1

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

     2

     3

  Intel PRO/1000 Linux driver

     4

  Copyright(c) 1999 - 2013 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-3.14-ethercat.h"

    34

    35

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

    36

 * maximum number of ports that the driver can manage.

    37

 */

    38

#define E1000_MAX_NIC 32

    39

    40

#define OPTION_UNSET   -1

    41

#define OPTION_DISABLED 0

    42

#define OPTION_ENABLED  1

    43

    44

#define COPYBREAK_DEFAULT 256

    45

unsigned int copybreak = COPYBREAK_DEFAULT;

    46

module_param(copybreak, uint, 0644);

    47

MODULE_PARM_DESC(copybreak,

    48

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

    49

    50

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

    51

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

    52

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

    53

 */

    54

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

    55

#define E1000_PARAM(X, desc)					\

    56

	static int X[E1000_MAX_NIC+1] = E1000_PARAM_INIT;	\

    57

	static unsigned int num_##X;				\

    58

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

    59

	MODULE_PARM_DESC(X, desc);

    60

    61

/* Transmit Interrupt Delay in units of 1.024 microseconds

    62

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

    63

 *

    64

 * Valid Range: 0-65535

    65

 */

    66

E1000_PARAM(TxIntDelay, "Transmit Interrupt Delay");

    67

#define DEFAULT_TIDV 8

    68

#define MAX_TXDELAY 0xFFFF

    69

#define MIN_TXDELAY 0

    70

    71

/* Transmit Absolute Interrupt Delay in units of 1.024 microseconds

    72

 *

    73

 * Valid Range: 0-65535

    74

 */

    75

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

    76

#define DEFAULT_TADV 32

    77

#define MAX_TXABSDELAY 0xFFFF

    78

#define MIN_TXABSDELAY 0

    79

    80

/* Receive Interrupt Delay in units of 1.024 microseconds

    81

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

    82

 *

    83

 * Valid Range: 0-65535

    84

 */

    85

E1000_PARAM(RxIntDelay, "Receive Interrupt Delay");

    86

#define MAX_RXDELAY 0xFFFF

    87

#define MIN_RXDELAY 0

    88

    89

/* Receive Absolute Interrupt Delay in units of 1.024 microseconds

    90

 *

    91

 * Valid Range: 0-65535

    92

 */

    93

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

    94

#define MAX_RXABSDELAY 0xFFFF

    95

#define MIN_RXABSDELAY 0

    96

    97

/* Interrupt Throttle Rate (interrupts/sec)

    98

 *

    99

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

   100

 */

   101

E1000_PARAM(InterruptThrottleRate, "Interrupt Throttling Rate");

   102

#define DEFAULT_ITR 3

   103

#define MAX_ITR 100000

   104

#define MIN_ITR 100

   105

   106

/* IntMode (Interrupt Mode)

   107

 *

   108

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

   109

 *

   110

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

   111

 *

   112

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

   113

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

   114

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

   115

 *   Default Value: 0 (legacy)

   116

 *

   117

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

   118

 * demoted to the most advanced interrupt mode available.

   119

 */

   120

E1000_PARAM(IntMode, "Interrupt Mode");

   121

#define MAX_INTMODE	2

   122

#define MIN_INTMODE	0

   123

   124

/* Enable Smart Power Down of the PHY

   125

 *

   126

 * Valid Range: 0, 1

   127

 *

   128

 * Default Value: 0 (disabled)

   129

 */

   130

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

   131

   132

/* Enable Kumeran Lock Loss workaround

   133

 *

   134

 * Valid Range: 0, 1

   135

 *

   136

 * Default Value: 1 (enabled)

   137

 */

   138

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

   139

   140

/* Write Protect NVM

   141

 *

   142

 * Valid Range: 0, 1

   143

 *

   144

 * Default Value: 1 (enabled)

   145

 */

   146

E1000_PARAM(WriteProtectNVM,

   147

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

   148

   149

/* Enable CRC Stripping

   150

 *

   151

 * Valid Range: 0, 1

   152

 *

   153

 * Default Value: 1 (enabled)

   154

 */

   155

E1000_PARAM(CrcStripping,

   156

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

   157

   158

struct e1000_option {

   159

	enum { enable_option, range_option, list_option } type;

   160

	const char *name;

   161

	const char *err;

   162

	int def;

   163

	union {

   164

		/* range_option info */

   165

		struct {

   166

			int min;

   167

			int max;

   168

		} r;

   169

		/* list_option info */

   170

		struct {

   171

			int nr;

   172

			struct e1000_opt_list {

   173

				int i;

   174

				char *str;

   175

			} *p;

   176

		} l;

   177

	} arg;

   178

};

   179

   180

static int e1000_validate_option(unsigned int *value,

   181

				 const struct e1000_option *opt,

   182

				 struct e1000_adapter *adapter)

   183

{

   184

	if (*value == OPTION_UNSET) {

   185

		*value = opt->def;

   186

		return 0;

   187

	}

   188

   189

	switch (opt->type) {

   190

	case enable_option:

   191

		switch (*value) {

   192

		case OPTION_ENABLED:

   193

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

   194

				 opt->name);

   195

			return 0;

   196

		case OPTION_DISABLED:

   197

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

   198

				 opt->name);

   199

			return 0;

   200

		}

   201

		break;

   202

	case range_option:

   203

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

   204

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

   205

				 opt->name, *value);

   206

			return 0;

   207

		}

   208

		break;

   209

	case list_option: {

   210

		int i;

   211

		struct e1000_opt_list *ent;

   212

   213

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

   214

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

   215

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

   216

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

   217

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

   218

						 ent->str);

   219

				return 0;

   220

			}

   221

		}

   222

	}

   223

		break;

   224

	default:

   225

		BUG();

   226

	}

   227

   228

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

   229

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

   230

	*value = opt->def;

   231

	return -1;

   232

}

   233

   234

