diff --git a/app/test-pmd/cmdline.c b/app/test-pmd/cmdline.c
index 8e76ec62a2..84db81cf31 100644
--- a/app/test-pmd/cmdline.c
+++ b/app/test-pmd/cmdline.c
@@ -650,20 +650,6 @@ static void cmd_help_long_parsed(void *parsed_result,
 			"set link-down port (port_id)\n"
 			"	Set link down for a port.\n\n"
 
-			"E-tag set insertion on port-tag-id (value)"
-			" port (port_id) vf (vf_id)\n"
-			"    Enable E-tag insertion for a VF on a port\n\n"
-
-			"E-tag set insertion off port (port_id) vf (vf_id)\n"
-			"    Disable E-tag insertion for a VF on a port\n\n"
-
-			"E-tag set stripping (on|off) port (port_id)\n"
-			"    Enable/disable E-tag stripping on a port\n\n"
-
-			"E-tag set forwarding (on|off) port (port_id)\n"
-			"    Enable/disable E-tag based forwarding"
-			" on a port\n\n"
-
 			"ddp add (port_id) (profile_path[,backup_profile_path])\n"
 			"    Load a profile package on a port\n\n"
 
@@ -843,10 +829,6 @@ static void cmd_help_long_parsed(void *parsed_result,
 			"port (port_id) (rxq|txq) (queue_id) setup\n"
 			"    Setup a rx/tx queue of port X.\n\n"
 
-			"port config (port_id|all) l2-tunnel E-tag"
-			" (enable|disable)\n"
-			"    Enable/disable the E-tag support.\n\n"
-
 			"port config (port_id) pctype mapping reset\n"
 			"    Reset flow type to pctype mapping on a port\n\n"
 
@@ -10671,437 +10653,6 @@ cmdline_parse_inst_t cmd_mcast_addr = {
 	},
 };
 
-/* l2 tunnel config
- * only support E-tag now.
- */
-
-static enum rte_eth_tunnel_type
-str2fdir_l2_tunnel_type(char *string)
-{
-	uint32_t i = 0;
-
-	static const struct {
-		char str[32];
-		enum rte_eth_tunnel_type type;
-	} l2_tunnel_type_str[] = {
-		{"E-tag", RTE_L2_TUNNEL_TYPE_E_TAG},
-	};
-
-	for (i = 0; i < RTE_DIM(l2_tunnel_type_str); i++) {
-		if (!strcmp(l2_tunnel_type_str[i].str, string))
-			return l2_tunnel_type_str[i].type;
-	}
-	return RTE_TUNNEL_TYPE_NONE;
-}
-
-/* Enable/disable l2 tunnel */
-struct cmd_config_l2_tunnel_en_dis_result {
-	cmdline_fixed_string_t port;
-	cmdline_fixed_string_t config;
-	cmdline_fixed_string_t all;
-	portid_t id;
-	cmdline_fixed_string_t l2_tunnel;
-	cmdline_fixed_string_t l2_tunnel_type;
-	cmdline_fixed_string_t en_dis;
-};
-
-cmdline_parse_token_string_t cmd_config_l2_tunnel_en_dis_port =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_l2_tunnel_en_dis_result,
-		 port, "port");
-cmdline_parse_token_string_t cmd_config_l2_tunnel_en_dis_config =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_l2_tunnel_en_dis_result,
-		 config, "config");
-cmdline_parse_token_string_t cmd_config_l2_tunnel_en_dis_all_str =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_l2_tunnel_en_dis_result,
-		 all, "all");
-cmdline_parse_token_num_t cmd_config_l2_tunnel_en_dis_id =
-	TOKEN_NUM_INITIALIZER
-		(struct cmd_config_l2_tunnel_en_dis_result,
-		 id, UINT16);
-cmdline_parse_token_string_t cmd_config_l2_tunnel_en_dis_l2_tunnel =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_l2_tunnel_en_dis_result,
-		 l2_tunnel, "l2-tunnel");
-cmdline_parse_token_string_t cmd_config_l2_tunnel_en_dis_l2_tunnel_type =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_l2_tunnel_en_dis_result,
-		 l2_tunnel_type, "E-tag");
-cmdline_parse_token_string_t cmd_config_l2_tunnel_en_dis_en_dis =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_l2_tunnel_en_dis_result,
-		 en_dis, "enable#disable");
-
-/* enable/disable l2 tunnel for all ports */
-static void
-cmd_config_l2_tunnel_en_dis_all_parsed(
-	void *parsed_result,
-	__rte_unused struct cmdline *cl,
-	__rte_unused void *data)
-{
-	struct cmd_config_l2_tunnel_en_dis_result *res = parsed_result;
-	struct rte_eth_l2_tunnel_conf entry;
-	portid_t pid;
-	uint8_t en;
-
-	entry.l2_tunnel_type = str2fdir_l2_tunnel_type(res->l2_tunnel_type);
-
-	if (!strcmp("enable", res->en_dis))
-		en = 1;
-	else
-		en = 0;
-
-	RTE_ETH_FOREACH_DEV(pid) {
-		rte_eth_dev_l2_tunnel_offload_set(pid,
-						  &entry,
-						  ETH_L2_TUNNEL_ENABLE_MASK,
-						  en);
-	}
-}
-
-cmdline_parse_inst_t cmd_config_l2_tunnel_en_dis_all = {
-	.f = cmd_config_l2_tunnel_en_dis_all_parsed,
-	.data = NULL,
-	.help_str = "port config all l2-tunnel E-tag enable|disable",
-	.tokens = {
-		(void *)&cmd_config_l2_tunnel_en_dis_port,
-		(void *)&cmd_config_l2_tunnel_en_dis_config,
-		(void *)&cmd_config_l2_tunnel_en_dis_all_str,
-		(void *)&cmd_config_l2_tunnel_en_dis_l2_tunnel,
-		(void *)&cmd_config_l2_tunnel_en_dis_l2_tunnel_type,
-		(void *)&cmd_config_l2_tunnel_en_dis_en_dis,
-		NULL,
-	},
-};
-
-/* enable/disable l2 tunnel for a port */
-static void
-cmd_config_l2_tunnel_en_dis_specific_parsed(
-	void *parsed_result,
-	__rte_unused struct cmdline *cl,
-	__rte_unused void *data)
-{
-	struct cmd_config_l2_tunnel_en_dis_result *res =
-		parsed_result;
-	struct rte_eth_l2_tunnel_conf entry;
-
-	if (port_id_is_invalid(res->id, ENABLED_WARN))
-		return;
-
-	entry.l2_tunnel_type = str2fdir_l2_tunnel_type(res->l2_tunnel_type);
-
-	if (!strcmp("enable", res->en_dis))
-		rte_eth_dev_l2_tunnel_offload_set(res->id,
-						  &entry,
-						  ETH_L2_TUNNEL_ENABLE_MASK,
-						  1);
-	else
-		rte_eth_dev_l2_tunnel_offload_set(res->id,
-						  &entry,
-						  ETH_L2_TUNNEL_ENABLE_MASK,
-						  0);
-}
-
-cmdline_parse_inst_t cmd_config_l2_tunnel_en_dis_specific = {
-	.f = cmd_config_l2_tunnel_en_dis_specific_parsed,
-	.data = NULL,
-	.help_str = "port config <port_id> l2-tunnel E-tag enable|disable",
-	.tokens = {
-		(void *)&cmd_config_l2_tunnel_en_dis_port,
-		(void *)&cmd_config_l2_tunnel_en_dis_config,
-		(void *)&cmd_config_l2_tunnel_en_dis_id,
-		(void *)&cmd_config_l2_tunnel_en_dis_l2_tunnel,
-		(void *)&cmd_config_l2_tunnel_en_dis_l2_tunnel_type,
-		(void *)&cmd_config_l2_tunnel_en_dis_en_dis,
-		NULL,
-	},
-};
-
-/* E-tag configuration */
-
-/* Common result structure for all E-tag configuration */
-struct cmd_config_e_tag_result {
-	cmdline_fixed_string_t e_tag;
-	cmdline_fixed_string_t set;
-	cmdline_fixed_string_t insertion;
-	cmdline_fixed_string_t stripping;
-	cmdline_fixed_string_t forwarding;
-	cmdline_fixed_string_t filter;
-	cmdline_fixed_string_t add;
-	cmdline_fixed_string_t del;
-	cmdline_fixed_string_t on;
-	cmdline_fixed_string_t off;
-	cmdline_fixed_string_t on_off;
-	cmdline_fixed_string_t port_tag_id;
-	uint32_t port_tag_id_val;
-	cmdline_fixed_string_t e_tag_id;
-	uint16_t e_tag_id_val;
-	cmdline_fixed_string_t dst_pool;
-	uint8_t dst_pool_val;
-	cmdline_fixed_string_t port;
-	portid_t port_id;
-	cmdline_fixed_string_t vf;
-	uint8_t vf_id;
-};
-
-/* Common CLI fields for all E-tag configuration */
-cmdline_parse_token_string_t cmd_config_e_tag_e_tag =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_e_tag_result,
-		 e_tag, "E-tag");
-cmdline_parse_token_string_t cmd_config_e_tag_set =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_e_tag_result,
-		 set, "set");
-cmdline_parse_token_string_t cmd_config_e_tag_insertion =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_e_tag_result,
-		 insertion, "insertion");
-cmdline_parse_token_string_t cmd_config_e_tag_stripping =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_e_tag_result,
-		 stripping, "stripping");
-cmdline_parse_token_string_t cmd_config_e_tag_forwarding =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_e_tag_result,
-		 forwarding, "forwarding");
-cmdline_parse_token_string_t cmd_config_e_tag_filter =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_e_tag_result,
-		 filter, "filter");
-cmdline_parse_token_string_t cmd_config_e_tag_add =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_e_tag_result,
-		 add, "add");
-cmdline_parse_token_string_t cmd_config_e_tag_del =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_e_tag_result,
-		 del, "del");
-cmdline_parse_token_string_t cmd_config_e_tag_on =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_e_tag_result,
-		 on, "on");
-cmdline_parse_token_string_t cmd_config_e_tag_off =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_e_tag_result,
-		 off, "off");
-cmdline_parse_token_string_t cmd_config_e_tag_on_off =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_e_tag_result,
-		 on_off, "on#off");
-cmdline_parse_token_string_t cmd_config_e_tag_port_tag_id =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_e_tag_result,
-		 port_tag_id, "port-tag-id");
-cmdline_parse_token_num_t cmd_config_e_tag_port_tag_id_val =
-	TOKEN_NUM_INITIALIZER
-		(struct cmd_config_e_tag_result,
-		 port_tag_id_val, UINT32);
-cmdline_parse_token_string_t cmd_config_e_tag_e_tag_id =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_e_tag_result,
-		 e_tag_id, "e-tag-id");
-cmdline_parse_token_num_t cmd_config_e_tag_e_tag_id_val =
-	TOKEN_NUM_INITIALIZER
-		(struct cmd_config_e_tag_result,
-		 e_tag_id_val, UINT16);
-cmdline_parse_token_string_t cmd_config_e_tag_dst_pool =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_e_tag_result,
-		 dst_pool, "dst-pool");
-cmdline_parse_token_num_t cmd_config_e_tag_dst_pool_val =
-	TOKEN_NUM_INITIALIZER
-		(struct cmd_config_e_tag_result,
-		 dst_pool_val, UINT8);
-cmdline_parse_token_string_t cmd_config_e_tag_port =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_e_tag_result,
-		 port, "port");
-cmdline_parse_token_num_t cmd_config_e_tag_port_id =
-	TOKEN_NUM_INITIALIZER
-		(struct cmd_config_e_tag_result,
-		 port_id, UINT16);
-cmdline_parse_token_string_t cmd_config_e_tag_vf =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_e_tag_result,
-		 vf, "vf");
-cmdline_parse_token_num_t cmd_config_e_tag_vf_id =
-	TOKEN_NUM_INITIALIZER
-		(struct cmd_config_e_tag_result,
-		 vf_id, UINT8);
-
-/* E-tag insertion configuration */
-static void
-cmd_config_e_tag_insertion_en_parsed(
-	void *parsed_result,
-	__rte_unused struct cmdline *cl,
-	__rte_unused void *data)
-{
-	struct cmd_config_e_tag_result *res =
-		parsed_result;
-	struct rte_eth_l2_tunnel_conf entry;
-
-	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
-		return;
-
-	entry.l2_tunnel_type = RTE_L2_TUNNEL_TYPE_E_TAG;
-	entry.tunnel_id = res->port_tag_id_val;
-	entry.vf_id = res->vf_id;
-	rte_eth_dev_l2_tunnel_offload_set(res->port_id,
-					  &entry,
-					  ETH_L2_TUNNEL_INSERTION_MASK,
-					  1);
-}
-
-static void
-cmd_config_e_tag_insertion_dis_parsed(
-	void *parsed_result,
-	__rte_unused struct cmdline *cl,
-	__rte_unused void *data)
-{
-	struct cmd_config_e_tag_result *res =
-		parsed_result;
-	struct rte_eth_l2_tunnel_conf entry;
-
-	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
-		return;
-
-	entry.l2_tunnel_type = RTE_L2_TUNNEL_TYPE_E_TAG;
-	entry.vf_id = res->vf_id;
-
-	rte_eth_dev_l2_tunnel_offload_set(res->port_id,
-					  &entry,
-					  ETH_L2_TUNNEL_INSERTION_MASK,
-					  0);
-}
-
-cmdline_parse_inst_t cmd_config_e_tag_insertion_en = {
-	.f = cmd_config_e_tag_insertion_en_parsed,
-	.data = NULL,
-	.help_str = "E-tag ... : E-tag insertion enable",
-	.tokens = {
-		(void *)&cmd_config_e_tag_e_tag,
-		(void *)&cmd_config_e_tag_set,
-		(void *)&cmd_config_e_tag_insertion,
-		(void *)&cmd_config_e_tag_on,
-		(void *)&cmd_config_e_tag_port_tag_id,
-		(void *)&cmd_config_e_tag_port_tag_id_val,
-		(void *)&cmd_config_e_tag_port,
-		(void *)&cmd_config_e_tag_port_id,
-		(void *)&cmd_config_e_tag_vf,
-		(void *)&cmd_config_e_tag_vf_id,
-		NULL,
-	},
-};
-
-cmdline_parse_inst_t cmd_config_e_tag_insertion_dis = {
-	.f = cmd_config_e_tag_insertion_dis_parsed,
-	.data = NULL,
-	.help_str = "E-tag ... : E-tag insertion disable",
-	.tokens = {
-		(void *)&cmd_config_e_tag_e_tag,
-		(void *)&cmd_config_e_tag_set,
-		(void *)&cmd_config_e_tag_insertion,
-		(void *)&cmd_config_e_tag_off,
-		(void *)&cmd_config_e_tag_port,
-		(void *)&cmd_config_e_tag_port_id,
-		(void *)&cmd_config_e_tag_vf,
-		(void *)&cmd_config_e_tag_vf_id,
-		NULL,
-	},
-};
-
-/* E-tag stripping configuration */
-static void
-cmd_config_e_tag_stripping_parsed(
-	void *parsed_result,
-	__rte_unused struct cmdline *cl,
-	__rte_unused void *data)
-{
-	struct cmd_config_e_tag_result *res =
-		parsed_result;
-	struct rte_eth_l2_tunnel_conf entry;
-
-	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
-		return;
-
-	entry.l2_tunnel_type = RTE_L2_TUNNEL_TYPE_E_TAG;
-
-	if (!strcmp(res->on_off, "on"))
-		rte_eth_dev_l2_tunnel_offload_set
-			(res->port_id,
-			 &entry,
-			 ETH_L2_TUNNEL_STRIPPING_MASK,
-			 1);
-	else
-		rte_eth_dev_l2_tunnel_offload_set
-			(res->port_id,
-			 &entry,
-			 ETH_L2_TUNNEL_STRIPPING_MASK,
-			 0);
-}
-
-cmdline_parse_inst_t cmd_config_e_tag_stripping_en_dis = {
-	.f = cmd_config_e_tag_stripping_parsed,
-	.data = NULL,
-	.help_str = "E-tag ... : E-tag stripping enable/disable",
-	.tokens = {
-		(void *)&cmd_config_e_tag_e_tag,
-		(void *)&cmd_config_e_tag_set,
-		(void *)&cmd_config_e_tag_stripping,
-		(void *)&cmd_config_e_tag_on_off,
-		(void *)&cmd_config_e_tag_port,
-		(void *)&cmd_config_e_tag_port_id,
-		NULL,
-	},
-};
-
-/* E-tag forwarding configuration */
-static void
-cmd_config_e_tag_forwarding_parsed(
-	void *parsed_result,
-	__rte_unused struct cmdline *cl,
-	__rte_unused void *data)
-{
-	struct cmd_config_e_tag_result *res = parsed_result;
-	struct rte_eth_l2_tunnel_conf entry;
-
-	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
-		return;
-
-	entry.l2_tunnel_type = RTE_L2_TUNNEL_TYPE_E_TAG;
-
-	if (!strcmp(res->on_off, "on"))
-		rte_eth_dev_l2_tunnel_offload_set
-			(res->port_id,
-			 &entry,
-			 ETH_L2_TUNNEL_FORWARDING_MASK,
-			 1);
-	else
-		rte_eth_dev_l2_tunnel_offload_set
-			(res->port_id,
-			 &entry,
-			 ETH_L2_TUNNEL_FORWARDING_MASK,
-			 0);
-}
-
-cmdline_parse_inst_t cmd_config_e_tag_forwarding_en_dis = {
-	.f = cmd_config_e_tag_forwarding_parsed,
-	.data = NULL,
-	.help_str = "E-tag ... : E-tag forwarding enable/disable",
-	.tokens = {
-		(void *)&cmd_config_e_tag_e_tag,
-		(void *)&cmd_config_e_tag_set,
-		(void *)&cmd_config_e_tag_forwarding,
-		(void *)&cmd_config_e_tag_on_off,
-		(void *)&cmd_config_e_tag_port,
-		(void *)&cmd_config_e_tag_port_id,
-		NULL,
-	},
-};
-
 /* vf vlan anti spoof configuration */
 
 /* Common result structure for vf vlan anti spoof */
