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