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_irq, 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_irq. 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_irq(&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_irq(&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_request_stats(adapter);
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 		snprintf(data, ETH_GSTRING_LEN, "%s",
400 			 iavf_gstrings_priv_flags[i].flag_string);
401 		data += ETH_GSTRING_LEN;
402 	}
403 }
404 
405 /**
406  * iavf_get_stat_strings - Get stat strings
407  * @netdev: network interface device structure
408  * @data: buffer for string data
409  *
410  * Builds the statistics string table
411  **/
412 static void iavf_get_stat_strings(struct net_device *netdev, u8 *data)
413 {
414 	unsigned int i;
415 
416 	iavf_add_stat_strings(&data, iavf_gstrings_stats);
417 
418 	/* Queues are always allocated in pairs, so we just use
419 	 * real_num_tx_queues for both Tx and Rx queues.
420 	 */
421 	for (i = 0; i < netdev->real_num_tx_queues; i++) {
422 		iavf_add_stat_strings(&data, iavf_gstrings_queue_stats,
423 				      "tx", i);
424 		iavf_add_stat_strings(&data, iavf_gstrings_queue_stats,
425 				      "rx", i);
426 	}
427 }
428 
429 /**
430  * iavf_get_strings - Get string set
431  * @netdev: network interface device structure
432  * @sset: id of string set
433  * @data: buffer for string data
434  *
435  * Builds string tables for various string sets
436  **/
437 static void iavf_get_strings(struct net_device *netdev, u32 sset, u8 *data)
438 {
439 	switch (sset) {
440 	case ETH_SS_STATS:
441 		iavf_get_stat_strings(netdev, data);
442 		break;
443 	case ETH_SS_PRIV_FLAGS:
444 		iavf_get_priv_flag_strings(netdev, data);
445 		break;
446 	default:
447 		break;
448 	}
449 }
450 
451 /**
452  * iavf_get_priv_flags - report device private flags
453  * @netdev: network interface device structure
454  *
455  * The get string set count and the string set should be matched for each
456  * flag returned.  Add new strings for each flag to the iavf_gstrings_priv_flags
457  * array.
458  *
459  * Returns a u32 bitmap of flags.
460  **/
461 static u32 iavf_get_priv_flags(struct net_device *netdev)
462 {
463 	struct iavf_adapter *adapter = netdev_priv(netdev);
464 	u32 i, ret_flags = 0;
465 
466 	for (i = 0; i < IAVF_PRIV_FLAGS_STR_LEN; i++) {
467 		const struct iavf_priv_flags *priv_flags;
468 
469 		priv_flags = &iavf_gstrings_priv_flags[i];
470 
471 		if (priv_flags->flag & adapter->flags)
472 			ret_flags |= BIT(i);
473 	}
474 
475 	return ret_flags;
476 }
477 
478 /**
479  * iavf_set_priv_flags - set private flags
480  * @netdev: network interface device structure
481  * @flags: bit flags to be set
482  **/
483 static int iavf_set_priv_flags(struct net_device *netdev, u32 flags)
484 {
485 	struct iavf_adapter *adapter = netdev_priv(netdev);
486 	u32 orig_flags, new_flags, changed_flags;
487 	u32 i;
488 
489 	orig_flags = READ_ONCE(adapter->flags);
490 	new_flags = orig_flags;
491 
492 	for (i = 0; i < IAVF_PRIV_FLAGS_STR_LEN; i++) {
493 		const struct iavf_priv_flags *priv_flags;
494 
495 		priv_flags = &iavf_gstrings_priv_flags[i];
496 
497 		if (flags & BIT(i))
498 			new_flags |= priv_flags->flag;
499 		else
500 			new_flags &= ~(priv_flags->flag);
501 
502 		if (priv_flags->read_only &&
503 		    ((orig_flags ^ new_flags) & ~BIT(i)))
504 			return -EOPNOTSUPP;
505 	}
506 
507 	/* Before we finalize any flag changes, any checks which we need to
508 	 * perform to determine if the new flags will be supported should go
509 	 * here...
510 	 */
511 
512 	/* Compare and exchange the new flags into place. If we failed, that
513 	 * is if cmpxchg returns anything but the old value, this means
514 	 * something else must have modified the flags variable since we
515 	 * copied it. We'll just punt with an error and log something in the
516 	 * message buffer.
517 	 */
518 	if (cmpxchg(&adapter->flags, orig_flags, new_flags) != orig_flags) {
519 		dev_warn(&adapter->pdev->dev,
520 			 "Unable to update adapter->flags as it was modified by another thread...\n");
521 		return -EAGAIN;
522 	}
523 
524 	changed_flags = orig_flags ^ new_flags;
525 
526 	/* Process any additional changes needed as a result of flag changes.
527 	 * The changed_flags value reflects the list of bits that were changed
528 	 * in the code above.
529 	 */
530 
531 	/* issue a reset to force legacy-rx change to take effect */
532 	if (changed_flags & IAVF_FLAG_LEGACY_RX) {
533 		if (netif_running(netdev)) {
534 			adapter->flags |= IAVF_FLAG_RESET_NEEDED;
535 			queue_work(iavf_wq, &adapter->reset_task);
536 		}
537 	}
538 
539 	return 0;
540 }
541 
542 /**
543  * iavf_get_msglevel - Get debug message level
544  * @netdev: network interface device structure
545  *
546  * Returns current debug message level.
547  **/
548 static u32 iavf_get_msglevel(struct net_device *netdev)
549 {
550 	struct iavf_adapter *adapter = netdev_priv(netdev);
551 
552 	return adapter->msg_enable;
553 }
554 
555 /**
556  * iavf_set_msglevel - Set debug message level
557  * @netdev: network interface device structure
558  * @data: message level
559  *
560  * Set current debug message level. Higher values cause the driver to
561  * be noisier.
562  **/
563 static void iavf_set_msglevel(struct net_device *netdev, u32 data)
564 {
565 	struct iavf_adapter *adapter = netdev_priv(netdev);
566 
567 	if (IAVF_DEBUG_USER & data)
568 		adapter->hw.debug_mask = data;
569 	adapter->msg_enable = data;
570 }
571 
572 /**
573  * iavf_get_drvinfo - Get driver info
574  * @netdev: network interface device structure
575  * @drvinfo: ethool driver info structure
576  *
577  * Returns information about the driver and device for display to the user.
578  **/
579 static void iavf_get_drvinfo(struct net_device *netdev,
580 			     struct ethtool_drvinfo *drvinfo)
581 {
582 	struct iavf_adapter *adapter = netdev_priv(netdev);
583 
584 	strscpy(drvinfo->driver, iavf_driver_name, 32);
585 	strscpy(drvinfo->fw_version, "N/A", 4);
586 	strscpy(drvinfo->bus_info, pci_name(adapter->pdev), 32);
587 	drvinfo->n_priv_flags = IAVF_PRIV_FLAGS_STR_LEN;
588 }
589 
590 /**
591  * iavf_get_ringparam - Get ring parameters
592  * @netdev: network interface device structure
593  * @ring: ethtool ringparam structure
594  * @kernel_ring: ethtool extenal ringparam structure
595  * @extack: netlink extended ACK report struct
596  *
597  * Returns current ring parameters. TX and RX rings are reported separately,
598  * but the number of rings is not reported.
599  **/
600 static void iavf_get_ringparam(struct net_device *netdev,
601 			       struct ethtool_ringparam *ring,
602 			       struct kernel_ethtool_ringparam *kernel_ring,
603 			       struct netlink_ext_ack *extack)
604 {
605 	struct iavf_adapter *adapter = netdev_priv(netdev);
606 
607 	ring->rx_max_pending = IAVF_MAX_RXD;
608 	ring->tx_max_pending = IAVF_MAX_TXD;
609 	ring->rx_pending = adapter->rx_desc_count;
610 	ring->tx_pending = adapter->tx_desc_count;
611 }
612 
613 /**
614  * iavf_set_ringparam - Set ring parameters
615  * @netdev: network interface device structure
616  * @ring: ethtool ringparam structure
617  * @kernel_ring: ethtool external ringparam structure
618  * @extack: netlink extended ACK report struct
619  *
620  * Sets ring parameters. TX and RX rings are controlled separately, but the
621  * number of rings is not specified, so all rings get the same settings.
622  **/
623 static int iavf_set_ringparam(struct net_device *netdev,
624 			      struct ethtool_ringparam *ring,
625 			      struct kernel_ethtool_ringparam *kernel_ring,
626 			      struct netlink_ext_ack *extack)
627 {
628 	struct iavf_adapter *adapter = netdev_priv(netdev);
629 	u32 new_rx_count, new_tx_count;
630 
631 	if ((ring->rx_mini_pending) || (ring->rx_jumbo_pending))
632 		return -EINVAL;
633 
634 	if (ring->tx_pending > IAVF_MAX_TXD ||
635 	    ring->tx_pending < IAVF_MIN_TXD ||
636 	    ring->rx_pending > IAVF_MAX_RXD ||
637 	    ring->rx_pending < IAVF_MIN_RXD) {
638 		netdev_err(netdev, "Descriptors requested (Tx: %d / Rx: %d) out of range [%d-%d] (increment %d)\n",
639 			   ring->tx_pending, ring->rx_pending, IAVF_MIN_TXD,
640 			   IAVF_MAX_RXD, IAVF_REQ_DESCRIPTOR_MULTIPLE);
641 		return -EINVAL;
642 	}
643 
644 	new_tx_count = ALIGN(ring->tx_pending, IAVF_REQ_DESCRIPTOR_MULTIPLE);
645 	if (new_tx_count != ring->tx_pending)
646 		netdev_info(netdev, "Requested Tx descriptor count rounded up to %d\n",
647 			    new_tx_count);
648 
649 	new_rx_count = ALIGN(ring->rx_pending, IAVF_REQ_DESCRIPTOR_MULTIPLE);
650 	if (new_rx_count != ring->rx_pending)
651 		netdev_info(netdev, "Requested Rx descriptor count rounded up to %d\n",
652 			    new_rx_count);
653 
654 	/* if nothing to do return success */
655 	if ((new_tx_count == adapter->tx_desc_count) &&
656 	    (new_rx_count == adapter->rx_desc_count)) {
657 		netdev_dbg(netdev, "Nothing to change, descriptor count is same as requested\n");
658 		return 0;
659 	}
660 
661 	if (new_tx_count != adapter->tx_desc_count) {
662 		netdev_dbg(netdev, "Changing Tx descriptor count from %d to %d\n",
663 			   adapter->tx_desc_count, new_tx_count);
664 		adapter->tx_desc_count = new_tx_count;
665 	}
666 
667 	if (new_rx_count != adapter->rx_desc_count) {
668 		netdev_dbg(netdev, "Changing Rx descriptor count from %d to %d\n",
669 			   adapter->rx_desc_count, new_rx_count);
670 		adapter->rx_desc_count = new_rx_count;
671 	}
672 
673 	if (netif_running(netdev)) {
674 		adapter->flags |= IAVF_FLAG_RESET_NEEDED;
675 		queue_work(iavf_wq, &adapter->reset_task);
676 	}
677 
678 	return 0;
679 }
680 
681 /**
682  * __iavf_get_coalesce - get per-queue coalesce settings
683  * @netdev: the netdev to check
684  * @ec: ethtool coalesce data structure
685  * @queue: which queue to pick
686  *
687  * Gets the per-queue settings for coalescence. Specifically Rx and Tx usecs
688  * are per queue. If queue is <0 then we default to queue 0 as the
689  * representative value.
690  **/
691 static int __iavf_get_coalesce(struct net_device *netdev,
692 			       struct ethtool_coalesce *ec, int queue)
693 {
694 	struct iavf_adapter *adapter = netdev_priv(netdev);
695 	struct iavf_ring *rx_ring, *tx_ring;
696 
697 	/* Rx and Tx usecs per queue value. If user doesn't specify the
698 	 * queue, return queue 0's value to represent.
699 	 */
700 	if (queue < 0)
701 		queue = 0;
702 	else if (queue >= adapter->num_active_queues)
703 		return -EINVAL;
704 
705 	rx_ring = &adapter->rx_rings[queue];
706 	tx_ring = &adapter->tx_rings[queue];
707 
708 	if (ITR_IS_DYNAMIC(rx_ring->itr_setting))
709 		ec->use_adaptive_rx_coalesce = 1;
710 
711 	if (ITR_IS_DYNAMIC(tx_ring->itr_setting))
712 		ec->use_adaptive_tx_coalesce = 1;
713 
714 	ec->rx_coalesce_usecs = rx_ring->itr_setting & ~IAVF_ITR_DYNAMIC;
715 	ec->tx_coalesce_usecs = tx_ring->itr_setting & ~IAVF_ITR_DYNAMIC;
716 
717 	return 0;
718 }
719 
720 /**
721  * iavf_get_coalesce - Get interrupt coalescing settings
722  * @netdev: network interface device structure
723  * @ec: ethtool coalesce structure
724  * @kernel_coal: ethtool CQE mode setting structure
725  * @extack: extack for reporting error messages
726  *
727  * Returns current coalescing settings. This is referred to elsewhere in the
728  * driver as Interrupt Throttle Rate, as this is how the hardware describes
729  * this functionality. Note that if per-queue settings have been modified this
730  * only represents the settings of queue 0.
731  **/
732 static int iavf_get_coalesce(struct net_device *netdev,
733 			     struct ethtool_coalesce *ec,
734 			     struct kernel_ethtool_coalesce *kernel_coal,
735 			     struct netlink_ext_ack *extack)
736 {
737 	return __iavf_get_coalesce(netdev, ec, -1);
738 }
739 
740 /**
741  * iavf_get_per_queue_coalesce - get coalesce values for specific queue
742  * @netdev: netdev to read
743  * @ec: coalesce settings from ethtool
744  * @queue: the queue to read
745  *
746  * Read specific queue's coalesce settings.
747  **/
748 static int iavf_get_per_queue_coalesce(struct net_device *netdev, u32 queue,
749 				       struct ethtool_coalesce *ec)
750 {
751 	return __iavf_get_coalesce(netdev, ec, queue);
752 }
753 
754 /**
755  * iavf_set_itr_per_queue - set ITR values for specific queue
756  * @adapter: the VF adapter struct to set values for
757  * @ec: coalesce settings from ethtool
758  * @queue: the queue to modify
759  *
760  * Change the ITR settings for a specific queue.
761  **/
762 static int iavf_set_itr_per_queue(struct iavf_adapter *adapter,
763 				  struct ethtool_coalesce *ec, int queue)
764 {
765 	struct iavf_ring *rx_ring = &adapter->rx_rings[queue];
766 	struct iavf_ring *tx_ring = &adapter->tx_rings[queue];
767 	struct iavf_q_vector *q_vector;
768 	u16 itr_setting;
769 
770 	itr_setting = rx_ring->itr_setting & ~IAVF_ITR_DYNAMIC;
771 
772 	if (ec->rx_coalesce_usecs != itr_setting &&
773 	    ec->use_adaptive_rx_coalesce) {
774 		netif_info(adapter, drv, adapter->netdev,
775 			   "Rx interrupt throttling cannot be changed if adaptive-rx is enabled\n");
776 		return -EINVAL;
777 	}
778 
779 	itr_setting = tx_ring->itr_setting & ~IAVF_ITR_DYNAMIC;
780 
781 	if (ec->tx_coalesce_usecs != itr_setting &&
782 	    ec->use_adaptive_tx_coalesce) {
783 		netif_info(adapter, drv, adapter->netdev,
784 			   "Tx interrupt throttling cannot be changed if adaptive-tx is enabled\n");
785 		return -EINVAL;
786 	}
787 
788 	rx_ring->itr_setting = ITR_REG_ALIGN(ec->rx_coalesce_usecs);
789 	tx_ring->itr_setting = ITR_REG_ALIGN(ec->tx_coalesce_usecs);
790 
791 	rx_ring->itr_setting |= IAVF_ITR_DYNAMIC;
792 	if (!ec->use_adaptive_rx_coalesce)
793 		rx_ring->itr_setting ^= IAVF_ITR_DYNAMIC;
794 
795 	tx_ring->itr_setting |= IAVF_ITR_DYNAMIC;
796 	if (!ec->use_adaptive_tx_coalesce)
797 		tx_ring->itr_setting ^= IAVF_ITR_DYNAMIC;
798 
799 	q_vector = rx_ring->q_vector;
800 	q_vector->rx.target_itr = ITR_TO_REG(rx_ring->itr_setting);
801 
802 	q_vector = tx_ring->q_vector;
803 	q_vector->tx.target_itr = ITR_TO_REG(tx_ring->itr_setting);
804 
805 	/* The interrupt handler itself will take care of programming
806 	 * the Tx and Rx ITR values based on the values we have entered
807 	 * into the q_vector, no need to write the values now.
808 	 */
809 	return 0;
810 }
811 
812 /**
813  * __iavf_set_coalesce - set coalesce settings for particular queue
814  * @netdev: the netdev to change
815  * @ec: ethtool coalesce settings
816  * @queue: the queue to change
817  *
818  * Sets the coalesce settings for a particular queue.
819  **/
820 static int __iavf_set_coalesce(struct net_device *netdev,
821 			       struct ethtool_coalesce *ec, int queue)
822 {
823 	struct iavf_adapter *adapter = netdev_priv(netdev);
824 	int i;
825 
826 	if (ec->rx_coalesce_usecs == 0) {
827 		if (ec->use_adaptive_rx_coalesce)
828 			netif_info(adapter, drv, netdev, "rx-usecs=0, need to disable adaptive-rx for a complete disable\n");
829 	} else if ((ec->rx_coalesce_usecs < IAVF_MIN_ITR) ||
830 		   (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 == 0) {
834 		if (ec->use_adaptive_tx_coalesce)
835 			netif_info(adapter, drv, netdev, "tx-usecs=0, need to disable adaptive-tx for a complete disable\n");
836 	} else if ((ec->tx_coalesce_usecs < IAVF_MIN_ITR) ||
837 		   (ec->tx_coalesce_usecs > IAVF_MAX_ITR)) {
838 		netif_info(adapter, drv, netdev, "Invalid value, tx-usecs range is 0-8160\n");
839 		return -EINVAL;
840 	}
841 
842 	/* Rx and Tx usecs has per queue value. If user doesn't specify the
843 	 * queue, apply to all queues.
844 	 */
845 	if (queue < 0) {
846 		for (i = 0; i < adapter->num_active_queues; i++)
847 			if (iavf_set_itr_per_queue(adapter, ec, i))
848 				return -EINVAL;
849 	} else if (queue < adapter->num_active_queues) {
850 		if (iavf_set_itr_per_queue(adapter, ec, queue))
851 			return -EINVAL;
852 	} else {
853 		netif_info(adapter, drv, netdev, "Invalid queue value, queue range is 0 - %d\n",
854 			   adapter->num_active_queues - 1);
855 		return -EINVAL;
856 	}
857 
858 	return 0;
859 }
860 
861 /**
862  * iavf_set_coalesce - Set interrupt coalescing settings
863  * @netdev: network interface device structure
864  * @ec: ethtool coalesce structure
865  * @kernel_coal: ethtool CQE mode setting structure
866  * @extack: extack for reporting error messages
867  *
868  * Change current coalescing settings for every queue.
869  **/
870 static int iavf_set_coalesce(struct net_device *netdev,
871 			     struct ethtool_coalesce *ec,
872 			     struct kernel_ethtool_coalesce *kernel_coal,
873 			     struct netlink_ext_ack *extack)
874 {
875 	return __iavf_set_coalesce(netdev, ec, -1);
876 }
877 
878 /**
879  * iavf_set_per_queue_coalesce - set specific queue's coalesce settings
880  * @netdev: the netdev to change
881  * @ec: ethtool's coalesce settings
882  * @queue: the queue to modify
883  *
884  * Modifies a specific queue's coalesce settings.
885  */
886 static int iavf_set_per_queue_coalesce(struct net_device *netdev, u32 queue,
887 				       struct ethtool_coalesce *ec)
888 {
889 	return __iavf_set_coalesce(netdev, ec, queue);
890 }
891 
892 /**
893  * iavf_fltr_to_ethtool_flow - convert filter type values to ethtool
894  * flow type values
895  * @flow: filter type to be converted
896  *
897  * Returns the corresponding ethtool flow type.
898  */
899 static int iavf_fltr_to_ethtool_flow(enum iavf_fdir_flow_type flow)
900 {
901 	switch (flow) {
902 	case IAVF_FDIR_FLOW_IPV4_TCP:
903 		return TCP_V4_FLOW;
904 	case IAVF_FDIR_FLOW_IPV4_UDP:
905 		return UDP_V4_FLOW;
906 	case IAVF_FDIR_FLOW_IPV4_SCTP:
907 		return SCTP_V4_FLOW;
908 	case IAVF_FDIR_FLOW_IPV4_AH:
909 		return AH_V4_FLOW;
910 	case IAVF_FDIR_FLOW_IPV4_ESP:
911 		return ESP_V4_FLOW;
912 	case IAVF_FDIR_FLOW_IPV4_OTHER:
913 		return IPV4_USER_FLOW;
914 	case IAVF_FDIR_FLOW_IPV6_TCP:
915 		return TCP_V6_FLOW;
916 	case IAVF_FDIR_FLOW_IPV6_UDP:
917 		return UDP_V6_FLOW;
918 	case IAVF_FDIR_FLOW_IPV6_SCTP:
919 		return SCTP_V6_FLOW;
920 	case IAVF_FDIR_FLOW_IPV6_AH:
921 		return AH_V6_FLOW;
922 	case IAVF_FDIR_FLOW_IPV6_ESP:
923 		return ESP_V6_FLOW;
924 	case IAVF_FDIR_FLOW_IPV6_OTHER:
925 		return IPV6_USER_FLOW;
926 	case IAVF_FDIR_FLOW_NON_IP_L2:
927 		return ETHER_FLOW;
928 	default:
929 		/* 0 is undefined ethtool flow */
930 		return 0;
931 	}
932 }
933 
934 /**
935  * iavf_ethtool_flow_to_fltr - convert ethtool flow type to filter enum
936  * @eth: Ethtool flow type to be converted
937  *
938  * Returns flow enum
939  */
940 static enum iavf_fdir_flow_type iavf_ethtool_flow_to_fltr(int eth)
941 {
942 	switch (eth) {
943 	case TCP_V4_FLOW:
944 		return IAVF_FDIR_FLOW_IPV4_TCP;
945 	case UDP_V4_FLOW:
946 		return IAVF_FDIR_FLOW_IPV4_UDP;
947 	case SCTP_V4_FLOW:
948 		return IAVF_FDIR_FLOW_IPV4_SCTP;
949 	case AH_V4_FLOW:
950 		return IAVF_FDIR_FLOW_IPV4_AH;
951 	case ESP_V4_FLOW:
952 		return IAVF_FDIR_FLOW_IPV4_ESP;
953 	case IPV4_USER_FLOW:
954 		return IAVF_FDIR_FLOW_IPV4_OTHER;
955 	case TCP_V6_FLOW:
956 		return IAVF_FDIR_FLOW_IPV6_TCP;
957 	case UDP_V6_FLOW:
958 		return IAVF_FDIR_FLOW_IPV6_UDP;
959 	case SCTP_V6_FLOW:
960 		return IAVF_FDIR_FLOW_IPV6_SCTP;
961 	case AH_V6_FLOW:
962 		return IAVF_FDIR_FLOW_IPV6_AH;
963 	case ESP_V6_FLOW:
964 		return IAVF_FDIR_FLOW_IPV6_ESP;
965 	case IPV6_USER_FLOW:
966 		return IAVF_FDIR_FLOW_IPV6_OTHER;
967 	case ETHER_FLOW:
968 		return IAVF_FDIR_FLOW_NON_IP_L2;
969 	default:
970 		return IAVF_FDIR_FLOW_NONE;
971 	}
972 }
973 
974 /**
975  * iavf_is_mask_valid - check mask field set
976  * @mask: full mask to check
977  * @field: field for which mask should be valid
978  *
979  * If the mask is fully set return true. If it is not valid for field return
980  * false.
981  */
982 static bool iavf_is_mask_valid(u64 mask, u64 field)
983 {
984 	return (mask & field) == field;
985 }
986 
987 /**
988  * iavf_parse_rx_flow_user_data - deconstruct user-defined data
989  * @fsp: pointer to ethtool Rx flow specification
990  * @fltr: pointer to Flow Director filter for userdef data storage
991  *
992  * Returns 0 on success, negative error value on failure
993  */
994 static int
995 iavf_parse_rx_flow_user_data(struct ethtool_rx_flow_spec *fsp,
996 			     struct iavf_fdir_fltr *fltr)
997 {
998 	struct iavf_flex_word *flex;
999 	int i, cnt = 0;
1000 
1001 	if (!(fsp->flow_type & FLOW_EXT))
1002 		return 0;
1003 
1004 	for (i = 0; i < IAVF_FLEX_WORD_NUM; i++) {
1005 #define IAVF_USERDEF_FLEX_WORD_M	GENMASK(15, 0)
1006 #define IAVF_USERDEF_FLEX_OFFS_S	16
1007 #define IAVF_USERDEF_FLEX_OFFS_M	GENMASK(31, IAVF_USERDEF_FLEX_OFFS_S)
1008 #define IAVF_USERDEF_FLEX_FLTR_M	GENMASK(31, 0)
1009 		u32 value = be32_to_cpu(fsp->h_ext.data[i]);
1010 		u32 mask = be32_to_cpu(fsp->m_ext.data[i]);
1011 
1012 		if (!value || !mask)
1013 			continue;
1014 
1015 		if (!iavf_is_mask_valid(mask, IAVF_USERDEF_FLEX_FLTR_M))
1016 			return -EINVAL;
1017 
1018 		/* 504 is the maximum value for offsets, and offset is measured
1019 		 * from the start of the MAC address.
1020 		 */
1021 #define IAVF_USERDEF_FLEX_MAX_OFFS_VAL 504
1022 		flex = &fltr->flex_words[cnt++];
1023 		flex->word = value & IAVF_USERDEF_FLEX_WORD_M;
1024 		flex->offset = (value & IAVF_USERDEF_FLEX_OFFS_M) >>
1025 			     IAVF_USERDEF_FLEX_OFFS_S;
1026 		if (flex->offset > IAVF_USERDEF_FLEX_MAX_OFFS_VAL)
1027 			return -EINVAL;
1028 	}
1029 
1030 	fltr->flex_cnt = cnt;
1031 
1032 	return 0;
1033 }
1034 
1035 /**
1036  * iavf_fill_rx_flow_ext_data - fill the additional data
1037  * @fsp: pointer to ethtool Rx flow specification
1038  * @fltr: pointer to Flow Director filter to get additional data
1039  */
1040 static void
1041 iavf_fill_rx_flow_ext_data(struct ethtool_rx_flow_spec *fsp,
1042 			   struct iavf_fdir_fltr *fltr)
1043 {
1044 	if (!fltr->ext_mask.usr_def[0] && !fltr->ext_mask.usr_def[1])
1045 		return;
1046 
1047 	fsp->flow_type |= FLOW_EXT;
1048 
1049 	memcpy(fsp->h_ext.data, fltr->ext_data.usr_def, sizeof(fsp->h_ext.data));
1050 	memcpy(fsp->m_ext.data, fltr->ext_mask.usr_def, sizeof(fsp->m_ext.data));
1051 }
1052 
1053 /**
1054  * iavf_get_ethtool_fdir_entry - fill ethtool structure with Flow Director filter data
1055  * @adapter: the VF adapter structure that contains filter list
1056  * @cmd: ethtool command data structure to receive the filter data
1057  *
1058  * Returns 0 as expected for success by ethtool
1059  */
1060 static int
1061 iavf_get_ethtool_fdir_entry(struct iavf_adapter *adapter,
1062 			    struct ethtool_rxnfc *cmd)
1063 {
1064 	struct ethtool_rx_flow_spec *fsp = (struct ethtool_rx_flow_spec *)&cmd->fs;
1065 	struct iavf_fdir_fltr *rule = NULL;
1066 	int ret = 0;
1067 
1068 	if (!FDIR_FLTR_SUPPORT(adapter))
1069 		return -EOPNOTSUPP;
1070 
1071 	spin_lock_bh(&adapter->fdir_fltr_lock);
1072 
1073 	rule = iavf_find_fdir_fltr_by_loc(adapter, fsp->location);
1074 	if (!rule) {
1075 		ret = -EINVAL;
1076 		goto release_lock;
1077 	}
1078 
1079 	fsp->flow_type = iavf_fltr_to_ethtool_flow(rule->flow_type);
1080 
1081 	memset(&fsp->m_u, 0, sizeof(fsp->m_u));
1082 	memset(&fsp->m_ext, 0, sizeof(fsp->m_ext));
1083 
1084 	switch (fsp->flow_type) {
1085 	case TCP_V4_FLOW:
1086 	case UDP_V4_FLOW:
1087 	case SCTP_V4_FLOW:
1088 		fsp->h_u.tcp_ip4_spec.ip4src = rule->ip_data.v4_addrs.src_ip;
1089 		fsp->h_u.tcp_ip4_spec.ip4dst = rule->ip_data.v4_addrs.dst_ip;
1090 		fsp->h_u.tcp_ip4_spec.psrc = rule->ip_data.src_port;
1091 		fsp->h_u.tcp_ip4_spec.pdst = rule->ip_data.dst_port;
1092 		fsp->h_u.tcp_ip4_spec.tos = rule->ip_data.tos;
1093 		fsp->m_u.tcp_ip4_spec.ip4src = rule->ip_mask.v4_addrs.src_ip;
1094 		fsp->m_u.tcp_ip4_spec.ip4dst = rule->ip_mask.v4_addrs.dst_ip;
1095 		fsp->m_u.tcp_ip4_spec.psrc = rule->ip_mask.src_port;
1096 		fsp->m_u.tcp_ip4_spec.pdst = rule->ip_mask.dst_port;
1097 		fsp->m_u.tcp_ip4_spec.tos = rule->ip_mask.tos;
1098 		break;
1099 	case AH_V4_FLOW:
1100 	case ESP_V4_FLOW:
1101 		fsp->h_u.ah_ip4_spec.ip4src = rule->ip_data.v4_addrs.src_ip;
1102 		fsp->h_u.ah_ip4_spec.ip4dst = rule->ip_data.v4_addrs.dst_ip;
1103 		fsp->h_u.ah_ip4_spec.spi = rule->ip_data.spi;
1104 		fsp->h_u.ah_ip4_spec.tos = rule->ip_data.tos;
1105 		fsp->m_u.ah_ip4_spec.ip4src = rule->ip_mask.v4_addrs.src_ip;
1106 		fsp->m_u.ah_ip4_spec.ip4dst = rule->ip_mask.v4_addrs.dst_ip;
1107 		fsp->m_u.ah_ip4_spec.spi = rule->ip_mask.spi;
1108 		fsp->m_u.ah_ip4_spec.tos = rule->ip_mask.tos;
1109 		break;
1110 	case IPV4_USER_FLOW:
1111 		fsp->h_u.usr_ip4_spec.ip4src = rule->ip_data.v4_addrs.src_ip;
1112 		fsp->h_u.usr_ip4_spec.ip4dst = rule->ip_data.v4_addrs.dst_ip;
1113 		fsp->h_u.usr_ip4_spec.l4_4_bytes = rule->ip_data.l4_header;
1114 		fsp->h_u.usr_ip4_spec.tos = rule->ip_data.tos;
1115 		fsp->h_u.usr_ip4_spec.ip_ver = ETH_RX_NFC_IP4;
1116 		fsp->h_u.usr_ip4_spec.proto = rule->ip_data.proto;
1117 		fsp->m_u.usr_ip4_spec.ip4src = rule->ip_mask.v4_addrs.src_ip;
1118 		fsp->m_u.usr_ip4_spec.ip4dst = rule->ip_mask.v4_addrs.dst_ip;
1119 		fsp->m_u.usr_ip4_spec.l4_4_bytes = rule->ip_mask.l4_header;
1120 		fsp->m_u.usr_ip4_spec.tos = rule->ip_mask.tos;
1121 		fsp->m_u.usr_ip4_spec.ip_ver = 0xFF;
1122 		fsp->m_u.usr_ip4_spec.proto = rule->ip_mask.proto;
1123 		break;
1124 	case TCP_V6_FLOW:
1125 	case UDP_V6_FLOW:
1126 	case SCTP_V6_FLOW:
1127 		memcpy(fsp->h_u.usr_ip6_spec.ip6src, &rule->ip_data.v6_addrs.src_ip,
1128 		       sizeof(struct in6_addr));
1129 		memcpy(fsp->h_u.usr_ip6_spec.ip6dst, &rule->ip_data.v6_addrs.dst_ip,
1130 		       sizeof(struct in6_addr));
1131 		fsp->h_u.tcp_ip6_spec.psrc = rule->ip_data.src_port;
1132 		fsp->h_u.tcp_ip6_spec.pdst = rule->ip_data.dst_port;
1133 		fsp->h_u.tcp_ip6_spec.tclass = rule->ip_data.tclass;
1134 		memcpy(fsp->m_u.usr_ip6_spec.ip6src, &rule->ip_mask.v6_addrs.src_ip,
1135 		       sizeof(struct in6_addr));
1136 		memcpy(fsp->m_u.usr_ip6_spec.ip6dst, &rule->ip_mask.v6_addrs.dst_ip,
1137 		       sizeof(struct in6_addr));
1138 		fsp->m_u.tcp_ip6_spec.psrc = rule->ip_mask.src_port;
1139 		fsp->m_u.tcp_ip6_spec.pdst = rule->ip_mask.dst_port;
1140 		fsp->m_u.tcp_ip6_spec.tclass = rule->ip_mask.tclass;
1141 		break;
1142 	case AH_V6_FLOW:
1143 	case ESP_V6_FLOW:
1144 		memcpy(fsp->h_u.ah_ip6_spec.ip6src, &rule->ip_data.v6_addrs.src_ip,
1145 		       sizeof(struct in6_addr));
1146 		memcpy(fsp->h_u.ah_ip6_spec.ip6dst, &rule->ip_data.v6_addrs.dst_ip,
1147 		       sizeof(struct in6_addr));
1148 		fsp->h_u.ah_ip6_spec.spi = rule->ip_data.spi;
1149 		fsp->h_u.ah_ip6_spec.tclass = rule->ip_data.tclass;
1150 		memcpy(fsp->m_u.ah_ip6_spec.ip6src, &rule->ip_mask.v6_addrs.src_ip,
1151 		       sizeof(struct in6_addr));
1152 		memcpy(fsp->m_u.ah_ip6_spec.ip6dst, &rule->ip_mask.v6_addrs.dst_ip,
1153 		       sizeof(struct in6_addr));
1154 		fsp->m_u.ah_ip6_spec.spi = rule->ip_mask.spi;
1155 		fsp->m_u.ah_ip6_spec.tclass = rule->ip_mask.tclass;
1156 		break;
1157 	case IPV6_USER_FLOW:
1158 		memcpy(fsp->h_u.usr_ip6_spec.ip6src, &rule->ip_data.v6_addrs.src_ip,
1159 		       sizeof(struct in6_addr));
1160 		memcpy(fsp->h_u.usr_ip6_spec.ip6dst, &rule->ip_data.v6_addrs.dst_ip,
1161 		       sizeof(struct in6_addr));
1162 		fsp->h_u.usr_ip6_spec.l4_4_bytes = rule->ip_data.l4_header;
1163 		fsp->h_u.usr_ip6_spec.tclass = rule->ip_data.tclass;
1164 		fsp->h_u.usr_ip6_spec.l4_proto = rule->ip_data.proto;
1165 		memcpy(fsp->m_u.usr_ip6_spec.ip6src, &rule->ip_mask.v6_addrs.src_ip,
1166 		       sizeof(struct in6_addr));
1167 		memcpy(fsp->m_u.usr_ip6_spec.ip6dst, &rule->ip_mask.v6_addrs.dst_ip,
1168 		       sizeof(struct in6_addr));
1169 		fsp->m_u.usr_ip6_spec.l4_4_bytes = rule->ip_mask.l4_header;
1170 		fsp->m_u.usr_ip6_spec.tclass = rule->ip_mask.tclass;
1171 		fsp->m_u.usr_ip6_spec.l4_proto = rule->ip_mask.proto;
1172 		break;
1173 	case ETHER_FLOW:
1174 		fsp->h_u.ether_spec.h_proto = rule->eth_data.etype;
1175 		fsp->m_u.ether_spec.h_proto = rule->eth_mask.etype;
1176 		break;
1177 	default:
1178 		ret = -EINVAL;
1179 		break;
1180 	}
1181 
1182 	iavf_fill_rx_flow_ext_data(fsp, rule);
1183 
1184 	if (rule->action == VIRTCHNL_ACTION_DROP)
1185 		fsp->ring_cookie = RX_CLS_FLOW_DISC;
1186 	else
1187 		fsp->ring_cookie = rule->q_index;
1188 
1189 release_lock:
1190 	spin_unlock_bh(&adapter->fdir_fltr_lock);
1191 	return ret;
1192 }
1193 
1194 /**
1195  * iavf_get_fdir_fltr_ids - fill buffer with filter IDs of active filters
1196  * @adapter: the VF adapter structure containing the filter list
1197  * @cmd: ethtool command data structure
1198  * @rule_locs: ethtool array passed in from OS to receive filter IDs
1199  *
1200  * Returns 0 as expected for success by ethtool
1201  */
1202 static int
1203 iavf_get_fdir_fltr_ids(struct iavf_adapter *adapter, struct ethtool_rxnfc *cmd,
1204 		       u32 *rule_locs)
1205 {
1206 	struct iavf_fdir_fltr *fltr;
1207 	unsigned int cnt = 0;
1208 	int val = 0;
1209 
1210 	if (!FDIR_FLTR_SUPPORT(adapter))
1211 		return -EOPNOTSUPP;
1212 
1213 	cmd->data = IAVF_MAX_FDIR_FILTERS;
1214 
1215 	spin_lock_bh(&adapter->fdir_fltr_lock);
1216 
1217 	list_for_each_entry(fltr, &adapter->fdir_list_head, list) {
1218 		if (cnt == cmd->rule_cnt) {
1219 			val = -EMSGSIZE;
1220 			goto release_lock;
1221 		}
1222 		rule_locs[cnt] = fltr->loc;
1223 		cnt++;
1224 	}
1225 
1226 release_lock:
1227 	spin_unlock_bh(&adapter->fdir_fltr_lock);
1228 	if (!val)
1229 		cmd->rule_cnt = cnt;
1230 
1231 	return val;
1232 }
1233 
1234 /**
1235  * iavf_add_fdir_fltr_info - Set the input set for Flow Director filter
1236  * @adapter: pointer to the VF adapter structure
1237  * @fsp: pointer to ethtool Rx flow specification
1238  * @fltr: filter structure
1239  */
1240 static int
1241 iavf_add_fdir_fltr_info(struct iavf_adapter *adapter, struct ethtool_rx_flow_spec *fsp,
1242 			struct iavf_fdir_fltr *fltr)
1243 {
1244 	u32 flow_type, q_index = 0;
1245 	enum virtchnl_action act;
1246 	int err;
1247 
1248 	if (fsp->ring_cookie == RX_CLS_FLOW_DISC) {
1249 		act = VIRTCHNL_ACTION_DROP;
1250 	} else {
1251 		q_index = fsp->ring_cookie;
1252 		if (q_index >= adapter->num_active_queues)
1253 			return -EINVAL;
1254 
1255 		act = VIRTCHNL_ACTION_QUEUE;
1256 	}
1257 
1258 	fltr->action = act;
1259 	fltr->loc = fsp->location;
1260 	fltr->q_index = q_index;
1261 
1262 	if (fsp->flow_type & FLOW_EXT) {
1263 		memcpy(fltr->ext_data.usr_def, fsp->h_ext.data,
1264 		       sizeof(fltr->ext_data.usr_def));
1265 		memcpy(fltr->ext_mask.usr_def, fsp->m_ext.data,
1266 		       sizeof(fltr->ext_mask.usr_def));
1267 	}
1268 
1269 	flow_type = fsp->flow_type & ~(FLOW_EXT | FLOW_MAC_EXT | FLOW_RSS);
1270 	fltr->flow_type = iavf_ethtool_flow_to_fltr(flow_type);
1271 
1272 	switch (flow_type) {
1273 	case TCP_V4_FLOW:
1274 	case UDP_V4_FLOW:
1275 	case SCTP_V4_FLOW:
1276 		fltr->ip_data.v4_addrs.src_ip = fsp->h_u.tcp_ip4_spec.ip4src;
1277 		fltr->ip_data.v4_addrs.dst_ip = fsp->h_u.tcp_ip4_spec.ip4dst;
1278 		fltr->ip_data.src_port = fsp->h_u.tcp_ip4_spec.psrc;
1279 		fltr->ip_data.dst_port = fsp->h_u.tcp_ip4_spec.pdst;
1280 		fltr->ip_data.tos = fsp->h_u.tcp_ip4_spec.tos;
1281 		fltr->ip_mask.v4_addrs.src_ip = fsp->m_u.tcp_ip4_spec.ip4src;
1282 		fltr->ip_mask.v4_addrs.dst_ip = fsp->m_u.tcp_ip4_spec.ip4dst;
1283 		fltr->ip_mask.src_port = fsp->m_u.tcp_ip4_spec.psrc;
1284 		fltr->ip_mask.dst_port = fsp->m_u.tcp_ip4_spec.pdst;
1285 		fltr->ip_mask.tos = fsp->m_u.tcp_ip4_spec.tos;
1286 		break;
1287 	case AH_V4_FLOW:
1288 	case ESP_V4_FLOW:
1289 		fltr->ip_data.v4_addrs.src_ip = fsp->h_u.ah_ip4_spec.ip4src;
1290 		fltr->ip_data.v4_addrs.dst_ip = fsp->h_u.ah_ip4_spec.ip4dst;
1291 		fltr->ip_data.spi = fsp->h_u.ah_ip4_spec.spi;
1292 		fltr->ip_data.tos = fsp->h_u.ah_ip4_spec.tos;
1293 		fltr->ip_mask.v4_addrs.src_ip = fsp->m_u.ah_ip4_spec.ip4src;
1294 		fltr->ip_mask.v4_addrs.dst_ip = fsp->m_u.ah_ip4_spec.ip4dst;
1295 		fltr->ip_mask.spi = fsp->m_u.ah_ip4_spec.spi;
1296 		fltr->ip_mask.tos = fsp->m_u.ah_ip4_spec.tos;
1297 		break;
1298 	case IPV4_USER_FLOW:
1299 		fltr->ip_data.v4_addrs.src_ip = fsp->h_u.usr_ip4_spec.ip4src;
1300 		fltr->ip_data.v4_addrs.dst_ip = fsp->h_u.usr_ip4_spec.ip4dst;
1301 		fltr->ip_data.l4_header = fsp->h_u.usr_ip4_spec.l4_4_bytes;
1302 		fltr->ip_data.tos = fsp->h_u.usr_ip4_spec.tos;
1303 		fltr->ip_data.proto = fsp->h_u.usr_ip4_spec.proto;
1304 		fltr->ip_mask.v4_addrs.src_ip = fsp->m_u.usr_ip4_spec.ip4src;
1305 		fltr->ip_mask.v4_addrs.dst_ip = fsp->m_u.usr_ip4_spec.ip4dst;
1306 		fltr->ip_mask.l4_header = fsp->m_u.usr_ip4_spec.l4_4_bytes;
1307 		fltr->ip_mask.tos = fsp->m_u.usr_ip4_spec.tos;
1308 		fltr->ip_mask.proto = fsp->m_u.usr_ip4_spec.proto;
1309 		break;
1310 	case TCP_V6_FLOW:
1311 	case UDP_V6_FLOW:
1312 	case SCTP_V6_FLOW:
1313 		memcpy(&fltr->ip_data.v6_addrs.src_ip, fsp->h_u.usr_ip6_spec.ip6src,
1314 		       sizeof(struct in6_addr));
1315 		memcpy(&fltr->ip_data.v6_addrs.dst_ip, fsp->h_u.usr_ip6_spec.ip6dst,
1316 		       sizeof(struct in6_addr));
1317 		fltr->ip_data.src_port = fsp->h_u.tcp_ip6_spec.psrc;
1318 		fltr->ip_data.dst_port = fsp->h_u.tcp_ip6_spec.pdst;
1319 		fltr->ip_data.tclass = fsp->h_u.tcp_ip6_spec.tclass;
1320 		memcpy(&fltr->ip_mask.v6_addrs.src_ip, fsp->m_u.usr_ip6_spec.ip6src,
1321 		       sizeof(struct in6_addr));
1322 		memcpy(&fltr->ip_mask.v6_addrs.dst_ip, fsp->m_u.usr_ip6_spec.ip6dst,
1323 		       sizeof(struct in6_addr));
1324 		fltr->ip_mask.src_port = fsp->m_u.tcp_ip6_spec.psrc;
1325 		fltr->ip_mask.dst_port = fsp->m_u.tcp_ip6_spec.pdst;
1326 		fltr->ip_mask.tclass = fsp->m_u.tcp_ip6_spec.tclass;
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 		break;
1343 	case IPV6_USER_FLOW:
1344 		memcpy(&fltr->ip_data.v6_addrs.src_ip, fsp->h_u.usr_ip6_spec.ip6src,
1345 		       sizeof(struct in6_addr));
1346 		memcpy(&fltr->ip_data.v6_addrs.dst_ip, fsp->h_u.usr_ip6_spec.ip6dst,
1347 		       sizeof(struct in6_addr));
1348 		fltr->ip_data.l4_header = fsp->h_u.usr_ip6_spec.l4_4_bytes;
1349 		fltr->ip_data.tclass = fsp->h_u.usr_ip6_spec.tclass;
1350 		fltr->ip_data.proto = fsp->h_u.usr_ip6_spec.l4_proto;
1351 		memcpy(&fltr->ip_mask.v6_addrs.src_ip, fsp->m_u.usr_ip6_spec.ip6src,
1352 		       sizeof(struct in6_addr));
1353 		memcpy(&fltr->ip_mask.v6_addrs.dst_ip, fsp->m_u.usr_ip6_spec.ip6dst,
1354 		       sizeof(struct in6_addr));
1355 		fltr->ip_mask.l4_header = fsp->m_u.usr_ip6_spec.l4_4_bytes;
1356 		fltr->ip_mask.tclass = fsp->m_u.usr_ip6_spec.tclass;
1357 		fltr->ip_mask.proto = fsp->m_u.usr_ip6_spec.l4_proto;
1358 		break;
1359 	case ETHER_FLOW:
1360 		fltr->eth_data.etype = fsp->h_u.ether_spec.h_proto;
1361 		fltr->eth_mask.etype = fsp->m_u.ether_spec.h_proto;
1362 		break;
1363 	default:
1364 		/* not doing un-parsed flow types */
1365 		return -EINVAL;
1366 	}
1367 
1368 	if (iavf_fdir_is_dup_fltr(adapter, fltr))
1369 		return -EEXIST;
1370 
1371 	err = iavf_parse_rx_flow_user_data(fsp, fltr);
1372 	if (err)
1373 		return err;
1374 
1375 	return iavf_fill_fdir_add_msg(adapter, fltr);
1376 }
1377 
1378 /**
1379  * iavf_add_fdir_ethtool - add Flow Director filter
1380  * @adapter: pointer to the VF adapter structure
1381  * @cmd: command to add Flow Director filter
1382  *
1383  * Returns 0 on success and negative values for failure
1384  */
1385 static int iavf_add_fdir_ethtool(struct iavf_adapter *adapter, struct ethtool_rxnfc *cmd)
1386 {
1387 	struct ethtool_rx_flow_spec *fsp = &cmd->fs;
1388 	struct iavf_fdir_fltr *fltr;
1389 	int count = 50;
1390 	int err;
1391 
1392 	if (!FDIR_FLTR_SUPPORT(adapter))
1393 		return -EOPNOTSUPP;
1394 
1395 	if (fsp->flow_type & FLOW_MAC_EXT)
1396 		return -EINVAL;
1397 
1398 	if (adapter->fdir_active_fltr >= IAVF_MAX_FDIR_FILTERS) {
1399 		dev_err(&adapter->pdev->dev,
1400 			"Unable to add Flow Director filter because VF reached the limit of max allowed filters (%u)\n",
1401 			IAVF_MAX_FDIR_FILTERS);
1402 		return -ENOSPC;
1403 	}
1404 
1405 	spin_lock_bh(&adapter->fdir_fltr_lock);
1406 	if (iavf_find_fdir_fltr_by_loc(adapter, fsp->location)) {
1407 		dev_err(&adapter->pdev->dev, "Failed to add Flow Director filter, it already exists\n");
1408 		spin_unlock_bh(&adapter->fdir_fltr_lock);
1409 		return -EEXIST;
1410 	}
1411 	spin_unlock_bh(&adapter->fdir_fltr_lock);
1412 
1413 	fltr = kzalloc(sizeof(*fltr), GFP_KERNEL);
1414 	if (!fltr)
1415 		return -ENOMEM;
1416 
1417 	while (!mutex_trylock(&adapter->crit_lock)) {
1418 		if (--count == 0) {
1419 			kfree(fltr);
1420 			return -EINVAL;
1421 		}
1422 		udelay(1);
1423 	}
1424 
1425 	err = iavf_add_fdir_fltr_info(adapter, fsp, fltr);
1426 	if (err)
1427 		goto ret;
1428 
1429 	spin_lock_bh(&adapter->fdir_fltr_lock);
1430 	iavf_fdir_list_add_fltr(adapter, fltr);
1431 	adapter->fdir_active_fltr++;
1432 	fltr->state = IAVF_FDIR_FLTR_ADD_REQUEST;
1433 	adapter->aq_required |= IAVF_FLAG_AQ_ADD_FDIR_FILTER;
1434 	spin_unlock_bh(&adapter->fdir_fltr_lock);
1435 
1436 	mod_delayed_work(iavf_wq, &adapter->watchdog_task, 0);
1437 
1438 ret:
1439 	if (err && fltr)
1440 		kfree(fltr);
1441 
1442 	mutex_unlock(&adapter->crit_lock);
1443 	return err;
1444 }
1445 
1446 /**
1447  * iavf_del_fdir_ethtool - delete Flow Director filter
1448  * @adapter: pointer to the VF adapter structure
1449  * @cmd: command to delete Flow Director filter
1450  *
1451  * Returns 0 on success and negative values for failure
1452  */
1453 static int iavf_del_fdir_ethtool(struct iavf_adapter *adapter, struct ethtool_rxnfc *cmd)
1454 {
1455 	struct ethtool_rx_flow_spec *fsp = (struct ethtool_rx_flow_spec *)&cmd->fs;
1456 	struct iavf_fdir_fltr *fltr = NULL;
1457 	int err = 0;
1458 
1459 	if (!FDIR_FLTR_SUPPORT(adapter))
1460 		return -EOPNOTSUPP;
1461 
1462 	spin_lock_bh(&adapter->fdir_fltr_lock);
1463 	fltr = iavf_find_fdir_fltr_by_loc(adapter, fsp->location);
1464 	if (fltr) {
1465 		if (fltr->state == IAVF_FDIR_FLTR_ACTIVE) {
1466 			fltr->state = IAVF_FDIR_FLTR_DEL_REQUEST;
1467 			adapter->aq_required |= IAVF_FLAG_AQ_DEL_FDIR_FILTER;
1468 		} else {
1469 			err = -EBUSY;
1470 		}
1471 	} else if (adapter->fdir_active_fltr) {
1472 		err = -EINVAL;
1473 	}
1474 	spin_unlock_bh(&adapter->fdir_fltr_lock);
1475 
1476 	if (fltr && fltr->state == IAVF_FDIR_FLTR_DEL_REQUEST)
1477 		mod_delayed_work(iavf_wq, &adapter->watchdog_task, 0);
1478 
1479 	return err;
1480 }
1481 
1482 /**
1483  * iavf_adv_rss_parse_hdrs - parses headers from RSS hash input
1484  * @cmd: ethtool rxnfc command
1485  *
1486  * This function parses the rxnfc command and returns intended
1487  * header types for RSS configuration
1488  */
1489 static u32 iavf_adv_rss_parse_hdrs(struct ethtool_rxnfc *cmd)
1490 {
1491 	u32 hdrs = IAVF_ADV_RSS_FLOW_SEG_HDR_NONE;
1492 
1493 	switch (cmd->flow_type) {
1494 	case TCP_V4_FLOW:
1495 		hdrs |= IAVF_ADV_RSS_FLOW_SEG_HDR_TCP |
1496 			IAVF_ADV_RSS_FLOW_SEG_HDR_IPV4;
1497 		break;
1498 	case UDP_V4_FLOW:
1499 		hdrs |= IAVF_ADV_RSS_FLOW_SEG_HDR_UDP |
1500 			IAVF_ADV_RSS_FLOW_SEG_HDR_IPV4;
1501 		break;
1502 	case SCTP_V4_FLOW:
1503 		hdrs |= IAVF_ADV_RSS_FLOW_SEG_HDR_SCTP |
1504 			IAVF_ADV_RSS_FLOW_SEG_HDR_IPV4;
1505 		break;
1506 	case TCP_V6_FLOW:
1507 		hdrs |= IAVF_ADV_RSS_FLOW_SEG_HDR_TCP |
1508 			IAVF_ADV_RSS_FLOW_SEG_HDR_IPV6;
1509 		break;
1510 	case UDP_V6_FLOW:
1511 		hdrs |= IAVF_ADV_RSS_FLOW_SEG_HDR_UDP |
1512 			IAVF_ADV_RSS_FLOW_SEG_HDR_IPV6;
1513 		break;
1514 	case SCTP_V6_FLOW:
1515 		hdrs |= IAVF_ADV_RSS_FLOW_SEG_HDR_SCTP |
1516 			IAVF_ADV_RSS_FLOW_SEG_HDR_IPV6;
1517 		break;
1518 	default:
1519 		break;
1520 	}
1521 
1522 	return hdrs;
1523 }
1524 
1525 /**
1526  * iavf_adv_rss_parse_hash_flds - parses hash fields from RSS hash input
1527  * @cmd: ethtool rxnfc command
1528  *
1529  * This function parses the rxnfc command and returns intended hash fields for
1530  * RSS configuration
1531  */
1532 static u64 iavf_adv_rss_parse_hash_flds(struct ethtool_rxnfc *cmd)
1533 {
1534 	u64 hfld = IAVF_ADV_RSS_HASH_INVALID;
1535 
1536 	if (cmd->data & RXH_IP_SRC || cmd->data & RXH_IP_DST) {
1537 		switch (cmd->flow_type) {
1538 		case TCP_V4_FLOW:
1539 		case UDP_V4_FLOW:
1540 		case SCTP_V4_FLOW:
1541 			if (cmd->data & RXH_IP_SRC)
1542 				hfld |= IAVF_ADV_RSS_HASH_FLD_IPV4_SA;
1543 			if (cmd->data & RXH_IP_DST)
1544 				hfld |= IAVF_ADV_RSS_HASH_FLD_IPV4_DA;
1545 			break;
1546 		case TCP_V6_FLOW:
1547 		case UDP_V6_FLOW:
1548 		case SCTP_V6_FLOW:
1549 			if (cmd->data & RXH_IP_SRC)
1550 				hfld |= IAVF_ADV_RSS_HASH_FLD_IPV6_SA;
1551 			if (cmd->data & RXH_IP_DST)
1552 				hfld |= IAVF_ADV_RSS_HASH_FLD_IPV6_DA;
1553 			break;
1554 		default:
1555 			break;
1556 		}
1557 	}
1558 
1559 	if (cmd->data & RXH_L4_B_0_1 || cmd->data & RXH_L4_B_2_3) {
1560 		switch (cmd->flow_type) {
1561 		case TCP_V4_FLOW:
1562 		case TCP_V6_FLOW:
1563 			if (cmd->data & RXH_L4_B_0_1)
1564 				hfld |= IAVF_ADV_RSS_HASH_FLD_TCP_SRC_PORT;
1565 			if (cmd->data & RXH_L4_B_2_3)
1566 				hfld |= IAVF_ADV_RSS_HASH_FLD_TCP_DST_PORT;
1567 			break;
1568 		case UDP_V4_FLOW:
1569 		case UDP_V6_FLOW:
1570 			if (cmd->data & RXH_L4_B_0_1)
1571 				hfld |= IAVF_ADV_RSS_HASH_FLD_UDP_SRC_PORT;
1572 			if (cmd->data & RXH_L4_B_2_3)
1573 				hfld |= IAVF_ADV_RSS_HASH_FLD_UDP_DST_PORT;
1574 			break;
1575 		case SCTP_V4_FLOW:
1576 		case SCTP_V6_FLOW:
1577 			if (cmd->data & RXH_L4_B_0_1)
1578 				hfld |= IAVF_ADV_RSS_HASH_FLD_SCTP_SRC_PORT;
1579 			if (cmd->data & RXH_L4_B_2_3)
1580 				hfld |= IAVF_ADV_RSS_HASH_FLD_SCTP_DST_PORT;
1581 			break;
1582 		default:
1583 			break;
1584 		}
1585 	}
1586 
1587 	return hfld;
1588 }
1589 
1590 /**
1591  * iavf_set_adv_rss_hash_opt - Enable/Disable flow types for RSS hash
1592  * @adapter: pointer to the VF adapter structure
1593  * @cmd: ethtool rxnfc command
1594  *
1595  * Returns Success if the flow input set is supported.
1596  */
1597 static int
1598 iavf_set_adv_rss_hash_opt(struct iavf_adapter *adapter,
1599 			  struct ethtool_rxnfc *cmd)
1600 {
1601 	struct iavf_adv_rss *rss_old, *rss_new;
1602 	bool rss_new_add = false;
1603 	int count = 50, err = 0;
1604 	u64 hash_flds;
1605 	u32 hdrs;
1606 
1607 	if (!ADV_RSS_SUPPORT(adapter))
1608 		return -EOPNOTSUPP;
1609 
1610 	hdrs = iavf_adv_rss_parse_hdrs(cmd);
1611 	if (hdrs == IAVF_ADV_RSS_FLOW_SEG_HDR_NONE)
1612 		return -EINVAL;
1613 
1614 	hash_flds = iavf_adv_rss_parse_hash_flds(cmd);
1615 	if (hash_flds == IAVF_ADV_RSS_HASH_INVALID)
1616 		return -EINVAL;
1617 
1618 	rss_new = kzalloc(sizeof(*rss_new), GFP_KERNEL);
1619 	if (!rss_new)
1620 		return -ENOMEM;
1621 
1622 	if (iavf_fill_adv_rss_cfg_msg(&rss_new->cfg_msg, hdrs, hash_flds)) {
1623 		kfree(rss_new);
1624 		return -EINVAL;
1625 	}
1626 
1627 	while (!mutex_trylock(&adapter->crit_lock)) {
1628 		if (--count == 0) {
1629 			kfree(rss_new);
1630 			return -EINVAL;
1631 		}
1632 
1633 		udelay(1);
1634 	}
1635 
1636 	spin_lock_bh(&adapter->adv_rss_lock);
1637 	rss_old = iavf_find_adv_rss_cfg_by_hdrs(adapter, hdrs);
1638 	if (rss_old) {
1639 		if (rss_old->state != IAVF_ADV_RSS_ACTIVE) {
1640 			err = -EBUSY;
1641 		} else if (rss_old->hash_flds != hash_flds) {
1642 			rss_old->state = IAVF_ADV_RSS_ADD_REQUEST;
1643 			rss_old->hash_flds = hash_flds;
1644 			memcpy(&rss_old->cfg_msg, &rss_new->cfg_msg,
1645 			       sizeof(rss_new->cfg_msg));
1646 			adapter->aq_required |= IAVF_FLAG_AQ_ADD_ADV_RSS_CFG;
1647 		} else {
1648 			err = -EEXIST;
1649 		}
1650 	} else {
1651 		rss_new_add = true;
1652 		rss_new->state = IAVF_ADV_RSS_ADD_REQUEST;
1653 		rss_new->packet_hdrs = hdrs;
1654 		rss_new->hash_flds = hash_flds;
1655 		list_add_tail(&rss_new->list, &adapter->adv_rss_list_head);
1656 		adapter->aq_required |= IAVF_FLAG_AQ_ADD_ADV_RSS_CFG;
1657 	}
1658 	spin_unlock_bh(&adapter->adv_rss_lock);
1659 
1660 	if (!err)
1661 		mod_delayed_work(iavf_wq, &adapter->watchdog_task, 0);
1662 
1663 	mutex_unlock(&adapter->crit_lock);
1664 
1665 	if (!rss_new_add)
1666 		kfree(rss_new);
1667 
1668 	return err;
1669 }
1670 
1671 /**
1672  * iavf_get_adv_rss_hash_opt - Retrieve hash fields for a given flow-type
1673  * @adapter: pointer to the VF adapter structure
1674  * @cmd: ethtool rxnfc command
1675  *
1676  * Returns Success if the flow input set is supported.
1677  */
1678 static int
1679 iavf_get_adv_rss_hash_opt(struct iavf_adapter *adapter,
1680 			  struct ethtool_rxnfc *cmd)
1681 {
1682 	struct iavf_adv_rss *rss;
1683 	u64 hash_flds;
1684 	u32 hdrs;
1685 
1686 	if (!ADV_RSS_SUPPORT(adapter))
1687 		return -EOPNOTSUPP;
1688 
1689 	cmd->data = 0;
1690 
1691 	hdrs = iavf_adv_rss_parse_hdrs(cmd);
1692 	if (hdrs == IAVF_ADV_RSS_FLOW_SEG_HDR_NONE)
1693 		return -EINVAL;
1694 
1695 	spin_lock_bh(&adapter->adv_rss_lock);
1696 	rss = iavf_find_adv_rss_cfg_by_hdrs(adapter, hdrs);
1697 	if (rss)
1698 		hash_flds = rss->hash_flds;
1699 	else
1700 		hash_flds = IAVF_ADV_RSS_HASH_INVALID;
1701 	spin_unlock_bh(&adapter->adv_rss_lock);
1702 
1703 	if (hash_flds == IAVF_ADV_RSS_HASH_INVALID)
1704 		return -EINVAL;
1705 
1706 	if (hash_flds & (IAVF_ADV_RSS_HASH_FLD_IPV4_SA |
1707 			 IAVF_ADV_RSS_HASH_FLD_IPV6_SA))
1708 		cmd->data |= (u64)RXH_IP_SRC;
1709 
1710 	if (hash_flds & (IAVF_ADV_RSS_HASH_FLD_IPV4_DA |
1711 			 IAVF_ADV_RSS_HASH_FLD_IPV6_DA))
1712 		cmd->data |= (u64)RXH_IP_DST;
1713 
1714 	if (hash_flds & (IAVF_ADV_RSS_HASH_FLD_TCP_SRC_PORT |
1715 			 IAVF_ADV_RSS_HASH_FLD_UDP_SRC_PORT |
1716 			 IAVF_ADV_RSS_HASH_FLD_SCTP_SRC_PORT))
1717 		cmd->data |= (u64)RXH_L4_B_0_1;
1718 
1719 	if (hash_flds & (IAVF_ADV_RSS_HASH_FLD_TCP_DST_PORT |
1720 			 IAVF_ADV_RSS_HASH_FLD_UDP_DST_PORT |
1721 			 IAVF_ADV_RSS_HASH_FLD_SCTP_DST_PORT))
1722 		cmd->data |= (u64)RXH_L4_B_2_3;
1723 
1724 	return 0;
1725 }
1726 
1727 /**
1728  * iavf_set_rxnfc - command to set Rx flow rules.
1729  * @netdev: network interface device structure
1730  * @cmd: ethtool rxnfc command
1731  *
1732  * Returns 0 for success and negative values for errors
1733  */
1734 static int iavf_set_rxnfc(struct net_device *netdev, struct ethtool_rxnfc *cmd)
1735 {
1736 	struct iavf_adapter *adapter = netdev_priv(netdev);
1737 	int ret = -EOPNOTSUPP;
1738 
1739 	switch (cmd->cmd) {
1740 	case ETHTOOL_SRXCLSRLINS:
1741 		ret = iavf_add_fdir_ethtool(adapter, cmd);
1742 		break;
1743 	case ETHTOOL_SRXCLSRLDEL:
1744 		ret = iavf_del_fdir_ethtool(adapter, cmd);
1745 		break;
1746 	case ETHTOOL_SRXFH:
1747 		ret = iavf_set_adv_rss_hash_opt(adapter, cmd);
1748 		break;
1749 	default:
1750 		break;
1751 	}
1752 
1753 	return ret;
1754 }
1755 
1756 /**
1757  * iavf_get_rxnfc - command to get RX flow classification rules
1758  * @netdev: network interface device structure
1759  * @cmd: ethtool rxnfc command
1760  * @rule_locs: pointer to store rule locations
1761  *
1762  * Returns Success if the command is supported.
1763  **/
1764 static int iavf_get_rxnfc(struct net_device *netdev, struct ethtool_rxnfc *cmd,
1765 			  u32 *rule_locs)
1766 {
1767 	struct iavf_adapter *adapter = netdev_priv(netdev);
1768 	int ret = -EOPNOTSUPP;
1769 
1770 	switch (cmd->cmd) {
1771 	case ETHTOOL_GRXRINGS:
1772 		cmd->data = adapter->num_active_queues;
1773 		ret = 0;
1774 		break;
1775 	case ETHTOOL_GRXCLSRLCNT:
1776 		if (!FDIR_FLTR_SUPPORT(adapter))
1777 			break;
1778 		cmd->rule_cnt = adapter->fdir_active_fltr;
1779 		cmd->data = IAVF_MAX_FDIR_FILTERS;
1780 		ret = 0;
1781 		break;
1782 	case ETHTOOL_GRXCLSRULE:
1783 		ret = iavf_get_ethtool_fdir_entry(adapter, cmd);
1784 		break;
1785 	case ETHTOOL_GRXCLSRLALL:
1786 		ret = iavf_get_fdir_fltr_ids(adapter, cmd, (u32 *)rule_locs);
1787 		break;
1788 	case ETHTOOL_GRXFH:
1789 		ret = iavf_get_adv_rss_hash_opt(adapter, cmd);
1790 		break;
1791 	default:
1792 		break;
1793 	}
1794 
1795 	return ret;
1796 }
1797 /**
1798  * iavf_get_channels: get the number of channels supported by the device
1799  * @netdev: network interface device structure
1800  * @ch: channel information structure
1801  *
1802  * For the purposes of our device, we only use combined channels, i.e. a tx/rx
1803  * queue pair. Report one extra channel to match our "other" MSI-X vector.
1804  **/
1805 static void iavf_get_channels(struct net_device *netdev,
1806 			      struct ethtool_channels *ch)
1807 {
1808 	struct iavf_adapter *adapter = netdev_priv(netdev);
1809 
1810 	/* Report maximum channels */
1811 	ch->max_combined = adapter->vsi_res->num_queue_pairs;
1812 
1813 	ch->max_other = NONQ_VECS;
1814 	ch->other_count = NONQ_VECS;
1815 
1816 	ch->combined_count = adapter->num_active_queues;
1817 }
1818 
1819 /**
1820  * iavf_set_channels: set the new channel count
1821  * @netdev: network interface device structure
1822  * @ch: channel information structure
1823  *
1824  * Negotiate a new number of channels with the PF then do a reset.  During
1825  * reset we'll realloc queues and fix the RSS table.  Returns 0 on success,
1826  * negative on failure.
1827  **/
1828 static int iavf_set_channels(struct net_device *netdev,
1829 			     struct ethtool_channels *ch)
1830 {
1831 	struct iavf_adapter *adapter = netdev_priv(netdev);
1832 	u32 num_req = ch->combined_count;
1833 	int i;
1834 
1835 	if ((adapter->vf_res->vf_cap_flags & VIRTCHNL_VF_OFFLOAD_ADQ) &&
1836 	    adapter->num_tc) {
1837 		dev_info(&adapter->pdev->dev, "Cannot set channels since ADq is enabled.\n");
1838 		return -EINVAL;
1839 	}
1840 
1841 	/* All of these should have already been checked by ethtool before this
1842 	 * even gets to us, but just to be sure.
1843 	 */
1844 	if (num_req == 0 || num_req > adapter->vsi_res->num_queue_pairs)
1845 		return -EINVAL;
1846 
1847 	if (num_req == adapter->num_active_queues)
1848 		return 0;
1849 
1850 	if (ch->rx_count || ch->tx_count || ch->other_count != NONQ_VECS)
1851 		return -EINVAL;
1852 
1853 	adapter->num_req_queues = num_req;
1854 	adapter->flags |= IAVF_FLAG_REINIT_ITR_NEEDED;
1855 	iavf_schedule_reset(adapter);
1856 
1857 	/* wait for the reset is done */
1858 	for (i = 0; i < IAVF_RESET_WAIT_COMPLETE_COUNT; i++) {
1859 		msleep(IAVF_RESET_WAIT_MS);
1860 		if (adapter->flags & IAVF_FLAG_RESET_PENDING)
1861 			continue;
1862 		break;
1863 	}
1864 	if (i == IAVF_RESET_WAIT_COMPLETE_COUNT) {
1865 		adapter->flags &= ~IAVF_FLAG_REINIT_ITR_NEEDED;
1866 		adapter->num_active_queues = num_req;
1867 		return -EOPNOTSUPP;
1868 	}
1869 
1870 	return 0;
1871 }
1872 
1873 /**
1874  * iavf_get_rxfh_key_size - get the RSS hash key size
1875  * @netdev: network interface device structure
1876  *
1877  * Returns the table size.
1878  **/
1879 static u32 iavf_get_rxfh_key_size(struct net_device *netdev)
1880 {
1881 	struct iavf_adapter *adapter = netdev_priv(netdev);
1882 
1883 	return adapter->rss_key_size;
1884 }
1885 
1886 /**
1887  * iavf_get_rxfh_indir_size - get the rx flow hash indirection table size
1888  * @netdev: network interface device structure
1889  *
1890  * Returns the table size.
1891  **/
1892 static u32 iavf_get_rxfh_indir_size(struct net_device *netdev)
1893 {
1894 	struct iavf_adapter *adapter = netdev_priv(netdev);
1895 
1896 	return adapter->rss_lut_size;
1897 }
1898 
1899 /**
1900  * iavf_get_rxfh - get the rx flow hash indirection table
1901  * @netdev: network interface device structure
1902  * @indir: indirection table
1903  * @key: hash key
1904  * @hfunc: hash function in use
1905  *
1906  * Reads the indirection table directly from the hardware. Always returns 0.
1907  **/
1908 static int iavf_get_rxfh(struct net_device *netdev, u32 *indir, u8 *key,
1909 			 u8 *hfunc)
1910 {
1911 	struct iavf_adapter *adapter = netdev_priv(netdev);
1912 	u16 i;
1913 
1914 	if (hfunc)
1915 		*hfunc = ETH_RSS_HASH_TOP;
1916 	if (key)
1917 		memcpy(key, adapter->rss_key, adapter->rss_key_size);
1918 
1919 	if (indir)
1920 		/* Each 32 bits pointed by 'indir' is stored with a lut entry */
1921 		for (i = 0; i < adapter->rss_lut_size; i++)
1922 			indir[i] = (u32)adapter->rss_lut[i];
1923 
1924 	return 0;
1925 }
1926 
1927 /**
1928  * iavf_set_rxfh - set the rx flow hash indirection table
1929  * @netdev: network interface device structure
1930  * @indir: indirection table
1931  * @key: hash key
1932  * @hfunc: hash function to use
1933  *
1934  * Returns -EINVAL if the table specifies an invalid queue id, otherwise
1935  * returns 0 after programming the table.
1936  **/
1937 static int iavf_set_rxfh(struct net_device *netdev, const u32 *indir,
1938 			 const u8 *key, const u8 hfunc)
1939 {
1940 	struct iavf_adapter *adapter = netdev_priv(netdev);
1941 	u16 i;
1942 
1943 	/* Only support toeplitz hash function */
1944 	if (hfunc != ETH_RSS_HASH_NO_CHANGE && hfunc != ETH_RSS_HASH_TOP)
1945 		return -EOPNOTSUPP;
1946 
1947 	if (!key && !indir)
1948 		return 0;
1949 
1950 	if (key)
1951 		memcpy(adapter->rss_key, key, adapter->rss_key_size);
1952 
1953 	if (indir) {
1954 		/* Each 32 bits pointed by 'indir' is stored with a lut entry */
1955 		for (i = 0; i < adapter->rss_lut_size; i++)
1956 			adapter->rss_lut[i] = (u8)(indir[i]);
1957 	}
1958 
1959 	return iavf_config_rss(adapter);
1960 }
1961 
1962 static const struct ethtool_ops iavf_ethtool_ops = {
1963 	.supported_coalesce_params = ETHTOOL_COALESCE_USECS |
1964 				     ETHTOOL_COALESCE_USE_ADAPTIVE,
1965 	.get_drvinfo		= iavf_get_drvinfo,
1966 	.get_link		= ethtool_op_get_link,
1967 	.get_ringparam		= iavf_get_ringparam,
1968 	.set_ringparam		= iavf_set_ringparam,
1969 	.get_strings		= iavf_get_strings,
1970 	.get_ethtool_stats	= iavf_get_ethtool_stats,
1971 	.get_sset_count		= iavf_get_sset_count,
1972 	.get_priv_flags		= iavf_get_priv_flags,
1973 	.set_priv_flags		= iavf_set_priv_flags,
1974 	.get_msglevel		= iavf_get_msglevel,
1975 	.set_msglevel		= iavf_set_msglevel,
1976 	.get_coalesce		= iavf_get_coalesce,
1977 	.set_coalesce		= iavf_set_coalesce,
1978 	.get_per_queue_coalesce = iavf_get_per_queue_coalesce,
1979 	.set_per_queue_coalesce = iavf_set_per_queue_coalesce,
1980 	.set_rxnfc		= iavf_set_rxnfc,
1981 	.get_rxnfc		= iavf_get_rxnfc,
1982 	.get_rxfh_indir_size	= iavf_get_rxfh_indir_size,
1983 	.get_rxfh		= iavf_get_rxfh,
1984 	.set_rxfh		= iavf_set_rxfh,
1985 	.get_channels		= iavf_get_channels,
1986 	.set_channels		= iavf_set_channels,
1987 	.get_rxfh_key_size	= iavf_get_rxfh_key_size,
1988 	.get_link_ksettings	= iavf_get_link_ksettings,
1989 };
1990 
1991 /**
1992  * iavf_set_ethtool_ops - Initialize ethtool ops struct
1993  * @netdev: network interface device structure
1994  *
1995  * Sets ethtool ops struct in our netdev so that ethtool can call
1996  * our functions.
1997  **/
1998 void iavf_set_ethtool_ops(struct net_device *netdev)
1999 {
2000 	netdev->ethtool_ops = &iavf_ethtool_ops;
2001 }
2002