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

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright(c) 1999 - 2018 Intel Corporation. */
   3
   4 /* ethtool support for e1000 */
   5
   6 #include <linux/netdevice.h>
   7 #include <linux/interrupt.h>
   8 #include <linux/ethtool.h>
   9 #include <linux/pci.h>
  10 #include <linux/slab.h>
  11 #include <linux/delay.h>
  12 #include <linux/vmalloc.h>
  13 #include <linux/pm_runtime.h>
  14
  15 #include "e1000.h"
  16
  17 enum { NETDEV_STATS, E1000_STATS };
  18
  19 struct e1000_stats {
  20         char stat_string[ETH_GSTRING_LEN];
  21         int type;
  22         int sizeof_stat;
  23         int stat_offset;
  24 };
  25
  26 static const char e1000e_priv_flags_strings[][ETH_GSTRING_LEN] = {
  27 #define E1000E_PRIV_FLAGS_S0IX_ENABLED  BIT(0)
  28         "s0ix-enabled",
  29 };
  30
  31 #define E1000E_PRIV_FLAGS_STR_LEN ARRAY_SIZE(e1000e_priv_flags_strings)
  32
  33 #define E1000_STAT(str, m) { \
  34                 .stat_string = str, \
  35                 .type = E1000_STATS, \
  36                 .sizeof_stat = sizeof(((struct e1000_adapter *)0)->m), \
  37                 .stat_offset = offsetof(struct e1000_adapter, m) }
  38 #define E1000_NETDEV_STAT(str, m) { \
  39                 .stat_string = str, \
  40                 .type = NETDEV_STATS, \
  41                 .sizeof_stat = sizeof(((struct rtnl_link_stats64 *)0)->m), \
  42                 .stat_offset = offsetof(struct rtnl_link_stats64, m) }
  43
  44 static const struct e1000_stats e1000_gstrings_stats[] = {
  45         E1000_STAT("rx_packets", stats.gprc),
  46         E1000_STAT("tx_packets", stats.gptc),
  47         E1000_STAT("rx_bytes", stats.gorc),
  48         E1000_STAT("tx_bytes", stats.gotc),
  49         E1000_STAT("rx_broadcast", stats.bprc),
  50         E1000_STAT("tx_broadcast", stats.bptc),
  51         E1000_STAT("rx_multicast", stats.mprc),
  52         E1000_STAT("tx_multicast", stats.mptc),
  53         E1000_NETDEV_STAT("rx_errors", rx_errors),
  54         E1000_NETDEV_STAT("tx_errors", tx_errors),
  55         E1000_NETDEV_STAT("tx_dropped", tx_dropped),
  56         E1000_STAT("multicast", stats.mprc),
  57         E1000_STAT("collisions", stats.colc),
  58         E1000_NETDEV_STAT("rx_length_errors", rx_length_errors),
  59         E1000_NETDEV_STAT("rx_over_errors", rx_over_errors),
  60         E1000_STAT("rx_crc_errors", stats.crcerrs),
  61         E1000_NETDEV_STAT("rx_frame_errors", rx_frame_errors),
  62         E1000_STAT("rx_no_buffer_count", stats.rnbc),
  63         E1000_STAT("rx_missed_errors", stats.mpc),
  64         E1000_STAT("tx_aborted_errors", stats.ecol),
  65         E1000_STAT("tx_carrier_errors", stats.tncrs),
  66         E1000_NETDEV_STAT("tx_fifo_errors", tx_fifo_errors),
  67         E1000_NETDEV_STAT("tx_heartbeat_errors", tx_heartbeat_errors),
  68         E1000_STAT("tx_window_errors", stats.latecol),
  69         E1000_STAT("tx_abort_late_coll", stats.latecol),
  70         E1000_STAT("tx_deferred_ok", stats.dc),
  71         E1000_STAT("tx_single_coll_ok", stats.scc),
  72         E1000_STAT("tx_multi_coll_ok", stats.mcc),
  73         E1000_STAT("tx_timeout_count", tx_timeout_count),
  74         E1000_STAT("tx_restart_queue", restart_queue),
  75         E1000_STAT("rx_long_length_errors", stats.roc),
  76         E1000_STAT("rx_short_length_errors", stats.ruc),
  77         E1000_STAT("rx_align_errors", stats.algnerrc),
  78         E1000_STAT("tx_tcp_seg_good", stats.tsctc),
  79         E1000_STAT("tx_tcp_seg_failed", stats.tsctfc),
  80         E1000_STAT("rx_flow_control_xon", stats.xonrxc),
  81         E1000_STAT("rx_flow_control_xoff", stats.xoffrxc),
  82         E1000_STAT("tx_flow_control_xon", stats.xontxc),
  83         E1000_STAT("tx_flow_control_xoff", stats.xofftxc),
  84         E1000_STAT("rx_csum_offload_good", hw_csum_good),
  85         E1000_STAT("rx_csum_offload_errors", hw_csum_err),
  86         E1000_STAT("rx_header_split", rx_hdr_split),
  87         E1000_STAT("alloc_rx_buff_failed", alloc_rx_buff_failed),
  88         E1000_STAT("tx_smbus", stats.mgptc),
  89         E1000_STAT("rx_smbus", stats.mgprc),
  90         E1000_STAT("dropped_smbus", stats.mgpdc),
  91         E1000_STAT("rx_dma_failed", rx_dma_failed),
  92         E1000_STAT("tx_dma_failed", tx_dma_failed),
  93         E1000_STAT("rx_hwtstamp_cleared", rx_hwtstamp_cleared),
  94         E1000_STAT("uncorr_ecc_errors", uncorr_errors),
  95         E1000_STAT("corr_ecc_errors", corr_errors),
  96         E1000_STAT("tx_hwtstamp_timeouts", tx_hwtstamp_timeouts),
  97         E1000_STAT("tx_hwtstamp_skipped", tx_hwtstamp_skipped),
  98 };
  99
 100 #define E1000_GLOBAL_STATS_LEN  ARRAY_SIZE(e1000_gstrings_stats)
 101 #define E1000_STATS_LEN (E1000_GLOBAL_STATS_LEN)
 102 static const char e1000_gstrings_test[][ETH_GSTRING_LEN] = {
 103         "Register test  (offline)", "Eeprom test    (offline)",
 104         "Interrupt test (offline)", "Loopback test  (offline)",
 105         "Link test   (on/offline)"
 106 };
 107
 108 #define E1000_TEST_LEN ARRAY_SIZE(e1000_gstrings_test)
 109
 110 static int e1000_get_link_ksettings(struct net_device *netdev,
 111                                     struct ethtool_link_ksettings *cmd)
 112 {
 113         struct e1000_adapter *adapter = netdev_priv(netdev);
 114         struct e1000_hw *hw = &adapter->hw;
 115         u32 speed, supported, advertising;
 116
 117         if (hw->phy.media_type == e1000_media_type_copper) {
 118                 supported = (SUPPORTED_10baseT_Half |
 119                              SUPPORTED_10baseT_Full |
 120                              SUPPORTED_100baseT_Half |
 121                              SUPPORTED_100baseT_Full |
 122                              SUPPORTED_1000baseT_Full |
 123                              SUPPORTED_Autoneg |
 124                              SUPPORTED_TP);
 125                 if (hw->phy.type == e1000_phy_ife)
 126                         supported &= ~SUPPORTED_1000baseT_Full;
 127                 advertising = ADVERTISED_TP;
 128
 129                 if (hw->mac.autoneg == 1) {
 130                         advertising |= ADVERTISED_Autoneg;
 131                         /* the e1000 autoneg seems to match ethtool nicely */
 132                         advertising |= hw->phy.autoneg_advertised;
 133                 }
 134
 135                 cmd->base.port = PORT_TP;
 136                 cmd->base.phy_address = hw->phy.addr;
 137         } else {
 138                 supported   = (SUPPORTED_1000baseT_Full |
 139                                SUPPORTED_FIBRE |
 140                                SUPPORTED_Autoneg);
 141
 142                 advertising = (ADVERTISED_1000baseT_Full |
 143                                ADVERTISED_FIBRE |
 144                                ADVERTISED_Autoneg);
 145
 146                 cmd->base.port = PORT_FIBRE;
 147         }
 148
 149         speed = SPEED_UNKNOWN;
 150         cmd->base.duplex = DUPLEX_UNKNOWN;
 151
 152         if (netif_running(netdev)) {
 153                 if (netif_carrier_ok(netdev)) {
 154                         speed = adapter->link_speed;
 155                         cmd->base.duplex = adapter->link_duplex - 1;
 156                 }
 157         } else if (!pm_runtime_suspended(netdev->dev.parent)) {
 158                 u32 status = er32(STATUS);
 159
 160                 if (status & E1000_STATUS_LU) {
 161                         if (status & E1000_STATUS_SPEED_1000)
 162                                 speed = SPEED_1000;
 163                         else if (status & E1000_STATUS_SPEED_100)
 164                                 speed = SPEED_100;
 165                         else
 166                                 speed = SPEED_10;
 167
 168                         if (status & E1000_STATUS_FD)
 169                                 cmd->base.duplex = DUPLEX_FULL;
 170                         else
 171                                 cmd->base.duplex = DUPLEX_HALF;
 172                 }
 173         }
 174
 175         cmd->base.speed = speed;
 176         cmd->base.autoneg = ((hw->phy.media_type == e1000_media_type_fiber) ||
 177                          hw->mac.autoneg) ? AUTONEG_ENABLE : AUTONEG_DISABLE;
 178
 179         /* MDI-X => 2; MDI =>1; Invalid =>0 */
 180         if ((hw->phy.media_type == e1000_media_type_copper) &&
 181             netif_carrier_ok(netdev))
 182                 cmd->base.eth_tp_mdix = hw->phy.is_mdix ?
 183                         ETH_TP_MDI_X : ETH_TP_MDI;
 184         else
 185                 cmd->base.eth_tp_mdix = ETH_TP_MDI_INVALID;
 186
 187         if (hw->phy.mdix == AUTO_ALL_MODES)
 188                 cmd->base.eth_tp_mdix_ctrl = ETH_TP_MDI_AUTO;
 189         else
 190                 cmd->base.eth_tp_mdix_ctrl = hw->phy.mdix;
 191
 192         if (hw->phy.media_type != e1000_media_type_copper)
 193                 cmd->base.eth_tp_mdix_ctrl = ETH_TP_MDI_INVALID;
 194
 195         ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported,
 196                                                 supported);
 197         ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.advertising,
 198                                                 advertising);
 199
 200         return 0;
 201 }
 202
 203 static int e1000_set_spd_dplx(struct e1000_adapter *adapter, u32 spd, u8 dplx)
 204 {
 205         struct e1000_mac_info *mac = &adapter->hw.mac;
 206
 207         mac->autoneg = 0;
 208
 209         /* Make sure dplx is at most 1 bit and lsb of speed is not set
 210          * for the switch() below to work
 211          */
 212         if ((spd & 1) || (dplx & ~1))
 213                 goto err_inval;
 214
 215         /* Fiber NICs only allow 1000 gbps Full duplex */
 216         if ((adapter->hw.phy.media_type == e1000_media_type_fiber) &&
 217             (spd != SPEED_1000) && (dplx != DUPLEX_FULL)) {
 218                 goto err_inval;
 219         }
 220
 221         switch (spd + dplx) {
 222         case SPEED_10 + DUPLEX_HALF:
 223                 mac->forced_speed_duplex = ADVERTISE_10_HALF;
 224                 break;
 225         case SPEED_10 + DUPLEX_FULL:
 226                 mac->forced_speed_duplex = ADVERTISE_10_FULL;
 227                 break;
 228         case SPEED_100 + DUPLEX_HALF:
 229                 mac->forced_speed_duplex = ADVERTISE_100_HALF;
 230                 break;
 231         case SPEED_100 + DUPLEX_FULL:
 232                 mac->forced_speed_duplex = ADVERTISE_100_FULL;
 233                 break;
 234         case SPEED_1000 + DUPLEX_FULL:
 235                 if (adapter->hw.phy.media_type == e1000_media_type_copper) {
 236                         mac->autoneg = 1;
 237                         adapter->hw.phy.autoneg_advertised =
 238                                 ADVERTISE_1000_FULL;
 239                 } else {
 240                         mac->forced_speed_duplex = ADVERTISE_1000_FULL;
 241                 }
 242                 break;
 243         case SPEED_1000 + DUPLEX_HALF:  /* not supported */
 244         default:
 245                 goto err_inval;
 246         }
 247
 248         /* clear MDI, MDI(-X) override is only allowed when autoneg enabled */
 249         adapter->hw.phy.mdix = AUTO_ALL_MODES;
 250
 251         return 0;
 252
 253 err_inval:
 254         e_err("Unsupported Speed/Duplex configuration\n");
 255         return -EINVAL;
 256 }
 257
 258 static int e1000_set_link_ksettings(struct net_device *netdev,
 259                                     const struct ethtool_link_ksettings *cmd)
 260 {
 261         struct e1000_adapter *adapter = netdev_priv(netdev);
 262         struct e1000_hw *hw = &adapter->hw;
 263         int ret_val = 0;
 264         u32 advertising;
 265
 266         ethtool_convert_link_mode_to_legacy_u32(&advertising,
 267                                                 cmd->link_modes.advertising);
 268
 269         pm_runtime_get_sync(netdev->dev.parent);
 270
 271         /* When SoL/IDER sessions are active, autoneg/speed/duplex
 272          * cannot be changed
 273          */
 274         if (hw->phy.ops.check_reset_block &&
 275             hw->phy.ops.check_reset_block(hw)) {
 276                 e_err("Cannot change link characteristics when SoL/IDER is active.\n");
 277                 ret_val = -EINVAL;
 278                 goto out;
 279         }
 280
 281         /* MDI setting is only allowed when autoneg enabled because
 282          * some hardware doesn't allow MDI setting when speed or
 283          * duplex is forced.
 284          */
 285         if (cmd->base.eth_tp_mdix_ctrl) {
 286                 if (hw->phy.media_type != e1000_media_type_copper) {
 287                         ret_val = -EOPNOTSUPP;
 288                         goto out;
 289                 }
 290
 291                 if ((cmd->base.eth_tp_mdix_ctrl != ETH_TP_MDI_AUTO) &&
 292                     (cmd->base.autoneg != AUTONEG_ENABLE)) {
 293                         e_err("forcing MDI/MDI-X state is not supported when link speed and/or duplex are forced\n");
 294                         ret_val = -EINVAL;
 295                         goto out;
 296                 }
 297         }
 298
 299         while (test_and_set_bit(__E1000_RESETTING, &adapter->state))
 300                 usleep_range(1000, 2000);
 301
 302         if (cmd->base.autoneg == AUTONEG_ENABLE) {
 303                 hw->mac.autoneg = 1;
 304                 if (hw->phy.media_type == e1000_media_type_fiber)
 305                         hw->phy.autoneg_advertised = ADVERTISED_1000baseT_Full |
 306                             ADVERTISED_FIBRE | ADVERTISED_Autoneg;
 307                 else
 308                         hw->phy.autoneg_advertised = advertising |
 309                             ADVERTISED_TP | ADVERTISED_Autoneg;
 310                 advertising = hw->phy.autoneg_advertised;
 311                 if (adapter->fc_autoneg)
 312                         hw->fc.requested_mode = e1000_fc_default;
 313         } else {
 314                 u32 speed = cmd->base.speed;
 315                 /* calling this overrides forced MDI setting */
 316                 if (e1000_set_spd_dplx(adapter, speed, cmd->base.duplex)) {
 317                         ret_val = -EINVAL;
 318                         goto out;
 319                 }
 320         }
 321
 322         /* MDI-X => 2; MDI => 1; Auto => 3 */
 323         if (cmd->base.eth_tp_mdix_ctrl) {
 324                 /* fix up the value for auto (3 => 0) as zero is mapped
 325                  * internally to auto
 326                  */
 327                 if (cmd->base.eth_tp_mdix_ctrl == ETH_TP_MDI_AUTO)
 328                         hw->phy.mdix = AUTO_ALL_MODES;
 329                 else
 330                         hw->phy.mdix = cmd->base.eth_tp_mdix_ctrl;
 331         }
 332
 333         /* reset the link */
 334         if (netif_running(adapter->netdev)) {
 335                 e1000e_down(adapter, true);
 336                 e1000e_up(adapter);
 337         } else {
 338                 e1000e_reset(adapter);
 339         }
 340
 341 out:
 342         pm_runtime_put_sync(netdev->dev.parent);
 343         clear_bit(__E1000_RESETTING, &adapter->state);
 344         return ret_val;
 345 }
 346
 347 static void e1000_get_pauseparam(struct net_device *netdev,
 348                                  struct ethtool_pauseparam *pause)
 349 {
 350         struct e1000_adapter *adapter = netdev_priv(netdev);
 351         struct e1000_hw *hw = &adapter->hw;
 352
 353         pause->autoneg =
 354             (adapter->fc_autoneg ? AUTONEG_ENABLE : AUTONEG_DISABLE);
 355
 356         if (hw->fc.current_mode == e1000_fc_rx_pause) {
 357                 pause->rx_pause = 1;
 358         } else if (hw->fc.current_mode == e1000_fc_tx_pause) {
 359                 pause->tx_pause = 1;
 360         } else if (hw->fc.current_mode == e1000_fc_full) {
 361                 pause->rx_pause = 1;
 362                 pause->tx_pause = 1;
 363         }
 364 }
 365
 366 static int e1000_set_pauseparam(struct net_device *netdev,
 367                                 struct ethtool_pauseparam *pause)
 368 {
 369         struct e1000_adapter *adapter = netdev_priv(netdev);
 370         struct e1000_hw *hw = &adapter->hw;
 371         int retval = 0;
 372
 373         adapter->fc_autoneg = pause->autoneg;
 374
 375         while (test_and_set_bit(__E1000_RESETTING, &adapter->state))
 376                 usleep_range(1000, 2000);
 377
 378         pm_runtime_get_sync(netdev->dev.parent);
 379
 380         if (adapter->fc_autoneg == AUTONEG_ENABLE) {
 381                 hw->fc.requested_mode = e1000_fc_default;
 382                 if (netif_running(adapter->netdev)) {
 383                         e1000e_down(adapter, true);
 384                         e1000e_up(adapter);
 385                 } else {
 386                         e1000e_reset(adapter);
 387                 }
 388         } else {
 389                 if (pause->rx_pause && pause->tx_pause)
 390                         hw->fc.requested_mode = e1000_fc_full;
 391                 else if (pause->rx_pause && !pause->tx_pause)
 392                         hw->fc.requested_mode = e1000_fc_rx_pause;
 393                 else if (!pause->rx_pause && pause->tx_pause)
 394                         hw->fc.requested_mode = e1000_fc_tx_pause;
 395                 else if (!pause->rx_pause && !pause->tx_pause)
 396                         hw->fc.requested_mode = e1000_fc_none;
 397
 398                 hw->fc.current_mode = hw->fc.requested_mode;
 399
 400                 if (hw->phy.media_type == e1000_media_type_fiber) {
 401                         retval = hw->mac.ops.setup_link(hw);
 402                         /* implicit goto out */
 403                 } else {
 404                         retval = e1000e_force_mac_fc(hw);
 405                         if (retval)
 406                                 goto out;
 407                         e1000e_set_fc_watermarks(hw);
 408                 }
 409         }
 410
 411 out:
 412         pm_runtime_put_sync(netdev->dev.parent);
 413         clear_bit(__E1000_RESETTING, &adapter->state);
 414         return retval;
 415 }
 416
 417 static u32 e1000_get_msglevel(struct net_device *netdev)
 418 {
 419         struct e1000_adapter *adapter = netdev_priv(netdev);
 420         return adapter->msg_enable;
 421 }
 422
 423 static void e1000_set_msglevel(struct net_device *netdev, u32 data)
 424 {
 425         struct e1000_adapter *adapter = netdev_priv(netdev);
 426         adapter->msg_enable = data;
 427 }
 428
 429 static int e1000_get_regs_len(struct net_device __always_unused *netdev)
 430 {
 431 #define E1000_REGS_LEN 32       /* overestimate */
 432         return E1000_REGS_LEN * sizeof(u32);
 433 }
 434
 435 static void e1000_get_regs(struct net_device *netdev,
 436                            struct ethtool_regs *regs, void *p)
 437 {
 438         struct e1000_adapter *adapter = netdev_priv(netdev);
 439         struct e1000_hw *hw = &adapter->hw;
 440         u32 *regs_buff = p;
 441         u16 phy_data;
 442
 443         pm_runtime_get_sync(netdev->dev.parent);
 444
 445         memset(p, 0, E1000_REGS_LEN * sizeof(u32));
 446
 447         regs->version = (1u << 24) |
 448                         (adapter->pdev->revision << 16) |
 449                         adapter->pdev->device;
 450
 451         regs_buff[0] = er32(CTRL);
 452         regs_buff[1] = er32(STATUS);
 453
 454         regs_buff[2] = er32(RCTL);
 455         regs_buff[3] = er32(RDLEN(0));
 456         regs_buff[4] = er32(RDH(0));
 457         regs_buff[5] = er32(RDT(0));
 458         regs_buff[6] = er32(RDTR);
 459
 460         regs_buff[7] = er32(TCTL);
 461         regs_buff[8] = er32(TDLEN(0));
 462         regs_buff[9] = er32(TDH(0));
 463         regs_buff[10] = er32(TDT(0));
 464         regs_buff[11] = er32(TIDV);
 465
 466         regs_buff[12] = adapter->hw.phy.type;   /* PHY type (IGP=1, M88=0) */
 467
 468         /* ethtool doesn't use anything past this point, so all this
 469          * code is likely legacy junk for apps that may or may not exist
 470          */
 471         if (hw->phy.type == e1000_phy_m88) {
 472                 e1e_rphy(hw, M88E1000_PHY_SPEC_STATUS, &phy_data);
 473                 regs_buff[13] = (u32)phy_data; /* cable length */
 474                 regs_buff[14] = 0;  /* Dummy (to align w/ IGP phy reg dump) */
 475                 regs_buff[15] = 0;  /* Dummy (to align w/ IGP phy reg dump) */
 476                 regs_buff[16] = 0;  /* Dummy (to align w/ IGP phy reg dump) */
 477                 e1e_rphy(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);
 478                 regs_buff[17] = (u32)phy_data; /* extended 10bt distance */
 479                 regs_buff[18] = regs_buff[13]; /* cable polarity */
 480                 regs_buff[19] = 0;  /* Dummy (to align w/ IGP phy reg dump) */
 481                 regs_buff[20] = regs_buff[17]; /* polarity correction */
 482                 /* phy receive errors */
 483                 regs_buff[22] = adapter->phy_stats.receive_errors;
 484                 regs_buff[23] = regs_buff[13]; /* mdix mode */
 485         }
 486         regs_buff[21] = 0;      /* was idle_errors */
 487         e1e_rphy(hw, MII_STAT1000, &phy_data);
 488         regs_buff[24] = (u32)phy_data;  /* phy local receiver status */
 489         regs_buff[25] = regs_buff[24];  /* phy remote receiver status */
 490
 491         pm_runtime_put_sync(netdev->dev.parent);
 492 }
 493
 494 static int e1000_get_eeprom_len(struct net_device *netdev)
 495 {
 496         struct e1000_adapter *adapter = netdev_priv(netdev);
 497         return adapter->hw.nvm.word_size * 2;
 498 }
 499
 500 static int e1000_get_eeprom(struct net_device *netdev,
 501                             struct ethtool_eeprom *eeprom, u8 *bytes)
 502 {
 503         struct e1000_adapter *adapter = netdev_priv(netdev);
 504         struct e1000_hw *hw = &adapter->hw;
 505         u16 *eeprom_buff;
 506         int first_word;
 507         int last_word;
 508         int ret_val = 0;
 509         u16 i;
 510
 511         if (eeprom->len == 0)
 512                 return -EINVAL;
 513
 514         eeprom->magic = adapter->pdev->vendor | (adapter->pdev->device << 16);
 515
 516         first_word = eeprom->offset >> 1;
 517         last_word = (eeprom->offset + eeprom->len - 1) >> 1;
 518
 519         eeprom_buff = kmalloc_array(last_word - first_word + 1, sizeof(u16),
 520                                     GFP_KERNEL);
 521         if (!eeprom_buff)
 522                 return -ENOMEM;
 523
 524         pm_runtime_get_sync(netdev->dev.parent);
 525
 526         if (hw->nvm.type == e1000_nvm_eeprom_spi) {
 527                 ret_val = e1000_read_nvm(hw, first_word,
 528                                          last_word - first_word + 1,
 529                                          eeprom_buff);
 530         } else {
 531                 for (i = 0; i < last_word - first_word + 1; i++) {
 532                         ret_val = e1000_read_nvm(hw, first_word + i, 1,
 533                                                  &eeprom_buff[i]);
 534                         if (ret_val)
 535                                 break;
 536                 }
 537         }
 538
 539         pm_runtime_put_sync(netdev->dev.parent);
 540
 541         if (ret_val) {
 542                 /* a read error occurred, throw away the result */
 543                 memset(eeprom_buff, 0xff, sizeof(u16) *
 544                        (last_word - first_word + 1));
 545         } else {
 546                 /* Device's eeprom is always little-endian, word addressable */
 547                 for (i = 0; i < last_word - first_word + 1; i++)
 548                         le16_to_cpus(&eeprom_buff[i]);
 549         }
 550
 551         memcpy(bytes, (u8 *)eeprom_buff + (eeprom->offset & 1), eeprom->len);
 552         kfree(eeprom_buff);
 553
 554         return ret_val;
 555 }
 556
 557 static int e1000_set_eeprom(struct net_device *netdev,
 558                             struct ethtool_eeprom *eeprom, u8 *bytes)
 559 {
 560         struct e1000_adapter *adapter = netdev_priv(netdev);
 561         struct e1000_hw *hw = &adapter->hw;
 562         u16 *eeprom_buff;
 563         void *ptr;
 564         int max_len;
 565         int first_word;
 566         int last_word;
 567         int ret_val = 0;
 568         u16 i;
 569
 570         if (eeprom->len == 0)
 571                 return -EOPNOTSUPP;
 572
 573         if (eeprom->magic !=
 574             (adapter->pdev->vendor | (adapter->pdev->device << 16)))
 575                 return -EFAULT;
 576
 577         if (adapter->flags & FLAG_READ_ONLY_NVM)
 578                 return -EINVAL;
 579
 580         max_len = hw->nvm.word_size * 2;
 581
 582         first_word = eeprom->offset >> 1;
 583         last_word = (eeprom->offset + eeprom->len - 1) >> 1;
 584         eeprom_buff = kmalloc(max_len, GFP_KERNEL);
 585         if (!eeprom_buff)
 586                 return -ENOMEM;
 587
 588         ptr = (void *)eeprom_buff;
 589
 590         pm_runtime_get_sync(netdev->dev.parent);
 591
 592         if (eeprom->offset & 1) {
 593                 /* need read/modify/write of first changed EEPROM word */
 594                 /* only the second byte of the word is being modified */
 595                 ret_val = e1000_read_nvm(hw, first_word, 1, &eeprom_buff[0]);
 596                 ptr++;
 597         }
 598         if (((eeprom->offset + eeprom->len) & 1) && (!ret_val))
 599                 /* need read/modify/write of last changed EEPROM word */
 600                 /* only the first byte of the word is being modified */
 601                 ret_val = e1000_read_nvm(hw, last_word, 1,
 602                                          &eeprom_buff[last_word - first_word]);
 603
 604         if (ret_val)
 605                 goto out;
 606
 607         /* Device's eeprom is always little-endian, word addressable */
 608         for (i = 0; i < last_word - first_word + 1; i++)
 609                 le16_to_cpus(&eeprom_buff[i]);
 610
 611         memcpy(ptr, bytes, eeprom->len);
 612
 613         for (i = 0; i < last_word - first_word + 1; i++)
 614                 cpu_to_le16s(&eeprom_buff[i]);
 615
 616         ret_val = e1000_write_nvm(hw, first_word,
 617                                   last_word - first_word + 1, eeprom_buff);
 618
 619         if (ret_val)
 620                 goto out;
 621
 622         /* Update the checksum over the first part of the EEPROM if needed
 623          * and flush shadow RAM for applicable controllers
 624          */
 625         if ((first_word <= NVM_CHECKSUM_REG) ||
 626             (hw->mac.type == e1000_82583) ||
 627             (hw->mac.type == e1000_82574) ||
 628             (hw->mac.type == e1000_82573))
 629                 ret_val = e1000e_update_nvm_checksum(hw);
 630
 631 out:
 632         pm_runtime_put_sync(netdev->dev.parent);
 633         kfree(eeprom_buff);
 634         return ret_val;
 635 }
 636
 637 static void e1000_get_drvinfo(struct net_device *netdev,
 638                               struct ethtool_drvinfo *drvinfo)
 639 {
 640         struct e1000_adapter *adapter = netdev_priv(netdev);
 641
 642         strlcpy(drvinfo->driver, e1000e_driver_name, sizeof(drvinfo->driver));
 643
 644         /* EEPROM image version # is reported as firmware version # for
 645          * PCI-E controllers
 646          */
 647         snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version),
 648                  "%d.%d-%d",
 649                  (adapter->eeprom_vers & 0xF000) >> 12,
 650                  (adapter->eeprom_vers & 0x0FF0) >> 4,
 651                  (adapter->eeprom_vers & 0x000F));
 652
 653         strlcpy(drvinfo->bus_info, pci_name(adapter->pdev),
 654                 sizeof(drvinfo->bus_info));
 655 }
 656
 657 static void e1000_get_ringparam(struct net_device *netdev,
 658                                 struct ethtool_ringparam *ring)
 659 {
 660         struct e1000_adapter *adapter = netdev_priv(netdev);
 661
 662         ring->rx_max_pending = E1000_MAX_RXD;
 663         ring->tx_max_pending = E1000_MAX_TXD;
 664         ring->rx_pending = adapter->rx_ring_count;
 665         ring->tx_pending = adapter->tx_ring_count;
 666 }
 667
 668 static int e1000_set_ringparam(struct net_device *netdev,
 669                                struct ethtool_ringparam *ring)
 670 {
 671         struct e1000_adapter *adapter = netdev_priv(netdev);
 672         struct e1000_ring *temp_tx = NULL, *temp_rx = NULL;
 673         int err = 0, size = sizeof(struct e1000_ring);
 674         bool set_tx = false, set_rx = false;
 675         u16 new_rx_count, new_tx_count;
 676
 677         if ((ring->rx_mini_pending) || (ring->rx_jumbo_pending))
 678                 return -EINVAL;
 679
 680         new_rx_count = clamp_t(u32, ring->rx_pending, E1000_MIN_RXD,
 681                                E1000_MAX_RXD);
 682         new_rx_count = ALIGN(new_rx_count, REQ_RX_DESCRIPTOR_MULTIPLE);
 683
 684         new_tx_count = clamp_t(u32, ring->tx_pending, E1000_MIN_TXD,
 685                                E1000_MAX_TXD);
 686         new_tx_count = ALIGN(new_tx_count, REQ_TX_DESCRIPTOR_MULTIPLE);
 687
 688         if ((new_tx_count == adapter->tx_ring_count) &&
 689             (new_rx_count == adapter->rx_ring_count))
 690                 /* nothing to do */
 691                 return 0;
 692
 693         while (test_and_set_bit(__E1000_RESETTING, &adapter->state))
 694                 usleep_range(1000, 2000);
 695
 696         if (!netif_running(adapter->netdev)) {
 697                 /* Set counts now and allocate resources during open() */
 698                 adapter->tx_ring->count = new_tx_count;
 699                 adapter->rx_ring->count = new_rx_count;
 700                 adapter->tx_ring_count = new_tx_count;
 701                 adapter->rx_ring_count = new_rx_count;
 702                 goto clear_reset;
 703         }
 704
 705         set_tx = (new_tx_count != adapter->tx_ring_count);
 706         set_rx = (new_rx_count != adapter->rx_ring_count);
 707
 708         /* Allocate temporary storage for ring updates */
 709         if (set_tx) {
 710                 temp_tx = vmalloc(size);
 711                 if (!temp_tx) {
 712                         err = -ENOMEM;
 713                         goto free_temp;
 714                 }
 715         }
 716         if (set_rx) {
 717                 temp_rx = vmalloc(size);
 718                 if (!temp_rx) {
 719                         err = -ENOMEM;
 720                         goto free_temp;
 721                 }
 722         }
 723
 724         pm_runtime_get_sync(netdev->dev.parent);
 725
 726         e1000e_down(adapter, true);
 727
 728         /* We can't just free everything and then setup again, because the
 729          * ISRs in MSI-X mode get passed pointers to the Tx and Rx ring
 730          * structs.  First, attempt to allocate new resources...
 731          */
 732         if (set_tx) {
 733                 memcpy(temp_tx, adapter->tx_ring, size);
 734                 temp_tx->count = new_tx_count;
 735                 err = e1000e_setup_tx_resources(temp_tx);
 736                 if (err)
 737                         goto err_setup;
 738         }
 739         if (set_rx) {
 740                 memcpy(temp_rx, adapter->rx_ring, size);
 741                 temp_rx->count = new_rx_count;
 742                 err = e1000e_setup_rx_resources(temp_rx);
 743                 if (err)
 744                         goto err_setup_rx;
 745         }
 746
 747         /* ...then free the old resources and copy back any new ring data */
 748         if (set_tx) {
 749                 e1000e_free_tx_resources(adapter->tx_ring);
 750                 memcpy(adapter->tx_ring, temp_tx, size);
 751                 adapter->tx_ring_count = new_tx_count;
 752         }
 753         if (set_rx) {
 754                 e1000e_free_rx_resources(adapter->rx_ring);
 755                 memcpy(adapter->rx_ring, temp_rx, size);
 756                 adapter->rx_ring_count = new_rx_count;
 757         }
 758
 759 err_setup_rx:
 760         if (err && set_tx)
 761                 e1000e_free_tx_resources(temp_tx);
 762 err_setup:
 763         e1000e_up(adapter);
 764         pm_runtime_put_sync(netdev->dev.parent);
 765 free_temp:
 766         vfree(temp_tx);
 767         vfree(temp_rx);
 768 clear_reset:
 769         clear_bit(__E1000_RESETTING, &adapter->state);
 770         return err;
 771 }
 772
 773 static bool reg_pattern_test(struct e1000_adapter *adapter, u64 *data,
 774                              int reg, int offset, u32 mask, u32 write)
 775 {
 776         u32 pat, val;
 777         static const u32 test[] = {
 778                 0x5A5A5A5A, 0xA5A5A5A5, 0x00000000, 0xFFFFFFFF
 779         };
 780         for (pat = 0; pat < ARRAY_SIZE(test); pat++) {
 781                 E1000_WRITE_REG_ARRAY(&adapter->hw, reg, offset,
 782                                       (test[pat] & write));
 783                 val = E1000_READ_REG_ARRAY(&adapter->hw, reg, offset);
 784                 if (val != (test[pat] & write & mask)) {
 785                         e_err("pattern test failed (reg 0x%05X): got 0x%08X expected 0x%08X\n",
 786                               reg + (offset << 2), val,
 787                               (test[pat] & write & mask));
 788                         *data = reg;
 789                         return true;
 790                 }
 791         }
 792         return false;
 793 }
 794
 795 static bool reg_set_and_check(struct e1000_adapter *adapter, u64 *data,
 796                               int reg, u32 mask, u32 write)
 797 {
 798         u32 val;
 799
 800         __ew32(&adapter->hw, reg, write & mask);
 801         val = __er32(&adapter->hw, reg);
 802         if ((write & mask) != (val & mask)) {
 803                 e_err("set/check test failed (reg 0x%05X): got 0x%08X expected 0x%08X\n",
 804                       reg, (val & mask), (write & mask));
 805                 *data = reg;
 806                 return true;
 807         }
 808         return false;
 809 }
 810
 811 #define REG_PATTERN_TEST_ARRAY(reg, offset, mask, write)                       \
 812         do {                                                                   \
 813                 if (reg_pattern_test(adapter, data, reg, offset, mask, write)) \
 814                         return 1;                                              \
 815         } while (0)
 816 #define REG_PATTERN_TEST(reg, mask, write)                                     \
 817         REG_PATTERN_TEST_ARRAY(reg, 0, mask, write)
 818
 819 #define REG_SET_AND_CHECK(reg, mask, write)                                    \
 820         do {                                                                   \
 821                 if (reg_set_and_check(adapter, data, reg, mask, write))        \
 822                         return 1;                                              \
 823         } while (0)
 824
 825 static int e1000_reg_test(struct e1000_adapter *adapter, u64 *data)
 826 {
 827         struct e1000_hw *hw = &adapter->hw;
 828         struct e1000_mac_info *mac = &adapter->hw.mac;
 829         u32 value;
 830         u32 before;
 831         u32 after;
 832         u32 i;
 833         u32 toggle;
 834         u32 mask;
 835         u32 wlock_mac = 0;
 836
 837         /* The status register is Read Only, so a write should fail.
 838          * Some bits that get toggled are ignored.  There are several bits
 839          * on newer hardware that are r/w.
 840          */
 841         switch (mac->type) {
 842         case e1000_82571:
 843         case e1000_82572:
 844         case e1000_80003es2lan:
 845                 toggle = 0x7FFFF3FF;
 846                 break;
 847         default:
 848                 toggle = 0x7FFFF033;
 849                 break;
 850         }
 851
 852         before = er32(STATUS);
 853         value = (er32(STATUS) & toggle);
 854         ew32(STATUS, toggle);
 855         after = er32(STATUS) & toggle;
 856         if (value != after) {
 857                 e_err("failed STATUS register test got: 0x%08X expected: 0x%08X\n",
 858                       after, value);
 859                 *data = 1;
 860                 return 1;
 861         }
 862         /* restore previous status */
 863         ew32(STATUS, before);
 864
 865         if (!(adapter->flags & FLAG_IS_ICH)) {
 866                 REG_PATTERN_TEST(E1000_FCAL, 0xFFFFFFFF, 0xFFFFFFFF);
 867                 REG_PATTERN_TEST(E1000_FCAH, 0x0000FFFF, 0xFFFFFFFF);
 868                 REG_PATTERN_TEST(E1000_FCT, 0x0000FFFF, 0xFFFFFFFF);
 869                 REG_PATTERN_TEST(E1000_VET, 0x0000FFFF, 0xFFFFFFFF);
 870         }
 871
 872         REG_PATTERN_TEST(E1000_RDTR, 0x0000FFFF, 0xFFFFFFFF);
 873         REG_PATTERN_TEST(E1000_RDBAH(0), 0xFFFFFFFF, 0xFFFFFFFF);
 874         REG_PATTERN_TEST(E1000_RDLEN(0), 0x000FFF80, 0x000FFFFF);
 875         REG_PATTERN_TEST(E1000_RDH(0), 0x0000FFFF, 0x0000FFFF);
 876         REG_PATTERN_TEST(E1000_RDT(0), 0x0000FFFF, 0x0000FFFF);
 877         REG_PATTERN_TEST(E1000_FCRTH, 0x0000FFF8, 0x0000FFF8);
 878         REG_PATTERN_TEST(E1000_FCTTV, 0x0000FFFF, 0x0000FFFF);
 879         REG_PATTERN_TEST(E1000_TIPG, 0x3FFFFFFF, 0x3FFFFFFF);
 880         REG_PATTERN_TEST(E1000_TDBAH(0), 0xFFFFFFFF, 0xFFFFFFFF);
 881         REG_PATTERN_TEST(E1000_TDLEN(0), 0x000FFF80, 0x000FFFFF);
 882
 883         REG_SET_AND_CHECK(E1000_RCTL, 0xFFFFFFFF, 0x00000000);
 884
 885         before = ((adapter->flags & FLAG_IS_ICH) ? 0x06C3B33E : 0x06DFB3FE);
 886         REG_SET_AND_CHECK(E1000_RCTL, before, 0x003FFFFB);
 887         REG_SET_AND_CHECK(E1000_TCTL, 0xFFFFFFFF, 0x00000000);
 888
 889         REG_SET_AND_CHECK(E1000_RCTL, before, 0xFFFFFFFF);
 890         REG_PATTERN_TEST(E1000_RDBAL(0), 0xFFFFFFF0, 0xFFFFFFFF);
 891         if (!(adapter->flags & FLAG_IS_ICH))
 892                 REG_PATTERN_TEST(E1000_TXCW, 0xC000FFFF, 0x0000FFFF);
 893         REG_PATTERN_TEST(E1000_TDBAL(0), 0xFFFFFFF0, 0xFFFFFFFF);
 894         REG_PATTERN_TEST(E1000_TIDV, 0x0000FFFF, 0x0000FFFF);
 895         mask = 0x8003FFFF;
 896         switch (mac->type) {
 897         case e1000_ich10lan:
 898         case e1000_pchlan:
 899         case e1000_pch2lan:
 900         case e1000_pch_lpt:
 901         case e1000_pch_spt:
 902         case e1000_pch_cnp:
 903         case e1000_pch_tgp:
 904         case e1000_pch_adp:
 905         case e1000_pch_mtp:
 906                 mask |= BIT(18);
 907                 break;
 908         default:
 909                 break;
 910         }
 911
 912         if (mac->type >= e1000_pch_lpt)
 913                 wlock_mac = (er32(FWSM) & E1000_FWSM_WLOCK_MAC_MASK) >>
 914                     E1000_FWSM_WLOCK_MAC_SHIFT;
 915
 916         for (i = 0; i < mac->rar_entry_count; i++) {
 917                 if (mac->type >= e1000_pch_lpt) {
 918                         /* Cannot test write-protected SHRAL[n] registers */
 919                         if ((wlock_mac == 1) || (wlock_mac && (i > wlock_mac)))
 920                                 continue;
 921
 922                         /* SHRAH[9] different than the others */
 923                         if (i == 10)
 924                                 mask |= BIT(30);
 925                         else
 926                                 mask &= ~BIT(30);
 927                 }
 928                 if (mac->type == e1000_pch2lan) {
 929                         /* SHRAH[0,1,2] different than previous */
 930                         if (i == 1)
 931                                 mask &= 0xFFF4FFFF;
 932                         /* SHRAH[3] different than SHRAH[0,1,2] */
 933                         if (i == 4)
 934                                 mask |= BIT(30);
 935                         /* RAR[1-6] owned by management engine - skipping */
 936                         if (i > 0)
 937                                 i += 6;
 938                 }
 939
 940                 REG_PATTERN_TEST_ARRAY(E1000_RA, ((i << 1) + 1), mask,
 941                                        0xFFFFFFFF);
 942                 /* reset index to actual value */
 943                 if ((mac->type == e1000_pch2lan) && (i > 6))
 944                         i -= 6;
 945         }
 946
 947         for (i = 0; i < mac->mta_reg_count; i++)
 948                 REG_PATTERN_TEST_ARRAY(E1000_MTA, i, 0xFFFFFFFF, 0xFFFFFFFF);
 949
 950         *data = 0;
 951
 952         return 0;
 953 }
 954
 955 static int e1000_eeprom_test(struct e1000_adapter *adapter, u64 *data)
 956 {
 957         u16 temp;
 958         u16 checksum = 0;
 959         u16 i;
 960
 961         *data = 0;
 962         /* Read and add up the contents of the EEPROM */
 963         for (i = 0; i < (NVM_CHECKSUM_REG + 1); i++) {
 964                 if ((e1000_read_nvm(&adapter->hw, i, 1, &temp)) < 0) {
 965                         *data = 1;
 966                         return *data;
 967                 }
 968                 checksum += temp;
 969         }
 970
 971         /* If Checksum is not Correct return error else test passed */
 972         if ((checksum != (u16)NVM_SUM) && !(*data))
 973                 *data = 2;
 974
 975         return *data;
 976 }
 977
 978 static irqreturn_t e1000_test_intr(int __always_unused irq, void *data)
 979 {
 980         struct net_device *netdev = (struct net_device *)data;
 981         struct e1000_adapter *adapter = netdev_priv(netdev);
 982         struct e1000_hw *hw = &adapter->hw;
 983
 984         adapter->test_icr |= er32(ICR);
 985
 986         return IRQ_HANDLED;
 987 }
 988
 989 static int e1000_intr_test(struct e1000_adapter *adapter, u64 *data)
 990 {
 991         struct net_device *netdev = adapter->netdev;
 992         struct e1000_hw *hw = &adapter->hw;
 993         u32 mask;
 994         u32 shared_int = 1;
 995         u32 irq = adapter->pdev->irq;
 996         int i;
 997         int ret_val = 0;
 998         int int_mode = E1000E_INT_MODE_LEGACY;
 999
1000         *data = 0;
1001
1002         /* NOTE: we don't test MSI/MSI-X interrupts here, yet */
1003         if (adapter->int_mode == E1000E_INT_MODE_MSIX) {
1004                 int_mode = adapter->int_mode;
1005                 e1000e_reset_interrupt_capability(adapter);
1006                 adapter->int_mode = E1000E_INT_MODE_LEGACY;
1007                 e1000e_set_interrupt_capability(adapter);
1008         }
1009         /* Hook up test interrupt handler just for this test */
1010         if (!request_irq(irq, e1000_test_intr, IRQF_PROBE_SHARED, netdev->name,
1011                          netdev)) {
1012                 shared_int = 0;
1013         } else if (request_irq(irq, e1000_test_intr, IRQF_SHARED, netdev->name,
1014                                netdev)) {
1015                 *data = 1;
1016                 ret_val = -1;
1017                 goto out;
1018         }
1019         e_info("testing %s interrupt\n", (shared_int ? "shared" : "unshared"));
1020
1021         /* Disable all the interrupts */
1022         ew32(IMC, 0xFFFFFFFF);
1023         e1e_flush();
1024         usleep_range(10000, 11000);
1025
1026         /* Test each interrupt */
1027         for (i = 0; i < 10; i++) {
1028                 /* Interrupt to test */
1029                 mask = BIT(i);
1030
1031                 if (adapter->flags & FLAG_IS_ICH) {
1032                         switch (mask) {
1033                         case E1000_ICR_RXSEQ:
1034                                 continue;
1035                         case 0x00000100:
1036                                 if (adapter->hw.mac.type == e1000_ich8lan ||
1037                                     adapter->hw.mac.type == e1000_ich9lan)
1038                                         continue;
1039                                 break;
1040                         default:
1041                                 break;
1042                         }
1043                 }
1044
1045                 if (!shared_int) {
1046                         /* Disable the interrupt to be reported in
1047                          * the cause register and then force the same
1048                          * interrupt and see if one gets posted.  If
1049                          * an interrupt was posted to the bus, the
1050                          * test failed.
1051                          */
1052                         adapter->test_icr = 0;
1053                         ew32(IMC, mask);
1054                         ew32(ICS, mask);
1055                         e1e_flush();
1056                         usleep_range(10000, 11000);
1057
1058                         if (adapter->test_icr & mask) {
1059                                 *data = 3;
1060                                 break;
1061                         }
1062                 }
1063
1064                 /* Enable the interrupt to be reported in
1065                  * the cause register and then force the same
1066                  * interrupt and see if one gets posted.  If
1067                  * an interrupt was not posted to the bus, the
1068                  * test failed.
1069                  */
1070                 adapter->test_icr = 0;
1071                 ew32(IMS, mask);
1072                 ew32(ICS, mask);
1073                 e1e_flush();
1074                 usleep_range(10000, 11000);
1075
1076                 if (!(adapter->test_icr & mask)) {
1077                         *data = 4;
1078                         break;
1079                 }
1080
1081                 if (!shared_int) {
1082                         /* Disable the other interrupts to be reported in
1083                          * the cause register and then force the other
1084                          * interrupts and see if any get posted.  If
1085                          * an interrupt was posted to the bus, the
1086                          * test failed.
1087                          */
1088                         adapter->test_icr = 0;
1089                         ew32(IMC, ~mask & 0x00007FFF);
1090                         ew32(ICS, ~mask & 0x00007FFF);
1091                         e1e_flush();
1092                         usleep_range(10000, 11000);
1093
1094                         if (adapter->test_icr) {
1095                                 *data = 5;
1096                                 break;
1097                         }
1098                 }
1099         }
1100
1101         /* Disable all the interrupts */
1102         ew32(IMC, 0xFFFFFFFF);
1103         e1e_flush();
1104         usleep_range(10000, 11000);
1105
1106         /* Unhook test interrupt handler */
1107         free_irq(irq, netdev);
1108
1109 out:
1110         if (int_mode == E1000E_INT_MODE_MSIX) {
1111                 e1000e_reset_interrupt_capability(adapter);
1112                 adapter->int_mode = int_mode;
1113                 e1000e_set_interrupt_capability(adapter);
1114         }
1115
1116         return ret_val;
1117 }
1118
1119 static void e1000_free_desc_rings(struct e1000_adapter *adapter)
1120 {
1121         struct e1000_ring *tx_ring = &adapter->test_tx_ring;
1122         struct e1000_ring *rx_ring = &adapter->test_rx_ring;
1123         struct pci_dev *pdev = adapter->pdev;
1124         struct e1000_buffer *buffer_info;
1125         int i;
1126
1127         if (tx_ring->desc && tx_ring->buffer_info) {
1128                 for (i = 0; i < tx_ring->count; i++) {
1129                         buffer_info = &tx_ring->buffer_info[i];
1130
1131                         if (buffer_info->dma)
1132                                 dma_unmap_single(&pdev->dev,
1133                                                  buffer_info->dma,
1134                                                  buffer_info->length,
1135                                                  DMA_TO_DEVICE);
1136                         dev_kfree_skb(buffer_info->skb);
1137                 }
1138         }
1139
1140         if (rx_ring->desc && rx_ring->buffer_info) {
1141                 for (i = 0; i < rx_ring->count; i++) {
1142                         buffer_info = &rx_ring->buffer_info[i];
1143
1144                         if (buffer_info->dma)
1145                                 dma_unmap_single(&pdev->dev,
1146                                                  buffer_info->dma,
1147                                                  2048, DMA_FROM_DEVICE);
1148                         dev_kfree_skb(buffer_info->skb);
1149                 }
1150         }
1151
1152         if (tx_ring->desc) {
1153                 dma_free_coherent(&pdev->dev, tx_ring->size, tx_ring->desc,
1154                                   tx_ring->dma);
1155                 tx_ring->desc = NULL;
1156         }
1157         if (rx_ring->desc) {
1158                 dma_free_coherent(&pdev->dev, rx_ring->size, rx_ring->desc,
1159                                   rx_ring->dma);
1160                 rx_ring->desc = NULL;
1161         }
1162
1163         kfree(tx_ring->buffer_info);
1164         tx_ring->buffer_info = NULL;
1165         kfree(rx_ring->buffer_info);
1166         rx_ring->buffer_info = NULL;
1167 }
1168
1169 static int e1000_setup_desc_rings(struct e1000_adapter *adapter)
1170 {
1171         struct e1000_ring *tx_ring = &adapter->test_tx_ring;
1172         struct e1000_ring *rx_ring = &adapter->test_rx_ring;
1173         struct pci_dev *pdev = adapter->pdev;
1174         struct e1000_hw *hw = &adapter->hw;
1175         u32 rctl;
1176         int i;
1177         int ret_val;
1178
1179         /* Setup Tx descriptor ring and Tx buffers */
1180
1181         if (!tx_ring->count)
1182                 tx_ring->count = E1000_DEFAULT_TXD;
1183
1184         tx_ring->buffer_info = kcalloc(tx_ring->count,
1185                                        sizeof(struct e1000_buffer), GFP_KERNEL);
1186         if (!tx_ring->buffer_info) {
1187                 ret_val = 1;
1188                 goto err_nomem;
1189         }
1190
1191         tx_ring->size = tx_ring->count * sizeof(struct e1000_tx_desc);
1192         tx_ring->size = ALIGN(tx_ring->size, 4096);
1193         tx_ring->desc = dma_alloc_coherent(&pdev->dev, tx_ring->size,
1194                                            &tx_ring->dma, GFP_KERNEL);
1195         if (!tx_ring->desc) {
1196                 ret_val = 2;
1197                 goto err_nomem;
1198         }
1199         tx_ring->next_to_use = 0;
1200         tx_ring->next_to_clean = 0;
1201
1202         ew32(TDBAL(0), ((u64)tx_ring->dma & 0x00000000FFFFFFFF));
1203         ew32(TDBAH(0), ((u64)tx_ring->dma >> 32));
1204         ew32(TDLEN(0), tx_ring->count * sizeof(struct e1000_tx_desc));
1205         ew32(TDH(0), 0);
1206         ew32(TDT(0), 0);
1207         ew32(TCTL, E1000_TCTL_PSP | E1000_TCTL_EN | E1000_TCTL_MULR |
1208              E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT |
1209              E1000_COLLISION_DISTANCE << E1000_COLD_SHIFT);
1210
1211         for (i = 0; i < tx_ring->count; i++) {
1212                 struct e1000_tx_desc *tx_desc = E1000_TX_DESC(*tx_ring, i);
1213                 struct sk_buff *skb;
1214                 unsigned int skb_size = 1024;
1215
1216                 skb = alloc_skb(skb_size, GFP_KERNEL);
1217                 if (!skb) {
1218                         ret_val = 3;
1219                         goto err_nomem;
1220                 }
1221                 skb_put(skb, skb_size);
1222                 tx_ring->buffer_info[i].skb = skb;
1223                 tx_ring->buffer_info[i].length = skb->len;
1224                 tx_ring->buffer_info[i].dma =
1225                     dma_map_single(&pdev->dev, skb->data, skb->len,
1226                                    DMA_TO_DEVICE);
1227                 if (dma_mapping_error(&pdev->dev,
1228                                       tx_ring->buffer_info[i].dma)) {
1229                         ret_val = 4;
1230                         goto err_nomem;
1231                 }
1232                 tx_desc->buffer_addr = cpu_to_le64(tx_ring->buffer_info[i].dma);
1233                 tx_desc->lower.data = cpu_to_le32(skb->len);
1234                 tx_desc->lower.data |= cpu_to_le32(E1000_TXD_CMD_EOP |
1235                                                    E1000_TXD_CMD_IFCS |
1236                                                    E1000_TXD_CMD_RS);
1237                 tx_desc->upper.data = 0;
1238         }
1239
1240         /* Setup Rx descriptor ring and Rx buffers */
1241
1242         if (!rx_ring->count)
1243                 rx_ring->count = E1000_DEFAULT_RXD;
1244
1245         rx_ring->buffer_info = kcalloc(rx_ring->count,
1246                                        sizeof(struct e1000_buffer), GFP_KERNEL);
1247         if (!rx_ring->buffer_info) {
1248                 ret_val = 5;
1249                 goto err_nomem;
1250         }
1251
1252         rx_ring->size = rx_ring->count * sizeof(union e1000_rx_desc_extended);
1253         rx_ring->desc = dma_alloc_coherent(&pdev->dev, rx_ring->size,
1254                                            &rx_ring->dma, GFP_KERNEL);
1255         if (!rx_ring->desc) {
1256                 ret_val = 6;
1257                 goto err_nomem;
1258         }
1259         rx_ring->next_to_use = 0;
1260         rx_ring->next_to_clean = 0;
1261
1262         rctl = er32(RCTL);
1263         if (!(adapter->flags2 & FLAG2_NO_DISABLE_RX))
1264                 ew32(RCTL, rctl & ~E1000_RCTL_EN);
1265         ew32(RDBAL(0), ((u64)rx_ring->dma & 0xFFFFFFFF));
1266         ew32(RDBAH(0), ((u64)rx_ring->dma >> 32));
1267         ew32(RDLEN(0), rx_ring->size);
1268         ew32(RDH(0), 0);
1269         ew32(RDT(0), 0);
1270         rctl = E1000_RCTL_EN | E1000_RCTL_BAM | E1000_RCTL_SZ_2048 |
1271             E1000_RCTL_UPE | E1000_RCTL_MPE | E1000_RCTL_LPE |
1272             E1000_RCTL_SBP | E1000_RCTL_SECRC |
1273             E1000_RCTL_LBM_NO | E1000_RCTL_RDMTS_HALF |
1274             (adapter->hw.mac.mc_filter_type << E1000_RCTL_MO_SHIFT);
1275         ew32(RCTL, rctl);
1276
1277         for (i = 0; i < rx_ring->count; i++) {
1278                 union e1000_rx_desc_extended *rx_desc;
1279                 struct sk_buff *skb;
1280
1281                 skb = alloc_skb(2048 + NET_IP_ALIGN, GFP_KERNEL);
1282                 if (!skb) {
1283                         ret_val = 7;
1284                         goto err_nomem;
1285                 }
1286                 skb_reserve(skb, NET_IP_ALIGN);
1287                 rx_ring->buffer_info[i].skb = skb;
1288                 rx_ring->buffer_info[i].dma =
1289                     dma_map_single(&pdev->dev, skb->data, 2048,
1290                                    DMA_FROM_DEVICE);
1291                 if (dma_mapping_error(&pdev->dev,
1292                                       rx_ring->buffer_info[i].dma)) {
1293                         ret_val = 8;
1294                         goto err_nomem;
1295                 }
1296                 rx_desc = E1000_RX_DESC_EXT(*rx_ring, i);
1297                 rx_desc->read.buffer_addr =
1298                     cpu_to_le64(rx_ring->buffer_info[i].dma);
1299                 memset(skb->data, 0x00, skb->len);
1300         }
1301
1302         return 0;
1303
1304 err_nomem:
1305         e1000_free_desc_rings(adapter);
1306         return ret_val;
1307 }
1308
1309 static void e1000_phy_disable_receiver(struct e1000_adapter *adapter)
1310 {
1311         /* Write out to PHY registers 29 and 30 to disable the Receiver. */
1312         e1e_wphy(&adapter->hw, 29, 0x001F);
1313         e1e_wphy(&adapter->hw, 30, 0x8FFC);
1314         e1e_wphy(&adapter->hw, 29, 0x001A);
1315         e1e_wphy(&adapter->hw, 30, 0x8FF0);
1316 }
1317
1318 static int e1000_integrated_phy_loopback(struct e1000_adapter *adapter)
1319 {
1320         struct e1000_hw *hw = &adapter->hw;
1321         u32 ctrl_reg = 0;
1322         u16 phy_reg = 0;
1323         s32 ret_val = 0;
1324
1325         hw->mac.autoneg = 0;
1326
1327         if (hw->phy.type == e1000_phy_ife) {
1328                 /* force 100, set loopback */
1329                 e1e_wphy(hw, MII_BMCR, 0x6100);
1330
1331                 /* Now set up the MAC to the same speed/duplex as the PHY. */
1332                 ctrl_reg = er32(CTRL);
1333                 ctrl_reg &= ~E1000_CTRL_SPD_SEL; /* Clear the speed sel bits */
1334                 ctrl_reg |= (E1000_CTRL_FRCSPD | /* Set the Force Speed Bit */
1335                              E1000_CTRL_FRCDPX | /* Set the Force Duplex Bit */
1336                              E1000_CTRL_SPD_100 |/* Force Speed to 100 */
1337                              E1000_CTRL_FD);     /* Force Duplex to FULL */
1338
1339                 ew32(CTRL, ctrl_reg);
1340                 e1e_flush();
1341                 usleep_range(500, 1000);
1342
1343                 return 0;
1344         }
1345
1346         /* Specific PHY configuration for loopback */
1347         switch (hw->phy.type) {
1348         case e1000_phy_m88:
1349                 /* Auto-MDI/MDIX Off */
1350                 e1e_wphy(hw, M88E1000_PHY_SPEC_CTRL, 0x0808);
1351                 /* reset to update Auto-MDI/MDIX */
1352                 e1e_wphy(hw, MII_BMCR, 0x9140);
1353                 /* autoneg off */
1354                 e1e_wphy(hw, MII_BMCR, 0x8140);
1355                 break;
1356         case e1000_phy_gg82563:
1357                 e1e_wphy(hw, GG82563_PHY_KMRN_MODE_CTRL, 0x1CC);
1358                 break;
1359         case e1000_phy_bm:
1360                 /* Set Default MAC Interface speed to 1GB */
1361                 e1e_rphy(hw, PHY_REG(2, 21), &phy_reg);
1362                 phy_reg &= ~0x0007;
1363                 phy_reg |= 0x006;
1364                 e1e_wphy(hw, PHY_REG(2, 21), phy_reg);
1365                 /* Assert SW reset for above settings to take effect */
1366                 hw->phy.ops.commit(hw);
1367                 usleep_range(1000, 2000);
1368                 /* Force Full Duplex */
1369                 e1e_rphy(hw, PHY_REG(769, 16), &phy_reg);
1370                 e1e_wphy(hw, PHY_REG(769, 16), phy_reg | 0x000C);
1371                 /* Set Link Up (in force link) */
1372                 e1e_rphy(hw, PHY_REG(776, 16), &phy_reg);
1373                 e1e_wphy(hw, PHY_REG(776, 16), phy_reg | 0x0040);
1374                 /* Force Link */
1375                 e1e_rphy(hw, PHY_REG(769, 16), &phy_reg);
1376                 e1e_wphy(hw, PHY_REG(769, 16), phy_reg | 0x0040);
1377                 /* Set Early Link Enable */
1378                 e1e_rphy(hw, PHY_REG(769, 20), &phy_reg);
1379                 e1e_wphy(hw, PHY_REG(769, 20), phy_reg | 0x0400);
1380                 break;
1381         case e1000_phy_82577:
1382         case e1000_phy_82578:
1383                 /* Workaround: K1 must be disabled for stable 1Gbps operation */
1384                 ret_val = hw->phy.ops.acquire(hw);
1385                 if (ret_val) {
1386                         e_err("Cannot setup 1Gbps loopback.\n");
1387                         return ret_val;
1388                 }
1389                 e1000_configure_k1_ich8lan(hw, false);
1390                 hw->phy.ops.release(hw);
1391                 break;
1392         case e1000_phy_82579:
1393                 /* Disable PHY energy detect power down */
1394                 e1e_rphy(hw, PHY_REG(0, 21), &phy_reg);
1395                 e1e_wphy(hw, PHY_REG(0, 21), phy_reg & ~BIT(3));
1396                 /* Disable full chip energy detect */
1397                 e1e_rphy(hw, PHY_REG(776, 18), &phy_reg);
1398                 e1e_wphy(hw, PHY_REG(776, 18), phy_reg | 1);
1399                 /* Enable loopback on the PHY */
1400                 e1e_wphy(hw, I82577_PHY_LBK_CTRL, 0x8001);
1401                 break;
1402         default:
1403                 break;
1404         }
1405
1406         /* force 1000, set loopback */
1407         e1e_wphy(hw, MII_BMCR, 0x4140);
1408         msleep(250);
1409
1410         /* Now set up the MAC to the same speed/duplex as the PHY. */
1411         ctrl_reg = er32(CTRL);
1412         ctrl_reg &= ~E1000_CTRL_SPD_SEL; /* Clear the speed sel bits */
1413         ctrl_reg |= (E1000_CTRL_FRCSPD | /* Set the Force Speed Bit */
1414                      E1000_CTRL_FRCDPX | /* Set the Force Duplex Bit */
1415                      E1000_CTRL_SPD_1000 |/* Force Speed to 1000 */
1416                      E1000_CTRL_FD);     /* Force Duplex to FULL */
1417
1418         if (adapter->flags & FLAG_IS_ICH)
1419                 ctrl_reg |= E1000_CTRL_SLU;     /* Set Link Up */
1420
1421         if (hw->phy.media_type == e1000_media_type_copper &&
1422             hw->phy.type == e1000_phy_m88) {
1423                 ctrl_reg |= E1000_CTRL_ILOS;    /* Invert Loss of Signal */
1424         } else {
1425                 /* Set the ILOS bit on the fiber Nic if half duplex link is
1426                  * detected.
1427                  */
1428                 if ((er32(STATUS) & E1000_STATUS_FD) == 0)
1429                         ctrl_reg |= (E1000_CTRL_ILOS | E1000_CTRL_SLU);
1430         }
1431
1432         ew32(CTRL, ctrl_reg);
1433
1434         /* Disable the receiver on the PHY so when a cable is plugged in, the
1435          * PHY does not begin to autoneg when a cable is reconnected to the NIC.
1436          */
1437         if (hw->phy.type == e1000_phy_m88)
1438                 e1000_phy_disable_receiver(adapter);
1439
1440         usleep_range(500, 1000);
1441
1442         return 0;
1443 }
1444
1445 static int e1000_set_82571_fiber_loopback(struct e1000_adapter *adapter)
1446 {
1447         struct e1000_hw *hw = &adapter->hw;
1448         u32 ctrl = er32(CTRL);
1449         int link;
1450
1451         /* special requirements for 82571/82572 fiber adapters */
1452
1453         /* jump through hoops to make sure link is up because serdes
1454          * link is hardwired up
1455          */
1456         ctrl |= E1000_CTRL_SLU;
1457         ew32(CTRL, ctrl);
1458
1459         /* disable autoneg */
1460         ctrl = er32(TXCW);
1461         ctrl &= ~BIT(31);
1462         ew32(TXCW, ctrl);
1463
1464         link = (er32(STATUS) & E1000_STATUS_LU);
1465
1466         if (!link) {
1467                 /* set invert loss of signal */
1468                 ctrl = er32(CTRL);
1469                 ctrl |= E1000_CTRL_ILOS;
1470                 ew32(CTRL, ctrl);
1471         }
1472
1473         /* special write to serdes control register to enable SerDes analog
1474          * loopback
1475          */
1476         ew32(SCTL, E1000_SCTL_ENABLE_SERDES_LOOPBACK);
1477         e1e_flush();
1478         usleep_range(10000, 11000);
1479
1480         return 0;
1481 }
1482
1483 /* only call this for fiber/serdes connections to es2lan */
1484 static int e1000_set_es2lan_mac_loopback(struct e1000_adapter *adapter)
1485 {
1486         struct e1000_hw *hw = &adapter->hw;
1487         u32 ctrlext = er32(CTRL_EXT);
1488         u32 ctrl = er32(CTRL);
1489
1490         /* save CTRL_EXT to restore later, reuse an empty variable (unused
1491          * on mac_type 80003es2lan)
1492          */
1493         adapter->tx_fifo_head = ctrlext;
1494
1495         /* clear the serdes mode bits, putting the device into mac loopback */
1496         ctrlext &= ~E1000_CTRL_EXT_LINK_MODE_PCIE_SERDES;
1497         ew32(CTRL_EXT, ctrlext);
1498
1499         /* force speed to 1000/FD, link up */
1500         ctrl &= ~(E1000_CTRL_SPD_1000 | E1000_CTRL_SPD_100);
1501         ctrl |= (E1000_CTRL_SLU | E1000_CTRL_FRCSPD | E1000_CTRL_FRCDPX |
1502                  E1000_CTRL_SPD_1000 | E1000_CTRL_FD);
1503         ew32(CTRL, ctrl);
1504
1505         /* set mac loopback */
1506         ctrl = er32(RCTL);
1507         ctrl |= E1000_RCTL_LBM_MAC;
1508         ew32(RCTL, ctrl);
1509
1510         /* set testing mode parameters (no need to reset later) */
1511 #define KMRNCTRLSTA_OPMODE (0x1F << 16)
1512 #define KMRNCTRLSTA_OPMODE_1GB_FD_GMII 0x0582
1513         ew32(KMRNCTRLSTA,
1514              (KMRNCTRLSTA_OPMODE | KMRNCTRLSTA_OPMODE_1GB_FD_GMII));
1515
1516         return 0;
1517 }
1518
1519 static int e1000_setup_loopback_test(struct e1000_adapter *adapter)
1520 {
1521         struct e1000_hw *hw = &adapter->hw;
1522         u32 rctl, fext_nvm11, tarc0;
1523
1524         if (hw->mac.type >= e1000_pch_spt) {
1525                 fext_nvm11 = er32(FEXTNVM11);
1526                 fext_nvm11 |= E1000_FEXTNVM11_DISABLE_MULR_FIX;
1527                 ew32(FEXTNVM11, fext_nvm11);
1528                 tarc0 = er32(TARC(0));
1529                 /* clear bits 28 & 29 (control of MULR concurrent requests) */
1530                 tarc0 &= 0xcfffffff;
1531                 /* set bit 29 (value of MULR requests is now 2) */
1532                 tarc0 |= 0x20000000;
1533                 ew32(TARC(0), tarc0);
1534         }
1535         if (hw->phy.media_type == e1000_media_type_fiber ||
1536             hw->phy.media_type == e1000_media_type_internal_serdes) {
1537                 switch (hw->mac.type) {
1538                 case e1000_80003es2lan:
1539                         return e1000_set_es2lan_mac_loopback(adapter);
1540                 case e1000_82571:
1541                 case e1000_82572:
1542                         return e1000_set_82571_fiber_loopback(adapter);
1543                 default:
1544                         rctl = er32(RCTL);
1545                         rctl |= E1000_RCTL_LBM_TCVR;
1546                         ew32(RCTL, rctl);
1547                         return 0;
1548                 }
1549         } else if (hw->phy.media_type == e1000_media_type_copper) {
1550                 return e1000_integrated_phy_loopback(adapter);
1551         }
1552
1553         return 7;
1554 }
1555
1556 static void e1000_loopback_cleanup(struct e1000_adapter *adapter)
1557 {
1558         struct e1000_hw *hw = &adapter->hw;
1559         u32 rctl, fext_nvm11, tarc0;
1560         u16 phy_reg;
1561
1562         rctl = er32(RCTL);
1563         rctl &= ~(E1000_RCTL_LBM_TCVR | E1000_RCTL_LBM_MAC);
1564         ew32(RCTL, rctl);
1565
1566         switch (hw->mac.type) {
1567         case e1000_pch_spt:
1568         case e1000_pch_cnp:
1569         case e1000_pch_tgp:
1570         case e1000_pch_adp:
1571         case e1000_pch_mtp:
1572                 fext_nvm11 = er32(FEXTNVM11);
1573                 fext_nvm11 &= ~E1000_FEXTNVM11_DISABLE_MULR_FIX;
1574                 ew32(FEXTNVM11, fext_nvm11);
1575                 tarc0 = er32(TARC(0));
1576                 /* clear bits 28 & 29 (control of MULR concurrent requests) */
1577                 /* set bit 29 (value of MULR requests is now 0) */
1578                 tarc0 &= 0xcfffffff;
1579                 ew32(TARC(0), tarc0);
1580                 fallthrough;
1581         case e1000_80003es2lan:
1582                 if (hw->phy.media_type == e1000_media_type_fiber ||
1583                     hw->phy.media_type == e1000_media_type_internal_serdes) {
1584                         /* restore CTRL_EXT, stealing space from tx_fifo_head */
1585                         ew32(CTRL_EXT, adapter->tx_fifo_head);
1586                         adapter->tx_fifo_head = 0;
1587                 }
1588                 fallthrough;
1589         case e1000_82571:
1590         case e1000_82572:
1591                 if (hw->phy.media_type == e1000_media_type_fiber ||
1592                     hw->phy.media_type == e1000_media_type_internal_serdes) {
1593                         ew32(SCTL, E1000_SCTL_DISABLE_SERDES_LOOPBACK);
1594                         e1e_flush();
1595                         usleep_range(10000, 11000);
1596                         break;
1597                 }
1598                 fallthrough;
1599         default:
1600                 hw->mac.autoneg = 1;
1601                 if (hw->phy.type == e1000_phy_gg82563)
1602                         e1e_wphy(hw, GG82563_PHY_KMRN_MODE_CTRL, 0x180);
1603                 e1e_rphy(hw, MII_BMCR, &phy_reg);
1604                 if (phy_reg & BMCR_LOOPBACK) {
1605                         phy_reg &= ~BMCR_LOOPBACK;
1606                         e1e_wphy(hw, MII_BMCR, phy_reg);
1607                         if (hw->phy.ops.commit)
1608                                 hw->phy.ops.commit(hw);
1609                 }
1610                 break;
1611         }
1612 }
1613
1614 static void e1000_create_lbtest_frame(struct sk_buff *skb,
1615                                       unsigned int frame_size)
1616 {
1617         memset(skb->data, 0xFF, frame_size);
1618         frame_size &= ~1;
1619         memset(&skb->data[frame_size / 2], 0xAA, frame_size / 2 - 1);
1620         skb->data[frame_size / 2 + 10] = 0xBE;
1621         skb->data[frame_size / 2 + 12] = 0xAF;
1622 }
1623
1624 static int e1000_check_lbtest_frame(struct sk_buff *skb,
1625                                     unsigned int frame_size)
1626 {
1627         frame_size &= ~1;
1628         if (*(skb->data + 3) == 0xFF)
1629                 if ((*(skb->data + frame_size / 2 + 10) == 0xBE) &&
1630                     (*(skb->data + frame_size / 2 + 12) == 0xAF))
1631                         return 0;
1632         return 13;
1633 }
1634
1635 static int e1000_run_loopback_test(struct e1000_adapter *adapter)
1636 {
1637         struct e1000_ring *tx_ring = &adapter->test_tx_ring;
1638         struct e1000_ring *rx_ring = &adapter->test_rx_ring;
1639         struct pci_dev *pdev = adapter->pdev;
1640         struct e1000_hw *hw = &adapter->hw;
1641         struct e1000_buffer *buffer_info;
1642         int i, j, k, l;
1643         int lc;
1644         int good_cnt;
1645         int ret_val = 0;
1646         unsigned long time;
1647
1648         ew32(RDT(0), rx_ring->count - 1);
1649
1650         /* Calculate the loop count based on the largest descriptor ring
1651          * The idea is to wrap the largest ring a number of times using 64
1652          * send/receive pairs during each loop
1653          */
1654
1655         if (rx_ring->count <= tx_ring->count)
1656                 lc = ((tx_ring->count / 64) * 2) + 1;
1657         else
1658                 lc = ((rx_ring->count / 64) * 2) + 1;
1659
1660         k = 0;
1661         l = 0;
1662         /* loop count loop */
1663         for (j = 0; j <= lc; j++) {
1664                 /* send the packets */
1665                 for (i = 0; i < 64; i++) {
1666                         buffer_info = &tx_ring->buffer_info[k];
1667
1668                         e1000_create_lbtest_frame(buffer_info->skb, 1024);
1669                         dma_sync_single_for_device(&pdev->dev,
1670                                                    buffer_info->dma,
1671                                                    buffer_info->length,
1672                                                    DMA_TO_DEVICE);
1673                         k++;
1674                         if (k == tx_ring->count)
1675                                 k = 0;
1676                 }
1677                 ew32(TDT(0), k);
1678                 e1e_flush();
1679                 msleep(200);
1680                 time = jiffies; /* set the start time for the receive */
1681                 good_cnt = 0;
1682                 /* receive the sent packets */
1683                 do {
1684                         buffer_info = &rx_ring->buffer_info[l];
1685
1686                         dma_sync_single_for_cpu(&pdev->dev,
1687                                                 buffer_info->dma, 2048,
1688                                                 DMA_FROM_DEVICE);
1689
1690                         ret_val = e1000_check_lbtest_frame(buffer_info->skb,
1691                                                            1024);
1692                         if (!ret_val)
1693                                 good_cnt++;
1694                         l++;
1695                         if (l == rx_ring->count)
1696                                 l = 0;
1697                         /* time + 20 msecs (200 msecs on 2.4) is more than
1698                          * enough time to complete the receives, if it's
1699                          * exceeded, break and error off
1700                          */
1701                 } while ((good_cnt < 64) && !time_after(jiffies, time + 20));
1702                 if (good_cnt != 64) {
1703                         ret_val = 13;   /* ret_val is the same as mis-compare */
1704                         break;
1705                 }
1706                 if (time_after(jiffies, time + 20)) {
1707                         ret_val = 14;   /* error code for time out error */
1708                         break;
1709                 }
1710         }
1711         return ret_val;
1712 }
1713
1714 static int e1000_loopback_test(struct e1000_adapter *adapter, u64 *data)
1715 {
1716         struct e1000_hw *hw = &adapter->hw;
1717
1718         /* PHY loopback cannot be performed if SoL/IDER sessions are active */
1719         if (hw->phy.ops.check_reset_block &&
1720             hw->phy.ops.check_reset_block(hw)) {
1721                 e_err("Cannot do PHY loopback test when SoL/IDER is active.\n");
1722                 *data = 0;
1723                 goto out;
1724         }
1725
1726         *data = e1000_setup_desc_rings(adapter);
1727         if (*data)
1728                 goto out;
1729
1730         *data = e1000_setup_loopback_test(adapter);
1731         if (*data)
1732                 goto err_loopback;
1733
1734         *data = e1000_run_loopback_test(adapter);
1735         e1000_loopback_cleanup(adapter);
1736
1737 err_loopback:
1738         e1000_free_desc_rings(adapter);
1739 out:
1740         return *data;
1741 }
1742
1743 static int e1000_link_test(struct e1000_adapter *adapter, u64 *data)
1744 {
1745         struct e1000_hw *hw = &adapter->hw;
1746
1747         *data = 0;
1748         if (hw->phy.media_type == e1000_media_type_internal_serdes) {
1749                 int i = 0;
1750
1751                 hw->mac.serdes_has_link = false;
1752
1753                 /* On some blade server designs, link establishment
1754                  * could take as long as 2-3 minutes
1755                  */
1756                 do {
1757                         hw->mac.ops.check_for_link(hw);
1758                         if (hw->mac.serdes_has_link)
1759                                 return *data;
1760                         msleep(20);
1761                 } while (i++ < 3750);
1762
1763                 *data = 1;
1764         } else {
1765                 hw->mac.ops.check_for_link(hw);
1766                 if (hw->mac.autoneg)
1767                         /* On some Phy/switch combinations, link establishment
1768                          * can take a few seconds more than expected.
1769                          */
1770                         msleep_interruptible(5000);
1771
1772                 if (!(er32(STATUS) & E1000_STATUS_LU))
1773                         *data = 1;
1774         }
1775         return *data;
1776 }
1777
1778 static int e1000e_get_sset_count(struct net_device __always_unused *netdev,
1779                                  int sset)
1780 {
1781         switch (sset) {
1782         case ETH_SS_TEST:
1783                 return E1000_TEST_LEN;
1784         case ETH_SS_STATS:
1785                 return E1000_STATS_LEN;
1786         case ETH_SS_PRIV_FLAGS:
1787                 return E1000E_PRIV_FLAGS_STR_LEN;
1788         default:
1789                 return -EOPNOTSUPP;
1790         }
1791 }
1792
1793 static void e1000_diag_test(struct net_device *netdev,
1794                             struct ethtool_test *eth_test, u64 *data)
1795 {
1796         struct e1000_adapter *adapter = netdev_priv(netdev);
1797         u16 autoneg_advertised;
1798         u8 forced_speed_duplex;
1799         u8 autoneg;
1800         bool if_running = netif_running(netdev);
1801
1802         pm_runtime_get_sync(netdev->dev.parent);
1803
1804         set_bit(__E1000_TESTING, &adapter->state);
1805
1806         if (!if_running) {
1807                 /* Get control of and reset hardware */
1808                 if (adapter->flags & FLAG_HAS_AMT)
1809                         e1000e_get_hw_control(adapter);
1810
1811                 e1000e_power_up_phy(adapter);
1812
1813                 adapter->hw.phy.autoneg_wait_to_complete = 1;
1814                 e1000e_reset(adapter);
1815                 adapter->hw.phy.autoneg_wait_to_complete = 0;
1816         }
1817
1818         if (eth_test->flags == ETH_TEST_FL_OFFLINE) {
1819                 /* Offline tests */
1820
1821                 /* save speed, duplex, autoneg settings */
1822                 autoneg_advertised = adapter->hw.phy.autoneg_advertised;
1823                 forced_speed_duplex = adapter->hw.mac.forced_speed_duplex;
1824                 autoneg = adapter->hw.mac.autoneg;
1825
1826                 e_info("offline testing starting\n");
1827
1828                 if (if_running)
1829                         /* indicate we're in test mode */
1830                         e1000e_close(netdev);
1831
1832                 if (e1000_reg_test(adapter, &data[0]))
1833                         eth_test->flags |= ETH_TEST_FL_FAILED;
1834
1835                 e1000e_reset(adapter);
1836                 if (e1000_eeprom_test(adapter, &data[1]))
1837                         eth_test->flags |= ETH_TEST_FL_FAILED;
1838
1839                 e1000e_reset(adapter);
1840                 if (e1000_intr_test(adapter, &data[2]))
1841                         eth_test->flags |= ETH_TEST_FL_FAILED;
1842
1843                 e1000e_reset(adapter);
1844                 if (e1000_loopback_test(adapter, &data[3]))
1845                         eth_test->flags |= ETH_TEST_FL_FAILED;
1846
1847                 /* force this routine to wait until autoneg complete/timeout */
1848                 adapter->hw.phy.autoneg_wait_to_complete = 1;
1849                 e1000e_reset(adapter);
1850                 adapter->hw.phy.autoneg_wait_to_complete = 0;
1851
1852                 if (e1000_link_test(adapter, &data[4]))
1853                         eth_test->flags |= ETH_TEST_FL_FAILED;
1854
1855                 /* restore speed, duplex, autoneg settings */
1856                 adapter->hw.phy.autoneg_advertised = autoneg_advertised;
1857                 adapter->hw.mac.forced_speed_duplex = forced_speed_duplex;
1858                 adapter->hw.mac.autoneg = autoneg;
1859                 e1000e_reset(adapter);
1860
1861                 clear_bit(__E1000_TESTING, &adapter->state);
1862                 if (if_running)
1863                         e1000e_open(netdev);
1864         } else {
1865                 /* Online tests */
1866
1867                 e_info("online testing starting\n");
1868
1869                 /* register, eeprom, intr and loopback tests not run online */
1870                 data[0] = 0;
1871                 data[1] = 0;
1872                 data[2] = 0;
1873                 data[3] = 0;
1874
1875                 if (e1000_link_test(adapter, &data[4]))
1876                         eth_test->flags |= ETH_TEST_FL_FAILED;
1877
1878                 clear_bit(__E1000_TESTING, &adapter->state);
1879         }
1880
1881         if (!if_running) {
1882                 e1000e_reset(adapter);
1883
1884                 if (adapter->flags & FLAG_HAS_AMT)
1885                         e1000e_release_hw_control(adapter);
1886         }
1887
1888         msleep_interruptible(4 * 1000);
1889
1890         pm_runtime_put_sync(netdev->dev.parent);
1891 }
1892
1893 static void e1000_get_wol(struct net_device *netdev,
1894                           struct ethtool_wolinfo *wol)
1895 {
1896         struct e1000_adapter *adapter = netdev_priv(netdev);
1897
1898         wol->supported = 0;
1899         wol->wolopts = 0;
1900
1901         if (!(adapter->flags & FLAG_HAS_WOL) ||
1902             !device_can_wakeup(&adapter->pdev->dev))
1903                 return;
1904
1905         wol->supported = WAKE_UCAST | WAKE_MCAST |
1906             WAKE_BCAST | WAKE_MAGIC | WAKE_PHY;
1907
1908         /* apply any specific unsupported masks here */
1909         if (adapter->flags & FLAG_NO_WAKE_UCAST) {
1910                 wol->supported &= ~WAKE_UCAST;
1911
1912                 if (adapter->wol & E1000_WUFC_EX)
1913                         e_err("Interface does not support directed (unicast) frame wake-up packets\n");
1914         }
1915
1916         if (adapter->wol & E1000_WUFC_EX)
1917                 wol->wolopts |= WAKE_UCAST;
1918         if (adapter->wol & E1000_WUFC_MC)
1919                 wol->wolopts |= WAKE_MCAST;
1920         if (adapter->wol & E1000_WUFC_BC)
1921                 wol->wolopts |= WAKE_BCAST;
1922         if (adapter->wol & E1000_WUFC_MAG)
1923                 wol->wolopts |= WAKE_MAGIC;
1924         if (adapter->wol & E1000_WUFC_LNKC)
1925                 wol->wolopts |= WAKE_PHY;
1926 }
1927
1928 static int e1000_set_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)
1929 {
1930         struct e1000_adapter *adapter = netdev_priv(netdev);
1931
1932         if (!(adapter->flags & FLAG_HAS_WOL) ||
1933             !device_can_wakeup(&adapter->pdev->dev) ||
1934             (wol->wolopts & ~(WAKE_UCAST | WAKE_MCAST | WAKE_BCAST |
1935                               WAKE_MAGIC | WAKE_PHY)))
1936                 return -EOPNOTSUPP;
1937
1938         /* these settings will always override what we currently have */
1939         adapter->wol = 0;
1940
1941         if (wol->wolopts & WAKE_UCAST)
1942                 adapter->wol |= E1000_WUFC_EX;
1943         if (wol->wolopts & WAKE_MCAST)
1944                 adapter->wol |= E1000_WUFC_MC;
1945         if (wol->wolopts & WAKE_BCAST)
1946                 adapter->wol |= E1000_WUFC_BC;
1947         if (wol->wolopts & WAKE_MAGIC)
1948                 adapter->wol |= E1000_WUFC_MAG;
1949         if (wol->wolopts & WAKE_PHY)
1950                 adapter->wol |= E1000_WUFC_LNKC;
1951
1952         device_set_wakeup_enable(&adapter->pdev->dev, adapter->wol);
1953
1954         return 0;
1955 }
1956
1957 static int e1000_set_phys_id(struct net_device *netdev,
1958                              enum ethtool_phys_id_state state)
1959 {
1960         struct e1000_adapter *adapter = netdev_priv(netdev);
1961         struct e1000_hw *hw = &adapter->hw;
1962
1963         switch (state) {
1964         case ETHTOOL_ID_ACTIVE:
1965                 pm_runtime_get_sync(netdev->dev.parent);
1966
1967                 if (!hw->mac.ops.blink_led)
1968                         return 2;       /* cycle on/off twice per second */
1969
1970                 hw->mac.ops.blink_led(hw);
1971                 break;
1972
1973         case ETHTOOL_ID_INACTIVE:
1974                 if (hw->phy.type == e1000_phy_ife)
1975                         e1e_wphy(hw, IFE_PHY_SPECIAL_CONTROL_LED, 0);
1976                 hw->mac.ops.led_off(hw);
1977                 hw->mac.ops.cleanup_led(hw);
1978                 pm_runtime_put_sync(netdev->dev.parent);
1979                 break;
1980
1981         case ETHTOOL_ID_ON:
1982                 hw->mac.ops.led_on(hw);
1983                 break;
1984
1985         case ETHTOOL_ID_OFF:
1986                 hw->mac.ops.led_off(hw);
1987                 break;
1988         }
1989
1990         return 0;
1991 }
1992
1993 static int e1000_get_coalesce(struct net_device *netdev,
1994                               struct ethtool_coalesce *ec)
1995 {
1996         struct e1000_adapter *adapter = netdev_priv(netdev);
1997
1998         if (adapter->itr_setting <= 4)
1999                 ec->rx_coalesce_usecs = adapter->itr_setting;
2000         else
2001                 ec->rx_coalesce_usecs = 1000000 / adapter->itr_setting;
2002
2003         return 0;
2004 }
2005
2006 static int e1000_set_coalesce(struct net_device *netdev,
2007                               struct ethtool_coalesce *ec)
2008 {
2009         struct e1000_adapter *adapter = netdev_priv(netdev);
2010
2011         if ((ec->rx_coalesce_usecs > E1000_MAX_ITR_USECS) ||
2012             ((ec->rx_coalesce_usecs > 4) &&
2013              (ec->rx_coalesce_usecs < E1000_MIN_ITR_USECS)) ||
2014             (ec->rx_coalesce_usecs == 2))
2015                 return -EINVAL;
2016
2017         if (ec->rx_coalesce_usecs == 4) {
2018                 adapter->itr_setting = 4;
2019                 adapter->itr = adapter->itr_setting;
2020         } else if (ec->rx_coalesce_usecs <= 3) {
2021                 adapter->itr = 20000;
2022                 adapter->itr_setting = ec->rx_coalesce_usecs;
2023         } else {
2024                 adapter->itr = (1000000 / ec->rx_coalesce_usecs);
2025                 adapter->itr_setting = adapter->itr & ~3;
2026         }
2027
2028         pm_runtime_get_sync(netdev->dev.parent);
2029
2030         if (adapter->itr_setting != 0)
2031                 e1000e_write_itr(adapter, adapter->itr);
2032         else
2033                 e1000e_write_itr(adapter, 0);
2034
2035         pm_runtime_put_sync(netdev->dev.parent);
2036
2037         return 0;
2038 }
2039
2040 static int e1000_nway_reset(struct net_device *netdev)
2041 {
2042         struct e1000_adapter *adapter = netdev_priv(netdev);
2043
2044         if (!netif_running(netdev))
2045                 return -EAGAIN;
2046
2047         if (!adapter->hw.mac.autoneg)
2048                 return -EINVAL;
2049
2050         pm_runtime_get_sync(netdev->dev.parent);
2051         e1000e_reinit_locked(adapter);
2052         pm_runtime_put_sync(netdev->dev.parent);
2053
2054         return 0;
2055 }
2056
2057 static void e1000_get_ethtool_stats(struct net_device *netdev,
2058                                     struct ethtool_stats __always_unused *stats,
2059                                     u64 *data)
2060 {
2061         struct e1000_adapter *adapter = netdev_priv(netdev);
2062         struct rtnl_link_stats64 net_stats;
2063         int i;
2064         char *p = NULL;
2065
2066         pm_runtime_get_sync(netdev->dev.parent);
2067
2068         dev_get_stats(netdev, &net_stats);
2069
2070         pm_runtime_put_sync(netdev->dev.parent);
2071
2072         for (i = 0; i < E1000_GLOBAL_STATS_LEN; i++) {
2073                 switch (e1000_gstrings_stats[i].type) {
2074                 case NETDEV_STATS:
2075                         p = (char *)&net_stats +
2076                             e1000_gstrings_stats[i].stat_offset;
2077                         break;
2078                 case E1000_STATS:
2079                         p = (char *)adapter +
2080                             e1000_gstrings_stats[i].stat_offset;
2081                         break;
2082                 default:
2083                         data[i] = 0;
2084                         continue;
2085                 }
2086
2087                 data[i] = (e1000_gstrings_stats[i].sizeof_stat ==
2088                            sizeof(u64)) ? *(u64 *)p : *(u32 *)p;
2089         }
2090 }
2091
2092 static void e1000_get_strings(struct net_device __always_unused *netdev,
2093                               u32 stringset, u8 *data)
2094 {
2095         u8 *p = data;
2096         int i;
2097
2098         switch (stringset) {
2099         case ETH_SS_TEST:
2100                 memcpy(data, e1000_gstrings_test, sizeof(e1000_gstrings_test));
2101                 break;
2102         case ETH_SS_STATS:
2103                 for (i = 0; i < E1000_GLOBAL_STATS_LEN; i++) {
2104                         memcpy(p, e1000_gstrings_stats[i].stat_string,
2105                                ETH_GSTRING_LEN);
2106                         p += ETH_GSTRING_LEN;
2107                 }
2108                 break;
2109         case ETH_SS_PRIV_FLAGS:
2110                 memcpy(data, e1000e_priv_flags_strings,
2111                        E1000E_PRIV_FLAGS_STR_LEN * ETH_GSTRING_LEN);
2112                 break;
2113         }
2114 }
2115
2116 static int e1000_get_rxnfc(struct net_device *netdev,
2117                            struct ethtool_rxnfc *info,
2118                            u32 __always_unused *rule_locs)
2119 {
2120         info->data = 0;
2121
2122         switch (info->cmd) {
2123         case ETHTOOL_GRXFH: {
2124                 struct e1000_adapter *adapter = netdev_priv(netdev);
2125                 struct e1000_hw *hw = &adapter->hw;
2126                 u32 mrqc;
2127
2128                 pm_runtime_get_sync(netdev->dev.parent);
2129                 mrqc = er32(MRQC);
2130                 pm_runtime_put_sync(netdev->dev.parent);
2131
2132                 if (!(mrqc & E1000_MRQC_RSS_FIELD_MASK))
2133                         return 0;
2134
2135                 switch (info->flow_type) {
2136                 case TCP_V4_FLOW:
2137                         if (mrqc & E1000_MRQC_RSS_FIELD_IPV4_TCP)
2138                                 info->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
2139                         fallthrough;
2140                 case UDP_V4_FLOW:
2141                 case SCTP_V4_FLOW:
2142                 case AH_ESP_V4_FLOW:
2143                 case IPV4_FLOW:
2144                         if (mrqc & E1000_MRQC_RSS_FIELD_IPV4)
2145                                 info->data |= RXH_IP_SRC | RXH_IP_DST;
2146                         break;
2147                 case TCP_V6_FLOW:
2148                         if (mrqc & E1000_MRQC_RSS_FIELD_IPV6_TCP)
2149                                 info->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
2150                         fallthrough;
2151                 case UDP_V6_FLOW:
2152                 case SCTP_V6_FLOW:
2153                 case AH_ESP_V6_FLOW:
2154                 case IPV6_FLOW:
2155                         if (mrqc & E1000_MRQC_RSS_FIELD_IPV6)
2156                                 info->data |= RXH_IP_SRC | RXH_IP_DST;
2157                         break;
2158                 default:
2159                         break;
2160                 }
2161                 return 0;
2162         }
2163         default:
2164                 return -EOPNOTSUPP;
2165         }
2166 }
2167
2168 static int e1000e_get_eee(struct net_device *netdev, struct ethtool_eee *edata)
2169 {
2170         struct e1000_adapter *adapter = netdev_priv(netdev);
2171         struct e1000_hw *hw = &adapter->hw;
2172         u16 cap_addr, lpa_addr, pcs_stat_addr, phy_data;
2173         u32 ret_val;
2174
2175         if (!(adapter->flags2 & FLAG2_HAS_EEE))
2176                 return -EOPNOTSUPP;
2177
2178         switch (hw->phy.type) {
2179         case e1000_phy_82579:
2180                 cap_addr = I82579_EEE_CAPABILITY;
2181                 lpa_addr = I82579_EEE_LP_ABILITY;
2182                 pcs_stat_addr = I82579_EEE_PCS_STATUS;
2183                 break;
2184         case e1000_phy_i217:
2185                 cap_addr = I217_EEE_CAPABILITY;
2186                 lpa_addr = I217_EEE_LP_ABILITY;
2187                 pcs_stat_addr = I217_EEE_PCS_STATUS;
2188                 break;
2189         default:
2190                 return -EOPNOTSUPP;
2191         }
2192
2193         pm_runtime_get_sync(netdev->dev.parent);
2194
2195         ret_val = hw->phy.ops.acquire(hw);
2196         if (ret_val) {
2197                 pm_runtime_put_sync(netdev->dev.parent);
2198                 return -EBUSY;
2199         }
2200
2201         /* EEE Capability */
2202         ret_val = e1000_read_emi_reg_locked(hw, cap_addr, &phy_data);
2203         if (ret_val)
2204                 goto release;
2205         edata->supported = mmd_eee_cap_to_ethtool_sup_t(phy_data);
2206
2207         /* EEE Advertised */
2208         edata->advertised = mmd_eee_adv_to_ethtool_adv_t(adapter->eee_advert);
2209
2210         /* EEE Link Partner Advertised */
2211         ret_val = e1000_read_emi_reg_locked(hw, lpa_addr, &phy_data);
2212         if (ret_val)
2213                 goto release;
2214         edata->lp_advertised = mmd_eee_adv_to_ethtool_adv_t(phy_data);
2215
2216         /* EEE PCS Status */
2217         ret_val = e1000_read_emi_reg_locked(hw, pcs_stat_addr, &phy_data);
2218         if (ret_val)
2219                 goto release;
2220         if (hw->phy.type == e1000_phy_82579)
2221                 phy_data <<= 8;
2222
2223         /* Result of the EEE auto negotiation - there is no register that
2224          * has the status of the EEE negotiation so do a best-guess based
2225          * on whether Tx or Rx LPI indications have been received.
2226          */
2227         if (phy_data & (E1000_EEE_TX_LPI_RCVD | E1000_EEE_RX_LPI_RCVD))
2228                 edata->eee_active = true;
2229
2230         edata->eee_enabled = !hw->dev_spec.ich8lan.eee_disable;
2231         edata->tx_lpi_enabled = true;
2232         edata->tx_lpi_timer = er32(LPIC) >> E1000_LPIC_LPIET_SHIFT;
2233
2234 release:
2235         hw->phy.ops.release(hw);
2236         if (ret_val)
2237                 ret_val = -ENODATA;
2238
2239         pm_runtime_put_sync(netdev->dev.parent);
2240
2241         return ret_val;
2242 }
2243
2244 static int e1000e_set_eee(struct net_device *netdev, struct ethtool_eee *edata)
2245 {
2246         struct e1000_adapter *adapter = netdev_priv(netdev);
2247         struct e1000_hw *hw = &adapter->hw;
2248         struct ethtool_eee eee_curr;
2249         s32 ret_val;
2250
2251         ret_val = e1000e_get_eee(netdev, &eee_curr);
2252         if (ret_val)
2253                 return ret_val;
2254
2255         if (eee_curr.tx_lpi_enabled != edata->tx_lpi_enabled) {
2256                 e_err("Setting EEE tx-lpi is not supported\n");
2257                 return -EINVAL;
2258         }
2259
2260         if (eee_curr.tx_lpi_timer != edata->tx_lpi_timer) {
2261                 e_err("Setting EEE Tx LPI timer is not supported\n");
2262                 return -EINVAL;
2263         }
2264
2265         if (edata->advertised & ~(ADVERTISE_100_FULL | ADVERTISE_1000_FULL)) {
2266                 e_err("EEE advertisement supports only 100TX and/or 1000T full-duplex\n");
2267                 return -EINVAL;
2268         }
2269
2270         adapter->eee_advert = ethtool_adv_to_mmd_eee_adv_t(edata->advertised);
2271
2272         hw->dev_spec.ich8lan.eee_disable = !edata->eee_enabled;
2273
2274         pm_runtime_get_sync(netdev->dev.parent);
2275
2276         /* reset the link */
2277         if (netif_running(netdev))
2278                 e1000e_reinit_locked(adapter);
2279         else
2280                 e1000e_reset(adapter);
2281
2282         pm_runtime_put_sync(netdev->dev.parent);
2283
2284         return 0;
2285 }
2286
2287 static int e1000e_get_ts_info(struct net_device *netdev,
2288                               struct ethtool_ts_info *info)
2289 {
2290         struct e1000_adapter *adapter = netdev_priv(netdev);
2291
2292         ethtool_op_get_ts_info(netdev, info);
2293
2294         if (!(adapter->flags & FLAG_HAS_HW_TIMESTAMP))
2295                 return 0;
2296
2297         info->so_timestamping |= (SOF_TIMESTAMPING_TX_HARDWARE |
2298                                   SOF_TIMESTAMPING_RX_HARDWARE |
2299                                   SOF_TIMESTAMPING_RAW_HARDWARE);
2300
2301         info->tx_types = BIT(HWTSTAMP_TX_OFF) | BIT(HWTSTAMP_TX_ON);
2302
2303         info->rx_filters = (BIT(HWTSTAMP_FILTER_NONE) |
2304                             BIT(HWTSTAMP_FILTER_PTP_V1_L4_SYNC) |
2305                             BIT(HWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQ) |
2306                             BIT(HWTSTAMP_FILTER_PTP_V2_L4_SYNC) |
2307                             BIT(HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ) |
2308                             BIT(HWTSTAMP_FILTER_PTP_V2_L2_SYNC) |
2309                             BIT(HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ) |
2310                             BIT(HWTSTAMP_FILTER_PTP_V2_EVENT) |
2311                             BIT(HWTSTAMP_FILTER_PTP_V2_SYNC) |
2312                             BIT(HWTSTAMP_FILTER_PTP_V2_DELAY_REQ) |
2313                             BIT(HWTSTAMP_FILTER_ALL));
2314
2315         if (adapter->ptp_clock)
2316                 info->phc_index = ptp_clock_index(adapter->ptp_clock);
2317
2318         return 0;
2319 }
2320
2321 static u32 e1000e_get_priv_flags(struct net_device *netdev)
2322 {
2323         struct e1000_adapter *adapter = netdev_priv(netdev);
2324         u32 priv_flags = 0;
2325
2326         if (adapter->flags2 & FLAG2_ENABLE_S0IX_FLOWS)
2327                 priv_flags |= E1000E_PRIV_FLAGS_S0IX_ENABLED;
2328
2329         return priv_flags;
2330 }
2331
2332 static int e1000e_set_priv_flags(struct net_device *netdev, u32 priv_flags)
2333 {
2334         struct e1000_adapter *adapter = netdev_priv(netdev);
2335         unsigned int flags2 = adapter->flags2;
2336
2337         flags2 &= ~FLAG2_ENABLE_S0IX_FLOWS;
2338         if (priv_flags & E1000E_PRIV_FLAGS_S0IX_ENABLED) {
2339                 struct e1000_hw *hw = &adapter->hw;
2340
2341                 if (hw->mac.type < e1000_pch_cnp)
2342                         return -EINVAL;
2343                 flags2 |= FLAG2_ENABLE_S0IX_FLOWS;
2344         }
2345
2346         if (flags2 != adapter->flags2)
2347                 adapter->flags2 = flags2;
2348
2349         return 0;
2350 }
2351
2352 static const struct ethtool_ops e1000_ethtool_ops = {
2353         .supported_coalesce_params = ETHTOOL_COALESCE_RX_USECS,
2354         .get_drvinfo            = e1000_get_drvinfo,
2355         .get_regs_len           = e1000_get_regs_len,
2356         .get_regs               = e1000_get_regs,
2357         .get_wol                = e1000_get_wol,
2358         .set_wol                = e1000_set_wol,
2359         .get_msglevel           = e1000_get_msglevel,
2360         .set_msglevel           = e1000_set_msglevel,
2361         .nway_reset             = e1000_nway_reset,
2362         .get_link               = ethtool_op_get_link,
2363         .get_eeprom_len         = e1000_get_eeprom_len,
2364         .get_eeprom             = e1000_get_eeprom,
2365         .set_eeprom             = e1000_set_eeprom,
2366         .get_ringparam          = e1000_get_ringparam,
2367         .set_ringparam          = e1000_set_ringparam,
2368         .get_pauseparam         = e1000_get_pauseparam,
2369         .set_pauseparam         = e1000_set_pauseparam,
2370         .self_test              = e1000_diag_test,
2371         .get_strings            = e1000_get_strings,
2372         .set_phys_id            = e1000_set_phys_id,
2373         .get_ethtool_stats      = e1000_get_ethtool_stats,
2374         .get_sset_count         = e1000e_get_sset_count,
2375         .get_coalesce           = e1000_get_coalesce,
2376         .set_coalesce           = e1000_set_coalesce,
2377         .get_rxnfc              = e1000_get_rxnfc,
2378         .get_ts_info            = e1000e_get_ts_info,
2379         .get_eee                = e1000e_get_eee,
2380         .set_eee                = e1000e_set_eee,
2381         .get_link_ksettings     = e1000_get_link_ksettings,
2382         .set_link_ksettings     = e1000_set_link_ksettings,
2383         .get_priv_flags         = e1000e_get_priv_flags,
2384         .set_priv_flags         = e1000e_set_priv_flags,
2385 };
2386
2387 void e1000e_set_ethtool_ops(struct net_device *netdev)
2388 {
2389         netdev->ethtool_ops = &e1000_ethtool_ops;
2390 }