1

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

     2

     3

     4

  Copyright(c) 1999 - 2006 Intel Corporation. All rights reserved.

     5

     6

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

     7

  under the terms of the GNU General Public License as published by the Free 

     8

  Software Foundation; either version 2 of the License, or (at your option) 

     9

  any later version.

    10

    11

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

    12

  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 

    13

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

    14

  more details.

    15

    16

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

    17

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

    18

  Temple Place - Suite 330, Boston, MA  02111-1307, USA.

    19

    20

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

    21

  file called LICENSE.

    22

    23

  Contact Information:

    24

  Linux NICS <linux.nics@intel.com>

    25

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

    26

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

    27

    28

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

    29

    30

/* ethtool support for e1000 */

    31

    32

#include "e1000.h"

    33

    34

#include <asm/uaccess.h>

    35

    36

struct e1000_stats {

    37

	char stat_string[ETH_GSTRING_LEN];

    38

	int sizeof_stat;

    39

	int stat_offset;

    40

};

    41

    42

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

    43

		      offsetof(struct e1000_adapter, m)

    44

static const struct e1000_stats e1000_gstrings_stats[] = {

    45

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

    46

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

    47

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

    48

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

    49

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

    50

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

    51

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

    52

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

    53

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

    54

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

    55

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

    56

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

    57

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

    58

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

    59

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

    60

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

    61

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

    62

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

    63

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

    64

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

    65

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

    66

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

    67

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

    68

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

    69

	{ "tx_timeout_count", E1000_STAT(tx_timeout_count) },

    70

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

    71

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

    72

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

    73

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

    74

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

    75

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

    76

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

    77

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

    78

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

    79

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

    80

	{ "rx_csum_offload_good", E1000_STAT(hw_csum_good) },

    81

	{ "rx_csum_offload_errors", E1000_STAT(hw_csum_err) },

    82

	{ "rx_header_split", E1000_STAT(rx_hdr_split) },

    83

	{ "alloc_rx_buff_failed", E1000_STAT(alloc_rx_buff_failed) },

    84

};

    85

    86

#define E1000_QUEUE_STATS_LEN 0

    87

#define E1000_GLOBAL_STATS_LEN	\

    88

	sizeof(e1000_gstrings_stats) / sizeof(struct e1000_stats)

    89

#define E1000_STATS_LEN (E1000_GLOBAL_STATS_LEN + E1000_QUEUE_STATS_LEN)

    90

static const char e1000_gstrings_test[][ETH_GSTRING_LEN] = {

    91

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

    92

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

    93

	"Link test   (on/offline)"

    94

};

    95

#define E1000_TEST_LEN sizeof(e1000_gstrings_test) / ETH_GSTRING_LEN

    96

    97

static int

    98

e1000_get_settings(struct net_device *netdev, struct ethtool_cmd *ecmd)

    99

{

   100

	struct e1000_adapter *adapter = netdev_priv(netdev);

   101

	struct e1000_hw *hw = &adapter->hw;

   102

   103

	if (hw->media_type == e1000_media_type_copper) {

   104

   105

		ecmd->supported = (SUPPORTED_10baseT_Half |

   106

		                   SUPPORTED_10baseT_Full |

   107

		                   SUPPORTED_100baseT_Half |

   108

		                   SUPPORTED_100baseT_Full |

   109

		                   SUPPORTED_1000baseT_Full|

   110

		                   SUPPORTED_Autoneg |

   111

		                   SUPPORTED_TP);

   112

		if (hw->phy_type == e1000_phy_ife)

   113

			ecmd->supported &= ~SUPPORTED_1000baseT_Full;

   114

		ecmd->advertising = ADVERTISED_TP;

   115

   116

		if (hw->autoneg == 1) {

   117

			ecmd->advertising |= ADVERTISED_Autoneg;

   118

   119

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

   120

   121

			ecmd->advertising |= hw->autoneg_advertised;

   122

		}

   123

   124

		ecmd->port = PORT_TP;

   125

		ecmd->phy_address = hw->phy_addr;

   126

   127

		if (hw->mac_type == e1000_82543)

   128

			ecmd->transceiver = XCVR_EXTERNAL;

   129

		else

   130

			ecmd->transceiver = XCVR_INTERNAL;

   131

   132

	} else {

   133

		ecmd->supported   = (SUPPORTED_1000baseT_Full |

   134

				     SUPPORTED_FIBRE |

   135

				     SUPPORTED_Autoneg);

   136

   137

		ecmd->advertising = (ADVERTISED_1000baseT_Full |

   138

				     ADVERTISED_FIBRE |

   139

				     ADVERTISED_Autoneg);

   140

   141

		ecmd->port = PORT_FIBRE;

   142

   143

		if (hw->mac_type >= e1000_82545)

   144

			ecmd->transceiver = XCVR_INTERNAL;

   145

		else

   146

			ecmd->transceiver = XCVR_EXTERNAL;

   147

	}

   148

   149

	if (netif_carrier_ok(adapter->netdev)) {

   150

   151

		e1000_get_speed_and_duplex(hw, &adapter->link_speed,

   152

		                                   &adapter->link_duplex);

   153

		ecmd->speed = adapter->link_speed;

   154

   155

		/* unfortunatly FULL_DUPLEX != DUPLEX_FULL

   156

		 *          and HALF_DUPLEX != DUPLEX_HALF */

   157

   158

		if (adapter->link_duplex == FULL_DUPLEX)

   159

			ecmd->duplex = DUPLEX_FULL;

   160

		else

   161

			ecmd->duplex = DUPLEX_HALF;

   162

	} else {

   163

		ecmd->speed = -1;

   164

		ecmd->duplex = -1;

   165

	}

   166

   167

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

   168

			 hw->autoneg) ? AUTONEG_ENABLE : AUTONEG_DISABLE;

   169

	return 0;

   170

}

   171

   172

