X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=drivers%2Fnet%2Fice%2Fice_ethdev.c;h=4a161ae8a7895ae486230ba6a8c521690c036aef;hb=6982f1848f985f89ecc4b16b3a09a504da3fec5b;hp=84a0d8e0b371aaa64ab829e5c7a57bedfa931efe;hpb=e40a84ebedf3d8f6ea00f6c10d0fc885a8163d43;p=dpdk.git

diff --git a/drivers/net/ice/ice_ethdev.c b/drivers/net/ice/ice_ethdev.c
index 84a0d8e0b3..4a161ae8a7 100644
--- a/drivers/net/ice/ice_ethdev.c
+++ b/drivers/net/ice/ice_ethdev.c
@@ -47,6 +47,8 @@ struct proto_xtr_ol_flag {
 	bool required;
 };
 
+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" },
@@ -63,6 +65,9 @@ static struct proto_xtr_ol_flag ice_proto_xtr_ol_flag_params[] = {
 	[PROTO_XTR_TCP] = {
 		.param = { .name = "ice_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" },
+		.ol_flag = &rte_net_ice_dynflag_proto_xtr_ip_offset_mask },
 };
 
 #define ICE_DFLT_OUTER_TAG_TYPE ICE_AQ_VSI_OUTER_TAG_VLAN_9100
@@ -321,6 +326,7 @@ lookup_proto_xtr_type(const char *xtr_name)
 		{ "ipv6",      PROTO_XTR_IPV6      },
 		{ "ipv6_flow", PROTO_XTR_IPV6_FLOW },
 		{ "tcp",       PROTO_XTR_TCP       },
+		{ "ip_offset", PROTO_XTR_IP_OFFSET },
 	};
 	uint32_t i;
 
@@ -536,25 +542,40 @@ handle_proto_xtr_arg(__rte_unused const char *key, const char *value,
 	return 0;
 }
 
