drivers/net/ixgbevf/ethtool.c

   1 /*******************************************************************************
   2
   3   Intel 82599 Virtual Function driver
   4   Copyright(c) 1999 - 2009 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, write to the Free Software Foundation, Inc.,
  17   51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  18
  19   The full GNU General Public License is included in this distribution in
  20   the file called "COPYING".
  21
  22   Contact Information:
  23   e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
  24   Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  25
  26 *******************************************************************************/
  27
  28 /* ethtool support for ixgbevf */
  29
  30 #include <linux/types.h>
  31 #include <linux/module.h>
  32 #include <linux/pci.h>
  33 #include <linux/netdevice.h>
  34 #include <linux/ethtool.h>
  35 #include <linux/vmalloc.h>
  36 #include <linux/if_vlan.h>
  37 #include <linux/uaccess.h>
  38
  39 #include "ixgbevf.h"
  40
  41 #define IXGBE_ALL_RAR_ENTRIES 16
  42
  43 #ifdef ETHTOOL_GSTATS
  44 struct ixgbe_stats {
  45         char stat_string[ETH_GSTRING_LEN];
  46         int sizeof_stat;
  47         int stat_offset;
  48         int base_stat_offset;
  49         int saved_reset_offset;
  50 };
  51
  52 #define IXGBEVF_STAT(m, b, r)  sizeof(((struct ixgbevf_adapter *)0)->m), \
  53                             offsetof(struct ixgbevf_adapter, m),         \
  54                             offsetof(struct ixgbevf_adapter, b),         \
  55                             offsetof(struct ixgbevf_adapter, r)
  56 static struct ixgbe_stats ixgbe_gstrings_stats[] = {
  57         {"rx_packets", IXGBEVF_STAT(stats.vfgprc, stats.base_vfgprc,
  58                                     stats.saved_reset_vfgprc)},
  59         {"tx_packets", IXGBEVF_STAT(stats.vfgptc, stats.base_vfgptc,
  60                                     stats.saved_reset_vfgptc)},
  61         {"rx_bytes", IXGBEVF_STAT(stats.vfgorc, stats.base_vfgorc,
  62                                   stats.saved_reset_vfgorc)},
  63         {"tx_bytes", IXGBEVF_STAT(stats.vfgotc, stats.base_vfgotc,
  64                                   stats.saved_reset_vfgotc)},
  65         {"tx_busy", IXGBEVF_STAT(tx_busy, zero_base, zero_base)},
  66         {"multicast", IXGBEVF_STAT(stats.vfmprc, stats.base_vfmprc,
  67                                    stats.saved_reset_vfmprc)},
  68         {"rx_csum_offload_good", IXGBEVF_STAT(hw_csum_rx_good, zero_base,
  69                                               zero_base)},
  70         {"rx_csum_offload_errors", IXGBEVF_STAT(hw_csum_rx_error, zero_base,
  71                                                 zero_base)},
  72         {"tx_csum_offload_ctxt", IXGBEVF_STAT(hw_csum_tx_good, zero_base,
  73                                               zero_base)},
  74         {"rx_header_split", IXGBEVF_STAT(rx_hdr_split, zero_base, zero_base)},
  75 };
  76
  77 #define IXGBE_QUEUE_STATS_LEN 0
  78 #define IXGBE_GLOBAL_STATS_LEN  ARRAY_SIZE(ixgbe_gstrings_stats)
  79
  80 #define IXGBEVF_STATS_LEN (IXGBE_GLOBAL_STATS_LEN + IXGBE_QUEUE_STATS_LEN)
  81 #endif /* ETHTOOL_GSTATS */
  82 #ifdef ETHTOOL_TEST
  83 static const char ixgbe_gstrings_test[][ETH_GSTRING_LEN] = {
  84         "Register test  (offline)",
  85         "Link test   (on/offline)"
  86 };
  87 #define IXGBE_TEST_LEN (sizeof(ixgbe_gstrings_test) / ETH_GSTRING_LEN)
  88 #endif /* ETHTOOL_TEST */
  89
  90 static int ixgbevf_get_settings(struct net_device *netdev,
  91                                 struct ethtool_cmd *ecmd)
  92 {
  93         struct ixgbevf_adapter *adapter = netdev_priv(netdev);
  94         struct ixgbe_hw *hw = &adapter->hw;
  95         u32 link_speed = 0;
  96         bool link_up;
  97
  98         ecmd->supported = SUPPORTED_10000baseT_Full;
  99         ecmd->autoneg = AUTONEG_DISABLE;
 100         ecmd->transceiver = XCVR_DUMMY1;
 101         ecmd->port = -1;
 102
 103         hw->mac.ops.check_link(hw, &link_speed, &link_up, false);
 104
 105         if (link_up) {
 106                 ecmd->speed = (link_speed == IXGBE_LINK_SPEED_10GB_FULL) ?
 107                                SPEED_10000 : SPEED_1000;
 108                 ecmd->duplex = DUPLEX_FULL;
 109         } else {
 110                 ecmd->speed = -1;
 111                 ecmd->duplex = -1;
 112         }
 113
 114         return 0;
 115 }
 116
 117 static u32 ixgbevf_get_rx_csum(struct net_device *netdev)
 118 {
 119         struct ixgbevf_adapter *adapter = netdev_priv(netdev);
 120         return adapter->flags & IXGBE_FLAG_RX_CSUM_ENABLED;
 121 }
 122
 123 static int ixgbevf_set_rx_csum(struct net_device *netdev, u32 data)
 124 {
 125         struct ixgbevf_adapter *adapter = netdev_priv(netdev);
 126         if (data)
 127                 adapter->flags |= IXGBE_FLAG_RX_CSUM_ENABLED;
 128         else
 129                 adapter->flags &= ~IXGBE_FLAG_RX_CSUM_ENABLED;
 130
 131         if (netif_running(netdev)) {
 132                 if (!adapter->dev_closed)
 133                         ixgbevf_reinit_locked(adapter);
 134         } else {
 135                 ixgbevf_reset(adapter);
 136         }
 137
 138         return 0;
 139 }
 140
 141 static int ixgbevf_set_tso(struct net_device *netdev, u32 data)
 142 {
 143         if (data) {
 144                 netdev->features |= NETIF_F_TSO;
 145                 netdev->features |= NETIF_F_TSO6;
 146         } else {
 147                 netif_tx_stop_all_queues(netdev);
 148                 netdev->features &= ~NETIF_F_TSO;
 149                 netdev->features &= ~NETIF_F_TSO6;
 150                 netif_tx_start_all_queues(netdev);
 151         }
 152         return 0;
 153 }
 154
 155 static u32 ixgbevf_get_msglevel(struct net_device *netdev)
 156 {
 157         struct ixgbevf_adapter *adapter = netdev_priv(netdev);
 158         return adapter->msg_enable;
 159 }
 160
 161 static void ixgbevf_set_msglevel(struct net_device *netdev, u32 data)
 162 {
 163         struct ixgbevf_adapter *adapter = netdev_priv(netdev);
 164         adapter->msg_enable = data;
 165 }
 166
 167 #define IXGBE_GET_STAT(_A_, _R_) (_A_->stats._R_)
 168
 169 static char *ixgbevf_reg_names[] = {
 170         "IXGBE_VFCTRL",
 171         "IXGBE_VFSTATUS",
 172         "IXGBE_VFLINKS",
 173         "IXGBE_VFRXMEMWRAP",
 174         "IXGBE_VFRTIMER",
 175         "IXGBE_VTEICR",
 176         "IXGBE_VTEICS",
 177         "IXGBE_VTEIMS",
 178         "IXGBE_VTEIMC",
 179         "IXGBE_VTEIAC",
 180         "IXGBE_VTEIAM",
 181         "IXGBE_VTEITR",
 182         "IXGBE_VTIVAR",
 183         "IXGBE_VTIVAR_MISC",
 184         "IXGBE_VFRDBAL0",
 185         "IXGBE_VFRDBAL1",
 186         "IXGBE_VFRDBAH0",
 187         "IXGBE_VFRDBAH1",
 188         "IXGBE_VFRDLEN0",
 189         "IXGBE_VFRDLEN1",
 190         "IXGBE_VFRDH0",
 191         "IXGBE_VFRDH1",
 192         "IXGBE_VFRDT0",
 193         "IXGBE_VFRDT1",
 194         "IXGBE_VFRXDCTL0",
 195         "IXGBE_VFRXDCTL1",
 196         "IXGBE_VFSRRCTL0",
 197         "IXGBE_VFSRRCTL1",
 198         "IXGBE_VFPSRTYPE",
 199         "IXGBE_VFTDBAL0",
 200         "IXGBE_VFTDBAL1",
 201         "IXGBE_VFTDBAH0",
 202         "IXGBE_VFTDBAH1",
 203         "IXGBE_VFTDLEN0",
 204         "IXGBE_VFTDLEN1",
 205         "IXGBE_VFTDH0",
 206         "IXGBE_VFTDH1",
 207         "IXGBE_VFTDT0",
 208         "IXGBE_VFTDT1",
 209         "IXGBE_VFTXDCTL0",
 210         "IXGBE_VFTXDCTL1",
 211         "IXGBE_VFTDWBAL0",
 212         "IXGBE_VFTDWBAL1",
 213         "IXGBE_VFTDWBAH0",
 214         "IXGBE_VFTDWBAH1"
 215 };
 216
 217
 218 static int ixgbevf_get_regs_len(struct net_device *netdev)
 219 {
 220         return (ARRAY_SIZE(ixgbevf_reg_names)) * sizeof(u32);
 221 }
 222
 223 static void ixgbevf_get_regs(struct net_device *netdev,
 224                              struct ethtool_regs *regs,
 225                              void *p)
 226 {
 227         struct ixgbevf_adapter *adapter = netdev_priv(netdev);
 228         struct ixgbe_hw *hw = &adapter->hw;
 229         u32 *regs_buff = p;
 230         u32 regs_len = ixgbevf_get_regs_len(netdev);
 231         u8 i;
 232
 233         memset(p, 0, regs_len);
 234
 235         regs->version = (1 << 24) | hw->revision_id << 16 | hw->device_id;
 236
 237         /* General Registers */
 238         regs_buff[0] = IXGBE_READ_REG(hw, IXGBE_VFCTRL);
 239         regs_buff[1] = IXGBE_READ_REG(hw, IXGBE_VFSTATUS);
 240         regs_buff[2] = IXGBE_READ_REG(hw, IXGBE_VFLINKS);
 241         regs_buff[3] = IXGBE_READ_REG(hw, IXGBE_VFRXMEMWRAP);
 242         regs_buff[4] = IXGBE_READ_REG(hw, IXGBE_VFRTIMER);
 243
 244         /* Interrupt */
 245         /* don't read EICR because it can clear interrupt causes, instead
 246          * read EICS which is a shadow but doesn't clear EICR */
 247         regs_buff[5] = IXGBE_READ_REG(hw, IXGBE_VTEICS);
 248         regs_buff[6] = IXGBE_READ_REG(hw, IXGBE_VTEICS);
 249         regs_buff[7] = IXGBE_READ_REG(hw, IXGBE_VTEIMS);
 250         regs_buff[8] = IXGBE_READ_REG(hw, IXGBE_VTEIMC);
 251         regs_buff[9] = IXGBE_READ_REG(hw, IXGBE_VTEIAC);
 252         regs_buff[10] = IXGBE_READ_REG(hw, IXGBE_VTEIAM);
 253         regs_buff[11] = IXGBE_READ_REG(hw, IXGBE_VTEITR(0));
 254         regs_buff[12] = IXGBE_READ_REG(hw, IXGBE_VTIVAR(0));
 255         regs_buff[13] = IXGBE_READ_REG(hw, IXGBE_VTIVAR_MISC);
 256
 257         /* Receive DMA */
 258         for (i = 0; i < 2; i++)
 259                 regs_buff[14 + i] = IXGBE_READ_REG(hw, IXGBE_VFRDBAL(i));
 260         for (i = 0; i < 2; i++)
 261                 regs_buff[16 + i] = IXGBE_READ_REG(hw, IXGBE_VFRDBAH(i));
 262         for (i = 0; i < 2; i++)
 263                 regs_buff[18 + i] = IXGBE_READ_REG(hw, IXGBE_VFRDLEN(i));
 264         for (i = 0; i < 2; i++)
 265                 regs_buff[20 + i] = IXGBE_READ_REG(hw, IXGBE_VFRDH(i));
 266         for (i = 0; i < 2; i++)
 267                 regs_buff[22 + i] = IXGBE_READ_REG(hw, IXGBE_VFRDT(i));
 268         for (i = 0; i < 2; i++)
 269                 regs_buff[24 + i] = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(i));
 270         for (i = 0; i < 2; i++)
 271                 regs_buff[26 + i] = IXGBE_READ_REG(hw, IXGBE_VFSRRCTL(i));
 272
 273         /* Receive */
 274         regs_buff[28] = IXGBE_READ_REG(hw, IXGBE_VFPSRTYPE);
 275
 276         /* Transmit */
 277         for (i = 0; i < 2; i++)
 278                 regs_buff[29 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDBAL(i));
 279         for (i = 0; i < 2; i++)
 280                 regs_buff[31 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDBAH(i));
 281         for (i = 0; i < 2; i++)
 282                 regs_buff[33 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDLEN(i));
 283         for (i = 0; i < 2; i++)
 284                 regs_buff[35 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDH(i));
 285         for (i = 0; i < 2; i++)
 286                 regs_buff[37 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDT(i));
 287         for (i = 0; i < 2; i++)
 288                 regs_buff[39 + i] = IXGBE_READ_REG(hw, IXGBE_VFTXDCTL(i));
 289         for (i = 0; i < 2; i++)
 290                 regs_buff[41 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDWBAL(i));
 291         for (i = 0; i < 2; i++)
 292                 regs_buff[43 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDWBAH(i));
 293
 294         for (i = 0; i < ARRAY_SIZE(ixgbevf_reg_names); i++)
 295                 hw_dbg(hw, "%s\t%8.8x\n", ixgbevf_reg_names[i], regs_buff[i]);
 296 }
 297
 298 static void ixgbevf_get_drvinfo(struct net_device *netdev,
 299                                 struct ethtool_drvinfo *drvinfo)
 300 {
 301         struct ixgbevf_adapter *adapter = netdev_priv(netdev);
 302
 303         strlcpy(drvinfo->driver, ixgbevf_driver_name, 32);
 304         strlcpy(drvinfo->version, ixgbevf_driver_version, 32);
 305
 306         strlcpy(drvinfo->fw_version, "N/A", 4);
 307         strlcpy(drvinfo->bus_info, pci_name(adapter->pdev), 32);
 308 }
 309
 310 static void ixgbevf_get_ringparam(struct net_device *netdev,
 311                                   struct ethtool_ringparam *ring)
 312 {
 313         struct ixgbevf_adapter *adapter = netdev_priv(netdev);
 314         struct ixgbevf_ring *tx_ring = adapter->tx_ring;
 315         struct ixgbevf_ring *rx_ring = adapter->rx_ring;
 316
 317         ring->rx_max_pending = IXGBEVF_MAX_RXD;
 318         ring->tx_max_pending = IXGBEVF_MAX_TXD;
 319         ring->rx_mini_max_pending = 0;
 320         ring->rx_jumbo_max_pending = 0;
 321         ring->rx_pending = rx_ring->count;
 322         ring->tx_pending = tx_ring->count;
 323         ring->rx_mini_pending = 0;
 324         ring->rx_jumbo_pending = 0;
 325 }
 326
 327 static int ixgbevf_set_ringparam(struct net_device *netdev,
 328                                  struct ethtool_ringparam *ring)
 329 {
 330         struct ixgbevf_adapter *adapter = netdev_priv(netdev);
 331         struct ixgbevf_ring *tx_ring = NULL, *rx_ring = NULL;
 332         int i, err;
 333         u32 new_rx_count, new_tx_count;
 334         bool need_tx_update = false;
 335         bool need_rx_update = false;
 336
 337         if ((ring->rx_mini_pending) || (ring->rx_jumbo_pending))
 338                 return -EINVAL;
 339
 340         new_rx_count = max(ring->rx_pending, (u32)IXGBEVF_MIN_RXD);
 341         new_rx_count = min(new_rx_count, (u32)IXGBEVF_MAX_RXD);
 342         new_rx_count = ALIGN(new_rx_count, IXGBE_REQ_RX_DESCRIPTOR_MULTIPLE);
 343
 344         new_tx_count = max(ring->tx_pending, (u32)IXGBEVF_MIN_TXD);
 345         new_tx_count = min(new_tx_count, (u32)IXGBEVF_MAX_TXD);
 346         new_tx_count = ALIGN(new_tx_count, IXGBE_REQ_TX_DESCRIPTOR_MULTIPLE);
 347
 348         if ((new_tx_count == adapter->tx_ring->count) &&
 349             (new_rx_count == adapter->rx_ring->count)) {
 350                 /* nothing to do */
 351                 return 0;
 352         }
 353
 354         while (test_and_set_bit(__IXGBEVF_RESETTING, &adapter->state))
 355                 msleep(1);
 356
 357         if (new_tx_count != adapter->tx_ring_count) {
 358                 tx_ring = kcalloc(adapter->num_tx_queues,
 359                                   sizeof(struct ixgbevf_ring), GFP_KERNEL);
 360                 if (!tx_ring) {
 361                         err = -ENOMEM;
 362                         goto err_setup;
 363                 }
 364                 memcpy(tx_ring, adapter->tx_ring,
 365                        adapter->num_tx_queues * sizeof(struct ixgbevf_ring));
 366                 for (i = 0; i < adapter->num_tx_queues; i++) {
 367                         tx_ring[i].count = new_tx_count;
 368                         err = ixgbevf_setup_tx_resources(adapter,
 369                                                          &tx_ring[i]);
 370                         if (err) {
 371                                 while (i) {
 372                                         i--;
 373                                         ixgbevf_free_tx_resources(adapter,
 374                                                                   &tx_ring[i]);
 375                                 }
 376                                 kfree(tx_ring);
 377                                 goto err_setup;
 378                         }
 379                         tx_ring[i].v_idx = adapter->tx_ring[i].v_idx;
 380                 }
 381                 need_tx_update = true;
 382         }
 383
 384         if (new_rx_count != adapter->rx_ring_count) {
 385                 rx_ring = kcalloc(adapter->num_rx_queues,
 386                                   sizeof(struct ixgbevf_ring), GFP_KERNEL);
 387                 if ((!rx_ring) && (need_tx_update)) {
 388                         err = -ENOMEM;
 389                         goto err_rx_setup;
 390                 }
 391                 memcpy(rx_ring, adapter->rx_ring,
 392                        adapter->num_rx_queues * sizeof(struct ixgbevf_ring));
 393                 for (i = 0; i < adapter->num_rx_queues; i++) {
 394                         rx_ring[i].count = new_rx_count;
 395                         err = ixgbevf_setup_rx_resources(adapter,
 396                                                          &rx_ring[i]);
 397                         if (err) {
 398                                 while (i) {
 399                                         i--;
 400                                         ixgbevf_free_rx_resources(adapter,
 401                                                                   &rx_ring[i]);
 402                                 }
 403                                 kfree(rx_ring);
 404                                 goto err_rx_setup;
 405                         }
 406                         rx_ring[i].v_idx = adapter->rx_ring[i].v_idx;
 407                 }
 408                 need_rx_update = true;
 409         }
 410
 411 err_rx_setup:
 412         /* if rings need to be updated, here's the place to do it in one shot */
 413         if (need_tx_update || need_rx_update) {
 414                 if (netif_running(netdev))
 415                         ixgbevf_down(adapter);
 416         }
 417
 418         /* tx */
 419         if (need_tx_update) {
 420                 kfree(adapter->tx_ring);
 421                 adapter->tx_ring = tx_ring;
 422                 tx_ring = NULL;
 423                 adapter->tx_ring_count = new_tx_count;
 424         }
 425
 426         /* rx */
 427         if (need_rx_update) {
 428                 kfree(adapter->rx_ring);
 429                 adapter->rx_ring = rx_ring;
 430                 rx_ring = NULL;
 431                 adapter->rx_ring_count = new_rx_count;
 432         }
 433
 434         /* success! */
 435         err = 0;
 436         if (netif_running(netdev))
 437                 ixgbevf_up(adapter);
 438
 439 err_setup:
 440         clear_bit(__IXGBEVF_RESETTING, &adapter->state);
 441         return err;
 442 }
 443
 444 static int ixgbevf_get_sset_count(struct net_device *dev, int stringset)
 445 {
 446        switch (stringset) {
 447        case ETH_SS_TEST:
 448                return IXGBE_TEST_LEN;
 449        case ETH_SS_STATS:
 450                return IXGBE_GLOBAL_STATS_LEN;
 451        default:
 452                return -EINVAL;
 453        }
 454 }
 455
 456 static void ixgbevf_get_ethtool_stats(struct net_device *netdev,
 457                                       struct ethtool_stats *stats, u64 *data)
 458 {
 459         struct ixgbevf_adapter *adapter = netdev_priv(netdev);
 460         int i;
 461
 462         ixgbevf_update_stats(adapter);
 463         for (i = 0; i < IXGBE_GLOBAL_STATS_LEN; i++) {
 464                 char *p = (char *)adapter +
 465                         ixgbe_gstrings_stats[i].stat_offset;
 466                 char *b = (char *)adapter +
 467                         ixgbe_gstrings_stats[i].base_stat_offset;
 468                 char *r = (char *)adapter +
 469                         ixgbe_gstrings_stats[i].saved_reset_offset;
 470                 data[i] = ((ixgbe_gstrings_stats[i].sizeof_stat ==
 471                             sizeof(u64)) ? *(u64 *)p : *(u32 *)p) -
 472                           ((ixgbe_gstrings_stats[i].sizeof_stat ==
 473                             sizeof(u64)) ? *(u64 *)b : *(u32 *)b) +
 474                           ((ixgbe_gstrings_stats[i].sizeof_stat ==
 475                             sizeof(u64)) ? *(u64 *)r : *(u32 *)r);
 476         }
 477 }
 478
 479 static void ixgbevf_get_strings(struct net_device *netdev, u32 stringset,
 480                                 u8 *data)
 481 {
 482         char *p = (char *)data;
 483         int i;
 484
 485         switch (stringset) {
 486         case ETH_SS_TEST:
 487                 memcpy(data, *ixgbe_gstrings_test,
 488                        IXGBE_TEST_LEN * ETH_GSTRING_LEN);
 489                 break;
 490         case ETH_SS_STATS:
 491                 for (i = 0; i < IXGBE_GLOBAL_STATS_LEN; i++) {
 492                         memcpy(p, ixgbe_gstrings_stats[i].stat_string,
 493                                ETH_GSTRING_LEN);
 494                         p += ETH_GSTRING_LEN;
 495                 }
 496                 break;
 497         }
 498 }
 499
 500 static int ixgbevf_link_test(struct ixgbevf_adapter *adapter, u64 *data)
 501 {
 502         struct ixgbe_hw *hw = &adapter->hw;
 503         bool link_up;
 504         u32 link_speed = 0;
 505         *data = 0;
 506
 507         hw->mac.ops.check_link(hw, &link_speed, &link_up, true);
 508         if (!link_up)
 509                 *data = 1;
 510
 511         return *data;
 512 }
 513
 514 /* ethtool register test data */
 515 struct ixgbevf_reg_test {
 516         u16 reg;
 517         u8  array_len;
 518         u8  test_type;
 519         u32 mask;
 520         u32 write;
 521 };
 522
 523 /* In the hardware, registers are laid out either singly, in arrays
 524  * spaced 0x40 bytes apart, or in contiguous tables.  We assume
 525  * most tests take place on arrays or single registers (handled
 526  * as a single-element array) and special-case the tables.
 527  * Table tests are always pattern tests.
 528  *
 529  * We also make provision for some required setup steps by specifying
 530  * registers to be written without any read-back testing.
 531  */
 532
 533 #define PATTERN_TEST    1
 534 #define SET_READ_TEST   2
 535 #define WRITE_NO_TEST   3
 536 #define TABLE32_TEST    4
 537 #define TABLE64_TEST_LO 5
 538 #define TABLE64_TEST_HI 6
 539
 540 /* default VF register test */
 541 static struct ixgbevf_reg_test reg_test_vf[] = {
 542         { IXGBE_VFRDBAL(0), 2, PATTERN_TEST, 0xFFFFFF80, 0xFFFFFF80 },
 543         { IXGBE_VFRDBAH(0), 2, PATTERN_TEST, 0xFFFFFFFF, 0xFFFFFFFF },
 544         { IXGBE_VFRDLEN(0), 2, PATTERN_TEST, 0x000FFF80, 0x000FFFFF },
 545         { IXGBE_VFRXDCTL(0), 2, WRITE_NO_TEST, 0, IXGBE_RXDCTL_ENABLE },
 546         { IXGBE_VFRDT(0), 2, PATTERN_TEST, 0x0000FFFF, 0x0000FFFF },
 547         { IXGBE_VFRXDCTL(0), 2, WRITE_NO_TEST, 0, 0 },
 548         { IXGBE_VFTDBAL(0), 2, PATTERN_TEST, 0xFFFFFF80, 0xFFFFFFFF },
 549         { IXGBE_VFTDBAH(0), 2, PATTERN_TEST, 0xFFFFFFFF, 0xFFFFFFFF },
 550         { IXGBE_VFTDLEN(0), 2, PATTERN_TEST, 0x000FFF80, 0x000FFF80 },
 551         { 0, 0, 0, 0 }
 552 };
 553
 554 #define REG_PATTERN_TEST(R, M, W)                                             \
 555 {                                                                             \
 556         u32 pat, val, before;                                                 \
 557         const u32 _test[] = {0x5A5A5A5A, 0xA5A5A5A5, 0x00000000, 0xFFFFFFFF}; \
 558         for (pat = 0; pat < ARRAY_SIZE(_test); pat++) {                       \
 559                 before = readl(adapter->hw.hw_addr + R);                      \
 560                 writel((_test[pat] & W), (adapter->hw.hw_addr + R));          \
 561                 val = readl(adapter->hw.hw_addr + R);                         \
 562                 if (val != (_test[pat] & W & M)) {                            \
 563                         hw_dbg(&adapter->hw,                                  \
 564                         "pattern test reg %04X failed: got "                  \
 565                         "0x%08X expected 0x%08X\n",                           \
 566                         R, val, (_test[pat] & W & M));                        \
 567                         *data = R;                                            \
 568                         writel(before, adapter->hw.hw_addr + R);              \
 569                         return 1;                                             \
 570                 }                                                             \
 571                 writel(before, adapter->hw.hw_addr + R);                      \
 572         }                                                                     \
 573 }
 574
 575 #define REG_SET_AND_CHECK(R, M, W)                                            \
 576 {                                                                             \
 577         u32 val, before;                                                      \
 578         before = readl(adapter->hw.hw_addr + R);                              \
 579         writel((W & M), (adapter->hw.hw_addr + R));                           \
 580         val = readl(adapter->hw.hw_addr + R);                                 \
 581         if ((W & M) != (val & M)) {                                           \
 582                 printk(KERN_ERR "set/check reg %04X test failed: got 0x%08X " \
 583                                  "expected 0x%08X\n", R, (val & M), (W & M)); \
 584                 *data = R;                                                    \
 585                 writel(before, (adapter->hw.hw_addr + R));                    \
 586                 return 1;                                                     \
 587         }                                                                     \
 588         writel(before, (adapter->hw.hw_addr + R));                            \
 589 }
 590
 591 static int ixgbevf_reg_test(struct ixgbevf_adapter *adapter, u64 *data)
 592 {
 593         struct ixgbevf_reg_test *test;
 594         u32 i;
 595
 596         test = reg_test_vf;
 597
 598         /*
 599          * Perform the register test, looping through the test table
 600          * until we either fail or reach the null entry.
 601          */
 602         while (test->reg) {
 603                 for (i = 0; i < test->array_len; i++) {
 604                         switch (test->test_type) {
 605                         case PATTERN_TEST:
 606                                 REG_PATTERN_TEST(test->reg + (i * 0x40),
 607                                                 test->mask,
 608                                                 test->write);
 609                                 break;
 610                         case SET_READ_TEST:
 611                                 REG_SET_AND_CHECK(test->reg + (i * 0x40),
 612                                                 test->mask,
 613                                                 test->write);
 614                                 break;
 615                         case WRITE_NO_TEST:
 616                                 writel(test->write,
 617                                        (adapter->hw.hw_addr + test->reg)
 618                                        + (i * 0x40));
 619                                 break;
 620                         case TABLE32_TEST:
 621                                 REG_PATTERN_TEST(test->reg + (i * 4),
 622                                                 test->mask,
 623                                                 test->write);
 624                                 break;
 625                         case TABLE64_TEST_LO:
 626                                 REG_PATTERN_TEST(test->reg + (i * 8),
 627                                                 test->mask,
 628                                                 test->write);
 629                                 break;
 630                         case TABLE64_TEST_HI:
 631                                 REG_PATTERN_TEST((test->reg + 4) + (i * 8),
 632                                                 test->mask,
 633                                                 test->write);
 634                                 break;
 635                         }
 636                 }
 637                 test++;
 638         }
 639
 640         *data = 0;
 641         return *data;
 642 }
 643
 644 static void ixgbevf_diag_test(struct net_device *netdev,
 645                               struct ethtool_test *eth_test, u64 *data)
 646 {
 647         struct ixgbevf_adapter *adapter = netdev_priv(netdev);
 648         bool if_running = netif_running(netdev);
 649
 650         set_bit(__IXGBEVF_TESTING, &adapter->state);
 651         if (eth_test->flags == ETH_TEST_FL_OFFLINE) {
 652                 /* Offline tests */
 653
 654                 hw_dbg(&adapter->hw, "offline testing starting\n");
 655
 656                 /* Link test performed before hardware reset so autoneg doesn't
 657                  * interfere with test result */
 658                 if (ixgbevf_link_test(adapter, &data[1]))
 659                         eth_test->flags |= ETH_TEST_FL_FAILED;
 660
 661                 if (if_running)
 662                         /* indicate we're in test mode */
 663                         dev_close(netdev);
 664                 else
 665                         ixgbevf_reset(adapter);
 666
 667                 hw_dbg(&adapter->hw, "register testing starting\n");
 668                 if (ixgbevf_reg_test(adapter, &data[0]))
 669                         eth_test->flags |= ETH_TEST_FL_FAILED;
 670
 671                 ixgbevf_reset(adapter);
 672
 673                 clear_bit(__IXGBEVF_TESTING, &adapter->state);
 674                 if (if_running)
 675                         dev_open(netdev);
 676         } else {
 677                 hw_dbg(&adapter->hw, "online testing starting\n");
 678                 /* Online tests */
 679                 if (ixgbevf_link_test(adapter, &data[1]))
 680                         eth_test->flags |= ETH_TEST_FL_FAILED;
 681
 682                 /* Online tests aren't run; pass by default */
 683                 data[0] = 0;
 684
 685                 clear_bit(__IXGBEVF_TESTING, &adapter->state);
 686         }
 687         msleep_interruptible(4 * 1000);
 688 }
 689
 690 static int ixgbevf_nway_reset(struct net_device *netdev)
 691 {
 692         struct ixgbevf_adapter *adapter = netdev_priv(netdev);
 693
 694         if (netif_running(netdev)) {
 695                 if (!adapter->dev_closed)
 696                         ixgbevf_reinit_locked(adapter);
 697         }
 698
 699         return 0;
 700 }
 701
 702 static struct ethtool_ops ixgbevf_ethtool_ops = {
 703         .get_settings           = ixgbevf_get_settings,
 704         .get_drvinfo            = ixgbevf_get_drvinfo,
 705         .get_regs_len           = ixgbevf_get_regs_len,
 706         .get_regs               = ixgbevf_get_regs,
 707         .nway_reset             = ixgbevf_nway_reset,
 708         .get_link               = ethtool_op_get_link,
 709         .get_ringparam          = ixgbevf_get_ringparam,
 710         .set_ringparam          = ixgbevf_set_ringparam,
 711         .get_rx_csum            = ixgbevf_get_rx_csum,
 712         .set_rx_csum            = ixgbevf_set_rx_csum,
 713         .get_tx_csum            = ethtool_op_get_tx_csum,
 714         .set_tx_csum            = ethtool_op_set_tx_ipv6_csum,
 715         .get_sg                 = ethtool_op_get_sg,
 716         .set_sg                 = ethtool_op_set_sg,
 717         .get_msglevel           = ixgbevf_get_msglevel,
 718         .set_msglevel           = ixgbevf_set_msglevel,
 719         .get_tso                = ethtool_op_get_tso,
 720         .set_tso                = ixgbevf_set_tso,
 721         .self_test              = ixgbevf_diag_test,
 722         .get_sset_count         = ixgbevf_get_sset_count,
 723         .get_strings            = ixgbevf_get_strings,
 724         .get_ethtool_stats      = ixgbevf_get_ethtool_stats,
 725 };
 726
 727 void ixgbevf_set_ethtool_ops(struct net_device *netdev)
 728 {
 729         SET_ETHTOOL_OPS(netdev, &ixgbevf_ethtool_ops);
 730 }