linux/drivers/net/ethernet/hisilicon/hns/hns_ethtool.c
<<
>>
Prefs
   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 */
  38static 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
  61static 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 */
 113static 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 */
 200static 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
 251static const char hns_nic_test_strs[][ETH_GSTRING_LEN] = {
 252        "Mac    Loopback test",
 253        "Serdes Loopback test",
 254        "Phy    Loopback test"
 255};
 256
 257static 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
 278out:
 279        return err;
 280}
 281
 282static 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
 334static 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
 370static 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
 445static 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 */
 472static 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
 550static 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 */
 582static 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 */
 642static 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 * @kernel_param: ethtool external parameter
 667 * @extack: netlink extended ACK report struct
 668 */
 669static void hns_get_ringparam(struct net_device *net_dev,
 670                              struct ethtool_ringparam *param,
 671                              struct kernel_ethtool_ringparam *kernel_param,
 672                              struct netlink_ext_ack *extack)
 673{
 674        struct hns_nic_priv *priv = netdev_priv(net_dev);
 675        struct hnae_ae_ops *ops;
 676        struct hnae_queue *queue;
 677        u32 uplimit = 0;
 678
 679        queue = priv->ae_handle->qs[0];
 680        ops = priv->ae_handle->dev->ops;
 681
 682        if (ops->get_ring_bdnum_limit)
 683                ops->get_ring_bdnum_limit(queue, &uplimit);
 684
 685        param->rx_max_pending = uplimit;
 686        param->tx_max_pending = uplimit;
 687        param->rx_pending = queue->rx_ring.desc_num;
 688        param->tx_pending = queue->tx_ring.desc_num;
 689}
 690
 691/**
 692 * hns_get_pauseparam - get pause parameter
 693 * @net_dev: net device
 694 * @param: pause parameter
 695 */
 696static void hns_get_pauseparam(struct net_device *net_dev,
 697                               struct ethtool_pauseparam *param)
 698{
 699        struct hns_nic_priv *priv = netdev_priv(net_dev);
 700        struct hnae_ae_ops *ops;
 701
 702        ops = priv->ae_handle->dev->ops;
 703
 704        if (ops->get_pauseparam)
 705                ops->get_pauseparam(priv->ae_handle, &param->autoneg,
 706                                            &param->rx_pause, &param->tx_pause);
 707}
 708
 709/**
 710 * hns_set_pauseparam - set pause parameter
 711 * @net_dev: net device
 712 * @param: pause parameter
 713 *
 714 * Return 0 on success, negative on failure
 715 */
 716static int hns_set_pauseparam(struct net_device *net_dev,
 717                              struct ethtool_pauseparam *param)
 718{
 719        struct hns_nic_priv *priv = netdev_priv(net_dev);
 720        struct hnae_handle *h;
 721        struct hnae_ae_ops *ops;
 722
 723        h = priv->ae_handle;
 724        ops = h->dev->ops;
 725
 726        if (!ops->set_pauseparam)
 727                return -ESRCH;
 728
 729        return ops->set_pauseparam(priv->ae_handle, param->autoneg,
 730                                   param->rx_pause, param->tx_pause);
 731}
 732
 733/**
 734 * hns_get_coalesce - get coalesce info.
 735 * @net_dev: net device
 736 * @ec: coalesce info.
 737 * @kernel_coal: ethtool CQE mode setting structure
 738 * @extack: extack for reporting error messages
 739 *
 740 * Return 0 on success, negative on failure.
 741 */
 742static int hns_get_coalesce(struct net_device *net_dev,
 743                            struct ethtool_coalesce *ec,
 744                            struct kernel_ethtool_coalesce *kernel_coal,
 745                            struct netlink_ext_ack *extack)
 746{
 747        struct hns_nic_priv *priv = netdev_priv(net_dev);
 748        struct hnae_ae_ops *ops;
 749
 750        ops = priv->ae_handle->dev->ops;
 751
 752        ec->use_adaptive_rx_coalesce = priv->ae_handle->coal_adapt_en;
 753        ec->use_adaptive_tx_coalesce = priv->ae_handle->coal_adapt_en;
 754
 755        if ((!ops->get_coalesce_usecs) ||
 756            (!ops->get_max_coalesced_frames))
 757                return -ESRCH;
 758
 759        ops->get_coalesce_usecs(priv->ae_handle,
 760                                        &ec->tx_coalesce_usecs,
 761                                        &ec->rx_coalesce_usecs);
 762
 763        ops->get_max_coalesced_frames(
 764                priv->ae_handle,
 765                &ec->tx_max_coalesced_frames,
 766                &ec->rx_max_coalesced_frames);
 767
 768        ops->get_coalesce_range(priv->ae_handle,
 769                                &ec->tx_max_coalesced_frames_low,
 770                                &ec->rx_max_coalesced_frames_low,
 771                                &ec->tx_max_coalesced_frames_high,
 772                                &ec->rx_max_coalesced_frames_high,
 773                                &ec->tx_coalesce_usecs_low,
 774                                &ec->rx_coalesce_usecs_low,
 775                                &ec->tx_coalesce_usecs_high,
 776                                &ec->rx_coalesce_usecs_high);
 777
 778        return 0;
 779}
 780
 781/**
 782 * hns_set_coalesce - set coalesce info.
 783 * @net_dev: net device
 784 * @ec: coalesce info.
 785 * @kernel_coal: ethtool CQE mode setting structure
 786 * @extack: extack for reporting error messages
 787 *
 788 * Return 0 on success, negative on failure.
 789 */
 790static int hns_set_coalesce(struct net_device *net_dev,
 791                            struct ethtool_coalesce *ec,
 792                            struct kernel_ethtool_coalesce *kernel_coal,
 793                            struct netlink_ext_ack *extack)
 794{
 795        struct hns_nic_priv *priv = netdev_priv(net_dev);
 796        struct hnae_ae_ops *ops;
 797        int rc1, rc2;
 798
 799        ops = priv->ae_handle->dev->ops;
 800
 801        if (ec->tx_coalesce_usecs != ec->rx_coalesce_usecs)
 802                return -EINVAL;
 803
 804        if ((!ops->set_coalesce_usecs) ||
 805            (!ops->set_coalesce_frames))
 806                return -ESRCH;
 807
 808        if (ec->use_adaptive_rx_coalesce != priv->ae_handle->coal_adapt_en)
 809                priv->ae_handle->coal_adapt_en = ec->use_adaptive_rx_coalesce;
 810
 811        rc1 = ops->set_coalesce_usecs(priv->ae_handle,
 812                                      ec->rx_coalesce_usecs);
 813
 814        rc2 = ops->set_coalesce_frames(priv->ae_handle,
 815                                       ec->tx_max_coalesced_frames,
 816                                       ec->rx_max_coalesced_frames);
 817
 818        if (rc1 || rc2)
 819                return -EINVAL;
 820
 821        return 0;
 822}
 823
 824/**
 825 * hns_get_channels - get channel info.
 826 * @net_dev: net device
 827 * @ch: channel info.
 828 */
 829static void
 830hns_get_channels(struct net_device *net_dev, struct ethtool_channels *ch)
 831{
 832        struct hns_nic_priv *priv = netdev_priv(net_dev);
 833
 834        ch->max_rx = priv->ae_handle->q_num;
 835        ch->max_tx = priv->ae_handle->q_num;
 836
 837        ch->rx_count = priv->ae_handle->q_num;
 838        ch->tx_count = priv->ae_handle->q_num;
 839}
 840
 841/**
 842 * hns_get_ethtool_stats - get detail statistics.
 843 * @netdev: net device
 844 * @stats: statistics info.
 845 * @data: statistics data.
 846 */
 847static void hns_get_ethtool_stats(struct net_device *netdev,
 848                                  struct ethtool_stats *stats, u64 *data)
 849{
 850        u64 *p = data;
 851        struct hns_nic_priv *priv = netdev_priv(netdev);
 852        struct hnae_handle *h = priv->ae_handle;
 853        const struct rtnl_link_stats64 *net_stats;
 854        struct rtnl_link_stats64 temp;
 855
 856        if (!h->dev->ops->get_stats || !h->dev->ops->update_stats) {
 857                netdev_err(netdev, "get_stats or update_stats is null!\n");
 858                return;
 859        }
 860
 861        h->dev->ops->update_stats(h, &netdev->stats);
 862
 863        net_stats = dev_get_stats(netdev, &temp);
 864
 865        /* get netdev statistics */
 866        p[0] = net_stats->rx_packets;
 867        p[1] = net_stats->tx_packets;
 868        p[2] = net_stats->rx_bytes;
 869        p[3] = net_stats->tx_bytes;
 870        p[4] = net_stats->rx_errors;
 871        p[5] = net_stats->tx_errors;
 872        p[6] = net_stats->rx_dropped;
 873        p[7] = net_stats->tx_dropped;
 874        p[8] = net_stats->multicast;
 875        p[9] = net_stats->collisions;
 876        p[10] = net_stats->rx_over_errors;
 877        p[11] = net_stats->rx_crc_errors;
 878        p[12] = net_stats->rx_frame_errors;
 879        p[13] = net_stats->rx_fifo_errors;
 880        p[14] = net_stats->rx_missed_errors;
 881        p[15] = net_stats->tx_aborted_errors;
 882        p[16] = net_stats->tx_carrier_errors;
 883        p[17] = net_stats->tx_fifo_errors;
 884        p[18] = net_stats->tx_heartbeat_errors;
 885        p[19] = net_stats->rx_length_errors;
 886        p[20] = net_stats->tx_window_errors;
 887        p[21] = net_stats->rx_compressed;
 888        p[22] = net_stats->tx_compressed;
 889
 890        p[23] = netdev->rx_dropped.counter;
 891        p[24] = netdev->tx_dropped.counter;
 892
 893        p[25] = priv->tx_timeout_count;
 894
 895        /* get driver statistics */
 896        h->dev->ops->get_stats(h, &p[26]);
 897}
 898
 899/**
 900 * hns_get_strings: Return a set of strings that describe the requested objects
 901 * @netdev: net device
 902 * @stringset: string set ID.
 903 * @data: objects data.
 904 */
 905static void hns_get_strings(struct net_device *netdev, u32 stringset, u8 *data)
 906{
 907        struct hns_nic_priv *priv = netdev_priv(netdev);
 908        struct hnae_handle *h = priv->ae_handle;
 909        u8 *buff = data;
 910
 911        if (!h->dev->ops->get_strings) {
 912                netdev_err(netdev, "h->dev->ops->get_strings is null!\n");
 913                return;
 914        }
 915
 916        if (stringset == ETH_SS_TEST) {
 917                if (priv->ae_handle->phy_if != PHY_INTERFACE_MODE_XGMII)
 918                        ethtool_sprintf(&buff,
 919                                        hns_nic_test_strs[MAC_INTERNALLOOP_MAC]);
 920                ethtool_sprintf(&buff,
 921                                hns_nic_test_strs[MAC_INTERNALLOOP_SERDES]);
 922                if ((netdev->phydev) && (!netdev->phydev->is_c45))
 923                        ethtool_sprintf(&buff,
 924                                        hns_nic_test_strs[MAC_INTERNALLOOP_PHY]);
 925
 926        } else {
 927                ethtool_sprintf(&buff, "rx_packets");
 928                ethtool_sprintf(&buff, "tx_packets");
 929                ethtool_sprintf(&buff, "rx_bytes");
 930                ethtool_sprintf(&buff, "tx_bytes");
 931                ethtool_sprintf(&buff, "rx_errors");
 932                ethtool_sprintf(&buff, "tx_errors");
 933                ethtool_sprintf(&buff, "rx_dropped");
 934                ethtool_sprintf(&buff, "tx_dropped");
 935                ethtool_sprintf(&buff, "multicast");
 936                ethtool_sprintf(&buff, "collisions");
 937                ethtool_sprintf(&buff, "rx_over_errors");
 938                ethtool_sprintf(&buff, "rx_crc_errors");
 939                ethtool_sprintf(&buff, "rx_frame_errors");
 940                ethtool_sprintf(&buff, "rx_fifo_errors");
 941                ethtool_sprintf(&buff, "rx_missed_errors");
 942                ethtool_sprintf(&buff, "tx_aborted_errors");
 943                ethtool_sprintf(&buff, "tx_carrier_errors");
 944                ethtool_sprintf(&buff, "tx_fifo_errors");
 945                ethtool_sprintf(&buff, "tx_heartbeat_errors");
 946                ethtool_sprintf(&buff, "rx_length_errors");
 947                ethtool_sprintf(&buff, "tx_window_errors");
 948                ethtool_sprintf(&buff, "rx_compressed");
 949                ethtool_sprintf(&buff, "tx_compressed");
 950                ethtool_sprintf(&buff, "netdev_rx_dropped");
 951                ethtool_sprintf(&buff, "netdev_tx_dropped");
 952
 953                ethtool_sprintf(&buff, "netdev_tx_timeout");
 954
 955                h->dev->ops->get_strings(h, stringset, buff);
 956        }
 957}
 958
 959/**
 960 * hns_get_sset_count - get string set count returned by nic_get_strings
 961 * @netdev: net device
 962 * @stringset: string set index, 0: self test string; 1: statistics string.
 963 *
 964 * Return string set count.
 965 */
 966static int hns_get_sset_count(struct net_device *netdev, int stringset)
 967{
 968        struct hns_nic_priv *priv = netdev_priv(netdev);
 969        struct hnae_handle *h = priv->ae_handle;
 970        struct hnae_ae_ops *ops = h->dev->ops;
 971
 972        if (!ops->get_sset_count) {
 973                netdev_err(netdev, "get_sset_count is null!\n");
 974                return -EOPNOTSUPP;
 975        }
 976        if (stringset == ETH_SS_TEST) {
 977                u32 cnt = (sizeof(hns_nic_test_strs) / ETH_GSTRING_LEN);
 978
 979                if (priv->ae_handle->phy_if == PHY_INTERFACE_MODE_XGMII)
 980                        cnt--;
 981
 982                if ((!netdev->phydev) || (netdev->phydev->is_c45))
 983                        cnt--;
 984
 985                return cnt;
 986        } else if (stringset == ETH_SS_STATS) {
 987                return (HNS_NET_STATS_CNT + ops->get_sset_count(h, stringset));
 988        } else {
 989                return -EOPNOTSUPP;
 990        }
 991}
 992
 993/**
 994 * hns_phy_led_set - set phy LED status.
 995 * @netdev: net device
 996 * @value: LED state.
 997 *
 998 * Return 0 on success, negative on failure.
 999 */
