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