@@ -17394,12 +16945,6 @@ cmdline_parse_ctx_t main_ctx[] = {
 	(cmdline_parse_inst_t *)&cmd_set_port_meter_stats_mask,
 	(cmdline_parse_inst_t *)&cmd_show_port_meter_stats,
 	(cmdline_parse_inst_t *)&cmd_mcast_addr,
-	(cmdline_parse_inst_t *)&cmd_config_l2_tunnel_en_dis_all,
-	(cmdline_parse_inst_t *)&cmd_config_l2_tunnel_en_dis_specific,
-	(cmdline_parse_inst_t *)&cmd_config_e_tag_insertion_en,
-	(cmdline_parse_inst_t *)&cmd_config_e_tag_insertion_dis,
-	(cmdline_parse_inst_t *)&cmd_config_e_tag_stripping_en_dis,
-	(cmdline_parse_inst_t *)&cmd_config_e_tag_forwarding_en_dis,
 	(cmdline_parse_inst_t *)&cmd_set_vf_vlan_anti_spoof,
 	(cmdline_parse_inst_t *)&cmd_set_vf_mac_anti_spoof,
 	(cmdline_parse_inst_t *)&cmd_set_vf_vlan_stripq,
diff --git a/doc/guides/nics/features.rst b/doc/guides/nics/features.rst
index 37cd26d84a..98ad7d0822 100644
--- a/doc/guides/nics/features.rst
+++ b/doc/guides/nics/features.rst
@@ -938,10 +938,8 @@ Other dev ops not represented by a Feature
 * ``vlan_strip_queue_set``
 * ``vlan_pvid_set``
 * ``rx_queue_count``
-* ``l2_tunnel_offload_set``
 * ``uc_hash_table_set``
 * ``uc_all_hash_table_set``
 * ``udp_tunnel_port_add``
 * ``udp_tunnel_port_del``
-* ``l2_tunnel_offload_set``
 * ``tx_pkt_prepare``
diff --git a/doc/guides/rel_notes/deprecation.rst b/doc/guides/rel_notes/deprecation.rst
index 38706775f5..a348138757 100644
--- a/doc/guides/rel_notes/deprecation.rst
+++ b/doc/guides/rel_notes/deprecation.rst
@@ -98,12 +98,6 @@ Deprecation Notices
   and the related structures (``rte_fdir_*`` and ``rte_eth_fdir_*``),
   will be removed in DPDK 20.11.
 
-* ethdev: The legacy L2 tunnel filtering API is deprecated as the rest of
-  the legacy filtering API.
-  The function
-  ``rte_eth_dev_l2_tunnel_offload_set`` which were not marked as deprecated,
-  will be removed in DPDK 20.11.
-
 * ethdev: New offload flags ``DEV_RX_OFFLOAD_FLOW_MARK`` will be added in 19.11.
   This will allow application to enable or disable PMDs from updating
   ``rte_mbuf::hash::fdir``.
diff --git a/doc/guides/rel_notes/release_20_11.rst b/doc/guides/rel_notes/release_20_11.rst
index 3165307de9..82d392dec8 100644
--- a/doc/guides/rel_notes/release_20_11.rst
+++ b/doc/guides/rel_notes/release_20_11.rst
@@ -472,7 +472,8 @@ API Changes
   ``rte_eth_dev_filter_supported()`` and ``rte_eth_dev_filter_ctrl()``.
 
 * ethdev: Removed the legacy L2 tunnel configuration API, including
-  ``rte_eth_dev_l2_tunnel_eth_type_conf()``.
+  ``rte_eth_dev_l2_tunnel_eth_type_conf()`` and
+  ``rte_eth_dev_l2_tunnel_offload_set()``..
 
 * vhost: Moved vDPA APIs from experimental to stable.
 
diff --git a/doc/guides/testpmd_app_ug/testpmd_funcs.rst b/doc/guides/testpmd_app_ug/testpmd_funcs.rst
index e6439719d1..edcb4d2d17 100644
--- a/doc/guides/testpmd_app_ug/testpmd_funcs.rst
+++ b/doc/guides/testpmd_app_ug/testpmd_funcs.rst
@@ -2339,13 +2339,6 @@ Where the threshold type can be:
 
 These threshold options are also available from the command-line.
 
-port config - E-tag
-~~~~~~~~~~~~~~~~~~~
-
-Enable/disable the E-tag support::
-
-   testpmd> port config (port_id|all) l2-tunnel E-tag (enable|disable)
-
 port config pctype mapping
 ~~~~~~~~~~~~~~~~~~~~~~~~~~
 
diff --git a/drivers/net/ixgbe/ixgbe_ethdev.c b/drivers/net/ixgbe/ixgbe_ethdev.c
index 4918517b92..9c91b8cde8 100644
--- a/drivers/net/ixgbe/ixgbe_ethdev.c
+++ b/drivers/net/ixgbe/ixgbe_ethdev.c
@@ -348,12 +348,6 @@ static int ixgbe_timesync_write_time(struct rte_eth_dev *dev,
 				   const struct timespec *timestamp);
 static void ixgbevf_dev_interrupt_handler(void *param);
 
-static int ixgbe_dev_l2_tunnel_offload_set
-	(struct rte_eth_dev *dev,
-	 struct rte_eth_l2_tunnel_conf *l2_tunnel,
-	 uint32_t mask,
-	 uint8_t en);
-
 static int ixgbe_dev_udp_tunnel_port_add(struct rte_eth_dev *dev,
 					 struct rte_eth_udp_tunnel *udp_tunnel);
 static int ixgbe_dev_udp_tunnel_port_del(struct rte_eth_dev *dev,
@@ -562,7 +556,6 @@ static const struct eth_dev_ops ixgbe_eth_dev_ops = {
 	.timesync_adjust_time = ixgbe_timesync_adjust_time,
 	.timesync_read_time   = ixgbe_timesync_read_time,
 	.timesync_write_time  = ixgbe_timesync_write_time,
-	.l2_tunnel_offload_set   = ixgbe_dev_l2_tunnel_offload_set,
 	.udp_tunnel_port_add  = ixgbe_dev_udp_tunnel_port_add,
 	.udp_tunnel_port_del  = ixgbe_dev_udp_tunnel_port_del,
 	.tm_ops_get           = ixgbe_tm_ops_get,
@@ -7555,74 +7548,6 @@ ixgbe_e_tag_enable(struct ixgbe_hw *hw)
 	return 0;
 }
 
-/* Enable l2 tunnel */
-static int
-ixgbe_dev_l2_tunnel_enable(struct rte_eth_dev *dev,
-			   enum rte_eth_tunnel_type l2_tunnel_type)
-{
-	int ret = 0;
-	struct ixgbe_hw *hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
-	struct ixgbe_l2_tn_info *l2_tn_info =
-		IXGBE_DEV_PRIVATE_TO_L2_TN_INFO(dev->data->dev_private);
-
-	switch (l2_tunnel_type) {
-	case RTE_L2_TUNNEL_TYPE_E_TAG:
-		l2_tn_info->e_tag_en = TRUE;
-		ret = ixgbe_e_tag_enable(hw);
-		break;
-	default:
-		PMD_DRV_LOG(ERR, "Invalid tunnel type");
-		ret = -EINVAL;
-		break;
-	}
-
-	return ret;
-}
-
-/* Disable e-tag tunnel */
-static int
-ixgbe_e_tag_disable(struct ixgbe_hw *hw)
-{
-	uint32_t etag_etype;
-
-	if (hw->mac.type != ixgbe_mac_X550 &&
-	    hw->mac.type != ixgbe_mac_X550EM_x &&
-	    hw->mac.type != ixgbe_mac_X550EM_a) {
-		return -ENOTSUP;
-	}
-
-	etag_etype = IXGBE_READ_REG(hw, IXGBE_ETAG_ETYPE);
-	etag_etype &= ~IXGBE_ETAG_ETYPE_VALID;
-	IXGBE_WRITE_REG(hw, IXGBE_ETAG_ETYPE, etag_etype);
-	IXGBE_WRITE_FLUSH(hw);
-
-	return 0;
-}
-
-/* Disable l2 tunnel */
-static int
-ixgbe_dev_l2_tunnel_disable(struct rte_eth_dev *dev,
-			    enum rte_eth_tunnel_type l2_tunnel_type)
-{
-	int ret = 0;
-	struct ixgbe_hw *hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
-	struct ixgbe_l2_tn_info *l2_tn_info =
-		IXGBE_DEV_PRIVATE_TO_L2_TN_INFO(dev->data->dev_private);
-
-	switch (l2_tunnel_type) {
-	case RTE_L2_TUNNEL_TYPE_E_TAG:
-		l2_tn_info->e_tag_en = FALSE;
-		ret = ixgbe_e_tag_disable(hw);
-		break;
-	default:
-		PMD_DRV_LOG(ERR, "Invalid tunnel type");
-		ret = -EINVAL;
-		break;
-	}
-
-	return ret;
-}
-
 static int
 ixgbe_e_tag_filter_del(struct rte_eth_dev *dev,
 		       struct rte_eth_l2_tunnel_conf *l2_tunnel)
@@ -7870,264 +7795,6 @@ ixgbe_e_tag_forwarding_en_dis(struct rte_eth_dev *dev, bool en)
 	return ret;
 }
 
-/* Enable l2 tunnel forwarding */
-static int
-ixgbe_dev_l2_tunnel_forwarding_enable
-	(struct rte_eth_dev *dev,
-	 enum rte_eth_tunnel_type l2_tunnel_type)
-{
-	struct ixgbe_l2_tn_info *l2_tn_info =
-		IXGBE_DEV_PRIVATE_TO_L2_TN_INFO(dev->data->dev_private);
-	int ret = 0;
-
-	switch (l2_tunnel_type) {
-	case RTE_L2_TUNNEL_TYPE_E_TAG:
-		l2_tn_info->e_tag_fwd_en = TRUE;
-		ret = ixgbe_e_tag_forwarding_en_dis(dev, 1);
-		break;
-	default:
-		PMD_DRV_LOG(ERR, "Invalid tunnel type");
-		ret = -EINVAL;
-		break;
-	}
-
-	return ret;
-}
-
-/* Disable l2 tunnel forwarding */
-static int
-ixgbe_dev_l2_tunnel_forwarding_disable
-	(struct rte_eth_dev *dev,
-	 enum rte_eth_tunnel_type l2_tunnel_type)
-{
-	struct ixgbe_l2_tn_info *l2_tn_info =
-		IXGBE_DEV_PRIVATE_TO_L2_TN_INFO(dev->data->dev_private);
-	int ret = 0;
-
-	switch (l2_tunnel_type) {
-	case RTE_L2_TUNNEL_TYPE_E_TAG:
-		l2_tn_info->e_tag_fwd_en = FALSE;
-		ret = ixgbe_e_tag_forwarding_en_dis(dev, 0);
-		break;
-	default:
-		PMD_DRV_LOG(ERR, "Invalid tunnel type");
-		ret = -EINVAL;
-		break;
-	}
-
-	return ret;
-}
-
-static int
-ixgbe_e_tag_insertion_en_dis(struct rte_eth_dev *dev,
-			     struct rte_eth_l2_tunnel_conf *l2_tunnel,
-			     bool en)
-{
-	struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(dev);
-	int ret = 0;
-	uint32_t vmtir, vmvir;
-	struct ixgbe_hw *hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
-
-	if (l2_tunnel->vf_id >= pci_dev->max_vfs) {
-		PMD_DRV_LOG(ERR,
-			    "VF id %u should be less than %u",
-			    l2_tunnel->vf_id,
-			    pci_dev->max_vfs);
-		return -EINVAL;
-	}
-
-	if (hw->mac.type != ixgbe_mac_X550 &&
-	    hw->mac.type != ixgbe_mac_X550EM_x &&
-	    hw->mac.type != ixgbe_mac_X550EM_a) {
-		return -ENOTSUP;
-	}
-
-	if (en)
-		vmtir = l2_tunnel->tunnel_id;
-	else
-		vmtir = 0;
-
-	IXGBE_WRITE_REG(hw, IXGBE_VMTIR(l2_tunnel->vf_id), vmtir);
-
-	vmvir = IXGBE_READ_REG(hw, IXGBE_VMVIR(l2_tunnel->vf_id));
-	vmvir &= ~IXGBE_VMVIR_TAGA_MASK;
-	if (en)
-		vmvir |= IXGBE_VMVIR_TAGA_ETAG_INSERT;
-	IXGBE_WRITE_REG(hw, IXGBE_VMVIR(l2_tunnel->vf_id), vmvir);
-
-	return ret;
-}
-
-/* Enable l2 tunnel tag insertion */
-static int
-ixgbe_dev_l2_tunnel_insertion_enable(struct rte_eth_dev *dev,
-				     struct rte_eth_l2_tunnel_conf *l2_tunnel)
-{
-	int ret = 0;
-
-	switch (l2_tunnel->l2_tunnel_type) {
-	case RTE_L2_TUNNEL_TYPE_E_TAG:
-		ret = ixgbe_e_tag_insertion_en_dis(dev, l2_tunnel, 1);
-		break;
-	default:
-		PMD_DRV_LOG(ERR, "Invalid tunnel type");
-		ret = -EINVAL;
-		break;
-	}
-
-	return ret;
-}
-
-/* Disable l2 tunnel tag insertion */
-static int
-ixgbe_dev_l2_tunnel_insertion_disable
-	(struct rte_eth_dev *dev,
-	 struct rte_eth_l2_tunnel_conf *l2_tunnel)
-{
-	int ret = 0;
-
-	switch (l2_tunnel->l2_tunnel_type) {
-	case RTE_L2_TUNNEL_TYPE_E_TAG:
-		ret = ixgbe_e_tag_insertion_en_dis(dev, l2_tunnel, 0);
-		break;
-	default:
-		PMD_DRV_LOG(ERR, "Invalid tunnel type");
-		ret = -EINVAL;
-		break;
-	}
-
-	return ret;
-}
-
-static int
-ixgbe_e_tag_stripping_en_dis(struct rte_eth_dev *dev,
-			     bool en)
-{
-	int ret = 0;
-	uint32_t qde;
-	struct ixgbe_hw *hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
-
-	if (hw->mac.type != ixgbe_mac_X550 &&
-	    hw->mac.type != ixgbe_mac_X550EM_x &&
-	    hw->mac.type != ixgbe_mac_X550EM_a) {
-		return -ENOTSUP;
-	}
-
-	qde = IXGBE_READ_REG(hw, IXGBE_QDE);
-	if (en)
-		qde |= IXGBE_QDE_STRIP_TAG;
-	else
-		qde &= ~IXGBE_QDE_STRIP_TAG;
-	qde &= ~IXGBE_QDE_READ;
-	qde |= IXGBE_QDE_WRITE;
-	IXGBE_WRITE_REG(hw, IXGBE_QDE, qde);
-
-	return ret;
-}
-
-/* Enable l2 tunnel tag stripping */
-static int
-ixgbe_dev_l2_tunnel_stripping_enable
-	(struct rte_eth_dev *dev,
-	 enum rte_eth_tunnel_type l2_tunnel_type)
-{
-	int ret = 0;
-
-	switch (l2_tunnel_type) {
-	case RTE_L2_TUNNEL_TYPE_E_TAG:
-		ret = ixgbe_e_tag_stripping_en_dis(dev, 1);
-		break;
-	default:
-		PMD_DRV_LOG(ERR, "Invalid tunnel type");
-		ret = -EINVAL;
-		break;
-	}
-
-	return ret;
-}
-
-/* Disable l2 tunnel tag stripping */
-static int
-ixgbe_dev_l2_tunnel_stripping_disable
-	(struct rte_eth_dev *dev,
-	 enum rte_eth_tunnel_type l2_tunnel_type)
-{
-	int ret = 0;
-
-	switch (l2_tunnel_type) {
-	case RTE_L2_TUNNEL_TYPE_E_TAG:
-		ret = ixgbe_e_tag_stripping_en_dis(dev, 0);
-		break;
-	default:
-		PMD_DRV_LOG(ERR, "Invalid tunnel type");
-		ret = -EINVAL;
-		break;
-	}
-
-	return ret;
-}
-
-/* Enable/disable l2 tunnel offload functions */
-static int
-ixgbe_dev_l2_tunnel_offload_set
-	(struct rte_eth_dev *dev,
-	 struct rte_eth_l2_tunnel_conf *l2_tunnel,
-	 uint32_t mask,
-	 uint8_t en)
-{
-	int ret = 0;
-
-	if (l2_tunnel == NULL)
-		return -EINVAL;
-
-	ret = -EINVAL;
-	if (mask & ETH_L2_TUNNEL_ENABLE_MASK) {
-		if (en)
-			ret = ixgbe_dev_l2_tunnel_enable(
-				dev,
-				l2_tunnel->l2_tunnel_type);
-		else
-			ret = ixgbe_dev_l2_tunnel_disable(
-				dev,
-				l2_tunnel->l2_tunnel_type);
-	}
-
-	if (mask & ETH_L2_TUNNEL_INSERTION_MASK) {
-		if (en)
-			ret = ixgbe_dev_l2_tunnel_insertion_enable(
-				dev,
-				l2_tunnel);
-		else
-			ret = ixgbe_dev_l2_tunnel_insertion_disable(
-				dev,
-				l2_tunnel);
-	}
-
-	if (mask & ETH_L2_TUNNEL_STRIPPING_MASK) {
-		if (en)
-			ret = ixgbe_dev_l2_tunnel_stripping_enable(
-				dev,
-				l2_tunnel->l2_tunnel_type);
-		else
-			ret = ixgbe_dev_l2_tunnel_stripping_disable(
-				dev,
-				l2_tunnel->l2_tunnel_type);
-	}
-
-	if (mask & ETH_L2_TUNNEL_FORWARDING_MASK) {
-		if (en)
-			ret = ixgbe_dev_l2_tunnel_forwarding_enable(
-				dev,
-				l2_tunnel->l2_tunnel_type);
-		else
-			ret = ixgbe_dev_l2_tunnel_forwarding_disable(
-				dev,
-				l2_tunnel->l2_tunnel_type);
-	}
-
-	return ret;
-}
-
 static int
 ixgbe_update_vxlan_port(struct ixgbe_hw *hw,
 			uint16_t port)
diff --git a/lib/librte_ethdev/rte_ethdev.c b/lib/librte_ethdev/rte_ethdev.c
index e5d0a18feb..c8f25f7c89 100644
--- a/lib/librte_ethdev/rte_ethdev.c
+++ b/lib/librte_ethdev/rte_ethdev.c
@@ -5317,38 +5317,6 @@ rte_eth_dev_get_dcb_info(uint16_t port_id,
 	return eth_err(port_id, (*dev->dev_ops->get_dcb_info)(dev, dcb_info));
 }
 
-int
-rte_eth_dev_l2_tunnel_offload_set(uint16_t port_id,
-				  struct rte_eth_l2_tunnel_conf *l2_tunnel,
-				  uint32_t mask,
-				  uint8_t en)
-{
-	struct rte_eth_dev *dev;
-
-	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
-
-	if (l2_tunnel == NULL) {
-		RTE_ETHDEV_LOG(ERR, "Invalid l2_tunnel parameter\n");
-		return -EINVAL;
-	}
-
-	if (l2_tunnel->l2_tunnel_type >= RTE_TUNNEL_TYPE_MAX) {
-		RTE_ETHDEV_LOG(ERR, "Invalid tunnel type\n");
-		return -EINVAL;
-	}
-
-	if (mask == 0) {
-		RTE_ETHDEV_LOG(ERR, "Mask should have a value\n");
-		return -EINVAL;
-	}
-
-	dev = &rte_eth_devices[port_id];
-	RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->l2_tunnel_offload_set,
-				-ENOTSUP);
-	return eth_err(port_id, (*dev->dev_ops->l2_tunnel_offload_set)(dev,
-							l2_tunnel, mask, en));
-}
-
 static void
 eth_dev_adjust_nb_desc(uint16_t *nb_desc,
 		const struct rte_eth_desc_lim *desc_lim)
