[linux-block.git] / drivers / net / ethernet / samsung / sxgbe / sxgbe_ethtool.c

// SPDX-License-Identifier: GPL-2.0-only
/* 10G controller driver for Samsung SoCs
 *
 * Copyright (C) 2013 Samsung Electronics Co., Ltd.
 *		http://www.samsung.com
 *
 * Author: Siva Reddy Kallam <siva.kallam@samsung.com>
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/clk.h>
#include <linux/interrupt.h>
#include <linux/kernel.h>
#include <linux/netdevice.h>
#include <linux/net_tstamp.h>
#include <linux/phy.h>
#include <linux/ptp_clock_kernel.h>

#include "sxgbe_common.h"
#include "sxgbe_reg.h"
#include "sxgbe_dma.h"

struct sxgbe_stats {
	char stat_string[ETH_GSTRING_LEN];
	int sizeof_stat;
	int stat_offset;
};

#define SXGBE_STAT(m)						\
{								\
	#m,							\
	sizeof_field(struct sxgbe_extra_stats, m),		\
	offsetof(struct sxgbe_priv_data, xstats.m)		\
}

static const struct sxgbe_stats sxgbe_gstrings_stats[] = {
	/* TX/RX IRQ events */
	SXGBE_STAT(tx_process_stopped_irq),
	SXGBE_STAT(tx_ctxt_desc_err),
	SXGBE_STAT(tx_threshold),
	SXGBE_STAT(rx_threshold),
	SXGBE_STAT(tx_pkt_n),
	SXGBE_STAT(rx_pkt_n),
	SXGBE_STAT(normal_irq_n),
	SXGBE_STAT(tx_normal_irq_n),
	SXGBE_STAT(rx_normal_irq_n),
	SXGBE_STAT(napi_poll),
	SXGBE_STAT(tx_clean),
	SXGBE_STAT(tx_reset_ic_bit),
	SXGBE_STAT(rx_process_stopped_irq),
	SXGBE_STAT(rx_underflow_irq),

	/* Bus access errors */
	SXGBE_STAT(fatal_bus_error_irq),
	SXGBE_STAT(tx_read_transfer_err),
	SXGBE_STAT(tx_write_transfer_err),
	SXGBE_STAT(tx_desc_access_err),
	SXGBE_STAT(tx_buffer_access_err),
	SXGBE_STAT(tx_data_transfer_err),
	SXGBE_STAT(rx_read_transfer_err),
	SXGBE_STAT(rx_write_transfer_err),
	SXGBE_STAT(rx_desc_access_err),
	SXGBE_STAT(rx_buffer_access_err),
	SXGBE_STAT(rx_data_transfer_err),

	/* EEE-LPI stats */
	SXGBE_STAT(tx_lpi_entry_n),
	SXGBE_STAT(tx_lpi_exit_n),
	SXGBE_STAT(rx_lpi_entry_n),
	SXGBE_STAT(rx_lpi_exit_n),
	SXGBE_STAT(eee_wakeup_error_n),

	/* RX specific */
	/* L2 error */
	SXGBE_STAT(rx_code_gmii_err),
	SXGBE_STAT(rx_watchdog_err),
	SXGBE_STAT(rx_crc_err),
	SXGBE_STAT(rx_gaint_pkt_err),
	SXGBE_STAT(ip_hdr_err),
	SXGBE_STAT(ip_payload_err),
	SXGBE_STAT(overflow_error),

	/* L2 Pkt type */
	SXGBE_STAT(len_pkt),
	SXGBE_STAT(mac_ctl_pkt),
	SXGBE_STAT(dcb_ctl_pkt),
	SXGBE_STAT(arp_pkt),
	SXGBE_STAT(oam_pkt),
	SXGBE_STAT(untag_okt),
	SXGBE_STAT(other_pkt),
	SXGBE_STAT(svlan_tag_pkt),
	SXGBE_STAT(cvlan_tag_pkt),
	SXGBE_STAT(dvlan_ocvlan_icvlan_pkt),
	SXGBE_STAT(dvlan_osvlan_isvlan_pkt),
	SXGBE_STAT(dvlan_osvlan_icvlan_pkt),
	SXGBE_STAT(dvan_ocvlan_icvlan_pkt),

	/* L3/L4 Pkt type */
	SXGBE_STAT(not_ip_pkt),
	SXGBE_STAT(ip4_tcp_pkt),
	SXGBE_STAT(ip4_udp_pkt),
	SXGBE_STAT(ip4_icmp_pkt),
	SXGBE_STAT(ip4_unknown_pkt),
	SXGBE_STAT(ip6_tcp_pkt),
	SXGBE_STAT(ip6_udp_pkt),
	SXGBE_STAT(ip6_icmp_pkt),
	SXGBE_STAT(ip6_unknown_pkt),

	/* Filter specific */
	SXGBE_STAT(vlan_filter_match),
	SXGBE_STAT(sa_filter_fail),
	SXGBE_STAT(da_filter_fail),
	SXGBE_STAT(hash_filter_pass),
	SXGBE_STAT(l3_filter_match),
	SXGBE_STAT(l4_filter_match),

	/* RX context specific */
	SXGBE_STAT(timestamp_dropped),
	SXGBE_STAT(rx_msg_type_no_ptp),
	SXGBE_STAT(rx_ptp_type_sync),
	SXGBE_STAT(rx_ptp_type_follow_up),
	SXGBE_STAT(rx_ptp_type_delay_req),
	SXGBE_STAT(rx_ptp_type_delay_resp),
	SXGBE_STAT(rx_ptp_type_pdelay_req),
	SXGBE_STAT(rx_ptp_type_pdelay_resp),
	SXGBE_STAT(rx_ptp_type_pdelay_follow_up),
	SXGBE_STAT(rx_ptp_announce),
	SXGBE_STAT(rx_ptp_mgmt),
	SXGBE_STAT(rx_ptp_signal),
	SXGBE_STAT(rx_ptp_resv_msg_type),
};
#define SXGBE_STATS_LEN ARRAY_SIZE(sxgbe_gstrings_stats)

