1	// SPDX-License-Identifier: GPL-2.0
2	/* Copyright(c) 2013 - 2018 Intel Corporation. */
3
4	/* ethtool support for i40e */
5
6	#include "i40e_devids.h"
7	#include "i40e_diag.h"
8	#include "i40e_txrx_common.h"
9	#include "i40e_virtchnl_pf.h"
10
11	/* ethtool statistics helpers */
12
13	/**
14	* struct i40e_stats - definition for an ethtool statistic
15	* @stat_string: statistic name to display in ethtool -S output
16	* @sizeof_stat: the sizeof() the stat, must be no greater than sizeof(u64)
17	* @stat_offset: offsetof() the stat from a base pointer
18	*
19	* This structure defines a statistic to be added to the ethtool stats buffer.
20	* It defines a statistic as offset from a common base pointer. Stats should
21	* be defined in constant arrays using the I40E_STAT macro, with every element
22	* of the array using the same _type for calculating the sizeof_stat and
23	* stat_offset.
24	*
25	* The @sizeof_stat is expected to be sizeof(u8), sizeof(u16), sizeof(u32) or
26	* sizeof(u64). Other sizes are not expected and will produce a WARN_ONCE from
27	* the i40e_add_ethtool_stat() helper function.
28	*
29	* The @stat_string is interpreted as a format string, allowing formatted
30	* values to be inserted while looping over multiple structures for a given
31	* statistics array. Thus, every statistic string in an array should have the
32	* same type and number of format specifiers, to be formatted by variadic
33	* arguments to the i40e_add_stat_string() helper function.
34	**/
35	struct i40e_stats {
36	char stat_string[ETH_GSTRING_LEN];
37	int sizeof_stat;
38	int stat_offset;
39	};
40
41	/* Helper macro to define an i40e_stat structure with proper size and type.
42	* Use this when defining constant statistics arrays. Note that @_type expects
43	* only a type name and is used multiple times.
44	*/
45	#define I40E_STAT(_type, _name, _stat) { \
46	.stat_string = _name, \
47	.sizeof_stat = sizeof_field(_type, _stat), \
48	.stat_offset = offsetof(_type, _stat) \
49	}
50
51	/* Helper macro for defining some statistics directly copied from the netdev
52	* stats structure.
53	*/
54	#define I40E_NETDEV_STAT(_net_stat) \
55	I40E_STAT(struct rtnl_link_stats64, #_net_stat, _net_stat)
56
57	/* Helper macro for defining some statistics related to queues */
58	#define I40E_QUEUE_STAT(_name, _stat) \
59	I40E_STAT(struct i40e_ring, _name, _stat)
60
61	/* Stats associated with a Tx or Rx ring */
62	static const struct i40e_stats i40e_gstrings_queue_stats[] = {
63	I40E_QUEUE_STAT("%s-%u.packets", stats.packets),
64	I40E_QUEUE_STAT("%s-%u.bytes", stats.bytes),
65	};
66
67	/**
68	* i40e_add_one_ethtool_stat - copy the stat into the supplied buffer
69	* @data: location to store the stat value
70	* @pointer: basis for where to copy from
71	* @stat: the stat definition
72	*
73	* Copies the stat data defined by the pointer and stat structure pair into
74	* the memory supplied as data. Used to implement i40e_add_ethtool_stats and
75	* i40e_add_queue_stats. If the pointer is null, data will be zero'd.
76	*/
77	static void
78	i40e_add_one_ethtool_stat(u64 *data, void *pointer,
79	const struct i40e_stats *stat)
80	{
81	char *p;
82
83	if (!pointer) {
84	/* ensure that the ethtool data buffer is zero'd for any stats
85	* which don't have a valid pointer.
86	*/
87	*data = 0;
88	return;
89	}
90
91	p = (char *)pointer + stat->stat_offset;
92	switch (stat->sizeof_stat) {
93	case sizeof(u64):
94	*data = *((u64 *)p);
95	break;
96	case sizeof(u32):
97	*data = *((u32 *)p);
98	break;
99	case sizeof(u16):
100	*data = *((u16 *)p);
101	break;
102	case sizeof(u8):
103	*data = *((u8 *)p);
104	break;
105	default:
106	WARN_ONCE(1, "unexpected stat size for %s",
107	stat->stat_string);
108	*data = 0;
109	}
110	}
111
112	/**
113	* __i40e_add_ethtool_stats - copy stats into the ethtool supplied buffer
114	* @data: ethtool stats buffer
115	* @pointer: location to copy stats from
116	* @stats: array of stats to copy
117	* @size: the size of the stats definition
118	*
119	* Copy the stats defined by the stats array using the pointer as a base into
120	* the data buffer supplied by ethtool. Updates the data pointer to point to
121	* the next empty location for successive calls to __i40e_add_ethtool_stats.
122	* If pointer is null, set the data values to zero and update the pointer to
123	* skip these stats.
124	**/
125	static void
126	__i40e_add_ethtool_stats(u64 **data, void *pointer,
127	const struct i40e_stats stats[],
128	const unsigned int size)
129	{
130	unsigned int i;
131
132	for (i = 0; i < size; i++)
133	i40e_add_one_ethtool_stat(data: (*data)++, pointer, stat: &stats[i]);
134	}
135
136	/**
137	* i40e_add_ethtool_stats - copy stats into ethtool supplied buffer
138	* @data: ethtool stats buffer
139	* @pointer: location where stats are stored
140	* @stats: static const array of stat definitions
141	*
142	* Macro to ease the use of __i40e_add_ethtool_stats by taking a static
143	* constant stats array and passing the ARRAY_SIZE(). This avoids typos by
144	* ensuring that we pass the size associated with the given stats array.
145	*
146	* The parameter @stats is evaluated twice, so parameters with side effects
147	* should be avoided.
148	**/
149	#define i40e_add_ethtool_stats(data, pointer, stats) \
150	__i40e_add_ethtool_stats(data, pointer, stats, ARRAY_SIZE(stats))
151
152	/**
153	* i40e_add_queue_stats - copy queue statistics into supplied buffer
154	* @data: ethtool stats buffer
155	* @ring: the ring to copy
156	*
157	* Queue statistics must be copied while protected by
158	* u64_stats_fetch_begin, so we can't directly use i40e_add_ethtool_stats.
159	* Assumes that queue stats are defined in i40e_gstrings_queue_stats. If the
160	* ring pointer is null, zero out the queue stat values and update the data
161	* pointer. Otherwise safely copy the stats from the ring into the supplied
162	* buffer and update the data pointer when finished.
163	*
164	* This function expects to be called while under rcu_read_lock().
165	**/
166	static void
167	i40e_add_queue_stats(u64 **data, struct i40e_ring *ring)
168	{
169	const unsigned int size = ARRAY_SIZE(i40e_gstrings_queue_stats);
170	const struct i40e_stats *stats = i40e_gstrings_queue_stats;
171	unsigned int start;
172	unsigned int i;
173
174	/* To avoid invalid statistics values, ensure that we keep retrying
175	* the copy until we get a consistent value according to
176	* u64_stats_fetch_retry. But first, make sure our ring is
177	* non-null before attempting to access its syncp.
178	*/
179	do {
180	start = !ring ? 0 : u64_stats_fetch_begin(syncp: &ring->syncp);
181	for (i = 0; i < size; i++) {
182	i40e_add_one_ethtool_stat(data: &(*data)[i], pointer: ring,
183	stat: &stats[i]);
184	}
185	} while (ring && u64_stats_fetch_retry(syncp: &ring->syncp, start));
186
187	/* Once we successfully copy the stats in, update the data pointer */
188	*data += size;
189	}
190
191	/**
192	* __i40e_add_stat_strings - copy stat strings into ethtool buffer
193	* @p: ethtool supplied buffer
194	* @stats: stat definitions array
195	* @size: size of the stats array
196	*
197	* Format and copy the strings described by stats into the buffer pointed at
198	* by p.
199	**/
200	static void __i40e_add_stat_strings(u8 **p, const struct i40e_stats stats[],
201	const unsigned int size, ...)
202	{
203	unsigned int i;
204
205	for (i = 0; i < size; i++) {
206	va_list args;
207
208	va_start(args, size);
209	vsnprintf(buf: *p, ETH_GSTRING_LEN, fmt: stats[i].stat_string, args);
210	*p += ETH_GSTRING_LEN;
211	va_end(args);
212	}
213	}
214
215	/**
216	* i40e_add_stat_strings - copy stat strings into ethtool buffer
217	* @p: ethtool supplied buffer
218	* @stats: stat definitions array
219	*
220	* Format and copy the strings described by the const static stats value into
221	* the buffer pointed at by p.
222	*
223	* The parameter @stats is evaluated twice, so parameters with side effects
224	* should be avoided. Additionally, stats must be an array such that
225	* ARRAY_SIZE can be called on it.
226	**/
227	#define i40e_add_stat_strings(p, stats, ...) \
228	__i40e_add_stat_strings(p, stats, ARRAY_SIZE(stats), ## __VA_ARGS__)
229
230	#define I40E_PF_STAT(_name, _stat) \
231	I40E_STAT(struct i40e_pf, _name, _stat)
232	#define I40E_VSI_STAT(_name, _stat) \
233	I40E_STAT(struct i40e_vsi, _name, _stat)
234	#define I40E_VEB_STAT(_name, _stat) \
235	I40E_STAT(struct i40e_veb, _name, _stat)
236	#define I40E_VEB_TC_STAT(_name, _stat) \
237	I40E_STAT(struct i40e_cp_veb_tc_stats, _name, _stat)
238	#define I40E_PFC_STAT(_name, _stat) \
239	I40E_STAT(struct i40e_pfc_stats, _name, _stat)
240
241	static const struct i40e_stats i40e_gstrings_net_stats[] = {
242	I40E_NETDEV_STAT(rx_packets),
243	I40E_NETDEV_STAT(tx_packets),
244	I40E_NETDEV_STAT(rx_bytes),
245	I40E_NETDEV_STAT(tx_bytes),
246	I40E_NETDEV_STAT(rx_errors),
247	I40E_NETDEV_STAT(tx_errors),
248	I40E_NETDEV_STAT(rx_dropped),
249	I40E_NETDEV_STAT(rx_missed_errors),
250	I40E_NETDEV_STAT(tx_dropped),
251	I40E_NETDEV_STAT(collisions),
252	I40E_NETDEV_STAT(rx_length_errors),
253	I40E_NETDEV_STAT(rx_crc_errors),
254	};
255
256	static const struct i40e_stats i40e_gstrings_veb_stats[] = {
257	I40E_VEB_STAT("veb.rx_bytes", stats.rx_bytes),
258	I40E_VEB_STAT("veb.tx_bytes", stats.tx_bytes),
259	I40E_VEB_STAT("veb.rx_unicast", stats.rx_unicast),
260	I40E_VEB_STAT("veb.tx_unicast", stats.tx_unicast),
261	I40E_VEB_STAT("veb.rx_multicast", stats.rx_multicast),
262	I40E_VEB_STAT("veb.tx_multicast", stats.tx_multicast),
263	I40E_VEB_STAT("veb.rx_broadcast", stats.rx_broadcast),
264	I40E_VEB_STAT("veb.tx_broadcast", stats.tx_broadcast),
265	I40E_VEB_STAT("veb.rx_discards", stats.rx_discards),
266	I40E_VEB_STAT("veb.tx_discards", stats.tx_discards),
267	I40E_VEB_STAT("veb.tx_errors", stats.tx_errors),
268	I40E_VEB_STAT("veb.rx_unknown_protocol", stats.rx_unknown_protocol),
269	};
270
271	struct i40e_cp_veb_tc_stats {
272	u64 tc_rx_packets;
273	u64 tc_rx_bytes;
274	u64 tc_tx_packets;
275	u64 tc_tx_bytes;
276	};
277
278	static const struct i40e_stats i40e_gstrings_veb_tc_stats[] = {
279	I40E_VEB_TC_STAT("veb.tc_%u_tx_packets", tc_tx_packets),
280	I40E_VEB_TC_STAT("veb.tc_%u_tx_bytes", tc_tx_bytes),
281	I40E_VEB_TC_STAT("veb.tc_%u_rx_packets", tc_rx_packets),
282	I40E_VEB_TC_STAT("veb.tc_%u_rx_bytes", tc_rx_bytes),
283	};
284
285	static const struct i40e_stats i40e_gstrings_misc_stats[] = {
286	I40E_VSI_STAT("rx_unicast", eth_stats.rx_unicast),
287	I40E_VSI_STAT("tx_unicast", eth_stats.tx_unicast),
288	I40E_VSI_STAT("rx_multicast", eth_stats.rx_multicast),
289	I40E_VSI_STAT("tx_multicast", eth_stats.tx_multicast),
290	I40E_VSI_STAT("rx_broadcast", eth_stats.rx_broadcast),
291	I40E_VSI_STAT("tx_broadcast", eth_stats.tx_broadcast),
292	I40E_VSI_STAT("rx_unknown_protocol", eth_stats.rx_unknown_protocol),
293	I40E_VSI_STAT("tx_linearize", tx_linearize),
294	I40E_VSI_STAT("tx_force_wb", tx_force_wb),
295	I40E_VSI_STAT("tx_busy", tx_busy),
296	I40E_VSI_STAT("tx_stopped", tx_stopped),
297	I40E_VSI_STAT("rx_alloc_fail", rx_buf_failed),
298	I40E_VSI_STAT("rx_pg_alloc_fail", rx_page_failed),
299	I40E_VSI_STAT("rx_cache_reuse", rx_page_reuse),
300	I40E_VSI_STAT("rx_cache_alloc", rx_page_alloc),
301	I40E_VSI_STAT("rx_cache_waive", rx_page_waive),
302	I40E_VSI_STAT("rx_cache_busy", rx_page_busy),
303	I40E_VSI_STAT("tx_restart", tx_restart),
304	};
305
306	/* These PF_STATs might look like duplicates of some NETDEV_STATs,
307	* but they are separate. This device supports Virtualization, and
308	* as such might have several netdevs supporting VMDq and FCoE going
309	* through a single port. The NETDEV_STATs are for individual netdevs
310	* seen at the top of the stack, and the PF_STATs are for the physical
311	* function at the bottom of the stack hosting those netdevs.
312	*
313	* The PF_STATs are appended to the netdev stats only when ethtool -S
314	* is queried on the base PF netdev, not on the VMDq or FCoE netdev.
315	*/
316	static const struct i40e_stats i40e_gstrings_stats[] = {
317	I40E_PF_STAT("port.rx_bytes", stats.eth.rx_bytes),
318	I40E_PF_STAT("port.tx_bytes", stats.eth.tx_bytes),
319	I40E_PF_STAT("port.rx_unicast", stats.eth.rx_unicast),
320	I40E_PF_STAT("port.tx_unicast", stats.eth.tx_unicast),
321	I40E_PF_STAT("port.rx_multicast", stats.eth.rx_multicast),
322	I40E_PF_STAT("port.tx_multicast", stats.eth.tx_multicast),
323	I40E_PF_STAT("port.rx_broadcast", stats.eth.rx_broadcast),
324	I40E_PF_STAT("port.tx_broadcast", stats.eth.tx_broadcast),
325	I40E_PF_STAT("port.tx_errors", stats.eth.tx_errors),
326	I40E_PF_STAT("port.rx_discards", stats.eth.rx_discards),
327	I40E_PF_STAT("port.tx_dropped_link_down", stats.tx_dropped_link_down),
328	I40E_PF_STAT("port.rx_crc_errors", stats.crc_errors),
329	I40E_PF_STAT("port.illegal_bytes", stats.illegal_bytes),
330	I40E_PF_STAT("port.mac_local_faults", stats.mac_local_faults),
331	I40E_PF_STAT("port.mac_remote_faults", stats.mac_remote_faults),
332	I40E_PF_STAT("port.tx_timeout", tx_timeout_count),
333	I40E_PF_STAT("port.rx_csum_bad", hw_csum_rx_error),
334	I40E_PF_STAT("port.rx_length_errors", stats.rx_length_errors),
335	I40E_PF_STAT("port.link_xon_rx", stats.link_xon_rx),
336	I40E_PF_STAT("port.link_xoff_rx", stats.link_xoff_rx),
337	I40E_PF_STAT("port.link_xon_tx", stats.link_xon_tx),
338	I40E_PF_STAT("port.link_xoff_tx", stats.link_xoff_tx),
339	I40E_PF_STAT("port.rx_size_64", stats.rx_size_64),
340	I40E_PF_STAT("port.rx_size_127", stats.rx_size_127),
341	I40E_PF_STAT("port.rx_size_255", stats.rx_size_255),
342	I40E_PF_STAT("port.rx_size_511", stats.rx_size_511),
343	I40E_PF_STAT("port.rx_size_1023", stats.rx_size_1023),
344	I40E_PF_STAT("port.rx_size_1522", stats.rx_size_1522),
345	I40E_PF_STAT("port.rx_size_big", stats.rx_size_big),
346	I40E_PF_STAT("port.tx_size_64", stats.tx_size_64),
347	I40E_PF_STAT("port.tx_size_127", stats.tx_size_127),
348	I40E_PF_STAT("port.tx_size_255", stats.tx_size_255),
349	I40E_PF_STAT("port.tx_size_511", stats.tx_size_511),
350	I40E_PF_STAT("port.tx_size_1023", stats.tx_size_1023),
351	I40E_PF_STAT("port.tx_size_1522", stats.tx_size_1522),
352	I40E_PF_STAT("port.tx_size_big", stats.tx_size_big),
353	I40E_PF_STAT("port.rx_undersize", stats.rx_undersize),
354	I40E_PF_STAT("port.rx_fragments", stats.rx_fragments),
355	I40E_PF_STAT("port.rx_oversize", stats.rx_oversize),
356	I40E_PF_STAT("port.rx_jabber", stats.rx_jabber),
357	I40E_PF_STAT("port.VF_admin_queue_requests", vf_aq_requests),
358	I40E_PF_STAT("port.arq_overflows", arq_overflows),
359	I40E_PF_STAT("port.tx_hwtstamp_timeouts", tx_hwtstamp_timeouts),
360	I40E_PF_STAT("port.rx_hwtstamp_cleared", rx_hwtstamp_cleared),
361	I40E_PF_STAT("port.tx_hwtstamp_skipped", tx_hwtstamp_skipped),
362	I40E_PF_STAT("port.fdir_flush_cnt", fd_flush_cnt),
363	I40E_PF_STAT("port.fdir_atr_match", stats.fd_atr_match),
364	I40E_PF_STAT("port.fdir_atr_tunnel_match", stats.fd_atr_tunnel_match),
365	I40E_PF_STAT("port.fdir_atr_status", stats.fd_atr_status),
366	I40E_PF_STAT("port.fdir_sb_match", stats.fd_sb_match),
367	I40E_PF_STAT("port.fdir_sb_status", stats.fd_sb_status),
368
369	/* LPI stats */
370	I40E_PF_STAT("port.tx_lpi_status", stats.tx_lpi_status),
371	I40E_PF_STAT("port.rx_lpi_status", stats.rx_lpi_status),
372	I40E_PF_STAT("port.tx_lpi_count", stats.tx_lpi_count),
373	I40E_PF_STAT("port.rx_lpi_count", stats.rx_lpi_count),
374	};
375
376	struct i40e_pfc_stats {
377	u64 priority_xon_rx;
378	u64 priority_xoff_rx;
379	u64 priority_xon_tx;
380	u64 priority_xoff_tx;
381	u64 priority_xon_2_xoff;
382	};
383
384	static const struct i40e_stats i40e_gstrings_pfc_stats[] = {
385	I40E_PFC_STAT("port.tx_priority_%u_xon_tx", priority_xon_tx),
386	I40E_PFC_STAT("port.tx_priority_%u_xoff_tx", priority_xoff_tx),
387	I40E_PFC_STAT("port.rx_priority_%u_xon_rx", priority_xon_rx),
388	I40E_PFC_STAT("port.rx_priority_%u_xoff_rx", priority_xoff_rx),
389	I40E_PFC_STAT("port.rx_priority_%u_xon_2_xoff", priority_xon_2_xoff),
390	};
391
392	#define I40E_NETDEV_STATS_LEN ARRAY_SIZE(i40e_gstrings_net_stats)
393
394	#define I40E_MISC_STATS_LEN ARRAY_SIZE(i40e_gstrings_misc_stats)
395
396	#define I40E_VSI_STATS_LEN (I40E_NETDEV_STATS_LEN + I40E_MISC_STATS_LEN)
397
398	#define I40E_PFC_STATS_LEN (ARRAY_SIZE(i40e_gstrings_pfc_stats) * \
399	I40E_MAX_USER_PRIORITY)
400
401	#define I40E_VEB_STATS_LEN (ARRAY_SIZE(i40e_gstrings_veb_stats) + \
402	(ARRAY_SIZE(i40e_gstrings_veb_tc_stats) * \
403	I40E_MAX_TRAFFIC_CLASS))
404
405	#define I40E_GLOBAL_STATS_LEN ARRAY_SIZE(i40e_gstrings_stats)
406
407	#define I40E_PF_STATS_LEN (I40E_GLOBAL_STATS_LEN + \
408	I40E_PFC_STATS_LEN + \
409	I40E_VEB_STATS_LEN + \
410	I40E_VSI_STATS_LEN)
411
412	/* Length of stats for a single queue */
413	#define I40E_QUEUE_STATS_LEN ARRAY_SIZE(i40e_gstrings_queue_stats)
414
415	enum i40e_ethtool_test_id {
416	I40E_ETH_TEST_REG = 0,
417	I40E_ETH_TEST_EEPROM,
418	I40E_ETH_TEST_INTR,
419	I40E_ETH_TEST_LINK,
420	};
421
422	static const char i40e_gstrings_test[][ETH_GSTRING_LEN] = {
423	"Register test (offline)",
424	"Eeprom test (offline)",
425	"Interrupt test (offline)",
426	"Link test (on/offline)"
427	};
428
429	#define I40E_TEST_LEN (sizeof(i40e_gstrings_test) / ETH_GSTRING_LEN)
430
431	struct i40e_priv_flags {
432	char flag_string[ETH_GSTRING_LEN];
433	u8 bitno;
434	bool read_only;
435	};
436
437	#define I40E_PRIV_FLAG(_name, _bitno, _read_only) { \
438	.flag_string = _name, \
439	.bitno = _bitno, \
440	.read_only = _read_only, \
441	}
442
443	static const struct i40e_priv_flags i40e_gstrings_priv_flags[] = {
444	/* NOTE: MFP setting cannot be changed */
445	I40E_PRIV_FLAG("MFP", I40E_FLAG_MFP_ENA, 1),
446	I40E_PRIV_FLAG("total-port-shutdown",
447	I40E_FLAG_TOTAL_PORT_SHUTDOWN_ENA, 1),
448	I40E_PRIV_FLAG("LinkPolling", I40E_FLAG_LINK_POLLING_ENA, 0),
449	I40E_PRIV_FLAG("flow-director-atr", I40E_FLAG_FD_ATR_ENA, 0),
450	I40E_PRIV_FLAG("veb-stats", I40E_FLAG_VEB_STATS_ENA, 0),
451	I40E_PRIV_FLAG("hw-atr-eviction", I40E_FLAG_HW_ATR_EVICT_ENA, 0),
452	I40E_PRIV_FLAG("link-down-on-close",
453	I40E_FLAG_LINK_DOWN_ON_CLOSE_ENA, 0),
454	I40E_PRIV_FLAG("legacy-rx", I40E_FLAG_LEGACY_RX_ENA, 0),
455	I40E_PRIV_FLAG("disable-source-pruning",
456	I40E_FLAG_SOURCE_PRUNING_DIS, 0),
457	I40E_PRIV_FLAG("disable-fw-lldp", I40E_FLAG_FW_LLDP_DIS, 0),
458	I40E_PRIV_FLAG("rs-fec", I40E_FLAG_RS_FEC, 0),
459	I40E_PRIV_FLAG("base-r-fec", I40E_FLAG_BASE_R_FEC, 0),
460	I40E_PRIV_FLAG("vf-vlan-pruning",
461	I40E_FLAG_VF_VLAN_PRUNING_ENA, 0),
462	};
463
464	#define I40E_PRIV_FLAGS_STR_LEN ARRAY_SIZE(i40e_gstrings_priv_flags)
465
466	/* Private flags with a global effect, restricted to PF 0 */
467	static const struct i40e_priv_flags i40e_gl_gstrings_priv_flags[] = {
468	I40E_PRIV_FLAG("vf-true-promisc-support",
469	I40E_FLAG_TRUE_PROMISC_ENA, 0),
470	};
471
472	#define I40E_GL_PRIV_FLAGS_STR_LEN ARRAY_SIZE(i40e_gl_gstrings_priv_flags)
473
474	/**
475	* i40e_partition_setting_complaint - generic complaint for MFP restriction
476	* @pf: the PF struct
477	**/
478	static void i40e_partition_setting_complaint(struct i40e_pf *pf)
479	{
480	dev_info(&pf->pdev->dev,
481	"The link settings are allowed to be changed only from the first partition of a given port. Please switch to the first partition in order to change the setting.\n");
482	}
483
484	/**
485	* i40e_phy_type_to_ethtool - convert the phy_types to ethtool link modes
486	* @pf: PF struct with phy_types
487	* @ks: ethtool link ksettings struct to fill out
488	*
489	**/
490	static void i40e_phy_type_to_ethtool(struct i40e_pf *pf,
491	struct ethtool_link_ksettings *ks)
492	{
493	struct i40e_link_status *hw_link_info = &pf->hw.phy.link_info;
494	u64 phy_types = pf->hw.phy.phy_types;
495
496	ethtool_link_ksettings_zero_link_mode(ks, supported);
497	ethtool_link_ksettings_zero_link_mode(ks, advertising);
498
499	if (phy_types & I40E_CAP_PHY_TYPE_SGMII) {
500	ethtool_link_ksettings_add_link_mode(ks, supported,
501	1000baseT_Full);
502	if (hw_link_info->requested_speeds & I40E_LINK_SPEED_1GB)
503	ethtool_link_ksettings_add_link_mode(ks, advertising,
504	1000baseT_Full);
505	if (test_bit(I40E_HW_CAP_100M_SGMII, pf->hw.caps)) {
506	ethtool_link_ksettings_add_link_mode(ks, supported,
507	100baseT_Full);
508	ethtool_link_ksettings_add_link_mode(ks, advertising,
509	100baseT_Full);
510	}
511	}
512	if (phy_types & I40E_CAP_PHY_TYPE_XAUI ||
513	phy_types & I40E_CAP_PHY_TYPE_XFI ||
514	phy_types & I40E_CAP_PHY_TYPE_SFI ||
515	phy_types & I40E_CAP_PHY_TYPE_10GBASE_SFPP_CU ||
516	phy_types & I40E_CAP_PHY_TYPE_10GBASE_AOC) {
517	ethtool_link_ksettings_add_link_mode(ks, supported,
518	10000baseT_Full);
519	if (hw_link_info->requested_speeds & I40E_LINK_SPEED_10GB)
520	ethtool_link_ksettings_add_link_mode(ks, advertising,
521	10000baseT_Full);
522	}
523	if (phy_types & I40E_CAP_PHY_TYPE_10GBASE_T) {
524	ethtool_link_ksettings_add_link_mode(ks, supported,
525	10000baseT_Full);
526	if (hw_link_info->requested_speeds & I40E_LINK_SPEED_10GB)
527	ethtool_link_ksettings_add_link_mode(ks, advertising,
528	10000baseT_Full);
529	}
530	if (phy_types & I40E_CAP_PHY_TYPE_2_5GBASE_T) {
531	ethtool_link_ksettings_add_link_mode(ks, supported,
532	2500baseT_Full);
533	if (hw_link_info->requested_speeds & I40E_LINK_SPEED_2_5GB)
534	ethtool_link_ksettings_add_link_mode(ks, advertising,
535	2500baseT_Full);
536	}
537	if (phy_types & I40E_CAP_PHY_TYPE_5GBASE_T) {
538	ethtool_link_ksettings_add_link_mode(ks, supported,
539	5000baseT_Full);
540	if (hw_link_info->requested_speeds & I40E_LINK_SPEED_5GB)
541	ethtool_link_ksettings_add_link_mode(ks, advertising,
542	5000baseT_Full);
543	}
544	if (phy_types & I40E_CAP_PHY_TYPE_XLAUI ||
545	phy_types & I40E_CAP_PHY_TYPE_XLPPI ||
546	phy_types & I40E_CAP_PHY_TYPE_40GBASE_AOC)
547	ethtool_link_ksettings_add_link_mode(ks, supported,
548	40000baseCR4_Full);
549	if (phy_types & I40E_CAP_PHY_TYPE_40GBASE_CR4_CU ||
550	phy_types & I40E_CAP_PHY_TYPE_40GBASE_CR4) {
551	ethtool_link_ksettings_add_link_mode(ks, supported,
552	40000baseCR4_Full);
553	if (hw_link_info->requested_speeds & I40E_LINK_SPEED_40GB)
554	ethtool_link_ksettings_add_link_mode(ks, advertising,
555	40000baseCR4_Full);
556	}
557	if (phy_types & I40E_CAP_PHY_TYPE_100BASE_TX) {
558	ethtool_link_ksettings_add_link_mode(ks, supported,
559	100baseT_Full);
560	if (hw_link_info->requested_speeds & I40E_LINK_SPEED_100MB)
561	ethtool_link_ksettings_add_link_mode(ks, advertising,
562	100baseT_Full);
563	}
564	if (phy_types & I40E_CAP_PHY_TYPE_1000BASE_T) {
565	ethtool_link_ksettings_add_link_mode(ks, supported,
566	1000baseT_Full);
567	if (hw_link_info->requested_speeds & I40E_LINK_SPEED_1GB)
568	ethtool_link_ksettings_add_link_mode(ks, advertising,
569	1000baseT_Full);
570	}
571	if (phy_types & I40E_CAP_PHY_TYPE_40GBASE_SR4) {
572	ethtool_link_ksettings_add_link_mode(ks, supported,
573	40000baseSR4_Full);
574	ethtool_link_ksettings_add_link_mode(ks, advertising,
575	40000baseSR4_Full);
576	}
577	if (phy_types & I40E_CAP_PHY_TYPE_40GBASE_LR4) {
578	ethtool_link_ksettings_add_link_mode(ks, supported,
579	40000baseLR4_Full);
580	ethtool_link_ksettings_add_link_mode(ks, advertising,
581	40000baseLR4_Full);
582	}
583	if (phy_types & I40E_CAP_PHY_TYPE_40GBASE_KR4) {
584	ethtool_link_ksettings_add_link_mode(ks, supported,
585	40000baseKR4_Full);
586	ethtool_link_ksettings_add_link_mode(ks, advertising,
587	40000baseKR4_Full);
588	}
589	if (phy_types & I40E_CAP_PHY_TYPE_20GBASE_KR2) {
590	ethtool_link_ksettings_add_link_mode(ks, supported,
591	20000baseKR2_Full);
592	if (hw_link_info->requested_speeds & I40E_LINK_SPEED_20GB)
593	ethtool_link_ksettings_add_link_mode(ks, advertising,
594	20000baseKR2_Full);
595	}
596	if (phy_types & I40E_CAP_PHY_TYPE_10GBASE_KX4) {
597	ethtool_link_ksettings_add_link_mode(ks, supported,
598	10000baseKX4_Full);
599	if (hw_link_info->requested_speeds & I40E_LINK_SPEED_10GB)
600	ethtool_link_ksettings_add_link_mode(ks, advertising,
601	10000baseKX4_Full);
602	}
603	if (phy_types & I40E_CAP_PHY_TYPE_10GBASE_KR &&
604	!test_bit(I40E_HW_CAP_CRT_RETIMER, pf->hw.caps)) {
605	ethtool_link_ksettings_add_link_mode(ks, supported,
606	10000baseKR_Full);
607	if (hw_link_info->requested_speeds & I40E_LINK_SPEED_10GB)
608	ethtool_link_ksettings_add_link_mode(ks, advertising,
609	10000baseKR_Full);
610	}
611	if (phy_types & I40E_CAP_PHY_TYPE_1000BASE_KX &&
612	!test_bit(I40E_HW_CAP_CRT_RETIMER, pf->hw.caps)) {
613	ethtool_link_ksettings_add_link_mode(ks, supported,
614	1000baseKX_Full);
615	if (hw_link_info->requested_speeds & I40E_LINK_SPEED_1GB)
616	ethtool_link_ksettings_add_link_mode(ks, advertising,
617	1000baseKX_Full);
618	}
619	/* need to add 25G PHY types */
620	if (phy_types & I40E_CAP_PHY_TYPE_25GBASE_KR) {
621	ethtool_link_ksettings_add_link_mode(ks, supported,
622	25000baseKR_Full);
623	if (hw_link_info->requested_speeds & I40E_LINK_SPEED_25GB)
624	ethtool_link_ksettings_add_link_mode(ks, advertising,
625	25000baseKR_Full);
626	}
627	if (phy_types & I40E_CAP_PHY_TYPE_25GBASE_CR) {
628	ethtool_link_ksettings_add_link_mode(ks, supported,
629	25000baseCR_Full);
630	if (hw_link_info->requested_speeds & I40E_LINK_SPEED_25GB)
631	ethtool_link_ksettings_add_link_mode(ks, advertising,
632	25000baseCR_Full);
633	}
634	if (phy_types & I40E_CAP_PHY_TYPE_25GBASE_SR ||
635	phy_types & I40E_CAP_PHY_TYPE_25GBASE_LR) {
636	ethtool_link_ksettings_add_link_mode(ks, supported,
637	25000baseSR_Full);
638	if (hw_link_info->requested_speeds & I40E_LINK_SPEED_25GB)
639	ethtool_link_ksettings_add_link_mode(ks, advertising,
640	25000baseSR_Full);
641	}
642	if (phy_types & I40E_CAP_PHY_TYPE_25GBASE_AOC ||
643	phy_types & I40E_CAP_PHY_TYPE_25GBASE_ACC) {
644	ethtool_link_ksettings_add_link_mode(ks, supported,
645	25000baseCR_Full);
646	if (hw_link_info->requested_speeds & I40E_LINK_SPEED_25GB)
647	ethtool_link_ksettings_add_link_mode(ks, advertising,
648	25000baseCR_Full);
649	}
650	if (phy_types & I40E_CAP_PHY_TYPE_25GBASE_KR ||
651	phy_types & I40E_CAP_PHY_TYPE_25GBASE_CR ||
652	phy_types & I40E_CAP_PHY_TYPE_25GBASE_SR ||
653	phy_types & I40E_CAP_PHY_TYPE_25GBASE_LR ||
654	phy_types & I40E_CAP_PHY_TYPE_25GBASE_AOC ||
655	phy_types & I40E_CAP_PHY_TYPE_25GBASE_ACC) {
656	ethtool_link_ksettings_add_link_mode(ks, supported, FEC_NONE);
657	ethtool_link_ksettings_add_link_mode(ks, supported, FEC_RS);
658	ethtool_link_ksettings_add_link_mode(ks, supported, FEC_BASER);
659	if (hw_link_info->requested_speeds & I40E_LINK_SPEED_25GB) {
660	ethtool_link_ksettings_add_link_mode(ks, advertising,
661	FEC_NONE);
662	ethtool_link_ksettings_add_link_mode(ks, advertising,
663	FEC_RS);
664	ethtool_link_ksettings_add_link_mode(ks, advertising,
665	FEC_BASER);
666	}
667	}
668	/* need to add new 10G PHY types */
669	if (phy_types & I40E_CAP_PHY_TYPE_10GBASE_CR1 ||
670	phy_types & I40E_CAP_PHY_TYPE_10GBASE_CR1_CU) {
671	ethtool_link_ksettings_add_link_mode(ks, supported,
672	10000baseCR_Full);
673	if (hw_link_info->requested_speeds & I40E_LINK_SPEED_10GB)
674	ethtool_link_ksettings_add_link_mode(ks, advertising,
675	10000baseCR_Full);
676	}
677	if (phy_types & I40E_CAP_PHY_TYPE_10GBASE_SR) {
678	ethtool_link_ksettings_add_link_mode(ks, supported,
679	10000baseSR_Full);
680	if (hw_link_info->requested_speeds & I40E_LINK_SPEED_10GB)
681	ethtool_link_ksettings_add_link_mode(ks, advertising,
682	10000baseSR_Full);
683	}
684	if (phy_types & I40E_CAP_PHY_TYPE_10GBASE_LR) {
685	ethtool_link_ksettings_add_link_mode(ks, supported,
686	10000baseLR_Full);
687	if (hw_link_info->requested_speeds & I40E_LINK_SPEED_10GB)
688	ethtool_link_ksettings_add_link_mode(ks, advertising,
689	10000baseLR_Full);
690	}
691	if (phy_types & I40E_CAP_PHY_TYPE_1000BASE_SX ||
692	phy_types & I40E_CAP_PHY_TYPE_1000BASE_LX ||
693	phy_types & I40E_CAP_PHY_TYPE_1000BASE_T_OPTICAL) {
694	ethtool_link_ksettings_add_link_mode(ks, supported,
695	1000baseX_Full);
696	if (hw_link_info->requested_speeds & I40E_LINK_SPEED_1GB)
697	ethtool_link_ksettings_add_link_mode(ks, advertising,
698	1000baseX_Full);
699	}
700	/* Autoneg PHY types */
701	if (phy_types & I40E_CAP_PHY_TYPE_SGMII ||
702	phy_types & I40E_CAP_PHY_TYPE_40GBASE_KR4 ||
703	phy_types & I40E_CAP_PHY_TYPE_40GBASE_CR4_CU ||
704	phy_types & I40E_CAP_PHY_TYPE_40GBASE_CR4 ||
705	phy_types & I40E_CAP_PHY_TYPE_25GBASE_SR ||
706	phy_types & I40E_CAP_PHY_TYPE_25GBASE_LR ||
707	phy_types & I40E_CAP_PHY_TYPE_25GBASE_KR ||
708	phy_types & I40E_CAP_PHY_TYPE_25GBASE_CR ||
709	phy_types & I40E_CAP_PHY_TYPE_20GBASE_KR2 ||
710	phy_types & I40E_CAP_PHY_TYPE_10GBASE_SR ||
711	phy_types & I40E_CAP_PHY_TYPE_10GBASE_LR ||
712	phy_types & I40E_CAP_PHY_TYPE_10GBASE_KX4 ||
713	phy_types & I40E_CAP_PHY_TYPE_10GBASE_KR ||
714	phy_types & I40E_CAP_PHY_TYPE_10GBASE_CR1_CU ||
715	phy_types & I40E_CAP_PHY_TYPE_10GBASE_CR1 ||
716	phy_types & I40E_CAP_PHY_TYPE_10GBASE_T ||
717	phy_types & I40E_CAP_PHY_TYPE_5GBASE_T ||
718	phy_types & I40E_CAP_PHY_TYPE_2_5GBASE_T ||
719	phy_types & I40E_CAP_PHY_TYPE_1000BASE_T_OPTICAL ||
720	phy_types & I40E_CAP_PHY_TYPE_1000BASE_T ||
721	phy_types & I40E_CAP_PHY_TYPE_1000BASE_SX ||
722	phy_types & I40E_CAP_PHY_TYPE_1000BASE_LX ||
723	phy_types & I40E_CAP_PHY_TYPE_1000BASE_KX ||
724	phy_types & I40E_CAP_PHY_TYPE_100BASE_TX) {
725	ethtool_link_ksettings_add_link_mode(ks, supported,
726	Autoneg);
727	ethtool_link_ksettings_add_link_mode(ks, advertising,
728	Autoneg);
729	}
730	}
731
732	/**
733	* i40e_get_settings_link_up_fec - Get the FEC mode encoding from mask
734	* @req_fec_info: mask request FEC info
735	* @ks: ethtool ksettings to fill in
736	**/
737	static void i40e_get_settings_link_up_fec(u8 req_fec_info,
738	struct ethtool_link_ksettings *ks)
739	{
740	ethtool_link_ksettings_add_link_mode(ks, supported, FEC_NONE);
741	ethtool_link_ksettings_add_link_mode(ks, supported, FEC_RS);
742	ethtool_link_ksettings_add_link_mode(ks, supported, FEC_BASER);
743
744	if ((I40E_AQ_SET_FEC_REQUEST_RS & req_fec_info) &&
745	(I40E_AQ_SET_FEC_REQUEST_KR & req_fec_info)) {
746	ethtool_link_ksettings_add_link_mode(ks, advertising,
747	FEC_NONE);
748	ethtool_link_ksettings_add_link_mode(ks, advertising,
749	FEC_BASER);
750	ethtool_link_ksettings_add_link_mode(ks, advertising, FEC_RS);
751	} else if (I40E_AQ_SET_FEC_REQUEST_RS & req_fec_info) {
752	ethtool_link_ksettings_add_link_mode(ks, advertising, FEC_RS);
753	} else if (I40E_AQ_SET_FEC_REQUEST_KR & req_fec_info) {
754	ethtool_link_ksettings_add_link_mode(ks, advertising,
755	FEC_BASER);
756	} else {
757	ethtool_link_ksettings_add_link_mode(ks, advertising,
758	FEC_NONE);
759	}
760	}
761
762	/**
763	* i40e_get_settings_link_up - Get the Link settings for when link is up
764	* @hw: hw structure
765	* @ks: ethtool ksettings to fill in
766	* @netdev: network interface device structure
767	* @pf: pointer to physical function struct
768	**/
769	static void i40e_get_settings_link_up(struct i40e_hw *hw,
770	struct ethtool_link_ksettings *ks,
771	struct net_device *netdev,
772	struct i40e_pf *pf)
773	{
774	struct i40e_link_status *hw_link_info = &hw->phy.link_info;
775	struct ethtool_link_ksettings cap_ksettings;
776	u32 link_speed = hw_link_info->link_speed;
777
778	/* Initialize supported and advertised settings based on phy settings */
779	switch (hw_link_info->phy_type) {
780	case I40E_PHY_TYPE_40GBASE_CR4:
781	case I40E_PHY_TYPE_40GBASE_CR4_CU:
782	ethtool_link_ksettings_add_link_mode(ks, supported, Autoneg);
783	ethtool_link_ksettings_add_link_mode(ks, supported,
784	40000baseCR4_Full);
785	ethtool_link_ksettings_add_link_mode(ks, advertising, Autoneg);
786	ethtool_link_ksettings_add_link_mode(ks, advertising,
787	40000baseCR4_Full);
788	break;
789	case I40E_PHY_TYPE_XLAUI:
790	case I40E_PHY_TYPE_XLPPI:
791	case I40E_PHY_TYPE_40GBASE_AOC:
792	ethtool_link_ksettings_add_link_mode(ks, supported,
793	40000baseCR4_Full);
794	ethtool_link_ksettings_add_link_mode(ks, advertising,
795	40000baseCR4_Full);
796	break;
797	case I40E_PHY_TYPE_40GBASE_SR4:
798	ethtool_link_ksettings_add_link_mode(ks, supported,
799	40000baseSR4_Full);
800	ethtool_link_ksettings_add_link_mode(ks, advertising,
801	40000baseSR4_Full);
802	break;
803	case I40E_PHY_TYPE_40GBASE_LR4:
804	ethtool_link_ksettings_add_link_mode(ks, supported,
805	40000baseLR4_Full);
806	ethtool_link_ksettings_add_link_mode(ks, advertising,
807	40000baseLR4_Full);
808	break;
809	case I40E_PHY_TYPE_25GBASE_SR:
810	case I40E_PHY_TYPE_25GBASE_LR:
811	case I40E_PHY_TYPE_10GBASE_SR:
812	case I40E_PHY_TYPE_10GBASE_LR:
813	case I40E_PHY_TYPE_1000BASE_SX:
814	case I40E_PHY_TYPE_1000BASE_LX:
815	ethtool_link_ksettings_add_link_mode(ks, supported, Autoneg);
816	ethtool_link_ksettings_add_link_mode(ks, advertising, Autoneg);
817	ethtool_link_ksettings_add_link_mode(ks, supported,
818	25000baseSR_Full);
819	ethtool_link_ksettings_add_link_mode(ks, advertising,
820	25000baseSR_Full);
821	i40e_get_settings_link_up_fec(req_fec_info: hw_link_info->req_fec_info, ks);
822	ethtool_link_ksettings_add_link_mode(ks, supported,
823	10000baseSR_Full);
824	ethtool_link_ksettings_add_link_mode(ks, advertising,
825	10000baseSR_Full);
826	ethtool_link_ksettings_add_link_mode(ks, supported,
827	10000baseLR_Full);
828	ethtool_link_ksettings_add_link_mode(ks, advertising,
829	10000baseLR_Full);
830	ethtool_link_ksettings_add_link_mode(ks, supported,
831	1000baseX_Full);
832	ethtool_link_ksettings_add_link_mode(ks, advertising,
833	1000baseX_Full);
834	ethtool_link_ksettings_add_link_mode(ks, supported,
835	10000baseT_Full);
836	if (hw_link_info->module_type[2] &
837	I40E_MODULE_TYPE_1000BASE_SX ||
838	hw_link_info->module_type[2] &
839	I40E_MODULE_TYPE_1000BASE_LX) {
840	ethtool_link_ksettings_add_link_mode(ks, supported,
841	1000baseT_Full);
842	if (hw_link_info->requested_speeds &
843	I40E_LINK_SPEED_1GB)
844	ethtool_link_ksettings_add_link_mode(
845	ks, advertising, 1000baseT_Full);
846	}
847	if (hw_link_info->requested_speeds & I40E_LINK_SPEED_10GB)
848	ethtool_link_ksettings_add_link_mode(ks, advertising,
849	10000baseT_Full);
850	break;
851	case I40E_PHY_TYPE_10GBASE_T:
852	case I40E_PHY_TYPE_5GBASE_T_LINK_STATUS:
853	case I40E_PHY_TYPE_2_5GBASE_T_LINK_STATUS:
854	case I40E_PHY_TYPE_1000BASE_T:
855	case I40E_PHY_TYPE_100BASE_TX:
856	ethtool_link_ksettings_add_link_mode(ks, supported, Autoneg);
857	ethtool_link_ksettings_add_link_mode(ks, supported,
858	10000baseT_Full);
859	ethtool_link_ksettings_add_link_mode(ks, supported,
860	5000baseT_Full);
861	ethtool_link_ksettings_add_link_mode(ks, supported,
862	2500baseT_Full);
863	ethtool_link_ksettings_add_link_mode(ks, supported,
864	1000baseT_Full);
865	ethtool_link_ksettings_add_link_mode(ks, supported,
866	100baseT_Full);
867	ethtool_link_ksettings_add_link_mode(ks, advertising, Autoneg);
868	if (hw_link_info->requested_speeds & I40E_LINK_SPEED_10GB)
869	ethtool_link_ksettings_add_link_mode(ks, advertising,
870	10000baseT_Full);
871	if (hw_link_info->requested_speeds & I40E_LINK_SPEED_5GB)
872	ethtool_link_ksettings_add_link_mode(ks, advertising,
873	5000baseT_Full);
874	if (hw_link_info->requested_speeds & I40E_LINK_SPEED_2_5GB)
875	ethtool_link_ksettings_add_link_mode(ks, advertising,
876	2500baseT_Full);
877	if (hw_link_info->requested_speeds & I40E_LINK_SPEED_1GB)
878	ethtool_link_ksettings_add_link_mode(ks, advertising,
879	1000baseT_Full);
880	if (hw_link_info->requested_speeds & I40E_LINK_SPEED_100MB)
881	ethtool_link_ksettings_add_link_mode(ks, advertising,
882	100baseT_Full);
883	break;
884	case I40E_PHY_TYPE_1000BASE_T_OPTICAL:
885	ethtool_link_ksettings_add_link_mode(ks, supported, Autoneg);
886	ethtool_link_ksettings_add_link_mode(ks, supported,
887	1000baseT_Full);
888	ethtool_link_ksettings_add_link_mode(ks, advertising, Autoneg);
889	ethtool_link_ksettings_add_link_mode(ks, advertising,
890	1000baseT_Full);
891	break;
892	case I40E_PHY_TYPE_10GBASE_CR1_CU:
893	case I40E_PHY_TYPE_10GBASE_CR1:
894	ethtool_link_ksettings_add_link_mode(ks, supported, Autoneg);
895	ethtool_link_ksettings_add_link_mode(ks, supported,
896	10000baseT_Full);
897	ethtool_link_ksettings_add_link_mode(ks, advertising, Autoneg);
898	ethtool_link_ksettings_add_link_mode(ks, advertising,
899	10000baseT_Full);
900	break;
901	case I40E_PHY_TYPE_XAUI:
902	case I40E_PHY_TYPE_XFI:
903	case I40E_PHY_TYPE_SFI:
904	case I40E_PHY_TYPE_10GBASE_SFPP_CU:
905	case I40E_PHY_TYPE_10GBASE_AOC:
906	ethtool_link_ksettings_add_link_mode(ks, supported,
907	10000baseT_Full);
908	if (hw_link_info->requested_speeds & I40E_LINK_SPEED_10GB)
909	ethtool_link_ksettings_add_link_mode(ks, advertising,
910	10000baseT_Full);
911	i40e_get_settings_link_up_fec(req_fec_info: hw_link_info->req_fec_info, ks);
912	break;
913	case I40E_PHY_TYPE_SGMII:
914	ethtool_link_ksettings_add_link_mode(ks, supported, Autoneg);
915	ethtool_link_ksettings_add_link_mode(ks, supported,
916	1000baseT_Full);
917	if (hw_link_info->requested_speeds & I40E_LINK_SPEED_1GB)
918	ethtool_link_ksettings_add_link_mode(ks, advertising,
919	1000baseT_Full);
920	if (test_bit(I40E_HW_CAP_100M_SGMII, pf->hw.caps)) {
921	ethtool_link_ksettings_add_link_mode(ks, supported,
922	100baseT_Full);
923	if (hw_link_info->requested_speeds &
924	I40E_LINK_SPEED_100MB)
925	ethtool_link_ksettings_add_link_mode(
926	ks, advertising, 100baseT_Full);
927	}
928	break;
929	case I40E_PHY_TYPE_40GBASE_KR4:
930	case I40E_PHY_TYPE_25GBASE_KR:
931	case I40E_PHY_TYPE_20GBASE_KR2:
932	case I40E_PHY_TYPE_10GBASE_KR:
933	case I40E_PHY_TYPE_10GBASE_KX4:
934	case I40E_PHY_TYPE_1000BASE_KX:
935	ethtool_link_ksettings_add_link_mode(ks, supported,
936	40000baseKR4_Full);
937	ethtool_link_ksettings_add_link_mode(ks, supported,
938	25000baseKR_Full);
939	ethtool_link_ksettings_add_link_mode(ks, supported,
940	20000baseKR2_Full);
941	ethtool_link_ksettings_add_link_mode(ks, supported,
942	10000baseKR_Full);
943	ethtool_link_ksettings_add_link_mode(ks, supported,
944	10000baseKX4_Full);
945	ethtool_link_ksettings_add_link_mode(ks, supported,
946	1000baseKX_Full);
947	ethtool_link_ksettings_add_link_mode(ks, supported, Autoneg);
948	ethtool_link_ksettings_add_link_mode(ks, advertising,
949	40000baseKR4_Full);
950	ethtool_link_ksettings_add_link_mode(ks, advertising,
951	25000baseKR_Full);
952	i40e_get_settings_link_up_fec(req_fec_info: hw_link_info->req_fec_info, ks);
953	ethtool_link_ksettings_add_link_mode(ks, advertising,
954	20000baseKR2_Full);
955	ethtool_link_ksettings_add_link_mode(ks, advertising,
956	10000baseKR_Full);
957	ethtool_link_ksettings_add_link_mode(ks, advertising,
958	10000baseKX4_Full);
959	ethtool_link_ksettings_add_link_mode(ks, advertising,
960	1000baseKX_Full);
961	ethtool_link_ksettings_add_link_mode(ks, advertising, Autoneg);
962	break;
963	case I40E_PHY_TYPE_25GBASE_CR:
964	ethtool_link_ksettings_add_link_mode(ks, supported, Autoneg);
965	ethtool_link_ksettings_add_link_mode(ks, advertising, Autoneg);
966	ethtool_link_ksettings_add_link_mode(ks, supported,
967	25000baseCR_Full);
968	ethtool_link_ksettings_add_link_mode(ks, advertising,
969	25000baseCR_Full);
970	i40e_get_settings_link_up_fec(req_fec_info: hw_link_info->req_fec_info, ks);
971
972	break;
973	case I40E_PHY_TYPE_25GBASE_AOC:
974	case I40E_PHY_TYPE_25GBASE_ACC:
975	ethtool_link_ksettings_add_link_mode(ks, supported, Autoneg);
976	ethtool_link_ksettings_add_link_mode(ks, advertising, Autoneg);
977	ethtool_link_ksettings_add_link_mode(ks, supported,
978	25000baseCR_Full);
979	ethtool_link_ksettings_add_link_mode(ks, advertising,
980	25000baseCR_Full);
981	i40e_get_settings_link_up_fec(req_fec_info: hw_link_info->req_fec_info, ks);
982
983	ethtool_link_ksettings_add_link_mode(ks, supported,
984	10000baseCR_Full);
985	ethtool_link_ksettings_add_link_mode(ks, advertising,
986	10000baseCR_Full);
987	break;
988	default:
989	/* if we got here and link is up something bad is afoot */
990	netdev_info(dev: netdev,
991	format: "WARNING: Link is up but PHY type 0x%x is not recognized, or incorrect cable is in use\n",
992	hw_link_info->phy_type);
993	}
994
995	/* Now that we've worked out everything that could be supported by the
996	* current PHY type, get what is supported by the NVM and intersect
997	* them to get what is truly supported
998	*/
999	memset(&cap_ksettings, 0, sizeof(struct ethtool_link_ksettings));
1000	i40e_phy_type_to_ethtool(pf, ks: &cap_ksettings);
1001	ethtool_intersect_link_masks(dst: ks, src: &cap_ksettings);
1002
1003	/* Set speed and duplex */
1004	switch (link_speed) {
1005	case I40E_LINK_SPEED_40GB:
1006	ks->base.speed = SPEED_40000;
1007	break;
1008	case I40E_LINK_SPEED_25GB:
1009	ks->base.speed = SPEED_25000;
1010	break;
1011	case I40E_LINK_SPEED_20GB:
1012	ks->base.speed = SPEED_20000;
1013	break;
1014	case I40E_LINK_SPEED_10GB:
1015	ks->base.speed = SPEED_10000;
1016	break;
1017	case I40E_LINK_SPEED_5GB:
1018	ks->base.speed = SPEED_5000;
1019	break;
1020	case I40E_LINK_SPEED_2_5GB:
1021	ks->base.speed = SPEED_2500;
1022	break;
1023	case I40E_LINK_SPEED_1GB:
1024	ks->base.speed = SPEED_1000;
1025	break;
1026	case I40E_LINK_SPEED_100MB:
1027	ks->base.speed = SPEED_100;
1028	break;
1029	default:
1030	ks->base.speed = SPEED_UNKNOWN;
1031	break;
1032	}
1033	ks->base.duplex = DUPLEX_FULL;
1034	}
1035
1036	/**
1037	* i40e_get_settings_link_down - Get the Link settings for when link is down
1038	* @hw: hw structure
1039	* @ks: ethtool ksettings to fill in
1040	* @pf: pointer to physical function struct
1041	*
1042	* Reports link settings that can be determined when link is down
1043	**/
1044	static void i40e_get_settings_link_down(struct i40e_hw *hw,
1045	struct ethtool_link_ksettings *ks,
1046	struct i40e_pf *pf)
1047	{
1048	/* link is down and the driver needs to fall back on
1049	* supported phy types to figure out what info to display
1050	*/
1051	i40e_phy_type_to_ethtool(pf, ks);
1052
1053	/* With no link speed and duplex are unknown */
1054	ks->base.speed = SPEED_UNKNOWN;
1055	ks->base.duplex = DUPLEX_UNKNOWN;
1056	}
1057
1058	/**
1059	* i40e_get_link_ksettings - Get Link Speed and Duplex settings
1060	* @netdev: network interface device structure
1061	* @ks: ethtool ksettings
1062	*
1063	* Reports speed/duplex settings based on media_type
1064	**/
1065	static int i40e_get_link_ksettings(struct net_device *netdev,
1066	struct ethtool_link_ksettings *ks)
1067	{
1068	struct i40e_netdev_priv *np = netdev_priv(dev: netdev);
1069	struct i40e_pf *pf = np->vsi->back;
1070	struct i40e_hw *hw = &pf->hw;
1071	struct i40e_link_status *hw_link_info = &hw->phy.link_info;
1072	bool link_up = hw_link_info->link_info & I40E_AQ_LINK_UP;
1073
1074	ethtool_link_ksettings_zero_link_mode(ks, supported);
1075	ethtool_link_ksettings_zero_link_mode(ks, advertising);
1076
1077	if (link_up)
1078	i40e_get_settings_link_up(hw, ks, netdev, pf);
1079	else
1080	i40e_get_settings_link_down(hw, ks, pf);
1081
1082	/* Now set the settings that don't rely on link being up/down */
1083	/* Set autoneg settings */
1084	ks->base.autoneg = ((hw_link_info->an_info & I40E_AQ_AN_COMPLETED) ?
1085	AUTONEG_ENABLE : AUTONEG_DISABLE);
1086
1087	/* Set media type settings */
1088	switch (hw->phy.media_type) {
1089	case I40E_MEDIA_TYPE_BACKPLANE:
1090	ethtool_link_ksettings_add_link_mode(ks, supported, Autoneg);
1091	ethtool_link_ksettings_add_link_mode(ks, supported, Backplane);
1092	ethtool_link_ksettings_add_link_mode(ks, advertising, Autoneg);
1093	ethtool_link_ksettings_add_link_mode(ks, advertising,
1094	Backplane);
1095	ks->base.port = PORT_NONE;
1096	break;
1097	case I40E_MEDIA_TYPE_BASET:
1098	ethtool_link_ksettings_add_link_mode(ks, supported, TP);
1099	ethtool_link_ksettings_add_link_mode(ks, advertising, TP);
1100	ks->base.port = PORT_TP;
1101	break;
1102	case I40E_MEDIA_TYPE_DA:
1103	case I40E_MEDIA_TYPE_CX4:
1104	ethtool_link_ksettings_add_link_mode(ks, supported, FIBRE);
1105	ethtool_link_ksettings_add_link_mode(ks, advertising, FIBRE);
1106	ks->base.port = PORT_DA;
1107	break;
1108	case I40E_MEDIA_TYPE_FIBER:
1109	ethtool_link_ksettings_add_link_mode(ks, supported, FIBRE);
1110	ethtool_link_ksettings_add_link_mode(ks, advertising, FIBRE);
1111	ks->base.port = PORT_FIBRE;
1112	break;
1113	case I40E_MEDIA_TYPE_UNKNOWN:
1114	default:
1115	ks->base.port = PORT_OTHER;
1116	break;
1117	}
1118
1119	/* Set flow control settings */
1120	ethtool_link_ksettings_add_link_mode(ks, supported, Pause);
1121	ethtool_link_ksettings_add_link_mode(ks, supported, Asym_Pause);
1122
1123	switch (hw->fc.requested_mode) {
1124	case I40E_FC_FULL:
1125	ethtool_link_ksettings_add_link_mode(ks, advertising, Pause);
1126	break;
1127	case I40E_FC_TX_PAUSE:
1128	ethtool_link_ksettings_add_link_mode(ks, advertising,
1129	Asym_Pause);
1130	break;
1131	case I40E_FC_RX_PAUSE:
1132	ethtool_link_ksettings_add_link_mode(ks, advertising, Pause);
1133	ethtool_link_ksettings_add_link_mode(ks, advertising,
1134	Asym_Pause);
1135	break;
1136	default:
1137	ethtool_link_ksettings_del_link_mode(ks, advertising, Pause);
1138	ethtool_link_ksettings_del_link_mode(ks, advertising,
1139	Asym_Pause);
1140	break;
1141	}
1142
1143	return 0;
1144	}
1145
1146	#define I40E_LBIT_SIZE 8
1147	/**
1148	* i40e_speed_to_link_speed - Translate decimal speed to i40e_aq_link_speed
1149	* @speed: speed in decimal
1150	* @ks: ethtool ksettings
1151	*
1152	* Return i40e_aq_link_speed based on speed
1153	**/
1154	static enum i40e_aq_link_speed
1155	i40e_speed_to_link_speed(__u32 speed, const struct ethtool_link_ksettings *ks)
1156	{
1157	enum i40e_aq_link_speed link_speed = I40E_LINK_SPEED_UNKNOWN;
1158	bool speed_changed = false;
1159	int i, j;
1160
1161	static const struct {
1162	__u32 speed;
1163	enum i40e_aq_link_speed link_speed;
1164	__u8 bit[I40E_LBIT_SIZE];
1165	} i40e_speed_lut[] = {
1166	#define I40E_LBIT(mode) ETHTOOL_LINK_MODE_ ## mode ##_Full_BIT
1167	{SPEED_100, I40E_LINK_SPEED_100MB, {I40E_LBIT(100baseT)} },
1168	{SPEED_1000, I40E_LINK_SPEED_1GB,
1169	{I40E_LBIT(1000baseT), I40E_LBIT(1000baseX),
1170	I40E_LBIT(1000baseKX)} },
1171	{SPEED_10000, I40E_LINK_SPEED_10GB,
1172	{I40E_LBIT(10000baseT), I40E_LBIT(10000baseKR),
1173	I40E_LBIT(10000baseLR), I40E_LBIT(10000baseCR),
1174	I40E_LBIT(10000baseSR), I40E_LBIT(10000baseKX4)} },
1175
1176	{SPEED_25000, I40E_LINK_SPEED_25GB,
1177	{I40E_LBIT(25000baseCR), I40E_LBIT(25000baseKR),
1178	I40E_LBIT(25000baseSR)} },
1179	{SPEED_40000, I40E_LINK_SPEED_40GB,
1180	{I40E_LBIT(40000baseKR4), I40E_LBIT(40000baseCR4),
1181	I40E_LBIT(40000baseSR4), I40E_LBIT(40000baseLR4)} },
1182	{SPEED_20000, I40E_LINK_SPEED_20GB,
1183	{I40E_LBIT(20000baseKR2)} },
1184	{SPEED_2500, I40E_LINK_SPEED_2_5GB, {I40E_LBIT(2500baseT)} },
1185	{SPEED_5000, I40E_LINK_SPEED_5GB, {I40E_LBIT(2500baseT)} }
1186	#undef I40E_LBIT
1187	};
1188
1189	for (i = 0; i < ARRAY_SIZE(i40e_speed_lut); i++) {
1190	if (i40e_speed_lut[i].speed == speed) {
1191	for (j = 0; j < I40E_LBIT_SIZE; j++) {
1192	if (test_bit(i40e_speed_lut[i].bit[j],
1193	ks->link_modes.supported)) {
1194	speed_changed = true;
1195	break;
1196	}
1197	if (!i40e_speed_lut[i].bit[j])
1198	break;
1199	}
1200	if (speed_changed) {
1201	link_speed = i40e_speed_lut[i].link_speed;
1202	break;
1203	}
1204	}
1205	}
1206	return link_speed;
1207	}
1208
1209	#undef I40E_LBIT_SIZE
1210
1211	/**
1212	* i40e_set_link_ksettings - Set Speed and Duplex
1213	* @netdev: network interface device structure
1214	* @ks: ethtool ksettings
1215	*
1216	* Set speed/duplex per media_types advertised/forced
1217	**/
1218	static int i40e_set_link_ksettings(struct net_device *netdev,
1219	const struct ethtool_link_ksettings *ks)
1220	{
1221	struct i40e_netdev_priv *np = netdev_priv(dev: netdev);
1222	struct i40e_aq_get_phy_abilities_resp abilities;
1223	struct ethtool_link_ksettings safe_ks;
1224	struct ethtool_link_ksettings copy_ks;
1225	struct i40e_aq_set_phy_config config;
1226	struct i40e_pf *pf = np->vsi->back;
1227	enum i40e_aq_link_speed link_speed;
1228	struct i40e_vsi *vsi = np->vsi;
1229	struct i40e_hw *hw = &pf->hw;
1230	bool autoneg_changed = false;
1231	int timeout = 50;
1232	int status = 0;
1233	int err = 0;
1234	__u32 speed;
1235	u8 autoneg;
1236
1237	/* Changing port settings is not supported if this isn't the
1238	* port's controlling PF
1239	*/
1240	if (hw->partition_id != 1) {
1241	i40e_partition_setting_complaint(pf);
1242	return -EOPNOTSUPP;
1243	}
1244	if (vsi != pf->vsi[pf->lan_vsi])
1245	return -EOPNOTSUPP;
1246	if (hw->phy.media_type != I40E_MEDIA_TYPE_BASET &&
1247	hw->phy.media_type != I40E_MEDIA_TYPE_FIBER &&
1248	hw->phy.media_type != I40E_MEDIA_TYPE_BACKPLANE &&
1249	hw->phy.media_type != I40E_MEDIA_TYPE_DA &&
1250	hw->phy.link_info.link_info & I40E_AQ_LINK_UP)
1251	return -EOPNOTSUPP;
1252	if (hw->device_id == I40E_DEV_ID_KX_B ||
1253	hw->device_id == I40E_DEV_ID_KX_C ||
1254	hw->device_id == I40E_DEV_ID_20G_KR2 ||
1255	hw->device_id == I40E_DEV_ID_20G_KR2_A ||
1256	hw->device_id == I40E_DEV_ID_25G_B ||
1257	hw->device_id == I40E_DEV_ID_KX_X722) {
1258	netdev_info(dev: netdev, format: "Changing settings is not supported on backplane.\n");
1259	return -EOPNOTSUPP;
1260	}
1261
1262	/* copy the ksettings to copy_ks to avoid modifying the origin */
1263	memcpy(&copy_ks, ks, sizeof(struct ethtool_link_ksettings));
1264
1265	/* save autoneg out of ksettings */
1266	autoneg = copy_ks.base.autoneg;
1267	speed = copy_ks.base.speed;
1268
1269	/* get our own copy of the bits to check against */
1270	memset(&safe_ks, 0, sizeof(struct ethtool_link_ksettings));
1271	safe_ks.base.cmd = copy_ks.base.cmd;
1272	safe_ks.base.link_mode_masks_nwords =
1273	copy_ks.base.link_mode_masks_nwords;
1274	i40e_get_link_ksettings(netdev, ks: &safe_ks);
1275
1276	/* Get link modes supported by hardware and check against modes
1277	* requested by the user. Return an error if unsupported mode was set.
1278	*/
1279	if (!bitmap_subset(src1: copy_ks.link_modes.advertising,
1280	src2: safe_ks.link_modes.supported,
1281	nbits: __ETHTOOL_LINK_MODE_MASK_NBITS))
1282	return -EINVAL;
1283
1284	/* set autoneg back to what it currently is */
1285	copy_ks.base.autoneg = safe_ks.base.autoneg;
1286	copy_ks.base.speed = safe_ks.base.speed;
1287
1288	/* If copy_ks.base and safe_ks.base are not the same now, then they are
1289	* trying to set something that we do not support.
1290	*/
1291	if (memcmp(p: &copy_ks.base, q: &safe_ks.base,
1292	size: sizeof(struct ethtool_link_settings))) {
1293	netdev_err(dev: netdev, format: "Only speed and autoneg are supported.\n");
1294	return -EOPNOTSUPP;
1295	}
1296
1297	while (test_and_set_bit(nr: __I40E_CONFIG_BUSY, addr: pf->state)) {
1298	timeout--;
1299	if (!timeout)
1300	return -EBUSY;
1301	usleep_range(min: 1000, max: 2000);
1302	}
1303
1304	/* Get the current phy config */
1305	status = i40e_aq_get_phy_capabilities(hw, qualified_modules: false, report_init: false, abilities: &abilities,
1306	NULL);
1307	if (status) {
1308	err = -EAGAIN;
1309	goto done;
1310	}
1311
1312	/* Copy abilities to config in case autoneg is not
1313	* set below
1314	*/
1315	memset(&config, 0, sizeof(struct i40e_aq_set_phy_config));
1316	config.abilities = abilities.abilities;
1317
1318	/* Check autoneg */
1319	if (autoneg == AUTONEG_ENABLE) {
1320	/* If autoneg was not already enabled */
1321	if (!(hw->phy.link_info.an_info & I40E_AQ_AN_COMPLETED)) {
1322	/* If autoneg is not supported, return error */
1323	if (!ethtool_link_ksettings_test_link_mode(&safe_ks,
1324	supported,
1325	Autoneg)) {
1326	netdev_info(dev: netdev, format: "Autoneg not supported on this phy\n");
1327	err = -EINVAL;
1328	goto done;
1329	}
1330	/* Autoneg is allowed to change */
1331	config.abilities = abilities.abilities |
1332	I40E_AQ_PHY_ENABLE_AN;
1333	autoneg_changed = true;
1334	}
1335	} else {
1336	/* If autoneg is currently enabled */
1337	if (hw->phy.link_info.an_info & I40E_AQ_AN_COMPLETED) {
1338	/* If autoneg is supported 10GBASE_T is the only PHY
1339	* that can disable it, so otherwise return error
1340	*/
1341	if (ethtool_link_ksettings_test_link_mode(&safe_ks,
1342	supported,
1343	Autoneg) &&
1344	hw->phy.media_type != I40E_MEDIA_TYPE_BASET) {
1345	netdev_info(dev: netdev, format: "Autoneg cannot be disabled on this phy\n");
1346	err = -EINVAL;
1347	goto done;
1348	}
1349	/* Autoneg is allowed to change */
1350	config.abilities = abilities.abilities &
1351	~I40E_AQ_PHY_ENABLE_AN;
1352	autoneg_changed = true;
1353	}
1354	}
1355
1356	if (ethtool_link_ksettings_test_link_mode(ks, advertising,
1357	100baseT_Full))
1358	config.link_speed |= I40E_LINK_SPEED_100MB;
1359	if (ethtool_link_ksettings_test_link_mode(ks, advertising,
1360	1000baseT_Full) ||
1361	ethtool_link_ksettings_test_link_mode(ks, advertising,
1362	1000baseX_Full) ||
1363	ethtool_link_ksettings_test_link_mode(ks, advertising,
1364	1000baseKX_Full))
1365	config.link_speed |= I40E_LINK_SPEED_1GB;
1366	if (ethtool_link_ksettings_test_link_mode(ks, advertising,
1367	10000baseT_Full) ||
1368	ethtool_link_ksettings_test_link_mode(ks, advertising,
1369	10000baseKX4_Full) ||
1370	ethtool_link_ksettings_test_link_mode(ks, advertising,
1371	10000baseKR_Full) ||
1372	ethtool_link_ksettings_test_link_mode(ks, advertising,
1373	10000baseCR_Full) ||
1374	ethtool_link_ksettings_test_link_mode(ks, advertising,
1375	10000baseSR_Full) ||
1376	ethtool_link_ksettings_test_link_mode(ks, advertising,
1377	10000baseLR_Full))
1378	config.link_speed |= I40E_LINK_SPEED_10GB;
1379	if (ethtool_link_ksettings_test_link_mode(ks, advertising,
1380	2500baseT_Full))
1381	config.link_speed |= I40E_LINK_SPEED_2_5GB;
1382	if (ethtool_link_ksettings_test_link_mode(ks, advertising,
1383	5000baseT_Full))
1384	config.link_speed |= I40E_LINK_SPEED_5GB;
1385	if (ethtool_link_ksettings_test_link_mode(ks, advertising,
1386	20000baseKR2_Full))
1387	config.link_speed |= I40E_LINK_SPEED_20GB;
1388	if (ethtool_link_ksettings_test_link_mode(ks, advertising,
1389	25000baseCR_Full) ||
1390	ethtool_link_ksettings_test_link_mode(ks, advertising,
1391	25000baseKR_Full) ||
1392	ethtool_link_ksettings_test_link_mode(ks, advertising,
1393	25000baseSR_Full))
1394	config.link_speed |= I40E_LINK_SPEED_25GB;
1395	if (ethtool_link_ksettings_test_link_mode(ks, advertising,
1396	40000baseKR4_Full) ||
1397	ethtool_link_ksettings_test_link_mode(ks, advertising,
1398	40000baseCR4_Full) ||
1399	ethtool_link_ksettings_test_link_mode(ks, advertising,
1400	40000baseSR4_Full) ||
1401	ethtool_link_ksettings_test_link_mode(ks, advertising,
1402	40000baseLR4_Full))
1403	config.link_speed |= I40E_LINK_SPEED_40GB;
1404
1405	/* Autonegotiation must be disabled to change speed */
1406	if ((speed != SPEED_UNKNOWN && safe_ks.base.speed != speed) &&
1407	(autoneg == AUTONEG_DISABLE ||
1408	(safe_ks.base.autoneg == AUTONEG_DISABLE && !autoneg_changed))) {
1409	link_speed = i40e_speed_to_link_speed(speed, ks);
1410	if (link_speed == I40E_LINK_SPEED_UNKNOWN) {
1411	netdev_info(dev: netdev, format: "Given speed is not supported\n");
1412	err = -EOPNOTSUPP;
1413	goto done;
1414	} else {
1415	config.link_speed = link_speed;
1416	}
1417	} else {
1418	if (safe_ks.base.speed != speed) {
1419	netdev_info(dev: netdev,
1420	format: "Unable to set speed, disable autoneg\n");
1421	err = -EOPNOTSUPP;
1422	goto done;
1423	}
1424	}
1425
1426	/* If speed didn't get set, set it to what it currently is.
1427	* This is needed because if advertise is 0 (as it is when autoneg
1428	* is disabled) then speed won't get set.
1429	*/
1430	if (!config.link_speed)
1431	config.link_speed = abilities.link_speed;
1432	if (autoneg_changed || abilities.link_speed != config.link_speed) {
1433	/* copy over the rest of the abilities */
1434	config.phy_type = abilities.phy_type;
1435	config.phy_type_ext = abilities.phy_type_ext;
1436	config.eee_capability = abilities.eee_capability;
1437	config.eeer = abilities.eeer_val;
1438	config.low_power_ctrl = abilities.d3_lpan;
1439	config.fec_config = abilities.fec_cfg_curr_mod_ext_info &
1440	I40E_AQ_PHY_FEC_CONFIG_MASK;
1441
1442	/* save the requested speeds */
1443	hw->phy.link_info.requested_speeds = config.link_speed;
1444	/* set link and auto negotiation so changes take effect */
1445	config.abilities |= I40E_AQ_PHY_ENABLE_ATOMIC_LINK;
1446	/* If link is up put link down */
1447	if (hw->phy.link_info.link_info & I40E_AQ_LINK_UP) {
1448	/* Tell the OS link is going down, the link will go
1449	* back up when fw says it is ready asynchronously
1450	*/
1451	i40e_print_link_message(vsi, isup: false);
1452	netif_carrier_off(dev: netdev);
1453	netif_tx_stop_all_queues(dev: netdev);
1454	}
1455
1456	/* make the aq call */
1457	status = i40e_aq_set_phy_config(hw, config: &config, NULL);
1458	if (status) {
1459	netdev_info(dev: netdev,
1460	format: "Set phy config failed, err %pe aq_err %s\n",
1461	ERR_PTR(error: status),
1462	i40e_aq_str(hw, aq_err: hw->aq.asq_last_status));
1463	err = -EAGAIN;
1464	goto done;
1465	}
1466
1467	status = i40e_update_link_info(hw);
1468	if (status)
1469	netdev_dbg(netdev,
1470	"Updating link info failed with err %pe aq_err %s\n",
1471	ERR_PTR(status),
1472	i40e_aq_str(hw, hw->aq.asq_last_status));
1473
1474	} else {
1475	netdev_info(dev: netdev, format: "Nothing changed, exiting without setting anything.\n");
1476	}
1477
1478	done:
1479	clear_bit(nr: __I40E_CONFIG_BUSY, addr: pf->state);
1480
1481	return err;
1482	}
1483
1484	static int i40e_set_fec_cfg(struct net_device *netdev, u8 fec_cfg)
1485	{
1486	struct i40e_netdev_priv *np = netdev_priv(dev: netdev);
1487	struct i40e_aq_get_phy_abilities_resp abilities;
1488	struct i40e_pf *pf = np->vsi->back;
1489	struct i40e_hw *hw = &pf->hw;
1490	int status = 0;
1491	int err = 0;
1492
1493	/* Get the current phy config */
1494	memset(&abilities, 0, sizeof(abilities));
1495	status = i40e_aq_get_phy_capabilities(hw, qualified_modules: false, report_init: false, abilities: &abilities,
1496	NULL);
1497	if (status) {
1498	err = -EAGAIN;
1499	goto done;
1500	}
1501
1502	if (abilities.fec_cfg_curr_mod_ext_info != fec_cfg) {
1503	struct i40e_aq_set_phy_config config;
1504
1505	memset(&config, 0, sizeof(config));
1506	config.phy_type = abilities.phy_type;
1507	config.abilities = abilities.abilities |
1508	I40E_AQ_PHY_ENABLE_ATOMIC_LINK;
1509	config.phy_type_ext = abilities.phy_type_ext;
1510	config.link_speed = abilities.link_speed;
1511	config.eee_capability = abilities.eee_capability;
1512	config.eeer = abilities.eeer_val;
1513	config.low_power_ctrl = abilities.d3_lpan;
1514	config.fec_config = fec_cfg & I40E_AQ_PHY_FEC_CONFIG_MASK;
1515	status = i40e_aq_set_phy_config(hw, config: &config, NULL);
1516	if (status) {
1517	netdev_info(dev: netdev,
1518	format: "Set phy config failed, err %pe aq_err %s\n",
1519	ERR_PTR(error: status),
1520	i40e_aq_str(hw, aq_err: hw->aq.asq_last_status));
1521	err = -EAGAIN;
1522	goto done;
1523	}
1524	i40e_set_fec_in_flags(fec_cfg, flags: pf->flags);
1525	status = i40e_update_link_info(hw);
1526	if (status)
1527	/* debug level message only due to relation to the link
1528	* itself rather than to the FEC settings
1529	* (e.g. no physical connection etc.)
1530	*/
1531	netdev_dbg(netdev,
1532	"Updating link info failed with err %pe aq_err %s\n",
1533	ERR_PTR(status),
1534	i40e_aq_str(hw, hw->aq.asq_last_status));
1535	}
1536
1537	done:
1538	return err;
1539	}
1540
1541	static int i40e_get_fec_param(struct net_device *netdev,
1542	struct ethtool_fecparam *fecparam)
1543	{
1544	struct i40e_netdev_priv *np = netdev_priv(dev: netdev);
1545	struct i40e_aq_get_phy_abilities_resp abilities;
1546	struct i40e_pf *pf = np->vsi->back;
1547	struct i40e_hw *hw = &pf->hw;
1548	int status = 0;
1549	int err = 0;
1550	u8 fec_cfg;
1551
1552	/* Get the current phy config */
1553	memset(&abilities, 0, sizeof(abilities));
1554	status = i40e_aq_get_phy_capabilities(hw, qualified_modules: false, report_init: false, abilities: &abilities,
1555	NULL);
1556	if (status) {
1557	err = -EAGAIN;
1558	goto done;
1559	}
1560
1561	fecparam->fec = 0;
1562	fec_cfg = abilities.fec_cfg_curr_mod_ext_info;
1563	if (fec_cfg & I40E_AQ_SET_FEC_AUTO)
1564	fecparam->fec |= ETHTOOL_FEC_AUTO;
1565	else if (fec_cfg & (I40E_AQ_SET_FEC_REQUEST_RS |
1566	I40E_AQ_SET_FEC_ABILITY_RS))
1567	fecparam->fec |= ETHTOOL_FEC_RS;
1568	else if (fec_cfg & (I40E_AQ_SET_FEC_REQUEST_KR |
1569	I40E_AQ_SET_FEC_ABILITY_KR))
1570	fecparam->fec |= ETHTOOL_FEC_BASER;
1571	if (fec_cfg == 0)
1572	fecparam->fec |= ETHTOOL_FEC_OFF;
1573
1574	if (hw->phy.link_info.fec_info & I40E_AQ_CONFIG_FEC_KR_ENA)
1575	fecparam->active_fec = ETHTOOL_FEC_BASER;
1576	else if (hw->phy.link_info.fec_info & I40E_AQ_CONFIG_FEC_RS_ENA)
1577	fecparam->active_fec = ETHTOOL_FEC_RS;
1578	else
1579	fecparam->active_fec = ETHTOOL_FEC_OFF;
1580	done:
1581	return err;
1582	}
1583
1584	static int i40e_set_fec_param(struct net_device *netdev,
1585	struct ethtool_fecparam *fecparam)
1586	{
1587	struct i40e_netdev_priv *np = netdev_priv(dev: netdev);
1588	struct i40e_pf *pf = np->vsi->back;
1589	struct i40e_hw *hw = &pf->hw;
1590	u8 fec_cfg = 0;
1591
1592	if (hw->device_id != I40E_DEV_ID_25G_SFP28 &&
1593	hw->device_id != I40E_DEV_ID_25G_B &&
1594	hw->device_id != I40E_DEV_ID_KX_X722)
1595	return -EPERM;
1596
1597	if (hw->mac.type == I40E_MAC_X722 &&
1598	!test_bit(I40E_HW_CAP_X722_FEC_REQUEST, hw->caps)) {
1599	netdev_err(dev: netdev, format: "Setting FEC encoding not supported by firmware. Please update the NVM image.\n");
1600	return -EOPNOTSUPP;
1601	}
1602
1603	switch (fecparam->fec) {
1604	case ETHTOOL_FEC_AUTO:
1605	fec_cfg = I40E_AQ_SET_FEC_AUTO;
1606	break;
1607	case ETHTOOL_FEC_RS:
1608	fec_cfg = (I40E_AQ_SET_FEC_REQUEST_RS |
1609	I40E_AQ_SET_FEC_ABILITY_RS);
1610	break;
1611	case ETHTOOL_FEC_BASER:
1612	fec_cfg = (I40E_AQ_SET_FEC_REQUEST_KR |
1613	I40E_AQ_SET_FEC_ABILITY_KR);
1614	break;
1615	case ETHTOOL_FEC_OFF:
1616	case ETHTOOL_FEC_NONE:
1617	fec_cfg = 0;
1618	break;
1619	default:
1620	dev_warn(&pf->pdev->dev, "Unsupported FEC mode: %d",
1621	fecparam->fec);
1622	return -EINVAL;
1623	}
1624
1625	return i40e_set_fec_cfg(netdev, fec_cfg);
1626	}
1627
1628	static int i40e_nway_reset(struct net_device *netdev)
1629	{
1630	/* restart autonegotiation */
1631	struct i40e_netdev_priv *np = netdev_priv(dev: netdev);
1632	struct i40e_pf *pf = np->vsi->back;
1633	struct i40e_hw *hw = &pf->hw;
1634	bool link_up = hw->phy.link_info.link_info & I40E_AQ_LINK_UP;
1635	int ret = 0;
1636
1637	ret = i40e_aq_set_link_restart_an(hw, enable_link: link_up, NULL);
1638	if (ret) {
1639	netdev_info(dev: netdev, format: "link restart failed, err %pe aq_err %s\n",
1640	ERR_PTR(error: ret),
1641	i40e_aq_str(hw, aq_err: hw->aq.asq_last_status));
1642	return -EIO;
1643	}
1644
1645	return 0;
1646	}
1647
1648	/**
1649	* i40e_get_pauseparam - Get Flow Control status
1650	* @netdev: netdevice structure
1651	* @pause: buffer to return pause parameters
1652	*
1653	* Return tx/rx-pause status
1654	**/
1655	static void i40e_get_pauseparam(struct net_device *netdev,
1656	struct ethtool_pauseparam *pause)
1657	{
1658	struct i40e_netdev_priv *np = netdev_priv(dev: netdev);
1659	struct i40e_pf *pf = np->vsi->back;
1660	struct i40e_hw *hw = &pf->hw;
1661	struct i40e_link_status *hw_link_info = &hw->phy.link_info;
1662	struct i40e_dcbx_config *dcbx_cfg = &hw->local_dcbx_config;
1663
1664	pause->autoneg =
1665	((hw_link_info->an_info & I40E_AQ_AN_COMPLETED) ?
1666	AUTONEG_ENABLE : AUTONEG_DISABLE);
1667
1668	/* PFC enabled so report LFC as off */
1669	if (dcbx_cfg->pfc.pfcenable) {
1670	pause->rx_pause = 0;
1671	pause->tx_pause = 0;
1672	return;
1673	}
1674
1675	if (hw->fc.current_mode == I40E_FC_RX_PAUSE) {
1676	pause->rx_pause = 1;
1677	} else if (hw->fc.current_mode == I40E_FC_TX_PAUSE) {
1678	pause->tx_pause = 1;
1679	} else if (hw->fc.current_mode == I40E_FC_FULL) {
1680	pause->rx_pause = 1;
1681	pause->tx_pause = 1;
1682	}
1683	}
1684
1685	/**
1686	* i40e_set_pauseparam - Set Flow Control parameter
1687	* @netdev: network interface device structure
1688	* @pause: return tx/rx flow control status
1689	**/
1690	static int i40e_set_pauseparam(struct net_device *netdev,
1691	struct ethtool_pauseparam *pause)
1692	{
1693	struct i40e_netdev_priv *np = netdev_priv(dev: netdev);
1694	struct i40e_pf *pf = np->vsi->back;
1695	struct i40e_vsi *vsi = np->vsi;
1696	struct i40e_hw *hw = &pf->hw;
1697	struct i40e_link_status *hw_link_info = &hw->phy.link_info;
1698	struct i40e_dcbx_config *dcbx_cfg = &hw->local_dcbx_config;
1699	bool link_up = hw_link_info->link_info & I40E_AQ_LINK_UP;
1700	u8 aq_failures;
1701	int err = 0;
1702	int status;
1703	u32 is_an;
1704
1705	/* Changing the port's flow control is not supported if this isn't the
1706	* port's controlling PF
1707	*/
1708	if (hw->partition_id != 1) {
1709	i40e_partition_setting_complaint(pf);
1710	return -EOPNOTSUPP;
1711	}
1712
1713	if (vsi != pf->vsi[pf->lan_vsi])
1714	return -EOPNOTSUPP;
1715
1716	is_an = hw_link_info->an_info & I40E_AQ_AN_COMPLETED;
1717	if (pause->autoneg != is_an) {
1718	netdev_info(dev: netdev, format: "To change autoneg please use: ethtool -s <dev> autoneg <on|off>\n");
1719	return -EOPNOTSUPP;
1720	}
1721
1722	/* If we have link and don't have autoneg */
1723	if (!test_bit(__I40E_DOWN, pf->state) && !is_an) {
1724	/* Send message that it might not necessarily work*/
1725	netdev_info(dev: netdev, format: "Autoneg did not complete so changing settings may not result in an actual change.\n");
1726	}
1727
1728	if (dcbx_cfg->pfc.pfcenable) {
1729	netdev_info(dev: netdev,
1730	format: "Priority flow control enabled. Cannot set link flow control.\n");
1731	return -EOPNOTSUPP;
1732	}
1733
1734	if (pause->rx_pause && pause->tx_pause)
1735	hw->fc.requested_mode = I40E_FC_FULL;
1736	else if (pause->rx_pause && !pause->tx_pause)
1737	hw->fc.requested_mode = I40E_FC_RX_PAUSE;
1738	else if (!pause->rx_pause && pause->tx_pause)
1739	hw->fc.requested_mode = I40E_FC_TX_PAUSE;
1740	else if (!pause->rx_pause && !pause->tx_pause)
1741	hw->fc.requested_mode = I40E_FC_NONE;
1742	else
1743	return -EINVAL;
1744
1745	/* Tell the OS link is going down, the link will go back up when fw
1746	* says it is ready asynchronously
1747	*/
1748	i40e_print_link_message(vsi, isup: false);
1749	netif_carrier_off(dev: netdev);
1750	netif_tx_stop_all_queues(dev: netdev);
1751
1752	/* Set the fc mode and only restart an if link is up*/
1753	status = i40e_set_fc(hw, aq_failures: &aq_failures, atomic_reset: link_up);
1754
1755	if (aq_failures & I40E_SET_FC_AQ_FAIL_GET) {
1756	netdev_info(dev: netdev, format: "Set fc failed on the get_phy_capabilities call with err %pe aq_err %s\n",
1757	ERR_PTR(error: status),
1758	i40e_aq_str(hw, aq_err: hw->aq.asq_last_status));
1759	err = -EAGAIN;
1760	}
1761	if (aq_failures & I40E_SET_FC_AQ_FAIL_SET) {
1762	netdev_info(dev: netdev, format: "Set fc failed on the set_phy_config call with err %pe aq_err %s\n",
1763	ERR_PTR(error: status),
1764	i40e_aq_str(hw, aq_err: hw->aq.asq_last_status));
1765	err = -EAGAIN;
1766	}
1767	if (aq_failures & I40E_SET_FC_AQ_FAIL_UPDATE) {
1768	netdev_info(dev: netdev, format: "Set fc failed on the get_link_info call with err %pe aq_err %s\n",
1769	ERR_PTR(error: status),
1770	i40e_aq_str(hw, aq_err: hw->aq.asq_last_status));
1771	err = -EAGAIN;
1772	}
1773
1774	if (!test_bit(__I40E_DOWN, pf->state) && is_an) {
1775	/* Give it a little more time to try to come back */
1776	msleep(msecs: 75);
1777	if (!test_bit(__I40E_DOWN, pf->state))
1778	return i40e_nway_reset(netdev);
1779	}
1780
1781	return err;
1782	}
1783
1784	static u32 i40e_get_msglevel(struct net_device *netdev)
1785	{
1786	struct i40e_netdev_priv *np = netdev_priv(dev: netdev);
1787	struct i40e_pf *pf = np->vsi->back;
1788	u32 debug_mask = pf->hw.debug_mask;
1789
1790	if (debug_mask)
1791	netdev_info(dev: netdev, format: "i40e debug_mask: 0x%08X\n", debug_mask);
1792
1793	return pf->msg_enable;
1794	}
1795
1796	static void i40e_set_msglevel(struct net_device *netdev, u32 data)
1797	{
1798	struct i40e_netdev_priv *np = netdev_priv(dev: netdev);
1799	struct i40e_pf *pf = np->vsi->back;
1800
1801	if (I40E_DEBUG_USER & data)
1802	pf->hw.debug_mask = data;
1803	else
1804	pf->msg_enable = data;
1805	}
1806
1807	static int i40e_get_regs_len(struct net_device *netdev)
1808	{
1809	int reg_count = 0;
1810	int i;
1811
1812	for (i = 0; i40e_reg_list[i].offset != 0; i++)
1813	reg_count += i40e_reg_list[i].elements;
1814
1815	return reg_count * sizeof(u32);
1816	}
1817
1818	static void i40e_get_regs(struct net_device *netdev, struct ethtool_regs *regs,
1819	void *p)
1820	{
1821	struct i40e_netdev_priv *np = netdev_priv(dev: netdev);
1822	struct i40e_pf *pf = np->vsi->back;
1823	struct i40e_hw *hw = &pf->hw;
1824	u32 *reg_buf = p;
1825	unsigned int i, j, ri;
1826	u32 reg;
1827
1828	/* Tell ethtool which driver-version-specific regs output we have.
1829	*
1830	* At some point, if we have ethtool doing special formatting of
1831	* this data, it will rely on this version number to know how to
1832	* interpret things. Hence, this needs to be updated if/when the
1833	* diags register table is changed.
1834	*/
1835	regs->version = 1;
1836
1837	/* loop through the diags reg table for what to print */
1838	ri = 0;
1839	for (i = 0; i40e_reg_list[i].offset != 0; i++) {
1840	for (j = 0; j < i40e_reg_list[i].elements; j++) {
1841	reg = i40e_reg_list[i].offset
1842	+ (j * i40e_reg_list[i].stride);
1843	reg_buf[ri++] = rd32(hw, reg);
1844	}
1845	}
1846
1847	}
1848
1849	static int i40e_get_eeprom(struct net_device *netdev,
1850	struct ethtool_eeprom *eeprom, u8 *bytes)
1851	{
1852	struct i40e_netdev_priv *np = netdev_priv(dev: netdev);
1853	struct i40e_hw *hw = &np->vsi->back->hw;
1854	struct i40e_pf *pf = np->vsi->back;
1855	int ret_val = 0, len, offset;
1856	u8 *eeprom_buff;
1857	u16 i, sectors;
1858	bool last;
1859	u32 magic;
1860
1861	#define I40E_NVM_SECTOR_SIZE 4096
1862	if (eeprom->len == 0)
1863	return -EINVAL;
1864
1865	/* check for NVMUpdate access method */
1866	magic = hw->vendor_id | (hw->device_id << 16);
1867	if (eeprom->magic && eeprom->magic != magic) {
1868	struct i40e_nvm_access *cmd = (struct i40e_nvm_access *)eeprom;
1869	int errno = 0;
1870
1871	/* make sure it is the right magic for NVMUpdate */
1872	if ((eeprom->magic >> 16) != hw->device_id)
1873	errno = -EINVAL;
1874	else if (test_bit(__I40E_RESET_RECOVERY_PENDING, pf->state) ||
1875	test_bit(__I40E_RESET_INTR_RECEIVED, pf->state))
1876	errno = -EBUSY;
1877	else
1878	ret_val = i40e_nvmupd_command(hw, cmd, bytes, errno: &errno);
1879
1880	if ((errno || ret_val) && (hw->debug_mask & I40E_DEBUG_NVM))
1881	dev_info(&pf->pdev->dev,
1882	"NVMUpdate read failed err=%d status=0x%x errno=%d module=%d offset=0x%x size=%d\n",
1883	ret_val, hw->aq.asq_last_status, errno,
1884	(u8)(cmd->config & I40E_NVM_MOD_PNT_MASK),
1885	cmd->offset, cmd->data_size);
1886
1887	return errno;
1888	}
1889
1890	/* normal ethtool get_eeprom support */
1891	eeprom->magic = hw->vendor_id | (hw->device_id << 16);
1892
1893	eeprom_buff = kzalloc(size: eeprom->len, GFP_KERNEL);
1894	if (!eeprom_buff)
1895	return -ENOMEM;
1896
1897	ret_val = i40e_acquire_nvm(hw, access: I40E_RESOURCE_READ);
1898	if (ret_val) {
1899	dev_info(&pf->pdev->dev,
1900	"Failed Acquiring NVM resource for read err=%d status=0x%x\n",
1901	ret_val, hw->aq.asq_last_status);
1902	goto free_buff;
1903	}
1904
1905	sectors = eeprom->len / I40E_NVM_SECTOR_SIZE;
1906	sectors += (eeprom->len % I40E_NVM_SECTOR_SIZE) ? 1 : 0;
1907	len = I40E_NVM_SECTOR_SIZE;
1908	last = false;
1909	for (i = 0; i < sectors; i++) {
1910	if (i == (sectors - 1)) {
1911	len = eeprom->len - (I40E_NVM_SECTOR_SIZE * i);
1912	last = true;
1913	}
1914	offset = eeprom->offset + (I40E_NVM_SECTOR_SIZE * i);
1915	ret_val = i40e_aq_read_nvm(hw, module_pointer: 0x0, offset, length: len,
1916	data: (u8 *)eeprom_buff + (I40E_NVM_SECTOR_SIZE * i),
1917	last_command: last, NULL);
1918	if (ret_val && hw->aq.asq_last_status == I40E_AQ_RC_EPERM) {
1919	dev_info(&pf->pdev->dev,
1920	"read NVM failed, invalid offset 0x%x\n",
1921	offset);
1922	break;
1923	} else if (ret_val &&
1924	hw->aq.asq_last_status == I40E_AQ_RC_EACCES) {
1925	dev_info(&pf->pdev->dev,
1926	"read NVM failed, access, offset 0x%x\n",
1927	offset);
1928	break;
1929	} else if (ret_val) {
1930	dev_info(&pf->pdev->dev,
1931	"read NVM failed offset %d err=%d status=0x%x\n",
1932	offset, ret_val, hw->aq.asq_last_status);
1933	break;
1934	}
1935	}
1936
1937	i40e_release_nvm(hw);
1938	memcpy(bytes, (u8 *)eeprom_buff, eeprom->len);
1939	free_buff:
1940	kfree(objp: eeprom_buff);
1941	return ret_val;
1942	}
1943
1944	static int i40e_get_eeprom_len(struct net_device *netdev)
1945	{
1946	struct i40e_netdev_priv *np = netdev_priv(dev: netdev);
1947	struct i40e_hw *hw = &np->vsi->back->hw;
1948	u32 val;
1949
1950	#define X722_EEPROM_SCOPE_LIMIT 0x5B9FFF
1951	if (hw->mac.type == I40E_MAC_X722) {
1952	val = X722_EEPROM_SCOPE_LIMIT + 1;
1953	return val;
1954	}
1955	val = FIELD_GET(I40E_GLPCI_LBARCTRL_FL_SIZE_MASK,
1956	rd32(hw, I40E_GLPCI_LBARCTRL));
1957	/* register returns value in power of 2, 64Kbyte chunks. */
1958	val = (64 * 1024) * BIT(val);
1959	return val;
1960	}
1961
1962	static int i40e_set_eeprom(struct net_device *netdev,
1963	struct ethtool_eeprom *eeprom, u8 *bytes)
1964	{
1965	struct i40e_netdev_priv *np = netdev_priv(dev: netdev);
1966	struct i40e_hw *hw = &np->vsi->back->hw;
1967	struct i40e_pf *pf = np->vsi->back;
1968	struct i40e_nvm_access *cmd = (struct i40e_nvm_access *)eeprom;
1969	int ret_val = 0;
1970	int errno = 0;
1971	u32 magic;
1972
1973	/* normal ethtool set_eeprom is not supported */
1974	magic = hw->vendor_id | (hw->device_id << 16);
1975	if (eeprom->magic == magic)
1976	errno = -EOPNOTSUPP;
1977	/* check for NVMUpdate access method */
1978	else if (!eeprom->magic || (eeprom->magic >> 16) != hw->device_id)
1979	errno = -EINVAL;
1980	else if (test_bit(__I40E_RESET_RECOVERY_PENDING, pf->state) ||
1981	test_bit(__I40E_RESET_INTR_RECEIVED, pf->state))
1982	errno = -EBUSY;
1983	else
1984	ret_val = i40e_nvmupd_command(hw, cmd, bytes, errno: &errno);
1985
1986	if ((errno || ret_val) && (hw->debug_mask & I40E_DEBUG_NVM))
1987	dev_info(&pf->pdev->dev,
1988	"NVMUpdate write failed err=%d status=0x%x errno=%d module=%d offset=0x%x size=%d\n",
1989	ret_val, hw->aq.asq_last_status, errno,
1990	(u8)(cmd->config & I40E_NVM_MOD_PNT_MASK),
1991	cmd->offset, cmd->data_size);
1992
1993	return errno;
1994	}
1995
1996	static void i40e_get_drvinfo(struct net_device *netdev,
1997	struct ethtool_drvinfo *drvinfo)
1998	{
1999	struct i40e_netdev_priv *np = netdev_priv(dev: netdev);
2000	struct i40e_vsi *vsi = np->vsi;
2001	struct i40e_pf *pf = vsi->back;
2002
2003	strscpy(drvinfo->driver, i40e_driver_name, sizeof(drvinfo->driver));
2004	i40e_nvm_version_str(hw: &pf->hw, buf: drvinfo->fw_version,
2005	len: sizeof(drvinfo->fw_version));
2006	strscpy(drvinfo->bus_info, pci_name(pf->pdev),
2007	sizeof(drvinfo->bus_info));
2008	drvinfo->n_priv_flags = I40E_PRIV_FLAGS_STR_LEN;
2009	if (pf->hw.pf_id == 0)
2010	drvinfo->n_priv_flags += I40E_GL_PRIV_FLAGS_STR_LEN;
2011	}
2012
2013	static u32 i40e_get_max_num_descriptors(struct i40e_pf *pf)
2014	{
2015	struct i40e_hw *hw = &pf->hw;
2016
2017	switch (hw->mac.type) {
2018	case I40E_MAC_XL710:
2019	return I40E_MAX_NUM_DESCRIPTORS_XL710;
2020	default:
2021	return I40E_MAX_NUM_DESCRIPTORS;
2022	}
2023	}
2024
2025	static void i40e_get_ringparam(struct net_device *netdev,
2026	struct ethtool_ringparam *ring,
2027	struct kernel_ethtool_ringparam *kernel_ring,
2028	struct netlink_ext_ack *extack)
2029	{
2030	struct i40e_netdev_priv *np = netdev_priv(dev: netdev);
2031	struct i40e_pf *pf = np->vsi->back;
2032	struct i40e_vsi *vsi = pf->vsi[pf->lan_vsi];
2033
2034	ring->rx_max_pending = i40e_get_max_num_descriptors(pf);
2035	ring->tx_max_pending = i40e_get_max_num_descriptors(pf);
2036	ring->rx_mini_max_pending = 0;
2037	ring->rx_jumbo_max_pending = 0;
2038	ring->rx_pending = vsi->rx_rings[0]->count;
2039	ring->tx_pending = vsi->tx_rings[0]->count;
2040	ring->rx_mini_pending = 0;
2041	ring->rx_jumbo_pending = 0;
2042	}
2043
2044	static bool i40e_active_tx_ring_index(struct i40e_vsi *vsi, u16 index)
2045	{
2046	if (i40e_enabled_xdp_vsi(vsi)) {
2047	return index < vsi->num_queue_pairs ||
2048	(index >= vsi->alloc_queue_pairs &&
2049	index < vsi->alloc_queue_pairs + vsi->num_queue_pairs);
2050	}
2051
2052	return index < vsi->num_queue_pairs;
2053	}
2054
2055	static int i40e_set_ringparam(struct net_device *netdev,
2056	struct ethtool_ringparam *ring,
2057	struct kernel_ethtool_ringparam *kernel_ring,
2058	struct netlink_ext_ack *extack)
2059	{
2060	u32 new_rx_count, new_tx_count, max_num_descriptors;
2061	struct i40e_ring *tx_rings = NULL, *rx_rings = NULL;
2062	struct i40e_netdev_priv *np = netdev_priv(dev: netdev);
2063	struct i40e_hw *hw = &np->vsi->back->hw;
2064	struct i40e_vsi *vsi = np->vsi;
2065	struct i40e_pf *pf = vsi->back;
2066	u16 tx_alloc_queue_pairs;
2067	int timeout = 50;
2068	int i, err = 0;
2069
2070	if ((ring->rx_mini_pending) || (ring->rx_jumbo_pending))
2071	return -EINVAL;
2072
2073	max_num_descriptors = i40e_get_max_num_descriptors(pf);
2074	if (ring->tx_pending > max_num_descriptors ||
2075	ring->tx_pending < I40E_MIN_NUM_DESCRIPTORS ||
2076	ring->rx_pending > max_num_descriptors ||
2077	ring->rx_pending < I40E_MIN_NUM_DESCRIPTORS) {
2078	netdev_info(dev: netdev,
2079	format: "Descriptors requested (Tx: %d / Rx: %d) out of range [%d-%d]\n",
2080	ring->tx_pending, ring->rx_pending,
2081	I40E_MIN_NUM_DESCRIPTORS, max_num_descriptors);
2082	return -EINVAL;
2083	}
2084
2085	new_tx_count = ALIGN(ring->tx_pending, I40E_REQ_DESCRIPTOR_MULTIPLE);
2086	new_rx_count = ALIGN(ring->rx_pending, I40E_REQ_DESCRIPTOR_MULTIPLE);
2087
2088	/* if nothing to do return success */
2089	if ((new_tx_count == vsi->tx_rings[0]->count) &&
2090	(new_rx_count == vsi->rx_rings[0]->count))
2091	return 0;
2092
2093	/* If there is a AF_XDP page pool attached to any of Rx rings,
2094	* disallow changing the number of descriptors -- regardless
2095	* if the netdev is running or not.
2096	*/
2097	if (i40e_xsk_any_rx_ring_enabled(vsi))
2098	return -EBUSY;
2099
2100	while (test_and_set_bit(nr: __I40E_CONFIG_BUSY, addr: pf->state)) {
2101	timeout--;
2102	if (!timeout)
2103	return -EBUSY;
2104	usleep_range(min: 1000, max: 2000);
2105	}
2106
2107	if (!netif_running(dev: vsi->netdev)) {
2108	/* simple case - set for the next time the netdev is started */
2109	for (i = 0; i < vsi->num_queue_pairs; i++) {
2110	vsi->tx_rings[i]->count = new_tx_count;
2111	vsi->rx_rings[i]->count = new_rx_count;
2112	if (i40e_enabled_xdp_vsi(vsi))
2113	vsi->xdp_rings[i]->count = new_tx_count;
2114	}
2115	vsi->num_tx_desc = new_tx_count;
2116	vsi->num_rx_desc = new_rx_count;
2117	goto done;
2118	}
2119
2120	/* We can't just free everything and then setup again,
2121	* because the ISRs in MSI-X mode get passed pointers
2122	* to the Tx and Rx ring structs.
2123	*/
2124
2125	/* alloc updated Tx and XDP Tx resources */
2126	tx_alloc_queue_pairs = vsi->alloc_queue_pairs *
2127	(i40e_enabled_xdp_vsi(vsi) ? 2 : 1);
2128	if (new_tx_count != vsi->tx_rings[0]->count) {
2129	netdev_info(dev: netdev,
2130	format: "Changing Tx descriptor count from %d to %d.\n",
2131	vsi->tx_rings[0]->count, new_tx_count);
2132	tx_rings = kcalloc(n: tx_alloc_queue_pairs,
2133	size: sizeof(struct i40e_ring), GFP_KERNEL);
2134	if (!tx_rings) {
2135	err = -ENOMEM;
2136	goto done;
2137	}
2138
2139	for (i = 0; i < tx_alloc_queue_pairs; i++) {
2140	if (!i40e_active_tx_ring_index(vsi, index: i))
2141	continue;
2142
2143	tx_rings[i] = *vsi->tx_rings[i];
2144	tx_rings[i].count = new_tx_count;
2145	/* the desc and bi pointers will be reallocated in the
2146	* setup call
2147	*/
2148	tx_rings[i].desc = NULL;
2149	tx_rings[i].rx_bi = NULL;
2150	err = i40e_setup_tx_descriptors(tx_ring: &tx_rings[i]);
2151	if (err) {
2152	while (i) {
2153	i--;
2154	if (!i40e_active_tx_ring_index(vsi, index: i))
2155	continue;
2156	i40e_free_tx_resources(tx_ring: &tx_rings[i]);
2157	}
2158	kfree(objp: tx_rings);
2159	tx_rings = NULL;
2160
2161	goto done;
2162	}
2163	}
2164	}
2165
2166	/* alloc updated Rx resources */
2167	if (new_rx_count != vsi->rx_rings[0]->count) {
2168	netdev_info(dev: netdev,
2169	format: "Changing Rx descriptor count from %d to %d\n",
2170	vsi->rx_rings[0]->count, new_rx_count);
2171	rx_rings = kcalloc(n: vsi->alloc_queue_pairs,
2172	size: sizeof(struct i40e_ring), GFP_KERNEL);
2173	if (!rx_rings) {
2174	err = -ENOMEM;
2175	goto free_tx;
2176	}
2177
2178	for (i = 0; i < vsi->num_queue_pairs; i++) {
2179	u16 unused;
2180
2181	/* clone ring and setup updated count */
2182	rx_rings[i] = *vsi->rx_rings[i];
2183	rx_rings[i].count = new_rx_count;
2184	/* the desc and bi pointers will be reallocated in the
2185	* setup call
2186	*/
2187	rx_rings[i].desc = NULL;
2188	rx_rings[i].rx_bi = NULL;
2189	/* Clear cloned XDP RX-queue info before setup call */
2190	memset(&rx_rings[i].xdp_rxq, 0, sizeof(rx_rings[i].xdp_rxq));
2191	/* this is to allow wr32 to have something to write to
2192	* during early allocation of Rx buffers
2193	*/
2194	rx_rings[i].tail = hw->hw_addr + I40E_PRTGEN_STATUS;
2195	err = i40e_setup_rx_descriptors(rx_ring: &rx_rings[i]);
2196	if (err)
2197	goto rx_unwind;
2198
2199	/* now allocate the Rx buffers to make sure the OS
2200	* has enough memory, any failure here means abort
2201	*/
2202	unused = I40E_DESC_UNUSED(&rx_rings[i]);
2203	err = i40e_alloc_rx_buffers(rxr: &rx_rings[i], cleaned_count: unused);
2204	rx_unwind:
2205	if (err) {
2206	do {
2207	i40e_free_rx_resources(rx_ring: &rx_rings[i]);
2208	} while (i--);
2209	kfree(objp: rx_rings);
2210	rx_rings = NULL;
2211
2212	goto free_tx;
2213	}
2214	}
2215	}
2216
2217	/* Bring interface down, copy in the new ring info,
2218	* then restore the interface
2219	*/
2220	i40e_down(vsi);
2221
2222	if (tx_rings) {
2223	for (i = 0; i < tx_alloc_queue_pairs; i++) {
2224	if (i40e_active_tx_ring_index(vsi, index: i)) {
2225	i40e_free_tx_resources(tx_ring: vsi->tx_rings[i]);
2226	*vsi->tx_rings[i] = tx_rings[i];
2227	}
2228	}
2229	kfree(objp: tx_rings);
2230	tx_rings = NULL;
2231	}
2232
2233	if (rx_rings) {
2234	for (i = 0; i < vsi->num_queue_pairs; i++) {
2235	i40e_free_rx_resources(rx_ring: vsi->rx_rings[i]);
2236	/* get the real tail offset */
2237	rx_rings[i].tail = vsi->rx_rings[i]->tail;
2238	/* this is to fake out the allocation routine
2239	* into thinking it has to realloc everything
2240	* but the recycling logic will let us re-use
2241	* the buffers allocated above
2242	*/
2243	rx_rings[i].next_to_use = 0;
2244	rx_rings[i].next_to_clean = 0;
2245	rx_rings[i].next_to_alloc = 0;
2246	/* do a struct copy */
2247	*vsi->rx_rings[i] = rx_rings[i];
2248	}
2249	kfree(objp: rx_rings);
2250	rx_rings = NULL;
2251	}
2252
2253	vsi->num_tx_desc = new_tx_count;
2254	vsi->num_rx_desc = new_rx_count;
2255	i40e_up(vsi);
2256
2257	free_tx:
2258	/* error cleanup if the Rx allocations failed after getting Tx */
2259	if (tx_rings) {
2260	for (i = 0; i < tx_alloc_queue_pairs; i++) {
2261	if (i40e_active_tx_ring_index(vsi, index: i))
2262	i40e_free_tx_resources(tx_ring: vsi->tx_rings[i]);
2263	}
2264	kfree(objp: tx_rings);
2265	tx_rings = NULL;
2266	}
2267
2268	done:
2269	clear_bit(nr: __I40E_CONFIG_BUSY, addr: pf->state);
2270
2271	return err;
2272	}
2273
2274	/**
2275	* i40e_get_stats_count - return the stats count for a device
2276	* @netdev: the netdev to return the count for
2277	*
2278	* Returns the total number of statistics for this netdev. Note that even
2279	* though this is a function, it is required that the count for a specific
2280	* netdev must never change. Basing the count on static values such as the
2281	* maximum number of queues or the device type is ok. However, the API for
2282	* obtaining stats is *not* safe against changes based on non-static
2283	* values such as the *current* number of queues, or runtime flags.
2284	*
2285	* If a statistic is not always enabled, return it as part of the count
2286	* anyways, always return its string, and report its value as zero.
2287	**/
2288	static int i40e_get_stats_count(struct net_device *netdev)
2289	{
2290	struct i40e_netdev_priv *np = netdev_priv(dev: netdev);
2291	struct i40e_vsi *vsi = np->vsi;
2292	struct i40e_pf *pf = vsi->back;
2293	int stats_len;
2294
2295	if (vsi == pf->vsi[pf->lan_vsi] && pf->hw.partition_id == 1)
2296	stats_len = I40E_PF_STATS_LEN;
2297	else
2298	stats_len = I40E_VSI_STATS_LEN;
2299
2300	/* The number of stats reported for a given net_device must remain
2301	* constant throughout the life of that device.
2302	*
2303	* This is because the API for obtaining the size, strings, and stats
2304	* is spread out over three separate ethtool ioctls. There is no safe
2305	* way to lock the number of stats across these calls, so we must
2306	* assume that they will never change.
2307	*
2308	* Due to this, we report the maximum number of queues, even if not
2309	* every queue is currently configured. Since we always allocate
2310	* queues in pairs, we'll just use netdev->num_tx_queues * 2. This
2311	* works because the num_tx_queues is set at device creation and never
2312	* changes.
2313	*/
2314	stats_len += I40E_QUEUE_STATS_LEN * 2 * netdev->num_tx_queues;
2315
2316	return stats_len;
2317	}
2318
2319	static int i40e_get_sset_count(struct net_device *netdev, int sset)
2320	{
2321	struct i40e_netdev_priv *np = netdev_priv(dev: netdev);
2322	struct i40e_vsi *vsi = np->vsi;
2323	struct i40e_pf *pf = vsi->back;
2324
2325	switch (sset) {
2326	case ETH_SS_TEST:
2327	return I40E_TEST_LEN;
2328	case ETH_SS_STATS:
2329	return i40e_get_stats_count(netdev);
2330	case ETH_SS_PRIV_FLAGS:
2331	return I40E_PRIV_FLAGS_STR_LEN +
2332	(pf->hw.pf_id == 0 ? I40E_GL_PRIV_FLAGS_STR_LEN : 0);
2333	default:
2334	return -EOPNOTSUPP;
2335	}
2336	}
2337
2338	/**
2339	* i40e_get_veb_tc_stats - copy VEB TC statistics to formatted structure
2340	* @tc: the TC statistics in VEB structure (veb->tc_stats)
2341	* @i: the index of traffic class in (veb->tc_stats) structure to copy
2342	*
2343	* Copy VEB TC statistics from structure of arrays (veb->tc_stats) to
2344	* one dimensional structure i40e_cp_veb_tc_stats.
2345	* Produce formatted i40e_cp_veb_tc_stats structure of the VEB TC
2346	* statistics for the given TC.
2347	**/
2348	static struct i40e_cp_veb_tc_stats
2349	i40e_get_veb_tc_stats(struct i40e_veb_tc_stats *tc, unsigned int i)
2350	{
2351	struct i40e_cp_veb_tc_stats veb_tc = {
2352	.tc_rx_packets = tc->tc_rx_packets[i],
2353	.tc_rx_bytes = tc->tc_rx_bytes[i],
2354	.tc_tx_packets = tc->tc_tx_packets[i],
2355	.tc_tx_bytes = tc->tc_tx_bytes[i],
2356	};
2357
2358	return veb_tc;
2359	}
2360
2361	/**
2362	* i40e_get_pfc_stats - copy HW PFC statistics to formatted structure
2363	* @pf: the PF device structure
2364	* @i: the priority value to copy
2365	*
2366	* The PFC stats are found as arrays in pf->stats, which is not easy to pass
2367	* into i40e_add_ethtool_stats. Produce a formatted i40e_pfc_stats structure
2368	* of the PFC stats for the given priority.
2369	**/
2370	static inline struct i40e_pfc_stats
2371	i40e_get_pfc_stats(struct i40e_pf *pf, unsigned int i)
2372	{
2373	#define I40E_GET_PFC_STAT(stat, priority) \
2374	.stat = pf->stats.stat[priority]
2375
2376	struct i40e_pfc_stats pfc = {
2377	I40E_GET_PFC_STAT(priority_xon_rx, i),
2378	I40E_GET_PFC_STAT(priority_xoff_rx, i),
2379	I40E_GET_PFC_STAT(priority_xon_tx, i),
2380	I40E_GET_PFC_STAT(priority_xoff_tx, i),
2381	I40E_GET_PFC_STAT(priority_xon_2_xoff, i),
2382	};
2383	return pfc;
2384	}
2385
2386	/**
2387	* i40e_get_ethtool_stats - copy stat values into supplied buffer
2388	* @netdev: the netdev to collect stats for
2389	* @stats: ethtool stats command structure
2390	* @data: ethtool supplied buffer
2391	*
2392	* Copy the stats values for this netdev into the buffer. Expects data to be
2393	* pre-allocated to the size returned by i40e_get_stats_count.. Note that all
2394	* statistics must be copied in a static order, and the count must not change
2395	* for a given netdev. See i40e_get_stats_count for more details.
2396	*
2397	* If a statistic is not currently valid (such as a disabled queue), this
2398	* function reports its value as zero.
2399	**/
2400	static void i40e_get_ethtool_stats(struct net_device *netdev,
2401	struct ethtool_stats *stats, u64 *data)
2402	{
2403	struct i40e_netdev_priv *np = netdev_priv(dev: netdev);
2404	struct i40e_vsi *vsi = np->vsi;
2405	struct i40e_pf *pf = vsi->back;
2406	struct i40e_veb *veb = NULL;
2407	unsigned int i;
2408	bool veb_stats;
2409	u64 *p = data;
2410
2411	i40e_update_stats(vsi);
2412
2413	i40e_add_ethtool_stats(&data, i40e_get_vsi_stats_struct(vsi),
2414	i40e_gstrings_net_stats);
2415
2416	i40e_add_ethtool_stats(&data, vsi, i40e_gstrings_misc_stats);
2417
2418	rcu_read_lock();
2419	for (i = 0; i < netdev->num_tx_queues; i++) {
2420	i40e_add_queue_stats(data: &data, READ_ONCE(vsi->tx_rings[i]));
2421	i40e_add_queue_stats(data: &data, READ_ONCE(vsi->rx_rings[i]));
2422	}
2423	rcu_read_unlock();
2424
2425	if (vsi != pf->vsi[pf->lan_vsi] || pf->hw.partition_id != 1)
2426	goto check_data_pointer;
2427
2428	veb_stats = ((pf->lan_veb != I40E_NO_VEB) &&
2429	(pf->lan_veb < I40E_MAX_VEB) &&
2430	test_bit(I40E_FLAG_VEB_STATS_ENA, pf->flags));
2431
2432	if (veb_stats) {
2433	veb = pf->veb[pf->lan_veb];
2434	i40e_update_veb_stats(veb);
2435	}
2436
2437	/* If veb stats aren't enabled, pass NULL instead of the veb so that
2438	* we initialize stats to zero and update the data pointer
2439	* intelligently
2440	*/
2441	i40e_add_ethtool_stats(&data, veb_stats ? veb : NULL,
2442	i40e_gstrings_veb_stats);
2443
2444	for (i = 0; i < I40E_MAX_TRAFFIC_CLASS; i++)
2445	if (veb_stats) {
2446	struct i40e_cp_veb_tc_stats veb_tc =
2447	i40e_get_veb_tc_stats(tc: &veb->tc_stats, i);
2448
2449	i40e_add_ethtool_stats(&data, &veb_tc,
2450	i40e_gstrings_veb_tc_stats);
2451	} else {
2452	i40e_add_ethtool_stats(&data, NULL,
2453	i40e_gstrings_veb_tc_stats);
2454	}
2455
2456	i40e_add_ethtool_stats(&data, pf, i40e_gstrings_stats);
2457
2458	for (i = 0; i < I40E_MAX_USER_PRIORITY; i++) {
2459	struct i40e_pfc_stats pfc = i40e_get_pfc_stats(pf, i);
2460
2461	i40e_add_ethtool_stats(&data, &pfc, i40e_gstrings_pfc_stats);
2462	}
2463
2464	check_data_pointer:
2465	WARN_ONCE(data - p != i40e_get_stats_count(netdev),
2466	"ethtool stats count mismatch!");
2467	}
2468
2469	/**
2470	* i40e_get_stat_strings - copy stat strings into supplied buffer
2471	* @netdev: the netdev to collect strings for
2472	* @data: supplied buffer to copy strings into
2473	*
2474	* Copy the strings related to stats for this netdev. Expects data to be
2475	* pre-allocated with the size reported by i40e_get_stats_count. Note that the
2476	* strings must be copied in a static order and the total count must not
2477	* change for a given netdev. See i40e_get_stats_count for more details.
2478	**/
2479	static void i40e_get_stat_strings(struct net_device *netdev, u8 *data)
2480	{
2481	struct i40e_netdev_priv *np = netdev_priv(dev: netdev);
2482	struct i40e_vsi *vsi = np->vsi;
2483	struct i40e_pf *pf = vsi->back;
2484	unsigned int i;
2485	u8 *p = data;
2486
2487	i40e_add_stat_strings(&data, i40e_gstrings_net_stats);
2488
2489	i40e_add_stat_strings(&data, i40e_gstrings_misc_stats);
2490
2491	for (i = 0; i < netdev->num_tx_queues; i++) {
2492	i40e_add_stat_strings(&data, i40e_gstrings_queue_stats,
2493	"tx", i);
2494	i40e_add_stat_strings(&data, i40e_gstrings_queue_stats,
2495	"rx", i);
2496	}
2497
2498	if (vsi != pf->vsi[pf->lan_vsi] || pf->hw.partition_id != 1)
2499	goto check_data_pointer;
2500
2501	i40e_add_stat_strings(&data, i40e_gstrings_veb_stats);
2502
2503	for (i = 0; i < I40E_MAX_TRAFFIC_CLASS; i++)
2504	i40e_add_stat_strings(&data, i40e_gstrings_veb_tc_stats, i);
2505
2506	i40e_add_stat_strings(&data, i40e_gstrings_stats);
2507
2508	for (i = 0; i < I40E_MAX_USER_PRIORITY; i++)
2509	i40e_add_stat_strings(&data, i40e_gstrings_pfc_stats, i);
2510
2511	check_data_pointer:
2512	WARN_ONCE(data - p != i40e_get_stats_count(netdev) * ETH_GSTRING_LEN,
2513	"stat strings count mismatch!");
2514	}
2515
2516	static void i40e_get_priv_flag_strings(struct net_device *netdev, u8 *data)
2517	{
2518	struct i40e_netdev_priv *np = netdev_priv(dev: netdev);
2519	struct i40e_vsi *vsi = np->vsi;
2520	struct i40e_pf *pf = vsi->back;
2521	unsigned int i;
2522	u8 *p = data;
2523
2524	for (i = 0; i < I40E_PRIV_FLAGS_STR_LEN; i++)
2525	ethtool_puts(data: &p, str: i40e_gstrings_priv_flags[i].flag_string);
2526	if (pf->hw.pf_id != 0)
2527	return;
2528	for (i = 0; i < I40E_GL_PRIV_FLAGS_STR_LEN; i++)
2529	ethtool_puts(data: &p, str: i40e_gl_gstrings_priv_flags[i].flag_string);
2530	}
2531
2532	static void i40e_get_strings(struct net_device *netdev, u32 stringset,
2533	u8 *data)
2534	{
2535	switch (stringset) {
2536	case ETH_SS_TEST:
2537	memcpy(data, i40e_gstrings_test,
2538	I40E_TEST_LEN * ETH_GSTRING_LEN);
2539	break;
2540	case ETH_SS_STATS:
2541	i40e_get_stat_strings(netdev, data);
2542	break;
2543	case ETH_SS_PRIV_FLAGS:
2544	i40e_get_priv_flag_strings(netdev, data);
2545	break;
2546	default:
2547	break;
2548	}
2549	}
2550
2551	static int i40e_get_ts_info(struct net_device *dev,
2552	struct ethtool_ts_info *info)
2553	{
2554	struct i40e_pf *pf = i40e_netdev_to_pf(netdev: dev);
2555
2556	/* only report HW timestamping if PTP is enabled */
2557	if (!test_bit(I40E_FLAG_PTP_ENA, pf->flags))
2558	return ethtool_op_get_ts_info(dev, eti: info);
2559
2560	info->so_timestamping = SOF_TIMESTAMPING_TX_SOFTWARE |
2561	SOF_TIMESTAMPING_RX_SOFTWARE |
2562	SOF_TIMESTAMPING_SOFTWARE |
2563	SOF_TIMESTAMPING_TX_HARDWARE |
2564	SOF_TIMESTAMPING_RX_HARDWARE |
2565	SOF_TIMESTAMPING_RAW_HARDWARE;
2566
2567	if (pf->ptp_clock)
2568	info->phc_index = ptp_clock_index(ptp: pf->ptp_clock);
2569	else
2570	info->phc_index = -1;
2571
2572	info->tx_types = BIT(HWTSTAMP_TX_OFF) | BIT(HWTSTAMP_TX_ON);
2573
2574	info->rx_filters = BIT(HWTSTAMP_FILTER_NONE) |
2575	BIT(HWTSTAMP_FILTER_PTP_V2_L2_EVENT) |
2576	BIT(HWTSTAMP_FILTER_PTP_V2_L2_SYNC) |
2577	BIT(HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ);
2578
2579	if (test_bit(I40E_HW_CAP_PTP_L4, pf->hw.caps))
2580	info->rx_filters |= BIT(HWTSTAMP_FILTER_PTP_V1_L4_SYNC) |
2581	BIT(HWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQ) |
2582	BIT(HWTSTAMP_FILTER_PTP_V2_EVENT) |
2583	BIT(HWTSTAMP_FILTER_PTP_V2_L4_EVENT) |
2584	BIT(HWTSTAMP_FILTER_PTP_V2_SYNC) |
2585	BIT(HWTSTAMP_FILTER_PTP_V2_L4_SYNC) |
2586	BIT(HWTSTAMP_FILTER_PTP_V2_DELAY_REQ) |
2587	BIT(HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ);
2588
2589	return 0;
2590	}
2591
2592	static u64 i40e_link_test(struct net_device *netdev, u64 *data)
2593	{
2594	struct i40e_netdev_priv *np = netdev_priv(dev: netdev);
2595	struct i40e_pf *pf = np->vsi->back;
2596	bool link_up = false;
2597	int status;
2598
2599	netif_info(pf, hw, netdev, "link test\n");
2600	status = i40e_get_link_status(hw: &pf->hw, link_up: &link_up);
2601	if (status) {
2602	netif_err(pf, drv, netdev, "link query timed out, please retry test\n");
2603	*data = 1;
2604	return *data;
2605	}
2606
2607	if (link_up)
2608	*data = 0;
2609	else
2610	*data = 1;
2611
2612	return *data;
2613	}
2614
2615	static u64 i40e_reg_test(struct net_device *netdev, u64 *data)
2616	{
2617	struct i40e_netdev_priv *np = netdev_priv(dev: netdev);
2618	struct i40e_pf *pf = np->vsi->back;
2619
2620	netif_info(pf, hw, netdev, "register test\n");
2621	*data = i40e_diag_reg_test(hw: &pf->hw);
2622
2623	return *data;
2624	}
2625
2626	static u64 i40e_eeprom_test(struct net_device *netdev, u64 *data)
2627	{
2628	struct i40e_netdev_priv *np = netdev_priv(dev: netdev);
2629	struct i40e_pf *pf = np->vsi->back;
2630
2631	netif_info(pf, hw, netdev, "eeprom test\n");
2632	*data = i40e_diag_eeprom_test(hw: &pf->hw);
2633
2634	/* forcebly clear the NVM Update state machine */
2635	pf->hw.nvmupd_state = I40E_NVMUPD_STATE_INIT;
2636
2637	return *data;
2638	}
2639
2640	static u64 i40e_intr_test(struct net_device *netdev, u64 *data)
2641	{
2642	struct i40e_netdev_priv *np = netdev_priv(dev: netdev);
2643	struct i40e_pf *pf = np->vsi->back;
2644	u16 swc_old = pf->sw_int_count;
2645
2646	netif_info(pf, hw, netdev, "interrupt test\n");
2647	wr32(&pf->hw, I40E_PFINT_DYN_CTL0,
2648	(I40E_PFINT_DYN_CTL0_INTENA_MASK |
2649	I40E_PFINT_DYN_CTL0_SWINT_TRIG_MASK |
2650	I40E_PFINT_DYN_CTL0_ITR_INDX_MASK |
2651	I40E_PFINT_DYN_CTL0_SW_ITR_INDX_ENA_MASK |
2652	I40E_PFINT_DYN_CTL0_SW_ITR_INDX_MASK));
2653	usleep_range(min: 1000, max: 2000);
2654	*data = (swc_old == pf->sw_int_count);
2655
2656	return *data;
2657	}
2658
2659	static inline bool i40e_active_vfs(struct i40e_pf *pf)
2660	{
2661	struct i40e_vf *vfs = pf->vf;
2662	int i;
2663
2664	for (i = 0; i < pf->num_alloc_vfs; i++)
2665	if (test_bit(I40E_VF_STATE_ACTIVE, &vfs[i].vf_states))
2666	return true;
2667	return false;
2668	}
2669
2670	static inline bool i40e_active_vmdqs(struct i40e_pf *pf)
2671	{
2672	return !!i40e_find_vsi_by_type(pf, type: I40E_VSI_VMDQ2);
2673	}
2674
2675	static void i40e_diag_test(struct net_device *netdev,
2676	struct ethtool_test *eth_test, u64 *data)
2677	{
2678	struct i40e_netdev_priv *np = netdev_priv(dev: netdev);
2679	bool if_running = netif_running(dev: netdev);
2680	struct i40e_pf *pf = np->vsi->back;
2681
2682	if (eth_test->flags == ETH_TEST_FL_OFFLINE) {
2683	/* Offline tests */
2684	netif_info(pf, drv, netdev, "offline testing starting\n");
2685
2686	set_bit(nr: __I40E_TESTING, addr: pf->state);
2687
2688	if (test_bit(__I40E_RESET_RECOVERY_PENDING, pf->state) ||
2689	test_bit(__I40E_RESET_INTR_RECEIVED, pf->state)) {
2690	dev_warn(&pf->pdev->dev,
2691	"Cannot start offline testing when PF is in reset state.\n");
2692	goto skip_ol_tests;
2693	}
2694
2695	if (i40e_active_vfs(pf) || i40e_active_vmdqs(pf)) {
2696	dev_warn(&pf->pdev->dev,
2697	"Please take active VFs and Netqueues offline and restart the adapter before running NIC diagnostics\n");
2698	goto skip_ol_tests;
2699	}
2700
2701	/* If the device is online then take it offline */
2702	if (if_running)
2703	/* indicate we're in test mode */
2704	i40e_close(netdev);
2705	else
2706	/* This reset does not affect link - if it is
2707	* changed to a type of reset that does affect
2708	* link then the following link test would have
2709	* to be moved to before the reset
2710	*/
2711	i40e_do_reset(pf, BIT(__I40E_PF_RESET_REQUESTED), lock_acquired: true);
2712
2713	if (i40e_link_test(netdev, data: &data[I40E_ETH_TEST_LINK]))
2714	eth_test->flags |= ETH_TEST_FL_FAILED;
2715
2716	if (i40e_eeprom_test(netdev, data: &data[I40E_ETH_TEST_EEPROM]))
2717	eth_test->flags |= ETH_TEST_FL_FAILED;
2718
2719	if (i40e_intr_test(netdev, data: &data[I40E_ETH_TEST_INTR]))
2720	eth_test->flags |= ETH_TEST_FL_FAILED;
2721
2722	/* run reg test last, a reset is required after it */
2723	if (i40e_reg_test(netdev, data: &data[I40E_ETH_TEST_REG]))
2724	eth_test->flags |= ETH_TEST_FL_FAILED;
2725
2726	clear_bit(nr: __I40E_TESTING, addr: pf->state);
2727	i40e_do_reset(pf, BIT(__I40E_PF_RESET_REQUESTED), lock_acquired: true);
2728
2729	if (if_running)
2730	i40e_open(netdev);
2731	} else {
2732	/* Online tests */
2733	netif_info(pf, drv, netdev, "online testing starting\n");
2734
2735	if (i40e_link_test(netdev, data: &data[I40E_ETH_TEST_LINK]))
2736	eth_test->flags |= ETH_TEST_FL_FAILED;
2737
2738	/* Offline only tests, not run in online; pass by default */
2739	data[I40E_ETH_TEST_REG] = 0;
2740	data[I40E_ETH_TEST_EEPROM] = 0;
2741	data[I40E_ETH_TEST_INTR] = 0;
2742	}
2743
2744	netif_info(pf, drv, netdev, "testing finished\n");
2745	return;
2746
2747	skip_ol_tests:
2748	data[I40E_ETH_TEST_REG] = 1;
2749	data[I40E_ETH_TEST_EEPROM] = 1;
2750	data[I40E_ETH_TEST_INTR] = 1;
2751	data[I40E_ETH_TEST_LINK] = 1;
2752	eth_test->flags |= ETH_TEST_FL_FAILED;
2753	clear_bit(nr: __I40E_TESTING, addr: pf->state);
2754	netif_info(pf, drv, netdev, "testing failed\n");
2755	}
2756
2757	static void i40e_get_wol(struct net_device *netdev,
2758	struct ethtool_wolinfo *wol)
2759	{
2760	struct i40e_netdev_priv *np = netdev_priv(dev: netdev);
2761	struct i40e_pf *pf = np->vsi->back;
2762	struct i40e_hw *hw = &pf->hw;
2763	u16 wol_nvm_bits;
2764
2765	/* NVM bit on means WoL disabled for the port */
2766	i40e_read_nvm_word(hw, I40E_SR_NVM_WAKE_ON_LAN, data: &wol_nvm_bits);
2767	if ((BIT(hw->port) & wol_nvm_bits) || (hw->partition_id != 1)) {
2768	wol->supported = 0;
2769	wol->wolopts = 0;
2770	} else {
2771	wol->supported = WAKE_MAGIC;
2772	wol->wolopts = (pf->wol_en ? WAKE_MAGIC : 0);
2773	}
2774	}
2775
2776	/**
2777	* i40e_set_wol - set the WakeOnLAN configuration
2778	* @netdev: the netdev in question
2779	* @wol: the ethtool WoL setting data
2780	**/
2781	static int i40e_set_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)
2782	{
2783	struct i40e_netdev_priv *np = netdev_priv(dev: netdev);
2784	struct i40e_pf *pf = np->vsi->back;
2785	struct i40e_vsi *vsi = np->vsi;
2786	struct i40e_hw *hw = &pf->hw;
2787	u16 wol_nvm_bits;
2788
2789	/* WoL not supported if this isn't the controlling PF on the port */
2790	if (hw->partition_id != 1) {
2791	i40e_partition_setting_complaint(pf);
2792	return -EOPNOTSUPP;
2793	}
2794
2795	if (vsi != pf->vsi[pf->lan_vsi])
2796	return -EOPNOTSUPP;
2797
2798	/* NVM bit on means WoL disabled for the port */
2799	i40e_read_nvm_word(hw, I40E_SR_NVM_WAKE_ON_LAN, data: &wol_nvm_bits);
2800	if (BIT(hw->port) & wol_nvm_bits)
2801	return -EOPNOTSUPP;
2802
2803	/* only magic packet is supported */
2804	if (wol->wolopts & ~WAKE_MAGIC)
2805	return -EOPNOTSUPP;
2806
2807	/* is this a new value? */
2808	if (pf->wol_en != !!wol->wolopts) {
2809	pf->wol_en = !!wol->wolopts;
2810	device_set_wakeup_enable(dev: &pf->pdev->dev, enable: pf->wol_en);
2811	}
2812
2813	return 0;
2814	}
2815
2816	static int i40e_set_phys_id(struct net_device *netdev,
2817	enum ethtool_phys_id_state state)
2818	{
2819	struct i40e_netdev_priv *np = netdev_priv(dev: netdev);
2820	struct i40e_pf *pf = np->vsi->back;
2821	struct i40e_hw *hw = &pf->hw;
2822	int blink_freq = 2;
2823	u16 temp_status;
2824	int ret = 0;
2825
2826	switch (state) {
2827	case ETHTOOL_ID_ACTIVE:
2828	if (!test_bit(I40E_HW_CAP_PHY_CONTROLS_LEDS, pf->hw.caps)) {
2829	pf->led_status = i40e_led_get(hw);
2830	} else {
2831	if (!test_bit(I40E_HW_CAP_AQ_PHY_ACCESS, hw->caps))
2832	i40e_aq_set_phy_debug(hw, I40E_PHY_DEBUG_ALL,
2833	NULL);
2834	ret = i40e_led_get_phy(hw, led_addr: &temp_status,
2835	val: &pf->phy_led_val);
2836	pf->led_status = temp_status;
2837	}
2838	return blink_freq;
2839	case ETHTOOL_ID_ON:
2840	if (!test_bit(I40E_HW_CAP_PHY_CONTROLS_LEDS, pf->hw.caps))
2841	i40e_led_set(hw, mode: 0xf, blink: false);
2842	else
2843	ret = i40e_led_set_phy(hw, on: true, led_addr: pf->led_status, mode: 0);
2844	break;
2845	case ETHTOOL_ID_OFF:
2846	if (!test_bit(I40E_HW_CAP_PHY_CONTROLS_LEDS, pf->hw.caps))
2847	i40e_led_set(hw, mode: 0x0, blink: false);
2848	else
2849	ret = i40e_led_set_phy(hw, on: false, led_addr: pf->led_status, mode: 0);
2850	break;
2851	case ETHTOOL_ID_INACTIVE:
2852	if (!test_bit(I40E_HW_CAP_PHY_CONTROLS_LEDS, pf->hw.caps)) {
2853	i40e_led_set(hw, mode: pf->led_status, blink: false);
2854	} else {
2855	ret = i40e_led_set_phy(hw, on: false, led_addr: pf->led_status,
2856	mode: (pf->phy_led_val |
2857	I40E_PHY_LED_MODE_ORIG));
2858	if (!test_bit(I40E_HW_CAP_AQ_PHY_ACCESS, hw->caps))
2859	i40e_aq_set_phy_debug(hw, cmd_flags: 0, NULL);
2860	}
2861	break;
2862	default:
2863	break;
2864	}
2865	if (ret)
2866	return -ENOENT;
2867	else
2868	return 0;
2869	}
2870
2871	/* NOTE: i40e hardware uses a conversion factor of 2 for Interrupt
2872	* Throttle Rate (ITR) ie. ITR(1) = 2us ITR(10) = 20 us, and also
2873	* 125us (8000 interrupts per second) == ITR(62)
2874	*/
2875
2876	/**
2877	* __i40e_get_coalesce - get per-queue coalesce settings
2878	* @netdev: the netdev to check
2879	* @ec: ethtool coalesce data structure
2880	* @queue: which queue to pick
2881	*
2882	* Gets the per-queue settings for coalescence. Specifically Rx and Tx usecs
2883	* are per queue. If queue is <0 then we default to queue 0 as the
2884	* representative value.
2885	**/
2886	static int __i40e_get_coalesce(struct net_device *netdev,
2887	struct ethtool_coalesce *ec,
2888	int queue)
2889	{
2890	struct i40e_netdev_priv *np = netdev_priv(dev: netdev);
2891	struct i40e_ring *rx_ring, *tx_ring;
2892	struct i40e_vsi *vsi = np->vsi;
2893
2894	ec->tx_max_coalesced_frames_irq = vsi->work_limit;
2895
2896	/* rx and tx usecs has per queue value. If user doesn't specify the
2897	* queue, return queue 0's value to represent.
2898	*/
2899	if (queue < 0)
2900	queue = 0;
2901	else if (queue >= vsi->num_queue_pairs)
2902	return -EINVAL;
2903
2904	rx_ring = vsi->rx_rings[queue];
2905	tx_ring = vsi->tx_rings[queue];
2906
2907	if (ITR_IS_DYNAMIC(rx_ring->itr_setting))
2908	ec->use_adaptive_rx_coalesce = 1;
2909
2910	if (ITR_IS_DYNAMIC(tx_ring->itr_setting))
2911	ec->use_adaptive_tx_coalesce = 1;
2912
2913	ec->rx_coalesce_usecs = rx_ring->itr_setting & ~I40E_ITR_DYNAMIC;
2914	ec->tx_coalesce_usecs = tx_ring->itr_setting & ~I40E_ITR_DYNAMIC;
2915
2916	/* we use the _usecs_high to store/set the interrupt rate limit
2917	* that the hardware supports, that almost but not quite
2918	* fits the original intent of the ethtool variable,
2919	* the rx_coalesce_usecs_high limits total interrupts
2920	* per second from both tx/rx sources.
2921	*/
2922	ec->rx_coalesce_usecs_high = vsi->int_rate_limit;
2923	ec->tx_coalesce_usecs_high = vsi->int_rate_limit;
2924
2925	return 0;
2926	}
2927
2928	/**
2929	* i40e_get_coalesce - get a netdev's coalesce settings
2930	* @netdev: the netdev to check
2931	* @ec: ethtool coalesce data structure
2932	* @kernel_coal: ethtool CQE mode setting structure
2933	* @extack: extack for reporting error messages
2934	*
2935	* Gets the coalesce settings for a particular netdev. Note that if user has
2936	* modified per-queue settings, this only guarantees to represent queue 0. See
2937	* __i40e_get_coalesce for more details.
2938	**/
2939	static int i40e_get_coalesce(struct net_device *netdev,
2940	struct ethtool_coalesce *ec,
2941	struct kernel_ethtool_coalesce *kernel_coal,
2942	struct netlink_ext_ack *extack)
2943	{
2944	return __i40e_get_coalesce(netdev, ec, queue: -1);
2945	}
2946
2947	/**
2948	* i40e_get_per_queue_coalesce - gets coalesce settings for particular queue
2949	* @netdev: netdev structure
2950	* @ec: ethtool's coalesce settings
2951	* @queue: the particular queue to read
2952	*
2953	* Will read a specific queue's coalesce settings
2954	**/
2955	static int i40e_get_per_queue_coalesce(struct net_device *netdev, u32 queue,
2956	struct ethtool_coalesce *ec)
2957	{
2958	return __i40e_get_coalesce(netdev, ec, queue);
2959	}
2960
2961	/**
2962	* i40e_set_itr_per_queue - set ITR values for specific queue
2963	* @vsi: the VSI to set values for
2964	* @ec: coalesce settings from ethtool
2965	* @queue: the queue to modify
2966	*
2967	* Change the ITR settings for a specific queue.
2968	**/
2969	static void i40e_set_itr_per_queue(struct i40e_vsi *vsi,
2970	struct ethtool_coalesce *ec,
2971	int queue)
2972	{
2973	struct i40e_ring *rx_ring = vsi->rx_rings[queue];
2974	struct i40e_ring *tx_ring = vsi->tx_rings[queue];
2975	struct i40e_pf *pf = vsi->back;
2976	struct i40e_hw *hw = &pf->hw;
2977	struct i40e_q_vector *q_vector;
2978	u16 intrl;
2979
2980	intrl = i40e_intrl_usec_to_reg(intrl: vsi->int_rate_limit);
2981
2982	rx_ring->itr_setting = ITR_REG_ALIGN(ec->rx_coalesce_usecs);
2983	tx_ring->itr_setting = ITR_REG_ALIGN(ec->tx_coalesce_usecs);
2984
2985	if (ec->use_adaptive_rx_coalesce)
2986	rx_ring->itr_setting |= I40E_ITR_DYNAMIC;
2987	else
2988	rx_ring->itr_setting &= ~I40E_ITR_DYNAMIC;
2989
2990	if (ec->use_adaptive_tx_coalesce)
2991	tx_ring->itr_setting |= I40E_ITR_DYNAMIC;
2992	else
2993	tx_ring->itr_setting &= ~I40E_ITR_DYNAMIC;
2994
2995	q_vector = rx_ring->q_vector;
2996	q_vector->rx.target_itr = ITR_TO_REG(rx_ring->itr_setting);
2997
2998	q_vector = tx_ring->q_vector;
2999	q_vector->tx.target_itr = ITR_TO_REG(tx_ring->itr_setting);
3000
3001	/* The interrupt handler itself will take care of programming
3002	* the Tx and Rx ITR values based on the values we have entered
3003	* into the q_vector, no need to write the values now.
3004	*/
3005
3006	wr32(hw, I40E_PFINT_RATEN(q_vector->reg_idx), intrl);
3007	i40e_flush(hw);
3008	}
3009
3010	/**
3011	* __i40e_set_coalesce - set coalesce settings for particular queue
3012	* @netdev: the netdev to change
3013	* @ec: ethtool coalesce settings
3014	* @queue: the queue to change
3015	*
3016	* Sets the coalesce settings for a particular queue.
3017	**/
3018	static int __i40e_set_coalesce(struct net_device *netdev,
3019	struct ethtool_coalesce *ec,
3020	int queue)
3021	{
3022	struct i40e_netdev_priv *np = netdev_priv(dev: netdev);
3023	u16 intrl_reg, cur_rx_itr, cur_tx_itr;
3024	struct i40e_vsi *vsi = np->vsi;
3025	struct i40e_pf *pf = vsi->back;
3026	int i;
3027
3028	if (ec->tx_max_coalesced_frames_irq)
3029	vsi->work_limit = ec->tx_max_coalesced_frames_irq;
3030
3031	if (queue < 0) {
3032	cur_rx_itr = vsi->rx_rings[0]->itr_setting;
3033	cur_tx_itr = vsi->tx_rings[0]->itr_setting;
3034	} else if (queue < vsi->num_queue_pairs) {
3035	cur_rx_itr = vsi->rx_rings[queue]->itr_setting;
3036	cur_tx_itr = vsi->tx_rings[queue]->itr_setting;
3037	} else {
3038	netif_info(pf, drv, netdev, "Invalid queue value, queue range is 0 - %d\n",
3039	vsi->num_queue_pairs - 1);
3040	return -EINVAL;
3041	}
3042
3043	cur_tx_itr &= ~I40E_ITR_DYNAMIC;
3044	cur_rx_itr &= ~I40E_ITR_DYNAMIC;
3045
3046	/* tx_coalesce_usecs_high is ignored, use rx-usecs-high instead */
3047	if (ec->tx_coalesce_usecs_high != vsi->int_rate_limit) {
3048	netif_info(pf, drv, netdev, "tx-usecs-high is not used, please program rx-usecs-high\n");
3049	return -EINVAL;
3050	}
3051
3052	if (ec->rx_coalesce_usecs_high > INTRL_REG_TO_USEC(I40E_MAX_INTRL)) {
3053	netif_info(pf, drv, netdev, "Invalid value, rx-usecs-high range is 0-%lu\n",
3054	INTRL_REG_TO_USEC(I40E_MAX_INTRL));
3055	return -EINVAL;
3056	}
3057
3058	if (ec->rx_coalesce_usecs != cur_rx_itr &&
3059	ec->use_adaptive_rx_coalesce) {
3060	netif_info(pf, drv, netdev, "RX interrupt moderation cannot be changed if adaptive-rx is enabled.\n");
3061	return -EINVAL;
3062	}
3063
3064	if (ec->rx_coalesce_usecs > I40E_MAX_ITR) {
3065	netif_info(pf, drv, netdev, "Invalid value, rx-usecs range is 0-8160\n");
3066	return -EINVAL;
3067	}
3068
3069	if (ec->tx_coalesce_usecs != cur_tx_itr &&
3070	ec->use_adaptive_tx_coalesce) {
3071	netif_info(pf, drv, netdev, "TX interrupt moderation cannot be changed if adaptive-tx is enabled.\n");
3072	return -EINVAL;
3073	}
3074
3075	if (ec->tx_coalesce_usecs > I40E_MAX_ITR) {
3076	netif_info(pf, drv, netdev, "Invalid value, tx-usecs range is 0-8160\n");
3077	return -EINVAL;
3078	}
3079
3080	if (ec->use_adaptive_rx_coalesce && !cur_rx_itr)
3081	ec->rx_coalesce_usecs = I40E_MIN_ITR;
3082
3083	if (ec->use_adaptive_tx_coalesce && !cur_tx_itr)
3084	ec->tx_coalesce_usecs = I40E_MIN_ITR;
3085
3086	intrl_reg = i40e_intrl_usec_to_reg(intrl: ec->rx_coalesce_usecs_high);
3087	vsi->int_rate_limit = INTRL_REG_TO_USEC(intrl_reg);
3088	if (vsi->int_rate_limit != ec->rx_coalesce_usecs_high) {
3089	netif_info(pf, drv, netdev, "Interrupt rate limit rounded down to %d\n",
3090	vsi->int_rate_limit);
3091	}
3092
3093	/* rx and tx usecs has per queue value. If user doesn't specify the
3094	* queue, apply to all queues.
3095	*/
3096	if (queue < 0) {
3097	for (i = 0; i < vsi->num_queue_pairs; i++)
3098	i40e_set_itr_per_queue(vsi, ec, queue: i);
3099	} else {
3100	i40e_set_itr_per_queue(vsi, ec, queue);
3101	}
3102
3103	return 0;
3104	}
3105
3106	/**
3107	* i40e_set_coalesce - set coalesce settings for every queue on the netdev
3108	* @netdev: the netdev to change
3109	* @ec: ethtool coalesce settings
3110	* @kernel_coal: ethtool CQE mode setting structure
3111	* @extack: extack for reporting error messages
3112	*
3113	* This will set each queue to the same coalesce settings.
3114	**/
3115	static int i40e_set_coalesce(struct net_device *netdev,
3116	struct ethtool_coalesce *ec,
3117	struct kernel_ethtool_coalesce *kernel_coal,
3118	struct netlink_ext_ack *extack)
3119	{
3120	return __i40e_set_coalesce(netdev, ec, queue: -1);
3121	}
3122
3123	/**
3124	* i40e_set_per_queue_coalesce - set specific queue's coalesce settings
3125	* @netdev: the netdev to change
3126	* @ec: ethtool's coalesce settings
3127	* @queue: the queue to change
3128	*
3129	* Sets the specified queue's coalesce settings.
3130	**/
3131	static int i40e_set_per_queue_coalesce(struct net_device *netdev, u32 queue,
3132	struct ethtool_coalesce *ec)
3133	{
3134	return __i40e_set_coalesce(netdev, ec, queue);
3135	}
3136
3137	/**
3138	* i40e_get_rss_hash_opts - Get RSS hash Input Set for each flow type
3139	* @pf: pointer to the physical function struct
3140	* @cmd: ethtool rxnfc command
3141	*
3142	* Returns Success if the flow is supported, else Invalid Input.
3143	**/
3144	static int i40e_get_rss_hash_opts(struct i40e_pf *pf, struct ethtool_rxnfc *cmd)
3145	{
3146	struct i40e_hw *hw = &pf->hw;
3147	u8 flow_pctype = 0;
3148	u64 i_set = 0;
3149
3150	cmd->data = 0;
3151
3152	switch (cmd->flow_type) {
3153	case TCP_V4_FLOW:
3154	flow_pctype = I40E_FILTER_PCTYPE_NONF_IPV4_TCP;
3155	break;
3156	case UDP_V4_FLOW:
3157	flow_pctype = I40E_FILTER_PCTYPE_NONF_IPV4_UDP;
3158	break;
3159	case TCP_V6_FLOW:
3160	flow_pctype = I40E_FILTER_PCTYPE_NONF_IPV6_TCP;
3161	break;
3162	case UDP_V6_FLOW:
3163	flow_pctype = I40E_FILTER_PCTYPE_NONF_IPV6_UDP;
3164	break;
3165	case SCTP_V4_FLOW:
3166	case AH_ESP_V4_FLOW:
3167	case AH_V4_FLOW:
3168	case ESP_V4_FLOW:
3169	case IPV4_FLOW:
3170	case SCTP_V6_FLOW:
3171	case AH_ESP_V6_FLOW:
3172	case AH_V6_FLOW:
3173	case ESP_V6_FLOW:
3174	case IPV6_FLOW:
3175	/* Default is src/dest for IP, no matter the L4 hashing */
3176	cmd->data |= RXH_IP_SRC | RXH_IP_DST;
3177	break;
3178	default:
3179	return -EINVAL;
3180	}
3181
3182	/* Read flow based hash input set register */
3183	if (flow_pctype) {
3184	i_set = (u64)i40e_read_rx_ctl(hw, I40E_GLQF_HASH_INSET(0,
3185	flow_pctype)) |
3186	((u64)i40e_read_rx_ctl(hw, I40E_GLQF_HASH_INSET(1,
3187	flow_pctype)) << 32);
3188	}
3189
3190	/* Process bits of hash input set */
3191	if (i_set) {
3192	if (i_set & I40E_L4_SRC_MASK)
3193	cmd->data |= RXH_L4_B_0_1;
3194	if (i_set & I40E_L4_DST_MASK)
3195	cmd->data |= RXH_L4_B_2_3;
3196
3197	if (cmd->flow_type == TCP_V4_FLOW ||
3198	cmd->flow_type == UDP_V4_FLOW) {
3199	if (hw->mac.type == I40E_MAC_X722) {
3200	if (i_set & I40E_X722_L3_SRC_MASK)
3201	cmd->data |= RXH_IP_SRC;
3202	if (i_set & I40E_X722_L3_DST_MASK)
3203	cmd->data |= RXH_IP_DST;
3204	} else {
3205	if (i_set & I40E_L3_SRC_MASK)
3206	cmd->data |= RXH_IP_SRC;
3207	if (i_set & I40E_L3_DST_MASK)
3208	cmd->data |= RXH_IP_DST;
3209	}
3210	} else if (cmd->flow_type == TCP_V6_FLOW ||
3211	cmd->flow_type == UDP_V6_FLOW) {
3212	if (i_set & I40E_L3_V6_SRC_MASK)
3213	cmd->data |= RXH_IP_SRC;
3214	if (i_set & I40E_L3_V6_DST_MASK)
3215	cmd->data |= RXH_IP_DST;
3216	}
3217	}
3218
3219	return 0;
3220	}
3221
3222	/**
3223	* i40e_check_mask - Check whether a mask field is set
3224	* @mask: the full mask value
3225	* @field: mask of the field to check
3226	*
3227	* If the given mask is fully set, return positive value. If the mask for the
3228	* field is fully unset, return zero. Otherwise return a negative error code.
3229	**/
3230	static int i40e_check_mask(u64 mask, u64 field)
3231	{
3232	u64 value = mask & field;
3233
3234	if (value == field)
3235	return 1;
3236	else if (!value)
3237	return 0;
3238	else
3239	return -1;
3240	}
3241
3242	/**
3243	* i40e_parse_rx_flow_user_data - Deconstruct user-defined data
3244	* @fsp: pointer to rx flow specification
3245	* @data: pointer to userdef data structure for storage
3246	*
3247	* Read the user-defined data and deconstruct the value into a structure. No
3248	* other code should read the user-defined data, so as to ensure that every
3249	* place consistently reads the value correctly.
3250	*
3251	* The user-defined field is a 64bit Big Endian format value, which we
3252	* deconstruct by reading bits or bit fields from it. Single bit flags shall
3253	* be defined starting from the highest bits, while small bit field values
3254	* shall be defined starting from the lowest bits.
3255	*
3256	* Returns 0 if the data is valid, and non-zero if the userdef data is invalid
3257	* and the filter should be rejected. The data structure will always be
3258	* modified even if FLOW_EXT is not set.
3259	*
3260	**/
3261	static int i40e_parse_rx_flow_user_data(struct ethtool_rx_flow_spec *fsp,
3262	struct i40e_rx_flow_userdef *data)
3263	{
3264	u64 value, mask;
3265	int valid;
3266
3267	/* Zero memory first so it's always consistent. */
3268	memset(data, 0, sizeof(*data));
3269
3270	if (!(fsp->flow_type & FLOW_EXT))
3271	return 0;
3272
3273	value = be64_to_cpu(*((__be64 *)fsp->h_ext.data));
3274	mask = be64_to_cpu(*((__be64 *)fsp->m_ext.data));
3275
3276	#define I40E_USERDEF_FLEX_WORD GENMASK_ULL(15, 0)
3277	#define I40E_USERDEF_FLEX_OFFSET GENMASK_ULL(31, 16)
3278	#define I40E_USERDEF_FLEX_FILTER GENMASK_ULL(31, 0)
3279
3280	valid = i40e_check_mask(mask, I40E_USERDEF_FLEX_FILTER);
3281	if (valid < 0) {
3282	return -EINVAL;
3283	} else if (valid) {
3284	data->flex_word = value & I40E_USERDEF_FLEX_WORD;
3285	data->flex_offset =
3286	FIELD_GET(I40E_USERDEF_FLEX_OFFSET, value);
3287	data->flex_filter = true;
3288	}
3289
3290	return 0;
3291	}
3292
3293	/**
3294	* i40e_fill_rx_flow_user_data - Fill in user-defined data field
3295	* @fsp: pointer to rx_flow specification
3296	* @data: pointer to return userdef data
3297	*
3298	* Reads the userdef data structure and properly fills in the user defined
3299	* fields of the rx_flow_spec.
3300	**/
3301	static void i40e_fill_rx_flow_user_data(struct ethtool_rx_flow_spec *fsp,
3302	struct i40e_rx_flow_userdef *data)
3303	{
3304	u64 value = 0, mask = 0;
3305
3306	if (data->flex_filter) {
3307	value |= data->flex_word;
3308	value |= (u64)data->flex_offset << 16;
3309	mask |= I40E_USERDEF_FLEX_FILTER;
3310	}
3311
3312	if (value || mask)
3313	fsp->flow_type |= FLOW_EXT;
3314
3315	*((__be64 *)fsp->h_ext.data) = cpu_to_be64(value);
3316	*((__be64 *)fsp->m_ext.data) = cpu_to_be64(mask);
3317	}
3318
3319	/**
3320	* i40e_get_ethtool_fdir_all - Populates the rule count of a command
3321	* @pf: Pointer to the physical function struct
3322	* @cmd: The command to get or set Rx flow classification rules
3323	* @rule_locs: Array of used rule locations
3324	*
3325	* This function populates both the total and actual rule count of
3326	* the ethtool flow classification command
3327	*
3328	* Returns 0 on success or -EMSGSIZE if entry not found
3329	**/
3330	static int i40e_get_ethtool_fdir_all(struct i40e_pf *pf,
3331	struct ethtool_rxnfc *cmd,
3332	u32 *rule_locs)
3333	{
3334	struct i40e_fdir_filter *rule;
3335	struct hlist_node *node2;
3336	int cnt = 0;
3337
3338	/* report total rule count */
3339	cmd->data = i40e_get_fd_cnt_all(pf);
3340
3341	hlist_for_each_entry_safe(rule, node2,
3342	&pf->fdir_filter_list, fdir_node) {
3343	if (cnt == cmd->rule_cnt)
3344	return -EMSGSIZE;
3345
3346	rule_locs[cnt] = rule->fd_id;
3347	cnt++;
3348	}
3349
3350	cmd->rule_cnt = cnt;
3351
3352	return 0;
3353	}
3354
3355	/**
3356	* i40e_get_ethtool_fdir_entry - Look up a filter based on Rx flow
3357	* @pf: Pointer to the physical function struct
3358	* @cmd: The command to get or set Rx flow classification rules
3359	*
3360	* This function looks up a filter based on the Rx flow classification
3361	* command and fills the flow spec info for it if found
3362	*
3363	* Returns 0 on success or -EINVAL if filter not found
3364	**/
3365	static int i40e_get_ethtool_fdir_entry(struct i40e_pf *pf,
3366	struct ethtool_rxnfc *cmd)
3367	{
3368	struct ethtool_rx_flow_spec *fsp =
3369	(struct ethtool_rx_flow_spec *)&cmd->fs;
3370	struct i40e_rx_flow_userdef userdef = {0};
3371	struct i40e_fdir_filter *rule = NULL;
3372	struct hlist_node *node2;
3373	u64 input_set;
3374	u16 index;
3375
3376	hlist_for_each_entry_safe(rule, node2,
3377	&pf->fdir_filter_list, fdir_node) {
3378	if (fsp->location <= rule->fd_id)
3379	break;
3380	}
3381
3382	if (!rule || fsp->location != rule->fd_id)
3383	return -EINVAL;
3384
3385	fsp->flow_type = rule->flow_type;
3386	if (fsp->flow_type == IP_USER_FLOW) {
3387	fsp->h_u.usr_ip4_spec.ip_ver = ETH_RX_NFC_IP4;
3388	fsp->h_u.usr_ip4_spec.proto = 0;
3389	fsp->m_u.usr_ip4_spec.proto = 0;
3390	}
3391
3392	if (fsp->flow_type == IPV6_USER_FLOW ||
3393	fsp->flow_type == UDP_V6_FLOW ||
3394	fsp->flow_type == TCP_V6_FLOW ||
3395	fsp->flow_type == SCTP_V6_FLOW) {
3396	/* Reverse the src and dest notion, since the HW views them
3397	* from Tx perspective where as the user expects it from
3398	* Rx filter view.
3399	*/
3400	fsp->h_u.tcp_ip6_spec.psrc = rule->dst_port;
3401	fsp->h_u.tcp_ip6_spec.pdst = rule->src_port;
3402	memcpy(fsp->h_u.tcp_ip6_spec.ip6dst, rule->src_ip6,
3403	sizeof(__be32) * 4);
3404	memcpy(fsp->h_u.tcp_ip6_spec.ip6src, rule->dst_ip6,
3405	sizeof(__be32) * 4);
3406	} else {
3407	/* Reverse the src and dest notion, since the HW views them
3408	* from Tx perspective where as the user expects it from
3409	* Rx filter view.
3410	*/
3411	fsp->h_u.tcp_ip4_spec.psrc = rule->dst_port;
3412	fsp->h_u.tcp_ip4_spec.pdst = rule->src_port;
3413	fsp->h_u.tcp_ip4_spec.ip4src = rule->dst_ip;
3414	fsp->h_u.tcp_ip4_spec.ip4dst = rule->src_ip;
3415	}
3416
3417	switch (rule->flow_type) {
3418	case SCTP_V4_FLOW:
3419	index = I40E_FILTER_PCTYPE_NONF_IPV4_SCTP;
3420	break;
3421	case TCP_V4_FLOW:
3422	index = I40E_FILTER_PCTYPE_NONF_IPV4_TCP;
3423	break;
3424	case UDP_V4_FLOW:
3425	index = I40E_FILTER_PCTYPE_NONF_IPV4_UDP;
3426	break;
3427	case SCTP_V6_FLOW:
3428	index = I40E_FILTER_PCTYPE_NONF_IPV6_SCTP;
3429	break;
3430	case TCP_V6_FLOW:
3431	index = I40E_FILTER_PCTYPE_NONF_IPV6_TCP;
3432	break;
3433	case UDP_V6_FLOW:
3434	index = I40E_FILTER_PCTYPE_NONF_IPV6_UDP;
3435	break;
3436	case IP_USER_FLOW:
3437	index = I40E_FILTER_PCTYPE_NONF_IPV4_OTHER;
3438	break;
3439	case IPV6_USER_FLOW:
3440	index = I40E_FILTER_PCTYPE_NONF_IPV6_OTHER;
3441	break;
3442	default:
3443	/* If we have stored a filter with a flow type not listed here
3444	* it is almost certainly a driver bug. WARN(), and then
3445	* assign the input_set as if all fields are enabled to avoid
3446	* reading unassigned memory.
3447	*/
3448	WARN(1, "Missing input set index for flow_type %d\n",
3449	rule->flow_type);
3450	input_set = 0xFFFFFFFFFFFFFFFFULL;
3451	goto no_input_set;
3452	}
3453
3454	input_set = i40e_read_fd_input_set(pf, addr: index);
3455
3456	no_input_set:
3457	if (input_set & I40E_L3_V6_SRC_MASK) {
3458	fsp->m_u.tcp_ip6_spec.ip6src[0] = htonl(0xFFFFFFFF);
3459	fsp->m_u.tcp_ip6_spec.ip6src[1] = htonl(0xFFFFFFFF);
3460	fsp->m_u.tcp_ip6_spec.ip6src[2] = htonl(0xFFFFFFFF);
3461	fsp->m_u.tcp_ip6_spec.ip6src[3] = htonl(0xFFFFFFFF);
3462	}
3463
3464	if (input_set & I40E_L3_V6_DST_MASK) {
3465	fsp->m_u.tcp_ip6_spec.ip6dst[0] = htonl(0xFFFFFFFF);
3466	fsp->m_u.tcp_ip6_spec.ip6dst[1] = htonl(0xFFFFFFFF);
3467	fsp->m_u.tcp_ip6_spec.ip6dst[2] = htonl(0xFFFFFFFF);
3468	fsp->m_u.tcp_ip6_spec.ip6dst[3] = htonl(0xFFFFFFFF);
3469	}
3470
3471	if (input_set & I40E_L3_SRC_MASK)
3472	fsp->m_u.tcp_ip4_spec.ip4src = htonl(0xFFFFFFFF);
3473
3474	if (input_set & I40E_L3_DST_MASK)
3475	fsp->m_u.tcp_ip4_spec.ip4dst = htonl(0xFFFFFFFF);
3476
3477	if (input_set & I40E_L4_SRC_MASK)
3478	fsp->m_u.tcp_ip4_spec.psrc = htons(0xFFFF);
3479
3480	if (input_set & I40E_L4_DST_MASK)
3481	fsp->m_u.tcp_ip4_spec.pdst = htons(0xFFFF);
3482
3483	if (rule->dest_ctl == I40E_FILTER_PROGRAM_DESC_DEST_DROP_PACKET)
3484	fsp->ring_cookie = RX_CLS_FLOW_DISC;
3485	else
3486	fsp->ring_cookie = rule->q_index;
3487
3488	if (rule->vlan_tag) {
3489	fsp->h_ext.vlan_etype = rule->vlan_etype;
3490	fsp->m_ext.vlan_etype = htons(0xFFFF);
3491	fsp->h_ext.vlan_tci = rule->vlan_tag;
3492	fsp->m_ext.vlan_tci = htons(0xFFFF);
3493	fsp->flow_type |= FLOW_EXT;
3494	}
3495
3496	if (rule->dest_vsi != pf->vsi[pf->lan_vsi]->id) {
3497	struct i40e_vsi *vsi;
3498
3499	vsi = i40e_find_vsi_from_id(pf, id: rule->dest_vsi);
3500	if (vsi && vsi->type == I40E_VSI_SRIOV) {
3501	/* VFs are zero-indexed by the driver, but ethtool
3502	* expects them to be one-indexed, so add one here
3503	*/
3504	u64 ring_vf = vsi->vf_id + 1;
3505
3506	ring_vf <<= ETHTOOL_RX_FLOW_SPEC_RING_VF_OFF;
3507	fsp->ring_cookie |= ring_vf;
3508	}
3509	}
3510
3511	if (rule->flex_filter) {
3512	userdef.flex_filter = true;
3513	userdef.flex_word = be16_to_cpu(rule->flex_word);
3514	userdef.flex_offset = rule->flex_offset;
3515	}
3516
3517	i40e_fill_rx_flow_user_data(fsp, data: &userdef);
3518
3519	return 0;
3520	}
3521
3522	/**
3523	* i40e_get_rxnfc - command to get RX flow classification rules
3524	* @netdev: network interface device structure
3525	* @cmd: ethtool rxnfc command
3526	* @rule_locs: pointer to store rule data
3527	*
3528	* Returns Success if the command is supported.
3529	**/
3530	static int i40e_get_rxnfc(struct net_device *netdev, struct ethtool_rxnfc *cmd,
3531	u32 *rule_locs)
3532	{
3533	struct i40e_netdev_priv *np = netdev_priv(dev: netdev);
3534	struct i40e_vsi *vsi = np->vsi;
3535	struct i40e_pf *pf = vsi->back;
3536	int ret = -EOPNOTSUPP;
3537
3538	switch (cmd->cmd) {
3539	case ETHTOOL_GRXRINGS:
3540	cmd->data = vsi->rss_size;
3541	ret = 0;
3542	break;
3543	case ETHTOOL_GRXFH:
3544	ret = i40e_get_rss_hash_opts(pf, cmd);
3545	break;
3546	case ETHTOOL_GRXCLSRLCNT:
3547	cmd->rule_cnt = pf->fdir_pf_active_filters;
3548	/* report total rule count */
3549	cmd->data = i40e_get_fd_cnt_all(pf);
3550	ret = 0;
3551	break;
3552	case ETHTOOL_GRXCLSRULE:
3553	ret = i40e_get_ethtool_fdir_entry(pf, cmd);
3554	break;
3555	case ETHTOOL_GRXCLSRLALL:
3556	ret = i40e_get_ethtool_fdir_all(pf, cmd, rule_locs);
3557	break;
3558	default:
3559	break;
3560	}
3561
3562	return ret;
3563	}
3564
3565	/**
3566	* i40e_get_rss_hash_bits - Read RSS Hash bits from register
3567	* @hw: hw structure
3568	* @nfc: pointer to user request
3569	* @i_setc: bits currently set
3570	*
3571	* Returns value of bits to be set per user request
3572	**/
3573	static u64 i40e_get_rss_hash_bits(struct i40e_hw *hw,
3574	struct ethtool_rxnfc *nfc,
3575	u64 i_setc)
3576	{
3577	u64 i_set = i_setc;
3578	u64 src_l3 = 0, dst_l3 = 0;
3579
3580	if (nfc->data & RXH_L4_B_0_1)
3581	i_set |= I40E_L4_SRC_MASK;
3582	else
3583	i_set &= ~I40E_L4_SRC_MASK;
3584	if (nfc->data & RXH_L4_B_2_3)
3585	i_set |= I40E_L4_DST_MASK;
3586	else
3587	i_set &= ~I40E_L4_DST_MASK;
3588
3589	if (nfc->flow_type == TCP_V6_FLOW || nfc->flow_type == UDP_V6_FLOW) {
3590	src_l3 = I40E_L3_V6_SRC_MASK;
3591	dst_l3 = I40E_L3_V6_DST_MASK;
3592	} else if (nfc->flow_type == TCP_V4_FLOW ||
3593	nfc->flow_type == UDP_V4_FLOW) {
3594	if (hw->mac.type == I40E_MAC_X722) {
3595	src_l3 = I40E_X722_L3_SRC_MASK;
3596	dst_l3 = I40E_X722_L3_DST_MASK;
3597	} else {
3598	src_l3 = I40E_L3_SRC_MASK;
3599	dst_l3 = I40E_L3_DST_MASK;
3600	}
3601	} else {
3602	/* Any other flow type are not supported here */
3603	return i_set;
3604	}
3605
3606	if (nfc->data & RXH_IP_SRC)
3607	i_set |= src_l3;
3608	else
3609	i_set &= ~src_l3;
3610	if (nfc->data & RXH_IP_DST)
3611	i_set |= dst_l3;
3612	else
3613	i_set &= ~dst_l3;
3614
3615	return i_set;
3616	}
3617
3618	#define FLOW_PCTYPES_SIZE 64
3619	/**
3620	* i40e_set_rss_hash_opt - Enable/Disable flow types for RSS hash
3621	* @pf: pointer to the physical function struct
3622	* @nfc: ethtool rxnfc command
3623	*
3624	* Returns Success if the flow input set is supported.
3625	**/
3626	static int i40e_set_rss_hash_opt(struct i40e_pf *pf, struct ethtool_rxnfc *nfc)
3627	{
3628	struct i40e_hw *hw = &pf->hw;
3629	u64 hena = (u64)i40e_read_rx_ctl(hw, I40E_PFQF_HENA(0)) |
3630	((u64)i40e_read_rx_ctl(hw, I40E_PFQF_HENA(1)) << 32);
3631	DECLARE_BITMAP(flow_pctypes, FLOW_PCTYPES_SIZE);
3632	u64 i_set, i_setc;
3633
3634	bitmap_zero(dst: flow_pctypes, FLOW_PCTYPES_SIZE);
3635
3636	if (test_bit(I40E_FLAG_MFP_ENA, pf->flags)) {
3637	dev_err(&pf->pdev->dev,
3638	"Change of RSS hash input set is not supported when MFP mode is enabled\n");
3639	return -EOPNOTSUPP;
3640	}
3641
3642	/* RSS does not support anything other than hashing
3643	* to queues on src and dst IPs and ports
3644	*/
3645	if (nfc->data & ~(RXH_IP_SRC | RXH_IP_DST |
3646	RXH_L4_B_0_1 | RXH_L4_B_2_3))
3647	return -EINVAL;
3648
3649	switch (nfc->flow_type) {
3650	case TCP_V4_FLOW:
3651	set_bit(nr: I40E_FILTER_PCTYPE_NONF_IPV4_TCP, addr: flow_pctypes);
3652	if (test_bit(I40E_HW_CAP_MULTI_TCP_UDP_RSS_PCTYPE,
3653	pf->hw.caps))
3654	set_bit(nr: I40E_FILTER_PCTYPE_NONF_IPV4_TCP_SYN_NO_ACK,
3655	addr: flow_pctypes);
3656	break;
3657	case TCP_V6_FLOW:
3658	set_bit(nr: I40E_FILTER_PCTYPE_NONF_IPV6_TCP, addr: flow_pctypes);
3659	if (test_bit(I40E_HW_CAP_MULTI_TCP_UDP_RSS_PCTYPE,
3660	pf->hw.caps))
3661	set_bit(nr: I40E_FILTER_PCTYPE_NONF_IPV6_TCP_SYN_NO_ACK,
3662	addr: flow_pctypes);
3663	break;
3664	case UDP_V4_FLOW:
3665	set_bit(nr: I40E_FILTER_PCTYPE_NONF_IPV4_UDP, addr: flow_pctypes);
3666	if (test_bit(I40E_HW_CAP_MULTI_TCP_UDP_RSS_PCTYPE,
3667	pf->hw.caps)) {
3668	set_bit(nr: I40E_FILTER_PCTYPE_NONF_UNICAST_IPV4_UDP,
3669	addr: flow_pctypes);
3670	set_bit(nr: I40E_FILTER_PCTYPE_NONF_MULTICAST_IPV4_UDP,
3671	addr: flow_pctypes);
3672	}
3673	hena |= BIT_ULL(I40E_FILTER_PCTYPE_FRAG_IPV4);
3674	break;
3675	case UDP_V6_FLOW:
3676	set_bit(nr: I40E_FILTER_PCTYPE_NONF_IPV6_UDP, addr: flow_pctypes);
3677	if (test_bit(I40E_HW_CAP_MULTI_TCP_UDP_RSS_PCTYPE,
3678	pf->hw.caps)) {
3679	set_bit(nr: I40E_FILTER_PCTYPE_NONF_UNICAST_IPV6_UDP,
3680	addr: flow_pctypes);
3681	set_bit(nr: I40E_FILTER_PCTYPE_NONF_MULTICAST_IPV6_UDP,
3682	addr: flow_pctypes);
3683	}
3684	hena |= BIT_ULL(I40E_FILTER_PCTYPE_FRAG_IPV6);
3685	break;
3686	case AH_ESP_V4_FLOW:
3687	case AH_V4_FLOW:
3688	case ESP_V4_FLOW:
3689	case SCTP_V4_FLOW:
3690	if ((nfc->data & RXH_L4_B_0_1) ||
3691	(nfc->data & RXH_L4_B_2_3))
3692	return -EINVAL;
3693	hena |= BIT_ULL(I40E_FILTER_PCTYPE_NONF_IPV4_OTHER);
3694	break;
3695	case AH_ESP_V6_FLOW:
3696	case AH_V6_FLOW:
3697	case ESP_V6_FLOW:
3698	case SCTP_V6_FLOW:
3699	if ((nfc->data & RXH_L4_B_0_1) ||
3700	(nfc->data & RXH_L4_B_2_3))
3701	return -EINVAL;
3702	hena |= BIT_ULL(I40E_FILTER_PCTYPE_NONF_IPV6_OTHER);
3703	break;
3704	case IPV4_FLOW:
3705	hena |= BIT_ULL(I40E_FILTER_PCTYPE_NONF_IPV4_OTHER) |
3706	BIT_ULL(I40E_FILTER_PCTYPE_FRAG_IPV4);
3707	break;
3708	case IPV6_FLOW:
3709	hena |= BIT_ULL(I40E_FILTER_PCTYPE_NONF_IPV6_OTHER) |
3710	BIT_ULL(I40E_FILTER_PCTYPE_FRAG_IPV6);
3711	break;
3712	default:
3713	return -EINVAL;
3714	}
3715
3716	if (bitmap_weight(src: flow_pctypes, FLOW_PCTYPES_SIZE)) {
3717	u8 flow_id;
3718
3719	for_each_set_bit(flow_id, flow_pctypes, FLOW_PCTYPES_SIZE) {
3720	i_setc = (u64)i40e_read_rx_ctl(hw, I40E_GLQF_HASH_INSET(0, flow_id)) |
3721	((u64)i40e_read_rx_ctl(hw, I40E_GLQF_HASH_INSET(1, flow_id)) << 32);
3722	i_set = i40e_get_rss_hash_bits(hw: &pf->hw, nfc, i_setc);
3723
3724	i40e_write_rx_ctl(hw, I40E_GLQF_HASH_INSET(0, flow_id),
3725	reg_val: (u32)i_set);
3726	i40e_write_rx_ctl(hw, I40E_GLQF_HASH_INSET(1, flow_id),
3727	reg_val: (u32)(i_set >> 32));
3728	hena |= BIT_ULL(flow_id);
3729	}
3730	}
3731
3732	i40e_write_rx_ctl(hw, I40E_PFQF_HENA(0), reg_val: (u32)hena);
3733	i40e_write_rx_ctl(hw, I40E_PFQF_HENA(1), reg_val: (u32)(hena >> 32));
3734	i40e_flush(hw);
3735
3736	return 0;
3737	}
3738
3739	/**
3740	* i40e_update_ethtool_fdir_entry - Updates the fdir filter entry
3741	* @vsi: Pointer to the targeted VSI
3742	* @input: The filter to update or NULL to indicate deletion
3743	* @sw_idx: Software index to the filter
3744	* @cmd: The command to get or set Rx flow classification rules
3745	*
3746	* This function updates (or deletes) a Flow Director entry from
3747	* the hlist of the corresponding PF
3748	*
3749	* Returns 0 on success
3750	**/
3751	static int i40e_update_ethtool_fdir_entry(struct i40e_vsi *vsi,
3752	struct i40e_fdir_filter *input,
3753	u16 sw_idx,
3754	struct ethtool_rxnfc *cmd)
3755	{
3756	struct i40e_fdir_filter *rule, *parent;
3757	struct i40e_pf *pf = vsi->back;
3758	struct hlist_node *node2;
3759	int err = -EINVAL;
3760
3761	parent = NULL;
3762	rule = NULL;
3763
3764	hlist_for_each_entry_safe(rule, node2,
3765	&pf->fdir_filter_list, fdir_node) {
3766	/* hash found, or no matching entry */
3767	if (rule->fd_id >= sw_idx)
3768	break;
3769	parent = rule;
3770	}
3771
3772	/* if there is an old rule occupying our place remove it */
3773	if (rule && (rule->fd_id == sw_idx)) {
3774	/* Remove this rule, since we're either deleting it, or
3775	* replacing it.
3776	*/
3777	err = i40e_add_del_fdir(vsi, input: rule, add: false);
3778	hlist_del(n: &rule->fdir_node);
3779	kfree(objp: rule);
3780	pf->fdir_pf_active_filters--;
3781	}
3782
3783	/* If we weren't given an input, this is a delete, so just return the
3784	* error code indicating if there was an entry at the requested slot
3785	*/
3786	if (!input)
3787	return err;
3788
3789	/* Otherwise, install the new rule as requested */
3790	INIT_HLIST_NODE(h: &input->fdir_node);
3791
3792	/* add filter to the list */
3793	if (parent)
3794	hlist_add_behind(n: &input->fdir_node, prev: &parent->fdir_node);
3795	else
3796	hlist_add_head(n: &input->fdir_node,
3797	h: &pf->fdir_filter_list);
3798
3799	/* update counts */
3800	pf->fdir_pf_active_filters++;
3801
3802	return 0;
3803	}
3804
3805	/**
3806	* i40e_prune_flex_pit_list - Cleanup unused entries in FLX_PIT table
3807	* @pf: pointer to PF structure
3808	*
3809	* This function searches the list of filters and determines which FLX_PIT
3810	* entries are still required. It will prune any entries which are no longer
3811	* in use after the deletion.
3812	**/
3813	static void i40e_prune_flex_pit_list(struct i40e_pf *pf)
3814	{
3815	struct i40e_flex_pit *entry, *tmp;
3816	struct i40e_fdir_filter *rule;
3817
3818	/* First, we'll check the l3 table */
3819	list_for_each_entry_safe(entry, tmp, &pf->l3_flex_pit_list, list) {
3820	bool found = false;
3821
3822	hlist_for_each_entry(rule, &pf->fdir_filter_list, fdir_node) {
3823	if (rule->flow_type != IP_USER_FLOW)
3824	continue;
3825	if (rule->flex_filter &&
3826	rule->flex_offset == entry->src_offset) {
3827	found = true;
3828	break;
3829	}
3830	}
3831
3832	/* If we didn't find the filter, then we can prune this entry
3833	* from the list.
3834	*/
3835	if (!found) {
3836	list_del(entry: &entry->list);
3837	kfree(objp: entry);
3838	}
3839	}
3840
3841	/* Followed by the L4 table */
3842	list_for_each_entry_safe(entry, tmp, &pf->l4_flex_pit_list, list) {
3843	bool found = false;
3844
3845	hlist_for_each_entry(rule, &pf->fdir_filter_list, fdir_node) {
3846	/* Skip this filter if it's L3, since we already
3847	* checked those in the above loop
3848	*/
3849	if (rule->flow_type == IP_USER_FLOW)
3850	continue;
3851	if (rule->flex_filter &&
3852	rule->flex_offset == entry->src_offset) {
3853	found = true;
3854	break;
3855	}
3856	}
3857
3858	/* If we didn't find the filter, then we can prune this entry
3859	* from the list.
3860	*/
3861	if (!found) {
3862	list_del(entry: &entry->list);
3863	kfree(objp: entry);
3864	}
3865	}
3866	}
3867
3868	/**
3869	* i40e_del_fdir_entry - Deletes a Flow Director filter entry
3870	* @vsi: Pointer to the targeted VSI
3871	* @cmd: The command to get or set Rx flow classification rules
3872	*
3873	* The function removes a Flow Director filter entry from the
3874	* hlist of the corresponding PF
3875	*
3876	* Returns 0 on success
3877	*/
3878	static int i40e_del_fdir_entry(struct i40e_vsi *vsi,
3879	struct ethtool_rxnfc *cmd)
3880	{
3881	struct ethtool_rx_flow_spec *fsp =
3882	(struct ethtool_rx_flow_spec *)&cmd->fs;
3883	struct i40e_pf *pf = vsi->back;
3884	int ret = 0;
3885
3886	if (test_bit(__I40E_RESET_RECOVERY_PENDING, pf->state) ||
3887	test_bit(__I40E_RESET_INTR_RECEIVED, pf->state))
3888	return -EBUSY;
3889
3890	if (test_bit(__I40E_FD_FLUSH_REQUESTED, pf->state))
3891	return -EBUSY;
3892
3893	ret = i40e_update_ethtool_fdir_entry(vsi, NULL, sw_idx: fsp->location, cmd);
3894
3895	i40e_prune_flex_pit_list(pf);
3896
3897	i40e_fdir_check_and_reenable(pf);
3898	return ret;
3899	}
3900
3901	/**
3902	* i40e_unused_pit_index - Find an unused PIT index for given list
3903	* @pf: the PF data structure
3904	*
3905	* Find the first unused flexible PIT index entry. We search both the L3 and
3906	* L4 flexible PIT lists so that the returned index is unique and unused by
3907	* either currently programmed L3 or L4 filters. We use a bit field as storage
3908	* to track which indexes are already used.
3909	**/
3910	static u8 i40e_unused_pit_index(struct i40e_pf *pf)
3911	{
3912	unsigned long available_index = 0xFF;
3913	struct i40e_flex_pit *entry;
3914
3915	/* We need to make sure that the new index isn't in use by either L3
3916	* or L4 filters so that IP_USER_FLOW filters can program both L3 and
3917	* L4 to use the same index.
3918	*/
3919
3920	list_for_each_entry(entry, &pf->l4_flex_pit_list, list)
3921	clear_bit(nr: entry->pit_index, addr: &available_index);
3922
3923	list_for_each_entry(entry, &pf->l3_flex_pit_list, list)
3924	clear_bit(nr: entry->pit_index, addr: &available_index);
3925
3926	return find_first_bit(addr: &available_index, size: 8);
3927	}
3928
3929	/**
3930	* i40e_find_flex_offset - Find an existing flex src_offset
3931	* @flex_pit_list: L3 or L4 flex PIT list
3932	* @src_offset: new src_offset to find
3933	*
3934	* Searches the flex_pit_list for an existing offset. If no offset is
3935	* currently programmed, then this will return an ERR_PTR if there is no space
3936	* to add a new offset, otherwise it returns NULL.
3937	**/
3938	static
3939	struct i40e_flex_pit *i40e_find_flex_offset(struct list_head *flex_pit_list,
3940	u16 src_offset)
3941	{
3942	struct i40e_flex_pit *entry;
3943	int size = 0;
3944
3945	/* Search for the src_offset first. If we find a matching entry
3946	* already programmed, we can simply re-use it.
3947	*/
3948	list_for_each_entry(entry, flex_pit_list, list) {
3949	size++;
3950	if (entry->src_offset == src_offset)
3951	return entry;
3952	}
3953
3954	/* If we haven't found an entry yet, then the provided src offset has
3955	* not yet been programmed. We will program the src offset later on,
3956	* but we need to indicate whether there is enough space to do so
3957	* here. We'll make use of ERR_PTR for this purpose.
3958	*/
3959	if (size >= I40E_FLEX_PIT_TABLE_SIZE)
3960	return ERR_PTR(error: -ENOSPC);
3961
3962	return NULL;
3963	}
3964
3965	/**
3966	* i40e_add_flex_offset - Add src_offset to flex PIT table list
3967	* @flex_pit_list: L3 or L4 flex PIT list
3968	* @src_offset: new src_offset to add
3969	* @pit_index: the PIT index to program
3970	*
3971	* This function programs the new src_offset to the list. It is expected that
3972	* i40e_find_flex_offset has already been tried and returned NULL, indicating
3973	* that this offset is not programmed, and that the list has enough space to
3974	* store another offset.
3975	*
3976	* Returns 0 on success, and negative value on error.
3977	**/
3978	static int i40e_add_flex_offset(struct list_head *flex_pit_list,
3979	u16 src_offset,
3980	u8 pit_index)
3981	{
3982	struct i40e_flex_pit *new_pit, *entry;
3983
3984	new_pit = kzalloc(size: sizeof(*entry), GFP_KERNEL);
3985	if (!new_pit)
3986	return -ENOMEM;
3987
3988	new_pit->src_offset = src_offset;
3989	new_pit->pit_index = pit_index;
3990
3991	/* We need to insert this item such that the list is sorted by
3992	* src_offset in ascending order.
3993	*/
3994	list_for_each_entry(entry, flex_pit_list, list) {
3995	if (new_pit->src_offset < entry->src_offset) {
3996	list_add_tail(new: &new_pit->list, head: &entry->list);
3997	return 0;
3998	}
3999
4000	/* If we found an entry with our offset already programmed we
4001	* can simply return here, after freeing the memory. However,
4002	* if the pit_index does not match we need to report an error.
4003	*/
4004	if (new_pit->src_offset == entry->src_offset) {
4005	int err = 0;
4006
4007	/* If the PIT index is not the same we can't re-use
4008	* the entry, so we must report an error.
4009	*/
4010	if (new_pit->pit_index != entry->pit_index)
4011	err = -EINVAL;
4012
4013	kfree(objp: new_pit);
4014	return err;
4015	}
4016	}
4017
4018	/* If we reached here, then we haven't yet added the item. This means
4019	* that we should add the item at the end of the list.
4020	*/
4021	list_add_tail(new: &new_pit->list, head: flex_pit_list);
4022	return 0;
4023	}
4024
4025	/**
4026	* __i40e_reprogram_flex_pit - Re-program specific FLX_PIT table
4027	* @pf: Pointer to the PF structure
4028	* @flex_pit_list: list of flexible src offsets in use
4029	* @flex_pit_start: index to first entry for this section of the table
4030	*
4031	* In order to handle flexible data, the hardware uses a table of values
4032	* called the FLX_PIT table. This table is used to indicate which sections of
4033	* the input correspond to what PIT index values. Unfortunately, hardware is
4034	* very restrictive about programming this table. Entries must be ordered by
4035	* src_offset in ascending order, without duplicates. Additionally, unused
4036	* entries must be set to the unused index value, and must have valid size and
4037	* length according to the src_offset ordering.
4038	*
4039	* This function will reprogram the FLX_PIT register from a book-keeping
4040	* structure that we guarantee is already ordered correctly, and has no more
4041	* than 3 entries.
4042	*
4043	* To make things easier, we only support flexible values of one word length,
4044	* rather than allowing variable length flexible values.
4045	**/
4046	static void __i40e_reprogram_flex_pit(struct i40e_pf *pf,
4047	struct list_head *flex_pit_list,
4048	int flex_pit_start)
4049	{
4050	struct i40e_flex_pit *entry = NULL;
4051	u16 last_offset = 0;
4052	int i = 0, j = 0;
4053
4054	/* First, loop over the list of flex PIT entries, and reprogram the
4055	* registers.
4056	*/
4057	list_for_each_entry(entry, flex_pit_list, list) {
4058	/* We have to be careful when programming values for the
4059	* largest SRC_OFFSET value. It is possible that adding
4060	* additional empty values at the end would overflow the space
4061	* for the SRC_OFFSET in the FLX_PIT register. To avoid this,
4062	* we check here and add the empty values prior to adding the
4063	* largest value.
4064	*
4065	* To determine this, we will use a loop from i+1 to 3, which
4066	* will determine whether the unused entries would have valid
4067	* SRC_OFFSET. Note that there cannot be extra entries past
4068	* this value, because the only valid values would have been
4069	* larger than I40E_MAX_FLEX_SRC_OFFSET, and thus would not
4070	* have been added to the list in the first place.
4071	*/
4072	for (j = i + 1; j < 3; j++) {
4073	u16 offset = entry->src_offset + j;
4074	int index = flex_pit_start + i;
4075	u32 value = I40E_FLEX_PREP_VAL(I40E_FLEX_DEST_UNUSED,
4076	1,
4077	offset - 3);
4078
4079	if (offset > I40E_MAX_FLEX_SRC_OFFSET) {
4080	i40e_write_rx_ctl(hw: &pf->hw,
4081	I40E_PRTQF_FLX_PIT(index),
4082	reg_val: value);
4083	i++;
4084	}
4085	}
4086
4087	/* Now, we can program the actual value into the table */
4088	i40e_write_rx_ctl(hw: &pf->hw,
4089	I40E_PRTQF_FLX_PIT(flex_pit_start + i),
4090	I40E_FLEX_PREP_VAL(entry->pit_index + 50,
4091	1,
4092	entry->src_offset));
4093	i++;
4094	}
4095
4096	/* In order to program the last entries in the table, we need to
4097	* determine the valid offset. If the list is empty, we'll just start
4098	* with 0. Otherwise, we'll start with the last item offset and add 1.
4099	* This ensures that all entries have valid sizes. If we don't do this
4100	* correctly, the hardware will disable flexible field parsing.
4101	*/
4102	if (!list_empty(head: flex_pit_list))
4103	last_offset = list_prev_entry(entry, list)->src_offset + 1;
4104
4105	for (; i < 3; i++, last_offset++) {
4106	i40e_write_rx_ctl(hw: &pf->hw,
4107	I40E_PRTQF_FLX_PIT(flex_pit_start + i),
4108	I40E_FLEX_PREP_VAL(I40E_FLEX_DEST_UNUSED,
4109	1,
4110	last_offset));
4111	}
4112	}
4113
4114	/**
4115	* i40e_reprogram_flex_pit - Reprogram all FLX_PIT tables after input set change
4116	* @pf: pointer to the PF structure
4117	*
4118	* This function reprograms both the L3 and L4 FLX_PIT tables. See the
4119	* internal helper function for implementation details.
4120	**/
4121	static void i40e_reprogram_flex_pit(struct i40e_pf *pf)
4122	{
4123	__i40e_reprogram_flex_pit(pf, flex_pit_list: &pf->l3_flex_pit_list,
4124	I40E_FLEX_PIT_IDX_START_L3);
4125
4126	__i40e_reprogram_flex_pit(pf, flex_pit_list: &pf->l4_flex_pit_list,
4127	I40E_FLEX_PIT_IDX_START_L4);
4128
4129	/* We also need to program the L3 and L4 GLQF ORT register */
4130	i40e_write_rx_ctl(hw: &pf->hw,
4131	I40E_GLQF_ORT(I40E_L3_GLQF_ORT_IDX),
4132	I40E_ORT_PREP_VAL(I40E_FLEX_PIT_IDX_START_L3,
4133	3, 1));
4134
4135	i40e_write_rx_ctl(hw: &pf->hw,
4136	I40E_GLQF_ORT(I40E_L4_GLQF_ORT_IDX),
4137	I40E_ORT_PREP_VAL(I40E_FLEX_PIT_IDX_START_L4,
4138	3, 1));
4139	}
4140
4141	/**
4142	* i40e_flow_str - Converts a flow_type into a human readable string
4143	* @fsp: the flow specification
4144	*
4145	* Currently only flow types we support are included here, and the string
4146	* value attempts to match what ethtool would use to configure this flow type.
4147	**/
4148	static const char *i40e_flow_str(struct ethtool_rx_flow_spec *fsp)
4149	{
4150	switch (fsp->flow_type & ~FLOW_EXT) {
4151	case TCP_V4_FLOW:
4152	return "tcp4";
4153	case UDP_V4_FLOW:
4154	return "udp4";
4155	case SCTP_V4_FLOW:
4156	return "sctp4";
4157	case IP_USER_FLOW:
4158	return "ip4";
4159	case TCP_V6_FLOW:
4160	return "tcp6";
4161	case UDP_V6_FLOW:
4162	return "udp6";
4163	case SCTP_V6_FLOW:
4164	return "sctp6";
4165	case IPV6_USER_FLOW:
4166	return "ip6";
4167	default:
4168	return "unknown";
4169	}
4170	}
4171
4172	/**
4173	* i40e_pit_index_to_mask - Return the FLEX mask for a given PIT index
4174	* @pit_index: PIT index to convert
4175	*
4176	* Returns the mask for a given PIT index. Will return 0 if the pit_index is
4177	* of range.
4178	**/
4179	static u64 i40e_pit_index_to_mask(int pit_index)
4180	{
4181	switch (pit_index) {
4182	case 0:
4183	return I40E_FLEX_50_MASK;
4184	case 1:
4185	return I40E_FLEX_51_MASK;
4186	case 2:
4187	return I40E_FLEX_52_MASK;
4188	case 3:
4189	return I40E_FLEX_53_MASK;
4190	case 4:
4191	return I40E_FLEX_54_MASK;
4192	case 5:
4193	return I40E_FLEX_55_MASK;
4194	case 6:
4195	return I40E_FLEX_56_MASK;
4196	case 7:
4197	return I40E_FLEX_57_MASK;
4198	default:
4199	return 0;
4200	}
4201	}
4202
4203	/**
4204	* i40e_print_input_set - Show changes between two input sets
4205	* @vsi: the vsi being configured
4206	* @old: the old input set
4207	* @new: the new input set
4208	*
4209	* Print the difference between old and new input sets by showing which series
4210	* of words are toggled on or off. Only displays the bits we actually support
4211	* changing.
4212	**/
4213	static void i40e_print_input_set(struct i40e_vsi *vsi, u64 old, u64 new)
4214	{
4215	struct i40e_pf *pf = vsi->back;
4216	bool old_value, new_value;
4217	int i;
4218
4219	old_value = !!(old & I40E_L3_SRC_MASK);
4220	new_value = !!(new & I40E_L3_SRC_MASK);
4221	if (old_value != new_value)
4222	netif_info(pf, drv, vsi->netdev, "L3 source address: %s -> %s\n",
4223	old_value ? "ON" : "OFF",
4224	new_value ? "ON" : "OFF");
4225
4226	old_value = !!(old & I40E_L3_DST_MASK);
4227	new_value = !!(new & I40E_L3_DST_MASK);
4228	if (old_value != new_value)
4229	netif_info(pf, drv, vsi->netdev, "L3 destination address: %s -> %s\n",
4230	old_value ? "ON" : "OFF",
4231	new_value ? "ON" : "OFF");
4232
4233	old_value = !!(old & I40E_L4_SRC_MASK);
4234	new_value = !!(new & I40E_L4_SRC_MASK);
4235	if (old_value != new_value)
4236	netif_info(pf, drv, vsi->netdev, "L4 source port: %s -> %s\n",
4237	old_value ? "ON" : "OFF",
4238	new_value ? "ON" : "OFF");
4239
4240	old_value = !!(old & I40E_L4_DST_MASK);
4241	new_value = !!(new & I40E_L4_DST_MASK);
4242	if (old_value != new_value)
4243	netif_info(pf, drv, vsi->netdev, "L4 destination port: %s -> %s\n",
4244	old_value ? "ON" : "OFF",
4245	new_value ? "ON" : "OFF");
4246
4247	old_value = !!(old & I40E_VERIFY_TAG_MASK);
4248	new_value = !!(new & I40E_VERIFY_TAG_MASK);
4249	if (old_value != new_value)
4250	netif_info(pf, drv, vsi->netdev, "SCTP verification tag: %s -> %s\n",
4251	old_value ? "ON" : "OFF",
4252	new_value ? "ON" : "OFF");
4253
4254	/* Show change of flexible filter entries */
4255	for (i = 0; i < I40E_FLEX_INDEX_ENTRIES; i++) {
4256	u64 flex_mask = i40e_pit_index_to_mask(pit_index: i);
4257
4258	old_value = !!(old & flex_mask);
4259	new_value = !!(new & flex_mask);
4260	if (old_value != new_value)
4261	netif_info(pf, drv, vsi->netdev, "FLEX index %d: %s -> %s\n",
4262	i,
4263	old_value ? "ON" : "OFF",
4264	new_value ? "ON" : "OFF");
4265	}
4266
4267	netif_info(pf, drv, vsi->netdev, " Current input set: %0llx\n",
4268	old);
4269	netif_info(pf, drv, vsi->netdev, "Requested input set: %0llx\n",
4270	new);
4271	}
4272
4273	/**
4274	* i40e_check_fdir_input_set - Check that a given rx_flow_spec mask is valid
4275	* @vsi: pointer to the targeted VSI
4276	* @fsp: pointer to Rx flow specification
4277	* @userdef: userdefined data from flow specification
4278	*
4279	* Ensures that a given ethtool_rx_flow_spec has a valid mask. Some support
4280	* for partial matches exists with a few limitations. First, hardware only
4281	* supports masking by word boundary (2 bytes) and not per individual bit.
4282	* Second, hardware is limited to using one mask for a flow type and cannot
4283	* use a separate mask for each filter.
4284	*
4285	* To support these limitations, if we already have a configured filter for
4286	* the specified type, this function enforces that new filters of the type
4287	* match the configured input set. Otherwise, if we do not have a filter of
4288	* the specified type, we allow the input set to be updated to match the
4289	* desired filter.
4290	*
4291	* To help ensure that administrators understand why filters weren't displayed
4292	* as supported, we print a diagnostic message displaying how the input set
4293	* would change and warning to delete the preexisting filters if required.
4294	*
4295	* Returns 0 on successful input set match, and a negative return code on
4296	* failure.
4297	**/
4298	static int i40e_check_fdir_input_set(struct i40e_vsi *vsi,
4299	struct ethtool_rx_flow_spec *fsp,
4300	struct i40e_rx_flow_userdef *userdef)
4301	{
4302	static const __be32 ipv6_full_mask[4] = {cpu_to_be32(0xffffffff),
4303	cpu_to_be32(0xffffffff), cpu_to_be32(0xffffffff),
4304	cpu_to_be32(0xffffffff)};
4305	struct ethtool_tcpip6_spec *tcp_ip6_spec;
4306	struct ethtool_usrip6_spec *usr_ip6_spec;
4307	struct ethtool_tcpip4_spec *tcp_ip4_spec;
4308	struct ethtool_usrip4_spec *usr_ip4_spec;
4309	struct i40e_pf *pf = vsi->back;
4310	u64 current_mask, new_mask;
4311	bool new_flex_offset = false;
4312	bool flex_l3 = false;
4313	u16 *fdir_filter_count;
4314	u16 index, src_offset = 0;
4315	u8 pit_index = 0;
4316	int err;
4317
4318	switch (fsp->flow_type & ~FLOW_EXT) {
4319	case SCTP_V4_FLOW:
4320	index = I40E_FILTER_PCTYPE_NONF_IPV4_SCTP;
4321	fdir_filter_count = &pf->fd_sctp4_filter_cnt;
4322	break;
4323	case TCP_V4_FLOW:
4324	index = I40E_FILTER_PCTYPE_NONF_IPV4_TCP;
4325	fdir_filter_count = &pf->fd_tcp4_filter_cnt;
4326	break;
4327	case UDP_V4_FLOW:
4328	index = I40E_FILTER_PCTYPE_NONF_IPV4_UDP;
4329	fdir_filter_count = &pf->fd_udp4_filter_cnt;
4330	break;
4331	case SCTP_V6_FLOW:
4332	index = I40E_FILTER_PCTYPE_NONF_IPV6_SCTP;
4333	fdir_filter_count = &pf->fd_sctp6_filter_cnt;
4334	break;
4335	case TCP_V6_FLOW:
4336	index = I40E_FILTER_PCTYPE_NONF_IPV6_TCP;
4337	fdir_filter_count = &pf->fd_tcp6_filter_cnt;
4338	break;
4339	case UDP_V6_FLOW:
4340	index = I40E_FILTER_PCTYPE_NONF_IPV6_UDP;
4341	fdir_filter_count = &pf->fd_udp6_filter_cnt;
4342	break;
4343	case IP_USER_FLOW:
4344	index = I40E_FILTER_PCTYPE_NONF_IPV4_OTHER;
4345	fdir_filter_count = &pf->fd_ip4_filter_cnt;
4346	flex_l3 = true;
4347	break;
4348	case IPV6_USER_FLOW:
4349	index = I40E_FILTER_PCTYPE_NONF_IPV6_OTHER;
4350	fdir_filter_count = &pf->fd_ip6_filter_cnt;
4351	flex_l3 = true;
4352	break;
4353	default:
4354	return -EOPNOTSUPP;
4355	}
4356
4357	/* Read the current input set from register memory. */
4358	current_mask = i40e_read_fd_input_set(pf, addr: index);
4359	new_mask = current_mask;
4360
4361	/* Determine, if any, the required changes to the input set in order
4362	* to support the provided mask.
4363	*
4364	* Hardware only supports masking at word (2 byte) granularity and does
4365	* not support full bitwise masking. This implementation simplifies
4366	* even further and only supports fully enabled or fully disabled
4367	* masks for each field, even though we could split the ip4src and
4368	* ip4dst fields.
4369	*/
4370	switch (fsp->flow_type & ~FLOW_EXT) {
4371	case SCTP_V4_FLOW:
4372	new_mask &= ~I40E_VERIFY_TAG_MASK;
4373	fallthrough;
4374	case TCP_V4_FLOW:
4375	case UDP_V4_FLOW:
4376	tcp_ip4_spec = &fsp->m_u.tcp_ip4_spec;
4377
4378	/* IPv4 source address */
4379	if (tcp_ip4_spec->ip4src == htonl(0xFFFFFFFF))
4380	new_mask |= I40E_L3_SRC_MASK;
4381	else if (!tcp_ip4_spec->ip4src)
4382	new_mask &= ~I40E_L3_SRC_MASK;
4383	else
4384	return -EOPNOTSUPP;
4385
4386	/* IPv4 destination address */
4387	if (tcp_ip4_spec->ip4dst == htonl(0xFFFFFFFF))
4388	new_mask |= I40E_L3_DST_MASK;
4389	else if (!tcp_ip4_spec->ip4dst)
4390	new_mask &= ~I40E_L3_DST_MASK;
4391	else
4392	return -EOPNOTSUPP;
4393
4394	/* L4 source port */
4395	if (tcp_ip4_spec->psrc == htons(0xFFFF))
4396	new_mask |= I40E_L4_SRC_MASK;
4397	else if (!tcp_ip4_spec->psrc)
4398	new_mask &= ~I40E_L4_SRC_MASK;
4399	else
4400	return -EOPNOTSUPP;
4401
4402	/* L4 destination port */
4403	if (tcp_ip4_spec->pdst == htons(0xFFFF))
4404	new_mask |= I40E_L4_DST_MASK;
4405	else if (!tcp_ip4_spec->pdst)
4406	new_mask &= ~I40E_L4_DST_MASK;
4407	else
4408	return -EOPNOTSUPP;
4409
4410	/* Filtering on Type of Service is not supported. */
4411	if (tcp_ip4_spec->tos)
4412	return -EOPNOTSUPP;
4413
4414	break;
4415	case SCTP_V6_FLOW:
4416	new_mask &= ~I40E_VERIFY_TAG_MASK;
4417	fallthrough;
4418	case TCP_V6_FLOW:
4419	case UDP_V6_FLOW:
4420	tcp_ip6_spec = &fsp->m_u.tcp_ip6_spec;
4421
4422	/* Check if user provided IPv6 source address. */
4423	if (ipv6_addr_equal(a1: (struct in6_addr *)&tcp_ip6_spec->ip6src,
4424	a2: (struct in6_addr *)&ipv6_full_mask))
4425	new_mask |= I40E_L3_V6_SRC_MASK;
4426	else if (ipv6_addr_any(a: (struct in6_addr *)
4427	&tcp_ip6_spec->ip6src))
4428	new_mask &= ~I40E_L3_V6_SRC_MASK;
4429	else
4430	return -EOPNOTSUPP;
4431
4432	/* Check if user provided destination address. */
4433	if (ipv6_addr_equal(a1: (struct in6_addr *)&tcp_ip6_spec->ip6dst,
4434	a2: (struct in6_addr *)&ipv6_full_mask))
4435	new_mask |= I40E_L3_V6_DST_MASK;
4436	else if (ipv6_addr_any(a: (struct in6_addr *)
4437	&tcp_ip6_spec->ip6dst))
4438	new_mask &= ~I40E_L3_V6_DST_MASK;
4439	else
4440	return -EOPNOTSUPP;
4441
4442	/* L4 source port */
4443	if (tcp_ip6_spec->psrc == htons(0xFFFF))
4444	new_mask |= I40E_L4_SRC_MASK;
4445	else if (!tcp_ip6_spec->psrc)
4446	new_mask &= ~I40E_L4_SRC_MASK;
4447	else
4448	return -EOPNOTSUPP;
4449
4450	/* L4 destination port */
4451	if (tcp_ip6_spec->pdst == htons(0xFFFF))
4452	new_mask |= I40E_L4_DST_MASK;
4453	else if (!tcp_ip6_spec->pdst)
4454	new_mask &= ~I40E_L4_DST_MASK;
4455	else
4456	return -EOPNOTSUPP;
4457
4458	/* Filtering on Traffic Classes is not supported. */
4459	if (tcp_ip6_spec->tclass)
4460	return -EOPNOTSUPP;
4461	break;
4462	case IP_USER_FLOW:
4463	usr_ip4_spec = &fsp->m_u.usr_ip4_spec;
4464
4465	/* IPv4 source address */
4466	if (usr_ip4_spec->ip4src == htonl(0xFFFFFFFF))
4467	new_mask |= I40E_L3_SRC_MASK;
4468	else if (!usr_ip4_spec->ip4src)
4469	new_mask &= ~I40E_L3_SRC_MASK;
4470	else
4471	return -EOPNOTSUPP;
4472
4473	/* IPv4 destination address */
4474	if (usr_ip4_spec->ip4dst == htonl(0xFFFFFFFF))
4475	new_mask |= I40E_L3_DST_MASK;
4476	else if (!usr_ip4_spec->ip4dst)
4477	new_mask &= ~I40E_L3_DST_MASK;
4478	else
4479	return -EOPNOTSUPP;
4480
4481	/* First 4 bytes of L4 header */
4482	if (usr_ip4_spec->l4_4_bytes)
4483	return -EOPNOTSUPP;
4484
4485	/* Filtering on Type of Service is not supported. */
4486	if (usr_ip4_spec->tos)
4487	return -EOPNOTSUPP;
4488
4489	/* Filtering on IP version is not supported */
4490	if (usr_ip4_spec->ip_ver)
4491	return -EINVAL;
4492
4493	/* Filtering on L4 protocol is not supported */
4494	if (usr_ip4_spec->proto)
4495	return -EINVAL;
4496
4497	break;
4498	case IPV6_USER_FLOW:
4499	usr_ip6_spec = &fsp->m_u.usr_ip6_spec;
4500
4501	/* Check if user provided IPv6 source address. */
4502	if (ipv6_addr_equal(a1: (struct in6_addr *)&usr_ip6_spec->ip6src,
4503	a2: (struct in6_addr *)&ipv6_full_mask))
4504	new_mask |= I40E_L3_V6_SRC_MASK;
4505	else if (ipv6_addr_any(a: (struct in6_addr *)
4506	&usr_ip6_spec->ip6src))
4507	new_mask &= ~I40E_L3_V6_SRC_MASK;
4508	else
4509	return -EOPNOTSUPP;
4510
4511	/* Check if user provided destination address. */
4512	if (ipv6_addr_equal(a1: (struct in6_addr *)&usr_ip6_spec->ip6dst,
4513	a2: (struct in6_addr *)&ipv6_full_mask))
4514	new_mask |= I40E_L3_V6_DST_MASK;
4515	else if (ipv6_addr_any(a: (struct in6_addr *)
4516	&usr_ip6_spec->ip6dst))
4517	new_mask &= ~I40E_L3_V6_DST_MASK;
4518	else
4519	return -EOPNOTSUPP;
4520
4521	if (usr_ip6_spec->l4_4_bytes)
4522	return -EOPNOTSUPP;
4523
4524	/* Filtering on Traffic class is not supported. */
4525	if (usr_ip6_spec->tclass)
4526	return -EOPNOTSUPP;
4527
4528	/* Filtering on L4 protocol is not supported */
4529	if (usr_ip6_spec->l4_proto)
4530	return -EINVAL;
4531
4532	break;
4533	default:
4534	return -EOPNOTSUPP;
4535	}
4536
4537	if (fsp->flow_type & FLOW_EXT) {
4538	/* Allow only 802.1Q and no etype defined, as
4539	* later it's modified to 0x8100
4540	*/
4541	if (fsp->h_ext.vlan_etype != htons(ETH_P_8021Q) &&
4542	fsp->h_ext.vlan_etype != 0)
4543	return -EOPNOTSUPP;
4544	if (fsp->m_ext.vlan_tci == htons(0xFFFF))
4545	new_mask |= I40E_VLAN_SRC_MASK;
4546	else
4547	new_mask &= ~I40E_VLAN_SRC_MASK;
4548	}
4549
4550	/* First, clear all flexible filter entries */
4551	new_mask &= ~I40E_FLEX_INPUT_MASK;
4552
4553	/* If we have a flexible filter, try to add this offset to the correct
4554	* flexible filter PIT list. Once finished, we can update the mask.
4555	* If the src_offset changed, we will get a new mask value which will
4556	* trigger an input set change.
4557	*/
4558	if (userdef->flex_filter) {
4559	struct i40e_flex_pit *l3_flex_pit = NULL, *flex_pit = NULL;
4560
4561	/* Flexible offset must be even, since the flexible payload
4562	* must be aligned on 2-byte boundary.
4563	*/
4564	if (userdef->flex_offset & 0x1) {
4565	dev_warn(&pf->pdev->dev,
4566	"Flexible data offset must be 2-byte aligned\n");
4567	return -EINVAL;
4568	}
4569
4570	src_offset = userdef->flex_offset >> 1;
4571
4572	/* FLX_PIT source offset value is only so large */
4573	if (src_offset > I40E_MAX_FLEX_SRC_OFFSET) {
4574	dev_warn(&pf->pdev->dev,
4575	"Flexible data must reside within first 64 bytes of the packet payload\n");
4576	return -EINVAL;
4577	}
4578
4579	/* See if this offset has already been programmed. If we get
4580	* an ERR_PTR, then the filter is not safe to add. Otherwise,
4581	* if we get a NULL pointer, this means we will need to add
4582	* the offset.
4583	*/
4584	flex_pit = i40e_find_flex_offset(flex_pit_list: &pf->l4_flex_pit_list,
4585	src_offset);
4586	if (IS_ERR(ptr: flex_pit))
4587	return PTR_ERR(ptr: flex_pit);
4588
4589	/* IP_USER_FLOW filters match both L4 (ICMP) and L3 (unknown)
4590	* packet types, and thus we need to program both L3 and L4
4591	* flexible values. These must have identical flexible index,
4592	* as otherwise we can't correctly program the input set. So
4593	* we'll find both an L3 and L4 index and make sure they are
4594	* the same.
4595	*/
4596	if (flex_l3) {
4597	l3_flex_pit =
4598	i40e_find_flex_offset(flex_pit_list: &pf->l3_flex_pit_list,
4599	src_offset);
4600	if (IS_ERR(ptr: l3_flex_pit))
4601	return PTR_ERR(ptr: l3_flex_pit);
4602
4603	if (flex_pit) {
4604	/* If we already had a matching L4 entry, we
4605	* need to make sure that the L3 entry we
4606	* obtained uses the same index.
4607	*/
4608	if (l3_flex_pit) {
4609	if (l3_flex_pit->pit_index !=
4610	flex_pit->pit_index) {
4611	return -EINVAL;
4612	}
4613	} else {
4614	new_flex_offset = true;
4615	}
4616	} else {
4617	flex_pit = l3_flex_pit;
4618	}
4619	}
4620
4621	/* If we didn't find an existing flex offset, we need to
4622	* program a new one. However, we don't immediately program it
4623	* here because we will wait to program until after we check
4624	* that it is safe to change the input set.
4625	*/
4626	if (!flex_pit) {
4627	new_flex_offset = true;
4628	pit_index = i40e_unused_pit_index(pf);
4629	} else {
4630	pit_index = flex_pit->pit_index;
4631	}
4632
4633	/* Update the mask with the new offset */
4634	new_mask |= i40e_pit_index_to_mask(pit_index);
4635	}
4636
4637	/* If the mask and flexible filter offsets for this filter match the
4638	* currently programmed values we don't need any input set change, so
4639	* this filter is safe to install.
4640	*/
4641	if (new_mask == current_mask && !new_flex_offset)
4642	return 0;
4643
4644	netif_info(pf, drv, vsi->netdev, "Input set change requested for %s flows:\n",
4645	i40e_flow_str(fsp));
4646	i40e_print_input_set(vsi, old: current_mask, new: new_mask);
4647	if (new_flex_offset) {
4648	netif_info(pf, drv, vsi->netdev, "FLEX index %d: Offset -> %d",
4649	pit_index, src_offset);
4650	}
4651
4652	/* Hardware input sets are global across multiple ports, so even the
4653	* main port cannot change them when in MFP mode as this would impact
4654	* any filters on the other ports.
4655	*/
4656	if (test_bit(I40E_FLAG_MFP_ENA, pf->flags)) {
4657	netif_err(pf, drv, vsi->netdev, "Cannot change Flow Director input sets while MFP is enabled\n");
4658	return -EOPNOTSUPP;
4659	}
4660
4661	/* This filter requires us to update the input set. However, hardware
4662	* only supports one input set per flow type, and does not support
4663	* separate masks for each filter. This means that we can only support
4664	* a single mask for all filters of a specific type.
4665	*
4666	* If we have preexisting filters, they obviously depend on the
4667	* current programmed input set. Display a diagnostic message in this
4668	* case explaining why the filter could not be accepted.
4669	*/
4670	if (*fdir_filter_count) {
4671	netif_err(pf, drv, vsi->netdev, "Cannot change input set for %s flows until %d preexisting filters are removed\n",
4672	i40e_flow_str(fsp),
4673	*fdir_filter_count);
4674	return -EOPNOTSUPP;
4675	}
4676
4677	i40e_write_fd_input_set(pf, addr: index, val: new_mask);
4678
4679	/* IP_USER_FLOW filters match both IPv4/Other and IPv4/Fragmented
4680	* frames. If we're programming the input set for IPv4/Other, we also
4681	* need to program the IPv4/Fragmented input set. Since we don't have
4682	* separate support, we'll always assume and enforce that the two flow
4683	* types must have matching input sets.
4684	*/
4685	if (index == I40E_FILTER_PCTYPE_NONF_IPV4_OTHER)
4686	i40e_write_fd_input_set(pf, addr: I40E_FILTER_PCTYPE_FRAG_IPV4,
4687	val: new_mask);
4688
4689	/* Add the new offset and update table, if necessary */
4690	if (new_flex_offset) {
4691	err = i40e_add_flex_offset(flex_pit_list: &pf->l4_flex_pit_list, src_offset,
4692	pit_index);
4693	if (err)
4694	return err;
4695
4696	if (flex_l3) {
4697	err = i40e_add_flex_offset(flex_pit_list: &pf->l3_flex_pit_list,
4698	src_offset,
4699	pit_index);
4700	if (err)
4701	return err;
4702	}
4703
4704	i40e_reprogram_flex_pit(pf);
4705	}
4706
4707	return 0;
4708	}
4709
4710	/**
4711	* i40e_match_fdir_filter - Return true of two filters match
4712	* @a: pointer to filter struct
4713	* @b: pointer to filter struct
4714	*
4715	* Returns true if the two filters match exactly the same criteria. I.e. they
4716	* match the same flow type and have the same parameters. We don't need to
4717	* check any input-set since all filters of the same flow type must use the
4718	* same input set.
4719	**/
4720	static bool i40e_match_fdir_filter(struct i40e_fdir_filter *a,
4721	struct i40e_fdir_filter *b)
4722	{
4723	/* The filters do not much if any of these criteria differ. */
4724	if (a->dst_ip != b->dst_ip ||
4725	a->src_ip != b->src_ip ||
4726	a->dst_port != b->dst_port ||
4727	a->src_port != b->src_port ||
4728	a->flow_type != b->flow_type ||
4729	a->ipl4_proto != b->ipl4_proto ||
4730	a->vlan_tag != b->vlan_tag ||
4731	a->vlan_etype != b->vlan_etype)
4732	return false;
4733
4734	return true;
4735	}
4736
4737	/**
4738	* i40e_disallow_matching_filters - Check that new filters differ
4739	* @vsi: pointer to the targeted VSI
4740	* @input: new filter to check
4741	*
4742	* Due to hardware limitations, it is not possible for two filters that match
4743	* similar criteria to be programmed at the same time. This is true for a few
4744	* reasons:
4745	*
4746	* (a) all filters matching a particular flow type must use the same input
4747	* set, that is they must match the same criteria.
4748	* (b) different flow types will never match the same packet, as the flow type
4749	* is decided by hardware before checking which rules apply.
4750	* (c) hardware has no way to distinguish which order filters apply in.
4751	*
4752	* Due to this, we can't really support using the location data to order
4753	* filters in the hardware parsing. It is technically possible for the user to
4754	* request two filters matching the same criteria but which select different
4755	* queues. In this case, rather than keep both filters in the list, we reject
4756	* the 2nd filter when the user requests adding it.
4757	*
4758	* This avoids needing to track location for programming the filter to
4759	* hardware, and ensures that we avoid some strange scenarios involving
4760	* deleting filters which match the same criteria.
4761	**/
4762	static int i40e_disallow_matching_filters(struct i40e_vsi *vsi,
4763	struct i40e_fdir_filter *input)
4764	{
4765	struct i40e_pf *pf = vsi->back;
4766	struct i40e_fdir_filter *rule;
4767	struct hlist_node *node2;
4768
4769	/* Loop through every filter, and check that it doesn't match */
4770	hlist_for_each_entry_safe(rule, node2,
4771	&pf->fdir_filter_list, fdir_node) {
4772	/* Don't check the filters match if they share the same fd_id,
4773	* since the new filter is actually just updating the target
4774	* of the old filter.
4775	*/
4776	if (rule->fd_id == input->fd_id)
4777	continue;
4778
4779	/* If any filters match, then print a warning message to the
4780	* kernel message buffer and bail out.
4781	*/
4782	if (i40e_match_fdir_filter(a: rule, b: input)) {
4783	dev_warn(&pf->pdev->dev,
4784	"Existing user defined filter %d already matches this flow.\n",
4785	rule->fd_id);
4786	return -EINVAL;
4787	}
4788	}
4789
4790	return 0;
4791	}
4792
4793	/**
4794	* i40e_add_fdir_ethtool - Add/Remove Flow Director filters
4795	* @vsi: pointer to the targeted VSI
4796	* @cmd: command to get or set RX flow classification rules
4797	*
4798	* Add Flow Director filters for a specific flow spec based on their
4799	* protocol. Returns 0 if the filters were successfully added.
4800	**/
4801	static int i40e_add_fdir_ethtool(struct i40e_vsi *vsi,
4802	struct ethtool_rxnfc *cmd)
4803	{
4804	struct i40e_rx_flow_userdef userdef;
4805	struct ethtool_rx_flow_spec *fsp;
4806	struct i40e_fdir_filter *input;
4807	u16 dest_vsi = 0, q_index = 0;
4808	struct i40e_pf *pf;
4809	int ret = -EINVAL;
4810	u8 dest_ctl;
4811
4812	if (!vsi)
4813	return -EINVAL;
4814	pf = vsi->back;
4815
4816	if (!test_bit(I40E_FLAG_FD_SB_ENA, pf->flags))
4817	return -EOPNOTSUPP;
4818
4819	if (test_bit(__I40E_FD_SB_AUTO_DISABLED, pf->state))
4820	return -ENOSPC;
4821
4822	if (test_bit(__I40E_RESET_RECOVERY_PENDING, pf->state) ||
4823	test_bit(__I40E_RESET_INTR_RECEIVED, pf->state))
4824	return -EBUSY;
4825
4826	if (test_bit(__I40E_FD_FLUSH_REQUESTED, pf->state))
4827	return -EBUSY;
4828
4829	fsp = (struct ethtool_rx_flow_spec *)&cmd->fs;
4830
4831	/* Parse the user-defined field */
4832	if (i40e_parse_rx_flow_user_data(fsp, data: &userdef))
4833	return -EINVAL;
4834
4835	/* Extended MAC field is not supported */
4836	if (fsp->flow_type & FLOW_MAC_EXT)
4837	return -EINVAL;
4838
4839	ret = i40e_check_fdir_input_set(vsi, fsp, userdef: &userdef);
4840	if (ret)
4841	return ret;
4842
4843	if (fsp->location >= (pf->hw.func_caps.fd_filters_best_effort +
4844	pf->hw.func_caps.fd_filters_guaranteed)) {
4845	return -EINVAL;
4846	}
4847
4848	/* ring_cookie is either the drop index, or is a mask of the queue
4849	* index and VF id we wish to target.
4850	*/
4851	if (fsp->ring_cookie == RX_CLS_FLOW_DISC) {
4852	dest_ctl = I40E_FILTER_PROGRAM_DESC_DEST_DROP_PACKET;
4853	} else {
4854	u32 ring = ethtool_get_flow_spec_ring(ring_cookie: fsp->ring_cookie);
4855	u8 vf = ethtool_get_flow_spec_ring_vf(ring_cookie: fsp->ring_cookie);
4856
4857	if (!vf) {
4858	if (ring >= vsi->num_queue_pairs)
4859	return -EINVAL;
4860	dest_vsi = vsi->id;
4861	} else {
4862	/* VFs are zero-indexed, so we subtract one here */
4863	vf--;
4864
4865	if (vf >= pf->num_alloc_vfs)
4866	return -EINVAL;
4867	if (ring >= pf->vf[vf].num_queue_pairs)
4868	return -EINVAL;
4869	dest_vsi = pf->vf[vf].lan_vsi_id;
4870	}
4871	dest_ctl = I40E_FILTER_PROGRAM_DESC_DEST_DIRECT_PACKET_QINDEX;
4872	q_index = ring;
4873	}
4874
4875	input = kzalloc(size: sizeof(*input), GFP_KERNEL);
4876
4877	if (!input)
4878	return -ENOMEM;
4879
4880	input->fd_id = fsp->location;
4881	input->q_index = q_index;
4882	input->dest_vsi = dest_vsi;
4883	input->dest_ctl = dest_ctl;
4884	input->fd_status = I40E_FILTER_PROGRAM_DESC_FD_STATUS_FD_ID;
4885	input->cnt_index = I40E_FD_SB_STAT_IDX(pf->hw.pf_id);
4886	input->dst_ip = fsp->h_u.tcp_ip4_spec.ip4src;
4887	input->src_ip = fsp->h_u.tcp_ip4_spec.ip4dst;
4888	input->flow_type = fsp->flow_type & ~FLOW_EXT;
4889
4890	input->vlan_etype = fsp->h_ext.vlan_etype;
4891	if (!fsp->m_ext.vlan_etype && fsp->h_ext.vlan_tci)
4892	input->vlan_etype = cpu_to_be16(ETH_P_8021Q);
4893	if (fsp->m_ext.vlan_tci && input->vlan_etype)
4894	input->vlan_tag = fsp->h_ext.vlan_tci;
4895	if (input->flow_type == IPV6_USER_FLOW ||
4896	input->flow_type == UDP_V6_FLOW ||
4897	input->flow_type == TCP_V6_FLOW ||
4898	input->flow_type == SCTP_V6_FLOW) {
4899	/* Reverse the src and dest notion, since the HW expects them
4900	* to be from Tx perspective where as the input from user is
4901	* from Rx filter view.
4902	*/
4903	input->ipl4_proto = fsp->h_u.usr_ip6_spec.l4_proto;
4904	input->dst_port = fsp->h_u.tcp_ip6_spec.psrc;
4905	input->src_port = fsp->h_u.tcp_ip6_spec.pdst;
4906	memcpy(input->dst_ip6, fsp->h_u.ah_ip6_spec.ip6src,
4907	sizeof(__be32) * 4);
4908	memcpy(input->src_ip6, fsp->h_u.ah_ip6_spec.ip6dst,
4909	sizeof(__be32) * 4);
4910	} else {
4911	/* Reverse the src and dest notion, since the HW expects them
4912	* to be from Tx perspective where as the input from user is
4913	* from Rx filter view.
4914	*/
4915	input->ipl4_proto = fsp->h_u.usr_ip4_spec.proto;
4916	input->dst_port = fsp->h_u.tcp_ip4_spec.psrc;
4917	input->src_port = fsp->h_u.tcp_ip4_spec.pdst;
4918	input->dst_ip = fsp->h_u.tcp_ip4_spec.ip4src;
4919	input->src_ip = fsp->h_u.tcp_ip4_spec.ip4dst;
4920	}
4921
4922	if (userdef.flex_filter) {
4923	input->flex_filter = true;
4924	input->flex_word = cpu_to_be16(userdef.flex_word);
4925	input->flex_offset = userdef.flex_offset;
4926	}
4927
4928	/* Avoid programming two filters with identical match criteria. */
4929	ret = i40e_disallow_matching_filters(vsi, input);
4930	if (ret)
4931	goto free_filter_memory;
4932
4933	/* Add the input filter to the fdir_input_list, possibly replacing
4934	* a previous filter. Do not free the input structure after adding it
4935	* to the list as this would cause a use-after-free bug.
4936	*/
4937	i40e_update_ethtool_fdir_entry(vsi, input, sw_idx: fsp->location, NULL);
4938	ret = i40e_add_del_fdir(vsi, input, add: true);
4939	if (ret)
4940	goto remove_sw_rule;
4941	return 0;
4942
4943	remove_sw_rule:
4944	hlist_del(n: &input->fdir_node);
4945	pf->fdir_pf_active_filters--;
4946	free_filter_memory:
4947	kfree(objp: input);
4948	return ret;
4949	}
4950
4951	/**
4952	* i40e_set_rxnfc - command to set RX flow classification rules
4953	* @netdev: network interface device structure
4954	* @cmd: ethtool rxnfc command
4955	*
4956	* Returns Success if the command is supported.
4957	**/
4958	static int i40e_set_rxnfc(struct net_device *netdev, struct ethtool_rxnfc *cmd)
4959	{
4960	struct i40e_netdev_priv *np = netdev_priv(dev: netdev);
4961	struct i40e_vsi *vsi = np->vsi;
4962	struct i40e_pf *pf = vsi->back;
4963	int ret = -EOPNOTSUPP;
4964
4965	switch (cmd->cmd) {
4966	case ETHTOOL_SRXFH:
4967	ret = i40e_set_rss_hash_opt(pf, nfc: cmd);
4968	break;
4969	case ETHTOOL_SRXCLSRLINS:
4970	ret = i40e_add_fdir_ethtool(vsi, cmd);
4971	break;
4972	case ETHTOOL_SRXCLSRLDEL:
4973	ret = i40e_del_fdir_entry(vsi, cmd);
4974	break;
4975	default:
4976	break;
4977	}
4978
4979	return ret;
4980	}
4981
4982	/**
4983	* i40e_max_channels - get Max number of combined channels supported
4984	* @vsi: vsi pointer
4985	**/
4986	static unsigned int i40e_max_channels(struct i40e_vsi *vsi)
4987	{
4988	/* TODO: This code assumes DCB and FD is disabled for now. */
4989	return vsi->alloc_queue_pairs;
4990	}
4991
4992	/**
4993	* i40e_get_channels - Get the current channels enabled and max supported etc.
4994	* @dev: network interface device structure
4995	* @ch: ethtool channels structure
4996	*
4997	* We don't support separate tx and rx queues as channels. The other count
4998	* represents how many queues are being used for control. max_combined counts
4999	* how many queue pairs we can support. They may not be mapped 1 to 1 with
5000	* q_vectors since we support a lot more queue pairs than q_vectors.
5001	**/
5002	static void i40e_get_channels(struct net_device *dev,
5003	struct ethtool_channels *ch)
5004	{
5005	struct i40e_netdev_priv *np = netdev_priv(dev);
5006	struct i40e_vsi *vsi = np->vsi;
5007	struct i40e_pf *pf = vsi->back;
5008
5009	/* report maximum channels */
5010	ch->max_combined = i40e_max_channels(vsi);
5011
5012	/* report info for other vector */
5013	ch->other_count = test_bit(I40E_FLAG_FD_SB_ENA, pf->flags) ? 1 : 0;
5014	ch->max_other = ch->other_count;
5015
5016	/* Note: This code assumes DCB is disabled for now. */
5017	ch->combined_count = vsi->num_queue_pairs;
5018	}
5019
5020	/**
5021	* i40e_set_channels - Set the new channels count.
5022	* @dev: network interface device structure
5023	* @ch: ethtool channels structure
5024	*
5025	* The new channels count may not be the same as requested by the user
5026	* since it gets rounded down to a power of 2 value.
5027	**/
5028	static int i40e_set_channels(struct net_device *dev,
5029	struct ethtool_channels *ch)
5030	{
5031	const u8 drop = I40E_FILTER_PROGRAM_DESC_DEST_DROP_PACKET;
5032	struct i40e_netdev_priv *np = netdev_priv(dev);
5033	unsigned int count = ch->combined_count;
5034	struct i40e_vsi *vsi = np->vsi;
5035	struct i40e_pf *pf = vsi->back;
5036	struct i40e_fdir_filter *rule;
5037	struct hlist_node *node2;
5038	int new_count;
5039	int err = 0;
5040
5041	/* We do not support setting channels for any other VSI at present */
5042	if (vsi->type != I40E_VSI_MAIN)
5043	return -EINVAL;
5044
5045	/* We do not support setting channels via ethtool when TCs are
5046	* configured through mqprio
5047	*/
5048	if (i40e_is_tc_mqprio_enabled(pf))
5049	return -EINVAL;
5050
5051	/* verify they are not requesting separate vectors */
5052	if (!count || ch->rx_count || ch->tx_count)
5053	return -EINVAL;
5054
5055	/* verify other_count has not changed */
5056	if (ch->other_count != (test_bit(I40E_FLAG_FD_SB_ENA, pf->flags) ? 1 : 0))
5057	return -EINVAL;
5058
5059	/* verify the number of channels does not exceed hardware limits */
5060	if (count > i40e_max_channels(vsi))
5061	return -EINVAL;
5062
5063	/* verify that the number of channels does not invalidate any current
5064	* flow director rules
5065	*/
5066	hlist_for_each_entry_safe(rule, node2,
5067	&pf->fdir_filter_list, fdir_node) {
5068	if (rule->dest_ctl != drop && count <= rule->q_index) {
5069	dev_warn(&pf->pdev->dev,
5070	"Existing user defined filter %d assigns flow to queue %d\n",
5071	rule->fd_id, rule->q_index);
5072	err = -EINVAL;
5073	}
5074	}
5075
5076	if (err) {
5077	dev_err(&pf->pdev->dev,
5078	"Existing filter rules must be deleted to reduce combined channel count to %d\n",
5079	count);
5080	return err;
5081	}
5082
5083	/* update feature limits from largest to smallest supported values */
5084	/* TODO: Flow director limit, DCB etc */
5085
5086	/* use rss_reconfig to rebuild with new queue count and update traffic
5087	* class queue mapping
5088	*/
5089	new_count = i40e_reconfig_rss_queues(pf, queue_count: count);
5090	if (new_count > 0)
5091	return 0;
5092	else
5093	return -EINVAL;
5094	}
5095
5096	/**
5097	* i40e_get_rxfh_key_size - get the RSS hash key size
5098	* @netdev: network interface device structure
5099	*
5100	* Returns the table size.
5101	**/
5102	static u32 i40e_get_rxfh_key_size(struct net_device *netdev)
5103	{
5104	return I40E_HKEY_ARRAY_SIZE;
5105	}
5106
5107	/**
5108	* i40e_get_rxfh_indir_size - get the rx flow hash indirection table size
5109	* @netdev: network interface device structure
5110	*
5111	* Returns the table size.
5112	**/
5113	static u32 i40e_get_rxfh_indir_size(struct net_device *netdev)
5114	{
5115	return I40E_HLUT_ARRAY_SIZE;
5116	}
5117
5118	/**
5119	* i40e_get_rxfh - get the rx flow hash indirection table
5120	* @netdev: network interface device structure
5121	* @rxfh: pointer to param struct (indir, key, hfunc)
5122	*
5123	* Reads the indirection table directly from the hardware. Returns 0 on
5124	* success.
5125	**/
5126	static int i40e_get_rxfh(struct net_device *netdev,
5127	struct ethtool_rxfh_param *rxfh)
5128	{
5129	struct i40e_netdev_priv *np = netdev_priv(dev: netdev);
5130	struct i40e_vsi *vsi = np->vsi;
5131	u8 *lut, *seed = NULL;
5132	int ret;
5133	u16 i;
5134
5135	rxfh->hfunc = ETH_RSS_HASH_TOP;
5136
5137	if (!rxfh->indir)
5138	return 0;
5139
5140	seed = rxfh->key;
5141	lut = kzalloc(I40E_HLUT_ARRAY_SIZE, GFP_KERNEL);
5142	if (!lut)
5143	return -ENOMEM;
5144	ret = i40e_get_rss(vsi, seed, lut, I40E_HLUT_ARRAY_SIZE);
5145	if (ret)
5146	goto out;
5147	for (i = 0; i < I40E_HLUT_ARRAY_SIZE; i++)
5148	rxfh->indir[i] = (u32)(lut[i]);
5149
5150	out:
5151	kfree(objp: lut);
5152
5153	return ret;
5154	}
5155
5156	/**
5157	* i40e_set_rxfh - set the rx flow hash indirection table
5158	* @netdev: network interface device structure
5159	* @rxfh: pointer to param struct (indir, key, hfunc)
5160	* @extack: extended ACK from the Netlink message
5161	*
5162	* Returns -EINVAL if the table specifies an invalid queue id, otherwise
5163	* returns 0 after programming the table.
5164	**/
5165	static int i40e_set_rxfh(struct net_device *netdev,
5166	struct ethtool_rxfh_param *rxfh,
5167	struct netlink_ext_ack *extack)
5168	{
5169	struct i40e_netdev_priv *np = netdev_priv(dev: netdev);
5170	struct i40e_vsi *vsi = np->vsi;
5171	struct i40e_pf *pf = vsi->back;
5172	u8 *seed = NULL;
5173	u16 i;
5174
5175	if (rxfh->hfunc != ETH_RSS_HASH_NO_CHANGE &&
5176	rxfh->hfunc != ETH_RSS_HASH_TOP)
5177	return -EOPNOTSUPP;
5178
5179	if (rxfh->key) {
5180	if (!vsi->rss_hkey_user) {
5181	vsi->rss_hkey_user = kzalloc(I40E_HKEY_ARRAY_SIZE,
5182	GFP_KERNEL);
5183	if (!vsi->rss_hkey_user)
5184	return -ENOMEM;
5185	}
5186	memcpy(vsi->rss_hkey_user, rxfh->key, I40E_HKEY_ARRAY_SIZE);
5187	seed = vsi->rss_hkey_user;
5188	}
5189	if (!vsi->rss_lut_user) {
5190	vsi->rss_lut_user = kzalloc(I40E_HLUT_ARRAY_SIZE, GFP_KERNEL);
5191	if (!vsi->rss_lut_user)
5192	return -ENOMEM;
5193	}
5194
5195	/* Each 32 bits pointed by 'indir' is stored with a lut entry */
5196	if (rxfh->indir)
5197	for (i = 0; i < I40E_HLUT_ARRAY_SIZE; i++)
5198	vsi->rss_lut_user[i] = (u8)(rxfh->indir[i]);
5199	else
5200	i40e_fill_rss_lut(pf, lut: vsi->rss_lut_user, I40E_HLUT_ARRAY_SIZE,
5201	rss_size: vsi->rss_size);
5202
5203	return i40e_config_rss(vsi, seed, lut: vsi->rss_lut_user,
5204	I40E_HLUT_ARRAY_SIZE);
5205	}
5206
5207	/**
5208	* i40e_get_priv_flags - report device private flags
5209	* @dev: network interface device structure
5210	*
5211	* The get string set count and the string set should be matched for each
5212	* flag returned. Add new strings for each flag to the i40e_gstrings_priv_flags
5213	* array.
5214	*
5215	* Returns a u32 bitmap of flags.
5216	**/
5217	static u32 i40e_get_priv_flags(struct net_device *dev)
5218	{
5219	struct i40e_netdev_priv *np = netdev_priv(dev);
5220	struct i40e_vsi *vsi = np->vsi;
5221	struct i40e_pf *pf = vsi->back;
5222	u32 i, j, ret_flags = 0;
5223
5224	for (i = 0; i < I40E_PRIV_FLAGS_STR_LEN; i++) {
5225	const struct i40e_priv_flags *priv_flag;
5226
5227	priv_flag = &i40e_gstrings_priv_flags[i];
5228
5229	if (test_bit(priv_flag->bitno, pf->flags))
5230	ret_flags |= BIT(i);
5231	}
5232
5233	if (pf->hw.pf_id != 0)
5234	return ret_flags;
5235
5236	for (j = 0; j < I40E_GL_PRIV_FLAGS_STR_LEN; j++) {
5237	const struct i40e_priv_flags *priv_flag;
5238
5239	priv_flag = &i40e_gl_gstrings_priv_flags[j];
5240
5241	if (test_bit(priv_flag->bitno, pf->flags))
5242	ret_flags |= BIT(i + j);
5243	}
5244
5245	return ret_flags;
5246	}
5247
5248	/**
5249	* i40e_set_priv_flags - set private flags
5250	* @dev: network interface device structure
5251	* @flags: bit flags to be set
5252	**/
5253	static int i40e_set_priv_flags(struct net_device *dev, u32 flags)
5254	{
5255	DECLARE_BITMAP(changed_flags, I40E_PF_FLAGS_NBITS);
5256	DECLARE_BITMAP(orig_flags, I40E_PF_FLAGS_NBITS);
5257	DECLARE_BITMAP(new_flags, I40E_PF_FLAGS_NBITS);
5258	struct i40e_netdev_priv *np = netdev_priv(dev);
5259	enum i40e_admin_queue_err adq_err;
5260	struct i40e_vsi *vsi = np->vsi;
5261	struct i40e_pf *pf = vsi->back;
5262	u32 reset_needed = 0;
5263	int status;
5264	u32 i, j;
5265
5266	bitmap_copy(dst: orig_flags, src: pf->flags, nbits: I40E_PF_FLAGS_NBITS);
5267	bitmap_copy(dst: new_flags, src: pf->flags, nbits: I40E_PF_FLAGS_NBITS);
5268
5269	for (i = 0; i < I40E_PRIV_FLAGS_STR_LEN; i++) {
5270	const struct i40e_priv_flags *priv_flag;
5271	bool new_val;
5272
5273	priv_flag = &i40e_gstrings_priv_flags[i];
5274	new_val = (flags & BIT(i)) ? true : false;
5275
5276	/* If this is a read-only flag, it can't be changed */
5277	if (priv_flag->read_only &&
5278	test_bit(priv_flag->bitno, orig_flags) != new_val)
5279	return -EOPNOTSUPP;
5280
5281	if (new_val)
5282	set_bit(nr: priv_flag->bitno, addr: new_flags);
5283	else
5284	clear_bit(nr: priv_flag->bitno, addr: new_flags);
5285	}
5286
5287	if (pf->hw.pf_id != 0)
5288	goto flags_complete;
5289
5290	for (j = 0; j < I40E_GL_PRIV_FLAGS_STR_LEN; j++) {
5291	const struct i40e_priv_flags *priv_flag;
5292	bool new_val;
5293
5294	priv_flag = &i40e_gl_gstrings_priv_flags[j];
5295	new_val = (flags & BIT(i + j)) ? true : false;
5296
5297	/* If this is a read-only flag, it can't be changed */
5298	if (priv_flag->read_only &&
5299	test_bit(priv_flag->bitno, orig_flags) != new_val)
5300	return -EOPNOTSUPP;
5301
5302	if (new_val)
5303	set_bit(nr: priv_flag->bitno, addr: new_flags);
5304	else
5305	clear_bit(nr: priv_flag->bitno, addr: new_flags);
5306	}
5307
5308	flags_complete:
5309	bitmap_xor(dst: changed_flags, src1: pf->flags, src2: orig_flags, nbits: I40E_PF_FLAGS_NBITS);
5310
5311	if (test_bit(I40E_FLAG_FW_LLDP_DIS, changed_flags))
5312	reset_needed = I40E_PF_RESET_AND_REBUILD_FLAG;
5313
5314	if (test_bit(I40E_FLAG_VEB_STATS_ENA, changed_flags) ||
5315	test_bit(I40E_FLAG_LEGACY_RX_ENA, changed_flags) ||
5316	test_bit(I40E_FLAG_SOURCE_PRUNING_DIS, changed_flags))
5317	reset_needed = BIT(__I40E_PF_RESET_REQUESTED);
5318
5319	/* Before we finalize any flag changes, we need to perform some
5320	* checks to ensure that the changes are supported and safe.
5321	*/
5322
5323	/* ATR eviction is not supported on all devices */
5324	if (test_bit(I40E_FLAG_HW_ATR_EVICT_ENA, new_flags) &&
5325	!test_bit(I40E_HW_CAP_ATR_EVICT, pf->hw.caps))
5326	return -EOPNOTSUPP;
5327
5328	/* If the driver detected FW LLDP was disabled on init, this flag could
5329	* be set, however we do not support _changing_ the flag:
5330	* - on XL710 if NPAR is enabled or FW API version < 1.7
5331	* - on X722 with FW API version < 1.6
5332	* There are situations where older FW versions/NPAR enabled PFs could
5333	* disable LLDP, however we _must_ not allow the user to enable/disable
5334	* LLDP with this flag on unsupported FW versions.
5335	*/
5336	if (test_bit(I40E_FLAG_FW_LLDP_DIS, changed_flags) &&
5337	!test_bit(I40E_HW_CAP_FW_LLDP_STOPPABLE, pf->hw.caps)) {
5338	dev_warn(&pf->pdev->dev,
5339	"Device does not support changing FW LLDP\n");
5340	return -EOPNOTSUPP;
5341	}
5342
5343	if (test_bit(I40E_FLAG_RS_FEC, changed_flags) &&
5344	pf->hw.device_id != I40E_DEV_ID_25G_SFP28 &&
5345	pf->hw.device_id != I40E_DEV_ID_25G_B) {
5346	dev_warn(&pf->pdev->dev,
5347	"Device does not support changing FEC configuration\n");
5348	return -EOPNOTSUPP;
5349	}
5350
5351	if (test_bit(I40E_FLAG_BASE_R_FEC, changed_flags) &&
5352	pf->hw.device_id != I40E_DEV_ID_25G_SFP28 &&
5353	pf->hw.device_id != I40E_DEV_ID_25G_B &&
5354	pf->hw.device_id != I40E_DEV_ID_KX_X722) {
5355	dev_warn(&pf->pdev->dev,
5356	"Device does not support changing FEC configuration\n");
5357	return -EOPNOTSUPP;
5358	}
5359
5360	/* Process any additional changes needed as a result of flag changes.
5361	* The changed_flags value reflects the list of bits that were
5362	* changed in the code above.
5363	*/
5364
5365	/* Flush current ATR settings if ATR was disabled */
5366	if (test_bit(I40E_FLAG_FD_ATR_ENA, changed_flags) &&
5367	!test_bit(I40E_FLAG_FD_ATR_ENA, new_flags)) {
5368	set_bit(nr: __I40E_FD_ATR_AUTO_DISABLED, addr: pf->state);
5369	set_bit(nr: __I40E_FD_FLUSH_REQUESTED, addr: pf->state);
5370	}
5371
5372	if (test_bit(I40E_FLAG_TRUE_PROMISC_ENA, changed_flags)) {
5373	u16 sw_flags = 0, valid_flags = 0;
5374	int ret;
5375
5376	if (!test_bit(I40E_FLAG_TRUE_PROMISC_ENA, new_flags))
5377	sw_flags = I40E_AQ_SET_SWITCH_CFG_PROMISC;
5378	valid_flags = I40E_AQ_SET_SWITCH_CFG_PROMISC;
5379	ret = i40e_aq_set_switch_config(hw: &pf->hw, flags: sw_flags, valid_flags,
5380	mode: 0, NULL);
5381	if (ret && pf->hw.aq.asq_last_status != I40E_AQ_RC_ESRCH) {
5382	dev_info(&pf->pdev->dev,
5383	"couldn't set switch config bits, err %pe aq_err %s\n",
5384	ERR_PTR(ret),
5385	i40e_aq_str(&pf->hw,
5386	pf->hw.aq.asq_last_status));
5387	/* not a fatal problem, just keep going */
5388	}
5389	}
5390
5391	if (test_bit(I40E_FLAG_RS_FEC, changed_flags) ||
5392	test_bit(I40E_FLAG_BASE_R_FEC, changed_flags)) {
5393	u8 fec_cfg = 0;
5394
5395	if (test_bit(I40E_FLAG_RS_FEC, new_flags) &&
5396	test_bit(I40E_FLAG_BASE_R_FEC, new_flags)) {
5397	fec_cfg = I40E_AQ_SET_FEC_AUTO;
5398	} else if (test_bit(I40E_FLAG_RS_FEC, new_flags)) {
5399	fec_cfg = (I40E_AQ_SET_FEC_REQUEST_RS |
5400	I40E_AQ_SET_FEC_ABILITY_RS);
5401	} else if (test_bit(I40E_FLAG_BASE_R_FEC, new_flags)) {
5402	fec_cfg = (I40E_AQ_SET_FEC_REQUEST_KR |
5403	I40E_AQ_SET_FEC_ABILITY_KR);
5404	}
5405	if (i40e_set_fec_cfg(netdev: dev, fec_cfg))
5406	dev_warn(&pf->pdev->dev, "Cannot change FEC config\n");
5407	}
5408
5409	if (test_bit(I40E_FLAG_LINK_DOWN_ON_CLOSE_ENA, changed_flags) &&
5410	test_bit(I40E_FLAG_TOTAL_PORT_SHUTDOWN_ENA, orig_flags)) {
5411	dev_err(&pf->pdev->dev,
5412	"Setting link-down-on-close not supported on this port (because total-port-shutdown is enabled)\n");
5413	return -EOPNOTSUPP;
5414	}
5415
5416	if (test_bit(I40E_FLAG_VF_VLAN_PRUNING_ENA, changed_flags) &&
5417	pf->num_alloc_vfs) {
5418	dev_warn(&pf->pdev->dev,
5419	"Changing vf-vlan-pruning flag while VF(s) are active is not supported\n");
5420	return -EOPNOTSUPP;
5421	}
5422
5423	if (test_bit(I40E_FLAG_LEGACY_RX_ENA, changed_flags) &&
5424	I40E_2K_TOO_SMALL_WITH_PADDING) {
5425	dev_warn(&pf->pdev->dev,
5426	"2k Rx buffer is too small to fit standard MTU and skb_shared_info\n");
5427	return -EOPNOTSUPP;
5428	}
5429
5430	if (test_bit(I40E_FLAG_LINK_DOWN_ON_CLOSE_ENA, changed_flags) &&
5431	test_bit(I40E_FLAG_LINK_DOWN_ON_CLOSE_ENA, new_flags) &&
5432	test_bit(I40E_FLAG_MFP_ENA, new_flags))
5433	dev_warn(&pf->pdev->dev,
5434	"Turning on link-down-on-close flag may affect other partitions\n");
5435
5436	if (test_bit(I40E_FLAG_FW_LLDP_DIS, changed_flags)) {
5437	if (test_bit(I40E_FLAG_FW_LLDP_DIS, new_flags)) {
5438	#ifdef CONFIG_I40E_DCB
5439	i40e_dcb_sw_default_config(pf);
5440	#endif /* CONFIG_I40E_DCB */
5441	i40e_aq_cfg_lldp_mib_change_event(hw: &pf->hw, enable_update: false, NULL);
5442	i40e_aq_stop_lldp(hw: &pf->hw, shutdown_agent: true, persist: false, NULL);
5443	} else {
5444	status = i40e_aq_start_lldp(hw: &pf->hw, persist: false, NULL);
5445	if (status) {
5446	adq_err = pf->hw.aq.asq_last_status;
5447	switch (adq_err) {
5448	case I40E_AQ_RC_EEXIST:
5449	dev_warn(&pf->pdev->dev,
5450	"FW LLDP agent is already running\n");
5451	reset_needed = 0;
5452	break;
5453	case I40E_AQ_RC_EPERM:
5454	dev_warn(&pf->pdev->dev,
5455	"Device configuration forbids SW from starting the LLDP agent.\n");
5456	return -EINVAL;
5457	case I40E_AQ_RC_EAGAIN:
5458	dev_warn(&pf->pdev->dev,
5459	"Stop FW LLDP agent command is still being processed, please try again in a second.\n");
5460	return -EBUSY;
5461	default:
5462	dev_warn(&pf->pdev->dev,
5463	"Starting FW LLDP agent failed: error: %pe, %s\n",
5464	ERR_PTR(status),
5465	i40e_aq_str(&pf->hw,
5466	adq_err));
5467	return -EINVAL;
5468	}
5469	}
5470	}
5471	}
5472
5473	/* Now that we've checked to ensure that the new flags are valid, load
5474	* them into place. Since we only modify flags either (a) during
5475	* initialization or (b) while holding the RTNL lock, we don't need
5476	* anything fancy here.
5477	*/
5478	bitmap_copy(dst: pf->flags, src: new_flags, nbits: I40E_PF_FLAGS_NBITS);
5479
5480	/* Issue reset to cause things to take effect, as additional bits
5481	* are added we will need to create a mask of bits requiring reset
5482	*/
5483	if (reset_needed)
5484	i40e_do_reset(pf, reset_flags: reset_needed, lock_acquired: true);
5485
5486	return 0;
5487	}
5488
5489	/**
5490	* i40e_get_module_info - get (Q)SFP+ module type info
5491	* @netdev: network interface device structure
5492	* @modinfo: module EEPROM size and layout information structure
5493	**/
5494	static int i40e_get_module_info(struct net_device *netdev,
5495	struct ethtool_modinfo *modinfo)
5496	{
5497	struct i40e_netdev_priv *np = netdev_priv(dev: netdev);
5498	struct i40e_vsi *vsi = np->vsi;
5499	struct i40e_pf *pf = vsi->back;
5500	struct i40e_hw *hw = &pf->hw;
5501	u32 sff8472_comp = 0;
5502	u32 sff8472_swap = 0;
5503	u32 sff8636_rev = 0;
5504	u32 type = 0;
5505	int status;
5506
5507	/* Check if firmware supports reading module EEPROM. */
5508	if (!test_bit(I40E_HW_CAP_AQ_PHY_ACCESS, hw->caps)) {
5509	netdev_err(dev: vsi->netdev, format: "Module EEPROM memory read not supported. Please update the NVM image.\n");
5510	return -EINVAL;
5511	}
5512
5513	status = i40e_update_link_info(hw);
5514	if (status)
5515	return -EIO;
5516
5517	if (hw->phy.link_info.phy_type == I40E_PHY_TYPE_EMPTY) {
5518	netdev_err(dev: vsi->netdev, format: "Cannot read module EEPROM memory. No module connected.\n");
5519	return -EINVAL;
5520	}
5521
5522	type = hw->phy.link_info.module_type[0];
5523
5524	switch (type) {
5525	case I40E_MODULE_TYPE_SFP:
5526	status = i40e_aq_get_phy_register(hw,
5527	I40E_AQ_PHY_REG_ACCESS_EXTERNAL_MODULE,
5528	I40E_I2C_EEPROM_DEV_ADDR, true,
5529	I40E_MODULE_SFF_8472_COMP,
5530	&sff8472_comp, NULL);
5531	if (status)
5532	return -EIO;
5533
5534	status = i40e_aq_get_phy_register(hw,
5535	I40E_AQ_PHY_REG_ACCESS_EXTERNAL_MODULE,
5536	I40E_I2C_EEPROM_DEV_ADDR, true,
5537	I40E_MODULE_SFF_8472_SWAP,
5538	&sff8472_swap, NULL);
5539	if (status)
5540	return -EIO;
5541
5542	/* Check if the module requires address swap to access
5543	* the other EEPROM memory page.
5544	*/
5545	if (sff8472_swap & I40E_MODULE_SFF_ADDR_MODE) {
5546	netdev_warn(dev: vsi->netdev, format: "Module address swap to access page 0xA2 is not supported.\n");
5547	modinfo->type = ETH_MODULE_SFF_8079;
5548	modinfo->eeprom_len = ETH_MODULE_SFF_8079_LEN;
5549	} else if (sff8472_comp == 0x00) {
5550	/* Module is not SFF-8472 compliant */
5551	modinfo->type = ETH_MODULE_SFF_8079;
5552	modinfo->eeprom_len = ETH_MODULE_SFF_8079_LEN;
5553	} else if (!(sff8472_swap & I40E_MODULE_SFF_DDM_IMPLEMENTED)) {
5554	/* Module is SFF-8472 compliant but doesn't implement
5555	* Digital Diagnostic Monitoring (DDM).
5556	*/
5557	modinfo->type = ETH_MODULE_SFF_8079;
5558	modinfo->eeprom_len = ETH_MODULE_SFF_8079_LEN;
5559	} else {
5560	modinfo->type = ETH_MODULE_SFF_8472;
5561	modinfo->eeprom_len = ETH_MODULE_SFF_8472_LEN;
5562	}
5563	break;
5564	case I40E_MODULE_TYPE_QSFP_PLUS:
5565	/* Read from memory page 0. */
5566	status = i40e_aq_get_phy_register(hw,
5567	I40E_AQ_PHY_REG_ACCESS_EXTERNAL_MODULE,
5568	0, true,
5569	I40E_MODULE_REVISION_ADDR,
5570	&sff8636_rev, NULL);
5571	if (status)
5572	return -EIO;
5573	/* Determine revision compliance byte */
5574	if (sff8636_rev > 0x02) {
5575	/* Module is SFF-8636 compliant */
5576	modinfo->type = ETH_MODULE_SFF_8636;
5577	modinfo->eeprom_len = I40E_MODULE_QSFP_MAX_LEN;
5578	} else {
5579	modinfo->type = ETH_MODULE_SFF_8436;
5580	modinfo->eeprom_len = I40E_MODULE_QSFP_MAX_LEN;
5581	}
5582	break;
5583	case I40E_MODULE_TYPE_QSFP28:
5584	modinfo->type = ETH_MODULE_SFF_8636;
5585	modinfo->eeprom_len = I40E_MODULE_QSFP_MAX_LEN;
5586	break;
5587	default:
5588	netdev_dbg(vsi->netdev, "SFP module type unrecognized or no SFP connector used.\n");
5589	return -EOPNOTSUPP;
5590	}
5591	return 0;
5592	}
5593
5594	/**
5595	* i40e_get_module_eeprom - fills buffer with (Q)SFP+ module memory contents
5596	* @netdev: network interface device structure
5597	* @ee: EEPROM dump request structure
5598	* @data: buffer to be filled with EEPROM contents
5599	**/
5600	static int i40e_get_module_eeprom(struct net_device *netdev,
5601	struct ethtool_eeprom *ee,
5602	u8 *data)
5603	{
5604	struct i40e_netdev_priv *np = netdev_priv(dev: netdev);
5605	struct i40e_vsi *vsi = np->vsi;
5606	struct i40e_pf *pf = vsi->back;
5607	struct i40e_hw *hw = &pf->hw;
5608	bool is_sfp = false;
5609	u32 value = 0;
5610	int status;
5611	int i;
5612
5613	if (!ee || !ee->len || !data)
5614	return -EINVAL;
5615
5616	if (hw->phy.link_info.module_type[0] == I40E_MODULE_TYPE_SFP)
5617	is_sfp = true;
5618
5619	for (i = 0; i < ee->len; i++) {
5620	u32 offset = i + ee->offset;
5621	u32 addr = is_sfp ? I40E_I2C_EEPROM_DEV_ADDR : 0;
5622
5623	/* Check if we need to access the other memory page */
5624	if (is_sfp) {
5625	if (offset >= ETH_MODULE_SFF_8079_LEN) {
5626	offset -= ETH_MODULE_SFF_8079_LEN;
5627	addr = I40E_I2C_EEPROM_DEV_ADDR2;
5628	}
5629	} else {
5630	while (offset >= ETH_MODULE_SFF_8436_LEN) {
5631	/* Compute memory page number and offset. */
5632	offset -= ETH_MODULE_SFF_8436_LEN / 2;
5633	addr++;
5634	}
5635	}
5636
5637	status = i40e_aq_get_phy_register(hw,
5638	I40E_AQ_PHY_REG_ACCESS_EXTERNAL_MODULE,
5639	addr, true, offset, &value, NULL);
5640	if (status)
5641	return -EIO;
5642	data[i] = value;
5643	}
5644	return 0;
5645	}
5646
5647	static int i40e_get_eee(struct net_device *netdev, struct ethtool_keee *edata)
5648	{
5649	struct i40e_netdev_priv *np = netdev_priv(dev: netdev);
5650	struct i40e_aq_get_phy_abilities_resp phy_cfg;
5651	struct i40e_vsi *vsi = np->vsi;
5652	struct i40e_pf *pf = vsi->back;
5653	struct i40e_hw *hw = &pf->hw;
5654	int status = 0;
5655
5656	/* Get initial PHY capabilities */
5657	status = i40e_aq_get_phy_capabilities(hw, qualified_modules: false, report_init: true, abilities: &phy_cfg, NULL);
5658	if (status)
5659	return -EAGAIN;
5660
5661	/* Check whether NIC configuration is compatible with Energy Efficient
5662	* Ethernet (EEE) mode.
5663	*/
5664	if (phy_cfg.eee_capability == 0)
5665	return -EOPNOTSUPP;
5666
5667	/* Get current configuration */
5668	status = i40e_aq_get_phy_capabilities(hw, qualified_modules: false, report_init: false, abilities: &phy_cfg, NULL);
5669	if (status)
5670	return -EAGAIN;
5671
5672	edata->eee_enabled = !!phy_cfg.eee_capability;
5673	edata->tx_lpi_enabled = pf->stats.tx_lpi_status;
5674
5675	edata->eee_active = pf->stats.tx_lpi_status && pf->stats.rx_lpi_status;
5676
5677	return 0;
5678	}
5679
5680	static int i40e_is_eee_param_supported(struct net_device *netdev,
5681	struct ethtool_keee *edata)
5682	{
5683	struct i40e_netdev_priv *np = netdev_priv(dev: netdev);
5684	struct i40e_vsi *vsi = np->vsi;
5685	struct i40e_pf *pf = vsi->back;
5686	struct i40e_ethtool_not_used {
5687	u32 value;
5688	const char *name;
5689	} param[] = {
5690	{edata->tx_lpi_timer, "tx-timer"},
5691	{edata->tx_lpi_enabled != pf->stats.tx_lpi_status, "tx-lpi"}
5692	};
5693	int i;
5694
5695	for (i = 0; i < ARRAY_SIZE(param); i++) {
5696	if (param[i].value) {
5697	netdev_info(dev: netdev,
5698	format: "EEE setting %s not supported\n",
5699	param[i].name);
5700	return -EOPNOTSUPP;
5701	}
5702	}
5703
5704	return 0;
5705	}
5706
5707	static int i40e_set_eee(struct net_device *netdev, struct ethtool_keee *edata)
5708	{
5709	struct i40e_netdev_priv *np = netdev_priv(dev: netdev);
5710	struct i40e_aq_get_phy_abilities_resp abilities;
5711	struct i40e_aq_set_phy_config config;
5712	struct i40e_vsi *vsi = np->vsi;
5713	struct i40e_pf *pf = vsi->back;
5714	struct i40e_hw *hw = &pf->hw;
5715	__le16 eee_capability;
5716	int status = 0;
5717
5718	/* Deny parameters we don't support */
5719	if (i40e_is_eee_param_supported(netdev, edata))
5720	return -EOPNOTSUPP;
5721
5722	/* Get initial PHY capabilities */
5723	status = i40e_aq_get_phy_capabilities(hw, qualified_modules: false, report_init: true, abilities: &abilities,
5724	NULL);
5725	if (status)
5726	return -EAGAIN;
5727
5728	/* Check whether NIC configuration is compatible with Energy Efficient
5729	* Ethernet (EEE) mode.
5730	*/
5731	if (abilities.eee_capability == 0)
5732	return -EOPNOTSUPP;
5733
5734	/* Cache initial EEE capability */
5735	eee_capability = abilities.eee_capability;
5736
5737	/* Get current PHY configuration */
5738	status = i40e_aq_get_phy_capabilities(hw, qualified_modules: false, report_init: false, abilities: &abilities,
5739	NULL);
5740	if (status)
5741	return -EAGAIN;
5742
5743	/* Cache current PHY configuration */
5744	config.phy_type = abilities.phy_type;
5745	config.phy_type_ext = abilities.phy_type_ext;
5746	config.link_speed = abilities.link_speed;
5747	config.abilities = abilities.abilities |
5748	I40E_AQ_PHY_ENABLE_ATOMIC_LINK;
5749	config.eeer = abilities.eeer_val;
5750	config.low_power_ctrl = abilities.d3_lpan;
5751	config.fec_config = abilities.fec_cfg_curr_mod_ext_info &
5752	I40E_AQ_PHY_FEC_CONFIG_MASK;
5753
5754	/* Set desired EEE state */
5755	if (edata->eee_enabled) {
5756	config.eee_capability = eee_capability;
5757	config.eeer |= cpu_to_le32(I40E_PRTPM_EEER_TX_LPI_EN_MASK);
5758	} else {
5759	config.eee_capability = 0;
5760	config.eeer &= cpu_to_le32(~I40E_PRTPM_EEER_TX_LPI_EN_MASK);
5761	}
5762
5763	/* Apply modified PHY configuration */
5764	status = i40e_aq_set_phy_config(hw, config: &config, NULL);
5765	if (status)
5766	return -EAGAIN;
5767
5768	return 0;
5769	}
5770
5771	static const struct ethtool_ops i40e_ethtool_recovery_mode_ops = {
5772	.get_drvinfo = i40e_get_drvinfo,
5773	.set_eeprom = i40e_set_eeprom,
5774	.get_eeprom_len = i40e_get_eeprom_len,
5775	.get_eeprom = i40e_get_eeprom,
5776	};
5777
5778	static const struct ethtool_ops i40e_ethtool_ops = {
5779	.supported_coalesce_params = ETHTOOL_COALESCE_USECS |
5780	ETHTOOL_COALESCE_TX_MAX_FRAMES_IRQ |
5781	ETHTOOL_COALESCE_USE_ADAPTIVE |
5782	ETHTOOL_COALESCE_RX_USECS_HIGH |
5783	ETHTOOL_COALESCE_TX_USECS_HIGH,
5784	.get_drvinfo = i40e_get_drvinfo,
5785	.get_regs_len = i40e_get_regs_len,
5786	.get_regs = i40e_get_regs,
5787	.nway_reset = i40e_nway_reset,
5788	.get_link = ethtool_op_get_link,
5789	.get_wol = i40e_get_wol,
5790	.set_wol = i40e_set_wol,
5791	.set_eeprom = i40e_set_eeprom,
5792	.get_eeprom_len = i40e_get_eeprom_len,
5793	.get_eeprom = i40e_get_eeprom,
5794	.get_ringparam = i40e_get_ringparam,
5795	.set_ringparam = i40e_set_ringparam,
5796	.get_pauseparam = i40e_get_pauseparam,
5797	.set_pauseparam = i40e_set_pauseparam,
5798	.get_msglevel = i40e_get_msglevel,
5799	.set_msglevel = i40e_set_msglevel,
5800	.get_rxnfc = i40e_get_rxnfc,
5801	.set_rxnfc = i40e_set_rxnfc,
5802	.self_test = i40e_diag_test,
5803	.get_strings = i40e_get_strings,
5804	.get_eee = i40e_get_eee,
5805	.set_eee = i40e_set_eee,
5806	.set_phys_id = i40e_set_phys_id,
5807	.get_sset_count = i40e_get_sset_count,
5808	.get_ethtool_stats = i40e_get_ethtool_stats,
5809	.get_coalesce = i40e_get_coalesce,
5810	.set_coalesce = i40e_set_coalesce,
5811	.get_rxfh_key_size = i40e_get_rxfh_key_size,
5812	.get_rxfh_indir_size = i40e_get_rxfh_indir_size,
5813	.get_rxfh = i40e_get_rxfh,
5814	.set_rxfh = i40e_set_rxfh,
5815	.get_channels = i40e_get_channels,
5816	.set_channels = i40e_set_channels,
5817	.get_module_info = i40e_get_module_info,
5818	.get_module_eeprom = i40e_get_module_eeprom,
5819	.get_ts_info = i40e_get_ts_info,
5820	.get_priv_flags = i40e_get_priv_flags,
5821	.set_priv_flags = i40e_set_priv_flags,
5822	.get_per_queue_coalesce = i40e_get_per_queue_coalesce,
5823	.set_per_queue_coalesce = i40e_set_per_queue_coalesce,
5824	.get_link_ksettings = i40e_get_link_ksettings,
5825	.set_link_ksettings = i40e_set_link_ksettings,
5826	.get_fecparam = i40e_get_fec_param,
5827	.set_fecparam = i40e_set_fec_param,
5828	.flash_device = i40e_ddp_flash,
5829	};
5830
5831	void i40e_set_ethtool_ops(struct net_device *netdev)
5832	{
5833	struct i40e_netdev_priv *np = netdev_priv(dev: netdev);
5834	struct i40e_pf *pf = np->vsi->back;
5835
5836	if (!test_bit(__I40E_RECOVERY_MODE, pf->state))
5837	netdev->ethtool_ops = &i40e_ethtool_ops;
5838	else
5839	netdev->ethtool_ops = &i40e_ethtool_recovery_mode_ops;
5840	}
5841