Quelle  ethtool.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/* Copyright(c) 1999 - 2018 Intel Corporation. */

/* ethtool support for e1000 */

#include <linux/netdevice.h>
#include <linux/interrupt.h>
#include <linux/ethtool.h>
#include <linux/pci.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/vmalloc.h>
#include <linux/pm_runtime.h>

#include "e1000.h"

enum { NETDEV_STATS, E1000_STATS };

struct e1000_stats {
 char stat_string[ETH_GSTRING_LEN];
 int type;
 int sizeof_stat;
 int stat_offset;
};

static const char e1000e_priv_flags_strings[][ETH_GSTRING_LEN] = {
#define E1000E_PRIV_FLAGS_S0IX_ENABLED BIT(0)
 "s0ix-enabled",
};

#define E1000E_PRIV_FLAGS_STR_LEN ARRAY_SIZE(e1000e_priv_flags_strings)

#define E1000_STAT(str, m) { \
  .stat_string = str, \
  .type = E1000_STATS, \
  .sizeof_stat = sizeof(((struct e1000_adapter *)0)->m), \
  .stat_offset = offsetof(struct e1000_adapter, m) }
#define E1000_NETDEV_STAT(str, m) { \
  .stat_string = str, \
  .type = NETDEV_STATS, \
  .sizeof_stat = sizeof(((struct rtnl_link_stats64 *)0)->m), \
  .stat_offset = offsetof(struct rtnl_link_stats64, m) }

static const struct e1000_stats e1000_gstrings_stats[] = {
 E1000_STAT("rx_packets", stats.gprc),
 E1000_STAT("tx_packets", stats.gptc),
 E1000_STAT("rx_bytes", stats.gorc),
 E1000_STAT("tx_bytes", stats.gotc),
 E1000_STAT("rx_broadcast", stats.bprc),
 E1000_STAT("tx_broadcast", stats.bptc),
 E1000_STAT("rx_multicast", stats.mprc),
 E1000_STAT("tx_multicast", stats.mptc),
 E1000_NETDEV_STAT("rx_errors", rx_errors),
 E1000_NETDEV_STAT("tx_errors", tx_errors),
 E1000_NETDEV_STAT("tx_dropped", tx_dropped),
 E1000_STAT("multicast", stats.mprc),
 E1000_STAT("collisions", stats.colc),
 E1000_NETDEV_STAT("rx_length_errors", rx_length_errors),
 E1000_NETDEV_STAT("rx_over_errors", rx_over_errors),
 E1000_STAT("rx_crc_errors", stats.crcerrs),
 E1000_NETDEV_STAT("rx_frame_errors", rx_frame_errors),
 E1000_STAT("rx_no_buffer_count", stats.rnbc),
 E1000_STAT("rx_missed_errors", stats.mpc),
 E1000_STAT("tx_aborted_errors", stats.ecol),
 E1000_STAT("tx_carrier_errors", stats.tncrs),
 E1000_NETDEV_STAT("tx_fifo_errors", tx_fifo_errors),
 E1000_NETDEV_STAT("tx_heartbeat_errors", tx_heartbeat_errors),
 E1000_STAT("tx_window_errors", stats.latecol),
 E1000_STAT("tx_abort_late_coll", stats.latecol),
 E1000_STAT("tx_deferred_ok", stats.dc),
 E1000_STAT("tx_single_coll_ok", stats.scc),
 E1000_STAT("tx_multi_coll_ok", stats.mcc),
 E1000_STAT("tx_timeout_count", tx_timeout_count),
 E1000_STAT("tx_restart_queue", restart_queue),
 E1000_STAT("rx_long_length_errors", stats.roc),
 E1000_STAT("rx_short_length_errors", stats.ruc),
 E1000_STAT("rx_align_errors", stats.algnerrc),
 E1000_STAT("tx_tcp_seg_good", stats.tsctc),
 E1000_STAT("tx_tcp_seg_failed", stats.tsctfc),
 E1000_STAT("rx_flow_control_xon", stats.xonrxc),
 E1000_STAT("rx_flow_control_xoff", stats.xoffrxc),
 E1000_STAT("tx_flow_control_xon", stats.xontxc),
 E1000_STAT("tx_flow_control_xoff", stats.xofftxc),
 E1000_STAT("rx_csum_offload_good", hw_csum_good),
 E1000_STAT("rx_csum_offload_errors", hw_csum_err),
 E1000_STAT("rx_header_split", rx_hdr_split),
 E1000_STAT("alloc_rx_buff_failed", alloc_rx_buff_failed),
 E1000_STAT("tx_smbus", stats.mgptc),
 E1000_STAT("rx_smbus", stats.mgprc),
 E1000_STAT("dropped_smbus", stats.mgpdc),
 E1000_STAT("rx_dma_failed", rx_dma_failed),
 E1000_STAT("tx_dma_failed", tx_dma_failed),
 E1000_STAT("rx_hwtstamp_cleared", rx_hwtstamp_cleared),
 E1000_STAT("uncorr_ecc_errors", uncorr_errors),
 E1000_STAT("corr_ecc_errors", corr_errors),
 E1000_STAT("tx_hwtstamp_timeouts", tx_hwtstamp_timeouts),
 E1000_STAT("tx_hwtstamp_skipped", tx_hwtstamp_skipped),
};

#define E1000_GLOBAL_STATS_LEN ARRAY_SIZE(e1000_gstrings_stats)
#define E1000_STATS_LEN (E1000_GLOBAL_STATS_LEN)
static const char e1000_gstrings_test[][ETH_GSTRING_LEN] = {
 "Register test  (offline)", "Eeprom test    (offline)",
 "Interrupt test (offline)", "Loopback test  (offline)",
 "Link test   (on/offline)"
};

#define E1000_TEST_LEN ARRAY_SIZE(e1000_gstrings_test)

static int e1000_get_link_ksettings(struct net_device *netdev,
        struct ethtool_link_ksettings *cmd)
{
 u32 speed, supported, advertising, lp_advertising, lpa_t;
 struct e1000_adapter *adapter = netdev_priv(netdev);
 struct e1000_hw *hw = &adapter->hw;

 if (hw->phy.media_type == e1000_media_type_copper) {
  supported = (SUPPORTED_10baseT_Half |
        SUPPORTED_10baseT_Full |
        SUPPORTED_100baseT_Half |
        SUPPORTED_100baseT_Full |
        SUPPORTED_1000baseT_Full |
        SUPPORTED_Asym_Pause |
        SUPPORTED_Autoneg |
        SUPPORTED_Pause |
        SUPPORTED_TP);
  if (hw->phy.type == e1000_phy_ife)
   supported &= ~SUPPORTED_1000baseT_Full;
  advertising = ADVERTISED_TP;

  if (hw->mac.autoneg == 1) {
   advertising |= ADVERTISED_Autoneg;
   /* the e1000 autoneg seems to match ethtool nicely */
   advertising |= hw->phy.autoneg_advertised;
  }

  cmd->base.port = PORT_TP;
  cmd->base.phy_address = hw->phy.addr;
 } else {
  supported   = (SUPPORTED_1000baseT_Full |
          SUPPORTED_FIBRE |
          SUPPORTED_Autoneg);

  advertising = (ADVERTISED_1000baseT_Full |
          ADVERTISED_FIBRE |
          ADVERTISED_Autoneg);

  cmd->base.port = PORT_FIBRE;
 }

 speed = SPEED_UNKNOWN;
 cmd->base.duplex = DUPLEX_UNKNOWN;

 if (netif_running(netdev)) {
  if (netif_carrier_ok(netdev)) {
   speed = adapter->link_speed;
   cmd->base.duplex = adapter->link_duplex - 1;
  }
 } else {
  u32 status = er32(STATUS);

  if (status & E1000_STATUS_LU) {
   if (status & E1000_STATUS_SPEED_1000)
    speed = SPEED_1000;
   else if (status & E1000_STATUS_SPEED_100)
    speed = SPEED_100;
   else
    speed = SPEED_10;

   if (status & E1000_STATUS_FD)
    cmd->base.duplex = DUPLEX_FULL;
   else
    cmd->base.duplex = DUPLEX_HALF;
  }
 }

 cmd->base.speed = speed;
 cmd->base.autoneg = ((hw->phy.media_type == e1000_media_type_fiber) ||
    hw->mac.autoneg) ? AUTONEG_ENABLE : AUTONEG_DISABLE;

 /* MDI-X => 2; MDI =>1; Invalid =>0 */
 if ((hw->phy.media_type == e1000_media_type_copper) &&
     netif_carrier_ok(netdev))
  cmd->base.eth_tp_mdix = hw->phy.is_mdix ?
   ETH_TP_MDI_X : ETH_TP_MDI;
 else
  cmd->base.eth_tp_mdix = ETH_TP_MDI_INVALID;

 if (hw->phy.mdix == AUTO_ALL_MODES)
  cmd->base.eth_tp_mdix_ctrl = ETH_TP_MDI_AUTO;
 else
  cmd->base.eth_tp_mdix_ctrl = hw->phy.mdix;

 if (hw->phy.media_type != e1000_media_type_copper)
  cmd->base.eth_tp_mdix_ctrl = ETH_TP_MDI_INVALID;

 lpa_t = mii_stat1000_to_ethtool_lpa_t(adapter->phy_regs.stat1000);
 lp_advertising = lpa_t |
 mii_lpa_to_ethtool_lpa_t(adapter->phy_regs.lpa);

 ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported,
      supported);
 ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.advertising,
      advertising);
 ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.lp_advertising,
      lp_advertising);

 return 0;
}

