X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=drivers%2Fnet%2Fice%2Fice_ethdev.c;h=02a25e8d2a47a9a6eaa17abc59c06100b4cb82f6;hb=c678299594a817c62c5d50ec61f444d2e30f5619;hp=e63e423215ecbef0eca64a5838f3c426fdc6535e;hpb=62024eb8275696bead35b38a6062a2513f1f7c58;p=dpdk.git diff --git a/drivers/net/ice/ice_ethdev.c b/drivers/net/ice/ice_ethdev.c index e63e423215..02a25e8d2a 100644 --- a/drivers/net/ice/ice_ethdev.c +++ b/drivers/net/ice/ice_ethdev.c @@ -3,7 +3,7 @@ */ #include -#include +#include #include #include @@ -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 }, }; @@ -152,6 +152,11 @@ static const struct rte_pci_id pci_id_ice_map[] = { { RTE_PCI_DEVICE(ICE_INTEL_VENDOR_ID, ICE_DEV_ID_E810_XXV_BACKPLANE) }, { RTE_PCI_DEVICE(ICE_INTEL_VENDOR_ID, ICE_DEV_ID_E810_XXV_QSFP) }, { RTE_PCI_DEVICE(ICE_INTEL_VENDOR_ID, ICE_DEV_ID_E810_XXV_SFP) }, + { RTE_PCI_DEVICE(ICE_INTEL_VENDOR_ID, ICE_DEV_ID_E823C_BACKPLANE) }, + { RTE_PCI_DEVICE(ICE_INTEL_VENDOR_ID, ICE_DEV_ID_E823C_QSFP) }, + { RTE_PCI_DEVICE(ICE_INTEL_VENDOR_ID, ICE_DEV_ID_E823C_SFP) }, + { RTE_PCI_DEVICE(ICE_INTEL_VENDOR_ID, ICE_DEV_ID_E823C_10G_BASE_T) }, + { RTE_PCI_DEVICE(ICE_INTEL_VENDOR_ID, ICE_DEV_ID_E823C_SGMII) }, { RTE_PCI_DEVICE(ICE_INTEL_VENDOR_ID, ICE_DEV_ID_E822C_BACKPLANE) }, { RTE_PCI_DEVICE(ICE_INTEL_VENDOR_ID, ICE_DEV_ID_E822C_QSFP) }, { RTE_PCI_DEVICE(ICE_INTEL_VENDOR_ID, ICE_DEV_ID_E822C_SFP) }, @@ -216,6 +221,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 +1134,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 +1187,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 +1585,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; @@ -2137,6 +2143,8 @@ ice_dev_init(struct rte_eth_dev *dev) 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; @@ -2434,10 +2442,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 @@ -2445,7 +2450,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 @@ -2458,8 +2464,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", @@ -2476,16 +2481,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", @@ -2762,15 +2762,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: @@ -2849,16 +2846,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; } @@ -2879,36 +2876,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"); @@ -2918,14 +2915,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); @@ -2933,9 +2949,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); @@ -2943,10 +2959,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); @@ -2954,10 +2970,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); @@ -2965,10 +2981,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); @@ -2976,10 +2992,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); @@ -2987,10 +3003,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); @@ -2998,222 +3014,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) @@ -3221,6 +3175,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; @@ -3233,6 +3188,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; @@ -3275,9 +3236,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; @@ -3316,10 +3280,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; @@ -3343,7 +3309,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); } @@ -3888,8 +3854,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; @@ -3952,7 +3918,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 @@ -4132,24 +4098,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); @@ -4202,6 +4168,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; @@ -4210,8 +4177,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; @@ -4230,6 +4201,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; @@ -4241,8 +4213,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; @@ -4437,8 +4413,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; } @@ -4619,24 +4594,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 =