1

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

     2

     3

  Intel PRO/1000 Linux driver

     4

  Copyright(c) 1999 - 2009 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 <linux/netdevice.h>

    32

#include <linux/ethtool.h>

    33

#include <linux/pci.h>

    34

#include <linux/slab.h>

    35

#include <linux/delay.h>

    36

    37

#include "e1000.h"

    38

    39

enum {NETDEV_STATS, E1000_STATS};

    40

    41

struct e1000_stats {

    42

	char stat_string[ETH_GSTRING_LEN];

    43

	int type;

    44

	int sizeof_stat;

    45

	int stat_offset;

    46

};

    47

    48

#define E1000_STAT(m)		E1000_STATS, \

    49

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

    50

		      		offsetof(struct e1000_adapter, m)

    51

#define E1000_NETDEV_STAT(m)	NETDEV_STATS, \

    52

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

    53

				offsetof(struct net_device, m)

    54

    55

static const struct e1000_stats e1000_gstrings_stats[] = {

    56

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

    57

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

    58

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

    59

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

    60

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

    61

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

    62

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

    63

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

    64

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

    65

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

    66

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

    67

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

    68

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

    69

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

    70

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

    71

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

    72

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

    73

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

    74

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

    75

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

    76

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

    77

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

    78

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

    79

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

    80

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

    81

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

    82

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

    83

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

    84

	{ "tx_timeout_count", E1000_STAT(tx_timeout_count) },

    85

	{ "tx_restart_queue", E1000_STAT(restart_queue) },

    86

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

    87

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

    88

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

    89

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

    90

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

    91

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

    92

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

    93

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

    94

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

    95

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

    96

	{ "rx_csum_offload_good", E1000_STAT(hw_csum_good) },

    97

	{ "rx_csum_offload_errors", E1000_STAT(hw_csum_err) },

    98

	{ "rx_header_split", E1000_STAT(rx_hdr_split) },

    99

	{ "alloc_rx_buff_failed", E1000_STAT(alloc_rx_buff_failed) },

   100

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

   101

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

   102

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

   103

	{ "rx_dma_failed", E1000_STAT(rx_dma_failed) },

   104

	{ "tx_dma_failed", E1000_STAT(tx_dma_failed) },

   105

};

   106

   107

#define E1000_GLOBAL_STATS_LEN	ARRAY_SIZE(e1000_gstrings_stats)

   108

#define E1000_STATS_LEN (E1000_GLOBAL_STATS_LEN)

   109

static const char e1000_gstrings_test[][ETH_GSTRING_LEN] = {

   110

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

   111

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

   112

	"Link test   (on/offline)"

   113

};

   114

#define E1000_TEST_LEN ARRAY_SIZE(e1000_gstrings_test)

   115

   116

static int e1000_get_settings(struct net_device *netdev,

   117

			      struct ethtool_cmd *ecmd)

   118

{

   119

	struct e1000_adapter *adapter = netdev_priv(netdev);

   120

	struct e1000_hw *hw = &adapter->hw;

   121

	u32 status;

   122

   123

	if (hw->phy.media_type == e1000_media_type_copper) {

   124

   125

		ecmd->supported = (SUPPORTED_10baseT_Half |

   126

				   SUPPORTED_10baseT_Full |

   127

				   SUPPORTED_100baseT_Half |

   128

				   SUPPORTED_100baseT_Full |

   129

				   SUPPORTED_1000baseT_Full |

   130

				   SUPPORTED_Autoneg |

   131

				   SUPPORTED_TP);

   132

		if (hw->phy.type == e1000_phy_ife)

   133

			ecmd->supported &= ~SUPPORTED_1000baseT_Full;

   134

		ecmd->advertising = ADVERTISED_TP;

   135

   136

		if (hw->mac.autoneg == 1) {

   137

			ecmd->advertising |= ADVERTISED_Autoneg;

   138

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

   139

			ecmd->advertising |= hw->phy.autoneg_advertised;

   140

		}

   141

   142

		ecmd->port = PORT_TP;

   143

		ecmd->phy_address = hw->phy.addr;

   144

		ecmd->transceiver = XCVR_INTERNAL;

   145

   146

	} else {

   147

		ecmd->supported   = (SUPPORTED_1000baseT_Full |

   148

				     SUPPORTED_FIBRE |

   149

				     SUPPORTED_Autoneg);

   150

   151

		ecmd->advertising = (ADVERTISED_1000baseT_Full |

   152

				     ADVERTISED_FIBRE |

   153

				     ADVERTISED_Autoneg);

   154

   155

		ecmd->port = PORT_FIBRE;

   156

		ecmd->transceiver = XCVR_EXTERNAL;

   157

	}

   158

   159

	status = er32(STATUS);

   160

	if (status & E1000_STATUS_LU) {

   161

		if (status & E1000_STATUS_SPEED_1000)

   162

			ecmd->speed = 1000;

   163

		else if (status & E1000_STATUS_SPEED_100)

   164

			ecmd->speed = 100;

   165

		else

   166

			ecmd->speed = 10;

   167

   168

		if (status & E1000_STATUS_FD)

   169

			ecmd->duplex = DUPLEX_FULL;

   170

		else

   171

			ecmd->duplex = DUPLEX_HALF;

   172

	} else {

   173

		ecmd->speed = -1;

   174

		ecmd->duplex = -1;

   175

	}

   176

   177

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

   178

			 hw->mac.autoneg) ? AUTONEG_ENABLE : AUTONEG_DISABLE;

   179

   180

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

   181

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

   182

	    !hw->mac.get_link_status)

   183

		ecmd->eth_tp_mdix = hw->phy.is_mdix ? ETH_TP_MDI_X :

   184

		                                      ETH_TP_MDI;

   185

	else

   186

		ecmd->eth_tp_mdix = ETH_TP_MDI_INVALID;

   187

   188

	return 0;

   189

}

   190

   191

