[mirror_ubuntu-bionic-kernel.git] / drivers / net / ethernet / hisilicon / hns3 / hns3pf / hns3_ethtool.c

/*
 * Copyright (c) 2016~2017 Hisilicon Limited.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 */

#include <linux/etherdevice.h>
#include <linux/string.h>

#include "hns3_enet.h"

struct hns3_stats {
	char stats_string[ETH_GSTRING_LEN];
	int stats_size;
	int stats_offset;
};

/* tqp related stats */
#define HNS3_TQP_STAT(_string, _member)	{			\
	.stats_string = _string,				\
	.stats_size = FIELD_SIZEOF(struct ring_stats, _member),	\
	.stats_offset = offsetof(struct hns3_enet_ring, stats),	\
}								\

static const struct hns3_stats hns3_txq_stats[] = {
	/* Tx per-queue statistics */
	HNS3_TQP_STAT("tx_io_err_cnt", io_err_cnt),
	HNS3_TQP_STAT("tx_sw_err_cnt", sw_err_cnt),
	HNS3_TQP_STAT("tx_seg_pkt_cnt", seg_pkt_cnt),
	HNS3_TQP_STAT("tx_pkts", tx_pkts),
	HNS3_TQP_STAT("tx_bytes", tx_bytes),
	HNS3_TQP_STAT("tx_err_cnt", tx_err_cnt),
	HNS3_TQP_STAT("tx_restart_queue", restart_queue),
	HNS3_TQP_STAT("tx_busy", tx_busy),
};

#define HNS3_TXQ_STATS_COUNT ARRAY_SIZE(hns3_txq_stats)

static const struct hns3_stats hns3_rxq_stats[] = {
	/* Rx per-queue statistics */
	HNS3_TQP_STAT("rx_io_err_cnt", io_err_cnt),
	HNS3_TQP_STAT("rx_sw_err_cnt", sw_err_cnt),
	HNS3_TQP_STAT("rx_seg_pkt_cnt", seg_pkt_cnt),
	HNS3_TQP_STAT("rx_pkts", rx_pkts),
	HNS3_TQP_STAT("rx_bytes", rx_bytes),
	HNS3_TQP_STAT("rx_err_cnt", rx_err_cnt),
	HNS3_TQP_STAT("rx_reuse_pg_cnt", reuse_pg_cnt),
	HNS3_TQP_STAT("rx_err_pkt_len", err_pkt_len),
	HNS3_TQP_STAT("rx_non_vld_descs", non_vld_descs),
	HNS3_TQP_STAT("rx_err_bd_num", err_bd_num),
	HNS3_TQP_STAT("rx_l2_err", l2_err),
	HNS3_TQP_STAT("rx_l3l4_csum_err", l3l4_csum_err),
};

#define HNS3_RXQ_STATS_COUNT ARRAY_SIZE(hns3_rxq_stats)

#define HNS3_TQP_STATS_COUNT (HNS3_TXQ_STATS_COUNT + HNS3_RXQ_STATS_COUNT)

struct hns3_link_mode_mapping {
	u32 hns3_link_mode;
	u32 ethtool_link_mode;
};

static const struct hns3_link_mode_mapping hns3_lm_map[] = {
	{HNS3_LM_FIBRE_BIT, ETHTOOL_LINK_MODE_FIBRE_BIT},
	{HNS3_LM_AUTONEG_BIT, ETHTOOL_LINK_MODE_Autoneg_BIT},
	{HNS3_LM_TP_BIT, ETHTOOL_LINK_MODE_TP_BIT},
	{HNS3_LM_PAUSE_BIT, ETHTOOL_LINK_MODE_Pause_BIT},
	{HNS3_LM_BACKPLANE_BIT, ETHTOOL_LINK_MODE_Backplane_BIT},
	{HNS3_LM_10BASET_HALF_BIT, ETHTOOL_LINK_MODE_10baseT_Half_BIT},
	{HNS3_LM_10BASET_FULL_BIT, ETHTOOL_LINK_MODE_10baseT_Full_BIT},
	{HNS3_LM_100BASET_HALF_BIT, ETHTOOL_LINK_MODE_100baseT_Half_BIT},
	{HNS3_LM_100BASET_FULL_BIT, ETHTOOL_LINK_MODE_100baseT_Full_BIT},
	{HNS3_LM_1000BASET_FULL_BIT, ETHTOOL_LINK_MODE_1000baseT_Full_BIT},
};

static void hns3_driv_to_eth_caps(u32 caps, struct ethtool_link_ksettings *cmd,
				  bool is_advertised)
{
	int i;

	for (i = 0; i < ARRAY_SIZE(hns3_lm_map); i++) {
		if (!(caps & hns3_lm_map[i].hns3_link_mode))
			continue;

		if (is_advertised) {
			ethtool_link_ksettings_zero_link_mode(cmd,
							      advertising);
			__set_bit(hns3_lm_map[i].ethtool_link_mode,
				  cmd->link_modes.advertising);
		} else {
			ethtool_link_ksettings_zero_link_mode(cmd,
							      supported);
			__set_bit(hns3_lm_map[i].ethtool_link_mode,
				  cmd->link_modes.supported);
		}
	}
}

static int hns3_get_sset_count(struct net_device *netdev, int stringset)
{
	struct hnae3_handle *h = hns3_get_handle(netdev);
	const struct hnae3_ae_ops *ops = h->ae_algo->ops;

	if (!ops->get_sset_count)
		return -EOPNOTSUPP;

	switch (stringset) {
	case ETH_SS_STATS:
		return ((HNS3_TQP_STATS_COUNT * h->kinfo.num_tqps) +
			ops->get_sset_count(h, stringset));

	case ETH_SS_TEST:
		return ops->get_sset_count(h, stringset);
	}

	return 0;
}

