drivers/net/ethernet/hisilicon/hns/hns_ethtool.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Copyright (c) 2014-2015 Hisilicon Limited.
   4  */
   5
   6 #include <linux/etherdevice.h>
   7 #include <linux/interrupt.h>
   8 #include <linux/module.h>
   9 #include <linux/platform_device.h>
  10 #include "hns_enet.h"
  11
  12 #define HNS_PHY_PAGE_MDIX       0
  13 #define HNS_PHY_PAGE_LED        3
  14 #define HNS_PHY_PAGE_COPPER     0
  15
  16 #define HNS_PHY_PAGE_REG        22      /* Page Selection Reg. */
  17 #define HNS_PHY_CSC_REG         16      /* Copper Specific Control Register */
  18 #define HNS_PHY_CSS_REG         17      /* Copper Specific Status Register */
  19 #define HNS_LED_FC_REG          16      /* LED Function Control Reg. */
  20
  21 #define HNS_LED_FORCE_ON        9
  22 #define HNS_LED_FORCE_OFF       8
  23
  24 #define HNS_CHIP_VERSION 660
  25 #define HNS_NET_STATS_CNT 26
  26
  27 #define PHY_MDIX_CTRL_S         (5)
  28 #define PHY_MDIX_CTRL_M         (3 << PHY_MDIX_CTRL_S)
  29
  30 #define PHY_MDIX_STATUS_B       (6)
  31 #define PHY_SPEED_DUP_RESOLVE_B (11)
  32
  33 /**
  34  *hns_nic_get_link - get current link status
  35  *@net_dev: net_device
  36  *retuen 0 - success , negative --fail
  37  */
  38 static u32 hns_nic_get_link(struct net_device *net_dev)
  39 {
  40         struct hns_nic_priv *priv = netdev_priv(net_dev);
  41         u32 link_stat = priv->link;
  42         struct hnae_handle *h;
  43
  44         h = priv->ae_handle;
  45
  46         if (net_dev->phydev) {
  47                 if (!genphy_read_status(net_dev->phydev))
  48                         link_stat = net_dev->phydev->link;
  49                 else
  50                         link_stat = 0;
  51         }
  52
  53         if (h->dev && h->dev->ops && h->dev->ops->get_status)
  54                 link_stat = link_stat && h->dev->ops->get_status(h);
  55         else
  56                 link_stat = 0;
  57
  58         return link_stat;
  59 }
  60
  61 static void hns_get_mdix_mode(struct net_device *net_dev,
  62                               struct ethtool_link_ksettings *cmd)
  63 {
  64         int mdix_ctrl, mdix, retval, is_resolved;
  65         struct phy_device *phy_dev = net_dev->phydev;
  66
  67         if (!phy_dev || !phy_dev->mdio.bus) {
  68                 cmd->base.eth_tp_mdix_ctrl = ETH_TP_MDI_INVALID;
  69                 cmd->base.eth_tp_mdix = ETH_TP_MDI_INVALID;
  70                 return;
  71         }
  72
  73         phy_write(phy_dev, HNS_PHY_PAGE_REG, HNS_PHY_PAGE_MDIX);
  74
  75         retval = phy_read(phy_dev, HNS_PHY_CSC_REG);
  76         mdix_ctrl = hnae_get_field(retval, PHY_MDIX_CTRL_M, PHY_MDIX_CTRL_S);
  77
  78         retval = phy_read(phy_dev, HNS_PHY_CSS_REG);
  79         mdix = hnae_get_bit(retval, PHY_MDIX_STATUS_B);
  80         is_resolved = hnae_get_bit(retval, PHY_SPEED_DUP_RESOLVE_B);
  81
  82         phy_write(phy_dev, HNS_PHY_PAGE_REG, HNS_PHY_PAGE_COPPER);
  83
  84         switch (mdix_ctrl) {
  85         case 0x0:
  86                 cmd->base.eth_tp_mdix_ctrl = ETH_TP_MDI;
  87                 break;
  88         case 0x1:
  89                 cmd->base.eth_tp_mdix_ctrl = ETH_TP_MDI_X;
  90                 break;
  91         case 0x3:
  92                 cmd->base.eth_tp_mdix_ctrl = ETH_TP_MDI_AUTO;
  93                 break;
  94         default:
  95                 cmd->base.eth_tp_mdix_ctrl = ETH_TP_MDI_INVALID;
  96                 break;
  97         }
  98
  99         if (!is_resolved)
 100                 cmd->base.eth_tp_mdix = ETH_TP_MDI_INVALID;
 101         else if (mdix)
 102                 cmd->base.eth_tp_mdix = ETH_TP_MDI_X;
 103         else
 104                 cmd->base.eth_tp_mdix = ETH_TP_MDI;
 105 }
 106
 107 /**
 108  *hns_nic_get_link_ksettings - implement ethtool get link ksettings
 109  *@net_dev: net_device
 110  *@cmd: ethtool_link_ksettings
 111  *retuen 0 - success , negative --fail
 112  */
 113 static int hns_nic_get_link_ksettings(struct net_device *net_dev,
 114                                       struct ethtool_link_ksettings *cmd)
 115 {
 116         struct hns_nic_priv *priv = netdev_priv(net_dev);
 117         struct hnae_handle *h;
 118         u32 link_stat;
 119         int ret;
 120         u8 duplex;
 121         u16 speed;
 122         u32 supported, advertising;
 123
 124         if (!priv || !priv->ae_handle)
 125                 return -ESRCH;
 126
 127         h = priv->ae_handle;
 128         if (!h->dev || !h->dev->ops || !h->dev->ops->get_info)
 129                 return -ESRCH;
 130
 131         ret = h->dev->ops->get_info(h, NULL, &speed, &duplex);
 132         if (ret < 0) {
 133                 netdev_err(net_dev, "%s get_info error!\n", __func__);
 134                 return -EINVAL;
 135         }
 136
 137         ethtool_convert_link_mode_to_legacy_u32(&supported,
 138                                                 cmd->link_modes.supported);
 139         ethtool_convert_link_mode_to_legacy_u32(&advertising,
 140                                                 cmd->link_modes.advertising);
 141
 142         /* When there is no phy, autoneg is off. */
 143         cmd->base.autoneg = false;
 144         cmd->base.speed = speed;
 145         cmd->base.duplex = duplex;
 146
 147         if (net_dev->phydev)
 148                 phy_ethtool_ksettings_get(net_dev->phydev, cmd);
 149
 150         link_stat = hns_nic_get_link(net_dev);
 151         if (!link_stat) {
 152                 cmd->base.speed = (u32)SPEED_UNKNOWN;
 153                 cmd->base.duplex = DUPLEX_UNKNOWN;
 154         }
 155
 156         if (cmd->base.autoneg)
 157                 advertising |= ADVERTISED_Autoneg;
 158
 159         supported |= h->if_support;
 160         if (h->phy_if == PHY_INTERFACE_MODE_SGMII) {
 161                 supported |= SUPPORTED_TP;
 162                 advertising |= ADVERTISED_1000baseT_Full;
 163         } else if (h->phy_if == PHY_INTERFACE_MODE_XGMII) {
 164                 supported |= SUPPORTED_FIBRE;
 165                 advertising |= ADVERTISED_10000baseKR_Full;
 166         }
 167
 168         switch (h->media_type) {
 169         case HNAE_MEDIA_TYPE_FIBER:
 170                 cmd->base.port = PORT_FIBRE;
 171                 break;
 172         case HNAE_MEDIA_TYPE_COPPER:
 173                 cmd->base.port = PORT_TP;
 174                 break;
 175         case HNAE_MEDIA_TYPE_UNKNOWN:
 176         default:
 177                 break;
 178         }
 179
 180         if (!(AE_IS_VER1(priv->enet_ver) && h->port_type == HNAE_PORT_DEBUG))
 181                 supported |= SUPPORTED_Pause;
 182
 183         ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported,
 184                                                 supported);
 185         ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.advertising,
 186                                                 advertising);
 187
 188         cmd->base.mdio_support = ETH_MDIO_SUPPORTS_C45 | ETH_MDIO_SUPPORTS_C22;
 189         hns_get_mdix_mode(net_dev, cmd);
 190
 191         return 0;
 192 }
 193
 194 /**
 195  *hns_nic_set_link_ksettings - implement ethtool set link ksettings
 196  *@net_dev: net_device
 197  *@cmd: ethtool_link_ksettings
 198  *retuen 0 - success , negative --fail
 199  */
 200 static int hns_nic_set_link_ksettings(struct net_device *net_dev,
 201                                       const struct ethtool_link_ksettings *cmd)
 202 {
 203         struct hns_nic_priv *priv = netdev_priv(net_dev);
 204         struct hnae_handle *h;
 205         u32 speed;
 206
 207         if (!netif_running(net_dev))
 208                 return -ESRCH;
 209
 210         if (!priv || !priv->ae_handle || !priv->ae_handle->dev ||
 211             !priv->ae_handle->dev->ops)
 212                 return -ENODEV;
 213
 214         h = priv->ae_handle;
 215         speed = cmd->base.speed;
 216
 217         if (h->phy_if == PHY_INTERFACE_MODE_XGMII) {
 218                 if (cmd->base.autoneg == AUTONEG_ENABLE ||
 219                     speed != SPEED_10000 ||
 220                     cmd->base.duplex != DUPLEX_FULL)
 221                         return -EINVAL;
 222         } else if (h->phy_if == PHY_INTERFACE_MODE_SGMII) {
 223                 if (!net_dev->phydev && cmd->base.autoneg == AUTONEG_ENABLE)
 224                         return -EINVAL;
 225
 226                 if (speed == SPEED_1000 && cmd->base.duplex == DUPLEX_HALF)
 227                         return -EINVAL;
 228                 if (net_dev->phydev)
 229                         return phy_ethtool_ksettings_set(net_dev->phydev, cmd);
 230
 231                 if ((speed != SPEED_10 && speed != SPEED_100 &&
 232                      speed != SPEED_1000) || (cmd->base.duplex != DUPLEX_HALF &&
 233                      cmd->base.duplex != DUPLEX_FULL))
 234                         return -EINVAL;
 235         } else {
 236                 netdev_err(net_dev, "Not supported!");
 237                 return -ENOTSUPP;
 238         }
 239
 240         if (h->dev->ops->adjust_link) {
 241                 netif_carrier_off(net_dev);
 242                 h->dev->ops->adjust_link(h, (int)speed, cmd->base.duplex);
 243                 netif_carrier_on(net_dev);
 244                 return 0;
 245         }
 246
 247         netdev_err(net_dev, "Not supported!");
 248         return -ENOTSUPP;
 249 }
 250
 251 static const char hns_nic_test_strs[][ETH_GSTRING_LEN] = {
 252         "Mac    Loopback test",
 253         "Serdes Loopback test",
 254         "Phy    Loopback test"
 255 };
 256
 257 static int hns_nic_config_phy_loopback(struct phy_device *phy_dev, u8 en)
 258 {
 259         int err;
 260
 261         if (en) {
 262                 /* Doing phy loopback in offline state, phy resuming is
 263                  * needed to power up the device.
 264                  */
 265                 err = phy_resume(phy_dev);
 266                 if (err)
 267                         goto out;
 268
 269                 err = phy_loopback(phy_dev, true);
 270         } else {
 271                 err = phy_loopback(phy_dev, false);
 272                 if (err)
 273                         goto out;
 274
 275                 err = phy_suspend(phy_dev);
 276         }
 277
 278 out:
 279         return err;
 280 }
 281
 282 static int __lb_setup(struct net_device *ndev,
 283                       enum hnae_loop loop)
 284 {
 285         int ret = 0;
 286         struct hns_nic_priv *priv = netdev_priv(ndev);
 287         struct phy_device *phy_dev = ndev->phydev;
 288         struct hnae_handle *h = priv->ae_handle;
 289
 290         switch (loop) {
 291         case MAC_INTERNALLOOP_PHY:
 292                 ret = hns_nic_config_phy_loopback(phy_dev, 0x1);
 293                 if (!ret)
 294                         ret = h->dev->ops->set_loopback(h, loop, 0x1);
 295                 break;
 296         case MAC_INTERNALLOOP_MAC:
 297                 if ((h->dev->ops->set_loopback) &&
 298                     (priv->ae_handle->phy_if != PHY_INTERFACE_MODE_XGMII))
 299                         ret = h->dev->ops->set_loopback(h, loop, 0x1);
 300                 break;
 301         case MAC_INTERNALLOOP_SERDES:
 302                 if (h->dev->ops->set_loopback)
 303                         ret = h->dev->ops->set_loopback(h, loop, 0x1);
 304                 break;
 305         case MAC_LOOP_PHY_NONE:
 306                 ret = hns_nic_config_phy_loopback(phy_dev, 0x0);
 307                 fallthrough;
 308         case MAC_LOOP_NONE:
 309                 if (!ret && h->dev->ops->set_loopback) {
 310                         if (priv->ae_handle->phy_if != PHY_INTERFACE_MODE_XGMII)
 311                                 ret = h->dev->ops->set_loopback(h,
 312                                         MAC_INTERNALLOOP_MAC, 0x0);
 313
 314                         if (!ret)
 315                                 ret = h->dev->ops->set_loopback(h,
 316                                         MAC_INTERNALLOOP_SERDES, 0x0);
 317                 }
 318                 break;
 319         default:
 320                 ret = -EINVAL;
 321                 break;
 322         }
 323
 324         if (!ret) {
 325                 if (loop == MAC_LOOP_NONE)
 326                         h->dev->ops->set_promisc_mode(
 327                                 h, ndev->flags & IFF_PROMISC);
 328                 else
 329                         h->dev->ops->set_promisc_mode(h, 1);
 330         }
 331         return ret;
 332 }
 333
 334 static int __lb_up(struct net_device *ndev,
 335                    enum hnae_loop loop_mode)
 336 {
 337 #define NIC_LB_TEST_WAIT_PHY_LINK_TIME 300
 338         struct hns_nic_priv *priv = netdev_priv(ndev);
 339         struct hnae_handle *h = priv->ae_handle;
 340         int speed, duplex;
 341         int ret;
 342
 343         hns_nic_net_reset(ndev);
 344
 345         ret = __lb_setup(ndev, loop_mode);
 346         if (ret)
 347                 return ret;
 348
 349         msleep(200);
 350
 351         ret = h->dev->ops->start ? h->dev->ops->start(h) : 0;
 352         if (ret)
 353                 return ret;
 354
 355         /* link adjust duplex*/
 356         if (priv->ae_handle->phy_if != PHY_INTERFACE_MODE_XGMII)
 357                 speed = 1000;
 358         else
 359                 speed = 10000;
 360         duplex = 1;
 361
 362         h->dev->ops->adjust_link(h, speed, duplex);
 363
 364         /* wait adjust link done and phy ready */
 365         msleep(NIC_LB_TEST_WAIT_PHY_LINK_TIME);
 366
 367         return 0;
 368 }
 369
 370 static void __lb_other_process(struct hns_nic_ring_data *ring_data,
 371                                struct sk_buff *skb)
 372 {
 373         struct net_device *ndev;
 374         struct hns_nic_priv *priv;
 375         struct hnae_ring *ring;
 376         struct netdev_queue *dev_queue;
 377         struct sk_buff *new_skb;
 378         unsigned int frame_size;
 379         int check_ok;
 380         u32 i;
 381         char buff[33]; /* 32B data and the last character '\0' */
 382
 383         if (!ring_data) { /* Just for doing create frame*/
 384                 ndev = skb->dev;
 385                 priv = netdev_priv(ndev);
 386
 387                 frame_size = skb->len;
 388                 memset(skb->data, 0xFF, frame_size);
 389                 if ((!AE_IS_VER1(priv->enet_ver)) &&
 390                     (priv->ae_handle->port_type == HNAE_PORT_SERVICE)) {
 391                         memcpy(skb->data, ndev->dev_addr, 6);
 392                         skb->data[5] += 0x1f;
 393                 }
 394
 395                 frame_size &= ~1ul;
 396                 memset(&skb->data[frame_size / 2], 0xAA, frame_size / 2 - 1);
 397                 memset(&skb->data[frame_size / 2 + 10], 0xBE,
 398                        frame_size / 2 - 11);
 399                 memset(&skb->data[frame_size / 2 + 12], 0xAF,
 400                        frame_size / 2 - 13);
 401                 return;
 402         }
 403
 404         ring = ring_data->ring;
 405         ndev = ring_data->napi.dev;
 406         if (is_tx_ring(ring)) { /* for tx queue reset*/
 407                 dev_queue = netdev_get_tx_queue(ndev, ring_data->queue_index);
 408                 netdev_tx_reset_queue(dev_queue);
 409                 return;
 410         }
 411
 412         frame_size = skb->len;
 413         frame_size &= ~1ul;
 414         /* for mutl buffer*/
 415         new_skb = skb_copy(skb, GFP_ATOMIC);
 416         dev_kfree_skb_any(skb);
 417         if (!new_skb) {
 418                 netdev_err(ndev, "skb alloc failed\n");
 419                 return;
 420         }
 421         skb = new_skb;
 422
 423         check_ok = 0;
 424         if (*(skb->data + 10) == 0xFF) { /* for rx check frame*/
 425                 if ((*(skb->data + frame_size / 2 + 10) == 0xBE) &&
 426                     (*(skb->data + frame_size / 2 + 12) == 0xAF))
 427                         check_ok = 1;
 428         }
 429
 430         if (check_ok) {
 431                 ndev->stats.rx_packets++;
 432                 ndev->stats.rx_bytes += skb->len;
 433         } else {
 434                 ndev->stats.rx_frame_errors++;
 435                 for (i = 0; i < skb->len; i++) {
 436                         snprintf(buff + i % 16 * 2, 3, /* tailing \0*/
 437                                  "%02x", *(skb->data + i));
 438                         if ((i % 16 == 15) || (i == skb->len - 1))
 439                                 pr_info("%s\n", buff);
 440                 }
 441         }
 442         dev_kfree_skb_any(skb);
 443 }
 444
 445 static int __lb_clean_rings(struct hns_nic_priv *priv,
 446                             int ringid0, int ringid1, int budget)
 447 {
 448         int i, ret;
 449         struct hns_nic_ring_data *ring_data;
 450         struct net_device *ndev = priv->netdev;
 451         unsigned long rx_packets = ndev->stats.rx_packets;
 452         unsigned long rx_bytes = ndev->stats.rx_bytes;
 453         unsigned long rx_frame_errors = ndev->stats.rx_frame_errors;
 454
 455         for (i = ringid0; i <= ringid1; i++) {
 456                 ring_data = &priv->ring_data[i];
 457                 (void)ring_data->poll_one(ring_data,
 458                                           budget, __lb_other_process);
 459         }
 460         ret = (int)(ndev->stats.rx_packets - rx_packets);
 461         ndev->stats.rx_packets = rx_packets;
 462         ndev->stats.rx_bytes = rx_bytes;
 463         ndev->stats.rx_frame_errors = rx_frame_errors;
 464         return ret;
 465 }
 466
 467 /**
 468  * __lb_run_test -  run loopback test
 469  * @ndev: net device
 470  * @loop_mode: loopback mode
 471  */
 472 static int __lb_run_test(struct net_device *ndev,
 473                          enum hnae_loop loop_mode)
 474 {
 475 #define NIC_LB_TEST_PKT_NUM_PER_CYCLE 1
 476 #define NIC_LB_TEST_RING_ID 0
 477 #define NIC_LB_TEST_FRAME_SIZE 128
 478 /* nic loopback test err  */
 479 #define NIC_LB_TEST_NO_MEM_ERR 1
 480 #define NIC_LB_TEST_TX_CNT_ERR 2
 481 #define NIC_LB_TEST_RX_CNT_ERR 3
 482
 483         struct hns_nic_priv *priv = netdev_priv(ndev);
 484         struct hnae_handle *h = priv->ae_handle;
 485         int i, j, lc, good_cnt, ret_val = 0;
 486         unsigned int size;
 487         netdev_tx_t tx_ret_val;
 488         struct sk_buff *skb;
 489
 490         size = NIC_LB_TEST_FRAME_SIZE;
 491         /* allocate test skb */
 492         skb = alloc_skb(size, GFP_KERNEL);
 493         if (!skb)
 494                 return NIC_LB_TEST_NO_MEM_ERR;
 495
 496         /* place data into test skb */
 497         (void)skb_put(skb, size);
 498         skb->dev = ndev;
 499         __lb_other_process(NULL, skb);
 500         skb->queue_mapping = NIC_LB_TEST_RING_ID;
 501
 502         lc = 1;
 503         for (j = 0; j < lc; j++) {
 504                 /* reset count of good packets */
 505                 good_cnt = 0;
 506                 /* place 64 packets on the transmit queue*/
 507                 for (i = 0; i < NIC_LB_TEST_PKT_NUM_PER_CYCLE; i++) {
 508                         (void)skb_get(skb);
 509
 510                         tx_ret_val = (netdev_tx_t)hns_nic_net_xmit_hw(
 511                                 ndev, skb,
 512                                 &tx_ring_data(priv, skb->queue_mapping));
 513                         if (tx_ret_val == NETDEV_TX_OK)
 514                                 good_cnt++;
 515                         else
 516                                 break;
 517                 }
 518                 if (good_cnt != NIC_LB_TEST_PKT_NUM_PER_CYCLE) {
 519                         ret_val = NIC_LB_TEST_TX_CNT_ERR;
 520                         dev_err(priv->dev, "%s sent fail, cnt=0x%x, budget=0x%x\n",
 521                                 hns_nic_test_strs[loop_mode], good_cnt,
 522                                 NIC_LB_TEST_PKT_NUM_PER_CYCLE);
 523                         break;
 524                 }
 525
 526                 /* allow 100 milliseconds for packets to go from Tx to Rx */
 527                 msleep(100);
 528
 529                 good_cnt = __lb_clean_rings(priv,
 530                                             h->q_num, h->q_num * 2 - 1,
 531                                             NIC_LB_TEST_PKT_NUM_PER_CYCLE);
 532                 if (good_cnt != NIC_LB_TEST_PKT_NUM_PER_CYCLE) {
 533                         ret_val = NIC_LB_TEST_RX_CNT_ERR;
 534                         dev_err(priv->dev, "%s recv fail, cnt=0x%x, budget=0x%x\n",
 535                                 hns_nic_test_strs[loop_mode], good_cnt,
 536                                 NIC_LB_TEST_PKT_NUM_PER_CYCLE);
 537                         break;
 538                 }
 539                 (void)__lb_clean_rings(priv,
 540                                        NIC_LB_TEST_RING_ID, NIC_LB_TEST_RING_ID,
 541                                        NIC_LB_TEST_PKT_NUM_PER_CYCLE);
 542         }
 543
 544         /* free the original skb */
 545         kfree_skb(skb);
 546
 547         return ret_val;
 548 }
 549
 550 static int __lb_down(struct net_device *ndev, enum hnae_loop loop)
 551 {
 552         struct hns_nic_priv *priv = netdev_priv(ndev);
 553         struct hnae_handle *h = priv->ae_handle;
 554         int ret;
 555
 556         if (loop == MAC_INTERNALLOOP_PHY)
 557                 ret = __lb_setup(ndev, MAC_LOOP_PHY_NONE);
 558         else
 559                 ret = __lb_setup(ndev, MAC_LOOP_NONE);
 560         if (ret)
 561                 netdev_err(ndev, "%s: __lb_setup return error(%d)!\n",
 562                            __func__,
 563                            ret);
 564
 565         if (h->dev->ops->stop)
 566                 h->dev->ops->stop(h);
 567
 568         usleep_range(10000, 20000);
 569         (void)__lb_clean_rings(priv, 0, h->q_num - 1, 256);
 570
 571         hns_nic_net_reset(ndev);
 572
 573         return 0;
 574 }
 575
 576 /**
 577  * hns_nic_self_test - self test
 578  * @ndev: net device
 579  * @eth_test: test cmd
 580  * @data: test result
 581  */
 582 static void hns_nic_self_test(struct net_device *ndev,
 583                               struct ethtool_test *eth_test, u64 *data)
 584 {
 585         struct hns_nic_priv *priv = netdev_priv(ndev);
 586         bool if_running = netif_running(ndev);
 587 #define SELF_TEST_TPYE_NUM 3
 588         int st_param[SELF_TEST_TPYE_NUM][2];
 589         int i;
 590         int test_index = 0;
 591
 592         st_param[0][0] = MAC_INTERNALLOOP_MAC; /* XGE not supported lb */
 593         st_param[0][1] = (priv->ae_handle->phy_if != PHY_INTERFACE_MODE_XGMII);
 594         st_param[1][0] = MAC_INTERNALLOOP_SERDES;
 595         st_param[1][1] = 1; /*serdes must exist*/
 596         st_param[2][0] = MAC_INTERNALLOOP_PHY; /* only supporte phy node*/
 597         st_param[2][1] = ((!!(priv->ae_handle->phy_dev)) &&
 598                 (priv->ae_handle->phy_if != PHY_INTERFACE_MODE_XGMII));
 599
 600         if (eth_test->flags == ETH_TEST_FL_OFFLINE) {
 601                 set_bit(NIC_STATE_TESTING, &priv->state);
 602
 603                 if (if_running)
 604                         dev_close(ndev);
 605
 606                 for (i = 0; i < SELF_TEST_TPYE_NUM; i++) {
 607                         if (!st_param[i][1])
 608                                 continue;       /* NEXT testing */
 609
 610                         data[test_index] = __lb_up(ndev,
 611                                 (enum hnae_loop)st_param[i][0]);
 612                         if (!data[test_index]) {
 613                                 data[test_index] = __lb_run_test(
 614                                         ndev, (enum hnae_loop)st_param[i][0]);
 615                                 (void)__lb_down(ndev,
 616                                                 (enum hnae_loop)st_param[i][0]);
 617                         }
 618
 619                         if (data[test_index])
 620                                 eth_test->flags |= ETH_TEST_FL_FAILED;
 621
 622                         test_index++;
 623                 }
 624
 625                 hns_nic_net_reset(priv->netdev);
 626
 627                 clear_bit(NIC_STATE_TESTING, &priv->state);
 628
 629                 if (if_running)
 630                         (void)dev_open(ndev, NULL);
 631         }
 632         /* Online tests aren't run; pass by default */
 633
 634         (void)msleep_interruptible(4 * 1000);
 635 }
 636
 637 /**
 638  * hns_nic_get_drvinfo - get net driver info
 639  * @net_dev: net device
 640  * @drvinfo: driver info
 641  */
 642 static void hns_nic_get_drvinfo(struct net_device *net_dev,
 643                                 struct ethtool_drvinfo *drvinfo)
 644 {
 645         struct hns_nic_priv *priv = netdev_priv(net_dev);
 646
 647         strncpy(drvinfo->version, HNAE_DRIVER_VERSION,
 648                 sizeof(drvinfo->version));
 649         drvinfo->version[sizeof(drvinfo->version) - 1] = '\0';
 650
 651         strncpy(drvinfo->driver, HNAE_DRIVER_NAME, sizeof(drvinfo->driver));
 652         drvinfo->driver[sizeof(drvinfo->driver) - 1] = '\0';
 653
 654         strncpy(drvinfo->bus_info, priv->dev->bus->name,
 655                 sizeof(drvinfo->bus_info));
 656         drvinfo->bus_info[ETHTOOL_BUSINFO_LEN - 1] = '\0';
 657
 658         strncpy(drvinfo->fw_version, "N/A", ETHTOOL_FWVERS_LEN);
 659         drvinfo->eedump_len = 0;
 660 }
 661
 662 /**
 663  * hns_get_ringparam - get ring parameter
 664  * @net_dev: net device
 665  * @param: ethtool parameter
 666  */
 667 static void hns_get_ringparam(struct net_device *net_dev,
 668                               struct ethtool_ringparam *param)
 669 {
 670         struct hns_nic_priv *priv = netdev_priv(net_dev);
 671         struct hnae_ae_ops *ops;
 672         struct hnae_queue *queue;
 673         u32 uplimit = 0;
 674
 675         queue = priv->ae_handle->qs[0];
 676         ops = priv->ae_handle->dev->ops;
 677
 678         if (ops->get_ring_bdnum_limit)
 679                 ops->get_ring_bdnum_limit(queue, &uplimit);
 680
 681         param->rx_max_pending = uplimit;
 682         param->tx_max_pending = uplimit;
 683         param->rx_pending = queue->rx_ring.desc_num;
 684         param->tx_pending = queue->tx_ring.desc_num;
 685 }
 686
 687 /**
 688  * hns_get_pauseparam - get pause parameter
 689  * @net_dev: net device
 690  * @param: pause parameter
 691  */
 692 static void hns_get_pauseparam(struct net_device *net_dev,
 693                                struct ethtool_pauseparam *param)
 694 {
 695         struct hns_nic_priv *priv = netdev_priv(net_dev);
 696         struct hnae_ae_ops *ops;
 697
 698         ops = priv->ae_handle->dev->ops;
 699
 700         if (ops->get_pauseparam)
 701                 ops->get_pauseparam(priv->ae_handle, &param->autoneg,
 702                                             &param->rx_pause, &param->tx_pause);
 703 }
 704
 705 /**
 706  * hns_set_pauseparam - set pause parameter
 707  * @net_dev: net device
 708  * @param: pause parameter
 709  *
 710  * Return 0 on success, negative on failure
 711  */
 712 static int hns_set_pauseparam(struct net_device *net_dev,
 713                               struct ethtool_pauseparam *param)
 714 {
 715         struct hns_nic_priv *priv = netdev_priv(net_dev);
 716         struct hnae_handle *h;
 717         struct hnae_ae_ops *ops;
 718
 719         h = priv->ae_handle;
 720         ops = h->dev->ops;
 721
 722         if (!ops->set_pauseparam)
 723                 return -ESRCH;
 724
 725         return ops->set_pauseparam(priv->ae_handle, param->autoneg,
 726                                    param->rx_pause, param->tx_pause);
 727 }
 728
 729 /**
 730  * hns_get_coalesce - get coalesce info.
 731  * @net_dev: net device
 732  * @ec: coalesce info.
 733  * @kernel_coal: ethtool CQE mode setting structure
 734  * @extack: extack for reporting error messages
 735  *
 736  * Return 0 on success, negative on failure.
 737  */
 738 static int hns_get_coalesce(struct net_device *net_dev,
 739                             struct ethtool_coalesce *ec,
 740                             struct kernel_ethtool_coalesce *kernel_coal,
 741                             struct netlink_ext_ack *extack)
 742 {
 743         struct hns_nic_priv *priv = netdev_priv(net_dev);
 744         struct hnae_ae_ops *ops;
 745
 746         ops = priv->ae_handle->dev->ops;
 747
 748         ec->use_adaptive_rx_coalesce = priv->ae_handle->coal_adapt_en;
 749         ec->use_adaptive_tx_coalesce = priv->ae_handle->coal_adapt_en;
 750
 751         if ((!ops->get_coalesce_usecs) ||
 752             (!ops->get_max_coalesced_frames))
 753                 return -ESRCH;
 754
 755         ops->get_coalesce_usecs(priv->ae_handle,
 756                                         &ec->tx_coalesce_usecs,
 757                                         &ec->rx_coalesce_usecs);
 758
 759         ops->get_max_coalesced_frames(
 760                 priv->ae_handle,
 761                 &ec->tx_max_coalesced_frames,
 762                 &ec->rx_max_coalesced_frames);
 763
 764         ops->get_coalesce_range(priv->ae_handle,
 765                                 &ec->tx_max_coalesced_frames_low,
 766                                 &ec->rx_max_coalesced_frames_low,
 767                                 &ec->tx_max_coalesced_frames_high,
 768                                 &ec->rx_max_coalesced_frames_high,
 769                                 &ec->tx_coalesce_usecs_low,
 770                                 &ec->rx_coalesce_usecs_low,
 771                                 &ec->tx_coalesce_usecs_high,
 772                                 &ec->rx_coalesce_usecs_high);
 773
 774         return 0;
 775 }
 776
 777 /**
 778  * hns_set_coalesce - set coalesce info.
 779  * @net_dev: net device
 780  * @ec: coalesce info.
 781  * @kernel_coal: ethtool CQE mode setting structure
 782  * @extack: extack for reporting error messages
 783  *
 784  * Return 0 on success, negative on failure.
 785  */
 786 static int hns_set_coalesce(struct net_device *net_dev,
 787                             struct ethtool_coalesce *ec,
 788                             struct kernel_ethtool_coalesce *kernel_coal,
 789                             struct netlink_ext_ack *extack)
 790 {
 791         struct hns_nic_priv *priv = netdev_priv(net_dev);
 792         struct hnae_ae_ops *ops;
 793         int rc1, rc2;
 794
 795         ops = priv->ae_handle->dev->ops;
 796
 797         if (ec->tx_coalesce_usecs != ec->rx_coalesce_usecs)
 798                 return -EINVAL;
 799
 800         if ((!ops->set_coalesce_usecs) ||
 801             (!ops->set_coalesce_frames))
 802                 return -ESRCH;
 803
 804         if (ec->use_adaptive_rx_coalesce != priv->ae_handle->coal_adapt_en)
 805                 priv->ae_handle->coal_adapt_en = ec->use_adaptive_rx_coalesce;
 806
 807         rc1 = ops->set_coalesce_usecs(priv->ae_handle,
 808                                       ec->rx_coalesce_usecs);
 809
 810         rc2 = ops->set_coalesce_frames(priv->ae_handle,
 811                                        ec->tx_max_coalesced_frames,
 812                                        ec->rx_max_coalesced_frames);
 813
 814         if (rc1 || rc2)
 815                 return -EINVAL;
 816
 817         return 0;
 818 }
 819
 820 /**
 821  * hns_get_channels - get channel info.
 822  * @net_dev: net device
 823  * @ch: channel info.
 824  */
 825 static void
 826 hns_get_channels(struct net_device *net_dev, struct ethtool_channels *ch)
 827 {
 828         struct hns_nic_priv *priv = netdev_priv(net_dev);
 829
 830         ch->max_rx = priv->ae_handle->q_num;
 831         ch->max_tx = priv->ae_handle->q_num;
 832
 833         ch->rx_count = priv->ae_handle->q_num;
 834         ch->tx_count = priv->ae_handle->q_num;
 835 }
 836
 837 /**
 838  * hns_get_ethtool_stats - get detail statistics.
 839  * @netdev: net device
 840  * @stats: statistics info.
 841  * @data: statistics data.
 842  */
 843 static void hns_get_ethtool_stats(struct net_device *netdev,
 844                                   struct ethtool_stats *stats, u64 *data)
 845 {
 846         u64 *p = data;
 847         struct hns_nic_priv *priv = netdev_priv(netdev);
 848         struct hnae_handle *h = priv->ae_handle;
 849         const struct rtnl_link_stats64 *net_stats;
 850         struct rtnl_link_stats64 temp;
 851
 852         if (!h->dev->ops->get_stats || !h->dev->ops->update_stats) {
 853                 netdev_err(netdev, "get_stats or update_stats is null!\n");
 854                 return;
 855         }
 856
 857         h->dev->ops->update_stats(h, &netdev->stats);
 858
 859         net_stats = dev_get_stats(netdev, &temp);
 860
 861         /* get netdev statistics */
 862         p[0] = net_stats->rx_packets;
 863         p[1] = net_stats->tx_packets;
 864         p[2] = net_stats->rx_bytes;
 865         p[3] = net_stats->tx_bytes;
 866         p[4] = net_stats->rx_errors;
 867         p[5] = net_stats->tx_errors;
 868         p[6] = net_stats->rx_dropped;
 869         p[7] = net_stats->tx_dropped;
 870         p[8] = net_stats->multicast;
 871         p[9] = net_stats->collisions;
 872         p[10] = net_stats->rx_over_errors;
 873         p[11] = net_stats->rx_crc_errors;
 874         p[12] = net_stats->rx_frame_errors;
 875         p[13] = net_stats->rx_fifo_errors;
 876         p[14] = net_stats->rx_missed_errors;
 877         p[15] = net_stats->tx_aborted_errors;
 878         p[16] = net_stats->tx_carrier_errors;
 879         p[17] = net_stats->tx_fifo_errors;
 880         p[18] = net_stats->tx_heartbeat_errors;
 881         p[19] = net_stats->rx_length_errors;
 882         p[20] = net_stats->tx_window_errors;
 883         p[21] = net_stats->rx_compressed;
 884         p[22] = net_stats->tx_compressed;
 885
 886         p[23] = netdev->rx_dropped.counter;
 887         p[24] = netdev->tx_dropped.counter;
 888
 889         p[25] = priv->tx_timeout_count;
 890
 891         /* get driver statistics */
 892         h->dev->ops->get_stats(h, &p[26]);
 893 }
 894
 895 /**
 896  * hns_get_strings: Return a set of strings that describe the requested objects
 897  * @netdev: net device
 898  * @stringset: string set ID.
 899  * @data: objects data.
 900  */
 901 static void hns_get_strings(struct net_device *netdev, u32 stringset, u8 *data)
 902 {
 903         struct hns_nic_priv *priv = netdev_priv(netdev);
 904         struct hnae_handle *h = priv->ae_handle;
 905         u8 *buff = data;
 906
 907         if (!h->dev->ops->get_strings) {
 908                 netdev_err(netdev, "h->dev->ops->get_strings is null!\n");
 909                 return;
 910         }
 911
 912         if (stringset == ETH_SS_TEST) {
 913                 if (priv->ae_handle->phy_if != PHY_INTERFACE_MODE_XGMII)
 914                         ethtool_sprintf(&buff,
 915                                         hns_nic_test_strs[MAC_INTERNALLOOP_MAC]);
 916                 ethtool_sprintf(&buff,
 917                                 hns_nic_test_strs[MAC_INTERNALLOOP_SERDES]);
 918                 if ((netdev->phydev) && (!netdev->phydev->is_c45))
 919                         ethtool_sprintf(&buff,
 920                                         hns_nic_test_strs[MAC_INTERNALLOOP_PHY]);
 921
 922         } else {
 923                 ethtool_sprintf(&buff, "rx_packets");
 924                 ethtool_sprintf(&buff, "tx_packets");
 925                 ethtool_sprintf(&buff, "rx_bytes");
 926                 ethtool_sprintf(&buff, "tx_bytes");
 927                 ethtool_sprintf(&buff, "rx_errors");
 928                 ethtool_sprintf(&buff, "tx_errors");
 929                 ethtool_sprintf(&buff, "rx_dropped");
 930                 ethtool_sprintf(&buff, "tx_dropped");
 931                 ethtool_sprintf(&buff, "multicast");
 932                 ethtool_sprintf(&buff, "collisions");
 933                 ethtool_sprintf(&buff, "rx_over_errors");
 934                 ethtool_sprintf(&buff, "rx_crc_errors");
 935                 ethtool_sprintf(&buff, "rx_frame_errors");
 936                 ethtool_sprintf(&buff, "rx_fifo_errors");
 937                 ethtool_sprintf(&buff, "rx_missed_errors");
 938                 ethtool_sprintf(&buff, "tx_aborted_errors");
 939                 ethtool_sprintf(&buff, "tx_carrier_errors");
 940                 ethtool_sprintf(&buff, "tx_fifo_errors");
 941                 ethtool_sprintf(&buff, "tx_heartbeat_errors");
 942                 ethtool_sprintf(&buff, "rx_length_errors");
 943                 ethtool_sprintf(&buff, "tx_window_errors");
 944                 ethtool_sprintf(&buff, "rx_compressed");
 945                 ethtool_sprintf(&buff, "tx_compressed");
 946                 ethtool_sprintf(&buff, "netdev_rx_dropped");
 947                 ethtool_sprintf(&buff, "netdev_tx_dropped");
 948
 949                 ethtool_sprintf(&buff, "netdev_tx_timeout");
 950
 951                 h->dev->ops->get_strings(h, stringset, buff);
 952         }
 953 }
 954
 955 /**
 956  * hns_get_sset_count - get string set count returned by nic_get_strings
 957  * @netdev: net device
 958  * @stringset: string set index, 0: self test string; 1: statistics string.
 959  *
 960  * Return string set count.
 961  */
 962 static int hns_get_sset_count(struct net_device *netdev, int stringset)
 963 {
 964         struct hns_nic_priv *priv = netdev_priv(netdev);
 965         struct hnae_handle *h = priv->ae_handle;
 966         struct hnae_ae_ops *ops = h->dev->ops;
 967
 968         if (!ops->get_sset_count) {
 969                 netdev_err(netdev, "get_sset_count is null!\n");
 970                 return -EOPNOTSUPP;
 971         }
 972         if (stringset == ETH_SS_TEST) {
 973                 u32 cnt = (sizeof(hns_nic_test_strs) / ETH_GSTRING_LEN);
 974
 975                 if (priv->ae_handle->phy_if == PHY_INTERFACE_MODE_XGMII)
 976                         cnt--;
 977
 978                 if ((!netdev->phydev) || (netdev->phydev->is_c45))
 979                         cnt--;
 980
 981                 return cnt;
 982         } else if (stringset == ETH_SS_STATS) {
 983                 return (HNS_NET_STATS_CNT + ops->get_sset_count(h, stringset));
 984         } else {
 985                 return -EOPNOTSUPP;
 986         }
 987 }
 988
 989 /**
 990  * hns_phy_led_set - set phy LED status.
 991  * @netdev: net device
 992  * @value: LED state.
 993  *
 994  * Return 0 on success, negative on failure.
 995  */
 996 static int hns_phy_led_set(struct net_device *netdev, int value)
 997 {
 998         int retval;
 999         struct phy_device *phy_dev = netdev->phydev;
1000
1001         retval = phy_write(phy_dev, HNS_PHY_PAGE_REG, HNS_PHY_PAGE_LED);
1002         retval |= phy_write(phy_dev, HNS_LED_FC_REG, value);
1003         retval |= phy_write(phy_dev, HNS_PHY_PAGE_REG, HNS_PHY_PAGE_COPPER);
1004         if (retval) {
1005                 netdev_err(netdev, "mdiobus_write fail !\n");
1006                 return retval;
1007         }
1008         return 0;
1009 }
1010
1011 /**
1012  * hns_set_phys_id - set phy identify LED.
1013  * @netdev: net device
1014  * @state: LED state.
1015  *
1016  * Return 0 on success, negative on failure.
1017  */
1018 static int
1019 hns_set_phys_id(struct net_device *netdev, enum ethtool_phys_id_state state)
1020 {
1021         struct hns_nic_priv *priv = netdev_priv(netdev);
1022         struct hnae_handle *h = priv->ae_handle;
1023         struct phy_device *phy_dev = netdev->phydev;
1024         int ret;
1025
1026         if (phy_dev)
1027                 switch (state) {
1028                 case ETHTOOL_ID_ACTIVE:
1029                         ret = phy_write(phy_dev, HNS_PHY_PAGE_REG,
1030                                         HNS_PHY_PAGE_LED);
1031                         if (ret)
1032                                 return ret;
1033
1034                         priv->phy_led_val = phy_read(phy_dev, HNS_LED_FC_REG);
1035
1036                         ret = phy_write(phy_dev, HNS_PHY_PAGE_REG,
1037                                         HNS_PHY_PAGE_COPPER);
1038                         if (ret)
1039                                 return ret;
1040                         return 2;
1041                 case ETHTOOL_ID_ON:
1042                         ret = hns_phy_led_set(netdev, HNS_LED_FORCE_ON);
1043                         if (ret)
1044                                 return ret;
1045                         break;
1046                 case ETHTOOL_ID_OFF:
1047                         ret = hns_phy_led_set(netdev, HNS_LED_FORCE_OFF);
1048                         if (ret)
1049                                 return ret;
1050                         break;
1051                 case ETHTOOL_ID_INACTIVE:
1052                         ret = phy_write(phy_dev, HNS_PHY_PAGE_REG,
1053                                         HNS_PHY_PAGE_LED);
1054                         if (ret)
1055                                 return ret;
1056
1057                         ret = phy_write(phy_dev, HNS_LED_FC_REG,
1058                                         priv->phy_led_val);
1059                         if (ret)
1060                                 return ret;
1061
1062                         ret = phy_write(phy_dev, HNS_PHY_PAGE_REG,
1063                                         HNS_PHY_PAGE_COPPER);
1064                         if (ret)
1065                                 return ret;
1066                         break;
1067                 default:
1068                         return -EINVAL;
1069                 }
1070         else
1071                 switch (state) {
1072                 case ETHTOOL_ID_ACTIVE:
1073                         return h->dev->ops->set_led_id(h, HNAE_LED_ACTIVE);
1074                 case ETHTOOL_ID_ON:
1075                         return h->dev->ops->set_led_id(h, HNAE_LED_ON);
1076                 case ETHTOOL_ID_OFF:
1077                         return h->dev->ops->set_led_id(h, HNAE_LED_OFF);
1078                 case ETHTOOL_ID_INACTIVE:
1079                         return h->dev->ops->set_led_id(h, HNAE_LED_INACTIVE);
1080                 default:
1081                         return -EINVAL;
1082                 }
1083
1084         return 0;
1085 }
1086
1087 /**
1088  * hns_get_regs - get net device register
1089  * @net_dev: net device
1090  * @cmd: ethtool cmd
1091  * @data: register data
1092  */
1093 static void hns_get_regs(struct net_device *net_dev, struct ethtool_regs *cmd,
1094                          void *data)
1095 {
1096         struct hns_nic_priv *priv = netdev_priv(net_dev);
1097         struct hnae_ae_ops *ops;
1098
1099         ops = priv->ae_handle->dev->ops;
1100
1101         cmd->version = HNS_CHIP_VERSION;
1102         if (!ops->get_regs) {
1103                 netdev_err(net_dev, "ops->get_regs is null!\n");
1104                 return;
1105         }
1106         ops->get_regs(priv->ae_handle, data);
1107 }
1108
1109 /**
1110  * hns_get_regs_len - get total register len.
1111  * @net_dev: net device
1112  *
1113  * Return total register len.
1114  */
1115 static int hns_get_regs_len(struct net_device *net_dev)
1116 {
1117         u32 reg_num;
1118         struct hns_nic_priv *priv = netdev_priv(net_dev);
1119         struct hnae_ae_ops *ops;
1120
1121         ops = priv->ae_handle->dev->ops;
1122         if (!ops->get_regs_len) {
1123                 netdev_err(net_dev, "ops->get_regs_len is null!\n");
1124                 return -EOPNOTSUPP;
1125         }
1126
1127         reg_num = ops->get_regs_len(priv->ae_handle);
1128         if (reg_num > 0)
1129                 return reg_num * sizeof(u32);
1130         else
1131                 return reg_num; /* error code */
1132 }
1133
1134 /**
1135  * hns_nic_nway_reset - nway reset
1136  * @netdev: net device
1137  *
1138  * Return 0 on success, negative on failure
1139  */
1140 static int hns_nic_nway_reset(struct net_device *netdev)
1141 {
1142         struct phy_device *phy = netdev->phydev;
1143
1144         if (!netif_running(netdev))
1145                 return 0;
1146
1147         if (!phy)
1148                 return -EOPNOTSUPP;
1149
1150         if (phy->autoneg != AUTONEG_ENABLE)
1151                 return -EINVAL;
1152
1153         return genphy_restart_aneg(phy);
1154 }
1155
1156 static u32
1157 hns_get_rss_key_size(struct net_device *netdev)
1158 {
1159         struct hns_nic_priv *priv = netdev_priv(netdev);
1160         struct hnae_ae_ops *ops;
1161
1162         if (AE_IS_VER1(priv->enet_ver)) {
1163                 netdev_err(netdev,
1164                            "RSS feature is not supported on this hardware\n");
1165                 return 0;
1166         }
1167
1168         ops = priv->ae_handle->dev->ops;
1169         return ops->get_rss_key_size(priv->ae_handle);
1170 }
1171
1172 static u32
1173 hns_get_rss_indir_size(struct net_device *netdev)
1174 {
1175         struct hns_nic_priv *priv = netdev_priv(netdev);
1176         struct hnae_ae_ops *ops;
1177
1178         if (AE_IS_VER1(priv->enet_ver)) {
1179                 netdev_err(netdev,
1180                            "RSS feature is not supported on this hardware\n");
1181                 return 0;
1182         }
1183
1184         ops = priv->ae_handle->dev->ops;
1185         return ops->get_rss_indir_size(priv->ae_handle);
1186 }
1187
1188 static int
1189 hns_get_rss(struct net_device *netdev, u32 *indir, u8 *key, u8 *hfunc)
1190 {
1191         struct hns_nic_priv *priv = netdev_priv(netdev);
1192         struct hnae_ae_ops *ops;
1193
1194         if (AE_IS_VER1(priv->enet_ver)) {
1195                 netdev_err(netdev,
1196                            "RSS feature is not supported on this hardware\n");
1197                 return -EOPNOTSUPP;
1198         }
1199
1200         ops = priv->ae_handle->dev->ops;
1201
1202         if (!indir)
1203                 return 0;
1204
1205         return ops->get_rss(priv->ae_handle, indir, key, hfunc);
1206 }
1207
1208 static int
1209 hns_set_rss(struct net_device *netdev, const u32 *indir, const u8 *key,
1210             const u8 hfunc)
1211 {
1212         struct hns_nic_priv *priv = netdev_priv(netdev);
1213         struct hnae_ae_ops *ops;
1214
1215         if (AE_IS_VER1(priv->enet_ver)) {
1216                 netdev_err(netdev,
1217                            "RSS feature is not supported on this hardware\n");
1218                 return -EOPNOTSUPP;
1219         }
1220
1221         ops = priv->ae_handle->dev->ops;
1222
1223         if (hfunc != ETH_RSS_HASH_NO_CHANGE && hfunc != ETH_RSS_HASH_TOP) {
1224                 netdev_err(netdev, "Invalid hfunc!\n");
1225                 return -EOPNOTSUPP;
1226         }
1227
1228         return ops->set_rss(priv->ae_handle, indir, key, hfunc);
1229 }
1230
1231 static int hns_get_rxnfc(struct net_device *netdev,
1232                          struct ethtool_rxnfc *cmd,
1233                          u32 *rule_locs)
1234 {
1235         struct hns_nic_priv *priv = netdev_priv(netdev);
1236
1237         switch (cmd->cmd) {
1238         case ETHTOOL_GRXRINGS:
1239                 cmd->data = priv->ae_handle->q_num;
1240                 break;
1241         default:
1242                 return -EOPNOTSUPP;
1243         }
1244
1245         return 0;
1246 }
1247
1248 static const struct ethtool_ops hns_ethtool_ops = {
1249         .supported_coalesce_params = ETHTOOL_COALESCE_USECS |
1250                                      ETHTOOL_COALESCE_MAX_FRAMES |
1251                                      ETHTOOL_COALESCE_USE_ADAPTIVE |
1252                                      ETHTOOL_COALESCE_USECS_LOW_HIGH |
1253                                      ETHTOOL_COALESCE_MAX_FRAMES_LOW_HIGH,
1254         .get_drvinfo = hns_nic_get_drvinfo,
1255         .get_link  = hns_nic_get_link,
1256         .get_ringparam = hns_get_ringparam,
1257         .get_pauseparam = hns_get_pauseparam,
1258         .set_pauseparam = hns_set_pauseparam,
1259         .get_coalesce = hns_get_coalesce,
1260         .set_coalesce = hns_set_coalesce,
1261         .get_channels = hns_get_channels,
1262         .self_test = hns_nic_self_test,
1263         .get_strings = hns_get_strings,
1264         .get_sset_count = hns_get_sset_count,
1265         .get_ethtool_stats = hns_get_ethtool_stats,
1266         .set_phys_id = hns_set_phys_id,
1267         .get_regs_len = hns_get_regs_len,
1268         .get_regs = hns_get_regs,
1269         .nway_reset = hns_nic_nway_reset,
1270         .get_rxfh_key_size = hns_get_rss_key_size,
1271         .get_rxfh_indir_size = hns_get_rss_indir_size,
1272         .get_rxfh = hns_get_rss,
1273         .set_rxfh = hns_set_rss,
1274         .get_rxnfc = hns_get_rxnfc,
1275         .get_link_ksettings  = hns_nic_get_link_ksettings,
1276         .set_link_ksettings  = hns_nic_set_link_ksettings,
1277 };
1278
1279 void hns_ethtool_set_ops(struct net_device *ndev)
1280 {
1281         ndev->ethtool_ops = &hns_ethtool_ops;
1282 }