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 struct { /* range_option info */
168 struct { /* list_option info */
170 struct e1000_opt_list
{ int i
; char *str
; } *p
;
175 static int e1000_validate_option(unsigned int *value
,
176 const struct e1000_option
*opt
,
177 struct e1000_adapter
*adapter
)
179 if (*value
== OPTION_UNSET
) {
188 dev_info(&adapter
->pdev
->dev
, "%s Enabled\n",
191 case OPTION_DISABLED
:
192 dev_info(&adapter
->pdev
->dev
, "%s Disabled\n",
198 if (*value
>= opt
->arg
.r
.min
&& *value
<= opt
->arg
.r
.max
) {
199 dev_info(&adapter
->pdev
->dev
, "%s set to %i\n",
206 struct e1000_opt_list
*ent
;
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",
223 dev_info(&adapter
->pdev
->dev
, "Invalid %s value specified (%i) %s\n",
224 opt
->name
, *value
, opt
->err
);
230 * e1000e_check_options - Range Checking for Command Line Parameters
231 * @adapter: board private structure
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.
238 void e1000e_check_options(struct e1000_adapter
*adapter
)
240 struct e1000_hw
*hw
= &adapter
->hw
;
241 int bd
= adapter
->bd_number
;
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");
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
),
257 .arg
= { .r
= { .min
= MIN_TXDELAY
,
258 .max
= MAX_TXDELAY
} }
261 if (num_TxIntDelay
> bd
) {
262 adapter
->tx_int_delay
= TxIntDelay
[bd
];
263 e1000_validate_option(&adapter
->tx_int_delay
, &opt
,
266 adapter
->tx_int_delay
= opt
.def
;
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
),
276 .arg
= { .r
= { .min
= MIN_TXABSDELAY
,
277 .max
= MAX_TXABSDELAY
} }
280 if (num_TxAbsIntDelay
> bd
) {
281 adapter
->tx_abs_int_delay
= TxAbsIntDelay
[bd
];
282 e1000_validate_option(&adapter
->tx_abs_int_delay
, &opt
,
285 adapter
->tx_abs_int_delay
= opt
.def
;
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
),
295 .arg
= { .r
= { .min
= MIN_RXDELAY
,
296 .max
= MAX_RXDELAY
} }
299 if (num_RxIntDelay
> bd
) {
300 adapter
->rx_int_delay
= RxIntDelay
[bd
];
301 e1000_validate_option(&adapter
->rx_int_delay
, &opt
,
304 adapter
->rx_int_delay
= opt
.def
;
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
),
314 .arg
= { .r
= { .min
= MIN_RXABSDELAY
,
315 .max
= MAX_RXABSDELAY
} }
318 if (num_RxAbsIntDelay
> bd
) {
319 adapter
->rx_abs_int_delay
= RxAbsIntDelay
[bd
];
320 e1000_validate_option(&adapter
->rx_abs_int_delay
, &opt
,
323 adapter
->rx_abs_int_delay
= opt
.def
;
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
),
333 .arg
= { .r
= { .min
= MIN_ITR
,
337 if (num_InterruptThrottleRate
> bd
) {
338 adapter
->itr
= InterruptThrottleRate
[bd
];
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
345 if ((adapter
->itr
> 4) &&
346 e1000_validate_option(&adapter
->itr
, &opt
, adapter
))
347 adapter
->itr
= opt
.def
;
349 /* If no option specified, use default value and go
350 * through the logic below to adjust itr/itr_setting
352 adapter
->itr
= opt
.def
;
354 /* Make sure a message is printed for non-special
357 if (adapter
->itr
> 4)
358 dev_info(&adapter
->pdev
->dev
,
359 "%s set to default %d\n", opt
.name
,
363 adapter
->itr_setting
= adapter
->itr
;
364 switch (adapter
->itr
) {
366 dev_info(&adapter
->pdev
->dev
, "%s turned off\n",
370 dev_info(&adapter
->pdev
->dev
,
371 "%s set to dynamic mode\n", opt
.name
);
372 adapter
->itr
= 20000;
375 dev_info(&adapter
->pdev
->dev
,
376 "%s set to dynamic conservative mode\n",
378 adapter
->itr
= 20000;
381 dev_info(&adapter
->pdev
->dev
,
382 "%s set to simplified (2000-8000 ints) mode\n",
386 /* Save the setting, because the dynamic bits
389 * Clear the lower two bits because
390 * they are used as control.
392 adapter
->itr_setting
&= ~3;
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,
408 #ifdef CONFIG_PCI_MSI
409 if (adapter
->flags
& FLAG_HAS_MSIX
) {
410 opt
.err
= kstrdup("defaulting to 2 (MSI-X)",
412 opt
.def
= E1000E_INT_MODE_MSIX
;
413 opt
.arg
.r
.max
= E1000E_INT_MODE_MSIX
;
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
;
421 dev_err(&adapter
->pdev
->dev
,
422 "Failed to allocate memory\n");
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
;
432 adapter
->int_mode
= opt
.def
;
435 #ifdef CONFIG_PCI_MSI
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
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
) && spd
)
451 adapter
->flags
|= FLAG_SMART_POWER_DOWN
;
454 { /* CRC Stripping */
455 static const struct e1000_option opt
= {
456 .type
= enable_option
,
457 .name
= "CRC Stripping",
458 .err
= "defaulting to Enabled",
459 .def
= OPTION_ENABLED
462 if (num_CrcStripping
> bd
) {
463 unsigned int crc_stripping
= CrcStripping
[bd
];
464 e1000_validate_option(&crc_stripping
, &opt
, adapter
);
465 if (crc_stripping
== OPTION_ENABLED
) {
466 adapter
->flags2
|= FLAG2_CRC_STRIPPING
;
467 adapter
->flags2
|= FLAG2_DFLT_CRC_STRIPPING
;
470 adapter
->flags2
|= FLAG2_CRC_STRIPPING
;
471 adapter
->flags2
|= FLAG2_DFLT_CRC_STRIPPING
;
474 { /* Kumeran Lock Loss Workaround */
475 static const struct e1000_option opt
= {
476 .type
= enable_option
,
477 .name
= "Kumeran Lock Loss Workaround",
478 .err
= "defaulting to Enabled",
479 .def
= OPTION_ENABLED
482 if (num_KumeranLockLoss
> bd
) {
483 unsigned int kmrn_lock_loss
= KumeranLockLoss
[bd
];
484 e1000_validate_option(&kmrn_lock_loss
, &opt
, adapter
);
485 if (hw
->mac
.type
== e1000_ich8lan
)
486 e1000e_set_kmrn_lock_loss_workaround_ich8lan(hw
,
489 if (hw
->mac
.type
== e1000_ich8lan
)
490 e1000e_set_kmrn_lock_loss_workaround_ich8lan(hw
,
494 { /* Write-protect NVM */
495 static const struct e1000_option opt
= {
496 .type
= enable_option
,
497 .name
= "Write-protect NVM",
498 .err
= "defaulting to Enabled",
499 .def
= OPTION_ENABLED
502 if (adapter
->flags
& FLAG_IS_ICH
) {
503 if (num_WriteProtectNVM
> bd
) {
504 unsigned int write_protect_nvm
=
506 e1000_validate_option(&write_protect_nvm
, &opt
,
508 if (write_protect_nvm
)
509 adapter
->flags
|= FLAG_READ_ONLY_NVM
;
512 adapter
->flags
|= FLAG_READ_ONLY_NVM
;