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 #define MAX_INTMODE 2 105 #define MIN_INTMODE 0 106 107 /* Enable Smart Power Down of the PHY 108 * 109 * Valid Range: 0, 1 110 * 111 * Default Value: 0 (disabled) 112 */ 113 E1000_PARAM(SmartPowerDownEnable, "Enable PHY smart power down"); 114 115 /* Enable Kumeran Lock Loss workaround 116 * 117 * Valid Range: 0, 1 118 * 119 * Default Value: 1 (enabled) 120 */ 121 E1000_PARAM(KumeranLockLoss, "Enable Kumeran lock loss workaround"); 122 123 /* Write Protect NVM 124 * 125 * Valid Range: 0, 1 126 * 127 * Default Value: 1 (enabled) 128 */ 129 E1000_PARAM(WriteProtectNVM, 130 "Write-protect NVM [WARNING: disabling this can lead to corrupted NVM]"); 131 132 /* Enable CRC Stripping 133 * 134 * Valid Range: 0, 1 135 * 136 * Default Value: 1 (enabled) 137 */ 138 E1000_PARAM(CrcStripping, 139 "Enable CRC Stripping, disable if your BMC needs the CRC"); 140 141 struct e1000_option { 142 enum { enable_option, range_option, list_option } type; 143 const char *name; 144 const char *err; 145 int def; 146 union { 147 /* range_option info */ 148 struct { 149 int min; 150 int max; 151 } r; 152 /* list_option info */ 153 struct { 154 int nr; 155 struct e1000_opt_list { 156 int i; 157 char *str; 158 } *p; 159 } l; 160 } arg; 161 }; 162 163 static int e1000_validate_option(unsigned int *value, 164 const struct e1000_option *opt, 165 struct e1000_adapter *adapter) 166 { 167 if (*value == OPTION_UNSET) { 168 *value = opt->def; 169 return 0; 170 } 171 172 switch (opt->type) { 173 case enable_option: 174 switch (*value) { 175 case OPTION_ENABLED: 176 dev_info(&adapter->pdev->dev, "%s Enabled\n", 177 opt->name); 178 return 0; 179 case OPTION_DISABLED: 180 dev_info(&adapter->pdev->dev, "%s Disabled\n", 181 opt->name); 182 return 0; 183 } 184 break; 185 case range_option: 186 if (*value >= opt->arg.r.min && *value <= opt->arg.r.max) { 187 dev_info(&adapter->pdev->dev, "%s set to %i\n", 188 opt->name, *value); 189 return 0; 190 } 191 break; 192 case list_option: { 193 int i; 194 struct e1000_opt_list *ent; 195 196 for (i = 0; i < opt->arg.l.nr; i++) { 197 ent = &opt->arg.l.p[i]; 198 if (*value == ent->i) { 199 if (ent->str[0] != '\0') 200 dev_info(&adapter->pdev->dev, "%s\n", 201 ent->str); 202 return 0; 203 } 204 } 205 } 206 break; 207 default: 208 BUG(); 209 } 210 211 dev_info(&adapter->pdev->dev, "Invalid %s value specified (%i) %s\n", 212 opt->name, *value, opt->err); 213 *value = opt->def; 214 return -1; 215 } 216 217 /** 218 * e1000e_check_options - Range Checking for Command Line Parameters 219 * @adapter: board private structure 220 * 221 * This routine checks all command line parameters for valid user 222 * input. If an invalid value is given, or if no user specified 223 * value exists, a default value is used. The final value is stored 224 * in a variable in the adapter structure. 225 **/ 226 void e1000e_check_options(struct e1000_adapter *adapter) 227 { 228 struct e1000_hw *hw = &adapter->hw; 229 int bd = adapter->bd_number; 230 231 if (bd >= E1000_MAX_NIC) { 232 dev_notice(&adapter->pdev->dev, 233 "Warning: no configuration for board #%i\n", bd); 234 dev_notice(&adapter->pdev->dev, 235 "Using defaults for all values\n"); 236 } 237 238 /* Transmit Interrupt Delay */ 239 { 240 static const struct e1000_option opt = { 241 .type = range_option, 242 .name = "Transmit Interrupt Delay", 243 .err = "using default of " 244 __MODULE_STRING(DEFAULT_TIDV), 245 .def = DEFAULT_TIDV, 246 .arg = { .r = { .min = MIN_TXDELAY, 247 .max = MAX_TXDELAY } } 248 }; 249 250 if (num_TxIntDelay > bd) { 251 adapter->tx_int_delay = TxIntDelay[bd]; 252 e1000_validate_option(&adapter->tx_int_delay, &opt, 253 adapter); 254 } else { 255 adapter->tx_int_delay = opt.def; 256 } 257 } 258 /* Transmit Absolute Interrupt Delay */ 259 { 260 static const struct e1000_option opt = { 261 .type = range_option, 262 .name = "Transmit Absolute Interrupt Delay", 263 .err = "using default of " 264 __MODULE_STRING(DEFAULT_TADV), 265 .def = DEFAULT_TADV, 266 .arg = { .r = { .min = MIN_TXABSDELAY, 267 .max = MAX_TXABSDELAY } } 268 }; 269 270 if (num_TxAbsIntDelay > bd) { 271 adapter->tx_abs_int_delay = TxAbsIntDelay[bd]; 272 e1000_validate_option(&adapter->tx_abs_int_delay, &opt, 273 adapter); 274 } else { 275 adapter->tx_abs_int_delay = opt.def; 276 } 277 } 278 /* Receive Interrupt Delay */ 279 { 280 static struct e1000_option opt = { 281 .type = range_option, 282 .name = "Receive Interrupt Delay", 283 .err = "using default of " 284 __MODULE_STRING(DEFAULT_RDTR), 285 .def = DEFAULT_RDTR, 286 .arg = { .r = { .min = MIN_RXDELAY, 287 .max = MAX_RXDELAY } } 288 }; 289 290 if (adapter->flags2 & FLAG2_DMA_BURST) 291 opt.def = BURST_RDTR; 292 293 if (num_RxIntDelay > bd) { 294 adapter->rx_int_delay = RxIntDelay[bd]; 295 e1000_validate_option(&adapter->rx_int_delay, &opt, 296 adapter); 297 } else { 298 adapter->rx_int_delay = opt.def; 299 } 300 } 301 /* Receive Absolute Interrupt Delay */ 302 { 303 static struct e1000_option opt = { 304 .type = range_option, 305 .name = "Receive Absolute Interrupt Delay", 306 .err = "using default of " 307 __MODULE_STRING(DEFAULT_RADV), 308 .def = DEFAULT_RADV, 309 .arg = { .r = { .min = MIN_RXABSDELAY, 310 .max = MAX_RXABSDELAY } } 311 }; 312 313 if (adapter->flags2 & FLAG2_DMA_BURST) 314 opt.def = BURST_RADV; 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 { 326 static const struct e1000_option opt = { 327 .type = range_option, 328 .name = "Interrupt Throttling Rate (ints/sec)", 329 .err = "using default of " 330 __MODULE_STRING(DEFAULT_ITR), 331 .def = DEFAULT_ITR, 332 .arg = { .r = { .min = MIN_ITR, 333 .max = MAX_ITR } } 334 }; 335 336 if (num_InterruptThrottleRate > bd) { 337 adapter->itr = InterruptThrottleRate[bd]; 338 339 /* Make sure a message is printed for non-special 340 * values. And in case of an invalid option, display 341 * warning, use default and go through itr/itr_setting 342 * adjustment logic below 343 */ 344 if ((adapter->itr > 4) && 345 e1000_validate_option(&adapter->itr, &opt, adapter)) 346 adapter->itr = opt.def; 347 } else { 348 /* If no option specified, use default value and go 349 * through the logic below to adjust itr/itr_setting 350 */ 351 adapter->itr = opt.def; 352 353 /* Make sure a message is printed for non-special 354 * default values 355 */ 356 if (adapter->itr > 4) 357 dev_info(&adapter->pdev->dev, 358 "%s set to default %d\n", opt.name, 359 adapter->itr); 360 } 361 362 adapter->itr_setting = adapter->itr; 363 switch (adapter->itr) { 364 case 0: 365 dev_info(&adapter->pdev->dev, "%s turned off\n", 366 opt.name); 367 break; 368 case 1: 369 dev_info(&adapter->pdev->dev, 370 "%s set to dynamic mode\n", opt.name); 371 adapter->itr = 20000; 372 break; 373 case 2: 374 dev_info(&adapter->pdev->dev, 375 "%s Invalid mode - setting default\n", 376 opt.name); 377 adapter->itr_setting = opt.def; 378 /* fall-through */ 379 case 3: 380 dev_info(&adapter->pdev->dev, 381 "%s set to dynamic conservative mode\n", 382 opt.name); 383 adapter->itr = 20000; 384 break; 385 case 4: 386 dev_info(&adapter->pdev->dev, 387 "%s set to simplified (2000-8000 ints) mode\n", 388 opt.name); 389 break; 390 default: 391 /* Save the setting, because the dynamic bits 392 * change itr. 393 * 394 * Clear the lower two bits because 395 * they are used as control. 396 */ 397 adapter->itr_setting &= ~3; 398 break; 399 } 400 } 401 /* Interrupt Mode */ 402 { 403 static struct e1000_option opt = { 404 .type = range_option, 405 .name = "Interrupt Mode", 406 #ifndef CONFIG_PCI_MSI 407 .err = "defaulting to 0 (legacy)", 408 .def = E1000E_INT_MODE_LEGACY, 409 .arg = { .r = { .min = 0, 410 .max = 0 } } 411 #endif 412 }; 413 414 #ifdef CONFIG_PCI_MSI 415 if (adapter->flags & FLAG_HAS_MSIX) { 416 opt.err = kstrdup("defaulting to 2 (MSI-X)", 417 GFP_KERNEL); 418 opt.def = E1000E_INT_MODE_MSIX; 419 opt.arg.r.max = E1000E_INT_MODE_MSIX; 420 } else { 421 opt.err = kstrdup("defaulting to 1 (MSI)", GFP_KERNEL); 422 opt.def = E1000E_INT_MODE_MSI; 423 opt.arg.r.max = E1000E_INT_MODE_MSI; 424 } 425 426 if (!opt.err) { 427 dev_err(&adapter->pdev->dev, 428 "Failed to allocate memory\n"); 429 return; 430 } 431 #endif 432 433 if (num_IntMode > bd) { 434 unsigned int int_mode = IntMode[bd]; 435 436 e1000_validate_option(&int_mode, &opt, adapter); 437 adapter->int_mode = int_mode; 438 } else { 439 adapter->int_mode = opt.def; 440 } 441 442 #ifdef CONFIG_PCI_MSI 443 kfree(opt.err); 444 #endif 445 } 446 /* Smart Power Down */ 447 { 448 static const struct e1000_option opt = { 449 .type = enable_option, 450 .name = "PHY Smart Power Down", 451 .err = "defaulting to Disabled", 452 .def = OPTION_DISABLED 453 }; 454 455 if (num_SmartPowerDownEnable > bd) { 456 unsigned int spd = SmartPowerDownEnable[bd]; 457 458 e1000_validate_option(&spd, &opt, adapter); 459 if ((adapter->flags & FLAG_HAS_SMART_POWER_DOWN) && spd) 460 adapter->flags |= FLAG_SMART_POWER_DOWN; 461 } 462 } 463 /* CRC Stripping */ 464 { 465 static const struct e1000_option opt = { 466 .type = enable_option, 467 .name = "CRC Stripping", 468 .err = "defaulting to Enabled", 469 .def = OPTION_ENABLED 470 }; 471 472 if (num_CrcStripping > bd) { 473 unsigned int crc_stripping = CrcStripping[bd]; 474 475 e1000_validate_option(&crc_stripping, &opt, adapter); 476 if (crc_stripping == OPTION_ENABLED) { 477 adapter->flags2 |= FLAG2_CRC_STRIPPING; 478 adapter->flags2 |= FLAG2_DFLT_CRC_STRIPPING; 479 } 480 } else { 481 adapter->flags2 |= FLAG2_CRC_STRIPPING; 482 adapter->flags2 |= FLAG2_DFLT_CRC_STRIPPING; 483 } 484 } 485 /* Kumeran Lock Loss Workaround */ 486 { 487 static const struct e1000_option opt = { 488 .type = enable_option, 489 .name = "Kumeran Lock Loss Workaround", 490 .err = "defaulting to Enabled", 491 .def = OPTION_ENABLED 492 }; 493 bool enabled = opt.def; 494 495 if (num_KumeranLockLoss > bd) { 496 unsigned int kmrn_lock_loss = KumeranLockLoss[bd]; 497 498 e1000_validate_option(&kmrn_lock_loss, &opt, adapter); 499 enabled = kmrn_lock_loss; 500 } 501 502 if (hw->mac.type == e1000_ich8lan) 503 e1000e_set_kmrn_lock_loss_workaround_ich8lan(hw, 504 enabled); 505 } 506 /* Write-protect NVM */ 507 { 508 static const struct e1000_option opt = { 509 .type = enable_option, 510 .name = "Write-protect NVM", 511 .err = "defaulting to Enabled", 512 .def = OPTION_ENABLED 513 }; 514 515 if (adapter->flags & FLAG_IS_ICH) { 516 if (num_WriteProtectNVM > bd) { 517 unsigned int write_protect_nvm = 518 WriteProtectNVM[bd]; 519 e1000_validate_option(&write_protect_nvm, &opt, 520 adapter); 521 if (write_protect_nvm) 522 adapter->flags |= FLAG_READ_ONLY_NVM; 523 } else { 524 if (opt.def) 525 adapter->flags |= FLAG_READ_ONLY_NVM; 526 } 527 } 528 } 529 } 530