* Re: (subset) [PATCH 05/10] leds: led-class: switch to using class_find_device_by_fwnode()
From: Lee Jones @ 2026-03-31 10:29 UTC (permalink / raw)
To: Andrew Lunn, David S. Miller, Eric Dumazet, Jakub Kicinski,
Paolo Abeni, Vinod Koul, Neil Armstrong, Mark Brown,
Liam Girdwood, Lee Jones, Pavel Machek, Peter Rosin, Andrew Lunn,
Heiner Kallweit, Russell King, Moritz Fischer, Xu Yilun, Tom Rix,
Greg Kroah-Hartman, Rafael J. Wysocki, Danilo Krummrich,
Dmitry Torokhov
Cc: netdev, linux-kernel, linux-phy, linux-spi, linux-leds,
linux-fpga, driver-core
In-Reply-To: <20260322-remove-device-find-by-of-node-v1-5-b72eb22a1215@gmail.com>
On Sun, 22 Mar 2026 18:54:23 -0700, Dmitry Torokhov wrote:
> In preparation to class_find_device_by_of_node() going away switch to
> using class_find_device_by_fwnode().
Applied, thanks!
[05/10] leds: led-class: switch to using class_find_device_by_fwnode()
commit: b6de441f8ce22e3ead3b858342fe5652598a3572
--
Lee Jones [李琼斯]
^ permalink raw reply
* Re: [PATCH net V2 0/2] Correct BD length masks and BQL accounting for multi-BD TX packets
From: patchwork-bot+netdevbpf @ 2026-03-31 10:20 UTC (permalink / raw)
To: Suraj Gupta
Cc: radhey.shyam.pandey, andrew+netdev, davem, edumazet, kuba, pabeni,
michal.simek, sean.anderson, daniel, ariane.keller, netdev,
linux-arm-kernel, linux-kernel
In-Reply-To: <20260327073238.134948-1-suraj.gupta2@amd.com>
Hello:
This series was applied to netdev/net.git (main)
by Paolo Abeni <pabeni@redhat.com>:
On Fri, 27 Mar 2026 13:02:36 +0530 you wrote:
> This patch series fixes two issues in the Xilinx AXI Ethernet driver:
> 1. Corrects the BD length masks to match the AXIDMA IP spec.
> 2. Fixes BQL accounting for multi-BD TX packets.
>
> ---
> Changes in V2:
> - Define BD length masks with GENMASK(25, 0) per PG021.
> - Credit BQL using skb->len on packet completion instead of summing
> per-BD actual lengths from descriptor status.
>
> [...]
Here is the summary with links:
- [net,V2,1/2] net: xilinx: axienet: Correct BD length masks to match AXIDMA IP spec
https://git.kernel.org/netdev/net/c/393e0b4f178e
- [net,V2,2/2] net: xilinx: axienet: Fix BQL accounting for multi-BD TX packets
https://git.kernel.org/netdev/net/c/d1978d03e867
You are awesome, thank you!
--
Deet-doot-dot, I am a bot.
https://korg.docs.kernel.org/patchwork/pwbot.html
^ permalink raw reply
* Re: [PATCH V3 1/3] net: stmmac: Fix PTP ref clock for Tegra234
From: Krzysztof Kozlowski @ 2026-03-31 10:18 UTC (permalink / raw)
To: Jon Hunter
Cc: Andrew Lunn, David S . Miller, Eric Dumazet, Jakub Kicinski,
Paolo Abeni, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
Thierry Reding, netdev, devicetree, linux-tegra
In-Reply-To: <01f56e6f-5459-4a96-9042-8a003a340fab@nvidia.com>
On 31/03/2026 12:14, Jon Hunter wrote:
>
> On 26/03/2026 08:32, Krzysztof Kozlowski wrote:
>
> ...
>
>>> @@ -257,9 +258,23 @@ static int tegra_mgbe_probe(struct platform_device *pdev)
>>> if (!mgbe->clks)
>>> return -ENOMEM;
>>>
>>> - for (i = 0; i < ARRAY_SIZE(mgbe_clks); i++)
>>> + /*
>>> + * Older device-trees use 'ptp-ref' rather than 'ptp_ref'.
>>> + * Fall back to the legacy name when 'ptp_ref' is absent.
>>> + */
>>> + use_legacy_ptp = of_property_match_string(pdev->dev.of_node,
>>> + "clock-names", "ptp_ref") < 0;
>>> +
>>> + for (i = 0; i < ARRAY_SIZE(mgbe_clks); i++) {
>>> mgbe->clks[i].id = mgbe_clks[i];
>>>
>>> + if (use_legacy_ptp && !strcmp(mgbe_clks[i], "ptp_ref")) {
>>
>> Why index 0 is not valid? And why -EINVAL would be considered as legacy
>> clock present?
>
> Index 0 is valid. However, yes I guess that treating an -EINVAL from
> of_property_match_string() is not correct. I will switch the logic to be ...
>
> use_legacy_ptp = of_property_match_string(pdev->dev.of_node,
> "clock-names", "ptp-ref") >= 0;
No, apologies, I think my comment was not correct and your reply made me
rethink. I missed final "< 0" in of_property_match_string().
So the code is good, you do not store index in 'use_legacy_ptp', but the
error return value.
Can you however make it more obvious code, so something like:
if (of_property_match_string...))
use_legacy_ptp = true;;
Best regards,
Krzysztof
^ permalink raw reply
* Re: [PATCH V3 1/3] net: stmmac: Fix PTP ref clock for Tegra234
From: Jon Hunter @ 2026-03-31 10:14 UTC (permalink / raw)
To: Krzysztof Kozlowski
Cc: Andrew Lunn, David S . Miller, Eric Dumazet, Jakub Kicinski,
Paolo Abeni, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
Thierry Reding, netdev, devicetree, linux-tegra
In-Reply-To: <20260326-gigantic-tentacled-hornet-cbdb8d@quoll>
On 26/03/2026 08:32, Krzysztof Kozlowski wrote:
...
>> @@ -257,9 +258,23 @@ static int tegra_mgbe_probe(struct platform_device *pdev)
>> if (!mgbe->clks)
>> return -ENOMEM;
>>
>> - for (i = 0; i < ARRAY_SIZE(mgbe_clks); i++)
>> + /*
>> + * Older device-trees use 'ptp-ref' rather than 'ptp_ref'.
>> + * Fall back to the legacy name when 'ptp_ref' is absent.
>> + */
>> + use_legacy_ptp = of_property_match_string(pdev->dev.of_node,
>> + "clock-names", "ptp_ref") < 0;
>> +
>> + for (i = 0; i < ARRAY_SIZE(mgbe_clks); i++) {
>> mgbe->clks[i].id = mgbe_clks[i];
>>
>> + if (use_legacy_ptp && !strcmp(mgbe_clks[i], "ptp_ref")) {
>
> Why index 0 is not valid? And why -EINVAL would be considered as legacy
> clock present?
Index 0 is valid. However, yes I guess that treating an -EINVAL from
of_property_match_string() is not correct. I will switch the logic to be ...
use_legacy_ptp = of_property_match_string(pdev->dev.of_node,
"clock-names", "ptp-ref") >= 0;
Jon
--
nvpublic
^ permalink raw reply
* Re: [PATCH] net: ns83820: check DMA mapping errors in hard_start_xmit
From: Paolo Abeni @ 2026-03-31 10:05 UTC (permalink / raw)
To: Wang Jun, kuba
Cc: andrew+netdev, davem, edumazet, simon.horman, netdev,
linux-kernel, gszhai, 25125332, 25125283, 23120469, stable
In-Reply-To: <tencent_5F1EACA5E1063E7E346A4138913F7486A009@qq.com>
On 3/27/26 2:16 AM, Wang Jun wrote:
> The ns83820 driver currently ignores the return values of dma_map_single()
> and skb_frag_dma_map() in the transmit path. If DMA mapping fails due to
> IOMMU exhaustion or SWIOTLB pressure, the driver may proceed with invalid
> DMA addresses, potentially causing hardware errors, data corruption, or
> system instability.
>
> Additionally, if mapping fails midway through processing fragmented
> packets,previously mapped DMA resources are not released, leading
> to DMA resource leaks.
>
> Fix this by:
> 1. Checking dma_mapping_error() after each DMA mapping call.
> 2. Implementing an error handling path to unmap successfully
> mapped buffers(both linear and fragments) using
> dma_unmap_single().
> 3. Freeing the skb using dev_kfree_skb_any() to safely handle
> both process and softirq contexts, as hard_start_xmit may be
> called with IRQs enabled.
> 4. Returning NETDEV_TX_OK to drop the packet gracefully and
> prevent TX queue stagnation.
>
> This ensures compliance with the DMA API guidelines and
> improves driver stability under memory pressure.
>
> Fixes: fd9e4d6fec15 ("natsemi: switch from 'pci_' to 'dma_' API")
The fix tag looks wrong, as the above just to mechanical substitution of
used APIs. The issue is pre-existent
> Cc: stable@vger.kernel.org
> Signed-off-by: Wang Jun <1742789905@qq.com>
> ---
> drivers/net/ethernet/natsemi/ns83820.c | 32 ++++++++++++++++++++++++++
> 1 file changed, 32 insertions(+)
>
> diff --git a/drivers/net/ethernet/natsemi/ns83820.c b/drivers/net/ethernet/natsemi/ns83820.c
> index cdbf82affa7b..90465e4977c3 100644
> --- a/drivers/net/ethernet/natsemi/ns83820.c
> +++ b/drivers/net/ethernet/natsemi/ns83820.c
> @@ -1051,6 +1051,12 @@ static netdev_tx_t ns83820_hard_start_xmit(struct sk_buff *skb,
> int stopped = 0;
> int do_intr = 0;
> volatile __le32 *first_desc;
> + dma_addr_t frag_dma_addr[MAX_SKB_FRAGS];
> + unsigned int frag_dma_len[MAX_SKB_FRAGS];
> + int frag_mapped_count = 0;
> + dma_addr_t main_buf = 0;
> + unsigned int main_len = 0;
> + int i;
Please respect the reverse christmas tree order above.
> dprintk("ns83820_hard_start_xmit\n");
>
> @@ -1121,6 +1127,13 @@ static netdev_tx_t ns83820_hard_start_xmit(struct sk_buff *skb,
> buf = dma_map_single(&dev->pci_dev->dev, skb->data, len,
> DMA_TO_DEVICE);
>
> + if (dma_mapping_error(&dev->pci_dev->dev, buf)) {
> + dev_kfree_skb_any(skb);
> + return NETDEV_TX_OK;
> + }
> + main_buf = buf;
> + main_len = len;
> +
> first_desc = dev->tx_descs + (free_idx * DESC_SIZE);
>
> for (;;) {
> @@ -1144,6 +1157,15 @@ static netdev_tx_t ns83820_hard_start_xmit(struct sk_buff *skb,
>
> buf = skb_frag_dma_map(&dev->pci_dev->dev, frag, 0,
> skb_frag_size(frag), DMA_TO_DEVICE);
> + if (dma_mapping_error(&dev->pci_dev->dev, buf))
> + goto dma_map_error;
> +
> + if (frag_mapped_count < MAX_SKB_FRAGS) {
> + frag_dma_addr[frag_mapped_count] = buf;
> + frag_dma_len[frag_mapped_count] = skb_frag_size(frag);
> + frag_mapped_count++;
> + }
> +
> dprintk("frag: buf=%08Lx page=%08lx offset=%08lx\n",
> (long long)buf, (long) page_to_pfn(frag->page),
> frag->page_offset);
> @@ -1166,6 +1188,16 @@ static netdev_tx_t ns83820_hard_start_xmit(struct sk_buff *skb,
> if (stopped && (dev->tx_done_idx != tx_done_idx) && start_tx_okay(dev))
> netif_start_queue(ndev);
>
> + return NETDEV_TX_OK;
> +dma_map_error:
> + dma_unmap_single(&dev->pci_dev->dev, main_buf, main_len, DMA_TO_DEVICE);
> + for (i = 0; i < frag_mapped_count; i++) {
> + dma_unmap_single(&dev->pci_dev->dev, frag_dma_addr[i], frag_dma_len[i],
> + DMA_TO_DEVICE);
> + }
> +
> + dev_kfree_skb_any(skb);
AI review says:
If nr_free < MIN_TX_DESC_FREE earlier in the function, netif_stop_queue
is called and the stopped flag is set to 1. By returning NETDEV_TX_OK
directly from the error path, we skip the race check at the end of the
normal
flow:
if (stopped && (dev->tx_done_idx != tx_done_idx) && start_tx_okay(dev))
netif_start_queue(ndev);
If all pending packets completed concurrently right before the queue was
stopped, could this cause the TX queue to stall indefinitely until the
tx watchdog fires?
^ permalink raw reply
* [PATCH net-next v3 13/13] net: renesas: rswitch: add vlan aware switching
From: Michael Dege @ 2026-03-31 10:04 UTC (permalink / raw)
To: Yoshihiro Shimoda, Andrew Lunn, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Niklas Söderlund, Paul Barker
Cc: netdev, linux-renesas-soc, linux-kernel, Michael Dege
In-Reply-To: <20260331-rswitch_add_vlans-v3-0-c37f41b1c556@renesas.com>
Add vlan support to L2 HW bridge.
On R-Car S4 there is limited vlan support, which is not fully
802.1Q compliant. The aim of this driver addition is to get as
close as possible to the correct behavior. Limitations are:
- all ports should be in the same default vlan
- default vlans are not stripped on egress.
Signed-off-by: Michael Dege <michael.dege@renesas.com>
---
drivers/net/ethernet/renesas/Kconfig | 1 +
drivers/net/ethernet/renesas/rswitch_l2.c | 408 ++++++++++++++++++++++++++----
2 files changed, 360 insertions(+), 49 deletions(-)
diff --git a/drivers/net/ethernet/renesas/Kconfig b/drivers/net/ethernet/renesas/Kconfig
index 9b7559c88bee..2494ff60e8c2 100644
--- a/drivers/net/ethernet/renesas/Kconfig
+++ b/drivers/net/ethernet/renesas/Kconfig
@@ -43,6 +43,7 @@ config RENESAS_ETHER_SWITCH
tristate "Renesas Ethernet Switch support"
depends on ARCH_RENESAS || COMPILE_TEST
depends on PTP_1588_CLOCK
+ depends on BRIDGE || BRIDGE=n
select CRC32
select MII
select PHYLINK
diff --git a/drivers/net/ethernet/renesas/rswitch_l2.c b/drivers/net/ethernet/renesas/rswitch_l2.c
index ea95a87ed234..b7d0e7f94ecd 100644
--- a/drivers/net/ethernet/renesas/rswitch_l2.c
+++ b/drivers/net/ethernet/renesas/rswitch_l2.c
@@ -7,6 +7,7 @@
#include <linux/err.h>
#include <linux/etherdevice.h>
#include <linux/if_bridge.h>
+#include <linux/if_vlan.h>
#include <linux/kernel.h>
#include <net/switchdev.h>
@@ -173,22 +174,6 @@ static void rswitch_port_update_brdev(struct net_device *ndev,
rswitch_update_offload_brdev(rdev->priv);
}
-static int rswitch_port_update_stp_state(struct net_device *ndev, u8 stp_state)
-{
- struct rswitch_device *rdev;
-
- if (!is_rdev(ndev))
- return -ENODEV;
-
- rdev = netdev_priv(ndev);
- rdev->learning_requested = (stp_state == BR_STATE_LEARNING ||
- stp_state == BR_STATE_FORWARDING);
- rdev->forwarding_requested = (stp_state == BR_STATE_FORWARDING);
- rswitch_update_l2_offload(rdev->priv);
-
- return 0;
-}
-
static int rswitch_netdevice_event(struct notifier_block *nb,
unsigned long event,
void *ptr)
@@ -212,61 +197,397 @@ static int rswitch_netdevice_event(struct notifier_block *nb,
return NOTIFY_OK;
}
-static int rswitch_update_ageing_time(struct net_device *ndev, clock_t time)
+static int rswitch_port_update_stp_state(struct net_device *ndev, u8 stp_state)
{
- struct rswitch_device *rdev = netdev_priv(ndev);
- u32 reg_val;
+ struct rswitch_device *rdev;
if (!is_rdev(ndev))
return -ENODEV;
+ rdev = netdev_priv(ndev);
+ rdev->learning_requested = (stp_state == BR_STATE_LEARNING ||
+ stp_state == BR_STATE_FORWARDING);
+ rdev->forwarding_requested = (stp_state == BR_STATE_FORWARDING);
+ rswitch_update_l2_offload(rdev->priv);
+
+ return 0;
+}
+
+static int rswitch_update_ageing_time(struct rswitch_private *priv, clock_t time)
+{
+ u32 reg_val;
+
if (!FIELD_FIT(FWMACAGC_MACAGT, time))
return -EINVAL;
reg_val = FIELD_PREP(FWMACAGC_MACAGT, time);
reg_val |= FWMACAGC_MACAGE | FWMACAGC_MACAGSL;
- iowrite32(reg_val, rdev->priv->addr + FWMACAGC);
+ iowrite32(reg_val, priv->addr + FWMACAGC);
return 0;
}
-static int rswitch_port_attr_set(struct net_device *ndev, const void *ctx,
- const struct switchdev_attr *attr,
- struct netlink_ext_ack *extack)
+static void rswitch_update_vlan_filtering(struct rswitch_private *priv,
+ bool vlan_filtering)
+{
+ if (vlan_filtering)
+ rswitch_modify(priv->addr, FWPC0(AGENT_INDEX_GWCA),
+ 0, FWPC0_VLANSA | FWPC0_VLANRU);
+ else
+ rswitch_modify(priv->addr, FWPC0(AGENT_INDEX_GWCA),
+ FWPC0_VLANSA | FWPC0_VLANRU, 0);
+}
+
+static int rswitch_handle_port_attr_set(struct net_device *ndev,
+ struct notifier_block *nb,
+ struct switchdev_notifier_port_attr_info *info)
{
+ const struct switchdev_attr *attr = info->attr;
+ struct rswitch_private *priv;
+ int err = 0;
+
+ priv = container_of(nb, struct rswitch_private, rswitch_switchdev_blocking_nb);
+
switch (attr->id) {
case SWITCHDEV_ATTR_ID_PORT_STP_STATE:
- return rswitch_port_update_stp_state(ndev, attr->u.stp_state);
+ err = rswitch_port_update_stp_state(ndev, attr->u.stp_state);
+
+ break;
case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME:
- return rswitch_update_ageing_time(ndev, attr->u.ageing_time);
+ err = rswitch_update_ageing_time(priv, attr->u.ageing_time);
+
+ break;
+ case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING:
+ rswitch_update_vlan_filtering(priv, attr->u.vlan_filtering);
+
+ break;
+ case SWITCHDEV_ATTR_ID_BRIDGE_MC_DISABLED:
+
+ break;
+ default:
+ return -EOPNOTSUPP;
+ }
+
+ if (err < 0)
+ return err;
+
+ info->handled = true;
+
+ return NOTIFY_DONE;
+}
+
+static int rswitch_read_vlan_table(struct rswitch_private *priv, u16 vid,
+ u32 *vlanslvs, u32 *vlandvs)
+{
+ int err;
+
+ iowrite32(FIELD_PREP(VLANVIDS, vid), priv->addr + FWVLANTS);
+ err = rswitch_reg_wait(priv->addr, FWVLANTSR0, VLANTS, 0);
+ if (err < 0)
+ return err;
+
+ /* check if vlans are present in table */
+ if (!(ioread32(priv->addr + FWVLANTSR0) & VLANSNF)) {
+ *vlanslvs = (ioread32(priv->addr + FWVLANTSR1) & VLANSLVS);
+ *vlandvs = (ioread32(priv->addr + FWVLANTSR3) & VLANDVS);
+ }
+
+ return 0;
+}
+
+static int rswitch_write_vlan_table(struct rswitch_private *priv, u16 vid, u32 index)
+{
+ u32 vlancsdl = priv->gwca.l2_shared_rx_queue->index;
+ u32 vlanslvs = 0, vlandvs = 0;
+ int err;
+
+ err = rswitch_read_vlan_table(priv, vid, &vlanslvs, &vlandvs);
+ if (err < 0)
+ return err;
+
+ rswitch_modify(priv->addr, FWVLANTL0, VLANED, 0);
+ iowrite32(FIELD_PREP(VLANVIDL, vid), priv->addr + FWVLANTL1);
+
+ vlanslvs |= BIT(index);
+ vlandvs |= BIT(index);
+ iowrite32(FIELD_PREP(VLANSLVL, vlanslvs), priv->addr + FWVLANTL2);
+ iowrite32(FIELD_PREP(VLANCSDL, vlancsdl), priv->addr + FWVLANTL3(GWCA_INDEX));
+ iowrite32(FIELD_PREP(VLANDVL, vlandvs), priv->addr + FWVLANTL4);
+
+ return rswitch_reg_wait(priv->addr, FWVLANTLR, VLANTL, 0);
+}
+
+static int rswitch_erase_vlan_table(struct rswitch_private *priv, u16 vid, u32 index)
+{
+ u32 vlanslvs = 0, vlandvs = 0;
+ int err;
+
+ err = rswitch_read_vlan_table(priv, vid, &vlanslvs, &vlandvs);
+ if (err < 0)
+ return err;
+
+ vlanslvs &= ~BIT(index);
+ vlandvs &= ~BIT(index);
+
+ /* only erase empty vlan table entries */
+ if (vlanslvs == 0)
+ rswitch_modify(priv->addr, FWVLANTL0, 0, VLANED);
+
+ iowrite32(FIELD_PREP(VLANVIDL, vid), priv->addr + FWVLANTL1);
+ iowrite32(FIELD_PREP(VLANSLVL, vlanslvs), priv->addr + FWVLANTL2);
+ iowrite32(FIELD_PREP(VLANDVL, vlandvs), priv->addr + FWVLANTL4);
+
+ return rswitch_reg_wait(priv->addr, FWVLANTLR, VLANTL, 0);
+}
+
+static int rswitch_port_set_vlan_tag(struct rswitch_etha *etha,
+ struct switchdev_obj_port_vlan *p_vlan,
+ bool delete)
+{
+ u32 vem_val;
+ int err;
+
+ err = rswitch_etha_change_mode(etha, EAMC_OPC_CONFIG);
+ if (err < 0)
+ return err;
+
+ rswitch_modify(etha->addr, EAVCC, VIM, 0);
+
+ if (((ioread32(etha->addr + EAVTC) & CTV) == p_vlan->vid) && delete) {
+ rswitch_modify(etha->addr, EAVTC, CTV, 0);
+ rswitch_modify(etha->addr, EAVCC, VEM, 0);
+ } else if (!delete) {
+ if ((p_vlan->flags & BRIDGE_VLAN_INFO_PVID) &&
+ (p_vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED))
+ vem_val = FIELD_PREP(VEM, C_TAG_VLAN);
+ else if (p_vlan->flags & BRIDGE_VLAN_INFO_PVID)
+ vem_val = FIELD_PREP(VEM, HW_C_TAG_VLAN);
+ else
+ vem_val = 0;
+ rswitch_modify(etha->addr, EAVCC, VEM, vem_val);
+ rswitch_modify(etha->addr, EAVTC, CTV, FIELD_PREP(CTV, p_vlan->vid));
+ }
+
+ return rswitch_etha_change_mode(etha, EAMC_OPC_OPERATION);
+}
+
+static int rswitch_gwca_set_vlan_tag(struct rswitch_private *priv,
+ struct switchdev_obj_port_vlan *p_vlan,
+ bool delete)
+{
+ u32 vem_val;
+ int err;
+
+ err = rswitch_gwca_change_mode(priv, GWMC_OPC_CONFIG);
+ if (err < 0)
+ return err;
+
+ rswitch_modify(priv->addr, GWVCC, VIM, 0);
+
+ if (((ioread32(priv->addr + GWVTC) & CTV) == p_vlan->vid) && delete) {
+ rswitch_modify(priv->addr, GWVTC, CTV, 0);
+ rswitch_modify(priv->addr, GWVCC, VEM, 0);
+ } else if (!delete) {
+ if ((p_vlan->flags & BRIDGE_VLAN_INFO_PVID) &&
+ (p_vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED))
+ vem_val = FIELD_PREP(VEM, C_TAG_VLAN);
+ else if (p_vlan->flags & BRIDGE_VLAN_INFO_PVID)
+ vem_val = FIELD_PREP(VEM, HW_C_TAG_VLAN);
+ else
+ vem_val = 0;
+ rswitch_modify(priv->addr, GWVCC, VEM, vem_val);
+ rswitch_modify(priv->addr, GWVTC, CTV, FIELD_PREP(CTV, p_vlan->vid));
+ }
+
+ return rswitch_gwca_change_mode(priv, GWMC_OPC_OPERATION);
+}
+
+static int rswitch_port_obj_do_add(struct net_device *ndev,
+ struct switchdev_obj_port_vlan *p_vlan)
+{
+ struct rswitch_device *rdev = netdev_priv(ndev);
+ struct rswitch_private *priv = rdev->priv;
+ struct rswitch_etha *etha = rdev->etha;
+ int err;
+
+ /* Set Rswitch VLAN mode */
+ iowrite32(br_vlan_enabled(rdev->brdev) ? FIELD_PREP(FWGC_SVM, C_TAG) : 0,
+ priv->addr + FWGC);
+
+ err = rswitch_write_vlan_table(priv, p_vlan->vid, etha->index);
+ if (err < 0)
+ return err;
+
+ /* If the default vlan for this port has been set, don't overwrite it. */
+ if (ioread32(etha->addr + EAVCC))
+ return NOTIFY_DONE;
+
+ if (br_vlan_enabled(rdev->brdev))
+ rswitch_modify(priv->addr, FWPC0(etha->index), 0, FWPC0_VLANSA | FWPC0_VLANRU);
+
+ rswitch_modify(priv->addr, FWPC2(AGENT_INDEX_GWCA),
+ FIELD_PREP(FWPC2_LTWFW, BIT(etha->index)),
+ 0);
+
+ return rswitch_port_set_vlan_tag(etha, p_vlan, false);
+}
+
+static int rswitch_port_obj_do_add_gwca(struct net_device *ndev,
+ struct rswitch_private *priv,
+ struct switchdev_obj_port_vlan *p_vlan)
+{
+ int err;
+
+ if (!(p_vlan->flags & BRIDGE_VLAN_INFO_BRENTRY))
+ return NOTIFY_DONE;
+
+ /* Set Rswitch VLAN mode */
+ iowrite32(br_vlan_enabled(ndev) ? FIELD_PREP(FWGC_SVM, C_TAG) : 0, priv->addr + FWGC);
+
+ err = rswitch_write_vlan_table(priv, p_vlan->vid, AGENT_INDEX_GWCA);
+ if (err < 0)
+ return err;
+
+ /* If the default vlan for this port has been set, don't overwrite it. */
+ if (ioread32(priv->addr + GWVCC))
+ return NOTIFY_DONE;
+
+ return rswitch_gwca_set_vlan_tag(priv, p_vlan, false);
+}
+
+static int rswitch_port_obj_do_del(struct net_device *ndev,
+ struct switchdev_obj_port_vlan *p_vlan)
+{
+ struct rswitch_device *rdev = netdev_priv(ndev);
+ struct rswitch_private *priv = rdev->priv;
+ struct rswitch_etha *etha = rdev->etha;
+ int err;
+
+ err = rswitch_port_set_vlan_tag(etha, p_vlan, true);
+ if (err < 0)
+ return err;
+
+ rswitch_modify(priv->addr, FWPC0(etha->index), FWPC0_VLANSA | FWPC0_VLANRU, 0);
+ rswitch_modify(priv->addr, FWPC2(AGENT_INDEX_GWCA), 0,
+ FIELD_PREP(FWPC2_LTWFW, BIT(etha->index)));
+ rswitch_modify(priv->addr, FWPC2(rdev->port),
+ 0, FIELD_PREP(FWPC2_LTWFW, GENMASK(RSWITCH_NUM_AGENTS - 1, 0)));
+
+ return rswitch_erase_vlan_table(priv, p_vlan->vid, etha->index);
+}
+
+static int rswitch_port_obj_do_del_gwca(struct net_device *ndev,
+ struct rswitch_private *priv,
+ struct switchdev_obj_port_vlan *p_vlan)
+{
+ int err;
+
+ err = rswitch_gwca_set_vlan_tag(priv, p_vlan, true);
+ if (err < 0)
+ return err;
+
+ rswitch_modify(priv->addr, FWPC0(AGENT_INDEX_GWCA),
+ FWPC0_VLANSA | FWPC0_VLANRU,
+ 0);
+
+ return rswitch_erase_vlan_table(priv, p_vlan->vid, AGENT_INDEX_GWCA);
+}
+
+static int rswitch_handle_port_obj_add(struct net_device *ndev,
+ struct notifier_block *nb,
+ struct switchdev_notifier_port_obj_info *info)
+{
+ struct switchdev_obj_port_vlan *p_vlan = SWITCHDEV_OBJ_PORT_VLAN(info->obj);
+ struct rswitch_private *priv;
+ int err;
+
+ priv = container_of(nb, struct rswitch_private, rswitch_switchdev_blocking_nb);
+
+ if ((p_vlan->flags & BRIDGE_VLAN_INFO_MASTER) ||
+ (p_vlan->flags & BRIDGE_VLAN_INFO_RANGE_BEGIN) ||
+ (p_vlan->flags & BRIDGE_VLAN_INFO_RANGE_END) ||
+ (p_vlan->flags & BRIDGE_VLAN_INFO_ONLY_OPTS))
+ return NOTIFY_DONE;
+
+ switch (info->obj->id) {
+ case SWITCHDEV_OBJ_ID_PORT_VLAN:
+ if (!is_rdev(ndev))
+ err = rswitch_port_obj_do_add_gwca(ndev, priv, p_vlan);
+ else
+ err = rswitch_port_obj_do_add(ndev, p_vlan);
+
+ if (err < 0)
+ return err;
+
+ break;
default:
return -EOPNOTSUPP;
}
+
+ info->handled = true;
+
+ return NOTIFY_DONE;
+}
+
+static int rswitch_handle_port_obj_del(struct net_device *ndev,
+ struct notifier_block *nb,
+ struct switchdev_notifier_port_obj_info *info)
+{
+ struct switchdev_obj_port_vlan *p_vlan = SWITCHDEV_OBJ_PORT_VLAN(info->obj);
+ struct rswitch_private *priv;
+ int err;
+
+ priv = container_of(nb, struct rswitch_private, rswitch_switchdev_blocking_nb);
+
+ if ((p_vlan->flags & BRIDGE_VLAN_INFO_MASTER) ||
+ (p_vlan->flags & BRIDGE_VLAN_INFO_RANGE_BEGIN) ||
+ (p_vlan->flags & BRIDGE_VLAN_INFO_RANGE_END) ||
+ (p_vlan->flags & BRIDGE_VLAN_INFO_ONLY_OPTS))
+ return NOTIFY_DONE;
+
+ switch (info->obj->id) {
+ case SWITCHDEV_OBJ_ID_PORT_VLAN:
+ if (!is_rdev(ndev))
+ err = rswitch_port_obj_do_del_gwca(ndev, priv, p_vlan);
+ else
+ err = rswitch_port_obj_do_del(ndev, p_vlan);
+
+ if (err < 0)
+ return err;
+
+ break;
+ default:
+ return -EOPNOTSUPP;
+ }
+
+ info->handled = true;
+
+ return NOTIFY_DONE;
}
static int rswitch_switchdev_blocking_event(struct notifier_block *nb,
- unsigned long event, void *ptr)
+ unsigned long event,
+ void *ptr)
{
struct net_device *ndev = switchdev_notifier_info_to_dev(ptr);
- int ret;
+ int err;
switch (event) {
case SWITCHDEV_PORT_OBJ_ADD:
- return -EOPNOTSUPP;
+ err = rswitch_handle_port_obj_add(ndev, nb, ptr);
+
+ return notifier_from_errno(err);
case SWITCHDEV_PORT_OBJ_DEL:
- return -EOPNOTSUPP;
+ err = rswitch_handle_port_obj_del(ndev, nb, ptr);
+
+ return notifier_from_errno(err);
case SWITCHDEV_PORT_ATTR_SET:
- ret = switchdev_handle_port_attr_set(ndev, ptr,
- is_rdev,
- rswitch_port_attr_set);
- break;
- default:
- if (!is_rdev(ndev))
- return NOTIFY_DONE;
- ret = -EOPNOTSUPP;
+ err = rswitch_handle_port_attr_set(ndev, nb, ptr);
+
+ return notifier_from_errno(err);
}
- return notifier_from_errno(ret);
+ return NOTIFY_DONE;
}
static int rswitch_gwca_write_mac_address(struct rswitch_private *priv, const u8 *mac)
@@ -389,7 +710,6 @@ static int rswitch_switchdev_event(struct notifier_block *nb,
struct switchdev_notifier_fdb_info *fdb_info;
struct switchdev_notifier_info *info = ptr;
struct rswitch_private *priv;
- int err;
priv = container_of(nb, struct rswitch_private, rswitch_switchdev_nb);
@@ -424,16 +744,6 @@ static int rswitch_switchdev_event(struct notifier_block *nb,
queue_work(system_long_wq, &switchdev_work->work);
break;
- case SWITCHDEV_PORT_ATTR_SET:
- err = switchdev_handle_port_attr_set(ndev, ptr,
- is_rdev,
- rswitch_port_attr_set);
- return notifier_from_errno(err);
-
- if (!is_rdev(ndev))
- return NOTIFY_DONE;
-
- return notifier_from_errno(-EOPNOTSUPP);
}
return NOTIFY_DONE;
--
2.43.0
^ permalink raw reply related
* [PATCH net-next v3 12/13] net: renesas: rswitch: add handler for FDB notification
From: Michael Dege @ 2026-03-31 10:04 UTC (permalink / raw)
To: Yoshihiro Shimoda, Andrew Lunn, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Niklas Söderlund, Paul Barker
Cc: netdev, linux-renesas-soc, linux-kernel, Michael Dege
In-Reply-To: <20260331-rswitch_add_vlans-v3-0-c37f41b1c556@renesas.com>
The SWITCHDEV_FDB_ADD_TO_DEVICE notification writes the bridge MAC address
to the GWCA and adds a static rule to the MAC table.
The SWITCHDEV_FDB_DEL_TO_DEVICE removes the static rule from the MAC table.
Signed-off-by: Michael Dege <michael.dege@renesas.com>
---
drivers/net/ethernet/renesas/rswitch.h | 8 ++
drivers/net/ethernet/renesas/rswitch_l2.c | 205 ++++++++++++++++++++++++++----
2 files changed, 190 insertions(+), 23 deletions(-)
diff --git a/drivers/net/ethernet/renesas/rswitch.h b/drivers/net/ethernet/renesas/rswitch.h
index 6dfc53c6b985..443fc4e49602 100644
--- a/drivers/net/ethernet/renesas/rswitch.h
+++ b/drivers/net/ethernet/renesas/rswitch.h
@@ -1217,6 +1217,14 @@ struct rswitch_private {
enum hwtstamp_rx_filters tstamp_rx_ctrl;
};
+struct rswitch_switchdev_event_work {
+ struct work_struct work;
+ struct switchdev_notifier_fdb_info fdb_info;
+ struct net_device *ndev;
+ struct rswitch_private *priv;
+ unsigned long event;
+};
+
bool is_rdev(const struct net_device *ndev);
void rswitch_modify(void __iomem *addr, enum rswitch_reg reg, u32 clear, u32 set);
int rswitch_reg_wait(void __iomem *addr, u32 offs, u32 mask, u32 expected);
diff --git a/drivers/net/ethernet/renesas/rswitch_l2.c b/drivers/net/ethernet/renesas/rswitch_l2.c
index f1c5c96027ba..ea95a87ed234 100644
--- a/drivers/net/ethernet/renesas/rswitch_l2.c
+++ b/drivers/net/ethernet/renesas/rswitch_l2.c
@@ -23,7 +23,8 @@ static bool rdev_for_l2_offload(struct rswitch_device *rdev)
static void rswitch_change_l2_hw_offloading(struct rswitch_device *rdev,
bool start, bool learning)
{
- u32 bits = learning ? FWPC0_MACSSA | FWPC0_MACHLA | FWPC0_MACHMA : FWPC0_MACDSA;
+ u32 bits = learning ? FWPC0_MACSSA | FWPC0_MACHLA | FWPC0_MACHMA | FWPC0_MACRUDA :
+ FWPC0_MACDSA;
u32 clear = start ? 0 : bits;
u32 set = start ? bits : 0;
@@ -82,8 +83,9 @@ static void rswitch_update_l2_hw_forwarding(struct rswitch_private *priv)
*
* Do not allow L2 forwarding to self for hw port.
*/
- iowrite32(FIELD_PREP(FWPC2_LTWFW, fwd_mask | BIT(rdev->port)),
- priv->addr + FWPC2(rdev->port));
+ rswitch_modify(priv->addr, FWPC2(rdev->port),
+ FIELD_PREP(FWPC2_LTWFW, ~(fwd_mask | BIT(rdev->port))),
+ 0);
}
if (new_forwarding_offload && !rdev->forwarding_offloaded)
@@ -188,7 +190,8 @@ static int rswitch_port_update_stp_state(struct net_device *ndev, u8 stp_state)
}
static int rswitch_netdevice_event(struct notifier_block *nb,
- unsigned long event, void *ptr)
+ unsigned long event,
+ void *ptr)
{
struct net_device *ndev = netdev_notifier_info_to_dev(ptr);
struct netdev_notifier_changeupper_info *info;
@@ -241,25 +244,6 @@ static int rswitch_port_attr_set(struct net_device *ndev, const void *ctx,
}
}
-static int rswitch_switchdev_event(struct notifier_block *nb,
- unsigned long event, void *ptr)
-{
- struct net_device *ndev = switchdev_notifier_info_to_dev(ptr);
- int ret;
-
- if (event == SWITCHDEV_PORT_ATTR_SET) {
- ret = switchdev_handle_port_attr_set(ndev, ptr,
- is_rdev,
- rswitch_port_attr_set);
- return notifier_from_errno(ret);
- }
-
- if (!is_rdev(ndev))
- return NOTIFY_DONE;
-
- return notifier_from_errno(-EOPNOTSUPP);
-}
-
static int rswitch_switchdev_blocking_event(struct notifier_block *nb,
unsigned long event, void *ptr)
{
@@ -285,6 +269,181 @@ static int rswitch_switchdev_blocking_event(struct notifier_block *nb,
return notifier_from_errno(ret);
}
+static int rswitch_gwca_write_mac_address(struct rswitch_private *priv, const u8 *mac)
+{
+ int err;
+
+ err = rswitch_gwca_change_mode(priv, GWMC_OPC_CONFIG);
+ if (err < 0)
+ return err;
+
+ iowrite32((mac[0] << 8) | mac[1], priv->addr + GWMAC0);
+ iowrite32((mac[2] << 24) | (mac[3] << 16) | (mac[4] << 8) | mac[5],
+ priv->addr + GWMAC1);
+
+ return rswitch_gwca_change_mode(priv, GWMC_OPC_OPERATION);
+}
+
+static int rswitch_add_addr_to_mactable(struct rswitch_private *priv, const u8 *mac)
+{
+ u32 index = priv->gwca.l2_shared_rx_queue->index;
+ int err;
+
+ rswitch_modify(priv->addr, FWMACTL0, FWMACTL0_ED, 0);
+ iowrite32((mac[0] << 8) | mac[1], priv->addr + FWMACTL1);
+ iowrite32((mac[2] << 24) | (mac[3] << 16) | (mac[4] << 8) | mac[5],
+ priv->addr + FWMACTL2);
+ iowrite32(FWMACTL3_DSLV | FWMACTL3_SSLV,
+ priv->addr + FWMACTL3);
+ iowrite32(FIELD_PREP(FWMACTL4_CSDL, index),
+ priv->addr + FWMACTL4(GWCA_INDEX));
+ iowrite32(FIELD_PREP(FWMACTL5_DV, BIT(AGENT_INDEX_GWCA)),
+ priv->addr + FWMACTL5);
+
+ err = rswitch_reg_wait(priv->addr, FWMACTLR, FWMACTLR_L, 0);
+ if (err < 0)
+ return err;
+
+ if (ioread32(priv->addr + FWMACTLR))
+ return NOTIFY_BAD;
+
+ return NOTIFY_DONE;
+}
+
+static int rswitch_del_addr_from_mactable(struct rswitch_private *priv, const u8 *mac)
+{
+ int err;
+
+ rswitch_modify(priv->addr, FWMACTL0, 0, FWMACTL0_ED);
+ iowrite32((mac[0] << 8) | mac[1], priv->addr + FWMACTL1);
+ iowrite32((mac[2] << 24) | (mac[3] << 16) | (mac[4] << 8) | mac[5],
+ priv->addr + FWMACTL2);
+ iowrite32(FWMACTL3_DSLV | FWMACTL3_SSLV,
+ priv->addr + FWMACTL3);
+ iowrite32(FIELD_PREP(FWMACTL4_CSDL, BIT(0)),
+ priv->addr + FWMACTL4(GWCA_INDEX));
+ iowrite32(FIELD_PREP(FWMACTL5_DV, BIT(AGENT_INDEX_GWCA)),
+ priv->addr + FWMACTL5);
+
+ err = rswitch_reg_wait(priv->addr, FWMACTLR, FWMACTLR_L, 0);
+ if (err < 0)
+ return err;
+
+ err = ioread32(priv->addr + FWMACTLR);
+ if (err)
+ return NOTIFY_BAD;
+
+ return NOTIFY_DONE;
+}
+
+static void rswitch_switchdev_bridge_fdb_event_work(struct work_struct *work)
+{
+ struct rswitch_switchdev_event_work *switchdev_work;
+ struct rswitch_device *rdev;
+ struct net_device *ndev;
+
+ switchdev_work = container_of(work, struct rswitch_switchdev_event_work, work);
+ ndev = switchdev_work->ndev;
+
+ rtnl_lock();
+
+ /* Unfortunately all net_device members point to br0, there is no simple way to check
+ * if the event was triggered by a port device setting.
+ */
+ rswitch_for_all_ports(switchdev_work->priv, rdev) {
+ if (ether_addr_equal(rdev->ndev->dev_addr, switchdev_work->fdb_info.addr))
+ goto out;
+ }
+
+ /* Handle only bridge device */
+ if (is_rdev(ndev))
+ goto out;
+
+ switch (switchdev_work->event) {
+ case SWITCHDEV_FDB_ADD_TO_DEVICE:
+ rswitch_gwca_write_mac_address(switchdev_work->priv, switchdev_work->fdb_info.addr);
+ rswitch_add_addr_to_mactable(switchdev_work->priv, switchdev_work->fdb_info.addr);
+ break;
+ case SWITCHDEV_FDB_DEL_TO_DEVICE:
+ rswitch_del_addr_from_mactable(switchdev_work->priv, switchdev_work->fdb_info.addr);
+ break;
+ default:
+ break;
+ }
+
+out:
+ rtnl_unlock();
+
+ kfree(switchdev_work->fdb_info.addr);
+ kfree(switchdev_work);
+ dev_put(ndev);
+}
+
+/* called under rcu_read_lock() */
+static int rswitch_switchdev_event(struct notifier_block *nb,
+ unsigned long event,
+ void *ptr)
+{
+ struct net_device *ndev = switchdev_notifier_info_to_dev(ptr);
+ struct rswitch_switchdev_event_work *switchdev_work;
+ struct switchdev_notifier_fdb_info *fdb_info;
+ struct switchdev_notifier_info *info = ptr;
+ struct rswitch_private *priv;
+ int err;
+
+ priv = container_of(nb, struct rswitch_private, rswitch_switchdev_nb);
+
+ switch (event) {
+ case SWITCHDEV_FDB_ADD_TO_DEVICE:
+ fallthrough;
+ case SWITCHDEV_FDB_DEL_TO_DEVICE:
+ switchdev_work = kzalloc(sizeof(*switchdev_work), GFP_ATOMIC);
+
+ if (!switchdev_work)
+ return NOTIFY_BAD;
+
+ switchdev_work->ndev = info->dev;
+ switchdev_work->priv = priv;
+ switchdev_work->event = event;
+
+ fdb_info = container_of(info,
+ struct switchdev_notifier_fdb_info,
+ info);
+
+ INIT_WORK(&switchdev_work->work, rswitch_switchdev_bridge_fdb_event_work);
+
+ memcpy(&switchdev_work->fdb_info, ptr, sizeof(switchdev_work->fdb_info));
+
+ switchdev_work->fdb_info.addr = kzalloc(ETH_ALEN, GFP_ATOMIC);
+ if (!switchdev_work->fdb_info.addr)
+ goto err_addr_alloc;
+
+ ether_addr_copy((u8 *)switchdev_work->fdb_info.addr,
+ fdb_info->addr);
+ dev_hold(ndev);
+ queue_work(system_long_wq, &switchdev_work->work);
+
+ break;
+ case SWITCHDEV_PORT_ATTR_SET:
+ err = switchdev_handle_port_attr_set(ndev, ptr,
+ is_rdev,
+ rswitch_port_attr_set);
+ return notifier_from_errno(err);
+
+ if (!is_rdev(ndev))
+ return NOTIFY_DONE;
+
+ return notifier_from_errno(-EOPNOTSUPP);
+ }
+
+ return NOTIFY_DONE;
+
+err_addr_alloc:
+ kfree(switchdev_work);
+
+ return NOTIFY_BAD;
+}
+
int rswitch_register_notifiers(struct rswitch_private *priv)
{
int err;
--
2.43.0
^ permalink raw reply related
* [PATCH net-next v3 11/13] net: renesas: rswitch: add passing of rswitch_private into notifiers
From: Michael Dege @ 2026-03-31 10:04 UTC (permalink / raw)
To: Yoshihiro Shimoda, Andrew Lunn, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Niklas Söderlund, Paul Barker
Cc: netdev, linux-renesas-soc, linux-kernel, Michael Dege
In-Reply-To: <20260331-rswitch_add_vlans-v3-0-c37f41b1c556@renesas.com>
Provide struct rswitch_private to notifiers. This will be needed
to access the HW in the notification handlers.
Signed-off-by: Michael Dege <michael.dege@renesas.com>
---
drivers/net/ethernet/renesas/rswitch.h | 5 ++++
drivers/net/ethernet/renesas/rswitch_l2.c | 45 ++++++++++++-----------------
drivers/net/ethernet/renesas/rswitch_l2.h | 6 ++--
drivers/net/ethernet/renesas/rswitch_main.c | 4 +--
4 files changed, 28 insertions(+), 32 deletions(-)
diff --git a/drivers/net/ethernet/renesas/rswitch.h b/drivers/net/ethernet/renesas/rswitch.h
index 42c8bbafa27d..6dfc53c6b985 100644
--- a/drivers/net/ethernet/renesas/rswitch.h
+++ b/drivers/net/ethernet/renesas/rswitch.h
@@ -1199,6 +1199,11 @@ struct rswitch_private {
struct rswitch_etha etha[RSWITCH_NUM_PORTS];
struct rswitch_mfwd mfwd;
+ /* Notifiers */
+ struct notifier_block rswitch_netdevice_nb;
+ struct notifier_block rswitch_switchdev_nb;
+ struct notifier_block rswitch_switchdev_blocking_nb;
+
struct list_head port_list;
spinlock_t lock; /* lock interrupt registers' control */
diff --git a/drivers/net/ethernet/renesas/rswitch_l2.c b/drivers/net/ethernet/renesas/rswitch_l2.c
index ae3857ef9af6..f1c5c96027ba 100644
--- a/drivers/net/ethernet/renesas/rswitch_l2.c
+++ b/drivers/net/ethernet/renesas/rswitch_l2.c
@@ -285,48 +285,39 @@ static int rswitch_switchdev_blocking_event(struct notifier_block *nb,
return notifier_from_errno(ret);
}
-static struct notifier_block rswitch_netdevice_nb = {
- .notifier_call = rswitch_netdevice_event,
-};
-
-static struct notifier_block rswitch_switchdev_nb = {
- .notifier_call = rswitch_switchdev_event,
-};
-
-static struct notifier_block rswitch_switchdev_blocking_nb = {
- .notifier_call = rswitch_switchdev_blocking_event,
-};
-
-int rswitch_register_notifiers(void)
+int rswitch_register_notifiers(struct rswitch_private *priv)
{
- int ret;
+ int err;
- ret = register_netdevice_notifier(&rswitch_netdevice_nb);
- if (ret)
+ priv->rswitch_netdevice_nb.notifier_call = rswitch_netdevice_event;
+ err = register_netdevice_notifier(&priv->rswitch_netdevice_nb);
+ if (err)
goto register_netdevice_notifier_failed;
- ret = register_switchdev_notifier(&rswitch_switchdev_nb);
- if (ret)
+ priv->rswitch_switchdev_nb.notifier_call = rswitch_switchdev_event;
+ err = register_switchdev_notifier(&priv->rswitch_switchdev_nb);
+ if (err)
goto register_switchdev_notifier_failed;
- ret = register_switchdev_blocking_notifier(&rswitch_switchdev_blocking_nb);
- if (ret)
+ priv->rswitch_switchdev_blocking_nb.notifier_call = rswitch_switchdev_blocking_event;
+ err = register_switchdev_blocking_notifier(&priv->rswitch_switchdev_blocking_nb);
+ if (err)
goto register_switchdev_blocking_notifier_failed;
return 0;
register_switchdev_blocking_notifier_failed:
- unregister_switchdev_notifier(&rswitch_switchdev_nb);
+ unregister_switchdev_notifier(&priv->rswitch_switchdev_nb);
register_switchdev_notifier_failed:
- unregister_netdevice_notifier(&rswitch_netdevice_nb);
+ unregister_netdevice_notifier(&priv->rswitch_netdevice_nb);
register_netdevice_notifier_failed:
- return ret;
+ return err;
}
-void rswitch_unregister_notifiers(void)
+void rswitch_unregister_notifiers(struct rswitch_private *priv)
{
- unregister_switchdev_blocking_notifier(&rswitch_switchdev_blocking_nb);
- unregister_switchdev_notifier(&rswitch_switchdev_nb);
- unregister_netdevice_notifier(&rswitch_netdevice_nb);
+ unregister_switchdev_blocking_notifier(&priv->rswitch_switchdev_blocking_nb);
+ unregister_switchdev_notifier(&priv->rswitch_switchdev_nb);
+ unregister_netdevice_notifier(&priv->rswitch_netdevice_nb);
}
diff --git a/drivers/net/ethernet/renesas/rswitch_l2.h b/drivers/net/ethernet/renesas/rswitch_l2.h
index 57050ede8f31..af9780c63c9a 100644
--- a/drivers/net/ethernet/renesas/rswitch_l2.h
+++ b/drivers/net/ethernet/renesas/rswitch_l2.h
@@ -1,7 +1,7 @@
/* SPDX-License-Identifier: GPL-2.0 */
/* Renesas Ethernet Switch device driver
*
- * Copyright (C) 2025 Renesas Electronics Corporation
+ * Copyright (C) 2025 - 2026 Renesas Electronics Corporation
*/
#ifndef __RSWITCH_L2_H__
@@ -9,7 +9,7 @@
void rswitch_update_l2_offload(struct rswitch_private *priv);
-int rswitch_register_notifiers(void);
-void rswitch_unregister_notifiers(void);
+int rswitch_register_notifiers(struct rswitch_private *priv);
+void rswitch_unregister_notifiers(struct rswitch_private *priv);
#endif /* #ifndef __RSWITCH_L2_H__ */
diff --git a/drivers/net/ethernet/renesas/rswitch_main.c b/drivers/net/ethernet/renesas/rswitch_main.c
index fc2c9892aea0..92dd372aaa20 100644
--- a/drivers/net/ethernet/renesas/rswitch_main.c
+++ b/drivers/net/ethernet/renesas/rswitch_main.c
@@ -2272,7 +2272,7 @@ static int renesas_eth_sw_probe(struct platform_device *pdev)
if (list_empty(&priv->port_list))
dev_warn(&pdev->dev, "could not initialize any ports\n");
- ret = rswitch_register_notifiers();
+ ret = rswitch_register_notifiers(priv);
if (ret) {
dev_err(&pdev->dev, "could not register notifiers\n");
return ret;
@@ -2311,7 +2311,7 @@ static void renesas_eth_sw_remove(struct platform_device *pdev)
{
struct rswitch_private *priv = platform_get_drvdata(pdev);
- rswitch_unregister_notifiers();
+ rswitch_unregister_notifiers(priv);
rswitch_deinit(priv);
pm_runtime_put(&pdev->dev);
--
2.43.0
^ permalink raw reply related
* [PATCH net-next v3 10/13] net: renesas: rswitch: clean up is_rdev rswitch_device checking
From: Michael Dege @ 2026-03-31 10:04 UTC (permalink / raw)
To: Yoshihiro Shimoda, Andrew Lunn, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Niklas Söderlund, Paul Barker
Cc: netdev, linux-renesas-soc, linux-kernel, Michael Dege
In-Reply-To: <20260331-rswitch_add_vlans-v3-0-c37f41b1c556@renesas.com>
Add null pointer checking for ndev and remove unnecessay
rswitch_port_check() wrapper function.
Signed-off-by: Michael Dege <michael.dege@renesas.com>
---
drivers/net/ethernet/renesas/rswitch_l2.c | 15 +++++----------
drivers/net/ethernet/renesas/rswitch_main.c | 2 +-
2 files changed, 6 insertions(+), 11 deletions(-)
diff --git a/drivers/net/ethernet/renesas/rswitch_l2.c b/drivers/net/ethernet/renesas/rswitch_l2.c
index cabf1f92ad0c..ae3857ef9af6 100644
--- a/drivers/net/ethernet/renesas/rswitch_l2.c
+++ b/drivers/net/ethernet/renesas/rswitch_l2.c
@@ -158,11 +158,6 @@ static void rswitch_update_offload_brdev(struct rswitch_private *priv)
rswitch_update_l2_offload(priv);
}
-static bool rswitch_port_check(const struct net_device *ndev)
-{
- return is_rdev(ndev);
-}
-
static void rswitch_port_update_brdev(struct net_device *ndev,
struct net_device *brdev)
{
@@ -199,7 +194,7 @@ static int rswitch_netdevice_event(struct notifier_block *nb,
struct netdev_notifier_changeupper_info *info;
struct net_device *brdev;
- if (!rswitch_port_check(ndev))
+ if (!is_rdev(ndev))
return NOTIFY_DONE;
if (event != NETDEV_CHANGEUPPER)
return NOTIFY_DONE;
@@ -254,12 +249,12 @@ static int rswitch_switchdev_event(struct notifier_block *nb,
if (event == SWITCHDEV_PORT_ATTR_SET) {
ret = switchdev_handle_port_attr_set(ndev, ptr,
- rswitch_port_check,
+ is_rdev,
rswitch_port_attr_set);
return notifier_from_errno(ret);
}
- if (!rswitch_port_check(ndev))
+ if (!is_rdev(ndev))
return NOTIFY_DONE;
return notifier_from_errno(-EOPNOTSUPP);
@@ -278,11 +273,11 @@ static int rswitch_switchdev_blocking_event(struct notifier_block *nb,
return -EOPNOTSUPP;
case SWITCHDEV_PORT_ATTR_SET:
ret = switchdev_handle_port_attr_set(ndev, ptr,
- rswitch_port_check,
+ is_rdev,
rswitch_port_attr_set);
break;
default:
- if (!rswitch_port_check(ndev))
+ if (!is_rdev(ndev))
return NOTIFY_DONE;
ret = -EOPNOTSUPP;
}
diff --git a/drivers/net/ethernet/renesas/rswitch_main.c b/drivers/net/ethernet/renesas/rswitch_main.c
index 60bfa22cc412..fc2c9892aea0 100644
--- a/drivers/net/ethernet/renesas/rswitch_main.c
+++ b/drivers/net/ethernet/renesas/rswitch_main.c
@@ -1962,7 +1962,7 @@ static const struct net_device_ops rswitch_netdev_ops = {
bool is_rdev(const struct net_device *ndev)
{
- return (ndev->netdev_ops == &rswitch_netdev_ops);
+ return ndev && (ndev->netdev_ops == &rswitch_netdev_ops);
}
static int rswitch_get_ts_info(struct net_device *ndev, struct kernel_ethtool_ts_info *info)
--
2.43.0
^ permalink raw reply related
* [PATCH net-next v3 09/13] net: renesas: rswitch: update port HW init
From: Michael Dege @ 2026-03-31 10:04 UTC (permalink / raw)
To: Yoshihiro Shimoda, Andrew Lunn, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Niklas Söderlund, Paul Barker
Cc: netdev, linux-renesas-soc, linux-kernel, Michael Dege
In-Reply-To: <20260331-rswitch_add_vlans-v3-0-c37f41b1c556@renesas.com>
Certain Ethernet and cpu port settings need to be updated for vlan
support.
Signed-off-by: Michael Dege <michael.dege@renesas.com>
---
drivers/net/ethernet/renesas/rswitch.h | 4 ----
drivers/net/ethernet/renesas/rswitch_main.c | 15 ++++++++++++---
2 files changed, 12 insertions(+), 7 deletions(-)
diff --git a/drivers/net/ethernet/renesas/rswitch.h b/drivers/net/ethernet/renesas/rswitch.h
index ff2a84057f01..42c8bbafa27d 100644
--- a/drivers/net/ethernet/renesas/rswitch.h
+++ b/drivers/net/ethernet/renesas/rswitch.h
@@ -766,8 +766,6 @@ enum vlan_egress_mode {
HW_SC_TAG_VLAN,
};
-#define EAVCC_VEM_SC_TAG (0x3 << 16)
-
#define MPIC_PIS GENMASK(2, 0)
#define MPIC_PIS_GMII 2
#define MPIC_PIS_XGMII 4
@@ -806,8 +804,6 @@ enum rswitch_gwca_mode {
#define GWMTIRM_MTIOG BIT(0)
#define GWMTIRM_MTR BIT(1)
-#define GWVCC_VEM_SC_TAG (0x3 << 16)
-
#define GWARIRM_ARIOG BIT(0)
#define GWARIRM_ARR BIT(1)
diff --git a/drivers/net/ethernet/renesas/rswitch_main.c b/drivers/net/ethernet/renesas/rswitch_main.c
index 160b70997924..60bfa22cc412 100644
--- a/drivers/net/ethernet/renesas/rswitch_main.c
+++ b/drivers/net/ethernet/renesas/rswitch_main.c
@@ -735,8 +735,11 @@ static int rswitch_gwca_hw_init(struct rswitch_private *priv)
if (err < 0)
return err;
- iowrite32(GWVCC_VEM_SC_TAG, priv->addr + GWVCC);
- iowrite32(0, priv->addr + GWTTFC);
+ iowrite32(0, priv->addr + GWIRC);
+ iowrite32(FIELD_PREP(DQD, DES_RAM_DP), priv->addr + GWRDQDC0);
+ /* Drop frames with unknown tags */
+ iowrite32(UT, priv->addr + GWTTFC);
+
iowrite32(lower_32_bits(priv->gwca.linkfix_table_dma), priv->addr + GWDCBAC1);
iowrite32(upper_32_bits(priv->gwca.linkfix_table_dma), priv->addr + GWDCBAC0);
iowrite32(lower_32_bits(priv->gwca.ts_queue.ring_dma), priv->addr + GWTDCAC10);
@@ -878,6 +881,7 @@ static bool rswitch_rx(struct net_device *ndev, int *quota)
limit = boguscnt;
desc = &gq->rx_ring[gq->cur];
+
while ((desc->desc.die_dt & DT_MASK) != DT_FEMPTY) {
dma_rmb();
skb = rswitch_rx_handle_desc(ndev, gq, desc);
@@ -1267,7 +1271,12 @@ static int rswitch_etha_hw_init(struct rswitch_etha *etha, const u8 *mac)
if (err < 0)
return err;
- iowrite32(EAVCC_VEM_SC_TAG, etha->addr + EAVCC);
+ iowrite32(0, etha->addr + EAIRC);
+ iowrite32(FIELD_PREP(DQD, DES_RAM_DP), etha->addr + EATDQDC0);
+
+ /* Drop frames with unknown tags */
+ iowrite32(UT, etha->addr + EARTFC);
+
rswitch_rmac_setting(etha, mac);
rswitch_etha_enable_mii(etha);
--
2.43.0
^ permalink raw reply related
* [PATCH net-next v3 08/13] net: renesas: rswitch: add basic vlan init to rswitch_fwd_init
From: Michael Dege @ 2026-03-31 10:04 UTC (permalink / raw)
To: Yoshihiro Shimoda, Andrew Lunn, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Niklas Söderlund, Paul Barker
Cc: netdev, linux-renesas-soc, linux-kernel, Michael Dege
In-Reply-To: <20260331-rswitch_add_vlans-v3-0-c37f41b1c556@renesas.com>
Add basic vlan related register initialization.
Signed-off-by: Michael Dege <michael.dege@renesas.com>
---
drivers/net/ethernet/renesas/rswitch_main.c | 17 ++++++++++++++---
1 file changed, 14 insertions(+), 3 deletions(-)
diff --git a/drivers/net/ethernet/renesas/rswitch_main.c b/drivers/net/ethernet/renesas/rswitch_main.c
index 99c9bef14ca5..160b70997924 100644
--- a/drivers/net/ethernet/renesas/rswitch_main.c
+++ b/drivers/net/ethernet/renesas/rswitch_main.c
@@ -120,6 +120,7 @@ static int rswitch_fwd_init(struct rswitch_private *priv)
u32 all_ports_mask = GENMASK(RSWITCH_NUM_AGENTS - 1, 0);
unsigned int i;
u32 reg_val;
+ int ret;
/* Start with empty configuration */
for (i = 0; i < RSWITCH_NUM_AGENTS; i++) {
@@ -154,17 +155,27 @@ static int rswitch_fwd_init(struct rswitch_private *priv)
}
/* For GWCA port, allow direct descriptor forwarding */
- rswitch_modify(priv->addr, FWPC1(priv->gwca.index), FWPC1_DDE, FWPC1_DDE);
+ rswitch_modify(priv->addr, FWPC1(priv->gwca.index), 0, FWPC1_DDE);
/* Initialize hardware L2 forwarding table */
- /* Allow entire table to be used for "unsecure" entries */
+ /* Allow entire table to be used for "un-secure" entries */
rswitch_modify(priv->addr, FWMACHEC, 0, FWMACHEC_MACHMUE_MASK);
/* Initialize MAC hash table */
iowrite32(FWMACTIM_MACTIOG, priv->addr + FWMACTIM);
- return rswitch_reg_wait(priv->addr, FWMACTIM, FWMACTIM_MACTIOG, 0);
+ ret = rswitch_reg_wait(priv->addr, FWMACTIM, FWMACTIM_MACTIOG, 0);
+ if (ret)
+ return ret;
+
+ /* Allow entire VLAN table to be used for "un-secure" entries */
+ iowrite32(VLANTMUE, priv->addr + FWVLANTEC);
+
+ /* Initialize VLAN table */
+ iowrite32(VLANTIOG, priv->addr + FWVLANTIM);
+
+ return rswitch_reg_wait(priv->addr, FWVLANTIM, VLANTIOG, 0);
}
/* Gateway CPU agent block (GWCA) */
--
2.43.0
^ permalink raw reply related
* [PATCH net-next v3 07/13] net: renesas: rswitch: make helper functions available to whole driver
From: Michael Dege @ 2026-03-31 10:04 UTC (permalink / raw)
To: Yoshihiro Shimoda, Andrew Lunn, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Niklas Söderlund, Paul Barker
Cc: netdev, linux-renesas-soc, linux-kernel, Michael Dege
In-Reply-To: <20260331-rswitch_add_vlans-v3-0-c37f41b1c556@renesas.com>
These functions will be needed in L2 and vlan handling. Remove static
declaration and add function prototype to rswitch.h.
Signed-off-by: Michael Dege <michael.dege@renesas.com>
---
drivers/net/ethernet/renesas/rswitch.h | 6 ++++--
drivers/net/ethernet/renesas/rswitch_main.c | 12 ++++++------
2 files changed, 10 insertions(+), 8 deletions(-)
diff --git a/drivers/net/ethernet/renesas/rswitch.h b/drivers/net/ethernet/renesas/rswitch.h
index bf123b564ed1..ff2a84057f01 100644
--- a/drivers/net/ethernet/renesas/rswitch.h
+++ b/drivers/net/ethernet/renesas/rswitch.h
@@ -1,7 +1,7 @@
/* SPDX-License-Identifier: GPL-2.0 */
/* Renesas Ethernet Switch device driver
*
- * Copyright (C) 2022-2025 Renesas Electronics Corporation
+ * Copyright (C) 2022-2026 Renesas Electronics Corporation
*/
#ifndef __RSWITCH_H__
@@ -1218,5 +1218,7 @@ struct rswitch_private {
bool is_rdev(const struct net_device *ndev);
void rswitch_modify(void __iomem *addr, enum rswitch_reg reg, u32 clear, u32 set);
-
+int rswitch_reg_wait(void __iomem *addr, u32 offs, u32 mask, u32 expected);
+int rswitch_gwca_change_mode(struct rswitch_private *priv, enum rswitch_gwca_mode mode);
+int rswitch_etha_change_mode(struct rswitch_etha *etha, enum rswitch_etha_mode mode);
#endif /* #ifndef __RSWITCH_H__ */
diff --git a/drivers/net/ethernet/renesas/rswitch_main.c b/drivers/net/ethernet/renesas/rswitch_main.c
index 3c142fa3c810..99c9bef14ca5 100644
--- a/drivers/net/ethernet/renesas/rswitch_main.c
+++ b/drivers/net/ethernet/renesas/rswitch_main.c
@@ -1,7 +1,7 @@
// SPDX-License-Identifier: GPL-2.0
/* Renesas Ethernet Switch device driver
*
- * Copyright (C) 2022-2025 Renesas Electronics Corporation
+ * Copyright (C) 2022-2026 Renesas Electronics Corporation
*/
#include <linux/clk.h>
@@ -32,7 +32,7 @@
#define RSWITCH_GPTP_OFFSET_S4 0x00018000
-static int rswitch_reg_wait(void __iomem *addr, u32 offs, u32 mask, u32 expected)
+int rswitch_reg_wait(void __iomem *addr, u32 offs, u32 mask, u32 expected)
{
u32 val;
@@ -168,8 +168,8 @@ static int rswitch_fwd_init(struct rswitch_private *priv)
}
/* Gateway CPU agent block (GWCA) */
-static int rswitch_gwca_change_mode(struct rswitch_private *priv,
- enum rswitch_gwca_mode mode)
+int rswitch_gwca_change_mode(struct rswitch_private *priv,
+ enum rswitch_gwca_mode mode)
{
int ret;
@@ -1153,8 +1153,8 @@ static int rswitch_gwca_ts_request_irqs(struct rswitch_private *priv)
}
/* Ethernet TSN Agent block (ETHA) and Ethernet MAC IP block (RMAC) */
-static int rswitch_etha_change_mode(struct rswitch_etha *etha,
- enum rswitch_etha_mode mode)
+int rswitch_etha_change_mode(struct rswitch_etha *etha,
+ enum rswitch_etha_mode mode)
{
int ret;
--
2.43.0
^ permalink raw reply related
* [PATCH net-next v3 06/13] net: renesas: rswitch: add forwarding rules for gwca
From: Michael Dege @ 2026-03-31 10:04 UTC (permalink / raw)
To: Yoshihiro Shimoda, Andrew Lunn, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Niklas Söderlund, Paul Barker
Cc: netdev, linux-renesas-soc, linux-kernel, Michael Dege
In-Reply-To: <20260331-rswitch_add_vlans-v3-0-c37f41b1c556@renesas.com>
Add rules to forward packets from the Ethernet ports to the CPU port (GWCA)
using L2 forwarding instead of port forwarding.
Signed-off-by: Michael Dege <michael.dege@renesas.com>
---
drivers/net/ethernet/renesas/rswitch_l2.c | 22 ++++++++++++++++++++++
1 file changed, 22 insertions(+)
diff --git a/drivers/net/ethernet/renesas/rswitch_l2.c b/drivers/net/ethernet/renesas/rswitch_l2.c
index 709524c8a5c4..cabf1f92ad0c 100644
--- a/drivers/net/ethernet/renesas/rswitch_l2.c
+++ b/drivers/net/ethernet/renesas/rswitch_l2.c
@@ -93,10 +93,32 @@ static void rswitch_update_l2_hw_forwarding(struct rswitch_private *priv)
}
}
+static void rswitch_update_l2_hw_forwarding_gwca(struct rswitch_private *priv)
+{
+ struct rswitch_device *rdev;
+ u32 fwpc0_set, fwpc0_clr, fwpc2_set, fwpc2_clr;
+
+ fwpc0_clr = FWPC0_MACSSA | FWPC0_MACDSA | FWPC0_MACRUDA;
+ fwpc0_set = fwpc0_clr;
+ fwpc2_clr = FIELD_PREP(FWPC2_LTWFW, BIT(AGENT_INDEX_GWCA));
+ fwpc2_set = fwpc2_clr;
+
+ (priv->offload_brdev) ? (fwpc0_clr = 0, fwpc2_set = 0)
+ : (fwpc0_set = 0, fwpc2_set = 0);
+
+ rswitch_modify(priv->addr, FWPC0(AGENT_INDEX_GWCA), fwpc0_clr, fwpc0_set);
+
+ rswitch_for_all_ports(priv, rdev) {
+ rswitch_modify(priv->addr, FWPC2(rdev->etha->index),
+ fwpc2_clr, fwpc2_set);
+ }
+}
+
void rswitch_update_l2_offload(struct rswitch_private *priv)
{
rswitch_update_l2_hw_learning(priv);
rswitch_update_l2_hw_forwarding(priv);
+ rswitch_update_l2_hw_forwarding_gwca(priv);
}
static void rswitch_update_offload_brdev(struct rswitch_private *priv)
--
2.43.0
^ permalink raw reply related
* [PATCH net-next v3 05/13] net: renesas: rswitch: add exception path for packets with unknown dst MAC
From: Michael Dege @ 2026-03-31 10:03 UTC (permalink / raw)
To: Yoshihiro Shimoda, Andrew Lunn, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Niklas Söderlund, Paul Barker
Cc: netdev, linux-renesas-soc, linux-kernel, Michael Dege
In-Reply-To: <20260331-rswitch_add_vlans-v3-0-c37f41b1c556@renesas.com>
Packets with unknown MAC address cannot be handled by the HW forwarding.
These need to be forwarded, via an exception path, to the network driver.
Creates a queue for the exeption path. Packets received with unknown
src/dst address need to be passed to the CPU. The received packet does not
have the correct source port information, this is derived from the
descriptor and added to the new queue. The received packet is added to the
new queue and sent to the CPU for MAC learning. The CPU will broadcast the
received packet, to all ports. This is how the HW learns the new MAC
address.
Signed-off-by: Michael Dege <michael.dege@renesas.com>
---
drivers/net/ethernet/renesas/rswitch.h | 1 +
drivers/net/ethernet/renesas/rswitch_main.c | 80 ++++++++++++++++++++++++++---
2 files changed, 74 insertions(+), 7 deletions(-)
diff --git a/drivers/net/ethernet/renesas/rswitch.h b/drivers/net/ethernet/renesas/rswitch.h
index 15d3fa48b0e3..bf123b564ed1 100644
--- a/drivers/net/ethernet/renesas/rswitch.h
+++ b/drivers/net/ethernet/renesas/rswitch.h
@@ -1148,6 +1148,7 @@ struct rswitch_gwca {
struct rswitch_gwca_queue *queues;
int num_queues;
struct rswitch_gwca_queue ts_queue;
+ struct rswitch_gwca_queue *l2_shared_rx_queue;
DECLARE_BITMAP(used, RSWITCH_MAX_NUM_QUEUES);
u32 tx_irq_bits[RSWITCH_NUM_IRQ_REGS];
u32 rx_irq_bits[RSWITCH_NUM_IRQ_REGS];
diff --git a/drivers/net/ethernet/renesas/rswitch_main.c b/drivers/net/ethernet/renesas/rswitch_main.c
index d404bc41bd1e..3c142fa3c810 100644
--- a/drivers/net/ethernet/renesas/rswitch_main.c
+++ b/drivers/net/ethernet/renesas/rswitch_main.c
@@ -680,6 +680,34 @@ static int rswitch_rxdmac_init(struct rswitch_private *priv, unsigned int index)
return rswitch_gwca_queue_ext_ts_format(ndev->dev.parent, priv, rdev->rx_queue);
}
+static int rswitch_shared_rx_queue_alloc(struct rswitch_private *priv)
+{
+ struct rswitch_gwca *gwca = &priv->gwca;
+ struct device *dev = &priv->pdev->dev;
+
+ int err;
+
+ gwca->l2_shared_rx_queue = rswitch_gwca_get(priv);
+ if (!gwca->l2_shared_rx_queue)
+ return -EBUSY;
+
+ err = rswitch_gwca_queue_alloc(NULL, priv, gwca->l2_shared_rx_queue, false, RX_RING_SIZE);
+ if (err < 0) {
+ rswitch_gwca_put(priv, gwca->l2_shared_rx_queue);
+ return err;
+ }
+
+ return rswitch_gwca_queue_ext_ts_format(dev, priv, gwca->l2_shared_rx_queue);
+}
+
+static void rswitch_shared_rx_queue_free(struct rswitch_private *priv)
+{
+ struct rswitch_gwca *gwca = &priv->gwca;
+
+ rswitch_gwca_queue_free(&priv->pdev->dev, gwca->l2_shared_rx_queue);
+ rswitch_gwca_put(priv, gwca->l2_shared_rx_queue);
+}
+
static int rswitch_gwca_hw_init(struct rswitch_private *priv)
{
unsigned int i;
@@ -717,6 +745,12 @@ static int rswitch_gwca_hw_init(struct rswitch_private *priv)
return err;
}
+ err = rswitch_shared_rx_queue_alloc(priv);
+ if (err < 0) {
+ rswitch_shared_rx_queue_free(priv);
+ return err;
+ }
+
return rswitch_gwca_change_mode(priv, GWMC_OPC_OPERATION);
}
@@ -940,6 +974,7 @@ static int rswitch_poll(struct napi_struct *napi, int budget)
rswitch_enadis_data_irq(priv, rdev->tx_queue->index, true);
rswitch_enadis_data_irq(priv, rdev->rx_queue->index, true);
}
+ rswitch_enadis_data_irq(priv, priv->gwca.l2_shared_rx_queue->index, true);
spin_unlock_irqrestore(&priv->lock, flags);
}
@@ -952,15 +987,31 @@ static int rswitch_poll(struct napi_struct *napi, int budget)
return 0;
}
-static void rswitch_queue_interrupt(struct net_device *ndev)
+static void rswitch_queue_interrupt(struct rswitch_private *priv, struct rswitch_gwca_queue *gq)
{
- struct rswitch_device *rdev = netdev_priv(ndev);
+ struct rswitch_ext_ts_desc *desc;
+ struct rswitch_device *rdev;
+ struct net_device *ndev;
+ u32 spn;
+
+ if (gq->index == priv->gwca.l2_shared_rx_queue->index) {
+ desc = &gq->rx_ring[gq->cur];
+ spn = FIELD_GET(SPN, desc->info1);
+ ndev = priv->rdev[spn]->ndev;
+ rdev = netdev_priv(ndev);
+ gq->ndev = ndev;
+ rdev->rx_queue = gq;
+ } else {
+ rdev = netdev_priv(gq->ndev);
+ }
+
if (napi_schedule_prep(&rdev->napi)) {
- spin_lock(&rdev->priv->lock);
- rswitch_enadis_data_irq(rdev->priv, rdev->tx_queue->index, false);
- rswitch_enadis_data_irq(rdev->priv, rdev->rx_queue->index, false);
- spin_unlock(&rdev->priv->lock);
+ spin_lock(&priv->lock);
+ rswitch_enadis_data_irq(priv, rdev->tx_queue->index, false);
+ rswitch_enadis_data_irq(priv, rdev->rx_queue->index, false);
+ rswitch_enadis_data_irq(priv, priv->gwca.l2_shared_rx_queue->index, false);
+ spin_unlock(&priv->lock);
__napi_schedule(&rdev->napi);
}
}
@@ -978,7 +1029,7 @@ static irqreturn_t rswitch_data_irq(struct rswitch_private *priv, u32 *dis)
continue;
rswitch_ack_data_irq(priv, gq->index);
- rswitch_queue_interrupt(gq->ndev);
+ rswitch_queue_interrupt(priv, gq);
}
return IRQ_HANDLED;
@@ -1513,6 +1564,14 @@ static int rswitch_serdes_set_params(struct rswitch_device *rdev)
return phy_set_speed(rdev->serdes, rdev->etha->speed);
}
+static void rswitch_etha_set_exception_path(struct rswitch_private *priv)
+{
+ iowrite32(FDMACUFEF, priv->addr + FWCEPRC2);
+ iowrite32(FIELD_PREP(EPCS, GWCA_INDEX) |
+ FIELD_PREP(EPCSD, priv->gwca.l2_shared_rx_queue->index),
+ priv->addr + FWCEPTC);
+}
+
static int rswitch_ether_port_init_one(struct rswitch_device *rdev)
{
int err;
@@ -1566,6 +1625,8 @@ static int rswitch_ether_port_init_all(struct rswitch_private *priv)
unsigned int i;
int err;
+ rswitch_etha_set_exception_path(priv);
+
rswitch_for_each_enabled_port(priv, i) {
err = rswitch_ether_port_init_one(priv->rdev[i]);
if (err)
@@ -1616,6 +1677,7 @@ static int rswitch_open(struct net_device *ndev)
bitmap_set(rdev->priv->opened_ports, rdev->port, 1);
rswitch_enadis_data_irq(rdev->priv, rdev->tx_queue->index, true);
rswitch_enadis_data_irq(rdev->priv, rdev->rx_queue->index, true);
+ rswitch_enadis_data_irq(rdev->priv, rdev->priv->gwca.l2_shared_rx_queue->index, true);
spin_unlock_irqrestore(&rdev->priv->lock, flags);
phy_start(ndev->phydev);
@@ -1642,6 +1704,7 @@ static int rswitch_stop(struct net_device *ndev)
spin_lock_irqsave(&rdev->priv->lock, flags);
rswitch_enadis_data_irq(rdev->priv, rdev->tx_queue->index, false);
rswitch_enadis_data_irq(rdev->priv, rdev->rx_queue->index, false);
+ rswitch_enadis_data_irq(rdev->priv, rdev->priv->gwca.l2_shared_rx_queue->index, false);
bitmap_clear(rdev->priv->opened_ports, rdev->port, 1);
spin_unlock_irqrestore(&rdev->priv->lock, flags);
@@ -2166,6 +2229,9 @@ static int renesas_eth_sw_probe(struct platform_device *pdev)
priv->gwca.index = AGENT_INDEX_GWCA;
priv->gwca.num_queues = min(RSWITCH_NUM_PORTS * NUM_QUEUES_PER_NDEV,
RSWITCH_MAX_NUM_QUEUES);
+ /* One extra queue for L2 switch reception */
+ priv->gwca.num_queues = min(priv->gwca.num_queues + 1,
+ RSWITCH_MAX_NUM_QUEUES);
priv->gwca.queues = devm_kcalloc(&pdev->dev, priv->gwca.num_queues,
sizeof(*priv->gwca.queues), GFP_KERNEL);
if (!priv->gwca.queues)
--
2.43.0
^ permalink raw reply related
* [PATCH net-next v3 04/13] net: renesas: rswitch: add register definitions for vlan support
From: Michael Dege @ 2026-03-31 10:03 UTC (permalink / raw)
To: Yoshihiro Shimoda, Andrew Lunn, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Niklas Söderlund, Paul Barker
Cc: netdev, linux-renesas-soc, linux-kernel, Michael Dege
In-Reply-To: <20260331-rswitch_add_vlans-v3-0-c37f41b1c556@renesas.com>
Add missing register and bit definitions for vlan support.
Signed-off-by: Michael Dege <michael.dege@renesas.com>
---
drivers/net/ethernet/renesas/rswitch.h | 156 ++++++++++++++++++++++++++++++++-
1 file changed, 152 insertions(+), 4 deletions(-)
diff --git a/drivers/net/ethernet/renesas/rswitch.h b/drivers/net/ethernet/renesas/rswitch.h
index 340524d995ac..15d3fa48b0e3 100644
--- a/drivers/net/ethernet/renesas/rswitch.h
+++ b/drivers/net/ethernet/renesas/rswitch.h
@@ -7,8 +7,10 @@
#ifndef __RSWITCH_H__
#define __RSWITCH_H__
+#include <linux/if_vlan.h>
#include <linux/platform_device.h>
#include <linux/phy.h>
+#include <net/switchdev.h>
#include "rcar_gen4_ptp.h"
@@ -221,7 +223,7 @@ enum rswitch_reg {
FWMACTL1 = FWRO + 0x4634,
FWMACTL2 = FWRO + 0x4638,
FWMACTL3 = FWRO + 0x463c,
- FWMACTL4 = FWRO + 0x4640,
+ FWMACTL40 = FWRO + 0x4640,
FWMACTL5 = FWRO + 0x4650,
FWMACTLR = FWRO + 0x4654,
FWMACTIM = FWRO + 0x4660,
@@ -249,7 +251,7 @@ enum rswitch_reg {
FWVLANTL0 = FWRO + 0x4910,
FWVLANTL1 = FWRO + 0x4914,
FWVLANTL2 = FWRO + 0x4918,
- FWVLANTL3 = FWRO + 0x4920,
+ FWVLANTL30 = FWRO + 0x4920,
FWVLANTL4 = FWRO + 0x4930,
FWVLANTLR = FWRO + 0x4934,
FWVLANTIM = FWRO + 0x4940,
@@ -508,7 +510,7 @@ enum rswitch_reg {
EACTDQMLM = TARO + 0x010c,
EAVCC = TARO + 0x0130,
EAVTC = TARO + 0x0134,
- EATTFC = TARO + 0x0138,
+ EARTFC = TARO + 0x0138,
EACAEC = TARO + 0x0200,
EACC = TARO + 0x0204,
EACAIVC0 = TARO + 0x0220,
@@ -729,6 +731,41 @@ enum rswitch_etha_mode {
#define EAMS_OPS_MASK EAMC_OPC_OPERATION
+/* bit field definitions for EAVCC and GWVCC */
+#define VEM GENMASK(18, 16)
+#define VIM BIT(0)
+
+/* bit field definitions for EAVTC and GWVTC */
+#define STD BIT(31)
+#define STP GENMASK(30, 28)
+#define STV GENMASK(27, 16)
+#define CTD BIT(15)
+#define CTP GENMASK(14, 12)
+#define CTV GENMASK(11, 0)
+
+/* bit field definitions for EARTFC and GWTTCF */
+#define UT BIT(8)
+#define SCRT BIT(7)
+#define SCT BIT(6)
+#define CRT BIT(5)
+#define CT BIT(4)
+#define CSRT BIT(3)
+#define CST BIT(2)
+#define RT BIT(1)
+#define NT BIT(0)
+
+/* bit field definitions for EARDQDC and GWRDQDC */
+#define DQD GENMASK(10, 0)
+#define DES_RAM_DP 0x400
+
+enum vlan_egress_mode {
+ NO_VLAN,
+ C_TAG_VLAN,
+ HW_C_TAG_VLAN,
+ SC_TAG_VLAN,
+ HW_SC_TAG_VLAN,
+};
+
#define EAVCC_VEM_SC_TAG (0x3 << 16)
#define MPIC_PIS GENMASK(2, 0)
@@ -806,6 +843,22 @@ enum rswitch_gwca_mode {
#define CABPPFLC_INIT_VALUE 0x00800080
/* MFWD */
+#define FWGC_SVM GENMASK(1, 0)
+
+enum switch_vlan_mode {
+ NO_VLAN_MODE,
+ C_TAG,
+ SC_TAG,
+};
+
+/* FWCEPRC2 */
+#define FDMACSLFEF BIT(19)
+#define FDMACUFEF BIT(3)
+
+/* FWCEPTC */
+#define EPCS GENMASK(17, 16)
+#define EPCSD GENMASK(6, 0)
+
#define FWPC0(i) (FWPC00 + (i) * 0x10)
#define FWPC0_LTHTA BIT(0)
#define FWPC0_IP4UE BIT(3)
@@ -816,10 +869,13 @@ enum rswitch_gwca_mode {
#define FWPC0_IPDSA BIT(12)
#define FWPC0_IPHLA BIT(18)
#define FWPC0_MACDSA BIT(20)
+#define FWPC0_MACRUDA BIT(21)
#define FWPC0_MACSSA BIT(23)
#define FWPC0_MACHLA BIT(26)
#define FWPC0_MACHMA BIT(27)
#define FWPC0_VLANSA BIT(28)
+#define FWPC0_VLANRU BIT(29)
+#define FWPC0_VLANRUS BIT(30)
#define FWPC1(i) (FWPC10 + (i) * 0x10)
#define FWCP1_LTHFW GENMASK(16 + (RSWITCH_NUM_AGENTS - 1), 16)
@@ -847,6 +903,98 @@ enum rswitch_gwca_mode {
#define FWMACAGC_MACAGOG BIT(28)
#define FWMACAGC_MACDESOG BIT(29)
+//FWMACTL0
+#define FWMACTL0_ED BIT(16)
+#define FWMACTL0_HLD BIT(10)
+#define FWMACTL0_DE BIT(9)
+#define FWMACTL0_SL BIT(8)
+
+//FWMACTL3
+#define FWMACTL3_DSLV GENMASK(16 + RSWITCH_NUM_AGENTS - 1, 16)
+#define FWMACTL3_SSLV GENMASK(RSWITCH_NUM_AGENTS - 1, 0)
+
+//FWMACTL4
+#define FWMACTL4(i) (FWMACTL40 + (i) * 4)
+#define FWMACTL4_CSDL GENMASK(6, 0)
+
+//FWMACTL5
+#define FWMACTL5_CME BIT(21)
+#define FWMACTL5_EME BIT(20)
+#define FWMACTL5_IPU BIT(19)
+#define FWMACTL5_IPV GENMASK(18, 16)
+#define FWMACTL5_DV GENMASK(6, 0)
+
+//FWMACTLR
+#define FWMACTLR_L BIT(31)
+#define FWMACTLR_LCN GENMASK(25, 16)
+#define FWMACTLR_LO BIT(3)
+#define FWMACTLR_LEF BIT(2)
+#define FWMACTLR_LSF BIT(1)
+#define FWMACTLR_LF BIT(0)
+
+// FWVLANTEC
+#define VLANTMUE GENMASK(28, 16)
+
+// FWVLANTL0
+#define VLANED BIT(16)
+#define VLANHLDL BIT(10)
+#define VLANSLL BIT(8)
+
+// FWVLANTL1
+#define VLANVIDL GENMASK(11, 0)
+
+// FWVLANTL2
+#define VLANSLVL GENMASK(6, 0)
+
+// FWVLANTL3
+#define FWVLANTL3(i) (FWVLANTL30 + (i) * 4)
+#define VLANCSDL GENMASK(6, 0)
+
+// FWVLANTL4
+#define VLANCMEL BIT(21)
+#define VLANEMEL BIT(20)
+#define VLANIPUL BIT(19)
+#define VLANIPVL GENMASK(18, 16)
+#define VLANDVL GENMASK(6, 0)
+
+// FWVLANTLR
+#define VLANTL BIT(31)
+#define VLANLO BIT(3)
+#define VLANLEF BIT(2)
+#define VLANLSF BIT(1)
+#define VLANLF BIT(0)
+
+// FWVLANTIM
+#define VLANTR BIT(1)
+#define VLANTIOG BIT(0)
+
+// FWVLANTEM
+#define VLANTUEN GENMASK(28, 16)
+#define VLANTEN GENAMSK(12, 0)
+
+// FWVLANTS
+#define VLANVIDS GENMASK(11, 0)
+
+// FWVLANTSR0
+#define VLANTS BIT(31)
+#define VLANHLDS BIT(10)
+#define VLANSLS BIT(8)
+#define VLANSNF BIT(1)
+#define VLANSEF BIT(0)
+
+// FWVLANTSR1
+#define VLANSLVS GENMASK(6, 0)
+
+// FWVLANTSR2
+#define FWVLANTSR2(i) (FWVLANTSR20 + (i) * 4)
+
+// FWVLANTSR3
+#define VLANCMES BIT(21)
+#define VLANEMES BIT(20)
+#define VLANIPUS BIT(19)
+#define VLANIPVS GENMASK(18, 16)
+#define VLANDVS GENMASK(6, 0)
+
#define RSW_AGEING_CLK_PER_US 0x140
#define RSW_AGEING_TIME 300
@@ -904,7 +1052,7 @@ enum DIE_DT {
#define INFO1_DV(port_vector) ((u64)(port_vector) << 48ULL)
/* For reception */
-#define INFO1_SPN(port) ((u64)(port) << 36ULL)
+#define SPN GENMASK_U64(38, 36)
/* For timestamp descriptor in dptrl (Byte 4 to 7) */
#define TS_DESC_TSUN(dptrl) ((dptrl) & GENMASK(7, 0))
--
2.43.0
^ permalink raw reply related
* [PATCH net-next v3 03/13] net: renesas: rswitch: fix FWPC2 register access macros
From: Michael Dege @ 2026-03-31 10:03 UTC (permalink / raw)
To: Yoshihiro Shimoda, Andrew Lunn, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Niklas Söderlund, Paul Barker
Cc: netdev, linux-renesas-soc, linux-kernel, Michael Dege
In-Reply-To: <20260331-rswitch_add_vlans-v3-0-c37f41b1c556@renesas.com>
Fix typo in macro name and remove duplicate macro definition.
Signed-off-by: Michael Dege <michael.dege@renesas.com>
---
drivers/net/ethernet/renesas/rswitch.h | 3 +--
drivers/net/ethernet/renesas/rswitch_l2.c | 2 +-
drivers/net/ethernet/renesas/rswitch_main.c | 2 +-
3 files changed, 3 insertions(+), 4 deletions(-)
diff --git a/drivers/net/ethernet/renesas/rswitch.h b/drivers/net/ethernet/renesas/rswitch.h
index aa605304fed0..340524d995ac 100644
--- a/drivers/net/ethernet/renesas/rswitch.h
+++ b/drivers/net/ethernet/renesas/rswitch.h
@@ -826,8 +826,7 @@ enum rswitch_gwca_mode {
#define FWPC1_DDE BIT(0)
#define FWPC2(i) (FWPC20 + (i) * 0x10)
-#define FWCP2_LTWFW GENMASK(16 + (RSWITCH_NUM_AGENTS - 1), 16)
-#define FWCP2_LTWFW_MASK GENMASK(16 + (RSWITCH_NUM_AGENTS - 1), 16)
+#define FWPC2_LTWFW GENMASK(16 + (RSWITCH_NUM_AGENTS - 1), 16)
#define FWPBFC(i) (FWPBFC0 + (i) * 0x10)
#define FWPBFC_PBDV GENMASK(RSWITCH_NUM_AGENTS - 1, 0)
diff --git a/drivers/net/ethernet/renesas/rswitch_l2.c b/drivers/net/ethernet/renesas/rswitch_l2.c
index 9433cd8adced..709524c8a5c4 100644
--- a/drivers/net/ethernet/renesas/rswitch_l2.c
+++ b/drivers/net/ethernet/renesas/rswitch_l2.c
@@ -82,7 +82,7 @@ static void rswitch_update_l2_hw_forwarding(struct rswitch_private *priv)
*
* Do not allow L2 forwarding to self for hw port.
*/
- iowrite32(FIELD_PREP(FWCP2_LTWFW_MASK, fwd_mask | BIT(rdev->port)),
+ iowrite32(FIELD_PREP(FWPC2_LTWFW, fwd_mask | BIT(rdev->port)),
priv->addr + FWPC2(rdev->port));
}
diff --git a/drivers/net/ethernet/renesas/rswitch_main.c b/drivers/net/ethernet/renesas/rswitch_main.c
index f10e188bc0bd..d404bc41bd1e 100644
--- a/drivers/net/ethernet/renesas/rswitch_main.c
+++ b/drivers/net/ethernet/renesas/rswitch_main.c
@@ -129,7 +129,7 @@ static int rswitch_fwd_init(struct rswitch_private *priv)
iowrite32(FIELD_PREP(FWCP1_LTHFW, all_ports_mask),
priv->addr + FWPC1(i));
/* Disallow L2 forwarding */
- iowrite32(FIELD_PREP(FWCP2_LTWFW, all_ports_mask),
+ iowrite32(FIELD_PREP(FWPC2_LTWFW, all_ports_mask),
priv->addr + FWPC2(i));
/* Disallow port based forwarding */
iowrite32(0, priv->addr + FWPBFC(i));
--
2.43.0
^ permalink raw reply related
* [PATCH net-next v3 02/13] net: renesas: rswitch: use device instead of net_device
From: Michael Dege @ 2026-03-31 10:03 UTC (permalink / raw)
To: Yoshihiro Shimoda, Andrew Lunn, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Niklas Söderlund, Paul Barker
Cc: netdev, linux-renesas-soc, linux-kernel, Michael Dege
In-Reply-To: <20260331-rswitch_add_vlans-v3-0-c37f41b1c556@renesas.com>
In upcomming changes for adding vlan support struct net_device
will not be available in all cases, therefore use struct device
instead.
Signed-off-by: Michael Dege <michael.dege@renesas.com>
---
drivers/net/ethernet/renesas/rswitch_main.c | 34 ++++++++++++++---------------
1 file changed, 16 insertions(+), 18 deletions(-)
diff --git a/drivers/net/ethernet/renesas/rswitch_main.c b/drivers/net/ethernet/renesas/rswitch_main.c
index f6d1e610e7fa..f10e188bc0bd 100644
--- a/drivers/net/ethernet/renesas/rswitch_main.c
+++ b/drivers/net/ethernet/renesas/rswitch_main.c
@@ -302,13 +302,13 @@ static int rswitch_gwca_queue_alloc_rx_buf(struct rswitch_gwca_queue *gq,
return -ENOMEM;
}
-static void rswitch_gwca_queue_free(struct net_device *ndev,
+static void rswitch_gwca_queue_free(struct device *dev,
struct rswitch_gwca_queue *gq)
{
unsigned int i;
if (!gq->dir_tx) {
- dma_free_coherent(ndev->dev.parent,
+ dma_free_coherent(dev,
sizeof(struct rswitch_ext_ts_desc) *
(gq->ring_size + 1), gq->rx_ring, gq->ring_dma);
gq->rx_ring = NULL;
@@ -318,7 +318,7 @@ static void rswitch_gwca_queue_free(struct net_device *ndev,
kfree(gq->rx_bufs);
gq->rx_bufs = NULL;
} else {
- dma_free_coherent(ndev->dev.parent,
+ dma_free_coherent(dev,
sizeof(struct rswitch_ext_desc) *
(gq->ring_size + 1), gq->tx_ring, gq->ring_dma);
gq->tx_ring = NULL;
@@ -357,7 +357,7 @@ static int rswitch_gwca_queue_alloc(struct net_device *ndev,
if (rswitch_gwca_queue_alloc_rx_buf(gq, 0, gq->ring_size) < 0)
goto out;
- gq->rx_ring = dma_alloc_coherent(ndev->dev.parent,
+ gq->rx_ring = dma_alloc_coherent(&priv->pdev->dev,
sizeof(struct rswitch_ext_ts_desc) *
(gq->ring_size + 1), &gq->ring_dma, GFP_KERNEL);
} else {
@@ -367,7 +367,7 @@ static int rswitch_gwca_queue_alloc(struct net_device *ndev,
gq->unmap_addrs = kzalloc_objs(*gq->unmap_addrs, gq->ring_size);
if (!gq->unmap_addrs)
goto out;
- gq->tx_ring = dma_alloc_coherent(ndev->dev.parent,
+ gq->tx_ring = dma_alloc_coherent(&priv->pdev->dev,
sizeof(struct rswitch_ext_desc) *
(gq->ring_size + 1), &gq->ring_dma, GFP_KERNEL);
}
@@ -385,7 +385,7 @@ static int rswitch_gwca_queue_alloc(struct net_device *ndev,
return 0;
out:
- rswitch_gwca_queue_free(ndev, gq);
+ rswitch_gwca_queue_free(&priv->pdev->dev, gq);
return -ENOMEM;
}
@@ -467,12 +467,11 @@ static void rswitch_gwca_ts_queue_fill(struct rswitch_private *priv,
}
}
-static int rswitch_gwca_queue_ext_ts_fill(struct net_device *ndev,
+static int rswitch_gwca_queue_ext_ts_fill(struct device *dev,
struct rswitch_gwca_queue *gq,
unsigned int start_index,
unsigned int num)
{
- struct rswitch_device *rdev = netdev_priv(ndev);
struct rswitch_ext_ts_desc *desc;
unsigned int i, index;
dma_addr_t dma_addr;
@@ -481,18 +480,17 @@ static int rswitch_gwca_queue_ext_ts_fill(struct net_device *ndev,
index = (i + start_index) % gq->ring_size;
desc = &gq->rx_ring[index];
if (!gq->dir_tx) {
- dma_addr = dma_map_single(ndev->dev.parent,
+ dma_addr = dma_map_single(dev,
gq->rx_bufs[index] + RSWITCH_HEADROOM,
RSWITCH_MAP_BUF_SIZE,
DMA_FROM_DEVICE);
- if (dma_mapping_error(ndev->dev.parent, dma_addr))
+ if (dma_mapping_error(dev, dma_addr))
goto err;
desc->desc.info_ds = cpu_to_le16(RSWITCH_DESC_BUF_SIZE);
rswitch_desc_set_dptr(&desc->desc, dma_addr);
dma_wmb();
desc->desc.die_dt = DT_FEMPTY | DIE;
- desc->info1 = cpu_to_le64(INFO1_SPN(rdev->etha->index));
} else {
desc->desc.die_dt = DT_EEMPTY | DIE;
}
@@ -506,7 +504,7 @@ static int rswitch_gwca_queue_ext_ts_fill(struct net_device *ndev,
index = (i + start_index) % gq->ring_size;
desc = &gq->rx_ring[index];
dma_addr = rswitch_desc_get_dptr(&desc->desc);
- dma_unmap_single(ndev->dev.parent, dma_addr,
+ dma_unmap_single(dev, dma_addr,
RSWITCH_MAP_BUF_SIZE, DMA_FROM_DEVICE);
}
}
@@ -514,7 +512,7 @@ static int rswitch_gwca_queue_ext_ts_fill(struct net_device *ndev,
return -ENOMEM;
}
-static int rswitch_gwca_queue_ext_ts_format(struct net_device *ndev,
+static int rswitch_gwca_queue_ext_ts_format(struct device *dev,
struct rswitch_private *priv,
struct rswitch_gwca_queue *gq)
{
@@ -524,7 +522,7 @@ static int rswitch_gwca_queue_ext_ts_format(struct net_device *ndev,
int err;
memset(gq->rx_ring, 0, ring_size);
- err = rswitch_gwca_queue_ext_ts_fill(ndev, gq, 0, gq->ring_size);
+ err = rswitch_gwca_queue_ext_ts_fill(dev, gq, 0, gq->ring_size);
if (err < 0)
return err;
@@ -636,7 +634,7 @@ static void rswitch_txdmac_free(struct net_device *ndev)
{
struct rswitch_device *rdev = netdev_priv(ndev);
- rswitch_gwca_queue_free(ndev, rdev->tx_queue);
+ rswitch_gwca_queue_free(ndev->dev.parent, rdev->tx_queue);
rswitch_gwca_put(rdev->priv, rdev->tx_queue);
}
@@ -670,7 +668,7 @@ static void rswitch_rxdmac_free(struct net_device *ndev)
{
struct rswitch_device *rdev = netdev_priv(ndev);
- rswitch_gwca_queue_free(ndev, rdev->rx_queue);
+ rswitch_gwca_queue_free(ndev->dev.parent, rdev->rx_queue);
rswitch_gwca_put(rdev->priv, rdev->rx_queue);
}
@@ -679,7 +677,7 @@ static int rswitch_rxdmac_init(struct rswitch_private *priv, unsigned int index)
struct rswitch_device *rdev = priv->rdev[index];
struct net_device *ndev = rdev->ndev;
- return rswitch_gwca_queue_ext_ts_format(ndev, priv, rdev->rx_queue);
+ return rswitch_gwca_queue_ext_ts_format(ndev->dev.parent, priv, rdev->rx_queue);
}
static int rswitch_gwca_hw_init(struct rswitch_private *priv)
@@ -870,7 +868,7 @@ static bool rswitch_rx(struct net_device *ndev, int *quota)
ret = rswitch_gwca_queue_alloc_rx_buf(gq, gq->dirty, num);
if (ret < 0)
goto err;
- ret = rswitch_gwca_queue_ext_ts_fill(ndev, gq, gq->dirty, num);
+ ret = rswitch_gwca_queue_ext_ts_fill(ndev->dev.parent, gq, gq->dirty, num);
if (ret < 0)
goto err;
gq->dirty = rswitch_next_queue_index(gq, false, num);
--
2.43.0
^ permalink raw reply related
* [PATCH net-next v3 01/13] net: renesas: rswitch: improve port change mode functions
From: Michael Dege @ 2026-03-31 10:03 UTC (permalink / raw)
To: Yoshihiro Shimoda, Andrew Lunn, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Niklas Söderlund, Paul Barker
Cc: netdev, linux-renesas-soc, linux-kernel, Michael Dege
In-Reply-To: <20260331-rswitch_add_vlans-v3-0-c37f41b1c556@renesas.com>
For ETHA and GWCA ports every mode change from operational to
configuration and vice-versa requires to change the mode to
"disable" first. This was done by calling the function twice.
Let the change_mode functione take care of this requiered step
in a single call.
Signed-off-by: Michael Dege <michael.dege@renesas.com>
---
drivers/net/ethernet/renesas/rswitch_main.c | 39 +++++++++++++----------------
1 file changed, 18 insertions(+), 21 deletions(-)
diff --git a/drivers/net/ethernet/renesas/rswitch_main.c b/drivers/net/ethernet/renesas/rswitch_main.c
index 6fe964816322..f6d1e610e7fa 100644
--- a/drivers/net/ethernet/renesas/rswitch_main.c
+++ b/drivers/net/ethernet/renesas/rswitch_main.c
@@ -176,14 +176,19 @@ static int rswitch_gwca_change_mode(struct rswitch_private *priv,
if (!rswitch_agent_clock_is_enabled(priv->addr, priv->gwca.index))
rswitch_agent_clock_ctrl(priv->addr, priv->gwca.index, 1);
- iowrite32(mode, priv->addr + GWMC);
+ iowrite32(GWMC_OPC_DISABLE, priv->addr + GWMC);
- ret = rswitch_reg_wait(priv->addr, GWMS, GWMS_OPS_MASK, mode);
+ ret = rswitch_reg_wait(priv->addr, GWMS, GWMS_OPS_MASK, GWMC_OPC_DISABLE);
- if (mode == GWMC_OPC_DISABLE)
+ if (mode == GWMC_OPC_DISABLE) {
rswitch_agent_clock_ctrl(priv->addr, priv->gwca.index, 0);
- return ret;
+ return ret;
+ }
+
+ iowrite32(mode, priv->addr + GWMC);
+
+ return rswitch_reg_wait(priv->addr, GWMS, GWMS_OPS_MASK, mode);
}
static int rswitch_gwca_mcast_table_reset(struct rswitch_private *priv)
@@ -682,9 +687,6 @@ static int rswitch_gwca_hw_init(struct rswitch_private *priv)
unsigned int i;
int err;
- err = rswitch_gwca_change_mode(priv, GWMC_OPC_DISABLE);
- if (err < 0)
- return err;
err = rswitch_gwca_change_mode(priv, GWMC_OPC_CONFIG);
if (err < 0)
return err;
@@ -717,9 +719,6 @@ static int rswitch_gwca_hw_init(struct rswitch_private *priv)
return err;
}
- err = rswitch_gwca_change_mode(priv, GWMC_OPC_DISABLE);
- if (err < 0)
- return err;
return rswitch_gwca_change_mode(priv, GWMC_OPC_OPERATION);
}
@@ -727,9 +726,6 @@ static int rswitch_gwca_hw_deinit(struct rswitch_private *priv)
{
int err;
- err = rswitch_gwca_change_mode(priv, GWMC_OPC_DISABLE);
- if (err < 0)
- return err;
err = rswitch_gwca_change_mode(priv, GWMC_OPC_RESET);
if (err < 0)
return err;
@@ -1116,14 +1112,18 @@ static int rswitch_etha_change_mode(struct rswitch_etha *etha,
if (!rswitch_agent_clock_is_enabled(etha->coma_addr, etha->index))
rswitch_agent_clock_ctrl(etha->coma_addr, etha->index, 1);
- iowrite32(mode, etha->addr + EAMC);
-
- ret = rswitch_reg_wait(etha->addr, EAMS, EAMS_OPS_MASK, mode);
+ iowrite32(EAMC_OPC_DISABLE, etha->addr + EAMC);
+ ret = rswitch_reg_wait(etha->addr, EAMS, EAMS_OPS_MASK, EAMC_OPC_DISABLE);
- if (mode == EAMC_OPC_DISABLE)
+ if (mode == EAMC_OPC_DISABLE) {
rswitch_agent_clock_ctrl(etha->coma_addr, etha->index, 0);
- return ret;
+ return ret;
+ }
+
+ iowrite32(mode, etha->addr + EAMC);
+
+ return rswitch_reg_wait(etha->addr, EAMS, EAMS_OPS_MASK, mode);
}
static void rswitch_etha_read_mac_address(struct rswitch_etha *etha)
@@ -1203,9 +1203,6 @@ static int rswitch_etha_hw_init(struct rswitch_etha *etha, const u8 *mac)
{
int err;
- err = rswitch_etha_change_mode(etha, EAMC_OPC_DISABLE);
- if (err < 0)
- return err;
err = rswitch_etha_change_mode(etha, EAMC_OPC_CONFIG);
if (err < 0)
return err;
--
2.43.0
^ permalink raw reply related
* [net-next PATCH v3 00/13] net: renesas: rswitch: R-Car S4 add VLAN aware switching
From: Michael Dege @ 2026-03-31 10:03 UTC (permalink / raw)
To: Yoshihiro Shimoda, Andrew Lunn, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Niklas Söderlund, Paul Barker
Cc: netdev, linux-renesas-soc, linux-kernel, Michael Dege
Hello!
The current R-Car S4 rswitch driver only supports basic HW offloading
for L2 switching/bridgeing. This patchset extends the driver with
support for VLAN aware switching.
1. For every port mode change from configuration to operation and
vice-versa you need to change to disabled mode first. The
functions rswitch_<port>_change_mode now take care of this.
2. In upcomming changes for adding vlan support struct net_device
will not be available in all cases, therefore use struct device
instead.
3. Fix typo in register define macro and remove duplicate macro.
4. Add register definitions needed fo vlan support.
5. Add exception path for packets with unknown destitination MAC
addresses.
6. Make the helper functions rswitch_reg_wait(),
rswitch_etha_change_mode() and rswitch_etha_change_mode()
available to the whole driver.
7. Add basic start-up time initialization needed to support VLANs.
8. Update ETHA and GWCA port HW initializations.
9. Clean up is_rdev() rswitch_device checking.
10. Provide struct rswitch_private to notifiers.
11. Add handler for FDB notifications to configure bridge MAC address
to GWCA registers and update static MAC table entry.
12. Add vlan support to L2 HW bridge.
Configuration example:
ip link add name br0 type bridge vlan_filtering 1
ip link set dev tsn0 master br0
ip link set dev tsn1 master br0
ip link set dev br0 up
ip link set dev tsn0 up
ip link set dev tsn1 up
bridge vlan add dev tsn0 vid 4
bridge vlan add dev tsn1 vid 4
bridge vlan add dev br0 vid 4 self
ip a a 192.168.1.20/24 dev br0
ip l a link br0 name br0.1 type vlan id 1
ip l a link br0 name br0.4 type vlan id 4
ip a a 192.168.2.20/24 dev br0.1
ip a a 192.168.4.20/24 dev br0.4
ip link set dev br0.1 up
ip link set dev br0.4 up
Signed-off-by: Michael Dege <michael.dege@renesas.com>
---
Changes in v3:
- Fixed findings made by coccicheck
- Fixed missing 'depends on BRIDGE' in Kconfig found by test robot.
- Link to v2: https://lore.kernel.org/r/20260327-rswitch_add_vlans-v2-0-d7f4358ca57a@renesas.com
Changes in v2:
- Reworked reswitch_update_l2_hw_forwarding_gwca() as suggested.
- Fixed missing initialization found by test robot.
- Link to v1: https://lore.kernel.org/r/20260317-rswitch_add_vlans-v1-0-3a57bfa0f2d1@renesas.com
---
Michael Dege (13):
net: renesas: rswitch: improve port change mode functions
net: renesas: rswitch: use device instead of net_device
net: renesas: rswitch: fix FWPC2 register access macros
net: renesas: rswitch: add register definitions for vlan support
net: renesas: rswitch: add exception path for packets with unknown dst MAC
net: renesas: rswitch: add forwarding rules for gwca
net: renesas: rswitch: make helper functions available to whole driver
net: renesas: rswitch: add basic vlan init to rswitch_fwd_init
net: renesas: rswitch: update port HW init
net: renesas: rswitch: clean up is_rdev rswitch_device checking
net: renesas: rswitch: add passing of rswitch_private into notifiers
net: renesas: rswitch: add handler for FDB notification
net: renesas: rswitch: add vlan aware switching
drivers/net/ethernet/renesas/Kconfig | 1 +
drivers/net/ethernet/renesas/rswitch.h | 181 +++++++-
drivers/net/ethernet/renesas/rswitch_l2.c | 639 ++++++++++++++++++++++++----
drivers/net/ethernet/renesas/rswitch_l2.h | 6 +-
drivers/net/ethernet/renesas/rswitch_main.c | 203 ++++++---
5 files changed, 874 insertions(+), 156 deletions(-)
---
base-commit: 1f318b96cc84d7c2ab792fcc0bfd42a7ca890681
change-id: 20260120-rswitch_add_vlans-39488bfb296c
Best regards,
--
Michael Dege <michael.dege@renesas.com>
^ permalink raw reply
* [PATCH net] bnxt_en: fix out-of-bounds write in bnxt_alloc_vf_resources()
From: Junrui Luo @ 2026-03-31 9:57 UTC (permalink / raw)
To: Michael Chan, Pavan Chebbi, Andrew Lunn, David S. Miller,
Eric Dumazet, Jakub Kicinski, Paolo Abeni, Prashant Sreedharan,
Jeffrey Huang, Eddie Wai
Cc: Michael Chan, netdev, linux-kernel, Yuhao Jiang, stable,
Junrui Luo
bnxt_alloc_vf_resources() derives the number of DMA pages for VF HWRM
command buffers from num_vfs and stores them in the fixed-size arrays
hwrm_cmd_req_addr[4] and hwrm_cmd_req_dma_addr[4]. The vf_event_bmap
bitmap is similarly fixed at 128 bits.
If num_vfs exceeds 128, the allocation loop writes past the arrays,
corrupting adjacent fields in bnxt_pf_info.
Add BNXT_MAX_VFS to cap num_vfs at 128, matching the existing array and
bitmap capacity.
Fixes: c0c050c58d84 ("bnxt_en: New Broadcom ethernet driver.")
Reported-by: Yuhao Jiang <danisjiang@gmail.com>
Cc: stable@vger.kernel.org
Signed-off-by: Junrui Luo <moonafterrain@outlook.com>
---
drivers/net/ethernet/broadcom/bnxt/bnxt.h | 2 ++
drivers/net/ethernet/broadcom/bnxt/bnxt_sriov.c | 6 ++++++
2 files changed, 8 insertions(+)
diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt.h b/drivers/net/ethernet/broadcom/bnxt/bnxt.h
index a97d651130df..cee67ca2955d 100644
--- a/drivers/net/ethernet/broadcom/bnxt/bnxt.h
+++ b/drivers/net/ethernet/broadcom/bnxt/bnxt.h
@@ -1398,6 +1398,8 @@ struct bnxt_vf_info {
};
#endif
+#define BNXT_MAX_VFS 128
+
struct bnxt_pf_info {
#define BNXT_FIRST_PF_FID 1
#define BNXT_FIRST_VF_FID 128
diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt_sriov.c b/drivers/net/ethernet/broadcom/bnxt/bnxt_sriov.c
index 7f9829287c49..18ac0aaf4166 100644
--- a/drivers/net/ethernet/broadcom/bnxt/bnxt_sriov.c
+++ b/drivers/net/ethernet/broadcom/bnxt/bnxt_sriov.c
@@ -459,6 +459,12 @@ static int bnxt_alloc_vf_resources(struct bnxt *bp, int num_vfs)
struct pci_dev *pdev = bp->pdev;
u32 nr_pages, size, i, j, k = 0;
+ if (num_vfs > BNXT_MAX_VFS) {
+ netdev_warn(bp->dev, "Too many VFs (%d), max is %d\n",
+ num_vfs, BNXT_MAX_VFS);
+ return -EINVAL;
+ }
+
bp->pf.vf = kzalloc_objs(struct bnxt_vf_info, num_vfs);
if (!bp->pf.vf)
return -ENOMEM;
---
base-commit: c369299895a591d96745d6492d4888259b004a9e
change-id: 20260331-fixes-ee2efcc963a3
Best regards,
--
Junrui Luo <moonafterrain@outlook.com>
^ permalink raw reply related
* Re: [PATCH net-next v8 4/4] net: dsa: mxl862xx: implement bridge offloading
From: Paolo Abeni @ 2026-03-31 9:48 UTC (permalink / raw)
To: Daniel Golle, Andrew Lunn, Vladimir Oltean, David S. Miller,
Eric Dumazet, Jakub Kicinski, David Yang, Simon Horman,
Russell King, netdev, linux-kernel
Cc: Frank Wunderlich, Chad Monroe, Cezary Wilmanski, Liang Xu,
Benny (Ying-Tsan) Weng, Jose Maria Verdu Munoz, Avinash Jayaraman,
John Crispin
In-Reply-To: <201af75c81ca093c46ab5c28a9379eeb6e9fa432.1774572749.git.daniel@makrotopia.org>
On 3/27/26 2:01 AM, Daniel Golle wrote:
> +static int mxl862xx_set_bridge_port(struct dsa_switch *ds, int port)
> +{
> + struct mxl862xx_bridge_port_config br_port_cfg = {};
> + struct dsa_port *dp = dsa_to_port(ds, port);
> + struct mxl862xx_priv *priv = ds->priv;
> + struct mxl862xx_port *p = &priv->ports[port];
> + u16 bridge_id = dp->bridge ?
> + priv->bridges[dp->bridge->num] : p->fid;
> + bool enable;
> + int i, idx;
> +
> + br_port_cfg.bridge_port_id = cpu_to_le16(port);
> + br_port_cfg.bridge_id = cpu_to_le16(bridge_id);
> + br_port_cfg.mask = cpu_to_le32(MXL862XX_BRIDGE_PORT_CONFIG_MASK_BRIDGE_ID |
> + MXL862XX_BRIDGE_PORT_CONFIG_MASK_BRIDGE_PORT_MAP |
> + MXL862XX_BRIDGE_PORT_CONFIG_MASK_MC_SRC_MAC_LEARNING |
> + MXL862XX_BRIDGE_PORT_CONFIG_MASK_EGRESS_SUB_METER);
AI reviews say:
Does this silently switch the hardware from Independent VLAN Learning
(IVL) to Shared VLAN Learning (SVL)? The mask no longer includes
MXL862XX_BRIDGE_PORT_CONFIG_MASK_VLAN_BASED_MAC_LEARNING, and the
vlan_src_mac_vid_enable and vlan_dst_mac_vid_enable fields are not set.
For a VLAN-aware bridge, this appears to break VLAN isolation
boundaries, as a MAC address learned on one VLAN could affect forwarding
decisions on other VLANs.
[ ... ]
> +static int mxl862xx_add_single_port_bridge(struct dsa_switch *ds, int port)
> +{
> + struct dsa_port *dp = dsa_to_port(ds, port);
> + struct mxl862xx_priv *priv = ds->priv;
> + int ret;
> +
> + ret = mxl862xx_allocate_bridge(priv, &priv->ports[port].fid);
> + if (ret) {
> + dev_err(ds->dev, "failed to allocate a bridge for port %d\n", port);
> + return ret;
> + }
> +
> + priv->ports[port].learning = false;
> + bitmap_zero(priv->ports[port].portmap, MXL862XX_MAX_BRIDGE_PORTS);
> + __set_bit(dp->cpu_dp->index, priv->ports[port].portmap);
> +
> + ret = mxl862xx_set_bridge_port(ds, port);
> + if (ret)
> + return ret;
AI review says:
If mxl862xx_set_bridge_port() fails, does this leak the newly allocated
hardware bridge? It looks like there is no call to mxl862xx_free_bridge()
on this error path.
[...]
> +static int mxl862xx_port_bridge_join(struct dsa_switch *ds, int port,
> + const struct dsa_bridge bridge,
> + bool *tx_fwd_offload,
> + struct netlink_ext_ack *extack)
> {
> - struct mxl862xx_bridge_port_config br_port_cfg = {};
> - struct dsa_port *dp = dsa_to_port(ds, port);
> - struct mxl862xx_bridge_alloc br_alloc = {};
> + struct mxl862xx_priv *priv = ds->priv;
> + u16 fw_id;
> int ret;
>
> - ret = MXL862XX_API_READ(ds->priv, MXL862XX_BRIDGE_ALLOC, br_alloc);
> - if (ret) {
> - dev_err(ds->dev, "failed to allocate a bridge for port %d\n", port);
> - return ret;
> + if (!priv->bridges[bridge.num]) {
> + ret = mxl862xx_allocate_bridge(priv, &fw_id);
> + if (ret)
> + return ret;
> +
> + priv->bridges[bridge.num] = fw_id;
> +
> + /* Free bridge here on error, DSA rollback won't. */
> + ret = mxl862xx_sync_bridge_members(ds, &bridge);
> + if (ret) {
> + mxl862xx_free_bridge(ds, &bridge);
> + return ret;
AI review says:
If mxl862xx_sync_bridge_members() encounters an error partway through
updating the ports in its loop, are the already-updated ports left pointing
to a bridge ID that is then freed here?
It seems the software portmaps and hardware states of the preceding ports
are not rolled back, which might leave them corrupted and permanently
referencing a freed bridge.
> + }
> +
> + return 0;
> }
>
> - br_port_cfg.bridge_id = br_alloc.bridge_id;
> - br_port_cfg.bridge_port_id = cpu_to_le16(port);
> - br_port_cfg.mask = cpu_to_le32(MXL862XX_BRIDGE_PORT_CONFIG_MASK_BRIDGE_ID |
> - MXL862XX_BRIDGE_PORT_CONFIG_MASK_BRIDGE_PORT_MAP |
> - MXL862XX_BRIDGE_PORT_CONFIG_MASK_MC_SRC_MAC_LEARNING |
> - MXL862XX_BRIDGE_PORT_CONFIG_MASK_VLAN_BASED_MAC_LEARNING);
> - br_port_cfg.src_mac_learning_disable = true;
> - br_port_cfg.vlan_src_mac_vid_enable = false;
> - br_port_cfg.vlan_dst_mac_vid_enable = false;
> - /* As this function is only called for user ports it is safe to rely on
> - * cpu_dp being valid
> - */
> - br_port_cfg.bridge_port_map[0] = cpu_to_le16(BIT(dp->cpu_dp->index));
> + return mxl862xx_sync_bridge_members(ds, &bridge);
> +}
> +
> +static void mxl862xx_port_bridge_leave(struct dsa_switch *ds, int port,
> + const struct dsa_bridge bridge)
> +{
> + struct dsa_port *dp = dsa_to_port(ds, port);
> + struct mxl862xx_priv *priv = ds->priv;
> + struct mxl862xx_port *p = &priv->ports[port];
> + int err;
> +
> + err = mxl862xx_sync_bridge_members(ds, &bridge);
> + if (err)
> + dev_err(ds->dev,
> + "failed to sync bridge members after port %d left: %pe\n",
> + port, ERR_PTR(err));
AI review says:
Is the leaving port still present in dp->bridge when this function is
called?
The DSA core typically clears dp->bridge after the leave callback returns.
If so, mxl862xx_sync_bridge_members() would still iterate over the
leaving port and incorrectly add it to the hardware portmaps of all
remaining bridge members.
>
> - return MXL862XX_API_WRITE(ds->priv, MXL862XX_BRIDGEPORT_CONFIGSET, br_port_cfg);
> + /* Revert leaving port, omitted by the sync above, to its
> + * single-port bridge
> + */
> + bitmap_zero(p->portmap, MXL862XX_MAX_BRIDGE_PORTS);
> + __set_bit(dp->cpu_dp->index, p->portmap);
> + p->flood_block = 0;
> + err = mxl862xx_set_bridge_port(ds, port);
AI review says:
Could there be two issues during this revert?
First, if dp->bridge is still set as noted above, mxl862xx_set_bridge_port()
will evaluate dp->bridge to true and use the shared bridge's hardware FID
instead of the port's standalone FID, keeping the port assigned to the
shared bridge.
Second, if learning was enabled while the port was in the bridge,
p->learning
remains true here. Should p->learning be set to false when the port reverts
to a standalone port to prevent inappropriate MAC learning?
^ permalink raw reply
* RE: [PATCH net] tipc: fix UAF in tipc_buf_append via tipc_msg_validate
From: Tung Quang Nguyen @ 2026-03-31 9:38 UTC (permalink / raw)
To: nicholas@carlini.com
Cc: Jon Maloy, stable@vger.kernel.org, netdev@vger.kernel.org
In-Reply-To: <20260330205313.2433372-1-nicholas@carlini.com>
>Subject: [PATCH net] tipc: fix UAF in tipc_buf_append via tipc_msg_validate
Please remove "via tipc_msg_validate". It gives wrong impression that the fix could be done in tipc_msg_validate().
>
>From: Nicholas Carlini <nicholas@carlini.com>
>
>tipc_buf_append() passes the address of a local variable `head` to
>tipc_msg_validate(). When the flow-control ratio check in
>tipc_msg_validate() fires, it frees the original skb and updates *_skb to point to
>a new copy -- but this only updates the local `head`, not *headbuf. If validation
>subsequently fails (e.g. the reassembled message has an invalid TIPC version),
>the err path calls kfree_skb(*headbuf) on the already-freed skb. The
>replacement skb is also leaked.
>
>A remote attacker with an established TIPC link over a UDP bearer can trigger
>this by sending a sequence of MSG_FRAGMENTER packets crafted to inflate the
>reassembled skb's truesize relative to its length past the ratio threshold, with
>an invalid version field in the inner message.
>
>Fix by passing headbuf directly to tipc_msg_validate() so the pointer update
>propagates correctly.
>
>Fixes: d618d09a68e4 ("tipc: enforce valid ratio between skb truesize and
>contents")
>Cc: stable@vger.kernel.org
>Signed-off-by: Nicholas Carlini <nicholas@carlini.com>
>---
> net/tipc/msg.c | 3 ++-
> 1 file changed, 2 insertions(+), 1 deletion(-)
>
>diff --git a/net/tipc/msg.c b/net/tipc/msg.c index 76284fc53..9f4f612ee 100644
>--- a/net/tipc/msg.c
>+++ b/net/tipc/msg.c
>@@ -177,8 +177,9 @@ int tipc_buf_append(struct sk_buff **headbuf, struct
>sk_buff **buf)
>
> if (fragid == LAST_FRAGMENT) {
> TIPC_SKB_CB(head)->validated = 0;
>- if (unlikely(!tipc_msg_validate(&head)))
>+ if (unlikely(!tipc_msg_validate(headbuf)))
> goto err;
>+ head = *headbuf;
This fix is not optimal because it adds overhead to normal path. This patch is better, I think:
diff --git a/net/tipc/msg.c b/net/tipc/msg.c
index 76284fc538eb..01a693559589 100644
--- a/net/tipc/msg.c
+++ b/net/tipc/msg.c
@@ -177,8 +177,19 @@ int tipc_buf_append(struct sk_buff **headbuf, struct sk_buff **buf)
if (fragid == LAST_FRAGMENT) {
TIPC_SKB_CB(head)->validated = 0;
- if (unlikely(!tipc_msg_validate(&head)))
+ if (unlikely(!tipc_msg_validate(&head))) {
+ /* reassembled skb has been freed in
+ * tipc_msg_validate() because of invalid truesize.
+ * head now points to newly-allocated reassembled skb
+ * while *headbuf points to freed reassembled skb.
+ * So, correct *headbuf for freeing newly-allocated
+ * reassembled skb later.
+ */
+ if (head != *headbuf)
+ *headbuf = head;
+
goto err;
+ }
*buf = head;
TIPC_SKB_CB(head)->tail = NULL;
*headbuf = NULL;
> *buf = head;
> TIPC_SKB_CB(head)->tail = NULL;
> *headbuf = NULL;
>--
>2.43.0
>
^ permalink raw reply related
* Re: [PATCH net-next] net: mana: hardening: Reject zero max_num_queues from MANA_QUERY_VPORT_CONFIG
From: Paolo Abeni @ 2026-03-31 9:33 UTC (permalink / raw)
To: Erni Sri Satya Vennela, kys, haiyangz, wei.liu, decui, longli,
andrew+netdev, davem, edumazet, kuba, ssengar, dipayanroy,
gargaditya, shirazsaleem, kees, linux-hyperv, netdev,
linux-kernel
In-Reply-To: <20260326174815.2012137-1-ernis@linux.microsoft.com>
On 3/26/26 6:48 PM, Erni Sri Satya Vennela wrote:
> As a part of MANA hardening for CVM, validate that max_num_sq and
> max_num_rq returned by MANA_QUERY_VPORT_CONFIG are not zero. These
> values flow into apc->num_queues, which is used as an allocation count
> and loop bound. A zero value would result in zero-size allocations and
> incorrect driver behavior.
>
> Return -EPROTO if either value is zero.
>
> Signed-off-by: Erni Sri Satya Vennela <ernis@linux.microsoft.com>
> ---
> drivers/net/ethernet/microsoft/mana/mana_en.c | 6 ++++++
> 1 file changed, 6 insertions(+)
>
> diff --git a/drivers/net/ethernet/microsoft/mana/mana_en.c b/drivers/net/ethernet/microsoft/mana/mana_en.c
> index b39e8b920791..a4197b4b0597 100644
> --- a/drivers/net/ethernet/microsoft/mana/mana_en.c
> +++ b/drivers/net/ethernet/microsoft/mana/mana_en.c
> @@ -1249,6 +1249,12 @@ static int mana_query_vport_cfg(struct mana_port_context *apc, u32 vport_index,
>
> *max_sq = resp.max_num_sq;
> *max_rq = resp.max_num_rq;
> +
> + if (*max_sq == 0 || *max_rq == 0) {
> + netdev_err(apc->ndev, "Invalid max queues from vPort config\n");
> + return -EPROTO;
AI review says:
Will returning -EPROTO here expose a pre-existing resource leak in the
driver's teardown path?
If mana_query_vport_cfg() returns an error, mana_init_port() fails and
mana_probe_port() frees the ndev, leaving ac->ports[i] as NULL. In
mana_probe(), the port initialization loop breaks upon this error, but
the err variable is then overwritten:
mana_probe() {
...
for (i = 0; i < ac->num_ports; i++) {
err = mana_probe_port(ac, i, &ac->ports[i]);
if (err) {
dev_err(dev, "Probe Failed for port %d\n", i);
break;
}
}
err = add_adev(gd, "eth");
...
}
If add_adev() succeeds, mana_probe() completes successfully instead of
failing, masking the earlier error while leaving ac->ports[0] as NULL.
Later, when the driver is unloaded or if add_adev() fails and triggers
immediate cleanup, mana_remove() is called. It iterates over ac->ports
and, upon encountering the NULL device, immediately executes goto out:
mana_remove() {
...
for (i = 0; i < ac->num_ports; i++) {
ndev = ac->ports[i];
if (!ndev) {
if (i == 0)
...
goto out;
}
...
}
mana_destroy_eq(ac);
out:
...
}
Because the out label in mana_remove() is located after the
mana_destroy_eq(ac) call, jumping there completely skips destroying the
event queues allocated earlier by mana_create_eq(ac).
In a Confidential Virtual Machine context, could an untrusted hypervisor
repeatedly return invalid configs to continuously leak guest memory and
hardware queues?
^ permalink raw reply
* Re: [PATCH net-next] net: mana: hardening: Validate adapter_mtu from MANA_QUERY_DEV_CONFIG
From: Paolo Abeni @ 2026-03-31 9:28 UTC (permalink / raw)
To: Erni Sri Satya Vennela, kys, haiyangz, wei.liu, decui, longli,
andrew+netdev, davem, edumazet, kuba, ssengar, dipayanroy,
gargaditya, shirazsaleem, kees, linux-hyperv, netdev,
linux-kernel
In-Reply-To: <20260326173101.2010514-1-ernis@linux.microsoft.com>
On 3/26/26 6:30 PM, Erni Sri Satya Vennela wrote:
> As a part of MANA hardening for CVM, validate the adapter_mtu value
> returned from the MANA_QUERY_DEV_CONFIG HWC command.
>
> The adapter_mtu value is used to compute ndev->max_mtu via:
> gc->adapter_mtu - ETH_HLEN. If hardware returns a bogus adapter_mtu
> smaller than ETH_HLEN (e.g. 0), the unsigned subtraction wraps to a
> huge value, silently allowing oversized MTU settings.
>
> Add a validation check to reject adapter_mtu values below
> ETH_MIN_MTU + ETH_HLEN, returning -EPROTO to fail the device
> configuration early with a clear error message.
>
> Signed-off-by: Erni Sri Satya Vennela <ernis@linux.microsoft.com>
> ---
> drivers/net/ethernet/microsoft/mana/mana_en.c | 10 ++++++++--
> 1 file changed, 8 insertions(+), 2 deletions(-)
>
> diff --git a/drivers/net/ethernet/microsoft/mana/mana_en.c b/drivers/net/ethernet/microsoft/mana/mana_en.c
> index b39e8b920791..bd07d17a6017 100644
> --- a/drivers/net/ethernet/microsoft/mana/mana_en.c
> +++ b/drivers/net/ethernet/microsoft/mana/mana_en.c
> @@ -1207,10 +1207,16 @@ static int mana_query_device_cfg(struct mana_context *ac, u32 proto_major_ver,
>
> *max_num_vports = resp.max_num_vports;
>
> - if (resp.hdr.response.msg_version >= GDMA_MESSAGE_V2)
> + if (resp.hdr.response.msg_version >= GDMA_MESSAGE_V2) {
> + if (resp.adapter_mtu < ETH_MIN_MTU + ETH_HLEN) {
> + dev_err(dev, "Adapter MTU too small: %u\n",
> + resp.adapter_mtu);
> + return -EPROTO;
AI review says:
If this returns -EPROTO, does the caller mana_probe() jump to an error
label and call mana_remove()?
If so, mana_remove() unconditionally calls
disable_work_sync(&ac->link_change_work) and
cancel_delayed_work_sync(&ac->gf_stats_work).
Since mana_query_device_cfg() is called before INIT_WORK() and
INIT_DELAYED_WORK() in the probe sequence, wouldn't this result in
calling sync cancellation functions on uninitialized, zeroed work
structures?
This can lead to a WARN_ON(!work->func) in __flush_work(), or debug
object warnings if CONFIG_DEBUG_OBJECTS_WORK is enabled.
While this initialization issue appears to already exist for other early
error paths, this new error path can also trigger it.
^ permalink raw reply
* [PATCH v2] xfrm: delay dev_put in xfrm_input to after transport reinject
From: Qi Tang @ 2026-03-31 9:27 UTC (permalink / raw)
To: Steffen Klassert, Herbert Xu
Cc: David S . Miller, Eric Dumazet, Jakub Kicinski, Paolo Abeni,
Simon Horman, David Ahern, netdev, Qi Tang, stable
xfrm_trans_queue() queues transport-mode packets for async reinject
via xfrm_trans_reinject() workqueue. After async crypto completes,
xfrm_input_resume() re-enters xfrm_input() with encap_type == -1,
which immediately calls dev_put(skb->dev) before the skb reaches
transport_finish and the reinject queue. The device can be freed
before the workqueue callback runs, causing a use-after-free when
xfrm_trans_reinject dereferences skb->dev.
Remove the dev_put from the async resumption entry and let the
reference survive through the transport reinject path. Introduce
async variants of the NF_HOOK okfn callbacks that queue the skb
with dev_held=true and drop the reference on error. The reinject
worker checks this flag and puts the reference after the callback
completes.
For the synchronous crypto path, the existing dev_hold/dev_put
around x->type->input() is unchanged — the reference is balanced
within the same softirq context before the skb reaches the queue.
If the loop re-enters async crypto (multi-SPI with a second
-EINPROGRESS), drop the extra reference from the earlier async
resume so exactly one reference accompanies the skb.
Fixes: acf568ee859f ("xfrm: Reinject transport-mode packets through tasklet")
Cc: stable@vger.kernel.org
Signed-off-by: Qi Tang <tpluszz77@gmail.com>
---
Changes in v2:
- Do not add extra dev_hold/dev_put pair (reviewer feedback:
"expensive operation, we just drop it too early")
- Reuse existing dev_hold from xfrm_input, delay dev_put to
reinject completion
- Add async okfn variants for IPv4/IPv6 transport_finish so
the reinject queue knows whether a dev ref is held
- Drop the cb->dev field from v1; use bool dev_held flag instead
Link: https://lore.kernel.org/all/20260320073023.21873-1-tpluszz77@gmail.com/
---
include/net/xfrm.h | 3 ++-
net/ipv4/esp4.c | 3 ++-
net/ipv4/xfrm4_input.c | 25 ++++++++++++++++++++++++-
net/ipv6/esp6.c | 3 ++-
net/ipv6/xfrm6_input.c | 16 +++++++++++++++-
net/xfrm/xfrm_input.c | 35 ++++++++++++++++++++++++++---------
6 files changed, 71 insertions(+), 14 deletions(-)
diff --git a/include/net/xfrm.h b/include/net/xfrm.h
index 10d3edde6b2f..1dd8b3b36649 100644
--- a/include/net/xfrm.h
+++ b/include/net/xfrm.h
@@ -1779,7 +1779,8 @@ int xfrm_input(struct sk_buff *skb, int nexthdr, __be32 spi, int encap_type);
int xfrm_input_resume(struct sk_buff *skb, int nexthdr);
int xfrm_trans_queue_net(struct net *net, struct sk_buff *skb,
int (*finish)(struct net *, struct sock *,
- struct sk_buff *));
+ struct sk_buff *),
+ bool dev_held);
int xfrm_trans_queue(struct sk_buff *skb,
int (*finish)(struct net *, struct sock *,
struct sk_buff *));
diff --git a/net/ipv4/esp4.c b/net/ipv4/esp4.c
index 6dfc0bcdef65..0114c92b10d4 100644
--- a/net/ipv4/esp4.c
+++ b/net/ipv4/esp4.c
@@ -187,7 +187,8 @@ static int esp_output_tail_tcp(struct xfrm_state *x, struct sk_buff *skb)
int err;
local_bh_disable();
- err = xfrm_trans_queue_net(xs_net(x), skb, esp_output_tcp_encap_cb);
+ err = xfrm_trans_queue_net(xs_net(x), skb, esp_output_tcp_encap_cb,
+ false);
local_bh_enable();
/* EINPROGRESS just happens to do the right thing. It
diff --git a/net/ipv4/xfrm4_input.c b/net/ipv4/xfrm4_input.c
index f28cfd88eaf5..9765fdc63ffc 100644
--- a/net/ipv4/xfrm4_input.c
+++ b/net/ipv4/xfrm4_input.c
@@ -46,6 +46,28 @@ static inline int xfrm4_rcv_encap_finish(struct net *net, struct sock *sk,
return NET_RX_DROP;
}
+static int xfrm4_rcv_encap_finish_async(struct net *net, struct sock *sk,
+ struct sk_buff *skb)
+{
+ if (!skb_dst(skb)) {
+ const struct iphdr *iph = ip_hdr(skb);
+
+ if (ip_route_input_noref(skb, iph->daddr, iph->saddr,
+ ip4h_dscp(iph), skb->dev))
+ goto drop;
+ }
+
+ if (xfrm_trans_queue_net(dev_net(skb->dev), skb,
+ xfrm4_rcv_encap_finish2, true))
+ goto drop;
+
+ return 0;
+drop:
+ dev_put(skb->dev);
+ kfree_skb(skb);
+ return NET_RX_DROP;
+}
+
int xfrm4_transport_finish(struct sk_buff *skb, int async)
{
struct xfrm_offload *xo = xfrm_offload(skb);
@@ -74,7 +96,8 @@ int xfrm4_transport_finish(struct sk_buff *skb, int async)
NF_HOOK(NFPROTO_IPV4, NF_INET_PRE_ROUTING,
dev_net(skb->dev), NULL, skb, skb->dev, NULL,
- xfrm4_rcv_encap_finish);
+ async ? xfrm4_rcv_encap_finish_async :
+ xfrm4_rcv_encap_finish);
return 0;
}
diff --git a/net/ipv6/esp6.c b/net/ipv6/esp6.c
index 9f75313734f8..8a0a44d7d010 100644
--- a/net/ipv6/esp6.c
+++ b/net/ipv6/esp6.c
@@ -204,7 +204,8 @@ static int esp_output_tail_tcp(struct xfrm_state *x, struct sk_buff *skb)
int err;
local_bh_disable();
- err = xfrm_trans_queue_net(xs_net(x), skb, esp_output_tcp_encap_cb);
+ err = xfrm_trans_queue_net(xs_net(x), skb, esp_output_tcp_encap_cb,
+ false);
local_bh_enable();
/* EINPROGRESS just happens to do the right thing. It
diff --git a/net/ipv6/xfrm6_input.c b/net/ipv6/xfrm6_input.c
index 9005fc156a20..d4eede5315ac 100644
--- a/net/ipv6/xfrm6_input.c
+++ b/net/ipv6/xfrm6_input.c
@@ -40,6 +40,19 @@ static int xfrm6_transport_finish2(struct net *net, struct sock *sk,
return 0;
}
+static int xfrm6_transport_finish2_async(struct net *net, struct sock *sk,
+ struct sk_buff *skb)
+{
+ if (xfrm_trans_queue_net(dev_net(skb->dev), skb, ip6_rcv_finish,
+ true)) {
+ dev_put(skb->dev);
+ kfree_skb(skb);
+ return NET_RX_DROP;
+ }
+
+ return 0;
+}
+
int xfrm6_transport_finish(struct sk_buff *skb, int async)
{
struct xfrm_offload *xo = xfrm_offload(skb);
@@ -69,7 +82,8 @@ int xfrm6_transport_finish(struct sk_buff *skb, int async)
NF_HOOK(NFPROTO_IPV6, NF_INET_PRE_ROUTING,
dev_net(skb->dev), NULL, skb, skb->dev, NULL,
- xfrm6_transport_finish2);
+ async ? xfrm6_transport_finish2_async :
+ xfrm6_transport_finish2);
return 0;
}
diff --git a/net/xfrm/xfrm_input.c b/net/xfrm/xfrm_input.c
index dc1312ed5a09..2d75f984532a 100644
--- a/net/xfrm/xfrm_input.c
+++ b/net/xfrm/xfrm_input.c
@@ -40,6 +40,7 @@ struct xfrm_trans_cb {
} header;
int (*finish)(struct net *net, struct sock *sk, struct sk_buff *skb);
struct net *net;
+ bool dev_held;
};
#define XFRM_TRANS_SKB_CB(__skb) ((struct xfrm_trans_cb *)&((__skb)->cb[0]))
@@ -506,7 +507,6 @@ int xfrm_input(struct sk_buff *skb, int nexthdr, __be32 spi, int encap_type)
/* An encap_type of -1 indicates async resumption. */
if (encap_type == -1) {
async = 1;
- dev_put(skb->dev);
seq = XFRM_SKB_CB(skb)->seq.input.low;
spin_lock(&x->lock);
goto resume;
@@ -659,8 +659,11 @@ int xfrm_input(struct sk_buff *skb, int nexthdr, __be32 spi, int encap_type)
dev_hold(skb->dev);
nexthdr = x->type->input(x, skb);
- if (nexthdr == -EINPROGRESS)
+ if (nexthdr == -EINPROGRESS) {
+ if (async)
+ dev_put(skb->dev);
return 0;
+ }
dev_put(skb->dev);
spin_lock(&x->lock);
@@ -695,9 +698,11 @@ int xfrm_input(struct sk_buff *skb, int nexthdr, __be32 spi, int encap_type)
XFRM_MODE_SKB_CB(skb)->protocol = nexthdr;
err = xfrm_inner_mode_input(x, skb);
- if (err == -EINPROGRESS)
+ if (err == -EINPROGRESS) {
+ if (async)
+ dev_put(skb->dev);
return 0;
- else if (err) {
+ } else if (err) {
XFRM_INC_STATS(net, LINUX_MIB_XFRMINSTATEMODEERROR);
goto drop;
}
@@ -734,6 +739,8 @@ int xfrm_input(struct sk_buff *skb, int nexthdr, __be32 spi, int encap_type)
sp->olen = 0;
if (skb_valid_dst(skb))
skb_dst_drop(skb);
+ if (async)
+ dev_put(skb->dev);
gro_cells_receive(&gro_cells, skb);
return 0;
} else {
@@ -753,6 +760,8 @@ int xfrm_input(struct sk_buff *skb, int nexthdr, __be32 spi, int encap_type)
sp->olen = 0;
if (skb_valid_dst(skb))
skb_dst_drop(skb);
+ if (async)
+ dev_put(skb->dev);
gro_cells_receive(&gro_cells, skb);
return err;
}
@@ -763,6 +772,8 @@ int xfrm_input(struct sk_buff *skb, int nexthdr, __be32 spi, int encap_type)
drop_unlock:
spin_unlock(&x->lock);
drop:
+ if (async)
+ dev_put(skb->dev);
xfrm_rcv_cb(skb, family, x && x->type ? x->type->proto : nexthdr, -1);
kfree_skb(skb);
return 0;
@@ -787,15 +798,20 @@ static void xfrm_trans_reinject(struct work_struct *work)
spin_unlock_bh(&trans->queue_lock);
local_bh_disable();
- while ((skb = __skb_dequeue(&queue)))
- XFRM_TRANS_SKB_CB(skb)->finish(XFRM_TRANS_SKB_CB(skb)->net,
- NULL, skb);
+ while ((skb = __skb_dequeue(&queue))) {
+ struct xfrm_trans_cb *cb = XFRM_TRANS_SKB_CB(skb);
+ struct net_device *dev = cb->dev_held ? skb->dev : NULL;
+
+ cb->finish(cb->net, NULL, skb);
+ dev_put(dev);
+ }
local_bh_enable();
}
int xfrm_trans_queue_net(struct net *net, struct sk_buff *skb,
int (*finish)(struct net *, struct sock *,
- struct sk_buff *))
+ struct sk_buff *),
+ bool dev_held)
{
struct xfrm_trans_tasklet *trans;
@@ -808,6 +824,7 @@ int xfrm_trans_queue_net(struct net *net, struct sk_buff *skb,
XFRM_TRANS_SKB_CB(skb)->finish = finish;
XFRM_TRANS_SKB_CB(skb)->net = net;
+ XFRM_TRANS_SKB_CB(skb)->dev_held = dev_held;
spin_lock_bh(&trans->queue_lock);
__skb_queue_tail(&trans->queue, skb);
spin_unlock_bh(&trans->queue_lock);
@@ -820,7 +837,7 @@ int xfrm_trans_queue(struct sk_buff *skb,
int (*finish)(struct net *, struct sock *,
struct sk_buff *))
{
- return xfrm_trans_queue_net(dev_net(skb->dev), skb, finish);
+ return xfrm_trans_queue_net(dev_net(skb->dev), skb, finish, false);
}
EXPORT_SYMBOL(xfrm_trans_queue);
--
2.43.0
^ permalink raw reply related
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox