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