1

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

     2

     3

  Intel PRO/1000 Linux driver

     4

  Copyright(c) 1999 - 2006 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 "e1000.h"

    30

    31

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

    32

 * maximum number of ports that the driver can manage.

    33

 */

    34

    35

#define E1000_MAX_NIC 32

    36

    37

#define OPTION_UNSET   -1

    38

#define OPTION_DISABLED 0

    39

#define OPTION_ENABLED  1

    40

    41

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

    42

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

    43

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

    44

 */

    45

    46

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

    47

#define E1000_PARAM(X, desc) \

    48

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

    49

	static unsigned int num_##X; \

    50

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

    51

	MODULE_PARM_DESC(X, desc);

    52

    53

/* Transmit Descriptor Count

    54

 *

    55

 * Valid Range: 80-256 for 82542 and 82543 gigabit ethernet controllers

    56

 * Valid Range: 80-4096 for 82544 and newer

    57

 *

    58

 * Default Value: 256

    59

 */

    60

E1000_PARAM(TxDescriptors, "Number of transmit descriptors");

    61

    62

/* Receive Descriptor Count

    63

 *

    64

 * Valid Range: 80-256 for 82542 and 82543 gigabit ethernet controllers

    65

 * Valid Range: 80-4096 for 82544 and newer

    66

 *

    67

 * Default Value: 256

    68

 */

    69

E1000_PARAM(RxDescriptors, "Number of receive descriptors");

    70

    71

/* User Specified Speed Override

    72

 *

    73

 * Valid Range: 0, 10, 100, 1000

    74

 *  - 0    - auto-negotiate at all supported speeds

    75

 *  - 10   - only link at 10 Mbps

    76

 *  - 100  - only link at 100 Mbps

    77

 *  - 1000 - only link at 1000 Mbps

    78

 *

    79

 * Default Value: 0

    80

 */

    81

E1000_PARAM(Speed, "Speed setting");

    82

    83

/* User Specified Duplex Override

    84

 *

    85

 * Valid Range: 0-2

    86

 *  - 0 - auto-negotiate for duplex

    87

 *  - 1 - only link at half duplex

    88

 *  - 2 - only link at full duplex

    89

 *

    90

 * Default Value: 0

    91

 */

    92

E1000_PARAM(Duplex, "Duplex setting");

    93

    94

/* Auto-negotiation Advertisement Override

    95

 *

    96

 * Valid Range: 0x01-0x0F, 0x20-0x2F (copper); 0x20 (fiber)

    97

 *

    98

 * The AutoNeg value is a bit mask describing which speed and duplex

    99

 * combinations should be advertised during auto-negotiation.

   100

 * The supported speed and duplex modes are listed below

   101

 *

   102

 * Bit           7     6     5      4      3     2     1      0

   103

 * Speed (Mbps)  N/A   N/A   1000   N/A    100   100   10     10

   104

 * Duplex                    Full          Full  Half  Full   Half

   105

 *

   106

 * Default Value: 0x2F (copper); 0x20 (fiber)

   107

 */

   108

E1000_PARAM(AutoNeg, "Advertised auto-negotiation setting");

   109

#define AUTONEG_ADV_DEFAULT  0x2F

   110

#define AUTONEG_ADV_MASK     0x2F

   111

   112

/* User Specified Flow Control Override

   113

 *

   114

 * Valid Range: 0-3

   115

 *  - 0 - No Flow Control

   116

 *  - 1 - Rx only, respond to PAUSE frames but do not generate them

   117

 *  - 2 - Tx only, generate PAUSE frames but ignore them on receive

   118

 *  - 3 - Full Flow Control Support

   119

 *

   120

 * Default Value: Read flow control settings from the EEPROM

   121

 */

   122

E1000_PARAM(FlowControl, "Flow Control setting");

   123

#define FLOW_CONTROL_DEFAULT FLOW_CONTROL_FULL

   124

   125

