1

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

     2

     3

  Intel PRO/1000 Linux driver

     4

  Copyright(c) 1999 - 2011 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

#include "e1000.h"

    30

    31

enum e1000_mng_mode {

    32

	e1000_mng_mode_none = 0,

    33

	e1000_mng_mode_asf,

    34

	e1000_mng_mode_pt,

    35

	e1000_mng_mode_ipmi,

    36

	e1000_mng_mode_host_if_only

    37

};

    38

    39

#define E1000_FACTPS_MNGCG		0x20000000

    40

    41

/* Intel(R) Active Management Technology signature */

    42

#define E1000_IAMT_SIGNATURE		0x544D4149

    43

    44

/**

    45

 *  e1000e_get_bus_info_pcie - Get PCIe bus information

    46

 *  @hw: pointer to the HW structure

    47

 *

    48

 *  Determines and stores the system bus information for a particular

    49

 *  network interface.  The following bus information is determined and stored:

    50

 *  bus speed, bus width, type (PCIe), and PCIe function.

    51

 **/

    52

s32 e1000e_get_bus_info_pcie(struct e1000_hw *hw)

    53

{

    54

	struct e1000_mac_info *mac = &hw->mac;

    55

	struct e1000_bus_info *bus = &hw->bus;

    56

	struct e1000_adapter *adapter = hw->adapter;

    57

	u16 pcie_link_status, cap_offset;

    58

    59

	cap_offset = adapter->pdev->pcie_cap;

    60

	if (!cap_offset) {

    61

		bus->width = e1000_bus_width_unknown;

    62

	} else {

    63

		pci_read_config_word(adapter->pdev,

    64

				     cap_offset + PCIE_LINK_STATUS,

    65

				     &pcie_link_status);

    66

		bus->width = (enum e1000_bus_width)((pcie_link_status &

    67

						     PCIE_LINK_WIDTH_MASK) >>

    68

						    PCIE_LINK_WIDTH_SHIFT);

    69

	}

    70

    71

	mac->ops.set_lan_id(hw);

    72

    73

	return 0;

    74

}

    75

    76

/**

    77

 *  e1000_set_lan_id_multi_port_pcie - Set LAN id for PCIe multiple port devices

    78

 *

    79

 *  @hw: pointer to the HW structure

    80

 *

    81

 *  Determines the LAN function id by reading memory-mapped registers

    82

 *  and swaps the port value if requested.

    83

 **/

    84

void e1000_set_lan_id_multi_port_pcie(struct e1000_hw *hw)

    85

{

    86

	struct e1000_bus_info *bus = &hw->bus;

    87

	u32 reg;

    88

    89

	/*

    90

	 * The status register reports the correct function number

    91

	 * for the device regardless of function swap state.

    92

	 */

    93

	reg = er32(STATUS);

    94

	bus->func = (reg & E1000_STATUS_FUNC_MASK) >> E1000_STATUS_FUNC_SHIFT;

    95

}

    96

    97

/**

    98

 *  e1000_set_lan_id_single_port - Set LAN id for a single port device

    99

 *  @hw: pointer to the HW structure

   100

 *

   101

 *  Sets the LAN function id to zero for a single port device.

   102

 **/

   103

void e1000_set_lan_id_single_port(struct e1000_hw *hw)

   104

{

   105

	struct e1000_bus_info *bus = &hw->bus;

   106

   107

	bus->func = 0;

   108

}

   109

   110

/**

   111

 *  e1000_clear_vfta_generic - Clear VLAN filter table

   112

 *  @hw: pointer to the HW structure

   113

 *

   114

 *  Clears the register array which contains the VLAN filter table by

   115

 *  setting all the values to 0.

   116

 **/

   117

void e1000_clear_vfta_generic(struct e1000_hw *hw)

   118

{

   119

	u32 offset;

   120

   121

	for (offset = 0; offset < E1000_VLAN_FILTER_TBL_SIZE; offset++) {

   122

		E1000_WRITE_REG_ARRAY(hw, E1000_VFTA, offset, 0);

   123

		e1e_flush();

   124

	}

   125

}

   126

   127

/**

   128

 *  e1000_write_vfta_generic - Write value to VLAN filter table

   129

 *  @hw: pointer to the HW structure

   130

 *  @offset: register offset in VLAN filter table

   131

 *  @value: register value written to VLAN filter table

   132

 *

   133

 *  Writes value at the given offset in the register array which stores

   134

 *  the VLAN filter table.

   135

 **/

   136

