1

/* Intel PRO/1000 Linux driver

     2

 * Copyright(c) 1999 - 2014 Intel Corporation.

     3

 *

     4

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

     5

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

     6

 * version 2, as published by the Free Software Foundation.

     7

 *

     8

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

     9

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    10

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

    11

 * more details.

    12

 *

    13

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

    14

 * the file called "COPYING".

    15

 *

    16

 * Contact Information:

    17

 * Linux NICS <linux.nics@intel.com>

    18

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

    19

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

    20

 */

    21

    22

/* ethtool support for e1000 */

    23

    24

#include <linux/netdevice.h>

    25

#include <linux/interrupt.h>

    26

#include <linux/ethtool.h>

    27

#include <linux/pci.h>

    28

#include <linux/slab.h>

    29

#include <linux/delay.h>

    30

#include <linux/vmalloc.h>

    31

#include <linux/pm_runtime.h>

    32

    33

#include "e1000.h"

    34

    35

enum { NETDEV_STATS, E1000_STATS };

    36

    37

struct e1000_stats {

    38

	char stat_string[ETH_GSTRING_LEN];

    39

	int type;

    40

	int sizeof_stat;

    41

	int stat_offset;

    42

};

    43

    44

#define E1000_STAT(str, m) { \

    45

		.stat_string = str, \

    46

		.type = E1000_STATS, \

    47

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

    48

		.stat_offset = offsetof(struct e1000_adapter, m) }

    49

#define E1000_NETDEV_STAT(str, m) { \

    50

		.stat_string = str, \

    51

		.type = NETDEV_STATS, \

    52

		.sizeof_stat = sizeof(((struct rtnl_link_stats64 *)0)->m), \

    53

		.stat_offset = offsetof(struct rtnl_link_stats64, m) }

    54

    55

static const struct e1000_stats e1000_gstrings_stats[] = {

    56

	E1000_STAT("rx_packets", stats.gprc),

    57

	E1000_STAT("tx_packets", stats.gptc),

    58

	E1000_STAT("rx_bytes", stats.gorc),

    59

	E1000_STAT("tx_bytes", stats.gotc),

    60

	E1000_STAT("rx_broadcast", stats.bprc),

    61

	E1000_STAT("tx_broadcast", stats.bptc),

    62

	E1000_STAT("rx_multicast", stats.mprc),

    63

	E1000_STAT("tx_multicast", stats.mptc),

    64

	E1000_NETDEV_STAT("rx_errors", rx_errors),

    65

	E1000_NETDEV_STAT("tx_errors", tx_errors),

    66

	E1000_NETDEV_STAT("tx_dropped", tx_dropped),

    67

	E1000_STAT("multicast", stats.mprc),

    68

	E1000_STAT("collisions", stats.colc),

    69

	E1000_NETDEV_STAT("rx_length_errors", rx_length_errors),

    70

	E1000_NETDEV_STAT("rx_over_errors", rx_over_errors),

    71

	E1000_STAT("rx_crc_errors", stats.crcerrs),

    72

	E1000_NETDEV_STAT("rx_frame_errors", rx_frame_errors),

    73

	E1000_STAT("rx_no_buffer_count", stats.rnbc),

    74

	E1000_STAT("rx_missed_errors", stats.mpc),

    75

	E1000_STAT("tx_aborted_errors", stats.ecol),

    76

	E1000_STAT("tx_carrier_errors", stats.tncrs),

    77

	E1000_NETDEV_STAT("tx_fifo_errors", tx_fifo_errors),

    78

	E1000_NETDEV_STAT("tx_heartbeat_errors", tx_heartbeat_errors),

    79

	E1000_STAT("tx_window_errors", stats.latecol),

    80

	E1000_STAT("tx_abort_late_coll", stats.latecol),

    81

	E1000_STAT("tx_deferred_ok", stats.dc),

    82

	E1000_STAT("tx_single_coll_ok", stats.scc),

    83

	E1000_STAT("tx_multi_coll_ok", stats.mcc),

    84

	E1000_STAT("tx_timeout_count", tx_timeout_count),

    85

	E1000_STAT("tx_restart_queue", restart_queue),

    86

	E1000_STAT("rx_long_length_errors", stats.roc),

    87

	E1000_STAT("rx_short_length_errors", stats.ruc),

    88

	E1000_STAT("rx_align_errors", stats.algnerrc),

    89

	E1000_STAT("tx_tcp_seg_good", stats.tsctc),

    90

	E1000_STAT("tx_tcp_seg_failed", stats.tsctfc),

    91

	E1000_STAT("rx_flow_control_xon", stats.xonrxc),

    92

	E1000_STAT("rx_flow_control_xoff", stats.xoffrxc),

    93

	E1000_STAT("tx_flow_control_xon", stats.xontxc),

    94

	E1000_STAT("tx_flow_control_xoff", stats.xofftxc),

    95

	E1000_STAT("rx_csum_offload_good", hw_csum_good),

    96

	E1000_STAT("rx_csum_offload_errors", hw_csum_err),

    97

	E1000_STAT("rx_header_split", rx_hdr_split),

    98

	E1000_STAT("alloc_rx_buff_failed", alloc_rx_buff_failed),

    99

	E1000_STAT("tx_smbus", stats.mgptc),

   100

	E1000_STAT("rx_smbus", stats.mgprc),

   101

	E1000_STAT("dropped_smbus", stats.mgpdc),

   102

	E1000_STAT("rx_dma_failed", rx_dma_failed),

   103

	E1000_STAT("tx_dma_failed", tx_dma_failed),

   104

	E1000_STAT("rx_hwtstamp_cleared", rx_hwtstamp_cleared),

   105

	E1000_STAT("uncorr_ecc_errors", uncorr_errors),

   106

	E1000_STAT("corr_ecc_errors", corr_errors),

   107

	E1000_STAT("tx_hwtstamp_timeouts", tx_hwtstamp_timeouts),

   108

};

   109

   110

