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