1

/* Intel(R) Gigabit Ethernet Linux driver

     2

 * Copyright(c) 2007-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

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

    14

 * this program; if not, see <http://www.gnu.org/licenses/>.

    15

 *

    16

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

    17

 * the file called "COPYING".

    18

 *

    19

 * Contact Information:

    20

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

    21

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

    22

 */

    23

    24

/* ethtool support for igb */

    25

    26

#include <linux/vmalloc.h>

    27

#include <linux/netdevice.h>

    28

#include <linux/pci.h>

    29

#include <linux/delay.h>

    30

#include <linux/interrupt.h>

    31

#include <linux/if_ether.h>

    32

#include <linux/ethtool.h>

    33

#include <linux/sched.h>

    34

#include <linux/slab.h>

    35

#include <linux/pm_runtime.h>

    36

#include <linux/highmem.h>

    37

#include <linux/mdio.h>

    38

    39

#include "igb.h"

    40

    41

struct igb_stats {

    42

	char stat_string[ETH_GSTRING_LEN];

    43

	int sizeof_stat;

    44

	int stat_offset;

    45

};

    46

    47

#define IGB_STAT(_name, _stat) { \

    48

	.stat_string = _name, \

    49

	.sizeof_stat = FIELD_SIZEOF(struct igb_adapter, _stat), \

    50

	.stat_offset = offsetof(struct igb_adapter, _stat) \

    51

}

    52

static const struct igb_stats igb_gstrings_stats[] = {

    53

	IGB_STAT("rx_packets", stats.gprc),

    54

	IGB_STAT("tx_packets", stats.gptc),

    55

	IGB_STAT("rx_bytes", stats.gorc),

    56

	IGB_STAT("tx_bytes", stats.gotc),

    57

	IGB_STAT("rx_broadcast", stats.bprc),

    58

	IGB_STAT("tx_broadcast", stats.bptc),

    59

	IGB_STAT("rx_multicast", stats.mprc),

    60

	IGB_STAT("tx_multicast", stats.mptc),

    61

	IGB_STAT("multicast", stats.mprc),

    62

	IGB_STAT("collisions", stats.colc),

    63

	IGB_STAT("rx_crc_errors", stats.crcerrs),

    64

	IGB_STAT("rx_no_buffer_count", stats.rnbc),

    65

	IGB_STAT("rx_missed_errors", stats.mpc),

    66

	IGB_STAT("tx_aborted_errors", stats.ecol),

    67

	IGB_STAT("tx_carrier_errors", stats.tncrs),

    68

	IGB_STAT("tx_window_errors", stats.latecol),

    69

	IGB_STAT("tx_abort_late_coll", stats.latecol),

    70

	IGB_STAT("tx_deferred_ok", stats.dc),

    71

	IGB_STAT("tx_single_coll_ok", stats.scc),

    72

	IGB_STAT("tx_multi_coll_ok", stats.mcc),

    73

	IGB_STAT("tx_timeout_count", tx_timeout_count),

    74

	IGB_STAT("rx_long_length_errors", stats.roc),

    75

	IGB_STAT("rx_short_length_errors", stats.ruc),

    76

	IGB_STAT("rx_align_errors", stats.algnerrc),

    77

	IGB_STAT("tx_tcp_seg_good", stats.tsctc),

    78

	IGB_STAT("tx_tcp_seg_failed", stats.tsctfc),

    79

	IGB_STAT("rx_flow_control_xon", stats.xonrxc),

    80

	IGB_STAT("rx_flow_control_xoff", stats.xoffrxc),

    81

	IGB_STAT("tx_flow_control_xon", stats.xontxc),

    82

	IGB_STAT("tx_flow_control_xoff", stats.xofftxc),

    83

	IGB_STAT("rx_long_byte_count", stats.gorc),

    84

	IGB_STAT("tx_dma_out_of_sync", stats.doosync),

    85

	IGB_STAT("tx_smbus", stats.mgptc),

    86

	IGB_STAT("rx_smbus", stats.mgprc),

    87

	IGB_STAT("dropped_smbus", stats.mgpdc),

    88

	IGB_STAT("os2bmc_rx_by_bmc", stats.o2bgptc),

    89

	IGB_STAT("os2bmc_tx_by_bmc", stats.b2ospc),

    90

	IGB_STAT("os2bmc_tx_by_host", stats.o2bspc),

    91

	IGB_STAT("os2bmc_rx_by_host", stats.b2ogprc),

    92

	IGB_STAT("tx_hwtstamp_timeouts", tx_hwtstamp_timeouts),

    93

	IGB_STAT("rx_hwtstamp_cleared", rx_hwtstamp_cleared),

    94

};

    95

    96

