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

#include <linux/delay.h>

    30

    31

#include "e1000.h"

    32

    33

static s32 e1000_get_phy_cfg_done(struct e1000_hw *hw);

    34

static s32 e1000_phy_force_speed_duplex(struct e1000_hw *hw);

    35

static s32 e1000_set_d0_lplu_state(struct e1000_hw *hw, bool active);

    36

static s32 e1000_wait_autoneg(struct e1000_hw *hw);

    37

static u32 e1000_get_phy_addr_for_bm_page(u32 page, u32 reg);

    38

static s32 e1000_access_phy_wakeup_reg_bm(struct e1000_hw *hw, u32 offset,

    39

					  u16 *data, bool read);

    40

static u32 e1000_get_phy_addr_for_hv_page(u32 page);

    41

static s32 e1000_access_phy_debug_regs_hv(struct e1000_hw *hw, u32 offset,

    42

                                          u16 *data, bool read);

    43

    44

/* Cable length tables */

    45

static const u16 e1000_m88_cable_length_table[] =

    46

	{ 0, 50, 80, 110, 140, 140, E1000_CABLE_LENGTH_UNDEFINED };

    47

#define M88E1000_CABLE_LENGTH_TABLE_SIZE \

    48

		ARRAY_SIZE(e1000_m88_cable_length_table)

    49

    50

static const u16 e1000_igp_2_cable_length_table[] =

    51

	{ 0, 0, 0, 0, 0, 0, 0, 0, 3, 5, 8, 11, 13, 16, 18, 21, 0, 0, 0, 3,

    52

	  6, 10, 13, 16, 19, 23, 26, 29, 32, 35, 38, 41, 6, 10, 14, 18, 22,

    53

	  26, 30, 33, 37, 41, 44, 48, 51, 54, 58, 61, 21, 26, 31, 35, 40,

    54

	  44, 49, 53, 57, 61, 65, 68, 72, 75, 79, 82, 40, 45, 51, 56, 61,

    55

	  66, 70, 75, 79, 83, 87, 91, 94, 98, 101, 104, 60, 66, 72, 77, 82,

    56

	  87, 92, 96, 100, 104, 108, 111, 114, 117, 119, 121, 83, 89, 95,

    57

	  100, 105, 109, 113, 116, 119, 122, 124, 104, 109, 114, 118, 121,

    58

	  124};

    59

#define IGP02E1000_CABLE_LENGTH_TABLE_SIZE \

    60

		ARRAY_SIZE(e1000_igp_2_cable_length_table)

    61

    62

#define BM_PHY_REG_PAGE(offset) \

    63

	((u16)(((offset) >> PHY_PAGE_SHIFT) & 0xFFFF))

    64

#define BM_PHY_REG_NUM(offset) \

    65

	((u16)(((offset) & MAX_PHY_REG_ADDRESS) |\

    66

	 (((offset) >> (PHY_UPPER_SHIFT - PHY_PAGE_SHIFT)) &\

    67

		~MAX_PHY_REG_ADDRESS)))

    68

    69

#define HV_INTC_FC_PAGE_START             768

    70

#define I82578_ADDR_REG                   29

    71

#define I82577_ADDR_REG                   16

    72

#define I82577_CFG_REG                    22

    73

#define I82577_CFG_ASSERT_CRS_ON_TX       (1 << 15)

    74

#define I82577_CFG_ENABLE_DOWNSHIFT       (3 << 10) /* auto downshift 100/10 */

    75

#define I82577_CTRL_REG                   23

    76

    77

/* 82577 specific PHY registers */

    78

#define I82577_PHY_CTRL_2            18

    79

#define I82577_PHY_STATUS_2          26

    80

#define I82577_PHY_DIAG_STATUS       31

    81

    82

/* I82577 PHY Status 2 */

    83

#define I82577_PHY_STATUS2_REV_POLARITY   0x0400

    84

#define I82577_PHY_STATUS2_MDIX           0x0800

    85

#define I82577_PHY_STATUS2_SPEED_MASK     0x0300

    86

#define I82577_PHY_STATUS2_SPEED_1000MBPS 0x0200

    87

    88

/* I82577 PHY Control 2 */

    89

#define I82577_PHY_CTRL2_AUTO_MDIX        0x0400

    90

#define I82577_PHY_CTRL2_FORCE_MDI_MDIX   0x0200

    91

    92