void e1000_write_vfta_generic(struct e1000_hw *hw, u32 offset, u32 value)

   137

{

   138

	E1000_WRITE_REG_ARRAY(hw, E1000_VFTA, offset, value);

   139

	e1e_flush();

   140

}

   141

   142

/**

   143

 *  e1000e_init_rx_addrs - Initialize receive address's

   144

 *  @hw: pointer to the HW structure

   145

 *  @rar_count: receive address registers

   146

 *

   147

 *  Setup the receive address registers by setting the base receive address

   148

 *  register to the devices MAC address and clearing all the other receive

   149

 *  address registers to 0.

   150

 **/

   151

void e1000e_init_rx_addrs(struct e1000_hw *hw, u16 rar_count)

   152

{

   153

	u32 i;

   154

	u8 mac_addr[ETH_ALEN] = {0};

   155

   156

	/* Setup the receive address */

   157

	e_dbg("Programming MAC Address into RAR[0]\n");

   158

   159

	e1000e_rar_set(hw, hw->mac.addr, 0);

   160

   161

	/* Zero out the other (rar_entry_count - 1) receive addresses */

   162

	e_dbg("Clearing RAR[1-%u]\n", rar_count-1);

   163

	for (i = 1; i < rar_count; i++)

   164

		e1000e_rar_set(hw, mac_addr, i);

   165

}

   166

   167

/**

   168

 *  e1000_check_alt_mac_addr_generic - Check for alternate MAC addr

   169

 *  @hw: pointer to the HW structure

   170

 *

   171

 *  Checks the nvm for an alternate MAC address.  An alternate MAC address

   172

 *  can be setup by pre-boot software and must be treated like a permanent

   173

 *  address and must override the actual permanent MAC address. If an

   174

 *  alternate MAC address is found it is programmed into RAR0, replacing

   175

 *  the permanent address that was installed into RAR0 by the Si on reset.

   176

 *  This function will return SUCCESS unless it encounters an error while

   177

 *  reading the EEPROM.

   178

 **/

   179

s32 e1000_check_alt_mac_addr_generic(struct e1000_hw *hw)

   180

{

   181

	u32 i;

   182

	s32 ret_val = 0;

   183

	u16 offset, nvm_alt_mac_addr_offset, nvm_data;

   184

	u8 alt_mac_addr[ETH_ALEN];

   185

   186

	ret_val = e1000_read_nvm(hw, NVM_COMPAT, 1, &nvm_data);

   187

	if (ret_val)

   188

		goto out;

   189

   190

	/* Check for LOM (vs. NIC) or one of two valid mezzanine cards */

   191

	if (!((nvm_data & NVM_COMPAT_LOM) ||

   192

	      (hw->adapter->pdev->device == E1000_DEV_ID_82571EB_SERDES_DUAL) ||

   193

	      (hw->adapter->pdev->device == E1000_DEV_ID_82571EB_SERDES_QUAD) ||

   194

	      (hw->adapter->pdev->device == E1000_DEV_ID_82571EB_SERDES)))

   195

		goto out;

   196

   197

	ret_val = e1000_read_nvm(hw, NVM_ALT_MAC_ADDR_PTR, 1,

   198

	                         &nvm_alt_mac_addr_offset);

   199

	if (ret_val) {

   200

		e_dbg("NVM Read Error\n");

   201

		goto out;

   202

	}

   203

   204

	if ((nvm_alt_mac_addr_offset == 0xFFFF) ||

   205

	    (nvm_alt_mac_addr_offset == 0x0000))

   206

		/* There is no Alternate MAC Address */

   207

		goto out;

   208

   209

	if (hw->bus.func == E1000_FUNC_1)

   210

		nvm_alt_mac_addr_offset += E1000_ALT_MAC_ADDRESS_OFFSET_LAN1;

   211

	for (i = 0; i < ETH_ALEN; i += 2) {

   212

		offset = nvm_alt_mac_addr_offset + (i >> 1);

   213

		ret_val = e1000_read_nvm(hw, offset, 1, &nvm_data);

   214

		if (ret_val) {

   215

			e_dbg("NVM Read Error\n");

   216

			goto out;

   217

		}

   218

   219

		alt_mac_addr[i] = (u8)(nvm_data & 0xFF);

   220

		alt_mac_addr[i + 1] = (u8)(nvm_data >> 8);

   221

	}

   222

   223

	/* if multicast bit is set, the alternate address will not be used */

   224

	if (is_multicast_ether_addr(alt_mac_addr)) {

   225

		e_dbg("Ignoring Alternate Mac Address with MC bit set\n");

   226

		goto out;

   227

	}

   228

   229

	/*

   230

	 * We have a valid alternate MAC address, and we want to treat it the

   231

	 * same as the normal permanent MAC address stored by the HW into the

   232

	 * RAR. Do this by mapping this address into RAR0.

   233

	 */

   234

	e1000e_rar_set(hw, alt_mac_addr, 0);

   235

   236

out:

   237

	return ret_val;

   238

}

   239

   240