#define E1000_GLOBAL_STATS_LEN	ARRAY_SIZE(e1000_gstrings_stats)

   111

#define E1000_STATS_LEN (E1000_GLOBAL_STATS_LEN)

   112

static const char e1000_gstrings_test[][ETH_GSTRING_LEN] = {

   113

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

   114

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

   115

	"Link test   (on/offline)"

   116

};

   117

   118

#define E1000_TEST_LEN ARRAY_SIZE(e1000_gstrings_test)

   119

   120

static int e1000_get_settings(struct net_device *netdev,

   121

			      struct ethtool_cmd *ecmd)

   122

{

   123

	struct e1000_adapter *adapter = netdev_priv(netdev);

   124

	struct e1000_hw *hw = &adapter->hw;

   125

	u32 speed;

   126

   127

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

   128

		ecmd->supported = (SUPPORTED_10baseT_Half |

   129

				   SUPPORTED_10baseT_Full |

   130

				   SUPPORTED_100baseT_Half |

   131

				   SUPPORTED_100baseT_Full |

   132

				   SUPPORTED_1000baseT_Full |

   133

				   SUPPORTED_Autoneg |

   134

				   SUPPORTED_TP);

   135

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

   136

			ecmd->supported &= ~SUPPORTED_1000baseT_Full;

   137

		ecmd->advertising = ADVERTISED_TP;

   138

   139

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

   140

			ecmd->advertising |= ADVERTISED_Autoneg;

   141

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

   142

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

   143

		}

   144

   145

		ecmd->port = PORT_TP;

   146

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

   147

		ecmd->transceiver = XCVR_INTERNAL;

   148

   149

	} else {

   150

		ecmd->supported   = (SUPPORTED_1000baseT_Full |

   151

				     SUPPORTED_FIBRE |

   152

				     SUPPORTED_Autoneg);

   153

   154

		ecmd->advertising = (ADVERTISED_1000baseT_Full |

   155

				     ADVERTISED_FIBRE |

   156

				     ADVERTISED_Autoneg);

   157

   158

		ecmd->port = PORT_FIBRE;

   159

		ecmd->transceiver = XCVR_EXTERNAL;

   160

	}

   161

   162

	speed = SPEED_UNKNOWN;

   163

	ecmd->duplex = DUPLEX_UNKNOWN;

   164

   165

	if (netif_running(netdev)) {

   166

		if (netif_carrier_ok(netdev)) {

   167

			speed = adapter->link_speed;

   168

			ecmd->duplex = adapter->link_duplex - 1;

   169

		}

   170

	} else if (!pm_runtime_suspended(netdev->dev.parent)) {

   171

		u32 status = er32(STATUS);

   172

   173

		if (status & E1000_STATUS_LU) {

   174

			if (status & E1000_STATUS_SPEED_1000)

   175

				speed = SPEED_1000;

   176

			else if (status & E1000_STATUS_SPEED_100)

   177

				speed = SPEED_100;

   178

			else

   179

				speed = SPEED_10;

   180

   181

			if (status & E1000_STATUS_FD)

   182

				ecmd->duplex = DUPLEX_FULL;

   183

			else

   184

				ecmd->duplex = DUPLEX_HALF;

   185

		}

   186

	}

   187

   188

	ethtool_cmd_speed_set(ecmd, speed);

   189

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

   190

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

   191

   192

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

   193

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

   194

	    netif_carrier_ok(netdev))

   195

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

   196

	else

   197

		ecmd->eth_tp_mdix = ETH_TP_MDI_INVALID;

   198

   199

	if (hw->phy.mdix == AUTO_ALL_MODES)

   200

		ecmd->eth_tp_mdix_ctrl = ETH_TP_MDI_AUTO;

   201

	else

   202

		ecmd->eth_tp_mdix_ctrl = hw->phy.mdix;

   203

   204

	return 0;

   205

}

   206

   207

