[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / net / e1000e / param.c

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

  Intel PRO/1000 Linux driver
  Copyright(c) 1999 - 2011 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 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 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

/* IntMode (Interrupt Mode)
 *
 * Valid Range: 0 - 2
 *
 * Default Value: 2 (MSI-X)
 */
E1000_PARAM(IntMode, "Interrupt Mode");
#define MAX_INTMODE	2
#define MIN_INTMODE	0

/*
 * 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");

/*
 * Write Protect NVM
 *
 * Valid Range: 0, 1
 *
 * Default Value: 1 (enabled)
 */
E1000_PARAM(WriteProtectNVM, "Write-protect NVM [WARNING: disabling this can lead to corrupted NVM]");

/*
 * Enable CRC Stripping
 *
 * Valid Range: 0, 1
 *
 * Default Value: 1 (enabled)
 */
E1000_PARAM(CrcStripping, "Enable CRC Stripping, disable if your BMC needs " \
                          "the CRC");

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 */
		static 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 */
		static 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 */
		static 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 */
		static 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 */
		static 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;
			case 4:
				e_info("%s set to simplified (2000-8000 ints) "
				       "mode\n", opt.name);
				adapter->itr_setting = 4;
				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;
		}
	}
	{ /* Interrupt Mode */
		static struct e1000_option opt = {
			.type = range_option,
			.name = "Interrupt Mode",
			.err  = "defaulting to 2 (MSI-X)",
			.def  = E1000E_INT_MODE_MSIX,
			.arg  = { .r = { .min = MIN_INTMODE,
					 .max = MAX_INTMODE } }
		};

		if (num_IntMode > bd) {
			unsigned int int_mode = IntMode[bd];
			e1000_validate_option(&int_mode, &opt, adapter);
			adapter->int_mode = int_mode;
		} else {
			adapter->int_mode = opt.def;
		}
	}
	{ /* Smart Power Down */
		static 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;
		}
	}
	{ /* CRC Stripping */
		static const struct e1000_option opt = {
			.type = enable_option,
			.name = "CRC Stripping",
			.err  = "defaulting to Enabled",
			.def  = OPTION_ENABLED
		};

		if (num_CrcStripping > bd) {
			unsigned int crc_stripping = CrcStripping[bd];
			e1000_validate_option(&crc_stripping, &opt, adapter);
			if (crc_stripping == OPTION_ENABLED)
				adapter->flags2 |= FLAG2_CRC_STRIPPING;
		} else {
			adapter->flags2 |= FLAG2_CRC_STRIPPING;
		}
	}
	{ /* Kumeran Lock Loss Workaround */
		static 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);
		}
	}
	{ /* Write-protect NVM */
		static const struct e1000_option opt = {
			.type = enable_option,
			.name = "Write-protect NVM",
			.err  = "defaulting to Enabled",
			.def  = OPTION_ENABLED
		};

		if (adapter->flags & FLAG_IS_ICH) {
			if (num_WriteProtectNVM > bd) {
				unsigned int write_protect_nvm = WriteProtectNVM[bd];
				e1000_validate_option(&write_protect_nvm, &opt,
						      adapter);
				if (write_protect_nvm)
					adapter->flags |= FLAG_READ_ONLY_NVM;
			} else {
				if (opt.def)
					adapter->flags |= FLAG_READ_ONLY_NVM;
			}
		}
	}
}
Commit	Line	Data
bc7f75fa AK	1	/*******************************************************************************
	2
	3	Intel PRO/1000 Linux driver
0d6057e4	4	Copyright(c) 1999 - 2011 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);
bc7f75fa AK	64
ad68076e BA	65	/*
ad68076e BA	66	* Transmit Interrupt Delay in units of 1.024 microseconds
af667a29	67	* Tx interrupt delay needs to typically be set to something non-zero
bc7f75fa AK	68	*
	69	* Valid Range: 0-65535
	70	*/
	71	E1000_PARAM(TxIntDelay, "Transmit Interrupt Delay");
	72	#define DEFAULT_TIDV 8
	73	#define MAX_TXDELAY 0xFFFF
	74	#define MIN_TXDELAY 0
	75