/**

   235

 * e1000e_check_options - Range Checking for Command Line Parameters

   236

 * @adapter: board private structure

   237

 *

   238

 * This routine checks all command line parameters for valid user

   239

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

   240

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

   241

 * in a variable in the adapter structure.

   242

 **/

   243

void e1000e_check_options(struct e1000_adapter *adapter)

   244

{

   245

	struct e1000_hw *hw = &adapter->hw;

   246

	int bd = adapter->bd_number;

   247

   248

	if (bd >= E1000_MAX_NIC) {

   249

		dev_notice(&adapter->pdev->dev,

   250

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

   251

		dev_notice(&adapter->pdev->dev,

   252

			   "Using defaults for all values\n");

   253

	}

   254

   255

	/* Transmit Interrupt Delay */

   256

	{

   257

		static const struct e1000_option opt = {

   258

			.type = range_option,

   259

			.name = "Transmit Interrupt Delay",

   260

			.err  = "using default of "

   261

				__MODULE_STRING(DEFAULT_TIDV),

   262

			.def  = DEFAULT_TIDV,

   263

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

   264

					 .max = MAX_TXDELAY } }

   265

		};

   266

   267

		if (num_TxIntDelay > bd) {

   268

			adapter->tx_int_delay = TxIntDelay[bd];

   269

			e1000_validate_option(&adapter->tx_int_delay, &opt,

   270

					      adapter);

   271

		} else {

   272

			adapter->tx_int_delay = opt.def;

   273

		}

   274

	}

   275

	/* Transmit Absolute Interrupt Delay */

   276

	{

   277

		static const struct e1000_option opt = {

   278

			.type = range_option,

   279

			.name = "Transmit Absolute Interrupt Delay",

   280

			.err  = "using default of "

   281

				__MODULE_STRING(DEFAULT_TADV),

   282

			.def  = DEFAULT_TADV,

   283

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

   284

					 .max = MAX_TXABSDELAY } }

   285

		};

   286

   287

		if (num_TxAbsIntDelay > bd) {

   288

			adapter->tx_abs_int_delay = TxAbsIntDelay[bd];

   289

			e1000_validate_option(&adapter->tx_abs_int_delay, &opt,

   290

					      adapter);

   291

		} else {

   292

			adapter->tx_abs_int_delay = opt.def;

   293

		}

   294

	}

   295

	/* Receive Interrupt Delay */

   296

	{

   297

		static struct e1000_option opt = {

   298

			.type = range_option,

   299

			.name = "Receive Interrupt Delay",

   300

			.err  = "using default of "

   301

				__MODULE_STRING(DEFAULT_RDTR),

   302

			.def  = DEFAULT_RDTR,

   303

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

   304

					 .max = MAX_RXDELAY } }

   305

		};

   306

   307

		if (num_RxIntDelay > bd) {

   308

			adapter->rx_int_delay = RxIntDelay[bd];

   309

			e1000_validate_option(&adapter->rx_int_delay, &opt,

   310

					      adapter);

   311

		} else {

   312

			adapter->rx_int_delay = opt.def;

   313

		}

   314

	}

   315

	/* Receive Absolute Interrupt Delay */

   316

	{

   317

		static const struct e1000_option opt = {

   318

			.type = range_option,

   319

			.name = "Receive Absolute Interrupt Delay",

   320

			.err  = "using default of "

   321

				__MODULE_STRING(DEFAULT_RADV),

   322

			.def  = DEFAULT_RADV,

   323

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

   324

					 .max = MAX_RXABSDELAY } }

   325

		};

   326

   327

		if (num_RxAbsIntDelay > bd) {

   328

			adapter->rx_abs_int_delay = RxAbsIntDelay[bd];

   329

			e1000_validate_option(&adapter->rx_abs_int_delay, &opt,

   330

					      adapter);

   331

		} else {

   332

			adapter->rx_abs_int_delay = opt.def;

   333

		}

   334

	}

   335

	/* Interrupt Throttling Rate */

   336

	{

   337

		static const struct e1000_option opt = {

   338

			.type = range_option,

   339

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

   340

			.err  = "using default of "

   341

				__MODULE_STRING(DEFAULT_ITR),

   342

			.def  = DEFAULT_ITR,

   343

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

   344

					 .max = MAX_ITR } }

   345

		};

   346

   347

		if (num_InterruptThrottleRate > bd) {

   348

			adapter->itr = InterruptThrottleRate[bd];

   349

   350

			/* Make sure a message is printed for non-special

   351

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

   352

			 * warning, use default and go through itr/itr_setting

   353

			 * adjustment logic below

   354

			 */

   355

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

   356

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

   357

				adapter->itr = opt.def;

   358

		} else {

   359

			/* If no option specified, use default value and go

   360

			 * through the logic below to adjust itr/itr_setting

   361

			 */

   362

			adapter->itr = opt.def;

   363

   364

			/* Make sure a message is printed for non-special

   365

			 * default values

   366

			 */

   367

			if (adapter->itr > 4)

   368

				dev_info(&adapter->pdev->dev,

   369

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

   370

					 adapter->itr);

   371

		}

   372

   373

		adapter->itr_setting = adapter->itr;

   374

		switch (adapter->itr) {

   375

		case 0:

   376

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

   377

				 opt.name);

   378

			break;

   379

		case 1:

   380

			dev_info(&adapter->pdev->dev,

   381

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

   382

			adapter->itr = 20000;

   383

			break;

   384

		case 3:

   385

			dev_info(&adapter->pdev->dev,

   386

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

   387

				 opt.name);

   388

			adapter->itr = 20000;

   389

			break;

   390

		case 4:

   391

			dev_info(&adapter->pdev->dev,

   392

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

   393

				 opt.name);

   394

			break;

   395

		default:

   396

			/* Save the setting, because the dynamic bits

   397

			 * change itr.

   398

			 *

   399

			 * Clear the lower two bits because

   400

			 * they are used as control.

   401

			 */

   402

			adapter->itr_setting &= ~3;

   403

			break;

   404

		}

   405

	}

   406

	/* Interrupt Mode */

   407

	{

   408

		static struct e1000_option opt = {

   409

			.type = range_option,

   410

			.name = "Interrupt Mode",

   411

#ifndef CONFIG_PCI_MSI

   412

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

   413

			.def  = E1000E_INT_MODE_LEGACY,

   414

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

   415

					 .max = 0 } }

   416