-static bool
-ice_proto_xtr_support(struct ice_hw *hw)
+static void
+ice_check_proto_xtr_support(struct ice_hw *hw)
 {
 #define FLX_REG(val, fld, idx) \
 	(((val) & GLFLXP_RXDID_FLX_WRD_##idx##_##fld##_M) >> \
 	 GLFLXP_RXDID_FLX_WRD_##idx##_##fld##_S)
 	static struct {
 		uint32_t rxdid;
-		uint16_t protid_0;
-		uint16_t protid_1;
+		uint8_t opcode;
+		uint8_t protid_0;
+		uint8_t protid_1;
 	} xtr_sets[] = {
-		{ ICE_RXDID_COMMS_AUX_VLAN, ICE_PROT_EVLAN_O, ICE_PROT_VLAN_O },
-		{ ICE_RXDID_COMMS_AUX_IPV4, ICE_PROT_IPV4_OF_OR_S,
-		  ICE_PROT_IPV4_OF_OR_S },
-		{ ICE_RXDID_COMMS_AUX_IPV6, ICE_PROT_IPV6_OF_OR_S,
-		  ICE_PROT_IPV6_OF_OR_S },
-		{ ICE_RXDID_COMMS_AUX_IPV6_FLOW, ICE_PROT_IPV6_OF_OR_S,
-		  ICE_PROT_IPV6_OF_OR_S },
-		{ ICE_RXDID_COMMS_AUX_TCP, ICE_PROT_TCP_IL, ICE_PROT_ID_INVAL },
+		[PROTO_XTR_VLAN] = { ICE_RXDID_COMMS_AUX_VLAN,
+				     ICE_RX_OPC_EXTRACT,
+				     ICE_PROT_EVLAN_O, ICE_PROT_VLAN_O},
+		[PROTO_XTR_IPV4] = { ICE_RXDID_COMMS_AUX_IPV4,
+				     ICE_RX_OPC_EXTRACT,
+				     ICE_PROT_IPV4_OF_OR_S,
+				     ICE_PROT_IPV4_OF_OR_S },
+		[PROTO_XTR_IPV6] = { ICE_RXDID_COMMS_AUX_IPV6,
+				     ICE_RX_OPC_EXTRACT,
+				     ICE_PROT_IPV6_OF_OR_S,
+				     ICE_PROT_IPV6_OF_OR_S },
+		[PROTO_XTR_IPV6_FLOW] = { ICE_RXDID_COMMS_AUX_IPV6_FLOW,
+					  ICE_RX_OPC_EXTRACT,
+					  ICE_PROT_IPV6_OF_OR_S,
+					  ICE_PROT_IPV6_OF_OR_S },
+		[PROTO_XTR_TCP] = { ICE_RXDID_COMMS_AUX_TCP,
+				    ICE_RX_OPC_EXTRACT,
+				    ICE_PROT_TCP_IL, ICE_PROT_ID_INVAL },
+		[PROTO_XTR_IP_OFFSET] = { ICE_RXDID_COMMS_AUX_IP_OFFSET,
+					  ICE_RX_OPC_PROTID,
+					  ICE_PROT_IPV4_OF_OR_S,
+					  ICE_PROT_IPV6_OF_OR_S },
 	};
 	uint32_t i;
 
@@ -565,21 +586,19 @@ ice_proto_xtr_support(struct ice_hw *hw)
 		if (xtr_sets[i].protid_0 != ICE_PROT_ID_INVAL) {
 			v = ICE_READ_REG(hw, GLFLXP_RXDID_FLX_WRD_4(rxdid));
 
-			if (FLX_REG(v, PROT_MDID, 4) != xtr_sets[i].protid_0 ||
-			    FLX_REG(v, RXDID_OPCODE, 4) != ICE_RX_OPC_EXTRACT)
-				return false;
+			if (FLX_REG(v, PROT_MDID, 4) == xtr_sets[i].protid_0 &&
+			    FLX_REG(v, RXDID_OPCODE, 4) == xtr_sets[i].opcode)
+				ice_proto_xtr_hw_support[i] = true;
 		}
 
 		if (xtr_sets[i].protid_1 != ICE_PROT_ID_INVAL) {
 			v = ICE_READ_REG(hw, GLFLXP_RXDID_FLX_WRD_5(rxdid));
 
-			if (FLX_REG(v, PROT_MDID, 5) != xtr_sets[i].protid_1 ||
-			    FLX_REG(v, RXDID_OPCODE, 5) != ICE_RX_OPC_EXTRACT)
-				return false;
+			if (FLX_REG(v, PROT_MDID, 5) == xtr_sets[i].protid_1 &&
+			    FLX_REG(v, RXDID_OPCODE, 5) == xtr_sets[i].opcode)
+				ice_proto_xtr_hw_support[i] = true;
 		}
 	}
-
-	return true;
 }
 
 static int
@@ -1416,11 +1435,6 @@ ice_init_proto_xtr(struct rte_eth_dev *dev)
 	int offset;
 	uint16_t i;
 
-	if (!ice_proto_xtr_support(hw)) {
-		PMD_DRV_LOG(NOTICE, "Protocol extraction is not supported");
-		return;
-	}
-
 	pf->proto_xtr = rte_zmalloc(NULL, pf->lan_nb_qps, 0);
 	if (unlikely(pf->proto_xtr == NULL)) {
 		PMD_DRV_LOG(ERR, "No memory for setting up protocol extraction table");
@@ -1443,6 +1457,8 @@ ice_init_proto_xtr(struct rte_eth_dev *dev)
 	if (likely(!proto_xtr_enable))
 		return;
 
+	ice_check_proto_xtr_support(hw);
+
 	offset = rte_mbuf_dynfield_register(&ice_proto_xtr_metadata_param);
 	if (unlikely(offset == -1)) {
 		PMD_DRV_LOG(ERR,
@@ -1462,6 +1478,14 @@ ice_init_proto_xtr(struct rte_eth_dev *dev)
 		if (!ol_flag->required)
 			continue;
 
+		if (!ice_proto_xtr_hw_support[i]) {
+			PMD_DRV_LOG(ERR,
+				    "Protocol extraction type %u is not supported in hardware",
+				    i);
+			rte_net_ice_dynfield_proto_xtr_metadata_offs = -1;
+			break;
+		}
+
 		offset = rte_mbuf_dynflag_register(&ol_flag->param);
 		if (unlikely(offset == -1)) {
 			PMD_DRV_LOG(ERR,
@@ -2113,6 +2137,19 @@ ice_reset_fxp_resource(struct ice_hw *hw)
 	return 0;
 }
 
+static void
+ice_rss_ctx_init(struct ice_pf *pf)
+{
+	ICE_HASH_CFG_RESET(&pf->gtpu_hash_ctx.ipv4);
+	ICE_HASH_CFG_RESET(&pf->gtpu_hash_ctx.ipv6);
+
+	ICE_HASH_CFG_RESET(&pf->gtpu_hash_ctx.ipv4_udp);
+	ICE_HASH_CFG_RESET(&pf->gtpu_hash_ctx.ipv6_udp);
+
+	ICE_HASH_CFG_RESET(&pf->gtpu_hash_ctx.ipv4_tcp);
+	ICE_HASH_CFG_RESET(&pf->gtpu_hash_ctx.ipv6_tcp);
+}
+
 static int
 ice_dev_init(struct rte_eth_dev *dev)
 {
@@ -2244,6 +2281,9 @@ ice_dev_init(struct rte_eth_dev *dev)
 	/* get base queue pairs index  in the device */
 	ice_base_queue_get(pf);
 
+	/* Initialize RSS context for gtpu_eh */
+	ice_rss_ctx_init(pf);
+
 	if (!ad->is_safe_mode) {
 		ret = ice_flow_init(ad);
 		if (ret) {
@@ -2431,16 +2471,283 @@ ice_dev_uninit(struct rte_eth_dev *dev)
 	return 0;
 }
 
+static int
+ice_add_rss_cfg_post(struct ice_pf *pf, uint32_t hdr, uint64_t fld, bool symm)
+{
+	struct ice_hw *hw = ICE_PF_TO_HW(pf);
+	struct ice_vsi *vsi = pf->main_vsi;
+
+	if (hdr & ICE_FLOW_SEG_HDR_GTPU_EH) {
+		if ((hdr & ICE_FLOW_SEG_HDR_IPV4) &&
+		    (hdr & ICE_FLOW_SEG_HDR_UDP)) {
+			pf->gtpu_hash_ctx.ipv4_udp.pkt_hdr = hdr;
+			pf->gtpu_hash_ctx.ipv4_udp.hash_fld = fld;
+			pf->gtpu_hash_ctx.ipv4_udp.symm = symm;
+		} else if ((hdr & ICE_FLOW_SEG_HDR_IPV6) &&
+			   (hdr & ICE_FLOW_SEG_HDR_UDP)) {
+			pf->gtpu_hash_ctx.ipv6_udp.pkt_hdr = hdr;
+			pf->gtpu_hash_ctx.ipv6_udp.hash_fld = fld;
+			pf->gtpu_hash_ctx.ipv6_udp.symm = symm;
+		} else if ((hdr & ICE_FLOW_SEG_HDR_IPV4) &&
+			   (hdr & ICE_FLOW_SEG_HDR_TCP)) {
+			pf->gtpu_hash_ctx.ipv4_tcp.pkt_hdr = hdr;
+			pf->gtpu_hash_ctx.ipv4_tcp.hash_fld = fld;
+			pf->gtpu_hash_ctx.ipv4_tcp.symm = symm;
+		} else if ((hdr & ICE_FLOW_SEG_HDR_IPV6) &&
+			   (hdr & ICE_FLOW_SEG_HDR_TCP)) {
+			pf->gtpu_hash_ctx.ipv6_tcp.pkt_hdr = hdr;
+			pf->gtpu_hash_ctx.ipv6_tcp.hash_fld = fld;
+			pf->gtpu_hash_ctx.ipv6_tcp.symm = symm;
+		} else if (hdr & ICE_FLOW_SEG_HDR_IPV4) {
+			pf->gtpu_hash_ctx.ipv4.pkt_hdr = hdr;
+			pf->gtpu_hash_ctx.ipv4.hash_fld = fld;
+			pf->gtpu_hash_ctx.ipv4.symm = symm;
+			ICE_HASH_CFG_RESET(&pf->gtpu_hash_ctx.ipv4_udp);
+			ICE_HASH_CFG_RESET(&pf->gtpu_hash_ctx.ipv4_tcp);
+		} else if (hdr & ICE_FLOW_SEG_HDR_IPV6) {
+			pf->gtpu_hash_ctx.ipv6.pkt_hdr = hdr;
+			pf->gtpu_hash_ctx.ipv6.hash_fld = fld;
+			pf->gtpu_hash_ctx.ipv6.symm = symm;
+			ICE_HASH_CFG_RESET(&pf->gtpu_hash_ctx.ipv6_udp);
+			ICE_HASH_CFG_RESET(&pf->gtpu_hash_ctx.ipv6_tcp);
+		}
+	}
+
+	if (hdr & (ICE_FLOW_SEG_HDR_GTPU_DWN |
+	    ICE_FLOW_SEG_HDR_GTPU_UP)) {
+		if ((hdr & ICE_FLOW_SEG_HDR_IPV4) &&
+		    (hdr & ICE_FLOW_SEG_HDR_UDP)) {
+			if (ICE_HASH_CFG_IS_ROTATING(&pf->gtpu_hash_ctx.ipv4)) {
+				ice_add_rss_cfg(hw, vsi->idx,
+					pf->gtpu_hash_ctx.ipv4.hash_fld,
+					pf->gtpu_hash_ctx.ipv4.pkt_hdr,
+					pf->gtpu_hash_ctx.ipv4.symm);
+				ICE_HASH_CFG_ROTATE_STOP(&pf->gtpu_hash_ctx.ipv4);
+			}
+		} else if ((hdr & ICE_FLOW_SEG_HDR_IPV6) &&
+			   (hdr & ICE_FLOW_SEG_HDR_UDP)) {
+			if (ICE_HASH_CFG_IS_ROTATING(&pf->gtpu_hash_ctx.ipv6)) {
+				ice_add_rss_cfg(hw, vsi->idx,
+					pf->gtpu_hash_ctx.ipv6.hash_fld,
+					pf->gtpu_hash_ctx.ipv6.pkt_hdr,
+					pf->gtpu_hash_ctx.ipv6.symm);
+				ICE_HASH_CFG_ROTATE_STOP(&pf->gtpu_hash_ctx.ipv6);
+			}
+		} else if ((hdr & ICE_FLOW_SEG_HDR_IPV4) &&
+			   (hdr & ICE_FLOW_SEG_HDR_TCP)) {
+			if (ICE_HASH_CFG_IS_ROTATING(&pf->gtpu_hash_ctx.ipv4)) {
+				ice_add_rss_cfg(hw, vsi->idx,
+					pf->gtpu_hash_ctx.ipv4.hash_fld,
+					pf->gtpu_hash_ctx.ipv4.pkt_hdr,
+					pf->gtpu_hash_ctx.ipv4.symm);
+				ICE_HASH_CFG_ROTATE_STOP(&pf->gtpu_hash_ctx.ipv4);
+			}
+		} else if ((hdr & ICE_FLOW_SEG_HDR_IPV6) &&
+			   (hdr & ICE_FLOW_SEG_HDR_TCP)) {
+			if (ICE_HASH_CFG_IS_ROTATING(&pf->gtpu_hash_ctx.ipv6)) {
+				ice_add_rss_cfg(hw, vsi->idx,
+					pf->gtpu_hash_ctx.ipv6.hash_fld,
+					pf->gtpu_hash_ctx.ipv6.pkt_hdr,
+					pf->gtpu_hash_ctx.ipv6.symm);
+				ICE_HASH_CFG_ROTATE_STOP(&pf->gtpu_hash_ctx.ipv6);
+			}
+		}
+	}
+
+	return 0;
+}
+
+static int
+ice_add_rss_cfg_pre(struct ice_pf *pf, uint32_t hdr)
+{
+	struct ice_hw *hw = ICE_PF_TO_HW(pf);
+	struct ice_vsi *vsi = pf->main_vsi;
+
+	if (hdr & (ICE_FLOW_SEG_HDR_GTPU_DWN |
+	    ICE_FLOW_SEG_HDR_GTPU_UP)) {
+		if ((hdr & ICE_FLOW_SEG_HDR_IPV4) &&
+		    (hdr & ICE_FLOW_SEG_HDR_UDP)) {
+			if (ICE_HASH_CFG_VALID(&pf->gtpu_hash_ctx.ipv4_udp)) {
+				ice_rem_rss_cfg(hw, vsi->idx,
+					pf->gtpu_hash_ctx.ipv4_udp.hash_fld,
+					pf->gtpu_hash_ctx.ipv4_udp.pkt_hdr);
+				ICE_HASH_CFG_RESET(&pf->gtpu_hash_ctx.ipv4_udp);
+			}
+
+			if (ICE_HASH_CFG_VALID(&pf->gtpu_hash_ctx.ipv4)) {
+				ice_rem_rss_cfg(hw, vsi->idx,
+					pf->gtpu_hash_ctx.ipv4.hash_fld,
+					pf->gtpu_hash_ctx.ipv4.pkt_hdr);
+				ICE_HASH_CFG_ROTATE_START(&pf->gtpu_hash_ctx.ipv4);
+			}
+		} else if ((hdr & ICE_FLOW_SEG_HDR_IPV6) &&
+			   (hdr & ICE_FLOW_SEG_HDR_UDP)) {
+			if (ICE_HASH_CFG_VALID(&pf->gtpu_hash_ctx.ipv6_udp)) {
+				ice_rem_rss_cfg(hw, vsi->idx,
+					pf->gtpu_hash_ctx.ipv6_udp.hash_fld,
+					pf->gtpu_hash_ctx.ipv6_udp.pkt_hdr);
+				ICE_HASH_CFG_RESET(&pf->gtpu_hash_ctx.ipv6_udp);
+			}
+
+			if (ICE_HASH_CFG_VALID(&pf->gtpu_hash_ctx.ipv6)) {
+				ice_rem_rss_cfg(hw, vsi->idx,
+					pf->gtpu_hash_ctx.ipv6.hash_fld,
+					pf->gtpu_hash_ctx.ipv6.pkt_hdr);
+				ICE_HASH_CFG_ROTATE_START(&pf->gtpu_hash_ctx.ipv6);
+			}
+		} else if ((hdr & ICE_FLOW_SEG_HDR_IPV4) &&
+			   (hdr & ICE_FLOW_SEG_HDR_TCP)) {
+			if (ICE_HASH_CFG_VALID(&pf->gtpu_hash_ctx.ipv4_tcp)) {
+				ice_rem_rss_cfg(hw, vsi->idx,
+					pf->gtpu_hash_ctx.ipv4_tcp.hash_fld,
+					pf->gtpu_hash_ctx.ipv4_tcp.pkt_hdr);
+				ICE_HASH_CFG_RESET(&pf->gtpu_hash_ctx.ipv4_tcp);
+			}
+
+			if (ICE_HASH_CFG_VALID(&pf->gtpu_hash_ctx.ipv4)) {
+				ice_rem_rss_cfg(hw, vsi->idx,
+					pf->gtpu_hash_ctx.ipv4.hash_fld,
+					pf->gtpu_hash_ctx.ipv4.pkt_hdr);
+				ICE_HASH_CFG_ROTATE_START(&pf->gtpu_hash_ctx.ipv4);
+			}
+		} else if ((hdr & ICE_FLOW_SEG_HDR_IPV6) &&
+			   (hdr & ICE_FLOW_SEG_HDR_TCP)) {
+			if (ICE_HASH_CFG_VALID(&pf->gtpu_hash_ctx.ipv6_tcp)) {
+				ice_rem_rss_cfg(hw, vsi->idx,
+					pf->gtpu_hash_ctx.ipv6_tcp.hash_fld,
+					pf->gtpu_hash_ctx.ipv6_tcp.pkt_hdr);
+				ICE_HASH_CFG_RESET(&pf->gtpu_hash_ctx.ipv6_tcp);
+			}
+
+			if (ICE_HASH_CFG_VALID(&pf->gtpu_hash_ctx.ipv6)) {
+				ice_rem_rss_cfg(hw, vsi->idx,
+					pf->gtpu_hash_ctx.ipv6.hash_fld,
+					pf->gtpu_hash_ctx.ipv6.pkt_hdr);
+				ICE_HASH_CFG_ROTATE_START(&pf->gtpu_hash_ctx.ipv6);
+			}
+		} else if (hdr & ICE_FLOW_SEG_HDR_IPV4) {
+			if (ICE_HASH_CFG_VALID(&pf->gtpu_hash_ctx.ipv4)) {
+				ice_rem_rss_cfg(hw, vsi->idx,
+					pf->gtpu_hash_ctx.ipv4.hash_fld,
+					pf->gtpu_hash_ctx.ipv4.pkt_hdr);
+				ICE_HASH_CFG_RESET(&pf->gtpu_hash_ctx.ipv4);
+			}
+
+			if (ICE_HASH_CFG_VALID(&pf->gtpu_hash_ctx.ipv4_udp)) {
+				ice_rem_rss_cfg(hw, vsi->idx,
+					pf->gtpu_hash_ctx.ipv4_udp.hash_fld,
+					pf->gtpu_hash_ctx.ipv4_udp.pkt_hdr);
+				ICE_HASH_CFG_RESET(&pf->gtpu_hash_ctx.ipv4_udp);
+			}
+
+			if (ICE_HASH_CFG_VALID(&pf->gtpu_hash_ctx.ipv4_tcp)) {
+				ice_rem_rss_cfg(hw, vsi->idx,
+					pf->gtpu_hash_ctx.ipv4_tcp.hash_fld,
+					pf->gtpu_hash_ctx.ipv4_tcp.pkt_hdr);
+				ICE_HASH_CFG_RESET(&pf->gtpu_hash_ctx.ipv4_tcp);
+			}
+		} else if (hdr & ICE_FLOW_SEG_HDR_IPV6) {
+			if (ICE_HASH_CFG_VALID(&pf->gtpu_hash_ctx.ipv6)) {
+				ice_rem_rss_cfg(hw, vsi->idx,
+					pf->gtpu_hash_ctx.ipv6.hash_fld,
+					pf->gtpu_hash_ctx.ipv6.pkt_hdr);
+				ICE_HASH_CFG_RESET(&pf->gtpu_hash_ctx.ipv6);
+			}
+
+			if (ICE_HASH_CFG_VALID(&pf->gtpu_hash_ctx.ipv6_udp)) {
+				ice_rem_rss_cfg(hw, vsi->idx,
+					pf->gtpu_hash_ctx.ipv6_udp.hash_fld,
+					pf->gtpu_hash_ctx.ipv6_udp.pkt_hdr);
+				ICE_HASH_CFG_RESET(&pf->gtpu_hash_ctx.ipv6_udp);
+			}
+
+			if (ICE_HASH_CFG_VALID(&pf->gtpu_hash_ctx.ipv6_tcp)) {
+				ice_rem_rss_cfg(hw, vsi->idx,
+					pf->gtpu_hash_ctx.ipv6_tcp.hash_fld,
+					pf->gtpu_hash_ctx.ipv6_tcp.pkt_hdr);
+				ICE_HASH_CFG_RESET(&pf->gtpu_hash_ctx.ipv6_tcp);
+			}
+		}
+	}
+
+	return 0;
+}
+
+static int
+ice_rem_rss_cfg_post(struct ice_pf *pf, uint32_t hdr)
+{
+	if (hdr & ICE_FLOW_SEG_HDR_GTPU_EH) {
+		if ((hdr & ICE_FLOW_SEG_HDR_IPV4) &&
+		    (hdr & ICE_FLOW_SEG_HDR_UDP)) {
+			ICE_HASH_CFG_RESET(&pf->gtpu_hash_ctx.ipv4_udp);
+		} else if ((hdr & ICE_FLOW_SEG_HDR_IPV6) &&
+			   (hdr & ICE_FLOW_SEG_HDR_UDP)) {
+			ICE_HASH_CFG_RESET(&pf->gtpu_hash_ctx.ipv6_udp);
+		} else if ((hdr & ICE_FLOW_SEG_HDR_IPV4) &&
+			   (hdr & ICE_FLOW_SEG_HDR_TCP)) {
+			ICE_HASH_CFG_RESET(&pf->gtpu_hash_ctx.ipv4_tcp);
+		} else if ((hdr & ICE_FLOW_SEG_HDR_IPV6) &&
+			   (hdr & ICE_FLOW_SEG_HDR_TCP)) {
+			ICE_HASH_CFG_RESET(&pf->gtpu_hash_ctx.ipv6_tcp);
+		} else if (hdr & ICE_FLOW_SEG_HDR_IPV4) {
+			ICE_HASH_CFG_RESET(&pf->gtpu_hash_ctx.ipv4);
+		} else if (hdr & ICE_FLOW_SEG_HDR_IPV6) {
+			ICE_HASH_CFG_RESET(&pf->gtpu_hash_ctx.ipv6);
+		}
+	}
+
+	return 0;
+}
+
+int
+ice_rem_rss_cfg_wrap(struct ice_pf *pf, uint16_t vsi_id,
+		uint64_t fld, uint32_t hdr)
+{
+	struct ice_hw *hw = ICE_PF_TO_HW(pf);
+	int ret;
+
+	ret = ice_rem_rss_cfg(hw, vsi_id, fld, hdr);
+	if (ret && ret != ICE_ERR_DOES_NOT_EXIST)
+		PMD_DRV_LOG(ERR, "remove rss cfg failed\n");
+
+	ret = ice_rem_rss_cfg_post(pf, hdr);
+	if (ret)
+		PMD_DRV_LOG(ERR, "remove rss cfg post failed\n");
+
+	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_hw *hw = ICE_PF_TO_HW(pf);
+	int ret;
+
+	ret = ice_add_rss_cfg_pre(pf, hdr);
+	if (ret)
+		PMD_DRV_LOG(ERR, "add rss cfg pre failed\n");
+
+	ret = ice_add_rss_cfg(hw, vsi_id, fld, hdr, symm);
+	if (ret)
+		PMD_DRV_LOG(ERR, "add rss cfg failed\n");
+
+	ret = ice_add_rss_cfg_post(pf, hdr, fld, symm);
+	if (ret)
+		PMD_DRV_LOG(ERR, "add rss cfg post failed\n");
+
+	return 0;
+}
+
 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;
 	int ret;
 
 	/* Configure RSS for IPv4 with src/dst addr as input set */
 	if (rss_hf & ETH_RSS_IPV4) {
-		ret = ice_add_rss_cfg(hw, vsi->idx, ICE_FLOW_HASH_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);
 		if (ret)
@@ -2450,7 +2757,7 @@ 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(hw, vsi->idx, ICE_FLOW_HASH_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);
 		if (ret)
@@ -2460,7 +2767,7 @@ 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(hw, vsi->idx, ICE_HASH_UDP_IPV4,
+		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);
@@ -2471,7 +2778,7 @@ 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(hw, vsi->idx, ICE_HASH_UDP_IPV6,
+		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);
@@ -2482,7 +2789,7 @@ 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(hw, vsi->idx, ICE_HASH_TCP_IPV4,
+		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);
@@ -2493,7 +2800,7 @@ 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(hw, vsi->idx, ICE_HASH_TCP_IPV6,
+		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);
@@ -2504,7 +2811,7 @@ 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(hw, vsi->idx, ICE_FLOW_HASH_IPV4,
+		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);
@@ -2515,7 +2822,7 @@ 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(hw, vsi->idx, ICE_FLOW_HASH_IPV6,
+		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);
@@ -2525,7 +2832,7 @@ ice_rss_hash_set(struct ice_pf *pf, uint64_t rss_hf)
 	}
 
 	if (rss_hf & ETH_RSS_IPV4) {
-		ret = ice_add_rss_cfg(hw, vsi->idx, ICE_FLOW_HASH_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);
@@ -2533,7 +2840,7 @@ ice_rss_hash_set(struct ice_pf *pf, uint64_t rss_hf)
 			PMD_DRV_LOG(ERR, "%s GTPU_IPV4 rss flow fail %d",
 				    __func__, ret);
 
-		ret = ice_add_rss_cfg(hw, vsi->idx, ICE_FLOW_HASH_IPV4,
+		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);
@@ -2541,7 +2848,7 @@ ice_rss_hash_set(struct ice_pf *pf, uint64_t rss_hf)
 			PMD_DRV_LOG(ERR, "%s GTPU_EH_IPV4 rss flow fail %d",
 				    __func__, ret);
 
-		ret = ice_add_rss_cfg(hw, vsi->idx, ICE_FLOW_HASH_IPV4,
+		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);
@@ -2551,7 +2858,7 @@ ice_rss_hash_set(struct ice_pf *pf, uint64_t rss_hf)
 	}
 
 	if (rss_hf & ETH_RSS_IPV6) {
-		ret = ice_add_rss_cfg(hw, vsi->idx, ICE_FLOW_HASH_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);
@@ -2559,7 +2866,7 @@ ice_rss_hash_set(struct ice_pf *pf, uint64_t rss_hf)
 			PMD_DRV_LOG(ERR, "%s GTPU_IPV6 rss flow fail %d",
 				    __func__, ret);
 
-		ret = ice_add_rss_cfg(hw, vsi->idx, ICE_FLOW_HASH_IPV6,
+		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);
@@ -2567,7 +2874,7 @@ ice_rss_hash_set(struct ice_pf *pf, uint64_t rss_hf)
 			PMD_DRV_LOG(ERR, "%s GTPU_EH_IPV6 rss flow fail %d",
 				    __func__, ret);
 
-		ret = ice_add_rss_cfg(hw, vsi->idx, ICE_FLOW_HASH_IPV6,
+		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);
@@ -2577,108 +2884,156 @@ ice_rss_hash_set(struct ice_pf *pf, uint64_t rss_hf)
 	}
 
 	if (rss_hf & ETH_RSS_NONFRAG_IPV4_UDP) {
-		ret = ice_add_rss_cfg(hw, vsi->idx, ICE_HASH_UDP_IPV4,
-				ICE_FLOW_SEG_HDR_GTPU_IP, 0);
+		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);
 		if (ret)
 			PMD_DRV_LOG(ERR, "%s GTPU_IPV4_UDP rss flow fail %d",
 				    __func__, ret);
 
-		ret = ice_add_rss_cfg(hw, vsi->idx, ICE_HASH_UDP_IPV4,
-				ICE_FLOW_SEG_HDR_GTPU_EH, 0);
+		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);
 		if (ret)
 			PMD_DRV_LOG(ERR, "%s GTPU_EH_IPV4_UDP rss flow fail %d",
 				    __func__, ret);
 
-		ret = ice_add_rss_cfg(hw, vsi->idx, ICE_HASH_UDP_IPV4,
-				ICE_FLOW_SEG_HDR_PPPOE, 0);
+		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);
 		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(hw, vsi->idx, ICE_HASH_UDP_IPV6,
-				ICE_FLOW_SEG_HDR_GTPU_IP, 0);
+		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);
 		if (ret)
 			PMD_DRV_LOG(ERR, "%s GTPU_IPV6_UDP rss flow fail %d",
 				    __func__, ret);
 
-		ret = ice_add_rss_cfg(hw, vsi->idx, ICE_HASH_UDP_IPV6,
-				ICE_FLOW_SEG_HDR_GTPU_EH, 0);
+		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);
 		if (ret)
 			PMD_DRV_LOG(ERR, "%s GTPU_EH_IPV6_UDP rss flow fail %d",
 				    __func__, ret);
 
-		ret = ice_add_rss_cfg(hw, vsi->idx, ICE_HASH_UDP_IPV6,
-				ICE_FLOW_SEG_HDR_PPPOE, 0);
+		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);
 		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(hw, vsi->idx, ICE_HASH_TCP_IPV4,
-				ICE_FLOW_SEG_HDR_GTPU_IP, 0);
+		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);
 		if (ret)
 			PMD_DRV_LOG(ERR, "%s GTPU_IPV4_TCP rss flow fail %d",
 				    __func__, ret);
 
-		ret = ice_add_rss_cfg(hw, vsi->idx, ICE_HASH_TCP_IPV4,
-				ICE_FLOW_SEG_HDR_GTPU_EH, 0);
+		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);
 		if (ret)
 			PMD_DRV_LOG(ERR, "%s GTPU_EH_IPV4_TCP rss flow fail %d",
 				    __func__, ret);
 
