Loading...
Note: File does not exist in v6.8.
1/*******************************************************************************
2
3 Intel PRO/1000 Linux driver
4 Copyright(c) 1999 - 2011 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/pci.h>
31
32#include "e1000.h"
33
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
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
46unsigned int copybreak = COPYBREAK_DEFAULT;
47module_param(copybreak, uint, 0644);
48MODULE_PARM_DESC(copybreak,
49 "Maximum size of packet that is copied to a new buffer on receive");
50
51/*
52 * All parameters are treated the same, as an integer array of values.
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 }
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); \
63 MODULE_PARM_DESC(X, desc);
64
65/*
66 * Transmit Interrupt Delay in units of 1.024 microseconds
67 * Tx interrupt delay needs to typically be set to something non-zero
68 *
69 * Valid Range: 0-65535
70 */
71E1000_PARAM(TxIntDelay, "Transmit Interrupt Delay");
72#define DEFAULT_TIDV 8
73#define MAX_TXDELAY 0xFFFF
74#define MIN_TXDELAY 0
75
76/*
77 * Transmit Absolute Interrupt Delay in units of 1.024 microseconds
78 *
79 * Valid Range: 0-65535
80 */
81E1000_PARAM(TxAbsIntDelay, "Transmit Absolute Interrupt Delay");
82#define DEFAULT_TADV 32
83#define MAX_TXABSDELAY 0xFFFF
84#define MIN_TXABSDELAY 0
85
86/*
87 * Receive Interrupt Delay in units of 1.024 microseconds
88 * hardware will likely hang if you set this to anything but zero.
89 *
90 * Valid Range: 0-65535
91 */
92E1000_PARAM(RxIntDelay, "Receive Interrupt Delay");
93#define MAX_RXDELAY 0xFFFF
94#define MIN_RXDELAY 0
95
96/*
97 * Receive Absolute Interrupt Delay in units of 1.024 microseconds
98 *
99 * Valid Range: 0-65535
100 */
101E1000_PARAM(RxAbsIntDelay, "Receive Absolute Interrupt Delay");
102#define MAX_RXABSDELAY 0xFFFF
103#define MIN_RXABSDELAY 0
104
105/*
106 * Interrupt Throttle Rate (interrupts/sec)
107 *
108 * Valid Range: 100-100000 (0=off, 1=dynamic, 3=dynamic conservative)
109 */
110E1000_PARAM(InterruptThrottleRate, "Interrupt Throttling Rate");
111#define DEFAULT_ITR 3
112#define MAX_ITR 100000
113#define MIN_ITR 100
114
115/* IntMode (Interrupt Mode)
116 *
117 * Valid Range: 0 - 2
118 *
119 * Default Value: 2 (MSI-X)
120 */
121E1000_PARAM(IntMode, "Interrupt Mode");
122#define MAX_INTMODE 2
123#define MIN_INTMODE 0
124
125/*
126 * Enable Smart Power Down of the PHY
127 *
128 * Valid Range: 0, 1
129 *
130 * Default Value: 0 (disabled)
131 */
132E1000_PARAM(SmartPowerDownEnable, "Enable PHY smart power down");
133
134/*
135 * Enable Kumeran Lock Loss workaround
136 *
137 * Valid Range: 0, 1
138 *
139 * Default Value: 1 (enabled)
140 */
141E1000_PARAM(KumeranLockLoss, "Enable Kumeran lock loss workaround");
142
143/*
144 * Write Protect NVM
145 *
146 * Valid Range: 0, 1
147 *
148 * Default Value: 1 (enabled)
149 */
150E1000_PARAM(WriteProtectNVM, "Write-protect NVM [WARNING: disabling this can lead to corrupted NVM]");
151
152/*
153 * Enable CRC Stripping
154 *
155 * Valid Range: 0, 1
156 *
157 * Default Value: 1 (enabled)
158 */
159E1000_PARAM(CrcStripping, "Enable CRC Stripping, disable if your BMC needs " \
160 "the CRC");
161
162struct e1000_option {
163 enum { enable_option, range_option, list_option } type;
164 const char *name;
165 const char *err;
166 int def;
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
179static int __devinit e1000_validate_option(unsigned int *value,
180 const struct e1000_option *opt,
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:
192 e_info("%s Enabled\n", opt->name);
193 return 0;
194 case OPTION_DISABLED:
195 e_info("%s Disabled\n", opt->name);
196 return 0;
197 }
198 break;
199 case range_option:
200 if (*value >= opt->arg.r.min && *value <= opt->arg.r.max) {
201 e_info("%s set to %i\n", opt->name, *value);
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')
213 e_info("%s\n", ent->str);
214 return 0;
215 }
216 }
217 }
218 break;
219 default:
220 BUG();
221 }
222
223 e_info("Invalid %s value specified (%i) %s\n", opt->name, *value,
224 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 **/
238void __devinit 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 e_notice("Warning: no configuration for board #%i\n", bd);
245 e_notice("Using defaults for all values\n");
246 }
247
248 { /* Transmit Interrupt Delay */
249 static const struct e1000_option opt = {
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 */
268 static const struct e1000_option opt = {
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 */
287 static struct e1000_option opt = {
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
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 */
306 static const struct e1000_option opt = {
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 */
325 static const struct e1000_option opt = {
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:
339 e_info("%s turned off\n", opt.name);
340 break;
341 case 1:
342 e_info("%s set to dynamic mode\n", opt.name);
343 adapter->itr_setting = adapter->itr;
344 adapter->itr = 20000;
345 break;
346 case 3:
347 e_info("%s set to dynamic conservative mode\n",
348 opt.name);
349 adapter->itr_setting = adapter->itr;
350 adapter->itr = 20000;
351 break;
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;
357 default:
358 /*
359 * Save the setting, because the dynamic bits
360 * change itr.
361 */
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 }
379 break;
380 }
381 } else {
382 adapter->itr_setting = opt.def;
383 adapter->itr = 20000;
384 }
385 }
386 { /* Interrupt Mode */
387 static struct e1000_option opt = {
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 }
404 { /* Smart Power Down */
405 static const struct e1000_option opt = {
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) {
413 unsigned int spd = SmartPowerDownEnable[bd];
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 }
420 { /* CRC Stripping */
421 static const struct e1000_option opt = {
422 .type = enable_option,
423 .name = "CRC Stripping",
424 .err = "defaulting to Enabled",
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;
433 } else {
434 adapter->flags2 |= FLAG2_CRC_STRIPPING;
435 }
436 }
437 { /* Kumeran Lock Loss Workaround */
438 static const struct e1000_option opt = {
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) {
446 unsigned int kmrn_lock_loss = KumeranLockLoss[bd];
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 }
457 { /* Write-protect NVM */
458 static const struct e1000_option opt = {
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 }
478}