hns3_ethtool.c

   1// SPDX-License-Identifier: GPL-2.0+
   2// Copyright (c) 2016-2017 Hisilicon Limited.
   3
   4#include <linux/etherdevice.h>
   5#include <linux/string.h>
   6#include <linux/string_choices.h>
   7#include <linux/phy.h>
   8#include <linux/sfp.h>
   9
  10#include "hns3_enet.h"
  11#include "hns3_ethtool.h"
  12
  13/* tqp related stats */
  14#define HNS3_TQP_STAT(_string, _member)	{			\
  15	.stats_string = _string,				\
  16	.stats_offset = offsetof(struct hns3_enet_ring, stats) +\
  17			offsetof(struct ring_stats, _member),   \
  18}
  19
  20static const struct hns3_stats hns3_txq_stats[] = {
  21	/* Tx per-queue statistics */
  22	HNS3_TQP_STAT("dropped", sw_err_cnt),
  23	HNS3_TQP_STAT("seg_pkt_cnt", seg_pkt_cnt),
  24	HNS3_TQP_STAT("packets", tx_pkts),
  25	HNS3_TQP_STAT("bytes", tx_bytes),
  26	HNS3_TQP_STAT("more", tx_more),
  27	HNS3_TQP_STAT("push", tx_push),
  28	HNS3_TQP_STAT("mem_doorbell", tx_mem_doorbell),
  29	HNS3_TQP_STAT("wake", restart_queue),
  30	HNS3_TQP_STAT("busy", tx_busy),
  31	HNS3_TQP_STAT("copy", tx_copy),
  32	HNS3_TQP_STAT("vlan_err", tx_vlan_err),
  33	HNS3_TQP_STAT("l4_proto_err", tx_l4_proto_err),
  34	HNS3_TQP_STAT("l2l3l4_err", tx_l2l3l4_err),
  35	HNS3_TQP_STAT("tso_err", tx_tso_err),
  36	HNS3_TQP_STAT("over_max_recursion", over_max_recursion),
  37	HNS3_TQP_STAT("hw_limitation", hw_limitation),
  38	HNS3_TQP_STAT("bounce", tx_bounce),
  39	HNS3_TQP_STAT("spare_full", tx_spare_full),
  40	HNS3_TQP_STAT("copy_bits_err", copy_bits_err),
  41	HNS3_TQP_STAT("sgl", tx_sgl),
  42	HNS3_TQP_STAT("skb2sgl_err", skb2sgl_err),
  43	HNS3_TQP_STAT("map_sg_err", map_sg_err),
  44};
  45
  46#define HNS3_TXQ_STATS_COUNT ARRAY_SIZE(hns3_txq_stats)
  47
  48static const struct hns3_stats hns3_rxq_stats[] = {
  49	/* Rx per-queue statistics */
  50	HNS3_TQP_STAT("dropped", sw_err_cnt),
  51	HNS3_TQP_STAT("seg_pkt_cnt", seg_pkt_cnt),
  52	HNS3_TQP_STAT("packets", rx_pkts),
  53	HNS3_TQP_STAT("bytes", rx_bytes),
  54	HNS3_TQP_STAT("errors", rx_err_cnt),
  55	HNS3_TQP_STAT("reuse_pg_cnt", reuse_pg_cnt),
  56	HNS3_TQP_STAT("err_pkt_len", err_pkt_len),
  57	HNS3_TQP_STAT("err_bd_num", err_bd_num),
  58	HNS3_TQP_STAT("l2_err", l2_err),
  59	HNS3_TQP_STAT("l3l4_csum_err", l3l4_csum_err),
  60	HNS3_TQP_STAT("csum_complete", csum_complete),
  61	HNS3_TQP_STAT("multicast", rx_multicast),
  62	HNS3_TQP_STAT("non_reuse_pg", non_reuse_pg),
  63	HNS3_TQP_STAT("frag_alloc_err", frag_alloc_err),
  64	HNS3_TQP_STAT("frag_alloc", frag_alloc),
  65};
  66
  67#define HNS3_PRIV_FLAGS_LEN ARRAY_SIZE(hns3_priv_flags)
  68
  69#define HNS3_RXQ_STATS_COUNT ARRAY_SIZE(hns3_rxq_stats)
  70
  71#define HNS3_TQP_STATS_COUNT (HNS3_TXQ_STATS_COUNT + HNS3_RXQ_STATS_COUNT)
  72
  73#define HNS3_NIC_LB_TEST_PKT_NUM	1
  74#define HNS3_NIC_LB_TEST_RING_ID	0
  75#define HNS3_NIC_LB_TEST_PACKET_SIZE	128
  76#define HNS3_NIC_LB_SETUP_USEC		10000
  77
  78/* Nic loopback test err  */
  79#define HNS3_NIC_LB_TEST_NO_MEM_ERR	1
  80#define HNS3_NIC_LB_TEST_TX_CNT_ERR	2
  81#define HNS3_NIC_LB_TEST_RX_CNT_ERR	3
  82#define HNS3_NIC_LB_TEST_UNEXECUTED	4
  83
  84static int hns3_get_sset_count(struct net_device *netdev, int stringset);
  85
  86static int hns3_lp_setup(struct net_device *ndev, enum hnae3_loop loop, bool en)
  87{
  88	struct hnae3_handle *h = hns3_get_handle(ndev);
  89	struct hnae3_ae_dev *ae_dev = hns3_get_ae_dev(h);
  90	int ret;
  91
  92	if (!h->ae_algo->ops->set_loopback ||
  93	    !h->ae_algo->ops->set_promisc_mode)
  94		return -EOPNOTSUPP;
  95
  96	switch (loop) {
  97	case HNAE3_LOOP_SERIAL_SERDES:
  98	case HNAE3_LOOP_PARALLEL_SERDES:
  99	case HNAE3_LOOP_APP:
 100	case HNAE3_LOOP_PHY:
 101	case HNAE3_LOOP_EXTERNAL:
 102		ret = h->ae_algo->ops->set_loopback(h, loop, en);
 103		break;
 104	default:
 105		ret = -ENOTSUPP;
 106		break;
 107	}
 108
 109	if (ret || ae_dev->dev_version >= HNAE3_DEVICE_VERSION_V2)
 110		return ret;
 111
 112	if (en)
 113		h->ae_algo->ops->set_promisc_mode(h, true, true);
 114	else
 115		/* recover promisc mode before loopback test */
 116		hns3_request_update_promisc_mode(h);
 117
 118	return ret;
 119}
 120
 121static int hns3_lp_up(struct net_device *ndev, enum hnae3_loop loop_mode)
 122{
 123	struct hnae3_handle *h = hns3_get_handle(ndev);
 124	int ret;
 125
 126	ret = hns3_nic_reset_all_ring(h);
 127	if (ret)
 128		return ret;
 129
 130	ret = hns3_lp_setup(ndev, loop_mode, true);
 131	usleep_range(HNS3_NIC_LB_SETUP_USEC, HNS3_NIC_LB_SETUP_USEC * 2);
 132
 133	return ret;
 134}
 135
 136static int hns3_lp_down(struct net_device *ndev, enum hnae3_loop loop_mode)
 137{
 138	int ret;
 139
 140	ret = hns3_lp_setup(ndev, loop_mode, false);
 141	if (ret) {
 142		netdev_err(ndev, "lb_setup return error: %d\n", ret);
 143		return ret;
 144	}
 145
 146	usleep_range(HNS3_NIC_LB_SETUP_USEC, HNS3_NIC_LB_SETUP_USEC * 2);
 147
 148	return 0;
 149}
 150
 151static void hns3_lp_setup_skb(struct sk_buff *skb)
 152{
 153#define	HNS3_NIC_LB_DST_MAC_ADDR	0x1f
 154
 155	struct net_device *ndev = skb->dev;
 156	struct hnae3_handle *handle;
 157	struct hnae3_ae_dev *ae_dev;
 158	unsigned char *packet;
 159	struct ethhdr *ethh;
 160	unsigned int i;
 161
 162	skb_reserve(skb, NET_IP_ALIGN);
 163	ethh = skb_put(skb, sizeof(struct ethhdr));
 164	packet = skb_put(skb, HNS3_NIC_LB_TEST_PACKET_SIZE);
 165
 166	memcpy(ethh->h_dest, ndev->dev_addr, ETH_ALEN);
 167
 168	/* The dst mac addr of loopback packet is the same as the host'
 169	 * mac addr, the SSU component may loop back the packet to host
 170	 * before the packet reaches mac or serdes, which will defect
 171	 * the purpose of mac or serdes selftest.
 172	 */
 173	handle = hns3_get_handle(ndev);
 174	ae_dev = hns3_get_ae_dev(handle);
 175	if (ae_dev->dev_version < HNAE3_DEVICE_VERSION_V2)
 176		ethh->h_dest[5] += HNS3_NIC_LB_DST_MAC_ADDR;
 177	eth_zero_addr(ethh->h_source);
 178	ethh->h_proto = htons(ETH_P_ARP);
 179	skb_reset_mac_header(skb);
 180
 181	for (i = 0; i < HNS3_NIC_LB_TEST_PACKET_SIZE; i++)
 182		packet[i] = (unsigned char)(i & 0xff);
 183}
 184
 185static void hns3_lb_check_skb_data(struct hns3_enet_ring *ring,
 186				   struct sk_buff *skb)
 187{
 188	struct hns3_enet_tqp_vector *tqp_vector = ring->tqp_vector;
 189	unsigned char *packet = skb->data;
 190	u32 len = skb_headlen(skb);
 191	u32 i;
 192
 193	len = min_t(u32, len, HNS3_NIC_LB_TEST_PACKET_SIZE);
 194
 195	for (i = 0; i < len; i++)
 196		if (packet[i] != (unsigned char)(i & 0xff))
 197			break;
 198
 199	/* The packet is correctly received */
 200	if (i == HNS3_NIC_LB_TEST_PACKET_SIZE)
 201		tqp_vector->rx_group.total_packets++;
 202	else
 203		print_hex_dump(KERN_ERR, "selftest:", DUMP_PREFIX_OFFSET, 16, 1,
 204			       skb->data, len, true);
 205
 206	dev_kfree_skb_any(skb);
 207}
 208
 209static u32 hns3_lb_check_rx_ring(struct hns3_nic_priv *priv, u32 budget)
 210{
 211	struct hnae3_handle *h = priv->ae_handle;
 212	struct hnae3_knic_private_info *kinfo;
 213	u32 i, rcv_good_pkt_total = 0;
 214
 215	kinfo = &h->kinfo;
 216	for (i = kinfo->num_tqps; i < kinfo->num_tqps * 2; i++) {
 217		struct hns3_enet_ring *ring = &priv->ring[i];
 218		struct hns3_enet_ring_group *rx_group;
 219		u64 pre_rx_pkt;
 220
 221		rx_group = &ring->tqp_vector->rx_group;
 222		pre_rx_pkt = rx_group->total_packets;
 223
 224		preempt_disable();
 225		hns3_clean_rx_ring(ring, budget, hns3_lb_check_skb_data);
 226		preempt_enable();
 227
 228		rcv_good_pkt_total += (rx_group->total_packets - pre_rx_pkt);
 229		rx_group->total_packets = pre_rx_pkt;
 230	}
 231	return rcv_good_pkt_total;
 232}
 233
 234static void hns3_lb_clear_tx_ring(struct hns3_nic_priv *priv, u32 start_ringid,
 235				  u32 end_ringid)
 236{
 237	u32 i;
 238
 239	for (i = start_ringid; i <= end_ringid; i++) {
 240		struct hns3_enet_ring *ring = &priv->ring[i];
 241
 242		hns3_clean_tx_ring(ring, 0);
 243	}
 244}
 245
 246/**
 247 * hns3_lp_run_test - run loopback test
 248 * @ndev: net device
 249 * @mode: loopback type
 250 *
 251 * Return: %0 for success or a NIC loopback test error code on failure
 252 */
 253static int hns3_lp_run_test(struct net_device *ndev, enum hnae3_loop mode)
 254{
 255	struct hns3_nic_priv *priv = netdev_priv(ndev);
 256	struct sk_buff *skb;
 257	u32 i, good_cnt;
 258	int ret_val = 0;
 259
 260	skb = alloc_skb(HNS3_NIC_LB_TEST_PACKET_SIZE + ETH_HLEN + NET_IP_ALIGN,
 261			GFP_KERNEL);
 262	if (!skb)
 263		return HNS3_NIC_LB_TEST_NO_MEM_ERR;
 264
 265	skb->dev = ndev;
 266	hns3_lp_setup_skb(skb);
 267	skb->queue_mapping = HNS3_NIC_LB_TEST_RING_ID;
 268
 269	good_cnt = 0;
 270	for (i = 0; i < HNS3_NIC_LB_TEST_PKT_NUM; i++) {
 271		netdev_tx_t tx_ret;
 272
 273		skb_get(skb);
 274		tx_ret = hns3_nic_net_xmit(skb, ndev);
 275		if (tx_ret == NETDEV_TX_OK) {
 276			good_cnt++;
 277		} else {
 278			kfree_skb(skb);
 279			netdev_err(ndev, "hns3_lb_run_test xmit failed: %d\n",
 280				   tx_ret);
 281		}
 282	}
 283	if (good_cnt != HNS3_NIC_LB_TEST_PKT_NUM) {
 284		ret_val = HNS3_NIC_LB_TEST_TX_CNT_ERR;
 285		netdev_err(ndev, "mode %d sent fail, cnt=0x%x, budget=0x%x\n",
 286			   mode, good_cnt, HNS3_NIC_LB_TEST_PKT_NUM);
 287		goto out;
 288	}
 289
 290	/* Allow 200 milliseconds for packets to go from Tx to Rx */
 291	msleep(200);
 292
 293	good_cnt = hns3_lb_check_rx_ring(priv, HNS3_NIC_LB_TEST_PKT_NUM);
 294	if (good_cnt != HNS3_NIC_LB_TEST_PKT_NUM) {
 295		ret_val = HNS3_NIC_LB_TEST_RX_CNT_ERR;
 296		netdev_err(ndev, "mode %d recv fail, cnt=0x%x, budget=0x%x\n",
 297			   mode, good_cnt, HNS3_NIC_LB_TEST_PKT_NUM);
 298	}
 299
 300out:
 301	hns3_lb_clear_tx_ring(priv, HNS3_NIC_LB_TEST_RING_ID,
 302			      HNS3_NIC_LB_TEST_RING_ID);
 303
 304	kfree_skb(skb);
 305	return ret_val;
 306}
 307
 308static void hns3_set_selftest_param(struct hnae3_handle *h, int (*st_param)[2])
 309{
 310	st_param[HNAE3_LOOP_EXTERNAL][0] = HNAE3_LOOP_EXTERNAL;
 311	st_param[HNAE3_LOOP_EXTERNAL][1] =
 312			h->flags & HNAE3_SUPPORT_EXTERNAL_LOOPBACK;
 313
 314	st_param[HNAE3_LOOP_APP][0] = HNAE3_LOOP_APP;
 315	st_param[HNAE3_LOOP_APP][1] =
 316			h->flags & HNAE3_SUPPORT_APP_LOOPBACK;
 317
 318	st_param[HNAE3_LOOP_SERIAL_SERDES][0] = HNAE3_LOOP_SERIAL_SERDES;
 319	st_param[HNAE3_LOOP_SERIAL_SERDES][1] =
 320			h->flags & HNAE3_SUPPORT_SERDES_SERIAL_LOOPBACK;
 321
 322	st_param[HNAE3_LOOP_PARALLEL_SERDES][0] =
 323			HNAE3_LOOP_PARALLEL_SERDES;
 324	st_param[HNAE3_LOOP_PARALLEL_SERDES][1] =
 325			h->flags & HNAE3_SUPPORT_SERDES_PARALLEL_LOOPBACK;
 326
 327	st_param[HNAE3_LOOP_PHY][0] = HNAE3_LOOP_PHY;
 328	st_param[HNAE3_LOOP_PHY][1] =
 329			h->flags & HNAE3_SUPPORT_PHY_LOOPBACK;
 330}
 331
 332static void hns3_selftest_prepare(struct net_device *ndev, bool if_running)
 333{
 334	struct hns3_nic_priv *priv = netdev_priv(ndev);
 335	struct hnae3_handle *h = priv->ae_handle;
 336
 337	if (if_running)
 338		ndev->netdev_ops->ndo_stop(ndev);
 339
 340#if IS_ENABLED(CONFIG_VLAN_8021Q)
 341	/* Disable the vlan filter for selftest does not support it */
 342	if (h->ae_algo->ops->enable_vlan_filter &&
 343	    ndev->features & NETIF_F_HW_VLAN_CTAG_FILTER)
 344		h->ae_algo->ops->enable_vlan_filter(h, false);
 345#endif
 346
 347	/* Tell firmware to stop mac autoneg before loopback test start,
 348	 * otherwise loopback test may be failed when the port is still
 349	 * negotiating.
 350	 */
 351	if (h->ae_algo->ops->halt_autoneg)
 352		h->ae_algo->ops->halt_autoneg(h, true);
 353
 354	set_bit(HNS3_NIC_STATE_TESTING, &priv->state);
 355}
 356
 357static void hns3_selftest_restore(struct net_device *ndev, bool if_running)
 358{
 359	struct hns3_nic_priv *priv = netdev_priv(ndev);
 360	struct hnae3_handle *h = priv->ae_handle;
 361
 362	clear_bit(HNS3_NIC_STATE_TESTING, &priv->state);
 363
 364	if (h->ae_algo->ops->halt_autoneg)
 365		h->ae_algo->ops->halt_autoneg(h, false);
 366
 367#if IS_ENABLED(CONFIG_VLAN_8021Q)
 368	if (h->ae_algo->ops->enable_vlan_filter &&
 369	    ndev->features & NETIF_F_HW_VLAN_CTAG_FILTER)
 370		h->ae_algo->ops->enable_vlan_filter(h, true);
 371#endif
 372
 373	if (if_running)
 374		ndev->netdev_ops->ndo_open(ndev);
 375}
 376
 377static void hns3_do_selftest(struct net_device *ndev, int (*st_param)[2],
 378			     struct ethtool_test *eth_test, u64 *data)
 379{
 380	int test_index = HNAE3_LOOP_APP;
 381	u32 i;
 382
 383	for (i = HNAE3_LOOP_APP; i < HNAE3_LOOP_NONE; i++) {
 384		enum hnae3_loop loop_type = (enum hnae3_loop)st_param[i][0];
 385
 386		if (!st_param[i][1])
 387			continue;
 388
 389		data[test_index] = hns3_lp_up(ndev, loop_type);
 390		if (!data[test_index])
 391			data[test_index] = hns3_lp_run_test(ndev, loop_type);
 392
 393		hns3_lp_down(ndev, loop_type);
 394
 395		if (data[test_index])
 396			eth_test->flags |= ETH_TEST_FL_FAILED;
 397
 398		test_index++;
 399	}
 400}
 401
 402static void hns3_do_external_lb(struct net_device *ndev,
 403				struct ethtool_test *eth_test, u64 *data)
 404{
 405	data[HNAE3_LOOP_EXTERNAL] = hns3_lp_up(ndev, HNAE3_LOOP_EXTERNAL);
 406	if (!data[HNAE3_LOOP_EXTERNAL])
 407		data[HNAE3_LOOP_EXTERNAL] = hns3_lp_run_test(ndev, HNAE3_LOOP_EXTERNAL);
 408	hns3_lp_down(ndev, HNAE3_LOOP_EXTERNAL);
 409
 410	if (data[HNAE3_LOOP_EXTERNAL])
 411		eth_test->flags |= ETH_TEST_FL_FAILED;
 412
 413	eth_test->flags |= ETH_TEST_FL_EXTERNAL_LB_DONE;
 414}
 415
 416/**
 417 * hns3_self_test - self test
 418 * @ndev: net device
 419 * @eth_test: test cmd
 420 * @data: test result
 421 */
 422static void hns3_self_test(struct net_device *ndev,
 423			   struct ethtool_test *eth_test, u64 *data)
 424{
 425	int cnt = hns3_get_sset_count(ndev, ETH_SS_TEST);
 426	struct hns3_nic_priv *priv = netdev_priv(ndev);
 427	struct hnae3_handle *h = priv->ae_handle;
 428	int st_param[HNAE3_LOOP_NONE][2];
 429	bool if_running = netif_running(ndev);
 430	int i;
 431
 432	/* initialize the loopback test result, avoid marking an unexcuted
 433	 * loopback test as PASS.
 434	 */
 435	for (i = 0; i < cnt; i++)
 436		data[i] = HNS3_NIC_LB_TEST_UNEXECUTED;
 437
 438	if (hns3_nic_resetting(ndev)) {
 439		netdev_err(ndev, "dev resetting!\n");
 440		goto failure;
 441	}
 442
 443	if (!(eth_test->flags & ETH_TEST_FL_OFFLINE))
 444		goto failure;
 445
 446	if (netif_msg_ifdown(h))
 447		netdev_info(ndev, "self test start\n");
 448
 449	hns3_set_selftest_param(h, st_param);
 450
 451	/* external loopback test requires that the link is up and the duplex is
 452	 * full, do external test first to reduce the whole test time
 453	 */
 454	if (eth_test->flags & ETH_TEST_FL_EXTERNAL_LB) {
 455		hns3_external_lb_prepare(ndev, if_running);
 456		hns3_do_external_lb(ndev, eth_test, data);
 457		hns3_external_lb_restore(ndev, if_running);
 458	}
 459
 460	hns3_selftest_prepare(ndev, if_running);
 461	hns3_do_selftest(ndev, st_param, eth_test, data);
 462	hns3_selftest_restore(ndev, if_running);
 463
 464	if (netif_msg_ifdown(h))
 465		netdev_info(ndev, "self test end\n");
 466	return;
 467
 468failure:
 469	eth_test->flags |= ETH_TEST_FL_FAILED;
 470}
 471
 472static void hns3_update_limit_promisc_mode(struct net_device *netdev,
 473					   bool enable)
 474{
 475	struct hnae3_handle *handle = hns3_get_handle(netdev);
 476
 477	if (enable)
 478		set_bit(HNAE3_PFLAG_LIMIT_PROMISC, &handle->priv_flags);
 479	else
 480		clear_bit(HNAE3_PFLAG_LIMIT_PROMISC, &handle->priv_flags);
 481
 482	hns3_request_update_promisc_mode(handle);
 483}
 484
 485static const struct hns3_pflag_desc hns3_priv_flags[HNAE3_PFLAG_MAX] = {
 486	{ "limit_promisc",	hns3_update_limit_promisc_mode }
 487};
 488
 489static int hns3_get_sset_count(struct net_device *netdev, int stringset)
 490{
 491	struct hnae3_handle *h = hns3_get_handle(netdev);
 492	const struct hnae3_ae_ops *ops = hns3_get_ops(h);
 493
 494	if (!ops->get_sset_count)
 495		return -EOPNOTSUPP;
 496
 497	switch (stringset) {
 498	case ETH_SS_STATS:
 499		return ((HNS3_TQP_STATS_COUNT * h->kinfo.num_tqps) +
 500			ops->get_sset_count(h, stringset));
 501
 502	case ETH_SS_TEST:
 503		return ops->get_sset_count(h, stringset);
 504
 505	case ETH_SS_PRIV_FLAGS:
 506		return HNAE3_PFLAG_MAX;
 507
 508	default:
 509		return -EOPNOTSUPP;
 510	}
 511}
 512
 513static void hns3_update_strings(u8 **data, const struct hns3_stats *stats,
 514				u32 stat_count, u32 num_tqps,
 515				const char *prefix)
 516{
 517	u32 i, j;
 518
 519	for (i = 0; i < num_tqps; i++)
 520		for (j = 0; j < stat_count; j++)
 521			ethtool_sprintf(data, "%s%u_%s", prefix, i,
 522					stats[j].stats_string);
 523}
 524
 525static void hns3_get_strings_tqps(struct hnae3_handle *handle, u8 **data)
 526{
 527	struct hnae3_knic_private_info *kinfo = &handle->kinfo;
 528	const char tx_prefix[] = "txq";
 529	const char rx_prefix[] = "rxq";
 530
 531	/* get strings for Tx */
 532	hns3_update_strings(data, hns3_txq_stats, HNS3_TXQ_STATS_COUNT,
 533			    kinfo->num_tqps, tx_prefix);
 534
 535	/* get strings for Rx */
 536	hns3_update_strings(data, hns3_rxq_stats, HNS3_RXQ_STATS_COUNT,
 537			    kinfo->num_tqps, rx_prefix);
 538}
 539
 540static void hns3_get_strings(struct net_device *netdev, u32 stringset, u8 *data)
 541{
 542	struct hnae3_handle *h = hns3_get_handle(netdev);
 543	const struct hnae3_ae_ops *ops = hns3_get_ops(h);
 544	u32 i;
 545
 546	if (!ops->get_strings)
 547		return;
 548
 549	switch (stringset) {
 550	case ETH_SS_STATS:
 551		hns3_get_strings_tqps(h, &data);
 552		ops->get_strings(h, stringset, &data);
 553		break;
 554	case ETH_SS_TEST:
 555		ops->get_strings(h, stringset, &data);
 556		break;
 557	case ETH_SS_PRIV_FLAGS:
 558		for (i = 0; i < HNS3_PRIV_FLAGS_LEN; i++)
 559			ethtool_puts(&data, hns3_priv_flags[i].name);
 560		break;
 561	default:
 562		break;
 563	}
 564}
 565
 566static u64 *hns3_get_stats_tqps(struct hnae3_handle *handle, u64 *data)
 567{
 568	struct hnae3_knic_private_info *kinfo = &handle->kinfo;
 569	struct hns3_nic_priv *nic_priv = handle->priv;
 570	struct hns3_enet_ring *ring;
 571	u8 *stat;
 572	u32 i, j;
 573
 574	/* get stats for Tx */
 575	for (i = 0; i < kinfo->num_tqps; i++) {
 576		ring = &nic_priv->ring[i];
 577		for (j = 0; j < HNS3_TXQ_STATS_COUNT; j++) {
 578			stat = (u8 *)ring + hns3_txq_stats[j].stats_offset;
 579			*data++ = *(u64 *)stat;
 580		}
 581	}
 582
 583	/* get stats for Rx */
 584	for (i = 0; i < kinfo->num_tqps; i++) {
 585		ring = &nic_priv->ring[i + kinfo->num_tqps];
 586		for (j = 0; j < HNS3_RXQ_STATS_COUNT; j++) {
 587			stat = (u8 *)ring + hns3_rxq_stats[j].stats_offset;
 588			*data++ = *(u64 *)stat;
 589		}
 590	}
 591
 592	return data;
 593}
 594
 595/* hns3_get_stats - get detail statistics.
 596 * @netdev: net device
 597 * @stats: statistics info.
 598 * @data: statistics data.
 599 */
 600static void hns3_get_stats(struct net_device *netdev,
 601			   struct ethtool_stats *stats, u64 *data)
 602{
 603	struct hnae3_handle *h = hns3_get_handle(netdev);
 604	u64 *p = data;
 605
 606	if (hns3_nic_resetting(netdev)) {
 607		netdev_err(netdev, "dev resetting, could not get stats\n");
 608		return;
 609	}
 610
 611	if (!h->ae_algo->ops->get_stats || !h->ae_algo->ops->update_stats) {
 612		netdev_err(netdev, "could not get any statistics\n");
 613		return;
 614	}
 615
 616	h->ae_algo->ops->update_stats(h);
 617
 618	/* get per-queue stats */
 619	p = hns3_get_stats_tqps(h, p);
 620
 621	/* get MAC & other misc hardware stats */
 622	h->ae_algo->ops->get_stats(h, p);
 623}
 624
 625static void hns3_get_drvinfo(struct net_device *netdev,
 626			     struct ethtool_drvinfo *drvinfo)
 627{
 628	struct hns3_nic_priv *priv = netdev_priv(netdev);
 629	struct hnae3_handle *h = priv->ae_handle;
 630	u32 fw_version;
 631
 632	if (!h->ae_algo->ops->get_fw_version) {
 633		netdev_err(netdev, "could not get fw version!\n");
 634		return;
 635	}
 636
 637	strscpy(drvinfo->driver, dev_driver_string(&h->pdev->dev),
 638		sizeof(drvinfo->driver));
 639
 640	strscpy(drvinfo->bus_info, pci_name(h->pdev),
 641		sizeof(drvinfo->bus_info));
 642
 643	fw_version = priv->ae_handle->ae_algo->ops->get_fw_version(h);
 644
 645	snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version),
 646		 "%lu.%lu.%lu.%lu",
 647		 hnae3_get_field(fw_version, HNAE3_FW_VERSION_BYTE3_MASK,
 648				 HNAE3_FW_VERSION_BYTE3_SHIFT),
 649		 hnae3_get_field(fw_version, HNAE3_FW_VERSION_BYTE2_MASK,
 650				 HNAE3_FW_VERSION_BYTE2_SHIFT),
 651		 hnae3_get_field(fw_version, HNAE3_FW_VERSION_BYTE1_MASK,
 652				 HNAE3_FW_VERSION_BYTE1_SHIFT),
 653		 hnae3_get_field(fw_version, HNAE3_FW_VERSION_BYTE0_MASK,
 654				 HNAE3_FW_VERSION_BYTE0_SHIFT));
 655}
 656
 657static u32 hns3_get_link(struct net_device *netdev)
 658{
 659	struct hnae3_handle *h = hns3_get_handle(netdev);
 660
 661	if (h->ae_algo->ops->get_status)
 662		return h->ae_algo->ops->get_status(h);
 663	else
 664		return 0;
 665}
 666
 667static void hns3_get_ringparam(struct net_device *netdev,
 668			       struct ethtool_ringparam *param,
 669			       struct kernel_ethtool_ringparam *kernel_param,
 670			       struct netlink_ext_ack *extack)
 671{
 672	struct hns3_nic_priv *priv = netdev_priv(netdev);
 673	struct hnae3_handle *h = priv->ae_handle;
 674	int rx_queue_index = h->kinfo.num_tqps;
 675
 676	if (hns3_nic_resetting(netdev) || !priv->ring) {
 677		netdev_err(netdev, "failed to get ringparam value, due to dev resetting or uninited\n");
 678		return;
 679	}
 680
 681	param->tx_max_pending = HNS3_RING_MAX_PENDING;
 682	param->rx_max_pending = HNS3_RING_MAX_PENDING;
 683
 684	param->tx_pending = priv->ring[0].desc_num;
 685	param->rx_pending = priv->ring[rx_queue_index].desc_num;
 686	kernel_param->rx_buf_len = priv->ring[rx_queue_index].buf_size;
 687	kernel_param->tx_push = test_bit(HNS3_NIC_STATE_TX_PUSH_ENABLE,
 688					 &priv->state);
 689}
 690
 691static void hns3_get_pauseparam(struct net_device *netdev,
 692				struct ethtool_pauseparam *param)
 693{
 694	struct hnae3_handle *h = hns3_get_handle(netdev);
 695	struct hnae3_ae_dev *ae_dev = hns3_get_ae_dev(h);
 696
 697	if (!test_bit(HNAE3_DEV_SUPPORT_PAUSE_B, ae_dev->caps))
 698		return;
 699
 700	if (h->ae_algo->ops->get_pauseparam)
 701		h->ae_algo->ops->get_pauseparam(h, &param->autoneg,
 702			&param->rx_pause, &param->tx_pause);
 703}
 704
 705static int hns3_set_pauseparam(struct net_device *netdev,
 706			       struct ethtool_pauseparam *param)
 707{
 708	struct hnae3_handle *h = hns3_get_handle(netdev);
 709	struct hnae3_ae_dev *ae_dev = hns3_get_ae_dev(h);
 710
 711	if (!test_bit(HNAE3_DEV_SUPPORT_PAUSE_B, ae_dev->caps))
 712		return -EOPNOTSUPP;
 713
 714	netif_dbg(h, drv, netdev,
 715		  "set pauseparam: autoneg=%u, rx:%u, tx:%u\n",
 716		  param->autoneg, param->rx_pause, param->tx_pause);
 717
 718	if (h->ae_algo->ops->set_pauseparam)
 719		return h->ae_algo->ops->set_pauseparam(h, param->autoneg,
 720						       param->rx_pause,
 721						       param->tx_pause);
 722	return -EOPNOTSUPP;
 723}
 724
 725static void hns3_get_ksettings(struct hnae3_handle *h,
 726			       struct ethtool_link_ksettings *cmd)
 727{
 728	const struct hnae3_ae_ops *ops = hns3_get_ops(h);
 729
 730	/* 1.auto_neg & speed & duplex from cmd */
 731	if (ops->get_ksettings_an_result)
 732		ops->get_ksettings_an_result(h,
 733					     &cmd->base.autoneg,
 734					     &cmd->base.speed,
 735					     &cmd->base.duplex,
 736					     &cmd->lanes);
 737
 738	/* 2.get link mode */
 739	if (ops->get_link_mode)
 740		ops->get_link_mode(h,
 741				   cmd->link_modes.supported,
 742				   cmd->link_modes.advertising);
 743
 744	/* 3.mdix_ctrl&mdix get from phy reg */
 745	if (ops->get_mdix_mode)
 746		ops->get_mdix_mode(h, &cmd->base.eth_tp_mdix_ctrl,
 747				   &cmd->base.eth_tp_mdix);
 748}
 749
 750static int hns3_get_link_ksettings(struct net_device *netdev,
 751				   struct ethtool_link_ksettings *cmd)
 752{
 753	struct hnae3_handle *h = hns3_get_handle(netdev);
 754	struct hnae3_ae_dev *ae_dev = hns3_get_ae_dev(h);
 755	const struct hnae3_ae_ops *ops;
 756	u8 module_type;
 757	u8 media_type;
 758	u8 link_stat;
 759
 760	ops = h->ae_algo->ops;
 761	if (ops->get_media_type)
 762		ops->get_media_type(h, &media_type, &module_type);
 763	else
 764		return -EOPNOTSUPP;
 765
 766	switch (media_type) {
 767	case HNAE3_MEDIA_TYPE_NONE:
 768		cmd->base.port = PORT_NONE;
 769		hns3_get_ksettings(h, cmd);
 770		break;
 771	case HNAE3_MEDIA_TYPE_FIBER:
 772		if (module_type == HNAE3_MODULE_TYPE_UNKNOWN)
 773			cmd->base.port = PORT_OTHER;
 774		else if (module_type == HNAE3_MODULE_TYPE_CR)
 775			cmd->base.port = PORT_DA;
 776		else
 777			cmd->base.port = PORT_FIBRE;
 778
 779		hns3_get_ksettings(h, cmd);
 780		break;
 781	case HNAE3_MEDIA_TYPE_BACKPLANE:
 782		cmd->base.port = PORT_NONE;
 783		hns3_get_ksettings(h, cmd);
 784		break;
 785	case HNAE3_MEDIA_TYPE_COPPER:
 786		cmd->base.port = PORT_TP;
 787		if (test_bit(HNAE3_DEV_SUPPORT_PHY_IMP_B, ae_dev->caps) &&
 788		    ops->get_phy_link_ksettings)
 789			ops->get_phy_link_ksettings(h, cmd);
 790		else if (!netdev->phydev)
 791			hns3_get_ksettings(h, cmd);
 792		else
 793			phy_ethtool_ksettings_get(netdev->phydev, cmd);
 794		break;
 795	default:
 796
 797		netdev_warn(netdev, "Unknown media type\n");
 798		return 0;
 799	}
 800
 801	/* mdio_support */
 802	cmd->base.mdio_support = ETH_MDIO_SUPPORTS_C22;
 803
 804	link_stat = hns3_get_link(netdev);
 805	if (!link_stat) {
 806		cmd->base.speed = SPEED_UNKNOWN;
 807		cmd->base.duplex = DUPLEX_UNKNOWN;
 808	}
 809
 810	return 0;
 811}
 812
 813static int hns3_check_ksettings_param(const struct net_device *netdev,
 814				      const struct ethtool_link_ksettings *cmd)
 815{
 816	struct hnae3_handle *handle = hns3_get_handle(netdev);
 817	const struct hnae3_ae_ops *ops = hns3_get_ops(handle);
 818	u8 module_type = HNAE3_MODULE_TYPE_UNKNOWN;
 819	u8 media_type = HNAE3_MEDIA_TYPE_UNKNOWN;
 820	u32 lane_num;
 821	u8 autoneg;
 822	u32 speed;
 823	u8 duplex;
 824	int ret;
 825
 826	/* hw doesn't support use specified speed and duplex to negotiate,
 827	 * unnecessary to check them when autoneg on.
 828	 */
 829	if (cmd->base.autoneg)
 830		return 0;
 831
 832	if (ops->get_ksettings_an_result) {
 833		ops->get_ksettings_an_result(handle, &autoneg, &speed, &duplex, &lane_num);
 834		if (cmd->base.autoneg == autoneg && cmd->base.speed == speed &&
 835		    cmd->base.duplex == duplex && cmd->lanes == lane_num)
 836			return 0;
 837	}
 838
 839	if (ops->get_media_type)
 840		ops->get_media_type(handle, &media_type, &module_type);
 841
 842	if (cmd->base.duplex == DUPLEX_HALF &&
 843	    media_type != HNAE3_MEDIA_TYPE_COPPER) {
 844		netdev_err(netdev,
 845			   "only copper port supports half duplex!\n");
 846		return -EINVAL;
 847	}
 848
 849	if (ops->check_port_speed) {
 850		ret = ops->check_port_speed(handle, cmd->base.speed);
 851		if (ret) {
 852			netdev_err(netdev, "unsupported speed\n");
 853			return ret;
 854		}
 855	}
 856
 857	return 0;
 858}
 859
 860static int hns3_set_link_ksettings(struct net_device *netdev,
 861				   const struct ethtool_link_ksettings *cmd)
 862{
 863	struct hnae3_handle *handle = hns3_get_handle(netdev);
 864	struct hnae3_ae_dev *ae_dev = hns3_get_ae_dev(handle);
 865	const struct hnae3_ae_ops *ops = hns3_get_ops(handle);
 866	int ret;
 867
 868	/* Chip don't support this mode. */
 869	if (cmd->base.speed == SPEED_1000 && cmd->base.duplex == DUPLEX_HALF)
 870		return -EINVAL;
 871
 872	if (cmd->lanes && !hnae3_ae_dev_lane_num_supported(ae_dev))
 873		return -EOPNOTSUPP;
 874
 875	netif_dbg(handle, drv, netdev,
 876		  "set link(%s): autoneg=%u, speed=%u, duplex=%u, lanes=%u\n",
 877		  netdev->phydev ? "phy" : "mac",
 878		  cmd->base.autoneg, cmd->base.speed, cmd->base.duplex,
 879		  cmd->lanes);
 880
 881	/* Only support ksettings_set for netdev with phy attached for now */
 882	if (netdev->phydev) {
 883		if (cmd->base.speed == SPEED_1000 &&
 884		    cmd->base.autoneg == AUTONEG_DISABLE)
 885			return -EINVAL;
 886
 887		return phy_ethtool_ksettings_set(netdev->phydev, cmd);
 888	} else if (test_bit(HNAE3_DEV_SUPPORT_PHY_IMP_B, ae_dev->caps) &&
 889		   ops->set_phy_link_ksettings) {
 890		return ops->set_phy_link_ksettings(handle, cmd);
 891	}
 892
 893	if (ae_dev->dev_version < HNAE3_DEVICE_VERSION_V2)
 894		return -EOPNOTSUPP;
 895
 896	ret = hns3_check_ksettings_param(netdev, cmd);
 897	if (ret)
 898		return ret;
 899
 900	if (ops->set_autoneg) {
 901		ret = ops->set_autoneg(handle, cmd->base.autoneg);
 902		if (ret)
 903			return ret;
 904	}
 905
 906	/* hw doesn't support use specified speed and duplex to negotiate,
 907	 * ignore them when autoneg on.
 908	 */
 909	if (cmd->base.autoneg) {
 910		netdev_info(netdev,
 911			    "autoneg is on, ignore the speed and duplex\n");
 912		return 0;
 913	}
 914
 915	if (ops->cfg_mac_speed_dup_h)
 916		ret = ops->cfg_mac_speed_dup_h(handle, cmd->base.speed,
 917					       cmd->base.duplex, (u8)(cmd->lanes));
 918
 919	return ret;
 920}
 921
 922static u32 hns3_get_rss_key_size(struct net_device *netdev)
 923{
 924	struct hnae3_handle *h = hns3_get_handle(netdev);
 925
 926	if (!h->ae_algo->ops->get_rss_key_size)
 927		return 0;
 928
 929	return h->ae_algo->ops->get_rss_key_size(h);
 930}
 931
 932static u32 hns3_get_rss_indir_size(struct net_device *netdev)
 933{
 934	struct hnae3_handle *h = hns3_get_handle(netdev);
 935	struct hnae3_ae_dev *ae_dev = hns3_get_ae_dev(h);
 936
 937	return ae_dev->dev_specs.rss_ind_tbl_size;
 938}
 939
 940static int hns3_get_rss(struct net_device *netdev,
 941			struct ethtool_rxfh_param *rxfh)
 942{
 943	struct hnae3_handle *h = hns3_get_handle(netdev);
 944
 945	if (!h->ae_algo->ops->get_rss)
 946		return -EOPNOTSUPP;
 947
 948	return h->ae_algo->ops->get_rss(h, rxfh->indir, rxfh->key,
 949					&rxfh->hfunc);
 950}
 951
 952static int hns3_set_rss(struct net_device *netdev,
 953			struct ethtool_rxfh_param *rxfh,
 954			struct netlink_ext_ack *extack)
 955{
 956	struct hnae3_handle *h = hns3_get_handle(netdev);
 957	struct hnae3_ae_dev *ae_dev = hns3_get_ae_dev(h);
 958
 959	if (!h->ae_algo->ops->set_rss)
 960		return -EOPNOTSUPP;
 961
 962	if ((ae_dev->dev_version < HNAE3_DEVICE_VERSION_V2 &&
 963	     rxfh->hfunc != ETH_RSS_HASH_TOP) ||
 964	    (rxfh->hfunc != ETH_RSS_HASH_NO_CHANGE &&
 965	     rxfh->hfunc != ETH_RSS_HASH_TOP &&
 966	     rxfh->hfunc != ETH_RSS_HASH_XOR)) {
 967		netdev_err(netdev, "hash func not supported\n");
 968		return -EOPNOTSUPP;
 969	}
 970
 971	if (!rxfh->indir) {
 972		netdev_err(netdev,
 973			   "set rss failed for indir is empty\n");
 974		return -EOPNOTSUPP;
 975	}
 976
 977	return h->ae_algo->ops->set_rss(h, rxfh->indir, rxfh->key,
 978					rxfh->hfunc);
 979}
 980
 981static int hns3_get_rxfh_fields(struct net_device *netdev,
 982				struct ethtool_rxfh_fields *cmd)
 983{
 984	struct hnae3_handle *h = hns3_get_handle(netdev);
 985
 986	if (h->ae_algo->ops->get_rss_tuple)
 987		return h->ae_algo->ops->get_rss_tuple(h, cmd);
 988	return -EOPNOTSUPP;
 989}
 990
 991static int hns3_get_rxnfc(struct net_device *netdev,
 992			  struct ethtool_rxnfc *cmd,
 993			  u32 *rule_locs)
 994{
 995	struct hnae3_handle *h = hns3_get_handle(netdev);
 996
 997	switch (cmd->cmd) {
 998	case ETHTOOL_GRXRINGS:
 999		cmd->data = h->kinfo.num_tqps;
1000		return 0;
1001	case ETHTOOL_GRXCLSRLCNT:
1002		if (h->ae_algo->ops->get_fd_rule_cnt)
1003			return h->ae_algo->ops->get_fd_rule_cnt(h, cmd);
1004		return -EOPNOTSUPP;
1005	case ETHTOOL_GRXCLSRULE:
1006		if (h->ae_algo->ops->get_fd_rule_info)
1007			return h->ae_algo->ops->get_fd_rule_info(h, cmd);
1008		return -EOPNOTSUPP;
1009	case ETHTOOL_GRXCLSRLALL:
1010		if (h->ae_algo->ops->get_fd_all_rules)
1011			return h->ae_algo->ops->get_fd_all_rules(h, cmd,
1012								 rule_locs);
1013		return -EOPNOTSUPP;
1014	default:
1015		return -EOPNOTSUPP;
1016	}
1017}
1018
1019static const struct hns3_reset_type_map hns3_reset_type[] = {
1020	{ETH_RESET_MGMT, HNAE3_IMP_RESET},
1021	{ETH_RESET_ALL, HNAE3_GLOBAL_RESET},
1022	{ETH_RESET_DEDICATED, HNAE3_FUNC_RESET},
1023};
1024
1025static const struct hns3_reset_type_map hns3vf_reset_type[] = {
1026	{ETH_RESET_DEDICATED, HNAE3_VF_FUNC_RESET},
1027};
1028
1029static int hns3_set_reset(struct net_device *netdev, u32 *flags)
1030{
1031	enum hnae3_reset_type rst_type = HNAE3_NONE_RESET;
1032	struct hnae3_handle *h = hns3_get_handle(netdev);
1033	struct hnae3_ae_dev *ae_dev = hns3_get_ae_dev(h);
1034	const struct hnae3_ae_ops *ops = hns3_get_ops(h);
1035	const struct hns3_reset_type_map *rst_type_map;
1036	enum ethtool_reset_flags rst_flags;
1037	u32 i, size;
1038
1039	if (ops->ae_dev_resetting && ops->ae_dev_resetting(h))
1040		return -EBUSY;
1041
1042	if (!ops->set_default_reset_request || !ops->reset_event)
1043		return -EOPNOTSUPP;
1044
1045	if (h->flags & HNAE3_SUPPORT_VF) {
1046		rst_type_map = hns3vf_reset_type;
1047		size = ARRAY_SIZE(hns3vf_reset_type);
1048	} else {
1049		rst_type_map = hns3_reset_type;
1050		size = ARRAY_SIZE(hns3_reset_type);
1051	}
1052
1053	for (i = 0; i < size; i++) {
1054		if (rst_type_map[i].rst_flags == *flags) {
1055			rst_type = rst_type_map[i].rst_type;
1056			rst_flags = rst_type_map[i].rst_flags;
1057			break;
1058		}
1059	}
1060
1061	if (rst_type == HNAE3_NONE_RESET ||
1062	    (rst_type == HNAE3_IMP_RESET &&
1063	     ae_dev->dev_version <= HNAE3_DEVICE_VERSION_V2))
1064		return -EOPNOTSUPP;
1065
1066	netdev_info(netdev, "Setting reset type %d\n", rst_type);
1067
1068	ops->set_default_reset_request(ae_dev, rst_type);
1069
1070	ops->reset_event(h->pdev, h);
1071
1072	*flags &= ~rst_flags;
1073
1074	return 0;
1075}
1076
1077static void hns3_change_all_ring_bd_num(struct hns3_nic_priv *priv,
1078					u32 tx_desc_num, u32 rx_desc_num)
1079{
1080	struct hnae3_handle *h = priv->ae_handle;
1081	int i;
1082
1083	h->kinfo.num_tx_desc = tx_desc_num;
1084	h->kinfo.num_rx_desc = rx_desc_num;
1085
1086	for (i = 0; i < h->kinfo.num_tqps; i++) {
1087		priv->ring[i].desc_num = tx_desc_num;
1088		priv->ring[i + h->kinfo.num_tqps].desc_num = rx_desc_num;
1089	}
1090}
1091
1092static struct hns3_enet_ring *hns3_backup_ringparam(struct hns3_nic_priv *priv)
1093{
1094	struct hnae3_handle *handle = priv->ae_handle;
1095	struct hns3_enet_ring *tmp_rings;
1096	int i;
1097
1098	tmp_rings = kcalloc(handle->kinfo.num_tqps * 2,
1099			    sizeof(struct hns3_enet_ring), GFP_KERNEL);
1100	if (!tmp_rings)
1101		return NULL;
1102
1103	for (i = 0; i < handle->kinfo.num_tqps * 2; i++) {
1104		memcpy(&tmp_rings[i], &priv->ring[i],
1105		       sizeof(struct hns3_enet_ring));
1106		tmp_rings[i].skb = NULL;
1107	}
1108
1109	return tmp_rings;
1110}
1111
1112static int hns3_check_ringparam(struct net_device *ndev,
1113				struct ethtool_ringparam *param,
1114				struct kernel_ethtool_ringparam *kernel_param)
1115{
1116#define RX_BUF_LEN_2K 2048
1117#define RX_BUF_LEN_4K 4096
1118
1119	struct hns3_nic_priv *priv = netdev_priv(ndev);
1120
1121	if (hns3_nic_resetting(ndev) || !priv->ring) {
1122		netdev_err(ndev, "failed to set ringparam value, due to dev resetting or uninited\n");
1123		return -EBUSY;
1124	}
1125
1126
1127	if (param->rx_mini_pending || param->rx_jumbo_pending)
1128		return -EINVAL;
1129
1130	if (kernel_param->rx_buf_len != RX_BUF_LEN_2K &&
1131	    kernel_param->rx_buf_len != RX_BUF_LEN_4K) {
1132		netdev_err(ndev, "Rx buf len only support 2048 and 4096\n");
1133		return -EINVAL;
1134	}
1135
1136	if (param->tx_pending > HNS3_RING_MAX_PENDING ||
1137	    param->tx_pending < HNS3_RING_MIN_PENDING ||
1138	    param->rx_pending > HNS3_RING_MAX_PENDING ||
1139	    param->rx_pending < HNS3_RING_MIN_PENDING) {
1140		netdev_err(ndev, "Queue depth out of range [%d-%d]\n",
1141			   HNS3_RING_MIN_PENDING, HNS3_RING_MAX_PENDING);
1142		return -EINVAL;
1143	}
1144
1145	return 0;
1146}
1147
1148static bool
1149hns3_is_ringparam_changed(struct net_device *ndev,
1150			  struct ethtool_ringparam *param,
1151			  struct kernel_ethtool_ringparam *kernel_param,
1152			  struct hns3_ring_param *old_ringparam,
1153			  struct hns3_ring_param *new_ringparam)
1154{
1155	struct hns3_nic_priv *priv = netdev_priv(ndev);
1156	struct hnae3_handle *h = priv->ae_handle;
1157	u16 queue_num = h->kinfo.num_tqps;
1158
1159	new_ringparam->tx_desc_num = ALIGN(param->tx_pending,
1160					   HNS3_RING_BD_MULTIPLE);
1161	new_ringparam->rx_desc_num = ALIGN(param->rx_pending,
1162					   HNS3_RING_BD_MULTIPLE);
1163	old_ringparam->tx_desc_num = priv->ring[0].desc_num;
1164	old_ringparam->rx_desc_num = priv->ring[queue_num].desc_num;
1165	old_ringparam->rx_buf_len = priv->ring[queue_num].buf_size;
1166	new_ringparam->rx_buf_len = kernel_param->rx_buf_len;
1167
1168	if (old_ringparam->tx_desc_num == new_ringparam->tx_desc_num &&
1169	    old_ringparam->rx_desc_num == new_ringparam->rx_desc_num &&
1170	    old_ringparam->rx_buf_len == new_ringparam->rx_buf_len) {
1171		netdev_info(ndev, "descriptor number and rx buffer length not changed\n");
1172		return false;
1173	}
1174
1175	return true;
1176}
1177
1178static int hns3_change_rx_buf_len(struct net_device *ndev, u32 rx_buf_len)
1179{
1180	struct hns3_nic_priv *priv = netdev_priv(ndev);
1181	struct hnae3_handle *h = priv->ae_handle;
1182	int i;
1183
1184	h->kinfo.rx_buf_len = rx_buf_len;
1185
1186	for (i = 0; i < h->kinfo.num_tqps; i++) {
1187		h->kinfo.tqp[i]->buf_size = rx_buf_len;
1188		priv->ring[i + h->kinfo.num_tqps].buf_size = rx_buf_len;
1189	}
1190
1191	return 0;
1192}
1193
1194static int hns3_set_tx_push(struct net_device *netdev, u32 tx_push)
1195{
1196	struct hns3_nic_priv *priv = netdev_priv(netdev);
1197	struct hnae3_handle *h = hns3_get_handle(netdev);
1198	struct hnae3_ae_dev *ae_dev = hns3_get_ae_dev(h);
1199	u32 old_state = test_bit(HNS3_NIC_STATE_TX_PUSH_ENABLE, &priv->state);
1200
1201	if (!test_bit(HNAE3_DEV_SUPPORT_TX_PUSH_B, ae_dev->caps) && tx_push)
1202		return -EOPNOTSUPP;
1203
1204	if (tx_push == old_state)
1205		return 0;
1206
1207	netdev_dbg(netdev, "Changing tx push from %s to %s\n",
1208		   str_on_off(old_state), str_on_off(tx_push));
1209
1210	if (tx_push)
1211		set_bit(HNS3_NIC_STATE_TX_PUSH_ENABLE, &priv->state);
1212	else
1213		clear_bit(HNS3_NIC_STATE_TX_PUSH_ENABLE, &priv->state);
1214
1215	return 0;
1216}
1217
1218static int hns3_set_ringparam(struct net_device *ndev,
1219			      struct ethtool_ringparam *param,
1220			      struct kernel_ethtool_ringparam *kernel_param,
1221			      struct netlink_ext_ack *extack)
1222{
1223	struct hns3_ring_param old_ringparam, new_ringparam;
1224	struct hns3_nic_priv *priv = netdev_priv(ndev);
1225	struct hnae3_handle *h = priv->ae_handle;
1226	struct hns3_enet_ring *tmp_rings;
1227	bool if_running = netif_running(ndev);
1228	int ret, i;
1229
1230	ret = hns3_check_ringparam(ndev, param, kernel_param);
1231	if (ret)
1232		return ret;
1233
1234	ret = hns3_set_tx_push(ndev, kernel_param->tx_push);
1235	if (ret)
1236		return ret;
1237
1238	if (!hns3_is_ringparam_changed(ndev, param, kernel_param,
1239				       &old_ringparam, &new_ringparam))
1240		return 0;
1241
1242	tmp_rings = hns3_backup_ringparam(priv);
1243	if (!tmp_rings) {
1244		netdev_err(ndev, "backup ring param failed by allocating memory fail\n");
1245		return -ENOMEM;
1246	}
1247
1248	netdev_info(ndev,
1249		    "Changing Tx/Rx ring depth from %u/%u to %u/%u, Changing rx buffer len from %u to %u\n",
1250		    old_ringparam.tx_desc_num, old_ringparam.rx_desc_num,
1251		    new_ringparam.tx_desc_num, new_ringparam.rx_desc_num,
1252		    old_ringparam.rx_buf_len, new_ringparam.rx_buf_len);
1253
1254	if (if_running)
1255		ndev->netdev_ops->ndo_stop(ndev);
1256
1257	hns3_change_all_ring_bd_num(priv, new_ringparam.tx_desc_num,
1258				    new_ringparam.rx_desc_num);
1259	hns3_change_rx_buf_len(ndev, new_ringparam.rx_buf_len);
1260	ret = hns3_init_all_ring(priv);
1261	if (ret) {
1262		netdev_err(ndev, "set ringparam fail, revert to old value(%d)\n",
1263			   ret);
1264
1265		hns3_change_rx_buf_len(ndev, old_ringparam.rx_buf_len);
1266		hns3_change_all_ring_bd_num(priv, old_ringparam.tx_desc_num,
1267					    old_ringparam.rx_desc_num);
1268		for (i = 0; i < h->kinfo.num_tqps * 2; i++)
1269			memcpy(&priv->ring[i], &tmp_rings[i],
1270			       sizeof(struct hns3_enet_ring));
1271	} else {
1272		for (i = 0; i < h->kinfo.num_tqps * 2; i++)
1273			hns3_fini_ring(&tmp_rings[i]);
1274	}
1275
1276	kfree(tmp_rings);
1277
1278	if (if_running)
1279		ret = ndev->netdev_ops->ndo_open(ndev);
1280
1281	return ret;
1282}
1283
1284static int hns3_set_rxfh_fields(struct net_device *netdev,
1285				const struct ethtool_rxfh_fields *cmd,
1286				struct netlink_ext_ack *extack)
1287{
1288	struct hnae3_handle *h = hns3_get_handle(netdev);
1289
1290	if (h->ae_algo->ops->set_rss_tuple)
1291		return h->ae_algo->ops->set_rss_tuple(h, cmd);
1292	return -EOPNOTSUPP;
1293}
1294
1295static int hns3_set_rxnfc(struct net_device *netdev, struct ethtool_rxnfc *cmd)
1296{
1297	struct hnae3_handle *h = hns3_get_handle(netdev);
1298
1299	switch (cmd->cmd) {
1300	case ETHTOOL_SRXCLSRLINS:
1301		if (h->ae_algo->ops->add_fd_entry)
1302			return h->ae_algo->ops->add_fd_entry(h, cmd);
1303		return -EOPNOTSUPP;
1304	case ETHTOOL_SRXCLSRLDEL:
1305		if (h->ae_algo->ops->del_fd_entry)
1306			return h->ae_algo->ops->del_fd_entry(h, cmd);
1307		return -EOPNOTSUPP;
1308	default:
1309		return -EOPNOTSUPP;
1310	}
1311}
1312
1313static int hns3_nway_reset(struct net_device *netdev)
1314{
1315	struct hnae3_handle *handle = hns3_get_handle(netdev);
1316	const struct hnae3_ae_ops *ops = hns3_get_ops(handle);
1317	struct phy_device *phy = netdev->phydev;
1318	int autoneg;
1319
1320	if (!netif_running(netdev))
1321		return 0;
1322
1323	if (hns3_nic_resetting(netdev)) {
1324		netdev_err(netdev, "dev resetting!\n");
1325		return -EBUSY;
1326	}
1327
1328	if (!ops->get_autoneg || !ops->restart_autoneg)
1329		return -EOPNOTSUPP;
1330
1331	autoneg = ops->get_autoneg(handle);
1332	if (autoneg != AUTONEG_ENABLE) {
1333		netdev_err(netdev,
1334			   "Autoneg is off, don't support to restart it\n");
1335		return -EINVAL;
1336	}
1337
1338	netif_dbg(handle, drv, netdev,
1339		  "nway reset (using %s)\n", phy ? "phy" : "mac");
1340
1341	if (phy)
1342		return genphy_restart_aneg(phy);
1343
1344	return ops->restart_autoneg(handle);
1345}
1346
1347static void hns3_get_channels(struct net_device *netdev,
1348			      struct ethtool_channels *ch)
1349{
1350	struct hnae3_handle *h = hns3_get_handle(netdev);
1351
1352	if (h->ae_algo->ops->get_channels)
1353		h->ae_algo->ops->get_channels(h, ch);
1354}
1355
1356static int hns3_get_coalesce(struct net_device *netdev,
1357			     struct ethtool_coalesce *cmd,
1358			     struct kernel_ethtool_coalesce *kernel_coal,
1359			     struct netlink_ext_ack *extack)
1360{
1361	struct hns3_nic_priv *priv = netdev_priv(netdev);
1362	struct hns3_enet_coalesce *tx_coal = &priv->tx_coal;
1363	struct hns3_enet_coalesce *rx_coal = &priv->rx_coal;
1364	struct hnae3_handle *h = priv->ae_handle;
1365
1366	if (hns3_nic_resetting(netdev))
1367		return -EBUSY;
1368
1369	cmd->use_adaptive_tx_coalesce = tx_coal->adapt_enable;
1370	cmd->use_adaptive_rx_coalesce = rx_coal->adapt_enable;
1371
1372	cmd->tx_coalesce_usecs = tx_coal->int_gl;
1373	cmd->rx_coalesce_usecs = rx_coal->int_gl;
1374
1375	cmd->tx_coalesce_usecs_high = h->kinfo.int_rl_setting;
1376	cmd->rx_coalesce_usecs_high = h->kinfo.int_rl_setting;
1377
1378	cmd->tx_max_coalesced_frames = tx_coal->int_ql;
1379	cmd->rx_max_coalesced_frames = rx_coal->int_ql;
1380
1381	kernel_coal->use_cqe_mode_tx = (priv->tx_cqe_mode ==
1382					DIM_CQ_PERIOD_MODE_START_FROM_CQE);
1383	kernel_coal->use_cqe_mode_rx = (priv->rx_cqe_mode ==
1384					DIM_CQ_PERIOD_MODE_START_FROM_CQE);
1385
1386	return 0;
1387}
1388
1389static int hns3_check_gl_coalesce_para(struct net_device *netdev,
1390				       struct ethtool_coalesce *cmd)
1391{
1392	struct hnae3_handle *handle = hns3_get_handle(netdev);
1393	struct hnae3_ae_dev *ae_dev = hns3_get_ae_dev(handle);
1394	u32 rx_gl, tx_gl;
1395
1396	if (cmd->rx_coalesce_usecs > ae_dev->dev_specs.max_int_gl) {
1397		netdev_err(netdev,
1398			   "invalid rx-usecs value, rx-usecs range is 0-%u\n",
1399			   ae_dev->dev_specs.max_int_gl);
1400		return -EINVAL;
1401	}
1402
1403	if (cmd->tx_coalesce_usecs > ae_dev->dev_specs.max_int_gl) {
1404		netdev_err(netdev,
1405			   "invalid tx-usecs value, tx-usecs range is 0-%u\n",
1406			   ae_dev->dev_specs.max_int_gl);
1407		return -EINVAL;
1408	}
1409
1410	/* device version above V3(include V3), GL uses 1us unit,
1411	 * so the round down is not needed.
1412	 */
1413	if (ae_dev->dev_version >= HNAE3_DEVICE_VERSION_V3)
1414		return 0;
1415
1416	rx_gl = hns3_gl_round_down(cmd->rx_coalesce_usecs);
1417	if (rx_gl != cmd->rx_coalesce_usecs) {
1418		netdev_info(netdev,
1419			    "rx_usecs(%u) rounded down to %u, because it must be multiple of 2.\n",
1420			    cmd->rx_coalesce_usecs, rx_gl);
1421	}
1422
1423	tx_gl = hns3_gl_round_down(cmd->tx_coalesce_usecs);
1424	if (tx_gl != cmd->tx_coalesce_usecs) {
1425		netdev_info(netdev,
1426			    "tx_usecs(%u) rounded down to %u, because it must be multiple of 2.\n",
1427			    cmd->tx_coalesce_usecs, tx_gl);
1428	}
1429
1430	return 0;
1431}
1432
1433static int hns3_check_rl_coalesce_para(struct net_device *netdev,
1434				       struct ethtool_coalesce *cmd)
1435{
1436	u32 rl;
1437
1438	if (cmd->tx_coalesce_usecs_high != cmd->rx_coalesce_usecs_high) {
1439		netdev_err(netdev,
1440			   "tx_usecs_high must be same as rx_usecs_high.\n");
1441		return -EINVAL;
1442	}
1443
1444	if (cmd->rx_coalesce_usecs_high > HNS3_INT_RL_MAX) {
1445		netdev_err(netdev,
1446			   "Invalid usecs_high value, usecs_high range is 0-%d\n",
1447			   HNS3_INT_RL_MAX);
1448		return -EINVAL;
1449	}
1450
1451	rl = hns3_rl_round_down(cmd->rx_coalesce_usecs_high);
1452	if (rl != cmd->rx_coalesce_usecs_high) {
1453		netdev_info(netdev,
1454			    "usecs_high(%u) rounded down to %u, because it must be multiple of 4.\n",
1455			    cmd->rx_coalesce_usecs_high, rl);
1456	}
1457
1458	return 0;
1459}
1460
1461static int hns3_check_ql_coalesce_param(struct net_device *netdev,
1462					struct ethtool_coalesce *cmd)
1463{
1464	struct hnae3_handle *handle = hns3_get_handle(netdev);
1465	struct hnae3_ae_dev *ae_dev = hns3_get_ae_dev(handle);
1466
1467	if ((cmd->tx_max_coalesced_frames || cmd->rx_max_coalesced_frames) &&
1468	    !ae_dev->dev_specs.int_ql_max) {
1469		netdev_err(netdev, "coalesced frames is not supported\n");
1470		return -EOPNOTSUPP;
1471	}
1472
1473	if (cmd->tx_max_coalesced_frames > ae_dev->dev_specs.int_ql_max ||
1474	    cmd->rx_max_coalesced_frames > ae_dev->dev_specs.int_ql_max) {
1475		netdev_err(netdev,
1476			   "invalid coalesced_frames value, range is 0-%u\n",
1477			   ae_dev->dev_specs.int_ql_max);
1478		return -ERANGE;
1479	}
1480
1481	return 0;
1482}
1483
1484static int
1485hns3_check_cqe_coalesce_param(struct net_device *netdev,
1486			      struct kernel_ethtool_coalesce *kernel_coal)
1487{
1488	struct hnae3_handle *handle = hns3_get_handle(netdev);
1489	struct hnae3_ae_dev *ae_dev = hns3_get_ae_dev(handle);
1490
1491	if ((kernel_coal->use_cqe_mode_tx || kernel_coal->use_cqe_mode_rx) &&
1492	    !hnae3_ae_dev_cq_supported(ae_dev)) {
1493		netdev_err(netdev, "coalesced cqe mode is not supported\n");
1494		return -EOPNOTSUPP;
1495	}
1496
1497	return 0;
1498}
1499
1500static int
1501hns3_check_coalesce_para(struct net_device *netdev,
1502			 struct ethtool_coalesce *cmd,
1503			 struct kernel_ethtool_coalesce *kernel_coal)
1504{
1505	int ret;
1506
1507	ret = hns3_check_cqe_coalesce_param(netdev, kernel_coal);
1508	if (ret)
1509		return ret;
1510
1511	ret = hns3_check_gl_coalesce_para(netdev, cmd);
1512	if (ret) {
1513		netdev_err(netdev,
1514			   "Check gl coalesce param fail. ret = %d\n", ret);
1515		return ret;
1516	}
1517
1518	ret = hns3_check_rl_coalesce_para(netdev, cmd);
1519	if (ret) {
1520		netdev_err(netdev,
1521			   "Check rl coalesce param fail. ret = %d\n", ret);
1522		return ret;
1523	}
1524
1525	return hns3_check_ql_coalesce_param(netdev, cmd);
1526}
1527
1528static void hns3_set_coalesce_per_queue(struct net_device *netdev,
1529					struct ethtool_coalesce *cmd,
1530					u32 queue)
1531{
1532	struct hns3_enet_tqp_vector *tx_vector, *rx_vector;
1533	struct hns3_nic_priv *priv = netdev_priv(netdev);
1534	struct hnae3_handle *h = priv->ae_handle;
1535	int queue_num = h->kinfo.num_tqps;
1536
1537	tx_vector = priv->ring[queue].tqp_vector;
1538	rx_vector = priv->ring[queue_num + queue].tqp_vector;
1539
1540	tx_vector->tx_group.coal.adapt_enable =
1541				cmd->use_adaptive_tx_coalesce;
1542	rx_vector->rx_group.coal.adapt_enable =
1543				cmd->use_adaptive_rx_coalesce;
1544
1545	tx_vector->tx_group.coal.int_gl = cmd->tx_coalesce_usecs;
1546	rx_vector->rx_group.coal.int_gl = cmd->rx_coalesce_usecs;
1547
1548	tx_vector->tx_group.coal.int_ql = cmd->tx_max_coalesced_frames;
1549	rx_vector->rx_group.coal.int_ql = cmd->rx_max_coalesced_frames;
1550
1551	hns3_set_vector_coalesce_tx_gl(tx_vector,
1552				       tx_vector->tx_group.coal.int_gl);
1553	hns3_set_vector_coalesce_rx_gl(rx_vector,
1554				       rx_vector->rx_group.coal.int_gl);
1555
1556	hns3_set_vector_coalesce_rl(tx_vector, h->kinfo.int_rl_setting);
1557	hns3_set_vector_coalesce_rl(rx_vector, h->kinfo.int_rl_setting);
1558
1559	if (tx_vector->tx_group.coal.ql_enable)
1560		hns3_set_vector_coalesce_tx_ql(tx_vector,
1561					       tx_vector->tx_group.coal.int_ql);
1562	if (rx_vector->rx_group.coal.ql_enable)
1563		hns3_set_vector_coalesce_rx_ql(rx_vector,
1564					       rx_vector->rx_group.coal.int_ql);
1565}
1566
1567static int hns3_set_coalesce(struct net_device *netdev,
1568			     struct ethtool_coalesce *cmd,
1569			     struct kernel_ethtool_coalesce *kernel_coal,
1570			     struct netlink_ext_ack *extack)
1571{
1572	struct hnae3_handle *h = hns3_get_handle(netdev);
1573	struct hns3_nic_priv *priv = netdev_priv(netdev);
1574	struct hns3_enet_coalesce *tx_coal = &priv->tx_coal;
1575	struct hns3_enet_coalesce *rx_coal = &priv->rx_coal;
1576	u16 queue_num = h->kinfo.num_tqps;
1577	enum dim_cq_period_mode tx_mode;
1578	enum dim_cq_period_mode rx_mode;
1579	int ret;
1580	int i;
1581
1582	if (hns3_nic_resetting(netdev))
1583		return -EBUSY;
1584
1585	ret = hns3_check_coalesce_para(netdev, cmd, kernel_coal);
1586	if (ret)
1587		return ret;
1588
1589	h->kinfo.int_rl_setting =
1590		hns3_rl_round_down(cmd->rx_coalesce_usecs_high);
1591
1592	tx_coal->adapt_enable = cmd->use_adaptive_tx_coalesce;
1593	rx_coal->adapt_enable = cmd->use_adaptive_rx_coalesce;
1594
1595	tx_coal->int_gl = cmd->tx_coalesce_usecs;
1596	rx_coal->int_gl = cmd->rx_coalesce_usecs;
1597
1598	tx_coal->int_ql = cmd->tx_max_coalesced_frames;
1599	rx_coal->int_ql = cmd->rx_max_coalesced_frames;
1600
1601	for (i = 0; i < queue_num; i++)
1602		hns3_set_coalesce_per_queue(netdev, cmd, i);
1603
1604	tx_mode = kernel_coal->use_cqe_mode_tx ?
1605		  DIM_CQ_PERIOD_MODE_START_FROM_CQE :
1606		  DIM_CQ_PERIOD_MODE_START_FROM_EQE;
1607	rx_mode = kernel_coal->use_cqe_mode_rx ?
1608		  DIM_CQ_PERIOD_MODE_START_FROM_CQE :
1609		  DIM_CQ_PERIOD_MODE_START_FROM_EQE;
1610	hns3_cq_period_mode_init(priv, tx_mode, rx_mode);
1611
1612	return 0;
1613}
1614
1615static int hns3_get_regs_len(struct net_device *netdev)
1616{
1617	struct hnae3_handle *h = hns3_get_handle(netdev);
1618
1619	if (!h->ae_algo->ops->get_regs_len)
1620		return -EOPNOTSUPP;
1621
1622	return h->ae_algo->ops->get_regs_len(h);
1623}
1624
1625static void hns3_get_regs(struct net_device *netdev,
1626			  struct ethtool_regs *cmd, void *data)
1627{
1628	struct hnae3_handle *h = hns3_get_handle(netdev);
1629
1630	if (!h->ae_algo->ops->get_regs)
1631		return;
1632
1633	h->ae_algo->ops->get_regs(h, &cmd->version, data);
1634}
1635
1636static int hns3_set_phys_id(struct net_device *netdev,
1637			    enum ethtool_phys_id_state state)
1638{
1639	struct hnae3_handle *h = hns3_get_handle(netdev);
1640
1641	if (!h->ae_algo->ops->set_led_id)
1642		return -EOPNOTSUPP;
1643
1644	return h->ae_algo->ops->set_led_id(h, state);
1645}
1646
1647static u32 hns3_get_msglevel(struct net_device *netdev)
1648{
1649	struct hnae3_handle *h = hns3_get_handle(netdev);
1650
1651	return h->msg_enable;
1652}
1653
1654static void hns3_set_msglevel(struct net_device *netdev, u32 msg_level)
1655{
1656	struct hnae3_handle *h = hns3_get_handle(netdev);
1657
1658	h->msg_enable = msg_level;
1659}
1660
1661static void hns3_get_fec_stats(struct net_device *netdev,
1662			       struct ethtool_fec_stats *fec_stats,
1663			       struct ethtool_fec_hist *hist)
1664{
1665	struct hnae3_handle *handle = hns3_get_handle(netdev);
1666	struct hnae3_ae_dev *ae_dev = hns3_get_ae_dev(handle);
1667	const struct hnae3_ae_ops *ops = hns3_get_ops(handle);
1668
1669	if (!hnae3_ae_dev_fec_stats_supported(ae_dev) || !ops->get_fec_stats)
1670		return;
1671
1672	ops->get_fec_stats(handle, fec_stats);
1673}
1674
1675/* Translate local fec value into ethtool value. */
1676static unsigned int loc_to_eth_fec(u8 loc_fec)
1677{
1678	u32 eth_fec = 0;
1679
1680	if (loc_fec & BIT(HNAE3_FEC_AUTO))
1681		eth_fec |= ETHTOOL_FEC_AUTO;
1682	if (loc_fec & BIT(HNAE3_FEC_RS))
1683		eth_fec |= ETHTOOL_FEC_RS;
1684	if (loc_fec & BIT(HNAE3_FEC_LLRS))
1685		eth_fec |= ETHTOOL_FEC_LLRS;
1686	if (loc_fec & BIT(HNAE3_FEC_BASER))
1687		eth_fec |= ETHTOOL_FEC_BASER;
1688	if (loc_fec & BIT(HNAE3_FEC_NONE))
1689		eth_fec |= ETHTOOL_FEC_OFF;
1690
1691	return eth_fec;
1692}
1693
1694/* Translate ethtool fec value into local value. */
1695static unsigned int eth_to_loc_fec(unsigned int eth_fec)
1696{
1697	u32 loc_fec = 0;
1698
1699	if (eth_fec & ETHTOOL_FEC_OFF)
1700		loc_fec |= BIT(HNAE3_FEC_NONE);
1701	if (eth_fec & ETHTOOL_FEC_AUTO)
1702		loc_fec |= BIT(HNAE3_FEC_AUTO);
1703	if (eth_fec & ETHTOOL_FEC_RS)
1704		loc_fec |= BIT(HNAE3_FEC_RS);
1705	if (eth_fec & ETHTOOL_FEC_LLRS)
1706		loc_fec |= BIT(HNAE3_FEC_LLRS);
1707	if (eth_fec & ETHTOOL_FEC_BASER)
1708		loc_fec |= BIT(HNAE3_FEC_BASER);
1709
1710	return loc_fec;
1711}
1712
1713static int hns3_get_fecparam(struct net_device *netdev,
1714			     struct ethtool_fecparam *fec)
1715{
1716	struct hnae3_handle *handle = hns3_get_handle(netdev);
1717	struct hnae3_ae_dev *ae_dev = hns3_get_ae_dev(handle);
1718	const struct hnae3_ae_ops *ops = hns3_get_ops(handle);
1719	u8 fec_ability;
1720	u8 fec_mode;
1721
1722	if (!test_bit(HNAE3_DEV_SUPPORT_FEC_B, ae_dev->caps))
1723		return -EOPNOTSUPP;
1724
1725	if (!ops->get_fec)
1726		return -EOPNOTSUPP;
1727
1728	ops->get_fec(handle, &fec_ability, &fec_mode);
1729
1730	fec->fec = loc_to_eth_fec(fec_ability);
1731	fec->active_fec = loc_to_eth_fec(fec_mode);
1732	if (!fec->active_fec)
1733		fec->active_fec = ETHTOOL_FEC_OFF;
1734
1735	return 0;
1736}
1737
1738static int hns3_set_fecparam(struct net_device *netdev,
1739			     struct ethtool_fecparam *fec)
1740{
1741	struct hnae3_handle *handle = hns3_get_handle(netdev);
1742	struct hnae3_ae_dev *ae_dev = hns3_get_ae_dev(handle);
1743	const struct hnae3_ae_ops *ops = hns3_get_ops(handle);
1744	u32 fec_mode;
1745
1746	if (!test_bit(HNAE3_DEV_SUPPORT_FEC_B, ae_dev->caps))
1747		return -EOPNOTSUPP;
1748
1749	if (!ops->set_fec)
1750		return -EOPNOTSUPP;
1751	fec_mode = eth_to_loc_fec(fec->fec);
1752
1753	netif_dbg(handle, drv, netdev, "set fecparam: mode=%u\n", fec_mode);
1754
1755	return ops->set_fec(handle, fec_mode);
1756}
1757
1758static int hns3_get_module_info(struct net_device *netdev,
1759				struct ethtool_modinfo *modinfo)
1760{
1761#define HNS3_SFF_8636_V1_3 0x03
1762
1763	struct hnae3_handle *handle = hns3_get_handle(netdev);
1764	struct hnae3_ae_dev *ae_dev = hns3_get_ae_dev(handle);
1765	const struct hnae3_ae_ops *ops = hns3_get_ops(handle);
1766	struct hns3_sfp_type sfp_type;
1767	int ret;
1768
1769	if (ae_dev->dev_version < HNAE3_DEVICE_VERSION_V2 ||
1770	    !ops->get_module_eeprom)
1771		return -EOPNOTSUPP;
1772
1773	memset(&sfp_type, 0, sizeof(sfp_type));
1774	ret = ops->get_module_eeprom(handle, 0, sizeof(sfp_type) / sizeof(u8),
1775				     (u8 *)&sfp_type);
1776	if (ret)
1777		return ret;
1778
1779	switch (sfp_type.type) {
1780	case SFF8024_ID_SFP:
1781		modinfo->type = ETH_MODULE_SFF_8472;
1782		modinfo->eeprom_len = ETH_MODULE_SFF_8472_LEN;
1783		break;
1784	case SFF8024_ID_QSFP_8438:
1785		modinfo->type = ETH_MODULE_SFF_8436;
1786		modinfo->eeprom_len = ETH_MODULE_SFF_8436_MAX_LEN;
1787		break;
1788	case SFF8024_ID_QSFP_8436_8636:
1789		if (sfp_type.ext_type < HNS3_SFF_8636_V1_3) {
1790			modinfo->type = ETH_MODULE_SFF_8436;
1791			modinfo->eeprom_len = ETH_MODULE_SFF_8436_MAX_LEN;
1792		} else {
1793			modinfo->type = ETH_MODULE_SFF_8636;
1794			modinfo->eeprom_len = ETH_MODULE_SFF_8636_MAX_LEN;
1795		}
1796		break;
1797	case SFF8024_ID_QSFP28_8636:
1798		modinfo->type = ETH_MODULE_SFF_8636;
1799		modinfo->eeprom_len = ETH_MODULE_SFF_8636_MAX_LEN;
1800		break;
1801	default:
1802		netdev_err(netdev, "Optical module unknown: %#x\n",
1803			   sfp_type.type);
1804		return -EINVAL;
1805	}
1806
1807	return 0;
1808}
1809
1810static int hns3_get_module_eeprom(struct net_device *netdev,
1811				  struct ethtool_eeprom *ee, u8 *data)
1812{
1813	struct hnae3_handle *handle = hns3_get_handle(netdev);
1814	struct hnae3_ae_dev *ae_dev = hns3_get_ae_dev(handle);
1815	const struct hnae3_ae_ops *ops = hns3_get_ops(handle);
1816
1817	if (ae_dev->dev_version < HNAE3_DEVICE_VERSION_V2 ||
1818	    !ops->get_module_eeprom)
1819		return -EOPNOTSUPP;
1820
1821	if (!ee->len)
1822		return -EINVAL;
1823
1824	memset(data, 0, ee->len);
1825
1826	return ops->get_module_eeprom(handle, ee->offset, ee->len, data);
1827}
1828
1829static u32 hns3_get_priv_flags(struct net_device *netdev)
1830{
1831	struct hnae3_handle *handle = hns3_get_handle(netdev);
1832
1833	return handle->priv_flags;
1834}
1835
1836static int hns3_check_priv_flags(struct hnae3_handle *h, u32 changed)
1837{
1838	u32 i;
1839
1840	for (i = 0; i < HNAE3_PFLAG_MAX; i++)
1841		if ((changed & BIT(i)) && !test_bit(i, &h->supported_pflags)) {
1842			netdev_err(h->netdev, "%s is unsupported\n",
1843				   hns3_priv_flags[i].name);
1844			return -EOPNOTSUPP;
1845		}
1846
1847	return 0;
1848}
1849
1850static int hns3_set_priv_flags(struct net_device *netdev, u32 pflags)
1851{
1852	struct hnae3_handle *handle = hns3_get_handle(netdev);
1853	u32 changed = pflags ^ handle->priv_flags;
1854	int ret;
1855	u32 i;
1856
1857	ret = hns3_check_priv_flags(handle, changed);
1858	if (ret)
1859		return ret;
1860
1861	for (i = 0; i < HNAE3_PFLAG_MAX; i++) {
1862		if (changed & BIT(i)) {
1863			bool enable = !(handle->priv_flags & BIT(i));
1864
1865			if (enable)
1866				handle->priv_flags |= BIT(i);
1867			else
1868				handle->priv_flags &= ~BIT(i);
1869			hns3_priv_flags[i].handler(netdev, enable);
1870		}
1871	}
1872
1873	return 0;
1874}
1875
1876static int hns3_get_tunable(struct net_device *netdev,
1877			    const struct ethtool_tunable *tuna,
1878			    void *data)
1879{
1880	struct hns3_nic_priv *priv = netdev_priv(netdev);
1881	struct hnae3_handle *h = priv->ae_handle;
1882	int ret = 0;
1883
1884	switch (tuna->id) {
1885	case ETHTOOL_TX_COPYBREAK:
1886		/* all the tx rings have the same tx_copybreak */
1887		*(u32 *)data = priv->tx_copybreak;
1888		break;
1889	case ETHTOOL_RX_COPYBREAK:
1890		*(u32 *)data = priv->rx_copybreak;
1891		break;
1892	case ETHTOOL_TX_COPYBREAK_BUF_SIZE:
1893		*(u32 *)data = h->kinfo.tx_spare_buf_size;
1894		break;
1895	default:
1896		ret = -EOPNOTSUPP;
1897		break;
1898	}
1899
1900	return ret;
1901}
1902
1903static int hns3_set_tx_spare_buf_size(struct net_device *netdev,
1904				      u32 data)
1905{
1906	struct hns3_nic_priv *priv = netdev_priv(netdev);
1907	struct hnae3_handle *h = priv->ae_handle;
1908	int ret;
1909
1910	h->kinfo.tx_spare_buf_size = data;
1911
1912	ret = hns3_reset_notify(h, HNAE3_DOWN_CLIENT);
1913	if (ret)
1914		return ret;
1915
1916	ret = hns3_reset_notify(h, HNAE3_UNINIT_CLIENT);
1917	if (ret)
1918		return ret;
1919
1920	ret = hns3_reset_notify(h, HNAE3_INIT_CLIENT);
1921	if (ret)
1922		return ret;
1923
1924	ret = hns3_reset_notify(h, HNAE3_UP_CLIENT);
1925	if (ret)
1926		hns3_reset_notify(h, HNAE3_UNINIT_CLIENT);
1927
1928	return ret;
1929}
1930
1931static int hns3_check_tx_copybreak(struct net_device *netdev, u32 copybreak)
1932{
1933	struct hns3_nic_priv *priv = netdev_priv(netdev);
1934
1935	if (copybreak < priv->min_tx_copybreak) {
1936		netdev_err(netdev, "tx copybreak %u should be no less than %u!\n",
1937			   copybreak, priv->min_tx_copybreak);
1938		return -EINVAL;
1939	}
1940	return 0;
1941}
1942
1943static int hns3_check_tx_spare_buf_size(struct net_device *netdev, u32 buf_size)
1944{
1945	struct hns3_nic_priv *priv = netdev_priv(netdev);
1946
1947	if (buf_size < priv->min_tx_spare_buf_size) {
1948		netdev_err(netdev,
1949			   "tx spare buf size %u should be no less than %u!\n",
1950			   buf_size, priv->min_tx_spare_buf_size);
1951		return -EINVAL;
1952	}
1953	return 0;
1954}
1955
1956static int hns3_set_tunable(struct net_device *netdev,
1957			    const struct ethtool_tunable *tuna,
1958			    const void *data)
1959{
1960	struct hns3_nic_priv *priv = netdev_priv(netdev);
1961	u32 old_tx_spare_buf_size, new_tx_spare_buf_size;
1962	struct hnae3_handle *h = priv->ae_handle;
1963	int i, ret = 0;
1964
1965	if (hns3_nic_resetting(netdev) || !priv->ring) {
1966		netdev_err(netdev, "failed to set tunable value, dev resetting!\n");
1967		return -EBUSY;
1968	}
1969
1970	switch (tuna->id) {
1971	case ETHTOOL_TX_COPYBREAK:
1972		ret = hns3_check_tx_copybreak(netdev, *(u32 *)data);
1973		if (ret)
1974			return ret;
1975
1976		priv->tx_copybreak = *(u32 *)data;
1977
1978		for (i = 0; i < h->kinfo.num_tqps; i++)
1979			priv->ring[i].tx_copybreak = priv->tx_copybreak;
1980
1981		break;
1982	case ETHTOOL_RX_COPYBREAK:
1983		priv->rx_copybreak = *(u32 *)data;
1984
1985		for (i = h->kinfo.num_tqps; i < h->kinfo.num_tqps * 2; i++)
1986			priv->ring[i].rx_copybreak = priv->rx_copybreak;
1987
1988		break;
1989	case ETHTOOL_TX_COPYBREAK_BUF_SIZE:
1990		ret = hns3_check_tx_spare_buf_size(netdev, *(u32 *)data);
1991		if (ret)
1992			return ret;
1993
1994		old_tx_spare_buf_size = h->kinfo.tx_spare_buf_size;
1995		new_tx_spare_buf_size = *(u32 *)data;
1996		netdev_info(netdev, "request to set tx spare buf size from %u to %u\n",
1997			    old_tx_spare_buf_size, new_tx_spare_buf_size);
1998		ret = hns3_set_tx_spare_buf_size(netdev, new_tx_spare_buf_size);
1999		if (ret ||
2000		    (!priv->ring->tx_spare && new_tx_spare_buf_size != 0)) {
2001			int ret1;
2002
2003			netdev_warn(netdev, "change tx spare buf size fail, revert to old value\n");
2004			ret1 = hns3_set_tx_spare_buf_size(netdev,
2005							  old_tx_spare_buf_size);
2006			if (ret1) {
2007				netdev_err(netdev, "revert to old tx spare buf size fail\n");
2008				return ret1;
2009			}
2010
2011			return ret;
2012		}
2013
2014		if (!priv->ring->tx_spare)
2015			netdev_info(netdev, "the active tx spare buf size is 0, disable tx spare buffer\n");
2016		else
2017			netdev_info(netdev, "the active tx spare buf size is %u, due to page order\n",
2018				    priv->ring->tx_spare->len);
2019
2020		break;
2021	default:
2022		ret = -EOPNOTSUPP;
2023		break;
2024	}
2025
2026	return ret;
2027}
2028
2029#define HNS3_ETHTOOL_COALESCE	(ETHTOOL_COALESCE_USECS |		\
2030				 ETHTOOL_COALESCE_USE_ADAPTIVE |	\
2031				 ETHTOOL_COALESCE_RX_USECS_HIGH |	\
2032				 ETHTOOL_COALESCE_TX_USECS_HIGH |	\
2033				 ETHTOOL_COALESCE_MAX_FRAMES |		\
2034				 ETHTOOL_COALESCE_USE_CQE)
2035
2036#define HNS3_ETHTOOL_RING	(ETHTOOL_RING_USE_RX_BUF_LEN |		\
2037				 ETHTOOL_RING_USE_TX_PUSH)
2038
2039static int hns3_get_ts_info(struct net_device *netdev,
2040			    struct kernel_ethtool_ts_info *info)
2041{
2042	struct hnae3_handle *handle = hns3_get_handle(netdev);
2043
2044	if (handle->ae_algo->ops->get_ts_info)
2045		return handle->ae_algo->ops->get_ts_info(handle, info);
2046
2047	return ethtool_op_get_ts_info(netdev, info);
2048}
2049
2050static const struct hns3_ethtool_link_ext_state_mapping
2051hns3_link_ext_state_map[] = {
2052	{1, ETHTOOL_LINK_EXT_STATE_AUTONEG,
2053		ETHTOOL_LINK_EXT_SUBSTATE_AN_NO_HCD},
2054	{2, ETHTOOL_LINK_EXT_STATE_AUTONEG,
2055		ETHTOOL_LINK_EXT_SUBSTATE_AN_ACK_NOT_RECEIVED},
2056
2057	{256, ETHTOOL_LINK_EXT_STATE_LINK_TRAINING_FAILURE,
2058		ETHTOOL_LINK_EXT_SUBSTATE_LT_KR_LINK_INHIBIT_TIMEOUT},
2059	{257, ETHTOOL_LINK_EXT_STATE_LINK_TRAINING_FAILURE,
2060		ETHTOOL_LINK_EXT_SUBSTATE_LT_KR_LINK_PARTNER_DID_NOT_SET_RECEIVER_READY},
2061	{512, ETHTOOL_LINK_EXT_STATE_LINK_TRAINING_FAILURE,
2062		ETHTOOL_LINK_EXT_SUBSTATE_LT_REMOTE_FAULT},
2063
2064	{513, ETHTOOL_LINK_EXT_STATE_LINK_LOGICAL_MISMATCH,
2065		ETHTOOL_LINK_EXT_SUBSTATE_LLM_PCS_DID_NOT_ACQUIRE_BLOCK_LOCK},
2066	{514, ETHTOOL_LINK_EXT_STATE_LINK_LOGICAL_MISMATCH,
2067		ETHTOOL_LINK_EXT_SUBSTATE_LLM_FC_FEC_IS_NOT_LOCKED},
2068	{515, ETHTOOL_LINK_EXT_STATE_LINK_LOGICAL_MISMATCH,
2069		ETHTOOL_LINK_EXT_SUBSTATE_LLM_RS_FEC_IS_NOT_LOCKED},
2070
2071	{768, ETHTOOL_LINK_EXT_STATE_BAD_SIGNAL_INTEGRITY,
2072		ETHTOOL_LINK_EXT_SUBSTATE_BSI_LARGE_NUMBER_OF_PHYSICAL_ERRORS},
2073	{769, ETHTOOL_LINK_EXT_STATE_BAD_SIGNAL_INTEGRITY,
2074		ETHTOOL_LINK_EXT_SUBSTATE_BSI_SERDES_REFERENCE_CLOCK_LOST},
2075	{770, ETHTOOL_LINK_EXT_STATE_BAD_SIGNAL_INTEGRITY,
2076		ETHTOOL_LINK_EXT_SUBSTATE_BSI_SERDES_ALOS},
2077
2078	{1024, ETHTOOL_LINK_EXT_STATE_NO_CABLE, 0},
2079	{1025, ETHTOOL_LINK_EXT_STATE_CABLE_ISSUE,
2080		ETHTOOL_LINK_EXT_SUBSTATE_CI_UNSUPPORTED_CABLE},
2081
2082	{1026, ETHTOOL_LINK_EXT_STATE_EEPROM_ISSUE, 0},
2083};
2084
2085static int hns3_get_link_ext_state(struct net_device *netdev,
2086				   struct ethtool_link_ext_state_info *info)
2087{
2088	const struct hns3_ethtool_link_ext_state_mapping *map;
2089	struct hnae3_handle *h = hns3_get_handle(netdev);
2090	u32 status_code, i;
2091	int ret;
2092
2093	if (netif_carrier_ok(netdev))
2094		return -ENODATA;
2095
2096	if (!h->ae_algo->ops->get_link_diagnosis_info)
2097		return -EOPNOTSUPP;
2098
2099	ret = h->ae_algo->ops->get_link_diagnosis_info(h, &status_code);
2100	if (ret)
2101		return ret;
2102
2103	for (i = 0; i < ARRAY_SIZE(hns3_link_ext_state_map); i++) {
2104		map = &hns3_link_ext_state_map[i];
2105		if (map->status_code == status_code) {
2106			info->link_ext_state = map->link_ext_state;
2107			info->__link_ext_substate = map->link_ext_substate;
2108			return 0;
2109		}
2110	}
2111
2112	return -ENODATA;
2113}
2114
2115static void hns3_get_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)
2116{
2117	struct hnae3_handle *handle = hns3_get_handle(netdev);
2118	const struct hnae3_ae_ops *ops = hns3_get_ops(handle);
2119	struct hnae3_ae_dev *ae_dev = hns3_get_ae_dev(handle);
2120
2121	if (!hnae3_ae_dev_wol_supported(ae_dev))
2122		return;
2123
2124	ops->get_wol(handle, wol);
2125}
2126
2127static int hns3_set_wol(struct net_device *netdev,
2128			struct ethtool_wolinfo *wol)
2129{
2130	struct hnae3_handle *handle = hns3_get_handle(netdev);
2131	const struct hnae3_ae_ops *ops = hns3_get_ops(handle);
2132	struct hnae3_ae_dev *ae_dev = hns3_get_ae_dev(handle);
2133
2134	if (!hnae3_ae_dev_wol_supported(ae_dev))
2135		return -EOPNOTSUPP;
2136
2137	return ops->set_wol(handle, wol);
2138}
2139
2140static const struct ethtool_ops hns3vf_ethtool_ops = {
2141	.supported_coalesce_params = HNS3_ETHTOOL_COALESCE,
2142	.supported_ring_params = HNS3_ETHTOOL_RING,
2143	.get_drvinfo = hns3_get_drvinfo,
2144	.get_ringparam = hns3_get_ringparam,
2145	.set_ringparam = hns3_set_ringparam,
2146	.get_strings = hns3_get_strings,
2147	.get_ethtool_stats = hns3_get_stats,
2148	.get_sset_count = hns3_get_sset_count,
2149	.get_rxnfc = hns3_get_rxnfc,
2150	.set_rxnfc = hns3_set_rxnfc,
2151	.get_rxfh_key_size = hns3_get_rss_key_size,
2152	.get_rxfh_indir_size = hns3_get_rss_indir_size,
2153	.get_rxfh = hns3_get_rss,
2154	.set_rxfh = hns3_set_rss,
2155	.get_rxfh_fields = hns3_get_rxfh_fields,
2156	.set_rxfh_fields = hns3_set_rxfh_fields,
2157	.get_link_ksettings = hns3_get_link_ksettings,
2158	.get_channels = hns3_get_channels,
2159	.set_channels = hns3_set_channels,
2160	.get_coalesce = hns3_get_coalesce,
2161	.set_coalesce = hns3_set_coalesce,
2162	.get_regs_len = hns3_get_regs_len,
2163	.get_regs = hns3_get_regs,
2164	.get_link = hns3_get_link,
2165	.get_msglevel = hns3_get_msglevel,
2166	.set_msglevel = hns3_set_msglevel,
2167	.get_priv_flags = hns3_get_priv_flags,
2168	.set_priv_flags = hns3_set_priv_flags,
2169	.get_tunable = hns3_get_tunable,
2170	.set_tunable = hns3_set_tunable,
2171	.reset = hns3_set_reset,
2172};
2173
2174static const struct ethtool_ops hns3_ethtool_ops = {
2175	.supported_coalesce_params = HNS3_ETHTOOL_COALESCE,
2176	.supported_ring_params = HNS3_ETHTOOL_RING,
2177	.cap_link_lanes_supported = true,
2178	.self_test = hns3_self_test,
2179	.get_drvinfo = hns3_get_drvinfo,
2180	.get_link = hns3_get_link,
2181	.get_ringparam = hns3_get_ringparam,
2182	.set_ringparam = hns3_set_ringparam,
2183	.get_pauseparam = hns3_get_pauseparam,
2184	.set_pauseparam = hns3_set_pauseparam,
2185	.get_strings = hns3_get_strings,
2186	.get_ethtool_stats = hns3_get_stats,
2187	.get_sset_count = hns3_get_sset_count,
2188	.get_rxnfc = hns3_get_rxnfc,
2189	.set_rxnfc = hns3_set_rxnfc,
2190	.get_rxfh_key_size = hns3_get_rss_key_size,
2191	.get_rxfh_indir_size = hns3_get_rss_indir_size,
2192	.get_rxfh = hns3_get_rss,
2193	.set_rxfh = hns3_set_rss,
2194	.get_rxfh_fields = hns3_get_rxfh_fields,
2195	.set_rxfh_fields = hns3_set_rxfh_fields,
2196	.get_link_ksettings = hns3_get_link_ksettings,
2197	.set_link_ksettings = hns3_set_link_ksettings,
2198	.nway_reset = hns3_nway_reset,
2199	.get_channels = hns3_get_channels,
2200	.set_channels = hns3_set_channels,
2201	.get_coalesce = hns3_get_coalesce,
2202	.set_coalesce = hns3_set_coalesce,
2203	.get_regs_len = hns3_get_regs_len,
2204	.get_regs = hns3_get_regs,
2205	.set_phys_id = hns3_set_phys_id,
2206	.get_msglevel = hns3_get_msglevel,
2207	.set_msglevel = hns3_set_msglevel,
2208	.get_fecparam = hns3_get_fecparam,
2209	.set_fecparam = hns3_set_fecparam,
2210	.get_fec_stats = hns3_get_fec_stats,
2211	.get_module_info = hns3_get_module_info,
2212	.get_module_eeprom = hns3_get_module_eeprom,
2213	.get_priv_flags = hns3_get_priv_flags,
2214	.set_priv_flags = hns3_set_priv_flags,
2215	.get_ts_info = hns3_get_ts_info,
2216	.get_tunable = hns3_get_tunable,
2217	.set_tunable = hns3_set_tunable,
2218	.reset = hns3_set_reset,
2219	.get_link_ext_state = hns3_get_link_ext_state,
2220	.get_wol = hns3_get_wol,
2221	.set_wol = hns3_set_wol,
2222};
2223
2224void hns3_ethtool_set_ops(struct net_device *netdev)
2225{
2226	struct hnae3_handle *h = hns3_get_handle(netdev);
2227
2228	if (h->flags & HNAE3_SUPPORT_VF)
2229		netdev->ethtool_ops = &hns3vf_ethtool_ops;
2230	else
2231		netdev->ethtool_ops = &hns3_ethtool_ops;
2232}