drivers/net/ethernet/intel/ixgbevf/ethtool.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright(c) 1999 - 2018 Intel Corporation. */
   3
   4 /* ethtool support for ixgbevf */
   5
   6 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
   7
   8 #include <linux/types.h>
   9 #include <linux/module.h>
  10 #include <linux/slab.h>
  11 #include <linux/pci.h>
  12 #include <linux/netdevice.h>
  13 #include <linux/ethtool.h>
  14 #include <linux/vmalloc.h>
  15 #include <linux/if_vlan.h>
  16 #include <linux/uaccess.h>
  17
  18 #include "ixgbevf.h"
  19
  20 #define IXGBE_ALL_RAR_ENTRIES 16
  21
  22 enum {NETDEV_STATS, IXGBEVF_STATS};
  23
  24 struct ixgbe_stats {
  25         char stat_string[ETH_GSTRING_LEN];
  26         int type;
  27         int sizeof_stat;
  28         int stat_offset;
  29 };
  30
  31 #define IXGBEVF_STAT(_name, _stat) { \
  32         .stat_string = _name, \
  33         .type = IXGBEVF_STATS, \
  34         .sizeof_stat = FIELD_SIZEOF(struct ixgbevf_adapter, _stat), \
  35         .stat_offset = offsetof(struct ixgbevf_adapter, _stat) \
  36 }
  37
  38 #define IXGBEVF_NETDEV_STAT(_net_stat) { \
  39         .stat_string = #_net_stat, \
  40         .type = NETDEV_STATS, \
  41         .sizeof_stat = FIELD_SIZEOF(struct net_device_stats, _net_stat), \
  42         .stat_offset = offsetof(struct net_device_stats, _net_stat) \
  43 }
  44
  45 static struct ixgbe_stats ixgbevf_gstrings_stats[] = {
  46         IXGBEVF_NETDEV_STAT(rx_packets),
  47         IXGBEVF_NETDEV_STAT(tx_packets),
  48         IXGBEVF_NETDEV_STAT(rx_bytes),
  49         IXGBEVF_NETDEV_STAT(tx_bytes),
  50         IXGBEVF_STAT("tx_busy", tx_busy),
  51         IXGBEVF_STAT("tx_restart_queue", restart_queue),
  52         IXGBEVF_STAT("tx_timeout_count", tx_timeout_count),
  53         IXGBEVF_NETDEV_STAT(multicast),
  54         IXGBEVF_STAT("rx_csum_offload_errors", hw_csum_rx_error),
  55         IXGBEVF_STAT("alloc_rx_page", alloc_rx_page),
  56         IXGBEVF_STAT("alloc_rx_page_failed", alloc_rx_page_failed),
  57         IXGBEVF_STAT("alloc_rx_buff_failed", alloc_rx_buff_failed),
  58         IXGBEVF_STAT("tx_ipsec", tx_ipsec),
  59         IXGBEVF_STAT("rx_ipsec", rx_ipsec),
  60 };
  61
  62 #define IXGBEVF_QUEUE_STATS_LEN ( \
  63         (((struct ixgbevf_adapter *)netdev_priv(netdev))->num_tx_queues + \
  64          ((struct ixgbevf_adapter *)netdev_priv(netdev))->num_xdp_queues + \
  65          ((struct ixgbevf_adapter *)netdev_priv(netdev))->num_rx_queues) * \
  66          (sizeof(struct ixgbevf_stats) / sizeof(u64)))
  67 #define IXGBEVF_GLOBAL_STATS_LEN ARRAY_SIZE(ixgbevf_gstrings_stats)
  68
  69 #define IXGBEVF_STATS_LEN (IXGBEVF_GLOBAL_STATS_LEN + IXGBEVF_QUEUE_STATS_LEN)
  70 static const char ixgbe_gstrings_test[][ETH_GSTRING_LEN] = {
  71         "Register test  (offline)",
  72         "Link test   (on/offline)"
  73 };
  74
  75 #define IXGBEVF_TEST_LEN (sizeof(ixgbe_gstrings_test) / ETH_GSTRING_LEN)
  76
  77 static const char ixgbevf_priv_flags_strings[][ETH_GSTRING_LEN] = {
  78 #define IXGBEVF_PRIV_FLAGS_LEGACY_RX    BIT(0)
  79         "legacy-rx",
  80 };
  81
  82 #define IXGBEVF_PRIV_FLAGS_STR_LEN ARRAY_SIZE(ixgbevf_priv_flags_strings)
  83
  84 static int ixgbevf_get_link_ksettings(struct net_device *netdev,
  85                                       struct ethtool_link_ksettings *cmd)
  86 {
  87         struct ixgbevf_adapter *adapter = netdev_priv(netdev);
  88         struct ixgbe_hw *hw = &adapter->hw;
  89         u32 link_speed = 0;
  90         bool link_up;
  91
  92         ethtool_link_ksettings_zero_link_mode(cmd, supported);
  93         ethtool_link_ksettings_add_link_mode(cmd, supported, 10000baseT_Full);
  94         cmd->base.autoneg = AUTONEG_DISABLE;
  95         cmd->base.port = -1;
  96
  97         hw->mac.get_link_status = 1;
  98         hw->mac.ops.check_link(hw, &link_speed, &link_up, false);
  99
 100         if (link_up) {
 101                 __u32 speed = SPEED_10000;
 102
 103                 switch (link_speed) {
 104                 case IXGBE_LINK_SPEED_10GB_FULL:
 105                         speed = SPEED_10000;
 106                         break;
 107                 case IXGBE_LINK_SPEED_1GB_FULL:
 108                         speed = SPEED_1000;
 109                         break;
 110                 case IXGBE_LINK_SPEED_100_FULL:
 111                         speed = SPEED_100;
 112                         break;
 113                 }
 114
 115                 cmd->base.speed = speed;
 116                 cmd->base.duplex = DUPLEX_FULL;
 117         } else {
 118                 cmd->base.speed = SPEED_UNKNOWN;
 119                 cmd->base.duplex = DUPLEX_UNKNOWN;
 120         }
 121
 122         return 0;
 123 }
 124
 125 static u32 ixgbevf_get_msglevel(struct net_device *netdev)
 126 {
 127         struct ixgbevf_adapter *adapter = netdev_priv(netdev);
 128
 129         return adapter->msg_enable;
 130 }
 131
 132 static void ixgbevf_set_msglevel(struct net_device *netdev, u32 data)
 133 {
 134         struct ixgbevf_adapter *adapter = netdev_priv(netdev);
 135
 136         adapter->msg_enable = data;
 137 }
 138
 139 #define IXGBE_GET_STAT(_A_, _R_) (_A_->stats._R_)
 140
 141 static int ixgbevf_get_regs_len(struct net_device *netdev)
 142 {
 143 #define IXGBE_REGS_LEN 45
 144         return IXGBE_REGS_LEN * sizeof(u32);
 145 }
 146
 147 static void ixgbevf_get_regs(struct net_device *netdev,
 148                              struct ethtool_regs *regs,
 149                              void *p)
 150 {
 151         struct ixgbevf_adapter *adapter = netdev_priv(netdev);
 152         struct ixgbe_hw *hw = &adapter->hw;
 153         u32 *regs_buff = p;
 154         u32 regs_len = ixgbevf_get_regs_len(netdev);
 155         u8 i;
 156
 157         memset(p, 0, regs_len);
 158
 159         /* generate a number suitable for ethtool's register version */
 160         regs->version = (1u << 24) | (hw->revision_id << 16) | hw->device_id;
 161
 162         /* General Registers */
 163         regs_buff[0] = IXGBE_READ_REG(hw, IXGBE_VFCTRL);
 164         regs_buff[1] = IXGBE_READ_REG(hw, IXGBE_VFSTATUS);
 165         regs_buff[2] = IXGBE_READ_REG(hw, IXGBE_VFLINKS);
 166         regs_buff[3] = IXGBE_READ_REG(hw, IXGBE_VFRXMEMWRAP);
 167         regs_buff[4] = IXGBE_READ_REG(hw, IXGBE_VFFRTIMER);
 168
 169         /* Interrupt */
 170         /* don't read EICR because it can clear interrupt causes, instead
 171          * read EICS which is a shadow but doesn't clear EICR
 172          */
 173         regs_buff[5] = IXGBE_READ_REG(hw, IXGBE_VTEICS);
 174         regs_buff[6] = IXGBE_READ_REG(hw, IXGBE_VTEICS);
 175         regs_buff[7] = IXGBE_READ_REG(hw, IXGBE_VTEIMS);
 176         regs_buff[8] = IXGBE_READ_REG(hw, IXGBE_VTEIMC);
 177         regs_buff[9] = IXGBE_READ_REG(hw, IXGBE_VTEIAC);
 178         regs_buff[10] = IXGBE_READ_REG(hw, IXGBE_VTEIAM);
 179         regs_buff[11] = IXGBE_READ_REG(hw, IXGBE_VTEITR(0));
 180         regs_buff[12] = IXGBE_READ_REG(hw, IXGBE_VTIVAR(0));
 181         regs_buff[13] = IXGBE_READ_REG(hw, IXGBE_VTIVAR_MISC);
 182
 183         /* Receive DMA */
 184         for (i = 0; i < 2; i++)
 185                 regs_buff[14 + i] = IXGBE_READ_REG(hw, IXGBE_VFRDBAL(i));
 186         for (i = 0; i < 2; i++)
 187                 regs_buff[16 + i] = IXGBE_READ_REG(hw, IXGBE_VFRDBAH(i));
 188         for (i = 0; i < 2; i++)
 189                 regs_buff[18 + i] = IXGBE_READ_REG(hw, IXGBE_VFRDLEN(i));
 190         for (i = 0; i < 2; i++)
 191                 regs_buff[20 + i] = IXGBE_READ_REG(hw, IXGBE_VFRDH(i));
 192         for (i = 0; i < 2; i++)
 193                 regs_buff[22 + i] = IXGBE_READ_REG(hw, IXGBE_VFRDT(i));
 194         for (i = 0; i < 2; i++)
 195                 regs_buff[24 + i] = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(i));
 196         for (i = 0; i < 2; i++)
 197                 regs_buff[26 + i] = IXGBE_READ_REG(hw, IXGBE_VFSRRCTL(i));
 198
 199         /* Receive */
 200         regs_buff[28] = IXGBE_READ_REG(hw, IXGBE_VFPSRTYPE);
 201
 202         /* Transmit */
 203         for (i = 0; i < 2; i++)
 204                 regs_buff[29 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDBAL(i));
 205         for (i = 0; i < 2; i++)
 206                 regs_buff[31 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDBAH(i));
 207         for (i = 0; i < 2; i++)
 208                 regs_buff[33 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDLEN(i));
 209         for (i = 0; i < 2; i++)
 210                 regs_buff[35 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDH(i));
 211         for (i = 0; i < 2; i++)
 212                 regs_buff[37 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDT(i));
 213         for (i = 0; i < 2; i++)
 214                 regs_buff[39 + i] = IXGBE_READ_REG(hw, IXGBE_VFTXDCTL(i));
 215         for (i = 0; i < 2; i++)
 216                 regs_buff[41 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDWBAL(i));
 217         for (i = 0; i < 2; i++)
 218                 regs_buff[43 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDWBAH(i));
 219 }
 220
 221 static void ixgbevf_get_drvinfo(struct net_device *netdev,
 222                                 struct ethtool_drvinfo *drvinfo)
 223 {
 224         struct ixgbevf_adapter *adapter = netdev_priv(netdev);
 225
 226         strlcpy(drvinfo->driver, ixgbevf_driver_name, sizeof(drvinfo->driver));
 227         strlcpy(drvinfo->version, ixgbevf_driver_version,
 228                 sizeof(drvinfo->version));
 229         strlcpy(drvinfo->bus_info, pci_name(adapter->pdev),
 230                 sizeof(drvinfo->bus_info));
 231
 232         drvinfo->n_priv_flags = IXGBEVF_PRIV_FLAGS_STR_LEN;
 233 }
 234
 235 static void ixgbevf_get_ringparam(struct net_device *netdev,
 236                                   struct ethtool_ringparam *ring)
 237 {
 238         struct ixgbevf_adapter *adapter = netdev_priv(netdev);
 239
 240         ring->rx_max_pending = IXGBEVF_MAX_RXD;
 241         ring->tx_max_pending = IXGBEVF_MAX_TXD;
 242         ring->rx_pending = adapter->rx_ring_count;
 243         ring->tx_pending = adapter->tx_ring_count;
 244 }
 245
 246 static int ixgbevf_set_ringparam(struct net_device *netdev,
 247                                  struct ethtool_ringparam *ring)
 248 {
 249         struct ixgbevf_adapter *adapter = netdev_priv(netdev);
 250         struct ixgbevf_ring *tx_ring = NULL, *rx_ring = NULL;
 251         u32 new_rx_count, new_tx_count;
 252         int i, j, err = 0;
 253
 254         if ((ring->rx_mini_pending) || (ring->rx_jumbo_pending))
 255                 return -EINVAL;
 256
 257         new_tx_count = max_t(u32, ring->tx_pending, IXGBEVF_MIN_TXD);
 258         new_tx_count = min_t(u32, new_tx_count, IXGBEVF_MAX_TXD);
 259         new_tx_count = ALIGN(new_tx_count, IXGBE_REQ_TX_DESCRIPTOR_MULTIPLE);
 260
 261         new_rx_count = max_t(u32, ring->rx_pending, IXGBEVF_MIN_RXD);
 262         new_rx_count = min_t(u32, new_rx_count, IXGBEVF_MAX_RXD);
 263         new_rx_count = ALIGN(new_rx_count, IXGBE_REQ_RX_DESCRIPTOR_MULTIPLE);
 264
 265         /* if nothing to do return success */
 266         if ((new_tx_count == adapter->tx_ring_count) &&
 267             (new_rx_count == adapter->rx_ring_count))
 268                 return 0;
 269
 270         while (test_and_set_bit(__IXGBEVF_RESETTING, &adapter->state))
 271                 usleep_range(1000, 2000);
 272
 273         if (!netif_running(adapter->netdev)) {
 274                 for (i = 0; i < adapter->num_tx_queues; i++)
 275                         adapter->tx_ring[i]->count = new_tx_count;
 276                 for (i = 0; i < adapter->num_xdp_queues; i++)
 277                         adapter->xdp_ring[i]->count = new_tx_count;
 278                 for (i = 0; i < adapter->num_rx_queues; i++)
 279                         adapter->rx_ring[i]->count = new_rx_count;
 280                 adapter->tx_ring_count = new_tx_count;
 281                 adapter->xdp_ring_count = new_tx_count;
 282                 adapter->rx_ring_count = new_rx_count;
 283                 goto clear_reset;
 284         }
 285
 286         if (new_tx_count != adapter->tx_ring_count) {
 287                 tx_ring = vmalloc(array_size(sizeof(*tx_ring),
 288                                              adapter->num_tx_queues +
 289                                                 adapter->num_xdp_queues));
 290                 if (!tx_ring) {
 291                         err = -ENOMEM;
 292                         goto clear_reset;
 293                 }
 294
 295                 for (i = 0; i < adapter->num_tx_queues; i++) {
 296                         /* clone ring and setup updated count */
 297                         tx_ring[i] = *adapter->tx_ring[i];
 298                         tx_ring[i].count = new_tx_count;
 299                         err = ixgbevf_setup_tx_resources(&tx_ring[i]);
 300                         if (err) {
 301                                 while (i) {
 302                                         i--;
 303                                         ixgbevf_free_tx_resources(&tx_ring[i]);
 304                                 }
 305
 306                                 vfree(tx_ring);
 307                                 tx_ring = NULL;
 308
 309                                 goto clear_reset;
 310                         }
 311                 }
 312
 313                 for (j = 0; j < adapter->num_xdp_queues; i++, j++) {
 314                         /* clone ring and setup updated count */
 315                         tx_ring[i] = *adapter->xdp_ring[j];
 316                         tx_ring[i].count = new_tx_count;
 317                         err = ixgbevf_setup_tx_resources(&tx_ring[i]);
 318                         if (err) {
 319                                 while (i) {
 320                                         i--;
 321                                         ixgbevf_free_tx_resources(&tx_ring[i]);
 322                                 }
 323
 324                                 vfree(tx_ring);
 325                                 tx_ring = NULL;
 326
 327                                 goto clear_reset;
 328                         }
 329                 }
 330         }
 331
 332         if (new_rx_count != adapter->rx_ring_count) {
 333                 rx_ring = vmalloc(array_size(sizeof(*rx_ring),
 334                                              adapter->num_rx_queues));
 335                 if (!rx_ring) {
 336                         err = -ENOMEM;
 337                         goto clear_reset;
 338                 }
 339
 340                 for (i = 0; i < adapter->num_rx_queues; i++) {
 341                         /* clone ring and setup updated count */
 342                         rx_ring[i] = *adapter->rx_ring[i];
 343
 344                         /* Clear copied XDP RX-queue info */
 345                         memset(&rx_ring[i].xdp_rxq, 0,
 346                                sizeof(rx_ring[i].xdp_rxq));
 347
 348                         rx_ring[i].count = new_rx_count;
 349                         err = ixgbevf_setup_rx_resources(adapter, &rx_ring[i]);
 350                         if (err) {
 351                                 while (i) {
 352                                         i--;
 353                                         ixgbevf_free_rx_resources(&rx_ring[i]);
 354                                 }
 355
 356                                 vfree(rx_ring);
 357                                 rx_ring = NULL;
 358
 359                                 goto clear_reset;
 360                         }
 361                 }
 362         }
 363
 364         /* bring interface down to prepare for update */
 365         ixgbevf_down(adapter);
 366
 367         /* Tx */
 368         if (tx_ring) {
 369                 for (i = 0; i < adapter->num_tx_queues; i++) {
 370                         ixgbevf_free_tx_resources(adapter->tx_ring[i]);
 371                         *adapter->tx_ring[i] = tx_ring[i];
 372                 }
 373                 adapter->tx_ring_count = new_tx_count;
 374
 375                 for (j = 0; j < adapter->num_xdp_queues; i++, j++) {
 376                         ixgbevf_free_tx_resources(adapter->xdp_ring[j]);
 377                         *adapter->xdp_ring[j] = tx_ring[i];
 378                 }
 379                 adapter->xdp_ring_count = new_tx_count;
 380
 381                 vfree(tx_ring);
 382                 tx_ring = NULL;
 383         }
 384
 385         /* Rx */
 386         if (rx_ring) {
 387                 for (i = 0; i < adapter->num_rx_queues; i++) {
 388                         ixgbevf_free_rx_resources(adapter->rx_ring[i]);
 389                         *adapter->rx_ring[i] = rx_ring[i];
 390                 }
 391                 adapter->rx_ring_count = new_rx_count;
 392
 393                 vfree(rx_ring);
 394                 rx_ring = NULL;
 395         }
 396
 397         /* restore interface using new values */
 398         ixgbevf_up(adapter);
 399
 400 clear_reset:
 401         /* free Tx resources if Rx error is encountered */
 402         if (tx_ring) {
 403                 for (i = 0;
 404                      i < adapter->num_tx_queues + adapter->num_xdp_queues; i++)
 405                         ixgbevf_free_tx_resources(&tx_ring[i]);
 406                 vfree(tx_ring);
 407         }
 408
 409         clear_bit(__IXGBEVF_RESETTING, &adapter->state);
 410         return err;
 411 }
 412
 413 static int ixgbevf_get_sset_count(struct net_device *netdev, int stringset)
 414 {
 415         switch (stringset) {
 416         case ETH_SS_TEST:
 417                 return IXGBEVF_TEST_LEN;
 418         case ETH_SS_STATS:
 419                 return IXGBEVF_STATS_LEN;
 420         case ETH_SS_PRIV_FLAGS:
 421                 return IXGBEVF_PRIV_FLAGS_STR_LEN;
 422         default:
 423                 return -EINVAL;
 424         }
 425 }
 426
 427 static void ixgbevf_get_ethtool_stats(struct net_device *netdev,
 428                                       struct ethtool_stats *stats, u64 *data)
 429 {
 430         struct ixgbevf_adapter *adapter = netdev_priv(netdev);
 431         struct rtnl_link_stats64 temp;
 432         const struct rtnl_link_stats64 *net_stats;
 433         unsigned int start;
 434         struct ixgbevf_ring *ring;
 435         int i, j;
 436         char *p;
 437
 438         ixgbevf_update_stats(adapter);
 439         net_stats = dev_get_stats(netdev, &temp);
 440         for (i = 0; i < IXGBEVF_GLOBAL_STATS_LEN; i++) {
 441                 switch (ixgbevf_gstrings_stats[i].type) {
 442                 case NETDEV_STATS:
 443                         p = (char *)net_stats +
 444                                         ixgbevf_gstrings_stats[i].stat_offset;
 445                         break;
 446                 case IXGBEVF_STATS:
 447                         p = (char *)adapter +
 448                                         ixgbevf_gstrings_stats[i].stat_offset;
 449                         break;
 450                 default:
 451                         data[i] = 0;
 452                         continue;
 453                 }
 454
 455                 data[i] = (ixgbevf_gstrings_stats[i].sizeof_stat ==
 456                            sizeof(u64)) ? *(u64 *)p : *(u32 *)p;
 457         }
 458
 459         /* populate Tx queue data */
 460         for (j = 0; j < adapter->num_tx_queues; j++) {
 461                 ring = adapter->tx_ring[j];
 462                 if (!ring) {
 463                         data[i++] = 0;
 464                         data[i++] = 0;
 465                         continue;
 466                 }
 467
 468                 do {
 469                         start = u64_stats_fetch_begin_irq(&ring->syncp);
 470                         data[i]   = ring->stats.packets;
 471                         data[i + 1] = ring->stats.bytes;
 472                 } while (u64_stats_fetch_retry_irq(&ring->syncp, start));
 473                 i += 2;
 474         }
 475
 476         /* populate XDP queue data */
 477         for (j = 0; j < adapter->num_xdp_queues; j++) {
 478                 ring = adapter->xdp_ring[j];
 479                 if (!ring) {
 480                         data[i++] = 0;
 481                         data[i++] = 0;
 482                         continue;
 483                 }
 484
 485                 do {
 486                         start = u64_stats_fetch_begin_irq(&ring->syncp);
 487                         data[i] = ring->stats.packets;
 488                         data[i + 1] = ring->stats.bytes;
 489                 } while (u64_stats_fetch_retry_irq(&ring->syncp, start));
 490                 i += 2;
 491         }
 492
 493         /* populate Rx queue data */
 494         for (j = 0; j < adapter->num_rx_queues; j++) {
 495                 ring = adapter->rx_ring[j];
 496                 if (!ring) {
 497                         data[i++] = 0;
 498                         data[i++] = 0;
 499                         continue;
 500                 }
 501
 502                 do {
 503                         start = u64_stats_fetch_begin_irq(&ring->syncp);
 504                         data[i]   = ring->stats.packets;
 505                         data[i + 1] = ring->stats.bytes;
 506                 } while (u64_stats_fetch_retry_irq(&ring->syncp, start));
 507                 i += 2;
 508         }
 509 }
 510
 511 static void ixgbevf_get_strings(struct net_device *netdev, u32 stringset,
 512                                 u8 *data)
 513 {
 514         struct ixgbevf_adapter *adapter = netdev_priv(netdev);
 515         char *p = (char *)data;
 516         int i;
 517
 518         switch (stringset) {
 519         case ETH_SS_TEST:
 520                 memcpy(data, *ixgbe_gstrings_test,
 521                        IXGBEVF_TEST_LEN * ETH_GSTRING_LEN);
 522                 break;
 523         case ETH_SS_STATS:
 524                 for (i = 0; i < IXGBEVF_GLOBAL_STATS_LEN; i++) {
 525                         memcpy(p, ixgbevf_gstrings_stats[i].stat_string,
 526                                ETH_GSTRING_LEN);
 527                         p += ETH_GSTRING_LEN;
 528                 }
 529
 530                 for (i = 0; i < adapter->num_tx_queues; i++) {
 531                         sprintf(p, "tx_queue_%u_packets", i);
 532                         p += ETH_GSTRING_LEN;
 533                         sprintf(p, "tx_queue_%u_bytes", i);
 534                         p += ETH_GSTRING_LEN;
 535                 }
 536                 for (i = 0; i < adapter->num_xdp_queues; i++) {
 537                         sprintf(p, "xdp_queue_%u_packets", i);
 538                         p += ETH_GSTRING_LEN;
 539                         sprintf(p, "xdp_queue_%u_bytes", i);
 540                         p += ETH_GSTRING_LEN;
 541                 }
 542                 for (i = 0; i < adapter->num_rx_queues; i++) {
 543                         sprintf(p, "rx_queue_%u_packets", i);
 544                         p += ETH_GSTRING_LEN;
 545                         sprintf(p, "rx_queue_%u_bytes", i);
 546                         p += ETH_GSTRING_LEN;
 547                 }
 548                 break;
 549         case ETH_SS_PRIV_FLAGS:
 550                 memcpy(data, ixgbevf_priv_flags_strings,
 551                        IXGBEVF_PRIV_FLAGS_STR_LEN * ETH_GSTRING_LEN);
 552                 break;
 553         }
 554 }
 555
 556 static int ixgbevf_link_test(struct ixgbevf_adapter *adapter, u64 *data)
 557 {
 558         struct ixgbe_hw *hw = &adapter->hw;
 559         bool link_up;
 560         u32 link_speed = 0;
 561         *data = 0;
 562
 563         hw->mac.ops.check_link(hw, &link_speed, &link_up, true);
 564         if (!link_up)
 565                 *data = 1;
 566
 567         return *data;
 568 }
 569
 570 /* ethtool register test data */
 571 struct ixgbevf_reg_test {
 572         u16 reg;
 573         u8  array_len;
 574         u8  test_type;
 575         u32 mask;
 576         u32 write;
 577 };
 578
 579 /* In the hardware, registers are laid out either singly, in arrays
 580  * spaced 0x40 bytes apart, or in contiguous tables.  We assume
 581  * most tests take place on arrays or single registers (handled
 582  * as a single-element array) and special-case the tables.
 583  * Table tests are always pattern tests.
 584  *
 585  * We also make provision for some required setup steps by specifying
 586  * registers to be written without any read-back testing.
 587  */
 588
 589 #define PATTERN_TEST    1
 590 #define SET_READ_TEST   2
 591 #define WRITE_NO_TEST   3
 592 #define TABLE32_TEST    4
 593 #define TABLE64_TEST_LO 5
 594 #define TABLE64_TEST_HI 6
 595
 596 /* default VF register test */
 597 static const struct ixgbevf_reg_test reg_test_vf[] = {
 598         { IXGBE_VFRDBAL(0), 2, PATTERN_TEST, 0xFFFFFF80, 0xFFFFFF80 },
 599         { IXGBE_VFRDBAH(0), 2, PATTERN_TEST, 0xFFFFFFFF, 0xFFFFFFFF },
 600         { IXGBE_VFRDLEN(0), 2, PATTERN_TEST, 0x000FFF80, 0x000FFFFF },
 601         { IXGBE_VFRXDCTL(0), 2, WRITE_NO_TEST, 0, IXGBE_RXDCTL_ENABLE },
 602         { IXGBE_VFRDT(0), 2, PATTERN_TEST, 0x0000FFFF, 0x0000FFFF },
 603         { IXGBE_VFRXDCTL(0), 2, WRITE_NO_TEST, 0, 0 },
 604         { IXGBE_VFTDBAL(0), 2, PATTERN_TEST, 0xFFFFFF80, 0xFFFFFFFF },
 605         { IXGBE_VFTDBAH(0), 2, PATTERN_TEST, 0xFFFFFFFF, 0xFFFFFFFF },
 606         { IXGBE_VFTDLEN(0), 2, PATTERN_TEST, 0x000FFF80, 0x000FFF80 },
 607         { .reg = 0 }
 608 };
 609
 610 static const u32 register_test_patterns[] = {
 611         0x5A5A5A5A, 0xA5A5A5A5, 0x00000000, 0xFFFFFFFF
 612 };
 613
 614 static bool reg_pattern_test(struct ixgbevf_adapter *adapter, u64 *data,
 615                              int reg, u32 mask, u32 write)
 616 {
 617         u32 pat, val, before;
 618
 619         if (IXGBE_REMOVED(adapter->hw.hw_addr)) {
 620                 *data = 1;
 621                 return true;
 622         }
 623         for (pat = 0; pat < ARRAY_SIZE(register_test_patterns); pat++) {
 624                 before = ixgbevf_read_reg(&adapter->hw, reg);
 625                 ixgbe_write_reg(&adapter->hw, reg,
 626                                 register_test_patterns[pat] & write);
 627                 val = ixgbevf_read_reg(&adapter->hw, reg);
 628                 if (val != (register_test_patterns[pat] & write & mask)) {
 629                         hw_dbg(&adapter->hw,
 630                                "pattern test reg %04X failed: got 0x%08X expected 0x%08X\n",
 631                                reg, val,
 632                                register_test_patterns[pat] & write & mask);
 633                         *data = reg;
 634                         ixgbe_write_reg(&adapter->hw, reg, before);
 635                         return true;
 636                 }
 637                 ixgbe_write_reg(&adapter->hw, reg, before);
 638         }
 639         return false;
 640 }
 641
 642 static bool reg_set_and_check(struct ixgbevf_adapter *adapter, u64 *data,
 643                               int reg, u32 mask, u32 write)
 644 {
 645         u32 val, before;
 646
 647         if (IXGBE_REMOVED(adapter->hw.hw_addr)) {
 648                 *data = 1;
 649                 return true;
 650         }
 651         before = ixgbevf_read_reg(&adapter->hw, reg);
 652         ixgbe_write_reg(&adapter->hw, reg, write & mask);
 653         val = ixgbevf_read_reg(&adapter->hw, reg);
 654         if ((write & mask) != (val & mask)) {
 655                 pr_err("set/check reg %04X test failed: got 0x%08X expected 0x%08X\n",
 656                        reg, (val & mask), write & mask);
 657                 *data = reg;
 658                 ixgbe_write_reg(&adapter->hw, reg, before);
 659                 return true;
 660         }
 661         ixgbe_write_reg(&adapter->hw, reg, before);
 662         return false;
 663 }
 664
 665 static int ixgbevf_reg_test(struct ixgbevf_adapter *adapter, u64 *data)
 666 {
 667         const struct ixgbevf_reg_test *test;
 668         u32 i;
 669
 670         if (IXGBE_REMOVED(adapter->hw.hw_addr)) {
 671                 dev_err(&adapter->pdev->dev,
 672                         "Adapter removed - register test blocked\n");
 673                 *data = 1;
 674                 return 1;
 675         }
 676         test = reg_test_vf;
 677
 678         /* Perform the register test, looping through the test table
 679          * until we either fail or reach the null entry.
 680          */
 681         while (test->reg) {
 682                 for (i = 0; i < test->array_len; i++) {
 683                         bool b = false;
 684
 685                         switch (test->test_type) {
 686                         case PATTERN_TEST:
 687                                 b = reg_pattern_test(adapter, data,
 688                                                      test->reg + (i * 0x40),
 689                                                      test->mask,
 690                                                      test->write);
 691                                 break;
 692                         case SET_READ_TEST:
 693                                 b = reg_set_and_check(adapter, data,
 694                                                       test->reg + (i * 0x40),
 695                                                       test->mask,
 696                                                       test->write);
 697                                 break;
 698                         case WRITE_NO_TEST:
 699                                 ixgbe_write_reg(&adapter->hw,
 700                                                 test->reg + (i * 0x40),
 701                                                 test->write);
 702                                 break;
 703                         case TABLE32_TEST:
 704                                 b = reg_pattern_test(adapter, data,
 705                                                      test->reg + (i * 4),
 706                                                      test->mask,
 707                                                      test->write);
 708                                 break;
 709                         case TABLE64_TEST_LO:
 710                                 b = reg_pattern_test(adapter, data,
 711                                                      test->reg + (i * 8),
 712                                                      test->mask,
 713                                                      test->write);
 714                                 break;
 715                         case TABLE64_TEST_HI:
 716                                 b = reg_pattern_test(adapter, data,
 717                                                      test->reg + 4 + (i * 8),
 718                                                      test->mask,
 719                                                      test->write);
 720                                 break;
 721                         }
 722                         if (b)
 723                                 return 1;
 724                 }
 725                 test++;
 726         }
 727
 728         *data = 0;
 729         return *data;
 730 }
 731
 732 static void ixgbevf_diag_test(struct net_device *netdev,
 733                               struct ethtool_test *eth_test, u64 *data)
 734 {
 735         struct ixgbevf_adapter *adapter = netdev_priv(netdev);
 736         bool if_running = netif_running(netdev);
 737
 738         if (IXGBE_REMOVED(adapter->hw.hw_addr)) {
 739                 dev_err(&adapter->pdev->dev,
 740                         "Adapter removed - test blocked\n");
 741                 data[0] = 1;
 742                 data[1] = 1;
 743                 eth_test->flags |= ETH_TEST_FL_FAILED;
 744                 return;
 745         }
 746         set_bit(__IXGBEVF_TESTING, &adapter->state);
 747         if (eth_test->flags == ETH_TEST_FL_OFFLINE) {
 748                 /* Offline tests */
 749
 750                 hw_dbg(&adapter->hw, "offline testing starting\n");
 751
 752                 /* Link test performed before hardware reset so autoneg doesn't
 753                  * interfere with test result
 754                  */
 755                 if (ixgbevf_link_test(adapter, &data[1]))
 756                         eth_test->flags |= ETH_TEST_FL_FAILED;
 757
 758                 if (if_running)
 759                         /* indicate we're in test mode */
 760                         ixgbevf_close(netdev);
 761                 else
 762                         ixgbevf_reset(adapter);
 763
 764                 hw_dbg(&adapter->hw, "register testing starting\n");
 765                 if (ixgbevf_reg_test(adapter, &data[0]))
 766                         eth_test->flags |= ETH_TEST_FL_FAILED;
 767
 768                 ixgbevf_reset(adapter);
 769
 770                 clear_bit(__IXGBEVF_TESTING, &adapter->state);
 771                 if (if_running)
 772                         ixgbevf_open(netdev);
 773         } else {
 774                 hw_dbg(&adapter->hw, "online testing starting\n");
 775                 /* Online tests */
 776                 if (ixgbevf_link_test(adapter, &data[1]))
 777                         eth_test->flags |= ETH_TEST_FL_FAILED;
 778
 779                 /* Online tests aren't run; pass by default */
 780                 data[0] = 0;
 781
 782                 clear_bit(__IXGBEVF_TESTING, &adapter->state);
 783         }
 784         msleep_interruptible(4 * 1000);
 785 }
 786
 787 static int ixgbevf_nway_reset(struct net_device *netdev)
 788 {
 789         struct ixgbevf_adapter *adapter = netdev_priv(netdev);
 790
 791         if (netif_running(netdev))
 792                 ixgbevf_reinit_locked(adapter);
 793
 794         return 0;
 795 }
 796
 797 static int ixgbevf_get_coalesce(struct net_device *netdev,
 798                                 struct ethtool_coalesce *ec)
 799 {
 800         struct ixgbevf_adapter *adapter = netdev_priv(netdev);
 801
 802         /* only valid if in constant ITR mode */
 803         if (adapter->rx_itr_setting <= 1)
 804                 ec->rx_coalesce_usecs = adapter->rx_itr_setting;
 805         else
 806                 ec->rx_coalesce_usecs = adapter->rx_itr_setting >> 2;
 807
 808         /* if in mixed Tx/Rx queues per vector mode, report only Rx settings */
 809         if (adapter->q_vector[0]->tx.count && adapter->q_vector[0]->rx.count)
 810                 return 0;
 811
 812         /* only valid if in constant ITR mode */
 813         if (adapter->tx_itr_setting <= 1)
 814                 ec->tx_coalesce_usecs = adapter->tx_itr_setting;
 815         else
 816                 ec->tx_coalesce_usecs = adapter->tx_itr_setting >> 2;
 817
 818         return 0;
 819 }
 820
 821 static int ixgbevf_set_coalesce(struct net_device *netdev,
 822                                 struct ethtool_coalesce *ec)
 823 {
 824         struct ixgbevf_adapter *adapter = netdev_priv(netdev);
 825         struct ixgbevf_q_vector *q_vector;
 826         int num_vectors, i;
 827         u16 tx_itr_param, rx_itr_param;
 828
 829         /* don't accept Tx specific changes if we've got mixed RxTx vectors */
 830         if (adapter->q_vector[0]->tx.count &&
 831             adapter->q_vector[0]->rx.count && ec->tx_coalesce_usecs)
 832                 return -EINVAL;
 833
 834         if ((ec->rx_coalesce_usecs > (IXGBE_MAX_EITR >> 2)) ||
 835             (ec->tx_coalesce_usecs > (IXGBE_MAX_EITR >> 2)))
 836                 return -EINVAL;
 837
 838         if (ec->rx_coalesce_usecs > 1)
 839                 adapter->rx_itr_setting = ec->rx_coalesce_usecs << 2;
 840         else
 841                 adapter->rx_itr_setting = ec->rx_coalesce_usecs;
 842
 843         if (adapter->rx_itr_setting == 1)
 844                 rx_itr_param = IXGBE_20K_ITR;
 845         else
 846                 rx_itr_param = adapter->rx_itr_setting;
 847
 848         if (ec->tx_coalesce_usecs > 1)
 849                 adapter->tx_itr_setting = ec->tx_coalesce_usecs << 2;
 850         else
 851                 adapter->tx_itr_setting = ec->tx_coalesce_usecs;
 852
 853         if (adapter->tx_itr_setting == 1)
 854                 tx_itr_param = IXGBE_12K_ITR;
 855         else
 856                 tx_itr_param = adapter->tx_itr_setting;
 857
 858         num_vectors = adapter->num_msix_vectors - NON_Q_VECTORS;
 859
 860         for (i = 0; i < num_vectors; i++) {
 861                 q_vector = adapter->q_vector[i];
 862                 if (q_vector->tx.count && !q_vector->rx.count)
 863                         /* Tx only */
 864                         q_vector->itr = tx_itr_param;
 865                 else
 866                         /* Rx only or mixed */
 867                         q_vector->itr = rx_itr_param;
 868                 ixgbevf_write_eitr(q_vector);
 869         }
 870
 871         return 0;
 872 }
 873
 874 static int ixgbevf_get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *info,
 875                              u32 *rules __always_unused)
 876 {
 877         struct ixgbevf_adapter *adapter = netdev_priv(dev);
 878
 879         switch (info->cmd) {
 880         case ETHTOOL_GRXRINGS:
 881                 info->data = adapter->num_rx_queues;
 882                 return 0;
 883         default:
 884                 hw_dbg(&adapter->hw, "Command parameters not supported\n");
 885                 return -EOPNOTSUPP;
 886         }
 887 }
 888
 889 static u32 ixgbevf_get_rxfh_indir_size(struct net_device *netdev)
 890 {
 891         struct ixgbevf_adapter *adapter = netdev_priv(netdev);
 892
 893         if (adapter->hw.mac.type >= ixgbe_mac_X550_vf)
 894                 return IXGBEVF_X550_VFRETA_SIZE;
 895
 896         return IXGBEVF_82599_RETA_SIZE;
 897 }
 898
 899 static u32 ixgbevf_get_rxfh_key_size(struct net_device *netdev)
 900 {
 901         return IXGBEVF_RSS_HASH_KEY_SIZE;
 902 }
 903
 904 static int ixgbevf_get_rxfh(struct net_device *netdev, u32 *indir, u8 *key,
 905                             u8 *hfunc)
 906 {
 907         struct ixgbevf_adapter *adapter = netdev_priv(netdev);
 908         int err = 0;
 909
 910         if (hfunc)
 911                 *hfunc = ETH_RSS_HASH_TOP;
 912
 913         if (adapter->hw.mac.type >= ixgbe_mac_X550_vf) {
 914                 if (key)
 915                         memcpy(key, adapter->rss_key,
 916                                ixgbevf_get_rxfh_key_size(netdev));
 917
 918                 if (indir) {
 919                         int i;
 920
 921                         for (i = 0; i < IXGBEVF_X550_VFRETA_SIZE; i++)
 922                                 indir[i] = adapter->rss_indir_tbl[i];
 923                 }
 924         } else {
 925                 /* If neither indirection table nor hash key was requested
 926                  *  - just return a success avoiding taking any locks.
 927                  */
 928                 if (!indir && !key)
 929                         return 0;
 930
 931                 spin_lock_bh(&adapter->mbx_lock);
 932                 if (indir)
 933                         err = ixgbevf_get_reta_locked(&adapter->hw, indir,
 934                                                       adapter->num_rx_queues);
 935
 936                 if (!err && key)
 937                         err = ixgbevf_get_rss_key_locked(&adapter->hw, key);
 938
 939                 spin_unlock_bh(&adapter->mbx_lock);
 940         }
 941
 942         return err;
 943 }
 944
 945 static u32 ixgbevf_get_priv_flags(struct net_device *netdev)
 946 {
 947         struct ixgbevf_adapter *adapter = netdev_priv(netdev);
 948         u32 priv_flags = 0;
 949
 950         if (adapter->flags & IXGBEVF_FLAGS_LEGACY_RX)
 951                 priv_flags |= IXGBEVF_PRIV_FLAGS_LEGACY_RX;
 952
 953         return priv_flags;
 954 }
 955
 956 static int ixgbevf_set_priv_flags(struct net_device *netdev, u32 priv_flags)
 957 {
 958         struct ixgbevf_adapter *adapter = netdev_priv(netdev);
 959         unsigned int flags = adapter->flags;
 960
 961         flags &= ~IXGBEVF_FLAGS_LEGACY_RX;
 962         if (priv_flags & IXGBEVF_PRIV_FLAGS_LEGACY_RX)
 963                 flags |= IXGBEVF_FLAGS_LEGACY_RX;
 964
 965         if (flags != adapter->flags) {
 966                 adapter->flags = flags;
 967
 968                 /* reset interface to repopulate queues */
 969                 if (netif_running(netdev))
 970                         ixgbevf_reinit_locked(adapter);
 971         }
 972
 973         return 0;
 974 }
 975
 976 static const struct ethtool_ops ixgbevf_ethtool_ops = {
 977         .get_drvinfo            = ixgbevf_get_drvinfo,
 978         .get_regs_len           = ixgbevf_get_regs_len,
 979         .get_regs               = ixgbevf_get_regs,
 980         .nway_reset             = ixgbevf_nway_reset,
 981         .get_link               = ethtool_op_get_link,
 982         .get_ringparam          = ixgbevf_get_ringparam,
 983         .set_ringparam          = ixgbevf_set_ringparam,
 984         .get_msglevel           = ixgbevf_get_msglevel,
 985         .set_msglevel           = ixgbevf_set_msglevel,
 986         .self_test              = ixgbevf_diag_test,
 987         .get_sset_count         = ixgbevf_get_sset_count,
 988         .get_strings            = ixgbevf_get_strings,
 989         .get_ethtool_stats      = ixgbevf_get_ethtool_stats,
 990         .get_coalesce           = ixgbevf_get_coalesce,
 991         .set_coalesce           = ixgbevf_set_coalesce,
 992         .get_rxnfc              = ixgbevf_get_rxnfc,
 993         .get_rxfh_indir_size    = ixgbevf_get_rxfh_indir_size,
 994         .get_rxfh_key_size      = ixgbevf_get_rxfh_key_size,
 995         .get_rxfh               = ixgbevf_get_rxfh,
 996         .get_link_ksettings     = ixgbevf_get_link_ksettings,
 997         .get_priv_flags         = ixgbevf_get_priv_flags,
 998         .set_priv_flags         = ixgbevf_set_priv_flags,
 999 };
1000
1001 void ixgbevf_set_ethtool_ops(struct net_device *netdev)
1002 {
1003         netdev->ethtool_ops = &ixgbevf_ethtool_ops;
1004 }