static u32 e1000_get_link(struct net_device *netdev)

   192

{

   193

	struct e1000_adapter *adapter = netdev_priv(netdev);

   194

	struct e1000_mac_info *mac = &adapter->hw.mac;

   195

   196

	/*

   197

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

   198

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

   199

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

   200

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

   201

	 * stale link state from the driver.

   202

	 */

   203

	if (!netif_carrier_ok(netdev))

   204

		mac->get_link_status = 1;

   205

   206

	return e1000e_has_link(adapter);

   207

}

   208

   209

static int e1000_set_spd_dplx(struct e1000_adapter *adapter, u16 spddplx)

   210

{

   211

	struct e1000_mac_info *mac = &adapter->hw.mac;

   212

   213

	mac->autoneg = 0;

   214

   215

	/* Fiber NICs only allow 1000 gbps Full duplex */

   216

	if ((adapter->hw.phy.media_type == e1000_media_type_fiber) &&

   217

		spddplx != (SPEED_1000 + DUPLEX_FULL)) {

   218

		e_err("Unsupported Speed/Duplex configuration\n");

   219

		return -EINVAL;

   220

	}

   221

   222

	switch (spddplx) {

   223

	case SPEED_10 + DUPLEX_HALF:

   224

		mac->forced_speed_duplex = ADVERTISE_10_HALF;

   225

		break;

   226

	case SPEED_10 + DUPLEX_FULL:

   227

		mac->forced_speed_duplex = ADVERTISE_10_FULL;

   228

		break;

   229

	case SPEED_100 + DUPLEX_HALF:

   230

		mac->forced_speed_duplex = ADVERTISE_100_HALF;

   231

		break;

   232

	case SPEED_100 + DUPLEX_FULL:

   233

		mac->forced_speed_duplex = ADVERTISE_100_FULL;

   234

		break;

   235

	case SPEED_1000 + DUPLEX_FULL:

   236

		mac->autoneg = 1;

   237

		adapter->hw.phy.autoneg_advertised = ADVERTISE_1000_FULL;

   238

		break;

   239

	case SPEED_1000 + DUPLEX_HALF: /* not supported */

   240

	default:

   241

		e_err("Unsupported Speed/Duplex configuration\n");

   242

		return -EINVAL;

   243

	}

   244

	return 0;

   245

}

   246

   247

static int e1000_set_settings(struct net_device *netdev,

   248

			      struct ethtool_cmd *ecmd)

   249

{

   250

	struct e1000_adapter *adapter = netdev_priv(netdev);

   251

	struct e1000_hw *hw = &adapter->hw;

   252

   253

	/*

   254

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

   255

	 * cannot be changed

   256

	 */

   257

	if (e1000_check_reset_block(hw)) {

   258

		e_err("Cannot change link characteristics when SoL/IDER is "

   259

		      "active.\n");

   260

		return -EINVAL;

   261

	}

   262

   263

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

   264

		msleep(1);

   265

   266

	if (ecmd->autoneg == AUTONEG_ENABLE) {

   267

		hw->mac.autoneg = 1;

   268

		if (hw->phy.media_type == e1000_media_type_fiber)

   269

			hw->phy.autoneg_advertised = ADVERTISED_1000baseT_Full |

   270

						     ADVERTISED_FIBRE |

   271

						     ADVERTISED_Autoneg;

   272

		else

   273

			hw->phy.autoneg_advertised = ecmd->advertising |

   274

						     ADVERTISED_TP |

   275

						     ADVERTISED_Autoneg;

   276

		ecmd->advertising = hw->phy.autoneg_advertised;

   277

		if (adapter->fc_autoneg)

   278

			hw->fc.requested_mode = e1000_fc_default;

   279

	} else {

   280

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

   281

			clear_bit(__E1000_RESETTING, &adapter->state);

   282

			return -EINVAL;

   283

		}

   284

	}

   285

   286

	/* reset the link */

   287

   288

	if (netif_running(adapter->netdev)) {

   289

		e1000e_down(adapter);

   290

		e1000e_up(adapter);

   291

	} else {

   292

		e1000e_reset(adapter);

   293

	}

   294

   295

	clear_bit(__E1000_RESETTING, &adapter->state);

   296

	return 0;

   297

}

   298

   299

