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

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