* [PATCH net-next v7 1/3] net: ethernet: mtk_eth_soc: fix the RX
2026-11-17 19:55 [PATCH net-next v7 0/3] net: ethernet: mtk_eth_soc: 9K jumbo frame support Sandeep Haemoon
@ 2026-11-13 22:34 ` Sandeep Haemoon
2026-11-21 20:21 ` netdev-bot+sashiko
2026-11-13 22:34 ` [PATCH net-next v7 2/3] net: ethernet: mtk_eth_soc: skip page_pool Sandeep Haemoon
` (2 subsequent siblings)
3 siblings, 1 reply; 8+ messages in thread
From: Sandeep Haemoon @ 2026-11-13 22:34 UTC (permalink / raw)
To: netdev
Cc: Felix Fietkau, Lorenzo Bianconi, Andrew Lunn, David S. Miller,
Eric Dumazet, Jakub Kicinski, Paolo Abeni, Matthias Brugger,
AngeloGioacchino Del Regno, Russell King, Daniel Golle,
Mason Chang, Frank Wunderlich, linux-mediatek, linux-arm-kernel,
linux-kernel
mtk_poll_rx() keeps one dma_addr_t across the whole poll loop and only
refreshes it when a replacement buffer was mapped for the descriptor
being processed. The paths that jump straight to release_desc (no
netdev for the source port, MTK_RESETTING set, or a refill allocation
failure) re-arm the descriptor with the buffer it still holds. The
address written back must therefore come from the descriptor's own
rxd2, and the release path relies on dma_addr being DMA_MAPPING_ERROR
to select those bits.
The declaration was moved to function scope and initialised to
DMA_MAPPING_ERROR by commit e10a35abb3da ("net: ethernet: mtk_eth_soc:
fix uninitialized variable"), which also added the first check for
that sentinel on the release path. The check was later replaced with
the FIELD_GET(rxd2) fallback below by commit 6e0490fc36cd ("net:
ethernet: mtk_eth_soc: fix SER panic with 4GB+ RAM"). Because the
sentinel is only still true before the first mapping, that fallback
has only ever been taken for the first descriptor of a poll. From the
second iteration on, the previous descriptor's high address bits are
combined with the current descriptor's low bits in rxd1. With
MTK_36BIT_DMA and DRAM above 4 GiB the hardware then DMAs the next
frame to an address that is neither buffer, and the driver passes the
stale contents of the untouched buffer up the stack. mtk_rx_clean()
unmaps the same mismatched address during a SER, which is the panic
that commit was fixing.
Reset dma_addr to DMA_MAPPING_ERROR at the start of every iteration,
so a descriptor that is released without a new mapping keeps its own
address bits.
This change depends on the FIELD_GET(rxd2) fallback, so that commit or
its stable backport has to be present: on a tree without it the
release path would clear the high bits instead of preserving them.
Fixes: 2d75891ebc09 ("net: ethernet: mtk_eth_soc: support 36-bit DMA addressing on MT7988")
Signed-off-by: Sandeep Haemoon <sandeeph@loljews.com>
---
drivers/net/ethernet/mediatek/mtk_eth_soc.c | 8 +++++++-
1 file changed, 7 insertions(+), 1 deletion(-)
diff --git a/drivers/net/ethernet/mediatek/mtk_eth_soc.c b/drivers/net/ethernet/mediatek/mtk_eth_soc.c
index 21abeccfe0..6c8b039fad 100644
--- a/drivers/net/ethernet/mediatek/mtk_eth_soc.c
+++ b/drivers/net/ethernet/mediatek/mtk_eth_soc.c
@@ -2210,7 +2210,7 @@ static int mtk_poll_rx(struct napi_struct *napi, int budget,
u8 *data, *new_data;
struct mtk_rx_dma_v2 *rxd, trxd;
int done = 0, bytes = 0;
- dma_addr_t dma_addr = DMA_MAPPING_ERROR;
+ dma_addr_t dma_addr;
int ppe_idx = 0;
while (done < budget) {
@@ -2219,6 +2219,12 @@ static int mtk_poll_rx(struct napi_struct *napi, int budget,
u32 hash, reason;
int mac = 0;
+ /* The release paths below hand the descriptor back with the
+ * buffer it still holds, so only overwrite its address when
+ * a new buffer was actually mapped for it.
+ */
+ dma_addr = DMA_MAPPING_ERROR;
+
ring = mtk_get_rx_ring(eth);
if (unlikely(!ring))
goto rx_done;
--
2.53.0
^ permalink raw reply related [flat|nested] 8+ messages in thread
* [PATCH net-next v7 2/3] net: ethernet: mtk_eth_soc: skip page_pool
2026-11-17 19:55 [PATCH net-next v7 0/3] net: ethernet: mtk_eth_soc: 9K jumbo frame support Sandeep Haemoon
2026-11-13 22:34 ` [PATCH net-next v7 1/3] net: ethernet: mtk_eth_soc: fix the RX Sandeep Haemoon
@ 2026-11-13 22:34 ` Sandeep Haemoon
2026-11-21 20:22 ` netdev-bot+sashiko
2026-11-13 22:40 ` [PATCH net-next v7 3/3] net: ethernet: mtk_eth_soc: add 9K jumbo Sandeep Haemoon
2026-11-17 19:57 ` [PATCH net-next v7 0/3] net: ethernet: mtk_eth_soc: 9K jumbo frame support netdev-bot+sinfo
3 siblings, 1 reply; 8+ messages in thread
From: Sandeep Haemoon @ 2026-11-13 22:34 UTC (permalink / raw)
To: netdev
Cc: Felix Fietkau, Lorenzo Bianconi, Andrew Lunn, David S. Miller,
Eric Dumazet, Jakub Kicinski, Paolo Abeni, Matthias Brugger,
AngeloGioacchino Del Regno, Russell King, Daniel Golle,
Mason Chang, Frank Wunderlich, linux-mediatek, linux-arm-kernel,
linux-kernel
The page_pool is created with order-0 pages and MTK_PP_MAX_BUF_SIZE as
the maximum DMA length, so it can only back a ring whose descriptor
length fits in that.
Gate the pool on ring->buf_size <= MTK_PP_MAX_BUF_SIZE and let larger
rings use the netdev_alloc_frag()/mtk_max_lro_buf_alloc() path that already
exists. ring->frag_size cannot serve as the limit: it follows the
netdev_alloc_frag() layout, whose headroom and skb_shared_info footprint
differ from the pool's, so a ring can have frag_size <= PAGE_SIZE while
its descriptor length is already larger than the pool can map.
With the current MTU limits every ring fits and the gate always passes;
it becomes active with the 9K jumbo support that follows, when the
shared rings grow past the limit.
Link: https://github.com/mediatek/mtk-openwrt-feeds
Reviewed-by: Simon Horman <horms@kernel.org>
Signed-off-by: Sandeep Haemoon <sandeeph@loljews.com>
---
drivers/net/ethernet/mediatek/mtk_eth_soc.c | 8 +++++++-
1 file changed, 7 insertions(+), 1 deletion(-)
diff --git a/drivers/net/ethernet/mediatek/mtk_eth_soc.c b/drivers/net/ethernet/mediatek/mtk_eth_soc.c
index 6c8b039fad..b3a6e57035 100644
--- a/drivers/net/ethernet/mediatek/mtk_eth_soc.c
+++ b/drivers/net/ethernet/mediatek/mtk_eth_soc.c
@@ -2824,7 +2824,13 @@ static int mtk_rx_alloc(struct mtk_eth *eth, int ring_no, int rx_flag)
if (!ring->data)
return -ENOMEM;
- if (mtk_page_pool_enabled(eth)) {
+ /* A page_pool hands out order-0 pages and is created with
+ * MTK_PP_MAX_BUF_SIZE, so it can only back a ring whose descriptor
+ * length fits. Larger rings use the netdev_alloc_frag()/
+ * mtk_max_lro_buf_alloc() path below instead.
+ */
+ if (mtk_page_pool_enabled(eth) &&
+ ring->buf_size <= MTK_PP_MAX_BUF_SIZE) {
struct page_pool *pp;
pp = mtk_create_page_pool(eth, &ring->xdp_q, ring_no,
--
2.53.0
^ permalink raw reply related [flat|nested] 8+ messages in thread
* [PATCH net-next v7 3/3] net: ethernet: mtk_eth_soc: add 9K jumbo
2026-11-17 19:55 [PATCH net-next v7 0/3] net: ethernet: mtk_eth_soc: 9K jumbo frame support Sandeep Haemoon
2026-11-13 22:34 ` [PATCH net-next v7 1/3] net: ethernet: mtk_eth_soc: fix the RX Sandeep Haemoon
2026-11-13 22:34 ` [PATCH net-next v7 2/3] net: ethernet: mtk_eth_soc: skip page_pool Sandeep Haemoon
@ 2026-11-13 22:40 ` Sandeep Haemoon
2026-11-21 20:22 ` netdev-bot+sashiko
2026-11-17 19:57 ` [PATCH net-next v7 0/3] net: ethernet: mtk_eth_soc: 9K jumbo frame support netdev-bot+sinfo
3 siblings, 1 reply; 8+ messages in thread
From: Sandeep Haemoon @ 2026-11-13 22:40 UTC (permalink / raw)
To: netdev
Cc: Felix Fietkau, Lorenzo Bianconi, Andrew Lunn, David S. Miller,
Eric Dumazet, Jakub Kicinski, Paolo Abeni, Matthias Brugger,
AngeloGioacchino Del Regno, Russell King, Daniel Golle,
Mason Chang, Frank Wunderlich, linux-mediatek, linux-arm-kernel,
linux-kernel
The driver caps max_mtu at 2030 bytes and programs the MAC max-rx
field for at most 2048-byte frames, so MTU > 2K is rejected and 9K
jumbo frames are not usable on the 10G XGMII MACs.
Add a MTK_NETSYS_RX_9K capability for MT7988 and:
- advertise a 9194-byte max_mtu on the XGMII MACs, from the DT
phy_mode at probe time, so DSA can raise the conduit MTU before the
netdev is opened. The four bytes below the 9216-byte MAC and ring
cap keep room for the 802.1Q tag of a maximum-size frame;
- derive the shared RX buffer length from the largest MTU of any MAC,
with the 802.1Q headroom added before the 1 KiB round-up and a 2K
minimum, and size the RX rings from it. The QDMA RX ring is never
polled or refilled by the CPU, so it keeps its 2K buffers;
- program the PDMA RX SDL max-frame field from that length on netsys
v3+. The field is written the way the MediaTek downstream driver
does, frame length offset by MTK_PDMA_LRO_SDL in GENMASK(30, 16);
the encoding is not publicly documented, and without this new write
the DMA engine keeps its small reset default (~1518 bytes) and
drops larger frames on the wire, so a datasheet confirmation of the
layout would be welcome;
- program XMAC_RX_CFG2 from the same length on the XGMII MACs, keeping
the bits outside the length field, so 802.1Q-tagged frames fit at
any MTU. GMAC1 (the built-in switch port, phy-mode internal) keeps
its MCR programming instead: the XMAC register is not used for it,
and the MCR max-rx field gets the jumbo field (bits 31:28, in
1024-byte units, the encoding of the MediaTek downstream driver),
so the same shared length can be programmed for GMAC1 as for the
XGMII MACs. The write runs after the XGMII setup of
mtk_mac_config(), whose MAC_MCR_FORCE_LINK_DOWN write is a
full-register write that would otherwise reset the field to the
1518 bucket. Whether the internal switch path enforces the MCR
field for switch-side frames at all is a hardware property: the
downstream reference programs no limit for GMAC1 and jumbo frames
pass the switch on the reference hardware, which suggests the field
is not enforced there;
- rewrite the MAC limits on every successful mtk_mac_config() and on
every mtk_hw_init() call on the SoCs with the capability, so no MAC
accepts a frame the rings cannot hold, not even after a reopen with
a smaller MTU. The other SoCs keep their per-device limits: they
never grow their rings, and their MCR programming is left exactly
as before this patch;
- reject a runtime MTU change that would need larger buffers while
DMA is running (-EBUSY). Shrinking is allowed: the rings keep the
buffers they already have. The rings are shared by every MAC, so
raising a DSA user port MTU on a live system fails while any MAC is
up; the runtime reallocation that lifts this is a separate series.
XDP runs only on rings that have a page_pool, and the pool cannot back
buffers larger than MTK_PP_MAX_BUF_SIZE, so an MTU that needs a larger
buffer cannot be combined with XDP; attaching a program is rejected in
that case. The check uses eth->rx_buf_len, the length the live rings
were actually built with; when the rings are not live, or the attach
itself tears them down, the next open re-derives the length from the
current MTUs and that value is checked instead. A program can
therefore never attach and silently not run, and an attach on a
closed device is never rejected over a stale ring length. Detaching
is always allowed: it does not need a page_pool.
With the 1 KiB rounding, the buffer length is order-1 (8 KiB) for
rx_buf_len 4096..7168 (MTU about 3051..7146) and order-2 (16 KiB)
from rx_buf_len 8192 (MTU 7147) up: once any MAC's MTU reaches 7147,
every RX buffer is a 16 KiB compound page, which pins 2048 x 16 KiB
(about 32 MiB) in the single CPU-polled ring on MT7988 while DMA is up
and turns the refill into a high-order GFP_ATOMIC allocation.
skb->truesize reports the size that was actually allocated for those
buffers, not the smaller frag_size. That correction also covers the
HW-LRO rings on mt2701, mt7622, mt7623 and mt7629, whose ~12.4 KiB
buffers now report 16 KiB.
This is a forward-port of the MediaTek downstream jumbo work: Mason
Chang's "change default rx buffer length" and "add 9k jumbo frame
support" (MediaTek OpenWrt feed 999-eth-30/31, carried in
frank-w/BPI-Router-Linux), plus Frank Wunderlich's "try to fix crash
the right way". The runtime reallocation of Mason's "dynamic rx
buffer adjustment" (feed 999-eth-33) is not included; it will be sent
separately.
Link: https://github.com/frank-w/BPI-Router-Linux/commit/b4c6cb1d5532
Link: https://github.com/mediatek/mtk-openwrt-feeds
Signed-off-by: Sandeep Haemoon <sandeeph@loljews.com>
---
drivers/net/ethernet/mediatek/mtk_eth_soc.c | 328 ++++++++++++++++----
drivers/net/ethernet/mediatek/mtk_eth_soc.h | 16 +-
2 files changed, 288 insertions(+), 56 deletions(-)
diff --git a/drivers/net/ethernet/mediatek/mtk_eth_soc.c b/drivers/net/ethernet/mediatek/mtk_eth_soc.c
index b3a6e57035..0a87b94e8c 100644
--- a/drivers/net/ethernet/mediatek/mtk_eth_soc.c
+++ b/drivers/net/ethernet/mediatek/mtk_eth_soc.c
@@ -170,6 +170,7 @@ static const struct mtk_reg_map mt7988_reg_map = {
.pcrx_ptr = 0x6908,
.glo_cfg = 0x6a04,
.rst_idx = 0x6a08,
+ .rx_cfg = 0x6a10,
.delay_irq = 0x6a0c,
.irq_status = 0x6a20,
.irq_mask = 0x6a28,
@@ -554,6 +555,62 @@ static int mtk_mac_prepare(struct phylink_config *config, unsigned int mode,
return 0;
}
+/* The MACs are fed from the shared RX rings, so the maximum frame they may
+ * accept is a property of the ring buffer length. GMAC1 on netsys v3+ is
+ * the built-in switch port: it has no XMAC_RX_CFG2 limit register, so it
+ * keeps the MCR programming the other SoCs use, extended with the MCR
+ * jumbo field so its limit can grow with the rings like the XGMII MACs'.
+ */
+static void mtk_set_mcr_max_rx(struct mtk_mac *mac, u32 val)
+{
+ struct mtk_eth *eth = mac->hw;
+ u32 mcr_cur, mcr_new;
+
+ if (MTK_HAS_CAPS(eth->soc->caps, MTK_SOC_MT7628))
+ return;
+
+ if (!mtk_interface_mode_is_xgmii(eth, mac->interface) ||
+ mac->id == MTK_GMAC1_ID) {
+ mcr_cur = mtk_r32(mac->hw, MTK_MAC_MCR(mac->id));
+ mcr_new = mcr_cur & ~MAC_MCR_MAX_RX_MASK;
+
+ if (val <= 1518)
+ mcr_new |= MAC_MCR_MAX_RX(MAC_MCR_MAX_RX_1518);
+ else if (val <= 1536)
+ mcr_new |= MAC_MCR_MAX_RX(MAC_MCR_MAX_RX_1536);
+ else if (val <= 1552)
+ mcr_new |= MAC_MCR_MAX_RX(MAC_MCR_MAX_RX_1552);
+ else
+ mcr_new |= MAC_MCR_MAX_RX(MAC_MCR_MAX_RX_2048);
+
+ /* The bucket encodes at most 2048; the SoCs with the 9K
+ * capability need the jumbo field, in 1024-byte units, for
+ * anything larger. Clearing it together with the bucket
+ * keeps a later MTU shrink from leaving a stale larger
+ * limit behind.
+ */
+ if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_RX_9K)) {
+ u32 jumbo = DIV_ROUND_UP(val, MTK_MAX_RX_LENGTH_UNIT);
+
+ mcr_new &= ~MAC_MCR_MAX_RX_JUMBO_MASK;
+
+ if (val > 1552)
+ mcr_new |= MAC_MCR_MAX_RX_JUMBO(jumbo);
+ }
+
+ if (mcr_new != mcr_cur)
+ mtk_w32(mac->hw, mcr_new, MTK_MAC_MCR(mac->id));
+ } else {
+ mcr_cur = mtk_r32(mac->hw, MTK_XMAC_RX_CFG2(mac->id));
+ mcr_new = mcr_cur & ~MTK_XMAC_MAX_RX_MASK;
+ mcr_new |= FIELD_PREP(MTK_XMAC_MAX_RX_MASK,
+ min_t(u32, val, MTK_MAX_RX_LENGTH_9K));
+
+ if (mcr_new != mcr_cur)
+ mtk_w32(mac->hw, mcr_new, MTK_XMAC_RX_CFG2(mac->id));
+ }
+}
+
static void mtk_mac_config(struct phylink_config *config, unsigned int mode,
const struct phylink_link_state *state)
{
@@ -678,6 +735,18 @@ static void mtk_mac_config(struct phylink_config *config, unsigned int mode,
mtk_setup_bridge_switch(eth);
}
+ /* On the SoCs with the 9K capability the rings grow with the MTU, so
+ * rewrite the MAC limit on every successful mac_config, not only
+ * when the interface mode changes: a reopen after an MTU change
+ * must narrow the MACs that still carry the previous, larger
+ * limit. This must run after the XGMII setup above: its
+ * MAC_MCR_FORCE_LINK_DOWN write is a full-register write that
+ * would otherwise reset GMAC1's max-rx field (its limit lives in
+ * the MCR register, not in XMAC_RX_CFG2) back to the 1518 bucket.
+ */
+ if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_RX_9K))
+ mtk_set_mcr_max_rx(mac, eth->rx_buf_len);
+
return;
err_phy:
@@ -1239,29 +1308,40 @@ static void mtk_get_stats64(struct net_device *dev,
storage->tx_errors = dev->stats.tx_errors;
storage->rx_dropped = dev->stats.rx_dropped;
+ storage->rx_length_errors += dev->stats.rx_length_errors;
storage->tx_dropped = dev->stats.tx_dropped;
}
-static inline int mtk_max_frag_size(int mtu)
+static inline int mtk_max_frag_size(u32 rx_buf_len, int mtu)
{
- /* make sure buf_size will be at least MTK_MAX_RX_LENGTH */
- if (mtu + MTK_RX_ETH_HLEN < MTK_MAX_RX_LENGTH_2K)
- mtu = MTK_MAX_RX_LENGTH_2K - MTK_RX_ETH_HLEN;
+ /* make sure buf_size will be at least the rx buffer length */
+ if (mtu + MTK_RX_ETH_HLEN < rx_buf_len)
+ mtu = rx_buf_len - MTK_RX_ETH_HLEN;
return SKB_DATA_ALIGN(MTK_RX_HLEN + mtu) +
SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
}
-static inline int mtk_max_buf_size(int frag_size)
+static inline int mtk_max_buf_size(u32 rx_buf_len, int frag_size)
{
int buf_size = frag_size - NET_SKB_PAD - NET_IP_ALIGN -
SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
- WARN_ON(buf_size < MTK_MAX_RX_LENGTH_2K);
+ WARN_ON(buf_size < rx_buf_len);
return buf_size;
}
+/* The descriptor length a normal RX ring gets for a given shared buffer
+ * length. The page_pool gate in mtk_rx_alloc() uses the same value, so the
+ * XDP admission checks test exactly what the pool can back.
+ */
+static inline u32 mtk_rx_ring_buf_size(u32 rx_buf_len)
+{
+ return mtk_max_buf_size(rx_buf_len,
+ mtk_max_frag_size(rx_buf_len, ETH_DATA_LEN));
+}
+
static bool mtk_rx_get_desc(struct mtk_eth *eth, struct mtk_rx_dma_v2 *rxd,
struct mtk_rx_dma_v2 *dma_rxd)
{
@@ -1280,9 +1360,17 @@ static bool mtk_rx_get_desc(struct mtk_eth *eth, struct mtk_rx_dma_v2 *rxd,
return true;
}
-static void *mtk_max_lro_buf_alloc(gfp_t gfp_mask)
+/* mtk_max_buf_alloc() rounds the buffer up to a whole page order, so
+ * report the size it actually allocated, not the smaller frag_size, in
+ * skb->truesize.
+ */
+static unsigned int mtk_buf_alloc_size(unsigned int size)
+{
+ return PAGE_SIZE << get_order(size);
+}
+
+static void *mtk_max_buf_alloc(unsigned int size, gfp_t gfp_mask)
{
- unsigned int size = mtk_max_frag_size(MTK_MAX_LRO_RX_LENGTH);
unsigned long data;
data = __get_free_pages(gfp_mask | __GFP_COMP | __GFP_NOWARN,
@@ -2268,6 +2356,15 @@ static int mtk_poll_rx(struct napi_struct *napi, int budget,
pktlen = RX_DMA_GET_PLEN0(trxd.rxd2);
+ /* The engine can report a length larger than the posted
+ * buffer; never pass the unwritten remainder of the buffer
+ * up the stack.
+ */
+ if (unlikely(pktlen > ring->buf_size)) {
+ netdev->stats.rx_length_errors++;
+ goto release_desc;
+ }
+
/* alloc new buffer */
if (ring->page_pool) {
struct page *page = virt_to_head_page(data);
@@ -2313,10 +2410,15 @@ static int mtk_poll_rx(struct napi_struct *napi, int budget,
skb_metadata_set(skb, metasize);
skb_mark_for_recycle(skb);
} else {
+ unsigned int alloc_size = ring->frag_size > PAGE_SIZE ?
+ mtk_buf_alloc_size(ring->frag_size) :
+ ring->frag_size;
+
if (ring->frag_size <= PAGE_SIZE)
new_data = napi_alloc_frag(ring->frag_size);
else
- new_data = mtk_max_lro_buf_alloc(GFP_ATOMIC);
+ new_data = mtk_max_buf_alloc(ring->frag_size,
+ GFP_ATOMIC);
if (unlikely(!new_data)) {
netdev->stats.rx_dropped++;
@@ -2339,7 +2441,7 @@ static int mtk_poll_rx(struct napi_struct *napi, int budget,
dma_unmap_single(eth->dma_dev, ((u64)trxd.rxd1 | addr64),
ring->buf_size, DMA_FROM_DEVICE);
- skb = build_skb(data, ring->frag_size);
+ skb = build_skb(data, alloc_size);
if (unlikely(!skb)) {
netdev->stats.rx_dropped++;
skb_free_frag(data);
@@ -2800,6 +2902,7 @@ static int mtk_rx_alloc(struct mtk_eth *eth, int ring_no, int rx_flag)
const struct mtk_soc_data *soc = eth->soc;
struct mtk_rx_ring *ring;
int rx_data_len, rx_dma_size;
+ u32 buf_len;
int i;
if (rx_flag == MTK_RX_FLAGS_QDMA) {
@@ -2818,8 +2921,19 @@ static int mtk_rx_alloc(struct mtk_eth *eth, int ring_no, int rx_flag)
rx_dma_size = soc->rx.dma_size;
}
- ring->frag_size = mtk_max_frag_size(rx_data_len);
- ring->buf_size = mtk_max_buf_size(ring->frag_size);
+ /* The QDMA RX ring is only ever scratch memory for the engine: the
+ * CPU neither polls nor refills it, so it keeps its 2K buffers
+ * even when the polled rings grow.
+ */
+ if (rx_flag == MTK_RX_FLAGS_QDMA)
+ buf_len = MTK_MAX_RX_LENGTH_2K;
+ else if (rx_flag == MTK_RX_FLAGS_HWLRO)
+ buf_len = max_t(u32, eth->rx_buf_len, MTK_MAX_LRO_RX_LENGTH);
+ else
+ buf_len = eth->rx_buf_len;
+
+ ring->frag_size = mtk_max_frag_size(buf_len, rx_data_len);
+ ring->buf_size = mtk_max_buf_size(buf_len, ring->frag_size);
ring->data = kzalloc_objs(*ring->data, rx_dma_size);
if (!ring->data)
return -ENOMEM;
@@ -2863,7 +2977,8 @@ static int mtk_rx_alloc(struct mtk_eth *eth, int ring_no, int rx_flag)
if (ring->frag_size <= PAGE_SIZE)
data = netdev_alloc_frag(ring->frag_size);
else
- data = mtk_max_lro_buf_alloc(GFP_KERNEL);
+ data = mtk_max_buf_alloc(ring->frag_size,
+ GFP_KERNEL);
if (!data)
return -ENOMEM;
@@ -3259,6 +3374,67 @@ static int mtk_dma_busy_wait(struct mtk_eth *eth)
return ret;
}
+static int mtk_max_gmac_mtu(struct mtk_eth *eth)
+{
+ int i, max_mtu = ETH_DATA_LEN;
+
+ for (i = 0; i < ARRAY_SIZE(eth->netdev); i++)
+ if (eth->netdev[i] && eth->netdev[i]->mtu > max_mtu)
+ max_mtu = eth->netdev[i]->mtu;
+
+ return max_mtu;
+}
+
+static u32 mtk_rx_buf_len_from_mtu(struct mtk_eth *eth, int max_mtu)
+{
+ int length;
+
+ /* Only the SoCs with the 9K capability grow the shared rings with
+ * the MTU. Everywhere else the buffers stay at 2K, so the largest
+ * MTU those SoCs advertise keeps working at runtime and the -EBUSY
+ * rule below never applies to them.
+ */
+ if (!MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_RX_9K))
+ return MTK_MAX_RX_LENGTH_2K;
+
+ length = max_mtu + MTK_RX_ETH_HLEN + VLAN_HLEN;
+ if (length <= MTK_MAX_RX_LENGTH_2K)
+ return MTK_MAX_RX_LENGTH_2K;
+
+ return DIV_ROUND_UP(length, 1024) * 1024;
+}
+
+/* The rx rings are shared by every MAC, so their buffers are sized for
+ * the largest MTU configured on any of them.
+ */
+static u32 mtk_rx_buf_len(struct mtk_eth *eth)
+{
+ return mtk_rx_buf_len_from_mtu(eth, mtk_max_gmac_mtu(eth));
+}
+
+/* Program the PDMA RX max-frame (SDL) field from the shared RX buffer
+ * length. The field only exists on netsys v3+ and is programmed the way
+ * the MediaTek downstream driver does: frame length offset by
+ * MTK_PDMA_LRO_SDL in GENMASK(30, 16). The encoding is the vendor's and
+ * not publicly documented; without the write the DMA engine keeps its
+ * small reset default (~1518 bytes) and drops larger frames on the wire,
+ * so a datasheet confirmation of the layout would be welcome.
+ */
+static void mtk_pdma_set_sdl(struct mtk_eth *eth)
+{
+ const struct mtk_reg_map *reg_map = eth->soc->reg_map;
+ u32 val;
+
+ if (!mtk_is_netsys_v3_or_greater(eth))
+ return;
+
+ val = mtk_r32(eth, reg_map->pdma.rx_cfg);
+ val &= ~MTK_RX_CFG_SDL_MASK;
+ val |= FIELD_PREP(MTK_RX_CFG_SDL_MASK,
+ MTK_PDMA_LRO_SDL + eth->rx_buf_len);
+ mtk_w32(eth, val, reg_map->pdma.rx_cfg);
+}
+
static int mtk_dma_init(struct mtk_eth *eth)
{
int err;
@@ -3267,6 +3443,14 @@ static int mtk_dma_init(struct mtk_eth *eth)
if (mtk_dma_busy_wait(eth))
return -EBUSY;
+ /* Derived here, at ring allocation, so eth->rx_buf_len always
+ * describes the buffers the rings actually hold; mtk_change_mtu()
+ * updates it while DMA is down so it describes the rings-to-be,
+ * and mtk_mac_config() then never lets a MAC accept a frame the
+ * rings cannot take.
+ */
+ eth->rx_buf_len = mtk_rx_buf_len(eth);
+
if (MTK_HAS_CAPS(eth->soc->caps, MTK_QDMA)) {
/* QDMA needs scratch memory for internal reordering of the
* descriptors
@@ -3310,6 +3494,8 @@ static int mtk_dma_init(struct mtk_eth *eth)
mtk_w32(eth, 0x0, eth->soc->reg_map->qdma.hred);
}
+ mtk_pdma_set_sdl(eth);
+
return 0;
}
@@ -3600,17 +3786,6 @@ static int mtk_device_event(struct notifier_block *n, unsigned long event, void
return NOTIFY_DONE;
}
-static int mtk_max_gmac_mtu(struct mtk_eth *eth)
-{
- int i, max_mtu = ETH_DATA_LEN;
-
- for (i = 0; i < ARRAY_SIZE(eth->netdev); i++)
- if (eth->netdev[i] && eth->netdev[i]->mtu > max_mtu)
- max_mtu = eth->netdev[i]->mtu;
-
- return max_mtu;
-}
-
static int mtk_open(struct net_device *dev)
{
struct mtk_mac *mac = netdev_priv(dev);
@@ -3780,6 +3955,7 @@ static int mtk_xdp_setup(struct net_device *dev, struct bpf_prog *prog,
struct mtk_mac *mac = netdev_priv(dev);
struct mtk_eth *eth = mac->hw;
struct bpf_prog *old_prog;
+ u32 rx_buf_len;
bool need_update;
if (eth->hwlro) {
@@ -3787,12 +3963,28 @@ static int mtk_xdp_setup(struct net_device *dev, struct bpf_prog *prog,
return -EOPNOTSUPP;
}
- if (dev->mtu > MTK_PP_MAX_BUF_SIZE) {
+ need_update = !!eth->prog != !!prog;
+
+ /* XDP only runs on rings that have a page_pool, and the pool is
+ * only created when the shared RX buffer length fits
+ * MTK_PP_MAX_BUF_SIZE. eth->rx_buf_len describes the live rings;
+ * when the rings are not live, or this attach tears them down,
+ * the next open re-derives it from the current MTUs, so check
+ * that value instead. A detach never needs a pool, so it is not
+ * checked at all.
+ */
+ rx_buf_len = eth->rx_buf_len;
+ if (prog &&
+ (!refcount_read(ð->dma_refcnt) ||
+ (netif_running(dev) && need_update &&
+ refcount_read(ð->dma_refcnt) == 1)))
+ rx_buf_len = mtk_rx_buf_len(eth);
+
+ if (prog && mtk_rx_ring_buf_size(rx_buf_len) > MTK_PP_MAX_BUF_SIZE) {
NL_SET_ERR_MSG_MOD(extack, "MTU too large for XDP");
return -EOPNOTSUPP;
}
- need_update = !!eth->prog != !!prog;
if (netif_running(dev) && need_update)
mtk_stop(dev);
@@ -3927,30 +4119,6 @@ static void mtk_dim_tx(struct work_struct *work)
dim->state = DIM_START_MEASURE;
}
-static void mtk_set_mcr_max_rx(struct mtk_mac *mac, u32 val)
-{
- struct mtk_eth *eth = mac->hw;
- u32 mcr_cur, mcr_new;
-
- if (MTK_HAS_CAPS(eth->soc->caps, MTK_SOC_MT7628))
- return;
-
- mcr_cur = mtk_r32(mac->hw, MTK_MAC_MCR(mac->id));
- mcr_new = mcr_cur & ~MAC_MCR_MAX_RX_MASK;
-
- if (val <= 1518)
- mcr_new |= MAC_MCR_MAX_RX(MAC_MCR_MAX_RX_1518);
- else if (val <= 1536)
- mcr_new |= MAC_MCR_MAX_RX(MAC_MCR_MAX_RX_1536);
- else if (val <= 1552)
- mcr_new |= MAC_MCR_MAX_RX(MAC_MCR_MAX_RX_1552);
- else
- mcr_new |= MAC_MCR_MAX_RX(MAC_MCR_MAX_RX_2048);
-
- if (mcr_new != mcr_cur)
- mtk_w32(mac->hw, mcr_new, MTK_MAC_MCR(mac->id));
-}
-
static void mtk_hw_reset(struct mtk_eth *eth)
{
u32 val;
@@ -4218,8 +4386,11 @@ static int mtk_hw_init(struct mtk_eth *eth, bool reset)
continue;
mtk_w32(eth, MAC_MCR_FORCE_LINK_DOWN, MTK_MAC_MCR(i));
- mtk_set_mcr_max_rx(netdev_priv(dev),
- dev->mtu + MTK_RX_ETH_HLEN);
+ if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_RX_9K))
+ mtk_set_mcr_max_rx(netdev_priv(dev), eth->rx_buf_len);
+ else
+ mtk_set_mcr_max_rx(netdev_priv(dev),
+ dev->mtu + MTK_RX_ETH_HLEN);
}
/* Indicates CDM to parse the MTK special tag from CPU
@@ -4360,21 +4531,59 @@ static int mtk_change_mtu(struct net_device *dev, int new_mtu)
int length = new_mtu + MTK_RX_ETH_HLEN;
struct mtk_mac *mac = netdev_priv(dev);
struct mtk_eth *eth = mac->hw;
+ u32 rx_buf_len;
+ bool running;
int max_mtu, i;
+ /* The RX rings are shared by every MAC, so the buffer length
+ * follows the largest MTU of all of them, the new one included.
+ */
+ max_mtu = new_mtu;
+ for (i = 0; i < MTK_MAX_DEVS; i++) {
+ if (eth->netdev[i] && eth->netdev[i] != dev &&
+ eth->netdev[i]->mtu > max_mtu)
+ max_mtu = eth->netdev[i]->mtu;
+ }
+ rx_buf_len = mtk_rx_buf_len_from_mtu(eth, max_mtu);
+
if (rcu_access_pointer(eth->prog) &&
- length > MTK_PP_MAX_BUF_SIZE) {
+ mtk_rx_ring_buf_size(rx_buf_len) > MTK_PP_MAX_BUF_SIZE) {
netdev_err(dev, "Invalid MTU for XDP mode\n");
return -EINVAL;
}
- mtk_set_mcr_max_rx(mac, length);
+ /* The rings cannot be resized in place while DMA is running: a
+ * larger buffer can only come from the reallocation at the next
+ * open, so reject it. A smaller one is fine, the buffers the
+ * rings already hold are big enough for it.
+ */
+ running = refcount_read(ð->dma_refcnt);
+ if (running && rx_buf_len > eth->rx_buf_len)
+ return -EBUSY;
+
+ /* On the SoCs whose rings grow with the MTU, keep the MAC limit in
+ * step with the shared buffers; the other SoCs keep the per-device
+ * limit they always had.
+ */
+ if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_RX_9K))
+ mtk_set_mcr_max_rx(mac, rx_buf_len);
+ else
+ mtk_set_mcr_max_rx(mac, length);
+
WRITE_ONCE(dev->mtu, new_mtu);
max_mtu = mtk_max_gmac_mtu(eth);
for (i = 0; i < ARRAY_SIZE(eth->ppe); i++)
mtk_ppe_update_mtu(eth->ppe[i], max_mtu);
+ /* While DMA is up the rings keep the buffers they were built
+ * with; update eth->rx_buf_len only when DMA is down so it keeps
+ * describing the buffers the rings hold, or will hold at the next
+ * open.
+ */
+ if (!running)
+ eth->rx_buf_len = rx_buf_len;
+
return 0;
}
@@ -5018,8 +5227,17 @@ static int mtk_add_mac(struct mtk_eth *eth, struct device_node *np)
eth->netdev[id]->irq = eth->irq[MTK_FE_IRQ_SHARED];
eth->netdev[id]->dev.of_node = np;
+ /* DSA sets the conduit MTU (user MTU + tag) before the netdev is
+ * opened, so max_mtu must already be final here. Deriving it only
+ * in mtk_open() leaves the conduit at its 1504 default and blocks
+ * 9K frames on the DSA user ports.
+ */
if (MTK_HAS_CAPS(eth->soc->caps, MTK_SOC_MT7628))
eth->netdev[id]->max_mtu = MTK_MAX_RX_LENGTH - MTK_RX_ETH_HLEN;
+ else if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_RX_9K) &&
+ mtk_interface_mode_is_xgmii(eth, phy_mode))
+ eth->netdev[id]->max_mtu =
+ MTK_MAX_RX_LENGTH_9K - MTK_RX_ETH_HLEN - VLAN_HLEN;
else
eth->netdev[id]->max_mtu = MTK_MAX_RX_LENGTH_2K - MTK_RX_ETH_HLEN;
@@ -5160,6 +5378,8 @@ static int mtk_probe(struct platform_device *pdev)
spin_lock_init(ð->rx_irq_lock);
spin_lock_init(ð->dim_lock);
+ eth->rx_buf_len = MTK_MAX_RX_LENGTH_2K;
+
eth->rx_dim.mode = DIM_CQ_PERIOD_MODE_START_FROM_EQE;
INIT_WORK(ð->rx_dim.work, mtk_dim_rx);
INIT_DELAYED_WORK(ð->reset.monitor_work, mtk_hw_reset_monitor_work);
diff --git a/drivers/net/ethernet/mediatek/mtk_eth_soc.h b/drivers/net/ethernet/mediatek/mtk_eth_soc.h
index 88a9b3b23b..4b4a544612 100644
--- a/drivers/net/ethernet/mediatek/mtk_eth_soc.h
+++ b/drivers/net/ethernet/mediatek/mtk_eth_soc.h
@@ -28,7 +28,9 @@
#define MTK_QDMA_NUM_QUEUES 16
#define MTK_QDMA_PAGE_SIZE 2048
#define MTK_MAX_RX_LENGTH 1536
+#define MTK_MAX_RX_LENGTH_UNIT 1024
#define MTK_MAX_RX_LENGTH_2K 2048
+#define MTK_MAX_RX_LENGTH_9K 9216
#define MTK_TX_DMA_BUF_LEN 0x3fff
#define MTK_TX_DMA_BUF_LEN_V2 0xffff
#define MTK_QDMA_RING_SIZE 2048
@@ -198,9 +200,10 @@
#define MTK_MULTI_EN BIT(10)
#define MTK_PDMA_SIZE_8DWORDS (1 << 4)
-/* PDMA Global Configuration Register */
+/* PDMA RX Configuration Register */
#define MTK_PDMA_LRO_SDL 0x3000
#define MTK_RX_CFG_SDL_OFFSET 16
+#define MTK_RX_CFG_SDL_MASK GENMASK(30, MTK_RX_CFG_SDL_OFFSET)
/* PDMA Reset Index Register */
#define MTK_PST_DRX_IDX0 BIT(16)
@@ -451,6 +454,9 @@
/* Mac control registers */
#define MTK_MAC_MCR(x) (0x10100 + (x * 0x100))
+#define MAC_MCR_MAX_RX_JUMBO_MASK GENMASK(31, 28)
+#define MAC_MCR_MAX_RX_JUMBO(x) \
+ FIELD_PREP(MAC_MCR_MAX_RX_JUMBO_MASK, (x))
#define MAC_MCR_MAX_RX_MASK GENMASK(25, 24)
#define MAC_MCR_MAX_RX(_x) (MAC_MCR_MAX_RX_MASK & ((_x) << 24))
#define MAC_MCR_MAX_RX_1518 0x0
@@ -530,6 +536,8 @@
/* XFI Mac control registers */
#define MTK_XMAC_BASE(x) (0x12000 + (((x) - 1) * 0x1000))
#define MTK_XMAC_MCR(x) (MTK_XMAC_BASE(x))
+#define MTK_XMAC_RX_CFG2(x) (MTK_XMAC_MCR(x) + 0xd0)
+#define MTK_XMAC_MAX_RX_MASK GENMASK(13, 0)
#define XMAC_MCR_TRX_DISABLE 0xf
#define XMAC_MCR_FORCE_TX_FC BIT(5)
#define XMAC_MCR_FORCE_RX_FC BIT(4)
@@ -985,6 +993,7 @@ enum mkt_eth_capabilities {
MTK_INFRA_BIT,
MTK_SHARED_SGMII_BIT,
MTK_HWLRO_BIT,
+ MTK_NETSYS_RX_9K_BIT,
MTK_SHARED_INT_BIT,
MTK_TRGMII_MT7621_CLK_BIT,
MTK_QDMA_BIT,
@@ -1026,6 +1035,7 @@ enum mkt_eth_capabilities {
#define MTK_INFRA BIT_ULL(MTK_INFRA_BIT)
#define MTK_SHARED_SGMII BIT_ULL(MTK_SHARED_SGMII_BIT)
#define MTK_HWLRO BIT_ULL(MTK_HWLRO_BIT)
+#define MTK_NETSYS_RX_9K BIT_ULL(MTK_NETSYS_RX_9K_BIT)
#define MTK_SHARED_INT BIT_ULL(MTK_SHARED_INT_BIT)
#define MTK_TRGMII_MT7621_CLK BIT_ULL(MTK_TRGMII_MT7621_CLK_BIT)
#define MTK_QDMA BIT_ULL(MTK_QDMA_BIT)
@@ -1127,7 +1137,7 @@ enum mkt_eth_capabilities {
#define MT7988_CAPS (MTK_36BIT_DMA | MTK_GDM1_ESW | MTK_GMAC2_2P5GPHY | \
MTK_MUX_GMAC2_TO_2P5GPHY | MTK_QDMA | MTK_RSTCTRL_PPE1 | \
- MTK_RSTCTRL_PPE2 | MTK_SRAM)
+ MTK_RSTCTRL_PPE2 | MTK_SRAM | MTK_NETSYS_RX_9K)
struct mtk_tx_dma_desc_info {
dma_addr_t addr;
@@ -1150,6 +1160,7 @@ struct mtk_reg_map {
u32 pcrx_ptr; /* rx cpu pointer */
u32 glo_cfg; /* global configuration */
u32 rst_idx; /* reset index */
+ u32 rx_cfg; /* rx dma configuration */
u32 delay_irq; /* delay interrupt */
u32 irq_status; /* interrupt status */
u32 irq_mask; /* interrupt mask */
@@ -1314,6 +1325,7 @@ struct mtk_eth {
struct mtk_tx_ring tx_ring;
struct mtk_rx_ring rx_ring[MTK_MAX_RX_RING_NUM];
struct mtk_rx_ring rx_ring_qdma;
+ u32 rx_buf_len;
struct napi_struct tx_napi;
struct napi_struct rx_napi;
void *scratch_ring;
--
2.53.0
^ permalink raw reply related [flat|nested] 8+ messages in thread
* [PATCH net-next v7 0/3] net: ethernet: mtk_eth_soc: 9K jumbo frame support
@ 2026-11-17 19:55 Sandeep Haemoon
2026-11-13 22:34 ` [PATCH net-next v7 1/3] net: ethernet: mtk_eth_soc: fix the RX Sandeep Haemoon
` (3 more replies)
0 siblings, 4 replies; 8+ messages in thread
From: Sandeep Haemoon @ 2026-11-17 19:55 UTC (permalink / raw)
To: netdev
Cc: Felix Fietkau, Lorenzo Bianconi, Andrew Lunn, David S. Miller,
Eric Dumazet, Jakub Kicinski, Paolo Abeni, Matthias Brugger,
AngeloGioacchino Del Regno, Russell King, Daniel Golle,
Mason Chang, Frank Wunderlich, linux-mediatek, linux-arm-kernel,
linux-kernel
This series makes the MediaTek SoC ethernet driver support 9K jumbo
frames on the 10G XGMII MACs (MT7988). The driver advertises a
2030-byte max_mtu and programs the MAC max-rx field for at most 2048
bytes, so MTU > 2K is rejected and 9K frames are not usable.
Patch 1 fixes a pre-existing 36-bit DMA bug in mtk_poll_rx() that the
review of v3 found: a descriptor released without a new mapping is
handed back with the previous buffer's high address bits. It is
independent of the rest of the series and carries a Fixes: tag for the
commit that introduced the bug, so the maintainers can route it to
net directly if they prefer.
Patch 2 gates the page_pool on the ring's descriptor length: the pool
hands out order-0 pages and maps at most MTK_PP_MAX_BUF_SIZE, so a
ring whose descriptor length is larger has to use the
netdev_alloc_frag()/mtk_max_buf_alloc() path.
Patch 3 adds the MTK_NETSYS_RX_9K capability, advertises a 9194-byte
max_mtu on the XGMII MACs (from the DT phy_mode at probe, so DSA can
raise the conduit MTU before the netdev is opened), programs
XMAC_RX_CFG2 and the PDMA RX SDL, derives the shared RX buffer length
from the largest MTU (802.1Q headroom included) and sizes the RX rings
from it, keeping the never-polled QDMA ring at its 2K buffers. The
MAC max-rx limits stay in sync with that shared length, including
GMAC1's MCR jumbo field. A runtime MTU change that needs larger
buffers is rejected with -EBUSY while DMA is running; shrinking is
allowed. GMAC1, the built-in switch port, keeps its MCR programming
(bucket plus the jumbo field in 1024-byte units), written after the
MAC_MCR_FORCE_LINK_DOWN reset so it survives every mac_config();
whether the internal switch path enforces that field at all is a
hardware property the commit message documents.
This work is a forward-port of the MediaTek downstream jumbo work:
Mason Chang's "change default rx buffer length" and "add 9k jumbo
frame support" (MediaTek OpenWrt feed 999-eth-30/31, carried in
frank-w/BPI-Router-Linux), plus Frank Wunderlich's "try to fix crash
the right way". The runtime reallocation of Mason's "dynamic rx
buffer adjustment" (feed 999-eth-33) is not included and will be sent
separately. Attribution is prose plus Link: tags: Co-developed-by
requires the original authors' own Signed-off-by lines, which we do
not have, and the port diverges from the downstream implementation
(2K buffer floor, per-ring pool gate, the -EBUSY rule, the XDP checks
and the truesize fix are not in the downstream patches).
The equivalent change was tested on a BPI-R4 Pro 8X (MT7988, 10G
lan6 / MxL86252) on the 6.18.60 backport: with both ends at MTU 9000,
8K ICMP passes and iperf3 with MSS 8900 reaches ~9.87 Gbit/s (vs
~2.57 Gbit/s at MSS 1460); the DSA conduit is raised to 9004 at boot.
This v7.3 series is compile-tested with CONFIG_NET_MEDIATEK_SOC=y and
COMPILE_TEST=y; no hardware run of this exact tree yet.
With the 1 KiB rounding the RX buffer length is order-1 (8 KiB) for
rx_buf_len 4096..7168 and order-2 (16 KiB) from rx_buf_len 8192 up;
at the 9K ring size the 16 KiB buffers pin around 64 MiB while DMA is
up and make the refill a high-order GFP_ATOMIC allocation. That cost
is inherent to the downstream design; skb->truesize now reports the
allocation that was actually made.
Changes in v7:
- respin reason: patchwork registered the v6 posting as superseded by the
v5 posting that went out ten minutes before it, so the series that
actually applies was hidden behind one that does not. This repost
restores a sane version order; the content below also folds in the v6
review.
- only the SoCs with MTK_NETSYS_RX_9K grow the shared RX rings with the
MTU. Everywhere else the buffers stay at 2K, so the 2030-byte maximum
those SoCs advertise keeps working at runtime and the -EBUSY rule no
longer applies to them.
- the XDP admission checks now test the same descriptor length the
page_pool gate uses, instead of the raw buffer length.
- mtk_get_stats64() adds the software rx_length_errors counter, so the
new over-long descriptor drop is visible in the exported statistics.
- 2/3 names mtk_max_lro_buf_alloc(), the allocator that exists at that
commit.
- 1/3 gives the commits in the right order and states that the change
depends on 6e0490fc36cd; the 3/3 message uses the real 32 MiB figure
for the single polled ring.
Changes in v6:
- rebase onto current net-next (a76e8bf4be) so the series applies
again: net-next converted mtk_rx_alloc() to kzalloc_objs(), which
the hunk context depended on. No functional change.
Changes in v5 (the v4 review, in full):
- 802.1Q headroom (Medium): the shared RX buffer length now includes
VLAN_HLEN before the 1 KiB round-up, and the advertised max_mtu is
lowered by the same four bytes to 9194, so a tagged maximum-size
frame (9194 + 18 + 4) still fits in rx_buf_len 9216 and the XMAC
9216 cap. XMAC_RX_CFG2 and the ring buffers therefore cover a
tagged frame at every MTU, including the maximum.
- GMAC1 MCR jumbo field (Medium): the vendor driver has a second MCR
max-rx field we had not ported. mtk_set_mcr_max_rx() now clears
and programs the jumbo field (bits 31:28, 1024-byte units,
MAC_MCR_MAX_RX_JUMBO) for GMAC1, so the driver can program the same
shared length for the switch port as for the XGMII MACs. The new
field handling is limited to the MTK_NETSYS_RX_9K SoCs; every other
SoC keeps its previous MCR programming bit for bit.
- QDMA ring sizing (Medium): the helpers now take the buffer length
instead of struct mtk_eth, and mtk_rx_alloc() sizes the
never-polled QDMA RX ring at the fixed 2K length instead of the
jumbo length, so it no longer pins ~32 MiB of high-order pages.
HW-LRO rings keep their 12288-byte sizing.
- pktlen bound (Medium): mtk_poll_rx() drops descriptors whose PLEN0
exceeds ring->buf_size, with rx_length_errors, before the buffer
can be passed up, so the larger build_skb() size can no longer hand
stale memory to the stack if the engine over-reports the length.
- PDMA SDL encoding (Medium): kept as in v4; the comment and commit
message now say explicitly that the GENMASK(30,16) encoding (frame
length offset by MTK_PDMA_LRO_SDL) is the vendor's and not publicly
documented, and that a datasheet confirmation would be welcome.
- XDP detach (Medium): the pool-size check now runs only when a
program is attached, so a detach always succeeds. The shared
eth->prog weakness the review also points out is pre-existing and
is left to a separate fix.
- 3/3 message (Low): the buffer-size math is corrected (order-1 for
rx_buf_len 4096..7168, order-2 from 8192) and the message now says
that the build_skb()/truesize change also covers the HW-LRO rings
on mt2701, mt7622, mt7623 and mt7629.
- 1/3 subject and message (Low): retitled to describe the fix ("fix
the RX descriptor address on the release path") and the message now
cites 6e0490fc36cd and e10a35abb3da, which moved the
DMA_MAPPING_ERROR initialisation out of the loop and made the first
commit's protection ineffective after the first iteration.
The pre-existing High finding of the review (a failure while filling
an RX ring leaks the partially filled buffers and DMA mappings
because ring->dma_size is still 0) is not part of this series: it is
in the untouched v7.3 code and will be sent as a separate fix that
sets ring->dma_size before the fill loop.
Simon Horman's Reviewed-by is kept on patch 2 only: patches 1 and 3
are new or changed materially since his review of v1.
Previous versions:
https://lore.kernel.org/all/patch-9e765e74d06edbba3fd85a0cd49c4bb5@loljews.com/ (v6)
https://lore.kernel.org/all/patch-f1e62a87eb0f914e1ea52a395f465998@loljews.com/ (v5)
https://lore.kernel.org/all/patch-fc08a7ef40667bf3017366e452e6d3c0@loljews.com/ (v4)
https://lore.kernel.org/all/patch-aad4cfa8d9522d1f7dbc9893ea12e813@loljews.com/ (v3)
https://lore.kernel.org/all/patch-2793186c653124c4c0b3d463bde2ea3a@loljews.com/ (v2)
https://lore.kernel.org/all/patch-4f863a941889f0bceca1c082f2d79624@loljews.com/ (v1)
Sandeep Haemoon (3):
net: ethernet: mtk_eth_soc: fix the RX descriptor address on the
release path
net: ethernet: mtk_eth_soc: skip page_pool for RX rings whose buffers
do not fit
net: ethernet: mtk_eth_soc: add 9K jumbo frame support
drivers/net/ethernet/mediatek/mtk_eth_soc.c | 344 ++++++++++++++++----
drivers/net/ethernet/mediatek/mtk_eth_soc.h | 16 +-
2 files changed, 302 insertions(+), 58 deletions(-)
base-commit: a76e8bf4be552eed20801186188e5606365870a0
--
2.53.0
^ permalink raw reply [flat|nested] 8+ messages in thread
* Re: [PATCH net-next v7 0/3] net: ethernet: mtk_eth_soc: 9K jumbo frame support
2026-11-17 19:55 [PATCH net-next v7 0/3] net: ethernet: mtk_eth_soc: 9K jumbo frame support Sandeep Haemoon
` (2 preceding siblings ...)
2026-11-13 22:40 ` [PATCH net-next v7 3/3] net: ethernet: mtk_eth_soc: add 9K jumbo Sandeep Haemoon
@ 2026-11-17 19:57 ` netdev-bot+sinfo
3 siblings, 0 replies; 8+ messages in thread
From: netdev-bot+sinfo @ 2026-11-17 19:57 UTC (permalink / raw)
To: Sandeep Haemoon
Cc: netdev, Felix Fietkau, Lorenzo Bianconi, Andrew Lunn,
David S. Miller, Eric Dumazet, Jakub Kicinski, Paolo Abeni,
Matthias Brugger, AngeloGioacchino Del Regno, Russell King,
Daniel Golle, Mason Chang, Frank Wunderlich, linux-mediatek,
linux-arm-kernel, linux-kernel
Hi!
This is an automated message. This series looks like a fix, but its
commit messages seem to be missing some information:
- Whether the issue was actually triggered, or is only theoretical
(e.g. found by LLM and not proven at runtime). If it was triggered
please include the symptoms, like the stack trace or kernel messages.
Please do not repost the series just to address the above. Instead,
reply to this email with the missing information, so that reviewers
can take it into account.
*IMPORTANT*: If you do repost (for other reasons) - please include
the relevant info in the cover letter or commit messages.
--
The evaluation is done by an LLM so it may be wrong, if you think
that is the case please reply and explain.
^ permalink raw reply [flat|nested] 8+ messages in thread
* Re: [PATCH net-next v7 1/3] net: ethernet: mtk_eth_soc: fix the RX
2026-11-13 22:34 ` [PATCH net-next v7 1/3] net: ethernet: mtk_eth_soc: fix the RX Sandeep Haemoon
@ 2026-11-21 20:21 ` netdev-bot+sashiko
0 siblings, 0 replies; 8+ messages in thread
From: netdev-bot+sashiko @ 2026-11-21 20:21 UTC (permalink / raw)
To: sandeeph
Cc: netdev, nbd, lorenzo, andrew+netdev, davem, edumazet, kuba,
pabeni, matthias.bgg, angelogioacchino.delregno, linux, daniel,
mason-cw.chang, frank-w, linux-mediatek, linux-arm-kernel,
linux-kernel
Thank you for your contribution! Sashiko AI review found more severe
issue(s) in other patches of this series. This mail is only an FYI, in case
you want to address the nit picks below when you respin.
Low priority / nit picks for your consideration:
- [Low] The patch subject "net: ethernet: mtk_eth_soc: fix the RX" does
not say what is being fixed and reads like a cut-off sentence.
--
net: ethernet: mtk_eth_soc: fix the RX
This commit resets dma_addr to DMA_MAPPING_ERROR at the start of every
iteration of the mtk_poll_rx() loop. Before this change, a descriptor
that took the release_desc path without a new mapping could be re-armed
with high address bits left over from the previous descriptor. On
MTK_36BIT_DMA SoCs with DRAM above 4 GiB, the hardware would then DMA
to the wrong address.
> net: ethernet: mtk_eth_soc: fix the RX
[Severity: Low]
This isn't a bug, but the subject doesn't say what is being fixed. It
also reads like a sentence that was cut off.
The body describes a specific defect. In mtk_poll_rx(), dma_addr
carries over from the previous loop iteration. A descriptor can reach
release_desc without a new buffer being mapped:
- no netdev for the source port
- MTK_RESETTING is set
- the refill allocation or mapping fails
In those cases rxd2 gets the previous descriptor's high address bits,
while rxd1 still holds the current descriptor's low bits.
None of this shows up in the shortlog, and stable and patchwork tooling
rely on the shortlog. Could the subject be made more descriptive, for
example:
net: ethernet: mtk_eth_soc: reset RX dma_addr for every descriptor
--
Sashiko AI review · https://netdev-ai.bots.linux.dev/sashiko/#/patchset/patch-7d2c457e68de6b53b7348d1bdbeadcec%40loljews.com
^ permalink raw reply [flat|nested] 8+ messages in thread
* Re: [PATCH net-next v7 2/3] net: ethernet: mtk_eth_soc: skip page_pool
2026-11-13 22:34 ` [PATCH net-next v7 2/3] net: ethernet: mtk_eth_soc: skip page_pool Sandeep Haemoon
@ 2026-11-21 20:22 ` netdev-bot+sashiko
0 siblings, 0 replies; 8+ messages in thread
From: netdev-bot+sashiko @ 2026-11-21 20:22 UTC (permalink / raw)
To: sandeeph
Cc: netdev, nbd, lorenzo, andrew+netdev, davem, edumazet, kuba,
pabeni, matthias.bgg, angelogioacchino.delregno, linux, daniel,
mason-cw.chang, frank-w, linux-mediatek, linux-arm-kernel,
linux-kernel
Thank you for your contribution! Sashiko AI review found more severe
issue(s) in other patches of this series. This mail is only an FYI, in case
you want to address the nit picks below when you respin.
Low priority / nit picks for your consideration:
- [Low] The subject "net: ethernet: mtk_eth_soc: skip page_pool" leaves
out when the page_pool is skipped.
--
net: ethernet: mtk_eth_soc: skip page_pool
This commit adds a condition in mtk_rx_alloc() so that a page_pool is
only created for an RX ring whose ring->buf_size fits in
MTK_PP_MAX_BUF_SIZE. Larger rings fall back to the existing
netdev_alloc_frag()/mtk_max_lro_buf_alloc() path. With the current MTU
limits this condition always passes. It only takes effect once the
9K jumbo support that follows is applied.
Link: https://github.com/mediatek/mtk-openwrt-feeds
> net: ethernet: mtk_eth_soc: skip page_pool
[Severity: Low]
This isn't a bug, but could the subject say when the page_pool is
skipped?
Read on its own in the shortlog, or during stable/backport triage,
"skip page_pool" reads as if page_pool is being removed from the driver
entirely. The change in mtk_rx_alloc() is actually a per-ring check:
if (mtk_page_pool_enabled(eth) &&
ring->buf_size <= MTK_PP_MAX_BUF_SIZE) {
Something like "skip page_pool for RX rings larger than
MTK_PP_MAX_BUF_SIZE" would describe the change.
The earlier patch in the series, "net: ethernet: mtk_eth_soc: fix the
RX", also seems to have a subject that was cut short.
--
Sashiko AI review · https://netdev-ai.bots.linux.dev/sashiko/#/patchset/patch-7d2c457e68de6b53b7348d1bdbeadcec%40loljews.com
^ permalink raw reply [flat|nested] 8+ messages in thread
* Re: [PATCH net-next v7 3/3] net: ethernet: mtk_eth_soc: add 9K jumbo
2026-11-13 22:40 ` [PATCH net-next v7 3/3] net: ethernet: mtk_eth_soc: add 9K jumbo Sandeep Haemoon
@ 2026-11-21 20:22 ` netdev-bot+sashiko
0 siblings, 0 replies; 8+ messages in thread
From: netdev-bot+sashiko @ 2026-11-21 20:22 UTC (permalink / raw)
To: sandeeph
Cc: netdev, nbd, lorenzo, andrew+netdev, davem, edumazet, kuba,
pabeni, matthias.bgg, angelogioacchino.delregno, linux, daniel,
mason-cw.chang, frank-w, linux-mediatek, linux-arm-kernel,
linux-kernel
Thank you for your contribution! Sashiko AI review found 6 potential
issue(s) to consider.
Critical: 0 · High: 0 · 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).
- [Medium] mtk_pdma_set_sdl() programs the PDMA RX SDL field with
MTK_PDMA_LRO_SDL + eth->rx_buf_len, and the result is far above every…
- [Medium] On MT7988 (MTK_NETSYS_RX_9K), mtk_rx_buf_len_from_mtu() adds
VLAN_HLEN before comparing against the 2K floor.
- [Medium] The new XMAC_RX_CFG2 max-RX limit for the XGMII MACs
(GMAC2/GMAC3) may be undone by the XMAC logic reset.
- [Medium] net: mediatek: stale MAC max-rx limits after MTU shrink in
mtk_change_mtu()
- [Low] The patch adds an RX drop path on every SoC that the commit
message does not mention.
- [Low] This patch renames mtk_max_lro_buf_alloc() to
mtk_max_buf_alloc(size, gfp) and updates both call sites.
--
net: ethernet: mtk_eth_soc: add 9K jumbo
This commit adds an MTK_NETSYS_RX_9K capability for MT7988. With it the
XGMII MACs advertise a 9194 byte max_mtu, and the shared RX rings are
sized from the largest MTU of any MAC. The PDMA SDL, XMAC_RX_CFG2 and MCR
jumbo limits are programmed from that buffer length, and MTU growth is
rejected with -EBUSY while DMA is running.
Link: https://github.com/frank-w/BPI-Router-Linux/commit/b4c6cb1d5532
Link: https://github.com/mediatek/mtk-openwrt-feeds
> diff --git a/drivers/net/ethernet/mediatek/mtk_eth_soc.c b/drivers/net/ethernet/mediatek/mtk_eth_soc.c
> index b3a6e5703538e..0a87b94e8c103 100644
> --- a/drivers/net/ethernet/mediatek/mtk_eth_soc.c
> +++ b/drivers/net/ethernet/mediatek/mtk_eth_soc.c
[ ... ]
> @@ -554,6 +555,62 @@ static int mtk_mac_prepare(struct phylink_config *config, unsigned int mode,
> return 0;
> }
>
> +/* The MACs are fed from the shared RX rings, so the maximum frame they may
> + * accept is a property of the ring buffer length. GMAC1 on netsys v3+ is
> + * the built-in switch port: it has no XMAC_RX_CFG2 limit register, so it
> + * keeps the MCR programming the other SoCs use, extended with the MCR
> + * jumbo field so its limit can grow with the rings like the XGMII MACs'.
> + */
> +static void mtk_set_mcr_max_rx(struct mtk_mac *mac, u32 val)
> +{
[ ... ]
> + } else {
> + mcr_cur = mtk_r32(mac->hw, MTK_XMAC_RX_CFG2(mac->id));
> + mcr_new = mcr_cur & ~MTK_XMAC_MAX_RX_MASK;
> + mcr_new |= FIELD_PREP(MTK_XMAC_MAX_RX_MASK,
> + min_t(u32, val, MTK_MAX_RX_LENGTH_9K));
> +
> + if (mcr_new != mcr_cur)
> + mtk_w32(mac->hw, mcr_new, MTK_XMAC_RX_CFG2(mac->id));
> + }
> +}
[Severity: Medium]
Does this XMAC_RX_CFG2 limit survive link-up on GMAC2/GMAC3?
The value is written from mtk_mac_config(). phylink then calls
mac_link_up, and mtk_xgdm_mac_link_up() pulses the XMAC logic reset for
every non-GMAC1 XGMII MAC:
drivers/net/ethernet/mediatek/mtk_eth_soc.c:mtk_xgdm_mac_link_up() {
...
/* Eliminate the interference(before link-up) caused by PHY noise */
mtk_m32(mac->hw, XMAC_LOGIC_RST, 0, MTK_XMAC_LOGIC_RST(mac->id));
mdelay(20);
...
}
Nothing writes XMAC_RX_CFG2 again after that. The reset could clear the
XMAC RX configuration, or the hardware could ignore writes made while
the logic is held in reset before the first link-up. In either case,
would RX_CFG2 go back to its hardware default on every link-up, so the
10G ports silently drop jumbo frames?
The commit message describes jumbo testing only on the switch path, and
GMAC1 returns from mtk_xgdm_mac_link_up() before it reaches this reset.
Have jumbo frames been tested on the XGMII ports after a link flap?
[ ... ]
> @@ -2268,6 +2356,15 @@ static int mtk_poll_rx(struct napi_struct *napi, int budget,
>
> pktlen = RX_DMA_GET_PLEN0(trxd.rxd2);
>
> + /* The engine can report a length larger than the posted
> + * buffer; never pass the unwritten remainder of the buffer
> + * up the stack.
> + */
> + if (unlikely(pktlen > ring->buf_size)) {
> + netdev->stats.rx_length_errors++;
> + goto release_desc;
> + }
> +
[Severity: Low]
This check runs on every SoC, not only on the ones with
MTK_NETSYS_RX_9K, and it adds a new drop path counted in
rx_length_errors.
mtk_get_stats64() also now adds dev->stats.rx_length_errors to the
hardware short/long error sum, which changes the rx_length_errors value
userspace sees.
Before this patch such a frame would have reached skb_put() and hit
skb_over_panic(). Could the commit message mention this check and the
stats change? The list of changes does not cover either of them.
[ ... ]
> @@ -2863,7 +2977,8 @@ static int mtk_rx_alloc(struct mtk_eth *eth, int ring_no, int rx_flag)
> if (ring->frag_size <= PAGE_SIZE)
> data = netdev_alloc_frag(ring->frag_size);
> else
> - data = mtk_max_lro_buf_alloc(GFP_KERNEL);
> + data = mtk_max_buf_alloc(ring->frag_size,
> + GFP_KERNEL);
[Severity: Low]
This isn't a bug, but the page_pool gate comment earlier in mtk_rx_alloc()
still names the old helper:
* length fits. Larger rings use the netdev_alloc_frag()/
* mtk_max_lro_buf_alloc() path below instead.
Should it say mtk_max_buf_alloc() now? The fallback is no longer
LRO-only either, because it also backs the normal jumbo ring.
[ ... ]
> @@ -3259,6 +3374,67 @@ static int mtk_dma_busy_wait(struct mtk_eth *eth)
[ ... ]
> +static u32 mtk_rx_buf_len_from_mtu(struct mtk_eth *eth, int max_mtu)
> +{
> + int length;
> +
> + /* Only the SoCs with the 9K capability grow the shared rings with
> + * the MTU. Everywhere else the buffers stay at 2K, so the largest
> + * MTU those SoCs advertise keeps working at runtime and the -EBUSY
> + * rule below never applies to them.
> + */
> + if (!MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_RX_9K))
> + return MTK_MAX_RX_LENGTH_2K;
> +
> + length = max_mtu + MTK_RX_ETH_HLEN + VLAN_HLEN;
> + if (length <= MTK_MAX_RX_LENGTH_2K)
> + return MTK_MAX_RX_LENGTH_2K;
> +
> + return DIV_ROUND_UP(length, 1024) * 1024;
> +}
[Severity: Medium]
On MT7988, does adding VLAN_HLEN here break part of the advertised MTU
range at runtime? For a max MTU from 2027 to 2030:
2027 + 18 + 4 = 2049 -> DIV_ROUND_UP(2049, 1024) * 1024 = 3072
At the default MTU the rings are built with rx_buf_len 2048, so
mtk_change_mtu() then hits:
running = refcount_read(ð->dma_refcnt);
if (running && rx_buf_len > eth->rx_buf_len)
return -EBUSY;
mtk_add_mac() still sets max_mtu = MTK_MAX_RX_LENGTH_2K -
MTK_RX_ETH_HLEN (2030) on the non-XGMII MACs: SGMII/2500base-x GMAC2 and
GMAC3, and the internal 2.5G PHY GMAC2. As a result,
"ip link set <sgmii port> mtu 2030" on a running MT7988 now returns
-EBUSY. It is inside max_mtu, and it was accepted before this patch.
The same threshold hits DSA user ports on the GMAC1 conduit at user MTUs
2023 to 2026, because the conduit MTU is the user MTU + 4.
The comment above says the largest advertised MTU keeps working at
runtime, but that is only true on the non-9K SoCs. Should the non-XGMII
max_mtu on MT7988 lose VLAN_HLEN as well? Or should the 2K floor be
checked before the VLAN headroom is added?
[ ... ]
> +static void mtk_pdma_set_sdl(struct mtk_eth *eth)
> +{
> + const struct mtk_reg_map *reg_map = eth->soc->reg_map;
> + u32 val;
> +
> + if (!mtk_is_netsys_v3_or_greater(eth))
> + return;
> +
> + val = mtk_r32(eth, reg_map->pdma.rx_cfg);
> + val &= ~MTK_RX_CFG_SDL_MASK;
> + val |= FIELD_PREP(MTK_RX_CFG_SDL_MASK,
> + MTK_PDMA_LRO_SDL + eth->rx_buf_len);
> + mtk_w32(eth, val, reg_map->pdma.rx_cfg);
> +}
[Severity: Medium]
Can this set the PDMA RX length limit well above the buffers posted in
the ring?
MTK_PDMA_LRO_SDL is 0x3000, the same value as MTK_MAX_LRO_RX_LENGTH
(4096 * 3), which is the HW-LRO segment length. Elsewhere in the driver
the SDL field at bit 16 holds a plain byte length:
#define MTK_LRO_MIN_RXD_SDL (MTK_HW_LRO_SDL_REMAIN_ROOM << 16)
Read the same way, this write sets the limit to 0x3000 + 2048 = 14336
bytes with 2K rings and 0x3000 + 9216 = 21504 bytes with 9K rings. Both
are at least 12 KiB above ring->buf_size, the PLEN0 written into every
descriptor. Both are also above the 9216 cap this patch uses for
max_mtu, XMAC_RX_CFG2 and the MCR jumbo field.
The write runs on every MT7988 open, including at MTU 1500:
mtk_open()->mtk_start_dma()->mtk_dma_init()->mtk_pdma_set_sdl()
The commit message also says the GMAC1 MCR limit is probably not
enforced for switch-side frames. That would leave this field as the only
hardware length guard on the DSA conduit.
The new check in mtk_poll_rx() says "The engine can report a length
larger than the posted buffer". Suppose the engine applies this global
limit instead of the per-descriptor PLEN0. Could an oversized frame from
the wire then be written past the mapped buffer, into a neighbouring
frag or skb_shared_info? The pktlen check only runs after the DMA write
has happened.
If the engine splits the frame instead, mtk_poll_rx() has no
last-segment check. Would the tail of the frame then be parsed as a
separate frame?
The field could also be "flag bits | length", as in the vendor's 0x3000
+ 1536 case. Then the addition carries into bits 12-13 for any
rx_buf_len >= 4096 (0x3000 + 0x1000 = 0x4000, 0x3000 + 0x2400 = 0x5400).
Can that encoding represent the jumbo lengths at all?
[ ... ]
> @@ -4360,21 +4531,59 @@ static int mtk_change_mtu(struct net_device *dev, int new_mtu)
> int length = new_mtu + MTK_RX_ETH_HLEN;
> struct mtk_mac *mac = netdev_priv(dev);
> struct mtk_eth *eth = mac->hw;
> + u32 rx_buf_len;
> + bool running;
> int max_mtu, i;
>
> + /* The RX rings are shared by every MAC, so the buffer length
> + * follows the largest MTU of all of them, the new one included.
> + */
> + max_mtu = new_mtu;
> + for (i = 0; i < MTK_MAX_DEVS; i++) {
> + if (eth->netdev[i] && eth->netdev[i] != dev &&
> + eth->netdev[i]->mtu > max_mtu)
> + max_mtu = eth->netdev[i]->mtu;
> + }
> + rx_buf_len = mtk_rx_buf_len_from_mtu(eth, max_mtu);
> +
> if (rcu_access_pointer(eth->prog) &&
> - length > MTK_PP_MAX_BUF_SIZE) {
> + mtk_rx_ring_buf_size(rx_buf_len) > MTK_PP_MAX_BUF_SIZE) {
> netdev_err(dev, "Invalid MTU for XDP mode\n");
> return -EINVAL;
> }
>
> - mtk_set_mcr_max_rx(mac, length);
> + /* The rings cannot be resized in place while DMA is running: a
> + * larger buffer can only come from the reallocation at the next
> + * open, so reject it. A smaller one is fine, the buffers the
> + * rings already hold are big enough for it.
> + */
> + running = refcount_read(ð->dma_refcnt);
> + if (running && rx_buf_len > eth->rx_buf_len)
> + return -EBUSY;
> +
> + /* On the SoCs whose rings grow with the MTU, keep the MAC limit in
> + * step with the shared buffers; the other SoCs keep the per-device
> + * limit they always had.
> + */
> + if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_RX_9K))
> + mtk_set_mcr_max_rx(mac, rx_buf_len);
> + else
> + mtk_set_mcr_max_rx(mac, length);
> +
> WRITE_ONCE(dev->mtu, new_mtu);
>
> max_mtu = mtk_max_gmac_mtu(eth);
> for (i = 0; i < ARRAY_SIZE(eth->ppe); i++)
> mtk_ppe_update_mtu(eth->ppe[i], max_mtu);
>
> + /* While DMA is up the rings keep the buffers they were built
> + * with; update eth->rx_buf_len only when DMA is down so it keeps
> + * describing the buffers the rings hold, or will hold at the next
> + * open.
> + */
> + if (!running)
> + eth->rx_buf_len = rx_buf_len;
> +
> return 0;
> }
>
[Severity: Medium]
On the MTK_NETSYS_RX_9K SoCs the limit written here comes from the
shared rings, but only the MAC whose MTU is changing gets it. Can the
other MACs keep a limit larger than the buffers the rings end up
holding?
Take GMAC1 and GMAC2 both at MTU 9000 with DMA down. Lowering GMAC1
to 1500 keeps rx_buf_len at 9216 because of GMAC2, so GMAC1 is
programmed for 9216. Lowering GMAC2 to 1500 then drops
eth->rx_buf_len to 2048, but only GMAC2 is narrowed. GMAC1 keeps
9216 until mtk_mac_config() runs for it again.
That may never happen. Suppose only GMAC2 is reopened.
mtk_dma_init() builds 2048 byte rings, and mtk_open() calls
mtk_gdm_config() for every registered MAC. phylink_start(), though,
only reaches mtk_mac_config() for GMAC2.
GMAC1 is the switch conduit. Its link is forced up by
mtk_setup_bridge_switch() and, as far as I can see, stays up after
GMAC1 is closed. MTK_MAC_MCR(0) would then keep accepting 9216 byte
frames into 2048 byte buffers.
The same happens in this case:
- GMAC1 at 1500 and GMAC2 at 9000 are both open, so both get 9216;
- both are closed;
- GMAC2 is lowered to 1500;
- only GMAC2 is reopened.
The FE reset path has a similar gap after an MTU shrink while DMA is
running. eth->rx_buf_len is correctly left at the live value then.
However, mtk_stop() does not refresh it when dma_refcnt drops to
zero.
In mtk_pending_work(), mtk_hw_init(eth, true) then programs every MAC
from the stale 9216. Only after that does
mtk_open()->mtk_dma_init() derive 2048 and reallocate the rings. The
reopened MACs are narrowed again by mtk_mac_config(), but MACs that
were not running stay at 9216.
For GMAC2/GMAC3 there is also an ordering question. mac->interface is
PHY_INTERFACE_MODE_NA until the first mtk_mac_config(). A call from
mtk_hw_init() or mtk_change_mtu() before the first open therefore
takes the MCR branch of mtk_set_mcr_max_rx(). It writes the MCR jumbo
field of an XGMII MAC instead of XMAC_RX_CFG2. Is that intended?
The commit message says no MAC accepts a frame the rings cannot hold,
even after a reopen with a smaller MTU. These sequences seem to break
that.
Would it work better to have a helper that applies eth->rx_buf_len to
every MAC in eth->netdev[]? It could be called from mtk_change_mtu()
and again once mtk_dma_init() has derived the new length. Should the
reset path also derive the length before mtk_hw_init() runs?
--
Sashiko AI review · https://netdev-ai.bots.linux.dev/sashiko/#/patchset/patch-7d2c457e68de6b53b7348d1bdbeadcec%40loljews.com
^ permalink raw reply [flat|nested] 8+ messages in thread
end of thread, other threads:[~2026-11-21 20:22 UTC | newest]
Thread overview: 8+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2026-11-17 19:55 [PATCH net-next v7 0/3] net: ethernet: mtk_eth_soc: 9K jumbo frame support Sandeep Haemoon
2026-11-13 22:34 ` [PATCH net-next v7 1/3] net: ethernet: mtk_eth_soc: fix the RX Sandeep Haemoon
2026-11-21 20:21 ` netdev-bot+sashiko
2026-11-13 22:34 ` [PATCH net-next v7 2/3] net: ethernet: mtk_eth_soc: skip page_pool Sandeep Haemoon
2026-11-21 20:22 ` netdev-bot+sashiko
2026-11-13 22:40 ` [PATCH net-next v7 3/3] net: ethernet: mtk_eth_soc: add 9K jumbo Sandeep Haemoon
2026-11-21 20:22 ` netdev-bot+sashiko
2026-11-17 19:57 ` [PATCH net-next v7 0/3] net: ethernet: mtk_eth_soc: 9K jumbo frame support netdev-bot+sinfo
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox