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