};
static const struct rte_mbuf_dynfield ice_proto_xtr_metadata_param = {
- .name = "ice_dynfield_proto_xtr_metadata",
+ .name = "intel_pmd_dynfield_proto_xtr_metadata",
.size = sizeof(uint32_t),
.align = __alignof__(uint32_t),
.flags = 0,
static struct proto_xtr_ol_flag ice_proto_xtr_ol_flag_params[] = {
[PROTO_XTR_VLAN] = {
- .param = { .name = "ice_dynflag_proto_xtr_vlan" },
+ .param = { .name = "intel_pmd_dynflag_proto_xtr_vlan" },
.ol_flag = &rte_net_ice_dynflag_proto_xtr_vlan_mask },
[PROTO_XTR_IPV4] = {
- .param = { .name = "ice_dynflag_proto_xtr_ipv4" },
+ .param = { .name = "intel_pmd_dynflag_proto_xtr_ipv4" },
.ol_flag = &rte_net_ice_dynflag_proto_xtr_ipv4_mask },
[PROTO_XTR_IPV6] = {
- .param = { .name = "ice_dynflag_proto_xtr_ipv6" },
+ .param = { .name = "intel_pmd_dynflag_proto_xtr_ipv6" },
.ol_flag = &rte_net_ice_dynflag_proto_xtr_ipv6_mask },
[PROTO_XTR_IPV6_FLOW] = {
- .param = { .name = "ice_dynflag_proto_xtr_ipv6_flow" },
+ .param = { .name = "intel_pmd_dynflag_proto_xtr_ipv6_flow" },
.ol_flag = &rte_net_ice_dynflag_proto_xtr_ipv6_flow_mask },
[PROTO_XTR_TCP] = {
- .param = { .name = "ice_dynflag_proto_xtr_tcp" },
+ .param = { .name = "intel_pmd_dynflag_proto_xtr_tcp" },
.ol_flag = &rte_net_ice_dynflag_proto_xtr_tcp_mask },
[PROTO_XTR_IP_OFFSET] = {
- .param = { .name = "ice_dynflag_proto_xtr_ip_offset" },
+ .param = { .name = "intel_pmd_dynflag_proto_xtr_ip_offset" },
.ol_flag = &rte_net_ice_dynflag_proto_xtr_ip_offset_mask },
};
static int ice_dev_configure(struct rte_eth_dev *dev);
static int ice_dev_start(struct rte_eth_dev *dev);
-static void ice_dev_stop(struct rte_eth_dev *dev);
+static int ice_dev_stop(struct rte_eth_dev *dev);
static int ice_dev_close(struct rte_eth_dev *dev);
static int ice_dev_reset(struct rte_eth_dev *dev);
static int ice_dev_info_get(struct rte_eth_dev *dev,
if (vsi->info.valid_sections &
rte_cpu_to_le_16(ICE_AQ_VSI_PROP_OUTER_TAG_VALID)) {
if (on) {
- if ((vsi->info.outer_tag_flags &
- ICE_AQ_VSI_OUTER_TAG_ACCEPT_HOST) ==
- ICE_AQ_VSI_OUTER_TAG_ACCEPT_HOST)
+ if ((vsi->info.outer_vlan_flags &
+ ICE_AQ_VSI_OUTER_VLAN_PORT_BASED_ACCEPT_HOST) ==
+ ICE_AQ_VSI_OUTER_VLAN_PORT_BASED_ACCEPT_HOST)
return 0; /* already on */
} else {
- if (!(vsi->info.outer_tag_flags &
- ICE_AQ_VSI_OUTER_TAG_ACCEPT_HOST))
+ if (!(vsi->info.outer_vlan_flags &
+ ICE_AQ_VSI_OUTER_VLAN_PORT_BASED_ACCEPT_HOST))
return 0; /* already off */
}
}
if (on)
- qinq_flags = ICE_AQ_VSI_OUTER_TAG_ACCEPT_HOST;
+ qinq_flags = ICE_AQ_VSI_OUTER_VLAN_PORT_BASED_ACCEPT_HOST;
else
qinq_flags = 0;
/* clear global insertion and use per packet insertion */
- vsi->info.outer_tag_flags &= ~(ICE_AQ_VSI_OUTER_TAG_INSERT);
- vsi->info.outer_tag_flags &= ~(ICE_AQ_VSI_OUTER_TAG_ACCEPT_HOST);
- vsi->info.outer_tag_flags |= qinq_flags;
+ vsi->info.outer_vlan_flags &= ~(ICE_AQ_VSI_OUTER_VLAN_PORT_BASED_INSERT);
+ vsi->info.outer_vlan_flags &= ~(ICE_AQ_VSI_OUTER_VLAN_PORT_BASED_ACCEPT_HOST);
+ vsi->info.outer_vlan_flags |= qinq_flags;
/* use default vlan type 0x8100 */
- vsi->info.outer_tag_flags &= ~(ICE_AQ_VSI_OUTER_TAG_TYPE_M);
- vsi->info.outer_tag_flags |= ICE_DFLT_OUTER_TAG_TYPE <<
+ vsi->info.outer_vlan_flags &= ~(ICE_AQ_VSI_OUTER_TAG_TYPE_M);
+ vsi->info.outer_vlan_flags |= ICE_DFLT_OUTER_TAG_TYPE <<
ICE_AQ_VSI_OUTER_TAG_TYPE_S;
(void)rte_memcpy(&ctxt.info, &vsi->info, sizeof(vsi->info));
ctxt.info.valid_sections =
if (vsi->info.valid_sections &
rte_cpu_to_le_16(ICE_AQ_VSI_PROP_OUTER_TAG_VALID)) {
if (on) {
- if ((vsi->info.outer_tag_flags &
- ICE_AQ_VSI_OUTER_TAG_MODE_M) ==
- ICE_AQ_VSI_OUTER_TAG_COPY)
+ if ((vsi->info.outer_vlan_flags &
+ ICE_AQ_VSI_OUTER_VLAN_EMODE_M) ==
+ ICE_AQ_VSI_OUTER_VLAN_EMODE_SHOW)
return 0; /* already on */
} else {
- if ((vsi->info.outer_tag_flags &
- ICE_AQ_VSI_OUTER_TAG_MODE_M) ==
- ICE_AQ_VSI_OUTER_TAG_NOTHING)
+ if ((vsi->info.outer_vlan_flags &
+ ICE_AQ_VSI_OUTER_VLAN_EMODE_M) ==
+ ICE_AQ_VSI_OUTER_VLAN_EMODE_SHOW_BOTH)
return 0; /* already off */
}
}
if (on)
- qinq_flags = ICE_AQ_VSI_OUTER_TAG_COPY;
+ qinq_flags = ICE_AQ_VSI_OUTER_VLAN_EMODE_SHOW;
else
- qinq_flags = ICE_AQ_VSI_OUTER_TAG_NOTHING;
- vsi->info.outer_tag_flags &= ~(ICE_AQ_VSI_OUTER_TAG_MODE_M);
- vsi->info.outer_tag_flags |= qinq_flags;
+ qinq_flags = ICE_AQ_VSI_OUTER_VLAN_EMODE_SHOW_BOTH;
+ vsi->info.outer_vlan_flags &= ~(ICE_AQ_VSI_OUTER_VLAN_EMODE_M);
+ vsi->info.outer_vlan_flags |= qinq_flags;
/* use default vlan type 0x8100 */
- vsi->info.outer_tag_flags &= ~(ICE_AQ_VSI_OUTER_TAG_TYPE_M);
- vsi->info.outer_tag_flags |= ICE_DFLT_OUTER_TAG_TYPE <<
+ vsi->info.outer_vlan_flags &= ~(ICE_AQ_VSI_OUTER_TAG_TYPE_M);
+ vsi->info.outer_vlan_flags |= ICE_DFLT_OUTER_TAG_TYPE <<
ICE_AQ_VSI_OUTER_TAG_TYPE_S;
(void)rte_memcpy(&ctxt.info, &vsi->info, sizeof(vsi->info));
ctxt.info.valid_sections =
vsi_ctx.info.sw_id = hw->port_info->sw_id;
vsi_ctx.info.sw_flags2 = ICE_AQ_VSI_SW_FLAG_LAN_ENA;
/* Allow all untagged or tagged packets */
- vsi_ctx.info.vlan_flags = ICE_AQ_VSI_VLAN_MODE_ALL;
- vsi_ctx.info.vlan_flags |= ICE_AQ_VSI_VLAN_EMOD_NOTHING;
+ vsi_ctx.info.inner_vlan_flags = ICE_AQ_VSI_INNER_VLAN_TX_MODE_ALL;
+ vsi_ctx.info.inner_vlan_flags |= ICE_AQ_VSI_INNER_VLAN_EMODE_NOTHING;
vsi_ctx.info.q_opt_rss = ICE_AQ_VSI_Q_OPT_RSS_LUT_PF |
ICE_AQ_VSI_Q_OPT_RSS_TPLZ;
return 0;
}
+ dev->data->dev_flags |= RTE_ETH_DEV_AUTOFILL_QUEUE_XSTATS;
+
ice_set_default_ptype_table(dev);
pci_dev = RTE_DEV_TO_PCI(dev->device);
intr_handle = &pci_dev->intr_handle;
ICE_WRITE_REG(hw, GLINT_DYN_CTL(0), GLINT_DYN_CTL_WB_ON_ITR_M);
}
-static void
+static int
ice_dev_stop(struct rte_eth_dev *dev)
{
struct rte_eth_dev_data *data = dev->data;
/* avoid stopping again */
if (pf->adapter_stopped)
- return;
+ return 0;
/* stop and clear all Rx queues */
for (i = 0; i < data->nb_rx_queues; i++)
pf->adapter_stopped = true;
dev->data->dev_started = 0;
+
+ return 0;
}
static int
struct rte_intr_handle *intr_handle = &pci_dev->intr_handle;
struct ice_adapter *ad =
ICE_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private);
+ int ret;
if (rte_eal_process_type() != RTE_PROC_PRIMARY)
return 0;
*/
ice_pf_disable_irq0(hw);
- ice_dev_stop(dev);
+ ret = ice_dev_stop(dev);
if (!ad->is_safe_mode)
ice_flow_uninit(ad);
rte_intr_callback_unregister(intr_handle,
ice_interrupt_handler, dev);
- return 0;
+ return ret;
}
static int
static bool
is_hash_cfg_valid(struct ice_rss_hash_cfg *cfg)
{
- return ((cfg->hash_func >= ICE_RSS_HASH_TOEPLITZ &&
- cfg->hash_func <= ICE_RSS_HASH_JHASH) &&
- (cfg->hash_flds != 0 && cfg->addl_hdrs != 0)) ?
- true : false;
+ return (cfg->hash_flds != 0 && cfg->addl_hdrs != 0) ? true : false;
}
static void
{
cfg->hash_flds = 0;
cfg->addl_hdrs = 0;
- cfg->hash_func = 0;
+ cfg->symm = 0;
+ cfg->hdr_type = ICE_RSS_ANY_HEADERS;
}
static int
if (!is_hash_cfg_valid(cfg))
return -ENOENT;
- status = ice_rem_rss_cfg(hw, vsi->idx, cfg->hash_flds,
- cfg->addl_hdrs);
+ status = ice_rem_rss_cfg(hw, vsi->idx, cfg);
if (status && status != ICE_ERR_DOES_NOT_EXIST) {
PMD_DRV_LOG(ERR,
"ice_rem_rss_cfg failed for VSI:%d, error:%d\n",
enum ice_status status = ICE_SUCCESS;
struct ice_hw *hw = ICE_PF_TO_HW(pf);
struct ice_vsi *vsi = pf->main_vsi;
- bool symm;
if (!is_hash_cfg_valid(cfg))
return -ENOENT;
- symm = (cfg->hash_func == ICE_RSS_HASH_TOEPLITZ_SYMMETRIC) ?
- true : false;
-
- status = ice_add_rss_cfg(hw, vsi->idx, cfg->hash_flds,
- cfg->addl_hdrs, symm);
+ status = ice_add_rss_cfg(hw, vsi->idx, cfg);
if (status) {
PMD_DRV_LOG(ERR,
"ice_add_rss_cfg failed for VSI:%d, error:%d\n",
static int
ice_add_rss_cfg_post_gtpu(struct ice_pf *pf, struct ice_hash_gtpu_ctx *ctx,
- u32 hdr, u64 fld, bool symm, u8 ctx_idx)
+ u8 ctx_idx, struct ice_rss_hash_cfg *cfg)
{
int ret;
- if (ctx_idx < ICE_HASH_GTPU_CTX_MAX) {
- ctx->ctx[ctx_idx].addl_hdrs = hdr;
- ctx->ctx[ctx_idx].hash_flds = fld;
- ctx->ctx[ctx_idx].hash_func = symm;
- }
+ if (ctx_idx < ICE_HASH_GTPU_CTX_MAX)
+ ctx->ctx[ctx_idx] = *cfg;
switch (ctx_idx) {
case ICE_HASH_GTPU_CTX_EH_IP:
}
static int
-ice_add_rss_cfg_post(struct ice_pf *pf, uint32_t hdr, uint64_t fld, bool symm)
+ice_add_rss_cfg_post(struct ice_pf *pf, struct ice_rss_hash_cfg *cfg)
{
- u8 gtpu_ctx_idx = calc_gtpu_ctx_idx(hdr);
+ u8 gtpu_ctx_idx = calc_gtpu_ctx_idx(cfg->addl_hdrs);
- if (hdr & ICE_FLOW_SEG_HDR_IPV4)
- return ice_add_rss_cfg_post_gtpu(pf, &pf->hash_ctx.gtpu4, hdr,
- fld, symm, gtpu_ctx_idx);
- else if (hdr & ICE_FLOW_SEG_HDR_IPV6)
- return ice_add_rss_cfg_post_gtpu(pf, &pf->hash_ctx.gtpu6, hdr,
- fld, symm, gtpu_ctx_idx);
+ if (cfg->addl_hdrs & ICE_FLOW_SEG_HDR_IPV4)
+ return ice_add_rss_cfg_post_gtpu(pf, &pf->hash_ctx.gtpu4,
+ gtpu_ctx_idx, cfg);
+ else if (cfg->addl_hdrs & ICE_FLOW_SEG_HDR_IPV6)
+ return ice_add_rss_cfg_post_gtpu(pf, &pf->hash_ctx.gtpu6,
+ gtpu_ctx_idx, cfg);
return 0;
}
int
ice_rem_rss_cfg_wrap(struct ice_pf *pf, uint16_t vsi_id,
- uint64_t fld, uint32_t hdr)
+ struct ice_rss_hash_cfg *cfg)
{
struct ice_hw *hw = ICE_PF_TO_HW(pf);
int ret;
- ret = ice_rem_rss_cfg(hw, vsi_id, fld, hdr);
+ ret = ice_rem_rss_cfg(hw, vsi_id, cfg);
if (ret && ret != ICE_ERR_DOES_NOT_EXIST)
PMD_DRV_LOG(ERR, "remove rss cfg failed\n");
- ice_rem_rss_cfg_post(pf, hdr);
+ ice_rem_rss_cfg_post(pf, cfg->addl_hdrs);
return 0;
}
int
ice_add_rss_cfg_wrap(struct ice_pf *pf, uint16_t vsi_id,
- uint64_t fld, uint32_t hdr, bool symm)
+ struct ice_rss_hash_cfg *cfg)
{
struct ice_hw *hw = ICE_PF_TO_HW(pf);
int ret;
- ret = ice_add_rss_cfg_pre(pf, hdr);
+ ret = ice_add_rss_cfg_pre(pf, cfg->addl_hdrs);
if (ret)
PMD_DRV_LOG(ERR, "add rss cfg pre failed\n");
- ret = ice_add_rss_cfg(hw, vsi_id, fld, hdr, symm);
+ ret = ice_add_rss_cfg(hw, vsi_id, cfg);
if (ret)
PMD_DRV_LOG(ERR, "add rss cfg failed\n");
- ret = ice_add_rss_cfg_post(pf, hdr, fld, symm);
+ ret = ice_add_rss_cfg_post(pf, cfg);
if (ret)
PMD_DRV_LOG(ERR, "add rss cfg post failed\n");
static void
ice_rss_hash_set(struct ice_pf *pf, uint64_t rss_hf)
{
+ struct ice_hw *hw = ICE_PF_TO_HW(pf);
struct ice_vsi *vsi = pf->main_vsi;
+ struct ice_rss_hash_cfg cfg;
int ret;
+#define ICE_RSS_HF_ALL ( \
+ ETH_RSS_IPV4 | \
+ ETH_RSS_IPV6 | \
+ ETH_RSS_NONFRAG_IPV4_UDP | \
+ ETH_RSS_NONFRAG_IPV6_UDP | \
+ ETH_RSS_NONFRAG_IPV4_TCP | \
+ ETH_RSS_NONFRAG_IPV6_TCP | \
+ ETH_RSS_NONFRAG_IPV4_SCTP | \
+ ETH_RSS_NONFRAG_IPV6_SCTP)
+
+ ret = ice_rem_vsi_rss_cfg(hw, vsi->idx);
+ if (ret)
+ PMD_DRV_LOG(ERR, "%s Remove rss vsi fail %d",
+ __func__, ret);
+
+ cfg.symm = 0;
+ cfg.hdr_type = ICE_RSS_ANY_HEADERS;
/* Configure RSS for IPv4 with src/dst addr as input set */
if (rss_hf & ETH_RSS_IPV4) {
- ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_FLOW_HASH_IPV4,
- ICE_FLOW_SEG_HDR_IPV4 |
- ICE_FLOW_SEG_HDR_IPV_OTHER, 0);
+ cfg.addl_hdrs = ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER;
+ cfg.hash_flds = ICE_FLOW_HASH_IPV4;
+ ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg);
if (ret)
PMD_DRV_LOG(ERR, "%s IPV4 rss flow fail %d",
__func__, ret);
/* Configure RSS for IPv6 with src/dst addr as input set */
if (rss_hf & ETH_RSS_IPV6) {
- ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_FLOW_HASH_IPV6,
- ICE_FLOW_SEG_HDR_IPV6 |
- ICE_FLOW_SEG_HDR_IPV_OTHER, 0);
+ cfg.addl_hdrs = ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER;
+ cfg.hash_flds = ICE_FLOW_HASH_IPV6;
+ ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg);
if (ret)
PMD_DRV_LOG(ERR, "%s IPV6 rss flow fail %d",
__func__, ret);
/* Configure RSS for udp4 with src/dst addr and port as input set */
if (rss_hf & ETH_RSS_NONFRAG_IPV4_UDP) {
- ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_HASH_UDP_IPV4,
- ICE_FLOW_SEG_HDR_UDP |
- ICE_FLOW_SEG_HDR_IPV4 |
- ICE_FLOW_SEG_HDR_IPV_OTHER, 0);
+ cfg.addl_hdrs = ICE_FLOW_SEG_HDR_UDP | ICE_FLOW_SEG_HDR_IPV4 |
+ ICE_FLOW_SEG_HDR_IPV_OTHER;
+ cfg.hash_flds = ICE_HASH_UDP_IPV4;
+ ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg);
if (ret)
PMD_DRV_LOG(ERR, "%s UDP_IPV4 rss flow fail %d",
__func__, ret);
/* Configure RSS for udp6 with src/dst addr and port as input set */
if (rss_hf & ETH_RSS_NONFRAG_IPV6_UDP) {
- ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_HASH_UDP_IPV6,
- ICE_FLOW_SEG_HDR_UDP |
- ICE_FLOW_SEG_HDR_IPV6 |
- ICE_FLOW_SEG_HDR_IPV_OTHER, 0);
+ cfg.addl_hdrs = ICE_FLOW_SEG_HDR_UDP | ICE_FLOW_SEG_HDR_IPV6 |
+ ICE_FLOW_SEG_HDR_IPV_OTHER;
+ cfg.hash_flds = ICE_HASH_UDP_IPV6;
+ ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg);
if (ret)
PMD_DRV_LOG(ERR, "%s UDP_IPV6 rss flow fail %d",
__func__, ret);
/* Configure RSS for tcp4 with src/dst addr and port as input set */
if (rss_hf & ETH_RSS_NONFRAG_IPV4_TCP) {
- ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_HASH_TCP_IPV4,
- ICE_FLOW_SEG_HDR_TCP |
- ICE_FLOW_SEG_HDR_IPV4 |
- ICE_FLOW_SEG_HDR_IPV_OTHER, 0);
+ cfg.addl_hdrs = ICE_FLOW_SEG_HDR_TCP | ICE_FLOW_SEG_HDR_IPV4 |
+ ICE_FLOW_SEG_HDR_IPV_OTHER;
+ cfg.hash_flds = ICE_HASH_TCP_IPV4;
+ ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg);
if (ret)
PMD_DRV_LOG(ERR, "%s TCP_IPV4 rss flow fail %d",
__func__, ret);
/* Configure RSS for tcp6 with src/dst addr and port as input set */
if (rss_hf & ETH_RSS_NONFRAG_IPV6_TCP) {
- ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_HASH_TCP_IPV6,
- ICE_FLOW_SEG_HDR_TCP |
- ICE_FLOW_SEG_HDR_IPV6 |
- ICE_FLOW_SEG_HDR_IPV_OTHER, 0);
+ cfg.addl_hdrs = ICE_FLOW_SEG_HDR_TCP | ICE_FLOW_SEG_HDR_IPV6 |
+ ICE_FLOW_SEG_HDR_IPV_OTHER;
+ cfg.hash_flds = ICE_HASH_TCP_IPV6;
+ ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg);
if (ret)
PMD_DRV_LOG(ERR, "%s TCP_IPV6 rss flow fail %d",
__func__, ret);
/* Configure RSS for sctp4 with src/dst addr and port as input set */
if (rss_hf & ETH_RSS_NONFRAG_IPV4_SCTP) {
- ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_FLOW_HASH_IPV4,
- ICE_FLOW_SEG_HDR_SCTP |
- ICE_FLOW_SEG_HDR_IPV4 |
- ICE_FLOW_SEG_HDR_IPV_OTHER, 0);
+ cfg.addl_hdrs = ICE_FLOW_SEG_HDR_SCTP | ICE_FLOW_SEG_HDR_IPV4 |
+ ICE_FLOW_SEG_HDR_IPV_OTHER;
+ cfg.hash_flds = ICE_HASH_SCTP_IPV4;
+ ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg);
if (ret)
PMD_DRV_LOG(ERR, "%s SCTP_IPV4 rss flow fail %d",
__func__, ret);
/* Configure RSS for sctp6 with src/dst addr and port as input set */
if (rss_hf & ETH_RSS_NONFRAG_IPV6_SCTP) {
- ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_FLOW_HASH_IPV6,
- ICE_FLOW_SEG_HDR_SCTP |
- ICE_FLOW_SEG_HDR_IPV6 |
- ICE_FLOW_SEG_HDR_IPV_OTHER, 0);
+ cfg.addl_hdrs = ICE_FLOW_SEG_HDR_SCTP | ICE_FLOW_SEG_HDR_IPV6 |
+ ICE_FLOW_SEG_HDR_IPV_OTHER;
+ cfg.hash_flds = ICE_HASH_SCTP_IPV6;
+ ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg);
if (ret)
PMD_DRV_LOG(ERR, "%s SCTP_IPV6 rss flow fail %d",
__func__, ret);
}
if (rss_hf & ETH_RSS_IPV4) {
- ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_FLOW_HASH_IPV4,
- ICE_FLOW_SEG_HDR_GTPU_IP |
- ICE_FLOW_SEG_HDR_IPV4 |
- ICE_FLOW_SEG_HDR_IPV_OTHER, 0);
+ cfg.addl_hdrs = ICE_FLOW_SEG_HDR_GTPU_IP | ICE_FLOW_SEG_HDR_IPV4 |
+ ICE_FLOW_SEG_HDR_IPV_OTHER;
+ cfg.hash_flds = ICE_FLOW_HASH_IPV4;
+ ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg);
if (ret)
PMD_DRV_LOG(ERR, "%s GTPU_IPV4 rss flow fail %d",
__func__, ret);
- ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_FLOW_HASH_IPV4,
- ICE_FLOW_SEG_HDR_GTPU_EH |
- ICE_FLOW_SEG_HDR_IPV4 |
- ICE_FLOW_SEG_HDR_IPV_OTHER, 0);
+ cfg.addl_hdrs = ICE_FLOW_SEG_HDR_GTPU_EH | ICE_FLOW_SEG_HDR_IPV4 |
+ ICE_FLOW_SEG_HDR_IPV_OTHER;
+ ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg);
if (ret)
PMD_DRV_LOG(ERR, "%s GTPU_EH_IPV4 rss flow fail %d",
__func__, ret);
- ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_FLOW_HASH_IPV4,
- ICE_FLOW_SEG_HDR_PPPOE |
- ICE_FLOW_SEG_HDR_IPV4 |
- ICE_FLOW_SEG_HDR_IPV_OTHER, 0);
+ cfg.addl_hdrs = ICE_FLOW_SEG_HDR_PPPOE | ICE_FLOW_SEG_HDR_IPV4 |
+ ICE_FLOW_SEG_HDR_IPV_OTHER;
+ ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg);
if (ret)
PMD_DRV_LOG(ERR, "%s PPPoE_IPV4 rss flow fail %d",
__func__, ret);
}
if (rss_hf & ETH_RSS_IPV6) {
- ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_FLOW_HASH_IPV6,
- ICE_FLOW_SEG_HDR_GTPU_IP |
- ICE_FLOW_SEG_HDR_IPV6 |
- ICE_FLOW_SEG_HDR_IPV_OTHER, 0);
+ cfg.addl_hdrs = ICE_FLOW_SEG_HDR_GTPU_IP | ICE_FLOW_SEG_HDR_IPV6 |
+ ICE_FLOW_SEG_HDR_IPV_OTHER;
+ cfg.hash_flds = ICE_FLOW_HASH_IPV6;
+ ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg);
if (ret)
PMD_DRV_LOG(ERR, "%s GTPU_IPV6 rss flow fail %d",
__func__, ret);
- ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_FLOW_HASH_IPV6,
- ICE_FLOW_SEG_HDR_GTPU_EH |
- ICE_FLOW_SEG_HDR_IPV6 |
- ICE_FLOW_SEG_HDR_IPV_OTHER, 0);
+ cfg.addl_hdrs = ICE_FLOW_SEG_HDR_GTPU_EH | ICE_FLOW_SEG_HDR_IPV6 |
+ ICE_FLOW_SEG_HDR_IPV_OTHER;
+ ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg);
if (ret)
PMD_DRV_LOG(ERR, "%s GTPU_EH_IPV6 rss flow fail %d",
__func__, ret);
- ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_FLOW_HASH_IPV6,
- ICE_FLOW_SEG_HDR_PPPOE |
- ICE_FLOW_SEG_HDR_IPV6 |
- ICE_FLOW_SEG_HDR_IPV_OTHER, 0);
+ cfg.addl_hdrs = ICE_FLOW_SEG_HDR_PPPOE | ICE_FLOW_SEG_HDR_IPV6 |
+ ICE_FLOW_SEG_HDR_IPV_OTHER;
+ ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg);
if (ret)
PMD_DRV_LOG(ERR, "%s PPPoE_IPV6 rss flow fail %d",
__func__, ret);
}
if (rss_hf & ETH_RSS_NONFRAG_IPV4_UDP) {
- ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_HASH_UDP_IPV4,
- ICE_FLOW_SEG_HDR_GTPU_IP |
- ICE_FLOW_SEG_HDR_UDP |
- ICE_FLOW_SEG_HDR_IPV4 |
- ICE_FLOW_SEG_HDR_IPV_OTHER, 0);
+ cfg.addl_hdrs = ICE_FLOW_SEG_HDR_GTPU_IP | ICE_FLOW_SEG_HDR_UDP |
+ ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER;
+ cfg.hash_flds = ICE_HASH_UDP_IPV4;
+ ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg);
if (ret)
PMD_DRV_LOG(ERR, "%s GTPU_IPV4_UDP rss flow fail %d",
__func__, ret);
- ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_HASH_UDP_IPV4,
- ICE_FLOW_SEG_HDR_GTPU_EH |
- ICE_FLOW_SEG_HDR_UDP |
- ICE_FLOW_SEG_HDR_IPV4 |
- ICE_FLOW_SEG_HDR_IPV_OTHER, 0);
+ cfg.addl_hdrs = ICE_FLOW_SEG_HDR_GTPU_EH | ICE_FLOW_SEG_HDR_UDP |
+ ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER;
+ ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg);
if (ret)
PMD_DRV_LOG(ERR, "%s GTPU_EH_IPV4_UDP rss flow fail %d",
__func__, ret);
- ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_HASH_UDP_IPV4,
- ICE_FLOW_SEG_HDR_PPPOE |
- ICE_FLOW_SEG_HDR_UDP |
- ICE_FLOW_SEG_HDR_IPV4 |
- ICE_FLOW_SEG_HDR_IPV_OTHER, 0);
+ cfg.addl_hdrs = ICE_FLOW_SEG_HDR_PPPOE | ICE_FLOW_SEG_HDR_UDP |
+ ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER;
+ ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg);
if (ret)
PMD_DRV_LOG(ERR, "%s PPPoE_IPV4_UDP rss flow fail %d",
__func__, ret);
}
if (rss_hf & ETH_RSS_NONFRAG_IPV6_UDP) {
- ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_HASH_UDP_IPV6,
- ICE_FLOW_SEG_HDR_GTPU_IP |
- ICE_FLOW_SEG_HDR_UDP |
- ICE_FLOW_SEG_HDR_IPV6 |
- ICE_FLOW_SEG_HDR_IPV_OTHER, 0);
+ cfg.addl_hdrs = ICE_FLOW_SEG_HDR_GTPU_IP | ICE_FLOW_SEG_HDR_UDP |
+ ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER;
+ cfg.hash_flds = ICE_HASH_UDP_IPV6;
+ ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg);
if (ret)
PMD_DRV_LOG(ERR, "%s GTPU_IPV6_UDP rss flow fail %d",
__func__, ret);
- ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_HASH_UDP_IPV6,
- ICE_FLOW_SEG_HDR_GTPU_EH |
- ICE_FLOW_SEG_HDR_UDP |
- ICE_FLOW_SEG_HDR_IPV6 |
- ICE_FLOW_SEG_HDR_IPV_OTHER, 0);
+ cfg.addl_hdrs = ICE_FLOW_SEG_HDR_GTPU_EH | ICE_FLOW_SEG_HDR_UDP |
+ ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER;
+ ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg);
if (ret)
PMD_DRV_LOG(ERR, "%s GTPU_EH_IPV6_UDP rss flow fail %d",
__func__, ret);
- ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_HASH_UDP_IPV6,
- ICE_FLOW_SEG_HDR_PPPOE |
- ICE_FLOW_SEG_HDR_UDP |
- ICE_FLOW_SEG_HDR_IPV6 |
- ICE_FLOW_SEG_HDR_IPV_OTHER, 0);
+ cfg.addl_hdrs = ICE_FLOW_SEG_HDR_PPPOE | ICE_FLOW_SEG_HDR_UDP |
+ ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER;
+ ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg);
if (ret)
PMD_DRV_LOG(ERR, "%s PPPoE_IPV6_UDP rss flow fail %d",
__func__, ret);
}
if (rss_hf & ETH_RSS_NONFRAG_IPV4_TCP) {
- ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_HASH_TCP_IPV4,
- ICE_FLOW_SEG_HDR_GTPU_IP |
- ICE_FLOW_SEG_HDR_TCP |
- ICE_FLOW_SEG_HDR_IPV4 |
- ICE_FLOW_SEG_HDR_IPV_OTHER, 0);
+ cfg.addl_hdrs = ICE_FLOW_SEG_HDR_GTPU_IP | ICE_FLOW_SEG_HDR_TCP |
+ ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER;
+ cfg.hash_flds = ICE_HASH_TCP_IPV4;
+ ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg);
if (ret)
PMD_DRV_LOG(ERR, "%s GTPU_IPV4_TCP rss flow fail %d",
__func__, ret);
- ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_HASH_TCP_IPV4,
- ICE_FLOW_SEG_HDR_GTPU_EH |
- ICE_FLOW_SEG_HDR_TCP |
- ICE_FLOW_SEG_HDR_IPV4 |
- ICE_FLOW_SEG_HDR_IPV_OTHER, 0);
+ cfg.addl_hdrs = ICE_FLOW_SEG_HDR_GTPU_EH | ICE_FLOW_SEG_HDR_TCP |
+ ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER;
+ ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg);
if (ret)
PMD_DRV_LOG(ERR, "%s GTPU_EH_IPV4_TCP rss flow fail %d",
__func__, ret);
- ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_HASH_TCP_IPV4,
- ICE_FLOW_SEG_HDR_PPPOE |
- ICE_FLOW_SEG_HDR_TCP |
- ICE_FLOW_SEG_HDR_IPV4 |
- ICE_FLOW_SEG_HDR_IPV_OTHER, 0);
+ cfg.addl_hdrs = ICE_FLOW_SEG_HDR_PPPOE | ICE_FLOW_SEG_HDR_TCP |
+ ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_IPV_OTHER;
+ ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg);
if (ret)
PMD_DRV_LOG(ERR, "%s PPPoE_IPV4_TCP rss flow fail %d",
__func__, ret);
}
if (rss_hf & ETH_RSS_NONFRAG_IPV6_TCP) {
- ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_HASH_TCP_IPV6,
- ICE_FLOW_SEG_HDR_GTPU_IP |
- ICE_FLOW_SEG_HDR_TCP |
- ICE_FLOW_SEG_HDR_IPV6 |
- ICE_FLOW_SEG_HDR_IPV_OTHER, 0);
+ cfg.addl_hdrs = ICE_FLOW_SEG_HDR_GTPU_IP | ICE_FLOW_SEG_HDR_TCP |
+ ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER;
+ cfg.hash_flds = ICE_HASH_TCP_IPV6;
+ ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg);
if (ret)
PMD_DRV_LOG(ERR, "%s GTPU_IPV6_TCP rss flow fail %d",
__func__, ret);
- ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_HASH_TCP_IPV6,
- ICE_FLOW_SEG_HDR_GTPU_EH |
- ICE_FLOW_SEG_HDR_TCP |
- ICE_FLOW_SEG_HDR_IPV6 |
- ICE_FLOW_SEG_HDR_IPV_OTHER, 0);
+ cfg.addl_hdrs = ICE_FLOW_SEG_HDR_GTPU_EH | ICE_FLOW_SEG_HDR_TCP |
+ ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER;
+ ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg);
if (ret)
PMD_DRV_LOG(ERR, "%s GTPU_EH_IPV6_TCP rss flow fail %d",
__func__, ret);
- ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_HASH_TCP_IPV6,
- ICE_FLOW_SEG_HDR_PPPOE |
- ICE_FLOW_SEG_HDR_TCP |
- ICE_FLOW_SEG_HDR_IPV6 |
- ICE_FLOW_SEG_HDR_IPV_OTHER, 0);
+ cfg.addl_hdrs = ICE_FLOW_SEG_HDR_PPPOE | ICE_FLOW_SEG_HDR_TCP |
+ ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_IPV_OTHER;
+ ret = ice_add_rss_cfg_wrap(pf, vsi->idx, &cfg);
if (ret)
PMD_DRV_LOG(ERR, "%s PPPoE_IPV6_TCP rss flow fail %d",
__func__, ret);
}
- if (rss_hf & ETH_RSS_NONFRAG_IPV4_SCTP) {
- ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_HASH_SCTP_IPV4,
- ICE_FLOW_SEG_HDR_GTPU_IP |
- ICE_FLOW_SEG_HDR_SCTP |
- ICE_FLOW_SEG_HDR_IPV4 |
- ICE_FLOW_SEG_HDR_IPV_OTHER, 0);
- if (ret)
- PMD_DRV_LOG(ERR, "%s GTPU_IPV4_SCTP rss flow fail %d",
- __func__, ret);
-
- ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_HASH_SCTP_IPV4,
- ICE_FLOW_SEG_HDR_GTPU_EH |
- ICE_FLOW_SEG_HDR_SCTP |
- ICE_FLOW_SEG_HDR_IPV4 |
- ICE_FLOW_SEG_HDR_IPV_OTHER, 0);
- if (ret)
- PMD_DRV_LOG(ERR, "%s GTPU_EH_IPV4_SCTP rss flow fail %d",
- __func__, ret);
- }
-
- if (rss_hf & ETH_RSS_NONFRAG_IPV6_SCTP) {
- ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_HASH_SCTP_IPV6,
- ICE_FLOW_SEG_HDR_GTPU_IP |
- ICE_FLOW_SEG_HDR_SCTP |
- ICE_FLOW_SEG_HDR_IPV6 |
- ICE_FLOW_SEG_HDR_IPV_OTHER, 0);
- if (ret)
- PMD_DRV_LOG(ERR, "%s GTPU_IPV6_SCTP rss flow fail %d",
- __func__, ret);
-
- ret = ice_add_rss_cfg_wrap(pf, vsi->idx, ICE_HASH_SCTP_IPV6,
- ICE_FLOW_SEG_HDR_GTPU_EH |
- ICE_FLOW_SEG_HDR_SCTP |
- ICE_FLOW_SEG_HDR_IPV6 |
- ICE_FLOW_SEG_HDR_IPV_OTHER, 0);
- if (ret)
- PMD_DRV_LOG(ERR, "%s GTPU_EH_IPV6_SCTP rss flow fail %d",
- __func__, ret);
- }
+ pf->rss_hf = rss_hf & ICE_RSS_HF_ALL;
}
static int ice_init_rss(struct ice_pf *pf)
struct ice_hw *hw = ICE_PF_TO_HW(pf);
struct ice_vsi *vsi = pf->main_vsi;
struct rte_eth_dev *dev = pf->adapter->eth_dev;
+ struct ice_aq_get_set_rss_lut_params lut_params;
struct rte_eth_rss_conf *rss_conf;
struct ice_aqc_get_set_rss_keys key;
uint16_t i, nb_q;
vsi->rss_key_size = ICE_AQC_GET_SET_RSS_KEY_DATA_RSS_KEY_SIZE;
vsi->rss_lut_size = pf->hash_lut_size;
+ if (nb_q == 0) {
+ PMD_DRV_LOG(WARNING,
+ "RSS is not supported as rx queues number is zero\n");
+ return 0;
+ }
+
if (is_safe_mode) {
PMD_DRV_LOG(WARNING, "RSS is not supported in safe mode\n");
return 0;
for (i = 0; i < vsi->rss_lut_size; i++)
vsi->rss_lut[i] = i % nb_q;
- ret = ice_aq_set_rss_lut(hw, vsi->idx,
- ICE_AQC_GSET_RSS_LUT_TABLE_TYPE_PF,
- vsi->rss_lut, vsi->rss_lut_size);
+ lut_params.vsi_handle = vsi->idx;
+ lut_params.lut_size = vsi->rss_lut_size;
+ lut_params.lut_type = ICE_AQC_GSET_RSS_LUT_TABLE_TYPE_PF;
+ lut_params.lut = vsi->rss_lut;
+ lut_params.global_lut_id = 0;
+ ret = ice_aq_set_rss_lut(hw, &lut_params);
if (ret)
goto out;
PMD_DRV_LOG(INFO, "queue %d is binding to vect %d",
base_queue + i, msix_vect);
/* set ITR0 value */
- ICE_WRITE_REG(hw, GLINT_ITR(0, msix_vect), 0x10);
+ ICE_WRITE_REG(hw, GLINT_ITR(0, msix_vect), 0x2);
ICE_WRITE_REG(hw, QINT_RQCTL(base_queue + i), val);
ICE_WRITE_REG(hw, QINT_TQCTL(base_queue + i), val_tx);
}
if (!pcaps)
return ICE_ERR_NO_MEMORY;
- status = ice_aq_get_phy_caps(pi, false, ICE_AQC_REPORT_SW_CFG, pcaps,
- NULL);
+ status = ice_aq_get_phy_caps(pi, false, ICE_AQC_REPORT_ACTIVE_CFG,
+ pcaps, NULL);
if (status)
goto out;
if (vsi->info.valid_sections &
rte_cpu_to_le_16(ICE_AQ_VSI_PROP_VLAN_VALID)) {
if (on) {
- if ((vsi->info.vlan_flags &
- ICE_AQ_VSI_VLAN_EMOD_M) ==
- ICE_AQ_VSI_VLAN_EMOD_STR_BOTH)
+ if ((vsi->info.inner_vlan_flags &
+ ICE_AQ_VSI_INNER_VLAN_EMODE_M) ==
+ ICE_AQ_VSI_INNER_VLAN_EMODE_STR_BOTH)
return 0; /* already on */
} else {
- if ((vsi->info.vlan_flags &
- ICE_AQ_VSI_VLAN_EMOD_M) ==
- ICE_AQ_VSI_VLAN_EMOD_NOTHING)
+ if ((vsi->info.inner_vlan_flags &
+ ICE_AQ_VSI_INNER_VLAN_EMODE_M) ==
+ ICE_AQ_VSI_INNER_VLAN_EMODE_NOTHING)
return 0; /* already off */
}
}
if (on)
- vlan_flags = ICE_AQ_VSI_VLAN_EMOD_STR_BOTH;
+ vlan_flags = ICE_AQ_VSI_INNER_VLAN_EMODE_STR_BOTH;
else
- vlan_flags = ICE_AQ_VSI_VLAN_EMOD_NOTHING;
- vsi->info.vlan_flags &= ~(ICE_AQ_VSI_VLAN_EMOD_M);
- vsi->info.vlan_flags |= vlan_flags;
+ vlan_flags = ICE_AQ_VSI_INNER_VLAN_EMODE_NOTHING;
+ vsi->info.inner_vlan_flags &= ~(ICE_AQ_VSI_INNER_VLAN_EMODE_M);
+ vsi->info.inner_vlan_flags |= vlan_flags;
(void)rte_memcpy(&ctxt.info, &vsi->info, sizeof(vsi->info));
ctxt.info.valid_sections =
rte_cpu_to_le_16(ICE_AQ_VSI_PROP_VLAN_VALID);
static int
ice_get_rss_lut(struct ice_vsi *vsi, uint8_t *lut, uint16_t lut_size)
{
+ struct ice_aq_get_set_rss_lut_params lut_params;
struct ice_pf *pf = ICE_VSI_TO_PF(vsi);
struct ice_hw *hw = ICE_VSI_TO_HW(vsi);
int ret;
return -EINVAL;
if (pf->flags & ICE_FLAG_RSS_AQ_CAPABLE) {
- ret = ice_aq_get_rss_lut(hw, vsi->idx,
- ICE_AQC_GSET_RSS_LUT_TABLE_TYPE_PF, lut, lut_size);
+ lut_params.vsi_handle = vsi->idx;
+ lut_params.lut_size = lut_size;
+ lut_params.lut_type = ICE_AQC_GSET_RSS_LUT_TABLE_TYPE_PF;
+ lut_params.lut = lut;
+ lut_params.global_lut_id = 0;
+ ret = ice_aq_get_rss_lut(hw, &lut_params);
if (ret) {
PMD_DRV_LOG(ERR, "Failed to get RSS lookup table");
return -EINVAL;
static int
ice_set_rss_lut(struct ice_vsi *vsi, uint8_t *lut, uint16_t lut_size)
{
+ struct ice_aq_get_set_rss_lut_params lut_params;
struct ice_pf *pf;
struct ice_hw *hw;
int ret;
hw = ICE_VSI_TO_HW(vsi);
if (pf->flags & ICE_FLAG_RSS_AQ_CAPABLE) {
- ret = ice_aq_set_rss_lut(hw, vsi->idx,
- ICE_AQC_GSET_RSS_LUT_TABLE_TYPE_PF, lut, lut_size);
+ lut_params.vsi_handle = vsi->idx;
+ lut_params.lut_size = lut_size;
+ lut_params.lut_type = ICE_AQC_GSET_RSS_LUT_TABLE_TYPE_PF;
+ lut_params.lut = lut;
+ lut_params.global_lut_id = 0;
+ ret = ice_aq_set_rss_lut(hw, &lut_params);
if (ret) {
PMD_DRV_LOG(ERR, "Failed to set RSS lookup table");
return -EINVAL;
ice_get_rss_key(vsi, rss_conf->rss_key,
&rss_conf->rss_key_len);
- /* TODO: default set to 0 as hf config is not supported now */
- rss_conf->rss_hf = 0;
+ rss_conf->rss_hf = pf->rss_hf;
return 0;
}
}
if (info->on) {
- vsi->info.pvid = info->config.pvid;
+ vsi->info.port_based_inner_vlan = info->config.pvid;
/**
* If insert pvid is enabled, only tagged pkts are
* allowed to be sent out.
*/
- vlan_flags = ICE_AQ_VSI_PVLAN_INSERT_PVID |
- ICE_AQ_VSI_VLAN_MODE_UNTAGGED;
+ vlan_flags = ICE_AQ_VSI_INNER_VLAN_INSERT_PVID |
+ ICE_AQ_VSI_INNER_VLAN_TX_MODE_ACCEPTUNTAGGED;
} else {
- vsi->info.pvid = 0;
+ vsi->info.port_based_inner_vlan = 0;
if (info->config.reject.tagged == 0)
- vlan_flags |= ICE_AQ_VSI_VLAN_MODE_TAGGED;
+ vlan_flags |= ICE_AQ_VSI_INNER_VLAN_TX_MODE_ACCEPTTAGGED;
if (info->config.reject.untagged == 0)
- vlan_flags |= ICE_AQ_VSI_VLAN_MODE_UNTAGGED;
+ vlan_flags |= ICE_AQ_VSI_INNER_VLAN_TX_MODE_ACCEPTUNTAGGED;
}
- vsi->info.vlan_flags &= ~(ICE_AQ_VSI_PVLAN_INSERT_PVID |
- ICE_AQ_VSI_VLAN_MODE_M);
- vsi->info.vlan_flags |= vlan_flags;
+ vsi->info.inner_vlan_flags &= ~(ICE_AQ_VSI_INNER_VLAN_INSERT_PVID |
+ ICE_AQ_VSI_INNER_VLAN_EMODE_M);
+ vsi->info.inner_vlan_flags |= vlan_flags;
memset(&ctxt, 0, sizeof(ctxt));
rte_memcpy(&ctxt.info, &vsi->info, sizeof(vsi->info));
ctxt.info.valid_sections =
git.droids-corp.org / dpdk.git / blobdiff