1

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

     2

     3

     4

  Copyright(c) 1999 - 2005 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

  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 int num_##X = 0; \

    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

    61

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

    62

    63

/* Receive Descriptor Count

    64

 *

    65

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

    66

 * Valid Range: 80-4096 for 82544 and newer

    67

 *

    68

 * Default Value: 256

    69

 */

    70

    71

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

    72

    73

/* User Specified Speed Override

    74

 *

    75

 * Valid Range: 0, 10, 100, 1000

    76

 *  - 0    - auto-negotiate at all supported speeds

    77

 *  - 10   - only link at 10 Mbps

    78

 *  - 100  - only link at 100 Mbps

    79

 *  - 1000 - only link at 1000 Mbps

    80

 *

    81

 * Default Value: 0

    82

 */

    83

    84

E1000_PARAM(Speed, "Speed setting");

    85

    86

/* User Specified Duplex Override

    87

 *

    88

 * Valid Range: 0-2

    89

 *  - 0 - auto-negotiate for duplex

    90

 *  - 1 - only link at half duplex

    91

 *  - 2 - only link at full duplex

    92

 *

    93

 * Default Value: 0

    94

 */

    95

    96

E1000_PARAM(Duplex, "Duplex setting");

    97

    98

/* Auto-negotiation Advertisement Override

    99

 *

   100

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

   101

 *

   102

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

   103

 * combinations should be advertised during auto-negotiation.

   104

 * The supported speed and duplex modes are listed below

   105

 *

   106

 * Bit           7     6     5      4      3     2     1      0

   107

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

   108

 * Duplex                    Full          Full  Half  Full   Half

   109

 *

   110

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

   111

 */

   112

   113

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

   114

   115

/* User Specified Flow Control Override

   116

 *

   117

 * Valid Range: 0-3

   118

 *  - 0 - No Flow Control

   119

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

   120

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

   121

 *  - 3 - Full Flow Control Support

   122

 *

   123

 * Default Value: Read flow control settings from the EEPROM

   124

 */

   125

   126

E1000_PARAM(FlowControl, "Flow Control setting");

   127

   128

/* XsumRX - Receive Checksum Offload Enable/Disable

   129

 *

   130

 * Valid Range: 0, 1

   131

 *  - 0 - disables all checksum offload

   132

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

   133

 *        on 82543 and newer -based NICs

   134

 *

   135

 * Default Value: 1

   136

 */

   137

   138

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

   139

   140

/* Transmit Interrupt Delay in units of 1.024 microseconds

   141

 *

   142

 * Valid Range: 0-65535

   143

 *

   144

 * Default Value: 64

   145

 */

   146

   147

E1000_PARAM(TxIntDelay, "Transmit Interrupt Delay");

   148

   149

/* Transmit Absolute Interrupt Delay in units of 1.024 microseconds

   150

 *

   151

 * Valid Range: 0-65535

   152

 *

   153

 * Default Value: 0

   154

 */

   155

   156

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

   157

   158

/* Receive Interrupt Delay in units of 1.024 microseconds

   159

 *

   160

 * Valid Range: 0-65535

   161

 *

   162

 * Default Value: 0

   163

 */

   164

   165

E1000_PARAM(RxIntDelay, "Receive Interrupt Delay");

   166

   167

/* Receive Absolute Interrupt Delay in units of 1.024 microseconds

   168

 *

   169

 * Valid Range: 0-65535

   170

 *

   171

 * Default Value: 128

   172

 */

   173

   174

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

   175

   176

/* Interrupt Throttle Rate (interrupts/sec)

   177

 *

   178

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

   179

 *

   180

 * Default Value: 1

   181

 */

   182

   183

E1000_PARAM(InterruptThrottleRate, "Interrupt Throttling Rate");

   184

   185

#define AUTONEG_ADV_DEFAULT  0x2F

   186

#define AUTONEG_ADV_MASK     0x2F

   187