/* XsumRX - Receive Checksum Offload Enable/Disable

   126

 *

   127

 * Valid Range: 0, 1

   128

 *  - 0 - disables all checksum offload

   129

 *  - 1 - enables receive IP/TCP/UDP checksum offload

   130

 *        on 82543 and newer -based NICs

   131

 *

   132

 * Default Value: 1

   133

 */

   134

E1000_PARAM(XsumRX, "Disable or enable Receive Checksum offload");

   135

   136

/* Transmit Interrupt Delay in units of 1.024 microseconds

   137

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

   138

 *

   139

 * Valid Range: 0-65535

   140

 */

   141

E1000_PARAM(TxIntDelay, "Transmit Interrupt Delay");

   142

#define DEFAULT_TIDV                   8

   143

#define MAX_TXDELAY               0xFFFF

   144

#define MIN_TXDELAY                    0

   145

   146

/* Transmit Absolute Interrupt Delay in units of 1.024 microseconds

   147

 *

   148

 * Valid Range: 0-65535

   149

 */

   150

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

   151

#define DEFAULT_TADV                  32

   152

#define MAX_TXABSDELAY            0xFFFF

   153

#define MIN_TXABSDELAY                 0

   154

   155

/* Receive Interrupt Delay in units of 1.024 microseconds

   156

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

   157

 *

   158

 * Valid Range: 0-65535

   159

 */

   160

E1000_PARAM(RxIntDelay, "Receive Interrupt Delay");

   161

#define DEFAULT_RDTR                   0

   162

#define MAX_RXDELAY               0xFFFF

   163

#define MIN_RXDELAY                    0

   164

   165

/* Receive Absolute Interrupt Delay in units of 1.024 microseconds

   166

 *

   167

 * Valid Range: 0-65535

   168

 */

   169

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

   170

#define DEFAULT_RADV                   8

   171

#define MAX_RXABSDELAY            0xFFFF

   172

#define MIN_RXABSDELAY                 0

   173

   174

/* Interrupt Throttle Rate (interrupts/sec)

   175

 *

   176

 * Valid Range: 100-100000 (0=off, 1=dynamic, 3=dynamic conservative)

   177

 */

   178

E1000_PARAM(InterruptThrottleRate, "Interrupt Throttling Rate");

   179

#define DEFAULT_ITR                    3

   180

#define MAX_ITR                   100000

   181

#define MIN_ITR                      100

   182

   183

/* Enable Smart Power Down of the PHY

   184

 *

   185

 * Valid Range: 0, 1

   186

 *

   187

 * Default Value: 0 (disabled)

   188

 */

   189

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

   190

   191

/* Enable Kumeran Lock Loss workaround

   192

 *

   193

 * Valid Range: 0, 1

   194

 *

   195

 * Default Value: 1 (enabled)

   196

 */

   197

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

   198

   199

struct e1000_option {

   200

	enum { enable_option, range_option, list_option } type;

   201

	const char *name;

   202

	const char *err;

   203

	int def;

   204

	union {

   205

		struct { /* range_option info */

   206

			int min;

   207

			int max;

   208

		} r;

   209

		struct { /* list_option info */

   210

			int nr;

   211

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

   212

		} l;

   213

	} arg;

   214

};

   215

   216

static int __devinit

   217

e1000_validate_option(unsigned int *value,

   218

		      const struct e1000_option *opt,

   219

		      struct e1000_adapter *adapter)

   220

{

   221

	if (*value == OPTION_UNSET) {

   222

		*value = opt->def;

   223

		return 0;

   224

	}

   225

   226

	switch (opt->type) {

   227

	case enable_option:

   228

		switch (*value) {

   229

		case OPTION_ENABLED:

   230

			DPRINTK(PROBE, INFO, "%s Enabled\n", opt->name);

   231

			return 0;

   232

		case OPTION_DISABLED:

   233

			DPRINTK(PROBE, INFO, "%s Disabled\n", opt->name);

   234

			return 0;

   235

		}

   236

		break;

   237

	case range_option:

   238

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

   239

			DPRINTK(PROBE, INFO,

   240

					"%s set to %i\n", opt->name, *value);

   241

			return 0;

   242

		}

   243

		break;

   244

	case list_option: {

   245

		int i;

   246

		struct e1000_opt_list *ent;

   247

   248

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

   249

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

   250

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

   251

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

   252

					DPRINTK(PROBE, INFO, "%s\n", ent->str);

   253

				return 0;

   254

			}

   255

		}

   256

	}

   257

		break;

   258

	default:

   259

		BUG();

   260

	}

   261

   262

	DPRINTK(PROBE, INFO, "Invalid %s value specified (%i) %s\n",

   263

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

   264

	*value = opt->def;

   265

	return -1;

   266

}

   267

   268