static int e1000_set_spd_dplx(struct e1000_adapter *adapter, u32 spd, u8 dplx)

   208

{

   209

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

   210

   211

	mac->autoneg = 0;

   212

   213

	/* Make sure dplx is at most 1 bit and lsb of speed is not set

   214

	 * for the switch() below to work

   215

	 */

   216

	if ((spd & 1) || (dplx & ~1))

   217

		goto err_inval;

   218

   219

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

   220

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

   221

	    (spd != SPEED_1000) && (dplx != DUPLEX_FULL)) {

   222

		goto err_inval;

   223

	}

   224

   225

	switch (spd + dplx) {

   226

	case SPEED_10 + DUPLEX_HALF:

   227

		mac->forced_speed_duplex = ADVERTISE_10_HALF;

   228

		break;

   229

	case SPEED_10 + DUPLEX_FULL:

   230

		mac->forced_speed_duplex = ADVERTISE_10_FULL;

   231

		break;

   232

	case SPEED_100 + DUPLEX_HALF:

   233

		mac->forced_speed_duplex = ADVERTISE_100_HALF;

   234

		break;

   235

	case SPEED_100 + DUPLEX_FULL:

   236

		mac->forced_speed_duplex = ADVERTISE_100_FULL;

   237

		break;

   238

	case SPEED_1000 + DUPLEX_FULL:

   239

		mac->autoneg = 1;

   240

		adapter->hw.phy.autoneg_advertised = ADVERTISE_1000_FULL;

   241

		break;

   242

	case SPEED_1000 + DUPLEX_HALF:	/* not supported */

   243

	default:

   244

		goto err_inval;

   245

	}

   246

   247

	/* clear MDI, MDI(-X) override is only allowed when autoneg enabled */

   248

	adapter->hw.phy.mdix = AUTO_ALL_MODES;

   249

   250

	return 0;

   251

   252

err_inval:

   253

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

   254

	return -EINVAL;

   255

}

   256

   257

static int e1000_set_settings(struct net_device *netdev,

   258

			      struct ethtool_cmd *ecmd)

   259

