1

/* Intel PRO/1000 Linux driver

     2

 * Copyright(c) 1999 - 2014 Intel Corporation.

     3

 *

     4

 * This program is free software; you can redistribute it and/or modify it

     5

 * under the terms and conditions of the GNU General Public License,

     6

 * version 2, as published by the Free Software Foundation.

     7

 *

     8

 * This program is distributed in the hope it will be useful, but WITHOUT

     9

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    10

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for

    11

 * more details.

    12

 *

    13

 * The full GNU General Public License is included in this distribution in

    14

 * the file called "COPYING".

    15

 *

    16

 * Contact Information:

    17

 * Linux NICS <linux.nics@intel.com>

    18

 * e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>

    19

 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497

    20

 */

    21

    22

#include <linux/netdevice.h>

    23

#include <linux/module.h>

    24

#include <linux/pci.h>

    25

    26

#include "e1000.h"

    27

    28

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

    29

 * maximum number of ports that the driver can manage.

    30

 */

    31

#define E1000_MAX_NIC 32

    32

    33

#define OPTION_UNSET   -1

    34

#define OPTION_DISABLED 0

    35

#define OPTION_ENABLED  1

    36

    37

#define COPYBREAK_DEFAULT 256

    38

unsigned int copybreak = COPYBREAK_DEFAULT;

    39

module_param(copybreak, uint, 0644);

    40

MODULE_PARM_DESC(copybreak,

    41

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

    42

    43

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

    44

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

    45

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

    46

 */

    47

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

    48

#define E1000_PARAM(X, desc)					\

    49

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

    50

	static unsigned int num_##X;				\

    51

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

    52

	MODULE_PARM_DESC(X, desc);

    53

    54

/* Transmit Interrupt Delay in units of 1.024 microseconds

    55

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

    56

 *

    57

 * Valid Range: 0-65535

    58

 */

    59

E1000_PARAM(TxIntDelay, "Transmit Interrupt Delay");

    60

#define DEFAULT_TIDV 8

    61

#define MAX_TXDELAY 0xFFFF

    62

#define MIN_TXDELAY 0

    63

    64

/* Transmit Absolute Interrupt Delay in units of 1.024 microseconds

    65

 *

    66

 * Valid Range: 0-65535

    67

 */

    68

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

    69

#define DEFAULT_TADV 32

    70

#define MAX_TXABSDELAY 0xFFFF

    71

#define MIN_TXABSDELAY 0

    72

    73

/* Receive Interrupt Delay in units of 1.024 microseconds

    74

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

    75

 *

    76

 * Valid Range: 0-65535

    77

 */

    78

E1000_PARAM(RxIntDelay, "Receive Interrupt Delay");

    79

#define MAX_RXDELAY 0xFFFF

    80

#define MIN_RXDELAY 0

    81

    82

/* Receive Absolute Interrupt Delay in units of 1.024 microseconds

    83

 *

    84

 * Valid Range: 0-65535

    85

 */

    86

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

    87

#define MAX_RXABSDELAY 0xFFFF

    88

#define MIN_RXABSDELAY 0

    89

    90

/* Interrupt Throttle Rate (interrupts/sec)

    91

 *

    92

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

    93

 */

    94

E1000_PARAM(InterruptThrottleRate, "Interrupt Throttling Rate");

    95

#define DEFAULT_ITR 3

    96

#define MAX_ITR 100000

    97

#define MIN_ITR 100

    98

    99

/* IntMode (Interrupt Mode)

   100

 *

   101

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

   102

 *

   103

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

   104

 *

   105

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

   106

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

   107

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

   108

 *   Default Value: 0 (legacy)

   109

 *

   110

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

   111

 * demoted to the most advanced interrupt mode available.

   112

 */

   113

E1000_PARAM(IntMode, "Interrupt Mode");

   114

#define MAX_INTMODE	2

   115

#define MIN_INTMODE	0

   116

   117

/* Enable Smart Power Down of the PHY

   118

 *

   119

 * Valid Range: 0, 1

   120

 *

   121

 * Default Value: 0 (disabled)

   122

 */

   123

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

   124

   125

/* Enable Kumeran Lock Loss workaround

   126

 *

   127

 * Valid Range: 0, 1

   128

 *

   129

 * Default Value: 1 (enabled)

   130

 */

   131

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

   132

   133

/* Write Protect NVM

   134

 *

   135

 * Valid Range: 0, 1

   136

 *

   137

 * Default Value: 1 (enabled)

   138

 */

   139

E1000_PARAM(WriteProtectNVM,

   140

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

   141

   142

/* Enable CRC Stripping

   143

 *

   144

 * Valid Range: 0, 1

   145

 *

   146

 * Default Value: 1 (enabled)

   147

 */

   148

E1000_PARAM(CrcStripping,

   149

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

   150

   151

struct e1000_option {

   152

	enum { enable_option, range_option, list_option } type;

   153

	const char *name;

   154

	const char *err;

   155

	int def;

   156

	union {

   157

		/* range_option info */

   158

		struct {

   159

			int min;

   160

			int max;

   161

		} r;

   162

		/* list_option info */

   163

		struct {

   164

			int nr;

   165

			struct e1000_opt_list {

   166

				int i;

   167

				char *str;

   168

			} *p;

   169

		} l;

   170

	} arg;

   171

};

   172

   173

static int e1000_validate_option(unsigned int *value,

   174

				 const struct e1000_option *opt,

   175

				 struct e1000_adapter *adapter)

   176

{

   177

	if (*value == OPTION_UNSET) {

   178

		*value = opt->def;

   179

		return 0;

   180

	}

   181

   182

	switch (opt->type) {

   183

	case enable_option:

   184

		switch (*value) {

   185

		case OPTION_ENABLED:

   186

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

   187

				 opt->name);

   188

			return 0;

   189

		case OPTION_DISABLED:

   190

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

   191

				 opt->name);

   192

			return 0;

   193

		}

   194

		break;

   195

	case range_option:

   196

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

   197

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

   198

				 opt->name, *value);

   199

			return 0;

   200

		}

   201

		break;

   202

	case list_option: {

   203

		int i;

   204

		struct e1000_opt_list *ent;

   205

   206

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

   207

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

   208

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

   209

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

   210

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

   211

						 ent->str);

   212

				return 0;

   213

			}

   214

		}

   215

	}

   216

		break;

   217

	default:

   218

		BUG();

   219

	}

   220

   221

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

   222

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

   223

	*value = opt->def;

   224

	return -1;

   225

}

   226

   227

