1

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

     2

     3

  Intel PRO/1000 Linux driver

     4

  Copyright(c) 1999 - 2012 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/interrupt.h>

    33

#include <linux/ethtool.h>

    34

#include <linux/pci.h>

    35

#include <linux/slab.h>

    36

#include <linux/delay.h>

    37

#include <linux/vmalloc.h>

    38

    39

#include "e1000.h"

    40

    41

enum {NETDEV_STATS, E1000_STATS};

    42

    43

struct e1000_stats {

    44

	char stat_string[ETH_GSTRING_LEN];

    45

	int type;

    46

	int sizeof_stat;

    47

	int stat_offset;

    48

};

    49

    50

#define E1000_STAT(str, m) { \

    51

		.stat_string = str, \

    52

		.type = E1000_STATS, \

    53

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

    54

		.stat_offset = offsetof(struct e1000_adapter, m) }

    55

#define E1000_NETDEV_STAT(str, m) { \

    56

		.stat_string = str, \

    57

		.type = NETDEV_STATS, \

    58

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

    59

		.stat_offset = offsetof(struct rtnl_link_stats64, m) }

    60

    61

static const struct e1000_stats e1000_gstrings_stats[] = {

    62

	E1000_STAT("rx_packets", stats.gprc),

    63

	E1000_STAT("tx_packets", stats.gptc),

    64

	E1000_STAT("rx_bytes", stats.gorc),

    65

	E1000_STAT("tx_bytes", stats.gotc),

    66

	E1000_STAT("rx_broadcast", stats.bprc),

    67

	E1000_STAT("tx_broadcast", stats.bptc),

    68

	E1000_STAT("rx_multicast", stats.mprc),

    69

	E1000_STAT("tx_multicast", stats.mptc),

    70

	E1000_NETDEV_STAT("rx_errors", rx_errors),

    71

	E1000_NETDEV_STAT("tx_errors", tx_errors),

    72

	E1000_NETDEV_STAT("tx_dropped", tx_dropped),

    73

	E1000_STAT("multicast", stats.mprc),

    74

	E1000_STAT("collisions", stats.colc),

    75

	E1000_NETDEV_STAT("rx_length_errors", rx_length_errors),

    76

	E1000_NETDEV_STAT("rx_over_errors", rx_over_errors),

    77

	E1000_STAT("rx_crc_errors", stats.crcerrs),

    78

	E1000_NETDEV_STAT("rx_frame_errors", rx_frame_errors),

    79

	E1000_STAT("rx_no_buffer_count", stats.rnbc),

    80

	E1000_STAT("rx_missed_errors", stats.mpc),

    81

	E1000_STAT("tx_aborted_errors", stats.ecol),

    82

	E1000_STAT("tx_carrier_errors", stats.tncrs),

    83

	E1000_NETDEV_STAT("tx_fifo_errors", tx_fifo_errors),

    84

	E1000_NETDEV_STAT("tx_heartbeat_errors", tx_heartbeat_errors),

    85

	E1000_STAT("tx_window_errors", stats.latecol),

    86

	E1000_STAT("tx_abort_late_coll", stats.latecol),

    87

	E1000_STAT("tx_deferred_ok", stats.dc),

    88

	E1000_STAT("tx_single_coll_ok", stats.scc),

    89

	E1000_STAT("tx_multi_coll_ok", stats.mcc),

    90

	E1000_STAT("tx_timeout_count", tx_timeout_count),

    91

	E1000_STAT("tx_restart_queue", restart_queue),

    92

	E1000_STAT("rx_long_length_errors", stats.roc),

    93

	E1000_STAT("rx_short_length_errors", stats.ruc),

    94

	E1000_STAT("rx_align_errors", stats.algnerrc),

    95

	E1000_STAT("tx_tcp_seg_good", stats.tsctc),

    96

	E1000_STAT("tx_tcp_seg_failed", stats.tsctfc),

    97

	E1000_STAT("rx_flow_control_xon", stats.xonrxc),

    98

	E1000_STAT("rx_flow_control_xoff", stats.xoffrxc),

    99

	E1000_STAT("tx_flow_control_xon", stats.xontxc),

   100

	E1000_STAT("tx_flow_control_xoff", stats.xofftxc),

   101

	E1000_STAT("rx_long_byte_count", stats.gorc),

   102

	E1000_STAT("rx_csum_offload_good", hw_csum_good),

   103

	E1000_STAT("rx_csum_offload_errors", hw_csum_err),

   104

	E1000_STAT("rx_header_split", rx_hdr_split),

   105

	E1000_STAT("alloc_rx_buff_failed", alloc_rx_buff_failed),

   106

	E1000_STAT("tx_smbus", stats.mgptc),

   107

	E1000_STAT("rx_smbus", stats.mgprc),

   108

	E1000_STAT("dropped_smbus", stats.mgpdc),

   109

	E1000_STAT("rx_dma_failed", rx_dma_failed),

   110

	E1000_STAT("tx_dma_failed", tx_dma_failed),

   111

};

   112

   113

