drivers/net/ethernet/intel/e1000e/param.c

   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 }