xref: /linux/drivers/net/ethernet/qlogic/qede/qede_ethtool.c (revision a64f302022ba2f7e7b1cc185cbc95b454ae4ae8f)
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_rxfh_fields(struct net_device *dev,
1172 				struct ethtool_rxfh_fields *info)
1173 {
1174 	struct qede_dev *edev = netdev_priv(dev);
1175 
1176 	info->data = RXH_IP_SRC | RXH_IP_DST;
1177 
1178 	switch (info->flow_type) {
1179 	case TCP_V4_FLOW:
1180 	case TCP_V6_FLOW:
1181 		info->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
1182 		break;
1183 	case UDP_V4_FLOW:
1184 		if (edev->rss_caps & QED_RSS_IPV4_UDP)
1185 			info->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
1186 		break;
1187 	case UDP_V6_FLOW:
1188 		if (edev->rss_caps & QED_RSS_IPV6_UDP)
1189 			info->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
1190 		break;
1191 	case IPV4_FLOW:
1192 	case IPV6_FLOW:
1193 		break;
1194 	default:
1195 		info->data = 0;
1196 		break;
1197 	}
1198 
1199 	return 0;
1200 }
1201 
1202 static u32 qede_get_rx_ring_count(struct net_device *dev)
1203 {
1204 	struct qede_dev *edev = netdev_priv(dev);
1205 
1206 	return QEDE_RSS_COUNT(edev);
1207 }
1208 
1209 static int qede_get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *info,
1210 			  u32 *rule_locs)
1211 {
1212 	struct qede_dev *edev = netdev_priv(dev);
1213 	int rc = 0;
1214 
1215 	switch (info->cmd) {
1216 	case ETHTOOL_GRXCLSRLCNT:
1217 		info->rule_cnt = qede_get_arfs_filter_count(edev);
1218 		info->data = QEDE_RFS_MAX_FLTR;
1219 		break;
1220 	case ETHTOOL_GRXCLSRULE:
1221 		rc = qede_get_cls_rule_entry(edev, info);
1222 		break;
1223 	case ETHTOOL_GRXCLSRLALL:
1224 		rc = qede_get_cls_rule_all(edev, info, rule_locs);
1225 		break;
1226 	default:
1227 		DP_ERR(edev, "Command parameters not supported\n");
1228 		rc = -EOPNOTSUPP;
1229 	}
1230 
1231 	return rc;
1232 }
1233 
1234 static int qede_set_rxfh_fields(struct net_device *dev,
1235 				const struct ethtool_rxfh_fields *info,
1236 				struct netlink_ext_ack *extack)
1237 {
1238 	struct qed_update_vport_params *vport_update_params;
1239 	struct qede_dev *edev = netdev_priv(dev);
1240 	u8 set_caps = 0, clr_caps = 0;
1241 	int rc = 0;
1242 
1243 	DP_VERBOSE(edev, QED_MSG_DEBUG,
1244 		   "Set rss flags command parameters: flow type = %d, data = %u\n",
1245 		   info->flow_type, info->data);
1246 
1247 	switch (info->flow_type) {
1248 	case TCP_V4_FLOW:
1249 	case TCP_V6_FLOW:
1250 		/* For TCP only 4-tuple hash is supported */
1251 		if (info->data ^ (RXH_IP_SRC | RXH_IP_DST |
1252 				  RXH_L4_B_0_1 | RXH_L4_B_2_3)) {
1253 			DP_INFO(edev, "Command parameters not supported\n");
1254 			return -EINVAL;
1255 		}
1256 		return 0;
1257 	case UDP_V4_FLOW:
1258 		/* For UDP either 2-tuple hash or 4-tuple hash is supported */
1259 		if (info->data == (RXH_IP_SRC | RXH_IP_DST |
1260 				   RXH_L4_B_0_1 | RXH_L4_B_2_3)) {
1261 			set_caps = QED_RSS_IPV4_UDP;
1262 			DP_VERBOSE(edev, QED_MSG_DEBUG,
1263 				   "UDP 4-tuple enabled\n");
1264 		} else if (info->data == (RXH_IP_SRC | RXH_IP_DST)) {
1265 			clr_caps = QED_RSS_IPV4_UDP;
1266 			DP_VERBOSE(edev, QED_MSG_DEBUG,
1267 				   "UDP 4-tuple disabled\n");
1268 		} else {
1269 			return -EINVAL;
1270 		}
1271 		break;
1272 	case UDP_V6_FLOW:
1273 		/* For UDP either 2-tuple hash or 4-tuple hash is supported */
1274 		if (info->data == (RXH_IP_SRC | RXH_IP_DST |
1275 				   RXH_L4_B_0_1 | RXH_L4_B_2_3)) {
1276 			set_caps = QED_RSS_IPV6_UDP;
1277 			DP_VERBOSE(edev, QED_MSG_DEBUG,
1278 				   "UDP 4-tuple enabled\n");
1279 		} else if (info->data == (RXH_IP_SRC | RXH_IP_DST)) {
1280 			clr_caps = QED_RSS_IPV6_UDP;
1281 			DP_VERBOSE(edev, QED_MSG_DEBUG,
1282 				   "UDP 4-tuple disabled\n");
1283 		} else {
1284 			return -EINVAL;
1285 		}
1286 		break;
1287 	case IPV4_FLOW:
1288 	case IPV6_FLOW:
1289 		/* For IP only 2-tuple hash is supported */
1290 		if (info->data ^ (RXH_IP_SRC | RXH_IP_DST)) {
1291 			DP_INFO(edev, "Command parameters not supported\n");
1292 			return -EINVAL;
1293 		}
1294 		return 0;
1295 	case SCTP_V4_FLOW:
1296 	case AH_ESP_V4_FLOW:
1297 	case AH_V4_FLOW:
1298 	case ESP_V4_FLOW:
1299 	case SCTP_V6_FLOW:
1300 	case AH_ESP_V6_FLOW:
1301 	case AH_V6_FLOW:
1302 	case ESP_V6_FLOW:
1303 	case IP_USER_FLOW:
1304 	case ETHER_FLOW:
1305 		/* RSS is not supported for these protocols */
1306 		if (info->data) {
1307 			DP_INFO(edev, "Command parameters not supported\n");
1308 			return -EINVAL;
1309 		}
1310 		return 0;
1311 	default:
1312 		return -EINVAL;
1313 	}
1314 
1315 	/* No action is needed if there is no change in the rss capability */
1316 	if (edev->rss_caps == ((edev->rss_caps & ~clr_caps) | set_caps))
1317 		return 0;
1318 
1319 	/* Update internal configuration */
1320 	edev->rss_caps = ((edev->rss_caps & ~clr_caps) | set_caps);
1321 	edev->rss_params_inited |= QEDE_RSS_CAPS_INITED;
1322 
1323 	/* Re-configure if possible */
1324 	__qede_lock(edev);
1325 	if (edev->state == QEDE_STATE_OPEN) {
1326 		vport_update_params = vzalloc(sizeof(*vport_update_params));
1327 		if (!vport_update_params) {
1328 			__qede_unlock(edev);
1329 			return -ENOMEM;
1330 		}
1331 		qede_fill_rss_params(edev, &vport_update_params->rss_params,
1332 				     &vport_update_params->update_rss_flg);
1333 		rc = edev->ops->vport_update(edev->cdev, vport_update_params);
1334 		vfree(vport_update_params);
1335 	}
1336 	__qede_unlock(edev);
1337 
1338 	return rc;
1339 }
1340 
1341 static int qede_set_rxnfc(struct net_device *dev, struct ethtool_rxnfc *info)
1342 {
1343 	struct qede_dev *edev = netdev_priv(dev);
1344 	int rc;
1345 
1346 	switch (info->cmd) {
1347 	case ETHTOOL_SRXCLSRLINS:
1348 		rc = qede_add_cls_rule(edev, info);
1349 		break;
1350 	case ETHTOOL_SRXCLSRLDEL:
1351 		rc = qede_delete_flow_filter(edev, info->fs.location);
1352 		break;
1353 	default:
1354 		DP_INFO(edev, "Command parameters not supported\n");
1355 		rc = -EOPNOTSUPP;
1356 	}
1357 
1358 	return rc;
1359 }
1360 
1361 static u32 qede_get_rxfh_indir_size(struct net_device *dev)
1362 {
1363 	return QED_RSS_IND_TABLE_SIZE;
1364 }
1365 
1366 static u32 qede_get_rxfh_key_size(struct net_device *dev)
1367 {
1368 	struct qede_dev *edev = netdev_priv(dev);
1369 
1370 	return sizeof(edev->rss_key);
1371 }
1372 
1373 static int qede_get_rxfh(struct net_device *dev,
1374 			 struct ethtool_rxfh_param *rxfh)
1375 {
1376 	struct qede_dev *edev = netdev_priv(dev);
1377 	int i;
1378 
1379 	rxfh->hfunc = ETH_RSS_HASH_TOP;
1380 
1381 	if (!rxfh->indir)
1382 		return 0;
1383 
1384 	for (i = 0; i < QED_RSS_IND_TABLE_SIZE; i++)
1385 		rxfh->indir[i] = edev->rss_ind_table[i];
1386 
1387 	if (rxfh->key)
1388 		memcpy(rxfh->key, edev->rss_key, qede_get_rxfh_key_size(dev));
1389 
1390 	return 0;
1391 }
1392 
1393 static int qede_set_rxfh(struct net_device *dev,
1394 			 struct ethtool_rxfh_param *rxfh,
1395 			 struct netlink_ext_ack *extack)
1396 {
1397 	struct qed_update_vport_params *vport_update_params;
1398 	struct qede_dev *edev = netdev_priv(dev);
1399 	int i, rc = 0;
1400 
1401 	if (edev->dev_info.common.num_hwfns > 1) {
1402 		DP_INFO(edev,
1403 			"RSS configuration is not supported for 100G devices\n");
1404 		return -EOPNOTSUPP;
1405 	}
1406 
1407 	if (rxfh->hfunc != ETH_RSS_HASH_NO_CHANGE &&
1408 	    rxfh->hfunc != ETH_RSS_HASH_TOP)
1409 		return -EOPNOTSUPP;
1410 
1411 	if (!rxfh->indir && !rxfh->key)
1412 		return 0;
1413 
1414 	if (rxfh->indir) {
1415 		for (i = 0; i < QED_RSS_IND_TABLE_SIZE; i++)
1416 			edev->rss_ind_table[i] = rxfh->indir[i];
1417 		edev->rss_params_inited |= QEDE_RSS_INDIR_INITED;
1418 	}
1419 
1420 	if (rxfh->key) {
1421 		memcpy(&edev->rss_key, rxfh->key, qede_get_rxfh_key_size(dev));
1422 		edev->rss_params_inited |= QEDE_RSS_KEY_INITED;
1423 	}
1424 
1425 	__qede_lock(edev);
1426 	if (edev->state == QEDE_STATE_OPEN) {
1427 		vport_update_params = vzalloc(sizeof(*vport_update_params));
1428 		if (!vport_update_params) {
1429 			__qede_unlock(edev);
1430 			return -ENOMEM;
1431 		}
1432 		qede_fill_rss_params(edev, &vport_update_params->rss_params,
1433 				     &vport_update_params->update_rss_flg);
1434 		rc = edev->ops->vport_update(edev->cdev, vport_update_params);
1435 		vfree(vport_update_params);
1436 	}
1437 	__qede_unlock(edev);
1438 
1439 	return rc;
1440 }
1441 
1442 /* This function enables the interrupt generation and the NAPI on the device */
1443 static void qede_netif_start(struct qede_dev *edev)
1444 {
1445 	int i;
1446 
1447 	if (!netif_running(edev->ndev))
1448 		return;
1449 
1450 	for_each_queue(i) {
1451 		/* Update and reenable interrupts */
1452 		qed_sb_ack(edev->fp_array[i].sb_info, IGU_INT_ENABLE, 1);
1453 		napi_enable(&edev->fp_array[i].napi);
1454 	}
1455 }
1456 
1457 /* This function disables the NAPI and the interrupt generation on the device */
1458 static void qede_netif_stop(struct qede_dev *edev)
1459 {
1460 	int i;
1461 
1462 	for_each_queue(i) {
1463 		napi_disable(&edev->fp_array[i].napi);
1464 		/* Disable interrupts */
1465 		qed_sb_ack(edev->fp_array[i].sb_info, IGU_INT_DISABLE, 0);
1466 	}
1467 }
1468 
1469 static int qede_selftest_transmit_traffic(struct qede_dev *edev,
1470 					  struct sk_buff *skb)
1471 {
1472 	struct qede_tx_queue *txq = NULL;
1473 	struct eth_tx_1st_bd *first_bd;
1474 	dma_addr_t mapping;
1475 	int i, idx;
1476 	u16 val;
1477 
1478 	for_each_queue(i) {
1479 		struct qede_fastpath *fp = &edev->fp_array[i];
1480 
1481 		if (fp->type & QEDE_FASTPATH_TX) {
1482 			txq = QEDE_FP_TC0_TXQ(fp);
1483 			break;
1484 		}
1485 	}
1486 
1487 	if (!txq) {
1488 		DP_NOTICE(edev, "Tx path is not available\n");
1489 		return -1;
1490 	}
1491 
1492 	/* Fill the entry in the SW ring and the BDs in the FW ring */
1493 	idx = txq->sw_tx_prod;
1494 	txq->sw_tx_ring.skbs[idx].skb = skb;
1495 	first_bd = qed_chain_produce(&txq->tx_pbl);
1496 	memset(first_bd, 0, sizeof(*first_bd));
1497 	val = 1 << ETH_TX_1ST_BD_FLAGS_START_BD_SHIFT;
1498 	first_bd->data.bd_flags.bitfields = val;
1499 	val = skb->len & ETH_TX_DATA_1ST_BD_PKT_LEN_MASK;
1500 	val = val << ETH_TX_DATA_1ST_BD_PKT_LEN_SHIFT;
1501 	first_bd->data.bitfields |= cpu_to_le16(val);
1502 
1503 	/* Map skb linear data for DMA and set in the first BD */
1504 	mapping = dma_map_single(&edev->pdev->dev, skb->data,
1505 				 skb_headlen(skb), DMA_TO_DEVICE);
1506 	if (unlikely(dma_mapping_error(&edev->pdev->dev, mapping))) {
1507 		DP_NOTICE(edev, "SKB mapping failed\n");
1508 		return -ENOMEM;
1509 	}
1510 	BD_SET_UNMAP_ADDR_LEN(first_bd, mapping, skb_headlen(skb));
1511 
1512 	/* update the first BD with the actual num BDs */
1513 	first_bd->data.nbds = 1;
1514 	txq->sw_tx_prod = (txq->sw_tx_prod + 1) % txq->num_tx_buffers;
1515 	/* 'next page' entries are counted in the producer value */
1516 	val = qed_chain_get_prod_idx(&txq->tx_pbl);
1517 	txq->tx_db.data.bd_prod = cpu_to_le16(val);
1518 
1519 	/* wmb makes sure that the BDs data is updated before updating the
1520 	 * producer, otherwise FW may read old data from the BDs.
1521 	 */
1522 	wmb();
1523 	barrier();
1524 	writel(txq->tx_db.raw, txq->doorbell_addr);
1525 
1526 	for (i = 0; i < QEDE_SELFTEST_POLL_COUNT; i++) {
1527 		if (qede_txq_has_work(txq))
1528 			break;
1529 		usleep_range(100, 200);
1530 	}
1531 
1532 	if (!qede_txq_has_work(txq)) {
1533 		DP_NOTICE(edev, "Tx completion didn't happen\n");
1534 		return -1;
1535 	}
1536 
1537 	first_bd = (struct eth_tx_1st_bd *)qed_chain_consume(&txq->tx_pbl);
1538 	dma_unmap_single(&edev->pdev->dev, BD_UNMAP_ADDR(first_bd),
1539 			 BD_UNMAP_LEN(first_bd), DMA_TO_DEVICE);
1540 	txq->sw_tx_cons = (txq->sw_tx_cons + 1) % txq->num_tx_buffers;
1541 	txq->sw_tx_ring.skbs[idx].skb = NULL;
1542 
1543 	return 0;
1544 }
1545 
1546 static int qede_selftest_receive_traffic(struct qede_dev *edev)
1547 {
1548 	u16 sw_rx_index, len;
1549 	struct eth_fast_path_rx_reg_cqe *fp_cqe;
1550 	struct qede_rx_queue *rxq = NULL;
1551 	struct sw_rx_data *sw_rx_data;
1552 	union eth_rx_cqe *cqe;
1553 	int i, iter, rc = 0;
1554 	u8 *data_ptr;
1555 
1556 	for_each_queue(i) {
1557 		if (edev->fp_array[i].type & QEDE_FASTPATH_RX) {
1558 			rxq = edev->fp_array[i].rxq;
1559 			break;
1560 		}
1561 	}
1562 
1563 	if (!rxq) {
1564 		DP_NOTICE(edev, "Rx path is not available\n");
1565 		return -1;
1566 	}
1567 
1568 	/* The packet is expected to receive on rx-queue 0 even though RSS is
1569 	 * enabled. This is because the queue 0 is configured as the default
1570 	 * queue and that the loopback traffic is not IP.
1571 	 */
1572 	for (iter = 0; iter < QEDE_SELFTEST_POLL_COUNT; iter++) {
1573 		if (!qede_has_rx_work(rxq)) {
1574 			usleep_range(100, 200);
1575 			continue;
1576 		}
1577 
1578 		/* Get the CQE from the completion ring */
1579 		cqe = (union eth_rx_cqe *)qed_chain_consume(&rxq->rx_comp_ring);
1580 
1581 		/* Get the data from the SW ring */
1582 		sw_rx_index = rxq->sw_rx_cons & NUM_RX_BDS_MAX;
1583 		sw_rx_data = &rxq->sw_rx_ring[sw_rx_index];
1584 		fp_cqe = &cqe->fast_path_regular;
1585 		len =  le16_to_cpu(fp_cqe->len_on_first_bd);
1586 		data_ptr = (u8 *)(page_address(sw_rx_data->data) +
1587 				  fp_cqe->placement_offset +
1588 				  sw_rx_data->page_offset +
1589 				  rxq->rx_headroom);
1590 		if (ether_addr_equal(data_ptr,  edev->ndev->dev_addr) &&
1591 		    ether_addr_equal(data_ptr + ETH_ALEN,
1592 				     edev->ndev->dev_addr)) {
1593 			for (i = ETH_HLEN; i < len; i++)
1594 				if (data_ptr[i] != (unsigned char)(i & 0xff)) {
1595 					rc = -1;
1596 					break;
1597 				}
1598 
1599 			qede_recycle_rx_bd_ring(rxq, 1);
1600 			qed_chain_recycle_consumed(&rxq->rx_comp_ring);
1601 			break;
1602 		}
1603 
1604 		DP_INFO(edev, "Not the transmitted packet\n");
1605 		qede_recycle_rx_bd_ring(rxq, 1);
1606 		qed_chain_recycle_consumed(&rxq->rx_comp_ring);
1607 	}
1608 
1609 	if (iter == QEDE_SELFTEST_POLL_COUNT) {
1610 		DP_NOTICE(edev, "Failed to receive the traffic\n");
1611 		return -1;
1612 	}
1613 
1614 	qede_update_rx_prod(edev, rxq);
1615 
1616 	return rc;
1617 }
1618 
1619 static int qede_selftest_run_loopback(struct qede_dev *edev, u32 loopback_mode)
1620 {
1621 	struct qed_link_params link_params;
1622 	struct sk_buff *skb = NULL;
1623 	int rc = 0, i;
1624 	u32 pkt_size;
1625 	u8 *packet;
1626 
1627 	if (!netif_running(edev->ndev)) {
1628 		DP_NOTICE(edev, "Interface is down\n");
1629 		return -EINVAL;
1630 	}
1631 
1632 	qede_netif_stop(edev);
1633 
1634 	/* Bring up the link in Loopback mode */
1635 	memset(&link_params, 0, sizeof(link_params));
1636 	link_params.link_up = true;
1637 	link_params.override_flags = QED_LINK_OVERRIDE_LOOPBACK_MODE;
1638 	link_params.loopback_mode = loopback_mode;
1639 	edev->ops->common->set_link(edev->cdev, &link_params);
1640 
1641 	/* Wait for loopback configuration to apply */
1642 	msleep_interruptible(500);
1643 
1644 	/* Setting max packet size to 1.5K to avoid data being split over
1645 	 * multiple BDs in cases where MTU > PAGE_SIZE.
1646 	 */
1647 	pkt_size = (((edev->ndev->mtu < ETH_DATA_LEN) ?
1648 		     edev->ndev->mtu : ETH_DATA_LEN) + ETH_HLEN);
1649 
1650 	skb = netdev_alloc_skb(edev->ndev, pkt_size);
1651 	if (!skb) {
1652 		DP_INFO(edev, "Can't allocate skb\n");
1653 		rc = -ENOMEM;
1654 		goto test_loopback_exit;
1655 	}
1656 	packet = skb_put(skb, pkt_size);
1657 	ether_addr_copy(packet, edev->ndev->dev_addr);
1658 	ether_addr_copy(packet + ETH_ALEN, edev->ndev->dev_addr);
1659 	memset(packet + (2 * ETH_ALEN), 0x77, (ETH_HLEN - (2 * ETH_ALEN)));
1660 	for (i = ETH_HLEN; i < pkt_size; i++)
1661 		packet[i] = (unsigned char)(i & 0xff);
1662 
1663 	rc = qede_selftest_transmit_traffic(edev, skb);
1664 	if (rc)
1665 		goto test_loopback_exit;
1666 
1667 	rc = qede_selftest_receive_traffic(edev);
1668 	if (rc)
1669 		goto test_loopback_exit;
1670 
1671 	DP_VERBOSE(edev, NETIF_MSG_RX_STATUS, "Loopback test successful\n");
1672 
1673 test_loopback_exit:
1674 	dev_kfree_skb(skb);
1675 
1676 	/* Bring up the link in Normal mode */
1677 	memset(&link_params, 0, sizeof(link_params));
1678 	link_params.link_up = true;
1679 	link_params.override_flags = QED_LINK_OVERRIDE_LOOPBACK_MODE;
1680 	link_params.loopback_mode = QED_LINK_LOOPBACK_NONE;
1681 	edev->ops->common->set_link(edev->cdev, &link_params);
1682 
1683 	/* Wait for loopback configuration to apply */
1684 	msleep_interruptible(500);
1685 
1686 	qede_netif_start(edev);
1687 
1688 	return rc;
1689 }
1690 
1691 static void qede_self_test(struct net_device *dev,
1692 			   struct ethtool_test *etest, u64 *buf)
1693 {
1694 	struct qede_dev *edev = netdev_priv(dev);
1695 
1696 	DP_VERBOSE(edev, QED_MSG_DEBUG,
1697 		   "Self-test command parameters: offline = %d, external_lb = %d\n",
1698 		   (etest->flags & ETH_TEST_FL_OFFLINE),
1699 		   (etest->flags & ETH_TEST_FL_EXTERNAL_LB) >> 2);
1700 
1701 	memset(buf, 0, sizeof(u64) * QEDE_ETHTOOL_TEST_MAX);
1702 
1703 	if (etest->flags & ETH_TEST_FL_OFFLINE) {
1704 		if (qede_selftest_run_loopback(edev,
1705 					       QED_LINK_LOOPBACK_INT_PHY)) {
1706 			buf[QEDE_ETHTOOL_INT_LOOPBACK] = 1;
1707 			etest->flags |= ETH_TEST_FL_FAILED;
1708 		}
1709 	}
1710 
1711 	if (edev->ops->common->selftest->selftest_interrupt(edev->cdev)) {
1712 		buf[QEDE_ETHTOOL_INTERRUPT_TEST] = 1;
1713 		etest->flags |= ETH_TEST_FL_FAILED;
1714 	}
1715 
1716 	if (edev->ops->common->selftest->selftest_memory(edev->cdev)) {
1717 		buf[QEDE_ETHTOOL_MEMORY_TEST] = 1;
1718 		etest->flags |= ETH_TEST_FL_FAILED;
1719 	}
1720 
1721 	if (edev->ops->common->selftest->selftest_register(edev->cdev)) {
1722 		buf[QEDE_ETHTOOL_REGISTER_TEST] = 1;
1723 		etest->flags |= ETH_TEST_FL_FAILED;
1724 	}
1725 
1726 	if (edev->ops->common->selftest->selftest_clock(edev->cdev)) {
1727 		buf[QEDE_ETHTOOL_CLOCK_TEST] = 1;
1728 		etest->flags |= ETH_TEST_FL_FAILED;
1729 	}
1730 
1731 	if (edev->ops->common->selftest->selftest_nvram(edev->cdev)) {
1732 		buf[QEDE_ETHTOOL_NVRAM_TEST] = 1;
1733 		etest->flags |= ETH_TEST_FL_FAILED;
1734 	}
1735 }
1736 
1737 static int qede_set_tunable(struct net_device *dev,
1738 			    const struct ethtool_tunable *tuna,
1739 			    const void *data)
1740 {
1741 	struct qede_dev *edev = netdev_priv(dev);
1742 	u32 val;
1743 
1744 	switch (tuna->id) {
1745 	case ETHTOOL_RX_COPYBREAK:
1746 		val = *(u32 *)data;
1747 		if (val < QEDE_MIN_PKT_LEN || val > QEDE_RX_HDR_SIZE) {
1748 			DP_VERBOSE(edev, QED_MSG_DEBUG,
1749 				   "Invalid rx copy break value, range is [%u, %u]",
1750 				   QEDE_MIN_PKT_LEN, QEDE_RX_HDR_SIZE);
1751 			return -EINVAL;
1752 		}
1753 
1754 		edev->rx_copybreak = *(u32 *)data;
1755 		break;
1756 	default:
1757 		return -EOPNOTSUPP;
1758 	}
1759 
1760 	return 0;
1761 }
1762 
1763 static int qede_get_tunable(struct net_device *dev,
1764 			    const struct ethtool_tunable *tuna, void *data)
1765 {
1766 	struct qede_dev *edev = netdev_priv(dev);
1767 
1768 	switch (tuna->id) {
1769 	case ETHTOOL_RX_COPYBREAK:
1770 		*(u32 *)data = edev->rx_copybreak;
1771 		break;
1772 	default:
1773 		return -EOPNOTSUPP;
1774 	}
1775 
1776 	return 0;
1777 }
1778 
1779 static int qede_get_eee(struct net_device *dev, struct ethtool_keee *edata)
1780 {
1781 	struct qede_dev *edev = netdev_priv(dev);
1782 	struct qed_link_output current_link;
1783 
1784 	memset(&current_link, 0, sizeof(current_link));
1785 	edev->ops->common->get_link(edev->cdev, &current_link);
1786 
1787 	if (!current_link.eee_supported) {
1788 		DP_INFO(edev, "EEE is not supported\n");
1789 		return -EOPNOTSUPP;
1790 	}
1791 
1792 	linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
1793 			 edata->advertised,
1794 			 current_link.eee.adv_caps & QED_EEE_1G_ADV);
1795 	linkmode_mod_bit(ETHTOOL_LINK_MODE_10000baseT_Full_BIT,
1796 			 edata->advertised,
1797 			 current_link.eee.adv_caps & QED_EEE_10G_ADV);
1798 
1799 	linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
1800 			 edata->supported,
1801 			 current_link.sup_caps & QED_EEE_1G_ADV);
1802 	linkmode_mod_bit(ETHTOOL_LINK_MODE_10000baseT_Full_BIT,
1803 			 edata->supported,
1804 			 current_link.sup_caps & QED_EEE_10G_ADV);
1805 
1806 	linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
1807 			 edata->lp_advertised,
1808 			 current_link.eee.lp_adv_caps & QED_EEE_1G_ADV);
1809 	linkmode_mod_bit(ETHTOOL_LINK_MODE_10000baseT_Full_BIT,
1810 			 edata->lp_advertised,
1811 			 current_link.eee.lp_adv_caps & QED_EEE_10G_ADV);
1812 
1813 	edata->tx_lpi_timer = current_link.eee.tx_lpi_timer;
1814 	edata->eee_enabled = current_link.eee.enable;
1815 	edata->tx_lpi_enabled = current_link.eee.tx_lpi_enable;
1816 	edata->eee_active = current_link.eee_active;
1817 
1818 	return 0;
1819 }
1820 
1821 static int qede_set_eee(struct net_device *dev, struct ethtool_keee *edata)
1822 {
1823 	__ETHTOOL_DECLARE_LINK_MODE_MASK(supported) = {};
1824 	__ETHTOOL_DECLARE_LINK_MODE_MASK(tmp) = {};
1825 	struct qede_dev *edev = netdev_priv(dev);
1826 	struct qed_link_output current_link;
1827 	struct qed_link_params params;
1828 	bool unsupp;
1829 
1830 	if (!edev->ops->common->can_link_change(edev->cdev)) {
1831 		DP_INFO(edev, "Link settings are not allowed to be changed\n");
1832 		return -EOPNOTSUPP;
1833 	}
1834 
1835 	memset(&current_link, 0, sizeof(current_link));
1836 	edev->ops->common->get_link(edev->cdev, &current_link);
1837 
1838 	if (!current_link.eee_supported) {
1839 		DP_INFO(edev, "EEE is not supported\n");
1840 		return -EOPNOTSUPP;
1841 	}
1842 
1843 	memset(&params, 0, sizeof(params));
1844 	params.override_flags |= QED_LINK_OVERRIDE_EEE_CONFIG;
1845 
1846 	linkmode_set_bit(ETHTOOL_LINK_MODE_10000baseT_Full_BIT,
1847 			 supported);
1848 	linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
1849 			 supported);
1850 
1851 	unsupp = linkmode_andnot(tmp, edata->advertised, supported);
1852 	if (unsupp) {
1853 		DP_VERBOSE(edev, QED_MSG_DEBUG,
1854 			   "Invalid advertised capabilities %*pb\n",
1855 			   __ETHTOOL_LINK_MODE_MASK_NBITS, edata->advertised);
1856 		return -EINVAL;
1857 	}
1858 
1859 	if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
1860 			      edata->advertised))
1861 		params.eee.adv_caps = QED_EEE_1G_ADV;
1862 	if (linkmode_test_bit(ETHTOOL_LINK_MODE_10000baseT_Full_BIT,
1863 			      edata->advertised))
1864 		params.eee.adv_caps = QED_EEE_10G_ADV;
1865 
1866 	params.eee.enable = edata->eee_enabled;
1867 	params.eee.tx_lpi_enable = edata->tx_lpi_enabled;
1868 	params.eee.tx_lpi_timer = edata->tx_lpi_timer;
1869 
1870 	params.link_up = true;
1871 	edev->ops->common->set_link(edev->cdev, &params);
1872 
1873 	return 0;
1874 }
1875 
1876 static u32 qede_link_to_ethtool_fec(u32 link_fec)
1877 {
1878 	u32 eth_fec = 0;
1879 
1880 	if (link_fec & QED_FEC_MODE_NONE)
1881 		eth_fec |= ETHTOOL_FEC_OFF;
1882 	if (link_fec & QED_FEC_MODE_FIRECODE)
1883 		eth_fec |= ETHTOOL_FEC_BASER;
1884 	if (link_fec & QED_FEC_MODE_RS)
1885 		eth_fec |= ETHTOOL_FEC_RS;
1886 	if (link_fec & QED_FEC_MODE_AUTO)
1887 		eth_fec |= ETHTOOL_FEC_AUTO;
1888 	if (link_fec & QED_FEC_MODE_UNSUPPORTED)
1889 		eth_fec |= ETHTOOL_FEC_NONE;
1890 
1891 	return eth_fec;
1892 }
1893 
1894 static u32 qede_ethtool_to_link_fec(u32 eth_fec)
1895 {
1896 	u32 link_fec = 0;
1897 
1898 	if (eth_fec & ETHTOOL_FEC_OFF)
1899 		link_fec |= QED_FEC_MODE_NONE;
1900 	if (eth_fec & ETHTOOL_FEC_BASER)
1901 		link_fec |= QED_FEC_MODE_FIRECODE;
1902 	if (eth_fec & ETHTOOL_FEC_RS)
1903 		link_fec |= QED_FEC_MODE_RS;
1904 	if (eth_fec & ETHTOOL_FEC_AUTO)
1905 		link_fec |= QED_FEC_MODE_AUTO;
1906 	if (eth_fec & ETHTOOL_FEC_NONE)
1907 		link_fec |= QED_FEC_MODE_UNSUPPORTED;
1908 
1909 	return link_fec;
1910 }
1911 
1912 static int qede_get_fecparam(struct net_device *dev,
1913 			     struct ethtool_fecparam *fecparam)
1914 {
1915 	struct qede_dev *edev = netdev_priv(dev);
1916 	struct qed_link_output curr_link;
1917 
1918 	memset(&curr_link, 0, sizeof(curr_link));
1919 	edev->ops->common->get_link(edev->cdev, &curr_link);
1920 
1921 	fecparam->active_fec = qede_link_to_ethtool_fec(curr_link.active_fec);
1922 	fecparam->fec = qede_link_to_ethtool_fec(curr_link.sup_fec);
1923 
1924 	return 0;
1925 }
1926 
1927 static int qede_set_fecparam(struct net_device *dev,
1928 			     struct ethtool_fecparam *fecparam)
1929 {
1930 	struct qede_dev *edev = netdev_priv(dev);
1931 	struct qed_link_params params;
1932 
1933 	if (!edev->ops || !edev->ops->common->can_link_change(edev->cdev)) {
1934 		DP_INFO(edev, "Link settings are not allowed to be changed\n");
1935 		return -EOPNOTSUPP;
1936 	}
1937 
1938 	memset(&params, 0, sizeof(params));
1939 	params.override_flags |= QED_LINK_OVERRIDE_FEC_CONFIG;
1940 	params.fec = qede_ethtool_to_link_fec(fecparam->fec);
1941 	params.link_up = true;
1942 
1943 	edev->ops->common->set_link(edev->cdev, &params);
1944 
1945 	return 0;
1946 }
1947 
1948 static int qede_get_module_info(struct net_device *dev,
1949 				struct ethtool_modinfo *modinfo)
1950 {
1951 	struct qede_dev *edev = netdev_priv(dev);
1952 	u8 buf[4];
1953 	int rc;
1954 
1955 	/* Read first 4 bytes to find the sfp type */
1956 	rc = edev->ops->common->read_module_eeprom(edev->cdev, buf,
1957 						   QED_I2C_DEV_ADDR_A0, 0, 4);
1958 	if (rc) {
1959 		DP_ERR(edev, "Failed reading EEPROM data %d\n", rc);
1960 		return rc;
1961 	}
1962 
1963 	switch (buf[0]) {
1964 	case 0x3: /* SFP, SFP+, SFP-28 */
1965 		modinfo->type = ETH_MODULE_SFF_8472;
1966 		modinfo->eeprom_len = ETH_MODULE_SFF_8472_LEN;
1967 		break;
1968 	case 0xc: /* QSFP */
1969 	case 0xd: /* QSFP+ */
1970 		modinfo->type = ETH_MODULE_SFF_8436;
1971 		modinfo->eeprom_len = ETH_MODULE_SFF_8436_LEN;
1972 		break;
1973 	case 0x11: /* QSFP-28 */
1974 		modinfo->type = ETH_MODULE_SFF_8636;
1975 		modinfo->eeprom_len = ETH_MODULE_SFF_8636_LEN;
1976 		break;
1977 	default:
1978 		DP_ERR(edev, "Unknown transceiver type 0x%x\n", buf[0]);
1979 		return -EINVAL;
1980 	}
1981 
1982 	return 0;
1983 }
1984 
1985 static int qede_get_module_eeprom(struct net_device *dev,
1986 				  struct ethtool_eeprom *ee, u8 *data)
1987 {
1988 	struct qede_dev *edev = netdev_priv(dev);
1989 	u32 start_addr = ee->offset, size = 0;
1990 	u8 *buf = data;
1991 	int rc = 0;
1992 
1993 	/* Read A0 section */
1994 	if (ee->offset < ETH_MODULE_SFF_8079_LEN) {
1995 		/* Limit transfer size to the A0 section boundary */
1996 		if (ee->offset + ee->len > ETH_MODULE_SFF_8079_LEN)
1997 			size = ETH_MODULE_SFF_8079_LEN - ee->offset;
1998 		else
1999 			size = ee->len;
2000 
2001 		rc = edev->ops->common->read_module_eeprom(edev->cdev, buf,
2002 							   QED_I2C_DEV_ADDR_A0,
2003 							   start_addr, size);
2004 		if (rc) {
2005 			DP_ERR(edev, "Failed reading A0 section  %d\n", rc);
2006 			return rc;
2007 		}
2008 
2009 		buf += size;
2010 		start_addr += size;
2011 	}
2012 
2013 	/* Read A2 section */
2014 	if (start_addr >= ETH_MODULE_SFF_8079_LEN &&
2015 	    start_addr < ETH_MODULE_SFF_8472_LEN) {
2016 		size = ee->len - size;
2017 		/* Limit transfer size to the A2 section boundary */
2018 		if (start_addr + size > ETH_MODULE_SFF_8472_LEN)
2019 			size = ETH_MODULE_SFF_8472_LEN - start_addr;
2020 		start_addr -= ETH_MODULE_SFF_8079_LEN;
2021 		rc = edev->ops->common->read_module_eeprom(edev->cdev, buf,
2022 							   QED_I2C_DEV_ADDR_A2,
2023 							   start_addr, size);
2024 		if (rc) {
2025 			DP_VERBOSE(edev, QED_MSG_DEBUG,
2026 				   "Failed reading A2 section %d\n", rc);
2027 			return 0;
2028 		}
2029 	}
2030 
2031 	return rc;
2032 }
2033 
2034 static int qede_set_dump(struct net_device *dev, struct ethtool_dump *val)
2035 {
2036 	struct qede_dev *edev = netdev_priv(dev);
2037 	int rc = 0;
2038 
2039 	if (edev->dump_info.cmd == QEDE_DUMP_CMD_NONE) {
2040 		if (val->flag > QEDE_DUMP_CMD_MAX) {
2041 			DP_ERR(edev, "Invalid command %d\n", val->flag);
2042 			return -EINVAL;
2043 		}
2044 		edev->dump_info.cmd = val->flag;
2045 		edev->dump_info.num_args = 0;
2046 		return 0;
2047 	}
2048 
2049 	if (edev->dump_info.num_args == QEDE_DUMP_MAX_ARGS) {
2050 		DP_ERR(edev, "Arg count = %d\n", edev->dump_info.num_args);
2051 		return -EINVAL;
2052 	}
2053 
2054 	switch (edev->dump_info.cmd) {
2055 	case QEDE_DUMP_CMD_NVM_CFG:
2056 		edev->dump_info.args[edev->dump_info.num_args] = val->flag;
2057 		edev->dump_info.num_args++;
2058 		break;
2059 	case QEDE_DUMP_CMD_GRCDUMP:
2060 		rc = edev->ops->common->set_grc_config(edev->cdev,
2061 						       val->flag, 1);
2062 		break;
2063 	default:
2064 		break;
2065 	}
2066 
2067 	return rc;
2068 }
2069 
2070 static int qede_get_dump_flag(struct net_device *dev,
2071 			      struct ethtool_dump *dump)
2072 {
2073 	struct qede_dev *edev = netdev_priv(dev);
2074 
2075 	if (!edev->ops || !edev->ops->common) {
2076 		DP_ERR(edev, "Edev ops not populated\n");
2077 		return -EINVAL;
2078 	}
2079 
2080 	dump->version = QEDE_DUMP_VERSION;
2081 	switch (edev->dump_info.cmd) {
2082 	case QEDE_DUMP_CMD_NVM_CFG:
2083 		dump->flag = QEDE_DUMP_CMD_NVM_CFG;
2084 		dump->len = edev->ops->common->read_nvm_cfg_len(edev->cdev,
2085 						edev->dump_info.args[0]);
2086 		break;
2087 	case QEDE_DUMP_CMD_GRCDUMP:
2088 		dump->flag = QEDE_DUMP_CMD_GRCDUMP;
2089 		dump->len = edev->ops->common->dbg_all_data_size(edev->cdev);
2090 		break;
2091 	default:
2092 		DP_ERR(edev, "Invalid cmd = %d\n", edev->dump_info.cmd);
2093 		return -EINVAL;
2094 	}
2095 
2096 	DP_VERBOSE(edev, QED_MSG_DEBUG,
2097 		   "dump->version = 0x%x dump->flag = %d dump->len = %d\n",
2098 		   dump->version, dump->flag, dump->len);
2099 	return 0;
2100 }
2101 
2102 static int qede_get_dump_data(struct net_device *dev,
2103 			      struct ethtool_dump *dump, void *buf)
2104 {
2105 	struct qede_dev *edev = netdev_priv(dev);
2106 	int rc = 0;
2107 
2108 	if (!edev->ops || !edev->ops->common) {
2109 		DP_ERR(edev, "Edev ops not populated\n");
2110 		rc = -EINVAL;
2111 		goto err;
2112 	}
2113 
2114 	switch (edev->dump_info.cmd) {
2115 	case QEDE_DUMP_CMD_NVM_CFG:
2116 		if (edev->dump_info.num_args != QEDE_DUMP_NVM_ARG_COUNT) {
2117 			DP_ERR(edev, "Arg count = %d required = %d\n",
2118 			       edev->dump_info.num_args,
2119 			       QEDE_DUMP_NVM_ARG_COUNT);
2120 			rc = -EINVAL;
2121 			goto err;
2122 		}
2123 		rc =  edev->ops->common->read_nvm_cfg(edev->cdev, (u8 **)&buf,
2124 						      edev->dump_info.args[0],
2125 						      edev->dump_info.args[1]);
2126 		break;
2127 	case QEDE_DUMP_CMD_GRCDUMP:
2128 		memset(buf, 0, dump->len);
2129 		rc = edev->ops->common->dbg_all_data(edev->cdev, buf);
2130 		break;
2131 	default:
2132 		DP_ERR(edev, "Invalid cmd = %d\n", edev->dump_info.cmd);
2133 		rc = -EINVAL;
2134 		break;
2135 	}
2136 
2137 err:
2138 	edev->dump_info.cmd = QEDE_DUMP_CMD_NONE;
2139 	edev->dump_info.num_args = 0;
2140 	memset(edev->dump_info.args, 0, sizeof(edev->dump_info.args));
2141 
2142 	return rc;
2143 }
2144 
2145 int qede_set_per_coalesce(struct net_device *dev, u32 queue,
2146 			  struct ethtool_coalesce *coal)
2147 {
2148 	struct qede_dev *edev = netdev_priv(dev);
2149 	struct qede_fastpath *fp;
2150 	u16 rxc, txc;
2151 	int rc = 0;
2152 
2153 	if (coal->rx_coalesce_usecs > QED_COALESCE_MAX ||
2154 	    coal->tx_coalesce_usecs > QED_COALESCE_MAX) {
2155 		DP_INFO(edev,
2156 			"Can't support requested %s coalesce value [max supported value %d]\n",
2157 			coal->rx_coalesce_usecs > QED_COALESCE_MAX ? "rx"
2158 								   : "tx",
2159 			QED_COALESCE_MAX);
2160 		return -EINVAL;
2161 	}
2162 
2163 	rxc = (u16)coal->rx_coalesce_usecs;
2164 	txc = (u16)coal->tx_coalesce_usecs;
2165 
2166 	__qede_lock(edev);
2167 	if (queue >= edev->num_queues) {
2168 		DP_INFO(edev, "Invalid queue\n");
2169 		rc = -EINVAL;
2170 		goto out;
2171 	}
2172 
2173 	if (edev->state != QEDE_STATE_OPEN) {
2174 		rc = -EINVAL;
2175 		goto out;
2176 	}
2177 
2178 	fp = &edev->fp_array[queue];
2179 
2180 	if (edev->fp_array[queue].type & QEDE_FASTPATH_RX) {
2181 		rc = edev->ops->common->set_coalesce(edev->cdev,
2182 						     rxc, 0,
2183 						     fp->rxq->handle);
2184 		if (rc) {
2185 			DP_INFO(edev,
2186 				"Set RX coalesce error, rc = %d\n", rc);
2187 			goto out;
2188 		}
2189 		edev->coal_entry[queue].rxc = rxc;
2190 		edev->coal_entry[queue].isvalid = true;
2191 	}
2192 
2193 	if (edev->fp_array[queue].type & QEDE_FASTPATH_TX) {
2194 		rc = edev->ops->common->set_coalesce(edev->cdev,
2195 						     0, txc,
2196 						     fp->txq->handle);
2197 		if (rc) {
2198 			DP_INFO(edev,
2199 				"Set TX coalesce error, rc = %d\n", rc);
2200 			goto out;
2201 		}
2202 		edev->coal_entry[queue].txc = txc;
2203 		edev->coal_entry[queue].isvalid = true;
2204 	}
2205 out:
2206 	__qede_unlock(edev);
2207 
2208 	return rc;
2209 }
2210 
2211 static int qede_get_per_coalesce(struct net_device *dev,
2212 				 u32 queue,
2213 				 struct ethtool_coalesce *coal)
2214 {
2215 	void *rx_handle = NULL, *tx_handle = NULL;
2216 	struct qede_dev *edev = netdev_priv(dev);
2217 	struct qede_fastpath *fp;
2218 	u16 rx_coal, tx_coal;
2219 	int rc = 0;
2220 
2221 	rx_coal = QED_DEFAULT_RX_USECS;
2222 	tx_coal = QED_DEFAULT_TX_USECS;
2223 
2224 	memset(coal, 0, sizeof(struct ethtool_coalesce));
2225 
2226 	__qede_lock(edev);
2227 	if (queue >= edev->num_queues) {
2228 		DP_INFO(edev, "Invalid queue\n");
2229 		rc = -EINVAL;
2230 		goto out;
2231 	}
2232 
2233 	if (edev->state != QEDE_STATE_OPEN) {
2234 		rc = -EINVAL;
2235 		goto out;
2236 	}
2237 
2238 	fp = &edev->fp_array[queue];
2239 
2240 	if (fp->type & QEDE_FASTPATH_RX)
2241 		rx_handle = fp->rxq->handle;
2242 
2243 	rc = edev->ops->get_coalesce(edev->cdev, &rx_coal,
2244 				     rx_handle);
2245 	if (rc) {
2246 		DP_INFO(edev, "Read Rx coalesce error\n");
2247 		goto out;
2248 	}
2249 
2250 	fp = &edev->fp_array[queue];
2251 	if (fp->type & QEDE_FASTPATH_TX)
2252 		tx_handle = fp->txq->handle;
2253 
2254 	rc = edev->ops->get_coalesce(edev->cdev, &tx_coal,
2255 				      tx_handle);
2256 	if (rc)
2257 		DP_INFO(edev, "Read Tx coalesce error\n");
2258 
2259 out:
2260 	__qede_unlock(edev);
2261 
2262 	coal->rx_coalesce_usecs = rx_coal;
2263 	coal->tx_coalesce_usecs = tx_coal;
2264 
2265 	return rc;
2266 }
2267 
2268 static const struct ethtool_ops qede_ethtool_ops = {
2269 	.supported_coalesce_params	= ETHTOOL_COALESCE_USECS |
2270 					  ETHTOOL_COALESCE_STATS_BLOCK_USECS,
2271 	.get_link_ksettings		= qede_get_link_ksettings,
2272 	.set_link_ksettings		= qede_set_link_ksettings,
2273 	.get_drvinfo			= qede_get_drvinfo,
2274 	.get_regs_len			= qede_get_regs_len,
2275 	.get_regs			= qede_get_regs,
2276 	.get_wol			= qede_get_wol,
2277 	.set_wol			= qede_set_wol,
2278 	.get_msglevel			= qede_get_msglevel,
2279 	.set_msglevel			= qede_set_msglevel,
2280 	.nway_reset			= qede_nway_reset,
2281 	.get_link			= qede_get_link,
2282 	.get_coalesce			= qede_get_coalesce,
2283 	.set_coalesce			= qede_set_coalesce,
2284 	.get_ringparam			= qede_get_ringparam,
2285 	.set_ringparam			= qede_set_ringparam,
2286 	.get_pauseparam			= qede_get_pauseparam,
2287 	.set_pauseparam			= qede_set_pauseparam,
2288 	.get_strings			= qede_get_strings,
2289 	.set_phys_id			= qede_set_phys_id,
2290 	.get_ethtool_stats		= qede_get_ethtool_stats,
2291 	.get_priv_flags			= qede_get_priv_flags,
2292 	.set_priv_flags			= qede_set_priv_flags,
2293 	.get_sset_count			= qede_get_sset_count,
2294 	.get_rxnfc			= qede_get_rxnfc,
2295 	.set_rxnfc			= qede_set_rxnfc,
2296 	.get_rx_ring_count		= qede_get_rx_ring_count,
2297 	.get_rxfh_indir_size		= qede_get_rxfh_indir_size,
2298 	.get_rxfh_key_size		= qede_get_rxfh_key_size,
2299 	.get_rxfh			= qede_get_rxfh,
2300 	.set_rxfh			= qede_set_rxfh,
2301 	.get_rxfh_fields		= qede_get_rxfh_fields,
2302 	.set_rxfh_fields		= qede_set_rxfh_fields,
2303 	.get_ts_info			= qede_get_ts_info,
2304 	.get_channels			= qede_get_channels,
2305 	.set_channels			= qede_set_channels,
2306 	.self_test			= qede_self_test,
2307 	.get_module_info		= qede_get_module_info,
2308 	.get_module_eeprom		= qede_get_module_eeprom,
2309 	.get_eee			= qede_get_eee,
2310 	.set_eee			= qede_set_eee,
2311 	.get_fecparam			= qede_get_fecparam,
2312 	.set_fecparam			= qede_set_fecparam,
2313 	.get_tunable			= qede_get_tunable,
2314 	.set_tunable			= qede_set_tunable,
2315 	.get_per_queue_coalesce		= qede_get_per_coalesce,
2316 	.set_per_queue_coalesce		= qede_set_per_coalesce,
2317 	.flash_device			= qede_flash_device,
2318 	.get_dump_flag			= qede_get_dump_flag,
2319 	.get_dump_data			= qede_get_dump_data,
2320 	.set_dump			= qede_set_dump,
2321 };
2322 
2323 static const struct ethtool_ops qede_vf_ethtool_ops = {
2324 	.supported_coalesce_params	= ETHTOOL_COALESCE_USECS |
2325 					  ETHTOOL_COALESCE_STATS_BLOCK_USECS,
2326 	.get_link_ksettings		= qede_get_link_ksettings,
2327 	.get_drvinfo			= qede_get_drvinfo,
2328 	.get_msglevel			= qede_get_msglevel,
2329 	.set_msglevel			= qede_set_msglevel,
2330 	.get_link			= qede_get_link,
2331 	.get_coalesce			= qede_get_coalesce,
2332 	.set_coalesce			= qede_set_coalesce,
2333 	.get_ringparam			= qede_get_ringparam,
2334 	.set_ringparam			= qede_set_ringparam,
2335 	.get_strings			= qede_get_strings,
2336 	.get_ethtool_stats		= qede_get_ethtool_stats,
2337 	.get_priv_flags			= qede_get_priv_flags,
2338 	.get_sset_count			= qede_get_sset_count,
2339 	.get_rxnfc			= qede_get_rxnfc,
2340 	.set_rxnfc			= qede_set_rxnfc,
2341 	.get_rx_ring_count		= qede_get_rx_ring_count,
2342 	.get_rxfh_indir_size		= qede_get_rxfh_indir_size,
2343 	.get_rxfh_key_size		= qede_get_rxfh_key_size,
2344 	.get_rxfh			= qede_get_rxfh,
2345 	.set_rxfh			= qede_set_rxfh,
2346 	.get_rxfh_fields		= qede_get_rxfh_fields,
2347 	.set_rxfh_fields		= qede_set_rxfh_fields,
2348 	.get_channels			= qede_get_channels,
2349 	.set_channels			= qede_set_channels,
2350 	.get_per_queue_coalesce		= qede_get_per_coalesce,
2351 	.set_per_queue_coalesce		= qede_set_per_coalesce,
2352 	.get_tunable			= qede_get_tunable,
2353 	.set_tunable			= qede_set_tunable,
2354 };
2355 
2356 void qede_set_ethtool_ops(struct net_device *dev)
2357 {
2358 	struct qede_dev *edev = netdev_priv(dev);
2359 
2360 	if (IS_VF(edev))
2361 		dev->ethtool_ops = &qede_vf_ethtool_ops;
2362 	else
2363 		dev->ethtool_ops = &qede_ethtool_ops;
2364 }
2365