#define E1000_GLOBAL_STATS_LEN	ARRAY_SIZE(e1000_gstrings_stats)

   114

#define E1000_STATS_LEN (E1000_GLOBAL_STATS_LEN)

   115

static const char e1000_gstrings_test[][ETH_GSTRING_LEN] = {

   116

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

   117

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

   118

	"Link test   (on/offline)"

   119

};

   120

#define E1000_TEST_LEN ARRAY_SIZE(e1000_gstrings_test)

   121

   122

static int e1000_get_settings(struct net_device *netdev,

   123

			      struct ethtool_cmd *ecmd)

   124

{

   125

	struct e1000_adapter *adapter = netdev_priv(netdev);

   126

	struct e1000_hw *hw = &adapter->hw;

   127

	u32 speed;

   128

   129

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

   130

   131

		ecmd->supported = (SUPPORTED_10baseT_Half |

   132

				   SUPPORTED_10baseT_Full |

   133

				   SUPPORTED_100baseT_Half |

   134

				   SUPPORTED_100baseT_Full |

   135

				   SUPPORTED_1000baseT_Full |

   136

				   SUPPORTED_Autoneg |

   137

				   SUPPORTED_TP);

   138

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

   139

			ecmd->supported &= ~SUPPORTED_1000baseT_Full;

   140

		ecmd->advertising = ADVERTISED_TP;

   141

   142

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

   143

			ecmd->advertising |= ADVERTISED_Autoneg;

   144

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

   145

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

   146

		}

   147

   148

		ecmd->port = PORT_TP;

   149

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

   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

		ecmd->transceiver = XCVR_EXTERNAL;

   163

	}

   164

   165

	speed = -1;

   166

	ecmd->duplex = -1;

   167

   168

	if (netif_running(netdev)) {

   169

		if (netif_carrier_ok(netdev)) {

   170

			speed = adapter->link_speed;

   171

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

   172

		}

   173

	} else {

   174

		u32 status = er32(STATUS);

   175

		if (status & E1000_STATUS_LU) {

   176

			if (status & E1000_STATUS_SPEED_1000)

   177

				speed = SPEED_1000;

   178

			else if (status & E1000_STATUS_SPEED_100)

   179

				speed = SPEED_100;

   180

			else

   181

				speed = SPEED_10;

   182

   183

			if (status & E1000_STATUS_FD)

   184

				ecmd->duplex = DUPLEX_FULL;

   185

			else

   186

				ecmd->duplex = DUPLEX_HALF;

   187

		}

   188

	}

   189

   190

	ethtool_cmd_speed_set(ecmd, speed);

   191

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

   192

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

   193

   194

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

   195

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

   196

	    netif_carrier_ok(netdev))

   197

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

   198

		                                      ETH_TP_MDI;

   199

	else

   200

		ecmd->eth_tp_mdix = ETH_TP_MDI_INVALID;

   201

   202

	return 0;

   203

}

   204

   205

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

   206

{

   207

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

   208

   209

	mac->autoneg = 0;

   210

   211

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

   212

	 * for the switch() below to work */

   213

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

   214

		goto err_inval;

   215

   216

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

   217

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

   218

	    spd != SPEED_1000 &&

   219

	    dplx != DUPLEX_FULL) {

   220

		goto err_inval;

   221

	}

   222

   223

	switch (spd + dplx) {

   224

	case SPEED_10 + DUPLEX_HALF:

   225

		mac->forced_speed_duplex = ADVERTISE_10_HALF;

   226

		break;

   227

	case SPEED_10 + DUPLEX_FULL:

   228

		mac->forced_speed_duplex = ADVERTISE_10_FULL;

   229

		break;

   230

	case SPEED_100 + DUPLEX_HALF:

   231

		mac->forced_speed_duplex = ADVERTISE_100_HALF;

   232

		break;

   233

	case SPEED_100 + DUPLEX_FULL:

   234

		mac->forced_speed_duplex = ADVERTISE_100_FULL;

   235

		break;

   236

	case SPEED_1000 + DUPLEX_FULL:

   237

		mac->autoneg = 1;

   238

		adapter->hw.phy.autoneg_advertised = ADVERTISE_1000_FULL;

   239

		break;

   240

	case SPEED_1000 + DUPLEX_HALF: /* not supported */

   241

	default:

   242

		goto err_inval;

   243

	}

   244

	return 0;

   245

   246

