1

/*******************************************************************************

     2

     3

  Intel PRO/1000 Linux driver

     4

  Copyright(c) 1999 - 2006 Intel Corporation.

     5

     6

  This program is free software; you can redistribute it and/or modify it

     7

  under the terms and conditions of the GNU General Public License,

     8

  version 2, as published by the Free Software Foundation.

     9

    10

  This program is distributed in the hope it will be useful, but WITHOUT

    11

  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    12

  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for

    13

  more details.

    14

    15

  You should have received a copy of the GNU General Public License along with

    16

  this program; if not, write to the Free Software Foundation, Inc.,

    17

  51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.

    18

    19

  The full GNU General Public License is included in this distribution in

    20

  the file called "COPYING".

    21

    22

  Contact Information:

    23

  Linux NICS <linux.nics@intel.com>

    24

  e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>

    25

  Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497

    26

    27

*******************************************************************************/

    28

    29

/* ethtool support for e1000 */

    30

    31

#include "e1000-3.16-ethercat.h"

    32

#include <asm/uaccess.h>

    33

    34

enum {NETDEV_STATS, E1000_STATS};

    35

    36

struct e1000_stats {

    37

	char stat_string[ETH_GSTRING_LEN];

    38

	int type;

    39

	int sizeof_stat;

    40

	int stat_offset;

    41

};

    42

    43

#define E1000_STAT(m)		E1000_STATS, \

    44

				sizeof(((struct e1000_adapter *)0)->m), \

    45

		      		offsetof(struct e1000_adapter, m)

    46

#define E1000_NETDEV_STAT(m)	NETDEV_STATS, \

    47

				sizeof(((struct net_device *)0)->m), \

    48

				offsetof(struct net_device, m)

    49

    50

static const struct e1000_stats e1000_gstrings_stats[] = {

    51

	{ "rx_packets", E1000_STAT(stats.gprc) },

    52

	{ "tx_packets", E1000_STAT(stats.gptc) },

    53

	{ "rx_bytes", E1000_STAT(stats.gorcl) },

    54

	{ "tx_bytes", E1000_STAT(stats.gotcl) },

    55

	{ "rx_broadcast", E1000_STAT(stats.bprc) },

    56

	{ "tx_broadcast", E1000_STAT(stats.bptc) },

    57

	{ "rx_multicast", E1000_STAT(stats.mprc) },

    58

	{ "tx_multicast", E1000_STAT(stats.mptc) },

    59

	{ "rx_errors", E1000_STAT(stats.rxerrc) },

    60

	{ "tx_errors", E1000_STAT(stats.txerrc) },

    61

	{ "tx_dropped", E1000_NETDEV_STAT(stats.tx_dropped) },

    62

	{ "multicast", E1000_STAT(stats.mprc) },

    63

	{ "collisions", E1000_STAT(stats.colc) },

    64

	{ "rx_length_errors", E1000_STAT(stats.rlerrc) },

    65

	{ "rx_over_errors", E1000_NETDEV_STAT(stats.rx_over_errors) },

    66

	{ "rx_crc_errors", E1000_STAT(stats.crcerrs) },

    67

	{ "rx_frame_errors", E1000_NETDEV_STAT(stats.rx_frame_errors) },

    68

	{ "rx_no_buffer_count", E1000_STAT(stats.rnbc) },

    69

	{ "rx_missed_errors", E1000_STAT(stats.mpc) },

    70

	{ "tx_aborted_errors", E1000_STAT(stats.ecol) },

    71

	{ "tx_carrier_errors", E1000_STAT(stats.tncrs) },

    72

	{ "tx_fifo_errors", E1000_NETDEV_STAT(stats.tx_fifo_errors) },

    73

	{ "tx_heartbeat_errors", E1000_NETDEV_STAT(stats.tx_heartbeat_errors) },

    74

	{ "tx_window_errors", E1000_STAT(stats.latecol) },

    75

	{ "tx_abort_late_coll", E1000_STAT(stats.latecol) },

    76

	{ "tx_deferred_ok", E1000_STAT(stats.dc) },

    77

	{ "tx_single_coll_ok", E1000_STAT(stats.scc) },

    78

	{ "tx_multi_coll_ok", E1000_STAT(stats.mcc) },

    79

	{ "tx_timeout_count", E1000_STAT(tx_timeout_count) },

    80

	{ "tx_restart_queue", E1000_STAT(restart_queue) },

    81

	{ "rx_long_length_errors", E1000_STAT(stats.roc) },

    82

	{ "rx_short_length_errors", E1000_STAT(stats.ruc) },

    83

	{ "rx_align_errors", E1000_STAT(stats.algnerrc) },

    84

	{ "tx_tcp_seg_good", E1000_STAT(stats.tsctc) },

    85

	{ "tx_tcp_seg_failed", E1000_STAT(stats.tsctfc) },

    86

	{ "rx_flow_control_xon", E1000_STAT(stats.xonrxc) },

    87

	{ "rx_flow_control_xoff", E1000_STAT(stats.xoffrxc) },

    88

	{ "tx_flow_control_xon", E1000_STAT(stats.xontxc) },

    89

	{ "tx_flow_control_xoff", E1000_STAT(stats.xofftxc) },

    90

	{ "rx_long_byte_count", E1000_STAT(stats.gorcl) },

    91

	{ "rx_csum_offload_good", E1000_STAT(hw_csum_good) },

    92

	{ "rx_csum_offload_errors", E1000_STAT(hw_csum_err) },

    93

	{ "alloc_rx_buff_failed", E1000_STAT(alloc_rx_buff_failed) },

    94

	{ "tx_smbus", E1000_STAT(stats.mgptc) },

    95

	{ "rx_smbus", E1000_STAT(stats.mgprc) },

    96

	{ "dropped_smbus", E1000_STAT(stats.mgpdc) },

    97

};

    98

    99

