* [PATCH net-next v2 1/4] amd-xgbe: do not select NET_SELFTESTS when INET is disabled
2026-02-03 14:56 [PATCH net-next v2 0/4] amd-xgbe: add ARP offload and RSS self-tests Raju Rangoju
@ 2026-02-03 14:56 ` Raju Rangoju
2026-02-03 14:56 ` [PATCH net-next v2 2/4] amd-xgbe: add hardware ARP offload support Raju Rangoju
` (2 subsequent siblings)
3 siblings, 0 replies; 5+ messages in thread
From: Raju Rangoju @ 2026-02-03 14:56 UTC (permalink / raw)
To: netdev
Cc: horms, pabeni, kuba, edumazet, davem, andrew+netdev, linux-kernel,
Shyam-sundar.S-k, Raju Rangoju, kernel test robot
AMD_XGBE currently selects NET_SELFTESTS unconditionally. Since select
does not honor dependencies, this can force-enable NET_SELFTESTS even
when INET is disabled (e.g. INET=n randconfig builds).
Fixes build issue when INET is disabled.
Fixes: 862a64c83faf ("amd-xgbe: introduce support ethtool selftest")
Reported-by: kernel test robot <lkp@intel.com>
Closes: https://lore.kernel.org/oe-kbuild-all/202602030920.SWN7cwzT-lkp@intel.com/
Signed-off-by: Raju Rangoju <Raju.Rangoju@amd.com>
---
Changes since v1:
- Added this patch to address the build failure reported by the kernel test robot.
drivers/net/ethernet/amd/Kconfig | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/drivers/net/ethernet/amd/Kconfig b/drivers/net/ethernet/amd/Kconfig
index d54dca3074eb..45e8d698781c 100644
--- a/drivers/net/ethernet/amd/Kconfig
+++ b/drivers/net/ethernet/amd/Kconfig
@@ -165,7 +165,7 @@ config AMD_XGBE
select CRC32
select PHYLIB
select AMD_XGBE_HAVE_ECC if X86
- select NET_SELFTESTS
+ imply NET_SELFTESTS
help
This driver supports the AMD 10GbE Ethernet device found on an
AMD SoC.
--
2.34.1
^ permalink raw reply related [flat|nested] 5+ messages in thread* [PATCH net-next v2 2/4] amd-xgbe: add hardware ARP offload support
2026-02-03 14:56 [PATCH net-next v2 0/4] amd-xgbe: add ARP offload and RSS self-tests Raju Rangoju
2026-02-03 14:56 ` [PATCH net-next v2 1/4] amd-xgbe: do not select NET_SELFTESTS when INET is disabled Raju Rangoju
@ 2026-02-03 14:56 ` Raju Rangoju
2026-02-03 14:56 ` [PATCH net-next v2 3/4] amd-xgbe: add ARP offload ethtool self-test Raju Rangoju
2026-02-03 14:56 ` [PATCH net-next v2 4/4] amd-xgbe: add RSS " Raju Rangoju
3 siblings, 0 replies; 5+ messages in thread
From: Raju Rangoju @ 2026-02-03 14:56 UTC (permalink / raw)
To: netdev
Cc: horms, pabeni, kuba, edumazet, davem, andrew+netdev, linux-kernel,
Shyam-sundar.S-k, Raju Rangoju
Add ARP offload functionality to the XGBE driver that enables the MAC
hardware to automatically respond to ARP requests without CPU
intervention, reducing system latency and power consumption.
The XGBE MAC supports ARP offloading through:
- MAC_ARP_ADDR register (offset 0x0c10): stores the IPv4 address for
which the hardware should respond to ARP requests
- ARPEN bit in MAC_RCR register (bit 31): enables/disables the ARP
offload feature
When enabled, the MAC hardware will automatically generate ARP replies
for requests targeting the configured IP address, without involving
the host CPU.
The feature requires the aoe (ARP Offload Engine) hardware capability
bit (ARPOFFSEL) to be set in the MAC_HWF0R register, which is checked
before enabling.
Signed-off-by: Raju Rangoju <Raju.Rangoju@amd.com>
---
drivers/net/ethernet/amd/xgbe/xgbe-common.h | 3 +++
drivers/net/ethernet/amd/xgbe/xgbe-dev.c | 24 +++++++++++++++++++++
drivers/net/ethernet/amd/xgbe/xgbe.h | 4 ++++
3 files changed, 31 insertions(+)
diff --git a/drivers/net/ethernet/amd/xgbe/xgbe-common.h b/drivers/net/ethernet/amd/xgbe/xgbe-common.h
index 711f295eb777..522e71f2d6e1 100644
--- a/drivers/net/ethernet/amd/xgbe/xgbe-common.h
+++ b/drivers/net/ethernet/amd/xgbe/xgbe-common.h
@@ -210,6 +210,7 @@
#define MAC_MACA0LR 0x0304
#define MAC_MACA1HR 0x0308
#define MAC_MACA1LR 0x030c
+#define MAC_ARP_ADDR 0x0c10
#define MAC_RSSCR 0x0c80
#define MAC_RSSAR 0x0c88
#define MAC_RSSDR 0x0c8c
@@ -400,6 +401,8 @@
#define MAC_RCR_RE_WIDTH 1
#define MAC_RCR_GPSL_INDEX 16
#define MAC_RCR_GPSL_WIDTH 14
+#define MAC_RCR_ARPEN_INDEX 31
+#define MAC_RCR_ARPEN_WIDTH 1
#define MAC_RFCR_PFCE_INDEX 8
#define MAC_RFCR_PFCE_WIDTH 1
#define MAC_RFCR_RFE_INDEX 0
diff --git a/drivers/net/ethernet/amd/xgbe/xgbe-dev.c b/drivers/net/ethernet/amd/xgbe/xgbe-dev.c
index c04a9c76bd40..c9243b4d7682 100644
--- a/drivers/net/ethernet/amd/xgbe/xgbe-dev.c
+++ b/drivers/net/ethernet/amd/xgbe/xgbe-dev.c
@@ -3605,3 +3605,27 @@ void xgbe_disable_mac_loopback(struct xgbe_prv_data *pdata)
/* Disable MAC loopback mode */
XGMAC_IOWRITE_BITS(pdata, MAC_RCR, LM, 0);
}
+
+/**
+ * xgbe_enable_arp_offload - Enable hardware ARP offload
+ * @pdata: pointer to driver private data
+ * @ip_addr: IPv4 address (in host byte order) to respond to ARP requests
+ *
+ * Configures the MAC to automatically respond to ARP requests for the
+ * specified IP address without CPU intervention.
+ */
+void xgbe_enable_arp_offload(struct xgbe_prv_data *pdata, u32 ip_addr)
+{
+ XGMAC_IOWRITE(pdata, MAC_ARP_ADDR, ip_addr);
+ XGMAC_IOWRITE_BITS(pdata, MAC_RCR, ARPEN, 1);
+}
+
+/**
+ * xgbe_disable_arp_offload - Disable hardware ARP offload
+ * @pdata: pointer to driver private data
+ */
+void xgbe_disable_arp_offload(struct xgbe_prv_data *pdata)
+{
+ XGMAC_IOWRITE_BITS(pdata, MAC_RCR, ARPEN, 0);
+ XGMAC_IOWRITE(pdata, MAC_ARP_ADDR, 0);
+}
diff --git a/drivers/net/ethernet/amd/xgbe/xgbe.h b/drivers/net/ethernet/amd/xgbe/xgbe.h
index 1269b8ce9249..a44973ae21a2 100644
--- a/drivers/net/ethernet/amd/xgbe/xgbe.h
+++ b/drivers/net/ethernet/amd/xgbe/xgbe.h
@@ -1334,6 +1334,10 @@ int xgbe_selftest_get_count(struct xgbe_prv_data *pdata);
int xgbe_enable_mac_loopback(struct xgbe_prv_data *pdata);
void xgbe_disable_mac_loopback(struct xgbe_prv_data *pdata);
+/* ARP offload */
+void xgbe_enable_arp_offload(struct xgbe_prv_data *pdata, u32 ip_addr);
+void xgbe_disable_arp_offload(struct xgbe_prv_data *pdata);
+
#ifdef CONFIG_DEBUG_FS
void xgbe_debugfs_init(struct xgbe_prv_data *);
void xgbe_debugfs_exit(struct xgbe_prv_data *);
--
2.34.1
^ permalink raw reply related [flat|nested] 5+ messages in thread* [PATCH net-next v2 3/4] amd-xgbe: add ARP offload ethtool self-test
2026-02-03 14:56 [PATCH net-next v2 0/4] amd-xgbe: add ARP offload and RSS self-tests Raju Rangoju
2026-02-03 14:56 ` [PATCH net-next v2 1/4] amd-xgbe: do not select NET_SELFTESTS when INET is disabled Raju Rangoju
2026-02-03 14:56 ` [PATCH net-next v2 2/4] amd-xgbe: add hardware ARP offload support Raju Rangoju
@ 2026-02-03 14:56 ` Raju Rangoju
2026-02-03 14:56 ` [PATCH net-next v2 4/4] amd-xgbe: add RSS " Raju Rangoju
3 siblings, 0 replies; 5+ messages in thread
From: Raju Rangoju @ 2026-02-03 14:56 UTC (permalink / raw)
To: netdev
Cc: horms, pabeni, kuba, edumazet, davem, andrew+netdev, linux-kernel,
Shyam-sundar.S-k, Raju Rangoju
Add an ethtool self-test to verify the hardware ARP offload
functionality. The test validates that the MAC correctly responds
to ARP requests without CPU intervention.
Test procedure:
1. Check for aoe (ARP Offload Engine) hardware capability
2. Create an ARP request packet with test IP addresses
3. Enable ARP offload with the target IP address
4. Transmit the ARP request in PHY loopback mode
5. Verify that an ARP reply is received from the hardware
6. Clean up and restore configuration
The test requires the device to be in PHY loopback mode and runs as part
of offline ethtool self-test suite.
Usage:
$ ethtool -t <interface>
Signed-off-by: Raju Rangoju <Raju.Rangoju@amd.com>
---
Changes since v1:
- Use link-local IPs (169.254.x.x) for ARP test to avoid interfering with real network configuration.
- Improved error handling and resource cleanup.
drivers/net/ethernet/amd/xgbe/xgbe-selftest.c | 121 +++++++++++++++++-
1 file changed, 120 insertions(+), 1 deletion(-)
diff --git a/drivers/net/ethernet/amd/xgbe/xgbe-selftest.c b/drivers/net/ethernet/amd/xgbe/xgbe-selftest.c
index 55e5e467facd..b57826a91361 100644
--- a/drivers/net/ethernet/amd/xgbe/xgbe-selftest.c
+++ b/drivers/net/ethernet/amd/xgbe/xgbe-selftest.c
@@ -29,6 +29,121 @@ struct xgbe_test {
static u8 xgbe_test_id;
+/* Link-local test IPs to avoid interfering with real network config */
+#define XGBE_TEST_ARP_SRC_IP htonl(0xa9fe0101) /* 169.254.1.1 */
+#define XGBE_TEST_ARP_DST_IP htonl(0xa9fe0102) /* 169.254.1.2 */
+
+static int xgbe_test_arp_validate(struct sk_buff *skb,
+ struct net_device *ndev,
+ struct packet_type *pt,
+ struct net_device *orig_ndev)
+{
+ struct net_test_priv *tdata = pt->af_packet_priv;
+ struct ethhdr *eth_hdr;
+ struct arphdr *ah;
+
+ skb = skb_unshare(skb, GFP_ATOMIC);
+ if (!skb)
+ goto out;
+
+ if (skb_linearize(skb))
+ goto out;
+
+ eth_hdr = (struct ethhdr *)skb_mac_header(skb);
+
+ /* Verify the reply is destined to our test source MAC */
+ if (!ether_addr_equal_unaligned(eth_hdr->h_dest, tdata->packet->src))
+ goto out;
+
+ /* Verify this is an ARP reply */
+ if (eth_hdr->h_proto != htons(ETH_P_ARP))
+ goto out;
+
+ ah = arp_hdr(skb);
+
+ /* Verify the ARP operation is a reply */
+ if (ah->ar_op != htons(ARPOP_REPLY))
+ goto out;
+
+ tdata->ok = true;
+ complete(&tdata->comp);
+out:
+ kfree_skb(skb);
+ return 0;
+}
+
+static int xgbe_test_arpoffload(struct xgbe_prv_data *pdata)
+{
+ unsigned char bcast[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
+ unsigned char src[ETH_ALEN] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05 };
+ struct net_packet_attrs attr = {};
+ struct net_test_priv *tdata;
+ bool pt_added = false;
+ struct sk_buff *skb;
+ int ret;
+
+ /* Check if ARP offload is supported */
+ if (!pdata->hw_feat.aoe)
+ return -EOPNOTSUPP;
+
+ tdata = kzalloc(sizeof(*tdata), GFP_KERNEL);
+ if (!tdata)
+ return -ENOMEM;
+
+ tdata->ok = false;
+ init_completion(&tdata->comp);
+
+ attr.src = src;
+ tdata->packet = &attr;
+
+ /* Build ARP request: who-has DST tell SRC */
+ skb = arp_create(ARPOP_REQUEST, ETH_P_ARP, XGBE_TEST_ARP_DST_IP,
+ pdata->netdev, XGBE_TEST_ARP_SRC_IP, NULL, src, bcast);
+ if (!skb) {
+ ret = -ENOMEM;
+ goto out_free;
+ }
+
+ tdata->pt.type = htons(ETH_P_ARP);
+ tdata->pt.func = xgbe_test_arp_validate;
+ tdata->pt.dev = pdata->netdev;
+ tdata->pt.af_packet_priv = tdata;
+ dev_add_pack(&tdata->pt);
+ pt_added = true;
+
+ /* Enable ARP offload */
+ xgbe_enable_arp_offload(pdata, ntohl(XGBE_TEST_ARP_DST_IP));
+
+ /* Set device to promiscuous to receive the ARP reply */
+ ret = dev_set_promiscuity(pdata->netdev, 1);
+ if (ret) {
+ netdev_err(pdata->netdev, "Failed to set promiscuous mode\n");
+ kfree(skb);
+ goto out_disable;
+ }
+
+ ret = dev_direct_xmit(skb, 0);
+ skb = NULL;
+ if (ret)
+ goto disable_promisc;
+
+ /* Wait for ARP reply */
+ wait_for_completion_timeout(&tdata->comp, NET_LB_TIMEOUT);
+ ret = tdata->ok ? 0 : -ETIMEDOUT;
+ if (ret)
+ netdev_err(pdata->netdev, "ARP Offload test timed out: ret %d\n", ret);
+
+disable_promisc:
+ dev_set_promiscuity(pdata->netdev, -1);
+out_disable:
+ xgbe_disable_arp_offload(pdata);
+ if (pt_added)
+ dev_remove_pack(&tdata->pt);
+out_free:
+ kfree(tdata);
+ return ret;
+}
+
static int xgbe_test_loopback_validate(struct sk_buff *skb,
struct net_device *ndev,
struct packet_type *pt,
@@ -251,7 +366,11 @@ static const struct xgbe_test xgbe_selftests[] = {
.name = "Jumbo Frame ",
.lb = XGBE_LOOPBACK_PHY,
.fn = xgbe_test_jumbo,
- },
+ }, {
+ .name = "ARP Offload ",
+ .lb = XGBE_LOOPBACK_PHY,
+ .fn = xgbe_test_arpoffload,
+ }
};
void xgbe_selftest_run(struct net_device *dev,
--
2.34.1
^ permalink raw reply related [flat|nested] 5+ messages in thread* [PATCH net-next v2 4/4] amd-xgbe: add RSS ethtool self-test
2026-02-03 14:56 [PATCH net-next v2 0/4] amd-xgbe: add ARP offload and RSS self-tests Raju Rangoju
` (2 preceding siblings ...)
2026-02-03 14:56 ` [PATCH net-next v2 3/4] amd-xgbe: add ARP offload ethtool self-test Raju Rangoju
@ 2026-02-03 14:56 ` Raju Rangoju
3 siblings, 0 replies; 5+ messages in thread
From: Raju Rangoju @ 2026-02-03 14:56 UTC (permalink / raw)
To: netdev
Cc: horms, pabeni, kuba, edumazet, davem, andrew+netdev, linux-kernel,
Shyam-sundar.S-k, Raju Rangoju
Add a Receive Side Scaling (RSS) self-test to the ethtool diagnostic
suite to verify that the hardware correctly computes hash values for
incoming packets.
The test validates RSS functionality by:
1. Checking for RSS hardware feature support (rss bit in MAC_HWF1R)
2. Sending a test packet with specific TCP/UDP ports to trigger
hash computation
3. Verifying that the received packet has a non-zero hash value
computed by the hardware
The test uses the existing loopback infrastructure and requires
PHY loopback mode. It uses specific port values (sport=0xabc,
dport=0xdef) to generate a deterministic hash that exercises
the RSS hash computation logic.
This test helps users verify that RSS is properly configured and
functioning, which is essential for multi-queue performance on
multi-core systems.
Usage:
$ ethtool -t <interface>
Signed-off-by: Raju Rangoju <Raju.Rangoju@amd.com>
---
drivers/net/ethernet/amd/xgbe/xgbe-selftest.c | 32 +++++++++++++++++++
include/net/selftests.h | 1 +
2 files changed, 33 insertions(+)
diff --git a/drivers/net/ethernet/amd/xgbe/xgbe-selftest.c b/drivers/net/ethernet/amd/xgbe/xgbe-selftest.c
index b57826a91361..a4e7decf768f 100644
--- a/drivers/net/ethernet/amd/xgbe/xgbe-selftest.c
+++ b/drivers/net/ethernet/amd/xgbe/xgbe-selftest.c
@@ -213,8 +213,13 @@ static int xgbe_test_loopback_validate(struct sk_buff *skb,
if (tdata->packet->id != hdr->id)
goto out;
+ /* Validate RSS hash if expected */
+ if (tdata->packet->exp_hash && !skb->hash)
+ goto out;
+
tdata->ok = true;
complete(&tdata->comp);
+
out:
kfree_skb(skb);
return 0;
@@ -267,6 +272,29 @@ static int __xgbe_test_loopback(struct xgbe_prv_data *pdata,
return ret;
}
+static int xgbe_test_rss(struct xgbe_prv_data *pdata)
+{
+ struct net_packet_attrs attr = {};
+ int ret;
+
+ /* Check for RSS hardware support */
+ if (!pdata->hw_feat.rss)
+ return -EOPNOTSUPP;
+
+ attr.dst = pdata->netdev->dev_addr;
+ /*
+ * Use specific port values to generate a hash.
+ * The asymmetric port values ensure the hash computation
+ * produces a non-zero result for test validation.
+ */
+ attr.sport = 0xabc;
+ attr.dport = 0xdef;
+ attr.exp_hash = true;
+ ret = __xgbe_test_loopback(pdata, &attr);
+
+ return ret;
+}
+
static int xgbe_test_mac_loopback(struct xgbe_prv_data *pdata)
{
struct net_packet_attrs attr = {};
@@ -370,6 +398,10 @@ static const struct xgbe_test xgbe_selftests[] = {
.name = "ARP Offload ",
.lb = XGBE_LOOPBACK_PHY,
.fn = xgbe_test_arpoffload,
+ }, {
+ .name = "RSS ",
+ .lb = XGBE_LOOPBACK_PHY,
+ .fn = xgbe_test_rss,
}
};
diff --git a/include/net/selftests.h b/include/net/selftests.h
index c36e07406ad4..18a9b4830dfc 100644
--- a/include/net/selftests.h
+++ b/include/net/selftests.h
@@ -19,6 +19,7 @@ struct net_packet_attrs {
u8 id;
u16 queue_mapping;
bool bad_csum;
+ u32 exp_hash;
};
struct net_test_priv {
--
2.34.1
^ permalink raw reply related [flat|nested] 5+ messages in thread