linux/drivers/net/ethernet/intel/iavf/iavf_ethtool.c
<<
>>
Prefs
   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 **/
  33struct 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 */
  54static 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 */
  69static void
  70iavf_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 **/
 117static 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 **/
 158static void
 159iavf_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 **/
 190static 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
 223static 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 */
 247struct 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
 259static 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 **/
 273static 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 **/
 332static int iavf_get_sset_count(struct net_device *netdev, int sset)
 333{
 334        if (sset == ETH_SS_STATS)
 335                return IAVF_STATS_LEN +
 336                        (IAVF_QUEUE_STATS_LEN * 2 * IAVF_MAX_REQ_QUEUES);
 337        else if (sset == ETH_SS_PRIV_FLAGS)
 338                return IAVF_PRIV_FLAGS_STR_LEN;
 339        else
 340                return -EINVAL;
 341}
 342
 343/**
 344 * iavf_get_ethtool_stats - report device statistics
 345 * @netdev: network interface device structure
 346 * @stats: ethtool statistics structure
 347 * @data: pointer to data buffer
 348 *
 349 * All statistics are added to the data buffer as an array of u64.
 350 **/
 351static void iavf_get_ethtool_stats(struct net_device *netdev,
 352                                   struct ethtool_stats *stats, u64 *data)
 353{
 354        struct iavf_adapter *adapter = netdev_priv(netdev);
 355        unsigned int i;
 356
 357        iavf_add_ethtool_stats(&data, adapter, iavf_gstrings_stats);
 358
 359        rcu_read_lock();
 360        for (i = 0; i < IAVF_MAX_REQ_QUEUES; i++) {
 361                struct iavf_ring *ring;
 362
 363                /* Avoid accessing un-allocated queues */
 364                ring = (i < adapter->num_active_queues ?
 365                        &adapter->tx_rings[i] : NULL);
 366                iavf_add_queue_stats(&data, ring);
 367
 368                /* Avoid accessing un-allocated queues */
 369                ring = (i < adapter->num_active_queues ?
 370                        &adapter->rx_rings[i] : NULL);
 371                iavf_add_queue_stats(&data, ring);
 372        }
 373        rcu_read_unlock();
 374}
 375
 376/**
 377 * iavf_get_priv_flag_strings - Get private flag strings
 378 * @netdev: network interface device structure
 379 * @data: buffer for string data
 380 *
 381 * Builds the private flags string table
 382 **/
 383static void iavf_get_priv_flag_strings(struct net_device *netdev, u8 *data)
 384{
 385        unsigned int i;
 386
 387        for (i = 0; i < IAVF_PRIV_FLAGS_STR_LEN; i++) {
 388                snprintf(data, ETH_GSTRING_LEN, "%s",
 389                         iavf_gstrings_priv_flags[i].flag_string);
 390                data += ETH_GSTRING_LEN;
 391        }
 392}
 393
 394/**
 395 * iavf_get_stat_strings - Get stat strings
 396 * @netdev: network interface device structure
 397 * @data: buffer for string data
 398 *
 399 * Builds the statistics string table
 400 **/
 401static void iavf_get_stat_strings(struct net_device *netdev, u8 *data)
 402{
 403        unsigned int i;
 404
 405        iavf_add_stat_strings(&data, iavf_gstrings_stats);
 406
 407        /* Queues are always allocated in pairs, so we just use num_tx_queues
 408         * for both Tx and Rx queues.
 409         */
 410        for (i = 0; i < netdev->num_tx_queues; i++) {
 411                iavf_add_stat_strings(&data, iavf_gstrings_queue_stats,
 412                                      "tx", i);
 413                iavf_add_stat_strings(&data, iavf_gstrings_queue_stats,
 414                                      "rx", i);
 415        }
 416}
 417
 418/**
 419 * iavf_get_strings - Get string set
 420 * @netdev: network interface device structure
 421 * @sset: id of string set
 422 * @data: buffer for string data
 423 *
 424 * Builds string tables for various string sets
 425 **/
 426static void iavf_get_strings(struct net_device *netdev, u32 sset, u8 *data)
 427{
 428        switch (sset) {
 429        case ETH_SS_STATS:
 430                iavf_get_stat_strings(netdev, data);
 431                break;
 432        case ETH_SS_PRIV_FLAGS:
 433                iavf_get_priv_flag_strings(netdev, data);
 434                break;
 435        default:
 436                break;
 437        }
 438}
 439
 440/**
 441 * iavf_get_priv_flags - report device private flags
 442 * @netdev: network interface device structure
 443 *
 444 * The get string set count and the string set should be matched for each
 445 * flag returned.  Add new strings for each flag to the iavf_gstrings_priv_flags
 446 * array.
 447 *
 448 * Returns a u32 bitmap of flags.
 449 **/
 450static u32 iavf_get_priv_flags(struct net_device *netdev)
 451{
 452        struct iavf_adapter *adapter = netdev_priv(netdev);
 453        u32 i, ret_flags = 0;
 454
 455        for (i = 0; i < IAVF_PRIV_FLAGS_STR_LEN; i++) {
 456                const struct iavf_priv_flags *priv_flags;
 457
 458                priv_flags = &iavf_gstrings_priv_flags[i];
 459
 460                if (priv_flags->flag & adapter->flags)
 461                        ret_flags |= BIT(i);
 462        }
 463
 464        return ret_flags;
 465}
 466
 467/**
 468 * iavf_set_priv_flags - set private flags
 469 * @netdev: network interface device structure
 470 * @flags: bit flags to be set
 471 **/
 472static int iavf_set_priv_flags(struct net_device *netdev, u32 flags)
 473{
 474        struct iavf_adapter *adapter = netdev_priv(netdev);
 475        u32 orig_flags, new_flags, changed_flags;
 476        u32 i;
 477
 478        orig_flags = READ_ONCE(adapter->flags);
 479        new_flags = orig_flags;
 480
 481        for (i = 0; i < IAVF_PRIV_FLAGS_STR_LEN; i++) {
 482                const struct iavf_priv_flags *priv_flags;
 483
 484                priv_flags = &iavf_gstrings_priv_flags[i];
 485
 486                if (flags & BIT(i))
 487                        new_flags |= priv_flags->flag;
 488                else
 489                        new_flags &= ~(priv_flags->flag);
 490
 491                if (priv_flags->read_only &&
 492                    ((orig_flags ^ new_flags) & ~BIT(i)))
 493                        return -EOPNOTSUPP;
 494        }
 495
 496        /* Before we finalize any flag changes, any checks which we need to
 497         * perform to determine if the new flags will be supported should go
 498         * here...
 499         */
 500
 501        /* Compare and exchange the new flags into place. If we failed, that
 502         * is if cmpxchg returns anything but the old value, this means
 503         * something else must have modified the flags variable since we
 504         * copied it. We'll just punt with an error and log something in the
 505         * message buffer.
 506         */
 507        if (cmpxchg(&adapter->flags, orig_flags, new_flags) != orig_flags) {
 508                dev_warn(&adapter->pdev->dev,
 509                         "Unable to update adapter->flags as it was modified by another thread...\n");
 510                return -EAGAIN;
 511        }
 512
 513        changed_flags = orig_flags ^ new_flags;
 514
 515        /* Process any additional changes needed as a result of flag changes.
 516         * The changed_flags value reflects the list of bits that were changed
 517         * in the code above.
 518         */
 519
 520        /* issue a reset to force legacy-rx change to take effect */
 521        if (changed_flags & IAVF_FLAG_LEGACY_RX) {
 522                if (netif_running(netdev)) {
 523                        adapter->flags |= IAVF_FLAG_RESET_NEEDED;
 524                        queue_work(iavf_wq, &adapter->reset_task);
 525                }
 526        }
 527
 528        return 0;
 529}
 530
 531/**
 532 * iavf_get_msglevel - Get debug message level
 533 * @netdev: network interface device structure
 534 *
 535 * Returns current debug message level.
 536 **/
 537static u32 iavf_get_msglevel(struct net_device *netdev)
 538{
 539        struct iavf_adapter *adapter = netdev_priv(netdev);
 540
 541        return adapter->msg_enable;
 542}
 543
 544/**
 545 * iavf_set_msglevel - Set debug message level
 546 * @netdev: network interface device structure
 547 * @data: message level
 548 *
 549 * Set current debug message level. Higher values cause the driver to
 550 * be noisier.
 551 **/
 552static void iavf_set_msglevel(struct net_device *netdev, u32 data)
 553{
 554        struct iavf_adapter *adapter = netdev_priv(netdev);
 555
 556        if (IAVF_DEBUG_USER & data)
 557                adapter->hw.debug_mask = data;
 558        adapter->msg_enable = data;
 559}
 560
 561/**
 562 * iavf_get_drvinfo - Get driver info
 563 * @netdev: network interface device structure
 564 * @drvinfo: ethool driver info structure
 565 *
 566 * Returns information about the driver and device for display to the user.
 567 **/
 568static void iavf_get_drvinfo(struct net_device *netdev,
 569                             struct ethtool_drvinfo *drvinfo)
 570{
 571        struct iavf_adapter *adapter = netdev_priv(netdev);
 572
 573        strlcpy(drvinfo->driver, iavf_driver_name, 32);
 574        strlcpy(drvinfo->fw_version, "N/A", 4);
 575        strlcpy(drvinfo->bus_info, pci_name(adapter->pdev), 32);
 576        drvinfo->n_priv_flags = IAVF_PRIV_FLAGS_STR_LEN;
 577}
 578
 579/**
 580 * iavf_get_ringparam - Get ring parameters
 581 * @netdev: network interface device structure
 582 * @ring: ethtool ringparam structure
 583 *
 584 * Returns current ring parameters. TX and RX rings are reported separately,
 585 * but the number of rings is not reported.
 586 **/
 587static void iavf_get_ringparam(struct net_device *netdev,
 588                               struct ethtool_ringparam *ring)
 589{
 590        struct iavf_adapter *adapter = netdev_priv(netdev);
 591
 592        ring->rx_max_pending = IAVF_MAX_RXD;
 593        ring->tx_max_pending = IAVF_MAX_TXD;
 594        ring->rx_pending = adapter->rx_desc_count;
 595        ring->tx_pending = adapter->tx_desc_count;
 596}
 597
 598/**
 599 * iavf_set_ringparam - Set ring parameters
 600 * @netdev: network interface device structure
 601 * @ring: ethtool ringparam structure
 602 *
 603 * Sets ring parameters. TX and RX rings are controlled separately, but the
 604 * number of rings is not specified, so all rings get the same settings.
 605 **/
 606static int iavf_set_ringparam(struct net_device *netdev,
 607                              struct ethtool_ringparam *ring)
 608{
 609        struct iavf_adapter *adapter = netdev_priv(netdev);
 610        u32 new_rx_count, new_tx_count;
 611
 612        if ((ring->rx_mini_pending) || (ring->rx_jumbo_pending))
 613                return -EINVAL;
 614
 615        new_tx_count = clamp_t(u32, ring->tx_pending,
 616                               IAVF_MIN_TXD,
 617                               IAVF_MAX_TXD);
 618        new_tx_count = ALIGN(new_tx_count, IAVF_REQ_DESCRIPTOR_MULTIPLE);
 619
 620        new_rx_count = clamp_t(u32, ring->rx_pending,
 621                               IAVF_MIN_RXD,
 622                               IAVF_MAX_RXD);
 623        new_rx_count = ALIGN(new_rx_count, IAVF_REQ_DESCRIPTOR_MULTIPLE);
 624
 625        /* if nothing to do return success */
 626        if ((new_tx_count == adapter->tx_desc_count) &&
 627            (new_rx_count == adapter->rx_desc_count))
 628                return 0;
 629
 630        adapter->tx_desc_count = new_tx_count;
 631        adapter->rx_desc_count = new_rx_count;
 632
 633        if (netif_running(netdev)) {
 634                adapter->flags |= IAVF_FLAG_RESET_NEEDED;
 635                queue_work(iavf_wq, &adapter->reset_task);
 636        }
 637
 638        return 0;
 639}
 640
 641/**
 642 * __iavf_get_coalesce - get per-queue coalesce settings
 643 * @netdev: the netdev to check
 644 * @ec: ethtool coalesce data structure
 645 * @queue: which queue to pick
 646 *
 647 * Gets the per-queue settings for coalescence. Specifically Rx and Tx usecs
 648 * are per queue. If queue is <0 then we default to queue 0 as the
 649 * representative value.
 650 **/
 651static int __iavf_get_coalesce(struct net_device *netdev,
 652                               struct ethtool_coalesce *ec, int queue)
 653{
 654        struct iavf_adapter *adapter = netdev_priv(netdev);
 655        struct iavf_vsi *vsi = &adapter->vsi;
 656        struct iavf_ring *rx_ring, *tx_ring;
 657
 658        ec->tx_max_coalesced_frames = vsi->work_limit;
 659        ec->rx_max_coalesced_frames = vsi->work_limit;
 660
 661        /* Rx and Tx usecs per queue value. If user doesn't specify the
 662         * queue, return queue 0's value to represent.
 663         */
 664        if (queue < 0)
 665                queue = 0;
 666        else if (queue >= adapter->num_active_queues)
 667                return -EINVAL;
 668
 669        rx_ring = &adapter->rx_rings[queue];
 670        tx_ring = &adapter->tx_rings[queue];
 671
 672        if (ITR_IS_DYNAMIC(rx_ring->itr_setting))
 673                ec->use_adaptive_rx_coalesce = 1;
 674
 675        if (ITR_IS_DYNAMIC(tx_ring->itr_setting))
 676                ec->use_adaptive_tx_coalesce = 1;
 677
 678        ec->rx_coalesce_usecs = rx_ring->itr_setting & ~IAVF_ITR_DYNAMIC;
 679        ec->tx_coalesce_usecs = tx_ring->itr_setting & ~IAVF_ITR_DYNAMIC;
 680
 681        return 0;
 682}
 683
 684/**
 685 * iavf_get_coalesce - Get interrupt coalescing settings
 686 * @netdev: network interface device structure
 687 * @ec: ethtool coalesce structure
 688 *
 689 * Returns current coalescing settings. This is referred to elsewhere in the
 690 * driver as Interrupt Throttle Rate, as this is how the hardware describes
 691 * this functionality. Note that if per-queue settings have been modified this
 692 * only represents the settings of queue 0.
 693 **/
 694static int iavf_get_coalesce(struct net_device *netdev,
 695                             struct ethtool_coalesce *ec)
 696{
 697        return __iavf_get_coalesce(netdev, ec, -1);
 698}
 699
 700/**
 701 * iavf_get_per_queue_coalesce - get coalesce values for specific queue
 702 * @netdev: netdev to read
 703 * @ec: coalesce settings from ethtool
 704 * @queue: the queue to read
 705 *
 706 * Read specific queue's coalesce settings.
 707 **/
 708static int iavf_get_per_queue_coalesce(struct net_device *netdev, u32 queue,
 709                                       struct ethtool_coalesce *ec)
 710{
 711        return __iavf_get_coalesce(netdev, ec, queue);
 712}
 713
 714/**
 715 * iavf_set_itr_per_queue - set ITR values for specific queue
 716 * @adapter: the VF adapter struct to set values for
 717 * @ec: coalesce settings from ethtool
 718 * @queue: the queue to modify
 719 *
 720 * Change the ITR settings for a specific queue.
 721 **/
 722static void iavf_set_itr_per_queue(struct iavf_adapter *adapter,
 723                                   struct ethtool_coalesce *ec, int queue)
 724{
 725        struct iavf_ring *rx_ring = &adapter->rx_rings[queue];
 726        struct iavf_ring *tx_ring = &adapter->tx_rings[queue];
 727        struct iavf_q_vector *q_vector;
 728
 729        rx_ring->itr_setting = ITR_REG_ALIGN(ec->rx_coalesce_usecs);
 730        tx_ring->itr_setting = ITR_REG_ALIGN(ec->tx_coalesce_usecs);
 731
 732        rx_ring->itr_setting |= IAVF_ITR_DYNAMIC;
 733        if (!ec->use_adaptive_rx_coalesce)
 734                rx_ring->itr_setting ^= IAVF_ITR_DYNAMIC;
 735
 736        tx_ring->itr_setting |= IAVF_ITR_DYNAMIC;
 737        if (!ec->use_adaptive_tx_coalesce)
 738                tx_ring->itr_setting ^= IAVF_ITR_DYNAMIC;
 739
 740        q_vector = rx_ring->q_vector;
 741        q_vector->rx.target_itr = ITR_TO_REG(rx_ring->itr_setting);
 742
 743        q_vector = tx_ring->q_vector;
 744        q_vector->tx.target_itr = ITR_TO_REG(tx_ring->itr_setting);
 745
 746        /* The interrupt handler itself will take care of programming
 747         * the Tx and Rx ITR values based on the values we have entered
 748         * into the q_vector, no need to write the values now.
 749         */
 750}
 751
 752/**
 753 * __iavf_set_coalesce - set coalesce settings for particular queue
 754 * @netdev: the netdev to change
 755 * @ec: ethtool coalesce settings
 756 * @queue: the queue to change
 757 *
 758 * Sets the coalesce settings for a particular queue.
 759 **/
 760static int __iavf_set_coalesce(struct net_device *netdev,
 761                               struct ethtool_coalesce *ec, int queue)
 762{
 763        struct iavf_adapter *adapter = netdev_priv(netdev);
 764        struct iavf_vsi *vsi = &adapter->vsi;
 765        int i;
 766
 767        if (ec->tx_max_coalesced_frames_irq || ec->rx_max_coalesced_frames_irq)
 768                vsi->work_limit = ec->tx_max_coalesced_frames_irq;
 769
 770        if (ec->rx_coalesce_usecs == 0) {
 771                if (ec->use_adaptive_rx_coalesce)
 772                        netif_info(adapter, drv, netdev, "rx-usecs=0, need to disable adaptive-rx for a complete disable\n");
 773        } else if ((ec->rx_coalesce_usecs < IAVF_MIN_ITR) ||
 774                   (ec->rx_coalesce_usecs > IAVF_MAX_ITR)) {
 775                netif_info(adapter, drv, netdev, "Invalid value, rx-usecs range is 0-8160\n");
 776                return -EINVAL;
 777        } else if (ec->tx_coalesce_usecs == 0) {
 778                if (ec->use_adaptive_tx_coalesce)
 779                        netif_info(adapter, drv, netdev, "tx-usecs=0, need to disable adaptive-tx for a complete disable\n");
 780        } else if ((ec->tx_coalesce_usecs < IAVF_MIN_ITR) ||
 781                   (ec->tx_coalesce_usecs > IAVF_MAX_ITR)) {
 782                netif_info(adapter, drv, netdev, "Invalid value, tx-usecs range is 0-8160\n");
 783                return -EINVAL;
 784        }
 785
 786        /* Rx and Tx usecs has per queue value. If user doesn't specify the
 787         * queue, apply to all queues.
 788         */
 789        if (queue < 0) {
 790                for (i = 0; i < adapter->num_active_queues; i++)
 791                        iavf_set_itr_per_queue(adapter, ec, i);
 792        } else if (queue < adapter->num_active_queues) {
 793                iavf_set_itr_per_queue(adapter, ec, queue);
 794        } else {
 795                netif_info(adapter, drv, netdev, "Invalid queue value, queue range is 0 - %d\n",
 796                           adapter->num_active_queues - 1);
 797                return -EINVAL;
 798        }
 799
 800        return 0;
 801}
 802
 803/**
 804 * iavf_set_coalesce - Set interrupt coalescing settings
 805 * @netdev: network interface device structure
 806 * @ec: ethtool coalesce structure
 807 *
 808 * Change current coalescing settings for every queue.
 809 **/
 810static int iavf_set_coalesce(struct net_device *netdev,
 811                             struct ethtool_coalesce *ec)
 812{
 813        return __iavf_set_coalesce(netdev, ec, -1);
 814}
 815
 816/**
 817 * iavf_set_per_queue_coalesce - set specific queue's coalesce settings
 818 * @netdev: the netdev to change
 819 * @ec: ethtool's coalesce settings
 820 * @queue: the queue to modify
 821 *
 822 * Modifies a specific queue's coalesce settings.
 823 */
 824static int iavf_set_per_queue_coalesce(struct net_device *netdev, u32 queue,
 825                                       struct ethtool_coalesce *ec)
 826{
 827        return __iavf_set_coalesce(netdev, ec, queue);
 828}
 829
 830/**
 831 * iavf_get_rxnfc - command to get RX flow classification rules
 832 * @netdev: network interface device structure
 833 * @cmd: ethtool rxnfc command
 834 * @rule_locs: pointer to store rule locations
 835 *
 836 * Returns Success if the command is supported.
 837 **/
 838static int iavf_get_rxnfc(struct net_device *netdev, struct ethtool_rxnfc *cmd,
 839                          u32 *rule_locs)
 840{
 841        struct iavf_adapter *adapter = netdev_priv(netdev);
 842        int ret = -EOPNOTSUPP;
 843
 844        switch (cmd->cmd) {
 845        case ETHTOOL_GRXRINGS:
 846                cmd->data = adapter->num_active_queues;
 847                ret = 0;
 848                break;
 849        case ETHTOOL_GRXFH:
 850                netdev_info(netdev,
 851                            "RSS hash info is not available to vf, use pf.\n");
 852                break;
 853        default:
 854                break;
 855        }
 856
 857        return ret;
 858}
 859/**
 860 * iavf_get_channels: get the number of channels supported by the device
 861 * @netdev: network interface device structure
 862 * @ch: channel information structure
 863 *
 864 * For the purposes of our device, we only use combined channels, i.e. a tx/rx
 865 * queue pair. Report one extra channel to match our "other" MSI-X vector.
 866 **/
 867static void iavf_get_channels(struct net_device *netdev,
 868                              struct ethtool_channels *ch)
 869{
 870        struct iavf_adapter *adapter = netdev_priv(netdev);
 871
 872        /* Report maximum channels */
 873        ch->max_combined = adapter->vsi_res->num_queue_pairs;
 874
 875        ch->max_other = NONQ_VECS;
 876        ch->other_count = NONQ_VECS;
 877
 878        ch->combined_count = adapter->num_active_queues;
 879}
 880
 881/**
 882 * iavf_set_channels: set the new channel count
 883 * @netdev: network interface device structure
 884 * @ch: channel information structure
 885 *
 886 * Negotiate a new number of channels with the PF then do a reset.  During
 887 * reset we'll realloc queues and fix the RSS table.  Returns 0 on success,
 888 * negative on failure.
 889 **/
 890static int iavf_set_channels(struct net_device *netdev,
 891                             struct ethtool_channels *ch)
 892{
 893        struct iavf_adapter *adapter = netdev_priv(netdev);
 894        u32 num_req = ch->combined_count;
 895
 896        if ((adapter->vf_res->vf_cap_flags & VIRTCHNL_VF_OFFLOAD_ADQ) &&
 897            adapter->num_tc) {
 898                dev_info(&adapter->pdev->dev, "Cannot set channels since ADq is enabled.\n");
 899                return -EINVAL;
 900        }
 901
 902        /* All of these should have already been checked by ethtool before this
 903         * even gets to us, but just to be sure.
 904         */
 905        if (num_req > adapter->vsi_res->num_queue_pairs)
 906                return -EINVAL;
 907
 908        if (num_req == adapter->num_active_queues)
 909                return 0;
 910
 911        if (ch->rx_count || ch->tx_count || ch->other_count != NONQ_VECS)
 912                return -EINVAL;
 913
 914        adapter->num_req_queues = num_req;
 915        adapter->flags |= IAVF_FLAG_REINIT_ITR_NEEDED;
 916        iavf_schedule_reset(adapter);
 917        return 0;
 918}
 919
 920/**
 921 * iavf_get_rxfh_key_size - get the RSS hash key size
 922 * @netdev: network interface device structure
 923 *
 924 * Returns the table size.
 925 **/
 926static u32 iavf_get_rxfh_key_size(struct net_device *netdev)
 927{
 928        struct iavf_adapter *adapter = netdev_priv(netdev);
 929
 930        return adapter->rss_key_size;
 931}
 932
 933/**
 934 * iavf_get_rxfh_indir_size - get the rx flow hash indirection table size
 935 * @netdev: network interface device structure
 936 *
 937 * Returns the table size.
 938 **/
 939static u32 iavf_get_rxfh_indir_size(struct net_device *netdev)
 940{
 941        struct iavf_adapter *adapter = netdev_priv(netdev);
 942
 943        return adapter->rss_lut_size;
 944}
 945
 946/**
 947 * iavf_get_rxfh - get the rx flow hash indirection table
 948 * @netdev: network interface device structure
 949 * @indir: indirection table
 950 * @key: hash key
 951 * @hfunc: hash function in use
 952 *
 953 * Reads the indirection table directly from the hardware. Always returns 0.
 954 **/
 955static int iavf_get_rxfh(struct net_device *netdev, u32 *indir, u8 *key,
 956                         u8 *hfunc)
 957{
 958        struct iavf_adapter *adapter = netdev_priv(netdev);
 959        u16 i;
 960
 961        if (hfunc)
 962                *hfunc = ETH_RSS_HASH_TOP;
 963        if (!indir)
 964                return 0;
 965
 966        memcpy(key, adapter->rss_key, adapter->rss_key_size);
 967
 968        /* Each 32 bits pointed by 'indir' is stored with a lut entry */
 969        for (i = 0; i < adapter->rss_lut_size; i++)
 970                indir[i] = (u32)adapter->rss_lut[i];
 971
 972        return 0;
 973}
 974
 975/**
 976 * iavf_set_rxfh - set the rx flow hash indirection table
 977 * @netdev: network interface device structure
 978 * @indir: indirection table
 979 * @key: hash key
 980 * @hfunc: hash function to use
 981 *
 982 * Returns -EINVAL if the table specifies an inavlid queue id, otherwise
 983 * returns 0 after programming the table.
 984 **/
 985static int iavf_set_rxfh(struct net_device *netdev, const u32 *indir,
 986                         const u8 *key, const u8 hfunc)
 987{
 988        struct iavf_adapter *adapter = netdev_priv(netdev);
 989        u16 i;
 990
 991        /* We do not allow change in unsupported parameters */
 992        if (key ||
 993            (hfunc != ETH_RSS_HASH_NO_CHANGE && hfunc != ETH_RSS_HASH_TOP))
 994                return -EOPNOTSUPP;
 995        if (!indir)
 996                return 0;
 997
 998        if (key)
 999                memcpy(adapter->rss_key, key, adapter->rss_key_size);
1000
1001        /* Each 32 bits pointed by 'indir' is stored with a lut entry */
1002        for (i = 0; i < adapter->rss_lut_size; i++)
1003                adapter->rss_lut[i] = (u8)(indir[i]);
1004
1005        return iavf_config_rss(adapter);
1006}
1007
1008static const struct ethtool_ops iavf_ethtool_ops = {
1009        .supported_coalesce_params = ETHTOOL_COALESCE_USECS |
1010                                     ETHTOOL_COALESCE_MAX_FRAMES |
1011                                     ETHTOOL_COALESCE_MAX_FRAMES_IRQ |
1012                                     ETHTOOL_COALESCE_USE_ADAPTIVE,
1013        .get_drvinfo            = iavf_get_drvinfo,
1014        .get_link               = ethtool_op_get_link,
1015        .get_ringparam          = iavf_get_ringparam,
1016        .set_ringparam          = iavf_set_ringparam,
1017        .get_strings            = iavf_get_strings,
1018        .get_ethtool_stats      = iavf_get_ethtool_stats,
1019        .get_sset_count         = iavf_get_sset_count,
1020        .get_priv_flags         = iavf_get_priv_flags,
1021        .set_priv_flags         = iavf_set_priv_flags,
1022        .get_msglevel           = iavf_get_msglevel,
1023        .set_msglevel           = iavf_set_msglevel,
1024        .get_coalesce           = iavf_get_coalesce,
1025        .set_coalesce           = iavf_set_coalesce,
1026        .get_per_queue_coalesce = iavf_get_per_queue_coalesce,
1027        .set_per_queue_coalesce = iavf_set_per_queue_coalesce,
1028        .get_rxnfc              = iavf_get_rxnfc,
1029        .get_rxfh_indir_size    = iavf_get_rxfh_indir_size,
1030        .get_rxfh               = iavf_get_rxfh,
1031        .set_rxfh               = iavf_set_rxfh,
1032        .get_channels           = iavf_get_channels,
1033        .set_channels           = iavf_set_channels,
1034        .get_rxfh_key_size      = iavf_get_rxfh_key_size,
1035        .get_link_ksettings     = iavf_get_link_ksettings,
1036};
1037
1038/**
1039 * iavf_set_ethtool_ops - Initialize ethtool ops struct
1040 * @netdev: network interface device structure
1041 *
1042 * Sets ethtool ops struct in our netdev so that ethtool can call
1043 * our functions.
1044 **/
1045void iavf_set_ethtool_ops(struct net_device *netdev)
1046{
1047        netdev->ethtool_ops = &iavf_ethtool_ops;
1048}
1049