#define FLOW_CONTROL_DEFAULT FLOW_CONTROL_FULL

   188

   189

#define DEFAULT_RDTR                   0

   190

#define MAX_RXDELAY               0xFFFF

   191

#define MIN_RXDELAY                    0

   192

   193

#define DEFAULT_RADV                 128

   194

#define MAX_RXABSDELAY            0xFFFF

   195

#define MIN_RXABSDELAY                 0

   196

   197

#define DEFAULT_TIDV                  64

   198

#define MAX_TXDELAY               0xFFFF

   199

#define MIN_TXDELAY                    0

   200

   201

#define DEFAULT_TADV                  64

   202

#define MAX_TXABSDELAY            0xFFFF

   203

#define MIN_TXABSDELAY                 0

   204

   205

#define DEFAULT_ITR                 8000

   206

#define MAX_ITR                   100000

   207

#define MIN_ITR                      100

   208

   209

struct e1000_option {

   210

	enum { enable_option, range_option, list_option } type;

   211

	char *name;

   212

	char *err;

   213

	int  def;

   214

	union {

   215

		struct { /* range_option info */

   216

			int min;

   217

			int max;

   218

		} r;

   219

		struct { /* list_option info */

   220

			int nr;

   221

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

   222

		} l;

   223

	} arg;

   224

};

   225

   226

static int __devinit

   227

e1000_validate_option(int *value, struct e1000_option *opt,

   228

		struct e1000_adapter *adapter)

   229

{

   230

	if(*value == OPTION_UNSET) {

   231

		*value = opt->def;

   232

		return 0;

   233

	}

   234

   235

	switch (opt->type) {

   236

	case enable_option:

   237

		switch (*value) {

   238

		case OPTION_ENABLED:

   239

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

   240

			return 0;

   241

		case OPTION_DISABLED:

   242

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

   243

			return 0;

   244

		}

   245

		break;

   246

	case range_option:

   247

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

   248

			DPRINTK(PROBE, INFO,

   249

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

   250

			return 0;

   251

		}

   252

		break;

   253

	case list_option: {

   254

		int i;

   255

		struct e1000_opt_list *ent;

   256

   257

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

   258

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

   259

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

   260

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

   261

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

   262

				return 0;

   263

			}

   264

		}

   265

	}

   266

		break;

   267

	default:

   268

		BUG();

   269

	}

   270

   271

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

   272

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

   273

	*value = opt->def;

   274

	return -1;

   275

}

   276

   277

static void e1000_check_fiber_options(struct e1000_adapter *adapter);

   278

static void e1000_check_copper_options(struct e1000_adapter *adapter);

   279

   280

/**

   281

 * e1000_check_options - Range Checking for Command Line Parameters

   282

 * @adapter: board private structure

   283

 *

   284

 * This routine checks all command line parameters for valid user

   285

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

   286

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

   287

 * in a variable in the adapter structure.

   288

 **/

   289

   290

void __devinit

   291

e1000_check_options(struct e1000_adapter *adapter)

   292

