Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /* Copyright(c) 1999 - 2018 Intel Corporation. */
0003 
0004 /* ethtool support for e1000 */
0005 
0006 #include <linux/netdevice.h>
0007 #include <linux/interrupt.h>
0008 #include <linux/ethtool.h>
0009 #include <linux/pci.h>
0010 #include <linux/slab.h>
0011 #include <linux/delay.h>
0012 #include <linux/vmalloc.h>
0013 #include <linux/pm_runtime.h>
0014 
0015 #include "e1000.h"
0016 
0017 enum { NETDEV_STATS, E1000_STATS };
0018 
0019 struct e1000_stats {
0020     char stat_string[ETH_GSTRING_LEN];
0021     int type;
0022     int sizeof_stat;
0023     int stat_offset;
0024 };
0025 
0026 static const char e1000e_priv_flags_strings[][ETH_GSTRING_LEN] = {
0027 #define E1000E_PRIV_FLAGS_S0IX_ENABLED  BIT(0)
0028     "s0ix-enabled",
0029 };
0030 
0031 #define E1000E_PRIV_FLAGS_STR_LEN ARRAY_SIZE(e1000e_priv_flags_strings)
0032 
0033 #define E1000_STAT(str, m) { \
0034         .stat_string = str, \
0035         .type = E1000_STATS, \
0036         .sizeof_stat = sizeof(((struct e1000_adapter *)0)->m), \
0037         .stat_offset = offsetof(struct e1000_adapter, m) }
0038 #define E1000_NETDEV_STAT(str, m) { \
0039         .stat_string = str, \
0040         .type = NETDEV_STATS, \
0041         .sizeof_stat = sizeof(((struct rtnl_link_stats64 *)0)->m), \
0042         .stat_offset = offsetof(struct rtnl_link_stats64, m) }
0043 
0044 static const struct e1000_stats e1000_gstrings_stats[] = {
0045     E1000_STAT("rx_packets", stats.gprc),
0046     E1000_STAT("tx_packets", stats.gptc),
0047     E1000_STAT("rx_bytes", stats.gorc),
0048     E1000_STAT("tx_bytes", stats.gotc),
0049     E1000_STAT("rx_broadcast", stats.bprc),
0050     E1000_STAT("tx_broadcast", stats.bptc),
0051     E1000_STAT("rx_multicast", stats.mprc),
0052     E1000_STAT("tx_multicast", stats.mptc),
0053     E1000_NETDEV_STAT("rx_errors", rx_errors),
0054     E1000_NETDEV_STAT("tx_errors", tx_errors),
0055     E1000_NETDEV_STAT("tx_dropped", tx_dropped),
0056     E1000_STAT("multicast", stats.mprc),
0057     E1000_STAT("collisions", stats.colc),
0058     E1000_NETDEV_STAT("rx_length_errors", rx_length_errors),
0059     E1000_NETDEV_STAT("rx_over_errors", rx_over_errors),
0060     E1000_STAT("rx_crc_errors", stats.crcerrs),
0061     E1000_NETDEV_STAT("rx_frame_errors", rx_frame_errors),
0062     E1000_STAT("rx_no_buffer_count", stats.rnbc),
0063     E1000_STAT("rx_missed_errors", stats.mpc),
0064     E1000_STAT("tx_aborted_errors", stats.ecol),
0065     E1000_STAT("tx_carrier_errors", stats.tncrs),
0066     E1000_NETDEV_STAT("tx_fifo_errors", tx_fifo_errors),
0067     E1000_NETDEV_STAT("tx_heartbeat_errors", tx_heartbeat_errors),
0068     E1000_STAT("tx_window_errors", stats.latecol),
0069     E1000_STAT("tx_abort_late_coll", stats.latecol),
0070     E1000_STAT("tx_deferred_ok", stats.dc),
0071     E1000_STAT("tx_single_coll_ok", stats.scc),
0072     E1000_STAT("tx_multi_coll_ok", stats.mcc),
0073     E1000_STAT("tx_timeout_count", tx_timeout_count),
0074     E1000_STAT("tx_restart_queue", restart_queue),
0075     E1000_STAT("rx_long_length_errors", stats.roc),
0076     E1000_STAT("rx_short_length_errors", stats.ruc),
0077     E1000_STAT("rx_align_errors", stats.algnerrc),
0078     E1000_STAT("tx_tcp_seg_good", stats.tsctc),
0079     E1000_STAT("tx_tcp_seg_failed", stats.tsctfc),
0080     E1000_STAT("rx_flow_control_xon", stats.xonrxc),
0081     E1000_STAT("rx_flow_control_xoff", stats.xoffrxc),
0082     E1000_STAT("tx_flow_control_xon", stats.xontxc),
0083     E1000_STAT("tx_flow_control_xoff", stats.xofftxc),
0084     E1000_STAT("rx_csum_offload_good", hw_csum_good),
0085     E1000_STAT("rx_csum_offload_errors", hw_csum_err),
0086     E1000_STAT("rx_header_split", rx_hdr_split),
0087     E1000_STAT("alloc_rx_buff_failed", alloc_rx_buff_failed),
0088     E1000_STAT("tx_smbus", stats.mgptc),
0089     E1000_STAT("rx_smbus", stats.mgprc),
0090     E1000_STAT("dropped_smbus", stats.mgpdc),
0091     E1000_STAT("rx_dma_failed", rx_dma_failed),
0092     E1000_STAT("tx_dma_failed", tx_dma_failed),
0093     E1000_STAT("rx_hwtstamp_cleared", rx_hwtstamp_cleared),
0094     E1000_STAT("uncorr_ecc_errors", uncorr_errors),
0095     E1000_STAT("corr_ecc_errors", corr_errors),
0096     E1000_STAT("tx_hwtstamp_timeouts", tx_hwtstamp_timeouts),
0097     E1000_STAT("tx_hwtstamp_skipped", tx_hwtstamp_skipped),
0098 };
0099 
0100 #define E1000_GLOBAL_STATS_LEN  ARRAY_SIZE(e1000_gstrings_stats)
0101 #define E1000_STATS_LEN (E1000_GLOBAL_STATS_LEN)
0102 static const char e1000_gstrings_test[][ETH_GSTRING_LEN] = {
0103     "Register test  (offline)", "Eeprom test    (offline)",
0104     "Interrupt test (offline)", "Loopback test  (offline)",
0105     "Link test   (on/offline)"
0106 };
0107 
0108 #define E1000_TEST_LEN ARRAY_SIZE(e1000_gstrings_test)
0109 
0110 static int e1000_get_link_ksettings(struct net_device *netdev,
0111                     struct ethtool_link_ksettings *cmd)
0112 {
0113     struct e1000_adapter *adapter = netdev_priv(netdev);
0114     struct e1000_hw *hw = &adapter->hw;
0115     u32 speed, supported, advertising;
0116 
0117     if (hw->phy.media_type == e1000_media_type_copper) {
0118         supported = (SUPPORTED_10baseT_Half |
0119                  SUPPORTED_10baseT_Full |
0120                  SUPPORTED_100baseT_Half |
0121                  SUPPORTED_100baseT_Full |
0122                  SUPPORTED_1000baseT_Full |
0123                  SUPPORTED_Autoneg |
0124                  SUPPORTED_TP);
0125         if (hw->phy.type == e1000_phy_ife)
0126             supported &= ~SUPPORTED_1000baseT_Full;
0127         advertising = ADVERTISED_TP;
0128 
0129         if (hw->mac.autoneg == 1) {
0130             advertising |= ADVERTISED_Autoneg;
0131             /* the e1000 autoneg seems to match ethtool nicely */
0132             advertising |= hw->phy.autoneg_advertised;
0133         }
0134 
0135         cmd->base.port = PORT_TP;
0136         cmd->base.phy_address = hw->phy.addr;
0137     } else {
0138         supported   = (SUPPORTED_1000baseT_Full |
0139                    SUPPORTED_FIBRE |
0140                    SUPPORTED_Autoneg);
0141 
0142         advertising = (ADVERTISED_1000baseT_Full |
0143                    ADVERTISED_FIBRE |
0144                    ADVERTISED_Autoneg);
0145 
0146         cmd->base.port = PORT_FIBRE;
0147     }
0148 
0149     speed = SPEED_UNKNOWN;
0150     cmd->base.duplex = DUPLEX_UNKNOWN;
0151 
0152     if (netif_running(netdev)) {
0153         if (netif_carrier_ok(netdev)) {
0154             speed = adapter->link_speed;
0155             cmd->base.duplex = adapter->link_duplex - 1;
0156         }
0157     } else if (!pm_runtime_suspended(netdev->dev.parent)) {
0158         u32 status = er32(STATUS);
0159 
0160         if (status & E1000_STATUS_LU) {
0161             if (status & E1000_STATUS_SPEED_1000)
0162                 speed = SPEED_1000;
0163             else if (status & E1000_STATUS_SPEED_100)
0164                 speed = SPEED_100;
0165             else
0166                 speed = SPEED_10;
0167 
0168             if (status & E1000_STATUS_FD)
0169                 cmd->base.duplex = DUPLEX_FULL;
0170             else
0171                 cmd->base.duplex = DUPLEX_HALF;
0172         }
0173     }
0174 
0175     cmd->base.speed = speed;
0176     cmd->base.autoneg = ((hw->phy.media_type == e1000_media_type_fiber) ||
0177              hw->mac.autoneg) ? AUTONEG_ENABLE : AUTONEG_DISABLE;
0178 
0179     /* MDI-X => 2; MDI =>1; Invalid =>0 */
0180     if ((hw->phy.media_type == e1000_media_type_copper) &&
0181         netif_carrier_ok(netdev))
0182         cmd->base.eth_tp_mdix = hw->phy.is_mdix ?
0183             ETH_TP_MDI_X : ETH_TP_MDI;
0184     else
0185         cmd->base.eth_tp_mdix = ETH_TP_MDI_INVALID;
0186 
0187     if (hw->phy.mdix == AUTO_ALL_MODES)
0188         cmd->base.eth_tp_mdix_ctrl = ETH_TP_MDI_AUTO;
0189     else
0190         cmd->base.eth_tp_mdix_ctrl = hw->phy.mdix;
0191 
0192     if (hw->phy.media_type != e1000_media_type_copper)
0193         cmd->base.eth_tp_mdix_ctrl = ETH_TP_MDI_INVALID;
0194 
0195     ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported,
0196                         supported);
0197     ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.advertising,
0198                         advertising);
0199 
0200     return 0;
0201 }
0202 
0203 static int e1000_set_spd_dplx(struct e1000_adapter *adapter, u32 spd, u8 dplx)
0204 {
0205     struct e1000_mac_info *mac = &adapter->hw.mac;
0206 
0207     mac->autoneg = 0;
0208 
0209     /* Make sure dplx is at most 1 bit and lsb of speed is not set
0210      * for the switch() below to work
0211      */
0212     if ((spd & 1) || (dplx & ~1))
0213         goto err_inval;
0214 
0215     /* Fiber NICs only allow 1000 gbps Full duplex */
0216     if ((adapter->hw.phy.media_type == e1000_media_type_fiber) &&
0217         (spd != SPEED_1000) && (dplx != DUPLEX_FULL)) {
0218         goto err_inval;
0219     }
0220 
0221     switch (spd + dplx) {
0222     case SPEED_10 + DUPLEX_HALF:
0223         mac->forced_speed_duplex = ADVERTISE_10_HALF;
0224         break;
0225     case SPEED_10 + DUPLEX_FULL:
0226         mac->forced_speed_duplex = ADVERTISE_10_FULL;
0227         break;
0228     case SPEED_100 + DUPLEX_HALF:
0229         mac->forced_speed_duplex = ADVERTISE_100_HALF;
0230         break;
0231     case SPEED_100 + DUPLEX_FULL:
0232         mac->forced_speed_duplex = ADVERTISE_100_FULL;
0233         break;
0234     case SPEED_1000 + DUPLEX_FULL:
0235         if (adapter->hw.phy.media_type == e1000_media_type_copper) {
0236             mac->autoneg = 1;
0237             adapter->hw.phy.autoneg_advertised =
0238                 ADVERTISE_1000_FULL;
0239         } else {
0240             mac->forced_speed_duplex = ADVERTISE_1000_FULL;
0241         }
0242         break;
0243     case SPEED_1000 + DUPLEX_HALF:  /* not supported */
0244     default:
0245         goto err_inval;
0246     }
0247 
0248     /* clear MDI, MDI(-X) override is only allowed when autoneg enabled */
0249     adapter->hw.phy.mdix = AUTO_ALL_MODES;
0250 
0251     return 0;
0252 
0253 err_inval:
0254     e_err("Unsupported Speed/Duplex configuration\n");
0255     return -EINVAL;
0256 }
0257 
0258 static int e1000_set_link_ksettings(struct net_device *netdev,
0259                     const struct ethtool_link_ksettings *cmd)
0260 {
0261     struct e1000_adapter *adapter = netdev_priv(netdev);
0262     struct e1000_hw *hw = &adapter->hw;
0263     int ret_val = 0;
0264     u32 advertising;
0265 
0266     ethtool_convert_link_mode_to_legacy_u32(&advertising,
0267                         cmd->link_modes.advertising);
0268 
0269     pm_runtime_get_sync(netdev->dev.parent);
0270 
0271     /* When SoL/IDER sessions are active, autoneg/speed/duplex
0272      * cannot be changed
0273      */
0274     if (hw->phy.ops.check_reset_block &&
0275         hw->phy.ops.check_reset_block(hw)) {
0276         e_err("Cannot change link characteristics when SoL/IDER is active.\n");
0277         ret_val = -EINVAL;
0278         goto out;
0279     }
0280 
0281     /* MDI setting is only allowed when autoneg enabled because
0282      * some hardware doesn't allow MDI setting when speed or
0283      * duplex is forced.
0284      */
0285     if (cmd->base.eth_tp_mdix_ctrl) {
0286         if (hw->phy.media_type != e1000_media_type_copper) {
0287             ret_val = -EOPNOTSUPP;
0288             goto out;
0289         }
0290 
0291         if ((cmd->base.eth_tp_mdix_ctrl != ETH_TP_MDI_AUTO) &&
0292             (cmd->base.autoneg != AUTONEG_ENABLE)) {
0293             e_err("forcing MDI/MDI-X state is not supported when link speed and/or duplex are forced\n");
0294             ret_val = -EINVAL;
0295             goto out;
0296         }
0297     }
0298 
0299     while (test_and_set_bit(__E1000_RESETTING, &adapter->state))
0300         usleep_range(1000, 2000);
0301 
0302     if (cmd->base.autoneg == AUTONEG_ENABLE) {
0303         hw->mac.autoneg = 1;
0304         if (hw->phy.media_type == e1000_media_type_fiber)
0305             hw->phy.autoneg_advertised = ADVERTISED_1000baseT_Full |
0306                 ADVERTISED_FIBRE | ADVERTISED_Autoneg;
0307         else
0308             hw->phy.autoneg_advertised = advertising |
0309                 ADVERTISED_TP | ADVERTISED_Autoneg;
0310         advertising = hw->phy.autoneg_advertised;
0311         if (adapter->fc_autoneg)
0312             hw->fc.requested_mode = e1000_fc_default;
0313     } else {
0314         u32 speed = cmd->base.speed;
0315         /* calling this overrides forced MDI setting */
0316         if (e1000_set_spd_dplx(adapter, speed, cmd->base.duplex)) {
0317             ret_val = -EINVAL;
0318             goto out;
0319         }
0320     }
0321 
0322     /* MDI-X => 2; MDI => 1; Auto => 3 */
0323     if (cmd->base.eth_tp_mdix_ctrl) {
0324         /* fix up the value for auto (3 => 0) as zero is mapped
0325          * internally to auto
0326          */
0327         if (cmd->base.eth_tp_mdix_ctrl == ETH_TP_MDI_AUTO)
0328             hw->phy.mdix = AUTO_ALL_MODES;
0329         else
0330             hw->phy.mdix = cmd->base.eth_tp_mdix_ctrl;
0331     }
0332 
0333     /* reset the link */
0334     if (netif_running(adapter->netdev)) {
0335         e1000e_down(adapter, true);
0336         e1000e_up(adapter);
0337     } else {
0338         e1000e_reset(adapter);
0339     }
0340 
0341 out:
0342     pm_runtime_put_sync(netdev->dev.parent);
0343     clear_bit(__E1000_RESETTING, &adapter->state);
0344     return ret_val;
0345 }
0346 
0347 static void e1000_get_pauseparam(struct net_device *netdev,
0348                  struct ethtool_pauseparam *pause)
0349 {
0350     struct e1000_adapter *adapter = netdev_priv(netdev);
0351     struct e1000_hw *hw = &adapter->hw;
0352 
0353     pause->autoneg =
0354         (adapter->fc_autoneg ? AUTONEG_ENABLE : AUTONEG_DISABLE);
0355 
0356     if (hw->fc.current_mode == e1000_fc_rx_pause) {
0357         pause->rx_pause = 1;
0358     } else if (hw->fc.current_mode == e1000_fc_tx_pause) {
0359         pause->tx_pause = 1;
0360     } else if (hw->fc.current_mode == e1000_fc_full) {
0361         pause->rx_pause = 1;
0362         pause->tx_pause = 1;
0363     }
0364 }
0365 
0366 static int e1000_set_pauseparam(struct net_device *netdev,
0367                 struct ethtool_pauseparam *pause)
0368 {
0369     struct e1000_adapter *adapter = netdev_priv(netdev);
0370     struct e1000_hw *hw = &adapter->hw;
0371     int retval = 0;
0372 
0373     adapter->fc_autoneg = pause->autoneg;
0374 
0375     while (test_and_set_bit(__E1000_RESETTING, &adapter->state))
0376         usleep_range(1000, 2000);
0377 
0378     pm_runtime_get_sync(netdev->dev.parent);
0379 
0380     if (adapter->fc_autoneg == AUTONEG_ENABLE) {
0381         hw->fc.requested_mode = e1000_fc_default;
0382         if (netif_running(adapter->netdev)) {
0383             e1000e_down(adapter, true);
0384             e1000e_up(adapter);
0385         } else {
0386             e1000e_reset(adapter);
0387         }
0388     } else {
0389         if (pause->rx_pause && pause->tx_pause)
0390             hw->fc.requested_mode = e1000_fc_full;
0391         else if (pause->rx_pause && !pause->tx_pause)
0392             hw->fc.requested_mode = e1000_fc_rx_pause;
0393         else if (!pause->rx_pause && pause->tx_pause)
0394             hw->fc.requested_mode = e1000_fc_tx_pause;
0395         else if (!pause->rx_pause && !pause->tx_pause)
0396             hw->fc.requested_mode = e1000_fc_none;
0397 
0398         hw->fc.current_mode = hw->fc.requested_mode;
0399 
0400         if (hw->phy.media_type == e1000_media_type_fiber) {
0401             retval = hw->mac.ops.setup_link(hw);
0402             /* implicit goto out */
0403         } else {
0404             retval = e1000e_force_mac_fc(hw);
0405             if (retval)
0406                 goto out;
0407             e1000e_set_fc_watermarks(hw);
0408         }
0409     }
0410 
0411 out:
0412     pm_runtime_put_sync(netdev->dev.parent);
0413     clear_bit(__E1000_RESETTING, &adapter->state);
0414     return retval;
0415 }
0416 
0417 static u32 e1000_get_msglevel(struct net_device *netdev)
0418 {
0419     struct e1000_adapter *adapter = netdev_priv(netdev);
0420     return adapter->msg_enable;
0421 }
0422 
0423 static void e1000_set_msglevel(struct net_device *netdev, u32 data)
0424 {
0425     struct e1000_adapter *adapter = netdev_priv(netdev);
0426     adapter->msg_enable = data;
0427 }
0428 
0429 static int e1000_get_regs_len(struct net_device __always_unused *netdev)
0430 {
0431 #define E1000_REGS_LEN 32   /* overestimate */
0432     return E1000_REGS_LEN * sizeof(u32);
0433 }
0434 
0435 static void e1000_get_regs(struct net_device *netdev,
0436                struct ethtool_regs *regs, void *p)
0437 {
0438     struct e1000_adapter *adapter = netdev_priv(netdev);
0439     struct e1000_hw *hw = &adapter->hw;
0440     u32 *regs_buff = p;
0441     u16 phy_data;
0442 
0443     pm_runtime_get_sync(netdev->dev.parent);
0444 
0445     memset(p, 0, E1000_REGS_LEN * sizeof(u32));
0446 
0447     regs->version = (1u << 24) |
0448             (adapter->pdev->revision << 16) |
0449             adapter->pdev->device;
0450 
0451     regs_buff[0] = er32(CTRL);
0452     regs_buff[1] = er32(STATUS);
0453 
0454     regs_buff[2] = er32(RCTL);
0455     regs_buff[3] = er32(RDLEN(0));
0456     regs_buff[4] = er32(RDH(0));
0457     regs_buff[5] = er32(RDT(0));
0458     regs_buff[6] = er32(RDTR);
0459 
0460     regs_buff[7] = er32(TCTL);
0461     regs_buff[8] = er32(TDLEN(0));
0462     regs_buff[9] = er32(TDH(0));
0463     regs_buff[10] = er32(TDT(0));
0464     regs_buff[11] = er32(TIDV);
0465 
0466     regs_buff[12] = adapter->hw.phy.type;   /* PHY type (IGP=1, M88=0) */
0467 
0468     /* ethtool doesn't use anything past this point, so all this
0469      * code is likely legacy junk for apps that may or may not exist
0470      */
0471     if (hw->phy.type == e1000_phy_m88) {
0472         e1e_rphy(hw, M88E1000_PHY_SPEC_STATUS, &phy_data);
0473         regs_buff[13] = (u32)phy_data; /* cable length */
0474         regs_buff[14] = 0;  /* Dummy (to align w/ IGP phy reg dump) */
0475         regs_buff[15] = 0;  /* Dummy (to align w/ IGP phy reg dump) */
0476         regs_buff[16] = 0;  /* Dummy (to align w/ IGP phy reg dump) */
0477         e1e_rphy(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);
0478         regs_buff[17] = (u32)phy_data; /* extended 10bt distance */
0479         regs_buff[18] = regs_buff[13]; /* cable polarity */
0480         regs_buff[19] = 0;  /* Dummy (to align w/ IGP phy reg dump) */
0481         regs_buff[20] = regs_buff[17]; /* polarity correction */
0482         /* phy receive errors */
0483         regs_buff[22] = adapter->phy_stats.receive_errors;
0484         regs_buff[23] = regs_buff[13]; /* mdix mode */
0485     }
0486     regs_buff[21] = 0;  /* was idle_errors */
0487     e1e_rphy(hw, MII_STAT1000, &phy_data);
0488     regs_buff[24] = (u32)phy_data;  /* phy local receiver status */
0489     regs_buff[25] = regs_buff[24];  /* phy remote receiver status */
0490 
0491     pm_runtime_put_sync(netdev->dev.parent);
0492 }
0493 
0494 static int e1000_get_eeprom_len(struct net_device *netdev)
0495 {
0496     struct e1000_adapter *adapter = netdev_priv(netdev);
0497     return adapter->hw.nvm.word_size * 2;
0498 }
0499 
0500 static int e1000_get_eeprom(struct net_device *netdev,
0501                 struct ethtool_eeprom *eeprom, u8 *bytes)
0502 {
0503     struct e1000_adapter *adapter = netdev_priv(netdev);
0504     struct e1000_hw *hw = &adapter->hw;
0505     u16 *eeprom_buff;
0506     int first_word;
0507     int last_word;
0508     int ret_val = 0;
0509     u16 i;
0510 
0511     if (eeprom->len == 0)
0512         return -EINVAL;
0513 
0514     eeprom->magic = adapter->pdev->vendor | (adapter->pdev->device << 16);
0515 
0516     first_word = eeprom->offset >> 1;
0517     last_word = (eeprom->offset + eeprom->len - 1) >> 1;
0518 
0519     eeprom_buff = kmalloc_array(last_word - first_word + 1, sizeof(u16),
0520                     GFP_KERNEL);
0521     if (!eeprom_buff)
0522         return -ENOMEM;
0523 
0524     pm_runtime_get_sync(netdev->dev.parent);
0525 
0526     if (hw->nvm.type == e1000_nvm_eeprom_spi) {
0527         ret_val = e1000_read_nvm(hw, first_word,
0528                      last_word - first_word + 1,
0529                      eeprom_buff);
0530     } else {
0531         for (i = 0; i < last_word - first_word + 1; i++) {
0532             ret_val = e1000_read_nvm(hw, first_word + i, 1,
0533                          &eeprom_buff[i]);
0534             if (ret_val)
0535                 break;
0536         }
0537     }
0538 
0539     pm_runtime_put_sync(netdev->dev.parent);
0540 
0541     if (ret_val) {
0542         /* a read error occurred, throw away the result */
0543         memset(eeprom_buff, 0xff, sizeof(u16) *
0544                (last_word - first_word + 1));
0545     } else {
0546         /* Device's eeprom is always little-endian, word addressable */
0547         for (i = 0; i < last_word - first_word + 1; i++)
0548             le16_to_cpus(&eeprom_buff[i]);
0549     }
0550 
0551     memcpy(bytes, (u8 *)eeprom_buff + (eeprom->offset & 1), eeprom->len);
0552     kfree(eeprom_buff);
0553 
0554     return ret_val;
0555 }
0556 
0557 static int e1000_set_eeprom(struct net_device *netdev,
0558                 struct ethtool_eeprom *eeprom, u8 *bytes)
0559 {
0560     struct e1000_adapter *adapter = netdev_priv(netdev);
0561     struct e1000_hw *hw = &adapter->hw;
0562     u16 *eeprom_buff;
0563     void *ptr;
0564     int max_len;
0565     int first_word;
0566     int last_word;
0567     int ret_val = 0;
0568     u16 i;
0569 
0570     if (eeprom->len == 0)
0571         return -EOPNOTSUPP;
0572 
0573     if (eeprom->magic !=
0574         (adapter->pdev->vendor | (adapter->pdev->device << 16)))
0575         return -EFAULT;
0576 
0577     if (adapter->flags & FLAG_READ_ONLY_NVM)
0578         return -EINVAL;
0579 
0580     max_len = hw->nvm.word_size * 2;
0581 
0582     first_word = eeprom->offset >> 1;
0583     last_word = (eeprom->offset + eeprom->len - 1) >> 1;
0584     eeprom_buff = kmalloc(max_len, GFP_KERNEL);
0585     if (!eeprom_buff)
0586         return -ENOMEM;
0587 
0588     ptr = (void *)eeprom_buff;
0589 
0590     pm_runtime_get_sync(netdev->dev.parent);
0591 
0592     if (eeprom->offset & 1) {
0593         /* need read/modify/write of first changed EEPROM word */
0594         /* only the second byte of the word is being modified */
0595         ret_val = e1000_read_nvm(hw, first_word, 1, &eeprom_buff[0]);
0596         ptr++;
0597     }
0598     if (((eeprom->offset + eeprom->len) & 1) && (!ret_val))
0599         /* need read/modify/write of last changed EEPROM word */
0600         /* only the first byte of the word is being modified */
0601         ret_val = e1000_read_nvm(hw, last_word, 1,
0602                      &eeprom_buff[last_word - first_word]);
0603 
0604     if (ret_val)
0605         goto out;
0606 
0607     /* Device's eeprom is always little-endian, word addressable */
0608     for (i = 0; i < last_word - first_word + 1; i++)
0609         le16_to_cpus(&eeprom_buff[i]);
0610 
0611     memcpy(ptr, bytes, eeprom->len);
0612 
0613     for (i = 0; i < last_word - first_word + 1; i++)
0614         cpu_to_le16s(&eeprom_buff[i]);
0615 
0616     ret_val = e1000_write_nvm(hw, first_word,
0617                   last_word - first_word + 1, eeprom_buff);
0618 
0619     if (ret_val)
0620         goto out;
0621 
0622     /* Update the checksum over the first part of the EEPROM if needed
0623      * and flush shadow RAM for applicable controllers
0624      */
0625     if ((first_word <= NVM_CHECKSUM_REG) ||
0626         (hw->mac.type == e1000_82583) ||
0627         (hw->mac.type == e1000_82574) ||
0628         (hw->mac.type == e1000_82573))
0629         ret_val = e1000e_update_nvm_checksum(hw);
0630 
0631 out:
0632     pm_runtime_put_sync(netdev->dev.parent);
0633     kfree(eeprom_buff);
0634     return ret_val;
0635 }
0636 
0637 static void e1000_get_drvinfo(struct net_device *netdev,
0638                   struct ethtool_drvinfo *drvinfo)
0639 {
0640     struct e1000_adapter *adapter = netdev_priv(netdev);
0641 
0642     strlcpy(drvinfo->driver, e1000e_driver_name, sizeof(drvinfo->driver));
0643 
0644     /* EEPROM image version # is reported as firmware version # for
0645      * PCI-E controllers
0646      */
0647     snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version),
0648          "%d.%d-%d",
0649          (adapter->eeprom_vers & 0xF000) >> 12,
0650          (adapter->eeprom_vers & 0x0FF0) >> 4,
0651          (adapter->eeprom_vers & 0x000F));
0652 
0653     strlcpy(drvinfo->bus_info, pci_name(adapter->pdev),
0654         sizeof(drvinfo->bus_info));
0655 }
0656 
0657 static void e1000_get_ringparam(struct net_device *netdev,
0658                 struct ethtool_ringparam *ring,
0659                 struct kernel_ethtool_ringparam *kernel_ring,
0660                 struct netlink_ext_ack *extack)
0661 {
0662     struct e1000_adapter *adapter = netdev_priv(netdev);
0663 
0664     ring->rx_max_pending = E1000_MAX_RXD;
0665     ring->tx_max_pending = E1000_MAX_TXD;
0666     ring->rx_pending = adapter->rx_ring_count;
0667     ring->tx_pending = adapter->tx_ring_count;
0668 }
0669 
0670 static int e1000_set_ringparam(struct net_device *netdev,
0671                    struct ethtool_ringparam *ring,
0672                    struct kernel_ethtool_ringparam *kernel_ring,
0673                    struct netlink_ext_ack *extack)
0674 {
0675     struct e1000_adapter *adapter = netdev_priv(netdev);
0676     struct e1000_ring *temp_tx = NULL, *temp_rx = NULL;
0677     int err = 0, size = sizeof(struct e1000_ring);
0678     bool set_tx = false, set_rx = false;
0679     u16 new_rx_count, new_tx_count;
0680 
0681     if ((ring->rx_mini_pending) || (ring->rx_jumbo_pending))
0682         return -EINVAL;
0683 
0684     new_rx_count = clamp_t(u32, ring->rx_pending, E1000_MIN_RXD,
0685                    E1000_MAX_RXD);
0686     new_rx_count = ALIGN(new_rx_count, REQ_RX_DESCRIPTOR_MULTIPLE);
0687 
0688     new_tx_count = clamp_t(u32, ring->tx_pending, E1000_MIN_TXD,
0689                    E1000_MAX_TXD);
0690     new_tx_count = ALIGN(new_tx_count, REQ_TX_DESCRIPTOR_MULTIPLE);
0691 
0692     if ((new_tx_count == adapter->tx_ring_count) &&
0693         (new_rx_count == adapter->rx_ring_count))
0694         /* nothing to do */
0695         return 0;
0696 
0697     while (test_and_set_bit(__E1000_RESETTING, &adapter->state))
0698         usleep_range(1000, 2000);
0699 
0700     if (!netif_running(adapter->netdev)) {
0701         /* Set counts now and allocate resources during open() */
0702         adapter->tx_ring->count = new_tx_count;
0703         adapter->rx_ring->count = new_rx_count;
0704         adapter->tx_ring_count = new_tx_count;
0705         adapter->rx_ring_count = new_rx_count;
0706         goto clear_reset;
0707     }
0708 
0709     set_tx = (new_tx_count != adapter->tx_ring_count);
0710     set_rx = (new_rx_count != adapter->rx_ring_count);
0711 
0712     /* Allocate temporary storage for ring updates */
0713     if (set_tx) {
0714         temp_tx = vmalloc(size);
0715         if (!temp_tx) {
0716             err = -ENOMEM;
0717             goto free_temp;
0718         }
0719     }
0720     if (set_rx) {
0721         temp_rx = vmalloc(size);
0722         if (!temp_rx) {
0723             err = -ENOMEM;
0724             goto free_temp;
0725         }
0726     }
0727 
0728     pm_runtime_get_sync(netdev->dev.parent);
0729 
0730     e1000e_down(adapter, true);
0731 
0732     /* We can't just free everything and then setup again, because the
0733      * ISRs in MSI-X mode get passed pointers to the Tx and Rx ring
0734      * structs.  First, attempt to allocate new resources...
0735      */
0736     if (set_tx) {
0737         memcpy(temp_tx, adapter->tx_ring, size);
0738         temp_tx->count = new_tx_count;
0739         err = e1000e_setup_tx_resources(temp_tx);
0740         if (err)
0741             goto err_setup;
0742     }
0743     if (set_rx) {
0744         memcpy(temp_rx, adapter->rx_ring, size);
0745         temp_rx->count = new_rx_count;
0746         err = e1000e_setup_rx_resources(temp_rx);
0747         if (err)
0748             goto err_setup_rx;
0749     }
0750 
0751     /* ...then free the old resources and copy back any new ring data */
0752     if (set_tx) {
0753         e1000e_free_tx_resources(adapter->tx_ring);
0754         memcpy(adapter->tx_ring, temp_tx, size);
0755         adapter->tx_ring_count = new_tx_count;
0756     }
0757     if (set_rx) {
0758         e1000e_free_rx_resources(adapter->rx_ring);
0759         memcpy(adapter->rx_ring, temp_rx, size);
0760         adapter->rx_ring_count = new_rx_count;
0761     }
0762 
0763 err_setup_rx:
0764     if (err && set_tx)
0765         e1000e_free_tx_resources(temp_tx);
0766 err_setup:
0767     e1000e_up(adapter);
0768     pm_runtime_put_sync(netdev->dev.parent);
0769 free_temp:
0770     vfree(temp_tx);
0771     vfree(temp_rx);
0772 clear_reset:
0773     clear_bit(__E1000_RESETTING, &adapter->state);
0774     return err;
0775 }
0776 
0777 static bool reg_pattern_test(struct e1000_adapter *adapter, u64 *data,
0778                  int reg, int offset, u32 mask, u32 write)
0779 {
0780     u32 pat, val;
0781     static const u32 test[] = {
0782         0x5A5A5A5A, 0xA5A5A5A5, 0x00000000, 0xFFFFFFFF
0783     };
0784     for (pat = 0; pat < ARRAY_SIZE(test); pat++) {
0785         E1000_WRITE_REG_ARRAY(&adapter->hw, reg, offset,
0786                       (test[pat] & write));
0787         val = E1000_READ_REG_ARRAY(&adapter->hw, reg, offset);
0788         if (val != (test[pat] & write & mask)) {
0789             e_err("pattern test failed (reg 0x%05X): got 0x%08X expected 0x%08X\n",
0790                   reg + (offset << 2), val,
0791                   (test[pat] & write & mask));
0792             *data = reg;
0793             return true;
0794         }
0795     }
0796     return false;
0797 }
0798 
0799 static bool reg_set_and_check(struct e1000_adapter *adapter, u64 *data,
0800                   int reg, u32 mask, u32 write)
0801 {
0802     u32 val;
0803 
0804     __ew32(&adapter->hw, reg, write & mask);
0805     val = __er32(&adapter->hw, reg);
0806     if ((write & mask) != (val & mask)) {
0807         e_err("set/check test failed (reg 0x%05X): got 0x%08X expected 0x%08X\n",
0808               reg, (val & mask), (write & mask));
0809         *data = reg;
0810         return true;
0811     }
0812     return false;
0813 }
0814 
0815 #define REG_PATTERN_TEST_ARRAY(reg, offset, mask, write)                       \
0816     do {                                                                   \
0817         if (reg_pattern_test(adapter, data, reg, offset, mask, write)) \
0818             return 1;                                              \
0819     } while (0)
0820 #define REG_PATTERN_TEST(reg, mask, write)                                     \
0821     REG_PATTERN_TEST_ARRAY(reg, 0, mask, write)
0822 
0823 #define REG_SET_AND_CHECK(reg, mask, write)                                    \
0824     do {                                                                   \
0825         if (reg_set_and_check(adapter, data, reg, mask, write))        \
0826             return 1;                                              \
0827     } while (0)
0828 
0829 static int e1000_reg_test(struct e1000_adapter *adapter, u64 *data)
0830 {
0831     struct e1000_hw *hw = &adapter->hw;
0832     struct e1000_mac_info *mac = &adapter->hw.mac;
0833     u32 value;
0834     u32 before;
0835     u32 after;
0836     u32 i;
0837     u32 toggle;
0838     u32 mask;
0839     u32 wlock_mac = 0;
0840 
0841     /* The status register is Read Only, so a write should fail.
0842      * Some bits that get toggled are ignored.  There are several bits
0843      * on newer hardware that are r/w.
0844      */
0845     switch (mac->type) {
0846     case e1000_82571:
0847     case e1000_82572:
0848     case e1000_80003es2lan:
0849         toggle = 0x7FFFF3FF;
0850         break;
0851     default:
0852         toggle = 0x7FFFF033;
0853         break;
0854     }
0855 
0856     before = er32(STATUS);
0857     value = (er32(STATUS) & toggle);
0858     ew32(STATUS, toggle);
0859     after = er32(STATUS) & toggle;
0860     if (value != after) {
0861         e_err("failed STATUS register test got: 0x%08X expected: 0x%08X\n",
0862               after, value);
0863         *data = 1;
0864         return 1;
0865     }
0866     /* restore previous status */
0867     ew32(STATUS, before);
0868 
0869     if (!(adapter->flags & FLAG_IS_ICH)) {
0870         REG_PATTERN_TEST(E1000_FCAL, 0xFFFFFFFF, 0xFFFFFFFF);
0871         REG_PATTERN_TEST(E1000_FCAH, 0x0000FFFF, 0xFFFFFFFF);
0872         REG_PATTERN_TEST(E1000_FCT, 0x0000FFFF, 0xFFFFFFFF);
0873         REG_PATTERN_TEST(E1000_VET, 0x0000FFFF, 0xFFFFFFFF);
0874     }
0875 
0876     REG_PATTERN_TEST(E1000_RDTR, 0x0000FFFF, 0xFFFFFFFF);
0877     REG_PATTERN_TEST(E1000_RDBAH(0), 0xFFFFFFFF, 0xFFFFFFFF);
0878     REG_PATTERN_TEST(E1000_RDLEN(0), 0x000FFF80, 0x000FFFFF);
0879     REG_PATTERN_TEST(E1000_RDH(0), 0x0000FFFF, 0x0000FFFF);
0880     REG_PATTERN_TEST(E1000_RDT(0), 0x0000FFFF, 0x0000FFFF);
0881     REG_PATTERN_TEST(E1000_FCRTH, 0x0000FFF8, 0x0000FFF8);
0882     REG_PATTERN_TEST(E1000_FCTTV, 0x0000FFFF, 0x0000FFFF);
0883     REG_PATTERN_TEST(E1000_TIPG, 0x3FFFFFFF, 0x3FFFFFFF);
0884     REG_PATTERN_TEST(E1000_TDBAH(0), 0xFFFFFFFF, 0xFFFFFFFF);
0885     REG_PATTERN_TEST(E1000_TDLEN(0), 0x000FFF80, 0x000FFFFF);
0886 
0887     REG_SET_AND_CHECK(E1000_RCTL, 0xFFFFFFFF, 0x00000000);
0888 
0889     before = ((adapter->flags & FLAG_IS_ICH) ? 0x06C3B33E : 0x06DFB3FE);
0890     REG_SET_AND_CHECK(E1000_RCTL, before, 0x003FFFFB);
0891     REG_SET_AND_CHECK(E1000_TCTL, 0xFFFFFFFF, 0x00000000);
0892 
0893     REG_SET_AND_CHECK(E1000_RCTL, before, 0xFFFFFFFF);
0894     REG_PATTERN_TEST(E1000_RDBAL(0), 0xFFFFFFF0, 0xFFFFFFFF);
0895     if (!(adapter->flags & FLAG_IS_ICH))
0896         REG_PATTERN_TEST(E1000_TXCW, 0xC000FFFF, 0x0000FFFF);
0897     REG_PATTERN_TEST(E1000_TDBAL(0), 0xFFFFFFF0, 0xFFFFFFFF);
0898     REG_PATTERN_TEST(E1000_TIDV, 0x0000FFFF, 0x0000FFFF);
0899     mask = 0x8003FFFF;
0900     switch (mac->type) {
0901     case e1000_ich10lan:
0902     case e1000_pchlan:
0903     case e1000_pch2lan:
0904     case e1000_pch_lpt:
0905     case e1000_pch_spt:
0906     case e1000_pch_cnp:
0907     case e1000_pch_tgp:
0908     case e1000_pch_adp:
0909     case e1000_pch_mtp:
0910     case e1000_pch_lnp:
0911         mask |= BIT(18);
0912         break;
0913     default:
0914         break;
0915     }
0916 
0917     if (mac->type >= e1000_pch_lpt)
0918         wlock_mac = (er32(FWSM) & E1000_FWSM_WLOCK_MAC_MASK) >>
0919             E1000_FWSM_WLOCK_MAC_SHIFT;
0920 
0921     for (i = 0; i < mac->rar_entry_count; i++) {
0922         if (mac->type >= e1000_pch_lpt) {
0923             /* Cannot test write-protected SHRAL[n] registers */
0924             if ((wlock_mac == 1) || (wlock_mac && (i > wlock_mac)))
0925                 continue;
0926 
0927             /* SHRAH[9] different than the others */
0928             if (i == 10)
0929                 mask |= BIT(30);
0930             else
0931                 mask &= ~BIT(30);
0932         }
0933         if (mac->type == e1000_pch2lan) {
0934             /* SHRAH[0,1,2] different than previous */
0935             if (i == 1)
0936                 mask &= 0xFFF4FFFF;
0937             /* SHRAH[3] different than SHRAH[0,1,2] */
0938             if (i == 4)
0939                 mask |= BIT(30);
0940             /* RAR[1-6] owned by management engine - skipping */
0941             if (i > 0)
0942                 i += 6;
0943         }
0944 
0945         REG_PATTERN_TEST_ARRAY(E1000_RA, ((i << 1) + 1), mask,
0946                        0xFFFFFFFF);
0947         /* reset index to actual value */
0948         if ((mac->type == e1000_pch2lan) && (i > 6))
0949             i -= 6;
0950     }
0951 
0952     for (i = 0; i < mac->mta_reg_count; i++)
0953         REG_PATTERN_TEST_ARRAY(E1000_MTA, i, 0xFFFFFFFF, 0xFFFFFFFF);
0954 
0955     *data = 0;
0956 
0957     return 0;
0958 }
0959 
0960 static int e1000_eeprom_test(struct e1000_adapter *adapter, u64 *data)
0961 {
0962     u16 temp;
0963     u16 checksum = 0;
0964     u16 i;
0965 
0966     *data = 0;
0967     /* Read and add up the contents of the EEPROM */
0968     for (i = 0; i < (NVM_CHECKSUM_REG + 1); i++) {
0969         if ((e1000_read_nvm(&adapter->hw, i, 1, &temp)) < 0) {
0970             *data = 1;
0971             return *data;
0972         }
0973         checksum += temp;
0974     }
0975 
0976     /* If Checksum is not Correct return error else test passed */
0977     if ((checksum != (u16)NVM_SUM) && !(*data))
0978         *data = 2;
0979 
0980     return *data;
0981 }
0982 
0983 static irqreturn_t e1000_test_intr(int __always_unused irq, void *data)
0984 {
0985     struct net_device *netdev = (struct net_device *)data;
0986     struct e1000_adapter *adapter = netdev_priv(netdev);
0987     struct e1000_hw *hw = &adapter->hw;
0988 
0989     adapter->test_icr |= er32(ICR);
0990 
0991     return IRQ_HANDLED;
0992 }
0993 
0994 static int e1000_intr_test(struct e1000_adapter *adapter, u64 *data)
0995 {
0996     struct net_device *netdev = adapter->netdev;
0997     struct e1000_hw *hw = &adapter->hw;
0998     u32 mask;
0999     u32 shared_int = 1;
1000     u32 irq = adapter->pdev->irq;
1001     int i;
1002     int ret_val = 0;
1003     int int_mode = E1000E_INT_MODE_LEGACY;
1004 
1005     *data = 0;
1006 
1007     /* NOTE: we don't test MSI/MSI-X interrupts here, yet */
1008     if (adapter->int_mode == E1000E_INT_MODE_MSIX) {
1009         int_mode = adapter->int_mode;
1010         e1000e_reset_interrupt_capability(adapter);
1011         adapter->int_mode = E1000E_INT_MODE_LEGACY;
1012         e1000e_set_interrupt_capability(adapter);
1013     }
1014     /* Hook up test interrupt handler just for this test */
1015     if (!request_irq(irq, e1000_test_intr, IRQF_PROBE_SHARED, netdev->name,
1016              netdev)) {
1017         shared_int = 0;
1018     } else if (request_irq(irq, e1000_test_intr, IRQF_SHARED, netdev->name,
1019                    netdev)) {
1020         *data = 1;
1021         ret_val = -1;
1022         goto out;
1023     }
1024     e_info("testing %s interrupt\n", (shared_int ? "shared" : "unshared"));
1025 
1026     /* Disable all the interrupts */
1027     ew32(IMC, 0xFFFFFFFF);
1028     e1e_flush();
1029     usleep_range(10000, 11000);
1030 
1031     /* Test each interrupt */
1032     for (i = 0; i < 10; i++) {
1033         /* Interrupt to test */
1034         mask = BIT(i);
1035 
1036         if (adapter->flags & FLAG_IS_ICH) {
1037             switch (mask) {
1038             case E1000_ICR_RXSEQ:
1039                 continue;
1040             case 0x00000100:
1041                 if (adapter->hw.mac.type == e1000_ich8lan ||
1042                     adapter->hw.mac.type == e1000_ich9lan)
1043                     continue;
1044                 break;
1045             default:
1046                 break;
1047             }
1048         }
1049 
1050         if (!shared_int) {
1051             /* Disable the interrupt to be reported in
1052              * the cause register and then force the same
1053              * interrupt and see if one gets posted.  If
1054              * an interrupt was posted to the bus, the
1055              * test failed.
1056              */
1057             adapter->test_icr = 0;
1058             ew32(IMC, mask);
1059             ew32(ICS, mask);
1060             e1e_flush();
1061             usleep_range(10000, 11000);
1062 
1063             if (adapter->test_icr & mask) {
1064                 *data = 3;
1065                 break;
1066             }
1067         }
1068 
1069         /* Enable the interrupt to be reported in
1070          * the cause register and then force the same
1071          * interrupt and see if one gets posted.  If
1072          * an interrupt was not posted to the bus, the
1073          * test failed.
1074          */
1075         adapter->test_icr = 0;
1076         ew32(IMS, mask);
1077         ew32(ICS, mask);
1078         e1e_flush();
1079         usleep_range(10000, 11000);
1080 
1081         if (!(adapter->test_icr & mask)) {
1082             *data = 4;
1083             break;
1084         }
1085 
1086         if (!shared_int) {
1087             /* Disable the other interrupts to be reported in
1088              * the cause register and then force the other
1089              * interrupts and see if any get posted.  If
1090              * an interrupt was posted to the bus, the
1091              * test failed.
1092              */
1093             adapter->test_icr = 0;
1094             ew32(IMC, ~mask & 0x00007FFF);
1095             ew32(ICS, ~mask & 0x00007FFF);
1096             e1e_flush();
1097             usleep_range(10000, 11000);
1098 
1099             if (adapter->test_icr) {
1100                 *data = 5;
1101                 break;
1102             }
1103         }
1104     }
1105 
1106     /* Disable all the interrupts */
1107     ew32(IMC, 0xFFFFFFFF);
1108     e1e_flush();
1109     usleep_range(10000, 11000);
1110 
1111     /* Unhook test interrupt handler */
1112     free_irq(irq, netdev);
1113 
1114 out:
1115     if (int_mode == E1000E_INT_MODE_MSIX) {
1116         e1000e_reset_interrupt_capability(adapter);
1117         adapter->int_mode = int_mode;
1118         e1000e_set_interrupt_capability(adapter);
1119     }
1120 
1121     return ret_val;
1122 }
1123 
1124 static void e1000_free_desc_rings(struct e1000_adapter *adapter)
1125 {
1126     struct e1000_ring *tx_ring = &adapter->test_tx_ring;
1127     struct e1000_ring *rx_ring = &adapter->test_rx_ring;
1128     struct pci_dev *pdev = adapter->pdev;
1129     struct e1000_buffer *buffer_info;
1130     int i;
1131 
1132     if (tx_ring->desc && tx_ring->buffer_info) {
1133         for (i = 0; i < tx_ring->count; i++) {
1134             buffer_info = &tx_ring->buffer_info[i];
1135 
1136             if (buffer_info->dma)
1137                 dma_unmap_single(&pdev->dev,
1138                          buffer_info->dma,
1139                          buffer_info->length,
1140                          DMA_TO_DEVICE);
1141             dev_kfree_skb(buffer_info->skb);
1142         }
1143     }
1144 
1145     if (rx_ring->desc && rx_ring->buffer_info) {
1146         for (i = 0; i < rx_ring->count; i++) {
1147             buffer_info = &rx_ring->buffer_info[i];
1148 
1149             if (buffer_info->dma)
1150                 dma_unmap_single(&pdev->dev,
1151                          buffer_info->dma,
1152                          2048, DMA_FROM_DEVICE);
1153             dev_kfree_skb(buffer_info->skb);
1154         }
1155     }
1156 
1157     if (tx_ring->desc) {
1158         dma_free_coherent(&pdev->dev, tx_ring->size, tx_ring->desc,
1159                   tx_ring->dma);
1160         tx_ring->desc = NULL;
1161     }
1162     if (rx_ring->desc) {
1163         dma_free_coherent(&pdev->dev, rx_ring->size, rx_ring->desc,
1164                   rx_ring->dma);
1165         rx_ring->desc = NULL;
1166     }
1167 
1168     kfree(tx_ring->buffer_info);
1169     tx_ring->buffer_info = NULL;
1170     kfree(rx_ring->buffer_info);
1171     rx_ring->buffer_info = NULL;
1172 }
1173 
1174 static int e1000_setup_desc_rings(struct e1000_adapter *adapter)
1175 {
1176     struct e1000_ring *tx_ring = &adapter->test_tx_ring;
1177     struct e1000_ring *rx_ring = &adapter->test_rx_ring;
1178     struct pci_dev *pdev = adapter->pdev;
1179     struct e1000_hw *hw = &adapter->hw;
1180     u32 rctl;
1181     int i;
1182     int ret_val;
1183 
1184     /* Setup Tx descriptor ring and Tx buffers */
1185 
1186     if (!tx_ring->count)
1187         tx_ring->count = E1000_DEFAULT_TXD;
1188 
1189     tx_ring->buffer_info = kcalloc(tx_ring->count,
1190                        sizeof(struct e1000_buffer), GFP_KERNEL);
1191     if (!tx_ring->buffer_info) {
1192         ret_val = 1;
1193         goto err_nomem;
1194     }
1195 
1196     tx_ring->size = tx_ring->count * sizeof(struct e1000_tx_desc);
1197     tx_ring->size = ALIGN(tx_ring->size, 4096);
1198     tx_ring->desc = dma_alloc_coherent(&pdev->dev, tx_ring->size,
1199                        &tx_ring->dma, GFP_KERNEL);
1200     if (!tx_ring->desc) {
1201         ret_val = 2;
1202         goto err_nomem;
1203     }
1204     tx_ring->next_to_use = 0;
1205     tx_ring->next_to_clean = 0;
1206 
1207     ew32(TDBAL(0), ((u64)tx_ring->dma & 0x00000000FFFFFFFF));
1208     ew32(TDBAH(0), ((u64)tx_ring->dma >> 32));
1209     ew32(TDLEN(0), tx_ring->count * sizeof(struct e1000_tx_desc));
1210     ew32(TDH(0), 0);
1211     ew32(TDT(0), 0);
1212     ew32(TCTL, E1000_TCTL_PSP | E1000_TCTL_EN | E1000_TCTL_MULR |
1213          E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT |
1214          E1000_COLLISION_DISTANCE << E1000_COLD_SHIFT);
1215 
1216     for (i = 0; i < tx_ring->count; i++) {
1217         struct e1000_tx_desc *tx_desc = E1000_TX_DESC(*tx_ring, i);
1218         struct sk_buff *skb;
1219         unsigned int skb_size = 1024;
1220 
1221         skb = alloc_skb(skb_size, GFP_KERNEL);
1222         if (!skb) {
1223             ret_val = 3;
1224             goto err_nomem;
1225         }
1226         skb_put(skb, skb_size);
1227         tx_ring->buffer_info[i].skb = skb;
1228         tx_ring->buffer_info[i].length = skb->len;
1229         tx_ring->buffer_info[i].dma =
1230             dma_map_single(&pdev->dev, skb->data, skb->len,
1231                    DMA_TO_DEVICE);
1232         if (dma_mapping_error(&pdev->dev,
1233                       tx_ring->buffer_info[i].dma)) {
1234             ret_val = 4;
1235             goto err_nomem;
1236         }
1237         tx_desc->buffer_addr = cpu_to_le64(tx_ring->buffer_info[i].dma);
1238         tx_desc->lower.data = cpu_to_le32(skb->len);
1239         tx_desc->lower.data |= cpu_to_le32(E1000_TXD_CMD_EOP |
1240                            E1000_TXD_CMD_IFCS |
1241                            E1000_TXD_CMD_RS);
1242         tx_desc->upper.data = 0;
1243     }
1244 
1245     /* Setup Rx descriptor ring and Rx buffers */
1246 
1247     if (!rx_ring->count)
1248         rx_ring->count = E1000_DEFAULT_RXD;
1249 
1250     rx_ring->buffer_info = kcalloc(rx_ring->count,
1251                        sizeof(struct e1000_buffer), GFP_KERNEL);
1252     if (!rx_ring->buffer_info) {
1253         ret_val = 5;
1254         goto err_nomem;
1255     }
1256 
1257     rx_ring->size = rx_ring->count * sizeof(union e1000_rx_desc_extended);
1258     rx_ring->desc = dma_alloc_coherent(&pdev->dev, rx_ring->size,
1259                        &rx_ring->dma, GFP_KERNEL);
1260     if (!rx_ring->desc) {
1261         ret_val = 6;
1262         goto err_nomem;
1263     }
1264     rx_ring->next_to_use = 0;
1265     rx_ring->next_to_clean = 0;
1266 
1267     rctl = er32(RCTL);
1268     if (!(adapter->flags2 & FLAG2_NO_DISABLE_RX))
1269         ew32(RCTL, rctl & ~E1000_RCTL_EN);
1270     ew32(RDBAL(0), ((u64)rx_ring->dma & 0xFFFFFFFF));
1271     ew32(RDBAH(0), ((u64)rx_ring->dma >> 32));
1272     ew32(RDLEN(0), rx_ring->size);
1273     ew32(RDH(0), 0);
1274     ew32(RDT(0), 0);
1275     rctl = E1000_RCTL_EN | E1000_RCTL_BAM | E1000_RCTL_SZ_2048 |
1276         E1000_RCTL_UPE | E1000_RCTL_MPE | E1000_RCTL_LPE |
1277         E1000_RCTL_SBP | E1000_RCTL_SECRC |
1278         E1000_RCTL_LBM_NO | E1000_RCTL_RDMTS_HALF |
1279         (adapter->hw.mac.mc_filter_type << E1000_RCTL_MO_SHIFT);
1280     ew32(RCTL, rctl);
1281 
1282     for (i = 0; i < rx_ring->count; i++) {
1283         union e1000_rx_desc_extended *rx_desc;
1284         struct sk_buff *skb;
1285 
1286         skb = alloc_skb(2048 + NET_IP_ALIGN, GFP_KERNEL);
1287         if (!skb) {
1288             ret_val = 7;
1289             goto err_nomem;
1290         }
1291         skb_reserve(skb, NET_IP_ALIGN);
1292         rx_ring->buffer_info[i].skb = skb;
1293         rx_ring->buffer_info[i].dma =
1294             dma_map_single(&pdev->dev, skb->data, 2048,
1295                    DMA_FROM_DEVICE);
1296         if (dma_mapping_error(&pdev->dev,
1297                       rx_ring->buffer_info[i].dma)) {
1298             ret_val = 8;
1299             goto err_nomem;
1300         }
1301         rx_desc = E1000_RX_DESC_EXT(*rx_ring, i);
1302         rx_desc->read.buffer_addr =
1303             cpu_to_le64(rx_ring->buffer_info[i].dma);
1304         memset(skb->data, 0x00, skb->len);
1305     }
1306 
1307     return 0;
1308 
1309 err_nomem:
1310     e1000_free_desc_rings(adapter);
1311     return ret_val;
1312 }
1313 
1314 static void e1000_phy_disable_receiver(struct e1000_adapter *adapter)
1315 {
1316     /* Write out to PHY registers 29 and 30 to disable the Receiver. */
1317     e1e_wphy(&adapter->hw, 29, 0x001F);
1318     e1e_wphy(&adapter->hw, 30, 0x8FFC);
1319     e1e_wphy(&adapter->hw, 29, 0x001A);
1320     e1e_wphy(&adapter->hw, 30, 0x8FF0);
1321 }
1322 
1323 static int e1000_integrated_phy_loopback(struct e1000_adapter *adapter)
1324 {
1325     struct e1000_hw *hw = &adapter->hw;
1326     u32 ctrl_reg = 0;
1327     u16 phy_reg = 0;
1328     s32 ret_val = 0;
1329 
1330     hw->mac.autoneg = 0;
1331 
1332     if (hw->phy.type == e1000_phy_ife) {
1333         /* force 100, set loopback */
1334         e1e_wphy(hw, MII_BMCR, 0x6100);
1335 
1336         /* Now set up the MAC to the same speed/duplex as the PHY. */
1337         ctrl_reg = er32(CTRL);
1338         ctrl_reg &= ~E1000_CTRL_SPD_SEL; /* Clear the speed sel bits */
1339         ctrl_reg |= (E1000_CTRL_FRCSPD | /* Set the Force Speed Bit */
1340                  E1000_CTRL_FRCDPX | /* Set the Force Duplex Bit */
1341                  E1000_CTRL_SPD_100 |/* Force Speed to 100 */
1342                  E1000_CTRL_FD);     /* Force Duplex to FULL */
1343 
1344         ew32(CTRL, ctrl_reg);
1345         e1e_flush();
1346         usleep_range(500, 1000);
1347 
1348         return 0;
1349     }
1350 
1351     /* Specific PHY configuration for loopback */
1352     switch (hw->phy.type) {
1353     case e1000_phy_m88:
1354         /* Auto-MDI/MDIX Off */
1355         e1e_wphy(hw, M88E1000_PHY_SPEC_CTRL, 0x0808);
1356         /* reset to update Auto-MDI/MDIX */
1357         e1e_wphy(hw, MII_BMCR, 0x9140);
1358         /* autoneg off */
1359         e1e_wphy(hw, MII_BMCR, 0x8140);
1360         break;
1361     case e1000_phy_gg82563:
1362         e1e_wphy(hw, GG82563_PHY_KMRN_MODE_CTRL, 0x1CC);
1363         break;
1364     case e1000_phy_bm:
1365         /* Set Default MAC Interface speed to 1GB */
1366         e1e_rphy(hw, PHY_REG(2, 21), &phy_reg);
1367         phy_reg &= ~0x0007;
1368         phy_reg |= 0x006;
1369         e1e_wphy(hw, PHY_REG(2, 21), phy_reg);
1370         /* Assert SW reset for above settings to take effect */
1371         hw->phy.ops.commit(hw);
1372         usleep_range(1000, 2000);
1373         /* Force Full Duplex */
1374         e1e_rphy(hw, PHY_REG(769, 16), &phy_reg);
1375         e1e_wphy(hw, PHY_REG(769, 16), phy_reg | 0x000C);
1376         /* Set Link Up (in force link) */
1377         e1e_rphy(hw, PHY_REG(776, 16), &phy_reg);
1378         e1e_wphy(hw, PHY_REG(776, 16), phy_reg | 0x0040);
1379         /* Force Link */
1380         e1e_rphy(hw, PHY_REG(769, 16), &phy_reg);
1381         e1e_wphy(hw, PHY_REG(769, 16), phy_reg | 0x0040);
1382         /* Set Early Link Enable */
1383         e1e_rphy(hw, PHY_REG(769, 20), &phy_reg);
1384         e1e_wphy(hw, PHY_REG(769, 20), phy_reg | 0x0400);
1385         break;
1386     case e1000_phy_82577:
1387     case e1000_phy_82578:
1388         /* Workaround: K1 must be disabled for stable 1Gbps operation */
1389         ret_val = hw->phy.ops.acquire(hw);
1390         if (ret_val) {
1391             e_err("Cannot setup 1Gbps loopback.\n");
1392             return ret_val;
1393         }
1394         e1000_configure_k1_ich8lan(hw, false);
1395         hw->phy.ops.release(hw);
1396         break;
1397     case e1000_phy_82579:
1398         /* Disable PHY energy detect power down */
1399         e1e_rphy(hw, PHY_REG(0, 21), &phy_reg);
1400         e1e_wphy(hw, PHY_REG(0, 21), phy_reg & ~BIT(3));
1401         /* Disable full chip energy detect */
1402         e1e_rphy(hw, PHY_REG(776, 18), &phy_reg);
1403         e1e_wphy(hw, PHY_REG(776, 18), phy_reg | 1);
1404         /* Enable loopback on the PHY */
1405         e1e_wphy(hw, I82577_PHY_LBK_CTRL, 0x8001);
1406         break;
1407     default:
1408         break;
1409     }
1410 
1411     /* force 1000, set loopback */
1412     e1e_wphy(hw, MII_BMCR, 0x4140);
1413     msleep(250);
1414 
1415     /* Now set up the MAC to the same speed/duplex as the PHY. */
1416     ctrl_reg = er32(CTRL);
1417     ctrl_reg &= ~E1000_CTRL_SPD_SEL; /* Clear the speed sel bits */
1418     ctrl_reg |= (E1000_CTRL_FRCSPD | /* Set the Force Speed Bit */
1419              E1000_CTRL_FRCDPX | /* Set the Force Duplex Bit */
1420              E1000_CTRL_SPD_1000 |/* Force Speed to 1000 */
1421              E1000_CTRL_FD);     /* Force Duplex to FULL */
1422 
1423     if (adapter->flags & FLAG_IS_ICH)
1424         ctrl_reg |= E1000_CTRL_SLU; /* Set Link Up */
1425 
1426     if (hw->phy.media_type == e1000_media_type_copper &&
1427         hw->phy.type == e1000_phy_m88) {
1428         ctrl_reg |= E1000_CTRL_ILOS;    /* Invert Loss of Signal */
1429     } else {
1430         /* Set the ILOS bit on the fiber Nic if half duplex link is
1431          * detected.
1432          */
1433         if ((er32(STATUS) & E1000_STATUS_FD) == 0)
1434             ctrl_reg |= (E1000_CTRL_ILOS | E1000_CTRL_SLU);
1435     }
1436 
1437     ew32(CTRL, ctrl_reg);
1438 
1439     /* Disable the receiver on the PHY so when a cable is plugged in, the
1440      * PHY does not begin to autoneg when a cable is reconnected to the NIC.
1441      */
1442     if (hw->phy.type == e1000_phy_m88)
1443         e1000_phy_disable_receiver(adapter);
1444 
1445     usleep_range(500, 1000);
1446 
1447     return 0;
1448 }
1449 
1450 static int e1000_set_82571_fiber_loopback(struct e1000_adapter *adapter)
1451 {
1452     struct e1000_hw *hw = &adapter->hw;
1453     u32 ctrl = er32(CTRL);
1454     int link;
1455 
1456     /* special requirements for 82571/82572 fiber adapters */
1457 
1458     /* jump through hoops to make sure link is up because serdes
1459      * link is hardwired up
1460      */
1461     ctrl |= E1000_CTRL_SLU;
1462     ew32(CTRL, ctrl);
1463 
1464     /* disable autoneg */
1465     ctrl = er32(TXCW);
1466     ctrl &= ~BIT(31);
1467     ew32(TXCW, ctrl);
1468 
1469     link = (er32(STATUS) & E1000_STATUS_LU);
1470 
1471     if (!link) {
1472         /* set invert loss of signal */
1473         ctrl = er32(CTRL);
1474         ctrl |= E1000_CTRL_ILOS;
1475         ew32(CTRL, ctrl);
1476     }
1477 
1478     /* special write to serdes control register to enable SerDes analog
1479      * loopback
1480      */
1481     ew32(SCTL, E1000_SCTL_ENABLE_SERDES_LOOPBACK);
1482     e1e_flush();
1483     usleep_range(10000, 11000);
1484 
1485     return 0;
1486 }
1487 
1488 /* only call this for fiber/serdes connections to es2lan */
1489 static int e1000_set_es2lan_mac_loopback(struct e1000_adapter *adapter)
1490 {
1491     struct e1000_hw *hw = &adapter->hw;
1492     u32 ctrlext = er32(CTRL_EXT);
1493     u32 ctrl = er32(CTRL);
1494 
1495     /* save CTRL_EXT to restore later, reuse an empty variable (unused
1496      * on mac_type 80003es2lan)
1497      */
1498     adapter->tx_fifo_head = ctrlext;
1499 
1500     /* clear the serdes mode bits, putting the device into mac loopback */
1501     ctrlext &= ~E1000_CTRL_EXT_LINK_MODE_PCIE_SERDES;
1502     ew32(CTRL_EXT, ctrlext);
1503 
1504     /* force speed to 1000/FD, link up */
1505     ctrl &= ~(E1000_CTRL_SPD_1000 | E1000_CTRL_SPD_100);
1506     ctrl |= (E1000_CTRL_SLU | E1000_CTRL_FRCSPD | E1000_CTRL_FRCDPX |
1507          E1000_CTRL_SPD_1000 | E1000_CTRL_FD);
1508     ew32(CTRL, ctrl);
1509 
1510     /* set mac loopback */
1511     ctrl = er32(RCTL);
1512     ctrl |= E1000_RCTL_LBM_MAC;
1513     ew32(RCTL, ctrl);
1514 
1515     /* set testing mode parameters (no need to reset later) */
1516 #define KMRNCTRLSTA_OPMODE (0x1F << 16)
1517 #define KMRNCTRLSTA_OPMODE_1GB_FD_GMII 0x0582
1518     ew32(KMRNCTRLSTA,
1519          (KMRNCTRLSTA_OPMODE | KMRNCTRLSTA_OPMODE_1GB_FD_GMII));
1520 
1521     return 0;
1522 }
1523 
1524 static int e1000_setup_loopback_test(struct e1000_adapter *adapter)
1525 {
1526     struct e1000_hw *hw = &adapter->hw;
1527     u32 rctl, fext_nvm11, tarc0;
1528 
1529     if (hw->mac.type >= e1000_pch_spt) {
1530         fext_nvm11 = er32(FEXTNVM11);
1531         fext_nvm11 |= E1000_FEXTNVM11_DISABLE_MULR_FIX;
1532         ew32(FEXTNVM11, fext_nvm11);
1533         tarc0 = er32(TARC(0));
1534         /* clear bits 28 & 29 (control of MULR concurrent requests) */
1535         tarc0 &= 0xcfffffff;
1536         /* set bit 29 (value of MULR requests is now 2) */
1537         tarc0 |= 0x20000000;
1538         ew32(TARC(0), tarc0);
1539     }
1540     if (hw->phy.media_type == e1000_media_type_fiber ||
1541         hw->phy.media_type == e1000_media_type_internal_serdes) {
1542         switch (hw->mac.type) {
1543         case e1000_80003es2lan:
1544             return e1000_set_es2lan_mac_loopback(adapter);
1545         case e1000_82571:
1546         case e1000_82572:
1547             return e1000_set_82571_fiber_loopback(adapter);
1548         default:
1549             rctl = er32(RCTL);
1550             rctl |= E1000_RCTL_LBM_TCVR;
1551             ew32(RCTL, rctl);
1552             return 0;
1553         }
1554     } else if (hw->phy.media_type == e1000_media_type_copper) {
1555         return e1000_integrated_phy_loopback(adapter);
1556     }
1557 
1558     return 7;
1559 }
1560 
1561 static void e1000_loopback_cleanup(struct e1000_adapter *adapter)
1562 {
1563     struct e1000_hw *hw = &adapter->hw;
1564     u32 rctl, fext_nvm11, tarc0;
1565     u16 phy_reg;
1566 
1567     rctl = er32(RCTL);
1568     rctl &= ~(E1000_RCTL_LBM_TCVR | E1000_RCTL_LBM_MAC);
1569     ew32(RCTL, rctl);
1570 
1571     switch (hw->mac.type) {
1572     case e1000_pch_spt:
1573     case e1000_pch_cnp:
1574     case e1000_pch_tgp:
1575     case e1000_pch_adp:
1576     case e1000_pch_mtp:
1577     case e1000_pch_lnp:
1578         fext_nvm11 = er32(FEXTNVM11);
1579         fext_nvm11 &= ~E1000_FEXTNVM11_DISABLE_MULR_FIX;
1580         ew32(FEXTNVM11, fext_nvm11);
1581         tarc0 = er32(TARC(0));
1582         /* clear bits 28 & 29 (control of MULR concurrent requests) */
1583         /* set bit 29 (value of MULR requests is now 0) */
1584         tarc0 &= 0xcfffffff;
1585         ew32(TARC(0), tarc0);
1586         fallthrough;
1587     case e1000_80003es2lan:
1588         if (hw->phy.media_type == e1000_media_type_fiber ||
1589             hw->phy.media_type == e1000_media_type_internal_serdes) {
1590             /* restore CTRL_EXT, stealing space from tx_fifo_head */
1591             ew32(CTRL_EXT, adapter->tx_fifo_head);
1592             adapter->tx_fifo_head = 0;
1593         }
1594         fallthrough;
1595     case e1000_82571:
1596     case e1000_82572:
1597         if (hw->phy.media_type == e1000_media_type_fiber ||
1598             hw->phy.media_type == e1000_media_type_internal_serdes) {
1599             ew32(SCTL, E1000_SCTL_DISABLE_SERDES_LOOPBACK);
1600             e1e_flush();
1601             usleep_range(10000, 11000);
1602             break;
1603         }
1604         fallthrough;
1605     default:
1606         hw->mac.autoneg = 1;
1607         if (hw->phy.type == e1000_phy_gg82563)
1608             e1e_wphy(hw, GG82563_PHY_KMRN_MODE_CTRL, 0x180);
1609         e1e_rphy(hw, MII_BMCR, &phy_reg);
1610         if (phy_reg & BMCR_LOOPBACK) {
1611             phy_reg &= ~BMCR_LOOPBACK;
1612             e1e_wphy(hw, MII_BMCR, phy_reg);
1613             if (hw->phy.ops.commit)
1614                 hw->phy.ops.commit(hw);
1615         }
1616         break;
1617     }
1618 }
1619 
1620 static void e1000_create_lbtest_frame(struct sk_buff *skb,
1621                       unsigned int frame_size)
1622 {
1623     memset(skb->data, 0xFF, frame_size);
1624     frame_size &= ~1;
1625     memset(&skb->data[frame_size / 2], 0xAA, frame_size / 2 - 1);
1626     skb->data[frame_size / 2 + 10] = 0xBE;
1627     skb->data[frame_size / 2 + 12] = 0xAF;
1628 }
1629 
1630 static int e1000_check_lbtest_frame(struct sk_buff *skb,
1631                     unsigned int frame_size)
1632 {
1633     frame_size &= ~1;
1634     if (*(skb->data + 3) == 0xFF)
1635         if ((*(skb->data + frame_size / 2 + 10) == 0xBE) &&
1636             (*(skb->data + frame_size / 2 + 12) == 0xAF))
1637             return 0;
1638     return 13;
1639 }
1640 
1641 static int e1000_run_loopback_test(struct e1000_adapter *adapter)
1642 {
1643     struct e1000_ring *tx_ring = &adapter->test_tx_ring;
1644     struct e1000_ring *rx_ring = &adapter->test_rx_ring;
1645     struct pci_dev *pdev = adapter->pdev;
1646     struct e1000_hw *hw = &adapter->hw;
1647     struct e1000_buffer *buffer_info;
1648     int i, j, k, l;
1649     int lc;
1650     int good_cnt;
1651     int ret_val = 0;
1652     unsigned long time;
1653 
1654     ew32(RDT(0), rx_ring->count - 1);
1655 
1656     /* Calculate the loop count based on the largest descriptor ring
1657      * The idea is to wrap the largest ring a number of times using 64
1658      * send/receive pairs during each loop
1659      */
1660 
1661     if (rx_ring->count <= tx_ring->count)
1662         lc = ((tx_ring->count / 64) * 2) + 1;
1663     else
1664         lc = ((rx_ring->count / 64) * 2) + 1;
1665 
1666     k = 0;
1667     l = 0;
1668     /* loop count loop */
1669     for (j = 0; j <= lc; j++) {
1670         /* send the packets */
1671         for (i = 0; i < 64; i++) {
1672             buffer_info = &tx_ring->buffer_info[k];
1673 
1674             e1000_create_lbtest_frame(buffer_info->skb, 1024);
1675             dma_sync_single_for_device(&pdev->dev,
1676                            buffer_info->dma,
1677                            buffer_info->length,
1678                            DMA_TO_DEVICE);
1679             k++;
1680             if (k == tx_ring->count)
1681                 k = 0;
1682         }
1683         ew32(TDT(0), k);
1684         e1e_flush();
1685         msleep(200);
1686         time = jiffies; /* set the start time for the receive */
1687         good_cnt = 0;
1688         /* receive the sent packets */
1689         do {
1690             buffer_info = &rx_ring->buffer_info[l];
1691 
1692             dma_sync_single_for_cpu(&pdev->dev,
1693                         buffer_info->dma, 2048,
1694                         DMA_FROM_DEVICE);
1695 
1696             ret_val = e1000_check_lbtest_frame(buffer_info->skb,
1697                                1024);
1698             if (!ret_val)
1699                 good_cnt++;
1700             l++;
1701             if (l == rx_ring->count)
1702                 l = 0;
1703             /* time + 20 msecs (200 msecs on 2.4) is more than
1704              * enough time to complete the receives, if it's
1705              * exceeded, break and error off
1706              */
1707         } while ((good_cnt < 64) && !time_after(jiffies, time + 20));
1708         if (good_cnt != 64) {
1709             ret_val = 13;   /* ret_val is the same as mis-compare */
1710             break;
1711         }
1712         if (time_after(jiffies, time + 20)) {
1713             ret_val = 14;   /* error code for time out error */
1714             break;
1715         }
1716     }
1717     return ret_val;
1718 }
1719 
1720 static int e1000_loopback_test(struct e1000_adapter *adapter, u64 *data)
1721 {
1722     struct e1000_hw *hw = &adapter->hw;
1723 
1724     /* PHY loopback cannot be performed if SoL/IDER sessions are active */
1725     if (hw->phy.ops.check_reset_block &&
1726         hw->phy.ops.check_reset_block(hw)) {
1727         e_err("Cannot do PHY loopback test when SoL/IDER is active.\n");
1728         *data = 0;
1729         goto out;
1730     }
1731 
1732     *data = e1000_setup_desc_rings(adapter);
1733     if (*data)
1734         goto out;
1735 
1736     *data = e1000_setup_loopback_test(adapter);
1737     if (*data)
1738         goto err_loopback;
1739 
1740     *data = e1000_run_loopback_test(adapter);
1741     e1000_loopback_cleanup(adapter);
1742 
1743 err_loopback:
1744     e1000_free_desc_rings(adapter);
1745 out:
1746     return *data;
1747 }
1748 
1749 static int e1000_link_test(struct e1000_adapter *adapter, u64 *data)
1750 {
1751     struct e1000_hw *hw = &adapter->hw;
1752 
1753     *data = 0;
1754     if (hw->phy.media_type == e1000_media_type_internal_serdes) {
1755         int i = 0;
1756 
1757         hw->mac.serdes_has_link = false;
1758 
1759         /* On some blade server designs, link establishment
1760          * could take as long as 2-3 minutes
1761          */
1762         do {
1763             hw->mac.ops.check_for_link(hw);
1764             if (hw->mac.serdes_has_link)
1765                 return *data;
1766             msleep(20);
1767         } while (i++ < 3750);
1768 
1769         *data = 1;
1770     } else {
1771         hw->mac.ops.check_for_link(hw);
1772         if (hw->mac.autoneg)
1773             /* On some Phy/switch combinations, link establishment
1774              * can take a few seconds more than expected.
1775              */
1776             msleep_interruptible(5000);
1777 
1778         if (!(er32(STATUS) & E1000_STATUS_LU))
1779             *data = 1;
1780     }
1781     return *data;
1782 }
1783 
1784 static int e1000e_get_sset_count(struct net_device __always_unused *netdev,
1785                  int sset)
1786 {
1787     switch (sset) {
1788     case ETH_SS_TEST:
1789         return E1000_TEST_LEN;
1790     case ETH_SS_STATS:
1791         return E1000_STATS_LEN;
1792     case ETH_SS_PRIV_FLAGS:
1793         return E1000E_PRIV_FLAGS_STR_LEN;
1794     default:
1795         return -EOPNOTSUPP;
1796     }
1797 }
1798 
1799 static void e1000_diag_test(struct net_device *netdev,
1800                 struct ethtool_test *eth_test, u64 *data)
1801 {
1802     struct e1000_adapter *adapter = netdev_priv(netdev);
1803     u16 autoneg_advertised;
1804     u8 forced_speed_duplex;
1805     u8 autoneg;
1806     bool if_running = netif_running(netdev);
1807 
1808     pm_runtime_get_sync(netdev->dev.parent);
1809 
1810     set_bit(__E1000_TESTING, &adapter->state);
1811 
1812     if (!if_running) {
1813         /* Get control of and reset hardware */
1814         if (adapter->flags & FLAG_HAS_AMT)
1815             e1000e_get_hw_control(adapter);
1816 
1817         e1000e_power_up_phy(adapter);
1818 
1819         adapter->hw.phy.autoneg_wait_to_complete = 1;
1820         e1000e_reset(adapter);
1821         adapter->hw.phy.autoneg_wait_to_complete = 0;
1822     }
1823 
1824     if (eth_test->flags == ETH_TEST_FL_OFFLINE) {
1825         /* Offline tests */
1826 
1827         /* save speed, duplex, autoneg settings */
1828         autoneg_advertised = adapter->hw.phy.autoneg_advertised;
1829         forced_speed_duplex = adapter->hw.mac.forced_speed_duplex;
1830         autoneg = adapter->hw.mac.autoneg;
1831 
1832         e_info("offline testing starting\n");
1833 
1834         if (if_running)
1835             /* indicate we're in test mode */
1836             e1000e_close(netdev);
1837 
1838         if (e1000_reg_test(adapter, &data[0]))
1839             eth_test->flags |= ETH_TEST_FL_FAILED;
1840 
1841         e1000e_reset(adapter);
1842         if (e1000_eeprom_test(adapter, &data[1]))
1843             eth_test->flags |= ETH_TEST_FL_FAILED;
1844 
1845         e1000e_reset(adapter);
1846         if (e1000_intr_test(adapter, &data[2]))
1847             eth_test->flags |= ETH_TEST_FL_FAILED;
1848 
1849         e1000e_reset(adapter);
1850         if (e1000_loopback_test(adapter, &data[3]))
1851             eth_test->flags |= ETH_TEST_FL_FAILED;
1852 
1853         /* force this routine to wait until autoneg complete/timeout */
1854         adapter->hw.phy.autoneg_wait_to_complete = 1;
1855         e1000e_reset(adapter);
1856         adapter->hw.phy.autoneg_wait_to_complete = 0;
1857 
1858         if (e1000_link_test(adapter, &data[4]))
1859             eth_test->flags |= ETH_TEST_FL_FAILED;
1860 
1861         /* restore speed, duplex, autoneg settings */
1862         adapter->hw.phy.autoneg_advertised = autoneg_advertised;
1863         adapter->hw.mac.forced_speed_duplex = forced_speed_duplex;
1864         adapter->hw.mac.autoneg = autoneg;
1865         e1000e_reset(adapter);
1866 
1867         clear_bit(__E1000_TESTING, &adapter->state);
1868         if (if_running)
1869             e1000e_open(netdev);
1870     } else {
1871         /* Online tests */
1872 
1873         e_info("online testing starting\n");
1874 
1875         /* register, eeprom, intr and loopback tests not run online */
1876         data[0] = 0;
1877         data[1] = 0;
1878         data[2] = 0;
1879         data[3] = 0;
1880 
1881         if (e1000_link_test(adapter, &data[4]))
1882             eth_test->flags |= ETH_TEST_FL_FAILED;
1883 
1884         clear_bit(__E1000_TESTING, &adapter->state);
1885     }
1886 
1887     if (!if_running) {
1888         e1000e_reset(adapter);
1889 
1890         if (adapter->flags & FLAG_HAS_AMT)
1891             e1000e_release_hw_control(adapter);
1892     }
1893 
1894     msleep_interruptible(4 * 1000);
1895 
1896     pm_runtime_put_sync(netdev->dev.parent);
1897 }
1898 
1899 static void e1000_get_wol(struct net_device *netdev,
1900               struct ethtool_wolinfo *wol)
1901 {
1902     struct e1000_adapter *adapter = netdev_priv(netdev);
1903 
1904     wol->supported = 0;
1905     wol->wolopts = 0;
1906 
1907     if (!(adapter->flags & FLAG_HAS_WOL) ||
1908         !device_can_wakeup(&adapter->pdev->dev))
1909         return;
1910 
1911     wol->supported = WAKE_UCAST | WAKE_MCAST |
1912         WAKE_BCAST | WAKE_MAGIC | WAKE_PHY;
1913 
1914     /* apply any specific unsupported masks here */
1915     if (adapter->flags & FLAG_NO_WAKE_UCAST) {
1916         wol->supported &= ~WAKE_UCAST;
1917 
1918         if (adapter->wol & E1000_WUFC_EX)
1919             e_err("Interface does not support directed (unicast) frame wake-up packets\n");
1920     }
1921 
1922     if (adapter->wol & E1000_WUFC_EX)
1923         wol->wolopts |= WAKE_UCAST;
1924     if (adapter->wol & E1000_WUFC_MC)
1925         wol->wolopts |= WAKE_MCAST;
1926     if (adapter->wol & E1000_WUFC_BC)
1927         wol->wolopts |= WAKE_BCAST;
1928     if (adapter->wol & E1000_WUFC_MAG)
1929         wol->wolopts |= WAKE_MAGIC;
1930     if (adapter->wol & E1000_WUFC_LNKC)
1931         wol->wolopts |= WAKE_PHY;
1932 }
1933 
1934 static int e1000_set_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)
1935 {
1936     struct e1000_adapter *adapter = netdev_priv(netdev);
1937 
1938     if (!(adapter->flags & FLAG_HAS_WOL) ||
1939         !device_can_wakeup(&adapter->pdev->dev) ||
1940         (wol->wolopts & ~(WAKE_UCAST | WAKE_MCAST | WAKE_BCAST |
1941                   WAKE_MAGIC | WAKE_PHY)))
1942         return -EOPNOTSUPP;
1943 
1944     /* these settings will always override what we currently have */
1945     adapter->wol = 0;
1946 
1947     if (wol->wolopts & WAKE_UCAST)
1948         adapter->wol |= E1000_WUFC_EX;
1949     if (wol->wolopts & WAKE_MCAST)
1950         adapter->wol |= E1000_WUFC_MC;
1951     if (wol->wolopts & WAKE_BCAST)
1952         adapter->wol |= E1000_WUFC_BC;
1953     if (wol->wolopts & WAKE_MAGIC)
1954         adapter->wol |= E1000_WUFC_MAG;
1955     if (wol->wolopts & WAKE_PHY)
1956         adapter->wol |= E1000_WUFC_LNKC;
1957 
1958     device_set_wakeup_enable(&adapter->pdev->dev, adapter->wol);
1959 
1960     return 0;
1961 }
1962 
1963 static int e1000_set_phys_id(struct net_device *netdev,
1964                  enum ethtool_phys_id_state state)
1965 {
1966     struct e1000_adapter *adapter = netdev_priv(netdev);
1967     struct e1000_hw *hw = &adapter->hw;
1968 
1969     switch (state) {
1970     case ETHTOOL_ID_ACTIVE:
1971         pm_runtime_get_sync(netdev->dev.parent);
1972 
1973         if (!hw->mac.ops.blink_led)
1974             return 2;   /* cycle on/off twice per second */
1975 
1976         hw->mac.ops.blink_led(hw);
1977         break;
1978 
1979     case ETHTOOL_ID_INACTIVE:
1980         if (hw->phy.type == e1000_phy_ife)
1981             e1e_wphy(hw, IFE_PHY_SPECIAL_CONTROL_LED, 0);
1982         hw->mac.ops.led_off(hw);
1983         hw->mac.ops.cleanup_led(hw);
1984         pm_runtime_put_sync(netdev->dev.parent);
1985         break;
1986 
1987     case ETHTOOL_ID_ON:
1988         hw->mac.ops.led_on(hw);
1989         break;
1990 
1991     case ETHTOOL_ID_OFF:
1992         hw->mac.ops.led_off(hw);
1993         break;
1994     }
1995 
1996     return 0;
1997 }
1998 
1999 static int e1000_get_coalesce(struct net_device *netdev,
2000                   struct ethtool_coalesce *ec,
2001                   struct kernel_ethtool_coalesce *kernel_coal,
2002                   struct netlink_ext_ack *extack)
2003 {
2004     struct e1000_adapter *adapter = netdev_priv(netdev);
2005 
2006     if (adapter->itr_setting <= 4)
2007         ec->rx_coalesce_usecs = adapter->itr_setting;
2008     else
2009         ec->rx_coalesce_usecs = 1000000 / adapter->itr_setting;
2010 
2011     return 0;
2012 }
2013 
2014 static int e1000_set_coalesce(struct net_device *netdev,
2015                   struct ethtool_coalesce *ec,
2016                   struct kernel_ethtool_coalesce *kernel_coal,
2017                   struct netlink_ext_ack *extack)
2018 {
2019     struct e1000_adapter *adapter = netdev_priv(netdev);
2020 
2021     if ((ec->rx_coalesce_usecs > E1000_MAX_ITR_USECS) ||
2022         ((ec->rx_coalesce_usecs > 4) &&
2023          (ec->rx_coalesce_usecs < E1000_MIN_ITR_USECS)) ||
2024         (ec->rx_coalesce_usecs == 2))
2025         return -EINVAL;
2026 
2027     if (ec->rx_coalesce_usecs == 4) {
2028         adapter->itr_setting = 4;
2029         adapter->itr = adapter->itr_setting;
2030     } else if (ec->rx_coalesce_usecs <= 3) {
2031         adapter->itr = 20000;
2032         adapter->itr_setting = ec->rx_coalesce_usecs;
2033     } else {
2034         adapter->itr = (1000000 / ec->rx_coalesce_usecs);
2035         adapter->itr_setting = adapter->itr & ~3;
2036     }
2037 
2038     pm_runtime_get_sync(netdev->dev.parent);
2039 
2040     if (adapter->itr_setting != 0)
2041         e1000e_write_itr(adapter, adapter->itr);
2042     else
2043         e1000e_write_itr(adapter, 0);
2044 
2045     pm_runtime_put_sync(netdev->dev.parent);
2046 
2047     return 0;
2048 }
2049 
2050 static int e1000_nway_reset(struct net_device *netdev)
2051 {
2052     struct e1000_adapter *adapter = netdev_priv(netdev);
2053 
2054     if (!netif_running(netdev))
2055         return -EAGAIN;
2056 
2057     if (!adapter->hw.mac.autoneg)
2058         return -EINVAL;
2059 
2060     pm_runtime_get_sync(netdev->dev.parent);
2061     e1000e_reinit_locked(adapter);
2062     pm_runtime_put_sync(netdev->dev.parent);
2063 
2064     return 0;
2065 }
2066 
2067 static void e1000_get_ethtool_stats(struct net_device *netdev,
2068                     struct ethtool_stats __always_unused *stats,
2069                     u64 *data)
2070 {
2071     struct e1000_adapter *adapter = netdev_priv(netdev);
2072     struct rtnl_link_stats64 net_stats;
2073     int i;
2074     char *p = NULL;
2075 
2076     pm_runtime_get_sync(netdev->dev.parent);
2077 
2078     dev_get_stats(netdev, &net_stats);
2079 
2080     pm_runtime_put_sync(netdev->dev.parent);
2081 
2082     for (i = 0; i < E1000_GLOBAL_STATS_LEN; i++) {
2083         switch (e1000_gstrings_stats[i].type) {
2084         case NETDEV_STATS:
2085             p = (char *)&net_stats +
2086                 e1000_gstrings_stats[i].stat_offset;
2087             break;
2088         case E1000_STATS:
2089             p = (char *)adapter +
2090                 e1000_gstrings_stats[i].stat_offset;
2091             break;
2092         default:
2093             data[i] = 0;
2094             continue;
2095         }
2096 
2097         data[i] = (e1000_gstrings_stats[i].sizeof_stat ==
2098                sizeof(u64)) ? *(u64 *)p : *(u32 *)p;
2099     }
2100 }
2101 
2102 static void e1000_get_strings(struct net_device __always_unused *netdev,
2103                   u32 stringset, u8 *data)
2104 {
2105     u8 *p = data;
2106     int i;
2107 
2108     switch (stringset) {
2109     case ETH_SS_TEST:
2110         memcpy(data, e1000_gstrings_test, sizeof(e1000_gstrings_test));
2111         break;
2112     case ETH_SS_STATS:
2113         for (i = 0; i < E1000_GLOBAL_STATS_LEN; i++) {
2114             memcpy(p, e1000_gstrings_stats[i].stat_string,
2115                    ETH_GSTRING_LEN);
2116             p += ETH_GSTRING_LEN;
2117         }
2118         break;
2119     case ETH_SS_PRIV_FLAGS:
2120         memcpy(data, e1000e_priv_flags_strings,
2121                E1000E_PRIV_FLAGS_STR_LEN * ETH_GSTRING_LEN);
2122         break;
2123     }
2124 }
2125 
2126 static int e1000_get_rxnfc(struct net_device *netdev,
2127                struct ethtool_rxnfc *info,
2128                u32 __always_unused *rule_locs)
2129 {
2130     info->data = 0;
2131 
2132     switch (info->cmd) {
2133     case ETHTOOL_GRXFH: {
2134         struct e1000_adapter *adapter = netdev_priv(netdev);
2135         struct e1000_hw *hw = &adapter->hw;
2136         u32 mrqc;
2137 
2138         pm_runtime_get_sync(netdev->dev.parent);
2139         mrqc = er32(MRQC);
2140         pm_runtime_put_sync(netdev->dev.parent);
2141 
2142         if (!(mrqc & E1000_MRQC_RSS_FIELD_MASK))
2143             return 0;
2144 
2145         switch (info->flow_type) {
2146         case TCP_V4_FLOW:
2147             if (mrqc & E1000_MRQC_RSS_FIELD_IPV4_TCP)
2148                 info->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
2149             fallthrough;
2150         case UDP_V4_FLOW:
2151         case SCTP_V4_FLOW:
2152         case AH_ESP_V4_FLOW:
2153         case IPV4_FLOW:
2154             if (mrqc & E1000_MRQC_RSS_FIELD_IPV4)
2155                 info->data |= RXH_IP_SRC | RXH_IP_DST;
2156             break;
2157         case TCP_V6_FLOW:
2158             if (mrqc & E1000_MRQC_RSS_FIELD_IPV6_TCP)
2159                 info->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
2160             fallthrough;
2161         case UDP_V6_FLOW:
2162         case SCTP_V6_FLOW:
2163         case AH_ESP_V6_FLOW:
2164         case IPV6_FLOW:
2165             if (mrqc & E1000_MRQC_RSS_FIELD_IPV6)
2166                 info->data |= RXH_IP_SRC | RXH_IP_DST;
2167             break;
2168         default:
2169             break;
2170         }
2171         return 0;
2172     }
2173     default:
2174         return -EOPNOTSUPP;
2175     }
2176 }
2177 
2178 static int e1000e_get_eee(struct net_device *netdev, struct ethtool_eee *edata)
2179 {
2180     struct e1000_adapter *adapter = netdev_priv(netdev);
2181     struct e1000_hw *hw = &adapter->hw;
2182     u16 cap_addr, lpa_addr, pcs_stat_addr, phy_data;
2183     u32 ret_val;
2184 
2185     if (!(adapter->flags2 & FLAG2_HAS_EEE))
2186         return -EOPNOTSUPP;
2187 
2188     switch (hw->phy.type) {
2189     case e1000_phy_82579:
2190         cap_addr = I82579_EEE_CAPABILITY;
2191         lpa_addr = I82579_EEE_LP_ABILITY;
2192         pcs_stat_addr = I82579_EEE_PCS_STATUS;
2193         break;
2194     case e1000_phy_i217:
2195         cap_addr = I217_EEE_CAPABILITY;
2196         lpa_addr = I217_EEE_LP_ABILITY;
2197         pcs_stat_addr = I217_EEE_PCS_STATUS;
2198         break;
2199     default:
2200         return -EOPNOTSUPP;
2201     }
2202 
2203     pm_runtime_get_sync(netdev->dev.parent);
2204 
2205     ret_val = hw->phy.ops.acquire(hw);
2206     if (ret_val) {
2207         pm_runtime_put_sync(netdev->dev.parent);
2208         return -EBUSY;
2209     }
2210 
2211     /* EEE Capability */
2212     ret_val = e1000_read_emi_reg_locked(hw, cap_addr, &phy_data);
2213     if (ret_val)
2214         goto release;
2215     edata->supported = mmd_eee_cap_to_ethtool_sup_t(phy_data);
2216 
2217     /* EEE Advertised */
2218     edata->advertised = mmd_eee_adv_to_ethtool_adv_t(adapter->eee_advert);
2219 
2220     /* EEE Link Partner Advertised */
2221     ret_val = e1000_read_emi_reg_locked(hw, lpa_addr, &phy_data);
2222     if (ret_val)
2223         goto release;
2224     edata->lp_advertised = mmd_eee_adv_to_ethtool_adv_t(phy_data);
2225 
2226     /* EEE PCS Status */
2227     ret_val = e1000_read_emi_reg_locked(hw, pcs_stat_addr, &phy_data);
2228     if (ret_val)
2229         goto release;
2230     if (hw->phy.type == e1000_phy_82579)
2231         phy_data <<= 8;
2232 
2233     /* Result of the EEE auto negotiation - there is no register that
2234      * has the status of the EEE negotiation so do a best-guess based
2235      * on whether Tx or Rx LPI indications have been received.
2236      */
2237     if (phy_data & (E1000_EEE_TX_LPI_RCVD | E1000_EEE_RX_LPI_RCVD))
2238         edata->eee_active = true;
2239 
2240     edata->eee_enabled = !hw->dev_spec.ich8lan.eee_disable;
2241     edata->tx_lpi_enabled = true;
2242     edata->tx_lpi_timer = er32(LPIC) >> E1000_LPIC_LPIET_SHIFT;
2243 
2244 release:
2245     hw->phy.ops.release(hw);
2246     if (ret_val)
2247         ret_val = -ENODATA;
2248 
2249     pm_runtime_put_sync(netdev->dev.parent);
2250 
2251     return ret_val;
2252 }
2253 
2254 static int e1000e_set_eee(struct net_device *netdev, struct ethtool_eee *edata)
2255 {
2256     struct e1000_adapter *adapter = netdev_priv(netdev);
2257     struct e1000_hw *hw = &adapter->hw;
2258     struct ethtool_eee eee_curr;
2259     s32 ret_val;
2260 
2261     ret_val = e1000e_get_eee(netdev, &eee_curr);
2262     if (ret_val)
2263         return ret_val;
2264 
2265     if (eee_curr.tx_lpi_enabled != edata->tx_lpi_enabled) {
2266         e_err("Setting EEE tx-lpi is not supported\n");
2267         return -EINVAL;
2268     }
2269 
2270     if (eee_curr.tx_lpi_timer != edata->tx_lpi_timer) {
2271         e_err("Setting EEE Tx LPI timer is not supported\n");
2272         return -EINVAL;
2273     }
2274 
2275     if (edata->advertised & ~(ADVERTISE_100_FULL | ADVERTISE_1000_FULL)) {
2276         e_err("EEE advertisement supports only 100TX and/or 1000T full-duplex\n");
2277         return -EINVAL;
2278     }
2279 
2280     adapter->eee_advert = ethtool_adv_to_mmd_eee_adv_t(edata->advertised);
2281 
2282     hw->dev_spec.ich8lan.eee_disable = !edata->eee_enabled;
2283 
2284     pm_runtime_get_sync(netdev->dev.parent);
2285 
2286     /* reset the link */
2287     if (netif_running(netdev))
2288         e1000e_reinit_locked(adapter);
2289     else
2290         e1000e_reset(adapter);
2291 
2292     pm_runtime_put_sync(netdev->dev.parent);
2293 
2294     return 0;
2295 }
2296 
2297 static int e1000e_get_ts_info(struct net_device *netdev,
2298                   struct ethtool_ts_info *info)
2299 {
2300     struct e1000_adapter *adapter = netdev_priv(netdev);
2301 
2302     ethtool_op_get_ts_info(netdev, info);
2303 
2304     if (!(adapter->flags & FLAG_HAS_HW_TIMESTAMP))
2305         return 0;
2306 
2307     info->so_timestamping |= (SOF_TIMESTAMPING_TX_HARDWARE |
2308                   SOF_TIMESTAMPING_RX_HARDWARE |
2309                   SOF_TIMESTAMPING_RAW_HARDWARE);
2310 
2311     info->tx_types = BIT(HWTSTAMP_TX_OFF) | BIT(HWTSTAMP_TX_ON);
2312 
2313     info->rx_filters = (BIT(HWTSTAMP_FILTER_NONE) |
2314                 BIT(HWTSTAMP_FILTER_PTP_V1_L4_SYNC) |
2315                 BIT(HWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQ) |
2316                 BIT(HWTSTAMP_FILTER_PTP_V2_L4_SYNC) |
2317                 BIT(HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ) |
2318                 BIT(HWTSTAMP_FILTER_PTP_V2_L2_SYNC) |
2319                 BIT(HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ) |
2320                 BIT(HWTSTAMP_FILTER_PTP_V2_EVENT) |
2321                 BIT(HWTSTAMP_FILTER_PTP_V2_SYNC) |
2322                 BIT(HWTSTAMP_FILTER_PTP_V2_DELAY_REQ) |
2323                 BIT(HWTSTAMP_FILTER_ALL));
2324 
2325     if (adapter->ptp_clock)
2326         info->phc_index = ptp_clock_index(adapter->ptp_clock);
2327 
2328     return 0;
2329 }
2330 
2331 static u32 e1000e_get_priv_flags(struct net_device *netdev)
2332 {
2333     struct e1000_adapter *adapter = netdev_priv(netdev);
2334     u32 priv_flags = 0;
2335 
2336     if (adapter->flags2 & FLAG2_ENABLE_S0IX_FLOWS)
2337         priv_flags |= E1000E_PRIV_FLAGS_S0IX_ENABLED;
2338 
2339     return priv_flags;
2340 }
2341 
2342 static int e1000e_set_priv_flags(struct net_device *netdev, u32 priv_flags)
2343 {
2344     struct e1000_adapter *adapter = netdev_priv(netdev);
2345     unsigned int flags2 = adapter->flags2;
2346 
2347     flags2 &= ~FLAG2_ENABLE_S0IX_FLOWS;
2348     if (priv_flags & E1000E_PRIV_FLAGS_S0IX_ENABLED) {
2349         struct e1000_hw *hw = &adapter->hw;
2350 
2351         if (hw->mac.type < e1000_pch_cnp)
2352             return -EINVAL;
2353         flags2 |= FLAG2_ENABLE_S0IX_FLOWS;
2354     }
2355 
2356     if (flags2 != adapter->flags2)
2357         adapter->flags2 = flags2;
2358 
2359     return 0;
2360 }
2361 
2362 static const struct ethtool_ops e1000_ethtool_ops = {
2363     .supported_coalesce_params = ETHTOOL_COALESCE_RX_USECS,
2364     .get_drvinfo        = e1000_get_drvinfo,
2365     .get_regs_len       = e1000_get_regs_len,
2366     .get_regs       = e1000_get_regs,
2367     .get_wol        = e1000_get_wol,
2368     .set_wol        = e1000_set_wol,
2369     .get_msglevel       = e1000_get_msglevel,
2370     .set_msglevel       = e1000_set_msglevel,
2371     .nway_reset     = e1000_nway_reset,
2372     .get_link       = ethtool_op_get_link,
2373     .get_eeprom_len     = e1000_get_eeprom_len,
2374     .get_eeprom     = e1000_get_eeprom,
2375     .set_eeprom     = e1000_set_eeprom,
2376     .get_ringparam      = e1000_get_ringparam,
2377     .set_ringparam      = e1000_set_ringparam,
2378     .get_pauseparam     = e1000_get_pauseparam,
2379     .set_pauseparam     = e1000_set_pauseparam,
2380     .self_test      = e1000_diag_test,
2381     .get_strings        = e1000_get_strings,
2382     .set_phys_id        = e1000_set_phys_id,
2383     .get_ethtool_stats  = e1000_get_ethtool_stats,
2384     .get_sset_count     = e1000e_get_sset_count,
2385     .get_coalesce       = e1000_get_coalesce,
2386     .set_coalesce       = e1000_set_coalesce,
2387     .get_rxnfc      = e1000_get_rxnfc,
2388     .get_ts_info        = e1000e_get_ts_info,
2389     .get_eee        = e1000e_get_eee,
2390     .set_eee        = e1000e_set_eee,
2391     .get_link_ksettings = e1000_get_link_ksettings,
2392     .set_link_ksettings = e1000_set_link_ksettings,
2393     .get_priv_flags     = e1000e_get_priv_flags,
2394     .set_priv_flags     = e1000e_set_priv_flags,
2395 };
2396 
2397 void e1000e_set_ethtool_ops(struct net_device *netdev)
2398 {
2399     netdev->ethtool_ops = &e1000_ethtool_ops;
2400 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!