#define E1000_QUEUE_STATS_LEN 0

   100

#define E1000_GLOBAL_STATS_LEN ARRAY_SIZE(e1000_gstrings_stats)

   101

#define E1000_STATS_LEN (E1000_GLOBAL_STATS_LEN + E1000_QUEUE_STATS_LEN)

   102

static const char e1000_gstrings_test[][ETH_GSTRING_LEN] = {

   103

	"Register test  (offline)", "Eeprom test    (offline)",

   104

	"Interrupt test (offline)", "Loopback test  (offline)",

   105

	"Link test   (on/offline)"

   106

};

   107

#define E1000_TEST_LEN	ARRAY_SIZE(e1000_gstrings_test)

   108

   109

static int e1000_get_settings(struct net_device *netdev,

   110

			      struct ethtool_cmd *ecmd)

   111

{

   112

	struct e1000_adapter *adapter = netdev_priv(netdev);

   113

	struct e1000_hw *hw = &adapter->hw;

   114

   115

	if (hw->media_type == e1000_media_type_copper) {

   116

   117

		ecmd->supported = (SUPPORTED_10baseT_Half |

   118

				   SUPPORTED_10baseT_Full |

   119

				   SUPPORTED_100baseT_Half |

   120

				   SUPPORTED_100baseT_Full |

   121

				   SUPPORTED_1000baseT_Full|

   122

				   SUPPORTED_Autoneg |

   123

				   SUPPORTED_TP);

   124

		ecmd->advertising = ADVERTISED_TP;

   125

   126

		if (hw->autoneg == 1) {

   127

			ecmd->advertising |= ADVERTISED_Autoneg;

   128

			/* the e1000 autoneg seems to match ethtool nicely */

   129

			ecmd->advertising |= hw->autoneg_advertised;

   130

		}

   131

   132

		ecmd->port = PORT_TP;

   133

		ecmd->phy_address = hw->phy_addr;

   134

   135

		if (hw->mac_type == e1000_82543)

   136

			ecmd->transceiver = XCVR_EXTERNAL;

   137

		else

   138

			ecmd->transceiver = XCVR_INTERNAL;

   139

   140

	} else {

   141

		ecmd->supported   = (SUPPORTED_1000baseT_Full |

   142

				     SUPPORTED_FIBRE |

   143

				     SUPPORTED_Autoneg);

   144

   145

		ecmd->advertising = (ADVERTISED_1000baseT_Full |

   146

				     ADVERTISED_FIBRE |

   147

				     ADVERTISED_Autoneg);

   148

   149

		ecmd->port = PORT_FIBRE;

   150

   151

		if (hw->mac_type >= e1000_82545)

   152

			ecmd->transceiver = XCVR_INTERNAL;

   153

		else

   154

			ecmd->transceiver = XCVR_EXTERNAL;

   155

	}

   156

   157

	if (er32(STATUS) & E1000_STATUS_LU) {

   158

   159

		e1000_get_speed_and_duplex(hw, &adapter->link_speed,

   160

		                                   &adapter->link_duplex);

   161

		ethtool_cmd_speed_set(ecmd, adapter->link_speed);

   162

   163

		/* unfortunately FULL_DUPLEX != DUPLEX_FULL

   164

		 * and HALF_DUPLEX != DUPLEX_HALF

   165

		 */

   166

		if (adapter->link_duplex == FULL_DUPLEX)

   167

			ecmd->duplex = DUPLEX_FULL;

   168

		else

   169

			ecmd->duplex = DUPLEX_HALF;

   170

	} else {

   171

		ethtool_cmd_speed_set(ecmd, SPEED_UNKNOWN);

   172

		ecmd->duplex = DUPLEX_UNKNOWN;

   173

	}

   174

   175

	ecmd->autoneg = ((hw->media_type == e1000_media_type_fiber) ||

   176

			 hw->autoneg) ? AUTONEG_ENABLE : AUTONEG_DISABLE;

   177

   178

	/* MDI-X => 1; MDI => 0 */

   179

	if ((hw->media_type == e1000_media_type_copper) &&

   180

	    netif_carrier_ok(netdev))

   181

		ecmd->eth_tp_mdix = (!!adapter->phy_info.mdix_mode ?

   182

				     ETH_TP_MDI_X : ETH_TP_MDI);

   183

	else

   184

		ecmd->eth_tp_mdix = ETH_TP_MDI_INVALID;

   185

   186

	if (hw->mdix == AUTO_ALL_MODES)

   187

		ecmd->eth_tp_mdix_ctrl = ETH_TP_MDI_AUTO;

   188

	else

   189

		ecmd->eth_tp_mdix_ctrl = hw->mdix;

   190

	return 0;

   191

}

   192

   193

