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