1

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

     2

     3

     4

  Copyright(c) 1999 - 2006 Intel Corporation. All rights reserved.

     5

     6

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

     7

  under the terms of the GNU General Public License as published by the Free 

     8

  Software Foundation; either version 2 of the License, or (at your option) 

     9

  any later version.

    10

    11

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

    12

  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 

    13

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

    14

  more details.

    15

    16

  You should have received a copy of the GNU General Public License along with

    17

  this program; if not, write to the Free Software Foundation, Inc., 59 

    18

  Temple Place - Suite 330, Boston, MA  02111-1307, USA.

    19

    20

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

    21

  file called LICENSE.

    22

    23

  Contact Information:

    24

  Linux NICS <linux.nics@intel.com>

    25

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

    26

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

    27

    28

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

    29

    30

#include "e1000.h"

    31

    32

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

    33

 * maximum number of ports that the driver can manage.

    34

 */

    35

    36

#define E1000_MAX_NIC 32

    37

    38

#define OPTION_UNSET   -1

    39

#define OPTION_DISABLED 0

    40

#define OPTION_ENABLED  1

    41

    42

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

    43

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

    44

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

    45

 */

    46

    47

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

    48

/* Module Parameters are always initialized to -1, so that the driver

    49

 * can tell the difference between no user specified value or the

    50

 * user asking for the default value.

    51

 * The true default values are loaded in when e1000_check_options is called.

    52

 *

    53

 * This is a GCC extension to ANSI C.

    54

 * See the item "Labeled Elements in Initializers" in the section

    55

 * "Extensions to the C Language Family" of the GCC documentation.

    56

 */

    57

    58

#define E1000_PARAM(X, desc) \

    59

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

    60

	static int num_##X = 0; \

    61

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

    62

	MODULE_PARM_DESC(X, desc);

    63

    64

/* Transmit Descriptor Count

    65

 *

    66

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

    67

 * Valid Range: 80-4096 for 82544 and newer

    68

 *

    69

 * Default Value: 256

    70

 */

    71

    72

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

    73

    74

/* Receive Descriptor Count

    75

 *

    76

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

    77

 * Valid Range: 80-4096 for 82544 and newer

    78

 *

    79

 * Default Value: 256

    80

 */

    81

    82

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

    83

    84

/* User Specified Speed Override

    85

 *

    86

 * Valid Range: 0, 10, 100, 1000

    87

 *  - 0    - auto-negotiate at all supported speeds

    88

 *  - 10   - only link at 10 Mbps

    89

 *  - 100  - only link at 100 Mbps

    90

 *  - 1000 - only link at 1000 Mbps

    91

 *

    92

 * Default Value: 0

    93

 */

    94

    95

E1000_PARAM(Speed, "Speed setting");

    96

    97

/* User Specified Duplex Override

    98

 *

    99

 * Valid Range: 0-2

   100

 *  - 0 - auto-negotiate for duplex

   101

 *  - 1 - only link at half duplex

   102

 *  - 2 - only link at full duplex

   103

 *

   104

 * Default Value: 0

   105

 */

   106

   107

E1000_PARAM(Duplex, "Duplex setting");

   108

   109

/* Auto-negotiation Advertisement Override

   110

 *

   111

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

   112

 *

   113

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

   114

 * combinations should be advertised during auto-negotiation.

   115

 * The supported speed and duplex modes are listed below

   116

 *

   117

 * Bit           7     6     5      4      3     2     1      0

   118

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

   119

 * Duplex                    Full          Full  Half  Full   Half

   120

 *

   121

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

   122

 */

   123

   124

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

   125

   126

/* User Specified Flow Control Override

   127

 *

   128

 * Valid Range: 0-3

   129

 *  - 0 - No Flow Control

   130

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

   131

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

   132

 *  - 3 - Full Flow Control Support

   133

 *

   134

 * Default Value: Read flow control settings from the EEPROM

   135

 */

   136

   137

E1000_PARAM(FlowControl, "Flow Control setting");

   138

   139

/* XsumRX - Receive Checksum Offload Enable/Disable

   140

 *

   141

 * Valid Range: 0, 1

   142

 *  - 0 - disables all checksum offload

   143

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

   144

 *        on 82543 and newer -based NICs

   145

 *

   146

 * Default Value: 1

   147

 */

   148

   149

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

   150

   151