/**

   241

 *  e1000e_rar_set - Set receive address register

   242

 *  @hw: pointer to the HW structure

   243

 *  @addr: pointer to the receive address

   244

 *  @index: receive address array register

   245

 *

   246

 *  Sets the receive address array register at index to the address passed

   247

 *  in by addr.

   248

 **/

   249

void e1000e_rar_set(struct e1000_hw *hw, u8 *addr, u32 index)

   250

{

   251

	u32 rar_low, rar_high;

   252

   253

	/*

   254

	 * HW expects these in little endian so we reverse the byte order

   255

	 * from network order (big endian) to little endian

   256

	 */

   257

	rar_low = ((u32) addr[0] |

   258

		   ((u32) addr[1] << 8) |

   259

		    ((u32) addr[2] << 16) | ((u32) addr[3] << 24));

   260

   261

	rar_high = ((u32) addr[4] | ((u32) addr[5] << 8));

   262

   263

	/* If MAC address zero, no need to set the AV bit */

   264

	if (rar_low || rar_high)

   265

		rar_high |= E1000_RAH_AV;

   266

   267

	/*

   268

	 * Some bridges will combine consecutive 32-bit writes into

   269

	 * a single burst write, which will malfunction on some parts.

   270

	 * The flushes avoid this.

   271

	 */

   272

	ew32(RAL(index), rar_low);

   273

	e1e_flush();

   274

	ew32(RAH(index), rar_high);

   275

	e1e_flush();

   276

}

   277

   278

/**

   279

 *  e1000_hash_mc_addr - Generate a multicast hash value

   280

 *  @hw: pointer to the HW structure

   281

 *  @mc_addr: pointer to a multicast address

   282

 *

   283

 *  Generates a multicast address hash value which is used to determine

   284

 *  the multicast filter table array address and new table value.  See

   285

 *  e1000_mta_set_generic()

   286

 **/

   287

static u32 e1000_hash_mc_addr(struct e1000_hw *hw, u8 *mc_addr)

   288

{

   289

	u32 hash_value, hash_mask;

   290

	u8 bit_shift = 0;

   291

   292

	/* Register count multiplied by bits per register */

   293

	hash_mask = (hw->mac.mta_reg_count * 32) - 1;

   294

   295

	/*

   296

	 * For a mc_filter_type of 0, bit_shift is the number of left-shifts

   297

	 * where 0xFF would still fall within the hash mask.

   298

	 */

   299

	while (hash_mask >> bit_shift != 0xFF)

   300

		bit_shift++;

   301

   302

	/*

   303

	 * The portion of the address that is used for the hash table

   304

	 * is determined by the mc_filter_type setting.

   305

	 * The algorithm is such that there is a total of 8 bits of shifting.

   306

	 * The bit_shift for a mc_filter_type of 0 represents the number of

   307

	 * left-shifts where the MSB of mc_addr[5] would still fall within

   308

	 * the hash_mask.  Case 0 does this exactly.  Since there are a total

   309

	 * of 8 bits of shifting, then mc_addr[4] will shift right the

   310

	 * remaining number of bits. Thus 8 - bit_shift.  The rest of the

   311

	 * cases are a variation of this algorithm...essentially raising the

   312

	 * number of bits to shift mc_addr[5] left, while still keeping the

   313

	 * 8-bit shifting total.

   314

	 *

   315

	 * For example, given the following Destination MAC Address and an

   316

	 * mta register count of 128 (thus a 4096-bit vector and 0xFFF mask),

   317

	 * we can see that the bit_shift for case 0 is 4.  These are the hash

   318

	 * values resulting from each mc_filter_type...

   319

	 * [0] [1] [2] [3] [4] [5]

   320

	 * 01  AA  00  12  34  56

   321

	 * LSB		 MSB

   322

	 *

   323

	 * case 0: hash_value = ((0x34 >> 4) | (0x56 << 4)) & 0xFFF = 0x563

   324

	 * case 1: hash_value = ((0x34 >> 3) | (0x56 << 5)) & 0xFFF = 0xAC6

   325

	 * case 2: hash_value = ((0x34 >> 2) | (0x56 << 6)) & 0xFFF = 0x163

   326

	 * case 3: hash_value = ((0x34 >> 0) | (0x56 << 8)) & 0xFFF = 0x634

   327

	 */

   328

	switch (hw->mac.mc_filter_type) {

   329

	default:

   330

	case 0:

   331

		break;

   332

	case 1:

   333

		bit_shift += 1;

   334

		break;

   335

	case 2:

   336

		bit_shift += 2;

   337

		break;

   338

	case 3:

   339

		bit_shift += 4;

   340

		break;

   341

	}

   342

   343

	hash_value = hash_mask & (((mc_addr[4] >> (8 - bit_shift)) |

   344

				  (((u16) mc_addr[5]) << bit_shift)));

   345

   346

	return hash_value;

   347

}

   348

   349

