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

    32

    33

#include <asm/uaccess.h>

    34

    35

extern char e1000_driver_name[];

    36

extern char e1000_driver_version[];

    37

    38

extern int e1000_up(struct e1000_adapter *adapter);

    39

extern void e1000_down(struct e1000_adapter *adapter);

    40

extern void e1000_reinit_locked(struct e1000_adapter *adapter);

    41

extern void e1000_reset(struct e1000_adapter *adapter);

    42

extern int e1000_set_spd_dplx(struct e1000_adapter *adapter, uint16_t spddplx);

    43

extern int e1000_setup_all_rx_resources(struct e1000_adapter *adapter);

    44

extern int e1000_setup_all_tx_resources(struct e1000_adapter *adapter);

    45

extern void e1000_free_all_rx_resources(struct e1000_adapter *adapter);

    46

extern void e1000_free_all_tx_resources(struct e1000_adapter *adapter);

    47

extern void e1000_update_stats(struct e1000_adapter *adapter);

    48

    49

    50

struct e1000_stats {

    51

	char stat_string[ETH_GSTRING_LEN];

    52

	int sizeof_stat;

    53

	int stat_offset;

    54

};

    55

    56

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

    57

		      offsetof(struct e1000_adapter, m)

    58

static const struct e1000_stats e1000_gstrings_stats[] = {

    59

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

    60

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

    61

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

    62

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

    63

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

    64

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

    65

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

    66

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

    67

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

    68

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

    69

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

    70

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

    71

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

    72

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

    73

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

    74

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

    75

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

    76

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

    77

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

    78

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

    79

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

    80

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

    81

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

    82

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

    83

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

    84

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

    85

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

    86

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

    87

	{ "tx_timeout_count", E1000_STAT(tx_timeout_count) },

    88

	{ "tx_restart_queue", E1000_STAT(restart_queue) },

    89

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

    90

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

    91

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

    92

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

    93

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

    94

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

    95

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

    96

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

    97

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

    98

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

    99

	{ "rx_csum_offload_good", E1000_STAT(hw_csum_good) },

   100

	{ "rx_csum_offload_errors", E1000_STAT(hw_csum_err) },

   101

	{ "rx_header_split", E1000_STAT(rx_hdr_split) },

   102

	{ "alloc_rx_buff_failed", E1000_STAT(alloc_rx_buff_failed) },

   103

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

   104

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

   105

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

   106

};

   107

   108

#define E1000_QUEUE_STATS_LEN 0

   109

#define E1000_GLOBAL_STATS_LEN	\

   110

	sizeof(e1000_gstrings_stats) / sizeof(struct e1000_stats)

   111

#define E1000_STATS_LEN (E1000_GLOBAL_STATS_LEN + E1000_QUEUE_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

#define E1000_TEST_LEN sizeof(e1000_gstrings_test) / ETH_GSTRING_LEN

   118

   119

static int

   120

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

   121