static int sxgbe_get_eee(struct net_device *dev,
			 struct ethtool_eee *edata)
{
	struct sxgbe_priv_data *priv = netdev_priv(dev);

	if (!priv->hw_cap.eee)
		return -EOPNOTSUPP;

	edata->eee_enabled = priv->eee_enabled;
	edata->eee_active = priv->eee_active;
	edata->tx_lpi_timer = priv->tx_lpi_timer;

	return phy_ethtool_get_eee(dev->phydev, edata);
}

static int sxgbe_set_eee(struct net_device *dev,
			 struct ethtool_eee *edata)
{
	struct sxgbe_priv_data *priv = netdev_priv(dev);

	priv->eee_enabled = edata->eee_enabled;

	if (!priv->eee_enabled) {
		sxgbe_disable_eee_mode(priv);
	} else {
		/* We are asking for enabling the EEE but it is safe
		 * to verify all by invoking the eee_init function.
		 * In case of failure it will return an error.
		 */
		priv->eee_enabled = sxgbe_eee_init(priv);
		if (!priv->eee_enabled)
			return -EOPNOTSUPP;

		/* Do not change tx_lpi_timer in case of failure */
		priv->tx_lpi_timer = edata->tx_lpi_timer;
	}

	return phy_ethtool_set_eee(dev->phydev, edata);
}

static void sxgbe_getdrvinfo(struct net_device *dev,
			     struct ethtool_drvinfo *info)
{
	strlcpy(info->driver, KBUILD_MODNAME, sizeof(info->driver));
	strlcpy(info->version, DRV_VERSION, sizeof(info->version));
}

static u32 sxgbe_getmsglevel(struct net_device *dev)
{
	struct sxgbe_priv_data *priv = netdev_priv(dev);
	return priv->msg_enable;
}

static void sxgbe_setmsglevel(struct net_device *dev, u32 level)
{
	struct sxgbe_priv_data *priv = netdev_priv(dev);
	priv->msg_enable = level;
}

static void sxgbe_get_strings(struct net_device *dev, u32 stringset, u8 *data)
{
	int i;
	u8 *p = data;

	switch (stringset) {
	case ETH_SS_STATS:
		for (i = 0; i < SXGBE_STATS_LEN; i++) {
			memcpy(p, sxgbe_gstrings_stats[i].stat_string,
			       ETH_GSTRING_LEN);
			p += ETH_GSTRING_LEN;
		}
		break;
	default:
		WARN_ON(1);
		break;
	}
}

static int sxgbe_get_sset_count(struct net_device *netdev, int sset)
{
	int len;

	switch (sset) {
	case ETH_SS_STATS:
		len = SXGBE_STATS_LEN;
		return len;
	default:
		return -EINVAL;
	}
}

static void sxgbe_get_ethtool_stats(struct net_device *dev,
				    struct ethtool_stats *dummy, u64 *data)
{
	struct sxgbe_priv_data *priv = netdev_priv(dev);
	int i;
	char *p;

	if (priv->eee_enabled) {
		int val = phy_get_eee_err(dev->phydev);

		if (val)
			priv->xstats.eee_wakeup_error_n = val;
	}

	for (i = 0; i < SXGBE_STATS_LEN; i++) {
		p = (char *)priv + sxgbe_gstrings_stats[i].stat_offset;
		data[i] = (sxgbe_gstrings_stats[i].sizeof_stat == sizeof(u64))
			? (*(u64 *)p) : (*(u32 *)p);
	}
}

static void sxgbe_get_channels(struct net_device *dev,
			       struct ethtool_channels *channel)
{
	channel->max_rx = SXGBE_MAX_RX_CHANNELS;
	channel->max_tx = SXGBE_MAX_TX_CHANNELS;
	channel->rx_count = SXGBE_RX_QUEUES;
	channel->tx_count = SXGBE_TX_QUEUES;
}

static u32 sxgbe_riwt2usec(u32 riwt, struct sxgbe_priv_data *priv)
{
	unsigned long clk = clk_get_rate(priv->sxgbe_clk);

	if (!clk)
		return 0;

	return (riwt * 256) / (clk / 1000000);
}

