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.h"

    32

#include <asm/uaccess.h>

    33

    34

struct e1000_stats {

    35

	char stat_string[ETH_GSTRING_LEN];

    36

	int sizeof_stat;

    37

	int stat_offset;

    38

};

    39

    40

#define E1000_STAT(m) FIELD_SIZEOF(struct e1000_adapter, m), \

    41

		      offsetof(struct e1000_adapter, m)

    42

static const struct e1000_stats e1000_gstrings_stats[] = {

    43

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

    44

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

    45

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

    46

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

    47

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

    48

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

    49

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

    50

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

    51

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

    52

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

    53

	{ "tx_dropped", E1000_STAT(net_stats.tx_dropped) },

    54

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

    55

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

    56

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

    57

	{ "rx_over_errors", E1000_STAT(net_stats.rx_over_errors) },

    58

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

    59

	{ "rx_frame_errors", E1000_STAT(net_stats.rx_frame_errors) },

    60

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

    61

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

    62

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

    63

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

    64

	{ "tx_fifo_errors", E1000_STAT(net_stats.tx_fifo_errors) },

    65

	{ "tx_heartbeat_errors", E1000_STAT(net_stats.tx_heartbeat_errors) },

    66

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

    67

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

    68

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

    69

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

    70

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

    71

	{ "tx_timeout_count", E1000_STAT(tx_timeout_count) },

    72

	{ "tx_restart_queue", E1000_STAT(restart_queue) },

    73

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

    74

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

    75

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

    76

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

    77

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

    78

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

    79

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

    80

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

    81

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

    82

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

    83

	{ "rx_csum_offload_good", E1000_STAT(hw_csum_good) },

    84

	{ "rx_csum_offload_errors", E1000_STAT(hw_csum_err) },

    85

	{ "rx_header_split", E1000_STAT(rx_hdr_split) },

    86

	{ "alloc_rx_buff_failed", E1000_STAT(alloc_rx_buff_failed) },

    87

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

    88

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

    89

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

    90

};

    91

    92

#define E1000_QUEUE_STATS_LEN 0

    93

#define E1000_GLOBAL_STATS_LEN ARRAY_SIZE(e1000_gstrings_stats)

    94

#define E1000_STATS_LEN (E1000_GLOBAL_STATS_LEN + E1000_QUEUE_STATS_LEN)

    95

static const char e1000_gstrings_test[][ETH_GSTRING_LEN] = {

    96

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

    97

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

    98

	"Link test   (on/offline)"

    99

};

   100

#define E1000_TEST_LEN	ARRAY_SIZE(e1000_gstrings_test)

   101

   102

static int e1000_get_settings(struct net_device *netdev,

   103

			      struct ethtool_cmd *ecmd)

   104

{

   105

	struct e1000_adapter *adapter = netdev_priv(netdev);

   106

	struct e1000_hw *hw = &adapter->hw;

   107

   108

	if (hw->media_type == e1000_media_type_copper) {

   109

   110

		ecmd->supported = (SUPPORTED_10baseT_Half |

   111

		                   SUPPORTED_10baseT_Full |

   112

		                   SUPPORTED_100baseT_Half |

   113

		                   SUPPORTED_100baseT_Full |

   114

		                   SUPPORTED_1000baseT_Full|

   115

		                   SUPPORTED_Autoneg |

   116

		                   SUPPORTED_TP);

   117

		if (hw->phy_type == e1000_phy_ife)

   118

			ecmd->supported &= ~SUPPORTED_1000baseT_Full;

   119

		ecmd->advertising = ADVERTISED_TP;

   120

   121

		if (hw->autoneg == 1) {

   122

			ecmd->advertising |= ADVERTISED_Autoneg;

   123

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

   124

			ecmd->advertising |= hw->autoneg_advertised;

   125

		}

   126

   127

		ecmd->port = PORT_TP;

   128

		ecmd->phy_address = hw->phy_addr;

   129

   130

		if (hw->mac_type == e1000_82543)

   131

			ecmd->transceiver = XCVR_EXTERNAL;

   132

		else

   133

			ecmd->transceiver = XCVR_INTERNAL;

   134

   135

	} else {

   136

		ecmd->supported   = (SUPPORTED_1000baseT_Full |

   137

				     SUPPORTED_FIBRE |

   138

				     SUPPORTED_Autoneg);

   139

   140

		ecmd->advertising = (ADVERTISED_1000baseT_Full |

   141

				     ADVERTISED_FIBRE |

   142

				     ADVERTISED_Autoneg);

   143

   144

		ecmd->port = PORT_FIBRE;

   145

   146

		if (hw->mac_type >= e1000_82545)

   147

			ecmd->transceiver = XCVR_INTERNAL;

   148

		else

   149

			ecmd->transceiver = XCVR_EXTERNAL;

   150

	}

   151

   152

	if (er32(STATUS) & E1000_STATUS_LU) {

   153

   154

		e1000_get_speed_and_duplex(hw, &adapter->link_speed,

   155

		                                   &adapter->link_duplex);

   156

		ecmd->speed = adapter->link_speed;

   157

   158

		/* unfortunatly FULL_DUPLEX != DUPLEX_FULL

   159

		 *          and HALF_DUPLEX != DUPLEX_HALF */

   160

   161

		if (adapter->link_duplex == FULL_DUPLEX)

   162

			ecmd->duplex = DUPLEX_FULL;

   163

		else

   164

			ecmd->duplex = DUPLEX_HALF;

   165

	} else {

   166

		ecmd->speed = -1;

   167

		ecmd->duplex = -1;

   168

	}

   169

   170

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

   171

			 hw->autoneg) ? AUTONEG_ENABLE : AUTONEG_DISABLE;

   172

	return 0;

   173

}

   174

   175