static int

   173

e1000_set_settings(struct net_device *netdev, struct ethtool_cmd *ecmd)

   174

{

   175

	struct e1000_adapter *adapter = netdev_priv(netdev);

   176

	struct e1000_hw *hw = &adapter->hw;

   177

   178

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

   179

	 * cannot be changed */

   180

	if (e1000_check_phy_reset_block(hw)) {

   181

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

   182

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

   183

		return -EINVAL;

   184

	}

   185

   186

	if (ecmd->autoneg == AUTONEG_ENABLE) {

   187

		hw->autoneg = 1;

   188

		if (hw->media_type == e1000_media_type_fiber)

   189

			hw->autoneg_advertised = ADVERTISED_1000baseT_Full |

   190

				     ADVERTISED_FIBRE |

   191

				     ADVERTISED_Autoneg;

   192

		else

   193

			hw->autoneg_advertised = ADVERTISED_10baseT_Half |

   194

						  ADVERTISED_10baseT_Full |

   195

						  ADVERTISED_100baseT_Half |

   196

						  ADVERTISED_100baseT_Full |

   197

						  ADVERTISED_1000baseT_Full|

   198

						  ADVERTISED_Autoneg |

   199

						  ADVERTISED_TP;

   200

		ecmd->advertising = hw->autoneg_advertised;

   201

	} else

   202

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

   203

			return -EINVAL;

   204

   205

	/* reset the link */

   206

   207

	if (netif_running(adapter->netdev))

   208

		e1000_reinit_locked(adapter);

   209

	else

   210

		e1000_reset(adapter);

   211

   212

	return 0;

   213

}

   214

   215

static void

   216

e1000_get_pauseparam(struct net_device *netdev,

   217

                     struct ethtool_pauseparam *pause)

   218

{

   219

	struct e1000_adapter *adapter = netdev_priv(netdev);

   220

	struct e1000_hw *hw = &adapter->hw;

   221

   222

	pause->autoneg =

   223

		(adapter->fc_autoneg ? AUTONEG_ENABLE : AUTONEG_DISABLE);

   224

   225

	if (hw->fc == e1000_fc_rx_pause)

   226

		pause->rx_pause = 1;

   227

	else if (hw->fc == e1000_fc_tx_pause)

   228

		pause->tx_pause = 1;

   229

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

   230

		pause->rx_pause = 1;

   231

		pause->tx_pause = 1;

   232

	}

   233

}

   234

   235

static int

   236

e1000_set_pauseparam(struct net_device *netdev,

   237

                     struct ethtool_pauseparam *pause)

   238

{

   239

	struct e1000_adapter *adapter = netdev_priv(netdev);

   240

	struct e1000_hw *hw = &adapter->hw;

   241

   242

	adapter->fc_autoneg = pause->autoneg;

   243

   244

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

   245

		hw->fc = e1000_fc_full;

   246

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

   247

		hw->fc = e1000_fc_rx_pause;

   248

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

   249

		hw->fc = e1000_fc_tx_pause;

   250

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

   251

		hw->fc = e1000_fc_none;

   252

   253

	hw->original_fc = hw->fc;

   254

   255

	if (adapter->fc_autoneg == AUTONEG_ENABLE) {

   256

		if (netif_running(adapter->netdev))

   257

			e1000_reinit_locked(adapter);

   258

		else

   259

			e1000_reset(adapter);

   260

	} else

   261

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

   262

			e1000_setup_link(hw) : e1000_force_mac_fc(hw));

   263

   264

	return 0;

   265

}

   266

   267

static uint32_t

   268