static u32 sxgbe_usec2riwt(u32 usec, struct sxgbe_priv_data *priv)
{
	unsigned long clk = clk_get_rate(priv->sxgbe_clk);

	if (!clk)
		return 0;

	return (usec * (clk / 1000000)) / 256;
}

static int sxgbe_get_coalesce(struct net_device *dev,
			      struct ethtool_coalesce *ec)
{
	struct sxgbe_priv_data *priv = netdev_priv(dev);

	if (priv->use_riwt)
		ec->rx_coalesce_usecs = sxgbe_riwt2usec(priv->rx_riwt, priv);

	return 0;
}

static int sxgbe_set_coalesce(struct net_device *dev,
			      struct ethtool_coalesce *ec)
{
	struct sxgbe_priv_data *priv = netdev_priv(dev);
	unsigned int rx_riwt;

	if (!ec->rx_coalesce_usecs)
		return -EINVAL;

	rx_riwt = sxgbe_usec2riwt(ec->rx_coalesce_usecs, priv);

	if ((rx_riwt > SXGBE_MAX_DMA_RIWT) || (rx_riwt < SXGBE_MIN_DMA_RIWT))
		return -EINVAL;
	else if (!priv->use_riwt)
		return -EOPNOTSUPP;

	priv->rx_riwt = rx_riwt;
	priv->hw->dma->rx_watchdog(priv->ioaddr, priv->rx_riwt);

	return 0;
}

static int sxgbe_get_rss_hash_opts(struct sxgbe_priv_data *priv,
				   struct ethtool_rxnfc *cmd)
{
	cmd->data = 0;

	/* Report default options for RSS on sxgbe */
	switch (cmd->flow_type) {
	case TCP_V4_FLOW:
	case UDP_V4_FLOW:
		cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
		fallthrough;
	case SCTP_V4_FLOW:
	case AH_ESP_V4_FLOW:
	case AH_V4_FLOW:
	case ESP_V4_FLOW:
	case IPV4_FLOW:
		cmd->data |= RXH_IP_SRC | RXH_IP_DST;
		break;
	case TCP_V6_FLOW:
	case UDP_V6_FLOW:
		cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
		fallthrough;
	case SCTP_V6_FLOW:
	case AH_ESP_V6_FLOW:
	case AH_V6_FLOW:
	case ESP_V6_FLOW:
	case IPV6_FLOW:
		cmd->data |= RXH_IP_SRC | RXH_IP_DST;
		break;
	default:
		return -EINVAL;
	}

	return 0;
}

static int sxgbe_get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd,
			   u32 *rule_locs)
{
	struct sxgbe_priv_data *priv = netdev_priv(dev);
	int ret = -EOPNOTSUPP;

	switch (cmd->cmd) {
	case ETHTOOL_GRXFH:
		ret = sxgbe_get_rss_hash_opts(priv, cmd);
		break;
	default:
		break;
	}

	return ret;
}

static int sxgbe_set_rss_hash_opt(struct sxgbe_priv_data *priv,
				  struct ethtool_rxnfc *cmd)
{
	u32 reg_val = 0;

	/* RSS does not support anything other than hashing
	 * to queues on src and dst IPs and ports
	 */
	if (cmd->data & ~(RXH_IP_SRC | RXH_IP_DST |
			  RXH_L4_B_0_1 | RXH_L4_B_2_3))
		return -EINVAL;

	switch (cmd->flow_type) {
	case TCP_V4_FLOW:
	case TCP_V6_FLOW:
		if (!(cmd->data & RXH_IP_SRC) ||
		    !(cmd->data & RXH_IP_DST) ||
		    !(cmd->data & RXH_L4_B_0_1) ||
		    !(cmd->data & RXH_L4_B_2_3))
			return -EINVAL;
		reg_val = SXGBE_CORE_RSS_CTL_TCP4TE;
		break;
	case UDP_V4_FLOW:
	case UDP_V6_FLOW:
		if (!(cmd->data & RXH_IP_SRC) ||
		    !(cmd->data & RXH_IP_DST) ||
		    !(cmd->data & RXH_L4_B_0_1) ||
		    !(cmd->data & RXH_L4_B_2_3))
			return -EINVAL;
		reg_val = SXGBE_CORE_RSS_CTL_UDP4TE;
		break;
	case SCTP_V4_FLOW:
	case AH_ESP_V4_FLOW:
	case AH_V4_FLOW:
	case ESP_V4_FLOW:
	case AH_ESP_V6_FLOW:
	case AH_V6_FLOW:
	case ESP_V6_FLOW:
	case SCTP_V6_FLOW:
	case IPV4_FLOW:
	case IPV6_FLOW:
		if (!(cmd->data & RXH_IP_SRC) ||
		    !(cmd->data & RXH_IP_DST) ||
		    (cmd->data & RXH_L4_B_0_1) ||
		    (cmd->data & RXH_L4_B_2_3))
			return -EINVAL;
		reg_val = SXGBE_CORE_RSS_CTL_IP2TE;
		break;
	default:
		return -EINVAL;
	}

	/* Read SXGBE RSS control register and update */
	reg_val |= readl(priv->ioaddr + SXGBE_CORE_RSS_CTL_REG);
	writel(reg_val, priv->ioaddr + SXGBE_CORE_RSS_CTL_REG);
	readl(priv->ioaddr + SXGBE_CORE_RSS_CTL_REG);