static void *hns3_update_strings(u8 *data, const struct hns3_stats *stats,
				 u32 stat_count, u32 num_tqps)
{
#define MAX_PREFIX_SIZE (8 + 4)
	u32 size_left;
	u32 i, j;
	u32 n1;

	for (i = 0; i < num_tqps; i++) {
		for (j = 0; j < stat_count; j++) {
			data[ETH_GSTRING_LEN - 1] = '\0';

			/* first, prepend the prefix string */
			n1 = snprintf(data, MAX_PREFIX_SIZE, "rcb_q%d_", i);
			n1 = min_t(uint, n1, MAX_PREFIX_SIZE - 1);
			size_left = (ETH_GSTRING_LEN - 1) - n1;

			/* now, concatenate the stats string to it */
			strncat(data, stats[j].stats_string, size_left);
			data += ETH_GSTRING_LEN;
		}
	}

	return data;
}

static u8 *hns3_get_strings_tqps(struct hnae3_handle *handle, u8 *data)
{
	struct hnae3_knic_private_info *kinfo = &handle->kinfo;

	/* get strings for Tx */
	data = hns3_update_strings(data, hns3_txq_stats, HNS3_TXQ_STATS_COUNT,
				   kinfo->num_tqps);

	/* get strings for Rx */
	data = hns3_update_strings(data, hns3_rxq_stats, HNS3_RXQ_STATS_COUNT,
				   kinfo->num_tqps);

	return data;
}

static void hns3_get_strings(struct net_device *netdev, u32 stringset, u8 *data)
{
	struct hnae3_handle *h = hns3_get_handle(netdev);
	const struct hnae3_ae_ops *ops = h->ae_algo->ops;
	char *buff = (char *)data;

	if (!ops->get_strings)
		return;

	switch (stringset) {
	case ETH_SS_STATS:
		buff = hns3_get_strings_tqps(h, buff);
		h->ae_algo->ops->get_strings(h, stringset, (u8 *)buff);
		break;
	case ETH_SS_TEST:
		ops->get_strings(h, stringset, data);
		break;
	}
}

static u64 *hns3_get_stats_tqps(struct hnae3_handle *handle, u64 *data)
{
	struct hns3_nic_priv *nic_priv = (struct hns3_nic_priv *)handle->priv;
	struct hnae3_knic_private_info *kinfo = &handle->kinfo;
	struct hns3_enet_ring *ring;
	u8 *stat;
	u32 i;

	/* get stats for Tx */
	for (i = 0; i < kinfo->num_tqps; i++) {
		ring = nic_priv->ring_data[i].ring;
		for (i = 0; i < HNS3_TXQ_STATS_COUNT; i++) {
			stat = (u8 *)ring + hns3_txq_stats[i].stats_offset;
			*data++ = *(u64 *)stat;
		}
	}

	/* get stats for Rx */
	for (i = 0; i < kinfo->num_tqps; i++) {
		ring = nic_priv->ring_data[i + kinfo->num_tqps].ring;
		for (i = 0; i < HNS3_RXQ_STATS_COUNT; i++) {
			stat = (u8 *)ring + hns3_rxq_stats[i].stats_offset;
			*data++ = *(u64 *)stat;
		}
	}

	return data;
}

/* hns3_get_stats - get detail statistics.
 * @netdev: net device
 * @stats: statistics info.
 * @data: statistics data.
 */
static void hns3_get_stats(struct net_device *netdev,
			   struct ethtool_stats *stats, u64 *data)
{
	struct hnae3_handle *h = hns3_get_handle(netdev);
	u64 *p = data;

	if (!h->ae_algo->ops->get_stats || !h->ae_algo->ops->update_stats) {
		netdev_err(netdev, "could not get any statistics\n");
		return;
	}

	h->ae_algo->ops->update_stats(h, &netdev->stats);

	/* get per-queue stats */
	p = hns3_get_stats_tqps(h, p);

	/* get MAC & other misc hardware stats */
	h->ae_algo->ops->get_stats(h, p);
}

static void hns3_get_drvinfo(struct net_device *netdev,
			     struct ethtool_drvinfo *drvinfo)
{
	struct hns3_nic_priv *priv = netdev_priv(netdev);
	struct hnae3_handle *h = priv->ae_handle;

	strncpy(drvinfo->version, hns3_driver_version,
		sizeof(drvinfo->version));
	drvinfo->version[sizeof(drvinfo->version) - 1] = '\0';

	strncpy(drvinfo->driver, h->pdev->driver->name,
		sizeof(drvinfo->driver));
	drvinfo->driver[sizeof(drvinfo->driver) - 1] = '\0';

	strncpy(drvinfo->bus_info, pci_name(h->pdev),
		sizeof(drvinfo->bus_info));
	drvinfo->bus_info[ETHTOOL_BUSINFO_LEN - 1] = '\0';

	snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version), "0x%08x",
		 priv->ae_handle->ae_algo->ops->get_fw_version(h));
}

static u32 hns3_get_link(struct net_device *netdev)
{
	struct hnae3_handle *h = hns3_get_handle(netdev);

	if (h->ae_algo && h->ae_algo->ops && h->ae_algo->ops->get_status)
		return h->ae_algo->ops->get_status(h);
	else
		return 0;
}

static void hns3_get_ringparam(struct net_device *netdev,
			       struct ethtool_ringparam *param)
{
	struct hns3_nic_priv *priv = netdev_priv(netdev);
	struct hnae3_handle *h = priv->ae_handle;
	int queue_num = h->kinfo.num_tqps;

	param->tx_max_pending = HNS3_RING_MAX_PENDING;
	param->rx_max_pending = HNS3_RING_MAX_PENDING;

	param->tx_pending = priv->ring_data[0].ring->desc_num;
	param->rx_pending = priv->ring_data[queue_num].ring->desc_num;
}

static void hns3_get_pauseparam(struct net_device *netdev,
				struct ethtool_pauseparam *param)
{
	struct hnae3_handle *h = hns3_get_handle(netdev);

	if (h->ae_algo && h->ae_algo->ops && h->ae_algo->ops->get_pauseparam)
		h->ae_algo->ops->get_pauseparam(h, &param->autoneg,
			&param->rx_pause, &param->tx_pause);
}

