/** * 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; } }