#endif

   417

		};

   418

   419

#ifdef CONFIG_PCI_MSI

   420

		if (adapter->flags & FLAG_HAS_MSIX) {

   421

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

   422

					  GFP_KERNEL);

   423

			opt.def = E1000E_INT_MODE_MSIX;

   424

			opt.arg.r.max = E1000E_INT_MODE_MSIX;

   425

		} else {

   426

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

   427

			opt.def = E1000E_INT_MODE_MSI;

   428

			opt.arg.r.max = E1000E_INT_MODE_MSI;

   429

		}

   430

   431

		if (!opt.err) {

   432

			dev_err(&adapter->pdev->dev,

   433

				"Failed to allocate memory\n");

   434

			return;

   435

		}

   436

#endif

   437

   438

		if (num_IntMode > bd) {

   439

			unsigned int int_mode = IntMode[bd];

   440

			e1000_validate_option(&int_mode, &opt, adapter);

   441

			adapter->int_mode = int_mode;

   442

		} else {

   443

			adapter->int_mode = opt.def;

   444

		}

   445

   446

#ifdef CONFIG_PCI_MSI

   447

		kfree(opt.err);

   448

#endif

   449

	}

   450

	/* Smart Power Down */

   451

	{

   452

		static const struct e1000_option opt = {

   453

			.type = enable_option,

   454

			.name = "PHY Smart Power Down",

   455

			.err  = "defaulting to Disabled",

   456

			.def  = OPTION_DISABLED

   457

		};

   458

   459

		if (num_SmartPowerDownEnable > bd) {

   460

			unsigned int spd = SmartPowerDownEnable[bd];

   461

			e1000_validate_option(&spd, &opt, adapter);

   462

			if ((adapter->flags & FLAG_HAS_SMART_POWER_DOWN) && spd)

   463

				adapter->flags |= FLAG_SMART_POWER_DOWN;

   464

		}

   465

	}

   466

	/* CRC Stripping */

   467

	{

   468

		static const struct e1000_option opt = {

   469

			.type = enable_option,

   470

			.name = "CRC Stripping",

   471

			.err  = "defaulting to Enabled",

   472

			.def  = OPTION_ENABLED

   473

		};

   474

   475

		if (num_CrcStripping > bd) {

   476

			unsigned int crc_stripping = CrcStripping[bd];

   477

			e1000_validate_option(&crc_stripping, &opt, adapter);

   478

			if (crc_stripping == OPTION_ENABLED) {

   479

				adapter->flags2 |= FLAG2_CRC_STRIPPING;

   480

				adapter->flags2 |= FLAG2_DFLT_CRC_STRIPPING;

   481

			}

   482

		} else {

   483

			adapter->flags2 |= FLAG2_CRC_STRIPPING;

   484

			adapter->flags2 |= FLAG2_DFLT_CRC_STRIPPING;

   485

		}

   486

	}

   487

	/* Kumeran Lock Loss Workaround */

   488

	{

   489

		static const struct e1000_option opt = {

   490

			.type = enable_option,

   491

			.name = "Kumeran Lock Loss Workaround",

   492

			.err  = "defaulting to Enabled",

   493

			.def  = OPTION_ENABLED

   494

		};

   495

		bool enabled = opt.def;

   496

   497

		if (num_KumeranLockLoss > bd) {

   498

			unsigned int kmrn_lock_loss = KumeranLockLoss[bd];

   499

			e1000_validate_option(&kmrn_lock_loss, &opt, adapter);

   500

			enabled = kmrn_lock_loss;

   501

		}

   502

   503

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

   504

			e1000e_set_kmrn_lock_loss_workaround_ich8lan(hw,

   505

								     enabled);

   506

	}

   507

	/* Write-protect NVM */

   508

	{

   509

		static const struct e1000_option opt = {

   510

			.type = enable_option,

   511

			.name = "Write-protect NVM",

   512

			.err  = "defaulting to Enabled",

   513

			.def  = OPTION_ENABLED

   514

		};

   515

   516

		if (adapter->flags & FLAG_IS_ICH) {

   517

			if (num_WriteProtectNVM > bd) {

   518

				unsigned int write_protect_nvm =

   519

				    WriteProtectNVM[bd];

   520

				e1000_validate_option(&write_protect_nvm, &opt,

   521

						      adapter);

   522

				if (write_protect_nvm)

   523

					adapter->flags |= FLAG_READ_ONLY_NVM;

   524

			} else {

   525

				if (opt.def)

   526

					adapter->flags |= FLAG_READ_ONLY_NVM;

   527

			}

   528

		}

   529

	}