drivers/net/ethernet/intel/iavf/iavf_ethtool.c

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