static int e1000_set_settings(struct net_device *netdev,

   194

			      struct ethtool_cmd *ecmd)

   195

{

   196

	struct e1000_adapter *adapter = netdev_priv(netdev);

   197

	struct e1000_hw *hw = &adapter->hw;

   198

   199

	/* MDI setting is only allowed when autoneg enabled because

   200

	 * some hardware doesn't allow MDI setting when speed or

   201

	 * duplex is forced.

   202

	 */

   203

	if (ecmd->eth_tp_mdix_ctrl) {

   204

		if (hw->media_type != e1000_media_type_copper)

   205

			return -EOPNOTSUPP;

   206

   207

		if ((ecmd->eth_tp_mdix_ctrl != ETH_TP_MDI_AUTO) &&

   208

		    (ecmd->autoneg != AUTONEG_ENABLE)) {

   209

			e_err(drv, "forcing MDI/MDI-X state is not supported when link speed and/or duplex are forced\n");

   210

			return -EINVAL;

   211

		}

   212

	}

   213

   214

	while (test_and_set_bit(__E1000_RESETTING, &adapter->flags))

   215

		msleep(1);

   216

   217

	if (ecmd->autoneg == AUTONEG_ENABLE) {

   218

		hw->autoneg = 1;

   219

		if (hw->media_type == e1000_media_type_fiber)

   220

			hw->autoneg_advertised = ADVERTISED_1000baseT_Full |

   221

				     ADVERTISED_FIBRE |

   222

				     ADVERTISED_Autoneg;

   223

		else

   224

			hw->autoneg_advertised = ecmd->advertising |

   225

						 ADVERTISED_TP |

   226

						 ADVERTISED_Autoneg;

   227

		ecmd->advertising = hw->autoneg_advertised;

   228

	} else {

   229

		u32 speed = ethtool_cmd_speed(ecmd);

   230

		/* calling this overrides forced MDI setting */

   231

		if (e1000_set_spd_dplx(adapter, speed, ecmd->duplex)) {

   232

			clear_bit(__E1000_RESETTING, &adapter->flags);

   233

			return -EINVAL;

   234

		}

   235

	}

   236

   237

	/* MDI-X => 2; MDI => 1; Auto => 3 */

   238

	if (ecmd->eth_tp_mdix_ctrl) {

   239

		if (ecmd->eth_tp_mdix_ctrl == ETH_TP_MDI_AUTO)

   240

			hw->mdix = AUTO_ALL_MODES;

   241

		else

   242

			hw->mdix = ecmd->eth_tp_mdix_ctrl;

   243

	}

   244

   245

	/* reset the link */

   246

   247

	if (netif_running(adapter->netdev)) {

   248

		e1000_down(adapter);

   249

		e1000_up(adapter);

   250

	} else

   251

		e1000_reset(adapter);

   252

   253

	clear_bit(__E1000_RESETTING, &adapter->flags);

   254

	return 0;

   255

}

   256

   257

