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

#include <linux/netdevice.h>

    30

#include <linux/module.h>

    31

#include <linux/pci.h>

    32

    33

#include "e1000.h"

    34

    35

/*

    36

 * This is the only thing that needs to be changed to adjust the

    37

 * maximum number of ports that the driver can manage.

    38

 */

    39

    40

#define E1000_MAX_NIC 32

    41

    42

#define OPTION_UNSET   -1

    43

#define OPTION_DISABLED 0

    44

#define OPTION_ENABLED  1

    45

    46

#define COPYBREAK_DEFAULT 256

    47

unsigned int copybreak = COPYBREAK_DEFAULT;

    48

module_param(copybreak, uint, 0644);

    49

MODULE_PARM_DESC(copybreak,

    50

	"Maximum size of packet that is copied to a new buffer on receive");

    51

    52

/*

    53

 * All parameters are treated the same, as an integer array of values.

    54

 * This macro just reduces the need to repeat the same declaration code

    55

 * over and over (plus this helps to avoid typo bugs).

    56

 */

    57

    58

#define E1000_PARAM_INIT { [0 ... E1000_MAX_NIC] = OPTION_UNSET }

    59

#define E1000_PARAM(X, desc)					\

    60

	static int __devinitdata X[E1000_MAX_NIC+1]		\

    61

		= E1000_PARAM_INIT;				\

    62

	static unsigned int num_##X;				\

    63

	module_param_array_named(X, X, int, &num_##X, 0);	\

    64

	MODULE_PARM_DESC(X, desc);

    65

    66

/*

    67

 * Transmit Interrupt Delay in units of 1.024 microseconds

    68

 * Tx interrupt delay needs to typically be set to something non-zero

    69

 *

    70

 * Valid Range: 0-65535

    71

 */

    72

E1000_PARAM(TxIntDelay, "Transmit Interrupt Delay");

    73

#define DEFAULT_TIDV 8

    74

#define MAX_TXDELAY 0xFFFF

    75

#define MIN_TXDELAY 0

    76

    77

/*

    78

 * Transmit Absolute Interrupt Delay in units of 1.024 microseconds

    79

 *

    80

 * Valid Range: 0-65535

    81

 */

    82

E1000_PARAM(TxAbsIntDelay, "Transmit Absolute Interrupt Delay");

    83

#define DEFAULT_TADV 32

    84

#define MAX_TXABSDELAY 0xFFFF

    85

#define MIN_TXABSDELAY 0

    86

    87

/*

    88

 * Receive Interrupt Delay in units of 1.024 microseconds

    89

 * hardware will likely hang if you set this to anything but zero.

    90

 *

    91

 * Valid Range: 0-65535

    92

 */

    93

E1000_PARAM(RxIntDelay, "Receive Interrupt Delay");

    94

#define MAX_RXDELAY 0xFFFF

    95

#define MIN_RXDELAY 0

    96

    97

/*

    98

 * Receive Absolute Interrupt Delay in units of 1.024 microseconds

    99

 *

   100

 * Valid Range: 0-65535

   101

 */

   102

E1000_PARAM(RxAbsIntDelay, "Receive Absolute Interrupt Delay");

   103

#define MAX_RXABSDELAY 0xFFFF

   104

#define MIN_RXABSDELAY 0

   105

   106

/*

   107

 * Interrupt Throttle Rate (interrupts/sec)

   108

 *

   109

 * Valid Range: 100-100000 or one of: 0=off, 1=dynamic, 3=dynamic conservative

   110

 */

   111

E1000_PARAM(InterruptThrottleRate, "Interrupt Throttling Rate");

   112

#define DEFAULT_ITR 3

   113

#define MAX_ITR 100000

   114

#define MIN_ITR 100

   115

   116

/*

   117

 * IntMode (Interrupt Mode)

   118

 *

   119

 * Valid Range: varies depending on kernel configuration & hardware support

   120

 *

   121

 * legacy=0, MSI=1, MSI-X=2

   122

 *

   123

 * When MSI/MSI-X support is enabled in kernel-

   124

 *   Default Value: 2 (MSI-X) when supported by hardware, 1 (MSI) otherwise

   125

 * When MSI/MSI-X support is not enabled in kernel-

   126

 *   Default Value: 0 (legacy)

   127

 *

   128

 * When a mode is specified that is not allowed/supported, it will be

   129

 * demoted to the most advanced interrupt mode available.

   130

 */

   131

E1000_PARAM(IntMode, "Interrupt Mode");

   132

#define MAX_INTMODE	2

   133

#define MIN_INTMODE	0

   134

   135

/*

   136

 * Enable Smart Power Down of the PHY

   137

 *

   138

 * Valid Range: 0, 1

   139

 *

   140

 * Default Value: 0 (disabled)

   141

 */

   142

E1000_PARAM(SmartPowerDownEnable, "Enable PHY smart power down");

   143

   144

/*

   145

 * Enable Kumeran Lock Loss workaround

   146

 *

   147

 * Valid Range: 0, 1

   148

 *

   149

 * Default Value: 1 (enabled)

   150

 */

   151

E1000_PARAM(KumeranLockLoss, "Enable Kumeran lock loss workaround");

   152

   153

/*

   154

 * Write Protect NVM

   155

 *

   156

 * Valid Range: 0, 1

   157

 *

   158

 * Default Value: 1 (enabled)

   159

 */

   160

E1000_PARAM(WriteProtectNVM, "Write-protect NVM [WARNING: disabling this can lead to corrupted NVM]");

   161

   162

/*

   163

 * Enable CRC Stripping

   164

 *

   165

 * Valid Range: 0, 1

   166

 *

   167

 * Default Value: 1 (enabled)

   168

 */

   169

E1000_PARAM(CrcStripping,

   170

	    "Enable CRC Stripping, disable if your BMC needs the CRC");

   171

   172

struct e1000_option {

   173

	enum { enable_option, range_option, list_option } type;

   174

	const char *name;

   175

	const char *err;

   176

	int def;

   177

	union {

   178

		struct { /* range_option info */

   179

			int min;

   180

			int max;

   181

		} r;

   182

		struct { /* list_option info */

   183

			int nr;

   184

			struct e1000_opt_list { int i; char *str; } *p;

   185

		} l;

   186

	} arg;

   187

};

   188

   189

static int __devinit e1000_validate_option(unsigned int *value,

   190

					   const struct e1000_option *opt,

   191

					   struct e1000_adapter *adapter)

   192

{

   193

	if (*value == OPTION_UNSET) {

   194

		*value = opt->def;

   195

		return 0;

   196

	}

   197

   198

	switch (opt->type) {

   199

	case enable_option:

   200

		switch (*value) {

   201

		case OPTION_ENABLED:

   202

			dev_info(&adapter->pdev->dev, "%s Enabled\n",

   203

				 opt->name);

   204

			return 0;

   205

		case OPTION_DISABLED:

   206

			dev_info(&adapter->pdev->dev, "%s Disabled\n",

   207

				 opt->name);

   208

			return 0;

   209

		}

   210

		break;

   211

	case range_option:

   212

		if (*value >= opt->arg.r.min && *value <= opt->arg.r.max) {

   213

			dev_info(&adapter->pdev->dev, "%s set to %i\n",

   214

				 opt->name, *value);

   215

			return 0;

   216

		}

   217

		break;

   218

	case list_option: {

   219

		int i;

   220

		struct e1000_opt_list *ent;

   221

   222

		for (i = 0; i < opt->arg.l.nr; i++) {

   223

			ent = &opt->arg.l.p[i];

   224

			if (*value == ent->i) {

   225

				if (ent->str[0] != '\0')

   226

					dev_info(&adapter->pdev->dev, "%s\n",

   227

						 ent->str);

   228

				return 0;

   229

			}

   230

		}

   231

	}

   232

		break;

   233

	default:

   234

		BUG();

   235

	}

   236

   237

	dev_info(&adapter->pdev->dev, "Invalid %s value specified (%i) %s\n",

   238

		 opt->name, *value, opt->err);

   239

	*value = opt->def;

   240

	return -1;

   241

}

   242

   243

/**

   244

 * e1000e_check_options - Range Checking for Command Line Parameters

   245

 * @adapter: board private structure

   246

 *

   247

 * This routine checks all command line parameters for valid user

   248

 * input.  If an invalid value is given, or if no user specified

   249

 * value exists, a default value is used.  The final value is stored

   250

 * in a variable in the adapter structure.

   251

 **/

   252

void __devinit e1000e_check_options(struct e1000_adapter *adapter)

   253

{

   254

	struct e1000_hw *hw = &adapter->hw;

   255

	int bd = adapter->bd_number;

   256

   257

	if (bd >= E1000_MAX_NIC) {

   258

		dev_notice(&adapter->pdev->dev,

   259

			   "Warning: no configuration for board #%i\n", bd);

   260

		dev_notice(&adapter->pdev->dev,

   261

			   "Using defaults for all values\n");

   262

	}

   263

   264

	{ /* Transmit Interrupt Delay */

   265

		static const struct e1000_option opt = {

   266

			.type = range_option,

   267

			.name = "Transmit Interrupt Delay",

   268

			.err  = "using default of "

   269

				__MODULE_STRING(DEFAULT_TIDV),

   270

			.def  = DEFAULT_TIDV,

   271

			.arg  = { .r = { .min = MIN_TXDELAY,

   272

					 .max = MAX_TXDELAY } }

   273

		};

   274

   275

		if (num_TxIntDelay > bd) {

   276

			adapter->tx_int_delay = TxIntDelay[bd];

   277

			e1000_validate_option(&adapter->tx_int_delay, &opt,

   278

					      adapter);

   279

		} else {

   280

			adapter->tx_int_delay = opt.def;

   281

		}

   282

	}

   283

	{ /* Transmit Absolute Interrupt Delay */

   284

		static const struct e1000_option opt = {

   285

			.type = range_option,

   286

			.name = "Transmit Absolute Interrupt Delay",

   287

			.err  = "using default of "

   288

				__MODULE_STRING(DEFAULT_TADV),

   289

			.def  = DEFAULT_TADV,

   290

			.arg  = { .r = { .min = MIN_TXABSDELAY,

   291

					 .max = MAX_TXABSDELAY } }

   292

		};

   293

   294

		if (num_TxAbsIntDelay > bd) {

   295

			adapter->tx_abs_int_delay = TxAbsIntDelay[bd];

   296

			e1000_validate_option(&adapter->tx_abs_int_delay, &opt,

   297

					      adapter);

   298

		} else {

   299

			adapter->tx_abs_int_delay = opt.def;

   300

		}

   301

	}

   302

	{ /* Receive Interrupt Delay */

   303

		static struct e1000_option opt = {

   304

			.type = range_option,

   305

			.name = "Receive Interrupt Delay",

   306

			.err  = "using default of "

   307

				__MODULE_STRING(DEFAULT_RDTR),

   308

			.def  = DEFAULT_RDTR,

   309

			.arg  = { .r = { .min = MIN_RXDELAY,

   310

					 .max = MAX_RXDELAY } }

   311

		};

   312

   313

		if (num_RxIntDelay > bd) {

   314

			adapter->rx_int_delay = RxIntDelay[bd];

   315

			e1000_validate_option(&adapter->rx_int_delay, &opt,

   316

					      adapter);

   317

		} else {

   318

			adapter->rx_int_delay = opt.def;

   319

		}

   320

	}

   321

	{ /* Receive Absolute Interrupt Delay */

   322

		static const struct e1000_option opt = {

   323

			.type = range_option,

   324

			.name = "Receive Absolute Interrupt Delay",

   325

			.err  = "using default of "

   326

				__MODULE_STRING(DEFAULT_RADV),

   327

			.def  = DEFAULT_RADV,

   328

			.arg  = { .r = { .min = MIN_RXABSDELAY,

   329

					 .max = MAX_RXABSDELAY } }

   330

		};

   331

   332

		if (num_RxAbsIntDelay > bd) {

   333

			adapter->rx_abs_int_delay = RxAbsIntDelay[bd];

   334

			e1000_validate_option(&adapter->rx_abs_int_delay, &opt,

   335

					      adapter);

   336

		} else {

   337

			adapter->rx_abs_int_delay = opt.def;

   338

		}

   339

	}

   340

	{ /* Interrupt Throttling Rate */

   341

		static const struct e1000_option opt = {

   342

			.type = range_option,

   343

			.name = "Interrupt Throttling Rate (ints/sec)",

   344

			.err  = "using default of "

   345

				__MODULE_STRING(DEFAULT_ITR),

   346

			.def  = DEFAULT_ITR,

   347

			.arg  = { .r = { .min = MIN_ITR,

   348

					 .max = MAX_ITR } }

   349

		};

   350

   351

		if (num_InterruptThrottleRate > bd) {

   352

			adapter->itr = InterruptThrottleRate[bd];

   353

   354

			/*

   355

			 * Make sure a message is printed for non-special

   356

			 * values. And in case of an invalid option, display

   357

			 * warning, use default and go through itr/itr_setting

   358

			 * adjustment logic below

   359

			 */

   360

			if ((adapter->itr > 4) &&

   361

			    e1000_validate_option(&adapter->itr, &opt, adapter))

   362

				adapter->itr = opt.def;

   363

		} else {

   364

			/*

   365

			 * If no option specified, use default value and go

   366

			 * through the logic below to adjust itr/itr_setting

   367

			 */

   368

			adapter->itr = opt.def;

   369

   370

			/*

   371

			 * Make sure a message is printed for non-special

   372

			 * default values

   373

			 */

   374

			if (adapter->itr > 4)

   375

				dev_info(&adapter->pdev->dev,

   376

					 "%s set to default %d\n", opt.name,

   377

					 adapter->itr);

   378

		}

   379

   380

		adapter->itr_setting = adapter->itr;

   381

		switch (adapter->itr) {

   382

		case 0:

   383

			dev_info(&adapter->pdev->dev, "%s turned off\n",

   384

				 opt.name);

   385

			break;

   386

		case 1:

   387

			dev_info(&adapter->pdev->dev,

   388

				 "%s set to dynamic mode\n", opt.name);

   389

			adapter->itr = 20000;

   390

			break;

   391

		case 3:

   392

			dev_info(&adapter->pdev->dev,

   393

				 "%s set to dynamic conservative mode\n",

   394

				 opt.name);

   395

			adapter->itr = 20000;

   396

			break;

   397

		case 4:

   398

			dev_info(&adapter->pdev->dev,

   399

				 "%s set to simplified (2000-8000 ints) mode\n",

   400

				 opt.name);

   401

			break;

   402

		default:

   403

			/*

   404

			 * Save the setting, because the dynamic bits

   405

			 * change itr.

   406

			 *

   407

			 * Clear the lower two bits because

   408

			 * they are used as control.

   409

			 */

   410

			adapter->itr_setting &= ~3;

   411

			break;

   412

		}

   413

	}

   414

	{ /* Interrupt Mode */

   415

		static struct e1000_option opt = {

   416

			.type = range_option,

   417

			.name = "Interrupt Mode",

   418

#ifndef CONFIG_PCI_MSI

   419

			.err  = "defaulting to 0 (legacy)",

   420

			.def  = E1000E_INT_MODE_LEGACY,

   421

			.arg  = { .r = { .min = 0,

   422

					 .max = 0 } }

   423

#endif

   424

		};

   425

   426

#ifdef CONFIG_PCI_MSI

   427

		if (adapter->flags & FLAG_HAS_MSIX) {

   428

			opt.err = kstrdup("defaulting to 2 (MSI-X)",

   429

					  GFP_KERNEL);

   430

			opt.def = E1000E_INT_MODE_MSIX;

   431

			opt.arg.r.max = E1000E_INT_MODE_MSIX;

   432

		} else {

   433

			opt.err = kstrdup("defaulting to 1 (MSI)", GFP_KERNEL);

   434

			opt.def = E1000E_INT_MODE_MSI;

   435

			opt.arg.r.max = E1000E_INT_MODE_MSI;

   436

		}

   437

   438

		if (!opt.err) {

   439

			dev_err(&adapter->pdev->dev,

   440

				"Failed to allocate memory\n");

   441

			return;

   442

		}

   443

#endif

   444

   445

		if (num_IntMode > bd) {

   446

			unsigned int int_mode = IntMode[bd];

   447

			e1000_validate_option(&int_mode, &opt, adapter);

   448

			adapter->int_mode = int_mode;

   449

		} else {

   450

			adapter->int_mode = opt.def;

   451

		}

   452

   453

#ifdef CONFIG_PCI_MSI

   454

		kfree(opt.err);

   455

#endif

   456

	}

   457

	{ /* Smart Power Down */

   458

		static const struct e1000_option opt = {

   459

			.type = enable_option,

   460

			.name = "PHY Smart Power Down",

   461

			.err  = "defaulting to Disabled",

   462

			.def  = OPTION_DISABLED

   463

		};

   464

   465

		if (num_SmartPowerDownEnable > bd) {

   466

			unsigned int spd = SmartPowerDownEnable[bd];

   467

			e1000_validate_option(&spd, &opt, adapter);

   468

			if ((adapter->flags & FLAG_HAS_SMART_POWER_DOWN)

   469

			    && spd)

   470

				adapter->flags |= FLAG_SMART_POWER_DOWN;

   471

		}

   472

	}

   473

	{ /* CRC Stripping */

   474

		static const struct e1000_option opt = {

   475

			.type = enable_option,

   476

			.name = "CRC Stripping",

   477

			.err  = "defaulting to Enabled",

   478

			.def  = OPTION_ENABLED

   479

		};

   480

   481

		if (num_CrcStripping > bd) {

   482

			unsigned int crc_stripping = CrcStripping[bd];

   483

			e1000_validate_option(&crc_stripping, &opt, adapter);

   484

			if (crc_stripping == OPTION_ENABLED) {

   485

				adapter->flags2 |= FLAG2_CRC_STRIPPING;

   486

				adapter->flags2 |= FLAG2_DFLT_CRC_STRIPPING;

   487

			}

   488

		} else {

   489

			adapter->flags2 |= FLAG2_CRC_STRIPPING;

   490

			adapter->flags2 |= FLAG2_DFLT_CRC_STRIPPING;

   491

		}

   492

	}

   493

	{ /* Kumeran Lock Loss Workaround */

   494

		static const struct e1000_option opt = {

   495

			.type = enable_option,

   496

			.name = "Kumeran Lock Loss Workaround",

   497

			.err  = "defaulting to Enabled",

   498

			.def  = OPTION_ENABLED

   499

		};

   500

   501

		if (num_KumeranLockLoss > bd) {

   502

			unsigned int kmrn_lock_loss = KumeranLockLoss[bd];

   503

			e1000_validate_option(&kmrn_lock_loss, &opt, adapter);

   504

			if (hw->mac.type == e1000_ich8lan)

   505

				e1000e_set_kmrn_lock_loss_workaround_ich8lan(hw,

   506

								kmrn_lock_loss);

   507

		} else {

   508

			if (hw->mac.type == e1000_ich8lan)

   509

				e1000e_set_kmrn_lock_loss_workaround_ich8lan(hw,

   510

								       opt.def);

   511

		}

   512

	}

   513

	{ /* Write-protect NVM */

   514

		static const struct e1000_option opt = {

   515

			.type = enable_option,

   516

			.name = "Write-protect NVM",

   517

			.err  = "defaulting to Enabled",

   518

			.def  = OPTION_ENABLED

   519

		};

   520

   521

		if (adapter->flags & FLAG_IS_ICH) {

   522

			if (num_WriteProtectNVM > bd) {

   523

				unsigned int write_protect_nvm = WriteProtectNVM[bd];

   524

				e1000_validate_option(&write_protect_nvm, &opt,

   525

						      adapter);

   526

				if (write_protect_nvm)

   527

					adapter->flags |= FLAG_READ_ONLY_NVM;

   528

			} else {

   529

				if (opt.def)

   530

					adapter->flags |= FLAG_READ_ONLY_NVM;