static int hns3_get_link_ksettings(struct net_device *netdev,
				   struct ethtool_link_ksettings *cmd)
{
	struct hnae3_handle *h = hns3_get_handle(netdev);
	u32 supported_caps;
	u32 advertised_caps;
	u8 media_type = HNAE3_MEDIA_TYPE_UNKNOWN;
	u8 link_stat;
	u8 auto_neg;
	u8 duplex;
	u32 speed;

	if (!h->ae_algo || !h->ae_algo->ops)
		return -EOPNOTSUPP;

	/* 1.auto_neg & speed & duplex from cmd */
	if (h->ae_algo->ops->get_ksettings_an_result) {
		h->ae_algo->ops->get_ksettings_an_result(h, &auto_neg,
							 &speed, &duplex);
		cmd->base.autoneg = auto_neg;
		cmd->base.speed = speed;
		cmd->base.duplex = duplex;

		link_stat = hns3_get_link(netdev);
		if (!link_stat) {
			cmd->base.speed = (u32)SPEED_UNKNOWN;
			cmd->base.duplex = DUPLEX_UNKNOWN;
		}
	}

	/* 2.media_type get from bios parameter block */
	if (h->ae_algo->ops->get_media_type) {
		h->ae_algo->ops->get_media_type(h, &media_type);

		switch (media_type) {
		case HNAE3_MEDIA_TYPE_FIBER:
			cmd->base.port = PORT_FIBRE;
			supported_caps = HNS3_LM_FIBRE_BIT |
					 HNS3_LM_AUTONEG_BIT |
					 HNS3_LM_PAUSE_BIT |
					 HNS3_LM_1000BASET_FULL_BIT;

			advertised_caps = supported_caps;
			break;
		case HNAE3_MEDIA_TYPE_COPPER:
			cmd->base.port = PORT_TP;
			supported_caps = HNS3_LM_TP_BIT |
					 HNS3_LM_AUTONEG_BIT |
					 HNS3_LM_PAUSE_BIT |
					 HNS3_LM_1000BASET_FULL_BIT |
					 HNS3_LM_100BASET_FULL_BIT |
					 HNS3_LM_100BASET_HALF_BIT |
					 HNS3_LM_10BASET_FULL_BIT |
					 HNS3_LM_10BASET_HALF_BIT;
			advertised_caps = supported_caps;
			break;
		case HNAE3_MEDIA_TYPE_BACKPLANE:
			cmd->base.port = PORT_NONE;
			supported_caps = HNS3_LM_BACKPLANE_BIT |
					 HNS3_LM_PAUSE_BIT |
					 HNS3_LM_AUTONEG_BIT |
					 HNS3_LM_1000BASET_FULL_BIT |
					 HNS3_LM_100BASET_FULL_BIT |
					 HNS3_LM_100BASET_HALF_BIT |
					 HNS3_LM_10BASET_FULL_BIT |
					 HNS3_LM_10BASET_HALF_BIT;

			advertised_caps = supported_caps;
			break;
		case HNAE3_MEDIA_TYPE_UNKNOWN:
		default:
			cmd->base.port = PORT_OTHER;
			supported_caps = 0;
			advertised_caps = 0;
			break;
		}

		/* now, map driver link modes to ethtool link modes */
		hns3_driv_to_eth_caps(supported_caps, cmd, false);
		hns3_driv_to_eth_caps(advertised_caps, cmd, true);
	}

	/* 3.mdix_ctrl&mdix get from phy reg */
	if (h->ae_algo->ops->get_mdix_mode)
		h->ae_algo->ops->get_mdix_mode(h, &cmd->base.eth_tp_mdix_ctrl,
					       &cmd->base.eth_tp_mdix);
	/* 4.mdio_support */
	cmd->base.mdio_support = ETH_MDIO_SUPPORTS_C22;

	return 0;
}

static u32 hns3_get_rss_key_size(struct net_device *netdev)
{
	struct hnae3_handle *h = hns3_get_handle(netdev);

	if (!h->ae_algo || !h->ae_algo->ops ||
	    !h->ae_algo->ops->get_rss_key_size)
		return -EOPNOTSUPP;

	return h->ae_algo->ops->get_rss_key_size(h);
}

static u32 hns3_get_rss_indir_size(struct net_device *netdev)
{
	struct hnae3_handle *h = hns3_get_handle(netdev);

	if (!h->ae_algo || !h->ae_algo->ops ||
	    !h->ae_algo->ops->get_rss_indir_size)
		return -EOPNOTSUPP;

	return h->ae_algo->ops->get_rss_indir_size(h);
}

static int hns3_get_rss(struct net_device *netdev, u32 *indir, u8 *key,
			u8 *hfunc)
{
	struct hnae3_handle *h = hns3_get_handle(netdev);

	if (!h->ae_algo || !h->ae_algo->ops || !h->ae_algo->ops->get_rss)
		return -EOPNOTSUPP;

	return h->ae_algo->ops->get_rss(h, indir, key, hfunc);
}

static int hns3_set_rss(struct net_device *netdev, const u32 *indir,
			const u8 *key, const u8 hfunc)
{
	struct hnae3_handle *h = hns3_get_handle(netdev);

	if (!h->ae_algo || !h->ae_algo->ops || !h->ae_algo->ops->set_rss)
		return -EOPNOTSUPP;

	/* currently we only support Toeplitz hash */
	if ((hfunc != ETH_RSS_HASH_NO_CHANGE) && (hfunc != ETH_RSS_HASH_TOP)) {
		netdev_err(netdev,
			   "hash func not supported (only Toeplitz hash)\n");
		return -EOPNOTSUPP;
	}
	if (!indir) {
		netdev_err(netdev,
			   "set rss failed for indir is empty\n");
		return -EOPNOTSUPP;
	}

	return h->ae_algo->ops->set_rss(h, indir, key, hfunc);
}

static int hns3_get_rxnfc(struct net_device *netdev,
			  struct ethtool_rxnfc *cmd,
			  u32 *rule_locs)
{
	struct hnae3_handle *h = hns3_get_handle(netdev);

	if (!h->ae_algo || !h->ae_algo->ops || !h->ae_algo->ops->get_tc_size)
		return -EOPNOTSUPP;

	switch (cmd->cmd) {
	case ETHTOOL_GRXRINGS:
		cmd->data = h->ae_algo->ops->get_tc_size(h);
		break;
	default:
		return -EOPNOTSUPP;
	}

	return 0;
}

