/**
* ixgbe_check_options - Range Checking for Command Line Parameters
* @adapter: board private structure
*
* This routine checks all command line parameters for valid user
* input. If an invalid value is given, or if no user specified
* value exists, a default value is used. The final value is stored
* in a variable in the adapter structure.
**/
void __devinit ixgbe_check_options(struct ixgbe_adapter *adapter)
{
int bd = adapter->bd_number;
u32 *aflags = &adapter->flags;
if (bd >= IXGBE_MAX_NIC) {
printk(KERN_NOTICE
"Warning: no configuration for board #%d\n", bd);
printk(KERN_NOTICE "Using defaults for all values\n");
}
{ /* Interrupt Mode */
unsigned int i_mode;
static struct ixgbe_option opt = {
.type = range_option,
.name = "Interrupt Mode",
.err =
"using default of "__MODULE_STRING(IXGBE_DEFAULT_INT),
.def = IXGBE_DEFAULT_INT,
.arg = { .r = { .min = IXGBE_INT_LEGACY,
.max = IXGBE_INT_MSIX}}
};
/* enable MSI/MSI-X capabilities by default */
*aflags |= IXGBE_FLAG_MSIX_CAPABLE;
*aflags |= IXGBE_FLAG_MSI_CAPABLE;
if (num_IntMode > bd) {
/* take the minimum of whatever was set */
i_mode = IntMode[bd];
ixgbe_validate_option(&i_mode, &opt);
switch (i_mode) {
case IXGBE_INT_MSIX:
break;
case IXGBE_INT_LEGACY:
*aflags &= ~IXGBE_FLAG_MSI_CAPABLE;
/* fall through */
case IXGBE_INT_MSI:
*aflags &= ~IXGBE_FLAG_MSIX_CAPABLE;
*aflags &= ~IXGBE_FLAG_RSS_ENABLED;
break;
default:
*aflags &= ~IXGBE_FLAG_MSIX_CAPABLE;
*aflags &= ~IXGBE_FLAG_MSI_CAPABLE;
break;
}
}
/* empty code line with semi-colon */ ;
}
}
/**
* ixgbe_check_options - Range Checking for Command Line Parameters
* @adapter: board private structure
*
* This routine checks all command line parameters for valid user
* input. If an invalid value is given, or if no user specified
* value exists, a default value is used. The final value is stored
* in a variable in the adapter structure.
**/
void __devinit ixgbe_check_options(struct ixgbe_adapter *adapter)
{
int bd = adapter->bd_number;
u32 *aflags = &adapter->flags;
struct ixgbe_ring_feature *feature = adapter->ring_feature;
if (bd >= IXGBE_MAX_NIC) {
printk(KERN_NOTICE
"Warning: no configuration for board #%d\n", bd);
printk(KERN_NOTICE "Using defaults for all values\n");
#ifndef module_param_array
bd = IXGBE_MAX_NIC;
#endif
}
{ /* Linux RX Stack Support */
static struct ixgbe_option opt = {
.type = enable_option,
.name = "Linux TCP/IP stack RX",
.err = "defaulting to Disabled",
.def = OPTION_DISABLED
};
#ifdef module_param_array
if (num_RXKernel > bd) {
#endif
unsigned int tmp = RXKernel[bd];
ixgbe_validate_option(&tmp, &opt);
if (tmp)
*aflags |= IXGBE_FLAG_RX_KERNEL_ENABLE;
else
*aflags &= ~IXGBE_FLAG_RX_KERNEL_ENABLE;
#ifdef module_param_array
} else {
if (opt.def == OPTION_ENABLED)
*aflags |= IXGBE_FLAG_RX_KERNEL_ENABLE;
else
*aflags &= ~IXGBE_FLAG_RX_KERNEL_ENABLE;
}
#endif
}
{ /* Interrupt Type */
unsigned int i_type;
static struct ixgbe_option opt = {
.type = range_option,
.name = "Interrupt Type",
.err =
"using default of "__MODULE_STRING(IXGBE_DEFAULT_INT),
.def = IXGBE_DEFAULT_INT,
.arg = { .r = { .min = IXGBE_INT_LEGACY,
.max = IXGBE_INT_MSIX}}
};
#ifdef module_param_array
if (num_InterruptType > bd) {
#endif
i_type = InterruptType[bd];
ixgbe_validate_option(&i_type, &opt);
switch (i_type) {
case IXGBE_INT_MSIX:
if (!(*aflags & IXGBE_FLAG_MSIX_CAPABLE))
printk(KERN_INFO
"Ignoring MSI-X setting; "
"support unavailable\n");
break;
case IXGBE_INT_MSI:
if (!(*aflags & IXGBE_FLAG_MSI_CAPABLE)) {
printk(KERN_INFO
"Ignoring MSI setting; "
"support unavailable\n");
} else {
*aflags &= ~IXGBE_FLAG_MSIX_CAPABLE;
*aflags &= ~IXGBE_FLAG_DCB_CAPABLE;
}
break;
case IXGBE_INT_LEGACY:
default:
*aflags &= ~IXGBE_FLAG_MSIX_CAPABLE;
*aflags &= ~IXGBE_FLAG_MSI_CAPABLE;
*aflags &= ~IXGBE_FLAG_DCB_CAPABLE;
break;
}
#ifdef module_param_array
} else {
*aflags |= IXGBE_FLAG_MSIX_CAPABLE;
*aflags |= IXGBE_FLAG_MSI_CAPABLE;
}
#endif
}
#if defined(CONFIG_DCA) || defined(CONFIG_DCA_MODULE)
{ /* Direct Cache Access (DCA) */
static struct ixgbe_option opt = {
.type = range_option,
.name = "Direct Cache Access (DCA)",
.err = "defaulting to Enabled",
.def = OPTION_DISABLED,
.arg = { .r = { .min = OPTION_DISABLED,
.max = IXGBE_MAX_DCA}}
};
unsigned int dca = opt.def;
#ifdef module_param_array
if (num_DCA > bd) {
#endif
dca = DCA[bd];
ixgbe_validate_option(&dca, &opt);
if (!dca)
*aflags &= ~IXGBE_FLAG_DCA_CAPABLE;
/* Check Interoperability */
if (!(*aflags & IXGBE_FLAG_DCA_CAPABLE)) {
DPRINTK(PROBE, INFO, "DCA is disabled\n");
*aflags &= ~IXGBE_FLAG_DCA_ENABLED;
}
if (dca == IXGBE_MAX_DCA) {
DPRINTK(PROBE, INFO,
"DCA enabled for rx data\n");
adapter->flags |= IXGBE_FLAG_DCA_ENABLED_DATA;
}
#ifdef module_param_array
} else {
/* make sure to clear the capability flag if the
* option is disabled by default above */
if (opt.def == OPTION_DISABLED)
*aflags &= ~IXGBE_FLAG_DCA_CAPABLE;
}
#endif
if (dca == IXGBE_MAX_DCA)
adapter->flags |= IXGBE_FLAG_DCA_ENABLED_DATA;
}
#endif /* CONFIG_DCA or CONFIG_DCA_MODULE */
{ /* # of RX queues with RSS (RXQ) */
static struct ixgbe_option opt = {
.type = range_option,
.name = "RX queues (RXQ)",
.err = "using default.",
.def = 0,
.arg = { .r = { .min = 0,
.max = IXGBE_MAX_RSS_INDICES}}
};
unsigned int rxq = RXQ[bd];
#ifdef module_param_array
if (num_RXQ > bd) {
#endif
switch (rxq) {
case 0:
/*
* Base it off num_online_cpus() with
* a hardware limit cap.
*/
rxq = min(IXGBE_MAX_RSS_INDICES,
(int)num_online_cpus());
break;
default:
ixgbe_validate_option(&rxq, &opt);
break;
}
feature[RING_F_RXQ].indices = rxq;
*aflags |= IXGBE_FLAG_RSS_ENABLED;
#ifdef module_param_array
} else {
rxq = min(IXGBE_MAX_RSS_INDICES,
(int)num_online_cpus());
feature[RING_F_RXQ].indices = rxq;
*aflags |= IXGBE_FLAG_RSS_ENABLED;
}
#endif
}
{ /* # of TX queues (TXQ) */
static struct ixgbe_option opt = {
.type = range_option,
.name = "TX queues (TXQ)",
.err = "using default.",
.def = 0,
.arg = { .r = { .min = 0,
.max = IXGBE_MAX_RSS_INDICES}}
};
unsigned int txq = TXQ[bd];
#ifdef module_param_array
if (num_TXQ > bd) {
#endif
switch (txq) {
case 0:
/*
* Base it off num_online_cpus() with
* a hardware limit cap.
*/
txq = min(IXGBE_MAX_RSS_INDICES,
(int)num_online_cpus());
break;
default:
ixgbe_validate_option(&txq, &opt);
break;
}
feature[RING_F_TXQ].indices = txq;
#ifdef module_param_array
} else {
txq = min(IXGBE_MAX_RSS_INDICES,
(int)num_online_cpus());
feature[RING_F_TXQ].indices = txq;
}
#endif
}
{ /* Interrupt Throttling Rate */
static struct ixgbe_option opt = {
.type = range_option,
.name = "Interrupt Throttling Rate (ints/sec)",
.err = "using default of "__MODULE_STRING(DEFAULT_ITR),
.def = DEFAULT_ITR,
.arg = { .r = { .min = MIN_ITR,
.max = MAX_ITR }}
};
#ifdef module_param_array
if (num_InterruptThrottleRate > bd) {
#endif
u32 eitr = InterruptThrottleRate[bd];
switch (eitr) {
case 0:
DPRINTK(PROBE, INFO, "%s turned off\n",
opt.name);
/*
* zero is a special value, we don't want to
* turn off ITR completely, just set it to an
* insane interrupt rate
*/
adapter->eitr_param = IXGBE_MAX_INT_RATE;
adapter->itr_setting = 0;
break;
case 1:
DPRINTK(PROBE, INFO, "dynamic interrupt "
"throttling enabled\n");
adapter->eitr_param = 20000;
adapter->itr_setting = 1;
break;
default:
ixgbe_validate_option(&eitr, &opt);
adapter->eitr_param = eitr;
/* the first bit is used as control */
adapter->itr_setting = eitr & ~1;
break;
}
#ifdef module_param_array
} else {
adapter->eitr_param = DEFAULT_ITR;
adapter->itr_setting = DEFAULT_ITR;
}
#endif
}
#ifndef IXGBE_NO_LLI
{ /* Low Latency Interrupt TCP Port*/
static struct ixgbe_option opt = {
.type = range_option,
.name = "Low Latency Interrupt TCP Port",
.err = "using default of "
__MODULE_STRING(DEFAULT_LLIPORT),
.def = DEFAULT_LLIPORT,
.arg = { .r = { .min = MIN_LLIPORT,
.max = MAX_LLIPORT }}
};
#ifdef module_param_array
if (num_LLIPort > bd) {
#endif
adapter->lli_port = LLIPort[bd];
if (adapter->lli_port) {
ixgbe_validate_option(&adapter->lli_port, &opt);
} else {
DPRINTK(PROBE, INFO, "%s turned off\n",
opt.name);
}
#ifdef module_param_array
} else {
adapter->lli_port = opt.def;
}
#endif
}
{ /* Low Latency Interrupt on Packet Size */
static struct ixgbe_option opt = {
.type = range_option,
.name = "Low Latency Interrupt on Packet Size",
.err = "using default of "
__MODULE_STRING(DEFAULT_LLISIZE),
.def = DEFAULT_LLISIZE,
.arg = { .r = { .min = MIN_LLISIZE,
.max = MAX_LLISIZE }}
};
#ifdef module_param_array
if (num_LLISize > bd) {
#endif
adapter->lli_size = LLISize[bd];
if (adapter->lli_size) {
ixgbe_validate_option(&adapter->lli_size, &opt);
} else {
DPRINTK(PROBE, INFO, "%s turned off\n",
opt.name);
}
#ifdef module_param_array
} else {
adapter->lli_size = opt.def;
}
#endif
}
{ /*Low Latency Interrupt on TCP Push flag*/
static struct ixgbe_option opt = {
.type = enable_option,
.name = "Low Latency Interrupt on TCP Push flag",
.err = "defaulting to Disabled",
.def = OPTION_DISABLED
};
#ifdef module_param_array
if (num_LLIPush > bd) {
#endif
unsigned int lli_push = LLIPush[bd];
ixgbe_validate_option(&lli_push, &opt);
if (lli_push)
*aflags |= IXGBE_FLAG_LLI_PUSH;
else
*aflags &= ~IXGBE_FLAG_LLI_PUSH;
#ifdef module_param_array
} else {
if (opt.def == OPTION_ENABLED)
*aflags |= IXGBE_FLAG_LLI_PUSH;
else
*aflags &= ~IXGBE_FLAG_LLI_PUSH;
}
#endif
}
{ /* Low Latency Interrupt EtherType*/
static struct ixgbe_option opt = {
.type = range_option,
.name = "Low Latency Interrupt on Ethernet Protocol Type",
.err = "using default of "
__MODULE_STRING(DEFAULT_LLIETYPE),
.def = DEFAULT_LLIETYPE,
.arg = { .r = { .min = MIN_LLIETYPE,
.max = MAX_LLIETYPE }}
};
#ifdef module_param_array
if (num_LLIEType > bd) {
#endif
adapter->lli_etype = LLIEType[bd];
if (adapter->lli_etype) {
ixgbe_validate_option(&adapter->lli_etype, &opt);
} else {
DPRINTK(PROBE, INFO, "%s turned off\n",
opt.name);
}
#ifdef module_param_array
} else {
adapter->lli_etype = opt.def;
}
#endif
}
{ /* LLI VLAN Priority */
static struct ixgbe_option opt = {
.type = range_option,
.name = "Low Latency Interrupt on VLAN priority threashold",
.err = "using default of "
__MODULE_STRING(DEFAULT_LLIVLANP),
.def = DEFAULT_LLIVLANP,
.arg = { .r = { .min = MIN_LLIVLANP,
.max = MAX_LLIVLANP }}
};
#ifdef module_param_array
if (num_LLIVLANP > bd) {
#endif
adapter->lli_vlan_pri = LLIVLANP[bd];
if (adapter->lli_vlan_pri) {
ixgbe_validate_option(&adapter->lli_vlan_pri, &opt);
} else {
DPRINTK(PROBE, INFO, "%s turned off\n",
opt.name);
}
#ifdef module_param_array
} else {
adapter->lli_vlan_pri = opt.def;
}
#endif
}
#endif /* IXGBE_NO_LLI */
{ /* Rx buffer mode */
unsigned int rx_buf_mode;
static struct ixgbe_option opt = {
.type = range_option,
.name = "Rx buffer mode",
.err = "using default of "
__MODULE_STRING(IXGBE_DEFAULT_RXBUFMODE),
.def = IXGBE_DEFAULT_RXBUFMODE,
.arg = {.r = {.min = IXGBE_RXBUFMODE_1BUF_ALWAYS,
.max = IXGBE_RXBUFMODE_OPTIMAL}}
};
#ifdef module_param_array
if (num_RxBufferMode > bd) {
#endif
rx_buf_mode = RxBufferMode[bd];
ixgbe_validate_option(&rx_buf_mode, &opt);
switch (rx_buf_mode) {
case IXGBE_RXBUFMODE_OPTIMAL:
*aflags |= IXGBE_FLAG_RX_1BUF_CAPABLE;
*aflags |= IXGBE_FLAG_RX_PS_CAPABLE;
break;
case IXGBE_RXBUFMODE_PS_ALWAYS:
*aflags |= IXGBE_FLAG_RX_PS_CAPABLE;
break;
case IXGBE_RXBUFMODE_1BUF_ALWAYS:
*aflags |= IXGBE_FLAG_RX_1BUF_CAPABLE;
default:
break;
}
#ifdef module_param_array
} else {
*aflags |= IXGBE_FLAG_RX_1BUF_CAPABLE;
*aflags |= IXGBE_FLAG_RX_PS_CAPABLE;
}
#endif
}
{ /* Flow Director filtering mode */
unsigned int fdir_filter_mode;
static struct ixgbe_option opt = {
.type = range_option,
.name = "Flow Director filtering mode",
.err = "using default of "
__MODULE_STRING(IXGBE_DEFAULT_FDIR_FILTER),
.def = IXGBE_DEFAULT_FDIR_FILTER,
.arg = {.r = {.min = IXGBE_FDIR_FILTER_OFF,
.max = IXGBE_FDIR_FILTER_PERFECT}}
};
*aflags &= ~IXGBE_FLAG_FDIR_HASH_CAPABLE;
*aflags &= ~IXGBE_FLAG_FDIR_PERFECT_CAPABLE;
if (adapter->hw.mac.type == ixgbe_mac_82598EB)
goto no_flow_director;
#ifdef module_param_array
if (num_FdirMode > bd) {
#endif
#ifdef HAVE_TX_MQ
fdir_filter_mode = FdirMode[bd];
#else
fdir_filter_mode = IXGBE_FDIR_FILTER_OFF;
#endif /* HAVE_TX_MQ */
ixgbe_validate_option(&fdir_filter_mode, &opt);
switch (fdir_filter_mode) {
case IXGBE_FDIR_FILTER_OFF:
DPRINTK(PROBE, INFO, "Flow Director disabled\n");
break;
case IXGBE_FDIR_FILTER_HASH:
*aflags |= IXGBE_FLAG_FDIR_HASH_CAPABLE;
*aflags &= ~IXGBE_FLAG_FDIR_PERFECT_CAPABLE;
feature[RING_F_FDIR].indices =
IXGBE_MAX_FDIR_INDICES;
DPRINTK(PROBE, INFO,
"Flow Director hash filtering enabled\n");
break;
case IXGBE_FDIR_FILTER_PERFECT:
*aflags &= ~IXGBE_FLAG_FDIR_HASH_CAPABLE;
*aflags |= IXGBE_FLAG_FDIR_PERFECT_CAPABLE;
feature[RING_F_FDIR].indices =
IXGBE_MAX_FDIR_INDICES;
spin_lock_init(&adapter->fdir_perfect_lock);
DPRINTK(PROBE, INFO,
"Flow Director perfect filtering enabled\n");
break;
default:
break;
}
#ifdef module_param_array
} else {
#ifdef HAVE_TX_MQ
if (opt.def != IXGBE_FDIR_FILTER_OFF) {
*aflags |= IXGBE_FLAG_FDIR_HASH_CAPABLE;
feature[RING_F_FDIR].indices = IXGBE_MAX_FDIR_INDICES;
DPRINTK(PROBE, INFO,
"Flow Director hash filtering enabled\n");
} else {
#endif /* HAVE_TX_MQ */
*aflags &= ~IXGBE_FLAG_FDIR_HASH_CAPABLE;
*aflags &= ~IXGBE_FLAG_FDIR_PERFECT_CAPABLE;
feature[RING_F_FDIR].indices = 0;
DPRINTK(PROBE, INFO,
"Flow Director hash filtering disabled\n");
#ifdef HAVE_TX_MQ
}
#endif /* HAVE_TX_MQ */
}
/* Check interoperability */
if ((*aflags & IXGBE_FLAG_FDIR_HASH_CAPABLE) ||
(*aflags & IXGBE_FLAG_FDIR_PERFECT_CAPABLE)) {
if (!(*aflags & IXGBE_FLAG_MQ_CAPABLE)) {
DPRINTK(PROBE, INFO,
"Flow Director is not supported "
"while multiple queues are disabled. "
"Disabling Flow Director\n");
*aflags &= ~IXGBE_FLAG_FDIR_HASH_CAPABLE;
*aflags &= ~IXGBE_FLAG_FDIR_PERFECT_CAPABLE;
}
}
#endif
no_flow_director:
/* empty code line with semi-colon */ ;
}
{ /* Flow Director packet buffer allocation */
unsigned int fdir_pballoc_mode;
static struct ixgbe_option opt = {
.type = range_option,
.name = "Flow Director packet buffer allocation",
.err = "using default of "
__MODULE_STRING(IXGBE_DEFAULT_FDIR_PBALLOC),
.def = IXGBE_DEFAULT_FDIR_PBALLOC,
.arg = {.r = {.min = IXGBE_FDIR_PBALLOC_64K,
.max = IXGBE_FDIR_PBALLOC_256K}}
};
char pstring[10];
if ((adapter->hw.mac.type == ixgbe_mac_82598EB) ||
(!(*aflags & (IXGBE_FLAG_FDIR_HASH_CAPABLE |
IXGBE_FLAG_FDIR_PERFECT_CAPABLE))))
goto no_fdir_pballoc;
#ifdef module_param_array
if (num_FdirPballoc > bd) {
#endif
fdir_pballoc_mode = FdirPballoc[bd];
ixgbe_validate_option(&fdir_pballoc_mode, &opt);
switch (fdir_pballoc_mode) {
case IXGBE_FDIR_PBALLOC_64K:
adapter->fdir_pballoc = IXGBE_FDIR_PBALLOC_64K;
sprintf(pstring, "64kB");
break;
case IXGBE_FDIR_PBALLOC_128K:
adapter->fdir_pballoc = IXGBE_FDIR_PBALLOC_128K;
sprintf(pstring, "128kB");
break;
case IXGBE_FDIR_PBALLOC_256K:
adapter->fdir_pballoc = IXGBE_FDIR_PBALLOC_256K;
sprintf(pstring, "256kB");
break;
default:
break;
}
DPRINTK(PROBE, INFO,
"Flow Director allocated %s of packet buffer\n",
pstring);
#ifdef module_param_array
} else {
adapter->fdir_pballoc = opt.def;
DPRINTK(PROBE, INFO,
"Flow Director allocated 64kB of packet buffer\n");
}
#endif
no_fdir_pballoc:
/* empty code line with semi-colon */ ;
}
{ /* Flow Director ATR Tx sample packet rate */
static struct ixgbe_option opt = {
.type = range_option,
.name = "Software ATR Tx packet sample rate",
.err = "using default of "
__MODULE_STRING(IXGBE_DEFAULT_ATR_SAMPLE_RATE),
.def = IXGBE_DEFAULT_ATR_SAMPLE_RATE,
.arg = {.r = {.min = IXGBE_ATR_SAMPLE_RATE_OFF,
.max = IXGBE_MAX_ATR_SAMPLE_RATE}}
};
static const char atr_string[] =
"ATR Tx Packet sample rate set to";
adapter->atr_sample_rate = IXGBE_ATR_SAMPLE_RATE_OFF;
if (adapter->hw.mac.type == ixgbe_mac_82598EB)
goto no_fdir_sample;
/* no sample rate for perfect filtering */
if (*aflags & IXGBE_FLAG_FDIR_PERFECT_CAPABLE)
goto no_fdir_sample;
#ifdef module_param_array
if (num_AtrSampleRate > bd) {
#endif
/* Only enable the sample rate if hashing (ATR) is on */
if (*aflags & IXGBE_FLAG_FDIR_HASH_CAPABLE)
adapter->atr_sample_rate = AtrSampleRate[bd];
if (adapter->atr_sample_rate) {
ixgbe_validate_option(&adapter->atr_sample_rate,
&opt);
DPRINTK(PROBE, INFO, "%s %d\n", atr_string,
adapter->atr_sample_rate);
}
#ifdef module_param_array
} else {
/* Only enable the sample rate if hashing (ATR) is on */
if (*aflags & IXGBE_FLAG_FDIR_HASH_CAPABLE)
adapter->atr_sample_rate = opt.def;
DPRINTK(PROBE, INFO, "%s default of %d\n", atr_string,
adapter->atr_sample_rate);
}
#endif
no_fdir_sample:
/* empty code line with semi-colon */ ;
}
}
/**
* ixgbe_check_options - Range Checking for Command Line Parameters
* @adapter: board private structure
*
* This routine checks all command line parameters for valid user
* input. If an invalid value is given, or if no user specified
* value exists, a default value is used. The final value is stored
* in a variable in the adapter structure.
**/
void __devinit ixgbe_check_options(struct ixgbe_adapter *adapter)
{
unsigned int mdd;
int bd = adapter->bd_number;
u32 *aflags = &adapter->flags;
struct ixgbe_ring_feature *feature = adapter->ring_feature;
unsigned int vmdq;
if (bd >= IXGBE_MAX_NIC) {
printk(KERN_NOTICE
"Warning: no configuration for board #%d\n", bd);
printk(KERN_NOTICE "Using defaults for all values\n");
#ifndef module_param_array
bd = IXGBE_MAX_NIC;
#endif
}
{ /* Interrupt Mode */
unsigned int int_mode;
static struct ixgbe_option opt = {
.type = range_option,
.name = "Interrupt Mode",
.err =
"using default of "__MODULE_STRING(IXGBE_DEFAULT_INT),
.def = IXGBE_DEFAULT_INT,
.arg = { .r = { .min = IXGBE_INT_LEGACY,
.max = IXGBE_INT_MSIX} }
};
#ifdef module_param_array
if (num_IntMode > bd || num_InterruptType > bd) {
#endif
int_mode = IntMode[bd];
if (int_mode == OPTION_UNSET)
int_mode = InterruptType[bd];
ixgbe_validate_option(&int_mode, &opt);
switch (int_mode) {
case IXGBE_INT_MSIX:
if (!(*aflags & IXGBE_FLAG_MSIX_CAPABLE))
printk(KERN_INFO
"Ignoring MSI-X setting; "
"support unavailable\n");
break;
case IXGBE_INT_MSI:
if (!(*aflags & IXGBE_FLAG_MSI_CAPABLE)) {
printk(KERN_INFO
"Ignoring MSI setting; "
"support unavailable\n");
} else {
*aflags &= ~IXGBE_FLAG_MSIX_CAPABLE;
}
break;
case IXGBE_INT_LEGACY:
default:
*aflags &= ~IXGBE_FLAG_MSIX_CAPABLE;
*aflags &= ~IXGBE_FLAG_MSI_CAPABLE;
break;
}
#ifdef module_param_array
} else {
/* default settings */
if (opt.def == IXGBE_INT_MSIX &&
*aflags & IXGBE_FLAG_MSIX_CAPABLE) {
*aflags |= IXGBE_FLAG_MSIX_CAPABLE;
*aflags |= IXGBE_FLAG_MSI_CAPABLE;
} else if (opt.def == IXGBE_INT_MSI &&
*aflags & IXGBE_FLAG_MSI_CAPABLE) {
*aflags &= ~IXGBE_FLAG_MSIX_CAPABLE;
*aflags |= IXGBE_FLAG_MSI_CAPABLE;
} else {
*aflags &= ~IXGBE_FLAG_MSIX_CAPABLE;
*aflags &= ~IXGBE_FLAG_MSI_CAPABLE;
}
}
#endif
}
{ /* Multiple Queue Support */
static struct ixgbe_option opt = {
.type = enable_option,
.name = "Multiple Queue Support",
.err = "defaulting to Enabled",
.def = OPTION_ENABLED
};
#ifdef module_param_array
if (num_MQ > bd) {
#endif
unsigned int mq = MQ[bd];
ixgbe_validate_option(&mq, &opt);
if (mq)
*aflags |= IXGBE_FLAG_MQ_CAPABLE;
else
*aflags &= ~IXGBE_FLAG_MQ_CAPABLE;
#ifdef module_param_array
} else {
if (opt.def == OPTION_ENABLED)
*aflags |= IXGBE_FLAG_MQ_CAPABLE;
else
*aflags &= ~IXGBE_FLAG_MQ_CAPABLE;
}
#endif
/* Check Interoperability */
if ((*aflags & IXGBE_FLAG_MQ_CAPABLE) &&
!(*aflags & IXGBE_FLAG_MSIX_CAPABLE)) {
DPRINTK(PROBE, INFO,
"Multiple queues are not supported while MSI-X "
"is disabled. Disabling Multiple Queues.\n");
*aflags &= ~IXGBE_FLAG_MQ_CAPABLE;
}
}
#if IS_ENABLED(CONFIG_DCA)
{ /* Direct Cache Access (DCA) */
static struct ixgbe_option opt = {
.type = range_option,
.name = "Direct Cache Access (DCA)",
.err = "defaulting to Enabled",
.def = IXGBE_MAX_DCA,
.arg = { .r = { .min = OPTION_DISABLED,
.max = IXGBE_MAX_DCA} }
};
unsigned int dca = opt.def;
#ifdef module_param_array
if (num_DCA > bd) {
#endif
dca = DCA[bd];
ixgbe_validate_option(&dca, &opt);
if (!dca)
*aflags &= ~IXGBE_FLAG_DCA_CAPABLE;
/* Check Interoperability */
if (!(*aflags & IXGBE_FLAG_DCA_CAPABLE)) {
DPRINTK(PROBE, INFO, "DCA is disabled\n");
*aflags &= ~IXGBE_FLAG_DCA_ENABLED;
}
if (dca == IXGBE_MAX_DCA) {
DPRINTK(PROBE, INFO,
"DCA enabled for rx data\n");
adapter->flags |= IXGBE_FLAG_DCA_ENABLED_DATA;
}
#ifdef module_param_array
} else {
/* make sure to clear the capability flag if the
* option is disabled by default above */
if (opt.def == OPTION_DISABLED)
*aflags &= ~IXGBE_FLAG_DCA_CAPABLE;
}
#endif
if (dca == IXGBE_MAX_DCA)
adapter->flags |= IXGBE_FLAG_DCA_ENABLED_DATA;
}
#endif /* CONFIG_DCA */
{ /* Receive-Side Scaling (RSS) */
static struct ixgbe_option opt = {
.type = range_option,
.name = "Receive-Side Scaling (RSS)",
.err = "using default.",
.def = 0,
.arg = { .r = { .min = 0,
.max = 1} }
};
unsigned int rss = RSS[bd];
/* adjust Max allowed RSS queues based on MAC type */
opt.arg.r.max = ixgbe_max_rss_indices(adapter);
#ifdef module_param_array
if (num_RSS > bd) {
#endif
ixgbe_validate_option(&rss, &opt);
/* base it off num_online_cpus() with hardware limit */
if (!rss)
rss = min_t(int, opt.arg.r.max,
num_online_cpus());
else
feature[RING_F_FDIR].limit = rss;
feature[RING_F_RSS].limit = rss;
#ifdef module_param_array
} else if (opt.def == 0) {
/**
* ixgbe_check_options - Range Checking for Command Line Parameters
* @adapter: board private structure
*
* This routine checks all command line parameters for valid user
* input. If an invalid value is given, or if no user specified
* value exists, a default value is used. The final value is stored
* in a variable in the adapter structure.
**/
void __devinit ixgbe_check_options(struct ixgbe_adapter *adapter)
{
int bd = adapter->bd_number;
u32 *aflags = &adapter->flags;
struct ixgbe_ring_feature *feature = adapter->ring_feature;
if (bd >= IXGBE_MAX_NIC) {
printk(KERN_NOTICE
"Warning: no configuration for board #%d\n", bd);
printk(KERN_NOTICE "Using defaults for all values\n");
#ifndef module_param_array
bd = IXGBE_MAX_NIC;
#endif
}
{ /* Interrupt Mode */
unsigned int int_mode;
static struct ixgbe_option opt = {
.type = range_option,
.name = "Interrupt Mode",
.err =
"using default of "__MODULE_STRING(IXGBE_DEFAULT_INT),
.def = IXGBE_DEFAULT_INT,
.arg = { .r = { .min = IXGBE_INT_LEGACY,
.max = IXGBE_INT_MSIX}}
};
#ifdef module_param_array
if (num_IntMode > bd || num_InterruptType > bd) {
#endif
int_mode = IntMode[bd];
if (int_mode == OPTION_UNSET)
int_mode = InterruptType[bd];
ixgbe_validate_option(&int_mode, &opt);
switch (int_mode) {
case IXGBE_INT_MSIX:
if (!(*aflags & IXGBE_FLAG_MSIX_CAPABLE))
printk(KERN_INFO
"Ignoring MSI-X setting; "
"support unavailable\n");
break;
case IXGBE_INT_MSI:
if (!(*aflags & IXGBE_FLAG_MSI_CAPABLE)) {
printk(KERN_INFO
"Ignoring MSI setting; "
"support unavailable\n");
} else {
*aflags &= ~IXGBE_FLAG_MSIX_CAPABLE;
*aflags &= ~IXGBE_FLAG_DCB_CAPABLE;
}
break;
case IXGBE_INT_LEGACY:
default:
*aflags &= ~IXGBE_FLAG_MSIX_CAPABLE;
*aflags &= ~IXGBE_FLAG_MSI_CAPABLE;
*aflags &= ~IXGBE_FLAG_DCB_CAPABLE;
break;
}
#ifdef module_param_array
} else {
/* default settings */
if (opt.def == IXGBE_INT_MSIX &&
*aflags & IXGBE_FLAG_MSIX_CAPABLE) {
*aflags |= IXGBE_FLAG_MSIX_CAPABLE;
*aflags |= IXGBE_FLAG_MSI_CAPABLE;
} else if (opt.def == IXGBE_INT_MSI &&
*aflags & IXGBE_FLAG_MSI_CAPABLE) {
*aflags &= ~IXGBE_FLAG_MSIX_CAPABLE;
*aflags |= IXGBE_FLAG_MSI_CAPABLE;
*aflags &= ~IXGBE_FLAG_DCB_CAPABLE;
} else {
*aflags &= ~IXGBE_FLAG_MSIX_CAPABLE;
*aflags &= ~IXGBE_FLAG_MSI_CAPABLE;
*aflags &= ~IXGBE_FLAG_DCB_CAPABLE;
}
}
#endif
}
{ /* Multiple Queue Support */
static struct ixgbe_option opt = {
.type = enable_option,
.name = "Multiple Queue Support",
.err = "defaulting to Enabled",
.def = OPTION_ENABLED
};
#ifdef module_param_array
if (num_MQ > bd) {
#endif
unsigned int mq = MQ[bd];
ixgbe_validate_option(&mq, &opt);
if (mq)
*aflags |= IXGBE_FLAG_MQ_CAPABLE;
else
*aflags &= ~IXGBE_FLAG_MQ_CAPABLE;
#ifdef module_param_array
} else {
if (opt.def == OPTION_ENABLED)
*aflags |= IXGBE_FLAG_MQ_CAPABLE;
else
*aflags &= ~IXGBE_FLAG_MQ_CAPABLE;
}
#endif
/* Check Interoperability */
if ((*aflags & IXGBE_FLAG_MQ_CAPABLE) &&
!(*aflags & IXGBE_FLAG_MSIX_CAPABLE)) {
DPRINTK(PROBE, INFO,
"Multiple queues are not supported while MSI-X "
"is disabled. Disabling Multiple Queues.\n");
*aflags &= ~IXGBE_FLAG_MQ_CAPABLE;
}
}
#if defined(CONFIG_DCA) || defined(CONFIG_DCA_MODULE)
{ /* Direct Cache Access (DCA) */
static struct ixgbe_option opt = {
.type = range_option,
.name = "Direct Cache Access (DCA)",
.err = "defaulting to Enabled",
.def = IXGBE_MAX_DCA,
.arg = { .r = { .min = OPTION_DISABLED,
.max = IXGBE_MAX_DCA}}
};
unsigned int dca = opt.def;
#ifdef module_param_array
if (num_DCA > bd) {
#endif
dca = DCA[bd];
ixgbe_validate_option(&dca, &opt);
if (!dca)
*aflags &= ~IXGBE_FLAG_DCA_CAPABLE;
/* Check Interoperability */
if (!(*aflags & IXGBE_FLAG_DCA_CAPABLE)) {
DPRINTK(PROBE, INFO, "DCA is disabled\n");
*aflags &= ~IXGBE_FLAG_DCA_ENABLED;
}
if (dca == IXGBE_MAX_DCA) {
DPRINTK(PROBE, INFO,
"DCA enabled for rx data\n");
adapter->flags |= IXGBE_FLAG_DCA_ENABLED_DATA;
}
#ifdef module_param_array
} else {
/* make sure to clear the capability flag if the
* option is disabled by default above */
if (opt.def == OPTION_DISABLED)
*aflags &= ~IXGBE_FLAG_DCA_CAPABLE;
}
#endif
if (dca == IXGBE_MAX_DCA)
adapter->flags |= IXGBE_FLAG_DCA_ENABLED_DATA;
}
#endif /* CONFIG_DCA or CONFIG_DCA_MODULE */
{ /* Receive-Side Scaling (RSS) */
static struct ixgbe_option opt = {
.type = range_option,
.name = "Receive-Side Scaling (RSS)",
.err = "using default.",
.def = OPTION_ENABLED,
.arg = { .r = { .min = OPTION_DISABLED,
.max = IXGBE_MAX_RSS_INDICES}}
};
unsigned int rss = RSS[bd];
#ifdef module_param_array
if (num_RSS > bd) {
#endif
if (rss != OPTION_ENABLED)
ixgbe_validate_option(&rss, &opt);
/*
* we cannot use an else since validate option may
* have changed the state of RSS
*/
if (rss == OPTION_ENABLED) {
/*
* Base it off num_online_cpus() with
* a hardware limit cap.
*/
rss = min(IXGBE_MAX_RSS_INDICES,
(int)num_online_cpus());
}
feature[RING_F_RSS].indices = rss ? : 1;
if (rss)
*aflags |= IXGBE_FLAG_RSS_ENABLED;
else
*aflags &= ~IXGBE_FLAG_RSS_ENABLED;
#ifdef module_param_array
} else {
if (opt.def == OPTION_DISABLED) {
*aflags &= ~IXGBE_FLAG_RSS_ENABLED;
} else {
rss = min(IXGBE_MAX_RSS_INDICES,
(int)num_online_cpus());
feature[RING_F_RSS].indices = rss;
if (rss)
*aflags |= IXGBE_FLAG_RSS_ENABLED;
else
*aflags &= ~IXGBE_FLAG_RSS_ENABLED;
}
}
#endif
/* Check Interoperability */
if (*aflags & IXGBE_FLAG_RSS_ENABLED) {
if (!(*aflags & IXGBE_FLAG_RSS_CAPABLE)) {
DPRINTK(PROBE, INFO,
"RSS is not supported on this "
"hardware. Disabling RSS.\n");
*aflags &= ~IXGBE_FLAG_RSS_ENABLED;
feature[RING_F_RSS].indices = 0;
} else if (!(*aflags & IXGBE_FLAG_MQ_CAPABLE)) {
DPRINTK(PROBE, INFO,
"RSS is not supported while multiple "
"queues are disabled. "
"Disabling RSS.\n");
*aflags &= ~IXGBE_FLAG_RSS_ENABLED;
*aflags &= ~IXGBE_FLAG_DCB_CAPABLE;
feature[RING_F_RSS].indices = 0;
}
}
}
{ /* Virtual Machine Device Queues (VMDQ) */
static struct ixgbe_option opt = {
.type = range_option,
.name = "Virtual Machine Device Queues (VMDQ)",
.err = "defaulting to Disabled",
.def = OPTION_DISABLED,
.arg = { .r = { .min = OPTION_DISABLED,
.max = IXGBE_MAX_VMDQ_INDICES
}}
};
#ifdef module_param_array
if (num_VMDQ > bd) {
#endif
unsigned int vmdq = VMDQ[bd];
ixgbe_validate_option(&vmdq, &opt);
feature[RING_F_VMDQ].indices = vmdq;
adapter->flags2 |= IXGBE_FLAG2_VMDQ_DEFAULT_OVERRIDE;
/* zero or one both mean disabled from our driver's
* perspective */
if (vmdq > 1)
*aflags |= IXGBE_FLAG_VMDQ_ENABLED;
else
*aflags &= ~IXGBE_FLAG_VMDQ_ENABLED;
#ifdef module_param_array
} else {
if (opt.def == OPTION_DISABLED) {
*aflags &= ~IXGBE_FLAG_VMDQ_ENABLED;
} else {
feature[RING_F_VMDQ].indices = IXGBE_DEFAULT_NUM_VMDQ;
*aflags |= IXGBE_FLAG_VMDQ_ENABLED;
}
}
#endif
/* Check Interoperability */
if (*aflags & IXGBE_FLAG_VMDQ_ENABLED) {
if (!(*aflags & IXGBE_FLAG_VMDQ_CAPABLE)) {
DPRINTK(PROBE, INFO,
"VMDQ is not supported on this "
"hardware. Disabling VMDQ.\n");
*aflags &= ~IXGBE_FLAG_VMDQ_ENABLED;
feature[RING_F_VMDQ].indices = 0;
} else if (!(*aflags & IXGBE_FLAG_MQ_CAPABLE)) {
DPRINTK(PROBE, INFO,
"VMDQ is not supported while multiple "
"queues are disabled. "
"Disabling VMDQ.\n");
*aflags &= ~IXGBE_FLAG_VMDQ_ENABLED;
feature[RING_F_VMDQ].indices = 0;
}
if (adapter->hw.mac.type == ixgbe_mac_82598EB)
feature[RING_F_VMDQ].indices =
min(feature[RING_F_VMDQ].indices, 16);
/* Disable incompatible features */
*aflags &= ~IXGBE_FLAG_RSS_CAPABLE;
*aflags &= ~IXGBE_FLAG_RSS_ENABLED;
*aflags &= ~IXGBE_FLAG_DCB_CAPABLE;
*aflags &= ~IXGBE_FLAG_DCB_ENABLED;
}
}
#ifdef CONFIG_PCI_IOV
{ /* Single Root I/O Virtualization (SR-IOV) */
static struct ixgbe_option opt = {
.type = range_option,
.name = "I/O Virtualization (IOV)",
.err = "defaulting to Disabled",
.def = OPTION_DISABLED,
.arg = { .r = { .min = OPTION_DISABLED,
.max = IXGBE_MAX_VF_FUNCTIONS}}
};
#ifdef module_param_array
if (num_max_vfs > bd) {
#endif
unsigned int vfs = max_vfs[bd];
ixgbe_validate_option(&vfs, &opt);
adapter->num_vfs = vfs;
if (vfs)
*aflags |= IXGBE_FLAG_SRIOV_ENABLED;
else
*aflags &= ~IXGBE_FLAG_SRIOV_ENABLED;
#ifdef module_param_array
} else {
if (opt.def == OPTION_DISABLED) {
adapter->num_vfs = 0;
*aflags &= ~IXGBE_FLAG_SRIOV_ENABLED;
} else {
adapter->num_vfs = opt.def;
*aflags |= IXGBE_FLAG_SRIOV_ENABLED;
}
}
#endif
/* Check Interoperability */
if (*aflags & IXGBE_FLAG_SRIOV_ENABLED) {
if (!(*aflags & IXGBE_FLAG_SRIOV_CAPABLE)) {
DPRINTK(PROBE, INFO,
"IOV is not supported on this "
"hardware. Disabling IOV.\n");
*aflags &= ~IXGBE_FLAG_SRIOV_ENABLED;
adapter->num_vfs = 0;
} else if (!(*aflags & IXGBE_FLAG_MQ_CAPABLE)) {
DPRINTK(PROBE, INFO,
"IOV is not supported while multiple "
"queues are disabled. "
"Disabling IOV.\n");
*aflags &= ~IXGBE_FLAG_SRIOV_ENABLED;
adapter->num_vfs = 0;
} else {
*aflags &= ~IXGBE_FLAG_RSS_CAPABLE;
adapter->flags2 &= ~IXGBE_FLAG2_RSC_CAPABLE;
}
}
}
{ /* L2 Loopback Enable in SR-IOV mode */
static struct ixgbe_option opt = {
.type = range_option,
.name = "L2 Loopback Enable",
.err = "defaulting to Enable",
.def = OPTION_ENABLED,
.arg = { .r = { .min = OPTION_DISABLED,
.max = OPTION_ENABLED}}
};
#ifdef module_param_array
if (num_L2LBen > bd) {
#endif
unsigned int l2LBen = L2LBen[bd];
ixgbe_validate_option(&l2LBen, &opt);
if (l2LBen)
adapter->flags |= IXGBE_FLAG_SRIOV_L2LOOPBACK_ENABLE;
#ifdef module_param_array
} else {
if (opt.def == OPTION_ENABLED)
adapter->flags |= IXGBE_FLAG_SRIOV_L2LOOPBACK_ENABLE;
}
#endif
}
#endif /* CONFIG_PCI_IOV */
{ /* Interrupt Throttling Rate */
static struct ixgbe_option opt = {
.type = range_option,
.name = "Interrupt Throttling Rate (ints/sec)",
.err = "using default of "__MODULE_STRING(DEFAULT_ITR),
.def = DEFAULT_ITR,
.arg = { .r = { .min = MIN_ITR,
.max = MAX_ITR }}
};
#ifdef module_param_array
if (num_InterruptThrottleRate > bd) {
#endif
u32 itr = InterruptThrottleRate[bd];
switch (itr) {
case 0:
DPRINTK(PROBE, INFO, "%s turned off\n",
opt.name);
adapter->rx_itr_setting = 0;
break;
case 1:
DPRINTK(PROBE, INFO, "dynamic interrupt "
"throttling enabled\n");
adapter->rx_itr_setting = 1;
break;
default:
ixgbe_validate_option(&itr, &opt);
/* the first bit is used as control */
adapter->rx_itr_setting = (1000000/itr) << 2;
break;
}
adapter->tx_itr_setting = adapter->rx_itr_setting;
#ifdef module_param_array
} else {
adapter->rx_itr_setting = opt.def;
adapter->tx_itr_setting = opt.def;
}
#endif
}
#ifndef IXGBE_NO_LLI
{ /* Low Latency Interrupt TCP Port*/
static struct ixgbe_option opt = {
.type = range_option,
.name = "Low Latency Interrupt TCP Port",
.err = "using default of "
__MODULE_STRING(DEFAULT_LLIPORT),
.def = DEFAULT_LLIPORT,
.arg = { .r = { .min = MIN_LLIPORT,
.max = MAX_LLIPORT }}
};
#ifdef module_param_array
if (num_LLIPort > bd) {
#endif
adapter->lli_port = LLIPort[bd];
if (adapter->lli_port) {
ixgbe_validate_option(&adapter->lli_port, &opt);
} else {
DPRINTK(PROBE, INFO, "%s turned off\n",
opt.name);
}
#ifdef module_param_array
} else {
adapter->lli_port = opt.def;
}
#endif
}
{ /* Low Latency Interrupt on Packet Size */
static struct ixgbe_option opt = {
.type = range_option,
.name = "Low Latency Interrupt on Packet Size",
.err = "using default of "
__MODULE_STRING(DEFAULT_LLISIZE),
.def = DEFAULT_LLISIZE,
.arg = { .r = { .min = MIN_LLISIZE,
.max = MAX_LLISIZE }}
};
#ifdef module_param_array
if (num_LLISize > bd) {
#endif
adapter->lli_size = LLISize[bd];
if (adapter->lli_size) {
ixgbe_validate_option(&adapter->lli_size, &opt);
} else {
DPRINTK(PROBE, INFO, "%s turned off\n",
opt.name);
}
#ifdef module_param_array
} else {
adapter->lli_size = opt.def;
}
#endif
}
{ /*Low Latency Interrupt on TCP Push flag*/
static struct ixgbe_option opt = {
.type = enable_option,
.name = "Low Latency Interrupt on TCP Push flag",
.err = "defaulting to Disabled",
.def = OPTION_DISABLED
};
#ifdef module_param_array
if (num_LLIPush > bd) {
#endif
unsigned int lli_push = LLIPush[bd];
ixgbe_validate_option(&lli_push, &opt);
if (lli_push)
*aflags |= IXGBE_FLAG_LLI_PUSH;
else
*aflags &= ~IXGBE_FLAG_LLI_PUSH;
#ifdef module_param_array
} else {
if (opt.def == OPTION_ENABLED)
*aflags |= IXGBE_FLAG_LLI_PUSH;
else
*aflags &= ~IXGBE_FLAG_LLI_PUSH;
}
#endif
}
{ /* Low Latency Interrupt EtherType*/
static struct ixgbe_option opt = {
.type = range_option,
.name = "Low Latency Interrupt on Ethernet Protocol Type",
.err = "using default of "
__MODULE_STRING(DEFAULT_LLIETYPE),
.def = DEFAULT_LLIETYPE,
.arg = { .r = { .min = MIN_LLIETYPE,
.max = MAX_LLIETYPE }}
};
#ifdef module_param_array
if (num_LLIEType > bd) {
#endif
adapter->lli_etype = LLIEType[bd];
if (adapter->lli_etype) {
ixgbe_validate_option(&adapter->lli_etype, &opt);
} else {
DPRINTK(PROBE, INFO, "%s turned off\n",
opt.name);
}
#ifdef module_param_array
} else {
adapter->lli_etype = opt.def;
}
#endif
}
{ /* LLI VLAN Priority */
static struct ixgbe_option opt = {
.type = range_option,
.name = "Low Latency Interrupt on VLAN priority threashold",
.err = "using default of "
__MODULE_STRING(DEFAULT_LLIVLANP),
.def = DEFAULT_LLIVLANP,
.arg = { .r = { .min = MIN_LLIVLANP,
.max = MAX_LLIVLANP }}
};
#ifdef module_param_array
if (num_LLIVLANP > bd) {
#endif
adapter->lli_vlan_pri = LLIVLANP[bd];
if (adapter->lli_vlan_pri) {
ixgbe_validate_option(&adapter->lli_vlan_pri, &opt);
} else {
DPRINTK(PROBE, INFO, "%s turned off\n",
opt.name);
}
#ifdef module_param_array
} else {
adapter->lli_vlan_pri = opt.def;
}
#endif
}
#endif /* IXGBE_NO_LLI */
{ /* Rx buffer mode */
unsigned int rx_buf_mode;
static struct ixgbe_option opt = {
.type = range_option,
.name = "Rx buffer mode",
.err = "using default of "
__MODULE_STRING(IXGBE_DEFAULT_RXBUFMODE),
.def = IXGBE_DEFAULT_RXBUFMODE,
.arg = {.r = {.min = IXGBE_RXBUFMODE_1BUF_ALWAYS,
.max = IXGBE_RXBUFMODE_OPTIMAL}}
};
#ifdef module_param_array
if (num_RxBufferMode > bd) {
#endif
/* for 82599 only 1BUF supported value - erratum 45 */
if (adapter->hw.mac.type == ixgbe_mac_82599EB)
RxBufferMode[bd] = IXGBE_RXBUFMODE_1BUF_ALWAYS;
rx_buf_mode = RxBufferMode[bd];
ixgbe_validate_option(&rx_buf_mode, &opt);
switch (rx_buf_mode) {
case IXGBE_RXBUFMODE_OPTIMAL:
*aflags |= IXGBE_FLAG_RX_1BUF_CAPABLE;
*aflags |= IXGBE_FLAG_RX_PS_CAPABLE;
break;
case IXGBE_RXBUFMODE_PS_ALWAYS:
*aflags |= IXGBE_FLAG_RX_PS_CAPABLE;
break;
case IXGBE_RXBUFMODE_1BUF_ALWAYS:
*aflags |= IXGBE_FLAG_RX_1BUF_CAPABLE;
break;
default:
break;
}
#ifdef module_param_array
} else {
/* 82599 doesn't support PS - erratum 45 */
if (adapter->hw.mac.type != ixgbe_mac_82599EB)
*aflags |= IXGBE_FLAG_RX_PS_CAPABLE;
*aflags |= IXGBE_FLAG_RX_1BUF_CAPABLE;
}
#endif
}
#ifdef HAVE_TX_MQ
{ /* Flow Director filtering mode */
unsigned int fdir_filter_mode;
static struct ixgbe_option opt = {
.type = range_option,
.name = "Flow Director filtering mode",
.err = "using default of "
__MODULE_STRING(IXGBE_DEFAULT_FDIR_FILTER),
.def = IXGBE_DEFAULT_FDIR_FILTER,
.arg = {.r = {.min = IXGBE_FDIR_FILTER_OFF,
.max = IXGBE_FDIR_FILTER_PERFECT}}
};
*aflags &= ~IXGBE_FLAG_FDIR_HASH_CAPABLE;
*aflags &= ~IXGBE_FLAG_FDIR_PERFECT_CAPABLE;
feature[RING_F_FDIR].indices = IXGBE_MAX_FDIR_INDICES;
if (adapter->hw.mac.type == ixgbe_mac_82598EB)
goto no_flow_director;
if (num_FdirMode > bd) {
fdir_filter_mode = FdirMode[bd];
ixgbe_validate_option(&fdir_filter_mode, &opt);
switch (fdir_filter_mode) {
case IXGBE_FDIR_FILTER_PERFECT:
#ifdef ETHTOOL_GRXRINGS
*aflags |= IXGBE_FLAG_FDIR_PERFECT_CAPABLE;
DPRINTK(PROBE, INFO,
"Flow Director perfect filtering enabled\n");
#else /* ETHTOOL_GRXRINGS */
DPRINTK(PROBE, INFO, "No ethtool support for "
"Flow Director perfect filtering.\n");
#endif /* ETHTOOL_GRXRINGS */
break;
case IXGBE_FDIR_FILTER_HASH:
*aflags |= IXGBE_FLAG_FDIR_HASH_CAPABLE;
DPRINTK(PROBE, INFO,
"Flow Director hash filtering enabled\n");
break;
case IXGBE_FDIR_FILTER_OFF:
default:
DPRINTK(PROBE, INFO, "Flow Director disabled\n");
break;
}
} else {
*aflags |= IXGBE_FLAG_FDIR_HASH_CAPABLE;
}
/* Check interoperability */
if ((*aflags & (IXGBE_FLAG_FDIR_HASH_CAPABLE |
IXGBE_FLAG_FDIR_PERFECT_CAPABLE)) &&
!(*aflags & IXGBE_FLAG_MQ_CAPABLE)) {
DPRINTK(PROBE, INFO,
"Flow Director is not supported while "
"multiple queues are disabled. "
"Disabling Flow Director\n");
*aflags &= ~IXGBE_FLAG_FDIR_HASH_CAPABLE;
*aflags &= ~IXGBE_FLAG_FDIR_PERFECT_CAPABLE;
}
/* limit the number of queues for FDIR using RSS param */
if (feature[RING_F_RSS].indices && num_RSS > bd && RSS[bd])
feature[RING_F_FDIR].indices = feature[RING_F_RSS].indices;
no_flow_director:
/* empty code line with semi-colon */ ;
}
{ /* Flow Director packet buffer allocation */
unsigned int fdir_pballoc_mode;
static struct ixgbe_option opt = {
.type = range_option,
.name = "Flow Director packet buffer allocation",
.err = "using default of "
__MODULE_STRING(IXGBE_DEFAULT_FDIR_PBALLOC),
.def = IXGBE_DEFAULT_FDIR_PBALLOC,
.arg = {.r = {.min = IXGBE_FDIR_PBALLOC_64K,
.max = IXGBE_FDIR_PBALLOC_256K}}
};
char pstring[10];
if (adapter->hw.mac.type == ixgbe_mac_82598EB)
goto no_fdir_pballoc;
if (num_FdirPballoc > bd) {
fdir_pballoc_mode = FdirPballoc[bd];
ixgbe_validate_option(&fdir_pballoc_mode, &opt);
switch (fdir_pballoc_mode) {
case IXGBE_FDIR_PBALLOC_64K:
adapter->fdir_pballoc = IXGBE_FDIR_PBALLOC_64K;
sprintf(pstring, "64kB");
break;
case IXGBE_FDIR_PBALLOC_128K:
adapter->fdir_pballoc = IXGBE_FDIR_PBALLOC_128K;
sprintf(pstring, "128kB");
break;
case IXGBE_FDIR_PBALLOC_256K:
adapter->fdir_pballoc = IXGBE_FDIR_PBALLOC_256K;
sprintf(pstring, "256kB");
break;
default:
break;
}
DPRINTK(PROBE, INFO,
"Flow Director will be allocated %s of packet buffer\n",
pstring);
} else {
adapter->fdir_pballoc = opt.def;
}
no_fdir_pballoc:
/* empty code line with semi-colon */ ;
}
{ /* Flow Director ATR Tx sample packet rate */
static struct ixgbe_option opt = {
.type = range_option,
.name = "Software ATR Tx packet sample rate",
.err = "using default of "
__MODULE_STRING(IXGBE_DEFAULT_ATR_SAMPLE_RATE),
.def = IXGBE_DEFAULT_ATR_SAMPLE_RATE,
.arg = {.r = {.min = IXGBE_ATR_SAMPLE_RATE_OFF,
.max = IXGBE_MAX_ATR_SAMPLE_RATE}}
};
static const char atr_string[] =
"ATR Tx Packet sample rate set to";
adapter->atr_sample_rate = IXGBE_ATR_SAMPLE_RATE_OFF;
if (adapter->hw.mac.type == ixgbe_mac_82598EB)
goto no_fdir_sample;
if (num_AtrSampleRate > bd) {
adapter->atr_sample_rate = AtrSampleRate[bd];
if (adapter->atr_sample_rate) {
ixgbe_validate_option(&adapter->atr_sample_rate,
&opt);
DPRINTK(PROBE, INFO, "%s %d\n", atr_string,
adapter->atr_sample_rate);
}
} else {
adapter->atr_sample_rate = opt.def;
}
no_fdir_sample:
/* empty code line with semi-colon */ ;
}
#endif /* HAVE_TX_MQ */
#ifdef IXGBE_FCOE
{
*aflags &= ~IXGBE_FLAG_FCOE_CAPABLE;
switch (adapter->hw.mac.type) {
case ixgbe_mac_X540:
case ixgbe_mac_82599EB: {
struct ixgbe_option opt = {
.type = enable_option,
.name = "Enabled/Disable FCoE offload",
.err = "defaulting to Enabled",
.def = OPTION_ENABLED
};
#ifdef module_param_array
if (num_FCoE > bd) {
#endif
unsigned int fcoe = FCoE[bd];
ixgbe_validate_option(&fcoe, &opt);
if (fcoe)
*aflags |= IXGBE_FLAG_FCOE_CAPABLE;
#ifdef module_param_array
} else {
if (opt.def == OPTION_ENABLED)
*aflags |= IXGBE_FLAG_FCOE_CAPABLE;
}
#endif
#ifdef CONFIG_PCI_IOV
if (*aflags & (IXGBE_FLAG_SRIOV_ENABLED |
IXGBE_FLAG_VMDQ_ENABLED))
*aflags &= ~IXGBE_FLAG_FCOE_CAPABLE;
#endif
DPRINTK(PROBE, INFO, "FCoE Offload feature %sabled\n",
(*aflags & IXGBE_FLAG_FCOE_CAPABLE) ?
"en" : "dis");
}
break;
default:
break;
}
}
#endif /* IXGBE_FCOE */
{ /* LRO - Enable Large Receive Offload */
struct ixgbe_option opt = {
.type = enable_option,
.name = "LRO - Large Receive Offload",
.err = "defaulting to Enabled",
.def = OPTION_ENABLED
};
struct net_device *netdev = adapter->netdev;
#ifdef IXGBE_NO_LRO
if (!(adapter->flags2 & IXGBE_FLAG2_RSC_CAPABLE))
opt.def = OPTION_DISABLED;
#endif
#ifdef module_param_array
if (num_LRO > bd) {
#endif
unsigned int lro = LRO[bd];
ixgbe_validate_option(&lro, &opt);
if (lro)
netdev->features |= NETIF_F_LRO;
else
netdev->features &= ~NETIF_F_LRO;
#ifdef module_param_array
} else if (opt.def == OPTION_ENABLED) {
netdev->features |= NETIF_F_LRO;
} else {
netdev->features &= ~NETIF_F_LRO;
}
#endif
#ifdef IXGBE_NO_LRO
if ((netdev->features & NETIF_F_LRO) &&
!(adapter->flags2 & IXGBE_FLAG2_RSC_CAPABLE)) {
DPRINTK(PROBE, INFO,
"RSC is not supported on this "
"hardware. Disabling RSC.\n");
netdev->features &= ~NETIF_F_LRO;
}
#endif
}
{ /* Node assignment */
static struct ixgbe_option opt = {
.type = range_option,
.name = "Node to start on",
#ifdef HAVE_EARLY_VMALLOC_NODE
.err = "defaulting to 0",
.def = 0,
#else
.err = "defaulting to -1",
.def = -1,
#endif
.arg = { .r = { .min = 0,
.max = (MAX_NUMNODES - 1)}}
};
int node_param = opt.def;
/* if the default was zero then we need to set the
* default value to an online node, which is not
* necessarily zero, and the constant initializer
* above can't take first_online_node */
if (node_param == 0)
/* must set opt.def for validate */
opt.def = node_param = first_online_node;
#ifdef module_param_array
if (num_Node > bd) {
#endif
node_param = Node[bd];
ixgbe_validate_option((uint *)&node_param, &opt);
if (node_param != OPTION_UNSET) {
DPRINTK(PROBE, INFO, "node set to %d\n", node_param);
}
#ifdef module_param_array
}
#endif
/* check sanity of the value */
if (node_param != -1 && !node_online(node_param)) {
DPRINTK(PROBE, INFO,
"ignoring node set to invalid value %d\n",
node_param);
node_param = opt.def;
}
adapter->node = node_param;
}
}