static int e1000_set_settings(struct net_device *netdev,

   176

			      struct ethtool_cmd *ecmd)

   177

{

   178

	struct e1000_adapter *adapter = netdev_priv(netdev);

   179

	struct e1000_hw *hw = &adapter->hw;

   180

   181

	/* When SoL/IDER sessions are active, autoneg/speed/duplex

   182

	 * cannot be changed */

   183

	if (e1000_check_phy_reset_block(hw)) {

   184

		DPRINTK(DRV, ERR, "Cannot change link characteristics "

   185

		        "when SoL/IDER is active.\n");

   186

		return -EINVAL;

   187

	}

   188

   189

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

   190

		msleep(1);

   191

   192

	if (ecmd->autoneg == AUTONEG_ENABLE) {

   193

		hw->autoneg = 1;

   194

		if (hw->media_type == e1000_media_type_fiber)

   195

			hw->autoneg_advertised = ADVERTISED_1000baseT_Full |

   196

				     ADVERTISED_FIBRE |

   197

				     ADVERTISED_Autoneg;

   198

		else

   199

			hw->autoneg_advertised = ecmd->advertising |

   200

			                         ADVERTISED_TP |

   201

			                         ADVERTISED_Autoneg;

   202

		ecmd->advertising = hw->autoneg_advertised;

   203

	} else

   204

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

   205

			clear_bit(__E1000_RESETTING, &adapter->flags);

   206

			return -EINVAL;

   207

		}

   208

   209

	/* reset the link */

   210

   211

	if (netif_running(adapter->netdev)) {

   212

		e1000_down(adapter);

   213

		e1000_up(adapter);

   214

	} else

   215

		e1000_reset(adapter);

   216

   217

	clear_bit(__E1000_RESETTING, &adapter->flags);

   218

	return 0;

   219

}

   220

   221

static void e1000_get_pauseparam(struct net_device *netdev,

   222

				 struct ethtool_pauseparam *pause)

   223

{

   224

	struct e1000_adapter *adapter = netdev_priv(netdev);

   225

	struct e1000_hw *hw = &adapter->hw;

   226

   227

	pause->autoneg =

   228

		(adapter->fc_autoneg ? AUTONEG_ENABLE : AUTONEG_DISABLE);

   229

   230

	if (hw->fc == E1000_FC_RX_PAUSE)

   231

		pause->rx_pause = 1;

   232

	else if (hw->fc == E1000_FC_TX_PAUSE)

   233

		pause->tx_pause = 1;

   234

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

   235

		pause->rx_pause = 1;

   236

		pause->tx_pause = 1;

   237

	}

   238

}

   239

   240

static int e1000_set_pauseparam(struct net_device *netdev,

   241

				struct ethtool_pauseparam *pause)

   242

{

   243

	struct e1000_adapter *adapter = netdev_priv(netdev);

   244

	struct e1000_hw *hw = &adapter->hw;

   245

	int retval = 0;

   246

   247

	adapter->fc_autoneg = pause->autoneg;

   248

   249

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

   250

		msleep(1);

   251

   252

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

   253

		hw->fc = E1000_FC_FULL;

   254

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

   255

		hw->fc = E1000_FC_RX_PAUSE;

   256

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

   257

		hw->fc = E1000_FC_TX_PAUSE;

   258

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

   259

		hw->fc = E1000_FC_NONE;

   260

   261

	hw->original_fc = hw->fc;

   262

   263

	if (adapter->fc_autoneg == AUTONEG_ENABLE) {

   264

		if (netif_running(adapter->netdev)) {

   265

			e1000_down(adapter);

   266

			e1000_up(adapter);

   267

		} else

   268

			e1000_reset(adapter);

   269

	} else

   270

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

   271

			  e1000_setup_link(hw) : e1000_force_mac_fc(hw));

   272

   273

	clear_bit(__E1000_RESETTING, &adapter->flags);

   274

	return retval;

   275

}

   276

   277