/**

   350

 *  e1000e_update_mc_addr_list_generic - Update Multicast addresses

   351

 *  @hw: pointer to the HW structure

   352

 *  @mc_addr_list: array of multicast addresses to program

   353

 *  @mc_addr_count: number of multicast addresses to program

   354

 *

   355

 *  Updates entire Multicast Table Array.

   356

 *  The caller must have a packed mc_addr_list of multicast addresses.

   357

 **/

   358

void e1000e_update_mc_addr_list_generic(struct e1000_hw *hw,

   359

					u8 *mc_addr_list, u32 mc_addr_count)

   360

{

   361

	u32 hash_value, hash_bit, hash_reg;

   362

	int i;

   363

   364

	/* clear mta_shadow */

   365

	memset(&hw->mac.mta_shadow, 0, sizeof(hw->mac.mta_shadow));

   366

   367

	/* update mta_shadow from mc_addr_list */

   368

	for (i = 0; (u32) i < mc_addr_count; i++) {

   369

		hash_value = e1000_hash_mc_addr(hw, mc_addr_list);

   370

   371

		hash_reg = (hash_value >> 5) & (hw->mac.mta_reg_count - 1);

   372

		hash_bit = hash_value & 0x1F;

   373

   374

		hw->mac.mta_shadow[hash_reg] |= (1 << hash_bit);

   375

		mc_addr_list += (ETH_ALEN);

   376

	}

   377

   378

	/* replace the entire MTA table */

   379

	for (i = hw->mac.mta_reg_count - 1; i >= 0; i--)

   380

		E1000_WRITE_REG_ARRAY(hw, E1000_MTA, i, hw->mac.mta_shadow[i]);

   381

	e1e_flush();

   382

}

   383

   384

/**

   385

 *  e1000e_clear_hw_cntrs_base - Clear base hardware counters

   386

 *  @hw: pointer to the HW structure

   387

 *

   388

 *  Clears the base hardware counters by reading the counter registers.

   389

 **/

   390

void e1000e_clear_hw_cntrs_base(struct e1000_hw *hw)

   391

{

   392

	er32(CRCERRS);

   393

	er32(SYMERRS);

   394

	er32(MPC);

   395

	er32(SCC);

   396

	er32(ECOL);

   397

	er32(MCC);

   398

	er32(LATECOL);

   399

	er32(COLC);

   400

	er32(DC);

   401

	er32(SEC);

   402

	er32(RLEC);

   403

	er32(XONRXC);

   404

	er32(XONTXC);

   405

	er32(XOFFRXC);

   406

	er32(XOFFTXC);

   407

	er32(FCRUC);

   408

	er32(GPRC);

   409

	er32(BPRC);

   410

	er32(MPRC);

   411

	er32(GPTC);

   412

	er32(GORCL);

   413

	er32(GORCH);

   414

	er32(GOTCL);

   415

	er32(GOTCH);

   416

	er32(RNBC);

   417

	er32(RUC);

   418

	er32(RFC);

   419

	er32(ROC);

   420

	er32(RJC);

   421

	er32(TORL);

   422

	er32(TORH);

   423

	er32(TOTL);

   424

	er32(TOTH);

   425

	er32(TPR);

   426

	er32(TPT);

   427

	er32(MPTC);

   428

	er32(BPTC);

   429

}

   430

   431

