X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=drivers%2Fnet%2Fice%2Fice_ethdev.c;h=ec29f0fe40a34bb18cc10aa54b031e8c42415ee0;hb=bb3386f348ddf1a32b752ca371146e6be5c56a8b;hp=c65125ff3260a891e948e13f725db8bf038a2193;hpb=f30e69b41f949cd4a9afb6ff39de196e661708e2;p=dpdk.git diff --git a/drivers/net/ice/ice_ethdev.c b/drivers/net/ice/ice_ethdev.c index c65125ff32..ec29f0fe40 100644 --- a/drivers/net/ice/ice_ethdev.c +++ b/drivers/net/ice/ice_ethdev.c @@ -33,7 +33,7 @@ static const char * const ice_valid_args[] = { }; 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, @@ -49,22 +49,22 @@ static bool ice_proto_xtr_hw_support[PROTO_XTR_MAX]; 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 }, }; @@ -216,6 +216,7 @@ static const struct eth_dev_ops ice_eth_dev_ops = { .udp_tunnel_port_add = ice_dev_udp_tunnel_port_add, .udp_tunnel_port_del = ice_dev_udp_tunnel_port_del, .tx_done_cleanup = ice_tx_done_cleanup, + .get_monitor_addr = ice_get_monitor_addr, }; /* store statistics names and its offset in stats structure */ @@ -1128,28 +1129,28 @@ ice_vsi_config_qinq_insertion(struct ice_vsi *vsi, bool on) 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 = @@ -1181,27 +1182,27 @@ ice_vsi_config_qinq_stripping(struct ice_vsi *vsi, bool on) 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 = @@ -1579,8 +1580,8 @@ ice_setup_vsi(struct ice_pf *pf, enum ice_vsi_type type) 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; @@ -2436,10 +2437,7 @@ ice_dev_uninit(struct rte_eth_dev *dev) 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 @@ -2447,7 +2445,8 @@ hash_cfg_reset(struct ice_rss_hash_cfg *cfg) { cfg->hash_flds = 0; cfg->addl_hdrs = 0; - cfg->hash_func = 0; + cfg->symm = 0; + cfg->hdr_type = ICE_RSS_ANY_HEADERS; } static int @@ -2460,8 +2459,7 @@ ice_hash_moveout(struct ice_pf *pf, struct ice_rss_hash_cfg *cfg) 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", @@ -2478,16 +2476,11 @@ ice_hash_moveback(struct ice_pf *pf, struct ice_rss_hash_cfg *cfg) 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", @@ -2764,15 +2757,12 @@ ice_add_rss_cfg_pre(struct ice_pf *pf, uint32_t hdr) 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: @@ -2851,16 +2841,16 @@ ice_add_rss_cfg_post_gtpu(struct ice_pf *pf, struct ice_hash_gtpu_ctx *ctx, } 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; } @@ -2881,36 +2871,36 @@ ice_rem_rss_cfg_post(struct ice_pf *pf, uint32_t hdr) 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"); @@ -2920,14 +2910,33 @@ ice_add_rss_cfg_wrap(struct ice_pf *pf, uint16_t vsi_id, 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); @@ -2935,9 +2944,9 @@ ice_rss_hash_set(struct ice_pf *pf, uint64_t rss_hf) /* 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); @@ -2945,10 +2954,10 @@ ice_rss_hash_set(struct ice_pf *pf, uint64_t rss_hf) /* 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); @@ -2956,10 +2965,10 @@ ice_rss_hash_set(struct ice_pf *pf, uint64_t rss_hf) /* 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); @@ -2967,10 +2976,10 @@ ice_rss_hash_set(struct ice_pf *pf, uint64_t rss_hf) /* 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); @@ -2978,10 +2987,10 @@ ice_rss_hash_set(struct ice_pf *pf, uint64_t rss_hf) /* 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); @@ -2989,10 +2998,10 @@ ice_rss_hash_set(struct ice_pf *pf, uint64_t rss_hf) /* 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); @@ -3000,222 +3009,160 @@ ice_rss_hash_set(struct ice_pf *pf, uint64_t rss_hf) /* 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) @@ -3223,6 +3170,7 @@ 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; @@ -3235,6 +3183,12 @@ static int ice_init_rss(struct ice_pf *pf) 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; @@ -3277,9 +3231,12 @@ static int ice_init_rss(struct ice_pf *pf) 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; @@ -3318,10 +3275,12 @@ ice_dev_configure(struct rte_eth_dev *dev) if (dev->data->dev_conf.rxmode.mq_mode & ETH_MQ_RX_RSS_FLAG) dev->data->dev_conf.rxmode.offloads |= DEV_RX_OFFLOAD_RSS_HASH; - ret = ice_init_rss(pf); - if (ret) { - PMD_DRV_LOG(ERR, "Failed to enable rss for PF"); - return ret; + if (dev->data->nb_rx_queues) { + ret = ice_init_rss(pf); + if (ret) { + PMD_DRV_LOG(ERR, "Failed to enable rss for PF"); + return ret; + } } return 0; @@ -3345,7 +3304,7 @@ __vsi_queues_bind_intr(struct ice_vsi *vsi, uint16_t msix_vect, 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); } @@ -3890,8 +3849,8 @@ ice_force_phys_link_state(struct ice_hw *hw, bool link_up) 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; @@ -3954,7 +3913,7 @@ ice_mtu_set(struct rte_eth_dev *dev, uint16_t mtu) return -EBUSY; } - if (frame_size > RTE_ETHER_MAX_LEN) + if (frame_size > ICE_ETH_MAX_LEN) dev_data->dev_conf.rxmode.offloads |= DEV_RX_OFFLOAD_JUMBO_FRAME; else @@ -4134,24 +4093,24 @@ ice_vsi_config_vlan_stripping(struct ice_vsi *vsi, bool on) 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); @@ -4204,6 +4163,7 @@ ice_vlan_offload_set(struct rte_eth_dev *dev, int mask) 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; @@ -4212,8 +4172,12 @@ ice_get_rss_lut(struct ice_vsi *vsi, uint8_t *lut, uint16_t lut_size) 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; @@ -4232,6 +4196,7 @@ ice_get_rss_lut(struct ice_vsi *vsi, uint8_t *lut, uint16_t lut_size) 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; @@ -4243,8 +4208,12 @@ ice_set_rss_lut(struct ice_vsi *vsi, uint8_t *lut, uint16_t lut_size) 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; @@ -4439,8 +4408,7 @@ ice_rss_hash_conf_get(struct rte_eth_dev *dev, 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; } @@ -4621,24 +4589,24 @@ ice_vsi_vlan_pvid_set(struct ice_vsi *vsi, struct ice_vsi_vlan_pvid_info *info) } 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 =