/**

   228

 * e1000e_check_options - Range Checking for Command Line Parameters

   229

 * @adapter: board private structure

   230

 *

   231

 * This routine checks all command line parameters for valid user

   232

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

   233

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

   234

 * in a variable in the adapter structure.

   235

 **/

   236

void e1000e_check_options(struct e1000_adapter *adapter)

   237

{

   238

	struct e1000_hw *hw = &adapter->hw;

   239

	int bd = adapter->bd_number;

   240

   241

	if (bd >= E1000_MAX_NIC) {

   242

		dev_notice(&adapter->pdev->dev,

   243

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

   244

		dev_notice(&adapter->pdev->dev,

   245

			   "Using defaults for all values\n");

   246

	}

   247

   248

	/* Transmit Interrupt Delay */

   249

	{

   250

		static const struct e1000_option opt = {

   251

			.type = range_option,

   252

			.name = "Transmit Interrupt Delay",

   253

			.err  = "using default of "

   254

				__MODULE_STRING(DEFAULT_TIDV),

   255

			.def  = DEFAULT_TIDV,

   256

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

   257

					 .max = MAX_TXDELAY } }

   258

		};

   259

   260

		if (num_TxIntDelay > bd) {

   261

			adapter->tx_int_delay = TxIntDelay[bd];

   262

			e1000_validate_option(&adapter->tx_int_delay, &opt,

   263

					      adapter);

   264

		} else {

   265

			adapter->tx_int_delay = opt.def;

   266

		}

   267

	}

   268

	/* Transmit Absolute Interrupt Delay */

   269

	{

   270

		static const struct e1000_option opt = {

   271

			.type = range_option,

   272

			.name = "Transmit Absolute Interrupt Delay",

   273

			.err  = "using default of "

   274

				__MODULE_STRING(DEFAULT_TADV),

   275

			.def  = DEFAULT_TADV,

   276

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

   277

					 .max = MAX_TXABSDELAY } }

   278

		};

   279

   280

		if (num_TxAbsIntDelay > bd) {

   281

			adapter->tx_abs_int_delay = TxAbsIntDelay[bd];

   282

			e1000_validate_option(&adapter->tx_abs_int_delay, &opt,

   283

					      adapter);

   284

		} else {

   285

			adapter->tx_abs_int_delay = opt.def;

   286

		}

   287

	}

   288

	/* Receive Interrupt Delay */

   289

	{

   290

		static struct e1000_option opt = {

   291

			.type = range_option,

   292

			.name = "Receive Interrupt Delay",

   293

			.err  = "using default of "

   294

				__MODULE_STRING(DEFAULT_RDTR),

   295

			.def  = DEFAULT_RDTR,

   296

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

   297

					 .max = MAX_RXDELAY } }

   298

		};

   299

   300

		if (num_RxIntDelay > bd) {

   301

			adapter->rx_int_delay = RxIntDelay[bd];

   302

			e1000_validate_option(&adapter->rx_int_delay, &opt,

   303

					      adapter);

   304

		} else {

   305

			adapter->rx_int_delay = opt.def;

   306

		}

   307

	}

   308

	/* Receive Absolute Interrupt Delay */

   309

	{

   310

		static const struct e1000_option opt = {

   311

			.type = range_option,

   312

			.name = "Receive Absolute Interrupt Delay",

   313

			.err  = "using default of "

   314

				__MODULE_STRING(DEFAULT_RADV),

   315

			.def  = DEFAULT_RADV,

   316

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

   317

					 .max = MAX_RXABSDELAY } }

   318

		};

   319

   320

		if (num_RxAbsIntDelay > bd) {

   321

			adapter->rx_abs_int_delay = RxAbsIntDelay[bd];

   322

			e1000_validate_option(&adapter->rx_abs_int_delay, &opt,

   323

					      adapter);

   324

		} else {

   325

			adapter->rx_abs_int_delay = opt.def;

   326

		}

   327

	}

   328

	/* Interrupt Throttling Rate */

   329

	{

   330

		static const struct e1000_option opt = {

   331

			.type = range_option,

   332

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

   333

			.err  = "using default of "

   334

				__MODULE_STRING(DEFAULT_ITR),

   335

			.def  = DEFAULT_ITR,

   336

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

   337

					 .max = MAX_ITR } }

   338

		};

   339

   340

		if (num_InterruptThrottleRate > bd) {

   341

			adapter->itr = InterruptThrottleRate[bd];

   342

   343

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

   344

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

   345

			 * warning, use default and go through itr/itr_setting

   346

			 * adjustment logic below

   347

			 */

   348

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

   349

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

   350

				adapter->itr = opt.def;

   351

		} else {

   352

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

   353

			 * through the logic below to adjust itr/itr_setting

   354

			 */

   355

			adapter->itr = opt.def;

   356

   357

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

   358

			 * default values

   359

			 */

   360

			if (adapter->itr > 4)

   361

				dev_info(&adapter->pdev->dev,

   362

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

   363

					 adapter->itr);

   364

		}

   365

   366

		adapter->itr_setting = adapter->itr;

   367

		switch (adapter->itr) {

   368

		case 0:

   369

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

   370

				 opt.name);

   371

			break;

   372

		case 1:

   373

			dev_info(&adapter->pdev->dev,

   374

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

   375

			adapter->itr = 20000;

   376

			break;

   377

		case 2:

   378

			dev_info(&adapter->pdev->dev,

   379

				 "%s Invalid mode - setting default\n",

   380

				 opt.name);

   381

			adapter->itr_setting = opt.def;

   382

			/* fall-through */

   383

		case 3:

   384

			dev_info(&adapter->pdev->dev,

   385

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

   386

				 opt.name);

   387

			adapter->itr = 20000;

   388

			break;

   389

		case 4:

   390

			dev_info(&adapter->pdev->dev,

   391

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

   392

				 opt.name);

   393

			break;

   394

		default:

   395

			/* Save the setting, because the dynamic bits

   396

			 * change itr.

   397

			 *

   398

			 * Clear the lower two bits because

   399

			 * they are used as control.

   400

			 */

   401

			adapter->itr_setting &= ~3;

   402

			break;

   403

		}

   404

	}

   405

	/* Interrupt Mode */

   406

	{

   407

		static struct e1000_option opt = {

   408

			.type = range_option,

   409

			.name = "Interrupt Mode",

   410

#ifndef CONFIG_PCI_MSI

   411

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

   412

			.def  = E1000E_INT_MODE_LEGACY,

   413

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

   414

					 .max = 0 } }

   415