#define IGB_NETDEV_STAT(_net_stat) { \

    97

	.stat_string = __stringify(_net_stat), \

    98

	.sizeof_stat = FIELD_SIZEOF(struct rtnl_link_stats64, _net_stat), \

    99

	.stat_offset = offsetof(struct rtnl_link_stats64, _net_stat) \

   100

}

   101

static const struct igb_stats igb_gstrings_net_stats[] = {

   102

	IGB_NETDEV_STAT(rx_errors),

   103

	IGB_NETDEV_STAT(tx_errors),

   104

	IGB_NETDEV_STAT(tx_dropped),

   105

	IGB_NETDEV_STAT(rx_length_errors),

   106

	IGB_NETDEV_STAT(rx_over_errors),

   107

	IGB_NETDEV_STAT(rx_frame_errors),

   108

	IGB_NETDEV_STAT(rx_fifo_errors),

   109

	IGB_NETDEV_STAT(tx_fifo_errors),

   110

	IGB_NETDEV_STAT(tx_heartbeat_errors)

   111

};

   112

   113

#define IGB_GLOBAL_STATS_LEN	\

   114

	(sizeof(igb_gstrings_stats) / sizeof(struct igb_stats))

   115

#define IGB_NETDEV_STATS_LEN	\

   116

	(sizeof(igb_gstrings_net_stats) / sizeof(struct igb_stats))

   117

#define IGB_RX_QUEUE_STATS_LEN \

   118

	(sizeof(struct igb_rx_queue_stats) / sizeof(u64))

   119

   120

#define IGB_TX_QUEUE_STATS_LEN 3 /* packets, bytes, restart_queue */

   121

   122

#define IGB_QUEUE_STATS_LEN \

   123

	((((struct igb_adapter *)netdev_priv(netdev))->num_rx_queues * \

   124

	  IGB_RX_QUEUE_STATS_LEN) + \

   125

	 (((struct igb_adapter *)netdev_priv(netdev))->num_tx_queues * \

   126

	  IGB_TX_QUEUE_STATS_LEN))

   127

#define IGB_STATS_LEN \

   128

	(IGB_GLOBAL_STATS_LEN + IGB_NETDEV_STATS_LEN + IGB_QUEUE_STATS_LEN)

   129

   130

static const char igb_gstrings_test[][ETH_GSTRING_LEN] = {

   131

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

   132

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

   133

	"Link test   (on/offline)"

   134

};

   135

#define IGB_TEST_LEN (sizeof(igb_gstrings_test) / ETH_GSTRING_LEN)

   136

   137

static int igb_get_settings(struct net_device *netdev, struct ethtool_cmd *ecmd)

   138

