1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* Copyright(c) 1999 - 2018 Intel Corporation. */ |
3 | |
4 | #include <linux/netdevice.h> |
5 | #include <linux/module.h> |
6 | #include <linux/pci.h> |
7 | |
8 | #include "e1000.h" |
9 | |
10 | /* This is the only thing that needs to be changed to adjust the |
11 | * maximum number of ports that the driver can manage. |
12 | */ |
13 | #define E1000_MAX_NIC 32 |
14 | |
15 | #define OPTION_UNSET -1 |
16 | #define OPTION_DISABLED 0 |
17 | #define OPTION_ENABLED 1 |
18 | |
19 | #define COPYBREAK_DEFAULT 256 |
20 | unsigned int copybreak = COPYBREAK_DEFAULT; |
21 | module_param(copybreak, uint, 0644); |
22 | MODULE_PARM_DESC(copybreak, |
23 | "Maximum size of packet that is copied to a new buffer on receive" ); |
24 | |
25 | /* All parameters are treated the same, as an integer array of values. |
26 | * This macro just reduces the need to repeat the same declaration code |
27 | * over and over (plus this helps to avoid typo bugs). |
28 | */ |
29 | #define E1000_PARAM_INIT { [0 ... E1000_MAX_NIC] = OPTION_UNSET } |
30 | #define E1000_PARAM(X, desc) \ |
31 | static int X[E1000_MAX_NIC+1] = E1000_PARAM_INIT; \ |
32 | static unsigned int num_##X; \ |
33 | module_param_array_named(X, X, int, &num_##X, 0); \ |
34 | MODULE_PARM_DESC(X, desc); |
35 | |
36 | /* Transmit Interrupt Delay in units of 1.024 microseconds |
37 | * Tx interrupt delay needs to typically be set to something non-zero |
38 | * |
39 | * Valid Range: 0-65535 |
40 | */ |
41 | E1000_PARAM(TxIntDelay, "Transmit Interrupt Delay" ); |
42 | #define DEFAULT_TIDV 8 |
43 | #define MAX_TXDELAY 0xFFFF |
44 | #define MIN_TXDELAY 0 |
45 | |
46 | /* Transmit Absolute Interrupt Delay in units of 1.024 microseconds |
47 | * |
48 | * Valid Range: 0-65535 |
49 | */ |
50 | E1000_PARAM(TxAbsIntDelay, "Transmit Absolute Interrupt Delay" ); |
51 | #define DEFAULT_TADV 32 |
52 | #define MAX_TXABSDELAY 0xFFFF |
53 | #define MIN_TXABSDELAY 0 |
54 | |
55 | /* Receive Interrupt Delay in units of 1.024 microseconds |
56 | * hardware will likely hang if you set this to anything but zero. |
57 | * |
58 | * Burst variant is used as default if device has FLAG2_DMA_BURST. |
59 | * |
60 | * Valid Range: 0-65535 |
61 | */ |
62 | E1000_PARAM(RxIntDelay, "Receive Interrupt Delay" ); |
63 | #define DEFAULT_RDTR 0 |
64 | #define BURST_RDTR 0x20 |
65 | #define MAX_RXDELAY 0xFFFF |
66 | #define MIN_RXDELAY 0 |
67 | |
68 | /* Receive Absolute Interrupt Delay in units of 1.024 microseconds |
69 | * |
70 | * Burst variant is used as default if device has FLAG2_DMA_BURST. |
71 | * |
72 | * Valid Range: 0-65535 |
73 | */ |
74 | E1000_PARAM(RxAbsIntDelay, "Receive Absolute Interrupt Delay" ); |
75 | #define DEFAULT_RADV 8 |
76 | #define BURST_RADV 0x20 |
77 | #define MAX_RXABSDELAY 0xFFFF |
78 | #define MIN_RXABSDELAY 0 |
79 | |
80 | /* Interrupt Throttle Rate (interrupts/sec) |
81 | * |
82 | * Valid Range: 100-100000 or one of: 0=off, 1=dynamic, 3=dynamic conservative |
83 | */ |
84 | E1000_PARAM(InterruptThrottleRate, "Interrupt Throttling Rate" ); |
85 | #define DEFAULT_ITR 3 |
86 | #define MAX_ITR 100000 |
87 | #define MIN_ITR 100 |
88 | |
89 | /* IntMode (Interrupt Mode) |
90 | * |
91 | * Valid Range: varies depending on kernel configuration & hardware support |
92 | * |
93 | * legacy=0, MSI=1, MSI-X=2 |
94 | * |
95 | * When MSI/MSI-X support is enabled in kernel- |
96 | * Default Value: 2 (MSI-X) when supported by hardware, 1 (MSI) otherwise |
97 | * When MSI/MSI-X support is not enabled in kernel- |
98 | * Default Value: 0 (legacy) |
99 | * |
100 | * When a mode is specified that is not allowed/supported, it will be |
101 | * demoted to the most advanced interrupt mode available. |
102 | */ |
103 | E1000_PARAM(IntMode, "Interrupt Mode" ); |
104 | |
105 | /* Enable Smart Power Down of the PHY |
106 | * |
107 | * Valid Range: 0, 1 |
108 | * |
109 | * Default Value: 0 (disabled) |
110 | */ |
111 | E1000_PARAM(SmartPowerDownEnable, "Enable PHY smart power down" ); |
112 | |
113 | /* Enable Kumeran Lock Loss workaround |
114 | * |
115 | * Valid Range: 0, 1 |
116 | * |
117 | * Default Value: 1 (enabled) |
118 | */ |
119 | E1000_PARAM(KumeranLockLoss, "Enable Kumeran lock loss workaround" ); |
120 | |
121 | /* Write Protect NVM |
122 | * |
123 | * Valid Range: 0, 1 |
124 | * |
125 | * Default Value: 1 (enabled) |
126 | */ |
127 | E1000_PARAM(WriteProtectNVM, |
128 | "Write-protect NVM [WARNING: disabling this can lead to corrupted NVM]" ); |
129 | |
130 | /* Enable CRC Stripping |
131 | * |
132 | * Valid Range: 0, 1 |
133 | * |
134 | * Default Value: 1 (enabled) |
135 | */ |
136 | E1000_PARAM(CrcStripping, |
137 | "Enable CRC Stripping, disable if your BMC needs the CRC" ); |
138 | |
139 | struct e1000_option { |
140 | enum { enable_option, range_option, list_option } type; |
141 | const char *name; |
142 | const char *err; |
143 | int def; |
144 | union { |
145 | /* range_option info */ |
146 | struct { |
147 | int min; |
148 | int max; |
149 | } r; |
150 | /* list_option info */ |
151 | struct { |
152 | int nr; |
153 | struct e1000_opt_list { |
154 | int i; |
155 | char *str; |
156 | } *p; |
157 | } l; |
158 | } arg; |
159 | }; |
160 | |
161 | static int e1000_validate_option(unsigned int *value, |
162 | const struct e1000_option *opt, |
163 | struct e1000_adapter *adapter) |
164 | { |
165 | if (*value == OPTION_UNSET) { |
166 | *value = opt->def; |
167 | return 0; |
168 | } |
169 | |
170 | switch (opt->type) { |
171 | case enable_option: |
172 | switch (*value) { |
173 | case OPTION_ENABLED: |
174 | dev_info(&adapter->pdev->dev, "%s Enabled\n" , |
175 | opt->name); |
176 | return 0; |
177 | case OPTION_DISABLED: |
178 | dev_info(&adapter->pdev->dev, "%s Disabled\n" , |
179 | opt->name); |
180 | return 0; |
181 | } |
182 | break; |
183 | case range_option: |
184 | if (*value >= opt->arg.r.min && *value <= opt->arg.r.max) { |
185 | dev_info(&adapter->pdev->dev, "%s set to %i\n" , |
186 | opt->name, *value); |
187 | return 0; |
188 | } |
189 | break; |
190 | case list_option: { |
191 | int i; |
192 | struct e1000_opt_list *ent; |
193 | |
194 | for (i = 0; i < opt->arg.l.nr; i++) { |
195 | ent = &opt->arg.l.p[i]; |
196 | if (*value == ent->i) { |
197 | if (ent->str[0] != '\0') |
198 | dev_info(&adapter->pdev->dev, "%s\n" , |
199 | ent->str); |
200 | return 0; |
201 | } |
202 | } |
203 | } |
204 | break; |
205 | default: |
206 | BUG(); |
207 | } |
208 | |
209 | dev_info(&adapter->pdev->dev, "Invalid %s value specified (%i) %s\n" , |
210 | opt->name, *value, opt->err); |
211 | *value = opt->def; |
212 | return -1; |
213 | } |
214 | |
215 | /** |
216 | * e1000e_check_options - Range Checking for Command Line Parameters |
217 | * @adapter: board private structure |
218 | * |
219 | * This routine checks all command line parameters for valid user |
220 | * input. If an invalid value is given, or if no user specified |
221 | * value exists, a default value is used. The final value is stored |
222 | * in a variable in the adapter structure. |
223 | **/ |
224 | void e1000e_check_options(struct e1000_adapter *adapter) |
225 | { |
226 | struct e1000_hw *hw = &adapter->hw; |
227 | int bd = adapter->bd_number; |
228 | |
229 | if (bd >= E1000_MAX_NIC) { |
230 | dev_notice(&adapter->pdev->dev, |
231 | "Warning: no configuration for board #%i\n" , bd); |
232 | dev_notice(&adapter->pdev->dev, |
233 | "Using defaults for all values\n" ); |
234 | } |
235 | |
236 | /* Transmit Interrupt Delay */ |
237 | { |
238 | static const struct e1000_option opt = { |
239 | .type = range_option, |
240 | .name = "Transmit Interrupt Delay" , |
241 | .err = "using default of " |
242 | __MODULE_STRING(DEFAULT_TIDV), |
243 | .def = DEFAULT_TIDV, |
244 | .arg = { .r = { .min = MIN_TXDELAY, |
245 | .max = MAX_TXDELAY } } |
246 | }; |
247 | |
248 | if (num_TxIntDelay > bd) { |
249 | adapter->tx_int_delay = TxIntDelay[bd]; |
250 | e1000_validate_option(value: &adapter->tx_int_delay, opt: &opt, |
251 | adapter); |
252 | } else { |
253 | adapter->tx_int_delay = opt.def; |
254 | } |
255 | } |
256 | /* Transmit Absolute Interrupt Delay */ |
257 | { |
258 | static const struct e1000_option opt = { |
259 | .type = range_option, |
260 | .name = "Transmit Absolute Interrupt Delay" , |
261 | .err = "using default of " |
262 | __MODULE_STRING(DEFAULT_TADV), |
263 | .def = DEFAULT_TADV, |
264 | .arg = { .r = { .min = MIN_TXABSDELAY, |
265 | .max = MAX_TXABSDELAY } } |
266 | }; |
267 | |
268 | if (num_TxAbsIntDelay > bd) { |
269 | adapter->tx_abs_int_delay = TxAbsIntDelay[bd]; |
270 | e1000_validate_option(value: &adapter->tx_abs_int_delay, opt: &opt, |
271 | adapter); |
272 | } else { |
273 | adapter->tx_abs_int_delay = opt.def; |
274 | } |
275 | } |
276 | /* Receive Interrupt Delay */ |
277 | { |
278 | static struct e1000_option opt = { |
279 | .type = range_option, |
280 | .name = "Receive Interrupt Delay" , |
281 | .err = "using default of " |
282 | __MODULE_STRING(DEFAULT_RDTR), |
283 | .def = DEFAULT_RDTR, |
284 | .arg = { .r = { .min = MIN_RXDELAY, |
285 | .max = MAX_RXDELAY } } |
286 | }; |
287 | |
288 | if (adapter->flags2 & FLAG2_DMA_BURST) |
289 | opt.def = BURST_RDTR; |
290 | |
291 | if (num_RxIntDelay > bd) { |
292 | adapter->rx_int_delay = RxIntDelay[bd]; |
293 | e1000_validate_option(value: &adapter->rx_int_delay, opt: &opt, |
294 | adapter); |
295 | } else { |
296 | adapter->rx_int_delay = opt.def; |
297 | } |
298 | } |
299 | /* Receive Absolute Interrupt Delay */ |
300 | { |
301 | static struct e1000_option opt = { |
302 | .type = range_option, |
303 | .name = "Receive Absolute Interrupt Delay" , |
304 | .err = "using default of " |
305 | __MODULE_STRING(DEFAULT_RADV), |
306 | .def = DEFAULT_RADV, |
307 | .arg = { .r = { .min = MIN_RXABSDELAY, |
308 | .max = MAX_RXABSDELAY } } |
309 | }; |
310 | |
311 | if (adapter->flags2 & FLAG2_DMA_BURST) |
312 | opt.def = BURST_RADV; |
313 | |
314 | if (num_RxAbsIntDelay > bd) { |
315 | adapter->rx_abs_int_delay = RxAbsIntDelay[bd]; |
316 | e1000_validate_option(value: &adapter->rx_abs_int_delay, opt: &opt, |
317 | adapter); |
318 | } else { |
319 | adapter->rx_abs_int_delay = opt.def; |
320 | } |
321 | } |
322 | /* Interrupt Throttling Rate */ |
323 | { |
324 | static const struct e1000_option opt = { |
325 | .type = range_option, |
326 | .name = "Interrupt Throttling Rate (ints/sec)" , |
327 | .err = "using default of " |
328 | __MODULE_STRING(DEFAULT_ITR), |
329 | .def = DEFAULT_ITR, |
330 | .arg = { .r = { .min = MIN_ITR, |
331 | .max = MAX_ITR } } |
332 | }; |
333 | |
334 | if (num_InterruptThrottleRate > bd) { |
335 | adapter->itr = InterruptThrottleRate[bd]; |
336 | |
337 | /* Make sure a message is printed for non-special |
338 | * values. And in case of an invalid option, display |
339 | * warning, use default and go through itr/itr_setting |
340 | * adjustment logic below |
341 | */ |
342 | if ((adapter->itr > 4) && |
343 | e1000_validate_option(value: &adapter->itr, opt: &opt, adapter)) |
344 | adapter->itr = opt.def; |
345 | } else { |
346 | /* If no option specified, use default value and go |
347 | * through the logic below to adjust itr/itr_setting |
348 | */ |
349 | adapter->itr = opt.def; |
350 | |
351 | /* Make sure a message is printed for non-special |
352 | * default values |
353 | */ |
354 | if (adapter->itr > 4) |
355 | dev_info(&adapter->pdev->dev, |
356 | "%s set to default %d\n" , opt.name, |
357 | adapter->itr); |
358 | } |
359 | |
360 | adapter->itr_setting = adapter->itr; |
361 | switch (adapter->itr) { |
362 | case 0: |
363 | dev_info(&adapter->pdev->dev, "%s turned off\n" , |
364 | opt.name); |
365 | break; |
366 | case 1: |
367 | dev_info(&adapter->pdev->dev, |
368 | "%s set to dynamic mode\n" , opt.name); |
369 | adapter->itr = 20000; |
370 | break; |
371 | case 2: |
372 | dev_info(&adapter->pdev->dev, |
373 | "%s Invalid mode - setting default\n" , |
374 | opt.name); |
375 | adapter->itr_setting = opt.def; |
376 | fallthrough; |
377 | case 3: |
378 | dev_info(&adapter->pdev->dev, |
379 | "%s set to dynamic conservative mode\n" , |
380 | opt.name); |
381 | adapter->itr = 20000; |
382 | break; |
383 | case 4: |
384 | dev_info(&adapter->pdev->dev, |
385 | "%s set to simplified (2000-8000 ints) mode\n" , |
386 | opt.name); |
387 | break; |
388 | default: |
389 | /* Save the setting, because the dynamic bits |
390 | * change itr. |
391 | * |
392 | * Clear the lower two bits because |
393 | * they are used as control. |
394 | */ |
395 | adapter->itr_setting &= ~3; |
396 | break; |
397 | } |
398 | } |
399 | /* Interrupt Mode */ |
400 | { |
401 | static struct e1000_option opt = { |
402 | .type = range_option, |
403 | .name = "Interrupt Mode" , |
404 | #ifndef CONFIG_PCI_MSI |
405 | .err = "defaulting to 0 (legacy)" , |
406 | .def = E1000E_INT_MODE_LEGACY, |
407 | .arg = { .r = { .min = 0, |
408 | .max = 0 } } |
409 | #endif |
410 | }; |
411 | |
412 | #ifdef CONFIG_PCI_MSI |
413 | if (adapter->flags & FLAG_HAS_MSIX) { |
414 | opt.err = kstrdup(s: "defaulting to 2 (MSI-X)" , |
415 | GFP_KERNEL); |
416 | opt.def = E1000E_INT_MODE_MSIX; |
417 | opt.arg.r.max = E1000E_INT_MODE_MSIX; |
418 | } else { |
419 | opt.err = kstrdup(s: "defaulting to 1 (MSI)" , GFP_KERNEL); |
420 | opt.def = E1000E_INT_MODE_MSI; |
421 | opt.arg.r.max = E1000E_INT_MODE_MSI; |
422 | } |
423 | |
424 | if (!opt.err) { |
425 | dev_err(&adapter->pdev->dev, |
426 | "Failed to allocate memory\n" ); |
427 | return; |
428 | } |
429 | #endif |
430 | |
431 | if (num_IntMode > bd) { |
432 | unsigned int int_mode = IntMode[bd]; |
433 | |
434 | e1000_validate_option(value: &int_mode, opt: &opt, adapter); |
435 | adapter->int_mode = int_mode; |
436 | } else { |
437 | adapter->int_mode = opt.def; |
438 | } |
439 | |
440 | #ifdef CONFIG_PCI_MSI |
441 | kfree(objp: opt.err); |
442 | #endif |
443 | } |
444 | /* Smart Power Down */ |
445 | { |
446 | static const struct e1000_option opt = { |
447 | .type = enable_option, |
448 | .name = "PHY Smart Power Down" , |
449 | .err = "defaulting to Disabled" , |
450 | .def = OPTION_DISABLED |
451 | }; |
452 | |
453 | if (num_SmartPowerDownEnable > bd) { |
454 | unsigned int spd = SmartPowerDownEnable[bd]; |
455 | |
456 | e1000_validate_option(value: &spd, opt: &opt, adapter); |
457 | if ((adapter->flags & FLAG_HAS_SMART_POWER_DOWN) && spd) |
458 | adapter->flags |= FLAG_SMART_POWER_DOWN; |
459 | } |
460 | } |
461 | /* CRC Stripping */ |
462 | { |
463 | static const struct e1000_option opt = { |
464 | .type = enable_option, |
465 | .name = "CRC Stripping" , |
466 | .err = "defaulting to Enabled" , |
467 | .def = OPTION_ENABLED |
468 | }; |
469 | |
470 | if (num_CrcStripping > bd) { |
471 | unsigned int crc_stripping = CrcStripping[bd]; |
472 | |
473 | e1000_validate_option(value: &crc_stripping, opt: &opt, adapter); |
474 | if (crc_stripping == OPTION_ENABLED) { |
475 | adapter->flags2 |= FLAG2_CRC_STRIPPING; |
476 | adapter->flags2 |= FLAG2_DFLT_CRC_STRIPPING; |
477 | } |
478 | } else { |
479 | adapter->flags2 |= FLAG2_CRC_STRIPPING; |
480 | adapter->flags2 |= FLAG2_DFLT_CRC_STRIPPING; |
481 | } |
482 | } |
483 | /* Kumeran Lock Loss Workaround */ |
484 | { |
485 | static const struct e1000_option opt = { |
486 | .type = enable_option, |
487 | .name = "Kumeran Lock Loss Workaround" , |
488 | .err = "defaulting to Enabled" , |
489 | .def = OPTION_ENABLED |
490 | }; |
491 | bool enabled = opt.def; |
492 | |
493 | if (num_KumeranLockLoss > bd) { |
494 | unsigned int kmrn_lock_loss = KumeranLockLoss[bd]; |
495 | |
496 | e1000_validate_option(value: &kmrn_lock_loss, opt: &opt, adapter); |
497 | enabled = kmrn_lock_loss; |
498 | } |
499 | |
500 | if (hw->mac.type == e1000_ich8lan) |
501 | e1000e_set_kmrn_lock_loss_workaround_ich8lan(hw, |
502 | state: enabled); |
503 | } |
504 | /* Write-protect NVM */ |
505 | { |
506 | static const struct e1000_option opt = { |
507 | .type = enable_option, |
508 | .name = "Write-protect NVM" , |
509 | .err = "defaulting to Enabled" , |
510 | .def = OPTION_ENABLED |
511 | }; |
512 | |
513 | if (adapter->flags & FLAG_IS_ICH) { |
514 | if (num_WriteProtectNVM > bd) { |
515 | unsigned int write_protect_nvm = |
516 | WriteProtectNVM[bd]; |
517 | e1000_validate_option(value: &write_protect_nvm, opt: &opt, |
518 | adapter); |
519 | if (write_protect_nvm) |
520 | adapter->flags |= FLAG_READ_ONLY_NVM; |
521 | } else { |
522 | if (opt.def) |
523 | adapter->flags |= FLAG_READ_ONLY_NVM; |
524 | } |
525 | } |
526 | } |
527 | } |
528 | |