int hns3_change_all_ring_bd_num(struct hns3_nic_priv *priv, u32 new_desc_num)
{
	struct hnae3_handle *h = priv->ae_handle;
	int i;

	h->kinfo.num_desc = new_desc_num;

	for (i = 0; i < h->kinfo.num_tqps * 2; i++)
		priv->ring_data[i].ring->desc_num = new_desc_num;

	return hns3_init_all_ring(priv);
}

int hns3_set_ringparam(struct net_device *ndev, struct ethtool_ringparam *param)
{
	struct hns3_nic_priv *priv = netdev_priv(ndev);
	struct hnae3_handle *h = priv->ae_handle;
	bool if_running = netif_running(ndev);
	u32 old_desc_num, new_desc_num;
	int ret;

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

	if (param->tx_pending != param->rx_pending) {
		netdev_err(ndev,
			   "Descriptors of tx and rx must be equal");
		return -EINVAL;
	}

	if (param->tx_pending > HNS3_RING_MAX_PENDING ||
	    param->tx_pending < HNS3_RING_MIN_PENDING) {
		netdev_err(ndev,
			   "Descriptors requested (Tx/Rx: %d) out of range [%d-%d]\n",
			   param->tx_pending, HNS3_RING_MIN_PENDING,
			   HNS3_RING_MAX_PENDING);
		return -EINVAL;
	}

	new_desc_num = param->tx_pending;

	/* Hardware requires that its descriptors must be multiple of eight */
	new_desc_num = ALIGN(new_desc_num, HNS3_RING_BD_MULTIPLE);
	old_desc_num = h->kinfo.num_desc;
	if (old_desc_num == new_desc_num)
		return 0;

	netdev_info(ndev,
		    "Changing descriptor count from %d to %d.\n",
		    old_desc_num, new_desc_num);

	if (if_running)
		dev_close(ndev);

	ret = hns3_uninit_all_ring(priv);
	if (ret)
		return ret;

	ret = hns3_change_all_ring_bd_num(priv, new_desc_num);
	if (ret) {
		ret = hns3_change_all_ring_bd_num(priv, old_desc_num);
		if (ret) {
			netdev_err(ndev,
				   "Revert to old bd num fail, ret=%d.\n", ret);
			return ret;
		}
	}

	if (if_running)
		ret = dev_open(ndev);

	return ret;
}

static int hns3_set_rxnfc(struct net_device *netdev, struct ethtool_rxnfc *cmd)
{
	struct hnae3_handle *h = hns3_get_handle(netdev);

	if (!h->ae_algo || !h->ae_algo->ops || !h->ae_algo->ops->set_rss_tuple)
		return -EOPNOTSUPP;

	switch (cmd->cmd) {
	case ETHTOOL_SRXFH:
		return h->ae_algo->ops->set_rss_tuple(h, cmd);
	default:
		return -EOPNOTSUPP;
	}
}

static const struct ethtool_ops hns3_ethtool_ops = {
	.get_drvinfo = hns3_get_drvinfo,
	.get_link = hns3_get_link,
	.get_ringparam = hns3_get_ringparam,
	.set_ringparam = hns3_set_ringparam,
	.get_pauseparam = hns3_get_pauseparam,
	.get_strings = hns3_get_strings,
	.get_ethtool_stats = hns3_get_stats,
	.get_sset_count = hns3_get_sset_count,
	.get_rxnfc = hns3_get_rxnfc,
	.set_rxnfc = hns3_set_rxnfc,
	.get_rxfh_key_size = hns3_get_rss_key_size,
	.get_rxfh_indir_size = hns3_get_rss_indir_size,
	.get_rxfh = hns3_get_rss,
	.set_rxfh = hns3_set_rss,
	.get_link_ksettings = hns3_get_link_ksettings,
};