{

   139

	struct igb_adapter *adapter = netdev_priv(netdev);

   140

	struct e1000_hw *hw = &adapter->hw;

   141

	struct e1000_dev_spec_82575 *dev_spec = &hw->dev_spec._82575;

   142

	struct e1000_sfp_flags *eth_flags = &dev_spec->eth_flags;

   143

	u32 status;

   144

	u32 speed;

   145

   146

	status = rd32(E1000_STATUS);

   147

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

   148

   149

		ecmd->supported = (SUPPORTED_10baseT_Half |

   150

				   SUPPORTED_10baseT_Full |

   151

				   SUPPORTED_100baseT_Half |

   152

				   SUPPORTED_100baseT_Full |

   153

				   SUPPORTED_1000baseT_Full|

   154

				   SUPPORTED_Autoneg |

   155

				   SUPPORTED_TP |

   156

				   SUPPORTED_Pause);

   157

		ecmd->advertising = ADVERTISED_TP;

   158

   159

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

   160

			ecmd->advertising |= ADVERTISED_Autoneg;

   161

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

   162

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

   163

		}

   164

   165

		ecmd->port = PORT_TP;

   166

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

   167

		ecmd->transceiver = XCVR_INTERNAL;

   168

	} else {

   169

		ecmd->supported = (SUPPORTED_FIBRE |

   170

				   SUPPORTED_1000baseKX_Full |

   171

				   SUPPORTED_Autoneg |

   172

				   SUPPORTED_Pause);

   173

		ecmd->advertising = (ADVERTISED_FIBRE |

   174

				     ADVERTISED_1000baseKX_Full);

   175

		if (hw->mac.type == e1000_i354) {

   176

			if ((hw->device_id ==

   177

			     E1000_DEV_ID_I354_BACKPLANE_2_5GBPS) &&

   178

			    !(status & E1000_STATUS_2P5_SKU_OVER)) {

   179

				ecmd->supported |= SUPPORTED_2500baseX_Full;

   180

				ecmd->supported &=

   181

					~SUPPORTED_1000baseKX_Full;

   182

				ecmd->advertising |= ADVERTISED_2500baseX_Full;

   183

				ecmd->advertising &=

   184

					~ADVERTISED_1000baseKX_Full;

   185

			}

   186

		}

   187

		if (eth_flags->e100_base_fx) {

   188

			ecmd->supported |= SUPPORTED_100baseT_Full;

   189

			ecmd->advertising |= ADVERTISED_100baseT_Full;

   190

		}

   191

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

   192

			ecmd->advertising |= ADVERTISED_Autoneg;

   193

   194

		ecmd->port = PORT_FIBRE;

   195

		ecmd->transceiver = XCVR_EXTERNAL;

   196

	}

   197

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

   198

		ecmd->advertising &= ~(ADVERTISED_Pause |

   199

				       ADVERTISED_Asym_Pause);

   200

   201

	switch (hw->fc.requested_mode) {

   202

	case e1000_fc_full:

   203

		ecmd->advertising |= ADVERTISED_Pause;

   204

		break;

   205

	case e1000_fc_rx_pause:

   206

		ecmd->advertising |= (ADVERTISED_Pause |

   207

				      ADVERTISED_Asym_Pause);

   208

		break;

   209

	case e1000_fc_tx_pause:

   210

		ecmd->advertising |=  ADVERTISED_Asym_Pause;

   211

		break;

   212

	default:

   213

		ecmd->advertising &= ~(ADVERTISED_Pause |

   214

				       ADVERTISED_Asym_Pause);

   215

	}

   216

	if (status & E1000_STATUS_LU) {

   217

		if ((status & E1000_STATUS_2P5_SKU) &&

   218

		    !(status & E1000_STATUS_2P5_SKU_OVER)) {

   219

			speed = SPEED_2500;

   220

		} else if (status & E1000_STATUS_SPEED_1000) {

   221

			speed = SPEED_1000;

   222

		} else if (status & E1000_STATUS_SPEED_100) {

   223

			speed = SPEED_100;

   224

		} else {

   225

			speed = SPEED_10;

   226

		}

   227

		if ((status & E1000_STATUS_FD) ||

   228

		    hw->phy.media_type != e1000_media_type_copper)

   229

			ecmd->duplex = DUPLEX_FULL;

   230

		else

   231

			ecmd->duplex = DUPLEX_HALF;

   232

	} else {

   233

		speed = SPEED_UNKNOWN;

   234

		ecmd->duplex = DUPLEX_UNKNOWN;

   235

	}

   236

	ethtool_cmd_speed_set(ecmd, speed);

   237

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

   238

	    hw->mac.autoneg)

   239

		ecmd->autoneg = AUTONEG_ENABLE;

   240

	else

   241

		ecmd->autoneg = AUTONEG_DISABLE;

   242

   243

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

   244

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

   245

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

   246

						      ETH_TP_MDI;

   247

	else

   248

		ecmd->eth_tp_mdix = ETH_TP_MDI_INVALID;

   249

   250

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

   251

		ecmd->eth_tp_mdix_ctrl = ETH_TP_MDI_AUTO;

   252

	else

   253

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

   254

   255

	return 0;

   256

}

   257

   258