static void e1000_get_pauseparam(struct net_device *netdev,

   300

				 struct ethtool_pauseparam *pause)

   301

{

   302

	struct e1000_adapter *adapter = netdev_priv(netdev);

   303

	struct e1000_hw *hw = &adapter->hw;

   304

   305

	pause->autoneg =

   306

		(adapter->fc_autoneg ? AUTONEG_ENABLE : AUTONEG_DISABLE);

   307

   308

	if (hw->fc.current_mode == e1000_fc_rx_pause) {

   309

		pause->rx_pause = 1;

   310

	} else if (hw->fc.current_mode == e1000_fc_tx_pause) {

   311

		pause->tx_pause = 1;

   312

	} else if (hw->fc.current_mode == e1000_fc_full) {

   313

		pause->rx_pause = 1;

   314

		pause->tx_pause = 1;

   315

	}

   316

}

   317

   318

static int e1000_set_pauseparam(struct net_device *netdev,

   319

				struct ethtool_pauseparam *pause)

   320

{

   321

	struct e1000_adapter *adapter = netdev_priv(netdev);

   322

	struct e1000_hw *hw = &adapter->hw;

   323

	int retval = 0;

   324

   325

	adapter->fc_autoneg = pause->autoneg;

   326

   327

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

   328

		msleep(1);

   329

   330

	if (adapter->fc_autoneg == AUTONEG_ENABLE) {

   331

		hw->fc.requested_mode = e1000_fc_default;

   332

		if (netif_running(adapter->netdev)) {

   333

			e1000e_down(adapter);

   334

			e1000e_up(adapter);

   335

		} else {

   336

			e1000e_reset(adapter);

   337

		}

   338

	} else {

   339

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

   340

			hw->fc.requested_mode = e1000_fc_full;

   341

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

   342

			hw->fc.requested_mode = e1000_fc_rx_pause;

   343

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

   344

			hw->fc.requested_mode = e1000_fc_tx_pause;

   345

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

   346

			hw->fc.requested_mode = e1000_fc_none;

   347

   348

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

   349

   350

		if (hw->phy.media_type == e1000_media_type_fiber) {

   351

			retval = hw->mac.ops.setup_link(hw);

   352

			/* implicit goto out */

   353

		} else {

   354

			retval = e1000e_force_mac_fc(hw);

   355

			if (retval)

   356

				goto out;

   357

			e1000e_set_fc_watermarks(hw);

   358

		}

   359

	}

   360

   361

out:

   362

	clear_bit(__E1000_RESETTING, &adapter->state);

   363

	return retval;

   364

}

   365

   366

static u32 e1000_get_rx_csum(struct net_device *netdev)

   367

{

   368

	struct e1000_adapter *adapter = netdev_priv(netdev);

   369

	return (adapter->flags & FLAG_RX_CSUM_ENABLED);

   370

}

   371

   372

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

   373

{

   374

	struct e1000_adapter *adapter = netdev_priv(netdev);

   375

   376

	if (data)

   377

		adapter->flags |= FLAG_RX_CSUM_ENABLED;

   378

	else

   379

		adapter->flags &= ~FLAG_RX_CSUM_ENABLED;

   380

   381

	if (netif_running(netdev))

   382

		e1000e_reinit_locked(adapter);

   383

	else

   384

		e1000e_reset(adapter);

   385

	return 0;

   386

}

   387

   388

static u32 e1000_get_tx_csum(struct net_device *netdev)

   389

{

   390

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

   391

}

   392

   393

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

   394

{

   395

	if (data)

   396

		netdev->features |= NETIF_F_HW_CSUM;

   397

	else

   398

		netdev->features &= ~NETIF_F_HW_CSUM;

   399

   400

	return 0;

   401

}

   402

   403

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

   404