e1000_get_rx_csum(struct net_device *netdev)

   269

{

   270

	struct e1000_adapter *adapter = netdev_priv(netdev);

   271

	return adapter->rx_csum;

   272

}

   273

   274

static int

   275

e1000_set_rx_csum(struct net_device *netdev, uint32_t data)

   276

{

   277

	struct e1000_adapter *adapter = netdev_priv(netdev);

   278

	adapter->rx_csum = data;

   279

   280

	if (netif_running(netdev))

   281

		e1000_reinit_locked(adapter);

   282

	else

   283

		e1000_reset(adapter);

   284

	return 0;

   285

}

   286

   287

static uint32_t

   288

e1000_get_tx_csum(struct net_device *netdev)

   289

{

   290

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

   291

}

   292

   293

static int

   294

e1000_set_tx_csum(struct net_device *netdev, uint32_t data)

   295

{

   296

	struct e1000_adapter *adapter = netdev_priv(netdev);

   297

   298

	if (adapter->hw.mac_type < e1000_82543) {

   299

		if (!data)

   300

			return -EINVAL;

   301

		return 0;

   302

	}

   303

   304

	if (data)

   305

		netdev->features |= NETIF_F_HW_CSUM;

   306

	else

   307

		netdev->features &= ~NETIF_F_HW_CSUM;

   308

   309

	return 0;

   310

}

   311

   312

#ifdef NETIF_F_TSO

   313

static int

   314

e1000_set_tso(struct net_device *netdev, uint32_t data)

   315

{

   316

	struct e1000_adapter *adapter = netdev_priv(netdev);

   317

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

   318

	    (adapter->hw.mac_type == e1000_82547))

   319

		return data ? -EINVAL : 0;

   320

   321

	if (data)

   322

		netdev->features |= NETIF_F_TSO;

   323

	else

   324

		netdev->features &= ~NETIF_F_TSO;

   325

   326

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

   327

	adapter->tso_force = TRUE;

   328

	return 0;

   329

}

   330

#endif /* NETIF_F_TSO */

   331

   332

static uint32_t

   333

e1000_get_msglevel(struct net_device *netdev)

   334

{

   335

	struct e1000_adapter *adapter = netdev_priv(netdev);

   336

	return adapter->msg_enable;

   337

}

   338

   339

static void

   340

e1000_set_msglevel(struct net_device *netdev, uint32_t data)

   341

{

   342

	struct e1000_adapter *adapter = netdev_priv(netdev);

   343

	adapter->msg_enable = data;

   344

}

   345

   346

static int

   347

e1000_get_regs_len(struct net_device *netdev)

   348

{

   349

#define E1000_REGS_LEN 32

   350

	return E1000_REGS_LEN * sizeof(uint32_t);

   351

}

   352

   353

static void

   354

e1000_get_regs(struct net_device *netdev,

   355

	       struct ethtool_regs *regs, void *p)

   356

{

   357

	struct e1000_adapter *adapter = netdev_priv(netdev);

   358

	struct e1000_hw *hw = &adapter->hw;

   359

	uint32_t *regs_buff = p;

   360

	uint16_t phy_data;

   361

   362

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

   363

   364

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

   365

   366

	regs_buff[0]  = E1000_READ_REG(hw, CTRL);

   367

	regs_buff[1]  = E1000_READ_REG(hw, STATUS);

   368

   369

	regs_buff[2]  = E1000_READ_REG(hw, RCTL);

   370

	regs_buff[3]  = E1000_READ_REG(hw, RDLEN);

   371

	regs_buff[4]  = E1000_READ_REG(hw, RDH);

   372

	regs_buff[5]  = E1000_READ_REG(hw, RDT);

   373

	regs_buff[6]  = E1000_READ_REG(hw, RDTR);

   374

   375

	regs_buff[7]  = E1000_READ_REG(hw, TCTL);

   376

	regs_buff[8]  = E1000_READ_REG(hw, TDLEN);

   377

	regs_buff[9]  = E1000_READ_REG(hw, TDH);

   378

	regs_buff[10] = E1000_READ_REG(hw, TDT);

   379

	regs_buff[11] = E1000_READ_REG(hw, TIDV);

   380

   381

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

   382

	if (hw->phy_type == e1000_phy_igp) {

   383

		e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT,

   384

				    IGP01E1000_PHY_AGC_A);

   385

		e1000_read_phy_reg(hw, IGP01E1000_PHY_AGC_A &

   386

				   IGP01E1000_PHY_PAGE_SELECT, &phy_data);

   387

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

   388

		e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT,

   389

				    IGP01E1000_PHY_AGC_B);

   390

		e1000_read_phy_reg(hw, IGP01E1000_PHY_AGC_B &

   391

				   IGP01E1000_PHY_PAGE_SELECT, &phy_data);

   392

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

   393

		e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT,

   394

				    IGP01E1000_PHY_AGC_C);

   395

		e1000_read_phy_reg(hw, IGP01E1000_PHY_AGC_C &

   396

				   IGP01E1000_PHY_PAGE_SELECT, &phy_data);

   397

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

   398

		e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT,

   399

				    IGP01E1000_PHY_AGC_D);

   400

		e1000_read_phy_reg(hw, IGP01E1000_PHY_AGC_D &

   401

				   IGP01E1000_PHY_PAGE_SELECT, &phy_data);

   402

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

   403

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

   404

		e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT, 0x0);

   405

		e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_STATUS &

   406

				   IGP01E1000_PHY_PAGE_SELECT, &phy_data);

   407

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

   408

		e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT,

   409

				    IGP01E1000_PHY_PCS_INIT_REG);

   410

		e1000_read_phy_reg(hw, IGP01E1000_PHY_PCS_INIT_REG &

   411

				   IGP01E1000_PHY_PAGE_SELECT, &phy_data);

   412

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

   413

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

   414

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

   415

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

   416

		e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT, 0x0);

   417

	} else {

   418

        	e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_STATUS, &phy_data);

   419

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

   420

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

   421

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

   422

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

   423

        	e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);

   424

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

   425

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

   426

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

   427

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

   428

		/* phy receive errors */

   429

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

   430

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

   431

	}

   432

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

   433

	e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_data);

   434

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

   435

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

   436

	if (hw->mac_type >= e1000_82540 &&

   437

	   hw->media_type == e1000_media_type_copper) {

   438

		regs_buff[26] = E1000_READ_REG(hw, MANC);

   439

	}

   440

}

   441

   442