{

   122

	struct e1000_adapter *adapter = netdev_priv(netdev);

   123

	struct e1000_hw *hw = &adapter->hw;

   124

   125

	if (hw->media_type == e1000_media_type_copper) {

   126

   127

		ecmd->supported = (SUPPORTED_10baseT_Half |

   128

		                   SUPPORTED_10baseT_Full |

   129

		                   SUPPORTED_100baseT_Half |

   130

		                   SUPPORTED_100baseT_Full |

   131

		                   SUPPORTED_1000baseT_Full|

   132

		                   SUPPORTED_Autoneg |

   133

		                   SUPPORTED_TP);

   134

		if (hw->phy_type == e1000_phy_ife)

   135

			ecmd->supported &= ~SUPPORTED_1000baseT_Full;

   136

		ecmd->advertising = ADVERTISED_TP;

   137

   138

		if (hw->autoneg == 1) {

   139

			ecmd->advertising |= ADVERTISED_Autoneg;

   140

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

   141

			ecmd->advertising |= hw->autoneg_advertised;

   142

		}

   143

   144

		ecmd->port = PORT_TP;

   145

		ecmd->phy_address = hw->phy_addr;

   146

   147

		if (hw->mac_type == e1000_82543)

   148

			ecmd->transceiver = XCVR_EXTERNAL;

   149

		else

   150

			ecmd->transceiver = XCVR_INTERNAL;

   151

   152

	} else {

   153

		ecmd->supported   = (SUPPORTED_1000baseT_Full |

   154

				     SUPPORTED_FIBRE |

   155

				     SUPPORTED_Autoneg);

   156

   157

		ecmd->advertising = (ADVERTISED_1000baseT_Full |

   158

				     ADVERTISED_FIBRE |

   159

				     ADVERTISED_Autoneg);

   160

   161

		ecmd->port = PORT_FIBRE;

   162

   163

		if (hw->mac_type >= e1000_82545)

   164

			ecmd->transceiver = XCVR_INTERNAL;

   165

		else

   166

			ecmd->transceiver = XCVR_EXTERNAL;

   167

	}

   168

   169

	if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU) {

   170

   171

		e1000_get_speed_and_duplex(hw, &adapter->link_speed,

   172

		                                   &adapter->link_duplex);

   173

		ecmd->speed = adapter->link_speed;

   174

   175

		/* unfortunatly FULL_DUPLEX != DUPLEX_FULL

   176

		 *          and HALF_DUPLEX != DUPLEX_HALF */

   177

   178

		if (adapter->link_duplex == FULL_DUPLEX)

   179

			ecmd->duplex = DUPLEX_FULL;

   180

		else

   181

			ecmd->duplex = DUPLEX_HALF;

   182

	} else {

   183

		ecmd->speed = -1;

   184

		ecmd->duplex = -1;

   185

	}

   186

   187

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

   188

			 hw->autoneg) ? AUTONEG_ENABLE : AUTONEG_DISABLE;

   189

	return 0;

   190

}

   191

   192

static int

   193

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

   194

{

   195

	struct e1000_adapter *adapter = netdev_priv(netdev);

   196

	struct e1000_hw *hw = &adapter->hw;

   197

   198

	if (adapter->ecdev)

   199

		return -EBUSY;

   200

   201

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

   202

	 * cannot be changed */

   203

	if (e1000_check_phy_reset_block(hw)) {

   204

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

   205

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

   206

		return -EINVAL;

   207

	}

   208

   209

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

   210

		msleep(1);

   211

   212

	if (ecmd->autoneg == AUTONEG_ENABLE) {

   213

		hw->autoneg = 1;

   214

		if (hw->media_type == e1000_media_type_fiber)

   215

			hw->autoneg_advertised = ADVERTISED_1000baseT_Full |

   216

				     ADVERTISED_FIBRE |

   217

				     ADVERTISED_Autoneg;

   218

		else

   219

			hw->autoneg_advertised = ecmd->advertising |

   220

			                         ADVERTISED_TP |

   221

			                         ADVERTISED_Autoneg;

   222

		ecmd->advertising = hw->autoneg_advertised;

   223

	} else

   224

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

   225

			clear_bit(__E1000_RESETTING, &adapter->flags);

   226

			return -EINVAL;

   227

		}

   228

   229

	/* reset the link */

   230

   231

	if (netif_running(adapter->netdev)) {

   232

		e1000_down(adapter);

   233

		e1000_up(adapter);

   234

	} else

   235

		e1000_reset(adapter);

   236

   237

	clear_bit(__E1000_RESETTING, &adapter->flags);

   238

	return 0;

   239

}

   240

   241

static void

   242

e1000_get_pauseparam(struct net_device *netdev,

   243

                     struct ethtool_pauseparam *pause)

   244

{

   245

	struct e1000_adapter *adapter = netdev_priv(netdev);

   246

	struct e1000_hw *hw = &adapter->hw;

   247

   248

	pause->autoneg =

   249

		(adapter->fc_autoneg ? AUTONEG_ENABLE : AUTONEG_DISABLE);

   250

   251

	if (hw->fc == E1000_FC_RX_PAUSE)

   252

		pause->rx_pause = 1;

   253

	else if (hw->fc == E1000_FC_TX_PAUSE)

   254

		pause->tx_pause = 1;

   255

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

   256

		pause->rx_pause = 1;

   257

		pause->tx_pause = 1;

   258

	}

   259

}

   260

   261

static int

   262

e1000_set_pauseparam(struct net_device *netdev,

   263

                     struct ethtool_pauseparam *pause)

   264