static u32 e1000_get_rx_csum(struct net_device *netdev)

   278

{

   279

	struct e1000_adapter *adapter = netdev_priv(netdev);

   280

	return adapter->rx_csum;

   281

}

   282

   283

static int e1000_set_rx_csum(struct net_device *netdev, u32 data)

   284

{

   285

	struct e1000_adapter *adapter = netdev_priv(netdev);

   286

	adapter->rx_csum = data;

   287

   288

	if (netif_running(netdev))

   289

		e1000_reinit_locked(adapter);

   290

	else

   291

		e1000_reset(adapter);

   292

	return 0;

   293

}

   294

   295

static u32 e1000_get_tx_csum(struct net_device *netdev)

   296

{

   297

	return (netdev->features & NETIF_F_HW_CSUM) != 0;

   298

}

   299

   300

static int e1000_set_tx_csum(struct net_device *netdev, u32 data)

   301

{

   302

	struct e1000_adapter *adapter = netdev_priv(netdev);

   303

	struct e1000_hw *hw = &adapter->hw;

   304

   305

	if (hw->mac_type < e1000_82543) {

   306

		if (!data)

   307

			return -EINVAL;

   308

		return 0;

   309

	}

   310

   311

	if (data)

   312

		netdev->features |= NETIF_F_HW_CSUM;

   313

	else

   314

		netdev->features &= ~NETIF_F_HW_CSUM;

   315

   316

	return 0;

   317

}

   318

   319

static int e1000_set_tso(struct net_device *netdev, u32 data)

   320

{

   321

	struct e1000_adapter *adapter = netdev_priv(netdev);

   322

	struct e1000_hw *hw = &adapter->hw;

   323

   324

	if ((hw->mac_type < e1000_82544) ||

   325

	    (hw->mac_type == e1000_82547))

   326

		return data ? -EINVAL : 0;

   327

   328

	if (data)

   329

		netdev->features |= NETIF_F_TSO;

   330

	else

   331

		netdev->features &= ~NETIF_F_TSO;

   332

   333

	if (data && (adapter->hw.mac_type > e1000_82547_rev_2))

   334

		netdev->features |= NETIF_F_TSO6;

   335

	else

   336

		netdev->features &= ~NETIF_F_TSO6;

   337

   338

	DPRINTK(PROBE, INFO, "TSO is %s\n", data ? "Enabled" : "Disabled");

   339

	adapter->tso_force = true;

   340

	return 0;

   341

}

   342

   343

static u32 e1000_get_msglevel(struct net_device *netdev)

   344

{

   345

	struct e1000_adapter *adapter = netdev_priv(netdev);

   346

	return adapter->msg_enable;

   347

}

   348

   349

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

   350

{

   351

	struct e1000_adapter *adapter = netdev_priv(netdev);

   352

	adapter->msg_enable = data;

   353

}

   354

   355

static int e1000_get_regs_len(struct net_device *netdev)

   356

{

   357

#define E1000_REGS_LEN 32

   358

	return E1000_REGS_LEN * sizeof(u32);

   359

}

   360

   361

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

   362

			   void *p)

   363