{

   293

	int bd = adapter->bd_number;

   294

	if(bd >= E1000_MAX_NIC) {

   295

		DPRINTK(PROBE, NOTICE,

   296

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

   297

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

   298

	}

   299

   300

	{ /* Transmit Descriptor Count */

   301

		struct e1000_option opt = {

   302

			.type = range_option,

   303

			.name = "Transmit Descriptors",

   304

			.err  = "using default of "

   305

				__MODULE_STRING(E1000_DEFAULT_TXD),

   306

			.def  = E1000_DEFAULT_TXD,

   307

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

   308

		};

   309

		struct e1000_desc_ring *tx_ring = &adapter->tx_ring;

   310

		e1000_mac_type mac_type = adapter->hw.mac_type;

   311

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

   312

			E1000_MAX_TXD : E1000_MAX_82544_TXD;

   313

   314

		if (num_TxDescriptors > bd) {

   315

			tx_ring->count = TxDescriptors[bd];

   316

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

   317

			E1000_ROUNDUP(tx_ring->count, 

   318

						REQ_TX_DESCRIPTOR_MULTIPLE);

   319

		} else {

   320

			tx_ring->count = opt.def;

   321

		}

   322

	}

   323

	{ /* Receive Descriptor Count */

   324

		struct e1000_option opt = {

   325

			.type = range_option,

   326

			.name = "Receive Descriptors",

   327

			.err  = "using default of "

   328

				__MODULE_STRING(E1000_DEFAULT_RXD),

   329

			.def  = E1000_DEFAULT_RXD,

   330

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

   331

		};

   332

		struct e1000_desc_ring *rx_ring = &adapter->rx_ring;

   333

		e1000_mac_type mac_type = adapter->hw.mac_type;

   334

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

   335

			E1000_MAX_82544_RXD;

   336

   337

		if (num_RxDescriptors > bd) {

   338

			rx_ring->count = RxDescriptors[bd];

   339

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

   340

			E1000_ROUNDUP(rx_ring->count, 

   341

						REQ_RX_DESCRIPTOR_MULTIPLE);

   342

		} else {

   343

			rx_ring->count = opt.def;

   344

		}

   345

	}

   346

	{ /* Checksum Offload Enable/Disable */

   347

		struct e1000_option opt = {

   348

			.type = enable_option,

   349

			.name = "Checksum Offload",

   350

			.err  = "defaulting to Enabled",

   351

			.def  = OPTION_ENABLED

   352

		};

   353

   354

		if (num_XsumRX > bd) {

   355

			int rx_csum = XsumRX[bd];

   356

			e1000_validate_option(&rx_csum, &opt, adapter);

   357

			adapter->rx_csum = rx_csum;

   358

		} else {

   359

			adapter->rx_csum = opt.def;

   360

		}

   361

	}

   362

	{ /* Flow Control */

   363

   364

		struct e1000_opt_list fc_list[] =

   365

			{{ e1000_fc_none,    "Flow Control Disabled" },

   366

			 { e1000_fc_rx_pause,"Flow Control Receive Only" },

   367

			 { e1000_fc_tx_pause,"Flow Control Transmit Only" },

   368

			 { e1000_fc_full,    "Flow Control Enabled" },

   369

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

   370

   371

		struct e1000_option opt = {

   372

			.type = list_option,

   373

			.name = "Flow Control",

   374

			.err  = "reading default settings from EEPROM",

   375

			.def  = e1000_fc_default,

   376

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

   377

					 .p = fc_list }}

   378

		};

   379

   380

		if (num_FlowControl > bd) {

   381

			int fc = FlowControl[bd];

   382

			e1000_validate_option(&fc, &opt, adapter);

   383

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

   384

		} else {

   385

			adapter->hw.fc = opt.def;

   386

		}

   387

	}

   388

	{ /* Transmit Interrupt Delay */

   389

		struct e1000_option opt = {

   390

			.type = range_option,

   391

			.name = "Transmit Interrupt Delay",

   392

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

   393

			.def  = DEFAULT_TIDV,

   394

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

   395

					 .max = MAX_TXDELAY }}

   396

		};

   397

   398

		if (num_TxIntDelay > bd) {

   399

			adapter->tx_int_delay = TxIntDelay[bd];

   400

			e1000_validate_option(&adapter->tx_int_delay, &opt, 

   401

								adapter);

   402

		} else {

   403

			adapter->tx_int_delay = opt.def;

   404

		}

   405

	}

   406

	{ /* Transmit Absolute Interrupt Delay */

   407

		struct e1000_option opt = {

   408

			.type = range_option,

   409

			.name = "Transmit Absolute Interrupt Delay",

   410

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

   411

			.def  = DEFAULT_TADV,

   412

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

   413

					 .max = MAX_TXABSDELAY }}

   414

		};

   415

   416

		if (num_TxAbsIntDelay > bd) {

   417

			adapter->tx_abs_int_delay = TxAbsIntDelay[bd];

   418

			e1000_validate_option(&adapter->tx_abs_int_delay, &opt, 

   419

								adapter);

   420

		} else {

   421

			adapter->tx_abs_int_delay = opt.def;

   422

		}

   423

	}

   424

	{ /* Receive Interrupt Delay */

   425

		struct e1000_option opt = {

   426

			.type = range_option,

   427

			.name = "Receive Interrupt Delay",

   428

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

   429

			.def  = DEFAULT_RDTR,

   430

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

   431

					 .max = MAX_RXDELAY }}

   432

		};

   433

   434

		if (num_RxIntDelay > bd) {

   435

			adapter->rx_int_delay = RxIntDelay[bd];

   436

			e1000_validate_option(&adapter->rx_int_delay, &opt, 

   437

								adapter);

   438

		} else {

   439

			adapter->rx_int_delay = opt.def;

   440

		}

   441

	}

   442

	{ /* Receive Absolute Interrupt Delay */

   443

		struct e1000_option opt = {

   444

			.type = range_option,

   445

			.name = "Receive Absolute Interrupt Delay",

   446

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

   447

			.def  = DEFAULT_RADV,

   448

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

   449

					 .max = MAX_RXABSDELAY }}

   450

		};

   451

   452

		if (num_RxAbsIntDelay > bd) {

   453

			adapter->rx_abs_int_delay = RxAbsIntDelay[bd];

   454

			e1000_validate_option(&adapter->rx_abs_int_delay, &opt, 

   455

								adapter);

   456

		} else {

   457

			adapter->rx_abs_int_delay = opt.def;

   458

		}

   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

		if (num_InterruptThrottleRate > bd) {

   471

			adapter->itr = InterruptThrottleRate[bd];

   472

			switch(adapter->itr) {

   473

			case 0:

   474

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

   475

					opt.name);

   476

				break;

   477

			case 1:

   478

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

   479

					opt.name);

   480

				break;

   481

			default:

   482

				e1000_validate_option(&adapter->itr, &opt, 

   483

					adapter);

   484

				break;

   485

			}

   486

		} else {

   487

			adapter->itr = opt.def;

   488

		}

   489

	}

   490

   491

	switch(adapter->hw.media_type) {

   492

	case e1000_media_type_fiber:

   493

	case e1000_media_type_internal_serdes:

   494

		e1000_check_fiber_options(adapter);

   495

		break;

   496

	case e1000_media_type_copper:

   497

		e1000_check_copper_options(adapter);

   498

		break;

   499

	default:

   500

		BUG();

   501

	}

   502

}

   503

   504

/**

   505

 * e1000_check_fiber_options - Range Checking for Link Options, Fiber Version

   506

 * @adapter: board private structure

   507

 *

   508

 * Handles speed and duplex options on fiber adapters

   509

 **/

   510

   511

static void __devinit

   512

e1000_check_fiber_options(struct e1000_adapter *adapter)

   513

{

   514

	int bd = adapter->bd_number;

   515

	if(num_Speed > bd) {

   516

		DPRINTK(PROBE, INFO, "Speed not valid for fiber adapters, "

   517

		       "parameter ignored\n");

   518

	}

   519

   520

	if(num_Duplex > bd) {

   521

		DPRINTK(PROBE, INFO, "Duplex not valid for fiber adapters, "

   522

		       "parameter ignored\n");

   523

	}

   524

   525

	if((num_AutoNeg > bd) && (AutoNeg[bd] != 0x20)) {

   526

		DPRINTK(PROBE, INFO, "AutoNeg other than 1000/Full is "

   527

				 "not valid for fiber adapters, "

   528

				 "parameter ignored\n");

   529

	}

   530

}