static int igb_set_settings(struct net_device *netdev, struct ethtool_cmd *ecmd)

   259

{

   260

	struct igb_adapter *adapter = netdev_priv(netdev);

   261

	struct e1000_hw *hw = &adapter->hw;

   262

   263

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

   264

	 * cannot be changed

   265

	 */

   266

	if (igb_check_reset_block(hw)) {

   267

		dev_err(&adapter->pdev->dev,

   268

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

   269

		return -EINVAL;

   270

	}

   271

   272

	/* MDI setting is only allowed when autoneg enabled because

   273

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

   274

	 * duplex is forced.

   275

	 */

   276

	if (ecmd->eth_tp_mdix_ctrl) {

   277

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

   278

			return -EOPNOTSUPP;

   279

   280

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

   281

		    (ecmd->autoneg != AUTONEG_ENABLE)) {

   282

			dev_err(&adapter->pdev->dev, "forcing MDI/MDI-X state is not supported when link speed and/or duplex are forced\n");

   283

			return -EINVAL;

   284

		}

   285

	}

   286

   287

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

   288

		usleep_range(1000, 2000);

   289

   290

	if (ecmd->autoneg == AUTONEG_ENABLE) {

   291

		hw->mac.autoneg = 1;

   292

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

   293

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

   294

						     ADVERTISED_FIBRE |

   295

						     ADVERTISED_Autoneg;

   296

			switch (adapter->link_speed) {

   297

			case SPEED_2500:

   298

				hw->phy.autoneg_advertised =

   299

					ADVERTISED_2500baseX_Full;

   300

				break;

   301

			case SPEED_1000:

   302

				hw->phy.autoneg_advertised =

   303

					ADVERTISED_1000baseT_Full;

   304

				break;

   305

			case SPEED_100:

   306

				hw->phy.autoneg_advertised =

   307

					ADVERTISED_100baseT_Full;

   308

				break;

   309

			default:

   310

				break;

   311

			}

   312

		} else {

   313

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

   314

						     ADVERTISED_TP |

   315

						     ADVERTISED_Autoneg;

   316

		}

   317

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

   318

		if (adapter->fc_autoneg)

   319

			hw->fc.requested_mode = e1000_fc_default;

   320

	} else {

   321

		u32 speed = ethtool_cmd_speed(ecmd);

   322

		/* calling this overrides forced MDI setting */

   323

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

   324

			clear_bit(__IGB_RESETTING, &adapter->state);

   325

			return -EINVAL;

   326

		}

   327

	}

   328

   329

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

   330

	if (ecmd->eth_tp_mdix_ctrl) {

   331

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

   332

		 * internally to auto

   333

		 */

   334

		if (ecmd->eth_tp_mdix_ctrl == ETH_TP_MDI_AUTO)

   335

			hw->phy.mdix = AUTO_ALL_MODES;

   336

		else

   337

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

   338

	}

   339

   340

	/* reset the link */

   341

	if (netif_running(adapter->netdev)) {

   342

		igb_down(adapter);

   343

		igb_up(adapter);

   344

	} else

   345

		igb_reset(adapter);

   346

   347

	clear_bit(__IGB_RESETTING, &adapter->state);

   348

	return 0;

   349

}

   350

   351