diff --git a/lib/librte_ethdev/rte_ethdev.h b/lib/librte_ethdev/rte_ethdev.h
index dda75a82b3..ca694b793e 100644
--- a/lib/librte_ethdev/rte_ethdev.h
+++ b/lib/librte_ethdev/rte_ethdev.h
@@ -4627,36 +4627,6 @@ __rte_experimental
 int
 rte_eth_read_clock(uint16_t port_id, uint64_t *clock);
 
-/**
- * Enable/disable l2 tunnel offload functions. Include,
- * 1, The ability of parsing a type of l2 tunnel of an Ethernet device.
- *    Filtering, forwarding and offloading this type of tunnel packets depend on
- *    this ability.
- * 2, Stripping the l2 tunnel tag.
- * 3, Insertion of the l2 tunnel tag.
- * 4, Forwarding the packets based on the l2 tunnel tag.
- *
- * @param port_id
- *   The port identifier of the Ethernet device.
- * @param l2_tunnel
- *   l2 tunnel parameters.
- * @param mask
- *   Indicate the offload function.
- * @param en
- *   Enable or disable this function.
- *
- * @return
- *   - (0) if successful.
- *   - (-ENODEV) if port identifier is invalid.
- *   - (-EIO) if device is removed.
- *   - (-ENOTSUP) if hardware doesn't support tunnel type.
- */
-int
-rte_eth_dev_l2_tunnel_offload_set(uint16_t port_id,
-				  struct rte_eth_l2_tunnel_conf *l2_tunnel,
-				  uint32_t mask,
-				  uint8_t en);
-
 /**
 * Get the port id from device name. The device name should be specified
 * as below:
diff --git a/lib/librte_ethdev/rte_ethdev_driver.h b/lib/librte_ethdev/rte_ethdev_driver.h
index a69793dcb1..0eacfd8425 100644
--- a/lib/librte_ethdev/rte_ethdev_driver.h
+++ b/lib/librte_ethdev/rte_ethdev_driver.h
@@ -465,13 +465,6 @@ typedef int (*eth_get_module_eeprom_t)(struct rte_eth_dev *dev,
 				       struct rte_dev_eeprom_info *info);
 /**< @internal Retrieve plugin module eeprom data */
 