static u32 e1000_get_link(struct net_device *netdev)

   258

{

   259

	struct e1000_adapter *adapter = netdev_priv(netdev);

   260

   261

	/* If the link is not reported up to netdev, interrupts are disabled,

   262

	 * and so the physical link state may have changed since we last

   263

	 * looked. Set get_link_status to make sure that the true link

   264

	 * state is interrogated, rather than pulling a cached and possibly

   265

	 * stale link state from the driver.

   266

	 */

   267

	if (!netif_carrier_ok(netdev))

   268

		adapter->hw.get_link_status = 1;

   269

   270

	return e1000_has_link(adapter);

   271

}

   272

   273

static void e1000_get_pauseparam(struct net_device *netdev,

   274

				 struct ethtool_pauseparam *pause)

   275

{

   276

	struct e1000_adapter *adapter = netdev_priv(netdev);

   277

	struct e1000_hw *hw = &adapter->hw;

   278

   279

	pause->autoneg =

   280

		(adapter->fc_autoneg ? AUTONEG_ENABLE : AUTONEG_DISABLE);

   281

   282

	if (hw->fc == E1000_FC_RX_PAUSE)

   283

		pause->rx_pause = 1;

   284

	else if (hw->fc == E1000_FC_TX_PAUSE)

   285

		pause->tx_pause = 1;

   286

	else if (hw->fc == E1000_FC_FULL) {

   287

		pause->rx_pause = 1;

   288

		pause->tx_pause = 1;

   289

	}

   290

}

   291

   292

static int e1000_set_pauseparam(struct net_device *netdev,

   293

				struct ethtool_pauseparam *pause)

   294

{

   295

	struct e1000_adapter *adapter = netdev_priv(netdev);

   296

	struct e1000_hw *hw = &adapter->hw;

   297

	int retval = 0;

   298

   299

	adapter->fc_autoneg = pause->autoneg;

   300

   301

	while (test_and_set_bit(__E1000_RESETTING, &adapter->flags))

   302

		msleep(1);

   303

   304

	if (pause->rx_pause && pause->tx_pause)

   305

		hw->fc = E1000_FC_FULL;

   306

	else if (pause->rx_pause && !pause->tx_pause)

   307

		hw->fc = E1000_FC_RX_PAUSE;

   308

	else if (!pause->rx_pause && pause->tx_pause)

   309

		hw->fc = E1000_FC_TX_PAUSE;

   310

	else if (!pause->rx_pause && !pause->tx_pause)

   311

		hw->fc = E1000_FC_NONE;

   312

   313

	hw->original_fc = hw->fc;

   314

   315

	if (adapter->fc_autoneg == AUTONEG_ENABLE) {

   316

		if (netif_running(adapter->netdev)) {

   317

			e1000_down(adapter);

   318

			e1000_up(adapter);

   319

		} else

   320

			e1000_reset(adapter);

   321

	} else

   322

		retval = ((hw->media_type == e1000_media_type_fiber) ?

   323

			  e1000_setup_link(hw) : e1000_force_mac_fc(hw));

   324

   325

	clear_bit(__E1000_RESETTING, &adapter->flags);

   326

	return retval;

   327

}

   328

   329

static u32 e1000_get_msglevel(struct net_device *netdev)

   330

{

   331

	struct e1000_adapter *adapter = netdev_priv(netdev);

   332

	return adapter->msg_enable;

   333

}

   334

   335

static void e1000_set_msglevel(struct net_device *netdev, u32 data)

   336

{

   337

	struct e1000_adapter *adapter = netdev_priv(netdev);

   338

	adapter->msg_enable = data;

   339

}

   340

   341

static int e1000_get_regs_len(struct net_device *netdev)

   342

{

   343

#define E1000_REGS_LEN 32

   344

	return E1000_REGS_LEN * sizeof(u32);

   345

}

   346

   347

static void e1000_get_regs(struct net_device *netdev, struct ethtool_regs *regs,

   348

			   void *p)

   349

