1

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

     2

     3

  Intel PRO/1000 Linux driver

     4

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

/*

    30

 * 82571EB Gigabit Ethernet Controller

    31

 * 82571EB Gigabit Ethernet Controller (Copper)

    32

 * 82571EB Gigabit Ethernet Controller (Fiber)

    33

 * 82571EB Dual Port Gigabit Mezzanine Adapter

    34

 * 82571EB Quad Port Gigabit Mezzanine Adapter

    35

 * 82571PT Gigabit PT Quad Port Server ExpressModule

    36

 * 82572EI Gigabit Ethernet Controller (Copper)

    37

 * 82572EI Gigabit Ethernet Controller (Fiber)

    38

 * 82572EI Gigabit Ethernet Controller

    39

 * 82573V Gigabit Ethernet Controller (Copper)

    40

 * 82573E Gigabit Ethernet Controller (Copper)

    41

 * 82573L Gigabit Ethernet Controller

    42

 * 82574L Gigabit Network Connection

    43

 * 82583V Gigabit Network Connection

    44

 */

    45

    46

#include "e1000-2.6.35-ethercat.h"

    47

    48

#define ID_LED_RESERVED_F746 0xF746

    49

#define ID_LED_DEFAULT_82573 ((ID_LED_DEF1_DEF2 << 12) | \

    50

			      (ID_LED_OFF1_ON2  <<  8) | \

    51

			      (ID_LED_DEF1_DEF2 <<  4) | \

    52

			      (ID_LED_DEF1_DEF2))

    53

    54

#define E1000_GCR_L1_ACT_WITHOUT_L0S_RX 0x08000000

    55

    56

#define E1000_NVM_INIT_CTRL2_MNGM 0x6000 /* Manageability Operation Mode mask */

    57

    58

static s32 e1000_get_phy_id_82571(struct e1000_hw *hw);

    59

static s32 e1000_setup_copper_link_82571(struct e1000_hw *hw);

    60

static s32 e1000_setup_fiber_serdes_link_82571(struct e1000_hw *hw);

    61

static s32 e1000_check_for_serdes_link_82571(struct e1000_hw *hw);

    62

static s32 e1000_write_nvm_eewr_82571(struct e1000_hw *hw, u16 offset,

    63

				      u16 words, u16 *data);

    64

static s32 e1000_fix_nvm_checksum_82571(struct e1000_hw *hw);

    65

static void e1000_initialize_hw_bits_82571(struct e1000_hw *hw);

    66

static s32 e1000_setup_link_82571(struct e1000_hw *hw);

    67

static void e1000_clear_hw_cntrs_82571(struct e1000_hw *hw);

    68

static void e1000_clear_vfta_82571(struct e1000_hw *hw);

    69

static bool e1000_check_mng_mode_82574(struct e1000_hw *hw);

    70

static s32 e1000_led_on_82574(struct e1000_hw *hw);

    71

static void e1000_put_hw_semaphore_82571(struct e1000_hw *hw);

    72

static void e1000_power_down_phy_copper_82571(struct e1000_hw *hw);

    73

    74

/**

    75

 *  e1000_init_phy_params_82571 - Init PHY func ptrs.

    76

 *  @hw: pointer to the HW structure

    77

 **/

    78

static s32 e1000_init_phy_params_82571(struct e1000_hw *hw)

    79