err_inval:

   247

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

   248

	return -EINVAL;

   249

}

   250

   251

static int e1000_set_settings(struct net_device *netdev,

   252

			      struct ethtool_cmd *ecmd)

   253

{

   254

	struct e1000_adapter *adapter = netdev_priv(netdev);

   255

	struct e1000_hw *hw = &adapter->hw;

   256

   257

	/*

   258

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

   259

	 * cannot be changed

   260

	 */

   261

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

   262

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

   263

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

   264

		return -EINVAL;

   265

	}

   266

   267

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

   268

		usleep_range(1000, 2000);

   269

   270

	if (ecmd->autoneg == AUTONEG_ENABLE) {

   271

		hw->mac.autoneg = 1;

   272

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

   273

			hw->phy.autoneg_advertised = ADVERTISED_1000baseT_Full |

   274

						     ADVERTISED_FIBRE |

   275

						     ADVERTISED_Autoneg;

   276

		else

   277

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

   278

						     ADVERTISED_TP |

   279

						     ADVERTISED_Autoneg;

   280

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

   281

		if (adapter->fc_autoneg)

   282

			hw->fc.requested_mode = e1000_fc_default;

   283

	} else {

   284

		u32 speed = ethtool_cmd_speed(ecmd);

   285

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

   286

			clear_bit(__E1000_RESETTING, &adapter->state);

   287

			return -EINVAL;

   288

		}

   289

	}

   290

   291

	/* reset the link */

   292

   293

	if (netif_running(adapter->netdev)) {

   294

		e1000e_down(adapter);

   295

		e1000e_up(adapter);

   296

	} else {

   297

		e1000e_reset(adapter);

   298

	}

   299

   300

	clear_bit(__E1000_RESETTING, &adapter->state);

   301

	return 0;

   302

}

   303

   304

static void e1000_get_pauseparam(struct net_device *netdev,

   305

				 struct ethtool_pauseparam *pause)

   306

{

   307

	struct e1000_adapter *adapter = netdev_priv(netdev);

   308

	struct e1000_hw *hw = &adapter->hw;

   309

   310

	pause->autoneg =

   311

		(adapter->fc_autoneg ? AUTONEG_ENABLE : AUTONEG_DISABLE);

   312

   313

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

   314

		pause->rx_pause = 1;

   315

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

   316

		pause->tx_pause = 1;

   317

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

   318

		pause->rx_pause = 1;

   319

		pause->tx_pause = 1;

   320

	}

   321

}

   322

   323

static int e1000_set_pauseparam(struct net_device *netdev,

   324

				struct ethtool_pauseparam *pause)

   325

{

   326

	struct e1000_adapter *adapter = netdev_priv(netdev);

   327

	struct e1000_hw *hw = &adapter->hw;

   328

	int retval = 0;

   329

   330

	adapter->fc_autoneg = pause->autoneg;

   331

   332

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

   333

		usleep_range(1000, 2000);

   334

   335

	if (adapter->fc_autoneg == AUTONEG_ENABLE) {

   336

		hw->fc.requested_mode = e1000_fc_default;

   337

		if (netif_running(adapter->netdev)) {

   338

			e1000e_down(adapter);

   339

			e1000e_up(adapter);

   340

		} else {

   341

			e1000e_reset(adapter);

   342

		}

   343

	} else {

   344

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

   345

			hw->fc.requested_mode = e1000_fc_full;

   346

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

   347

			hw->fc.requested_mode = e1000_fc_rx_pause;

   348

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

   349

			hw->fc.requested_mode = e1000_fc_tx_pause;

   350

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

   351

			hw->fc.requested_mode = e1000_fc_none;

   352

   353

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

   354

   355

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

   356

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

   357

			/* implicit goto out */

   358

		} else {

   359

			retval = e1000e_force_mac_fc(hw);

   360

			if (retval)

   361

				goto out;

   362

			e1000e_set_fc_watermarks(hw);

   363

		}

   364

	}

   365

   366

out:

   367

	clear_bit(__E1000_RESETTING, &adapter->state);

   368

	return retval;

   369

}

   370

   371

static u32 e1000_get_msglevel(struct net_device *netdev)

   372

{

   373

	struct e1000_adapter *adapter = netdev_priv(netdev);

   374

	return adapter->msg_enable;

   375

}

   376

   377

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

   378