static u32 igb_get_link(struct net_device *netdev)

   352

{

   353

	struct igb_adapter *adapter = netdev_priv(netdev);

   354

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

   355

   356

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

   357

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

   358

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

   359

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

   360

	 * stale link state from the driver.

   361

	 */

   362

	if (!netif_carrier_ok(netdev))

   363

		mac->get_link_status = 1;

   364

   365

	return igb_has_link(adapter);

   366

}

   367

   368

static void igb_get_pauseparam(struct net_device *netdev,

   369

			       struct ethtool_pauseparam *pause)

   370

{

   371

	struct igb_adapter *adapter = netdev_priv(netdev);

   372

	struct e1000_hw *hw = &adapter->hw;

   373

   374

	pause->autoneg =

   375

		(adapter->fc_autoneg ? AUTONEG_ENABLE : AUTONEG_DISABLE);

   376

   377

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

   378

		pause->rx_pause = 1;

   379

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

   380

		pause->tx_pause = 1;

   381

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

   382

		pause->rx_pause = 1;

   383

		pause->tx_pause = 1;

   384

	}

   385

}

   386

   387

static int igb_set_pauseparam(struct net_device *netdev,

   388

			      struct ethtool_pauseparam *pause)

   389

{

   390

	struct igb_adapter *adapter = netdev_priv(netdev);

   391

	struct e1000_hw *hw = &adapter->hw;

   392

	int retval = 0;

   393

   394

	/* 100basefx does not support setting link flow control */

   395

	if (hw->dev_spec._82575.eth_flags.e100_base_fx)

   396

		return -EINVAL;

   397

   398

	adapter->fc_autoneg = pause->autoneg;

   399

   400

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

   401

		usleep_range(1000, 2000);

   402

   403

	if (adapter->fc_autoneg == AUTONEG_ENABLE) {

   404

		hw->fc.requested_mode = e1000_fc_default;

   405

		if (netif_running(adapter->netdev)) {

   406

			igb_down(adapter);

   407

			igb_up(adapter);

   408

		} else {

   409

			igb_reset(adapter);

   410

		}

   411

	} else {

   412

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

   413

			hw->fc.requested_mode = e1000_fc_full;

   414

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

   415

			hw->fc.requested_mode = e1000_fc_rx_pause;

   416

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

   417

			hw->fc.requested_mode = e1000_fc_tx_pause;

   418

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

   419

			hw->fc.requested_mode = e1000_fc_none;

   420

   421

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

   422

   423

		retval = ((hw->phy.media_type == e1000_media_type_copper) ?

   424

			  igb_force_mac_fc(hw) : igb_setup_link(hw));

   425

	}

   426

   427

	clear_bit(__IGB_RESETTING, &adapter->state);

   428

	return retval;

   429

}

   430

   431

static u32 igb_get_msglevel(struct net_device *netdev)

   432

{

   433

	struct igb_adapter *adapter = netdev_priv(netdev);

   434

	return adapter->msg_enable;

   435

}

   436

   437

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

   438

{

   439

	struct igb_adapter *adapter = netdev_priv(netdev);

   440

	adapter->msg_enable = data;

   441

}

   442

   443

static int igb_get_regs_len(struct net_device *netdev)

   444

{

   445

#define IGB_REGS_LEN 739

   446

	return IGB_REGS_LEN * sizeof(u32);

   447

}

   448

   449

static void igb_get_regs(struct net_device *netdev,

   450

			 struct ethtool_regs *regs, void *p)

   451