{

    80

	struct e1000_phy_info *phy = &hw->phy;

    81

	s32 ret_val;

    82

    83

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

    84

		phy->type = e1000_phy_none;

    85

		return 0;

    86

	}

    87

    88

	phy->addr			 = 1;

    89

	phy->autoneg_mask		 = AUTONEG_ADVERTISE_SPEED_DEFAULT;

    90

	phy->reset_delay_us		 = 100;

    91

    92

	phy->ops.power_up		 = e1000_power_up_phy_copper;

    93

	phy->ops.power_down		 = e1000_power_down_phy_copper_82571;

    94

    95

	switch (hw->mac.type) {

    96

	case e1000_82571:

    97

	case e1000_82572:

    98

		phy->type		 = e1000_phy_igp_2;

    99

		break;

   100

	case e1000_82573:

   101

		phy->type		 = e1000_phy_m88;

   102

		break;

   103

	case e1000_82574:

   104

	case e1000_82583:

   105

		phy->type		 = e1000_phy_bm;

   106

		break;

   107

	default:

   108

		return -E1000_ERR_PHY;

   109

		break;

   110

	}

   111

   112

	/* This can only be done after all function pointers are setup. */

   113

	ret_val = e1000_get_phy_id_82571(hw);

   114

   115

	/* Verify phy id */

   116

	switch (hw->mac.type) {

   117

	case e1000_82571:

   118

	case e1000_82572:

   119

		if (phy->id != IGP01E1000_I_PHY_ID)

   120

			return -E1000_ERR_PHY;

   121

		break;

   122

	case e1000_82573:

   123

		if (phy->id != M88E1111_I_PHY_ID)

   124

			return -E1000_ERR_PHY;

   125

		break;

   126

	case e1000_82574:

   127

	case e1000_82583:

   128

		if (phy->id != BME1000_E_PHY_ID_R2)

   129

			return -E1000_ERR_PHY;

   130

		break;

   131

	default:

   132

		return -E1000_ERR_PHY;

   133

		break;

   134

	}

   135

   136

	return 0;

   137

}

   138

   139

/**

   140

 *  e1000_init_nvm_params_82571 - Init NVM func ptrs.

   141

 *  @hw: pointer to the HW structure

   142

 **/

   143

static s32 e1000_init_nvm_params_82571(struct e1000_hw *hw)

   144

{

   145

	struct e1000_nvm_info *nvm = &hw->nvm;

   146

	u32 eecd = er32(EECD);

   147

	u16 size;

   148

   149

	nvm->opcode_bits = 8;

   150

	nvm->delay_usec = 1;

   151

	switch (nvm->override) {

   152

	case e1000_nvm_override_spi_large:

   153

		nvm->page_size = 32;

   154

		nvm->address_bits = 16;

   155

		break;

   156

	case e1000_nvm_override_spi_small:

   157

		nvm->page_size = 8;

   158

		nvm->address_bits = 8;

   159

		break;

   160

	default:

   161

		nvm->page_size = eecd & E1000_EECD_ADDR_BITS ? 32 : 8;

   162

		nvm->address_bits = eecd & E1000_EECD_ADDR_BITS ? 16 : 8;

   163

		break;

   164

	}

   165

   166

	switch (hw->mac.type) {

   167

	case e1000_82573:

   168

	case e1000_82574:

   169

	case e1000_82583:

   170

		if (((eecd >> 15) & 0x3) == 0x3) {

   171

			nvm->type = e1000_nvm_flash_hw;

   172

			nvm->word_size = 2048;

   173

			/*

   174

			 * Autonomous Flash update bit must be cleared due

   175

			 * to Flash update issue.

   176

			 */

   177

			eecd &= ~E1000_EECD_AUPDEN;

   178

			ew32(EECD, eecd);

   179

			break;

   180

		}

   181

		/* Fall Through */

   182

	default:

   183

		nvm->type = e1000_nvm_eeprom_spi;

   184

		size = (u16)((eecd & E1000_EECD_SIZE_EX_MASK) >>

   185

				  E1000_EECD_SIZE_EX_SHIFT);

   186

		/*

   187

		 * Added to a constant, "size" becomes the left-shift value

   188

		 * for setting word_size.

   189

		 */

   190

		size += NVM_WORD_SIZE_BASE_SHIFT;

   191

   192

		/* EEPROM access above 16k is unsupported */

   193

		if (size > 14)

   194

			size = 14;

   195

		nvm->word_size	= 1 << size;

   196

		break;

   197

	}

   198

   199

	return 0;

   200

}

   201

   202

/**

   203

 *  e1000_init_mac_params_82571 - Init MAC func ptrs.

   204

 *  @hw: pointer to the HW structure

   205

 **/

   206

static s32 e1000_init_mac_params_82571(struct e1000_adapter *adapter)

   207

