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 			const struct e1000_opt_list { int i; char *str; } *p;

   212 		} l;

   213 	} arg;

   214 };

   215 

   216 static int __devinit e1000_validate_option(unsigned int *value,

   217 					   const struct e1000_option *opt,

   218 					   struct e1000_adapter *adapter)

   219 {

   220 	if (*value == OPTION_UNSET) {

   221 		*value = opt->def;

   222 		return 0;

   223 	}

   224 

   225 	switch (opt->type) {

   226 	case enable_option:

   227 		switch (*value) {

   228 		case OPTION_ENABLED:

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

   230 			return 0;

   231 		case OPTION_DISABLED:

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

   233 			return 0;

   234 		}

   235 		break;

   236 	case range_option:

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

   238 			DPRINTK(PROBE, INFO,

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

   240 			return 0;

   241 		}

   242 		break;

   243 	case list_option: {

   244 		int i;

   245 		const struct e1000_opt_list *ent;

   246 

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

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

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

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

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

   252 				return 0;

   253 			}

   254 		}

   255 	}

   256 		break;

   257 	default:

   258 		BUG();

   259 	}

   260 

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

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

   263 	*value = opt->def;

   264 	return -1;

   265 }

   266 

   267 static void e1000_check_fiber_options(struct e1000_adapter *adapter);

   268 static void e1000_check_copper_options(struct e1000_adapter *adapter);

   269 

   270 /**

   271  * e1000_check_options - Range Checking for Command Line Parameters

   272  * @adapter: board private structure

   273  *

   274  * This routine checks all command line parameters for valid user

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

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

   277  * in a variable in the adapter structure.

   278  **/

   279 

   280 void __devinit e1000_check_options(struct e1000_adapter *adapter)

   281 {

   282 	struct e1000_option opt;

   283 	int bd = adapter->bd_number;

   284 

   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_tx_ring *tx_ring = adapter->tx_ring;

   293 		int i;

   294 		e1000_mac_type mac_type = adapter->hw.mac_type;

   295 

   296 		opt = (struct e1000_option) {

   297 			.type = range_option,

   298 			.name = "Transmit Descriptors",

   299 			.err  = "using default of "

   300 				__MODULE_STRING(E1000_DEFAULT_TXD),

   301 			.def  = E1000_DEFAULT_TXD,

   302 			.arg  = { .r = {

   303 				.min = E1000_MIN_TXD,

   304 				.max = mac_type < e1000_82544 ? E1000_MAX_TXD : E1000_MAX_82544_TXD

   305 				}}

   306 		};

   307 

   308 		if (num_TxDescriptors > bd) {

   309 			tx_ring->count = TxDescriptors[bd];

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

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

   312 						REQ_TX_DESCRIPTOR_MULTIPLE);

   313 		} else {

   314 			tx_ring->count = opt.def;

   315 		}

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

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

   318 	}

   319 	{ /* Receive Descriptor Count */

   320 		struct e1000_rx_ring *rx_ring = adapter->rx_ring;

   321 		int i;

   322 		e1000_mac_type mac_type = adapter->hw.mac_type;

   323 

   324 		opt = (struct e1000_option) {

   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 = {

   331 				.min = E1000_MIN_RXD,

   332 				.max = mac_type < e1000_82544 ? E1000_MAX_RXD : E1000_MAX_82544_RXD

   333 			}}

   334 		};

   335 

   336 		if (num_RxDescriptors > bd) {

   337 			rx_ring->count = RxDescriptors[bd];

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

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

   340 						REQ_RX_DESCRIPTOR_MULTIPLE);

   341 		} else {

   342 			rx_ring->count = opt.def;

   343 		}

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

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

   346 	}

   347 	{ /* Checksum Offload Enable/Disable */

   348 		opt = (struct e1000_option) {

   349 			.type = enable_option,

   350 			.name = "Checksum Offload",

   351 			.err  = "defaulting to Enabled",

   352 			.def  = OPTION_ENABLED

   353 		};

   354 

   355 		if (num_XsumRX > bd) {

   356 			unsigned int rx_csum = XsumRX[bd];

   357 			e1000_validate_option(&rx_csum, &opt, adapter);

   358 			adapter->rx_csum = rx_csum;

   359 		} else {

   360 			adapter->rx_csum = opt.def;

   361 		}

   362 	}

   363 	{ /* Flow Control */

   364 

   365 		struct e1000_opt_list fc_list[] =

   366 			{{ E1000_FC_NONE,    "Flow Control Disabled" },

   367 			 { E1000_FC_RX_PAUSE,"Flow Control Receive Only" },

   368 			 { E1000_FC_TX_PAUSE,"Flow Control Transmit Only" },

   369 			 { E1000_FC_FULL,    "Flow Control Enabled" },

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

   371 

   372 		opt = (struct e1000_option) {

   373 			.type = list_option,

   374 			.name = "Flow Control",

   375 			.err  = "reading default settings from EEPROM",

   376 			.def  = E1000_FC_DEFAULT,

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

   378 					 .p = fc_list }}

   379 		};

   380 

   381 		if (num_FlowControl > bd) {

   382 			unsigned int fc = FlowControl[bd];

   383 			e1000_validate_option(&fc, &opt, adapter);

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

   385 		} else {

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

   387 		}

   388 	}

   389 	{ /* Transmit Interrupt Delay */

   390 		opt = (struct e1000_option) {

   391 			.type = range_option,

   392 			.name = "Transmit Interrupt Delay",

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

   394 			.def  = DEFAULT_TIDV,

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

   396 					 .max = MAX_TXDELAY }}

   397 		};

   398 

   399 		if (num_TxIntDelay > bd) {

   400 			adapter->tx_int_delay = TxIntDelay[bd];

   401 			e1000_validate_option(&adapter->tx_int_delay, &opt,

   402 			                      adapter);

   403 		} else {

   404 			adapter->tx_int_delay = opt.def;

   405 		}

   406 	}

   407 	{ /* Transmit Absolute Interrupt Delay */

   408 		opt = (struct e1000_option) {

   409 			.type = range_option,

   410 			.name = "Transmit Absolute Interrupt Delay",

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

   412 			.def  = DEFAULT_TADV,

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

   414 					 .max = MAX_TXABSDELAY }}

   415 		};

   416 

   417 		if (num_TxAbsIntDelay > bd) {

   418 			adapter->tx_abs_int_delay = TxAbsIntDelay[bd];

   419 			e1000_validate_option(&adapter->tx_abs_int_delay, &opt,

   420 			                      adapter);

   421 		} else {

   422 			adapter->tx_abs_int_delay = opt.def;

   423 		}

   424 	}

   425 	{ /* Receive Interrupt Delay */

   426 		opt = (struct e1000_option) {

   427 			.type = range_option,

   428 			.name = "Receive Interrupt Delay",

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

   430 			.def  = DEFAULT_RDTR,

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

   432 					 .max = MAX_RXDELAY }}

   433 		};

   434 

   435 		if (num_RxIntDelay > bd) {

   436 			adapter->rx_int_delay = RxIntDelay[bd];

   437 			e1000_validate_option(&adapter->rx_int_delay, &opt,

   438 			                      adapter);

   439 		} else {

   440 			adapter->rx_int_delay = opt.def;

   441 		}

   442 	}

   443 	{ /* Receive Absolute Interrupt Delay */

   444 		opt = (struct e1000_option) {

   445 			.type = range_option,

   446 			.name = "Receive Absolute Interrupt Delay",

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

   448 			.def  = DEFAULT_RADV,

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

   450 					 .max = MAX_RXABSDELAY }}

   451 		};

   452 

   453 		if (num_RxAbsIntDelay > bd) {

   454 			adapter->rx_abs_int_delay = RxAbsIntDelay[bd];

   455 			e1000_validate_option(&adapter->rx_abs_int_delay, &opt,

   456 			                      adapter);

   457 		} else {

   458 			adapter->rx_abs_int_delay = opt.def;

   459 		}

   460 	}

   461 	{ /* Interrupt Throttling Rate */

   462 		opt = (struct e1000_option) {

   463 			.type = range_option,

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

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

   466 			.def  = DEFAULT_ITR,

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

   468 					 .max = MAX_ITR }}

   469 		};

   470 

   471 		if (num_InterruptThrottleRate > bd) {

   472 			adapter->itr = InterruptThrottleRate[bd];

   473 			switch (adapter->itr) {

   474 			case 0:

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

   476 				        opt.name);

   477 				break;

   478 			case 1:

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

   480 					opt.name);

   481 				adapter->itr_setting = adapter->itr;

   482 				adapter->itr = 20000;

   483 				break;

   484 			case 3:

   485 				DPRINTK(PROBE, INFO,

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

   487 					opt.name);

   488 				adapter->itr_setting = adapter->itr;

   489 				adapter->itr = 20000;

   490 				break;

   491 			default:

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

   493 				        adapter);

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

   495 				/* clear the lower two bits because they are

   496 				 * used as control */

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

   498 				break;

   499 			}

   500 		} else {

   501 			adapter->itr_setting = opt.def;

   502 			adapter->itr = 20000;

   503 		}

   504 	}

   505 	{ /* Smart Power Down */

   506 		opt = (struct e1000_option) {

   507 			.type = enable_option,

   508 			.name = "PHY Smart Power Down",

   509 			.err  = "defaulting to Disabled",

   510 			.def  = OPTION_DISABLED

   511 		};

   512 

   513 		if (num_SmartPowerDownEnable > bd) {

   514 			unsigned int spd = SmartPowerDownEnable[bd];

   515 			e1000_validate_option(&spd, &opt, adapter);

   516 			adapter->smart_power_down = spd;

   517 		} else {

   518 			adapter->smart_power_down = opt.def;

   519 		}

   520 	}

   521 	{ /* Kumeran Lock Loss Workaround */

   522 		opt = (struct e1000_option) {

   523 			.type = enable_option,

   524 			.name = "Kumeran Lock Loss Workaround",

   525 			.err  = "defaulting to Enabled",

   526 			.def  = OPTION_ENABLED

   527 		};

   528 

   529 		if (num_KumeranLockLoss > bd) {

   530 			unsigned int kmrn_lock_loss = KumeranLockLoss[bd];

   531 			e1000_validate_option(&kmrn_lock_loss, &opt, adapter);

   532 			adapter->hw.kmrn_lock_loss_workaround_disabled = !kmrn_lock_loss;

   533 		} else {

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

   535 		}

   536 	}

   537 

   538 	switch (adapter->hw.media_type) {

   539 	case e1000_media_type_fiber:

   540 	case e1000_media_type_internal_serdes:

   541 		e1000_check_fiber_options(adapter);

   542 		break;

   543 	case e1000_media_type_copper:

   544 		e1000_check_copper_options(adapter);

   545 		break;

   546 	default:

   547 		BUG();

   548 	}

   549 }

   550 

   551 /**

   552  * e1000_check_fiber_options - Range Checking for Link Options, Fiber Version

   553  * @adapter: board private structure

   554  *

   555  * Handles speed and duplex options on fiber adapters

   556  **/

   557 

   558 static void __devinit e1000_check_fiber_options(struct e1000_adapter *adapter)

   559 {

   560 	int bd = adapter->bd_number;

   561 	if (num_Speed > bd) {

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

   563 		       "parameter ignored\n");

   564 	}

   565 

   566 	if (num_Duplex > bd) {

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

   568 		       "parameter ignored\n");

   569 	}

   570 

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

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

   573 				 "not valid for fiber adapters, "

   574 				 "parameter ignored\n");

   575 	}

   576 }

   577 

   578 /**

   579  * e1000_check_copper_options - Range Checking for Link Options, Copper Version

   580  * @adapter: board private structure

   581  *

   582  * Handles speed and duplex options on copper adapters

   583  **/

   584 

   585 static void __devinit e1000_check_copper_options(struct e1000_adapter *adapter)

   586 {

   587 	struct e1000_option opt;

   588 	unsigned int speed, dplx, an;

   589 	int bd = adapter->bd_number;

   590 

   591 	{ /* Speed */

   592 		static const struct e1000_opt_list speed_list[] = {

   593 			{          0, "" },

   594 			{   SPEED_10, "" },

   595 			{  SPEED_100, "" },

   596 			{ SPEED_1000, "" }};

   597 

   598 		opt = (struct e1000_option) {

   599 			.type = list_option,

   600 			.name = "Speed",

   601 			.err  = "parameter ignored",

   602 			.def  = 0,

   603 			.arg  = { .l = { .nr = ARRAY_SIZE(speed_list),

   604 					 .p = speed_list }}

   605 		};

   606 

   607 		if (num_Speed > bd) {

   608 			speed = Speed[bd];

   609 			e1000_validate_option(&speed, &opt, adapter);

   610 		} else {

   611 			speed = opt.def;

   612 		}

   613 	}

   614 	{ /* Duplex */

   615 		static const struct e1000_opt_list dplx_list[] = {

   616 			{           0, "" },

   617 			{ HALF_DUPLEX, "" },

   618 			{ FULL_DUPLEX, "" }};

   619 

   620 		opt = (struct e1000_option) {

   621 			.type = list_option,

   622 			.name = "Duplex",

   623 			.err  = "parameter ignored",

   624 			.def  = 0,

   625 			.arg  = { .l = { .nr = ARRAY_SIZE(dplx_list),

   626 					 .p = dplx_list }}

   627 		};

   628 

   629 		if (e1000_check_phy_reset_block(&adapter->hw)) {

   630 			DPRINTK(PROBE, INFO,

   631 				"Link active due to SoL/IDER Session. "

   632 			        "Speed/Duplex/AutoNeg parameter ignored.\n");

   633 			return;

   634 		}

   635 		if (num_Duplex > bd) {

   636 			dplx = Duplex[bd];

   637 			e1000_validate_option(&dplx, &opt, adapter);

   638 		} else {

   639 			dplx = opt.def;

   640 		}

   641 	}

   642 

   643 	if ((num_AutoNeg > bd) && (speed != 0 || dplx != 0)) {

   644 		DPRINTK(PROBE, INFO,

   645 		       "AutoNeg specified along with Speed or Duplex, "

   646 		       "parameter ignored\n");

   647 		adapter->hw.autoneg_advertised = AUTONEG_ADV_DEFAULT;

   648 	} else { /* Autoneg */

   649 		static const struct e1000_opt_list an_list[] =

   650 			#define AA "AutoNeg advertising "

   651 			{{ 0x01, AA "10/HD" },

   652 			 { 0x02, AA "10/FD" },

   653 			 { 0x03, AA "10/FD, 10/HD" },

   654 			 { 0x04, AA "100/HD" },

   655 			 { 0x05, AA "100/HD, 10/HD" },

   656 			 { 0x06, AA "100/HD, 10/FD" },

   657 			 { 0x07, AA "100/HD, 10/FD, 10/HD" },

   658 			 { 0x08, AA "100/FD" },

   659 			 { 0x09, AA "100/FD, 10/HD" },

   660 			 { 0x0a, AA "100/FD, 10/FD" },

   661 			 { 0x0b, AA "100/FD, 10/FD, 10/HD" },

   662 			 { 0x0c, AA "100/FD, 100/HD" },

   663 			 { 0x0d, AA "100/FD, 100/HD, 10/HD" },

   664 			 { 0x0e, AA "100/FD, 100/HD, 10/FD" },

   665 			 { 0x0f, AA "100/FD, 100/HD, 10/FD, 10/HD" },

   666 			 { 0x20, AA "1000/FD" },

   667 			 { 0x21, AA "1000/FD, 10/HD" },

   668 			 { 0x22, AA "1000/FD, 10/FD" },

   669 			 { 0x23, AA "1000/FD, 10/FD, 10/HD" },

   670 			 { 0x24, AA "1000/FD, 100/HD" },

   671 			 { 0x25, AA "1000/FD, 100/HD, 10/HD" },

   672 			 { 0x26, AA "1000/FD, 100/HD, 10/FD" },

   673 			 { 0x27, AA "1000/FD, 100/HD, 10/FD, 10/HD" },

   674 			 { 0x28, AA "1000/FD, 100/FD" },

   675 			 { 0x29, AA "1000/FD, 100/FD, 10/HD" },

   676 			 { 0x2a, AA "1000/FD, 100/FD, 10/FD" },

   677 			 { 0x2b, AA "1000/FD, 100/FD, 10/FD, 10/HD" },

   678 			 { 0x2c, AA "1000/FD, 100/FD, 100/HD" },

   679 			 { 0x2d, AA "1000/FD, 100/FD, 100/HD, 10/HD" },

   680 			 { 0x2e, AA "1000/FD, 100/FD, 100/HD, 10/FD" },

   681 			 { 0x2f, AA "1000/FD, 100/FD, 100/HD, 10/FD, 10/HD" }};

   682 

   683 		opt = (struct e1000_option) {

   684 			.type = list_option,

   685 			.name = "AutoNeg",

   686 			.err  = "parameter ignored",

   687 			.def  = AUTONEG_ADV_DEFAULT,

   688 			.arg  = { .l = { .nr = ARRAY_SIZE(an_list),

   689 					 .p = an_list }}

   690 		};

   691 

   692 		if (num_AutoNeg > bd) {

   693 			an = AutoNeg[bd];

   694 			e1000_validate_option(&an, &opt, adapter);

   695 		} else {

   696 			an = opt.def;

   697 		}

   698 		adapter->hw.autoneg_advertised = an;

   699 	}

   700 

   701 	switch (speed + dplx) {

   702 	case 0:

   703 		adapter->hw.autoneg = adapter->fc_autoneg = 1;

   704 		if ((num_Speed > bd) && (speed != 0 || dplx != 0))

   705 			DPRINTK(PROBE, INFO,

   706 			       "Speed and duplex autonegotiation enabled\n");

   707 		break;

   708 	case HALF_DUPLEX:

   709 		DPRINTK(PROBE, INFO, "Half Duplex specified without Speed\n");

   710 		DPRINTK(PROBE, INFO, "Using Autonegotiation at "

   711 			"Half Duplex only\n");

   712 		adapter->hw.autoneg = adapter->fc_autoneg = 1;

   713 		adapter->hw.autoneg_advertised = ADVERTISE_10_HALF |

   714 		                                 ADVERTISE_100_HALF;

   715 		break;

   716 	case FULL_DUPLEX:

   717 		DPRINTK(PROBE, INFO, "Full Duplex specified without Speed\n");

   718 		DPRINTK(PROBE, INFO, "Using Autonegotiation at "

   719 			"Full Duplex only\n");

   720 		adapter->hw.autoneg = adapter->fc_autoneg = 1;

   721 		adapter->hw.autoneg_advertised = ADVERTISE_10_FULL |

   722 		                                 ADVERTISE_100_FULL |

   723 		                                 ADVERTISE_1000_FULL;

   724 		break;

   725 	case SPEED_10:

   726 		DPRINTK(PROBE, INFO, "10 Mbps Speed specified "

   727 			"without Duplex\n");

   728 		DPRINTK(PROBE, INFO, "Using Autonegotiation at 10 Mbps only\n");

   729 		adapter->hw.autoneg = adapter->fc_autoneg = 1;

   730 		adapter->hw.autoneg_advertised = ADVERTISE_10_HALF |

   731 		                                 ADVERTISE_10_FULL;

   732 		break;

   733 	case SPEED_10 + HALF_DUPLEX:

   734 		DPRINTK(PROBE, INFO, "Forcing to 10 Mbps Half Duplex\n");

   735 		adapter->hw.autoneg = adapter->fc_autoneg = 0;

   736 		adapter->hw.forced_speed_duplex = e1000_10_half;

   737 		adapter->hw.autoneg_advertised = 0;

   738 		break;

   739 	case SPEED_10 + FULL_DUPLEX:

   740 		DPRINTK(PROBE, INFO, "Forcing to 10 Mbps Full Duplex\n");

   741 		adapter->hw.autoneg = adapter->fc_autoneg = 0;

   742 		adapter->hw.forced_speed_duplex = e1000_10_full;

   743 		adapter->hw.autoneg_advertised = 0;

   744 		break;

   745 	case SPEED_100:

   746 		DPRINTK(PROBE, INFO, "100 Mbps Speed specified "

   747 			"without Duplex\n");

   748 		DPRINTK(PROBE, INFO, "Using Autonegotiation at "

   749 			"100 Mbps only\n");

   750 		adapter->hw.autoneg = adapter->fc_autoneg = 1;

   751 		adapter->hw.autoneg_advertised = ADVERTISE_100_HALF |

   752 		                                 ADVERTISE_100_FULL;

   753 		break;

   754 	case SPEED_100 + HALF_DUPLEX:

   755 		DPRINTK(PROBE, INFO, "Forcing to 100 Mbps Half Duplex\n");

   756 		adapter->hw.autoneg = adapter->fc_autoneg = 0;

   757 		adapter->hw.forced_speed_duplex = e1000_100_half;

   758 		adapter->hw.autoneg_advertised = 0;

   759 		break;

   760 	case SPEED_100 + FULL_DUPLEX:

   761 		DPRINTK(PROBE, INFO, "Forcing to 100 Mbps Full Duplex\n");

   762 		adapter->hw.autoneg = adapter->fc_autoneg = 0;

   763 		adapter->hw.forced_speed_duplex = e1000_100_full;

   764 		adapter->hw.autoneg_advertised = 0;

   765 		break;

   766 	case SPEED_1000:

   767 		DPRINTK(PROBE, INFO, "1000 Mbps Speed specified without "

   768 			"Duplex\n");

   769 		goto full_duplex_only;

   770 	case SPEED_1000 + HALF_DUPLEX:

   771 		DPRINTK(PROBE, INFO,

   772 			"Half Duplex is not supported at 1000 Mbps\n");

   773 		/* fall through */

   774 	case SPEED_1000 + FULL_DUPLEX:

   775 full_duplex_only:

   776 		DPRINTK(PROBE, INFO,

   777 		       "Using Autonegotiation at 1000 Mbps Full Duplex only\n");

   778 		adapter->hw.autoneg = adapter->fc_autoneg = 1;

   779 		adapter->hw.autoneg_advertised = ADVERTISE_1000_FULL;

   780 		break;

   781 	default:

   782 		BUG();

   783 	}

   784 

   785 	/* Speed, AutoNeg and MDI/MDI-X must all play nice */

   786 	if (e1000_validate_mdi_setting(&(adapter->hw)) < 0) {

   787 		DPRINTK(PROBE, INFO,

   788 			"Speed, AutoNeg and MDI-X specifications are "

   789 			"incompatible. Setting MDI-X to a compatible value.\n");

   790 	}

   791 }

   792