{

   350

	struct e1000_adapter *adapter = netdev_priv(netdev);

   351

	struct e1000_hw *hw = &adapter->hw;

   352

	u32 *regs_buff = p;

   353

	u16 phy_data;

   354

   355

	memset(p, 0, E1000_REGS_LEN * sizeof(u32));

   356

   357

	regs->version = (1 << 24) | (hw->revision_id << 16) | hw->device_id;

   358

   359

	regs_buff[0]  = er32(CTRL);

   360

	regs_buff[1]  = er32(STATUS);

   361

   362

	regs_buff[2]  = er32(RCTL);

   363

	regs_buff[3]  = er32(RDLEN);

   364

	regs_buff[4]  = er32(RDH);

   365

	regs_buff[5]  = er32(RDT);

   366

	regs_buff[6]  = er32(RDTR);

   367

   368

	regs_buff[7]  = er32(TCTL);

   369

	regs_buff[8]  = er32(TDLEN);

   370

	regs_buff[9]  = er32(TDH);

   371

	regs_buff[10] = er32(TDT);

   372

	regs_buff[11] = er32(TIDV);

   373

   374

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

   375

	if (hw->phy_type == e1000_phy_igp) {

   376

		e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT,

   377

				    IGP01E1000_PHY_AGC_A);

   378

		e1000_read_phy_reg(hw, IGP01E1000_PHY_AGC_A &

   379

				   IGP01E1000_PHY_PAGE_SELECT, &phy_data);

   380

		regs_buff[13] = (u32)phy_data; /* cable length */

   381

		e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT,

   382

				    IGP01E1000_PHY_AGC_B);

   383

		e1000_read_phy_reg(hw, IGP01E1000_PHY_AGC_B &

   384

				   IGP01E1000_PHY_PAGE_SELECT, &phy_data);

   385

		regs_buff[14] = (u32)phy_data; /* cable length */

   386

		e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT,

   387

				    IGP01E1000_PHY_AGC_C);

   388

		e1000_read_phy_reg(hw, IGP01E1000_PHY_AGC_C &

   389

				   IGP01E1000_PHY_PAGE_SELECT, &phy_data);

   390

		regs_buff[15] = (u32)phy_data; /* cable length */

   391

		e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT,

   392

				    IGP01E1000_PHY_AGC_D);

   393

		e1000_read_phy_reg(hw, IGP01E1000_PHY_AGC_D &

   394

				   IGP01E1000_PHY_PAGE_SELECT, &phy_data);

   395

		regs_buff[16] = (u32)phy_data; /* cable length */

   396

		regs_buff[17] = 0; /* extended 10bt distance (not needed) */

   397

		e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT, 0x0);

   398

		e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_STATUS &

   399

				   IGP01E1000_PHY_PAGE_SELECT, &phy_data);

   400

		regs_buff[18] = (u32)phy_data; /* cable polarity */

   401

		e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT,

   402

				    IGP01E1000_PHY_PCS_INIT_REG);

   403

		e1000_read_phy_reg(hw, IGP01E1000_PHY_PCS_INIT_REG &

   404

				   IGP01E1000_PHY_PAGE_SELECT, &phy_data);

   405

		regs_buff[19] = (u32)phy_data; /* cable polarity */

   406

		regs_buff[20] = 0; /* polarity correction enabled (always) */

   407

		regs_buff[22] = 0; /* phy receive errors (unavailable) */

   408

		regs_buff[23] = regs_buff[18]; /* mdix mode */

   409

		e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT, 0x0);

   410

	} else {

   411

		e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_STATUS, &phy_data);

   412

		regs_buff[13] = (u32)phy_data; /* cable length */

   413

		regs_buff[14] = 0;  /* Dummy (to align w/ IGP phy reg dump) */

   414

		regs_buff[15] = 0;  /* Dummy (to align w/ IGP phy reg dump) */

   415

		regs_buff[16] = 0;  /* Dummy (to align w/ IGP phy reg dump) */

   416

		e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);

   417

		regs_buff[17] = (u32)phy_data; /* extended 10bt distance */

   418

		regs_buff[18] = regs_buff[13]; /* cable polarity */

   419

		regs_buff[19] = 0;  /* Dummy (to align w/ IGP phy reg dump) */

   420

		regs_buff[20] = regs_buff[17]; /* polarity correction */

   421

		/* phy receive errors */

   422

		regs_buff[22] = adapter->phy_stats.receive_errors;

   423

		regs_buff[23] = regs_buff[13]; /* mdix mode */

   424

	}

   425

	regs_buff[21] = adapter->phy_stats.idle_errors;  /* phy idle errors */

   426

	e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_data);

   427

	regs_buff[24] = (u32)phy_data;  /* phy local receiver status */

   428

	regs_buff[25] = regs_buff[24];  /* phy remote receiver status */

   429

	if (hw->mac_type >= e1000_82540 &&

   430

	    hw->media_type == e1000_media_type_copper) {

   431

		regs_buff[26] = er32(MANC);

   432

	}

   433

}

   434

   435

