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