/* I82577 PHY Diagnostics Status */

    93

#define I82577_DSTATUS_CABLE_LENGTH       0x03FC

    94

#define I82577_DSTATUS_CABLE_LENGTH_SHIFT 2

    95

    96

/* BM PHY Copper Specific Control 1 */

    97

#define BM_CS_CTRL1                       16

    98

    99

#define HV_MUX_DATA_CTRL               PHY_REG(776, 16)

   100

#define HV_MUX_DATA_CTRL_GEN_TO_MAC    0x0400

   101

#define HV_MUX_DATA_CTRL_FORCE_SPEED   0x0004

   102

   103

/**

   104

 *  e1000e_check_reset_block_generic - Check if PHY reset is blocked

   105

 *  @hw: pointer to the HW structure

   106

 *

   107

 *  Read the PHY management control register and check whether a PHY reset

   108

 *  is blocked.  If a reset is not blocked return 0, otherwise

   109

 *  return E1000_BLK_PHY_RESET (12).

   110

 **/

   111

s32 e1000e_check_reset_block_generic(struct e1000_hw *hw)

   112

{

   113

	u32 manc;

   114

   115

	manc = er32(MANC);

   116

   117

	return (manc & E1000_MANC_BLK_PHY_RST_ON_IDE) ?

   118

	       E1000_BLK_PHY_RESET : 0;

   119

}

   120

   121

/**

   122

 *  e1000e_get_phy_id - Retrieve the PHY ID and revision

   123

 *  @hw: pointer to the HW structure

   124

 *

   125

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

   126

 *  revision in the hardware structure.

   127

 **/

   128

s32 e1000e_get_phy_id(struct e1000_hw *hw)

   129

{

   130

	struct e1000_phy_info *phy = &hw->phy;

   131

	s32 ret_val = 0;

   132

	u16 phy_id;

   133

	u16 retry_count = 0;

   134

   135

	if (!(phy->ops.read_reg))

   136

		goto out;

   137

   138

	while (retry_count < 2) {

   139

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

   140

		if (ret_val)

   141

			goto out;

   142

   143

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

   144

		udelay(20);

   145

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

   146

		if (ret_val)

   147

			goto out;

   148

   149

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

   150

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

   151

   152

		if (phy->id != 0 && phy->id != PHY_REVISION_MASK)

   153

			goto out;

   154

   155

		retry_count++;

   156

	}

   157

out:

   158

	return ret_val;

   159

}

   160

   161

/**

   162

 *  e1000e_phy_reset_dsp - Reset PHY DSP

   163

 *  @hw: pointer to the HW structure

   164

 *

   165

 *  Reset the digital signal processor.

   166

 **/

   167

s32 e1000e_phy_reset_dsp(struct e1000_hw *hw)

   168

{

   169

	s32 ret_val;

   170

   171

	ret_val = e1e_wphy(hw, M88E1000_PHY_GEN_CONTROL, 0xC1);

   172

	if (ret_val)

   173

		return ret_val;

   174

   175

	return e1e_wphy(hw, M88E1000_PHY_GEN_CONTROL, 0);

   176

}

   177

   178

/**

   179

 *  e1000e_read_phy_reg_mdic - Read MDI control register

   180

 *  @hw: pointer to the HW structure

   181

 *  @offset: register offset to be read

   182

 *  @data: pointer to the read data

   183

 *

   184

 *  Reads the MDI control register in the PHY at offset and stores the

   185

 *  information read to data.

   186

 **/

   187

s32 e1000e_read_phy_reg_mdic(struct e1000_hw *hw, u32 offset, u16 *data)

   188

