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