1 /*******************************************************************************
3 Intel PRO/1000 Linux driver
4 Copyright(c) 1999 - 2013 Intel Corporation.
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.
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
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.
19 The full GNU General Public License is included in this distribution in
20 the file called "COPYING".
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
27 *******************************************************************************/
29 #include <linux/netdevice.h>
30 #include <linux/module.h>
31 #include <linux/pci.h>
35 /* This is the only thing that needs to be changed to adjust the
36 * maximum number of ports that the driver can manage.
38 #define E1000_MAX_NIC 32
40 #define OPTION_UNSET -1
41 #define OPTION_DISABLED 0
42 #define OPTION_ENABLED 1
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");
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).
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] = E1000_PARAM_INIT; \
57 static unsigned int num_##X; \
58 module_param_array_named(X, X, int, &num_##X, 0); \
59 MODULE_PARM_DESC(X, desc);
61 /* Transmit Interrupt Delay in units of 1.024 microseconds
62 * Tx interrupt delay needs to typically be set to something non-zero
64 * Valid Range: 0-65535
66 E1000_PARAM(TxIntDelay, "Transmit Interrupt Delay");
67 #define DEFAULT_TIDV 8
68 #define MAX_TXDELAY 0xFFFF
71 /* Transmit Absolute Interrupt Delay in units of 1.024 microseconds
73 * Valid Range: 0-65535
75 E1000_PARAM(TxAbsIntDelay, "Transmit Absolute Interrupt Delay");
76 #define DEFAULT_TADV 32
77 #define MAX_TXABSDELAY 0xFFFF
78 #define MIN_TXABSDELAY 0
80 /* Receive Interrupt Delay in units of 1.024 microseconds
81 * hardware will likely hang if you set this to anything but zero.
83 * Valid Range: 0-65535
85 E1000_PARAM(RxIntDelay, "Receive Interrupt Delay");
86 #define MAX_RXDELAY 0xFFFF
89 /* Receive Absolute Interrupt Delay in units of 1.024 microseconds
91 * Valid Range: 0-65535
93 E1000_PARAM(RxAbsIntDelay, "Receive Absolute Interrupt Delay");
94 #define MAX_RXABSDELAY 0xFFFF
95 #define MIN_RXABSDELAY 0
97 /* Interrupt Throttle Rate (interrupts/sec)
99 * Valid Range: 100-100000 or one of: 0=off, 1=dynamic, 3=dynamic conservative
101 E1000_PARAM(InterruptThrottleRate, "Interrupt Throttling Rate");
102 #define DEFAULT_ITR 3
103 #define MAX_ITR 100000
106 /* IntMode (Interrupt Mode)
108 * Valid Range: varies depending on kernel configuration & hardware support
110 * legacy=0, MSI=1, MSI-X=2
112 * When MSI/MSI-X support is enabled in kernel-
113 * Default Value: 2 (MSI-X) when supported by hardware, 1 (MSI) otherwise
114 * When MSI/MSI-X support is not enabled in kernel-
115 * Default Value: 0 (legacy)
117 * When a mode is specified that is not allowed/supported, it will be
118 * demoted to the most advanced interrupt mode available.
120 E1000_PARAM(IntMode, "Interrupt Mode");
121 #define MAX_INTMODE 2
122 #define MIN_INTMODE 0
124 /* Enable Smart Power Down of the PHY
128 * Default Value: 0 (disabled)
130 E1000_PARAM(SmartPowerDownEnable, "Enable PHY smart power down");
132 /* Enable Kumeran Lock Loss workaround
136 * Default Value: 1 (enabled)
138 E1000_PARAM(KumeranLockLoss, "Enable Kumeran lock loss workaround");
144 * Default Value: 1 (enabled)
146 E1000_PARAM(WriteProtectNVM,
147 "Write-protect NVM [WARNING: disabling this can lead to corrupted NVM]");
149 /* Enable CRC Stripping
153 * Default Value: 1 (enabled)
155 E1000_PARAM(CrcStripping,
156 "Enable CRC Stripping, disable if your BMC needs the CRC");
158 struct e1000_option {
159 enum { enable_option, range_option, list_option } type;
164 /* range_option info */
169 /* list_option info */
172 struct e1000_opt_list {
180 static int e1000_validate_option(unsigned int *value,
181 const struct e1000_option *opt,
182 struct e1000_adapter *adapter)
184 if (*value == OPTION_UNSET) {
193 dev_info(&adapter->pdev->dev, "%s Enabled\n",
196 case OPTION_DISABLED:
197 dev_info(&adapter->pdev->dev, "%s Disabled\n",
203 if (*value >= opt->arg.r.min && *value <= opt->arg.r.max) {
204 dev_info(&adapter->pdev->dev, "%s set to %i\n",
211 struct e1000_opt_list *ent;
213 for (i = 0; i < opt->arg.l.nr; i++) {
214 ent = &opt->arg.l.p[i];
215 if (*value == ent->i) {
216 if (ent->str[0] != '\0')
217 dev_info(&adapter->pdev->dev, "%s\n",
228 dev_info(&adapter->pdev->dev, "Invalid %s value specified (%i) %s\n",
229 opt->name, *value, opt->err);
235 * e1000e_check_options - Range Checking for Command Line Parameters
236 * @adapter: board private structure
238 * This routine checks all command line parameters for valid user
239 * input. If an invalid value is given, or if no user specified
240 * value exists, a default value is used. The final value is stored
241 * in a variable in the adapter structure.
243 void e1000e_check_options(struct e1000_adapter *adapter)
245 struct e1000_hw *hw = &adapter->hw;
246 int bd = adapter->bd_number;
248 if (bd >= E1000_MAX_NIC) {
249 dev_notice(&adapter->pdev->dev,
250 "Warning: no configuration for board #%i\n", bd);
251 dev_notice(&adapter->pdev->dev,
252 "Using defaults for all values\n");
255 /* Transmit Interrupt Delay */
257 static const struct e1000_option opt = {
258 .type = range_option,
259 .name = "Transmit Interrupt Delay",
260 .err = "using default of "
261 __MODULE_STRING(DEFAULT_TIDV),
263 .arg = { .r = { .min = MIN_TXDELAY,
264 .max = MAX_TXDELAY } }
267 if (num_TxIntDelay > bd) {
268 adapter->tx_int_delay = TxIntDelay[bd];
269 e1000_validate_option(&adapter->tx_int_delay, &opt,
272 adapter->tx_int_delay = opt.def;
275 /* Transmit Absolute Interrupt Delay */
277 static const struct e1000_option opt = {
278 .type = range_option,
279 .name = "Transmit Absolute Interrupt Delay",
280 .err = "using default of "
281 __MODULE_STRING(DEFAULT_TADV),
283 .arg = { .r = { .min = MIN_TXABSDELAY,
284 .max = MAX_TXABSDELAY } }
287 if (num_TxAbsIntDelay > bd) {
288 adapter->tx_abs_int_delay = TxAbsIntDelay[bd];
289 e1000_validate_option(&adapter->tx_abs_int_delay, &opt,
292 adapter->tx_abs_int_delay = opt.def;
295 /* Receive Interrupt Delay */
297 static struct e1000_option opt = {
298 .type = range_option,
299 .name = "Receive Interrupt Delay",
300 .err = "using default of "
301 __MODULE_STRING(DEFAULT_RDTR),
303 .arg = { .r = { .min = MIN_RXDELAY,
304 .max = MAX_RXDELAY } }
307 if (num_RxIntDelay > bd) {
308 adapter->rx_int_delay = RxIntDelay[bd];
309 e1000_validate_option(&adapter->rx_int_delay, &opt,
312 adapter->rx_int_delay = opt.def;
315 /* Receive Absolute Interrupt Delay */
317 static const struct e1000_option opt = {
318 .type = range_option,
319 .name = "Receive Absolute Interrupt Delay",
320 .err = "using default of "
321 __MODULE_STRING(DEFAULT_RADV),
323 .arg = { .r = { .min = MIN_RXABSDELAY,
324 .max = MAX_RXABSDELAY } }
327 if (num_RxAbsIntDelay > bd) {
328 adapter->rx_abs_int_delay = RxAbsIntDelay[bd];
329 e1000_validate_option(&adapter->rx_abs_int_delay, &opt,
332 adapter->rx_abs_int_delay = opt.def;
335 /* Interrupt Throttling Rate */
337 static const struct e1000_option opt = {
338 .type = range_option,
339 .name = "Interrupt Throttling Rate (ints/sec)",
340 .err = "using default of "
341 __MODULE_STRING(DEFAULT_ITR),
343 .arg = { .r = { .min = MIN_ITR,
347 if (num_InterruptThrottleRate > bd) {
348 adapter->itr = InterruptThrottleRate[bd];
350 /* Make sure a message is printed for non-special
351 * values. And in case of an invalid option, display
352 * warning, use default and go through itr/itr_setting
353 * adjustment logic below
355 if ((adapter->itr > 4) &&
356 e1000_validate_option(&adapter->itr, &opt, adapter))
357 adapter->itr = opt.def;
359 /* If no option specified, use default value and go
360 * through the logic below to adjust itr/itr_setting
362 adapter->itr = opt.def;
364 /* Make sure a message is printed for non-special
367 if (adapter->itr > 4)
368 dev_info(&adapter->pdev->dev,
369 "%s set to default %d\n", opt.name,
373 adapter->itr_setting = adapter->itr;
374 switch (adapter->itr) {
376 dev_info(&adapter->pdev->dev, "%s turned off\n",
380 dev_info(&adapter->pdev->dev,
381 "%s set to dynamic mode\n", opt.name);
382 adapter->itr = 20000;
385 dev_info(&adapter->pdev->dev,
386 "%s set to dynamic conservative mode\n",
388 adapter->itr = 20000;
391 dev_info(&adapter->pdev->dev,
392 "%s set to simplified (2000-8000 ints) mode\n",
396 /* Save the setting, because the dynamic bits
399 * Clear the lower two bits because
400 * they are used as control.
402 adapter->itr_setting &= ~3;
408 static struct e1000_option opt = {
409 .type = range_option,
410 .name = "Interrupt Mode",
411 #ifndef CONFIG_PCI_MSI
412 .err = "defaulting to 0 (legacy)",
413 .def = E1000E_INT_MODE_LEGACY,
414 .arg = { .r = { .min = 0,
419 #ifdef CONFIG_PCI_MSI
420 if (adapter->flags & FLAG_HAS_MSIX) {
421 opt.err = kstrdup("defaulting to 2 (MSI-X)",
423 opt.def = E1000E_INT_MODE_MSIX;
424 opt.arg.r.max = E1000E_INT_MODE_MSIX;
426 opt.err = kstrdup("defaulting to 1 (MSI)", GFP_KERNEL);
427 opt.def = E1000E_INT_MODE_MSI;
428 opt.arg.r.max = E1000E_INT_MODE_MSI;
432 dev_err(&adapter->pdev->dev,
433 "Failed to allocate memory\n");
438 if (num_IntMode > bd) {
439 unsigned int int_mode = IntMode[bd];
440 e1000_validate_option(&int_mode, &opt, adapter);
441 adapter->int_mode = int_mode;
443 adapter->int_mode = opt.def;
446 #ifdef CONFIG_PCI_MSI
450 /* Smart Power Down */
452 static const struct e1000_option opt = {
453 .type = enable_option,
454 .name = "PHY Smart Power Down",
455 .err = "defaulting to Disabled",
456 .def = OPTION_DISABLED
459 if (num_SmartPowerDownEnable > bd) {
460 unsigned int spd = SmartPowerDownEnable[bd];
461 e1000_validate_option(&spd, &opt, adapter);
462 if ((adapter->flags & FLAG_HAS_SMART_POWER_DOWN) && spd)
463 adapter->flags |= FLAG_SMART_POWER_DOWN;
468 static const struct e1000_option opt = {
469 .type = enable_option,
470 .name = "CRC Stripping",
471 .err = "defaulting to Enabled",
472 .def = OPTION_ENABLED
475 if (num_CrcStripping > bd) {
476 unsigned int crc_stripping = CrcStripping[bd];
477 e1000_validate_option(&crc_stripping, &opt, adapter);
478 if (crc_stripping == OPTION_ENABLED) {
479 adapter->flags2 |= FLAG2_CRC_STRIPPING;
480 adapter->flags2 |= FLAG2_DFLT_CRC_STRIPPING;
483 adapter->flags2 |= FLAG2_CRC_STRIPPING;
484 adapter->flags2 |= FLAG2_DFLT_CRC_STRIPPING;
487 /* Kumeran Lock Loss Workaround */
489 static const struct e1000_option opt = {
490 .type = enable_option,
491 .name = "Kumeran Lock Loss Workaround",
492 .err = "defaulting to Enabled",
493 .def = OPTION_ENABLED
495 bool enabled = opt.def;
497 if (num_KumeranLockLoss > bd) {
498 unsigned int kmrn_lock_loss = KumeranLockLoss[bd];
499 e1000_validate_option(&kmrn_lock_loss, &opt, adapter);
500 enabled = kmrn_lock_loss;
503 if (hw->mac.type == e1000_ich8lan)
504 e1000e_set_kmrn_lock_loss_workaround_ich8lan(hw,
507 /* Write-protect NVM */
509 static const struct e1000_option opt = {
510 .type = enable_option,
511 .name = "Write-protect NVM",
512 .err = "defaulting to Enabled",
513 .def = OPTION_ENABLED
516 if (adapter->flags & FLAG_IS_ICH) {
517 if (num_WriteProtectNVM > bd) {
518 unsigned int write_protect_nvm =
520 e1000_validate_option(&write_protect_nvm, &opt,
522 if (write_protect_nvm)
523 adapter->flags |= FLAG_READ_ONLY_NVM;
526 adapter->flags |= FLAG_READ_ONLY_NVM;