ad68076e BA	76	/*
ad68076e BA	77	* Transmit Absolute Interrupt Delay in units of 1.024 microseconds
bc7f75fa AK	78	*
	79	* Valid Range: 0-65535
	80	*/
	81	E1000_PARAM(TxAbsIntDelay, "Transmit Absolute Interrupt Delay");
	82	#define DEFAULT_TADV 32
	83	#define MAX_TXABSDELAY 0xFFFF
	84	#define MIN_TXABSDELAY 0
	85
ad68076e BA	86	/*
	87	* Receive Interrupt Delay in units of 1.024 microseconds
	88	* hardware will likely hang if you set this to anything but zero.
bc7f75fa AK	89	*
	90	* Valid Range: 0-65535
	91	*/
	92	E1000_PARAM(RxIntDelay, "Receive Interrupt Delay");
bc7f75fa AK	93	#define MAX_RXDELAY 0xFFFF
	94	#define MIN_RXDELAY 0
	95
ad68076e BA	96	/*
ad68076e BA	97	* Receive Absolute Interrupt Delay in units of 1.024 microseconds
bc7f75fa AK	98	*
	99	* Valid Range: 0-65535
	100	*/
	101	E1000_PARAM(RxAbsIntDelay, "Receive Absolute Interrupt Delay");
bc7f75fa AK	102	#define MAX_RXABSDELAY 0xFFFF
	103	#define MIN_RXABSDELAY 0
	104
ad68076e BA	105	/*
ad68076e BA	106	* Interrupt Throttle Rate (interrupts/sec)
bc7f75fa AK	107	*
	108	* Valid Range: 100-100000 (0=off, 1=dynamic, 3=dynamic conservative)
	109	*/
	110	E1000_PARAM(InterruptThrottleRate, "Interrupt Throttling Rate");
	111	#define DEFAULT_ITR 3
	112	#define MAX_ITR 100000
	113	#define MIN_ITR 100
af667a29	114
4662e82b BA	115	/* IntMode (Interrupt Mode)
	116	*
	117	* Valid Range: 0 - 2
	118	*
	119	* Default Value: 2 (MSI-X)
	120	*/
	121	E1000_PARAM(IntMode, "Interrupt Mode");
	122	#define MAX_INTMODE 2
	123	#define MIN_INTMODE 0
bc7f75fa	124
ad68076e BA	125	/*
ad68076e BA	126	* Enable Smart Power Down of the PHY
bc7f75fa AK	127	*
	128	* Valid Range: 0, 1
	129	*
	130	* Default Value: 0 (disabled)
	131	*/
	132	E1000_PARAM(SmartPowerDownEnable, "Enable PHY smart power down");
	133
ad68076e BA	134	/*
ad68076e BA	135	* Enable Kumeran Lock Loss workaround
bc7f75fa AK	136	*
	137	* Valid Range: 0, 1
	138	*
	139	* Default Value: 1 (enabled)
	140	*/
	141	E1000_PARAM(KumeranLockLoss, "Enable Kumeran lock loss workaround");
	142
4a770358 BA	143	/*
	144	* Write Protect NVM
	145	*
	146	* Valid Range: 0, 1
	147	*
	148	* Default Value: 1 (enabled)
	149	*/
	150	E1000_PARAM(WriteProtectNVM, "Write-protect NVM [WARNING: disabling this can lead to corrupted NVM]");
	151
eb7c3adb JK	152	/*
	153	* Enable CRC Stripping
	154	*
	155	* Valid Range: 0, 1
	156	*
	157	* Default Value: 1 (enabled)
	158	*/
	159	E1000_PARAM(CrcStripping, "Enable CRC Stripping, disable if your BMC needs " \
	160	"the CRC");
	161
bc7f75fa AK	162	struct e1000_option {
bc7f75fa AK	163	enum { enable_option, range_option, list_option } type;
5a9147bb SH	164	const char *name;
	165	const char *err;
	166	int def;
bc7f75fa AK	167	union {
	168	struct { /* range_option info */
	169	int min;
	170	int max;
	171	} r;
	172	struct { /* list_option info */
	173	int nr;
	174	struct e1000_opt_list { int i; char str; } p;
	175	} l;
	176	} arg;
	177	};
	178
