~hc/RK356X_SDK_RELEASE.git

..	..	@@ -1,34 +1,9 @@
	1	+// SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause)
1	2	/* QLogic qede NIC Driver
2	3	* Copyright (c) 2015-2017 QLogic Corporation
3		- *
4		- * This software is available to you under a choice of one of two
5		- * licenses. You may choose to be licensed under the terms of the GNU
6		- * General Public License (GPL) Version 2, available from the file
7		- * COPYING in the main directory of this source tree, or the
8		- * OpenIB.org BSD license below:
9		- *
10		- * Redistribution and use in source and binary forms, with or
11		- * without modification, are permitted provided that the following
12		- * conditions are met:
13		- *
14		- * - Redistributions of source code must retain the above
15		- * copyright notice, this list of conditions and the following
16		- * disclaimer.
17		- *
18		- * - Redistributions in binary form must reproduce the above
19		- * copyright notice, this list of conditions and the following
20		- * disclaimer in the documentation and /or other materials
21		- * provided with the distribution.
22		- *
23		- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24		- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25		- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26		- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27		- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28		- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29		- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30		- * SOFTWARE.
	4	+ * Copyright (c) 2019-2020 Marvell International Ltd.
31	5	*/
	6	+
32	7	#include <linux/version.h>
33	8	#include <linux/types.h>
34	9	#include <linux/netdevice.h>
..	..	@@ -38,6 +13,8 @@
38	13	#include <linux/pci.h>
39	14	#include <linux/capability.h>
40	15	#include <linux/vmalloc.h>
	16	+#include <linux/phylink.h>
	17	+
41	18	#include "qede.h"
42	19	#include "qede_ptp.h"
43	20
..	..	@@ -48,6 +25,8 @@
48	25	{QEDE_RQSTAT_OFFSET(stat_name), QEDE_RQSTAT_STRING(stat_name)}
49	26
50	27	#define QEDE_SELFTEST_POLL_COUNT 100
	28	+#define QEDE_DUMP_VERSION 0x1
	29	+#define QEDE_DUMP_NVM_ARG_COUNT 2
51	30
52	31	static const struct {
53	32	u64 offset;
..	..	@@ -73,6 +52,7 @@
73	52	} qede_tqstats_arr[] = {
74	53	QEDE_TQSTAT(xmit_pkts),
75	54	QEDE_TQSTAT(stopped_cnt),
	55	+ QEDE_TQSTAT(tx_mem_alloc_err),
76	56	};
77	57
78	58	#define QEDE_STAT_OFFSET(stat_name, type, base) \
..	..	@@ -173,6 +153,7 @@
173	153	QEDE_STAT(coalesced_bytes),
174	154
175	155	QEDE_STAT(link_change_count),
	156	+ QEDE_STAT(ptp_skip_txts),
