Contributors: 1
Author Tokens Token Proportion Commits Commit Proportion
Dimitris Michailidis 5971 100.00% 3 100.00%
Total 5971 3 


// SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause)

#include <linux/ethtool.h>
#include <linux/linkmode.h>
#include <linux/netdevice.h>
#include <linux/nvme.h>
#include <linux/io.h>
#include <linux/io-64-nonatomic-lo-hi.h>
#include <linux/pci.h>
#include <linux/rtnetlink.h>
#include "funeth.h"
#include "fun_port.h"
#include "funeth_txrx.h"

/* Min queue depth. The smallest power-of-2 supporting jumbo frames with 4K
 * pages is 8. Require it for all types of queues though some could work with
 * fewer entries.
 */
#define FUNETH_MIN_QDEPTH 8

static const char mac_tx_stat_names[][ETH_GSTRING_LEN] = {
	"mac_tx_octets_total",
	"mac_tx_frames_total",
	"mac_tx_vlan_frames_ok",
	"mac_tx_unicast_frames",
	"mac_tx_multicast_frames",
	"mac_tx_broadcast_frames",
	"mac_tx_errors",
	"mac_tx_CBFCPAUSE0",
	"mac_tx_CBFCPAUSE1",
	"mac_tx_CBFCPAUSE2",
	"mac_tx_CBFCPAUSE3",
	"mac_tx_CBFCPAUSE4",
	"mac_tx_CBFCPAUSE5",
	"mac_tx_CBFCPAUSE6",
	"mac_tx_CBFCPAUSE7",
	"mac_tx_CBFCPAUSE8",
	"mac_tx_CBFCPAUSE9",
	"mac_tx_CBFCPAUSE10",
	"mac_tx_CBFCPAUSE11",
	"mac_tx_CBFCPAUSE12",
	"mac_tx_CBFCPAUSE13",
	"mac_tx_CBFCPAUSE14",
	"mac_tx_CBFCPAUSE15",
};

static const char mac_rx_stat_names[][ETH_GSTRING_LEN] = {
	"mac_rx_octets_total",
	"mac_rx_frames_total",
	"mac_rx_VLAN_frames_ok",
	"mac_rx_unicast_frames",
	"mac_rx_multicast_frames",
	"mac_rx_broadcast_frames",
	"mac_rx_drop_events",
	"mac_rx_errors",
	"mac_rx_alignment_errors",
	"mac_rx_CBFCPAUSE0",
	"mac_rx_CBFCPAUSE1",
	"mac_rx_CBFCPAUSE2",
	"mac_rx_CBFCPAUSE3",
	"mac_rx_CBFCPAUSE4",
	"mac_rx_CBFCPAUSE5",
	"mac_rx_CBFCPAUSE6",
	"mac_rx_CBFCPAUSE7",
	"mac_rx_CBFCPAUSE8",
	"mac_rx_CBFCPAUSE9",
	"mac_rx_CBFCPAUSE10",
	"mac_rx_CBFCPAUSE11",
	"mac_rx_CBFCPAUSE12",
	"mac_rx_CBFCPAUSE13",
	"mac_rx_CBFCPAUSE14",
	"mac_rx_CBFCPAUSE15",
};

static const char * const txq_stat_names[] = {
	"tx_pkts",
	"tx_bytes",
	"tx_cso",
	"tx_tso",
	"tx_encapsulated_tso",
	"tx_uso",
	"tx_more",
	"tx_queue_stops",
	"tx_queue_restarts",
	"tx_mapping_errors",
	"tx_tls_encrypted_packets",
	"tx_tls_encrypted_bytes",
	"tx_tls_ooo",
	"tx_tls_drop_no_sync_data",
};

static const char * const xdpq_stat_names[] = {
	"tx_xdp_pkts",
	"tx_xdp_bytes",
	"tx_xdp_full",
	"tx_xdp_mapping_errors",
};

static const char * const rxq_stat_names[] = {
	"rx_pkts",
	"rx_bytes",
	"rx_cso",
	"gro_pkts",
	"gro_merged",
	"rx_xdp_tx",
	"rx_xdp_redir",
	"rx_xdp_drops",
	"rx_buffers",
	"rx_page_allocs",
	"rx_drops",
	"rx_budget_exhausted",
	"rx_mapping_errors",
};

static const char * const tls_stat_names[] = {
	"tx_tls_ctx",
	"tx_tls_del",
	"tx_tls_resync",
};