-		ret = ice_add_rss_cfg(hw, vsi->idx, ICE_HASH_TCP_IPV4,
-				ICE_FLOW_SEG_HDR_PPPOE, 0);
+		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);
 		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(hw, vsi->idx, ICE_HASH_TCP_IPV6,
-				ICE_FLOW_SEG_HDR_GTPU_IP, 0);
+		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);
 		if (ret)
 			PMD_DRV_LOG(ERR, "%s GTPU_IPV6_TCP rss flow fail %d",
 				    __func__, ret);
 
-		ret = ice_add_rss_cfg(hw, vsi->idx, ICE_HASH_TCP_IPV6,
-				ICE_FLOW_SEG_HDR_GTPU_EH, 0);
+		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);
 		if (ret)
 			PMD_DRV_LOG(ERR, "%s GTPU_EH_IPV6_TCP rss flow fail %d",
 				    __func__, ret);
 
-		ret = ice_add_rss_cfg(hw, vsi->idx, ICE_HASH_TCP_IPV6,
-				ICE_FLOW_SEG_HDR_PPPOE, 0);
+		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);
 		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(hw, vsi->idx, ICE_HASH_SCTP_IPV4,
-				ICE_FLOW_SEG_HDR_GTPU_IP, 0);
+		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(hw, vsi->idx, ICE_HASH_SCTP_IPV4,
-				ICE_FLOW_SEG_HDR_GTPU_EH, 0);
+		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(hw, vsi->idx, ICE_HASH_SCTP_IPV6,
-				ICE_FLOW_SEG_HDR_GTPU_IP, 0);
+		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(hw, vsi->idx, ICE_HASH_SCTP_IPV6,
-				ICE_FLOW_SEG_HDR_GTPU_EH, 0);
+		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);
@@ -4798,7 +5153,7 @@ RTE_PMD_REGISTER_PCI(net_ice, rte_ice_pmd);
 RTE_PMD_REGISTER_PCI_TABLE(net_ice, pci_id_ice_map);
 RTE_PMD_REGISTER_KMOD_DEP(net_ice, "* igb_uio | uio_pci_generic | vfio-pci");
 RTE_PMD_REGISTER_PARAM_STRING(net_ice,
-			      ICE_PROTO_XTR_ARG "=[queue:]<vlan|ipv4|ipv6|ipv6_flow|tcp>"
+			      ICE_PROTO_XTR_ARG "=[queue:]<vlan|ipv4|ipv6|ipv6_flow|tcp|ip_offset>"
 			      ICE_SAFE_MODE_SUPPORT_ARG "=<0|1>"
 			      ICE_PIPELINE_MODE_SUPPORT_ARG "=<0|1>"
 			      ICE_FLOW_MARK_SUPPORT_ARG "=<0|1>");