Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /* Copyright(c) 1999 - 2006 Intel Corporation. */
0003 
0004 /* ethtool support for e1000 */
0005 
0006 #include "e1000.h"
0007 #include <linux/jiffies.h>
0008 #include <linux/uaccess.h>
0009 
0010 enum {NETDEV_STATS, E1000_STATS};
0011 
0012 struct e1000_stats {
0013     char stat_string[ETH_GSTRING_LEN];
0014     int type;
0015     int sizeof_stat;
0016     int stat_offset;
0017 };
0018 
0019 #define E1000_STAT(m)       E1000_STATS, \
0020                 sizeof(((struct e1000_adapter *)0)->m), \
0021                 offsetof(struct e1000_adapter, m)
0022 #define E1000_NETDEV_STAT(m)    NETDEV_STATS, \
0023                 sizeof(((struct net_device *)0)->m), \
0024                 offsetof(struct net_device, m)
0025 
0026 static const struct e1000_stats e1000_gstrings_stats[] = {
0027     { "rx_packets", E1000_STAT(stats.gprc) },
0028     { "tx_packets", E1000_STAT(stats.gptc) },
0029     { "rx_bytes", E1000_STAT(stats.gorcl) },
0030     { "tx_bytes", E1000_STAT(stats.gotcl) },
0031     { "rx_broadcast", E1000_STAT(stats.bprc) },
0032     { "tx_broadcast", E1000_STAT(stats.bptc) },
0033     { "rx_multicast", E1000_STAT(stats.mprc) },
0034     { "tx_multicast", E1000_STAT(stats.mptc) },
0035     { "rx_errors", E1000_STAT(stats.rxerrc) },
0036     { "tx_errors", E1000_STAT(stats.txerrc) },
0037     { "tx_dropped", E1000_NETDEV_STAT(stats.tx_dropped) },
0038     { "multicast", E1000_STAT(stats.mprc) },
0039     { "collisions", E1000_STAT(stats.colc) },
0040     { "rx_length_errors", E1000_STAT(stats.rlerrc) },
0041     { "rx_over_errors", E1000_NETDEV_STAT(stats.rx_over_errors) },
0042     { "rx_crc_errors", E1000_STAT(stats.crcerrs) },
0043     { "rx_frame_errors", E1000_NETDEV_STAT(stats.rx_frame_errors) },
0044     { "rx_no_buffer_count", E1000_STAT(stats.rnbc) },
0045     { "rx_missed_errors", E1000_STAT(stats.mpc) },
0046     { "tx_aborted_errors", E1000_STAT(stats.ecol) },
0047     { "tx_carrier_errors", E1000_STAT(stats.tncrs) },
0048     { "tx_fifo_errors", E1000_NETDEV_STAT(stats.tx_fifo_errors) },
0049     { "tx_heartbeat_errors", E1000_NETDEV_STAT(stats.tx_heartbeat_errors) },
0050     { "tx_window_errors", E1000_STAT(stats.latecol) },
0051     { "tx_abort_late_coll", E1000_STAT(stats.latecol) },
0052     { "tx_deferred_ok", E1000_STAT(stats.dc) },
0053     { "tx_single_coll_ok", E1000_STAT(stats.scc) },
0054     { "tx_multi_coll_ok", E1000_STAT(stats.mcc) },
0055     { "tx_timeout_count", E1000_STAT(tx_timeout_count) },
0056     { "tx_restart_queue", E1000_STAT(restart_queue) },
0057     { "rx_long_length_errors", E1000_STAT(stats.roc) },
0058     { "rx_short_length_errors", E1000_STAT(stats.ruc) },
0059     { "rx_align_errors", E1000_STAT(stats.algnerrc) },
0060     { "tx_tcp_seg_good", E1000_STAT(stats.tsctc) },
0061     { "tx_tcp_seg_failed", E1000_STAT(stats.tsctfc) },
0062     { "rx_flow_control_xon", E1000_STAT(stats.xonrxc) },
0063     { "rx_flow_control_xoff", E1000_STAT(stats.xoffrxc) },
0064     { "tx_flow_control_xon", E1000_STAT(stats.xontxc) },
0065     { "tx_flow_control_xoff", E1000_STAT(stats.xofftxc) },
0066     { "rx_long_byte_count", E1000_STAT(stats.gorcl) },
0067     { "rx_csum_offload_good", E1000_STAT(hw_csum_good) },
0068     { "rx_csum_offload_errors", E1000_STAT(hw_csum_err) },
0069     { "alloc_rx_buff_failed", E1000_STAT(alloc_rx_buff_failed) },
0070     { "tx_smbus", E1000_STAT(stats.mgptc) },
0071     { "rx_smbus", E1000_STAT(stats.mgprc) },
0072     { "dropped_smbus", E1000_STAT(stats.mgpdc) },
0073 };
0074 
0075 #define E1000_QUEUE_STATS_LEN 0
0076 #define E1000_GLOBAL_STATS_LEN ARRAY_SIZE(e1000_gstrings_stats)
0077 #define E1000_STATS_LEN (E1000_GLOBAL_STATS_LEN + E1000_QUEUE_STATS_LEN)
0078 static const char e1000_gstrings_test[][ETH_GSTRING_LEN] = {
0079     "Register test  (offline)", "Eeprom test    (offline)",
0080     "Interrupt test (offline)", "Loopback test  (offline)",
0081     "Link test   (on/offline)"
0082 };
0083 
0084 #define E1000_TEST_LEN  ARRAY_SIZE(e1000_gstrings_test)
0085 
0086 static int e1000_get_link_ksettings(struct net_device *netdev,
0087                     struct ethtool_link_ksettings *cmd)
0088 {
0089     struct e1000_adapter *adapter = netdev_priv(netdev);
0090     struct e1000_hw *hw = &adapter->hw;
0091     u32 supported, advertising;
0092 
0093     if (hw->media_type == e1000_media_type_copper) {
0094         supported = (SUPPORTED_10baseT_Half |
0095                  SUPPORTED_10baseT_Full |
0096                  SUPPORTED_100baseT_Half |
0097                  SUPPORTED_100baseT_Full |
0098                  SUPPORTED_1000baseT_Full|
0099                  SUPPORTED_Autoneg |
0100                  SUPPORTED_TP);
0101         advertising = ADVERTISED_TP;
0102 
0103         if (hw->autoneg == 1) {
0104             advertising |= ADVERTISED_Autoneg;
0105             /* the e1000 autoneg seems to match ethtool nicely */
0106             advertising |= hw->autoneg_advertised;
0107         }
0108 
0109         cmd->base.port = PORT_TP;
0110         cmd->base.phy_address = hw->phy_addr;
0111     } else {
0112         supported   = (SUPPORTED_1000baseT_Full |
0113                    SUPPORTED_FIBRE |
0114                    SUPPORTED_Autoneg);
0115 
0116         advertising = (ADVERTISED_1000baseT_Full |
0117                    ADVERTISED_FIBRE |
0118                    ADVERTISED_Autoneg);
0119 
0120         cmd->base.port = PORT_FIBRE;
0121     }
0122 
0123     if (er32(STATUS) & E1000_STATUS_LU) {
0124         e1000_get_speed_and_duplex(hw, &adapter->link_speed,
0125                        &adapter->link_duplex);
0126         cmd->base.speed = adapter->link_speed;
0127 
0128         /* unfortunately FULL_DUPLEX != DUPLEX_FULL
0129          * and HALF_DUPLEX != DUPLEX_HALF
0130          */
0131         if (adapter->link_duplex == FULL_DUPLEX)
0132             cmd->base.duplex = DUPLEX_FULL;
0133         else
0134             cmd->base.duplex = DUPLEX_HALF;
0135     } else {
0136         cmd->base.speed = SPEED_UNKNOWN;
0137         cmd->base.duplex = DUPLEX_UNKNOWN;
0138     }
0139 
0140     cmd->base.autoneg = ((hw->media_type == e1000_media_type_fiber) ||
0141              hw->autoneg) ? AUTONEG_ENABLE : AUTONEG_DISABLE;
0142 
0143     /* MDI-X => 1; MDI => 0 */
0144     if ((hw->media_type == e1000_media_type_copper) &&
0145         netif_carrier_ok(netdev))
0146         cmd->base.eth_tp_mdix = (!!adapter->phy_info.mdix_mode ?
0147                      ETH_TP_MDI_X : ETH_TP_MDI);
0148     else
0149         cmd->base.eth_tp_mdix = ETH_TP_MDI_INVALID;
0150 
0151     if (hw->mdix == AUTO_ALL_MODES)
0152         cmd->base.eth_tp_mdix_ctrl = ETH_TP_MDI_AUTO;
0153     else
0154         cmd->base.eth_tp_mdix_ctrl = hw->mdix;
0155 
0156     ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported,
0157                         supported);
0158     ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.advertising,
0159                         advertising);
0160 
0161     return 0;
0162 }
0163 
0164 static int e1000_set_link_ksettings(struct net_device *netdev,
0165                     const struct ethtool_link_ksettings *cmd)
0166 {
0167     struct e1000_adapter *adapter = netdev_priv(netdev);
0168     struct e1000_hw *hw = &adapter->hw;
0169     u32 advertising;
0170 
0171     ethtool_convert_link_mode_to_legacy_u32(&advertising,
0172                         cmd->link_modes.advertising);
0173 
0174     /* MDI setting is only allowed when autoneg enabled because
0175      * some hardware doesn't allow MDI setting when speed or
0176      * duplex is forced.
0177      */
0178     if (cmd->base.eth_tp_mdix_ctrl) {
0179         if (hw->media_type != e1000_media_type_copper)
0180             return -EOPNOTSUPP;
0181 
0182         if ((cmd->base.eth_tp_mdix_ctrl != ETH_TP_MDI_AUTO) &&
0183             (cmd->base.autoneg != AUTONEG_ENABLE)) {
0184             e_err(drv, "forcing MDI/MDI-X state is not supported when link speed and/or duplex are forced\n");
0185             return -EINVAL;
0186         }
0187     }
0188 
0189     while (test_and_set_bit(__E1000_RESETTING, &adapter->flags))
0190         msleep(1);
0191 
0192     if (cmd->base.autoneg == AUTONEG_ENABLE) {
0193         hw->autoneg = 1;
0194         if (hw->media_type == e1000_media_type_fiber)
0195             hw->autoneg_advertised = ADVERTISED_1000baseT_Full |
0196                          ADVERTISED_FIBRE |
0197                          ADVERTISED_Autoneg;
0198         else
0199             hw->autoneg_advertised = advertising |
0200                          ADVERTISED_TP |
0201                          ADVERTISED_Autoneg;
0202     } else {
0203         u32 speed = cmd->base.speed;
0204         /* calling this overrides forced MDI setting */
0205         if (e1000_set_spd_dplx(adapter, speed, cmd->base.duplex)) {
0206             clear_bit(__E1000_RESETTING, &adapter->flags);
0207             return -EINVAL;
0208         }
0209     }
0210 
0211     /* MDI-X => 2; MDI => 1; Auto => 3 */
0212     if (cmd->base.eth_tp_mdix_ctrl) {
0213         if (cmd->base.eth_tp_mdix_ctrl == ETH_TP_MDI_AUTO)
0214             hw->mdix = AUTO_ALL_MODES;
0215         else
0216             hw->mdix = cmd->base.eth_tp_mdix_ctrl;
0217     }
0218 
0219     /* reset the link */
0220 
0221     if (netif_running(adapter->netdev)) {
0222         e1000_down(adapter);
0223         e1000_up(adapter);
0224     } else {
0225         e1000_reset(adapter);
0226     }
0227     clear_bit(__E1000_RESETTING, &adapter->flags);
0228     return 0;
0229 }
0230 
0231 static u32 e1000_get_link(struct net_device *netdev)
0232 {
0233     struct e1000_adapter *adapter = netdev_priv(netdev);
0234 
0235     /* If the link is not reported up to netdev, interrupts are disabled,
0236      * and so the physical link state may have changed since we last
0237      * looked. Set get_link_status to make sure that the true link
0238      * state is interrogated, rather than pulling a cached and possibly
0239      * stale link state from the driver.
0240      */
0241     if (!netif_carrier_ok(netdev))
0242         adapter->hw.get_link_status = 1;
0243 
0244     return e1000_has_link(adapter);
0245 }
0246 
0247 static void e1000_get_pauseparam(struct net_device *netdev,
0248                  struct ethtool_pauseparam *pause)
0249 {
0250     struct e1000_adapter *adapter = netdev_priv(netdev);
0251     struct e1000_hw *hw = &adapter->hw;
0252 
0253     pause->autoneg =
0254         (adapter->fc_autoneg ? AUTONEG_ENABLE : AUTONEG_DISABLE);
0255 
0256     if (hw->fc == E1000_FC_RX_PAUSE) {
0257         pause->rx_pause = 1;
0258     } else if (hw->fc == E1000_FC_TX_PAUSE) {
0259         pause->tx_pause = 1;
0260     } else if (hw->fc == E1000_FC_FULL) {
0261         pause->rx_pause = 1;
0262         pause->tx_pause = 1;
0263     }
0264 }
0265 
0266 static int e1000_set_pauseparam(struct net_device *netdev,
0267                 struct ethtool_pauseparam *pause)
0268 {
0269     struct e1000_adapter *adapter = netdev_priv(netdev);
0270     struct e1000_hw *hw = &adapter->hw;
0271     int retval = 0;
0272 
0273     adapter->fc_autoneg = pause->autoneg;
0274 
0275     while (test_and_set_bit(__E1000_RESETTING, &adapter->flags))
0276         msleep(1);
0277 
0278     if (pause->rx_pause && pause->tx_pause)
0279         hw->fc = E1000_FC_FULL;
0280     else if (pause->rx_pause && !pause->tx_pause)
0281         hw->fc = E1000_FC_RX_PAUSE;
0282     else if (!pause->rx_pause && pause->tx_pause)
0283         hw->fc = E1000_FC_TX_PAUSE;
0284     else if (!pause->rx_pause && !pause->tx_pause)
0285         hw->fc = E1000_FC_NONE;
0286 
0287     hw->original_fc = hw->fc;
0288 
0289     if (adapter->fc_autoneg == AUTONEG_ENABLE) {
0290         if (netif_running(adapter->netdev)) {
0291             e1000_down(adapter);
0292             e1000_up(adapter);
0293         } else {
0294             e1000_reset(adapter);
0295         }
0296     } else
0297         retval = ((hw->media_type == e1000_media_type_fiber) ?
0298               e1000_setup_link(hw) : e1000_force_mac_fc(hw));
0299 
0300     clear_bit(__E1000_RESETTING, &adapter->flags);
0301     return retval;
0302 }
0303 
0304 static u32 e1000_get_msglevel(struct net_device *netdev)
0305 {
0306     struct e1000_adapter *adapter = netdev_priv(netdev);
0307 
0308     return adapter->msg_enable;
0309 }
0310 
0311 static void e1000_set_msglevel(struct net_device *netdev, u32 data)
0312 {
0313     struct e1000_adapter *adapter = netdev_priv(netdev);
0314 
0315     adapter->msg_enable = data;
0316 }
0317 
0318 static int e1000_get_regs_len(struct net_device *netdev)
0319 {
0320 #define E1000_REGS_LEN 32
0321     return E1000_REGS_LEN * sizeof(u32);
0322 }
0323 
0324 static void e1000_get_regs(struct net_device *netdev, struct ethtool_regs *regs,
0325                void *p)
0326 {
0327     struct e1000_adapter *adapter = netdev_priv(netdev);
0328     struct e1000_hw *hw = &adapter->hw;
0329     u32 *regs_buff = p;
0330     u16 phy_data;
0331 
0332     memset(p, 0, E1000_REGS_LEN * sizeof(u32));
0333 
0334     regs->version = (1 << 24) | (hw->revision_id << 16) | hw->device_id;
0335 
0336     regs_buff[0]  = er32(CTRL);
0337     regs_buff[1]  = er32(STATUS);
0338 
0339     regs_buff[2]  = er32(RCTL);
0340     regs_buff[3]  = er32(RDLEN);
0341     regs_buff[4]  = er32(RDH);
0342     regs_buff[5]  = er32(RDT);
0343     regs_buff[6]  = er32(RDTR);
0344 
0345     regs_buff[7]  = er32(TCTL);
0346     regs_buff[8]  = er32(TDLEN);
0347     regs_buff[9]  = er32(TDH);
0348     regs_buff[10] = er32(TDT);
0349     regs_buff[11] = er32(TIDV);
0350 
0351     regs_buff[12] = hw->phy_type;  /* PHY type (IGP=1, M88=0) */
0352     if (hw->phy_type == e1000_phy_igp) {
0353         e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT,
0354                     IGP01E1000_PHY_AGC_A);
0355         e1000_read_phy_reg(hw, IGP01E1000_PHY_AGC_A &
0356                    IGP01E1000_PHY_PAGE_SELECT, &phy_data);
0357         regs_buff[13] = (u32)phy_data; /* cable length */
0358         e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT,
0359                     IGP01E1000_PHY_AGC_B);
0360         e1000_read_phy_reg(hw, IGP01E1000_PHY_AGC_B &
0361                    IGP01E1000_PHY_PAGE_SELECT, &phy_data);
0362         regs_buff[14] = (u32)phy_data; /* cable length */
0363         e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT,
0364                     IGP01E1000_PHY_AGC_C);
0365         e1000_read_phy_reg(hw, IGP01E1000_PHY_AGC_C &
0366                    IGP01E1000_PHY_PAGE_SELECT, &phy_data);
0367         regs_buff[15] = (u32)phy_data; /* cable length */
0368         e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT,
0369                     IGP01E1000_PHY_AGC_D);
0370         e1000_read_phy_reg(hw, IGP01E1000_PHY_AGC_D &
0371                    IGP01E1000_PHY_PAGE_SELECT, &phy_data);
0372         regs_buff[16] = (u32)phy_data; /* cable length */
0373         regs_buff[17] = 0; /* extended 10bt distance (not needed) */
0374         e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT, 0x0);
0375         e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_STATUS &
0376                    IGP01E1000_PHY_PAGE_SELECT, &phy_data);
0377         regs_buff[18] = (u32)phy_data; /* cable polarity */
0378         e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT,
0379                     IGP01E1000_PHY_PCS_INIT_REG);
0380         e1000_read_phy_reg(hw, IGP01E1000_PHY_PCS_INIT_REG &
0381                    IGP01E1000_PHY_PAGE_SELECT, &phy_data);
0382         regs_buff[19] = (u32)phy_data; /* cable polarity */
0383         regs_buff[20] = 0; /* polarity correction enabled (always) */
0384         regs_buff[22] = 0; /* phy receive errors (unavailable) */
0385         regs_buff[23] = regs_buff[18]; /* mdix mode */
0386         e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT, 0x0);
0387     } else {
0388         e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_STATUS, &phy_data);
0389         regs_buff[13] = (u32)phy_data; /* cable length */
0390         regs_buff[14] = 0;  /* Dummy (to align w/ IGP phy reg dump) */
0391         regs_buff[15] = 0;  /* Dummy (to align w/ IGP phy reg dump) */
0392         regs_buff[16] = 0;  /* Dummy (to align w/ IGP phy reg dump) */
0393         e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);
0394         regs_buff[17] = (u32)phy_data; /* extended 10bt distance */
0395         regs_buff[18] = regs_buff[13]; /* cable polarity */
0396         regs_buff[19] = 0;  /* Dummy (to align w/ IGP phy reg dump) */
0397         regs_buff[20] = regs_buff[17]; /* polarity correction */
0398         /* phy receive errors */
0399         regs_buff[22] = adapter->phy_stats.receive_errors;
0400         regs_buff[23] = regs_buff[13]; /* mdix mode */
0401     }
0402     regs_buff[21] = adapter->phy_stats.idle_errors;  /* phy idle errors */
0403     e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_data);
0404     regs_buff[24] = (u32)phy_data;  /* phy local receiver status */
0405     regs_buff[25] = regs_buff[24];  /* phy remote receiver status */
0406     if (hw->mac_type >= e1000_82540 &&
0407         hw->media_type == e1000_media_type_copper) {
0408         regs_buff[26] = er32(MANC);
0409     }
0410 }
0411 
0412 static int e1000_get_eeprom_len(struct net_device *netdev)
0413 {
0414     struct e1000_adapter *adapter = netdev_priv(netdev);
0415     struct e1000_hw *hw = &adapter->hw;
0416 
0417     return hw->eeprom.word_size * 2;
0418 }
0419 
0420 static int e1000_get_eeprom(struct net_device *netdev,
0421                 struct ethtool_eeprom *eeprom, u8 *bytes)
0422 {
0423     struct e1000_adapter *adapter = netdev_priv(netdev);
0424     struct e1000_hw *hw = &adapter->hw;
0425     u16 *eeprom_buff;
0426     int first_word, last_word;
0427     int ret_val = 0;
0428     u16 i;
0429 
0430     if (eeprom->len == 0)
0431         return -EINVAL;
0432 
0433     eeprom->magic = hw->vendor_id | (hw->device_id << 16);
0434 
0435     first_word = eeprom->offset >> 1;
0436     last_word = (eeprom->offset + eeprom->len - 1) >> 1;
0437 
0438     eeprom_buff = kmalloc_array(last_word - first_word + 1, sizeof(u16),
0439                     GFP_KERNEL);
0440     if (!eeprom_buff)
0441         return -ENOMEM;
0442 
0443     if (hw->eeprom.type == e1000_eeprom_spi)
0444         ret_val = e1000_read_eeprom(hw, first_word,
0445                         last_word - first_word + 1,
0446                         eeprom_buff);
0447     else {
0448         for (i = 0; i < last_word - first_word + 1; i++) {
0449             ret_val = e1000_read_eeprom(hw, first_word + i, 1,
0450                             &eeprom_buff[i]);
0451             if (ret_val)
0452                 break;
0453         }
0454     }
0455 
0456     /* Device's eeprom is always little-endian, word addressable */
0457     for (i = 0; i < last_word - first_word + 1; i++)
0458         le16_to_cpus(&eeprom_buff[i]);
0459 
0460     memcpy(bytes, (u8 *)eeprom_buff + (eeprom->offset & 1),
0461            eeprom->len);
0462     kfree(eeprom_buff);
0463 
0464     return ret_val;
0465 }
0466 
0467 static int e1000_set_eeprom(struct net_device *netdev,
0468                 struct ethtool_eeprom *eeprom, u8 *bytes)
0469 {
0470     struct e1000_adapter *adapter = netdev_priv(netdev);
0471     struct e1000_hw *hw = &adapter->hw;
0472     u16 *eeprom_buff;
0473     void *ptr;
0474     int max_len, first_word, last_word, ret_val = 0;
0475     u16 i;
0476 
0477     if (eeprom->len == 0)
0478         return -EOPNOTSUPP;
0479 
0480     if (eeprom->magic != (hw->vendor_id | (hw->device_id << 16)))
0481         return -EFAULT;
0482 
0483     max_len = hw->eeprom.word_size * 2;
0484 
0485     first_word = eeprom->offset >> 1;
0486     last_word = (eeprom->offset + eeprom->len - 1) >> 1;
0487     eeprom_buff = kmalloc(max_len, GFP_KERNEL);
0488     if (!eeprom_buff)
0489         return -ENOMEM;
0490 
0491     ptr = (void *)eeprom_buff;
0492 
0493     if (eeprom->offset & 1) {
0494         /* need read/modify/write of first changed EEPROM word
0495          * only the second byte of the word is being modified
0496          */
0497         ret_val = e1000_read_eeprom(hw, first_word, 1,
0498                         &eeprom_buff[0]);
0499         ptr++;
0500     }
0501     if (((eeprom->offset + eeprom->len) & 1) && (ret_val == 0)) {
0502         /* need read/modify/write of last changed EEPROM word
0503          * only the first byte of the word is being modified
0504          */
0505         ret_val = e1000_read_eeprom(hw, last_word, 1,
0506                         &eeprom_buff[last_word - first_word]);
0507     }
0508 
0509     /* Device's eeprom is always little-endian, word addressable */
0510     for (i = 0; i < last_word - first_word + 1; i++)
0511         le16_to_cpus(&eeprom_buff[i]);
0512 
0513     memcpy(ptr, bytes, eeprom->len);
0514 
0515     for (i = 0; i < last_word - first_word + 1; i++)
0516         cpu_to_le16s(&eeprom_buff[i]);
0517 
0518     ret_val = e1000_write_eeprom(hw, first_word,
0519                      last_word - first_word + 1, eeprom_buff);
0520 
0521     /* Update the checksum over the first part of the EEPROM if needed */
0522     if ((ret_val == 0) && (first_word <= EEPROM_CHECKSUM_REG))
0523         e1000_update_eeprom_checksum(hw);
0524 
0525     kfree(eeprom_buff);
0526     return ret_val;
0527 }
0528 
0529 static void e1000_get_drvinfo(struct net_device *netdev,
0530                   struct ethtool_drvinfo *drvinfo)
0531 {
0532     struct e1000_adapter *adapter = netdev_priv(netdev);
0533 
0534     strlcpy(drvinfo->driver,  e1000_driver_name,
0535         sizeof(drvinfo->driver));
0536 
0537     strlcpy(drvinfo->bus_info, pci_name(adapter->pdev),
0538         sizeof(drvinfo->bus_info));
0539 }
0540 
0541 static void e1000_get_ringparam(struct net_device *netdev,
0542                 struct ethtool_ringparam *ring,
0543                 struct kernel_ethtool_ringparam *kernel_ring,
0544                 struct netlink_ext_ack *extack)
0545 {
0546     struct e1000_adapter *adapter = netdev_priv(netdev);
0547     struct e1000_hw *hw = &adapter->hw;
0548     e1000_mac_type mac_type = hw->mac_type;
0549     struct e1000_tx_ring *txdr = adapter->tx_ring;
0550     struct e1000_rx_ring *rxdr = adapter->rx_ring;
0551 
0552     ring->rx_max_pending = (mac_type < e1000_82544) ? E1000_MAX_RXD :
0553         E1000_MAX_82544_RXD;
0554     ring->tx_max_pending = (mac_type < e1000_82544) ? E1000_MAX_TXD :
0555         E1000_MAX_82544_TXD;
0556     ring->rx_pending = rxdr->count;
0557     ring->tx_pending = txdr->count;
0558 }
0559 
0560 static int e1000_set_ringparam(struct net_device *netdev,
0561                    struct ethtool_ringparam *ring,
0562                    struct kernel_ethtool_ringparam *kernel_ring,
0563                    struct netlink_ext_ack *extack)
0564 {
0565     struct e1000_adapter *adapter = netdev_priv(netdev);
0566     struct e1000_hw *hw = &adapter->hw;
0567     e1000_mac_type mac_type = hw->mac_type;
0568     struct e1000_tx_ring *txdr, *tx_old;
0569     struct e1000_rx_ring *rxdr, *rx_old;
0570     int i, err;
0571 
0572     if ((ring->rx_mini_pending) || (ring->rx_jumbo_pending))
0573         return -EINVAL;
0574 
0575     while (test_and_set_bit(__E1000_RESETTING, &adapter->flags))
0576         msleep(1);
0577 
0578     if (netif_running(adapter->netdev))
0579         e1000_down(adapter);
0580 
0581     tx_old = adapter->tx_ring;
0582     rx_old = adapter->rx_ring;
0583 
0584     err = -ENOMEM;
0585     txdr = kcalloc(adapter->num_tx_queues, sizeof(struct e1000_tx_ring),
0586                GFP_KERNEL);
0587     if (!txdr)
0588         goto err_alloc_tx;
0589 
0590     rxdr = kcalloc(adapter->num_rx_queues, sizeof(struct e1000_rx_ring),
0591                GFP_KERNEL);
0592     if (!rxdr)
0593         goto err_alloc_rx;
0594 
0595     adapter->tx_ring = txdr;
0596     adapter->rx_ring = rxdr;
0597 
0598     rxdr->count = max(ring->rx_pending, (u32)E1000_MIN_RXD);
0599     rxdr->count = min(rxdr->count, (u32)(mac_type < e1000_82544 ?
0600               E1000_MAX_RXD : E1000_MAX_82544_RXD));
0601     rxdr->count = ALIGN(rxdr->count, REQ_RX_DESCRIPTOR_MULTIPLE);
0602     txdr->count = max(ring->tx_pending, (u32)E1000_MIN_TXD);
0603     txdr->count = min(txdr->count, (u32)(mac_type < e1000_82544 ?
0604               E1000_MAX_TXD : E1000_MAX_82544_TXD));
0605     txdr->count = ALIGN(txdr->count, REQ_TX_DESCRIPTOR_MULTIPLE);
0606 
0607     for (i = 0; i < adapter->num_tx_queues; i++)
0608         txdr[i].count = txdr->count;
0609     for (i = 0; i < adapter->num_rx_queues; i++)
0610         rxdr[i].count = rxdr->count;
0611 
0612     err = 0;
0613     if (netif_running(adapter->netdev)) {
0614         /* Try to get new resources before deleting old */
0615         err = e1000_setup_all_rx_resources(adapter);
0616         if (err)
0617             goto err_setup_rx;
0618         err = e1000_setup_all_tx_resources(adapter);
0619         if (err)
0620             goto err_setup_tx;
0621 
0622         /* save the new, restore the old in order to free it,
0623          * then restore the new back again
0624          */
0625 
0626         adapter->rx_ring = rx_old;
0627         adapter->tx_ring = tx_old;
0628         e1000_free_all_rx_resources(adapter);
0629         e1000_free_all_tx_resources(adapter);
0630         adapter->rx_ring = rxdr;
0631         adapter->tx_ring = txdr;
0632         err = e1000_up(adapter);
0633     }
0634     kfree(tx_old);
0635     kfree(rx_old);
0636 
0637     clear_bit(__E1000_RESETTING, &adapter->flags);
0638     return err;
0639 
0640 err_setup_tx:
0641     e1000_free_all_rx_resources(adapter);
0642 err_setup_rx:
0643     adapter->rx_ring = rx_old;
0644     adapter->tx_ring = tx_old;
0645     kfree(rxdr);
0646 err_alloc_rx:
0647     kfree(txdr);
0648 err_alloc_tx:
0649     if (netif_running(adapter->netdev))
0650         e1000_up(adapter);
0651     clear_bit(__E1000_RESETTING, &adapter->flags);
0652     return err;
0653 }
0654 
0655 static bool reg_pattern_test(struct e1000_adapter *adapter, u64 *data, int reg,
0656                  u32 mask, u32 write)
0657 {
0658     struct e1000_hw *hw = &adapter->hw;
0659     static const u32 test[] = {
0660         0x5A5A5A5A, 0xA5A5A5A5, 0x00000000, 0xFFFFFFFF
0661     };
0662     u8 __iomem *address = hw->hw_addr + reg;
0663     u32 read;
0664     int i;
0665 
0666     for (i = 0; i < ARRAY_SIZE(test); i++) {
0667         writel(write & test[i], address);
0668         read = readl(address);
0669         if (read != (write & test[i] & mask)) {
0670             e_err(drv, "pattern test reg %04X failed: "
0671                   "got 0x%08X expected 0x%08X\n",
0672                   reg, read, (write & test[i] & mask));
0673             *data = reg;
0674             return true;
0675         }
0676     }
0677     return false;
0678 }
0679 
0680 static bool reg_set_and_check(struct e1000_adapter *adapter, u64 *data, int reg,
0681                   u32 mask, u32 write)
0682 {
0683     struct e1000_hw *hw = &adapter->hw;
0684     u8 __iomem *address = hw->hw_addr + reg;
0685     u32 read;
0686 
0687     writel(write & mask, address);
0688     read = readl(address);
0689     if ((read & mask) != (write & mask)) {
0690         e_err(drv, "set/check reg %04X test failed: "
0691               "got 0x%08X expected 0x%08X\n",
0692               reg, (read & mask), (write & mask));
0693         *data = reg;
0694         return true;
0695     }
0696     return false;
0697 }
0698 
0699 #define REG_PATTERN_TEST(reg, mask, write)               \
0700     do {                                 \
0701         if (reg_pattern_test(adapter, data,          \
0702                  (hw->mac_type >= e1000_82543)   \
0703                  ? E1000_##reg : E1000_82542_##reg,      \
0704                  mask, write))               \
0705             return 1;                    \
0706     } while (0)
0707 
0708 #define REG_SET_AND_CHECK(reg, mask, write)              \
0709     do {                                 \
0710         if (reg_set_and_check(adapter, data,             \
0711                   (hw->mac_type >= e1000_82543)  \
0712                   ? E1000_##reg : E1000_82542_##reg,     \
0713                   mask, write))              \
0714             return 1;                    \
0715     } while (0)
0716 
0717 static int e1000_reg_test(struct e1000_adapter *adapter, u64 *data)
0718 {
0719     u32 value, before, after;
0720     u32 i, toggle;
0721     struct e1000_hw *hw = &adapter->hw;
0722 
0723     /* The status register is Read Only, so a write should fail.
0724      * Some bits that get toggled are ignored.
0725      */
0726 
0727     /* there are several bits on newer hardware that are r/w */
0728     toggle = 0xFFFFF833;
0729 
0730     before = er32(STATUS);
0731     value = (er32(STATUS) & toggle);
0732     ew32(STATUS, toggle);
0733     after = er32(STATUS) & toggle;
0734     if (value != after) {
0735         e_err(drv, "failed STATUS register test got: "
0736               "0x%08X expected: 0x%08X\n", after, value);
0737         *data = 1;
0738         return 1;
0739     }
0740     /* restore previous status */
0741     ew32(STATUS, before);
0742 
0743     REG_PATTERN_TEST(FCAL, 0xFFFFFFFF, 0xFFFFFFFF);
0744     REG_PATTERN_TEST(FCAH, 0x0000FFFF, 0xFFFFFFFF);
0745     REG_PATTERN_TEST(FCT, 0x0000FFFF, 0xFFFFFFFF);
0746     REG_PATTERN_TEST(VET, 0x0000FFFF, 0xFFFFFFFF);
0747 
0748     REG_PATTERN_TEST(RDTR, 0x0000FFFF, 0xFFFFFFFF);
0749     REG_PATTERN_TEST(RDBAH, 0xFFFFFFFF, 0xFFFFFFFF);
0750     REG_PATTERN_TEST(RDLEN, 0x000FFF80, 0x000FFFFF);
0751     REG_PATTERN_TEST(RDH, 0x0000FFFF, 0x0000FFFF);
0752     REG_PATTERN_TEST(RDT, 0x0000FFFF, 0x0000FFFF);
0753     REG_PATTERN_TEST(FCRTH, 0x0000FFF8, 0x0000FFF8);
0754     REG_PATTERN_TEST(FCTTV, 0x0000FFFF, 0x0000FFFF);
0755     REG_PATTERN_TEST(TIPG, 0x3FFFFFFF, 0x3FFFFFFF);
0756     REG_PATTERN_TEST(TDBAH, 0xFFFFFFFF, 0xFFFFFFFF);
0757     REG_PATTERN_TEST(TDLEN, 0x000FFF80, 0x000FFFFF);
0758 
0759     REG_SET_AND_CHECK(RCTL, 0xFFFFFFFF, 0x00000000);
0760 
0761     before = 0x06DFB3FE;
0762     REG_SET_AND_CHECK(RCTL, before, 0x003FFFFB);
0763     REG_SET_AND_CHECK(TCTL, 0xFFFFFFFF, 0x00000000);
0764 
0765     if (hw->mac_type >= e1000_82543) {
0766         REG_SET_AND_CHECK(RCTL, before, 0xFFFFFFFF);
0767         REG_PATTERN_TEST(RDBAL, 0xFFFFFFF0, 0xFFFFFFFF);
0768         REG_PATTERN_TEST(TXCW, 0xC000FFFF, 0x0000FFFF);
0769         REG_PATTERN_TEST(TDBAL, 0xFFFFFFF0, 0xFFFFFFFF);
0770         REG_PATTERN_TEST(TIDV, 0x0000FFFF, 0x0000FFFF);
0771         value = E1000_RAR_ENTRIES;
0772         for (i = 0; i < value; i++) {
0773             REG_PATTERN_TEST(RA + (((i << 1) + 1) << 2),
0774                      0x8003FFFF, 0xFFFFFFFF);
0775         }
0776     } else {
0777         REG_SET_AND_CHECK(RCTL, 0xFFFFFFFF, 0x01FFFFFF);
0778         REG_PATTERN_TEST(RDBAL, 0xFFFFF000, 0xFFFFFFFF);
0779         REG_PATTERN_TEST(TXCW, 0x0000FFFF, 0x0000FFFF);
0780         REG_PATTERN_TEST(TDBAL, 0xFFFFF000, 0xFFFFFFFF);
0781     }
0782 
0783     value = E1000_MC_TBL_SIZE;
0784     for (i = 0; i < value; i++)
0785         REG_PATTERN_TEST(MTA + (i << 2), 0xFFFFFFFF, 0xFFFFFFFF);
0786 
0787     *data = 0;
0788     return 0;
0789 }
0790 
0791 static int e1000_eeprom_test(struct e1000_adapter *adapter, u64 *data)
0792 {
0793     struct e1000_hw *hw = &adapter->hw;
0794     u16 temp;
0795     u16 checksum = 0;
0796     u16 i;
0797 
0798     *data = 0;
0799     /* Read and add up the contents of the EEPROM */
0800     for (i = 0; i < (EEPROM_CHECKSUM_REG + 1); i++) {
0801         if ((e1000_read_eeprom(hw, i, 1, &temp)) < 0) {
0802             *data = 1;
0803             break;
0804         }
0805         checksum += temp;
0806     }
0807 
0808     /* If Checksum is not Correct return error else test passed */
0809     if ((checksum != (u16)EEPROM_SUM) && !(*data))
0810         *data = 2;
0811 
0812     return *data;
0813 }
0814 
0815 static irqreturn_t e1000_test_intr(int irq, void *data)
0816 {
0817     struct net_device *netdev = (struct net_device *)data;
0818     struct e1000_adapter *adapter = netdev_priv(netdev);
0819     struct e1000_hw *hw = &adapter->hw;
0820 
0821     adapter->test_icr |= er32(ICR);
0822 
0823     return IRQ_HANDLED;
0824 }
0825 
0826 static int e1000_intr_test(struct e1000_adapter *adapter, u64 *data)
0827 {
0828     struct net_device *netdev = adapter->netdev;
0829     u32 mask, i = 0;
0830     bool shared_int = true;
0831     u32 irq = adapter->pdev->irq;
0832     struct e1000_hw *hw = &adapter->hw;
0833 
0834     *data = 0;
0835 
0836     /* NOTE: we don't test MSI interrupts here, yet
0837      * Hook up test interrupt handler just for this test
0838      */
0839     if (!request_irq(irq, e1000_test_intr, IRQF_PROBE_SHARED, netdev->name,
0840              netdev))
0841         shared_int = false;
0842     else if (request_irq(irq, e1000_test_intr, IRQF_SHARED,
0843                  netdev->name, netdev)) {
0844         *data = 1;
0845         return -1;
0846     }
0847     e_info(hw, "testing %s interrupt\n", (shared_int ?
0848            "shared" : "unshared"));
0849 
0850     /* Disable all the interrupts */
0851     ew32(IMC, 0xFFFFFFFF);
0852     E1000_WRITE_FLUSH();
0853     msleep(10);
0854 
0855     /* Test each interrupt */
0856     for (; i < 10; i++) {
0857         /* Interrupt to test */
0858         mask = 1 << i;
0859 
0860         if (!shared_int) {
0861             /* Disable the interrupt to be reported in
0862              * the cause register and then force the same
0863              * interrupt and see if one gets posted.  If
0864              * an interrupt was posted to the bus, the
0865              * test failed.
0866              */
0867             adapter->test_icr = 0;
0868             ew32(IMC, mask);
0869             ew32(ICS, mask);
0870             E1000_WRITE_FLUSH();
0871             msleep(10);
0872 
0873             if (adapter->test_icr & mask) {
0874                 *data = 3;
0875                 break;
0876             }
0877         }
0878 
0879         /* Enable the interrupt to be reported in
0880          * the cause register and then force the same
0881          * interrupt and see if one gets posted.  If
0882          * an interrupt was not posted to the bus, the
0883          * test failed.
0884          */
0885         adapter->test_icr = 0;
0886         ew32(IMS, mask);
0887         ew32(ICS, mask);
0888         E1000_WRITE_FLUSH();
0889         msleep(10);
0890 
0891         if (!(adapter->test_icr & mask)) {
0892             *data = 4;
0893             break;
0894         }
0895 
0896         if (!shared_int) {
0897             /* Disable the other interrupts to be reported in
0898              * the cause register and then force the other
0899              * interrupts and see if any get posted.  If
0900              * an interrupt was posted to the bus, the
0901              * test failed.
0902              */
0903             adapter->test_icr = 0;
0904             ew32(IMC, ~mask & 0x00007FFF);
0905             ew32(ICS, ~mask & 0x00007FFF);
0906             E1000_WRITE_FLUSH();
0907             msleep(10);
0908 
0909             if (adapter->test_icr) {
0910                 *data = 5;
0911                 break;
0912             }
0913         }
0914     }
0915 
0916     /* Disable all the interrupts */
0917     ew32(IMC, 0xFFFFFFFF);
0918     E1000_WRITE_FLUSH();
0919     msleep(10);
0920 
0921     /* Unhook test interrupt handler */
0922     free_irq(irq, netdev);
0923 
0924     return *data;
0925 }
0926 
0927 static void e1000_free_desc_rings(struct e1000_adapter *adapter)
0928 {
0929     struct e1000_tx_ring *txdr = &adapter->test_tx_ring;
0930     struct e1000_rx_ring *rxdr = &adapter->test_rx_ring;
0931     struct pci_dev *pdev = adapter->pdev;
0932     int i;
0933 
0934     if (txdr->desc && txdr->buffer_info) {
0935         for (i = 0; i < txdr->count; i++) {
0936             if (txdr->buffer_info[i].dma)
0937                 dma_unmap_single(&pdev->dev,
0938                          txdr->buffer_info[i].dma,
0939                          txdr->buffer_info[i].length,
0940                          DMA_TO_DEVICE);
0941             dev_kfree_skb(txdr->buffer_info[i].skb);
0942         }
0943     }
0944 
0945     if (rxdr->desc && rxdr->buffer_info) {
0946         for (i = 0; i < rxdr->count; i++) {
0947             if (rxdr->buffer_info[i].dma)
0948                 dma_unmap_single(&pdev->dev,
0949                          rxdr->buffer_info[i].dma,
0950                          E1000_RXBUFFER_2048,
0951                          DMA_FROM_DEVICE);
0952             kfree(rxdr->buffer_info[i].rxbuf.data);
0953         }
0954     }
0955 
0956     if (txdr->desc) {
0957         dma_free_coherent(&pdev->dev, txdr->size, txdr->desc,
0958                   txdr->dma);
0959         txdr->desc = NULL;
0960     }
0961     if (rxdr->desc) {
0962         dma_free_coherent(&pdev->dev, rxdr->size, rxdr->desc,
0963                   rxdr->dma);
0964         rxdr->desc = NULL;
0965     }
0966 
0967     kfree(txdr->buffer_info);
0968     txdr->buffer_info = NULL;
0969     kfree(rxdr->buffer_info);
0970     rxdr->buffer_info = NULL;
0971 }
0972 
0973 static int e1000_setup_desc_rings(struct e1000_adapter *adapter)
0974 {
0975     struct e1000_hw *hw = &adapter->hw;
0976     struct e1000_tx_ring *txdr = &adapter->test_tx_ring;
0977     struct e1000_rx_ring *rxdr = &adapter->test_rx_ring;
0978     struct pci_dev *pdev = adapter->pdev;
0979     u32 rctl;
0980     int i, ret_val;
0981 
0982     /* Setup Tx descriptor ring and Tx buffers */
0983 
0984     if (!txdr->count)
0985         txdr->count = E1000_DEFAULT_TXD;
0986 
0987     txdr->buffer_info = kcalloc(txdr->count, sizeof(struct e1000_tx_buffer),
0988                     GFP_KERNEL);
0989     if (!txdr->buffer_info) {
0990         ret_val = 1;
0991         goto err_nomem;
0992     }
0993 
0994     txdr->size = txdr->count * sizeof(struct e1000_tx_desc);
0995     txdr->size = ALIGN(txdr->size, 4096);
0996     txdr->desc = dma_alloc_coherent(&pdev->dev, txdr->size, &txdr->dma,
0997                     GFP_KERNEL);
0998     if (!txdr->desc) {
0999         ret_val = 2;
1000         goto err_nomem;
1001     }
1002     txdr->next_to_use = txdr->next_to_clean = 0;
1003 
1004     ew32(TDBAL, ((u64)txdr->dma & 0x00000000FFFFFFFF));
1005     ew32(TDBAH, ((u64)txdr->dma >> 32));
1006     ew32(TDLEN, txdr->count * sizeof(struct e1000_tx_desc));
1007     ew32(TDH, 0);
1008     ew32(TDT, 0);
1009     ew32(TCTL, E1000_TCTL_PSP | E1000_TCTL_EN |
1010          E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT |
1011          E1000_FDX_COLLISION_DISTANCE << E1000_COLD_SHIFT);
1012 
1013     for (i = 0; i < txdr->count; i++) {
1014         struct e1000_tx_desc *tx_desc = E1000_TX_DESC(*txdr, i);
1015         struct sk_buff *skb;
1016         unsigned int size = 1024;
1017 
1018         skb = alloc_skb(size, GFP_KERNEL);
1019         if (!skb) {
1020             ret_val = 3;
1021             goto err_nomem;
1022         }
1023         skb_put(skb, size);
1024         txdr->buffer_info[i].skb = skb;
1025         txdr->buffer_info[i].length = skb->len;
1026         txdr->buffer_info[i].dma =
1027             dma_map_single(&pdev->dev, skb->data, skb->len,
1028                        DMA_TO_DEVICE);
1029         if (dma_mapping_error(&pdev->dev, txdr->buffer_info[i].dma)) {
1030             ret_val = 4;
1031             goto err_nomem;
1032         }
1033         tx_desc->buffer_addr = cpu_to_le64(txdr->buffer_info[i].dma);
1034         tx_desc->lower.data = cpu_to_le32(skb->len);
1035         tx_desc->lower.data |= cpu_to_le32(E1000_TXD_CMD_EOP |
1036                            E1000_TXD_CMD_IFCS |
1037                            E1000_TXD_CMD_RPS);
1038         tx_desc->upper.data = 0;
1039     }
1040 
1041     /* Setup Rx descriptor ring and Rx buffers */
1042 
1043     if (!rxdr->count)
1044         rxdr->count = E1000_DEFAULT_RXD;
1045 
1046     rxdr->buffer_info = kcalloc(rxdr->count, sizeof(struct e1000_rx_buffer),
1047                     GFP_KERNEL);
1048     if (!rxdr->buffer_info) {
1049         ret_val = 5;
1050         goto err_nomem;
1051     }
1052 
1053     rxdr->size = rxdr->count * sizeof(struct e1000_rx_desc);
1054     rxdr->desc = dma_alloc_coherent(&pdev->dev, rxdr->size, &rxdr->dma,
1055                     GFP_KERNEL);
1056     if (!rxdr->desc) {
1057         ret_val = 6;
1058         goto err_nomem;
1059     }
1060     rxdr->next_to_use = rxdr->next_to_clean = 0;
1061 
1062     rctl = er32(RCTL);
1063     ew32(RCTL, rctl & ~E1000_RCTL_EN);
1064     ew32(RDBAL, ((u64)rxdr->dma & 0xFFFFFFFF));
1065     ew32(RDBAH, ((u64)rxdr->dma >> 32));
1066     ew32(RDLEN, rxdr->size);
1067     ew32(RDH, 0);
1068     ew32(RDT, 0);
1069     rctl = E1000_RCTL_EN | E1000_RCTL_BAM | E1000_RCTL_SZ_2048 |
1070         E1000_RCTL_LBM_NO | E1000_RCTL_RDMTS_HALF |
1071         (hw->mc_filter_type << E1000_RCTL_MO_SHIFT);
1072     ew32(RCTL, rctl);
1073 
1074     for (i = 0; i < rxdr->count; i++) {
1075         struct e1000_rx_desc *rx_desc = E1000_RX_DESC(*rxdr, i);
1076         u8 *buf;
1077 
1078         buf = kzalloc(E1000_RXBUFFER_2048 + NET_SKB_PAD + NET_IP_ALIGN,
1079                   GFP_KERNEL);
1080         if (!buf) {
1081             ret_val = 7;
1082             goto err_nomem;
1083         }
1084         rxdr->buffer_info[i].rxbuf.data = buf;
1085 
1086         rxdr->buffer_info[i].dma =
1087             dma_map_single(&pdev->dev,
1088                        buf + NET_SKB_PAD + NET_IP_ALIGN,
1089                        E1000_RXBUFFER_2048, DMA_FROM_DEVICE);
1090         if (dma_mapping_error(&pdev->dev, rxdr->buffer_info[i].dma)) {
1091             ret_val = 8;
1092             goto err_nomem;
1093         }
1094         rx_desc->buffer_addr = cpu_to_le64(rxdr->buffer_info[i].dma);
1095     }
1096 
1097     return 0;
1098 
1099 err_nomem:
1100     e1000_free_desc_rings(adapter);
1101     return ret_val;
1102 }
1103 
1104 static void e1000_phy_disable_receiver(struct e1000_adapter *adapter)
1105 {
1106     struct e1000_hw *hw = &adapter->hw;
1107 
1108     /* Write out to PHY registers 29 and 30 to disable the Receiver. */
1109     e1000_write_phy_reg(hw, 29, 0x001F);
1110     e1000_write_phy_reg(hw, 30, 0x8FFC);
1111     e1000_write_phy_reg(hw, 29, 0x001A);
1112     e1000_write_phy_reg(hw, 30, 0x8FF0);
1113 }
1114 
1115 static void e1000_phy_reset_clk_and_crs(struct e1000_adapter *adapter)
1116 {
1117     struct e1000_hw *hw = &adapter->hw;
1118     u16 phy_reg;
1119 
1120     /* Because we reset the PHY above, we need to re-force TX_CLK in the
1121      * Extended PHY Specific Control Register to 25MHz clock.  This
1122      * value defaults back to a 2.5MHz clock when the PHY is reset.
1123      */
1124     e1000_read_phy_reg(hw, M88E1000_EXT_PHY_SPEC_CTRL, &phy_reg);
1125     phy_reg |= M88E1000_EPSCR_TX_CLK_25;
1126     e1000_write_phy_reg(hw, M88E1000_EXT_PHY_SPEC_CTRL, phy_reg);
1127 
1128     /* In addition, because of the s/w reset above, we need to enable
1129      * CRS on TX.  This must be set for both full and half duplex
1130      * operation.
1131      */
1132     e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_reg);
1133     phy_reg |= M88E1000_PSCR_ASSERT_CRS_ON_TX;
1134     e1000_write_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_reg);
1135 }
1136 
1137 static int e1000_nonintegrated_phy_loopback(struct e1000_adapter *adapter)
1138 {
1139     struct e1000_hw *hw = &adapter->hw;
1140     u32 ctrl_reg;
1141     u16 phy_reg;
1142 
1143     /* Setup the Device Control Register for PHY loopback test. */
1144 
1145     ctrl_reg = er32(CTRL);
1146     ctrl_reg |= (E1000_CTRL_ILOS |      /* Invert Loss-Of-Signal */
1147              E1000_CTRL_FRCSPD |    /* Set the Force Speed Bit */
1148              E1000_CTRL_FRCDPX |    /* Set the Force Duplex Bit */
1149              E1000_CTRL_SPD_1000 |  /* Force Speed to 1000 */
1150              E1000_CTRL_FD);        /* Force Duplex to FULL */
1151 
1152     ew32(CTRL, ctrl_reg);
1153 
1154     /* Read the PHY Specific Control Register (0x10) */
1155     e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_reg);
1156 
1157     /* Clear Auto-Crossover bits in PHY Specific Control Register
1158      * (bits 6:5).
1159      */
1160     phy_reg &= ~M88E1000_PSCR_AUTO_X_MODE;
1161     e1000_write_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_reg);
1162 
1163     /* Perform software reset on the PHY */
1164     e1000_phy_reset(hw);
1165 
1166     /* Have to setup TX_CLK and TX_CRS after software reset */
1167     e1000_phy_reset_clk_and_crs(adapter);
1168 
1169     e1000_write_phy_reg(hw, PHY_CTRL, 0x8100);
1170 
1171     /* Wait for reset to complete. */
1172     udelay(500);
1173 
1174     /* Have to setup TX_CLK and TX_CRS after software reset */
1175     e1000_phy_reset_clk_and_crs(adapter);
1176 
1177     /* Write out to PHY registers 29 and 30 to disable the Receiver. */
1178     e1000_phy_disable_receiver(adapter);
1179 
1180     /* Set the loopback bit in the PHY control register. */
1181     e1000_read_phy_reg(hw, PHY_CTRL, &phy_reg);
1182     phy_reg |= MII_CR_LOOPBACK;
1183     e1000_write_phy_reg(hw, PHY_CTRL, phy_reg);
1184 
1185     /* Setup TX_CLK and TX_CRS one more time. */
1186     e1000_phy_reset_clk_and_crs(adapter);
1187 
1188     /* Check Phy Configuration */
1189     e1000_read_phy_reg(hw, PHY_CTRL, &phy_reg);
1190     if (phy_reg != 0x4100)
1191         return 9;
1192 
1193     e1000_read_phy_reg(hw, M88E1000_EXT_PHY_SPEC_CTRL, &phy_reg);
1194     if (phy_reg != 0x0070)
1195         return 10;
1196 
1197     e1000_read_phy_reg(hw, 29, &phy_reg);
1198     if (phy_reg != 0x001A)
1199         return 11;
1200 
1201     return 0;
1202 }
1203 
1204 static int e1000_integrated_phy_loopback(struct e1000_adapter *adapter)
1205 {
1206     struct e1000_hw *hw = &adapter->hw;
1207     u32 ctrl_reg = 0;
1208     u32 stat_reg = 0;
1209 
1210     hw->autoneg = false;
1211 
1212     if (hw->phy_type == e1000_phy_m88) {
1213         /* Auto-MDI/MDIX Off */
1214         e1000_write_phy_reg(hw,
1215                     M88E1000_PHY_SPEC_CTRL, 0x0808);
1216         /* reset to update Auto-MDI/MDIX */
1217         e1000_write_phy_reg(hw, PHY_CTRL, 0x9140);
1218         /* autoneg off */
1219         e1000_write_phy_reg(hw, PHY_CTRL, 0x8140);
1220     }
1221 
1222     ctrl_reg = er32(CTRL);
1223 
1224     /* force 1000, set loopback */
1225     e1000_write_phy_reg(hw, PHY_CTRL, 0x4140);
1226 
1227     /* Now set up the MAC to the same speed/duplex as the PHY. */
1228     ctrl_reg = er32(CTRL);
1229     ctrl_reg &= ~E1000_CTRL_SPD_SEL; /* Clear the speed sel bits */
1230     ctrl_reg |= (E1000_CTRL_FRCSPD | /* Set the Force Speed Bit */
1231             E1000_CTRL_FRCDPX | /* Set the Force Duplex Bit */
1232             E1000_CTRL_SPD_1000 |/* Force Speed to 1000 */
1233             E1000_CTRL_FD); /* Force Duplex to FULL */
1234 
1235     if (hw->media_type == e1000_media_type_copper &&
1236         hw->phy_type == e1000_phy_m88)
1237         ctrl_reg |= E1000_CTRL_ILOS; /* Invert Loss of Signal */
1238     else {
1239         /* Set the ILOS bit on the fiber Nic is half
1240          * duplex link is detected.
1241          */
1242         stat_reg = er32(STATUS);
1243         if ((stat_reg & E1000_STATUS_FD) == 0)
1244             ctrl_reg |= (E1000_CTRL_ILOS | E1000_CTRL_SLU);
1245     }
1246 
1247     ew32(CTRL, ctrl_reg);
1248 
1249     /* Disable the receiver on the PHY so when a cable is plugged in, the
1250      * PHY does not begin to autoneg when a cable is reconnected to the NIC.
1251      */
1252     if (hw->phy_type == e1000_phy_m88)
1253         e1000_phy_disable_receiver(adapter);
1254 
1255     udelay(500);
1256 
1257     return 0;
1258 }
1259 
1260 static int e1000_set_phy_loopback(struct e1000_adapter *adapter)
1261 {
1262     struct e1000_hw *hw = &adapter->hw;
1263     u16 phy_reg = 0;
1264     u16 count = 0;
1265 
1266     switch (hw->mac_type) {
1267     case e1000_82543:
1268         if (hw->media_type == e1000_media_type_copper) {
1269             /* Attempt to setup Loopback mode on Non-integrated PHY.
1270              * Some PHY registers get corrupted at random, so
1271              * attempt this 10 times.
1272              */
1273             while (e1000_nonintegrated_phy_loopback(adapter) &&
1274                    count++ < 10);
1275             if (count < 11)
1276                 return 0;
1277         }
1278         break;
1279 
1280     case e1000_82544:
1281     case e1000_82540:
1282     case e1000_82545:
1283     case e1000_82545_rev_3:
1284     case e1000_82546:
1285     case e1000_82546_rev_3:
1286     case e1000_82541:
1287     case e1000_82541_rev_2:
1288     case e1000_82547:
1289     case e1000_82547_rev_2:
1290         return e1000_integrated_phy_loopback(adapter);
1291     default:
1292         /* Default PHY loopback work is to read the MII
1293          * control register and assert bit 14 (loopback mode).
1294          */
1295         e1000_read_phy_reg(hw, PHY_CTRL, &phy_reg);
1296         phy_reg |= MII_CR_LOOPBACK;
1297         e1000_write_phy_reg(hw, PHY_CTRL, phy_reg);
1298         return 0;
1299     }
1300 
1301     return 8;
1302 }
1303 
1304 static int e1000_setup_loopback_test(struct e1000_adapter *adapter)
1305 {
1306     struct e1000_hw *hw = &adapter->hw;
1307     u32 rctl;
1308 
1309     if (hw->media_type == e1000_media_type_fiber ||
1310         hw->media_type == e1000_media_type_internal_serdes) {
1311         switch (hw->mac_type) {
1312         case e1000_82545:
1313         case e1000_82546:
1314         case e1000_82545_rev_3:
1315         case e1000_82546_rev_3:
1316             return e1000_set_phy_loopback(adapter);
1317         default:
1318             rctl = er32(RCTL);
1319             rctl |= E1000_RCTL_LBM_TCVR;
1320             ew32(RCTL, rctl);
1321             return 0;
1322         }
1323     } else if (hw->media_type == e1000_media_type_copper) {
1324         return e1000_set_phy_loopback(adapter);
1325     }
1326 
1327     return 7;
1328 }
1329 
1330 static void e1000_loopback_cleanup(struct e1000_adapter *adapter)
1331 {
1332     struct e1000_hw *hw = &adapter->hw;
1333     u32 rctl;
1334     u16 phy_reg;
1335 
1336     rctl = er32(RCTL);
1337     rctl &= ~(E1000_RCTL_LBM_TCVR | E1000_RCTL_LBM_MAC);
1338     ew32(RCTL, rctl);
1339 
1340     switch (hw->mac_type) {
1341     case e1000_82545:
1342     case e1000_82546:
1343     case e1000_82545_rev_3:
1344     case e1000_82546_rev_3:
1345     default:
1346         hw->autoneg = true;
1347         e1000_read_phy_reg(hw, PHY_CTRL, &phy_reg);
1348         if (phy_reg & MII_CR_LOOPBACK) {
1349             phy_reg &= ~MII_CR_LOOPBACK;
1350             e1000_write_phy_reg(hw, PHY_CTRL, phy_reg);
1351             e1000_phy_reset(hw);
1352         }
1353         break;
1354     }
1355 }
1356 
1357 static void e1000_create_lbtest_frame(struct sk_buff *skb,
1358                       unsigned int frame_size)
1359 {
1360     memset(skb->data, 0xFF, frame_size);
1361     frame_size &= ~1;
1362     memset(&skb->data[frame_size / 2], 0xAA, frame_size / 2 - 1);
1363     skb->data[frame_size / 2 + 10] = 0xBE;
1364     skb->data[frame_size / 2 + 12] = 0xAF;
1365 }
1366 
1367 static int e1000_check_lbtest_frame(const unsigned char *data,
1368                     unsigned int frame_size)
1369 {
1370     frame_size &= ~1;
1371     if (*(data + 3) == 0xFF) {
1372         if ((*(data + frame_size / 2 + 10) == 0xBE) &&
1373             (*(data + frame_size / 2 + 12) == 0xAF)) {
1374             return 0;
1375         }
1376     }
1377     return 13;
1378 }
1379 
1380 static int e1000_run_loopback_test(struct e1000_adapter *adapter)
1381 {
1382     struct e1000_hw *hw = &adapter->hw;
1383     struct e1000_tx_ring *txdr = &adapter->test_tx_ring;
1384     struct e1000_rx_ring *rxdr = &adapter->test_rx_ring;
1385     struct pci_dev *pdev = adapter->pdev;
1386     int i, j, k, l, lc, good_cnt, ret_val = 0;
1387     unsigned long time;
1388 
1389     ew32(RDT, rxdr->count - 1);
1390 
1391     /* Calculate the loop count based on the largest descriptor ring
1392      * The idea is to wrap the largest ring a number of times using 64
1393      * send/receive pairs during each loop
1394      */
1395 
1396     if (rxdr->count <= txdr->count)
1397         lc = ((txdr->count / 64) * 2) + 1;
1398     else
1399         lc = ((rxdr->count / 64) * 2) + 1;
1400 
1401     k = l = 0;
1402     for (j = 0; j <= lc; j++) { /* loop count loop */
1403         for (i = 0; i < 64; i++) { /* send the packets */
1404             e1000_create_lbtest_frame(txdr->buffer_info[i].skb,
1405                           1024);
1406             dma_sync_single_for_device(&pdev->dev,
1407                            txdr->buffer_info[k].dma,
1408                            txdr->buffer_info[k].length,
1409                            DMA_TO_DEVICE);
1410             if (unlikely(++k == txdr->count))
1411                 k = 0;
1412         }
1413         ew32(TDT, k);
1414         E1000_WRITE_FLUSH();
1415         msleep(200);
1416         time = jiffies; /* set the start time for the receive */
1417         good_cnt = 0;
1418         do { /* receive the sent packets */
1419             dma_sync_single_for_cpu(&pdev->dev,
1420                         rxdr->buffer_info[l].dma,
1421                         E1000_RXBUFFER_2048,
1422                         DMA_FROM_DEVICE);
1423 
1424             ret_val = e1000_check_lbtest_frame(
1425                     rxdr->buffer_info[l].rxbuf.data +
1426                     NET_SKB_PAD + NET_IP_ALIGN,
1427                     1024);
1428             if (!ret_val)
1429                 good_cnt++;
1430             if (unlikely(++l == rxdr->count))
1431                 l = 0;
1432             /* time + 20 msecs (200 msecs on 2.4) is more than
1433              * enough time to complete the receives, if it's
1434              * exceeded, break and error off
1435              */
1436         } while (good_cnt < 64 && time_after(time + 20, jiffies));
1437 
1438         if (good_cnt != 64) {
1439             ret_val = 13; /* ret_val is the same as mis-compare */
1440             break;
1441         }
1442         if (time_after_eq(jiffies, time + 2)) {
1443             ret_val = 14; /* error code for time out error */
1444             break;
1445         }
1446     } /* end loop count loop */
1447     return ret_val;
1448 }
1449 
1450 static int e1000_loopback_test(struct e1000_adapter *adapter, u64 *data)
1451 {
1452     *data = e1000_setup_desc_rings(adapter);
1453     if (*data)
1454         goto out;
1455     *data = e1000_setup_loopback_test(adapter);
1456     if (*data)
1457         goto err_loopback;
1458     *data = e1000_run_loopback_test(adapter);
1459     e1000_loopback_cleanup(adapter);
1460 
1461 err_loopback:
1462     e1000_free_desc_rings(adapter);
1463 out:
1464     return *data;
1465 }
1466 
1467 static int e1000_link_test(struct e1000_adapter *adapter, u64 *data)
1468 {
1469     struct e1000_hw *hw = &adapter->hw;
1470     *data = 0;
1471     if (hw->media_type == e1000_media_type_internal_serdes) {
1472         int i = 0;
1473 
1474         hw->serdes_has_link = false;
1475 
1476         /* On some blade server designs, link establishment
1477          * could take as long as 2-3 minutes
1478          */
1479         do {
1480             e1000_check_for_link(hw);
1481             if (hw->serdes_has_link)
1482                 return *data;
1483             msleep(20);
1484         } while (i++ < 3750);
1485 
1486         *data = 1;
1487     } else {
1488         e1000_check_for_link(hw);
1489         if (hw->autoneg)  /* if auto_neg is set wait for it */
1490             msleep(4000);
1491 
1492         if (!(er32(STATUS) & E1000_STATUS_LU))
1493             *data = 1;
1494     }
1495     return *data;
1496 }
1497 
1498 static int e1000_get_sset_count(struct net_device *netdev, int sset)
1499 {
1500     switch (sset) {
1501     case ETH_SS_TEST:
1502         return E1000_TEST_LEN;
1503     case ETH_SS_STATS:
1504         return E1000_STATS_LEN;
1505     default:
1506         return -EOPNOTSUPP;
1507     }
1508 }
1509 
1510 static void e1000_diag_test(struct net_device *netdev,
1511                 struct ethtool_test *eth_test, u64 *data)
1512 {
1513     struct e1000_adapter *adapter = netdev_priv(netdev);
1514     struct e1000_hw *hw = &adapter->hw;
1515     bool if_running = netif_running(netdev);
1516 
1517     set_bit(__E1000_TESTING, &adapter->flags);
1518     if (eth_test->flags == ETH_TEST_FL_OFFLINE) {
1519         /* Offline tests */
1520 
1521         /* save speed, duplex, autoneg settings */
1522         u16 autoneg_advertised = hw->autoneg_advertised;
1523         u8 forced_speed_duplex = hw->forced_speed_duplex;
1524         u8 autoneg = hw->autoneg;
1525 
1526         e_info(hw, "offline testing starting\n");
1527 
1528         /* Link test performed before hardware reset so autoneg doesn't
1529          * interfere with test result
1530          */
1531         if (e1000_link_test(adapter, &data[4]))
1532             eth_test->flags |= ETH_TEST_FL_FAILED;
1533 
1534         if (if_running)
1535             /* indicate we're in test mode */
1536             e1000_close(netdev);
1537         else
1538             e1000_reset(adapter);
1539 
1540         if (e1000_reg_test(adapter, &data[0]))
1541             eth_test->flags |= ETH_TEST_FL_FAILED;
1542 
1543         e1000_reset(adapter);
1544         if (e1000_eeprom_test(adapter, &data[1]))
1545             eth_test->flags |= ETH_TEST_FL_FAILED;
1546 
1547         e1000_reset(adapter);
1548         if (e1000_intr_test(adapter, &data[2]))
1549             eth_test->flags |= ETH_TEST_FL_FAILED;
1550 
1551         e1000_reset(adapter);
1552         /* make sure the phy is powered up */
1553         e1000_power_up_phy(adapter);
1554         if (e1000_loopback_test(adapter, &data[3]))
1555             eth_test->flags |= ETH_TEST_FL_FAILED;
1556 
1557         /* restore speed, duplex, autoneg settings */
1558         hw->autoneg_advertised = autoneg_advertised;
1559         hw->forced_speed_duplex = forced_speed_duplex;
1560         hw->autoneg = autoneg;
1561 
1562         e1000_reset(adapter);
1563         clear_bit(__E1000_TESTING, &adapter->flags);
1564         if (if_running)
1565             e1000_open(netdev);
1566     } else {
1567         e_info(hw, "online testing starting\n");
1568         /* Online tests */
1569         if (e1000_link_test(adapter, &data[4]))
1570             eth_test->flags |= ETH_TEST_FL_FAILED;
1571 
1572         /* Online tests aren't run; pass by default */
1573         data[0] = 0;
1574         data[1] = 0;
1575         data[2] = 0;
1576         data[3] = 0;
1577 
1578         clear_bit(__E1000_TESTING, &adapter->flags);
1579     }
1580     msleep_interruptible(4 * 1000);
1581 }
1582 
1583 static int e1000_wol_exclusion(struct e1000_adapter *adapter,
1584                    struct ethtool_wolinfo *wol)
1585 {
1586     struct e1000_hw *hw = &adapter->hw;
1587     int retval = 1; /* fail by default */
1588 
1589     switch (hw->device_id) {
1590     case E1000_DEV_ID_82542:
1591     case E1000_DEV_ID_82543GC_FIBER:
1592     case E1000_DEV_ID_82543GC_COPPER:
1593     case E1000_DEV_ID_82544EI_FIBER:
1594     case E1000_DEV_ID_82546EB_QUAD_COPPER:
1595     case E1000_DEV_ID_82545EM_FIBER:
1596     case E1000_DEV_ID_82545EM_COPPER:
1597     case E1000_DEV_ID_82546GB_QUAD_COPPER:
1598     case E1000_DEV_ID_82546GB_PCIE:
1599         /* these don't support WoL at all */
1600         wol->supported = 0;
1601         break;
1602     case E1000_DEV_ID_82546EB_FIBER:
1603     case E1000_DEV_ID_82546GB_FIBER:
1604         /* Wake events not supported on port B */
1605         if (er32(STATUS) & E1000_STATUS_FUNC_1) {
1606             wol->supported = 0;
1607             break;
1608         }
1609         /* return success for non excluded adapter ports */
1610         retval = 0;
1611         break;
1612     case E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3:
1613         /* quad port adapters only support WoL on port A */
1614         if (!adapter->quad_port_a) {
1615             wol->supported = 0;
1616             break;
1617         }
1618         /* return success for non excluded adapter ports */
1619         retval = 0;
1620         break;
1621     default:
1622         /* dual port cards only support WoL on port A from now on
1623          * unless it was enabled in the eeprom for port B
1624          * so exclude FUNC_1 ports from having WoL enabled
1625          */
1626         if (er32(STATUS) & E1000_STATUS_FUNC_1 &&
1627             !adapter->eeprom_wol) {
1628             wol->supported = 0;
1629             break;
1630         }
1631 
1632         retval = 0;
1633     }
1634 
1635     return retval;
1636 }
1637 
1638 static void e1000_get_wol(struct net_device *netdev,
1639               struct ethtool_wolinfo *wol)
1640 {
1641     struct e1000_adapter *adapter = netdev_priv(netdev);
1642     struct e1000_hw *hw = &adapter->hw;
1643 
1644     wol->supported = WAKE_UCAST | WAKE_MCAST | WAKE_BCAST | WAKE_MAGIC;
1645     wol->wolopts = 0;
1646 
1647     /* this function will set ->supported = 0 and return 1 if wol is not
1648      * supported by this hardware
1649      */
1650     if (e1000_wol_exclusion(adapter, wol) ||
1651         !device_can_wakeup(&adapter->pdev->dev))
1652         return;
1653 
1654     /* apply any specific unsupported masks here */
1655     switch (hw->device_id) {
1656     case E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3:
1657         /* KSP3 does not support UCAST wake-ups */
1658         wol->supported &= ~WAKE_UCAST;
1659 
1660         if (adapter->wol & E1000_WUFC_EX)
1661             e_err(drv, "Interface does not support directed "
1662                   "(unicast) frame wake-up packets\n");
1663         break;
1664     default:
1665         break;
1666     }
1667 
1668     if (adapter->wol & E1000_WUFC_EX)
1669         wol->wolopts |= WAKE_UCAST;
1670     if (adapter->wol & E1000_WUFC_MC)
1671         wol->wolopts |= WAKE_MCAST;
1672     if (adapter->wol & E1000_WUFC_BC)
1673         wol->wolopts |= WAKE_BCAST;
1674     if (adapter->wol & E1000_WUFC_MAG)
1675         wol->wolopts |= WAKE_MAGIC;
1676 }
1677 
1678 static int e1000_set_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)
1679 {
1680     struct e1000_adapter *adapter = netdev_priv(netdev);
1681     struct e1000_hw *hw = &adapter->hw;
1682 
1683     if (wol->wolopts & (WAKE_PHY | WAKE_ARP | WAKE_MAGICSECURE))
1684         return -EOPNOTSUPP;
1685 
1686     if (e1000_wol_exclusion(adapter, wol) ||
1687         !device_can_wakeup(&adapter->pdev->dev))
1688         return wol->wolopts ? -EOPNOTSUPP : 0;
1689 
1690     switch (hw->device_id) {
1691     case E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3:
1692         if (wol->wolopts & WAKE_UCAST) {
1693             e_err(drv, "Interface does not support directed "
1694                   "(unicast) frame wake-up packets\n");
1695             return -EOPNOTSUPP;
1696         }
1697         break;
1698     default:
1699         break;
1700     }
1701 
1702     /* these settings will always override what we currently have */
1703     adapter->wol = 0;
1704 
1705     if (wol->wolopts & WAKE_UCAST)
1706         adapter->wol |= E1000_WUFC_EX;
1707     if (wol->wolopts & WAKE_MCAST)
1708         adapter->wol |= E1000_WUFC_MC;
1709     if (wol->wolopts & WAKE_BCAST)
1710         adapter->wol |= E1000_WUFC_BC;
1711     if (wol->wolopts & WAKE_MAGIC)
1712         adapter->wol |= E1000_WUFC_MAG;
1713 
1714     device_set_wakeup_enable(&adapter->pdev->dev, adapter->wol);
1715 
1716     return 0;
1717 }
1718 
1719 static int e1000_set_phys_id(struct net_device *netdev,
1720                  enum ethtool_phys_id_state state)
1721 {
1722     struct e1000_adapter *adapter = netdev_priv(netdev);
1723     struct e1000_hw *hw = &adapter->hw;
1724 
1725     switch (state) {
1726     case ETHTOOL_ID_ACTIVE:
1727         e1000_setup_led(hw);
1728         return 2;
1729 
1730     case ETHTOOL_ID_ON:
1731         e1000_led_on(hw);
1732         break;
1733 
1734     case ETHTOOL_ID_OFF:
1735         e1000_led_off(hw);
1736         break;
1737 
1738     case ETHTOOL_ID_INACTIVE:
1739         e1000_cleanup_led(hw);
1740     }
1741 
1742     return 0;
1743 }
1744 
1745 static int e1000_get_coalesce(struct net_device *netdev,
1746                   struct ethtool_coalesce *ec,
1747                   struct kernel_ethtool_coalesce *kernel_coal,
1748                   struct netlink_ext_ack *extack)
1749 {
1750     struct e1000_adapter *adapter = netdev_priv(netdev);
1751 
1752     if (adapter->hw.mac_type < e1000_82545)
1753         return -EOPNOTSUPP;
1754 
1755     if (adapter->itr_setting <= 4)
1756         ec->rx_coalesce_usecs = adapter->itr_setting;
1757     else
1758         ec->rx_coalesce_usecs = 1000000 / adapter->itr_setting;
1759 
1760     return 0;
1761 }
1762 
1763 static int e1000_set_coalesce(struct net_device *netdev,
1764                   struct ethtool_coalesce *ec,
1765                   struct kernel_ethtool_coalesce *kernel_coal,
1766                   struct netlink_ext_ack *extack)
1767 {
1768     struct e1000_adapter *adapter = netdev_priv(netdev);
1769     struct e1000_hw *hw = &adapter->hw;
1770 
1771     if (hw->mac_type < e1000_82545)
1772         return -EOPNOTSUPP;
1773 
1774     if ((ec->rx_coalesce_usecs > E1000_MAX_ITR_USECS) ||
1775         ((ec->rx_coalesce_usecs > 4) &&
1776          (ec->rx_coalesce_usecs < E1000_MIN_ITR_USECS)) ||
1777         (ec->rx_coalesce_usecs == 2))
1778         return -EINVAL;
1779 
1780     if (ec->rx_coalesce_usecs == 4) {
1781         adapter->itr = adapter->itr_setting = 4;
1782     } else if (ec->rx_coalesce_usecs <= 3) {
1783         adapter->itr = 20000;
1784         adapter->itr_setting = ec->rx_coalesce_usecs;
1785     } else {
1786         adapter->itr = (1000000 / ec->rx_coalesce_usecs);
1787         adapter->itr_setting = adapter->itr & ~3;
1788     }
1789 
1790     if (adapter->itr_setting != 0)
1791         ew32(ITR, 1000000000 / (adapter->itr * 256));
1792     else
1793         ew32(ITR, 0);
1794 
1795     return 0;
1796 }
1797 
1798 static int e1000_nway_reset(struct net_device *netdev)
1799 {
1800     struct e1000_adapter *adapter = netdev_priv(netdev);
1801 
1802     if (netif_running(netdev))
1803         e1000_reinit_locked(adapter);
1804     return 0;
1805 }
1806 
1807 static void e1000_get_ethtool_stats(struct net_device *netdev,
1808                     struct ethtool_stats *stats, u64 *data)
1809 {
1810     struct e1000_adapter *adapter = netdev_priv(netdev);
1811     int i;
1812     const struct e1000_stats *stat = e1000_gstrings_stats;
1813 
1814     e1000_update_stats(adapter);
1815     for (i = 0; i < E1000_GLOBAL_STATS_LEN; i++, stat++) {
1816         char *p;
1817 
1818         switch (stat->type) {
1819         case NETDEV_STATS:
1820             p = (char *)netdev + stat->stat_offset;
1821             break;
1822         case E1000_STATS:
1823             p = (char *)adapter + stat->stat_offset;
1824             break;
1825         default:
1826             netdev_WARN_ONCE(netdev, "Invalid E1000 stat type: %u index %d\n",
1827                      stat->type, i);
1828             continue;
1829         }
1830 
1831         if (stat->sizeof_stat == sizeof(u64))
1832             data[i] = *(u64 *)p;
1833         else
1834             data[i] = *(u32 *)p;
1835     }
1836 /* BUG_ON(i != E1000_STATS_LEN); */
1837 }
1838 
1839 static void e1000_get_strings(struct net_device *netdev, u32 stringset,
1840                   u8 *data)
1841 {
1842     u8 *p = data;
1843     int i;
1844 
1845     switch (stringset) {
1846     case ETH_SS_TEST:
1847         memcpy(data, e1000_gstrings_test, sizeof(e1000_gstrings_test));
1848         break;
1849     case ETH_SS_STATS:
1850         for (i = 0; i < E1000_GLOBAL_STATS_LEN; i++) {
1851             memcpy(p, e1000_gstrings_stats[i].stat_string,
1852                    ETH_GSTRING_LEN);
1853             p += ETH_GSTRING_LEN;
1854         }
1855         /* BUG_ON(p - data != E1000_STATS_LEN * ETH_GSTRING_LEN); */
1856         break;
1857     }
1858 }
1859 
1860 static const struct ethtool_ops e1000_ethtool_ops = {
1861     .supported_coalesce_params = ETHTOOL_COALESCE_RX_USECS,
1862     .get_drvinfo        = e1000_get_drvinfo,
1863     .get_regs_len       = e1000_get_regs_len,
1864     .get_regs       = e1000_get_regs,
1865     .get_wol        = e1000_get_wol,
1866     .set_wol        = e1000_set_wol,
1867     .get_msglevel       = e1000_get_msglevel,
1868     .set_msglevel       = e1000_set_msglevel,
1869     .nway_reset     = e1000_nway_reset,
1870     .get_link       = e1000_get_link,
1871     .get_eeprom_len     = e1000_get_eeprom_len,
1872     .get_eeprom     = e1000_get_eeprom,
1873     .set_eeprom     = e1000_set_eeprom,
1874     .get_ringparam      = e1000_get_ringparam,
1875     .set_ringparam      = e1000_set_ringparam,
1876     .get_pauseparam     = e1000_get_pauseparam,
1877     .set_pauseparam     = e1000_set_pauseparam,
1878     .self_test      = e1000_diag_test,
1879     .get_strings        = e1000_get_strings,
1880     .set_phys_id        = e1000_set_phys_id,
1881     .get_ethtool_stats  = e1000_get_ethtool_stats,
1882     .get_sset_count     = e1000_get_sset_count,
1883     .get_coalesce       = e1000_get_coalesce,
1884     .set_coalesce       = e1000_set_coalesce,
1885     .get_ts_info        = ethtool_op_get_ts_info,
1886     .get_link_ksettings = e1000_get_link_ksettings,
1887     .set_link_ksettings = e1000_set_link_ksettings,
1888 };
1889 
1890 void e1000_set_ethtool_ops(struct net_device *netdev)
1891 {
1892     netdev->ethtool_ops = &e1000_ethtool_ops;
1893 }
[ 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!