static void fun_link_modes_to_ethtool(u64 modes,
				      unsigned long *ethtool_modes_map)
{
#define ADD_LINK_MODE(mode) \
	__set_bit(ETHTOOL_LINK_MODE_ ## mode ## _BIT, ethtool_modes_map)

	if (modes & FUN_PORT_CAP_AUTONEG)
		ADD_LINK_MODE(Autoneg);
	if (modes & FUN_PORT_CAP_1000_X)
		ADD_LINK_MODE(1000baseX_Full);
	if (modes & FUN_PORT_CAP_10G_R) {
		ADD_LINK_MODE(10000baseCR_Full);
		ADD_LINK_MODE(10000baseSR_Full);
		ADD_LINK_MODE(10000baseLR_Full);
		ADD_LINK_MODE(10000baseER_Full);
	}
	if (modes & FUN_PORT_CAP_25G_R) {
		ADD_LINK_MODE(25000baseCR_Full);
		ADD_LINK_MODE(25000baseSR_Full);
	}
	if (modes & FUN_PORT_CAP_40G_R4) {
		ADD_LINK_MODE(40000baseCR4_Full);
		ADD_LINK_MODE(40000baseSR4_Full);
		ADD_LINK_MODE(40000baseLR4_Full);
	}
	if (modes & FUN_PORT_CAP_50G_R2) {
		ADD_LINK_MODE(50000baseCR2_Full);
		ADD_LINK_MODE(50000baseSR2_Full);
	}
	if (modes & FUN_PORT_CAP_50G_R) {
		ADD_LINK_MODE(50000baseCR_Full);
		ADD_LINK_MODE(50000baseSR_Full);
		ADD_LINK_MODE(50000baseLR_ER_FR_Full);
	}
	if (modes & FUN_PORT_CAP_100G_R4) {
		ADD_LINK_MODE(100000baseCR4_Full);
		ADD_LINK_MODE(100000baseSR4_Full);
		ADD_LINK_MODE(100000baseLR4_ER4_Full);
	}
	if (modes & FUN_PORT_CAP_100G_R2) {
		ADD_LINK_MODE(100000baseCR2_Full);
		ADD_LINK_MODE(100000baseSR2_Full);
		ADD_LINK_MODE(100000baseLR2_ER2_FR2_Full);
	}
	if (modes & FUN_PORT_CAP_FEC_NONE)
		ADD_LINK_MODE(FEC_NONE);
	if (modes & FUN_PORT_CAP_FEC_FC)
		ADD_LINK_MODE(FEC_BASER);
	if (modes & FUN_PORT_CAP_FEC_RS)
		ADD_LINK_MODE(FEC_RS);
	if (modes & FUN_PORT_CAP_RX_PAUSE)
		ADD_LINK_MODE(Pause);

#undef ADD_LINK_MODE
}

static void set_asym_pause(u64 advertising, struct ethtool_link_ksettings *ks)
{
	bool rx_pause, tx_pause;

	rx_pause = advertising & FUN_PORT_CAP_RX_PAUSE;
	tx_pause = advertising & FUN_PORT_CAP_TX_PAUSE;
	if (tx_pause ^ rx_pause)
		ethtool_link_ksettings_add_link_mode(ks, advertising,
						     Asym_Pause);
}

static unsigned int fun_port_type(unsigned int xcvr)
{
	if (!xcvr)
		return PORT_NONE;

	switch (xcvr & 7) {
	case FUN_XCVR_BASET:
		return PORT_TP;
	case FUN_XCVR_CU:
		return PORT_DA;
	default:
		return PORT_FIBRE;
	}
}

static int fun_get_link_ksettings(struct net_device *netdev,
				  struct ethtool_link_ksettings *ks)
{
	const struct funeth_priv *fp = netdev_priv(netdev);
	unsigned int seq, speed, xcvr;
	u64 lp_advertising;
	bool link_up;

	ethtool_link_ksettings_zero_link_mode(ks, supported);
	ethtool_link_ksettings_zero_link_mode(ks, advertising);
	ethtool_link_ksettings_zero_link_mode(ks, lp_advertising);

	/* Link settings change asynchronously, take a consistent snapshot */
	do {
		seq = read_seqcount_begin(&fp->link_seq);
		link_up = netif_carrier_ok(netdev);
		speed = fp->link_speed;
		xcvr = fp->xcvr_type;
		lp_advertising = fp->lp_advertising;
	} while (read_seqcount_retry(&fp->link_seq, seq));

	if (link_up) {
		ks->base.speed = speed;
		ks->base.duplex = DUPLEX_FULL;
		fun_link_modes_to_ethtool(lp_advertising,
					  ks->link_modes.lp_advertising);
	} else {
		ks->base.speed = SPEED_UNKNOWN;
		ks->base.duplex = DUPLEX_UNKNOWN;
	}

	ks->base.autoneg = (fp->advertising & FUN_PORT_CAP_AUTONEG) ?
			   AUTONEG_ENABLE : AUTONEG_DISABLE;
	ks->base.port = fun_port_type(xcvr);

	fun_link_modes_to_ethtool(fp->port_caps, ks->link_modes.supported);
	if (fp->port_caps & (FUN_PORT_CAP_RX_PAUSE | FUN_PORT_CAP_TX_PAUSE))
		ethtool_link_ksettings_add_link_mode(ks, supported, Asym_Pause);

	fun_link_modes_to_ethtool(fp->advertising, ks->link_modes.advertising);
	set_asym_pause(fp->advertising, ks);
	return 0;
}

static u64 fun_advert_modes(const struct ethtool_link_ksettings *ks)
{
	u64 modes = 0;

#define HAS_MODE(mode) \
	ethtool_link_ksettings_test_link_mode(ks, advertising, mode)

	if (HAS_MODE(1000baseX_Full))
		modes |= FUN_PORT_CAP_1000_X;
	if (HAS_MODE(10000baseCR_Full) || HAS_MODE(10000baseSR_Full) ||
	    HAS_MODE(10000baseLR_Full) || HAS_MODE(10000baseER_Full))
		modes |= FUN_PORT_CAP_10G_R;
	if (HAS_MODE(25000baseCR_Full) || HAS_MODE(25000baseSR_Full))
		modes |= FUN_PORT_CAP_25G_R;
	if (HAS_MODE(40000baseCR4_Full) || HAS_MODE(40000baseSR4_Full) ||
	    HAS_MODE(40000baseLR4_Full))
		modes |= FUN_PORT_CAP_40G_R4;
	if (HAS_MODE(50000baseCR2_Full) || HAS_MODE(50000baseSR2_Full))
		modes |= FUN_PORT_CAP_50G_R2;
	if (HAS_MODE(50000baseCR_Full) || HAS_MODE(50000baseSR_Full) ||
	    HAS_MODE(50000baseLR_ER_FR_Full))
		modes |= FUN_PORT_CAP_50G_R;
	if (HAS_MODE(100000baseCR4_Full) || HAS_MODE(100000baseSR4_Full) ||
	    HAS_MODE(100000baseLR4_ER4_Full))
		modes |= FUN_PORT_CAP_100G_R4;
	if (HAS_MODE(100000baseCR2_Full) || HAS_MODE(100000baseSR2_Full) ||
	    HAS_MODE(100000baseLR2_ER2_FR2_Full))
		modes |= FUN_PORT_CAP_100G_R2;

	return modes;
#undef HAS_MODE
}

static u64 fun_speed_to_link_mode(unsigned int speed)
{
	switch (speed) {
	case SPEED_100000:
		return FUN_PORT_CAP_100G_R4 | FUN_PORT_CAP_100G_R2;
	case SPEED_50000:
		return FUN_PORT_CAP_50G_R | FUN_PORT_CAP_50G_R2;
	case SPEED_40000:
		return FUN_PORT_CAP_40G_R4;
	case SPEED_25000:
		return FUN_PORT_CAP_25G_R;
	case SPEED_10000:
		return FUN_PORT_CAP_10G_R;
	case SPEED_1000:
		return FUN_PORT_CAP_1000_X;
	default:
		return 0;
	}
}

static int fun_change_advert(struct funeth_priv *fp, u64 new_advert)
{
	int err;

	if (new_advert == fp->advertising)
		return 0;

	err = fun_port_write_cmd(fp, FUN_ADMIN_PORT_KEY_ADVERT, new_advert);
	if (!err)
		fp->advertising = new_advert;
	return err;
}

#define FUN_PORT_CAP_FEC_MASK \
	(FUN_PORT_CAP_FEC_NONE | FUN_PORT_CAP_FEC_FC | FUN_PORT_CAP_FEC_RS)

static int fun_set_link_ksettings(struct net_device *netdev,
				  const struct ethtool_link_ksettings *ks)
{
	__ETHTOOL_DECLARE_LINK_MODE_MASK(supported) = {};
	struct funeth_priv *fp = netdev_priv(netdev);
	u64 new_advert;

	/* eswitch ports don't support mode changes */
	if (fp->port_caps & FUN_PORT_CAP_VPORT)
		return -EOPNOTSUPP;

	if (ks->base.duplex == DUPLEX_HALF)
		return -EINVAL;
	if (ks->base.autoneg == AUTONEG_ENABLE &&
	    !(fp->port_caps & FUN_PORT_CAP_AUTONEG))
		return -EINVAL;

	if (ks->base.autoneg == AUTONEG_ENABLE) {
		if (linkmode_empty(ks->link_modes.advertising))
			return -EINVAL;

		fun_link_modes_to_ethtool(fp->port_caps, supported);
		if (!linkmode_subset(ks->link_modes.advertising, supported))
			return -EINVAL;

		new_advert = fun_advert_modes(ks) | FUN_PORT_CAP_AUTONEG;
	} else {
		new_advert = fun_speed_to_link_mode(ks->base.speed);
		new_advert &= fp->port_caps;
		if (!new_advert)
			return -EINVAL;
	}
	new_advert |= fp->advertising &
		      (FUN_PORT_CAP_PAUSE_MASK | FUN_PORT_CAP_FEC_MASK);

	return fun_change_advert(fp, new_advert);
}

static void fun_get_pauseparam(struct net_device *netdev,
			       struct ethtool_pauseparam *pause)
{
	const struct funeth_priv *fp = netdev_priv(netdev);
	u8 active_pause = fp->active_fc;

	pause->rx_pause = !!(active_pause & FUN_PORT_CAP_RX_PAUSE);
	pause->tx_pause = !!(active_pause & FUN_PORT_CAP_TX_PAUSE);
	pause->autoneg = !!(fp->advertising & FUN_PORT_CAP_AUTONEG);
}

static int fun_set_pauseparam(struct net_device *netdev,
			      struct ethtool_pauseparam *pause)
{
	struct funeth_priv *fp = netdev_priv(netdev);
	u64 new_advert;

	if (fp->port_caps & FUN_PORT_CAP_VPORT)
		return -EOPNOTSUPP;
	/* Forcing PAUSE settings with AN enabled is unsupported. */
	if (!pause->autoneg && (fp->advertising & FUN_PORT_CAP_AUTONEG))
		return -EOPNOTSUPP;
	if (pause->autoneg && !(fp->advertising & FUN_PORT_CAP_AUTONEG))
		return -EINVAL;
	if (pause->tx_pause && !(fp->port_caps & FUN_PORT_CAP_TX_PAUSE))
		return -EINVAL;
	if (pause->rx_pause && !(fp->port_caps & FUN_PORT_CAP_RX_PAUSE))
		return -EINVAL;

	new_advert = fp->advertising & ~FUN_PORT_CAP_PAUSE_MASK;
	if (pause->tx_pause)
		new_advert |= FUN_PORT_CAP_TX_PAUSE;
	if (pause->rx_pause)
		new_advert |= FUN_PORT_CAP_RX_PAUSE;

	return fun_change_advert(fp, new_advert);
}

static int fun_restart_an(struct net_device *netdev)
{
	struct funeth_priv *fp = netdev_priv(netdev);

	if (!(fp->advertising & FUN_PORT_CAP_AUTONEG))
		return -EOPNOTSUPP;

	return fun_port_write_cmd(fp, FUN_ADMIN_PORT_KEY_ADVERT,
				  FUN_PORT_CAP_AUTONEG);
}

static int fun_set_phys_id(struct net_device *netdev,
			   enum ethtool_phys_id_state state)
{
	struct funeth_priv *fp = netdev_priv(netdev);
	unsigned int beacon;

	if (fp->port_caps & FUN_PORT_CAP_VPORT)
		return -EOPNOTSUPP;
	if (state != ETHTOOL_ID_ACTIVE && state != ETHTOOL_ID_INACTIVE)
		return -EOPNOTSUPP;

	beacon = state == ETHTOOL_ID_ACTIVE ? FUN_PORT_LED_BEACON_ON :
					      FUN_PORT_LED_BEACON_OFF;
	return fun_port_write_cmd(fp, FUN_ADMIN_PORT_KEY_LED, beacon);
}

static void fun_get_drvinfo(struct net_device *netdev,
			    struct ethtool_drvinfo *info)
{
	const struct funeth_priv *fp = netdev_priv(netdev);

	strscpy(info->driver, KBUILD_MODNAME, sizeof(info->driver));
	strscpy(info->bus_info, pci_name(fp->pdev), sizeof(info->bus_info));
}

static u32 fun_get_msglevel(struct net_device *netdev)
{
	const struct funeth_priv *fp = netdev_priv(netdev);

	return fp->msg_enable;
}

static void fun_set_msglevel(struct net_device *netdev, u32 value)
{
	struct funeth_priv *fp = netdev_priv(netdev);

	fp->msg_enable = value;
}

static int fun_get_regs_len(struct net_device *dev)
{
	return NVME_REG_ACQ + sizeof(u64);
}

static void fun_get_regs(struct net_device *dev, struct ethtool_regs *regs,
			 void *buf)
{
	const struct funeth_priv *fp = netdev_priv(dev);
	void __iomem *bar = fp->fdev->bar;

	regs->version = 0;
	*(u64 *)(buf + NVME_REG_CAP)   = readq(bar + NVME_REG_CAP);
	*(u32 *)(buf + NVME_REG_VS)    = readl(bar + NVME_REG_VS);
	*(u32 *)(buf + NVME_REG_INTMS) = readl(bar + NVME_REG_INTMS);
	*(u32 *)(buf + NVME_REG_INTMC) = readl(bar + NVME_REG_INTMC);
	*(u32 *)(buf + NVME_REG_CC)    = readl(bar + NVME_REG_CC);
	*(u32 *)(buf + NVME_REG_CSTS)  = readl(bar + NVME_REG_CSTS);
	*(u32 *)(buf + NVME_REG_AQA)   = readl(bar + NVME_REG_AQA);
	*(u64 *)(buf + NVME_REG_ASQ)   = readq(bar + NVME_REG_ASQ);
	*(u64 *)(buf + NVME_REG_ACQ)   = readq(bar + NVME_REG_ACQ);
}

static int fun_get_coalesce(struct net_device *netdev,
			    struct ethtool_coalesce *coal,
			    struct kernel_ethtool_coalesce *kcoal,
			    struct netlink_ext_ack *ext_ack)
{
	const struct funeth_priv *fp = netdev_priv(netdev);

	coal->rx_coalesce_usecs        = fp->rx_coal_usec;
	coal->rx_max_coalesced_frames  = fp->rx_coal_count;
	coal->use_adaptive_rx_coalesce = !fp->cq_irq_db;
	coal->tx_coalesce_usecs        = fp->tx_coal_usec;
	coal->tx_max_coalesced_frames  = fp->tx_coal_count;
	return 0;
}

static int fun_set_coalesce(struct net_device *netdev,
			    struct ethtool_coalesce *coal,
			    struct kernel_ethtool_coalesce *kcoal,
			    struct netlink_ext_ack *ext_ack)
{
	struct funeth_priv *fp = netdev_priv(netdev);
	struct funeth_rxq **rxqs;
	unsigned int i, db_val;

	if (coal->rx_coalesce_usecs > FUN_DB_INTCOAL_USEC_M ||
	    coal->rx_max_coalesced_frames > FUN_DB_INTCOAL_ENTRIES_M ||
	    (coal->rx_coalesce_usecs | coal->rx_max_coalesced_frames) == 0 ||
	    coal->tx_coalesce_usecs > FUN_DB_INTCOAL_USEC_M ||
	    coal->tx_max_coalesced_frames > FUN_DB_INTCOAL_ENTRIES_M ||
	    (coal->tx_coalesce_usecs | coal->tx_max_coalesced_frames) == 0)
		return -EINVAL;

	/* a timer is required if there's any coalescing */
	if ((coal->rx_max_coalesced_frames > 1 && !coal->rx_coalesce_usecs) ||
	    (coal->tx_max_coalesced_frames > 1 && !coal->tx_coalesce_usecs))
		return -EINVAL;

	fp->rx_coal_usec  = coal->rx_coalesce_usecs;
	fp->rx_coal_count = coal->rx_max_coalesced_frames;
	fp->tx_coal_usec  = coal->tx_coalesce_usecs;
	fp->tx_coal_count = coal->tx_max_coalesced_frames;

	db_val = FUN_IRQ_CQ_DB(fp->rx_coal_usec, fp->rx_coal_count);
	WRITE_ONCE(fp->cq_irq_db, db_val);

	rxqs = rtnl_dereference(fp->rxqs);
	if (!rxqs)
		return 0;

	for (i = 0; i < netdev->real_num_rx_queues; i++)
		WRITE_ONCE(rxqs[i]->irq_db_val, db_val);

	db_val = FUN_IRQ_SQ_DB(fp->tx_coal_usec, fp->tx_coal_count);
	for (i = 0; i < netdev->real_num_tx_queues; i++)
		WRITE_ONCE(fp->txqs[i]->irq_db_val, db_val);

	return 0;
}

static void fun_get_channels(struct net_device *netdev,
			     struct ethtool_channels *chan)
{
	chan->max_rx   = netdev->num_rx_queues;
	chan->rx_count = netdev->real_num_rx_queues;

	chan->max_tx   = netdev->num_tx_queues;
	chan->tx_count = netdev->real_num_tx_queues;
}

static int fun_set_channels(struct net_device *netdev,
			    struct ethtool_channels *chan)
{
	if (!chan->tx_count || !chan->rx_count)
		return -EINVAL;

	if (chan->tx_count == netdev->real_num_tx_queues &&
	    chan->rx_count == netdev->real_num_rx_queues)
		return 0;

	if (netif_running(netdev))
		return fun_change_num_queues(netdev, chan->tx_count,
					     chan->rx_count);

	fun_set_ring_count(netdev, chan->tx_count, chan->rx_count);
	return 0;
}

static void fun_get_ringparam(struct net_device *netdev,
			      struct ethtool_ringparam *ring,
			      struct kernel_ethtool_ringparam *kring,
			      struct netlink_ext_ack *extack)
{
	const struct funeth_priv *fp = netdev_priv(netdev);
	unsigned int max_depth = fp->fdev->q_depth;

	/* We size CQs to be twice the RQ depth so max RQ depth is half the
	 * max queue depth.
	 */
	ring->rx_max_pending = max_depth / 2;
	ring->tx_max_pending = max_depth;

	ring->rx_pending = fp->rq_depth;
	ring->tx_pending = fp->sq_depth;

	kring->rx_buf_len = PAGE_SIZE;
	kring->cqe_size = FUNETH_CQE_SIZE;
}

static int fun_set_ringparam(struct net_device *netdev,
			     struct ethtool_ringparam *ring,
			     struct kernel_ethtool_ringparam *kring,
			     struct netlink_ext_ack *extack)
{
	struct funeth_priv *fp = netdev_priv(netdev);
	int rc;

	if (ring->rx_mini_pending || ring->rx_jumbo_pending)
		return -EINVAL;

	/* queue depths must be powers-of-2 */
	if (!is_power_of_2(ring->rx_pending) ||
	    !is_power_of_2(ring->tx_pending))
		return -EINVAL;

	if (ring->rx_pending < FUNETH_MIN_QDEPTH ||
	    ring->tx_pending < FUNETH_MIN_QDEPTH)
		return -EINVAL;

	if (fp->sq_depth == ring->tx_pending &&
	    fp->rq_depth == ring->rx_pending)
		return 0;

	if (netif_running(netdev)) {
		struct fun_qset req = {
			.cq_depth = 2 * ring->rx_pending,
			.rq_depth = ring->rx_pending,
			.sq_depth = ring->tx_pending
		};

		rc = fun_replace_queues(netdev, &req, extack);
		if (rc)
			return rc;
	}

	fp->sq_depth = ring->tx_pending;
	fp->rq_depth = ring->rx_pending;
	fp->cq_depth = 2 * fp->rq_depth;
	return 0;
}

static int fun_get_sset_count(struct net_device *dev, int sset)
{
	const struct funeth_priv *fp = netdev_priv(dev);
	int n;

	switch (sset) {
	case ETH_SS_STATS:
		n = (dev->real_num_tx_queues + 1) * ARRAY_SIZE(txq_stat_names) +
		    (dev->real_num_rx_queues + 1) * ARRAY_SIZE(rxq_stat_names) +
		    (fp->num_xdpqs + 1) * ARRAY_SIZE(xdpq_stat_names) +
		    ARRAY_SIZE(tls_stat_names);
		if (fp->port_caps & FUN_PORT_CAP_STATS) {
			n += ARRAY_SIZE(mac_tx_stat_names) +
			     ARRAY_SIZE(mac_rx_stat_names);
		}
		return n;
	default:
		break;
	}
	return 0;
}

static void fun_get_strings(struct net_device *netdev, u32 sset, u8 *data)
{
	const struct funeth_priv *fp = netdev_priv(netdev);
	unsigned int i, j;
	u8 *p = data;

	switch (sset) {
	case ETH_SS_STATS:
		if (fp->port_caps & FUN_PORT_CAP_STATS) {
			memcpy(p, mac_tx_stat_names, sizeof(mac_tx_stat_names));
			p += sizeof(mac_tx_stat_names);
			memcpy(p, mac_rx_stat_names, sizeof(mac_rx_stat_names));
			p += sizeof(mac_rx_stat_names);
		}

		for (i = 0; i < netdev->real_num_tx_queues; i++) {
			for (j = 0; j < ARRAY_SIZE(txq_stat_names); j++)
				ethtool_sprintf(&p, "%s[%u]", txq_stat_names[j],
						i);
		}
		for (j = 0; j < ARRAY_SIZE(txq_stat_names); j++)
			ethtool_sprintf(&p, txq_stat_names[j]);

		for (i = 0; i < fp->num_xdpqs; i++) {
			for (j = 0; j < ARRAY_SIZE(xdpq_stat_names); j++)
				ethtool_sprintf(&p, "%s[%u]",
						xdpq_stat_names[j], i);
		}
		for (j = 0; j < ARRAY_SIZE(xdpq_stat_names); j++)
			ethtool_sprintf(&p, xdpq_stat_names[j]);

		for (i = 0; i < netdev->real_num_rx_queues; i++) {
			for (j = 0; j < ARRAY_SIZE(rxq_stat_names); j++)
				ethtool_sprintf(&p, "%s[%u]", rxq_stat_names[j],
						i);
		}
		for (j = 0; j < ARRAY_SIZE(rxq_stat_names); j++)
			ethtool_sprintf(&p, rxq_stat_names[j]);

		for (j = 0; j < ARRAY_SIZE(tls_stat_names); j++)
			ethtool_sprintf(&p, tls_stat_names[j]);
		break;
	default:
		break;
	}
}

static u64 *get_mac_stats(const struct funeth_priv *fp, u64 *data)
{
#define TX_STAT(s) \
	*data++ = be64_to_cpu(fp->stats[PORT_MAC_RX_STATS_MAX + PORT_MAC_TX_##s])

	TX_STAT(etherStatsOctets);
	TX_STAT(etherStatsPkts);
	TX_STAT(VLANTransmittedOK);
	TX_STAT(ifOutUcastPkts);
	TX_STAT(ifOutMulticastPkts);
	TX_STAT(ifOutBroadcastPkts);
	TX_STAT(ifOutErrors);
	TX_STAT(CBFCPAUSEFramesTransmitted_0);
	TX_STAT(CBFCPAUSEFramesTransmitted_1);
	TX_STAT(CBFCPAUSEFramesTransmitted_2);
	TX_STAT(CBFCPAUSEFramesTransmitted_3);
	TX_STAT(CBFCPAUSEFramesTransmitted_4);
	TX_STAT(CBFCPAUSEFramesTransmitted_5);
	TX_STAT(CBFCPAUSEFramesTransmitted_6);
	TX_STAT(CBFCPAUSEFramesTransmitted_7);
	TX_STAT(CBFCPAUSEFramesTransmitted_8);
	TX_STAT(CBFCPAUSEFramesTransmitted_9);
	TX_STAT(CBFCPAUSEFramesTransmitted_10);
	TX_STAT(CBFCPAUSEFramesTransmitted_11);
	TX_STAT(CBFCPAUSEFramesTransmitted_12);
	TX_STAT(CBFCPAUSEFramesTransmitted_13);
	TX_STAT(CBFCPAUSEFramesTransmitted_14);
	TX_STAT(CBFCPAUSEFramesTransmitted_15);

#define RX_STAT(s) *data++ = be64_to_cpu(fp->stats[PORT_MAC_RX_##s])

	RX_STAT(etherStatsOctets);
	RX_STAT(etherStatsPkts);
	RX_STAT(VLANReceivedOK);
	RX_STAT(ifInUcastPkts);
	RX_STAT(ifInMulticastPkts);
	RX_STAT(ifInBroadcastPkts);
	RX_STAT(etherStatsDropEvents);
	RX_STAT(ifInErrors);
	RX_STAT(aAlignmentErrors);
	RX_STAT(CBFCPAUSEFramesReceived_0);
	RX_STAT(CBFCPAUSEFramesReceived_1);
	RX_STAT(CBFCPAUSEFramesReceived_2);
	RX_STAT(CBFCPAUSEFramesReceived_3);
	RX_STAT(CBFCPAUSEFramesReceived_4);
	RX_STAT(CBFCPAUSEFramesReceived_5);
	RX_STAT(CBFCPAUSEFramesReceived_6);
	RX_STAT(CBFCPAUSEFramesReceived_7);
	RX_STAT(CBFCPAUSEFramesReceived_8);
	RX_STAT(CBFCPAUSEFramesReceived_9);
	RX_STAT(CBFCPAUSEFramesReceived_10);
	RX_STAT(CBFCPAUSEFramesReceived_11);
	RX_STAT(CBFCPAUSEFramesReceived_12);
	RX_STAT(CBFCPAUSEFramesReceived_13);
	RX_STAT(CBFCPAUSEFramesReceived_14);
	RX_STAT(CBFCPAUSEFramesReceived_15);

	return data;

#undef TX_STAT
#undef RX_STAT
}

static void fun_get_ethtool_stats(struct net_device *netdev,
				  struct ethtool_stats *stats, u64 *data)
{
	const struct funeth_priv *fp = netdev_priv(netdev);
	struct funeth_txq_stats txs;
	struct funeth_rxq_stats rxs;
	struct funeth_txq **xdpqs;
	struct funeth_rxq **rxqs;
	unsigned int i, start;
	u64 *totals, *tot;

	if (fp->port_caps & FUN_PORT_CAP_STATS)
		data = get_mac_stats(fp, data);

	rxqs = rtnl_dereference(fp->rxqs);
	if (!rxqs)
		return;

#define ADD_STAT(cnt) do { \
	*data = (cnt); *tot++ += *data++; \
} while (0)

	/* Tx queues */
	totals = data + netdev->real_num_tx_queues * ARRAY_SIZE(txq_stat_names);

	for (i = 0; i < netdev->real_num_tx_queues; i++) {
		tot = totals;

		FUN_QSTAT_READ(fp->txqs[i], start, txs);

		ADD_STAT(txs.tx_pkts);
		ADD_STAT(txs.tx_bytes);
		ADD_STAT(txs.tx_cso);
		ADD_STAT(txs.tx_tso);
		ADD_STAT(txs.tx_encap_tso);
		ADD_STAT(txs.tx_uso);
		ADD_STAT(txs.tx_more);
		ADD_STAT(txs.tx_nstops);
		ADD_STAT(txs.tx_nrestarts);
		ADD_STAT(txs.tx_map_err);
		ADD_STAT(txs.tx_tls_pkts);
		ADD_STAT(txs.tx_tls_bytes);
		ADD_STAT(txs.tx_tls_fallback);
		ADD_STAT(txs.tx_tls_drops);
	}
	data += ARRAY_SIZE(txq_stat_names);

	/* XDP Tx queues */
	xdpqs = rtnl_dereference(fp->xdpqs);
	totals = data + fp->num_xdpqs * ARRAY_SIZE(xdpq_stat_names);

	for (i = 0; i < fp->num_xdpqs; i++) {
		tot = totals;

		FUN_QSTAT_READ(xdpqs[i], start, txs);

		ADD_STAT(txs.tx_pkts);
		ADD_STAT(txs.tx_bytes);
		ADD_STAT(txs.tx_xdp_full);
		ADD_STAT(txs.tx_map_err);
	}
	data += ARRAY_SIZE(xdpq_stat_names);

	/* Rx queues */
	totals = data + netdev->real_num_rx_queues * ARRAY_SIZE(rxq_stat_names);

	for (i = 0; i < netdev->real_num_rx_queues; i++) {
		tot = totals;

		FUN_QSTAT_READ(rxqs[i], start, rxs);

		ADD_STAT(rxs.rx_pkts);
		ADD_STAT(rxs.rx_bytes);
		ADD_STAT(rxs.rx_cso);
		ADD_STAT(rxs.gro_pkts);
		ADD_STAT(rxs.gro_merged);
		ADD_STAT(rxs.xdp_tx);
		ADD_STAT(rxs.xdp_redir);
		ADD_STAT(rxs.xdp_drops);
		ADD_STAT(rxs.rx_bufs);
		ADD_STAT(rxs.rx_page_alloc);
		ADD_STAT(rxs.rx_mem_drops + rxs.xdp_err);
		ADD_STAT(rxs.rx_budget);
		ADD_STAT(rxs.rx_map_err);
	}
	data += ARRAY_SIZE(rxq_stat_names);
#undef ADD_STAT

	*data++ = atomic64_read(&fp->tx_tls_add);
	*data++ = atomic64_read(&fp->tx_tls_del);
	*data++ = atomic64_read(&fp->tx_tls_resync);
}

#define RX_STAT(fp, s) be64_to_cpu((fp)->stats[PORT_MAC_RX_##s])
#define TX_STAT(fp, s) \
	be64_to_cpu((fp)->stats[PORT_MAC_RX_STATS_MAX + PORT_MAC_TX_##s])
#define FEC_STAT(fp, s) \
	be64_to_cpu((fp)->stats[PORT_MAC_RX_STATS_MAX + \
				PORT_MAC_TX_STATS_MAX + PORT_MAC_FEC_##s])

static void fun_get_pause_stats(struct net_device *netdev,
				struct ethtool_pause_stats *stats)
{
	const struct funeth_priv *fp = netdev_priv(netdev);

	if (!(fp->port_caps & FUN_PORT_CAP_STATS))
		return;

	stats->tx_pause_frames = TX_STAT(fp, aPAUSEMACCtrlFramesTransmitted);
	stats->rx_pause_frames = RX_STAT(fp, aPAUSEMACCtrlFramesReceived);
}

static void fun_get_802_3_stats(struct net_device *netdev,
				struct ethtool_eth_mac_stats *stats)
{
	const struct funeth_priv *fp = netdev_priv(netdev);

	if (!(fp->port_caps & FUN_PORT_CAP_STATS))
		return;

	stats->FramesTransmittedOK = TX_STAT(fp, aFramesTransmittedOK);
	stats->FramesReceivedOK = RX_STAT(fp, aFramesReceivedOK);
	stats->FrameCheckSequenceErrors = RX_STAT(fp, aFrameCheckSequenceErrors);
	stats->OctetsTransmittedOK = TX_STAT(fp, OctetsTransmittedOK);
	stats->OctetsReceivedOK = RX_STAT(fp, OctetsReceivedOK);
	stats->InRangeLengthErrors = RX_STAT(fp, aInRangeLengthErrors);
	stats->FrameTooLongErrors = RX_STAT(fp, aFrameTooLongErrors);
}

static void fun_get_802_3_ctrl_stats(struct net_device *netdev,
				     struct ethtool_eth_ctrl_stats *stats)
{
	const struct funeth_priv *fp = netdev_priv(netdev);

	if (!(fp->port_caps & FUN_PORT_CAP_STATS))
		return;

	stats->MACControlFramesTransmitted = TX_STAT(fp, MACControlFramesTransmitted);
	stats->MACControlFramesReceived = RX_STAT(fp, MACControlFramesReceived);
}

static void fun_get_rmon_stats(struct net_device *netdev,
			       struct ethtool_rmon_stats *stats,
			       const struct ethtool_rmon_hist_range **ranges)
{
	static const struct ethtool_rmon_hist_range rmon_ranges[] = {
		{   64,    64 },
		{   65,   127 },
		{  128,   255 },
		{  256,   511 },
		{  512,  1023 },
		{ 1024,  1518 },
		{ 1519, 32767 },
		{}
	};

	const struct funeth_priv *fp = netdev_priv(netdev);

	if (!(fp->port_caps & FUN_PORT_CAP_STATS))
		return;

	stats->undersize_pkts = RX_STAT(fp, etherStatsUndersizePkts);
	stats->oversize_pkts = RX_STAT(fp, etherStatsOversizePkts);
	stats->fragments = RX_STAT(fp, etherStatsFragments);
	stats->jabbers = RX_STAT(fp, etherStatsJabbers);

	stats->hist[0] = RX_STAT(fp, etherStatsPkts64Octets);
	stats->hist[1] = RX_STAT(fp, etherStatsPkts65to127Octets);
	stats->hist[2] = RX_STAT(fp, etherStatsPkts128to255Octets);
	stats->hist[3] = RX_STAT(fp, etherStatsPkts256to511Octets);
	stats->hist[4] = RX_STAT(fp, etherStatsPkts512to1023Octets);
	stats->hist[5] = RX_STAT(fp, etherStatsPkts1024to1518Octets);
	stats->hist[6] = RX_STAT(fp, etherStatsPkts1519toMaxOctets);

	stats->hist_tx[0] = TX_STAT(fp, etherStatsPkts64Octets);
	stats->hist_tx[1] = TX_STAT(fp, etherStatsPkts65to127Octets);
	stats->hist_tx[2] = TX_STAT(fp, etherStatsPkts128to255Octets);
	stats->hist_tx[3] = TX_STAT(fp, etherStatsPkts256to511Octets);
	stats->hist_tx[4] = TX_STAT(fp, etherStatsPkts512to1023Octets);
	stats->hist_tx[5] = TX_STAT(fp, etherStatsPkts1024to1518Octets);
	stats->hist_tx[6] = TX_STAT(fp, etherStatsPkts1519toMaxOctets);

	*ranges = rmon_ranges;
}

static void fun_get_fec_stats(struct net_device *netdev,
			      struct ethtool_fec_stats *stats)
{
	const struct funeth_priv *fp = netdev_priv(netdev);

	if (!(fp->port_caps & FUN_PORT_CAP_STATS))
		return;

	stats->corrected_blocks.total = FEC_STAT(fp, Correctable);
	stats->uncorrectable_blocks.total = FEC_STAT(fp, Uncorrectable);
}

#undef RX_STAT
#undef TX_STAT
#undef FEC_STAT

static int fun_get_rxnfc(struct net_device *netdev, struct ethtool_rxnfc *cmd,
			 u32 *rule_locs)
{
	switch (cmd->cmd) {
	case ETHTOOL_GRXRINGS:
		cmd->data = netdev->real_num_rx_queues;
		return 0;
	default:
		break;
	}
	return -EOPNOTSUPP;
}

static int fun_set_rxnfc(struct net_device *netdev, struct ethtool_rxnfc *info)
{
	return 0;
}

static u32 fun_get_rxfh_indir_size(struct net_device *netdev)
{
	const struct funeth_priv *fp = netdev_priv(netdev);

	return fp->indir_table_nentries;
}

static u32 fun_get_rxfh_key_size(struct net_device *netdev)
{
	const struct funeth_priv *fp = netdev_priv(netdev);

	return sizeof(fp->rss_key);
}

static int fun_get_rxfh(struct net_device *netdev, u32 *indir, u8 *key,
			u8 *hfunc)
{
	const struct funeth_priv *fp = netdev_priv(netdev);

	if (!fp->rss_cfg)
		return -EOPNOTSUPP;

	if (indir)
		memcpy(indir, fp->indir_table,
		       sizeof(u32) * fp->indir_table_nentries);

	if (key)
		memcpy(key, fp->rss_key, sizeof(fp->rss_key));

	if (hfunc)
		*hfunc = fp->hash_algo == FUN_ETH_RSS_ALG_TOEPLITZ ?
				ETH_RSS_HASH_TOP : ETH_RSS_HASH_CRC32;

	return 0;
}

static int fun_set_rxfh(struct net_device *netdev, const u32 *indir,
			const u8 *key, const u8 hfunc)
{
	struct funeth_priv *fp = netdev_priv(netdev);
	const u32 *rss_indir = indir ? indir : fp->indir_table;
	const u8 *rss_key = key ? key : fp->rss_key;
	enum fun_eth_hash_alg algo;

	if (!fp->rss_cfg)
		return -EOPNOTSUPP;

	if (hfunc == ETH_RSS_HASH_NO_CHANGE)
		algo = fp->hash_algo;
	else if (hfunc == ETH_RSS_HASH_CRC32)
		algo = FUN_ETH_RSS_ALG_CRC32;
	else if (hfunc == ETH_RSS_HASH_TOP)
		algo = FUN_ETH_RSS_ALG_TOEPLITZ;
	else
		return -EINVAL;

	/* If the port is enabled try to reconfigure RSS and keep the new
	 * settings if successful. If it is down we update the RSS settings
	 * and apply them at the next UP time.
	 */
	if (netif_running(netdev)) {
		int rc = fun_config_rss(netdev, algo, rss_key, rss_indir,
					FUN_ADMIN_SUBOP_MODIFY);
		if (rc)
			return rc;
	}

	fp->hash_algo = algo;
	if (key)
		memcpy(fp->rss_key, key, sizeof(fp->rss_key));
	if (indir)
		memcpy(fp->indir_table, indir,
		       sizeof(u32) * fp->indir_table_nentries);
	return 0;
}

static int fun_get_ts_info(struct net_device *netdev,
			   struct ethtool_ts_info *info)
{
	info->so_timestamping = SOF_TIMESTAMPING_RX_SOFTWARE |
				SOF_TIMESTAMPING_RX_HARDWARE |
				SOF_TIMESTAMPING_TX_SOFTWARE |
				SOF_TIMESTAMPING_SOFTWARE |
				SOF_TIMESTAMPING_RAW_HARDWARE;
	info->phc_index = -1;
	info->tx_types = BIT(HWTSTAMP_TX_OFF);
	info->rx_filters = BIT(HWTSTAMP_FILTER_NONE) | BIT(HWTSTAMP_FILTER_ALL);
	return 0;
}

static unsigned int to_ethtool_fec(unsigned int fun_fec)
{
	unsigned int fec = 0;

	if (fun_fec == FUN_PORT_FEC_NA)
		fec |= ETHTOOL_FEC_NONE;
	if (fun_fec & FUN_PORT_FEC_OFF)
		fec |= ETHTOOL_FEC_OFF;
	if (fun_fec & FUN_PORT_FEC_RS)
		fec |= ETHTOOL_FEC_RS;
	if (fun_fec & FUN_PORT_FEC_FC)
		fec |= ETHTOOL_FEC_BASER;
	if (fun_fec & FUN_PORT_FEC_AUTO)
		fec |= ETHTOOL_FEC_AUTO;
	return fec;
}

static int fun_get_fecparam(struct net_device *netdev,
			    struct ethtool_fecparam *fec)
{
	struct funeth_priv *fp = netdev_priv(netdev);
	u64 fec_data;
	int rc;

	rc = fun_port_read_cmd(fp, FUN_ADMIN_PORT_KEY_FEC, &fec_data);
	if (rc)
		return rc;

	fec->active_fec = to_ethtool_fec(fec_data & 0xff);
	fec->fec = to_ethtool_fec(fec_data >> 8);
	return 0;
}

static int fun_set_fecparam(struct net_device *netdev,
			    struct ethtool_fecparam *fec)
{
	struct funeth_priv *fp = netdev_priv(netdev);
	u64 fec_mode;

	switch (fec->fec) {
	case ETHTOOL_FEC_AUTO:
		fec_mode = FUN_PORT_FEC_AUTO;
		break;
	case ETHTOOL_FEC_OFF:
		if (!(fp->port_caps & FUN_PORT_CAP_FEC_NONE))
			return -EINVAL;
		fec_mode = FUN_PORT_FEC_OFF;
		break;
	case ETHTOOL_FEC_BASER:
		if (!(fp->port_caps & FUN_PORT_CAP_FEC_FC))
			return -EINVAL;
		fec_mode = FUN_PORT_FEC_FC;
		break;
	case ETHTOOL_FEC_RS:
		if (!(fp->port_caps & FUN_PORT_CAP_FEC_RS))
			return -EINVAL;
		fec_mode = FUN_PORT_FEC_RS;
		break;
	default:
		return -EINVAL;
	}

	return fun_port_write_cmd(fp, FUN_ADMIN_PORT_KEY_FEC, fec_mode);
}

static int fun_get_port_module_page(struct net_device *netdev,
				    const struct ethtool_module_eeprom *req,
				    struct netlink_ext_ack *extack)
{
	union {
		struct fun_admin_port_req req;
		struct fun_admin_port_xcvr_read_rsp rsp;
	} cmd;
	struct funeth_priv *fp = netdev_priv(netdev);
	int rc;

	if (fp->port_caps & FUN_PORT_CAP_VPORT) {
		NL_SET_ERR_MSG_MOD(extack,
				   "Specified port is virtual, only physical ports have modules");
		return -EOPNOTSUPP;
	}

	cmd.req.common = FUN_ADMIN_REQ_COMMON_INIT2(FUN_ADMIN_OP_PORT,
						    sizeof(cmd.req));
	cmd.req.u.xcvr_read =
		FUN_ADMIN_PORT_XCVR_READ_REQ_INIT(0, netdev->dev_port,
						  req->bank, req->page,
						  req->offset, req->length,
						  req->i2c_address);
	rc = fun_submit_admin_sync_cmd(fp->fdev, &cmd.req.common, &cmd.rsp,
				       sizeof(cmd.rsp), 0);
	if (rc)
		return rc;

	memcpy(req->data, cmd.rsp.data, req->length);
	return req->length;
}

static const struct ethtool_ops fun_ethtool_ops = {
	.supported_coalesce_params = ETHTOOL_COALESCE_USECS |
				     ETHTOOL_COALESCE_MAX_FRAMES,
	.get_link_ksettings  = fun_get_link_ksettings,
	.set_link_ksettings  = fun_set_link_ksettings,
	.set_phys_id         = fun_set_phys_id,
	.get_drvinfo         = fun_get_drvinfo,
	.get_msglevel        = fun_get_msglevel,
	.set_msglevel        = fun_set_msglevel,
	.get_regs_len        = fun_get_regs_len,
	.get_regs            = fun_get_regs,
	.get_link	     = ethtool_op_get_link,
	.get_coalesce        = fun_get_coalesce,
	.set_coalesce        = fun_set_coalesce,
	.get_ts_info         = fun_get_ts_info,
	.get_ringparam       = fun_get_ringparam,
	.set_ringparam       = fun_set_ringparam,
	.get_sset_count      = fun_get_sset_count,
	.get_strings         = fun_get_strings,
	.get_ethtool_stats   = fun_get_ethtool_stats,
	.get_rxnfc	     = fun_get_rxnfc,
	.set_rxnfc           = fun_set_rxnfc,
	.get_rxfh_indir_size = fun_get_rxfh_indir_size,
	.get_rxfh_key_size   = fun_get_rxfh_key_size,
	.get_rxfh            = fun_get_rxfh,
	.set_rxfh            = fun_set_rxfh,
	.get_channels        = fun_get_channels,
	.set_channels        = fun_set_channels,
	.get_fecparam	     = fun_get_fecparam,
	.set_fecparam	     = fun_set_fecparam,
	.get_pauseparam      = fun_get_pauseparam,
	.set_pauseparam      = fun_set_pauseparam,
	.nway_reset          = fun_restart_an,
	.get_pause_stats     = fun_get_pause_stats,
	.get_fec_stats       = fun_get_fec_stats,
	.get_eth_mac_stats   = fun_get_802_3_stats,
	.get_eth_ctrl_stats  = fun_get_802_3_ctrl_stats,
	.get_rmon_stats      = fun_get_rmon_stats,
	.get_module_eeprom_by_page = fun_get_port_module_page,
};

void fun_set_ethtool_ops(struct net_device *netdev)
{
	netdev->ethtool_ops = &fun_ethtool_ops;
}