176	157	};
177	158
178	159	#define QEDE_NUM_STATS ARRAY_SIZE(qede_stats_arr)
..	..	@@ -185,11 +166,15 @@
185	166
186	167	enum {
187	168	QEDE_PRI_FLAG_CMT,
	169	+ QEDE_PRI_FLAG_SMART_AN_SUPPORT, /* MFW supports SmartAN */
	170	+ QEDE_PRI_FLAG_RECOVER_ON_ERROR,
188	171	QEDE_PRI_FLAG_LEN,
189	172	};
190	173
191	174	static const char qede_private_arr[QEDE_PRI_FLAG_LEN][ETH_GSTRING_LEN] = {
192	175	"Coupled-Function",
	176	+ "SmartAN capable",
	177	+ "Recover on error",
193	178	};
194	179
195	180	enum qede_ethtool_tests {
..	..	@@ -210,6 +195,96 @@
210	195	"Clock (online)\t\t",
211	196	"Nvram (online)\t\t",
212	197	};
	198	+
	199	+/* Forced speed capabilities maps */
	200	+
	201	+struct qede_forced_speed_map {
	202	+ u32 speed;
	203	+ __ETHTOOL_DECLARE_LINK_MODE_MASK(caps);
	204	+
	205	+ const u32 *cap_arr;
	206	+ u32 arr_size;
	207	+};
	208	+
	209	+#define QEDE_FORCED_SPEED_MAP(value) \
	210	+{ \
	211	+ .speed = SPEED_##value, \
	212	+ .cap_arr = qede_forced_speed_##value, \
	213	+ .arr_size = ARRAY_SIZE(qede_forced_speed_##value), \
	214	+}
	215	+
	216	+static const u32 qede_forced_speed_1000[] __initconst = {
	217	+ ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
	218	+ ETHTOOL_LINK_MODE_1000baseKX_Full_BIT,
	219	+ ETHTOOL_LINK_MODE_1000baseX_Full_BIT,
	220	+};
	221	+
	222	+static const u32 qede_forced_speed_10000[] __initconst = {
	223	+ ETHTOOL_LINK_MODE_10000baseT_Full_BIT,
	224	+ ETHTOOL_LINK_MODE_10000baseKR_Full_BIT,
	225	+ ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT,
	226	+ ETHTOOL_LINK_MODE_10000baseR_FEC_BIT,
	227	+ ETHTOOL_LINK_MODE_10000baseCR_Full_BIT,
	228	+ ETHTOOL_LINK_MODE_10000baseSR_Full_BIT,
	229	+ ETHTOOL_LINK_MODE_10000baseLR_Full_BIT,
	230	+ ETHTOOL_LINK_MODE_10000baseLRM_Full_BIT,
	231	+};
	232	+
	233	+static const u32 qede_forced_speed_20000[] __initconst = {
	234	+ ETHTOOL_LINK_MODE_20000baseKR2_Full_BIT,
	235	+};
	236	+
	237	+static const u32 qede_forced_speed_25000[] __initconst = {
	238	+ ETHTOOL_LINK_MODE_25000baseKR_Full_BIT,
	239	+ ETHTOOL_LINK_MODE_25000baseCR_Full_BIT,
	240	+ ETHTOOL_LINK_MODE_25000baseSR_Full_BIT,
	241	+};
	242	+
	243	+static const u32 qede_forced_speed_40000[] __initconst = {
	244	+ ETHTOOL_LINK_MODE_40000baseLR4_Full_BIT,
	245	+ ETHTOOL_LINK_MODE_40000baseKR4_Full_BIT,
	246	+ ETHTOOL_LINK_MODE_40000baseCR4_Full_BIT,
	247	+ ETHTOOL_LINK_MODE_40000baseSR4_Full_BIT,
	248	+};
	249	+
	250	+static const u32 qede_forced_speed_50000[] __initconst = {
	251	+ ETHTOOL_LINK_MODE_50000baseKR2_Full_BIT,
	252	+ ETHTOOL_LINK_MODE_50000baseCR2_Full_BIT,
	253	+ ETHTOOL_LINK_MODE_50000baseSR2_Full_BIT,
	254	+};
	255	+
	256	+static const u32 qede_forced_speed_100000[] __initconst = {
	257	+ ETHTOOL_LINK_MODE_100000baseKR4_Full_BIT,
	258	+ ETHTOOL_LINK_MODE_100000baseSR4_Full_BIT,
	259	+ ETHTOOL_LINK_MODE_100000baseCR4_Full_BIT,
	260	+ ETHTOOL_LINK_MODE_100000baseLR4_ER4_Full_BIT,
	261	+};
	262	+
	263	+static struct qede_forced_speed_map qede_forced_speed_maps[] __ro_after_init = {
	264	+ QEDE_FORCED_SPEED_MAP(1000),
	265	+ QEDE_FORCED_SPEED_MAP(10000),
	266	+ QEDE_FORCED_SPEED_MAP(20000),
	267	+ QEDE_FORCED_SPEED_MAP(25000),
	268	+ QEDE_FORCED_SPEED_MAP(40000),
	269	+ QEDE_FORCED_SPEED_MAP(50000),
	270	+ QEDE_FORCED_SPEED_MAP(100000),
	271	+};
	272	+
	273	+void __init qede_forced_speed_maps_init(void)
	274	+{
	275	+ struct qede_forced_speed_map *map;
	276	+ u32 i;
	277	+
	278	+ for (i = 0; i < ARRAY_SIZE(qede_forced_speed_maps); i++) {
	279	+ map = qede_forced_speed_maps + i;
	280	+
	281	+ linkmode_set_bit_array(map->cap_arr, map->arr_size, map->caps);
	282	+ map->cap_arr = NULL;
	283	+ map->arr_size = 0;
	284	+ }
	285	+}
	286	+
	287	+/* Ethtool callbacks */
213	288
214	289	static void qede_get_strings_stats_txq(struct qede_dev *edev,
215	290	struct qede_tx_queue txq, u8 *buf)
..	..	@@ -351,6 +426,8 @@
351	426	}
352	427	}
353	428
	429	+ spin_lock(&edev->stats_lock);
	430	+
354	431	for (i = 0; i < QEDE_NUM_STATS; i++) {
355	432	if (qede_is_irrelevant_stat(edev, i))
356	433	continue;
..	..	@@ -359,6 +436,8 @@
359	436
360	437	buf++;
361	438	}
	439	+
	440	+ spin_unlock(&edev->stats_lock);