void hns3_ethtool_set_ops(struct net_device *netdev)
{
	netdev->ethtool_ops = &hns3_ethtool_ops;
}
Commit	Line	Data
496d03e9 S	1	/*
	2	* Copyright (c) 2016~2017 Hisilicon Limited.
	3	*
	4	* This program is free software; you can redistribute it and/or modify
	5	* it under the terms of the GNU General Public License as published by
	6	* the Free Software Foundation; either version 2 of the License, or
	7	* (at your option) any later version.
	8	*/
	9
	10	#include <linux/etherdevice.h>
	11	#include <linux/string.h>
	12
	13	#include "hns3_enet.h"
	14
	15	struct hns3_stats {
	16	char stats_string[ETH_GSTRING_LEN];
	17	int stats_size;
	18	int stats_offset;
	19	};
	20
	21	/* tqp related stats */
	22	#define HNS3_TQP_STAT(_string, _member) { \
	23	.stats_string = _string, \
	24	.stats_size = FIELD_SIZEOF(struct ring_stats, _member), \
	25	.stats_offset = offsetof(struct hns3_enet_ring, stats), \
	26	} \
	27
	28	static const struct hns3_stats hns3_txq_stats[] = {
	29	/* Tx per-queue statistics */
	30	HNS3_TQP_STAT("tx_io_err_cnt", io_err_cnt),
	31	HNS3_TQP_STAT("tx_sw_err_cnt", sw_err_cnt),
	32	HNS3_TQP_STAT("tx_seg_pkt_cnt", seg_pkt_cnt),
	33	HNS3_TQP_STAT("tx_pkts", tx_pkts),
	34	HNS3_TQP_STAT("tx_bytes", tx_bytes),
	35	HNS3_TQP_STAT("tx_err_cnt", tx_err_cnt),
	36	HNS3_TQP_STAT("tx_restart_queue", restart_queue),
	37	HNS3_TQP_STAT("tx_busy", tx_busy),
	38	};
	39
	40	#define HNS3_TXQ_STATS_COUNT ARRAY_SIZE(hns3_txq_stats)
	41
	42	static const struct hns3_stats hns3_rxq_stats[] = {
	43	/* Rx per-queue statistics */
	44	HNS3_TQP_STAT("rx_io_err_cnt", io_err_cnt),
	45	HNS3_TQP_STAT("rx_sw_err_cnt", sw_err_cnt),
	46	HNS3_TQP_STAT("rx_seg_pkt_cnt", seg_pkt_cnt),
	47	HNS3_TQP_STAT("rx_pkts", rx_pkts),
	48	HNS3_TQP_STAT("rx_bytes", rx_bytes),
	49	HNS3_TQP_STAT("rx_err_cnt", rx_err_cnt),
	50	HNS3_TQP_STAT("rx_reuse_pg_cnt", reuse_pg_cnt),
	51	HNS3_TQP_STAT("rx_err_pkt_len", err_pkt_len),
	52	HNS3_TQP_STAT("rx_non_vld_descs", non_vld_descs),
	53	HNS3_TQP_STAT("rx_err_bd_num", err_bd_num),
	54	HNS3_TQP_STAT("rx_l2_err", l2_err),
	55	HNS3_TQP_STAT("rx_l3l4_csum_err", l3l4_csum_err),
	56	};
	57
	58	#define HNS3_RXQ_STATS_COUNT ARRAY_SIZE(hns3_rxq_stats)
	59
	60	#define HNS3_TQP_STATS_COUNT (HNS3_TXQ_STATS_COUNT + HNS3_RXQ_STATS_COUNT)
	61
	62	struct hns3_link_mode_mapping {
	63	u32 hns3_link_mode;
	64	u32 ethtool_link_mode;
65	};
66
67	static const struct hns3_link_mode_mapping hns3_lm_map[] = {
68	{HNS3_LM_FIBRE_BIT, ETHTOOL_LINK_MODE_FIBRE_BIT},
69	{HNS3_LM_AUTONEG_BIT, ETHTOOL_LINK_MODE_Autoneg_BIT},
70	{HNS3_LM_TP_BIT, ETHTOOL_LINK_MODE_TP_BIT},
71	{HNS3_LM_PAUSE_BIT, ETHTOOL_LINK_MODE_Pause_BIT},
72	{HNS3_LM_BACKPLANE_BIT, ETHTOOL_LINK_MODE_Backplane_BIT},
73	{HNS3_LM_10BASET_HALF_BIT, ETHTOOL_LINK_MODE_10baseT_Half_BIT},
74	{HNS3_LM_10BASET_FULL_BIT, ETHTOOL_LINK_MODE_10baseT_Full_BIT},
75	{HNS3_LM_100BASET_HALF_BIT, ETHTOOL_LINK_MODE_100baseT_Half_BIT},
76	{HNS3_LM_100BASET_FULL_BIT, ETHTOOL_LINK_MODE_100baseT_Full_BIT},
77	{HNS3_LM_1000BASET_FULL_BIT, ETHTOOL_LINK_MODE_1000baseT_Full_BIT},
78	};
79
80	static void hns3_driv_to_eth_caps(u32 caps, struct ethtool_link_ksettings *cmd,
81	bool is_advertised)
82	{
83	int i;
84
85	for (i = 0; i < ARRAY_SIZE(hns3_lm_map); i++) {
86	if (!(caps & hns3_lm_map[i].hns3_link_mode))
87	continue;
88
89	if (is_advertised) {
90	ethtool_link_ksettings_zero_link_mode(cmd,
91	advertising);
92	__set_bit(hns3_lm_map[i].ethtool_link_mode,
93	cmd->link_modes.advertising);
94	} else {
95	ethtool_link_ksettings_zero_link_mode(cmd,
96	supported);
97	__set_bit(hns3_lm_map[i].ethtool_link_mode,
98	cmd->link_modes.supported);
99	}
100	}
101	}
102
103	static int hns3_get_sset_count(struct net_device *netdev, int stringset)
104	{
9780cb97	105	struct hnae3_handle *h = hns3_get_handle(netdev);
496d03e9 S	106	const struct hnae3_ae_ops *ops = h->ae_algo->ops;
	107
	108	if (!ops->get_sset_count)
	109	return -EOPNOTSUPP;
	110
	111	switch (stringset) {
	112	case ETH_SS_STATS:
	113	return ((HNS3_TQP_STATS_COUNT * h->kinfo.num_tqps) +
	114	ops->get_sset_count(h, stringset));
	115
	116	case ETH_SS_TEST:
	117	return ops->get_sset_count(h, stringset);
	118	}
	119
	120	return 0;
	121	}
	122
	123	static void hns3_update_strings(u8 data, const struct hns3_stats *stats,
	124	u32 stat_count, u32 num_tqps)
	125	{
	126	#define MAX_PREFIX_SIZE (8 + 4)
	127	u32 size_left;
	128	u32 i, j;
	129	u32 n1;
	130
	131	for (i = 0; i < num_tqps; i++) {
	132	for (j = 0; j < stat_count; j++) {
	133	data[ETH_GSTRING_LEN - 1] = '\0';
	134
	135	/* first, prepend the prefix string */
	136	n1 = snprintf(data, MAX_PREFIX_SIZE, "rcb_q%d_", i);
	137	n1 = min_t(uint, n1, MAX_PREFIX_SIZE - 1);
	138	size_left = (ETH_GSTRING_LEN - 1) - n1;
	139
	140	/* now, concatenate the stats string to it */
	141	strncat(data, stats[j].stats_string, size_left);
	142	data += ETH_GSTRING_LEN;
	143	}
	144	}
	145
	146	return data;
	147	}
	148
	149	static u8 hns3_get_strings_tqps(struct hnae3_handle handle, u8 *data)
	150	{
	151	struct hnae3_knic_private_info *kinfo = &handle->kinfo;
	152
	153	/* get strings for Tx */
	154	data = hns3_update_strings(data, hns3_txq_stats, HNS3_TXQ_STATS_COUNT,
	155	kinfo->num_tqps);
	156
	157	/* get strings for Rx */
	158	data = hns3_update_strings(data, hns3_rxq_stats, HNS3_RXQ_STATS_COUNT,
	159	kinfo->num_tqps);
	160
	161	return data;
	162	}
	163
	164	static void hns3_get_strings(struct net_device netdev, u32 stringset, u8 data)
	165	{
9780cb97	166	struct hnae3_handle *h = hns3_get_handle(netdev);
496d03e9 S	167	const struct hnae3_ae_ops *ops = h->ae_algo->ops;
	168	char buff = (char )data;
	169
	170	if (!ops->get_strings)
	171	return;
	172
	173	switch (stringset) {
	174	case ETH_SS_STATS:
	175	buff = hns3_get_strings_tqps(h, buff);
	176	h->ae_algo->ops->get_strings(h, stringset, (u8 *)buff);
	177	break;
	178	case ETH_SS_TEST:
	179	ops->get_strings(h, stringset, data);
	180	break;
	181	}
	182	}
	183
	184	static u64 hns3_get_stats_tqps(struct hnae3_handle handle, u64 *data)
	185	{
	186	struct hns3_nic_priv nic_priv = (struct hns3_nic_priv )handle->priv;
	187	struct hnae3_knic_private_info *kinfo = &handle->kinfo;
	188	struct hns3_enet_ring *ring;
	189	u8 *stat;
	190	u32 i;
	191
	192	/* get stats for Tx */
	193	for (i = 0; i < kinfo->num_tqps; i++) {
	194	ring = nic_priv->ring_data[i].ring;
	195	for (i = 0; i < HNS3_TXQ_STATS_COUNT; i++) {
	196	stat = (u8 *)ring + hns3_txq_stats[i].stats_offset;
	197	data++ = (u64 *)stat;
	198	}
	199	}
	200
	201	/* get stats for Rx */
	202	for (i = 0; i < kinfo->num_tqps; i++) {
	203	ring = nic_priv->ring_data[i + kinfo->num_tqps].ring;
	204	for (i = 0; i < HNS3_RXQ_STATS_COUNT; i++) {
	205	stat = (u8 *)ring + hns3_rxq_stats[i].stats_offset;
	206	data++ = (u64 *)stat;
	207	}
	208	}
	209
	210	return data;
	211	}
	212
	213	/* hns3_get_stats - get detail statistics.
	214	* @netdev: net device
	215	* @stats: statistics info.
	216	* @data: statistics data.
	217	*/