static int e1000_get_eeprom_len(struct net_device *netdev)

   436

{

   437

	struct e1000_adapter *adapter = netdev_priv(netdev);

   438

	struct e1000_hw *hw = &adapter->hw;

   439

   440

	return hw->eeprom.word_size * 2;

   441

}

   442

   443

static int e1000_get_eeprom(struct net_device *netdev,

   444

			    struct ethtool_eeprom *eeprom, u8 *bytes)

   445

{

   446

	struct e1000_adapter *adapter = netdev_priv(netdev);

   447

	struct e1000_hw *hw = &adapter->hw;

   448

	u16 *eeprom_buff;

   449

	int first_word, last_word;

   450

	int ret_val = 0;

   451

	u16 i;

   452

   453

	if (eeprom->len == 0)

   454

		return -EINVAL;

   455

   456

	eeprom->magic = hw->vendor_id | (hw->device_id << 16);

   457

   458

	first_word = eeprom->offset >> 1;

   459

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

   460

   461

	eeprom_buff = kmalloc(sizeof(u16) *

   462

			(last_word - first_word + 1), GFP_KERNEL);

   463

	if (!eeprom_buff)

   464

		return -ENOMEM;

   465

   466

	if (hw->eeprom.type == e1000_eeprom_spi)

   467

		ret_val = e1000_read_eeprom(hw, first_word,

   468

					    last_word - first_word + 1,

   469

					    eeprom_buff);

   470

	else {

   471

		for (i = 0; i < last_word - first_word + 1; i++) {

   472

			ret_val = e1000_read_eeprom(hw, first_word + i, 1,

   473

						    &eeprom_buff[i]);

   474

			if (ret_val)

   475

				break;

   476

		}

   477

	}

   478

   479

	/* Device's eeprom is always little-endian, word addressable */

   480

	for (i = 0; i < last_word - first_word + 1; i++)

   481

		le16_to_cpus(&eeprom_buff[i]);

   482

   483

	memcpy(bytes, (u8 *)eeprom_buff + (eeprom->offset & 1),

   484

	       eeprom->len);

   485

	kfree(eeprom_buff);

   486

   487

	return ret_val;

   488

}

   489

   490

static int e1000_set_eeprom(struct net_device *netdev,

   491

			    struct ethtool_eeprom *eeprom, u8 *bytes)

   492

{

   493

	struct e1000_adapter *adapter = netdev_priv(netdev);

   494

	struct e1000_hw *hw = &adapter->hw;

   495

	u16 *eeprom_buff;

   496

	void *ptr;

   497

	int max_len, first_word, last_word, ret_val = 0;

   498

	u16 i;

   499

   500

	if (eeprom->len == 0)

   501

		return -EOPNOTSUPP;

   502

   503

	if (eeprom->magic != (hw->vendor_id | (hw->device_id << 16)))

   504

		return -EFAULT;

   505

   506

	max_len = hw->eeprom.word_size * 2;

   507

   508

	first_word = eeprom->offset >> 1;

   509

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

   510

	eeprom_buff = kmalloc(max_len, GFP_KERNEL);

   511

	if (!eeprom_buff)

   512

		return -ENOMEM;

   513

   514

	ptr = (void *)eeprom_buff;

   515

   516

	if (eeprom->offset & 1) {

   517

		/* need read/modify/write of first changed EEPROM word

   518

		 * only the second byte of the word is being modified

   519

		 */

   520

		ret_val = e1000_read_eeprom(hw, first_word, 1,

   521

					    &eeprom_buff[0]);

   522

		ptr++;

   523

	}

   524

	if (((eeprom->offset + eeprom->len) & 1) && (ret_val == 0)) {

   525

		/* need read/modify/write of last changed EEPROM word

   526

		 * only the first byte of the word is being modified

   527

		 */

   528

		ret_val = e1000_read_eeprom(hw, last_word, 1,

   529

		                  &eeprom_buff[last_word - first_word]);

   530

	}