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 **/
  34struct 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 */
  55static 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 */
  70static void
  71iavf_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 **/
 118static void
 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 **/
 159static void
 160iavf_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 **/
 191static 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
 224static 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 **/
 251static 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 **/
 310static 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 **/
 334static 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 **/
 370static 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 **/
 395static 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 **/
 412static 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 **/
 427static 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 **/
 443static 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 **/
 463static 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 **/
 486static 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 **/
 557static 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 **/
 598static 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 **/
 614static 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 **/
 628static 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 **/
 686static 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 **/
 728static 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 */
 744static 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 */
 757static 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 */
 798static 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 */
 840static 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 */
 852static int
 853iavf_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 */
 897static void
 898iavf_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 */
 917static int
 918iavf_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
1046release_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 */
1059static int
1060iavf_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
1086release_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 */
1100static int
1101iavf_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 */
1255static 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 */
1306static 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 */
1323static 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 */
1367static 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 */
1432static int
1433iavf_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 */
1518static int
1519iavf_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 */
1574static 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 **/
1604static 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 **/
1647static 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 **/
1670static 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 **/
1712static 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 **/
1725static 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 **/
1739static 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 **/
1769static 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
1808static 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 **/
1843void iavf_set_ethtool_ops(struct net_device *netdev)
1844{
1845	netdev->ethtool_ops = &iavf_ethtool_ops;
1846}