1db9b1bf YL	218	static void hns3_get_stats(struct net_device *netdev,
1db9b1bf YL	219	struct ethtool_stats stats, u64 data)
496d03e9	220	{
9780cb97	221	struct hnae3_handle *h = hns3_get_handle(netdev);
496d03e9 S	222	u64 *p = data;
	223
	224	if (!h->ae_algo->ops->get_stats \|\| !h->ae_algo->ops->update_stats) {
	225	netdev_err(netdev, "could not get any statistics\n");
	226	return;
	227	}
	228
	229	h->ae_algo->ops->update_stats(h, &netdev->stats);
	230
	231	/* get per-queue stats */
	232	p = hns3_get_stats_tqps(h, p);
	233
	234	/* get MAC & other misc hardware stats */
	235	h->ae_algo->ops->get_stats(h, p);
	236	}
	237
	238	static void hns3_get_drvinfo(struct net_device *netdev,
	239	struct ethtool_drvinfo *drvinfo)
	240	{
	241	struct hns3_nic_priv *priv = netdev_priv(netdev);
	242	struct hnae3_handle *h = priv->ae_handle;
	243
	244	strncpy(drvinfo->version, hns3_driver_version,
	245	sizeof(drvinfo->version));
	246	drvinfo->version[sizeof(drvinfo->version) - 1] = '\0';
	247
	248	strncpy(drvinfo->driver, h->pdev->driver->name,
	249	sizeof(drvinfo->driver));
	250	drvinfo->driver[sizeof(drvinfo->driver) - 1] = '\0';
	251
	252	strncpy(drvinfo->bus_info, pci_name(h->pdev),
	253	sizeof(drvinfo->bus_info));
	254	drvinfo->bus_info[ETHTOOL_BUSINFO_LEN - 1] = '\0';
	255
	256	snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version), "0x%08x",
	257	priv->ae_handle->ae_algo->ops->get_fw_version(h));
	258	}
	259
	260	static u32 hns3_get_link(struct net_device *netdev)
	261	{
9780cb97	262	struct hnae3_handle *h = hns3_get_handle(netdev);
496d03e9 S	263
	264	if (h->ae_algo && h->ae_algo->ops && h->ae_algo->ops->get_status)
	265	return h->ae_algo->ops->get_status(h);
	266	else
	267	return 0;
	268	}
	269
	270	static void hns3_get_ringparam(struct net_device *netdev,
	271	struct ethtool_ringparam *param)
	272	{
	273	struct hns3_nic_priv *priv = netdev_priv(netdev);
9780cb97 YL	274	struct hnae3_handle *h = priv->ae_handle;
9780cb97 YL	275	int queue_num = h->kinfo.num_tqps;
496d03e9 S	276
	277	param->tx_max_pending = HNS3_RING_MAX_PENDING;
	278	param->rx_max_pending = HNS3_RING_MAX_PENDING;
	279
	280	param->tx_pending = priv->ring_data[0].ring->desc_num;
	281	param->rx_pending = priv->ring_data[queue_num].ring->desc_num;
	282	}
	283
	284	static void hns3_get_pauseparam(struct net_device *netdev,
	285	struct ethtool_pauseparam *param)
	286	{
9780cb97	287	struct hnae3_handle *h = hns3_get_handle(netdev);
496d03e9 S	288
	289	if (h->ae_algo && h->ae_algo->ops && h->ae_algo->ops->get_pauseparam)
	290	h->ae_algo->ops->get_pauseparam(h, &param->autoneg,
	291	&param->rx_pause, &param->tx_pause);
	292	}
	293
	294	static int hns3_get_link_ksettings(struct net_device *netdev,
	295	struct ethtool_link_ksettings *cmd)
	296	{
9780cb97	297	struct hnae3_handle *h = hns3_get_handle(netdev);
496d03e9 S	298	u32 supported_caps;
496d03e9 S	299	u32 advertised_caps;
fd07a62d	300	u8 media_type = HNAE3_MEDIA_TYPE_UNKNOWN;
496d03e9 S	301	u8 link_stat;
	302	u8 auto_neg;
	303	u8 duplex;
	304	u32 speed;
	305
	306	if (!h->ae_algo \|\| !h->ae_algo->ops)
	307	return -EOPNOTSUPP;
	308
9db85f33	309	/* 1.auto_neg & speed & duplex from cmd */
496d03e9 S	310	if (h->ae_algo->ops->get_ksettings_an_result) {
	311	h->ae_algo->ops->get_ksettings_an_result(h, &auto_neg,
	312	&speed, &duplex);
	313	cmd->base.autoneg = auto_neg;
	314	cmd->base.speed = speed;
	315	cmd->base.duplex = duplex;
	316
	317	link_stat = hns3_get_link(netdev);
	318	if (!link_stat) {
	319	cmd->base.speed = (u32)SPEED_UNKNOWN;
	320	cmd->base.duplex = DUPLEX_UNKNOWN;
	321	}
	322	}
	323
	324	/* 2.media_type get from bios parameter block */
9db85f33	325	if (h->ae_algo->ops->get_media_type) {
496d03e9 S	326	h->ae_algo->ops->get_media_type(h, &media_type);
496d03e9 S	327
9db85f33 S	328	switch (media_type) {
	329	case HNAE3_MEDIA_TYPE_FIBER:
	330	cmd->base.port = PORT_FIBRE;
	331	supported_caps = HNS3_LM_FIBRE_BIT \|
	332	HNS3_LM_AUTONEG_BIT \|
	333	HNS3_LM_PAUSE_BIT \|
	334	HNS3_LM_1000BASET_FULL_BIT;
	335
	336	advertised_caps = supported_caps;
	337	break;
	338	case HNAE3_MEDIA_TYPE_COPPER:
	339	cmd->base.port = PORT_TP;
	340	supported_caps = HNS3_LM_TP_BIT \|
	341	HNS3_LM_AUTONEG_BIT \|
	342	HNS3_LM_PAUSE_BIT \|
	343	HNS3_LM_1000BASET_FULL_BIT \|
	344	HNS3_LM_100BASET_FULL_BIT \|
	345	HNS3_LM_100BASET_HALF_BIT \|
	346	HNS3_LM_10BASET_FULL_BIT \|
	347	HNS3_LM_10BASET_HALF_BIT;
	348	advertised_caps = supported_caps;
	349	break;
	350	case HNAE3_MEDIA_TYPE_BACKPLANE:
	351	cmd->base.port = PORT_NONE;
	352	supported_caps = HNS3_LM_BACKPLANE_BIT \|
	353	HNS3_LM_PAUSE_BIT \|
	354	HNS3_LM_AUTONEG_BIT \|
	355	HNS3_LM_1000BASET_FULL_BIT \|
	356	HNS3_LM_100BASET_FULL_BIT \|
	357	HNS3_LM_100BASET_HALF_BIT \|
	358	HNS3_LM_10BASET_FULL_BIT \|
	359	HNS3_LM_10BASET_HALF_BIT;
	360
	361	advertised_caps = supported_caps;
	362	break;
	363	case HNAE3_MEDIA_TYPE_UNKNOWN:
	364	default:
	365	cmd->base.port = PORT_OTHER;
	366	supported_caps = 0;
	367	advertised_caps = 0;
	368	break;
	369	}
496d03e9	370
9db85f33 S	371	/* now, map driver link modes to ethtool link modes */
	372	hns3_driv_to_eth_caps(supported_caps, cmd, false);
	373	hns3_driv_to_eth_caps(advertised_caps, cmd, true);
496d03e9 S	374	}
496d03e9 S	375
496d03e9 S	376	/* 3.mdix_ctrl&mdix get from phy reg */
	377	if (h->ae_algo->ops->get_mdix_mode)
	378	h->ae_algo->ops->get_mdix_mode(h, &cmd->base.eth_tp_mdix_ctrl,
9db85f33	379	&cmd->base.eth_tp_mdix);
496d03e9 S	380	/* 4.mdio_support */
	381	cmd->base.mdio_support = ETH_MDIO_SUPPORTS_C22;
	382
	383	return 0;
	384	}
	385
	386	static u32 hns3_get_rss_key_size(struct net_device *netdev)
	387	{
9780cb97	388	struct hnae3_handle *h = hns3_get_handle(netdev);
496d03e9 S	389
	390	if (!h->ae_algo \|\| !h->ae_algo->ops \|\|
	391	!h->ae_algo->ops->get_rss_key_size)
	392	return -EOPNOTSUPP;
	393
	394	return h->ae_algo->ops->get_rss_key_size(h);
	395	}
	396
	397	static u32 hns3_get_rss_indir_size(struct net_device *netdev)
	398	{
9780cb97	399	struct hnae3_handle *h = hns3_get_handle(netdev);
496d03e9 S	400
	401	if (!h->ae_algo \|\| !h->ae_algo->ops \|\|
	402	!h->ae_algo->ops->get_rss_indir_size)
	403	return -EOPNOTSUPP;
	404
	405	return h->ae_algo->ops->get_rss_indir_size(h);
	406	}
	407
	408	static int hns3_get_rss(struct net_device netdev, u32 indir, u8 *key,
	409	u8 *hfunc)
	410	{
9780cb97	411	struct hnae3_handle *h = hns3_get_handle(netdev);
496d03e9 S	412
	413	if (!h->ae_algo \|\| !h->ae_algo->ops \|\| !h->ae_algo->ops->get_rss)
	414	return -EOPNOTSUPP;
	415
	416	return h->ae_algo->ops->get_rss(h, indir, key, hfunc);
	417	}
	418
	419	static int hns3_set_rss(struct net_device netdev, const u32 indir,
	420	const u8 *key, const u8 hfunc)
	421	{
9780cb97	422	struct hnae3_handle *h = hns3_get_handle(netdev);
496d03e9 S	423
	424	if (!h->ae_algo \|\| !h->ae_algo->ops \|\| !h->ae_algo->ops->set_rss)
	425	return -EOPNOTSUPP;
	426
	427	/* currently we only support Toeplitz hash */
	428	if ((hfunc != ETH_RSS_HASH_NO_CHANGE) && (hfunc != ETH_RSS_HASH_TOP)) {
	429	netdev_err(netdev,
	430	"hash func not supported (only Toeplitz hash)\n");
	431	return -EOPNOTSUPP;
	432	}
	433	if (!indir) {
	434	netdev_err(netdev,
	435	"set rss failed for indir is empty\n");
	436	return -EOPNOTSUPP;
	437	}
	438
	439	return h->ae_algo->ops->set_rss(h, indir, key, hfunc);
	440	}
	441
	442	static int hns3_get_rxnfc(struct net_device *netdev,
	443	struct ethtool_rxnfc *cmd,
	444	u32 *rule_locs)
	445	{
9780cb97	446	struct hnae3_handle *h = hns3_get_handle(netdev);
496d03e9 S	447
	448	if (!h->ae_algo \|\| !h->ae_algo->ops \|\| !h->ae_algo->ops->get_tc_size)
	449	return -EOPNOTSUPP;
	450
	451	switch (cmd->cmd) {
	452	case ETHTOOL_GRXRINGS:
	453	cmd->data = h->ae_algo->ops->get_tc_size(h);
	454	break;
	455	default:
	456	return -EOPNOTSUPP;
	457	}
	458
	459	return 0;
	460	}
	461
