lib/librte_eal/linuxapp/kni/ethtool/igb/igb_ethtool.c

   1 /*******************************************************************************
   2
   3   Intel(R) Gigabit Ethernet Linux driver
   4   Copyright(c) 2007-2013 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 "LICENSE.GPL".
  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 igb */
  29
  30 #include <linux/netdevice.h>
  31 #include <linux/vmalloc.h>
  32
  33 #ifdef SIOCETHTOOL
  34 #include <linux/ethtool.h>
  35 #ifdef CONFIG_PM_RUNTIME
  36 #include <linux/pm_runtime.h>
  37 #endif /* CONFIG_PM_RUNTIME */
  38 #include <linux/highmem.h>
  39
  40 #include "igb.h"
  41 #include "igb_regtest.h"
  42 #include <linux/if_vlan.h>
  43 #ifdef ETHTOOL_GEEE
  44 #include <linux/mdio.h>
  45 #endif
  46
  47 #ifdef ETHTOOL_OPS_COMPAT
  48 #include "kcompat_ethtool.c"
  49 #endif
  50 #ifdef ETHTOOL_GSTATS
  51 struct igb_stats {
  52         char stat_string[ETH_GSTRING_LEN];
  53         int sizeof_stat;
  54         int stat_offset;
  55 };
  56
  57 #define IGB_STAT(_name, _stat) { \
  58         .stat_string = _name, \
  59         .sizeof_stat = FIELD_SIZEOF(struct igb_adapter, _stat), \
  60         .stat_offset = offsetof(struct igb_adapter, _stat) \
  61 }
  62 static const struct igb_stats igb_gstrings_stats[] = {
  63         IGB_STAT("rx_packets", stats.gprc),
  64         IGB_STAT("tx_packets", stats.gptc),
  65         IGB_STAT("rx_bytes", stats.gorc),
  66         IGB_STAT("tx_bytes", stats.gotc),
  67         IGB_STAT("rx_broadcast", stats.bprc),
  68         IGB_STAT("tx_broadcast", stats.bptc),
  69         IGB_STAT("rx_multicast", stats.mprc),
  70         IGB_STAT("tx_multicast", stats.mptc),
  71         IGB_STAT("multicast", stats.mprc),
  72         IGB_STAT("collisions", stats.colc),
  73         IGB_STAT("rx_crc_errors", stats.crcerrs),
  74         IGB_STAT("rx_no_buffer_count", stats.rnbc),
  75         IGB_STAT("rx_missed_errors", stats.mpc),
  76         IGB_STAT("tx_aborted_errors", stats.ecol),
  77         IGB_STAT("tx_carrier_errors", stats.tncrs),
  78         IGB_STAT("tx_window_errors", stats.latecol),
  79         IGB_STAT("tx_abort_late_coll", stats.latecol),
  80         IGB_STAT("tx_deferred_ok", stats.dc),
  81         IGB_STAT("tx_single_coll_ok", stats.scc),
  82         IGB_STAT("tx_multi_coll_ok", stats.mcc),
  83         IGB_STAT("tx_timeout_count", tx_timeout_count),
  84         IGB_STAT("rx_long_length_errors", stats.roc),
  85         IGB_STAT("rx_short_length_errors", stats.ruc),
  86         IGB_STAT("rx_align_errors", stats.algnerrc),
  87         IGB_STAT("tx_tcp_seg_good", stats.tsctc),
  88         IGB_STAT("tx_tcp_seg_failed", stats.tsctfc),
  89         IGB_STAT("rx_flow_control_xon", stats.xonrxc),
  90         IGB_STAT("rx_flow_control_xoff", stats.xoffrxc),
  91         IGB_STAT("tx_flow_control_xon", stats.xontxc),
  92         IGB_STAT("tx_flow_control_xoff", stats.xofftxc),
  93         IGB_STAT("rx_long_byte_count", stats.gorc),
  94         IGB_STAT("tx_dma_out_of_sync", stats.doosync),
  95 #ifndef IGB_NO_LRO
  96         IGB_STAT("lro_aggregated", lro_stats.coal),
  97         IGB_STAT("lro_flushed", lro_stats.flushed),
  98 #endif /* IGB_LRO */
  99         IGB_STAT("tx_smbus", stats.mgptc),
 100         IGB_STAT("rx_smbus", stats.mgprc),
 101         IGB_STAT("dropped_smbus", stats.mgpdc),
 102         IGB_STAT("os2bmc_rx_by_bmc", stats.o2bgptc),
 103         IGB_STAT("os2bmc_tx_by_bmc", stats.b2ospc),
 104         IGB_STAT("os2bmc_tx_by_host", stats.o2bspc),
 105         IGB_STAT("os2bmc_rx_by_host", stats.b2ogprc),
 106 #ifdef HAVE_PTP_1588_CLOCK
 107         IGB_STAT("tx_hwtstamp_timeouts", tx_hwtstamp_timeouts),
 108         IGB_STAT("rx_hwtstamp_cleared", rx_hwtstamp_cleared),
 109 #endif /* HAVE_PTP_1588_CLOCK */
 110 };
 111
 112 #define IGB_NETDEV_STAT(_net_stat) { \
 113         .stat_string = #_net_stat, \
 114         .sizeof_stat = FIELD_SIZEOF(struct net_device_stats, _net_stat), \
 115         .stat_offset = offsetof(struct net_device_stats, _net_stat) \
 116 }
 117 static const struct igb_stats igb_gstrings_net_stats[] = {
 118         IGB_NETDEV_STAT(rx_errors),
 119         IGB_NETDEV_STAT(tx_errors),
 120         IGB_NETDEV_STAT(tx_dropped),
 121         IGB_NETDEV_STAT(rx_length_errors),
 122         IGB_NETDEV_STAT(rx_over_errors),
 123         IGB_NETDEV_STAT(rx_frame_errors),
 124         IGB_NETDEV_STAT(rx_fifo_errors),
 125         IGB_NETDEV_STAT(tx_fifo_errors),
 126         IGB_NETDEV_STAT(tx_heartbeat_errors)
 127 };
 128
 129 #define IGB_GLOBAL_STATS_LEN ARRAY_SIZE(igb_gstrings_stats)
 130 #define IGB_NETDEV_STATS_LEN ARRAY_SIZE(igb_gstrings_net_stats)
 131 #define IGB_RX_QUEUE_STATS_LEN \
 132         (sizeof(struct igb_rx_queue_stats) / sizeof(u64))
 133 #define IGB_TX_QUEUE_STATS_LEN \
 134         (sizeof(struct igb_tx_queue_stats) / sizeof(u64))
 135 #define IGB_QUEUE_STATS_LEN \
 136         ((((struct igb_adapter *)netdev_priv(netdev))->num_rx_queues * \
 137           IGB_RX_QUEUE_STATS_LEN) + \
 138          (((struct igb_adapter *)netdev_priv(netdev))->num_tx_queues * \
 139           IGB_TX_QUEUE_STATS_LEN))
 140 #define IGB_STATS_LEN \
 141         (IGB_GLOBAL_STATS_LEN + IGB_NETDEV_STATS_LEN + IGB_QUEUE_STATS_LEN)
 142
 143 #endif /* ETHTOOL_GSTATS */
 144 #ifdef ETHTOOL_TEST
 145 static const char igb_gstrings_test[][ETH_GSTRING_LEN] = {
 146         "Register test  (offline)", "Eeprom test    (offline)",
 147         "Interrupt test (offline)", "Loopback test  (offline)",
 148         "Link test   (on/offline)"
 149 };
 150 #define IGB_TEST_LEN (sizeof(igb_gstrings_test) / ETH_GSTRING_LEN)
 151 #endif /* ETHTOOL_TEST */
 152
 153 #ifndef ETHTOOL_GLINKSETTINGS
 154 static int igb_get_settings(struct net_device *netdev, struct ethtool_cmd *ecmd)
 155 {
 156         struct igb_adapter *adapter = netdev_priv(netdev);
 157         struct e1000_hw *hw = &adapter->hw;
 158         u32 status;
 159
 160         if (hw->phy.media_type == e1000_media_type_copper) {
 161
 162                 ecmd->supported = (SUPPORTED_10baseT_Half |
 163                                    SUPPORTED_10baseT_Full |
 164                                    SUPPORTED_100baseT_Half |
 165                                    SUPPORTED_100baseT_Full |
 166                                    SUPPORTED_1000baseT_Full|
 167                                    SUPPORTED_Autoneg |
 168                                    SUPPORTED_TP |
 169                                    SUPPORTED_Pause);
 170                 ecmd->advertising = ADVERTISED_TP;
 171
 172                 if (hw->mac.autoneg == 1) {
 173                         ecmd->advertising |= ADVERTISED_Autoneg;
 174                         /* the e1000 autoneg seems to match ethtool nicely */
 175                         ecmd->advertising |= hw->phy.autoneg_advertised;
 176                 }
 177
 178                 ecmd->port = PORT_TP;
 179                 ecmd->phy_address = hw->phy.addr;
 180                 ecmd->transceiver = XCVR_INTERNAL;
 181
 182         } else {
 183                 ecmd->supported = (SUPPORTED_1000baseT_Full |
 184                                    SUPPORTED_100baseT_Full |
 185                                    SUPPORTED_FIBRE |
 186                                    SUPPORTED_Autoneg |
 187                                    SUPPORTED_Pause);
 188                 if (hw->mac.type == e1000_i354)
 189                         ecmd->supported |= (SUPPORTED_2500baseX_Full);
 190
 191                 ecmd->advertising = ADVERTISED_FIBRE;
 192
 193                 switch (adapter->link_speed) {
 194                 case SPEED_2500:
 195                         ecmd->advertising = ADVERTISED_2500baseX_Full;
 196                         break;
 197                 case SPEED_1000:
 198                         ecmd->advertising = ADVERTISED_1000baseT_Full;
 199                         break;
 200                 case SPEED_100:
 201                         ecmd->advertising = ADVERTISED_100baseT_Full;
 202                         break;
 203                 default:
 204                         break;
 205                 }
 206
 207                 if (hw->mac.autoneg == 1)
 208                         ecmd->advertising |= ADVERTISED_Autoneg;
 209
 210                 ecmd->port = PORT_FIBRE;
 211                 ecmd->transceiver = XCVR_EXTERNAL;
 212         }
 213
 214         if (hw->mac.autoneg != 1)
 215                 ecmd->advertising &= ~(ADVERTISED_Pause |
 216                                        ADVERTISED_Asym_Pause);
 217
 218         if (hw->fc.requested_mode == e1000_fc_full)
 219                 ecmd->advertising |= ADVERTISED_Pause;
 220         else if (hw->fc.requested_mode == e1000_fc_rx_pause)
 221                 ecmd->advertising |= (ADVERTISED_Pause |
 222                                       ADVERTISED_Asym_Pause);
 223         else if (hw->fc.requested_mode == e1000_fc_tx_pause)
 224                 ecmd->advertising |=  ADVERTISED_Asym_Pause;
 225         else
 226                 ecmd->advertising &= ~(ADVERTISED_Pause |
 227                                        ADVERTISED_Asym_Pause);
 228
 229         status = E1000_READ_REG(hw, E1000_STATUS);
 230
 231         if (status & E1000_STATUS_LU) {
 232                 if ((hw->mac.type == e1000_i354) &&
 233                     (status & E1000_STATUS_2P5_SKU) &&
 234                     !(status & E1000_STATUS_2P5_SKU_OVER))
 235                         ecmd->speed = SPEED_2500;
 236                 else if (status & E1000_STATUS_SPEED_1000)
 237                         ecmd->speed = SPEED_1000;
 238                 else if (status & E1000_STATUS_SPEED_100)
 239                         ecmd->speed = SPEED_100;
 240                 else
 241                         ecmd->speed = SPEED_10;
 242
 243                 if ((status & E1000_STATUS_FD) ||
 244                     hw->phy.media_type != e1000_media_type_copper)
 245                         ecmd->duplex = DUPLEX_FULL;
 246                 else
 247                         ecmd->duplex = DUPLEX_HALF;
 248
 249         } else {
 250                 ecmd->speed = -1;
 251                 ecmd->duplex = -1;
 252         }
 253
 254         if ((hw->phy.media_type == e1000_media_type_fiber) ||
 255             hw->mac.autoneg)
 256                 ecmd->autoneg = AUTONEG_ENABLE;
 257         else
 258                 ecmd->autoneg = AUTONEG_DISABLE;
 259 #ifdef ETH_TP_MDI_X
 260
 261         /* MDI-X => 2; MDI =>1; Invalid =>0 */
 262         if (hw->phy.media_type == e1000_media_type_copper)
 263                 ecmd->eth_tp_mdix = hw->phy.is_mdix ? ETH_TP_MDI_X :
 264                                                       ETH_TP_MDI;
 265         else
 266                 ecmd->eth_tp_mdix = ETH_TP_MDI_INVALID;
 267
 268 #ifdef ETH_TP_MDI_AUTO
 269         if (hw->phy.mdix == AUTO_ALL_MODES)
 270                 ecmd->eth_tp_mdix_ctrl = ETH_TP_MDI_AUTO;
 271         else
 272                 ecmd->eth_tp_mdix_ctrl = hw->phy.mdix;
 273
 274 #endif
 275 #endif /* ETH_TP_MDI_X */
 276         return 0;
 277 }
 278 #endif
 279
 280 #ifndef ETHTOOL_SLINKSETTINGS
 281 static int igb_set_settings(struct net_device *netdev, struct ethtool_cmd *ecmd)
 282 {
 283         struct igb_adapter *adapter = netdev_priv(netdev);
 284         struct e1000_hw *hw = &adapter->hw;
 285
 286         if (ecmd->duplex  == DUPLEX_HALF) {
 287                 if (!hw->dev_spec._82575.eee_disable)
 288                         dev_info(pci_dev_to_dev(adapter->pdev), "EEE disabled: not supported with half duplex\n");
 289                 hw->dev_spec._82575.eee_disable = true;
 290         } else {
 291                 if (hw->dev_spec._82575.eee_disable)
 292                         dev_info(pci_dev_to_dev(adapter->pdev), "EEE enabled\n");
 293                 hw->dev_spec._82575.eee_disable = false;
 294         }
 295
 296         /* When SoL/IDER sessions are active, autoneg/speed/duplex
 297          * cannot be changed */
 298         if (e1000_check_reset_block(hw)) {
 299                 dev_err(pci_dev_to_dev(adapter->pdev), "Cannot change link "
 300                         "characteristics when SoL/IDER is active.\n");
 301                 return -EINVAL;
 302         }
 303
 304 #ifdef ETH_TP_MDI_AUTO
 305         /*
 306          * MDI setting is only allowed when autoneg enabled because
 307          * some hardware doesn't allow MDI setting when speed or
 308          * duplex is forced.
 309          */
 310         if (ecmd->eth_tp_mdix_ctrl) {
 311                 if (hw->phy.media_type != e1000_media_type_copper)
 312                         return -EOPNOTSUPP;
 313
 314                 if ((ecmd->eth_tp_mdix_ctrl != ETH_TP_MDI_AUTO) &&
 315                     (ecmd->autoneg != AUTONEG_ENABLE)) {
 316                         dev_err(&adapter->pdev->dev, "forcing MDI/MDI-X state is not supported when link speed and/or duplex are forced\n");
 317                         return -EINVAL;
 318                 }
 319         }
 320
 321 #endif /* ETH_TP_MDI_AUTO */
 322         while (test_and_set_bit(__IGB_RESETTING, &adapter->state))
 323                 usleep_range(1000, 2000);
 324
 325         if (ecmd->autoneg == AUTONEG_ENABLE) {
 326                 hw->mac.autoneg = 1;
 327                 if (hw->phy.media_type == e1000_media_type_fiber) {
 328                         hw->phy.autoneg_advertised = ecmd->advertising |
 329                                                      ADVERTISED_FIBRE |
 330                                                      ADVERTISED_Autoneg;
 331                         switch (adapter->link_speed) {
 332                         case SPEED_2500:
 333                                 hw->phy.autoneg_advertised =
 334                                         ADVERTISED_2500baseX_Full;
 335                                 break;
 336                         case SPEED_1000:
 337                                 hw->phy.autoneg_advertised =
 338                                         ADVERTISED_1000baseT_Full;
 339                                 break;
 340                         case SPEED_100:
 341                                 hw->phy.autoneg_advertised =
 342                                         ADVERTISED_100baseT_Full;
 343                                 break;
 344                         default:
 345                                 break;
 346                         }
 347                 } else {
 348                         hw->phy.autoneg_advertised = ecmd->advertising |
 349                                                      ADVERTISED_TP |
 350                                                      ADVERTISED_Autoneg;
 351                 }
 352                 ecmd->advertising = hw->phy.autoneg_advertised;
 353                 if (adapter->fc_autoneg)
 354                         hw->fc.requested_mode = e1000_fc_default;
 355         } else {
 356                 if (igb_set_spd_dplx(adapter, ecmd->speed + ecmd->duplex)) {
 357                         clear_bit(__IGB_RESETTING, &adapter->state);
 358                         return -EINVAL;
 359                 }
 360         }
 361
 362 #ifdef ETH_TP_MDI_AUTO
 363         /* MDI-X => 2; MDI => 1; Auto => 3 */
 364         if (ecmd->eth_tp_mdix_ctrl) {
 365                 /* fix up the value for auto (3 => 0) as zero is mapped
 366                  * internally to auto
 367                  */
 368                 if (ecmd->eth_tp_mdix_ctrl == ETH_TP_MDI_AUTO)
 369                         hw->phy.mdix = AUTO_ALL_MODES;
 370                 else
 371                         hw->phy.mdix = ecmd->eth_tp_mdix_ctrl;
 372         }
 373
 374 #endif /* ETH_TP_MDI_AUTO */
 375         /* reset the link */
 376         if (netif_running(adapter->netdev)) {
 377                 igb_down(adapter);
 378                 igb_up(adapter);
 379         } else
 380                 igb_reset(adapter);
 381
 382         clear_bit(__IGB_RESETTING, &adapter->state);
 383         return 0;
 384 }
 385 #endif
 386
 387 static u32 igb_get_link(struct net_device *netdev)
 388 {
 389         struct igb_adapter *adapter = netdev_priv(netdev);
 390         struct e1000_mac_info *mac = &adapter->hw.mac;
 391
 392         /*
 393          * If the link is not reported up to netdev, interrupts are disabled,
 394          * and so the physical link state may have changed since we last
 395          * looked. Set get_link_status to make sure that the true link
 396          * state is interrogated, rather than pulling a cached and possibly
 397          * stale link state from the driver.
 398          */
 399         if (!netif_carrier_ok(netdev))
 400                 mac->get_link_status = 1;
 401
 402         return igb_has_link(adapter);
 403 }
 404
 405 static void igb_get_pauseparam(struct net_device *netdev,
 406                                struct ethtool_pauseparam *pause)
 407 {
 408         struct igb_adapter *adapter = netdev_priv(netdev);
 409         struct e1000_hw *hw = &adapter->hw;
 410
 411         pause->autoneg =
 412                 (adapter->fc_autoneg ? AUTONEG_ENABLE : AUTONEG_DISABLE);
 413
 414         if (hw->fc.current_mode == e1000_fc_rx_pause)
 415                 pause->rx_pause = 1;
 416         else if (hw->fc.current_mode == e1000_fc_tx_pause)
 417                 pause->tx_pause = 1;
 418         else if (hw->fc.current_mode == e1000_fc_full) {
 419                 pause->rx_pause = 1;
 420                 pause->tx_pause = 1;
 421         }
 422 }
 423
 424 static int igb_set_pauseparam(struct net_device *netdev,
 425                               struct ethtool_pauseparam *pause)
 426 {
 427         struct igb_adapter *adapter = netdev_priv(netdev);
 428         struct e1000_hw *hw = &adapter->hw;
 429         int retval = 0;
 430
 431         adapter->fc_autoneg = pause->autoneg;
 432
 433         while (test_and_set_bit(__IGB_RESETTING, &adapter->state))
 434                 usleep_range(1000, 2000);
 435
 436         if (adapter->fc_autoneg == AUTONEG_ENABLE) {
 437                 hw->fc.requested_mode = e1000_fc_default;
 438                 if (netif_running(adapter->netdev)) {
 439                         igb_down(adapter);
 440                         igb_up(adapter);
 441                 } else {
 442                         igb_reset(adapter);
 443                 }
 444         } else {
 445                 if (pause->rx_pause && pause->tx_pause)
 446                         hw->fc.requested_mode = e1000_fc_full;
 447                 else if (pause->rx_pause && !pause->tx_pause)
 448                         hw->fc.requested_mode = e1000_fc_rx_pause;
 449                 else if (!pause->rx_pause && pause->tx_pause)
 450                         hw->fc.requested_mode = e1000_fc_tx_pause;
 451                 else if (!pause->rx_pause && !pause->tx_pause)
 452                         hw->fc.requested_mode = e1000_fc_none;
 453
 454                 hw->fc.current_mode = hw->fc.requested_mode;
 455
 456                 if (hw->phy.media_type == e1000_media_type_fiber) {
 457                         retval = hw->mac.ops.setup_link(hw);
 458                         /* implicit goto out */
 459                 } else {
 460                         retval = e1000_force_mac_fc(hw);
 461                         if (retval)
 462                                 goto out;
 463                         e1000_set_fc_watermarks_generic(hw);
 464                 }
 465         }
 466
 467 out:
 468         clear_bit(__IGB_RESETTING, &adapter->state);
 469         return retval;
 470 }
 471
 472 static u32 igb_get_msglevel(struct net_device *netdev)
 473 {
 474         struct igb_adapter *adapter = netdev_priv(netdev);
 475         return adapter->msg_enable;
 476 }
 477
 478 static void igb_set_msglevel(struct net_device *netdev, u32 data)
 479 {
 480         struct igb_adapter *adapter = netdev_priv(netdev);
 481         adapter->msg_enable = data;
 482 }
 483
 484 static int igb_get_regs_len(struct net_device *netdev)
 485 {
 486 #define IGB_REGS_LEN 555
 487         return IGB_REGS_LEN * sizeof(u32);
 488 }
 489
 490 static void igb_get_regs(struct net_device *netdev,
 491                          struct ethtool_regs *regs, void *p)
 492 {
 493         struct igb_adapter *adapter = netdev_priv(netdev);
 494         struct e1000_hw *hw = &adapter->hw;
 495         u32 *regs_buff = p;
 496         u8 i;
 497
 498         memset(p, 0, IGB_REGS_LEN * sizeof(u32));
 499
 500         regs->version = (1 << 24) | (hw->revision_id << 16) | hw->device_id;
 501
 502         /* General Registers */
 503         regs_buff[0] = E1000_READ_REG(hw, E1000_CTRL);
 504         regs_buff[1] = E1000_READ_REG(hw, E1000_STATUS);
 505         regs_buff[2] = E1000_READ_REG(hw, E1000_CTRL_EXT);
 506         regs_buff[3] = E1000_READ_REG(hw, E1000_MDIC);
 507         regs_buff[4] = E1000_READ_REG(hw, E1000_SCTL);
 508         regs_buff[5] = E1000_READ_REG(hw, E1000_CONNSW);
 509         regs_buff[6] = E1000_READ_REG(hw, E1000_VET);
 510         regs_buff[7] = E1000_READ_REG(hw, E1000_LEDCTL);
 511         regs_buff[8] = E1000_READ_REG(hw, E1000_PBA);
 512         regs_buff[9] = E1000_READ_REG(hw, E1000_PBS);
 513         regs_buff[10] = E1000_READ_REG(hw, E1000_FRTIMER);
 514         regs_buff[11] = E1000_READ_REG(hw, E1000_TCPTIMER);
 515
 516         /* NVM Register */
 517         regs_buff[12] = E1000_READ_REG(hw, E1000_EECD);
 518
 519         /* Interrupt */
 520         /* Reading EICS for EICR because they read the
 521          * same but EICS does not clear on read */
 522         regs_buff[13] = E1000_READ_REG(hw, E1000_EICS);
 523         regs_buff[14] = E1000_READ_REG(hw, E1000_EICS);
 524         regs_buff[15] = E1000_READ_REG(hw, E1000_EIMS);
 525         regs_buff[16] = E1000_READ_REG(hw, E1000_EIMC);
 526         regs_buff[17] = E1000_READ_REG(hw, E1000_EIAC);
 527         regs_buff[18] = E1000_READ_REG(hw, E1000_EIAM);
 528         /* Reading ICS for ICR because they read the
 529          * same but ICS does not clear on read */
 530         regs_buff[19] = E1000_READ_REG(hw, E1000_ICS);
 531         regs_buff[20] = E1000_READ_REG(hw, E1000_ICS);
 532         regs_buff[21] = E1000_READ_REG(hw, E1000_IMS);
 533         regs_buff[22] = E1000_READ_REG(hw, E1000_IMC);
 534         regs_buff[23] = E1000_READ_REG(hw, E1000_IAC);
 535         regs_buff[24] = E1000_READ_REG(hw, E1000_IAM);
 536         regs_buff[25] = E1000_READ_REG(hw, E1000_IMIRVP);
 537
 538         /* Flow Control */
 539         regs_buff[26] = E1000_READ_REG(hw, E1000_FCAL);
 540         regs_buff[27] = E1000_READ_REG(hw, E1000_FCAH);
 541         regs_buff[28] = E1000_READ_REG(hw, E1000_FCTTV);
 542         regs_buff[29] = E1000_READ_REG(hw, E1000_FCRTL);
 543         regs_buff[30] = E1000_READ_REG(hw, E1000_FCRTH);
 544         regs_buff[31] = E1000_READ_REG(hw, E1000_FCRTV);
 545
 546         /* Receive */
 547         regs_buff[32] = E1000_READ_REG(hw, E1000_RCTL);
 548         regs_buff[33] = E1000_READ_REG(hw, E1000_RXCSUM);
 549         regs_buff[34] = E1000_READ_REG(hw, E1000_RLPML);
 550         regs_buff[35] = E1000_READ_REG(hw, E1000_RFCTL);
 551         regs_buff[36] = E1000_READ_REG(hw, E1000_MRQC);
 552         regs_buff[37] = E1000_READ_REG(hw, E1000_VT_CTL);
 553
 554         /* Transmit */
 555         regs_buff[38] = E1000_READ_REG(hw, E1000_TCTL);
 556         regs_buff[39] = E1000_READ_REG(hw, E1000_TCTL_EXT);
 557         regs_buff[40] = E1000_READ_REG(hw, E1000_TIPG);
 558         regs_buff[41] = E1000_READ_REG(hw, E1000_DTXCTL);
 559
 560         /* Wake Up */
 561         regs_buff[42] = E1000_READ_REG(hw, E1000_WUC);
 562         regs_buff[43] = E1000_READ_REG(hw, E1000_WUFC);
 563         regs_buff[44] = E1000_READ_REG(hw, E1000_WUS);
 564         regs_buff[45] = E1000_READ_REG(hw, E1000_IPAV);
 565         regs_buff[46] = E1000_READ_REG(hw, E1000_WUPL);
 566
 567         /* MAC */
 568         regs_buff[47] = E1000_READ_REG(hw, E1000_PCS_CFG0);
 569         regs_buff[48] = E1000_READ_REG(hw, E1000_PCS_LCTL);
 570         regs_buff[49] = E1000_READ_REG(hw, E1000_PCS_LSTAT);
 571         regs_buff[50] = E1000_READ_REG(hw, E1000_PCS_ANADV);
 572         regs_buff[51] = E1000_READ_REG(hw, E1000_PCS_LPAB);
 573         regs_buff[52] = E1000_READ_REG(hw, E1000_PCS_NPTX);
 574         regs_buff[53] = E1000_READ_REG(hw, E1000_PCS_LPABNP);
 575
 576         /* Statistics */
 577         regs_buff[54] = adapter->stats.crcerrs;
 578         regs_buff[55] = adapter->stats.algnerrc;
 579         regs_buff[56] = adapter->stats.symerrs;
 580         regs_buff[57] = adapter->stats.rxerrc;
 581         regs_buff[58] = adapter->stats.mpc;
 582         regs_buff[59] = adapter->stats.scc;
 583         regs_buff[60] = adapter->stats.ecol;
 584         regs_buff[61] = adapter->stats.mcc;
 585         regs_buff[62] = adapter->stats.latecol;
 586         regs_buff[63] = adapter->stats.colc;
 587         regs_buff[64] = adapter->stats.dc;
 588         regs_buff[65] = adapter->stats.tncrs;
 589         regs_buff[66] = adapter->stats.sec;
 590         regs_buff[67] = adapter->stats.htdpmc;
 591         regs_buff[68] = adapter->stats.rlec;
 592         regs_buff[69] = adapter->stats.xonrxc;
 593         regs_buff[70] = adapter->stats.xontxc;
 594         regs_buff[71] = adapter->stats.xoffrxc;
 595         regs_buff[72] = adapter->stats.xofftxc;
 596         regs_buff[73] = adapter->stats.fcruc;
 597         regs_buff[74] = adapter->stats.prc64;
 598         regs_buff[75] = adapter->stats.prc127;
 599         regs_buff[76] = adapter->stats.prc255;
 600         regs_buff[77] = adapter->stats.prc511;
 601         regs_buff[78] = adapter->stats.prc1023;
 602         regs_buff[79] = adapter->stats.prc1522;
 603         regs_buff[80] = adapter->stats.gprc;
 604         regs_buff[81] = adapter->stats.bprc;
 605         regs_buff[82] = adapter->stats.mprc;
 606         regs_buff[83] = adapter->stats.gptc;
 607         regs_buff[84] = adapter->stats.gorc;
 608         regs_buff[86] = adapter->stats.gotc;
 609         regs_buff[88] = adapter->stats.rnbc;
 610         regs_buff[89] = adapter->stats.ruc;
 611         regs_buff[90] = adapter->stats.rfc;
 612         regs_buff[91] = adapter->stats.roc;
 613         regs_buff[92] = adapter->stats.rjc;
 614         regs_buff[93] = adapter->stats.mgprc;
 615         regs_buff[94] = adapter->stats.mgpdc;
 616         regs_buff[95] = adapter->stats.mgptc;
 617         regs_buff[96] = adapter->stats.tor;
 618         regs_buff[98] = adapter->stats.tot;
 619         regs_buff[100] = adapter->stats.tpr;
 620         regs_buff[101] = adapter->stats.tpt;
 621         regs_buff[102] = adapter->stats.ptc64;
 622         regs_buff[103] = adapter->stats.ptc127;
 623         regs_buff[104] = adapter->stats.ptc255;
 624         regs_buff[105] = adapter->stats.ptc511;
 625         regs_buff[106] = adapter->stats.ptc1023;
 626         regs_buff[107] = adapter->stats.ptc1522;
 627         regs_buff[108] = adapter->stats.mptc;
 628         regs_buff[109] = adapter->stats.bptc;
 629         regs_buff[110] = adapter->stats.tsctc;
 630         regs_buff[111] = adapter->stats.iac;
 631         regs_buff[112] = adapter->stats.rpthc;
 632         regs_buff[113] = adapter->stats.hgptc;
 633         regs_buff[114] = adapter->stats.hgorc;
 634         regs_buff[116] = adapter->stats.hgotc;
 635         regs_buff[118] = adapter->stats.lenerrs;
 636         regs_buff[119] = adapter->stats.scvpc;
 637         regs_buff[120] = adapter->stats.hrmpc;
 638
 639         for (i = 0; i < 4; i++)
 640                 regs_buff[121 + i] = E1000_READ_REG(hw, E1000_SRRCTL(i));
 641         for (i = 0; i < 4; i++)
 642                 regs_buff[125 + i] = E1000_READ_REG(hw, E1000_PSRTYPE(i));
 643         for (i = 0; i < 4; i++)
 644                 regs_buff[129 + i] = E1000_READ_REG(hw, E1000_RDBAL(i));
 645         for (i = 0; i < 4; i++)
 646                 regs_buff[133 + i] = E1000_READ_REG(hw, E1000_RDBAH(i));
 647         for (i = 0; i < 4; i++)
 648                 regs_buff[137 + i] = E1000_READ_REG(hw, E1000_RDLEN(i));
 649         for (i = 0; i < 4; i++)
 650                 regs_buff[141 + i] = E1000_READ_REG(hw, E1000_RDH(i));
 651         for (i = 0; i < 4; i++)
 652                 regs_buff[145 + i] = E1000_READ_REG(hw, E1000_RDT(i));
 653         for (i = 0; i < 4; i++)
 654                 regs_buff[149 + i] = E1000_READ_REG(hw, E1000_RXDCTL(i));
 655
 656         for (i = 0; i < 10; i++)
 657                 regs_buff[153 + i] = E1000_READ_REG(hw, E1000_EITR(i));
 658         for (i = 0; i < 8; i++)
 659                 regs_buff[163 + i] = E1000_READ_REG(hw, E1000_IMIR(i));
 660         for (i = 0; i < 8; i++)
 661                 regs_buff[171 + i] = E1000_READ_REG(hw, E1000_IMIREXT(i));
 662         for (i = 0; i < 16; i++)
 663                 regs_buff[179 + i] = E1000_READ_REG(hw, E1000_RAL(i));
 664         for (i = 0; i < 16; i++)
 665                 regs_buff[195 + i] = E1000_READ_REG(hw, E1000_RAH(i));
 666
 667         for (i = 0; i < 4; i++)
 668                 regs_buff[211 + i] = E1000_READ_REG(hw, E1000_TDBAL(i));
 669         for (i = 0; i < 4; i++)
 670                 regs_buff[215 + i] = E1000_READ_REG(hw, E1000_TDBAH(i));
 671         for (i = 0; i < 4; i++)
 672                 regs_buff[219 + i] = E1000_READ_REG(hw, E1000_TDLEN(i));
 673         for (i = 0; i < 4; i++)
 674                 regs_buff[223 + i] = E1000_READ_REG(hw, E1000_TDH(i));
 675         for (i = 0; i < 4; i++)
 676                 regs_buff[227 + i] = E1000_READ_REG(hw, E1000_TDT(i));
 677         for (i = 0; i < 4; i++)
 678                 regs_buff[231 + i] = E1000_READ_REG(hw, E1000_TXDCTL(i));
 679         for (i = 0; i < 4; i++)
 680                 regs_buff[235 + i] = E1000_READ_REG(hw, E1000_TDWBAL(i));
 681         for (i = 0; i < 4; i++)
 682                 regs_buff[239 + i] = E1000_READ_REG(hw, E1000_TDWBAH(i));
 683         for (i = 0; i < 4; i++)
 684                 regs_buff[243 + i] = E1000_READ_REG(hw, E1000_DCA_TXCTRL(i));
 685
 686         for (i = 0; i < 4; i++)
 687                 regs_buff[247 + i] = E1000_READ_REG(hw, E1000_IP4AT_REG(i));
 688         for (i = 0; i < 4; i++)
 689                 regs_buff[251 + i] = E1000_READ_REG(hw, E1000_IP6AT_REG(i));
 690         for (i = 0; i < 32; i++)
 691                 regs_buff[255 + i] = E1000_READ_REG(hw, E1000_WUPM_REG(i));
 692         for (i = 0; i < 128; i++)
 693                 regs_buff[287 + i] = E1000_READ_REG(hw, E1000_FFMT_REG(i));
 694         for (i = 0; i < 128; i++)
 695                 regs_buff[415 + i] = E1000_READ_REG(hw, E1000_FFVT_REG(i));
 696         for (i = 0; i < 4; i++)
 697                 regs_buff[543 + i] = E1000_READ_REG(hw, E1000_FFLT_REG(i));
 698
 699         regs_buff[547] = E1000_READ_REG(hw, E1000_TDFH);
 700         regs_buff[548] = E1000_READ_REG(hw, E1000_TDFT);
 701         regs_buff[549] = E1000_READ_REG(hw, E1000_TDFHS);
 702         regs_buff[550] = E1000_READ_REG(hw, E1000_TDFPC);
 703         if (hw->mac.type > e1000_82580) {
 704                 regs_buff[551] = adapter->stats.o2bgptc;
 705                 regs_buff[552] = adapter->stats.b2ospc;
 706                 regs_buff[553] = adapter->stats.o2bspc;
 707                 regs_buff[554] = adapter->stats.b2ogprc;
 708         }
 709 }
 710
 711 static int igb_get_eeprom_len(struct net_device *netdev)
 712 {
 713         struct igb_adapter *adapter = netdev_priv(netdev);
 714         return adapter->hw.nvm.word_size * 2;
 715 }
 716
 717 static int igb_get_eeprom(struct net_device *netdev,
 718                           struct ethtool_eeprom *eeprom, u8 *bytes)
 719 {
 720         struct igb_adapter *adapter = netdev_priv(netdev);
 721         struct e1000_hw *hw = &adapter->hw;
 722         u16 *eeprom_buff;
 723         int first_word, last_word;
 724         int ret_val = 0;
 725         u16 i;
 726
 727         if (eeprom->len == 0)
 728                 return -EINVAL;
 729
 730         eeprom->magic = hw->vendor_id | (hw->device_id << 16);
 731
 732         first_word = eeprom->offset >> 1;
 733         last_word = (eeprom->offset + eeprom->len - 1) >> 1;
 734
 735         eeprom_buff = kmalloc(sizeof(u16) *
 736                         (last_word - first_word + 1), GFP_KERNEL);
 737         if (!eeprom_buff)
 738                 return -ENOMEM;
 739
 740         if (hw->nvm.type == e1000_nvm_eeprom_spi)
 741                 ret_val = e1000_read_nvm(hw, first_word,
 742                                          last_word - first_word + 1,
 743                                          eeprom_buff);
 744         else {
 745                 for (i = 0; i < last_word - first_word + 1; i++) {
 746                         ret_val = e1000_read_nvm(hw, first_word + i, 1,
 747                                                  &eeprom_buff[i]);
 748                         if (ret_val)
 749                                 break;
 750                 }
 751         }
 752
 753         /* Device's eeprom is always little-endian, word addressable */
 754         for (i = 0; i < last_word - first_word + 1; i++)
 755                 eeprom_buff[i] = le16_to_cpu(eeprom_buff[i]);
 756
 757         memcpy(bytes, (u8 *)eeprom_buff + (eeprom->offset & 1),
 758                         eeprom->len);
 759         kfree(eeprom_buff);
 760
 761         return ret_val;
 762 }
 763
 764 static int igb_set_eeprom(struct net_device *netdev,
 765                           struct ethtool_eeprom *eeprom, u8 *bytes)
 766 {
 767         struct igb_adapter *adapter = netdev_priv(netdev);
 768         struct e1000_hw *hw = &adapter->hw;
 769         u16 *eeprom_buff;
 770         void *ptr;
 771         int max_len, first_word, last_word, ret_val = 0;
 772         u16 i;
 773
 774         if (eeprom->len == 0)
 775                 return -EOPNOTSUPP;
 776
 777         if (eeprom->magic != (hw->vendor_id | (hw->device_id << 16)))
 778                 return -EFAULT;
 779
 780         max_len = hw->nvm.word_size * 2;
 781
 782         first_word = eeprom->offset >> 1;
 783         last_word = (eeprom->offset + eeprom->len - 1) >> 1;
 784         eeprom_buff = kmalloc(max_len, GFP_KERNEL);
 785         if (!eeprom_buff)
 786                 return -ENOMEM;
 787
 788         ptr = (void *)eeprom_buff;
 789
 790         if (eeprom->offset & 1) {
 791                 /* need read/modify/write of first changed EEPROM word */
 792                 /* only the second byte of the word is being modified */
 793                 ret_val = e1000_read_nvm(hw, first_word, 1,
 794                                             &eeprom_buff[0]);
 795                 ptr++;
 796         }
 797         if (((eeprom->offset + eeprom->len) & 1) && (ret_val == 0)) {
 798                 /* need read/modify/write of last changed EEPROM word */
 799                 /* only the first byte of the word is being modified */
 800                 ret_val = e1000_read_nvm(hw, last_word, 1,
 801                           &eeprom_buff[last_word - first_word]);
 802         }
 803
 804         /* Device's eeprom is always little-endian, word addressable */
 805         for (i = 0; i < last_word - first_word + 1; i++)
 806                 le16_to_cpus(&eeprom_buff[i]);
 807
 808         memcpy(ptr, bytes, eeprom->len);
 809
 810         for (i = 0; i < last_word - first_word + 1; i++)
 811                 cpu_to_le16s(&eeprom_buff[i]);
 812
 813         ret_val = e1000_write_nvm(hw, first_word,
 814                                   last_word - first_word + 1, eeprom_buff);
 815
 816         /* Update the checksum if write succeeded.
 817          * and flush shadow RAM for 82573 controllers */
 818         if (ret_val == 0)
 819                 e1000_update_nvm_checksum(hw);
 820
 821         kfree(eeprom_buff);
 822         return ret_val;
 823 }
 824
 825 static void igb_get_drvinfo(struct net_device *netdev,
 826                             struct ethtool_drvinfo *drvinfo)
 827 {
 828         struct igb_adapter *adapter = netdev_priv(netdev);
 829
 830         strncpy(drvinfo->driver,  igb_driver_name, sizeof(drvinfo->driver) - 1);
 831         strncpy(drvinfo->version, igb_driver_version, sizeof(drvinfo->version) - 1);
 832
 833         strlcpy(drvinfo->fw_version, adapter->fw_version,
 834                 sizeof(drvinfo->fw_version));
 835         strlcpy(drvinfo->bus_info, pci_name(adapter->pdev),
 836                 sizeof(drvinfo->bus_info));
 837         drvinfo->n_stats = IGB_STATS_LEN;
 838         drvinfo->testinfo_len = IGB_TEST_LEN;
 839         drvinfo->regdump_len = igb_get_regs_len(netdev);
 840         drvinfo->eedump_len = igb_get_eeprom_len(netdev);
 841 }
 842
 843 static void igb_get_ringparam(struct net_device *netdev,
 844                               struct ethtool_ringparam *ring)
 845 {
 846         struct igb_adapter *adapter = netdev_priv(netdev);
 847
 848         ring->rx_max_pending = IGB_MAX_RXD;
 849         ring->tx_max_pending = IGB_MAX_TXD;
 850         ring->rx_mini_max_pending = 0;
 851         ring->rx_jumbo_max_pending = 0;
 852         ring->rx_pending = adapter->rx_ring_count;
 853         ring->tx_pending = adapter->tx_ring_count;
 854         ring->rx_mini_pending = 0;
 855         ring->rx_jumbo_pending = 0;
 856 }
 857
 858 static int igb_set_ringparam(struct net_device *netdev,
 859                              struct ethtool_ringparam *ring)
 860 {
 861         struct igb_adapter *adapter = netdev_priv(netdev);
 862         struct igb_ring *temp_ring;
 863         int i, err = 0;
 864         u16 new_rx_count, new_tx_count;
 865
 866         if ((ring->rx_mini_pending) || (ring->rx_jumbo_pending))
 867                 return -EINVAL;
 868
 869         new_rx_count = min(ring->rx_pending, (u32)IGB_MAX_RXD);
 870         new_rx_count = max(new_rx_count, (u16)IGB_MIN_RXD);
 871         new_rx_count = ALIGN(new_rx_count, REQ_RX_DESCRIPTOR_MULTIPLE);
 872
 873         new_tx_count = min(ring->tx_pending, (u32)IGB_MAX_TXD);
 874         new_tx_count = max(new_tx_count, (u16)IGB_MIN_TXD);
 875         new_tx_count = ALIGN(new_tx_count, REQ_TX_DESCRIPTOR_MULTIPLE);
 876
 877         if ((new_tx_count == adapter->tx_ring_count) &&
 878             (new_rx_count == adapter->rx_ring_count)) {
 879                 /* nothing to do */
 880                 return 0;
 881         }
 882
 883         while (test_and_set_bit(__IGB_RESETTING, &adapter->state))
 884                 usleep_range(1000, 2000);
 885
 886         if (!netif_running(adapter->netdev)) {
 887                 for (i = 0; i < adapter->num_tx_queues; i++)
 888                         adapter->tx_ring[i]->count = new_tx_count;
 889                 for (i = 0; i < adapter->num_rx_queues; i++)
 890                         adapter->rx_ring[i]->count = new_rx_count;
 891                 adapter->tx_ring_count = new_tx_count;
 892                 adapter->rx_ring_count = new_rx_count;
 893                 goto clear_reset;
 894         }
 895
 896         if (adapter->num_tx_queues > adapter->num_rx_queues)
 897                 temp_ring = vmalloc(adapter->num_tx_queues * sizeof(struct igb_ring));
 898         else
 899                 temp_ring = vmalloc(adapter->num_rx_queues * sizeof(struct igb_ring));
 900
 901         if (!temp_ring) {
 902                 err = -ENOMEM;
 903                 goto clear_reset;
 904         }
 905
 906         igb_down(adapter);
 907
 908         /*
 909          * We can't just free everything and then setup again,
 910          * because the ISRs in MSI-X mode get passed pointers
 911          * to the tx and rx ring structs.
 912          */
 913         if (new_tx_count != adapter->tx_ring_count) {
 914                 for (i = 0; i < adapter->num_tx_queues; i++) {
 915                         memcpy(&temp_ring[i], adapter->tx_ring[i],
 916                                sizeof(struct igb_ring));
 917
 918                         temp_ring[i].count = new_tx_count;
 919                         err = igb_setup_tx_resources(&temp_ring[i]);
 920                         if (err) {
 921                                 while (i) {
 922                                         i--;
 923                                         igb_free_tx_resources(&temp_ring[i]);
 924                                 }
 925                                 goto err_setup;
 926                         }
 927                 }
 928
 929                 for (i = 0; i < adapter->num_tx_queues; i++) {
 930                         igb_free_tx_resources(adapter->tx_ring[i]);
 931
 932                         memcpy(adapter->tx_ring[i], &temp_ring[i],
 933                                sizeof(struct igb_ring));
 934                 }
 935
 936                 adapter->tx_ring_count = new_tx_count;
 937         }
 938
 939         if (new_rx_count != adapter->rx_ring_count) {
 940                 for (i = 0; i < adapter->num_rx_queues; i++) {
 941                         memcpy(&temp_ring[i], adapter->rx_ring[i],
 942                                sizeof(struct igb_ring));
 943
 944                         temp_ring[i].count = new_rx_count;
 945                         err = igb_setup_rx_resources(&temp_ring[i]);
 946                         if (err) {
 947                                 while (i) {
 948                                         i--;
 949                                         igb_free_rx_resources(&temp_ring[i]);
 950                                 }
 951                                 goto err_setup;
 952                         }
 953
 954                 }
 955
 956                 for (i = 0; i < adapter->num_rx_queues; i++) {
 957                         igb_free_rx_resources(adapter->rx_ring[i]);
 958
 959                         memcpy(adapter->rx_ring[i], &temp_ring[i],
 960                                sizeof(struct igb_ring));
 961                 }
 962
 963                 adapter->rx_ring_count = new_rx_count;
 964         }
 965 err_setup:
 966         igb_up(adapter);
 967         vfree(temp_ring);
 968 clear_reset:
 969         clear_bit(__IGB_RESETTING, &adapter->state);
 970         return err;
 971 }
 972 static bool reg_pattern_test(struct igb_adapter *adapter, u64 *data,
 973                              int reg, u32 mask, u32 write)
 974 {
 975         struct e1000_hw *hw = &adapter->hw;
 976         u32 pat, val;
 977         static const u32 _test[] =
 978                 {0x5A5A5A5A, 0xA5A5A5A5, 0x00000000, 0xFFFFFFFF};
 979         for (pat = 0; pat < ARRAY_SIZE(_test); pat++) {
 980                 E1000_WRITE_REG(hw, reg, (_test[pat] & write));
 981                 val = E1000_READ_REG(hw, reg) & mask;
 982                 if (val != (_test[pat] & write & mask)) {
 983                         dev_err(pci_dev_to_dev(adapter->pdev), "pattern test reg %04X "
 984                                 "failed: got 0x%08X expected 0x%08X\n",
 985                                 E1000_REGISTER(hw, reg), val, (_test[pat] & write & mask));
 986                         *data = E1000_REGISTER(hw, reg);
 987                         return 1;
 988                 }
 989         }
 990
 991         return 0;
 992 }
 993
 994 static bool reg_set_and_check(struct igb_adapter *adapter, u64 *data,
 995                               int reg, u32 mask, u32 write)
 996 {
 997         struct e1000_hw *hw = &adapter->hw;
 998         u32 val;
 999         E1000_WRITE_REG(hw, reg, write & mask);
1000         val = E1000_READ_REG(hw, reg);
1001         if ((write & mask) != (val & mask)) {
1002                 dev_err(pci_dev_to_dev(adapter->pdev), "set/check reg %04X test failed:"
1003                         " got 0x%08X expected 0x%08X\n", reg,
1004                         (val & mask), (write & mask));
1005                 *data = E1000_REGISTER(hw, reg);
1006                 return 1;
1007         }
1008
1009         return 0;
1010 }
1011
1012 #define REG_PATTERN_TEST(reg, mask, write) \
1013         do { \
1014                 if (reg_pattern_test(adapter, data, reg, mask, write)) \
1015                         return 1; \
1016         } while (0)
1017
1018 #define REG_SET_AND_CHECK(reg, mask, write) \
1019         do { \
1020                 if (reg_set_and_check(adapter, data, reg, mask, write)) \
1021                         return 1; \
1022         } while (0)
1023
1024 static int igb_reg_test(struct igb_adapter *adapter, u64 *data)
1025 {
1026         struct e1000_hw *hw = &adapter->hw;
1027         struct igb_reg_test *test;
1028         u32 value, before, after;
1029         u32 i, toggle;
1030
1031         switch (adapter->hw.mac.type) {
1032         case e1000_i350:
1033         case e1000_i354:
1034                 test = reg_test_i350;
1035                 toggle = 0x7FEFF3FF;
1036                 break;
1037         case e1000_i210:
1038         case e1000_i211:
1039                 test = reg_test_i210;
1040                 toggle = 0x7FEFF3FF;
1041                 break;
1042         case e1000_82580:
1043                 test = reg_test_82580;
1044                 toggle = 0x7FEFF3FF;
1045                 break;
1046         case e1000_82576:
1047                 test = reg_test_82576;
1048                 toggle = 0x7FFFF3FF;
1049                 break;
1050         default:
1051                 test = reg_test_82575;
1052                 toggle = 0x7FFFF3FF;
1053                 break;
1054         }
1055
1056         /* Because the status register is such a special case,
1057          * we handle it separately from the rest of the register
1058          * tests.  Some bits are read-only, some toggle, and some
1059          * are writable on newer MACs.
1060          */
1061         before = E1000_READ_REG(hw, E1000_STATUS);
1062         value = (E1000_READ_REG(hw, E1000_STATUS) & toggle);
1063         E1000_WRITE_REG(hw, E1000_STATUS, toggle);
1064         after = E1000_READ_REG(hw, E1000_STATUS) & toggle;
1065         if (value != after) {
1066                 dev_err(pci_dev_to_dev(adapter->pdev), "failed STATUS register test "
1067                         "got: 0x%08X expected: 0x%08X\n", after, value);
1068                 *data = 1;
1069                 return 1;
1070         }
1071         /* restore previous status */
1072         E1000_WRITE_REG(hw, E1000_STATUS, before);
1073
1074         /* Perform the remainder of the register test, looping through
1075          * the test table until we either fail or reach the null entry.
1076          */
1077         while (test->reg) {
1078                 for (i = 0; i < test->array_len; i++) {
1079                         switch (test->test_type) {
1080                         case PATTERN_TEST:
1081                                 REG_PATTERN_TEST(test->reg +
1082                                                 (i * test->reg_offset),
1083                                                 test->mask,
1084                                                 test->write);
1085                                 break;
1086                         case SET_READ_TEST:
1087                                 REG_SET_AND_CHECK(test->reg +
1088                                                 (i * test->reg_offset),
1089                                                 test->mask,
1090                                                 test->write);
1091                                 break;
1092                         case WRITE_NO_TEST:
1093                                 writel(test->write,
1094                                        (adapter->hw.hw_addr + test->reg)
1095                                         + (i * test->reg_offset));
1096                                 break;
1097                         case TABLE32_TEST:
1098                                 REG_PATTERN_TEST(test->reg + (i * 4),
1099                                                 test->mask,
1100                                                 test->write);
1101                                 break;
1102                         case TABLE64_TEST_LO:
1103                                 REG_PATTERN_TEST(test->reg + (i * 8),
1104                                                 test->mask,
1105                                                 test->write);
1106                                 break;
1107                         case TABLE64_TEST_HI:
1108                                 REG_PATTERN_TEST((test->reg + 4) + (i * 8),
1109                                                 test->mask,
1110                                                 test->write);
1111                                 break;
1112                         }
1113                 }
1114                 test++;
1115         }
1116
1117         *data = 0;
1118         return 0;
1119 }
1120
1121 static int igb_eeprom_test(struct igb_adapter *adapter, u64 *data)
1122 {
1123         *data = 0;
1124
1125         /* Validate NVM checksum */
1126         if (e1000_validate_nvm_checksum(&adapter->hw) < 0)
1127                 *data = 2;
1128
1129         return *data;
1130 }
1131
1132 static irqreturn_t igb_test_intr(int irq, void *data)
1133 {
1134         struct igb_adapter *adapter = (struct igb_adapter *) data;
1135         struct e1000_hw *hw = &adapter->hw;
1136
1137         adapter->test_icr |= E1000_READ_REG(hw, E1000_ICR);
1138
1139         return IRQ_HANDLED;
1140 }
1141
1142 static int igb_intr_test(struct igb_adapter *adapter, u64 *data)
1143 {
1144         struct e1000_hw *hw = &adapter->hw;
1145         struct net_device *netdev = adapter->netdev;
1146         u32 mask, ics_mask, i = 0, shared_int = TRUE;
1147         u32 irq = adapter->pdev->irq;
1148
1149         *data = 0;
1150
1151         /* Hook up test interrupt handler just for this test */
1152         if (adapter->msix_entries) {
1153                 if (request_irq(adapter->msix_entries[0].vector,
1154                                 &igb_test_intr, 0, netdev->name, adapter)) {
1155                         *data = 1;
1156                         return -1;
1157                 }
1158         } else if (adapter->flags & IGB_FLAG_HAS_MSI) {
1159                 shared_int = FALSE;
1160                 if (request_irq(irq,
1161                                 igb_test_intr, 0, netdev->name, adapter)) {
1162                         *data = 1;
1163                         return -1;
1164                 }
1165         } else if (!request_irq(irq, igb_test_intr, IRQF_PROBE_SHARED,
1166                                 netdev->name, adapter)) {
1167                 shared_int = FALSE;
1168         } else if (request_irq(irq, &igb_test_intr, IRQF_SHARED,
1169                  netdev->name, adapter)) {
1170                 *data = 1;
1171                 return -1;
1172         }
1173         dev_info(pci_dev_to_dev(adapter->pdev), "testing %s interrupt\n",
1174                  (shared_int ? "shared" : "unshared"));
1175
1176         /* Disable all the interrupts */
1177         E1000_WRITE_REG(hw, E1000_IMC, ~0);
1178         E1000_WRITE_FLUSH(hw);
1179         usleep_range(10000, 20000);
1180
1181         /* Define all writable bits for ICS */
1182         switch (hw->mac.type) {
1183         case e1000_82575:
1184                 ics_mask = 0x37F47EDD;
1185                 break;
1186         case e1000_82576:
1187                 ics_mask = 0x77D4FBFD;
1188                 break;
1189         case e1000_82580:
1190                 ics_mask = 0x77DCFED5;
1191                 break;
1192         case e1000_i350:
1193         case e1000_i354:
1194                 ics_mask = 0x77DCFED5;
1195                 break;
1196         case e1000_i210:
1197         case e1000_i211:
1198                 ics_mask = 0x774CFED5;
1199                 break;
1200         default:
1201                 ics_mask = 0x7FFFFFFF;
1202                 break;
1203         }
1204
1205         /* Test each interrupt */
1206         for (; i < 31; i++) {
1207                 /* Interrupt to test */
1208                 mask = 1 << i;
1209
1210                 if (!(mask & ics_mask))
1211                         continue;
1212
1213                 if (!shared_int) {
1214                         /* Disable the interrupt to be reported in
1215                          * the cause register and then force the same
1216                          * interrupt and see if one gets posted.  If
1217                          * an interrupt was posted to the bus, the
1218                          * test failed.
1219                          */
1220                         adapter->test_icr = 0;
1221
1222                         /* Flush any pending interrupts */
1223                         E1000_WRITE_REG(hw, E1000_ICR, ~0);
1224
1225                         E1000_WRITE_REG(hw, E1000_IMC, mask);
1226                         E1000_WRITE_REG(hw, E1000_ICS, mask);
1227                         E1000_WRITE_FLUSH(hw);
1228                         usleep_range(10000, 20000);
1229
1230                         if (adapter->test_icr & mask) {
1231                                 *data = 3;
1232                                 break;
1233                         }
1234                 }
1235
1236                 /* Enable the interrupt to be reported in
1237                  * the cause register and then force the same
1238                  * interrupt and see if one gets posted.  If
1239                  * an interrupt was not posted to the bus, the
1240                  * test failed.
1241                  */
1242                 adapter->test_icr = 0;
1243
1244                 /* Flush any pending interrupts */
1245                 E1000_WRITE_REG(hw, E1000_ICR, ~0);
1246
1247                 E1000_WRITE_REG(hw, E1000_IMS, mask);
1248                 E1000_WRITE_REG(hw, E1000_ICS, mask);
1249                 E1000_WRITE_FLUSH(hw);
1250                 usleep_range(10000, 20000);
1251
1252                 if (!(adapter->test_icr & mask)) {
1253                         *data = 4;
1254                         break;
1255                 }
1256
1257                 if (!shared_int) {
1258                         /* Disable the other interrupts to be reported in
1259                          * the cause register and then force the other
1260                          * interrupts and see if any get posted.  If
1261                          * an interrupt was posted to the bus, the
1262                          * test failed.
1263                          */
1264                         adapter->test_icr = 0;
1265
1266                         /* Flush any pending interrupts */
1267                         E1000_WRITE_REG(hw, E1000_ICR, ~0);
1268
1269                         E1000_WRITE_REG(hw, E1000_IMC, ~mask);
1270                         E1000_WRITE_REG(hw, E1000_ICS, ~mask);
1271                         E1000_WRITE_FLUSH(hw);
1272                         usleep_range(10000, 20000);
1273
1274                         if (adapter->test_icr & mask) {
1275                                 *data = 5;
1276                                 break;
1277                         }
1278                 }
1279         }
1280
1281         /* Disable all the interrupts */
1282         E1000_WRITE_REG(hw, E1000_IMC, ~0);
1283         E1000_WRITE_FLUSH(hw);
1284         usleep_range(10000, 20000);
1285
1286         /* Unhook test interrupt handler */
1287         if (adapter->msix_entries)
1288                 free_irq(adapter->msix_entries[0].vector, adapter);
1289         else
1290                 free_irq(irq, adapter);
1291
1292         return *data;
1293 }
1294
1295 static void igb_free_desc_rings(struct igb_adapter *adapter)
1296 {
1297         igb_free_tx_resources(&adapter->test_tx_ring);
1298         igb_free_rx_resources(&adapter->test_rx_ring);
1299 }
1300
1301 static int igb_setup_desc_rings(struct igb_adapter *adapter)
1302 {
1303         struct igb_ring *tx_ring = &adapter->test_tx_ring;
1304         struct igb_ring *rx_ring = &adapter->test_rx_ring;
1305         struct e1000_hw *hw = &adapter->hw;
1306         int ret_val;
1307
1308         /* Setup Tx descriptor ring and Tx buffers */
1309         tx_ring->count = IGB_DEFAULT_TXD;
1310         tx_ring->dev = pci_dev_to_dev(adapter->pdev);
1311         tx_ring->netdev = adapter->netdev;
1312         tx_ring->reg_idx = adapter->vfs_allocated_count;
1313
1314         if (igb_setup_tx_resources(tx_ring)) {
1315                 ret_val = 1;
1316                 goto err_nomem;
1317         }
1318
1319         igb_setup_tctl(adapter);
1320         igb_configure_tx_ring(adapter, tx_ring);
1321
1322         /* Setup Rx descriptor ring and Rx buffers */
1323         rx_ring->count = IGB_DEFAULT_RXD;
1324         rx_ring->dev = pci_dev_to_dev(adapter->pdev);
1325         rx_ring->netdev = adapter->netdev;
1326 #ifdef CONFIG_IGB_DISABLE_PACKET_SPLIT
1327         rx_ring->rx_buffer_len = IGB_RX_HDR_LEN;
1328 #endif
1329         rx_ring->reg_idx = adapter->vfs_allocated_count;
1330
1331         if (igb_setup_rx_resources(rx_ring)) {
1332                 ret_val = 2;
1333                 goto err_nomem;
1334         }
1335
1336         /* set the default queue to queue 0 of PF */
1337         E1000_WRITE_REG(hw, E1000_MRQC, adapter->vfs_allocated_count << 3);
1338
1339         /* enable receive ring */
1340         igb_setup_rctl(adapter);
1341         igb_configure_rx_ring(adapter, rx_ring);
1342
1343         igb_alloc_rx_buffers(rx_ring, igb_desc_unused(rx_ring));
1344
1345         return 0;
1346
1347 err_nomem:
1348         igb_free_desc_rings(adapter);
1349         return ret_val;
1350 }
1351
1352 static void igb_phy_disable_receiver(struct igb_adapter *adapter)
1353 {
1354         struct e1000_hw *hw = &adapter->hw;
1355
1356         /* Write out to PHY registers 29 and 30 to disable the Receiver. */
1357         e1000_write_phy_reg(hw, 29, 0x001F);
1358         e1000_write_phy_reg(hw, 30, 0x8FFC);
1359         e1000_write_phy_reg(hw, 29, 0x001A);
1360         e1000_write_phy_reg(hw, 30, 0x8FF0);
1361 }
1362
1363 static int igb_integrated_phy_loopback(struct igb_adapter *adapter)
1364 {
1365         struct e1000_hw *hw = &adapter->hw;
1366         u32 ctrl_reg = 0;
1367
1368         hw->mac.autoneg = FALSE;
1369
1370         if (hw->phy.type == e1000_phy_m88) {
1371                 if (hw->phy.id != I210_I_PHY_ID) {
1372                         /* Auto-MDI/MDIX Off */
1373                         e1000_write_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, 0x0808);
1374                         /* reset to update Auto-MDI/MDIX */
1375                         e1000_write_phy_reg(hw, PHY_CONTROL, 0x9140);
1376                         /* autoneg off */
1377                         e1000_write_phy_reg(hw, PHY_CONTROL, 0x8140);
1378                 } else {
1379                         /* force 1000, set loopback  */
1380                         e1000_write_phy_reg(hw, I347AT4_PAGE_SELECT, 0);
1381                         e1000_write_phy_reg(hw, PHY_CONTROL, 0x4140);
1382                 }
1383         } else {
1384                 /* enable MII loopback */
1385                 if (hw->phy.type == e1000_phy_82580)
1386                         e1000_write_phy_reg(hw, I82577_PHY_LBK_CTRL, 0x8041);
1387         }
1388
1389         /* force 1000, set loopback  */
1390         e1000_write_phy_reg(hw, PHY_CONTROL, 0x4140);
1391
1392         /* Now set up the MAC to the same speed/duplex as the PHY. */
1393         ctrl_reg = E1000_READ_REG(hw, E1000_CTRL);
1394         ctrl_reg &= ~E1000_CTRL_SPD_SEL; /* Clear the speed sel bits */
1395         ctrl_reg |= (E1000_CTRL_FRCSPD | /* Set the Force Speed Bit */
1396                      E1000_CTRL_FRCDPX | /* Set the Force Duplex Bit */
1397                      E1000_CTRL_SPD_1000 |/* Force Speed to 1000 */
1398                      E1000_CTRL_FD |     /* Force Duplex to FULL */
1399                      E1000_CTRL_SLU);    /* Set link up enable bit */
1400
1401         if (hw->phy.type == e1000_phy_m88)
1402                 ctrl_reg |= E1000_CTRL_ILOS; /* Invert Loss of Signal */
1403
1404         E1000_WRITE_REG(hw, E1000_CTRL, ctrl_reg);
1405
1406         /* Disable the receiver on the PHY so when a cable is plugged in, the
1407          * PHY does not begin to autoneg when a cable is reconnected to the NIC.
1408          */
1409         if (hw->phy.type == e1000_phy_m88)
1410                 igb_phy_disable_receiver(adapter);
1411
1412         mdelay(500);
1413         return 0;
1414 }
1415
1416 static int igb_set_phy_loopback(struct igb_adapter *adapter)
1417 {
1418         return igb_integrated_phy_loopback(adapter);
1419 }
1420
1421 static int igb_setup_loopback_test(struct igb_adapter *adapter)
1422 {
1423         struct e1000_hw *hw = &adapter->hw;
1424         u32 reg;
1425
1426         reg = E1000_READ_REG(hw, E1000_CTRL_EXT);
1427
1428         /* use CTRL_EXT to identify link type as SGMII can appear as copper */
1429         if (reg & E1000_CTRL_EXT_LINK_MODE_MASK) {
1430                 if ((hw->device_id == E1000_DEV_ID_DH89XXCC_SGMII) ||
1431                     (hw->device_id == E1000_DEV_ID_DH89XXCC_SERDES) ||
1432                     (hw->device_id == E1000_DEV_ID_DH89XXCC_BACKPLANE) ||
1433                     (hw->device_id == E1000_DEV_ID_DH89XXCC_SFP)) {
1434
1435                         /* Enable DH89xxCC MPHY for near end loopback */
1436                         reg = E1000_READ_REG(hw, E1000_MPHY_ADDR_CTL);
1437                         reg = (reg & E1000_MPHY_ADDR_CTL_OFFSET_MASK) |
1438                                 E1000_MPHY_PCS_CLK_REG_OFFSET;
1439                         E1000_WRITE_REG(hw, E1000_MPHY_ADDR_CTL, reg);
1440
1441                         reg = E1000_READ_REG(hw, E1000_MPHY_DATA);
1442                         reg |= E1000_MPHY_PCS_CLK_REG_DIGINELBEN;
1443                         E1000_WRITE_REG(hw, E1000_MPHY_DATA, reg);
1444                 }
1445
1446                 reg = E1000_READ_REG(hw, E1000_RCTL);
1447                 reg |= E1000_RCTL_LBM_TCVR;
1448                 E1000_WRITE_REG(hw, E1000_RCTL, reg);
1449
1450                 E1000_WRITE_REG(hw, E1000_SCTL, E1000_ENABLE_SERDES_LOOPBACK);
1451
1452                 reg = E1000_READ_REG(hw, E1000_CTRL);
1453                 reg &= ~(E1000_CTRL_RFCE |
1454                          E1000_CTRL_TFCE |
1455                          E1000_CTRL_LRST);
1456                 reg |= E1000_CTRL_SLU |
1457                        E1000_CTRL_FD;
1458                 E1000_WRITE_REG(hw, E1000_CTRL, reg);
1459
1460                 /* Unset switch control to serdes energy detect */
1461                 reg = E1000_READ_REG(hw, E1000_CONNSW);
1462                 reg &= ~E1000_CONNSW_ENRGSRC;
1463                 E1000_WRITE_REG(hw, E1000_CONNSW, reg);
1464
1465                 /* Unset sigdetect for SERDES loopback on
1466                  * 82580 and newer devices
1467                  */
1468                 if (hw->mac.type >= e1000_82580) {
1469                         reg = E1000_READ_REG(hw, E1000_PCS_CFG0);
1470                         reg |= E1000_PCS_CFG_IGN_SD;
1471                         E1000_WRITE_REG(hw, E1000_PCS_CFG0, reg);
1472                 }
1473
1474                 /* Set PCS register for forced speed */
1475                 reg = E1000_READ_REG(hw, E1000_PCS_LCTL);
1476                 reg &= ~E1000_PCS_LCTL_AN_ENABLE;     /* Disable Autoneg*/
1477                 reg |= E1000_PCS_LCTL_FLV_LINK_UP |   /* Force link up */
1478                        E1000_PCS_LCTL_FSV_1000 |      /* Force 1000    */
1479                        E1000_PCS_LCTL_FDV_FULL |      /* SerDes Full duplex */
1480                        E1000_PCS_LCTL_FSD |           /* Force Speed */
1481                        E1000_PCS_LCTL_FORCE_LINK;     /* Force Link */
1482                 E1000_WRITE_REG(hw, E1000_PCS_LCTL, reg);
1483
1484                 return 0;
1485         }
1486
1487         return igb_set_phy_loopback(adapter);
1488 }
1489
1490 static void igb_loopback_cleanup(struct igb_adapter *adapter)
1491 {
1492         struct e1000_hw *hw = &adapter->hw;
1493         u32 rctl;
1494         u16 phy_reg;
1495
1496         if ((hw->device_id == E1000_DEV_ID_DH89XXCC_SGMII) ||
1497             (hw->device_id == E1000_DEV_ID_DH89XXCC_SERDES) ||
1498             (hw->device_id == E1000_DEV_ID_DH89XXCC_BACKPLANE) ||
1499             (hw->device_id == E1000_DEV_ID_DH89XXCC_SFP)) {
1500                 u32 reg;
1501
1502                 /* Disable near end loopback on DH89xxCC */
1503                 reg = E1000_READ_REG(hw, E1000_MPHY_ADDR_CTL);
1504                 reg = (reg & E1000_MPHY_ADDR_CTL_OFFSET_MASK ) |
1505                         E1000_MPHY_PCS_CLK_REG_OFFSET;
1506         E1000_WRITE_REG(hw, E1000_MPHY_ADDR_CTL, reg);
1507
1508                 reg = E1000_READ_REG(hw, E1000_MPHY_DATA);
1509         reg &= ~E1000_MPHY_PCS_CLK_REG_DIGINELBEN;
1510         E1000_WRITE_REG(hw, E1000_MPHY_DATA, reg);
1511         }
1512
1513         rctl = E1000_READ_REG(hw, E1000_RCTL);
1514         rctl &= ~(E1000_RCTL_LBM_TCVR | E1000_RCTL_LBM_MAC);
1515         E1000_WRITE_REG(hw, E1000_RCTL, rctl);
1516
1517         hw->mac.autoneg = TRUE;
1518         e1000_read_phy_reg(hw, PHY_CONTROL, &phy_reg);
1519         if (phy_reg & MII_CR_LOOPBACK) {
1520                 phy_reg &= ~MII_CR_LOOPBACK;
1521                 if (hw->phy.type == I210_I_PHY_ID)
1522                         e1000_write_phy_reg(hw, I347AT4_PAGE_SELECT, 0);
1523                 e1000_write_phy_reg(hw, PHY_CONTROL, phy_reg);
1524                 e1000_phy_commit(hw);
1525         }
1526 }
1527 static void igb_create_lbtest_frame(struct sk_buff *skb,
1528                                     unsigned int frame_size)
1529 {
1530         memset(skb->data, 0xFF, frame_size);
1531         frame_size /= 2;
1532         memset(&skb->data[frame_size], 0xAA, frame_size - 1);
1533         memset(&skb->data[frame_size + 10], 0xBE, 1);
1534         memset(&skb->data[frame_size + 12], 0xAF, 1);
1535 }
1536
1537 static int igb_check_lbtest_frame(struct igb_rx_buffer *rx_buffer,
1538                                   unsigned int frame_size)
1539 {
1540         unsigned char *data;
1541         bool match = true;
1542
1543         frame_size >>= 1;
1544
1545 #ifdef CONFIG_IGB_DISABLE_PACKET_SPLIT
1546         data = rx_buffer->skb->data;
1547 #else
1548         data = kmap(rx_buffer->page);
1549 #endif
1550
1551         if (data[3] != 0xFF ||
1552             data[frame_size + 10] != 0xBE ||
1553             data[frame_size + 12] != 0xAF)
1554                 match = false;
1555
1556 #ifndef CONFIG_IGB_DISABLE_PACKET_SPLIT
1557         kunmap(rx_buffer->page);
1558
1559 #endif
1560         return match;
1561 }
1562
1563 static u16 igb_clean_test_rings(struct igb_ring *rx_ring,
1564                                 struct igb_ring *tx_ring,
1565                                 unsigned int size)
1566 {
1567         union e1000_adv_rx_desc *rx_desc;
1568         struct igb_rx_buffer *rx_buffer_info;
1569         struct igb_tx_buffer *tx_buffer_info;
1570         u16 rx_ntc, tx_ntc, count = 0;
1571
1572         /* initialize next to clean and descriptor values */
1573         rx_ntc = rx_ring->next_to_clean;
1574         tx_ntc = tx_ring->next_to_clean;
1575         rx_desc = IGB_RX_DESC(rx_ring, rx_ntc);
1576
1577         while (igb_test_staterr(rx_desc, E1000_RXD_STAT_DD)) {
1578                 /* check rx buffer */
1579                 rx_buffer_info = &rx_ring->rx_buffer_info[rx_ntc];
1580
1581                 /* sync Rx buffer for CPU read */
1582                 dma_sync_single_for_cpu(rx_ring->dev,
1583                                         rx_buffer_info->dma,
1584 #ifdef CONFIG_IGB_DISABLE_PACKET_SPLIT
1585                                         IGB_RX_HDR_LEN,
1586 #else
1587                                         IGB_RX_BUFSZ,
1588 #endif
1589                                         DMA_FROM_DEVICE);
1590
1591                 /* verify contents of skb */
1592                 if (igb_check_lbtest_frame(rx_buffer_info, size))
1593                         count++;
1594
1595                 /* sync Rx buffer for device write */
1596                 dma_sync_single_for_device(rx_ring->dev,
1597                                            rx_buffer_info->dma,
1598 #ifdef CONFIG_IGB_DISABLE_PACKET_SPLIT
1599                                            IGB_RX_HDR_LEN,
1600 #else
1601                                            IGB_RX_BUFSZ,
1602 #endif
1603                                            DMA_FROM_DEVICE);
1604
1605                 /* unmap buffer on tx side */
1606                 tx_buffer_info = &tx_ring->tx_buffer_info[tx_ntc];
1607                 igb_unmap_and_free_tx_resource(tx_ring, tx_buffer_info);
1608
1609                 /* increment rx/tx next to clean counters */
1610                 rx_ntc++;
1611                 if (rx_ntc == rx_ring->count)
1612                         rx_ntc = 0;
1613                 tx_ntc++;
1614                 if (tx_ntc == tx_ring->count)
1615                         tx_ntc = 0;
1616
1617                 /* fetch next descriptor */
1618                 rx_desc = IGB_RX_DESC(rx_ring, rx_ntc);
1619         }
1620
1621         /* re-map buffers to ring, store next to clean values */
1622         igb_alloc_rx_buffers(rx_ring, count);
1623         rx_ring->next_to_clean = rx_ntc;
1624         tx_ring->next_to_clean = tx_ntc;
1625
1626         return count;
1627 }
1628
1629 static int igb_run_loopback_test(struct igb_adapter *adapter)
1630 {
1631         struct igb_ring *tx_ring = &adapter->test_tx_ring;
1632         struct igb_ring *rx_ring = &adapter->test_rx_ring;
1633         u16 i, j, lc, good_cnt;
1634         int ret_val = 0;
1635         unsigned int size = IGB_RX_HDR_LEN;
1636         netdev_tx_t tx_ret_val;
1637         struct sk_buff *skb;
1638
1639         /* allocate test skb */
1640         skb = alloc_skb(size, GFP_KERNEL);
1641         if (!skb)
1642                 return 11;
1643
1644         /* place data into test skb */
1645         igb_create_lbtest_frame(skb, size);
1646         skb_put(skb, size);
1647
1648         /*
1649          * Calculate the loop count based on the largest descriptor ring
1650          * The idea is to wrap the largest ring a number of times using 64
1651          * send/receive pairs during each loop
1652          */
1653
1654         if (rx_ring->count <= tx_ring->count)
1655                 lc = ((tx_ring->count / 64) * 2) + 1;
1656         else
1657                 lc = ((rx_ring->count / 64) * 2) + 1;
1658
1659         for (j = 0; j <= lc; j++) { /* loop count loop */
1660                 /* reset count of good packets */
1661                 good_cnt = 0;
1662
1663                 /* place 64 packets on the transmit queue*/
1664                 for (i = 0; i < 64; i++) {
1665                         skb_get(skb);
1666                         tx_ret_val = igb_xmit_frame_ring(skb, tx_ring);
1667                         if (tx_ret_val == NETDEV_TX_OK)
1668                                 good_cnt++;
1669                 }
1670
1671                 if (good_cnt != 64) {
1672                         ret_val = 12;
1673                         break;
1674                 }
1675
1676                 /* allow 200 milliseconds for packets to go from tx to rx */
1677                 msleep(200);
1678
1679                 good_cnt = igb_clean_test_rings(rx_ring, tx_ring, size);
1680                 if (good_cnt != 64) {
1681                         ret_val = 13;
1682                         break;
1683                 }
1684         } /* end loop count loop */
1685
1686         /* free the original skb */
1687         kfree_skb(skb);
1688
1689         return ret_val;
1690 }
1691
1692 static int igb_loopback_test(struct igb_adapter *adapter, u64 *data)
1693 {
1694         /* PHY loopback cannot be performed if SoL/IDER
1695          * sessions are active */
1696         if (e1000_check_reset_block(&adapter->hw)) {
1697                 dev_err(pci_dev_to_dev(adapter->pdev),
1698                         "Cannot do PHY loopback test "
1699                         "when SoL/IDER is active.\n");
1700                 *data = 0;
1701                 goto out;
1702         }
1703         if (adapter->hw.mac.type == e1000_i354) {
1704                 dev_info(&adapter->pdev->dev,
1705                         "Loopback test not supported on i354.\n");
1706                 *data = 0;
1707                 goto out;
1708         }
1709         *data = igb_setup_desc_rings(adapter);
1710         if (*data)
1711                 goto out;
1712         *data = igb_setup_loopback_test(adapter);
1713         if (*data)
1714                 goto err_loopback;
1715         *data = igb_run_loopback_test(adapter);
1716
1717         igb_loopback_cleanup(adapter);
1718
1719 err_loopback:
1720         igb_free_desc_rings(adapter);
1721 out:
1722         return *data;
1723 }
1724
1725 static int igb_link_test(struct igb_adapter *adapter, u64 *data)
1726 {
1727         u32 link;
1728         int i, time;
1729
1730         *data = 0;
1731         time = 0;
1732         if (adapter->hw.phy.media_type == e1000_media_type_internal_serdes) {
1733                 int i = 0;
1734                 adapter->hw.mac.serdes_has_link = FALSE;
1735
1736                 /* On some blade server designs, link establishment
1737                  * could take as long as 2-3 minutes */
1738                 do {
1739                         e1000_check_for_link(&adapter->hw);
1740                         if (adapter->hw.mac.serdes_has_link)
1741                                 goto out;
1742                         msleep(20);
1743                 } while (i++ < 3750);
1744
1745                 *data = 1;
1746         } else {
1747                 for (i=0; i < IGB_MAX_LINK_TRIES; i++) {
1748                 link = igb_has_link(adapter);
1749                         if (link)
1750                                 goto out;
1751                         else {
1752                                 time++;
1753                                 msleep(1000);
1754                         }
1755                 }
1756                 if (!link)
1757                         *data = 1;
1758         }
1759         out:
1760                 return *data;
1761 }
1762
1763 static void igb_diag_test(struct net_device *netdev,
1764                           struct ethtool_test *eth_test, u64 *data)
1765 {
1766         struct igb_adapter *adapter = netdev_priv(netdev);
1767         u16 autoneg_advertised;
1768         u8 forced_speed_duplex, autoneg;
1769         bool if_running = netif_running(netdev);
1770
1771         set_bit(__IGB_TESTING, &adapter->state);
1772         if (eth_test->flags == ETH_TEST_FL_OFFLINE) {
1773                 /* Offline tests */
1774
1775                 /* save speed, duplex, autoneg settings */
1776                 autoneg_advertised = adapter->hw.phy.autoneg_advertised;
1777                 forced_speed_duplex = adapter->hw.mac.forced_speed_duplex;
1778                 autoneg = adapter->hw.mac.autoneg;
1779
1780                 dev_info(pci_dev_to_dev(adapter->pdev), "offline testing starting\n");
1781
1782                 /* power up link for link test */
1783                 igb_power_up_link(adapter);
1784
1785                 /* Link test performed before hardware reset so autoneg doesn't
1786                  * interfere with test result */
1787                 if (igb_link_test(adapter, &data[4]))
1788                         eth_test->flags |= ETH_TEST_FL_FAILED;
1789
1790                 if (if_running)
1791                         /* indicate we're in test mode */
1792                         dev_close(netdev);
1793                 else
1794                         igb_reset(adapter);
1795
1796                 if (igb_reg_test(adapter, &data[0]))
1797                         eth_test->flags |= ETH_TEST_FL_FAILED;
1798
1799                 igb_reset(adapter);
1800                 if (igb_eeprom_test(adapter, &data[1]))
1801                         eth_test->flags |= ETH_TEST_FL_FAILED;
1802
1803                 igb_reset(adapter);
1804                 if (igb_intr_test(adapter, &data[2]))
1805                         eth_test->flags |= ETH_TEST_FL_FAILED;
1806
1807                 igb_reset(adapter);
1808
1809                 /* power up link for loopback test */
1810                 igb_power_up_link(adapter);
1811
1812                 if (igb_loopback_test(adapter, &data[3]))
1813                         eth_test->flags |= ETH_TEST_FL_FAILED;
1814
1815                 /* restore speed, duplex, autoneg settings */
1816                 adapter->hw.phy.autoneg_advertised = autoneg_advertised;
1817                 adapter->hw.mac.forced_speed_duplex = forced_speed_duplex;
1818                 adapter->hw.mac.autoneg = autoneg;
1819
1820                 /* force this routine to wait until autoneg complete/timeout */
1821                 adapter->hw.phy.autoneg_wait_to_complete = TRUE;
1822                 igb_reset(adapter);
1823                 adapter->hw.phy.autoneg_wait_to_complete = FALSE;
1824
1825                 clear_bit(__IGB_TESTING, &adapter->state);
1826                 if (if_running)
1827                         dev_open(netdev);
1828         } else {
1829                 dev_info(pci_dev_to_dev(adapter->pdev), "online testing starting\n");
1830
1831                 /* PHY is powered down when interface is down */
1832                 if (if_running && igb_link_test(adapter, &data[4]))
1833                         eth_test->flags |= ETH_TEST_FL_FAILED;
1834                 else
1835                         data[4] = 0;
1836
1837                 /* Online tests aren't run; pass by default */
1838                 data[0] = 0;
1839                 data[1] = 0;
1840                 data[2] = 0;
1841                 data[3] = 0;
1842
1843                 clear_bit(__IGB_TESTING, &adapter->state);
1844         }
1845         msleep_interruptible(4 * 1000);
1846 }
1847
1848 static void igb_get_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)
1849 {
1850         struct igb_adapter *adapter = netdev_priv(netdev);
1851
1852         wol->supported = WAKE_UCAST | WAKE_MCAST |
1853                          WAKE_BCAST | WAKE_MAGIC |
1854                          WAKE_PHY;
1855         wol->wolopts = 0;
1856
1857         if (!(adapter->flags & IGB_FLAG_WOL_SUPPORTED))
1858                 return;
1859
1860         /* apply any specific unsupported masks here */
1861         switch (adapter->hw.device_id) {
1862         default:
1863                 break;
1864         }
1865
1866         if (adapter->wol & E1000_WUFC_EX)
1867                 wol->wolopts |= WAKE_UCAST;
1868         if (adapter->wol & E1000_WUFC_MC)
1869                 wol->wolopts |= WAKE_MCAST;
1870         if (adapter->wol & E1000_WUFC_BC)
1871                 wol->wolopts |= WAKE_BCAST;
1872         if (adapter->wol & E1000_WUFC_MAG)
1873                 wol->wolopts |= WAKE_MAGIC;
1874         if (adapter->wol & E1000_WUFC_LNKC)
1875                 wol->wolopts |= WAKE_PHY;
1876 }
1877
1878 static int igb_set_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)
1879 {
1880         struct igb_adapter *adapter = netdev_priv(netdev);
1881
1882         if (wol->wolopts & (WAKE_ARP | WAKE_MAGICSECURE))
1883                 return -EOPNOTSUPP;
1884
1885         if (!(adapter->flags & IGB_FLAG_WOL_SUPPORTED))
1886                 return wol->wolopts ? -EOPNOTSUPP : 0;
1887
1888         /* these settings will always override what we currently have */
1889         adapter->wol = 0;
1890
1891         if (wol->wolopts & WAKE_UCAST)
1892                 adapter->wol |= E1000_WUFC_EX;
1893         if (wol->wolopts & WAKE_MCAST)
1894                 adapter->wol |= E1000_WUFC_MC;
1895         if (wol->wolopts & WAKE_BCAST)
1896                 adapter->wol |= E1000_WUFC_BC;
1897         if (wol->wolopts & WAKE_MAGIC)
1898                 adapter->wol |= E1000_WUFC_MAG;
1899         if (wol->wolopts & WAKE_PHY)
1900                 adapter->wol |= E1000_WUFC_LNKC;
1901         device_set_wakeup_enable(&adapter->pdev->dev, adapter->wol);
1902
1903         return 0;
1904 }
1905
1906 /* bit defines for adapter->led_status */
1907 #ifdef HAVE_ETHTOOL_SET_PHYS_ID
1908 static int igb_set_phys_id(struct net_device *netdev,
1909                            enum ethtool_phys_id_state state)
1910 {
1911         struct igb_adapter *adapter = netdev_priv(netdev);
1912         struct e1000_hw *hw = &adapter->hw;
1913
1914         switch (state) {
1915         case ETHTOOL_ID_ACTIVE:
1916                 e1000_blink_led(hw);
1917                 return 2;
1918         case ETHTOOL_ID_ON:
1919                 e1000_led_on(hw);
1920                 break;
1921         case ETHTOOL_ID_OFF:
1922                 e1000_led_off(hw);
1923                 break;
1924         case ETHTOOL_ID_INACTIVE:
1925                 e1000_led_off(hw);
1926                 e1000_cleanup_led(hw);
1927                 break;
1928         }
1929
1930         return 0;
1931 }
1932 #else
1933 static int igb_phys_id(struct net_device *netdev, u32 data)
1934 {
1935         struct igb_adapter *adapter = netdev_priv(netdev);
1936         struct e1000_hw *hw = &adapter->hw;
1937         unsigned long timeout;
1938
1939         timeout = data * 1000;
1940
1941         /*
1942          *  msleep_interruptable only accepts unsigned int so we are limited
1943          * in how long a duration we can wait
1944          */
1945         if (!timeout || timeout > UINT_MAX)
1946                 timeout = UINT_MAX;
1947
1948         e1000_blink_led(hw);
1949         msleep_interruptible(timeout);
1950
1951         e1000_led_off(hw);
1952         e1000_cleanup_led(hw);
1953
1954         return 0;
1955 }
1956 #endif /* HAVE_ETHTOOL_SET_PHYS_ID */
1957
1958 static int igb_set_coalesce(struct net_device *netdev,
1959                             struct ethtool_coalesce *ec)
1960 {
1961         struct igb_adapter *adapter = netdev_priv(netdev);
1962         int i;
1963
1964         if ((ec->rx_coalesce_usecs > IGB_MAX_ITR_USECS) ||
1965             ((ec->rx_coalesce_usecs > 3) &&
1966              (ec->rx_coalesce_usecs < IGB_MIN_ITR_USECS)) ||
1967             (ec->rx_coalesce_usecs == 2))
1968             {
1969                 printk("set_coalesce:invalid parameter..");
1970                 return -EINVAL;
1971         }
1972
1973         if ((ec->tx_coalesce_usecs > IGB_MAX_ITR_USECS) ||
1974             ((ec->tx_coalesce_usecs > 3) &&
1975              (ec->tx_coalesce_usecs < IGB_MIN_ITR_USECS)) ||
1976             (ec->tx_coalesce_usecs == 2))
1977                 return -EINVAL;
1978
1979         if ((adapter->flags & IGB_FLAG_QUEUE_PAIRS) && ec->tx_coalesce_usecs)
1980                 return -EINVAL;
1981
1982         if (ec->tx_max_coalesced_frames_irq)
1983                 adapter->tx_work_limit = ec->tx_max_coalesced_frames_irq;
1984
1985         /* If ITR is disabled, disable DMAC */
1986         if (ec->rx_coalesce_usecs == 0) {
1987                 adapter->dmac = IGB_DMAC_DISABLE;
1988         }
1989
1990         /* convert to rate of irq's per second */
1991         if (ec->rx_coalesce_usecs && ec->rx_coalesce_usecs <= 3)
1992                 adapter->rx_itr_setting = ec->rx_coalesce_usecs;
1993         else
1994                 adapter->rx_itr_setting = ec->rx_coalesce_usecs << 2;
1995
1996         /* convert to rate of irq's per second */
1997         if (adapter->flags & IGB_FLAG_QUEUE_PAIRS)
1998                 adapter->tx_itr_setting = adapter->rx_itr_setting;
1999         else if (ec->tx_coalesce_usecs && ec->tx_coalesce_usecs <= 3)
2000                 adapter->tx_itr_setting = ec->tx_coalesce_usecs;
2001         else
2002                 adapter->tx_itr_setting = ec->tx_coalesce_usecs << 2;
2003
2004         for (i = 0; i < adapter->num_q_vectors; i++) {
2005                 struct igb_q_vector *q_vector = adapter->q_vector[i];
2006                 q_vector->tx.work_limit = adapter->tx_work_limit;
2007                 if (q_vector->rx.ring)
2008                         q_vector->itr_val = adapter->rx_itr_setting;
2009                 else
2010                         q_vector->itr_val = adapter->tx_itr_setting;
2011                 if (q_vector->itr_val && q_vector->itr_val <= 3)
2012                         q_vector->itr_val = IGB_START_ITR;
2013                 q_vector->set_itr = 1;
2014         }
2015
2016         return 0;
2017 }
2018
2019 static int igb_get_coalesce(struct net_device *netdev,
2020                             struct ethtool_coalesce *ec)
2021 {
2022         struct igb_adapter *adapter = netdev_priv(netdev);
2023
2024         if (adapter->rx_itr_setting <= 3)
2025                 ec->rx_coalesce_usecs = adapter->rx_itr_setting;
2026         else
2027                 ec->rx_coalesce_usecs = adapter->rx_itr_setting >> 2;
2028
2029         ec->tx_max_coalesced_frames_irq = adapter->tx_work_limit;
2030
2031         if (!(adapter->flags & IGB_FLAG_QUEUE_PAIRS)) {
2032                 if (adapter->tx_itr_setting <= 3)
2033                         ec->tx_coalesce_usecs = adapter->tx_itr_setting;
2034                 else
2035                         ec->tx_coalesce_usecs = adapter->tx_itr_setting >> 2;
2036         }
2037
2038         return 0;
2039 }
2040
2041 static int igb_nway_reset(struct net_device *netdev)
2042 {
2043         struct igb_adapter *adapter = netdev_priv(netdev);
2044         if (netif_running(netdev))
2045                 igb_reinit_locked(adapter);
2046         return 0;
2047 }
2048
2049 #ifdef HAVE_ETHTOOL_GET_SSET_COUNT
2050 static int igb_get_sset_count(struct net_device *netdev, int sset)
2051 {
2052         switch (sset) {
2053         case ETH_SS_STATS:
2054                 return IGB_STATS_LEN;
2055         case ETH_SS_TEST:
2056                 return IGB_TEST_LEN;
2057         default:
2058                 return -ENOTSUPP;
2059         }
2060 }
2061 #else
2062 static int igb_get_stats_count(struct net_device *netdev)
2063 {
2064         return IGB_STATS_LEN;
2065 }
2066
2067 static int igb_diag_test_count(struct net_device *netdev)
2068 {
2069         return IGB_TEST_LEN;
2070 }
2071 #endif
2072
2073 static void igb_get_ethtool_stats(struct net_device *netdev,
2074                                   struct ethtool_stats *stats, u64 *data)
2075 {
2076         struct igb_adapter *adapter = netdev_priv(netdev);
2077 #ifdef HAVE_NETDEV_STATS_IN_NETDEV
2078         struct net_device_stats *net_stats = &netdev->stats;
2079 #else
2080         struct net_device_stats *net_stats = &adapter->net_stats;
2081 #endif
2082         u64 *queue_stat;
2083         int i, j, k;
2084         char *p;
2085
2086         igb_update_stats(adapter);
2087
2088         for (i = 0; i < IGB_GLOBAL_STATS_LEN; i++) {
2089                 p = (char *)adapter + igb_gstrings_stats[i].stat_offset;
2090                 data[i] = (igb_gstrings_stats[i].sizeof_stat ==
2091                         sizeof(u64)) ? *(u64 *)p : *(u32 *)p;
2092         }
2093         for (j = 0; j < IGB_NETDEV_STATS_LEN; j++, i++) {
2094                 p = (char *)net_stats + igb_gstrings_net_stats[j].stat_offset;
2095                 data[i] = (igb_gstrings_net_stats[j].sizeof_stat ==
2096                         sizeof(u64)) ? *(u64 *)p : *(u32 *)p;
2097         }
2098         for (j = 0; j < adapter->num_tx_queues; j++) {
2099                 queue_stat = (u64 *)&adapter->tx_ring[j]->tx_stats;
2100                 for (k = 0; k < IGB_TX_QUEUE_STATS_LEN; k++, i++)
2101                         data[i] = queue_stat[k];
2102         }
2103         for (j = 0; j < adapter->num_rx_queues; j++) {
2104                 queue_stat = (u64 *)&adapter->rx_ring[j]->rx_stats;
2105                 for (k = 0; k < IGB_RX_QUEUE_STATS_LEN; k++, i++)
2106                         data[i] = queue_stat[k];
2107         }
2108 }
2109
2110 static void igb_get_strings(struct net_device *netdev, u32 stringset, u8 *data)
2111 {
2112         struct igb_adapter *adapter = netdev_priv(netdev);
2113         u8 *p = data;
2114         int i;
2115
2116         switch (stringset) {
2117         case ETH_SS_TEST:
2118                 memcpy(data, *igb_gstrings_test,
2119                         IGB_TEST_LEN*ETH_GSTRING_LEN);
2120                 break;
2121         case ETH_SS_STATS:
2122                 for (i = 0; i < IGB_GLOBAL_STATS_LEN; i++) {
2123                         memcpy(p, igb_gstrings_stats[i].stat_string,
2124                                ETH_GSTRING_LEN);
2125                         p += ETH_GSTRING_LEN;
2126                 }
2127                 for (i = 0; i < IGB_NETDEV_STATS_LEN; i++) {
2128                         memcpy(p, igb_gstrings_net_stats[i].stat_string,
2129                                ETH_GSTRING_LEN);
2130                         p += ETH_GSTRING_LEN;
2131                 }
2132                 for (i = 0; i < adapter->num_tx_queues; i++) {
2133                         sprintf(p, "tx_queue_%u_packets", i);
2134                         p += ETH_GSTRING_LEN;
2135                         sprintf(p, "tx_queue_%u_bytes", i);
2136                         p += ETH_GSTRING_LEN;
2137                         sprintf(p, "tx_queue_%u_restart", i);
2138                         p += ETH_GSTRING_LEN;
2139                 }
2140                 for (i = 0; i < adapter->num_rx_queues; i++) {
2141                         sprintf(p, "rx_queue_%u_packets", i);
2142                         p += ETH_GSTRING_LEN;
2143                         sprintf(p, "rx_queue_%u_bytes", i);
2144                         p += ETH_GSTRING_LEN;
2145                         sprintf(p, "rx_queue_%u_drops", i);
2146                         p += ETH_GSTRING_LEN;
2147                         sprintf(p, "rx_queue_%u_csum_err", i);
2148                         p += ETH_GSTRING_LEN;
2149                         sprintf(p, "rx_queue_%u_alloc_failed", i);
2150                         p += ETH_GSTRING_LEN;
2151                         sprintf(p, "rx_queue_%u_ipv4_packets", i);
2152                         p += ETH_GSTRING_LEN;
2153                         sprintf(p, "rx_queue_%u_ipv4e_packets", i);
2154                         p += ETH_GSTRING_LEN;
2155                         sprintf(p, "rx_queue_%u_ipv6_packets", i);
2156                         p += ETH_GSTRING_LEN;
2157                         sprintf(p, "rx_queue_%u_ipv6e_packets", i);
2158                         p += ETH_GSTRING_LEN;
2159                         sprintf(p, "rx_queue_%u_tcp_packets", i);
2160                         p += ETH_GSTRING_LEN;
2161                         sprintf(p, "rx_queue_%u_udp_packets", i);
2162                         p += ETH_GSTRING_LEN;
2163                         sprintf(p, "rx_queue_%u_sctp_packets", i);
2164                         p += ETH_GSTRING_LEN;
2165                         sprintf(p, "rx_queue_%u_nfs_packets", i);
2166                         p += ETH_GSTRING_LEN;
2167                 }
2168 /*              BUG_ON(p - data != IGB_STATS_LEN * ETH_GSTRING_LEN); */
2169                 break;
2170         }
2171 }
2172
2173 #ifdef HAVE_ETHTOOL_GET_TS_INFO
2174 static int igb_get_ts_info(struct net_device *dev,
2175                            struct ethtool_ts_info *info)
2176 {
2177         struct igb_adapter *adapter = netdev_priv(dev);
2178
2179         switch (adapter->hw.mac.type) {
2180 #ifdef HAVE_PTP_1588_CLOCK
2181         case e1000_82575:
2182                 info->so_timestamping =
2183                         SOF_TIMESTAMPING_TX_SOFTWARE |
2184                         SOF_TIMESTAMPING_RX_SOFTWARE |
2185                         SOF_TIMESTAMPING_SOFTWARE;
2186                 return 0;
2187         case e1000_82576:
2188         case e1000_82580:
2189         case e1000_i350:
2190         case e1000_i354:
2191         case e1000_i210:
2192         case e1000_i211:
2193                 info->so_timestamping =
2194                         SOF_TIMESTAMPING_TX_SOFTWARE |
2195                         SOF_TIMESTAMPING_RX_SOFTWARE |
2196                         SOF_TIMESTAMPING_SOFTWARE |
2197                         SOF_TIMESTAMPING_TX_HARDWARE |
2198                         SOF_TIMESTAMPING_RX_HARDWARE |
2199                         SOF_TIMESTAMPING_RAW_HARDWARE;
2200
2201                 if (adapter->ptp_clock)
2202                         info->phc_index = ptp_clock_index(adapter->ptp_clock);
2203                 else
2204                         info->phc_index = -1;
2205
2206                 info->tx_types =
2207                         (1 << HWTSTAMP_TX_OFF) |
2208                         (1 << HWTSTAMP_TX_ON);
2209
2210                 info->rx_filters = 1 << HWTSTAMP_FILTER_NONE;
2211
2212                 /* 82576 does not support timestamping all packets. */
2213                 if (adapter->hw.mac.type >= e1000_82580)
2214                         info->rx_filters |= 1 << HWTSTAMP_FILTER_ALL;
2215                 else
2216                         info->rx_filters |=
2217                                 (1 << HWTSTAMP_FILTER_PTP_V1_L4_SYNC) |
2218                                 (1 << HWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQ) |
2219                                 (1 << HWTSTAMP_FILTER_PTP_V2_L2_SYNC) |
2220                                 (1 << HWTSTAMP_FILTER_PTP_V2_L4_SYNC) |
2221                                 (1 << HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ) |
2222                                 (1 << HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ) |
2223                                 (1 << HWTSTAMP_FILTER_PTP_V2_EVENT);
2224
2225                 return 0;
2226 #endif /* HAVE_PTP_1588_CLOCK */
2227         default:
2228                 return -EOPNOTSUPP;
2229         }
2230 }
2231 #endif /* HAVE_ETHTOOL_GET_TS_INFO */
2232
2233 #ifdef CONFIG_PM_RUNTIME
2234 static int igb_ethtool_begin(struct net_device *netdev)
2235 {
2236         struct igb_adapter *adapter = netdev_priv(netdev);
2237
2238         pm_runtime_get_sync(&adapter->pdev->dev);
2239
2240         return 0;
2241 }
2242
2243 static void igb_ethtool_complete(struct net_device *netdev)
2244 {
2245         struct igb_adapter *adapter = netdev_priv(netdev);
2246
2247         pm_runtime_put(&adapter->pdev->dev);
2248 }
2249 #endif /* CONFIG_PM_RUNTIME */
2250
2251 #ifndef HAVE_NDO_SET_FEATURES
2252 static u32 igb_get_rx_csum(struct net_device *netdev)
2253 {
2254         return !!(netdev->features & NETIF_F_RXCSUM);
2255 }
2256
2257 static int igb_set_rx_csum(struct net_device *netdev, u32 data)
2258 {
2259         const u32 feature_list = NETIF_F_RXCSUM;
2260
2261         if (data)
2262                 netdev->features |= feature_list;
2263         else
2264                 netdev->features &= ~feature_list;
2265
2266         return 0;
2267 }
2268
2269 static int igb_set_tx_csum(struct net_device *netdev, u32 data)
2270 {
2271         struct igb_adapter *adapter = netdev_priv(netdev);
2272 #ifdef NETIF_F_IPV6_CSUM
2273         u32 feature_list = NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
2274 #else
2275         u32 feature_list = NETIF_F_IP_CSUM;
2276 #endif
2277
2278         if (adapter->hw.mac.type >= e1000_82576)
2279                 feature_list |= NETIF_F_SCTP_CSUM;
2280
2281         if (data)
2282                 netdev->features |= feature_list;
2283         else
2284                 netdev->features &= ~feature_list;
2285
2286         return 0;
2287 }
2288
2289 #ifdef NETIF_F_TSO
2290 static int igb_set_tso(struct net_device *netdev, u32 data)
2291 {
2292 #ifdef NETIF_F_TSO6
2293         const u32 feature_list = NETIF_F_TSO | NETIF_F_TSO6;
2294 #else
2295         const u32 feature_list = NETIF_F_TSO;
2296 #endif
2297
2298         if (data)
2299                 netdev->features |= feature_list;
2300         else
2301                 netdev->features &= ~feature_list;
2302
2303 #ifndef HAVE_NETDEV_VLAN_FEATURES
2304         if (!data) {
2305                 struct igb_adapter *adapter = netdev_priv(netdev);
2306                 struct net_device *v_netdev;
2307                 int i;
2308
2309                 /* disable TSO on all VLANs if they're present */
2310                 if (!adapter->vlgrp)
2311                         goto tso_out;
2312
2313                 for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) {
2314                         v_netdev = vlan_group_get_device(adapter->vlgrp, i);
2315                         if (!v_netdev)
2316                                 continue;
2317
2318                         v_netdev->features &= ~feature_list;
2319                         vlan_group_set_device(adapter->vlgrp, i, v_netdev);
2320                 }
2321         }
2322
2323 tso_out:
2324
2325 #endif /* HAVE_NETDEV_VLAN_FEATURES */
2326         return 0;
2327 }
2328
2329 #endif /* NETIF_F_TSO */
2330 #ifdef ETHTOOL_GFLAGS
2331 static int igb_set_flags(struct net_device *netdev, u32 data)
2332 {
2333         u32 supported_flags = ETH_FLAG_RXVLAN | ETH_FLAG_TXVLAN |
2334                               ETH_FLAG_RXHASH;
2335 #ifndef HAVE_VLAN_RX_REGISTER
2336         u32 changed = netdev->features ^ data;
2337 #endif
2338         int rc;
2339 #ifndef IGB_NO_LRO
2340
2341         supported_flags |= ETH_FLAG_LRO;
2342 #endif
2343         /*
2344          * Since there is no support for separate tx vlan accel
2345          * enabled make sure tx flag is cleared if rx is.
2346          */
2347         if (!(data & ETH_FLAG_RXVLAN))
2348                 data &= ~ETH_FLAG_TXVLAN;
2349
2350         rc = ethtool_op_set_flags(netdev, data, supported_flags);
2351         if (rc)
2352                 return rc;
2353 #ifndef HAVE_VLAN_RX_REGISTER
2354
2355         if (changed & ETH_FLAG_RXVLAN)
2356                 igb_vlan_mode(netdev, data);
2357 #endif
2358
2359         return 0;
2360 }
2361
2362 #endif /* ETHTOOL_GFLAGS */
2363 #endif /* HAVE_NDO_SET_FEATURES */
2364 #ifdef ETHTOOL_SADV_COAL
2365 static int igb_set_adv_coal(struct net_device *netdev, struct ethtool_value *edata)
2366 {
2367         struct igb_adapter *adapter = netdev_priv(netdev);
2368
2369         switch (edata->data) {
2370         case IGB_DMAC_DISABLE:
2371                 adapter->dmac = edata->data;
2372                 break;
2373         case IGB_DMAC_MIN:
2374                 adapter->dmac = edata->data;
2375                 break;
2376         case IGB_DMAC_500:
2377                 adapter->dmac = edata->data;
2378                 break;
2379         case IGB_DMAC_EN_DEFAULT:
2380                 adapter->dmac = edata->data;
2381                 break;
2382         case IGB_DMAC_2000:
2383                 adapter->dmac = edata->data;
2384                 break;
2385         case IGB_DMAC_3000:
2386                 adapter->dmac = edata->data;
2387                 break;
2388         case IGB_DMAC_4000:
2389                 adapter->dmac = edata->data;
2390                 break;
2391         case IGB_DMAC_5000:
2392                 adapter->dmac = edata->data;
2393                 break;
2394         case IGB_DMAC_6000:
2395                 adapter->dmac = edata->data;
2396                 break;
2397         case IGB_DMAC_7000:
2398                 adapter->dmac = edata->data;
2399                 break;
2400         case IGB_DMAC_8000:
2401                 adapter->dmac = edata->data;
2402                 break;
2403         case IGB_DMAC_9000:
2404                 adapter->dmac = edata->data;
2405                 break;
2406         case IGB_DMAC_MAX:
2407                 adapter->dmac = edata->data;
2408                 break;
2409         default:
2410                 adapter->dmac = IGB_DMAC_DISABLE;
2411                 printk("set_dmac: invalid setting, setting DMAC to %d\n",
2412                         adapter->dmac);
2413         }
2414         printk("%s: setting DMAC to %d\n", netdev->name, adapter->dmac);
2415         return 0;
2416 }
2417 #endif /* ETHTOOL_SADV_COAL */
2418 #ifdef ETHTOOL_GADV_COAL
2419 static void igb_get_dmac(struct net_device *netdev,
2420                             struct ethtool_value *edata)
2421 {
2422         struct igb_adapter *adapter = netdev_priv(netdev);
2423         edata->data = adapter->dmac;
2424
2425         return;
2426 }
2427 #endif
2428
2429 #ifdef ETHTOOL_GEEE
2430 static int igb_get_eee(struct net_device *netdev, struct ethtool_eee *edata)
2431 {
2432         struct igb_adapter *adapter = netdev_priv(netdev);
2433         struct e1000_hw *hw = &adapter->hw;
2434         u32 ret_val;
2435         u16 phy_data;
2436
2437         if ((hw->mac.type < e1000_i350) ||
2438             (hw->phy.media_type != e1000_media_type_copper))
2439                 return -EOPNOTSUPP;
2440
2441         edata->supported = (SUPPORTED_1000baseT_Full |
2442                             SUPPORTED_100baseT_Full);
2443
2444         if (!hw->dev_spec._82575.eee_disable)
2445                 edata->advertised =
2446                         mmd_eee_adv_to_ethtool_adv_t(adapter->eee_advert);
2447
2448         /* The IPCNFG and EEER registers are not supported on I354. */
2449         if (hw->mac.type == e1000_i354) {
2450                 e1000_get_eee_status_i354(hw, (bool *)&edata->eee_active);
2451         } else {
2452                 u32 eeer;
2453
2454                 eeer = E1000_READ_REG(hw, E1000_EEER);
2455
2456                 /* EEE status on negotiated link */
2457                 if (eeer & E1000_EEER_EEE_NEG)
2458                         edata->eee_active = true;
2459
2460                 if (eeer & E1000_EEER_TX_LPI_EN)
2461                         edata->tx_lpi_enabled = true;
2462         }
2463
2464         /* EEE Link Partner Advertised */
2465         switch (hw->mac.type) {
2466         case e1000_i350:
2467                 ret_val = e1000_read_emi_reg(hw, E1000_EEE_LP_ADV_ADDR_I350,
2468                                              &phy_data);
2469                 if (ret_val)
2470                         return -ENODATA;
2471
2472                 edata->lp_advertised = mmd_eee_adv_to_ethtool_adv_t(phy_data);
2473
2474                 break;
2475         case e1000_i354:
2476         case e1000_i210:
2477         case e1000_i211:
2478                 ret_val = e1000_read_xmdio_reg(hw, E1000_EEE_LP_ADV_ADDR_I210,
2479                                                E1000_EEE_LP_ADV_DEV_I210,
2480                                                &phy_data);
2481                 if (ret_val)
2482                         return -ENODATA;
2483
2484                 edata->lp_advertised = mmd_eee_adv_to_ethtool_adv_t(phy_data);
2485
2486                 break;
2487         default:
2488                 break;
2489         }
2490
2491         edata->eee_enabled = !hw->dev_spec._82575.eee_disable;
2492
2493         if ((hw->mac.type == e1000_i354) &&
2494             (edata->eee_enabled))
2495                 edata->tx_lpi_enabled = true;
2496
2497         /*
2498          * report correct negotiated EEE status for devices that
2499          * wrongly report EEE at half-duplex
2500          */
2501         if (adapter->link_duplex == HALF_DUPLEX) {
2502                 edata->eee_enabled = false;
2503                 edata->eee_active = false;
2504                 edata->tx_lpi_enabled = false;
2505                 edata->advertised &= ~edata->advertised;
2506         }
2507
2508         return 0;
2509 }
2510 #endif
2511
2512 #ifdef ETHTOOL_SEEE
2513 static int igb_set_eee(struct net_device *netdev,
2514                        struct ethtool_eee *edata)
2515 {
2516         struct igb_adapter *adapter = netdev_priv(netdev);
2517         struct e1000_hw *hw = &adapter->hw;
2518         struct ethtool_eee eee_curr;
2519         s32 ret_val;
2520
2521         if ((hw->mac.type < e1000_i350) ||
2522             (hw->phy.media_type != e1000_media_type_copper))
2523                 return -EOPNOTSUPP;
2524
2525         ret_val = igb_get_eee(netdev, &eee_curr);
2526         if (ret_val)
2527                 return ret_val;
2528
2529         if (eee_curr.eee_enabled) {
2530                 if (eee_curr.tx_lpi_enabled != edata->tx_lpi_enabled) {
2531                         dev_err(pci_dev_to_dev(adapter->pdev),
2532                                 "Setting EEE tx-lpi is not supported\n");
2533                         return -EINVAL;
2534                 }
2535
2536                 /* Tx LPI time is not implemented currently */
2537                 if (edata->tx_lpi_timer) {
2538                         dev_err(pci_dev_to_dev(adapter->pdev),
2539                                 "Setting EEE Tx LPI timer is not supported\n");
2540                         return -EINVAL;
2541                 }
2542
2543                 if (edata->advertised &
2544                     ~(ADVERTISE_100_FULL | ADVERTISE_1000_FULL)) {
2545                         dev_err(pci_dev_to_dev(adapter->pdev),
2546                                 "EEE Advertisement supports only 100Tx and or 100T full duplex\n");
2547                         return -EINVAL;
2548                 }
2549
2550         } else if (!edata->eee_enabled) {
2551                 dev_err(pci_dev_to_dev(adapter->pdev),
2552                         "Setting EEE options is not supported with EEE disabled\n");
2553                         return -EINVAL;
2554                 }
2555
2556         adapter->eee_advert = ethtool_adv_to_mmd_eee_adv_t(edata->advertised);
2557
2558         if (hw->dev_spec._82575.eee_disable != !edata->eee_enabled) {
2559                 hw->dev_spec._82575.eee_disable = !edata->eee_enabled;
2560
2561                 /* reset link */
2562                 if (netif_running(netdev))
2563                         igb_reinit_locked(adapter);
2564                 else
2565                         igb_reset(adapter);
2566         }
2567
2568         return 0;
2569 }
2570 #endif /* ETHTOOL_SEEE */
2571
2572 #ifdef ETHTOOL_GRXRINGS
2573 static int igb_get_rss_hash_opts(struct igb_adapter *adapter,
2574                                  struct ethtool_rxnfc *cmd)
2575 {
2576         cmd->data = 0;
2577
2578         /* Report default options for RSS on igb */
2579         switch (cmd->flow_type) {
2580         case TCP_V4_FLOW:
2581                 cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
2582         case UDP_V4_FLOW:
2583                 if (adapter->flags & IGB_FLAG_RSS_FIELD_IPV4_UDP)
2584                         cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
2585         case SCTP_V4_FLOW:
2586         case AH_ESP_V4_FLOW:
2587         case AH_V4_FLOW:
2588         case ESP_V4_FLOW:
2589         case IPV4_FLOW:
2590                 cmd->data |= RXH_IP_SRC | RXH_IP_DST;
2591                 break;
2592         case TCP_V6_FLOW:
2593                 cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
2594         case UDP_V6_FLOW:
2595                 if (adapter->flags & IGB_FLAG_RSS_FIELD_IPV6_UDP)
2596                         cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
2597         case SCTP_V6_FLOW:
2598         case AH_ESP_V6_FLOW:
2599         case AH_V6_FLOW:
2600         case ESP_V6_FLOW:
2601         case IPV6_FLOW:
2602                 cmd->data |= RXH_IP_SRC | RXH_IP_DST;
2603                 break;
2604         default:
2605                 return -EINVAL;
2606         }
2607
2608         return 0;
2609 }
2610
2611 static int igb_get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd,
2612 #ifdef HAVE_ETHTOOL_GET_RXNFC_VOID_RULE_LOCS
2613                            void *rule_locs)
2614 #else
2615                            u32 *rule_locs)
2616 #endif
2617 {
2618         struct igb_adapter *adapter = netdev_priv(dev);
2619         int ret = -EOPNOTSUPP;
2620
2621         switch (cmd->cmd) {
2622         case ETHTOOL_GRXRINGS:
2623                 cmd->data = adapter->num_rx_queues;
2624                 ret = 0;
2625                 break;
2626         case ETHTOOL_GRXFH:
2627                 ret = igb_get_rss_hash_opts(adapter, cmd);
2628                 break;
2629         default:
2630                 break;
2631         }
2632
2633         return ret;
2634 }
2635
2636 #define UDP_RSS_FLAGS (IGB_FLAG_RSS_FIELD_IPV4_UDP | \
2637                        IGB_FLAG_RSS_FIELD_IPV6_UDP)
2638 static int igb_set_rss_hash_opt(struct igb_adapter *adapter,
2639                                 struct ethtool_rxnfc *nfc)
2640 {
2641         u32 flags = adapter->flags;
2642
2643         /*
2644          * RSS does not support anything other than hashing
2645          * to queues on src and dst IPs and ports
2646          */
2647         if (nfc->data & ~(RXH_IP_SRC | RXH_IP_DST |
2648                           RXH_L4_B_0_1 | RXH_L4_B_2_3))
2649                 return -EINVAL;
2650
2651         switch (nfc->flow_type) {
2652         case TCP_V4_FLOW:
2653         case TCP_V6_FLOW:
2654                 if (!(nfc->data & RXH_IP_SRC) ||
2655                     !(nfc->data & RXH_IP_DST) ||
2656                     !(nfc->data & RXH_L4_B_0_1) ||
2657                     !(nfc->data & RXH_L4_B_2_3))
2658                         return -EINVAL;
2659                 break;
2660         case UDP_V4_FLOW:
2661                 if (!(nfc->data & RXH_IP_SRC) ||
2662                     !(nfc->data & RXH_IP_DST))
2663                         return -EINVAL;
2664                 switch (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) {
2665                 case 0:
2666                         flags &= ~IGB_FLAG_RSS_FIELD_IPV4_UDP;
2667                         break;
2668                 case (RXH_L4_B_0_1 | RXH_L4_B_2_3):
2669                         flags |= IGB_FLAG_RSS_FIELD_IPV4_UDP;
2670                         break;
2671                 default:
2672                         return -EINVAL;
2673                 }
2674                 break;
2675         case UDP_V6_FLOW:
2676                 if (!(nfc->data & RXH_IP_SRC) ||
2677                     !(nfc->data & RXH_IP_DST))
2678                         return -EINVAL;
2679                 switch (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) {
2680                 case 0:
2681                         flags &= ~IGB_FLAG_RSS_FIELD_IPV6_UDP;
2682                         break;
2683                 case (RXH_L4_B_0_1 | RXH_L4_B_2_3):
2684                         flags |= IGB_FLAG_RSS_FIELD_IPV6_UDP;
2685                         break;
2686                 default:
2687                         return -EINVAL;
2688                 }
2689                 break;
2690         case AH_ESP_V4_FLOW:
2691         case AH_V4_FLOW:
2692         case ESP_V4_FLOW:
2693         case SCTP_V4_FLOW:
2694         case AH_ESP_V6_FLOW:
2695         case AH_V6_FLOW:
2696         case ESP_V6_FLOW:
2697         case SCTP_V6_FLOW:
2698                 if (!(nfc->data & RXH_IP_SRC) ||
2699                     !(nfc->data & RXH_IP_DST) ||
2700                     (nfc->data & RXH_L4_B_0_1) ||
2701                     (nfc->data & RXH_L4_B_2_3))
2702                         return -EINVAL;
2703                 break;
2704         default:
2705                 return -EINVAL;
2706         }
2707
2708         /* if we changed something we need to update flags */
2709         if (flags != adapter->flags) {
2710                 struct e1000_hw *hw = &adapter->hw;
2711                 u32 mrqc = E1000_READ_REG(hw, E1000_MRQC);
2712
2713                 if ((flags & UDP_RSS_FLAGS) &&
2714                     !(adapter->flags & UDP_RSS_FLAGS))
2715                         DPRINTK(DRV, WARNING,
2716                                 "enabling UDP RSS: fragmented packets may arrive out of order to the stack above\n");
2717
2718                 adapter->flags = flags;
2719
2720                 /* Perform hash on these packet types */
2721                 mrqc |= E1000_MRQC_RSS_FIELD_IPV4 |
2722                         E1000_MRQC_RSS_FIELD_IPV4_TCP |
2723                         E1000_MRQC_RSS_FIELD_IPV6 |
2724                         E1000_MRQC_RSS_FIELD_IPV6_TCP;
2725
2726                 mrqc &= ~(E1000_MRQC_RSS_FIELD_IPV4_UDP |
2727                           E1000_MRQC_RSS_FIELD_IPV6_UDP);
2728
2729                 if (flags & IGB_FLAG_RSS_FIELD_IPV4_UDP)
2730                         mrqc |= E1000_MRQC_RSS_FIELD_IPV4_UDP;
2731
2732                 if (flags & IGB_FLAG_RSS_FIELD_IPV6_UDP)
2733                         mrqc |= E1000_MRQC_RSS_FIELD_IPV6_UDP;
2734
2735                 E1000_WRITE_REG(hw, E1000_MRQC, mrqc);
2736         }
2737
2738         return 0;
2739 }
2740
2741 static int igb_set_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd)
2742 {
2743         struct igb_adapter *adapter = netdev_priv(dev);
2744         int ret = -EOPNOTSUPP;
2745
2746         switch (cmd->cmd) {
2747         case ETHTOOL_SRXFH:
2748                 ret = igb_set_rss_hash_opt(adapter, cmd);
2749                 break;
2750         default:
2751                 break;
2752         }
2753
2754         return ret;
2755 }
2756 #endif /* ETHTOOL_GRXRINGS */
2757
2758 static const struct ethtool_ops igb_ethtool_ops = {
2759 #ifndef ETHTOOL_GLINKSETTINGS
2760         .get_settings           = igb_get_settings,
2761 #endif
2762 #ifndef ETHTOOL_SLINKSETTINGS
2763         .set_settings           = igb_set_settings,
2764 #endif
2765         .get_drvinfo            = igb_get_drvinfo,
2766         .get_regs_len           = igb_get_regs_len,
2767         .get_regs               = igb_get_regs,
2768         .get_wol                = igb_get_wol,
2769         .set_wol                = igb_set_wol,
2770         .get_msglevel           = igb_get_msglevel,
2771         .set_msglevel           = igb_set_msglevel,
2772         .nway_reset             = igb_nway_reset,
2773         .get_link               = igb_get_link,
2774         .get_eeprom_len         = igb_get_eeprom_len,
2775         .get_eeprom             = igb_get_eeprom,
2776         .set_eeprom             = igb_set_eeprom,
2777         .get_ringparam          = igb_get_ringparam,
2778         .set_ringparam          = igb_set_ringparam,
2779         .get_pauseparam         = igb_get_pauseparam,
2780         .set_pauseparam         = igb_set_pauseparam,
2781         .self_test              = igb_diag_test,
2782         .get_strings            = igb_get_strings,
2783 #ifndef HAVE_RHEL6_ETHTOOL_OPS_EXT_STRUCT
2784 #ifdef HAVE_ETHTOOL_SET_PHYS_ID
2785         .set_phys_id            = igb_set_phys_id,
2786 #else
2787         .phys_id                = igb_phys_id,
2788 #endif /* HAVE_ETHTOOL_SET_PHYS_ID */
2789 #endif /* HAVE_RHEL6_ETHTOOL_OPS_EXT_STRUCT */
2790 #ifdef HAVE_ETHTOOL_GET_SSET_COUNT
2791         .get_sset_count         = igb_get_sset_count,
2792 #else
2793         .get_stats_count        = igb_get_stats_count,
2794         .self_test_count        = igb_diag_test_count,
2795 #endif
2796         .get_ethtool_stats      = igb_get_ethtool_stats,
2797 #ifdef HAVE_ETHTOOL_GET_PERM_ADDR
2798         .get_perm_addr          = ethtool_op_get_perm_addr,
2799 #endif
2800         .get_coalesce           = igb_get_coalesce,
2801         .set_coalesce           = igb_set_coalesce,
2802 #ifndef HAVE_RHEL6_ETHTOOL_OPS_EXT_STRUCT
2803 #ifdef HAVE_ETHTOOL_GET_TS_INFO
2804         .get_ts_info            = igb_get_ts_info,
2805 #endif /* HAVE_ETHTOOL_GET_TS_INFO */
2806 #endif /* HAVE_RHEL6_ETHTOOL_OPS_EXT_STRUCT */
2807 #ifdef CONFIG_PM_RUNTIME
2808         .begin                  = igb_ethtool_begin,
2809         .complete               = igb_ethtool_complete,
2810 #endif /* CONFIG_PM_RUNTIME */
2811 #ifndef HAVE_NDO_SET_FEATURES
2812         .get_rx_csum            = igb_get_rx_csum,
2813         .set_rx_csum            = igb_set_rx_csum,
2814         .get_tx_csum            = ethtool_op_get_tx_csum,
2815         .set_tx_csum            = igb_set_tx_csum,
2816         .get_sg                 = ethtool_op_get_sg,
2817         .set_sg                 = ethtool_op_set_sg,
2818 #ifdef NETIF_F_TSO
2819         .get_tso                = ethtool_op_get_tso,
2820         .set_tso                = igb_set_tso,
2821 #endif
2822 #ifdef ETHTOOL_GFLAGS
2823         .get_flags              = ethtool_op_get_flags,
2824         .set_flags              = igb_set_flags,
2825 #endif /* ETHTOOL_GFLAGS */
2826 #endif /* HAVE_NDO_SET_FEATURES */
2827 #ifdef ETHTOOL_GADV_COAL
2828         .get_advcoal            = igb_get_adv_coal,
2829         .set_advcoal            = igb_set_dmac_coal,
2830 #endif /* ETHTOOL_GADV_COAL */
2831 #ifndef HAVE_RHEL6_ETHTOOL_OPS_EXT_STRUCT
2832 #ifdef ETHTOOL_GEEE
2833         .get_eee                = igb_get_eee,
2834 #endif
2835 #ifdef ETHTOOL_SEEE
2836         .set_eee                = igb_set_eee,
2837 #endif
2838 #endif /* HAVE_RHEL6_ETHTOOL_OPS_EXT_STRUCT */
2839 #ifdef ETHTOOL_GRXRINGS
2840         .get_rxnfc              = igb_get_rxnfc,
2841         .set_rxnfc              = igb_set_rxnfc,
2842 #endif
2843 };
2844
2845 #ifdef HAVE_RHEL6_ETHTOOL_OPS_EXT_STRUCT
2846 static const struct ethtool_ops_ext igb_ethtool_ops_ext = {
2847         .size           = sizeof(struct ethtool_ops_ext),
2848         .get_ts_info    = igb_get_ts_info,
2849         .set_phys_id    = igb_set_phys_id,
2850         .get_eee        = igb_get_eee,
2851         .set_eee        = igb_set_eee,
2852 };
2853
2854 void igb_set_ethtool_ops(struct net_device *netdev)
2855 {
2856         SET_ETHTOOL_OPS(netdev, &igb_ethtool_ops);
2857         set_ethtool_ops_ext(netdev, &igb_ethtool_ops_ext);
2858 }
2859 #else
2860 void igb_set_ethtool_ops(struct net_device *netdev)
2861 {
2862         /* have to "undeclare" const on this struct to remove warnings */
2863         SET_ETHTOOL_OPS(netdev, (struct ethtool_ops *)&igb_ethtool_ops);
2864 }
2865 #endif /* HAVE_RHEL6_ETHTOOL_OPS_EXT_STRUCT */
2866 #endif  /* SIOCETHTOOL */