{

   208

	struct e1000_hw *hw = &adapter->hw;

   209

	struct e1000_mac_info *mac = &hw->mac;

   210

	struct e1000_mac_operations *func = &mac->ops;

   211

	u32 swsm = 0;

   212

	u32 swsm2 = 0;

   213

	bool force_clear_smbi = false;

   214

   215

	/* Set media type */

   216

	switch (adapter->pdev->device) {

   217

	case E1000_DEV_ID_82571EB_FIBER:

   218

	case E1000_DEV_ID_82572EI_FIBER:

   219

	case E1000_DEV_ID_82571EB_QUAD_FIBER:

   220

		hw->phy.media_type = e1000_media_type_fiber;

   221

		break;

   222

	case E1000_DEV_ID_82571EB_SERDES:

   223

	case E1000_DEV_ID_82572EI_SERDES:

   224

	case E1000_DEV_ID_82571EB_SERDES_DUAL:

   225

	case E1000_DEV_ID_82571EB_SERDES_QUAD:

   226

		hw->phy.media_type = e1000_media_type_internal_serdes;

   227

		break;

   228

	default:

   229

		hw->phy.media_type = e1000_media_type_copper;

   230

		break;

   231

	}

   232

   233

	/* Set mta register count */

   234

	mac->mta_reg_count = 128;

   235

	/* Set rar entry count */

   236

	mac->rar_entry_count = E1000_RAR_ENTRIES;

   237

	/* Adaptive IFS supported */

   238

	mac->adaptive_ifs = true;

   239

   240

	/* check for link */

   241

	switch (hw->phy.media_type) {

   242

	case e1000_media_type_copper:

   243

		func->setup_physical_interface = e1000_setup_copper_link_82571;

   244

		func->check_for_link = e1000e_check_for_copper_link;

   245

		func->get_link_up_info = e1000e_get_speed_and_duplex_copper;

   246

		break;

   247

	case e1000_media_type_fiber:

   248

		func->setup_physical_interface =

   249

			e1000_setup_fiber_serdes_link_82571;

   250

		func->check_for_link = e1000e_check_for_fiber_link;

   251

		func->get_link_up_info =

   252

			e1000e_get_speed_and_duplex_fiber_serdes;

   253

		break;

   254

	case e1000_media_type_internal_serdes:

   255

		func->setup_physical_interface =

   256

			e1000_setup_fiber_serdes_link_82571;

   257

		func->check_for_link = e1000_check_for_serdes_link_82571;

   258

		func->get_link_up_info =

   259

			e1000e_get_speed_and_duplex_fiber_serdes;

   260

		break;

   261

	default:

   262

		return -E1000_ERR_CONFIG;

   263

		break;

   264

	}

   265

   266

	switch (hw->mac.type) {

   267

	case e1000_82573:

   268

		func->set_lan_id = e1000_set_lan_id_single_port;

   269

		func->check_mng_mode = e1000e_check_mng_mode_generic;

   270

		func->led_on = e1000e_led_on_generic;

   271

   272

		/* FWSM register */

   273

		mac->has_fwsm = true;

   274

		/*

   275

		 * ARC supported; valid only if manageability features are

   276

		 * enabled.

   277

		 */

   278

		mac->arc_subsystem_valid =

   279

			(er32(FWSM) & E1000_FWSM_MODE_MASK)

   280

			? true : false;

   281

		break;

   282

	case e1000_82574:

   283

	case e1000_82583:

   284

		func->set_lan_id = e1000_set_lan_id_single_port;

   285

		func->check_mng_mode = e1000_check_mng_mode_82574;

   286

		func->led_on = e1000_led_on_82574;

   287

		break;

   288

	default:

   289

		func->check_mng_mode = e1000e_check_mng_mode_generic;

   290

		func->led_on = e1000e_led_on_generic;

   291

   292

		/* FWSM register */

   293

		mac->has_fwsm = true;

   294

		break;

   295

	}

   296

   297

	/*

   298

	 * Ensure that the inter-port SWSM.SMBI lock bit is clear before

   299

	 * first NVM or PHY acess. This should be done for single-port

   300

	 * devices, and for one port only on dual-port devices so that

   301

	 * for those devices we can still use the SMBI lock to synchronize

   302

	 * inter-port accesses to the PHY & NVM.

   303

	 */

   304

	switch (hw->mac.type) {

   305

	case e1000_82571:

   306

	case e1000_82572:

   307

		swsm2 = er32(SWSM2);

   308

   309

		if (!(swsm2 & E1000_SWSM2_LOCK)) {

   310

			/* Only do this for the first interface on this card */

   311

			ew32(SWSM2,

   312

			    swsm2 | E1000_SWSM2_LOCK);

   313

			force_clear_smbi = true;

   314

		} else

   315

			force_clear_smbi = false;

   316

		break;

   317

	default:

   318

		force_clear_smbi = true;

   319

		break;

   320

	}

   321

   322

	if (force_clear_smbi) {

   323

		/* Make sure SWSM.SMBI is clear */

   324

		swsm = er32(SWSM);

   325

		if (swsm & E1000_SWSM_SMBI) {

   326

			/* This bit should not be set on a first interface, and

   327

			 * indicates that the bootagent or EFI code has

   328

			 * improperly left this bit enabled

   329

			 */

   330

			e_dbg("Please update your 82571 Bootagent\n");

   331

		}

   332

		ew32(SWSM, swsm & ~E1000_SWSM_SMBI);

   333

	}

   334

   335

	/*

   336

	 * Initialize device specific counter of SMBI acquisition

   337

	 * timeouts.

   338

	 */

   339

	 hw->dev_spec.e82571.smb_counter = 0;

   340

   341

	return 0;

   342

}

   343

   344

