xref: /linux/drivers/net/ethernet/intel/iavf/iavf_ethtool.c (revision 576d7fed09c7edbae7600f29a8a3ed6c1ead904f)
1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright(c) 2013 - 2018 Intel Corporation. */
3 
4 /* ethtool support for iavf */
5 #include "iavf.h"
6 
7 #include <linux/uaccess.h>
8 
9 /* ethtool statistics helpers */
10 
11 /**
12  * struct iavf_stats - definition for an ethtool statistic
13  * @stat_string: statistic name to display in ethtool -S output
14  * @sizeof_stat: the sizeof() the stat, must be no greater than sizeof(u64)
15  * @stat_offset: offsetof() the stat from a base pointer
16  *
17  * This structure defines a statistic to be added to the ethtool stats buffer.
18  * It defines a statistic as offset from a common base pointer. Stats should
19  * be defined in constant arrays using the IAVF_STAT macro, with every element
20  * of the array using the same _type for calculating the sizeof_stat and
21  * stat_offset.
22  *
23  * The @sizeof_stat is expected to be sizeof(u8), sizeof(u16), sizeof(u32) or
24  * sizeof(u64). Other sizes are not expected and will produce a WARN_ONCE from
25  * the iavf_add_ethtool_stat() helper function.
26  *
27  * The @stat_string is interpreted as a format string, allowing formatted
28  * values to be inserted while looping over multiple structures for a given
29  * statistics array. Thus, every statistic string in an array should have the
30  * same type and number of format specifiers, to be formatted by variadic
31  * arguments to the iavf_add_stat_string() helper function.
32  **/
33 struct iavf_stats {
34 	char stat_string[ETH_GSTRING_LEN];
35 	int sizeof_stat;
36 	int stat_offset;
37 };
38 
39 /* Helper macro to define an iavf_stat structure with proper size and type.
40  * Use this when defining constant statistics arrays. Note that @_type expects
41  * only a type name and is used multiple times.
42  */
43 #define IAVF_STAT(_type, _name, _stat) { \
44 	.stat_string = _name, \
45 	.sizeof_stat = sizeof_field(_type, _stat), \
46 	.stat_offset = offsetof(_type, _stat) \
47 }
48 
49 /* Helper macro for defining some statistics related to queues */
50 #define IAVF_QUEUE_STAT(_name, _stat) \
51 	IAVF_STAT(struct iavf_ring, _name, _stat)
52 
53 /* Stats associated with a Tx or Rx ring */
54 static const struct iavf_stats iavf_gstrings_queue_stats[] = {
55 	IAVF_QUEUE_STAT("%s-%u.packets", stats.packets),
56 	IAVF_QUEUE_STAT("%s-%u.bytes", stats.bytes),
57 };
58 
59 /**
60  * iavf_add_one_ethtool_stat - copy the stat into the supplied buffer
61  * @data: location to store the stat value
62  * @pointer: basis for where to copy from
63  * @stat: the stat definition
64  *
65  * Copies the stat data defined by the pointer and stat structure pair into
66  * the memory supplied as data. Used to implement iavf_add_ethtool_stats and
67  * iavf_add_queue_stats. If the pointer is null, data will be zero'd.
68  */
69 static void
70 iavf_add_one_ethtool_stat(u64 *data, void *pointer,
71 			  const struct iavf_stats *stat)
72 {
73 	char *p;
74 
75 	if (!pointer) {
76 		/* ensure that the ethtool data buffer is zero'd for any stats
77 		 * which don't have a valid pointer.
78 		 */
79 		*data = 0;
80 		return;
81 	}
82 
83 	p = (char *)pointer + stat->stat_offset;
84 	switch (stat->sizeof_stat) {
85 	case sizeof(u64):
86 		*data = *((u64 *)p);
87 		break;
88 	case sizeof(u32):
89 		*data = *((u32 *)p);
90 		break;
91 	case sizeof(u16):
92 		*data = *((u16 *)p);
93 		break;
94 	case sizeof(u8):
95 		*data = *((u8 *)p);
96 		break;
97 	default:
98 		WARN_ONCE(1, "unexpected stat size for %s",
99 			  stat->stat_string);
100 		*data = 0;
101 	}
102 }
103 
104 /**
105  * __iavf_add_ethtool_stats - copy stats into the ethtool supplied buffer
106  * @data: ethtool stats buffer
107  * @pointer: location to copy stats from
108  * @stats: array of stats to copy
109  * @size: the size of the stats definition
110  *
111  * Copy the stats defined by the stats array using the pointer as a base into
112  * the data buffer supplied by ethtool. Updates the data pointer to point to
113  * the next empty location for successive calls to __iavf_add_ethtool_stats.
114  * If pointer is null, set the data values to zero and update the pointer to
115  * skip these stats.
116  **/
117 static void
118 __iavf_add_ethtool_stats(u64 **data, void *pointer,
119 			 const struct iavf_stats stats[],
120 			 const unsigned int size)
121 {
122 	unsigned int i;
123 
124 	for (i = 0; i < size; i++)
125 		iavf_add_one_ethtool_stat((*data)++, pointer, &stats[i]);
126 }
127 
128 /**
129  * iavf_add_ethtool_stats - copy stats into ethtool supplied buffer
130  * @data: ethtool stats buffer
131  * @pointer: location where stats are stored
132  * @stats: static const array of stat definitions
133  *
134  * Macro to ease the use of __iavf_add_ethtool_stats by taking a static
135  * constant stats array and passing the ARRAY_SIZE(). This avoids typos by
136  * ensuring that we pass the size associated with the given stats array.
137  *
138  * The parameter @stats is evaluated twice, so parameters with side effects
139  * should be avoided.
140  **/
141 #define iavf_add_ethtool_stats(data, pointer, stats) \
142 	__iavf_add_ethtool_stats(data, pointer, stats, ARRAY_SIZE(stats))
143 
144 /**
145  * iavf_add_queue_stats - copy queue statistics into supplied buffer
146  * @data: ethtool stats buffer
147  * @ring: the ring to copy
148  *
149  * Queue statistics must be copied while protected by
150  * u64_stats_fetch_begin, so we can't directly use iavf_add_ethtool_stats.
151  * Assumes that queue stats are defined in iavf_gstrings_queue_stats. If the
152  * ring pointer is null, zero out the queue stat values and update the data
153  * pointer. Otherwise safely copy the stats from the ring into the supplied
154  * buffer and update the data pointer when finished.
155  *
156  * This function expects to be called while under rcu_read_lock().
157  **/
158 static void
159 iavf_add_queue_stats(u64 **data, struct iavf_ring *ring)
160 {
161 	const unsigned int size = ARRAY_SIZE(iavf_gstrings_queue_stats);
162 	const struct iavf_stats *stats = iavf_gstrings_queue_stats;
163 	unsigned int start;
164 	unsigned int i;
165 
166 	/* To avoid invalid statistics values, ensure that we keep retrying
167 	 * the copy until we get a consistent value according to
168 	 * u64_stats_fetch_retry. But first, make sure our ring is
169 	 * non-null before attempting to access its syncp.
170 	 */
171 	do {
172 		start = !ring ? 0 : u64_stats_fetch_begin(&ring->syncp);
173 		for (i = 0; i < size; i++)
174 			iavf_add_one_ethtool_stat(&(*data)[i], ring, &stats[i]);
175 	} while (ring && u64_stats_fetch_retry(&ring->syncp, start));
176 
177 	/* Once we successfully copy the stats in, update the data pointer */
178 	*data += size;
179 }
180 
181 /**
182  * __iavf_add_stat_strings - copy stat strings into ethtool buffer
183  * @p: ethtool supplied buffer
184  * @stats: stat definitions array
185  * @size: size of the stats array
186  *
187  * Format and copy the strings described by stats into the buffer pointed at
188  * by p.
189  **/
190 static void __iavf_add_stat_strings(u8 **p, const struct iavf_stats stats[],
191 				    const unsigned int size, ...)
192 {
193 	unsigned int i;
194 
195 	for (i = 0; i < size; i++) {
196 		va_list args;
197 
198 		va_start(args, size);
199 		vsnprintf(*p, ETH_GSTRING_LEN, stats[i].stat_string, args);
200 		*p += ETH_GSTRING_LEN;
201 		va_end(args);
202 	}
203 }
204 
205 /**
206  * iavf_add_stat_strings - copy stat strings into ethtool buffer
207  * @p: ethtool supplied buffer
208  * @stats: stat definitions array
209  *
210  * Format and copy the strings described by the const static stats value into
211  * the buffer pointed at by p.
212  *
213  * The parameter @stats is evaluated twice, so parameters with side effects
214  * should be avoided. Additionally, stats must be an array such that
215  * ARRAY_SIZE can be called on it.
216  **/
217 #define iavf_add_stat_strings(p, stats, ...) \
218 	__iavf_add_stat_strings(p, stats, ARRAY_SIZE(stats), ## __VA_ARGS__)
219 
220 #define VF_STAT(_name, _stat) \
221 	IAVF_STAT(struct iavf_adapter, _name, _stat)
222 
223 static const struct iavf_stats iavf_gstrings_stats[] = {
224 	VF_STAT("rx_bytes", current_stats.rx_bytes),
225 	VF_STAT("rx_unicast", current_stats.rx_unicast),
226 	VF_STAT("rx_multicast", current_stats.rx_multicast),
227 	VF_STAT("rx_broadcast", current_stats.rx_broadcast),
228 	VF_STAT("rx_discards", current_stats.rx_discards),
229 	VF_STAT("rx_unknown_protocol", current_stats.rx_unknown_protocol),
230 	VF_STAT("tx_bytes", current_stats.tx_bytes),
231 	VF_STAT("tx_unicast", current_stats.tx_unicast),
232 	VF_STAT("tx_multicast", current_stats.tx_multicast),
233 	VF_STAT("tx_broadcast", current_stats.tx_broadcast),
234 	VF_STAT("tx_discards", current_stats.tx_discards),
235 	VF_STAT("tx_errors", current_stats.tx_errors),
236 };
237 
238 #define IAVF_STATS_LEN	ARRAY_SIZE(iavf_gstrings_stats)
239 
240 #define IAVF_QUEUE_STATS_LEN	ARRAY_SIZE(iavf_gstrings_queue_stats)
241 
242 /* For now we have one and only one private flag and it is only defined
243  * when we have support for the SKIP_CPU_SYNC DMA attribute.  Instead
244  * of leaving all this code sitting around empty we will strip it unless
245  * our one private flag is actually available.
246  */
247 struct iavf_priv_flags {
248 	char flag_string[ETH_GSTRING_LEN];
249 	u32 flag;
250 	bool read_only;
251 };
252 
253 #define IAVF_PRIV_FLAG(_name, _flag, _read_only) { \
254 	.flag_string = _name, \
255 	.flag = _flag, \
256 	.read_only = _read_only, \
257 }
258 
259 static const struct iavf_priv_flags iavf_gstrings_priv_flags[] = {
260 	IAVF_PRIV_FLAG("legacy-rx", IAVF_FLAG_LEGACY_RX, 0),
261 };
262 
263 #define IAVF_PRIV_FLAGS_STR_LEN ARRAY_SIZE(iavf_gstrings_priv_flags)
264 
265 /**
266  * iavf_get_link_ksettings - Get Link Speed and Duplex settings
267  * @netdev: network interface device structure
268  * @cmd: ethtool command
269  *
270  * Reports speed/duplex settings. Because this is a VF, we don't know what
271  * kind of link we really have, so we fake it.
272  **/
273 static int iavf_get_link_ksettings(struct net_device *netdev,
274 				   struct ethtool_link_ksettings *cmd)
275 {
276 	struct iavf_adapter *adapter = netdev_priv(netdev);
277 
278 	ethtool_link_ksettings_zero_link_mode(cmd, supported);
279 	cmd->base.autoneg = AUTONEG_DISABLE;
280 	cmd->base.port = PORT_NONE;
281 	cmd->base.duplex = DUPLEX_FULL;
282 
283 	if (ADV_LINK_SUPPORT(adapter)) {
284 		if (adapter->link_speed_mbps &&
285 		    adapter->link_speed_mbps < U32_MAX)
286 			cmd->base.speed = adapter->link_speed_mbps;
287 		else
288 			cmd->base.speed = SPEED_UNKNOWN;
289 
290 		return 0;
291 	}
292 
293 	switch (adapter->link_speed) {
294 	case VIRTCHNL_LINK_SPEED_40GB:
295 		cmd->base.speed = SPEED_40000;
296 		break;
297 	case VIRTCHNL_LINK_SPEED_25GB:
298 		cmd->base.speed = SPEED_25000;
299 		break;
300 	case VIRTCHNL_LINK_SPEED_20GB:
301 		cmd->base.speed = SPEED_20000;
302 		break;
303 	case VIRTCHNL_LINK_SPEED_10GB:
304 		cmd->base.speed = SPEED_10000;
305 		break;
306 	case VIRTCHNL_LINK_SPEED_5GB:
307 		cmd->base.speed = SPEED_5000;
308 		break;
309 	case VIRTCHNL_LINK_SPEED_2_5GB:
310 		cmd->base.speed = SPEED_2500;
311 		break;
312 	case VIRTCHNL_LINK_SPEED_1GB:
313 		cmd->base.speed = SPEED_1000;
314 		break;
315 	case VIRTCHNL_LINK_SPEED_100MB:
316 		cmd->base.speed = SPEED_100;
317 		break;
318 	default:
319 		break;
320 	}
321 
322 	return 0;
323 }
324 
325 /**
326  * iavf_get_sset_count - Get length of string set
327  * @netdev: network interface device structure
328  * @sset: id of string set
329  *
330  * Reports size of various string tables.
331  **/
332 static int iavf_get_sset_count(struct net_device *netdev, int sset)
333 {
334 	/* Report the maximum number queues, even if not every queue is
335 	 * currently configured. Since allocation of queues is in pairs,
336 	 * use netdev->real_num_tx_queues * 2. The real_num_tx_queues is set
337 	 * at device creation and never changes.
338 	 */
339 
340 	if (sset == ETH_SS_STATS)
341 		return IAVF_STATS_LEN +
342 			(IAVF_QUEUE_STATS_LEN * 2 *
343 			 netdev->real_num_tx_queues);
344 	else if (sset == ETH_SS_PRIV_FLAGS)
345 		return IAVF_PRIV_FLAGS_STR_LEN;
346 	else
347 		return -EINVAL;
348 }
349 
350 /**
351  * iavf_get_ethtool_stats - report device statistics
352  * @netdev: network interface device structure
353  * @stats: ethtool statistics structure
354  * @data: pointer to data buffer
355  *
356  * All statistics are added to the data buffer as an array of u64.
357  **/
358 static void iavf_get_ethtool_stats(struct net_device *netdev,
359 				   struct ethtool_stats *stats, u64 *data)
360 {
361 	struct iavf_adapter *adapter = netdev_priv(netdev);
362 	unsigned int i;
363 
364 	/* Explicitly request stats refresh */
365 	iavf_schedule_aq_request(adapter, IAVF_FLAG_AQ_REQUEST_STATS);
366 
367 	iavf_add_ethtool_stats(&data, adapter, iavf_gstrings_stats);
368 
369 	rcu_read_lock();
370 	/* As num_active_queues describe both tx and rx queues, we can use
371 	 * it to iterate over rings' stats.
372 	 */
373 	for (i = 0; i < adapter->num_active_queues; i++) {
374 		struct iavf_ring *ring;
375 
376 		/* Tx rings stats */
377 		ring = &adapter->tx_rings[i];
378 		iavf_add_queue_stats(&data, ring);
379 
380 		/* Rx rings stats */
381 		ring = &adapter->rx_rings[i];
382 		iavf_add_queue_stats(&data, ring);
383 	}
384 	rcu_read_unlock();
385 }
386 
387 /**
388  * iavf_get_priv_flag_strings - Get private flag strings
389  * @netdev: network interface device structure
390  * @data: buffer for string data
391  *
392  * Builds the private flags string table
393  **/
394 static void iavf_get_priv_flag_strings(struct net_device *netdev, u8 *data)
395 {
396 	unsigned int i;
397 
398 	for (i = 0; i < IAVF_PRIV_FLAGS_STR_LEN; i++)
399 		ethtool_sprintf(&data, "%s",
400 				iavf_gstrings_priv_flags[i].flag_string);
401 }
402 
403 /**
404  * iavf_get_stat_strings - Get stat strings
405  * @netdev: network interface device structure
406  * @data: buffer for string data
407  *
408  * Builds the statistics string table
409  **/
410 static void iavf_get_stat_strings(struct net_device *netdev, u8 *data)
411 {
412 	unsigned int i;
413 
414 	iavf_add_stat_strings(&data, iavf_gstrings_stats);
415 
416 	/* Queues are always allocated in pairs, so we just use
417 	 * real_num_tx_queues for both Tx and Rx queues.
418 	 */
419 	for (i = 0; i < netdev->real_num_tx_queues; i++) {
420 		iavf_add_stat_strings(&data, iavf_gstrings_queue_stats,
421 				      "tx", i);
422 		iavf_add_stat_strings(&data, iavf_gstrings_queue_stats,
423 				      "rx", i);
424 	}
425 }
426 
427 /**
428  * iavf_get_strings - Get string set
429  * @netdev: network interface device structure
430  * @sset: id of string set
431  * @data: buffer for string data
432  *
433  * Builds string tables for various string sets
434  **/
435 static void iavf_get_strings(struct net_device *netdev, u32 sset, u8 *data)
436 {
437 	switch (sset) {
438 	case ETH_SS_STATS:
439 		iavf_get_stat_strings(netdev, data);
440 		break;
441 	case ETH_SS_PRIV_FLAGS:
442 		iavf_get_priv_flag_strings(netdev, data);
443 		break;
444 	default:
445 		break;
446 	}
447 }
448 
449 /**
450  * iavf_get_priv_flags - report device private flags
451  * @netdev: network interface device structure
452  *
453  * The get string set count and the string set should be matched for each
454  * flag returned.  Add new strings for each flag to the iavf_gstrings_priv_flags
455  * array.
456  *
457  * Returns a u32 bitmap of flags.
458  **/
459 static u32 iavf_get_priv_flags(struct net_device *netdev)
460 {
461 	struct iavf_adapter *adapter = netdev_priv(netdev);
462 	u32 i, ret_flags = 0;
463 
464 	for (i = 0; i < IAVF_PRIV_FLAGS_STR_LEN; i++) {
465 		const struct iavf_priv_flags *priv_flags;
466 
467 		priv_flags = &iavf_gstrings_priv_flags[i];
468 
469 		if (priv_flags->flag & adapter->flags)
470 			ret_flags |= BIT(i);
471 	}
472 
473 	return ret_flags;
474 }
475 
476 /**
477  * iavf_set_priv_flags - set private flags
478  * @netdev: network interface device structure
479  * @flags: bit flags to be set
480  **/
481 static int iavf_set_priv_flags(struct net_device *netdev, u32 flags)
482 {
483 	struct iavf_adapter *adapter = netdev_priv(netdev);
484 	u32 orig_flags, new_flags, changed_flags;
485 	int ret = 0;
486 	u32 i;
487 
488 	orig_flags = READ_ONCE(adapter->flags);
489 	new_flags = orig_flags;
490 
491 	for (i = 0; i < IAVF_PRIV_FLAGS_STR_LEN; i++) {
492 		const struct iavf_priv_flags *priv_flags;
493 
494 		priv_flags = &iavf_gstrings_priv_flags[i];
495 
496 		if (flags & BIT(i))
497 			new_flags |= priv_flags->flag;
498 		else
499 			new_flags &= ~(priv_flags->flag);
500 
501 		if (priv_flags->read_only &&
502 		    ((orig_flags ^ new_flags) & ~BIT(i)))
503 			return -EOPNOTSUPP;
504 	}
505 
506 	/* Before we finalize any flag changes, any checks which we need to
507 	 * perform to determine if the new flags will be supported should go
508 	 * here...
509 	 */
510 
511 	/* Compare and exchange the new flags into place. If we failed, that
512 	 * is if cmpxchg returns anything but the old value, this means
513 	 * something else must have modified the flags variable since we
514 	 * copied it. We'll just punt with an error and log something in the
515 	 * message buffer.
516 	 */
517 	if (cmpxchg(&adapter->flags, orig_flags, new_flags) != orig_flags) {
518 		dev_warn(&adapter->pdev->dev,
519 			 "Unable to update adapter->flags as it was modified by another thread...\n");
520 		return -EAGAIN;
521 	}
522 
523 	changed_flags = orig_flags ^ new_flags;
524 
525 	/* Process any additional changes needed as a result of flag changes.
526 	 * The changed_flags value reflects the list of bits that were changed
527 	 * in the code above.
528 	 */
529 
530 	/* issue a reset to force legacy-rx change to take effect */
531 	if (changed_flags & IAVF_FLAG_LEGACY_RX) {
532 		if (netif_running(netdev)) {
533 			iavf_schedule_reset(adapter, IAVF_FLAG_RESET_NEEDED);
534 			ret = iavf_wait_for_reset(adapter);
535 			if (ret)
536 				netdev_warn(netdev, "Changing private flags timeout or interrupted waiting for reset");
537 		}
538 	}
539 
540 	return ret;
541 }
542 
543 /**
544  * iavf_get_msglevel - Get debug message level
545  * @netdev: network interface device structure
546  *
547  * Returns current debug message level.
548  **/
549 static u32 iavf_get_msglevel(struct net_device *netdev)
550 {
551 	struct iavf_adapter *adapter = netdev_priv(netdev);
552 
553 	return adapter->msg_enable;
554 }
555 
556 /**
557  * iavf_set_msglevel - Set debug message level
558  * @netdev: network interface device structure
559  * @data: message level
560  *
561  * Set current debug message level. Higher values cause the driver to
562  * be noisier.
563  **/
564 static void iavf_set_msglevel(struct net_device *netdev, u32 data)
565 {
566 	struct iavf_adapter *adapter = netdev_priv(netdev);
567 
568 	if (IAVF_DEBUG_USER & data)
569 		adapter->hw.debug_mask = data;
570 	adapter->msg_enable = data;
571 }
572 
573 /**
574  * iavf_get_drvinfo - Get driver info
575  * @netdev: network interface device structure
576  * @drvinfo: ethool driver info structure
577  *
578  * Returns information about the driver and device for display to the user.
579  **/
580 static void iavf_get_drvinfo(struct net_device *netdev,
581 			     struct ethtool_drvinfo *drvinfo)
582 {
583 	struct iavf_adapter *adapter = netdev_priv(netdev);
584 
585 	strscpy(drvinfo->driver, iavf_driver_name, 32);
586 	strscpy(drvinfo->fw_version, "N/A", 4);
587 	strscpy(drvinfo->bus_info, pci_name(adapter->pdev), 32);
588 	drvinfo->n_priv_flags = IAVF_PRIV_FLAGS_STR_LEN;
589 }
590 
591 /**
592  * iavf_get_ringparam - Get ring parameters
593  * @netdev: network interface device structure
594  * @ring: ethtool ringparam structure
595  * @kernel_ring: ethtool extenal ringparam structure
596  * @extack: netlink extended ACK report struct
597  *
598  * Returns current ring parameters. TX and RX rings are reported separately,
599  * but the number of rings is not reported.
600  **/
601 static void iavf_get_ringparam(struct net_device *netdev,
602 			       struct ethtool_ringparam *ring,
603 			       struct kernel_ethtool_ringparam *kernel_ring,
604 			       struct netlink_ext_ack *extack)
605 {
606 	struct iavf_adapter *adapter = netdev_priv(netdev);
607 
608 	ring->rx_max_pending = IAVF_MAX_RXD;
609 	ring->tx_max_pending = IAVF_MAX_TXD;
610 	ring->rx_pending = adapter->rx_desc_count;
611 	ring->tx_pending = adapter->tx_desc_count;
612 }
613 
614 /**
615  * iavf_set_ringparam - Set ring parameters
616  * @netdev: network interface device structure
617  * @ring: ethtool ringparam structure
618  * @kernel_ring: ethtool external ringparam structure
619  * @extack: netlink extended ACK report struct
620  *
621  * Sets ring parameters. TX and RX rings are controlled separately, but the
622  * number of rings is not specified, so all rings get the same settings.
623  **/
624 static int iavf_set_ringparam(struct net_device *netdev,
625 			      struct ethtool_ringparam *ring,
626 			      struct kernel_ethtool_ringparam *kernel_ring,
627 			      struct netlink_ext_ack *extack)
628 {
629 	struct iavf_adapter *adapter = netdev_priv(netdev);
630 	u32 new_rx_count, new_tx_count;
631 	int ret = 0;
632 
633 	if ((ring->rx_mini_pending) || (ring->rx_jumbo_pending))
634 		return -EINVAL;
635 
636 	if (ring->tx_pending > IAVF_MAX_TXD ||
637 	    ring->tx_pending < IAVF_MIN_TXD ||
638 	    ring->rx_pending > IAVF_MAX_RXD ||
639 	    ring->rx_pending < IAVF_MIN_RXD) {
640 		netdev_err(netdev, "Descriptors requested (Tx: %d / Rx: %d) out of range [%d-%d] (increment %d)\n",
641 			   ring->tx_pending, ring->rx_pending, IAVF_MIN_TXD,
642 			   IAVF_MAX_RXD, IAVF_REQ_DESCRIPTOR_MULTIPLE);
643 		return -EINVAL;
644 	}
645 
646 	new_tx_count = ALIGN(ring->tx_pending, IAVF_REQ_DESCRIPTOR_MULTIPLE);
647 	if (new_tx_count != ring->tx_pending)
648 		netdev_info(netdev, "Requested Tx descriptor count rounded up to %d\n",
649 			    new_tx_count);
650 
651 	new_rx_count = ALIGN(ring->rx_pending, IAVF_REQ_DESCRIPTOR_MULTIPLE);
652 	if (new_rx_count != ring->rx_pending)
653 		netdev_info(netdev, "Requested Rx descriptor count rounded up to %d\n",
654 			    new_rx_count);
655 
656 	/* if nothing to do return success */
657 	if ((new_tx_count == adapter->tx_desc_count) &&
658 	    (new_rx_count == adapter->rx_desc_count)) {
659 		netdev_dbg(netdev, "Nothing to change, descriptor count is same as requested\n");
660 		return 0;
661 	}
662 
663 	if (new_tx_count != adapter->tx_desc_count) {
664 		netdev_dbg(netdev, "Changing Tx descriptor count from %d to %d\n",
665 			   adapter->tx_desc_count, new_tx_count);
666 		adapter->tx_desc_count = new_tx_count;
667 	}
668 
669 	if (new_rx_count != adapter->rx_desc_count) {
670 		netdev_dbg(netdev, "Changing Rx descriptor count from %d to %d\n",
671 			   adapter->rx_desc_count, new_rx_count);
672 		adapter->rx_desc_count = new_rx_count;
673 	}
674 
675 	if (netif_running(netdev)) {
676 		iavf_schedule_reset(adapter, IAVF_FLAG_RESET_NEEDED);
677 		ret = iavf_wait_for_reset(adapter);
678 		if (ret)
679 			netdev_warn(netdev, "Changing ring parameters timeout or interrupted waiting for reset");
680 	}
681 
682 	return ret;
683 }
684 
685 /**
686  * __iavf_get_coalesce - get per-queue coalesce settings
687  * @netdev: the netdev to check
688  * @ec: ethtool coalesce data structure
689  * @queue: which queue to pick
690  *
691  * Gets the per-queue settings for coalescence. Specifically Rx and Tx usecs
692  * are per queue. If queue is <0 then we default to queue 0 as the
693  * representative value.
694  **/
695 static int __iavf_get_coalesce(struct net_device *netdev,
696 			       struct ethtool_coalesce *ec, int queue)
697 {
698 	struct iavf_adapter *adapter = netdev_priv(netdev);
699 	struct iavf_ring *rx_ring, *tx_ring;
700 
701 	/* Rx and Tx usecs per queue value. If user doesn't specify the
702 	 * queue, return queue 0's value to represent.
703 	 */
704 	if (queue < 0)
705 		queue = 0;
706 	else if (queue >= adapter->num_active_queues)
707 		return -EINVAL;
708 
709 	rx_ring = &adapter->rx_rings[queue];
710 	tx_ring = &adapter->tx_rings[queue];
711 
712 	if (ITR_IS_DYNAMIC(rx_ring->itr_setting))
713 		ec->use_adaptive_rx_coalesce = 1;
714 
715 	if (ITR_IS_DYNAMIC(tx_ring->itr_setting))
716 		ec->use_adaptive_tx_coalesce = 1;
717 
718 	ec->rx_coalesce_usecs = rx_ring->itr_setting & ~IAVF_ITR_DYNAMIC;
719 	ec->tx_coalesce_usecs = tx_ring->itr_setting & ~IAVF_ITR_DYNAMIC;
720 
721 	return 0;
722 }
723 
724 /**
725  * iavf_get_coalesce - Get interrupt coalescing settings
726  * @netdev: network interface device structure
727  * @ec: ethtool coalesce structure
728  * @kernel_coal: ethtool CQE mode setting structure
729  * @extack: extack for reporting error messages
730  *
731  * Returns current coalescing settings. This is referred to elsewhere in the
732  * driver as Interrupt Throttle Rate, as this is how the hardware describes
733  * this functionality. Note that if per-queue settings have been modified this
734  * only represents the settings of queue 0.
735  **/
736 static int iavf_get_coalesce(struct net_device *netdev,
737 			     struct ethtool_coalesce *ec,
738 			     struct kernel_ethtool_coalesce *kernel_coal,
739 			     struct netlink_ext_ack *extack)
740 {
741 	return __iavf_get_coalesce(netdev, ec, -1);
742 }
743 
744 /**
745  * iavf_get_per_queue_coalesce - get coalesce values for specific queue
746  * @netdev: netdev to read
747  * @ec: coalesce settings from ethtool
748  * @queue: the queue to read
749  *
750  * Read specific queue's coalesce settings.
751  **/
752 static int iavf_get_per_queue_coalesce(struct net_device *netdev, u32 queue,
753 				       struct ethtool_coalesce *ec)
754 {
755 	return __iavf_get_coalesce(netdev, ec, queue);
756 }
757 
758 /**
759  * iavf_set_itr_per_queue - set ITR values for specific queue
760  * @adapter: the VF adapter struct to set values for
761  * @ec: coalesce settings from ethtool
762  * @queue: the queue to modify
763  *
764  * Change the ITR settings for a specific queue.
765  **/
766 static int iavf_set_itr_per_queue(struct iavf_adapter *adapter,
767 				  struct ethtool_coalesce *ec, int queue)
768 {
769 	struct iavf_ring *rx_ring = &adapter->rx_rings[queue];
770 	struct iavf_ring *tx_ring = &adapter->tx_rings[queue];
771 	struct iavf_q_vector *q_vector;
772 	u16 itr_setting;
773 
774 	itr_setting = rx_ring->itr_setting & ~IAVF_ITR_DYNAMIC;
775 
776 	if (ec->rx_coalesce_usecs != itr_setting &&
777 	    ec->use_adaptive_rx_coalesce) {
778 		netif_info(adapter, drv, adapter->netdev,
779 			   "Rx interrupt throttling cannot be changed if adaptive-rx is enabled\n");
780 		return -EINVAL;
781 	}
782 
783 	itr_setting = tx_ring->itr_setting & ~IAVF_ITR_DYNAMIC;
784 
785 	if (ec->tx_coalesce_usecs != itr_setting &&
786 	    ec->use_adaptive_tx_coalesce) {
787 		netif_info(adapter, drv, adapter->netdev,
788 			   "Tx interrupt throttling cannot be changed if adaptive-tx is enabled\n");
789 		return -EINVAL;
790 	}
791 
792 	rx_ring->itr_setting = ITR_REG_ALIGN(ec->rx_coalesce_usecs);
793 	tx_ring->itr_setting = ITR_REG_ALIGN(ec->tx_coalesce_usecs);
794 
795 	rx_ring->itr_setting |= IAVF_ITR_DYNAMIC;
796 	if (!ec->use_adaptive_rx_coalesce)
797 		rx_ring->itr_setting ^= IAVF_ITR_DYNAMIC;
798 
799 	tx_ring->itr_setting |= IAVF_ITR_DYNAMIC;
800 	if (!ec->use_adaptive_tx_coalesce)
801 		tx_ring->itr_setting ^= IAVF_ITR_DYNAMIC;
802 
803 	q_vector = rx_ring->q_vector;
804 	q_vector->rx.target_itr = ITR_TO_REG(rx_ring->itr_setting);
805 
806 	q_vector = tx_ring->q_vector;
807 	q_vector->tx.target_itr = ITR_TO_REG(tx_ring->itr_setting);
808 
809 	/* The interrupt handler itself will take care of programming
810 	 * the Tx and Rx ITR values based on the values we have entered
811 	 * into the q_vector, no need to write the values now.
812 	 */
813 	return 0;
814 }
815 
816 /**
817  * __iavf_set_coalesce - set coalesce settings for particular queue
818  * @netdev: the netdev to change
819  * @ec: ethtool coalesce settings
820  * @queue: the queue to change
821  *
822  * Sets the coalesce settings for a particular queue.
823  **/
824 static int __iavf_set_coalesce(struct net_device *netdev,
825 			       struct ethtool_coalesce *ec, int queue)
826 {
827 	struct iavf_adapter *adapter = netdev_priv(netdev);
828 	int i;
829 
830 	if (ec->rx_coalesce_usecs > IAVF_MAX_ITR) {
831 		netif_info(adapter, drv, netdev, "Invalid value, rx-usecs range is 0-8160\n");
832 		return -EINVAL;
833 	} else if (ec->tx_coalesce_usecs > IAVF_MAX_ITR) {
834 		netif_info(adapter, drv, netdev, "Invalid value, tx-usecs range is 0-8160\n");
835 		return -EINVAL;
836 	}
837 
838 	/* Rx and Tx usecs has per queue value. If user doesn't specify the
839 	 * queue, apply to all queues.
840 	 */
841 	if (queue < 0) {
842 		for (i = 0; i < adapter->num_active_queues; i++)
843 			if (iavf_set_itr_per_queue(adapter, ec, i))
844 				return -EINVAL;
845 	} else if (queue < adapter->num_active_queues) {
846 		if (iavf_set_itr_per_queue(adapter, ec, queue))
847 			return -EINVAL;
848 	} else {
849 		netif_info(adapter, drv, netdev, "Invalid queue value, queue range is 0 - %d\n",
850 			   adapter->num_active_queues - 1);
851 		return -EINVAL;
852 	}
853 
854 	return 0;
855 }
856 
857 /**
858  * iavf_set_coalesce - Set interrupt coalescing settings
859  * @netdev: network interface device structure
860  * @ec: ethtool coalesce structure
861  * @kernel_coal: ethtool CQE mode setting structure
862  * @extack: extack for reporting error messages
863  *
864  * Change current coalescing settings for every queue.
865  **/
866 static int iavf_set_coalesce(struct net_device *netdev,
867 			     struct ethtool_coalesce *ec,
868 			     struct kernel_ethtool_coalesce *kernel_coal,
869 			     struct netlink_ext_ack *extack)
870 {
871 	return __iavf_set_coalesce(netdev, ec, -1);
872 }
873 
874 /**
875  * iavf_set_per_queue_coalesce - set specific queue's coalesce settings
876  * @netdev: the netdev to change
877  * @ec: ethtool's coalesce settings
878  * @queue: the queue to modify
879  *
880  * Modifies a specific queue's coalesce settings.
881  */
882 static int iavf_set_per_queue_coalesce(struct net_device *netdev, u32 queue,
883 				       struct ethtool_coalesce *ec)
884 {
885 	return __iavf_set_coalesce(netdev, ec, queue);
886 }
887 
888 /**
889  * iavf_fltr_to_ethtool_flow - convert filter type values to ethtool
890  * flow type values
891  * @flow: filter type to be converted
892  *
893  * Returns the corresponding ethtool flow type.
894  */
895 static int iavf_fltr_to_ethtool_flow(enum iavf_fdir_flow_type flow)
896 {
897 	switch (flow) {
898 	case IAVF_FDIR_FLOW_IPV4_TCP:
899 		return TCP_V4_FLOW;
900 	case IAVF_FDIR_FLOW_IPV4_UDP:
901 		return UDP_V4_FLOW;
902 	case IAVF_FDIR_FLOW_IPV4_SCTP:
903 		return SCTP_V4_FLOW;
904 	case IAVF_FDIR_FLOW_IPV4_AH:
905 		return AH_V4_FLOW;
906 	case IAVF_FDIR_FLOW_IPV4_ESP:
907 		return ESP_V4_FLOW;
908 	case IAVF_FDIR_FLOW_IPV4_OTHER:
909 		return IPV4_USER_FLOW;
910 	case IAVF_FDIR_FLOW_IPV6_TCP:
911 		return TCP_V6_FLOW;
912 	case IAVF_FDIR_FLOW_IPV6_UDP:
913 		return UDP_V6_FLOW;
914 	case IAVF_FDIR_FLOW_IPV6_SCTP:
915 		return SCTP_V6_FLOW;
916 	case IAVF_FDIR_FLOW_IPV6_AH:
917 		return AH_V6_FLOW;
918 	case IAVF_FDIR_FLOW_IPV6_ESP:
919 		return ESP_V6_FLOW;
920 	case IAVF_FDIR_FLOW_IPV6_OTHER:
921 		return IPV6_USER_FLOW;
922 	case IAVF_FDIR_FLOW_NON_IP_L2:
923 		return ETHER_FLOW;
924 	default:
925 		/* 0 is undefined ethtool flow */
926 		return 0;
927 	}
928 }
929 
930 /**
931  * iavf_ethtool_flow_to_fltr - convert ethtool flow type to filter enum
932  * @eth: Ethtool flow type to be converted
933  *
934  * Returns flow enum
935  */
936 static enum iavf_fdir_flow_type iavf_ethtool_flow_to_fltr(int eth)
937 {
938 	switch (eth) {
939 	case TCP_V4_FLOW:
940 		return IAVF_FDIR_FLOW_IPV4_TCP;
941 	case UDP_V4_FLOW:
942 		return IAVF_FDIR_FLOW_IPV4_UDP;
943 	case SCTP_V4_FLOW:
944 		return IAVF_FDIR_FLOW_IPV4_SCTP;
945 	case AH_V4_FLOW:
946 		return IAVF_FDIR_FLOW_IPV4_AH;
947 	case ESP_V4_FLOW:
948 		return IAVF_FDIR_FLOW_IPV4_ESP;
949 	case IPV4_USER_FLOW:
950 		return IAVF_FDIR_FLOW_IPV4_OTHER;
951 	case TCP_V6_FLOW:
952 		return IAVF_FDIR_FLOW_IPV6_TCP;
953 	case UDP_V6_FLOW:
954 		return IAVF_FDIR_FLOW_IPV6_UDP;
955 	case SCTP_V6_FLOW:
956 		return IAVF_FDIR_FLOW_IPV6_SCTP;
957 	case AH_V6_FLOW:
958 		return IAVF_FDIR_FLOW_IPV6_AH;
959 	case ESP_V6_FLOW:
960 		return IAVF_FDIR_FLOW_IPV6_ESP;
961 	case IPV6_USER_FLOW:
962 		return IAVF_FDIR_FLOW_IPV6_OTHER;
963 	case ETHER_FLOW:
964 		return IAVF_FDIR_FLOW_NON_IP_L2;
965 	default:
966 		return IAVF_FDIR_FLOW_NONE;
967 	}
968 }
969 
970 /**
971  * iavf_is_mask_valid - check mask field set
972  * @mask: full mask to check
973  * @field: field for which mask should be valid
974  *
975  * If the mask is fully set return true. If it is not valid for field return
976  * false.
977  */
978 static bool iavf_is_mask_valid(u64 mask, u64 field)
979 {
980 	return (mask & field) == field;
981 }
982 
983 /**
984  * iavf_parse_rx_flow_user_data - deconstruct user-defined data
985  * @fsp: pointer to ethtool Rx flow specification
986  * @fltr: pointer to Flow Director filter for userdef data storage
987  *
988  * Returns 0 on success, negative error value on failure
989  */
990 static int
991 iavf_parse_rx_flow_user_data(struct ethtool_rx_flow_spec *fsp,
992 			     struct iavf_fdir_fltr *fltr)
993 {
994 	struct iavf_flex_word *flex;
995 	int i, cnt = 0;
996 
997 	if (!(fsp->flow_type & FLOW_EXT))
998 		return 0;
999 
1000 	for (i = 0; i < IAVF_FLEX_WORD_NUM; i++) {
1001 #define IAVF_USERDEF_FLEX_WORD_M	GENMASK(15, 0)
1002 #define IAVF_USERDEF_FLEX_OFFS_S	16
1003 #define IAVF_USERDEF_FLEX_OFFS_M	GENMASK(31, IAVF_USERDEF_FLEX_OFFS_S)
1004 #define IAVF_USERDEF_FLEX_FLTR_M	GENMASK(31, 0)
1005 		u32 value = be32_to_cpu(fsp->h_ext.data[i]);
1006 		u32 mask = be32_to_cpu(fsp->m_ext.data[i]);
1007 
1008 		if (!value || !mask)
1009 			continue;
1010 
1011 		if (!iavf_is_mask_valid(mask, IAVF_USERDEF_FLEX_FLTR_M))
1012 			return -EINVAL;
1013 
1014 		/* 504 is the maximum value for offsets, and offset is measured
1015 		 * from the start of the MAC address.
1016 		 */
1017 #define IAVF_USERDEF_FLEX_MAX_OFFS_VAL 504
1018 		flex = &fltr->flex_words[cnt++];
1019 		flex->word = value & IAVF_USERDEF_FLEX_WORD_M;
1020 		flex->offset = (value & IAVF_USERDEF_FLEX_OFFS_M) >>
1021 			     IAVF_USERDEF_FLEX_OFFS_S;
1022 		if (flex->offset > IAVF_USERDEF_FLEX_MAX_OFFS_VAL)
1023 			return -EINVAL;
1024 	}
1025 
1026 	fltr->flex_cnt = cnt;
1027 
1028 	return 0;
1029 }
1030 
1031 /**
1032  * iavf_fill_rx_flow_ext_data - fill the additional data
1033  * @fsp: pointer to ethtool Rx flow specification
1034  * @fltr: pointer to Flow Director filter to get additional data
1035  */
1036 static void
1037 iavf_fill_rx_flow_ext_data(struct ethtool_rx_flow_spec *fsp,
1038 			   struct iavf_fdir_fltr *fltr)
1039 {
1040 	if (!fltr->ext_mask.usr_def[0] && !fltr->ext_mask.usr_def[1])
1041 		return;
1042 
1043 	fsp->flow_type |= FLOW_EXT;
1044 
1045 	memcpy(fsp->h_ext.data, fltr->ext_data.usr_def, sizeof(fsp->h_ext.data));
1046 	memcpy(fsp->m_ext.data, fltr->ext_mask.usr_def, sizeof(fsp->m_ext.data));
1047 }
1048 
1049 /**
1050  * iavf_get_ethtool_fdir_entry - fill ethtool structure with Flow Director filter data
1051  * @adapter: the VF adapter structure that contains filter list
1052  * @cmd: ethtool command data structure to receive the filter data
1053  *
1054  * Returns 0 as expected for success by ethtool
1055  */
1056 static int
1057 iavf_get_ethtool_fdir_entry(struct iavf_adapter *adapter,
1058 			    struct ethtool_rxnfc *cmd)
1059 {
1060 	struct ethtool_rx_flow_spec *fsp = (struct ethtool_rx_flow_spec *)&cmd->fs;
1061 	struct iavf_fdir_fltr *rule = NULL;
1062 	int ret = 0;
1063 
1064 	if (!(adapter->flags & IAVF_FLAG_FDIR_ENABLED))
1065 		return -EOPNOTSUPP;
1066 
1067 	spin_lock_bh(&adapter->fdir_fltr_lock);
1068 
1069 	rule = iavf_find_fdir_fltr_by_loc(adapter, fsp->location);
1070 	if (!rule) {
1071 		ret = -EINVAL;
1072 		goto release_lock;
1073 	}
1074 
1075 	fsp->flow_type = iavf_fltr_to_ethtool_flow(rule->flow_type);
1076 
1077 	memset(&fsp->m_u, 0, sizeof(fsp->m_u));
1078 	memset(&fsp->m_ext, 0, sizeof(fsp->m_ext));
1079 
1080 	switch (fsp->flow_type) {
1081 	case TCP_V4_FLOW:
1082 	case UDP_V4_FLOW:
1083 	case SCTP_V4_FLOW:
1084 		fsp->h_u.tcp_ip4_spec.ip4src = rule->ip_data.v4_addrs.src_ip;
1085 		fsp->h_u.tcp_ip4_spec.ip4dst = rule->ip_data.v4_addrs.dst_ip;
1086 		fsp->h_u.tcp_ip4_spec.psrc = rule->ip_data.src_port;
1087 		fsp->h_u.tcp_ip4_spec.pdst = rule->ip_data.dst_port;
1088 		fsp->h_u.tcp_ip4_spec.tos = rule->ip_data.tos;
1089 		fsp->m_u.tcp_ip4_spec.ip4src = rule->ip_mask.v4_addrs.src_ip;
1090 		fsp->m_u.tcp_ip4_spec.ip4dst = rule->ip_mask.v4_addrs.dst_ip;
1091 		fsp->m_u.tcp_ip4_spec.psrc = rule->ip_mask.src_port;
1092 		fsp->m_u.tcp_ip4_spec.pdst = rule->ip_mask.dst_port;
1093 		fsp->m_u.tcp_ip4_spec.tos = rule->ip_mask.tos;
1094 		break;
1095 	case AH_V4_FLOW:
1096 	case ESP_V4_FLOW:
1097 		fsp->h_u.ah_ip4_spec.ip4src = rule->ip_data.v4_addrs.src_ip;
1098 		fsp->h_u.ah_ip4_spec.ip4dst = rule->ip_data.v4_addrs.dst_ip;
1099 		fsp->h_u.ah_ip4_spec.spi = rule->ip_data.spi;
1100 		fsp->h_u.ah_ip4_spec.tos = rule->ip_data.tos;
1101 		fsp->m_u.ah_ip4_spec.ip4src = rule->ip_mask.v4_addrs.src_ip;
1102 		fsp->m_u.ah_ip4_spec.ip4dst = rule->ip_mask.v4_addrs.dst_ip;
1103 		fsp->m_u.ah_ip4_spec.spi = rule->ip_mask.spi;
1104 		fsp->m_u.ah_ip4_spec.tos = rule->ip_mask.tos;
1105 		break;
1106 	case IPV4_USER_FLOW:
1107 		fsp->h_u.usr_ip4_spec.ip4src = rule->ip_data.v4_addrs.src_ip;
1108 		fsp->h_u.usr_ip4_spec.ip4dst = rule->ip_data.v4_addrs.dst_ip;
1109 		fsp->h_u.usr_ip4_spec.l4_4_bytes = rule->ip_data.l4_header;
1110 		fsp->h_u.usr_ip4_spec.tos = rule->ip_data.tos;
1111 		fsp->h_u.usr_ip4_spec.ip_ver = ETH_RX_NFC_IP4;
1112 		fsp->h_u.usr_ip4_spec.proto = rule->ip_data.proto;
1113 		fsp->m_u.usr_ip4_spec.ip4src = rule->ip_mask.v4_addrs.src_ip;
1114 		fsp->m_u.usr_ip4_spec.ip4dst = rule->ip_mask.v4_addrs.dst_ip;
1115 		fsp->m_u.usr_ip4_spec.l4_4_bytes = rule->ip_mask.l4_header;
1116 		fsp->m_u.usr_ip4_spec.tos = rule->ip_mask.tos;
1117 		fsp->m_u.usr_ip4_spec.ip_ver = 0xFF;
1118 		fsp->m_u.usr_ip4_spec.proto = rule->ip_mask.proto;
1119 		break;
1120 	case TCP_V6_FLOW:
1121 	case UDP_V6_FLOW:
1122 	case SCTP_V6_FLOW:
1123 		memcpy(fsp->h_u.usr_ip6_spec.ip6src, &rule->ip_data.v6_addrs.src_ip,
1124 		       sizeof(struct in6_addr));
1125 		memcpy(fsp->h_u.usr_ip6_spec.ip6dst, &rule->ip_data.v6_addrs.dst_ip,
1126 		       sizeof(struct in6_addr));
1127 		fsp->h_u.tcp_ip6_spec.psrc = rule->ip_data.src_port;
1128 		fsp->h_u.tcp_ip6_spec.pdst = rule->ip_data.dst_port;
1129 		fsp->h_u.tcp_ip6_spec.tclass = rule->ip_data.tclass;
1130 		memcpy(fsp->m_u.usr_ip6_spec.ip6src, &rule->ip_mask.v6_addrs.src_ip,
1131 		       sizeof(struct in6_addr));
1132 		memcpy(fsp->m_u.usr_ip6_spec.ip6dst, &rule->ip_mask.v6_addrs.dst_ip,
1133 		       sizeof(struct in6_addr));
1134 		fsp->m_u.tcp_ip6_spec.psrc = rule->ip_mask.src_port;
1135 		fsp->m_u.tcp_ip6_spec.pdst = rule->ip_mask.dst_port;
1136 		fsp->m_u.tcp_ip6_spec.tclass = rule->ip_mask.tclass;
1137 		break;
1138 	case AH_V6_FLOW:
1139 	case ESP_V6_FLOW:
1140 		memcpy(fsp->h_u.ah_ip6_spec.ip6src, &rule->ip_data.v6_addrs.src_ip,
1141 		       sizeof(struct in6_addr));
1142 		memcpy(fsp->h_u.ah_ip6_spec.ip6dst, &rule->ip_data.v6_addrs.dst_ip,
1143 		       sizeof(struct in6_addr));
1144 		fsp->h_u.ah_ip6_spec.spi = rule->ip_data.spi;
1145 		fsp->h_u.ah_ip6_spec.tclass = rule->ip_data.tclass;
1146 		memcpy(fsp->m_u.ah_ip6_spec.ip6src, &rule->ip_mask.v6_addrs.src_ip,
1147 		       sizeof(struct in6_addr));
1148 		memcpy(fsp->m_u.ah_ip6_spec.ip6dst, &rule->ip_mask.v6_addrs.dst_ip,
1149 		       sizeof(struct in6_addr));
1150 		fsp->m_u.ah_ip6_spec.spi = rule->ip_mask.spi;
1151 		fsp->m_u.ah_ip6_spec.tclass = rule->ip_mask.tclass;
1152 		break;
1153 	case IPV6_USER_FLOW:
1154 		memcpy(fsp->h_u.usr_ip6_spec.ip6src, &rule->ip_data.v6_addrs.src_ip,
1155 		       sizeof(struct in6_addr));
1156 		memcpy(fsp->h_u.usr_ip6_spec.ip6dst, &rule->ip_data.v6_addrs.dst_ip,
1157 		       sizeof(struct in6_addr));
1158 		fsp->h_u.usr_ip6_spec.l4_4_bytes = rule->ip_data.l4_header;
1159 		fsp->h_u.usr_ip6_spec.tclass = rule->ip_data.tclass;
1160 		fsp->h_u.usr_ip6_spec.l4_proto = rule->ip_data.proto;
1161 		memcpy(fsp->m_u.usr_ip6_spec.ip6src, &rule->ip_mask.v6_addrs.src_ip,
1162 		       sizeof(struct in6_addr));
1163 		memcpy(fsp->m_u.usr_ip6_spec.ip6dst, &rule->ip_mask.v6_addrs.dst_ip,
1164 		       sizeof(struct in6_addr));
1165 		fsp->m_u.usr_ip6_spec.l4_4_bytes = rule->ip_mask.l4_header;
1166 		fsp->m_u.usr_ip6_spec.tclass = rule->ip_mask.tclass;
1167 		fsp->m_u.usr_ip6_spec.l4_proto = rule->ip_mask.proto;
1168 		break;
1169 	case ETHER_FLOW:
1170 		fsp->h_u.ether_spec.h_proto = rule->eth_data.etype;
1171 		fsp->m_u.ether_spec.h_proto = rule->eth_mask.etype;
1172 		break;
1173 	default:
1174 		ret = -EINVAL;
1175 		break;
1176 	}
1177 
1178 	iavf_fill_rx_flow_ext_data(fsp, rule);
1179 
1180 	if (rule->action == VIRTCHNL_ACTION_DROP)
1181 		fsp->ring_cookie = RX_CLS_FLOW_DISC;
1182 	else
1183 		fsp->ring_cookie = rule->q_index;
1184 
1185 release_lock:
1186 	spin_unlock_bh(&adapter->fdir_fltr_lock);
1187 	return ret;
1188 }
1189 
1190 /**
1191  * iavf_get_fdir_fltr_ids - fill buffer with filter IDs of active filters
1192  * @adapter: the VF adapter structure containing the filter list
1193  * @cmd: ethtool command data structure
1194  * @rule_locs: ethtool array passed in from OS to receive filter IDs
1195  *
1196  * Returns 0 as expected for success by ethtool
1197  */
1198 static int
1199 iavf_get_fdir_fltr_ids(struct iavf_adapter *adapter, struct ethtool_rxnfc *cmd,
1200 		       u32 *rule_locs)
1201 {
1202 	struct iavf_fdir_fltr *fltr;
1203 	unsigned int cnt = 0;
1204 	int val = 0;
1205 
1206 	if (!(adapter->flags & IAVF_FLAG_FDIR_ENABLED))
1207 		return -EOPNOTSUPP;
1208 
1209 	cmd->data = IAVF_MAX_FDIR_FILTERS;
1210 
1211 	spin_lock_bh(&adapter->fdir_fltr_lock);
1212 
1213 	list_for_each_entry(fltr, &adapter->fdir_list_head, list) {
1214 		if (cnt == cmd->rule_cnt) {
1215 			val = -EMSGSIZE;
1216 			goto release_lock;
1217 		}
1218 		rule_locs[cnt] = fltr->loc;
1219 		cnt++;
1220 	}
1221 
1222 release_lock:
1223 	spin_unlock_bh(&adapter->fdir_fltr_lock);
1224 	if (!val)
1225 		cmd->rule_cnt = cnt;
1226 
1227 	return val;
1228 }
1229 
1230 /**
1231  * iavf_add_fdir_fltr_info - Set the input set for Flow Director filter
1232  * @adapter: pointer to the VF adapter structure
1233  * @fsp: pointer to ethtool Rx flow specification
1234  * @fltr: filter structure
1235  */
1236 static int
1237 iavf_add_fdir_fltr_info(struct iavf_adapter *adapter, struct ethtool_rx_flow_spec *fsp,
1238 			struct iavf_fdir_fltr *fltr)
1239 {
1240 	u32 flow_type, q_index = 0;
1241 	enum virtchnl_action act;
1242 	int err;
1243 
1244 	if (fsp->ring_cookie == RX_CLS_FLOW_DISC) {
1245 		act = VIRTCHNL_ACTION_DROP;
1246 	} else {
1247 		q_index = fsp->ring_cookie;
1248 		if (q_index >= adapter->num_active_queues)
1249 			return -EINVAL;
1250 
1251 		act = VIRTCHNL_ACTION_QUEUE;
1252 	}
1253 
1254 	fltr->action = act;
1255 	fltr->loc = fsp->location;
1256 	fltr->q_index = q_index;
1257 
1258 	if (fsp->flow_type & FLOW_EXT) {
1259 		memcpy(fltr->ext_data.usr_def, fsp->h_ext.data,
1260 		       sizeof(fltr->ext_data.usr_def));
1261 		memcpy(fltr->ext_mask.usr_def, fsp->m_ext.data,
1262 		       sizeof(fltr->ext_mask.usr_def));
1263 	}
1264 
1265 	flow_type = fsp->flow_type & ~(FLOW_EXT | FLOW_MAC_EXT | FLOW_RSS);
1266 	fltr->flow_type = iavf_ethtool_flow_to_fltr(flow_type);
1267 
1268 	switch (flow_type) {
1269 	case TCP_V4_FLOW:
1270 	case UDP_V4_FLOW:
1271 	case SCTP_V4_FLOW:
1272 		fltr->ip_data.v4_addrs.src_ip = fsp->h_u.tcp_ip4_spec.ip4src;
1273 		fltr->ip_data.v4_addrs.dst_ip = fsp->h_u.tcp_ip4_spec.ip4dst;
1274 		fltr->ip_data.src_port = fsp->h_u.tcp_ip4_spec.psrc;
1275 		fltr->ip_data.dst_port = fsp->h_u.tcp_ip4_spec.pdst;
1276 		fltr->ip_data.tos = fsp->h_u.tcp_ip4_spec.tos;
1277 		fltr->ip_mask.v4_addrs.src_ip = fsp->m_u.tcp_ip4_spec.ip4src;
1278 		fltr->ip_mask.v4_addrs.dst_ip = fsp->m_u.tcp_ip4_spec.ip4dst;
1279 		fltr->ip_mask.src_port = fsp->m_u.tcp_ip4_spec.psrc;
1280 		fltr->ip_mask.dst_port = fsp->m_u.tcp_ip4_spec.pdst;
1281 		fltr->ip_mask.tos = fsp->m_u.tcp_ip4_spec.tos;
1282 		fltr->ip_ver = 4;
1283 		break;
1284 	case AH_V4_FLOW:
1285 	case ESP_V4_FLOW:
1286 		fltr->ip_data.v4_addrs.src_ip = fsp->h_u.ah_ip4_spec.ip4src;
1287 		fltr->ip_data.v4_addrs.dst_ip = fsp->h_u.ah_ip4_spec.ip4dst;
1288 		fltr->ip_data.spi = fsp->h_u.ah_ip4_spec.spi;
1289 		fltr->ip_data.tos = fsp->h_u.ah_ip4_spec.tos;
1290 		fltr->ip_mask.v4_addrs.src_ip = fsp->m_u.ah_ip4_spec.ip4src;
1291 		fltr->ip_mask.v4_addrs.dst_ip = fsp->m_u.ah_ip4_spec.ip4dst;
1292 		fltr->ip_mask.spi = fsp->m_u.ah_ip4_spec.spi;
1293 		fltr->ip_mask.tos = fsp->m_u.ah_ip4_spec.tos;
1294 		fltr->ip_ver = 4;
1295 		break;
1296 	case IPV4_USER_FLOW:
1297 		fltr->ip_data.v4_addrs.src_ip = fsp->h_u.usr_ip4_spec.ip4src;
1298 		fltr->ip_data.v4_addrs.dst_ip = fsp->h_u.usr_ip4_spec.ip4dst;
1299 		fltr->ip_data.l4_header = fsp->h_u.usr_ip4_spec.l4_4_bytes;
1300 		fltr->ip_data.tos = fsp->h_u.usr_ip4_spec.tos;
1301 		fltr->ip_data.proto = fsp->h_u.usr_ip4_spec.proto;
1302 		fltr->ip_mask.v4_addrs.src_ip = fsp->m_u.usr_ip4_spec.ip4src;
1303 		fltr->ip_mask.v4_addrs.dst_ip = fsp->m_u.usr_ip4_spec.ip4dst;
1304 		fltr->ip_mask.l4_header = fsp->m_u.usr_ip4_spec.l4_4_bytes;
1305 		fltr->ip_mask.tos = fsp->m_u.usr_ip4_spec.tos;
1306 		fltr->ip_mask.proto = fsp->m_u.usr_ip4_spec.proto;
1307 		fltr->ip_ver = 4;
1308 		break;
1309 	case TCP_V6_FLOW:
1310 	case UDP_V6_FLOW:
1311 	case SCTP_V6_FLOW:
1312 		memcpy(&fltr->ip_data.v6_addrs.src_ip, fsp->h_u.usr_ip6_spec.ip6src,
1313 		       sizeof(struct in6_addr));
1314 		memcpy(&fltr->ip_data.v6_addrs.dst_ip, fsp->h_u.usr_ip6_spec.ip6dst,
1315 		       sizeof(struct in6_addr));
1316 		fltr->ip_data.src_port = fsp->h_u.tcp_ip6_spec.psrc;
1317 		fltr->ip_data.dst_port = fsp->h_u.tcp_ip6_spec.pdst;
1318 		fltr->ip_data.tclass = fsp->h_u.tcp_ip6_spec.tclass;
1319 		memcpy(&fltr->ip_mask.v6_addrs.src_ip, fsp->m_u.usr_ip6_spec.ip6src,
1320 		       sizeof(struct in6_addr));
1321 		memcpy(&fltr->ip_mask.v6_addrs.dst_ip, fsp->m_u.usr_ip6_spec.ip6dst,
1322 		       sizeof(struct in6_addr));
1323 		fltr->ip_mask.src_port = fsp->m_u.tcp_ip6_spec.psrc;
1324 		fltr->ip_mask.dst_port = fsp->m_u.tcp_ip6_spec.pdst;
1325 		fltr->ip_mask.tclass = fsp->m_u.tcp_ip6_spec.tclass;
1326 		fltr->ip_ver = 6;
1327 		break;
1328 	case AH_V6_FLOW:
1329 	case ESP_V6_FLOW:
1330 		memcpy(&fltr->ip_data.v6_addrs.src_ip, fsp->h_u.ah_ip6_spec.ip6src,
1331 		       sizeof(struct in6_addr));
1332 		memcpy(&fltr->ip_data.v6_addrs.dst_ip, fsp->h_u.ah_ip6_spec.ip6dst,
1333 		       sizeof(struct in6_addr));
1334 		fltr->ip_data.spi = fsp->h_u.ah_ip6_spec.spi;
1335 		fltr->ip_data.tclass = fsp->h_u.ah_ip6_spec.tclass;
1336 		memcpy(&fltr->ip_mask.v6_addrs.src_ip, fsp->m_u.ah_ip6_spec.ip6src,
1337 		       sizeof(struct in6_addr));
1338 		memcpy(&fltr->ip_mask.v6_addrs.dst_ip, fsp->m_u.ah_ip6_spec.ip6dst,
1339 		       sizeof(struct in6_addr));
1340 		fltr->ip_mask.spi = fsp->m_u.ah_ip6_spec.spi;
1341 		fltr->ip_mask.tclass = fsp->m_u.ah_ip6_spec.tclass;
1342 		fltr->ip_ver = 6;
1343 		break;
1344 	case IPV6_USER_FLOW:
1345 		memcpy(&fltr->ip_data.v6_addrs.src_ip, fsp->h_u.usr_ip6_spec.ip6src,
1346 		       sizeof(struct in6_addr));
1347 		memcpy(&fltr->ip_data.v6_addrs.dst_ip, fsp->h_u.usr_ip6_spec.ip6dst,
1348 		       sizeof(struct in6_addr));
1349 		fltr->ip_data.l4_header = fsp->h_u.usr_ip6_spec.l4_4_bytes;
1350 		fltr->ip_data.tclass = fsp->h_u.usr_ip6_spec.tclass;
1351 		fltr->ip_data.proto = fsp->h_u.usr_ip6_spec.l4_proto;
1352 		memcpy(&fltr->ip_mask.v6_addrs.src_ip, fsp->m_u.usr_ip6_spec.ip6src,
1353 		       sizeof(struct in6_addr));
1354 		memcpy(&fltr->ip_mask.v6_addrs.dst_ip, fsp->m_u.usr_ip6_spec.ip6dst,
1355 		       sizeof(struct in6_addr));
1356 		fltr->ip_mask.l4_header = fsp->m_u.usr_ip6_spec.l4_4_bytes;
1357 		fltr->ip_mask.tclass = fsp->m_u.usr_ip6_spec.tclass;
1358 		fltr->ip_mask.proto = fsp->m_u.usr_ip6_spec.l4_proto;
1359 		fltr->ip_ver = 6;
1360 		break;
1361 	case ETHER_FLOW:
1362 		fltr->eth_data.etype = fsp->h_u.ether_spec.h_proto;
1363 		fltr->eth_mask.etype = fsp->m_u.ether_spec.h_proto;
1364 		break;
1365 	default:
1366 		/* not doing un-parsed flow types */
1367 		return -EINVAL;
1368 	}
1369 
1370 	err = iavf_validate_fdir_fltr_masks(adapter, fltr);
1371 	if (err)
1372 		return err;
1373 
1374 	if (iavf_fdir_is_dup_fltr(adapter, fltr))
1375 		return -EEXIST;
1376 
1377 	err = iavf_parse_rx_flow_user_data(fsp, fltr);
1378 	if (err)
1379 		return err;
1380 
1381 	return iavf_fill_fdir_add_msg(adapter, fltr);
1382 }
1383 
1384 /**
1385  * iavf_add_fdir_ethtool - add Flow Director filter
1386  * @adapter: pointer to the VF adapter structure
1387  * @cmd: command to add Flow Director filter
1388  *
1389  * Returns 0 on success and negative values for failure
1390  */
1391 static int iavf_add_fdir_ethtool(struct iavf_adapter *adapter, struct ethtool_rxnfc *cmd)
1392 {
1393 	struct ethtool_rx_flow_spec *fsp = &cmd->fs;
1394 	struct iavf_fdir_fltr *fltr;
1395 	int count = 50;
1396 	int err;
1397 
1398 	if (!(adapter->flags & IAVF_FLAG_FDIR_ENABLED))
1399 		return -EOPNOTSUPP;
1400 
1401 	if (fsp->flow_type & FLOW_MAC_EXT)
1402 		return -EINVAL;
1403 
1404 	spin_lock_bh(&adapter->fdir_fltr_lock);
1405 	if (adapter->fdir_active_fltr >= IAVF_MAX_FDIR_FILTERS) {
1406 		spin_unlock_bh(&adapter->fdir_fltr_lock);
1407 		dev_err(&adapter->pdev->dev,
1408 			"Unable to add Flow Director filter because VF reached the limit of max allowed filters (%u)\n",
1409 			IAVF_MAX_FDIR_FILTERS);
1410 		return -ENOSPC;
1411 	}
1412 
1413 	if (iavf_find_fdir_fltr_by_loc(adapter, fsp->location)) {
1414 		dev_err(&adapter->pdev->dev, "Failed to add Flow Director filter, it already exists\n");
1415 		spin_unlock_bh(&adapter->fdir_fltr_lock);
1416 		return -EEXIST;
1417 	}
1418 	spin_unlock_bh(&adapter->fdir_fltr_lock);
1419 
1420 	fltr = kzalloc(sizeof(*fltr), GFP_KERNEL);
1421 	if (!fltr)
1422 		return -ENOMEM;
1423 
1424 	while (!mutex_trylock(&adapter->crit_lock)) {
1425 		if (--count == 0) {
1426 			kfree(fltr);
1427 			return -EINVAL;
1428 		}
1429 		udelay(1);
1430 	}
1431 
1432 	err = iavf_add_fdir_fltr_info(adapter, fsp, fltr);
1433 	if (err)
1434 		goto ret;
1435 
1436 	spin_lock_bh(&adapter->fdir_fltr_lock);
1437 	iavf_fdir_list_add_fltr(adapter, fltr);
1438 	adapter->fdir_active_fltr++;
1439 	if (adapter->link_up) {
1440 		fltr->state = IAVF_FDIR_FLTR_ADD_REQUEST;
1441 		adapter->aq_required |= IAVF_FLAG_AQ_ADD_FDIR_FILTER;
1442 	} else {
1443 		fltr->state = IAVF_FDIR_FLTR_INACTIVE;
1444 	}
1445 	spin_unlock_bh(&adapter->fdir_fltr_lock);
1446 
1447 	if (adapter->link_up)
1448 		mod_delayed_work(adapter->wq, &adapter->watchdog_task, 0);
1449 ret:
1450 	if (err && fltr)
1451 		kfree(fltr);
1452 
1453 	mutex_unlock(&adapter->crit_lock);
1454 	return err;
1455 }
1456 
1457 /**
1458  * iavf_del_fdir_ethtool - delete Flow Director filter
1459  * @adapter: pointer to the VF adapter structure
1460  * @cmd: command to delete Flow Director filter
1461  *
1462  * Returns 0 on success and negative values for failure
1463  */
1464 static int iavf_del_fdir_ethtool(struct iavf_adapter *adapter, struct ethtool_rxnfc *cmd)
1465 {
1466 	struct ethtool_rx_flow_spec *fsp = (struct ethtool_rx_flow_spec *)&cmd->fs;
1467 	struct iavf_fdir_fltr *fltr = NULL;
1468 	int err = 0;
1469 
1470 	if (!(adapter->flags & IAVF_FLAG_FDIR_ENABLED))
1471 		return -EOPNOTSUPP;
1472 
1473 	spin_lock_bh(&adapter->fdir_fltr_lock);
1474 	fltr = iavf_find_fdir_fltr_by_loc(adapter, fsp->location);
1475 	if (fltr) {
1476 		if (fltr->state == IAVF_FDIR_FLTR_ACTIVE) {
1477 			fltr->state = IAVF_FDIR_FLTR_DEL_REQUEST;
1478 			adapter->aq_required |= IAVF_FLAG_AQ_DEL_FDIR_FILTER;
1479 		} else if (fltr->state == IAVF_FDIR_FLTR_INACTIVE) {
1480 			list_del(&fltr->list);
1481 			kfree(fltr);
1482 			adapter->fdir_active_fltr--;
1483 			fltr = NULL;
1484 		} else {
1485 			err = -EBUSY;
1486 		}
1487 	} else if (adapter->fdir_active_fltr) {
1488 		err = -EINVAL;
1489 	}
1490 	spin_unlock_bh(&adapter->fdir_fltr_lock);
1491 
1492 	if (fltr && fltr->state == IAVF_FDIR_FLTR_DEL_REQUEST)
1493 		mod_delayed_work(adapter->wq, &adapter->watchdog_task, 0);
1494 
1495 	return err;
1496 }
1497 
1498 /**
1499  * iavf_adv_rss_parse_hdrs - parses headers from RSS hash input
1500  * @cmd: ethtool rxnfc command
1501  *
1502  * This function parses the rxnfc command and returns intended
1503  * header types for RSS configuration
1504  */
1505 static u32 iavf_adv_rss_parse_hdrs(struct ethtool_rxnfc *cmd)
1506 {
1507 	u32 hdrs = IAVF_ADV_RSS_FLOW_SEG_HDR_NONE;
1508 
1509 	switch (cmd->flow_type) {
1510 	case TCP_V4_FLOW:
1511 		hdrs |= IAVF_ADV_RSS_FLOW_SEG_HDR_TCP |
1512 			IAVF_ADV_RSS_FLOW_SEG_HDR_IPV4;
1513 		break;
1514 	case UDP_V4_FLOW:
1515 		hdrs |= IAVF_ADV_RSS_FLOW_SEG_HDR_UDP |
1516 			IAVF_ADV_RSS_FLOW_SEG_HDR_IPV4;
1517 		break;
1518 	case SCTP_V4_FLOW:
1519 		hdrs |= IAVF_ADV_RSS_FLOW_SEG_HDR_SCTP |
1520 			IAVF_ADV_RSS_FLOW_SEG_HDR_IPV4;
1521 		break;
1522 	case TCP_V6_FLOW:
1523 		hdrs |= IAVF_ADV_RSS_FLOW_SEG_HDR_TCP |
1524 			IAVF_ADV_RSS_FLOW_SEG_HDR_IPV6;
1525 		break;
1526 	case UDP_V6_FLOW:
1527 		hdrs |= IAVF_ADV_RSS_FLOW_SEG_HDR_UDP |
1528 			IAVF_ADV_RSS_FLOW_SEG_HDR_IPV6;
1529 		break;
1530 	case SCTP_V6_FLOW:
1531 		hdrs |= IAVF_ADV_RSS_FLOW_SEG_HDR_SCTP |
1532 			IAVF_ADV_RSS_FLOW_SEG_HDR_IPV6;
1533 		break;
1534 	default:
1535 		break;
1536 	}
1537 
1538 	return hdrs;
1539 }
1540 
1541 /**
1542  * iavf_adv_rss_parse_hash_flds - parses hash fields from RSS hash input
1543  * @cmd: ethtool rxnfc command
1544  *
1545  * This function parses the rxnfc command and returns intended hash fields for
1546  * RSS configuration
1547  */
1548 static u64 iavf_adv_rss_parse_hash_flds(struct ethtool_rxnfc *cmd)
1549 {
1550 	u64 hfld = IAVF_ADV_RSS_HASH_INVALID;
1551 
1552 	if (cmd->data & RXH_IP_SRC || cmd->data & RXH_IP_DST) {
1553 		switch (cmd->flow_type) {
1554 		case TCP_V4_FLOW:
1555 		case UDP_V4_FLOW:
1556 		case SCTP_V4_FLOW:
1557 			if (cmd->data & RXH_IP_SRC)
1558 				hfld |= IAVF_ADV_RSS_HASH_FLD_IPV4_SA;
1559 			if (cmd->data & RXH_IP_DST)
1560 				hfld |= IAVF_ADV_RSS_HASH_FLD_IPV4_DA;
1561 			break;
1562 		case TCP_V6_FLOW:
1563 		case UDP_V6_FLOW:
1564 		case SCTP_V6_FLOW:
1565 			if (cmd->data & RXH_IP_SRC)
1566 				hfld |= IAVF_ADV_RSS_HASH_FLD_IPV6_SA;
1567 			if (cmd->data & RXH_IP_DST)
1568 				hfld |= IAVF_ADV_RSS_HASH_FLD_IPV6_DA;
1569 			break;
1570 		default:
1571 			break;
1572 		}
1573 	}
1574 
1575 	if (cmd->data & RXH_L4_B_0_1 || cmd->data & RXH_L4_B_2_3) {
1576 		switch (cmd->flow_type) {
1577 		case TCP_V4_FLOW:
1578 		case TCP_V6_FLOW:
1579 			if (cmd->data & RXH_L4_B_0_1)
1580 				hfld |= IAVF_ADV_RSS_HASH_FLD_TCP_SRC_PORT;
1581 			if (cmd->data & RXH_L4_B_2_3)
1582 				hfld |= IAVF_ADV_RSS_HASH_FLD_TCP_DST_PORT;
1583 			break;
1584 		case UDP_V4_FLOW:
1585 		case UDP_V6_FLOW:
1586 			if (cmd->data & RXH_L4_B_0_1)
1587 				hfld |= IAVF_ADV_RSS_HASH_FLD_UDP_SRC_PORT;
1588 			if (cmd->data & RXH_L4_B_2_3)
1589 				hfld |= IAVF_ADV_RSS_HASH_FLD_UDP_DST_PORT;
1590 			break;
1591 		case SCTP_V4_FLOW:
1592 		case SCTP_V6_FLOW:
1593 			if (cmd->data & RXH_L4_B_0_1)
1594 				hfld |= IAVF_ADV_RSS_HASH_FLD_SCTP_SRC_PORT;
1595 			if (cmd->data & RXH_L4_B_2_3)
1596 				hfld |= IAVF_ADV_RSS_HASH_FLD_SCTP_DST_PORT;
1597 			break;
1598 		default:
1599 			break;
1600 		}
1601 	}
1602 
1603 	return hfld;
1604 }
1605 
1606 /**
1607  * iavf_set_adv_rss_hash_opt - Enable/Disable flow types for RSS hash
1608  * @adapter: pointer to the VF adapter structure
1609  * @cmd: ethtool rxnfc command
1610  *
1611  * Returns Success if the flow input set is supported.
1612  */
1613 static int
1614 iavf_set_adv_rss_hash_opt(struct iavf_adapter *adapter,
1615 			  struct ethtool_rxnfc *cmd)
1616 {
1617 	struct iavf_adv_rss *rss_old, *rss_new;
1618 	bool rss_new_add = false;
1619 	int count = 50, err = 0;
1620 	u64 hash_flds;
1621 	u32 hdrs;
1622 
1623 	if (!ADV_RSS_SUPPORT(adapter))
1624 		return -EOPNOTSUPP;
1625 
1626 	hdrs = iavf_adv_rss_parse_hdrs(cmd);
1627 	if (hdrs == IAVF_ADV_RSS_FLOW_SEG_HDR_NONE)
1628 		return -EINVAL;
1629 
1630 	hash_flds = iavf_adv_rss_parse_hash_flds(cmd);
1631 	if (hash_flds == IAVF_ADV_RSS_HASH_INVALID)
1632 		return -EINVAL;
1633 
1634 	rss_new = kzalloc(sizeof(*rss_new), GFP_KERNEL);
1635 	if (!rss_new)
1636 		return -ENOMEM;
1637 
1638 	if (iavf_fill_adv_rss_cfg_msg(&rss_new->cfg_msg, hdrs, hash_flds)) {
1639 		kfree(rss_new);
1640 		return -EINVAL;
1641 	}
1642 
1643 	while (!mutex_trylock(&adapter->crit_lock)) {
1644 		if (--count == 0) {
1645 			kfree(rss_new);
1646 			return -EINVAL;
1647 		}
1648 
1649 		udelay(1);
1650 	}
1651 
1652 	spin_lock_bh(&adapter->adv_rss_lock);
1653 	rss_old = iavf_find_adv_rss_cfg_by_hdrs(adapter, hdrs);
1654 	if (rss_old) {
1655 		if (rss_old->state != IAVF_ADV_RSS_ACTIVE) {
1656 			err = -EBUSY;
1657 		} else if (rss_old->hash_flds != hash_flds) {
1658 			rss_old->state = IAVF_ADV_RSS_ADD_REQUEST;
1659 			rss_old->hash_flds = hash_flds;
1660 			memcpy(&rss_old->cfg_msg, &rss_new->cfg_msg,
1661 			       sizeof(rss_new->cfg_msg));
1662 			adapter->aq_required |= IAVF_FLAG_AQ_ADD_ADV_RSS_CFG;
1663 		} else {
1664 			err = -EEXIST;
1665 		}
1666 	} else {
1667 		rss_new_add = true;
1668 		rss_new->state = IAVF_ADV_RSS_ADD_REQUEST;
1669 		rss_new->packet_hdrs = hdrs;
1670 		rss_new->hash_flds = hash_flds;
1671 		list_add_tail(&rss_new->list, &adapter->adv_rss_list_head);
1672 		adapter->aq_required |= IAVF_FLAG_AQ_ADD_ADV_RSS_CFG;
1673 	}
1674 	spin_unlock_bh(&adapter->adv_rss_lock);
1675 
1676 	if (!err)
1677 		mod_delayed_work(adapter->wq, &adapter->watchdog_task, 0);
1678 
1679 	mutex_unlock(&adapter->crit_lock);
1680 
1681 	if (!rss_new_add)
1682 		kfree(rss_new);
1683 
1684 	return err;
1685 }
1686 
1687 /**
1688  * iavf_get_adv_rss_hash_opt - Retrieve hash fields for a given flow-type
1689  * @adapter: pointer to the VF adapter structure
1690  * @cmd: ethtool rxnfc command
1691  *
1692  * Returns Success if the flow input set is supported.
1693  */
1694 static int
1695 iavf_get_adv_rss_hash_opt(struct iavf_adapter *adapter,
1696 			  struct ethtool_rxnfc *cmd)
1697 {
1698 	struct iavf_adv_rss *rss;
1699 	u64 hash_flds;
1700 	u32 hdrs;
1701 
1702 	if (!ADV_RSS_SUPPORT(adapter))
1703 		return -EOPNOTSUPP;
1704 
1705 	cmd->data = 0;
1706 
1707 	hdrs = iavf_adv_rss_parse_hdrs(cmd);
1708 	if (hdrs == IAVF_ADV_RSS_FLOW_SEG_HDR_NONE)
1709 		return -EINVAL;
1710 
1711 	spin_lock_bh(&adapter->adv_rss_lock);
1712 	rss = iavf_find_adv_rss_cfg_by_hdrs(adapter, hdrs);
1713 	if (rss)
1714 		hash_flds = rss->hash_flds;
1715 	else
1716 		hash_flds = IAVF_ADV_RSS_HASH_INVALID;
1717 	spin_unlock_bh(&adapter->adv_rss_lock);
1718 
1719 	if (hash_flds == IAVF_ADV_RSS_HASH_INVALID)
1720 		return -EINVAL;
1721 
1722 	if (hash_flds & (IAVF_ADV_RSS_HASH_FLD_IPV4_SA |
1723 			 IAVF_ADV_RSS_HASH_FLD_IPV6_SA))
1724 		cmd->data |= (u64)RXH_IP_SRC;
1725 
1726 	if (hash_flds & (IAVF_ADV_RSS_HASH_FLD_IPV4_DA |
1727 			 IAVF_ADV_RSS_HASH_FLD_IPV6_DA))
1728 		cmd->data |= (u64)RXH_IP_DST;
1729 
1730 	if (hash_flds & (IAVF_ADV_RSS_HASH_FLD_TCP_SRC_PORT |
1731 			 IAVF_ADV_RSS_HASH_FLD_UDP_SRC_PORT |
1732 			 IAVF_ADV_RSS_HASH_FLD_SCTP_SRC_PORT))
1733 		cmd->data |= (u64)RXH_L4_B_0_1;
1734 
1735 	if (hash_flds & (IAVF_ADV_RSS_HASH_FLD_TCP_DST_PORT |
1736 			 IAVF_ADV_RSS_HASH_FLD_UDP_DST_PORT |
1737 			 IAVF_ADV_RSS_HASH_FLD_SCTP_DST_PORT))
1738 		cmd->data |= (u64)RXH_L4_B_2_3;
1739 
1740 	return 0;
1741 }
1742 
1743 /**
1744  * iavf_set_rxnfc - command to set Rx flow rules.
1745  * @netdev: network interface device structure
1746  * @cmd: ethtool rxnfc command
1747  *
1748  * Returns 0 for success and negative values for errors
1749  */
1750 static int iavf_set_rxnfc(struct net_device *netdev, struct ethtool_rxnfc *cmd)
1751 {
1752 	struct iavf_adapter *adapter = netdev_priv(netdev);
1753 	int ret = -EOPNOTSUPP;
1754 
1755 	switch (cmd->cmd) {
1756 	case ETHTOOL_SRXCLSRLINS:
1757 		ret = iavf_add_fdir_ethtool(adapter, cmd);
1758 		break;
1759 	case ETHTOOL_SRXCLSRLDEL:
1760 		ret = iavf_del_fdir_ethtool(adapter, cmd);
1761 		break;
1762 	case ETHTOOL_SRXFH:
1763 		ret = iavf_set_adv_rss_hash_opt(adapter, cmd);
1764 		break;
1765 	default:
1766 		break;
1767 	}
1768 
1769 	return ret;
1770 }
1771 
1772 /**
1773  * iavf_get_rxnfc - command to get RX flow classification rules
1774  * @netdev: network interface device structure
1775  * @cmd: ethtool rxnfc command
1776  * @rule_locs: pointer to store rule locations
1777  *
1778  * Returns Success if the command is supported.
1779  **/
1780 static int iavf_get_rxnfc(struct net_device *netdev, struct ethtool_rxnfc *cmd,
1781 			  u32 *rule_locs)
1782 {
1783 	struct iavf_adapter *adapter = netdev_priv(netdev);
1784 	int ret = -EOPNOTSUPP;
1785 
1786 	switch (cmd->cmd) {
1787 	case ETHTOOL_GRXRINGS:
1788 		cmd->data = adapter->num_active_queues;
1789 		ret = 0;
1790 		break;
1791 	case ETHTOOL_GRXCLSRLCNT:
1792 		if (!(adapter->flags & IAVF_FLAG_FDIR_ENABLED))
1793 			break;
1794 		spin_lock_bh(&adapter->fdir_fltr_lock);
1795 		cmd->rule_cnt = adapter->fdir_active_fltr;
1796 		spin_unlock_bh(&adapter->fdir_fltr_lock);
1797 		cmd->data = IAVF_MAX_FDIR_FILTERS;
1798 		ret = 0;
1799 		break;
1800 	case ETHTOOL_GRXCLSRULE:
1801 		ret = iavf_get_ethtool_fdir_entry(adapter, cmd);
1802 		break;
1803 	case ETHTOOL_GRXCLSRLALL:
1804 		ret = iavf_get_fdir_fltr_ids(adapter, cmd, (u32 *)rule_locs);
1805 		break;
1806 	case ETHTOOL_GRXFH:
1807 		ret = iavf_get_adv_rss_hash_opt(adapter, cmd);
1808 		break;
1809 	default:
1810 		break;
1811 	}
1812 
1813 	return ret;
1814 }
1815 /**
1816  * iavf_get_channels: get the number of channels supported by the device
1817  * @netdev: network interface device structure
1818  * @ch: channel information structure
1819  *
1820  * For the purposes of our device, we only use combined channels, i.e. a tx/rx
1821  * queue pair. Report one extra channel to match our "other" MSI-X vector.
1822  **/
1823 static void iavf_get_channels(struct net_device *netdev,
1824 			      struct ethtool_channels *ch)
1825 {
1826 	struct iavf_adapter *adapter = netdev_priv(netdev);
1827 
1828 	/* Report maximum channels */
1829 	ch->max_combined = adapter->vsi_res->num_queue_pairs;
1830 
1831 	ch->max_other = NONQ_VECS;
1832 	ch->other_count = NONQ_VECS;
1833 
1834 	ch->combined_count = adapter->num_active_queues;
1835 }
1836 
1837 /**
1838  * iavf_set_channels: set the new channel count
1839  * @netdev: network interface device structure
1840  * @ch: channel information structure
1841  *
1842  * Negotiate a new number of channels with the PF then do a reset.  During
1843  * reset we'll realloc queues and fix the RSS table.  Returns 0 on success,
1844  * negative on failure.
1845  **/
1846 static int iavf_set_channels(struct net_device *netdev,
1847 			     struct ethtool_channels *ch)
1848 {
1849 	struct iavf_adapter *adapter = netdev_priv(netdev);
1850 	u32 num_req = ch->combined_count;
1851 	int ret = 0;
1852 
1853 	if ((adapter->vf_res->vf_cap_flags & VIRTCHNL_VF_OFFLOAD_ADQ) &&
1854 	    adapter->num_tc) {
1855 		dev_info(&adapter->pdev->dev, "Cannot set channels since ADq is enabled.\n");
1856 		return -EINVAL;
1857 	}
1858 
1859 	/* All of these should have already been checked by ethtool before this
1860 	 * even gets to us, but just to be sure.
1861 	 */
1862 	if (num_req == 0 || num_req > adapter->vsi_res->num_queue_pairs)
1863 		return -EINVAL;
1864 
1865 	if (num_req == adapter->num_active_queues)
1866 		return 0;
1867 
1868 	if (ch->rx_count || ch->tx_count || ch->other_count != NONQ_VECS)
1869 		return -EINVAL;
1870 
1871 	adapter->num_req_queues = num_req;
1872 	adapter->flags |= IAVF_FLAG_REINIT_ITR_NEEDED;
1873 	iavf_schedule_reset(adapter, IAVF_FLAG_RESET_NEEDED);
1874 
1875 	ret = iavf_wait_for_reset(adapter);
1876 	if (ret)
1877 		netdev_warn(netdev, "Changing channel count timeout or interrupted waiting for reset");
1878 
1879 	return ret;
1880 }
1881 
1882 /**
1883  * iavf_get_rxfh_key_size - get the RSS hash key size
1884  * @netdev: network interface device structure
1885  *
1886  * Returns the table size.
1887  **/
1888 static u32 iavf_get_rxfh_key_size(struct net_device *netdev)
1889 {
1890 	struct iavf_adapter *adapter = netdev_priv(netdev);
1891 
1892 	return adapter->rss_key_size;
1893 }
1894 
1895 /**
1896  * iavf_get_rxfh_indir_size - get the rx flow hash indirection table size
1897  * @netdev: network interface device structure
1898  *
1899  * Returns the table size.
1900  **/
1901 static u32 iavf_get_rxfh_indir_size(struct net_device *netdev)
1902 {
1903 	struct iavf_adapter *adapter = netdev_priv(netdev);
1904 
1905 	return adapter->rss_lut_size;
1906 }
1907 
1908 /**
1909  * iavf_get_rxfh - get the rx flow hash indirection table
1910  * @netdev: network interface device structure
1911  * @indir: indirection table
1912  * @key: hash key
1913  * @hfunc: hash function in use
1914  *
1915  * Reads the indirection table directly from the hardware. Always returns 0.
1916  **/
1917 static int iavf_get_rxfh(struct net_device *netdev, u32 *indir, u8 *key,
1918 			 u8 *hfunc)
1919 {
1920 	struct iavf_adapter *adapter = netdev_priv(netdev);
1921 	u16 i;
1922 
1923 	if (hfunc)
1924 		*hfunc = ETH_RSS_HASH_TOP;
1925 	if (key)
1926 		memcpy(key, adapter->rss_key, adapter->rss_key_size);
1927 
1928 	if (indir)
1929 		/* Each 32 bits pointed by 'indir' is stored with a lut entry */
1930 		for (i = 0; i < adapter->rss_lut_size; i++)
1931 			indir[i] = (u32)adapter->rss_lut[i];
1932 
1933 	return 0;
1934 }
1935 
1936 /**
1937  * iavf_set_rxfh - set the rx flow hash indirection table
1938  * @netdev: network interface device structure
1939  * @indir: indirection table
1940  * @key: hash key
1941  * @hfunc: hash function to use
1942  *
1943  * Returns -EINVAL if the table specifies an invalid queue id, otherwise
1944  * returns 0 after programming the table.
1945  **/
1946 static int iavf_set_rxfh(struct net_device *netdev, const u32 *indir,
1947 			 const u8 *key, const u8 hfunc)
1948 {
1949 	struct iavf_adapter *adapter = netdev_priv(netdev);
1950 	u16 i;
1951 
1952 	/* Only support toeplitz hash function */
1953 	if (hfunc != ETH_RSS_HASH_NO_CHANGE && hfunc != ETH_RSS_HASH_TOP)
1954 		return -EOPNOTSUPP;
1955 
1956 	if (!key && !indir)
1957 		return 0;
1958 
1959 	if (key)
1960 		memcpy(adapter->rss_key, key, adapter->rss_key_size);
1961 
1962 	if (indir) {
1963 		/* Each 32 bits pointed by 'indir' is stored with a lut entry */
1964 		for (i = 0; i < adapter->rss_lut_size; i++)
1965 			adapter->rss_lut[i] = (u8)(indir[i]);
1966 	}
1967 
1968 	return iavf_config_rss(adapter);
1969 }
1970 
1971 static const struct ethtool_ops iavf_ethtool_ops = {
1972 	.supported_coalesce_params = ETHTOOL_COALESCE_USECS |
1973 				     ETHTOOL_COALESCE_USE_ADAPTIVE,
1974 	.get_drvinfo		= iavf_get_drvinfo,
1975 	.get_link		= ethtool_op_get_link,
1976 	.get_ringparam		= iavf_get_ringparam,
1977 	.set_ringparam		= iavf_set_ringparam,
1978 	.get_strings		= iavf_get_strings,
1979 	.get_ethtool_stats	= iavf_get_ethtool_stats,
1980 	.get_sset_count		= iavf_get_sset_count,
1981 	.get_priv_flags		= iavf_get_priv_flags,
1982 	.set_priv_flags		= iavf_set_priv_flags,
1983 	.get_msglevel		= iavf_get_msglevel,
1984 	.set_msglevel		= iavf_set_msglevel,
1985 	.get_coalesce		= iavf_get_coalesce,
1986 	.set_coalesce		= iavf_set_coalesce,
1987 	.get_per_queue_coalesce = iavf_get_per_queue_coalesce,
1988 	.set_per_queue_coalesce = iavf_set_per_queue_coalesce,
1989 	.set_rxnfc		= iavf_set_rxnfc,
1990 	.get_rxnfc		= iavf_get_rxnfc,
1991 	.get_rxfh_indir_size	= iavf_get_rxfh_indir_size,
1992 	.get_rxfh		= iavf_get_rxfh,
1993 	.set_rxfh		= iavf_set_rxfh,
1994 	.get_channels		= iavf_get_channels,
1995 	.set_channels		= iavf_set_channels,
1996 	.get_rxfh_key_size	= iavf_get_rxfh_key_size,
1997 	.get_link_ksettings	= iavf_get_link_ksettings,
1998 };
1999 
2000 /**
2001  * iavf_set_ethtool_ops - Initialize ethtool ops struct
2002  * @netdev: network interface device structure
2003  *
2004  * Sets ethtool ops struct in our netdev so that ethtool can call
2005  * our functions.
2006  **/
2007 void iavf_set_ethtool_ops(struct net_device *netdev)
2008 {
2009 	netdev->ethtool_ops = &iavf_ethtool_ops;
2010 }
2011