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