Commit 862a64c8 authored by Raju Rangoju's avatar Raju Rangoju Committed by Paolo Abeni
Browse files

amd-xgbe: introduce support ethtool selftest 



Add support for ethtool selftest for MAC loopback. This includes the
sanity check and helps in finding the misconfiguration of HW. Uses the
existing selftest infrastructure to create test packets.

Signed-off-by: default avatarRaju Rangoju <Raju.Rangoju@amd.com>
Reviewed-by: default avatarMaxime Chevallier <maxime.chevallier@bootlin.com>
Link: https://patch.msgid.link/20251031111555.774425-2-Raju.Rangoju@amd.com


Signed-off-by: default avatarPaolo Abeni <pabeni@redhat.com>
parent 6b47af35

drivers/net/ethernet/amd/Kconfig

+1 −0
Original line number Diff line number Diff line
@@ -165,6 +165,7 @@ config AMD_XGBE 
	select CRC32

	select PHYLIB

	select AMD_XGBE_HAVE_ECC if X86

	select NET_SELFTESTS

	help

	  This driver supports the AMD 10GbE Ethernet device found on an

	  AMD SoC.

drivers/net/ethernet/amd/xgbe/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -5,7 +5,7 @@ amd-xgbe-objs := xgbe-main.o xgbe-drv.o xgbe-dev.o \ 
		 xgbe-desc.o xgbe-ethtool.o xgbe-mdio.o \

		 xgbe-hwtstamp.o xgbe-ptp.o xgbe-pps.o \

		 xgbe-i2c.o xgbe-phy-v1.o xgbe-phy-v2.o \

		 xgbe-platform.o

		 xgbe-platform.o xgbe-selftest.o



amd-xgbe-$(CONFIG_PCI) += xgbe-pci.o

amd-xgbe-$(CONFIG_AMD_XGBE_DCB) += xgbe-dcb.o

drivers/net/ethernet/amd/xgbe/xgbe-dev.c

+17 −0
Original line number Diff line number Diff line
@@ -3578,3 +3578,20 @@ void xgbe_init_function_ptrs_dev(struct xgbe_hw_if *hw_if) 


	DBGPR("<--xgbe_init_function_ptrs\n");

}



int xgbe_enable_mac_loopback(struct xgbe_prv_data *pdata)

{

	/* Enable MAC loopback mode */

	XGMAC_IOWRITE_BITS(pdata, MAC_RCR, LM, 1);



	/* Wait for loopback to stabilize */

	usleep_range(10, 15);



	return 0;

}



void xgbe_disable_mac_loopback(struct xgbe_prv_data *pdata)

{

	/* Disable MAC loopback mode */

	XGMAC_IOWRITE_BITS(pdata, MAC_RCR, LM, 0);

}

drivers/net/ethernet/amd/xgbe/xgbe-ethtool.c