{

   452

	struct igb_adapter *adapter = netdev_priv(netdev);

   453

	struct e1000_hw *hw = &adapter->hw;

   454

	u32 *regs_buff = p;

   455

	u8 i;

   456

   457

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

   458

   459

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

   460

   461

	/* General Registers */

   462

	regs_buff[0] = rd32(E1000_CTRL);

   463

	regs_buff[1] = rd32(E1000_STATUS);

   464

	regs_buff[2] = rd32(E1000_CTRL_EXT);

   465

	regs_buff[3] = rd32(E1000_MDIC);

   466

	regs_buff[4] = rd32(E1000_SCTL);

   467

	regs_buff[5] = rd32(E1000_CONNSW);

   468

	regs_buff[6] = rd32(E1000_VET);

   469

	regs_buff[7] = rd32(E1000_LEDCTL);

   470

	regs_buff[8] = rd32(E1000_PBA);

   471

	regs_buff[9] = rd32(E1000_PBS);

   472

	regs_buff[10] = rd32(E1000_FRTIMER);

   473

	regs_buff[11] = rd32(E1000_TCPTIMER);

   474

   475

	/* NVM Register */

   476

	regs_buff[12] = rd32(E1000_EECD);

   477

   478

	/* Interrupt */

   479

	/* Reading EICS for EICR because they read the

   480

	 * same but EICS does not clear on read

   481

	 */

   482

	regs_buff[13] = rd32(E1000_EICS);

   483

	regs_buff[14] = rd32(E1000_EICS);

   484

	regs_buff[15] = rd32(E1000_EIMS);

   485

	regs_buff[16] = rd32(E1000_EIMC);

   486

	regs_buff[17] = rd32(E1000_EIAC);

   487

	regs_buff[18] = rd32(E1000_EIAM);

   488

	/* Reading ICS for ICR because they read the

   489

	 * same but ICS does not clear on read

   490

	 */

   491

	regs_buff[19] = rd32(E1000_ICS);

   492

	regs_buff[20] = rd32(E1000_ICS);

   493

	regs_buff[21] = rd32(E1000_IMS);

   494

	regs_buff[22] = rd32(E1000_IMC);

   495

	regs_buff[23] = rd32(E1000_IAC);

   496

	regs_buff[24] = rd32(E1000_IAM);

   497

	regs_buff[25] = rd32(E1000_IMIRVP);

   498

   499

	/* Flow Control */

   500

	regs_buff[26] = rd32(E1000_FCAL);

   501

	regs_buff[27] = rd32(E1000_FCAH);

   502

	regs_buff[28] = rd32(E1000_FCTTV);

   503

	regs_buff[29] = rd32(E1000_FCRTL);

   504

	regs_buff[30] = rd32(E1000_FCRTH);

   505

	regs_buff[31] = rd32(E1000_FCRTV);

   506

   507

	/* Receive */

   508

	regs_buff[32] = rd32(E1000_RCTL);

   509

	regs_buff[33] = rd32(E1000_RXCSUM);

   510

	regs_buff[34] = rd32(E1000_RLPML);

   511

	regs_buff[35] = rd32(E1000_RFCTL);

   512

	regs_buff[36] = rd32(E1000_MRQC);

   513

	regs_buff[37] = rd32(E1000_VT_CTL);

   514

   515

	/* Transmit */

   516

	regs_buff[38] = rd32(E1000_TCTL);

   517

	regs_buff[39] = rd32(E1000_TCTL_EXT);

   518

	regs_buff[40] = rd32(E1000_TIPG);

   519

	regs_buff[41] = rd32(E1000_DTXCTL);

   520

   521

	/* Wake Up */

   522

	regs_buff[42] = rd32(E1000_WUC);

   523

	regs_buff[43] = rd32(E1000_WUFC);

   524

	regs_buff[44] = rd32(E1000_WUS);

   525

	regs_buff[45] = rd32(E1000_IPAV);

   526

	regs_buff[46] = rd32(E1000_WUPL);

   527

   528

	/* MAC */

   529

	regs_buff[47] = rd32(E1000_PCS_CFG0);