{

   260

	struct e1000_adapter *adapter = netdev_priv(netdev);

   261

	struct e1000_hw *hw = &adapter->hw;

   262

	int ret_val = 0;

   263

   264

	pm_runtime_get_sync(netdev->dev.parent);

   265

   266

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

   267

	 * cannot be changed

   268

	 */

   269

	if (hw->phy.ops.check_reset_block &&

   270

	    hw->phy.ops.check_reset_block(hw)) {

   271

		e_err("Cannot change link characteristics when SoL/IDER is active.\n");

   272

		ret_val = -EINVAL;

   273

		goto out;

   274

	}

   275

   276

	/* MDI setting is only allowed when autoneg enabled because

   277

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

   278

	 * duplex is forced.

   279

	 */

   280

	if (ecmd->eth_tp_mdix_ctrl) {

   281

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

   282

			ret_val = -EOPNOTSUPP;

   283

			goto out;

   284

		}

   285

   286

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

   287

		    (ecmd->autoneg != AUTONEG_ENABLE)) {

   288

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

   289

			ret_val = -EINVAL;

   290

			goto out;

   291

		}

   292

	}

   293

   294

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

   295

		usleep_range(1000, 2000);

   296

   297

	if (ecmd->autoneg == AUTONEG_ENABLE) {

   298

		hw->mac.autoneg = 1;

   299

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

   300

			hw->phy.autoneg_advertised = ADVERTISED_1000baseT_Full |

   301

			    ADVERTISED_FIBRE | ADVERTISED_Autoneg;

   302

		else

   303

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

   304

			    ADVERTISED_TP | ADVERTISED_Autoneg;

   305

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

   306

		if (adapter->fc_autoneg)

   307

			hw->fc.requested_mode = e1000_fc_default;

   308

	} else {

   309

		u32 speed = ethtool_cmd_speed(ecmd);

   310

		/* calling this overrides forced MDI setting */

   311

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

   312

			ret_val = -EINVAL;

   313

			goto out;

   314

		}

   315

	}

   316

   317

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

   318

	if (ecmd->eth_tp_mdix_ctrl) {

   319

		/* fix up the value for auto (3 => 0) as zero is mapped

   320

		 * internally to auto

   321

		 */

   322

		if (ecmd->eth_tp_mdix_ctrl == ETH_TP_MDI_AUTO)

   323

			hw->phy.mdix = AUTO_ALL_MODES;

   324

		else

   325

			hw->phy.mdix = ecmd->eth_tp_mdix_ctrl;

   326

	}

   327

   328

	/* reset the link */

   329

	if (netif_running(adapter->netdev)) {

   330

		e1000e_down(adapter, true);

   331

		e1000e_up(adapter);

   332

	} else {

   333

		e1000e_reset(adapter);

   334

	}

   335

   336

out:

   337

	pm_runtime_put_sync(netdev->dev.parent);

   338

	clear_bit(__E1000_RESETTING, &adapter->state);

   339

	return ret_val;

   340

}

   341

   342

static void e1000_get_pauseparam(struct net_device *netdev,

   343

				 struct ethtool_pauseparam *pause)

   344

{

   345

	struct e1000_adapter *adapter = netdev_priv(netdev);

   346

	struct e1000_hw *hw = &adapter->hw;

   347

   348

	pause->autoneg =

   349

	    (adapter->fc_autoneg ? AUTONEG_ENABLE : AUTONEG_DISABLE);

   350

   351

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

   352

		pause->rx_pause = 1;

   353

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

   354

		pause->tx_pause = 1;

   355

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

   356

		pause->rx_pause = 1;

   357

		pause->tx_pause = 1;

   358

	}

   359

}

   360

   361

static int e1000_set_pauseparam(struct net_device *netdev,

   362

				struct ethtool_pauseparam *pause)

   363

{

   364

	struct e1000_adapter *adapter = netdev_priv(netdev);

   365

	struct e1000_hw *hw = &adapter->hw;

   366

	int retval = 0;

   367

   368

	adapter->fc_autoneg = pause->autoneg;

   369

   370

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

   371

		usleep_range(1000, 2000);

   372

   373

	pm_runtime_get_sync(netdev->dev.parent);

   374

   375

	if (adapter->fc_autoneg == AUTONEG_ENABLE) {

   376

		hw->fc.requested_mode = e1000_fc_default;

   377

		if (netif_running(adapter->netdev)) {

   378

			e1000e_down(adapter, true);

   379

			e1000e_up(adapter);

   380

		} else {

   381

			e1000e_reset(adapter);

   382

		}

   383

	} else {

   384

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

   385

			hw->fc.requested_mode = e1000_fc_full;

   386

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

   387

			hw->fc.requested_mode = e1000_fc_rx_pause;

   388

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

   389

			hw->fc.requested_mode = e1000_fc_tx_pause;

   390

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

   391

			hw->fc.requested_mode = e1000_fc_none;

   392

   393

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

   394

   395

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

   396

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

   397

			/* implicit goto out */

   398

		} else {

   399

			retval = e1000e_force_mac_fc(hw);

   400

			if (retval)

   401

				goto out;

   402

			e1000e_set_fc_watermarks(hw);

   403

		}

   404

	}

   405

   406