{

   364

	struct e1000_adapter *adapter = netdev_priv(netdev);

   365

	struct e1000_hw *hw = &adapter->hw;

   366

	u32 *regs_buff = p;

   367

	u16 phy_data;

   368

   369

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

   370

   371

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

   372

   373

	regs_buff[0]  = er32(CTRL);

   374

	regs_buff[1]  = er32(STATUS);

   375

   376

	regs_buff[2]  = er32(RCTL);

   377

	regs_buff[3]  = er32(RDLEN);

   378

	regs_buff[4]  = er32(RDH);

   379

	regs_buff[5]  = er32(RDT);

   380

	regs_buff[6]  = er32(RDTR);

   381

   382

	regs_buff[7]  = er32(TCTL);

   383

	regs_buff[8]  = er32(TDLEN);

   384

	regs_buff[9]  = er32(TDH);

   385

	regs_buff[10] = er32(TDT);

   386

	regs_buff[11] = er32(TIDV);

   387

   388

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

   389

	if (hw->phy_type == e1000_phy_igp) {

   390

		e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT,

   391

				    IGP01E1000_PHY_AGC_A);

   392

		e1000_read_phy_reg(hw, IGP01E1000_PHY_AGC_A &

   393

				   IGP01E1000_PHY_PAGE_SELECT, &phy_data);

   394

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

   395

		e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT,

   396

				    IGP01E1000_PHY_AGC_B);

   397

		e1000_read_phy_reg(hw, IGP01E1000_PHY_AGC_B &

   398

				   IGP01E1000_PHY_PAGE_SELECT, &phy_data);

   399

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

   400

		e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT,

   401

				    IGP01E1000_PHY_AGC_C);

   402

		e1000_read_phy_reg(hw, IGP01E1000_PHY_AGC_C &

   403

				   IGP01E1000_PHY_PAGE_SELECT, &phy_data);

   404

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

   405

		e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT,

   406

				    IGP01E1000_PHY_AGC_D);

   407

		e1000_read_phy_reg(hw, IGP01E1000_PHY_AGC_D &

   408

				   IGP01E1000_PHY_PAGE_SELECT, &phy_data);

   409

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

   410

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

   411

		e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT, 0x0);

   412

		e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_STATUS &

   413

				   IGP01E1000_PHY_PAGE_SELECT, &phy_data);

   414

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

   415

		e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT,

   416

				    IGP01E1000_PHY_PCS_INIT_REG);

   417

		e1000_read_phy_reg(hw, IGP01E1000_PHY_PCS_INIT_REG &

   418

				   IGP01E1000_PHY_PAGE_SELECT, &phy_data);

   419

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

   420

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

   421

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

   422

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

   423

		e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT, 0x0);

   424

	} else {

   425

		e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_STATUS, &phy_data);

   426

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

   427

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

   428

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

   429

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

   430

		e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);

   431

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

   432

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

   433

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

   434

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

   435

		/* phy receive errors */

   436

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

   437

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

   438

	}

   439

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

   440

	e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_data);

   441

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

   442

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

   443

	if (hw->mac_type >= e1000_82540 &&

   444

	    hw->mac_type < e1000_82571 &&

   445

	    hw->media_type == e1000_media_type_copper) {

   446

		regs_buff[26] = er32(MANC);

   447

	}

   448

}

   449

   450

static int e1000_get_eeprom_len(struct net_device *netdev)

   451

{

   452

	struct e1000_adapter *adapter = netdev_priv(netdev);

   453

	struct e1000_hw *hw = &adapter->hw;

   454

   455

	return hw->eeprom.word_size * 2;

   456

}

   457

   458

static int e1000_get_eeprom(struct net_device *netdev,

   459

			    struct ethtool_eeprom *eeprom, u8 *bytes)

   460

{

   461

	struct e1000_adapter *adapter = netdev_priv(netdev);

   462

	struct e1000_hw *hw = &adapter->hw;

   463

	u16 *eeprom_buff;

   464

	int first_word, last_word;

   465

	int ret_val = 0;

   466

	u16 i;

   467

   468

	if (eeprom->len == 0)

   469

		return -EINVAL;

   470

   471

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

   472

   473

	first_word = eeprom->offset >> 1;

   474

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

   475

   476

	eeprom_buff = kmalloc(sizeof(u16) *

   477

			(last_word - first_word + 1), GFP_KERNEL);

   478

	if (!eeprom_buff)

   479

		return -ENOMEM;

   480

   481

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

   482

		ret_val = e1000_read_eeprom(hw, first_word,

   483

					    last_word - first_word + 1,

   484

					    eeprom_buff);

   485

	else {

   486

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

   487

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

   488

						    &eeprom_buff[i]);

   489

			if (ret_val)

   490

				break;

   491

		}

   492

	}

   493

   494

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

   495

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

   496

		le16_to_cpus(&eeprom_buff[i]);

   497

   498

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

   499

			eeprom->len);

   500

	kfree(eeprom_buff);

   501

   502

	return ret_val;

   503

}

   504

   505

static int e1000_set_eeprom(struct net_device *netdev,

   506

			    struct ethtool_eeprom *eeprom, u8 *bytes)

   507

{

   508

	struct e1000_adapter *adapter = netdev_priv(netdev);

   509

	struct e1000_hw *hw = &adapter->hw;

   510

	u16 *eeprom_buff;

   511

	void *ptr;

   512

	int max_len, first_word, last_word, ret_val = 0;

   513

	u16 i;

   514

   515

	if (eeprom->len == 0)

   516

		return -EOPNOTSUPP;

   517

   518

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

   519

		return -EFAULT;

   520

   521

	max_len = hw->eeprom.word_size * 2;

   522

   523

	first_word = eeprom->offset >> 1;

   524

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

   525

	eeprom_buff = kmalloc(max_len, GFP_KERNEL);

   526

	if (!eeprom_buff)

   527

		return -ENOMEM;

   528

   529

	ptr = (void *)eeprom_buff;