{

   189

	struct e1000_phy_info *phy = &hw->phy;

   190

	u32 i, mdic = 0;

   191

   192

	if (offset > MAX_PHY_REG_ADDRESS) {

   193

		e_dbg("PHY Address %d is out of range\n", offset);

   194

		return -E1000_ERR_PARAM;

   195

	}

   196

   197

	/*

   198

	 * Set up Op-code, Phy Address, and register offset in the MDI

   199

	 * Control register.  The MAC will take care of interfacing with the

   200

	 * PHY to retrieve the desired data.

   201

	 */

   202

	mdic = ((offset << E1000_MDIC_REG_SHIFT) |

   203

		(phy->addr << E1000_MDIC_PHY_SHIFT) |

   204

		(E1000_MDIC_OP_READ));

   205

   206

	ew32(MDIC, mdic);

   207

   208

	/*

   209

	 * Poll the ready bit to see if the MDI read completed

   210

	 * Increasing the time out as testing showed failures with

   211

	 * the lower time out

   212

	 */

   213

	for (i = 0; i < (E1000_GEN_POLL_TIMEOUT * 3); i++) {

   214

		udelay(50);

   215

		mdic = er32(MDIC);

   216

		if (mdic & E1000_MDIC_READY)

   217

			break;

   218

	}

   219

	if (!(mdic & E1000_MDIC_READY)) {

   220

		e_dbg("MDI Read did not complete\n");

   221

		return -E1000_ERR_PHY;

   222

	}

   223

	if (mdic & E1000_MDIC_ERROR) {

   224

		e_dbg("MDI Error\n");

   225

		return -E1000_ERR_PHY;

   226

	}

   227

	*data = (u16) mdic;

   228

   229

	return 0;

   230

}

   231

   232

/**

   233

 *  e1000e_write_phy_reg_mdic - Write MDI control register

   234

 *  @hw: pointer to the HW structure

   235

 *  @offset: register offset to write to

   236

 *  @data: data to write to register at offset

   237

 *

   238

 *  Writes data to MDI control register in the PHY at offset.

   239

 **/

   240

s32 e1000e_write_phy_reg_mdic(struct e1000_hw *hw, u32 offset, u16 data)

   241

{

   242

	struct e1000_phy_info *phy = &hw->phy;

   243

	u32 i, mdic = 0;

   244

   245

	if (offset > MAX_PHY_REG_ADDRESS) {

   246

		e_dbg("PHY Address %d is out of range\n", offset);

   247

		return -E1000_ERR_PARAM;

   248

	}

   249

   250

	/*

   251

	 * Set up Op-code, Phy Address, and register offset in the MDI

   252

	 * Control register.  The MAC will take care of interfacing with the

   253

	 * PHY to retrieve the desired data.

   254

	 */

   255

	mdic = (((u32)data) |

   256

		(offset << E1000_MDIC_REG_SHIFT) |

   257

		(phy->addr << E1000_MDIC_PHY_SHIFT) |

   258

		(E1000_MDIC_OP_WRITE));

   259

   260

	ew32(MDIC, mdic);

   261

   262

	/*

   263

	 * Poll the ready bit to see if the MDI read completed

   264

	 * Increasing the time out as testing showed failures with

   265

	 * the lower time out

   266

	 */

   267

	for (i = 0; i < (E1000_GEN_POLL_TIMEOUT * 3); i++) {

   268

		udelay(50);

   269

		mdic = er32(MDIC);

   270

		if (mdic & E1000_MDIC_READY)

   271

			break;

   272

	}

   273

	if (!(mdic & E1000_MDIC_READY)) {

   274

		e_dbg("MDI Write did not complete\n");

   275

		return -E1000_ERR_PHY;

   276

	}

   277

	if (mdic & E1000_MDIC_ERROR) {

   278

		e_dbg("MDI Error\n");

   279

		return -E1000_ERR_PHY;

   280

	}

   281

   282

	return 0;

   283

}

   284

   285

/**

   286

 *  e1000e_read_phy_reg_m88 - Read m88 PHY register

   287

 *  @hw: pointer to the HW structure

   288

 *  @offset: register offset to be read

   289

 *  @data: pointer to the read data

   290

 *

   291

 *  Acquires semaphore, if necessary, then reads the PHY register at offset

   292

 *  and storing the retrieved information in data.  Release any acquired

   293

 *  semaphores before exiting.

   294

 **/

   295

s32 e1000e_read_phy_reg_m88(struct e1000_hw *hw, u32 offset, u16 *data)

   296

{

   297

	s32 ret_val;

   298

   299

	ret_val = hw->phy.ops.acquire(hw);

   300

	if (ret_val)

   301

		return ret_val;

   302

   303

	ret_val = e1000e_read_phy_reg_mdic(hw, MAX_PHY_REG_ADDRESS & offset,

   304

					   data);

   305

   306

	hw->phy.ops.release(hw);

   307

   308

	return ret_val;

   309

}

   310

   311