	return 0;
}

static int sxgbe_set_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd)
{
	struct sxgbe_priv_data *priv = netdev_priv(dev);
	int ret = -EOPNOTSUPP;

	switch (cmd->cmd) {
	case ETHTOOL_SRXFH:
		ret = sxgbe_set_rss_hash_opt(priv, cmd);
		break;
	default:
		break;
	}

	return ret;
}

static void sxgbe_get_regs(struct net_device *dev,
			   struct ethtool_regs *regs, void *space)
{
	struct sxgbe_priv_data *priv = netdev_priv(dev);
	u32 *reg_space = (u32 *)space;
	int reg_offset;
	int reg_ix = 0;
	void __iomem *ioaddr = priv->ioaddr;

	memset(reg_space, 0x0, REG_SPACE_SIZE);

	/* MAC registers */
	for (reg_offset = START_MAC_REG_OFFSET;
	     reg_offset <= MAX_MAC_REG_OFFSET; reg_offset += 4) {
		reg_space[reg_ix] = readl(ioaddr + reg_offset);
		reg_ix++;
	}

	/* MTL registers */
	for (reg_offset = START_MTL_REG_OFFSET;
	     reg_offset <= MAX_MTL_REG_OFFSET; reg_offset += 4) {
		reg_space[reg_ix] = readl(ioaddr + reg_offset);
		reg_ix++;
	}

	/* DMA registers */
	for (reg_offset = START_DMA_REG_OFFSET;
	     reg_offset <= MAX_DMA_REG_OFFSET; reg_offset += 4) {
		reg_space[reg_ix] = readl(ioaddr + reg_offset);
		reg_ix++;
	}

	BUG_ON(reg_ix * 4 > REG_SPACE_SIZE);
}

static int sxgbe_get_regs_len(struct net_device *dev)
{
	return REG_SPACE_SIZE;
}

static const struct ethtool_ops sxgbe_ethtool_ops = {
	.supported_coalesce_params = ETHTOOL_COALESCE_RX_USECS,
	.get_drvinfo = sxgbe_getdrvinfo,
	.get_msglevel = sxgbe_getmsglevel,
	.set_msglevel = sxgbe_setmsglevel,
	.get_link = ethtool_op_get_link,
	.get_strings = sxgbe_get_strings,
	.get_ethtool_stats = sxgbe_get_ethtool_stats,
	.get_sset_count = sxgbe_get_sset_count,
	.get_channels = sxgbe_get_channels,
	.get_coalesce = sxgbe_get_coalesce,
	.set_coalesce = sxgbe_set_coalesce,
	.get_rxnfc = sxgbe_get_rxnfc,
	.set_rxnfc = sxgbe_set_rxnfc,
	.get_regs = sxgbe_get_regs,
	.get_regs_len = sxgbe_get_regs_len,
	.get_eee = sxgbe_get_eee,
	.set_eee = sxgbe_set_eee,
	.get_link_ksettings = phy_ethtool_get_link_ksettings,
	.set_link_ksettings = phy_ethtool_set_link_ksettings,
};

void sxgbe_set_ethtool_ops(struct net_device *netdev)
{
	netdev->ethtool_ops = &sxgbe_ethtool_ops;
}
Commit	Line	Data
d2912cb1	1	// SPDX-License-Identifier: GPL-2.0-only
1edb9ca6 SR	2	/* 10G controller driver for Samsung SoCs
	3	*
	4	* Copyright (C) 2013 Samsung Electronics Co., Ltd.
	5	* http://www.samsung.com
	6	*
	7	* Author: Siva Reddy Kallam <siva.kallam@samsung.com>
1edb9ca6 SR	8	*/
	9
	10	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
	11