5668abda L	462	int hns3_change_all_ring_bd_num(struct hns3_nic_priv *priv, u32 new_desc_num)
	463	{
	464	struct hnae3_handle *h = priv->ae_handle;
	465	int i;
	466
	467	h->kinfo.num_desc = new_desc_num;
	468
	469	for (i = 0; i < h->kinfo.num_tqps * 2; i++)
	470	priv->ring_data[i].ring->desc_num = new_desc_num;
	471
	472	return hns3_init_all_ring(priv);
	473	}
	474
	475	int hns3_set_ringparam(struct net_device ndev, struct ethtool_ringparam param)
	476	{
	477	struct hns3_nic_priv *priv = netdev_priv(ndev);
	478	struct hnae3_handle *h = priv->ae_handle;
	479	bool if_running = netif_running(ndev);
	480	u32 old_desc_num, new_desc_num;
	481	int ret;
	482
	483	if (param->rx_mini_pending \|\| param->rx_jumbo_pending)
	484	return -EINVAL;
	485
	486	if (param->tx_pending != param->rx_pending) {
	487	netdev_err(ndev,
	488	"Descriptors of tx and rx must be equal");
	489	return -EINVAL;
	490	}
	491
	492	if (param->tx_pending > HNS3_RING_MAX_PENDING \|\|
	493	param->tx_pending < HNS3_RING_MIN_PENDING) {
	494	netdev_err(ndev,
	495	"Descriptors requested (Tx/Rx: %d) out of range [%d-%d]\n",
	496	param->tx_pending, HNS3_RING_MIN_PENDING,
	497	HNS3_RING_MAX_PENDING);
	498	return -EINVAL;
	499	}
	500
	501	new_desc_num = param->tx_pending;
	502
	503	/* Hardware requires that its descriptors must be multiple of eight */
	504	new_desc_num = ALIGN(new_desc_num, HNS3_RING_BD_MULTIPLE);
	505	old_desc_num = h->kinfo.num_desc;
	506	if (old_desc_num == new_desc_num)
	507	return 0;
	508
	509	netdev_info(ndev,
	510	"Changing descriptor count from %d to %d.\n",
	511	old_desc_num, new_desc_num);
	512
	513	if (if_running)
	514	dev_close(ndev);
	515
	516	ret = hns3_uninit_all_ring(priv);
	517	if (ret)
	518	return ret;
	519
	520	ret = hns3_change_all_ring_bd_num(priv, new_desc_num);
	521	if (ret) {
	522	ret = hns3_change_all_ring_bd_num(priv, old_desc_num);
	523	if (ret) {
	524	netdev_err(ndev,
	525	"Revert to old bd num fail, ret=%d.\n", ret);
526	return ret;
527	}
528	}
529
530	if (if_running)
531	ret = dev_open(ndev);
532
533	return ret;
534	}
535
f7db940a L	536	static int hns3_set_rxnfc(struct net_device netdev, struct ethtool_rxnfc cmd)
	537	{
	538	struct hnae3_handle *h = hns3_get_handle(netdev);
	539
	540	if (!h->ae_algo \|\| !h->ae_algo->ops \|\| !h->ae_algo->ops->set_rss_tuple)
	541	return -EOPNOTSUPP;
	542
	543	switch (cmd->cmd) {
	544	case ETHTOOL_SRXFH:
	545	return h->ae_algo->ops->set_rss_tuple(h, cmd);
	546	default:
	547	return -EOPNOTSUPP;
	548	}
	549	}
	550
496d03e9 S	551	static const struct ethtool_ops hns3_ethtool_ops = {
	552	.get_drvinfo = hns3_get_drvinfo,
	553	.get_link = hns3_get_link,
	554	.get_ringparam = hns3_get_ringparam,
5668abda	555	.set_ringparam = hns3_set_ringparam,
496d03e9 S	556	.get_pauseparam = hns3_get_pauseparam,
	557	.get_strings = hns3_get_strings,
	558	.get_ethtool_stats = hns3_get_stats,
	559	.get_sset_count = hns3_get_sset_count,
	560	.get_rxnfc = hns3_get_rxnfc,
f7db940a	561	.set_rxnfc = hns3_set_rxnfc,
496d03e9 S	562	.get_rxfh_key_size = hns3_get_rss_key_size,
	563	.get_rxfh_indir_size = hns3_get_rss_indir_size,
	564	.get_rxfh = hns3_get_rss,
	565	.set_rxfh = hns3_set_rss,
	566	.get_link_ksettings = hns3_get_link_ksettings,
	567	};
	568
	569	void hns3_ethtool_set_ops(struct net_device *netdev)
	570	{
	571	netdev->ethtool_ops = &hns3_ethtool_ops;
	572	}