/**

   312

 *  e1000e_write_phy_reg_m88 - Write m88 PHY register

   313

 *  @hw: pointer to the HW structure

   314

 *  @offset: register offset to write to

   315

 *  @data: data to write at register offset

   316

 *

   317

 *  Acquires semaphore, if necessary, then writes the data to PHY register

   318

 *  at the offset.  Release any acquired semaphores before exiting.

   319

 **/

   320

s32 e1000e_write_phy_reg_m88(struct e1000_hw *hw, u32 offset, u16 data)

   321

{

   322

	s32 ret_val;

   323

   324

	ret_val = hw->phy.ops.acquire(hw);

   325

	if (ret_val)

   326

		return ret_val;

   327

   328

	ret_val = e1000e_write_phy_reg_mdic(hw, MAX_PHY_REG_ADDRESS & offset,

   329

					    data);

   330

   331

	hw->phy.ops.release(hw);

   332

   333

	return ret_val;

   334

}

   335

   336

/**

   337

 *  __e1000e_read_phy_reg_igp - Read igp PHY register

   338

 *  @hw: pointer to the HW structure

   339

 *  @offset: register offset to be read

   340

 *  @data: pointer to the read data

   341

 *  @locked: semaphore has already been acquired or not

   342

 *

   343

 *  Acquires semaphore, if necessary, then reads the PHY register at offset

   344

 *  and stores the retrieved information in data.  Release any acquired

   345

 *  semaphores before exiting.

   346

 **/

   347

static s32 __e1000e_read_phy_reg_igp(struct e1000_hw *hw, u32 offset, u16 *data,

   348

                                    bool locked)

   349

{

   350

	s32 ret_val = 0;

   351

   352

	if (!locked) {

   353

		if (!(hw->phy.ops.acquire))

   354

			goto out;

   355

   356

		ret_val = hw->phy.ops.acquire(hw);

   357

		if (ret_val)

   358

			goto out;

   359

	}

   360

   361

	if (offset > MAX_PHY_MULTI_PAGE_REG) {

   362

		ret_val = e1000e_write_phy_reg_mdic(hw,

   363

						    IGP01E1000_PHY_PAGE_SELECT,

   364

						    (u16)offset);

   365

		if (ret_val)

   366

			goto release;

   367

	}

   368

   369

	ret_val = e1000e_read_phy_reg_mdic(hw, MAX_PHY_REG_ADDRESS & offset,

   370

	                                  data);

   371

   372

release:

   373

	if (!locked)

   374

		hw->phy.ops.release(hw);

   375

out:

   376

	return ret_val;

   377

}

   378

   379

/**

   380

 *  e1000e_read_phy_reg_igp - Read igp PHY register

   381

 *  @hw: pointer to the HW structure

   382

 *  @offset: register offset to be read

   383

 *  @data: pointer to the read data

   384

 *

   385

 *  Acquires semaphore then reads the PHY register at offset and stores the

   386

 *  retrieved information in data.

   387

 *  Release the acquired semaphore before exiting.

   388

 **/

   389

s32 e1000e_read_phy_reg_igp(struct e1000_hw *hw, u32 offset, u16 *data)

   390

{

   391

	return __e1000e_read_phy_reg_igp(hw, offset, data, false);

   392

}

   393

   394

/**

   395

 *  e1000e_read_phy_reg_igp_locked - Read igp PHY register

   396

 *  @hw: pointer to the HW structure

   397

 *  @offset: register offset to be read

   398

 *  @data: pointer to the read data

   399

 *

   400

 *  Reads the PHY register at offset and stores the retrieved information

   401

 *  in data.  Assumes semaphore already acquired.

   402

 **/

   403

s32 e1000e_read_phy_reg_igp_locked(struct e1000_hw *hw, u32 offset, u16 *data)

   404

{

   405

	return __e1000e_read_phy_reg_igp(hw, offset, data, true);

   406

}

   407

   408

/**

   409

 *  e1000e_write_phy_reg_igp - Write igp PHY register

   410

 *  @hw: pointer to the HW structure

   411

 *  @offset: register offset to write to

   412

 *  @data: data to write at register offset

   413

 *  @locked: semaphore has already been acquired or not

   414

 *

   415

 *  Acquires semaphore, if necessary, then writes the data to PHY register

   416

 *  at the offset.  Release any acquired semaphores before exiting.

   417

 **/

   418

static s32 __e1000e_write_phy_reg_igp(struct e1000_hw *hw, u32 offset, u16 data,

   419

                                     bool locked)

   420