25f72a74 VP	12	#include <linux/clk.h>
25f72a74 VP	13	#include <linux/interrupt.h>
1edb9ca6 SR	14	#include <linux/kernel.h>
1edb9ca6 SR	15	#include <linux/netdevice.h>
25f72a74	16	#include <linux/net_tstamp.h>
1edb9ca6	17	#include <linux/phy.h>
25f72a74	18	#include <linux/ptp_clock_kernel.h>
1edb9ca6 SR	19
1edb9ca6 SR	20	#include "sxgbe_common.h"
25f72a74 VP	21	#include "sxgbe_reg.h"
25f72a74 VP	22	#include "sxgbe_dma.h"
1edb9ca6 SR	23
	24	struct sxgbe_stats {
	25	char stat_string[ETH_GSTRING_LEN];
	26	int sizeof_stat;
	27	int stat_offset;
	28	};
	29
	30	#define SXGBE_STAT(m) \
	31	{ \
	32	#m, \
c593642c	33	sizeof_field(struct sxgbe_extra_stats, m), \
1edb9ca6 SR	34	offsetof(struct sxgbe_priv_data, xstats.m) \
	35	}
	36
	37	static const struct sxgbe_stats sxgbe_gstrings_stats[] = {
25f72a74 VP	38	/* TX/RX IRQ events */
	39	SXGBE_STAT(tx_process_stopped_irq),
	40	SXGBE_STAT(tx_ctxt_desc_err),
	41	SXGBE_STAT(tx_threshold),
	42	SXGBE_STAT(rx_threshold),
	43	SXGBE_STAT(tx_pkt_n),
	44	SXGBE_STAT(rx_pkt_n),
	45	SXGBE_STAT(normal_irq_n),
	46	SXGBE_STAT(tx_normal_irq_n),
	47	SXGBE_STAT(rx_normal_irq_n),
	48	SXGBE_STAT(napi_poll),
	49	SXGBE_STAT(tx_clean),
	50	SXGBE_STAT(tx_reset_ic_bit),
	51	SXGBE_STAT(rx_process_stopped_irq),
	52	SXGBE_STAT(rx_underflow_irq),
	53
	54	/* Bus access errors */
	55	SXGBE_STAT(fatal_bus_error_irq),
	56	SXGBE_STAT(tx_read_transfer_err),
	57	SXGBE_STAT(tx_write_transfer_err),
	58	SXGBE_STAT(tx_desc_access_err),
	59	SXGBE_STAT(tx_buffer_access_err),
	60	SXGBE_STAT(tx_data_transfer_err),
	61	SXGBE_STAT(rx_read_transfer_err),
	62	SXGBE_STAT(rx_write_transfer_err),
	63	SXGBE_STAT(rx_desc_access_err),
	64	SXGBE_STAT(rx_buffer_access_err),
	65	SXGBE_STAT(rx_data_transfer_err),
	66
	67	/* EEE-LPI stats */
acc18c14 G	68	SXGBE_STAT(tx_lpi_entry_n),
	69	SXGBE_STAT(tx_lpi_exit_n),
	70	SXGBE_STAT(rx_lpi_entry_n),
	71	SXGBE_STAT(rx_lpi_exit_n),
	72	SXGBE_STAT(eee_wakeup_error_n),
25f72a74 VP	73
	74	/* RX specific */
	75	/* L2 error */
	76	SXGBE_STAT(rx_code_gmii_err),
	77	SXGBE_STAT(rx_watchdog_err),
	78	SXGBE_STAT(rx_crc_err),
	79	SXGBE_STAT(rx_gaint_pkt_err),
	80	SXGBE_STAT(ip_hdr_err),
	81	SXGBE_STAT(ip_payload_err),
	82	SXGBE_STAT(overflow_error),
	83
	84	/* L2 Pkt type */
	85	SXGBE_STAT(len_pkt),
	86	SXGBE_STAT(mac_ctl_pkt),
	87	SXGBE_STAT(dcb_ctl_pkt),
	88	SXGBE_STAT(arp_pkt),
	89	SXGBE_STAT(oam_pkt),
	90	SXGBE_STAT(untag_okt),
	91	SXGBE_STAT(other_pkt),
	92	SXGBE_STAT(svlan_tag_pkt),
	93	SXGBE_STAT(cvlan_tag_pkt),
	94	SXGBE_STAT(dvlan_ocvlan_icvlan_pkt),
	95	SXGBE_STAT(dvlan_osvlan_isvlan_pkt),
	96	SXGBE_STAT(dvlan_osvlan_icvlan_pkt),
	97	SXGBE_STAT(dvan_ocvlan_icvlan_pkt),
	98
	99	/* L3/L4 Pkt type */
	100	SXGBE_STAT(not_ip_pkt),
	101	SXGBE_STAT(ip4_tcp_pkt),
	102	SXGBE_STAT(ip4_udp_pkt),
	103	SXGBE_STAT(ip4_icmp_pkt),
	104	SXGBE_STAT(ip4_unknown_pkt),
	105	SXGBE_STAT(ip6_tcp_pkt),
	106	SXGBE_STAT(ip6_udp_pkt),
	107	SXGBE_STAT(ip6_icmp_pkt),
	108	SXGBE_STAT(ip6_unknown_pkt),
	109
	110	/* Filter specific */
	111	SXGBE_STAT(vlan_filter_match),
	112	SXGBE_STAT(sa_filter_fail),
	113	SXGBE_STAT(da_filter_fail),
	114	SXGBE_STAT(hash_filter_pass),
	115	SXGBE_STAT(l3_filter_match),
	116	SXGBE_STAT(l4_filter_match),
	117
	118	/* RX context specific */
	119	SXGBE_STAT(timestamp_dropped),
	120	SXGBE_STAT(rx_msg_type_no_ptp),
	121	SXGBE_STAT(rx_ptp_type_sync),
	122	SXGBE_STAT(rx_ptp_type_follow_up),
	123	SXGBE_STAT(rx_ptp_type_delay_req),
	124	SXGBE_STAT(rx_ptp_type_delay_resp),
	125	SXGBE_STAT(rx_ptp_type_pdelay_req),
	126	SXGBE_STAT(rx_ptp_type_pdelay_resp),
	127	SXGBE_STAT(rx_ptp_type_pdelay_follow_up),
	128	SXGBE_STAT(rx_ptp_announce),
	129	SXGBE_STAT(rx_ptp_mgmt),
	130	SXGBE_STAT(rx_ptp_signal),
	131	SXGBE_STAT(rx_ptp_resv_msg_type),
1edb9ca6 SR	132	};
	133	#define SXGBE_STATS_LEN ARRAY_SIZE(sxgbe_gstrings_stats)
	134
