lib/librte_eal/linuxapp/kni/ethtool/igb/igb_param.c

   1 /*******************************************************************************
   2
   3   Intel(R) Gigabit Ethernet Linux driver
   4   Copyright(c) 2007-2013 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   e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
  24   Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  25
  26 *******************************************************************************/
  27
  28
  29 #include <linux/netdevice.h>
  30
  31 #include "igb.h"
  32
  33 /* This is the only thing that needs to be changed to adjust the
  34  * maximum number of ports that the driver can manage.
  35  */
  36
  37 #define IGB_MAX_NIC 32
  38
  39 #define OPTION_UNSET   -1
  40 #define OPTION_DISABLED 0
  41 #define OPTION_ENABLED  1
  42 #define MAX_NUM_LIST_OPTS 15
  43
  44 /* All parameters are treated the same, as an integer array of values.
  45  * This macro just reduces the need to repeat the same declaration code
  46  * over and over (plus this helps to avoid typo bugs).
  47  */
  48
  49 #define IGB_PARAM_INIT { [0 ... IGB_MAX_NIC] = OPTION_UNSET }
  50 #ifndef module_param_array
  51 /* Module Parameters are always initialized to -1, so that the driver
  52  * can tell the difference between no user specified value or the
  53  * user asking for the default value.
  54  * The true default values are loaded in when igb_check_options is called.
  55  *
  56  * This is a GCC extension to ANSI C.
  57  * See the item "Labeled Elements in Initializers" in the section
  58  * "Extensions to the C Language Family" of the GCC documentation.
  59  */
  60
  61 #define IGB_PARAM(X, desc) \
  62         static const int X[IGB_MAX_NIC+1] = IGB_PARAM_INIT; \
  63         MODULE_PARM(X, "1-" __MODULE_STRING(IGB_MAX_NIC) "i"); \
  64         MODULE_PARM_DESC(X, desc);
  65 #else
  66 #define IGB_PARAM(X, desc) \
  67         static int X[IGB_MAX_NIC+1] = IGB_PARAM_INIT; \
  68         static unsigned int num_##X; \
  69         module_param_array_named(X, X, int, &num_##X, 0); \
  70         MODULE_PARM_DESC(X, desc);
  71 #endif
  72
  73 /* Interrupt Throttle Rate (interrupts/sec)
  74  *
  75  * Valid Range: 100-100000 (0=off, 1=dynamic, 3=dynamic conservative)
  76  */
  77 IGB_PARAM(InterruptThrottleRate,
  78           "Maximum interrupts per second, per vector, (max 100000), default 3=adaptive");
  79 #define DEFAULT_ITR                    3
  80 #define MAX_ITR                   100000
  81 /* #define MIN_ITR                      120 */
  82 #define MIN_ITR                      0
  83 /* IntMode (Interrupt Mode)
  84  *
  85  * Valid Range: 0 - 2
  86  *
  87  * Default Value: 2 (MSI-X)
  88  */
  89 IGB_PARAM(IntMode, "Change Interrupt Mode (0=Legacy, 1=MSI, 2=MSI-X), default 2");
  90 #define MAX_INTMODE                    IGB_INT_MODE_MSIX
  91 #define MIN_INTMODE                    IGB_INT_MODE_LEGACY
  92
  93 IGB_PARAM(Node, "set the starting node to allocate memory on, default -1");
  94
  95 /* LLIPort (Low Latency Interrupt TCP Port)
  96  *
  97  * Valid Range: 0 - 65535
  98  *
  99  * Default Value: 0 (disabled)
 100  */
 101 IGB_PARAM(LLIPort, "Low Latency Interrupt TCP Port (0-65535), default 0=off");
 102
 103 #define DEFAULT_LLIPORT                0
 104 #define MAX_LLIPORT               0xFFFF
 105 #define MIN_LLIPORT                    0
 106
 107 /* LLIPush (Low Latency Interrupt on TCP Push flag)
 108  *
 109  * Valid Range: 0, 1
 110  *
 111  * Default Value: 0 (disabled)
 112  */
 113 IGB_PARAM(LLIPush, "Low Latency Interrupt on TCP Push flag (0,1), default 0=off");
 114
 115 #define DEFAULT_LLIPUSH                0
 116 #define MAX_LLIPUSH                    1
 117 #define MIN_LLIPUSH                    0
 118
 119 /* LLISize (Low Latency Interrupt on Packet Size)
 120  *
 121  * Valid Range: 0 - 1500
 122  *
 123  * Default Value: 0 (disabled)
 124  */
 125 IGB_PARAM(LLISize, "Low Latency Interrupt on Packet Size (0-1500), default 0=off");
 126
 127 #define DEFAULT_LLISIZE                0
 128 #define MAX_LLISIZE                 1500
 129 #define MIN_LLISIZE                    0
 130
 131 /* RSS (Enable RSS multiqueue receive)
 132  *
 133  * Valid Range: 0 - 8
 134  *
 135  * Default Value:  1
 136  */
 137 IGB_PARAM(RSS, "Number of Receive-Side Scaling Descriptor Queues (0-8), default 1, 0=number of cpus");
 138
 139 #define DEFAULT_RSS       1
 140 #define MAX_RSS           8
 141 #define MIN_RSS           0
 142
 143 /* VMDQ (Enable VMDq multiqueue receive)
 144  *
 145  * Valid Range: 0 - 8
 146  *
 147  * Default Value:  0
 148  */
 149 IGB_PARAM(VMDQ, "Number of Virtual Machine Device Queues: 0-1 = disable, 2-8 enable, default 0");
 150
 151 #define DEFAULT_VMDQ      0
 152 #define MAX_VMDQ          MAX_RSS
 153 #define MIN_VMDQ          0
 154
 155 /* max_vfs (Enable SR-IOV VF devices)
 156  *
 157  * Valid Range: 0 - 7
 158  *
 159  * Default Value:  0
 160  */
 161 IGB_PARAM(max_vfs, "Number of Virtual Functions: 0 = disable, 1-7 enable, default 0");
 162
 163 #define DEFAULT_SRIOV     0
 164 #define MAX_SRIOV         7
 165 #define MIN_SRIOV         0
 166
 167 /* MDD (Enable Malicious Driver Detection)
 168  *
 169  * Only available when SR-IOV is enabled - max_vfs is greater than 0
 170  *
 171  * Valid Range: 0, 1
 172  *
 173  * Default Value:  1
 174  */
 175 IGB_PARAM(MDD, "Malicious Driver Detection (0/1), default 1 = enabled. "
 176           "Only available when max_vfs is greater than 0");
 177
 178 #ifdef DEBUG
 179
 180 /* Disable Hardware Reset on Tx Hang
 181  *
 182  * Valid Range: 0, 1
 183  *
 184  * Default Value: 0 (disabled, i.e. h/w will reset)
 185  */
 186 IGB_PARAM(DisableHwReset, "Disable reset of hardware on Tx hang");
 187
 188 /* Dump Transmit and Receive buffers
 189  *
 190  * Valid Range: 0, 1
 191  *
 192  * Default Value: 0
 193  */
 194 IGB_PARAM(DumpBuffers, "Dump Tx/Rx buffers on Tx hang or by request");
 195
 196 #endif /* DEBUG */
 197
 198 /* QueuePairs (Enable TX/RX queue pairs for interrupt handling)
 199  *
 200  * Valid Range: 0 - 1
 201  *
 202  * Default Value:  1
 203  */
 204 IGB_PARAM(QueuePairs, "Enable Tx/Rx queue pairs for interrupt handling (0,1), default 1=on");
 205
 206 #define DEFAULT_QUEUE_PAIRS           1
 207 #define MAX_QUEUE_PAIRS               1
 208 #define MIN_QUEUE_PAIRS               0
 209
 210 /* Enable/disable EEE (a.k.a. IEEE802.3az)
 211  *
 212  * Valid Range: 0, 1
 213  *
 214  * Default Value: 1
 215  */
 216  IGB_PARAM(EEE, "Enable/disable on parts that support the feature");
 217
 218 /* Enable/disable DMA Coalescing
 219  *
 220  * Valid Values: 0(off), 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000,
 221  * 9000, 10000(msec), 250(usec), 500(usec)
 222  *
 223  * Default Value: 0
 224  */
 225  IGB_PARAM(DMAC, "Disable or set latency for DMA Coalescing ((0=off, 1000-10000(msec), 250, 500 (usec))");
 226
 227 #ifndef IGB_NO_LRO
 228 /* Enable/disable Large Receive Offload
 229  *
 230  * Valid Values: 0(off), 1(on)
 231  *
 232  * Default Value: 0
 233  */
 234  IGB_PARAM(LRO, "Large Receive Offload (0,1), default 0=off");
 235
 236 #endif
 237 struct igb_opt_list {
 238         int i;
 239         char *str;
 240 };
 241 struct igb_option {
 242         enum { enable_option, range_option, list_option } type;
 243         const char *name;
 244         const char *err;
 245         int def;
 246         union {
 247                 struct { /* range_option info */
 248                         int min;
 249                         int max;
 250                 } r;
 251                 struct { /* list_option info */
 252                         int nr;
 253                         struct igb_opt_list *p;
 254                 } l;
 255         } arg;
 256 };
 257
 258 static int igb_validate_option(unsigned int *value,
 259                                struct igb_option *opt,
 260                                struct igb_adapter *adapter)
 261 {
 262         if (*value == OPTION_UNSET) {
 263                 *value = opt->def;
 264                 return 0;
 265         }
 266
 267         switch (opt->type) {
 268         case enable_option:
 269                 switch (*value) {
 270                 case OPTION_ENABLED:
 271                         DPRINTK(PROBE, INFO, "%s Enabled\n", opt->name);
 272                         return 0;
 273                 case OPTION_DISABLED:
 274                         DPRINTK(PROBE, INFO, "%s Disabled\n", opt->name);
 275                         return 0;
 276                 }
 277                 break;
 278         case range_option:
 279                 if (*value >= opt->arg.r.min && *value <= opt->arg.r.max) {
 280                         DPRINTK(PROBE, INFO,
 281                                         "%s set to %d\n", opt->name, *value);
 282                         return 0;
 283                 }
 284                 break;
 285         case list_option: {
 286                 int i;
 287                 struct igb_opt_list *ent;
 288
 289                 for (i = 0; i < opt->arg.l.nr; i++) {
 290                         ent = &opt->arg.l.p[i];
 291                         if (*value == ent->i) {
 292                                 if (ent->str[0] != '\0')
 293                                         DPRINTK(PROBE, INFO, "%s\n", ent->str);
 294                                 return 0;
 295                         }
 296                 }
 297         }
 298                 break;
 299         default:
 300                 BUG();
 301         }
 302
 303         DPRINTK(PROBE, INFO, "Invalid %s value specified (%d) %s\n",
 304                opt->name, *value, opt->err);
 305         *value = opt->def;
 306         return -1;
 307 }
 308
 309 /**
 310  * igb_check_options - Range Checking for Command Line Parameters
 311  * @adapter: board private structure
 312  *
 313  * This routine checks all command line parameters for valid user
 314  * input.  If an invalid value is given, or if no user specified
 315  * value exists, a default value is used.  The final value is stored
 316  * in a variable in the adapter structure.
 317  **/
 318
 319 void igb_check_options(struct igb_adapter *adapter)
 320 {
 321         int bd = adapter->bd_number;
 322         struct e1000_hw *hw = &adapter->hw;
 323
 324         if (bd >= IGB_MAX_NIC) {
 325                 DPRINTK(PROBE, NOTICE,
 326                        "Warning: no configuration for board #%d\n", bd);
 327                 DPRINTK(PROBE, NOTICE, "Using defaults for all values\n");
 328 #ifndef module_param_array
 329                 bd = IGB_MAX_NIC;
 330 #endif
 331         }
 332
 333         { /* Interrupt Throttling Rate */
 334                 struct igb_option opt = {
 335                         .type = range_option,
 336                         .name = "Interrupt Throttling Rate (ints/sec)",
 337                         .err  = "using default of " __MODULE_STRING(DEFAULT_ITR),
 338                         .def  = DEFAULT_ITR,
 339                         .arg  = { .r = { .min = MIN_ITR,
 340                                          .max = MAX_ITR } }
 341                 };
 342
 343 #ifdef module_param_array
 344                 if (num_InterruptThrottleRate > bd) {
 345 #endif
 346                         unsigned int itr = InterruptThrottleRate[bd];
 347
 348                         switch (itr) {
 349                         case 0:
 350                                 DPRINTK(PROBE, INFO, "%s turned off\n",
 351                                         opt.name);
 352                                 if (hw->mac.type >= e1000_i350)
 353                                         adapter->dmac = IGB_DMAC_DISABLE;
 354                                 adapter->rx_itr_setting = itr;
 355                                 break;
 356                         case 1:
 357                                 DPRINTK(PROBE, INFO, "%s set to dynamic mode\n",
 358                                         opt.name);
 359                                 adapter->rx_itr_setting = itr;
 360                                 break;
 361                         case 3:
 362                                 DPRINTK(PROBE, INFO,
 363                                         "%s set to dynamic conservative mode\n",
 364                                         opt.name);
 365                                 adapter->rx_itr_setting = itr;
 366                                 break;
 367                         default:
 368                                 igb_validate_option(&itr, &opt, adapter);
 369                                 /* Save the setting, because the dynamic bits
 370                                  * change itr.  In case of invalid user value,
 371                                  * default to conservative mode, else need to
 372                                  * clear the lower two bits because they are
 373                                  * used as control */
 374                                 if (itr == 3) {
 375                                         adapter->rx_itr_setting = itr;
 376                                 } else {
 377                                         adapter->rx_itr_setting = 1000000000 /
 378                                                                   (itr * 256);
 379                                         adapter->rx_itr_setting &= ~3;
 380                                 }
 381                                 break;
 382                         }
 383 #ifdef module_param_array
 384                 } else {
 385                         adapter->rx_itr_setting = opt.def;
 386                 }
 387 #endif
 388                 adapter->tx_itr_setting = adapter->rx_itr_setting;
 389         }
 390         { /* Interrupt Mode */
 391                 struct igb_option opt = {
 392                         .type = range_option,
 393                         .name = "Interrupt Mode",
 394                         .err  = "defaulting to 2 (MSI-X)",
 395                         .def  = IGB_INT_MODE_MSIX,
 396                         .arg  = { .r = { .min = MIN_INTMODE,
 397                                          .max = MAX_INTMODE } }
 398                 };
 399
 400 #ifdef module_param_array
 401                 if (num_IntMode > bd) {
 402 #endif
 403                         unsigned int int_mode = IntMode[bd];
 404                         igb_validate_option(&int_mode, &opt, adapter);
 405                         adapter->int_mode = int_mode;
 406 #ifdef module_param_array
 407                 } else {
 408                         adapter->int_mode = opt.def;
 409                 }
 410 #endif
 411         }
 412         { /* Low Latency Interrupt TCP Port */
 413                 struct igb_option opt = {
 414                         .type = range_option,
 415                         .name = "Low Latency Interrupt TCP Port",
 416                         .err  = "using default of " __MODULE_STRING(DEFAULT_LLIPORT),
 417                         .def  = DEFAULT_LLIPORT,
 418                         .arg  = { .r = { .min = MIN_LLIPORT,
 419                                          .max = MAX_LLIPORT } }
 420                 };
 421
 422 #ifdef module_param_array
 423                 if (num_LLIPort > bd) {
 424 #endif
 425                         adapter->lli_port = LLIPort[bd];
 426                         if (adapter->lli_port) {
 427                                 igb_validate_option(&adapter->lli_port, &opt,
 428                                         adapter);
 429                         } else {
 430                                 DPRINTK(PROBE, INFO, "%s turned off\n",
 431                                         opt.name);
 432                         }
 433 #ifdef module_param_array
 434                 } else {
 435                         adapter->lli_port = opt.def;
 436                 }
 437 #endif
 438         }
 439         { /* Low Latency Interrupt on Packet Size */
 440                 struct igb_option opt = {
 441                         .type = range_option,
 442                         .name = "Low Latency Interrupt on Packet Size",
 443                         .err  = "using default of " __MODULE_STRING(DEFAULT_LLISIZE),
 444                         .def  = DEFAULT_LLISIZE,
 445                         .arg  = { .r = { .min = MIN_LLISIZE,
 446                                          .max = MAX_LLISIZE } }
 447                 };
 448
 449 #ifdef module_param_array
 450                 if (num_LLISize > bd) {
 451 #endif
 452                         adapter->lli_size = LLISize[bd];
 453                         if (adapter->lli_size) {
 454                                 igb_validate_option(&adapter->lli_size, &opt,
 455                                         adapter);
 456                         } else {
 457                                 DPRINTK(PROBE, INFO, "%s turned off\n",
 458                                         opt.name);
 459                         }
 460 #ifdef module_param_array
 461                 } else {
 462                         adapter->lli_size = opt.def;
 463                 }
 464 #endif
 465         }
 466         { /* Low Latency Interrupt on TCP Push flag */
 467                 struct igb_option opt = {
 468                         .type = enable_option,
 469                         .name = "Low Latency Interrupt on TCP Push flag",
 470                         .err  = "defaulting to Disabled",
 471                         .def  = OPTION_DISABLED
 472                 };
 473
 474 #ifdef module_param_array
 475                 if (num_LLIPush > bd) {
 476 #endif
 477                         unsigned int lli_push = LLIPush[bd];
 478                         igb_validate_option(&lli_push, &opt, adapter);
 479                         adapter->flags |= lli_push ? IGB_FLAG_LLI_PUSH : 0;
 480 #ifdef module_param_array
 481                 } else {
 482                         adapter->flags |= opt.def ? IGB_FLAG_LLI_PUSH : 0;
 483                 }
 484 #endif
 485         }
 486         { /* SRIOV - Enable SR-IOV VF devices */
 487                 struct igb_option opt = {
 488                         .type = range_option,
 489                         .name = "max_vfs - SR-IOV VF devices",
 490                         .err  = "using default of " __MODULE_STRING(DEFAULT_SRIOV),
 491                         .def  = DEFAULT_SRIOV,
 492                         .arg  = { .r = { .min = MIN_SRIOV,
 493                                          .max = MAX_SRIOV } }
 494                 };
 495
 496 #ifdef module_param_array
 497                 if (num_max_vfs > bd) {
 498 #endif
 499                         adapter->vfs_allocated_count = max_vfs[bd];
 500                         igb_validate_option(&adapter->vfs_allocated_count, &opt, adapter);
 501
 502 #ifdef module_param_array
 503                 } else {
 504                         adapter->vfs_allocated_count = opt.def;
 505                 }
 506 #endif
 507                 if (adapter->vfs_allocated_count) {
 508                         switch (hw->mac.type) {
 509                         case e1000_82575:
 510                         case e1000_82580:
 511                         case e1000_i210:
 512                         case e1000_i211:
 513                         case e1000_i354:
 514                                 adapter->vfs_allocated_count = 0;
 515                                 DPRINTK(PROBE, INFO, "SR-IOV option max_vfs not supported.\n");
 516                         default:
 517                                 break;
 518                         }
 519                 }
 520         }
 521         { /* VMDQ - Enable VMDq multiqueue receive */
 522                 struct igb_option opt = {
 523                         .type = range_option,
 524                         .name = "VMDQ - VMDq multiqueue queue count",
 525                         .err  = "using default of " __MODULE_STRING(DEFAULT_VMDQ),
 526                         .def  = DEFAULT_VMDQ,
 527                         .arg  = { .r = { .min = MIN_VMDQ,
 528                                          .max = (MAX_VMDQ - adapter->vfs_allocated_count) } }
 529                 };
 530                 if ((hw->mac.type != e1000_i210) ||
 531                     (hw->mac.type != e1000_i211)) {
 532 #ifdef module_param_array
 533                 if (num_VMDQ > bd) {
 534 #endif
 535                         adapter->vmdq_pools = (VMDQ[bd] == 1 ? 0 : VMDQ[bd]);
 536                         if (adapter->vfs_allocated_count && !adapter->vmdq_pools) {
 537                                 DPRINTK(PROBE, INFO, "Enabling SR-IOV requires VMDq be set to at least 1\n");
 538                                 adapter->vmdq_pools = 1;
 539                         }
 540                         igb_validate_option(&adapter->vmdq_pools, &opt, adapter);
 541
 542 #ifdef module_param_array
 543                 } else {
 544                         if (!adapter->vfs_allocated_count)
 545                                 adapter->vmdq_pools = (opt.def == 1 ? 0 : opt.def);
 546                         else
 547                                 adapter->vmdq_pools = 1;
 548                 }
 549 #endif
 550 #ifdef CONFIG_IGB_VMDQ_NETDEV
 551                 if (hw->mac.type == e1000_82575 && adapter->vmdq_pools) {
 552                         DPRINTK(PROBE, INFO, "VMDq not supported on this part.\n");
 553                         adapter->vmdq_pools = 0;
 554                 }
 555 #endif
 556
 557         } else {
 558                 DPRINTK(PROBE, INFO, "VMDq option is not supported.\n");
 559                 adapter->vmdq_pools = opt.def;
 560         }
 561         }
 562         { /* RSS - Enable RSS multiqueue receives */
 563                 struct igb_option opt = {
 564                         .type = range_option,
 565                         .name = "RSS - RSS multiqueue receive count",
 566                         .err  = "using default of " __MODULE_STRING(DEFAULT_RSS),
 567                         .def  = DEFAULT_RSS,
 568                         .arg  = { .r = { .min = MIN_RSS,
 569                                          .max = MAX_RSS } }
 570                 };
 571
 572                 switch (hw->mac.type) {
 573                 case e1000_82575:
 574 #ifndef CONFIG_IGB_VMDQ_NETDEV
 575                         if (!!adapter->vmdq_pools) {
 576                                 if (adapter->vmdq_pools <= 2) {
 577                                         if (adapter->vmdq_pools == 2)
 578                                                 opt.arg.r.max = 3;
 579                                 } else {
 580                                         opt.arg.r.max = 1;
 581                                 }
 582                         } else {
 583                                 opt.arg.r.max = 4;
 584                         }
 585 #else
 586                         opt.arg.r.max = !!adapter->vmdq_pools ? 1 : 4;
 587 #endif /* CONFIG_IGB_VMDQ_NETDEV */
 588                         break;
 589                 case e1000_i210:
 590                         opt.arg.r.max = 4;
 591                         break;
 592                 case e1000_i211:
 593                         opt.arg.r.max = 2;
 594                         break;
 595                 case e1000_82576:
 596 #ifndef CONFIG_IGB_VMDQ_NETDEV
 597                         if (!!adapter->vmdq_pools)
 598                                 opt.arg.r.max = 2;
 599                         break;
 600 #endif /* CONFIG_IGB_VMDQ_NETDEV */
 601                 case e1000_82580:
 602                 case e1000_i350:
 603                 case e1000_i354:
 604                 default:
 605                         if (!!adapter->vmdq_pools)
 606                                 opt.arg.r.max = 1;
 607                         break;
 608                 }
 609
 610                 if (adapter->int_mode != IGB_INT_MODE_MSIX) {
 611                         DPRINTK(PROBE, INFO, "RSS is not supported when in MSI/Legacy Interrupt mode, %s\n",
 612                                 opt.err);
 613                         opt.arg.r.max = 1;
 614                 }
 615
 616 #ifdef module_param_array
 617                 if (num_RSS > bd) {
 618 #endif
 619                         adapter->rss_queues = RSS[bd];
 620                         switch (adapter->rss_queues) {
 621                         case 1:
 622                                 break;
 623                         default:
 624                                 igb_validate_option(&adapter->rss_queues, &opt, adapter);
 625                                 if (adapter->rss_queues)
 626                                         break;
 627                         case 0:
 628                                 adapter->rss_queues = min_t(u32, opt.arg.r.max, num_online_cpus());
 629                                 break;
 630                         }
 631 #ifdef module_param_array
 632                 } else {
 633                         adapter->rss_queues = opt.def;
 634                 }
 635 #endif
 636         }
 637         { /* QueuePairs - Enable Tx/Rx queue pairs for interrupt handling */
 638                 struct igb_option opt = {
 639                         .type = enable_option,
 640                         .name = "QueuePairs - Tx/Rx queue pairs for interrupt handling",
 641                         .err  = "defaulting to Enabled",
 642                         .def  = OPTION_ENABLED
 643                 };
 644 #ifdef module_param_array
 645                 if (num_QueuePairs > bd) {
 646 #endif
 647                         unsigned int qp = QueuePairs[bd];
 648                         /*
 649                          * We must enable queue pairs if the number of queues
 650                          * exceeds the number of available interrupts. We are
 651                          * limited to 10, or 3 per unallocated vf. On I210 and
 652                          * I211 devices, we are limited to 5 interrupts.
 653                          * However, since I211 only supports 2 queues, we do not
 654                          * need to check and override the user option.
 655                          */
 656                         if (qp == OPTION_DISABLED) {
 657                                 if (adapter->rss_queues > 4)
 658                                         qp = OPTION_ENABLED;
 659
 660                                 if (adapter->vmdq_pools > 4)
 661                                         qp = OPTION_ENABLED;
 662
 663                                 if (adapter->rss_queues > 1 &&
 664                                     (adapter->vmdq_pools > 3 ||
 665                                      adapter->vfs_allocated_count > 6))
 666                                         qp = OPTION_ENABLED;
 667
 668                                 if (hw->mac.type == e1000_i210 &&
 669                                     adapter->rss_queues > 2)
 670                                         qp = OPTION_ENABLED;
 671
 672                                 if (qp == OPTION_ENABLED)
 673                                         DPRINTK(PROBE, INFO, "Number of queues exceeds available interrupts, %s\n",
 674                                                 opt.err);
 675                         }
 676                         igb_validate_option(&qp, &opt, adapter);
 677                         adapter->flags |= qp ? IGB_FLAG_QUEUE_PAIRS : 0;
 678 #ifdef module_param_array
 679                 } else {
 680                         adapter->flags |= opt.def ? IGB_FLAG_QUEUE_PAIRS : 0;
 681                 }
 682 #endif
 683         }
 684         { /* EEE -  Enable EEE for capable adapters */
 685
 686                 if (hw->mac.type >= e1000_i350) {
 687                         struct igb_option opt = {
 688                                 .type = enable_option,
 689                                 .name = "EEE Support",
 690                                 .err  = "defaulting to Enabled",
 691                                 .def  = OPTION_ENABLED
 692                         };
 693 #ifdef module_param_array
 694                         if (num_EEE > bd) {
 695 #endif
 696                                 unsigned int eee = EEE[bd];
 697                                 igb_validate_option(&eee, &opt, adapter);
 698                                 adapter->flags |= eee ? IGB_FLAG_EEE : 0;
 699                                 if (eee)
 700                                         hw->dev_spec._82575.eee_disable = false;
 701                                 else
 702                                         hw->dev_spec._82575.eee_disable = true;
 703
 704 #ifdef module_param_array
 705                         } else {
 706                                 adapter->flags |= opt.def ? IGB_FLAG_EEE : 0;
 707                                 if (adapter->flags & IGB_FLAG_EEE)
 708                                         hw->dev_spec._82575.eee_disable = false;
 709                                 else
 710                                         hw->dev_spec._82575.eee_disable = true;
 711                         }
 712 #endif
 713                 }
 714         }
 715         { /* DMAC -  Enable DMA Coalescing for capable adapters */
 716
 717                 if (hw->mac.type >= e1000_i350) {
 718                         struct igb_opt_list list [] = {
 719                                 { IGB_DMAC_DISABLE, "DMAC Disable"},
 720                                 { IGB_DMAC_MIN, "DMAC 250 usec"},
 721                                 { IGB_DMAC_500, "DMAC 500 usec"},
 722                                 { IGB_DMAC_EN_DEFAULT, "DMAC 1000 usec"},
 723                                 { IGB_DMAC_2000, "DMAC 2000 usec"},
 724                                 { IGB_DMAC_3000, "DMAC 3000 usec"},
 725                                 { IGB_DMAC_4000, "DMAC 4000 usec"},
 726                                 { IGB_DMAC_5000, "DMAC 5000 usec"},
 727                                 { IGB_DMAC_6000, "DMAC 6000 usec"},
 728                                 { IGB_DMAC_7000, "DMAC 7000 usec"},
 729                                 { IGB_DMAC_8000, "DMAC 8000 usec"},
 730                                 { IGB_DMAC_9000, "DMAC 9000 usec"},
 731                                 { IGB_DMAC_MAX, "DMAC 10000 usec"}
 732                         };
 733                         struct igb_option opt = {
 734                                 .type = list_option,
 735                                 .name = "DMA Coalescing",
 736                                 .err  = "using default of "__MODULE_STRING(IGB_DMAC_DISABLE),
 737                                 .def  = IGB_DMAC_DISABLE,
 738                                 .arg = { .l = { .nr = 13,
 739                                                 .p = list
 740                                         }
 741                                 }
 742                         };
 743 #ifdef module_param_array
 744                         if (num_DMAC > bd) {
 745 #endif
 746                                 unsigned int dmac = DMAC[bd];
 747                                 if (adapter->rx_itr_setting == IGB_DMAC_DISABLE)
 748                                         dmac = IGB_DMAC_DISABLE;
 749                                 igb_validate_option(&dmac, &opt, adapter);
 750                                 switch (dmac) {
 751                                 case IGB_DMAC_DISABLE:
 752                                         adapter->dmac = dmac;
 753                                         break;
 754                                 case IGB_DMAC_MIN:
 755                                         adapter->dmac = dmac;
 756                                         break;
 757                                 case IGB_DMAC_500:
 758                                         adapter->dmac = dmac;
 759                                         break;
 760                                 case IGB_DMAC_EN_DEFAULT:
 761                                         adapter->dmac = dmac;
 762                                         break;
 763                                 case IGB_DMAC_2000:
 764                                         adapter->dmac = dmac;
 765                                         break;
 766                                 case IGB_DMAC_3000:
 767                                         adapter->dmac = dmac;
 768                                         break;
 769                                 case IGB_DMAC_4000:
 770                                         adapter->dmac = dmac;
 771                                         break;
 772                                 case IGB_DMAC_5000:
 773                                         adapter->dmac = dmac;
 774                                         break;
 775                                 case IGB_DMAC_6000:
 776                                         adapter->dmac = dmac;
 777                                         break;
 778                                 case IGB_DMAC_7000:
 779                                         adapter->dmac = dmac;
 780                                         break;
 781                                 case IGB_DMAC_8000:
 782                                         adapter->dmac = dmac;
 783                                         break;
 784                                 case IGB_DMAC_9000:
 785                                         adapter->dmac = dmac;
 786                                         break;
 787                                 case IGB_DMAC_MAX:
 788                                         adapter->dmac = dmac;
 789                                         break;
 790                                 default:
 791                                         adapter->dmac = opt.def;
 792                                         DPRINTK(PROBE, INFO,
 793                                         "Invalid DMAC setting, "
 794                                         "resetting DMAC to %d\n", opt.def);
 795                                 }
 796 #ifdef module_param_array
 797                         } else
 798                                 adapter->dmac = opt.def;
 799 #endif
 800                 }
 801         }
 802 #ifndef IGB_NO_LRO
 803         { /* LRO - Enable Large Receive Offload */
 804                 struct igb_option opt = {
 805                         .type = enable_option,
 806                         .name = "LRO - Large Receive Offload",
 807                         .err  = "defaulting to Disabled",
 808                         .def  = OPTION_DISABLED
 809                 };
 810                 struct net_device *netdev = adapter->netdev;
 811 #ifdef module_param_array
 812                 if (num_LRO > bd) {
 813 #endif
 814                         unsigned int lro = LRO[bd];
 815                         igb_validate_option(&lro, &opt, adapter);
 816                         netdev->features |= lro ? NETIF_F_LRO : 0;
 817 #ifdef module_param_array
 818                 } else if (opt.def == OPTION_ENABLED) {
 819                         netdev->features |= NETIF_F_LRO;
 820                 }
 821 #endif
 822         }
 823 #endif /* IGB_NO_LRO */
 824         { /* MDD - Enable Malicious Driver Detection. Only available when
 825              SR-IOV is enabled. */
 826                 struct igb_option opt = {
 827                         .type = enable_option,
 828                         .name = "Malicious Driver Detection",
 829                         .err  = "defaulting to 1",
 830                         .def  = OPTION_ENABLED,
 831                         .arg  = { .r = { .min = OPTION_DISABLED,
 832                                          .max = OPTION_ENABLED } }
 833                 };
 834
 835 #ifdef module_param_array
 836                 if (num_MDD > bd) {
 837 #endif
 838                         adapter->mdd = MDD[bd];
 839                         igb_validate_option((uint *)&adapter->mdd, &opt,
 840                                             adapter);
 841 #ifdef module_param_array
 842                 } else {
 843                         adapter->mdd = opt.def;
 844                 }
 845 #endif
 846         }
 847 }