drivers/net/ethernet/qlogic/qede/qede_ethtool.c

   1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause)
   2 /* QLogic qede NIC Driver
   3  * Copyright (c) 2015-2017  QLogic Corporation
   4  * Copyright (c) 2019-2020 Marvell International Ltd.
   5  */
   6
   7 #include <linux/types.h>
   8 #include <linux/netdevice.h>
   9 #include <linux/etherdevice.h>
  10 #include <linux/ethtool.h>
  11 #include <linux/string.h>
  12 #include <linux/pci.h>
  13 #include <linux/capability.h>
  14 #include <linux/vmalloc.h>
  15 #include <linux/phylink.h>
  16
  17 #include "qede.h"
  18 #include "qede_ptp.h"
  19
  20 #define QEDE_RQSTAT_OFFSET(stat_name) \
  21          (offsetof(struct qede_rx_queue, stat_name))
  22 #define QEDE_RQSTAT_STRING(stat_name) (#stat_name)
  23 #define QEDE_RQSTAT(stat_name) \
  24          {QEDE_RQSTAT_OFFSET(stat_name), QEDE_RQSTAT_STRING(stat_name)}
  25
  26 #define QEDE_SELFTEST_POLL_COUNT 100
  27 #define QEDE_DUMP_VERSION       0x1
  28 #define QEDE_DUMP_NVM_ARG_COUNT 2
  29
  30 static const struct {
  31         u64 offset;
  32         char string[ETH_GSTRING_LEN];
  33 } qede_rqstats_arr[] = {
  34         QEDE_RQSTAT(rcv_pkts),
  35         QEDE_RQSTAT(rx_hw_errors),
  36         QEDE_RQSTAT(rx_alloc_errors),
  37         QEDE_RQSTAT(rx_ip_frags),
  38         QEDE_RQSTAT(xdp_no_pass),
  39 };
  40
  41 #define QEDE_NUM_RQSTATS ARRAY_SIZE(qede_rqstats_arr)
  42 #define QEDE_TQSTAT_OFFSET(stat_name) \
  43         (offsetof(struct qede_tx_queue, stat_name))
  44 #define QEDE_TQSTAT_STRING(stat_name) (#stat_name)
  45 #define QEDE_TQSTAT(stat_name) \
  46         {QEDE_TQSTAT_OFFSET(stat_name), QEDE_TQSTAT_STRING(stat_name)}
  47 #define QEDE_NUM_TQSTATS ARRAY_SIZE(qede_tqstats_arr)
  48 static const struct {
  49         u64 offset;
  50         char string[ETH_GSTRING_LEN];
  51 } qede_tqstats_arr[] = {
  52         QEDE_TQSTAT(xmit_pkts),
  53         QEDE_TQSTAT(stopped_cnt),
  54         QEDE_TQSTAT(tx_mem_alloc_err),
  55 };
  56
  57 #define QEDE_STAT_OFFSET(stat_name, type, base) \
  58         (offsetof(type, stat_name) + (base))
  59 #define QEDE_STAT_STRING(stat_name)     (#stat_name)
  60 #define _QEDE_STAT(stat_name, type, base, attr) \
  61         {QEDE_STAT_OFFSET(stat_name, type, base), \
  62          QEDE_STAT_STRING(stat_name), \
  63          attr}
  64 #define QEDE_STAT(stat_name) \
  65         _QEDE_STAT(stat_name, struct qede_stats_common, 0, 0x0)
  66 #define QEDE_PF_STAT(stat_name) \
  67         _QEDE_STAT(stat_name, struct qede_stats_common, 0, \
  68                    BIT(QEDE_STAT_PF_ONLY))
  69 #define QEDE_PF_BB_STAT(stat_name) \
  70         _QEDE_STAT(stat_name, struct qede_stats_bb, \
  71                    offsetof(struct qede_stats, bb), \
  72                    BIT(QEDE_STAT_PF_ONLY) | BIT(QEDE_STAT_BB_ONLY))
  73 #define QEDE_PF_AH_STAT(stat_name) \
  74         _QEDE_STAT(stat_name, struct qede_stats_ah, \
  75                    offsetof(struct qede_stats, ah), \
  76                    BIT(QEDE_STAT_PF_ONLY) | BIT(QEDE_STAT_AH_ONLY))
  77 static const struct {
  78         u64 offset;
  79         char string[ETH_GSTRING_LEN];
  80         unsigned long attr;
  81 #define QEDE_STAT_PF_ONLY       0
  82 #define QEDE_STAT_BB_ONLY       1
  83 #define QEDE_STAT_AH_ONLY       2
  84 } qede_stats_arr[] = {
  85         QEDE_STAT(rx_ucast_bytes),
  86         QEDE_STAT(rx_mcast_bytes),
  87         QEDE_STAT(rx_bcast_bytes),
  88         QEDE_STAT(rx_ucast_pkts),
  89         QEDE_STAT(rx_mcast_pkts),
  90         QEDE_STAT(rx_bcast_pkts),
  91
  92         QEDE_STAT(tx_ucast_bytes),
  93         QEDE_STAT(tx_mcast_bytes),
  94         QEDE_STAT(tx_bcast_bytes),
  95         QEDE_STAT(tx_ucast_pkts),
  96         QEDE_STAT(tx_mcast_pkts),
  97         QEDE_STAT(tx_bcast_pkts),
  98
  99         QEDE_PF_STAT(rx_64_byte_packets),
 100         QEDE_PF_STAT(rx_65_to_127_byte_packets),
 101         QEDE_PF_STAT(rx_128_to_255_byte_packets),
 102         QEDE_PF_STAT(rx_256_to_511_byte_packets),
 103         QEDE_PF_STAT(rx_512_to_1023_byte_packets),
 104         QEDE_PF_STAT(rx_1024_to_1518_byte_packets),
 105         QEDE_PF_BB_STAT(rx_1519_to_1522_byte_packets),
 106         QEDE_PF_BB_STAT(rx_1519_to_2047_byte_packets),
 107         QEDE_PF_BB_STAT(rx_2048_to_4095_byte_packets),
 108         QEDE_PF_BB_STAT(rx_4096_to_9216_byte_packets),
 109         QEDE_PF_BB_STAT(rx_9217_to_16383_byte_packets),
 110         QEDE_PF_AH_STAT(rx_1519_to_max_byte_packets),
 111         QEDE_PF_STAT(tx_64_byte_packets),
 112         QEDE_PF_STAT(tx_65_to_127_byte_packets),
 113         QEDE_PF_STAT(tx_128_to_255_byte_packets),
 114         QEDE_PF_STAT(tx_256_to_511_byte_packets),
 115         QEDE_PF_STAT(tx_512_to_1023_byte_packets),
 116         QEDE_PF_STAT(tx_1024_to_1518_byte_packets),
 117         QEDE_PF_BB_STAT(tx_1519_to_2047_byte_packets),
 118         QEDE_PF_BB_STAT(tx_2048_to_4095_byte_packets),
 119         QEDE_PF_BB_STAT(tx_4096_to_9216_byte_packets),
 120         QEDE_PF_BB_STAT(tx_9217_to_16383_byte_packets),
 121         QEDE_PF_AH_STAT(tx_1519_to_max_byte_packets),
 122         QEDE_PF_STAT(rx_mac_crtl_frames),
 123         QEDE_PF_STAT(tx_mac_ctrl_frames),
 124         QEDE_PF_STAT(rx_pause_frames),
 125         QEDE_PF_STAT(tx_pause_frames),
 126         QEDE_PF_STAT(rx_pfc_frames),
 127         QEDE_PF_STAT(tx_pfc_frames),
 128
 129         QEDE_PF_STAT(rx_crc_errors),
 130         QEDE_PF_STAT(rx_align_errors),
 131         QEDE_PF_STAT(rx_carrier_errors),
 132         QEDE_PF_STAT(rx_oversize_packets),
 133         QEDE_PF_STAT(rx_jabbers),
 134         QEDE_PF_STAT(rx_undersize_packets),
 135         QEDE_PF_STAT(rx_fragments),
 136         QEDE_PF_BB_STAT(tx_lpi_entry_count),
 137         QEDE_PF_BB_STAT(tx_total_collisions),
 138         QEDE_PF_STAT(brb_truncates),
 139         QEDE_PF_STAT(brb_discards),
 140         QEDE_STAT(no_buff_discards),
 141         QEDE_PF_STAT(mftag_filter_discards),
 142         QEDE_PF_STAT(mac_filter_discards),
 143         QEDE_PF_STAT(gft_filter_drop),
 144         QEDE_STAT(tx_err_drop_pkts),
 145         QEDE_STAT(ttl0_discard),
 146         QEDE_STAT(packet_too_big_discard),
 147
 148         QEDE_STAT(coalesced_pkts),
 149         QEDE_STAT(coalesced_events),
 150         QEDE_STAT(coalesced_aborts_num),
 151         QEDE_STAT(non_coalesced_pkts),
 152         QEDE_STAT(coalesced_bytes),
 153
 154         QEDE_STAT(link_change_count),
 155         QEDE_STAT(ptp_skip_txts),
 156 };
 157
 158 #define QEDE_NUM_STATS  ARRAY_SIZE(qede_stats_arr)
 159 #define QEDE_STAT_IS_PF_ONLY(i) \
 160         test_bit(QEDE_STAT_PF_ONLY, &qede_stats_arr[i].attr)
 161 #define QEDE_STAT_IS_BB_ONLY(i) \
 162         test_bit(QEDE_STAT_BB_ONLY, &qede_stats_arr[i].attr)
 163 #define QEDE_STAT_IS_AH_ONLY(i) \
 164         test_bit(QEDE_STAT_AH_ONLY, &qede_stats_arr[i].attr)
 165
 166 enum {
 167         QEDE_PRI_FLAG_CMT,
 168         QEDE_PRI_FLAG_SMART_AN_SUPPORT, /* MFW supports SmartAN */
 169         QEDE_PRI_FLAG_RECOVER_ON_ERROR,
 170         QEDE_PRI_FLAG_ESL_SUPPORT, /* MFW supports Enhanced System Lockdown */
 171         QEDE_PRI_FLAG_ESL_ACTIVE, /* Enhanced System Lockdown Active status */
 172         QEDE_PRI_FLAG_LEN,
 173 };
 174
 175 static const char qede_private_arr[QEDE_PRI_FLAG_LEN][ETH_GSTRING_LEN] = {
 176         "Coupled-Function",
 177         "SmartAN capable",
 178         "Recover on error",
 179         "ESL capable",
 180         "ESL active",
 181 };
 182
 183 enum qede_ethtool_tests {
 184         QEDE_ETHTOOL_INT_LOOPBACK,
 185         QEDE_ETHTOOL_INTERRUPT_TEST,
 186         QEDE_ETHTOOL_MEMORY_TEST,
 187         QEDE_ETHTOOL_REGISTER_TEST,
 188         QEDE_ETHTOOL_CLOCK_TEST,
 189         QEDE_ETHTOOL_NVRAM_TEST,
 190         QEDE_ETHTOOL_TEST_MAX
 191 };
 192
 193 static const char qede_tests_str_arr[QEDE_ETHTOOL_TEST_MAX][ETH_GSTRING_LEN] = {
 194         "Internal loopback (offline)",
 195         "Interrupt (online)\t",
 196         "Memory (online)\t\t",
 197         "Register (online)\t",
 198         "Clock (online)\t\t",
 199         "Nvram (online)\t\t",
 200 };
 201
 202 /* Forced speed capabilities maps */
 203
 204 static const u32 qede_forced_speed_1000[] __initconst = {
 205         ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
 206         ETHTOOL_LINK_MODE_1000baseKX_Full_BIT,
 207         ETHTOOL_LINK_MODE_1000baseX_Full_BIT,
 208 };
 209
 210 static const u32 qede_forced_speed_10000[] __initconst = {
 211         ETHTOOL_LINK_MODE_10000baseT_Full_BIT,
 212         ETHTOOL_LINK_MODE_10000baseKR_Full_BIT,
 213         ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT,
 214         ETHTOOL_LINK_MODE_10000baseR_FEC_BIT,
 215         ETHTOOL_LINK_MODE_10000baseCR_Full_BIT,
 216         ETHTOOL_LINK_MODE_10000baseSR_Full_BIT,
 217         ETHTOOL_LINK_MODE_10000baseLR_Full_BIT,
 218         ETHTOOL_LINK_MODE_10000baseLRM_Full_BIT,
 219 };
 220
 221 static const u32 qede_forced_speed_20000[] __initconst = {
 222         ETHTOOL_LINK_MODE_20000baseKR2_Full_BIT,
 223 };
 224
 225 static const u32 qede_forced_speed_25000[] __initconst = {
 226         ETHTOOL_LINK_MODE_25000baseKR_Full_BIT,
 227         ETHTOOL_LINK_MODE_25000baseCR_Full_BIT,
 228         ETHTOOL_LINK_MODE_25000baseSR_Full_BIT,
 229 };
 230
 231 static const u32 qede_forced_speed_40000[] __initconst = {
 232         ETHTOOL_LINK_MODE_40000baseLR4_Full_BIT,
 233         ETHTOOL_LINK_MODE_40000baseKR4_Full_BIT,
 234         ETHTOOL_LINK_MODE_40000baseCR4_Full_BIT,
 235         ETHTOOL_LINK_MODE_40000baseSR4_Full_BIT,
 236 };
 237
 238 static const u32 qede_forced_speed_50000[] __initconst = {
 239         ETHTOOL_LINK_MODE_50000baseKR2_Full_BIT,
 240         ETHTOOL_LINK_MODE_50000baseCR2_Full_BIT,
 241         ETHTOOL_LINK_MODE_50000baseSR2_Full_BIT,
 242 };
 243
 244 static const u32 qede_forced_speed_100000[] __initconst = {
 245         ETHTOOL_LINK_MODE_100000baseKR4_Full_BIT,
 246         ETHTOOL_LINK_MODE_100000baseSR4_Full_BIT,
 247         ETHTOOL_LINK_MODE_100000baseCR4_Full_BIT,
 248         ETHTOOL_LINK_MODE_100000baseLR4_ER4_Full_BIT,
 249 };
 250
 251 static struct ethtool_forced_speed_map
 252 qede_forced_speed_maps[] __ro_after_init = {
 253         ETHTOOL_FORCED_SPEED_MAP(qede_forced_speed, 1000),
 254         ETHTOOL_FORCED_SPEED_MAP(qede_forced_speed, 10000),
 255         ETHTOOL_FORCED_SPEED_MAP(qede_forced_speed, 20000),
 256         ETHTOOL_FORCED_SPEED_MAP(qede_forced_speed, 25000),
 257         ETHTOOL_FORCED_SPEED_MAP(qede_forced_speed, 40000),
 258         ETHTOOL_FORCED_SPEED_MAP(qede_forced_speed, 50000),
 259         ETHTOOL_FORCED_SPEED_MAP(qede_forced_speed, 100000),
 260 };
 261
 262 void __init qede_forced_speed_maps_init(void)
 263 {
 264         ethtool_forced_speed_maps_init(qede_forced_speed_maps,
 265                                        ARRAY_SIZE(qede_forced_speed_maps));
 266 }
 267
 268 /* Ethtool callbacks */
 269
 270 static void qede_get_strings_stats_txq(struct qede_dev *edev,
 271                                        struct qede_tx_queue *txq, u8 **buf)
 272 {
 273         int i;
 274
 275         for (i = 0; i < QEDE_NUM_TQSTATS; i++) {
 276                 if (txq->is_xdp)
 277                         sprintf(*buf, "%d [XDP]: %s",
 278                                 QEDE_TXQ_XDP_TO_IDX(edev, txq),
 279                                 qede_tqstats_arr[i].string);
 280                 else
 281                         sprintf(*buf, "%d_%d: %s", txq->index, txq->cos,
 282                                 qede_tqstats_arr[i].string);
 283                 *buf += ETH_GSTRING_LEN;
 284         }
 285 }
 286
 287 static void qede_get_strings_stats_rxq(struct qede_dev *edev,
 288                                        struct qede_rx_queue *rxq, u8 **buf)
 289 {
 290         int i;
 291
 292         for (i = 0; i < QEDE_NUM_RQSTATS; i++) {
 293                 sprintf(*buf, "%d: %s", rxq->rxq_id,
 294                         qede_rqstats_arr[i].string);
 295                 *buf += ETH_GSTRING_LEN;
 296         }
 297 }
 298
 299 static bool qede_is_irrelevant_stat(struct qede_dev *edev, int stat_index)
 300 {
 301         return (IS_VF(edev) && QEDE_STAT_IS_PF_ONLY(stat_index)) ||
 302                (QEDE_IS_BB(edev) && QEDE_STAT_IS_AH_ONLY(stat_index)) ||
 303                (QEDE_IS_AH(edev) && QEDE_STAT_IS_BB_ONLY(stat_index));
 304 }
 305
 306 static void qede_get_strings_stats(struct qede_dev *edev, u8 *buf)
 307 {
 308         struct qede_fastpath *fp;
 309         int i;
 310
 311         /* Account for queue statistics */
 312         for (i = 0; i < QEDE_QUEUE_CNT(edev); i++) {
 313                 fp = &edev->fp_array[i];
 314
 315                 if (fp->type & QEDE_FASTPATH_RX)
 316                         qede_get_strings_stats_rxq(edev, fp->rxq, &buf);
 317
 318                 if (fp->type & QEDE_FASTPATH_XDP)
 319                         qede_get_strings_stats_txq(edev, fp->xdp_tx, &buf);
 320
 321                 if (fp->type & QEDE_FASTPATH_TX) {
 322                         int cos;
 323
 324                         for_each_cos_in_txq(edev, cos)
 325                                 qede_get_strings_stats_txq(edev,
 326                                                            &fp->txq[cos], &buf);
 327                 }
 328         }
 329
 330         /* Account for non-queue statistics */
 331         for (i = 0; i < QEDE_NUM_STATS; i++) {
 332                 if (qede_is_irrelevant_stat(edev, i))
 333                         continue;
 334                 strcpy(buf, qede_stats_arr[i].string);
 335                 buf += ETH_GSTRING_LEN;
 336         }
 337 }
 338
 339 static void qede_get_strings(struct net_device *dev, u32 stringset, u8 *buf)
 340 {
 341         struct qede_dev *edev = netdev_priv(dev);
 342
 343         switch (stringset) {
 344         case ETH_SS_STATS:
 345                 qede_get_strings_stats(edev, buf);
 346                 break;
 347         case ETH_SS_PRIV_FLAGS:
 348                 memcpy(buf, qede_private_arr,
 349                        ETH_GSTRING_LEN * QEDE_PRI_FLAG_LEN);
 350                 break;
 351         case ETH_SS_TEST:
 352                 memcpy(buf, qede_tests_str_arr,
 353                        ETH_GSTRING_LEN * QEDE_ETHTOOL_TEST_MAX);
 354                 break;
 355         default:
 356                 DP_VERBOSE(edev, QED_MSG_DEBUG,
 357                            "Unsupported stringset 0x%08x\n", stringset);
 358         }
 359 }
 360
 361 static void qede_get_ethtool_stats_txq(struct qede_tx_queue *txq, u64 **buf)
 362 {
 363         int i;
 364
 365         for (i = 0; i < QEDE_NUM_TQSTATS; i++) {
 366                 **buf = *((u64 *)(((void *)txq) + qede_tqstats_arr[i].offset));
 367                 (*buf)++;
 368         }
 369 }
 370
 371 static void qede_get_ethtool_stats_rxq(struct qede_rx_queue *rxq, u64 **buf)
 372 {
 373         int i;
 374
 375         for (i = 0; i < QEDE_NUM_RQSTATS; i++) {
 376                 **buf = *((u64 *)(((void *)rxq) + qede_rqstats_arr[i].offset));
 377                 (*buf)++;
 378         }
 379 }
 380
 381 static void qede_get_ethtool_stats(struct net_device *dev,
 382                                    struct ethtool_stats *stats, u64 *buf)
 383 {
 384         struct qede_dev *edev = netdev_priv(dev);
 385         struct qede_fastpath *fp;
 386         int i;
 387
 388         qede_fill_by_demand_stats(edev);
 389
 390         /* Need to protect the access to the fastpath array */
 391         __qede_lock(edev);
 392
 393         for (i = 0; i < QEDE_QUEUE_CNT(edev); i++) {
 394                 fp = &edev->fp_array[i];
 395
 396                 if (fp->type & QEDE_FASTPATH_RX)
 397                         qede_get_ethtool_stats_rxq(fp->rxq, &buf);
 398
 399                 if (fp->type & QEDE_FASTPATH_XDP)
 400                         qede_get_ethtool_stats_txq(fp->xdp_tx, &buf);
 401
 402                 if (fp->type & QEDE_FASTPATH_TX) {
 403                         int cos;
 404
 405                         for_each_cos_in_txq(edev, cos)
 406                                 qede_get_ethtool_stats_txq(&fp->txq[cos], &buf);
 407                 }
 408         }
 409
 410         spin_lock(&edev->stats_lock);
 411
 412         for (i = 0; i < QEDE_NUM_STATS; i++) {
 413                 if (qede_is_irrelevant_stat(edev, i))
 414                         continue;
 415                 *buf = *((u64 *)(((void *)&edev->stats) +
 416                                  qede_stats_arr[i].offset));
 417
 418                 buf++;
 419         }
 420
 421         spin_unlock(&edev->stats_lock);
 422
 423         __qede_unlock(edev);
 424 }
 425
 426 static int qede_get_sset_count(struct net_device *dev, int stringset)
 427 {
 428         struct qede_dev *edev = netdev_priv(dev);
 429         int num_stats = QEDE_NUM_STATS, i;
 430
 431         switch (stringset) {
 432         case ETH_SS_STATS:
 433                 for (i = 0; i < QEDE_NUM_STATS; i++)
 434                         if (qede_is_irrelevant_stat(edev, i))
 435                                 num_stats--;
 436
 437                 /* Account for the Regular Tx statistics */
 438                 num_stats += QEDE_TSS_COUNT(edev) * QEDE_NUM_TQSTATS *
 439                                 edev->dev_info.num_tc;
 440
 441                 /* Account for the Regular Rx statistics */
 442                 num_stats += QEDE_RSS_COUNT(edev) * QEDE_NUM_RQSTATS;
 443
 444                 /* Account for XDP statistics [if needed] */
 445                 if (edev->xdp_prog)
 446                         num_stats += QEDE_RSS_COUNT(edev) * QEDE_NUM_TQSTATS;
 447                 return num_stats;
 448
 449         case ETH_SS_PRIV_FLAGS:
 450                 return QEDE_PRI_FLAG_LEN;
 451         case ETH_SS_TEST:
 452                 if (!IS_VF(edev))
 453                         return QEDE_ETHTOOL_TEST_MAX;
 454                 else
 455                         return 0;
 456         default:
 457                 DP_VERBOSE(edev, QED_MSG_DEBUG,
 458                            "Unsupported stringset 0x%08x\n", stringset);
 459                 return -EINVAL;
 460         }
 461 }
 462
 463 static u32 qede_get_priv_flags(struct net_device *dev)
 464 {
 465         struct qede_dev *edev = netdev_priv(dev);
 466         bool esl_active;
 467         u32 flags = 0;
 468
 469         if (edev->dev_info.common.num_hwfns > 1)
 470                 flags |= BIT(QEDE_PRI_FLAG_CMT);
 471
 472         if (edev->dev_info.common.smart_an)
 473                 flags |= BIT(QEDE_PRI_FLAG_SMART_AN_SUPPORT);
 474
 475         if (edev->err_flags & BIT(QEDE_ERR_IS_RECOVERABLE))
 476                 flags |= BIT(QEDE_PRI_FLAG_RECOVER_ON_ERROR);
 477
 478         if (edev->dev_info.common.esl)
 479                 flags |= BIT(QEDE_PRI_FLAG_ESL_SUPPORT);
 480
 481         edev->ops->common->get_esl_status(edev->cdev, &esl_active);
 482
 483         if (esl_active)
 484                 flags |= BIT(QEDE_PRI_FLAG_ESL_ACTIVE);
 485
 486         return flags;
 487 }
 488
 489 static int qede_set_priv_flags(struct net_device *dev, u32 flags)
 490 {
 491         struct qede_dev *edev = netdev_priv(dev);
 492         u32 cflags = qede_get_priv_flags(dev);
 493         u32 dflags = flags ^ cflags;
 494
 495         /* can only change RECOVER_ON_ERROR flag */
 496         if (dflags & ~BIT(QEDE_PRI_FLAG_RECOVER_ON_ERROR))
 497                 return -EINVAL;
 498
 499         if (flags & BIT(QEDE_PRI_FLAG_RECOVER_ON_ERROR))
 500                 set_bit(QEDE_ERR_IS_RECOVERABLE, &edev->err_flags);
 501         else
 502                 clear_bit(QEDE_ERR_IS_RECOVERABLE, &edev->err_flags);
 503
 504         return 0;
 505 }
 506
 507 static int qede_get_link_ksettings(struct net_device *dev,
 508                                    struct ethtool_link_ksettings *cmd)
 509 {
 510         typeof(cmd->link_modes) *link_modes = &cmd->link_modes;
 511         struct ethtool_link_settings *base = &cmd->base;
 512         struct qede_dev *edev = netdev_priv(dev);
 513         struct qed_link_output current_link;
 514
 515         __qede_lock(edev);
 516
 517         memset(&current_link, 0, sizeof(current_link));
 518         edev->ops->common->get_link(edev->cdev, &current_link);
 519
 520         linkmode_copy(link_modes->supported, current_link.supported_caps);
 521         linkmode_copy(link_modes->advertising, current_link.advertised_caps);
 522         linkmode_copy(link_modes->lp_advertising, current_link.lp_caps);
 523
 524         if ((edev->state == QEDE_STATE_OPEN) && (current_link.link_up)) {
 525                 base->speed = current_link.speed;
 526                 base->duplex = current_link.duplex;
 527         } else {
 528                 base->speed = SPEED_UNKNOWN;
 529                 base->duplex = DUPLEX_UNKNOWN;
 530         }
 531
 532         __qede_unlock(edev);
 533
 534         base->port = current_link.port;
 535         base->autoneg = (current_link.autoneg) ? AUTONEG_ENABLE :
 536                         AUTONEG_DISABLE;
 537
 538         return 0;
 539 }
 540
 541 static int qede_set_link_ksettings(struct net_device *dev,
 542                                    const struct ethtool_link_ksettings *cmd)
 543 {
 544         const struct ethtool_link_settings *base = &cmd->base;
 545         const struct ethtool_forced_speed_map *map;
 546         struct qede_dev *edev = netdev_priv(dev);
 547         struct qed_link_output current_link;
 548         struct qed_link_params params;
 549         u32 i;
 550
 551         if (!edev->ops || !edev->ops->common->can_link_change(edev->cdev)) {
 552                 DP_INFO(edev, "Link settings are not allowed to be changed\n");
 553                 return -EOPNOTSUPP;
 554         }
 555         memset(&current_link, 0, sizeof(current_link));
 556         memset(&params, 0, sizeof(params));
 557         edev->ops->common->get_link(edev->cdev, &current_link);
 558
 559         params.override_flags |= QED_LINK_OVERRIDE_SPEED_ADV_SPEEDS;
 560         params.override_flags |= QED_LINK_OVERRIDE_SPEED_AUTONEG;
 561
 562         if (base->autoneg == AUTONEG_ENABLE) {
 563                 if (!phylink_test(current_link.supported_caps, Autoneg)) {
 564                         DP_INFO(edev, "Auto negotiation is not supported\n");
 565                         return -EOPNOTSUPP;
 566                 }
 567
 568                 params.autoneg = true;
 569                 params.forced_speed = 0;
 570
 571                 linkmode_copy(params.adv_speeds, cmd->link_modes.advertising);
 572         } else {                /* forced speed */
 573                 params.override_flags |= QED_LINK_OVERRIDE_SPEED_FORCED_SPEED;
 574                 params.autoneg = false;
 575                 params.forced_speed = base->speed;
 576
 577                 for (i = 0; i < ARRAY_SIZE(qede_forced_speed_maps); i++) {
 578                         map = qede_forced_speed_maps + i;
 579
 580                         if (base->speed != map->speed ||
 581                             !linkmode_intersects(current_link.supported_caps,
 582                                                  map->caps))
 583                                 continue;
 584
 585                         linkmode_and(params.adv_speeds,
 586                                      current_link.supported_caps, map->caps);
 587                         goto set_link;
 588                 }
 589
 590                 DP_INFO(edev, "Unsupported speed %u\n", base->speed);
 591                 return -EINVAL;
 592         }
 593
 594 set_link:
 595         params.link_up = true;
 596         edev->ops->common->set_link(edev->cdev, &params);
 597
 598         return 0;
 599 }
 600
 601 static void qede_get_drvinfo(struct net_device *ndev,
 602                              struct ethtool_drvinfo *info)
 603 {
 604         char mfw[ETHTOOL_FWVERS_LEN], storm[ETHTOOL_FWVERS_LEN];
 605         struct qede_dev *edev = netdev_priv(ndev);
 606         char mbi[ETHTOOL_FWVERS_LEN];
 607
 608         strscpy(info->driver, "qede", sizeof(info->driver));
 609
 610         snprintf(storm, ETHTOOL_FWVERS_LEN, "%d.%d.%d.%d",
 611                  edev->dev_info.common.fw_major,
 612                  edev->dev_info.common.fw_minor,
 613                  edev->dev_info.common.fw_rev,
 614                  edev->dev_info.common.fw_eng);
 615
 616         snprintf(mfw, ETHTOOL_FWVERS_LEN, "%d.%d.%d.%d",
 617                  (edev->dev_info.common.mfw_rev >> 24) & 0xFF,
 618                  (edev->dev_info.common.mfw_rev >> 16) & 0xFF,
 619                  (edev->dev_info.common.mfw_rev >> 8) & 0xFF,
 620                  edev->dev_info.common.mfw_rev & 0xFF);
 621
 622         if ((strlen(storm) + strlen("[storm]")) <
 623             sizeof(info->version))
 624                 snprintf(info->version, sizeof(info->version),
 625                          "[storm %s]", storm);
 626         else
 627                 snprintf(info->version, sizeof(info->version),
 628                          "%s", storm);
 629
 630         if (edev->dev_info.common.mbi_version) {
 631                 snprintf(mbi, ETHTOOL_FWVERS_LEN, "%d.%d.%d",
 632                          (edev->dev_info.common.mbi_version &
 633                           QED_MBI_VERSION_2_MASK) >> QED_MBI_VERSION_2_OFFSET,
 634                          (edev->dev_info.common.mbi_version &
 635                           QED_MBI_VERSION_1_MASK) >> QED_MBI_VERSION_1_OFFSET,
 636                          (edev->dev_info.common.mbi_version &
 637                           QED_MBI_VERSION_0_MASK) >> QED_MBI_VERSION_0_OFFSET);
 638                 snprintf(info->fw_version, sizeof(info->fw_version),
 639                          "mbi %s [mfw %s]", mbi, mfw);
 640         } else {
 641                 snprintf(info->fw_version, sizeof(info->fw_version),
 642                          "mfw %s", mfw);
 643         }
 644
 645         strscpy(info->bus_info, pci_name(edev->pdev), sizeof(info->bus_info));
 646 }
 647
 648 static void qede_get_wol(struct net_device *ndev, struct ethtool_wolinfo *wol)
 649 {
 650         struct qede_dev *edev = netdev_priv(ndev);
 651
 652         if (edev->dev_info.common.wol_support) {
 653                 wol->supported = WAKE_MAGIC;
 654                 wol->wolopts = edev->wol_enabled ? WAKE_MAGIC : 0;
 655         }
 656 }
 657
 658 static int qede_set_wol(struct net_device *ndev, struct ethtool_wolinfo *wol)
 659 {
 660         struct qede_dev *edev = netdev_priv(ndev);
 661         bool wol_requested;
 662         int rc;
 663
 664         if (wol->wolopts & ~WAKE_MAGIC) {
 665                 DP_INFO(edev,
 666                         "Can't support WoL options other than magic-packet\n");
 667                 return -EINVAL;
 668         }
 669
 670         wol_requested = !!(wol->wolopts & WAKE_MAGIC);
 671         if (wol_requested == edev->wol_enabled)
 672                 return 0;
 673
 674         /* Need to actually change configuration */
 675         if (!edev->dev_info.common.wol_support) {
 676                 DP_INFO(edev, "Device doesn't support WoL\n");
 677                 return -EINVAL;
 678         }
 679
 680         rc = edev->ops->common->update_wol(edev->cdev, wol_requested);
 681         if (!rc)
 682                 edev->wol_enabled = wol_requested;
 683
 684         return rc;
 685 }
 686
 687 static u32 qede_get_msglevel(struct net_device *ndev)
 688 {
 689         struct qede_dev *edev = netdev_priv(ndev);
 690
 691         return ((u32)edev->dp_level << QED_LOG_LEVEL_SHIFT) | edev->dp_module;
 692 }
 693
 694 static void qede_set_msglevel(struct net_device *ndev, u32 level)
 695 {
 696         struct qede_dev *edev = netdev_priv(ndev);
 697         u32 dp_module = 0;
 698         u8 dp_level = 0;
 699
 700         qede_config_debug(level, &dp_module, &dp_level);
 701
 702         edev->dp_level = dp_level;
 703         edev->dp_module = dp_module;
 704         edev->ops->common->update_msglvl(edev->cdev,
 705                                          dp_module, dp_level);
 706 }
 707
 708 static int qede_nway_reset(struct net_device *dev)
 709 {
 710         struct qede_dev *edev = netdev_priv(dev);
 711         struct qed_link_output current_link;
 712         struct qed_link_params link_params;
 713
 714         if (!edev->ops || !edev->ops->common->can_link_change(edev->cdev)) {
 715                 DP_INFO(edev, "Link settings are not allowed to be changed\n");
 716                 return -EOPNOTSUPP;
 717         }
 718
 719         if (!netif_running(dev))
 720                 return 0;
 721
 722         memset(&current_link, 0, sizeof(current_link));
 723         edev->ops->common->get_link(edev->cdev, &current_link);
 724         if (!current_link.link_up)
 725                 return 0;
 726
 727         /* Toggle the link */
 728         memset(&link_params, 0, sizeof(link_params));
 729         link_params.link_up = false;
 730         edev->ops->common->set_link(edev->cdev, &link_params);
 731         link_params.link_up = true;
 732         edev->ops->common->set_link(edev->cdev, &link_params);
 733
 734         return 0;
 735 }
 736
 737 static u32 qede_get_link(struct net_device *dev)
 738 {
 739         struct qede_dev *edev = netdev_priv(dev);
 740         struct qed_link_output current_link;
 741
 742         memset(&current_link, 0, sizeof(current_link));
 743         edev->ops->common->get_link(edev->cdev, &current_link);
 744
 745         return current_link.link_up;
 746 }
 747
 748 static int qede_flash_device(struct net_device *dev,
 749                              struct ethtool_flash *flash)
 750 {
 751         struct qede_dev *edev = netdev_priv(dev);
 752
 753         return edev->ops->common->nvm_flash(edev->cdev, flash->data);
 754 }
 755
 756 static int qede_get_coalesce(struct net_device *dev,
 757                              struct ethtool_coalesce *coal,
 758                              struct kernel_ethtool_coalesce *kernel_coal,
 759                              struct netlink_ext_ack *extack)
 760 {
 761         void *rx_handle = NULL, *tx_handle = NULL;
 762         struct qede_dev *edev = netdev_priv(dev);
 763         u16 rx_coal, tx_coal, i, rc = 0;
 764         struct qede_fastpath *fp;
 765
 766         rx_coal = QED_DEFAULT_RX_USECS;
 767         tx_coal = QED_DEFAULT_TX_USECS;
 768
 769         memset(coal, 0, sizeof(struct ethtool_coalesce));
 770
 771         __qede_lock(edev);
 772         if (edev->state == QEDE_STATE_OPEN) {
 773                 for_each_queue(i) {
 774                         fp = &edev->fp_array[i];
 775
 776                         if (fp->type & QEDE_FASTPATH_RX) {
 777                                 rx_handle = fp->rxq->handle;
 778                                 break;
 779                         }
 780                 }
 781
 782                 rc = edev->ops->get_coalesce(edev->cdev, &rx_coal, rx_handle);
 783                 if (rc) {
 784                         DP_INFO(edev, "Read Rx coalesce error\n");
 785                         goto out;
 786                 }
 787
 788                 for_each_queue(i) {
 789                         struct qede_tx_queue *txq;
 790
 791                         fp = &edev->fp_array[i];
 792
 793                         /* All TX queues of given fastpath uses same
 794                          * coalescing value, so no need to iterate over
 795                          * all TCs, TC0 txq should suffice.
 796                          */
 797                         if (fp->type & QEDE_FASTPATH_TX) {
 798                                 txq = QEDE_FP_TC0_TXQ(fp);
 799                                 tx_handle = txq->handle;
 800                                 break;
 801                         }
 802                 }
 803
 804                 rc = edev->ops->get_coalesce(edev->cdev, &tx_coal, tx_handle);
 805                 if (rc)
 806                         DP_INFO(edev, "Read Tx coalesce error\n");
 807         }
 808
 809 out:
 810         __qede_unlock(edev);
 811
 812         coal->rx_coalesce_usecs = rx_coal;
 813         coal->tx_coalesce_usecs = tx_coal;
 814         coal->stats_block_coalesce_usecs = edev->stats_coal_usecs;
 815
 816         return rc;
 817 }
 818
 819 int qede_set_coalesce(struct net_device *dev, struct ethtool_coalesce *coal,
 820                       struct kernel_ethtool_coalesce *kernel_coal,
 821                       struct netlink_ext_ack *extack)
 822 {
 823         struct qede_dev *edev = netdev_priv(dev);
 824         struct qede_fastpath *fp;
 825         int i, rc = 0;
 826         u16 rxc, txc;
 827
 828         if (edev->stats_coal_usecs != coal->stats_block_coalesce_usecs) {
 829                 edev->stats_coal_usecs = coal->stats_block_coalesce_usecs;
 830                 if (edev->stats_coal_usecs) {
 831                         edev->stats_coal_ticks = usecs_to_jiffies(edev->stats_coal_usecs);
 832                         schedule_delayed_work(&edev->periodic_task, 0);
 833
 834                         DP_INFO(edev, "Configured stats coal ticks=%lu jiffies\n",
 835                                 edev->stats_coal_ticks);
 836                 } else {
 837                         cancel_delayed_work_sync(&edev->periodic_task);
 838                 }
 839         }
 840
 841         if (!netif_running(dev)) {
 842                 DP_INFO(edev, "Interface is down\n");
 843                 return -EINVAL;
 844         }
 845
 846         if (coal->rx_coalesce_usecs > QED_COALESCE_MAX ||
 847             coal->tx_coalesce_usecs > QED_COALESCE_MAX) {
 848                 DP_INFO(edev,
 849                         "Can't support requested %s coalesce value [max supported value %d]\n",
 850                         coal->rx_coalesce_usecs > QED_COALESCE_MAX ? "rx" :
 851                         "tx", QED_COALESCE_MAX);
 852                 return -EINVAL;
 853         }
 854
 855         rxc = (u16)coal->rx_coalesce_usecs;
 856         txc = (u16)coal->tx_coalesce_usecs;
 857         for_each_queue(i) {
 858                 fp = &edev->fp_array[i];
 859
 860                 if (edev->fp_array[i].type & QEDE_FASTPATH_RX) {
 861                         rc = edev->ops->common->set_coalesce(edev->cdev,
 862                                                              rxc, 0,
 863                                                              fp->rxq->handle);
 864                         if (rc) {
 865                                 DP_INFO(edev,
 866                                         "Set RX coalesce error, rc = %d\n", rc);
 867                                 return rc;
 868                         }
 869                         edev->coal_entry[i].rxc = rxc;
 870                         edev->coal_entry[i].isvalid = true;
 871                 }
 872
 873                 if (edev->fp_array[i].type & QEDE_FASTPATH_TX) {
 874                         struct qede_tx_queue *txq;
 875
 876                         /* All TX queues of given fastpath uses same
 877                          * coalescing value, so no need to iterate over
 878                          * all TCs, TC0 txq should suffice.
 879                          */
 880                         txq = QEDE_FP_TC0_TXQ(fp);
 881
 882                         rc = edev->ops->common->set_coalesce(edev->cdev,
 883                                                              0, txc,
 884                                                              txq->handle);
 885                         if (rc) {
 886                                 DP_INFO(edev,
 887                                         "Set TX coalesce error, rc = %d\n", rc);
 888                                 return rc;
 889                         }
 890                         edev->coal_entry[i].txc = txc;
 891                         edev->coal_entry[i].isvalid = true;
 892                 }
 893         }
 894
 895         return rc;
 896 }
 897
 898 static void qede_get_ringparam(struct net_device *dev,
 899                                struct ethtool_ringparam *ering,
 900                                struct kernel_ethtool_ringparam *kernel_ering,
 901                                struct netlink_ext_ack *extack)
 902 {
 903         struct qede_dev *edev = netdev_priv(dev);
 904
 905         ering->rx_max_pending = NUM_RX_BDS_MAX;
 906         ering->rx_pending = edev->q_num_rx_buffers;
 907         ering->tx_max_pending = NUM_TX_BDS_MAX;
 908         ering->tx_pending = edev->q_num_tx_buffers;
 909 }
 910
 911 static int qede_set_ringparam(struct net_device *dev,
 912                               struct ethtool_ringparam *ering,
 913                               struct kernel_ethtool_ringparam *kernel_ering,
 914                               struct netlink_ext_ack *extack)
 915 {
 916         struct qede_dev *edev = netdev_priv(dev);
 917
 918         DP_VERBOSE(edev, (NETIF_MSG_IFUP | NETIF_MSG_IFDOWN),
 919                    "Set ring params command parameters: rx_pending = %d, tx_pending = %d\n",
 920                    ering->rx_pending, ering->tx_pending);
 921
 922         /* Validate legality of configuration */
 923         if (ering->rx_pending > NUM_RX_BDS_MAX ||
 924             ering->rx_pending < NUM_RX_BDS_MIN ||
 925             ering->tx_pending > NUM_TX_BDS_MAX ||
 926             ering->tx_pending < NUM_TX_BDS_MIN) {
 927                 DP_VERBOSE(edev, (NETIF_MSG_IFUP | NETIF_MSG_IFDOWN),
 928                            "Can only support Rx Buffer size [0%08x,...,0x%08x] and Tx Buffer size [0x%08x,...,0x%08x]\n",
 929                            NUM_RX_BDS_MIN, NUM_RX_BDS_MAX,
 930                            NUM_TX_BDS_MIN, NUM_TX_BDS_MAX);
 931                 return -EINVAL;
 932         }
 933
 934         /* Change ring size and re-load */
 935         edev->q_num_rx_buffers = ering->rx_pending;
 936         edev->q_num_tx_buffers = ering->tx_pending;
 937
 938         qede_reload(edev, NULL, false);
 939
 940         return 0;
 941 }
 942
 943 static void qede_get_pauseparam(struct net_device *dev,
 944                                 struct ethtool_pauseparam *epause)
 945 {
 946         struct qede_dev *edev = netdev_priv(dev);
 947         struct qed_link_output current_link;
 948
 949         memset(&current_link, 0, sizeof(current_link));
 950         edev->ops->common->get_link(edev->cdev, &current_link);
 951
 952         if (current_link.pause_config & QED_LINK_PAUSE_AUTONEG_ENABLE)
 953                 epause->autoneg = true;
 954         if (current_link.pause_config & QED_LINK_PAUSE_RX_ENABLE)
 955                 epause->rx_pause = true;
 956         if (current_link.pause_config & QED_LINK_PAUSE_TX_ENABLE)
 957                 epause->tx_pause = true;
 958
 959         DP_VERBOSE(edev, QED_MSG_DEBUG,
 960                    "ethtool_pauseparam: cmd %d  autoneg %d  rx_pause %d  tx_pause %d\n",
 961                    epause->cmd, epause->autoneg, epause->rx_pause,
 962                    epause->tx_pause);
 963 }
 964
 965 static int qede_set_pauseparam(struct net_device *dev,
 966                                struct ethtool_pauseparam *epause)
 967 {
 968         struct qede_dev *edev = netdev_priv(dev);
 969         struct qed_link_params params;
 970         struct qed_link_output current_link;
 971
 972         if (!edev->ops || !edev->ops->common->can_link_change(edev->cdev)) {
 973                 DP_INFO(edev,
 974                         "Pause settings are not allowed to be changed\n");
 975                 return -EOPNOTSUPP;
 976         }
 977
 978         memset(&current_link, 0, sizeof(current_link));
 979         edev->ops->common->get_link(edev->cdev, &current_link);
 980
 981         memset(&params, 0, sizeof(params));
 982         params.override_flags |= QED_LINK_OVERRIDE_PAUSE_CONFIG;
 983
 984         if (epause->autoneg) {
 985                 if (!phylink_test(current_link.supported_caps, Autoneg)) {
 986                         DP_INFO(edev, "autoneg not supported\n");
 987                         return -EINVAL;
 988                 }
 989
 990                 params.pause_config |= QED_LINK_PAUSE_AUTONEG_ENABLE;
 991         }
 992
 993         if (epause->rx_pause)
 994                 params.pause_config |= QED_LINK_PAUSE_RX_ENABLE;
 995         if (epause->tx_pause)
 996                 params.pause_config |= QED_LINK_PAUSE_TX_ENABLE;
 997
 998         params.link_up = true;
 999         edev->ops->common->set_link(edev->cdev, &params);
1000
1001         return 0;
1002 }
1003
1004 static void qede_get_regs(struct net_device *ndev,
1005                           struct ethtool_regs *regs, void *buffer)
1006 {
1007         struct qede_dev *edev = netdev_priv(ndev);
1008
1009         regs->version = 0;
1010         memset(buffer, 0, regs->len);
1011
1012         if (edev->ops && edev->ops->common)
1013                 edev->ops->common->dbg_all_data(edev->cdev, buffer);
1014 }
1015
1016 static int qede_get_regs_len(struct net_device *ndev)
1017 {
1018         struct qede_dev *edev = netdev_priv(ndev);
1019
1020         if (edev->ops && edev->ops->common)
1021                 return edev->ops->common->dbg_all_data_size(edev->cdev);
1022         else
1023                 return -EINVAL;
1024 }
1025
1026 static void qede_update_mtu(struct qede_dev *edev,
1027                             struct qede_reload_args *args)
1028 {
1029         edev->ndev->mtu = args->u.mtu;
1030 }
1031
1032 /* Netdevice NDOs */
1033 int qede_change_mtu(struct net_device *ndev, int new_mtu)
1034 {
1035         struct qede_dev *edev = netdev_priv(ndev);
1036         struct qede_reload_args args;
1037
1038         DP_VERBOSE(edev, (NETIF_MSG_IFUP | NETIF_MSG_IFDOWN),
1039                    "Configuring MTU size of %d\n", new_mtu);
1040
1041         if (new_mtu > PAGE_SIZE)
1042                 ndev->features &= ~NETIF_F_GRO_HW;
1043
1044         /* Set the mtu field and re-start the interface if needed */
1045         args.u.mtu = new_mtu;
1046         args.func = &qede_update_mtu;
1047         qede_reload(edev, &args, false);
1048 #if IS_ENABLED(CONFIG_QED_RDMA)
1049         qede_rdma_event_change_mtu(edev);
1050 #endif
1051         edev->ops->common->update_mtu(edev->cdev, new_mtu);
1052
1053         return 0;
1054 }
1055
1056 static void qede_get_channels(struct net_device *dev,
1057                               struct ethtool_channels *channels)
1058 {
1059         struct qede_dev *edev = netdev_priv(dev);
1060
1061         channels->max_combined = QEDE_MAX_RSS_CNT(edev);
1062         channels->max_rx = QEDE_MAX_RSS_CNT(edev);
1063         channels->max_tx = QEDE_MAX_RSS_CNT(edev);
1064         channels->combined_count = QEDE_QUEUE_CNT(edev) - edev->fp_num_tx -
1065                                         edev->fp_num_rx;
1066         channels->tx_count = edev->fp_num_tx;
1067         channels->rx_count = edev->fp_num_rx;
1068 }
1069
1070 static int qede_set_channels(struct net_device *dev,
1071                              struct ethtool_channels *channels)
1072 {
1073         struct qede_dev *edev = netdev_priv(dev);
1074         u32 count;
1075
1076         DP_VERBOSE(edev, (NETIF_MSG_IFUP | NETIF_MSG_IFDOWN),
1077                    "set-channels command parameters: rx = %d, tx = %d, other = %d, combined = %d\n",
1078                    channels->rx_count, channels->tx_count,
1079                    channels->other_count, channels->combined_count);
1080
1081         count = channels->rx_count + channels->tx_count +
1082                         channels->combined_count;
1083
1084         /* We don't support `other' channels */
1085         if (channels->other_count) {
1086                 DP_VERBOSE(edev, (NETIF_MSG_IFUP | NETIF_MSG_IFDOWN),
1087                            "command parameters not supported\n");
1088                 return -EINVAL;
1089         }
1090
1091         if (!(channels->combined_count || (channels->rx_count &&
1092                                            channels->tx_count))) {
1093                 DP_VERBOSE(edev, (NETIF_MSG_IFUP | NETIF_MSG_IFDOWN),
1094                            "need to request at least one transmit and one receive channel\n");
1095                 return -EINVAL;
1096         }
1097
1098         if (count > QEDE_MAX_RSS_CNT(edev)) {
1099                 DP_VERBOSE(edev, (NETIF_MSG_IFUP | NETIF_MSG_IFDOWN),
1100                            "requested channels = %d max supported channels = %d\n",
1101                            count, QEDE_MAX_RSS_CNT(edev));
1102                 return -EINVAL;
1103         }
1104
1105         /* Check if there was a change in the active parameters */
1106         if ((count == QEDE_QUEUE_CNT(edev)) &&
1107             (channels->tx_count == edev->fp_num_tx) &&
1108             (channels->rx_count == edev->fp_num_rx)) {
1109                 DP_VERBOSE(edev, (NETIF_MSG_IFUP | NETIF_MSG_IFDOWN),
1110                            "No change in active parameters\n");
1111                 return 0;
1112         }
1113
1114         /* We need the number of queues to be divisible between the hwfns */
1115         if ((count % edev->dev_info.common.num_hwfns) ||
1116             (channels->tx_count % edev->dev_info.common.num_hwfns) ||
1117             (channels->rx_count % edev->dev_info.common.num_hwfns)) {
1118                 DP_VERBOSE(edev, (NETIF_MSG_IFUP | NETIF_MSG_IFDOWN),
1119                            "Number of channels must be divisible by %04x\n",
1120                            edev->dev_info.common.num_hwfns);
1121                 return -EINVAL;
1122         }
1123
1124         /* Set number of queues and reload if necessary */
1125         edev->req_queues = count;
1126         edev->req_num_tx = channels->tx_count;
1127         edev->req_num_rx = channels->rx_count;
1128         /* Reset the indirection table if rx queue count is updated */
1129         if ((edev->req_queues - edev->req_num_tx) != QEDE_RSS_COUNT(edev)) {
1130                 edev->rss_params_inited &= ~QEDE_RSS_INDIR_INITED;
1131                 memset(edev->rss_ind_table, 0, sizeof(edev->rss_ind_table));
1132         }
1133
1134         qede_reload(edev, NULL, false);
1135
1136         return 0;
1137 }
1138
1139 static int qede_get_ts_info(struct net_device *dev,
1140                             struct ethtool_ts_info *info)
1141 {
1142         struct qede_dev *edev = netdev_priv(dev);
1143
1144         return qede_ptp_get_ts_info(edev, info);
1145 }
1146
1147 static int qede_set_phys_id(struct net_device *dev,
1148                             enum ethtool_phys_id_state state)
1149 {
1150         struct qede_dev *edev = netdev_priv(dev);
1151         u8 led_state = 0;
1152
1153         switch (state) {
1154         case ETHTOOL_ID_ACTIVE:
1155                 return 1;       /* cycle on/off once per second */
1156
1157         case ETHTOOL_ID_ON:
1158                 led_state = QED_LED_MODE_ON;
1159                 break;
1160
1161         case ETHTOOL_ID_OFF:
1162                 led_state = QED_LED_MODE_OFF;
1163                 break;
1164
1165         case ETHTOOL_ID_INACTIVE:
1166                 led_state = QED_LED_MODE_RESTORE;
1167                 break;
1168         }
1169
1170         edev->ops->common->set_led(edev->cdev, led_state);
1171
1172         return 0;
1173 }
1174
1175 static int qede_get_rss_flags(struct qede_dev *edev, struct ethtool_rxnfc *info)
1176 {
1177         info->data = RXH_IP_SRC | RXH_IP_DST;
1178
1179         switch (info->flow_type) {
1180         case TCP_V4_FLOW:
1181         case TCP_V6_FLOW:
1182                 info->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
1183                 break;
1184         case UDP_V4_FLOW:
1185                 if (edev->rss_caps & QED_RSS_IPV4_UDP)
1186                         info->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
1187                 break;
1188         case UDP_V6_FLOW:
1189                 if (edev->rss_caps & QED_RSS_IPV6_UDP)
1190                         info->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
1191                 break;
1192         case IPV4_FLOW:
1193         case IPV6_FLOW:
1194                 break;
1195         default:
1196                 info->data = 0;
1197                 break;
1198         }
1199
1200         return 0;
1201 }
1202
1203 static int qede_get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *info,
1204                           u32 *rule_locs)
1205 {
1206         struct qede_dev *edev = netdev_priv(dev);
1207         int rc = 0;
1208
1209         switch (info->cmd) {
1210         case ETHTOOL_GRXRINGS:
1211                 info->data = QEDE_RSS_COUNT(edev);
1212                 break;
1213         case ETHTOOL_GRXFH:
1214                 rc = qede_get_rss_flags(edev, info);
1215                 break;
1216         case ETHTOOL_GRXCLSRLCNT:
1217                 info->rule_cnt = qede_get_arfs_filter_count(edev);
1218                 info->data = QEDE_RFS_MAX_FLTR;
1219                 break;
1220         case ETHTOOL_GRXCLSRULE:
1221                 rc = qede_get_cls_rule_entry(edev, info);
1222                 break;
1223         case ETHTOOL_GRXCLSRLALL:
1224                 rc = qede_get_cls_rule_all(edev, info, rule_locs);
1225                 break;
1226         default:
1227                 DP_ERR(edev, "Command parameters not supported\n");
1228                 rc = -EOPNOTSUPP;
1229         }
1230
1231         return rc;
1232 }
1233
1234 static int qede_set_rss_flags(struct qede_dev *edev, struct ethtool_rxnfc *info)
1235 {
1236         struct qed_update_vport_params *vport_update_params;
1237         u8 set_caps = 0, clr_caps = 0;
1238         int rc = 0;
1239
1240         DP_VERBOSE(edev, QED_MSG_DEBUG,
1241                    "Set rss flags command parameters: flow type = %d, data = %llu\n",
1242                    info->flow_type, info->data);
1243
1244         switch (info->flow_type) {
1245         case TCP_V4_FLOW:
1246         case TCP_V6_FLOW:
1247                 /* For TCP only 4-tuple hash is supported */
1248                 if (info->data ^ (RXH_IP_SRC | RXH_IP_DST |
1249                                   RXH_L4_B_0_1 | RXH_L4_B_2_3)) {
1250                         DP_INFO(edev, "Command parameters not supported\n");
1251                         return -EINVAL;
1252                 }
1253                 return 0;
1254         case UDP_V4_FLOW:
1255                 /* For UDP either 2-tuple hash or 4-tuple hash is supported */
1256                 if (info->data == (RXH_IP_SRC | RXH_IP_DST |
1257                                    RXH_L4_B_0_1 | RXH_L4_B_2_3)) {
1258                         set_caps = QED_RSS_IPV4_UDP;
1259                         DP_VERBOSE(edev, QED_MSG_DEBUG,
1260                                    "UDP 4-tuple enabled\n");
1261                 } else if (info->data == (RXH_IP_SRC | RXH_IP_DST)) {
1262                         clr_caps = QED_RSS_IPV4_UDP;
1263                         DP_VERBOSE(edev, QED_MSG_DEBUG,
1264                                    "UDP 4-tuple disabled\n");
1265                 } else {
1266                         return -EINVAL;
1267                 }
1268                 break;
1269         case UDP_V6_FLOW:
1270                 /* For UDP either 2-tuple hash or 4-tuple hash is supported */
1271                 if (info->data == (RXH_IP_SRC | RXH_IP_DST |
1272                                    RXH_L4_B_0_1 | RXH_L4_B_2_3)) {
1273                         set_caps = QED_RSS_IPV6_UDP;
1274                         DP_VERBOSE(edev, QED_MSG_DEBUG,
1275                                    "UDP 4-tuple enabled\n");
1276                 } else if (info->data == (RXH_IP_SRC | RXH_IP_DST)) {
1277                         clr_caps = QED_RSS_IPV6_UDP;
1278                         DP_VERBOSE(edev, QED_MSG_DEBUG,
1279                                    "UDP 4-tuple disabled\n");
1280                 } else {
1281                         return -EINVAL;
1282                 }
1283                 break;
1284         case IPV4_FLOW:
1285         case IPV6_FLOW:
1286                 /* For IP only 2-tuple hash is supported */
1287                 if (info->data ^ (RXH_IP_SRC | RXH_IP_DST)) {
1288                         DP_INFO(edev, "Command parameters not supported\n");
1289                         return -EINVAL;
1290                 }
1291                 return 0;
1292         case SCTP_V4_FLOW:
1293         case AH_ESP_V4_FLOW:
1294         case AH_V4_FLOW:
1295         case ESP_V4_FLOW:
1296         case SCTP_V6_FLOW:
1297         case AH_ESP_V6_FLOW:
1298         case AH_V6_FLOW:
1299         case ESP_V6_FLOW:
1300         case IP_USER_FLOW:
1301         case ETHER_FLOW:
1302                 /* RSS is not supported for these protocols */
1303                 if (info->data) {
1304                         DP_INFO(edev, "Command parameters not supported\n");
1305                         return -EINVAL;
1306                 }
1307                 return 0;
1308         default:
1309                 return -EINVAL;
1310         }
1311
1312         /* No action is needed if there is no change in the rss capability */
1313         if (edev->rss_caps == ((edev->rss_caps & ~clr_caps) | set_caps))
1314                 return 0;
1315
1316         /* Update internal configuration */
1317         edev->rss_caps = ((edev->rss_caps & ~clr_caps) | set_caps);
1318         edev->rss_params_inited |= QEDE_RSS_CAPS_INITED;
1319
1320         /* Re-configure if possible */
1321         __qede_lock(edev);
1322         if (edev->state == QEDE_STATE_OPEN) {
1323                 vport_update_params = vzalloc(sizeof(*vport_update_params));
1324                 if (!vport_update_params) {
1325                         __qede_unlock(edev);
1326                         return -ENOMEM;
1327                 }
1328                 qede_fill_rss_params(edev, &vport_update_params->rss_params,
1329                                      &vport_update_params->update_rss_flg);
1330                 rc = edev->ops->vport_update(edev->cdev, vport_update_params);
1331                 vfree(vport_update_params);
1332         }
1333         __qede_unlock(edev);
1334
1335         return rc;
1336 }
1337
1338 static int qede_set_rxnfc(struct net_device *dev, struct ethtool_rxnfc *info)
1339 {
1340         struct qede_dev *edev = netdev_priv(dev);
1341         int rc;
1342
1343         switch (info->cmd) {
1344         case ETHTOOL_SRXFH:
1345                 rc = qede_set_rss_flags(edev, info);
1346                 break;
1347         case ETHTOOL_SRXCLSRLINS:
1348                 rc = qede_add_cls_rule(edev, info);
1349                 break;
1350         case ETHTOOL_SRXCLSRLDEL:
1351                 rc = qede_delete_flow_filter(edev, info->fs.location);
1352                 break;
1353         default:
1354                 DP_INFO(edev, "Command parameters not supported\n");
1355                 rc = -EOPNOTSUPP;
1356         }
1357
1358         return rc;
1359 }
1360
1361 static u32 qede_get_rxfh_indir_size(struct net_device *dev)
1362 {
1363         return QED_RSS_IND_TABLE_SIZE;
1364 }
1365
1366 static u32 qede_get_rxfh_key_size(struct net_device *dev)
1367 {
1368         struct qede_dev *edev = netdev_priv(dev);
1369
1370         return sizeof(edev->rss_key);
1371 }
1372
1373 static int qede_get_rxfh(struct net_device *dev,
1374                          struct ethtool_rxfh_param *rxfh)
1375 {
1376         struct qede_dev *edev = netdev_priv(dev);
1377         int i;
1378
1379         rxfh->hfunc = ETH_RSS_HASH_TOP;
1380
1381         if (!rxfh->indir)
1382                 return 0;
1383
1384         for (i = 0; i < QED_RSS_IND_TABLE_SIZE; i++)
1385                 rxfh->indir[i] = edev->rss_ind_table[i];
1386
1387         if (rxfh->key)
1388                 memcpy(rxfh->key, edev->rss_key, qede_get_rxfh_key_size(dev));
1389
1390         return 0;
1391 }
1392
1393 static int qede_set_rxfh(struct net_device *dev,
1394                          struct ethtool_rxfh_param *rxfh,
1395                          struct netlink_ext_ack *extack)
1396 {
1397         struct qed_update_vport_params *vport_update_params;
1398         struct qede_dev *edev = netdev_priv(dev);
1399         int i, rc = 0;
1400
1401         if (edev->dev_info.common.num_hwfns > 1) {
1402                 DP_INFO(edev,
1403                         "RSS configuration is not supported for 100G devices\n");
1404                 return -EOPNOTSUPP;
1405         }
1406
1407         if (rxfh->hfunc != ETH_RSS_HASH_NO_CHANGE &&
1408             rxfh->hfunc != ETH_RSS_HASH_TOP)
1409                 return -EOPNOTSUPP;
1410
1411         if (!rxfh->indir && !rxfh->key)
1412                 return 0;
1413
1414         if (rxfh->indir) {
1415                 for (i = 0; i < QED_RSS_IND_TABLE_SIZE; i++)
1416                         edev->rss_ind_table[i] = rxfh->indir[i];
1417                 edev->rss_params_inited |= QEDE_RSS_INDIR_INITED;
1418         }
1419
1420         if (rxfh->key) {
1421                 memcpy(&edev->rss_key, rxfh->key, qede_get_rxfh_key_size(dev));
1422                 edev->rss_params_inited |= QEDE_RSS_KEY_INITED;
1423         }
1424
1425         __qede_lock(edev);
1426         if (edev->state == QEDE_STATE_OPEN) {
1427                 vport_update_params = vzalloc(sizeof(*vport_update_params));
1428                 if (!vport_update_params) {
1429                         __qede_unlock(edev);
1430                         return -ENOMEM;
1431                 }
1432                 qede_fill_rss_params(edev, &vport_update_params->rss_params,
1433                                      &vport_update_params->update_rss_flg);
1434                 rc = edev->ops->vport_update(edev->cdev, vport_update_params);
1435                 vfree(vport_update_params);
1436         }
1437         __qede_unlock(edev);
1438
1439         return rc;
1440 }
1441
1442 /* This function enables the interrupt generation and the NAPI on the device */
1443 static void qede_netif_start(struct qede_dev *edev)
1444 {
1445         int i;
1446
1447         if (!netif_running(edev->ndev))
1448                 return;
1449
1450         for_each_queue(i) {
1451                 /* Update and reenable interrupts */
1452                 qed_sb_ack(edev->fp_array[i].sb_info, IGU_INT_ENABLE, 1);
1453                 napi_enable(&edev->fp_array[i].napi);
1454         }
1455 }
1456
1457 /* This function disables the NAPI and the interrupt generation on the device */
1458 static void qede_netif_stop(struct qede_dev *edev)
1459 {
1460         int i;
1461
1462         for_each_queue(i) {
1463                 napi_disable(&edev->fp_array[i].napi);
1464                 /* Disable interrupts */
1465                 qed_sb_ack(edev->fp_array[i].sb_info, IGU_INT_DISABLE, 0);
1466         }
1467 }
1468
1469 static int qede_selftest_transmit_traffic(struct qede_dev *edev,
1470                                           struct sk_buff *skb)
1471 {
1472         struct qede_tx_queue *txq = NULL;
1473         struct eth_tx_1st_bd *first_bd;
1474         dma_addr_t mapping;
1475         int i, idx;
1476         u16 val;
1477
1478         for_each_queue(i) {
1479                 struct qede_fastpath *fp = &edev->fp_array[i];
1480
1481                 if (fp->type & QEDE_FASTPATH_TX) {
1482                         txq = QEDE_FP_TC0_TXQ(fp);
1483                         break;
1484                 }
1485         }
1486
1487         if (!txq) {
1488                 DP_NOTICE(edev, "Tx path is not available\n");
1489                 return -1;
1490         }
1491
1492         /* Fill the entry in the SW ring and the BDs in the FW ring */
1493         idx = txq->sw_tx_prod;
1494         txq->sw_tx_ring.skbs[idx].skb = skb;
1495         first_bd = qed_chain_produce(&txq->tx_pbl);
1496         memset(first_bd, 0, sizeof(*first_bd));
1497         val = 1 << ETH_TX_1ST_BD_FLAGS_START_BD_SHIFT;
1498         first_bd->data.bd_flags.bitfields = val;
1499         val = skb->len & ETH_TX_DATA_1ST_BD_PKT_LEN_MASK;
1500         val = val << ETH_TX_DATA_1ST_BD_PKT_LEN_SHIFT;
1501         first_bd->data.bitfields |= cpu_to_le16(val);
1502
1503         /* Map skb linear data for DMA and set in the first BD */
1504         mapping = dma_map_single(&edev->pdev->dev, skb->data,
1505                                  skb_headlen(skb), DMA_TO_DEVICE);
1506         if (unlikely(dma_mapping_error(&edev->pdev->dev, mapping))) {
1507                 DP_NOTICE(edev, "SKB mapping failed\n");
1508                 return -ENOMEM;
1509         }
1510         BD_SET_UNMAP_ADDR_LEN(first_bd, mapping, skb_headlen(skb));
1511
1512         /* update the first BD with the actual num BDs */
1513         first_bd->data.nbds = 1;
1514         txq->sw_tx_prod = (txq->sw_tx_prod + 1) % txq->num_tx_buffers;
1515         /* 'next page' entries are counted in the producer value */
1516         val = qed_chain_get_prod_idx(&txq->tx_pbl);
1517         txq->tx_db.data.bd_prod = cpu_to_le16(val);
1518
1519         /* wmb makes sure that the BDs data is updated before updating the
1520          * producer, otherwise FW may read old data from the BDs.
1521          */
1522         wmb();
1523         barrier();
1524         writel(txq->tx_db.raw, txq->doorbell_addr);
1525
1526         for (i = 0; i < QEDE_SELFTEST_POLL_COUNT; i++) {
1527                 if (qede_txq_has_work(txq))
1528                         break;
1529                 usleep_range(100, 200);
1530         }
1531
1532         if (!qede_txq_has_work(txq)) {
1533                 DP_NOTICE(edev, "Tx completion didn't happen\n");
1534                 return -1;
1535         }
1536
1537         first_bd = (struct eth_tx_1st_bd *)qed_chain_consume(&txq->tx_pbl);
1538         dma_unmap_single(&edev->pdev->dev, BD_UNMAP_ADDR(first_bd),
1539                          BD_UNMAP_LEN(first_bd), DMA_TO_DEVICE);
1540         txq->sw_tx_cons = (txq->sw_tx_cons + 1) % txq->num_tx_buffers;
1541         txq->sw_tx_ring.skbs[idx].skb = NULL;
1542
1543         return 0;
1544 }
1545
1546 static int qede_selftest_receive_traffic(struct qede_dev *edev)
1547 {
1548         u16 sw_rx_index, len;
1549         struct eth_fast_path_rx_reg_cqe *fp_cqe;
1550         struct qede_rx_queue *rxq = NULL;
1551         struct sw_rx_data *sw_rx_data;
1552         union eth_rx_cqe *cqe;
1553         int i, iter, rc = 0;
1554         u8 *data_ptr;
1555
1556         for_each_queue(i) {
1557                 if (edev->fp_array[i].type & QEDE_FASTPATH_RX) {
1558                         rxq = edev->fp_array[i].rxq;
1559                         break;
1560                 }
1561         }
1562
1563         if (!rxq) {
1564                 DP_NOTICE(edev, "Rx path is not available\n");
1565                 return -1;
1566         }
1567
1568         /* The packet is expected to receive on rx-queue 0 even though RSS is
1569          * enabled. This is because the queue 0 is configured as the default
1570          * queue and that the loopback traffic is not IP.
1571          */
1572         for (iter = 0; iter < QEDE_SELFTEST_POLL_COUNT; iter++) {
1573                 if (!qede_has_rx_work(rxq)) {
1574                         usleep_range(100, 200);
1575                         continue;
1576                 }
1577
1578                 /* Get the CQE from the completion ring */
1579                 cqe = (union eth_rx_cqe *)qed_chain_consume(&rxq->rx_comp_ring);
1580
1581                 /* Get the data from the SW ring */
1582                 sw_rx_index = rxq->sw_rx_cons & NUM_RX_BDS_MAX;
1583                 sw_rx_data = &rxq->sw_rx_ring[sw_rx_index];
1584                 fp_cqe = &cqe->fast_path_regular;
1585                 len =  le16_to_cpu(fp_cqe->len_on_first_bd);
1586                 data_ptr = (u8 *)(page_address(sw_rx_data->data) +
1587                                   fp_cqe->placement_offset +
1588                                   sw_rx_data->page_offset +
1589                                   rxq->rx_headroom);
1590                 if (ether_addr_equal(data_ptr,  edev->ndev->dev_addr) &&
1591                     ether_addr_equal(data_ptr + ETH_ALEN,
1592                                      edev->ndev->dev_addr)) {
1593                         for (i = ETH_HLEN; i < len; i++)
1594                                 if (data_ptr[i] != (unsigned char)(i & 0xff)) {
1595                                         rc = -1;
1596                                         break;
1597                                 }
1598
1599                         qede_recycle_rx_bd_ring(rxq, 1);
1600                         qed_chain_recycle_consumed(&rxq->rx_comp_ring);
1601                         break;
1602                 }
1603
1604                 DP_INFO(edev, "Not the transmitted packet\n");
1605                 qede_recycle_rx_bd_ring(rxq, 1);
1606                 qed_chain_recycle_consumed(&rxq->rx_comp_ring);
1607         }
1608
1609         if (iter == QEDE_SELFTEST_POLL_COUNT) {
1610                 DP_NOTICE(edev, "Failed to receive the traffic\n");
1611                 return -1;
1612         }
1613
1614         qede_update_rx_prod(edev, rxq);
1615
1616         return rc;
1617 }
1618
1619 static int qede_selftest_run_loopback(struct qede_dev *edev, u32 loopback_mode)
1620 {
1621         struct qed_link_params link_params;
1622         struct sk_buff *skb = NULL;
1623         int rc = 0, i;
1624         u32 pkt_size;
1625         u8 *packet;
1626
1627         if (!netif_running(edev->ndev)) {
1628                 DP_NOTICE(edev, "Interface is down\n");
1629                 return -EINVAL;
1630         }
1631
1632         qede_netif_stop(edev);
1633
1634         /* Bring up the link in Loopback mode */
1635         memset(&link_params, 0, sizeof(link_params));
1636         link_params.link_up = true;
1637         link_params.override_flags = QED_LINK_OVERRIDE_LOOPBACK_MODE;
1638         link_params.loopback_mode = loopback_mode;
1639         edev->ops->common->set_link(edev->cdev, &link_params);
1640
1641         /* Wait for loopback configuration to apply */
1642         msleep_interruptible(500);
1643
1644         /* Setting max packet size to 1.5K to avoid data being split over
1645          * multiple BDs in cases where MTU > PAGE_SIZE.
1646          */
1647         pkt_size = (((edev->ndev->mtu < ETH_DATA_LEN) ?
1648                      edev->ndev->mtu : ETH_DATA_LEN) + ETH_HLEN);
1649
1650         skb = netdev_alloc_skb(edev->ndev, pkt_size);
1651         if (!skb) {
1652                 DP_INFO(edev, "Can't allocate skb\n");
1653                 rc = -ENOMEM;
1654                 goto test_loopback_exit;
1655         }
1656         packet = skb_put(skb, pkt_size);
1657         ether_addr_copy(packet, edev->ndev->dev_addr);
1658         ether_addr_copy(packet + ETH_ALEN, edev->ndev->dev_addr);
1659         memset(packet + (2 * ETH_ALEN), 0x77, (ETH_HLEN - (2 * ETH_ALEN)));
1660         for (i = ETH_HLEN; i < pkt_size; i++)
1661                 packet[i] = (unsigned char)(i & 0xff);
1662
1663         rc = qede_selftest_transmit_traffic(edev, skb);
1664         if (rc)
1665                 goto test_loopback_exit;
1666
1667         rc = qede_selftest_receive_traffic(edev);
1668         if (rc)
1669                 goto test_loopback_exit;
1670
1671         DP_VERBOSE(edev, NETIF_MSG_RX_STATUS, "Loopback test successful\n");
1672
1673 test_loopback_exit:
1674         dev_kfree_skb(skb);
1675
1676         /* Bring up the link in Normal mode */
1677         memset(&link_params, 0, sizeof(link_params));
1678         link_params.link_up = true;
1679         link_params.override_flags = QED_LINK_OVERRIDE_LOOPBACK_MODE;
1680         link_params.loopback_mode = QED_LINK_LOOPBACK_NONE;
1681         edev->ops->common->set_link(edev->cdev, &link_params);
1682
1683         /* Wait for loopback configuration to apply */
1684         msleep_interruptible(500);
1685
1686         qede_netif_start(edev);
1687
1688         return rc;
1689 }
1690
1691 static void qede_self_test(struct net_device *dev,
1692                            struct ethtool_test *etest, u64 *buf)
1693 {
1694         struct qede_dev *edev = netdev_priv(dev);
1695
1696         DP_VERBOSE(edev, QED_MSG_DEBUG,
1697                    "Self-test command parameters: offline = %d, external_lb = %d\n",
1698                    (etest->flags & ETH_TEST_FL_OFFLINE),
1699                    (etest->flags & ETH_TEST_FL_EXTERNAL_LB) >> 2);
1700
1701         memset(buf, 0, sizeof(u64) * QEDE_ETHTOOL_TEST_MAX);
1702
1703         if (etest->flags & ETH_TEST_FL_OFFLINE) {
1704                 if (qede_selftest_run_loopback(edev,
1705                                                QED_LINK_LOOPBACK_INT_PHY)) {
1706                         buf[QEDE_ETHTOOL_INT_LOOPBACK] = 1;
1707                         etest->flags |= ETH_TEST_FL_FAILED;
1708                 }
1709         }
1710
1711         if (edev->ops->common->selftest->selftest_interrupt(edev->cdev)) {
1712                 buf[QEDE_ETHTOOL_INTERRUPT_TEST] = 1;
1713                 etest->flags |= ETH_TEST_FL_FAILED;
1714         }
1715
1716         if (edev->ops->common->selftest->selftest_memory(edev->cdev)) {
1717                 buf[QEDE_ETHTOOL_MEMORY_TEST] = 1;
1718                 etest->flags |= ETH_TEST_FL_FAILED;
1719         }
1720
1721         if (edev->ops->common->selftest->selftest_register(edev->cdev)) {
1722                 buf[QEDE_ETHTOOL_REGISTER_TEST] = 1;
1723                 etest->flags |= ETH_TEST_FL_FAILED;
1724         }
1725
1726         if (edev->ops->common->selftest->selftest_clock(edev->cdev)) {
1727                 buf[QEDE_ETHTOOL_CLOCK_TEST] = 1;
1728                 etest->flags |= ETH_TEST_FL_FAILED;
1729         }
1730
1731         if (edev->ops->common->selftest->selftest_nvram(edev->cdev)) {
1732                 buf[QEDE_ETHTOOL_NVRAM_TEST] = 1;
1733                 etest->flags |= ETH_TEST_FL_FAILED;
1734         }
1735 }
1736
1737 static int qede_set_tunable(struct net_device *dev,
1738                             const struct ethtool_tunable *tuna,
1739                             const void *data)
1740 {
1741         struct qede_dev *edev = netdev_priv(dev);
1742         u32 val;
1743
1744         switch (tuna->id) {
1745         case ETHTOOL_RX_COPYBREAK:
1746                 val = *(u32 *)data;
1747                 if (val < QEDE_MIN_PKT_LEN || val > QEDE_RX_HDR_SIZE) {
1748                         DP_VERBOSE(edev, QED_MSG_DEBUG,
1749                                    "Invalid rx copy break value, range is [%u, %u]",
1750                                    QEDE_MIN_PKT_LEN, QEDE_RX_HDR_SIZE);
1751                         return -EINVAL;
1752                 }
1753
1754                 edev->rx_copybreak = *(u32 *)data;
1755                 break;
1756         default:
1757                 return -EOPNOTSUPP;
1758         }
1759
1760         return 0;
1761 }
1762
1763 static int qede_get_tunable(struct net_device *dev,
1764                             const struct ethtool_tunable *tuna, void *data)
1765 {
1766         struct qede_dev *edev = netdev_priv(dev);
1767
1768         switch (tuna->id) {
1769         case ETHTOOL_RX_COPYBREAK:
1770                 *(u32 *)data = edev->rx_copybreak;
1771                 break;
1772         default:
1773                 return -EOPNOTSUPP;
1774         }
1775
1776         return 0;
1777 }
1778
1779 static int qede_get_eee(struct net_device *dev, struct ethtool_keee *edata)
1780 {
1781         struct qede_dev *edev = netdev_priv(dev);
1782         struct qed_link_output current_link;
1783
1784         memset(&current_link, 0, sizeof(current_link));
1785         edev->ops->common->get_link(edev->cdev, &current_link);
1786
1787         if (!current_link.eee_supported) {
1788                 DP_INFO(edev, "EEE is not supported\n");
1789                 return -EOPNOTSUPP;
1790         }
1791
1792         linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
1793                          edata->advertised,
1794                          current_link.eee.adv_caps & QED_EEE_1G_ADV);
1795         linkmode_mod_bit(ETHTOOL_LINK_MODE_10000baseT_Full_BIT,
1796                          edata->advertised,
1797                          current_link.eee.adv_caps & QED_EEE_10G_ADV);
1798
1799         linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
1800                          edata->supported,
1801                          current_link.sup_caps & QED_EEE_1G_ADV);
1802         linkmode_mod_bit(ETHTOOL_LINK_MODE_10000baseT_Full_BIT,
1803                          edata->supported,
1804                          current_link.sup_caps & QED_EEE_10G_ADV);
1805
1806         linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
1807                          edata->lp_advertised,
1808                          current_link.eee.lp_adv_caps & QED_EEE_1G_ADV);
1809         linkmode_mod_bit(ETHTOOL_LINK_MODE_10000baseT_Full_BIT,
1810                          edata->lp_advertised,
1811                          current_link.eee.lp_adv_caps & QED_EEE_10G_ADV);
1812
1813         edata->tx_lpi_timer = current_link.eee.tx_lpi_timer;
1814         edata->eee_enabled = current_link.eee.enable;
1815         edata->tx_lpi_enabled = current_link.eee.tx_lpi_enable;
1816         edata->eee_active = current_link.eee_active;
1817
1818         return 0;
1819 }
1820
1821 static int qede_set_eee(struct net_device *dev, struct ethtool_keee *edata)
1822 {
1823         __ETHTOOL_DECLARE_LINK_MODE_MASK(supported) = {};
1824         __ETHTOOL_DECLARE_LINK_MODE_MASK(tmp) = {};
1825         struct qede_dev *edev = netdev_priv(dev);
1826         struct qed_link_output current_link;
1827         struct qed_link_params params;
1828         bool unsupp;
1829
1830         if (!edev->ops->common->can_link_change(edev->cdev)) {
1831                 DP_INFO(edev, "Link settings are not allowed to be changed\n");
1832                 return -EOPNOTSUPP;
1833         }
1834
1835         memset(&current_link, 0, sizeof(current_link));
1836         edev->ops->common->get_link(edev->cdev, &current_link);
1837
1838         if (!current_link.eee_supported) {
1839                 DP_INFO(edev, "EEE is not supported\n");
1840                 return -EOPNOTSUPP;
1841         }
1842
1843         memset(&params, 0, sizeof(params));
1844         params.override_flags |= QED_LINK_OVERRIDE_EEE_CONFIG;
1845
1846         linkmode_set_bit(ETHTOOL_LINK_MODE_10000baseT_Full_BIT,
1847                          supported);
1848         linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
1849                          supported);
1850
1851         unsupp = linkmode_andnot(tmp, edata->advertised, supported);
1852         if (unsupp) {
1853                 DP_VERBOSE(edev, QED_MSG_DEBUG,
1854                            "Invalid advertised capabilities %*pb\n",
1855                            __ETHTOOL_LINK_MODE_MASK_NBITS, edata->advertised);
1856                 return -EINVAL;
1857         }
1858
1859         if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
1860                               edata->advertised))
1861                 params.eee.adv_caps = QED_EEE_1G_ADV;
1862         if (linkmode_test_bit(ETHTOOL_LINK_MODE_10000baseT_Full_BIT,
1863                               edata->advertised))
1864                 params.eee.adv_caps = QED_EEE_10G_ADV;
1865
1866         params.eee.enable = edata->eee_enabled;
1867         params.eee.tx_lpi_enable = edata->tx_lpi_enabled;
1868         params.eee.tx_lpi_timer = edata->tx_lpi_timer;
1869
1870         params.link_up = true;
1871         edev->ops->common->set_link(edev->cdev, &params);
1872
1873         return 0;
1874 }
1875
1876 static u32 qede_link_to_ethtool_fec(u32 link_fec)
1877 {
1878         u32 eth_fec = 0;
1879
1880         if (link_fec & QED_FEC_MODE_NONE)
1881                 eth_fec |= ETHTOOL_FEC_OFF;
1882         if (link_fec & QED_FEC_MODE_FIRECODE)
1883                 eth_fec |= ETHTOOL_FEC_BASER;
1884         if (link_fec & QED_FEC_MODE_RS)
1885                 eth_fec |= ETHTOOL_FEC_RS;
1886         if (link_fec & QED_FEC_MODE_AUTO)
1887                 eth_fec |= ETHTOOL_FEC_AUTO;
1888         if (link_fec & QED_FEC_MODE_UNSUPPORTED)
1889                 eth_fec |= ETHTOOL_FEC_NONE;
1890
1891         return eth_fec;
1892 }
1893
1894 static u32 qede_ethtool_to_link_fec(u32 eth_fec)
1895 {
1896         u32 link_fec = 0;
1897
1898         if (eth_fec & ETHTOOL_FEC_OFF)
1899                 link_fec |= QED_FEC_MODE_NONE;
1900         if (eth_fec & ETHTOOL_FEC_BASER)
1901                 link_fec |= QED_FEC_MODE_FIRECODE;
1902         if (eth_fec & ETHTOOL_FEC_RS)
1903                 link_fec |= QED_FEC_MODE_RS;
1904         if (eth_fec & ETHTOOL_FEC_AUTO)
1905                 link_fec |= QED_FEC_MODE_AUTO;
1906         if (eth_fec & ETHTOOL_FEC_NONE)
1907                 link_fec |= QED_FEC_MODE_UNSUPPORTED;
1908
1909         return link_fec;
1910 }
1911
1912 static int qede_get_fecparam(struct net_device *dev,
1913                              struct ethtool_fecparam *fecparam)
1914 {
1915         struct qede_dev *edev = netdev_priv(dev);
1916         struct qed_link_output curr_link;
1917
1918         memset(&curr_link, 0, sizeof(curr_link));
1919         edev->ops->common->get_link(edev->cdev, &curr_link);
1920
1921         fecparam->active_fec = qede_link_to_ethtool_fec(curr_link.active_fec);
1922         fecparam->fec = qede_link_to_ethtool_fec(curr_link.sup_fec);
1923
1924         return 0;
1925 }
1926
1927 static int qede_set_fecparam(struct net_device *dev,
1928                              struct ethtool_fecparam *fecparam)
1929 {
1930         struct qede_dev *edev = netdev_priv(dev);
1931         struct qed_link_params params;
1932
1933         if (!edev->ops || !edev->ops->common->can_link_change(edev->cdev)) {
1934                 DP_INFO(edev, "Link settings are not allowed to be changed\n");
1935                 return -EOPNOTSUPP;
1936         }
1937
1938         memset(&params, 0, sizeof(params));
1939         params.override_flags |= QED_LINK_OVERRIDE_FEC_CONFIG;
1940         params.fec = qede_ethtool_to_link_fec(fecparam->fec);
1941         params.link_up = true;
1942
1943         edev->ops->common->set_link(edev->cdev, &params);
1944
1945         return 0;
1946 }
1947
1948 static int qede_get_module_info(struct net_device *dev,
1949                                 struct ethtool_modinfo *modinfo)
1950 {
1951         struct qede_dev *edev = netdev_priv(dev);
1952         u8 buf[4];
1953         int rc;
1954
1955         /* Read first 4 bytes to find the sfp type */
1956         rc = edev->ops->common->read_module_eeprom(edev->cdev, buf,
1957                                                    QED_I2C_DEV_ADDR_A0, 0, 4);
1958         if (rc) {
1959                 DP_ERR(edev, "Failed reading EEPROM data %d\n", rc);
1960                 return rc;
1961         }
1962
1963         switch (buf[0]) {
1964         case 0x3: /* SFP, SFP+, SFP-28 */
1965                 modinfo->type = ETH_MODULE_SFF_8472;
1966                 modinfo->eeprom_len = ETH_MODULE_SFF_8472_LEN;
1967                 break;
1968         case 0xc: /* QSFP */
1969         case 0xd: /* QSFP+ */
1970                 modinfo->type = ETH_MODULE_SFF_8436;
1971                 modinfo->eeprom_len = ETH_MODULE_SFF_8436_LEN;
1972                 break;
1973         case 0x11: /* QSFP-28 */
1974                 modinfo->type = ETH_MODULE_SFF_8636;
1975                 modinfo->eeprom_len = ETH_MODULE_SFF_8636_LEN;
1976                 break;
1977         default:
1978                 DP_ERR(edev, "Unknown transceiver type 0x%x\n", buf[0]);
1979                 return -EINVAL;
1980         }
1981
1982         return 0;
1983 }
1984
1985 static int qede_get_module_eeprom(struct net_device *dev,
1986                                   struct ethtool_eeprom *ee, u8 *data)
1987 {
1988         struct qede_dev *edev = netdev_priv(dev);
1989         u32 start_addr = ee->offset, size = 0;
1990         u8 *buf = data;
1991         int rc = 0;
1992
1993         /* Read A0 section */
1994         if (ee->offset < ETH_MODULE_SFF_8079_LEN) {
1995                 /* Limit transfer size to the A0 section boundary */
1996                 if (ee->offset + ee->len > ETH_MODULE_SFF_8079_LEN)
1997                         size = ETH_MODULE_SFF_8079_LEN - ee->offset;
1998                 else
1999                         size = ee->len;
2000
2001                 rc = edev->ops->common->read_module_eeprom(edev->cdev, buf,
2002                                                            QED_I2C_DEV_ADDR_A0,
2003                                                            start_addr, size);
2004                 if (rc) {
2005                         DP_ERR(edev, "Failed reading A0 section  %d\n", rc);
2006                         return rc;
2007                 }
2008
2009                 buf += size;
2010                 start_addr += size;
2011         }
2012
2013         /* Read A2 section */
2014         if (start_addr >= ETH_MODULE_SFF_8079_LEN &&
2015             start_addr < ETH_MODULE_SFF_8472_LEN) {
2016                 size = ee->len - size;
2017                 /* Limit transfer size to the A2 section boundary */
2018                 if (start_addr + size > ETH_MODULE_SFF_8472_LEN)
2019                         size = ETH_MODULE_SFF_8472_LEN - start_addr;
2020                 start_addr -= ETH_MODULE_SFF_8079_LEN;
2021                 rc = edev->ops->common->read_module_eeprom(edev->cdev, buf,
2022                                                            QED_I2C_DEV_ADDR_A2,
2023                                                            start_addr, size);
2024                 if (rc) {
2025                         DP_VERBOSE(edev, QED_MSG_DEBUG,
2026                                    "Failed reading A2 section %d\n", rc);
2027                         return 0;
2028                 }
2029         }
2030
2031         return rc;
2032 }
2033
2034 static int qede_set_dump(struct net_device *dev, struct ethtool_dump *val)
2035 {
2036         struct qede_dev *edev = netdev_priv(dev);
2037         int rc = 0;
2038
2039         if (edev->dump_info.cmd == QEDE_DUMP_CMD_NONE) {
2040                 if (val->flag > QEDE_DUMP_CMD_MAX) {
2041                         DP_ERR(edev, "Invalid command %d\n", val->flag);
2042                         return -EINVAL;
2043                 }
2044                 edev->dump_info.cmd = val->flag;
2045                 edev->dump_info.num_args = 0;
2046                 return 0;
2047         }
2048
2049         if (edev->dump_info.num_args == QEDE_DUMP_MAX_ARGS) {
2050                 DP_ERR(edev, "Arg count = %d\n", edev->dump_info.num_args);
2051                 return -EINVAL;
2052         }
2053
2054         switch (edev->dump_info.cmd) {
2055         case QEDE_DUMP_CMD_NVM_CFG:
2056                 edev->dump_info.args[edev->dump_info.num_args] = val->flag;
2057                 edev->dump_info.num_args++;
2058                 break;
2059         case QEDE_DUMP_CMD_GRCDUMP:
2060                 rc = edev->ops->common->set_grc_config(edev->cdev,
2061                                                        val->flag, 1);
2062                 break;
2063         default:
2064                 break;
2065         }
2066
2067         return rc;
2068 }
2069
2070 static int qede_get_dump_flag(struct net_device *dev,
2071                               struct ethtool_dump *dump)
2072 {
2073         struct qede_dev *edev = netdev_priv(dev);
2074
2075         if (!edev->ops || !edev->ops->common) {
2076                 DP_ERR(edev, "Edev ops not populated\n");
2077                 return -EINVAL;
2078         }
2079
2080         dump->version = QEDE_DUMP_VERSION;
2081         switch (edev->dump_info.cmd) {
2082         case QEDE_DUMP_CMD_NVM_CFG:
2083                 dump->flag = QEDE_DUMP_CMD_NVM_CFG;
2084                 dump->len = edev->ops->common->read_nvm_cfg_len(edev->cdev,
2085                                                 edev->dump_info.args[0]);
2086                 break;
2087         case QEDE_DUMP_CMD_GRCDUMP:
2088                 dump->flag = QEDE_DUMP_CMD_GRCDUMP;
2089                 dump->len = edev->ops->common->dbg_all_data_size(edev->cdev);
2090                 break;
2091         default:
2092                 DP_ERR(edev, "Invalid cmd = %d\n", edev->dump_info.cmd);
2093                 return -EINVAL;
2094         }
2095
2096         DP_VERBOSE(edev, QED_MSG_DEBUG,
2097                    "dump->version = 0x%x dump->flag = %d dump->len = %d\n",
2098                    dump->version, dump->flag, dump->len);
2099         return 0;
2100 }
2101
2102 static int qede_get_dump_data(struct net_device *dev,
2103                               struct ethtool_dump *dump, void *buf)
2104 {
2105         struct qede_dev *edev = netdev_priv(dev);
2106         int rc = 0;
2107
2108         if (!edev->ops || !edev->ops->common) {
2109                 DP_ERR(edev, "Edev ops not populated\n");
2110                 rc = -EINVAL;
2111                 goto err;
2112         }
2113
2114         switch (edev->dump_info.cmd) {
2115         case QEDE_DUMP_CMD_NVM_CFG:
2116                 if (edev->dump_info.num_args != QEDE_DUMP_NVM_ARG_COUNT) {
2117                         DP_ERR(edev, "Arg count = %d required = %d\n",
2118                                edev->dump_info.num_args,
2119                                QEDE_DUMP_NVM_ARG_COUNT);
2120                         rc = -EINVAL;
2121                         goto err;
2122                 }
2123                 rc =  edev->ops->common->read_nvm_cfg(edev->cdev, (u8 **)&buf,
2124                                                       edev->dump_info.args[0],
2125                                                       edev->dump_info.args[1]);
2126                 break;
2127         case QEDE_DUMP_CMD_GRCDUMP:
2128                 memset(buf, 0, dump->len);
2129                 rc = edev->ops->common->dbg_all_data(edev->cdev, buf);
2130                 break;
2131         default:
2132                 DP_ERR(edev, "Invalid cmd = %d\n", edev->dump_info.cmd);
2133                 rc = -EINVAL;
2134                 break;
2135         }
2136
2137 err:
2138         edev->dump_info.cmd = QEDE_DUMP_CMD_NONE;
2139         edev->dump_info.num_args = 0;
2140         memset(edev->dump_info.args, 0, sizeof(edev->dump_info.args));
2141
2142         return rc;
2143 }
2144
2145 int qede_set_per_coalesce(struct net_device *dev, u32 queue,
2146                           struct ethtool_coalesce *coal)
2147 {
2148         struct qede_dev *edev = netdev_priv(dev);
2149         struct qede_fastpath *fp;
2150         u16 rxc, txc;
2151         int rc = 0;
2152
2153         if (coal->rx_coalesce_usecs > QED_COALESCE_MAX ||
2154             coal->tx_coalesce_usecs > QED_COALESCE_MAX) {
2155                 DP_INFO(edev,
2156                         "Can't support requested %s coalesce value [max supported value %d]\n",
2157                         coal->rx_coalesce_usecs > QED_COALESCE_MAX ? "rx"
2158                                                                    : "tx",
2159                         QED_COALESCE_MAX);
2160                 return -EINVAL;
2161         }
2162
2163         rxc = (u16)coal->rx_coalesce_usecs;
2164         txc = (u16)coal->tx_coalesce_usecs;
2165
2166         __qede_lock(edev);
2167         if (queue >= edev->num_queues) {
2168                 DP_INFO(edev, "Invalid queue\n");
2169                 rc = -EINVAL;
2170                 goto out;
2171         }
2172
2173         if (edev->state != QEDE_STATE_OPEN) {
2174                 rc = -EINVAL;
2175                 goto out;
2176         }
2177
2178         fp = &edev->fp_array[queue];
2179
2180         if (edev->fp_array[queue].type & QEDE_FASTPATH_RX) {
2181                 rc = edev->ops->common->set_coalesce(edev->cdev,
2182                                                      rxc, 0,
2183                                                      fp->rxq->handle);
2184                 if (rc) {
2185                         DP_INFO(edev,
2186                                 "Set RX coalesce error, rc = %d\n", rc);
2187                         goto out;
2188                 }
2189                 edev->coal_entry[queue].rxc = rxc;
2190                 edev->coal_entry[queue].isvalid = true;
2191         }
2192
2193         if (edev->fp_array[queue].type & QEDE_FASTPATH_TX) {
2194                 rc = edev->ops->common->set_coalesce(edev->cdev,
2195                                                      0, txc,
2196                                                      fp->txq->handle);
2197                 if (rc) {
2198                         DP_INFO(edev,
2199                                 "Set TX coalesce error, rc = %d\n", rc);
2200                         goto out;
2201                 }
2202                 edev->coal_entry[queue].txc = txc;
2203                 edev->coal_entry[queue].isvalid = true;
2204         }
2205 out:
2206         __qede_unlock(edev);
2207
2208         return rc;
2209 }
2210
2211 static int qede_get_per_coalesce(struct net_device *dev,
2212                                  u32 queue,
2213                                  struct ethtool_coalesce *coal)
2214 {
2215         void *rx_handle = NULL, *tx_handle = NULL;
2216         struct qede_dev *edev = netdev_priv(dev);
2217         struct qede_fastpath *fp;
2218         u16 rx_coal, tx_coal;
2219         int rc = 0;
2220
2221         rx_coal = QED_DEFAULT_RX_USECS;
2222         tx_coal = QED_DEFAULT_TX_USECS;
2223
2224         memset(coal, 0, sizeof(struct ethtool_coalesce));
2225
2226         __qede_lock(edev);
2227         if (queue >= edev->num_queues) {
2228                 DP_INFO(edev, "Invalid queue\n");
2229                 rc = -EINVAL;
2230                 goto out;
2231         }
2232
2233         if (edev->state != QEDE_STATE_OPEN) {
2234                 rc = -EINVAL;
2235                 goto out;
2236         }
2237
2238         fp = &edev->fp_array[queue];
2239
2240         if (fp->type & QEDE_FASTPATH_RX)
2241                 rx_handle = fp->rxq->handle;
2242
2243         rc = edev->ops->get_coalesce(edev->cdev, &rx_coal,
2244                                      rx_handle);
2245         if (rc) {
2246                 DP_INFO(edev, "Read Rx coalesce error\n");
2247                 goto out;
2248         }
2249
2250         fp = &edev->fp_array[queue];
2251         if (fp->type & QEDE_FASTPATH_TX)
2252                 tx_handle = fp->txq->handle;
2253
2254         rc = edev->ops->get_coalesce(edev->cdev, &tx_coal,
2255                                       tx_handle);
2256         if (rc)
2257                 DP_INFO(edev, "Read Tx coalesce error\n");
2258
2259 out:
2260         __qede_unlock(edev);
2261
2262         coal->rx_coalesce_usecs = rx_coal;
2263         coal->tx_coalesce_usecs = tx_coal;
2264
2265         return rc;
2266 }
2267
2268 static const struct ethtool_ops qede_ethtool_ops = {
2269         .supported_coalesce_params      = ETHTOOL_COALESCE_USECS |
2270                                           ETHTOOL_COALESCE_STATS_BLOCK_USECS,
2271         .get_link_ksettings             = qede_get_link_ksettings,
2272         .set_link_ksettings             = qede_set_link_ksettings,
2273         .get_drvinfo                    = qede_get_drvinfo,
2274         .get_regs_len                   = qede_get_regs_len,
2275         .get_regs                       = qede_get_regs,
2276         .get_wol                        = qede_get_wol,
2277         .set_wol                        = qede_set_wol,
2278         .get_msglevel                   = qede_get_msglevel,
2279         .set_msglevel                   = qede_set_msglevel,
2280         .nway_reset                     = qede_nway_reset,
2281         .get_link                       = qede_get_link,
2282         .get_coalesce                   = qede_get_coalesce,
2283         .set_coalesce                   = qede_set_coalesce,
2284         .get_ringparam                  = qede_get_ringparam,
2285         .set_ringparam                  = qede_set_ringparam,
2286         .get_pauseparam                 = qede_get_pauseparam,
2287         .set_pauseparam                 = qede_set_pauseparam,
2288         .get_strings                    = qede_get_strings,
2289         .set_phys_id                    = qede_set_phys_id,
2290         .get_ethtool_stats              = qede_get_ethtool_stats,
2291         .get_priv_flags                 = qede_get_priv_flags,
2292         .set_priv_flags                 = qede_set_priv_flags,
2293         .get_sset_count                 = qede_get_sset_count,
2294         .get_rxnfc                      = qede_get_rxnfc,
2295         .set_rxnfc                      = qede_set_rxnfc,
2296         .get_rxfh_indir_size            = qede_get_rxfh_indir_size,
2297         .get_rxfh_key_size              = qede_get_rxfh_key_size,
2298         .get_rxfh                       = qede_get_rxfh,
2299         .set_rxfh                       = qede_set_rxfh,
2300         .get_ts_info                    = qede_get_ts_info,
2301         .get_channels                   = qede_get_channels,
2302         .set_channels                   = qede_set_channels,
2303         .self_test                      = qede_self_test,
2304         .get_module_info                = qede_get_module_info,
2305         .get_module_eeprom              = qede_get_module_eeprom,
2306         .get_eee                        = qede_get_eee,
2307         .set_eee                        = qede_set_eee,
2308         .get_fecparam                   = qede_get_fecparam,
2309         .set_fecparam                   = qede_set_fecparam,
2310         .get_tunable                    = qede_get_tunable,
2311         .set_tunable                    = qede_set_tunable,
2312         .get_per_queue_coalesce         = qede_get_per_coalesce,
2313         .set_per_queue_coalesce         = qede_set_per_coalesce,
2314         .flash_device                   = qede_flash_device,
2315         .get_dump_flag                  = qede_get_dump_flag,
2316         .get_dump_data                  = qede_get_dump_data,
2317         .set_dump                       = qede_set_dump,
2318 };
2319
2320 static const struct ethtool_ops qede_vf_ethtool_ops = {
2321         .supported_coalesce_params      = ETHTOOL_COALESCE_USECS |
2322                                           ETHTOOL_COALESCE_STATS_BLOCK_USECS,
2323         .get_link_ksettings             = qede_get_link_ksettings,
2324         .get_drvinfo                    = qede_get_drvinfo,
2325         .get_msglevel                   = qede_get_msglevel,
2326         .set_msglevel                   = qede_set_msglevel,
2327         .get_link                       = qede_get_link,
2328         .get_coalesce                   = qede_get_coalesce,
2329         .set_coalesce                   = qede_set_coalesce,
2330         .get_ringparam                  = qede_get_ringparam,
2331         .set_ringparam                  = qede_set_ringparam,
2332         .get_strings                    = qede_get_strings,
2333         .get_ethtool_stats              = qede_get_ethtool_stats,
2334         .get_priv_flags                 = qede_get_priv_flags,
2335         .get_sset_count                 = qede_get_sset_count,
2336         .get_rxnfc                      = qede_get_rxnfc,
2337         .set_rxnfc                      = qede_set_rxnfc,
2338         .get_rxfh_indir_size            = qede_get_rxfh_indir_size,
2339         .get_rxfh_key_size              = qede_get_rxfh_key_size,
2340         .get_rxfh                       = qede_get_rxfh,
2341         .set_rxfh                       = qede_set_rxfh,
2342         .get_channels                   = qede_get_channels,
2343         .set_channels                   = qede_set_channels,
2344         .get_per_queue_coalesce         = qede_get_per_coalesce,
2345         .set_per_queue_coalesce         = qede_set_per_coalesce,
2346         .get_tunable                    = qede_get_tunable,
2347         .set_tunable                    = qede_set_tunable,
2348 };
2349
2350 void qede_set_ethtool_ops(struct net_device *dev)
2351 {
2352         struct qede_dev *edev = netdev_priv(dev);
2353
2354         if (IS_VF(edev))
2355                 dev->ethtool_ops = &qede_vf_ethtool_ops;
2356         else
2357                 dev->ethtool_ops = &qede_ethtool_ops;
2358 }