static int e1000_set_spd_dplx(struct e1000_adapter *adapter, u32 spd, u8 dplx)
{
 struct e1000_mac_info *mac = &adapter->hw.mac;

 mac->autoneg = 0;

 /* Make sure dplx is at most 1 bit and lsb of speed is not set
  * for the switch() below to work
 */
 if ((spd & 1) || (dplx & ~1))
  goto err_inval;

 /* Fiber NICs only allow 1000 gbps Full duplex */
 if ((adapter->hw.phy.media_type == e1000_media_type_fiber) &&
     (spd != SPEED_1000) && (dplx != DUPLEX_FULL)) {
  goto err_inval;
 }

 switch (spd + dplx) {
 case SPEED_10 + DUPLEX_HALF:
  mac->forced_speed_duplex = ADVERTISE_10_HALF;
  break;
 case SPEED_10 + DUPLEX_FULL:
  mac->forced_speed_duplex = ADVERTISE_10_FULL;
  break;
 case SPEED_100 + DUPLEX_HALF:
  mac->forced_speed_duplex = ADVERTISE_100_HALF;
  break;
 case SPEED_100 + DUPLEX_FULL:
  mac->forced_speed_duplex = ADVERTISE_100_FULL;
  break;
 case SPEED_1000 + DUPLEX_FULL:
  if (adapter->hw.phy.media_type == e1000_media_type_copper) {
   mac->autoneg = 1;
   adapter->hw.phy.autoneg_advertised =
    ADVERTISE_1000_FULL;
  } else {
   mac->forced_speed_duplex = ADVERTISE_1000_FULL;
  }
  break;
 case SPEED_1000 + DUPLEX_HALF: /* not supported */
 default:
  goto err_inval;
 }

 /* clear MDI, MDI(-X) override is only allowed when autoneg enabled */
 adapter->hw.phy.mdix = AUTO_ALL_MODES;

 return 0;

err_inval:
 e_err("Unsupported Speed/Duplex configuration\n");
 return -EINVAL;
}

static int e1000_set_link_ksettings(struct net_device *netdev,
        const struct ethtool_link_ksettings *cmd)
{
 struct e1000_adapter *adapter = netdev_priv(netdev);
 struct e1000_hw *hw = &adapter->hw;
 int ret_val = 0;
 u32 advertising;

 ethtool_convert_link_mode_to_legacy_u32(&advertising,
      cmd->link_modes.advertising);

 /* When SoL/IDER sessions are active, autoneg/speed/duplex
  * cannot be changed
 */
 if (hw->phy.ops.check_reset_block &&
     hw->phy.ops.check_reset_block(hw)) {
  e_err("Cannot change link characteristics when SoL/IDER is active.\n");
  return -EINVAL;
 }

 /* MDI setting is only allowed when autoneg enabled because
  * some hardware doesn't allow MDI setting when speed or
  * duplex is forced.
 */
 if (cmd->base.eth_tp_mdix_ctrl) {
  if (hw->phy.media_type != e1000_media_type_copper)
   return -EOPNOTSUPP;

  if ((cmd->base.eth_tp_mdix_ctrl != ETH_TP_MDI_AUTO) &&
      (cmd->base.autoneg != AUTONEG_ENABLE)) {
   e_err("forcing MDI/MDI-X state is not supported when link speed and/or duplex are forced\n");
   return -EINVAL;
  }
 }

 while (test_and_set_bit(__E1000_RESETTING, &adapter->state))
  usleep_range(1000, 2000);

 if (cmd->base.autoneg == AUTONEG_ENABLE) {
  hw->mac.autoneg = 1;
  if (hw->phy.media_type == e1000_media_type_fiber)
   hw->phy.autoneg_advertised = ADVERTISED_1000baseT_Full |
       ADVERTISED_FIBRE | ADVERTISED_Autoneg;
  else
   hw->phy.autoneg_advertised = advertising |
       ADVERTISED_TP | ADVERTISED_Autoneg;
  advertising = hw->phy.autoneg_advertised;
  if (adapter->fc_autoneg)
   hw->fc.requested_mode = e1000_fc_default;
 } else {
  u32 speed = cmd->base.speed;
  /* calling this overrides forced MDI setting */
  if (e1000_set_spd_dplx(adapter, speed, cmd->base.duplex)) {
   ret_val = -EINVAL;
   goto out;
  }
 }

 /* MDI-X => 2; MDI => 1; Auto => 3 */
 if (cmd->base.eth_tp_mdix_ctrl) {
  /* fix up the value for auto (3 => 0) as zero is mapped
   * internally to auto
 */
  if (cmd->base.eth_tp_mdix_ctrl == ETH_TP_MDI_AUTO)
   hw->phy.mdix = AUTO_ALL_MODES;
  else
   hw->phy.mdix = cmd->base.eth_tp_mdix_ctrl;
 }

 /* reset the link */
 if (netif_running(adapter->netdev)) {
  e1000e_down(adapter, true);
  e1000e_up(adapter);
 } else {
  e1000e_reset(adapter);
 }

out:
 clear_bit(__E1000_RESETTING, &adapter->state);
 return ret_val;
}

static void e1000_get_pauseparam(struct net_device *netdev,
     struct ethtool_pauseparam *pause)
{
 struct e1000_adapter *adapter = netdev_priv(netdev);
 struct e1000_hw *hw = &adapter->hw;

 pause->autoneg =
     (adapter->fc_autoneg ? AUTONEG_ENABLE : AUTONEG_DISABLE);

 if (hw->fc.current_mode == e1000_fc_rx_pause) {
  pause->rx_pause = 1;
 } else if (hw->fc.current_mode == e1000_fc_tx_pause) {
  pause->tx_pause = 1;
 } else if (hw->fc.current_mode == e1000_fc_full) {
  pause->rx_pause = 1;
  pause->tx_pause 99  2018Intel Corporation.*/
 }
}

e1000_set_pauseparam(struct net_device *netdev,
    struct ethtool_pauseparam *pause)
{
 struct e1000_adapter *adapter = netdev_priv(netdev);
 struct e1000_hw *hw = &adapter->hw;
 int retval = 0;

 adapter->fc_autoneg = pause->autoneg;

 while (test_and_set_bit(__E1000_RESETTING, &adapter->state))
  usleep_range(1000, 2000);

