devices/e1000/e1000_param-2.6.37-orig.c
changeset 2173 312ab8ed8284
equal deleted inserted replaced
2172:eb925f2b1ce9 2173:312ab8ed8284
       
     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 struct e1000_option {
       
   192 	enum { enable_option, range_option, list_option } type;
       
   193 	const char *name;
       
   194 	const char *err;
       
   195 	int def;
       
   196 	union {
       
   197 		struct { /* range_option info */
       
   198 			int min;
       
   199 			int max;
       
   200 		} r;
       
   201 		struct { /* list_option info */
       
   202 			int nr;
       
   203 			const struct e1000_opt_list { int i; char *str; } *p;
       
   204 		} l;
       
   205 	} arg;
       
   206 };
       
   207 
       
   208 static int __devinit e1000_validate_option(unsigned int *value,
       
   209 					   const struct e1000_option *opt,
       
   210 					   struct e1000_adapter *adapter)
       
   211 {
       
   212 	if (*value == OPTION_UNSET) {
       
   213 		*value = opt->def;
       
   214 		return 0;
       
   215 	}
       
   216 
       
   217 	switch (opt->type) {
       
   218 	case enable_option:
       
   219 		switch (*value) {
       
   220 		case OPTION_ENABLED:
       
   221 			e_dev_info("%s Enabled\n", opt->name);
       
   222 			return 0;
       
   223 		case OPTION_DISABLED:
       
   224 			e_dev_info("%s Disabled\n", opt->name);
       
   225 			return 0;
       
   226 		}
       
   227 		break;
       
   228 	case range_option:
       
   229 		if (*value >= opt->arg.r.min && *value <= opt->arg.r.max) {
       
   230 			e_dev_info("%s set to %i\n", opt->name, *value);
       
   231 			return 0;
       
   232 		}
       
   233 		break;
       
   234 	case list_option: {
       
   235 		int i;
       
   236 		const struct e1000_opt_list *ent;
       
   237 
       
   238 		for (i = 0; i < opt->arg.l.nr; i++) {
       
   239 			ent = &opt->arg.l.p[i];
       
   240 			if (*value == ent->i) {
       
   241 				if (ent->str[0] != '\0')
       
   242 					e_dev_info("%s\n", ent->str);
       
   243 				return 0;
       
   244 			}
       
   245 		}
       
   246 	}
       
   247 		break;
       
   248 	default:
       
   249 		BUG();
       
   250 	}
       
   251 
       
   252 	e_dev_info("Invalid %s value specified (%i) %s\n",
       
   253 	       opt->name, *value, opt->err);
       
   254 	*value = opt->def;
       
   255 	return -1;
       
   256 }
       
   257 
       
   258 static void e1000_check_fiber_options(struct e1000_adapter *adapter);
       
   259 static void e1000_check_copper_options(struct e1000_adapter *adapter);
       
   260 
       
   261 /**
       
   262  * e1000_check_options - Range Checking for Command Line Parameters
       
   263  * @adapter: board private structure
       
   264  *
       
   265  * This routine checks all command line parameters for valid user
       
   266  * input.  If an invalid value is given, or if no user specified
       
   267  * value exists, a default value is used.  The final value is stored
       
   268  * in a variable in the adapter structure.
       
   269  **/
       
   270 
       
   271 void __devinit e1000_check_options(struct e1000_adapter *adapter)
       
   272 {
       
   273 	struct e1000_option opt;
       
   274 	int bd = adapter->bd_number;
       
   275 
       
   276 	if (bd >= E1000_MAX_NIC) {
       
   277 		e_dev_warn("Warning: no configuration for board #%i "
       
   278 			   "using defaults for all values\n", bd);
       
   279 	}
       
   280 
       
   281 	{ /* Transmit Descriptor Count */
       
   282 		struct e1000_tx_ring *tx_ring = adapter->tx_ring;
       
   283 		int i;
       
   284 		e1000_mac_type mac_type = adapter->hw.mac_type;
       
   285 
       
   286 		opt = (struct e1000_option) {
       
   287 			.type = range_option,
       
   288 			.name = "Transmit Descriptors",
       
   289 			.err  = "using default of "
       
   290 				__MODULE_STRING(E1000_DEFAULT_TXD),
       
   291 			.def  = E1000_DEFAULT_TXD,
       
   292 			.arg  = { .r = {
       
   293 				.min = E1000_MIN_TXD,
       
   294 				.max = mac_type < e1000_82544 ? E1000_MAX_TXD : E1000_MAX_82544_TXD
       
   295 				}}
       
   296 		};
       
   297 
       
   298 		if (num_TxDescriptors > bd) {
       
   299 			tx_ring->count = TxDescriptors[bd];
       
   300 			e1000_validate_option(&tx_ring->count, &opt, adapter);
       
   301 			tx_ring->count = ALIGN(tx_ring->count,
       
   302 						REQ_TX_DESCRIPTOR_MULTIPLE);
       
   303 		} else {
       
   304 			tx_ring->count = opt.def;
       
   305 		}
       
   306 		for (i = 0; i < adapter->num_tx_queues; i++)
       
   307 			tx_ring[i].count = tx_ring->count;
       
   308 	}
       
   309 	{ /* Receive Descriptor Count */
       
   310 		struct e1000_rx_ring *rx_ring = adapter->rx_ring;
       
   311 		int i;
       
   312 		e1000_mac_type mac_type = adapter->hw.mac_type;
       
   313 
       
   314 		opt = (struct e1000_option) {
       
   315 			.type = range_option,
       
   316 			.name = "Receive Descriptors",
       
   317 			.err  = "using default of "
       
   318 				__MODULE_STRING(E1000_DEFAULT_RXD),
       
   319 			.def  = E1000_DEFAULT_RXD,
       
   320 			.arg  = { .r = {
       
   321 				.min = E1000_MIN_RXD,
       
   322 				.max = mac_type < e1000_82544 ? E1000_MAX_RXD : E1000_MAX_82544_RXD
       
   323 			}}
       
   324 		};
       
   325 
       
   326 		if (num_RxDescriptors > bd) {
       
   327 			rx_ring->count = RxDescriptors[bd];
       
   328 			e1000_validate_option(&rx_ring->count, &opt, adapter);
       
   329 			rx_ring->count = ALIGN(rx_ring->count,
       
   330 						REQ_RX_DESCRIPTOR_MULTIPLE);
       
   331 		} else {
       
   332 			rx_ring->count = opt.def;
       
   333 		}
       
   334 		for (i = 0; i < adapter->num_rx_queues; i++)
       
   335 			rx_ring[i].count = rx_ring->count;
       
   336 	}
       
   337 	{ /* Checksum Offload Enable/Disable */
       
   338 		opt = (struct e1000_option) {
       
   339 			.type = enable_option,
       
   340 			.name = "Checksum Offload",
       
   341 			.err  = "defaulting to Enabled",
       
   342 			.def  = OPTION_ENABLED
       
   343 		};
       
   344 
       
   345 		if (num_XsumRX > bd) {
       
   346 			unsigned int rx_csum = XsumRX[bd];
       
   347 			e1000_validate_option(&rx_csum, &opt, adapter);
       
   348 			adapter->rx_csum = rx_csum;
       
   349 		} else {
       
   350 			adapter->rx_csum = opt.def;
       
   351 		}
       
   352 	}
       
   353 	{ /* Flow Control */
       
   354 
       
   355 		struct e1000_opt_list fc_list[] =
       
   356 			{{ E1000_FC_NONE,    "Flow Control Disabled" },
       
   357 			 { E1000_FC_RX_PAUSE,"Flow Control Receive Only" },
       
   358 			 { E1000_FC_TX_PAUSE,"Flow Control Transmit Only" },
       
   359 			 { E1000_FC_FULL,    "Flow Control Enabled" },
       
   360 			 { E1000_FC_DEFAULT, "Flow Control Hardware Default" }};
       
   361 
       
   362 		opt = (struct e1000_option) {
       
   363 			.type = list_option,
       
   364 			.name = "Flow Control",
       
   365 			.err  = "reading default settings from EEPROM",
       
   366 			.def  = E1000_FC_DEFAULT,
       
   367 			.arg  = { .l = { .nr = ARRAY_SIZE(fc_list),
       
   368 					 .p = fc_list }}
       
   369 		};
       
   370 
       
   371 		if (num_FlowControl > bd) {
       
   372 			unsigned int fc = FlowControl[bd];
       
   373 			e1000_validate_option(&fc, &opt, adapter);
       
   374 			adapter->hw.fc = adapter->hw.original_fc = fc;
       
   375 		} else {
       
   376 			adapter->hw.fc = adapter->hw.original_fc = opt.def;
       
   377 		}
       
   378 	}
       
   379 	{ /* Transmit Interrupt Delay */
       
   380 		opt = (struct e1000_option) {
       
   381 			.type = range_option,
       
   382 			.name = "Transmit Interrupt Delay",
       
   383 			.err  = "using default of " __MODULE_STRING(DEFAULT_TIDV),
       
   384 			.def  = DEFAULT_TIDV,
       
   385 			.arg  = { .r = { .min = MIN_TXDELAY,
       
   386 					 .max = MAX_TXDELAY }}
       
   387 		};
       
   388 
       
   389 		if (num_TxIntDelay > bd) {
       
   390 			adapter->tx_int_delay = TxIntDelay[bd];
       
   391 			e1000_validate_option(&adapter->tx_int_delay, &opt,
       
   392 			                      adapter);
       
   393 		} else {
       
   394 			adapter->tx_int_delay = opt.def;
       
   395 		}
       
   396 	}
       
   397 	{ /* Transmit Absolute Interrupt Delay */
       
   398 		opt = (struct e1000_option) {
       
   399 			.type = range_option,
       
   400 			.name = "Transmit Absolute Interrupt Delay",
       
   401 			.err  = "using default of " __MODULE_STRING(DEFAULT_TADV),
       
   402 			.def  = DEFAULT_TADV,
       
   403 			.arg  = { .r = { .min = MIN_TXABSDELAY,
       
   404 					 .max = MAX_TXABSDELAY }}
       
   405 		};
       
   406 
       
   407 		if (num_TxAbsIntDelay > bd) {
       
   408 			adapter->tx_abs_int_delay = TxAbsIntDelay[bd];
       
   409 			e1000_validate_option(&adapter->tx_abs_int_delay, &opt,
       
   410 			                      adapter);
       
   411 		} else {
       
   412 			adapter->tx_abs_int_delay = opt.def;
       
   413 		}
       
   414 	}
       
   415 	{ /* Receive Interrupt Delay */
       
   416 		opt = (struct e1000_option) {
       
   417 			.type = range_option,
       
   418 			.name = "Receive Interrupt Delay",
       
   419 			.err  = "using default of " __MODULE_STRING(DEFAULT_RDTR),
       
   420 			.def  = DEFAULT_RDTR,
       
   421 			.arg  = { .r = { .min = MIN_RXDELAY,
       
   422 					 .max = MAX_RXDELAY }}
       
   423 		};
       
   424 
       
   425 		if (num_RxIntDelay > bd) {
       
   426 			adapter->rx_int_delay = RxIntDelay[bd];
       
   427 			e1000_validate_option(&adapter->rx_int_delay, &opt,
       
   428 			                      adapter);
       
   429 		} else {
       
   430 			adapter->rx_int_delay = opt.def;
       
   431 		}
       
   432 	}
       
   433 	{ /* Receive Absolute Interrupt Delay */
       
   434 		opt = (struct e1000_option) {
       
   435 			.type = range_option,
       
   436 			.name = "Receive Absolute Interrupt Delay",
       
   437 			.err  = "using default of " __MODULE_STRING(DEFAULT_RADV),
       
   438 			.def  = DEFAULT_RADV,
       
   439 			.arg  = { .r = { .min = MIN_RXABSDELAY,
       
   440 					 .max = MAX_RXABSDELAY }}
       
   441 		};
       
   442 
       
   443 		if (num_RxAbsIntDelay > bd) {
       
   444 			adapter->rx_abs_int_delay = RxAbsIntDelay[bd];
       
   445 			e1000_validate_option(&adapter->rx_abs_int_delay, &opt,
       
   446 			                      adapter);
       
   447 		} else {
       
   448 			adapter->rx_abs_int_delay = opt.def;
       
   449 		}
       
   450 	}
       
   451 	{ /* Interrupt Throttling Rate */
       
   452 		opt = (struct e1000_option) {
       
   453 			.type = range_option,
       
   454 			.name = "Interrupt Throttling Rate (ints/sec)",
       
   455 			.err  = "using default of " __MODULE_STRING(DEFAULT_ITR),
       
   456 			.def  = DEFAULT_ITR,
       
   457 			.arg  = { .r = { .min = MIN_ITR,
       
   458 					 .max = MAX_ITR }}
       
   459 		};
       
   460 
       
   461 		if (num_InterruptThrottleRate > bd) {
       
   462 			adapter->itr = InterruptThrottleRate[bd];
       
   463 			switch (adapter->itr) {
       
   464 			case 0:
       
   465 				e_dev_info("%s turned off\n", opt.name);
       
   466 				break;
       
   467 			case 1:
       
   468 				e_dev_info("%s set to dynamic mode\n",
       
   469 					   opt.name);
       
   470 				adapter->itr_setting = adapter->itr;
       
   471 				adapter->itr = 20000;
       
   472 				break;
       
   473 			case 3:
       
   474 				e_dev_info("%s set to dynamic conservative "
       
   475 					   "mode\n", opt.name);
       
   476 				adapter->itr_setting = adapter->itr;
       
   477 				adapter->itr = 20000;
       
   478 				break;
       
   479 			case 4:
       
   480 				e_dev_info("%s set to simplified "
       
   481 				           "(2000-8000) ints mode\n", opt.name);
       
   482 				adapter->itr_setting = adapter->itr;
       
   483 				break;
       
   484 			default:
       
   485 				e1000_validate_option(&adapter->itr, &opt,
       
   486 				        adapter);
       
   487 				/* save the setting, because the dynamic bits
       
   488 				 * change itr.
       
   489 				 * clear the lower two bits because they are
       
   490 				 * used as control */
       
   491 				adapter->itr_setting = adapter->itr & ~3;
       
   492 				break;
       
   493 			}
       
   494 		} else {
       
   495 			adapter->itr_setting = opt.def;
       
   496 			adapter->itr = 20000;
       
   497 		}
       
   498 	}
       
   499 	{ /* Smart Power Down */
       
   500 		opt = (struct e1000_option) {
       
   501 			.type = enable_option,
       
   502 			.name = "PHY Smart Power Down",
       
   503 			.err  = "defaulting to Disabled",
       
   504 			.def  = OPTION_DISABLED
       
   505 		};
       
   506 
       
   507 		if (num_SmartPowerDownEnable > bd) {
       
   508 			unsigned int spd = SmartPowerDownEnable[bd];
       
   509 			e1000_validate_option(&spd, &opt, adapter);
       
   510 			adapter->smart_power_down = spd;
       
   511 		} else {
       
   512 			adapter->smart_power_down = opt.def;
       
   513 		}
       
   514 	}
       
   515 
       
   516 	switch (adapter->hw.media_type) {
       
   517 	case e1000_media_type_fiber:
       
   518 	case e1000_media_type_internal_serdes:
       
   519 		e1000_check_fiber_options(adapter);
       
   520 		break;
       
   521 	case e1000_media_type_copper:
       
   522 		e1000_check_copper_options(adapter);
       
   523 		break;
       
   524 	default:
       
   525 		BUG();
       
   526 	}
       
   527 }
       
   528 
       
   529 /**
       
   530  * e1000_check_fiber_options - Range Checking for Link Options, Fiber Version
       
   531  * @adapter: board private structure
       
   532  *
       
   533  * Handles speed and duplex options on fiber adapters
       
   534  **/
       
   535 
       
   536 static void __devinit e1000_check_fiber_options(struct e1000_adapter *adapter)
       
   537 {
       
   538 	int bd = adapter->bd_number;
       
   539 	if (num_Speed > bd) {
       
   540 		e_dev_info("Speed not valid for fiber adapters, parameter "
       
   541 			   "ignored\n");
       
   542 	}
       
   543 
       
   544 	if (num_Duplex > bd) {
       
   545 		e_dev_info("Duplex not valid for fiber adapters, parameter "
       
   546 			   "ignored\n");
       
   547 	}
       
   548 
       
   549 	if ((num_AutoNeg > bd) && (AutoNeg[bd] != 0x20)) {
       
   550 		e_dev_info("AutoNeg other than 1000/Full is not valid for fiber"
       
   551 			   "adapters, parameter ignored\n");
       
   552 	}
       
   553 }
       
   554 
       
   555 /**
       
   556  * e1000_check_copper_options - Range Checking for Link Options, Copper Version
       
   557  * @adapter: board private structure
       
   558  *
       
   559  * Handles speed and duplex options on copper adapters
       
   560  **/
       
   561 
       
   562 static void __devinit e1000_check_copper_options(struct e1000_adapter *adapter)
       
   563 {
       
   564 	struct e1000_option opt;
       
   565 	unsigned int speed, dplx, an;
       
   566 	int bd = adapter->bd_number;
       
   567 
       
   568 	{ /* Speed */
       
   569 		static const struct e1000_opt_list speed_list[] = {
       
   570 			{          0, "" },
       
   571 			{   SPEED_10, "" },
       
   572 			{  SPEED_100, "" },
       
   573 			{ SPEED_1000, "" }};
       
   574 
       
   575 		opt = (struct e1000_option) {
       
   576 			.type = list_option,
       
   577 			.name = "Speed",
       
   578 			.err  = "parameter ignored",
       
   579 			.def  = 0,
       
   580 			.arg  = { .l = { .nr = ARRAY_SIZE(speed_list),
       
   581 					 .p = speed_list }}
       
   582 		};
       
   583 
       
   584 		if (num_Speed > bd) {
       
   585 			speed = Speed[bd];
       
   586 			e1000_validate_option(&speed, &opt, adapter);
       
   587 		} else {
       
   588 			speed = opt.def;
       
   589 		}
       
   590 	}
       
   591 	{ /* Duplex */
       
   592 		static const struct e1000_opt_list dplx_list[] = {
       
   593 			{           0, "" },
       
   594 			{ HALF_DUPLEX, "" },
       
   595 			{ FULL_DUPLEX, "" }};
       
   596 
       
   597 		opt = (struct e1000_option) {
       
   598 			.type = list_option,
       
   599 			.name = "Duplex",
       
   600 			.err  = "parameter ignored",
       
   601 			.def  = 0,
       
   602 			.arg  = { .l = { .nr = ARRAY_SIZE(dplx_list),
       
   603 					 .p = dplx_list }}
       
   604 		};
       
   605 
       
   606 		if (num_Duplex > bd) {
       
   607 			dplx = Duplex[bd];
       
   608 			e1000_validate_option(&dplx, &opt, adapter);
       
   609 		} else {
       
   610 			dplx = opt.def;
       
   611 		}
       
   612 	}
       
   613 
       
   614 	if ((num_AutoNeg > bd) && (speed != 0 || dplx != 0)) {
       
   615 		e_dev_info("AutoNeg specified along with Speed or Duplex, "
       
   616 			   "parameter ignored\n");
       
   617 		adapter->hw.autoneg_advertised = AUTONEG_ADV_DEFAULT;
       
   618 	} else { /* Autoneg */
       
   619 		static const struct e1000_opt_list an_list[] =
       
   620 			#define AA "AutoNeg advertising "
       
   621 			{{ 0x01, AA "10/HD" },
       
   622 			 { 0x02, AA "10/FD" },
       
   623 			 { 0x03, AA "10/FD, 10/HD" },
       
   624 			 { 0x04, AA "100/HD" },
       
   625 			 { 0x05, AA "100/HD, 10/HD" },
       
   626 			 { 0x06, AA "100/HD, 10/FD" },
       
   627 			 { 0x07, AA "100/HD, 10/FD, 10/HD" },
       
   628 			 { 0x08, AA "100/FD" },
       
   629 			 { 0x09, AA "100/FD, 10/HD" },
       
   630 			 { 0x0a, AA "100/FD, 10/FD" },
       
   631 			 { 0x0b, AA "100/FD, 10/FD, 10/HD" },
       
   632 			 { 0x0c, AA "100/FD, 100/HD" },
       
   633 			 { 0x0d, AA "100/FD, 100/HD, 10/HD" },
       
   634 			 { 0x0e, AA "100/FD, 100/HD, 10/FD" },
       
   635 			 { 0x0f, AA "100/FD, 100/HD, 10/FD, 10/HD" },
       
   636 			 { 0x20, AA "1000/FD" },
       
   637 			 { 0x21, AA "1000/FD, 10/HD" },
       
   638 			 { 0x22, AA "1000/FD, 10/FD" },
       
   639 			 { 0x23, AA "1000/FD, 10/FD, 10/HD" },
       
   640 			 { 0x24, AA "1000/FD, 100/HD" },
       
   641 			 { 0x25, AA "1000/FD, 100/HD, 10/HD" },
       
   642 			 { 0x26, AA "1000/FD, 100/HD, 10/FD" },
       
   643 			 { 0x27, AA "1000/FD, 100/HD, 10/FD, 10/HD" },
       
   644 			 { 0x28, AA "1000/FD, 100/FD" },
       
   645 			 { 0x29, AA "1000/FD, 100/FD, 10/HD" },
       
   646 			 { 0x2a, AA "1000/FD, 100/FD, 10/FD" },
       
   647 			 { 0x2b, AA "1000/FD, 100/FD, 10/FD, 10/HD" },
       
   648 			 { 0x2c, AA "1000/FD, 100/FD, 100/HD" },
       
   649 			 { 0x2d, AA "1000/FD, 100/FD, 100/HD, 10/HD" },
       
   650 			 { 0x2e, AA "1000/FD, 100/FD, 100/HD, 10/FD" },
       
   651 			 { 0x2f, AA "1000/FD, 100/FD, 100/HD, 10/FD, 10/HD" }};
       
   652 
       
   653 		opt = (struct e1000_option) {
       
   654 			.type = list_option,
       
   655 			.name = "AutoNeg",
       
   656 			.err  = "parameter ignored",
       
   657 			.def  = AUTONEG_ADV_DEFAULT,
       
   658 			.arg  = { .l = { .nr = ARRAY_SIZE(an_list),
       
   659 					 .p = an_list }}
       
   660 		};
       
   661 
       
   662 		if (num_AutoNeg > bd) {
       
   663 			an = AutoNeg[bd];
       
   664 			e1000_validate_option(&an, &opt, adapter);
       
   665 		} else {
       
   666 			an = opt.def;
       
   667 		}
       
   668 		adapter->hw.autoneg_advertised = an;
       
   669 	}
       
   670 
       
   671 	switch (speed + dplx) {
       
   672 	case 0:
       
   673 		adapter->hw.autoneg = adapter->fc_autoneg = 1;
       
   674 		if ((num_Speed > bd) && (speed != 0 || dplx != 0))
       
   675 			e_dev_info("Speed and duplex autonegotiation "
       
   676 				   "enabled\n");
       
   677 		break;
       
   678 	case HALF_DUPLEX:
       
   679 		e_dev_info("Half Duplex specified without Speed\n");
       
   680 		e_dev_info("Using Autonegotiation at Half Duplex only\n");
       
   681 		adapter->hw.autoneg = adapter->fc_autoneg = 1;
       
   682 		adapter->hw.autoneg_advertised = ADVERTISE_10_HALF |
       
   683 		                                 ADVERTISE_100_HALF;
       
   684 		break;
       
   685 	case FULL_DUPLEX:
       
   686 		e_dev_info("Full Duplex specified without Speed\n");
       
   687 		e_dev_info("Using Autonegotiation at Full Duplex only\n");
       
   688 		adapter->hw.autoneg = adapter->fc_autoneg = 1;
       
   689 		adapter->hw.autoneg_advertised = ADVERTISE_10_FULL |
       
   690 		                                 ADVERTISE_100_FULL |
       
   691 		                                 ADVERTISE_1000_FULL;
       
   692 		break;
       
   693 	case SPEED_10:
       
   694 		e_dev_info("10 Mbps Speed specified without Duplex\n");
       
   695 		e_dev_info("Using Autonegotiation at 10 Mbps only\n");
       
   696 		adapter->hw.autoneg = adapter->fc_autoneg = 1;
       
   697 		adapter->hw.autoneg_advertised = ADVERTISE_10_HALF |
       
   698 		                                 ADVERTISE_10_FULL;
       
   699 		break;
       
   700 	case SPEED_10 + HALF_DUPLEX:
       
   701 		e_dev_info("Forcing to 10 Mbps Half Duplex\n");
       
   702 		adapter->hw.autoneg = adapter->fc_autoneg = 0;
       
   703 		adapter->hw.forced_speed_duplex = e1000_10_half;
       
   704 		adapter->hw.autoneg_advertised = 0;
       
   705 		break;
       
   706 	case SPEED_10 + FULL_DUPLEX:
       
   707 		e_dev_info("Forcing to 10 Mbps Full Duplex\n");
       
   708 		adapter->hw.autoneg = adapter->fc_autoneg = 0;
       
   709 		adapter->hw.forced_speed_duplex = e1000_10_full;
       
   710 		adapter->hw.autoneg_advertised = 0;
       
   711 		break;
       
   712 	case SPEED_100:
       
   713 		e_dev_info("100 Mbps Speed specified without Duplex\n");
       
   714 		e_dev_info("Using Autonegotiation at 100 Mbps only\n");
       
   715 		adapter->hw.autoneg = adapter->fc_autoneg = 1;
       
   716 		adapter->hw.autoneg_advertised = ADVERTISE_100_HALF |
       
   717 		                                 ADVERTISE_100_FULL;
       
   718 		break;
       
   719 	case SPEED_100 + HALF_DUPLEX:
       
   720 		e_dev_info("Forcing to 100 Mbps Half Duplex\n");
       
   721 		adapter->hw.autoneg = adapter->fc_autoneg = 0;
       
   722 		adapter->hw.forced_speed_duplex = e1000_100_half;
       
   723 		adapter->hw.autoneg_advertised = 0;
       
   724 		break;
       
   725 	case SPEED_100 + FULL_DUPLEX:
       
   726 		e_dev_info("Forcing to 100 Mbps Full Duplex\n");
       
   727 		adapter->hw.autoneg = adapter->fc_autoneg = 0;
       
   728 		adapter->hw.forced_speed_duplex = e1000_100_full;
       
   729 		adapter->hw.autoneg_advertised = 0;
       
   730 		break;
       
   731 	case SPEED_1000:
       
   732 		e_dev_info("1000 Mbps Speed specified without Duplex\n");
       
   733 		goto full_duplex_only;
       
   734 	case SPEED_1000 + HALF_DUPLEX:
       
   735 		e_dev_info("Half Duplex is not supported at 1000 Mbps\n");
       
   736 		/* fall through */
       
   737 	case SPEED_1000 + FULL_DUPLEX:
       
   738 full_duplex_only:
       
   739 		e_dev_info("Using Autonegotiation at 1000 Mbps Full Duplex "
       
   740 			   "only\n");
       
   741 		adapter->hw.autoneg = adapter->fc_autoneg = 1;
       
   742 		adapter->hw.autoneg_advertised = ADVERTISE_1000_FULL;
       
   743 		break;
       
   744 	default:
       
   745 		BUG();
       
   746 	}
       
   747 
       
   748 	/* Speed, AutoNeg and MDI/MDI-X must all play nice */
       
   749 	if (e1000_validate_mdi_setting(&(adapter->hw)) < 0) {
       
   750 		e_dev_info("Speed, AutoNeg and MDI-X specs are incompatible. "
       
   751 			   "Setting MDI-X to a compatible value.\n");
       
   752 	}
       
   753 }
       
   754