diff mbox series

[RFC,v2,4/5] net/i40e: move testpmd commands

Message ID 20220518194649.1868574-5-david.marchand@redhat.com (mailing list archive)
State Changes Requested
Delegated to: Andrew Rybchenko
Headers show
Series Split driver specific commands out of testpmd | expand

Checks

Context Check Description
ci/checkpatch success coding style OK

Commit Message

David Marchand May 18, 2022, 7:46 p.m. UTC
Move related specific testpmd commands into this driver directory.
While at it, fix checkpatch warnings.

Signed-off-by: David Marchand <david.marchand@redhat.com>
---
Changes since RFC v1:
- moved more i40e commands,
- fixed checkpatch warnings,

---
 app/test-pmd/cmdline.c          | 5422 ++++++++-----------------------
 app/test-pmd/config.c           |   43 -
 app/test-pmd/testpmd.h          |    2 -
 drivers/net/i40e/i40e_testpmd.c | 2718 ++++++++++++++++
 drivers/net/i40e/meson.build    |    2 +
 5 files changed, 4075 insertions(+), 4112 deletions(-)
 create mode 100644 drivers/net/i40e/i40e_testpmd.c
diff mbox series

Patch

diff --git a/app/test-pmd/cmdline.c b/app/test-pmd/cmdline.c
index 58bdf206d7..a009b2ec47 100644
--- a/app/test-pmd/cmdline.c
+++ b/app/test-pmd/cmdline.c
@@ -192,21 +192,12 @@  static void cmd_help_long_parsed(void *parsed_result,
 			"read txd (port_id) (queue_id) (txd_id)\n"
 			"    Display a TX descriptor of a port TX queue.\n\n"
 
-			"ddp get list (port_id)\n"
-			"    Get ddp profile info list\n\n"
-
-			"ddp get info (profile_path)\n"
-			"    Get ddp profile information.\n\n"
-
 			"show vf stats (port_id) (vf_id)\n"
 			"    Display a VF's statistics.\n\n"
 
 			"clear vf stats (port_id) (vf_id)\n"
 			"    Reset a VF's statistics.\n\n"
 
-			"show port (port_id) pctype mapping\n"
-			"    Get flow ptype to pctype mapping on a port\n\n"
-
 			"show port meter stats (port_id) (meter_id) (clear)\n"
 			"    Get meter stats on a port\n\n"
 
@@ -362,9 +353,6 @@  static void cmd_help_long_parsed(void *parsed_result,
 			"set macsec sa (tx|rx) (port_id) (idx) (an) (pn) (key)\n"
 			"    Configure MACsec secure association (SA).\n\n"
 
-			"set vf broadcast (port_id) (vf_id) (on|off)\n"
-			"    Set VF broadcast for a VF from the PF.\n\n"
-
 			"vlan set stripq (on|off) (port_id,queue_id)\n"
 			"    Set the VLAN strip for a queue on a port.\n\n"
 
@@ -377,21 +365,6 @@  static void cmd_help_long_parsed(void *parsed_result,
 			"set vf vlan antispoof (port_id) (vf_id) (on|off)\n"
 			"    Set VLAN antispoof for a VF from the PF.\n\n"
 
-			"set vf vlan tag (port_id) (vf_id) (on|off)\n"
-			"    Set VLAN tag for a VF from the PF.\n\n"
-
-			"set vf tx max-bandwidth (port_id) (vf_id) (bandwidth)\n"
-			"    Set a VF's max bandwidth(Mbps).\n\n"
-
-			"set vf tc tx min-bandwidth (port_id) (vf_id) (bw1, bw2, ...)\n"
-			"    Set all TCs' min bandwidth(%%) on a VF.\n\n"
-
-			"set vf tc tx max-bandwidth (port_id) (vf_id) (tc_no) (bandwidth)\n"
-			"    Set a TC's max bandwidth(Mbps) on a VF.\n\n"
-
-			"set tx strict-link-priority (port_id) (tc_bitmap)\n"
-			"    Set some TCs' strict link priority mode on a physical port.\n\n"
-
 			"set tc tx min-bandwidth (port_id) (bw1, bw2, ...)\n"
 			"    Set all TCs' min bandwidth(%%) for all PF and VFs.\n\n"
 
@@ -520,12 +493,6 @@  static void cmd_help_long_parsed(void *parsed_result,
 			"set allmulti (port_id|all) (on|off)\n"
 			"    Set the allmulti mode on port_id, or all.\n\n"
 
-			"set vf promisc (port_id) (vf_id) (on|off)\n"
-			"    Set unicast promiscuous mode for a VF from the PF.\n\n"
-
-			"set vf allmulti (port_id) (vf_id) (on|off)\n"
-			"    Set multicast promiscuous mode for a VF from the PF.\n\n"
-
 			"set flow_ctrl rx (on|off) tx (on|off) (high_water)"
 			" (low_water) (pause_time) (send_xon) mac_ctrl_frame_fwd"
 			" (on|off) autoneg (on|off) (port_id)\n"
@@ -616,42 +583,9 @@  static void cmd_help_long_parsed(void *parsed_result,
 			"set link-down port (port_id)\n"
 			"	Set link down for a port.\n\n"
 
-			"ddp add (port_id) (profile_path[,backup_profile_path])\n"
-			"    Load a profile package on a port\n\n"
-
-			"ddp del (port_id) (backup_profile_path)\n"
-			"    Delete a profile package from a port\n\n"
-
-			"ptype mapping get (port_id) (valid_only)\n"
-			"    Get ptype mapping on a port\n\n"
-
-			"ptype mapping replace (port_id) (target) (mask) (pky_type)\n"
-			"    Replace target with the pkt_type in ptype mapping\n\n"
-
-			"ptype mapping reset (port_id)\n"
-			"    Reset ptype mapping on a port\n\n"
-
-			"ptype mapping update (port_id) (hw_ptype) (sw_ptype)\n"
-			"    Update a ptype mapping item on a port\n\n"
-
 			"set port (port_id) ptype_mask (ptype_mask)\n"
 			"    set packet types classification for a specific port\n\n"
 
-			"set port (port_id) queue-region region_id (value) "
-			"queue_start_index (value) queue_num (value)\n"
-			"    Set a queue region on a port\n\n"
-
-			"set port (port_id) queue-region region_id (value) "
-			"flowtype (value)\n"
-			"    Set a flowtype region index on a port\n\n"
-
-			"set port (port_id) queue-region UP (value) region_id (value)\n"
-			"    Set the mapping of User Priority to "
-			"queue region on a port\n\n"
-
-			"set port (port_id) queue-region flush (on|off)\n"
-			"    flush all queue region related configuration\n\n"
-
 			"show port meter cap (port_id)\n"
 			"    Show port meter capability information\n\n"
 
@@ -702,9 +636,6 @@  static void cmd_help_long_parsed(void *parsed_result,
 			"set port meter stats mask (port_id) (mtr_id) (stats_mask)\n"
 			"    meter update stats\n\n"
 
-			"show port (port_id) queue-region\n"
-			"    show all queue region related configuration info\n\n"
-
 			"set port (port_id) fec_mode auto|off|rs|baser\n"
 			"    set fec mode for a specific port\n\n"
 
@@ -801,22 +732,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) pctype mapping reset\n"
-			"    Reset flow type to pctype mapping on a port\n\n"
-
-			"port config (port_id) pctype mapping update"
-			" (pctype_id_0[,pctype_id_1]*) (flow_type_id)\n"
-			"    Update a flow type to pctype mapping item on a port\n\n"
-
-			"port config (port_id) pctype (pctype_id) hash_inset|"
-			"fdir_inset|fdir_flx_inset get|set|clear field\n"
-			" (field_idx)\n"
-			"    Configure RSS|FDIR|FDIR_FLX input set for some pctype\n\n"
-
-			"port config (port_id) pctype (pctype_id) hash_inset|"
-			"fdir_inset|fdir_flx_inset clear all"
-			"    Clear RSS|FDIR|FDIR_FLX input set completely for some pctype\n\n"
-
 			"port config (port_id) udp_tunnel_port add|rm vxlan|geneve|ecpri (udp_port)\n\n"
 			"    Add/remove UDP tunnel port for tunneling offload\n\n"
 
@@ -912,13 +827,6 @@  static void cmd_help_long_parsed(void *parsed_result,
 			"filters:\n"
 			"--------\n\n"
 
-#ifdef RTE_NET_I40E
-			"flow_director_filter (port_id) mode raw (add|del|update)"
-			" flow (flow_id) (drop|fwd) queue (queue_id)"
-			" fd_id (fd_id_value) packet (packet file name)\n"
-			"    Add/Del a raw type flow director filter.\n\n"
-#endif
-
 			"flow_director_mask (port_id) mode IP vlan (vlan_value)"
 			" src_mask (ipv4_src) (ipv6_src) (src_port)"
 			" dst_mask (ipv4_dst) (ipv6_dst) (dst_port)\n"
@@ -9090,450 +8998,6 @@  static cmdline_parse_inst_t cmd_dump_one = {
 	},
 };
 
-/* *** queue region set *** */
-struct cmd_queue_region_result {
-	cmdline_fixed_string_t set;
-	cmdline_fixed_string_t port;
-	portid_t port_id;
-	cmdline_fixed_string_t cmd;
-	cmdline_fixed_string_t region;
-	uint8_t  region_id;
-	cmdline_fixed_string_t queue_start_index;
-	uint8_t  queue_id;
-	cmdline_fixed_string_t queue_num;
-	uint8_t  queue_num_value;
-};
-
-static void
-cmd_queue_region_parsed(void *parsed_result,
-			__rte_unused struct cmdline *cl,
-			__rte_unused void *data)
-{
-	struct cmd_queue_region_result *res = parsed_result;
-	int ret = -ENOTSUP;
-#ifdef RTE_NET_I40E
-	struct rte_pmd_i40e_queue_region_conf region_conf;
-	enum rte_pmd_i40e_queue_region_op op_type;
-#endif
-
-	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
-		return;
-
-#ifdef RTE_NET_I40E
-	memset(&region_conf, 0, sizeof(region_conf));
-	op_type = RTE_PMD_I40E_RSS_QUEUE_REGION_SET;
-	region_conf.region_id = res->region_id;
-	region_conf.queue_num = res->queue_num_value;
-	region_conf.queue_start_index = res->queue_id;
-
-	ret = rte_pmd_i40e_rss_queue_region_conf(res->port_id,
-				op_type, &region_conf);
-#endif
-
-	switch (ret) {
-	case 0:
-		break;
-	case -ENOTSUP:
-		fprintf(stderr, "function not implemented or supported\n");
-		break;
-	default:
-		fprintf(stderr, "queue region config error: (%s)\n",
-			strerror(-ret));
-	}
-}
-
-static cmdline_parse_token_string_t cmd_queue_region_set =
-TOKEN_STRING_INITIALIZER(struct cmd_queue_region_result,
-		set, "set");
-static cmdline_parse_token_string_t cmd_queue_region_port =
-	TOKEN_STRING_INITIALIZER(struct cmd_queue_region_result, port, "port");
-static cmdline_parse_token_num_t cmd_queue_region_port_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_queue_region_result,
-				port_id, RTE_UINT16);
-static cmdline_parse_token_string_t cmd_queue_region_cmd =
-	TOKEN_STRING_INITIALIZER(struct cmd_queue_region_result,
-				 cmd, "queue-region");
-static cmdline_parse_token_string_t cmd_queue_region_id =
-	TOKEN_STRING_INITIALIZER(struct cmd_queue_region_result,
-				region, "region_id");
-static cmdline_parse_token_num_t cmd_queue_region_index =
-	TOKEN_NUM_INITIALIZER(struct cmd_queue_region_result,
-				region_id, RTE_UINT8);
-static cmdline_parse_token_string_t cmd_queue_region_queue_start_index =
-	TOKEN_STRING_INITIALIZER(struct cmd_queue_region_result,
-				queue_start_index, "queue_start_index");
-static cmdline_parse_token_num_t cmd_queue_region_queue_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_queue_region_result,
-				queue_id, RTE_UINT8);
-static cmdline_parse_token_string_t cmd_queue_region_queue_num =
-	TOKEN_STRING_INITIALIZER(struct cmd_queue_region_result,
-				queue_num, "queue_num");
-static cmdline_parse_token_num_t cmd_queue_region_queue_num_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_queue_region_result,
-				queue_num_value, RTE_UINT8);
-
-static cmdline_parse_inst_t cmd_queue_region = {
-	.f = cmd_queue_region_parsed,
-	.data = NULL,
-	.help_str = "set port <port_id> queue-region region_id <value> "
-		"queue_start_index <value> queue_num <value>: Set a queue region",
-	.tokens = {
-		(void *)&cmd_queue_region_set,
-		(void *)&cmd_queue_region_port,
-		(void *)&cmd_queue_region_port_id,
-		(void *)&cmd_queue_region_cmd,
-		(void *)&cmd_queue_region_id,
-		(void *)&cmd_queue_region_index,
-		(void *)&cmd_queue_region_queue_start_index,
-		(void *)&cmd_queue_region_queue_id,
-		(void *)&cmd_queue_region_queue_num,
-		(void *)&cmd_queue_region_queue_num_value,
-		NULL,
-	},
-};
-
-/* *** queue region and flowtype set *** */
-struct cmd_region_flowtype_result {
-	cmdline_fixed_string_t set;
-	cmdline_fixed_string_t port;
-	portid_t port_id;
-	cmdline_fixed_string_t cmd;
-	cmdline_fixed_string_t region;
-	uint8_t  region_id;
-	cmdline_fixed_string_t flowtype;
-	uint8_t  flowtype_id;
-};
-
-static void
-cmd_region_flowtype_parsed(void *parsed_result,
-			__rte_unused struct cmdline *cl,
-			__rte_unused void *data)
-{
-	struct cmd_region_flowtype_result *res = parsed_result;
-	int ret = -ENOTSUP;
-#ifdef RTE_NET_I40E
-	struct rte_pmd_i40e_queue_region_conf region_conf;
-	enum rte_pmd_i40e_queue_region_op op_type;
-#endif
-
-	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
-		return;
-
-#ifdef RTE_NET_I40E
-	memset(&region_conf, 0, sizeof(region_conf));
-
-	op_type = RTE_PMD_I40E_RSS_QUEUE_REGION_FLOWTYPE_SET;
-	region_conf.region_id = res->region_id;
-	region_conf.hw_flowtype = res->flowtype_id;
-
-	ret = rte_pmd_i40e_rss_queue_region_conf(res->port_id,
-			op_type, &region_conf);
-#endif
-
-	switch (ret) {
-	case 0:
-		break;
-	case -ENOTSUP:
-		fprintf(stderr, "function not implemented or supported\n");
-		break;
-	default:
-		fprintf(stderr, "region flowtype config error: (%s)\n",
-			strerror(-ret));
-	}
-}
-
-static cmdline_parse_token_string_t cmd_region_flowtype_set =
-TOKEN_STRING_INITIALIZER(struct cmd_region_flowtype_result,
-				set, "set");
-static cmdline_parse_token_string_t cmd_region_flowtype_port =
-	TOKEN_STRING_INITIALIZER(struct cmd_region_flowtype_result,
-				port, "port");
-static cmdline_parse_token_num_t cmd_region_flowtype_port_index =
-	TOKEN_NUM_INITIALIZER(struct cmd_region_flowtype_result,
-				port_id, RTE_UINT16);
-static cmdline_parse_token_string_t cmd_region_flowtype_cmd =
-	TOKEN_STRING_INITIALIZER(struct cmd_region_flowtype_result,
-				cmd, "queue-region");
-static cmdline_parse_token_string_t cmd_region_flowtype_index =
-	TOKEN_STRING_INITIALIZER(struct cmd_region_flowtype_result,
-				region, "region_id");
-static cmdline_parse_token_num_t cmd_region_flowtype_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_region_flowtype_result,
-				region_id, RTE_UINT8);
-static cmdline_parse_token_string_t cmd_region_flowtype_flow_index =
-	TOKEN_STRING_INITIALIZER(struct cmd_region_flowtype_result,
-				flowtype, "flowtype");
-static cmdline_parse_token_num_t cmd_region_flowtype_flow_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_region_flowtype_result,
-				flowtype_id, RTE_UINT8);
-static cmdline_parse_inst_t cmd_region_flowtype = {
-	.f = cmd_region_flowtype_parsed,
-	.data = NULL,
-	.help_str = "set port <port_id> queue-region region_id <value> "
-		"flowtype <value>: Set a flowtype region index",
-	.tokens = {
-		(void *)&cmd_region_flowtype_set,
-		(void *)&cmd_region_flowtype_port,
-		(void *)&cmd_region_flowtype_port_index,
-		(void *)&cmd_region_flowtype_cmd,
-		(void *)&cmd_region_flowtype_index,
-		(void *)&cmd_region_flowtype_id,
-		(void *)&cmd_region_flowtype_flow_index,
-		(void *)&cmd_region_flowtype_flow_id,
-		NULL,
-	},
-};
-
-/* *** User Priority (UP) to queue region (region_id) set *** */
-struct cmd_user_priority_region_result {
-	cmdline_fixed_string_t set;
-	cmdline_fixed_string_t port;
-	portid_t port_id;
-	cmdline_fixed_string_t cmd;
-	cmdline_fixed_string_t user_priority;
-	uint8_t  user_priority_id;
-	cmdline_fixed_string_t region;
-	uint8_t  region_id;
-};
-
-static void
-cmd_user_priority_region_parsed(void *parsed_result,
-			__rte_unused struct cmdline *cl,
-			__rte_unused void *data)
-{
-	struct cmd_user_priority_region_result *res = parsed_result;
-	int ret = -ENOTSUP;
-#ifdef RTE_NET_I40E
-	struct rte_pmd_i40e_queue_region_conf region_conf;
-	enum rte_pmd_i40e_queue_region_op op_type;
-#endif
-
-	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
-		return;
-
-#ifdef RTE_NET_I40E
-	memset(&region_conf, 0, sizeof(region_conf));
-	op_type = RTE_PMD_I40E_RSS_QUEUE_REGION_USER_PRIORITY_SET;
-	region_conf.user_priority = res->user_priority_id;
-	region_conf.region_id = res->region_id;
-
-	ret = rte_pmd_i40e_rss_queue_region_conf(res->port_id,
-				op_type, &region_conf);
-#endif
-
-	switch (ret) {
-	case 0:
-		break;
-	case -ENOTSUP:
-		fprintf(stderr, "function not implemented or supported\n");
-		break;
-	default:
-		fprintf(stderr, "user_priority region config error: (%s)\n",
-			strerror(-ret));
-	}
-}
-
-static cmdline_parse_token_string_t cmd_user_priority_region_set =
-	TOKEN_STRING_INITIALIZER(struct cmd_user_priority_region_result,
-				set, "set");
-static cmdline_parse_token_string_t cmd_user_priority_region_port =
-	TOKEN_STRING_INITIALIZER(struct cmd_user_priority_region_result,
-				port, "port");
-static cmdline_parse_token_num_t cmd_user_priority_region_port_index =
-	TOKEN_NUM_INITIALIZER(struct cmd_user_priority_region_result,
-				port_id, RTE_UINT16);
-static cmdline_parse_token_string_t cmd_user_priority_region_cmd =
-	TOKEN_STRING_INITIALIZER(struct cmd_user_priority_region_result,
-				cmd, "queue-region");
-static cmdline_parse_token_string_t cmd_user_priority_region_UP =
-	TOKEN_STRING_INITIALIZER(struct cmd_user_priority_region_result,
-				user_priority, "UP");
-static cmdline_parse_token_num_t cmd_user_priority_region_UP_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_user_priority_region_result,
-				user_priority_id, RTE_UINT8);
-static cmdline_parse_token_string_t cmd_user_priority_region_region =
-	TOKEN_STRING_INITIALIZER(struct cmd_user_priority_region_result,
-				region, "region_id");
-static cmdline_parse_token_num_t cmd_user_priority_region_region_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_user_priority_region_result,
-				region_id, RTE_UINT8);
-
-static cmdline_parse_inst_t cmd_user_priority_region = {
-	.f = cmd_user_priority_region_parsed,
-	.data = NULL,
-	.help_str = "set port <port_id> queue-region UP <value> "
-		"region_id <value>: Set the mapping of User Priority (UP) "
-		"to queue region (region_id) ",
-	.tokens = {
-		(void *)&cmd_user_priority_region_set,
-		(void *)&cmd_user_priority_region_port,
-		(void *)&cmd_user_priority_region_port_index,
-		(void *)&cmd_user_priority_region_cmd,
-		(void *)&cmd_user_priority_region_UP,
-		(void *)&cmd_user_priority_region_UP_id,
-		(void *)&cmd_user_priority_region_region,
-		(void *)&cmd_user_priority_region_region_id,
-		NULL,
-	},
-};
-
-/* *** flush all queue region related configuration *** */
-struct cmd_flush_queue_region_result {
-	cmdline_fixed_string_t set;
-	cmdline_fixed_string_t port;
-	portid_t port_id;
-	cmdline_fixed_string_t cmd;
-	cmdline_fixed_string_t flush;
-	cmdline_fixed_string_t what;
-};
-
-static void
-cmd_flush_queue_region_parsed(void *parsed_result,
-			__rte_unused struct cmdline *cl,
-			__rte_unused void *data)
-{
-	struct cmd_flush_queue_region_result *res = parsed_result;
-	int ret = -ENOTSUP;
-#ifdef RTE_NET_I40E
-	struct rte_pmd_i40e_queue_region_conf region_conf;
-	enum rte_pmd_i40e_queue_region_op op_type;
-#endif
-
-	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
-		return;
-
-#ifdef RTE_NET_I40E
-	memset(&region_conf, 0, sizeof(region_conf));
-
-	if (strcmp(res->what, "on") == 0)
-		op_type = RTE_PMD_I40E_RSS_QUEUE_REGION_ALL_FLUSH_ON;
-	else
-		op_type = RTE_PMD_I40E_RSS_QUEUE_REGION_ALL_FLUSH_OFF;
-
-	ret = rte_pmd_i40e_rss_queue_region_conf(res->port_id,
-				op_type, &region_conf);
-#endif
-
-	switch (ret) {
-	case 0:
-		break;
-	case -ENOTSUP:
-		fprintf(stderr, "function not implemented or supported\n");
-		break;
-	default:
-		fprintf(stderr, "queue region config flush error: (%s)\n",
-			strerror(-ret));
-	}
-}
-
-static cmdline_parse_token_string_t cmd_flush_queue_region_set =
-	TOKEN_STRING_INITIALIZER(struct cmd_flush_queue_region_result,
-				set, "set");
-static cmdline_parse_token_string_t cmd_flush_queue_region_port =
-	TOKEN_STRING_INITIALIZER(struct cmd_flush_queue_region_result,
-				port, "port");
-static cmdline_parse_token_num_t cmd_flush_queue_region_port_index =
-	TOKEN_NUM_INITIALIZER(struct cmd_flush_queue_region_result,
-				port_id, RTE_UINT16);
-static cmdline_parse_token_string_t cmd_flush_queue_region_cmd =
-	TOKEN_STRING_INITIALIZER(struct cmd_flush_queue_region_result,
-				cmd, "queue-region");
-static cmdline_parse_token_string_t cmd_flush_queue_region_flush =
-	TOKEN_STRING_INITIALIZER(struct cmd_flush_queue_region_result,
-				flush, "flush");
-static cmdline_parse_token_string_t cmd_flush_queue_region_what =
-	TOKEN_STRING_INITIALIZER(struct cmd_flush_queue_region_result,
-				what, "on#off");
-
-static cmdline_parse_inst_t cmd_flush_queue_region = {
-	.f = cmd_flush_queue_region_parsed,
-	.data = NULL,
-	.help_str = "set port <port_id> queue-region flush on|off"
-		": flush all queue region related configuration",
-	.tokens = {
-		(void *)&cmd_flush_queue_region_set,
-		(void *)&cmd_flush_queue_region_port,
-		(void *)&cmd_flush_queue_region_port_index,
-		(void *)&cmd_flush_queue_region_cmd,
-		(void *)&cmd_flush_queue_region_flush,
-		(void *)&cmd_flush_queue_region_what,
-		NULL,
-	},
-};
-
-/* *** get all queue region related configuration info *** */
-struct cmd_show_queue_region_info {
-	cmdline_fixed_string_t show;
-	cmdline_fixed_string_t port;
-	portid_t port_id;
-	cmdline_fixed_string_t cmd;
-};
-
-static void
-cmd_show_queue_region_info_parsed(void *parsed_result,
-			__rte_unused struct cmdline *cl,
-			__rte_unused void *data)
-{
-	struct cmd_show_queue_region_info *res = parsed_result;
-	int ret = -ENOTSUP;
-#ifdef RTE_NET_I40E
-	struct rte_pmd_i40e_queue_regions rte_pmd_regions;
-	enum rte_pmd_i40e_queue_region_op op_type;
-#endif
-
-	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
-		return;
-
-#ifdef RTE_NET_I40E
-	memset(&rte_pmd_regions, 0, sizeof(rte_pmd_regions));
-
-	op_type = RTE_PMD_I40E_RSS_QUEUE_REGION_INFO_GET;
-
-	ret = rte_pmd_i40e_rss_queue_region_conf(res->port_id,
-					op_type, &rte_pmd_regions);
-
-	port_queue_region_info_display(res->port_id, &rte_pmd_regions);
-#endif
-
-	switch (ret) {
-	case 0:
-		break;
-	case -ENOTSUP:
-		fprintf(stderr, "function not implemented or supported\n");
-		break;
-	default:
-		fprintf(stderr, "queue region config info show error: (%s)\n",
-			strerror(-ret));
-	}
-}
-
-static cmdline_parse_token_string_t cmd_show_queue_region_info_get =
-TOKEN_STRING_INITIALIZER(struct cmd_show_queue_region_info,
-				show, "show");
-static cmdline_parse_token_string_t cmd_show_queue_region_info_port =
-	TOKEN_STRING_INITIALIZER(struct cmd_show_queue_region_info,
-				port, "port");
-static cmdline_parse_token_num_t cmd_show_queue_region_info_port_index =
-	TOKEN_NUM_INITIALIZER(struct cmd_show_queue_region_info,
-				port_id, RTE_UINT16);
-static cmdline_parse_token_string_t cmd_show_queue_region_info_cmd =
-	TOKEN_STRING_INITIALIZER(struct cmd_show_queue_region_info,
-				cmd, "queue-region");
-
-static cmdline_parse_inst_t cmd_show_queue_region_info_all = {
-	.f = cmd_show_queue_region_info_parsed,
-	.data = NULL,
-	.help_str = "show port <port_id> queue-region"
-		": show all queue region related configuration info",
-	.tokens = {
-		(void *)&cmd_show_queue_region_info_get,
-		(void *)&cmd_show_queue_region_info_port,
-		(void *)&cmd_show_queue_region_info_port_index,
-		(void *)&cmd_show_queue_region_info_cmd,
-		NULL,
-	},
-};
-
 /* *** Filters Control *** */
 
 #define IPV4_ADDR_TO_UINT(ip_addr, ip) \
@@ -9558,197 +9022,9 @@  do { \
 	} \
 } while (0)
 
-#ifdef RTE_NET_I40E
-
-static uint16_t
-str2flowtype(char *string)
-{
-	uint8_t i = 0;
-	static const struct {
-		char str[32];
-		uint16_t type;
-	} flowtype_str[] = {
-		{"raw", RTE_ETH_FLOW_RAW},
-		{"ipv4", RTE_ETH_FLOW_IPV4},
-		{"ipv4-frag", RTE_ETH_FLOW_FRAG_IPV4},
-		{"ipv4-tcp", RTE_ETH_FLOW_NONFRAG_IPV4_TCP},
-		{"ipv4-udp", RTE_ETH_FLOW_NONFRAG_IPV4_UDP},
-		{"ipv4-sctp", RTE_ETH_FLOW_NONFRAG_IPV4_SCTP},
-		{"ipv4-other", RTE_ETH_FLOW_NONFRAG_IPV4_OTHER},
-		{"ipv6", RTE_ETH_FLOW_IPV6},
-		{"ipv6-frag", RTE_ETH_FLOW_FRAG_IPV6},
-		{"ipv6-tcp", RTE_ETH_FLOW_NONFRAG_IPV6_TCP},
-		{"ipv6-udp", RTE_ETH_FLOW_NONFRAG_IPV6_UDP},
-		{"ipv6-sctp", RTE_ETH_FLOW_NONFRAG_IPV6_SCTP},
-		{"ipv6-other", RTE_ETH_FLOW_NONFRAG_IPV6_OTHER},
-		{"l2_payload", RTE_ETH_FLOW_L2_PAYLOAD},
-		{"ipv6-ex", RTE_ETH_FLOW_IPV6_EX},
-		{"ipv6-tcp-ex", RTE_ETH_FLOW_IPV6_TCP_EX},
-		{"ipv6-udp-ex", RTE_ETH_FLOW_IPV6_UDP_EX},
-		{"gtpu", RTE_ETH_FLOW_GTPU},
-	};
-
-	for (i = 0; i < RTE_DIM(flowtype_str); i++) {
-		if (!strcmp(flowtype_str[i].str, string))
-			return flowtype_str[i].type;
-	}
-
-	if (isdigit(string[0]) && atoi(string) > 0 && atoi(string) < 64)
-		return (uint16_t)atoi(string);
-
-	return RTE_ETH_FLOW_UNKNOWN;
-}
-
-/* *** deal with flow director filter *** */
-struct cmd_flow_director_result {
-	cmdline_fixed_string_t flow_director_filter;
-	portid_t port_id;
-	cmdline_fixed_string_t mode;
-	cmdline_fixed_string_t mode_value;
-	cmdline_fixed_string_t ops;
-	cmdline_fixed_string_t flow;
-	cmdline_fixed_string_t flow_type;
-	cmdline_fixed_string_t drop;
-	cmdline_fixed_string_t queue;
-	uint16_t  queue_id;
-	cmdline_fixed_string_t fd_id;
-	uint32_t  fd_id_value;
-	cmdline_fixed_string_t packet;
-	char filepath[];
-};
-
-static void
-cmd_flow_director_filter_parsed(void *parsed_result,
-			  __rte_unused struct cmdline *cl,
-			  __rte_unused void *data)
-{
-	struct cmd_flow_director_result *res = parsed_result;
-	int ret = 0;
-	struct rte_pmd_i40e_flow_type_mapping
-			mapping[RTE_PMD_I40E_FLOW_TYPE_MAX];
-	struct rte_pmd_i40e_pkt_template_conf conf;
-	uint16_t flow_type = str2flowtype(res->flow_type);
-	uint16_t i, port = res->port_id;
-	uint8_t add;
-
-	memset(&conf, 0, sizeof(conf));
-
-	if (flow_type == RTE_ETH_FLOW_UNKNOWN) {
-		fprintf(stderr, "Invalid flow type specified.\n");
-		return;
-	}
-	ret = rte_pmd_i40e_flow_type_mapping_get(res->port_id,
-						 mapping);
-	if (ret)
-		return;
-	if (mapping[flow_type].pctype == 0ULL) {
-		fprintf(stderr, "Invalid flow type specified.\n");
-		return;
-	}
-	for (i = 0; i < RTE_PMD_I40E_PCTYPE_MAX; i++) {
-		if (mapping[flow_type].pctype & (1ULL << i)) {
-			conf.input.pctype = i;
-			break;
-		}
-	}
-
-	conf.input.packet = open_file(res->filepath,
-				&conf.input.length);
-	if (!conf.input.packet)
-		return;
-	if (!strcmp(res->drop, "drop"))
-		conf.action.behavior =
-			RTE_PMD_I40E_PKT_TEMPLATE_REJECT;
-	else
-		conf.action.behavior =
-			RTE_PMD_I40E_PKT_TEMPLATE_ACCEPT;
-	conf.action.report_status =
-			RTE_PMD_I40E_PKT_TEMPLATE_REPORT_ID;
-	conf.action.rx_queue = res->queue_id;
-	conf.soft_id = res->fd_id_value;
-	add  = strcmp(res->ops, "del") ? 1 : 0;
-	ret = rte_pmd_i40e_flow_add_del_packet_template(port,
-							&conf,
-							add);
-	if (ret < 0)
-		fprintf(stderr, "flow director config error: (%s)\n",
-			strerror(-ret));
-	close_file(conf.input.packet);
-}
-
-static cmdline_parse_token_string_t cmd_flow_director_filter =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
-				 flow_director_filter, "flow_director_filter");
-static cmdline_parse_token_num_t cmd_flow_director_port_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
-			      port_id, RTE_UINT16);
-static cmdline_parse_token_string_t cmd_flow_director_ops =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
-				 ops, "add#del#update");
-static cmdline_parse_token_string_t cmd_flow_director_flow =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
-				 flow, "flow");
-static cmdline_parse_token_string_t cmd_flow_director_flow_type =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
-		flow_type, NULL);
-static cmdline_parse_token_string_t cmd_flow_director_drop =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
-				 drop, "drop#fwd");
-static cmdline_parse_token_string_t cmd_flow_director_queue =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
-				 queue, "queue");
-static cmdline_parse_token_num_t cmd_flow_director_queue_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
-			      queue_id, RTE_UINT16);
-static cmdline_parse_token_string_t cmd_flow_director_fd_id =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
-				 fd_id, "fd_id");
-static cmdline_parse_token_num_t cmd_flow_director_fd_id_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
-			      fd_id_value, RTE_UINT32);
-
-static cmdline_parse_token_string_t cmd_flow_director_mode =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
-				 mode, "mode");
-static cmdline_parse_token_string_t cmd_flow_director_mode_raw =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
-				 mode_value, "raw");
-static cmdline_parse_token_string_t cmd_flow_director_packet =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
-				 packet, "packet");
-static cmdline_parse_token_string_t cmd_flow_director_filepath =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
-				 filepath, NULL);
-
-static cmdline_parse_inst_t cmd_add_del_raw_flow_director = {
-	.f = cmd_flow_director_filter_parsed,
-	.data = NULL,
-	.help_str = "flow_director_filter ... : Add or delete a raw flow "
-		"director entry on NIC",
-	.tokens = {
-		(void *)&cmd_flow_director_filter,
-		(void *)&cmd_flow_director_port_id,
-		(void *)&cmd_flow_director_mode,
-		(void *)&cmd_flow_director_mode_raw,
-		(void *)&cmd_flow_director_ops,
-		(void *)&cmd_flow_director_flow,
-		(void *)&cmd_flow_director_flow_type,
-		(void *)&cmd_flow_director_drop,
-		(void *)&cmd_flow_director_queue,
-		(void *)&cmd_flow_director_queue_id,
-		(void *)&cmd_flow_director_fd_id,
-		(void *)&cmd_flow_director_fd_id_value,
-		(void *)&cmd_flow_director_packet,
-		(void *)&cmd_flow_director_filepath,
-		NULL,
-	},
-};
-
-#endif /* RTE_NET_I40E */
-
-/* *** deal with flow director mask *** */
-struct cmd_flow_director_mask_result {
-	cmdline_fixed_string_t flow_director_mask;
+/* *** deal with flow director mask *** */
+struct cmd_flow_director_mask_result {
+	cmdline_fixed_string_t flow_director_mask;
 	portid_t port_id;
 	cmdline_fixed_string_t mode;
 	cmdline_fixed_string_t mode_value;
@@ -11355,249 +10631,121 @@  static cmdline_parse_inst_t cmd_set_macsec_sa = {
 	},
 };
 
-/* VF unicast promiscuous mode configuration */
-
-/* Common result structure for VF unicast promiscuous mode */
-struct cmd_vf_promisc_result {
+/* Common definition of VF and TC TX bandwidth configuration */
+struct cmd_vf_tc_bw_result {
 	cmdline_fixed_string_t set;
-	cmdline_fixed_string_t vf;
-	cmdline_fixed_string_t promisc;
+	cmdline_fixed_string_t tc;
+	cmdline_fixed_string_t tx;
+	cmdline_fixed_string_t min_bw;
 	portid_t port_id;
-	uint32_t vf_id;
-	cmdline_fixed_string_t on_off;
+	cmdline_fixed_string_t bw_list;
 };
 
-/* Common CLI fields for VF unicast promiscuous mode enable disable */
-static cmdline_parse_token_string_t cmd_vf_promisc_set =
+static cmdline_parse_token_string_t cmd_vf_tc_bw_set =
 	TOKEN_STRING_INITIALIZER
-		(struct cmd_vf_promisc_result,
+		(struct cmd_vf_tc_bw_result,
 		 set, "set");
-static cmdline_parse_token_string_t cmd_vf_promisc_vf =
+static cmdline_parse_token_string_t cmd_vf_tc_bw_tc =
 	TOKEN_STRING_INITIALIZER
-		(struct cmd_vf_promisc_result,
-		 vf, "vf");
-static cmdline_parse_token_string_t cmd_vf_promisc_promisc =
+		(struct cmd_vf_tc_bw_result,
+		 tc, "tc");
+static cmdline_parse_token_string_t cmd_vf_tc_bw_tx =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_vf_tc_bw_result,
+		 tx, "tx");
+static cmdline_parse_token_string_t cmd_vf_tc_bw_min_bw =
 	TOKEN_STRING_INITIALIZER
-		(struct cmd_vf_promisc_result,
-		 promisc, "promisc");
-static cmdline_parse_token_num_t cmd_vf_promisc_port_id =
+		(struct cmd_vf_tc_bw_result,
+		 min_bw, "min-bandwidth");
+static cmdline_parse_token_num_t cmd_vf_tc_bw_port_id =
 	TOKEN_NUM_INITIALIZER
-		(struct cmd_vf_promisc_result,
+		(struct cmd_vf_tc_bw_result,
 		 port_id, RTE_UINT16);
-static cmdline_parse_token_num_t cmd_vf_promisc_vf_id =
-	TOKEN_NUM_INITIALIZER
-		(struct cmd_vf_promisc_result,
-		 vf_id, RTE_UINT32);
-static cmdline_parse_token_string_t cmd_vf_promisc_on_off =
+static cmdline_parse_token_string_t cmd_vf_tc_bw_bw_list =
 	TOKEN_STRING_INITIALIZER
-		(struct cmd_vf_promisc_result,
-		 on_off, "on#off");
+		(struct cmd_vf_tc_bw_result,
+		 bw_list, NULL);
 
-static void
-cmd_set_vf_promisc_parsed(
-	void *parsed_result,
-	__rte_unused struct cmdline *cl,
-	__rte_unused void *data)
+static int
+vf_tc_min_bw_parse_bw_list(uint8_t *bw_list,
+			   uint8_t *tc_num,
+			   char *str)
 {
-	struct cmd_vf_promisc_result *res = parsed_result;
-	int ret = -ENOTSUP;
-
-	__rte_unused int is_on = (strcmp(res->on_off, "on") == 0) ? 1 : 0;
-
-	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
-		return;
-
-#ifdef RTE_NET_I40E
-	ret = rte_pmd_i40e_set_vf_unicast_promisc(res->port_id,
-						  res->vf_id, is_on);
-#endif
+	uint32_t size;
+	const char *p, *p0 = str;
+	char s[256];
+	char *end;
+	char *str_fld[16];
+	uint16_t i;
+	int ret;
 
-	switch (ret) {
-	case 0:
-		break;
-	case -EINVAL:
-		fprintf(stderr, "invalid vf_id %d\n", res->vf_id);
-		break;
-	case -ENODEV:
-		fprintf(stderr, "invalid port_id %d\n", res->port_id);
-		break;
-	case -ENOTSUP:
-		fprintf(stderr, "function not implemented\n");
-		break;
-	default:
-		fprintf(stderr, "programming error: (%s)\n", strerror(-ret));
+	p = strchr(p0, '(');
+	if (p == NULL) {
+		fprintf(stderr,
+			"The bandwidth-list should be '(bw1, bw2, ...)'\n");
+		return -1;
 	}
-}
-
-static cmdline_parse_inst_t cmd_set_vf_promisc = {
-	.f = cmd_set_vf_promisc_parsed,
-	.data = NULL,
-	.help_str = "set vf promisc <port_id> <vf_id> on|off: "
-		"Set unicast promiscuous mode for a VF from the PF",
-	.tokens = {
-		(void *)&cmd_vf_promisc_set,
-		(void *)&cmd_vf_promisc_vf,
-		(void *)&cmd_vf_promisc_promisc,
-		(void *)&cmd_vf_promisc_port_id,
-		(void *)&cmd_vf_promisc_vf_id,
-		(void *)&cmd_vf_promisc_on_off,
-		NULL,
-	},
-};
-
-/* VF multicast promiscuous mode configuration */
-
-/* Common result structure for VF multicast promiscuous mode */
-struct cmd_vf_allmulti_result {
-	cmdline_fixed_string_t set;
-	cmdline_fixed_string_t vf;
-	cmdline_fixed_string_t allmulti;
-	portid_t port_id;
-	uint32_t vf_id;
-	cmdline_fixed_string_t on_off;
-};
+	p++;
+	p0 = strchr(p, ')');
+	if (p0 == NULL) {
+		fprintf(stderr,
+			"The bandwidth-list should be '(bw1, bw2, ...)'\n");
+		return -1;
+	}
+	size = p0 - p;
+	if (size >= sizeof(s)) {
+		fprintf(stderr,
+			"The string size exceeds the internal buffer size\n");
+		return -1;
+	}
+	snprintf(s, sizeof(s), "%.*s", size, p);
+	ret = rte_strsplit(s, sizeof(s), str_fld, 16, ',');
+	if (ret <= 0) {
+		fprintf(stderr, "Failed to get the bandwidth list.\n");
+		return -1;
+	}
+	*tc_num = ret;
+	for (i = 0; i < ret; i++)
+		bw_list[i] = (uint8_t)strtoul(str_fld[i], &end, 0);
 
-/* Common CLI fields for VF multicast promiscuous mode enable disable */
-static cmdline_parse_token_string_t cmd_vf_allmulti_set =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_vf_allmulti_result,
-		 set, "set");
-static cmdline_parse_token_string_t cmd_vf_allmulti_vf =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_vf_allmulti_result,
-		 vf, "vf");
-static cmdline_parse_token_string_t cmd_vf_allmulti_allmulti =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_vf_allmulti_result,
-		 allmulti, "allmulti");
-static cmdline_parse_token_num_t cmd_vf_allmulti_port_id =
-	TOKEN_NUM_INITIALIZER
-		(struct cmd_vf_allmulti_result,
-		 port_id, RTE_UINT16);
-static cmdline_parse_token_num_t cmd_vf_allmulti_vf_id =
-	TOKEN_NUM_INITIALIZER
-		(struct cmd_vf_allmulti_result,
-		 vf_id, RTE_UINT32);
-static cmdline_parse_token_string_t cmd_vf_allmulti_on_off =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_vf_allmulti_result,
-		 on_off, "on#off");
+	return 0;
+}
 
 static void
-cmd_set_vf_allmulti_parsed(
+cmd_tc_min_bw_parsed(
 	void *parsed_result,
 	__rte_unused struct cmdline *cl,
 	__rte_unused void *data)
 {
-	struct cmd_vf_allmulti_result *res = parsed_result;
+	struct cmd_vf_tc_bw_result *res = parsed_result;
+	struct rte_port *port;
+	uint8_t tc_num;
+	uint8_t bw[16];
 	int ret = -ENOTSUP;
 
-	__rte_unused int is_on = (strcmp(res->on_off, "on") == 0) ? 1 : 0;
-
 	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
 		return;
 
-#ifdef RTE_NET_I40E
-	ret = rte_pmd_i40e_set_vf_multicast_promisc(res->port_id,
-						    res->vf_id, is_on);
-#endif
-
-	switch (ret) {
-	case 0:
-		break;
-	case -EINVAL:
-		fprintf(stderr, "invalid vf_id %d\n", res->vf_id);
-		break;
-	case -ENODEV:
-		fprintf(stderr, "invalid port_id %d\n", res->port_id);
-		break;
-	case -ENOTSUP:
-		fprintf(stderr, "function not implemented\n");
-		break;
-	default:
-		fprintf(stderr, "programming error: (%s)\n", strerror(-ret));
+	port = &ports[res->port_id];
+	/** Check if the port is not started **/
+	if (port->port_status != RTE_PORT_STOPPED) {
+		fprintf(stderr, "Please stop port %d first\n", res->port_id);
+		return;
 	}
-}
-
-static cmdline_parse_inst_t cmd_set_vf_allmulti = {
-	.f = cmd_set_vf_allmulti_parsed,
-	.data = NULL,
-	.help_str = "set vf allmulti <port_id> <vf_id> on|off: "
-		"Set multicast promiscuous mode for a VF from the PF",
-	.tokens = {
-		(void *)&cmd_vf_allmulti_set,
-		(void *)&cmd_vf_allmulti_vf,
-		(void *)&cmd_vf_allmulti_allmulti,
-		(void *)&cmd_vf_allmulti_port_id,
-		(void *)&cmd_vf_allmulti_vf_id,
-		(void *)&cmd_vf_allmulti_on_off,
-		NULL,
-	},
-};
-
-/* vf broadcast mode configuration */
-
-/* Common result structure for vf broadcast */
-struct cmd_set_vf_broadcast_result {
-	cmdline_fixed_string_t set;
-	cmdline_fixed_string_t vf;
-	cmdline_fixed_string_t broadcast;
-	portid_t port_id;
-	uint16_t vf_id;
-	cmdline_fixed_string_t on_off;
-};
-
-/* Common CLI fields for vf broadcast enable disable */
-static cmdline_parse_token_string_t cmd_set_vf_broadcast_set =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_set_vf_broadcast_result,
-		 set, "set");
-static cmdline_parse_token_string_t cmd_set_vf_broadcast_vf =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_set_vf_broadcast_result,
-		 vf, "vf");
-static cmdline_parse_token_string_t cmd_set_vf_broadcast_broadcast =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_set_vf_broadcast_result,
-		 broadcast, "broadcast");
-static cmdline_parse_token_num_t cmd_set_vf_broadcast_port_id =
-	TOKEN_NUM_INITIALIZER
-		(struct cmd_set_vf_broadcast_result,
-		 port_id, RTE_UINT16);
-static cmdline_parse_token_num_t cmd_set_vf_broadcast_vf_id =
-	TOKEN_NUM_INITIALIZER
-		(struct cmd_set_vf_broadcast_result,
-		 vf_id, RTE_UINT16);
-static cmdline_parse_token_string_t cmd_set_vf_broadcast_on_off =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_set_vf_broadcast_result,
-		 on_off, "on#off");
-
-static void
-cmd_set_vf_broadcast_parsed(
-	void *parsed_result,
-	__rte_unused struct cmdline *cl,
-	__rte_unused void *data)
-{
-	struct cmd_set_vf_broadcast_result *res = parsed_result;
-	int ret = -ENOTSUP;
 
-	__rte_unused int is_on = (strcmp(res->on_off, "on") == 0) ? 1 : 0;
-
-	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
+	ret = vf_tc_min_bw_parse_bw_list(bw, &tc_num, res->bw_list);
+	if (ret)
 		return;
 
-#ifdef RTE_NET_I40E
-	ret = rte_pmd_i40e_set_vf_broadcast(res->port_id,
-					    res->vf_id, is_on);
+#ifdef RTE_NET_IXGBE
+	ret = rte_pmd_ixgbe_set_tc_bw_alloc(res->port_id, tc_num, bw);
 #endif
 
 	switch (ret) {
 	case 0:
 		break;
 	case -EINVAL:
-		fprintf(stderr, "invalid vf_id %d or is_on %d\n",
-			res->vf_id, is_on);
+		fprintf(stderr, "invalid bandwidth\n");
 		break;
 	case -ENODEV:
 		fprintf(stderr, "invalid port_id %d\n", res->port_id);
@@ -11610,3200 +10758,1434 @@  cmd_set_vf_broadcast_parsed(
 	}
 }
 
-static cmdline_parse_inst_t cmd_set_vf_broadcast = {
-	.f = cmd_set_vf_broadcast_parsed,
+static cmdline_parse_inst_t cmd_tc_min_bw = {
+	.f = cmd_tc_min_bw_parsed,
 	.data = NULL,
-	.help_str = "set vf broadcast <port_id> <vf_id> on|off",
+	.help_str = "set tc tx min-bandwidth <port_id> <bw1, bw2, ...>",
 	.tokens = {
-		(void *)&cmd_set_vf_broadcast_set,
-		(void *)&cmd_set_vf_broadcast_vf,
-		(void *)&cmd_set_vf_broadcast_broadcast,
-		(void *)&cmd_set_vf_broadcast_port_id,
-		(void *)&cmd_set_vf_broadcast_vf_id,
-		(void *)&cmd_set_vf_broadcast_on_off,
+		(void *)&cmd_vf_tc_bw_set,
+		(void *)&cmd_vf_tc_bw_tc,
+		(void *)&cmd_vf_tc_bw_tx,
+		(void *)&cmd_vf_tc_bw_min_bw,
+		(void *)&cmd_vf_tc_bw_port_id,
+		(void *)&cmd_vf_tc_bw_bw_list,
 		NULL,
 	},
 };
 
-/* vf vlan tag configuration */
-
-/* Common result structure for vf vlan tag */
-struct cmd_set_vf_vlan_tag_result {
+/** Set VXLAN encapsulation details */
+struct cmd_set_vxlan_result {
 	cmdline_fixed_string_t set;
-	cmdline_fixed_string_t vf;
-	cmdline_fixed_string_t vlan;
-	cmdline_fixed_string_t tag;
-	portid_t port_id;
-	uint16_t vf_id;
-	cmdline_fixed_string_t on_off;
-};
-
-/* Common CLI fields for vf vlan tag enable disable */
-static cmdline_parse_token_string_t cmd_set_vf_vlan_tag_set =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_set_vf_vlan_tag_result,
-		 set, "set");
-static cmdline_parse_token_string_t cmd_set_vf_vlan_tag_vf =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_set_vf_vlan_tag_result,
-		 vf, "vf");
-static cmdline_parse_token_string_t cmd_set_vf_vlan_tag_vlan =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_set_vf_vlan_tag_result,
-		 vlan, "vlan");
-static cmdline_parse_token_string_t cmd_set_vf_vlan_tag_tag =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_set_vf_vlan_tag_result,
-		 tag, "tag");
-static cmdline_parse_token_num_t cmd_set_vf_vlan_tag_port_id =
-	TOKEN_NUM_INITIALIZER
-		(struct cmd_set_vf_vlan_tag_result,
-		 port_id, RTE_UINT16);
-static cmdline_parse_token_num_t cmd_set_vf_vlan_tag_vf_id =
-	TOKEN_NUM_INITIALIZER
-		(struct cmd_set_vf_vlan_tag_result,
-		 vf_id, RTE_UINT16);
-static cmdline_parse_token_string_t cmd_set_vf_vlan_tag_on_off =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_set_vf_vlan_tag_result,
-		 on_off, "on#off");
-
-static void
-cmd_set_vf_vlan_tag_parsed(
-	void *parsed_result,
-	__rte_unused struct cmdline *cl,
-	__rte_unused void *data)
-{
-	struct cmd_set_vf_vlan_tag_result *res = parsed_result;
-	int ret = -ENOTSUP;
-
-	__rte_unused int is_on = (strcmp(res->on_off, "on") == 0) ? 1 : 0;
-
-	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
-		return;
-
-#ifdef RTE_NET_I40E
-	ret = rte_pmd_i40e_set_vf_vlan_tag(res->port_id,
-					   res->vf_id, is_on);
-#endif
-
-	switch (ret) {
-	case 0:
-		break;
-	case -EINVAL:
-		fprintf(stderr, "invalid vf_id %d or is_on %d\n",
-			res->vf_id, is_on);
-		break;
-	case -ENODEV:
-		fprintf(stderr, "invalid port_id %d\n", res->port_id);
-		break;
-	case -ENOTSUP:
-		fprintf(stderr, "function not implemented\n");
-		break;
-	default:
-		fprintf(stderr, "programming error: (%s)\n", strerror(-ret));
-	}
-}
-
-static cmdline_parse_inst_t cmd_set_vf_vlan_tag = {
-	.f = cmd_set_vf_vlan_tag_parsed,
-	.data = NULL,
-	.help_str = "set vf vlan tag <port_id> <vf_id> on|off",
-	.tokens = {
-		(void *)&cmd_set_vf_vlan_tag_set,
-		(void *)&cmd_set_vf_vlan_tag_vf,
-		(void *)&cmd_set_vf_vlan_tag_vlan,
-		(void *)&cmd_set_vf_vlan_tag_tag,
-		(void *)&cmd_set_vf_vlan_tag_port_id,
-		(void *)&cmd_set_vf_vlan_tag_vf_id,
-		(void *)&cmd_set_vf_vlan_tag_on_off,
-		NULL,
-	},
-};
-
-/* Common definition of VF and TC TX bandwidth configuration */
-struct cmd_vf_tc_bw_result {
-	cmdline_fixed_string_t set;
-	cmdline_fixed_string_t vf;
-	cmdline_fixed_string_t tc;
-	cmdline_fixed_string_t tx;
-	cmdline_fixed_string_t min_bw;
-	cmdline_fixed_string_t max_bw;
-	cmdline_fixed_string_t strict_link_prio;
-	portid_t port_id;
-	uint16_t vf_id;
-	uint8_t tc_no;
-	uint32_t bw;
-	cmdline_fixed_string_t bw_list;
-	uint8_t tc_map;
-};
-
-static cmdline_parse_token_string_t cmd_vf_tc_bw_set =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_vf_tc_bw_result,
-		 set, "set");
-static cmdline_parse_token_string_t cmd_vf_tc_bw_vf =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_vf_tc_bw_result,
-		 vf, "vf");
-static cmdline_parse_token_string_t cmd_vf_tc_bw_tc =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_vf_tc_bw_result,
-		 tc, "tc");
-static cmdline_parse_token_string_t cmd_vf_tc_bw_tx =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_vf_tc_bw_result,
-		 tx, "tx");
-static cmdline_parse_token_string_t cmd_vf_tc_bw_strict_link_prio =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_vf_tc_bw_result,
-		 strict_link_prio, "strict-link-priority");
-static cmdline_parse_token_string_t cmd_vf_tc_bw_min_bw =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_vf_tc_bw_result,
-		 min_bw, "min-bandwidth");
-static cmdline_parse_token_string_t cmd_vf_tc_bw_max_bw =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_vf_tc_bw_result,
-		 max_bw, "max-bandwidth");
-static cmdline_parse_token_num_t cmd_vf_tc_bw_port_id =
-	TOKEN_NUM_INITIALIZER
-		(struct cmd_vf_tc_bw_result,
-		 port_id, RTE_UINT16);
-static cmdline_parse_token_num_t cmd_vf_tc_bw_vf_id =
-	TOKEN_NUM_INITIALIZER
-		(struct cmd_vf_tc_bw_result,
-		 vf_id, RTE_UINT16);
-static cmdline_parse_token_num_t cmd_vf_tc_bw_tc_no =
-	TOKEN_NUM_INITIALIZER
-		(struct cmd_vf_tc_bw_result,
-		 tc_no, RTE_UINT8);
-static cmdline_parse_token_num_t cmd_vf_tc_bw_bw =
-	TOKEN_NUM_INITIALIZER
-		(struct cmd_vf_tc_bw_result,
-		 bw, RTE_UINT32);
-static cmdline_parse_token_string_t cmd_vf_tc_bw_bw_list =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_vf_tc_bw_result,
-		 bw_list, NULL);
-static cmdline_parse_token_num_t cmd_vf_tc_bw_tc_map =
-	TOKEN_NUM_INITIALIZER
-		(struct cmd_vf_tc_bw_result,
-		 tc_map, RTE_UINT8);
-
-/* VF max bandwidth setting */
-static void
-cmd_vf_max_bw_parsed(
-	void *parsed_result,
-	__rte_unused struct cmdline *cl,
-	__rte_unused void *data)
-{
-	struct cmd_vf_tc_bw_result *res = parsed_result;
-	int ret = -ENOTSUP;
-
-	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
-		return;
-
-#ifdef RTE_NET_I40E
-	ret = rte_pmd_i40e_set_vf_max_bw(res->port_id,
-					 res->vf_id, res->bw);
-#endif
-
-	switch (ret) {
-	case 0:
-		break;
-	case -EINVAL:
-		fprintf(stderr, "invalid vf_id %d or bandwidth %d\n",
-			res->vf_id, res->bw);
-		break;
-	case -ENODEV:
-		fprintf(stderr, "invalid port_id %d\n", res->port_id);
-		break;
-	case -ENOTSUP:
-		fprintf(stderr, "function not implemented\n");
-		break;
-	default:
-		fprintf(stderr, "programming error: (%s)\n", strerror(-ret));
-	}
-}
-
-static cmdline_parse_inst_t cmd_vf_max_bw = {
-	.f = cmd_vf_max_bw_parsed,
-	.data = NULL,
-	.help_str = "set vf tx max-bandwidth <port_id> <vf_id> <bandwidth>",
-	.tokens = {
-		(void *)&cmd_vf_tc_bw_set,
-		(void *)&cmd_vf_tc_bw_vf,
-		(void *)&cmd_vf_tc_bw_tx,
-		(void *)&cmd_vf_tc_bw_max_bw,
-		(void *)&cmd_vf_tc_bw_port_id,
-		(void *)&cmd_vf_tc_bw_vf_id,
-		(void *)&cmd_vf_tc_bw_bw,
-		NULL,
-	},
-};
-
-static int
-vf_tc_min_bw_parse_bw_list(uint8_t *bw_list,
-			   uint8_t *tc_num,
-			   char *str)
-{
-	uint32_t size;
-	const char *p, *p0 = str;
-	char s[256];
-	char *end;
-	char *str_fld[16];
-	uint16_t i;
-	int ret;
-
-	p = strchr(p0, '(');
-	if (p == NULL) {
-		fprintf(stderr,
-			"The bandwidth-list should be '(bw1, bw2, ...)'\n");
-		return -1;
-	}
-	p++;
-	p0 = strchr(p, ')');
-	if (p0 == NULL) {
-		fprintf(stderr,
-			"The bandwidth-list should be '(bw1, bw2, ...)'\n");
-		return -1;
-	}
-	size = p0 - p;
-	if (size >= sizeof(s)) {
-		fprintf(stderr,
-			"The string size exceeds the internal buffer size\n");
-		return -1;
-	}
-	snprintf(s, sizeof(s), "%.*s", size, p);
-	ret = rte_strsplit(s, sizeof(s), str_fld, 16, ',');
-	if (ret <= 0) {
-		fprintf(stderr, "Failed to get the bandwidth list.\n");
-		return -1;
-	}
-	*tc_num = ret;
-	for (i = 0; i < ret; i++)
-		bw_list[i] = (uint8_t)strtoul(str_fld[i], &end, 0);
-
-	return 0;
-}
-
-/* TC min bandwidth setting */
-static void
-cmd_vf_tc_min_bw_parsed(
-	void *parsed_result,
-	__rte_unused struct cmdline *cl,
-	__rte_unused void *data)
-{
-	struct cmd_vf_tc_bw_result *res = parsed_result;
-	uint8_t tc_num;
-	uint8_t bw[16];
-	int ret = -ENOTSUP;
-
-	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
-		return;
-
-	ret = vf_tc_min_bw_parse_bw_list(bw, &tc_num, res->bw_list);
-	if (ret)
-		return;
-
-#ifdef RTE_NET_I40E
-	ret = rte_pmd_i40e_set_vf_tc_bw_alloc(res->port_id, res->vf_id,
-					      tc_num, bw);
-#endif
-
-	switch (ret) {
-	case 0:
-		break;
-	case -EINVAL:
-		fprintf(stderr, "invalid vf_id %d or bandwidth\n", res->vf_id);
-		break;
-	case -ENODEV:
-		fprintf(stderr, "invalid port_id %d\n", res->port_id);
-		break;
-	case -ENOTSUP:
-		fprintf(stderr, "function not implemented\n");
-		break;
-	default:
-		fprintf(stderr, "programming error: (%s)\n", strerror(-ret));
-	}
-}
-
-static cmdline_parse_inst_t cmd_vf_tc_min_bw = {
-	.f = cmd_vf_tc_min_bw_parsed,
-	.data = NULL,
-	.help_str = "set vf tc tx min-bandwidth <port_id> <vf_id>"
-		    " <bw1, bw2, ...>",
-	.tokens = {
-		(void *)&cmd_vf_tc_bw_set,
-		(void *)&cmd_vf_tc_bw_vf,
-		(void *)&cmd_vf_tc_bw_tc,
-		(void *)&cmd_vf_tc_bw_tx,
-		(void *)&cmd_vf_tc_bw_min_bw,
-		(void *)&cmd_vf_tc_bw_port_id,
-		(void *)&cmd_vf_tc_bw_vf_id,
-		(void *)&cmd_vf_tc_bw_bw_list,
-		NULL,
-	},
-};
-
-static void
-cmd_tc_min_bw_parsed(
-	void *parsed_result,
-	__rte_unused struct cmdline *cl,
-	__rte_unused void *data)
-{
-	struct cmd_vf_tc_bw_result *res = parsed_result;
-	struct rte_port *port;
-	uint8_t tc_num;
-	uint8_t bw[16];
-	int ret = -ENOTSUP;
-
-	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
-		return;
-
-	port = &ports[res->port_id];
-	/** Check if the port is not started **/
-	if (port->port_status != RTE_PORT_STOPPED) {
-		fprintf(stderr, "Please stop port %d first\n", res->port_id);
-		return;
-	}
-
-	ret = vf_tc_min_bw_parse_bw_list(bw, &tc_num, res->bw_list);
-	if (ret)
-		return;
-
-#ifdef RTE_NET_IXGBE
-	ret = rte_pmd_ixgbe_set_tc_bw_alloc(res->port_id, tc_num, bw);
-#endif
-
-	switch (ret) {
-	case 0:
-		break;
-	case -EINVAL:
-		fprintf(stderr, "invalid bandwidth\n");
-		break;
-	case -ENODEV:
-		fprintf(stderr, "invalid port_id %d\n", res->port_id);
-		break;
-	case -ENOTSUP:
-		fprintf(stderr, "function not implemented\n");
-		break;
-	default:
-		fprintf(stderr, "programming error: (%s)\n", strerror(-ret));
-	}
-}
-
-static cmdline_parse_inst_t cmd_tc_min_bw = {
-	.f = cmd_tc_min_bw_parsed,
-	.data = NULL,
-	.help_str = "set tc tx min-bandwidth <port_id> <bw1, bw2, ...>",
-	.tokens = {
-		(void *)&cmd_vf_tc_bw_set,
-		(void *)&cmd_vf_tc_bw_tc,
-		(void *)&cmd_vf_tc_bw_tx,
-		(void *)&cmd_vf_tc_bw_min_bw,
-		(void *)&cmd_vf_tc_bw_port_id,
-		(void *)&cmd_vf_tc_bw_bw_list,
-		NULL,
-	},
-};
-
-/* TC max bandwidth setting */
-static void
-cmd_vf_tc_max_bw_parsed(
-	void *parsed_result,
-	__rte_unused struct cmdline *cl,
-	__rte_unused void *data)
-{
-	struct cmd_vf_tc_bw_result *res = parsed_result;
-	int ret = -ENOTSUP;
-
-	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
-		return;
-
-#ifdef RTE_NET_I40E
-	ret = rte_pmd_i40e_set_vf_tc_max_bw(res->port_id, res->vf_id,
-					    res->tc_no, res->bw);
-#endif
-
-	switch (ret) {
-	case 0:
-		break;
-	case -EINVAL:
-		fprintf(stderr,
-			"invalid vf_id %d, tc_no %d or bandwidth %d\n",
-			res->vf_id, res->tc_no, res->bw);
-		break;
-	case -ENODEV:
-		fprintf(stderr, "invalid port_id %d\n", res->port_id);
-		break;
-	case -ENOTSUP:
-		fprintf(stderr, "function not implemented\n");
-		break;
-	default:
-		fprintf(stderr, "programming error: (%s)\n", strerror(-ret));
-	}
-}
-
-static cmdline_parse_inst_t cmd_vf_tc_max_bw = {
-	.f = cmd_vf_tc_max_bw_parsed,
-	.data = NULL,
-	.help_str = "set vf tc tx max-bandwidth <port_id> <vf_id> <tc_no>"
-		    " <bandwidth>",
-	.tokens = {
-		(void *)&cmd_vf_tc_bw_set,
-		(void *)&cmd_vf_tc_bw_vf,
-		(void *)&cmd_vf_tc_bw_tc,
-		(void *)&cmd_vf_tc_bw_tx,
-		(void *)&cmd_vf_tc_bw_max_bw,
-		(void *)&cmd_vf_tc_bw_port_id,
-		(void *)&cmd_vf_tc_bw_vf_id,
-		(void *)&cmd_vf_tc_bw_tc_no,
-		(void *)&cmd_vf_tc_bw_bw,
-		NULL,
-	},
-};
-
-/** Set VXLAN encapsulation details */
-struct cmd_set_vxlan_result {
-	cmdline_fixed_string_t set;
-	cmdline_fixed_string_t vxlan;
-	cmdline_fixed_string_t pos_token;
-	cmdline_fixed_string_t ip_version;
-	uint32_t vlan_present:1;
-	uint32_t vni;
-	uint16_t udp_src;
-	uint16_t udp_dst;
-	cmdline_ipaddr_t ip_src;
-	cmdline_ipaddr_t ip_dst;
-	uint16_t tci;
-	uint8_t tos;
-	uint8_t ttl;
-	struct rte_ether_addr eth_src;
-	struct rte_ether_addr eth_dst;
-};
-
-static cmdline_parse_token_string_t cmd_set_vxlan_set =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, set, "set");
-static cmdline_parse_token_string_t cmd_set_vxlan_vxlan =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, vxlan, "vxlan");
-static cmdline_parse_token_string_t cmd_set_vxlan_vxlan_tos_ttl =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, vxlan,
-				 "vxlan-tos-ttl");
-static cmdline_parse_token_string_t cmd_set_vxlan_vxlan_with_vlan =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, vxlan,
-				 "vxlan-with-vlan");
-static cmdline_parse_token_string_t cmd_set_vxlan_ip_version =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, pos_token,
-				 "ip-version");
-static cmdline_parse_token_string_t cmd_set_vxlan_ip_version_value =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, ip_version,
-				 "ipv4#ipv6");
-static cmdline_parse_token_string_t cmd_set_vxlan_vni =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, pos_token,
-				 "vni");
-static cmdline_parse_token_num_t cmd_set_vxlan_vni_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_vxlan_result, vni, RTE_UINT32);
-static cmdline_parse_token_string_t cmd_set_vxlan_udp_src =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, pos_token,
-				 "udp-src");
-static cmdline_parse_token_num_t cmd_set_vxlan_udp_src_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_vxlan_result, udp_src, RTE_UINT16);
-static cmdline_parse_token_string_t cmd_set_vxlan_udp_dst =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, pos_token,
-				 "udp-dst");
-static cmdline_parse_token_num_t cmd_set_vxlan_udp_dst_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_vxlan_result, udp_dst, RTE_UINT16);
-static cmdline_parse_token_string_t cmd_set_vxlan_ip_tos =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, pos_token,
-				 "ip-tos");
-static cmdline_parse_token_num_t cmd_set_vxlan_ip_tos_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_vxlan_result, tos, RTE_UINT8);
-static cmdline_parse_token_string_t cmd_set_vxlan_ip_ttl =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, pos_token,
-				 "ip-ttl");
-static cmdline_parse_token_num_t cmd_set_vxlan_ip_ttl_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_vxlan_result, ttl, RTE_UINT8);
-static cmdline_parse_token_string_t cmd_set_vxlan_ip_src =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, pos_token,
-				 "ip-src");
-static cmdline_parse_token_ipaddr_t cmd_set_vxlan_ip_src_value =
-	TOKEN_IPADDR_INITIALIZER(struct cmd_set_vxlan_result, ip_src);
-static cmdline_parse_token_string_t cmd_set_vxlan_ip_dst =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, pos_token,
-				 "ip-dst");
-static cmdline_parse_token_ipaddr_t cmd_set_vxlan_ip_dst_value =
-	TOKEN_IPADDR_INITIALIZER(struct cmd_set_vxlan_result, ip_dst);
-static cmdline_parse_token_string_t cmd_set_vxlan_vlan =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, pos_token,
-				 "vlan-tci");
-static cmdline_parse_token_num_t cmd_set_vxlan_vlan_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_vxlan_result, tci, RTE_UINT16);
-static cmdline_parse_token_string_t cmd_set_vxlan_eth_src =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, pos_token,
-				 "eth-src");
-static cmdline_parse_token_etheraddr_t cmd_set_vxlan_eth_src_value =
-	TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_vxlan_result, eth_src);
-static cmdline_parse_token_string_t cmd_set_vxlan_eth_dst =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, pos_token,
-				 "eth-dst");
-static cmdline_parse_token_etheraddr_t cmd_set_vxlan_eth_dst_value =
-	TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_vxlan_result, eth_dst);
-
-static void cmd_set_vxlan_parsed(void *parsed_result,
-	__rte_unused struct cmdline *cl,
-	__rte_unused void *data)
-{
-	struct cmd_set_vxlan_result *res = parsed_result;
-	union {
-		uint32_t vxlan_id;
-		uint8_t vni[4];
-	} id = {
-		.vxlan_id = rte_cpu_to_be_32(res->vni) & RTE_BE32(0x00ffffff),
-	};
-
-	vxlan_encap_conf.select_tos_ttl = 0;
-	if (strcmp(res->vxlan, "vxlan") == 0)
-		vxlan_encap_conf.select_vlan = 0;
-	else if (strcmp(res->vxlan, "vxlan-with-vlan") == 0)
-		vxlan_encap_conf.select_vlan = 1;
-	else if (strcmp(res->vxlan, "vxlan-tos-ttl") == 0) {
-		vxlan_encap_conf.select_vlan = 0;
-		vxlan_encap_conf.select_tos_ttl = 1;
-	}
-	if (strcmp(res->ip_version, "ipv4") == 0)
-		vxlan_encap_conf.select_ipv4 = 1;
-	else if (strcmp(res->ip_version, "ipv6") == 0)
-		vxlan_encap_conf.select_ipv4 = 0;
-	else
-		return;
-	rte_memcpy(vxlan_encap_conf.vni, &id.vni[1], 3);
-	vxlan_encap_conf.udp_src = rte_cpu_to_be_16(res->udp_src);
-	vxlan_encap_conf.udp_dst = rte_cpu_to_be_16(res->udp_dst);
-	vxlan_encap_conf.ip_tos = res->tos;
-	vxlan_encap_conf.ip_ttl = res->ttl;
-	if (vxlan_encap_conf.select_ipv4) {
-		IPV4_ADDR_TO_UINT(res->ip_src, vxlan_encap_conf.ipv4_src);
-		IPV4_ADDR_TO_UINT(res->ip_dst, vxlan_encap_conf.ipv4_dst);
-	} else {
-		IPV6_ADDR_TO_ARRAY(res->ip_src, vxlan_encap_conf.ipv6_src);
-		IPV6_ADDR_TO_ARRAY(res->ip_dst, vxlan_encap_conf.ipv6_dst);
-	}
-	if (vxlan_encap_conf.select_vlan)
-		vxlan_encap_conf.vlan_tci = rte_cpu_to_be_16(res->tci);
-	rte_memcpy(vxlan_encap_conf.eth_src, res->eth_src.addr_bytes,
-		   RTE_ETHER_ADDR_LEN);
-	rte_memcpy(vxlan_encap_conf.eth_dst, res->eth_dst.addr_bytes,
-		   RTE_ETHER_ADDR_LEN);
-}
-
-static cmdline_parse_inst_t cmd_set_vxlan = {
-	.f = cmd_set_vxlan_parsed,
-	.data = NULL,
-	.help_str = "set vxlan ip-version ipv4|ipv6 vni <vni> udp-src"
-		" <udp-src> udp-dst <udp-dst> ip-src <ip-src> ip-dst <ip-dst>"
-		" eth-src <eth-src> eth-dst <eth-dst>",
-	.tokens = {
-		(void *)&cmd_set_vxlan_set,
-		(void *)&cmd_set_vxlan_vxlan,
-		(void *)&cmd_set_vxlan_ip_version,
-		(void *)&cmd_set_vxlan_ip_version_value,
-		(void *)&cmd_set_vxlan_vni,
-		(void *)&cmd_set_vxlan_vni_value,
-		(void *)&cmd_set_vxlan_udp_src,
-		(void *)&cmd_set_vxlan_udp_src_value,
-		(void *)&cmd_set_vxlan_udp_dst,
-		(void *)&cmd_set_vxlan_udp_dst_value,
-		(void *)&cmd_set_vxlan_ip_src,
-		(void *)&cmd_set_vxlan_ip_src_value,
-		(void *)&cmd_set_vxlan_ip_dst,
-		(void *)&cmd_set_vxlan_ip_dst_value,
-		(void *)&cmd_set_vxlan_eth_src,
-		(void *)&cmd_set_vxlan_eth_src_value,
-		(void *)&cmd_set_vxlan_eth_dst,
-		(void *)&cmd_set_vxlan_eth_dst_value,
-		NULL,
-	},
-};
-
-static cmdline_parse_inst_t cmd_set_vxlan_tos_ttl = {
-	.f = cmd_set_vxlan_parsed,
-	.data = NULL,
-	.help_str = "set vxlan-tos-ttl ip-version ipv4|ipv6 vni <vni> udp-src"
-		" <udp-src> udp-dst <udp-dst> ip-tos <ip-tos> ip-ttl <ip-ttl>"
-		" ip-src <ip-src> ip-dst <ip-dst> eth-src <eth-src>"
-		" eth-dst <eth-dst>",
-	.tokens = {
-		(void *)&cmd_set_vxlan_set,
-		(void *)&cmd_set_vxlan_vxlan_tos_ttl,
-		(void *)&cmd_set_vxlan_ip_version,
-		(void *)&cmd_set_vxlan_ip_version_value,
-		(void *)&cmd_set_vxlan_vni,
-		(void *)&cmd_set_vxlan_vni_value,
-		(void *)&cmd_set_vxlan_udp_src,
-		(void *)&cmd_set_vxlan_udp_src_value,
-		(void *)&cmd_set_vxlan_udp_dst,
-		(void *)&cmd_set_vxlan_udp_dst_value,
-		(void *)&cmd_set_vxlan_ip_tos,
-		(void *)&cmd_set_vxlan_ip_tos_value,
-		(void *)&cmd_set_vxlan_ip_ttl,
-		(void *)&cmd_set_vxlan_ip_ttl_value,
-		(void *)&cmd_set_vxlan_ip_src,
-		(void *)&cmd_set_vxlan_ip_src_value,
-		(void *)&cmd_set_vxlan_ip_dst,
-		(void *)&cmd_set_vxlan_ip_dst_value,
-		(void *)&cmd_set_vxlan_eth_src,
-		(void *)&cmd_set_vxlan_eth_src_value,
-		(void *)&cmd_set_vxlan_eth_dst,
-		(void *)&cmd_set_vxlan_eth_dst_value,
-		NULL,
-	},
-};
-
-static cmdline_parse_inst_t cmd_set_vxlan_with_vlan = {
-	.f = cmd_set_vxlan_parsed,
-	.data = NULL,
-	.help_str = "set vxlan-with-vlan ip-version ipv4|ipv6 vni <vni>"
-		" udp-src <udp-src> udp-dst <udp-dst> ip-src <ip-src> ip-dst"
-		" <ip-dst> vlan-tci <vlan-tci> eth-src <eth-src> eth-dst"
-		" <eth-dst>",
-	.tokens = {
-		(void *)&cmd_set_vxlan_set,
-		(void *)&cmd_set_vxlan_vxlan_with_vlan,
-		(void *)&cmd_set_vxlan_ip_version,
-		(void *)&cmd_set_vxlan_ip_version_value,
-		(void *)&cmd_set_vxlan_vni,
-		(void *)&cmd_set_vxlan_vni_value,
-		(void *)&cmd_set_vxlan_udp_src,
-		(void *)&cmd_set_vxlan_udp_src_value,
-		(void *)&cmd_set_vxlan_udp_dst,
-		(void *)&cmd_set_vxlan_udp_dst_value,
-		(void *)&cmd_set_vxlan_ip_src,
-		(void *)&cmd_set_vxlan_ip_src_value,
-		(void *)&cmd_set_vxlan_ip_dst,
-		(void *)&cmd_set_vxlan_ip_dst_value,
-		(void *)&cmd_set_vxlan_vlan,
-		(void *)&cmd_set_vxlan_vlan_value,
-		(void *)&cmd_set_vxlan_eth_src,
-		(void *)&cmd_set_vxlan_eth_src_value,
-		(void *)&cmd_set_vxlan_eth_dst,
-		(void *)&cmd_set_vxlan_eth_dst_value,
-		NULL,
-	},
-};
-
-/** Set NVGRE encapsulation details */
-struct cmd_set_nvgre_result {
-	cmdline_fixed_string_t set;
-	cmdline_fixed_string_t nvgre;
-	cmdline_fixed_string_t pos_token;
-	cmdline_fixed_string_t ip_version;
-	uint32_t tni;
-	cmdline_ipaddr_t ip_src;
-	cmdline_ipaddr_t ip_dst;
-	uint16_t tci;
-	struct rte_ether_addr eth_src;
-	struct rte_ether_addr eth_dst;
-};
-
-static cmdline_parse_token_string_t cmd_set_nvgre_set =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_nvgre_result, set, "set");
-static cmdline_parse_token_string_t cmd_set_nvgre_nvgre =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_nvgre_result, nvgre, "nvgre");
-static cmdline_parse_token_string_t cmd_set_nvgre_nvgre_with_vlan =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_nvgre_result, nvgre,
-				 "nvgre-with-vlan");
-static cmdline_parse_token_string_t cmd_set_nvgre_ip_version =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_nvgre_result, pos_token,
-				 "ip-version");
-static cmdline_parse_token_string_t cmd_set_nvgre_ip_version_value =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_nvgre_result, ip_version,
-				 "ipv4#ipv6");
-static cmdline_parse_token_string_t cmd_set_nvgre_tni =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_nvgre_result, pos_token,
-				 "tni");
-static cmdline_parse_token_num_t cmd_set_nvgre_tni_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_nvgre_result, tni, RTE_UINT32);
-static cmdline_parse_token_string_t cmd_set_nvgre_ip_src =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_nvgre_result, pos_token,
-				 "ip-src");
-static cmdline_parse_token_num_t cmd_set_nvgre_ip_src_value =
-	TOKEN_IPADDR_INITIALIZER(struct cmd_set_nvgre_result, ip_src);
-static cmdline_parse_token_string_t cmd_set_nvgre_ip_dst =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_nvgre_result, pos_token,
-				 "ip-dst");
-static cmdline_parse_token_ipaddr_t cmd_set_nvgre_ip_dst_value =
-	TOKEN_IPADDR_INITIALIZER(struct cmd_set_nvgre_result, ip_dst);
-static cmdline_parse_token_string_t cmd_set_nvgre_vlan =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_nvgre_result, pos_token,
-				 "vlan-tci");
-static cmdline_parse_token_num_t cmd_set_nvgre_vlan_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_nvgre_result, tci, RTE_UINT16);
-static cmdline_parse_token_string_t cmd_set_nvgre_eth_src =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_nvgre_result, pos_token,
-				 "eth-src");
-static cmdline_parse_token_etheraddr_t cmd_set_nvgre_eth_src_value =
-	TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_nvgre_result, eth_src);
-static cmdline_parse_token_string_t cmd_set_nvgre_eth_dst =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_nvgre_result, pos_token,
-				 "eth-dst");
-static cmdline_parse_token_etheraddr_t cmd_set_nvgre_eth_dst_value =
-	TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_nvgre_result, eth_dst);
-
-static void cmd_set_nvgre_parsed(void *parsed_result,
-	__rte_unused struct cmdline *cl,
-	__rte_unused void *data)
-{
-	struct cmd_set_nvgre_result *res = parsed_result;
-	union {
-		uint32_t nvgre_tni;
-		uint8_t tni[4];
-	} id = {
-		.nvgre_tni = rte_cpu_to_be_32(res->tni) & RTE_BE32(0x00ffffff),
-	};
-
-	if (strcmp(res->nvgre, "nvgre") == 0)
-		nvgre_encap_conf.select_vlan = 0;
-	else if (strcmp(res->nvgre, "nvgre-with-vlan") == 0)
-		nvgre_encap_conf.select_vlan = 1;
-	if (strcmp(res->ip_version, "ipv4") == 0)
-		nvgre_encap_conf.select_ipv4 = 1;
-	else if (strcmp(res->ip_version, "ipv6") == 0)
-		nvgre_encap_conf.select_ipv4 = 0;
-	else
-		return;
-	rte_memcpy(nvgre_encap_conf.tni, &id.tni[1], 3);
-	if (nvgre_encap_conf.select_ipv4) {
-		IPV4_ADDR_TO_UINT(res->ip_src, nvgre_encap_conf.ipv4_src);
-		IPV4_ADDR_TO_UINT(res->ip_dst, nvgre_encap_conf.ipv4_dst);
-	} else {
-		IPV6_ADDR_TO_ARRAY(res->ip_src, nvgre_encap_conf.ipv6_src);
-		IPV6_ADDR_TO_ARRAY(res->ip_dst, nvgre_encap_conf.ipv6_dst);
-	}
-	if (nvgre_encap_conf.select_vlan)
-		nvgre_encap_conf.vlan_tci = rte_cpu_to_be_16(res->tci);
-	rte_memcpy(nvgre_encap_conf.eth_src, res->eth_src.addr_bytes,
-		   RTE_ETHER_ADDR_LEN);
-	rte_memcpy(nvgre_encap_conf.eth_dst, res->eth_dst.addr_bytes,
-		   RTE_ETHER_ADDR_LEN);
-}
-
-static cmdline_parse_inst_t cmd_set_nvgre = {
-	.f = cmd_set_nvgre_parsed,
-	.data = NULL,
-	.help_str = "set nvgre ip-version <ipv4|ipv6> tni <tni> ip-src"
-		" <ip-src> ip-dst <ip-dst> eth-src <eth-src>"
-		" eth-dst <eth-dst>",
-	.tokens = {
-		(void *)&cmd_set_nvgre_set,
-		(void *)&cmd_set_nvgre_nvgre,
-		(void *)&cmd_set_nvgre_ip_version,
-		(void *)&cmd_set_nvgre_ip_version_value,
-		(void *)&cmd_set_nvgre_tni,
-		(void *)&cmd_set_nvgre_tni_value,
-		(void *)&cmd_set_nvgre_ip_src,
-		(void *)&cmd_set_nvgre_ip_src_value,
-		(void *)&cmd_set_nvgre_ip_dst,
-		(void *)&cmd_set_nvgre_ip_dst_value,
-		(void *)&cmd_set_nvgre_eth_src,
-		(void *)&cmd_set_nvgre_eth_src_value,
-		(void *)&cmd_set_nvgre_eth_dst,
-		(void *)&cmd_set_nvgre_eth_dst_value,
-		NULL,
-	},
-};
-
-static cmdline_parse_inst_t cmd_set_nvgre_with_vlan = {
-	.f = cmd_set_nvgre_parsed,
-	.data = NULL,
-	.help_str = "set nvgre-with-vlan ip-version <ipv4|ipv6> tni <tni>"
-		" ip-src <ip-src> ip-dst <ip-dst> vlan-tci <vlan-tci>"
-		" eth-src <eth-src> eth-dst <eth-dst>",
-	.tokens = {
-		(void *)&cmd_set_nvgre_set,
-		(void *)&cmd_set_nvgre_nvgre_with_vlan,
-		(void *)&cmd_set_nvgre_ip_version,
-		(void *)&cmd_set_nvgre_ip_version_value,
-		(void *)&cmd_set_nvgre_tni,
-		(void *)&cmd_set_nvgre_tni_value,
-		(void *)&cmd_set_nvgre_ip_src,
-		(void *)&cmd_set_nvgre_ip_src_value,
-		(void *)&cmd_set_nvgre_ip_dst,
-		(void *)&cmd_set_nvgre_ip_dst_value,
-		(void *)&cmd_set_nvgre_vlan,
-		(void *)&cmd_set_nvgre_vlan_value,
-		(void *)&cmd_set_nvgre_eth_src,
-		(void *)&cmd_set_nvgre_eth_src_value,
-		(void *)&cmd_set_nvgre_eth_dst,
-		(void *)&cmd_set_nvgre_eth_dst_value,
-		NULL,
-	},
-};
-
-/** Set L2 encapsulation details */
-struct cmd_set_l2_encap_result {
-	cmdline_fixed_string_t set;
-	cmdline_fixed_string_t l2_encap;
-	cmdline_fixed_string_t pos_token;
-	cmdline_fixed_string_t ip_version;
-	uint32_t vlan_present:1;
-	uint16_t tci;
-	struct rte_ether_addr eth_src;
-	struct rte_ether_addr eth_dst;
-};
-
-static cmdline_parse_token_string_t cmd_set_l2_encap_set =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_l2_encap_result, set, "set");
-static cmdline_parse_token_string_t cmd_set_l2_encap_l2_encap =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_l2_encap_result, l2_encap, "l2_encap");
-static cmdline_parse_token_string_t cmd_set_l2_encap_l2_encap_with_vlan =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_l2_encap_result, l2_encap,
-				 "l2_encap-with-vlan");
-static cmdline_parse_token_string_t cmd_set_l2_encap_ip_version =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_l2_encap_result, pos_token,
-				 "ip-version");
-static cmdline_parse_token_string_t cmd_set_l2_encap_ip_version_value =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_l2_encap_result, ip_version,
-				 "ipv4#ipv6");
-static cmdline_parse_token_string_t cmd_set_l2_encap_vlan =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_l2_encap_result, pos_token,
-				 "vlan-tci");
-static cmdline_parse_token_num_t cmd_set_l2_encap_vlan_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_l2_encap_result, tci, RTE_UINT16);
-static cmdline_parse_token_string_t cmd_set_l2_encap_eth_src =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_l2_encap_result, pos_token,
-				 "eth-src");
-static cmdline_parse_token_etheraddr_t cmd_set_l2_encap_eth_src_value =
-	TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_l2_encap_result, eth_src);
-static cmdline_parse_token_string_t cmd_set_l2_encap_eth_dst =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_l2_encap_result, pos_token,
-				 "eth-dst");
-static cmdline_parse_token_etheraddr_t cmd_set_l2_encap_eth_dst_value =
-	TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_l2_encap_result, eth_dst);
-
-static void cmd_set_l2_encap_parsed(void *parsed_result,
-	__rte_unused struct cmdline *cl,
-	__rte_unused void *data)
-{
-	struct cmd_set_l2_encap_result *res = parsed_result;
-
-	if (strcmp(res->l2_encap, "l2_encap") == 0)
-		l2_encap_conf.select_vlan = 0;
-	else if (strcmp(res->l2_encap, "l2_encap-with-vlan") == 0)
-		l2_encap_conf.select_vlan = 1;
-	if (strcmp(res->ip_version, "ipv4") == 0)
-		l2_encap_conf.select_ipv4 = 1;
-	else if (strcmp(res->ip_version, "ipv6") == 0)
-		l2_encap_conf.select_ipv4 = 0;
-	else
-		return;
-	if (l2_encap_conf.select_vlan)
-		l2_encap_conf.vlan_tci = rte_cpu_to_be_16(res->tci);
-	rte_memcpy(l2_encap_conf.eth_src, res->eth_src.addr_bytes,
-		   RTE_ETHER_ADDR_LEN);
-	rte_memcpy(l2_encap_conf.eth_dst, res->eth_dst.addr_bytes,
-		   RTE_ETHER_ADDR_LEN);
-}
-
-static cmdline_parse_inst_t cmd_set_l2_encap = {
-	.f = cmd_set_l2_encap_parsed,
-	.data = NULL,
-	.help_str = "set l2_encap ip-version ipv4|ipv6"
-		" eth-src <eth-src> eth-dst <eth-dst>",
-	.tokens = {
-		(void *)&cmd_set_l2_encap_set,
-		(void *)&cmd_set_l2_encap_l2_encap,
-		(void *)&cmd_set_l2_encap_ip_version,
-		(void *)&cmd_set_l2_encap_ip_version_value,
-		(void *)&cmd_set_l2_encap_eth_src,
-		(void *)&cmd_set_l2_encap_eth_src_value,
-		(void *)&cmd_set_l2_encap_eth_dst,
-		(void *)&cmd_set_l2_encap_eth_dst_value,
-		NULL,
-	},
-};
-
-static cmdline_parse_inst_t cmd_set_l2_encap_with_vlan = {
-	.f = cmd_set_l2_encap_parsed,
-	.data = NULL,
-	.help_str = "set l2_encap-with-vlan ip-version ipv4|ipv6"
-		" vlan-tci <vlan-tci> eth-src <eth-src> eth-dst <eth-dst>",
-	.tokens = {
-		(void *)&cmd_set_l2_encap_set,
-		(void *)&cmd_set_l2_encap_l2_encap_with_vlan,
-		(void *)&cmd_set_l2_encap_ip_version,
-		(void *)&cmd_set_l2_encap_ip_version_value,
-		(void *)&cmd_set_l2_encap_vlan,
-		(void *)&cmd_set_l2_encap_vlan_value,
-		(void *)&cmd_set_l2_encap_eth_src,
-		(void *)&cmd_set_l2_encap_eth_src_value,
-		(void *)&cmd_set_l2_encap_eth_dst,
-		(void *)&cmd_set_l2_encap_eth_dst_value,
-		NULL,
-	},
-};
-
-/** Set L2 decapsulation details */
-struct cmd_set_l2_decap_result {
-	cmdline_fixed_string_t set;
-	cmdline_fixed_string_t l2_decap;
-	cmdline_fixed_string_t pos_token;
-	uint32_t vlan_present:1;
-};
-
-static cmdline_parse_token_string_t cmd_set_l2_decap_set =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_l2_decap_result, set, "set");
-static cmdline_parse_token_string_t cmd_set_l2_decap_l2_decap =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_l2_decap_result, l2_decap,
-				 "l2_decap");
-static cmdline_parse_token_string_t cmd_set_l2_decap_l2_decap_with_vlan =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_l2_decap_result, l2_decap,
-				 "l2_decap-with-vlan");
-
-static void cmd_set_l2_decap_parsed(void *parsed_result,
-	__rte_unused struct cmdline *cl,
-	__rte_unused void *data)
-{
-	struct cmd_set_l2_decap_result *res = parsed_result;
-
-	if (strcmp(res->l2_decap, "l2_decap") == 0)
-		l2_decap_conf.select_vlan = 0;
-	else if (strcmp(res->l2_decap, "l2_decap-with-vlan") == 0)
-		l2_decap_conf.select_vlan = 1;
-}
-
-static cmdline_parse_inst_t cmd_set_l2_decap = {
-	.f = cmd_set_l2_decap_parsed,
-	.data = NULL,
-	.help_str = "set l2_decap",
-	.tokens = {
-		(void *)&cmd_set_l2_decap_set,
-		(void *)&cmd_set_l2_decap_l2_decap,
-		NULL,
-	},
-};
-
-static cmdline_parse_inst_t cmd_set_l2_decap_with_vlan = {
-	.f = cmd_set_l2_decap_parsed,
-	.data = NULL,
-	.help_str = "set l2_decap-with-vlan",
-	.tokens = {
-		(void *)&cmd_set_l2_decap_set,
-		(void *)&cmd_set_l2_decap_l2_decap_with_vlan,
-		NULL,
-	},
-};
-
-/** Set MPLSoGRE encapsulation details */
-struct cmd_set_mplsogre_encap_result {
-	cmdline_fixed_string_t set;
-	cmdline_fixed_string_t mplsogre;
-	cmdline_fixed_string_t pos_token;
-	cmdline_fixed_string_t ip_version;
-	uint32_t vlan_present:1;
-	uint32_t label;
-	cmdline_ipaddr_t ip_src;
-	cmdline_ipaddr_t ip_dst;
-	uint16_t tci;
-	struct rte_ether_addr eth_src;
-	struct rte_ether_addr eth_dst;
-};
-
-static cmdline_parse_token_string_t cmd_set_mplsogre_encap_set =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_encap_result, set,
-				 "set");
-static cmdline_parse_token_string_t cmd_set_mplsogre_encap_mplsogre_encap =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_encap_result, mplsogre,
-				 "mplsogre_encap");
-static cmdline_parse_token_string_t cmd_set_mplsogre_encap_mplsogre_encap_with_vlan =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_encap_result,
-				 mplsogre, "mplsogre_encap-with-vlan");
-static cmdline_parse_token_string_t cmd_set_mplsogre_encap_ip_version =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_encap_result,
-				 pos_token, "ip-version");
-static cmdline_parse_token_string_t cmd_set_mplsogre_encap_ip_version_value =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_encap_result,
-				 ip_version, "ipv4#ipv6");
-static cmdline_parse_token_string_t cmd_set_mplsogre_encap_label =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_encap_result,
-				 pos_token, "label");
-static cmdline_parse_token_num_t cmd_set_mplsogre_encap_label_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_mplsogre_encap_result, label,
-			      RTE_UINT32);
-static cmdline_parse_token_string_t cmd_set_mplsogre_encap_ip_src =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_encap_result,
-				 pos_token, "ip-src");
-static cmdline_parse_token_ipaddr_t cmd_set_mplsogre_encap_ip_src_value =
-	TOKEN_IPADDR_INITIALIZER(struct cmd_set_mplsogre_encap_result, ip_src);
-static cmdline_parse_token_string_t cmd_set_mplsogre_encap_ip_dst =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_encap_result,
-				 pos_token, "ip-dst");
-static cmdline_parse_token_ipaddr_t cmd_set_mplsogre_encap_ip_dst_value =
-	TOKEN_IPADDR_INITIALIZER(struct cmd_set_mplsogre_encap_result, ip_dst);
-static cmdline_parse_token_string_t cmd_set_mplsogre_encap_vlan =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_encap_result,
-				 pos_token, "vlan-tci");
-static cmdline_parse_token_num_t cmd_set_mplsogre_encap_vlan_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_mplsogre_encap_result, tci,
-			      RTE_UINT16);
-static cmdline_parse_token_string_t cmd_set_mplsogre_encap_eth_src =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_encap_result,
-				 pos_token, "eth-src");
-static cmdline_parse_token_etheraddr_t cmd_set_mplsogre_encap_eth_src_value =
-	TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_mplsogre_encap_result,
-				    eth_src);
-static cmdline_parse_token_string_t cmd_set_mplsogre_encap_eth_dst =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_encap_result,
-				 pos_token, "eth-dst");
-static cmdline_parse_token_etheraddr_t cmd_set_mplsogre_encap_eth_dst_value =
-	TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_mplsogre_encap_result,
-				    eth_dst);
-
-static void cmd_set_mplsogre_encap_parsed(void *parsed_result,
-	__rte_unused struct cmdline *cl,
-	__rte_unused void *data)
-{
-	struct cmd_set_mplsogre_encap_result *res = parsed_result;
-	union {
-		uint32_t mplsogre_label;
-		uint8_t label[4];
-	} id = {
-		.mplsogre_label = rte_cpu_to_be_32(res->label<<12),
-	};
-
-	if (strcmp(res->mplsogre, "mplsogre_encap") == 0)
-		mplsogre_encap_conf.select_vlan = 0;
-	else if (strcmp(res->mplsogre, "mplsogre_encap-with-vlan") == 0)
-		mplsogre_encap_conf.select_vlan = 1;
-	if (strcmp(res->ip_version, "ipv4") == 0)
-		mplsogre_encap_conf.select_ipv4 = 1;
-	else if (strcmp(res->ip_version, "ipv6") == 0)
-		mplsogre_encap_conf.select_ipv4 = 0;
-	else
-		return;
-	rte_memcpy(mplsogre_encap_conf.label, &id.label, 3);
-	if (mplsogre_encap_conf.select_ipv4) {
-		IPV4_ADDR_TO_UINT(res->ip_src, mplsogre_encap_conf.ipv4_src);
-		IPV4_ADDR_TO_UINT(res->ip_dst, mplsogre_encap_conf.ipv4_dst);
-	} else {
-		IPV6_ADDR_TO_ARRAY(res->ip_src, mplsogre_encap_conf.ipv6_src);
-		IPV6_ADDR_TO_ARRAY(res->ip_dst, mplsogre_encap_conf.ipv6_dst);
-	}
-	if (mplsogre_encap_conf.select_vlan)
-		mplsogre_encap_conf.vlan_tci = rte_cpu_to_be_16(res->tci);
-	rte_memcpy(mplsogre_encap_conf.eth_src, res->eth_src.addr_bytes,
-		   RTE_ETHER_ADDR_LEN);
-	rte_memcpy(mplsogre_encap_conf.eth_dst, res->eth_dst.addr_bytes,
-		   RTE_ETHER_ADDR_LEN);
-}
-
-static cmdline_parse_inst_t cmd_set_mplsogre_encap = {
-	.f = cmd_set_mplsogre_encap_parsed,
-	.data = NULL,
-	.help_str = "set mplsogre_encap ip-version ipv4|ipv6 label <label>"
-		" ip-src <ip-src> ip-dst <ip-dst> eth-src <eth-src>"
-		" eth-dst <eth-dst>",
-	.tokens = {
-		(void *)&cmd_set_mplsogre_encap_set,
-		(void *)&cmd_set_mplsogre_encap_mplsogre_encap,
-		(void *)&cmd_set_mplsogre_encap_ip_version,
-		(void *)&cmd_set_mplsogre_encap_ip_version_value,
-		(void *)&cmd_set_mplsogre_encap_label,
-		(void *)&cmd_set_mplsogre_encap_label_value,
-		(void *)&cmd_set_mplsogre_encap_ip_src,
-		(void *)&cmd_set_mplsogre_encap_ip_src_value,
-		(void *)&cmd_set_mplsogre_encap_ip_dst,
-		(void *)&cmd_set_mplsogre_encap_ip_dst_value,
-		(void *)&cmd_set_mplsogre_encap_eth_src,
-		(void *)&cmd_set_mplsogre_encap_eth_src_value,
-		(void *)&cmd_set_mplsogre_encap_eth_dst,
-		(void *)&cmd_set_mplsogre_encap_eth_dst_value,
-		NULL,
-	},
-};
-
-static cmdline_parse_inst_t cmd_set_mplsogre_encap_with_vlan = {
-	.f = cmd_set_mplsogre_encap_parsed,
-	.data = NULL,
-	.help_str = "set mplsogre_encap-with-vlan ip-version ipv4|ipv6"
-		" label <label> ip-src <ip-src> ip-dst <ip-dst>"
-		" vlan-tci <vlan-tci> eth-src <eth-src> eth-dst <eth-dst>",
-	.tokens = {
-		(void *)&cmd_set_mplsogre_encap_set,
-		(void *)&cmd_set_mplsogre_encap_mplsogre_encap_with_vlan,
-		(void *)&cmd_set_mplsogre_encap_ip_version,
-		(void *)&cmd_set_mplsogre_encap_ip_version_value,
-		(void *)&cmd_set_mplsogre_encap_label,
-		(void *)&cmd_set_mplsogre_encap_label_value,
-		(void *)&cmd_set_mplsogre_encap_ip_src,
-		(void *)&cmd_set_mplsogre_encap_ip_src_value,
-		(void *)&cmd_set_mplsogre_encap_ip_dst,
-		(void *)&cmd_set_mplsogre_encap_ip_dst_value,
-		(void *)&cmd_set_mplsogre_encap_vlan,
-		(void *)&cmd_set_mplsogre_encap_vlan_value,
-		(void *)&cmd_set_mplsogre_encap_eth_src,
-		(void *)&cmd_set_mplsogre_encap_eth_src_value,
-		(void *)&cmd_set_mplsogre_encap_eth_dst,
-		(void *)&cmd_set_mplsogre_encap_eth_dst_value,
-		NULL,
-	},
-};
-
-/** Set MPLSoGRE decapsulation details */
-struct cmd_set_mplsogre_decap_result {
-	cmdline_fixed_string_t set;
-	cmdline_fixed_string_t mplsogre;
-	cmdline_fixed_string_t pos_token;
-	cmdline_fixed_string_t ip_version;
-	uint32_t vlan_present:1;
-};
-
-static cmdline_parse_token_string_t cmd_set_mplsogre_decap_set =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_decap_result, set,
-				 "set");
-static cmdline_parse_token_string_t cmd_set_mplsogre_decap_mplsogre_decap =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_decap_result, mplsogre,
-				 "mplsogre_decap");
-static cmdline_parse_token_string_t cmd_set_mplsogre_decap_mplsogre_decap_with_vlan =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_decap_result,
-				 mplsogre, "mplsogre_decap-with-vlan");
-static cmdline_parse_token_string_t cmd_set_mplsogre_decap_ip_version =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_decap_result,
-				 pos_token, "ip-version");
-static cmdline_parse_token_string_t cmd_set_mplsogre_decap_ip_version_value =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_decap_result,
-				 ip_version, "ipv4#ipv6");
-
-static void cmd_set_mplsogre_decap_parsed(void *parsed_result,
-	__rte_unused struct cmdline *cl,
-	__rte_unused void *data)
-{
-	struct cmd_set_mplsogre_decap_result *res = parsed_result;
-
-	if (strcmp(res->mplsogre, "mplsogre_decap") == 0)
-		mplsogre_decap_conf.select_vlan = 0;
-	else if (strcmp(res->mplsogre, "mplsogre_decap-with-vlan") == 0)
-		mplsogre_decap_conf.select_vlan = 1;
-	if (strcmp(res->ip_version, "ipv4") == 0)
-		mplsogre_decap_conf.select_ipv4 = 1;
-	else if (strcmp(res->ip_version, "ipv6") == 0)
-		mplsogre_decap_conf.select_ipv4 = 0;
-}
-
-static cmdline_parse_inst_t cmd_set_mplsogre_decap = {
-	.f = cmd_set_mplsogre_decap_parsed,
-	.data = NULL,
-	.help_str = "set mplsogre_decap ip-version ipv4|ipv6",
-	.tokens = {
-		(void *)&cmd_set_mplsogre_decap_set,
-		(void *)&cmd_set_mplsogre_decap_mplsogre_decap,
-		(void *)&cmd_set_mplsogre_decap_ip_version,
-		(void *)&cmd_set_mplsogre_decap_ip_version_value,
-		NULL,
-	},
-};
-
-static cmdline_parse_inst_t cmd_set_mplsogre_decap_with_vlan = {
-	.f = cmd_set_mplsogre_decap_parsed,
-	.data = NULL,
-	.help_str = "set mplsogre_decap-with-vlan ip-version ipv4|ipv6",
-	.tokens = {
-		(void *)&cmd_set_mplsogre_decap_set,
-		(void *)&cmd_set_mplsogre_decap_mplsogre_decap_with_vlan,
-		(void *)&cmd_set_mplsogre_decap_ip_version,
-		(void *)&cmd_set_mplsogre_decap_ip_version_value,
-		NULL,
-	},
-};
-
-/** Set MPLSoUDP encapsulation details */
-struct cmd_set_mplsoudp_encap_result {
-	cmdline_fixed_string_t set;
-	cmdline_fixed_string_t mplsoudp;
-	cmdline_fixed_string_t pos_token;
-	cmdline_fixed_string_t ip_version;
-	uint32_t vlan_present:1;
-	uint32_t label;
-	uint16_t udp_src;
-	uint16_t udp_dst;
-	cmdline_ipaddr_t ip_src;
-	cmdline_ipaddr_t ip_dst;
-	uint16_t tci;
-	struct rte_ether_addr eth_src;
-	struct rte_ether_addr eth_dst;
-};
-
-static cmdline_parse_token_string_t cmd_set_mplsoudp_encap_set =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result, set,
-				 "set");
-static cmdline_parse_token_string_t cmd_set_mplsoudp_encap_mplsoudp_encap =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result, mplsoudp,
-				 "mplsoudp_encap");
-static cmdline_parse_token_string_t cmd_set_mplsoudp_encap_mplsoudp_encap_with_vlan =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
-				 mplsoudp, "mplsoudp_encap-with-vlan");
-static cmdline_parse_token_string_t cmd_set_mplsoudp_encap_ip_version =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
-				 pos_token, "ip-version");
-static cmdline_parse_token_string_t cmd_set_mplsoudp_encap_ip_version_value =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
-				 ip_version, "ipv4#ipv6");
-static cmdline_parse_token_string_t cmd_set_mplsoudp_encap_label =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
-				 pos_token, "label");
-static cmdline_parse_token_num_t cmd_set_mplsoudp_encap_label_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_mplsoudp_encap_result, label,
-			      RTE_UINT32);
-static cmdline_parse_token_string_t cmd_set_mplsoudp_encap_udp_src =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
-				 pos_token, "udp-src");
-static cmdline_parse_token_num_t cmd_set_mplsoudp_encap_udp_src_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_mplsoudp_encap_result, udp_src,
-			      RTE_UINT16);
-static cmdline_parse_token_string_t cmd_set_mplsoudp_encap_udp_dst =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
-				 pos_token, "udp-dst");
-static cmdline_parse_token_num_t cmd_set_mplsoudp_encap_udp_dst_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_mplsoudp_encap_result, udp_dst,
-			      RTE_UINT16);
-static cmdline_parse_token_string_t cmd_set_mplsoudp_encap_ip_src =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
-				 pos_token, "ip-src");
-static cmdline_parse_token_ipaddr_t cmd_set_mplsoudp_encap_ip_src_value =
-	TOKEN_IPADDR_INITIALIZER(struct cmd_set_mplsoudp_encap_result, ip_src);
-static cmdline_parse_token_string_t cmd_set_mplsoudp_encap_ip_dst =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
-				 pos_token, "ip-dst");
-static cmdline_parse_token_ipaddr_t cmd_set_mplsoudp_encap_ip_dst_value =
-	TOKEN_IPADDR_INITIALIZER(struct cmd_set_mplsoudp_encap_result, ip_dst);
-static cmdline_parse_token_string_t cmd_set_mplsoudp_encap_vlan =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
-				 pos_token, "vlan-tci");
-static cmdline_parse_token_num_t cmd_set_mplsoudp_encap_vlan_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_mplsoudp_encap_result, tci,
-			      RTE_UINT16);
-static cmdline_parse_token_string_t cmd_set_mplsoudp_encap_eth_src =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
-				 pos_token, "eth-src");
-static cmdline_parse_token_etheraddr_t cmd_set_mplsoudp_encap_eth_src_value =
-	TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
-				    eth_src);
-static cmdline_parse_token_string_t cmd_set_mplsoudp_encap_eth_dst =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
-				 pos_token, "eth-dst");
-static cmdline_parse_token_etheraddr_t cmd_set_mplsoudp_encap_eth_dst_value =
-	TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
-				    eth_dst);
-
-static void cmd_set_mplsoudp_encap_parsed(void *parsed_result,
-	__rte_unused struct cmdline *cl,
-	__rte_unused void *data)
-{
-	struct cmd_set_mplsoudp_encap_result *res = parsed_result;
-	union {
-		uint32_t mplsoudp_label;
-		uint8_t label[4];
-	} id = {
-		.mplsoudp_label = rte_cpu_to_be_32(res->label<<12),
-	};
-
-	if (strcmp(res->mplsoudp, "mplsoudp_encap") == 0)
-		mplsoudp_encap_conf.select_vlan = 0;
-	else if (strcmp(res->mplsoudp, "mplsoudp_encap-with-vlan") == 0)
-		mplsoudp_encap_conf.select_vlan = 1;
-	if (strcmp(res->ip_version, "ipv4") == 0)
-		mplsoudp_encap_conf.select_ipv4 = 1;
-	else if (strcmp(res->ip_version, "ipv6") == 0)
-		mplsoudp_encap_conf.select_ipv4 = 0;
-	else
-		return;
-	rte_memcpy(mplsoudp_encap_conf.label, &id.label, 3);
-	mplsoudp_encap_conf.udp_src = rte_cpu_to_be_16(res->udp_src);
-	mplsoudp_encap_conf.udp_dst = rte_cpu_to_be_16(res->udp_dst);
-	if (mplsoudp_encap_conf.select_ipv4) {
-		IPV4_ADDR_TO_UINT(res->ip_src, mplsoudp_encap_conf.ipv4_src);
-		IPV4_ADDR_TO_UINT(res->ip_dst, mplsoudp_encap_conf.ipv4_dst);
-	} else {
-		IPV6_ADDR_TO_ARRAY(res->ip_src, mplsoudp_encap_conf.ipv6_src);
-		IPV6_ADDR_TO_ARRAY(res->ip_dst, mplsoudp_encap_conf.ipv6_dst);
-	}
-	if (mplsoudp_encap_conf.select_vlan)
-		mplsoudp_encap_conf.vlan_tci = rte_cpu_to_be_16(res->tci);
-	rte_memcpy(mplsoudp_encap_conf.eth_src, res->eth_src.addr_bytes,
-		   RTE_ETHER_ADDR_LEN);
-	rte_memcpy(mplsoudp_encap_conf.eth_dst, res->eth_dst.addr_bytes,
-		   RTE_ETHER_ADDR_LEN);
-}
-
-static cmdline_parse_inst_t cmd_set_mplsoudp_encap = {
-	.f = cmd_set_mplsoudp_encap_parsed,
-	.data = NULL,
-	.help_str = "set mplsoudp_encap ip-version ipv4|ipv6 label <label>"
-		" udp-src <udp-src> udp-dst <udp-dst> ip-src <ip-src>"
-		" ip-dst <ip-dst> eth-src <eth-src> eth-dst <eth-dst>",
-	.tokens = {
-		(void *)&cmd_set_mplsoudp_encap_set,
-		(void *)&cmd_set_mplsoudp_encap_mplsoudp_encap,
-		(void *)&cmd_set_mplsoudp_encap_ip_version,
-		(void *)&cmd_set_mplsoudp_encap_ip_version_value,
-		(void *)&cmd_set_mplsoudp_encap_label,
-		(void *)&cmd_set_mplsoudp_encap_label_value,
-		(void *)&cmd_set_mplsoudp_encap_udp_src,
-		(void *)&cmd_set_mplsoudp_encap_udp_src_value,
-		(void *)&cmd_set_mplsoudp_encap_udp_dst,
-		(void *)&cmd_set_mplsoudp_encap_udp_dst_value,
-		(void *)&cmd_set_mplsoudp_encap_ip_src,
-		(void *)&cmd_set_mplsoudp_encap_ip_src_value,
-		(void *)&cmd_set_mplsoudp_encap_ip_dst,
-		(void *)&cmd_set_mplsoudp_encap_ip_dst_value,
-		(void *)&cmd_set_mplsoudp_encap_eth_src,
-		(void *)&cmd_set_mplsoudp_encap_eth_src_value,
-		(void *)&cmd_set_mplsoudp_encap_eth_dst,
-		(void *)&cmd_set_mplsoudp_encap_eth_dst_value,
-		NULL,
-	},
-};
-
-static cmdline_parse_inst_t cmd_set_mplsoudp_encap_with_vlan = {
-	.f = cmd_set_mplsoudp_encap_parsed,
-	.data = NULL,
-	.help_str = "set mplsoudp_encap-with-vlan ip-version ipv4|ipv6"
-		" label <label> udp-src <udp-src> udp-dst <udp-dst>"
-		" ip-src <ip-src> ip-dst <ip-dst> vlan-tci <vlan-tci>"
-		" eth-src <eth-src> eth-dst <eth-dst>",
-	.tokens = {
-		(void *)&cmd_set_mplsoudp_encap_set,
-		(void *)&cmd_set_mplsoudp_encap_mplsoudp_encap_with_vlan,
-		(void *)&cmd_set_mplsoudp_encap_ip_version,
-		(void *)&cmd_set_mplsoudp_encap_ip_version_value,
-		(void *)&cmd_set_mplsoudp_encap_label,
-		(void *)&cmd_set_mplsoudp_encap_label_value,
-		(void *)&cmd_set_mplsoudp_encap_udp_src,
-		(void *)&cmd_set_mplsoudp_encap_udp_src_value,
-		(void *)&cmd_set_mplsoudp_encap_udp_dst,
-		(void *)&cmd_set_mplsoudp_encap_udp_dst_value,
-		(void *)&cmd_set_mplsoudp_encap_ip_src,
-		(void *)&cmd_set_mplsoudp_encap_ip_src_value,
-		(void *)&cmd_set_mplsoudp_encap_ip_dst,
-		(void *)&cmd_set_mplsoudp_encap_ip_dst_value,
-		(void *)&cmd_set_mplsoudp_encap_vlan,
-		(void *)&cmd_set_mplsoudp_encap_vlan_value,
-		(void *)&cmd_set_mplsoudp_encap_eth_src,
-		(void *)&cmd_set_mplsoudp_encap_eth_src_value,
-		(void *)&cmd_set_mplsoudp_encap_eth_dst,
-		(void *)&cmd_set_mplsoudp_encap_eth_dst_value,
-		NULL,
-	},
-};
-
-/** Set MPLSoUDP decapsulation details */
-struct cmd_set_mplsoudp_decap_result {
-	cmdline_fixed_string_t set;
-	cmdline_fixed_string_t mplsoudp;
-	cmdline_fixed_string_t pos_token;
-	cmdline_fixed_string_t ip_version;
-	uint32_t vlan_present:1;
-};
-
-static cmdline_parse_token_string_t cmd_set_mplsoudp_decap_set =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_decap_result, set,
-				 "set");
-static cmdline_parse_token_string_t cmd_set_mplsoudp_decap_mplsoudp_decap =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_decap_result, mplsoudp,
-				 "mplsoudp_decap");
-static cmdline_parse_token_string_t cmd_set_mplsoudp_decap_mplsoudp_decap_with_vlan =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_decap_result,
-				 mplsoudp, "mplsoudp_decap-with-vlan");
-static cmdline_parse_token_string_t cmd_set_mplsoudp_decap_ip_version =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_decap_result,
-				 pos_token, "ip-version");
-static cmdline_parse_token_string_t cmd_set_mplsoudp_decap_ip_version_value =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_decap_result,
-				 ip_version, "ipv4#ipv6");
-
-static void cmd_set_mplsoudp_decap_parsed(void *parsed_result,
-	__rte_unused struct cmdline *cl,
-	__rte_unused void *data)
-{
-	struct cmd_set_mplsoudp_decap_result *res = parsed_result;
-
-	if (strcmp(res->mplsoudp, "mplsoudp_decap") == 0)
-		mplsoudp_decap_conf.select_vlan = 0;
-	else if (strcmp(res->mplsoudp, "mplsoudp_decap-with-vlan") == 0)
-		mplsoudp_decap_conf.select_vlan = 1;
-	if (strcmp(res->ip_version, "ipv4") == 0)
-		mplsoudp_decap_conf.select_ipv4 = 1;
-	else if (strcmp(res->ip_version, "ipv6") == 0)
-		mplsoudp_decap_conf.select_ipv4 = 0;
-}
-
-static cmdline_parse_inst_t cmd_set_mplsoudp_decap = {
-	.f = cmd_set_mplsoudp_decap_parsed,
-	.data = NULL,
-	.help_str = "set mplsoudp_decap ip-version ipv4|ipv6",
-	.tokens = {
-		(void *)&cmd_set_mplsoudp_decap_set,
-		(void *)&cmd_set_mplsoudp_decap_mplsoudp_decap,
-		(void *)&cmd_set_mplsoudp_decap_ip_version,
-		(void *)&cmd_set_mplsoudp_decap_ip_version_value,
-		NULL,
-	},
-};
-
-static cmdline_parse_inst_t cmd_set_mplsoudp_decap_with_vlan = {
-	.f = cmd_set_mplsoudp_decap_parsed,
-	.data = NULL,
-	.help_str = "set mplsoudp_decap-with-vlan ip-version ipv4|ipv6",
-	.tokens = {
-		(void *)&cmd_set_mplsoudp_decap_set,
-		(void *)&cmd_set_mplsoudp_decap_mplsoudp_decap_with_vlan,
-		(void *)&cmd_set_mplsoudp_decap_ip_version,
-		(void *)&cmd_set_mplsoudp_decap_ip_version_value,
-		NULL,
-	},
-};
-
-/** Set connection tracking object common details */
-struct cmd_set_conntrack_common_result {
-	cmdline_fixed_string_t set;
-	cmdline_fixed_string_t conntrack;
-	cmdline_fixed_string_t common;
-	cmdline_fixed_string_t peer;
-	cmdline_fixed_string_t is_orig;
-	cmdline_fixed_string_t enable;
-	cmdline_fixed_string_t live;
-	cmdline_fixed_string_t sack;
-	cmdline_fixed_string_t cack;
-	cmdline_fixed_string_t last_dir;
-	cmdline_fixed_string_t liberal;
-	cmdline_fixed_string_t state;
-	cmdline_fixed_string_t max_ack_win;
-	cmdline_fixed_string_t retrans;
-	cmdline_fixed_string_t last_win;
-	cmdline_fixed_string_t last_seq;
-	cmdline_fixed_string_t last_ack;
-	cmdline_fixed_string_t last_end;
-	cmdline_fixed_string_t last_index;
-	uint8_t stat;
-	uint8_t factor;
-	uint16_t peer_port;
-	uint32_t is_original;
-	uint32_t en;
-	uint32_t is_live;
-	uint32_t s_ack;
-	uint32_t c_ack;
-	uint32_t ld;
-	uint32_t lb;
-	uint8_t re_num;
-	uint8_t li;
-	uint16_t lw;
-	uint32_t ls;
-	uint32_t la;
-	uint32_t le;
-};
-
-static cmdline_parse_token_string_t cmd_set_conntrack_set =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
-				 set, "set");
-static cmdline_parse_token_string_t cmd_set_conntrack_conntrack =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
-				 conntrack, "conntrack");
-static cmdline_parse_token_string_t cmd_set_conntrack_common_com =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
-				 common, "com");
-static cmdline_parse_token_string_t cmd_set_conntrack_common_peer =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
-				 peer, "peer");
-static cmdline_parse_token_num_t cmd_set_conntrack_common_peer_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
-			      peer_port, RTE_UINT16);
-static cmdline_parse_token_string_t cmd_set_conntrack_common_is_orig =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
-				 is_orig, "is_orig");
-static cmdline_parse_token_num_t cmd_set_conntrack_common_is_orig_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
-			      is_original, RTE_UINT32);
-static cmdline_parse_token_string_t cmd_set_conntrack_common_enable =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
-				 enable, "enable");
-static cmdline_parse_token_num_t cmd_set_conntrack_common_enable_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
-			      en, RTE_UINT32);
-static cmdline_parse_token_string_t cmd_set_conntrack_common_live =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
-				 live, "live");
-static cmdline_parse_token_num_t cmd_set_conntrack_common_live_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
-			      is_live, RTE_UINT32);
-static cmdline_parse_token_string_t cmd_set_conntrack_common_sack =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
-				 sack, "sack");
-static cmdline_parse_token_num_t cmd_set_conntrack_common_sack_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
-			      s_ack, RTE_UINT32);
-static cmdline_parse_token_string_t cmd_set_conntrack_common_cack =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
-				 cack, "cack");
-static cmdline_parse_token_num_t cmd_set_conntrack_common_cack_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
-			      c_ack, RTE_UINT32);
-static cmdline_parse_token_string_t cmd_set_conntrack_common_last_dir =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
-				 last_dir, "last_dir");
-static cmdline_parse_token_num_t cmd_set_conntrack_common_last_dir_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
-			      ld, RTE_UINT32);
-static cmdline_parse_token_string_t cmd_set_conntrack_common_liberal =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
-				 liberal, "liberal");
-static cmdline_parse_token_num_t cmd_set_conntrack_common_liberal_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
-			      lb, RTE_UINT32);
-static cmdline_parse_token_string_t cmd_set_conntrack_common_state =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
-				 state, "state");
-static cmdline_parse_token_num_t cmd_set_conntrack_common_state_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
-			      stat, RTE_UINT8);
-static cmdline_parse_token_string_t cmd_set_conntrack_common_max_ackwin =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
-				 max_ack_win, "max_ack_win");
-static cmdline_parse_token_num_t cmd_set_conntrack_common_max_ackwin_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
-			      factor, RTE_UINT8);
-static cmdline_parse_token_string_t cmd_set_conntrack_common_retrans =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
-				 retrans, "r_lim");
-static cmdline_parse_token_num_t cmd_set_conntrack_common_retrans_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
-			      re_num, RTE_UINT8);
-static cmdline_parse_token_string_t cmd_set_conntrack_common_last_win =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
-				 last_win, "last_win");
-static cmdline_parse_token_num_t cmd_set_conntrack_common_last_win_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
-			      lw, RTE_UINT16);
-static cmdline_parse_token_string_t cmd_set_conntrack_common_last_seq =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
-				 last_seq, "last_seq");
-static cmdline_parse_token_num_t cmd_set_conntrack_common_last_seq_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
-			      ls, RTE_UINT32);
-static cmdline_parse_token_string_t cmd_set_conntrack_common_last_ack =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
-				 last_ack, "last_ack");
-static cmdline_parse_token_num_t cmd_set_conntrack_common_last_ack_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
-			      la, RTE_UINT32);
-static cmdline_parse_token_string_t cmd_set_conntrack_common_last_end =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
-				 last_end, "last_end");
-static cmdline_parse_token_num_t cmd_set_conntrack_common_last_end_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
-			      le, RTE_UINT32);
-static cmdline_parse_token_string_t cmd_set_conntrack_common_last_index =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
-				 last_index, "last_index");
-static cmdline_parse_token_num_t cmd_set_conntrack_common_last_index_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
-			      li, RTE_UINT8);
-
-static void cmd_set_conntrack_common_parsed(void *parsed_result,
-	__rte_unused struct cmdline *cl,
-	__rte_unused void *data)
-{
-	struct cmd_set_conntrack_common_result *res = parsed_result;
-
-	/* No need to swap to big endian. */
-	conntrack_context.peer_port = res->peer_port;
-	conntrack_context.is_original_dir = res->is_original;
-	conntrack_context.enable = res->en;
-	conntrack_context.live_connection = res->is_live;
-	conntrack_context.selective_ack = res->s_ack;
-	conntrack_context.challenge_ack_passed = res->c_ack;
-	conntrack_context.last_direction = res->ld;
-	conntrack_context.liberal_mode = res->lb;
-	conntrack_context.state = (enum rte_flow_conntrack_state)res->stat;
-	conntrack_context.max_ack_window = res->factor;
-	conntrack_context.retransmission_limit = res->re_num;
-	conntrack_context.last_window = res->lw;
-	conntrack_context.last_index =
-		(enum rte_flow_conntrack_tcp_last_index)res->li;
-	conntrack_context.last_seq = res->ls;
-	conntrack_context.last_ack = res->la;
-	conntrack_context.last_end = res->le;
-}
-
-static cmdline_parse_inst_t cmd_set_conntrack_common = {
-	.f = cmd_set_conntrack_common_parsed,
-	.data = NULL,
-	.help_str = "set conntrack com peer <port_id> is_orig <dir> enable <en>"
-		" live <ack_seen> sack <en> cack <passed> last_dir <dir>"
-		" liberal <en> state <s> max_ack_win <factor> r_lim <num>"
-		" last_win <win> last_seq <seq> last_ack <ack> last_end <end>"
-		" last_index <flag>",
-	.tokens = {
-		(void *)&cmd_set_conntrack_set,
-		(void *)&cmd_set_conntrack_conntrack,
-		(void *)&cmd_set_conntrack_common_com,
-		(void *)&cmd_set_conntrack_common_peer,
-		(void *)&cmd_set_conntrack_common_peer_value,
-		(void *)&cmd_set_conntrack_common_is_orig,
-		(void *)&cmd_set_conntrack_common_is_orig_value,
-		(void *)&cmd_set_conntrack_common_enable,
-		(void *)&cmd_set_conntrack_common_enable_value,
-		(void *)&cmd_set_conntrack_common_live,
-		(void *)&cmd_set_conntrack_common_live_value,
-		(void *)&cmd_set_conntrack_common_sack,
-		(void *)&cmd_set_conntrack_common_sack_value,
-		(void *)&cmd_set_conntrack_common_cack,
-		(void *)&cmd_set_conntrack_common_cack_value,
-		(void *)&cmd_set_conntrack_common_last_dir,
-		(void *)&cmd_set_conntrack_common_last_dir_value,
-		(void *)&cmd_set_conntrack_common_liberal,
-		(void *)&cmd_set_conntrack_common_liberal_value,
-		(void *)&cmd_set_conntrack_common_state,
-		(void *)&cmd_set_conntrack_common_state_value,
-		(void *)&cmd_set_conntrack_common_max_ackwin,
-		(void *)&cmd_set_conntrack_common_max_ackwin_value,
-		(void *)&cmd_set_conntrack_common_retrans,
-		(void *)&cmd_set_conntrack_common_retrans_value,
-		(void *)&cmd_set_conntrack_common_last_win,
-		(void *)&cmd_set_conntrack_common_last_win_value,
-		(void *)&cmd_set_conntrack_common_last_seq,
-		(void *)&cmd_set_conntrack_common_last_seq_value,
-		(void *)&cmd_set_conntrack_common_last_ack,
-		(void *)&cmd_set_conntrack_common_last_ack_value,
-		(void *)&cmd_set_conntrack_common_last_end,
-		(void *)&cmd_set_conntrack_common_last_end_value,
-		(void *)&cmd_set_conntrack_common_last_index,
-		(void *)&cmd_set_conntrack_common_last_index_value,
-		NULL,
-	},
-};
-
-/** Set connection tracking object both directions' details */
-struct cmd_set_conntrack_dir_result {
-	cmdline_fixed_string_t set;
-	cmdline_fixed_string_t conntrack;
-	cmdline_fixed_string_t dir;
-	cmdline_fixed_string_t scale;
-	cmdline_fixed_string_t fin;
-	cmdline_fixed_string_t ack_seen;
-	cmdline_fixed_string_t unack;
-	cmdline_fixed_string_t sent_end;
-	cmdline_fixed_string_t reply_end;
-	cmdline_fixed_string_t max_win;
-	cmdline_fixed_string_t max_ack;
-	uint32_t factor;
-	uint32_t f;
-	uint32_t as;
-	uint32_t un;
-	uint32_t se;
-	uint32_t re;
-	uint32_t mw;
-	uint32_t ma;
+	cmdline_fixed_string_t vxlan;
+	cmdline_fixed_string_t pos_token;
+	cmdline_fixed_string_t ip_version;
+	uint32_t vlan_present:1;
+	uint32_t vni;
+	uint16_t udp_src;
+	uint16_t udp_dst;
+	cmdline_ipaddr_t ip_src;
+	cmdline_ipaddr_t ip_dst;
+	uint16_t tci;
+	uint8_t tos;
+	uint8_t ttl;
+	struct rte_ether_addr eth_src;
+	struct rte_ether_addr eth_dst;
 };
 
-static cmdline_parse_token_string_t cmd_set_conntrack_dir_dir =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
-				 dir, "orig#rply");
-static cmdline_parse_token_string_t cmd_set_conntrack_dir_scale =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
-				 scale, "scale");
-static cmdline_parse_token_num_t cmd_set_conntrack_dir_scale_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result,
-			      factor, RTE_UINT32);
-static cmdline_parse_token_string_t cmd_set_conntrack_dir_fin =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
-				 fin, "fin");
-static cmdline_parse_token_num_t cmd_set_conntrack_dir_fin_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result,
-			      f, RTE_UINT32);
-static cmdline_parse_token_string_t cmd_set_conntrack_dir_ack =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
-				 ack_seen, "acked");
-static cmdline_parse_token_num_t cmd_set_conntrack_dir_ack_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result,
-			      as, RTE_UINT32);
-static cmdline_parse_token_string_t cmd_set_conntrack_dir_unack_data =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
-				 unack, "unack_data");
-static cmdline_parse_token_num_t cmd_set_conntrack_dir_unack_data_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result,
-			      un, RTE_UINT32);
-static cmdline_parse_token_string_t cmd_set_conntrack_dir_sent_end =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
-				 sent_end, "sent_end");
-static cmdline_parse_token_num_t cmd_set_conntrack_dir_sent_end_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result,
-			      se, RTE_UINT32);
-static cmdline_parse_token_string_t cmd_set_conntrack_dir_reply_end =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
-				 reply_end, "reply_end");
-static cmdline_parse_token_num_t cmd_set_conntrack_dir_reply_end_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result,
-			      re, RTE_UINT32);
-static cmdline_parse_token_string_t cmd_set_conntrack_dir_max_win =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
-				 max_win, "max_win");
-static cmdline_parse_token_num_t cmd_set_conntrack_dir_max_win_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result,
-			      mw, RTE_UINT32);
-static cmdline_parse_token_string_t cmd_set_conntrack_dir_max_ack =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
-				 max_ack, "max_ack");
-static cmdline_parse_token_num_t cmd_set_conntrack_dir_max_ack_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result,
-			      ma, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_set_vxlan_set =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, set, "set");
+static cmdline_parse_token_string_t cmd_set_vxlan_vxlan =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, vxlan, "vxlan");
+static cmdline_parse_token_string_t cmd_set_vxlan_vxlan_tos_ttl =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, vxlan,
+				 "vxlan-tos-ttl");
+static cmdline_parse_token_string_t cmd_set_vxlan_vxlan_with_vlan =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, vxlan,
+				 "vxlan-with-vlan");
+static cmdline_parse_token_string_t cmd_set_vxlan_ip_version =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, pos_token,
+				 "ip-version");
+static cmdline_parse_token_string_t cmd_set_vxlan_ip_version_value =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, ip_version,
+				 "ipv4#ipv6");
+static cmdline_parse_token_string_t cmd_set_vxlan_vni =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, pos_token,
+				 "vni");
+static cmdline_parse_token_num_t cmd_set_vxlan_vni_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_vxlan_result, vni, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_set_vxlan_udp_src =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, pos_token,
+				 "udp-src");
+static cmdline_parse_token_num_t cmd_set_vxlan_udp_src_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_vxlan_result, udp_src, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_set_vxlan_udp_dst =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, pos_token,
+				 "udp-dst");
+static cmdline_parse_token_num_t cmd_set_vxlan_udp_dst_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_vxlan_result, udp_dst, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_set_vxlan_ip_tos =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, pos_token,
+				 "ip-tos");
+static cmdline_parse_token_num_t cmd_set_vxlan_ip_tos_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_vxlan_result, tos, RTE_UINT8);
+static cmdline_parse_token_string_t cmd_set_vxlan_ip_ttl =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, pos_token,
+				 "ip-ttl");
+static cmdline_parse_token_num_t cmd_set_vxlan_ip_ttl_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_vxlan_result, ttl, RTE_UINT8);
+static cmdline_parse_token_string_t cmd_set_vxlan_ip_src =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, pos_token,
+				 "ip-src");
+static cmdline_parse_token_ipaddr_t cmd_set_vxlan_ip_src_value =
+	TOKEN_IPADDR_INITIALIZER(struct cmd_set_vxlan_result, ip_src);
+static cmdline_parse_token_string_t cmd_set_vxlan_ip_dst =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, pos_token,
+				 "ip-dst");
+static cmdline_parse_token_ipaddr_t cmd_set_vxlan_ip_dst_value =
+	TOKEN_IPADDR_INITIALIZER(struct cmd_set_vxlan_result, ip_dst);
+static cmdline_parse_token_string_t cmd_set_vxlan_vlan =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, pos_token,
+				 "vlan-tci");
+static cmdline_parse_token_num_t cmd_set_vxlan_vlan_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_vxlan_result, tci, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_set_vxlan_eth_src =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, pos_token,
+				 "eth-src");
+static cmdline_parse_token_etheraddr_t cmd_set_vxlan_eth_src_value =
+	TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_vxlan_result, eth_src);
+static cmdline_parse_token_string_t cmd_set_vxlan_eth_dst =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, pos_token,
+				 "eth-dst");
+static cmdline_parse_token_etheraddr_t cmd_set_vxlan_eth_dst_value =
+	TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_vxlan_result, eth_dst);
 
-static void cmd_set_conntrack_dir_parsed(void *parsed_result,
+static void cmd_set_vxlan_parsed(void *parsed_result,
 	__rte_unused struct cmdline *cl,
 	__rte_unused void *data)
-{
-	struct cmd_set_conntrack_dir_result *res = parsed_result;
-	struct rte_flow_tcp_dir_param *dir = NULL;
+{
+	struct cmd_set_vxlan_result *res = parsed_result;
+	union {
+		uint32_t vxlan_id;
+		uint8_t vni[4];
+	} id = {
+		.vxlan_id = rte_cpu_to_be_32(res->vni) & RTE_BE32(0x00ffffff),
+	};
 
-	if (strcmp(res->dir, "orig") == 0)
-		dir = &conntrack_context.original_dir;
-	else if (strcmp(res->dir, "rply") == 0)
-		dir = &conntrack_context.reply_dir;
+	vxlan_encap_conf.select_tos_ttl = 0;
+	if (strcmp(res->vxlan, "vxlan") == 0)
+		vxlan_encap_conf.select_vlan = 0;
+	else if (strcmp(res->vxlan, "vxlan-with-vlan") == 0)
+		vxlan_encap_conf.select_vlan = 1;
+	else if (strcmp(res->vxlan, "vxlan-tos-ttl") == 0) {
+		vxlan_encap_conf.select_vlan = 0;
+		vxlan_encap_conf.select_tos_ttl = 1;
+	}
+	if (strcmp(res->ip_version, "ipv4") == 0)
+		vxlan_encap_conf.select_ipv4 = 1;
+	else if (strcmp(res->ip_version, "ipv6") == 0)
+		vxlan_encap_conf.select_ipv4 = 0;
 	else
 		return;
-	dir->scale = res->factor;
-	dir->close_initiated = res->f;
-	dir->last_ack_seen = res->as;
-	dir->data_unacked = res->un;
-	dir->sent_end = res->se;
-	dir->reply_end = res->re;
-	dir->max_ack = res->ma;
-	dir->max_win = res->mw;
+	rte_memcpy(vxlan_encap_conf.vni, &id.vni[1], 3);
+	vxlan_encap_conf.udp_src = rte_cpu_to_be_16(res->udp_src);
+	vxlan_encap_conf.udp_dst = rte_cpu_to_be_16(res->udp_dst);
+	vxlan_encap_conf.ip_tos = res->tos;
+	vxlan_encap_conf.ip_ttl = res->ttl;
+	if (vxlan_encap_conf.select_ipv4) {
+		IPV4_ADDR_TO_UINT(res->ip_src, vxlan_encap_conf.ipv4_src);
+		IPV4_ADDR_TO_UINT(res->ip_dst, vxlan_encap_conf.ipv4_dst);
+	} else {
+		IPV6_ADDR_TO_ARRAY(res->ip_src, vxlan_encap_conf.ipv6_src);
+		IPV6_ADDR_TO_ARRAY(res->ip_dst, vxlan_encap_conf.ipv6_dst);
+	}
+	if (vxlan_encap_conf.select_vlan)
+		vxlan_encap_conf.vlan_tci = rte_cpu_to_be_16(res->tci);
+	rte_memcpy(vxlan_encap_conf.eth_src, res->eth_src.addr_bytes,
+		   RTE_ETHER_ADDR_LEN);
+	rte_memcpy(vxlan_encap_conf.eth_dst, res->eth_dst.addr_bytes,
+		   RTE_ETHER_ADDR_LEN);
 }
 
-static cmdline_parse_inst_t cmd_set_conntrack_dir = {
-	.f = cmd_set_conntrack_dir_parsed,
+static cmdline_parse_inst_t cmd_set_vxlan = {
+	.f = cmd_set_vxlan_parsed,
 	.data = NULL,
-	.help_str = "set conntrack orig|rply scale <factor> fin <sent>"
-		    " acked <seen> unack_data <unack> sent_end <sent>"
-		    " reply_end <reply> max_win <win> max_ack <ack>",
+	.help_str = "set vxlan ip-version ipv4|ipv6 vni <vni> udp-src"
+		" <udp-src> udp-dst <udp-dst> ip-src <ip-src> ip-dst <ip-dst>"
+		" eth-src <eth-src> eth-dst <eth-dst>",
 	.tokens = {
-		(void *)&cmd_set_conntrack_set,
-		(void *)&cmd_set_conntrack_conntrack,
-		(void *)&cmd_set_conntrack_dir_dir,
-		(void *)&cmd_set_conntrack_dir_scale,
-		(void *)&cmd_set_conntrack_dir_scale_value,
-		(void *)&cmd_set_conntrack_dir_fin,
-		(void *)&cmd_set_conntrack_dir_fin_value,
-		(void *)&cmd_set_conntrack_dir_ack,
-		(void *)&cmd_set_conntrack_dir_ack_value,
-		(void *)&cmd_set_conntrack_dir_unack_data,
-		(void *)&cmd_set_conntrack_dir_unack_data_value,
-		(void *)&cmd_set_conntrack_dir_sent_end,
-		(void *)&cmd_set_conntrack_dir_sent_end_value,
-		(void *)&cmd_set_conntrack_dir_reply_end,
-		(void *)&cmd_set_conntrack_dir_reply_end_value,
-		(void *)&cmd_set_conntrack_dir_max_win,
-		(void *)&cmd_set_conntrack_dir_max_win_value,
-		(void *)&cmd_set_conntrack_dir_max_ack,
-		(void *)&cmd_set_conntrack_dir_max_ack_value,
+		(void *)&cmd_set_vxlan_set,
+		(void *)&cmd_set_vxlan_vxlan,
+		(void *)&cmd_set_vxlan_ip_version,
+		(void *)&cmd_set_vxlan_ip_version_value,
+		(void *)&cmd_set_vxlan_vni,
+		(void *)&cmd_set_vxlan_vni_value,
+		(void *)&cmd_set_vxlan_udp_src,
+		(void *)&cmd_set_vxlan_udp_src_value,
+		(void *)&cmd_set_vxlan_udp_dst,
+		(void *)&cmd_set_vxlan_udp_dst_value,
+		(void *)&cmd_set_vxlan_ip_src,
+		(void *)&cmd_set_vxlan_ip_src_value,
+		(void *)&cmd_set_vxlan_ip_dst,
+		(void *)&cmd_set_vxlan_ip_dst_value,
+		(void *)&cmd_set_vxlan_eth_src,
+		(void *)&cmd_set_vxlan_eth_src_value,
+		(void *)&cmd_set_vxlan_eth_dst,
+		(void *)&cmd_set_vxlan_eth_dst_value,
 		NULL,
 	},
 };
 
-/* Strict link priority scheduling mode setting */
-static void
-cmd_strict_link_prio_parsed(
-	void *parsed_result,
-	__rte_unused struct cmdline *cl,
-	__rte_unused void *data)
-{
-	struct cmd_vf_tc_bw_result *res = parsed_result;
-	int ret = -ENOTSUP;
-
-	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
-		return;
-
-#ifdef RTE_NET_I40E
-	ret = rte_pmd_i40e_set_tc_strict_prio(res->port_id, res->tc_map);
-#endif
-
-	switch (ret) {
-	case 0:
-		break;
-	case -EINVAL:
-		fprintf(stderr, "invalid tc_bitmap 0x%x\n", res->tc_map);
-		break;
-	case -ENODEV:
-		fprintf(stderr, "invalid port_id %d\n", res->port_id);
-		break;
-	case -ENOTSUP:
-		fprintf(stderr, "function not implemented\n");
-		break;
-	default:
-		fprintf(stderr, "programming error: (%s)\n", strerror(-ret));
-	}
-}
-
-static cmdline_parse_inst_t cmd_strict_link_prio = {
-	.f = cmd_strict_link_prio_parsed,
+static cmdline_parse_inst_t cmd_set_vxlan_tos_ttl = {
+	.f = cmd_set_vxlan_parsed,
 	.data = NULL,
-	.help_str = "set tx strict-link-priority <port_id> <tc_bitmap>",
+	.help_str = "set vxlan-tos-ttl ip-version ipv4|ipv6 vni <vni> udp-src"
+		" <udp-src> udp-dst <udp-dst> ip-tos <ip-tos> ip-ttl <ip-ttl>"
+		" ip-src <ip-src> ip-dst <ip-dst> eth-src <eth-src>"
+		" eth-dst <eth-dst>",
 	.tokens = {
-		(void *)&cmd_vf_tc_bw_set,
-		(void *)&cmd_vf_tc_bw_tx,
-		(void *)&cmd_vf_tc_bw_strict_link_prio,
-		(void *)&cmd_vf_tc_bw_port_id,
-		(void *)&cmd_vf_tc_bw_tc_map,
+		(void *)&cmd_set_vxlan_set,
+		(void *)&cmd_set_vxlan_vxlan_tos_ttl,
+		(void *)&cmd_set_vxlan_ip_version,
+		(void *)&cmd_set_vxlan_ip_version_value,
+		(void *)&cmd_set_vxlan_vni,
+		(void *)&cmd_set_vxlan_vni_value,
+		(void *)&cmd_set_vxlan_udp_src,
+		(void *)&cmd_set_vxlan_udp_src_value,
+		(void *)&cmd_set_vxlan_udp_dst,
+		(void *)&cmd_set_vxlan_udp_dst_value,
+		(void *)&cmd_set_vxlan_ip_tos,
+		(void *)&cmd_set_vxlan_ip_tos_value,
+		(void *)&cmd_set_vxlan_ip_ttl,
+		(void *)&cmd_set_vxlan_ip_ttl_value,
+		(void *)&cmd_set_vxlan_ip_src,
+		(void *)&cmd_set_vxlan_ip_src_value,
+		(void *)&cmd_set_vxlan_ip_dst,
+		(void *)&cmd_set_vxlan_ip_dst_value,
+		(void *)&cmd_set_vxlan_eth_src,
+		(void *)&cmd_set_vxlan_eth_src_value,
+		(void *)&cmd_set_vxlan_eth_dst,
+		(void *)&cmd_set_vxlan_eth_dst_value,
 		NULL,
 	},
 };
 
-/* Load dynamic device personalization*/
-struct cmd_ddp_add_result {
-	cmdline_fixed_string_t ddp;
-	cmdline_fixed_string_t add;
-	portid_t port_id;
-	char filepath[];
+static cmdline_parse_inst_t cmd_set_vxlan_with_vlan = {
+	.f = cmd_set_vxlan_parsed,
+	.data = NULL,
+	.help_str = "set vxlan-with-vlan ip-version ipv4|ipv6 vni <vni>"
+		" udp-src <udp-src> udp-dst <udp-dst> ip-src <ip-src> ip-dst"
+		" <ip-dst> vlan-tci <vlan-tci> eth-src <eth-src> eth-dst"
+		" <eth-dst>",
+	.tokens = {
+		(void *)&cmd_set_vxlan_set,
+		(void *)&cmd_set_vxlan_vxlan_with_vlan,
+		(void *)&cmd_set_vxlan_ip_version,
+		(void *)&cmd_set_vxlan_ip_version_value,
+		(void *)&cmd_set_vxlan_vni,
+		(void *)&cmd_set_vxlan_vni_value,
+		(void *)&cmd_set_vxlan_udp_src,
+		(void *)&cmd_set_vxlan_udp_src_value,
+		(void *)&cmd_set_vxlan_udp_dst,
+		(void *)&cmd_set_vxlan_udp_dst_value,
+		(void *)&cmd_set_vxlan_ip_src,
+		(void *)&cmd_set_vxlan_ip_src_value,
+		(void *)&cmd_set_vxlan_ip_dst,
+		(void *)&cmd_set_vxlan_ip_dst_value,
+		(void *)&cmd_set_vxlan_vlan,
+		(void *)&cmd_set_vxlan_vlan_value,
+		(void *)&cmd_set_vxlan_eth_src,
+		(void *)&cmd_set_vxlan_eth_src_value,
+		(void *)&cmd_set_vxlan_eth_dst,
+		(void *)&cmd_set_vxlan_eth_dst_value,
+		NULL,
+	},
 };
 
-static cmdline_parse_token_string_t cmd_ddp_add_ddp =
-	TOKEN_STRING_INITIALIZER(struct cmd_ddp_add_result, ddp, "ddp");
-static cmdline_parse_token_string_t cmd_ddp_add_add =
-	TOKEN_STRING_INITIALIZER(struct cmd_ddp_add_result, add, "add");
-static cmdline_parse_token_num_t cmd_ddp_add_port_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_ddp_add_result, port_id,
-		RTE_UINT16);
-static cmdline_parse_token_string_t cmd_ddp_add_filepath =
-	TOKEN_STRING_INITIALIZER(struct cmd_ddp_add_result, filepath, NULL);
-
-static void
-cmd_ddp_add_parsed(
-	void *parsed_result,
-	__rte_unused struct cmdline *cl,
-	__rte_unused void *data)
-{
-	struct cmd_ddp_add_result *res = parsed_result;
-	uint8_t *buff;
-	uint32_t size;
-	char *filepath;
-	char *file_fld[2];
-	int file_num;
-	int ret = -ENOTSUP;
+/** Set NVGRE encapsulation details */
+struct cmd_set_nvgre_result {
+	cmdline_fixed_string_t set;
+	cmdline_fixed_string_t nvgre;
+	cmdline_fixed_string_t pos_token;
+	cmdline_fixed_string_t ip_version;
+	uint32_t tni;
+	cmdline_ipaddr_t ip_src;
+	cmdline_ipaddr_t ip_dst;
+	uint16_t tci;
+	struct rte_ether_addr eth_src;
+	struct rte_ether_addr eth_dst;
+};
 
-	if (!all_ports_stopped()) {
-		fprintf(stderr, "Please stop all ports first\n");
-		return;
-	}
+static cmdline_parse_token_string_t cmd_set_nvgre_set =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_nvgre_result, set, "set");
+static cmdline_parse_token_string_t cmd_set_nvgre_nvgre =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_nvgre_result, nvgre, "nvgre");
+static cmdline_parse_token_string_t cmd_set_nvgre_nvgre_with_vlan =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_nvgre_result, nvgre,
+				 "nvgre-with-vlan");
+static cmdline_parse_token_string_t cmd_set_nvgre_ip_version =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_nvgre_result, pos_token,
+				 "ip-version");
+static cmdline_parse_token_string_t cmd_set_nvgre_ip_version_value =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_nvgre_result, ip_version,
+				 "ipv4#ipv6");
+static cmdline_parse_token_string_t cmd_set_nvgre_tni =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_nvgre_result, pos_token,
+				 "tni");
+static cmdline_parse_token_num_t cmd_set_nvgre_tni_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_nvgre_result, tni, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_set_nvgre_ip_src =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_nvgre_result, pos_token,
+				 "ip-src");
+static cmdline_parse_token_num_t cmd_set_nvgre_ip_src_value =
+	TOKEN_IPADDR_INITIALIZER(struct cmd_set_nvgre_result, ip_src);
+static cmdline_parse_token_string_t cmd_set_nvgre_ip_dst =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_nvgre_result, pos_token,
+				 "ip-dst");
+static cmdline_parse_token_ipaddr_t cmd_set_nvgre_ip_dst_value =
+	TOKEN_IPADDR_INITIALIZER(struct cmd_set_nvgre_result, ip_dst);
+static cmdline_parse_token_string_t cmd_set_nvgre_vlan =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_nvgre_result, pos_token,
+				 "vlan-tci");
+static cmdline_parse_token_num_t cmd_set_nvgre_vlan_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_nvgre_result, tci, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_set_nvgre_eth_src =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_nvgre_result, pos_token,
+				 "eth-src");
+static cmdline_parse_token_etheraddr_t cmd_set_nvgre_eth_src_value =
+	TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_nvgre_result, eth_src);
+static cmdline_parse_token_string_t cmd_set_nvgre_eth_dst =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_nvgre_result, pos_token,
+				 "eth-dst");
+static cmdline_parse_token_etheraddr_t cmd_set_nvgre_eth_dst_value =
+	TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_nvgre_result, eth_dst);
 
-	filepath = strdup(res->filepath);
-	if (filepath == NULL) {
-		fprintf(stderr, "Failed to allocate memory\n");
-		return;
-	}
-	file_num = rte_strsplit(filepath, strlen(filepath), file_fld, 2, ',');
+static void cmd_set_nvgre_parsed(void *parsed_result,
+	__rte_unused struct cmdline *cl,
+	__rte_unused void *data)
+{
+	struct cmd_set_nvgre_result *res = parsed_result;
+	union {
+		uint32_t nvgre_tni;
+		uint8_t tni[4];
+	} id = {
+		.nvgre_tni = rte_cpu_to_be_32(res->tni) & RTE_BE32(0x00ffffff),
+	};
 
-	buff = open_file(file_fld[0], &size);
-	if (!buff) {
-		free((void *)filepath);
+	if (strcmp(res->nvgre, "nvgre") == 0)
+		nvgre_encap_conf.select_vlan = 0;
+	else if (strcmp(res->nvgre, "nvgre-with-vlan") == 0)
+		nvgre_encap_conf.select_vlan = 1;
+	if (strcmp(res->ip_version, "ipv4") == 0)
+		nvgre_encap_conf.select_ipv4 = 1;
+	else if (strcmp(res->ip_version, "ipv6") == 0)
+		nvgre_encap_conf.select_ipv4 = 0;
+	else
 		return;
+	rte_memcpy(nvgre_encap_conf.tni, &id.tni[1], 3);
+	if (nvgre_encap_conf.select_ipv4) {
+		IPV4_ADDR_TO_UINT(res->ip_src, nvgre_encap_conf.ipv4_src);
+		IPV4_ADDR_TO_UINT(res->ip_dst, nvgre_encap_conf.ipv4_dst);
+	} else {
+		IPV6_ADDR_TO_ARRAY(res->ip_src, nvgre_encap_conf.ipv6_src);
+		IPV6_ADDR_TO_ARRAY(res->ip_dst, nvgre_encap_conf.ipv6_dst);
 	}
-
-#ifdef RTE_NET_I40E
-	if (ret == -ENOTSUP)
-		ret = rte_pmd_i40e_process_ddp_package(res->port_id,
-					       buff, size,
-					       RTE_PMD_I40E_PKG_OP_WR_ADD);
-#endif
-
-	if (ret == -EEXIST)
-		fprintf(stderr, "Profile has already existed.\n");
-	else if (ret < 0)
-		fprintf(stderr, "Failed to load profile.\n");
-	else if (file_num == 2)
-		save_file(file_fld[1], buff, size);
-
-	close_file(buff);
-	free((void *)filepath);
+	if (nvgre_encap_conf.select_vlan)
+		nvgre_encap_conf.vlan_tci = rte_cpu_to_be_16(res->tci);
+	rte_memcpy(nvgre_encap_conf.eth_src, res->eth_src.addr_bytes,
+		   RTE_ETHER_ADDR_LEN);
+	rte_memcpy(nvgre_encap_conf.eth_dst, res->eth_dst.addr_bytes,
+		   RTE_ETHER_ADDR_LEN);
 }
 
-static cmdline_parse_inst_t cmd_ddp_add = {
-	.f = cmd_ddp_add_parsed,
+static cmdline_parse_inst_t cmd_set_nvgre = {
+	.f = cmd_set_nvgre_parsed,
 	.data = NULL,
-	.help_str = "ddp add <port_id> <profile_path[,backup_profile_path]>",
+	.help_str = "set nvgre ip-version <ipv4|ipv6> tni <tni> ip-src"
+		" <ip-src> ip-dst <ip-dst> eth-src <eth-src>"
+		" eth-dst <eth-dst>",
 	.tokens = {
-		(void *)&cmd_ddp_add_ddp,
-		(void *)&cmd_ddp_add_add,
-		(void *)&cmd_ddp_add_port_id,
-		(void *)&cmd_ddp_add_filepath,
+		(void *)&cmd_set_nvgre_set,
+		(void *)&cmd_set_nvgre_nvgre,
+		(void *)&cmd_set_nvgre_ip_version,
+		(void *)&cmd_set_nvgre_ip_version_value,
+		(void *)&cmd_set_nvgre_tni,
+		(void *)&cmd_set_nvgre_tni_value,
+		(void *)&cmd_set_nvgre_ip_src,
+		(void *)&cmd_set_nvgre_ip_src_value,
+		(void *)&cmd_set_nvgre_ip_dst,
+		(void *)&cmd_set_nvgre_ip_dst_value,
+		(void *)&cmd_set_nvgre_eth_src,
+		(void *)&cmd_set_nvgre_eth_src_value,
+		(void *)&cmd_set_nvgre_eth_dst,
+		(void *)&cmd_set_nvgre_eth_dst_value,
 		NULL,
 	},
 };
 
-/* Delete dynamic device personalization*/
-struct cmd_ddp_del_result {
-	cmdline_fixed_string_t ddp;
-	cmdline_fixed_string_t del;
-	portid_t port_id;
-	char filepath[];
-};
-
-static cmdline_parse_token_string_t cmd_ddp_del_ddp =
-	TOKEN_STRING_INITIALIZER(struct cmd_ddp_del_result, ddp, "ddp");
-static cmdline_parse_token_string_t cmd_ddp_del_del =
-	TOKEN_STRING_INITIALIZER(struct cmd_ddp_del_result, del, "del");
-static cmdline_parse_token_num_t cmd_ddp_del_port_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_ddp_del_result, port_id, RTE_UINT16);
-static cmdline_parse_token_string_t cmd_ddp_del_filepath =
-	TOKEN_STRING_INITIALIZER(struct cmd_ddp_del_result, filepath, NULL);
-
-static void
-cmd_ddp_del_parsed(
-	void *parsed_result,
-	__rte_unused struct cmdline *cl,
-	__rte_unused void *data)
-{
-	struct cmd_ddp_del_result *res = parsed_result;
-	uint8_t *buff;
-	uint32_t size;
-	int ret = -ENOTSUP;
-
-	if (!all_ports_stopped()) {
-		fprintf(stderr, "Please stop all ports first\n");
-		return;
-	}
-
-	buff = open_file(res->filepath, &size);
-	if (!buff)
-		return;
-
-#ifdef RTE_NET_I40E
-	if (ret == -ENOTSUP)
-		ret = rte_pmd_i40e_process_ddp_package(res->port_id,
-					       buff, size,
-					       RTE_PMD_I40E_PKG_OP_WR_DEL);
-#endif
-
-	if (ret == -EACCES)
-		fprintf(stderr, "Profile does not exist.\n");
-	else if (ret < 0)
-		fprintf(stderr, "Failed to delete profile.\n");
-
-	close_file(buff);
-}
-
-static cmdline_parse_inst_t cmd_ddp_del = {
-	.f = cmd_ddp_del_parsed,
+static cmdline_parse_inst_t cmd_set_nvgre_with_vlan = {
+	.f = cmd_set_nvgre_parsed,
 	.data = NULL,
-	.help_str = "ddp del <port_id> <backup_profile_path>",
+	.help_str = "set nvgre-with-vlan ip-version <ipv4|ipv6> tni <tni>"
+		" ip-src <ip-src> ip-dst <ip-dst> vlan-tci <vlan-tci>"
+		" eth-src <eth-src> eth-dst <eth-dst>",
 	.tokens = {
-		(void *)&cmd_ddp_del_ddp,
-		(void *)&cmd_ddp_del_del,
-		(void *)&cmd_ddp_del_port_id,
-		(void *)&cmd_ddp_del_filepath,
+		(void *)&cmd_set_nvgre_set,
+		(void *)&cmd_set_nvgre_nvgre_with_vlan,
+		(void *)&cmd_set_nvgre_ip_version,
+		(void *)&cmd_set_nvgre_ip_version_value,
+		(void *)&cmd_set_nvgre_tni,
+		(void *)&cmd_set_nvgre_tni_value,
+		(void *)&cmd_set_nvgre_ip_src,
+		(void *)&cmd_set_nvgre_ip_src_value,
+		(void *)&cmd_set_nvgre_ip_dst,
+		(void *)&cmd_set_nvgre_ip_dst_value,
+		(void *)&cmd_set_nvgre_vlan,
+		(void *)&cmd_set_nvgre_vlan_value,
+		(void *)&cmd_set_nvgre_eth_src,
+		(void *)&cmd_set_nvgre_eth_src_value,
+		(void *)&cmd_set_nvgre_eth_dst,
+		(void *)&cmd_set_nvgre_eth_dst_value,
 		NULL,
 	},
 };
 
-/* Get dynamic device personalization profile info */
-struct cmd_ddp_info_result {
-	cmdline_fixed_string_t ddp;
-	cmdline_fixed_string_t get;
-	cmdline_fixed_string_t info;
-	char filepath[];
+/** Set L2 encapsulation details */
+struct cmd_set_l2_encap_result {
+	cmdline_fixed_string_t set;
+	cmdline_fixed_string_t l2_encap;
+	cmdline_fixed_string_t pos_token;
+	cmdline_fixed_string_t ip_version;
+	uint32_t vlan_present:1;
+	uint16_t tci;
+	struct rte_ether_addr eth_src;
+	struct rte_ether_addr eth_dst;
 };
 
-static cmdline_parse_token_string_t cmd_ddp_info_ddp =
-	TOKEN_STRING_INITIALIZER(struct cmd_ddp_info_result, ddp, "ddp");
-static cmdline_parse_token_string_t cmd_ddp_info_get =
-	TOKEN_STRING_INITIALIZER(struct cmd_ddp_info_result, get, "get");
-static cmdline_parse_token_string_t cmd_ddp_info_info =
-	TOKEN_STRING_INITIALIZER(struct cmd_ddp_info_result, info, "info");
-static cmdline_parse_token_string_t cmd_ddp_info_filepath =
-	TOKEN_STRING_INITIALIZER(struct cmd_ddp_info_result, filepath, NULL);
+static cmdline_parse_token_string_t cmd_set_l2_encap_set =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_l2_encap_result, set, "set");
+static cmdline_parse_token_string_t cmd_set_l2_encap_l2_encap =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_l2_encap_result, l2_encap, "l2_encap");
+static cmdline_parse_token_string_t cmd_set_l2_encap_l2_encap_with_vlan =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_l2_encap_result, l2_encap,
+				 "l2_encap-with-vlan");
+static cmdline_parse_token_string_t cmd_set_l2_encap_ip_version =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_l2_encap_result, pos_token,
+				 "ip-version");
+static cmdline_parse_token_string_t cmd_set_l2_encap_ip_version_value =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_l2_encap_result, ip_version,
+				 "ipv4#ipv6");
+static cmdline_parse_token_string_t cmd_set_l2_encap_vlan =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_l2_encap_result, pos_token,
+				 "vlan-tci");
+static cmdline_parse_token_num_t cmd_set_l2_encap_vlan_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_l2_encap_result, tci, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_set_l2_encap_eth_src =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_l2_encap_result, pos_token,
+				 "eth-src");
+static cmdline_parse_token_etheraddr_t cmd_set_l2_encap_eth_src_value =
+	TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_l2_encap_result, eth_src);
+static cmdline_parse_token_string_t cmd_set_l2_encap_eth_dst =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_l2_encap_result, pos_token,
+				 "eth-dst");
+static cmdline_parse_token_etheraddr_t cmd_set_l2_encap_eth_dst_value =
+	TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_l2_encap_result, eth_dst);
 
-static void
-cmd_ddp_info_parsed(
-	void *parsed_result,
+static void cmd_set_l2_encap_parsed(void *parsed_result,
 	__rte_unused struct cmdline *cl,
 	__rte_unused void *data)
 {
-	struct cmd_ddp_info_result *res = parsed_result;
-	uint8_t *pkg;
-	uint32_t pkg_size;
-	int ret = -ENOTSUP;
-#ifdef RTE_NET_I40E
-	uint32_t i, j, n;
-	uint8_t *buff;
-	uint32_t buff_size = 0;
-	struct rte_pmd_i40e_profile_info info;
-	uint32_t dev_num = 0;
-	struct rte_pmd_i40e_ddp_device_id *devs;
-	uint32_t proto_num = 0;
-	struct rte_pmd_i40e_proto_info *proto = NULL;
-	uint32_t pctype_num = 0;
-	struct rte_pmd_i40e_ptype_info *pctype;
-	uint32_t ptype_num = 0;
-	struct rte_pmd_i40e_ptype_info *ptype;
-	uint8_t proto_id;
-
-#endif
+	struct cmd_set_l2_encap_result *res = parsed_result;
 
-	pkg = open_file(res->filepath, &pkg_size);
-	if (!pkg)
+	if (strcmp(res->l2_encap, "l2_encap") == 0)
+		l2_encap_conf.select_vlan = 0;
+	else if (strcmp(res->l2_encap, "l2_encap-with-vlan") == 0)
+		l2_encap_conf.select_vlan = 1;
+	if (strcmp(res->ip_version, "ipv4") == 0)
+		l2_encap_conf.select_ipv4 = 1;
+	else if (strcmp(res->ip_version, "ipv6") == 0)
+		l2_encap_conf.select_ipv4 = 0;
+	else
 		return;
-
-#ifdef RTE_NET_I40E
-	ret = rte_pmd_i40e_get_ddp_info(pkg, pkg_size,
-				(uint8_t *)&info, sizeof(info),
-				RTE_PMD_I40E_PKG_INFO_GLOBAL_HEADER);
-	if (!ret) {
-		printf("Global Track id:       0x%x\n", info.track_id);
-		printf("Global Version:        %d.%d.%d.%d\n",
-			info.version.major,
-			info.version.minor,
-			info.version.update,
-			info.version.draft);
-		printf("Global Package name:   %s\n\n", info.name);
-	}
-
-	ret = rte_pmd_i40e_get_ddp_info(pkg, pkg_size,
-				(uint8_t *)&info, sizeof(info),
-				RTE_PMD_I40E_PKG_INFO_HEADER);
-	if (!ret) {
-		printf("i40e Profile Track id: 0x%x\n", info.track_id);
-		printf("i40e Profile Version:  %d.%d.%d.%d\n",
-			info.version.major,
-			info.version.minor,
-			info.version.update,
-			info.version.draft);
-		printf("i40e Profile name:     %s\n\n", info.name);
-	}
-
-	ret = rte_pmd_i40e_get_ddp_info(pkg, pkg_size,
-				(uint8_t *)&buff_size, sizeof(buff_size),
-				RTE_PMD_I40E_PKG_INFO_GLOBAL_NOTES_SIZE);
-	if (!ret && buff_size) {
-		buff = (uint8_t *)malloc(buff_size);
-		if (buff) {
-			ret = rte_pmd_i40e_get_ddp_info(pkg, pkg_size,
-						buff, buff_size,
-						RTE_PMD_I40E_PKG_INFO_GLOBAL_NOTES);
-			if (!ret)
-				printf("Package Notes:\n%s\n\n", buff);
-			free(buff);
-		}
-	}
-
-	ret = rte_pmd_i40e_get_ddp_info(pkg, pkg_size,
-				(uint8_t *)&dev_num, sizeof(dev_num),
-				RTE_PMD_I40E_PKG_INFO_DEVID_NUM);
-	if (!ret && dev_num) {
-		buff_size = dev_num * sizeof(struct rte_pmd_i40e_ddp_device_id);
-		devs = (struct rte_pmd_i40e_ddp_device_id *)malloc(buff_size);
-		if (devs) {
-			ret = rte_pmd_i40e_get_ddp_info(pkg, pkg_size,
-						(uint8_t *)devs, buff_size,
-						RTE_PMD_I40E_PKG_INFO_DEVID_LIST);
-			if (!ret) {
-				printf("List of supported devices:\n");
-				for (i = 0; i < dev_num; i++) {
-					printf("  %04X:%04X %04X:%04X\n",
-						devs[i].vendor_dev_id >> 16,
-						devs[i].vendor_dev_id & 0xFFFF,
-						devs[i].sub_vendor_dev_id >> 16,
-						devs[i].sub_vendor_dev_id & 0xFFFF);
-				}
-				printf("\n");
-			}
-			free(devs);
-		}
-	}
-
-	/* get information about protocols and packet types */
-	ret = rte_pmd_i40e_get_ddp_info(pkg, pkg_size,
-		(uint8_t *)&proto_num, sizeof(proto_num),
-		RTE_PMD_I40E_PKG_INFO_PROTOCOL_NUM);
-	if (ret || !proto_num)
-		goto no_print_return;
-
-	buff_size = proto_num * sizeof(struct rte_pmd_i40e_proto_info);
-	proto = (struct rte_pmd_i40e_proto_info *)malloc(buff_size);
-	if (!proto)
-		goto no_print_return;
-
-	ret = rte_pmd_i40e_get_ddp_info(pkg, pkg_size, (uint8_t *)proto,
-					buff_size,
-					RTE_PMD_I40E_PKG_INFO_PROTOCOL_LIST);
-	if (!ret) {
-		printf("List of used protocols:\n");
-		for (i = 0; i < proto_num; i++)
-			printf("  %2u: %s\n", proto[i].proto_id,
-			       proto[i].name);
-		printf("\n");
-	}
-	ret = rte_pmd_i40e_get_ddp_info(pkg, pkg_size,
-		(uint8_t *)&pctype_num, sizeof(pctype_num),
-		RTE_PMD_I40E_PKG_INFO_PCTYPE_NUM);
-	if (ret || !pctype_num)
-		goto no_print_pctypes;
-
-	buff_size = pctype_num * sizeof(struct rte_pmd_i40e_ptype_info);
-	pctype = (struct rte_pmd_i40e_ptype_info *)malloc(buff_size);
-	if (!pctype)
-		goto no_print_pctypes;
-
-	ret = rte_pmd_i40e_get_ddp_info(pkg, pkg_size, (uint8_t *)pctype,
-					buff_size,
-					RTE_PMD_I40E_PKG_INFO_PCTYPE_LIST);
-	if (ret) {
-		free(pctype);
-		goto no_print_pctypes;
-	}
-
-	printf("List of defined packet classification types:\n");
-	for (i = 0; i < pctype_num; i++) {
-		printf("  %2u:", pctype[i].ptype_id);
-		for (j = 0; j < RTE_PMD_I40E_PROTO_NUM; j++) {
-			proto_id = pctype[i].protocols[j];
-			if (proto_id != RTE_PMD_I40E_PROTO_UNUSED) {
-				for (n = 0; n < proto_num; n++) {
-					if (proto[n].proto_id == proto_id) {
-						printf(" %s", proto[n].name);
-						break;
-					}
-				}
-			}
-		}
-		printf("\n");
-	}
-	printf("\n");
-	free(pctype);
-
-no_print_pctypes:
-
-	ret = rte_pmd_i40e_get_ddp_info(pkg, pkg_size, (uint8_t *)&ptype_num,
-					sizeof(ptype_num),
-					RTE_PMD_I40E_PKG_INFO_PTYPE_NUM);
-	if (ret || !ptype_num)
-		goto no_print_return;
-
-	buff_size = ptype_num * sizeof(struct rte_pmd_i40e_ptype_info);
-	ptype = (struct rte_pmd_i40e_ptype_info *)malloc(buff_size);
-	if (!ptype)
-		goto no_print_return;
-
-	ret = rte_pmd_i40e_get_ddp_info(pkg, pkg_size, (uint8_t *)ptype,
-					buff_size,
-					RTE_PMD_I40E_PKG_INFO_PTYPE_LIST);
-	if (ret) {
-		free(ptype);
-		goto no_print_return;
-	}
-	printf("List of defined packet types:\n");
-	for (i = 0; i < ptype_num; i++) {
-		printf("  %2u:", ptype[i].ptype_id);
-		for (j = 0; j < RTE_PMD_I40E_PROTO_NUM; j++) {
-			proto_id = ptype[i].protocols[j];
-			if (proto_id != RTE_PMD_I40E_PROTO_UNUSED) {
-				for (n = 0; n < proto_num; n++) {
-					if (proto[n].proto_id == proto_id) {
-						printf(" %s", proto[n].name);
-						break;
-					}
-				}
-			}
-		}
-		printf("\n");
-	}
-	free(ptype);
-	printf("\n");
-
-	ret = 0;
-no_print_return:
-	free(proto);
-#endif
-	if (ret == -ENOTSUP)
-		fprintf(stderr, "Function not supported in PMD\n");
-	close_file(pkg);
+	if (l2_encap_conf.select_vlan)
+		l2_encap_conf.vlan_tci = rte_cpu_to_be_16(res->tci);
+	rte_memcpy(l2_encap_conf.eth_src, res->eth_src.addr_bytes,
+		   RTE_ETHER_ADDR_LEN);
+	rte_memcpy(l2_encap_conf.eth_dst, res->eth_dst.addr_bytes,
+		   RTE_ETHER_ADDR_LEN);
 }
 
-static cmdline_parse_inst_t cmd_ddp_get_info = {
-	.f = cmd_ddp_info_parsed,
+static cmdline_parse_inst_t cmd_set_l2_encap = {
+	.f = cmd_set_l2_encap_parsed,
 	.data = NULL,
-	.help_str = "ddp get info <profile_path>",
+	.help_str = "set l2_encap ip-version ipv4|ipv6"
+		" eth-src <eth-src> eth-dst <eth-dst>",
 	.tokens = {
-		(void *)&cmd_ddp_info_ddp,
-		(void *)&cmd_ddp_info_get,
-		(void *)&cmd_ddp_info_info,
-		(void *)&cmd_ddp_info_filepath,
+		(void *)&cmd_set_l2_encap_set,
+		(void *)&cmd_set_l2_encap_l2_encap,
+		(void *)&cmd_set_l2_encap_ip_version,
+		(void *)&cmd_set_l2_encap_ip_version_value,
+		(void *)&cmd_set_l2_encap_eth_src,
+		(void *)&cmd_set_l2_encap_eth_src_value,
+		(void *)&cmd_set_l2_encap_eth_dst,
+		(void *)&cmd_set_l2_encap_eth_dst_value,
 		NULL,
 	},
 };
 
-/* Get dynamic device personalization profile info list*/
-#define PROFILE_INFO_SIZE 48
-#define MAX_PROFILE_NUM 16
-
-struct cmd_ddp_get_list_result {
-	cmdline_fixed_string_t ddp;
-	cmdline_fixed_string_t get;
-	cmdline_fixed_string_t list;
-	portid_t port_id;
-};
-
-static cmdline_parse_token_string_t cmd_ddp_get_list_ddp =
-	TOKEN_STRING_INITIALIZER(struct cmd_ddp_get_list_result, ddp, "ddp");
-static cmdline_parse_token_string_t cmd_ddp_get_list_get =
-	TOKEN_STRING_INITIALIZER(struct cmd_ddp_get_list_result, get, "get");
-static cmdline_parse_token_string_t cmd_ddp_get_list_list =
-	TOKEN_STRING_INITIALIZER(struct cmd_ddp_get_list_result, list, "list");
-static cmdline_parse_token_num_t cmd_ddp_get_list_port_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_ddp_get_list_result, port_id,
-		RTE_UINT16);
-
-static void
-cmd_ddp_get_list_parsed(
-	__rte_unused void *parsed_result,
-	__rte_unused struct cmdline *cl,
-	__rte_unused void *data)
-{
-#ifdef RTE_NET_I40E
-	struct cmd_ddp_get_list_result *res = parsed_result;
-	struct rte_pmd_i40e_profile_list *p_list;
-	struct rte_pmd_i40e_profile_info *p_info;
-	uint32_t p_num;
-	uint32_t size;
-	uint32_t i;
-#endif
-	int ret = -ENOTSUP;
-
-#ifdef RTE_NET_I40E
-	size = PROFILE_INFO_SIZE * MAX_PROFILE_NUM + 4;
-	p_list = (struct rte_pmd_i40e_profile_list *)malloc(size);
-	if (!p_list) {
-		fprintf(stderr, "%s: Failed to malloc buffer\n", __func__);
-		return;
-	}
-
-	if (ret == -ENOTSUP)
-		ret = rte_pmd_i40e_get_ddp_list(res->port_id,
-						(uint8_t *)p_list, size);
-
-	if (!ret) {
-		p_num = p_list->p_count;
-		printf("Profile number is: %d\n\n", p_num);
-
-		for (i = 0; i < p_num; i++) {
-			p_info = &p_list->p_info[i];
-			printf("Profile %d:\n", i);
-			printf("Track id:     0x%x\n", p_info->track_id);
-			printf("Version:      %d.%d.%d.%d\n",
-			       p_info->version.major,
-			       p_info->version.minor,
-			       p_info->version.update,
-			       p_info->version.draft);
-			printf("Profile name: %s\n\n", p_info->name);
-		}
-	}
-
-	free(p_list);
-#endif
-
-	if (ret < 0)
-		fprintf(stderr, "Failed to get ddp list\n");
-}
-
-static cmdline_parse_inst_t cmd_ddp_get_list = {
-	.f = cmd_ddp_get_list_parsed,
+static cmdline_parse_inst_t cmd_set_l2_encap_with_vlan = {
+	.f = cmd_set_l2_encap_parsed,
 	.data = NULL,
-	.help_str = "ddp get list <port_id>",
+	.help_str = "set l2_encap-with-vlan ip-version ipv4|ipv6"
+		" vlan-tci <vlan-tci> eth-src <eth-src> eth-dst <eth-dst>",
 	.tokens = {
-		(void *)&cmd_ddp_get_list_ddp,
-		(void *)&cmd_ddp_get_list_get,
-		(void *)&cmd_ddp_get_list_list,
-		(void *)&cmd_ddp_get_list_port_id,
+		(void *)&cmd_set_l2_encap_set,
+		(void *)&cmd_set_l2_encap_l2_encap_with_vlan,
+		(void *)&cmd_set_l2_encap_ip_version,
+		(void *)&cmd_set_l2_encap_ip_version_value,
+		(void *)&cmd_set_l2_encap_vlan,
+		(void *)&cmd_set_l2_encap_vlan_value,
+		(void *)&cmd_set_l2_encap_eth_src,
+		(void *)&cmd_set_l2_encap_eth_src_value,
+		(void *)&cmd_set_l2_encap_eth_dst,
+		(void *)&cmd_set_l2_encap_eth_dst_value,
 		NULL,
 	},
 };
 
-/* Configure input set */
-struct cmd_cfg_input_set_result {
-	cmdline_fixed_string_t port;
-	cmdline_fixed_string_t cfg;
-	portid_t port_id;
-	cmdline_fixed_string_t pctype;
-	uint8_t pctype_id;
-	cmdline_fixed_string_t inset_type;
-	cmdline_fixed_string_t opt;
-	cmdline_fixed_string_t field;
-	uint8_t field_idx;
+/** Set L2 decapsulation details */
+struct cmd_set_l2_decap_result {
+	cmdline_fixed_string_t set;
+	cmdline_fixed_string_t l2_decap;
+	cmdline_fixed_string_t pos_token;
+	uint32_t vlan_present:1;
 };
 
-static void
-cmd_cfg_input_set_parsed(
-	__rte_unused void *parsed_result,
+static cmdline_parse_token_string_t cmd_set_l2_decap_set =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_l2_decap_result, set, "set");
+static cmdline_parse_token_string_t cmd_set_l2_decap_l2_decap =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_l2_decap_result, l2_decap,
+				 "l2_decap");
+static cmdline_parse_token_string_t cmd_set_l2_decap_l2_decap_with_vlan =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_l2_decap_result, l2_decap,
+				 "l2_decap-with-vlan");
+
+static void cmd_set_l2_decap_parsed(void *parsed_result,
 	__rte_unused struct cmdline *cl,
 	__rte_unused void *data)
 {
-#ifdef RTE_NET_I40E
-	struct cmd_cfg_input_set_result *res = parsed_result;
-	enum rte_pmd_i40e_inset_type inset_type = INSET_NONE;
-	struct rte_pmd_i40e_inset inset;
-#endif
-	int ret = -ENOTSUP;
-
-	if (!all_ports_stopped()) {
-		fprintf(stderr, "Please stop all ports first\n");
-		return;
-	}
-
-#ifdef RTE_NET_I40E
-	if (!strcmp(res->inset_type, "hash_inset"))
-		inset_type = INSET_HASH;
-	else if (!strcmp(res->inset_type, "fdir_inset"))
-		inset_type = INSET_FDIR;
-	else if (!strcmp(res->inset_type, "fdir_flx_inset"))
-		inset_type = INSET_FDIR_FLX;
-	ret = rte_pmd_i40e_inset_get(res->port_id, res->pctype_id,
-				     &inset, inset_type);
-	if (ret) {
-		fprintf(stderr, "Failed to get input set.\n");
-		return;
-	}
-
-	if (!strcmp(res->opt, "get")) {
-		ret = rte_pmd_i40e_inset_field_get(inset.inset,
-						   res->field_idx);
-		if (ret)
-			printf("Field index %d is enabled.\n", res->field_idx);
-		else
-			printf("Field index %d is disabled.\n", res->field_idx);
-		return;
-	} else if (!strcmp(res->opt, "set"))
-		ret = rte_pmd_i40e_inset_field_set(&inset.inset,
-						   res->field_idx);
-	else if (!strcmp(res->opt, "clear"))
-		ret = rte_pmd_i40e_inset_field_clear(&inset.inset,
-						     res->field_idx);
-	if (ret) {
-		fprintf(stderr, "Failed to configure input set field.\n");
-		return;
-	}
-
-	ret = rte_pmd_i40e_inset_set(res->port_id, res->pctype_id,
-				     &inset, inset_type);
-	if (ret) {
-		fprintf(stderr, "Failed to set input set.\n");
-		return;
-	}
-#endif
+	struct cmd_set_l2_decap_result *res = parsed_result;
 
-	if (ret == -ENOTSUP)
-		fprintf(stderr, "Function not supported\n");
+	if (strcmp(res->l2_decap, "l2_decap") == 0)
+		l2_decap_conf.select_vlan = 0;
+	else if (strcmp(res->l2_decap, "l2_decap-with-vlan") == 0)
+		l2_decap_conf.select_vlan = 1;
 }
 
-static cmdline_parse_token_string_t cmd_cfg_input_set_port =
-	TOKEN_STRING_INITIALIZER(struct cmd_cfg_input_set_result,
-				 port, "port");
-static cmdline_parse_token_string_t cmd_cfg_input_set_cfg =
-	TOKEN_STRING_INITIALIZER(struct cmd_cfg_input_set_result,
-				 cfg, "config");
-static cmdline_parse_token_num_t cmd_cfg_input_set_port_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_cfg_input_set_result,
-			      port_id, RTE_UINT16);
-static cmdline_parse_token_string_t cmd_cfg_input_set_pctype =
-	TOKEN_STRING_INITIALIZER(struct cmd_cfg_input_set_result,
-				 pctype, "pctype");
-static cmdline_parse_token_num_t cmd_cfg_input_set_pctype_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_cfg_input_set_result,
-			      pctype_id, RTE_UINT8);
-static cmdline_parse_token_string_t cmd_cfg_input_set_inset_type =
-	TOKEN_STRING_INITIALIZER(struct cmd_cfg_input_set_result,
-				 inset_type,
-				 "hash_inset#fdir_inset#fdir_flx_inset");
-static cmdline_parse_token_string_t cmd_cfg_input_set_opt =
-	TOKEN_STRING_INITIALIZER(struct cmd_cfg_input_set_result,
-				 opt, "get#set#clear");
-static cmdline_parse_token_string_t cmd_cfg_input_set_field =
-	TOKEN_STRING_INITIALIZER(struct cmd_cfg_input_set_result,
-				 field, "field");
-static cmdline_parse_token_num_t cmd_cfg_input_set_field_idx =
-	TOKEN_NUM_INITIALIZER(struct cmd_cfg_input_set_result,
-			      field_idx, RTE_UINT8);
-
-static cmdline_parse_inst_t cmd_cfg_input_set = {
-	.f = cmd_cfg_input_set_parsed,
+static cmdline_parse_inst_t cmd_set_l2_decap = {
+	.f = cmd_set_l2_decap_parsed,
 	.data = NULL,
-	.help_str = "port config <port_id> pctype <pctype_id> hash_inset|"
-		    "fdir_inset|fdir_flx_inset get|set|clear field <field_idx>",
+	.help_str = "set l2_decap",
 	.tokens = {
-		(void *)&cmd_cfg_input_set_port,
-		(void *)&cmd_cfg_input_set_cfg,
-		(void *)&cmd_cfg_input_set_port_id,
-		(void *)&cmd_cfg_input_set_pctype,
-		(void *)&cmd_cfg_input_set_pctype_id,
-		(void *)&cmd_cfg_input_set_inset_type,
-		(void *)&cmd_cfg_input_set_opt,
-		(void *)&cmd_cfg_input_set_field,
-		(void *)&cmd_cfg_input_set_field_idx,
+		(void *)&cmd_set_l2_decap_set,
+		(void *)&cmd_set_l2_decap_l2_decap,
 		NULL,
 	},
 };
 
-/* Clear input set */
-struct cmd_clear_input_set_result {
-	cmdline_fixed_string_t port;
-	cmdline_fixed_string_t cfg;
-	portid_t port_id;
-	cmdline_fixed_string_t pctype;
-	uint8_t pctype_id;
-	cmdline_fixed_string_t inset_type;
-	cmdline_fixed_string_t clear;
-	cmdline_fixed_string_t all;
-};
-
-static void
-cmd_clear_input_set_parsed(
-	__rte_unused void *parsed_result,
-	__rte_unused struct cmdline *cl,
-	__rte_unused void *data)
-{
-#ifdef RTE_NET_I40E
-	struct cmd_clear_input_set_result *res = parsed_result;
-	enum rte_pmd_i40e_inset_type inset_type = INSET_NONE;
-	struct rte_pmd_i40e_inset inset;
-#endif
-	int ret = -ENOTSUP;
-
-	if (!all_ports_stopped()) {
-		fprintf(stderr, "Please stop all ports first\n");
-		return;
-	}
-
-#ifdef RTE_NET_I40E
-	if (!strcmp(res->inset_type, "hash_inset"))
-		inset_type = INSET_HASH;
-	else if (!strcmp(res->inset_type, "fdir_inset"))
-		inset_type = INSET_FDIR;
-	else if (!strcmp(res->inset_type, "fdir_flx_inset"))
-		inset_type = INSET_FDIR_FLX;
-
-	memset(&inset, 0, sizeof(inset));
-
-	ret = rte_pmd_i40e_inset_set(res->port_id, res->pctype_id,
-				     &inset, inset_type);
-	if (ret) {
-		fprintf(stderr, "Failed to clear input set.\n");
-		return;
-	}
-
-#endif
-
-	if (ret == -ENOTSUP)
-		fprintf(stderr, "Function not supported\n");
-}
-
-static cmdline_parse_token_string_t cmd_clear_input_set_port =
-	TOKEN_STRING_INITIALIZER(struct cmd_clear_input_set_result,
-				 port, "port");
-static cmdline_parse_token_string_t cmd_clear_input_set_cfg =
-	TOKEN_STRING_INITIALIZER(struct cmd_clear_input_set_result,
-				 cfg, "config");
-static cmdline_parse_token_num_t cmd_clear_input_set_port_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_clear_input_set_result,
-			      port_id, RTE_UINT16);
-static cmdline_parse_token_string_t cmd_clear_input_set_pctype =
-	TOKEN_STRING_INITIALIZER(struct cmd_clear_input_set_result,
-				 pctype, "pctype");
-static cmdline_parse_token_num_t cmd_clear_input_set_pctype_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_clear_input_set_result,
-			      pctype_id, RTE_UINT8);
-static cmdline_parse_token_string_t cmd_clear_input_set_inset_type =
-	TOKEN_STRING_INITIALIZER(struct cmd_clear_input_set_result,
-				 inset_type,
-				 "hash_inset#fdir_inset#fdir_flx_inset");
-static cmdline_parse_token_string_t cmd_clear_input_set_clear =
-	TOKEN_STRING_INITIALIZER(struct cmd_clear_input_set_result,
-				 clear, "clear");
-static cmdline_parse_token_string_t cmd_clear_input_set_all =
-	TOKEN_STRING_INITIALIZER(struct cmd_clear_input_set_result,
-				 all, "all");
-
-static cmdline_parse_inst_t cmd_clear_input_set = {
-	.f = cmd_clear_input_set_parsed,
+static cmdline_parse_inst_t cmd_set_l2_decap_with_vlan = {
+	.f = cmd_set_l2_decap_parsed,
 	.data = NULL,
-	.help_str = "port config <port_id> pctype <pctype_id> hash_inset|"
-		    "fdir_inset|fdir_flx_inset clear all",
+	.help_str = "set l2_decap-with-vlan",
 	.tokens = {
-		(void *)&cmd_clear_input_set_port,
-		(void *)&cmd_clear_input_set_cfg,
-		(void *)&cmd_clear_input_set_port_id,
-		(void *)&cmd_clear_input_set_pctype,
-		(void *)&cmd_clear_input_set_pctype_id,
-		(void *)&cmd_clear_input_set_inset_type,
-		(void *)&cmd_clear_input_set_clear,
-		(void *)&cmd_clear_input_set_all,
+		(void *)&cmd_set_l2_decap_set,
+		(void *)&cmd_set_l2_decap_l2_decap_with_vlan,
 		NULL,
 	},
 };
 
-/* show vf stats */
-
-/* Common result structure for show vf stats */
-struct cmd_show_vf_stats_result {
-	cmdline_fixed_string_t show;
-	cmdline_fixed_string_t vf;
-	cmdline_fixed_string_t stats;
-	portid_t port_id;
-	uint16_t vf_id;
+/** Set MPLSoGRE encapsulation details */
+struct cmd_set_mplsogre_encap_result {
+	cmdline_fixed_string_t set;
+	cmdline_fixed_string_t mplsogre;
+	cmdline_fixed_string_t pos_token;
+	cmdline_fixed_string_t ip_version;
+	uint32_t vlan_present:1;
+	uint32_t label;
+	cmdline_ipaddr_t ip_src;
+	cmdline_ipaddr_t ip_dst;
+	uint16_t tci;
+	struct rte_ether_addr eth_src;
+	struct rte_ether_addr eth_dst;
 };
 
-/* Common CLI fields show vf stats*/
-static cmdline_parse_token_string_t cmd_show_vf_stats_show =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_show_vf_stats_result,
-		 show, "show");
-static cmdline_parse_token_string_t cmd_show_vf_stats_vf =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_show_vf_stats_result,
-		 vf, "vf");
-static cmdline_parse_token_string_t cmd_show_vf_stats_stats =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_show_vf_stats_result,
-		 stats, "stats");
-static cmdline_parse_token_num_t cmd_show_vf_stats_port_id =
-	TOKEN_NUM_INITIALIZER
-		(struct cmd_show_vf_stats_result,
-		 port_id, RTE_UINT16);
-static cmdline_parse_token_num_t cmd_show_vf_stats_vf_id =
-	TOKEN_NUM_INITIALIZER
-		(struct cmd_show_vf_stats_result,
-		 vf_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_set_mplsogre_encap_set =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_encap_result, set,
+				 "set");
+static cmdline_parse_token_string_t cmd_set_mplsogre_encap_mplsogre_encap =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_encap_result, mplsogre,
+				 "mplsogre_encap");
+static cmdline_parse_token_string_t cmd_set_mplsogre_encap_mplsogre_encap_with_vlan =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_encap_result,
+				 mplsogre, "mplsogre_encap-with-vlan");
+static cmdline_parse_token_string_t cmd_set_mplsogre_encap_ip_version =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_encap_result,
+				 pos_token, "ip-version");
+static cmdline_parse_token_string_t cmd_set_mplsogre_encap_ip_version_value =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_encap_result,
+				 ip_version, "ipv4#ipv6");
+static cmdline_parse_token_string_t cmd_set_mplsogre_encap_label =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_encap_result,
+				 pos_token, "label");
+static cmdline_parse_token_num_t cmd_set_mplsogre_encap_label_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_mplsogre_encap_result, label,
+			      RTE_UINT32);
+static cmdline_parse_token_string_t cmd_set_mplsogre_encap_ip_src =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_encap_result,
+				 pos_token, "ip-src");
+static cmdline_parse_token_ipaddr_t cmd_set_mplsogre_encap_ip_src_value =
+	TOKEN_IPADDR_INITIALIZER(struct cmd_set_mplsogre_encap_result, ip_src);
+static cmdline_parse_token_string_t cmd_set_mplsogre_encap_ip_dst =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_encap_result,
+				 pos_token, "ip-dst");
+static cmdline_parse_token_ipaddr_t cmd_set_mplsogre_encap_ip_dst_value =
+	TOKEN_IPADDR_INITIALIZER(struct cmd_set_mplsogre_encap_result, ip_dst);
+static cmdline_parse_token_string_t cmd_set_mplsogre_encap_vlan =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_encap_result,
+				 pos_token, "vlan-tci");
+static cmdline_parse_token_num_t cmd_set_mplsogre_encap_vlan_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_mplsogre_encap_result, tci,
+			      RTE_UINT16);
+static cmdline_parse_token_string_t cmd_set_mplsogre_encap_eth_src =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_encap_result,
+				 pos_token, "eth-src");
+static cmdline_parse_token_etheraddr_t cmd_set_mplsogre_encap_eth_src_value =
+	TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_mplsogre_encap_result,
+				    eth_src);
+static cmdline_parse_token_string_t cmd_set_mplsogre_encap_eth_dst =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_encap_result,
+				 pos_token, "eth-dst");
+static cmdline_parse_token_etheraddr_t cmd_set_mplsogre_encap_eth_dst_value =
+	TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_mplsogre_encap_result,
+				    eth_dst);
 
-static void
-cmd_show_vf_stats_parsed(
-	void *parsed_result,
+static void cmd_set_mplsogre_encap_parsed(void *parsed_result,
 	__rte_unused struct cmdline *cl,
 	__rte_unused void *data)
 {
-	struct cmd_show_vf_stats_result *res = parsed_result;
-	struct rte_eth_stats stats;
-	int ret = -ENOTSUP;
-	static const char *nic_stats_border = "########################";
-
-	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
-		return;
-
-	memset(&stats, 0, sizeof(stats));
-
-#ifdef RTE_NET_I40E
-	if (ret == -ENOTSUP)
-		ret = rte_pmd_i40e_get_vf_stats(res->port_id,
-						res->vf_id,
-						&stats);
-#endif
-#ifdef RTE_NET_BNXT
-	if (ret == -ENOTSUP)
-		ret = rte_pmd_bnxt_get_vf_stats(res->port_id,
-						res->vf_id,
-						&stats);
-#endif
-
-	switch (ret) {
-	case 0:
-		break;
-	case -EINVAL:
-		fprintf(stderr, "invalid vf_id %d\n", res->vf_id);
-		break;
-	case -ENODEV:
-		fprintf(stderr, "invalid port_id %d\n", res->port_id);
-		break;
-	case -ENOTSUP:
-		fprintf(stderr, "function not implemented\n");
-		break;
-	default:
-		fprintf(stderr, "programming error: (%s)\n", strerror(-ret));
-	}
-
-	printf("\n  %s NIC statistics for port %-2d vf %-2d %s\n",
-		nic_stats_border, res->port_id, res->vf_id, nic_stats_border);
-
-	printf("  RX-packets: %-10"PRIu64" RX-missed: %-10"PRIu64" RX-bytes:  "
-	       "%-"PRIu64"\n",
-	       stats.ipackets, stats.imissed, stats.ibytes);
-	printf("  RX-errors: %-"PRIu64"\n", stats.ierrors);
-	printf("  RX-nombuf:  %-10"PRIu64"\n",
-	       stats.rx_nombuf);
-	printf("  TX-packets: %-10"PRIu64" TX-errors: %-10"PRIu64" TX-bytes:  "
-	       "%-"PRIu64"\n",
-	       stats.opackets, stats.oerrors, stats.obytes);
+	struct cmd_set_mplsogre_encap_result *res = parsed_result;
+	union {
+		uint32_t mplsogre_label;
+		uint8_t label[4];
+	} id = {
+		.mplsogre_label = rte_cpu_to_be_32(res->label<<12),
+	};
 
-	printf("  %s############################%s\n",
-			       nic_stats_border, nic_stats_border);
+	if (strcmp(res->mplsogre, "mplsogre_encap") == 0)
+		mplsogre_encap_conf.select_vlan = 0;
+	else if (strcmp(res->mplsogre, "mplsogre_encap-with-vlan") == 0)
+		mplsogre_encap_conf.select_vlan = 1;
+	if (strcmp(res->ip_version, "ipv4") == 0)
+		mplsogre_encap_conf.select_ipv4 = 1;
+	else if (strcmp(res->ip_version, "ipv6") == 0)
+		mplsogre_encap_conf.select_ipv4 = 0;
+	else
+		return;
+	rte_memcpy(mplsogre_encap_conf.label, &id.label, 3);
+	if (mplsogre_encap_conf.select_ipv4) {
+		IPV4_ADDR_TO_UINT(res->ip_src, mplsogre_encap_conf.ipv4_src);
+		IPV4_ADDR_TO_UINT(res->ip_dst, mplsogre_encap_conf.ipv4_dst);
+	} else {
+		IPV6_ADDR_TO_ARRAY(res->ip_src, mplsogre_encap_conf.ipv6_src);
+		IPV6_ADDR_TO_ARRAY(res->ip_dst, mplsogre_encap_conf.ipv6_dst);
+	}
+	if (mplsogre_encap_conf.select_vlan)
+		mplsogre_encap_conf.vlan_tci = rte_cpu_to_be_16(res->tci);
+	rte_memcpy(mplsogre_encap_conf.eth_src, res->eth_src.addr_bytes,
+		   RTE_ETHER_ADDR_LEN);
+	rte_memcpy(mplsogre_encap_conf.eth_dst, res->eth_dst.addr_bytes,
+		   RTE_ETHER_ADDR_LEN);
 }
 
-static cmdline_parse_inst_t cmd_show_vf_stats = {
-	.f = cmd_show_vf_stats_parsed,
+static cmdline_parse_inst_t cmd_set_mplsogre_encap = {
+	.f = cmd_set_mplsogre_encap_parsed,
 	.data = NULL,
-	.help_str = "show vf stats <port_id> <vf_id>",
+	.help_str = "set mplsogre_encap ip-version ipv4|ipv6 label <label>"
+		" ip-src <ip-src> ip-dst <ip-dst> eth-src <eth-src>"
+		" eth-dst <eth-dst>",
 	.tokens = {
-		(void *)&cmd_show_vf_stats_show,
-		(void *)&cmd_show_vf_stats_vf,
-		(void *)&cmd_show_vf_stats_stats,
-		(void *)&cmd_show_vf_stats_port_id,
-		(void *)&cmd_show_vf_stats_vf_id,
+		(void *)&cmd_set_mplsogre_encap_set,
+		(void *)&cmd_set_mplsogre_encap_mplsogre_encap,
+		(void *)&cmd_set_mplsogre_encap_ip_version,
+		(void *)&cmd_set_mplsogre_encap_ip_version_value,
+		(void *)&cmd_set_mplsogre_encap_label,
+		(void *)&cmd_set_mplsogre_encap_label_value,
+		(void *)&cmd_set_mplsogre_encap_ip_src,
+		(void *)&cmd_set_mplsogre_encap_ip_src_value,
+		(void *)&cmd_set_mplsogre_encap_ip_dst,
+		(void *)&cmd_set_mplsogre_encap_ip_dst_value,
+		(void *)&cmd_set_mplsogre_encap_eth_src,
+		(void *)&cmd_set_mplsogre_encap_eth_src_value,
+		(void *)&cmd_set_mplsogre_encap_eth_dst,
+		(void *)&cmd_set_mplsogre_encap_eth_dst_value,
 		NULL,
 	},
 };
 
-/* clear vf stats */
+static cmdline_parse_inst_t cmd_set_mplsogre_encap_with_vlan = {
+	.f = cmd_set_mplsogre_encap_parsed,
+	.data = NULL,
+	.help_str = "set mplsogre_encap-with-vlan ip-version ipv4|ipv6"
+		" label <label> ip-src <ip-src> ip-dst <ip-dst>"
+		" vlan-tci <vlan-tci> eth-src <eth-src> eth-dst <eth-dst>",
+	.tokens = {
+		(void *)&cmd_set_mplsogre_encap_set,
+		(void *)&cmd_set_mplsogre_encap_mplsogre_encap_with_vlan,
+		(void *)&cmd_set_mplsogre_encap_ip_version,
+		(void *)&cmd_set_mplsogre_encap_ip_version_value,
+		(void *)&cmd_set_mplsogre_encap_label,
+		(void *)&cmd_set_mplsogre_encap_label_value,
+		(void *)&cmd_set_mplsogre_encap_ip_src,
+		(void *)&cmd_set_mplsogre_encap_ip_src_value,
+		(void *)&cmd_set_mplsogre_encap_ip_dst,
+		(void *)&cmd_set_mplsogre_encap_ip_dst_value,
+		(void *)&cmd_set_mplsogre_encap_vlan,
+		(void *)&cmd_set_mplsogre_encap_vlan_value,
+		(void *)&cmd_set_mplsogre_encap_eth_src,
+		(void *)&cmd_set_mplsogre_encap_eth_src_value,
+		(void *)&cmd_set_mplsogre_encap_eth_dst,
+		(void *)&cmd_set_mplsogre_encap_eth_dst_value,
+		NULL,
+	},
+};
 
-/* Common result structure for clear vf stats */
-struct cmd_clear_vf_stats_result {
-	cmdline_fixed_string_t clear;
-	cmdline_fixed_string_t vf;
-	cmdline_fixed_string_t stats;
-	portid_t port_id;
-	uint16_t vf_id;
+/** Set MPLSoGRE decapsulation details */
+struct cmd_set_mplsogre_decap_result {
+	cmdline_fixed_string_t set;
+	cmdline_fixed_string_t mplsogre;
+	cmdline_fixed_string_t pos_token;
+	cmdline_fixed_string_t ip_version;
+	uint32_t vlan_present:1;
 };
 
-/* Common CLI fields clear vf stats*/
-static cmdline_parse_token_string_t cmd_clear_vf_stats_clear =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_clear_vf_stats_result,
-		 clear, "clear");
-static cmdline_parse_token_string_t cmd_clear_vf_stats_vf =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_clear_vf_stats_result,
-		 vf, "vf");
-static cmdline_parse_token_string_t cmd_clear_vf_stats_stats =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_clear_vf_stats_result,
-		 stats, "stats");
-static cmdline_parse_token_num_t cmd_clear_vf_stats_port_id =
-	TOKEN_NUM_INITIALIZER
-		(struct cmd_clear_vf_stats_result,
-		 port_id, RTE_UINT16);
-static cmdline_parse_token_num_t cmd_clear_vf_stats_vf_id =
-	TOKEN_NUM_INITIALIZER
-		(struct cmd_clear_vf_stats_result,
-		 vf_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_set_mplsogre_decap_set =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_decap_result, set,
+				 "set");
+static cmdline_parse_token_string_t cmd_set_mplsogre_decap_mplsogre_decap =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_decap_result, mplsogre,
+				 "mplsogre_decap");
+static cmdline_parse_token_string_t cmd_set_mplsogre_decap_mplsogre_decap_with_vlan =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_decap_result,
+				 mplsogre, "mplsogre_decap-with-vlan");
+static cmdline_parse_token_string_t cmd_set_mplsogre_decap_ip_version =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_decap_result,
+				 pos_token, "ip-version");
+static cmdline_parse_token_string_t cmd_set_mplsogre_decap_ip_version_value =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_decap_result,
+				 ip_version, "ipv4#ipv6");
 
-static void
-cmd_clear_vf_stats_parsed(
-	void *parsed_result,
+static void cmd_set_mplsogre_decap_parsed(void *parsed_result,
 	__rte_unused struct cmdline *cl,
 	__rte_unused void *data)
 {
-	struct cmd_clear_vf_stats_result *res = parsed_result;
-	int ret = -ENOTSUP;
-
-	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
-		return;
-
-#ifdef RTE_NET_I40E
-	if (ret == -ENOTSUP)
-		ret = rte_pmd_i40e_reset_vf_stats(res->port_id,
-						  res->vf_id);
-#endif
-#ifdef RTE_NET_BNXT
-	if (ret == -ENOTSUP)
-		ret = rte_pmd_bnxt_reset_vf_stats(res->port_id,
-						  res->vf_id);
-#endif
+	struct cmd_set_mplsogre_decap_result *res = parsed_result;
 
-	switch (ret) {
-	case 0:
-		break;
-	case -EINVAL:
-		fprintf(stderr, "invalid vf_id %d\n", res->vf_id);
-		break;
-	case -ENODEV:
-		fprintf(stderr, "invalid port_id %d\n", res->port_id);
-		break;
-	case -ENOTSUP:
-		fprintf(stderr, "function not implemented\n");
-		break;
-	default:
-		fprintf(stderr, "programming error: (%s)\n", strerror(-ret));
-	}
+	if (strcmp(res->mplsogre, "mplsogre_decap") == 0)
+		mplsogre_decap_conf.select_vlan = 0;
+	else if (strcmp(res->mplsogre, "mplsogre_decap-with-vlan") == 0)
+		mplsogre_decap_conf.select_vlan = 1;
+	if (strcmp(res->ip_version, "ipv4") == 0)
+		mplsogre_decap_conf.select_ipv4 = 1;
+	else if (strcmp(res->ip_version, "ipv6") == 0)
+		mplsogre_decap_conf.select_ipv4 = 0;
 }
 
-static cmdline_parse_inst_t cmd_clear_vf_stats = {
-	.f = cmd_clear_vf_stats_parsed,
+static cmdline_parse_inst_t cmd_set_mplsogre_decap = {
+	.f = cmd_set_mplsogre_decap_parsed,
 	.data = NULL,
-	.help_str = "clear vf stats <port_id> <vf_id>",
+	.help_str = "set mplsogre_decap ip-version ipv4|ipv6",
 	.tokens = {
-		(void *)&cmd_clear_vf_stats_clear,
-		(void *)&cmd_clear_vf_stats_vf,
-		(void *)&cmd_clear_vf_stats_stats,
-		(void *)&cmd_clear_vf_stats_port_id,
-		(void *)&cmd_clear_vf_stats_vf_id,
+		(void *)&cmd_set_mplsogre_decap_set,
+		(void *)&cmd_set_mplsogre_decap_mplsogre_decap,
+		(void *)&cmd_set_mplsogre_decap_ip_version,
+		(void *)&cmd_set_mplsogre_decap_ip_version_value,
 		NULL,
 	},
 };
 
-/* port config pctype mapping reset */
+static cmdline_parse_inst_t cmd_set_mplsogre_decap_with_vlan = {
+	.f = cmd_set_mplsogre_decap_parsed,
+	.data = NULL,
+	.help_str = "set mplsogre_decap-with-vlan ip-version ipv4|ipv6",
+	.tokens = {
+		(void *)&cmd_set_mplsogre_decap_set,
+		(void *)&cmd_set_mplsogre_decap_mplsogre_decap_with_vlan,
+		(void *)&cmd_set_mplsogre_decap_ip_version,
+		(void *)&cmd_set_mplsogre_decap_ip_version_value,
+		NULL,
+	},
+};
 
-/* Common result structure for port config pctype mapping reset */
-struct cmd_pctype_mapping_reset_result {
-	cmdline_fixed_string_t port;
-	cmdline_fixed_string_t config;
-	portid_t port_id;
-	cmdline_fixed_string_t pctype;
-	cmdline_fixed_string_t mapping;
-	cmdline_fixed_string_t reset;
+/** Set MPLSoUDP encapsulation details */
+struct cmd_set_mplsoudp_encap_result {
+	cmdline_fixed_string_t set;
+	cmdline_fixed_string_t mplsoudp;
+	cmdline_fixed_string_t pos_token;
+	cmdline_fixed_string_t ip_version;
+	uint32_t vlan_present:1;
+	uint32_t label;
+	uint16_t udp_src;
+	uint16_t udp_dst;
+	cmdline_ipaddr_t ip_src;
+	cmdline_ipaddr_t ip_dst;
+	uint16_t tci;
+	struct rte_ether_addr eth_src;
+	struct rte_ether_addr eth_dst;
 };
 
-/* Common CLI fields for port config pctype mapping reset*/
-static cmdline_parse_token_string_t cmd_pctype_mapping_reset_port =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_pctype_mapping_reset_result,
-		 port, "port");
-static cmdline_parse_token_string_t cmd_pctype_mapping_reset_config =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_pctype_mapping_reset_result,
-		 config, "config");
-static cmdline_parse_token_num_t cmd_pctype_mapping_reset_port_id =
-	TOKEN_NUM_INITIALIZER
-		(struct cmd_pctype_mapping_reset_result,
-		 port_id, RTE_UINT16);
-static cmdline_parse_token_string_t cmd_pctype_mapping_reset_pctype =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_pctype_mapping_reset_result,
-		 pctype, "pctype");
-static cmdline_parse_token_string_t cmd_pctype_mapping_reset_mapping =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_pctype_mapping_reset_result,
-		 mapping, "mapping");
-static cmdline_parse_token_string_t cmd_pctype_mapping_reset_reset =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_pctype_mapping_reset_result,
-		 reset, "reset");
+static cmdline_parse_token_string_t cmd_set_mplsoudp_encap_set =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result, set,
+				 "set");
+static cmdline_parse_token_string_t cmd_set_mplsoudp_encap_mplsoudp_encap =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result, mplsoudp,
+				 "mplsoudp_encap");
+static cmdline_parse_token_string_t cmd_set_mplsoudp_encap_mplsoudp_encap_with_vlan =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
+				 mplsoudp, "mplsoudp_encap-with-vlan");
+static cmdline_parse_token_string_t cmd_set_mplsoudp_encap_ip_version =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
+				 pos_token, "ip-version");
+static cmdline_parse_token_string_t cmd_set_mplsoudp_encap_ip_version_value =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
+				 ip_version, "ipv4#ipv6");
+static cmdline_parse_token_string_t cmd_set_mplsoudp_encap_label =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
+				 pos_token, "label");
+static cmdline_parse_token_num_t cmd_set_mplsoudp_encap_label_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_mplsoudp_encap_result, label,
+			      RTE_UINT32);
+static cmdline_parse_token_string_t cmd_set_mplsoudp_encap_udp_src =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
+				 pos_token, "udp-src");
+static cmdline_parse_token_num_t cmd_set_mplsoudp_encap_udp_src_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_mplsoudp_encap_result, udp_src,
+			      RTE_UINT16);
+static cmdline_parse_token_string_t cmd_set_mplsoudp_encap_udp_dst =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
+				 pos_token, "udp-dst");
+static cmdline_parse_token_num_t cmd_set_mplsoudp_encap_udp_dst_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_mplsoudp_encap_result, udp_dst,
+			      RTE_UINT16);
+static cmdline_parse_token_string_t cmd_set_mplsoudp_encap_ip_src =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
+				 pos_token, "ip-src");
+static cmdline_parse_token_ipaddr_t cmd_set_mplsoudp_encap_ip_src_value =
+	TOKEN_IPADDR_INITIALIZER(struct cmd_set_mplsoudp_encap_result, ip_src);
+static cmdline_parse_token_string_t cmd_set_mplsoudp_encap_ip_dst =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
+				 pos_token, "ip-dst");
+static cmdline_parse_token_ipaddr_t cmd_set_mplsoudp_encap_ip_dst_value =
+	TOKEN_IPADDR_INITIALIZER(struct cmd_set_mplsoudp_encap_result, ip_dst);
+static cmdline_parse_token_string_t cmd_set_mplsoudp_encap_vlan =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
+				 pos_token, "vlan-tci");
+static cmdline_parse_token_num_t cmd_set_mplsoudp_encap_vlan_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_mplsoudp_encap_result, tci,
+			      RTE_UINT16);
+static cmdline_parse_token_string_t cmd_set_mplsoudp_encap_eth_src =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
+				 pos_token, "eth-src");
+static cmdline_parse_token_etheraddr_t cmd_set_mplsoudp_encap_eth_src_value =
+	TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
+				    eth_src);
+static cmdline_parse_token_string_t cmd_set_mplsoudp_encap_eth_dst =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
+				 pos_token, "eth-dst");
+static cmdline_parse_token_etheraddr_t cmd_set_mplsoudp_encap_eth_dst_value =
+	TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
+				    eth_dst);
 
-static void
-cmd_pctype_mapping_reset_parsed(
-	void *parsed_result,
+static void cmd_set_mplsoudp_encap_parsed(void *parsed_result,
 	__rte_unused struct cmdline *cl,
 	__rte_unused void *data)
 {
-	struct cmd_pctype_mapping_reset_result *res = parsed_result;
-	int ret = -ENOTSUP;
+	struct cmd_set_mplsoudp_encap_result *res = parsed_result;
+	union {
+		uint32_t mplsoudp_label;
+		uint8_t label[4];
+	} id = {
+		.mplsoudp_label = rte_cpu_to_be_32(res->label<<12),
+	};
 
-	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
+	if (strcmp(res->mplsoudp, "mplsoudp_encap") == 0)
+		mplsoudp_encap_conf.select_vlan = 0;
+	else if (strcmp(res->mplsoudp, "mplsoudp_encap-with-vlan") == 0)
+		mplsoudp_encap_conf.select_vlan = 1;
+	if (strcmp(res->ip_version, "ipv4") == 0)
+		mplsoudp_encap_conf.select_ipv4 = 1;
+	else if (strcmp(res->ip_version, "ipv6") == 0)
+		mplsoudp_encap_conf.select_ipv4 = 0;
+	else
 		return;
-
-#ifdef RTE_NET_I40E
-	ret = rte_pmd_i40e_flow_type_mapping_reset(res->port_id);
-#endif
-
-	switch (ret) {
-	case 0:
-		break;
-	case -ENODEV:
-		fprintf(stderr, "invalid port_id %d\n", res->port_id);
-		break;
-	case -ENOTSUP:
-		fprintf(stderr, "function not implemented\n");
-		break;
-	default:
-		fprintf(stderr, "programming error: (%s)\n", strerror(-ret));
+	rte_memcpy(mplsoudp_encap_conf.label, &id.label, 3);
+	mplsoudp_encap_conf.udp_src = rte_cpu_to_be_16(res->udp_src);
+	mplsoudp_encap_conf.udp_dst = rte_cpu_to_be_16(res->udp_dst);
+	if (mplsoudp_encap_conf.select_ipv4) {
+		IPV4_ADDR_TO_UINT(res->ip_src, mplsoudp_encap_conf.ipv4_src);
+		IPV4_ADDR_TO_UINT(res->ip_dst, mplsoudp_encap_conf.ipv4_dst);
+	} else {
+		IPV6_ADDR_TO_ARRAY(res->ip_src, mplsoudp_encap_conf.ipv6_src);
+		IPV6_ADDR_TO_ARRAY(res->ip_dst, mplsoudp_encap_conf.ipv6_dst);
 	}
+	if (mplsoudp_encap_conf.select_vlan)
+		mplsoudp_encap_conf.vlan_tci = rte_cpu_to_be_16(res->tci);
+	rte_memcpy(mplsoudp_encap_conf.eth_src, res->eth_src.addr_bytes,
+		   RTE_ETHER_ADDR_LEN);
+	rte_memcpy(mplsoudp_encap_conf.eth_dst, res->eth_dst.addr_bytes,
+		   RTE_ETHER_ADDR_LEN);
 }
 
-static cmdline_parse_inst_t cmd_pctype_mapping_reset = {
-	.f = cmd_pctype_mapping_reset_parsed,
+static cmdline_parse_inst_t cmd_set_mplsoudp_encap = {
+	.f = cmd_set_mplsoudp_encap_parsed,
 	.data = NULL,
-	.help_str = "port config <port_id> pctype mapping reset",
+	.help_str = "set mplsoudp_encap ip-version ipv4|ipv6 label <label>"
+		" udp-src <udp-src> udp-dst <udp-dst> ip-src <ip-src>"
+		" ip-dst <ip-dst> eth-src <eth-src> eth-dst <eth-dst>",
 	.tokens = {
-		(void *)&cmd_pctype_mapping_reset_port,
-		(void *)&cmd_pctype_mapping_reset_config,
-		(void *)&cmd_pctype_mapping_reset_port_id,
-		(void *)&cmd_pctype_mapping_reset_pctype,
-		(void *)&cmd_pctype_mapping_reset_mapping,
-		(void *)&cmd_pctype_mapping_reset_reset,
+		(void *)&cmd_set_mplsoudp_encap_set,
+		(void *)&cmd_set_mplsoudp_encap_mplsoudp_encap,
+		(void *)&cmd_set_mplsoudp_encap_ip_version,
+		(void *)&cmd_set_mplsoudp_encap_ip_version_value,
+		(void *)&cmd_set_mplsoudp_encap_label,
+		(void *)&cmd_set_mplsoudp_encap_label_value,
+		(void *)&cmd_set_mplsoudp_encap_udp_src,
+		(void *)&cmd_set_mplsoudp_encap_udp_src_value,
+		(void *)&cmd_set_mplsoudp_encap_udp_dst,
+		(void *)&cmd_set_mplsoudp_encap_udp_dst_value,
+		(void *)&cmd_set_mplsoudp_encap_ip_src,
+		(void *)&cmd_set_mplsoudp_encap_ip_src_value,
+		(void *)&cmd_set_mplsoudp_encap_ip_dst,
+		(void *)&cmd_set_mplsoudp_encap_ip_dst_value,
+		(void *)&cmd_set_mplsoudp_encap_eth_src,
+		(void *)&cmd_set_mplsoudp_encap_eth_src_value,
+		(void *)&cmd_set_mplsoudp_encap_eth_dst,
+		(void *)&cmd_set_mplsoudp_encap_eth_dst_value,
 		NULL,
 	},
 };
 
-/* show port pctype mapping */
+static cmdline_parse_inst_t cmd_set_mplsoudp_encap_with_vlan = {
+	.f = cmd_set_mplsoudp_encap_parsed,
+	.data = NULL,
+	.help_str = "set mplsoudp_encap-with-vlan ip-version ipv4|ipv6"
+		" label <label> udp-src <udp-src> udp-dst <udp-dst>"
+		" ip-src <ip-src> ip-dst <ip-dst> vlan-tci <vlan-tci>"
+		" eth-src <eth-src> eth-dst <eth-dst>",
+	.tokens = {
+		(void *)&cmd_set_mplsoudp_encap_set,
+		(void *)&cmd_set_mplsoudp_encap_mplsoudp_encap_with_vlan,
+		(void *)&cmd_set_mplsoudp_encap_ip_version,
+		(void *)&cmd_set_mplsoudp_encap_ip_version_value,
+		(void *)&cmd_set_mplsoudp_encap_label,
+		(void *)&cmd_set_mplsoudp_encap_label_value,
+		(void *)&cmd_set_mplsoudp_encap_udp_src,
+		(void *)&cmd_set_mplsoudp_encap_udp_src_value,
+		(void *)&cmd_set_mplsoudp_encap_udp_dst,
+		(void *)&cmd_set_mplsoudp_encap_udp_dst_value,
+		(void *)&cmd_set_mplsoudp_encap_ip_src,
+		(void *)&cmd_set_mplsoudp_encap_ip_src_value,
+		(void *)&cmd_set_mplsoudp_encap_ip_dst,
+		(void *)&cmd_set_mplsoudp_encap_ip_dst_value,
+		(void *)&cmd_set_mplsoudp_encap_vlan,
+		(void *)&cmd_set_mplsoudp_encap_vlan_value,
+		(void *)&cmd_set_mplsoudp_encap_eth_src,
+		(void *)&cmd_set_mplsoudp_encap_eth_src_value,
+		(void *)&cmd_set_mplsoudp_encap_eth_dst,
+		(void *)&cmd_set_mplsoudp_encap_eth_dst_value,
+		NULL,
+	},
+};
 
-/* Common result structure for show port pctype mapping */
-struct cmd_pctype_mapping_get_result {
-	cmdline_fixed_string_t show;
-	cmdline_fixed_string_t port;
-	portid_t port_id;
-	cmdline_fixed_string_t pctype;
-	cmdline_fixed_string_t mapping;
+/** Set MPLSoUDP decapsulation details */
+struct cmd_set_mplsoudp_decap_result {
+	cmdline_fixed_string_t set;
+	cmdline_fixed_string_t mplsoudp;
+	cmdline_fixed_string_t pos_token;
+	cmdline_fixed_string_t ip_version;
+	uint32_t vlan_present:1;
 };
 
-/* Common CLI fields for pctype mapping get */
-static cmdline_parse_token_string_t cmd_pctype_mapping_get_show =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_pctype_mapping_get_result,
-		 show, "show");
-static cmdline_parse_token_string_t cmd_pctype_mapping_get_port =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_pctype_mapping_get_result,
-		 port, "port");
-static cmdline_parse_token_num_t cmd_pctype_mapping_get_port_id =
-	TOKEN_NUM_INITIALIZER
-		(struct cmd_pctype_mapping_get_result,
-		 port_id, RTE_UINT16);
-static cmdline_parse_token_string_t cmd_pctype_mapping_get_pctype =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_pctype_mapping_get_result,
-		 pctype, "pctype");
-static cmdline_parse_token_string_t cmd_pctype_mapping_get_mapping =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_pctype_mapping_get_result,
-		 mapping, "mapping");
+static cmdline_parse_token_string_t cmd_set_mplsoudp_decap_set =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_decap_result, set,
+				 "set");
+static cmdline_parse_token_string_t cmd_set_mplsoudp_decap_mplsoudp_decap =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_decap_result, mplsoudp,
+				 "mplsoudp_decap");
+static cmdline_parse_token_string_t cmd_set_mplsoudp_decap_mplsoudp_decap_with_vlan =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_decap_result,
+				 mplsoudp, "mplsoudp_decap-with-vlan");
+static cmdline_parse_token_string_t cmd_set_mplsoudp_decap_ip_version =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_decap_result,
+				 pos_token, "ip-version");
+static cmdline_parse_token_string_t cmd_set_mplsoudp_decap_ip_version_value =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_decap_result,
+				 ip_version, "ipv4#ipv6");
 
-static void
-cmd_pctype_mapping_get_parsed(
-	void *parsed_result,
+static void cmd_set_mplsoudp_decap_parsed(void *parsed_result,
 	__rte_unused struct cmdline *cl,
 	__rte_unused void *data)
 {
-	struct cmd_pctype_mapping_get_result *res = parsed_result;
-	int ret = -ENOTSUP;
-#ifdef RTE_NET_I40E
-	struct rte_pmd_i40e_flow_type_mapping
-				mapping[RTE_PMD_I40E_FLOW_TYPE_MAX];
-	int i, j, first_pctype;
-#endif
-
-	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
-		return;
-
-#ifdef RTE_NET_I40E
-	ret = rte_pmd_i40e_flow_type_mapping_get(res->port_id, mapping);
-#endif
-
-	switch (ret) {
-	case 0:
-		break;
-	case -ENODEV:
-		fprintf(stderr, "invalid port_id %d\n", res->port_id);
-		return;
-	case -ENOTSUP:
-		fprintf(stderr, "function not implemented\n");
-		return;
-	default:
-		fprintf(stderr, "programming error: (%s)\n", strerror(-ret));
-		return;
-	}
+	struct cmd_set_mplsoudp_decap_result *res = parsed_result;
 
-#ifdef RTE_NET_I40E
-	for (i = 0; i < RTE_PMD_I40E_FLOW_TYPE_MAX; i++) {
-		if (mapping[i].pctype != 0ULL) {
-			first_pctype = 1;
-
-			printf("pctype: ");
-			for (j = 0; j < RTE_PMD_I40E_PCTYPE_MAX; j++) {
-				if (mapping[i].pctype & (1ULL << j)) {
-					printf(first_pctype ?
-					       "%02d" : ",%02d", j);
-					first_pctype = 0;
-				}
-			}
-			printf("  ->  flowtype: %02d\n", mapping[i].flow_type);
-		}
-	}
-#endif
+	if (strcmp(res->mplsoudp, "mplsoudp_decap") == 0)
+		mplsoudp_decap_conf.select_vlan = 0;
+	else if (strcmp(res->mplsoudp, "mplsoudp_decap-with-vlan") == 0)
+		mplsoudp_decap_conf.select_vlan = 1;
+	if (strcmp(res->ip_version, "ipv4") == 0)
+		mplsoudp_decap_conf.select_ipv4 = 1;
+	else if (strcmp(res->ip_version, "ipv6") == 0)
+		mplsoudp_decap_conf.select_ipv4 = 0;
 }
 
-static cmdline_parse_inst_t cmd_pctype_mapping_get = {
-	.f = cmd_pctype_mapping_get_parsed,
+static cmdline_parse_inst_t cmd_set_mplsoudp_decap = {
+	.f = cmd_set_mplsoudp_decap_parsed,
 	.data = NULL,
-	.help_str = "show port <port_id> pctype mapping",
+	.help_str = "set mplsoudp_decap ip-version ipv4|ipv6",
 	.tokens = {
-		(void *)&cmd_pctype_mapping_get_show,
-		(void *)&cmd_pctype_mapping_get_port,
-		(void *)&cmd_pctype_mapping_get_port_id,
-		(void *)&cmd_pctype_mapping_get_pctype,
-		(void *)&cmd_pctype_mapping_get_mapping,
+		(void *)&cmd_set_mplsoudp_decap_set,
+		(void *)&cmd_set_mplsoudp_decap_mplsoudp_decap,
+		(void *)&cmd_set_mplsoudp_decap_ip_version,
+		(void *)&cmd_set_mplsoudp_decap_ip_version_value,
 		NULL,
 	},
 };
 
-/* port config pctype mapping update */
+static cmdline_parse_inst_t cmd_set_mplsoudp_decap_with_vlan = {
+	.f = cmd_set_mplsoudp_decap_parsed,
+	.data = NULL,
+	.help_str = "set mplsoudp_decap-with-vlan ip-version ipv4|ipv6",
+	.tokens = {
+		(void *)&cmd_set_mplsoudp_decap_set,
+		(void *)&cmd_set_mplsoudp_decap_mplsoudp_decap_with_vlan,
+		(void *)&cmd_set_mplsoudp_decap_ip_version,
+		(void *)&cmd_set_mplsoudp_decap_ip_version_value,
+		NULL,
+	},
+};
 
-/* Common result structure for port config pctype mapping update */
-struct cmd_pctype_mapping_update_result {
-	cmdline_fixed_string_t port;
-	cmdline_fixed_string_t config;
-	portid_t port_id;
-	cmdline_fixed_string_t pctype;
-	cmdline_fixed_string_t mapping;
-	cmdline_fixed_string_t update;
-	cmdline_fixed_string_t pctype_list;
-	uint16_t flow_type;
+/** Set connection tracking object common details */
+struct cmd_set_conntrack_common_result {
+	cmdline_fixed_string_t set;
+	cmdline_fixed_string_t conntrack;
+	cmdline_fixed_string_t common;
+	cmdline_fixed_string_t peer;
+	cmdline_fixed_string_t is_orig;
+	cmdline_fixed_string_t enable;
+	cmdline_fixed_string_t live;
+	cmdline_fixed_string_t sack;
+	cmdline_fixed_string_t cack;
+	cmdline_fixed_string_t last_dir;
+	cmdline_fixed_string_t liberal;
+	cmdline_fixed_string_t state;
+	cmdline_fixed_string_t max_ack_win;
+	cmdline_fixed_string_t retrans;
+	cmdline_fixed_string_t last_win;
+	cmdline_fixed_string_t last_seq;
+	cmdline_fixed_string_t last_ack;
+	cmdline_fixed_string_t last_end;
+	cmdline_fixed_string_t last_index;
+	uint8_t stat;
+	uint8_t factor;
+	uint16_t peer_port;
+	uint32_t is_original;
+	uint32_t en;
+	uint32_t is_live;
+	uint32_t s_ack;
+	uint32_t c_ack;
+	uint32_t ld;
+	uint32_t lb;
+	uint8_t re_num;
+	uint8_t li;
+	uint16_t lw;
+	uint32_t ls;
+	uint32_t la;
+	uint32_t le;
 };
 
-/* Common CLI fields for pctype mapping update*/
-static cmdline_parse_token_string_t cmd_pctype_mapping_update_port =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_pctype_mapping_update_result,
-		 port, "port");
-static cmdline_parse_token_string_t cmd_pctype_mapping_update_config =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_pctype_mapping_update_result,
-		 config, "config");
-static cmdline_parse_token_num_t cmd_pctype_mapping_update_port_id =
-	TOKEN_NUM_INITIALIZER
-		(struct cmd_pctype_mapping_update_result,
-		 port_id, RTE_UINT16);
-static cmdline_parse_token_string_t cmd_pctype_mapping_update_pctype =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_pctype_mapping_update_result,
-		 pctype, "pctype");
-static cmdline_parse_token_string_t cmd_pctype_mapping_update_mapping =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_pctype_mapping_update_result,
-		 mapping, "mapping");
-static cmdline_parse_token_string_t cmd_pctype_mapping_update_update =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_pctype_mapping_update_result,
-		 update, "update");
-static cmdline_parse_token_string_t cmd_pctype_mapping_update_pc_type =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_pctype_mapping_update_result,
-		 pctype_list, NULL);
-static cmdline_parse_token_num_t cmd_pctype_mapping_update_flow_type =
-	TOKEN_NUM_INITIALIZER
-		(struct cmd_pctype_mapping_update_result,
-		 flow_type, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_set_conntrack_set =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+				 set, "set");
+static cmdline_parse_token_string_t cmd_set_conntrack_conntrack =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+				 conntrack, "conntrack");
+static cmdline_parse_token_string_t cmd_set_conntrack_common_com =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+				 common, "com");
+static cmdline_parse_token_string_t cmd_set_conntrack_common_peer =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+				 peer, "peer");
+static cmdline_parse_token_num_t cmd_set_conntrack_common_peer_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+			      peer_port, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_set_conntrack_common_is_orig =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+				 is_orig, "is_orig");
+static cmdline_parse_token_num_t cmd_set_conntrack_common_is_orig_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+			      is_original, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_set_conntrack_common_enable =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+				 enable, "enable");
+static cmdline_parse_token_num_t cmd_set_conntrack_common_enable_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+			      en, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_set_conntrack_common_live =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+				 live, "live");
+static cmdline_parse_token_num_t cmd_set_conntrack_common_live_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+			      is_live, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_set_conntrack_common_sack =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+				 sack, "sack");
+static cmdline_parse_token_num_t cmd_set_conntrack_common_sack_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+			      s_ack, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_set_conntrack_common_cack =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+				 cack, "cack");
+static cmdline_parse_token_num_t cmd_set_conntrack_common_cack_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+			      c_ack, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_set_conntrack_common_last_dir =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+				 last_dir, "last_dir");
+static cmdline_parse_token_num_t cmd_set_conntrack_common_last_dir_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+			      ld, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_set_conntrack_common_liberal =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+				 liberal, "liberal");
+static cmdline_parse_token_num_t cmd_set_conntrack_common_liberal_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+			      lb, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_set_conntrack_common_state =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+				 state, "state");
+static cmdline_parse_token_num_t cmd_set_conntrack_common_state_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+			      stat, RTE_UINT8);
+static cmdline_parse_token_string_t cmd_set_conntrack_common_max_ackwin =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+				 max_ack_win, "max_ack_win");
+static cmdline_parse_token_num_t cmd_set_conntrack_common_max_ackwin_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+			      factor, RTE_UINT8);
+static cmdline_parse_token_string_t cmd_set_conntrack_common_retrans =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+				 retrans, "r_lim");
+static cmdline_parse_token_num_t cmd_set_conntrack_common_retrans_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+			      re_num, RTE_UINT8);
+static cmdline_parse_token_string_t cmd_set_conntrack_common_last_win =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+				 last_win, "last_win");
+static cmdline_parse_token_num_t cmd_set_conntrack_common_last_win_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+			      lw, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_set_conntrack_common_last_seq =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+				 last_seq, "last_seq");
+static cmdline_parse_token_num_t cmd_set_conntrack_common_last_seq_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+			      ls, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_set_conntrack_common_last_ack =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+				 last_ack, "last_ack");
+static cmdline_parse_token_num_t cmd_set_conntrack_common_last_ack_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+			      la, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_set_conntrack_common_last_end =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+				 last_end, "last_end");
+static cmdline_parse_token_num_t cmd_set_conntrack_common_last_end_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+			      le, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_set_conntrack_common_last_index =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+				 last_index, "last_index");
+static cmdline_parse_token_num_t cmd_set_conntrack_common_last_index_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+			      li, RTE_UINT8);
 
-static void
-cmd_pctype_mapping_update_parsed(
-	void *parsed_result,
+static void cmd_set_conntrack_common_parsed(void *parsed_result,
 	__rte_unused struct cmdline *cl,
 	__rte_unused void *data)
 {
-	struct cmd_pctype_mapping_update_result *res = parsed_result;
-	int ret = -ENOTSUP;
-#ifdef RTE_NET_I40E
-	struct rte_pmd_i40e_flow_type_mapping mapping;
-	unsigned int i;
-	unsigned int nb_item;
-	unsigned int pctype_list[RTE_PMD_I40E_PCTYPE_MAX];
-#endif
-
-	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
-		return;
-
-#ifdef RTE_NET_I40E
-	nb_item = parse_item_list(res->pctype_list, "pctypes",
-				  RTE_PMD_I40E_PCTYPE_MAX, pctype_list, 1);
-	mapping.flow_type = res->flow_type;
-	for (i = 0, mapping.pctype = 0ULL; i < nb_item; i++)
-		mapping.pctype |= (1ULL << pctype_list[i]);
-	ret = rte_pmd_i40e_flow_type_mapping_update(res->port_id,
-						&mapping,
-						1,
-						0);
-#endif
+	struct cmd_set_conntrack_common_result *res = parsed_result;
 
-	switch (ret) {
-	case 0:
-		break;
-	case -EINVAL:
-		fprintf(stderr, "invalid pctype or flow type\n");
-		break;
-	case -ENODEV:
-		fprintf(stderr, "invalid port_id %d\n", res->port_id);
-		break;
-	case -ENOTSUP:
-		fprintf(stderr, "function not implemented\n");
-		break;
-	default:
-		fprintf(stderr, "programming error: (%s)\n", strerror(-ret));
-	}
+	/* No need to swap to big endian. */
+	conntrack_context.peer_port = res->peer_port;
+	conntrack_context.is_original_dir = res->is_original;
+	conntrack_context.enable = res->en;
+	conntrack_context.live_connection = res->is_live;
+	conntrack_context.selective_ack = res->s_ack;
+	conntrack_context.challenge_ack_passed = res->c_ack;
+	conntrack_context.last_direction = res->ld;
+	conntrack_context.liberal_mode = res->lb;
+	conntrack_context.state = (enum rte_flow_conntrack_state)res->stat;
+	conntrack_context.max_ack_window = res->factor;
+	conntrack_context.retransmission_limit = res->re_num;
+	conntrack_context.last_window = res->lw;
+	conntrack_context.last_index =
+		(enum rte_flow_conntrack_tcp_last_index)res->li;
+	conntrack_context.last_seq = res->ls;
+	conntrack_context.last_ack = res->la;
+	conntrack_context.last_end = res->le;
 }
 
-static cmdline_parse_inst_t cmd_pctype_mapping_update = {
-	.f = cmd_pctype_mapping_update_parsed,
+static cmdline_parse_inst_t cmd_set_conntrack_common = {
+	.f = cmd_set_conntrack_common_parsed,
 	.data = NULL,
-	.help_str = "port config <port_id> pctype mapping update"
-	" <pctype_id_0,[pctype_id_1]*> <flowtype_id>",
+	.help_str = "set conntrack com peer <port_id> is_orig <dir> enable <en>"
+		" live <ack_seen> sack <en> cack <passed> last_dir <dir>"
+		" liberal <en> state <s> max_ack_win <factor> r_lim <num>"
+		" last_win <win> last_seq <seq> last_ack <ack> last_end <end>"
+		" last_index <flag>",
 	.tokens = {
-		(void *)&cmd_pctype_mapping_update_port,
-		(void *)&cmd_pctype_mapping_update_config,
-		(void *)&cmd_pctype_mapping_update_port_id,
-		(void *)&cmd_pctype_mapping_update_pctype,
-		(void *)&cmd_pctype_mapping_update_mapping,
-		(void *)&cmd_pctype_mapping_update_update,
-		(void *)&cmd_pctype_mapping_update_pc_type,
-		(void *)&cmd_pctype_mapping_update_flow_type,
+		(void *)&cmd_set_conntrack_set,
+		(void *)&cmd_set_conntrack_conntrack,
+		(void *)&cmd_set_conntrack_common_com,
+		(void *)&cmd_set_conntrack_common_peer,
+		(void *)&cmd_set_conntrack_common_peer_value,
+		(void *)&cmd_set_conntrack_common_is_orig,
+		(void *)&cmd_set_conntrack_common_is_orig_value,
+		(void *)&cmd_set_conntrack_common_enable,
+		(void *)&cmd_set_conntrack_common_enable_value,
+		(void *)&cmd_set_conntrack_common_live,
+		(void *)&cmd_set_conntrack_common_live_value,
+		(void *)&cmd_set_conntrack_common_sack,
+		(void *)&cmd_set_conntrack_common_sack_value,
+		(void *)&cmd_set_conntrack_common_cack,
+		(void *)&cmd_set_conntrack_common_cack_value,
+		(void *)&cmd_set_conntrack_common_last_dir,
+		(void *)&cmd_set_conntrack_common_last_dir_value,
+		(void *)&cmd_set_conntrack_common_liberal,
+		(void *)&cmd_set_conntrack_common_liberal_value,
+		(void *)&cmd_set_conntrack_common_state,
+		(void *)&cmd_set_conntrack_common_state_value,
+		(void *)&cmd_set_conntrack_common_max_ackwin,
+		(void *)&cmd_set_conntrack_common_max_ackwin_value,
+		(void *)&cmd_set_conntrack_common_retrans,
+		(void *)&cmd_set_conntrack_common_retrans_value,
+		(void *)&cmd_set_conntrack_common_last_win,
+		(void *)&cmd_set_conntrack_common_last_win_value,
+		(void *)&cmd_set_conntrack_common_last_seq,
+		(void *)&cmd_set_conntrack_common_last_seq_value,
+		(void *)&cmd_set_conntrack_common_last_ack,
+		(void *)&cmd_set_conntrack_common_last_ack_value,
+		(void *)&cmd_set_conntrack_common_last_end,
+		(void *)&cmd_set_conntrack_common_last_end_value,
+		(void *)&cmd_set_conntrack_common_last_index,
+		(void *)&cmd_set_conntrack_common_last_index_value,
 		NULL,
 	},
 };
 
-/* ptype mapping get */
-
-/* Common result structure for ptype mapping get */
-struct cmd_ptype_mapping_get_result {
-	cmdline_fixed_string_t ptype;
-	cmdline_fixed_string_t mapping;
-	cmdline_fixed_string_t get;
-	portid_t port_id;
-	uint8_t valid_only;
+/** Set connection tracking object both directions' details */
+struct cmd_set_conntrack_dir_result {
+	cmdline_fixed_string_t set;
+	cmdline_fixed_string_t conntrack;
+	cmdline_fixed_string_t dir;
+	cmdline_fixed_string_t scale;
+	cmdline_fixed_string_t fin;
+	cmdline_fixed_string_t ack_seen;
+	cmdline_fixed_string_t unack;
+	cmdline_fixed_string_t sent_end;
+	cmdline_fixed_string_t reply_end;
+	cmdline_fixed_string_t max_win;
+	cmdline_fixed_string_t max_ack;
+	uint32_t factor;
+	uint32_t f;
+	uint32_t as;
+	uint32_t un;
+	uint32_t se;
+	uint32_t re;
+	uint32_t mw;
+	uint32_t ma;
 };
 
-/* Common CLI fields for ptype mapping get */
-static cmdline_parse_token_string_t cmd_ptype_mapping_get_ptype =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_ptype_mapping_get_result,
-		 ptype, "ptype");
-static cmdline_parse_token_string_t cmd_ptype_mapping_get_mapping =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_ptype_mapping_get_result,
-		 mapping, "mapping");
-static cmdline_parse_token_string_t cmd_ptype_mapping_get_get =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_ptype_mapping_get_result,
-		 get, "get");
-static cmdline_parse_token_num_t cmd_ptype_mapping_get_port_id =
-	TOKEN_NUM_INITIALIZER
-		(struct cmd_ptype_mapping_get_result,
-		 port_id, RTE_UINT16);
-static cmdline_parse_token_num_t cmd_ptype_mapping_get_valid_only =
-	TOKEN_NUM_INITIALIZER
-		(struct cmd_ptype_mapping_get_result,
-		 valid_only, RTE_UINT8);
+static cmdline_parse_token_string_t cmd_set_conntrack_dir_dir =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
+				 dir, "orig#rply");
+static cmdline_parse_token_string_t cmd_set_conntrack_dir_scale =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
+				 scale, "scale");
+static cmdline_parse_token_num_t cmd_set_conntrack_dir_scale_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result,
+			      factor, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_set_conntrack_dir_fin =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
+				 fin, "fin");
+static cmdline_parse_token_num_t cmd_set_conntrack_dir_fin_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result,
+			      f, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_set_conntrack_dir_ack =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
+				 ack_seen, "acked");
+static cmdline_parse_token_num_t cmd_set_conntrack_dir_ack_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result,
+			      as, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_set_conntrack_dir_unack_data =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
+				 unack, "unack_data");
+static cmdline_parse_token_num_t cmd_set_conntrack_dir_unack_data_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result,
+			      un, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_set_conntrack_dir_sent_end =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
+				 sent_end, "sent_end");
+static cmdline_parse_token_num_t cmd_set_conntrack_dir_sent_end_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result,
+			      se, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_set_conntrack_dir_reply_end =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
+				 reply_end, "reply_end");
+static cmdline_parse_token_num_t cmd_set_conntrack_dir_reply_end_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result,
+			      re, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_set_conntrack_dir_max_win =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
+				 max_win, "max_win");
+static cmdline_parse_token_num_t cmd_set_conntrack_dir_max_win_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result,
+			      mw, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_set_conntrack_dir_max_ack =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
+				 max_ack, "max_ack");
+static cmdline_parse_token_num_t cmd_set_conntrack_dir_max_ack_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result,
+			      ma, RTE_UINT32);
 
-static void
-cmd_ptype_mapping_get_parsed(
-	void *parsed_result,
+static void cmd_set_conntrack_dir_parsed(void *parsed_result,
 	__rte_unused struct cmdline *cl,
 	__rte_unused void *data)
 {
-	struct cmd_ptype_mapping_get_result *res = parsed_result;
-	int ret = -ENOTSUP;
-#ifdef RTE_NET_I40E
-	int max_ptype_num = 256;
-	struct rte_pmd_i40e_ptype_mapping mapping[max_ptype_num];
-	uint16_t count;
-	int i;
-#endif
+	struct cmd_set_conntrack_dir_result *res = parsed_result;
+	struct rte_flow_tcp_dir_param *dir = NULL;
 
-	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
+	if (strcmp(res->dir, "orig") == 0)
+		dir = &conntrack_context.original_dir;
+	else if (strcmp(res->dir, "rply") == 0)
+		dir = &conntrack_context.reply_dir;
+	else
 		return;
-
-#ifdef RTE_NET_I40E
-	ret = rte_pmd_i40e_ptype_mapping_get(res->port_id,
-					mapping,
-					max_ptype_num,
-					&count,
-					res->valid_only);
-#endif
-
-	switch (ret) {
-	case 0:
-		break;
-	case -ENODEV:
-		fprintf(stderr, "invalid port_id %d\n", res->port_id);
-		break;
-	case -ENOTSUP:
-		fprintf(stderr, "function not implemented\n");
-		break;
-	default:
-		fprintf(stderr, "programming error: (%s)\n", strerror(-ret));
-	}
-
-#ifdef RTE_NET_I40E
-	if (!ret) {
-		for (i = 0; i < count; i++)
-			printf("%3d\t0x%08x\n",
-				mapping[i].hw_ptype, mapping[i].sw_ptype);
-	}
-#endif
+	dir->scale = res->factor;
+	dir->close_initiated = res->f;
+	dir->last_ack_seen = res->as;
+	dir->data_unacked = res->un;
+	dir->sent_end = res->se;
+	dir->reply_end = res->re;
+	dir->max_ack = res->ma;
+	dir->max_win = res->mw;
 }
 
-static cmdline_parse_inst_t cmd_ptype_mapping_get = {
-	.f = cmd_ptype_mapping_get_parsed,
+static cmdline_parse_inst_t cmd_set_conntrack_dir = {
+	.f = cmd_set_conntrack_dir_parsed,
 	.data = NULL,
-	.help_str = "ptype mapping get <port_id> <valid_only>",
+	.help_str = "set conntrack orig|rply scale <factor> fin <sent>"
+		    " acked <seen> unack_data <unack> sent_end <sent>"
+		    " reply_end <reply> max_win <win> max_ack <ack>",
 	.tokens = {
-		(void *)&cmd_ptype_mapping_get_ptype,
-		(void *)&cmd_ptype_mapping_get_mapping,
-		(void *)&cmd_ptype_mapping_get_get,
-		(void *)&cmd_ptype_mapping_get_port_id,
-		(void *)&cmd_ptype_mapping_get_valid_only,
+		(void *)&cmd_set_conntrack_set,
+		(void *)&cmd_set_conntrack_conntrack,
+		(void *)&cmd_set_conntrack_dir_dir,
+		(void *)&cmd_set_conntrack_dir_scale,
+		(void *)&cmd_set_conntrack_dir_scale_value,
+		(void *)&cmd_set_conntrack_dir_fin,
+		(void *)&cmd_set_conntrack_dir_fin_value,
+		(void *)&cmd_set_conntrack_dir_ack,
+		(void *)&cmd_set_conntrack_dir_ack_value,
+		(void *)&cmd_set_conntrack_dir_unack_data,
+		(void *)&cmd_set_conntrack_dir_unack_data_value,
+		(void *)&cmd_set_conntrack_dir_sent_end,
+		(void *)&cmd_set_conntrack_dir_sent_end_value,
+		(void *)&cmd_set_conntrack_dir_reply_end,
+		(void *)&cmd_set_conntrack_dir_reply_end_value,
+		(void *)&cmd_set_conntrack_dir_max_win,
+		(void *)&cmd_set_conntrack_dir_max_win_value,
+		(void *)&cmd_set_conntrack_dir_max_ack,
+		(void *)&cmd_set_conntrack_dir_max_ack_value,
 		NULL,
 	},
 };
 
-/* ptype mapping replace */
+/* show vf stats */
 
-/* Common result structure for ptype mapping replace */
-struct cmd_ptype_mapping_replace_result {
-	cmdline_fixed_string_t ptype;
-	cmdline_fixed_string_t mapping;
-	cmdline_fixed_string_t replace;
+/* Common result structure for show vf stats */
+struct cmd_show_vf_stats_result {
+	cmdline_fixed_string_t show;
+	cmdline_fixed_string_t vf;
+	cmdline_fixed_string_t stats;
 	portid_t port_id;
-	uint32_t target;
-	uint8_t mask;
-	uint32_t pkt_type;
+	uint16_t vf_id;
 };
 
-/* Common CLI fields for ptype mapping replace */
-static cmdline_parse_token_string_t cmd_ptype_mapping_replace_ptype =
+/* Common CLI fields show vf stats*/
+static cmdline_parse_token_string_t cmd_show_vf_stats_show =
 	TOKEN_STRING_INITIALIZER
-		(struct cmd_ptype_mapping_replace_result,
-		 ptype, "ptype");
-static cmdline_parse_token_string_t cmd_ptype_mapping_replace_mapping =
+		(struct cmd_show_vf_stats_result,
+		 show, "show");
+static cmdline_parse_token_string_t cmd_show_vf_stats_vf =
 	TOKEN_STRING_INITIALIZER
-		(struct cmd_ptype_mapping_replace_result,
-		 mapping, "mapping");
-static cmdline_parse_token_string_t cmd_ptype_mapping_replace_replace =
+		(struct cmd_show_vf_stats_result,
+		 vf, "vf");
+static cmdline_parse_token_string_t cmd_show_vf_stats_stats =
 	TOKEN_STRING_INITIALIZER
-		(struct cmd_ptype_mapping_replace_result,
-		 replace, "replace");
-static cmdline_parse_token_num_t cmd_ptype_mapping_replace_port_id =
+		(struct cmd_show_vf_stats_result,
+		 stats, "stats");
+static cmdline_parse_token_num_t cmd_show_vf_stats_port_id =
 	TOKEN_NUM_INITIALIZER
-		(struct cmd_ptype_mapping_replace_result,
+		(struct cmd_show_vf_stats_result,
 		 port_id, RTE_UINT16);
-static cmdline_parse_token_num_t cmd_ptype_mapping_replace_target =
-	TOKEN_NUM_INITIALIZER
-		(struct cmd_ptype_mapping_replace_result,
-		 target, RTE_UINT32);
-static cmdline_parse_token_num_t cmd_ptype_mapping_replace_mask =
-	TOKEN_NUM_INITIALIZER
-		(struct cmd_ptype_mapping_replace_result,
-		 mask, RTE_UINT8);
-static cmdline_parse_token_num_t cmd_ptype_mapping_replace_pkt_type =
+static cmdline_parse_token_num_t cmd_show_vf_stats_vf_id =
 	TOKEN_NUM_INITIALIZER
-		(struct cmd_ptype_mapping_replace_result,
-		 pkt_type, RTE_UINT32);
+		(struct cmd_show_vf_stats_result,
+		 vf_id, RTE_UINT16);
 
 static void
-cmd_ptype_mapping_replace_parsed(
+cmd_show_vf_stats_parsed(
 	void *parsed_result,
 	__rte_unused struct cmdline *cl,
 	__rte_unused void *data)
 {
-	struct cmd_ptype_mapping_replace_result *res = parsed_result;
+	struct cmd_show_vf_stats_result *res = parsed_result;
+	struct rte_eth_stats stats;
 	int ret = -ENOTSUP;
+	static const char *nic_stats_border = "########################";
 
 	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
 		return;
 
+	memset(&stats, 0, sizeof(stats));
+
 #ifdef RTE_NET_I40E
-	ret = rte_pmd_i40e_ptype_mapping_replace(res->port_id,
-					res->target,
-					res->mask,
-					res->pkt_type);
+	if (ret == -ENOTSUP)
+		ret = rte_pmd_i40e_get_vf_stats(res->port_id,
+						res->vf_id,
+						&stats);
+#endif
+#ifdef RTE_NET_BNXT
+	if (ret == -ENOTSUP)
+		ret = rte_pmd_bnxt_get_vf_stats(res->port_id,
+						res->vf_id,
+						&stats);
 #endif
 
 	switch (ret) {
 	case 0:
 		break;
 	case -EINVAL:
-		fprintf(stderr, "invalid ptype 0x%8x or 0x%8x\n",
-			res->target, res->pkt_type);
+		fprintf(stderr, "invalid vf_id %d\n", res->vf_id);
 		break;
 	case -ENODEV:
 		fprintf(stderr, "invalid port_id %d\n", res->port_id);
@@ -14814,162 +12196,99 @@  cmd_ptype_mapping_replace_parsed(
 	default:
 		fprintf(stderr, "programming error: (%s)\n", strerror(-ret));
 	}
-}
-
-static cmdline_parse_inst_t cmd_ptype_mapping_replace = {
-	.f = cmd_ptype_mapping_replace_parsed,
-	.data = NULL,
-	.help_str =
-		"ptype mapping replace <port_id> <target> <mask> <pkt_type>",
-	.tokens = {
-		(void *)&cmd_ptype_mapping_replace_ptype,
-		(void *)&cmd_ptype_mapping_replace_mapping,
-		(void *)&cmd_ptype_mapping_replace_replace,
-		(void *)&cmd_ptype_mapping_replace_port_id,
-		(void *)&cmd_ptype_mapping_replace_target,
-		(void *)&cmd_ptype_mapping_replace_mask,
-		(void *)&cmd_ptype_mapping_replace_pkt_type,
-		NULL,
-	},
-};
-
-/* ptype mapping reset */
-
-/* Common result structure for ptype mapping reset */
-struct cmd_ptype_mapping_reset_result {
-	cmdline_fixed_string_t ptype;
-	cmdline_fixed_string_t mapping;
-	cmdline_fixed_string_t reset;
-	portid_t port_id;
-};
-
-/* Common CLI fields for ptype mapping reset*/
-static cmdline_parse_token_string_t cmd_ptype_mapping_reset_ptype =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_ptype_mapping_reset_result,
-		 ptype, "ptype");
-static cmdline_parse_token_string_t cmd_ptype_mapping_reset_mapping =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_ptype_mapping_reset_result,
-		 mapping, "mapping");
-static cmdline_parse_token_string_t cmd_ptype_mapping_reset_reset =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_ptype_mapping_reset_result,
-		 reset, "reset");
-static cmdline_parse_token_num_t cmd_ptype_mapping_reset_port_id =
-	TOKEN_NUM_INITIALIZER
-		(struct cmd_ptype_mapping_reset_result,
-		 port_id, RTE_UINT16);
-
-static void
-cmd_ptype_mapping_reset_parsed(
-	void *parsed_result,
-	__rte_unused struct cmdline *cl,
-	__rte_unused void *data)
-{
-	struct cmd_ptype_mapping_reset_result *res = parsed_result;
-	int ret = -ENOTSUP;
 
-	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
-		return;
+	printf("\n  %s NIC statistics for port %-2d vf %-2d %s\n",
+		nic_stats_border, res->port_id, res->vf_id, nic_stats_border);
 
-#ifdef RTE_NET_I40E
-	ret = rte_pmd_i40e_ptype_mapping_reset(res->port_id);
-#endif
+	printf("  RX-packets: %-10"PRIu64" RX-missed: %-10"PRIu64" RX-bytes:  "
+	       "%-"PRIu64"\n",
+	       stats.ipackets, stats.imissed, stats.ibytes);
+	printf("  RX-errors: %-"PRIu64"\n", stats.ierrors);
+	printf("  RX-nombuf:  %-10"PRIu64"\n",
+	       stats.rx_nombuf);
+	printf("  TX-packets: %-10"PRIu64" TX-errors: %-10"PRIu64" TX-bytes:  "
+	       "%-"PRIu64"\n",
+	       stats.opackets, stats.oerrors, stats.obytes);
 
-	switch (ret) {
-	case 0:
-		break;
-	case -ENODEV:
-		fprintf(stderr, "invalid port_id %d\n", res->port_id);
-		break;
-	case -ENOTSUP:
-		fprintf(stderr, "function not implemented\n");
-		break;
-	default:
-		fprintf(stderr, "programming error: (%s)\n", strerror(-ret));
-	}
+	printf("  %s############################%s\n",
+			       nic_stats_border, nic_stats_border);
 }
 
-static cmdline_parse_inst_t cmd_ptype_mapping_reset = {
-	.f = cmd_ptype_mapping_reset_parsed,
+static cmdline_parse_inst_t cmd_show_vf_stats = {
+	.f = cmd_show_vf_stats_parsed,
 	.data = NULL,
-	.help_str = "ptype mapping reset <port_id>",
+	.help_str = "show vf stats <port_id> <vf_id>",
 	.tokens = {
-		(void *)&cmd_ptype_mapping_reset_ptype,
-		(void *)&cmd_ptype_mapping_reset_mapping,
-		(void *)&cmd_ptype_mapping_reset_reset,
-		(void *)&cmd_ptype_mapping_reset_port_id,
+		(void *)&cmd_show_vf_stats_show,
+		(void *)&cmd_show_vf_stats_vf,
+		(void *)&cmd_show_vf_stats_stats,
+		(void *)&cmd_show_vf_stats_port_id,
+		(void *)&cmd_show_vf_stats_vf_id,
 		NULL,
 	},
 };
 
-/* ptype mapping update */
+/* clear vf stats */
 
-/* Common result structure for ptype mapping update */
-struct cmd_ptype_mapping_update_result {
-	cmdline_fixed_string_t ptype;
-	cmdline_fixed_string_t mapping;
-	cmdline_fixed_string_t reset;
+/* Common result structure for clear vf stats */
+struct cmd_clear_vf_stats_result {
+	cmdline_fixed_string_t clear;
+	cmdline_fixed_string_t vf;
+	cmdline_fixed_string_t stats;
 	portid_t port_id;
-	uint8_t hw_ptype;
-	uint32_t sw_ptype;
+	uint16_t vf_id;
 };
 
-/* Common CLI fields for ptype mapping update*/
-static cmdline_parse_token_string_t cmd_ptype_mapping_update_ptype =
+/* Common CLI fields clear vf stats*/
+static cmdline_parse_token_string_t cmd_clear_vf_stats_clear =
 	TOKEN_STRING_INITIALIZER
-		(struct cmd_ptype_mapping_update_result,
-		 ptype, "ptype");
-static cmdline_parse_token_string_t cmd_ptype_mapping_update_mapping =
+		(struct cmd_clear_vf_stats_result,
+		 clear, "clear");
+static cmdline_parse_token_string_t cmd_clear_vf_stats_vf =
 	TOKEN_STRING_INITIALIZER
-		(struct cmd_ptype_mapping_update_result,
-		 mapping, "mapping");
-static cmdline_parse_token_string_t cmd_ptype_mapping_update_update =
+		(struct cmd_clear_vf_stats_result,
+		 vf, "vf");
+static cmdline_parse_token_string_t cmd_clear_vf_stats_stats =
 	TOKEN_STRING_INITIALIZER
-		(struct cmd_ptype_mapping_update_result,
-		 reset, "update");
-static cmdline_parse_token_num_t cmd_ptype_mapping_update_port_id =
+		(struct cmd_clear_vf_stats_result,
+		 stats, "stats");
+static cmdline_parse_token_num_t cmd_clear_vf_stats_port_id =
 	TOKEN_NUM_INITIALIZER
-		(struct cmd_ptype_mapping_update_result,
+		(struct cmd_clear_vf_stats_result,
 		 port_id, RTE_UINT16);
-static cmdline_parse_token_num_t cmd_ptype_mapping_update_hw_ptype =
-	TOKEN_NUM_INITIALIZER
-		(struct cmd_ptype_mapping_update_result,
-		 hw_ptype, RTE_UINT8);
-static cmdline_parse_token_num_t cmd_ptype_mapping_update_sw_ptype =
+static cmdline_parse_token_num_t cmd_clear_vf_stats_vf_id =
 	TOKEN_NUM_INITIALIZER
-		(struct cmd_ptype_mapping_update_result,
-		 sw_ptype, RTE_UINT32);
+		(struct cmd_clear_vf_stats_result,
+		 vf_id, RTE_UINT16);
 
 static void
-cmd_ptype_mapping_update_parsed(
+cmd_clear_vf_stats_parsed(
 	void *parsed_result,
 	__rte_unused struct cmdline *cl,
 	__rte_unused void *data)
 {
-	struct cmd_ptype_mapping_update_result *res = parsed_result;
+	struct cmd_clear_vf_stats_result *res = parsed_result;
 	int ret = -ENOTSUP;
-#ifdef RTE_NET_I40E
-	struct rte_pmd_i40e_ptype_mapping mapping;
-#endif
+
 	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
 		return;
 
 #ifdef RTE_NET_I40E
-	mapping.hw_ptype = res->hw_ptype;
-	mapping.sw_ptype = res->sw_ptype;
-	ret = rte_pmd_i40e_ptype_mapping_update(res->port_id,
-						&mapping,
-						1,
-						0);
+	if (ret == -ENOTSUP)
+		ret = rte_pmd_i40e_reset_vf_stats(res->port_id,
+						  res->vf_id);
+#endif
+#ifdef RTE_NET_BNXT
+	if (ret == -ENOTSUP)
+		ret = rte_pmd_bnxt_reset_vf_stats(res->port_id,
+						  res->vf_id);
 #endif
 
 	switch (ret) {
 	case 0:
 		break;
 	case -EINVAL:
-		fprintf(stderr, "invalid ptype 0x%8x\n", res->sw_ptype);
+		fprintf(stderr, "invalid vf_id %d\n", res->vf_id);
 		break;
 	case -ENODEV:
 		fprintf(stderr, "invalid port_id %d\n", res->port_id);
@@ -14982,17 +12301,16 @@  cmd_ptype_mapping_update_parsed(
 	}
 }
 
-static cmdline_parse_inst_t cmd_ptype_mapping_update = {
-	.f = cmd_ptype_mapping_update_parsed,
+static cmdline_parse_inst_t cmd_clear_vf_stats = {
+	.f = cmd_clear_vf_stats_parsed,
 	.data = NULL,
-	.help_str = "ptype mapping update <port_id> <hw_ptype> <sw_ptype>",
+	.help_str = "clear vf stats <port_id> <vf_id>",
 	.tokens = {
-		(void *)&cmd_ptype_mapping_update_ptype,
-		(void *)&cmd_ptype_mapping_update_mapping,
-		(void *)&cmd_ptype_mapping_update_update,
-		(void *)&cmd_ptype_mapping_update_port_id,
-		(void *)&cmd_ptype_mapping_update_hw_ptype,
-		(void *)&cmd_ptype_mapping_update_sw_ptype,
+		(void *)&cmd_clear_vf_stats_clear,
+		(void *)&cmd_clear_vf_stats_vf,
+		(void *)&cmd_clear_vf_stats_stats,
+		(void *)&cmd_clear_vf_stats_port_id,
+		(void *)&cmd_clear_vf_stats_vf_id,
 		NULL,
 	},
 };
@@ -16929,9 +14247,6 @@  static cmdline_parse_ctx_t builtin_ctx[] = {
 	(cmdline_parse_inst_t *)&cmd_cleanup_txq_mbufs,
 	(cmdline_parse_inst_t *)&cmd_dump,
 	(cmdline_parse_inst_t *)&cmd_dump_one,
-#ifdef RTE_NET_I40E
-	(cmdline_parse_inst_t *)&cmd_add_del_raw_flow_director,
-#endif
 	(cmdline_parse_inst_t *)&cmd_set_flow_director_ip_mask,
 	(cmdline_parse_inst_t *)&cmd_set_flow_director_mac_vlan_mask,
 	(cmdline_parse_inst_t *)&cmd_set_flow_director_tunnel_mask,
@@ -16967,14 +14282,6 @@  static cmdline_parse_ctx_t builtin_ctx[] = {
 	(cmdline_parse_inst_t *)&cmd_vf_rate_limit,
 	(cmdline_parse_inst_t *)&cmd_vf_rxvlan_filter,
 	(cmdline_parse_inst_t *)&cmd_set_vf_mac_addr,
-	(cmdline_parse_inst_t *)&cmd_set_vf_promisc,
-	(cmdline_parse_inst_t *)&cmd_set_vf_allmulti,
-	(cmdline_parse_inst_t *)&cmd_set_vf_broadcast,
-	(cmdline_parse_inst_t *)&cmd_set_vf_vlan_tag,
-	(cmdline_parse_inst_t *)&cmd_vf_max_bw,
-	(cmdline_parse_inst_t *)&cmd_vf_tc_min_bw,
-	(cmdline_parse_inst_t *)&cmd_vf_tc_max_bw,
-	(cmdline_parse_inst_t *)&cmd_strict_link_prio,
 	(cmdline_parse_inst_t *)&cmd_tc_min_bw,
 	(cmdline_parse_inst_t *)&cmd_set_vxlan,
 	(cmdline_parse_inst_t *)&cmd_set_vxlan_tos_ttl,
@@ -16995,29 +14302,10 @@  static cmdline_parse_ctx_t builtin_ctx[] = {
 	(cmdline_parse_inst_t *)&cmd_set_mplsoudp_decap_with_vlan,
 	(cmdline_parse_inst_t *)&cmd_set_conntrack_common,
 	(cmdline_parse_inst_t *)&cmd_set_conntrack_dir,
-	(cmdline_parse_inst_t *)&cmd_ddp_add,
-	(cmdline_parse_inst_t *)&cmd_ddp_del,
-	(cmdline_parse_inst_t *)&cmd_ddp_get_list,
-	(cmdline_parse_inst_t *)&cmd_ddp_get_info,
-	(cmdline_parse_inst_t *)&cmd_cfg_input_set,
-	(cmdline_parse_inst_t *)&cmd_clear_input_set,
 	(cmdline_parse_inst_t *)&cmd_show_vf_stats,
 	(cmdline_parse_inst_t *)&cmd_clear_vf_stats,
 	(cmdline_parse_inst_t *)&cmd_show_port_supported_ptypes,
 	(cmdline_parse_inst_t *)&cmd_set_port_ptypes,
-	(cmdline_parse_inst_t *)&cmd_ptype_mapping_get,
-	(cmdline_parse_inst_t *)&cmd_ptype_mapping_replace,
-	(cmdline_parse_inst_t *)&cmd_ptype_mapping_reset,
-	(cmdline_parse_inst_t *)&cmd_ptype_mapping_update,
-
-	(cmdline_parse_inst_t *)&cmd_pctype_mapping_get,
-	(cmdline_parse_inst_t *)&cmd_pctype_mapping_reset,
-	(cmdline_parse_inst_t *)&cmd_pctype_mapping_update,
-	(cmdline_parse_inst_t *)&cmd_queue_region,
-	(cmdline_parse_inst_t *)&cmd_region_flowtype,
-	(cmdline_parse_inst_t *)&cmd_user_priority_region,
-	(cmdline_parse_inst_t *)&cmd_flush_queue_region,
-	(cmdline_parse_inst_t *)&cmd_show_queue_region_info_all,
 	(cmdline_parse_inst_t *)&cmd_show_port_tm_cap,
 	(cmdline_parse_inst_t *)&cmd_show_port_tm_level_cap,
 	(cmdline_parse_inst_t *)&cmd_show_port_tm_node_cap,
diff --git a/app/test-pmd/config.c b/app/test-pmd/config.c
index 1b1e738f83..2e5c631e8d 100644
--- a/app/test-pmd/config.c
+++ b/app/test-pmd/config.c
@@ -6243,49 +6243,6 @@  close_file(uint8_t *buf)
 	return -1;
 }
 
-void
-port_queue_region_info_display(portid_t port_id, void *buf)
-{
-#ifdef RTE_NET_I40E
-	uint16_t i, j;
-	struct rte_pmd_i40e_queue_regions *info =
-		(struct rte_pmd_i40e_queue_regions *)buf;
-	static const char *queue_region_info_stats_border = "-------";
-
-	if (!info->queue_region_number)
-		printf("there is no region has been set before");
-
-	printf("\n	%s All queue region info for port=%2d %s",
-			queue_region_info_stats_border, port_id,
-			queue_region_info_stats_border);
-	printf("\n	queue_region_number: %-14u \n",
-			info->queue_region_number);
-
-	for (i = 0; i < info->queue_region_number; i++) {
-		printf("\n	region_id: %-14u queue_number: %-14u "
-			"queue_start_index: %-14u \n",
-			info->region[i].region_id,
-			info->region[i].queue_num,
-			info->region[i].queue_start_index);
-
-		printf("  user_priority_num is	%-14u :",
-					info->region[i].user_priority_num);
-		for (j = 0; j < info->region[i].user_priority_num; j++)
-			printf(" %-14u ", info->region[i].user_priority[j]);
-
-		printf("\n	flowtype_num is  %-14u :",
-				info->region[i].flowtype_num);
-		for (j = 0; j < info->region[i].flowtype_num; j++)
-			printf(" %-14u ", info->region[i].hw_flowtype[j]);
-	}
-#else
-	RTE_SET_USED(port_id);
-	RTE_SET_USED(buf);
-#endif
-
-	printf("\n\n");
-}
-
 void
 show_macs(portid_t port_id)
 {
diff --git a/app/test-pmd/testpmd.h b/app/test-pmd/testpmd.h
index b7f926cd38..71aa168c6e 100644
--- a/app/test-pmd/testpmd.h
+++ b/app/test-pmd/testpmd.h
@@ -1122,8 +1122,6 @@  uint8_t *open_file(const char *file_path, uint32_t *size);
 int save_file(const char *file_path, uint8_t *buf, uint32_t size);
 int close_file(uint8_t *buf);
 
-void port_queue_region_info_display(portid_t port_id, void *buf);
-
 enum print_warning {
 	ENABLED_WARN = 0,
 	DISABLED_WARN
diff --git a/drivers/net/i40e/i40e_testpmd.c b/drivers/net/i40e/i40e_testpmd.c
new file mode 100644
index 0000000000..fd74352a07
--- /dev/null
+++ b/drivers/net/i40e/i40e_testpmd.c
@@ -0,0 +1,2718 @@ 
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2010-2016 Intel Corporation.
+ */
+#include <rte_pmd_i40e.h>
+
+#include <cmdline_parse_num.h>
+#include <cmdline_parse_string.h>
+
+#include "testpmd.h"
+
+/* *** queue region set *** */
+struct cmd_queue_region_result {
+	cmdline_fixed_string_t set;
+	cmdline_fixed_string_t port;
+	portid_t port_id;
+	cmdline_fixed_string_t cmd;
+	cmdline_fixed_string_t region;
+	uint8_t  region_id;
+	cmdline_fixed_string_t queue_start_index;
+	uint8_t  queue_id;
+	cmdline_fixed_string_t queue_num;
+	uint8_t  queue_num_value;
+};
+
+static void
+cmd_queue_region_parsed(void *parsed_result,
+			__rte_unused struct cmdline *cl,
+			__rte_unused void *data)
+{
+	struct cmd_queue_region_result *res = parsed_result;
+	int ret = -ENOTSUP;
+	struct rte_pmd_i40e_queue_region_conf region_conf;
+	enum rte_pmd_i40e_queue_region_op op_type;
+
+	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
+		return;
+
+	memset(&region_conf, 0, sizeof(region_conf));
+	op_type = RTE_PMD_I40E_RSS_QUEUE_REGION_SET;
+	region_conf.region_id = res->region_id;
+	region_conf.queue_num = res->queue_num_value;
+	region_conf.queue_start_index = res->queue_id;
+
+	ret = rte_pmd_i40e_rss_queue_region_conf(res->port_id,
+				op_type, &region_conf);
+	switch (ret) {
+	case 0:
+		break;
+	case -ENOTSUP:
+		fprintf(stderr, "function not implemented or supported\n");
+		break;
+	default:
+		fprintf(stderr, "queue region config error: (%s)\n",
+			strerror(-ret));
+	}
+}
+
+static cmdline_parse_token_string_t cmd_queue_region_set =
+TOKEN_STRING_INITIALIZER(struct cmd_queue_region_result,
+		set, "set");
+static cmdline_parse_token_string_t cmd_queue_region_port =
+	TOKEN_STRING_INITIALIZER(struct cmd_queue_region_result, port, "port");
+static cmdline_parse_token_num_t cmd_queue_region_port_id =
+	TOKEN_NUM_INITIALIZER(struct cmd_queue_region_result,
+				port_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_queue_region_cmd =
+	TOKEN_STRING_INITIALIZER(struct cmd_queue_region_result,
+				 cmd, "queue-region");
+static cmdline_parse_token_string_t cmd_queue_region_id =
+	TOKEN_STRING_INITIALIZER(struct cmd_queue_region_result,
+				region, "region_id");
+static cmdline_parse_token_num_t cmd_queue_region_index =
+	TOKEN_NUM_INITIALIZER(struct cmd_queue_region_result,
+				region_id, RTE_UINT8);
+static cmdline_parse_token_string_t cmd_queue_region_queue_start_index =
+	TOKEN_STRING_INITIALIZER(struct cmd_queue_region_result,
+				queue_start_index, "queue_start_index");
+static cmdline_parse_token_num_t cmd_queue_region_queue_id =
+	TOKEN_NUM_INITIALIZER(struct cmd_queue_region_result,
+				queue_id, RTE_UINT8);
+static cmdline_parse_token_string_t cmd_queue_region_queue_num =
+	TOKEN_STRING_INITIALIZER(struct cmd_queue_region_result,
+				queue_num, "queue_num");
+static cmdline_parse_token_num_t cmd_queue_region_queue_num_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_queue_region_result,
+				queue_num_value, RTE_UINT8);
+
+static cmdline_parse_inst_t cmd_queue_region = {
+	.f = cmd_queue_region_parsed,
+	.data = NULL,
+	.help_str = "set port <port_id> queue-region region_id <value> "
+		"queue_start_index <value> queue_num <value>: Set a queue region",
+	.tokens = {
+		(void *)&cmd_queue_region_set,
+		(void *)&cmd_queue_region_port,
+		(void *)&cmd_queue_region_port_id,
+		(void *)&cmd_queue_region_cmd,
+		(void *)&cmd_queue_region_id,
+		(void *)&cmd_queue_region_index,
+		(void *)&cmd_queue_region_queue_start_index,
+		(void *)&cmd_queue_region_queue_id,
+		(void *)&cmd_queue_region_queue_num,
+		(void *)&cmd_queue_region_queue_num_value,
+		NULL,
+	},
+};
+
+/* *** queue region and flowtype set *** */
+struct cmd_region_flowtype_result {
+	cmdline_fixed_string_t set;
+	cmdline_fixed_string_t port;
+	portid_t port_id;
+	cmdline_fixed_string_t cmd;
+	cmdline_fixed_string_t region;
+	uint8_t  region_id;
+	cmdline_fixed_string_t flowtype;
+	uint8_t  flowtype_id;
+};
+
+static void
+cmd_region_flowtype_parsed(void *parsed_result,
+			__rte_unused struct cmdline *cl,
+			__rte_unused void *data)
+{
+	struct cmd_region_flowtype_result *res = parsed_result;
+	int ret = -ENOTSUP;
+	struct rte_pmd_i40e_queue_region_conf region_conf;
+	enum rte_pmd_i40e_queue_region_op op_type;
+
+	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
+		return;
+
+	memset(&region_conf, 0, sizeof(region_conf));
+
+	op_type = RTE_PMD_I40E_RSS_QUEUE_REGION_FLOWTYPE_SET;
+	region_conf.region_id = res->region_id;
+	region_conf.hw_flowtype = res->flowtype_id;
+
+	ret = rte_pmd_i40e_rss_queue_region_conf(res->port_id,
+			op_type, &region_conf);
+	switch (ret) {
+	case 0:
+		break;
+	case -ENOTSUP:
+		fprintf(stderr, "function not implemented or supported\n");
+		break;
+	default:
+		fprintf(stderr, "region flowtype config error: (%s)\n",
+			strerror(-ret));
+	}
+}
+
+static cmdline_parse_token_string_t cmd_region_flowtype_set =
+TOKEN_STRING_INITIALIZER(struct cmd_region_flowtype_result,
+				set, "set");
+static cmdline_parse_token_string_t cmd_region_flowtype_port =
+	TOKEN_STRING_INITIALIZER(struct cmd_region_flowtype_result,
+				port, "port");
+static cmdline_parse_token_num_t cmd_region_flowtype_port_index =
+	TOKEN_NUM_INITIALIZER(struct cmd_region_flowtype_result,
+				port_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_region_flowtype_cmd =
+	TOKEN_STRING_INITIALIZER(struct cmd_region_flowtype_result,
+				cmd, "queue-region");
+static cmdline_parse_token_string_t cmd_region_flowtype_index =
+	TOKEN_STRING_INITIALIZER(struct cmd_region_flowtype_result,
+				region, "region_id");
+static cmdline_parse_token_num_t cmd_region_flowtype_id =
+	TOKEN_NUM_INITIALIZER(struct cmd_region_flowtype_result,
+				region_id, RTE_UINT8);
+static cmdline_parse_token_string_t cmd_region_flowtype_flow_index =
+	TOKEN_STRING_INITIALIZER(struct cmd_region_flowtype_result,
+				flowtype, "flowtype");
+static cmdline_parse_token_num_t cmd_region_flowtype_flow_id =
+	TOKEN_NUM_INITIALIZER(struct cmd_region_flowtype_result,
+				flowtype_id, RTE_UINT8);
+static cmdline_parse_inst_t cmd_region_flowtype = {
+	.f = cmd_region_flowtype_parsed,
+	.data = NULL,
+	.help_str = "set port <port_id> queue-region region_id <value> "
+		"flowtype <value>: Set a flowtype region index",
+	.tokens = {
+		(void *)&cmd_region_flowtype_set,
+		(void *)&cmd_region_flowtype_port,
+		(void *)&cmd_region_flowtype_port_index,
+		(void *)&cmd_region_flowtype_cmd,
+		(void *)&cmd_region_flowtype_index,
+		(void *)&cmd_region_flowtype_id,
+		(void *)&cmd_region_flowtype_flow_index,
+		(void *)&cmd_region_flowtype_flow_id,
+		NULL,
+	},
+};
+
+/* *** User Priority (UP) to queue region (region_id) set *** */
+struct cmd_user_priority_region_result {
+	cmdline_fixed_string_t set;
+	cmdline_fixed_string_t port;
+	portid_t port_id;
+	cmdline_fixed_string_t cmd;
+	cmdline_fixed_string_t user_priority;
+	uint8_t  user_priority_id;
+	cmdline_fixed_string_t region;
+	uint8_t  region_id;
+};
+
+static void
+cmd_user_priority_region_parsed(void *parsed_result,
+			__rte_unused struct cmdline *cl,
+			__rte_unused void *data)
+{
+	struct cmd_user_priority_region_result *res = parsed_result;
+	int ret = -ENOTSUP;
+	struct rte_pmd_i40e_queue_region_conf region_conf;
+	enum rte_pmd_i40e_queue_region_op op_type;
+
+	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
+		return;
+
+	memset(&region_conf, 0, sizeof(region_conf));
+	op_type = RTE_PMD_I40E_RSS_QUEUE_REGION_USER_PRIORITY_SET;
+	region_conf.user_priority = res->user_priority_id;
+	region_conf.region_id = res->region_id;
+
+	ret = rte_pmd_i40e_rss_queue_region_conf(res->port_id,
+				op_type, &region_conf);
+	switch (ret) {
+	case 0:
+		break;
+	case -ENOTSUP:
+		fprintf(stderr, "function not implemented or supported\n");
+		break;
+	default:
+		fprintf(stderr, "user_priority region config error: (%s)\n",
+			strerror(-ret));
+	}
+}
+
+static cmdline_parse_token_string_t cmd_user_priority_region_set =
+	TOKEN_STRING_INITIALIZER(struct cmd_user_priority_region_result,
+				set, "set");
+static cmdline_parse_token_string_t cmd_user_priority_region_port =
+	TOKEN_STRING_INITIALIZER(struct cmd_user_priority_region_result,
+				port, "port");
+static cmdline_parse_token_num_t cmd_user_priority_region_port_index =
+	TOKEN_NUM_INITIALIZER(struct cmd_user_priority_region_result,
+				port_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_user_priority_region_cmd =
+	TOKEN_STRING_INITIALIZER(struct cmd_user_priority_region_result,
+				cmd, "queue-region");
+static cmdline_parse_token_string_t cmd_user_priority_region_UP =
+	TOKEN_STRING_INITIALIZER(struct cmd_user_priority_region_result,
+				user_priority, "UP");
+static cmdline_parse_token_num_t cmd_user_priority_region_UP_id =
+	TOKEN_NUM_INITIALIZER(struct cmd_user_priority_region_result,
+				user_priority_id, RTE_UINT8);
+static cmdline_parse_token_string_t cmd_user_priority_region_region =
+	TOKEN_STRING_INITIALIZER(struct cmd_user_priority_region_result,
+				region, "region_id");
+static cmdline_parse_token_num_t cmd_user_priority_region_region_id =
+	TOKEN_NUM_INITIALIZER(struct cmd_user_priority_region_result,
+				region_id, RTE_UINT8);
+
+static cmdline_parse_inst_t cmd_user_priority_region = {
+	.f = cmd_user_priority_region_parsed,
+	.data = NULL,
+	.help_str = "set port <port_id> queue-region UP <value> "
+		"region_id <value>: Set the mapping of User Priority (UP) "
+		"to queue region (region_id) ",
+	.tokens = {
+		(void *)&cmd_user_priority_region_set,
+		(void *)&cmd_user_priority_region_port,
+		(void *)&cmd_user_priority_region_port_index,
+		(void *)&cmd_user_priority_region_cmd,
+		(void *)&cmd_user_priority_region_UP,
+		(void *)&cmd_user_priority_region_UP_id,
+		(void *)&cmd_user_priority_region_region,
+		(void *)&cmd_user_priority_region_region_id,
+		NULL,
+	},
+};
+
+/* *** flush all queue region related configuration *** */
+struct cmd_flush_queue_region_result {
+	cmdline_fixed_string_t set;
+	cmdline_fixed_string_t port;
+	portid_t port_id;
+	cmdline_fixed_string_t cmd;
+	cmdline_fixed_string_t flush;
+	cmdline_fixed_string_t what;
+};
+
+static void
+cmd_flush_queue_region_parsed(void *parsed_result,
+			__rte_unused struct cmdline *cl,
+			__rte_unused void *data)
+{
+	struct cmd_flush_queue_region_result *res = parsed_result;
+	int ret = -ENOTSUP;
+	struct rte_pmd_i40e_queue_region_conf region_conf;
+	enum rte_pmd_i40e_queue_region_op op_type;
+
+	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
+		return;
+
+	memset(&region_conf, 0, sizeof(region_conf));
+
+	if (strcmp(res->what, "on") == 0)
+		op_type = RTE_PMD_I40E_RSS_QUEUE_REGION_ALL_FLUSH_ON;
+	else
+		op_type = RTE_PMD_I40E_RSS_QUEUE_REGION_ALL_FLUSH_OFF;
+
+	ret = rte_pmd_i40e_rss_queue_region_conf(res->port_id,
+				op_type, &region_conf);
+	switch (ret) {
+	case 0:
+		break;
+	case -ENOTSUP:
+		fprintf(stderr, "function not implemented or supported\n");
+		break;
+	default:
+		fprintf(stderr, "queue region config flush error: (%s)\n",
+			strerror(-ret));
+	}
+}
+
+static cmdline_parse_token_string_t cmd_flush_queue_region_set =
+	TOKEN_STRING_INITIALIZER(struct cmd_flush_queue_region_result,
+				set, "set");
+static cmdline_parse_token_string_t cmd_flush_queue_region_port =
+	TOKEN_STRING_INITIALIZER(struct cmd_flush_queue_region_result,
+				port, "port");
+static cmdline_parse_token_num_t cmd_flush_queue_region_port_index =
+	TOKEN_NUM_INITIALIZER(struct cmd_flush_queue_region_result,
+				port_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_flush_queue_region_cmd =
+	TOKEN_STRING_INITIALIZER(struct cmd_flush_queue_region_result,
+				cmd, "queue-region");
+static cmdline_parse_token_string_t cmd_flush_queue_region_flush =
+	TOKEN_STRING_INITIALIZER(struct cmd_flush_queue_region_result,
+				flush, "flush");
+static cmdline_parse_token_string_t cmd_flush_queue_region_what =
+	TOKEN_STRING_INITIALIZER(struct cmd_flush_queue_region_result,
+				what, "on#off");
+
+static cmdline_parse_inst_t cmd_flush_queue_region = {
+	.f = cmd_flush_queue_region_parsed,
+	.data = NULL,
+	.help_str = "set port <port_id> queue-region flush on|off"
+		": flush all queue region related configuration",
+	.tokens = {
+		(void *)&cmd_flush_queue_region_set,
+		(void *)&cmd_flush_queue_region_port,
+		(void *)&cmd_flush_queue_region_port_index,
+		(void *)&cmd_flush_queue_region_cmd,
+		(void *)&cmd_flush_queue_region_flush,
+		(void *)&cmd_flush_queue_region_what,
+		NULL,
+	},
+};
+
+/* *** get all queue region related configuration info *** */
+struct cmd_show_queue_region_info {
+	cmdline_fixed_string_t show;
+	cmdline_fixed_string_t port;
+	portid_t port_id;
+	cmdline_fixed_string_t cmd;
+};
+
+static void
+port_queue_region_info_display(portid_t port_id, void *buf)
+{
+	uint16_t i, j;
+	struct rte_pmd_i40e_queue_regions *info =
+		(struct rte_pmd_i40e_queue_regions *)buf;
+	static const char *queue_region_info_stats_border = "-------";
+
+	if (!info->queue_region_number)
+		printf("there is no region has been set before");
+
+	printf("\n	%s All queue region info for port=%2d %s",
+			queue_region_info_stats_border, port_id,
+			queue_region_info_stats_border);
+	printf("\n	queue_region_number: %-14u\n",
+			info->queue_region_number);
+
+	for (i = 0; i < info->queue_region_number; i++) {
+		printf("\n	region_id: %-14u queue_number: %-14u "
+			"queue_start_index: %-14u\n",
+			info->region[i].region_id,
+			info->region[i].queue_num,
+			info->region[i].queue_start_index);
+
+		printf("  user_priority_num is	%-14u :",
+					info->region[i].user_priority_num);
+		for (j = 0; j < info->region[i].user_priority_num; j++)
+			printf(" %-14u ", info->region[i].user_priority[j]);
+
+		printf("\n	flowtype_num is  %-14u :",
+				info->region[i].flowtype_num);
+		for (j = 0; j < info->region[i].flowtype_num; j++)
+			printf(" %-14u ", info->region[i].hw_flowtype[j]);
+	}
+
+	printf("\n\n");
+}
+
+static void
+cmd_show_queue_region_info_parsed(void *parsed_result,
+			__rte_unused struct cmdline *cl,
+			__rte_unused void *data)
+{
+	struct cmd_show_queue_region_info *res = parsed_result;
+	int ret = -ENOTSUP;
+	struct rte_pmd_i40e_queue_regions rte_pmd_regions;
+	enum rte_pmd_i40e_queue_region_op op_type;
+
+	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
+		return;
+
+	memset(&rte_pmd_regions, 0, sizeof(rte_pmd_regions));
+
+	op_type = RTE_PMD_I40E_RSS_QUEUE_REGION_INFO_GET;
+
+	ret = rte_pmd_i40e_rss_queue_region_conf(res->port_id,
+					op_type, &rte_pmd_regions);
+
+	port_queue_region_info_display(res->port_id, &rte_pmd_regions);
+	switch (ret) {
+	case 0:
+		break;
+	case -ENOTSUP:
+		fprintf(stderr, "function not implemented or supported\n");
+		break;
+	default:
+		fprintf(stderr, "queue region config info show error: (%s)\n",
+			strerror(-ret));
+	}
+}
+
+static cmdline_parse_token_string_t cmd_show_queue_region_info_get =
+TOKEN_STRING_INITIALIZER(struct cmd_show_queue_region_info,
+				show, "show");
+static cmdline_parse_token_string_t cmd_show_queue_region_info_port =
+	TOKEN_STRING_INITIALIZER(struct cmd_show_queue_region_info,
+				port, "port");
+static cmdline_parse_token_num_t cmd_show_queue_region_info_port_index =
+	TOKEN_NUM_INITIALIZER(struct cmd_show_queue_region_info,
+				port_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_show_queue_region_info_cmd =
+	TOKEN_STRING_INITIALIZER(struct cmd_show_queue_region_info,
+				cmd, "queue-region");
+
+static cmdline_parse_inst_t cmd_show_queue_region_info_all = {
+	.f = cmd_show_queue_region_info_parsed,
+	.data = NULL,
+	.help_str = "show port <port_id> queue-region"
+		": show all queue region related configuration info",
+	.tokens = {
+		(void *)&cmd_show_queue_region_info_get,
+		(void *)&cmd_show_queue_region_info_port,
+		(void *)&cmd_show_queue_region_info_port_index,
+		(void *)&cmd_show_queue_region_info_cmd,
+		NULL,
+	},
+};
+
+static uint16_t
+str2flowtype(char *string)
+{
+	uint8_t i = 0;
+	static const struct {
+		char str[32];
+		uint16_t type;
+	} flowtype_str[] = {
+		{"raw", RTE_ETH_FLOW_RAW},
+		{"ipv4", RTE_ETH_FLOW_IPV4},
+		{"ipv4-frag", RTE_ETH_FLOW_FRAG_IPV4},
+		{"ipv4-tcp", RTE_ETH_FLOW_NONFRAG_IPV4_TCP},
+		{"ipv4-udp", RTE_ETH_FLOW_NONFRAG_IPV4_UDP},
+		{"ipv4-sctp", RTE_ETH_FLOW_NONFRAG_IPV4_SCTP},
+		{"ipv4-other", RTE_ETH_FLOW_NONFRAG_IPV4_OTHER},
+		{"ipv6", RTE_ETH_FLOW_IPV6},
+		{"ipv6-frag", RTE_ETH_FLOW_FRAG_IPV6},
+		{"ipv6-tcp", RTE_ETH_FLOW_NONFRAG_IPV6_TCP},
+		{"ipv6-udp", RTE_ETH_FLOW_NONFRAG_IPV6_UDP},
+		{"ipv6-sctp", RTE_ETH_FLOW_NONFRAG_IPV6_SCTP},
+		{"ipv6-other", RTE_ETH_FLOW_NONFRAG_IPV6_OTHER},
+		{"l2_payload", RTE_ETH_FLOW_L2_PAYLOAD},
+		{"ipv6-ex", RTE_ETH_FLOW_IPV6_EX},
+		{"ipv6-tcp-ex", RTE_ETH_FLOW_IPV6_TCP_EX},
+		{"ipv6-udp-ex", RTE_ETH_FLOW_IPV6_UDP_EX},
+		{"gtpu", RTE_ETH_FLOW_GTPU},
+	};
+
+	for (i = 0; i < RTE_DIM(flowtype_str); i++) {
+		if (!strcmp(flowtype_str[i].str, string))
+			return flowtype_str[i].type;
+	}
+
+	if (isdigit(string[0]) && atoi(string) > 0 && atoi(string) < 64)
+		return (uint16_t)atoi(string);
+
+	return RTE_ETH_FLOW_UNKNOWN;
+}
+
+/* *** deal with flow director filter *** */
+struct cmd_flow_director_result {
+	cmdline_fixed_string_t flow_director_filter;
+	portid_t port_id;
+	cmdline_fixed_string_t mode;
+	cmdline_fixed_string_t mode_value;
+	cmdline_fixed_string_t ops;
+	cmdline_fixed_string_t flow;
+	cmdline_fixed_string_t flow_type;
+	cmdline_fixed_string_t drop;
+	cmdline_fixed_string_t queue;
+	uint16_t  queue_id;
+	cmdline_fixed_string_t fd_id;
+	uint32_t  fd_id_value;
+	cmdline_fixed_string_t packet;
+	char filepath[];
+};
+
+static void
+cmd_flow_director_filter_parsed(void *parsed_result,
+			  __rte_unused struct cmdline *cl,
+			  __rte_unused void *data)
+{
+	struct cmd_flow_director_result *res = parsed_result;
+	int ret = 0;
+	struct rte_pmd_i40e_flow_type_mapping
+			mapping[RTE_PMD_I40E_FLOW_TYPE_MAX];
+	struct rte_pmd_i40e_pkt_template_conf conf;
+	uint16_t flow_type = str2flowtype(res->flow_type);
+	uint16_t i, port = res->port_id;
+	uint8_t add;
+
+	memset(&conf, 0, sizeof(conf));
+
+	if (flow_type == RTE_ETH_FLOW_UNKNOWN) {
+		fprintf(stderr, "Invalid flow type specified.\n");
+		return;
+	}
+	ret = rte_pmd_i40e_flow_type_mapping_get(res->port_id,
+						 mapping);
+	if (ret)
+		return;
+	if (mapping[flow_type].pctype == 0ULL) {
+		fprintf(stderr, "Invalid flow type specified.\n");
+		return;
+	}
+	for (i = 0; i < RTE_PMD_I40E_PCTYPE_MAX; i++) {
+		if (mapping[flow_type].pctype & (1ULL << i)) {
+			conf.input.pctype = i;
+			break;
+		}
+	}
+
+	conf.input.packet = open_file(res->filepath,
+				&conf.input.length);
+	if (!conf.input.packet)
+		return;
+	if (!strcmp(res->drop, "drop"))
+		conf.action.behavior =
+			RTE_PMD_I40E_PKT_TEMPLATE_REJECT;
+	else
+		conf.action.behavior =
+			RTE_PMD_I40E_PKT_TEMPLATE_ACCEPT;
+	conf.action.report_status =
+			RTE_PMD_I40E_PKT_TEMPLATE_REPORT_ID;
+	conf.action.rx_queue = res->queue_id;
+	conf.soft_id = res->fd_id_value;
+	add  = strcmp(res->ops, "del") ? 1 : 0;
+	ret = rte_pmd_i40e_flow_add_del_packet_template(port,
+							&conf,
+							add);
+	if (ret < 0)
+		fprintf(stderr, "flow director config error: (%s)\n",
+			strerror(-ret));
+	close_file(conf.input.packet);
+}
+
+static cmdline_parse_token_string_t cmd_flow_director_filter =
+	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
+				 flow_director_filter, "flow_director_filter");
+static cmdline_parse_token_num_t cmd_flow_director_port_id =
+	TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
+			      port_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_flow_director_ops =
+	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
+				 ops, "add#del#update");
+static cmdline_parse_token_string_t cmd_flow_director_flow =
+	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
+				 flow, "flow");
+static cmdline_parse_token_string_t cmd_flow_director_flow_type =
+	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
+		flow_type, NULL);
+static cmdline_parse_token_string_t cmd_flow_director_drop =
+	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
+				 drop, "drop#fwd");
+static cmdline_parse_token_string_t cmd_flow_director_queue =
+	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
+				 queue, "queue");
+static cmdline_parse_token_num_t cmd_flow_director_queue_id =
+	TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
+			      queue_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_flow_director_fd_id =
+	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
+				 fd_id, "fd_id");
+static cmdline_parse_token_num_t cmd_flow_director_fd_id_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
+			      fd_id_value, RTE_UINT32);
+
+static cmdline_parse_token_string_t cmd_flow_director_mode =
+	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
+				 mode, "mode");
+static cmdline_parse_token_string_t cmd_flow_director_mode_raw =
+	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
+				 mode_value, "raw");
+static cmdline_parse_token_string_t cmd_flow_director_packet =
+	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
+				 packet, "packet");
+static cmdline_parse_token_string_t cmd_flow_director_filepath =
+	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
+				 filepath, NULL);
+
+static cmdline_parse_inst_t cmd_add_del_raw_flow_director = {
+	.f = cmd_flow_director_filter_parsed,
+	.data = NULL,
+	.help_str = "flow_director_filter ... : Add or delete a raw flow "
+		"director entry on NIC",
+	.tokens = {
+		(void *)&cmd_flow_director_filter,
+		(void *)&cmd_flow_director_port_id,
+		(void *)&cmd_flow_director_mode,
+		(void *)&cmd_flow_director_mode_raw,
+		(void *)&cmd_flow_director_ops,
+		(void *)&cmd_flow_director_flow,
+		(void *)&cmd_flow_director_flow_type,
+		(void *)&cmd_flow_director_drop,
+		(void *)&cmd_flow_director_queue,
+		(void *)&cmd_flow_director_queue_id,
+		(void *)&cmd_flow_director_fd_id,
+		(void *)&cmd_flow_director_fd_id_value,
+		(void *)&cmd_flow_director_packet,
+		(void *)&cmd_flow_director_filepath,
+		NULL,
+	},
+};
+
+/* VF unicast promiscuous mode configuration */
+
+/* Common result structure for VF unicast promiscuous mode */
+struct cmd_vf_promisc_result {
+	cmdline_fixed_string_t set;
+	cmdline_fixed_string_t vf;
+	cmdline_fixed_string_t promisc;
+	portid_t port_id;
+	uint32_t vf_id;
+	cmdline_fixed_string_t on_off;
+};
+
+/* Common CLI fields for VF unicast promiscuous mode enable disable */
+static cmdline_parse_token_string_t cmd_vf_promisc_set =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_vf_promisc_result,
+		 set, "set");
+static cmdline_parse_token_string_t cmd_vf_promisc_vf =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_vf_promisc_result,
+		 vf, "vf");
+static cmdline_parse_token_string_t cmd_vf_promisc_promisc =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_vf_promisc_result,
+		 promisc, "promisc");
+static cmdline_parse_token_num_t cmd_vf_promisc_port_id =
+	TOKEN_NUM_INITIALIZER
+		(struct cmd_vf_promisc_result,
+		 port_id, RTE_UINT16);
+static cmdline_parse_token_num_t cmd_vf_promisc_vf_id =
+	TOKEN_NUM_INITIALIZER
+		(struct cmd_vf_promisc_result,
+		 vf_id, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_vf_promisc_on_off =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_vf_promisc_result,
+		 on_off, "on#off");
+
+static void
+cmd_set_vf_promisc_parsed(void *parsed_result,
+	__rte_unused struct cmdline *cl,
+	__rte_unused void *data)
+{
+	struct cmd_vf_promisc_result *res = parsed_result;
+	int ret = -ENOTSUP;
+
+	__rte_unused int is_on = (strcmp(res->on_off, "on") == 0) ? 1 : 0;
+
+	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
+		return;
+
+	ret = rte_pmd_i40e_set_vf_unicast_promisc(res->port_id,
+						  res->vf_id, is_on);
+	switch (ret) {
+	case 0:
+		break;
+	case -EINVAL:
+		fprintf(stderr, "invalid vf_id %d\n", res->vf_id);
+		break;
+	case -ENODEV:
+		fprintf(stderr, "invalid port_id %d\n", res->port_id);
+		break;
+	case -ENOTSUP:
+		fprintf(stderr, "function not implemented\n");
+		break;
+	default:
+		fprintf(stderr, "programming error: (%s)\n", strerror(-ret));
+	}
+}
+
+static cmdline_parse_inst_t cmd_set_vf_promisc = {
+	.f = cmd_set_vf_promisc_parsed,
+	.data = NULL,
+	.help_str = "set vf promisc <port_id> <vf_id> on|off: "
+		"Set unicast promiscuous mode for a VF from the PF",
+	.tokens = {
+		(void *)&cmd_vf_promisc_set,
+		(void *)&cmd_vf_promisc_vf,
+		(void *)&cmd_vf_promisc_promisc,
+		(void *)&cmd_vf_promisc_port_id,
+		(void *)&cmd_vf_promisc_vf_id,
+		(void *)&cmd_vf_promisc_on_off,
+		NULL,
+	},
+};
+
+/* VF multicast promiscuous mode configuration */
+
+/* Common result structure for VF multicast promiscuous mode */
+struct cmd_vf_allmulti_result {
+	cmdline_fixed_string_t set;
+	cmdline_fixed_string_t vf;
+	cmdline_fixed_string_t allmulti;
+	portid_t port_id;
+	uint32_t vf_id;
+	cmdline_fixed_string_t on_off;
+};
+
+/* Common CLI fields for VF multicast promiscuous mode enable disable */
+static cmdline_parse_token_string_t cmd_vf_allmulti_set =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_vf_allmulti_result,
+		 set, "set");
+static cmdline_parse_token_string_t cmd_vf_allmulti_vf =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_vf_allmulti_result,
+		 vf, "vf");
+static cmdline_parse_token_string_t cmd_vf_allmulti_allmulti =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_vf_allmulti_result,
+		 allmulti, "allmulti");
+static cmdline_parse_token_num_t cmd_vf_allmulti_port_id =
+	TOKEN_NUM_INITIALIZER
+		(struct cmd_vf_allmulti_result,
+		 port_id, RTE_UINT16);
+static cmdline_parse_token_num_t cmd_vf_allmulti_vf_id =
+	TOKEN_NUM_INITIALIZER
+		(struct cmd_vf_allmulti_result,
+		 vf_id, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_vf_allmulti_on_off =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_vf_allmulti_result,
+		 on_off, "on#off");
+
+static void
+cmd_set_vf_allmulti_parsed(void *parsed_result,
+	__rte_unused struct cmdline *cl,
+	__rte_unused void *data)
+{
+	struct cmd_vf_allmulti_result *res = parsed_result;
+	int ret = -ENOTSUP;
+
+	__rte_unused int is_on = (strcmp(res->on_off, "on") == 0) ? 1 : 0;
+
+	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
+		return;
+
+	ret = rte_pmd_i40e_set_vf_multicast_promisc(res->port_id,
+						    res->vf_id, is_on);
+	switch (ret) {
+	case 0:
+		break;
+	case -EINVAL:
+		fprintf(stderr, "invalid vf_id %d\n", res->vf_id);
+		break;
+	case -ENODEV:
+		fprintf(stderr, "invalid port_id %d\n", res->port_id);
+		break;
+	case -ENOTSUP:
+		fprintf(stderr, "function not implemented\n");
+		break;
+	default:
+		fprintf(stderr, "programming error: (%s)\n", strerror(-ret));
+	}
+}
+
+static cmdline_parse_inst_t cmd_set_vf_allmulti = {
+	.f = cmd_set_vf_allmulti_parsed,
+	.data = NULL,
+	.help_str = "set vf allmulti <port_id> <vf_id> on|off: "
+		"Set multicast promiscuous mode for a VF from the PF",
+	.tokens = {
+		(void *)&cmd_vf_allmulti_set,
+		(void *)&cmd_vf_allmulti_vf,
+		(void *)&cmd_vf_allmulti_allmulti,
+		(void *)&cmd_vf_allmulti_port_id,
+		(void *)&cmd_vf_allmulti_vf_id,
+		(void *)&cmd_vf_allmulti_on_off,
+		NULL,
+	},
+};
+
+/* vf broadcast mode configuration */
+
+/* Common result structure for vf broadcast */
+struct cmd_set_vf_broadcast_result {
+	cmdline_fixed_string_t set;
+	cmdline_fixed_string_t vf;
+	cmdline_fixed_string_t broadcast;
+	portid_t port_id;
+	uint16_t vf_id;
+	cmdline_fixed_string_t on_off;
+};
+
+/* Common CLI fields for vf broadcast enable disable */
+static cmdline_parse_token_string_t cmd_set_vf_broadcast_set =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_set_vf_broadcast_result,
+		 set, "set");
+static cmdline_parse_token_string_t cmd_set_vf_broadcast_vf =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_set_vf_broadcast_result,
+		 vf, "vf");
+static cmdline_parse_token_string_t cmd_set_vf_broadcast_broadcast =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_set_vf_broadcast_result,
+		 broadcast, "broadcast");
+static cmdline_parse_token_num_t cmd_set_vf_broadcast_port_id =
+	TOKEN_NUM_INITIALIZER
+		(struct cmd_set_vf_broadcast_result,
+		 port_id, RTE_UINT16);
+static cmdline_parse_token_num_t cmd_set_vf_broadcast_vf_id =
+	TOKEN_NUM_INITIALIZER
+		(struct cmd_set_vf_broadcast_result,
+		 vf_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_set_vf_broadcast_on_off =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_set_vf_broadcast_result,
+		 on_off, "on#off");
+
+static void
+cmd_set_vf_broadcast_parsed(void *parsed_result,
+	__rte_unused struct cmdline *cl,
+	__rte_unused void *data)
+{
+	struct cmd_set_vf_broadcast_result *res = parsed_result;
+	int ret = -ENOTSUP;
+
+	__rte_unused int is_on = (strcmp(res->on_off, "on") == 0) ? 1 : 0;
+
+	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
+		return;
+
+	ret = rte_pmd_i40e_set_vf_broadcast(res->port_id,
+					    res->vf_id, is_on);
+	switch (ret) {
+	case 0:
+		break;
+	case -EINVAL:
+		fprintf(stderr, "invalid vf_id %d or is_on %d\n",
+			res->vf_id, is_on);
+		break;
+	case -ENODEV:
+		fprintf(stderr, "invalid port_id %d\n", res->port_id);
+		break;
+	case -ENOTSUP:
+		fprintf(stderr, "function not implemented\n");
+		break;
+	default:
+		fprintf(stderr, "programming error: (%s)\n", strerror(-ret));
+	}
+}
+
+static cmdline_parse_inst_t cmd_set_vf_broadcast = {
+	.f = cmd_set_vf_broadcast_parsed,
+	.data = NULL,
+	.help_str = "set vf broadcast <port_id> <vf_id> on|off",
+	.tokens = {
+		(void *)&cmd_set_vf_broadcast_set,
+		(void *)&cmd_set_vf_broadcast_vf,
+		(void *)&cmd_set_vf_broadcast_broadcast,
+		(void *)&cmd_set_vf_broadcast_port_id,
+		(void *)&cmd_set_vf_broadcast_vf_id,
+		(void *)&cmd_set_vf_broadcast_on_off,
+		NULL,
+	},
+};
+
+/* vf vlan tag configuration */
+
+/* Common result structure for vf vlan tag */
+struct cmd_set_vf_vlan_tag_result {
+	cmdline_fixed_string_t set;
+	cmdline_fixed_string_t vf;
+	cmdline_fixed_string_t vlan;
+	cmdline_fixed_string_t tag;
+	portid_t port_id;
+	uint16_t vf_id;
+	cmdline_fixed_string_t on_off;
+};
+
+/* Common CLI fields for vf vlan tag enable disable */
+static cmdline_parse_token_string_t cmd_set_vf_vlan_tag_set =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_set_vf_vlan_tag_result,
+		 set, "set");
+static cmdline_parse_token_string_t cmd_set_vf_vlan_tag_vf =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_set_vf_vlan_tag_result,
+		 vf, "vf");
+static cmdline_parse_token_string_t cmd_set_vf_vlan_tag_vlan =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_set_vf_vlan_tag_result,
+		 vlan, "vlan");
+static cmdline_parse_token_string_t cmd_set_vf_vlan_tag_tag =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_set_vf_vlan_tag_result,
+		 tag, "tag");
+static cmdline_parse_token_num_t cmd_set_vf_vlan_tag_port_id =
+	TOKEN_NUM_INITIALIZER
+		(struct cmd_set_vf_vlan_tag_result,
+		 port_id, RTE_UINT16);
+static cmdline_parse_token_num_t cmd_set_vf_vlan_tag_vf_id =
+	TOKEN_NUM_INITIALIZER
+		(struct cmd_set_vf_vlan_tag_result,
+		 vf_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_set_vf_vlan_tag_on_off =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_set_vf_vlan_tag_result,
+		 on_off, "on#off");
+
+static void
+cmd_set_vf_vlan_tag_parsed(void *parsed_result,
+	__rte_unused struct cmdline *cl,
+	__rte_unused void *data)
+{
+	struct cmd_set_vf_vlan_tag_result *res = parsed_result;
+	int ret = -ENOTSUP;
+
+	__rte_unused int is_on = (strcmp(res->on_off, "on") == 0) ? 1 : 0;
+
+	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
+		return;
+
+	ret = rte_pmd_i40e_set_vf_vlan_tag(res->port_id,
+					   res->vf_id, is_on);
+	switch (ret) {
+	case 0:
+		break;
+	case -EINVAL:
+		fprintf(stderr, "invalid vf_id %d or is_on %d\n",
+			res->vf_id, is_on);
+		break;
+	case -ENODEV:
+		fprintf(stderr, "invalid port_id %d\n", res->port_id);
+		break;
+	case -ENOTSUP:
+		fprintf(stderr, "function not implemented\n");
+		break;
+	default:
+		fprintf(stderr, "programming error: (%s)\n", strerror(-ret));
+	}
+}
+
+static cmdline_parse_inst_t cmd_set_vf_vlan_tag = {
+	.f = cmd_set_vf_vlan_tag_parsed,
+	.data = NULL,
+	.help_str = "set vf vlan tag <port_id> <vf_id> on|off",
+	.tokens = {
+		(void *)&cmd_set_vf_vlan_tag_set,
+		(void *)&cmd_set_vf_vlan_tag_vf,
+		(void *)&cmd_set_vf_vlan_tag_vlan,
+		(void *)&cmd_set_vf_vlan_tag_tag,
+		(void *)&cmd_set_vf_vlan_tag_port_id,
+		(void *)&cmd_set_vf_vlan_tag_vf_id,
+		(void *)&cmd_set_vf_vlan_tag_on_off,
+		NULL,
+	},
+};
+
+/* Common definition of VF and TC TX bandwidth configuration */
+struct cmd_vf_tc_bw_result {
+	cmdline_fixed_string_t set;
+	cmdline_fixed_string_t vf;
+	cmdline_fixed_string_t tc;
+	cmdline_fixed_string_t tx;
+	cmdline_fixed_string_t max_bw;
+	cmdline_fixed_string_t min_bw;
+	cmdline_fixed_string_t strict_link_prio;
+	portid_t port_id;
+	uint16_t vf_id;
+	uint8_t tc_no;
+	uint32_t bw;
+	cmdline_fixed_string_t bw_list;
+	uint8_t tc_map;
+};
+
+static cmdline_parse_token_string_t cmd_vf_tc_bw_set =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_vf_tc_bw_result,
+		 set, "set");
+static cmdline_parse_token_string_t cmd_vf_tc_bw_tc =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_vf_tc_bw_result,
+		 tc, "tc");
+static cmdline_parse_token_string_t cmd_vf_tc_bw_tx =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_vf_tc_bw_result,
+		 tx, "tx");
+static cmdline_parse_token_string_t cmd_vf_tc_bw_strict_link_prio =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_vf_tc_bw_result,
+		 strict_link_prio, "strict-link-priority");
+static cmdline_parse_token_string_t cmd_vf_tc_bw_max_bw =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_vf_tc_bw_result,
+		 max_bw, "max-bandwidth");
+static cmdline_parse_token_string_t cmd_vf_tc_bw_min_bw =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_vf_tc_bw_result,
+		 min_bw, "min-bandwidth");
+static cmdline_parse_token_num_t cmd_vf_tc_bw_port_id =
+	TOKEN_NUM_INITIALIZER
+		(struct cmd_vf_tc_bw_result,
+		 port_id, RTE_UINT16);
+static cmdline_parse_token_num_t cmd_vf_tc_bw_vf_id =
+	TOKEN_NUM_INITIALIZER
+		(struct cmd_vf_tc_bw_result,
+		 vf_id, RTE_UINT16);
+static cmdline_parse_token_num_t cmd_vf_tc_bw_tc_no =
+	TOKEN_NUM_INITIALIZER
+		(struct cmd_vf_tc_bw_result,
+		 tc_no, RTE_UINT8);
+static cmdline_parse_token_num_t cmd_vf_tc_bw_bw =
+	TOKEN_NUM_INITIALIZER
+		(struct cmd_vf_tc_bw_result,
+		 bw, RTE_UINT32);
+static cmdline_parse_token_string_t cmd_vf_tc_bw_bw_list =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_vf_tc_bw_result,
+		 bw_list, NULL);
+static cmdline_parse_token_num_t cmd_vf_tc_bw_tc_map =
+	TOKEN_NUM_INITIALIZER
+		(struct cmd_vf_tc_bw_result,
+		 tc_map, RTE_UINT8);
+static cmdline_parse_token_string_t cmd_vf_tc_bw_vf =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_vf_tc_bw_result,
+		 vf, "vf");
+
+/* VF max bandwidth setting */
+static void
+cmd_vf_max_bw_parsed(void *parsed_result,
+	__rte_unused struct cmdline *cl,
+	__rte_unused void *data)
+{
+	struct cmd_vf_tc_bw_result *res = parsed_result;
+	int ret = -ENOTSUP;
+
+	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
+		return;
+
+	ret = rte_pmd_i40e_set_vf_max_bw(res->port_id,
+					 res->vf_id, res->bw);
+	switch (ret) {
+	case 0:
+		break;
+	case -EINVAL:
+		fprintf(stderr, "invalid vf_id %d or bandwidth %d\n",
+			res->vf_id, res->bw);
+		break;
+	case -ENODEV:
+		fprintf(stderr, "invalid port_id %d\n", res->port_id);
+		break;
+	case -ENOTSUP:
+		fprintf(stderr, "function not implemented\n");
+		break;
+	default:
+		fprintf(stderr, "programming error: (%s)\n", strerror(-ret));
+	}
+}
+
+static cmdline_parse_inst_t cmd_vf_max_bw = {
+	.f = cmd_vf_max_bw_parsed,
+	.data = NULL,
+	.help_str = "set vf tx max-bandwidth <port_id> <vf_id> <bandwidth>",
+	.tokens = {
+		(void *)&cmd_vf_tc_bw_set,
+		(void *)&cmd_vf_tc_bw_vf,
+		(void *)&cmd_vf_tc_bw_tx,
+		(void *)&cmd_vf_tc_bw_max_bw,
+		(void *)&cmd_vf_tc_bw_port_id,
+		(void *)&cmd_vf_tc_bw_vf_id,
+		(void *)&cmd_vf_tc_bw_bw,
+		NULL,
+	},
+};
+
+static int
+vf_tc_min_bw_parse_bw_list(uint8_t *bw_list,
+			   uint8_t *tc_num,
+			   char *str)
+{
+	uint32_t size;
+	const char *p, *p0 = str;
+	char s[256];
+	char *end;
+	char *str_fld[16];
+	uint16_t i;
+	int ret;
+
+	p = strchr(p0, '(');
+	if (p == NULL) {
+		fprintf(stderr,
+			"The bandwidth-list should be '(bw1, bw2, ...)'\n");
+		return -1;
+	}
+	p++;
+	p0 = strchr(p, ')');
+	if (p0 == NULL) {
+		fprintf(stderr,
+			"The bandwidth-list should be '(bw1, bw2, ...)'\n");
+		return -1;
+	}
+	size = p0 - p;
+	if (size >= sizeof(s)) {
+		fprintf(stderr,
+			"The string size exceeds the internal buffer size\n");
+		return -1;
+	}
+	snprintf(s, sizeof(s), "%.*s", size, p);
+	ret = rte_strsplit(s, sizeof(s), str_fld, 16, ',');
+	if (ret <= 0) {
+		fprintf(stderr, "Failed to get the bandwidth list.\n");
+		return -1;
+	}
+	*tc_num = ret;
+	for (i = 0; i < ret; i++)
+		bw_list[i] = (uint8_t)strtoul(str_fld[i], &end, 0);
+
+	return 0;
+}
+
+/* TC min bandwidth setting */
+static void
+cmd_vf_tc_min_bw_parsed(void *parsed_result,
+	__rte_unused struct cmdline *cl,
+	__rte_unused void *data)
+{
+	struct cmd_vf_tc_bw_result *res = parsed_result;
+	uint8_t tc_num;
+	uint8_t bw[16];
+	int ret = -ENOTSUP;
+
+	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
+		return;
+
+	ret = vf_tc_min_bw_parse_bw_list(bw, &tc_num, res->bw_list);
+	if (ret)
+		return;
+
+	ret = rte_pmd_i40e_set_vf_tc_bw_alloc(res->port_id, res->vf_id,
+					      tc_num, bw);
+	switch (ret) {
+	case 0:
+		break;
+	case -EINVAL:
+		fprintf(stderr, "invalid vf_id %d or bandwidth\n", res->vf_id);
+		break;
+	case -ENODEV:
+		fprintf(stderr, "invalid port_id %d\n", res->port_id);
+		break;
+	case -ENOTSUP:
+		fprintf(stderr, "function not implemented\n");
+		break;
+	default:
+		fprintf(stderr, "programming error: (%s)\n", strerror(-ret));
+	}
+}
+
+static cmdline_parse_inst_t cmd_vf_tc_min_bw = {
+	.f = cmd_vf_tc_min_bw_parsed,
+	.data = NULL,
+	.help_str = "set vf tc tx min-bandwidth <port_id> <vf_id>"
+		    " <bw1, bw2, ...>",
+	.tokens = {
+		(void *)&cmd_vf_tc_bw_set,
+		(void *)&cmd_vf_tc_bw_vf,
+		(void *)&cmd_vf_tc_bw_tc,
+		(void *)&cmd_vf_tc_bw_tx,
+		(void *)&cmd_vf_tc_bw_min_bw,
+		(void *)&cmd_vf_tc_bw_port_id,
+		(void *)&cmd_vf_tc_bw_vf_id,
+		(void *)&cmd_vf_tc_bw_bw_list,
+		NULL,
+	},
+};
+
+/* TC max bandwidth setting */
+static void
+cmd_vf_tc_max_bw_parsed(void *parsed_result,
+	__rte_unused struct cmdline *cl,
+	__rte_unused void *data)
+{
+	struct cmd_vf_tc_bw_result *res = parsed_result;
+	int ret = -ENOTSUP;
+
+	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
+		return;
+
+	ret = rte_pmd_i40e_set_vf_tc_max_bw(res->port_id, res->vf_id,
+					    res->tc_no, res->bw);
+	switch (ret) {
+	case 0:
+		break;
+	case -EINVAL:
+		fprintf(stderr,
+			"invalid vf_id %d, tc_no %d or bandwidth %d\n",
+			res->vf_id, res->tc_no, res->bw);
+		break;
+	case -ENODEV:
+		fprintf(stderr, "invalid port_id %d\n", res->port_id);
+		break;
+	case -ENOTSUP:
+		fprintf(stderr, "function not implemented\n");
+		break;
+	default:
+		fprintf(stderr, "programming error: (%s)\n", strerror(-ret));
+	}
+}
+
+static cmdline_parse_inst_t cmd_vf_tc_max_bw = {
+	.f = cmd_vf_tc_max_bw_parsed,
+	.data = NULL,
+	.help_str = "set vf tc tx max-bandwidth <port_id> <vf_id> <tc_no>"
+		    " <bandwidth>",
+	.tokens = {
+		(void *)&cmd_vf_tc_bw_set,
+		(void *)&cmd_vf_tc_bw_vf,
+		(void *)&cmd_vf_tc_bw_tc,
+		(void *)&cmd_vf_tc_bw_tx,
+		(void *)&cmd_vf_tc_bw_max_bw,
+		(void *)&cmd_vf_tc_bw_port_id,
+		(void *)&cmd_vf_tc_bw_vf_id,
+		(void *)&cmd_vf_tc_bw_tc_no,
+		(void *)&cmd_vf_tc_bw_bw,
+		NULL,
+	},
+};
+
+/* Strict link priority scheduling mode setting */
+static void
+cmd_strict_link_prio_parsed(void *parsed_result,
+	__rte_unused struct cmdline *cl,
+	__rte_unused void *data)
+{
+	struct cmd_vf_tc_bw_result *res = parsed_result;
+	int ret = -ENOTSUP;
+
+	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
+		return;
+
+	ret = rte_pmd_i40e_set_tc_strict_prio(res->port_id, res->tc_map);
+	switch (ret) {
+	case 0:
+		break;
+	case -EINVAL:
+		fprintf(stderr, "invalid tc_bitmap 0x%x\n", res->tc_map);
+		break;
+	case -ENODEV:
+		fprintf(stderr, "invalid port_id %d\n", res->port_id);
+		break;
+	case -ENOTSUP:
+		fprintf(stderr, "function not implemented\n");
+		break;
+	default:
+		fprintf(stderr, "programming error: (%s)\n", strerror(-ret));
+	}
+}
+
+static cmdline_parse_inst_t cmd_strict_link_prio = {
+	.f = cmd_strict_link_prio_parsed,
+	.data = NULL,
+	.help_str = "set tx strict-link-priority <port_id> <tc_bitmap>",
+	.tokens = {
+		(void *)&cmd_vf_tc_bw_set,
+		(void *)&cmd_vf_tc_bw_tx,
+		(void *)&cmd_vf_tc_bw_strict_link_prio,
+		(void *)&cmd_vf_tc_bw_port_id,
+		(void *)&cmd_vf_tc_bw_tc_map,
+		NULL,
+	},
+};
+
+/* Load dynamic device personalization*/
+struct cmd_ddp_add_result {
+	cmdline_fixed_string_t ddp;
+	cmdline_fixed_string_t add;
+	portid_t port_id;
+	char filepath[];
+};
+
+static cmdline_parse_token_string_t cmd_ddp_add_ddp =
+	TOKEN_STRING_INITIALIZER(struct cmd_ddp_add_result, ddp, "ddp");
+static cmdline_parse_token_string_t cmd_ddp_add_add =
+	TOKEN_STRING_INITIALIZER(struct cmd_ddp_add_result, add, "add");
+static cmdline_parse_token_num_t cmd_ddp_add_port_id =
+	TOKEN_NUM_INITIALIZER(struct cmd_ddp_add_result, port_id,
+		RTE_UINT16);
+static cmdline_parse_token_string_t cmd_ddp_add_filepath =
+	TOKEN_STRING_INITIALIZER(struct cmd_ddp_add_result, filepath, NULL);
+
+static void
+cmd_ddp_add_parsed(void *parsed_result,
+	__rte_unused struct cmdline *cl,
+	__rte_unused void *data)
+{
+	struct cmd_ddp_add_result *res = parsed_result;
+	uint8_t *buff;
+	uint32_t size;
+	char *filepath;
+	char *file_fld[2];
+	int file_num;
+	int ret = -ENOTSUP;
+
+	if (!all_ports_stopped()) {
+		fprintf(stderr, "Please stop all ports first\n");
+		return;
+	}
+
+	filepath = strdup(res->filepath);
+	if (filepath == NULL) {
+		fprintf(stderr, "Failed to allocate memory\n");
+		return;
+	}
+	file_num = rte_strsplit(filepath, strlen(filepath), file_fld, 2, ',');
+
+	buff = open_file(file_fld[0], &size);
+	if (!buff) {
+		free((void *)filepath);
+		return;
+	}
+
+	if (ret == -ENOTSUP)
+		ret = rte_pmd_i40e_process_ddp_package(res->port_id,
+					       buff, size,
+					       RTE_PMD_I40E_PKG_OP_WR_ADD);
+	if (ret == -EEXIST)
+		fprintf(stderr, "Profile has already existed.\n");
+	else if (ret < 0)
+		fprintf(stderr, "Failed to load profile.\n");
+	else if (file_num == 2)
+		save_file(file_fld[1], buff, size);
+
+	close_file(buff);
+	free((void *)filepath);
+}
+
+static cmdline_parse_inst_t cmd_ddp_add = {
+	.f = cmd_ddp_add_parsed,
+	.data = NULL,
+	.help_str = "ddp add <port_id> <profile_path[,backup_profile_path]>",
+	.tokens = {
+		(void *)&cmd_ddp_add_ddp,
+		(void *)&cmd_ddp_add_add,
+		(void *)&cmd_ddp_add_port_id,
+		(void *)&cmd_ddp_add_filepath,
+		NULL,
+	},
+};
+
+/* Delete dynamic device personalization*/
+struct cmd_ddp_del_result {
+	cmdline_fixed_string_t ddp;
+	cmdline_fixed_string_t del;
+	portid_t port_id;
+	char filepath[];
+};
+
+static cmdline_parse_token_string_t cmd_ddp_del_ddp =
+	TOKEN_STRING_INITIALIZER(struct cmd_ddp_del_result, ddp, "ddp");
+static cmdline_parse_token_string_t cmd_ddp_del_del =
+	TOKEN_STRING_INITIALIZER(struct cmd_ddp_del_result, del, "del");
+static cmdline_parse_token_num_t cmd_ddp_del_port_id =
+	TOKEN_NUM_INITIALIZER(struct cmd_ddp_del_result, port_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_ddp_del_filepath =
+	TOKEN_STRING_INITIALIZER(struct cmd_ddp_del_result, filepath, NULL);
+
+static void
+cmd_ddp_del_parsed(void *parsed_result,
+	__rte_unused struct cmdline *cl,
+	__rte_unused void *data)
+{
+	struct cmd_ddp_del_result *res = parsed_result;
+	uint8_t *buff;
+	uint32_t size;
+	int ret = -ENOTSUP;
+
+	if (!all_ports_stopped()) {
+		fprintf(stderr, "Please stop all ports first\n");
+		return;
+	}
+
+	buff = open_file(res->filepath, &size);
+	if (!buff)
+		return;
+
+	if (ret == -ENOTSUP)
+		ret = rte_pmd_i40e_process_ddp_package(res->port_id,
+					       buff, size,
+					       RTE_PMD_I40E_PKG_OP_WR_DEL);
+	if (ret == -EACCES)
+		fprintf(stderr, "Profile does not exist.\n");
+	else if (ret < 0)
+		fprintf(stderr, "Failed to delete profile.\n");
+
+	close_file(buff);
+}
+
+static cmdline_parse_inst_t cmd_ddp_del = {
+	.f = cmd_ddp_del_parsed,
+	.data = NULL,
+	.help_str = "ddp del <port_id> <backup_profile_path>",
+	.tokens = {
+		(void *)&cmd_ddp_del_ddp,
+		(void *)&cmd_ddp_del_del,
+		(void *)&cmd_ddp_del_port_id,
+		(void *)&cmd_ddp_del_filepath,
+		NULL,
+	},
+};
+
+/* Get dynamic device personalization profile info */
+struct cmd_ddp_info_result {
+	cmdline_fixed_string_t ddp;
+	cmdline_fixed_string_t get;
+	cmdline_fixed_string_t info;
+	char filepath[];
+};
+
+static cmdline_parse_token_string_t cmd_ddp_info_ddp =
+	TOKEN_STRING_INITIALIZER(struct cmd_ddp_info_result, ddp, "ddp");
+static cmdline_parse_token_string_t cmd_ddp_info_get =
+	TOKEN_STRING_INITIALIZER(struct cmd_ddp_info_result, get, "get");
+static cmdline_parse_token_string_t cmd_ddp_info_info =
+	TOKEN_STRING_INITIALIZER(struct cmd_ddp_info_result, info, "info");
+static cmdline_parse_token_string_t cmd_ddp_info_filepath =
+	TOKEN_STRING_INITIALIZER(struct cmd_ddp_info_result, filepath, NULL);
+
+static void
+cmd_ddp_info_parsed(void *parsed_result,
+	__rte_unused struct cmdline *cl,
+	__rte_unused void *data)
+{
+	struct cmd_ddp_info_result *res = parsed_result;
+	uint8_t *pkg;
+	uint32_t pkg_size;
+	int ret = -ENOTSUP;
+	uint32_t i, j, n;
+	uint8_t *buff;
+	uint32_t buff_size = 0;
+	struct rte_pmd_i40e_profile_info info;
+	uint32_t dev_num = 0;
+	struct rte_pmd_i40e_ddp_device_id *devs;
+	uint32_t proto_num = 0;
+	struct rte_pmd_i40e_proto_info *proto = NULL;
+	uint32_t pctype_num = 0;
+	struct rte_pmd_i40e_ptype_info *pctype;
+	uint32_t ptype_num = 0;
+	struct rte_pmd_i40e_ptype_info *ptype;
+	uint8_t proto_id;
+
+	pkg = open_file(res->filepath, &pkg_size);
+	if (!pkg)
+		return;
+
+	ret = rte_pmd_i40e_get_ddp_info(pkg, pkg_size,
+				(uint8_t *)&info, sizeof(info),
+				RTE_PMD_I40E_PKG_INFO_GLOBAL_HEADER);
+	if (!ret) {
+		printf("Global Track id:       0x%x\n", info.track_id);
+		printf("Global Version:        %d.%d.%d.%d\n",
+			info.version.major,
+			info.version.minor,
+			info.version.update,
+			info.version.draft);
+		printf("Global Package name:   %s\n\n", info.name);
+	}
+
+	ret = rte_pmd_i40e_get_ddp_info(pkg, pkg_size,
+				(uint8_t *)&info, sizeof(info),
+				RTE_PMD_I40E_PKG_INFO_HEADER);
+	if (!ret) {
+		printf("i40e Profile Track id: 0x%x\n", info.track_id);
+		printf("i40e Profile Version:  %d.%d.%d.%d\n",
+			info.version.major,
+			info.version.minor,
+			info.version.update,
+			info.version.draft);
+		printf("i40e Profile name:     %s\n\n", info.name);
+	}
+
+	ret = rte_pmd_i40e_get_ddp_info(pkg, pkg_size,
+				(uint8_t *)&buff_size, sizeof(buff_size),
+				RTE_PMD_I40E_PKG_INFO_GLOBAL_NOTES_SIZE);
+	if (!ret && buff_size) {
+		buff = (uint8_t *)malloc(buff_size);
+		if (buff) {
+			ret = rte_pmd_i40e_get_ddp_info(pkg, pkg_size,
+						buff, buff_size,
+						RTE_PMD_I40E_PKG_INFO_GLOBAL_NOTES);
+			if (!ret)
+				printf("Package Notes:\n%s\n\n", buff);
+			free(buff);
+		}
+	}
+
+	ret = rte_pmd_i40e_get_ddp_info(pkg, pkg_size,
+				(uint8_t *)&dev_num, sizeof(dev_num),
+				RTE_PMD_I40E_PKG_INFO_DEVID_NUM);
+	if (!ret && dev_num) {
+		buff_size = dev_num * sizeof(struct rte_pmd_i40e_ddp_device_id);
+		devs = (struct rte_pmd_i40e_ddp_device_id *)malloc(buff_size);
+		if (devs) {
+			ret = rte_pmd_i40e_get_ddp_info(pkg, pkg_size,
+						(uint8_t *)devs, buff_size,
+						RTE_PMD_I40E_PKG_INFO_DEVID_LIST);
+			if (!ret) {
+				printf("List of supported devices:\n");
+				for (i = 0; i < dev_num; i++) {
+					printf("  %04X:%04X %04X:%04X\n",
+						devs[i].vendor_dev_id >> 16,
+						devs[i].vendor_dev_id & 0xFFFF,
+						devs[i].sub_vendor_dev_id >> 16,
+						devs[i].sub_vendor_dev_id & 0xFFFF);
+				}
+				printf("\n");
+			}
+			free(devs);
+		}
+	}
+
+	/* get information about protocols and packet types */
+	ret = rte_pmd_i40e_get_ddp_info(pkg, pkg_size,
+		(uint8_t *)&proto_num, sizeof(proto_num),
+		RTE_PMD_I40E_PKG_INFO_PROTOCOL_NUM);
+	if (ret || !proto_num)
+		goto no_print_return;
+
+	buff_size = proto_num * sizeof(struct rte_pmd_i40e_proto_info);
+	proto = (struct rte_pmd_i40e_proto_info *)malloc(buff_size);
+	if (!proto)
+		goto no_print_return;
+
+	ret = rte_pmd_i40e_get_ddp_info(pkg, pkg_size, (uint8_t *)proto,
+					buff_size,
+					RTE_PMD_I40E_PKG_INFO_PROTOCOL_LIST);
+	if (!ret) {
+		printf("List of used protocols:\n");
+		for (i = 0; i < proto_num; i++)
+			printf("  %2u: %s\n", proto[i].proto_id,
+			       proto[i].name);
+		printf("\n");
+	}
+	ret = rte_pmd_i40e_get_ddp_info(pkg, pkg_size,
+		(uint8_t *)&pctype_num, sizeof(pctype_num),
+		RTE_PMD_I40E_PKG_INFO_PCTYPE_NUM);
+	if (ret || !pctype_num)
+		goto no_print_pctypes;
+
+	buff_size = pctype_num * sizeof(struct rte_pmd_i40e_ptype_info);
+	pctype = (struct rte_pmd_i40e_ptype_info *)malloc(buff_size);
+	if (!pctype)
+		goto no_print_pctypes;
+
+	ret = rte_pmd_i40e_get_ddp_info(pkg, pkg_size, (uint8_t *)pctype,
+					buff_size,
+					RTE_PMD_I40E_PKG_INFO_PCTYPE_LIST);
+	if (ret) {
+		free(pctype);
+		goto no_print_pctypes;
+	}
+
+	printf("List of defined packet classification types:\n");
+	for (i = 0; i < pctype_num; i++) {
+		printf("  %2u:", pctype[i].ptype_id);
+		for (j = 0; j < RTE_PMD_I40E_PROTO_NUM; j++) {
+			proto_id = pctype[i].protocols[j];
+			if (proto_id != RTE_PMD_I40E_PROTO_UNUSED) {
+				for (n = 0; n < proto_num; n++) {
+					if (proto[n].proto_id == proto_id) {
+						printf(" %s", proto[n].name);
+						break;
+					}
+				}
+			}
+		}
+		printf("\n");
+	}
+	printf("\n");
+	free(pctype);
+
+no_print_pctypes:
+
+	ret = rte_pmd_i40e_get_ddp_info(pkg, pkg_size, (uint8_t *)&ptype_num,
+					sizeof(ptype_num),
+					RTE_PMD_I40E_PKG_INFO_PTYPE_NUM);
+	if (ret || !ptype_num)
+		goto no_print_return;
+
+	buff_size = ptype_num * sizeof(struct rte_pmd_i40e_ptype_info);
+	ptype = (struct rte_pmd_i40e_ptype_info *)malloc(buff_size);
+	if (!ptype)
+		goto no_print_return;
+
+	ret = rte_pmd_i40e_get_ddp_info(pkg, pkg_size, (uint8_t *)ptype,
+					buff_size,
+					RTE_PMD_I40E_PKG_INFO_PTYPE_LIST);
+	if (ret) {
+		free(ptype);
+		goto no_print_return;
+	}
+	printf("List of defined packet types:\n");
+	for (i = 0; i < ptype_num; i++) {
+		printf("  %2u:", ptype[i].ptype_id);
+		for (j = 0; j < RTE_PMD_I40E_PROTO_NUM; j++) {
+			proto_id = ptype[i].protocols[j];
+			if (proto_id != RTE_PMD_I40E_PROTO_UNUSED) {
+				for (n = 0; n < proto_num; n++) {
+					if (proto[n].proto_id == proto_id) {
+						printf(" %s", proto[n].name);
+						break;
+					}
+				}
+			}
+		}
+		printf("\n");
+	}
+	free(ptype);
+	printf("\n");
+
+	ret = 0;
+no_print_return:
+	free(proto);
+	if (ret == -ENOTSUP)
+		fprintf(stderr, "Function not supported in PMD\n");
+	close_file(pkg);
+}
+
+static cmdline_parse_inst_t cmd_ddp_get_info = {
+	.f = cmd_ddp_info_parsed,
+	.data = NULL,
+	.help_str = "ddp get info <profile_path>",
+	.tokens = {
+		(void *)&cmd_ddp_info_ddp,
+		(void *)&cmd_ddp_info_get,
+		(void *)&cmd_ddp_info_info,
+		(void *)&cmd_ddp_info_filepath,
+		NULL,
+	},
+};
+
+/* Get dynamic device personalization profile info list*/
+#define PROFILE_INFO_SIZE 48
+#define MAX_PROFILE_NUM 16
+
+struct cmd_ddp_get_list_result {
+	cmdline_fixed_string_t ddp;
+	cmdline_fixed_string_t get;
+	cmdline_fixed_string_t list;
+	portid_t port_id;
+};
+
+static cmdline_parse_token_string_t cmd_ddp_get_list_ddp =
+	TOKEN_STRING_INITIALIZER(struct cmd_ddp_get_list_result, ddp, "ddp");
+static cmdline_parse_token_string_t cmd_ddp_get_list_get =
+	TOKEN_STRING_INITIALIZER(struct cmd_ddp_get_list_result, get, "get");
+static cmdline_parse_token_string_t cmd_ddp_get_list_list =
+	TOKEN_STRING_INITIALIZER(struct cmd_ddp_get_list_result, list, "list");
+static cmdline_parse_token_num_t cmd_ddp_get_list_port_id =
+	TOKEN_NUM_INITIALIZER(struct cmd_ddp_get_list_result, port_id,
+		RTE_UINT16);
+
+static void
+cmd_ddp_get_list_parsed(__rte_unused void *parsed_result,
+	__rte_unused struct cmdline *cl,
+	__rte_unused void *data)
+{
+	struct cmd_ddp_get_list_result *res = parsed_result;
+	struct rte_pmd_i40e_profile_list *p_list;
+	struct rte_pmd_i40e_profile_info *p_info;
+	uint32_t p_num;
+	uint32_t size;
+	uint32_t i;
+	int ret = -ENOTSUP;
+
+	size = PROFILE_INFO_SIZE * MAX_PROFILE_NUM + 4;
+	p_list = (struct rte_pmd_i40e_profile_list *)malloc(size);
+	if (!p_list) {
+		fprintf(stderr, "%s: Failed to malloc buffer\n", __func__);
+		return;
+	}
+
+	if (ret == -ENOTSUP)
+		ret = rte_pmd_i40e_get_ddp_list(res->port_id,
+						(uint8_t *)p_list, size);
+
+	if (!ret) {
+		p_num = p_list->p_count;
+		printf("Profile number is: %d\n\n", p_num);
+
+		for (i = 0; i < p_num; i++) {
+			p_info = &p_list->p_info[i];
+			printf("Profile %d:\n", i);
+			printf("Track id:     0x%x\n", p_info->track_id);
+			printf("Version:      %d.%d.%d.%d\n",
+			       p_info->version.major,
+			       p_info->version.minor,
+			       p_info->version.update,
+			       p_info->version.draft);
+			printf("Profile name: %s\n\n", p_info->name);
+		}
+	}
+
+	free(p_list);
+
+	if (ret < 0)
+		fprintf(stderr, "Failed to get ddp list\n");
+}
+
+static cmdline_parse_inst_t cmd_ddp_get_list = {
+	.f = cmd_ddp_get_list_parsed,
+	.data = NULL,
+	.help_str = "ddp get list <port_id>",
+	.tokens = {
+		(void *)&cmd_ddp_get_list_ddp,
+		(void *)&cmd_ddp_get_list_get,
+		(void *)&cmd_ddp_get_list_list,
+		(void *)&cmd_ddp_get_list_port_id,
+		NULL,
+	},
+};
+
+/* Configure input set */
+struct cmd_cfg_input_set_result {
+	cmdline_fixed_string_t port;
+	cmdline_fixed_string_t cfg;
+	portid_t port_id;
+	cmdline_fixed_string_t pctype;
+	uint8_t pctype_id;
+	cmdline_fixed_string_t inset_type;
+	cmdline_fixed_string_t opt;
+	cmdline_fixed_string_t field;
+	uint8_t field_idx;
+};
+
+static void
+cmd_cfg_input_set_parsed(__rte_unused void *parsed_result,
+	__rte_unused struct cmdline *cl,
+	__rte_unused void *data)
+{
+	struct cmd_cfg_input_set_result *res = parsed_result;
+	enum rte_pmd_i40e_inset_type inset_type = INSET_NONE;
+	struct rte_pmd_i40e_inset inset;
+	int ret = -ENOTSUP;
+
+	if (!all_ports_stopped()) {
+		fprintf(stderr, "Please stop all ports first\n");
+		return;
+	}
+
+	if (!strcmp(res->inset_type, "hash_inset"))
+		inset_type = INSET_HASH;
+	else if (!strcmp(res->inset_type, "fdir_inset"))
+		inset_type = INSET_FDIR;
+	else if (!strcmp(res->inset_type, "fdir_flx_inset"))
+		inset_type = INSET_FDIR_FLX;
+	ret = rte_pmd_i40e_inset_get(res->port_id, res->pctype_id,
+				     &inset, inset_type);
+	if (ret) {
+		fprintf(stderr, "Failed to get input set.\n");
+		return;
+	}
+
+	if (!strcmp(res->opt, "get")) {
+		ret = rte_pmd_i40e_inset_field_get(inset.inset,
+						   res->field_idx);
+		if (ret)
+			printf("Field index %d is enabled.\n", res->field_idx);
+		else
+			printf("Field index %d is disabled.\n", res->field_idx);
+		return;
+	} else if (!strcmp(res->opt, "set"))
+		ret = rte_pmd_i40e_inset_field_set(&inset.inset,
+						   res->field_idx);
+	else if (!strcmp(res->opt, "clear"))
+		ret = rte_pmd_i40e_inset_field_clear(&inset.inset,
+						     res->field_idx);
+	if (ret) {
+		fprintf(stderr, "Failed to configure input set field.\n");
+		return;
+	}
+
+	ret = rte_pmd_i40e_inset_set(res->port_id, res->pctype_id,
+				     &inset, inset_type);
+	if (ret) {
+		fprintf(stderr, "Failed to set input set.\n");
+		return;
+	}
+
+	if (ret == -ENOTSUP)
+		fprintf(stderr, "Function not supported\n");
+}
+
+static cmdline_parse_token_string_t cmd_cfg_input_set_port =
+	TOKEN_STRING_INITIALIZER(struct cmd_cfg_input_set_result,
+				 port, "port");
+static cmdline_parse_token_string_t cmd_cfg_input_set_cfg =
+	TOKEN_STRING_INITIALIZER(struct cmd_cfg_input_set_result,
+				 cfg, "config");
+static cmdline_parse_token_num_t cmd_cfg_input_set_port_id =
+	TOKEN_NUM_INITIALIZER(struct cmd_cfg_input_set_result,
+			      port_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_cfg_input_set_pctype =
+	TOKEN_STRING_INITIALIZER(struct cmd_cfg_input_set_result,
+				 pctype, "pctype");
+static cmdline_parse_token_num_t cmd_cfg_input_set_pctype_id =
+	TOKEN_NUM_INITIALIZER(struct cmd_cfg_input_set_result,
+			      pctype_id, RTE_UINT8);
+static cmdline_parse_token_string_t cmd_cfg_input_set_inset_type =
+	TOKEN_STRING_INITIALIZER(struct cmd_cfg_input_set_result,
+				 inset_type,
+				 "hash_inset#fdir_inset#fdir_flx_inset");
+static cmdline_parse_token_string_t cmd_cfg_input_set_opt =
+	TOKEN_STRING_INITIALIZER(struct cmd_cfg_input_set_result,
+				 opt, "get#set#clear");
+static cmdline_parse_token_string_t cmd_cfg_input_set_field =
+	TOKEN_STRING_INITIALIZER(struct cmd_cfg_input_set_result,
+				 field, "field");
+static cmdline_parse_token_num_t cmd_cfg_input_set_field_idx =
+	TOKEN_NUM_INITIALIZER(struct cmd_cfg_input_set_result,
+			      field_idx, RTE_UINT8);
+
+static cmdline_parse_inst_t cmd_cfg_input_set = {
+	.f = cmd_cfg_input_set_parsed,
+	.data = NULL,
+	.help_str = "port config <port_id> pctype <pctype_id> hash_inset|"
+		    "fdir_inset|fdir_flx_inset get|set|clear field <field_idx>",
+	.tokens = {
+		(void *)&cmd_cfg_input_set_port,
+		(void *)&cmd_cfg_input_set_cfg,
+		(void *)&cmd_cfg_input_set_port_id,
+		(void *)&cmd_cfg_input_set_pctype,
+		(void *)&cmd_cfg_input_set_pctype_id,
+		(void *)&cmd_cfg_input_set_inset_type,
+		(void *)&cmd_cfg_input_set_opt,
+		(void *)&cmd_cfg_input_set_field,
+		(void *)&cmd_cfg_input_set_field_idx,
+		NULL,
+	},
+};
+
+/* Clear input set */
+struct cmd_clear_input_set_result {
+	cmdline_fixed_string_t port;
+	cmdline_fixed_string_t cfg;
+	portid_t port_id;
+	cmdline_fixed_string_t pctype;
+	uint8_t pctype_id;
+	cmdline_fixed_string_t inset_type;
+	cmdline_fixed_string_t clear;
+	cmdline_fixed_string_t all;
+};
+
+static void
+cmd_clear_input_set_parsed(__rte_unused void *parsed_result,
+	__rte_unused struct cmdline *cl,
+	__rte_unused void *data)
+{
+	struct cmd_clear_input_set_result *res = parsed_result;
+	enum rte_pmd_i40e_inset_type inset_type = INSET_NONE;
+	struct rte_pmd_i40e_inset inset;
+	int ret = -ENOTSUP;
+
+	if (!all_ports_stopped()) {
+		fprintf(stderr, "Please stop all ports first\n");
+		return;
+	}
+
+	if (!strcmp(res->inset_type, "hash_inset"))
+		inset_type = INSET_HASH;
+	else if (!strcmp(res->inset_type, "fdir_inset"))
+		inset_type = INSET_FDIR;
+	else if (!strcmp(res->inset_type, "fdir_flx_inset"))
+		inset_type = INSET_FDIR_FLX;
+
+	memset(&inset, 0, sizeof(inset));
+
+	ret = rte_pmd_i40e_inset_set(res->port_id, res->pctype_id,
+				     &inset, inset_type);
+	if (ret) {
+		fprintf(stderr, "Failed to clear input set.\n");
+		return;
+	}
+
+	if (ret == -ENOTSUP)
+		fprintf(stderr, "Function not supported\n");
+}
+
+static cmdline_parse_token_string_t cmd_clear_input_set_port =
+	TOKEN_STRING_INITIALIZER(struct cmd_clear_input_set_result,
+				 port, "port");
+static cmdline_parse_token_string_t cmd_clear_input_set_cfg =
+	TOKEN_STRING_INITIALIZER(struct cmd_clear_input_set_result,
+				 cfg, "config");
+static cmdline_parse_token_num_t cmd_clear_input_set_port_id =
+	TOKEN_NUM_INITIALIZER(struct cmd_clear_input_set_result,
+			      port_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_clear_input_set_pctype =
+	TOKEN_STRING_INITIALIZER(struct cmd_clear_input_set_result,
+				 pctype, "pctype");
+static cmdline_parse_token_num_t cmd_clear_input_set_pctype_id =
+	TOKEN_NUM_INITIALIZER(struct cmd_clear_input_set_result,
+			      pctype_id, RTE_UINT8);
+static cmdline_parse_token_string_t cmd_clear_input_set_inset_type =
+	TOKEN_STRING_INITIALIZER(struct cmd_clear_input_set_result,
+				 inset_type,
+				 "hash_inset#fdir_inset#fdir_flx_inset");
+static cmdline_parse_token_string_t cmd_clear_input_set_clear =
+	TOKEN_STRING_INITIALIZER(struct cmd_clear_input_set_result,
+				 clear, "clear");
+static cmdline_parse_token_string_t cmd_clear_input_set_all =
+	TOKEN_STRING_INITIALIZER(struct cmd_clear_input_set_result,
+				 all, "all");
+
+static cmdline_parse_inst_t cmd_clear_input_set = {
+	.f = cmd_clear_input_set_parsed,
+	.data = NULL,
+	.help_str = "port config <port_id> pctype <pctype_id> hash_inset|"
+		    "fdir_inset|fdir_flx_inset clear all",
+	.tokens = {
+		(void *)&cmd_clear_input_set_port,
+		(void *)&cmd_clear_input_set_cfg,
+		(void *)&cmd_clear_input_set_port_id,
+		(void *)&cmd_clear_input_set_pctype,
+		(void *)&cmd_clear_input_set_pctype_id,
+		(void *)&cmd_clear_input_set_inset_type,
+		(void *)&cmd_clear_input_set_clear,
+		(void *)&cmd_clear_input_set_all,
+		NULL,
+	},
+};
+
+/* port config pctype mapping reset */
+
+/* Common result structure for port config pctype mapping reset */
+struct cmd_pctype_mapping_reset_result {
+	cmdline_fixed_string_t port;
+	cmdline_fixed_string_t config;
+	portid_t port_id;
+	cmdline_fixed_string_t pctype;
+	cmdline_fixed_string_t mapping;
+	cmdline_fixed_string_t reset;
+};
+
+/* Common CLI fields for port config pctype mapping reset*/
+static cmdline_parse_token_string_t cmd_pctype_mapping_reset_port =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_pctype_mapping_reset_result,
+		 port, "port");
+static cmdline_parse_token_string_t cmd_pctype_mapping_reset_config =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_pctype_mapping_reset_result,
+		 config, "config");
+static cmdline_parse_token_num_t cmd_pctype_mapping_reset_port_id =
+	TOKEN_NUM_INITIALIZER
+		(struct cmd_pctype_mapping_reset_result,
+		 port_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_pctype_mapping_reset_pctype =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_pctype_mapping_reset_result,
+		 pctype, "pctype");
+static cmdline_parse_token_string_t cmd_pctype_mapping_reset_mapping =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_pctype_mapping_reset_result,
+		 mapping, "mapping");
+static cmdline_parse_token_string_t cmd_pctype_mapping_reset_reset =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_pctype_mapping_reset_result,
+		 reset, "reset");
+
+static void
+cmd_pctype_mapping_reset_parsed(void *parsed_result,
+	__rte_unused struct cmdline *cl,
+	__rte_unused void *data)
+{
+	struct cmd_pctype_mapping_reset_result *res = parsed_result;
+	int ret = -ENOTSUP;
+
+	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
+		return;
+
+	ret = rte_pmd_i40e_flow_type_mapping_reset(res->port_id);
+	switch (ret) {
+	case 0:
+		break;
+	case -ENODEV:
+		fprintf(stderr, "invalid port_id %d\n", res->port_id);
+		break;
+	case -ENOTSUP:
+		fprintf(stderr, "function not implemented\n");
+		break;
+	default:
+		fprintf(stderr, "programming error: (%s)\n", strerror(-ret));
+	}
+}
+
+static cmdline_parse_inst_t cmd_pctype_mapping_reset = {
+	.f = cmd_pctype_mapping_reset_parsed,
+	.data = NULL,
+	.help_str = "port config <port_id> pctype mapping reset",
+	.tokens = {
+		(void *)&cmd_pctype_mapping_reset_port,
+		(void *)&cmd_pctype_mapping_reset_config,
+		(void *)&cmd_pctype_mapping_reset_port_id,
+		(void *)&cmd_pctype_mapping_reset_pctype,
+		(void *)&cmd_pctype_mapping_reset_mapping,
+		(void *)&cmd_pctype_mapping_reset_reset,
+		NULL,
+	},
+};
+
+/* show port pctype mapping */
+
+/* Common result structure for show port pctype mapping */
+struct cmd_pctype_mapping_get_result {
+	cmdline_fixed_string_t show;
+	cmdline_fixed_string_t port;
+	portid_t port_id;
+	cmdline_fixed_string_t pctype;
+	cmdline_fixed_string_t mapping;
+};
+
+/* Common CLI fields for pctype mapping get */
+static cmdline_parse_token_string_t cmd_pctype_mapping_get_show =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_pctype_mapping_get_result,
+		 show, "show");
+static cmdline_parse_token_string_t cmd_pctype_mapping_get_port =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_pctype_mapping_get_result,
+		 port, "port");
+static cmdline_parse_token_num_t cmd_pctype_mapping_get_port_id =
+	TOKEN_NUM_INITIALIZER
+		(struct cmd_pctype_mapping_get_result,
+		 port_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_pctype_mapping_get_pctype =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_pctype_mapping_get_result,
+		 pctype, "pctype");
+static cmdline_parse_token_string_t cmd_pctype_mapping_get_mapping =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_pctype_mapping_get_result,
+		 mapping, "mapping");
+
+static void
+cmd_pctype_mapping_get_parsed(void *parsed_result,
+	__rte_unused struct cmdline *cl,
+	__rte_unused void *data)
+{
+	struct cmd_pctype_mapping_get_result *res = parsed_result;
+	int ret = -ENOTSUP;
+	struct rte_pmd_i40e_flow_type_mapping
+				mapping[RTE_PMD_I40E_FLOW_TYPE_MAX];
+	int i, j, first_pctype;
+
+	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
+		return;
+
+	ret = rte_pmd_i40e_flow_type_mapping_get(res->port_id, mapping);
+	switch (ret) {
+	case 0:
+		break;
+	case -ENODEV:
+		fprintf(stderr, "invalid port_id %d\n", res->port_id);
+		return;
+	case -ENOTSUP:
+		fprintf(stderr, "function not implemented\n");
+		return;
+	default:
+		fprintf(stderr, "programming error: (%s)\n", strerror(-ret));
+		return;
+	}
+
+	for (i = 0; i < RTE_PMD_I40E_FLOW_TYPE_MAX; i++) {
+		if (mapping[i].pctype != 0ULL) {
+			first_pctype = 1;
+
+			printf("pctype: ");
+			for (j = 0; j < RTE_PMD_I40E_PCTYPE_MAX; j++) {
+				if (mapping[i].pctype & (1ULL << j)) {
+					printf(first_pctype ?
+					       "%02d" : ",%02d", j);
+					first_pctype = 0;
+				}
+			}
+			printf("  ->  flowtype: %02d\n", mapping[i].flow_type);
+		}
+	}
+}
+
+static cmdline_parse_inst_t cmd_pctype_mapping_get = {
+	.f = cmd_pctype_mapping_get_parsed,
+	.data = NULL,
+	.help_str = "show port <port_id> pctype mapping",
+	.tokens = {
+		(void *)&cmd_pctype_mapping_get_show,
+		(void *)&cmd_pctype_mapping_get_port,
+		(void *)&cmd_pctype_mapping_get_port_id,
+		(void *)&cmd_pctype_mapping_get_pctype,
+		(void *)&cmd_pctype_mapping_get_mapping,
+		NULL,
+	},
+};
+
+/* port config pctype mapping update */
+
+/* Common result structure for port config pctype mapping update */
+struct cmd_pctype_mapping_update_result {
+	cmdline_fixed_string_t port;
+	cmdline_fixed_string_t config;
+	portid_t port_id;
+	cmdline_fixed_string_t pctype;
+	cmdline_fixed_string_t mapping;
+	cmdline_fixed_string_t update;
+	cmdline_fixed_string_t pctype_list;
+	uint16_t flow_type;
+};
+
+/* Common CLI fields for pctype mapping update*/
+static cmdline_parse_token_string_t cmd_pctype_mapping_update_port =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_pctype_mapping_update_result,
+		 port, "port");
+static cmdline_parse_token_string_t cmd_pctype_mapping_update_config =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_pctype_mapping_update_result,
+		 config, "config");
+static cmdline_parse_token_num_t cmd_pctype_mapping_update_port_id =
+	TOKEN_NUM_INITIALIZER
+		(struct cmd_pctype_mapping_update_result,
+		 port_id, RTE_UINT16);
+static cmdline_parse_token_string_t cmd_pctype_mapping_update_pctype =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_pctype_mapping_update_result,
+		 pctype, "pctype");
+static cmdline_parse_token_string_t cmd_pctype_mapping_update_mapping =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_pctype_mapping_update_result,
+		 mapping, "mapping");
+static cmdline_parse_token_string_t cmd_pctype_mapping_update_update =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_pctype_mapping_update_result,
+		 update, "update");
+static cmdline_parse_token_string_t cmd_pctype_mapping_update_pc_type =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_pctype_mapping_update_result,
+		 pctype_list, NULL);
+static cmdline_parse_token_num_t cmd_pctype_mapping_update_flow_type =
+	TOKEN_NUM_INITIALIZER
+		(struct cmd_pctype_mapping_update_result,
+		 flow_type, RTE_UINT16);
+
+static void
+cmd_pctype_mapping_update_parsed(void *parsed_result,
+	__rte_unused struct cmdline *cl,
+	__rte_unused void *data)
+{
+	struct cmd_pctype_mapping_update_result *res = parsed_result;
+	int ret = -ENOTSUP;
+	struct rte_pmd_i40e_flow_type_mapping mapping;
+	unsigned int i;
+	unsigned int nb_item;
+	unsigned int pctype_list[RTE_PMD_I40E_PCTYPE_MAX];
+
+	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
+		return;
+
+	nb_item = parse_item_list(res->pctype_list, "pctypes",
+				  RTE_PMD_I40E_PCTYPE_MAX, pctype_list, 1);
+	mapping.flow_type = res->flow_type;
+	for (i = 0, mapping.pctype = 0ULL; i < nb_item; i++)
+		mapping.pctype |= (1ULL << pctype_list[i]);
+	ret = rte_pmd_i40e_flow_type_mapping_update(res->port_id,
+						&mapping,
+						1,
+						0);
+	switch (ret) {
+	case 0:
+		break;
+	case -EINVAL:
+		fprintf(stderr, "invalid pctype or flow type\n");
+		break;
+	case -ENODEV:
+		fprintf(stderr, "invalid port_id %d\n", res->port_id);
+		break;
+	case -ENOTSUP:
+		fprintf(stderr, "function not implemented\n");
+		break;
+	default:
+		fprintf(stderr, "programming error: (%s)\n", strerror(-ret));
+	}
+}
+
+static cmdline_parse_inst_t cmd_pctype_mapping_update = {
+	.f = cmd_pctype_mapping_update_parsed,
+	.data = NULL,
+	.help_str = "port config <port_id> pctype mapping update"
+	" <pctype_id_0,[pctype_id_1]*> <flowtype_id>",
+	.tokens = {
+		(void *)&cmd_pctype_mapping_update_port,
+		(void *)&cmd_pctype_mapping_update_config,
+		(void *)&cmd_pctype_mapping_update_port_id,
+		(void *)&cmd_pctype_mapping_update_pctype,
+		(void *)&cmd_pctype_mapping_update_mapping,
+		(void *)&cmd_pctype_mapping_update_update,
+		(void *)&cmd_pctype_mapping_update_pc_type,
+		(void *)&cmd_pctype_mapping_update_flow_type,
+		NULL,
+	},
+};
+
+/* ptype mapping get */
+
+/* Common result structure for ptype mapping get */
+struct cmd_ptype_mapping_get_result {
+	cmdline_fixed_string_t ptype;
+	cmdline_fixed_string_t mapping;
+	cmdline_fixed_string_t get;
+	portid_t port_id;
+	uint8_t valid_only;
+};
+
+/* Common CLI fields for ptype mapping get */
+static cmdline_parse_token_string_t cmd_ptype_mapping_get_ptype =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_ptype_mapping_get_result,
+		 ptype, "ptype");
+static cmdline_parse_token_string_t cmd_ptype_mapping_get_mapping =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_ptype_mapping_get_result,
+		 mapping, "mapping");
+static cmdline_parse_token_string_t cmd_ptype_mapping_get_get =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_ptype_mapping_get_result,
+		 get, "get");
+static cmdline_parse_token_num_t cmd_ptype_mapping_get_port_id =
+	TOKEN_NUM_INITIALIZER
+		(struct cmd_ptype_mapping_get_result,
+		 port_id, RTE_UINT16);
+static cmdline_parse_token_num_t cmd_ptype_mapping_get_valid_only =
+	TOKEN_NUM_INITIALIZER
+		(struct cmd_ptype_mapping_get_result,
+		 valid_only, RTE_UINT8);
+
+static void
+cmd_ptype_mapping_get_parsed(void *parsed_result,
+	__rte_unused struct cmdline *cl,
+	__rte_unused void *data)
+{
+	struct cmd_ptype_mapping_get_result *res = parsed_result;
+	int ret = -ENOTSUP;
+	int max_ptype_num = 256;
+	struct rte_pmd_i40e_ptype_mapping mapping[max_ptype_num];
+	uint16_t count;
+	int i;
+
+	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
+		return;
+
+	ret = rte_pmd_i40e_ptype_mapping_get(res->port_id,
+					mapping,
+					max_ptype_num,
+					&count,
+					res->valid_only);
+	switch (ret) {
+	case 0:
+		break;
+	case -ENODEV:
+		fprintf(stderr, "invalid port_id %d\n", res->port_id);
+		break;
+	case -ENOTSUP:
+		fprintf(stderr, "function not implemented\n");
+		break;
+	default:
+		fprintf(stderr, "programming error: (%s)\n", strerror(-ret));
+	}
+
+	if (!ret) {
+		for (i = 0; i < count; i++)
+			printf("%3d\t0x%08x\n",
+				mapping[i].hw_ptype, mapping[i].sw_ptype);
+	}
+}
+
+static cmdline_parse_inst_t cmd_ptype_mapping_get = {
+	.f = cmd_ptype_mapping_get_parsed,
+	.data = NULL,
+	.help_str = "ptype mapping get <port_id> <valid_only>",
+	.tokens = {
+		(void *)&cmd_ptype_mapping_get_ptype,
+		(void *)&cmd_ptype_mapping_get_mapping,
+		(void *)&cmd_ptype_mapping_get_get,
+		(void *)&cmd_ptype_mapping_get_port_id,
+		(void *)&cmd_ptype_mapping_get_valid_only,
+		NULL,
+	},
+};
+
+/* ptype mapping replace */
+
+/* Common result structure for ptype mapping replace */
+struct cmd_ptype_mapping_replace_result {
+	cmdline_fixed_string_t ptype;
+	cmdline_fixed_string_t mapping;
+	cmdline_fixed_string_t replace;
+	portid_t port_id;
+	uint32_t target;
+	uint8_t mask;
+	uint32_t pkt_type;
+};
+
+/* Common CLI fields for ptype mapping replace */
+static cmdline_parse_token_string_t cmd_ptype_mapping_replace_ptype =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_ptype_mapping_replace_result,
+		 ptype, "ptype");
+static cmdline_parse_token_string_t cmd_ptype_mapping_replace_mapping =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_ptype_mapping_replace_result,
+		 mapping, "mapping");
+static cmdline_parse_token_string_t cmd_ptype_mapping_replace_replace =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_ptype_mapping_replace_result,
+		 replace, "replace");
+static cmdline_parse_token_num_t cmd_ptype_mapping_replace_port_id =
+	TOKEN_NUM_INITIALIZER
+		(struct cmd_ptype_mapping_replace_result,
+		 port_id, RTE_UINT16);
+static cmdline_parse_token_num_t cmd_ptype_mapping_replace_target =
+	TOKEN_NUM_INITIALIZER
+		(struct cmd_ptype_mapping_replace_result,
+		 target, RTE_UINT32);
+static cmdline_parse_token_num_t cmd_ptype_mapping_replace_mask =
+	TOKEN_NUM_INITIALIZER
+		(struct cmd_ptype_mapping_replace_result,
+		 mask, RTE_UINT8);
+static cmdline_parse_token_num_t cmd_ptype_mapping_replace_pkt_type =
+	TOKEN_NUM_INITIALIZER
+		(struct cmd_ptype_mapping_replace_result,
+		 pkt_type, RTE_UINT32);
+
+static void
+cmd_ptype_mapping_replace_parsed(void *parsed_result,
+	__rte_unused struct cmdline *cl,
+	__rte_unused void *data)
+{
+	struct cmd_ptype_mapping_replace_result *res = parsed_result;
+	int ret = -ENOTSUP;
+
+	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
+		return;
+
+	ret = rte_pmd_i40e_ptype_mapping_replace(res->port_id,
+					res->target,
+					res->mask,
+					res->pkt_type);
+	switch (ret) {
+	case 0:
+		break;
+	case -EINVAL:
+		fprintf(stderr, "invalid ptype 0x%8x or 0x%8x\n",
+			res->target, res->pkt_type);
+		break;
+	case -ENODEV:
+		fprintf(stderr, "invalid port_id %d\n", res->port_id);
+		break;
+	case -ENOTSUP:
+		fprintf(stderr, "function not implemented\n");
+		break;
+	default:
+		fprintf(stderr, "programming error: (%s)\n", strerror(-ret));
+	}
+}
+
+static cmdline_parse_inst_t cmd_ptype_mapping_replace = {
+	.f = cmd_ptype_mapping_replace_parsed,
+	.data = NULL,
+	.help_str =
+		"ptype mapping replace <port_id> <target> <mask> <pkt_type>",
+	.tokens = {
+		(void *)&cmd_ptype_mapping_replace_ptype,
+		(void *)&cmd_ptype_mapping_replace_mapping,
+		(void *)&cmd_ptype_mapping_replace_replace,
+		(void *)&cmd_ptype_mapping_replace_port_id,
+		(void *)&cmd_ptype_mapping_replace_target,
+		(void *)&cmd_ptype_mapping_replace_mask,
+		(void *)&cmd_ptype_mapping_replace_pkt_type,
+		NULL,
+	},
+};
+
+/* ptype mapping reset */
+
+/* Common result structure for ptype mapping reset */
+struct cmd_ptype_mapping_reset_result {
+	cmdline_fixed_string_t ptype;
+	cmdline_fixed_string_t mapping;
+	cmdline_fixed_string_t reset;
+	portid_t port_id;
+};
+
+/* Common CLI fields for ptype mapping reset*/
+static cmdline_parse_token_string_t cmd_ptype_mapping_reset_ptype =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_ptype_mapping_reset_result,
+		 ptype, "ptype");
+static cmdline_parse_token_string_t cmd_ptype_mapping_reset_mapping =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_ptype_mapping_reset_result,
+		 mapping, "mapping");
+static cmdline_parse_token_string_t cmd_ptype_mapping_reset_reset =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_ptype_mapping_reset_result,
+		 reset, "reset");
+static cmdline_parse_token_num_t cmd_ptype_mapping_reset_port_id =
+	TOKEN_NUM_INITIALIZER
+		(struct cmd_ptype_mapping_reset_result,
+		 port_id, RTE_UINT16);
+
+static void
+cmd_ptype_mapping_reset_parsed(void *parsed_result,
+	__rte_unused struct cmdline *cl,
+	__rte_unused void *data)
+{
+	struct cmd_ptype_mapping_reset_result *res = parsed_result;
+	int ret = -ENOTSUP;
+
+	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
+		return;
+
+	ret = rte_pmd_i40e_ptype_mapping_reset(res->port_id);
+	switch (ret) {
+	case 0:
+		break;
+	case -ENODEV:
+		fprintf(stderr, "invalid port_id %d\n", res->port_id);
+		break;
+	case -ENOTSUP:
+		fprintf(stderr, "function not implemented\n");
+		break;
+	default:
+		fprintf(stderr, "programming error: (%s)\n", strerror(-ret));
+	}
+}
+
+static cmdline_parse_inst_t cmd_ptype_mapping_reset = {
+	.f = cmd_ptype_mapping_reset_parsed,
+	.data = NULL,
+	.help_str = "ptype mapping reset <port_id>",
+	.tokens = {
+		(void *)&cmd_ptype_mapping_reset_ptype,
+		(void *)&cmd_ptype_mapping_reset_mapping,
+		(void *)&cmd_ptype_mapping_reset_reset,
+		(void *)&cmd_ptype_mapping_reset_port_id,
+		NULL,
+	},
+};
+
+/* ptype mapping update */
+
+/* Common result structure for ptype mapping update */
+struct cmd_ptype_mapping_update_result {
+	cmdline_fixed_string_t ptype;
+	cmdline_fixed_string_t mapping;
+	cmdline_fixed_string_t reset;
+	portid_t port_id;
+	uint8_t hw_ptype;
+	uint32_t sw_ptype;
+};
+
+/* Common CLI fields for ptype mapping update*/
+static cmdline_parse_token_string_t cmd_ptype_mapping_update_ptype =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_ptype_mapping_update_result,
+		 ptype, "ptype");
+static cmdline_parse_token_string_t cmd_ptype_mapping_update_mapping =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_ptype_mapping_update_result,
+		 mapping, "mapping");
+static cmdline_parse_token_string_t cmd_ptype_mapping_update_update =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_ptype_mapping_update_result,
+		 reset, "update");
+static cmdline_parse_token_num_t cmd_ptype_mapping_update_port_id =
+	TOKEN_NUM_INITIALIZER
+		(struct cmd_ptype_mapping_update_result,
+		 port_id, RTE_UINT16);
+static cmdline_parse_token_num_t cmd_ptype_mapping_update_hw_ptype =
+	TOKEN_NUM_INITIALIZER
+		(struct cmd_ptype_mapping_update_result,
+		 hw_ptype, RTE_UINT8);
+static cmdline_parse_token_num_t cmd_ptype_mapping_update_sw_ptype =
+	TOKEN_NUM_INITIALIZER
+		(struct cmd_ptype_mapping_update_result,
+		 sw_ptype, RTE_UINT32);
+
+static void
+cmd_ptype_mapping_update_parsed(void *parsed_result,
+	__rte_unused struct cmdline *cl,
+	__rte_unused void *data)
+{
+	struct cmd_ptype_mapping_update_result *res = parsed_result;
+	int ret = -ENOTSUP;
+	struct rte_pmd_i40e_ptype_mapping mapping;
+
+	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
+		return;
+
+	mapping.hw_ptype = res->hw_ptype;
+	mapping.sw_ptype = res->sw_ptype;
+	ret = rte_pmd_i40e_ptype_mapping_update(res->port_id,
+						&mapping,
+						1,
+						0);
+	switch (ret) {
+	case 0:
+		break;
+	case -EINVAL:
+		fprintf(stderr, "invalid ptype 0x%8x\n", res->sw_ptype);
+		break;
+	case -ENODEV:
+		fprintf(stderr, "invalid port_id %d\n", res->port_id);
+		break;
+	case -ENOTSUP:
+		fprintf(stderr, "function not implemented\n");
+		break;
+	default:
+		fprintf(stderr, "programming error: (%s)\n", strerror(-ret));
+	}
+}
+
+static cmdline_parse_inst_t cmd_ptype_mapping_update = {
+	.f = cmd_ptype_mapping_update_parsed,
+	.data = NULL,
+	.help_str = "ptype mapping update <port_id> <hw_ptype> <sw_ptype>",
+	.tokens = {
+		(void *)&cmd_ptype_mapping_update_ptype,
+		(void *)&cmd_ptype_mapping_update_mapping,
+		(void *)&cmd_ptype_mapping_update_update,
+		(void *)&cmd_ptype_mapping_update_port_id,
+		(void *)&cmd_ptype_mapping_update_hw_ptype,
+		(void *)&cmd_ptype_mapping_update_sw_ptype,
+		NULL,
+	},
+};
+
+static struct testpmd_cmdline_parser driver_parser = {
+	.ctx = (cmdline_parse_ctx_t[]) {
+		(cmdline_parse_inst_t *)&cmd_queue_region,
+		(cmdline_parse_inst_t *)&cmd_region_flowtype,
+		(cmdline_parse_inst_t *)&cmd_user_priority_region,
+		(cmdline_parse_inst_t *)&cmd_flush_queue_region,
+		(cmdline_parse_inst_t *)&cmd_show_queue_region_info_all,
+		(cmdline_parse_inst_t *)&cmd_add_del_raw_flow_director,
+		(cmdline_parse_inst_t *)&cmd_set_vf_promisc,
+		(cmdline_parse_inst_t *)&cmd_set_vf_allmulti,
+		(cmdline_parse_inst_t *)&cmd_set_vf_broadcast,
+		(cmdline_parse_inst_t *)&cmd_set_vf_vlan_tag,
+		(cmdline_parse_inst_t *)&cmd_vf_max_bw,
+		(cmdline_parse_inst_t *)&cmd_vf_tc_min_bw,
+		(cmdline_parse_inst_t *)&cmd_vf_tc_max_bw,
+		(cmdline_parse_inst_t *)&cmd_strict_link_prio,
+		(cmdline_parse_inst_t *)&cmd_ddp_add,
+		(cmdline_parse_inst_t *)&cmd_ddp_del,
+		(cmdline_parse_inst_t *)&cmd_ddp_get_list,
+		(cmdline_parse_inst_t *)&cmd_ddp_get_info,
+		(cmdline_parse_inst_t *)&cmd_cfg_input_set,
+		(cmdline_parse_inst_t *)&cmd_clear_input_set,
+		(cmdline_parse_inst_t *)&cmd_ptype_mapping_get,
+		(cmdline_parse_inst_t *)&cmd_ptype_mapping_replace,
+		(cmdline_parse_inst_t *)&cmd_ptype_mapping_reset,
+		(cmdline_parse_inst_t *)&cmd_ptype_mapping_update,
+		(cmdline_parse_inst_t *)&cmd_pctype_mapping_get,
+		(cmdline_parse_inst_t *)&cmd_pctype_mapping_reset,
+		(cmdline_parse_inst_t *)&cmd_pctype_mapping_update,
+		NULL
+	},
+	.help = {
+		"set port (port_id) queue-region region_id (value) "
+		"queue_start_index (value) queue_num (value)\n"
+		"    Set a queue region on a port\n",
+
+		"set port (port_id) queue-region region_id (value) "
+		"flowtype (value)\n"
+		"    Set a flowtype region index on a port\n",
+
+		"set port (port_id) queue-region UP (value) region_id (value)\n"
+		"    Set the mapping of User Priority to "
+		"queue region on a port\n",
+
+		"set port (port_id) queue-region flush (on|off)\n"
+		"    flush all queue region related configuration\n",
+
+		"show port (port_id) queue-region\n"
+		"    show all queue region related configuration info\n",
+
+		"flow_director_filter (port_id) mode raw (add|del|update)"
+		" flow (flow_id) (drop|fwd) queue (queue_id)"
+		" fd_id (fd_id_value) packet (packet file name)\n"
+		"    Add/Del a raw type flow director filter.\n",
+
+		"set vf promisc (port_id) (vf_id) (on|off)\n"
+		"    Set unicast promiscuous mode for a VF from the PF.\n",
+
+		"set vf allmulti (port_id) (vf_id) (on|off)\n"
+		"    Set multicast promiscuous mode for a VF from the PF.\n",
+
+		"set vf broadcast (port_id) (vf_id) (on|off)\n"
+		"    Set VF broadcast for a VF from the PF.\n",
+
+		"set vf vlan tag (port_id) (vf_id) (on|off)\n"
+		"    Set VLAN tag for a VF from the PF.\n",
+
+		"set vf tx max-bandwidth (port_id) (vf_id) (bandwidth)\n"
+		"    Set a VF's max bandwidth(Mbps).\n",
+
+		"set vf tc tx min-bandwidth (port_id) (vf_id) (bw1, bw2, ...)\n"
+		"    Set all TCs' min bandwidth(%%) on a VF.\n",
+
+		"set vf tc tx max-bandwidth (port_id) (vf_id) (tc_no) (bandwidth)\n"
+		"    Set a TC's max bandwidth(Mbps) on a VF.\n",
+
+		"set tx strict-link-priority (port_id) (tc_bitmap)\n"
+		"    Set some TCs' strict link priority mode on a physical port.\n",
+
+		"ddp add (port_id) (profile_path[,backup_profile_path])\n"
+		"    Load a profile package on a port\n",
+
+		"ddp del (port_id) (backup_profile_path)\n"
+		"    Delete a profile package from a port\n",
+
+		"ddp get list (port_id)\n"
+		"    Get ddp profile info list\n",
+
+		"ddp get info (profile_path)\n"
+		"    Get ddp profile information.\n",
+
+		"port config (port_id) pctype (pctype_id) hash_inset|"
+		"fdir_inset|fdir_flx_inset get|set|clear field\n"
+		" (field_idx)\n"
+		"    Configure RSS|FDIR|FDIR_FLX input set for some pctype\n",
+
+		"port config (port_id) pctype (pctype_id) hash_inset|"
+		"fdir_inset|fdir_flx_inset clear all"
+		"    Clear RSS|FDIR|FDIR_FLX input set completely for some pctype\n",
+
+		"ptype mapping get (port_id) (valid_only)\n"
+		"    Get ptype mapping on a port\n",
+
+		"ptype mapping replace (port_id) (target) (mask) (pky_type)\n"
+		"    Replace target with the pkt_type in ptype mapping\n",
+
+		"ptype mapping reset (port_id)\n"
+		"    Reset ptype mapping on a port\n",
+
+		"ptype mapping update (port_id) (hw_ptype) (sw_ptype)\n"
+		"    Update a ptype mapping item on a port\n",
+
+		"show port (port_id) pctype mapping\n"
+		"    Get flow ptype to pctype mapping on a port\n",
+
+		"port config (port_id) pctype mapping reset\n"
+		"    Reset flow type to pctype mapping on a port\n",
+
+		"port config (port_id) pctype mapping update"
+		" (pctype_id_0[,pctype_id_1]*) (flow_type_id)\n"
+		"    Update a flow type to pctype mapping item on a port\n",
+
+		NULL
+	},
+};
+
+RTE_INIT(i40e_testpmd)
+{
+	testpmd_add_commands(&driver_parser);
+}
diff --git a/drivers/net/i40e/meson.build b/drivers/net/i40e/meson.build
index efc5f93e35..b282ec7213 100644
--- a/drivers/net/i40e/meson.build
+++ b/drivers/net/i40e/meson.build
@@ -21,6 +21,8 @@  sources = files(
         'rte_pmd_i40e.c',
 )
 
+testpmd_sources = files('i40e_testpmd.c')
+
 deps += ['hash']
 includes += include_directories('base')