#endif

   416

		};

   417

   418

#ifdef CONFIG_PCI_MSI

   419

		if (adapter->flags & FLAG_HAS_MSIX) {

   420

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

   421

					  GFP_KERNEL);

   422

			opt.def = E1000E_INT_MODE_MSIX;

   423

			opt.arg.r.max = E1000E_INT_MODE_MSIX;

   424

		} else {

   425

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

   426

			opt.def = E1000E_INT_MODE_MSI;

   427

			opt.arg.r.max = E1000E_INT_MODE_MSI;

   428

		}

   429

   430

		if (!opt.err) {

   431

			dev_err(&adapter->pdev->dev,

   432

				"Failed to allocate memory\n");

   433

			return;

   434

		}

   435

#endif

   436

   437

		if (num_IntMode > bd) {

   438

			unsigned int int_mode = IntMode[bd];

   439

   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

   462

			e1000_validate_option(&spd, &opt, adapter);

   463

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

   464

				adapter->flags |= FLAG_SMART_POWER_DOWN;

   465

		}

   466

	}

   467

	/* CRC Stripping */

   468

	{

   469

		static const struct e1000_option opt = {

   470

			.type = enable_option,

   471

			.name = "CRC Stripping",

   472

			.err  = "defaulting to Enabled",

   473

			.def  = OPTION_ENABLED

   474

		};

   475

   476

		if (num_CrcStripping > bd) {

   477

			unsigned int crc_stripping = CrcStripping[bd];

   478

   479

			e1000_validate_option(&crc_stripping, &opt, adapter);

   480

			if (crc_stripping == OPTION_ENABLED) {

   481

				adapter->flags2 |= FLAG2_CRC_STRIPPING;

   482

				adapter->flags2 |= FLAG2_DFLT_CRC_STRIPPING;

   483

			}

   484

		} else {

   485

			adapter->flags2 |= FLAG2_CRC_STRIPPING;

   486

			adapter->flags2 |= FLAG2_DFLT_CRC_STRIPPING;

   487

		}

   488

	}

   489

	/* Kumeran Lock Loss Workaround */

   490

	{

   491

		static const struct e1000_option opt = {

   492

			.type = enable_option,

   493

			.name = "Kumeran Lock Loss Workaround",

   494

			.err  = "defaulting to Enabled",

   495

			.def  = OPTION_ENABLED

   496

		};

   497

		bool enabled = opt.def;

   498

   499

		if (num_KumeranLockLoss > bd) {

   500

			unsigned int kmrn_lock_loss = KumeranLockLoss[bd];

   501

   502

			e1000_validate_option(&kmrn_lock_loss, &opt, adapter);

   503

			enabled = kmrn_lock_loss;

   504

		}

   505

   506

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

   507

			e1000e_set_kmrn_lock_loss_workaround_ich8lan(hw,

   508

								     enabled);

   509

	}

   510

	/* Write-protect NVM */

   511

	{

   512

		static const struct e1000_option opt = {

   513

			.type = enable_option,

   514

			.name = "Write-protect NVM",

   515

			.err  = "defaulting to Enabled",

   516

			.def  = OPTION_ENABLED

   517

		};

   518

   519

		if (adapter->flags & FLAG_IS_ICH) {

   520

			if (num_WriteProtectNVM > bd) {

   521

				unsigned int write_protect_nvm =

   522

				    WriteProtectNVM[bd];

   523

				e1000_validate_option(&write_protect_nvm, &opt,

   524

						      adapter);

   525

				if (write_protect_nvm)

   526

					adapter->flags |= FLAG_READ_ONLY_NVM;

   527

			} else {

   528

				if (opt.def)

   529

					adapter->flags |= FLAG_READ_ONLY_NVM;