[linux-2.6-block.git] / drivers / net / e1000e / param.c

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

  Intel PRO/1000 Linux driver
  Copyright(c) 1999 - 2008 Intel Corporation.

  This program is free software; you can redistribute it and/or modify it
  under the terms and conditions of the GNU General Public License,
  version 2, as published by the Free Software Foundation.

  This program is distributed in the hope it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  more details.

  You should have received a copy of the GNU General Public License along with
  this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.

  The full GNU General Public License is included in this distribution in
  the file called "COPYING".

  Contact Information:
  Linux NICS <linux.nics@intel.com>
  e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
  Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497

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

#include <linux/netdevice.h>
#include <linux/pci.h>

#include "e1000.h"

/*
 * This is the only thing that needs to be changed to adjust the
 * maximum number of ports that the driver can manage.
 */

#define E1000_MAX_NIC 32

#define OPTION_UNSET   -1
#define OPTION_DISABLED 0
#define OPTION_ENABLED  1

#define COPYBREAK_DEFAULT 256
unsigned int copybreak = COPYBREAK_DEFAULT;
module_param(copybreak, uint, 0644);
MODULE_PARM_DESC(copybreak,
	"Maximum size of packet that is copied to a new buffer on receive");

/*
 * All parameters are treated the same, as an integer array of values.
 * This macro just reduces the need to repeat the same declaration code
 * over and over (plus this helps to avoid typo bugs).
 */

