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