drivers/net/ethernet/hisilicon/hns3/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/phy.h>
   7
   8 #include "hns3_enet.h"
   9
  10 struct hns3_stats {
  11         char stats_string[ETH_GSTRING_LEN];
  12         int stats_offset;
  13 };
  14
  15 /* tqp related stats */
  16 #define HNS3_TQP_STAT(_string, _member) {                       \
  17         .stats_string = _string,                                \
  18         .stats_offset = offsetof(struct hns3_enet_ring, stats) +\
  19                         offsetof(struct ring_stats, _member),   \
  20 }
  21
  22 static const struct hns3_stats hns3_txq_stats[] = {
  23         /* Tx per-queue statistics */
  24         HNS3_TQP_STAT("io_err_cnt", io_err_cnt),
  25         HNS3_TQP_STAT("dropped", sw_err_cnt),
  26         HNS3_TQP_STAT("seg_pkt_cnt", seg_pkt_cnt),
  27         HNS3_TQP_STAT("packets", tx_pkts),
  28         HNS3_TQP_STAT("bytes", tx_bytes),
  29         HNS3_TQP_STAT("errors", tx_err_cnt),
  30         HNS3_TQP_STAT("wake", restart_queue),
  31         HNS3_TQP_STAT("busy", tx_busy),
  32 };
  33
  34 #define HNS3_TXQ_STATS_COUNT ARRAY_SIZE(hns3_txq_stats)
  35
  36 static const struct hns3_stats hns3_rxq_stats[] = {
  37         /* Rx per-queue statistics */
  38         HNS3_TQP_STAT("io_err_cnt", io_err_cnt),
  39         HNS3_TQP_STAT("dropped", sw_err_cnt),
  40         HNS3_TQP_STAT("seg_pkt_cnt", seg_pkt_cnt),
  41         HNS3_TQP_STAT("packets", rx_pkts),
  42         HNS3_TQP_STAT("bytes", rx_bytes),
  43         HNS3_TQP_STAT("errors", rx_err_cnt),
  44         HNS3_TQP_STAT("reuse_pg_cnt", reuse_pg_cnt),
  45         HNS3_TQP_STAT("err_pkt_len", err_pkt_len),
  46         HNS3_TQP_STAT("non_vld_descs", non_vld_descs),
  47         HNS3_TQP_STAT("err_bd_num", err_bd_num),
  48         HNS3_TQP_STAT("l2_err", l2_err),
  49         HNS3_TQP_STAT("l3l4_csum_err", l3l4_csum_err),
  50         HNS3_TQP_STAT("multicast", rx_multicast),
  51 };
  52
  53 #define HNS3_RXQ_STATS_COUNT ARRAY_SIZE(hns3_rxq_stats)
  54
  55 #define HNS3_TQP_STATS_COUNT (HNS3_TXQ_STATS_COUNT + HNS3_RXQ_STATS_COUNT)
  56
  57 #define HNS3_SELF_TEST_TYPE_NUM         3
  58 #define HNS3_NIC_LB_TEST_PKT_NUM        1
  59 #define HNS3_NIC_LB_TEST_RING_ID        0
  60 #define HNS3_NIC_LB_TEST_PACKET_SIZE    128
  61
  62 /* Nic loopback test err  */
  63 #define HNS3_NIC_LB_TEST_NO_MEM_ERR     1
  64 #define HNS3_NIC_LB_TEST_TX_CNT_ERR     2
  65 #define HNS3_NIC_LB_TEST_RX_CNT_ERR     3
  66
  67 struct hns3_link_mode_mapping {
  68         u32 hns3_link_mode;
  69         u32 ethtool_link_mode;
  70 };
  71
  72 static int hns3_lp_setup(struct net_device *ndev, enum hnae3_loop loop, bool en)
  73 {
  74         struct hnae3_handle *h = hns3_get_handle(ndev);
  75         bool vlan_filter_enable;
  76         int ret;
  77
  78         if (!h->ae_algo->ops->set_loopback ||
  79             !h->ae_algo->ops->set_promisc_mode)
  80                 return -EOPNOTSUPP;
  81
  82         switch (loop) {
  83         case HNAE3_LOOP_SERIAL_SERDES:
  84         case HNAE3_LOOP_PARALLEL_SERDES:
  85         case HNAE3_LOOP_APP:
  86                 ret = h->ae_algo->ops->set_loopback(h, loop, en);
  87                 break;
  88         default:
  89                 ret = -ENOTSUPP;
  90                 break;
  91         }
  92
  93         if (ret)
  94                 return ret;
  95
  96         if (en) {
  97                 h->ae_algo->ops->set_promisc_mode(h, true, true);
  98         } else {
  99                 /* recover promisc mode before loopback test */
 100                 hns3_update_promisc_mode(ndev, h->netdev_flags);
 101                 vlan_filter_enable = ndev->flags & IFF_PROMISC ? false : true;
 102                 hns3_enable_vlan_filter(ndev, vlan_filter_enable);
 103         }
 104
 105         return ret;
 106 }
 107
 108 static int hns3_lp_up(struct net_device *ndev, enum hnae3_loop loop_mode)
 109 {
 110         struct hnae3_handle *h = hns3_get_handle(ndev);
 111         int ret;
 112
 113         ret = hns3_nic_reset_all_ring(h);
 114         if (ret)
 115                 return ret;
 116
 117         ret = hns3_lp_setup(ndev, loop_mode, true);
 118         usleep_range(10000, 20000);
 119
 120         return ret;
 121 }
 122
 123 static int hns3_lp_down(struct net_device *ndev, enum hnae3_loop loop_mode)
 124 {
 125         int ret;
 126
 127         ret = hns3_lp_setup(ndev, loop_mode, false);
 128         if (ret) {
 129                 netdev_err(ndev, "lb_setup return error: %d\n", ret);
 130                 return ret;
 131         }
 132
 133         usleep_range(10000, 20000);
 134
 135         return 0;
 136 }
 137
 138 static void hns3_lp_setup_skb(struct sk_buff *skb)
 139 {
 140         struct net_device *ndev = skb->dev;
 141         unsigned char *packet;
 142         struct ethhdr *ethh;
 143         unsigned int i;
 144
 145         skb_reserve(skb, NET_IP_ALIGN);
 146         ethh = skb_put(skb, sizeof(struct ethhdr));
 147         packet = skb_put(skb, HNS3_NIC_LB_TEST_PACKET_SIZE);
 148
 149         memcpy(ethh->h_dest, ndev->dev_addr, ETH_ALEN);
 150         ethh->h_dest[5] += 0x1f;
 151         eth_zero_addr(ethh->h_source);
 152         ethh->h_proto = htons(ETH_P_ARP);
 153         skb_reset_mac_header(skb);
 154
 155         for (i = 0; i < HNS3_NIC_LB_TEST_PACKET_SIZE; i++)
 156                 packet[i] = (unsigned char)(i & 0xff);
 157 }
 158
 159 static void hns3_lb_check_skb_data(struct hns3_enet_ring *ring,
 160                                    struct sk_buff *skb)
 161 {
 162         struct hns3_enet_tqp_vector *tqp_vector = ring->tqp_vector;
 163         unsigned char *packet = skb->data;
 164         u32 i;
 165
 166         for (i = 0; i < skb->len; i++)
 167                 if (packet[i] != (unsigned char)(i & 0xff))
 168                         break;
 169
 170         /* The packet is correctly received */
 171         if (i == skb->len)
 172                 tqp_vector->rx_group.total_packets++;
 173         else
 174                 print_hex_dump(KERN_ERR, "selftest:", DUMP_PREFIX_OFFSET, 16, 1,
 175                                skb->data, skb->len, true);
 176
 177         dev_kfree_skb_any(skb);
 178 }
 179
 180 static u32 hns3_lb_check_rx_ring(struct hns3_nic_priv *priv, u32 budget)
 181 {
 182         struct hnae3_handle *h = priv->ae_handle;
 183         struct hnae3_knic_private_info *kinfo;
 184         u32 i, rcv_good_pkt_total = 0;
 185
 186         kinfo = &h->kinfo;
 187         for (i = kinfo->num_tqps; i < kinfo->num_tqps * 2; i++) {
 188                 struct hns3_enet_ring *ring = priv->ring_data[i].ring;
 189                 struct hns3_enet_ring_group *rx_group;
 190                 u64 pre_rx_pkt;
 191
 192                 rx_group = &ring->tqp_vector->rx_group;
 193                 pre_rx_pkt = rx_group->total_packets;
 194
 195                 preempt_disable();
 196                 hns3_clean_rx_ring(ring, budget, hns3_lb_check_skb_data);
 197                 preempt_enable();
 198
 199                 rcv_good_pkt_total += (rx_group->total_packets - pre_rx_pkt);
 200                 rx_group->total_packets = pre_rx_pkt;
 201         }
 202         return rcv_good_pkt_total;
 203 }
 204
 205 static void hns3_lb_clear_tx_ring(struct hns3_nic_priv *priv, u32 start_ringid,
 206                                   u32 end_ringid, u32 budget)
 207 {
 208         u32 i;
 209
 210         for (i = start_ringid; i <= end_ringid; i++) {
 211                 struct hns3_enet_ring *ring = priv->ring_data[i].ring;
 212
 213                 hns3_clean_tx_ring(ring);
 214         }
 215 }
 216
 217 /**
 218  * hns3_lp_run_test -  run loopback test
 219  * @ndev: net device
 220  * @mode: loopback type
 221  */
 222 static int hns3_lp_run_test(struct net_device *ndev, enum hnae3_loop mode)
 223 {
 224         struct hns3_nic_priv *priv = netdev_priv(ndev);
 225         struct sk_buff *skb;
 226         u32 i, good_cnt;
 227         int ret_val = 0;
 228
 229         skb = alloc_skb(HNS3_NIC_LB_TEST_PACKET_SIZE + ETH_HLEN + NET_IP_ALIGN,
 230                         GFP_KERNEL);
 231         if (!skb)
 232                 return HNS3_NIC_LB_TEST_NO_MEM_ERR;
 233
 234         skb->dev = ndev;
 235         hns3_lp_setup_skb(skb);
 236         skb->queue_mapping = HNS3_NIC_LB_TEST_RING_ID;
 237
 238         good_cnt = 0;
 239         for (i = 0; i < HNS3_NIC_LB_TEST_PKT_NUM; i++) {
 240                 netdev_tx_t tx_ret;
 241
 242                 skb_get(skb);
 243                 tx_ret = hns3_nic_net_xmit(skb, ndev);
 244                 if (tx_ret == NETDEV_TX_OK)
 245                         good_cnt++;
 246                 else
 247                         netdev_err(ndev, "hns3_lb_run_test xmit failed: %d\n",
 248                                    tx_ret);
 249         }
 250         if (good_cnt != HNS3_NIC_LB_TEST_PKT_NUM) {
 251                 ret_val = HNS3_NIC_LB_TEST_TX_CNT_ERR;
 252                 netdev_err(ndev, "mode %d sent fail, cnt=0x%x, budget=0x%x\n",
 253                            mode, good_cnt, HNS3_NIC_LB_TEST_PKT_NUM);
 254                 goto out;
 255         }
 256
 257         /* Allow 200 milliseconds for packets to go from Tx to Rx */
 258         msleep(200);
 259
 260         good_cnt = hns3_lb_check_rx_ring(priv, HNS3_NIC_LB_TEST_PKT_NUM);
 261         if (good_cnt != HNS3_NIC_LB_TEST_PKT_NUM) {
 262                 ret_val = HNS3_NIC_LB_TEST_RX_CNT_ERR;
 263                 netdev_err(ndev, "mode %d recv fail, cnt=0x%x, budget=0x%x\n",
 264                            mode, good_cnt, HNS3_NIC_LB_TEST_PKT_NUM);
 265         }
 266
 267 out:
 268         hns3_lb_clear_tx_ring(priv, HNS3_NIC_LB_TEST_RING_ID,
 269                               HNS3_NIC_LB_TEST_RING_ID,
 270                               HNS3_NIC_LB_TEST_PKT_NUM);
 271
 272         kfree_skb(skb);
 273         return ret_val;
 274 }
 275
 276 /**
 277  * hns3_nic_self_test - self test
 278  * @ndev: net device
 279  * @eth_test: test cmd
 280  * @data: test result
 281  */
 282 static void hns3_self_test(struct net_device *ndev,
 283                            struct ethtool_test *eth_test, u64 *data)
 284 {
 285         struct hns3_nic_priv *priv = netdev_priv(ndev);
 286         struct hnae3_handle *h = priv->ae_handle;
 287         int st_param[HNS3_SELF_TEST_TYPE_NUM][2];
 288         bool if_running = netif_running(ndev);
 289 #if IS_ENABLED(CONFIG_VLAN_8021Q)
 290         bool dis_vlan_filter;
 291 #endif
 292         int test_index = 0;
 293         u32 i;
 294
 295         if (hns3_nic_resetting(ndev)) {
 296                 netdev_err(ndev, "dev resetting!");
 297                 return;
 298         }
 299
 300         /* Only do offline selftest, or pass by default */
 301         if (eth_test->flags != ETH_TEST_FL_OFFLINE)
 302                 return;
 303
 304         st_param[HNAE3_LOOP_APP][0] = HNAE3_LOOP_APP;
 305         st_param[HNAE3_LOOP_APP][1] =
 306                         h->flags & HNAE3_SUPPORT_APP_LOOPBACK;
 307
 308         st_param[HNAE3_LOOP_SERIAL_SERDES][0] = HNAE3_LOOP_SERIAL_SERDES;
 309         st_param[HNAE3_LOOP_SERIAL_SERDES][1] =
 310                         h->flags & HNAE3_SUPPORT_SERDES_SERIAL_LOOPBACK;
 311
 312         st_param[HNAE3_LOOP_PARALLEL_SERDES][0] =
 313                         HNAE3_LOOP_PARALLEL_SERDES;
 314         st_param[HNAE3_LOOP_PARALLEL_SERDES][1] =
 315                         h->flags & HNAE3_SUPPORT_SERDES_PARALLEL_LOOPBACK;
 316
 317         if (if_running)
 318                 ndev->netdev_ops->ndo_stop(ndev);
 319
 320 #if IS_ENABLED(CONFIG_VLAN_8021Q)
 321         /* Disable the vlan filter for selftest does not support it */
 322         dis_vlan_filter = (ndev->features & NETIF_F_HW_VLAN_CTAG_FILTER) &&
 323                                 h->ae_algo->ops->enable_vlan_filter;
 324         if (dis_vlan_filter)
 325                 h->ae_algo->ops->enable_vlan_filter(h, false);
 326 #endif
 327
 328         set_bit(HNS3_NIC_STATE_TESTING, &priv->state);
 329
 330         for (i = 0; i < HNS3_SELF_TEST_TYPE_NUM; i++) {
 331                 enum hnae3_loop loop_type = (enum hnae3_loop)st_param[i][0];
 332
 333                 if (!st_param[i][1])
 334                         continue;
 335
 336                 data[test_index] = hns3_lp_up(ndev, loop_type);
 337                 if (!data[test_index])
 338                         data[test_index] = hns3_lp_run_test(ndev, loop_type);
 339
 340                 hns3_lp_down(ndev, loop_type);
 341
 342                 if (data[test_index])
 343                         eth_test->flags |= ETH_TEST_FL_FAILED;
 344
 345                 test_index++;
 346         }
 347
 348         clear_bit(HNS3_NIC_STATE_TESTING, &priv->state);
 349
 350 #if IS_ENABLED(CONFIG_VLAN_8021Q)
 351         if (dis_vlan_filter)
 352                 h->ae_algo->ops->enable_vlan_filter(h, true);
 353 #endif
 354
 355         if (if_running)
 356                 ndev->netdev_ops->ndo_open(ndev);
 357 }
 358
 359 static int hns3_get_sset_count(struct net_device *netdev, int stringset)
 360 {
 361         struct hnae3_handle *h = hns3_get_handle(netdev);
 362         const struct hnae3_ae_ops *ops = h->ae_algo->ops;
 363
 364         if (!ops->get_sset_count)
 365                 return -EOPNOTSUPP;
 366
 367         switch (stringset) {
 368         case ETH_SS_STATS:
 369                 return ((HNS3_TQP_STATS_COUNT * h->kinfo.num_tqps) +
 370                         ops->get_sset_count(h, stringset));
 371
 372         case ETH_SS_TEST:
 373                 return ops->get_sset_count(h, stringset);
 374
 375         default:
 376                 return -EOPNOTSUPP;
 377         }
 378 }
 379
 380 static void *hns3_update_strings(u8 *data, const struct hns3_stats *stats,
 381                 u32 stat_count, u32 num_tqps, const char *prefix)
 382 {
 383 #define MAX_PREFIX_SIZE (6 + 4)
 384         u32 size_left;
 385         u32 i, j;
 386         u32 n1;
 387
 388         for (i = 0; i < num_tqps; i++) {
 389                 for (j = 0; j < stat_count; j++) {
 390                         data[ETH_GSTRING_LEN - 1] = '\0';
 391
 392                         /* first, prepend the prefix string */
 393                         n1 = snprintf(data, MAX_PREFIX_SIZE, "%s%d_",
 394                                       prefix, i);
 395                         n1 = min_t(uint, n1, MAX_PREFIX_SIZE - 1);
 396                         size_left = (ETH_GSTRING_LEN - 1) - n1;
 397
 398                         /* now, concatenate the stats string to it */
 399                         strncat(data, stats[j].stats_string, size_left);
 400                         data += ETH_GSTRING_LEN;
 401                 }
 402         }
 403
 404         return data;
 405 }
 406
 407 static u8 *hns3_get_strings_tqps(struct hnae3_handle *handle, u8 *data)
 408 {
 409         struct hnae3_knic_private_info *kinfo = &handle->kinfo;
 410         const char tx_prefix[] = "txq";
 411         const char rx_prefix[] = "rxq";
 412
 413         /* get strings for Tx */
 414         data = hns3_update_strings(data, hns3_txq_stats, HNS3_TXQ_STATS_COUNT,
 415                                    kinfo->num_tqps, tx_prefix);
 416
 417         /* get strings for Rx */
 418         data = hns3_update_strings(data, hns3_rxq_stats, HNS3_RXQ_STATS_COUNT,
 419                                    kinfo->num_tqps, rx_prefix);
 420
 421         return data;
 422 }
 423
 424 static void hns3_get_strings(struct net_device *netdev, u32 stringset, u8 *data)
 425 {
 426         struct hnae3_handle *h = hns3_get_handle(netdev);
 427         const struct hnae3_ae_ops *ops = h->ae_algo->ops;
 428         char *buff = (char *)data;
 429
 430         if (!ops->get_strings)
 431                 return;
 432
 433         switch (stringset) {
 434         case ETH_SS_STATS:
 435                 buff = hns3_get_strings_tqps(h, buff);
 436                 h->ae_algo->ops->get_strings(h, stringset, (u8 *)buff);
 437                 break;
 438         case ETH_SS_TEST:
 439                 ops->get_strings(h, stringset, data);
 440                 break;
 441         default:
 442                 break;
 443         }
 444 }
 445
 446 static u64 *hns3_get_stats_tqps(struct hnae3_handle *handle, u64 *data)
 447 {
 448         struct hns3_nic_priv *nic_priv = (struct hns3_nic_priv *)handle->priv;
 449         struct hnae3_knic_private_info *kinfo = &handle->kinfo;
 450         struct hns3_enet_ring *ring;
 451         u8 *stat;
 452         int i, j;
 453
 454         /* get stats for Tx */
 455         for (i = 0; i < kinfo->num_tqps; i++) {
 456                 ring = nic_priv->ring_data[i].ring;
 457                 for (j = 0; j < HNS3_TXQ_STATS_COUNT; j++) {
 458                         stat = (u8 *)ring + hns3_txq_stats[j].stats_offset;
 459                         *data++ = *(u64 *)stat;
 460                 }
 461         }
 462
 463         /* get stats for Rx */
 464         for (i = 0; i < kinfo->num_tqps; i++) {
 465                 ring = nic_priv->ring_data[i + kinfo->num_tqps].ring;
 466                 for (j = 0; j < HNS3_RXQ_STATS_COUNT; j++) {
 467                         stat = (u8 *)ring + hns3_rxq_stats[j].stats_offset;
 468                         *data++ = *(u64 *)stat;
 469                 }
 470         }
 471
 472         return data;
 473 }
 474
 475 /* hns3_get_stats - get detail statistics.
 476  * @netdev: net device
 477  * @stats: statistics info.
 478  * @data: statistics data.
 479  */
 480 static void hns3_get_stats(struct net_device *netdev,
 481                            struct ethtool_stats *stats, u64 *data)
 482 {
 483         struct hnae3_handle *h = hns3_get_handle(netdev);
 484         u64 *p = data;
 485
 486         if (hns3_nic_resetting(netdev)) {
 487                 netdev_err(netdev, "dev resetting, could not get stats\n");
 488                 return;
 489         }
 490
 491         if (!h->ae_algo->ops->get_stats || !h->ae_algo->ops->update_stats) {
 492                 netdev_err(netdev, "could not get any statistics\n");
 493                 return;
 494         }
 495
 496         h->ae_algo->ops->update_stats(h, &netdev->stats);
 497
 498         /* get per-queue stats */
 499         p = hns3_get_stats_tqps(h, p);
 500
 501         /* get MAC & other misc hardware stats */
 502         h->ae_algo->ops->get_stats(h, p);
 503 }
 504
 505 static void hns3_get_drvinfo(struct net_device *netdev,
 506                              struct ethtool_drvinfo *drvinfo)
 507 {
 508         struct hns3_nic_priv *priv = netdev_priv(netdev);
 509         struct hnae3_handle *h = priv->ae_handle;
 510
 511         strncpy(drvinfo->version, hns3_driver_version,
 512                 sizeof(drvinfo->version));
 513         drvinfo->version[sizeof(drvinfo->version) - 1] = '\0';
 514
 515         strncpy(drvinfo->driver, h->pdev->driver->name,
 516                 sizeof(drvinfo->driver));
 517         drvinfo->driver[sizeof(drvinfo->driver) - 1] = '\0';
 518
 519         strncpy(drvinfo->bus_info, pci_name(h->pdev),
 520                 sizeof(drvinfo->bus_info));
 521         drvinfo->bus_info[ETHTOOL_BUSINFO_LEN - 1] = '\0';
 522
 523         snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version), "0x%08x",
 524                  priv->ae_handle->ae_algo->ops->get_fw_version(h));
 525 }
 526
 527 static u32 hns3_get_link(struct net_device *netdev)
 528 {
 529         struct hnae3_handle *h = hns3_get_handle(netdev);
 530
 531         if (h->ae_algo && h->ae_algo->ops && h->ae_algo->ops->get_status)
 532                 return h->ae_algo->ops->get_status(h);
 533         else
 534                 return 0;
 535 }
 536
 537 static void hns3_get_ringparam(struct net_device *netdev,
 538                                struct ethtool_ringparam *param)
 539 {
 540         struct hns3_nic_priv *priv = netdev_priv(netdev);
 541         struct hnae3_handle *h = priv->ae_handle;
 542         int queue_num = h->kinfo.num_tqps;
 543
 544         if (hns3_nic_resetting(netdev)) {
 545                 netdev_err(netdev, "dev resetting!");
 546                 return;
 547         }
 548
 549         param->tx_max_pending = HNS3_RING_MAX_PENDING;
 550         param->rx_max_pending = HNS3_RING_MAX_PENDING;
 551
 552         param->tx_pending = priv->ring_data[0].ring->desc_num;
 553         param->rx_pending = priv->ring_data[queue_num].ring->desc_num;
 554 }
 555
 556 static void hns3_get_pauseparam(struct net_device *netdev,
 557                                 struct ethtool_pauseparam *param)
 558 {
 559         struct hnae3_handle *h = hns3_get_handle(netdev);
 560
 561         if (h->ae_algo && h->ae_algo->ops && h->ae_algo->ops->get_pauseparam)
 562                 h->ae_algo->ops->get_pauseparam(h, &param->autoneg,
 563                         &param->rx_pause, &param->tx_pause);
 564 }
 565
 566 static int hns3_set_pauseparam(struct net_device *netdev,
 567                                struct ethtool_pauseparam *param)
 568 {
 569         struct hnae3_handle *h = hns3_get_handle(netdev);
 570
 571         if (h->ae_algo->ops->set_pauseparam)
 572                 return h->ae_algo->ops->set_pauseparam(h, param->autoneg,
 573                                                        param->rx_pause,
 574                                                        param->tx_pause);
 575         return -EOPNOTSUPP;
 576 }
 577
 578 static void hns3_get_ksettings(struct hnae3_handle *h,
 579                                struct ethtool_link_ksettings *cmd)
 580 {
 581         const struct hnae3_ae_ops *ops = h->ae_algo->ops;
 582
 583         /* 1.auto_neg & speed & duplex from cmd */
 584         if (ops->get_ksettings_an_result)
 585                 ops->get_ksettings_an_result(h,
 586                                              &cmd->base.autoneg,
 587                                              &cmd->base.speed,
 588                                              &cmd->base.duplex);
 589
 590         /* 2.get link mode*/
 591         if (ops->get_link_mode)
 592                 ops->get_link_mode(h,
 593                                    cmd->link_modes.supported,
 594                                    cmd->link_modes.advertising);
 595
 596         /* 3.mdix_ctrl&mdix get from phy reg */
 597         if (ops->get_mdix_mode)
 598                 ops->get_mdix_mode(h, &cmd->base.eth_tp_mdix_ctrl,
 599                                    &cmd->base.eth_tp_mdix);
 600 }
 601
 602 static int hns3_get_link_ksettings(struct net_device *netdev,
 603                                    struct ethtool_link_ksettings *cmd)
 604 {
 605         struct hnae3_handle *h = hns3_get_handle(netdev);
 606         const struct hnae3_ae_ops *ops;
 607         u8 media_type;
 608         u8 link_stat;
 609
 610         if (!h->ae_algo || !h->ae_algo->ops)
 611                 return -EOPNOTSUPP;
 612
 613         ops = h->ae_algo->ops;
 614         if (ops->get_media_type)
 615                 ops->get_media_type(h, &media_type);
 616         else
 617                 return -EOPNOTSUPP;
 618
 619         switch (media_type) {
 620         case HNAE3_MEDIA_TYPE_NONE:
 621                 cmd->base.port = PORT_NONE;
 622                 hns3_get_ksettings(h, cmd);
 623                 break;
 624         case HNAE3_MEDIA_TYPE_FIBER:
 625                 cmd->base.port = PORT_FIBRE;
 626                 hns3_get_ksettings(h, cmd);
 627                 break;
 628         case HNAE3_MEDIA_TYPE_COPPER:
 629                 cmd->base.port = PORT_TP;
 630                 if (!netdev->phydev)
 631                         hns3_get_ksettings(h, cmd);
 632                 else
 633                         phy_ethtool_ksettings_get(netdev->phydev, cmd);
 634                 break;
 635         default:
 636
 637                 netdev_warn(netdev, "Unknown media type");
 638                 return 0;
 639         }
 640
 641         /* mdio_support */
 642         cmd->base.mdio_support = ETH_MDIO_SUPPORTS_C22;
 643
 644         link_stat = hns3_get_link(netdev);
 645         if (!link_stat) {
 646                 cmd->base.speed = SPEED_UNKNOWN;
 647                 cmd->base.duplex = DUPLEX_UNKNOWN;
 648         }
 649
 650         return 0;
 651 }
 652
 653 static int hns3_set_link_ksettings(struct net_device *netdev,
 654                                    const struct ethtool_link_ksettings *cmd)
 655 {
 656         /* Chip doesn't support this mode. */
 657         if (cmd->base.speed == SPEED_1000 && cmd->base.duplex == DUPLEX_HALF)
 658                 return -EINVAL;
 659
 660         /* Only support ksettings_set for netdev with phy attached for now */
 661         if (netdev->phydev)
 662                 return phy_ethtool_ksettings_set(netdev->phydev, cmd);
 663
 664         return -EOPNOTSUPP;
 665 }
 666
 667 static u32 hns3_get_rss_key_size(struct net_device *netdev)
 668 {
 669         struct hnae3_handle *h = hns3_get_handle(netdev);
 670
 671         if (!h->ae_algo || !h->ae_algo->ops ||
 672             !h->ae_algo->ops->get_rss_key_size)
 673                 return 0;
 674
 675         return h->ae_algo->ops->get_rss_key_size(h);
 676 }
 677
 678 static u32 hns3_get_rss_indir_size(struct net_device *netdev)
 679 {
 680         struct hnae3_handle *h = hns3_get_handle(netdev);
 681
 682         if (!h->ae_algo || !h->ae_algo->ops ||
 683             !h->ae_algo->ops->get_rss_indir_size)
 684                 return 0;
 685
 686         return h->ae_algo->ops->get_rss_indir_size(h);
 687 }
 688
 689 static int hns3_get_rss(struct net_device *netdev, u32 *indir, u8 *key,
 690                         u8 *hfunc)
 691 {
 692         struct hnae3_handle *h = hns3_get_handle(netdev);
 693
 694         if (!h->ae_algo || !h->ae_algo->ops || !h->ae_algo->ops->get_rss)
 695                 return -EOPNOTSUPP;
 696
 697         return h->ae_algo->ops->get_rss(h, indir, key, hfunc);
 698 }
 699
 700 static int hns3_set_rss(struct net_device *netdev, const u32 *indir,
 701                         const u8 *key, const u8 hfunc)
 702 {
 703         struct hnae3_handle *h = hns3_get_handle(netdev);
 704
 705         if (!h->ae_algo || !h->ae_algo->ops || !h->ae_algo->ops->set_rss)
 706                 return -EOPNOTSUPP;
 707
 708         if ((h->pdev->revision == 0x20 &&
 709              hfunc != ETH_RSS_HASH_TOP) || (hfunc != ETH_RSS_HASH_NO_CHANGE &&
 710              hfunc != ETH_RSS_HASH_TOP && hfunc != ETH_RSS_HASH_XOR)) {
 711                 netdev_err(netdev, "hash func not supported\n");
 712                 return -EOPNOTSUPP;
 713         }
 714
 715         if (!indir) {
 716                 netdev_err(netdev,
 717                            "set rss failed for indir is empty\n");
 718                 return -EOPNOTSUPP;
 719         }
 720
 721         return h->ae_algo->ops->set_rss(h, indir, key, hfunc);
 722 }
 723
 724 static int hns3_get_rxnfc(struct net_device *netdev,
 725                           struct ethtool_rxnfc *cmd,
 726                           u32 *rule_locs)
 727 {
 728         struct hnae3_handle *h = hns3_get_handle(netdev);
 729
 730         if (!h->ae_algo || !h->ae_algo->ops)
 731                 return -EOPNOTSUPP;
 732
 733         switch (cmd->cmd) {
 734         case ETHTOOL_GRXRINGS:
 735                 cmd->data = h->kinfo.num_tqps;
 736                 return 0;
 737         case ETHTOOL_GRXFH:
 738                 if (h->ae_algo->ops->get_rss_tuple)
 739                         return h->ae_algo->ops->get_rss_tuple(h, cmd);
 740                 return -EOPNOTSUPP;
 741         case ETHTOOL_GRXCLSRLCNT:
 742                 if (h->ae_algo->ops->get_fd_rule_cnt)
 743                         return h->ae_algo->ops->get_fd_rule_cnt(h, cmd);
 744                 return -EOPNOTSUPP;
 745         case ETHTOOL_GRXCLSRULE:
 746                 if (h->ae_algo->ops->get_fd_rule_info)
 747                         return h->ae_algo->ops->get_fd_rule_info(h, cmd);
 748                 return -EOPNOTSUPP;
 749         case ETHTOOL_GRXCLSRLALL:
 750                 if (h->ae_algo->ops->get_fd_all_rules)
 751                         return h->ae_algo->ops->get_fd_all_rules(h, cmd,
 752                                                                  rule_locs);
 753                 return -EOPNOTSUPP;
 754         default:
 755                 return -EOPNOTSUPP;
 756         }
 757 }
 758
 759 static int hns3_change_all_ring_bd_num(struct hns3_nic_priv *priv,
 760                                        u32 tx_desc_num, u32 rx_desc_num)
 761 {
 762         struct hnae3_handle *h = priv->ae_handle;
 763         int i;
 764
 765         h->kinfo.num_tx_desc = tx_desc_num;
 766         h->kinfo.num_rx_desc = rx_desc_num;
 767
 768         for (i = 0; i < h->kinfo.num_tqps; i++) {
 769                 priv->ring_data[i].ring->desc_num = tx_desc_num;
 770                 priv->ring_data[i + h->kinfo.num_tqps].ring->desc_num =
 771                         rx_desc_num;
 772         }
 773
 774         return hns3_init_all_ring(priv);
 775 }
 776
 777 static int hns3_set_ringparam(struct net_device *ndev,
 778                               struct ethtool_ringparam *param)
 779 {
 780         struct hns3_nic_priv *priv = netdev_priv(ndev);
 781         struct hnae3_handle *h = priv->ae_handle;
 782         bool if_running = netif_running(ndev);
 783         u32 old_tx_desc_num, new_tx_desc_num;
 784         u32 old_rx_desc_num, new_rx_desc_num;
 785         int queue_num = h->kinfo.num_tqps;
 786         int ret;
 787
 788         if (hns3_nic_resetting(ndev))
 789                 return -EBUSY;
 790
 791         if (param->rx_mini_pending || param->rx_jumbo_pending)
 792                 return -EINVAL;
 793
 794         if (param->tx_pending > HNS3_RING_MAX_PENDING ||
 795             param->tx_pending < HNS3_RING_MIN_PENDING ||
 796             param->rx_pending > HNS3_RING_MAX_PENDING ||
 797             param->rx_pending < HNS3_RING_MIN_PENDING) {
 798                 netdev_err(ndev, "Queue depth out of range [%d-%d]\n",
 799                            HNS3_RING_MIN_PENDING, HNS3_RING_MAX_PENDING);
 800                 return -EINVAL;
 801         }
 802
 803         /* Hardware requires that its descriptors must be multiple of eight */
 804         new_tx_desc_num = ALIGN(param->tx_pending, HNS3_RING_BD_MULTIPLE);
 805         new_rx_desc_num = ALIGN(param->rx_pending, HNS3_RING_BD_MULTIPLE);
 806         old_tx_desc_num = priv->ring_data[0].ring->desc_num;
 807         old_rx_desc_num = priv->ring_data[queue_num].ring->desc_num;
 808         if (old_tx_desc_num == new_tx_desc_num &&
 809             old_rx_desc_num == new_rx_desc_num)
 810                 return 0;
 811
 812         netdev_info(ndev,
 813                     "Changing Tx/Rx ring depth from %d/%d to %d/%d\n",
 814                     old_tx_desc_num, old_rx_desc_num,
 815                     new_tx_desc_num, new_rx_desc_num);
 816
 817         if (if_running)
 818                 ndev->netdev_ops->ndo_stop(ndev);
 819
 820         ret = hns3_uninit_all_ring(priv);
 821         if (ret)
 822                 return ret;
 823
 824         ret = hns3_change_all_ring_bd_num(priv, new_tx_desc_num,
 825                                           new_rx_desc_num);
 826         if (ret) {
 827                 ret = hns3_change_all_ring_bd_num(priv, old_tx_desc_num,
 828                                                   old_rx_desc_num);
 829                 if (ret) {
 830                         netdev_err(ndev,
 831                                    "Revert to old bd num fail, ret=%d.\n", ret);
 832                         return ret;
 833                 }
 834         }
 835
 836         if (if_running)
 837                 ret = ndev->netdev_ops->ndo_open(ndev);
 838
 839         return ret;
 840 }
 841
 842 static int hns3_set_rxnfc(struct net_device *netdev, struct ethtool_rxnfc *cmd)
 843 {
 844         struct hnae3_handle *h = hns3_get_handle(netdev);
 845
 846         if (!h->ae_algo || !h->ae_algo->ops)
 847                 return -EOPNOTSUPP;
 848
 849         switch (cmd->cmd) {
 850         case ETHTOOL_SRXFH:
 851                 if (h->ae_algo->ops->set_rss_tuple)
 852                         return h->ae_algo->ops->set_rss_tuple(h, cmd);
 853                 return -EOPNOTSUPP;
 854         case ETHTOOL_SRXCLSRLINS:
 855                 if (h->ae_algo->ops->add_fd_entry)
 856                         return h->ae_algo->ops->add_fd_entry(h, cmd);
 857                 return -EOPNOTSUPP;
 858         case ETHTOOL_SRXCLSRLDEL:
 859                 if (h->ae_algo->ops->del_fd_entry)
 860                         return h->ae_algo->ops->del_fd_entry(h, cmd);
 861                 return -EOPNOTSUPP;
 862         default:
 863                 return -EOPNOTSUPP;
 864         }
 865 }
 866
 867 static int hns3_nway_reset(struct net_device *netdev)
 868 {
 869         struct phy_device *phy = netdev->phydev;
 870
 871         if (!netif_running(netdev))
 872                 return 0;
 873
 874         /* Only support nway_reset for netdev with phy attached for now */
 875         if (!phy)
 876                 return -EOPNOTSUPP;
 877
 878         if (phy->autoneg != AUTONEG_ENABLE)
 879                 return -EINVAL;
 880
 881         return genphy_restart_aneg(phy);
 882 }
 883
 884 static void hns3_get_channels(struct net_device *netdev,
 885                               struct ethtool_channels *ch)
 886 {
 887         struct hnae3_handle *h = hns3_get_handle(netdev);
 888
 889         if (h->ae_algo->ops->get_channels)
 890                 h->ae_algo->ops->get_channels(h, ch);
 891 }
 892
 893 static int hns3_get_coalesce_per_queue(struct net_device *netdev, u32 queue,
 894                                        struct ethtool_coalesce *cmd)
 895 {
 896         struct hns3_enet_tqp_vector *tx_vector, *rx_vector;
 897         struct hns3_nic_priv *priv = netdev_priv(netdev);
 898         struct hnae3_handle *h = priv->ae_handle;
 899         u16 queue_num = h->kinfo.num_tqps;
 900
 901         if (hns3_nic_resetting(netdev))
 902                 return -EBUSY;
 903
 904         if (queue >= queue_num) {
 905                 netdev_err(netdev,
 906                            "Invalid queue value %d! Queue max id=%d\n",
 907                            queue, queue_num - 1);
 908                 return -EINVAL;
 909         }
 910
 911         tx_vector = priv->ring_data[queue].ring->tqp_vector;
 912         rx_vector = priv->ring_data[queue_num + queue].ring->tqp_vector;
 913
 914         cmd->use_adaptive_tx_coalesce =
 915                         tx_vector->tx_group.coal.gl_adapt_enable;
 916         cmd->use_adaptive_rx_coalesce =
 917                         rx_vector->rx_group.coal.gl_adapt_enable;
 918
 919         cmd->tx_coalesce_usecs = tx_vector->tx_group.coal.int_gl;
 920         cmd->rx_coalesce_usecs = rx_vector->rx_group.coal.int_gl;
 921
 922         cmd->tx_coalesce_usecs_high = h->kinfo.int_rl_setting;
 923         cmd->rx_coalesce_usecs_high = h->kinfo.int_rl_setting;
 924
 925         return 0;
 926 }
 927
 928 static int hns3_get_coalesce(struct net_device *netdev,
 929                              struct ethtool_coalesce *cmd)
 930 {
 931         return hns3_get_coalesce_per_queue(netdev, 0, cmd);
 932 }
 933
 934 static int hns3_check_gl_coalesce_para(struct net_device *netdev,
 935                                        struct ethtool_coalesce *cmd)
 936 {
 937         u32 rx_gl, tx_gl;
 938
 939         if (cmd->rx_coalesce_usecs > HNS3_INT_GL_MAX) {
 940                 netdev_err(netdev,
 941                            "Invalid rx-usecs value, rx-usecs range is 0-%d\n",
 942                            HNS3_INT_GL_MAX);
 943                 return -EINVAL;
 944         }
 945
 946         if (cmd->tx_coalesce_usecs > HNS3_INT_GL_MAX) {
 947                 netdev_err(netdev,
 948                            "Invalid tx-usecs value, tx-usecs range is 0-%d\n",
 949                            HNS3_INT_GL_MAX);
 950                 return -EINVAL;
 951         }
 952
 953         rx_gl = hns3_gl_round_down(cmd->rx_coalesce_usecs);
 954         if (rx_gl != cmd->rx_coalesce_usecs) {
 955                 netdev_info(netdev,
 956                             "rx_usecs(%d) rounded down to %d, because it must be multiple of 2.\n",
 957                             cmd->rx_coalesce_usecs, rx_gl);
 958         }
 959
 960         tx_gl = hns3_gl_round_down(cmd->tx_coalesce_usecs);
 961         if (tx_gl != cmd->tx_coalesce_usecs) {
 962                 netdev_info(netdev,
 963                             "tx_usecs(%d) rounded down to %d, because it must be multiple of 2.\n",
 964                             cmd->tx_coalesce_usecs, tx_gl);
 965         }
 966
 967         return 0;
 968 }
 969
 970 static int hns3_check_rl_coalesce_para(struct net_device *netdev,
 971                                        struct ethtool_coalesce *cmd)
 972 {
 973         u32 rl;
 974
 975         if (cmd->tx_coalesce_usecs_high != cmd->rx_coalesce_usecs_high) {
 976                 netdev_err(netdev,
 977                            "tx_usecs_high must be same as rx_usecs_high.\n");
 978                 return -EINVAL;
 979         }
 980
 981         if (cmd->rx_coalesce_usecs_high > HNS3_INT_RL_MAX) {
 982                 netdev_err(netdev,
 983                            "Invalid usecs_high value, usecs_high range is 0-%d\n",
 984                            HNS3_INT_RL_MAX);
 985                 return -EINVAL;
 986         }
 987
 988         rl = hns3_rl_round_down(cmd->rx_coalesce_usecs_high);
 989         if (rl != cmd->rx_coalesce_usecs_high) {
 990                 netdev_info(netdev,
 991                             "usecs_high(%d) rounded down to %d, because it must be multiple of 4.\n",
 992                             cmd->rx_coalesce_usecs_high, rl);
 993         }
 994
 995         return 0;
 996 }
 997
 998 static int hns3_check_coalesce_para(struct net_device *netdev,
 999                                     struct ethtool_coalesce *cmd)
