528 lines · c
1// SPDX-License-Identifier: GPL-2.02/* 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 the11 * maximum number of ports that the driver can manage.12 */13#define E1000_MAX_NIC 3214 15#define OPTION_UNSET -116#define OPTION_DISABLED 017#define OPTION_ENABLED 118 19#define COPYBREAK_DEFAULT 25620unsigned int copybreak = COPYBREAK_DEFAULT;21module_param(copybreak, uint, 0644);22MODULE_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 code27 * 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 microseconds37 * Tx interrupt delay needs to typically be set to something non-zero38 *39 * Valid Range: 0-6553540 */41E1000_PARAM(TxIntDelay, "Transmit Interrupt Delay");42#define DEFAULT_TIDV 843#define MAX_TXDELAY 0xFFFF44#define MIN_TXDELAY 045 46/* Transmit Absolute Interrupt Delay in units of 1.024 microseconds47 *48 * Valid Range: 0-6553549 */50E1000_PARAM(TxAbsIntDelay, "Transmit Absolute Interrupt Delay");51#define DEFAULT_TADV 3252#define MAX_TXABSDELAY 0xFFFF53#define MIN_TXABSDELAY 054 55/* Receive Interrupt Delay in units of 1.024 microseconds56 * 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-6553561 */62E1000_PARAM(RxIntDelay, "Receive Interrupt Delay");63#define DEFAULT_RDTR 064#define BURST_RDTR 0x2065#define MAX_RXDELAY 0xFFFF66#define MIN_RXDELAY 067 68/* Receive Absolute Interrupt Delay in units of 1.024 microseconds69 *70 * Burst variant is used as default if device has FLAG2_DMA_BURST.71 *72 * Valid Range: 0-6553573 */74E1000_PARAM(RxAbsIntDelay, "Receive Absolute Interrupt Delay");75#define DEFAULT_RADV 876#define BURST_RADV 0x2077#define MAX_RXABSDELAY 0xFFFF78#define MIN_RXABSDELAY 079 80/* Interrupt Throttle Rate (interrupts/sec)81 *82 * Valid Range: 100-100000 or one of: 0=off, 1=dynamic, 3=dynamic conservative83 */84E1000_PARAM(InterruptThrottleRate, "Interrupt Throttling Rate");85#define DEFAULT_ITR 386#define MAX_ITR 10000087#define MIN_ITR 10088 89/* IntMode (Interrupt Mode)90 *91 * Valid Range: varies depending on kernel configuration & hardware support92 *93 * legacy=0, MSI=1, MSI-X=294 *95 * When MSI/MSI-X support is enabled in kernel-96 * Default Value: 2 (MSI-X) when supported by hardware, 1 (MSI) otherwise97 * 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 be101 * demoted to the most advanced interrupt mode available.102 */103E1000_PARAM(IntMode, "Interrupt Mode");104 105/* Enable Smart Power Down of the PHY106 *107 * Valid Range: 0, 1108 *109 * Default Value: 0 (disabled)110 */111E1000_PARAM(SmartPowerDownEnable, "Enable PHY smart power down");112 113/* Enable Kumeran Lock Loss workaround114 *115 * Valid Range: 0, 1116 *117 * Default Value: 1 (enabled)118 */119E1000_PARAM(KumeranLockLoss, "Enable Kumeran lock loss workaround");120 121/* Write Protect NVM122 *123 * Valid Range: 0, 1124 *125 * Default Value: 1 (enabled)126 */127E1000_PARAM(WriteProtectNVM,128 "Write-protect NVM [WARNING: disabling this can lead to corrupted NVM]");129 130/* Enable CRC Stripping131 *132 * Valid Range: 0, 1133 *134 * Default Value: 1 (enabled)135 */136E1000_PARAM(CrcStripping,137 "Enable CRC Stripping, disable if your BMC needs the CRC");138 139struct 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 161static 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 Parameters217 * @adapter: board private structure218 *219 * This routine checks all command line parameters for valid user220 * input. If an invalid value is given, or if no user specified221 * value exists, a default value is used. The final value is stored222 * in a variable in the adapter structure.223 **/224void 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(&adapter->tx_int_delay, &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(&adapter->tx_abs_int_delay, &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(&adapter->rx_int_delay, &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(&adapter->rx_abs_int_delay, &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-special338 * values. And in case of an invalid option, display339 * warning, use default and go through itr/itr_setting340 * adjustment logic below341 */342 if ((adapter->itr > 4) &&343 e1000_validate_option(&adapter->itr, &opt, adapter))344 adapter->itr = opt.def;345 } else {346 /* If no option specified, use default value and go347 * through the logic below to adjust itr/itr_setting348 */349 adapter->itr = opt.def;350 351 /* Make sure a message is printed for non-special352 * default values353 */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 bits390 * change itr.391 *392 * Clear the lower two bits because393 * 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_MSI405 .err = "defaulting to 0 (legacy)",406 .def = E1000E_INT_MODE_LEGACY,407 .arg = { .r = { .min = 0,408 .max = 0 } }409#endif410 };411 412#ifdef CONFIG_PCI_MSI413 if (adapter->flags & FLAG_HAS_MSIX) {414 opt.err = kstrdup("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("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#endif430 431 if (num_IntMode > bd) {432 unsigned int int_mode = IntMode[bd];433 434 e1000_validate_option(&int_mode, &opt, adapter);435 adapter->int_mode = int_mode;436 } else {437 adapter->int_mode = opt.def;438 }439 440#ifdef CONFIG_PCI_MSI441 kfree(opt.err);442#endif443 }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_DISABLED451 };452 453 if (num_SmartPowerDownEnable > bd) {454 unsigned int spd = SmartPowerDownEnable[bd];455 456 e1000_validate_option(&spd, &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_ENABLED468 };469 470 if (num_CrcStripping > bd) {471 unsigned int crc_stripping = CrcStripping[bd];472 473 e1000_validate_option(&crc_stripping, &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_ENABLED490 };491 bool enabled = opt.def;492 493 if (num_KumeranLockLoss > bd) {494 unsigned int kmrn_lock_loss = KumeranLockLoss[bd];495 496 e1000_validate_option(&kmrn_lock_loss, &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 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_ENABLED511 };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(&write_protect_nvm, &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