+7 −0
Original line number Diff line number Diff line
@@ -85,6 +85,9 @@ static void xgbe_get_strings(struct net_device *netdev, u32 stringset, u8 *data) 
	int i;



	switch (stringset) {

	case ETH_SS_TEST:

		xgbe_selftest_get_strings(pdata, data);

		break;

	case ETH_SS_STATS:

		for (i = 0; i < XGBE_STATS_COUNT; i++)

			ethtool_puts(&data, xgbe_gstring_stats[i].stat_string);
@@ -131,6 +134,9 @@ static int xgbe_get_sset_count(struct net_device *netdev, int stringset) 
	int ret;



	switch (stringset) {

	case ETH_SS_TEST:

		ret = xgbe_selftest_get_count(pdata);

		break;

	case ETH_SS_STATS:

		ret = XGBE_STATS_COUNT +

		      (pdata->tx_ring_count * 2) +
@@ -760,6 +766,7 @@ static const struct ethtool_ops xgbe_ethtool_ops = { 
	.set_ringparam = xgbe_set_ringparam,

	.get_channels = xgbe_get_channels,

	.set_channels = xgbe_set_channels,

	.self_test = xgbe_selftest_run,

};



const struct ethtool_ops *xgbe_get_ethtool_ops(void)

drivers/net/ethernet/amd/xgbe/xgbe-selftest.c

0 → 100644
+237 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: (GPL-2.0-or-later OR BSD-3-Clause)

/*

 * Copyright (c) 2014-2025, Advanced Micro Devices, Inc.

 * Copyright (c) 2014, Synopsys, Inc.

 * All rights reserved

 *

 * Author: Raju Rangoju <Raju.Rangoju@amd.com>

 */

#include <linux/crc32.h>

#include <linux/ip.h>

#include <linux/udp.h>

#include <net/tcp.h>

#include <net/udp.h>

#include <net/checksum.h>

#include <net/selftests.h>



#include "xgbe.h"

#include "xgbe-common.h"



#define XGBE_LOOPBACK_NONE	0

#define XGBE_LOOPBACK_MAC	1



struct xgbe_test {

	char name[ETH_GSTRING_LEN];

	int lb;

	int (*fn)(struct xgbe_prv_data *pdata);

};



static u8 xgbe_test_id;



static int xgbe_test_loopback_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;

	const unsigned char *dst = tdata->packet->dst;

	const unsigned char *src = tdata->packet->src;

	struct netsfhdr *hdr;

	struct ethhdr *eh;

	struct tcphdr *th;

	struct udphdr *uh;

	struct iphdr *ih;



	skb = skb_unshare(skb, GFP_ATOMIC);

	if (!skb)

		goto out;



	if (skb_linearize(skb))

		goto out;



	if (skb_headlen(skb) < (NET_TEST_PKT_SIZE - ETH_HLEN))

		goto out;



	eh = (struct ethhdr *)skb_mac_header(skb);

	if (dst) {

		if (!ether_addr_equal_unaligned(eh->h_dest, dst))

			goto out;

	}

	if (src) {

		if (!ether_addr_equal_unaligned(eh->h_source, src))

			goto out;

	}



	ih = ip_hdr(skb);



	if (tdata->packet->tcp) {

		if (ih->protocol != IPPROTO_TCP)

			goto out;



		th = (struct tcphdr *)((u8 *)ih + 4 * ih->ihl);

		if (th->dest != htons(tdata->packet->dport))

			goto out;



		hdr = (struct netsfhdr *)((u8 *)th + sizeof(*th));

	} else {

		if (ih->protocol != IPPROTO_UDP)

			goto out;



		uh = (struct udphdr *)((u8 *)ih + 4 * ih->ihl);

		if (uh->dest != htons(tdata->packet->dport))

			goto out;



		hdr = (struct netsfhdr *)((u8 *)uh + sizeof(*uh));

	}



	if (hdr->magic != cpu_to_be64(NET_TEST_PKT_MAGIC))

		goto out;

	if (tdata->packet->id != hdr->id)

		goto out;



	tdata->ok = true;

	complete(&tdata->comp);

out:

	kfree_skb(skb);

	return 0;

}



static int __xgbe_test_loopback(struct xgbe_prv_data *pdata,

				struct net_packet_attrs *attr)

{

	struct net_test_priv *tdata;

	struct sk_buff *skb = NULL;

	int ret = 0;



	tdata = kzalloc(sizeof(*tdata), GFP_KERNEL);

	if (!tdata)

		return -ENOMEM;



	tdata->ok = false;

	init_completion(&tdata->comp);



	tdata->pt.type = htons(ETH_P_IP);

	tdata->pt.func = xgbe_test_loopback_validate;

	tdata->pt.dev = pdata->netdev;

	tdata->pt.af_packet_priv = tdata;

	tdata->packet = attr;



	dev_add_pack(&tdata->pt);



	skb = net_test_get_skb(pdata->netdev, xgbe_test_id, attr);

	if (!skb) {

		ret = -ENOMEM;

		goto cleanup;

	}



	xgbe_test_id++;

	ret = dev_direct_xmit(skb, attr->queue_mapping);

	if (ret)

		goto cleanup;



	if (!attr->timeout)

		attr->timeout = NET_LB_TIMEOUT;



	wait_for_completion_timeout(&tdata->comp, attr->timeout);

	ret = tdata->ok ? 0 : -ETIMEDOUT;



	if (ret)

		netdev_err(pdata->netdev, "Response timedout: ret %d\n", ret);

cleanup:

	dev_remove_pack(&tdata->pt);

	kfree(tdata);

	return ret;

}



static int xgbe_test_mac_loopback(struct xgbe_prv_data *pdata)

{

	struct net_packet_attrs attr = {};



	attr.dst = pdata->netdev->dev_addr;

	return __xgbe_test_loopback(pdata, &attr);

}



static const struct xgbe_test xgbe_selftests[] = {

	{

		.name = "MAC Loopback   ",

		.lb = XGBE_LOOPBACK_MAC,

		.fn = xgbe_test_mac_loopback,

	},

};



void xgbe_selftest_run(struct net_device *dev,

		       struct ethtool_test *etest, u64 *buf)

{

	struct xgbe_prv_data *pdata = netdev_priv(dev);

	int count = xgbe_selftest_get_count(pdata);

	int i, ret;



	memset(buf, 0, sizeof(*buf) * count);

	xgbe_test_id = 0;



	if (etest->flags != ETH_TEST_FL_OFFLINE) {

		netdev_err(pdata->netdev, "Only offline tests are supported\n");

		etest->flags |= ETH_TEST_FL_FAILED;

		return;

	} else if (!netif_carrier_ok(dev)) {

		netdev_err(pdata->netdev,

			   "Invalid link, cannot execute tests\n");

		etest->flags |= ETH_TEST_FL_FAILED;

		return;

	}



	/* Wait for queues drain */

	msleep(200);



	for (i = 0; i < count; i++) {

		ret = 0;



		switch (xgbe_selftests[i].lb) {

		case XGBE_LOOPBACK_MAC:

			ret = xgbe_enable_mac_loopback(pdata);

			break;

		case XGBE_LOOPBACK_NONE:

			break;

		default:

			ret = -EOPNOTSUPP;

			break;

		}



		/*

		 * First tests will always be MAC / PHY loopback.

		 * If any of them is not supported we abort earlier.

		 */

		if (ret) {

			netdev_err(pdata->netdev, "Loopback not supported\n");

			etest->flags |= ETH_TEST_FL_FAILED;

			break;

		}



		ret = xgbe_selftests[i].fn(pdata);

		if (ret && (ret != -EOPNOTSUPP))

			etest->flags |= ETH_TEST_FL_FAILED;

		buf[i] = ret;



		switch (xgbe_selftests[i].lb) {

		case XGBE_LOOPBACK_MAC:

			xgbe_disable_mac_loopback(pdata);

			break;

		default:

			break;

		}

	}

}



void xgbe_selftest_get_strings(struct xgbe_prv_data *pdata, u8 *data)

{

	u8 *p = data;

	int i;



	for (i = 0; i < xgbe_selftest_get_count(pdata); i++)

		ethtool_puts(&p, xgbe_selftests[i].name);

}



int xgbe_selftest_get_count(struct xgbe_prv_data *pdata)

{

	return ARRAY_SIZE(xgbe_selftests);

}