{

   421

	s32 ret_val = 0;

   422

   423

	if (!locked) {

   424

		if (!(hw->phy.ops.acquire))

   425

			goto out;

   426

   427

		ret_val = hw->phy.ops.acquire(hw);

   428

		if (ret_val)

   429

			goto out;

   430

	}

   431

   432

	if (offset > MAX_PHY_MULTI_PAGE_REG) {

   433

		ret_val = e1000e_write_phy_reg_mdic(hw,

   434

						    IGP01E1000_PHY_PAGE_SELECT,

   435

						    (u16)offset);

   436

		if (ret_val)

   437

			goto release;

   438

	}

   439

   440

	ret_val = e1000e_write_phy_reg_mdic(hw, MAX_PHY_REG_ADDRESS & offset,

   441

					    data);

   442

   443

release:

   444

	if (!locked)

   445

		hw->phy.ops.release(hw);

   446

   447

out:

   448

	return ret_val;

   449

}

   450

   451

/**

   452

 *  e1000e_write_phy_reg_igp - Write igp PHY register

   453

 *  @hw: pointer to the HW structure

   454

 *  @offset: register offset to write to

   455

 *  @data: data to write at register offset

   456

 *

   457

 *  Acquires semaphore then writes the data to PHY register

   458

 *  at the offset.  Release any acquired semaphores before exiting.

   459

 **/

   460

s32 e1000e_write_phy_reg_igp(struct e1000_hw *hw, u32 offset, u16 data)

   461

{

   462

	return __e1000e_write_phy_reg_igp(hw, offset, data, false);

   463

}

   464

   465

/**

   466

 *  e1000e_write_phy_reg_igp_locked - Write igp PHY register

   467

 *  @hw: pointer to the HW structure

   468

 *  @offset: register offset to write to

   469

 *  @data: data to write at register offset

   470

 *

   471

 *  Writes the data to PHY register at the offset.

   472

 *  Assumes semaphore already acquired.

   473

 **/

   474

s32 e1000e_write_phy_reg_igp_locked(struct e1000_hw *hw, u32 offset, u16 data)

   475

{

   476

	return __e1000e_write_phy_reg_igp(hw, offset, data, true);

   477

}

   478

   479

/**

   480

 *  __e1000_read_kmrn_reg - Read kumeran register

   481

 *  @hw: pointer to the HW structure

   482

 *  @offset: register offset to be read

   483

 *  @data: pointer to the read data

   484

 *  @locked: semaphore has already been acquired or not

   485

 *

   486

 *  Acquires semaphore, if necessary.  Then reads the PHY register at offset

   487

 *  using the kumeran interface.  The information retrieved is stored in data.

   488

 *  Release any acquired semaphores before exiting.

   489

 **/

   490

static s32 __e1000_read_kmrn_reg(struct e1000_hw *hw, u32 offset, u16 *data,

   491

                                 bool locked)

   492

{

   493

	u32 kmrnctrlsta;

   494

	s32 ret_val = 0;

   495

   496

	if (!locked) {

   497

		if (!(hw->phy.ops.acquire))

   498

			goto out;

   499

   500

		ret_val = hw->phy.ops.acquire(hw);

   501

		if (ret_val)

   502

			goto out;

   503

	}

   504

   505

	kmrnctrlsta = ((offset << E1000_KMRNCTRLSTA_OFFSET_SHIFT) &

   506

		       E1000_KMRNCTRLSTA_OFFSET) | E1000_KMRNCTRLSTA_REN;

   507

	ew32(KMRNCTRLSTA, kmrnctrlsta);

   508

   509

	udelay(2);

   510

   511

	kmrnctrlsta = er32(KMRNCTRLSTA);

   512

	*data = (u16)kmrnctrlsta;

   513

   514

	if (!locked)

   515

		hw->phy.ops.release(hw);

   516

   517

out:

   518

	return ret_val;

   519

}

   520

   521

/**

   522

 *  e1000e_read_kmrn_reg -  Read kumeran register

   523

 *  @hw: pointer to the HW structure

   524

 *  @offset: register offset to be read

   525

 *  @data: pointer to the read data

   526

 *

   527

 *  Acquires semaphore then reads the PHY register at offset using the

   528

 *  kumeran interface.  The information retrieved is stored in data.

   529

 *  Release the acquired semaphore before exiting.