362	441
363	442	__qede_unlock(edev);
364	443	}
..	..	@@ -403,55 +482,42 @@
403	482	static u32 qede_get_priv_flags(struct net_device *dev)
404	483	{
405	484	struct qede_dev *edev = netdev_priv(dev);
	485	+ u32 flags = 0;
406	486
407		- return (!!(edev->dev_info.common.num_hwfns > 1)) << QEDE_PRI_FLAG_CMT;
	487	+ if (edev->dev_info.common.num_hwfns > 1)
	488	+ flags \|= BIT(QEDE_PRI_FLAG_CMT);
	489	+
	490	+ if (edev->dev_info.common.smart_an)
	491	+ flags \|= BIT(QEDE_PRI_FLAG_SMART_AN_SUPPORT);
	492	+
	493	+ if (edev->err_flags & BIT(QEDE_ERR_IS_RECOVERABLE))
	494	+ flags \|= BIT(QEDE_PRI_FLAG_RECOVER_ON_ERROR);
	495	+
	496	+ return flags;
408	497	}
409	498
410		-struct qede_link_mode_mapping {
411		- u32 qed_link_mode;
412		- u32 ethtool_link_mode;
413		-};
	499	+static int qede_set_priv_flags(struct net_device *dev, u32 flags)
	500	+{
	501	+ struct qede_dev *edev = netdev_priv(dev);
	502	+ u32 cflags = qede_get_priv_flags(dev);
	503	+ u32 dflags = flags ^ cflags;
414	504
415		-static const struct qede_link_mode_mapping qed_lm_map[] = {
416		- {QED_LM_FIBRE_BIT, ETHTOOL_LINK_MODE_FIBRE_BIT},
417		- {QED_LM_Autoneg_BIT, ETHTOOL_LINK_MODE_Autoneg_BIT},
418		- {QED_LM_Asym_Pause_BIT, ETHTOOL_LINK_MODE_Asym_Pause_BIT},
419		- {QED_LM_Pause_BIT, ETHTOOL_LINK_MODE_Pause_BIT},
420		- {QED_LM_1000baseT_Half_BIT, ETHTOOL_LINK_MODE_1000baseT_Half_BIT},
421		- {QED_LM_1000baseT_Full_BIT, ETHTOOL_LINK_MODE_1000baseT_Full_BIT},
422		- {QED_LM_10000baseKR_Full_BIT, ETHTOOL_LINK_MODE_10000baseKR_Full_BIT},
423		- {QED_LM_25000baseKR_Full_BIT, ETHTOOL_LINK_MODE_25000baseKR_Full_BIT},
424		- {QED_LM_40000baseLR4_Full_BIT, ETHTOOL_LINK_MODE_40000baseLR4_Full_BIT},
425		- {QED_LM_50000baseKR2_Full_BIT, ETHTOOL_LINK_MODE_50000baseKR2_Full_BIT},
426		- {QED_LM_100000baseKR4_Full_BIT,
427		- ETHTOOL_LINK_MODE_100000baseKR4_Full_BIT},
428		-};
	505	+ /* can only change RECOVER_ON_ERROR flag */
	506	+ if (dflags & ~BIT(QEDE_PRI_FLAG_RECOVER_ON_ERROR))
	507	+ return -EINVAL;
429	508
430		-#define QEDE_DRV_TO_ETHTOOL_CAPS(caps, lk_ksettings, name) \
431		-{ \
432		- int i; \
433		- \
434		- for (i = 0; i < ARRAY_SIZE(qed_lm_map); i++) { \
435		- if ((caps) & (qed_lm_map[i].qed_link_mode)) \
436		- __set_bit(qed_lm_map[i].ethtool_link_mode,\
437		- lk_ksettings->link_modes.name); \
438		- } \
439		-}
	509	+ if (flags & BIT(QEDE_PRI_FLAG_RECOVER_ON_ERROR))
	510	+ set_bit(QEDE_ERR_IS_RECOVERABLE, &edev->err_flags);
	511	+ else
	512	+ clear_bit(QEDE_ERR_IS_RECOVERABLE, &edev->err_flags);
440	513
441		-#define QEDE_ETHTOOL_TO_DRV_CAPS(caps, lk_ksettings, name) \
442		-{ \
443		- int i; \
444		- \
445		- for (i = 0; i < ARRAY_SIZE(qed_lm_map); i++) { \
446		- if (test_bit(qed_lm_map[i].ethtool_link_mode, \
447		- lk_ksettings->link_modes.name)) \
448		- caps \|= qed_lm_map[i].qed_link_mode; \
449		- } \
	514	+ return 0;
450	515	}
451	516
452	517	static int qede_get_link_ksettings(struct net_device *dev,
453	518	struct ethtool_link_ksettings *cmd)
454	519	{
	520	+ typeof(cmd->link_modes) *link_modes = &cmd->link_modes;
455	521	struct ethtool_link_settings *base = &cmd->base;
456	522	struct qede_dev *edev = netdev_priv(dev);
457	523	struct qed_link_output current_link;
..	..	@@ -461,14 +527,9 @@
461	527	memset(&current_link, 0, sizeof(current_link));
462	528	edev->ops->common->get_link(edev->cdev, &current_link);
463	529
464		- ethtool_link_ksettings_zero_link_mode(cmd, supported);
465		- QEDE_DRV_TO_ETHTOOL_CAPS(current_link.supported_caps, cmd, supported)
466		-
467		- ethtool_link_ksettings_zero_link_mode(cmd, advertising);
468		- QEDE_DRV_TO_ETHTOOL_CAPS(current_link.advertised_caps, cmd, advertising)
469		-
470		- ethtool_link_ksettings_zero_link_mode(cmd, lp_advertising);
471		- QEDE_DRV_TO_ETHTOOL_CAPS(current_link.lp_caps, cmd, lp_advertising)
	530	+ linkmode_copy(link_modes->supported, current_link.supported_caps);
	531	+ linkmode_copy(link_modes->advertising, current_link.advertised_caps);
	532	+ linkmode_copy(link_modes->lp_advertising, current_link.lp_caps);
472	533
473	534	if ((edev->state == QEDE_STATE_OPEN) && (current_link.link_up)) {
474	535	base->speed = current_link.speed;
..	..	@@ -492,8 +553,10 @@
492	553	{
493	554	const struct ethtool_link_settings *base = &cmd->base;
494	555	struct qede_dev *edev = netdev_priv(dev);
	556	+ const struct qede_forced_speed_map *map;
495	557	struct qed_link_output current_link;
496	558	struct qed_link_params params;
	559	+ u32 i;
497	560
498	561	if (!edev->ops \|\| !edev->ops->common->can_link_change(edev->cdev)) {
499	562	DP_INFO(edev, "Link settings are not allowed to be changed\n");
..	..	@@ -505,74 +568,40 @@
505	568
506	569	params.override_flags \|= QED_LINK_OVERRIDE_SPEED_ADV_SPEEDS;
507	570	params.override_flags \|= QED_LINK_OVERRIDE_SPEED_AUTONEG;
	571	+
508	572	if (base->autoneg == AUTONEG_ENABLE) {
509		- if (!(current_link.supported_caps & QED_LM_Autoneg_BIT)) {
	573	+ if (!phylink_test(current_link.supported_caps, Autoneg)) {
510	574	DP_INFO(edev, "Auto negotiation is not supported\n");
511	575	return -EOPNOTSUPP;
512	576	}
513	577
514	578	params.autoneg = true;
515	579	params.forced_speed = 0;
516		- QEDE_ETHTOOL_TO_DRV_CAPS(params.adv_speeds, cmd, advertising)
	580	+
	581	+ linkmode_copy(params.adv_speeds, cmd->link_modes.advertising);
517	582	} else { /* forced speed */
518	583	params.override_flags \|= QED_LINK_OVERRIDE_SPEED_FORCED_SPEED;
519	584	params.autoneg = false;
520	585	params.forced_speed = base->speed;
521		- switch (base->speed) {
522		- case SPEED_1000:
523		- if (!(current_link.supported_caps &
524		- QED_LM_1000baseT_Full_BIT)) {
525		- DP_INFO(edev, "1G speed not supported\n");
526		- return -EINVAL;
527		- }
528		- params.adv_speeds = QED_LM_1000baseT_Full_BIT;
529		- break;
530		- case SPEED_10000:
531		- if (!(current_link.supported_caps &
532		- QED_LM_10000baseKR_Full_BIT)) {
533		- DP_INFO(edev, "10G speed not supported\n");
534		- return -EINVAL;
535		- }
536		- params.adv_speeds = QED_LM_10000baseKR_Full_BIT;
537		- break;
538		- case SPEED_25000:
539		- if (!(current_link.supported_caps &
540		- QED_LM_25000baseKR_Full_BIT)) {
541		- DP_INFO(edev, "25G speed not supported\n");
542		- return -EINVAL;
543		- }
544		- params.adv_speeds = QED_LM_25000baseKR_Full_BIT;
545		- break;
546		- case SPEED_40000:
547		- if (!(current_link.supported_caps &
548		- QED_LM_40000baseLR4_Full_BIT)) {
549		- DP_INFO(edev, "40G speed not supported\n");
550		- return -EINVAL;
551		- }
552		- params.adv_speeds = QED_LM_40000baseLR4_Full_BIT;
553		- break;
554		- case SPEED_50000:
555		- if (!(current_link.supported_caps &
556		- QED_LM_50000baseKR2_Full_BIT)) {
557		- DP_INFO(edev, "50G speed not supported\n");
558		- return -EINVAL;
559		- }
560		- params.adv_speeds = QED_LM_50000baseKR2_Full_BIT;
561		- break;
562		- case SPEED_100000:
563		- if (!(current_link.supported_caps &
564		- QED_LM_100000baseKR4_Full_BIT)) {
565		- DP_INFO(edev, "100G speed not supported\n");
566		- return -EINVAL;
567		- }
568		- params.adv_speeds = QED_LM_100000baseKR4_Full_BIT;
569		- break;
570		- default:
571		- DP_INFO(edev, "Unsupported speed %u\n", base->speed);
572		- return -EINVAL;
	586	+
	587	+ for (i = 0; i < ARRAY_SIZE(qede_forced_speed_maps); i++) {
	588	+ map = qede_forced_speed_maps + i;
	589	+
	590	+ if (base->speed != map->speed \|\|
	591	+ !linkmode_intersects(current_link.supported_caps,
	592	+ map->caps))
	593	+ continue;
	594	+
	595	+ linkmode_and(params.adv_speeds,
	596	+ current_link.supported_caps, map->caps);
	597	+ goto set_link;
573	598	}
	599	+
	600	+ DP_INFO(edev, "Unsupported speed %u\n", base->speed);
	601	+ return -EINVAL;
574	602	}
575	603
	604	+set_link:
576	605	params.link_up = true;
577	606	edev->ops->common->set_link(edev->cdev, &params);
578	607
..	..	@@ -584,9 +613,9 @@
584	613	{
585	614	char mfw[ETHTOOL_FWVERS_LEN], storm[ETHTOOL_FWVERS_LEN];
586	615	struct qede_dev *edev = netdev_priv(ndev);
	616	+ char mbi[ETHTOOL_FWVERS_LEN];
587	617
588	618	strlcpy(info->driver, "qede", sizeof(info->driver));
589		- strlcpy(info->version, DRV_MODULE_VERSION, sizeof(info->version));
590	619
591	620	snprintf(storm, ETHTOOL_FWVERS_LEN, "%d.%d.%d.%d",
592	621	edev->dev_info.common.fw_major,
..	..	@@ -600,13 +629,27 @@
600	629	(edev->dev_info.common.mfw_rev >> 8) & 0xFF,
601	630	edev->dev_info.common.mfw_rev & 0xFF);
602	631
603		- if ((strlen(storm) + strlen(mfw) + strlen("mfw storm ")) <
604		- sizeof(info->fw_version)) {
	632	+ if ((strlen(storm) + strlen(DRV_MODULE_VERSION) + strlen("[storm] ")) <
	633	+ sizeof(info->version))
	634	+ snprintf(info->version, sizeof(info->version),
	635	+ "%s [storm %s]", DRV_MODULE_VERSION, storm);
	636	+ else
	637	+ snprintf(info->version, sizeof(info->version),
	638	+ "%s %s", DRV_MODULE_VERSION, storm);
	639	+
	640	+ if (edev->dev_info.common.mbi_version) {
	641	+ snprintf(mbi, ETHTOOL_FWVERS_LEN, "%d.%d.%d",
	642	+ (edev->dev_info.common.mbi_version &
	643	+ QED_MBI_VERSION_2_MASK) >> QED_MBI_VERSION_2_OFFSET,
	644	+ (edev->dev_info.common.mbi_version &
	645	+ QED_MBI_VERSION_1_MASK) >> QED_MBI_VERSION_1_OFFSET,
	646	+ (edev->dev_info.common.mbi_version &
	647	+ QED_MBI_VERSION_0_MASK) >> QED_MBI_VERSION_0_OFFSET);
605	648	snprintf(info->fw_version, sizeof(info->fw_version),
606		- "mfw %s storm %s", mfw, storm);
	649	+ "mbi %s [mfw %s]", mbi, mfw);
607	650	} else {
608	651	snprintf(info->fw_version, sizeof(info->fw_version),
609		- "%s %s", mfw, storm);
	652	+ "mfw %s", mfw);
610	653	}
611	654
612	655	strlcpy(info->bus_info, pci_name(edev->pdev), sizeof(info->bus_info));
..	..	@@ -776,6 +819,7 @@
776	819
777	820	coal->rx_coalesce_usecs = rx_coal;
778	821	coal->tx_coalesce_usecs = tx_coal;
	822	+ coal->stats_block_coalesce_usecs = edev->stats_coal_usecs;
779	823
780	824	return rc;
781	825	}
..	..	@@ -787,6 +831,19 @@
787	831	struct qede_fastpath *fp;
788	832	int i, rc = 0;
789	833	u16 rxc, txc;
	834	+
	835	+ if (edev->stats_coal_usecs != coal->stats_block_coalesce_usecs) {
	836	+ edev->stats_coal_usecs = coal->stats_block_coalesce_usecs;
	837	+ if (edev->stats_coal_usecs) {
	838	+ edev->stats_coal_ticks = usecs_to_jiffies(edev->stats_coal_usecs);
	839	+ schedule_delayed_work(&edev->periodic_task, 0);
	840	+
	841	+ DP_INFO(edev, "Configured stats coal ticks=%lu jiffies\n",
	842	+ edev->stats_coal_ticks);
	843	+ } else {
	844	+ cancel_delayed_work_sync(&edev->periodic_task);
	845	+ }
	846	+ }
790	847
791	848	if (!netif_running(dev)) {
792	849	DP_INFO(edev, "Interface is down\n");
..	..	@@ -922,13 +979,16 @@
922	979
923	980	memset(&params, 0, sizeof(params));
924	981	params.override_flags \|= QED_LINK_OVERRIDE_PAUSE_CONFIG;
	982	+
925	983	if (epause->autoneg) {
926		- if (!(current_link.supported_caps & QED_LM_Autoneg_BIT)) {
	984	+ if (!phylink_test(current_link.supported_caps, Autoneg)) {
927	985	DP_INFO(edev, "autoneg not supported\n");
928	986	return -EINVAL;
929	987	}
	988	+
930	989	params.pause_config \|= QED_LINK_PAUSE_AUTONEG_ENABLE;
931	990	}
	991	+
932	992	if (epause->rx_pause)
933	993	params.pause_config \|= QED_LINK_PAUSE_RX_ENABLE;
934	994	if (epause->tx_pause)
..	..	@@ -984,7 +1044,9 @@
984	1044	args.u.mtu = new_mtu;
985	1045	args.func = &qede_update_mtu;
986	1046	qede_reload(edev, &args, false);
987		-
	1047	+#if IS_ENABLED(CONFIG_QED_RDMA)
	1048	+ qede_rdma_event_change_mtu(edev);
	1049	+#endif
988	1050	edev->ops->common->update_mtu(edev->cdev, new_mtu);
989	1051
990	1052	return 0;
..	..	@@ -1458,14 +1520,6 @@
1458	1520	barrier();
1459	1521	writel(txq->tx_db.raw, txq->doorbell_addr);
1460	1522
1461		- /* mmiowb is needed to synchronize doorbell writes from more than one
1462		- * processor. It guarantees that the write arrives to the device before
1463		- * the queue lock is released and another start_xmit is called (possibly
1464		- * on another CPU). Without this barrier, the next doorbell can bypass
1465		- * this doorbell. This is applicable to IA64/Altix systems.
1466		- */
1467		- mmiowb();
1468		-
1469	1523	for (i = 0; i < QEDE_SELFTEST_POLL_COUNT; i++) {
1470	1524	if (qede_txq_has_work(txq))
1471	1525	break;
..	..	@@ -1488,7 +1542,7 @@
1488	1542
1489	1543	static int qede_selftest_receive_traffic(struct qede_dev *edev)
1490	1544	{
1491		- u16 hw_comp_cons, sw_comp_cons, sw_rx_index, len;
	1545	+ u16 sw_rx_index, len;
1492	1546	struct eth_fast_path_rx_reg_cqe *fp_cqe;
1493	1547	struct qede_rx_queue *rxq = NULL;
1494	1548	struct sw_rx_data *sw_rx_data;
..	..	@@ -1517,17 +1571,6 @@
1517	1571	usleep_range(100, 200);
1518	1572	continue;
1519	1573	}
1520		-
1521		- hw_comp_cons = le16_to_cpu(*rxq->hw_cons_ptr);
1522		- sw_comp_cons = qed_chain_get_cons_idx(&rxq->rx_comp_ring);
1523		-
1524		- /* Memory barrier to prevent the CPU from doing speculative
1525		- * reads of CQE/BD before reading hw_comp_cons. If the CQE is
1526		- * read before it is written by FW, then FW writes CQE and SB,
1527		- * and then the CPU reads the hw_comp_cons, it will use an old
1528		- * CQE.
1529		- */
1530		- rmb();
1531	1574
1532	1575	/* Get the CQE from the completion ring */
1533	1576	cqe = (union eth_rx_cqe *)qed_chain_consume(&rxq->rx_comp_ring);
..	..	@@ -1595,8 +1638,11 @@
1595	1638	/* Wait for loopback configuration to apply */
1596	1639	msleep_interruptible(500);
1597	1640
1598		- /* prepare the loopback packet */
1599		- pkt_size = edev->ndev->mtu + ETH_HLEN;
	1641	+ /* Setting max packet size to 1.5K to avoid data being split over
	1642	+ * multiple BDs in cases where MTU > PAGE_SIZE.
	1643	+ */
	1644	+ pkt_size = (((edev->ndev->mtu < ETH_DATA_LEN) ?
	1645	+ edev->ndev->mtu : ETH_DATA_LEN) + ETH_HLEN);
1600	1646
1601	1647	skb = netdev_alloc_skb(edev->ndev, pkt_size);
1602	1648	if (!skb) {
..	..	@@ -1808,6 +1854,78 @@
1808	1854	return 0;
1809	1855	}
1810	1856
	1857	+static u32 qede_link_to_ethtool_fec(u32 link_fec)
	1858	+{
	1859	+ u32 eth_fec = 0;
	1860	+
	1861	+ if (link_fec & QED_FEC_MODE_NONE)
	1862	+ eth_fec \|= ETHTOOL_FEC_OFF;
	1863	+ if (link_fec & QED_FEC_MODE_FIRECODE)
	1864	+ eth_fec \|= ETHTOOL_FEC_BASER;
	1865	+ if (link_fec & QED_FEC_MODE_RS)
	1866	+ eth_fec \|= ETHTOOL_FEC_RS;
	1867	+ if (link_fec & QED_FEC_MODE_AUTO)
	1868	+ eth_fec \|= ETHTOOL_FEC_AUTO;
	1869	+ if (link_fec & QED_FEC_MODE_UNSUPPORTED)
	1870	+ eth_fec \|= ETHTOOL_FEC_NONE;
	1871	+
	1872	+ return eth_fec;
	1873	+}
	1874	+
	1875	+static u32 qede_ethtool_to_link_fec(u32 eth_fec)
	1876	+{
	1877	+ u32 link_fec = 0;
	1878	+
	1879	+ if (eth_fec & ETHTOOL_FEC_OFF)
	1880	+ link_fec \|= QED_FEC_MODE_NONE;
	1881	+ if (eth_fec & ETHTOOL_FEC_BASER)
	1882	+ link_fec \|= QED_FEC_MODE_FIRECODE;
	1883	+ if (eth_fec & ETHTOOL_FEC_RS)
	1884	+ link_fec \|= QED_FEC_MODE_RS;
	1885	+ if (eth_fec & ETHTOOL_FEC_AUTO)
	1886	+ link_fec \|= QED_FEC_MODE_AUTO;
	1887	+ if (eth_fec & ETHTOOL_FEC_NONE)
	1888	+ link_fec \|= QED_FEC_MODE_UNSUPPORTED;
	1889	+
	1890	+ return link_fec;
	1891	+}
	1892	+
	1893	+static int qede_get_fecparam(struct net_device *dev,
	1894	+ struct ethtool_fecparam *fecparam)
	1895	+{
	1896	+ struct qede_dev *edev = netdev_priv(dev);
	1897	+ struct qed_link_output curr_link;
	1898	+
	1899	+ memset(&curr_link, 0, sizeof(curr_link));
	1900	+ edev->ops->common->get_link(edev->cdev, &curr_link);
	1901	+
	1902	+ fecparam->active_fec = qede_link_to_ethtool_fec(curr_link.active_fec);
	1903	+ fecparam->fec = qede_link_to_ethtool_fec(curr_link.sup_fec);
	1904	+
	1905	+ return 0;
	1906	+}
	1907	+
	1908	+static int qede_set_fecparam(struct net_device *dev,
	1909	+ struct ethtool_fecparam *fecparam)
	1910	+{
	1911	+ struct qede_dev *edev = netdev_priv(dev);
	1912	+ struct qed_link_params params;
	1913	+
	1914	+ if (!edev->ops \|\| !edev->ops->common->can_link_change(edev->cdev)) {
	1915	+ DP_INFO(edev, "Link settings are not allowed to be changed\n");
	1916	+ return -EOPNOTSUPP;
	1917	+ }
	1918	+
	1919	+ memset(&params, 0, sizeof(params));
	1920	+ params.override_flags \|= QED_LINK_OVERRIDE_FEC_CONFIG;
	1921	+ params.fec = qede_ethtool_to_link_fec(fecparam->fec);
	1922	+ params.link_up = true;
	1923	+
	1924	+ edev->ops->common->set_link(edev->cdev, &params);
	1925	+
	1926	+ return 0;
	1927	+}
	1928	+
1811	1929	static int qede_get_module_info(struct net_device *dev,
1812	1930	struct ethtool_modinfo *modinfo)
1813	1931	{
..	..	@@ -1894,73 +2012,193 @@
1894	2012	return rc;
1895	2013	}
1896	2014
1897		-static const struct ethtool_ops qede_ethtool_ops = {
1898		- .get_link_ksettings = qede_get_link_ksettings,
1899		- .set_link_ksettings = qede_set_link_ksettings,
1900		- .get_drvinfo = qede_get_drvinfo,
1901		- .get_regs_len = qede_get_regs_len,
1902		- .get_regs = qede_get_regs,
1903		- .get_wol = qede_get_wol,
1904		- .set_wol = qede_set_wol,
1905		- .get_msglevel = qede_get_msglevel,
1906		- .set_msglevel = qede_set_msglevel,
1907		- .nway_reset = qede_nway_reset,
1908		- .get_link = qede_get_link,
1909		- .get_coalesce = qede_get_coalesce,
1910		- .set_coalesce = qede_set_coalesce,
1911		- .get_ringparam = qede_get_ringparam,
1912		- .set_ringparam = qede_set_ringparam,
1913		- .get_pauseparam = qede_get_pauseparam,
1914		- .set_pauseparam = qede_set_pauseparam,
1915		- .get_strings = qede_get_strings,
1916		- .set_phys_id = qede_set_phys_id,
1917		- .get_ethtool_stats = qede_get_ethtool_stats,
1918		- .get_priv_flags = qede_get_priv_flags,
1919		- .get_sset_count = qede_get_sset_count,
1920		- .get_rxnfc = qede_get_rxnfc,
1921		- .set_rxnfc = qede_set_rxnfc,
1922		- .get_rxfh_indir_size = qede_get_rxfh_indir_size,
1923		- .get_rxfh_key_size = qede_get_rxfh_key_size,
1924		- .get_rxfh = qede_get_rxfh,
1925		- .set_rxfh = qede_set_rxfh,
1926		- .get_ts_info = qede_get_ts_info,
1927		- .get_channels = qede_get_channels,
1928		- .set_channels = qede_set_channels,
1929		- .self_test = qede_self_test,
1930		- .get_module_info = qede_get_module_info,
1931		- .get_module_eeprom = qede_get_module_eeprom,
1932		- .get_eee = qede_get_eee,
1933		- .set_eee = qede_set_eee,
	2015	+static int qede_set_dump(struct net_device dev, struct ethtool_dump val)
	2016	+{
	2017	+ struct qede_dev *edev = netdev_priv(dev);
	2018	+ int rc = 0;
1934	2019
1935		- .get_tunable = qede_get_tunable,
1936		- .set_tunable = qede_set_tunable,
1937		- .flash_device = qede_flash_device,
	2020	+ if (edev->dump_info.cmd == QEDE_DUMP_CMD_NONE) {
	2021	+ if (val->flag > QEDE_DUMP_CMD_MAX) {
	2022	+ DP_ERR(edev, "Invalid command %d\n", val->flag);
	2023	+ return -EINVAL;
	2024	+ }
	2025	+ edev->dump_info.cmd = val->flag;
	2026	+ edev->dump_info.num_args = 0;
	2027	+ return 0;
	2028	+ }
	2029	+
	2030	+ if (edev->dump_info.num_args == QEDE_DUMP_MAX_ARGS) {
	2031	+ DP_ERR(edev, "Arg count = %d\n", edev->dump_info.num_args);
	2032	+ return -EINVAL;
	2033	+ }
	2034	+
	2035	+ switch (edev->dump_info.cmd) {
	2036	+ case QEDE_DUMP_CMD_NVM_CFG:
	2037	+ edev->dump_info.args[edev->dump_info.num_args] = val->flag;
	2038	+ edev->dump_info.num_args++;
	2039	+ break;
	2040	+ case QEDE_DUMP_CMD_GRCDUMP:
	2041	+ rc = edev->ops->common->set_grc_config(edev->cdev,
	2042	+ val->flag, 1);
	2043	+ break;
	2044	+ default:
	2045	+ break;
	2046	+ }
	2047	+
	2048	+ return rc;
	2049	+}
	2050	+
	2051	+static int qede_get_dump_flag(struct net_device *dev,
	2052	+ struct ethtool_dump *dump)
	2053	+{
	2054	+ struct qede_dev *edev = netdev_priv(dev);
	2055	+
	2056	+ if (!edev->ops \|\| !edev->ops->common) {
	2057	+ DP_ERR(edev, "Edev ops not populated\n");
	2058	+ return -EINVAL;
	2059	+ }
	2060	+
	2061	+ dump->version = QEDE_DUMP_VERSION;
	2062	+ switch (edev->dump_info.cmd) {
	2063	+ case QEDE_DUMP_CMD_NVM_CFG:
	2064	+ dump->flag = QEDE_DUMP_CMD_NVM_CFG;
	2065	+ dump->len = edev->ops->common->read_nvm_cfg_len(edev->cdev,
	2066	+ edev->dump_info.args[0]);
	2067	+ break;
	2068	+ case QEDE_DUMP_CMD_GRCDUMP:
	2069	+ dump->flag = QEDE_DUMP_CMD_GRCDUMP;
	2070	+ dump->len = edev->ops->common->dbg_all_data_size(edev->cdev);
	2071	+ break;
	2072	+ default:
	2073	+ DP_ERR(edev, "Invalid cmd = %d\n", edev->dump_info.cmd);
	2074	+ return -EINVAL;
	2075	+ }
	2076	+
	2077	+ DP_VERBOSE(edev, QED_MSG_DEBUG,
	2078	+ "dump->version = 0x%x dump->flag = %d dump->len = %d\n",
	2079	+ dump->version, dump->flag, dump->len);
	2080	+ return 0;
	2081	+}
	2082	+
	2083	+static int qede_get_dump_data(struct net_device *dev,
	2084	+ struct ethtool_dump dump, void buf)
	2085	+{
	2086	+ struct qede_dev *edev = netdev_priv(dev);
	2087	+ int rc = 0;
	2088	+
	2089	+ if (!edev->ops \|\| !edev->ops->common) {
	2090	+ DP_ERR(edev, "Edev ops not populated\n");
	2091	+ rc = -EINVAL;
	2092	+ goto err;
	2093	+ }
	2094	+
	2095	+ switch (edev->dump_info.cmd) {
	2096	+ case QEDE_DUMP_CMD_NVM_CFG:
	2097	+ if (edev->dump_info.num_args != QEDE_DUMP_NVM_ARG_COUNT) {
	2098	+ DP_ERR(edev, "Arg count = %d required = %d\n",
	2099	+ edev->dump_info.num_args,
	2100	+ QEDE_DUMP_NVM_ARG_COUNT);
	2101	+ rc = -EINVAL;
	2102	+ goto err;
	2103	+ }
	2104	+ rc = edev->ops->common->read_nvm_cfg(edev->cdev, (u8 **)&buf,
	2105	+ edev->dump_info.args[0],
	2106	+ edev->dump_info.args[1]);
	2107	+ break;
	2108	+ case QEDE_DUMP_CMD_GRCDUMP:
	2109	+ memset(buf, 0, dump->len);
	2110	+ rc = edev->ops->common->dbg_all_data(edev->cdev, buf);
	2111	+ break;
	2112	+ default:
	2113	+ DP_ERR(edev, "Invalid cmd = %d\n", edev->dump_info.cmd);
	2114	+ rc = -EINVAL;
	2115	+ break;
	2116	+ }
	2117	+
	2118	+err:
	2119	+ edev->dump_info.cmd = QEDE_DUMP_CMD_NONE;
	2120	+ edev->dump_info.num_args = 0;
	2121	+ memset(edev->dump_info.args, 0, sizeof(edev->dump_info.args));
	2122	+
	2123	+ return rc;
	2124	+}
	2125	+
	2126	+static const struct ethtool_ops qede_ethtool_ops = {
	2127	+ .supported_coalesce_params = ETHTOOL_COALESCE_USECS \|
	2128	+ ETHTOOL_COALESCE_STATS_BLOCK_USECS,
	2129	+ .get_link_ksettings = qede_get_link_ksettings,
	2130	+ .set_link_ksettings = qede_set_link_ksettings,
	2131	+ .get_drvinfo = qede_get_drvinfo,
	2132	+ .get_regs_len = qede_get_regs_len,
	2133	+ .get_regs = qede_get_regs,
	2134	+ .get_wol = qede_get_wol,
	2135	+ .set_wol = qede_set_wol,
	2136	+ .get_msglevel = qede_get_msglevel,
	2137	+ .set_msglevel = qede_set_msglevel,
	2138	+ .nway_reset = qede_nway_reset,
	2139	+ .get_link = qede_get_link,
	2140	+ .get_coalesce = qede_get_coalesce,
	2141	+ .set_coalesce = qede_set_coalesce,
	2142	+ .get_ringparam = qede_get_ringparam,
	2143	+ .set_ringparam = qede_set_ringparam,
	2144	+ .get_pauseparam = qede_get_pauseparam,
	2145	+ .set_pauseparam = qede_set_pauseparam,
	2146	+ .get_strings = qede_get_strings,
	2147	+ .set_phys_id = qede_set_phys_id,
	2148	+ .get_ethtool_stats = qede_get_ethtool_stats,
	2149	+ .get_priv_flags = qede_get_priv_flags,
	2150	+ .set_priv_flags = qede_set_priv_flags,
	2151	+ .get_sset_count = qede_get_sset_count,
	2152	+ .get_rxnfc = qede_get_rxnfc,
	2153	+ .set_rxnfc = qede_set_rxnfc,
	2154	+ .get_rxfh_indir_size = qede_get_rxfh_indir_size,
	2155	+ .get_rxfh_key_size = qede_get_rxfh_key_size,
	2156	+ .get_rxfh = qede_get_rxfh,
	2157	+ .set_rxfh = qede_set_rxfh,
	2158	+ .get_ts_info = qede_get_ts_info,
	2159	+ .get_channels = qede_get_channels,
	2160	+ .set_channels = qede_set_channels,
	2161	+ .self_test = qede_self_test,
	2162	+ .get_module_info = qede_get_module_info,
	2163	+ .get_module_eeprom = qede_get_module_eeprom,
	2164	+ .get_eee = qede_get_eee,
	2165	+ .set_eee = qede_set_eee,
	2166	+ .get_fecparam = qede_get_fecparam,
	2167	+ .set_fecparam = qede_set_fecparam,
	2168	+ .get_tunable = qede_get_tunable,
	2169	+ .set_tunable = qede_set_tunable,
	2170	+ .flash_device = qede_flash_device,
	2171	+ .get_dump_flag = qede_get_dump_flag,
	2172	+ .get_dump_data = qede_get_dump_data,
	2173	+ .set_dump = qede_set_dump,
1938	2174	};
1939	2175
1940	2176	static const struct ethtool_ops qede_vf_ethtool_ops = {
1941		- .get_link_ksettings = qede_get_link_ksettings,
1942		- .get_drvinfo = qede_get_drvinfo,
1943		- .get_msglevel = qede_get_msglevel,
1944		- .set_msglevel = qede_set_msglevel,
1945		- .get_link = qede_get_link,
1946		- .get_coalesce = qede_get_coalesce,
1947		- .set_coalesce = qede_set_coalesce,
1948		- .get_ringparam = qede_get_ringparam,
1949		- .set_ringparam = qede_set_ringparam,
1950		- .get_strings = qede_get_strings,
1951		- .get_ethtool_stats = qede_get_ethtool_stats,
1952		- .get_priv_flags = qede_get_priv_flags,
1953		- .get_sset_count = qede_get_sset_count,
1954		- .get_rxnfc = qede_get_rxnfc,
1955		- .set_rxnfc = qede_set_rxnfc,
1956		- .get_rxfh_indir_size = qede_get_rxfh_indir_size,
1957		- .get_rxfh_key_size = qede_get_rxfh_key_size,
1958		- .get_rxfh = qede_get_rxfh,
1959		- .set_rxfh = qede_set_rxfh,
1960		- .get_channels = qede_get_channels,
1961		- .set_channels = qede_set_channels,
1962		- .get_tunable = qede_get_tunable,
1963		- .set_tunable = qede_set_tunable,
	2177	+ .supported_coalesce_params = ETHTOOL_COALESCE_USECS \|
	2178	+ ETHTOOL_COALESCE_STATS_BLOCK_USECS,
	2179	+ .get_link_ksettings = qede_get_link_ksettings,
	2180	+ .get_drvinfo = qede_get_drvinfo,
	2181	+ .get_msglevel = qede_get_msglevel,
	2182	+ .set_msglevel = qede_set_msglevel,
	2183	+ .get_link = qede_get_link,
	2184	+ .get_coalesce = qede_get_coalesce,
	2185	+ .set_coalesce = qede_set_coalesce,
	2186	+ .get_ringparam = qede_get_ringparam,
	2187	+ .set_ringparam = qede_set_ringparam,
	2188	+ .get_strings = qede_get_strings,
	2189	+ .get_ethtool_stats = qede_get_ethtool_stats,
	2190	+ .get_priv_flags = qede_get_priv_flags,
	2191	+ .get_sset_count = qede_get_sset_count,
	2192	+ .get_rxnfc = qede_get_rxnfc,
	2193	+ .set_rxnfc = qede_set_rxnfc,
	2194	+ .get_rxfh_indir_size = qede_get_rxfh_indir_size,
	2195	+ .get_rxfh_key_size = qede_get_rxfh_key_size,
	2196	+ .get_rxfh = qede_get_rxfh,
	2197	+ .set_rxfh = qede_set_rxfh,
	2198	+ .get_channels = qede_get_channels,
	2199	+ .set_channels = qede_set_channels,
	2200	+ .get_tunable = qede_get_tunable,
	2201	+ .set_tunable = qede_set_tunable,
1964	2202	};
1965	2203
1966	2204	void qede_set_ethtool_ops(struct net_device *dev)