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(&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-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(&adapter->itr, &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("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 #endif 430 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_MSI 441 kfree(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(&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_ENABLED 468 }; 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_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(&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_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(&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