/* Transmit Interrupt Delay in units of 1.024 microseconds

   152

 *

   153

 * Valid Range: 0-65535

   154

 *

   155

 * Default Value: 64

   156

 */

   157

   158

E1000_PARAM(TxIntDelay, "Transmit Interrupt Delay");

   159

   160

/* Transmit Absolute Interrupt Delay in units of 1.024 microseconds

   161

 *

   162

 * Valid Range: 0-65535

   163

 *

   164

 * Default Value: 0

   165

 */

   166

   167

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

   168

   169

/* Receive Interrupt Delay in units of 1.024 microseconds

   170

 *

   171

 * Valid Range: 0-65535

   172

 *

   173

 * Default Value: 0

   174

 */

   175

   176

E1000_PARAM(RxIntDelay, "Receive Interrupt Delay");

   177

   178

/* Receive Absolute Interrupt Delay in units of 1.024 microseconds

   179

 *

   180

 * Valid Range: 0-65535

   181

 *

   182

 * Default Value: 128

   183

 */

   184

   185

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

   186

   187

/* Interrupt Throttle Rate (interrupts/sec)

   188

 *

   189

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

   190

 *

   191

 * Default Value: 8000

   192

 */

   193

   194

E1000_PARAM(InterruptThrottleRate, "Interrupt Throttling Rate");

   195

   196

/* Enable Smart Power Down of the PHY

   197

 *

   198

 * Valid Range: 0, 1

   199

 *

   200

 * Default Value: 0 (disabled)

   201

 */

   202

   203

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

   204

   205

/* Enable Kumeran Lock Loss workaround

   206

 *

   207

 * Valid Range: 0, 1

   208

 *

   209

 * Default Value: 1 (enabled)

   210

 */

   211

   212

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

   213

   214

#define AUTONEG_ADV_DEFAULT  0x2F

   215

#define AUTONEG_ADV_MASK     0x2F

   216

#define FLOW_CONTROL_DEFAULT FLOW_CONTROL_FULL

   217

   218

#define DEFAULT_RDTR                   0

   219

#define MAX_RXDELAY               0xFFFF

   220

#define MIN_RXDELAY                    0

   221

   222

#define DEFAULT_RADV                 128

   223

#define MAX_RXABSDELAY            0xFFFF

   224

#define MIN_RXABSDELAY                 0

   225

   226

#define DEFAULT_TIDV                  64

   227

#define MAX_TXDELAY               0xFFFF

   228

#define MIN_TXDELAY                    0

   229

   230

#define DEFAULT_TADV                  64

   231

#define MAX_TXABSDELAY            0xFFFF

   232

#define MIN_TXABSDELAY                 0

   233

   234

#define DEFAULT_ITR                 8000

   235

#define MAX_ITR                   100000

   236

#define MIN_ITR                      100

   237

   238

struct e1000_option {

   239

	enum { enable_option, range_option, list_option } type;

   240

	char *name;

   241

	char *err;

   242

	int  def;

   243

	union {

   244

		struct { /* range_option info */

   245

			int min;

   246

			int max;

   247

		} r;

   248

		struct { /* list_option info */

   249

			int nr;

   250

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

   251

		} l;

   252

	} arg;

   253

};

   254

   255

static int __devinit

   256

e1000_validate_option(int *value, struct e1000_option *opt,

   257

		struct e1000_adapter *adapter)

   258

{

   259

	if (*value == OPTION_UNSET) {

   260

		*value = opt->def;

   261

		return 0;

   262

	}

   263

   264

	switch (opt->type) {

   265

	case enable_option:

   266

		switch (*value) {

   267

		case OPTION_ENABLED:

   268

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

   269

			return 0;

   270

		case OPTION_DISABLED:

   271

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

   272

			return 0;

   273

		}

   274

		break;

   275

	case range_option:

   276

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

   277

			DPRINTK(PROBE, INFO,

   278

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

   279

			return 0;

   280

		}

   281

		break;

   282

	case list_option: {

   283

		int i;

   284

		struct e1000_opt_list *ent;

   285

   286

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

   287

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

   288

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

   289

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

   290

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

   291

				return 0;

   292

			}

   293

		}

   294

	}

   295

		break;

   296

	default:

   297

		BUG();

   298

	}

   299

   300

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

   301

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

   302

	*value = opt->def;

   303

	return -1;

   304

}

   305

   306