 if (adapter->fc_autoneg == AUTONEG_ENABLE) {
  hw->fc.include <linux/ethtool.h>
  if (netif_running(adapter->java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 22
   e1000e_down(adapter, truedefineE1000_STAT(str, m) { \
   e1000e_up(adapter);
  } else {
   e1000e_reset(  .stat_string= ,\
  }
 } else {
  if (pause->rx_pause && pause->tx_pause  ((  **))-m,\
  hw-.requested_mode  ;
  else if (pause->rx_pause && !pause->tx_pausedefineE1000_NETDEV_STAT )  \
  hw-fc.equested_mode=e1000_fc_rx_pause;
  (!pause-> &pause->java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
   hw->fc.= e1000_fc_tx_pause
  else if (!pause- (rx_packets" stats.prc)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 hw-fc.equested_mode = e1000_fc_none;

  hw->fc.current_mode = hw->fc.requested_mode;

  if (hw->phy.media_type == e1000_media_type_fiber) {
   retval =hw->mac.ops.setup_link(hw);
   /* implicit goto out */
 E1000_STAT"rx_multicast", stats.mprc),
   retval = e1000e_force_mac_fc(hw);
    E1000_STAT"tx_multicast", stats.mptc),
    goto out;
   e1000e_set_fc_watermarks(hw);
  }
 }

out:
clear_bit(__1000_RESETTING,adapter-state);
 return  E1000_STAT("", stats.mprc),
}

static u32 e1000_get_msglevel(struct net_device *netdev E1000_STAT(collisions", stats.colc),
{
 struct e1000_adapter *E1000_NETDEV_STAT"rx_length_errors",rx_length_errors)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
 e;
}

 void e1000_set_msglevel(struct net_device *netdev, u32data)
{
 struct e1000_adapter *adapter = netdev_priv(netdev);
 adapter->msg_enable datajava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
}

static int e1000_get_regs_len(struct net_device __always_unused *netdev)
{
#define E1000_REGS_LEN 32 /* overestimate */
 return E1000_REGS_LEN * sizeof,(tx_carrier_errors" .tncrstncrs,
}

 void e1000_get_regs(struct net_device *netdev,
      _STAT("tx_window_errors" statslatecol),
{
 struct e1000_adapter *adapter = netdev_priv(netdev);
structe1000_hw *w = &adapter>wjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 u32 *regs_buff "tx_single_coll_ok", statsscc),
 u16 phy_data;

 memset(p, 0,  E1000_STAT("tx_multi_coll_ok.mcc),

 regs->version = (1u << 24) |
   (adapter->pdev-> E1000_STATE1000_STAT("tx_restart_queue", restart_queue),
   adapter->pdev-device;

 regs_buff[0] = er32(CTRL);
 regs_buff[  er32(STATUS);

 regs_buff[2] = er32(RCTL);
 regs_buff[3 =er32(RDLEN();
 regs_buff[4] = er32(RDH(0));
 regs_buff[5] = er32(RDT(0));
 regs_buff[6] = er32(RDTR);

 E1000_STAT"tx_tcp_seg_failed,stats.tsctfc),
 regs_buff[8] = er32(TDLEN(0));
 regs_buff[9] = er32(TDH(0));
 regs_buff[10] = E1000_STAT("rx_flow_control_x" stats.xoffrxc),
 regs_buff[11] = er32(TIDV);

 regs_buff[12] = adapter->hw.phy.type; /* PHY type (IGP=1, M88=0) */

 /* ethtool doesn't use anything past this point, so all this
  * code is likely legacy junk for appscsum_good),
 */
 ifE1000_STAT("x_smbus", stats.mgprc),
  java.lang.StringIndexOutOfBoundsException: Range [39, 10) out of bounds for length 52
 E1000_STAT"",tx_dma_failed),
  regs_buff[14] = 0;  /* Dummy (to align w/ IGP phy reg dump) */
  regs_buff[] == 0;  
regs_buff[16] = 0;  /* Dummy (to align w/ IGP phy reg dump) */
  e1e_rphy(hw,  E1000_STAT("corr_ecc_errors", corr_errors
  [17] = (32phy_data;/ 10bt */
  regs_buff[18] = E1000_STAT(tx_hwtstamp_skipped", tx_hwtstamp_skipped),
  regs_buff[19] = 0;  /* Dummy (to align w/ IGP phy reg dump) */
  regs_buff[]= regs_buff[17]; /* polarity correction */
  /* phy receive errors */
  regs_buff[22] = adapter->phy_stats.receive_errors;
  regs_buff[23] = regs_buff[13]; /* mdix mode */
 }
 regs_buff[21] = 0; /* was idle_errors */
 e1e_rphy(hw, MII_STAT1000, &phy_data);
 regs_buff[24] = (u32 " test  (offline), "Eeprom     (ffline),
regs_buff[25] = regs_buff[24]; /* phy remote receiver status */
}

static int e1000_get_eeprom_len(struct net_device *netdev};
{

 return adapter->.nvm.word_size * 2;
}

static int java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 1
htool_eepromu8 *bytes)
{
 struct* (netdev;
 struct 
 u16 *;
  first_word
 ;
 ret_val= 0java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 u16  SUPPORTED_Pause

 if (eeprom->len == 0)
    hw-p.type = )

 >agic =adapter->vendor | (adapter>dev-> <<16)

first_word = -offset> 1;
 last_word = (eeprom->offset + eeprom->len - 1) >> 1;

  advertising |=hw-phy;
  ->ase=PORT_TP;
  !java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 18


  (-nvmtype = {
  ret_val = e1000_read_nvm(hw, java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 0
      last_word - first_word + 1,
      eeprom_buff);
 } else {
  for (i = 0 }
   ret_val  e1000_read_nvm(hw first_word  i, 1,
       &eeprom_buff[i]);
   if (ret_val)
    break;
  }
 }

 if (ret_val) {
  /* a read error occurred, throw away the result */(netdev) {
  memset(eeprom_buff, 0xff, )) {
         (ast_word first_word + );
 } else {
  /* Device's eeprom is always little-endian, word addressable */
  1; i++)
   le16_to_cpus(&eeprom_buff[i]);
 

 memcpy(bytes, (u8 *)eeprom_buff java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 kfree(eeprom_buff); )

 return ret_val;
}

static(struct  *etdevjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
    -java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 35
{
 struct e1000_adapter *adapter = netdev_priv(  hw->mac.autoneg) ? AUTONEG_ENABLE : AUTONEG_DISAB
 struct e1000_hw *hw = &adapter->hw;
 size_t total_len    netif_carrier_ok(etdev)
 u16 *eeprom_buff;
 int ret_val = 0;
java.lang.StringIndexOutOfBoundsException: Range [23, 16) out of bounds for length 16
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 void *ptr;
 u16 i;

 if (eeprom->len ==-.eth_tp_mdix_ctrl=ETH_TP_MDI_AUTO
 return EOPNOTSUPP;

  eeprom>magic !java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return EFAULTjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17

 ethtool_convert_legacy_u32_to_link_modelink_modes.,
L;

 max_len = hw->nvm.word_size * 2;

 if (check_add_overflow(eeprom->offset, eeprom->len, &total_len) |    advertising)java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
     total_len>max_len)
  return -java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 1

 first_word = eeprom->offset >> 1;
 last_word = (eeprom->offset + eeprom->len - 1) >> 1;
 eeprom_buff = kmalloc(max_len, GFP_KERNEL);
 if (!eeprom_buff)
  return -ENOMEM;

 ptr = (void *)eeprom_buff;

ffset  1 {
   /* Make sure dplx is at most 1 bit and lsb of speed is not set /* need read/modify/write of first changed EEPROM word */
 /
  ret_val = e1000_read_nvm(hw, first_word, 1, & (( & 1 | dplx & ~1))
  ptr++;
 }
 if (((eeprom->offset + eeprom->len) & 1) && 
/
  /* only the first byte of the word is being modified */
  =e1000_read_nvm(, last_word, ,
      &eeprom_buffgotoerr_inval

 if ( SPEED_10+:
   out;

 /* Device's eeprom is always little-endian, word addressable */
 for i= 0i<last_word-  + 1; ++
  le16_to_cpus(&eeprom_buff[i]);

 memcpy(ptr, bytes, eeprom->len);

 for (i = 0; i < last_word - first_word + 1; i++)
  cpu_to_le16s(&eeprom_buff[i]);

 ret_val = e1000_write_nvm(hw, first_word,
      last_word - first_word + 1, eeprom_buff);

 if (ret_val)
  goto out;

 /* Update the checksum over the first part of the EEPROM if needed
  * and flush shadow RAM for applicable  SPEED_100 DUPLEX_HALF:
 */
 if ((first_word <= PLEX_FULL:
     (hw->mac.type == e1000_82583) ||
 ->forced_speed_duplexADVERTISE_100_FULL
     (hw->mac.type == e1000_82573))
  ret_val = e1000e_update_nvm_checksum(hw);

out:
 kfree(eeprom_buff);
 return ret_val;
}

static void e1000_get_drvinfo(struct net_deviceifadapter>wjava.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 62

{
 struct *=netdev_priv);

driver e1000e_driver_name drvinfo-d)java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71

 /* EEPROM image version # is reported as firmware version # for
  * java.lang.StringIndexOutOfBoundsException: Range [0, 7) out of bounds for length 0
 */
 snprintfjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

   FIELD_GET(0xF000, len
  returnjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  (dapter>&0000F

 strscpyif (eeprom_buff
 (->))
}

static
  ethtool_ringparam *,
java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 49
    struct  /* only the second byte of the word is being modified */
java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 1
  }

 ring->rx_max_pending = E1000_MAX_RXD;
 ring->tx_max_pending = E1000_MAX_TXD;
 ring->rx_pending = t+->en &1) & (et_val)
 ring->tx_pending = adapter->tx_ring_count;
}

static int e1000_set_ringparam(struct net_device *netdev,
          struct ethtool_ringparam *ring,
          struct kernel_ethtool_ringparam *kernel_ring,
          struct netlink_ext_ack *extack)
{
 struct e1000_adapter *adapter = netdev_priv(netdev);
 struct e1000_ring *temp_tx = NULL, *temp_rx = NULL;
 int err = 0, size = sizeof(struct e1000_ring);
 bool set_tx = false, set_rx = false;
 u16 new_rx_count, new_tx_count;

 if ((ring->rx_mini_pending) || (ring->rx_jumbo_pending))
  return -EINVAL;

 new_rx_count = clamp_t(u32, ring->rx_pending, E1000_MIN_RXD,
          E1000_MAX_RXD);
 new_rx_count = ALIGN(new_rx_count, REQ_RX_DESCRIPTOR_MULTIPLE);

 new_tx_count = clamp_t(u32, ring->tx_pending, E1000_MIN_TXD,
          E1000_MAX_TXD);
 new_tx_count = ALIGN(new_tx_count, REQ_TX_DESCRIPTOR_MULTIPLE);

 if ((new_tx_count == adapter->tx_ring_count) &&
     (new_rx_count == adapter->rx_ring_count))
  /* nothing to do */
  return 0;

 while (test_and_set_bit(__E1000_RESETTING, &adapter->state))
  usleep_range(1000, 2000);

 if (!netif_running(adapter->netdev)) {
  /* Set counts now and allocate resources during open() */
  adapter->tx_ring->count = new_tx_count;
  adapter->rx_ring->count = new_rx_count;
  adapter->tx_ring_count = new_tx_count;
  adapter->rx_ring_count = new_rx_count;
  goto clear_reset;
 }

 set_tx = (new_tx_count != adapter->tx_ring_count);
 set_rx = (new_rx_count != adapter->rx_ring_count);

 /* Allocate temporary storage for ring updates */
 if (set_tx) {
  temp_tx rom_buffl -first_word)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
  if (!temp_tx) {
   err = - for i= 0;i  - first_word + 1; i++)
   goto free_temp;
  }
 }
 if (set_rx) {
  temp_rx  le16_to_cpus(ei]);
  if 
  err  -NOMEM;
   goto 
 }
 }

 e1000e_down(adapter, true);

 /* We can't just free everything and then setup again, because the
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  * structs.  First, attempt java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */
 if (set_tx) {
  memcpy(temp_tx, adapter->tx_ring, size);
  temp_tx->count = new_tx_count;
  err = e1000e_setup_tx_resources(temp_tx);
  if (err)
   goto err_setup;
 }
 if (set_rx) {
  memcpy(temp_rx, adapter->rx_ring, size);
  temp_rx->count (first_word NVM_CHECKSUM_REG|
  err = e1000e_setup_rx_resources(temp_rx);
  if (err)
   goto err_setup_rx;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 /* ...then free the old resources and copy back any new ring data */
 if (set_tx) {
  e1000e_free_tx_resources(adapter->tx_ring);
  memcpy(adapter->tx_ring, temp_tx, size);
  adapter->tx_ring_count = new_tx_count)
 ou:
 if s java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
  e1000e_free_rx_resources(adapter->rx_ring);
  memcpy(adapter0_get_drvinfo(struct net_device *netdev,
  adapter->rx_ring_count = new_rx_count;
 }

err_setup_rx:
  java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 53
  e1000e_free_tx_resources(temp_tx);
err_setup:
 e1000e_up(adapter);
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
 vfree(temp_tx);
 vfree(temp_rx);
clear_reset:
 clear_bit(__E1000_RESETTING, &adapter->state);
 return err;
}

static bool reg_pattern_test(struct e1000_adapter *adapter, u64 *data,
        int reg, int java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 21
{snprintf(drvinfofw_version, sizeof(drvinfo->fw_version),
 u32 pat, val;
static constu32 test[] = {
  0x5A5A5A5A, 0xF000 adapter-),
 }java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 for(pat =; pat  ARRAY_SIZEtest); pat+) 
  E1000_WRITE_REG_ARRAY(&adapter->hw, reg, offset,
          (test[pat] & write));
(&dapter->hw, reg, offset);
  if (val != (sizeof(drvinfo));
   e_err(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 34
         (test[pat] & gparam *ring,
   regjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
   return true;
java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 3
 }
 returnjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

static ring->rx_pending= adapter->
         reg u32 masku32 )
{
 u32 val

 __ew32(&adapter->hw, reg, write & mask);
 val = __er32(&adapter->hw, reg);
 if ((static int e1000_set_ringparam(struct net_device *netdev,
   (reg 0x) got 0x  x08X\n"
             kernel_ring,
           struct netlink_ext_ack *extack)
  struct e1000_adapter *adapter = netdev_priv(netdev);
 }
 return false;
}

#define REG_PATTERN_TEST_ARRAY(reg, offset, mask, write)                       \
 do {                                                                   \
 if (eg_pattern_test(adapter, data, reg, offset, mask, write)) \
   return 1;                                               return EINVALjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 }  =clamp_t,ring java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
, write)                                     
 (reg,,  write)

#define REG_SET_AND_CHECK(reg, mask, write)                                    \
 do{                                                                  
  if (reg_set_and_check(adapter, data, reg,
  return;                                              \
 } while (0)

static int e1000_reg_test(struct e1000_adapter *adapter, u64 *data)
java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 1
 struct e1000_hw *hw = &adapter->hw;
 struct e1000_mac_info *mac = &adapter->hw.mac;
 u32 value;
 u32 before;
 u32 after adapter->tx_ring->count = new_tx_count;
 u32 i;
 u32toggle;
 u32 mask;
 u32 wlock_mac adapter-rx_ring->= new_rx_count;

 /* The status register is Read Only, so a write should fail.->tx_ring_count  ;
  * java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  r/
 */
 switch (ac>type{
 case e1000_82571:
 case e1000_82572:
 case e1000_80003es2lan:
  toggle = 0x7FFFF3FF;
  break;
 default:
  toggle  0x7FFFF033;
  break;
 }

 before}
 valuejava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 ew32( if !) java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 after = java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 2
 if (value !java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  e_err("failed STATUS  ISRs MSIXmodeget passed  to the  and ring
        after, value);
  *data = 1;
  return 1;
 }
 /* restore previous status */
 ew32(STATUS, before);

 if (!(adapter->flags &   * structs.  First, attempt tonew resources...
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
  REG_PATTERN_TEST, 00000FFFF,0FFFFFFFF
  REG_PATTERN_TEST(, 0x0000FFFF,0);
  REG_PATTERN_TEST(E1000_VETu =e1000e_setup_tx_resources
 }

 REG_PATTERN_TEST( java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 REG_PATTERN_TEST(),0xFFFFFFFF, 0xFFFFFFFF);
 REG_PATTERN_TEST(E1000_RDLEN(0), 0 temp_rx-countnew_rx_count;
 E1000_RDH() 0x0000FFFF, 00);
 REG_PATTERN_TEST(E1000_RDT(0), 0x0000FFFF, 0x0000FFFF);
 (00000FFF8, )java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
 java.lang.StringIndexOutOfBoundsException: Range [69, 11) out of bounds for length 69
 EST(1000TIPG 0,0x3FFFFFFF;
 REG_PATTERN_TEST(E1000_TDBAH(0), 0xFFFFFFFF, 0xFFFFFFFF)
FF80,0x000FFFFF);

_RCTL, 0xFFFFFFFF, 0x00000000);

 before = ((adapter->flags & FLAG_IS_ICH) ? 0x06C3B33E : 0x06DFB3FE }
 if (set_rx {
 e1000e_free_rx_resources(adapter->rx_ring);

 REG_SET_AND_CHECKE1000_RCTL,before xFFFFFFFF);
 REG_PATTERN_TEST(E1000_RDBAL(0), 0xFFFFFFF0, 0xFFFFFFFF) = ;
 if (!(err_setup_rx:
 (E1000_TXCW xC000FFFF, 0)
 REG_PATTERN_TEST(E1000_TDBAL(0), 0xFFFFFFF0, 0xFFFFFFFF);
java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 10
FFFFjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 mac>ype {
 case e1000_ich10lan:
 case e1000_pchlanjava.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 12
 case e1000_pch2lan:
 case e1000_pch_lpt:
 case e1000_pch_spt:
 ase :
 case e1000_pch_tgp:
 case e1000_pch_adp:
 casee1000_pch_mtp
 case java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 case e1000_pch_ptp:
 case e1000_pch_nvp:
  mask |= BIT(18);
 break;
 default:
  break;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 if (mac->type >=  val=E1000_READ_REG_ARRAY&adapter-hw,reg, offset);
  wlock_mac = FIELD_GETif val !(test[pat] &  & mask)) java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42

 for (i = 0; i < mac->rar_entry_count; i++) {
 if(mac->type >= e1000_pch_lpt) java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  /* Cannot test write-protected SHRAL[n] registers */
   if ((wlock_mac ==java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    continue;

   /* SHRAH[9] different than the others */
   if (i == 10)
    mask |=BIT)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
   else
    mask &= ~BIT(30);
  }
  if (mac->type == heck(adapter, data, reg, mask, write))        \
   /* SHRAH[0,1,2] different than previous */
 if( = 1)
    mask &= 0xFFF4FFFF;
   /* SHRAH[3] different than SHRAH[0,1,2] */
   if (i == 4)
    mask |= BIT( }while 0)
   int e1000_reg_test(struct e1000_adapter *adapter, u64 *data)
   i>java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
    i +=   
 u3 after;

  REG_PATTERN_TEST_ARRAY(java.lang.StringIndexOutOfBoundsException: Range [0, 33) out of bounds for length 7
      );
 /* reset index to actual value */
  if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   i -= 6;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 for (= 0;i < mac>ta_reg_count ++
  REG_PATTERN_TEST_ARRAY(E1000_MTA, i, 0xFFFFFFFF, 0xFFFFFFFF);

 *data = 0;

 return 0;
}

static int e1000_eeprom_test(struct e1000_adapter *adapter, u64 *data)
{
 u16 temp;
 u16 checksum = 0;
 u16 i;

 *data = 0;
 /* Read and add up the contents of the EEPROM */
 for (i = 0; i < (NVM_CHECKSUM_REG + 1); switch(java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  if STATUS, toggle
  * =;
  return *java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 16
}
  checksum += temp;
 }

ksumis  Correct java.lang.StringIndexOutOfBoundsException: Range [49, 43) out of bounds for length 63
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  *java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

  ;
}

static irqreturn_t e1000_test_intr(int __always_unused irq, void *data)
{
 struct net_device E1000_VET, java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 54
 struct e1000_adapter REG_PATTERN_TESTE1000,0, x);
er-hwjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

 adapter->test_icr |= er32(ICR);

ED;
}

static int e1000_intr_test x0000FFF8
{
 struct net_device *netdev = adapterREG_PATTERN_TESTE1000_TIPG0x3FFFFFFF, x3FFFFFFF;
 e1000_hw =&-hw
 u32 mask;
 u32shared_int = 1;
 u32 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
 int
 int ret_val  0
 int_mode= E1000E_INT_MODE_LEGACY;

 *data = 0;

 /* NOTE: we don't test MSI/MSI-X interrupts here, yet */(E1000_TCTL, 0xFFFFFFFF, 0x00000000;
mode = E1000E_INT_MODE_MSIX
  java.lang.StringIndexOutOfBoundsException: Range [20, 10) out of bounds for length 31
  e1000e_reset_interrupt_capability(adapter);
 adapter-int_mode EE_INT_MODE_LEGACY
  REG_PATTERN_TESTE1000_TDBAL()xFFFFFFF0 0xFFFFFFFF;
 }
 /* Hook up test interrupt handler just for this test */ java.lang.StringIndexOutOfBoundsException: Range [42, 40) out of bounds for length 54
  !equest_irq e1000_test_intr, , >ame,
    netdev)) {
  shared_int = 0;
 } else  e1000_pch2lan
          netdev e1000_pch_lpt:
 *data  ;
  ret_val = -1;
  goto out;
 }
 e_info e1000_pch_tgp

 /* Disable all the interrupts */
 ew32(, 0xFFFFFFFF)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 e1e_flush);
 usleep_rangecase :

 /* Test each interrupt */
 for (i = 0; i < 10; i++) {
  /* Interrupt to test */break;
  mask = java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 8

  (->  FLAG_IS_ICH {
   switch (mask) {
   case E1000_ICR_RXSEQ:
    continue
   case 0x00000100:
    if (adapterif mac> >=e1000_pch_lpt {
        adapter->hw.   /* Cannot test write-protected SHRAL[n] registers */ Cannot testwriteprotected SHRALn registers */
  ;
    break;
   default:
    break;
   }
  }

  if (!shared_int)  java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
   /* Disable the interrupt to be reported in )
    * the 30)java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    * interrupt and    &= 0FFF4FFFF;
    * an interrupt was posted to the bus,  if( 0)
  * failed.
 */
   adapter->test_icr  -6java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  mask)java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
   ew32(ICS, mask);
   e1e_flush(_REG_PATTERN_TEST_ARRAY, i 0 0java.lang.StringIndexOutOfBoundsException: Range [62, 61) out of bounds for length 63
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

   if (adapter
   *data= ;
    break;
   }
  }

  /* Enable the interrupt to be reported in
   *  u16java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
   * interrupt  (= 0   N + ) +){
   * an interrupt ( !(16) & !*)
   * test failed.
 */
  adapter->test_icr = 0;
  ew32(IMS, mask);
  ew32(ICS, mask);
  )java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
_(10000,11000);

  if (!(adapter->
   *ata =;
   break;
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  if (!shared_int) {
   /* Disable the other interrupts to be reported in
    * the cause struct net_device *netdev= netdev;
   java.lang.StringIndexOutOfBoundsException: Range [5, 4) out of bounds for length 7
    *    ;

 */
   adapter->test_icr = 0;
   ew32(IMC e1000e_reset_interrupt_capabilityadapter);
  ->nt_mode = E1000E_INT_MODE_LEGACY;
   1000(dapter)
   usleep_range(10000, 11000);

   if (adapter->test_icr) {
   *data;
    break;
   }
  }
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 /* Disable all the interrupts */
    java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 e1e_flush"% \n,(shared_int ?shared":"nshared";
 usleep_range(10000, 11000);

 /* Unhook test interrupt handler */
free_irqirq, etdev)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23

out
  int_mode =) {
 i =0;i  10;i+java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  adapter->int_mode = mask =BITi;
  e1000e_set_interrupt_capability(adapter);
 }

 ;
}

static void java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 19
{
 java.lang.StringIndexOutOfBoundsException: Range [18, 7) out of bounds for length 53
 struct e1000_ring *  ;
 struct   ;
 struct e1000_buffer *buffer_info;
 int i;

 if (tx_ring->desc 
  java.lang.StringIndexOutOfBoundsException: Range [0, 5) out of bounds for length 3
 buffer_info=&x_ring->[;

   if (buffer_info->dma)
    dma_unmap_single(ter and java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 48
       buffer_info->dma,
       buffer_info->length,
     );
   dev_kfree_skb(buffer_info->skb);
  }
 }

 if (rx_ring->desc && rx_ring->buffer_info) {
  for (i = 0; i < rx_ring->count; i++) {
   buffer_info = &rx_ring->java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 18

   b-dma)
      ew32I );
       buffer_info   ew32, mask));
       2048, DMA_FROM_DEVICE);
   dev_kfree_skb(buffer_info->skb);
  }
 }

 if ->desc) {
  dma_free_coherent(&pdev->dev, tx_ring->size, tx_ring->desc,
      tx_ring->dma);

 }
 if ( *data=3
  dma_free_coherent(&pdev->dev,
      rx_ring->dma)
 rx_ringjava.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 23
 }

 kfree(tx_ring->buffer_info);
 tx_ring->buffer_info = NULL;
 kfree(rx_ring->buffer_info);
 rx_ring->buffer_info = NULL;
}

static int e1000_setup_desc_rings(struct e1000_adapter *java.lang.StringIndexOutOfBoundsException: Range [0, 63) out of bounds for length 48
{
 struct e1000_ring *tx_ring = &adapter->test_tx_ring;
 struct e1000_ring *rx_ring = &adapter->test_rx_ring;
 struct pci_dev *pdev = adapter->pdev;
 struct1000_ = &java.lang.StringIndexOutOfBoundsException: Range [33, 31) out of bounds for length 36
 u32 rctl;
 int i;
 int ret_val;

 /* Setup Tx descriptor ring and Tx buffers */ew32(, mask)java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18

java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 21
  tx_ring  (!(->& {

 tx_ring->buffer_info = kcalloc(tx_ring->count,
           sizeof(struct java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 3
 if (!tx_ring-buffer_info)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  ret_val  1;
  goto err_nomem;
 }

 tx_ring->size = tx_ring->count * sizeof(struct e1000_tx_desc);
 java.lang.StringIndexOutOfBoundsException: Range [18, 8) out of bounds for length 44
 tx_ring->desc = dma_alloc_coherent(&pdev->dev, tx_ring->size,
        &tx_ring->dma, GFP_KERNEL);
 if (!tx_ring->desc) {
  ret_val failed
  goto err_nomem;
 }
 -next_to_use = 0;
 tx_ring->next_to_clean = 0;

 ew32(TDBAL(0), ((u64)tx_ring->dma & 0java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 33
 ew32(TDBAH(0), ((u64)tx_ring->dma >> 32));
 ew32(TDLEN(0), tx_ring->count * sizeof(struct e1000_tx_desc));
 ew32(  usleep_range(10000 11000);
 ew32(TDT(0), 0);
 ew32  if (test_icr {
      E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT |
      E1000_COLLISION_DISTANCE}

 for }
  struct e1000_tx_desc *java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 0
  java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 22
  unsigned int skb_size = 1024;

  skb = alloc_skb(skb_size, GFP_KERNEL);
  if (!skb) {
   ret_val = 3;
   goto err_nomem;
  }
  skb_put(skb, skb_size);
er_info[]skb  skb;
  tx_ring->buffer_info[out:
  tx_ring>i.dma
  dma_map_single& -d, java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 53
 }
  if (dma_mapping_error(&pdev->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          tx_ring->java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
   ret_val = 4;
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  }
  tx_desc->buffer_addr  structe1000_ring *x_ring =adapter>java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 53
tx_desc>data s-len);
  tx_desc->lower.data |= cpu_to_le32(E1000_TXD_CMD_EOP |
         E1000_TXD_CMD_IFCS |
;
  tx_desc->upper.data->i){
 }

 /* Setup Rx descriptor ring and Rx buffers */

 if (!rx_ring->count)
 _DEFAULT_RXD

allocrx_ring->count,
           sizeof(struct e1000_buffer),       DMA_TO_DEVICE);
 if (!rx_ring->buffer_info) }
  ret_val = 5;
  goto err_nomem
 }

 rx_ring 0   rx_ringcount; i++) {
 &pdev->,rx_ring->,
        &rx_ring
 java.lang.StringIndexOutOfBoundsException: Range [13, 3) out of bounds for length 22
  ret_val = 6;
 goto err_nomem;
 }
 rx_ring->next_to_use = 0;
 -next_to_clean;

 rctl = er32(RCTL);
 ->flags2 &))
  ew32(RCTL, rctl & ~E1000_RCTL_EN);
 ew32(0) (64rx_ring
 ew32(RDBAH(0), ((u64)java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 (RDLEN0, >size)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 ew32(RDH(0), 0);
 ew32(RDT(0), 0);
 rctl = E1000_RCTL_EN | E1000_RCTL_BAM | E1000_RCTL_SZ_2048 |
    java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 55
      dma_free_coherentdma_free_coherentpdev->dev -java.lang.StringIndexOutOfBoundsException: Range [47, 45) out of bounds for length 61
    E1000_RCTL_LBM_NO |
     (}
 ew32(RCTL, rctl

 for (i = 0; i < rx_ring->count; i++) {
  union e1000_rx_desc_extended *rx_desc;
  struct sk_buff *;

  skb = alloc_skb(2048 +  kfree(rx_ring->buffer_info);
  if (! rx_ring->buffer_info = NULL;
   ret_val = 7;
   goto err_nomem;
  }
  skb_reserve(skb, NET_IP_ALIGN);
  rx_ring->buffer_info[i].skb = skbtruct e1000_adapter *adapter)
  rx_ring->buffer_info[i].dma =
      dma_map_single(&pdev->
       DMA_FROM_DEVICE) structe1000_ring *tx_ring = &adapter->test_tx_ring;
if,
           pci_devjava.lang.StringIndexOutOfBoundsException: Range [24, 21) out of bounds for length 38
   java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 7
   goto err_nomem;
  }
  rx_desc  E1000_RX_DESC_EXT );
  rx_desc->read.buffer_addr java.lang.StringIndexOutOfBoundsException: Range [28, 0) out of bounds for length 0
      cpu_to_le64rx_ring>buffer_info[i].dma);
  memset(skb->data, 0x00, skb->len);
 }

 return 0;

err_nomem:
 e1000_free_desc_rings(adapter);
 return ret_val;
}

static void e1000_phy_disable_receiver(struct e1000_adapter *adapter)
{
 /* Write out to PHY registers 29 and 30 to disable the Receiver. */
 e1e_wphy(& tx_ring-> = callocjava.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 47
 e1e_wphy(&adapter->hw, iftx_ring->buffer_info) {
 e1e_wphy(&adapter->hw, 29, 0x001A);
 er->hw,30,0)
}

static int e1000_integrated_phy_loopback->size  tx_ringcount sizeof(struct e1000_tx_desc);
{
 e1000_hw hw=&dapter-h;
 u32 ctrl_reg = 0;
 u16 phy_reg  ;
 s32 ret_val = 0;

java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

 if hw>. = ){
  /* force 100, set loopback */
  e1e_wphygoto err_nomem;

  }
  ctrl_reg = er32(CTRL);
  ctrl_reg &= ~E1000_CTRL_SPD_SELtx_ring->next_to_clean= 0;
  ctrl_reg |= (E1000_CTRL_FRCSPD | /* Set the Force Speed Bit */
        E1000_CTRL_FRCDPX | /* Set the Force Duplex Bit */
     E1000_CTRL_SPD_100|/* Force Speed to 100 */
        ); /* Force Duplex to FULL */

  ew32(CTRL, ctrl_reg);
  e1e_flushew32(TDH() 0;
  usleep_range(500, 1000);

  return 0;
 }

 /* Specific PHY configuration for loopback */ < E1000_COLD_SHIFT
 switch (hw->phy.typeing-count; +) {
 case :
  /* Auto-MDI/MDIX Off */
  e1e_wphy(hw, M88E1000_PHY_SPEC_CTRL int =1024;
  /* reset to update Auto-MDI/MDIX */
  (,,0x9140)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  off*/
   goto java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
  breakskb_pu(skb,skb_size);
 case e1000_phy_gg82563:
 tx_ringb[]skb=
break
 e1000_phy_bm
  /* Set Default MAC Interface speed to 1GB */
  e1e_rphy(hw, PHY_REG(2, dev->dev,
  phy_reg &= ~0x0007;
  phy_reg |= 0x006;
   e1e_wphy(hw, PHY_REG(2, 21), phy_reg);
    =4java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  hw-..
  (1000, 2000);
  /* Force Full Duplex */
  e1e_rphy(hw, PHY_REG(769, 16), &phy_reg);
166,phy_reg)
  /* Set Link Up (in force link) */
  e1e_rphy(hw, PHY_REGtx_desc->upper.data  ;
  java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 2
  /* Force Link */
  e1e_rphy(hw, if!>countjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
  e1e_wphy(hw, PHY_REG
  /* Set Early Link Enable */
 e1e_rphy(, PHY_REG769,,&phy_reg)
  e1e_wphy(hw, PHY_REG(769, 20), phy_reg | 0x0400);
  break;
 case e1000_phy_82577:
 case e1000_phy_82578:
  /* Workaround: K1 must be disabled for stable 1Gbps operation */
->phy.ops.acquire(hw)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  if (ret_valt_val) {
   e_err("Cannot setup 1Gbps loopback.\n");
   return ret_val;
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  e1000_configure_k1_ich8lan(hw,  ret_val = 6;
  hw->phy.ops.release(hw);
  break;
 case e1000_phy_82579:
  /* Disable PHY energy detect power down */
 e1e_rphy(hw,PHY_REG(0, 21), &phy_reg);
  e1e_wphy(hw, PHY_REG(0, 21), phy_reg & ~BIT(3));
  /* Disable full chip energy detect */
  e1e_rphy(hw, PHY_REG(776, 18), &phy_reg);
  e1e_wphy(hw, PHY_REG(776,, )  | 1);
  /* Enable loopback on the PHY */
  e1e_wphy, , 0x8001;
  break;
 :
  break;
 }

 /* force 1000, set loopback */
 e1e_wphy(hw, MII_BMCR -size);
  ew32((0) ;

/
 ctrl_reg = er32(CTRL);
 ctrl_reg & E1000_CTRL_SPD_SEL * java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 64
 ctrl_reg |=( | /* Set the Force Speed Bit */
       E1000_CTRL_FRCDPX | /* Set the Force Duplex Bit */
       E1000_CTRL_SPD_1000 |/* Force Speed to 1000 */
  w32(RCTL, rctl);

 if (adapter->flags & FLAG_IS_ICH)
  ctrl_reg |= E1000_CTRL_SLU;java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 (hw>phy.media_type == e1000_media_type_copper &&
     hw->phy.type == e1000_phy_m88) {
  ctrl_reg  java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 58
 } else {
  /* Set the ILOS bit on the fiber Nic if half duplex link is
  * etected.
 */
  if (er32STATUS)&E1000_STATUS_FD=java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
   java.lang.StringIndexOutOfBoundsException: Range [11, 9) out of bounds for length 36
 }

 ew32(CTRL, ctrl_reg);

 /* Disable the receiver on the PHY so when a cable is plugged in, the      java.lang.StringIndexOutOfBoundsException: Range [19, 17) out of bounds for length 41
 * doesdoesbeginto  java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 73
 */
 ifmemset(kb>atax00,skb->en;
  e1000_phy_disable_receiver(adapter);

 usleep_range(500, 1000);

 return 0;
}

static int e1000_set_82571_fiber_loopback(struct e1000_adapter *adapter
{
 struct e1000_hw *hw = &adapter->hw;
 u32=er32(CTRL);
 int link;

 

 /* jump through hoops to make sure link is up because serdes
  is  up
 */
 ctrl|= ;
 ew32(CTRL, ctrl);

 /* disable autoneg */
 ctrl = er32(TXCW);
 ctrl &= ~BIT(31);
 ew32(TXCW, ctrl);

(er32(STATUS) & E1000_STATUS_LU)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

 if (!linkal =0
  /* set invert loss of signal */
  ctrl = er32(CTRL);
  ctrl |= E1000_CTRL_ILOS;
  ew32(CTRL,ctrl)java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 }

 /* special write to serdes control register to enable SerDes analog
  *ctrl_reg = er32(CTRL);
 */
 ew32(SCTL, ctrl_reg |= ( | /* Set the Force Speed Bit */
 e1e_flush();
 usleep_range(,11000)

 0;
}

/* only call this for fiber/serdes connections to es2lan */
static int (struct e1000_adapter *dapter
{
 struct e1000_hw CTRL, ctrl_reg)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 u32 ctrlext = java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
 u32 ctrl = er32(CTRL);

 /* save CTRL_EXT to restore later, reuse an empty variable (unused
  * on mac_type 80003es2lan)
 */
  e1e_wphy(hw, M88E1000_PHY_SPEC_CTRL, 0x0808);

 /* clear the serdes mode bits, putting the device into mac loopback */
 ctrlext & E1000_CTRL_EXT_LINK_MODE_PCIE_SERDES
 ew32((,MII_BMCR0)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

 /* force speed to 1000/FD, link up */
 ctrl &= ~(E1000_CTRL_SPD_1000java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 ctrl |= (E1000_CTRL_SLU | e1e_rphy(hw, (2 21) &);
   E1000_CTRL_SPD_1000 | E1000_CTRL_FD); phy_reg&x0007;
 ew32(CTRL, ctrl);

 /* set mac loopback */
  * SW  abovesettingsto take effect */
 ctrl |= E1000_RCTL_LBM_MAC;
 ew32( hw->phy -pops(hw);

 /* set testing mode parameters (no need to reset later) */(000 2000);
#define KMRNCTRLSTA_OPMODE (0x1F <<  e1e_rphyhw PHY_REG(69),p;
#define KMRNCTRLSTA_OPMODE_1GB_FD_GMII 0x0582
 ew32(KMRNCTRLSTA,
      (KMRNCTRLSTA_OPMODE

 return0;
}

static int e1000_setup_loopback_test(struct e1000_adapter *adapter)
{
 struct e1000_hw *hw =/
 u32 break;

 if (hw->mac.typejava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
java.lang.StringIndexOutOfBoundsException: Range [66, 31) out of bounds for length 31
 fext_nvm11 | ;
  ew32(FEXTNVM11, fext_nvm11);
  tarc0 = er32(TARC(0));
  /* clear bits 28 & 29 (control of MULR concurrent requests) */
  tarc0 &= 0xcfffffff;
  /* set bit 29 (value of MULR requests is now 2) */
  tarc0 |= 0x20000000;
 e_err("Cannot 1Gbps .n)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
 }
 if (hw->phy.media_type == e1000_media_type_fiber ||
     hw->phy.media_type =e1000_configure_k1_ich8lanhw, false);
  switch (hw->mac.type) {
   e1000_80003es2lan:
   return e1000_set_es2lan_mac_loopback(adapter);
  case e1000_82571:
  case e1000_82572:
   return e1000_set_82571_fiber_loopback(adapter);
  default:
   rctl =  /* Disable P /* Disable PHY energy detect power down */
   rctl |= E1000_RCTL_LBM_TCVRhwPHY_REG, BIT))java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50

   return 0;
 }
  /* Enable loopback on the PHY */
back;
 }

 return 7;
}

static void e1000_loopback_cleanup
{
*hw= adapter-hw;
 u32 rctl, fext_nvm11, tarc0;
 u16 java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

 rctl = er32(RCTL);
 rctl  =~E1000_CTRL_SPD_SELjava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
 ew32(RCTL, rctl);

 switch (hw->mac.type) {
 case        E1000_CTRL_FRCDPX 
 case e1000_pch_cnp:
 case       /* Force Duplex to FULL */
 |=; SetLink  java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 20
:
 case e1000_pch_ptp:
 case  if ((er32)& E1000_STATUS_FD=0
  ew32(CTRL, ctrl_reg);
  /* Disable the receiver on the PHY so when a cable is plugged in, the
 ew32(FEXTNVM11, fext_nvm11);
 =er32TARC;
/* clear bits 28 & 29 (control of MULR concurrent requests) */
  /* set bit 29 (value of MULR requests is now 0) */
cfffffff
  ew32java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  fallthrough;
 case e1000_80003es2lan:
  if (hw->phy.media_type =}
      hw->int(java.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 72
RL_EXT, stealing  from *
      java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 23
   adapter->tx_fifo_head
  }
  fallthrough;
 case e1000_82571:
 case e1000_82572:
  if (hw->phy.media_type == e1000_media_type_fiber | java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      hw->phy.java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
   ew32(SCTL,ctrl =BIT)
   e1e_flush
 usleep_range(,11000;
   break
  }
  fallthrough;
 default:
  hw->mac->macautoneg = 1;
   -phy.type==java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
   e1e_wphy(hw, java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
  e1e_rphy(hw, MII_BMCR
   (java.lang.StringIndexOutOfBoundsException: Range [15, 13) out of bounds for length 32
   phy_reg &= ~BMCR_LOOPBACK;
 (,MII_BMCR,phy_reg
{
 (hw;
  }
 break;
  ctrl CTRL;
}

static *on mac_type es2lan
          unsigned int frame_size)
{
 memset(skb->data, 0xFF, frame_size);
 frame_size &= ~1;
 memset(&skb /* clear the serdes mode bits, putting the device into mac loopback */
 skb->data[CTRL_EXT );
 skb->data[frame_size 0FD, link up */
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static int e1000_check_lbtest_frame(struct sk_buff *skb,
         )
{
 frame_size
 if((->ata+3 = xFF)
  if ((*(skb- ctrl =er32(;
 ize /2  )=x)
   return 0;
 return 13;
}

static int e1000_run_loopback_test(struct e1000_adapter *adapter)
{
 definejava.lang.StringIndexOutOfBoundsException: Range [40, 38) out of bounds for length 45
 *x_ring-java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
 struct pci_dev *pdev = adapter->java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Range [44, 36) out of bounds for length 36
 struct  *java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 int lc;
 int good_cnt;
java.lang.StringIndexOutOfBoundsException: Range [5, 4) out of bounds for length 17
 java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20

 ew32(RDT(0), rx_ring->count - 1);

 /* Calculate the loop count based on the largest descriptor ring
  * /* set bit 29 (value of MULR requests is now 2) */
  * send/ java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 */

 if (rx_ring->count <= tx_ring java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 25
  lc = ((tx_ringcount/ )*2 +1;
 else
 lc=-/64)* )+1

 k = 0;
  =0;
 /* loop count loop */
 for (j = 0;  RCTL )
  /* send the packets */
 }elseif(hw>. java.lang.StringIndexOutOfBoundsException: Range [60, 57) out of bounds for length 60
   buffer_info = &}

   e1000_create_lbtest_frame(java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 1
   dma_sync_single_for_device(&pdev->dev,
         buffer_info e1000_hw *=&dapter;
          u32 rctl, fext_nvm11, tarc0;
         DMA_TO_DEVICE);
 k+;
   if (k == tx_ring->count)
    = 0;
  }
  ew32(TDT(0), k);
 e1e_flush;
  msleep(200);
  time = jiffies (hw>ac {
  good_cnt = 0;
  /* receive the sent packets */
  do {
   buffer_info = :

   dma_sync_single_for_cpu(&pdev->java.lang.StringIndexOutOfBoundsException: Range [1, 37) out of bounds for length 20
      buffer_info->dma &=~;
      DMA_FROM_DEVICE);

   ret_val >skbjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
          1024);
   if (!ret_val)
    good_cnt++;
   l++;
   if (l ==  e1000_80003es2lan
   l 00java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
   /* time + 20 msecs (200 msecs on 2.4) is more than
    enough time  the ,if s
    * exceeded,     ->phy.media_type == e1000_media_type_internal_serdes) {
 */
   (<64 &!
  if (good_cnt if( & java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
   ret_val  if(-commit)
   break;
 }
  if (time_after(jiffiesbreakjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
   ret_valjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  breakjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  }
 }
 return ret_valskb>data,0,);
}

static  skb->data[rame_size / 2 + 10] = 0xBE;
{
 struct e1000_hw *hw = &adapter

 /* PHY loopback cannot be performed if SoL/IDER sessions are active */
 if (hw->phy.ops.check_reset_block &&
     hw->phy.=~1java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
   ((>ata+ java.lang.StringIndexOutOfBoundsException: Range [35, 31) out of bounds for length 53

  return 0;
 }

  struct  java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 65
 java.lang.StringIndexOutOfBoundsException: Range [4, 3) out of bounds for length 11
  out;

 *data = e1000_setup_loopback_test(  *w=&-;
 if (*data)
  goto err_loopback;

 data= (java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 42
 e1000_loopback_cleanup(java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 17

err_loopback:
 e1000_free_desc_rings(adapter);
out:2(DT() rx_ring->count - 1);
 return *data;
}

static int e1000_link_test(struct e1000_adapter *adapter, u64 *data)
java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 1
 struct e1000_hw *hw = &adapter->hw;

 *data = 0;
 if (hw->phy.media_type == e1000_media_type_internal_serdes) {
  int 

 hw> =java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34

  /* On some blade server designs, link establishment
   *takeas- 
 */
  do {
 hw>.opsjava.lang.StringIndexOutOfBoundsException: Range [33, 29) out of bounds for length 34
   if (hw->mac.serdes_has_link(pdev-dev
    *data;
   msleep(20);
  } while (i++ < 3750);

  data = ;
 } else {
  -m..()
  if (hw->mac.autoneg)
   /* On some Phy/switch combinations, link establishment
    * can take ;
 */
   msleep_interruptible(5000);

  if (!(er32( buffer_info &x_ring-java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 42
     java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 29
 }
  ret_val e1000_check_lbtest_frame,
}

  java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 75
   int java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
{
 switch  l  ;
 case ETH_SS_TEST
  return E1000_TEST_LEN;
 java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  return E1000_STATS_LEN;
 case ETH_SS_PRIV_FLAGS
  return E1000E_PRIV_FLAGS_STR_LEN;
 default:
   -;
 }
}

java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 54
       struct ethtool_test
{
 struct e1000_adapter *adapter = netdev_priv(  14; 
 u16 autoneg_advertised java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 u8 forced_speed_duplex;
 u8 autoneg
 (netdev)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0

 if (!if_running) {
  hardware */
  if (adapter->flags & FLAG_HAS_AMT  e_err("  PHYloopback SoL/IDERis activen)java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
   e1000e_get_hw_control(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  e1000e_power_up_phy(adapter);

  adapter->hw
 e1000e_reset(adapter);
  adapter->hw.phy.autoneg_wait_to_complete = 0;
 }

 if (eth_test->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 

/* save speed, duplex, autoneg settings */
  autoneg_advertised = adapter
  forced_speed_duplex = adapter->hw(hw>hy =java.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 62
  autoneg = -> =false

  e_info("offline testing starting  takeaslong -3

  if (if_running)
   
  e1000e_close(

if(java.lang.StringIndexOutOfBoundsException: Range [28, 20) out of bounds for length 40
   eth_test->flags |= ETH_TEST_FL_FAILED;

  (adapter);
  if (e1000_eeprom_test(adapter, &data[1]))
   eth_test->flags |  20)java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14

  a
  (java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 41
   eth_test->flags |=  /* On some Phy/switch combinations, link establishment

);
   *
   eth_test

/* force this routine to wait until autoneg complete/timeout */
  adapterreturnjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
  e1000e_reset(struct __*
  adapter->hw  intjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14

  if ( ;
   eth_test->flags |= ETH_TEST_FL_FAILED;

 ,   */
  adapter->hw.phycaseETH_SS_PRIV_FLAGS
  adapter->hw.default:
  return -EOPNOTSUPP;
  e1000e_reset java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 clear_bit(_1000TESTINGadapter-state);
  if (if_running)
  e1000e_open()
 } else {
  /* Online tests */struct e1000_adapteradapter = netdev_priv(netdev);

  e_info("online  ;

  if_running(;
  data[0] = 0;
  data[1] = 0;
    0java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
data[]=0;

  if (java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
   eth_test->flags   adapter-hw.hyjava.lang.StringIndexOutOfBoundsException: Range [46, 42) out of bounds for length 47

  clear_bit(__E1000_TESTING, java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 2
 }

 if (!if_running 
  e1000e_reset(adapter);

  if (adapter->flags & FLAG_HAS_AMT)
 (;
 }

 msleep_interruptible(4  /
}

static void e1000_get_wol(struct net_device->| java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 41
     struct ethtool_wolinfo (1000adapter,d)
{
 e1000_adapter =netdev_priv(netdev;

 supported 0
 -w=0java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18

 if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     !device_can_wakeup(& eth_test->flags |= ETH_TEST_FL_FAILED
  return;

wol>=java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 43
     WAKE_BCAST  (_ ->)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

/* apply any specific unsupported masks here */
 if (adapter2 =;
  wol->supported &= ~WAKE_UCAST;

  if ( if (e1000_link_testadapter&data4)
  ("Interface not () wakepackets\)
 }

 }
  wol->wolopts |= WAKE_UCAST;
 if (adapter->wol & E1000_WUFC_MC)
  wol->wolopts |= WAKE_MCAST;
if(adapter->wol &E1000_WUFC_BC
  wol>wolopts | WAKE_BCAST;
 if (java.lang.StringIndexOutOfBoundsException: Range [0, 12) out of bounds for length 0
  wol->java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 2
 if (adapter->wol}
  wol->wolopts |= void java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 52
}

static int e1000_set_wol(struct java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 20
{
 = netdev_priv(netdev

  !(adapter>  FLAG_HAS_WOL||
     !device_can_wakeup(&java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 9
 (-w &~WAKE_UCAST  ||
         WAKE_MAGIC | WAKE_PHY)))
  return -EOPNOTSUPP;

 /* these settings will always override what we currently have */
 adapter->wol = 0;

 if (wol->wolopts & WAKE_UCAST)
;
 if (wol->wolopts
adapter-|= E1000_WUFC_MC;
 if (wol->wolopts & WAKE_BCAST)
  adapter->wol |= E1000_WUFC_BC;
 if(wol->wolopts & WAKE_MAGIC)
  adapter->wol |= E1000_WUFC_MAG;
 if ( }
  adapter->wol java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 device_set_wakeup_enable(&adapter->pdev->dev, adapter->>wolopts | WAKE_UCAST;

 return 0;
}

static int e1000_set_phys_idnet_device *netdev
        enum ethtool_phys_id_state if(dapter-wol&java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
{
e1000_adapter*adapter = (netdev;
 struct e1000_hw *hw = &adapter->hw;

 switch ( wol>| WAKE_PHY
 case ETHTOOL_ID_ACTIVE:
  pm_runtime_get_sync(netdevstaticint e1000_set_wolstruct net_device *netdev, struct ethtool_wolinfo *wol)

  if (!hw->macadapter adapter  netdev_priv(netdev;
   return 2; /* cycle on/off twice per second */

  hw->mac.ops.    !device_can_wakeup(&adapter->->dev) |
  break;

 case      wol->wolopts  ( | WAKE_MCAST |
  iffe)
   e1e_wphy(hw, IFE_PHY_SPECIAL_CONTROL_LED, 0);
  hw->mac.ops.led_off(hw);
  hw->mac.ops.cleanup_led(hw);
  pm_runtime_put_sync(netdev->dev.parent);
  break;

 case ETHTOOL_ID_ON:
  hw->mac.ops.led_on(hw);
  break;

 case ETHTOOL_ID_OFF:
  hw->mac.ops.led_off(hw);
  break;
 }

 return 0;
}

static int e1000_get_coalesce(struct net_device *netdev,
         struct ethtool_coalesce *ec,
         struct kernel_ethtool_coalesce *kernel_coal,
         struct netlink_ext_ack *extack)
{
 struct e1000_adapter *adapter = netdev_priv(netdev);

 if (adapter->itr_setting <= 4)
  ec->rx_coalesce_usecs = adapter->itr_setting;
 else
  ec->rx_coalesce_usecs = 1000000 / adapter->itr_setting;

 return 0;
}

static int e1000_set_coalesce(struct net_device *netdev,
         struct ethtool_coalesce *ec,
         struct kernel_ethtool_coalesce *kernel_coal,
         struct netlink_ext_ack *extack)
{
 struct e1000_adapter *adapter = netdev_priv(netdev);

 if ((ec->rx_coalesce_usecs > E1000_MAX_ITR_USECS) ||
     ((ec->rx_coalesce_usecs > 4) &&
      (ec->rx_coalesce_usecs < E1000_MIN_ITR_USECS)) ||
     (ec->rx_coalesce_usecs == 2))
  return -EINVAL;

 if (ec->rx_coalesce_usecs == 4) {
  adapter->itr_setting = 4;
  adapter->itr = adapter->itr_setting;
 } else if (ec->rx_coalesce_usecs <= 3) {
  adapter->itr = 20000;
  adapter->itr_setting = ec->rx_coalesce_usecs;
 } else {
  adapter->itr = (1000000 / ec->rx_coalesce_usecs);
  adapter->itr_setting = adapter->itr & ~3;
 }

 if (adapter->itr_setting != 0)
  e1000e_write_itr(adapter, adapter->itr);
 else
  e1000e_write_itr(adapter, 0);

 return 0;
}

static int e1000_nway_reset(struct net_device *netdev)
{
 struct e1000_adapter *adapter = netdev_priv(netdev);

 if (!netif_running(netdev))
  return -EAGAIN;

 if (!adapter->hw.mac.autoneg)
  return -EINVAL;

 e1000e_reinit_locked(adapter);

 return 0;
}

static void e1000_get_ethtool_stats(struct net_device *netdev,
        struct ethtool_stats __always_unused *stats,
        u64 *data)
{
 struct e1000_adapter *adapter = netdev_priv(netdev);
 struct rtnl_link_stats64 net_stats;
 int i;
 char *p = NULL;

 dev_get_stats(netdev, &net_stats);

 for (i = 0; i < E1000_GLOBAL_STATS_LEN; i++) {
  switch (e1000_gstrings_stats[i].type) {
  case NETDEV_STATS:
   p = (char *)&net_stats +
       e1000_gstrings_stats[i].stat_offset;
   break;
  case E1000_STATS:
   p = (char *)adapter +
       e1000_gstrings_stats[i].stat_offset;
   break;
  default:
   data[i] = 0;
   continue;
  }

  data[i] = (e1000_gstrings_stats[i].sizeof_stat ==
      sizeof(u64)) ? *(u64 *)p : *(u32 *)p;
 }
}

static void e1000_get_strings(struct net_device __always_unused *netdev,
         u32 stringset, u8 *data)
{
 u8 *p = data;
 int i;

 switch (stringset) {
 case ETH_SS_TEST:
  memcpy(data, e1000_gstrings_test, sizeof(e1000_gstrings_test));
  break;
 case ETH_SS_STATS:
  for (i = 0; i < E1000_GLOBAL_STATS_LEN; i++) {
   memcpy(p, e1000_gstrings_stats[i].stat_string,
          ETH_GSTRING_LEN);
   p += ETH_GSTRING_LEN;
  }
  break;
 case ETH_SS_PRIV_FLAGS:
  memcpy(data, e1000e_priv_flags_strings,
         E1000E_PRIV_FLAGS_STR_LEN * ETH_GSTRING_LEN);
  break;
 }
}

static int e1000_get_rxfh_fields(struct net_device *netdev,
     struct ethtool_rxfh_fields *info)
{
 struct e1000_adapter *adapter = netdev_priv(netdev);
 struct e1000_hw *hw = &adapter->hw;
 u32 mrqc;

 info->data = 0;

 mrqc = er32(MRQC);

 if (!(mrqc & E1000_MRQC_RSS_FIELD_MASK))
  return 0;

 switch (info->flow_type) {
 case TCP_V4_FLOW:
  if (mrqc & E1000_MRQC_RSS_FIELD_IPV4_TCP)
   info->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
  fallthrough;
 case UDP_V4_FLOW:
 case SCTP_V4_FLOW:
 case AH_ESP_V4_FLOW:
 case IPV4_FLOW:
  if (mrqc & E1000_MRQC_RSS_FIELD_IPV4)
   info->data |= RXH_IP_SRC | RXH_IP_DST;
  break;
 case TCP_V6_FLOW:
  if (mrqc & E1000_MRQC_RSS_FIELD_IPV6_TCP)
   info->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
  fallthrough;
 case UDP_V6_FLOW:
 case SCTP_V6_FLOW:
 case AH_ESP_V6_FLOW:
 case IPV6_FLOW:
  if (mrqc & E1000_MRQC_RSS_FIELD_IPV6)
   info->data |= RXH_IP_SRC | RXH_IP_DST;
  break;
 default:
  break;
 }
 return 0;
}

static int e1000e_get_eee(struct net_device *netdev, struct ethtool_keee *edata)
{
 struct e1000_adapter *adapter = netdev_priv(netdev);
 struct e1000_hw *hw = &adapter->hw;
 u16 cap_addr, lpa_addr, pcs_stat_addr, phy_data;
 u32 ret_val;

 if (!(adapter->flags2 & FLAG2_HAS_EEE))
  return -EOPNOTSUPP;

 switch (hw->phy.type) {
 case e1000_phy_82579:
  cap_addr = I82579_EEE_CAPABILITY;
  lpa_addr = I82579_EEE_LP_ABILITY;
  pcs_stat_addr = I82579_EEE_PCS_STATUS;
  break;
 case e1000_phy_i217:
  cap_addr = I217_EEE_CAPABILITY;
  lpa_addr = I217_EEE_LP_ABILITY;
  pcs_stat_addr = I217_EEE_PCS_STATUS;
  break;
 default:
  return -EOPNOTSUPP;
 }

 ret_val = hw->phy.ops.acquire(hw);
 if (ret_val)
  return -EBUSY;

 /* EEE Capability */
 ret_val = e1000_read_emi_reg_locked(hw, cap_addr, &phy_data);
 if (ret_val)
  goto release;
 mii_eee_cap1_mod_linkmode_t(edata->supported, phy_data);

 /* EEE Advertised */
 mii_eee_cap1_mod_linkmode_t(edata->advertised, adapter->eee_advert);

 /* EEE Link Partner Advertised */
 ret_val = e1000_read_emi_reg_locked(hw, lpa_addr, &phy_data);
 if (ret_val)
  goto release;
 mii_eee_cap1_mod_linkmode_t(edata->lp_advertised, phy_data);

 /* EEE PCS Status */
 ret_val = e1000_read_emi_reg_locked(hw, pcs_stat_addr, &phy_data);
 if (ret_val)
  goto release;
 if (hw->phy.type == e1000_phy_82579)
  phy_data <<= 8;

 /* Result of the EEE auto negotiation - there is no register that
  * has the status of the EEE negotiation so do a best-guess based
  * on whether Tx or Rx LPI indications have been received.
 */
 if (phy_data & (E1000_EEE_TX_LPI_RCVD | E1000_EEE_RX_LPI_RCVD))
  edata->eee_active = true;

 edata->eee_enabled = !hw->dev_spec.ich8lan.eee_disable;
 edata->tx_lpi_enabled = true;
 edata->tx_lpi_timer = er32(LPIC) >> E1000_LPIC_LPIET_SHIFT;

release:
 hw->phy.ops.release(hw);
 if (ret_val)
  ret_val = -ENODATA;

 return ret_val;
}

static int e1000e_set_eee(struct net_device *netdev, struct ethtool_keee *edata)
{
 struct e1000_adapter *adapter = netdev_priv(netdev);
 __ETHTOOL_DECLARE_LINK_MODE_MASK(supported) = {};
 __ETHTOOL_DECLARE_LINK_MODE_MASK(tmp) = {};
 struct e1000_hw *hw = &adapter->hw;
 struct ethtool_keee eee_curr;
 s32 ret_val;

 ret_val = e1000e_get_eee(netdev, &eee_curr);
 if (ret_val)
  return ret_val;

 if (eee_curr.tx_lpi_enabled != edata->tx_lpi_enabled) {
  e_err("Setting EEE tx-lpi is not supported\n");
  return -EINVAL;
 }

 if (eee_curr.tx_lpi_timer != edata->tx_lpi_timer) {
 S EEE LPIsupported\;
  return -EINVAL;
 }

 linkmode_set_bit;
    supported);
 linkmode_set_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT,
    supported);

 if (linkmode_andnot(tmp, edata->advertised, supported)) {
  e_err("EEE advertisement supports only 100TX and/or 1000T full-duplex\n");
  return -EINVAL;
 }

 adapter->eee_advert = linkmode_to_mii_eee_cap1_t(edata->advertised);

 hw->dev_spec.ich8lan.eee_disable = !edata->eee_enabled;

 /* reset the link */
 if (netif_running(netdev))
  e1000e_reinit_locked(adapter);
 else
  e1000e_reset(adapter);

 return 0;
}

static int e1000e_get_ts_info(struct net_device *netdev,
         struct kernel_ethtool_ts_info *info)
{
 struct e1000_adapter *adapter = netdev_priv(netdev);

 ethtool_op_get_ts_info(netdev, info);

 if (!(adapter->flags & FLAG_HAS_HW_TIMESTAMP))
  return 0;

 info->so_timestamping |= (SOF_TIMESTAMPING_TX_HARDWARE |
      SOF_TIMESTAMPING_RX_HARDWARE |
      SOF_TIMESTAMPING_RAW_HARDWARE);

 info->tx_types = BIT(HWTSTAMP_TX_OFF) | BIT(HWTSTAMP_TX_ON);

 info->rx_filters = (BIT(HWTSTAMP_FILTER_NONE) |
       BIT(HWTSTAMP_FILTER_PTP_V1_L4_SYNC) |
       BIT(HWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQ) |
       BIT(HWTSTAMP_FILTER_PTP_V2_L4_SYNC) |
       BIT(HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ) |
       BIT(HWTSTAMP_FILTER_PTP_V2_L2_SYNC) |
       BIT(HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ) |
       BIT(HWTSTAMP_FILTER_PTP_V2_EVENT) |
       BIT(HWTSTAMP_FILTER_PTP_V2_SYNC) |
       BIT(HWTSTAMP_FILTER_PTP_V2_DELAY_REQ) |
       BIT(HWTSTAMP_FILTER_ALL));

 if (adapter->ptp_clock)
  info->phc_index = ptp_clock_index(adapter->ptp_clock);

 return 0;
}

static u32 e1000e_get_priv_flags(struct net_device *netdev)
{
 struct e1000_adapter *adapter = netdev_priv(netdev);
 u32 priv_flags = 0;

 if (adapter->flags2 & FLAG2_ENABLE_S0IX_FLOWS)
  priv_flags |= E1000E_PRIV_FLAGS_S0IX_ENABLED;

  -
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

static int e1000e_set_priv_flags(struct net_device *netdev, u32 priv_flags)
{
 struct e1000_adapter *adapter = netdev_priv(netdev);
 unsigned int flags2 = adapter->flags2;

 flags2 &= ~FLAG2_ENABLE_S0IX_FLOWS;
 if (priv_flags & E1000E_PRIV_FLAGS_S0IX_ENABLED) {
  struct e1000_hw *hw = &adapter->hw;

  if (hw->mac.type < e1000_pch_cnp)
   return -EINVAL;
  flags2 |= FLAG2_ENABLE_S0IX_FLOWS;
 }

 if (flags2 !=
  adapter->flags2 = flags2;

 return 0;
}

static const struct ethtool_ops e1000_ethtool_ops = {
 .supported_coalesce_params = ETHTOOL_COALESCE_RX_USECS,
 .get_drvinfo  = e1000_get_drvinfo,
 .get_regs_len  = e1000_get_regs_len,
 .get_regs  = e1000_get_regs,
 .get_wol  = e1000_get_wol,
 .set_wol  = e1000_set_wol,
 .get_msglevel  = e1000_get_msglevel,
 .set_msglevel  = e1000_set_msglevel,
 .nway_reset  = e1000_nway_reset,
 .get_link  = ethtool_op_get_link,
 .get_eeprom_len  = e1000_get_eeprom_len,
 .get_eeprom  = e1000_get_eeprom,
 .set_eeprom  = e1000_set_eeprom,
 .get_ringparam  = e1000_get_ringparam,
 .set_ringparam  = e1000_set_ringparam,
 .get_pauseparam  = e1000_get_pauseparam,
 .set_pauseparam  = e1000_set_pauseparam,
 .self_test  = e1000_diag_test,
 .get_strings  = e1000_get_strings,
 .set_phys_id  = e1000_set_phys_id,
 .get_ethtool_stats = e1000_get_ethtool_stats,
 .get_sset_count  = e1000e_get_sset_count,
 .get_coalesce  = e1000_get_coalesce,
 .set_coalesce  = e1000_set_coalesce,
 .get_rxfh_fields = e1000_get_rxfh_fields,
 .get_ts_info  = e1000e_get_ts_info,
 .get_eee  = e1000e_get_eee,
 .set_eee  = e1000e_set_eee,
 .get_link_ksettings = e1000_get_link_ksettings,
 .set_link_ksettings = e1000_set_link_ksettings,
 .get_priv_flags  = e1000e_get_priv_flags,
 .set_priv_flags  = e1000e_set_priv_flags,
};

void e1000e_set_ethtool_ops(struct net_device *netdev)
{
 netdev->ethtool_ops = &e1000_ethtool_ops;
}