1000static int hns_phy_led_set(struct net_device *netdev, int value)
1001{
1002        int retval;
1003        struct phy_device *phy_dev = netdev->phydev;
1004
1005        retval = phy_write(phy_dev, HNS_PHY_PAGE_REG, HNS_PHY_PAGE_LED);
1006        retval |= phy_write(phy_dev, HNS_LED_FC_REG, value);
1007        retval |= phy_write(phy_dev, HNS_PHY_PAGE_REG, HNS_PHY_PAGE_COPPER);
1008        if (retval) {
1009                netdev_err(netdev, "mdiobus_write fail !\n");
1010                return retval;
1011        }
1012        return 0;
1013}
1014
1015/**
1016 * hns_set_phys_id - set phy identify LED.
1017 * @netdev: net device
1018 * @state: LED state.
1019 *
1020 * Return 0 on success, negative on failure.
1021 */
1022static int
1023hns_set_phys_id(struct net_device *netdev, enum ethtool_phys_id_state state)
1024{
1025        struct hns_nic_priv *priv = netdev_priv(netdev);
1026        struct hnae_handle *h = priv->ae_handle;
1027        struct phy_device *phy_dev = netdev->phydev;
1028        int ret;
1029
1030        if (phy_dev)
1031                switch (state) {
1032                case ETHTOOL_ID_ACTIVE:
1033                        ret = phy_write(phy_dev, HNS_PHY_PAGE_REG,
1034                                        HNS_PHY_PAGE_LED);
1035                        if (ret)
1036                                return ret;
1037
1038                        priv->phy_led_val = phy_read(phy_dev, HNS_LED_FC_REG);
1039
1040                        ret = phy_write(phy_dev, HNS_PHY_PAGE_REG,
1041                                        HNS_PHY_PAGE_COPPER);
1042                        if (ret)
1043                                return ret;
1044                        return 2;
1045                case ETHTOOL_ID_ON:
1046                        ret = hns_phy_led_set(netdev, HNS_LED_FORCE_ON);
1047                        if (ret)
1048                                return ret;
1049                        break;
1050                case ETHTOOL_ID_OFF:
1051                        ret = hns_phy_led_set(netdev, HNS_LED_FORCE_OFF);
1052                        if (ret)
1053                                return ret;
1054                        break;
1055                case ETHTOOL_ID_INACTIVE:
1056                        ret = phy_write(phy_dev, HNS_PHY_PAGE_REG,
1057                                        HNS_PHY_PAGE_LED);
1058                        if (ret)
1059                                return ret;
1060
1061                        ret = phy_write(phy_dev, HNS_LED_FC_REG,
1062                                        priv->phy_led_val);
1063                        if (ret)
1064                                return ret;
1065
1066                        ret = phy_write(phy_dev, HNS_PHY_PAGE_REG,
1067                                        HNS_PHY_PAGE_COPPER);
1068                        if (ret)
1069                                return ret;
1070                        break;
1071                default:
1072                        return -EINVAL;
1073                }
1074        else
1075                switch (state) {
1076                case ETHTOOL_ID_ACTIVE:
1077                        return h->dev->ops->set_led_id(h, HNAE_LED_ACTIVE);
1078                case ETHTOOL_ID_ON:
1079                        return h->dev->ops->set_led_id(h, HNAE_LED_ON);
1080                case ETHTOOL_ID_OFF:
1081                        return h->dev->ops->set_led_id(h, HNAE_LED_OFF);
1082                case ETHTOOL_ID_INACTIVE:
1083                        return h->dev->ops->set_led_id(h, HNAE_LED_INACTIVE);
1084                default:
1085                        return -EINVAL;
1086                }
1087
1088        return 0;
1089}
1090
1091/**
1092 * hns_get_regs - get net device register
1093 * @net_dev: net device
1094 * @cmd: ethtool cmd
1095 * @data: register data
1096 */
1097static void hns_get_regs(struct net_device *net_dev, struct ethtool_regs *cmd,
1098                         void *data)
1099{
1100        struct hns_nic_priv *priv = netdev_priv(net_dev);
1101        struct hnae_ae_ops *ops;
1102
1103        ops = priv->ae_handle->dev->ops;
1104
1105        cmd->version = HNS_CHIP_VERSION;
1106        if (!ops->get_regs) {
1107                netdev_err(net_dev, "ops->get_regs is null!\n");
1108                return;
1109        }
1110        ops->get_regs(priv->ae_handle, data);
1111}
1112
1113/**
1114 * hns_get_regs_len - get total register len.
1115 * @net_dev: net device
1116 *
1117 * Return total register len.
1118 */
1119static int hns_get_regs_len(struct net_device *net_dev)
1120{
1121        u32 reg_num;
1122        struct hns_nic_priv *priv = netdev_priv(net_dev);
1123        struct hnae_ae_ops *ops;
1124
1125        ops = priv->ae_handle->dev->ops;
1126        if (!ops->get_regs_len) {
1127                netdev_err(net_dev, "ops->get_regs_len is null!\n");
1128                return -EOPNOTSUPP;
1129        }
1130
1131        reg_num = ops->get_regs_len(priv->ae_handle);
1132        if (reg_num > 0)
1133                return reg_num * sizeof(u32);
1134        else
1135                return reg_num; /* error code */
1136}
1137
1138/**
1139 * hns_nic_nway_reset - nway reset
1140 * @netdev: net device
1141 *
1142 * Return 0 on success, negative on failure
1143 */
1144static int hns_nic_nway_reset(struct net_device *netdev)
1145{
1146        struct phy_device *phy = netdev->phydev;
1147
1148        if (!netif_running(netdev))
1149                return 0;
1150
1151        if (!phy)
1152                return -EOPNOTSUPP;
1153
1154        if (phy->autoneg != AUTONEG_ENABLE)
1155                return -EINVAL;
1156
1157        return genphy_restart_aneg(phy);
1158}
1159
1160static u32
1161hns_get_rss_key_size(struct net_device *netdev)
1162{
1163        struct hns_nic_priv *priv = netdev_priv(netdev);
1164        struct hnae_ae_ops *ops;
1165
1166        if (AE_IS_VER1(priv->enet_ver)) {
1167                netdev_err(netdev,
1168                           "RSS feature is not supported on this hardware\n");
1169                return 0;
1170        }
1171
1172        ops = priv->ae_handle->dev->ops;
1173        return ops->get_rss_key_size(priv->ae_handle);
1174}
1175
1176static u32
1177hns_get_rss_indir_size(struct net_device *netdev)
1178{
1179        struct hns_nic_priv *priv = netdev_priv(netdev);
1180        struct hnae_ae_ops *ops;
1181
1182        if (AE_IS_VER1(priv->enet_ver)) {
1183                netdev_err(netdev,
1184                           "RSS feature is not supported on this hardware\n");
1185                return 0;
1186        }
1187
1188        ops = priv->ae_handle->dev->ops;
1189        return ops->get_rss_indir_size(priv->ae_handle);
1190}
1191
1192static int
1193hns_get_rss(struct net_device *netdev, u32 *indir, u8 *key, u8 *hfunc)
1194{
1195        struct hns_nic_priv *priv = netdev_priv(netdev);
1196        struct hnae_ae_ops *ops;
1197
1198        if (AE_IS_VER1(priv->enet_ver)) {
1199                netdev_err(netdev,
1200                           "RSS feature is not supported on this hardware\n");
1201                return -EOPNOTSUPP;
1202        }
1203
1204        ops = priv->ae_handle->dev->ops;
1205
1206        if (!indir)
1207                return 0;
1208
1209        return ops->get_rss(priv->ae_handle, indir, key, hfunc);
1210}
1211
1212static int
1213hns_set_rss(struct net_device *netdev, const u32 *indir, const u8 *key,
1214            const u8 hfunc)
1215{
1216        struct hns_nic_priv *priv = netdev_priv(netdev);
1217        struct hnae_ae_ops *ops;
1218
1219        if (AE_IS_VER1(priv->enet_ver)) {
1220                netdev_err(netdev,
1221                           "RSS feature is not supported on this hardware\n");
1222                return -EOPNOTSUPP;
1223        }
1224
1225        ops = priv->ae_handle->dev->ops;
1226
1227        if (hfunc != ETH_RSS_HASH_NO_CHANGE && hfunc != ETH_RSS_HASH_TOP) {
1228                netdev_err(netdev, "Invalid hfunc!\n");
1229                return -EOPNOTSUPP;
1230        }
1231
1232        return ops->set_rss(priv->ae_handle, indir, key, hfunc);
1233}
1234
1235static int hns_get_rxnfc(struct net_device *netdev,
1236                         struct ethtool_rxnfc *cmd,
1237                         u32 *rule_locs)
1238{
1239        struct hns_nic_priv *priv = netdev_priv(netdev);
1240
1241        switch (cmd->cmd) {
1242        case ETHTOOL_GRXRINGS:
1243                cmd->data = priv->ae_handle->q_num;
1244                break;
1245        default:
1246                return -EOPNOTSUPP;
1247        }
1248
1249        return 0;
1250}
1251
1252static const struct ethtool_ops hns_ethtool_ops = {
1253        .supported_coalesce_params = ETHTOOL_COALESCE_USECS |
1254                                     ETHTOOL_COALESCE_MAX_FRAMES |
1255                                     ETHTOOL_COALESCE_USE_ADAPTIVE |
1256                                     ETHTOOL_COALESCE_USECS_LOW_HIGH |
1257                                     ETHTOOL_COALESCE_MAX_FRAMES_LOW_HIGH,
1258        .get_drvinfo = hns_nic_get_drvinfo,
1259        .get_link  = hns_nic_get_link,
1260        .get_ringparam = hns_get_ringparam,
1261        .get_pauseparam = hns_get_pauseparam,
1262        .set_pauseparam = hns_set_pauseparam,
1263        .get_coalesce = hns_get_coalesce,
1264        .set_coalesce = hns_set_coalesce,
1265        .get_channels = hns_get_channels,
1266        .self_test = hns_nic_self_test,
1267        .get_strings = hns_get_strings,
1268        .get_sset_count = hns_get_sset_count,
1269        .get_ethtool_stats = hns_get_ethtool_stats,
1270        .set_phys_id = hns_set_phys_id,
1271        .get_regs_len = hns_get_regs_len,
1272        .get_regs = hns_get_regs,
1273        .nway_reset = hns_nic_nway_reset,
1274        .get_rxfh_key_size = hns_get_rss_key_size,
1275        .get_rxfh_indir_size = hns_get_rss_indir_size,
1276        .get_rxfh = hns_get_rss,
1277        .set_rxfh = hns_set_rss,
1278        .get_rxnfc = hns_get_rxnfc,
1279        .get_link_ksettings  = hns_nic_get_link_ksettings,
1280        .set_link_ksettings  = hns_nic_set_link_ksettings,
1281};
1282
1283void hns_ethtool_set_ops(struct net_device *ndev)
1284{
1285        ndev->ethtool_ops = &hns_ethtool_ops;
1286}
1287