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