#define E1000_PARAM_INIT { [0 ... E1000_MAX_NIC] = OPTION_UNSET }
#define E1000_PARAM(X, desc)					\
	static int __devinitdata X[E1000_MAX_NIC+1]		\
		= E1000_PARAM_INIT;				\
	static unsigned int num_##X;				\
	module_param_array_named(X, X, int, &num_##X, 0);	\
	MODULE_PARM_DESC(X, desc);


/*
 * Transmit Interrupt Delay in units of 1.024 microseconds
 * Tx interrupt delay needs to typically be set to something non zero
 *
 * Valid Range: 0-65535
 */
E1000_PARAM(TxIntDelay, "Transmit Interrupt Delay");
#define DEFAULT_TIDV 8
#define MAX_TXDELAY 0xFFFF
#define MIN_TXDELAY 0

/*
 * Transmit Absolute Interrupt Delay in units of 1.024 microseconds
 *
 * Valid Range: 0-65535
 */
E1000_PARAM(TxAbsIntDelay, "Transmit Absolute Interrupt Delay");
#define DEFAULT_TADV 32
#define MAX_TXABSDELAY 0xFFFF
#define MIN_TXABSDELAY 0

/*
 * Receive Interrupt Delay in units of 1.024 microseconds
 * hardware will likely hang if you set this to anything but zero.
 *
 * Valid Range: 0-65535
 */
E1000_PARAM(RxIntDelay, "Receive Interrupt Delay");
#define DEFAULT_RDTR 0
#define MAX_RXDELAY 0xFFFF
#define MIN_RXDELAY 0

/*
 * Receive Absolute Interrupt Delay in units of 1.024 microseconds
 *
 * Valid Range: 0-65535
 */
E1000_PARAM(RxAbsIntDelay, "Receive Absolute Interrupt Delay");
#define DEFAULT_RADV 8
#define MAX_RXABSDELAY 0xFFFF
#define MIN_RXABSDELAY 0

/*
 * Interrupt Throttle Rate (interrupts/sec)
 *
 * Valid Range: 100-100000 (0=off, 1=dynamic, 3=dynamic conservative)
 */
E1000_PARAM(InterruptThrottleRate, "Interrupt Throttling Rate");
#define DEFAULT_ITR 3
#define MAX_ITR 100000
#define MIN_ITR 100

/*
 * Enable Smart Power Down of the PHY
 *
 * Valid Range: 0, 1
 *
 * Default Value: 0 (disabled)
 */
E1000_PARAM(SmartPowerDownEnable, "Enable PHY smart power down");

/*
 * Enable Kumeran Lock Loss workaround
 *
 * Valid Range: 0, 1
 *
 * Default Value: 1 (enabled)
 */
E1000_PARAM(KumeranLockLoss, "Enable Kumeran lock loss workaround");

struct e1000_option {
	enum { enable_option, range_option, list_option } type;
	const char *name;
	const char *err;
	int def;
	union {
		struct { /* range_option info */
			int min;
			int max;
		} r;
		struct { /* list_option info */
			int nr;
			struct e1000_opt_list { int i; char *str; } *p;
		} l;
	} arg;
};

static int __devinit e1000_validate_option(unsigned int *value,
					   const struct e1000_option *opt,
					   struct e1000_adapter *adapter)
{
	if (*value == OPTION_UNSET) {
		*value = opt->def;
		return 0;
	}

	switch (opt->type) {
	case enable_option:
		switch (*value) {
		case OPTION_ENABLED:
			e_info("%s Enabled\n", opt->name);
			return 0;
		case OPTION_DISABLED:
			e_info("%s Disabled\n", opt->name);
			return 0;
		}
		break;
	case range_option:
		if (*value >= opt->arg.r.min && *value <= opt->arg.r.max) {
			e_info("%s set to %i\n", opt->name, *value);
			return 0;
		}
		break;
	case list_option: {
		int i;
		struct e1000_opt_list *ent;

		for (i = 0; i < opt->arg.l.nr; i++) {
			ent = &opt->arg.l.p[i];
			if (*value == ent->i) {
				if (ent->str[0] != '\0')
					e_info("%s\n", ent->str);
				return 0;
			}
		}
	}
		break;
	default:
		BUG();
	}

	e_info("Invalid %s value specified (%i) %s\n", opt->name, *value,
	       opt->err);
	*value = opt->def;
	return -1;
}

/**
 * e1000e_check_options - Range Checking for Command Line Parameters
 * @adapter: board private structure
 *
 * This routine checks all command line parameters for valid user
 * input.  If an invalid value is given, or if no user specified
 * value exists, a default value is used.  The final value is stored
 * in a variable in the adapter structure.
 **/
void __devinit e1000e_check_options(struct e1000_adapter *adapter)
{
	struct e1000_hw *hw = &adapter->hw;
	int bd = adapter->bd_number;

	if (bd >= E1000_MAX_NIC) {
		e_notice("Warning: no configuration for board #%i\n", bd);
		e_notice("Using defaults for all values\n");
	}

	{ /* Transmit Interrupt Delay */
		const struct e1000_option opt = {
			.type = range_option,
			.name = "Transmit Interrupt Delay",
			.err  = "using default of "
				__MODULE_STRING(DEFAULT_TIDV),
			.def  = DEFAULT_TIDV,
			.arg  = { .r = { .min = MIN_TXDELAY,
					 .max = MAX_TXDELAY } }
		};

		if (num_TxIntDelay > bd) {
			adapter->tx_int_delay = TxIntDelay[bd];
			e1000_validate_option(&adapter->tx_int_delay, &opt,
					      adapter);
		} else {
			adapter->tx_int_delay = opt.def;
		}
	}
	{ /* Transmit Absolute Interrupt Delay */
		const struct e1000_option opt = {
			.type = range_option,
			.name = "Transmit Absolute Interrupt Delay",
			.err  = "using default of "
				__MODULE_STRING(DEFAULT_TADV),
			.def  = DEFAULT_TADV,
			.arg  = { .r = { .min = MIN_TXABSDELAY,
					 .max = MAX_TXABSDELAY } }
		};

		if (num_TxAbsIntDelay > bd) {
			adapter->tx_abs_int_delay = TxAbsIntDelay[bd];
			e1000_validate_option(&adapter->tx_abs_int_delay, &opt,
					      adapter);
		} else {
			adapter->tx_abs_int_delay = opt.def;
		}
	}
	{ /* Receive Interrupt Delay */
		struct e1000_option opt = {
			.type = range_option,
			.name = "Receive Interrupt Delay",
			.err  = "using default of "
				__MODULE_STRING(DEFAULT_RDTR),
			.def  = DEFAULT_RDTR,
			.arg  = { .r = { .min = MIN_RXDELAY,
					 .max = MAX_RXDELAY } }
		};

		if (num_RxIntDelay > bd) {
			adapter->rx_int_delay = RxIntDelay[bd];
			e1000_validate_option(&adapter->rx_int_delay, &opt,
					      adapter);
		} else {
			adapter->rx_int_delay = opt.def;
		}
	}
	{ /* Receive Absolute Interrupt Delay */
		const struct e1000_option opt = {
			.type = range_option,
			.name = "Receive Absolute Interrupt Delay",
			.err  = "using default of "
				__MODULE_STRING(DEFAULT_RADV),
			.def  = DEFAULT_RADV,
			.arg  = { .r = { .min = MIN_RXABSDELAY,
					 .max = MAX_RXABSDELAY } }
		};

		if (num_RxAbsIntDelay > bd) {
			adapter->rx_abs_int_delay = RxAbsIntDelay[bd];
			e1000_validate_option(&adapter->rx_abs_int_delay, &opt,
					      adapter);
		} else {
			adapter->rx_abs_int_delay = opt.def;
		}
	}
	{ /* Interrupt Throttling Rate */
		const struct e1000_option opt = {
			.type = range_option,
			.name = "Interrupt Throttling Rate (ints/sec)",
			.err  = "using default of "
				__MODULE_STRING(DEFAULT_ITR),
			.def  = DEFAULT_ITR,
			.arg  = { .r = { .min = MIN_ITR,
					 .max = MAX_ITR } }
		};

		if (num_InterruptThrottleRate > bd) {
			adapter->itr = InterruptThrottleRate[bd];
			switch (adapter->itr) {
			case 0:
				e_info("%s turned off\n", opt.name);
				break;
			case 1:
				e_info("%s set to dynamic mode\n", opt.name);
				adapter->itr_setting = adapter->itr;
				adapter->itr = 20000;
				break;
			case 3:
				e_info("%s set to dynamic conservative mode\n",
					opt.name);
				adapter->itr_setting = adapter->itr;
				adapter->itr = 20000;
				break;
			default:
				/*
				 * Save the setting, because the dynamic bits
				 * change itr.
				 */
				if (e1000_validate_option(&adapter->itr, &opt,
							  adapter) &&
				    (adapter->itr == 3)) {
					/*
					 * In case of invalid user value,
					 * default to conservative mode.
					 */
					adapter->itr_setting = adapter->itr;
					adapter->itr = 20000;
				} else {
					/*
					 * Clear the lower two bits because
					 * they are used as control.
					 */
					adapter->itr_setting =
						adapter->itr & ~3;
				}
				break;
			}
		} else {
			adapter->itr_setting = opt.def;
			adapter->itr = 20000;
		}
	}
	{ /* Smart Power Down */
		const struct e1000_option opt = {
			.type = enable_option,
			.name = "PHY Smart Power Down",
			.err  = "defaulting to Disabled",
			.def  = OPTION_DISABLED
		};

		if (num_SmartPowerDownEnable > bd) {
			unsigned int spd = SmartPowerDownEnable[bd];
			e1000_validate_option(&spd, &opt, adapter);
			if ((adapter->flags & FLAG_HAS_SMART_POWER_DOWN)
			    && spd)
				adapter->flags |= FLAG_SMART_POWER_DOWN;
		}
	}
	{ /* Kumeran Lock Loss Workaround */
		const struct e1000_option opt = {
			.type = enable_option,
			.name = "Kumeran Lock Loss Workaround",
			.err  = "defaulting to Enabled",
			.def  = OPTION_ENABLED
		};

		if (num_KumeranLockLoss > bd) {
			unsigned int kmrn_lock_loss = KumeranLockLoss[bd];
			e1000_validate_option(&kmrn_lock_loss, &opt, adapter);
			if (hw->mac.type == e1000_ich8lan)
				e1000e_set_kmrn_lock_loss_workaround_ich8lan(hw,
								kmrn_lock_loss);
		} else {
			if (hw->mac.type == e1000_ich8lan)
				e1000e_set_kmrn_lock_loss_workaround_ich8lan(hw,
								       opt.def);
		}
	}
}
Commit	Line	Data
bc7f75fa AK	1	/*******************************************************************************
	2
	3	Intel PRO/1000 Linux driver
ad68076e	4	Copyright(c) 1999 - 2008 Intel Corporation.
bc7f75fa AK	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 <linux/netdevice.h>
44defeb3	30	#include <linux/pci.h>
bc7f75fa AK	31
	32	#include "e1000.h"
	33
ad68076e BA	34	/*
ad68076e BA	35	* This is the only thing that needs to be changed to adjust the
bc7f75fa AK	36	* maximum number of ports that the driver can manage.
	37	*/
	38
	39	#define E1000_MAX_NIC 32
	40
	41	#define OPTION_UNSET -1
	42	#define OPTION_DISABLED 0
	43	#define OPTION_ENABLED 1
	44
	45	#define COPYBREAK_DEFAULT 256
	46	unsigned int copybreak = COPYBREAK_DEFAULT;
	47	module_param(copybreak, uint, 0644);
	48	MODULE_PARM_DESC(copybreak,
	49	"Maximum size of packet that is copied to a new buffer on receive");
	50
ad68076e BA	51	/*
ad68076e BA	52	* All parameters are treated the same, as an integer array of values.
bc7f75fa AK	53	* This macro just reduces the need to repeat the same declaration code
	54	* over and over (plus this helps to avoid typo bugs).
	55	*/
	56
	57	#define E1000_PARAM_INIT { [0 ... E1000_MAX_NIC] = OPTION_UNSET }
5a9147bb SH	58	#define E1000_PARAM(X, desc) \
	59	static int __devinitdata X[E1000_MAX_NIC+1] \
	60	= E1000_PARAM_INIT; \
	61	static unsigned int num_##X; \
	62	module_param_array_named(X, X, int, &num_##X, 0); \
bc7f75fa AK	63	MODULE_PARM_DESC(X, desc);
	64
	65
ad68076e BA	66	/*
	67	* Transmit Interrupt Delay in units of 1.024 microseconds
	68	* Tx interrupt delay needs to typically be set to something non zero
bc7f75fa AK	69	*
	70	* Valid Range: 0-65535
	71	*/
	72	E1000_PARAM(TxIntDelay, "Transmit Interrupt Delay");
	73	#define DEFAULT_TIDV 8
	74	#define MAX_TXDELAY 0xFFFF
	75	#define MIN_TXDELAY 0
	76
ad68076e BA	77	/*
ad68076e BA	78	* Transmit Absolute Interrupt Delay in units of 1.024 microseconds
bc7f75fa AK	79	*
	80	* Valid Range: 0-65535
	81	*/
	82	E1000_PARAM(TxAbsIntDelay, "Transmit Absolute Interrupt Delay");
	83	#define DEFAULT_TADV 32
	84	#define MAX_TXABSDELAY 0xFFFF
	85	#define MIN_TXABSDELAY 0
	86
ad68076e BA	87	/*
	88	* Receive Interrupt Delay in units of 1.024 microseconds
	89	* hardware will likely hang if you set this to anything but zero.
bc7f75fa AK	90	*
	91	* Valid Range: 0-65535
	92	*/
	93	E1000_PARAM(RxIntDelay, "Receive Interrupt Delay");
	94	#define DEFAULT_RDTR 0
	95	#define MAX_RXDELAY 0xFFFF
	96	#define MIN_RXDELAY 0
	97
ad68076e BA	98	/*
ad68076e BA	99	* Receive Absolute Interrupt Delay in units of 1.024 microseconds
bc7f75fa AK	100	*
	101	* Valid Range: 0-65535
	102	*/
	103	E1000_PARAM(RxAbsIntDelay, "Receive Absolute Interrupt Delay");
	104	#define DEFAULT_RADV 8
	105	#define MAX_RXABSDELAY 0xFFFF
	106	#define MIN_RXABSDELAY 0
	107
ad68076e BA	108	/*
ad68076e BA	109	* Interrupt Throttle Rate (interrupts/sec)
bc7f75fa AK	110	*
	111	* Valid Range: 100-100000 (0=off, 1=dynamic, 3=dynamic conservative)
	112	*/
	113	E1000_PARAM(InterruptThrottleRate, "Interrupt Throttling Rate");
	114	#define DEFAULT_ITR 3
	115	#define MAX_ITR 100000
	116	#define MIN_ITR 100
	117
ad68076e BA	118	/*
ad68076e BA	119	* Enable Smart Power Down of the PHY
bc7f75fa AK	120	*
	121	* Valid Range: 0, 1
	122	*
	123	* Default Value: 0 (disabled)
	124	*/
	125	E1000_PARAM(SmartPowerDownEnable, "Enable PHY smart power down");
	126
ad68076e BA	127	/*
ad68076e BA	128	* Enable Kumeran Lock Loss workaround
bc7f75fa AK	129	*
	130	* Valid Range: 0, 1
	131	*
	132	* Default Value: 1 (enabled)
	133	*/
	134	E1000_PARAM(KumeranLockLoss, "Enable Kumeran lock loss workaround");
	135
	136	struct e1000_option {
	137	enum { enable_option, range_option, list_option } type;
5a9147bb SH	138	const char *name;
	139	const char *err;
	140	int def;
bc7f75fa AK	141	union {
	142	struct { /* range_option info */
	143	int min;
	144	int max;
	145	} r;
	146	struct { /* list_option info */
	147	int nr;
	148	struct e1000_opt_list { int i; char str; } p;
	149	} l;
	150	} arg;
	151	};
	152
5a9147bb SH	153	static int __devinit e1000_validate_option(unsigned int *value,
5a9147bb SH	154	const struct e1000_option *opt,
bc7f75fa AK	155	struct e1000_adapter *adapter)
	156	{
	157	if (*value == OPTION_UNSET) {
	158	*value = opt->def;
	159	return 0;
	160	}
	161
	162	switch (opt->type) {
	163	case enable_option:
	164	switch (*value) {
	165	case OPTION_ENABLED:
44defeb3	166	e_info("%s Enabled\n", opt->name);
bc7f75fa AK	167	return 0;
bc7f75fa AK	168	case OPTION_DISABLED:
44defeb3	169	e_info("%s Disabled\n", opt->name);
bc7f75fa AK	170	return 0;
	171	}
	172	break;
	173	case range_option:
	174	if (value >= opt->arg.r.min && value <= opt->arg.r.max) {
44defeb3	175	e_info("%s set to %i\n", opt->name, *value);
bc7f75fa AK	176	return 0;
	177	}
	178	break;
	179	case list_option: {
	180	int i;
	181	struct e1000_opt_list *ent;
	182
	183	for (i = 0; i < opt->arg.l.nr; i++) {
	184	ent = &opt->arg.l.p[i];
	185	if (*value == ent->i) {
	186	if (ent->str[0] != '\0')
44defeb3	187	e_info("%s\n", ent->str);
bc7f75fa AK	188	return 0;
	189	}
	190	}
	191	}
	192	break;
	193	default:
	194	BUG();
	195	}
	196
44defeb3 JK	197	e_info("Invalid %s value specified (%i) %s\n", opt->name, *value,
44defeb3 JK	198	opt->err);
bc7f75fa AK	199	*value = opt->def;
	200	return -1;
	201	}
	202
	203	/**
	204	* e1000e_check_options - Range Checking for Command Line Parameters
	205	* @adapter: board private structure
	206	*
	207	* This routine checks all command line parameters for valid user
	208	* input. If an invalid value is given, or if no user specified
	209	* value exists, a default value is used. The final value is stored
	210	* in a variable in the adapter structure.
	211	**/
	212	void __devinit e1000e_check_options(struct e1000_adapter *adapter)
	213	{
	214	struct e1000_hw *hw = &adapter->hw;
bc7f75fa AK	215	int bd = adapter->bd_number;
	216
	217	if (bd >= E1000_MAX_NIC) {
44defeb3 JK	218	e_notice("Warning: no configuration for board #%i\n", bd);
44defeb3 JK	219	e_notice("Using defaults for all values\n");
bc7f75fa AK	220	}
	221
	222	{ /* Transmit Interrupt Delay */
5a9147bb	223	const struct e1000_option opt = {
bc7f75fa AK	224	.type = range_option,
	225	.name = "Transmit Interrupt Delay",
	226	.err = "using default of "
	227	__MODULE_STRING(DEFAULT_TIDV),
	228	.def = DEFAULT_TIDV,
	229	.arg = { .r = { .min = MIN_TXDELAY,
	230	.max = MAX_TXDELAY } }
	231	};
	232
	233	if (num_TxIntDelay > bd) {
	234	adapter->tx_int_delay = TxIntDelay[bd];
	235	e1000_validate_option(&adapter->tx_int_delay, &opt,
	236	adapter);
	237	} else {
	238	adapter->tx_int_delay = opt.def;
	239	}
	240	}
	241	{ /* Transmit Absolute Interrupt Delay */
5a9147bb	242	const struct e1000_option opt = {
bc7f75fa AK	243	.type = range_option,
	244	.name = "Transmit Absolute Interrupt Delay",
	245	.err = "using default of "
	246	__MODULE_STRING(DEFAULT_TADV),
	247	.def = DEFAULT_TADV,
	248	.arg = { .r = { .min = MIN_TXABSDELAY,
	249	.max = MAX_TXABSDELAY } }
	250	};
	251
	252	if (num_TxAbsIntDelay > bd) {
	253	adapter->tx_abs_int_delay = TxAbsIntDelay[bd];
	254	e1000_validate_option(&adapter->tx_abs_int_delay, &opt,
	255	adapter);
	256	} else {
	257	adapter->tx_abs_int_delay = opt.def;
	258	}
	259	}
	260	{ /* Receive Interrupt Delay */
	261	struct e1000_option opt = {
	262	.type = range_option,
	263	.name = "Receive Interrupt Delay",
	264	.err = "using default of "
	265	__MODULE_STRING(DEFAULT_RDTR),
	266	.def = DEFAULT_RDTR,
	267	.arg = { .r = { .min = MIN_RXDELAY,
	268	.max = MAX_RXDELAY } }
	269	};
	270
bc7f75fa AK	271	if (num_RxIntDelay > bd) {
	272	adapter->rx_int_delay = RxIntDelay[bd];
	273	e1000_validate_option(&adapter->rx_int_delay, &opt,
	274	adapter);
	275	} else {
	276	adapter->rx_int_delay = opt.def;
	277	}
	278	}
	279	{ /* Receive Absolute Interrupt Delay */
5a9147bb	280	const struct e1000_option opt = {
bc7f75fa AK	281	.type = range_option,
	282	.name = "Receive Absolute Interrupt Delay",
	283	.err = "using default of "
	284	__MODULE_STRING(DEFAULT_RADV),
	285	.def = DEFAULT_RADV,
	286	.arg = { .r = { .min = MIN_RXABSDELAY,
	287	.max = MAX_RXABSDELAY } }
	288	};
	289
	290	if (num_RxAbsIntDelay > bd) {
	291	adapter->rx_abs_int_delay = RxAbsIntDelay[bd];
	292	e1000_validate_option(&adapter->rx_abs_int_delay, &opt,
	293	adapter);
	294	} else {
	295	adapter->rx_abs_int_delay = opt.def;
	296	}
	297	}
	298	{ /* Interrupt Throttling Rate */
5a9147bb	299	const struct e1000_option opt = {
bc7f75fa AK	300	.type = range_option,
	301	.name = "Interrupt Throttling Rate (ints/sec)",
	302	.err = "using default of "
	303	__MODULE_STRING(DEFAULT_ITR),
	304	.def = DEFAULT_ITR,
	305	.arg = { .r = { .min = MIN_ITR,
	306	.max = MAX_ITR } }
	307	};
	308
	309	if (num_InterruptThrottleRate > bd) {
	310	adapter->itr = InterruptThrottleRate[bd];
	311	switch (adapter->itr) {
	312	case 0:
44defeb3	313	e_info("%s turned off\n", opt.name);
bc7f75fa AK	314	break;
bc7f75fa AK	315	case 1:
44defeb3	316	e_info("%s set to dynamic mode\n", opt.name);
bc7f75fa AK	317	adapter->itr_setting = adapter->itr;
	318	adapter->itr = 20000;
	319	break;
	320	case 3:
44defeb3	321	e_info("%s set to dynamic conservative mode\n",
bc7f75fa AK	322	opt.name);
	323	adapter->itr_setting = adapter->itr;
	324	adapter->itr = 20000;
	325	break;
	326	default:
bc7f75fa	327	/*
2d06cad1 BA	328	* Save the setting, because the dynamic bits
2d06cad1 BA	329	* change itr.
bc7f75fa	330	*/
2d06cad1 BA	331	if (e1000_validate_option(&adapter->itr, &opt,
	332	adapter) &&
	333	(adapter->itr == 3)) {
	334	/*
	335	* In case of invalid user value,
	336	* default to conservative mode.
	337	*/
	338	adapter->itr_setting = adapter->itr;
	339	adapter->itr = 20000;
	340	} else {
	341	/*
	342	* Clear the lower two bits because
	343	* they are used as control.
	344	*/
	345	adapter->itr_setting =
	346	adapter->itr & ~3;
	347	}
bc7f75fa AK	348	break;
	349	}
	350	} else {
	351	adapter->itr_setting = opt.def;
	352	adapter->itr = 20000;
	353	}
	354	}
	355	{ /* Smart Power Down */
5a9147bb	356	const struct e1000_option opt = {
bc7f75fa AK	357	.type = enable_option,
	358	.name = "PHY Smart Power Down",
	359	.err = "defaulting to Disabled",
	360	.def = OPTION_DISABLED
	361	};
	362
	363	if (num_SmartPowerDownEnable > bd) {
5a9147bb	364	unsigned int spd = SmartPowerDownEnable[bd];
bc7f75fa AK	365	e1000_validate_option(&spd, &opt, adapter);
	366	if ((adapter->flags & FLAG_HAS_SMART_POWER_DOWN)
	367	&& spd)
	368	adapter->flags \|= FLAG_SMART_POWER_DOWN;
	369	}
	370	}
	371	{ /* Kumeran Lock Loss Workaround */
5a9147bb	372	const struct e1000_option opt = {
bc7f75fa AK	373	.type = enable_option,
	374	.name = "Kumeran Lock Loss Workaround",
	375	.err = "defaulting to Enabled",
	376	.def = OPTION_ENABLED
	377	};
	378
	379	if (num_KumeranLockLoss > bd) {
5a9147bb	380	unsigned int kmrn_lock_loss = KumeranLockLoss[bd];
bc7f75fa AK	381	e1000_validate_option(&kmrn_lock_loss, &opt, adapter);
	382	if (hw->mac.type == e1000_ich8lan)
	383	e1000e_set_kmrn_lock_loss_workaround_ich8lan(hw,
	384	kmrn_lock_loss);
	385	} else {
	386	if (hw->mac.type == e1000_ich8lan)
	387	e1000e_set_kmrn_lock_loss_workaround_ich8lan(hw,
	388	opt.def);
	389	}
	390	}
	391	}