1000 {
1001         int ret;
1002
1003         ret = hns3_check_gl_coalesce_para(netdev, cmd);
1004         if (ret) {
1005                 netdev_err(netdev,
1006                            "Check gl coalesce param fail. ret = %d\n", ret);
1007                 return ret;
1008         }
1009
1010         ret = hns3_check_rl_coalesce_para(netdev, cmd);
1011         if (ret) {
1012                 netdev_err(netdev,
1013                            "Check rl coalesce param fail. ret = %d\n", ret);
1014                 return ret;
1015         }
1016
1017         if (cmd->use_adaptive_tx_coalesce == 1 ||
1018             cmd->use_adaptive_rx_coalesce == 1) {
1019                 netdev_info(netdev,
1020                             "adaptive-tx=%d and adaptive-rx=%d, tx_usecs or rx_usecs will changed dynamically.\n",
1021                             cmd->use_adaptive_tx_coalesce,
1022                             cmd->use_adaptive_rx_coalesce);
1023         }
1024
1025         return 0;
1026 }
1027
1028 static void hns3_set_coalesce_per_queue(struct net_device *netdev,
1029                                         struct ethtool_coalesce *cmd,
1030                                         u32 queue)
1031 {
1032         struct hns3_enet_tqp_vector *tx_vector, *rx_vector;
1033         struct hns3_nic_priv *priv = netdev_priv(netdev);
1034         struct hnae3_handle *h = priv->ae_handle;
1035         int queue_num = h->kinfo.num_tqps;
1036
1037         tx_vector = priv->ring_data[queue].ring->tqp_vector;
1038         rx_vector = priv->ring_data[queue_num + queue].ring->tqp_vector;
1039
1040         tx_vector->tx_group.coal.gl_adapt_enable =
1041                                 cmd->use_adaptive_tx_coalesce;
1042         rx_vector->rx_group.coal.gl_adapt_enable =
1043                                 cmd->use_adaptive_rx_coalesce;
1044
1045         tx_vector->tx_group.coal.int_gl = cmd->tx_coalesce_usecs;
1046         rx_vector->rx_group.coal.int_gl = cmd->rx_coalesce_usecs;
1047
1048         hns3_set_vector_coalesce_tx_gl(tx_vector,
1049                                        tx_vector->tx_group.coal.int_gl);
1050         hns3_set_vector_coalesce_rx_gl(rx_vector,
1051                                        rx_vector->rx_group.coal.int_gl);
1052
1053         hns3_set_vector_coalesce_rl(tx_vector, h->kinfo.int_rl_setting);
1054         hns3_set_vector_coalesce_rl(rx_vector, h->kinfo.int_rl_setting);
1055 }
1056
1057 static int hns3_set_coalesce(struct net_device *netdev,
1058                              struct ethtool_coalesce *cmd)
1059 {
1060         struct hnae3_handle *h = hns3_get_handle(netdev);
1061         u16 queue_num = h->kinfo.num_tqps;
1062         int ret;
1063         int i;
1064
1065         if (hns3_nic_resetting(netdev))
1066                 return -EBUSY;
1067
1068         ret = hns3_check_coalesce_para(netdev, cmd);
1069         if (ret)
1070                 return ret;
1071
1072         h->kinfo.int_rl_setting =
1073                 hns3_rl_round_down(cmd->rx_coalesce_usecs_high);
1074
1075         for (i = 0; i < queue_num; i++)
1076                 hns3_set_coalesce_per_queue(netdev, cmd, i);
1077
1078         return 0;
1079 }
1080
1081 static int hns3_get_regs_len(struct net_device *netdev)
1082 {
1083         struct hnae3_handle *h = hns3_get_handle(netdev);
1084
1085         if (!h->ae_algo->ops->get_regs_len)
1086                 return -EOPNOTSUPP;
1087
1088         return h->ae_algo->ops->get_regs_len(h);
1089 }
1090
1091 static void hns3_get_regs(struct net_device *netdev,
1092                           struct ethtool_regs *cmd, void *data)
1093 {
1094         struct hnae3_handle *h = hns3_get_handle(netdev);
1095
1096         if (!h->ae_algo->ops->get_regs)
1097                 return;
1098
1099         h->ae_algo->ops->get_regs(h, &cmd->version, data);
1100 }
1101
1102 static int hns3_set_phys_id(struct net_device *netdev,
1103                             enum ethtool_phys_id_state state)
1104 {
1105         struct hnae3_handle *h = hns3_get_handle(netdev);
1106
1107         if (!h->ae_algo || !h->ae_algo->ops || !h->ae_algo->ops->set_led_id)
1108                 return -EOPNOTSUPP;
1109
1110         return h->ae_algo->ops->set_led_id(h, state);
1111 }
1112
1113 static u32 hns3_get_msglevel(struct net_device *netdev)
1114 {
1115         struct hnae3_handle *h = hns3_get_handle(netdev);
1116
1117         return h->msg_enable;
1118 }
1119
1120 static void hns3_set_msglevel(struct net_device *netdev, u32 msg_level)
1121 {
1122         struct hnae3_handle *h = hns3_get_handle(netdev);
1123
1124         h->msg_enable = msg_level;
1125 }
1126
1127 static const struct ethtool_ops hns3vf_ethtool_ops = {
1128         .get_drvinfo = hns3_get_drvinfo,
1129         .get_ringparam = hns3_get_ringparam,
1130         .set_ringparam = hns3_set_ringparam,
1131         .get_strings = hns3_get_strings,
1132         .get_ethtool_stats = hns3_get_stats,
1133         .get_sset_count = hns3_get_sset_count,
1134         .get_rxnfc = hns3_get_rxnfc,
1135         .set_rxnfc = hns3_set_rxnfc,
1136         .get_rxfh_key_size = hns3_get_rss_key_size,
1137         .get_rxfh_indir_size = hns3_get_rss_indir_size,
1138         .get_rxfh = hns3_get_rss,
1139         .set_rxfh = hns3_set_rss,
1140         .get_link_ksettings = hns3_get_link_ksettings,
1141         .get_channels = hns3_get_channels,
1142         .get_coalesce = hns3_get_coalesce,
1143         .set_coalesce = hns3_set_coalesce,
1144         .get_regs_len = hns3_get_regs_len,
1145         .get_regs = hns3_get_regs,
1146         .get_link = hns3_get_link,
1147         .get_msglevel = hns3_get_msglevel,
1148         .set_msglevel = hns3_set_msglevel,
1149 };
1150
1151 static const struct ethtool_ops hns3_ethtool_ops = {
1152         .self_test = hns3_self_test,
1153         .get_drvinfo = hns3_get_drvinfo,
1154         .get_link = hns3_get_link,
1155         .get_ringparam = hns3_get_ringparam,
1156         .set_ringparam = hns3_set_ringparam,
1157         .get_pauseparam = hns3_get_pauseparam,
1158         .set_pauseparam = hns3_set_pauseparam,
1159         .get_strings = hns3_get_strings,
1160         .get_ethtool_stats = hns3_get_stats,
1161         .get_sset_count = hns3_get_sset_count,
1162         .get_rxnfc = hns3_get_rxnfc,
1163         .set_rxnfc = hns3_set_rxnfc,
1164         .get_rxfh_key_size = hns3_get_rss_key_size,
1165         .get_rxfh_indir_size = hns3_get_rss_indir_size,
1166         .get_rxfh = hns3_get_rss,
1167         .set_rxfh = hns3_set_rss,
1168         .get_link_ksettings = hns3_get_link_ksettings,
1169         .set_link_ksettings = hns3_set_link_ksettings,
1170         .nway_reset = hns3_nway_reset,
1171         .get_channels = hns3_get_channels,
1172         .set_channels = hns3_set_channels,
1173         .get_coalesce = hns3_get_coalesce,
1174         .set_coalesce = hns3_set_coalesce,
1175         .get_regs_len = hns3_get_regs_len,
1176         .get_regs = hns3_get_regs,
1177         .set_phys_id = hns3_set_phys_id,
1178         .get_msglevel = hns3_get_msglevel,
1179         .set_msglevel = hns3_set_msglevel,
1180 };
1181
1182 void hns3_ethtool_set_ops(struct net_device *netdev)
1183 {
1184         struct hnae3_handle *h = hns3_get_handle(netdev);
1185
1186         if (h->flags & HNAE3_SUPPORT_VF)
1187                 netdev->ethtool_ops = &hns3vf_ethtool_ops;
1188         else
1189                 netdev->ethtool_ops = &hns3_ethtool_ops;
1190 }