static s32 e1000_get_variants_82571(struct e1000_adapter *adapter)

   345

{

   346

	struct e1000_hw *hw = &adapter->hw;

   347

	static int global_quad_port_a; /* global port a indication */

   348

	struct pci_dev *pdev = adapter->pdev;

   349

	int is_port_b = er32(STATUS) & E1000_STATUS_FUNC_1;

   350

	s32 rc;

   351

   352

	rc = e1000_init_mac_params_82571(adapter);

   353

	if (rc)

   354

		return rc;

   355

   356

	rc = e1000_init_nvm_params_82571(hw);

   357

	if (rc)

   358

		return rc;

   359

   360

	rc = e1000_init_phy_params_82571(hw);

   361

	if (rc)

   362

		return rc;

   363

   364

	/* tag quad port adapters first, it's used below */

   365

	switch (pdev->device) {

   366

	case E1000_DEV_ID_82571EB_QUAD_COPPER:

   367

	case E1000_DEV_ID_82571EB_QUAD_FIBER:

   368

	case E1000_DEV_ID_82571EB_QUAD_COPPER_LP:

   369

	case E1000_DEV_ID_82571PT_QUAD_COPPER:

   370

		adapter->flags |= FLAG_IS_QUAD_PORT;

   371

		/* mark the first port */

   372

		if (global_quad_port_a == 0)

   373

			adapter->flags |= FLAG_IS_QUAD_PORT_A;

   374

		/* Reset for multiple quad port adapters */

   375

		global_quad_port_a++;

   376

		if (global_quad_port_a == 4)

   377

			global_quad_port_a = 0;

   378

		break;

   379

	default:

   380

		break;

   381

	}

   382

   383

	switch (adapter->hw.mac.type) {

   384

	case e1000_82571:

   385

		/* these dual ports don't have WoL on port B at all */

   386

		if (((pdev->device == E1000_DEV_ID_82571EB_FIBER) ||

   387

		     (pdev->device == E1000_DEV_ID_82571EB_SERDES) ||

   388

		     (pdev->device == E1000_DEV_ID_82571EB_COPPER)) &&

   389

		    (is_port_b))

   390

			adapter->flags &= ~FLAG_HAS_WOL;

   391

		/* quad ports only support WoL on port A */

   392

		if (adapter->flags & FLAG_IS_QUAD_PORT &&

   393

		    (!(adapter->flags & FLAG_IS_QUAD_PORT_A)))

   394

			adapter->flags &= ~FLAG_HAS_WOL;

   395

		/* Does not support WoL on any port */

   396

		if (pdev->device == E1000_DEV_ID_82571EB_SERDES_QUAD)

   397

			adapter->flags &= ~FLAG_HAS_WOL;

   398

		break;

   399

	case e1000_82573:

   400

	case e1000_82574:

   401

	case e1000_82583:

   402

		/* Disable ASPM L0s due to hardware errata */

   403

		e1000e_disable_aspm(adapter->pdev, PCIE_LINK_STATE_L0S);

   404

   405

		if (pdev->device == E1000_DEV_ID_82573L) {

   406

			adapter->flags |= FLAG_HAS_JUMBO_FRAMES;

   407

			adapter->max_hw_frame_size = DEFAULT_JUMBO;

   408

		}

   409

		break;

   410

	default:

   411

		break;

   412

	}

   413

   414

	return 0;

   415

}

   416

   417