static void e1000_check_fiber_options(struct e1000_adapter *adapter);

   269

static void e1000_check_copper_options(struct e1000_adapter *adapter);

   270

   271

/**

   272

 * e1000_check_options - Range Checking for Command Line Parameters

   273

 * @adapter: board private structure

   274

 *

   275

 * This routine checks all command line parameters for valid user

   276

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

   277

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

   278

 * in a variable in the adapter structure.

   279

 **/

   280

   281

void __devinit

   282

e1000_check_options(struct e1000_adapter *adapter)

   283

{

   284

	int bd = adapter->bd_number;

   285

	if (bd >= E1000_MAX_NIC) {

   286

		DPRINTK(PROBE, NOTICE,

   287

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

   288

		DPRINTK(PROBE, NOTICE, "Using defaults for all values\n");

   289

	}

   290

   291

	{ /* Transmit Descriptor Count */

   292

		struct e1000_option opt = {

   293

			.type = range_option,

   294

			.name = "Transmit Descriptors",

   295

			.err  = "using default of "

   296

				__MODULE_STRING(E1000_DEFAULT_TXD),

   297

			.def  = E1000_DEFAULT_TXD,

   298

			.arg  = { .r = { .min = E1000_MIN_TXD }}

   299

		};

   300

		struct e1000_tx_ring *tx_ring = adapter->tx_ring;

   301

		int i;

   302

		e1000_mac_type mac_type = adapter->hw.mac_type;

   303

		opt.arg.r.max = mac_type < e1000_82544 ?

   304

			E1000_MAX_TXD : E1000_MAX_82544_TXD;

   305

   306

		if (num_TxDescriptors > bd) {

   307

			tx_ring->count = TxDescriptors[bd];

   308

			e1000_validate_option(&tx_ring->count, &opt, adapter);

   309

			tx_ring->count = ALIGN(tx_ring->count,

   310

						REQ_TX_DESCRIPTOR_MULTIPLE);

   311

		} else {

   312

			tx_ring->count = opt.def;

   313

		}

   314

		for (i = 0; i < adapter->num_tx_queues; i++)

   315

			tx_ring[i].count = tx_ring->count;

   316

	}

   317

	{ /* Receive Descriptor Count */

   318

		struct e1000_option opt = {

   319

			.type = range_option,

   320

			.name = "Receive Descriptors",

   321

			.err  = "using default of "

   322

				__MODULE_STRING(E1000_DEFAULT_RXD),

   323

			.def  = E1000_DEFAULT_RXD,

   324

			.arg  = { .r = { .min = E1000_MIN_RXD }}

   325

		};

   326

		struct e1000_rx_ring *rx_ring = adapter->rx_ring;

   327

		int i;

   328

		e1000_mac_type mac_type = adapter->hw.mac_type;

   329

		opt.arg.r.max = mac_type < e1000_82544 ? E1000_MAX_RXD :

   330

			E1000_MAX_82544_RXD;

   331

   332

		if (num_RxDescriptors > bd) {

   333

			rx_ring->count = RxDescriptors[bd];

   334

			e1000_validate_option(&rx_ring->count, &opt, adapter);

   335

			rx_ring->count = ALIGN(rx_ring->count,

   336

						REQ_RX_DESCRIPTOR_MULTIPLE);

   337

		} else {

   338

			rx_ring->count = opt.def;

   339

		}

   340

		for (i = 0; i < adapter->num_rx_queues; i++)

   341

			rx_ring[i].count = rx_ring->count;

   342

	}

   343

	{ /* Checksum Offload Enable/Disable */

   344

		struct e1000_option opt = {

   345

			.type = enable_option,

   346

			.name = "Checksum Offload",

   347

			.err  = "defaulting to Enabled",

   348

			.def  = OPTION_ENABLED

   349

		};

   350

   351

		if (num_XsumRX > bd) {

   352

			unsigned int rx_csum = XsumRX[bd];

   353

			e1000_validate_option(&rx_csum, &opt, adapter);

   354

			adapter->rx_csum = rx_csum;

   355

		} else {

   356

			adapter->rx_csum = opt.def;

   357

		}

   358

	}

   359

	{ /* Flow Control */

   360

   361

		struct e1000_opt_list fc_list[] =

   362

			{{ E1000_FC_NONE,    "Flow Control Disabled" },

   363

			 { E1000_FC_RX_PAUSE,"Flow Control Receive Only" },

   364

			 { E1000_FC_TX_PAUSE,"Flow Control Transmit Only" },

   365

			 { E1000_FC_FULL,    "Flow Control Enabled" },

   366

			 { E1000_FC_DEFAULT, "Flow Control Hardware Default" }};

   367

   368

		struct e1000_option opt = {

   369

			.type = list_option,

   370

			.name = "Flow Control",

   371

			.err  = "reading default settings from EEPROM",

   372

			.def  = E1000_FC_DEFAULT,

   373

			.arg  = { .l = { .nr = ARRAY_SIZE(fc_list),

   374

					 .p = fc_list }}

   375

		};

   376

   377

		if (num_FlowControl > bd) {

   378

			unsigned int fc = FlowControl[bd];

   379

			e1000_validate_option(&fc, &opt, adapter);

   380

			adapter->hw.fc = adapter->hw.original_fc = fc;

   381

		} else {

   382

			adapter->hw.fc = adapter->hw.original_fc = opt.def;

   383

		}

   384

	}

   385

	{ /* Transmit Interrupt Delay */

   386

		struct e1000_option opt = {

   387

			.type = range_option,

   388

			.name = "Transmit Interrupt Delay",

   389

			.err  = "using default of " __MODULE_STRING(DEFAULT_TIDV),

   390

			.def  = DEFAULT_TIDV,

   391

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

   392

					 .max = MAX_TXDELAY }}

   393

		};

   394

   395

		if (num_TxIntDelay > bd) {

   396

			adapter->tx_int_delay = TxIntDelay[bd];

   397

			e1000_validate_option(&adapter->tx_int_delay, &opt,

   398

			                      adapter);

   399

		} else {

   400

			adapter->tx_int_delay = opt.def;

   401

		}

   402

	}

   403

	{ /* Transmit Absolute Interrupt Delay */

   404

		struct e1000_option opt = {

   405

			.type = range_option,

   406

			.name = "Transmit Absolute Interrupt Delay",

   407

			.err  = "using default of " __MODULE_STRING(DEFAULT_TADV),

   408

			.def  = DEFAULT_TADV,

   409

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

   410

					 .max = MAX_TXABSDELAY }}

   411

		};

   412

   413

		if (num_TxAbsIntDelay > bd) {

   414

			adapter->tx_abs_int_delay = TxAbsIntDelay[bd];

   415

			e1000_validate_option(&adapter->tx_abs_int_delay, &opt,

   416

			                      adapter);

   417

		} else {

   418

			adapter->tx_abs_int_delay = opt.def;

   419

		}

   420

	}

   421

	{ /* Receive Interrupt Delay */

   422

		struct e1000_option opt = {

   423

			.type = range_option,

   424

			.name = "Receive Interrupt Delay",

   425

			.err  = "using default of " __MODULE_STRING(DEFAULT_RDTR),

   426

			.def  = DEFAULT_RDTR,

   427

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

   428

					 .max = MAX_RXDELAY }}

   429

		};

   430

   431

		if (num_RxIntDelay > bd) {

   432

			adapter->rx_int_delay = RxIntDelay[bd];

   433

			e1000_validate_option(&adapter->rx_int_delay, &opt,

   434

			                      adapter);

   435

		} else {

   436

			adapter->rx_int_delay = opt.def;

   437

		}

   438

	}

   439

	{ /* Receive Absolute Interrupt Delay */

   440

		struct e1000_option opt = {

   441

			.type = range_option,

   442

			.name = "Receive Absolute Interrupt Delay",

   443

			.err  = "using default of " __MODULE_STRING(DEFAULT_RADV),

   444

			.def  = DEFAULT_RADV,

   445

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

   446

					 .max = MAX_RXABSDELAY }}

   447

		};

   448

   449

		if (num_RxAbsIntDelay > bd) {

   450

			adapter->rx_abs_int_delay = RxAbsIntDelay[bd];

   451

			e1000_validate_option(&adapter->rx_abs_int_delay, &opt,

   452

			                      adapter);

   453

		} else {

   454

			adapter->rx_abs_int_delay = opt.def;

   455

		}

   456

	}

   457

	{ /* Interrupt Throttling Rate */

   458

		struct e1000_option opt = {

   459

			.type = range_option,

   460

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

   461

			.err  = "using default of " __MODULE_STRING(DEFAULT_ITR),

   462

			.def  = DEFAULT_ITR,

   463

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

   464

					 .max = MAX_ITR }}

   465

		};

   466

   467

		if (num_InterruptThrottleRate > bd) {

   468

			adapter->itr = InterruptThrottleRate[bd];

   469

			switch (adapter->itr) {

   470

			case 0:

   471

				DPRINTK(PROBE, INFO, "%s turned off\n",

   472

				        opt.name);

   473

				break;

   474

			case 1:

   475

				DPRINTK(PROBE, INFO, "%s set to dynamic mode\n",

   476

					opt.name);

   477

				adapter->itr_setting = adapter->itr;

   478

				adapter->itr = 20000;

   479

				break;

   480

			case 3:

   481

				DPRINTK(PROBE, INFO,

   482

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

   483

					opt.name);

   484

				adapter->itr_setting = adapter->itr;

   485

				adapter->itr = 20000;

   486

				break;

   487

			default:

   488

				e1000_validate_option(&adapter->itr, &opt,

   489

				        adapter);

   490

				/* save the setting, because the dynamic bits change itr */

   491

				/* clear the lower two bits because they are

   492

				 * used as control */

   493

				adapter->itr_setting = adapter->itr & ~3;

   494

				break;

   495

			}

   496

		} else {

   497

			adapter->itr_setting = opt.def;

   498

			adapter->itr = 20000;

   499

		}

   500

	}

   501

	{ /* Smart Power Down */

   502

		struct e1000_option opt = {

   503

			.type = enable_option,

   504

			.name = "PHY Smart Power Down",

   505

			.err  = "defaulting to Disabled",

   506

			.def  = OPTION_DISABLED

   507

		};

   508

   509

		if (num_SmartPowerDownEnable > bd) {

   510

			unsigned int spd = SmartPowerDownEnable[bd];

   511

			e1000_validate_option(&spd, &opt, adapter);

   512

			adapter->smart_power_down = spd;

   513

		} else {

   514

			adapter->smart_power_down = opt.def;

   515

		}

   516

	}

   517

	{ /* Kumeran Lock Loss Workaround */

   518

		struct e1000_option opt = {

   519

			.type = enable_option,

   520

			.name = "Kumeran Lock Loss Workaround",

   521

			.err  = "defaulting to Enabled",

   522

			.def  = OPTION_ENABLED

   523

		};

   524

   525

		if (num_KumeranLockLoss > bd) {

   526

			unsigned int kmrn_lock_loss = KumeranLockLoss[bd];

   527

			e1000_validate_option(&kmrn_lock_loss, &opt, adapter);

   528

			adapter->hw.kmrn_lock_loss_workaround_disabled = !kmrn_lock_loss;

   529

		} else {

   530

			adapter->hw.kmrn_lock_loss_workaround_disabled = !opt.def;