static void e1000_check_fiber_options(struct e1000_adapter *adapter);

   307

static void e1000_check_copper_options(struct e1000_adapter *adapter);

   308

   309

/**

   310

 * e1000_check_options - Range Checking for Command Line Parameters

   311

 * @adapter: board private structure

   312

 *

   313

 * This routine checks all command line parameters for valid user

   314

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

   315

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

   316

 * in a variable in the adapter structure.

   317

 **/

   318

   319

void __devinit

   320

e1000_check_options(struct e1000_adapter *adapter)

   321

{

   322

	int bd = adapter->bd_number;

   323

	if (bd >= E1000_MAX_NIC) {

   324

		DPRINTK(PROBE, NOTICE,

   325

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

   326

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

   327

		bd = E1000_MAX_NIC;

   328

	}

   329

   330

	{ /* Transmit Descriptor Count */

   331

		struct e1000_option opt = {

   332

			.type = range_option,

   333

			.name = "Transmit Descriptors",

   334

			.err  = "using default of "

   335

				__MODULE_STRING(E1000_DEFAULT_TXD),

   336

			.def  = E1000_DEFAULT_TXD,

   337

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

   338

		};

   339

		struct e1000_tx_ring *tx_ring = adapter->tx_ring;

   340

		int i;

   341

		e1000_mac_type mac_type = adapter->hw.mac_type;

   342

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

   343

			E1000_MAX_TXD : E1000_MAX_82544_TXD;

   344

   345

		tx_ring->count = TxDescriptors[bd];

   346

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

   347

		E1000_ROUNDUP(tx_ring->count, REQ_TX_DESCRIPTOR_MULTIPLE);

   348

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

   349

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

   350

	}

   351

	{ /* Receive Descriptor Count */

   352

		struct e1000_option opt = {

   353

			.type = range_option,

   354

			.name = "Receive Descriptors",

   355

			.err  = "using default of "

   356

				__MODULE_STRING(E1000_DEFAULT_RXD),

   357

			.def  = E1000_DEFAULT_RXD,

   358

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

   359

		};

   360

		struct e1000_rx_ring *rx_ring = adapter->rx_ring;

   361

		int i;

   362

		e1000_mac_type mac_type = adapter->hw.mac_type;

   363

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

   364

			E1000_MAX_82544_RXD;

   365

   366

		rx_ring->count = RxDescriptors[bd];

   367

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

   368

		E1000_ROUNDUP(rx_ring->count, REQ_RX_DESCRIPTOR_MULTIPLE);

   369

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

   370

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

   371

	}

   372

	{ /* Checksum Offload Enable/Disable */

   373

		struct e1000_option opt = {

   374

			.type = enable_option,

   375

			.name = "Checksum Offload",

   376

			.err  = "defaulting to Enabled",

   377

			.def  = OPTION_ENABLED

   378

		};

   379

   380

		int rx_csum = XsumRX[bd];

   381

		e1000_validate_option(&rx_csum, &opt, adapter);

   382

		adapter->rx_csum = rx_csum;

   383

	}

   384

	{ /* Flow Control */

   385

   386

		struct e1000_opt_list fc_list[] =

   387

			{{ e1000_fc_none,    "Flow Control Disabled" },

   388

			 { e1000_fc_rx_pause,"Flow Control Receive Only" },

   389

			 { e1000_fc_tx_pause,"Flow Control Transmit Only" },

   390

			 { e1000_fc_full,    "Flow Control Enabled" },

   391

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

   392

   393

		struct e1000_option opt = {

   394

			.type = list_option,

   395

			.name = "Flow Control",

   396

			.err  = "reading default settings from EEPROM",

   397

			.def  = e1000_fc_default,

   398

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

   399

					 .p = fc_list }}

   400

		};

   401

   402

		int fc = FlowControl[bd];

   403

		e1000_validate_option(&fc, &opt, adapter);

   404

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

   405

	}

   406

	{ /* Transmit Interrupt Delay */

   407

		struct e1000_option opt = {

   408

			.type = range_option,

   409

			.name = "Transmit Interrupt Delay",

   410

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

   411

			.def  = DEFAULT_TIDV,

   412

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

   413

					 .max = MAX_TXDELAY }}

   414

		};

   415

   416

		adapter->tx_int_delay = TxIntDelay[bd];

   417

		e1000_validate_option(&adapter->tx_int_delay, &opt, adapter);

   418

	}

   419

	{ /* Transmit Absolute Interrupt Delay */

   420

		struct e1000_option opt = {

   421

			.type = range_option,

   422

			.name = "Transmit Absolute Interrupt Delay",

   423

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

   424

			.def  = DEFAULT_TADV,

   425

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

   426

					 .max = MAX_TXABSDELAY }}

   427

		};

   428

   429

		adapter->tx_abs_int_delay = TxAbsIntDelay[bd];

   430

		e1000_validate_option(&adapter->tx_abs_int_delay, &opt,

   431

		                      adapter);

   432

	}

   433

	{ /* Receive Interrupt Delay */

   434

		struct e1000_option opt = {

   435

			.type = range_option,

   436

			.name = "Receive Interrupt Delay",

   437

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

   438

			.def  = DEFAULT_RDTR,

   439

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

   440

					 .max = MAX_RXDELAY }}

   441

		};

   442

   443

		adapter->rx_int_delay = RxIntDelay[bd];

   444

		e1000_validate_option(&adapter->rx_int_delay, &opt, adapter);

   445

	}

   446

	{ /* Receive Absolute Interrupt Delay */

   447

		struct e1000_option opt = {

   448

			.type = range_option,

   449

			.name = "Receive Absolute Interrupt Delay",

   450

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

   451

			.def  = DEFAULT_RADV,

   452

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

   453

					 .max = MAX_RXABSDELAY }}

   454

		};

   455

   456

		adapter->rx_abs_int_delay = RxAbsIntDelay[bd];

   457

		e1000_validate_option(&adapter->rx_abs_int_delay, &opt,

   458

		                      adapter);

   459

	}

   460

	{ /* Interrupt Throttling Rate */

   461

		struct e1000_option opt = {

   462

			.type = range_option,

   463

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

   464

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

   465

			.def  = DEFAULT_ITR,

   466

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

   467

					 .max = MAX_ITR }}

   468

		};

   469

   470

		adapter->itr = InterruptThrottleRate[bd];

   471

		switch (adapter->itr) {

   472

		case 0:

   473

			DPRINTK(PROBE, INFO, "%s turned off\n", opt.name);

   474

			break;

   475

		case 1:

   476

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

   477

				opt.name);

   478

			break;

   479

		default:

   480

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

   481

			break;

   482

		}

   483

	}

   484

	{ /* Smart Power Down */

   485

		struct e1000_option opt = {

   486

			.type = enable_option,

   487

			.name = "PHY Smart Power Down",

   488

			.err  = "defaulting to Disabled",

   489

			.def  = OPTION_DISABLED

   490

		};

   491

   492

		int spd = SmartPowerDownEnable[bd];

   493

		e1000_validate_option(&spd, &opt, adapter);

   494

		adapter->smart_power_down = spd;

   495

	}

   496

	{ /* Kumeran Lock Loss Workaround */

   497

		struct e1000_option opt = {

   498

			.type = enable_option,

   499

			.name = "Kumeran Lock Loss Workaround",

   500

			.err  = "defaulting to Enabled",

   501

			.def  = OPTION_ENABLED

   502

		};

   503

   504

			int kmrn_lock_loss = KumeranLockLoss[bd];

   505

			e1000_validate_option(&kmrn_lock_loss, &opt, adapter);

   506

			adapter->hw.kmrn_lock_loss_workaround_disabled = !kmrn_lock_loss;

   507

	}

   508

   509

	switch (adapter->hw.media_type) {

   510

	case e1000_media_type_fiber:

   511

	case e1000_media_type_internal_serdes:

   512

		e1000_check_fiber_options(adapter);

   513

		break;

   514

	case e1000_media_type_copper:

   515

		e1000_check_copper_options(adapter);

   516

		break;

   517

	default:

   518

		BUG();

   519

	}

   520

}

   521

   522

/**

   523

 * e1000_check_fiber_options - Range Checking for Link Options, Fiber Version

   524

 * @adapter: board private structure

   525

 *

   526

 * Handles speed and duplex options on fiber adapters

   527

 **/

   528

   529

static void __devinit

   530

e1000_check_fiber_options(struct e1000_adapter *adapter)