devices/e1000e/param-3.8-ethercat.c
branchstable-1.5
changeset 2584 0e3d989ff233
equal deleted inserted replaced
2583:fe5687a0a322 2584:0e3d989ff233
       
     1 /*******************************************************************************
       
     2 
       
     3   Intel PRO/1000 Linux driver
       
     4   Copyright(c) 1999 - 2012 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 <linux/netdevice.h>
       
    30 #include <linux/module.h>
       
    31 #include <linux/pci.h>
       
    32 
       
    33 #include "e1000-3.8-ethercat.h"
       
    34 
       
    35 /* This is the only thing that needs to be changed to adjust the
       
    36  * maximum number of ports that the driver can manage.
       
    37  */
       
    38 #define E1000_MAX_NIC 32
       
    39 
       
    40 #define OPTION_UNSET   -1
       
    41 #define OPTION_DISABLED 0
       
    42 #define OPTION_ENABLED  1
       
    43 
       
    44 #define COPYBREAK_DEFAULT 256
       
    45 unsigned int copybreak = COPYBREAK_DEFAULT;
       
    46 module_param(copybreak, uint, 0644);
       
    47 MODULE_PARM_DESC(copybreak,
       
    48 	"Maximum size of packet that is copied to a new buffer on receive");
       
    49 
       
    50 /* All parameters are treated the same, as an integer array of values.
       
    51  * This macro just reduces the need to repeat the same declaration code
       
    52  * over and over (plus this helps to avoid typo bugs).
       
    53  */
       
    54 #define E1000_PARAM_INIT { [0 ... E1000_MAX_NIC] = OPTION_UNSET }
       
    55 #define E1000_PARAM(X, desc)					\
       
    56 	static int X[E1000_MAX_NIC+1]		\
       
    57 		= E1000_PARAM_INIT;				\
       
    58 	static unsigned int num_##X;				\
       
    59 	module_param_array_named(X, X, int, &num_##X, 0);	\
       
    60 	MODULE_PARM_DESC(X, desc);
       
    61 
       
    62 /* Transmit Interrupt Delay in units of 1.024 microseconds
       
    63  * Tx interrupt delay needs to typically be set to something non-zero
       
    64  *
       
    65  * Valid Range: 0-65535
       
    66  */
       
    67 E1000_PARAM(TxIntDelay, "Transmit Interrupt Delay");
       
    68 #define DEFAULT_TIDV 8
       
    69 #define MAX_TXDELAY 0xFFFF
       
    70 #define MIN_TXDELAY 0
       
    71 
       
    72 /* Transmit Absolute Interrupt Delay in units of 1.024 microseconds
       
    73  *
       
    74  * Valid Range: 0-65535
       
    75  */
       
    76 E1000_PARAM(TxAbsIntDelay, "Transmit Absolute Interrupt Delay");
       
    77 #define DEFAULT_TADV 32
       
    78 #define MAX_TXABSDELAY 0xFFFF
       
    79 #define MIN_TXABSDELAY 0
       
    80 
       
    81 /* Receive Interrupt Delay in units of 1.024 microseconds
       
    82  * hardware will likely hang if you set this to anything but zero.
       
    83  *
       
    84  * Valid Range: 0-65535
       
    85  */
       
    86 E1000_PARAM(RxIntDelay, "Receive Interrupt Delay");
       
    87 #define MAX_RXDELAY 0xFFFF
       
    88 #define MIN_RXDELAY 0
       
    89 
       
    90 /* Receive Absolute Interrupt Delay in units of 1.024 microseconds
       
    91  *
       
    92  * Valid Range: 0-65535
       
    93  */
       
    94 E1000_PARAM(RxAbsIntDelay, "Receive Absolute Interrupt Delay");
       
    95 #define MAX_RXABSDELAY 0xFFFF
       
    96 #define MIN_RXABSDELAY 0
       
    97 
       
    98 /* Interrupt Throttle Rate (interrupts/sec)
       
    99  *
       
   100  * Valid Range: 100-100000 or one of: 0=off, 1=dynamic, 3=dynamic conservative
       
   101  */
       
   102 E1000_PARAM(InterruptThrottleRate, "Interrupt Throttling Rate");
       
   103 #define DEFAULT_ITR 3
       
   104 #define MAX_ITR 100000
       
   105 #define MIN_ITR 100
       
   106 
       
   107 /* IntMode (Interrupt Mode)
       
   108  *
       
   109  * Valid Range: varies depending on kernel configuration & hardware support
       
   110  *
       
   111  * legacy=0, MSI=1, MSI-X=2
       
   112  *
       
   113  * When MSI/MSI-X support is enabled in kernel-
       
   114  *   Default Value: 2 (MSI-X) when supported by hardware, 1 (MSI) otherwise
       
   115  * When MSI/MSI-X support is not enabled in kernel-
       
   116  *   Default Value: 0 (legacy)
       
   117  *
       
   118  * When a mode is specified that is not allowed/supported, it will be
       
   119  * demoted to the most advanced interrupt mode available.
       
   120  */
       
   121 E1000_PARAM(IntMode, "Interrupt Mode");
       
   122 #define MAX_INTMODE	2
       
   123 #define MIN_INTMODE	0
       
   124 
       
   125 /* Enable Smart Power Down of the PHY
       
   126  *
       
   127  * Valid Range: 0, 1
       
   128  *
       
   129  * Default Value: 0 (disabled)
       
   130  */
       
   131 E1000_PARAM(SmartPowerDownEnable, "Enable PHY smart power down");
       
   132 
       
   133 /* Enable Kumeran Lock Loss workaround
       
   134  *
       
   135  * Valid Range: 0, 1
       
   136  *
       
   137  * Default Value: 1 (enabled)
       
   138  */
       
   139 E1000_PARAM(KumeranLockLoss, "Enable Kumeran lock loss workaround");
       
   140 
       
   141 /* Write Protect NVM
       
   142  *
       
   143  * Valid Range: 0, 1
       
   144  *
       
   145  * Default Value: 1 (enabled)
       
   146  */
       
   147 E1000_PARAM(WriteProtectNVM, "Write-protect NVM [WARNING: disabling this can lead to corrupted NVM]");
       
   148 
       
   149 /* Enable CRC Stripping
       
   150  *
       
   151  * Valid Range: 0, 1
       
   152  *
       
   153  * Default Value: 1 (enabled)
       
   154  */
       
   155 E1000_PARAM(CrcStripping,
       
   156 	    "Enable CRC Stripping, disable if your BMC needs the CRC");
       
   157 
       
   158 struct e1000_option {
       
   159 	enum { enable_option, range_option, list_option } type;
       
   160 	const char *name;
       
   161 	const char *err;
       
   162 	int def;
       
   163 	union {
       
   164 		struct { /* range_option info */
       
   165 			int min;
       
   166 			int max;
       
   167 		} r;
       
   168 		struct { /* list_option info */
       
   169 			int nr;
       
   170 			struct e1000_opt_list { int i; char *str; } *p;
       
   171 		} l;
       
   172 	} arg;
       
   173 };
       
   174 
       
   175 static int e1000_validate_option(unsigned int *value,
       
   176 				 const struct e1000_option *opt,
       
   177 				 struct e1000_adapter *adapter)
       
   178 {
       
   179 	if (*value == OPTION_UNSET) {
       
   180 		*value = opt->def;
       
   181 		return 0;
       
   182 	}
       
   183 
       
   184 	switch (opt->type) {
       
   185 	case enable_option:
       
   186 		switch (*value) {
       
   187 		case OPTION_ENABLED:
       
   188 			dev_info(&adapter->pdev->dev, "%s Enabled\n",
       
   189 				 opt->name);
       
   190 			return 0;
       
   191 		case OPTION_DISABLED:
       
   192 			dev_info(&adapter->pdev->dev, "%s Disabled\n",
       
   193 				 opt->name);
       
   194 			return 0;
       
   195 		}
       
   196 		break;
       
   197 	case range_option:
       
   198 		if (*value >= opt->arg.r.min && *value <= opt->arg.r.max) {
       
   199 			dev_info(&adapter->pdev->dev, "%s set to %i\n",
       
   200 				 opt->name, *value);
       
   201 			return 0;
       
   202 		}
       
   203 		break;
       
   204 	case list_option: {
       
   205 		int i;
       
   206 		struct e1000_opt_list *ent;
       
   207 
       
   208 		for (i = 0; i < opt->arg.l.nr; i++) {
       
   209 			ent = &opt->arg.l.p[i];
       
   210 			if (*value == ent->i) {
       
   211 				if (ent->str[0] != '\0')
       
   212 					dev_info(&adapter->pdev->dev, "%s\n",
       
   213 						 ent->str);
       
   214 				return 0;
       
   215 			}
       
   216 		}
       
   217 	}
       
   218 		break;
       
   219 	default:
       
   220 		BUG();
       
   221 	}
       
   222 
       
   223 	dev_info(&adapter->pdev->dev, "Invalid %s value specified (%i) %s\n",
       
   224 		 opt->name, *value, opt->err);
       
   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 e1000e_check_options(struct e1000_adapter *adapter)
       
   239 {
       
   240 	struct e1000_hw *hw = &adapter->hw;
       
   241 	int bd = adapter->bd_number;
       
   242 
       
   243 	if (bd >= E1000_MAX_NIC) {
       
   244 		dev_notice(&adapter->pdev->dev,
       
   245 			   "Warning: no configuration for board #%i\n", bd);
       
   246 		dev_notice(&adapter->pdev->dev,
       
   247 			   "Using defaults for all values\n");
       
   248 	}
       
   249 
       
   250 	{ /* Transmit Interrupt Delay */
       
   251 		static const struct e1000_option opt = {
       
   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 */
       
   270 		static const struct e1000_option opt = {
       
   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 		static 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 
       
   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 */
       
   308 		static const struct e1000_option opt = {
       
   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 */
       
   327 		static const struct e1000_option opt = {
       
   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 
       
   340 			/* Make sure a message is printed for non-special
       
   341 			 * values. And in case of an invalid option, display
       
   342 			 * warning, use default and go through itr/itr_setting
       
   343 			 * adjustment logic below
       
   344 			 */
       
   345 			if ((adapter->itr > 4) &&
       
   346 			    e1000_validate_option(&adapter->itr, &opt, adapter))
       
   347 				adapter->itr = opt.def;
       
   348 		} else {
       
   349 			/* If no option specified, use default value and go
       
   350 			 * through the logic below to adjust itr/itr_setting
       
   351 			 */
       
   352 			adapter->itr = opt.def;
       
   353 
       
   354 			/* Make sure a message is printed for non-special
       
   355 			 * default values
       
   356 			 */
       
   357 			if (adapter->itr > 4)
       
   358 				dev_info(&adapter->pdev->dev,
       
   359 					 "%s set to default %d\n", opt.name,
       
   360 					 adapter->itr);
       
   361 		}
       
   362 
       
   363 		adapter->itr_setting = adapter->itr;
       
   364 		switch (adapter->itr) {
       
   365 		case 0:
       
   366 			dev_info(&adapter->pdev->dev, "%s turned off\n",
       
   367 				 opt.name);
       
   368 			break;
       
   369 		case 1:
       
   370 			dev_info(&adapter->pdev->dev,
       
   371 				 "%s set to dynamic mode\n", opt.name);
       
   372 			adapter->itr = 20000;
       
   373 			break;
       
   374 		case 3:
       
   375 			dev_info(&adapter->pdev->dev,
       
   376 				 "%s set to dynamic conservative mode\n",
       
   377 				 opt.name);
       
   378 			adapter->itr = 20000;
       
   379 			break;
       
   380 		case 4:
       
   381 			dev_info(&adapter->pdev->dev,
       
   382 				 "%s set to simplified (2000-8000 ints) mode\n",
       
   383 				 opt.name);
       
   384 			break;
       
   385 		default:
       
   386 			/* Save the setting, because the dynamic bits
       
   387 			 * change itr.
       
   388 			 *
       
   389 			 * Clear the lower two bits because
       
   390 			 * they are used as control.
       
   391 			 */
       
   392 			adapter->itr_setting &= ~3;
       
   393 			break;
       
   394 		}
       
   395 	}
       
   396 	{ /* Interrupt Mode */
       
   397 		static struct e1000_option opt = {
       
   398 			.type = range_option,
       
   399 			.name = "Interrupt Mode",
       
   400 #ifndef CONFIG_PCI_MSI
       
   401 			.err  = "defaulting to 0 (legacy)",
       
   402 			.def  = E1000E_INT_MODE_LEGACY,
       
   403 			.arg  = { .r = { .min = 0,
       
   404 					 .max = 0 } }
       
   405 #endif
       
   406 		};
       
   407 
       
   408 #ifdef CONFIG_PCI_MSI
       
   409 		if (adapter->flags & FLAG_HAS_MSIX) {
       
   410 			opt.err = kstrdup("defaulting to 2 (MSI-X)",
       
   411 					  GFP_KERNEL);
       
   412 			opt.def = E1000E_INT_MODE_MSIX;
       
   413 			opt.arg.r.max = E1000E_INT_MODE_MSIX;
       
   414 		} else {
       
   415 			opt.err = kstrdup("defaulting to 1 (MSI)", GFP_KERNEL);
       
   416 			opt.def = E1000E_INT_MODE_MSI;
       
   417 			opt.arg.r.max = E1000E_INT_MODE_MSI;
       
   418 		}
       
   419 
       
   420 		if (!opt.err) {
       
   421 			dev_err(&adapter->pdev->dev,
       
   422 				"Failed to allocate memory\n");
       
   423 			return;
       
   424 		}
       
   425 #endif
       
   426 
       
   427 		if (num_IntMode > bd) {
       
   428 			unsigned int int_mode = IntMode[bd];
       
   429 			e1000_validate_option(&int_mode, &opt, adapter);
       
   430 			adapter->int_mode = int_mode;
       
   431 		} else {
       
   432 			adapter->int_mode = opt.def;
       
   433 		}
       
   434 
       
   435 #ifdef CONFIG_PCI_MSI
       
   436 		kfree(opt.err);
       
   437 #endif
       
   438 	}
       
   439 	{ /* Smart Power Down */
       
   440 		static const struct e1000_option opt = {
       
   441 			.type = enable_option,
       
   442 			.name = "PHY Smart Power Down",
       
   443 			.err  = "defaulting to Disabled",
       
   444 			.def  = OPTION_DISABLED
       
   445 		};
       
   446 
       
   447 		if (num_SmartPowerDownEnable > bd) {
       
   448 			unsigned int spd = SmartPowerDownEnable[bd];
       
   449 			e1000_validate_option(&spd, &opt, adapter);
       
   450 			if ((adapter->flags & FLAG_HAS_SMART_POWER_DOWN)
       
   451 			    && spd)
       
   452 				adapter->flags |= FLAG_SMART_POWER_DOWN;
       
   453 		}
       
   454 	}
       
   455 	{ /* CRC Stripping */
       
   456 		static const struct e1000_option opt = {
       
   457 			.type = enable_option,
       
   458 			.name = "CRC Stripping",
       
   459 			.err  = "defaulting to Enabled",
       
   460 			.def  = OPTION_ENABLED
       
   461 		};
       
   462 
       
   463 		if (num_CrcStripping > bd) {
       
   464 			unsigned int crc_stripping = CrcStripping[bd];
       
   465 			e1000_validate_option(&crc_stripping, &opt, adapter);
       
   466 			if (crc_stripping == OPTION_ENABLED) {
       
   467 				adapter->flags2 |= FLAG2_CRC_STRIPPING;
       
   468 				adapter->flags2 |= FLAG2_DFLT_CRC_STRIPPING;
       
   469 			}
       
   470 		} else {
       
   471 			adapter->flags2 |= FLAG2_CRC_STRIPPING;
       
   472 			adapter->flags2 |= FLAG2_DFLT_CRC_STRIPPING;
       
   473 		}
       
   474 	}
       
   475 	{ /* Kumeran Lock Loss Workaround */
       
   476 		static const struct e1000_option opt = {
       
   477 			.type = enable_option,
       
   478 			.name = "Kumeran Lock Loss Workaround",
       
   479 			.err  = "defaulting to Enabled",
       
   480 			.def  = OPTION_ENABLED
       
   481 		};
       
   482 
       
   483 		if (num_KumeranLockLoss > bd) {
       
   484 			unsigned int kmrn_lock_loss = KumeranLockLoss[bd];
       
   485 			e1000_validate_option(&kmrn_lock_loss, &opt, adapter);
       
   486 			if (hw->mac.type == e1000_ich8lan)
       
   487 				e1000e_set_kmrn_lock_loss_workaround_ich8lan(hw,
       
   488 								kmrn_lock_loss);
       
   489 		} else {
       
   490 			if (hw->mac.type == e1000_ich8lan)
       
   491 				e1000e_set_kmrn_lock_loss_workaround_ich8lan(hw,
       
   492 								       opt.def);
       
   493 		}
       
   494 	}
       
   495 	{ /* Write-protect NVM */
       
   496 		static const struct e1000_option opt = {
       
   497 			.type = enable_option,
       
   498 			.name = "Write-protect NVM",
       
   499 			.err  = "defaulting to Enabled",
       
   500 			.def  = OPTION_ENABLED
       
   501 		};
       
   502 
       
   503 		if (adapter->flags & FLAG_IS_ICH) {
       
   504 			if (num_WriteProtectNVM > bd) {
       
   505 				unsigned int write_protect_nvm = WriteProtectNVM[bd];
       
   506 				e1000_validate_option(&write_protect_nvm, &opt,
       
   507 						      adapter);
       
   508 				if (write_protect_nvm)
       
   509 					adapter->flags |= FLAG_READ_ONLY_NVM;
       
   510 			} else {
       
   511 				if (opt.def)
       
   512 					adapter->flags |= FLAG_READ_ONLY_NVM;
       
   513 			}
       
   514 		}
       
   515 	}
       
   516 }