{

   265

	struct e1000_adapter *adapter = netdev_priv(netdev);

   266

	struct e1000_hw *hw = &adapter->hw;

   267

	int retval = 0;

   268

   269

	if (adapter->ecdev)

   270

		return -EBUSY;

   271

   272

	adapter->fc_autoneg = pause->autoneg;

   273

   274

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

   275

		msleep(1);

   276

   277

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

   278

		hw->fc = E1000_FC_FULL;

   279

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

   280

		hw->fc = E1000_FC_RX_PAUSE;

   281

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

   282

		hw->fc = E1000_FC_TX_PAUSE;

   283

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

   284

		hw->fc = E1000_FC_NONE;

   285

   286

	hw->original_fc = hw->fc;

   287

   288

	if (adapter->fc_autoneg == AUTONEG_ENABLE) {

   289

		if (netif_running(adapter->netdev)) {

   290

			e1000_down(adapter);

   291

			e1000_up(adapter);

   292

		} else

   293

			e1000_reset(adapter);

   294

	} else

   295

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

   296

			  e1000_setup_link(hw) : e1000_force_mac_fc(hw));

   297

   298

	clear_bit(__E1000_RESETTING, &adapter->flags);

   299

	return retval;

   300

}

   301

   302

static uint32_t

   303

e1000_get_rx_csum(struct net_device *netdev)

   304

{

   305

	struct e1000_adapter *adapter = netdev_priv(netdev);

   306

	return adapter->rx_csum;

   307

}

   308

   309

static int

   310

e1000_set_rx_csum(struct net_device *netdev, uint32_t data)

   311

{

   312

	struct e1000_adapter *adapter = netdev_priv(netdev);

   313

   314

	if (adapter->ecdev)

   315

		return -EBUSY;

   316

   317

	adapter->rx_csum = data;

   318

   319

	if (netif_running(netdev))

   320

		e1000_reinit_locked(adapter);

   321

	else

   322

		e1000_reset(adapter);

   323

	return 0;

   324

}

   325

   326

static uint32_t

   327

e1000_get_tx_csum(struct net_device *netdev)

   328

{

   329

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

   330

}

   331

   332

static int

   333

e1000_set_tx_csum(struct net_device *netdev, uint32_t data)

   334

{

   335

	struct e1000_adapter *adapter = netdev_priv(netdev);

   336

   337

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

   338

		if (!data)

   339

			return -EINVAL;

   340

		return 0;

   341

	}

   342

   343

	if (data)

   344

		netdev->features |= NETIF_F_HW_CSUM;

   345

	else

   346

		netdev->features &= ~NETIF_F_HW_CSUM;

   347

   348

	return 0;

   349

}

   350

   351

static int

   352

e1000_set_tso(struct net_device *netdev, uint32_t data)

   353

{

   354

	struct e1000_adapter *adapter = netdev_priv(netdev);

   355

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

   356

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

   357

		return data ? -EINVAL : 0;

   358

   359

	if (data)

   360

		netdev->features |= NETIF_F_TSO;

   361

	else

   362

		netdev->features &= ~NETIF_F_TSO;

   363

   364

	if (data)

   365

		netdev->features |= NETIF_F_TSO6;

   366

	else

   367

		netdev->features &= ~NETIF_F_TSO6;

   368

   369

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

   370

	adapter->tso_force = TRUE;

   371

	return 0;

   372

}

   373

   374

static uint32_t

   375

e1000_get_msglevel(struct net_device *netdev)

   376

{

   377

	struct e1000_adapter *adapter = netdev_priv(netdev);

   378

	return adapter->msg_enable;

   379

}

   380

   381

static void

   382

e1000_set_msglevel(struct net_device *netdev, uint32_t data)

   383

{

   384

	struct e1000_adapter *adapter = netdev_priv(netdev);

   385

	adapter->msg_enable = data;

   386

}

   387

   388

static int

   389

e1000_get_regs_len(struct net_device *netdev)

   390

{

   391

#define E1000_REGS_LEN 32

   392

	return E1000_REGS_LEN * sizeof(uint32_t);

   393

}

   394

   395

static void

   396

e1000_get_regs(struct net_device *netdev,

   397

	       struct ethtool_regs *regs, void *p)

   398

