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

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