out:

   407

	pm_runtime_put_sync(netdev->dev.parent);

   408

	clear_bit(__E1000_RESETTING, &adapter->state);

   409

	return retval;

   410

}

   411

   412

static u32 e1000_get_msglevel(struct net_device *netdev)

   413

{

   414

	struct e1000_adapter *adapter = netdev_priv(netdev);

   415

	return adapter->msg_enable;

   416

}

   417

   418

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

   419

{

   420

	struct e1000_adapter *adapter = netdev_priv(netdev);

   421

	adapter->msg_enable = data;

   422

}

   423

   424

static int e1000_get_regs_len(struct net_device __always_unused *netdev)

   425

{

   426

#define E1000_REGS_LEN 32	/* overestimate */

   427

	return E1000_REGS_LEN * sizeof(u32);

   428

}

   429

   430

static void e1000_get_regs(struct net_device *netdev,

   431

			   struct ethtool_regs *regs, void *p)

   432

{

   433

	struct e1000_adapter *adapter = netdev_priv(netdev);

   434

	struct e1000_hw *hw = &adapter->hw;

   435

	u32 *regs_buff = p;

   436

	u16 phy_data;

   437

   438

	pm_runtime_get_sync(netdev->dev.parent);

   439

   440

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

   441

   442

	regs->version = (1 << 24) | (adapter->pdev->revision << 16) |

   443

	    adapter->pdev->device;

   444

   445

	regs_buff[0] = er32(CTRL);

   446

	regs_buff[1] = er32(STATUS);

   447

   448

	regs_buff[2] = er32(RCTL);

   449

	regs_buff[3] = er32(RDLEN(0));

   450

	regs_buff[4] = er32(RDH(0));

   451

	regs_buff[5] = er32(RDT(0));

   452

	regs_buff[6] = er32(RDTR);

   453

   454

	regs_buff[7] = er32(TCTL);

   455

	regs_buff[8] = er32(TDLEN(0));

   456

	regs_buff[9] = er32(TDH(0));

   457

	regs_buff[10] = er32(TDT(0));

   458

	regs_buff[11] = er32(TIDV);

   459

   460

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

   461

   462

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

   463

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

   464

	 */

   465

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

   466

		e1e_rphy(hw, M88E1000_PHY_SPEC_STATUS, &phy_data);

   467

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

   468

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

   469

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

   470

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

   471

		e1e_rphy(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);

   472

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

   473

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

   474

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

   475

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

   476

		/* phy receive errors */

   477

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

   478

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

   479

	}

   480

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

   481

	e1e_rphy(hw, MII_STAT1000, &phy_data);

   482

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

   483

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

   484

   485

	pm_runtime_put_sync(netdev->dev.parent);

   486

}

   487

   488

static int e1000_get_eeprom_len(struct net_device *netdev)

   489

{

   490

	struct e1000_adapter *adapter = netdev_priv(netdev);

   491

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

   492

}

   493

   494

static int e1000_get_eeprom(struct net_device *netdev,

   495

			    struct ethtool_eeprom *eeprom, u8 *bytes)

   496

{

   497

	struct e1000_adapter *adapter = netdev_priv(netdev);

   498

	struct e1000_hw *hw = &adapter->hw;

   499

	u16 *eeprom_buff;

   500

	int first_word;

   501

	int last_word;

   502

	int ret_val = 0;

   503

	u16 i;

   504

   505

	if (eeprom->len == 0)

   506

		return -EINVAL;

   507

   508

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

   509

   510

	first_word = eeprom->offset >> 1;

   511

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

   512

   513

	eeprom_buff = kmalloc(sizeof(u16) * (last_word - first_word + 1),

   514

			      GFP_KERNEL);

   515

	if (!eeprom_buff)

   516

		return -ENOMEM;

   517

   518

	pm_runtime_get_sync(netdev->dev.parent);

   519

   520

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

   521

		ret_val = e1000_read_nvm(hw, first_word,

   522

					 last_word - first_word + 1,

   523

					 eeprom_buff);

   524

	} else {

   525

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

   526

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

   527

						 &eeprom_buff[i]);

   528

			if (ret_val)

   529

				break;