{

   379

	struct e1000_adapter *adapter = netdev_priv(netdev);

   380

	adapter->msg_enable = data;

   381

}

   382

   383

static int e1000_get_regs_len(struct net_device *netdev)

   384

{

   385

#define E1000_REGS_LEN 32 /* overestimate */

   386

	return E1000_REGS_LEN * sizeof(u32);

   387

}

   388

   389

static void e1000_get_regs(struct net_device *netdev,

   390

			   struct ethtool_regs *regs, void *p)

   391

{

   392

	struct e1000_adapter *adapter = netdev_priv(netdev);

   393

	struct e1000_hw *hw = &adapter->hw;

   394

	u32 *regs_buff = p;

   395

	u16 phy_data;

   396

   397

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

   398

   399

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

   400

			adapter->pdev->device;

   401

   402

	regs_buff[0]  = er32(CTRL);

   403

	regs_buff[1]  = er32(STATUS);

   404

   405

	regs_buff[2]  = er32(RCTL);

   406

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

   407

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

   408

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

   409

	regs_buff[6]  = er32(RDTR);

   410

   411

	regs_buff[7]  = er32(TCTL);

   412

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

   413

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

   414

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

   415

	regs_buff[11] = er32(TIDV);

   416

   417

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

   418

   419

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

   420

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

   421

	 * exist */

   422

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

   423

		e1e_rphy(hw, M88E1000_PHY_SPEC_STATUS, &phy_data);

   424

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

   425

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

   426

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

   427

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

   428

		e1e_rphy(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);

   429

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

   430

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

   431

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

   432

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

   433

		/* phy receive errors */

   434

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

   435

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

   436

	}

   437

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

   438

	e1e_rphy(hw, PHY_1000T_STATUS, &phy_data);

   439

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

   440

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

   441

}

   442

   443

static int e1000_get_eeprom_len(struct net_device *netdev)

   444

{

   445

	struct e1000_adapter *adapter = netdev_priv(netdev);

   446

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

   447

}

   448

   449

static int e1000_get_eeprom(struct net_device *netdev,

   450

			    struct ethtool_eeprom *eeprom, u8 *bytes)

   451

{

   452

	struct e1000_adapter *adapter = netdev_priv(netdev);

   453

	struct e1000_hw *hw = &adapter->hw;

   454

	u16 *eeprom_buff;

   455

	int first_word;

   456

	int last_word;

   457

	int ret_val = 0;

   458

	u16 i;

   459

   460

	if (eeprom->len == 0)

   461

		return -EINVAL;

   462

   463

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

   464

   465

	first_word = eeprom->offset >> 1;

   466

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

   467

   468

	eeprom_buff = kmalloc(sizeof(u16) *

   469

			(last_word - first_word + 1), GFP_KERNEL);

   470

	if (!eeprom_buff)

   471

		return -ENOMEM;

   472

   473

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

   474

		ret_val = e1000_read_nvm(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

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

   480

						      &eeprom_buff[i]);

   481

			if (ret_val)

   482

				break;

   483

		}

   484

	}

   485

   486

	if (ret_val) {

   487

		/* a read error occurred, throw away the result */

   488

		memset(eeprom_buff, 0xff, sizeof(u16) *

   489

		       (last_word - first_word + 1));

   490

	} else {

   491

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

   492

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

   493

			le16_to_cpus(&eeprom_buff[i]);

   494

	}

   495

   496

	memcpy(bytes, (u8 *)eeprom_buff + (eeprom->offset & 1), eeprom->len);

   497

	kfree(eeprom_buff);

   498

   499

	return ret_val;

   500

}

   501

   502

static int e1000_set_eeprom(struct net_device *netdev,

   503

			    struct ethtool_eeprom *eeprom, u8 *bytes)

   504

{

   505

	struct e1000_adapter *adapter = netdev_priv(netdev);

   506

	struct e1000_hw *hw = &adapter->hw;

   507

	u16 *eeprom_buff;

   508

	void *ptr;

   509

	int max_len;

   510

	int first_word;

   511

	int last_word;

   512

	int ret_val = 0;

   513

	u16 i;

   514

   515

	if (eeprom->len == 0)

   516

		return -EOPNOTSUPP;

   517

   518

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

   519

		return -EFAULT;

   520

   521

	if (adapter->flags & FLAG_READ_ONLY_NVM)

   522

		return -EINVAL;

   523

   524

	max_len = hw->nvm.word_size * 2;

   525

   526

	first_word = eeprom->offset >> 1;

   527

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

   528

	eeprom_buff = kmalloc(max_len, GFP_KERNEL);

   529

	if (!eeprom_buff)