acc18c14 G	135	static int sxgbe_get_eee(struct net_device *dev,
	136	struct ethtool_eee *edata)
	137	{
	138	struct sxgbe_priv_data *priv = netdev_priv(dev);
	139
	140	if (!priv->hw_cap.eee)
	141	return -EOPNOTSUPP;
	142
	143	edata->eee_enabled = priv->eee_enabled;
	144	edata->eee_active = priv->eee_active;
	145	edata->tx_lpi_timer = priv->tx_lpi_timer;
	146
2ebc440a	147	return phy_ethtool_get_eee(dev->phydev, edata);
acc18c14 G	148	}
	149
	150	static int sxgbe_set_eee(struct net_device *dev,
	151	struct ethtool_eee *edata)
	152	{
	153	struct sxgbe_priv_data *priv = netdev_priv(dev);
	154
	155	priv->eee_enabled = edata->eee_enabled;
	156
	157	if (!priv->eee_enabled) {
	158	sxgbe_disable_eee_mode(priv);
	159	} else {
	160	/* We are asking for enabling the EEE but it is safe
	161	* to verify all by invoking the eee_init function.
	162	* In case of failure it will return an error.
	163	*/
	164	priv->eee_enabled = sxgbe_eee_init(priv);
	165	if (!priv->eee_enabled)
	166	return -EOPNOTSUPP;
	167
	168	/* Do not change tx_lpi_timer in case of failure */
	169	priv->tx_lpi_timer = edata->tx_lpi_timer;
	170	}
	171
2ebc440a	172	return phy_ethtool_set_eee(dev->phydev, edata);
acc18c14 G	173	}
acc18c14 G	174
25f72a74 VP	175	static void sxgbe_getdrvinfo(struct net_device *dev,
	176	struct ethtool_drvinfo *info)
	177	{
	178	strlcpy(info->driver, KBUILD_MODNAME, sizeof(info->driver));
	179	strlcpy(info->version, DRV_VERSION, sizeof(info->version));
	180	}
	181