/**

   432

 *  e1000e_check_for_copper_link - Check for link (Copper)

   433

 *  @hw: pointer to the HW structure

   434

 *

   435

 *  Checks to see of the link status of the hardware has changed.  If a

   436

 *  change in link status has been detected, then we read the PHY registers

   437

 *  to get the current speed/duplex if link exists.

   438

 **/

   439

s32 e1000e_check_for_copper_link(struct e1000_hw *hw)

   440

{

   441

	struct e1000_mac_info *mac = &hw->mac;

   442

	s32 ret_val;

   443

	bool link;

   444

   445

	/*

   446

	 * We only want to go out to the PHY registers to see if Auto-Neg

   447

	 * has completed and/or if our link status has changed.  The

   448

	 * get_link_status flag is set upon receiving a Link Status

   449

	 * Change or Rx Sequence Error interrupt.

   450

	 */

   451

	if (!mac->get_link_status)

   452

		return 0;

   453

   454

	/*

   455

	 * First we want to see if the MII Status Register reports

   456

	 * link.  If so, then we want to get the current speed/duplex

   457

	 * of the PHY.

   458

	 */

   459

	ret_val = e1000e_phy_has_link_generic(hw, 1, 0, &link);

   460

	if (ret_val)

   461

		return ret_val;

   462

   463

	if (!link)

   464

		return ret_val; /* No link detected */

   465

   466

	mac->get_link_status = false;

   467

   468

	/*

   469

	 * Check if there was DownShift, must be checked

   470

	 * immediately after link-up

   471

	 */

   472

	e1000e_check_downshift(hw);

   473

   474

	/*

   475

	 * If we are forcing speed/duplex, then we simply return since

   476

	 * we have already determined whether we have link or not.

   477

	 */

   478

	if (!mac->autoneg) {

   479

		ret_val = -E1000_ERR_CONFIG;

   480

		return ret_val;

   481

	}

   482

   483

	/*

   484

	 * Auto-Neg is enabled.  Auto Speed Detection takes care

   485

	 * of MAC speed/duplex configuration.  So we only need to

   486

	 * configure Collision Distance in the MAC.

   487

	 */

   488

	e1000e_config_collision_dist(hw);

   489

   490

	/*

   491

	 * Configure Flow Control now that Auto-Neg has completed.

   492

	 * First, we need to restore the desired flow control

   493

	 * settings because we may have had to re-autoneg with a

   494

	 * different link partner.

   495

	 */

   496

	ret_val = e1000e_config_fc_after_link_up(hw);

   497

	if (ret_val)

   498

		e_dbg("Error configuring flow control\n");

   499

   500

	return ret_val;

   501

}

   502

   503

/**

   504

 *  e1000e_check_for_fiber_link - Check for link (Fiber)

   505

 *  @hw: pointer to the HW structure

   506

 *

   507

 *  Checks for link up on the hardware.  If link is not up and we have

   508

 *  a signal, then we need to force link up.

   509

 **/

   510

s32 e1000e_check_for_fiber_link(struct e1000_hw *hw)

   511

{

   512

	struct e1000_mac_info *mac = &hw->mac;

   513

	u32 rxcw;

   514

	u32 ctrl;

   515

	u32 status;

   516

	s32 ret_val;

   517

   518

	ctrl = er32(CTRL);

   519

	status = er32(STATUS);

   520

	rxcw = er32(RXCW);

   521

   522

	/*

   523

	 * If we don't have link (auto-negotiation failed or link partner

   524

	 * cannot auto-negotiate), the cable is plugged in (we have signal),

   525

	 * and our link partner is not trying to auto-negotiate with us (we

   526

	 * are receiving idles or data), we need to force link up. We also

   527

	 * need to give auto-negotiation time to complete, in case the cable

   528

	 * was just plugged in. The autoneg_failed flag does this.

   529

	 */

   530

	/* (ctrl & E1000_CTRL_SWDPIN1) == 1 == have signal */