{

   405

	struct e1000_adapter *adapter = netdev_priv(netdev);

   406

   407

	if (data) {

   408

		netdev->features |= NETIF_F_TSO;

   409

		netdev->features |= NETIF_F_TSO6;

   410

	} else {

   411

		netdev->features &= ~NETIF_F_TSO;

   412

		netdev->features &= ~NETIF_F_TSO6;

   413

	}

   414

   415

	adapter->flags |= FLAG_TSO_FORCE;

   416

	return 0;

   417

}

   418

   419

static u32 e1000_get_msglevel(struct net_device *netdev)

   420

{

   421

	struct e1000_adapter *adapter = netdev_priv(netdev);

   422

	return adapter->msg_enable;

   423

}

   424

   425

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

   426

{

   427

	struct e1000_adapter *adapter = netdev_priv(netdev);

   428

	adapter->msg_enable = data;

   429

}

   430

   431

static int e1000_get_regs_len(struct net_device *netdev)

   432

{

   433

#define E1000_REGS_LEN 32 /* overestimate */

   434

	return E1000_REGS_LEN * sizeof(u32);

   435

}

   436

   437

static void e1000_get_regs(struct net_device *netdev,

   438

			   struct ethtool_regs *regs, void *p)

   439

{

   440

	struct e1000_adapter *adapter = netdev_priv(netdev);

   441

	struct e1000_hw *hw = &adapter->hw;

   442

	u32 *regs_buff = p;

   443

	u16 phy_data;

   444

	u8 revision_id;

   445

   446

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

   447

   448

	pci_read_config_byte(adapter->pdev, PCI_REVISION_ID, &revision_id);

   449

   450

	regs->version = (1 << 24) | (revision_id << 16) | adapter->pdev->device;

   451

   452

	regs_buff[0]  = er32(CTRL);

   453

	regs_buff[1]  = er32(STATUS);

   454

   455

	regs_buff[2]  = er32(RCTL);

   456

	regs_buff[3]  = er32(RDLEN);

   457

	regs_buff[4]  = er32(RDH);

   458

	regs_buff[5]  = er32(RDT);

   459

	regs_buff[6]  = er32(RDTR);

   460

   461

	regs_buff[7]  = er32(TCTL);

   462

	regs_buff[8]  = er32(TDLEN);

   463

	regs_buff[9]  = er32(TDH);

   464

	regs_buff[10] = er32(TDT);

   465

	regs_buff[11] = er32(TIDV);

   466

   467

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

   468

   469

	/* ethtool doesn't use anything past this point, so all this

   470

	 * code is likely legacy junk for apps that may or may not

   471

	 * exist */

   472

	if (hw->phy.type == e1000_phy_m88) {

   473

		e1e_rphy(hw, M88E1000_PHY_SPEC_STATUS, &phy_data);

   474

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

   475

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

   476

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

   477

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

   478

		e1e_rphy(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);

   479

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

   480

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

   481

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

   482

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

   483

		/* phy receive errors */

   484

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

   485

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

   486

	}

   487

	regs_buff[21] = 0; /* was idle_errors */

   488

	e1e_rphy(hw, PHY_1000T_STATUS, &phy_data);

   489

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

   490

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

   491

}

   492

   493

static int e1000_get_eeprom_len(struct net_device *netdev)

   494

{

   495

	struct e1000_adapter *adapter = netdev_priv(netdev);

   496

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

   497

}

   498

   499

static int e1000_get_eeprom(struct net_device *netdev,

   500

			    struct ethtool_eeprom *eeprom, u8 *bytes)

   501

{

   502

	struct e1000_adapter *adapter = netdev_priv(netdev);

   503

	struct e1000_hw *hw = &adapter->hw;

   504

	u16 *eeprom_buff;

   505

	int first_word;

   506

	int last_word;

   507

	int ret_val = 0;

   508

	u16 i;

   509

   510

	if (eeprom->len == 0)

   511

		return -EINVAL;

   512

   513

	eeprom->magic = adapter->pdev->vendor | (adapter->pdev->device << 16);

   514

   515

	first_word = eeprom->offset >> 1;

   516

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

   517

   518

	eeprom_buff = kmalloc(sizeof(u16) *

   519

			(last_word - first_word + 1), GFP_KERNEL);

   520

	if (!eeprom_buff)

   521

		return -ENOMEM;

   522

   523

	if (hw->nvm.type == e1000_nvm_eeprom_spi) {

   524

		ret_val = e1000_read_nvm(hw, first_word,

   525

					 last_word - first_word + 1,

   526

					 eeprom_buff);

   527

	} else {

   528

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

   529

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

   530

						      &eeprom_buff[i]);