25f72a74 VP	182	static u32 sxgbe_getmsglevel(struct net_device *dev)
	183	{
	184	struct sxgbe_priv_data *priv = netdev_priv(dev);
	185	return priv->msg_enable;
	186	}
	187
	188	static void sxgbe_setmsglevel(struct net_device *dev, u32 level)
	189	{
	190	struct sxgbe_priv_data *priv = netdev_priv(dev);
	191	priv->msg_enable = level;
	192	}
	193
	194	static void sxgbe_get_strings(struct net_device dev, u32 stringset, u8 data)
	195	{
	196	int i;
	197	u8 *p = data;
	198
	199	switch (stringset) {
	200	case ETH_SS_STATS:
	201	for (i = 0; i < SXGBE_STATS_LEN; i++) {
	202	memcpy(p, sxgbe_gstrings_stats[i].stat_string,
	203	ETH_GSTRING_LEN);
	204	p += ETH_GSTRING_LEN;
	205	}
	206	break;
	207	default:
	208	WARN_ON(1);
	209	break;
	210	}
	211	}
	212
	213	static int sxgbe_get_sset_count(struct net_device *netdev, int sset)
	214	{
	215	int len;
	216
	217	switch (sset) {
	218	case ETH_SS_STATS:
	219	len = SXGBE_STATS_LEN;
	220	return len;
	221	default:
	222	return -EINVAL;
	223	}
	224	}
	225
	226	static void sxgbe_get_ethtool_stats(struct net_device *dev,
	227	struct ethtool_stats dummy, u64 data)
	228	{
	229	struct sxgbe_priv_data *priv = netdev_priv(dev);
	230	int i;
	231	char *p;
	232
	233	if (priv->eee_enabled) {
2ebc440a	234	int val = phy_get_eee_err(dev->phydev);
25f72a74 VP	235
	236	if (val)
	237	priv->xstats.eee_wakeup_error_n = val;
	238	}
	239
	240	for (i = 0; i < SXGBE_STATS_LEN; i++) {
	241	p = (char *)priv + sxgbe_gstrings_stats[i].stat_offset;
	242	data[i] = (sxgbe_gstrings_stats[i].sizeof_stat == sizeof(u64))
	243	? ((u64 )p) : ((u32 )p);
	244	}
	245	}
	246
	247	static void sxgbe_get_channels(struct net_device *dev,
	248	struct ethtool_channels *channel)
	249	{
	250	channel->max_rx = SXGBE_MAX_RX_CHANNELS;
	251	channel->max_tx = SXGBE_MAX_TX_CHANNELS;
	252	channel->rx_count = SXGBE_RX_QUEUES;
	253	channel->tx_count = SXGBE_TX_QUEUES;
	254	}
	255
	256	static u32 sxgbe_riwt2usec(u32 riwt, struct sxgbe_priv_data *priv)
	257	{
	258	unsigned long clk = clk_get_rate(priv->sxgbe_clk);
	259
	260	if (!clk)
	261	return 0;
	262
	263	return (riwt * 256) / (clk / 1000000);
	264	}
	265
	266	static u32 sxgbe_usec2riwt(u32 usec, struct sxgbe_priv_data *priv)
	267	{
	268	unsigned long clk = clk_get_rate(priv->sxgbe_clk);
	269
	270	if (!clk)
	271	return 0;
	272
	273	return (usec * (clk / 1000000)) / 256;
	274	}
	275
	276	static int sxgbe_get_coalesce(struct net_device *dev,
	277	struct ethtool_coalesce *ec)
	278	{
	279	struct sxgbe_priv_data *priv = netdev_priv(dev);
	280
	281	if (priv->use_riwt)
	282	ec->rx_coalesce_usecs = sxgbe_riwt2usec(priv->rx_riwt, priv);
	283
	284	return 0;
	285	}
	286
	287	static int sxgbe_set_coalesce(struct net_device *dev,
	288	struct ethtool_coalesce *ec)
	289	{
	290	struct sxgbe_priv_data *priv = netdev_priv(dev);
	291	unsigned int rx_riwt;
	292
	293	if (!ec->rx_coalesce_usecs)
	294	return -EINVAL;
	295
	296	rx_riwt = sxgbe_usec2riwt(ec->rx_coalesce_usecs, priv);
	297
	298	if ((rx_riwt > SXGBE_MAX_DMA_RIWT) \|\| (rx_riwt < SXGBE_MIN_DMA_RIWT))
299	return -EINVAL;
300	else if (!priv->use_riwt)
301	return -EOPNOTSUPP;
302
303	priv->rx_riwt = rx_riwt;
304	priv->hw->dma->rx_watchdog(priv->ioaddr, priv->rx_riwt);
305
306	return 0;
307	}
308
309	static int sxgbe_get_rss_hash_opts(struct sxgbe_priv_data *priv,
310	struct ethtool_rxnfc *cmd)
311	{
312	cmd->data = 0;
313
314	/* Report default options for RSS on sxgbe */
315	switch (cmd->flow_type) {
316	case TCP_V4_FLOW:
317	case UDP_V4_FLOW:
318	cmd->data \|= RXH_L4_B_0_1 \| RXH_L4_B_2_3;
df561f66	319	fallthrough;
25f72a74 VP	320	case SCTP_V4_FLOW:
	321	case AH_ESP_V4_FLOW:
	322	case AH_V4_FLOW:
	323	case ESP_V4_FLOW:
	324	case IPV4_FLOW:
	325	cmd->data \|= RXH_IP_SRC \| RXH_IP_DST;
	326	break;
	327	case TCP_V6_FLOW:
	328	case UDP_V6_FLOW:
	329	cmd->data \|= RXH_L4_B_0_1 \| RXH_L4_B_2_3;
df561f66	330	fallthrough;
25f72a74 VP	331	case SCTP_V6_FLOW:
	332	case AH_ESP_V6_FLOW:
	333	case AH_V6_FLOW:
	334	case ESP_V6_FLOW:
	335	case IPV6_FLOW:
	336	cmd->data \|= RXH_IP_SRC \| RXH_IP_DST;
	337	break;
	338	default:
	339	return -EINVAL;
	340	}
	341
	342	return 0;
	343	}
	344
	345	static int sxgbe_get_rxnfc(struct net_device dev, struct ethtool_rxnfc cmd,
	346	u32 *rule_locs)
	347	{
	348	struct sxgbe_priv_data *priv = netdev_priv(dev);
	349	int ret = -EOPNOTSUPP;
	350
	351	switch (cmd->cmd) {
	352	case ETHTOOL_GRXFH:
	353	ret = sxgbe_get_rss_hash_opts(priv, cmd);
	354	break;
	355	default:
	356	break;
	357	}
	358
	359	return ret;
	360	}
	361
	362	static int sxgbe_set_rss_hash_opt(struct sxgbe_priv_data *priv,
	363	struct ethtool_rxnfc *cmd)
	364	{
	365	u32 reg_val = 0;
	366
	367	/* RSS does not support anything other than hashing
	368	* to queues on src and dst IPs and ports
	369	*/
	370	if (cmd->data & ~(RXH_IP_SRC \| RXH_IP_DST \|
	371	RXH_L4_B_0_1 \| RXH_L4_B_2_3))
	372	return -EINVAL;
	373
	374	switch (cmd->flow_type) {
	375	case TCP_V4_FLOW:
	376	case TCP_V6_FLOW:
	377	if (!(cmd->data & RXH_IP_SRC) \|\|
	378	!(cmd->data & RXH_IP_DST) \|\|
	379	!(cmd->data & RXH_L4_B_0_1) \|\|
	380	!(cmd->data & RXH_L4_B_2_3))
	381	return -EINVAL;
	382	reg_val = SXGBE_CORE_RSS_CTL_TCP4TE;
	383	break;
	384	case UDP_V4_FLOW:
	385	case UDP_V6_FLOW:
	386	if (!(cmd->data & RXH_IP_SRC) \|\|
	387	!(cmd->data & RXH_IP_DST) \|\|
	388	!(cmd->data & RXH_L4_B_0_1) \|\|
	389	!(cmd->data & RXH_L4_B_2_3))
	390	return -EINVAL;
	391	reg_val = SXGBE_CORE_RSS_CTL_UDP4TE;
	392	break;
	393	case SCTP_V4_FLOW:
	394	case AH_ESP_V4_FLOW:
395	case AH_V4_FLOW:
396	case ESP_V4_FLOW:
397	case AH_ESP_V6_FLOW:
398	case AH_V6_FLOW:
399	case ESP_V6_FLOW:
400	case SCTP_V6_FLOW:
401	case IPV4_FLOW:
402	case IPV6_FLOW:
403	if (!(cmd->data & RXH_IP_SRC) \|\|
404	!(cmd->data & RXH_IP_DST) \|\|
405	(cmd->data & RXH_L4_B_0_1) \|\|
406	(cmd->data & RXH_L4_B_2_3))
407	return -EINVAL;
408	reg_val = SXGBE_CORE_RSS_CTL_IP2TE;
409	break;
410	default:
411	return -EINVAL;
412	}
413
414	/* Read SXGBE RSS control register and update */
415	reg_val \|= readl(priv->ioaddr + SXGBE_CORE_RSS_CTL_REG);
416	writel(reg_val, priv->ioaddr + SXGBE_CORE_RSS_CTL_REG);
417	readl(priv->ioaddr + SXGBE_CORE_RSS_CTL_REG);
418
419	return 0;
420	}
421
422	static int sxgbe_set_rxnfc(struct net_device dev, struct ethtool_rxnfc cmd)
423	{
424	struct sxgbe_priv_data *priv = netdev_priv(dev);
425	int ret = -EOPNOTSUPP;
426
427	switch (cmd->cmd) {
428	case ETHTOOL_SRXFH:
429	ret = sxgbe_set_rss_hash_opt(priv, cmd);
430	break;
431	default:
432	break;
433	}
434
435	return ret;
436	}
437
438	static void sxgbe_get_regs(struct net_device *dev,
439	struct ethtool_regs regs, void space)
440	{
441	struct sxgbe_priv_data *priv = netdev_priv(dev);
442	u32 reg_space = (u32 )space;
443	int reg_offset;
444	int reg_ix = 0;
445	void __iomem *ioaddr = priv->ioaddr;
446
447	memset(reg_space, 0x0, REG_SPACE_SIZE);
448
449	/* MAC registers */
450	for (reg_offset = START_MAC_REG_OFFSET;
451	reg_offset <= MAX_MAC_REG_OFFSET; reg_offset += 4) {
452	reg_space[reg_ix] = readl(ioaddr + reg_offset);
453	reg_ix++;
454	}
455
456	/* MTL registers */
457	for (reg_offset = START_MTL_REG_OFFSET;
458	reg_offset <= MAX_MTL_REG_OFFSET; reg_offset += 4) {
459	reg_space[reg_ix] = readl(ioaddr + reg_offset);
460	reg_ix++;
461	}
462
463	/* DMA registers */
464	for (reg_offset = START_DMA_REG_OFFSET;
465	reg_offset <= MAX_DMA_REG_OFFSET; reg_offset += 4) {
466	reg_space[reg_ix] = readl(ioaddr + reg_offset);
467	reg_ix++;
468	}
469
470	BUG_ON(reg_ix * 4 > REG_SPACE_SIZE);
471	}
472
473	static int sxgbe_get_regs_len(struct net_device *dev)
474	{
475	return REG_SPACE_SIZE;
476	}
477
1edb9ca6	478	static const struct ethtool_ops sxgbe_ethtool_ops = {
19d9ec99	479	.supported_coalesce_params = ETHTOOL_COALESCE_RX_USECS,
25f72a74	480	.get_drvinfo = sxgbe_getdrvinfo,
25f72a74 VP	481	.get_msglevel = sxgbe_getmsglevel,
	482	.set_msglevel = sxgbe_setmsglevel,
	483	.get_link = ethtool_op_get_link,
	484	.get_strings = sxgbe_get_strings,
	485	.get_ethtool_stats = sxgbe_get_ethtool_stats,
	486	.get_sset_count = sxgbe_get_sset_count,
	487	.get_channels = sxgbe_get_channels,
	488	.get_coalesce = sxgbe_get_coalesce,
	489	.set_coalesce = sxgbe_set_coalesce,
	490	.get_rxnfc = sxgbe_get_rxnfc,
	491	.set_rxnfc = sxgbe_set_rxnfc,
	492	.get_regs = sxgbe_get_regs,
	493	.get_regs_len = sxgbe_get_regs_len,
acc18c14 G	494	.get_eee = sxgbe_get_eee,
acc18c14 G	495	.set_eee = sxgbe_set_eee,
13e4c230 PR	496	.get_link_ksettings = phy_ethtool_get_link_ksettings,
13e4c230 PR	497	.set_link_ksettings = phy_ethtool_set_link_ksettings,
1edb9ca6 SR	498	};
	499
	500	void sxgbe_set_ethtool_ops(struct net_device *netdev)
	501	{
7ad24ea4	502	netdev->ethtool_ops = &sxgbe_ethtool_ops;
1edb9ca6	503	}