static int

   443

e1000_get_eeprom_len(struct net_device *netdev)

   444

{

   445

	struct e1000_adapter *adapter = netdev_priv(netdev);

   446

	return adapter->hw.eeprom.word_size * 2;

   447

}

   448

   449

static int

   450

e1000_get_eeprom(struct net_device *netdev,

   451

                      struct ethtool_eeprom *eeprom, uint8_t *bytes)

   452

{

   453

	struct e1000_adapter *adapter = netdev_priv(netdev);

   454

	struct e1000_hw *hw = &adapter->hw;

   455

	uint16_t *eeprom_buff;

   456

	int first_word, last_word;

   457

	int ret_val = 0;

   458

	uint16_t i;

   459

   460

	if (eeprom->len == 0)

   461

		return -EINVAL;

   462

   463

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

   464

   465

	first_word = eeprom->offset >> 1;

   466

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

   467

   468

	eeprom_buff = kmalloc(sizeof(uint16_t) *

   469

			(last_word - first_word + 1), GFP_KERNEL);

   470

	if (!eeprom_buff)

   471

		return -ENOMEM;

   472

   473

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

   474

		ret_val = e1000_read_eeprom(hw, first_word,

   475

					    last_word - first_word + 1,

   476

					    eeprom_buff);

   477

	else {

   478

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

   479

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

   480

							&eeprom_buff[i])))

   481

				break;

   482

	}

   483

   484

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

   485

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

   486

		le16_to_cpus(&eeprom_buff[i]);

   487

   488

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

   489

			eeprom->len);

   490

	kfree(eeprom_buff);

   491

   492

	return ret_val;

   493

}

   494

   495

static int

   496

e1000_set_eeprom(struct net_device *netdev,

   497

                      struct ethtool_eeprom *eeprom, uint8_t *bytes)

   498

{

   499

	struct e1000_adapter *adapter = netdev_priv(netdev);

   500

	struct e1000_hw *hw = &adapter->hw;

   501

	uint16_t *eeprom_buff;

   502

	void *ptr;

   503

	int max_len, first_word, last_word, ret_val = 0;

   504

	uint16_t i;

   505

   506

	if (eeprom->len == 0)

   507

		return -EOPNOTSUPP;

   508

   509

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

   510

		return -EFAULT;

   511

   512

	max_len = hw->eeprom.word_size * 2;

   513

   514

	first_word = eeprom->offset >> 1;

   515

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

   516

	eeprom_buff = kmalloc(max_len, GFP_KERNEL);

   517

	if (!eeprom_buff)

   518

		return -ENOMEM;

   519

   520

	ptr = (void *)eeprom_buff;

   521

   522

	if (eeprom->offset & 1) {

   523

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

   524

		/* only the second byte of the word is being modified */

   525

		ret_val = e1000_read_eeprom(hw, first_word, 1,

   526

					    &eeprom_buff[0]);

   527

		ptr++;

   528

	}

   529

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

   530