5a9147bb SH	179	static int __devinit e1000_validate_option(unsigned int *value,
5a9147bb SH	180	const struct e1000_option *opt,
bc7f75fa AK	181	struct e1000_adapter *adapter)
	182	{
	183	if (*value == OPTION_UNSET) {
	184	*value = opt->def;
	185	return 0;
	186	}
	187
	188	switch (opt->type) {
	189	case enable_option:
	190	switch (*value) {
	191	case OPTION_ENABLED:
44defeb3	192	e_info("%s Enabled\n", opt->name);
bc7f75fa AK	193	return 0;
bc7f75fa AK	194	case OPTION_DISABLED:
44defeb3	195	e_info("%s Disabled\n", opt->name);
bc7f75fa AK	196	return 0;
	197	}
	198	break;
	199	case range_option:
	200	if (value >= opt->arg.r.min && value <= opt->arg.r.max) {
44defeb3	201	e_info("%s set to %i\n", opt->name, *value);
bc7f75fa AK	202	return 0;
	203	}
	204	break;
	205	case list_option: {
	206	int i;
	207	struct e1000_opt_list *ent;
	208
	209	for (i = 0; i < opt->arg.l.nr; i++) {
	210	ent = &opt->arg.l.p[i];
	211	if (*value == ent->i) {
	212	if (ent->str[0] != '\0')
44defeb3	213	e_info("%s\n", ent->str);
bc7f75fa AK	214	return 0;
	215	}
	216	}
	217	}
	218	break;
	219	default:
	220	BUG();
	221	}
	222
44defeb3 JK	223	e_info("Invalid %s value specified (%i) %s\n", opt->name, *value,
44defeb3 JK	224	opt->err);
bc7f75fa AK	225	*value = opt->def;
	226	return -1;
	227	}
	228
	229	/**
	230	* e1000e_check_options - Range Checking for Command Line Parameters
	231	* @adapter: board private structure
	232	*
	233	* This routine checks all command line parameters for valid user
	234	* input. If an invalid value is given, or if no user specified
	235	* value exists, a default value is used. The final value is stored
	236	* in a variable in the adapter structure.
	237	**/
	238	void __devinit e1000e_check_options(struct e1000_adapter *adapter)
	239	{
	240	struct e1000_hw *hw = &adapter->hw;
bc7f75fa AK	241	int bd = adapter->bd_number;
	242
	243	if (bd >= E1000_MAX_NIC) {
44defeb3 JK	244	e_notice("Warning: no configuration for board #%i\n", bd);
44defeb3 JK	245	e_notice("Using defaults for all values\n");
bc7f75fa AK	246	}
	247
	248	{ /* Transmit Interrupt Delay */
6f59d660	249	static const struct e1000_option opt = {
bc7f75fa AK	250	.type = range_option,
	251	.name = "Transmit Interrupt Delay",
	252	.err = "using default of "
	253	__MODULE_STRING(DEFAULT_TIDV),
	254	.def = DEFAULT_TIDV,
	255	.arg = { .r = { .min = MIN_TXDELAY,
	256	.max = MAX_TXDELAY } }
	257	};
	258
	259	if (num_TxIntDelay > bd) {
	260	adapter->tx_int_delay = TxIntDelay[bd];
	261	e1000_validate_option(&adapter->tx_int_delay, &opt,
	262	adapter);
	263	} else {
	264	adapter->tx_int_delay = opt.def;
	265	}
	266	}
	267	{ /* Transmit Absolute Interrupt Delay */
6f59d660	268	static const struct e1000_option opt = {
bc7f75fa AK	269	.type = range_option,
	270	.name = "Transmit Absolute Interrupt Delay",
	271	.err = "using default of "
	272	__MODULE_STRING(DEFAULT_TADV),
	273	.def = DEFAULT_TADV,
	274	.arg = { .r = { .min = MIN_TXABSDELAY,
	275	.max = MAX_TXABSDELAY } }
	276	};
	277
	278	if (num_TxAbsIntDelay > bd) {
	279	adapter->tx_abs_int_delay = TxAbsIntDelay[bd];
	280	e1000_validate_option(&adapter->tx_abs_int_delay, &opt,
	281	adapter);
	282	} else {
	283	adapter->tx_abs_int_delay = opt.def;
	284	}
	285	}
	286	{ /* Receive Interrupt Delay */
4fe4491f	287	static struct e1000_option opt = {
bc7f75fa AK	288	.type = range_option,
	289	.name = "Receive Interrupt Delay",
	290	.err = "using default of "
	291	__MODULE_STRING(DEFAULT_RDTR),
	292	.def = DEFAULT_RDTR,
	293	.arg = { .r = { .min = MIN_RXDELAY,
	294	.max = MAX_RXDELAY } }
	295	};
	296
bc7f75fa AK	297	if (num_RxIntDelay > bd) {
	298	adapter->rx_int_delay = RxIntDelay[bd];
	299	e1000_validate_option(&adapter->rx_int_delay, &opt,
	300	adapter);
	301	} else {
	302	adapter->rx_int_delay = opt.def;
	303	}
	304	}
	305	{ /* Receive Absolute Interrupt Delay */
6f59d660	306	static const struct e1000_option opt = {
bc7f75fa AK	307	.type = range_option,
	308	.name = "Receive Absolute Interrupt Delay",
	309	.err = "using default of "
	310	__MODULE_STRING(DEFAULT_RADV),
	311	.def = DEFAULT_RADV,
	312	.arg = { .r = { .min = MIN_RXABSDELAY,
	313	.max = MAX_RXABSDELAY } }
	314	};
	315
	316	if (num_RxAbsIntDelay > bd) {
	317	adapter->rx_abs_int_delay = RxAbsIntDelay[bd];
	318	e1000_validate_option(&adapter->rx_abs_int_delay, &opt,
	319	adapter);
	320	} else {
	321	adapter->rx_abs_int_delay = opt.def;
	322	}
	323	}
	324	{ /* Interrupt Throttling Rate */
6f59d660	325	static const struct e1000_option opt = {
bc7f75fa AK	326	.type = range_option,
	327	.name = "Interrupt Throttling Rate (ints/sec)",
	328	.err = "using default of "
	329	__MODULE_STRING(DEFAULT_ITR),
	330	.def = DEFAULT_ITR,
	331	.arg = { .r = { .min = MIN_ITR,
	332	.max = MAX_ITR } }
	333	};
	334
	335	if (num_InterruptThrottleRate > bd) {
	336	adapter->itr = InterruptThrottleRate[bd];
	337	switch (adapter->itr) {
	338	case 0:
44defeb3	339	e_info("%s turned off\n", opt.name);
bc7f75fa AK	340	break;
bc7f75fa AK	341	case 1:
44defeb3	342	e_info("%s set to dynamic mode\n", opt.name);
bc7f75fa AK	343	adapter->itr_setting = adapter->itr;
	344	adapter->itr = 20000;
	345	break;
	346	case 3:
44defeb3	347	e_info("%s set to dynamic conservative mode\n",
bc7f75fa AK	348	opt.name);
	349	adapter->itr_setting = adapter->itr;
	350	adapter->itr = 20000;
	351	break;
eab2abf5 JB	352	case 4:
	353	e_info("%s set to simplified (2000-8000 ints) "
	354	"mode\n", opt.name);
	355	adapter->itr_setting = 4;
	356	break;
bc7f75fa	357	default:
bc7f75fa	358	/*
2d06cad1 BA	359	* Save the setting, because the dynamic bits
2d06cad1 BA	360	* change itr.
bc7f75fa	361	*/
2d06cad1 BA	362	if (e1000_validate_option(&adapter->itr, &opt,
	363	adapter) &&
	364	(adapter->itr == 3)) {
	365	/*
	366	* In case of invalid user value,
	367	* default to conservative mode.
	368	*/
	369	adapter->itr_setting = adapter->itr;
	370	adapter->itr = 20000;
	371	} else {
	372	/*
	373	* Clear the lower two bits because
	374	* they are used as control.
	375	*/
	376	adapter->itr_setting =
	377	adapter->itr & ~3;
	378	}
bc7f75fa AK	379	break;
	380	}
	381	} else {
	382	adapter->itr_setting = opt.def;
	383	adapter->itr = 20000;
	384	}
	385	}
4662e82b	386	{ /* Interrupt Mode */
4fe4491f	387	static struct e1000_option opt = {
4662e82b BA	388	.type = range_option,
	389	.name = "Interrupt Mode",
	390	.err = "defaulting to 2 (MSI-X)",
	391	.def = E1000E_INT_MODE_MSIX,
	392	.arg = { .r = { .min = MIN_INTMODE,
	393	.max = MAX_INTMODE } }
	394	};
	395
	396	if (num_IntMode > bd) {
	397	unsigned int int_mode = IntMode[bd];
	398	e1000_validate_option(&int_mode, &opt, adapter);
	399	adapter->int_mode = int_mode;
	400	} else {
	401	adapter->int_mode = opt.def;
	402	}
	403	}
bc7f75fa	404	{ /* Smart Power Down */
6f59d660	405	static const struct e1000_option opt = {
bc7f75fa AK	406	.type = enable_option,
	407	.name = "PHY Smart Power Down",
	408	.err = "defaulting to Disabled",
	409	.def = OPTION_DISABLED
	410	};
	411
	412	if (num_SmartPowerDownEnable > bd) {
5a9147bb	413	unsigned int spd = SmartPowerDownEnable[bd];
bc7f75fa AK	414	e1000_validate_option(&spd, &opt, adapter);
	415	if ((adapter->flags & FLAG_HAS_SMART_POWER_DOWN)
	416	&& spd)
	417	adapter->flags \|= FLAG_SMART_POWER_DOWN;
	418	}
	419	}
eb7c3adb	420	{ /* CRC Stripping */
6f59d660	421	static const struct e1000_option opt = {
eb7c3adb JK	422	.type = enable_option,
eb7c3adb JK	423	.name = "CRC Stripping",
e9262447	424	.err = "defaulting to Enabled",
eb7c3adb JK	425	.def = OPTION_ENABLED
	426	};
	427
	428	if (num_CrcStripping > bd) {
	429	unsigned int crc_stripping = CrcStripping[bd];
	430	e1000_validate_option(&crc_stripping, &opt, adapter);
	431	if (crc_stripping == OPTION_ENABLED)
	432	adapter->flags2 \|= FLAG2_CRC_STRIPPING;
6e50912a BA	433	} else {
6e50912a BA	434	adapter->flags2 \|= FLAG2_CRC_STRIPPING;
eb7c3adb JK	435	}
eb7c3adb JK	436	}
bc7f75fa	437	{ /* Kumeran Lock Loss Workaround */
6f59d660	438	static const struct e1000_option opt = {
bc7f75fa AK	439	.type = enable_option,
	440	.name = "Kumeran Lock Loss Workaround",
	441	.err = "defaulting to Enabled",
	442	.def = OPTION_ENABLED
	443	};
	444
	445	if (num_KumeranLockLoss > bd) {
5a9147bb	446	unsigned int kmrn_lock_loss = KumeranLockLoss[bd];
bc7f75fa AK	447	e1000_validate_option(&kmrn_lock_loss, &opt, adapter);
	448	if (hw->mac.type == e1000_ich8lan)
	449	e1000e_set_kmrn_lock_loss_workaround_ich8lan(hw,
	450	kmrn_lock_loss);
	451	} else {
	452	if (hw->mac.type == e1000_ich8lan)
	453	e1000e_set_kmrn_lock_loss_workaround_ich8lan(hw,
	454	opt.def);
	455	}
	456	}
4a770358	457	{ /* Write-protect NVM */
6f59d660	458	static const struct e1000_option opt = {
4a770358 BA	459	.type = enable_option,
	460	.name = "Write-protect NVM",
	461	.err = "defaulting to Enabled",
	462	.def = OPTION_ENABLED
	463	};
	464
	465	if (adapter->flags & FLAG_IS_ICH) {
	466	if (num_WriteProtectNVM > bd) {
	467	unsigned int write_protect_nvm = WriteProtectNVM[bd];
	468	e1000_validate_option(&write_protect_nvm, &opt,
	469	adapter);
	470	if (write_protect_nvm)
	471	adapter->flags \|= FLAG_READ_ONLY_NVM;
	472	} else {
	473	if (opt.def)
	474	adapter->flags \|= FLAG_READ_ONLY_NVM;
	475	}
	476	}
	477	}
bc7f75fa	478	}