{

   399

	struct e1000_adapter *adapter = netdev_priv(netdev);

   400

	struct e1000_hw *hw = &adapter->hw;

   401

	uint32_t *regs_buff = p;

   402

	uint16_t phy_data;

   403

   404

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

   405

   406

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

   407

   408

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

   409

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

   410

   411

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

   412

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

   413

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

   414

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

   415

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

   416

   417

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

   418

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

   419

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

   420

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

   421

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

   422

   423

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

   424

	if (hw->phy_type == e1000_phy_igp) {

   425

		e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT,

   426

				    IGP01E1000_PHY_AGC_A);

   427

		e1000_read_phy_reg(hw, IGP01E1000_PHY_AGC_A &

   428

				   IGP01E1000_PHY_PAGE_SELECT, &phy_data);

   429

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

   430

		e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT,

   431

				    IGP01E1000_PHY_AGC_B);

   432

		e1000_read_phy_reg(hw, IGP01E1000_PHY_AGC_B &

   433

				   IGP01E1000_PHY_PAGE_SELECT, &phy_data);

   434

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

   435

		e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT,

   436

				    IGP01E1000_PHY_AGC_C);

   437

		e1000_read_phy_reg(hw, IGP01E1000_PHY_AGC_C &

   438

				   IGP01E1000_PHY_PAGE_SELECT, &phy_data);

   439

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

   440

		e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT,

   441

				    IGP01E1000_PHY_AGC_D);

   442

		e1000_read_phy_reg(hw, IGP01E1000_PHY_AGC_D &

   443

				   IGP01E1000_PHY_PAGE_SELECT, &phy_data);

   444

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

   445

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

   446

		e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT, 0x0);

   447

		e1000_read_phy_reg(hw, IGP01E1000_PHY_PORT_STATUS &

   448

				   IGP01E1000_PHY_PAGE_SELECT, &phy_data);

   449

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

   450

		e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT,

   451

				    IGP01E1000_PHY_PCS_INIT_REG);

   452

		e1000_read_phy_reg(hw, IGP01E1000_PHY_PCS_INIT_REG &

   453

				   IGP01E1000_PHY_PAGE_SELECT, &phy_data);

   454

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

   455

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

   456

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

   457

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

   458

		e1000_write_phy_reg(hw, IGP01E1000_PHY_PAGE_SELECT, 0x0);

   459

	} else {

   460

		e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_STATUS, &phy_data);

   461

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

   462

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

   463

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

   464

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

   465

		e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);

   466

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

   467

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

   468

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

   469

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

   470

		/* phy receive errors */

   471

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

   472

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

   473

	}

   474

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

   475

	e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_data);

   476

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

   477

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

   478

	if (hw->mac_type >= e1000_82540 &&

   479

	    hw->mac_type < e1000_82571 &&

   480

	    hw->media_type == e1000_media_type_copper) {

   481

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

   482

	}

   483

}

   484

   485

static int

   486

e1000_get_eeprom_len(struct net_device *netdev)

   487

{

   488

	struct e1000_adapter *adapter = netdev_priv(netdev);

   489

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

   490

}

   491

   492

static int

   493

e1000_get_eeprom(struct net_device *netdev,

   494

                      struct ethtool_eeprom *eeprom, uint8_t *bytes)

   495

{

   496

	struct e1000_adapter *adapter = netdev_priv(netdev);

   497

	struct e1000_hw *hw = &adapter->hw;

   498

	uint16_t *eeprom_buff;

   499

	int first_word, last_word;

   500

	int ret_val = 0;

   501

	uint16_t i;

   502

   503

	if (eeprom->len == 0)

   504

		return -EINVAL;

   505

   506

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

   507

   508

	first_word = eeprom->offset >> 1;

   509

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

   510

   511

	eeprom_buff = kmalloc(sizeof(uint16_t) *

   512

			(last_word - first_word + 1), GFP_KERNEL);

   513

	if (!eeprom_buff)

   514

		return -ENOMEM;

   515

   516

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

   517

		ret_val = e1000_read_eeprom(hw, first_word,

   518

					    last_word - first_word + 1,

   519

					    eeprom_buff);

   520

	else {

   521

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

   522

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

   523

							&eeprom_buff[i])))

   524

				break;

   525

	}

   526

   527

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

   528

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

   529

		le16_to_cpus(&eeprom_buff[i]);