devices/e1000/e1000_param-2.6.31-ethercat.c
changeset 2060 8b67602f5161
parent 1996 852668fdae6a
equal deleted inserted replaced
2059:ab0b96ac18bb 2060:8b67602f5161
       
     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-2.6.31-ethercat.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