/**

   418

 *  e1000_get_phy_id_82571 - Retrieve the PHY ID and revision

   419

 *  @hw: pointer to the HW structure

   420

 *

   421

 *  Reads the PHY registers and stores the PHY ID and possibly the PHY

   422

 *  revision in the hardware structure.

   423

 **/

   424

static s32 e1000_get_phy_id_82571(struct e1000_hw *hw)

   425

{

   426

	struct e1000_phy_info *phy = &hw->phy;

   427

	s32 ret_val;

   428

	u16 phy_id = 0;

   429

   430

	switch (hw->mac.type) {

   431

	case e1000_82571:

   432

	case e1000_82572:

   433

		/*

   434

		 * The 82571 firmware may still be configuring the PHY.

   435

		 * In this case, we cannot access the PHY until the

   436

		 * configuration is done.  So we explicitly set the

   437

		 * PHY ID.

   438

		 */

   439

		phy->id = IGP01E1000_I_PHY_ID;

   440

		break;

   441

	case e1000_82573:

   442

		return e1000e_get_phy_id(hw);

   443

		break;

   444

	case e1000_82574:

   445

	case e1000_82583:

   446

		ret_val = e1e_rphy(hw, PHY_ID1, &phy_id);

   447

		if (ret_val)

   448

			return ret_val;

   449

   450

		phy->id = (u32)(phy_id << 16);

   451

		udelay(20);

   452

		ret_val = e1e_rphy(hw, PHY_ID2, &phy_id);

   453

		if (ret_val)

   454

			return ret_val;

   455

   456

		phy->id |= (u32)(phy_id);

   457

		phy->revision = (u32)(phy_id & ~PHY_REVISION_MASK);

   458

		break;

   459

	default:

   460

		return -E1000_ERR_PHY;

   461

		break;

   462

	}

   463

   464

	return 0;

   465

}

   466

   467

/**

   468

 *  e1000_get_hw_semaphore_82571 - Acquire hardware semaphore

   469

 *  @hw: pointer to the HW structure

   470

 *

   471

 *  Acquire the HW semaphore to access the PHY or NVM

   472

 **/

   473

static s32 e1000_get_hw_semaphore_82571(struct e1000_hw *hw)

   474

{

   475

	u32 swsm;

   476

	s32 sw_timeout = hw->nvm.word_size + 1;

   477

	s32 fw_timeout = hw->nvm.word_size + 1;

   478

	s32 i = 0;

   479

   480

	/*

   481

	 * If we have timedout 3 times on trying to acquire

   482

	 * the inter-port SMBI semaphore, there is old code

   483

	 * operating on the other port, and it is not

   484

	 * releasing SMBI. Modify the number of times that

   485

	 * we try for the semaphore to interwork with this

   486

	 * older code.

   487

	 */

   488

	if (hw->dev_spec.e82571.smb_counter > 2)

   489

		sw_timeout = 1;

   490

   491

	/* Get the SW semaphore */

   492

	while (i < sw_timeout) {

   493

		swsm = er32(SWSM);

   494

		if (!(swsm & E1000_SWSM_SMBI))

   495

			break;

   496

   497

		udelay(50);

   498

		i++;

   499

	}

   500

   501

	if (i == sw_timeout) {

   502

		e_dbg("Driver can't access device - SMBI bit is set.\n");

   503

		hw->dev_spec.e82571.smb_counter++;

   504

	}

   505

	/* Get the FW semaphore. */

   506

	for (i = 0; i < fw_timeout; i++) {

   507

		swsm = er32(SWSM);

   508

		ew32(SWSM, swsm | E1000_SWSM_SWESMBI);

   509

   510

		/* Semaphore acquired if bit latched */

   511

		if (er32(SWSM) & E1000_SWSM_SWESMBI)

   512

			break;

   513

   514

		udelay(50);

   515

	}

   516

   517

	if (i == fw_timeout) {

   518

		/* Release semaphores */

   519

		e1000_put_hw_semaphore_82571(hw);

   520

		e_dbg("Driver can't access the NVM\n");

   521

		return -E1000_ERR_NVM;

   522

	}

   523

   524

	return 0;

   525

}

   526

   527

/**

   528

 *  e1000_put_hw_semaphore_82571 - Release hardware semaphore

   529

 *  @hw: pointer to the HW structure