-typedef int (*eth_l2_tunnel_offload_set_t)
-	(struct rte_eth_dev *dev,
-	 struct rte_eth_l2_tunnel_conf *l2_tunnel,
-	 uint32_t mask,
-	 uint8_t en);
-/**< @internal enable/disable the l2 tunnel offload functions */
-
 /**
  * Feature filter types
  */
@@ -849,8 +842,6 @@ struct eth_dev_ops {
 
 	eth_udp_tunnel_port_add_t  udp_tunnel_port_add; /** Add UDP tunnel port. */
 	eth_udp_tunnel_port_del_t  udp_tunnel_port_del; /** Del UDP tunnel port. */
-	eth_l2_tunnel_offload_set_t   l2_tunnel_offload_set;
-	/** Enable/disable l2 tunnel offload functions. */
 
 	eth_set_queue_rate_limit_t set_queue_rate_limit; /**< Set queue rate limit. */
 
diff --git a/lib/librte_ethdev/version.map b/lib/librte_ethdev/version.map
index 63f077a3eb..d3f5410806 100644
--- a/lib/librte_ethdev/version.map
+++ b/lib/librte_ethdev/version.map
@@ -30,7 +30,6 @@ DPDK_21 {
 	rte_eth_dev_get_vlan_offload;
 	rte_eth_dev_info_get;
 	rte_eth_dev_is_valid_port;
-	rte_eth_dev_l2_tunnel_offload_set;
 	rte_eth_dev_logtype;
 	rte_eth_dev_mac_addr_add;
 	rte_eth_dev_mac_addr_remove;
