diff --git a/app/test-pmd/cmdline.c b/app/test-pmd/cmdline.c
index 2d18b6c..4b52091 100644
--- a/app/test-pmd/cmdline.c
+++ b/app/test-pmd/cmdline.c
@@ -9084,7 +9084,7 @@ struct cmd_tunnel_filter_result {
 
 /* *** CONFIGURE TUNNEL UDP PORT *** */
 struct cmd_tunnel_udp_config {
-	cmdline_fixed_string_t cmd;
+        cmdline_fixed_string_t rx_vxlan_port;
 	cmdline_fixed_string_t what;
 	uint16_t udp_port;
 	portid_t port_id;
@@ -9101,8 +9101,7 @@ struct cmd_tunnel_udp_config {
 
 	tunnel_udp.udp_port = res->udp_port;
 
-	if (!strcmp(res->cmd, "rx_vxlan_port"))
-		tunnel_udp.prot_type = RTE_TUNNEL_TYPE_VXLAN;
+        tunnel_udp.prot_type = RTE_TUNNEL_TYPE_VXLAN;
 
 	if (!strcmp(res->what, "add"))
 		ret = rte_eth_dev_udp_tunnel_port_add(res->port_id,
@@ -9115,9 +9114,9 @@ struct cmd_tunnel_udp_config {
 		printf("udp tunneling add error: (%s)\n", strerror(-ret));
 }
 
-cmdline_parse_token_string_t cmd_tunnel_udp_config_cmd =
-	TOKEN_STRING_INITIALIZER(struct cmd_tunnel_udp_config,
-				cmd, "rx_vxlan_port");
+cmdline_parse_token_string_t cmd_tunnel_udp_config_rx_vxlan_port =
+        TOKEN_STRING_INITIALIZER(struct cmd_tunnel_udp_config,
+                                rx_vxlan_port, "rx_vxlan_port");
 cmdline_parse_token_string_t cmd_tunnel_udp_config_what =
 	TOKEN_STRING_INITIALIZER(struct cmd_tunnel_udp_config,
 				what, "add#rm");
@@ -9134,7 +9133,7 @@ struct cmd_tunnel_udp_config {
 	.help_str = "rx_vxlan_port add|rm <udp_port> <port_id>: "
 		"Add/Remove a tunneling UDP port filter",
 	.tokens = {
-		(void *)&cmd_tunnel_udp_config_cmd,
+		(void *)&cmd_tunnel_udp_config_rx_vxlan_port,
 		(void *)&cmd_tunnel_udp_config_what,
 		(void *)&cmd_tunnel_udp_config_udp_port,
 		(void *)&cmd_tunnel_udp_config_port_id,
diff --git a/drivers/common/iavf/virtchnl.h b/drivers/common/iavf/virtchnl.h
index 302cc24..e7f7a02 100644
--- a/drivers/common/iavf/virtchnl.h
+++ b/drivers/common/iavf/virtchnl.h
@@ -128,7 +128,9 @@ enum virtchnl_ops {
 	VIRTCHNL_OP_DISABLE_CHANNELS = 31,
 	VIRTCHNL_OP_ADD_CLOUD_FILTER = 32,
 	VIRTCHNL_OP_DEL_CLOUD_FILTER = 33,
-	/* opcodes 34, 35, 36, 37 and 38 are reserved */
+	/* opcodes 34, 35, 36 and 37 are reserved */
+        VIRTCHNL_OP_DCF_RULE_FLUSH = 6000,
+        VIRTCHNL_OP_DCF_VLAN_OFFLOAD = 38,
 	VIRTCHNL_OP_DCF_CMD_DESC = 39,
 	VIRTCHNL_OP_DCF_CMD_BUFF = 40,
 	VIRTCHNL_OP_DCF_DISABLE = 41,
@@ -771,6 +773,7 @@ enum virtchnl_event_codes {
 	VIRTCHNL_EVENT_RESET_IMPENDING,
 	VIRTCHNL_EVENT_PF_DRIVER_CLOSE,
 	VIRTCHNL_EVENT_DCF_VSI_MAP_UPDATE,
+        VIRTCHNL_EVENT_DCF_VSI_INFO = 1000,
 };
 
 #define PF_EVENT_SEVERITY_INFO		0
@@ -1468,6 +1471,7 @@ enum virtchnl_vector_limits {
 		 */
 		valid_len = msglen;
 		break;
+        case VIRTCHNL_OP_DCF_RULE_FLUSH:
 	case VIRTCHNL_OP_DCF_DISABLE:
 	case VIRTCHNL_OP_DCF_GET_VSI_MAP:
 	case VIRTCHNL_OP_DCF_GET_PKG_INFO:
diff --git a/drivers/net/iavf/iavf_ethdev.c b/drivers/net/iavf/iavf_ethdev.c
index 93c68e6..eca54a9 100644
--- a/drivers/net/iavf/iavf_ethdev.c
+++ b/drivers/net/iavf/iavf_ethdev.c
@@ -2115,7 +2115,7 @@ static int iavf_parse_devargs(struct rte_eth_dev *dev)
 iavf_dcf_cap_check_handler(__rte_unused const char *key,
 			   const char *value, __rte_unused void *opaque)
 {
-	if (strcmp(value, "dcf"))
+        if (strcmp(value, "dcf") && strcmp(value, "mdcf"))
 		return -1;
 
 	return 0;
diff --git a/drivers/net/ice/base/ice_common.c b/drivers/net/ice/base/ice_common.c
index 304e55e..4039e34 100644
--- a/drivers/net/ice/base/ice_common.c
+++ b/drivers/net/ice/base/ice_common.c
@@ -538,6 +538,28 @@ enum ice_status
 	return ice_aq_send_cmd(hw, &desc, NULL, 0, cd);
 }
 
+static int ice_buildin_recipe_init(struct ice_hw *hw)
+{
+        struct ice_switch_info *sw = hw->switch_info;
+        struct ice_sw_recipe *recipe;
+
+        sw->buildin_recipes = ice_malloc(hw,
+                        sizeof(sw->buildin_recipes[0]) * ICE_MAX_NUM_RECIPES);
+
+        if (!sw->buildin_recipes)
+                return ICE_ERR_NO_MEMORY;
+
+        recipe = &sw->buildin_recipes[10];
+        recipe->is_root = 1;
+
+        recipe->lkup_exts.n_val_words = 1;
+        recipe->lkup_exts.field_mask[0] = 0x00ff;
+        recipe->lkup_exts.fv_words[0].off = 8;
+        recipe->lkup_exts.fv_words[0].prot_id = 32;
+
+        return ICE_SUCCESS;
+}
+
 /**
  * ice_init_fltr_mgmt_struct - initializes filter management list and locks
  * @hw: pointer to the HW struct
@@ -558,6 +580,8 @@ enum ice_status ice_init_fltr_mgmt_struct(struct ice_hw *hw)
 	INIT_LIST_HEAD(&sw->vsi_list_map_head);
 	sw->prof_res_bm_init = 0;
 
+        ice_buildin_recipe_init(hw);
+
 	status = ice_init_def_sw_recp(hw, &hw->switch_info->recp_list);
 	if (status) {
 		ice_free(hw, hw->switch_info);
@@ -628,6 +652,7 @@ enum ice_status ice_init_fltr_mgmt_struct(struct ice_hw *hw)
 			ice_free(hw, recps[i].root_buf);
 	}
 	ice_rm_sw_replay_rule_info(hw, sw);
+        ice_free(hw, sw->buildin_recipes);
 	ice_free(hw, sw->recp_list);
 	ice_free(hw, sw);
 }
diff --git a/drivers/net/ice/base/ice_flex_pipe.c b/drivers/net/ice/base/ice_flex_pipe.c
index 7594df1..6906259 100644
--- a/drivers/net/ice/base/ice_flex_pipe.c
+++ b/drivers/net/ice/base/ice_flex_pipe.c
@@ -13,6 +13,7 @@
 static const struct ice_tunnel_type_scan tnls[] = {
 	{ TNL_VXLAN,		"TNL_VXLAN_PF" },
 	{ TNL_GENEVE,		"TNL_GENEVE_PF" },
+        { TNL_ECPRI,           "TNL_UDP_ECPRI_PF" },
 	{ TNL_LAST,		"" }
 };
 
@@ -1280,6 +1281,9 @@ static void ice_init_pkg_regs(struct ice_hw *hw)
  */
 static enum ice_status ice_chk_pkg_version(struct ice_pkg_ver *pkg_ver)
 {
+        if (pkg_ver->major == 0xFF)
+            return ICE_SUCCESS;
+
 	if (pkg_ver->major != ICE_PKG_SUPP_VER_MAJ ||
 	    pkg_ver->minor != ICE_PKG_SUPP_VER_MNR)
 		return ICE_ERR_NOT_SUPPORTED;
@@ -1664,6 +1668,7 @@ static struct ice_buf_build *ice_pkg_buf_alloc(struct ice_hw *hw)
  * @ids_cnt: lookup/protocol count
  * @bm: bitmap of field vectors to consider
  * @fv_list: Head of a list
+ * @lkup_exts: lookup elements
  *
  * Finds all the field vector entries from switch block that contain
  * a given protocol ID and returns a list of structures of type
@@ -1674,7 +1679,8 @@ static struct ice_buf_build *ice_pkg_buf_alloc(struct ice_hw *hw)
  */
 enum ice_status
 ice_get_sw_fv_list(struct ice_hw *hw, u8 *prot_ids, u16 ids_cnt,
-		   ice_bitmap_t *bm, struct LIST_HEAD_TYPE *fv_list)
+                   ice_bitmap_t *bm, struct LIST_HEAD_TYPE *fv_list,
+                   struct ice_prot_lkup_ext *lkup_exts)
 {
 	struct ice_sw_fv_list_entry *fvl;
 	struct ice_sw_fv_list_entry *tmp;
@@ -1705,6 +1711,7 @@ enum ice_status
 		if (!ice_is_bit_set(bm, (u16)offset))
 			continue;
 
+#if 0
 		for (i = 0; i < ids_cnt; i++) {
 			int j;
 
@@ -1729,6 +1736,27 @@ enum ice_status
 				break;
 			}
 		}
+#else
+                int found = 1;
+                for (i = 0; i < lkup_exts->n_val_words; i++) {
+                        int j;
+
+                        for (j = 0; j < hw->blk[ICE_BLK_SW].es.fvw; j++)
+                                if (fv->ew[j].prot_id == lkup_exts->fv_words[i].prot_id && fv->ew[j].off == lkup_exts->fv_words[i].off)
+                                        break;
+                        if (j >= hw->blk[ICE_BLK_SW].es.fvw)
+                                found = 0;
+                }
+                if (found) {
+                        fvl = (struct ice_sw_fv_list_entry *)
+                                ice_malloc(hw, sizeof(*fvl));
+                        if (!fvl)
+                                goto err;
+                        fvl->fv_ptr = fv;
+                        fvl->profile_id = offset;
+                        LIST_ADD(&fvl->list_entry, fv_list);
+                }
+#endif
 	} while (fv);
 	if (LIST_EMPTY(fv_list))
 		return ICE_ERR_CFG;
diff --git a/drivers/net/ice/base/ice_flex_pipe.h b/drivers/net/ice/base/ice_flex_pipe.h
index 214c7a2..4ea0650 100644
--- a/drivers/net/ice/base/ice_flex_pipe.h
+++ b/drivers/net/ice/base/ice_flex_pipe.h
@@ -37,7 +37,7 @@ enum ice_status
 ice_init_prof_result_bm(struct ice_hw *hw);
 enum ice_status
 ice_get_sw_fv_list(struct ice_hw *hw, u8 *prot_ids, u16 ids_cnt,
-		   ice_bitmap_t *bm, struct LIST_HEAD_TYPE *fv_list);
+                   ice_bitmap_t *bm, struct LIST_HEAD_TYPE *fv_list, struct ice_prot_lkup_ext *lkup_exts);
 bool
 ice_get_open_tunnel_port(struct ice_hw *hw, enum ice_tunnel_type type,
 			 u16 *port);
diff --git a/drivers/net/ice/base/ice_flex_type.h b/drivers/net/ice/base/ice_flex_type.h
index 1dd57ba..bbe7a8a 100644
--- a/drivers/net/ice/base/ice_flex_type.h
+++ b/drivers/net/ice/base/ice_flex_type.h
@@ -516,6 +516,7 @@ struct ice_pkg_enum {
 enum ice_tunnel_type {
 	TNL_VXLAN = 0,
 	TNL_GENEVE,
+        TNL_ECPRI,
 	TNL_LAST = 0xFF,
 	TNL_ALL = 0xFF,
 };
diff --git a/drivers/net/ice/base/ice_protocol_type.h b/drivers/net/ice/base/ice_protocol_type.h
index e8caefd..f9fc208 100644
--- a/drivers/net/ice/base/ice_protocol_type.h
+++ b/drivers/net/ice/base/ice_protocol_type.h
@@ -44,6 +44,7 @@ enum ice_protocol_type {
 	ICE_GENEVE,
 	ICE_VXLAN_GPE,
 	ICE_NVGRE,
+        ICE_GRE,
 	ICE_GTP,
 	ICE_PPPOE,
 	ICE_PFCP,
@@ -65,6 +66,7 @@ enum ice_sw_tunnel_type {
 	ICE_SW_TUN_VXLAN,	/* VXLAN matches only non-VLAN pkts */
 	ICE_SW_TUN_VXLAN_VLAN,  /* VXLAN matches both VLAN and non-VLAN pkts */
 	ICE_SW_TUN_NVGRE,
+        ICE_SW_TUN_GRE,
 	ICE_SW_TUN_UDP, /* This means all "UDP" tunnel types: VXLAN-GPE, VXLAN
 			 * and GENEVE
 			 */
@@ -196,6 +198,10 @@ enum ice_prot_id {
 #define ICE_TUN_FLAG_VLAN_MASK 0x01
 #define ICE_TUN_FLAG_FV_IND 2
 
+#define ICE_GRE_FLAG_MDID 22
+#define ICE_GRE_FLAG_MDID_OFF (ICE_MDID_SIZE * ICE_GRE_FLAG_MDID)
+#define ICE_GRE_FLAG_MASK 0x01C0
+
 #define ICE_PROTOCOL_MAX_ENTRIES 16
 
 /* Mapping of software defined protocol ID to hardware defined protocol ID */
@@ -336,6 +342,15 @@ struct ice_nvgre {
 	__be32 tni_flow;
 };
 
+struct ice_gre {
+        __be16 flags;
+        __be16 protocol;
+        __be16 chksum;
+        __be16 offset;
+        __be32 key;
+        __be32 seqnum;
+};
+
 union ice_prot_hdr {
 	struct ice_ether_hdr eth_hdr;
 	struct ice_ethtype_hdr ethertype;
@@ -346,6 +361,7 @@ struct ice_nvgre {
 	struct ice_sctp_hdr sctp_hdr;
 	struct ice_udp_tnl_hdr tnl_hdr;
 	struct ice_nvgre nvgre_hdr;
+        struct ice_gre gre_hdr;
 	struct ice_udp_gtp_hdr gtp_hdr;
 	struct ice_pppoe_hdr pppoe_hdr;
 	struct ice_pfcp_hdr pfcp_hdr;
diff --git a/drivers/net/ice/base/ice_switch.c b/drivers/net/ice/base/ice_switch.c
index dc55d7e..b1a6ee3 100644
--- a/drivers/net/ice/base/ice_switch.c
+++ b/drivers/net/ice/base/ice_switch.c
@@ -11,6 +11,8 @@
 #define ICE_ETH_VLAN_TCI_OFFSET		14
 #define ICE_MAX_VLAN_ID			0xFFF
 #define ICE_IPV4_NVGRE_PROTO_ID		0x002F
+#define ICE_IPV4_GRE_PROTO_ID           0x002F
+#define ICE_IPV6_GRE_PROTO_ID           0x002F
 #define ICE_PPP_IPV6_PROTO_ID		0x0057
 #define ICE_IPV6_ETHER_ID		0x86DD
 #define ICE_TCP_PROTO_ID		0x06
@@ -126,6 +128,209 @@ struct ice_dummy_pkt_offsets {
 	0x00, 0x08, 0x00, 0x00,
 };
 
+static const struct ice_dummy_pkt_offsets dummy_ipv6_gre_udp_packet_offsets[] = {
+        { ICE_MAC_OFOS,         0 },
+        { ICE_ETYPE_OL,         12 },
+        { ICE_IPV6_OFOS,        14 },
+        { ICE_GRE,              54 },
+        { ICE_IPV6_IL,          58 },
+        { ICE_UDP_ILOS,         98 },
+        { ICE_PROTOCOL_LAST,    0 },
+};
+
+static const u8 dummy_ipv6_gre_udp_packet[] = {
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x86, 0xdd, 0x60, 0x00,
+        0x00, 0x00, 0x00, 0x36, 0x2f, 0x40, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+        0x86, 0xdd, 0x60, 0x00, 0x00, 0x00, 0x00, 0x0a,
+        0x11, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a,
+        0xff, 0xd8, 0x00, 0x00,
+};
+
+static const struct ice_dummy_pkt_offsets dummy_gre_rfc1701_c1k1_tcp_packet_offsets[] = {
+        { ICE_MAC_OFOS,         0 },
+        { ICE_ETYPE_OL,         12 },
+        { ICE_IPV4_OFOS,        14 },
+        { ICE_GRE,              34 },
+        { ICE_IPV4_IL,          50 },
+        { ICE_TCP_IL,           70 },
+        { ICE_PROTOCOL_LAST,    0 },
+};
+
+static const u8 dummy_gre_rfc1701_c1k1_tcp_packet[] = {
+        0x00, 0x00, 0x00, 0x00,  /* ICE_MAC_OFOS 0 */
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+
+        0x08, 0x00,             /* ICE_ETYPE_OL 12 */
+
+        0x45, 0x00, 0x00, 0x4e, /* ICE_IPV4_OFOS 14 */
+        0x00, 0x01, 0x00, 0x00,
+        0x40, 0x2f, 0x7c, 0x7e,
+        0x7f, 0x00, 0x00, 0x01,
+        0x7f, 0x00, 0x00, 0x01,
+
+        0xb0, 0x00, 0x08, 0x00, /* ICE_GRE 34 */
+        0x46, 0x1e, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+
+        0x45, 0x00, 0x00, 0x2a, /* ICE_IPV4_IL 50 */
+        0x00, 0x01, 0x00, 0x00,
+        0x40, 0x06, 0x7c, 0xcb,
+        0x7f, 0x00, 0x00, 0x01,
+        0x7f, 0x00, 0x00, 0x01,
+
+        0x00, 0x14, 0x00, 0x50, /* ICE_TCP_IL 70 */
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x50, 0x02, 0x20, 0x00,
+        0x91, 0x7a, 0x00, 0x00,
+
+        0x00, 0x00,
+};
+
+static const struct ice_dummy_pkt_offsets dummy_gre_rfc1701_c1k1_udp_packet_offsets[] = {
+        { ICE_MAC_OFOS,         0 },
+        { ICE_ETYPE_OL,         12 },
+        { ICE_IPV4_OFOS,        14 },
+        { ICE_GRE,              34 },
+        { ICE_IPV4_IL,          50 },
+        { ICE_UDP_ILOS,         70 },
+        { ICE_PROTOCOL_LAST,    0 },
+};
+
+static const u8 dummy_gre_rfc1701_c1k1_udp_packet[] = {
+        0x00, 0x00, 0x00, 0x00,  /* ICE_MAC_OFOS 0 */
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+
+        0x08, 0x00,             /* ICE_ETYPE_OL 12 */
+
+        0x45, 0x00, 0x00, 0x42, /* ICE_IPV4_OFOS 14 */
+        0x00, 0x01, 0x00, 0x00,
+        0x40, 0x2f, 0x7c, 0x8a,
+        0x7f, 0x00, 0x00, 0x01,
+        0x7f, 0x00, 0x00, 0x01,
+
+        0xb0, 0x00, 0x08, 0x00, /* ICE_GRE 34 */
+        0x46, 0x1d, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+
+        0x45, 0x00, 0x00, 0x1e, /* ICE_IPV4_IL 50 */
+        0x00, 0x01, 0x00, 0x00,
+        0x40, 0x11, 0x7c, 0xcc,
+        0x7f, 0x00, 0x00, 0x01,
+        0x7f, 0x00, 0x00, 0x01,
+
+        0x00, 0x35, 0x00, 0x35, /* ICE_UDP_ILOS 70 */
+        0x00, 0x0a, 0x01, 0x6e,
+
+        0x00, 0x00,
+};
+
+static const struct ice_dummy_pkt_offsets dummy_gre_rfc1701_c0k1_tcp_packet_offsets[] = {
+        { ICE_MAC_OFOS,         0 },
+        { ICE_ETYPE_OL,         12 },
+        { ICE_IPV4_OFOS,        14 },
+        { ICE_GRE,              34 },
+        { ICE_IPV4_IL,          46 },
+        { ICE_TCP_IL,           66 },
+        { ICE_PROTOCOL_LAST,    0 },
+};
+
+static const u8 dummy_gre_rfc1701_c0k1_tcp_packet[] = {
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x45, 0x00,
+        0x00, 0x4a, 0x00, 0x01, 0x00, 0x00, 0x40, 0x2f,
+        0x7c, 0x82, 0x7f, 0x00, 0x00, 0x01, 0x7f, 0x00,
+        0x00, 0x01, 0x30, 0x00, 0x08, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x45, 0x00,
+        0x00, 0x2a, 0x00, 0x01, 0x00, 0x00, 0x40, 0x06,
+        0x7c, 0xcb, 0x7f, 0x00, 0x00, 0x01, 0x7f, 0x00,
+        0x00, 0x01, 0x00, 0x14, 0x00, 0x50, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x02,
+        0x20, 0x00, 0x91, 0x7a, 0x00, 0x00, 0x00, 0x00,
+};
+
+static const struct ice_dummy_pkt_offsets dummy_gre_rfc1701_c0k1_udp_packet_offsets[] = {
+        { ICE_MAC_OFOS,         0 },
+        { ICE_ETYPE_OL,         12 },
+        { ICE_IPV4_OFOS,        14 },
+        { ICE_GRE,              34 },
+        { ICE_IPV4_IL,          46 },
+        { ICE_UDP_ILOS,         66 },
+        { ICE_PROTOCOL_LAST,    0 },
+};
+
+static const u8 dummy_gre_rfc1701_c0k1_udp_packet[] = {
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x45, 0x00,
+        0x00, 0x3e, 0x00, 0x01, 0x00, 0x00, 0x40, 0x2f,
+        0x7c, 0x8e, 0x7f, 0x00, 0x00, 0x01, 0x7f, 0x00,
+        0x00, 0x01, 0x30, 0x00, 0x08, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x45, 0x00,
+        0x00, 0x1e, 0x00, 0x01, 0x00, 0x00, 0x40, 0x11,
+        0x7c, 0xcc, 0x7f, 0x00, 0x00, 0x01, 0x7f, 0x00,
+        0x00, 0x01, 0x00, 0x35, 0x00, 0x35, 0x00, 0x0a,
+        0x01, 0x6e, 0x00, 0x00,
+};
+
+static const struct ice_dummy_pkt_offsets dummy_gre_rfc1701_c0k0_tcp_packet_offsets[] = {
+        { ICE_MAC_OFOS,         0 },
+        { ICE_ETYPE_OL,         12 },
+        { ICE_IPV4_OFOS,        14 },
+        { ICE_GRE,              34 },
+        { ICE_IPV4_IL,          42 },
+        { ICE_TCP_IL,           62 },
+        { ICE_PROTOCOL_LAST,    0 },
+};
+
+static const u8 dummy_gre_rfc1701_c0k0_tcp_packet[] = {
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x45, 0x00,
+        0x00, 0x46, 0x00, 0x01, 0x00, 0x00, 0x40, 0x2f,
+        0x7c, 0x86, 0x7f, 0x00, 0x00, 0x01, 0x7f, 0x00,
+        0x00, 0x01, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x45, 0x00, 0x00, 0x2a, 0x00, 0x01,
+        0x00, 0x00, 0x40, 0x06, 0x7c, 0xcb, 0x7f, 0x00,
+        0x00, 0x01, 0x7f, 0x00, 0x00, 0x01, 0x00, 0x14,
+        0x00, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x50, 0x02, 0x20, 0x00, 0x91, 0x7a,
+        0x00, 0x00, 0x00, 0x00,
+};
+
+static const struct ice_dummy_pkt_offsets dummy_gre_rfc1701_c0k0_udp_packet_offsets[] = {
+        { ICE_MAC_OFOS,         0 },
+        { ICE_ETYPE_OL,         12 },
+        { ICE_IPV4_OFOS,        14 },
+        { ICE_GRE,              34 },
+        { ICE_IPV4_IL,          42 },
+        { ICE_UDP_ILOS,         62 },
+        { ICE_PROTOCOL_LAST,    0 },
+};
+
+static const u8 dummy_gre_rfc1701_c0k0_udp_packet[] = {
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x45, 0x00,
+        0x00, 0x3a, 0x00, 0x01, 0x00, 0x00, 0x40, 0x2f,
+        0x7c, 0x92, 0x7f, 0x00, 0x00, 0x01, 0x7f, 0x00,
+        0x00, 0x01, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x45, 0x00, 0x00, 0x1e, 0x00, 0x01,
+        0x00, 0x00, 0x40, 0x11, 0x7c, 0xcc, 0x7f, 0x00,
+        0x00, 0x01, 0x7f, 0x00, 0x00, 0x01, 0x00, 0x35,
+        0x00, 0x35, 0x00, 0x0a, 0x01, 0x6e, 0x00, 0x00,
+};
+
 static const struct ice_dummy_pkt_offsets dummy_udp_tun_tcp_packet_offsets[] = {
 	{ ICE_MAC_OFOS,		0 },
 	{ ICE_ETYPE_OL,		12 },
@@ -6043,6 +6248,7 @@ enum ice_status
 	{ ICE_GENEVE,		{ 8, 10, 12, 14 } },
 	{ ICE_VXLAN_GPE,	{ 8, 10, 12, 14 } },
 	{ ICE_NVGRE,		{ 0, 2, 4, 6 } },
+        { ICE_GRE,              { 0, 2, 4, 6, 8, 10, 12, 14 } },
 	{ ICE_GTP,		{ 8, 10, 12, 14, 16, 18, 20 } },
 	{ ICE_PPPOE,		{ 0, 2, 4, 6 } },
 	{ ICE_PFCP,		{ 8, 10, 12, 14, 16, 18, 20, 22 } },
@@ -6077,6 +6283,7 @@ enum ice_status
 	{ ICE_GENEVE,		ICE_UDP_OF_HW },
 	{ ICE_VXLAN_GPE,	ICE_UDP_OF_HW },
 	{ ICE_NVGRE,		ICE_GRE_OF_HW },
+        { ICE_GRE,              ICE_GRE_OF_HW },
 	{ ICE_GTP,		ICE_UDP_OF_HW },
 	{ ICE_PPPOE,		ICE_PPPOE_HW },
 	{ ICE_PFCP,		ICE_UDP_ILOS_HW },
@@ -6088,6 +6295,47 @@ enum ice_status
 	{ ICE_VLAN_EX,		ICE_VLAN_OF_HW },
 };
 
+static u16 buildin_recipe_get(struct ice_switch_info *sw,
+                              struct ice_prot_lkup_ext *lkup_exts)
+{
+        int i;
+
+        if (!sw->buildin_recipes)
+                return ICE_MAX_NUM_RECIPES;
+
+        for (i = 10; i < ICE_MAX_NUM_RECIPES; i++) {
+                struct ice_sw_recipe *recp = &sw->buildin_recipes[i];
+                struct ice_fv_word *a = lkup_exts->fv_words;
+                struct ice_fv_word *b = recp->lkup_exts.fv_words;
+                u16 *c = recp->lkup_exts.field_mask;
+                u16 *d = lkup_exts->field_mask;
+                bool found = true;
+                u8 p, q;
+
+                if (!recp->is_root)
+                        continue;
+
+                if (recp->lkup_exts.n_val_words != lkup_exts->n_val_words)
+                        continue;
+
+                for (p = 0; p < lkup_exts->n_val_words; p++) {
+                        for (q = 0; q < recp->lkup_exts.n_val_words; q++) {
+                                if (a[p].off == b[q].off &&
+                                    a[p].prot_id == b[q].prot_id &&
+                                    d[p] == c[q])
+                                        break;
+                        }
+                        if (q >= recp->lkup_exts.n_val_words) {
+                                found = false;
+                                break;
+                        }
+                }
+                if (found)
+                        return i;
+        }
+        return ICE_MAX_NUM_RECIPES;
+}
+
 /**
  * ice_find_recp - find a recipe
  * @hw: pointer to the hardware structure
@@ -6100,8 +6348,15 @@ static u16 ice_find_recp(struct ice_hw *hw, struct ice_prot_lkup_ext *lkup_exts,
 {
 	bool refresh_required = true;
 	struct ice_sw_recipe *recp;
+        u16 buildin_rid;
 	u8 i;
 
+        if (hw->use_buildin_recipe) {
+                buildin_rid = buildin_recipe_get(hw->switch_info, lkup_exts);
+                if (buildin_rid < ICE_MAX_NUM_RECIPES)
+                        return buildin_rid;
+        }
+
 	/* Walk through existing recipes to find a match */
 	recp = hw->switch_info->recp_list;
 	for (i = 0; i < ICE_MAX_NUM_RECIPES; i++) {
@@ -6196,6 +6451,7 @@ static bool ice_prot_type_to_id(enum ice_protocol_type type, u8 *id)
 		     struct ice_prot_lkup_ext *lkup_exts)
 {
 	u8 j, word, prot_id, ret_val;
+        u8 extra_byte = 0;
 
 	if (!ice_prot_type_to_id(rule->type, &prot_id))
 		return 0;
@@ -6208,8 +6464,16 @@ static bool ice_prot_type_to_id(enum ice_protocol_type type, u8 *id)
 			/* No more space to accommodate */
 			if (word >= ICE_MAX_CHAIN_WORDS)
 				return 0;
+                        if (rule->type == ICE_GRE) {
+                                if (ice_prot_ext[rule->type].offs[j] == 0) {
+                                        if (((u16 *)&rule->h_u)[j] == 0x20) {
+                                                extra_byte = 4;
+                                        }
+                                        continue;
+                                }
+                        }
 			lkup_exts->fv_words[word].off =
-				ice_prot_ext[rule->type].offs[j];
+				ice_prot_ext[rule->type].offs[j] - extra_byte;
 			lkup_exts->fv_words[word].prot_id =
 				ice_prot_id_tbl[rule->type].protocol_id;
 			lkup_exts->field_mask[word] =
@@ -6753,10 +7017,11 @@ static bool ice_prot_type_to_id(enum ice_protocol_type type, u8 *id)
  * @lkups_cnt: number of protocols
  * @bm: bitmap of field vectors to consider
  * @fv_list: pointer to a list that holds the returned field vectors
+ * @lkup_exts: lookup elements
  */
 static enum ice_status
 ice_get_fv(struct ice_hw *hw, struct ice_adv_lkup_elem *lkups, u16 lkups_cnt,
-	   ice_bitmap_t *bm, struct LIST_HEAD_TYPE *fv_list)
+ice_bitmap_t *bm, struct LIST_HEAD_TYPE *fv_list, struct ice_prot_lkup_ext *lkup_exts)
 {
 	enum ice_status status;
 	u8 *prot_ids;
@@ -6776,7 +7041,7 @@ static bool ice_prot_type_to_id(enum ice_protocol_type type, u8 *id)
 		}
 
 	/* Find field vectors that include all specified protocol types */
-	status = ice_get_sw_fv_list(hw, prot_ids, lkups_cnt, bm, fv_list);
+        status = ice_get_sw_fv_list(hw, prot_ids, lkups_cnt, bm, fv_list, lkup_exts);
 
 free_mem:
 	ice_free(hw, prot_ids);
@@ -6806,6 +7071,10 @@ static bool ice_tun_type_match_word(enum ice_sw_tunnel_type tun_type, u16 *mask)
 		*mask = ICE_TUN_FLAG_MASK;
 		return true;
 
+        case ICE_SW_TUN_GRE:
+                *mask = ICE_GRE_FLAG_MASK;
+                return true;
+
 	case ICE_SW_TUN_GENEVE_VLAN:
 	case ICE_SW_TUN_VXLAN_VLAN:
 		*mask = ICE_TUN_FLAG_MASK & ~ICE_TUN_FLAG_VLAN_MASK;
@@ -6826,7 +7095,15 @@ static bool ice_tun_type_match_word(enum ice_sw_tunnel_type tun_type, u16 *mask)
 ice_add_special_words(struct ice_adv_rule_info *rinfo,
 		      struct ice_prot_lkup_ext *lkup_exts)
 {
+        u8 has_gre_key = 0;
 	u16 mask;
+        u8 i;
+
+        for (i = 0; i < lkup_exts->n_val_words; i++) {
+                if (lkup_exts->fv_words[i].prot_id == 0x40) {
+                        has_gre_key = 1;
+                }
+        }
 
 	/* If this is a tunneled packet, then add recipe index to match the
 	 * tunnel bit in the packet metadata flags.
@@ -6838,6 +7115,12 @@ static bool ice_tun_type_match_word(enum ice_sw_tunnel_type tun_type, u16 *mask)
 			lkup_exts->fv_words[word].prot_id = ICE_META_DATA_ID_HW;
 			lkup_exts->fv_words[word].off = ICE_TUN_FLAG_MDID_OFF;
 			lkup_exts->field_mask[word] = mask;
+
+                        if (rinfo->tun_type == ICE_SW_TUN_GRE)
+                                lkup_exts->fv_words[word].off = ICE_GRE_FLAG_MDID_OFF;
+
+                        if (!has_gre_key)
+                                lkup_exts->field_mask[word] = 0x0140;
 		} else {
 			return ICE_ERR_MAX_LIMIT;
 		}
@@ -6879,6 +7162,9 @@ static bool ice_tun_type_match_word(enum ice_sw_tunnel_type tun_type, u16 *mask)
 	case ICE_SW_TUN_NVGRE:
 		prof_type = ICE_PROF_TUN_GRE;
 		break;
+        case ICE_SW_TUN_GRE:
+                prof_type = ICE_PROF_TUN_GRE;
+                break;
 	case ICE_SW_TUN_PPPOE:
 	case ICE_SW_TUN_PPPOE_QINQ:
 		prof_type = ICE_PROF_TUN_PPPOE;
@@ -7099,7 +7385,7 @@ bool ice_is_prof_rule(enum ice_sw_tunnel_type type)
 	 */
 	ice_get_compat_fv_bitmap(hw, rinfo, fv_bitmap);
 
-	status = ice_get_fv(hw, lkups, lkups_cnt, fv_bitmap, &rm->fv_list);
+	status = ice_get_fv(hw, lkups, lkups_cnt, fv_bitmap, &rm->fv_list, lkup_exts);
 	if (status)
 		goto err_unroll;
 
@@ -7248,6 +7534,8 @@ bool ice_is_prof_rule(enum ice_sw_tunnel_type type)
 		      const struct ice_dummy_pkt_offsets **offsets)
 {
 	bool tcp = false, udp = false, ipv6 = false, vlan = false;
+        bool gre_c_bit = false;
+        bool gre_k_bit = false;
 	bool gre = false;
 	u16 i;
 
@@ -7256,10 +7544,26 @@ bool ice_is_prof_rule(enum ice_sw_tunnel_type type)
 			udp = true;
 		else if (lkups[i].type == ICE_TCP_IL)
 			tcp = true;
-		else if (lkups[i].type == ICE_IPV6_OFOS)
+                else if (lkups[i].type == ICE_IPV6_OFOS) {
 			ipv6 = true;
+                        if (lkups[i].h_u.ipv6_hdr.next_hdr == ICE_IPV6_GRE_PROTO_ID &&
+                            lkups[i].m_u.ipv6_hdr.next_hdr == 0xFF)
+                                gre = true;
+                }
 		else if (lkups[i].type == ICE_VLAN_OFOS)
 			vlan = true;
+                else if (lkups[i].type == ICE_GRE) {
+                        if (lkups[i].h_u.gre_hdr.flags & 0x20)
+                                gre_k_bit = true;
+                        if (lkups[i].h_u.gre_hdr.flags & 0x80)
+                                gre_c_bit = true;
+                }
+                else if (lkups[i].type == ICE_IPV4_OFOS &&
+                         lkups[i].h_u.ipv4_hdr.protocol ==
+                                ICE_IPV4_GRE_PROTO_ID &&
+                         lkups[i].m_u.ipv4_hdr.protocol ==
+                                0xFF)
+                        gre = true;
 		else if (lkups[i].type == ICE_IPV4_OFOS &&
 			 lkups[i].h_u.ipv4_hdr.protocol ==
 				ICE_IPV4_NVGRE_PROTO_ID &&
@@ -7469,6 +7773,12 @@ bool ice_is_prof_rule(enum ice_sw_tunnel_type type)
 	}
 
 	if (tun_type == ICE_SW_IPV4_TCP) {
+                if (vlan && tcp) {
+                        *pkt = dummy_vlan_tcp_packet;
+                        *pkt_len = sizeof(dummy_vlan_tcp_packet);
+                        *offsets = dummy_vlan_tcp_packet_offsets;
+                        return;
+                }
 		*pkt = dummy_tcp_packet;
 		*pkt_len = sizeof(dummy_tcp_packet);
 		*offsets = dummy_tcp_packet_offsets;
@@ -7476,6 +7786,12 @@ bool ice_is_prof_rule(enum ice_sw_tunnel_type type)
 	}
 
 	if (tun_type == ICE_SW_IPV4_UDP) {
+                if (vlan && udp) {
+                        *pkt = dummy_vlan_udp_packet;
+                        *pkt_len = sizeof(dummy_vlan_udp_packet);
+                        *offsets = dummy_vlan_udp_packet_offsets;
+                        return;
+                }
 		*pkt = dummy_udp_packet;
 		*pkt_len = sizeof(dummy_udp_packet);
 		*offsets = dummy_udp_packet_offsets;
@@ -7503,6 +7819,13 @@ bool ice_is_prof_rule(enum ice_sw_tunnel_type type)
 		return;
 	}
 
+       if (ipv6 && gre) {
+               *pkt = dummy_ipv6_gre_udp_packet;
+               *pkt_len = sizeof(dummy_ipv6_gre_udp_packet);
+               *offsets = dummy_ipv6_gre_udp_packet_offsets;
+               return;
+        }
+
 	if (tun_type == ICE_SW_TUN_NVGRE || gre) {
 		if (tcp) {
 			*pkt = dummy_gre_tcp_packet;
@@ -7517,6 +7840,46 @@ bool ice_is_prof_rule(enum ice_sw_tunnel_type type)
 		return;
 	}
 
+        if (tun_type == ICE_SW_TUN_GRE || gre) {
+                if (tcp) {
+                        if (gre_c_bit && gre_k_bit) {
+                                *pkt = dummy_gre_rfc1701_c1k1_tcp_packet;
+                                *pkt_len = sizeof(dummy_gre_rfc1701_c1k1_tcp_packet);
+                                *offsets = dummy_gre_rfc1701_c1k1_tcp_packet_offsets;
+                                return;
+                        }
+                        if (!gre_c_bit && gre_k_bit) {
+                                *pkt = dummy_gre_rfc1701_c0k1_tcp_packet;
+                                *pkt_len = sizeof(dummy_gre_rfc1701_c0k1_tcp_packet);
+                                *offsets = dummy_gre_rfc1701_c0k1_tcp_packet_offsets;
+                                return;
+                        }
+
+                        *pkt = dummy_gre_rfc1701_c0k0_tcp_packet;
+                        *pkt_len = sizeof(dummy_gre_rfc1701_c0k0_tcp_packet);
+                        *offsets = dummy_gre_rfc1701_c0k0_tcp_packet_offsets;
+                        return;
+                }
+
+                if (gre_c_bit && gre_k_bit) {
+                        *pkt = dummy_gre_rfc1701_c1k1_udp_packet;
+                        *pkt_len = sizeof(dummy_gre_rfc1701_c1k1_udp_packet);
+                        *offsets = dummy_gre_rfc1701_c1k1_udp_packet_offsets;
+                        return;
+                }
+                if (!gre_c_bit && gre_k_bit) {
+                        *pkt = dummy_gre_rfc1701_c0k1_udp_packet;
+                        *pkt_len = sizeof(dummy_gre_rfc1701_c0k1_udp_packet);
+                        *offsets = dummy_gre_rfc1701_c0k1_udp_packet_offsets;
+                        return;
+                }
+
+                *pkt = dummy_gre_rfc1701_c0k0_udp_packet;
+                *pkt_len = sizeof(dummy_gre_rfc1701_c0k0_udp_packet);
+                *offsets = dummy_gre_rfc1701_c0k0_udp_packet_offsets;
+                return;
+        }
+
 	if (tun_type == ICE_SW_TUN_VXLAN || tun_type == ICE_SW_TUN_GENEVE ||
 	    tun_type == ICE_SW_TUN_VXLAN_GPE || tun_type == ICE_SW_TUN_UDP ||
 	    tun_type == ICE_SW_TUN_GENEVE_VLAN ||
@@ -7658,6 +8021,9 @@ bool ice_is_prof_rule(enum ice_sw_tunnel_type type)
 		case ICE_NVGRE:
 			len = sizeof(struct ice_nvgre);
 			break;
+                case ICE_GRE:
+                        len = sizeof(struct ice_gre);
+                        break;
 		case ICE_VXLAN:
 		case ICE_GENEVE:
 		case ICE_VXLAN_GPE:
@@ -7691,6 +8057,20 @@ bool ice_is_prof_rule(enum ice_sw_tunnel_type type)
 		if (len % ICE_BYTES_PER_WORD)
 			return ICE_ERR_CFG;
 
+                if (lkups[i].type == ICE_GRE) {
+                        if (lkups[i].h_u.gre_hdr.flags == 0x20) {
+                                offset -= 4;
+                        }
+                        for (j = 1; j < len / sizeof(u16); j++)
+                                if (((u16 *)&lkups[i].m_u)[j])
+                                        ((u16 *)(pkt + offset))[j] =
+                                                (((u16 *)(pkt + offset))[j] &
+                                                 ~((u16 *)&lkups[i].m_u)[j]) |
+                                                (((u16 *)&lkups[i].h_u)[j] &
+                                                 ((u16 *)&lkups[i].m_u)[j]);
+                        continue;
+                }
+
 		/* We have the offset to the header start, the length, the
 		 * caller's header values and mask. Use this information to
 		 * copy the data into the dummy packet appropriately based on
@@ -8267,8 +8647,11 @@ enum ice_status
 			return ICE_ERR_CFG;
 
 		count = ice_fill_valid_words(&lkups[i], &lkup_exts);
-		if (!count)
-			return ICE_ERR_CFG;
+                if (!count) {
+                        if (lkups[i].type == ICE_GRE)
+                                continue;
+                        return ICE_ERR_CFG;
+                }
 	}
 
 	/* Create any special protocol/offset pairs, such as looking at tunnel
@@ -8357,6 +8740,7 @@ enum ice_status
 	struct ice_switch_info *sw;
 
 	sw = hw->switch_info;
+        if (!sw->buildin_recipes[remove_entry->rid].is_root)
 	if (!sw->recp_list[remove_entry->rid].recp_created)
 		return ICE_ERR_PARAM;
 	list_head = &sw->recp_list[remove_entry->rid].filt_rules;
diff --git a/drivers/net/ice/base/ice_type.h b/drivers/net/ice/base/ice_type.h
index 6b8d44f..d364066 100644
--- a/drivers/net/ice/base/ice_type.h
+++ b/drivers/net/ice/base/ice_type.h
@@ -838,6 +838,7 @@ struct ice_switch_info {
 	u16 max_used_prof_index;
 
 	ice_declare_bitmap(prof_res_bm[ICE_MAX_NUM_PROFILES], ICE_MAX_FV_WORDS);
+        struct ice_sw_recipe *buildin_recipes;
 };
 
 /* Port hardware description */
@@ -985,6 +986,7 @@ struct ice_hw {
 	ice_declare_bitmap(fdir_perfect_fltr, ICE_FLTR_PTYPE_MAX);
 	struct ice_lock rss_locks;	/* protect RSS configuration */
 	struct LIST_HEAD_TYPE rss_list_head;
+        u8 use_buildin_recipe;
 };
 
 /* Statistics collected by each port, VSI, VEB, and S-channel */
diff --git a/drivers/net/ice/ice_acl_filter.c b/drivers/net/ice/ice_acl_filter.c
index f7dbe53..2658515 100644
--- a/drivers/net/ice/ice_acl_filter.c
+++ b/drivers/net/ice/ice_acl_filter.c
@@ -25,6 +25,7 @@
 #include "ice_ethdev.h"
 #include "ice_generic_flow.h"
 #include "base/ice_flow.h"
+#include "ice_dcf_ethdev.h"
 
 #define MAX_ACL_SLOTS_ID 2048
 
@@ -978,8 +979,11 @@ static void ice_deinit_acl(struct ice_pf *pf)
 	struct ice_pf *pf = &ad->pf;
 	struct ice_hw *hw = ICE_PF_TO_HW(pf);
 	struct ice_flow_parser *parser = &ice_acl_parser;
+        struct rte_eth_dev *eth_dev = ad->eth_dev;
+        struct ice_dcf_adapter *dcf_adapter = eth_dev->data->dev_private;
+        struct ice_dcf_hw *dcf_hw = &dcf_adapter->real_hw;
 
-	if (!ad->hw.dcf_enabled)
+        if (!ad->hw.dcf_enabled || dcf_hw->multi_inst)
 		return 0;
 
 	ret = ice_acl_prof_alloc(hw);
@@ -1025,8 +1029,11 @@ static void ice_deinit_acl(struct ice_pf *pf)
 	struct ice_pf *pf = &ad->pf;
 	struct ice_hw *hw = ICE_PF_TO_HW(pf);
 	struct ice_flow_parser *parser = &ice_acl_parser;
+        struct rte_eth_dev *eth_dev = ad->eth_dev;
+        struct ice_dcf_adapter *dcf_adapter = eth_dev->data->dev_private;
+        struct ice_dcf_hw *dcf_hw = &dcf_adapter->real_hw;
 
-	if (ad->hw.dcf_enabled) {
+        if (ad->hw.dcf_enabled && !dcf_hw->multi_inst) {
 		ice_unregister_parser(parser, ad);
 		ice_deinit_acl(pf);
 		ice_acl_prof_free(hw);
diff --git a/drivers/net/ice/ice_dcf.c b/drivers/net/ice/ice_dcf.c
index 44dbd3b..d4b1bb9 100644
--- a/drivers/net/ice/ice_dcf.c
+++ b/drivers/net/ice/ice_dcf.c
@@ -642,7 +642,8 @@
 
 	if (ice_dcf_get_vf_vsi_map(hw) < 0) {
 		PMD_INIT_LOG(ERR, "Failed to get VF VSI map");
-		ice_dcf_mode_disable(hw);
+                if (!hw->multi_inst)
+		        ice_dcf_mode_disable(hw);
 		goto err_alloc;
 	}
 
@@ -700,8 +701,8 @@
 	rte_intr_disable(intr_handle);
 	rte_intr_callback_unregister(intr_handle,
 				     ice_dcf_dev_interrupt_handler, hw);
-
-	ice_dcf_mode_disable(hw);
+        if (!hw->multi_inst)
+	        ice_dcf_mode_disable(hw);
 	iavf_shutdown_adminq(&hw->avf);
 
 	rte_free(hw->arq_buf);
@@ -1079,3 +1080,19 @@
 	rte_free(list);
 	return err;
 }
+
+int
+ice_dcf_flush_rules(struct ice_dcf_hw *hw)
+{
+        struct dcf_virtchnl_cmd args;
+        int err = 0;
+
+        memset(&args, 0, sizeof(args));
+        args.v_op = VIRTCHNL_OP_DCF_RULE_FLUSH;
+
+        err = ice_dcf_execute_virtchnl_cmd(hw, &args);
+        if (err)
+                PMD_DRV_LOG(WARNING, "fail to execute command OF_DCF_RULE_FLUSH, DCF role must be preempted.");
+
+        return 0;
+}
diff --git a/drivers/net/ice/ice_dcf.h b/drivers/net/ice/ice_dcf.h
index ff02996..bebbc88 100644
--- a/drivers/net/ice/ice_dcf.h
+++ b/drivers/net/ice/ice_dcf.h
@@ -51,6 +51,8 @@ struct ice_dcf_hw {
 	uint16_t vsi_id;
 
 	struct rte_eth_dev *eth_dev;
+        bool multi_inst;
+        bool dcf_replaced;
 	uint8_t *rss_lut;
 	uint8_t *rss_key;
 	uint64_t supported_rxdid;
@@ -77,5 +79,6 @@ int ice_dcf_send_aq_cmd(void *dcf_hw, struct ice_aq_desc *desc,
 int ice_dcf_query_stats(struct ice_dcf_hw *hw,
 			struct virtchnl_eth_stats *pstats);
 int ice_dcf_add_del_all_mac_addr(struct ice_dcf_hw *hw, bool add);
+int ice_dcf_flush_rules(struct ice_dcf_hw *hw);
 
 #endif /* _ICE_DCF_H_ */
diff --git a/drivers/net/ice/ice_dcf_ethdev.c b/drivers/net/ice/ice_dcf_ethdev.c
index b983d84..dd835fe 100644
--- a/drivers/net/ice/ice_dcf_ethdev.c
+++ b/drivers/net/ice/ice_dcf_ethdev.c
@@ -19,6 +19,7 @@
 #include <rte_malloc.h>
 #include <rte_memzone.h>
 #include <rte_dev.h>
+#include <rte_ethdev.h>
 
 #include <iavf_devids.h>
 
@@ -26,6 +27,13 @@
 #include "ice_dcf_ethdev.h"
 #include "ice_rxtx.h"
 
+static int
+ice_dcf_dev_udp_tunnel_port_add(struct rte_eth_dev *dev,
+                               struct rte_eth_udp_tunnel *udp_tunnel);
+static int
+ice_dcf_dev_udp_tunnel_port_del(struct rte_eth_dev *dev,
+                               struct rte_eth_udp_tunnel *udp_tunnel);
+
 static uint16_t
 ice_dcf_recv_pkts(__rte_unused void *rx_queue,
 		  __rte_unused struct rte_mbuf **bufs,
@@ -866,6 +874,64 @@
 	return 0;
 }
 
+/* Add UDP tunneling port */
+static int
+ice_dcf_dev_udp_tunnel_port_add(struct rte_eth_dev *dev,
+                                struct rte_eth_udp_tunnel *udp_tunnel)
+{
+        struct ice_dcf_adapter *adapter = dev->data->dev_private;
+        struct ice_adapter *parent_adapter = &adapter->parent;
+        struct ice_hw *parent_hw = &parent_adapter->hw;
+        int ret = 0;
+
+        if (!udp_tunnel)
+                return -EINVAL;
+
+        switch (udp_tunnel->prot_type) {
+        case RTE_TUNNEL_TYPE_VXLAN:
+                ret = ice_create_tunnel(parent_hw, TNL_VXLAN,
+                                        udp_tunnel->udp_port);
+                break;
+        case RTE_TUNNEL_TYPE_ECPRI:
+                ret = ice_create_tunnel(parent_hw, TNL_ECPRI,
+                                        udp_tunnel->udp_port);
+                break;
+        default:
+                PMD_DRV_LOG(ERR, "Invalid tunnel type");
+                ret = -EINVAL;
+                break;
+        }
+
+        return ret;
+}
+
+/* Delete UDP tunneling port */
+static int
+ice_dcf_dev_udp_tunnel_port_del(struct rte_eth_dev *dev,
+                                struct rte_eth_udp_tunnel *udp_tunnel)
+{
+        struct ice_dcf_adapter *adapter = dev->data->dev_private;
+        struct ice_adapter *parent_adapter = &adapter->parent;
+        struct ice_hw *parent_hw = &parent_adapter->hw;
+        int ret = 0;
+
+        if (!udp_tunnel)
+                return -EINVAL;
+
+        switch (udp_tunnel->prot_type) {
+        case RTE_TUNNEL_TYPE_VXLAN:
+        case RTE_TUNNEL_TYPE_ECPRI:
+                ret = ice_destroy_tunnel(parent_hw, udp_tunnel->udp_port, 0);
+                break;
+        default:
+                PMD_DRV_LOG(ERR, "Invalid tunnel type");
+                ret = -EINVAL;
+                break;
+        }
+
+        return ret;
+}
+
 static const struct eth_dev_ops ice_dcf_eth_dev_ops = {
 	.dev_start               = ice_dcf_dev_start,
 	.dev_stop                = ice_dcf_dev_stop,
@@ -888,91 +954,139 @@
 	.allmulticast_enable     = ice_dcf_dev_allmulticast_enable,
 	.allmulticast_disable    = ice_dcf_dev_allmulticast_disable,
 	.filter_ctrl             = ice_dcf_dev_filter_ctrl,
+        .udp_tunnel_port_add     = ice_dcf_dev_udp_tunnel_port_add,
+        .udp_tunnel_port_del     = ice_dcf_dev_udp_tunnel_port_del,
 };
 
 static int
-ice_dcf_dev_init(struct rte_eth_dev *eth_dev)
+ice_dcf_cap_check_handler(__rte_unused const char *key,
+                          const char *value, void *opaque)
 {
-	struct ice_dcf_adapter *adapter = eth_dev->data->dev_private;
+        bool *mi = opaque;
+
+        if (!strcmp(value, "dcf")) {
+                *mi = 0;
+                return 0;
+        }
+        if (!strcmp(value, "mdcf")) {
+                *mi = 1;
+        return 0;
+        }
+
+        return -1;
+}
 
-	eth_dev->dev_ops = &ice_dcf_eth_dev_ops;
-	eth_dev->rx_pkt_burst = ice_dcf_recv_pkts;
-	eth_dev->tx_pkt_burst = ice_dcf_xmit_pkts;
+static int
+parse_bool(const char *key, const char *value, void *args)
+{
+        int *i = (int *)args;
+        char *end;
+        int num;
 
-	if (rte_eal_process_type() != RTE_PROC_PRIMARY)
-		return 0;
+        num = strtoul(value, &end, 10);
 
-	adapter->real_hw.vc_event_msg_cb = ice_dcf_handle_pf_event_msg;
-	if (ice_dcf_init_hw(eth_dev, &adapter->real_hw) != 0) {
-		PMD_INIT_LOG(ERR, "Failed to init DCF hardware");
-		return -1;
-	}
+        if (num != 0 && num != 1) {
+                PMD_DRV_LOG(WARNING, "invalid value:\"%s\" for key:\"%s\", "
+                            "value must be 0 or 1",
+                            value, key);
+                return -1;
+        }
 
-	if (ice_dcf_init_parent_adapter(eth_dev) != 0) {
-		PMD_INIT_LOG(ERR, "Failed to init DCF parent adapter");
-		ice_dcf_uninit_hw(eth_dev, &adapter->real_hw);
-		return -1;
-	}
-
-	return 0;
+        *i = num;
+        return 0;
 }
 
 static int
-ice_dcf_dev_uninit(struct rte_eth_dev *eth_dev)
+ice_dcf_cap_selected(struct ice_dcf_adapter *adapter,
+                      struct rte_devargs *devargs)
 {
-	ice_dcf_dev_close(eth_dev);
+        struct ice_adapter *ad = &adapter->parent;
+        struct rte_kvargs *kvlist;
+        const char *key_cap = "cap";
+        const char *key_br = "br";
+        int ret = 0;
 
-	return 0;
-}
+        if (devargs == NULL)
+                return 0;
 
-static int
-ice_dcf_cap_check_handler(__rte_unused const char *key,
-			  const char *value, __rte_unused void *opaque)
-{
-	if (strcmp(value, "dcf"))
-		return -1;
+        kvlist = rte_kvargs_parse(devargs->args, NULL);
+        if (kvlist == NULL)
+                return 0;
 
-	return 0;
+        if (!rte_kvargs_count(kvlist, key_cap))
+                goto exit;
+
+        /* dcf capability selected when there's a key-value pair: cap=dcf */
+        if (rte_kvargs_process(kvlist, key_cap,
+                               ice_dcf_cap_check_handler,
+                               &adapter->real_hw.multi_inst) < 0)
+                goto exit;
+
+        /* dcf capability selected when there's a key-value pair: cap=dcf */
+        if (rte_kvargs_process(kvlist, key_br,
+                               &parse_bool,
+                               &ad->hw.use_buildin_recipe) < 0)
+                goto exit;
+
+        ret = 1;
+
+exit:
+        rte_kvargs_free(kvlist);
+        return ret;
 }
 
+/**
+ * Queue xstats filled automatically by ethdev layer.
+ * PMDs filling the queue xstats themselves should not set this flag
+ */
+#define RTE_ETH_DEV_AUTOFILL_QUEUE_XSTATS 0x0040
 static int
-ice_dcf_cap_selected(struct rte_devargs *devargs)
+ice_dcf_dev_init(struct rte_eth_dev *eth_dev)
 {
-	struct rte_kvargs *kvlist;
-	const char *key = "cap";
-	int ret = 0;
+        struct rte_pci_device *pci_dev = RTE_DEV_TO_PCI(eth_dev->device);
+        struct ice_dcf_adapter *adapter = eth_dev->data->dev_private;
 
-	if (devargs == NULL)
-		return 0;
+        if (!ice_dcf_cap_selected(adapter, pci_dev->device.devargs))
+                return 1;
 
-	kvlist = rte_kvargs_parse(devargs->args, NULL);
-	if (kvlist == NULL)
-		return 0;
+        eth_dev->dev_ops = &ice_dcf_eth_dev_ops;
+        eth_dev->rx_pkt_burst = ice_dcf_recv_pkts;
+        eth_dev->tx_pkt_burst = ice_dcf_xmit_pkts;
 
-	if (!rte_kvargs_count(kvlist, key))
-		goto exit;
+        if (rte_eal_process_type() != RTE_PROC_PRIMARY)
+                return 0;
 
-	/* dcf capability selected when there's a key-value pair: cap=dcf */
-	if (rte_kvargs_process(kvlist, key,
-			       ice_dcf_cap_check_handler, NULL) < 0)
-		goto exit;
+        eth_dev->data->dev_flags |= RTE_ETH_DEV_AUTOFILL_QUEUE_XSTATS;
 
-	ret = 1;
+        adapter->real_hw.vc_event_msg_cb = ice_dcf_handle_pf_event_msg;
+        if (ice_dcf_init_hw(eth_dev, &adapter->real_hw) != 0) {
+                PMD_INIT_LOG(ERR, "Failed to init DCF hardware");
+                return -1;
+        }
 
-exit:
-	rte_kvargs_free(kvlist);
-	return ret;
+        if (ice_dcf_init_parent_adapter(eth_dev) != 0) {
+                PMD_INIT_LOG(ERR, "Failed to init DCF parent adapter");
+                ice_dcf_uninit_hw(eth_dev, &adapter->real_hw);
+                return -1;
+        }
+
+        return 0;
+}
+
+static int
+ice_dcf_dev_uninit(struct rte_eth_dev *eth_dev)
+{
+	ice_dcf_dev_close(eth_dev);
+
+	return 0;
 }
 
 static int eth_ice_dcf_pci_probe(__rte_unused struct rte_pci_driver *pci_drv,
 			     struct rte_pci_device *pci_dev)
 {
-	if (!ice_dcf_cap_selected(pci_dev->device.devargs))
-		return 1;
-
-	return rte_eth_dev_pci_generic_probe(pci_dev,
-					     sizeof(struct ice_dcf_adapter),
-					     ice_dcf_dev_init);
+        return rte_eth_dev_pci_generic_probe(pci_dev,
+                                             sizeof(struct ice_dcf_adapter),
+                                             ice_dcf_dev_init);
 }
 
 static int eth_ice_dcf_pci_remove(struct rte_pci_device *pci_dev)
@@ -995,4 +1109,6 @@ static int eth_ice_dcf_pci_remove(struct rte_pci_device *pci_dev)
 RTE_PMD_REGISTER_PCI(net_ice_dcf, rte_ice_dcf_pmd);
 RTE_PMD_REGISTER_PCI_TABLE(net_ice_dcf, pci_id_ice_dcf_map);
 RTE_PMD_REGISTER_KMOD_DEP(net_ice_dcf, "* igb_uio | vfio-pci");
-RTE_PMD_REGISTER_PARAM_STRING(net_ice_dcf, "cap=dcf");
+RTE_PMD_REGISTER_PARAM_STRING(net_ice_dcf,
+                              "cap=dcf|mdcf "
+                              "br=<1|0>");
diff --git a/drivers/net/ice/ice_dcf_parent.c b/drivers/net/ice/ice_dcf_parent.c
index 30ead4c..fdeef7d 100644
--- a/drivers/net/ice/ice_dcf_parent.c
+++ b/drivers/net/ice/ice_dcf_parent.c
@@ -112,6 +112,9 @@
 {
 	struct ice_dcf_hw *hw = param;
 
+        if (hw->multi_inst)
+                return NULL;
+
 	usleep(ICE_DCF_VSI_UPDATE_SERVICE_INTERVAL);
 
 	rte_spinlock_lock(&vsi_update_lock);
@@ -160,6 +163,10 @@
 		pthread_create(&thread, NULL,
 			       ice_dcf_vsi_update_service_handler, dcf_hw);
 		break;
+        case VIRTCHNL_EVENT_DCF_VSI_INFO:
+                if (dcf_hw->vsi_id != pf_msg->event_data.vf_vsi_map.vsi_id)
+                        dcf_hw->dcf_replaced = true;
+                break;
 	default:
 		PMD_DRV_LOG(ERR, "Unknown event received %u", pf_msg->event);
 		break;
@@ -381,6 +388,7 @@ static void ice_dcf_uninit_parent_hw(struct ice_hw *hw)
 	parent_hw->aq_send_cmd_fn = ice_dcf_send_aq_cmd;
 	parent_hw->aq_send_cmd_param = &adapter->real_hw;
 	parent_hw->dcf_enabled = true;
+        hw->dcf_replaced = false;
 
 	err = ice_dcf_init_parent_hw(parent_hw);
 	if (err) {
diff --git a/drivers/net/ice/ice_ethdev.c b/drivers/net/ice/ice_ethdev.c
index b01f2cd..58bffe1 100644
--- a/drivers/net/ice/ice_ethdev.c
+++ b/drivers/net/ice/ice_ethdev.c
@@ -72,6 +72,7 @@ struct proto_xtr_ol_flag {
 
 #define ICE_OS_DEFAULT_PKG_NAME		"ICE OS Default Package"
 #define ICE_COMMS_PKG_NAME			"ICE COMMS Package"
+#define ICE_CUSTOM_OS_PKG_NAME             "Tencent ICE OS Package"
 #define ICE_MAX_RES_DESC_NUM        1024
 
 static int ice_dev_configure(struct rte_eth_dev *dev);
@@ -1810,6 +1811,9 @@ enum ice_pkg_type
 	else if (!strncmp((char *)hw->active_pkg_name, ICE_COMMS_PKG_NAME,
 		ICE_PKG_NAME_SIZE))
 		package_type = ICE_PKG_TYPE_COMMS;
+        if (!strncmp((char *)hw->active_pkg_name, ICE_CUSTOM_OS_PKG_NAME,
+                ICE_PKG_NAME_SIZE))
+                package_type = ICE_PKG_TYPE_OS_DEFAULT;
 	else
 		package_type = ICE_PKG_TYPE_UNKNOWN;
 
diff --git a/drivers/net/ice/ice_generic_flow.c b/drivers/net/ice/ice_generic_flow.c
index cead476..f42df9b 100644
--- a/drivers/net/ice/ice_generic_flow.c
+++ b/drivers/net/ice/ice_generic_flow.c
@@ -17,6 +17,7 @@
 
 #include "ice_ethdev.h"
 #include "ice_generic_flow.h"
+#include "ice_dcf.h"
 
 /**
  * Non-pipeline mode, fdir and switch both used as distributor,
@@ -1003,6 +1004,33 @@ enum rte_flow_item_type pattern_eth_ipv6_nvgre_eth_ipv6_icmp6[] = {
 	RTE_FLOW_ITEM_TYPE_ICMP6,
 	RTE_FLOW_ITEM_TYPE_END,
 };
+/* IPv4 GRE RAW IPv4 */
+enum rte_flow_item_type pattern_eth_ipv4_gre_raw_ipv4[] = {
+        RTE_FLOW_ITEM_TYPE_ETH,
+        RTE_FLOW_ITEM_TYPE_IPV4,
+        RTE_FLOW_ITEM_TYPE_GRE,
+        RTE_FLOW_ITEM_TYPE_RAW,
+        RTE_FLOW_ITEM_TYPE_IPV4,
+        RTE_FLOW_ITEM_TYPE_END,
+};
+enum rte_flow_item_type pattern_eth_ipv4_gre_raw_ipv4_udp[] = {
+        RTE_FLOW_ITEM_TYPE_ETH,
+        RTE_FLOW_ITEM_TYPE_IPV4,
+        RTE_FLOW_ITEM_TYPE_GRE,
+        RTE_FLOW_ITEM_TYPE_RAW,
+        RTE_FLOW_ITEM_TYPE_IPV4,
+        RTE_FLOW_ITEM_TYPE_UDP,
+        RTE_FLOW_ITEM_TYPE_END,
+};
+enum rte_flow_item_type pattern_eth_ipv4_gre_raw_ipv4_tcp[] = {
+        RTE_FLOW_ITEM_TYPE_ETH,
+        RTE_FLOW_ITEM_TYPE_IPV4,
+        RTE_FLOW_ITEM_TYPE_GRE,
+        RTE_FLOW_ITEM_TYPE_RAW,
+        RTE_FLOW_ITEM_TYPE_IPV4,
+        RTE_FLOW_ITEM_TYPE_TCP,
+        RTE_FLOW_ITEM_TYPE_END,
+};
 
 /*IPv4 GTPU (EH) */
 enum rte_flow_item_type pattern_eth_ipv4_gtpu[] = {
@@ -2286,10 +2314,16 @@ struct ice_pattern_match_item *
 		struct rte_flow_error *error)
 {
 	struct ice_pf *pf = ICE_DEV_PRIVATE_TO_PF(dev->data->dev_private);
+        struct ice_adapter *ad =
+                ICE_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private);
+        struct ice_dcf_hw *hw = ad->hw.aq_send_cmd_param;
 	struct rte_flow *p_flow;
 	void *temp;
 	int ret = 0;
 
+        if (hw->dcf_replaced)
+                return ret;
+
 	TAILQ_FOREACH_SAFE(p_flow, &pf->flow_list, node, temp) {
 		ret = ice_flow_destroy(dev, p_flow, error);
 		if (ret) {
@@ -2298,6 +2332,9 @@ struct ice_pattern_match_item *
 		}
 	}
 
+        if (ad->hw.dcf_enabled && hw->multi_inst)
+                return ice_dcf_flush_rules(ad->hw.aq_send_cmd_param);
+
 	return ret;
 }
 
diff --git a/drivers/net/ice/ice_generic_flow.h b/drivers/net/ice/ice_generic_flow.h
index 434d2f4..f212736 100644
--- a/drivers/net/ice/ice_generic_flow.h
+++ b/drivers/net/ice/ice_generic_flow.h
@@ -35,6 +35,7 @@
 #define ICE_PROT_AH                (1ULL << 24)
 #define ICE_PROT_L2TPV3OIP         (1ULL << 25)
 #define ICE_PROT_PFCP              (1ULL << 26)
+#define ICE_PROT_GRE               (1ULL << 27)
 
 /* field */
 
@@ -61,6 +62,7 @@
 #define ICE_L2TPV3OIP_SESSION_ID   (1ULL << 43)
 #define ICE_PFCP_SEID              (1ULL << 42)
 #define ICE_PFCP_S_FIELD           (1ULL << 41)
+#define ICE_RAW_PATTERN            (1ULL << 40)
 
 /* input set */
 
@@ -189,6 +191,8 @@
 	(ICE_PROT_GTPU | ICE_GTPU_TEID)
 #define ICE_INSET_GTPU_QFI \
 	(ICE_PROT_GTPU | ICE_GTPU_QFI)
+#define ICE_INSET_RAW \
+        (ICE_PROT_GRE | ICE_RAW_PATTERN)
 #define ICE_INSET_PPPOE_SESSION \
 	(ICE_PROT_PPPOE_S | ICE_PPPOE_SESSION)
 #define ICE_INSET_PPPOE_PROTO \
@@ -361,6 +365,11 @@
 extern enum rte_flow_item_type pattern_eth_ipv6_nvgre_eth_ipv6_sctp[];
 extern enum rte_flow_item_type pattern_eth_ipv6_nvgre_eth_ipv6_icmp6[];
 
+/* IPv4 GRE RAW IPv4 */
+extern enum rte_flow_item_type pattern_eth_ipv4_gre_raw_ipv4[];
+extern enum rte_flow_item_type pattern_eth_ipv4_gre_raw_ipv4_udp[];
+extern enum rte_flow_item_type pattern_eth_ipv4_gre_raw_ipv4_tcp[];
+
 /* IPv4 GTPU (EH) */
 extern enum rte_flow_item_type pattern_eth_ipv4_gtpu[];
 extern enum rte_flow_item_type pattern_eth_ipv4_gtpu_eh[];
diff --git a/drivers/net/ice/ice_switch_filter.c b/drivers/net/ice/ice_switch_filter.c
index 8cba6eb..6746179 100644
--- a/drivers/net/ice/ice_switch_filter.c
+++ b/drivers/net/ice/ice_switch_filter.c
@@ -31,12 +31,15 @@
 #define ICE_PPP_IPV4_PROTO	0x0021
 #define ICE_PPP_IPV6_PROTO	0x0057
 #define ICE_IPV4_PROTO_NVGRE	0x002F
+#define ICE_IPV6_PROTO_NVGRE    0x002F
 
 #define ICE_SW_INSET_ETHER ( \
 	ICE_INSET_DMAC | ICE_INSET_SMAC | ICE_INSET_ETHERTYPE)
 #define ICE_SW_INSET_MAC_VLAN ( \
 		ICE_INSET_DMAC | ICE_INSET_SMAC | ICE_INSET_ETHERTYPE | \
 		ICE_INSET_VLAN_OUTER)
+#define ICE_SW_INSET_MAC_VLAN_IPV4 ( \
+        ICE_SW_INSET_MAC_VLAN | ICE_SW_INSET_MAC_IPV4)
 #define ICE_SW_INSET_MAC_IPV4 ( \
 	ICE_INSET_DMAC | ICE_INSET_IPV4_DST | ICE_INSET_IPV4_SRC | \
 	ICE_INSET_IPV4_PROTO | ICE_INSET_IPV4_TTL | ICE_INSET_IPV4_TOS)
@@ -48,6 +51,10 @@
 	ICE_INSET_DMAC | ICE_INSET_IPV4_DST | ICE_INSET_IPV4_SRC | \
 	ICE_INSET_IPV4_TTL | ICE_INSET_IPV4_TOS | \
 	ICE_INSET_UDP_DST_PORT | ICE_INSET_UDP_SRC_PORT)
+#define ICE_SW_INSET_MAC_VLAN_IPV4_TCP ( \
+        ICE_SW_INSET_MAC_VLAN | ICE_SW_INSET_MAC_IPV4_TCP)
+#define ICE_SW_INSET_MAC_VLAN_IPV4_UDP ( \
+        ICE_SW_INSET_MAC_VLAN | ICE_SW_INSET_MAC_IPV4_UDP)
 #define ICE_SW_INSET_MAC_IPV6 ( \
 	ICE_INSET_DMAC | ICE_INSET_IPV6_DST | ICE_INSET_IPV6_SRC | \
 	ICE_INSET_IPV6_TC | ICE_INSET_IPV6_HOP_LIMIT | \
@@ -82,6 +89,17 @@
 	ICE_INSET_TUN_IPV4_SRC | ICE_INSET_TUN_IPV4_DST | \
 	ICE_INSET_TUN_UDP_SRC_PORT | ICE_INSET_TUN_UDP_DST_PORT | \
 	ICE_INSET_TUN_DMAC | ICE_INSET_TUN_VXLAN_VNI | ICE_INSET_IPV4_DST)
+#define ICE_SW_INSET_DIST_GRE_RAW_IPV4 ( \
+        ICE_INSET_TUN_IPV4_SRC | ICE_INSET_TUN_IPV4_DST | \
+        ICE_INSET_IPV4_DST | ICE_INSET_RAW)
+#define ICE_SW_INSET_DIST_GRE_RAW_IPV4_TCP ( \
+        ICE_INSET_TUN_IPV4_SRC | ICE_INSET_TUN_IPV4_DST | \
+        ICE_INSET_TUN_TCP_SRC_PORT | ICE_INSET_TUN_TCP_DST_PORT | \
+        ICE_INSET_IPV4_DST | ICE_INSET_RAW)
+#define ICE_SW_INSET_DIST_GRE_RAW_IPV4_UDP ( \
+        ICE_INSET_TUN_IPV4_SRC | ICE_INSET_TUN_IPV4_DST | \
+        ICE_INSET_TUN_UDP_SRC_PORT | ICE_INSET_TUN_UDP_DST_PORT | \
+        ICE_INSET_IPV4_DST | ICE_INSET_RAW)
 #define ICE_SW_INSET_PERM_TUNNEL_IPV4 ( \
 	ICE_INSET_TUN_IPV4_SRC | ICE_INSET_TUN_IPV4_DST | \
 	ICE_INSET_TUN_IPV4_PROTO | ICE_INSET_TUN_IPV4_TOS)
@@ -131,6 +149,13 @@
 	ICE_SW_INSET_MAC_IPV6 | \
 	ICE_INSET_PFCP_S_FIELD | ICE_INSET_PFCP_SEID)
 
+#define CUSTOM_GRE_KEY_OFFSET 4
+#define CUSTOM_GRE_RAW_KEY_LEN 2*CUSTOM_GRE_KEY_OFFSET
+
+#define GRE_CFLAG (0x80)
+#define GRE_KFLAG (0x20)
+#define GRE_SFLAG (0x10)
+
 struct sw_meta {
 	struct ice_adv_lkup_elem *list;
 	uint16_t lkups_num;
@@ -156,6 +181,12 @@ struct sw_meta {
 			ICE_SW_INSET_MAC_IPV4_UDP, ICE_INSET_NONE},
 	{pattern_eth_ipv4_tcp,
 			ICE_SW_INSET_MAC_IPV4_TCP, ICE_INSET_NONE},
+        {pattern_eth_vlan_ipv4,
+                        ICE_SW_INSET_MAC_VLAN_IPV4, ICE_INSET_NONE},
+        {pattern_eth_vlan_ipv4_tcp,
+                        ICE_SW_INSET_MAC_VLAN_IPV4_TCP, ICE_INSET_NONE},
+        {pattern_eth_vlan_ipv4_udp,
+                        ICE_SW_INSET_MAC_VLAN_IPV4_UDP, ICE_INSET_NONE},
 	{pattern_eth_ipv6,
 			ICE_SW_INSET_MAC_IPV6, ICE_INSET_NONE},
 	{pattern_eth_ipv6_udp,
@@ -174,6 +205,12 @@ struct sw_meta {
 			ICE_SW_INSET_DIST_NVGRE_IPV4_UDP, ICE_INSET_NONE},
 	{pattern_eth_ipv4_nvgre_eth_ipv4_tcp,
 			ICE_SW_INSET_DIST_NVGRE_IPV4_TCP, ICE_INSET_NONE},
+        {pattern_eth_ipv4_gre_raw_ipv4,
+                        ICE_SW_INSET_DIST_GRE_RAW_IPV4, ICE_INSET_NONE},
+        {pattern_eth_ipv4_gre_raw_ipv4_tcp,
+                        ICE_SW_INSET_DIST_GRE_RAW_IPV4_TCP, ICE_INSET_NONE},
+        {pattern_eth_ipv4_gre_raw_ipv4_udp,
+                        ICE_SW_INSET_DIST_GRE_RAW_IPV4_UDP, ICE_INSET_NONE},
 };
 
 static struct
@@ -453,9 +490,10 @@ struct sw_meta {
 		struct rte_flow *flow,
 		struct rte_flow_error *error)
 {
+        struct ice_dcf_hw *dcf_hw = ad->hw.aq_send_cmd_param;
+        struct ice_rule_query_data *filter_ptr;
 	struct ice_hw *hw = &ad->hw;
 	int ret;
-	struct ice_rule_query_data *filter_ptr;
 
 	filter_ptr = (struct ice_rule_query_data *)
 		flow->rule;
@@ -469,7 +507,7 @@ struct sw_meta {
 	}
 
 	ret = ice_rem_adv_rule_by_id(hw, filter_ptr);
-	if (ret) {
+        if (ret && !(hw->dcf_enabled && dcf_hw->multi_inst)) {
 		rte_flow_error_set(error, EINVAL,
 			RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
 			"fail to destroy switch filter rule");
@@ -477,7 +515,7 @@ struct sw_meta {
 	}
 
 	rte_free(filter_ptr);
-	return ret;
+	return 0;
 }
 
 static void
@@ -502,6 +540,8 @@ struct sw_meta {
 	const struct rte_flow_item_udp *udp_spec, *udp_mask;
 	const struct rte_flow_item_sctp *sctp_spec, *sctp_mask;
 	const struct rte_flow_item_nvgre *nvgre_spec, *nvgre_mask;
+        const struct rte_flow_item_gre *gre_spec, *gre_mask;
+        const struct rte_flow_item_raw *raw_spec, *raw_mask;
 	const struct rte_flow_item_vxlan *vxlan_spec, *vxlan_mask;
 	const struct rte_flow_item_vlan *vlan_spec, *vlan_mask;
 	const struct rte_flow_item_pppoe *pppoe_spec, *pppoe_mask;
@@ -519,12 +559,16 @@ struct sw_meta {
 	bool tunnel_valid = 0;
 	bool profile_rule = 0;
 	bool nvgre_valid = 0;
+        bool gre_valid = 0;
 	bool vxlan_valid = 0;
 	bool ipv6_valid = 0;
 	bool ipv4_valid = 0;
 	bool udp_valid = 0;
 	bool tcp_valid = 0;
 	uint16_t j, t = 0;
+        int32_t off;
+        uint16_t len;
+        uint16_t c_rsvd0_ver = 0;
 
 	for (item = pattern; item->type !=
 			RTE_FLOW_ITEM_TYPE_END; item++) {
@@ -734,6 +778,10 @@ struct sw_meta {
 						break;
 					}
 				}
+                               if ((ipv6_spec->hdr.proto &
+                                       ipv6_mask->hdr.proto) ==
+                                       ICE_IPV6_PROTO_NVGRE)
+                                       *tun_type = ICE_SW_TUN_AND_NON_TUN;
 				if (ipv6_mask->hdr.proto &&
 					tunnel_valid)
 					input_set |=
@@ -1047,6 +1095,84 @@ struct sw_meta {
 			}
 			break;
 
+                case RTE_FLOW_ITEM_TYPE_GRE:
+                        gre_spec = item->spec;
+                        gre_mask = item->mask;
+
+                        gre_valid = 1;
+                        tunnel_valid = 1;
+                        if(gre_spec && gre_mask) {
+                                list[t].type = ICE_GRE;
+                                if(gre_mask->c_rsvd0_ver) {
+                                        /* GRE RFC1701 */
+                                        list[t].h_u.gre_hdr.flags = gre_spec->c_rsvd0_ver;
+                                        list[t].m_u.gre_hdr.flags = gre_mask->c_rsvd0_ver;
+                                        c_rsvd0_ver = gre_spec->c_rsvd0_ver & gre_mask->c_rsvd0_ver;
+                                }
+                        }
+                        break;
+
+                case RTE_FLOW_ITEM_TYPE_RAW:
+                        raw_spec = item->spec;
+                        raw_mask = item->mask;
+
+                        if(list[t].type != ICE_GRE) {
+                                rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, item, "RAW must follow GRE.");
+                                return -rte_errno;
+                        }
+
+                        if((c_rsvd0_ver & GRE_KFLAG) == 0) {
+                                if(raw_spec && raw_mask) {
+                                        rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, item, "invalid pattern! k_bit is 0 while raw pattern exists.");
+                                        return -rte_errno;
+                                }
+                                break;
+                        }
+
+                        if((!raw_spec) || (!raw_mask)) {
+                                rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, item, "invalid pattern! k_bit is 1 while raw pattern doesn't exist.");
+                                return -rte_errno;
+                        }
+
+                        off = raw_spec->offset;
+                        len = raw_spec->length;
+
+                        if((c_rsvd0_ver & GRE_CFLAG) == GRE_CFLAG) {
+                                if(off != CUSTOM_GRE_KEY_OFFSET) {
+                                        rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, item, "invalid pattern! c_bit is 1 while offset is not 4.");
+                                        return -rte_errno;
+                                }
+                        }
+
+                        if(len > CUSTOM_GRE_RAW_KEY_LEN) {
+                                rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, item, "Only support 4 bytes matching.");
+                                return -rte_errno;
+                        }
+
+                        if(raw_spec && raw_mask) {
+                                        /* store pattern to header buffer */
+                                        const uint8_t *pat_src = (const uint8_t *)raw_spec->pattern;
+                                        uint8_t *key_dst = (uint8_t *)&list[t].h_u.gre_hdr.key;
+
+                                        int i = 0;
+                                        for(i=0; i < len; i++) {
+                                                int t = 0;
+                                                if(pat_src[i] >= '0' && pat_src[i] <= '9')
+                                                        t = pat_src[i] - '0';
+                                                else if(pat_src[i] >= 'a' && pat_src[i] <= 'f')
+                                                        t = pat_src[i] - 'a' + 10;
+                                                else
+                                                        printf("invalid pattern.\n");
+
+                                                key_dst[i/2] = (i%2) ? (key_dst[i/2]+t) : t*16;
+                                        }
+                                        list[t].m_u.gre_hdr.key = 0xffffffff;
+                                        input_set |= ICE_INSET_RAW;
+                                        input_set_byte += 2;
+                                t++;
+                        }
+                        break;
+
 		case RTE_FLOW_ITEM_TYPE_VLAN:
 			vlan_spec = item->spec;
 			vlan_mask = item->mask;
@@ -1402,6 +1528,8 @@ struct sw_meta {
 			*tun_type = ICE_SW_TUN_VXLAN;
 		else if (nvgre_valid)
 			*tun_type = ICE_SW_TUN_NVGRE;
+                else if (gre_valid)
+                        *tun_type = ICE_SW_TUN_GRE;
 		else if (ipv4_valid && tcp_valid)
 			*tun_type = ICE_SW_IPV4_TCP;
 		else if (ipv4_valid && udp_valid)
diff --git a/lib/librte_ethdev/rte_ethdev.h b/lib/librte_ethdev/rte_ethdev.h
index 0934e02..846fa66 100644
--- a/lib/librte_ethdev/rte_ethdev.h
+++ b/lib/librte_ethdev/rte_ethdev.h
@@ -1043,6 +1043,7 @@ enum rte_eth_tunnel_type {
 	RTE_TUNNEL_TYPE_IP_IN_GRE,
 	RTE_L2_TUNNEL_TYPE_E_TAG,
 	RTE_TUNNEL_TYPE_VXLAN_GPE,
+        RTE_TUNNEL_TYPE_ECPRI,
 	RTE_TUNNEL_TYPE_MAX,
 };
 
