X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=app%2Ftest-pmd%2Fcmdline.c;h=0268b18f958e4fa5f18a83a3fb1ea551c4a8298e;hb=49ca9e5a256b7db55af71923ce827c1fa480b473;hp=39a1e772ed7ca1a185ef8dd269619949ddef95bc;hpb=4940344dab1d4da95ec6cd9f4fa8ac1fbc61ba54;p=dpdk.git

diff --git a/app/test-pmd/cmdline.c b/app/test-pmd/cmdline.c
index 39a1e772ed..0268b18f95 100644
--- a/app/test-pmd/cmdline.c
+++ b/app/test-pmd/cmdline.c
@@ -50,20 +50,20 @@
 #include <cmdline_parse_etheraddr.h>
 #include <cmdline_socket.h>
 #include <cmdline.h>
-#ifdef RTE_LIBRTE_PMD_BOND
+#ifdef RTE_NET_BOND
 #include <rte_eth_bond.h>
 #include <rte_eth_bond_8023ad.h>
 #endif
-#if defined RTE_LIBRTE_DPAA_BUS && defined RTE_LIBRTE_DPAA_PMD
+#if defined RTE_BUS_DPAA && defined RTE_NET_DPAA
 #include <rte_pmd_dpaa.h>
 #endif
-#ifdef RTE_LIBRTE_IXGBE_PMD
+#ifdef RTE_NET_IXGBE
 #include <rte_pmd_ixgbe.h>
 #endif
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
 #include <rte_pmd_i40e.h>
 #endif
-#ifdef RTE_LIBRTE_BNXT_PMD
+#ifdef RTE_NET_BNXT
 #include <rte_pmd_bnxt.h>
 #endif
 #include "testpmd.h"
@@ -163,9 +163,12 @@ static void cmd_help_long_parsed(void *parsed_result,
 			"Display:\n"
 			"--------\n\n"
 
-			"show port (info|stats|summary|xstats|fdir|stat_qmap|dcb_tc|cap) (port_id|all)\n"
+			"show port (info|stats|summary|xstats|fdir|dcb_tc) (port_id|all)\n"
 			"    Display information for port_id, or all.\n\n"
 
+			"show port port_id (module_eeprom|eeprom)\n"
+			"    Display the module EEPROM or EEPROM information for port_id.\n\n"
+
 			"show port X rss reta (size) (mask0,mask1,...)\n"
 			"    Display the rss redirection table entry indicated"
 			" by masks on port X. size is used to indicate the"
@@ -174,13 +177,13 @@ static void cmd_help_long_parsed(void *parsed_result,
 			"show port (port_id) rss-hash [key]\n"
 			"    Display the RSS hash functions and RSS hash key of port\n\n"
 
-			"clear port (info|stats|xstats|fdir|stat_qmap) (port_id|all)\n"
+			"clear port (info|stats|xstats|fdir) (port_id|all)\n"
 			"    Clear information for port_id, or all.\n\n"
 
 			"show (rxq|txq) info (port_id) (queue_id)\n"
 			"    Display information for configured RX/TX queue.\n\n"
 
-			"show config (rxtx|cores|fwd|txpkts)\n"
+			"show config (rxtx|cores|fwd|rxoffs|rxpkts|txpkts)\n"
 			"    Display the given configuration.\n\n"
 
 			"read rxd (port_id) (queue_id) (rxd_id)\n"
@@ -243,8 +246,21 @@ static void cmd_help_long_parsed(void *parsed_result,
 			"show port (port_id) rxq|txq (queue_id) desc (desc_id) status"
 			"       Show status of rx|tx descriptor.\n\n"
 
+			"show port (port_id) rxq (queue_id) desc used count\n"
+			"    Show current number of filled receive"
+			" packet descriptors.\n\n"
+
 			"show port (port_id) macs|mcast_macs"
 			"       Display list of mac addresses added to port.\n\n"
+
+			"show port (port_id) fec capabilities"
+			"	Show fec capabilities of a port.\n\n"
+
+			"show port (port_id) fec_mode"
+			"	Show fec mode of a port.\n\n"
+
+			"show port (port_id) flow_ctrl"
+			"	Show flow control info of a port.\n\n"
 		);
 	}
 
@@ -285,6 +301,18 @@ static void cmd_help_long_parsed(void *parsed_result,
 			"    Set the transmit delay time and number of retries,"
 			" effective when retry is enabled.\n\n"
 
+			"set rxoffs (x[,y]*)\n"
+			"    Set the offset of each packet segment on"
+			" receiving if split feature is engaged."
+			" Affects only the queues configured with split"
+			" offloads.\n\n"
+
+			"set rxpkts (x[,y]*)\n"
+			"    Set the length of each segment to scatter"
+			" packets on receiving if split feature is engaged."
+			" Affects only the queues configured with split"
+			" offloads.\n\n"
+
 			"set txpkts (x[,y]*)\n"
 			"    Set the length of each segment of TXONLY"
 			" and optionally CSUM packets.\n\n"
@@ -296,7 +324,7 @@ static void cmd_help_long_parsed(void *parsed_result,
 
 			"set txtimes (x, y)\n"
 			"    Set the scheduling on timestamps"
-			" timings for the TXOMLY mode\n\n"
+			" timings for the TXONLY mode\n\n"
 
 			"set corelist (x[,y]*)\n"
 			"    Set the list of forwarding cores.\n\n"
@@ -387,16 +415,6 @@ static void cmd_help_long_parsed(void *parsed_result,
 			"    Remove a vlan_id, to the set of VLAN identifiers"
 			"filtered for VF(s) from port_id.\n\n"
 
-			"tunnel_filter add (port_id) (outer_mac) (inner_mac) (ip_addr) "
-			"(inner_vlan) (vxlan|nvgre|ipingre|vxlan-gpe) (imac-ivlan|imac-ivlan-tenid|"
-			"imac-tenid|imac|omac-imac-tenid|oip|iip) (tenant_id) (queue_id)\n"
-			"   add a tunnel filter of a port.\n\n"
-
-			"tunnel_filter rm (port_id) (outer_mac) (inner_mac) (ip_addr) "
-			"(inner_vlan) (vxlan|nvgre|ipingre|vxlan-gpe) (imac-ivlan|imac-ivlan-tenid|"
-			"imac-tenid|imac|omac-imac-tenid|oip|iip) (tenant_id) (queue_id)\n"
-			"   remove a tunnel filter of a port.\n\n"
-
 			"rx_vxlan_port add (udp_port) (port_id)\n"
 			"    Add an UDP port for VXLAN packet filter on a port\n\n"
 
@@ -529,14 +547,15 @@ static void cmd_help_long_parsed(void *parsed_result,
 			"    Set the option to hide the zero values"
 			" for xstats display.\n"
 
+			"set record-core-cycles on|off\n"
+			"    Set the option to enable measurement of CPU cycles.\n"
+
+			"set record-burst-stats on|off\n"
+			"    Set the option to enable display of RX and TX bursts.\n"
+
 			"set port (port_id) vf (vf_id) rx|tx on|off\n"
 			"    Enable/Disable a VF receive/tranmit from a port\n\n"
 
-			"set port (port_id) vf (vf_id) (mac_addr)"
-			" (exact-mac#exact-mac-vlan#hashmac|hashmac-vlan) on|off\n"
-			"   Add/Remove unicast or multicast MAC addr filter"
-			" for a VF.\n\n"
-
 			"set port (port_id) vf (vf_id) rxmode (AUPE|ROPE|BAM"
 			"|MPE) (on|off)\n"
 			"    AUPE:accepts untagged VLAN;"
@@ -597,7 +616,7 @@ static void cmd_help_long_parsed(void *parsed_result,
 			"   Show the bypass configuration for a bypass enabled NIC"
 			" using the lowest port on the NIC.\n\n"
 
-#ifdef RTE_LIBRTE_PMD_BOND
+#ifdef RTE_NET_BOND
 			"create bonded device (mode) (socket)\n"
 			"	Create a new bonded device with specific bonding mode and socket.\n\n"
 
@@ -622,7 +641,7 @@ static void cmd_help_long_parsed(void *parsed_result,
 			"set bonding mode IEEE802.3AD aggregator policy (port_id) (agg_name)"
 			"	Set Aggregation mode for IEEE802.3AD (mode 4)"
 
-			"set bonding xmit_balance_policy (port_id) (l2|l23|l34)\n"
+			"set bonding balance_xmit_policy (port_id) (l2|l23|l34)\n"
 			"	Set the transmit balance policy for bonded device running in balance mode.\n\n"
 
 			"set bonding mon_period (port_id) (value)\n"
@@ -638,27 +657,6 @@ static void cmd_help_long_parsed(void *parsed_result,
 			"set link-down port (port_id)\n"
 			"	Set link down for a port.\n\n"
 
-			"E-tag set insertion on port-tag-id (value)"
-			" port (port_id) vf (vf_id)\n"
-			"    Enable E-tag insertion for a VF on a port\n\n"
-
-			"E-tag set insertion off port (port_id) vf (vf_id)\n"
-			"    Disable E-tag insertion for a VF on a port\n\n"
-
-			"E-tag set stripping (on|off) port (port_id)\n"
-			"    Enable/disable E-tag stripping on a port\n\n"
-
-			"E-tag set forwarding (on|off) port (port_id)\n"
-			"    Enable/disable E-tag based forwarding"
-			" on a port\n\n"
-
-			"E-tag set filter add e-tag-id (value) dst-pool"
-			" (pool_id) port (port_id)\n"
-			"    Add an E-tag forwarding filter on a port\n\n"
-
-			"E-tag set filter del e-tag-id (value) port (port_id)\n"
-			"    Delete an E-tag forwarding filter on a port\n\n"
-
 			"ddp add (port_id) (profile_path[,backup_profile_path])\n"
 			"    Load a profile package on a port\n\n"
 
@@ -698,21 +696,20 @@ static void cmd_help_long_parsed(void *parsed_result,
 			"show port meter cap (port_id)\n"
 			"    Show port meter capability information\n\n"
 
-			"add port meter profile srtcm_rfc2697 (port_id) (profile_id) (cir) (cbs) (ebs)\n"
+			"add port meter profile srtcm_rfc2697 (port_id) (profile_id) (cir) (cbs) (ebs) (packet_mode)\n"
 			"    meter profile add - srtcm rfc 2697\n\n"
 
-			"add port meter profile trtcm_rfc2698 (port_id) (profile_id) (cir) (pir) (cbs) (pbs)\n"
+			"add port meter profile trtcm_rfc2698 (port_id) (profile_id) (cir) (pir) (cbs) (pbs) (packet_mode)\n"
 			"    meter profile add - trtcm rfc 2698\n\n"
 
-			"add port meter profile trtcm_rfc4115 (port_id) (profile_id) (cir) (eir) (cbs) (ebs)\n"
+			"add port meter profile trtcm_rfc4115 (port_id) (profile_id) (cir) (eir) (cbs) (ebs) (packet_mode)\n"
 			"    meter profile add - trtcm rfc 4115\n\n"
 
 			"del port meter profile (port_id) (profile_id)\n"
 			"    meter profile delete\n\n"
 
-			"create port meter (port_id) (mtr_id) (profile_id) (meter_enable)\n"
-			"(g_action) (y_action) (r_action) (stats_mask) (shared)\n"
-			"(use_pre_meter_color) [(dscp_tbl_entry0) (dscp_tbl_entry1)...\n"
+			"create port meter (port_id) (mtr_id) (profile_id) (policy_id) (meter_enable)\n"
+			"(stats_mask) (shared) (use_pre_meter_color) [(dscp_tbl_entry0) (dscp_tbl_entry1)...\n"
 			"(dscp_tbl_entry63)]\n"
 			"    meter create\n\n"
 
@@ -725,6 +722,13 @@ static void cmd_help_long_parsed(void *parsed_result,
 			"del port meter (port_id) (mtr_id)\n"
 			"    meter delete\n\n"
 
+			"add port meter policy (port_id) (policy_id) g_actions (actions)\n"
+			"y_actions (actions) r_actions (actions)\n"
+			"    meter policy add\n\n"
+
+			"del port meter policy (port_id) (policy_id)\n"
+			"    meter policy delete\n\n"
+
 			"set port meter profile (port_id) (mtr_id) (profile_id)\n"
 			"    meter update meter profile\n\n"
 
@@ -742,6 +746,9 @@ static void cmd_help_long_parsed(void *parsed_result,
 			"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"
+
 			, list_pkt_forwarding_modes()
 		);
 	}
@@ -794,7 +801,8 @@ static void cmd_help_long_parsed(void *parsed_result,
 			"receive buffers available.\n\n"
 
 			"port config all rss (all|default|ip|tcp|udp|sctp|"
-			"ether|port|vxlan|geneve|nvgre|vxlan-gpe|none|<flowtype_id>)\n"
+			"ether|port|vxlan|geneve|nvgre|vxlan-gpe|ecpri|mpls|none|level-default|"
+			"level-outer|level-inner|<flowtype_id>)\n"
 			"    Set the RSS mode.\n\n"
 
 			"port config port-id rss reta (hash,queue)[,(hash,queue)]\n"
@@ -834,14 +842,6 @@ static void cmd_help_long_parsed(void *parsed_result,
 			"port (port_id) (rxq|txq) (queue_id) setup\n"
 			"    Setup a rx/tx queue of port X.\n\n"
 
-			"port config (port_id|all) l2-tunnel E-tag ether-type"
-			" (value)\n"
-			"    Set the value of E-tag ether-type.\n\n"
-
-			"port config (port_id|all) l2-tunnel E-tag"
-			" (enable|disable)\n"
-			"    Enable/disable the E-tag support.\n\n"
-
 			"port config (port_id) pctype mapping reset\n"
 			"    Reset flow type to pctype mapping on a port\n\n"
 
@@ -858,22 +858,22 @@ static void cmd_help_long_parsed(void *parsed_result,
 			"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 (udp_port)\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"
 
 			"port config <port_id> rx_offload vlan_strip|"
 			"ipv4_cksum|udp_cksum|tcp_cksum|tcp_lro|qinq_strip|"
 			"outer_ipv4_cksum|macsec_strip|header_split|"
-			"vlan_filter|vlan_extend|jumbo_frame|"
-			"scatter|timestamp|security|keep_crc on|off\n"
+			"vlan_filter|vlan_extend|jumbo_frame|scatter|"
+			"buffer_split|timestamp|security|keep_crc on|off\n"
 			"     Enable or disable a per port Rx offloading"
 			" on all Rx queues of a port\n\n"
 
 			"port (port_id) rxq (queue_id) rx_offload vlan_strip|"
 			"ipv4_cksum|udp_cksum|tcp_cksum|tcp_lro|qinq_strip|"
 			"outer_ipv4_cksum|macsec_strip|header_split|"
-			"vlan_filter|vlan_extend|jumbo_frame|"
-			"scatter|timestamp|security|keep_crc on|off\n"
+			"vlan_filter|vlan_extend|jumbo_frame|scatter|"
+			"buffer_split|timestamp|security|keep_crc on|off\n"
 			"    Enable or disable a per queue Rx offloading"
 			" only on a specific Rx queue\n\n"
 
@@ -911,6 +911,9 @@ static void cmd_help_long_parsed(void *parsed_result,
 			"    Register a dynf and Set/clear this flag on Tx. "
 			"Testpmd will set this value to any Tx packet "
 			"sent from this port\n\n"
+
+			"port cleanup (port_id) txq (queue_id) (free_cnt)\n"
+			"    Cleanup txq mbufs for a specific Tx queue\n\n"
 		);
 	}
 
@@ -950,89 +953,12 @@ static void cmd_help_long_parsed(void *parsed_result,
 			"filters:\n"
 			"--------\n\n"
 
-			"ethertype_filter (port_id) (add|del)"
-			" (mac_addr|mac_ignr) (mac_address) ethertype"
-			" (ether_type) (drop|fwd) queue (queue_id)\n"
-			"    Add/Del an ethertype filter.\n\n"
-
-			"2tuple_filter (port_id) (add|del)"
-			" dst_port (dst_port_value) protocol (protocol_value)"
-			" mask (mask_value) tcp_flags (tcp_flags_value)"
-			" priority (prio_value) queue (queue_id)\n"
-			"    Add/Del a 2tuple filter.\n\n"
-
-			"5tuple_filter (port_id) (add|del)"
-			" dst_ip (dst_address) src_ip (src_address)"
-			" dst_port (dst_port_value) src_port (src_port_value)"
-			" protocol (protocol_value)"
-			" mask (mask_value) tcp_flags (tcp_flags_value)"
-			" priority (prio_value) queue (queue_id)\n"
-			"    Add/Del a 5tuple filter.\n\n"
-
-			"syn_filter (port_id) (add|del) priority (high|low) queue (queue_id)"
-			"    Add/Del syn filter.\n\n"
-
-			"flex_filter (port_id) (add|del) len (len_value)"
-			" bytes (bytes_value) mask (mask_value)"
-			" priority (prio_value) queue (queue_id)\n"
-			"    Add/Del a flex filter.\n\n"
-
-			"flow_director_filter (port_id) mode IP (add|del|update)"
-			" flow (ipv4-other|ipv4-frag|ipv6-other|ipv6-frag)"
-			" src (src_ip_address) dst (dst_ip_address)"
-			" tos (tos_value) proto (proto_value) ttl (ttl_value)"
-			" vlan (vlan_value) flexbytes (flexbytes_value)"
-			" (drop|fwd) pf|vf(vf_id) queue (queue_id)"
-			" fd_id (fd_id_value)\n"
-			"    Add/Del an IP type flow director filter.\n\n"
-
-			"flow_director_filter (port_id) mode IP (add|del|update)"
-			" flow (ipv4-tcp|ipv4-udp|ipv6-tcp|ipv6-udp)"
-			" src (src_ip_address) (src_port)"
-			" dst (dst_ip_address) (dst_port)"
-			" tos (tos_value) ttl (ttl_value)"
-			" vlan (vlan_value) flexbytes (flexbytes_value)"
-			" (drop|fwd) pf|vf(vf_id) queue (queue_id)"
-			" fd_id (fd_id_value)\n"
-			"    Add/Del an UDP/TCP type flow director filter.\n\n"
-
-			"flow_director_filter (port_id) mode IP (add|del|update)"
-			" flow (ipv4-sctp|ipv6-sctp)"
-			" src (src_ip_address) (src_port)"
-			" dst (dst_ip_address) (dst_port)"
-			" tag (verification_tag) "
-			" tos (tos_value) ttl (ttl_value)"
-			" vlan (vlan_value)"
-			" flexbytes (flexbytes_value) (drop|fwd)"
-			" pf|vf(vf_id) queue (queue_id) fd_id (fd_id_value)\n"
-			"    Add/Del a SCTP type flow director filter.\n\n"
-
-			"flow_director_filter (port_id) mode IP (add|del|update)"
-			" flow l2_payload ether (ethertype)"
-			" flexbytes (flexbytes_value) (drop|fwd)"
-			" pf|vf(vf_id) queue (queue_id) fd_id (fd_id_value)\n"
-			"    Add/Del a l2 payload type flow director filter.\n\n"
-
-			"flow_director_filter (port_id) mode MAC-VLAN (add|del|update)"
-			" mac (mac_address) vlan (vlan_value)"
-			" flexbytes (flexbytes_value) (drop|fwd)"
-			" queue (queue_id) fd_id (fd_id_value)\n"
-			"    Add/Del a MAC-VLAN flow director filter.\n\n"
-
-			"flow_director_filter (port_id) mode Tunnel (add|del|update)"
-			" mac (mac_address) vlan (vlan_value)"
-			" tunnel (NVGRE|VxLAN) tunnel-id (tunnel_id_value)"
-			" flexbytes (flexbytes_value) (drop|fwd)"
-			" queue (queue_id) fd_id (fd_id_value)\n"
-			"    Add/Del a Tunnel flow director filter.\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"
-
-			"flush_flow_director (port_id)\n"
-			"    Flush all flow director entries of a device.\n\n"
+#endif
 
 			"flow_director_mask (port_id) mode IP vlan (vlan_value)"
 			" src_mask (ipv4_src) (ipv6_src) (src_port)"
@@ -1049,55 +975,10 @@ static void cmd_help_long_parsed(void *parsed_result,
 			" tunnel-id (tunnel_id_value)\n"
 			"    Set flow director Tunnel mask.\n\n"
 
-			"flow_director_flex_mask (port_id)"
-			" flow (none|ipv4-other|ipv4-frag|ipv4-tcp|ipv4-udp|ipv4-sctp|"
-			"ipv6-other|ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|l2_payload|all)"
-			" (mask)\n"
-			"    Configure mask of flex payload.\n\n"
-
 			"flow_director_flex_payload (port_id)"
 			" (raw|l2|l3|l4) (config)\n"
 			"    Configure flex payload selection.\n\n"
 
-			"get_sym_hash_ena_per_port (port_id)\n"
-			"    get symmetric hash enable configuration per port.\n\n"
-
-			"set_sym_hash_ena_per_port (port_id) (enable|disable)\n"
-			"    set symmetric hash enable configuration per port"
-			" to enable or disable.\n\n"
-
-			"get_hash_global_config (port_id)\n"
-			"    Get the global configurations of hash filters.\n\n"
-
-			"set_hash_global_config (port_id) (toeplitz|simple_xor|symmetric_toeplitz|default)"
-			" (ipv4|ipv4-frag|ipv4-tcp|ipv4-udp|ipv4-sctp|ipv4-other|ipv6|"
-			"ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|ipv6-other|l2_payload)"
-			" (enable|disable)\n"
-			"    Set the global configurations of hash filters.\n\n"
-
-			"set_hash_input_set (port_id) (ipv4|ipv4-frag|"
-			"ipv4-tcp|ipv4-udp|ipv4-sctp|ipv4-other|ipv6|"
-			"ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|ipv6-other|"
-			"l2_payload|<flowtype_id>) (ovlan|ivlan|src-ipv4|dst-ipv4|"
-			"src-ipv6|dst-ipv6|ipv4-tos|ipv4-proto|ipv6-tc|"
-			"ipv6-next-header|udp-src-port|udp-dst-port|"
-			"tcp-src-port|tcp-dst-port|sctp-src-port|"
-			"sctp-dst-port|sctp-veri-tag|udp-key|gre-key|fld-1st|"
-			"fld-2nd|fld-3rd|fld-4th|fld-5th|fld-6th|fld-7th|"
-			"fld-8th|none) (select|add)\n"
-			"    Set the input set for hash.\n\n"
-
-			"set_fdir_input_set (port_id) "
-			"(ipv4-frag|ipv4-tcp|ipv4-udp|ipv4-sctp|ipv4-other|"
-			"ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|ipv6-other|"
-			"l2_payload) (ivlan|ethertype|src-ipv4|dst-ipv4|src-ipv6|"
-			"dst-ipv6|ipv4-tos|ipv4-proto|ipv4-ttl|ipv6-tc|"
-			"ipv6-next-header|ipv6-hop-limits|udp-src-port|"
-			"udp-dst-port|tcp-src-port|tcp-dst-port|"
-			"sctp-src-port|sctp-dst-port|sctp-veri-tag|none)"
-			" (select|add)\n"
-			"    Set the input set for FDir.\n\n"
-
 			"flow validate {port_id}"
 			" [group {group_id}] [priority {level}]"
 			" [ingress] [egress]"
@@ -1133,6 +1014,24 @@ static void cmd_help_long_parsed(void *parsed_result,
 			"    List and destroy aged flows"
 			" flow rules\n\n"
 
+			"flow indirect_action {port_id} create"
+			" [action_id {indirect_action_id}]"
+			" [ingress] [egress]"
+			" action {action} / end\n"
+			"    Create indirect action.\n\n"
+
+			"flow indirect_action {port_id} update"
+			" {indirect_action_id} action {action} / end\n"
+			"    Update indirect action.\n\n"
+
+			"flow indirect_action {port_id} destroy"
+			" action_id {indirect_action_id} [...]\n"
+			"    Destroy specific indirect actions.\n\n"
+
+			"flow indirect_action {port_id} query"
+			" {indirect_action_id}\n"
+			"    Query an existing indirect action.\n\n"
+
 			"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)\n"
@@ -1192,7 +1091,7 @@ static void cmd_help_long_parsed(void *parsed_result,
 
 			"add port tm node shaper profile (port_id) (shaper_profile_id)"
 			" (cmit_tb_rate) (cmit_tb_size) (peak_tb_rate) (peak_tb_size)"
-			" (packet_length_adjust)\n"
+			" (packet_length_adjust) (packet_mode)\n"
 			"       Add port tm node private shaper profile.\n\n"
 
 			"del port tm node shaper profile (port_id) (shaper_profile_id)\n"
@@ -1224,6 +1123,12 @@ static void cmd_help_long_parsed(void *parsed_result,
 			" [(shared_shaper_id_0) (shared_shaper_id_1)...]\n"
 			"       Add port tm nonleaf node.\n\n"
 
+			"add port tm nonleaf node pktmode (port_id) (node_id) (parent_node_id)"
+			" (priority) (weight) (level_id) (shaper_profile_id)"
+			" (n_sp_priorities) (stats_mask) (n_shared_shapers)"
+			" [(shared_shaper_id_0) (shared_shaper_id_1)...]\n"
+			"       Add port tm nonleaf node with pkt mode enabled.\n\n"
+
 			"add port tm leaf node (port_id) (node_id) (parent_node_id)"
 			" (priority) (weight) (level_id) (shaper_profile_id)"
 			" (cman_mode) (wred_profile_id) (stats_mask) (n_shared_shapers)"
@@ -1378,7 +1283,7 @@ cmdline_parse_token_string_t cmd_operate_specific_port_port =
 						name, "start#stop#close#reset");
 cmdline_parse_token_num_t cmd_operate_specific_port_id =
 	TOKEN_NUM_INITIALIZER(struct cmd_operate_specific_port_result,
-							value, UINT8);
+							value, RTE_UINT8);
 
 cmdline_parse_inst_t cmd_operate_specific_port = {
 	.f = cmd_operate_specific_port_parsed,
@@ -1516,7 +1421,7 @@ cmdline_parse_token_string_t cmd_operate_detach_port_keyword =
 			keyword, "detach");
 cmdline_parse_token_num_t cmd_operate_detach_port_port_id =
 	TOKEN_NUM_INITIALIZER(struct cmd_operate_detach_port_result,
-			port_id, UINT16);
+			port_id, RTE_UINT16);
 
 cmdline_parse_inst_t cmd_operate_detach_port = {
 	.f = cmd_operate_detach_port_parsed,
@@ -1632,6 +1537,9 @@ parse_and_check_speed_duplex(char *speedstr, char *duplexstr, uint32_t *speed)
 		}
 	}
 
+	if (*speed != ETH_LINK_SPEED_AUTONEG)
+		*speed |= ETH_LINK_SPEED_FIXED;
+
 	return 0;
 }
 
@@ -1740,7 +1648,7 @@ cmdline_parse_token_string_t cmd_config_speed_specific_keyword =
 	TOKEN_STRING_INITIALIZER(struct cmd_config_speed_specific, keyword,
 								"config");
 cmdline_parse_token_num_t cmd_config_speed_specific_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_config_speed_specific, id, UINT16);
+	TOKEN_NUM_INITIALIZER(struct cmd_config_speed_specific, id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_config_speed_specific_item1 =
 	TOKEN_STRING_INITIALIZER(struct cmd_config_speed_specific, item1,
 								"speed");
@@ -1812,7 +1720,7 @@ cmdline_parse_token_string_t cmd_config_loopback_all_item =
 	TOKEN_STRING_INITIALIZER(struct cmd_config_loopback_all, item,
 							"loopback");
 cmdline_parse_token_num_t cmd_config_loopback_all_mode =
-	TOKEN_NUM_INITIALIZER(struct cmd_config_loopback_all, mode, UINT32);
+	TOKEN_NUM_INITIALIZER(struct cmd_config_loopback_all, mode, RTE_UINT32);
 
 cmdline_parse_inst_t cmd_config_loopback_all = {
 	.f = cmd_config_loopback_all_parsed,
@@ -1866,13 +1774,13 @@ cmdline_parse_token_string_t cmd_config_loopback_specific_keyword =
 								"config");
 cmdline_parse_token_num_t cmd_config_loopback_specific_id =
 	TOKEN_NUM_INITIALIZER(struct cmd_config_loopback_specific, port_id,
-								UINT16);
+								RTE_UINT16);
 cmdline_parse_token_string_t cmd_config_loopback_specific_item =
 	TOKEN_STRING_INITIALIZER(struct cmd_config_loopback_specific, item,
 								"loopback");
 cmdline_parse_token_num_t cmd_config_loopback_specific_mode =
 	TOKEN_NUM_INITIALIZER(struct cmd_config_loopback_specific, mode,
-			      UINT32);
+			      RTE_UINT32);
 
 cmdline_parse_inst_t cmd_config_loopback_specific = {
 	.f = cmd_config_loopback_specific_parsed,
@@ -1957,7 +1865,7 @@ cmdline_parse_token_string_t cmd_config_rx_tx_name =
 	TOKEN_STRING_INITIALIZER(struct cmd_config_rx_tx, name,
 						"rxq#txq#rxd#txd");
 cmdline_parse_token_num_t cmd_config_rx_tx_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_config_rx_tx, value, UINT16);
+	TOKEN_NUM_INITIALIZER(struct cmd_config_rx_tx, value, RTE_UINT16);
 
 cmdline_parse_inst_t cmd_config_rx_tx = {
 	.f = cmd_config_rx_tx_parsed,
@@ -1988,7 +1896,9 @@ cmd_config_max_pkt_len_parsed(void *parsed_result,
 				__rte_unused void *data)
 {
 	struct cmd_config_max_pkt_len_result *res = parsed_result;
+	uint32_t max_rx_pkt_len_backup = 0;
 	portid_t pid;
+	int ret;
 
 	if (!all_ports_stopped()) {
 		printf("Please stop all ports first\n");
@@ -1997,7 +1907,6 @@ cmd_config_max_pkt_len_parsed(void *parsed_result,
 
 	RTE_ETH_FOREACH_DEV(pid) {
 		struct rte_port *port = &ports[pid];
-		uint64_t rx_offloads = port->dev_conf.rxmode.offloads;
 
 		if (!strcmp(res->name, "max-pkt-len")) {
 			if (res->value < RTE_ETHER_MIN_LEN) {
@@ -2008,12 +1917,18 @@ cmd_config_max_pkt_len_parsed(void *parsed_result,
 			if (res->value == port->dev_conf.rxmode.max_rx_pkt_len)
 				return;
 
+			ret = eth_dev_info_get_print_err(pid, &port->dev_info);
+			if (ret != 0) {
+				printf("rte_eth_dev_info_get() failed for port %u\n",
+					pid);
+				return;
+			}
+
+			max_rx_pkt_len_backup = port->dev_conf.rxmode.max_rx_pkt_len;
+
 			port->dev_conf.rxmode.max_rx_pkt_len = res->value;
-			if (res->value > RTE_ETHER_MAX_LEN)
-				rx_offloads |= DEV_RX_OFFLOAD_JUMBO_FRAME;
-			else
-				rx_offloads &= ~DEV_RX_OFFLOAD_JUMBO_FRAME;
-			port->dev_conf.rxmode.offloads = rx_offloads;
+			if (update_jumbo_frame_offload(pid) != 0)
+				port->dev_conf.rxmode.max_rx_pkt_len = max_rx_pkt_len_backup;
 		} else {
 			printf("Unknown parameter\n");
 			return;
@@ -2039,7 +1954,7 @@ cmdline_parse_token_string_t cmd_config_max_pkt_len_name =
 								"max-pkt-len");
 cmdline_parse_token_num_t cmd_config_max_pkt_len_value =
 	TOKEN_NUM_INITIALIZER(struct cmd_config_max_pkt_len_result, value,
-								UINT32);
+								RTE_UINT32);
 
 cmdline_parse_inst_t cmd_config_max_pkt_len = {
 	.f = cmd_config_max_pkt_len_parsed,
@@ -2111,7 +2026,7 @@ cmdline_parse_token_string_t cmd_config_max_lro_pkt_size_name =
 				 name, "max-lro-pkt-size");
 cmdline_parse_token_num_t cmd_config_max_lro_pkt_size_value =
 	TOKEN_NUM_INITIALIZER(struct cmd_config_max_lro_pkt_size_result,
-			      value, UINT32);
+			      value, RTE_UINT32);
 
 cmdline_parse_inst_t cmd_config_max_lro_pkt_size = {
 	.f = cmd_config_max_lro_pkt_size_parsed,
@@ -2160,9 +2075,11 @@ cmdline_parse_token_string_t cmd_config_mtu_mtu =
 	TOKEN_STRING_INITIALIZER(struct cmd_config_mtu_result, keyword,
 				 "mtu");
 cmdline_parse_token_num_t cmd_config_mtu_port_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_config_mtu_result, port_id, UINT16);
+	TOKEN_NUM_INITIALIZER(struct cmd_config_mtu_result, port_id,
+				 RTE_UINT16);
 cmdline_parse_token_num_t cmd_config_mtu_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_config_mtu_result, value, UINT16);
+	TOKEN_NUM_INITIALIZER(struct cmd_config_mtu_result, value,
+				 RTE_UINT16);
 
 cmdline_parse_inst_t cmd_config_mtu = {
 	.f = cmd_config_mtu_parsed,
@@ -2273,7 +2190,8 @@ cmd_config_rss_parsed(void *parsed_result,
 		rss_conf.rss_hf = ETH_RSS_ETH | ETH_RSS_VLAN | ETH_RSS_IP |
 			ETH_RSS_TCP | ETH_RSS_UDP | ETH_RSS_SCTP |
 			ETH_RSS_L2_PAYLOAD | ETH_RSS_L2TPV3 | ETH_RSS_ESP |
-			ETH_RSS_AH | ETH_RSS_PFCP | ETH_RSS_GTPU;
+			ETH_RSS_AH | ETH_RSS_PFCP | ETH_RSS_GTPU |
+			ETH_RSS_ECPRI;
 	else if (!strcmp(res->value, "eth"))
 		rss_conf.rss_hf = ETH_RSS_ETH;
 	else if (!strcmp(res->value, "vlan"))
@@ -2332,9 +2250,22 @@ cmd_config_rss_parsed(void *parsed_result,
 		rss_conf.rss_hf = ETH_RSS_PPPOE;
 	else if (!strcmp(res->value, "gtpu"))
 		rss_conf.rss_hf = ETH_RSS_GTPU;
+	else if (!strcmp(res->value, "ecpri"))
+		rss_conf.rss_hf = ETH_RSS_ECPRI;
+	else if (!strcmp(res->value, "mpls"))
+		rss_conf.rss_hf = ETH_RSS_MPLS;
 	else if (!strcmp(res->value, "none"))
 		rss_conf.rss_hf = 0;
-	else if (!strcmp(res->value, "default"))
+	else if (!strcmp(res->value, "level-default")) {
+		rss_hf &= (~ETH_RSS_LEVEL_MASK);
+		rss_conf.rss_hf = (rss_hf | ETH_RSS_LEVEL_PMD_DEFAULT);
+	} else if (!strcmp(res->value, "level-outer")) {
+		rss_hf &= (~ETH_RSS_LEVEL_MASK);
+		rss_conf.rss_hf = (rss_hf | ETH_RSS_LEVEL_OUTERMOST);
+	} else if (!strcmp(res->value, "level-inner")) {
+		rss_hf &= (~ETH_RSS_LEVEL_MASK);
+		rss_conf.rss_hf = (rss_hf | ETH_RSS_LEVEL_INNERMOST);
+	} else if (!strcmp(res->value, "default"))
 		use_default = 1;
 	else if (isdigit(res->value[0]) && atoi(res->value) > 0 &&
 						atoi(res->value) < 64)
@@ -2393,7 +2324,8 @@ cmdline_parse_inst_t cmd_config_rss = {
 	.data = NULL,
 	.help_str = "port config all rss "
 		"all|default|eth|vlan|ip|tcp|udp|sctp|ether|port|vxlan|geneve|"
-		"nvgre|vxlan-gpe|l2tpv3|esp|ah|pfcp|none|<flowtype_id>",
+		"nvgre|vxlan-gpe|l2tpv3|esp|ah|pfcp|ecpri|mpls|none|level-default|"
+		"level-outer|level-inner|<flowtype_id>",
 	.tokens = {
 		(void *)&cmd_config_rss_port,
 		(void *)&cmd_config_rss_keyword,
@@ -2493,7 +2425,8 @@ cmdline_parse_token_string_t cmd_config_rss_hash_key_config =
 	TOKEN_STRING_INITIALIZER(struct cmd_config_rss_hash_key, config,
 				 "config");
 cmdline_parse_token_num_t cmd_config_rss_hash_key_port_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_config_rss_hash_key, port_id, UINT16);
+	TOKEN_NUM_INITIALIZER(struct cmd_config_rss_hash_key, port_id,
+				 RTE_UINT16);
 cmdline_parse_token_string_t cmd_config_rss_hash_key_rss_hash_key =
 	TOKEN_STRING_INITIALIZER(struct cmd_config_rss_hash_key,
 				 rss_hash_key, "rss-hash-key");
@@ -2505,7 +2438,7 @@ cmdline_parse_token_string_t cmd_config_rss_hash_key_rss_type =
 				 "ipv6-tcp-ex#ipv6-udp-ex#"
 				 "l3-src-only#l3-dst-only#l4-src-only#l4-dst-only#"
 				 "l2-src-only#l2-dst-only#s-vlan#c-vlan#"
-				 "l2tpv3#esp#ah#pfcp#pppoe#gtpu");
+				 "l2tpv3#esp#ah#pfcp#pppoe#gtpu#ecpri#mpls");
 cmdline_parse_token_string_t cmd_config_rss_hash_key_value =
 	TOKEN_STRING_INITIALIZER(struct cmd_config_rss_hash_key, key, NULL);
 
@@ -2518,7 +2451,7 @@ cmdline_parse_inst_t cmd_config_rss_hash_key = {
 		"l2-payload|ipv6-ex|ipv6-tcp-ex|ipv6-udp-ex|"
 		"l3-src-only|l3-dst-only|l4-src-only|l4-dst-only|"
 		"l2-src-only|l2-dst-only|s-vlan|c-vlan|"
-		"l2tpv3|esp|ah|pfcp|pppoe|gtpu "
+		"l2tpv3|esp|ah|pfcp|pppoe|gtpu|ecpri|mpls "
 		"<string of hex digits (variable length, NIC dependent)>",
 	.tokens = {
 		(void *)&cmd_config_rss_hash_key_port,
@@ -2531,6 +2464,90 @@ cmdline_parse_inst_t cmd_config_rss_hash_key = {
 	},
 };
 
+/* *** cleanup txq mbufs *** */
+struct cmd_cleanup_txq_mbufs_result {
+	cmdline_fixed_string_t port;
+	cmdline_fixed_string_t keyword;
+	cmdline_fixed_string_t name;
+	uint16_t port_id;
+	uint16_t queue_id;
+	uint32_t free_cnt;
+};
+
+static void
+cmd_cleanup_txq_mbufs_parsed(void *parsed_result,
+			     __rte_unused struct cmdline *cl,
+			     __rte_unused void *data)
+{
+	struct cmd_cleanup_txq_mbufs_result *res = parsed_result;
+	uint16_t port_id = res->port_id;
+	uint16_t queue_id = res->queue_id;
+	uint32_t free_cnt = res->free_cnt;
+	struct rte_eth_txq_info qinfo;
+	int ret;
+
+	if (test_done == 0) {
+		printf("Please stop forwarding first\n");
+		return;
+	}
+
+	if (rte_eth_tx_queue_info_get(port_id, queue_id, &qinfo)) {
+		printf("Failed to get port %u Tx queue %u info\n",
+		       port_id, queue_id);
+		return;
+	}
+
+	if (qinfo.queue_state != RTE_ETH_QUEUE_STATE_STARTED) {
+		printf("Tx queue %u not started\n", queue_id);
+		return;
+	}
+
+	ret = rte_eth_tx_done_cleanup(port_id, queue_id, free_cnt);
+	if (ret < 0) {
+		printf("Failed to cleanup mbuf for port %u Tx queue %u "
+		       "error desc: %s(%d)\n",
+		       port_id, queue_id, strerror(-ret), ret);
+		return;
+	}
+
+	printf("Cleanup port %u Tx queue %u mbuf nums: %u\n",
+	       port_id, queue_id, ret);
+}
+
+cmdline_parse_token_string_t cmd_cleanup_txq_mbufs_port =
+	TOKEN_STRING_INITIALIZER(struct cmd_cleanup_txq_mbufs_result, port,
+				 "port");
+cmdline_parse_token_string_t cmd_cleanup_txq_mbufs_cleanup =
+	TOKEN_STRING_INITIALIZER(struct cmd_cleanup_txq_mbufs_result, keyword,
+				 "cleanup");
+cmdline_parse_token_num_t cmd_cleanup_txq_mbufs_port_id =
+	TOKEN_NUM_INITIALIZER(struct cmd_cleanup_txq_mbufs_result, port_id,
+			      RTE_UINT16);
+cmdline_parse_token_string_t cmd_cleanup_txq_mbufs_txq =
+	TOKEN_STRING_INITIALIZER(struct cmd_cleanup_txq_mbufs_result, name,
+				 "txq");
+cmdline_parse_token_num_t cmd_cleanup_txq_mbufs_queue_id =
+	TOKEN_NUM_INITIALIZER(struct cmd_cleanup_txq_mbufs_result, queue_id,
+			      RTE_UINT16);
+cmdline_parse_token_num_t cmd_cleanup_txq_mbufs_free_cnt =
+	TOKEN_NUM_INITIALIZER(struct cmd_cleanup_txq_mbufs_result, free_cnt,
+			      RTE_UINT32);
+
+cmdline_parse_inst_t cmd_cleanup_txq_mbufs = {
+	.f = cmd_cleanup_txq_mbufs_parsed,
+	.data = NULL,
+	.help_str = "port cleanup <port_id> txq <queue_id> <free_cnt>",
+	.tokens = {
+		(void *)&cmd_cleanup_txq_mbufs_port,
+		(void *)&cmd_cleanup_txq_mbufs_cleanup,
+		(void *)&cmd_cleanup_txq_mbufs_port_id,
+		(void *)&cmd_cleanup_txq_mbufs_txq,
+		(void *)&cmd_cleanup_txq_mbufs_queue_id,
+		(void *)&cmd_cleanup_txq_mbufs_free_cnt,
+		NULL,
+	},
+};
+
 /* *** configure port rxq/txq ring size *** */
 struct cmd_config_rxtx_ring_size {
 	cmdline_fixed_string_t port;
@@ -2597,19 +2614,19 @@ cmdline_parse_token_string_t cmd_config_rxtx_ring_size_config =
 				 config, "config");
 cmdline_parse_token_num_t cmd_config_rxtx_ring_size_portid =
 	TOKEN_NUM_INITIALIZER(struct cmd_config_rxtx_ring_size,
-				 portid, UINT16);
+				 portid, RTE_UINT16);
 cmdline_parse_token_string_t cmd_config_rxtx_ring_size_rxtxq =
 	TOKEN_STRING_INITIALIZER(struct cmd_config_rxtx_ring_size,
 				 rxtxq, "rxq#txq");
 cmdline_parse_token_num_t cmd_config_rxtx_ring_size_qid =
 	TOKEN_NUM_INITIALIZER(struct cmd_config_rxtx_ring_size,
-			      qid, UINT16);
+			      qid, RTE_UINT16);
 cmdline_parse_token_string_t cmd_config_rxtx_ring_size_rsize =
 	TOKEN_STRING_INITIALIZER(struct cmd_config_rxtx_ring_size,
 				 rsize, "ring_size");
 cmdline_parse_token_num_t cmd_config_rxtx_ring_size_size =
 	TOKEN_NUM_INITIALIZER(struct cmd_config_rxtx_ring_size,
-			      size, UINT16);
+			      size, RTE_UINT16);
 
 cmdline_parse_inst_t cmd_config_rxtx_ring_size = {
 	.f = cmd_config_rxtx_ring_size_parsed,
@@ -2698,11 +2715,11 @@ cmd_config_rxtx_queue_parsed(void *parsed_result,
 cmdline_parse_token_string_t cmd_config_rxtx_queue_port =
 	TOKEN_STRING_INITIALIZER(struct cmd_config_rxtx_queue, port, "port");
 cmdline_parse_token_num_t cmd_config_rxtx_queue_portid =
-	TOKEN_NUM_INITIALIZER(struct cmd_config_rxtx_queue, portid, UINT16);
+	TOKEN_NUM_INITIALIZER(struct cmd_config_rxtx_queue, portid, RTE_UINT16);
 cmdline_parse_token_string_t cmd_config_rxtx_queue_rxtxq =
 	TOKEN_STRING_INITIALIZER(struct cmd_config_rxtx_queue, rxtxq, "rxq#txq");
 cmdline_parse_token_num_t cmd_config_rxtx_queue_qid =
-	TOKEN_NUM_INITIALIZER(struct cmd_config_rxtx_queue, qid, UINT16);
+	TOKEN_NUM_INITIALIZER(struct cmd_config_rxtx_queue, qid, RTE_UINT16);
 cmdline_parse_token_string_t cmd_config_rxtx_queue_opname =
 	TOKEN_STRING_INITIALIZER(struct cmd_config_rxtx_queue, opname,
 						"start#stop");
@@ -2778,13 +2795,13 @@ cmdline_parse_token_string_t cmd_config_deferred_start_rxtx_queue_port =
 						port, "port");
 cmdline_parse_token_num_t cmd_config_deferred_start_rxtx_queue_port_id =
 	TOKEN_NUM_INITIALIZER(struct cmd_config_deferred_start_rxtx_queue,
-						port_id, UINT16);
+						port_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_config_deferred_start_rxtx_queue_rxtxq =
 	TOKEN_STRING_INITIALIZER(struct cmd_config_deferred_start_rxtx_queue,
 						rxtxq, "rxq#txq");
 cmdline_parse_token_num_t cmd_config_deferred_start_rxtx_queue_qid =
 	TOKEN_NUM_INITIALIZER(struct cmd_config_deferred_start_rxtx_queue,
-						qid, UINT16);
+						qid, RTE_UINT16);
 cmdline_parse_token_string_t cmd_config_deferred_start_rxtx_queue_opname =
 	TOKEN_STRING_INITIALIZER(struct cmd_config_deferred_start_rxtx_queue,
 						opname, "deferred_start");
@@ -2820,11 +2837,11 @@ struct cmd_setup_rxtx_queue {
 cmdline_parse_token_string_t cmd_setup_rxtx_queue_port =
 	TOKEN_STRING_INITIALIZER(struct cmd_setup_rxtx_queue, port, "port");
 cmdline_parse_token_num_t cmd_setup_rxtx_queue_portid =
-	TOKEN_NUM_INITIALIZER(struct cmd_setup_rxtx_queue, portid, UINT16);
+	TOKEN_NUM_INITIALIZER(struct cmd_setup_rxtx_queue, portid, RTE_UINT16);
 cmdline_parse_token_string_t cmd_setup_rxtx_queue_rxtxq =
 	TOKEN_STRING_INITIALIZER(struct cmd_setup_rxtx_queue, rxtxq, "rxq#txq");
 cmdline_parse_token_num_t cmd_setup_rxtx_queue_qid =
-	TOKEN_NUM_INITIALIZER(struct cmd_setup_rxtx_queue, qid, UINT16);
+	TOKEN_NUM_INITIALIZER(struct cmd_setup_rxtx_queue, qid, RTE_UINT16);
 cmdline_parse_token_string_t cmd_setup_rxtx_queue_setup =
 	TOKEN_STRING_INITIALIZER(struct cmd_setup_rxtx_queue, setup, "setup");
 
@@ -2872,7 +2889,7 @@ cmd_setup_rxtx_queue_parsed(
 		if (!numa_support || socket_id == NUMA_NO_CONFIG)
 			socket_id = port->socket_id;
 
-		mp = mbuf_pool_find(socket_id);
+		mp = mbuf_pool_find(socket_id, 0);
 		if (mp == NULL) {
 			printf("Failed to setup RX queue: "
 				"No mempool allocation"
@@ -2880,12 +2897,12 @@ cmd_setup_rxtx_queue_parsed(
 				rxring_numa[res->portid]);
 			return;
 		}
-		ret = rte_eth_rx_queue_setup(res->portid,
-					     res->qid,
-					     port->nb_rx_desc[res->qid],
-					     socket_id,
-					     &port->rx_conf[res->qid],
-					     mp);
+		ret = rx_queue_setup(res->portid,
+				     res->qid,
+				     port->nb_rx_desc[res->qid],
+				     socket_id,
+				     &port->rx_conf[res->qid],
+				     mp);
 		if (ret)
 			printf("Failed to setup RX queue\n");
 	} else {
@@ -2893,6 +2910,10 @@ cmd_setup_rxtx_queue_parsed(
 		if (!numa_support || socket_id == NUMA_NO_CONFIG)
 			socket_id = port->socket_id;
 
+		if (port->nb_tx_desc[res->qid] < tx_pkt_nb_segs) {
+			printf("Failed to setup TX queue: not enough descriptors\n");
+			return;
+		}
 		ret = rte_eth_tx_queue_setup(res->portid,
 					     res->qid,
 					     port->nb_tx_desc[res->qid],
@@ -3033,7 +3054,7 @@ cmdline_parse_token_string_t cmd_config_rss_reta_port =
 cmdline_parse_token_string_t cmd_config_rss_reta_keyword =
 	TOKEN_STRING_INITIALIZER(struct cmd_config_rss_reta, keyword, "config");
 cmdline_parse_token_num_t cmd_config_rss_reta_port_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_config_rss_reta, port_id, UINT16);
+	TOKEN_NUM_INITIALIZER(struct cmd_config_rss_reta, port_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_config_rss_reta_name =
 	TOKEN_STRING_INITIALIZER(struct cmd_config_rss_reta, name, "rss");
 cmdline_parse_token_string_t cmd_config_rss_reta_list_name =
@@ -3144,13 +3165,13 @@ cmdline_parse_token_string_t cmd_showport_reta_show =
 cmdline_parse_token_string_t cmd_showport_reta_port =
 	TOKEN_STRING_INITIALIZER(struct  cmd_showport_reta, port, "port");
 cmdline_parse_token_num_t cmd_showport_reta_port_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_showport_reta, port_id, UINT16);
+	TOKEN_NUM_INITIALIZER(struct cmd_showport_reta, port_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_showport_reta_rss =
 	TOKEN_STRING_INITIALIZER(struct cmd_showport_reta, rss, "rss");
 cmdline_parse_token_string_t cmd_showport_reta_reta =
 	TOKEN_STRING_INITIALIZER(struct cmd_showport_reta, reta, "reta");
 cmdline_parse_token_num_t cmd_showport_reta_size =
-	TOKEN_NUM_INITIALIZER(struct cmd_showport_reta, size, UINT16);
+	TOKEN_NUM_INITIALIZER(struct cmd_showport_reta, size, RTE_UINT16);
 cmdline_parse_token_string_t cmd_showport_reta_list_of_items =
 	TOKEN_STRING_INITIALIZER(struct cmd_showport_reta,
 					list_of_items, NULL);
@@ -3195,7 +3216,8 @@ cmdline_parse_token_string_t cmd_showport_rss_hash_show =
 cmdline_parse_token_string_t cmd_showport_rss_hash_port =
 	TOKEN_STRING_INITIALIZER(struct cmd_showport_rss_hash, port, "port");
 cmdline_parse_token_num_t cmd_showport_rss_hash_port_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_showport_rss_hash, port_id, UINT16);
+	TOKEN_NUM_INITIALIZER(struct cmd_showport_rss_hash, port_id,
+				 RTE_UINT16);
 cmdline_parse_token_string_t cmd_showport_rss_hash_rss_hash =
 	TOKEN_STRING_INITIALIZER(struct cmd_showport_rss_hash, rss_hash,
 				 "rss-hash");
@@ -3248,6 +3270,7 @@ cmd_config_dcb_parsed(void *parsed_result,
                         __rte_unused void *data)
 {
 	struct cmd_config_dcb *res = parsed_result;
+	struct rte_eth_dcb_info dcb_info;
 	portid_t port_id = res->port_id;
 	struct rte_port *port;
 	uint8_t pfc_en;
@@ -3270,6 +3293,14 @@ cmd_config_dcb_parsed(void *parsed_result,
 		printf("nb_cores shouldn't be less than number of TCs.\n");
 		return;
 	}
+
+	/* Check whether the port supports the report of DCB info. */
+	ret = rte_eth_dev_get_dcb_info(port_id, &dcb_info);
+	if (ret == -ENOTSUP) {
+		printf("rte_eth_dev_get_dcb_info not supported.\n");
+		return;
+	}
+
 	if (!strncmp(res->pfc_en, "on", 2))
 		pfc_en = 1;
 	else
@@ -3284,13 +3315,13 @@ cmd_config_dcb_parsed(void *parsed_result,
 		ret = init_port_dcb_config(port_id, DCB_ENABLED,
 				(enum rte_eth_nb_tcs)res->num_tcs,
 				pfc_en);
-
-
 	if (ret != 0) {
 		printf("Cannot initialize network ports.\n");
 		return;
 	}
 
+	fwd_config_setup();
+
 	cmd_reconfig_device_queue(port_id, 1, 1);
 }
 
@@ -3299,7 +3330,7 @@ cmdline_parse_token_string_t cmd_config_dcb_port =
 cmdline_parse_token_string_t cmd_config_dcb_config =
         TOKEN_STRING_INITIALIZER(struct cmd_config_dcb, config, "config");
 cmdline_parse_token_num_t cmd_config_dcb_port_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_config_dcb, port_id, UINT16);
+	TOKEN_NUM_INITIALIZER(struct cmd_config_dcb, port_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_config_dcb_dcb =
         TOKEN_STRING_INITIALIZER(struct cmd_config_dcb, dcb, "dcb");
 cmdline_parse_token_string_t cmd_config_dcb_vt =
@@ -3307,7 +3338,7 @@ cmdline_parse_token_string_t cmd_config_dcb_vt =
 cmdline_parse_token_string_t cmd_config_dcb_vt_en =
         TOKEN_STRING_INITIALIZER(struct cmd_config_dcb, vt_en, "on#off");
 cmdline_parse_token_num_t cmd_config_dcb_num_tcs =
-        TOKEN_NUM_INITIALIZER(struct cmd_config_dcb, num_tcs, UINT8);
+	TOKEN_NUM_INITIALIZER(struct cmd_config_dcb, num_tcs, RTE_UINT8);
 cmdline_parse_token_string_t cmd_config_dcb_pfc=
         TOKEN_STRING_INITIALIZER(struct cmd_config_dcb, pfc, "pfc");
 cmdline_parse_token_string_t cmd_config_dcb_pfc_en =
@@ -3406,7 +3437,7 @@ cmdline_parse_token_string_t cmd_config_burst_all =
 cmdline_parse_token_string_t cmd_config_burst_name =
 	TOKEN_STRING_INITIALIZER(struct cmd_config_burst, name, "burst");
 cmdline_parse_token_num_t cmd_config_burst_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_config_burst, value, UINT16);
+	TOKEN_NUM_INITIALIZER(struct cmd_config_burst, value, RTE_UINT16);
 
 cmdline_parse_inst_t cmd_config_burst = {
 	.f = cmd_config_burst_parsed,
@@ -3475,7 +3506,7 @@ cmdline_parse_token_string_t cmd_config_thresh_name =
 	TOKEN_STRING_INITIALIZER(struct cmd_config_thresh, name,
 				"txpt#txht#txwt#rxpt#rxht#rxwt");
 cmdline_parse_token_num_t cmd_config_thresh_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_config_thresh, value, UINT8);
+	TOKEN_NUM_INITIALIZER(struct cmd_config_thresh, value, RTE_UINT8);
 
 cmdline_parse_inst_t cmd_config_thresh = {
 	.f = cmd_config_thresh_parsed,
@@ -3539,7 +3570,7 @@ cmdline_parse_token_string_t cmd_config_threshold_name =
 	TOKEN_STRING_INITIALIZER(struct cmd_config_threshold, name,
 						"txfreet#txrst#rxfreet");
 cmdline_parse_token_num_t cmd_config_threshold_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_config_threshold, value, UINT16);
+	TOKEN_NUM_INITIALIZER(struct cmd_config_threshold, value, RTE_UINT16);
 
 cmdline_parse_inst_t cmd_config_threshold = {
 	.f = cmd_config_threshold_parsed,
@@ -3745,7 +3776,7 @@ cmdline_parse_token_string_t cmd_setmask_mask =
 	TOKEN_STRING_INITIALIZER(struct cmd_setmask_result, mask,
 				 "coremask#portmask");
 cmdline_parse_token_num_t cmd_setmask_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_setmask_result, hexavalue, UINT64);
+	TOKEN_NUM_INITIALIZER(struct cmd_setmask_result, hexavalue, RTE_UINT64);
 
 cmdline_parse_inst_t cmd_set_fwd_mask = {
 	.f = cmd_set_mask_parsed,
@@ -3791,7 +3822,7 @@ cmdline_parse_token_string_t cmd_set_what =
 	TOKEN_STRING_INITIALIZER(struct cmd_set_result, what,
 				 "nbport#nbcore#burst#verbose");
 cmdline_parse_token_num_t cmd_set_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_result, value, UINT16);
+	TOKEN_NUM_INITIALIZER(struct cmd_set_result, value, RTE_UINT16);
 
 cmdline_parse_inst_t cmd_set_numbers = {
 	.f = cmd_set_parsed,
@@ -3839,7 +3870,7 @@ cmdline_parse_token_string_t cmd_set_log_log =
 cmdline_parse_token_string_t cmd_set_log_type =
 	TOKEN_STRING_INITIALIZER(struct cmd_set_log_result, type, NULL);
 cmdline_parse_token_num_t cmd_set_log_level =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_log_result, level, UINT32);
+	TOKEN_NUM_INITIALIZER(struct cmd_set_log_result, level, RTE_UINT32);
 
 cmdline_parse_inst_t cmd_set_log = {
 	.f = cmd_set_log_parsed,
@@ -3854,6 +3885,100 @@ cmdline_parse_inst_t cmd_set_log = {
 	},
 };
 
+/* *** SET SEGMENT OFFSETS OF RX PACKETS SPLIT *** */
+
+struct cmd_set_rxoffs_result {
+	cmdline_fixed_string_t cmd_keyword;
+	cmdline_fixed_string_t rxoffs;
+	cmdline_fixed_string_t seg_offsets;
+};
+
+static void
+cmd_set_rxoffs_parsed(void *parsed_result,
+		      __rte_unused struct cmdline *cl,
+		      __rte_unused void *data)
+{
+	struct cmd_set_rxoffs_result *res;
+	unsigned int seg_offsets[MAX_SEGS_BUFFER_SPLIT];
+	unsigned int nb_segs;
+
+	res = parsed_result;
+	nb_segs = parse_item_list(res->seg_offsets, "segment offsets",
+				  MAX_SEGS_BUFFER_SPLIT, seg_offsets, 0);
+	if (nb_segs > 0)
+		set_rx_pkt_offsets(seg_offsets, nb_segs);
+	cmd_reconfig_device_queue(RTE_PORT_ALL, 0, 1);
+}
+
+cmdline_parse_token_string_t cmd_set_rxoffs_keyword =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_rxoffs_result,
+				 cmd_keyword, "set");
+cmdline_parse_token_string_t cmd_set_rxoffs_name =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_rxoffs_result,
+				 rxoffs, "rxoffs");
+cmdline_parse_token_string_t cmd_set_rxoffs_offsets =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_rxoffs_result,
+				 seg_offsets, NULL);
+
+cmdline_parse_inst_t cmd_set_rxoffs = {
+	.f = cmd_set_rxoffs_parsed,
+	.data = NULL,
+	.help_str = "set rxoffs <len0[,len1]*>",
+	.tokens = {
+		(void *)&cmd_set_rxoffs_keyword,
+		(void *)&cmd_set_rxoffs_name,
+		(void *)&cmd_set_rxoffs_offsets,
+		NULL,
+	},
+};
+
+/* *** SET SEGMENT LENGTHS OF RX PACKETS SPLIT *** */
+
+struct cmd_set_rxpkts_result {
+	cmdline_fixed_string_t cmd_keyword;
+	cmdline_fixed_string_t rxpkts;
+	cmdline_fixed_string_t seg_lengths;
+};
+
+static void
+cmd_set_rxpkts_parsed(void *parsed_result,
+		      __rte_unused struct cmdline *cl,
+		      __rte_unused void *data)
+{
+	struct cmd_set_rxpkts_result *res;
+	unsigned int seg_lengths[MAX_SEGS_BUFFER_SPLIT];
+	unsigned int nb_segs;
+
+	res = parsed_result;
+	nb_segs = parse_item_list(res->seg_lengths, "segment lengths",
+				  MAX_SEGS_BUFFER_SPLIT, seg_lengths, 0);
+	if (nb_segs > 0)
+		set_rx_pkt_segments(seg_lengths, nb_segs);
+	cmd_reconfig_device_queue(RTE_PORT_ALL, 0, 1);
+}
+
+cmdline_parse_token_string_t cmd_set_rxpkts_keyword =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_rxpkts_result,
+				 cmd_keyword, "set");
+cmdline_parse_token_string_t cmd_set_rxpkts_name =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_rxpkts_result,
+				 rxpkts, "rxpkts");
+cmdline_parse_token_string_t cmd_set_rxpkts_lengths =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_rxpkts_result,
+				 seg_lengths, NULL);
+
+cmdline_parse_inst_t cmd_set_rxpkts = {
+	.f = cmd_set_rxpkts_parsed,
+	.data = NULL,
+	.help_str = "set rxpkts <len0[,len1]*>",
+	.tokens = {
+		(void *)&cmd_set_rxpkts_keyword,
+		(void *)&cmd_set_rxpkts_name,
+		(void *)&cmd_set_rxpkts_lengths,
+		NULL,
+	},
+};
+
 /* *** SET SEGMENT LENGTHS OF TXONLY PACKETS *** */
 
 struct cmd_set_txpkts_result {
@@ -4019,7 +4144,7 @@ cmdline_parse_token_string_t cmd_rx_vlan_filter_all_all =
 				 all, "all");
 cmdline_parse_token_num_t cmd_rx_vlan_filter_all_portid =
 	TOKEN_NUM_INITIALIZER(struct cmd_rx_vlan_filter_all_result,
-			      port_id, UINT16);
+			      port_id, RTE_UINT16);
 
 cmdline_parse_inst_t cmd_rx_vlan_filter_all = {
 	.f = cmd_rx_vlan_filter_all_parsed,
@@ -4183,10 +4308,10 @@ cmdline_parse_token_string_t cmd_vlan_tpid_what =
 				 what, "tpid");
 cmdline_parse_token_num_t cmd_vlan_tpid_tpid =
 	TOKEN_NUM_INITIALIZER(struct cmd_vlan_tpid_result,
-			      tp_id, UINT16);
+			      tp_id, RTE_UINT16);
 cmdline_parse_token_num_t cmd_vlan_tpid_portid =
 	TOKEN_NUM_INITIALIZER(struct cmd_vlan_tpid_result,
-			      port_id, UINT16);
+			      port_id, RTE_UINT16);
 
 cmdline_parse_inst_t cmd_vlan_tpid = {
 	.f = cmd_vlan_tpid_parsed,
@@ -4233,10 +4358,10 @@ cmdline_parse_token_string_t cmd_rx_vlan_filter_what =
 				 what, "add#rm");
 cmdline_parse_token_num_t cmd_rx_vlan_filter_vlanid =
 	TOKEN_NUM_INITIALIZER(struct cmd_rx_vlan_filter_result,
-			      vlan_id, UINT16);
+			      vlan_id, RTE_UINT16);
 cmdline_parse_token_num_t cmd_rx_vlan_filter_portid =
 	TOKEN_NUM_INITIALIZER(struct cmd_rx_vlan_filter_result,
-			      port_id, UINT16);
+			      port_id, RTE_UINT16);
 
 cmdline_parse_inst_t cmd_rx_vlan_filter = {
 	.f = cmd_rx_vlan_filter_parsed,
@@ -4268,6 +4393,9 @@ cmd_tx_vlan_set_parsed(void *parsed_result,
 {
 	struct cmd_tx_vlan_set_result *res = parsed_result;
 
+	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
+		return;
+
 	if (!port_is_stopped(res->port_id)) {
 		printf("Please stop port %d first\n", res->port_id);
 		return;
@@ -4286,10 +4414,10 @@ cmdline_parse_token_string_t cmd_tx_vlan_set_set =
 				 set, "set");
 cmdline_parse_token_num_t cmd_tx_vlan_set_portid =
 	TOKEN_NUM_INITIALIZER(struct cmd_tx_vlan_set_result,
-			      port_id, UINT16);
+			      port_id, RTE_UINT16);
 cmdline_parse_token_num_t cmd_tx_vlan_set_vlanid =
 	TOKEN_NUM_INITIALIZER(struct cmd_tx_vlan_set_result,
-			      vlan_id, UINT16);
+			      vlan_id, RTE_UINT16);
 
 cmdline_parse_inst_t cmd_tx_vlan_set = {
 	.f = cmd_tx_vlan_set_parsed,
@@ -4322,6 +4450,9 @@ cmd_tx_vlan_set_qinq_parsed(void *parsed_result,
 {
 	struct cmd_tx_vlan_set_qinq_result *res = parsed_result;
 
+	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
+		return;
+
 	if (!port_is_stopped(res->port_id)) {
 		printf("Please stop port %d first\n", res->port_id);
 		return;
@@ -4340,13 +4471,13 @@ cmdline_parse_token_string_t cmd_tx_vlan_set_qinq_set =
 		set, "set");
 cmdline_parse_token_num_t cmd_tx_vlan_set_qinq_portid =
 	TOKEN_NUM_INITIALIZER(struct cmd_tx_vlan_set_qinq_result,
-		port_id, UINT16);
+		port_id, RTE_UINT16);
 cmdline_parse_token_num_t cmd_tx_vlan_set_qinq_vlanid =
 	TOKEN_NUM_INITIALIZER(struct cmd_tx_vlan_set_qinq_result,
-		vlan_id, UINT16);
+		vlan_id, RTE_UINT16);
 cmdline_parse_token_num_t cmd_tx_vlan_set_qinq_vlanid_outer =
 	TOKEN_NUM_INITIALIZER(struct cmd_tx_vlan_set_qinq_result,
-		vlan_id_outer, UINT16);
+		vlan_id_outer, RTE_UINT16);
 
 cmdline_parse_inst_t cmd_tx_vlan_set_qinq = {
 	.f = cmd_tx_vlan_set_qinq_parsed,
@@ -4398,10 +4529,10 @@ cmdline_parse_token_string_t cmd_tx_vlan_set_pvid_pvid =
 				 pvid, "pvid");
 cmdline_parse_token_num_t cmd_tx_vlan_set_pvid_port_id =
 	TOKEN_NUM_INITIALIZER(struct cmd_tx_vlan_set_pvid_result,
-			     port_id, UINT16);
+			     port_id, RTE_UINT16);
 cmdline_parse_token_num_t cmd_tx_vlan_set_pvid_vlan_id =
 	TOKEN_NUM_INITIALIZER(struct cmd_tx_vlan_set_pvid_result,
-			      vlan_id, UINT16);
+			      vlan_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_tx_vlan_set_pvid_mode =
 	TOKEN_STRING_INITIALIZER(struct cmd_tx_vlan_set_pvid_result,
 				 mode, "on#off");
@@ -4435,6 +4566,9 @@ cmd_tx_vlan_reset_parsed(void *parsed_result,
 {
 	struct cmd_tx_vlan_reset_result *res = parsed_result;
 
+	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
+		return;
+
 	if (!port_is_stopped(res->port_id)) {
 		printf("Please stop port %d first\n", res->port_id);
 		return;
@@ -4453,7 +4587,7 @@ cmdline_parse_token_string_t cmd_tx_vlan_reset_reset =
 				 reset, "reset");
 cmdline_parse_token_num_t cmd_tx_vlan_reset_portid =
 	TOKEN_NUM_INITIALIZER(struct cmd_tx_vlan_reset_result,
-			      port_id, UINT16);
+			      port_id, RTE_UINT16);
 
 cmdline_parse_inst_t cmd_tx_vlan_reset = {
 	.f = cmd_tx_vlan_reset_parsed,
@@ -4545,7 +4679,7 @@ cmd_config_queue_tx_offloads(struct rte_port *port)
 	int k;
 
 	/* Apply queue tx offloads configuration */
-	for (k = 0; k < port->dev_info.max_rx_queues; k++)
+	for (k = 0; k < port->dev_info.max_tx_queues; k++)
 		port->tx_conf[k].offloads =
 			port->dev_conf.txmode.offloads;
 }
@@ -4659,7 +4793,7 @@ cmdline_parse_token_string_t cmd_csum_hwsw =
 				hwsw, "hw#sw");
 cmdline_parse_token_num_t cmd_csum_portid =
 	TOKEN_NUM_INITIALIZER(struct cmd_csum_result,
-				port_id, UINT16);
+				port_id, RTE_UINT16);
 
 cmdline_parse_inst_t cmd_csum_set = {
 	.f = cmd_csum_parsed,
@@ -4730,7 +4864,7 @@ cmdline_parse_token_string_t cmd_csum_tunnel_onoff =
 				onoff, "on#off");
 cmdline_parse_token_num_t cmd_csum_tunnel_portid =
 	TOKEN_NUM_INITIALIZER(struct cmd_csum_tunnel_result,
-				port_id, UINT16);
+				port_id, RTE_UINT16);
 
 cmdline_parse_inst_t cmd_csum_tunnel = {
 	.f = cmd_csum_tunnel_parsed,
@@ -4818,10 +4952,10 @@ cmdline_parse_token_string_t cmd_tso_set_mode =
 				mode, "set");
 cmdline_parse_token_num_t cmd_tso_set_tso_segsz =
 	TOKEN_NUM_INITIALIZER(struct cmd_tso_set_result,
-				tso_segsz, UINT16);
+				tso_segsz, RTE_UINT16);
 cmdline_parse_token_num_t cmd_tso_set_portid =
 	TOKEN_NUM_INITIALIZER(struct cmd_tso_set_result,
-				port_id, UINT16);
+				port_id, RTE_UINT16);
 
 cmdline_parse_inst_t cmd_tso_set = {
 	.f = cmd_tso_set_parsed,
@@ -4967,10 +5101,10 @@ cmdline_parse_token_string_t cmd_tunnel_tso_set_mode =
 				mode, "set");
 cmdline_parse_token_num_t cmd_tunnel_tso_set_tso_segsz =
 	TOKEN_NUM_INITIALIZER(struct cmd_tunnel_tso_set_result,
-				tso_segsz, UINT16);
+				tso_segsz, RTE_UINT16);
 cmdline_parse_token_num_t cmd_tunnel_tso_set_portid =
 	TOKEN_NUM_INITIALIZER(struct cmd_tunnel_tso_set_result,
-				port_id, UINT16);
+				port_id, RTE_UINT16);
 
 cmdline_parse_inst_t cmd_tunnel_tso_set = {
 	.f = cmd_tunnel_tso_set_parsed,
@@ -5034,7 +5168,7 @@ cmdline_parse_token_string_t cmd_gro_enable_port =
 			cmd_keyword, "port");
 cmdline_parse_token_num_t cmd_gro_enable_pid =
 	TOKEN_NUM_INITIALIZER(struct cmd_gro_enable_result,
-			cmd_pid, UINT16);
+			cmd_pid, RTE_UINT16);
 cmdline_parse_token_string_t cmd_gro_enable_keyword =
 	TOKEN_STRING_INITIALIZER(struct cmd_gro_enable_result,
 			cmd_keyword, "gro");
@@ -5084,7 +5218,7 @@ cmdline_parse_token_string_t cmd_gro_show_port =
 			cmd_port, "port");
 cmdline_parse_token_num_t cmd_gro_show_pid =
 	TOKEN_NUM_INITIALIZER(struct cmd_gro_show_result,
-			cmd_pid, UINT16);
+			cmd_pid, RTE_UINT16);
 cmdline_parse_token_string_t cmd_gro_show_keyword =
 	TOKEN_STRING_INITIALIZER(struct cmd_gro_show_result,
 			cmd_keyword, "gro");
@@ -5134,7 +5268,7 @@ cmdline_parse_token_string_t cmd_gro_flush_flush =
 			cmd_flush, "flush");
 cmdline_parse_token_num_t cmd_gro_flush_cycles =
 	TOKEN_NUM_INITIALIZER(struct cmd_gro_flush_result,
-			cmd_cycles, UINT8);
+			cmd_cycles, RTE_UINT8);
 
 cmdline_parse_inst_t cmd_gro_flush = {
 	.f = cmd_gro_flush_parsed,
@@ -5184,7 +5318,7 @@ cmdline_parse_token_string_t cmd_gso_enable_mode =
 			cmd_mode, "on#off");
 cmdline_parse_token_num_t cmd_gso_enable_pid =
 	TOKEN_NUM_INITIALIZER(struct cmd_gso_enable_result,
-			cmd_pid, UINT16);
+			cmd_pid, RTE_UINT16);
 
 cmdline_parse_inst_t cmd_gso_enable = {
 	.f = cmd_gso_enable_parsed,
@@ -5243,7 +5377,7 @@ cmdline_parse_token_string_t cmd_gso_size_segsz =
 				cmd_segsz, "segsz");
 cmdline_parse_token_num_t cmd_gso_size_size =
 	TOKEN_NUM_INITIALIZER(struct cmd_gso_size_result,
-				cmd_size, UINT16);
+				cmd_size, RTE_UINT16);
 
 cmdline_parse_inst_t cmd_gso_size = {
 	.f = cmd_gso_size_parsed,
@@ -5301,7 +5435,7 @@ cmdline_parse_token_string_t cmd_gso_show_keyword =
 				cmd_keyword, "gso");
 cmdline_parse_token_num_t cmd_gso_show_pid =
 	TOKEN_NUM_INITIALIZER(struct cmd_gso_show_result,
-				cmd_pid, UINT16);
+				cmd_pid, RTE_UINT16);
 
 cmdline_parse_inst_t cmd_gso_show = {
 	.f = cmd_gso_show_parsed,
@@ -5413,7 +5547,7 @@ cmd_set_bypass_mode_parsed(void *parsed_result,
 	portid_t port_id = res->port_id;
 	int32_t rc = -EINVAL;
 
-#if defined RTE_LIBRTE_IXGBE_PMD && defined RTE_LIBRTE_IXGBE_BYPASS
+#if defined RTE_NET_IXGBE && defined RTE_LIBRTE_IXGBE_BYPASS
 	uint32_t bypass_mode = RTE_PMD_IXGBE_BYPASS_MODE_NORMAL;
 
 	if (!strcmp(res->value, "bypass"))
@@ -5444,7 +5578,7 @@ cmdline_parse_token_string_t cmd_setbypass_mode_value =
 			value, "normal#bypass#isolate");
 cmdline_parse_token_num_t cmd_setbypass_mode_port =
 	TOKEN_NUM_INITIALIZER(struct cmd_set_bypass_mode_result,
-				port_id, UINT16);
+				port_id, RTE_UINT16);
 
 cmdline_parse_inst_t cmd_set_bypass_mode = {
 	.f = cmd_set_bypass_mode_parsed,
@@ -5481,7 +5615,7 @@ cmd_set_bypass_event_parsed(void *parsed_result,
 	struct cmd_set_bypass_event_result *res = parsed_result;
 	portid_t port_id = res->port_id;
 
-#if defined RTE_LIBRTE_IXGBE_PMD && defined RTE_LIBRTE_IXGBE_BYPASS
+#if defined RTE_NET_IXGBE && defined RTE_LIBRTE_IXGBE_BYPASS
 	uint32_t bypass_event = RTE_PMD_IXGBE_BYPASS_EVENT_NONE;
 	uint32_t bypass_mode = RTE_PMD_IXGBE_BYPASS_MODE_NORMAL;
 
@@ -5550,7 +5684,7 @@ cmdline_parse_token_string_t cmd_setbypass_event_mode_value =
 			mode_value, "normal#bypass#isolate");
 cmdline_parse_token_num_t cmd_setbypass_event_port =
 	TOKEN_NUM_INITIALIZER(struct cmd_set_bypass_event_result,
-				port_id, UINT16);
+				port_id, RTE_UINT16);
 
 cmdline_parse_inst_t cmd_set_bypass_event = {
 	.f = cmd_set_bypass_event_parsed,
@@ -5586,7 +5720,7 @@ cmd_set_bypass_timeout_parsed(void *parsed_result,
 {
 	__rte_unused struct cmd_set_bypass_timeout_result *res = parsed_result;
 
-#if defined RTE_LIBRTE_IXGBE_PMD && defined RTE_LIBRTE_IXGBE_BYPASS
+#if defined RTE_NET_IXGBE && defined RTE_LIBRTE_IXGBE_BYPASS
 	if (!strcmp(res->value, "1.5"))
 		bypass_timeout = RTE_PMD_IXGBE_BYPASS_TMT_1_5_SEC;
 	else if (!strcmp(res->value, "2"))
@@ -5649,7 +5783,7 @@ cmd_show_bypass_config_parsed(void *parsed_result,
 	struct cmd_show_bypass_config_result *res = parsed_result;
 	portid_t port_id = res->port_id;
 	int rc = -EINVAL;
-#if defined RTE_LIBRTE_IXGBE_PMD && defined RTE_LIBRTE_IXGBE_BYPASS
+#if defined RTE_NET_IXGBE && defined RTE_LIBRTE_IXGBE_BYPASS
 	uint32_t event_mode;
 	uint32_t bypass_mode;
 	uint32_t timeout = bypass_timeout;
@@ -5716,7 +5850,7 @@ cmdline_parse_token_string_t cmd_showbypass_config_config =
 			config, "config");
 cmdline_parse_token_num_t cmd_showbypass_config_port =
 	TOKEN_NUM_INITIALIZER(struct cmd_show_bypass_config_result,
-				port_id, UINT16);
+				port_id, RTE_UINT16);
 
 cmdline_parse_inst_t cmd_show_bypass_config = {
 	.f = cmd_show_bypass_config_parsed,
@@ -5732,7 +5866,7 @@ cmdline_parse_inst_t cmd_show_bypass_config = {
 	},
 };
 
-#ifdef RTE_LIBRTE_PMD_BOND
+#ifdef RTE_NET_BOND
 /* *** SET BONDING MODE *** */
 struct cmd_set_bonding_mode_result {
 	cmdline_fixed_string_t set;
@@ -5765,10 +5899,10 @@ TOKEN_STRING_INITIALIZER(struct cmd_set_bonding_mode_result,
 		mode, "mode");
 cmdline_parse_token_num_t cmd_setbonding_mode_value =
 TOKEN_NUM_INITIALIZER(struct cmd_set_bonding_mode_result,
-		value, UINT8);
+		value, RTE_UINT8);
 cmdline_parse_token_num_t cmd_setbonding_mode_port =
 TOKEN_NUM_INITIALIZER(struct cmd_set_bonding_mode_result,
-		port_id, UINT16);
+		port_id, RTE_UINT16);
 
 cmdline_parse_inst_t cmd_set_bonding_mode = {
 		.f = cmd_set_bonding_mode_parsed,
@@ -5842,7 +5976,7 @@ TOKEN_STRING_INITIALIZER(struct cmd_set_bonding_lacp_dedicated_queues_result,
 		dedicated_queues, "dedicated_queues");
 cmdline_parse_token_num_t cmd_setbonding_lacp_dedicated_queues_port_id =
 TOKEN_NUM_INITIALIZER(struct cmd_set_bonding_lacp_dedicated_queues_result,
-		port_id, UINT16);
+		port_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_setbonding_lacp_dedicated_queues_mode =
 TOKEN_STRING_INITIALIZER(struct cmd_set_bonding_lacp_dedicated_queues_result,
 		mode, "enable#disable");
@@ -5910,7 +6044,7 @@ TOKEN_STRING_INITIALIZER(struct cmd_set_bonding_balance_xmit_policy_result,
 		balance_xmit_policy, "balance_xmit_policy");
 cmdline_parse_token_num_t cmd_setbonding_balance_xmit_policy_port =
 TOKEN_NUM_INITIALIZER(struct cmd_set_bonding_balance_xmit_policy_result,
-		port_id, UINT16);
+		port_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_setbonding_balance_xmit_policy_policy =
 TOKEN_STRING_INITIALIZER(struct cmd_set_bonding_balance_xmit_policy_result,
 		policy, "l2#l23#l34");
@@ -6058,7 +6192,7 @@ TOKEN_STRING_INITIALIZER(struct cmd_show_bonding_config_result,
 		config, "config");
 cmdline_parse_token_num_t cmd_showbonding_config_port =
 TOKEN_NUM_INITIALIZER(struct cmd_show_bonding_config_result,
-		port_id, UINT16);
+		port_id, RTE_UINT16);
 
 cmdline_parse_inst_t cmd_show_bonding_config = {
 		.f = cmd_show_bonding_config_parsed,
@@ -6111,10 +6245,10 @@ TOKEN_STRING_INITIALIZER(struct cmd_set_bonding_primary_result,
 		primary, "primary");
 cmdline_parse_token_num_t cmd_setbonding_primary_slave =
 TOKEN_NUM_INITIALIZER(struct cmd_set_bonding_primary_result,
-		slave_id, UINT16);
+		slave_id, RTE_UINT16);
 cmdline_parse_token_num_t cmd_setbonding_primary_port =
 TOKEN_NUM_INITIALIZER(struct cmd_set_bonding_primary_result,
-		port_id, UINT16);
+		port_id, RTE_UINT16);
 
 cmdline_parse_inst_t cmd_set_bonding_primary = {
 		.f = cmd_set_bonding_primary_parsed,
@@ -6169,10 +6303,10 @@ TOKEN_STRING_INITIALIZER(struct cmd_add_bonding_slave_result,
 		slave, "slave");
 cmdline_parse_token_num_t cmd_addbonding_slave_slaveid =
 TOKEN_NUM_INITIALIZER(struct cmd_add_bonding_slave_result,
-		slave_id, UINT16);
+		slave_id, RTE_UINT16);
 cmdline_parse_token_num_t cmd_addbonding_slave_port =
 TOKEN_NUM_INITIALIZER(struct cmd_add_bonding_slave_result,
-		port_id, UINT16);
+		port_id, RTE_UINT16);
 
 cmdline_parse_inst_t cmd_add_bonding_slave = {
 		.f = cmd_add_bonding_slave_parsed,
@@ -6227,10 +6361,10 @@ cmdline_parse_token_string_t cmd_removebonding_slave_slave =
 				slave, "slave");
 cmdline_parse_token_num_t cmd_removebonding_slave_slaveid =
 		TOKEN_NUM_INITIALIZER(struct cmd_remove_bonding_slave_result,
-				slave_id, UINT16);
+				slave_id, RTE_UINT16);
 cmdline_parse_token_num_t cmd_removebonding_slave_port =
 		TOKEN_NUM_INITIALIZER(struct cmd_remove_bonding_slave_result,
-				port_id, UINT16);
+				port_id, RTE_UINT16);
 
 cmdline_parse_inst_t cmd_remove_bonding_slave = {
 		.f = cmd_remove_bonding_slave_parsed,
@@ -6309,10 +6443,10 @@ cmdline_parse_token_string_t cmd_createbonded_device_device =
 				device, "device");
 cmdline_parse_token_num_t cmd_createbonded_device_mode =
 		TOKEN_NUM_INITIALIZER(struct cmd_create_bonded_device_result,
-				mode, UINT8);
+				mode, RTE_UINT8);
 cmdline_parse_token_num_t cmd_createbonded_device_socket =
 		TOKEN_NUM_INITIALIZER(struct cmd_create_bonded_device_result,
-				socket, UINT8);
+				socket, RTE_UINT8);
 
 cmdline_parse_inst_t cmd_create_bonded_device = {
 		.f = cmd_create_bonded_device_parsed,
@@ -6365,7 +6499,7 @@ cmdline_parse_token_string_t cmd_set_bond_mac_addr_mac =
 				"mac_addr");
 cmdline_parse_token_num_t cmd_set_bond_mac_addr_portnum =
 		TOKEN_NUM_INITIALIZER(struct cmd_set_bond_mac_addr_result,
-				port_num, UINT16);
+				port_num, RTE_UINT16);
 cmdline_parse_token_etheraddr_t cmd_set_bond_mac_addr_addr =
 		TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_bond_mac_addr_result, address);
 
@@ -6418,10 +6552,10 @@ cmdline_parse_token_string_t cmd_set_bond_mon_period_mon_period =
 				mon_period,	"mon_period");
 cmdline_parse_token_num_t cmd_set_bond_mon_period_portnum =
 		TOKEN_NUM_INITIALIZER(struct cmd_set_bond_mon_period_result,
-				port_num, UINT16);
+				port_num, RTE_UINT16);
 cmdline_parse_token_num_t cmd_set_bond_mon_period_period_ms =
 		TOKEN_NUM_INITIALIZER(struct cmd_set_bond_mon_period_result,
-				period_ms, UINT32);
+				period_ms, RTE_UINT32);
 
 cmdline_parse_inst_t cmd_set_bond_mon_period = {
 		.f = cmd_set_bond_mon_period_parsed,
@@ -6480,7 +6614,7 @@ cmdline_parse_token_string_t cmd_set_bonding_agg_mode_agg_mode =
 
 cmdline_parse_token_num_t cmd_set_bonding_agg_mode_portnum =
 	TOKEN_NUM_INITIALIZER(struct cmd_set_bonding_agg_mode_policy_result,
-				port_num, UINT16);
+				port_num, RTE_UINT16);
 
 cmdline_parse_token_string_t cmd_set_bonding_agg_mode_policy_string =
 	TOKEN_STRING_INITIALIZER(
@@ -6502,7 +6636,7 @@ cmdline_parse_inst_t cmd_set_bonding_agg_mode_policy = {
 };
 
 
-#endif /* RTE_LIBRTE_PMD_BOND */
+#endif /* RTE_NET_BOND */
 
 /* *** SET FORWARDING MODE *** */
 struct cmd_set_fwd_mode_result {
@@ -6668,11 +6802,13 @@ cmdline_parse_token_string_t cmd_set_burst_tx_retry_tx =
 cmdline_parse_token_string_t cmd_set_burst_tx_retry_delay =
 	TOKEN_STRING_INITIALIZER(struct cmd_set_burst_tx_retry_result, delay, "delay");
 cmdline_parse_token_num_t cmd_set_burst_tx_retry_time =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_burst_tx_retry_result, time, UINT32);
+	TOKEN_NUM_INITIALIZER(struct cmd_set_burst_tx_retry_result, time,
+				 RTE_UINT32);
 cmdline_parse_token_string_t cmd_set_burst_tx_retry_retry =
 	TOKEN_STRING_INITIALIZER(struct cmd_set_burst_tx_retry_result, retry, "retry");
 cmdline_parse_token_num_t cmd_set_burst_tx_retry_retry_num =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_burst_tx_retry_result, retry_num, UINT32);
+	TOKEN_NUM_INITIALIZER(struct cmd_set_burst_tx_retry_result, retry_num,
+				 RTE_UINT32);
 
 cmdline_parse_inst_t cmd_set_burst_tx_retry = {
 	.f = cmd_set_burst_tx_retry_parsed,
@@ -6730,7 +6866,7 @@ cmdline_parse_token_string_t cmd_setpromisc_portall =
 				 "all");
 cmdline_parse_token_num_t cmd_setpromisc_portnum =
 	TOKEN_NUM_INITIALIZER(struct cmd_set_promisc_mode_result, port_num,
-			      UINT16);
+			      RTE_UINT16);
 cmdline_parse_token_string_t cmd_setpromisc_mode =
 	TOKEN_STRING_INITIALIZER(struct cmd_set_promisc_mode_result, mode,
 				 "on#off");
@@ -6804,7 +6940,7 @@ cmdline_parse_token_string_t cmd_setallmulti_portall =
 				 "all");
 cmdline_parse_token_num_t cmd_setallmulti_portnum =
 	TOKEN_NUM_INITIALIZER(struct cmd_set_allmulti_mode_result, port_num,
-			      UINT16);
+			      RTE_UINT16);
 cmdline_parse_token_string_t cmd_setallmulti_mode =
 	TOKEN_STRING_INITIALIZER(struct cmd_set_allmulti_mode_result, mode,
 				 "on#off");
@@ -6836,6 +6972,80 @@ cmdline_parse_inst_t cmd_set_allmulti_mode_one = {
 	},
 };
 
+/* *** GET CURRENT ETHERNET LINK FLOW CONTROL *** */
+struct cmd_link_flow_ctrl_show {
+	cmdline_fixed_string_t show;
+	cmdline_fixed_string_t port;
+	portid_t port_id;
+	cmdline_fixed_string_t flow_ctrl;
+};
+
+cmdline_parse_token_string_t cmd_lfc_show_show =
+	TOKEN_STRING_INITIALIZER(struct cmd_link_flow_ctrl_show,
+				show, "show");
+cmdline_parse_token_string_t cmd_lfc_show_port =
+	TOKEN_STRING_INITIALIZER(struct cmd_link_flow_ctrl_show,
+				port, "port");
+cmdline_parse_token_num_t cmd_lfc_show_portid =
+	TOKEN_NUM_INITIALIZER(struct cmd_link_flow_ctrl_show,
+				port_id, RTE_UINT16);
+cmdline_parse_token_string_t cmd_lfc_show_flow_ctrl =
+	TOKEN_STRING_INITIALIZER(struct cmd_link_flow_ctrl_show,
+				flow_ctrl, "flow_ctrl");
+
+static void
+cmd_link_flow_ctrl_show_parsed(void *parsed_result,
+			      __rte_unused struct cmdline *cl,
+			      __rte_unused void *data)
+{
+	struct cmd_link_flow_ctrl_show *res = parsed_result;
+	static const char *info_border = "*********************";
+	struct rte_eth_fc_conf fc_conf;
+	bool rx_fc_en = false;
+	bool tx_fc_en = false;
+	int ret;
+
+	ret = rte_eth_dev_flow_ctrl_get(res->port_id, &fc_conf);
+	if (ret != 0) {
+		printf("Failed to get current flow ctrl information: err = %d\n",
+		       ret);
+		return;
+	}
+
+	if (fc_conf.mode == RTE_FC_RX_PAUSE || fc_conf.mode == RTE_FC_FULL)
+		rx_fc_en = true;
+	if (fc_conf.mode == RTE_FC_TX_PAUSE || fc_conf.mode == RTE_FC_FULL)
+		tx_fc_en = true;
+
+	printf("\n%s Flow control infos for port %-2d %s\n",
+		info_border, res->port_id, info_border);
+	printf("FC mode:\n");
+	printf("   Rx pause: %s\n", rx_fc_en ? "on" : "off");
+	printf("   Tx pause: %s\n", tx_fc_en ? "on" : "off");
+	printf("Autoneg: %s\n", fc_conf.autoneg ? "on" : "off");
+	printf("Pause time: 0x%x\n", fc_conf.pause_time);
+	printf("High waterline: 0x%x\n", fc_conf.high_water);
+	printf("Low waterline: 0x%x\n", fc_conf.low_water);
+	printf("Send XON: %s\n", fc_conf.send_xon ? "on" : "off");
+	printf("Forward MAC control frames: %s\n",
+		fc_conf.mac_ctrl_frame_fwd ? "on" : "off");
+	printf("\n%s**************   End  ***********%s\n",
+		info_border, info_border);
+}
+
+cmdline_parse_inst_t cmd_link_flow_control_show = {
+	.f = cmd_link_flow_ctrl_show_parsed,
+	.data = NULL,
+	.help_str = "show port <port_id> flow_ctrl",
+	.tokens = {
+		(void *)&cmd_lfc_show_show,
+		(void *)&cmd_lfc_show_port,
+		(void *)&cmd_lfc_show_portid,
+		(void *)&cmd_lfc_show_flow_ctrl,
+		NULL,
+	},
+};
+
 /* *** SETUP ETHERNET LINK FLOW CONTROL *** */
 struct cmd_link_flow_ctrl_set_result {
 	cmdline_fixed_string_t set;
@@ -6882,25 +7092,25 @@ cmdline_parse_token_string_t cmd_lfc_set_high_water_str =
 				hw_str, "high_water");
 cmdline_parse_token_num_t cmd_lfc_set_high_water =
 	TOKEN_NUM_INITIALIZER(struct cmd_link_flow_ctrl_set_result,
-				high_water, UINT32);
+				high_water, RTE_UINT32);
 cmdline_parse_token_string_t cmd_lfc_set_low_water_str =
 	TOKEN_STRING_INITIALIZER(struct cmd_link_flow_ctrl_set_result,
 				lw_str, "low_water");
 cmdline_parse_token_num_t cmd_lfc_set_low_water =
 	TOKEN_NUM_INITIALIZER(struct cmd_link_flow_ctrl_set_result,
-				low_water, UINT32);
+				low_water, RTE_UINT32);
 cmdline_parse_token_string_t cmd_lfc_set_pause_time_str =
 	TOKEN_STRING_INITIALIZER(struct cmd_link_flow_ctrl_set_result,
 				pt_str, "pause_time");
 cmdline_parse_token_num_t cmd_lfc_set_pause_time =
 	TOKEN_NUM_INITIALIZER(struct cmd_link_flow_ctrl_set_result,
-				pause_time, UINT16);
+				pause_time, RTE_UINT16);
 cmdline_parse_token_string_t cmd_lfc_set_send_xon_str =
 	TOKEN_STRING_INITIALIZER(struct cmd_link_flow_ctrl_set_result,
 				xon_str, "send_xon");
 cmdline_parse_token_num_t cmd_lfc_set_send_xon =
 	TOKEN_NUM_INITIALIZER(struct cmd_link_flow_ctrl_set_result,
-				send_xon, UINT16);
+				send_xon, RTE_UINT16);
 cmdline_parse_token_string_t cmd_lfc_set_mac_ctrl_frame_fwd_mode =
 	TOKEN_STRING_INITIALIZER(struct cmd_link_flow_ctrl_set_result,
 				mac_ctrl_frame_fwd, "mac_ctrl_frame_fwd");
@@ -6915,7 +7125,7 @@ cmdline_parse_token_string_t cmd_lfc_set_autoneg =
 				autoneg, "on#off");
 cmdline_parse_token_num_t cmd_lfc_set_portid =
 	TOKEN_NUM_INITIALIZER(struct cmd_link_flow_ctrl_set_result,
-				port_id, UINT16);
+				port_id, RTE_UINT16);
 
 /* forward declaration */
 static void
@@ -7211,19 +7421,19 @@ cmdline_parse_token_string_t cmd_pfc_set_tx_mode =
 				tx_pfc_mode, "on#off");
 cmdline_parse_token_num_t cmd_pfc_set_high_water =
 	TOKEN_NUM_INITIALIZER(struct cmd_priority_flow_ctrl_set_result,
-				high_water, UINT32);
+				high_water, RTE_UINT32);
 cmdline_parse_token_num_t cmd_pfc_set_low_water =
 	TOKEN_NUM_INITIALIZER(struct cmd_priority_flow_ctrl_set_result,
-				low_water, UINT32);
+				low_water, RTE_UINT32);
 cmdline_parse_token_num_t cmd_pfc_set_pause_time =
 	TOKEN_NUM_INITIALIZER(struct cmd_priority_flow_ctrl_set_result,
-				pause_time, UINT16);
+				pause_time, RTE_UINT16);
 cmdline_parse_token_num_t cmd_pfc_set_priority =
 	TOKEN_NUM_INITIALIZER(struct cmd_priority_flow_ctrl_set_result,
-				priority, UINT8);
+				priority, RTE_UINT8);
 cmdline_parse_token_num_t cmd_pfc_set_portid =
 	TOKEN_NUM_INITIALIZER(struct cmd_priority_flow_ctrl_set_result,
-				port_id, UINT16);
+				port_id, RTE_UINT16);
 
 cmdline_parse_inst_t cmd_priority_flow_control_set = {
 	.f = cmd_priority_flow_ctrl_set_parsed,
@@ -7361,7 +7571,7 @@ cmdline_parse_token_string_t cmd_start_tx_first_n_tx_first =
 			tx_first, "tx_first");
 cmdline_parse_token_num_t cmd_start_tx_first_n_tx_num =
 	TOKEN_NUM_INITIALIZER(struct cmd_start_tx_first_n_result,
-			tx_num, UINT32);
+			tx_num, RTE_UINT32);
 
 cmdline_parse_inst_t cmd_start_tx_first_n = {
 	.f = cmd_start_tx_first_n_parsed,
@@ -7392,7 +7602,8 @@ cmdline_parse_token_string_t cmd_set_link_up_link_up =
 cmdline_parse_token_string_t cmd_set_link_up_port =
 	TOKEN_STRING_INITIALIZER(struct cmd_set_link_up_result, port, "port");
 cmdline_parse_token_num_t cmd_set_link_up_port_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_link_up_result, port_id, UINT16);
+	TOKEN_NUM_INITIALIZER(struct cmd_set_link_up_result, port_id,
+				RTE_UINT16);
 
 static void cmd_set_link_up_parsed(__rte_unused void *parsed_result,
 			     __rte_unused struct cmdline *cl,
@@ -7431,7 +7642,8 @@ cmdline_parse_token_string_t cmd_set_link_down_link_down =
 cmdline_parse_token_string_t cmd_set_link_down_port =
 	TOKEN_STRING_INITIALIZER(struct cmd_set_link_down_result, port, "port");
 cmdline_parse_token_num_t cmd_set_link_down_port_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_link_down_result, port_id, UINT16);
+	TOKEN_NUM_INITIALIZER(struct cmd_set_link_down_result, port_id,
+				RTE_UINT16);
 
 static void cmd_set_link_down_parsed(
 				__rte_unused void *parsed_result,
@@ -7473,6 +7685,10 @@ static void cmd_showcfg_parsed(void *parsed_result,
 		fwd_lcores_config_display();
 	else if (!strcmp(res->what, "fwd"))
 		pkt_fwd_config_display(&cur_fwd_config);
+	else if (!strcmp(res->what, "rxoffs"))
+		show_rx_pkt_offsets();
+	else if (!strcmp(res->what, "rxpkts"))
+		show_rx_pkt_segments();
 	else if (!strcmp(res->what, "txpkts"))
 		show_tx_pkt_segments();
 	else if (!strcmp(res->what, "txtimes"))
@@ -7485,12 +7701,12 @@ cmdline_parse_token_string_t cmd_showcfg_port =
 	TOKEN_STRING_INITIALIZER(struct cmd_showcfg_result, cfg, "config");
 cmdline_parse_token_string_t cmd_showcfg_what =
 	TOKEN_STRING_INITIALIZER(struct cmd_showcfg_result, what,
-				 "rxtx#cores#fwd#txpkts#txtimes");
+				 "rxtx#cores#fwd#rxoffs#rxpkts#txpkts#txtimes");
 
 cmdline_parse_inst_t cmd_showcfg = {
 	.f = cmd_showcfg_parsed,
 	.data = NULL,
-	.help_str = "show config rxtx|cores|fwd|txpkts|txtimes",
+	.help_str = "show config rxtx|cores|fwd|rxoffs|rxpkts|txpkts|txtimes",
 	.tokens = {
 		(void *)&cmd_showcfg_show,
 		(void *)&cmd_showcfg_port,
@@ -7535,18 +7751,14 @@ static void cmd_showportall_parsed(void *parsed_result,
 	else if (!strcmp(res->what, "xstats"))
 		RTE_ETH_FOREACH_DEV(i)
 			nic_xstats_display(i);
+#if defined(RTE_NET_I40E) || defined(RTE_NET_IXGBE)
 	else if (!strcmp(res->what, "fdir"))
 		RTE_ETH_FOREACH_DEV(i)
 			fdir_get_infos(i);
-	else if (!strcmp(res->what, "stat_qmap"))
-		RTE_ETH_FOREACH_DEV(i)
-			nic_stats_mapping_display(i);
+#endif
 	else if (!strcmp(res->what, "dcb_tc"))
 		RTE_ETH_FOREACH_DEV(i)
 			port_dcb_info_display(i);
-	else if (!strcmp(res->what, "cap"))
-		RTE_ETH_FOREACH_DEV(i)
-			port_offload_cap_display(i);
 }
 
 cmdline_parse_token_string_t cmd_showportall_show =
@@ -7556,14 +7768,14 @@ cmdline_parse_token_string_t cmd_showportall_port =
 	TOKEN_STRING_INITIALIZER(struct cmd_showportall_result, port, "port");
 cmdline_parse_token_string_t cmd_showportall_what =
 	TOKEN_STRING_INITIALIZER(struct cmd_showportall_result, what,
-				 "info#summary#stats#xstats#fdir#stat_qmap#dcb_tc#cap");
+				 "info#summary#stats#xstats#fdir#dcb_tc");
 cmdline_parse_token_string_t cmd_showportall_all =
 	TOKEN_STRING_INITIALIZER(struct cmd_showportall_result, all, "all");
 cmdline_parse_inst_t cmd_showportall = {
 	.f = cmd_showportall_parsed,
 	.data = NULL,
 	.help_str = "show|clear port "
-		"info|summary|stats|xstats|fdir|stat_qmap|dcb_tc|cap all",
+		"info|summary|stats|xstats|fdir|dcb_tc all",
 	.tokens = {
 		(void *)&cmd_showportall_show,
 		(void *)&cmd_showportall_port,
@@ -7601,14 +7813,12 @@ static void cmd_showport_parsed(void *parsed_result,
 		nic_stats_display(res->portnum);
 	else if (!strcmp(res->what, "xstats"))
 		nic_xstats_display(res->portnum);
+#if defined(RTE_NET_I40E) || defined(RTE_NET_IXGBE)
 	else if (!strcmp(res->what, "fdir"))
 		 fdir_get_infos(res->portnum);
-	else if (!strcmp(res->what, "stat_qmap"))
-		nic_stats_mapping_display(res->portnum);
+#endif
 	else if (!strcmp(res->what, "dcb_tc"))
 		port_dcb_info_display(res->portnum);
-	else if (!strcmp(res->what, "cap"))
-		port_offload_cap_display(res->portnum);
 }
 
 cmdline_parse_token_string_t cmd_showport_show =
@@ -7618,15 +7828,15 @@ cmdline_parse_token_string_t cmd_showport_port =
 	TOKEN_STRING_INITIALIZER(struct cmd_showport_result, port, "port");
 cmdline_parse_token_string_t cmd_showport_what =
 	TOKEN_STRING_INITIALIZER(struct cmd_showport_result, what,
-				 "info#summary#stats#xstats#fdir#stat_qmap#dcb_tc#cap");
+				 "info#summary#stats#xstats#fdir#dcb_tc");
 cmdline_parse_token_num_t cmd_showport_portnum =
-	TOKEN_NUM_INITIALIZER(struct cmd_showport_result, portnum, UINT16);
+	TOKEN_NUM_INITIALIZER(struct cmd_showport_result, portnum, RTE_UINT16);
 
 cmdline_parse_inst_t cmd_showport = {
 	.f = cmd_showport_parsed,
 	.data = NULL,
 	.help_str = "show|clear port "
-		"info|summary|stats|xstats|fdir|stat_qmap|dcb_tc|cap "
+		"info|summary|stats|xstats|fdir|dcb_tc "
 		"<port_id>",
 	.tokens = {
 		(void *)&cmd_showport_show,
@@ -7682,6 +7892,52 @@ cmdline_parse_inst_t cmd_showdevice = {
 		NULL,
 	},
 };
+
+/* *** SHOW MODULE EEPROM/EEPROM port INFO *** */
+struct cmd_showeeprom_result {
+	cmdline_fixed_string_t show;
+	cmdline_fixed_string_t port;
+	uint16_t portnum;
+	cmdline_fixed_string_t type;
+};
+
+static void cmd_showeeprom_parsed(void *parsed_result,
+		__rte_unused struct cmdline *cl,
+		__rte_unused void *data)
+{
+	struct cmd_showeeprom_result *res = parsed_result;
+
+	if (!strcmp(res->type, "eeprom"))
+		port_eeprom_display(res->portnum);
+	else if (!strcmp(res->type, "module_eeprom"))
+		port_module_eeprom_display(res->portnum);
+	else
+		printf("Unknown argument\n");
+}
+
+cmdline_parse_token_string_t cmd_showeeprom_show =
+	TOKEN_STRING_INITIALIZER(struct cmd_showeeprom_result, show, "show");
+cmdline_parse_token_string_t cmd_showeeprom_port =
+	TOKEN_STRING_INITIALIZER(struct cmd_showeeprom_result, port, "port");
+cmdline_parse_token_num_t cmd_showeeprom_portnum =
+	TOKEN_NUM_INITIALIZER(struct cmd_showeeprom_result, portnum,
+			RTE_UINT16);
+cmdline_parse_token_string_t cmd_showeeprom_type =
+	TOKEN_STRING_INITIALIZER(struct cmd_showeeprom_result, type, "module_eeprom#eeprom");
+
+cmdline_parse_inst_t cmd_showeeprom = {
+	.f = cmd_showeeprom_parsed,
+	.data = NULL,
+	.help_str = "show port <port_id> module_eeprom|eeprom",
+	.tokens = {
+		(void *)&cmd_showeeprom_show,
+		(void *)&cmd_showeeprom_port,
+		(void *)&cmd_showeeprom_portnum,
+		(void *)&cmd_showeeprom_type,
+		NULL,
+	},
+};
+
 /* *** SHOW QUEUE INFO *** */
 struct cmd_showqueue_result {
 	cmdline_fixed_string_t show;
@@ -7711,9 +7967,11 @@ cmdline_parse_token_string_t cmd_showqueue_type =
 cmdline_parse_token_string_t cmd_showqueue_what =
 	TOKEN_STRING_INITIALIZER(struct cmd_showqueue_result, what, "info");
 cmdline_parse_token_num_t cmd_showqueue_portnum =
-	TOKEN_NUM_INITIALIZER(struct cmd_showqueue_result, portnum, UINT16);
+	TOKEN_NUM_INITIALIZER(struct cmd_showqueue_result, portnum,
+		RTE_UINT16);
 cmdline_parse_token_num_t cmd_showqueue_queuenum =
-	TOKEN_NUM_INITIALIZER(struct cmd_showqueue_result, queuenum, UINT16);
+	TOKEN_NUM_INITIALIZER(struct cmd_showqueue_result, queuenum,
+		RTE_UINT16);
 
 cmdline_parse_inst_t cmd_showqueue = {
 	.f = cmd_showqueue_parsed,
@@ -7794,9 +8052,9 @@ cmdline_parse_token_string_t cmd_read_reg_read =
 cmdline_parse_token_string_t cmd_read_reg_reg =
 	TOKEN_STRING_INITIALIZER(struct cmd_read_reg_result, reg, "reg");
 cmdline_parse_token_num_t cmd_read_reg_port_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_read_reg_result, port_id, UINT16);
+	TOKEN_NUM_INITIALIZER(struct cmd_read_reg_result, port_id, RTE_UINT16);
 cmdline_parse_token_num_t cmd_read_reg_reg_off =
-	TOKEN_NUM_INITIALIZER(struct cmd_read_reg_result, reg_off, UINT32);
+	TOKEN_NUM_INITIALIZER(struct cmd_read_reg_result, reg_off, RTE_UINT32);
 
 cmdline_parse_inst_t cmd_read_reg = {
 	.f = cmd_read_reg_parsed,
@@ -7839,16 +8097,16 @@ cmdline_parse_token_string_t cmd_read_reg_bit_field_regfield =
 				 regfield, "regfield");
 cmdline_parse_token_num_t cmd_read_reg_bit_field_port_id =
 	TOKEN_NUM_INITIALIZER(struct cmd_read_reg_bit_field_result, port_id,
-			      UINT16);
+			      RTE_UINT16);
 cmdline_parse_token_num_t cmd_read_reg_bit_field_reg_off =
 	TOKEN_NUM_INITIALIZER(struct cmd_read_reg_bit_field_result, reg_off,
-			      UINT32);
+			      RTE_UINT32);
 cmdline_parse_token_num_t cmd_read_reg_bit_field_bit1_pos =
 	TOKEN_NUM_INITIALIZER(struct cmd_read_reg_bit_field_result, bit1_pos,
-			      UINT8);
+			      RTE_UINT8);
 cmdline_parse_token_num_t cmd_read_reg_bit_field_bit2_pos =
 	TOKEN_NUM_INITIALIZER(struct cmd_read_reg_bit_field_result, bit2_pos,
-			      UINT8);
+			      RTE_UINT8);
 
 cmdline_parse_inst_t cmd_read_reg_bit_field = {
 	.f = cmd_read_reg_bit_field_parsed,
@@ -7890,11 +8148,14 @@ cmdline_parse_token_string_t cmd_read_reg_bit_regbit =
 	TOKEN_STRING_INITIALIZER(struct cmd_read_reg_bit_result,
 				 regbit, "regbit");
 cmdline_parse_token_num_t cmd_read_reg_bit_port_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_read_reg_bit_result, port_id, UINT16);
+	TOKEN_NUM_INITIALIZER(struct cmd_read_reg_bit_result, port_id,
+				 RTE_UINT16);
 cmdline_parse_token_num_t cmd_read_reg_bit_reg_off =
-	TOKEN_NUM_INITIALIZER(struct cmd_read_reg_bit_result, reg_off, UINT32);
+	TOKEN_NUM_INITIALIZER(struct cmd_read_reg_bit_result, reg_off,
+				 RTE_UINT32);
 cmdline_parse_token_num_t cmd_read_reg_bit_bit_pos =
-	TOKEN_NUM_INITIALIZER(struct cmd_read_reg_bit_result, bit_pos, UINT8);
+	TOKEN_NUM_INITIALIZER(struct cmd_read_reg_bit_result, bit_pos,
+				 RTE_UINT8);
 
 cmdline_parse_inst_t cmd_read_reg_bit = {
 	.f = cmd_read_reg_bit_parsed,
@@ -7933,11 +8194,11 @@ cmdline_parse_token_string_t cmd_write_reg_write =
 cmdline_parse_token_string_t cmd_write_reg_reg =
 	TOKEN_STRING_INITIALIZER(struct cmd_write_reg_result, reg, "reg");
 cmdline_parse_token_num_t cmd_write_reg_port_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_write_reg_result, port_id, UINT16);
+	TOKEN_NUM_INITIALIZER(struct cmd_write_reg_result, port_id, RTE_UINT16);
 cmdline_parse_token_num_t cmd_write_reg_reg_off =
-	TOKEN_NUM_INITIALIZER(struct cmd_write_reg_result, reg_off, UINT32);
+	TOKEN_NUM_INITIALIZER(struct cmd_write_reg_result, reg_off, RTE_UINT32);
 cmdline_parse_token_num_t cmd_write_reg_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_write_reg_result, value, UINT32);
+	TOKEN_NUM_INITIALIZER(struct cmd_write_reg_result, value, RTE_UINT32);
 
 cmdline_parse_inst_t cmd_write_reg = {
 	.f = cmd_write_reg_parsed,
@@ -7982,19 +8243,19 @@ cmdline_parse_token_string_t cmd_write_reg_bit_field_regfield =
 				 regfield, "regfield");
 cmdline_parse_token_num_t cmd_write_reg_bit_field_port_id =
 	TOKEN_NUM_INITIALIZER(struct cmd_write_reg_bit_field_result, port_id,
-			      UINT16);
+			      RTE_UINT16);
 cmdline_parse_token_num_t cmd_write_reg_bit_field_reg_off =
 	TOKEN_NUM_INITIALIZER(struct cmd_write_reg_bit_field_result, reg_off,
-			      UINT32);
+			      RTE_UINT32);
 cmdline_parse_token_num_t cmd_write_reg_bit_field_bit1_pos =
 	TOKEN_NUM_INITIALIZER(struct cmd_write_reg_bit_field_result, bit1_pos,
-			      UINT8);
+			      RTE_UINT8);
 cmdline_parse_token_num_t cmd_write_reg_bit_field_bit2_pos =
 	TOKEN_NUM_INITIALIZER(struct cmd_write_reg_bit_field_result, bit2_pos,
-			      UINT8);
+			      RTE_UINT8);
 cmdline_parse_token_num_t cmd_write_reg_bit_field_value =
 	TOKEN_NUM_INITIALIZER(struct cmd_write_reg_bit_field_result, value,
-			      UINT32);
+			      RTE_UINT32);
 
 cmdline_parse_inst_t cmd_write_reg_bit_field = {
 	.f = cmd_write_reg_bit_field_parsed,
@@ -8040,13 +8301,17 @@ cmdline_parse_token_string_t cmd_write_reg_bit_regbit =
 	TOKEN_STRING_INITIALIZER(struct cmd_write_reg_bit_result,
 				 regbit, "regbit");
 cmdline_parse_token_num_t cmd_write_reg_bit_port_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_write_reg_bit_result, port_id, UINT16);
+	TOKEN_NUM_INITIALIZER(struct cmd_write_reg_bit_result, port_id,
+				 RTE_UINT16);
 cmdline_parse_token_num_t cmd_write_reg_bit_reg_off =
-	TOKEN_NUM_INITIALIZER(struct cmd_write_reg_bit_result, reg_off, UINT32);
+	TOKEN_NUM_INITIALIZER(struct cmd_write_reg_bit_result, reg_off,
+				 RTE_UINT32);
 cmdline_parse_token_num_t cmd_write_reg_bit_bit_pos =
-	TOKEN_NUM_INITIALIZER(struct cmd_write_reg_bit_result, bit_pos, UINT8);
+	TOKEN_NUM_INITIALIZER(struct cmd_write_reg_bit_result, bit_pos,
+				 RTE_UINT8);
 cmdline_parse_token_num_t cmd_write_reg_bit_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_write_reg_bit_result, value, UINT8);
+	TOKEN_NUM_INITIALIZER(struct cmd_write_reg_bit_result, value,
+				 RTE_UINT8);
 
 cmdline_parse_inst_t cmd_write_reg_bit = {
 	.f = cmd_write_reg_bit_parsed,
@@ -8092,11 +8357,14 @@ cmdline_parse_token_string_t cmd_read_rxd_txd_rxd_txd =
 	TOKEN_STRING_INITIALIZER(struct cmd_read_rxd_txd_result, rxd_txd,
 				 "rxd#txd");
 cmdline_parse_token_num_t cmd_read_rxd_txd_port_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_read_rxd_txd_result, port_id, UINT16);
+	TOKEN_NUM_INITIALIZER(struct cmd_read_rxd_txd_result, port_id,
+				 RTE_UINT16);
 cmdline_parse_token_num_t cmd_read_rxd_txd_queue_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_read_rxd_txd_result, queue_id, UINT16);
+	TOKEN_NUM_INITIALIZER(struct cmd_read_rxd_txd_result, queue_id,
+				 RTE_UINT16);
 cmdline_parse_token_num_t cmd_read_rxd_txd_desc_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_read_rxd_txd_result, desc_id, UINT16);
+	TOKEN_NUM_INITIALIZER(struct cmd_read_rxd_txd_result, desc_id,
+				 RTE_UINT16);
 
 cmdline_parse_inst_t cmd_read_rxd_txd = {
 	.f = cmd_read_rxd_txd_parsed,
@@ -8174,7 +8442,7 @@ cmdline_parse_token_string_t cmd_mac_addr_what =
 				"add#remove#set");
 cmdline_parse_token_num_t cmd_mac_addr_portnum =
 		TOKEN_NUM_INITIALIZER(struct cmd_mac_addr_result, port_num,
-					UINT16);
+					RTE_UINT16);
 cmdline_parse_token_etheraddr_t cmd_mac_addr_addr =
 		TOKEN_ETHERADDR_INITIALIZER(struct cmd_mac_addr_result, address);
 
@@ -8220,7 +8488,8 @@ cmdline_parse_token_string_t cmd_eth_peer_set =
 cmdline_parse_token_string_t cmd_eth_peer =
 	TOKEN_STRING_INITIALIZER(struct cmd_eth_peer_result, eth_peer, "eth-peer");
 cmdline_parse_token_num_t cmd_eth_peer_port_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_eth_peer_result, port_id, UINT16);
+	TOKEN_NUM_INITIALIZER(struct cmd_eth_peer_result, port_id,
+		RTE_UINT16);
 cmdline_parse_token_string_t cmd_eth_peer_addr =
 	TOKEN_STRING_INITIALIZER(struct cmd_eth_peer_result, peer_addr, NULL);
 
@@ -8269,13 +8538,13 @@ cmdline_parse_token_string_t cmd_setqmap_what =
 				 what, "tx#rx");
 cmdline_parse_token_num_t cmd_setqmap_portid =
 	TOKEN_NUM_INITIALIZER(struct cmd_set_qmap_result,
-			      port_id, UINT16);
+			      port_id, RTE_UINT16);
 cmdline_parse_token_num_t cmd_setqmap_queueid =
 	TOKEN_NUM_INITIALIZER(struct cmd_set_qmap_result,
-			      queue_id, UINT16);
+			      queue_id, RTE_UINT16);
 cmdline_parse_token_num_t cmd_setqmap_mapvalue =
 	TOKEN_NUM_INITIALIZER(struct cmd_set_qmap_result,
-			      map_value, UINT8);
+			      map_value, RTE_UINT8);
 
 cmdline_parse_inst_t cmd_set_qmap = {
 	.f = cmd_set_qmap_parsed,
@@ -8335,6 +8604,90 @@ cmdline_parse_inst_t cmd_set_xstats_hide_zero = {
 	},
 };
 
+/* *** SET OPTION TO ENABLE MEASUREMENT OF CPU CYCLES *** */
+struct cmd_set_record_core_cycles_result {
+	cmdline_fixed_string_t keyword;
+	cmdline_fixed_string_t name;
+	cmdline_fixed_string_t on_off;
+};
+
+static void
+cmd_set_record_core_cycles_parsed(void *parsed_result,
+			__rte_unused struct cmdline *cl,
+			__rte_unused void *data)
+{
+	struct cmd_set_record_core_cycles_result *res;
+	uint16_t on_off = 0;
+
+	res = parsed_result;
+	on_off = !strcmp(res->on_off, "on") ? 1 : 0;
+	set_record_core_cycles(on_off);
+}
+
+cmdline_parse_token_string_t cmd_set_record_core_cycles_keyword =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_record_core_cycles_result,
+				 keyword, "set");
+cmdline_parse_token_string_t cmd_set_record_core_cycles_name =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_record_core_cycles_result,
+				 name, "record-core-cycles");
+cmdline_parse_token_string_t cmd_set_record_core_cycles_on_off =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_record_core_cycles_result,
+				 on_off, "on#off");
+
+cmdline_parse_inst_t cmd_set_record_core_cycles = {
+	.f = cmd_set_record_core_cycles_parsed,
+	.data = NULL,
+	.help_str = "set record-core-cycles on|off",
+	.tokens = {
+		(void *)&cmd_set_record_core_cycles_keyword,
+		(void *)&cmd_set_record_core_cycles_name,
+		(void *)&cmd_set_record_core_cycles_on_off,
+		NULL,
+	},
+};
+
+/* *** SET OPTION TO ENABLE DISPLAY OF RX AND TX BURSTS *** */
+struct cmd_set_record_burst_stats_result {
+	cmdline_fixed_string_t keyword;
+	cmdline_fixed_string_t name;
+	cmdline_fixed_string_t on_off;
+};
+
+static void
+cmd_set_record_burst_stats_parsed(void *parsed_result,
+			__rte_unused struct cmdline *cl,
+			__rte_unused void *data)
+{
+	struct cmd_set_record_burst_stats_result *res;
+	uint16_t on_off = 0;
+
+	res = parsed_result;
+	on_off = !strcmp(res->on_off, "on") ? 1 : 0;
+	set_record_burst_stats(on_off);
+}
+
+cmdline_parse_token_string_t cmd_set_record_burst_stats_keyword =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_record_burst_stats_result,
+				 keyword, "set");
+cmdline_parse_token_string_t cmd_set_record_burst_stats_name =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_record_burst_stats_result,
+				 name, "record-burst-stats");
+cmdline_parse_token_string_t cmd_set_record_burst_stats_on_off =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_record_burst_stats_result,
+				 on_off, "on#off");
+
+cmdline_parse_inst_t cmd_set_record_burst_stats = {
+	.f = cmd_set_record_burst_stats_parsed,
+	.data = NULL,
+	.help_str = "set record-burst-stats on|off",
+	.tokens = {
+		(void *)&cmd_set_record_burst_stats_keyword,
+		(void *)&cmd_set_record_burst_stats_name,
+		(void *)&cmd_set_record_burst_stats_on_off,
+		NULL,
+	},
+};
+
 /* *** CONFIGURE UNICAST HASH TABLE *** */
 struct cmd_set_uc_hash_table {
 	cmdline_fixed_string_t set;
@@ -8371,7 +8724,7 @@ cmdline_parse_token_string_t cmd_set_uc_hash_port =
 				 port, "port");
 cmdline_parse_token_num_t cmd_set_uc_hash_portid =
 	TOKEN_NUM_INITIALIZER(struct cmd_set_uc_hash_table,
-			      port_id, UINT16);
+			      port_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_set_uc_hash_what =
 	TOKEN_STRING_INITIALIZER(struct cmd_set_uc_hash_table,
 				 what, "uta");
@@ -8432,7 +8785,7 @@ cmdline_parse_token_string_t cmd_set_uc_all_hash_port =
 				 port, "port");
 cmdline_parse_token_num_t cmd_set_uc_all_hash_portid =
 	TOKEN_NUM_INITIALIZER(struct cmd_set_uc_all_hash_table,
-			      port_id, UINT16);
+			      port_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_set_uc_all_hash_what =
 	TOKEN_STRING_INITIALIZER(struct cmd_set_uc_all_hash_table,
 				 what, "uta");
@@ -8458,118 +8811,14 @@ cmdline_parse_inst_t cmd_set_uc_all_hash_filter = {
 	},
 };
 
-/* *** CONFIGURE MACVLAN FILTER FOR VF(s) *** */
-struct cmd_set_vf_macvlan_filter {
+/* *** CONFIGURE VF TRAFFIC CONTROL *** */
+struct cmd_set_vf_traffic {
 	cmdline_fixed_string_t set;
 	cmdline_fixed_string_t port;
 	portid_t port_id;
 	cmdline_fixed_string_t vf;
 	uint8_t vf_id;
-	struct rte_ether_addr address;
-	cmdline_fixed_string_t filter_type;
-	cmdline_fixed_string_t mode;
-};
-
-static void
-cmd_set_vf_macvlan_parsed(void *parsed_result,
-		       __rte_unused struct cmdline *cl,
-		       __rte_unused void *data)
-{
-	int is_on, ret = 0;
-	struct cmd_set_vf_macvlan_filter *res = parsed_result;
-	struct rte_eth_mac_filter filter;
-
-	memset(&filter, 0, sizeof(struct rte_eth_mac_filter));
-
-	rte_memcpy(&filter.mac_addr, &res->address, RTE_ETHER_ADDR_LEN);
-
-	/* set VF MAC filter */
-	filter.is_vf = 1;
-
-	/* set VF ID */
-	filter.dst_id = res->vf_id;
-
-	if (!strcmp(res->filter_type, "exact-mac"))
-		filter.filter_type = RTE_MAC_PERFECT_MATCH;
-	else if (!strcmp(res->filter_type, "exact-mac-vlan"))
-		filter.filter_type = RTE_MACVLAN_PERFECT_MATCH;
-	else if (!strcmp(res->filter_type, "hashmac"))
-		filter.filter_type = RTE_MAC_HASH_MATCH;
-	else if (!strcmp(res->filter_type, "hashmac-vlan"))
-		filter.filter_type = RTE_MACVLAN_HASH_MATCH;
-
-	is_on = (strcmp(res->mode, "on") == 0) ? 1 : 0;
-
-	if (is_on)
-		ret = rte_eth_dev_filter_ctrl(res->port_id,
-					RTE_ETH_FILTER_MACVLAN,
-					RTE_ETH_FILTER_ADD,
-					 &filter);
-	else
-		ret = rte_eth_dev_filter_ctrl(res->port_id,
-					RTE_ETH_FILTER_MACVLAN,
-					RTE_ETH_FILTER_DELETE,
-					&filter);
-
-	if (ret < 0)
-		printf("bad set MAC hash parameter, return code = %d\n", ret);
-
-}
-
-cmdline_parse_token_string_t cmd_set_vf_macvlan_set =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_vf_macvlan_filter,
-				 set, "set");
-cmdline_parse_token_string_t cmd_set_vf_macvlan_port =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_vf_macvlan_filter,
-				 port, "port");
-cmdline_parse_token_num_t cmd_set_vf_macvlan_portid =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_vf_macvlan_filter,
-			      port_id, UINT16);
-cmdline_parse_token_string_t cmd_set_vf_macvlan_vf =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_vf_macvlan_filter,
-				 vf, "vf");
-cmdline_parse_token_num_t cmd_set_vf_macvlan_vf_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_vf_macvlan_filter,
-				vf_id, UINT8);
-cmdline_parse_token_etheraddr_t cmd_set_vf_macvlan_mac =
-	TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_vf_macvlan_filter,
-				address);
-cmdline_parse_token_string_t cmd_set_vf_macvlan_filter_type =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_vf_macvlan_filter,
-				filter_type, "exact-mac#exact-mac-vlan"
-				"#hashmac#hashmac-vlan");
-cmdline_parse_token_string_t cmd_set_vf_macvlan_mode =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_vf_macvlan_filter,
-				 mode, "on#off");
-
-cmdline_parse_inst_t cmd_set_vf_macvlan_filter = {
-	.f = cmd_set_vf_macvlan_parsed,
-	.data = NULL,
-	.help_str = "set port <port_id> vf <vf_id> <mac_addr> "
-		"exact-mac|exact-mac-vlan|hashmac|hashmac-vlan on|off: "
-		"Exact match rule: exact match of MAC or MAC and VLAN; "
-		"hash match rule: hash match of MAC and exact match of VLAN",
-	.tokens = {
-		(void *)&cmd_set_vf_macvlan_set,
-		(void *)&cmd_set_vf_macvlan_port,
-		(void *)&cmd_set_vf_macvlan_portid,
-		(void *)&cmd_set_vf_macvlan_vf,
-		(void *)&cmd_set_vf_macvlan_vf_id,
-		(void *)&cmd_set_vf_macvlan_mac,
-		(void *)&cmd_set_vf_macvlan_filter_type,
-		(void *)&cmd_set_vf_macvlan_mode,
-		NULL,
-	},
-};
-
-/* *** CONFIGURE VF TRAFFIC CONTROL *** */
-struct cmd_set_vf_traffic {
-	cmdline_fixed_string_t set;
-	cmdline_fixed_string_t port;
-	portid_t port_id;
-	cmdline_fixed_string_t vf;
-	uint8_t vf_id;
-	cmdline_fixed_string_t what;
+	cmdline_fixed_string_t what;
 	cmdline_fixed_string_t mode;
 };
 
@@ -8593,13 +8842,13 @@ cmdline_parse_token_string_t cmd_setvf_traffic_port =
 				 port, "port");
 cmdline_parse_token_num_t cmd_setvf_traffic_portid =
 	TOKEN_NUM_INITIALIZER(struct cmd_set_vf_traffic,
-			      port_id, UINT16);
+			      port_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_setvf_traffic_vf =
 	TOKEN_STRING_INITIALIZER(struct cmd_set_vf_traffic,
 				 vf, "vf");
 cmdline_parse_token_num_t cmd_setvf_traffic_vfid =
 	TOKEN_NUM_INITIALIZER(struct cmd_set_vf_traffic,
-			      vf_id, UINT8);
+			      vf_id, RTE_UINT8);
 cmdline_parse_token_string_t cmd_setvf_traffic_what =
 	TOKEN_STRING_INITIALIZER(struct cmd_set_vf_traffic,
 				 what, "tx#rx");
@@ -8658,12 +8907,12 @@ cmd_set_vf_rxmode_parsed(void *parsed_result,
 
 	RTE_SET_USED(is_on);
 
-#ifdef RTE_LIBRTE_IXGBE_PMD
+#ifdef RTE_NET_IXGBE
 	if (ret == -ENOTSUP)
 		ret = rte_pmd_ixgbe_set_vf_rxmode(res->port_id, res->vf_id,
 						  vf_rxmode, (uint8_t)is_on);
 #endif
-#ifdef RTE_LIBRTE_BNXT_PMD
+#ifdef RTE_NET_BNXT
 	if (ret == -ENOTSUP)
 		ret = rte_pmd_bnxt_set_vf_rxmode(res->port_id, res->vf_id,
 						 vf_rxmode, (uint8_t)is_on);
@@ -8681,13 +8930,13 @@ cmdline_parse_token_string_t cmd_set_vf_rxmode_port =
 				 port, "port");
 cmdline_parse_token_num_t cmd_set_vf_rxmode_portid =
 	TOKEN_NUM_INITIALIZER(struct cmd_set_vf_rxmode,
-			      port_id, UINT16);
+			      port_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_set_vf_rxmode_vf =
 	TOKEN_STRING_INITIALIZER(struct cmd_set_vf_rxmode,
 				 vf, "vf");
 cmdline_parse_token_num_t cmd_set_vf_rxmode_vfid =
 	TOKEN_NUM_INITIALIZER(struct cmd_set_vf_rxmode,
-			      vf_id, UINT8);
+			      vf_id, RTE_UINT8);
 cmdline_parse_token_string_t cmd_set_vf_rxmode_what =
 	TOKEN_STRING_INITIALIZER(struct cmd_set_vf_rxmode,
 				 what, "rxmode");
@@ -8737,12 +8986,12 @@ static void cmd_vf_mac_addr_parsed(void *parsed_result,
 	if (strcmp(res->what, "add") != 0)
 		return;
 
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
 	if (ret == -ENOTSUP)
 		ret = rte_pmd_i40e_add_vf_mac_addr(res->port_num, res->vf_num,
 						   &res->address);
 #endif
-#ifdef RTE_LIBRTE_BNXT_PMD
+#ifdef RTE_NET_BNXT
 	if (ret == -ENOTSUP)
 		ret = rte_pmd_bnxt_mac_addr_add(res->port_num, &res->address,
 						res->vf_num);
@@ -8764,13 +9013,13 @@ cmdline_parse_token_string_t cmd_vf_mac_addr_port =
 				port,"port");
 cmdline_parse_token_num_t cmd_vf_mac_addr_portnum =
 	TOKEN_NUM_INITIALIZER(struct cmd_vf_mac_addr_result,
-				port_num, UINT16);
+				port_num, RTE_UINT16);
 cmdline_parse_token_string_t cmd_vf_mac_addr_vf =
 	TOKEN_STRING_INITIALIZER(struct cmd_vf_mac_addr_result,
 				vf,"vf");
 cmdline_parse_token_num_t cmd_vf_mac_addr_vfnum =
 	TOKEN_NUM_INITIALIZER(struct cmd_vf_mac_addr_result,
-				vf_num, UINT8);
+				vf_num, RTE_UINT8);
 cmdline_parse_token_etheraddr_t cmd_vf_mac_addr_addr =
 	TOKEN_ETHERADDR_INITIALIZER(struct cmd_vf_mac_addr_result,
 				address);
@@ -8813,17 +9062,17 @@ cmd_vf_rx_vlan_filter_parsed(void *parsed_result,
 
 	__rte_unused int is_add = (strcmp(res->what, "add") == 0) ? 1 : 0;
 
-#ifdef RTE_LIBRTE_IXGBE_PMD
+#ifdef RTE_NET_IXGBE
 	if (ret == -ENOTSUP)
 		ret = rte_pmd_ixgbe_set_vf_vlan_filter(res->port_id,
 				res->vlan_id, res->vf_mask, is_add);
 #endif
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
 	if (ret == -ENOTSUP)
 		ret = rte_pmd_i40e_set_vf_vlan_filter(res->port_id,
 				res->vlan_id, res->vf_mask, is_add);
 #endif
-#ifdef RTE_LIBRTE_BNXT_PMD
+#ifdef RTE_NET_BNXT
 	if (ret == -ENOTSUP)
 		ret = rte_pmd_bnxt_set_vf_vlan_filter(res->port_id,
 				res->vlan_id, res->vf_mask, is_add);
@@ -8855,19 +9104,19 @@ cmdline_parse_token_string_t cmd_vf_rx_vlan_filter_what =
 				 what, "add#rm");
 cmdline_parse_token_num_t cmd_vf_rx_vlan_filter_vlanid =
 	TOKEN_NUM_INITIALIZER(struct cmd_vf_rx_vlan_filter,
-			      vlan_id, UINT16);
+			      vlan_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_vf_rx_vlan_filter_port =
 	TOKEN_STRING_INITIALIZER(struct cmd_vf_rx_vlan_filter,
 				 port, "port");
 cmdline_parse_token_num_t cmd_vf_rx_vlan_filter_portid =
 	TOKEN_NUM_INITIALIZER(struct cmd_vf_rx_vlan_filter,
-			      port_id, UINT16);
+			      port_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_vf_rx_vlan_filter_vf =
 	TOKEN_STRING_INITIALIZER(struct cmd_vf_rx_vlan_filter,
 				 vf, "vf");
 cmdline_parse_token_num_t cmd_vf_rx_vlan_filter_vf_mask =
 	TOKEN_NUM_INITIALIZER(struct cmd_vf_rx_vlan_filter,
-			      vf_mask, UINT64);
+			      vf_mask, RTE_UINT64);
 
 cmdline_parse_inst_t cmd_vf_rxvlan_filter = {
 	.f = cmd_vf_rx_vlan_filter_parsed,
@@ -8922,19 +9171,19 @@ cmdline_parse_token_string_t cmd_queue_rate_limit_port =
 				port, "port");
 cmdline_parse_token_num_t cmd_queue_rate_limit_portnum =
 	TOKEN_NUM_INITIALIZER(struct cmd_queue_rate_limit_result,
-				port_num, UINT16);
+				port_num, RTE_UINT16);
 cmdline_parse_token_string_t cmd_queue_rate_limit_queue =
 	TOKEN_STRING_INITIALIZER(struct cmd_queue_rate_limit_result,
 				queue, "queue");
 cmdline_parse_token_num_t cmd_queue_rate_limit_queuenum =
 	TOKEN_NUM_INITIALIZER(struct cmd_queue_rate_limit_result,
-				queue_num, UINT8);
+				queue_num, RTE_UINT8);
 cmdline_parse_token_string_t cmd_queue_rate_limit_rate =
 	TOKEN_STRING_INITIALIZER(struct cmd_queue_rate_limit_result,
 				rate, "rate");
 cmdline_parse_token_num_t cmd_queue_rate_limit_ratenum =
 	TOKEN_NUM_INITIALIZER(struct cmd_queue_rate_limit_result,
-				rate_num, UINT16);
+				rate_num, RTE_UINT16);
 
 cmdline_parse_inst_t cmd_queue_rate_limit = {
 	.f = cmd_queue_rate_limit_parsed,
@@ -8992,25 +9241,25 @@ cmdline_parse_token_string_t cmd_vf_rate_limit_port =
 				port, "port");
 cmdline_parse_token_num_t cmd_vf_rate_limit_portnum =
 	TOKEN_NUM_INITIALIZER(struct cmd_vf_rate_limit_result,
-				port_num, UINT16);
+				port_num, RTE_UINT16);
 cmdline_parse_token_string_t cmd_vf_rate_limit_vf =
 	TOKEN_STRING_INITIALIZER(struct cmd_vf_rate_limit_result,
 				vf, "vf");
 cmdline_parse_token_num_t cmd_vf_rate_limit_vfnum =
 	TOKEN_NUM_INITIALIZER(struct cmd_vf_rate_limit_result,
-				vf_num, UINT8);
+				vf_num, RTE_UINT8);
 cmdline_parse_token_string_t cmd_vf_rate_limit_rate =
 	TOKEN_STRING_INITIALIZER(struct cmd_vf_rate_limit_result,
 				rate, "rate");
 cmdline_parse_token_num_t cmd_vf_rate_limit_ratenum =
 	TOKEN_NUM_INITIALIZER(struct cmd_vf_rate_limit_result,
-				rate_num, UINT16);
+				rate_num, RTE_UINT16);
 cmdline_parse_token_string_t cmd_vf_rate_limit_q_msk =
 	TOKEN_STRING_INITIALIZER(struct cmd_vf_rate_limit_result,
 				q_msk, "queue_mask");
 cmdline_parse_token_num_t cmd_vf_rate_limit_q_msk_val =
 	TOKEN_NUM_INITIALIZER(struct cmd_vf_rate_limit_result,
-				q_msk_val, UINT64);
+				q_msk_val, RTE_UINT64);
 
 cmdline_parse_inst_t cmd_vf_rate_limit = {
 	.f = cmd_vf_rate_limit_parsed,
@@ -9032,160 +9281,9 @@ cmdline_parse_inst_t cmd_vf_rate_limit = {
 	},
 };
 
-/* *** ADD TUNNEL FILTER OF A PORT *** */
-struct cmd_tunnel_filter_result {
-	cmdline_fixed_string_t cmd;
-	cmdline_fixed_string_t what;
-	portid_t port_id;
-	struct rte_ether_addr outer_mac;
-	struct rte_ether_addr inner_mac;
-	cmdline_ipaddr_t ip_value;
-	uint16_t inner_vlan;
-	cmdline_fixed_string_t tunnel_type;
-	cmdline_fixed_string_t filter_type;
-	uint32_t tenant_id;
-	uint16_t queue_num;
-};
-
-static void
-cmd_tunnel_filter_parsed(void *parsed_result,
-			  __rte_unused struct cmdline *cl,
-			  __rte_unused void *data)
-{
-	struct cmd_tunnel_filter_result *res = parsed_result;
-	struct rte_eth_tunnel_filter_conf tunnel_filter_conf;
-	int ret = 0;
-
-	memset(&tunnel_filter_conf, 0, sizeof(tunnel_filter_conf));
-
-	rte_ether_addr_copy(&res->outer_mac, &tunnel_filter_conf.outer_mac);
-	rte_ether_addr_copy(&res->inner_mac, &tunnel_filter_conf.inner_mac);
-	tunnel_filter_conf.inner_vlan = res->inner_vlan;
-
-	if (res->ip_value.family == AF_INET) {
-		tunnel_filter_conf.ip_addr.ipv4_addr =
-			res->ip_value.addr.ipv4.s_addr;
-		tunnel_filter_conf.ip_type = RTE_TUNNEL_IPTYPE_IPV4;
-	} else {
-		memcpy(&(tunnel_filter_conf.ip_addr.ipv6_addr),
-			&(res->ip_value.addr.ipv6),
-			sizeof(struct in6_addr));
-		tunnel_filter_conf.ip_type = RTE_TUNNEL_IPTYPE_IPV6;
-	}
-
-	if (!strcmp(res->filter_type, "imac-ivlan"))
-		tunnel_filter_conf.filter_type = RTE_TUNNEL_FILTER_IMAC_IVLAN;
-	else if (!strcmp(res->filter_type, "imac-ivlan-tenid"))
-		tunnel_filter_conf.filter_type =
-			RTE_TUNNEL_FILTER_IMAC_IVLAN_TENID;
-	else if (!strcmp(res->filter_type, "imac-tenid"))
-		tunnel_filter_conf.filter_type = RTE_TUNNEL_FILTER_IMAC_TENID;
-	else if (!strcmp(res->filter_type, "imac"))
-		tunnel_filter_conf.filter_type = ETH_TUNNEL_FILTER_IMAC;
-	else if (!strcmp(res->filter_type, "omac-imac-tenid"))
-		tunnel_filter_conf.filter_type =
-			RTE_TUNNEL_FILTER_OMAC_TENID_IMAC;
-	else if (!strcmp(res->filter_type, "oip"))
-		tunnel_filter_conf.filter_type = ETH_TUNNEL_FILTER_OIP;
-	else if (!strcmp(res->filter_type, "iip"))
-		tunnel_filter_conf.filter_type = ETH_TUNNEL_FILTER_IIP;
-	else {
-		printf("The filter type is not supported");
-		return;
-	}
-
-	if (!strcmp(res->tunnel_type, "vxlan"))
-		tunnel_filter_conf.tunnel_type = RTE_TUNNEL_TYPE_VXLAN;
-	else if (!strcmp(res->tunnel_type, "vxlan-gpe"))
-		tunnel_filter_conf.tunnel_type = RTE_TUNNEL_TYPE_VXLAN_GPE;
-	else if (!strcmp(res->tunnel_type, "nvgre"))
-		tunnel_filter_conf.tunnel_type = RTE_TUNNEL_TYPE_NVGRE;
-	else if (!strcmp(res->tunnel_type, "ipingre"))
-		tunnel_filter_conf.tunnel_type = RTE_TUNNEL_TYPE_IP_IN_GRE;
-	else {
-		printf("The tunnel type %s not supported.\n", res->tunnel_type);
-		return;
-	}
-
-	tunnel_filter_conf.tenant_id = res->tenant_id;
-	tunnel_filter_conf.queue_id = res->queue_num;
-	if (!strcmp(res->what, "add"))
-		ret = rte_eth_dev_filter_ctrl(res->port_id,
-					RTE_ETH_FILTER_TUNNEL,
-					RTE_ETH_FILTER_ADD,
-					&tunnel_filter_conf);
-	else
-		ret = rte_eth_dev_filter_ctrl(res->port_id,
-					RTE_ETH_FILTER_TUNNEL,
-					RTE_ETH_FILTER_DELETE,
-					&tunnel_filter_conf);
-	if (ret < 0)
-		printf("cmd_tunnel_filter_parsed error: (%s)\n",
-				strerror(-ret));
-
-}
-cmdline_parse_token_string_t cmd_tunnel_filter_cmd =
-	TOKEN_STRING_INITIALIZER(struct cmd_tunnel_filter_result,
-	cmd, "tunnel_filter");
-cmdline_parse_token_string_t cmd_tunnel_filter_what =
-	TOKEN_STRING_INITIALIZER(struct cmd_tunnel_filter_result,
-	what, "add#rm");
-cmdline_parse_token_num_t cmd_tunnel_filter_port_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_tunnel_filter_result,
-	port_id, UINT16);
-cmdline_parse_token_etheraddr_t cmd_tunnel_filter_outer_mac =
-	TOKEN_ETHERADDR_INITIALIZER(struct cmd_tunnel_filter_result,
-	outer_mac);
-cmdline_parse_token_etheraddr_t cmd_tunnel_filter_inner_mac =
-	TOKEN_ETHERADDR_INITIALIZER(struct cmd_tunnel_filter_result,
-	inner_mac);
-cmdline_parse_token_num_t cmd_tunnel_filter_innner_vlan =
-	TOKEN_NUM_INITIALIZER(struct cmd_tunnel_filter_result,
-	inner_vlan, UINT16);
-cmdline_parse_token_ipaddr_t cmd_tunnel_filter_ip_value =
-	TOKEN_IPADDR_INITIALIZER(struct cmd_tunnel_filter_result,
-	ip_value);
-cmdline_parse_token_string_t cmd_tunnel_filter_tunnel_type =
-	TOKEN_STRING_INITIALIZER(struct cmd_tunnel_filter_result,
-	tunnel_type, "vxlan#nvgre#ipingre#vxlan-gpe");
-
-cmdline_parse_token_string_t cmd_tunnel_filter_filter_type =
-	TOKEN_STRING_INITIALIZER(struct cmd_tunnel_filter_result,
-	filter_type, "oip#iip#imac-ivlan#imac-ivlan-tenid#imac-tenid#"
-		"imac#omac-imac-tenid");
-cmdline_parse_token_num_t cmd_tunnel_filter_tenant_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_tunnel_filter_result,
-	tenant_id, UINT32);
-cmdline_parse_token_num_t cmd_tunnel_filter_queue_num =
-	TOKEN_NUM_INITIALIZER(struct cmd_tunnel_filter_result,
-	queue_num, UINT16);
-
-cmdline_parse_inst_t cmd_tunnel_filter = {
-	.f = cmd_tunnel_filter_parsed,
-	.data = (void *)0,
-	.help_str = "tunnel_filter add|rm <port_id> <outer_mac> <inner_mac> "
-		"<ip> <inner_vlan> vxlan|nvgre|ipingre oip|iip|imac-ivlan|"
-		"imac-ivlan-tenid|imac-tenid|imac|omac-imac-tenid <tenant_id> "
-		"<queue_id>: Add/Rm tunnel filter of a port",
-	.tokens = {
-		(void *)&cmd_tunnel_filter_cmd,
-		(void *)&cmd_tunnel_filter_what,
-		(void *)&cmd_tunnel_filter_port_id,
-		(void *)&cmd_tunnel_filter_outer_mac,
-		(void *)&cmd_tunnel_filter_inner_mac,
-		(void *)&cmd_tunnel_filter_ip_value,
-		(void *)&cmd_tunnel_filter_innner_vlan,
-		(void *)&cmd_tunnel_filter_tunnel_type,
-		(void *)&cmd_tunnel_filter_filter_type,
-		(void *)&cmd_tunnel_filter_tenant_id,
-		(void *)&cmd_tunnel_filter_queue_num,
-		NULL,
-	},
-};
-
 /* *** CONFIGURE TUNNEL UDP PORT *** */
 struct cmd_tunnel_udp_config {
-	cmdline_fixed_string_t cmd;
+	cmdline_fixed_string_t rx_vxlan_port;
 	cmdline_fixed_string_t what;
 	uint16_t udp_port;
 	portid_t port_id;
@@ -9201,9 +9299,7 @@ cmd_tunnel_udp_config_parsed(void *parsed_result,
 	int ret;
 
 	tunnel_udp.udp_port = res->udp_port;
-
-	if (!strcmp(res->cmd, "rx_vxlan_port"))
-		tunnel_udp.prot_type = RTE_TUNNEL_TYPE_VXLAN;
+	tunnel_udp.prot_type = RTE_TUNNEL_TYPE_VXLAN;
 
 	if (!strcmp(res->what, "add"))
 		ret = rte_eth_dev_udp_tunnel_port_add(res->port_id,
@@ -9216,18 +9312,18 @@ cmd_tunnel_udp_config_parsed(void *parsed_result,
 		printf("udp tunneling add error: (%s)\n", strerror(-ret));
 }
 
-cmdline_parse_token_string_t cmd_tunnel_udp_config_cmd =
+cmdline_parse_token_string_t cmd_tunnel_udp_config_rx_vxlan_port =
 	TOKEN_STRING_INITIALIZER(struct cmd_tunnel_udp_config,
-				cmd, "rx_vxlan_port");
+				rx_vxlan_port, "rx_vxlan_port");
 cmdline_parse_token_string_t cmd_tunnel_udp_config_what =
 	TOKEN_STRING_INITIALIZER(struct cmd_tunnel_udp_config,
 				what, "add#rm");
 cmdline_parse_token_num_t cmd_tunnel_udp_config_udp_port =
 	TOKEN_NUM_INITIALIZER(struct cmd_tunnel_udp_config,
-				udp_port, UINT16);
+				udp_port, RTE_UINT16);
 cmdline_parse_token_num_t cmd_tunnel_udp_config_port_id =
 	TOKEN_NUM_INITIALIZER(struct cmd_tunnel_udp_config,
-				port_id, UINT16);
+				port_id, RTE_UINT16);
 
 cmdline_parse_inst_t cmd_tunnel_udp_config = {
 	.f = cmd_tunnel_udp_config_parsed,
@@ -9235,7 +9331,7 @@ cmdline_parse_inst_t cmd_tunnel_udp_config = {
 	.help_str = "rx_vxlan_port add|rm <udp_port> <port_id>: "
 		"Add/Remove a tunneling UDP port filter",
 	.tokens = {
-		(void *)&cmd_tunnel_udp_config_cmd,
+		(void *)&cmd_tunnel_udp_config_rx_vxlan_port,
 		(void *)&cmd_tunnel_udp_config_what,
 		(void *)&cmd_tunnel_udp_config_udp_port,
 		(void *)&cmd_tunnel_udp_config_port_id,
@@ -9273,6 +9369,8 @@ cmd_cfg_tunnel_udp_port_parsed(void *parsed_result,
 		tunnel_udp.prot_type = RTE_TUNNEL_TYPE_GENEVE;
 	} else if (!strcmp(res->tunnel_type, "vxlan-gpe")) {
 		tunnel_udp.prot_type = RTE_TUNNEL_TYPE_VXLAN_GPE;
+	} else if (!strcmp(res->tunnel_type, "ecpri")) {
+		tunnel_udp.prot_type = RTE_TUNNEL_TYPE_ECPRI;
 	} else {
 		printf("Invalid tunnel type\n");
 		return;
@@ -9297,7 +9395,7 @@ cmdline_parse_token_string_t cmd_config_tunnel_udp_port_config =
 				 "config");
 cmdline_parse_token_num_t cmd_config_tunnel_udp_port_port_id =
 	TOKEN_NUM_INITIALIZER(struct cmd_config_tunnel_udp_port, port_id,
-			      UINT16);
+			      RTE_UINT16);
 cmdline_parse_token_string_t cmd_config_tunnel_udp_port_tunnel_port =
 	TOKEN_STRING_INITIALIZER(struct cmd_config_tunnel_udp_port,
 				 udp_tunnel_port,
@@ -9307,15 +9405,16 @@ cmdline_parse_token_string_t cmd_config_tunnel_udp_port_action =
 				 "add#rm");
 cmdline_parse_token_string_t cmd_config_tunnel_udp_port_tunnel_type =
 	TOKEN_STRING_INITIALIZER(struct cmd_config_tunnel_udp_port, tunnel_type,
-				 "vxlan#geneve#vxlan-gpe");
+				 "vxlan#geneve#vxlan-gpe#ecpri");
 cmdline_parse_token_num_t cmd_config_tunnel_udp_port_value =
 	TOKEN_NUM_INITIALIZER(struct cmd_config_tunnel_udp_port, udp_port,
-			      UINT16);
+			      RTE_UINT16);
 
 cmdline_parse_inst_t cmd_cfg_tunnel_udp_port = {
 	.f = cmd_cfg_tunnel_udp_port_parsed,
 	.data = NULL,
-	.help_str = "port config <port_id> udp_tunnel_port add|rm vxlan|geneve|vxlan-gpe <udp_port>",
+	.help_str = "port config <port_id> udp_tunnel_port add|rm vxlan|"
+		"geneve|vxlan-gpe|ecpri <udp_port>",
 	.tokens = {
 		(void *)&cmd_config_tunnel_udp_port_port,
 		(void *)&cmd_config_tunnel_udp_port_config,
@@ -9328,62 +9427,6 @@ cmdline_parse_inst_t cmd_cfg_tunnel_udp_port = {
 	},
 };
 
-/* *** GLOBAL CONFIG *** */
-struct cmd_global_config_result {
-	cmdline_fixed_string_t cmd;
-	portid_t port_id;
-	cmdline_fixed_string_t cfg_type;
-	uint8_t len;
-};
-
-static void
-cmd_global_config_parsed(void *parsed_result,
-			 __rte_unused struct cmdline *cl,
-			 __rte_unused void *data)
-{
-	struct cmd_global_config_result *res = parsed_result;
-	struct rte_eth_global_cfg conf;
-	int ret;
-
-	memset(&conf, 0, sizeof(conf));
-	conf.cfg_type = RTE_ETH_GLOBAL_CFG_TYPE_GRE_KEY_LEN;
-	conf.cfg.gre_key_len = res->len;
-	ret = rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_NONE,
-				      RTE_ETH_FILTER_SET, &conf);
-#ifdef RTE_LIBRTE_I40E_PMD
-	if (ret == -ENOTSUP)
-		ret = rte_pmd_i40e_set_gre_key_len(res->port_id, res->len);
-#endif
-	if (ret != 0)
-		printf("Global config error\n");
-}
-
-cmdline_parse_token_string_t cmd_global_config_cmd =
-	TOKEN_STRING_INITIALIZER(struct cmd_global_config_result, cmd,
-		"global_config");
-cmdline_parse_token_num_t cmd_global_config_port_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_global_config_result, port_id,
-			       UINT16);
-cmdline_parse_token_string_t cmd_global_config_type =
-	TOKEN_STRING_INITIALIZER(struct cmd_global_config_result,
-		cfg_type, "gre-key-len");
-cmdline_parse_token_num_t cmd_global_config_gre_key_len =
-	TOKEN_NUM_INITIALIZER(struct cmd_global_config_result,
-		len, UINT8);
-
-cmdline_parse_inst_t cmd_global_config = {
-	.f = cmd_global_config_parsed,
-	.data = (void *)NULL,
-	.help_str = "global_config <port_id> gre-key-len <key_len>",
-	.tokens = {
-		(void *)&cmd_global_config_cmd,
-		(void *)&cmd_global_config_port_id,
-		(void *)&cmd_global_config_type,
-		(void *)&cmd_global_config_gre_key_len,
-		NULL,
-	},
-};
-
 /* *** CONFIGURE VM MIRROR VLAN/POOL RULE *** */
 struct cmd_set_mirror_mask_result {
 	cmdline_fixed_string_t set;
@@ -9406,13 +9449,13 @@ cmdline_parse_token_string_t cmd_mirror_mask_port =
 				port, "port");
 cmdline_parse_token_num_t cmd_mirror_mask_portid =
 	TOKEN_NUM_INITIALIZER(struct cmd_set_mirror_mask_result,
-				port_id, UINT16);
+				port_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_mirror_mask_mirror =
 	TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_mask_result,
 				mirror, "mirror-rule");
 cmdline_parse_token_num_t cmd_mirror_mask_ruleid =
 	TOKEN_NUM_INITIALIZER(struct cmd_set_mirror_mask_result,
-				rule_id, UINT8);
+				rule_id, RTE_UINT8);
 cmdline_parse_token_string_t cmd_mirror_mask_what =
 	TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_mask_result,
 				what, "pool-mirror-up#pool-mirror-down"
@@ -9425,7 +9468,7 @@ cmdline_parse_token_string_t cmd_mirror_mask_dstpool =
 				dstpool, "dst-pool");
 cmdline_parse_token_num_t cmd_mirror_mask_poolid =
 	TOKEN_NUM_INITIALIZER(struct cmd_set_mirror_mask_result,
-				dstpool_id, UINT8);
+				dstpool_id, RTE_UINT8);
 cmdline_parse_token_string_t cmd_mirror_mask_on =
 	TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_mask_result,
 				on, "on#off");
@@ -9521,13 +9564,13 @@ cmdline_parse_token_string_t cmd_mirror_link_port =
 				port, "port");
 cmdline_parse_token_num_t cmd_mirror_link_portid =
 	TOKEN_NUM_INITIALIZER(struct cmd_set_mirror_link_result,
-				port_id, UINT16);
+				port_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_mirror_link_mirror =
 	TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_link_result,
 				mirror, "mirror-rule");
 cmdline_parse_token_num_t cmd_mirror_link_ruleid =
 	TOKEN_NUM_INITIALIZER(struct cmd_set_mirror_link_result,
-			    rule_id, UINT8);
+			    rule_id, RTE_UINT8);
 cmdline_parse_token_string_t cmd_mirror_link_what =
 	TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_link_result,
 				what, "uplink-mirror#downlink-mirror");
@@ -9536,7 +9579,7 @@ cmdline_parse_token_string_t cmd_mirror_link_dstpool =
 				dstpool, "dst-pool");
 cmdline_parse_token_num_t cmd_mirror_link_poolid =
 	TOKEN_NUM_INITIALIZER(struct cmd_set_mirror_link_result,
-				dstpool_id, UINT8);
+				dstpool_id, RTE_UINT8);
 cmdline_parse_token_string_t cmd_mirror_link_on =
 	TOKEN_STRING_INITIALIZER(struct cmd_set_mirror_link_result,
 				on, "on#off");
@@ -9607,13 +9650,13 @@ cmdline_parse_token_string_t cmd_rm_mirror_rule_port =
 				port, "port");
 cmdline_parse_token_num_t cmd_rm_mirror_rule_portid =
 	TOKEN_NUM_INITIALIZER(struct cmd_rm_mirror_rule_result,
-				port_id, UINT16);
+				port_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_rm_mirror_rule_mirror =
 	TOKEN_STRING_INITIALIZER(struct cmd_rm_mirror_rule_result,
 				mirror, "mirror-rule");
 cmdline_parse_token_num_t cmd_rm_mirror_rule_ruleid =
 	TOKEN_NUM_INITIALIZER(struct cmd_rm_mirror_rule_result,
-				rule_id, UINT8);
+				rule_id, RTE_UINT8);
 
 static void
 cmd_reset_mirror_rule_parsed(void *parsed_result,
@@ -9697,7 +9740,7 @@ dump_socket_mem(FILE *f)
 	fprintf(f,
 		"Total   : size(M) total: %.6lf alloc: %.6lf(%.3lf%%) free: %.6lf \tcount alloc: %-4u free: %u\n",
 		(double)total / (1024 * 1024), (double)alloc / (1024 * 1024),
-		(double)alloc * 100 / (double)total,
+		total ? ((double)alloc * 100 / (double)total) : 0,
 		(double)free / (1024 * 1024),
 		n_alloc, n_free);
 	if (last_allocs)
@@ -9802,97 +9845,6 @@ cmdline_parse_inst_t cmd_dump_one = {
 	},
 };
 
-/* *** Add/Del syn filter *** */
-struct cmd_syn_filter_result {
-	cmdline_fixed_string_t filter;
-	portid_t port_id;
-	cmdline_fixed_string_t ops;
-	cmdline_fixed_string_t priority;
-	cmdline_fixed_string_t high;
-	cmdline_fixed_string_t queue;
-	uint16_t queue_id;
-};
-
-static void
-cmd_syn_filter_parsed(void *parsed_result,
-			__rte_unused struct cmdline *cl,
-			__rte_unused void *data)
-{
-	struct cmd_syn_filter_result *res = parsed_result;
-	struct rte_eth_syn_filter syn_filter;
-	int ret = 0;
-
-	ret = rte_eth_dev_filter_supported(res->port_id,
-					RTE_ETH_FILTER_SYN);
-	if (ret < 0) {
-		printf("syn filter is not supported on port %u.\n",
-				res->port_id);
-		return;
-	}
-
-	memset(&syn_filter, 0, sizeof(syn_filter));
-
-	if (!strcmp(res->ops, "add")) {
-		if (!strcmp(res->high, "high"))
-			syn_filter.hig_pri = 1;
-		else
-			syn_filter.hig_pri = 0;
-
-		syn_filter.queue = res->queue_id;
-		ret = rte_eth_dev_filter_ctrl(res->port_id,
-						RTE_ETH_FILTER_SYN,
-						RTE_ETH_FILTER_ADD,
-						&syn_filter);
-	} else
-		ret = rte_eth_dev_filter_ctrl(res->port_id,
-						RTE_ETH_FILTER_SYN,
-						RTE_ETH_FILTER_DELETE,
-						&syn_filter);
-
-	if (ret < 0)
-		printf("syn filter programming error: (%s)\n",
-				strerror(-ret));
-}
-
-cmdline_parse_token_string_t cmd_syn_filter_filter =
-	TOKEN_STRING_INITIALIZER(struct cmd_syn_filter_result,
-	filter, "syn_filter");
-cmdline_parse_token_num_t cmd_syn_filter_port_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_syn_filter_result,
-	port_id, UINT16);
-cmdline_parse_token_string_t cmd_syn_filter_ops =
-	TOKEN_STRING_INITIALIZER(struct cmd_syn_filter_result,
-	ops, "add#del");
-cmdline_parse_token_string_t cmd_syn_filter_priority =
-	TOKEN_STRING_INITIALIZER(struct cmd_syn_filter_result,
-				priority, "priority");
-cmdline_parse_token_string_t cmd_syn_filter_high =
-	TOKEN_STRING_INITIALIZER(struct cmd_syn_filter_result,
-				high, "high#low");
-cmdline_parse_token_string_t cmd_syn_filter_queue =
-	TOKEN_STRING_INITIALIZER(struct cmd_syn_filter_result,
-				queue, "queue");
-cmdline_parse_token_num_t cmd_syn_filter_queue_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_syn_filter_result,
-				queue_id, UINT16);
-
-cmdline_parse_inst_t cmd_syn_filter = {
-	.f = cmd_syn_filter_parsed,
-	.data = NULL,
-	.help_str = "syn_filter <port_id> add|del priority high|low queue "
-		"<queue_id>: Add/Delete syn filter",
-	.tokens = {
-		(void *)&cmd_syn_filter_filter,
-		(void *)&cmd_syn_filter_port_id,
-		(void *)&cmd_syn_filter_ops,
-		(void *)&cmd_syn_filter_priority,
-		(void *)&cmd_syn_filter_high,
-		(void *)&cmd_syn_filter_queue,
-		(void *)&cmd_syn_filter_queue_id,
-		NULL,
-	},
-};
-
 /* *** queue region set *** */
 struct cmd_queue_region_result {
 	cmdline_fixed_string_t set;
@@ -9914,7 +9866,7 @@ cmd_queue_region_parsed(void *parsed_result,
 {
 	struct cmd_queue_region_result *res = parsed_result;
 	int ret = -ENOTSUP;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
 	struct rte_pmd_i40e_queue_region_conf region_conf;
 	enum rte_pmd_i40e_queue_region_op op_type;
 #endif
@@ -9922,7 +9874,7 @@ cmd_queue_region_parsed(void *parsed_result,
 	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
 		return;
 
-#ifdef RTE_LIBRTE_I40E_PMD
+#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;
@@ -9951,7 +9903,7 @@ cmdline_parse_token_string_t cmd_queue_region_port =
 	TOKEN_STRING_INITIALIZER(struct cmd_queue_region_result, port, "port");
 cmdline_parse_token_num_t cmd_queue_region_port_id =
 	TOKEN_NUM_INITIALIZER(struct cmd_queue_region_result,
-				port_id, UINT16);
+				port_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_queue_region_cmd =
 	TOKEN_STRING_INITIALIZER(struct cmd_queue_region_result,
 				 cmd, "queue-region");
@@ -9960,19 +9912,19 @@ cmdline_parse_token_string_t cmd_queue_region_id =
 				region, "region_id");
 cmdline_parse_token_num_t cmd_queue_region_index =
 	TOKEN_NUM_INITIALIZER(struct cmd_queue_region_result,
-				region_id, UINT8);
+				region_id, RTE_UINT8);
 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");
 cmdline_parse_token_num_t cmd_queue_region_queue_id =
 	TOKEN_NUM_INITIALIZER(struct cmd_queue_region_result,
-				queue_id, UINT8);
+				queue_id, RTE_UINT8);
 cmdline_parse_token_string_t cmd_queue_region_queue_num =
 	TOKEN_STRING_INITIALIZER(struct cmd_queue_region_result,
 				queue_num, "queue_num");
 cmdline_parse_token_num_t cmd_queue_region_queue_num_value =
 	TOKEN_NUM_INITIALIZER(struct cmd_queue_region_result,
-				queue_num_value, UINT8);
+				queue_num_value, RTE_UINT8);
 
 cmdline_parse_inst_t cmd_queue_region = {
 	.f = cmd_queue_region_parsed,
@@ -10013,7 +9965,7 @@ cmd_region_flowtype_parsed(void *parsed_result,
 {
 	struct cmd_region_flowtype_result *res = parsed_result;
 	int ret = -ENOTSUP;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
 	struct rte_pmd_i40e_queue_region_conf region_conf;
 	enum rte_pmd_i40e_queue_region_op op_type;
 #endif
@@ -10021,7 +9973,7 @@ cmd_region_flowtype_parsed(void *parsed_result,
 	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
 		return;
 
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
 	memset(&region_conf, 0, sizeof(region_conf));
 
 	op_type = RTE_PMD_I40E_RSS_QUEUE_REGION_FLOWTYPE_SET;
@@ -10051,7 +10003,7 @@ cmdline_parse_token_string_t cmd_region_flowtype_port =
 				port, "port");
 cmdline_parse_token_num_t cmd_region_flowtype_port_index =
 	TOKEN_NUM_INITIALIZER(struct cmd_region_flowtype_result,
-				port_id, UINT16);
+				port_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_region_flowtype_cmd =
 	TOKEN_STRING_INITIALIZER(struct cmd_region_flowtype_result,
 				cmd, "queue-region");
@@ -10060,13 +10012,13 @@ cmdline_parse_token_string_t cmd_region_flowtype_index =
 				region, "region_id");
 cmdline_parse_token_num_t cmd_region_flowtype_id =
 	TOKEN_NUM_INITIALIZER(struct cmd_region_flowtype_result,
-				region_id, UINT8);
+				region_id, RTE_UINT8);
 cmdline_parse_token_string_t cmd_region_flowtype_flow_index =
 	TOKEN_STRING_INITIALIZER(struct cmd_region_flowtype_result,
 				flowtype, "flowtype");
 cmdline_parse_token_num_t cmd_region_flowtype_flow_id =
 	TOKEN_NUM_INITIALIZER(struct cmd_region_flowtype_result,
-				flowtype_id, UINT8);
+				flowtype_id, RTE_UINT8);
 cmdline_parse_inst_t cmd_region_flowtype = {
 	.f = cmd_region_flowtype_parsed,
 	.data = NULL,
@@ -10104,7 +10056,7 @@ cmd_user_priority_region_parsed(void *parsed_result,
 {
 	struct cmd_user_priority_region_result *res = parsed_result;
 	int ret = -ENOTSUP;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
 	struct rte_pmd_i40e_queue_region_conf region_conf;
 	enum rte_pmd_i40e_queue_region_op op_type;
 #endif
@@ -10112,7 +10064,7 @@ cmd_user_priority_region_parsed(void *parsed_result,
 	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
 		return;
 
-#ifdef RTE_LIBRTE_I40E_PMD
+#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;
@@ -10142,7 +10094,7 @@ cmdline_parse_token_string_t cmd_user_priority_region_port =
 				port, "port");
 cmdline_parse_token_num_t cmd_user_priority_region_port_index =
 	TOKEN_NUM_INITIALIZER(struct cmd_user_priority_region_result,
-				port_id, UINT16);
+				port_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_user_priority_region_cmd =
 	TOKEN_STRING_INITIALIZER(struct cmd_user_priority_region_result,
 				cmd, "queue-region");
@@ -10151,13 +10103,13 @@ cmdline_parse_token_string_t cmd_user_priority_region_UP =
 				user_priority, "UP");
 cmdline_parse_token_num_t cmd_user_priority_region_UP_id =
 	TOKEN_NUM_INITIALIZER(struct cmd_user_priority_region_result,
-				user_priority_id, UINT8);
+				user_priority_id, RTE_UINT8);
 cmdline_parse_token_string_t cmd_user_priority_region_region =
 	TOKEN_STRING_INITIALIZER(struct cmd_user_priority_region_result,
 				region, "region_id");
 cmdline_parse_token_num_t cmd_user_priority_region_region_id =
 	TOKEN_NUM_INITIALIZER(struct cmd_user_priority_region_result,
-				region_id, UINT8);
+				region_id, RTE_UINT8);
 
 cmdline_parse_inst_t cmd_user_priority_region = {
 	.f = cmd_user_priority_region_parsed,
@@ -10195,7 +10147,7 @@ cmd_flush_queue_region_parsed(void *parsed_result,
 {
 	struct cmd_flush_queue_region_result *res = parsed_result;
 	int ret = -ENOTSUP;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
 	struct rte_pmd_i40e_queue_region_conf region_conf;
 	enum rte_pmd_i40e_queue_region_op op_type;
 #endif
@@ -10203,7 +10155,7 @@ cmd_flush_queue_region_parsed(void *parsed_result,
 	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
 		return;
 
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
 	memset(&region_conf, 0, sizeof(region_conf));
 
 	if (strcmp(res->what, "on") == 0)
@@ -10235,7 +10187,7 @@ cmdline_parse_token_string_t cmd_flush_queue_region_port =
 				port, "port");
 cmdline_parse_token_num_t cmd_flush_queue_region_port_index =
 	TOKEN_NUM_INITIALIZER(struct cmd_flush_queue_region_result,
-				port_id, UINT16);
+				port_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_flush_queue_region_cmd =
 	TOKEN_STRING_INITIALIZER(struct cmd_flush_queue_region_result,
 				cmd, "queue-region");
@@ -10277,7 +10229,7 @@ cmd_show_queue_region_info_parsed(void *parsed_result,
 {
 	struct cmd_show_queue_region_info *res = parsed_result;
 	int ret = -ENOTSUP;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
 	struct rte_pmd_i40e_queue_regions rte_pmd_regions;
 	enum rte_pmd_i40e_queue_region_op op_type;
 #endif
@@ -10285,7 +10237,7 @@ cmd_show_queue_region_info_parsed(void *parsed_result,
 	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
 		return;
 
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
 	memset(&rte_pmd_regions, 0, sizeof(rte_pmd_regions));
 
 	op_type = RTE_PMD_I40E_RSS_QUEUE_REGION_INFO_GET;
@@ -10316,7 +10268,7 @@ cmdline_parse_token_string_t cmd_show_queue_region_info_port =
 				port, "port");
 cmdline_parse_token_num_t cmd_show_queue_region_info_port_index =
 	TOKEN_NUM_INITIALIZER(struct cmd_show_queue_region_info,
-				port_id, UINT16);
+				port_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_show_queue_region_info_cmd =
 	TOKEN_STRING_INITIALIZER(struct cmd_show_queue_region_info,
 				cmd, "queue-region");
@@ -10335,3149 +10287,586 @@ cmdline_parse_inst_t cmd_show_queue_region_info_all = {
 	},
 };
 
-/* *** ADD/REMOVE A 2tuple FILTER *** */
-struct cmd_2tuple_filter_result {
-	cmdline_fixed_string_t filter;
-	portid_t port_id;
-	cmdline_fixed_string_t ops;
-	cmdline_fixed_string_t dst_port;
-	uint16_t dst_port_value;
-	cmdline_fixed_string_t protocol;
-	uint8_t protocol_value;
-	cmdline_fixed_string_t mask;
-	uint8_t  mask_value;
-	cmdline_fixed_string_t tcp_flags;
-	uint8_t tcp_flags_value;
-	cmdline_fixed_string_t priority;
-	uint8_t  priority_value;
-	cmdline_fixed_string_t queue;
-	uint16_t  queue_id;
-};
+/* *** Filters Control *** */
 
-static void
-cmd_2tuple_filter_parsed(void *parsed_result,
-			__rte_unused struct cmdline *cl,
-			__rte_unused void *data)
-{
-	struct rte_eth_ntuple_filter filter;
-	struct cmd_2tuple_filter_result *res = parsed_result;
-	int ret = 0;
+#define IPV4_ADDR_TO_UINT(ip_addr, ip) \
+do { \
+	if ((ip_addr).family == AF_INET) \
+		(ip) = (ip_addr).addr.ipv4.s_addr; \
+	else { \
+		printf("invalid parameter.\n"); \
+		return; \
+	} \
+} while (0)
 
-	ret = rte_eth_dev_filter_supported(res->port_id, RTE_ETH_FILTER_NTUPLE);
-	if (ret < 0) {
-		printf("ntuple filter is not supported on port %u.\n",
-			res->port_id);
-		return;
-	}
+#define IPV6_ADDR_TO_ARRAY(ip_addr, ip) \
+do { \
+	if ((ip_addr).family == AF_INET6) \
+		rte_memcpy(&(ip), \
+				 &((ip_addr).addr.ipv6), \
+				 sizeof(struct in6_addr)); \
+	else { \
+		printf("invalid parameter.\n"); \
+		return; \
+	} \
+} while (0)
 
-	memset(&filter, 0, sizeof(struct rte_eth_ntuple_filter));
+#ifdef RTE_NET_I40E
 
-	filter.flags = RTE_2TUPLE_FLAGS;
-	filter.dst_port_mask = (res->mask_value & 0x02) ? UINT16_MAX : 0;
-	filter.proto_mask = (res->mask_value & 0x01) ? UINT8_MAX : 0;
-	filter.proto = res->protocol_value;
-	filter.priority = res->priority_value;
-	if (res->tcp_flags_value != 0 && filter.proto != IPPROTO_TCP) {
-		printf("nonzero tcp_flags is only meaningful"
-			" when protocol is TCP.\n");
-		return;
-	}
-	if (res->tcp_flags_value > RTE_NTUPLE_TCP_FLAGS_MASK) {
-		printf("invalid TCP flags.\n");
-		return;
-	}
+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},
+	};
 
-	if (res->tcp_flags_value != 0) {
-		filter.flags |= RTE_NTUPLE_FLAGS_TCP_FLAG;
-		filter.tcp_flags = res->tcp_flags_value;
+	for (i = 0; i < RTE_DIM(flowtype_str); i++) {
+		if (!strcmp(flowtype_str[i].str, string))
+			return flowtype_str[i].type;
 	}
 
-	/* need convert to big endian. */
-	filter.dst_port = rte_cpu_to_be_16(res->dst_port_value);
-	filter.queue = res->queue_id;
-
-	if (!strcmp(res->ops, "add"))
-		ret = rte_eth_dev_filter_ctrl(res->port_id,
-				RTE_ETH_FILTER_NTUPLE,
-				RTE_ETH_FILTER_ADD,
-				&filter);
-	else
-		ret = rte_eth_dev_filter_ctrl(res->port_id,
-				RTE_ETH_FILTER_NTUPLE,
-				RTE_ETH_FILTER_DELETE,
-				&filter);
-	if (ret < 0)
-		printf("2tuple filter programming error: (%s)\n",
-			strerror(-ret));
+	if (isdigit(string[0]) && atoi(string) > 0 && atoi(string) < 64)
+		return (uint16_t)atoi(string);
 
+	return RTE_ETH_FLOW_UNKNOWN;
 }
 
-cmdline_parse_token_string_t cmd_2tuple_filter_filter =
-	TOKEN_STRING_INITIALIZER(struct cmd_2tuple_filter_result,
-				 filter, "2tuple_filter");
-cmdline_parse_token_num_t cmd_2tuple_filter_port_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_2tuple_filter_result,
-				port_id, UINT16);
-cmdline_parse_token_string_t cmd_2tuple_filter_ops =
-	TOKEN_STRING_INITIALIZER(struct cmd_2tuple_filter_result,
-				 ops, "add#del");
-cmdline_parse_token_string_t cmd_2tuple_filter_dst_port =
-	TOKEN_STRING_INITIALIZER(struct cmd_2tuple_filter_result,
-				dst_port, "dst_port");
-cmdline_parse_token_num_t cmd_2tuple_filter_dst_port_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_2tuple_filter_result,
-				dst_port_value, UINT16);
-cmdline_parse_token_string_t cmd_2tuple_filter_protocol =
-	TOKEN_STRING_INITIALIZER(struct cmd_2tuple_filter_result,
-				protocol, "protocol");
-cmdline_parse_token_num_t cmd_2tuple_filter_protocol_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_2tuple_filter_result,
-				protocol_value, UINT8);
-cmdline_parse_token_string_t cmd_2tuple_filter_mask =
-	TOKEN_STRING_INITIALIZER(struct cmd_2tuple_filter_result,
-				mask, "mask");
-cmdline_parse_token_num_t cmd_2tuple_filter_mask_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_2tuple_filter_result,
-				mask_value, INT8);
-cmdline_parse_token_string_t cmd_2tuple_filter_tcp_flags =
-	TOKEN_STRING_INITIALIZER(struct cmd_2tuple_filter_result,
-				tcp_flags, "tcp_flags");
-cmdline_parse_token_num_t cmd_2tuple_filter_tcp_flags_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_2tuple_filter_result,
-				tcp_flags_value, UINT8);
-cmdline_parse_token_string_t cmd_2tuple_filter_priority =
-	TOKEN_STRING_INITIALIZER(struct cmd_2tuple_filter_result,
-				priority, "priority");
-cmdline_parse_token_num_t cmd_2tuple_filter_priority_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_2tuple_filter_result,
-				priority_value, UINT8);
-cmdline_parse_token_string_t cmd_2tuple_filter_queue =
-	TOKEN_STRING_INITIALIZER(struct cmd_2tuple_filter_result,
-				queue, "queue");
-cmdline_parse_token_num_t cmd_2tuple_filter_queue_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_2tuple_filter_result,
-				queue_id, UINT16);
-
-cmdline_parse_inst_t cmd_2tuple_filter = {
-	.f = cmd_2tuple_filter_parsed,
-	.data = NULL,
-	.help_str = "2tuple_filter <port_id> add|del dst_port <value> protocol "
-		"<value> mask <value> tcp_flags <value> priority <value> queue "
-		"<queue_id>: Add a 2tuple filter",
-	.tokens = {
-		(void *)&cmd_2tuple_filter_filter,
-		(void *)&cmd_2tuple_filter_port_id,
-		(void *)&cmd_2tuple_filter_ops,
-		(void *)&cmd_2tuple_filter_dst_port,
-		(void *)&cmd_2tuple_filter_dst_port_value,
-		(void *)&cmd_2tuple_filter_protocol,
-		(void *)&cmd_2tuple_filter_protocol_value,
-		(void *)&cmd_2tuple_filter_mask,
-		(void *)&cmd_2tuple_filter_mask_value,
-		(void *)&cmd_2tuple_filter_tcp_flags,
-		(void *)&cmd_2tuple_filter_tcp_flags_value,
-		(void *)&cmd_2tuple_filter_priority,
-		(void *)&cmd_2tuple_filter_priority_value,
-		(void *)&cmd_2tuple_filter_queue,
-		(void *)&cmd_2tuple_filter_queue_id,
-		NULL,
-	},
-};
-
-/* *** ADD/REMOVE A 5tuple FILTER *** */
-struct cmd_5tuple_filter_result {
-	cmdline_fixed_string_t filter;
+/* *** 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 dst_ip;
-	cmdline_ipaddr_t dst_ip_value;
-	cmdline_fixed_string_t src_ip;
-	cmdline_ipaddr_t src_ip_value;
-	cmdline_fixed_string_t dst_port;
-	uint16_t dst_port_value;
-	cmdline_fixed_string_t src_port;
-	uint16_t src_port_value;
-	cmdline_fixed_string_t protocol;
-	uint8_t protocol_value;
-	cmdline_fixed_string_t mask;
-	uint8_t  mask_value;
-	cmdline_fixed_string_t tcp_flags;
-	uint8_t tcp_flags_value;
-	cmdline_fixed_string_t priority;
-	uint8_t  priority_value;
+	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_5tuple_filter_parsed(void *parsed_result,
-			__rte_unused struct cmdline *cl,
-			__rte_unused void *data)
+cmd_flow_director_filter_parsed(void *parsed_result,
+			  __rte_unused struct cmdline *cl,
+			  __rte_unused void *data)
 {
-	struct rte_eth_ntuple_filter filter;
-	struct cmd_5tuple_filter_result *res = parsed_result;
+	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;
 
-	ret = rte_eth_dev_filter_supported(res->port_id, RTE_ETH_FILTER_NTUPLE);
-	if (ret < 0) {
-		printf("ntuple filter is not supported on port %u.\n",
-			res->port_id);
-		return;
-	}
-
-	memset(&filter, 0, sizeof(struct rte_eth_ntuple_filter));
+	memset(&conf, 0, sizeof(conf));
 
-	filter.flags = RTE_5TUPLE_FLAGS;
-	filter.dst_ip_mask = (res->mask_value & 0x10) ? UINT32_MAX : 0;
-	filter.src_ip_mask = (res->mask_value & 0x08) ? UINT32_MAX : 0;
-	filter.dst_port_mask = (res->mask_value & 0x04) ? UINT16_MAX : 0;
-	filter.src_port_mask = (res->mask_value & 0x02) ? UINT16_MAX : 0;
-	filter.proto_mask = (res->mask_value & 0x01) ? UINT8_MAX : 0;
-	filter.proto = res->protocol_value;
-	filter.priority = res->priority_value;
-	if (res->tcp_flags_value != 0 && filter.proto != IPPROTO_TCP) {
-		printf("nonzero tcp_flags is only meaningful"
-			" when protocol is TCP.\n");
+	if (flow_type == RTE_ETH_FLOW_UNKNOWN) {
+		printf("Invalid flow type specified.\n");
 		return;
 	}
-	if (res->tcp_flags_value > RTE_NTUPLE_TCP_FLAGS_MASK) {
-		printf("invalid TCP flags.\n");
+	ret = rte_pmd_i40e_flow_type_mapping_get(res->port_id,
+						 mapping);
+	if (ret)
+		return;
+	if (mapping[flow_type].pctype == 0ULL) {
+		printf("Invalid flow type specified.\n");
 		return;
 	}
-
-	if (res->tcp_flags_value != 0) {
-		filter.flags |= RTE_NTUPLE_FLAGS_TCP_FLAG;
-		filter.tcp_flags = res->tcp_flags_value;
-	}
-
-	if (res->dst_ip_value.family == AF_INET)
-		/* no need to convert, already big endian. */
-		filter.dst_ip = res->dst_ip_value.addr.ipv4.s_addr;
-	else {
-		if (filter.dst_ip_mask == 0) {
-			printf("can not support ipv6 involved compare.\n");
-			return;
+	for (i = 0; i < RTE_PMD_I40E_PCTYPE_MAX; i++) {
+		if (mapping[flow_type].pctype & (1ULL << i)) {
+			conf.input.pctype = i;
+			break;
 		}
-		filter.dst_ip = 0;
 	}
 
-	if (res->src_ip_value.family == AF_INET)
-		/* no need to convert, already big endian. */
-		filter.src_ip = res->src_ip_value.addr.ipv4.s_addr;
-	else {
-		if (filter.src_ip_mask == 0) {
-			printf("can not support ipv6 involved compare.\n");
-			return;
-		}
-		filter.src_ip = 0;
-	}
-	/* need convert to big endian. */
-	filter.dst_port = rte_cpu_to_be_16(res->dst_port_value);
-	filter.src_port = rte_cpu_to_be_16(res->src_port_value);
-	filter.queue = res->queue_id;
-
-	if (!strcmp(res->ops, "add"))
-		ret = rte_eth_dev_filter_ctrl(res->port_id,
-				RTE_ETH_FILTER_NTUPLE,
-				RTE_ETH_FILTER_ADD,
-				&filter);
+	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
-		ret = rte_eth_dev_filter_ctrl(res->port_id,
-				RTE_ETH_FILTER_NTUPLE,
-				RTE_ETH_FILTER_DELETE,
-				&filter);
+		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)
-		printf("5tuple filter programming error: (%s)\n",
-			strerror(-ret));
+		printf("flow director config error: (%s)\n",
+		       strerror(-ret));
+	close_file(conf.input.packet);
 }
 
-cmdline_parse_token_string_t cmd_5tuple_filter_filter =
-	TOKEN_STRING_INITIALIZER(struct cmd_5tuple_filter_result,
-				 filter, "5tuple_filter");
-cmdline_parse_token_num_t cmd_5tuple_filter_port_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_5tuple_filter_result,
-				port_id, UINT16);
-cmdline_parse_token_string_t cmd_5tuple_filter_ops =
-	TOKEN_STRING_INITIALIZER(struct cmd_5tuple_filter_result,
-				 ops, "add#del");
-cmdline_parse_token_string_t cmd_5tuple_filter_dst_ip =
-	TOKEN_STRING_INITIALIZER(struct cmd_5tuple_filter_result,
-				dst_ip, "dst_ip");
-cmdline_parse_token_ipaddr_t cmd_5tuple_filter_dst_ip_value =
-	TOKEN_IPADDR_INITIALIZER(struct cmd_5tuple_filter_result,
-				dst_ip_value);
-cmdline_parse_token_string_t cmd_5tuple_filter_src_ip =
-	TOKEN_STRING_INITIALIZER(struct cmd_5tuple_filter_result,
-				src_ip, "src_ip");
-cmdline_parse_token_ipaddr_t cmd_5tuple_filter_src_ip_value =
-	TOKEN_IPADDR_INITIALIZER(struct cmd_5tuple_filter_result,
-				src_ip_value);
-cmdline_parse_token_string_t cmd_5tuple_filter_dst_port =
-	TOKEN_STRING_INITIALIZER(struct cmd_5tuple_filter_result,
-				dst_port, "dst_port");
-cmdline_parse_token_num_t cmd_5tuple_filter_dst_port_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_5tuple_filter_result,
-				dst_port_value, UINT16);
-cmdline_parse_token_string_t cmd_5tuple_filter_src_port =
-	TOKEN_STRING_INITIALIZER(struct cmd_5tuple_filter_result,
-				src_port, "src_port");
-cmdline_parse_token_num_t cmd_5tuple_filter_src_port_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_5tuple_filter_result,
-				src_port_value, UINT16);
-cmdline_parse_token_string_t cmd_5tuple_filter_protocol =
-	TOKEN_STRING_INITIALIZER(struct cmd_5tuple_filter_result,
-				protocol, "protocol");
-cmdline_parse_token_num_t cmd_5tuple_filter_protocol_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_5tuple_filter_result,
-				protocol_value, UINT8);
-cmdline_parse_token_string_t cmd_5tuple_filter_mask =
-	TOKEN_STRING_INITIALIZER(struct cmd_5tuple_filter_result,
-				mask, "mask");
-cmdline_parse_token_num_t cmd_5tuple_filter_mask_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_5tuple_filter_result,
-				mask_value, INT8);
-cmdline_parse_token_string_t cmd_5tuple_filter_tcp_flags =
-	TOKEN_STRING_INITIALIZER(struct cmd_5tuple_filter_result,
-				tcp_flags, "tcp_flags");
-cmdline_parse_token_num_t cmd_5tuple_filter_tcp_flags_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_5tuple_filter_result,
-				tcp_flags_value, UINT8);
-cmdline_parse_token_string_t cmd_5tuple_filter_priority =
-	TOKEN_STRING_INITIALIZER(struct cmd_5tuple_filter_result,
-				priority, "priority");
-cmdline_parse_token_num_t cmd_5tuple_filter_priority_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_5tuple_filter_result,
-				priority_value, UINT8);
-cmdline_parse_token_string_t cmd_5tuple_filter_queue =
-	TOKEN_STRING_INITIALIZER(struct cmd_5tuple_filter_result,
-				queue, "queue");
-cmdline_parse_token_num_t cmd_5tuple_filter_queue_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_5tuple_filter_result,
-				queue_id, UINT16);
-
-cmdline_parse_inst_t cmd_5tuple_filter = {
-	.f = cmd_5tuple_filter_parsed,
-	.data = NULL,
-	.help_str = "5tuple_filter <port_id> add|del dst_ip <value> "
-		"src_ip <value> dst_port <value> src_port <value> "
-		"protocol <value>  mask <value> tcp_flags <value> "
-		"priority <value> queue <queue_id>: Add/Del a 5tuple filter",
-	.tokens = {
-		(void *)&cmd_5tuple_filter_filter,
-		(void *)&cmd_5tuple_filter_port_id,
-		(void *)&cmd_5tuple_filter_ops,
-		(void *)&cmd_5tuple_filter_dst_ip,
-		(void *)&cmd_5tuple_filter_dst_ip_value,
-		(void *)&cmd_5tuple_filter_src_ip,
-		(void *)&cmd_5tuple_filter_src_ip_value,
-		(void *)&cmd_5tuple_filter_dst_port,
-		(void *)&cmd_5tuple_filter_dst_port_value,
-		(void *)&cmd_5tuple_filter_src_port,
-		(void *)&cmd_5tuple_filter_src_port_value,
-		(void *)&cmd_5tuple_filter_protocol,
-		(void *)&cmd_5tuple_filter_protocol_value,
-		(void *)&cmd_5tuple_filter_mask,
-		(void *)&cmd_5tuple_filter_mask_value,
-		(void *)&cmd_5tuple_filter_tcp_flags,
-		(void *)&cmd_5tuple_filter_tcp_flags_value,
-		(void *)&cmd_5tuple_filter_priority,
-		(void *)&cmd_5tuple_filter_priority_value,
-		(void *)&cmd_5tuple_filter_queue,
-		(void *)&cmd_5tuple_filter_queue_id,
-		NULL,
-	},
-};
-
-/* *** ADD/REMOVE A flex FILTER *** */
-struct cmd_flex_filter_result {
-	cmdline_fixed_string_t filter;
-	cmdline_fixed_string_t ops;
-	portid_t port_id;
-	cmdline_fixed_string_t len;
-	uint8_t len_value;
-	cmdline_fixed_string_t bytes;
-	cmdline_fixed_string_t bytes_value;
-	cmdline_fixed_string_t mask;
-	cmdline_fixed_string_t mask_value;
-	cmdline_fixed_string_t priority;
-	uint8_t priority_value;
-	cmdline_fixed_string_t queue;
-	uint16_t queue_id;
-};
-
-static int xdigit2val(unsigned char c)
-{
-	int val;
-	if (isdigit(c))
-		val = c - '0';
-	else if (isupper(c))
-		val = c - 'A' + 10;
-	else
-		val = c - 'a' + 10;
-	return val;
-}
-
-static void
-cmd_flex_filter_parsed(void *parsed_result,
-			  __rte_unused struct cmdline *cl,
-			  __rte_unused void *data)
-{
-	int ret = 0;
-	struct rte_eth_flex_filter filter;
-	struct cmd_flex_filter_result *res = parsed_result;
-	char *bytes_ptr, *mask_ptr;
-	uint16_t len, i, j = 0;
-	char c;
-	int val;
-	uint8_t byte = 0;
-
-	if (res->len_value > RTE_FLEX_FILTER_MAXLEN) {
-		printf("the len exceed the max length 128\n");
-		return;
-	}
-	memset(&filter, 0, sizeof(struct rte_eth_flex_filter));
-	filter.len = res->len_value;
-	filter.priority = res->priority_value;
-	filter.queue = res->queue_id;
-	bytes_ptr = res->bytes_value;
-	mask_ptr = res->mask_value;
-
-	 /* translate bytes string to array. */
-	if (bytes_ptr[0] == '0' && ((bytes_ptr[1] == 'x') ||
-		(bytes_ptr[1] == 'X')))
-		bytes_ptr += 2;
-	len = strnlen(bytes_ptr, res->len_value * 2);
-	if (len == 0 || (len % 8 != 0)) {
-		printf("please check len and bytes input\n");
-		return;
-	}
-	for (i = 0; i < len; i++) {
-		c = bytes_ptr[i];
-		if (isxdigit(c) == 0) {
-			/* invalid characters. */
-			printf("invalid input\n");
-			return;
-		}
-		val = xdigit2val(c);
-		if (i % 2) {
-			byte |= val;
-			filter.bytes[j] = byte;
-			printf("bytes[%d]:%02x ", j, filter.bytes[j]);
-			j++;
-			byte = 0;
-		} else
-			byte |= val << 4;
-	}
-	printf("\n");
-	 /* translate mask string to uint8_t array. */
-	if (mask_ptr[0] == '0' && ((mask_ptr[1] == 'x') ||
-		(mask_ptr[1] == 'X')))
-		mask_ptr += 2;
-	len = strnlen(mask_ptr, (res->len_value + 3) / 4);
-	if (len == 0) {
-		printf("invalid input\n");
-		return;
-	}
-	j = 0;
-	byte = 0;
-	for (i = 0; i < len; i++) {
-		c = mask_ptr[i];
-		if (isxdigit(c) == 0) {
-			/* invalid characters. */
-			printf("invalid input\n");
-			return;
-		}
-		val = xdigit2val(c);
-		if (i % 2) {
-			byte |= val;
-			filter.mask[j] = byte;
-			printf("mask[%d]:%02x ", j, filter.mask[j]);
-			j++;
-			byte = 0;
-		} else
-			byte |= val << 4;
-	}
-	printf("\n");
-
-	if (!strcmp(res->ops, "add"))
-		ret = rte_eth_dev_filter_ctrl(res->port_id,
-				RTE_ETH_FILTER_FLEXIBLE,
-				RTE_ETH_FILTER_ADD,
-				&filter);
-	else
-		ret = rte_eth_dev_filter_ctrl(res->port_id,
-				RTE_ETH_FILTER_FLEXIBLE,
-				RTE_ETH_FILTER_DELETE,
-				&filter);
-
-	if (ret < 0)
-		printf("flex filter setting error: (%s)\n", strerror(-ret));
-}
-
-cmdline_parse_token_string_t cmd_flex_filter_filter =
-	TOKEN_STRING_INITIALIZER(struct cmd_flex_filter_result,
-				filter, "flex_filter");
-cmdline_parse_token_num_t cmd_flex_filter_port_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_flex_filter_result,
-				port_id, UINT16);
-cmdline_parse_token_string_t cmd_flex_filter_ops =
-	TOKEN_STRING_INITIALIZER(struct cmd_flex_filter_result,
-				ops, "add#del");
-cmdline_parse_token_string_t cmd_flex_filter_len =
-	TOKEN_STRING_INITIALIZER(struct cmd_flex_filter_result,
-				len, "len");
-cmdline_parse_token_num_t cmd_flex_filter_len_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_flex_filter_result,
-				len_value, UINT8);
-cmdline_parse_token_string_t cmd_flex_filter_bytes =
-	TOKEN_STRING_INITIALIZER(struct cmd_flex_filter_result,
-				bytes, "bytes");
-cmdline_parse_token_string_t cmd_flex_filter_bytes_value =
-	TOKEN_STRING_INITIALIZER(struct cmd_flex_filter_result,
-				bytes_value, NULL);
-cmdline_parse_token_string_t cmd_flex_filter_mask =
-	TOKEN_STRING_INITIALIZER(struct cmd_flex_filter_result,
-				mask, "mask");
-cmdline_parse_token_string_t cmd_flex_filter_mask_value =
-	TOKEN_STRING_INITIALIZER(struct cmd_flex_filter_result,
-				mask_value, NULL);
-cmdline_parse_token_string_t cmd_flex_filter_priority =
-	TOKEN_STRING_INITIALIZER(struct cmd_flex_filter_result,
-				priority, "priority");
-cmdline_parse_token_num_t cmd_flex_filter_priority_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_flex_filter_result,
-				priority_value, UINT8);
-cmdline_parse_token_string_t cmd_flex_filter_queue =
-	TOKEN_STRING_INITIALIZER(struct cmd_flex_filter_result,
-				queue, "queue");
-cmdline_parse_token_num_t cmd_flex_filter_queue_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_flex_filter_result,
-				queue_id, UINT16);
-cmdline_parse_inst_t cmd_flex_filter = {
-	.f = cmd_flex_filter_parsed,
-	.data = NULL,
-	.help_str = "flex_filter <port_id> add|del len <value> bytes "
-		"<value> mask <value> priority <value> queue <queue_id>: "
-		"Add/Del a flex filter",
-	.tokens = {
-		(void *)&cmd_flex_filter_filter,
-		(void *)&cmd_flex_filter_port_id,
-		(void *)&cmd_flex_filter_ops,
-		(void *)&cmd_flex_filter_len,
-		(void *)&cmd_flex_filter_len_value,
-		(void *)&cmd_flex_filter_bytes,
-		(void *)&cmd_flex_filter_bytes_value,
-		(void *)&cmd_flex_filter_mask,
-		(void *)&cmd_flex_filter_mask_value,
-		(void *)&cmd_flex_filter_priority,
-		(void *)&cmd_flex_filter_priority_value,
-		(void *)&cmd_flex_filter_queue,
-		(void *)&cmd_flex_filter_queue_id,
-		NULL,
-	},
-};
-
-/* *** Filters Control *** */
-
-/* *** deal with ethertype filter *** */
-struct cmd_ethertype_filter_result {
-	cmdline_fixed_string_t filter;
-	portid_t port_id;
-	cmdline_fixed_string_t ops;
-	cmdline_fixed_string_t mac;
-	struct rte_ether_addr mac_addr;
-	cmdline_fixed_string_t ethertype;
-	uint16_t ethertype_value;
-	cmdline_fixed_string_t drop;
-	cmdline_fixed_string_t queue;
-	uint16_t  queue_id;
-};
-
-cmdline_parse_token_string_t cmd_ethertype_filter_filter =
-	TOKEN_STRING_INITIALIZER(struct cmd_ethertype_filter_result,
-				 filter, "ethertype_filter");
-cmdline_parse_token_num_t cmd_ethertype_filter_port_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_ethertype_filter_result,
-			      port_id, UINT16);
-cmdline_parse_token_string_t cmd_ethertype_filter_ops =
-	TOKEN_STRING_INITIALIZER(struct cmd_ethertype_filter_result,
-				 ops, "add#del");
-cmdline_parse_token_string_t cmd_ethertype_filter_mac =
-	TOKEN_STRING_INITIALIZER(struct cmd_ethertype_filter_result,
-				 mac, "mac_addr#mac_ignr");
-cmdline_parse_token_etheraddr_t cmd_ethertype_filter_mac_addr =
-	TOKEN_ETHERADDR_INITIALIZER(struct cmd_ethertype_filter_result,
-				     mac_addr);
-cmdline_parse_token_string_t cmd_ethertype_filter_ethertype =
-	TOKEN_STRING_INITIALIZER(struct cmd_ethertype_filter_result,
-				 ethertype, "ethertype");
-cmdline_parse_token_num_t cmd_ethertype_filter_ethertype_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_ethertype_filter_result,
-			      ethertype_value, UINT16);
-cmdline_parse_token_string_t cmd_ethertype_filter_drop =
-	TOKEN_STRING_INITIALIZER(struct cmd_ethertype_filter_result,
+cmdline_parse_token_string_t cmd_flow_director_filter =
+	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
+				 flow_director_filter, "flow_director_filter");
+cmdline_parse_token_num_t cmd_flow_director_port_id =
+	TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
+			      port_id, RTE_UINT16);
+cmdline_parse_token_string_t cmd_flow_director_ops =
+	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
+				 ops, "add#del#update");
+cmdline_parse_token_string_t cmd_flow_director_flow =
+	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
+				 flow, "flow");
+cmdline_parse_token_string_t cmd_flow_director_flow_type =
+	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
+		flow_type, NULL);
+cmdline_parse_token_string_t cmd_flow_director_drop =
+	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
 				 drop, "drop#fwd");
-cmdline_parse_token_string_t cmd_ethertype_filter_queue =
-	TOKEN_STRING_INITIALIZER(struct cmd_ethertype_filter_result,
+cmdline_parse_token_string_t cmd_flow_director_queue =
+	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
 				 queue, "queue");
-cmdline_parse_token_num_t cmd_ethertype_filter_queue_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_ethertype_filter_result,
-			      queue_id, UINT16);
-
-static void
-cmd_ethertype_filter_parsed(void *parsed_result,
-			  __rte_unused struct cmdline *cl,
-			  __rte_unused void *data)
-{
-	struct cmd_ethertype_filter_result *res = parsed_result;
-	struct rte_eth_ethertype_filter filter;
-	int ret = 0;
-
-	ret = rte_eth_dev_filter_supported(res->port_id,
-			RTE_ETH_FILTER_ETHERTYPE);
-	if (ret < 0) {
-		printf("ethertype filter is not supported on port %u.\n",
-			res->port_id);
-		return;
-	}
+cmdline_parse_token_num_t cmd_flow_director_queue_id =
+	TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
+			      queue_id, RTE_UINT16);
+cmdline_parse_token_string_t cmd_flow_director_fd_id =
+	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
+				 fd_id, "fd_id");
+cmdline_parse_token_num_t cmd_flow_director_fd_id_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
+			      fd_id_value, RTE_UINT32);
 
-	memset(&filter, 0, sizeof(filter));
-	if (!strcmp(res->mac, "mac_addr")) {
-		filter.flags |= RTE_ETHTYPE_FLAGS_MAC;
-		rte_memcpy(&filter.mac_addr, &res->mac_addr,
-			sizeof(struct rte_ether_addr));
-	}
-	if (!strcmp(res->drop, "drop"))
-		filter.flags |= RTE_ETHTYPE_FLAGS_DROP;
-	filter.ether_type = res->ethertype_value;
-	filter.queue = res->queue_id;
-
-	if (!strcmp(res->ops, "add"))
-		ret = rte_eth_dev_filter_ctrl(res->port_id,
-				RTE_ETH_FILTER_ETHERTYPE,
-				RTE_ETH_FILTER_ADD,
-				&filter);
-	else
-		ret = rte_eth_dev_filter_ctrl(res->port_id,
-				RTE_ETH_FILTER_ETHERTYPE,
-				RTE_ETH_FILTER_DELETE,
-				&filter);
-	if (ret < 0)
-		printf("ethertype filter programming error: (%s)\n",
-			strerror(-ret));
-}
+cmdline_parse_token_string_t cmd_flow_director_mode =
+	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
+				 mode, "mode");
+cmdline_parse_token_string_t cmd_flow_director_mode_raw =
+	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
+				 mode_value, "raw");
+cmdline_parse_token_string_t cmd_flow_director_packet =
+	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
+				 packet, "packet");
+cmdline_parse_token_string_t cmd_flow_director_filepath =
+	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
+				 filepath, NULL);
 
-cmdline_parse_inst_t cmd_ethertype_filter = {
-	.f = cmd_ethertype_filter_parsed,
+cmdline_parse_inst_t cmd_add_del_raw_flow_director = {
+	.f = cmd_flow_director_filter_parsed,
 	.data = NULL,
-	.help_str = "ethertype_filter <port_id> add|del mac_addr|mac_ignr "
-		"<mac_addr> ethertype <value> drop|fw queue <queue_id>: "
-		"Add or delete an ethertype filter entry",
+	.help_str = "flow_director_filter ... : Add or delete a raw flow "
+		"director entry on NIC",
 	.tokens = {
-		(void *)&cmd_ethertype_filter_filter,
-		(void *)&cmd_ethertype_filter_port_id,
-		(void *)&cmd_ethertype_filter_ops,
-		(void *)&cmd_ethertype_filter_mac,
-		(void *)&cmd_ethertype_filter_mac_addr,
-		(void *)&cmd_ethertype_filter_ethertype,
-		(void *)&cmd_ethertype_filter_ethertype_value,
-		(void *)&cmd_ethertype_filter_drop,
-		(void *)&cmd_ethertype_filter_queue,
-		(void *)&cmd_ethertype_filter_queue_id,
+		(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,
 	},
 };
 
-/* *** deal with flow director filter *** */
-struct cmd_flow_director_result {
-	cmdline_fixed_string_t flow_director_filter;
+#endif /* RTE_NET_I40E */
+
+/* *** 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;
-	cmdline_fixed_string_t ops;
-	cmdline_fixed_string_t flow;
-	cmdline_fixed_string_t flow_type;
-	cmdline_fixed_string_t ether;
-	uint16_t ether_type;
-	cmdline_fixed_string_t src;
-	cmdline_ipaddr_t ip_src;
+	cmdline_fixed_string_t vlan;
+	uint16_t vlan_mask;
+	cmdline_fixed_string_t src_mask;
+	cmdline_ipaddr_t ipv4_src;
+	cmdline_ipaddr_t ipv6_src;
 	uint16_t port_src;
-	cmdline_fixed_string_t dst;
-	cmdline_ipaddr_t ip_dst;
+	cmdline_fixed_string_t dst_mask;
+	cmdline_ipaddr_t ipv4_dst;
+	cmdline_ipaddr_t ipv6_dst;
 	uint16_t port_dst;
-	cmdline_fixed_string_t verify_tag;
-	uint32_t verify_tag_value;
-	cmdline_fixed_string_t tos;
-	uint8_t tos_value;
-	cmdline_fixed_string_t proto;
-	uint8_t proto_value;
-	cmdline_fixed_string_t ttl;
-	uint8_t ttl_value;
-	cmdline_fixed_string_t vlan;
-	uint16_t vlan_value;
-	cmdline_fixed_string_t flexbytes;
-	cmdline_fixed_string_t flexbytes_value;
-	cmdline_fixed_string_t pf_vf;
-	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 mac;
-	struct rte_ether_addr mac_addr;
-	cmdline_fixed_string_t tunnel;
-	cmdline_fixed_string_t tunnel_type;
+	uint8_t mac_addr_byte_mask;
 	cmdline_fixed_string_t tunnel_id;
-	uint32_t tunnel_id_value;
-	cmdline_fixed_string_t packet;
-	char filepath[];
+	uint32_t tunnel_id_mask;
+	cmdline_fixed_string_t tunnel_type;
+	uint8_t tunnel_type_mask;
 };
 
-static inline int
-parse_flexbytes(const char *q_arg, uint8_t *flexbytes, uint16_t max_num)
-{
-	char s[256];
-	const char *p, *p0 = q_arg;
-	char *end;
-	unsigned long int_fld;
-	char *str_fld[max_num];
-	int i;
-	unsigned size;
-	int ret = -1;
-
-	p = strchr(p0, '(');
-	if (p == NULL)
-		return -1;
-	++p;
-	p0 = strchr(p, ')');
-	if (p0 == NULL)
-		return -1;
-
-	size = p0 - p;
-	if (size >= sizeof(s))
-		return -1;
-
-	snprintf(s, sizeof(s), "%.*s", size, p);
-	ret = rte_strsplit(s, sizeof(s), str_fld, max_num, ',');
-	if (ret < 0 || ret > max_num)
-		return -1;
-	for (i = 0; i < ret; i++) {
-		errno = 0;
-		int_fld = strtoul(str_fld[i], &end, 0);
-		if (errno != 0 || *end != '\0' || int_fld > UINT8_MAX)
-			return -1;
-		flexbytes[i] = (uint8_t)int_fld;
-	}
-	return ret;
-}
-
-static uint16_t
-str2flowtype(char *string)
+static void
+cmd_flow_director_mask_parsed(void *parsed_result,
+			  __rte_unused struct cmdline *cl,
+			  __rte_unused void *data)
 {
-	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},
-	};
+	struct cmd_flow_director_mask_result *res = parsed_result;
+	struct rte_eth_fdir_masks *mask;
+	struct rte_port *port;
 
-	for (i = 0; i < RTE_DIM(flowtype_str); i++) {
-		if (!strcmp(flowtype_str[i].str, string))
-			return flowtype_str[i].type;
+	port = &ports[res->port_id];
+	/** Check if the port is not started **/
+	if (port->port_status != RTE_PORT_STOPPED) {
+		printf("Please stop port %d first\n", res->port_id);
+		return;
 	}
 
-	if (isdigit(string[0]) && atoi(string) > 0 && atoi(string) < 64)
-		return (uint16_t)atoi(string);
-
-	return RTE_ETH_FLOW_UNKNOWN;
-}
-
-static enum rte_eth_fdir_tunnel_type
-str2fdir_tunneltype(char *string)
-{
-	uint8_t i = 0;
-
-	static const struct {
-		char str[32];
-		enum rte_eth_fdir_tunnel_type type;
-	} tunneltype_str[] = {
-		{"NVGRE", RTE_FDIR_TUNNEL_TYPE_NVGRE},
-		{"VxLAN", RTE_FDIR_TUNNEL_TYPE_VXLAN},
-	};
-
-	for (i = 0; i < RTE_DIM(tunneltype_str); i++) {
-		if (!strcmp(tunneltype_str[i].str, string))
-			return tunneltype_str[i].type;
-	}
-	return RTE_FDIR_TUNNEL_TYPE_UNKNOWN;
-}
-
-#define IPV4_ADDR_TO_UINT(ip_addr, ip) \
-do { \
-	if ((ip_addr).family == AF_INET) \
-		(ip) = (ip_addr).addr.ipv4.s_addr; \
-	else { \
-		printf("invalid parameter.\n"); \
-		return; \
-	} \
-} while (0)
-
-#define IPV6_ADDR_TO_ARRAY(ip_addr, ip) \
-do { \
-	if ((ip_addr).family == AF_INET6) \
-		rte_memcpy(&(ip), \
-				 &((ip_addr).addr.ipv6), \
-				 sizeof(struct in6_addr)); \
-	else { \
-		printf("invalid parameter.\n"); \
-		return; \
-	} \
-} while (0)
-
-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;
-	struct rte_eth_fdir_filter entry;
-	uint8_t flexbytes[RTE_ETH_FDIR_MAX_FLEXLEN];
-	char *end;
-	unsigned long vf_id;
-	int ret = 0;
-
-	ret = rte_eth_dev_filter_supported(res->port_id, RTE_ETH_FILTER_FDIR);
-	if (ret < 0) {
-		printf("flow director is not supported on port %u.\n",
-			res->port_id);
-		return;
-	}
-	memset(flexbytes, 0, sizeof(flexbytes));
-	memset(&entry, 0, sizeof(struct rte_eth_fdir_filter));
+	mask = &port->dev_conf.fdir_conf.mask;
 
 	if (fdir_conf.mode ==  RTE_FDIR_MODE_PERFECT_MAC_VLAN) {
 		if (strcmp(res->mode_value, "MAC-VLAN")) {
 			printf("Please set mode to MAC-VLAN.\n");
-			return;
-		}
-	} else if (fdir_conf.mode ==  RTE_FDIR_MODE_PERFECT_TUNNEL) {
-		if (strcmp(res->mode_value, "Tunnel")) {
-			printf("Please set mode to Tunnel.\n");
-			return;
-		}
-	} else {
-		if (!strcmp(res->mode_value, "raw")) {
-#ifdef RTE_LIBRTE_I40E_PMD
-			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) {
-				printf("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) {
-				printf("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)
-				printf("flow director config error: (%s)\n",
-				       strerror(-ret));
-			close_file(conf.input.packet);
-#endif
-			return;
-		} else if (strcmp(res->mode_value, "IP")) {
-			printf("Please set mode to IP or raw.\n");
-			return;
-		}
-		entry.input.flow_type = str2flowtype(res->flow_type);
-	}
-
-	ret = parse_flexbytes(res->flexbytes_value,
-					flexbytes,
-					RTE_ETH_FDIR_MAX_FLEXLEN);
-	if (ret < 0) {
-		printf("error: Cannot parse flexbytes input.\n");
-		return;
-	}
-
-	switch (entry.input.flow_type) {
-	case RTE_ETH_FLOW_FRAG_IPV4:
-	case RTE_ETH_FLOW_NONFRAG_IPV4_OTHER:
-		entry.input.flow.ip4_flow.proto = res->proto_value;
-		/* fall-through */
-	case RTE_ETH_FLOW_NONFRAG_IPV4_UDP:
-	case RTE_ETH_FLOW_NONFRAG_IPV4_TCP:
-		IPV4_ADDR_TO_UINT(res->ip_dst,
-			entry.input.flow.ip4_flow.dst_ip);
-		IPV4_ADDR_TO_UINT(res->ip_src,
-			entry.input.flow.ip4_flow.src_ip);
-		entry.input.flow.ip4_flow.tos = res->tos_value;
-		entry.input.flow.ip4_flow.ttl = res->ttl_value;
-		/* need convert to big endian. */
-		entry.input.flow.udp4_flow.dst_port =
-				rte_cpu_to_be_16(res->port_dst);
-		entry.input.flow.udp4_flow.src_port =
-				rte_cpu_to_be_16(res->port_src);
-		break;
-	case RTE_ETH_FLOW_NONFRAG_IPV4_SCTP:
-		IPV4_ADDR_TO_UINT(res->ip_dst,
-			entry.input.flow.sctp4_flow.ip.dst_ip);
-		IPV4_ADDR_TO_UINT(res->ip_src,
-			entry.input.flow.sctp4_flow.ip.src_ip);
-		entry.input.flow.ip4_flow.tos = res->tos_value;
-		entry.input.flow.ip4_flow.ttl = res->ttl_value;
-		/* need convert to big endian. */
-		entry.input.flow.sctp4_flow.dst_port =
-				rte_cpu_to_be_16(res->port_dst);
-		entry.input.flow.sctp4_flow.src_port =
-				rte_cpu_to_be_16(res->port_src);
-		entry.input.flow.sctp4_flow.verify_tag =
-				rte_cpu_to_be_32(res->verify_tag_value);
-		break;
-	case RTE_ETH_FLOW_FRAG_IPV6:
-	case RTE_ETH_FLOW_NONFRAG_IPV6_OTHER:
-		entry.input.flow.ipv6_flow.proto = res->proto_value;
-		/* fall-through */
-	case RTE_ETH_FLOW_NONFRAG_IPV6_UDP:
-	case RTE_ETH_FLOW_NONFRAG_IPV6_TCP:
-		IPV6_ADDR_TO_ARRAY(res->ip_dst,
-			entry.input.flow.ipv6_flow.dst_ip);
-		IPV6_ADDR_TO_ARRAY(res->ip_src,
-			entry.input.flow.ipv6_flow.src_ip);
-		entry.input.flow.ipv6_flow.tc = res->tos_value;
-		entry.input.flow.ipv6_flow.hop_limits = res->ttl_value;
-		/* need convert to big endian. */
-		entry.input.flow.udp6_flow.dst_port =
-				rte_cpu_to_be_16(res->port_dst);
-		entry.input.flow.udp6_flow.src_port =
-				rte_cpu_to_be_16(res->port_src);
-		break;
-	case RTE_ETH_FLOW_NONFRAG_IPV6_SCTP:
-		IPV6_ADDR_TO_ARRAY(res->ip_dst,
-			entry.input.flow.sctp6_flow.ip.dst_ip);
-		IPV6_ADDR_TO_ARRAY(res->ip_src,
-			entry.input.flow.sctp6_flow.ip.src_ip);
-		entry.input.flow.ipv6_flow.tc = res->tos_value;
-		entry.input.flow.ipv6_flow.hop_limits = res->ttl_value;
-		/* need convert to big endian. */
-		entry.input.flow.sctp6_flow.dst_port =
-				rte_cpu_to_be_16(res->port_dst);
-		entry.input.flow.sctp6_flow.src_port =
-				rte_cpu_to_be_16(res->port_src);
-		entry.input.flow.sctp6_flow.verify_tag =
-				rte_cpu_to_be_32(res->verify_tag_value);
-		break;
-	case RTE_ETH_FLOW_L2_PAYLOAD:
-		entry.input.flow.l2_flow.ether_type =
-			rte_cpu_to_be_16(res->ether_type);
-		break;
-	default:
-		break;
-	}
-
-	if (fdir_conf.mode ==  RTE_FDIR_MODE_PERFECT_MAC_VLAN)
-		rte_memcpy(&entry.input.flow.mac_vlan_flow.mac_addr,
-				 &res->mac_addr,
-				 sizeof(struct rte_ether_addr));
-
-	if (fdir_conf.mode ==  RTE_FDIR_MODE_PERFECT_TUNNEL) {
-		rte_memcpy(&entry.input.flow.tunnel_flow.mac_addr,
-				 &res->mac_addr,
-				 sizeof(struct rte_ether_addr));
-		entry.input.flow.tunnel_flow.tunnel_type =
-			str2fdir_tunneltype(res->tunnel_type);
-		entry.input.flow.tunnel_flow.tunnel_id =
-			rte_cpu_to_be_32(res->tunnel_id_value);
-	}
-
-	rte_memcpy(entry.input.flow_ext.flexbytes,
-		   flexbytes,
-		   RTE_ETH_FDIR_MAX_FLEXLEN);
-
-	entry.input.flow_ext.vlan_tci = rte_cpu_to_be_16(res->vlan_value);
-
-	entry.action.flex_off = 0;  /*use 0 by default */
-	if (!strcmp(res->drop, "drop"))
-		entry.action.behavior = RTE_ETH_FDIR_REJECT;
-	else
-		entry.action.behavior = RTE_ETH_FDIR_ACCEPT;
-
-	if (fdir_conf.mode !=  RTE_FDIR_MODE_PERFECT_MAC_VLAN &&
-	    fdir_conf.mode !=  RTE_FDIR_MODE_PERFECT_TUNNEL) {
-		if (!strcmp(res->pf_vf, "pf"))
-			entry.input.flow_ext.is_vf = 0;
-		else if (!strncmp(res->pf_vf, "vf", 2)) {
-			struct rte_eth_dev_info dev_info;
-
-			ret = eth_dev_info_get_print_err(res->port_id,
-						&dev_info);
-			if (ret != 0)
-				return;
-
-			errno = 0;
-			vf_id = strtoul(res->pf_vf + 2, &end, 10);
-			if (errno != 0 || *end != '\0' ||
-			    vf_id >= dev_info.max_vfs) {
-				printf("invalid parameter %s.\n", res->pf_vf);
-				return;
-			}
-			entry.input.flow_ext.is_vf = 1;
-			entry.input.flow_ext.dst_id = (uint16_t)vf_id;
-		} else {
-			printf("invalid parameter %s.\n", res->pf_vf);
-			return;
-		}
-	}
-
-	/* set to report FD ID by default */
-	entry.action.report_status = RTE_ETH_FDIR_REPORT_ID;
-	entry.action.rx_queue = res->queue_id;
-	entry.soft_id = res->fd_id_value;
-	if (!strcmp(res->ops, "add"))
-		ret = rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_FDIR,
-					     RTE_ETH_FILTER_ADD, &entry);
-	else if (!strcmp(res->ops, "del"))
-		ret = rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_FDIR,
-					     RTE_ETH_FILTER_DELETE, &entry);
-	else
-		ret = rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_FDIR,
-					     RTE_ETH_FILTER_UPDATE, &entry);
-	if (ret < 0)
-		printf("flow director programming error: (%s)\n",
-			strerror(-ret));
-}
-
-cmdline_parse_token_string_t cmd_flow_director_filter =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
-				 flow_director_filter, "flow_director_filter");
-cmdline_parse_token_num_t cmd_flow_director_port_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
-			      port_id, UINT16);
-cmdline_parse_token_string_t cmd_flow_director_ops =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
-				 ops, "add#del#update");
-cmdline_parse_token_string_t cmd_flow_director_flow =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
-				 flow, "flow");
-cmdline_parse_token_string_t cmd_flow_director_flow_type =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
-		flow_type, NULL);
-cmdline_parse_token_string_t cmd_flow_director_ether =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
-				 ether, "ether");
-cmdline_parse_token_num_t cmd_flow_director_ether_type =
-	TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
-			      ether_type, UINT16);
-cmdline_parse_token_string_t cmd_flow_director_src =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
-				 src, "src");
-cmdline_parse_token_ipaddr_t cmd_flow_director_ip_src =
-	TOKEN_IPADDR_INITIALIZER(struct cmd_flow_director_result,
-				 ip_src);
-cmdline_parse_token_num_t cmd_flow_director_port_src =
-	TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
-			      port_src, UINT16);
-cmdline_parse_token_string_t cmd_flow_director_dst =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
-				 dst, "dst");
-cmdline_parse_token_ipaddr_t cmd_flow_director_ip_dst =
-	TOKEN_IPADDR_INITIALIZER(struct cmd_flow_director_result,
-				 ip_dst);
-cmdline_parse_token_num_t cmd_flow_director_port_dst =
-	TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
-			      port_dst, UINT16);
-cmdline_parse_token_string_t cmd_flow_director_verify_tag =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
-				  verify_tag, "verify_tag");
-cmdline_parse_token_num_t cmd_flow_director_verify_tag_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
-			      verify_tag_value, UINT32);
-cmdline_parse_token_string_t cmd_flow_director_tos =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
-				 tos, "tos");
-cmdline_parse_token_num_t cmd_flow_director_tos_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
-			      tos_value, UINT8);
-cmdline_parse_token_string_t cmd_flow_director_proto =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
-				 proto, "proto");
-cmdline_parse_token_num_t cmd_flow_director_proto_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
-			      proto_value, UINT8);
-cmdline_parse_token_string_t cmd_flow_director_ttl =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
-				 ttl, "ttl");
-cmdline_parse_token_num_t cmd_flow_director_ttl_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
-			      ttl_value, UINT8);
-cmdline_parse_token_string_t cmd_flow_director_vlan =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
-				 vlan, "vlan");
-cmdline_parse_token_num_t cmd_flow_director_vlan_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
-			      vlan_value, UINT16);
-cmdline_parse_token_string_t cmd_flow_director_flexbytes =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
-				 flexbytes, "flexbytes");
-cmdline_parse_token_string_t cmd_flow_director_flexbytes_value =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
-			      flexbytes_value, NULL);
-cmdline_parse_token_string_t cmd_flow_director_drop =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
-				 drop, "drop#fwd");
-cmdline_parse_token_string_t cmd_flow_director_pf_vf =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
-			      pf_vf, NULL);
-cmdline_parse_token_string_t cmd_flow_director_queue =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
-				 queue, "queue");
-cmdline_parse_token_num_t cmd_flow_director_queue_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
-			      queue_id, UINT16);
-cmdline_parse_token_string_t cmd_flow_director_fd_id =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
-				 fd_id, "fd_id");
-cmdline_parse_token_num_t cmd_flow_director_fd_id_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
-			      fd_id_value, UINT32);
-
-cmdline_parse_token_string_t cmd_flow_director_mode =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
-				 mode, "mode");
-cmdline_parse_token_string_t cmd_flow_director_mode_ip =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
-				 mode_value, "IP");
-cmdline_parse_token_string_t cmd_flow_director_mode_mac_vlan =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
-				 mode_value, "MAC-VLAN");
-cmdline_parse_token_string_t cmd_flow_director_mode_tunnel =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
-				 mode_value, "Tunnel");
-cmdline_parse_token_string_t cmd_flow_director_mode_raw =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
-				 mode_value, "raw");
-cmdline_parse_token_string_t cmd_flow_director_mac =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
-				 mac, "mac");
-cmdline_parse_token_etheraddr_t cmd_flow_director_mac_addr =
-	TOKEN_ETHERADDR_INITIALIZER(struct cmd_flow_director_result,
-				    mac_addr);
-cmdline_parse_token_string_t cmd_flow_director_tunnel =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
-				 tunnel, "tunnel");
-cmdline_parse_token_string_t cmd_flow_director_tunnel_type =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
-				 tunnel_type, "NVGRE#VxLAN");
-cmdline_parse_token_string_t cmd_flow_director_tunnel_id =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
-				 tunnel_id, "tunnel-id");
-cmdline_parse_token_num_t cmd_flow_director_tunnel_id_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_flow_director_result,
-			      tunnel_id_value, UINT32);
-cmdline_parse_token_string_t cmd_flow_director_packet =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
-				 packet, "packet");
-cmdline_parse_token_string_t cmd_flow_director_filepath =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
-				 filepath, NULL);
-
-cmdline_parse_inst_t cmd_add_del_ip_flow_director = {
-	.f = cmd_flow_director_filter_parsed,
-	.data = NULL,
-	.help_str = "flow_director_filter <port_id> mode IP add|del|update flow"
-		" ipv4-other|ipv4-frag|ipv4-tcp|ipv4-udp|ipv4-sctp|"
-		"ipv6-other|ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|"
-		"l2_payload src <src_ip> dst <dst_ip> tos <tos_value> "
-		"proto <proto_value> ttl <ttl_value> vlan <vlan_value> "
-		"flexbytes <flexbyte_values> drop|fw <pf_vf> queue <queue_id> "
-		"fd_id <fd_id_value>: "
-		"Add or delete an ip 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_ip,
-		(void *)&cmd_flow_director_ops,
-		(void *)&cmd_flow_director_flow,
-		(void *)&cmd_flow_director_flow_type,
-		(void *)&cmd_flow_director_src,
-		(void *)&cmd_flow_director_ip_src,
-		(void *)&cmd_flow_director_dst,
-		(void *)&cmd_flow_director_ip_dst,
-		(void *)&cmd_flow_director_tos,
-		(void *)&cmd_flow_director_tos_value,
-		(void *)&cmd_flow_director_proto,
-		(void *)&cmd_flow_director_proto_value,
-		(void *)&cmd_flow_director_ttl,
-		(void *)&cmd_flow_director_ttl_value,
-		(void *)&cmd_flow_director_vlan,
-		(void *)&cmd_flow_director_vlan_value,
-		(void *)&cmd_flow_director_flexbytes,
-		(void *)&cmd_flow_director_flexbytes_value,
-		(void *)&cmd_flow_director_drop,
-		(void *)&cmd_flow_director_pf_vf,
-		(void *)&cmd_flow_director_queue,
-		(void *)&cmd_flow_director_queue_id,
-		(void *)&cmd_flow_director_fd_id,
-		(void *)&cmd_flow_director_fd_id_value,
-		NULL,
-	},
-};
-
-cmdline_parse_inst_t cmd_add_del_udp_flow_director = {
-	.f = cmd_flow_director_filter_parsed,
-	.data = NULL,
-	.help_str = "flow_director_filter ... : Add or delete an udp/tcp 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_ip,
-		(void *)&cmd_flow_director_ops,
-		(void *)&cmd_flow_director_flow,
-		(void *)&cmd_flow_director_flow_type,
-		(void *)&cmd_flow_director_src,
-		(void *)&cmd_flow_director_ip_src,
-		(void *)&cmd_flow_director_port_src,
-		(void *)&cmd_flow_director_dst,
-		(void *)&cmd_flow_director_ip_dst,
-		(void *)&cmd_flow_director_port_dst,
-		(void *)&cmd_flow_director_tos,
-		(void *)&cmd_flow_director_tos_value,
-		(void *)&cmd_flow_director_ttl,
-		(void *)&cmd_flow_director_ttl_value,
-		(void *)&cmd_flow_director_vlan,
-		(void *)&cmd_flow_director_vlan_value,
-		(void *)&cmd_flow_director_flexbytes,
-		(void *)&cmd_flow_director_flexbytes_value,
-		(void *)&cmd_flow_director_drop,
-		(void *)&cmd_flow_director_pf_vf,
-		(void *)&cmd_flow_director_queue,
-		(void *)&cmd_flow_director_queue_id,
-		(void *)&cmd_flow_director_fd_id,
-		(void *)&cmd_flow_director_fd_id_value,
-		NULL,
-	},
-};
-
-cmdline_parse_inst_t cmd_add_del_sctp_flow_director = {
-	.f = cmd_flow_director_filter_parsed,
-	.data = NULL,
-	.help_str = "flow_director_filter ... : Add or delete a sctp 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_ip,
-		(void *)&cmd_flow_director_ops,
-		(void *)&cmd_flow_director_flow,
-		(void *)&cmd_flow_director_flow_type,
-		(void *)&cmd_flow_director_src,
-		(void *)&cmd_flow_director_ip_src,
-		(void *)&cmd_flow_director_port_src,
-		(void *)&cmd_flow_director_dst,
-		(void *)&cmd_flow_director_ip_dst,
-		(void *)&cmd_flow_director_port_dst,
-		(void *)&cmd_flow_director_verify_tag,
-		(void *)&cmd_flow_director_verify_tag_value,
-		(void *)&cmd_flow_director_tos,
-		(void *)&cmd_flow_director_tos_value,
-		(void *)&cmd_flow_director_ttl,
-		(void *)&cmd_flow_director_ttl_value,
-		(void *)&cmd_flow_director_vlan,
-		(void *)&cmd_flow_director_vlan_value,
-		(void *)&cmd_flow_director_flexbytes,
-		(void *)&cmd_flow_director_flexbytes_value,
-		(void *)&cmd_flow_director_drop,
-		(void *)&cmd_flow_director_pf_vf,
-		(void *)&cmd_flow_director_queue,
-		(void *)&cmd_flow_director_queue_id,
-		(void *)&cmd_flow_director_fd_id,
-		(void *)&cmd_flow_director_fd_id_value,
-		NULL,
-	},
-};
-
-cmdline_parse_inst_t cmd_add_del_l2_flow_director = {
-	.f = cmd_flow_director_filter_parsed,
-	.data = NULL,
-	.help_str = "flow_director_filter ... : Add or delete a L2 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_ip,
-		(void *)&cmd_flow_director_ops,
-		(void *)&cmd_flow_director_flow,
-		(void *)&cmd_flow_director_flow_type,
-		(void *)&cmd_flow_director_ether,
-		(void *)&cmd_flow_director_ether_type,
-		(void *)&cmd_flow_director_flexbytes,
-		(void *)&cmd_flow_director_flexbytes_value,
-		(void *)&cmd_flow_director_drop,
-		(void *)&cmd_flow_director_pf_vf,
-		(void *)&cmd_flow_director_queue,
-		(void *)&cmd_flow_director_queue_id,
-		(void *)&cmd_flow_director_fd_id,
-		(void *)&cmd_flow_director_fd_id_value,
-		NULL,
-	},
-};
-
-cmdline_parse_inst_t cmd_add_del_mac_vlan_flow_director = {
-	.f = cmd_flow_director_filter_parsed,
-	.data = NULL,
-	.help_str = "flow_director_filter ... : Add or delete a MAC VLAN 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_mac_vlan,
-		(void *)&cmd_flow_director_ops,
-		(void *)&cmd_flow_director_mac,
-		(void *)&cmd_flow_director_mac_addr,
-		(void *)&cmd_flow_director_vlan,
-		(void *)&cmd_flow_director_vlan_value,
-		(void *)&cmd_flow_director_flexbytes,
-		(void *)&cmd_flow_director_flexbytes_value,
-		(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,
-		NULL,
-	},
-};
-
-cmdline_parse_inst_t cmd_add_del_tunnel_flow_director = {
-	.f = cmd_flow_director_filter_parsed,
-	.data = NULL,
-	.help_str = "flow_director_filter ... : Add or delete a tunnel 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_tunnel,
-		(void *)&cmd_flow_director_ops,
-		(void *)&cmd_flow_director_mac,
-		(void *)&cmd_flow_director_mac_addr,
-		(void *)&cmd_flow_director_vlan,
-		(void *)&cmd_flow_director_vlan_value,
-		(void *)&cmd_flow_director_tunnel,
-		(void *)&cmd_flow_director_tunnel_type,
-		(void *)&cmd_flow_director_tunnel_id,
-		(void *)&cmd_flow_director_tunnel_id_value,
-		(void *)&cmd_flow_director_flexbytes,
-		(void *)&cmd_flow_director_flexbytes_value,
-		(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,
-		NULL,
-	},
-};
-
-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,
-	},
-};
-
-struct cmd_flush_flow_director_result {
-	cmdline_fixed_string_t flush_flow_director;
-	portid_t port_id;
-};
-
-cmdline_parse_token_string_t cmd_flush_flow_director_flush =
-	TOKEN_STRING_INITIALIZER(struct cmd_flush_flow_director_result,
-				 flush_flow_director, "flush_flow_director");
-cmdline_parse_token_num_t cmd_flush_flow_director_port_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_flush_flow_director_result,
-			      port_id, UINT16);
-
-static void
-cmd_flush_flow_director_parsed(void *parsed_result,
-			  __rte_unused struct cmdline *cl,
-			  __rte_unused void *data)
-{
-	struct cmd_flow_director_result *res = parsed_result;
-	int ret = 0;
-
-	ret = rte_eth_dev_filter_supported(res->port_id, RTE_ETH_FILTER_FDIR);
-	if (ret < 0) {
-		printf("flow director is not supported on port %u.\n",
-			res->port_id);
-		return;
-	}
-
-	ret = rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_FDIR,
-			RTE_ETH_FILTER_FLUSH, NULL);
-	if (ret < 0)
-		printf("flow director table flushing error: (%s)\n",
-			strerror(-ret));
-}
-
-cmdline_parse_inst_t cmd_flush_flow_director = {
-	.f = cmd_flush_flow_director_parsed,
-	.data = NULL,
-	.help_str = "flush_flow_director <port_id>: "
-		"Flush all flow director entries of a device on NIC",
-	.tokens = {
-		(void *)&cmd_flush_flow_director_flush,
-		(void *)&cmd_flush_flow_director_port_id,
-		NULL,
-	},
-};
-
-/* *** 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;
-	cmdline_fixed_string_t vlan;
-	uint16_t vlan_mask;
-	cmdline_fixed_string_t src_mask;
-	cmdline_ipaddr_t ipv4_src;
-	cmdline_ipaddr_t ipv6_src;
-	uint16_t port_src;
-	cmdline_fixed_string_t dst_mask;
-	cmdline_ipaddr_t ipv4_dst;
-	cmdline_ipaddr_t ipv6_dst;
-	uint16_t port_dst;
-	cmdline_fixed_string_t mac;
-	uint8_t mac_addr_byte_mask;
-	cmdline_fixed_string_t tunnel_id;
-	uint32_t tunnel_id_mask;
-	cmdline_fixed_string_t tunnel_type;
-	uint8_t tunnel_type_mask;
-};
-
-static void
-cmd_flow_director_mask_parsed(void *parsed_result,
-			  __rte_unused struct cmdline *cl,
-			  __rte_unused void *data)
-{
-	struct cmd_flow_director_mask_result *res = parsed_result;
-	struct rte_eth_fdir_masks *mask;
-	struct rte_port *port;
-
-	port = &ports[res->port_id];
-	/** Check if the port is not started **/
-	if (port->port_status != RTE_PORT_STOPPED) {
-		printf("Please stop port %d first\n", res->port_id);
-		return;
-	}
-
-	mask = &port->dev_conf.fdir_conf.mask;
-
-	if (fdir_conf.mode ==  RTE_FDIR_MODE_PERFECT_MAC_VLAN) {
-		if (strcmp(res->mode_value, "MAC-VLAN")) {
-			printf("Please set mode to MAC-VLAN.\n");
-			return;
-		}
-
-		mask->vlan_tci_mask = rte_cpu_to_be_16(res->vlan_mask);
-	} else if (fdir_conf.mode ==  RTE_FDIR_MODE_PERFECT_TUNNEL) {
-		if (strcmp(res->mode_value, "Tunnel")) {
-			printf("Please set mode to Tunnel.\n");
-			return;
-		}
-
-		mask->vlan_tci_mask = rte_cpu_to_be_16(res->vlan_mask);
-		mask->mac_addr_byte_mask = res->mac_addr_byte_mask;
-		mask->tunnel_id_mask = rte_cpu_to_be_32(res->tunnel_id_mask);
-		mask->tunnel_type_mask = res->tunnel_type_mask;
-	} else {
-		if (strcmp(res->mode_value, "IP")) {
-			printf("Please set mode to IP.\n");
-			return;
-		}
-
-		mask->vlan_tci_mask = rte_cpu_to_be_16(res->vlan_mask);
-		IPV4_ADDR_TO_UINT(res->ipv4_src, mask->ipv4_mask.src_ip);
-		IPV4_ADDR_TO_UINT(res->ipv4_dst, mask->ipv4_mask.dst_ip);
-		IPV6_ADDR_TO_ARRAY(res->ipv6_src, mask->ipv6_mask.src_ip);
-		IPV6_ADDR_TO_ARRAY(res->ipv6_dst, mask->ipv6_mask.dst_ip);
-		mask->src_port_mask = rte_cpu_to_be_16(res->port_src);
-		mask->dst_port_mask = rte_cpu_to_be_16(res->port_dst);
-	}
-
-	cmd_reconfig_device_queue(res->port_id, 1, 1);
-}
-
-cmdline_parse_token_string_t cmd_flow_director_mask =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result,
-				 flow_director_mask, "flow_director_mask");
-cmdline_parse_token_num_t cmd_flow_director_mask_port_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_flow_director_mask_result,
-			      port_id, UINT16);
-cmdline_parse_token_string_t cmd_flow_director_mask_vlan =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result,
-				 vlan, "vlan");
-cmdline_parse_token_num_t cmd_flow_director_mask_vlan_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_flow_director_mask_result,
-			      vlan_mask, UINT16);
-cmdline_parse_token_string_t cmd_flow_director_mask_src =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result,
-				 src_mask, "src_mask");
-cmdline_parse_token_ipaddr_t cmd_flow_director_mask_ipv4_src =
-	TOKEN_IPADDR_INITIALIZER(struct cmd_flow_director_mask_result,
-				 ipv4_src);
-cmdline_parse_token_ipaddr_t cmd_flow_director_mask_ipv6_src =
-	TOKEN_IPADDR_INITIALIZER(struct cmd_flow_director_mask_result,
-				 ipv6_src);
-cmdline_parse_token_num_t cmd_flow_director_mask_port_src =
-	TOKEN_NUM_INITIALIZER(struct cmd_flow_director_mask_result,
-			      port_src, UINT16);
-cmdline_parse_token_string_t cmd_flow_director_mask_dst =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result,
-				 dst_mask, "dst_mask");
-cmdline_parse_token_ipaddr_t cmd_flow_director_mask_ipv4_dst =
-	TOKEN_IPADDR_INITIALIZER(struct cmd_flow_director_mask_result,
-				 ipv4_dst);
-cmdline_parse_token_ipaddr_t cmd_flow_director_mask_ipv6_dst =
-	TOKEN_IPADDR_INITIALIZER(struct cmd_flow_director_mask_result,
-				 ipv6_dst);
-cmdline_parse_token_num_t cmd_flow_director_mask_port_dst =
-	TOKEN_NUM_INITIALIZER(struct cmd_flow_director_mask_result,
-			      port_dst, UINT16);
-
-cmdline_parse_token_string_t cmd_flow_director_mask_mode =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result,
-				 mode, "mode");
-cmdline_parse_token_string_t cmd_flow_director_mask_mode_ip =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result,
-				 mode_value, "IP");
-cmdline_parse_token_string_t cmd_flow_director_mask_mode_mac_vlan =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result,
-				 mode_value, "MAC-VLAN");
-cmdline_parse_token_string_t cmd_flow_director_mask_mode_tunnel =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result,
-				 mode_value, "Tunnel");
-cmdline_parse_token_string_t cmd_flow_director_mask_mac =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result,
-				 mac, "mac");
-cmdline_parse_token_num_t cmd_flow_director_mask_mac_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_flow_director_mask_result,
-			      mac_addr_byte_mask, UINT8);
-cmdline_parse_token_string_t cmd_flow_director_mask_tunnel_type =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result,
-				 tunnel_type, "tunnel-type");
-cmdline_parse_token_num_t cmd_flow_director_mask_tunnel_type_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_flow_director_mask_result,
-			      tunnel_type_mask, UINT8);
-cmdline_parse_token_string_t cmd_flow_director_mask_tunnel_id =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result,
-				 tunnel_id, "tunnel-id");
-cmdline_parse_token_num_t cmd_flow_director_mask_tunnel_id_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_flow_director_mask_result,
-			      tunnel_id_mask, UINT32);
-
-cmdline_parse_inst_t cmd_set_flow_director_ip_mask = {
-	.f = cmd_flow_director_mask_parsed,
-	.data = NULL,
-	.help_str = "flow_director_mask ... : "
-		"Set IP mode flow director's mask on NIC",
-	.tokens = {
-		(void *)&cmd_flow_director_mask,
-		(void *)&cmd_flow_director_mask_port_id,
-		(void *)&cmd_flow_director_mask_mode,
-		(void *)&cmd_flow_director_mask_mode_ip,
-		(void *)&cmd_flow_director_mask_vlan,
-		(void *)&cmd_flow_director_mask_vlan_value,
-		(void *)&cmd_flow_director_mask_src,
-		(void *)&cmd_flow_director_mask_ipv4_src,
-		(void *)&cmd_flow_director_mask_ipv6_src,
-		(void *)&cmd_flow_director_mask_port_src,
-		(void *)&cmd_flow_director_mask_dst,
-		(void *)&cmd_flow_director_mask_ipv4_dst,
-		(void *)&cmd_flow_director_mask_ipv6_dst,
-		(void *)&cmd_flow_director_mask_port_dst,
-		NULL,
-	},
-};
-
-cmdline_parse_inst_t cmd_set_flow_director_mac_vlan_mask = {
-	.f = cmd_flow_director_mask_parsed,
-	.data = NULL,
-	.help_str = "flow_director_mask ... : Set MAC VLAN mode "
-		"flow director's mask on NIC",
-	.tokens = {
-		(void *)&cmd_flow_director_mask,
-		(void *)&cmd_flow_director_mask_port_id,
-		(void *)&cmd_flow_director_mask_mode,
-		(void *)&cmd_flow_director_mask_mode_mac_vlan,
-		(void *)&cmd_flow_director_mask_vlan,
-		(void *)&cmd_flow_director_mask_vlan_value,
-		NULL,
-	},
-};
-
-cmdline_parse_inst_t cmd_set_flow_director_tunnel_mask = {
-	.f = cmd_flow_director_mask_parsed,
-	.data = NULL,
-	.help_str = "flow_director_mask ... : Set tunnel mode "
-		"flow director's mask on NIC",
-	.tokens = {
-		(void *)&cmd_flow_director_mask,
-		(void *)&cmd_flow_director_mask_port_id,
-		(void *)&cmd_flow_director_mask_mode,
-		(void *)&cmd_flow_director_mask_mode_tunnel,
-		(void *)&cmd_flow_director_mask_vlan,
-		(void *)&cmd_flow_director_mask_vlan_value,
-		(void *)&cmd_flow_director_mask_mac,
-		(void *)&cmd_flow_director_mask_mac_value,
-		(void *)&cmd_flow_director_mask_tunnel_type,
-		(void *)&cmd_flow_director_mask_tunnel_type_value,
-		(void *)&cmd_flow_director_mask_tunnel_id,
-		(void *)&cmd_flow_director_mask_tunnel_id_value,
-		NULL,
-	},
-};
-
-/* *** deal with flow director mask on flexible payload *** */
-struct cmd_flow_director_flex_mask_result {
-	cmdline_fixed_string_t flow_director_flexmask;
-	portid_t port_id;
-	cmdline_fixed_string_t flow;
-	cmdline_fixed_string_t flow_type;
-	cmdline_fixed_string_t mask;
-};
-
-static void
-cmd_flow_director_flex_mask_parsed(void *parsed_result,
-			  __rte_unused struct cmdline *cl,
-			  __rte_unused void *data)
-{
-	struct cmd_flow_director_flex_mask_result *res = parsed_result;
-	struct rte_eth_fdir_info fdir_info;
-	struct rte_eth_fdir_flex_mask flex_mask;
-	struct rte_port *port;
-	uint64_t flow_type_mask;
-	uint16_t i;
-	int ret;
-
-	port = &ports[res->port_id];
-	/** Check if the port is not started **/
-	if (port->port_status != RTE_PORT_STOPPED) {
-		printf("Please stop port %d first\n", res->port_id);
-		return;
-	}
-
-	memset(&flex_mask, 0, sizeof(struct rte_eth_fdir_flex_mask));
-	ret = parse_flexbytes(res->mask,
-			flex_mask.mask,
-			RTE_ETH_FDIR_MAX_FLEXLEN);
-	if (ret < 0) {
-		printf("error: Cannot parse mask input.\n");
-		return;
-	}
-
-	memset(&fdir_info, 0, sizeof(fdir_info));
-	ret = rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_FDIR,
-				RTE_ETH_FILTER_INFO, &fdir_info);
-	if (ret < 0) {
-		printf("Cannot get FDir filter info\n");
-		return;
-	}
-
-	if (!strcmp(res->flow_type, "none")) {
-		/* means don't specify the flow type */
-		flex_mask.flow_type = RTE_ETH_FLOW_UNKNOWN;
-		for (i = 0; i < RTE_ETH_FLOW_MAX; i++)
-			memset(&port->dev_conf.fdir_conf.flex_conf.flex_mask[i],
-			       0, sizeof(struct rte_eth_fdir_flex_mask));
-		port->dev_conf.fdir_conf.flex_conf.nb_flexmasks = 1;
-		rte_memcpy(&port->dev_conf.fdir_conf.flex_conf.flex_mask[0],
-				 &flex_mask,
-				 sizeof(struct rte_eth_fdir_flex_mask));
-		cmd_reconfig_device_queue(res->port_id, 1, 1);
-		return;
-	}
-	flow_type_mask = fdir_info.flow_types_mask[0];
-	if (!strcmp(res->flow_type, "all")) {
-		if (!flow_type_mask) {
-			printf("No flow type supported\n");
-			return;
-		}
-		for (i = RTE_ETH_FLOW_UNKNOWN; i < RTE_ETH_FLOW_MAX; i++) {
-			if (flow_type_mask & (1ULL << i)) {
-				flex_mask.flow_type = i;
-				fdir_set_flex_mask(res->port_id, &flex_mask);
-			}
-		}
-		cmd_reconfig_device_queue(res->port_id, 1, 1);
-		return;
-	}
-	flex_mask.flow_type = str2flowtype(res->flow_type);
-	if (!(flow_type_mask & (1ULL << flex_mask.flow_type))) {
-		printf("Flow type %s not supported on port %d\n",
-				res->flow_type, res->port_id);
-		return;
-	}
-	fdir_set_flex_mask(res->port_id, &flex_mask);
-	cmd_reconfig_device_queue(res->port_id, 1, 1);
-}
-
-cmdline_parse_token_string_t cmd_flow_director_flexmask =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_flex_mask_result,
-				 flow_director_flexmask,
-				 "flow_director_flex_mask");
-cmdline_parse_token_num_t cmd_flow_director_flexmask_port_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_flow_director_flex_mask_result,
-			      port_id, UINT16);
-cmdline_parse_token_string_t cmd_flow_director_flexmask_flow =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_flex_mask_result,
-				 flow, "flow");
-cmdline_parse_token_string_t cmd_flow_director_flexmask_flow_type =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_flex_mask_result,
-		flow_type, "none#ipv4-other#ipv4-frag#ipv4-tcp#ipv4-udp#ipv4-sctp#"
-		"ipv6-other#ipv6-frag#ipv6-tcp#ipv6-udp#ipv6-sctp#l2_payload#all");
-cmdline_parse_token_string_t cmd_flow_director_flexmask_mask =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_flex_mask_result,
-				 mask, NULL);
-
-cmdline_parse_inst_t cmd_set_flow_director_flex_mask = {
-	.f = cmd_flow_director_flex_mask_parsed,
-	.data = NULL,
-	.help_str = "flow_director_flex_mask ... : "
-		"Set flow director's flex mask on NIC",
-	.tokens = {
-		(void *)&cmd_flow_director_flexmask,
-		(void *)&cmd_flow_director_flexmask_port_id,
-		(void *)&cmd_flow_director_flexmask_flow,
-		(void *)&cmd_flow_director_flexmask_flow_type,
-		(void *)&cmd_flow_director_flexmask_mask,
-		NULL,
-	},
-};
-
-/* *** deal with flow director flexible payload configuration *** */
-struct cmd_flow_director_flexpayload_result {
-	cmdline_fixed_string_t flow_director_flexpayload;
-	portid_t port_id;
-	cmdline_fixed_string_t payload_layer;
-	cmdline_fixed_string_t payload_cfg;
-};
-
-static inline int
-parse_offsets(const char *q_arg, uint16_t *offsets, uint16_t max_num)
-{
-	char s[256];
-	const char *p, *p0 = q_arg;
-	char *end;
-	unsigned long int_fld;
-	char *str_fld[max_num];
-	int i;
-	unsigned size;
-	int ret = -1;
-
-	p = strchr(p0, '(');
-	if (p == NULL)
-		return -1;
-	++p;
-	p0 = strchr(p, ')');
-	if (p0 == NULL)
-		return -1;
-
-	size = p0 - p;
-	if (size >= sizeof(s))
-		return -1;
-
-	snprintf(s, sizeof(s), "%.*s", size, p);
-	ret = rte_strsplit(s, sizeof(s), str_fld, max_num, ',');
-	if (ret < 0 || ret > max_num)
-		return -1;
-	for (i = 0; i < ret; i++) {
-		errno = 0;
-		int_fld = strtoul(str_fld[i], &end, 0);
-		if (errno != 0 || *end != '\0' || int_fld > UINT16_MAX)
-			return -1;
-		offsets[i] = (uint16_t)int_fld;
-	}
-	return ret;
-}
-
-static void
-cmd_flow_director_flxpld_parsed(void *parsed_result,
-			  __rte_unused struct cmdline *cl,
-			  __rte_unused void *data)
-{
-	struct cmd_flow_director_flexpayload_result *res = parsed_result;
-	struct rte_eth_flex_payload_cfg flex_cfg;
-	struct rte_port *port;
-	int ret = 0;
-
-	port = &ports[res->port_id];
-	/** Check if the port is not started **/
-	if (port->port_status != RTE_PORT_STOPPED) {
-		printf("Please stop port %d first\n", res->port_id);
-		return;
-	}
-
-	memset(&flex_cfg, 0, sizeof(struct rte_eth_flex_payload_cfg));
-
-	if (!strcmp(res->payload_layer, "raw"))
-		flex_cfg.type = RTE_ETH_RAW_PAYLOAD;
-	else if (!strcmp(res->payload_layer, "l2"))
-		flex_cfg.type = RTE_ETH_L2_PAYLOAD;
-	else if (!strcmp(res->payload_layer, "l3"))
-		flex_cfg.type = RTE_ETH_L3_PAYLOAD;
-	else if (!strcmp(res->payload_layer, "l4"))
-		flex_cfg.type = RTE_ETH_L4_PAYLOAD;
-
-	ret = parse_offsets(res->payload_cfg, flex_cfg.src_offset,
-			    RTE_ETH_FDIR_MAX_FLEXLEN);
-	if (ret < 0) {
-		printf("error: Cannot parse flex payload input.\n");
-		return;
-	}
-
-	fdir_set_flex_payload(res->port_id, &flex_cfg);
-	cmd_reconfig_device_queue(res->port_id, 1, 1);
-}
-
-cmdline_parse_token_string_t cmd_flow_director_flexpayload =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_flexpayload_result,
-				 flow_director_flexpayload,
-				 "flow_director_flex_payload");
-cmdline_parse_token_num_t cmd_flow_director_flexpayload_port_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_flow_director_flexpayload_result,
-			      port_id, UINT16);
-cmdline_parse_token_string_t cmd_flow_director_flexpayload_payload_layer =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_flexpayload_result,
-				 payload_layer, "raw#l2#l3#l4");
-cmdline_parse_token_string_t cmd_flow_director_flexpayload_payload_cfg =
-	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_flexpayload_result,
-				 payload_cfg, NULL);
-
-cmdline_parse_inst_t cmd_set_flow_director_flex_payload = {
-	.f = cmd_flow_director_flxpld_parsed,
-	.data = NULL,
-	.help_str = "flow_director_flexpayload ... : "
-		"Set flow director's flex payload on NIC",
-	.tokens = {
-		(void *)&cmd_flow_director_flexpayload,
-		(void *)&cmd_flow_director_flexpayload_port_id,
-		(void *)&cmd_flow_director_flexpayload_payload_layer,
-		(void *)&cmd_flow_director_flexpayload_payload_cfg,
-		NULL,
-	},
-};
-
-/* Generic flow interface command. */
-extern cmdline_parse_inst_t cmd_flow;
-
-/* *** Classification Filters Control *** */
-/* *** Get symmetric hash enable per port *** */
-struct cmd_get_sym_hash_ena_per_port_result {
-	cmdline_fixed_string_t get_sym_hash_ena_per_port;
-	portid_t port_id;
-};
-
-static void
-cmd_get_sym_hash_per_port_parsed(void *parsed_result,
-				 __rte_unused struct cmdline *cl,
-				 __rte_unused void *data)
-{
-	struct cmd_get_sym_hash_ena_per_port_result *res = parsed_result;
-	struct rte_eth_hash_filter_info info;
-	int ret;
-
-	if (rte_eth_dev_filter_supported(res->port_id,
-				RTE_ETH_FILTER_HASH) < 0) {
-		printf("RTE_ETH_FILTER_HASH not supported on port: %d\n",
-							res->port_id);
-		return;
-	}
-
-	memset(&info, 0, sizeof(info));
-	info.info_type = RTE_ETH_HASH_FILTER_SYM_HASH_ENA_PER_PORT;
-	ret = rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_HASH,
-						RTE_ETH_FILTER_GET, &info);
-
-	if (ret < 0) {
-		printf("Cannot get symmetric hash enable per port "
-					"on port %u\n", res->port_id);
-		return;
-	}
-
-	printf("Symmetric hash is %s on port %u\n", info.info.enable ?
-				"enabled" : "disabled", res->port_id);
-}
-
-cmdline_parse_token_string_t cmd_get_sym_hash_ena_per_port_all =
-	TOKEN_STRING_INITIALIZER(struct cmd_get_sym_hash_ena_per_port_result,
-		get_sym_hash_ena_per_port, "get_sym_hash_ena_per_port");
-cmdline_parse_token_num_t cmd_get_sym_hash_ena_per_port_port_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_get_sym_hash_ena_per_port_result,
-		port_id, UINT16);
-
-cmdline_parse_inst_t cmd_get_sym_hash_ena_per_port = {
-	.f = cmd_get_sym_hash_per_port_parsed,
-	.data = NULL,
-	.help_str = "get_sym_hash_ena_per_port <port_id>",
-	.tokens = {
-		(void *)&cmd_get_sym_hash_ena_per_port_all,
-		(void *)&cmd_get_sym_hash_ena_per_port_port_id,
-		NULL,
-	},
-};
-
-/* *** Set symmetric hash enable per port *** */
-struct cmd_set_sym_hash_ena_per_port_result {
-	cmdline_fixed_string_t set_sym_hash_ena_per_port;
-	cmdline_fixed_string_t enable;
-	portid_t port_id;
-};
-
-static void
-cmd_set_sym_hash_per_port_parsed(void *parsed_result,
-				 __rte_unused struct cmdline *cl,
-				 __rte_unused void *data)
-{
-	struct cmd_set_sym_hash_ena_per_port_result *res = parsed_result;
-	struct rte_eth_hash_filter_info info;
-	int ret;
-
-	if (rte_eth_dev_filter_supported(res->port_id,
-				RTE_ETH_FILTER_HASH) < 0) {
-		printf("RTE_ETH_FILTER_HASH not supported on port: %d\n",
-							res->port_id);
-		return;
-	}
-
-	memset(&info, 0, sizeof(info));
-	info.info_type = RTE_ETH_HASH_FILTER_SYM_HASH_ENA_PER_PORT;
-	if (!strcmp(res->enable, "enable"))
-		info.info.enable = 1;
-	ret = rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_HASH,
-					RTE_ETH_FILTER_SET, &info);
-	if (ret < 0) {
-		printf("Cannot set symmetric hash enable per port on "
-					"port %u\n", res->port_id);
-		return;
-	}
-	printf("Symmetric hash has been set to %s on port %u\n",
-					res->enable, res->port_id);
-}
-
-cmdline_parse_token_string_t cmd_set_sym_hash_ena_per_port_all =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_sym_hash_ena_per_port_result,
-		set_sym_hash_ena_per_port, "set_sym_hash_ena_per_port");
-cmdline_parse_token_num_t cmd_set_sym_hash_ena_per_port_port_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_sym_hash_ena_per_port_result,
-		port_id, UINT16);
-cmdline_parse_token_string_t cmd_set_sym_hash_ena_per_port_enable =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_sym_hash_ena_per_port_result,
-		enable, "enable#disable");
-
-cmdline_parse_inst_t cmd_set_sym_hash_ena_per_port = {
-	.f = cmd_set_sym_hash_per_port_parsed,
-	.data = NULL,
-	.help_str = "set_sym_hash_ena_per_port <port_id> enable|disable",
-	.tokens = {
-		(void *)&cmd_set_sym_hash_ena_per_port_all,
-		(void *)&cmd_set_sym_hash_ena_per_port_port_id,
-		(void *)&cmd_set_sym_hash_ena_per_port_enable,
-		NULL,
-	},
-};
-
-/* Get global config of hash function */
-struct cmd_get_hash_global_config_result {
-	cmdline_fixed_string_t get_hash_global_config;
-	portid_t port_id;
-};
-
-static char *
-flowtype_to_str(uint16_t ftype)
-{
-	uint16_t i;
-	static struct {
-		char str[16];
-		uint16_t ftype;
-	} ftype_table[] = {
-		{"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},
-		{"port", RTE_ETH_FLOW_PORT},
-		{"vxlan", RTE_ETH_FLOW_VXLAN},
-		{"geneve", RTE_ETH_FLOW_GENEVE},
-		{"nvgre", RTE_ETH_FLOW_NVGRE},
-		{"vxlan-gpe", RTE_ETH_FLOW_VXLAN_GPE},
-	};
-
-	for (i = 0; i < RTE_DIM(ftype_table); i++) {
-		if (ftype_table[i].ftype == ftype)
-			return ftype_table[i].str;
-	}
-
-	return NULL;
-}
-
-static void
-cmd_get_hash_global_config_parsed(void *parsed_result,
-				  __rte_unused struct cmdline *cl,
-				  __rte_unused void *data)
-{
-	struct cmd_get_hash_global_config_result *res = parsed_result;
-	struct rte_eth_hash_filter_info info;
-	uint32_t idx, offset;
-	uint16_t i;
-	char *str;
-	int ret;
-
-	if (rte_eth_dev_filter_supported(res->port_id,
-			RTE_ETH_FILTER_HASH) < 0) {
-		printf("RTE_ETH_FILTER_HASH not supported on port %d\n",
-							res->port_id);
-		return;
-	}
-
-	memset(&info, 0, sizeof(info));
-	info.info_type = RTE_ETH_HASH_FILTER_GLOBAL_CONFIG;
-	ret = rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_HASH,
-					RTE_ETH_FILTER_GET, &info);
-	if (ret < 0) {
-		printf("Cannot get hash global configurations by port %d\n",
-							res->port_id);
-		return;
-	}
-
-	switch (info.info.global_conf.hash_func) {
-	case RTE_ETH_HASH_FUNCTION_TOEPLITZ:
-		printf("Hash function is Toeplitz\n");
-		break;
-	case RTE_ETH_HASH_FUNCTION_SIMPLE_XOR:
-		printf("Hash function is Simple XOR\n");
-		break;
-	case RTE_ETH_HASH_FUNCTION_SYMMETRIC_TOEPLITZ:
-		printf("Hash function is Symmetric Toeplitz\n");
-		break;
-	default:
-		printf("Unknown hash function\n");
-		break;
-	}
-
-	for (i = 0; i < RTE_ETH_FLOW_MAX; i++) {
-		idx = i / UINT64_BIT;
-		offset = i % UINT64_BIT;
-		if (!(info.info.global_conf.valid_bit_mask[idx] &
-						(1ULL << offset)))
-			continue;
-		str = flowtype_to_str(i);
-		if (!str)
-			continue;
-		printf("Symmetric hash is %s globally for flow type %s "
-							"by port %d\n",
-			((info.info.global_conf.sym_hash_enable_mask[idx] &
-			(1ULL << offset)) ? "enabled" : "disabled"), str,
-							res->port_id);
-	}
-}
-
-cmdline_parse_token_string_t cmd_get_hash_global_config_all =
-	TOKEN_STRING_INITIALIZER(struct cmd_get_hash_global_config_result,
-		get_hash_global_config, "get_hash_global_config");
-cmdline_parse_token_num_t cmd_get_hash_global_config_port_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_get_hash_global_config_result,
-		port_id, UINT16);
-
-cmdline_parse_inst_t cmd_get_hash_global_config = {
-	.f = cmd_get_hash_global_config_parsed,
-	.data = NULL,
-	.help_str = "get_hash_global_config <port_id>",
-	.tokens = {
-		(void *)&cmd_get_hash_global_config_all,
-		(void *)&cmd_get_hash_global_config_port_id,
-		NULL,
-	},
-};
-
-/* Set global config of hash function */
-struct cmd_set_hash_global_config_result {
-	cmdline_fixed_string_t set_hash_global_config;
-	portid_t port_id;
-	cmdline_fixed_string_t hash_func;
-	cmdline_fixed_string_t flow_type;
-	cmdline_fixed_string_t enable;
-};
-
-static void
-cmd_set_hash_global_config_parsed(void *parsed_result,
-				  __rte_unused struct cmdline *cl,
-				  __rte_unused void *data)
-{
-	struct cmd_set_hash_global_config_result *res = parsed_result;
-	struct rte_eth_hash_filter_info info;
-	uint32_t ftype, idx, offset;
-	int ret;
-
-	if (rte_eth_dev_filter_supported(res->port_id,
-				RTE_ETH_FILTER_HASH) < 0) {
-		printf("RTE_ETH_FILTER_HASH not supported on port %d\n",
-							res->port_id);
-		return;
-	}
-	memset(&info, 0, sizeof(info));
-	info.info_type = RTE_ETH_HASH_FILTER_GLOBAL_CONFIG;
-	if (!strcmp(res->hash_func, "toeplitz"))
-		info.info.global_conf.hash_func =
-			RTE_ETH_HASH_FUNCTION_TOEPLITZ;
-	else if (!strcmp(res->hash_func, "simple_xor"))
-		info.info.global_conf.hash_func =
-			RTE_ETH_HASH_FUNCTION_SIMPLE_XOR;
-	else if (!strcmp(res->hash_func, "symmetric_toeplitz"))
-		info.info.global_conf.hash_func =
-			RTE_ETH_HASH_FUNCTION_SYMMETRIC_TOEPLITZ;
-	else if (!strcmp(res->hash_func, "default"))
-		info.info.global_conf.hash_func =
-			RTE_ETH_HASH_FUNCTION_DEFAULT;
-
-	ftype = str2flowtype(res->flow_type);
-	idx = ftype / UINT64_BIT;
-	offset = ftype % UINT64_BIT;
-	info.info.global_conf.valid_bit_mask[idx] |= (1ULL << offset);
-	if (!strcmp(res->enable, "enable"))
-		info.info.global_conf.sym_hash_enable_mask[idx] |=
-						(1ULL << offset);
-	ret = rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_HASH,
-					RTE_ETH_FILTER_SET, &info);
-	if (ret < 0)
-		printf("Cannot set global hash configurations by port %d\n",
-							res->port_id);
-	else
-		printf("Global hash configurations have been set "
-			"successfully by port %d\n", res->port_id);
-}
-
-cmdline_parse_token_string_t cmd_set_hash_global_config_all =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_hash_global_config_result,
-		set_hash_global_config, "set_hash_global_config");
-cmdline_parse_token_num_t cmd_set_hash_global_config_port_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_hash_global_config_result,
-		port_id, UINT16);
-cmdline_parse_token_string_t cmd_set_hash_global_config_hash_func =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_hash_global_config_result,
-		hash_func, "toeplitz#simple_xor#symmetric_toeplitz#default");
-cmdline_parse_token_string_t cmd_set_hash_global_config_flow_type =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_hash_global_config_result,
-		flow_type,
-		"ipv4#ipv4-frag#ipv4-tcp#ipv4-udp#ipv4-sctp#ipv4-other#ipv6#"
-		"ipv6-frag#ipv6-tcp#ipv6-udp#ipv6-sctp#ipv6-other#l2_payload");
-cmdline_parse_token_string_t cmd_set_hash_global_config_enable =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_hash_global_config_result,
-		enable, "enable#disable");
-
-cmdline_parse_inst_t cmd_set_hash_global_config = {
-	.f = cmd_set_hash_global_config_parsed,
-	.data = NULL,
-	.help_str = "set_hash_global_config <port_id> "
-		"toeplitz|simple_xor|symmetric_toeplitz|default "
-		"ipv4|ipv4-frag|ipv4-tcp|ipv4-udp|ipv4-sctp|ipv4-other|"
-		"ipv6|ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|ipv6-other|"
-		"l2_payload enable|disable",
-	.tokens = {
-		(void *)&cmd_set_hash_global_config_all,
-		(void *)&cmd_set_hash_global_config_port_id,
-		(void *)&cmd_set_hash_global_config_hash_func,
-		(void *)&cmd_set_hash_global_config_flow_type,
-		(void *)&cmd_set_hash_global_config_enable,
-		NULL,
-	},
-};
-
-/* Set hash input set */
-struct cmd_set_hash_input_set_result {
-	cmdline_fixed_string_t set_hash_input_set;
-	portid_t port_id;
-	cmdline_fixed_string_t flow_type;
-	cmdline_fixed_string_t inset_field;
-	cmdline_fixed_string_t select;
-};
-
-static enum rte_eth_input_set_field
-str2inset(char *string)
-{
-	uint16_t i;
-
-	static const struct {
-		char str[32];
-		enum rte_eth_input_set_field inset;
-	} inset_table[] = {
-		{"ethertype", RTE_ETH_INPUT_SET_L2_ETHERTYPE},
-		{"ovlan", RTE_ETH_INPUT_SET_L2_OUTER_VLAN},
-		{"ivlan", RTE_ETH_INPUT_SET_L2_INNER_VLAN},
-		{"src-ipv4", RTE_ETH_INPUT_SET_L3_SRC_IP4},
-		{"dst-ipv4", RTE_ETH_INPUT_SET_L3_DST_IP4},
-		{"ipv4-tos", RTE_ETH_INPUT_SET_L3_IP4_TOS},
-		{"ipv4-proto", RTE_ETH_INPUT_SET_L3_IP4_PROTO},
-		{"ipv4-ttl", RTE_ETH_INPUT_SET_L3_IP4_TTL},
-		{"src-ipv6", RTE_ETH_INPUT_SET_L3_SRC_IP6},
-		{"dst-ipv6", RTE_ETH_INPUT_SET_L3_DST_IP6},
-		{"ipv6-tc", RTE_ETH_INPUT_SET_L3_IP6_TC},
-		{"ipv6-next-header", RTE_ETH_INPUT_SET_L3_IP6_NEXT_HEADER},
-		{"ipv6-hop-limits", RTE_ETH_INPUT_SET_L3_IP6_HOP_LIMITS},
-		{"udp-src-port", RTE_ETH_INPUT_SET_L4_UDP_SRC_PORT},
-		{"udp-dst-port", RTE_ETH_INPUT_SET_L4_UDP_DST_PORT},
-		{"tcp-src-port", RTE_ETH_INPUT_SET_L4_TCP_SRC_PORT},
-		{"tcp-dst-port", RTE_ETH_INPUT_SET_L4_TCP_DST_PORT},
-		{"sctp-src-port", RTE_ETH_INPUT_SET_L4_SCTP_SRC_PORT},
-		{"sctp-dst-port", RTE_ETH_INPUT_SET_L4_SCTP_DST_PORT},
-		{"sctp-veri-tag", RTE_ETH_INPUT_SET_L4_SCTP_VERIFICATION_TAG},
-		{"udp-key", RTE_ETH_INPUT_SET_TUNNEL_L4_UDP_KEY},
-		{"gre-key", RTE_ETH_INPUT_SET_TUNNEL_GRE_KEY},
-		{"fld-1st", RTE_ETH_INPUT_SET_FLEX_PAYLOAD_1ST_WORD},
-		{"fld-2nd", RTE_ETH_INPUT_SET_FLEX_PAYLOAD_2ND_WORD},
-		{"fld-3rd", RTE_ETH_INPUT_SET_FLEX_PAYLOAD_3RD_WORD},
-		{"fld-4th", RTE_ETH_INPUT_SET_FLEX_PAYLOAD_4TH_WORD},
-		{"fld-5th", RTE_ETH_INPUT_SET_FLEX_PAYLOAD_5TH_WORD},
-		{"fld-6th", RTE_ETH_INPUT_SET_FLEX_PAYLOAD_6TH_WORD},
-		{"fld-7th", RTE_ETH_INPUT_SET_FLEX_PAYLOAD_7TH_WORD},
-		{"fld-8th", RTE_ETH_INPUT_SET_FLEX_PAYLOAD_8TH_WORD},
-		{"none", RTE_ETH_INPUT_SET_NONE},
-	};
-
-	for (i = 0; i < RTE_DIM(inset_table); i++) {
-		if (!strcmp(string, inset_table[i].str))
-			return inset_table[i].inset;
-	}
-
-	return RTE_ETH_INPUT_SET_UNKNOWN;
-}
-
-static void
-cmd_set_hash_input_set_parsed(void *parsed_result,
-			      __rte_unused struct cmdline *cl,
-			      __rte_unused void *data)
-{
-	struct cmd_set_hash_input_set_result *res = parsed_result;
-	struct rte_eth_hash_filter_info info;
-
-	memset(&info, 0, sizeof(info));
-	info.info_type = RTE_ETH_HASH_FILTER_INPUT_SET_SELECT;
-	info.info.input_set_conf.flow_type = str2flowtype(res->flow_type);
-	info.info.input_set_conf.field[0] = str2inset(res->inset_field);
-	info.info.input_set_conf.inset_size = 1;
-	if (!strcmp(res->select, "select"))
-		info.info.input_set_conf.op = RTE_ETH_INPUT_SET_SELECT;
-	else if (!strcmp(res->select, "add"))
-		info.info.input_set_conf.op = RTE_ETH_INPUT_SET_ADD;
-	rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_HASH,
-				RTE_ETH_FILTER_SET, &info);
-}
-
-cmdline_parse_token_string_t cmd_set_hash_input_set_cmd =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_hash_input_set_result,
-		set_hash_input_set, "set_hash_input_set");
-cmdline_parse_token_num_t cmd_set_hash_input_set_port_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_hash_input_set_result,
-		port_id, UINT16);
-cmdline_parse_token_string_t cmd_set_hash_input_set_flow_type =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_hash_input_set_result,
-		flow_type, NULL);
-cmdline_parse_token_string_t cmd_set_hash_input_set_field =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_hash_input_set_result,
-		inset_field,
-		"ovlan#ivlan#src-ipv4#dst-ipv4#src-ipv6#dst-ipv6#"
-		"ipv4-tos#ipv4-proto#ipv6-tc#ipv6-next-header#udp-src-port#"
-		"udp-dst-port#tcp-src-port#tcp-dst-port#sctp-src-port#"
-		"sctp-dst-port#sctp-veri-tag#udp-key#gre-key#fld-1st#"
-		"fld-2nd#fld-3rd#fld-4th#fld-5th#fld-6th#fld-7th#"
-		"fld-8th#none");
-cmdline_parse_token_string_t cmd_set_hash_input_set_select =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_hash_input_set_result,
-		select, "select#add");
-
-cmdline_parse_inst_t cmd_set_hash_input_set = {
-	.f = cmd_set_hash_input_set_parsed,
-	.data = NULL,
-	.help_str = "set_hash_input_set <port_id> "
-	"ipv4-frag|ipv4-tcp|ipv4-udp|ipv4-sctp|ipv4-other|"
-	"ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|ipv6-other|l2_payload|<flowtype_id> "
-	"ovlan|ivlan|src-ipv4|dst-ipv4|src-ipv6|dst-ipv6|ipv4-tos|ipv4-proto|"
-	"ipv6-tc|ipv6-next-header|udp-src-port|udp-dst-port|tcp-src-port|"
-	"tcp-dst-port|sctp-src-port|sctp-dst-port|sctp-veri-tag|udp-key|"
-	"gre-key|fld-1st|fld-2nd|fld-3rd|fld-4th|fld-5th|fld-6th|"
-	"fld-7th|fld-8th|none select|add",
-	.tokens = {
-		(void *)&cmd_set_hash_input_set_cmd,
-		(void *)&cmd_set_hash_input_set_port_id,
-		(void *)&cmd_set_hash_input_set_flow_type,
-		(void *)&cmd_set_hash_input_set_field,
-		(void *)&cmd_set_hash_input_set_select,
-		NULL,
-	},
-};
-
-/* Set flow director input set */
-struct cmd_set_fdir_input_set_result {
-	cmdline_fixed_string_t set_fdir_input_set;
-	portid_t port_id;
-	cmdline_fixed_string_t flow_type;
-	cmdline_fixed_string_t inset_field;
-	cmdline_fixed_string_t select;
-};
-
-static void
-cmd_set_fdir_input_set_parsed(void *parsed_result,
-	__rte_unused struct cmdline *cl,
-	__rte_unused void *data)
-{
-	struct cmd_set_fdir_input_set_result *res = parsed_result;
-	struct rte_eth_fdir_filter_info info;
-
-	memset(&info, 0, sizeof(info));
-	info.info_type = RTE_ETH_FDIR_FILTER_INPUT_SET_SELECT;
-	info.info.input_set_conf.flow_type = str2flowtype(res->flow_type);
-	info.info.input_set_conf.field[0] = str2inset(res->inset_field);
-	info.info.input_set_conf.inset_size = 1;
-	if (!strcmp(res->select, "select"))
-		info.info.input_set_conf.op = RTE_ETH_INPUT_SET_SELECT;
-	else if (!strcmp(res->select, "add"))
-		info.info.input_set_conf.op = RTE_ETH_INPUT_SET_ADD;
-	rte_eth_dev_filter_ctrl(res->port_id, RTE_ETH_FILTER_FDIR,
-		RTE_ETH_FILTER_SET, &info);
-}
-
-cmdline_parse_token_string_t cmd_set_fdir_input_set_cmd =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_fdir_input_set_result,
-	set_fdir_input_set, "set_fdir_input_set");
-cmdline_parse_token_num_t cmd_set_fdir_input_set_port_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_fdir_input_set_result,
-	port_id, UINT16);
-cmdline_parse_token_string_t cmd_set_fdir_input_set_flow_type =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_fdir_input_set_result,
-	flow_type,
-	"ipv4-frag#ipv4-tcp#ipv4-udp#ipv4-sctp#ipv4-other#"
-	"ipv6-frag#ipv6-tcp#ipv6-udp#ipv6-sctp#ipv6-other#l2_payload");
-cmdline_parse_token_string_t cmd_set_fdir_input_set_field =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_fdir_input_set_result,
-	inset_field,
-	"ivlan#ethertype#src-ipv4#dst-ipv4#src-ipv6#dst-ipv6#"
-	"ipv4-tos#ipv4-proto#ipv4-ttl#ipv6-tc#ipv6-next-header#"
-	"ipv6-hop-limits#udp-src-port#udp-dst-port#"
-	"tcp-src-port#tcp-dst-port#sctp-src-port#sctp-dst-port#"
-	"sctp-veri-tag#none");
-cmdline_parse_token_string_t cmd_set_fdir_input_set_select =
-	TOKEN_STRING_INITIALIZER(struct cmd_set_fdir_input_set_result,
-	select, "select#add");
-
-cmdline_parse_inst_t cmd_set_fdir_input_set = {
-	.f = cmd_set_fdir_input_set_parsed,
-	.data = NULL,
-	.help_str = "set_fdir_input_set <port_id> "
-	"ipv4-frag|ipv4-tcp|ipv4-udp|ipv4-sctp|ipv4-other|"
-	"ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|ipv6-other|l2_payload "
-	"ivlan|ethertype|src-ipv4|dst-ipv4|src-ipv6|dst-ipv6|"
-	"ipv4-tos|ipv4-proto|ipv4-ttl|ipv6-tc|ipv6-next-header|"
-	"ipv6-hop-limits|udp-src-port|udp-dst-port|"
-	"tcp-src-port|tcp-dst-port|sctp-src-port|sctp-dst-port|"
-	"sctp-veri-tag|none select|add",
-	.tokens = {
-		(void *)&cmd_set_fdir_input_set_cmd,
-		(void *)&cmd_set_fdir_input_set_port_id,
-		(void *)&cmd_set_fdir_input_set_flow_type,
-		(void *)&cmd_set_fdir_input_set_field,
-		(void *)&cmd_set_fdir_input_set_select,
-		NULL,
-	},
-};
-
-/* *** ADD/REMOVE A MULTICAST MAC ADDRESS TO/FROM A PORT *** */
-struct cmd_mcast_addr_result {
-	cmdline_fixed_string_t mcast_addr_cmd;
-	cmdline_fixed_string_t what;
-	uint16_t port_num;
-	struct rte_ether_addr mc_addr;
-};
-
-static void cmd_mcast_addr_parsed(void *parsed_result,
-		__rte_unused struct cmdline *cl,
-		__rte_unused void *data)
-{
-	struct cmd_mcast_addr_result *res = parsed_result;
-
-	if (!rte_is_multicast_ether_addr(&res->mc_addr)) {
-		printf("Invalid multicast addr %02X:%02X:%02X:%02X:%02X:%02X\n",
-		       res->mc_addr.addr_bytes[0], res->mc_addr.addr_bytes[1],
-		       res->mc_addr.addr_bytes[2], res->mc_addr.addr_bytes[3],
-		       res->mc_addr.addr_bytes[4], res->mc_addr.addr_bytes[5]);
-		return;
-	}
-	if (strcmp(res->what, "add") == 0)
-		mcast_addr_add(res->port_num, &res->mc_addr);
-	else
-		mcast_addr_remove(res->port_num, &res->mc_addr);
-}
-
-cmdline_parse_token_string_t cmd_mcast_addr_cmd =
-	TOKEN_STRING_INITIALIZER(struct cmd_mcast_addr_result,
-				 mcast_addr_cmd, "mcast_addr");
-cmdline_parse_token_string_t cmd_mcast_addr_what =
-	TOKEN_STRING_INITIALIZER(struct cmd_mcast_addr_result, what,
-				 "add#remove");
-cmdline_parse_token_num_t cmd_mcast_addr_portnum =
-	TOKEN_NUM_INITIALIZER(struct cmd_mcast_addr_result, port_num, UINT16);
-cmdline_parse_token_etheraddr_t cmd_mcast_addr_addr =
-	TOKEN_ETHERADDR_INITIALIZER(struct cmd_mac_addr_result, address);
-
-cmdline_parse_inst_t cmd_mcast_addr = {
-	.f = cmd_mcast_addr_parsed,
-	.data = (void *)0,
-	.help_str = "mcast_addr add|remove <port_id> <mcast_addr>: "
-		"Add/Remove multicast MAC address on port_id",
-	.tokens = {
-		(void *)&cmd_mcast_addr_cmd,
-		(void *)&cmd_mcast_addr_what,
-		(void *)&cmd_mcast_addr_portnum,
-		(void *)&cmd_mcast_addr_addr,
-		NULL,
-	},
-};
-
-/* l2 tunnel config
- * only support E-tag now.
- */
-
-/* Ether type config */
-struct cmd_config_l2_tunnel_eth_type_result {
-	cmdline_fixed_string_t port;
-	cmdline_fixed_string_t config;
-	cmdline_fixed_string_t all;
-	portid_t id;
-	cmdline_fixed_string_t l2_tunnel;
-	cmdline_fixed_string_t l2_tunnel_type;
-	cmdline_fixed_string_t eth_type;
-	uint16_t eth_type_val;
-};
-
-cmdline_parse_token_string_t cmd_config_l2_tunnel_eth_type_port =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_l2_tunnel_eth_type_result,
-		 port, "port");
-cmdline_parse_token_string_t cmd_config_l2_tunnel_eth_type_config =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_l2_tunnel_eth_type_result,
-		 config, "config");
-cmdline_parse_token_string_t cmd_config_l2_tunnel_eth_type_all_str =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_l2_tunnel_eth_type_result,
-		 all, "all");
-cmdline_parse_token_num_t cmd_config_l2_tunnel_eth_type_id =
-	TOKEN_NUM_INITIALIZER
-		(struct cmd_config_l2_tunnel_eth_type_result,
-		 id, UINT16);
-cmdline_parse_token_string_t cmd_config_l2_tunnel_eth_type_l2_tunnel =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_l2_tunnel_eth_type_result,
-		 l2_tunnel, "l2-tunnel");
-cmdline_parse_token_string_t cmd_config_l2_tunnel_eth_type_l2_tunnel_type =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_l2_tunnel_eth_type_result,
-		 l2_tunnel_type, "E-tag");
-cmdline_parse_token_string_t cmd_config_l2_tunnel_eth_type_eth_type =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_l2_tunnel_eth_type_result,
-		 eth_type, "ether-type");
-cmdline_parse_token_num_t cmd_config_l2_tunnel_eth_type_eth_type_val =
-	TOKEN_NUM_INITIALIZER
-		(struct cmd_config_l2_tunnel_eth_type_result,
-		 eth_type_val, UINT16);
-
-static enum rte_eth_tunnel_type
-str2fdir_l2_tunnel_type(char *string)
-{
-	uint32_t i = 0;
-
-	static const struct {
-		char str[32];
-		enum rte_eth_tunnel_type type;
-	} l2_tunnel_type_str[] = {
-		{"E-tag", RTE_L2_TUNNEL_TYPE_E_TAG},
-	};
-
-	for (i = 0; i < RTE_DIM(l2_tunnel_type_str); i++) {
-		if (!strcmp(l2_tunnel_type_str[i].str, string))
-			return l2_tunnel_type_str[i].type;
-	}
-	return RTE_TUNNEL_TYPE_NONE;
-}
-
-/* ether type config for all ports */
-static void
-cmd_config_l2_tunnel_eth_type_all_parsed
-	(void *parsed_result,
-	 __rte_unused struct cmdline *cl,
-	 __rte_unused void *data)
-{
-	struct cmd_config_l2_tunnel_eth_type_result *res = parsed_result;
-	struct rte_eth_l2_tunnel_conf entry;
-	portid_t pid;
-
-	entry.l2_tunnel_type = str2fdir_l2_tunnel_type(res->l2_tunnel_type);
-	entry.ether_type = res->eth_type_val;
-
-	RTE_ETH_FOREACH_DEV(pid) {
-		rte_eth_dev_l2_tunnel_eth_type_conf(pid, &entry);
-	}
-}
-
-cmdline_parse_inst_t cmd_config_l2_tunnel_eth_type_all = {
-	.f = cmd_config_l2_tunnel_eth_type_all_parsed,
-	.data = NULL,
-	.help_str = "port config all l2-tunnel E-tag ether-type <value>",
-	.tokens = {
-		(void *)&cmd_config_l2_tunnel_eth_type_port,
-		(void *)&cmd_config_l2_tunnel_eth_type_config,
-		(void *)&cmd_config_l2_tunnel_eth_type_all_str,
-		(void *)&cmd_config_l2_tunnel_eth_type_l2_tunnel,
-		(void *)&cmd_config_l2_tunnel_eth_type_l2_tunnel_type,
-		(void *)&cmd_config_l2_tunnel_eth_type_eth_type,
-		(void *)&cmd_config_l2_tunnel_eth_type_eth_type_val,
-		NULL,
-	},
-};
-
-/* ether type config for a specific port */
-static void
-cmd_config_l2_tunnel_eth_type_specific_parsed(
-	void *parsed_result,
-	__rte_unused struct cmdline *cl,
-	__rte_unused void *data)
-{
-	struct cmd_config_l2_tunnel_eth_type_result *res =
-		 parsed_result;
-	struct rte_eth_l2_tunnel_conf entry;
-
-	if (port_id_is_invalid(res->id, ENABLED_WARN))
-		return;
-
-	entry.l2_tunnel_type = str2fdir_l2_tunnel_type(res->l2_tunnel_type);
-	entry.ether_type = res->eth_type_val;
-
-	rte_eth_dev_l2_tunnel_eth_type_conf(res->id, &entry);
-}
-
-cmdline_parse_inst_t cmd_config_l2_tunnel_eth_type_specific = {
-	.f = cmd_config_l2_tunnel_eth_type_specific_parsed,
-	.data = NULL,
-	.help_str = "port config <port_id> l2-tunnel E-tag ether-type <value>",
-	.tokens = {
-		(void *)&cmd_config_l2_tunnel_eth_type_port,
-		(void *)&cmd_config_l2_tunnel_eth_type_config,
-		(void *)&cmd_config_l2_tunnel_eth_type_id,
-		(void *)&cmd_config_l2_tunnel_eth_type_l2_tunnel,
-		(void *)&cmd_config_l2_tunnel_eth_type_l2_tunnel_type,
-		(void *)&cmd_config_l2_tunnel_eth_type_eth_type,
-		(void *)&cmd_config_l2_tunnel_eth_type_eth_type_val,
-		NULL,
-	},
-};
-
-/* Enable/disable l2 tunnel */
-struct cmd_config_l2_tunnel_en_dis_result {
-	cmdline_fixed_string_t port;
-	cmdline_fixed_string_t config;
-	cmdline_fixed_string_t all;
-	portid_t id;
-	cmdline_fixed_string_t l2_tunnel;
-	cmdline_fixed_string_t l2_tunnel_type;
-	cmdline_fixed_string_t en_dis;
-};
-
-cmdline_parse_token_string_t cmd_config_l2_tunnel_en_dis_port =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_l2_tunnel_en_dis_result,
-		 port, "port");
-cmdline_parse_token_string_t cmd_config_l2_tunnel_en_dis_config =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_l2_tunnel_en_dis_result,
-		 config, "config");
-cmdline_parse_token_string_t cmd_config_l2_tunnel_en_dis_all_str =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_l2_tunnel_en_dis_result,
-		 all, "all");
-cmdline_parse_token_num_t cmd_config_l2_tunnel_en_dis_id =
-	TOKEN_NUM_INITIALIZER
-		(struct cmd_config_l2_tunnel_en_dis_result,
-		 id, UINT16);
-cmdline_parse_token_string_t cmd_config_l2_tunnel_en_dis_l2_tunnel =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_l2_tunnel_en_dis_result,
-		 l2_tunnel, "l2-tunnel");
-cmdline_parse_token_string_t cmd_config_l2_tunnel_en_dis_l2_tunnel_type =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_l2_tunnel_en_dis_result,
-		 l2_tunnel_type, "E-tag");
-cmdline_parse_token_string_t cmd_config_l2_tunnel_en_dis_en_dis =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_l2_tunnel_en_dis_result,
-		 en_dis, "enable#disable");
-
-/* enable/disable l2 tunnel for all ports */
-static void
-cmd_config_l2_tunnel_en_dis_all_parsed(
-	void *parsed_result,
-	__rte_unused struct cmdline *cl,
-	__rte_unused void *data)
-{
-	struct cmd_config_l2_tunnel_en_dis_result *res = parsed_result;
-	struct rte_eth_l2_tunnel_conf entry;
-	portid_t pid;
-	uint8_t en;
-
-	entry.l2_tunnel_type = str2fdir_l2_tunnel_type(res->l2_tunnel_type);
-
-	if (!strcmp("enable", res->en_dis))
-		en = 1;
-	else
-		en = 0;
-
-	RTE_ETH_FOREACH_DEV(pid) {
-		rte_eth_dev_l2_tunnel_offload_set(pid,
-						  &entry,
-						  ETH_L2_TUNNEL_ENABLE_MASK,
-						  en);
-	}
-}
-
-cmdline_parse_inst_t cmd_config_l2_tunnel_en_dis_all = {
-	.f = cmd_config_l2_tunnel_en_dis_all_parsed,
-	.data = NULL,
-	.help_str = "port config all l2-tunnel E-tag enable|disable",
-	.tokens = {
-		(void *)&cmd_config_l2_tunnel_en_dis_port,
-		(void *)&cmd_config_l2_tunnel_en_dis_config,
-		(void *)&cmd_config_l2_tunnel_en_dis_all_str,
-		(void *)&cmd_config_l2_tunnel_en_dis_l2_tunnel,
-		(void *)&cmd_config_l2_tunnel_en_dis_l2_tunnel_type,
-		(void *)&cmd_config_l2_tunnel_en_dis_en_dis,
-		NULL,
-	},
-};
-
-/* enable/disable l2 tunnel for a port */
-static void
-cmd_config_l2_tunnel_en_dis_specific_parsed(
-	void *parsed_result,
-	__rte_unused struct cmdline *cl,
-	__rte_unused void *data)
-{
-	struct cmd_config_l2_tunnel_en_dis_result *res =
-		parsed_result;
-	struct rte_eth_l2_tunnel_conf entry;
-
-	if (port_id_is_invalid(res->id, ENABLED_WARN))
-		return;
-
-	entry.l2_tunnel_type = str2fdir_l2_tunnel_type(res->l2_tunnel_type);
-
-	if (!strcmp("enable", res->en_dis))
-		rte_eth_dev_l2_tunnel_offload_set(res->id,
-						  &entry,
-						  ETH_L2_TUNNEL_ENABLE_MASK,
-						  1);
-	else
-		rte_eth_dev_l2_tunnel_offload_set(res->id,
-						  &entry,
-						  ETH_L2_TUNNEL_ENABLE_MASK,
-						  0);
-}
-
-cmdline_parse_inst_t cmd_config_l2_tunnel_en_dis_specific = {
-	.f = cmd_config_l2_tunnel_en_dis_specific_parsed,
-	.data = NULL,
-	.help_str = "port config <port_id> l2-tunnel E-tag enable|disable",
-	.tokens = {
-		(void *)&cmd_config_l2_tunnel_en_dis_port,
-		(void *)&cmd_config_l2_tunnel_en_dis_config,
-		(void *)&cmd_config_l2_tunnel_en_dis_id,
-		(void *)&cmd_config_l2_tunnel_en_dis_l2_tunnel,
-		(void *)&cmd_config_l2_tunnel_en_dis_l2_tunnel_type,
-		(void *)&cmd_config_l2_tunnel_en_dis_en_dis,
-		NULL,
-	},
-};
-
-/* E-tag configuration */
-
-/* Common result structure for all E-tag configuration */
-struct cmd_config_e_tag_result {
-	cmdline_fixed_string_t e_tag;
-	cmdline_fixed_string_t set;
-	cmdline_fixed_string_t insertion;
-	cmdline_fixed_string_t stripping;
-	cmdline_fixed_string_t forwarding;
-	cmdline_fixed_string_t filter;
-	cmdline_fixed_string_t add;
-	cmdline_fixed_string_t del;
-	cmdline_fixed_string_t on;
-	cmdline_fixed_string_t off;
-	cmdline_fixed_string_t on_off;
-	cmdline_fixed_string_t port_tag_id;
-	uint32_t port_tag_id_val;
-	cmdline_fixed_string_t e_tag_id;
-	uint16_t e_tag_id_val;
-	cmdline_fixed_string_t dst_pool;
-	uint8_t dst_pool_val;
-	cmdline_fixed_string_t port;
-	portid_t port_id;
-	cmdline_fixed_string_t vf;
-	uint8_t vf_id;
-};
-
-/* Common CLI fields for all E-tag configuration */
-cmdline_parse_token_string_t cmd_config_e_tag_e_tag =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_e_tag_result,
-		 e_tag, "E-tag");
-cmdline_parse_token_string_t cmd_config_e_tag_set =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_e_tag_result,
-		 set, "set");
-cmdline_parse_token_string_t cmd_config_e_tag_insertion =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_e_tag_result,
-		 insertion, "insertion");
-cmdline_parse_token_string_t cmd_config_e_tag_stripping =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_e_tag_result,
-		 stripping, "stripping");
-cmdline_parse_token_string_t cmd_config_e_tag_forwarding =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_e_tag_result,
-		 forwarding, "forwarding");
-cmdline_parse_token_string_t cmd_config_e_tag_filter =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_e_tag_result,
-		 filter, "filter");
-cmdline_parse_token_string_t cmd_config_e_tag_add =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_e_tag_result,
-		 add, "add");
-cmdline_parse_token_string_t cmd_config_e_tag_del =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_e_tag_result,
-		 del, "del");
-cmdline_parse_token_string_t cmd_config_e_tag_on =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_e_tag_result,
-		 on, "on");
-cmdline_parse_token_string_t cmd_config_e_tag_off =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_e_tag_result,
-		 off, "off");
-cmdline_parse_token_string_t cmd_config_e_tag_on_off =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_e_tag_result,
-		 on_off, "on#off");
-cmdline_parse_token_string_t cmd_config_e_tag_port_tag_id =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_e_tag_result,
-		 port_tag_id, "port-tag-id");
-cmdline_parse_token_num_t cmd_config_e_tag_port_tag_id_val =
-	TOKEN_NUM_INITIALIZER
-		(struct cmd_config_e_tag_result,
-		 port_tag_id_val, UINT32);
-cmdline_parse_token_string_t cmd_config_e_tag_e_tag_id =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_e_tag_result,
-		 e_tag_id, "e-tag-id");
-cmdline_parse_token_num_t cmd_config_e_tag_e_tag_id_val =
-	TOKEN_NUM_INITIALIZER
-		(struct cmd_config_e_tag_result,
-		 e_tag_id_val, UINT16);
-cmdline_parse_token_string_t cmd_config_e_tag_dst_pool =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_e_tag_result,
-		 dst_pool, "dst-pool");
-cmdline_parse_token_num_t cmd_config_e_tag_dst_pool_val =
-	TOKEN_NUM_INITIALIZER
-		(struct cmd_config_e_tag_result,
-		 dst_pool_val, UINT8);
-cmdline_parse_token_string_t cmd_config_e_tag_port =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_e_tag_result,
-		 port, "port");
-cmdline_parse_token_num_t cmd_config_e_tag_port_id =
-	TOKEN_NUM_INITIALIZER
-		(struct cmd_config_e_tag_result,
-		 port_id, UINT16);
-cmdline_parse_token_string_t cmd_config_e_tag_vf =
-	TOKEN_STRING_INITIALIZER
-		(struct cmd_config_e_tag_result,
-		 vf, "vf");
-cmdline_parse_token_num_t cmd_config_e_tag_vf_id =
-	TOKEN_NUM_INITIALIZER
-		(struct cmd_config_e_tag_result,
-		 vf_id, UINT8);
-
-/* E-tag insertion configuration */
-static void
-cmd_config_e_tag_insertion_en_parsed(
-	void *parsed_result,
-	__rte_unused struct cmdline *cl,
-	__rte_unused void *data)
-{
-	struct cmd_config_e_tag_result *res =
-		parsed_result;
-	struct rte_eth_l2_tunnel_conf entry;
+			return;
+		}
 
-	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
-		return;
+		mask->vlan_tci_mask = rte_cpu_to_be_16(res->vlan_mask);
+	} else if (fdir_conf.mode ==  RTE_FDIR_MODE_PERFECT_TUNNEL) {
+		if (strcmp(res->mode_value, "Tunnel")) {
+			printf("Please set mode to Tunnel.\n");
+			return;
+		}
 
-	entry.l2_tunnel_type = RTE_L2_TUNNEL_TYPE_E_TAG;
-	entry.tunnel_id = res->port_tag_id_val;
-	entry.vf_id = res->vf_id;
-	rte_eth_dev_l2_tunnel_offload_set(res->port_id,
-					  &entry,
-					  ETH_L2_TUNNEL_INSERTION_MASK,
-					  1);
-}
+		mask->vlan_tci_mask = rte_cpu_to_be_16(res->vlan_mask);
+		mask->mac_addr_byte_mask = res->mac_addr_byte_mask;
+		mask->tunnel_id_mask = rte_cpu_to_be_32(res->tunnel_id_mask);
+		mask->tunnel_type_mask = res->tunnel_type_mask;
+	} else {
+		if (strcmp(res->mode_value, "IP")) {
+			printf("Please set mode to IP.\n");
+			return;
+		}
 
-static void
-cmd_config_e_tag_insertion_dis_parsed(
-	void *parsed_result,
-	__rte_unused struct cmdline *cl,
-	__rte_unused void *data)
-{
-	struct cmd_config_e_tag_result *res =
-		parsed_result;
-	struct rte_eth_l2_tunnel_conf entry;
+		mask->vlan_tci_mask = rte_cpu_to_be_16(res->vlan_mask);
+		IPV4_ADDR_TO_UINT(res->ipv4_src, mask->ipv4_mask.src_ip);
+		IPV4_ADDR_TO_UINT(res->ipv4_dst, mask->ipv4_mask.dst_ip);
+		IPV6_ADDR_TO_ARRAY(res->ipv6_src, mask->ipv6_mask.src_ip);
+		IPV6_ADDR_TO_ARRAY(res->ipv6_dst, mask->ipv6_mask.dst_ip);
+		mask->src_port_mask = rte_cpu_to_be_16(res->port_src);
+		mask->dst_port_mask = rte_cpu_to_be_16(res->port_dst);
+	}
 
-	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
-		return;
+	cmd_reconfig_device_queue(res->port_id, 1, 1);
+}
 
-	entry.l2_tunnel_type = RTE_L2_TUNNEL_TYPE_E_TAG;
-	entry.vf_id = res->vf_id;
+cmdline_parse_token_string_t cmd_flow_director_mask =
+	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result,
+				 flow_director_mask, "flow_director_mask");
+cmdline_parse_token_num_t cmd_flow_director_mask_port_id =
+	TOKEN_NUM_INITIALIZER(struct cmd_flow_director_mask_result,
+			      port_id, RTE_UINT16);
+cmdline_parse_token_string_t cmd_flow_director_mask_vlan =
+	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result,
+				 vlan, "vlan");
+cmdline_parse_token_num_t cmd_flow_director_mask_vlan_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_flow_director_mask_result,
+			      vlan_mask, RTE_UINT16);
+cmdline_parse_token_string_t cmd_flow_director_mask_src =
+	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result,
+				 src_mask, "src_mask");
+cmdline_parse_token_ipaddr_t cmd_flow_director_mask_ipv4_src =
+	TOKEN_IPADDR_INITIALIZER(struct cmd_flow_director_mask_result,
+				 ipv4_src);
+cmdline_parse_token_ipaddr_t cmd_flow_director_mask_ipv6_src =
+	TOKEN_IPADDR_INITIALIZER(struct cmd_flow_director_mask_result,
+				 ipv6_src);
+cmdline_parse_token_num_t cmd_flow_director_mask_port_src =
+	TOKEN_NUM_INITIALIZER(struct cmd_flow_director_mask_result,
+			      port_src, RTE_UINT16);
+cmdline_parse_token_string_t cmd_flow_director_mask_dst =
+	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result,
+				 dst_mask, "dst_mask");
+cmdline_parse_token_ipaddr_t cmd_flow_director_mask_ipv4_dst =
+	TOKEN_IPADDR_INITIALIZER(struct cmd_flow_director_mask_result,
+				 ipv4_dst);
+cmdline_parse_token_ipaddr_t cmd_flow_director_mask_ipv6_dst =
+	TOKEN_IPADDR_INITIALIZER(struct cmd_flow_director_mask_result,
+				 ipv6_dst);
+cmdline_parse_token_num_t cmd_flow_director_mask_port_dst =
+	TOKEN_NUM_INITIALIZER(struct cmd_flow_director_mask_result,
+			      port_dst, RTE_UINT16);
 
-	rte_eth_dev_l2_tunnel_offload_set(res->port_id,
-					  &entry,
-					  ETH_L2_TUNNEL_INSERTION_MASK,
-					  0);
-}
+cmdline_parse_token_string_t cmd_flow_director_mask_mode =
+	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result,
+				 mode, "mode");
+cmdline_parse_token_string_t cmd_flow_director_mask_mode_ip =
+	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result,
+				 mode_value, "IP");
+cmdline_parse_token_string_t cmd_flow_director_mask_mode_mac_vlan =
+	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result,
+				 mode_value, "MAC-VLAN");
+cmdline_parse_token_string_t cmd_flow_director_mask_mode_tunnel =
+	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result,
+				 mode_value, "Tunnel");
+cmdline_parse_token_string_t cmd_flow_director_mask_mac =
+	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result,
+				 mac, "mac");
+cmdline_parse_token_num_t cmd_flow_director_mask_mac_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_flow_director_mask_result,
+			      mac_addr_byte_mask, RTE_UINT8);
+cmdline_parse_token_string_t cmd_flow_director_mask_tunnel_type =
+	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result,
+				 tunnel_type, "tunnel-type");
+cmdline_parse_token_num_t cmd_flow_director_mask_tunnel_type_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_flow_director_mask_result,
+			      tunnel_type_mask, RTE_UINT8);
+cmdline_parse_token_string_t cmd_flow_director_mask_tunnel_id =
+	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_mask_result,
+				 tunnel_id, "tunnel-id");
+cmdline_parse_token_num_t cmd_flow_director_mask_tunnel_id_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_flow_director_mask_result,
+			      tunnel_id_mask, RTE_UINT32);
 
-cmdline_parse_inst_t cmd_config_e_tag_insertion_en = {
-	.f = cmd_config_e_tag_insertion_en_parsed,
+cmdline_parse_inst_t cmd_set_flow_director_ip_mask = {
+	.f = cmd_flow_director_mask_parsed,
 	.data = NULL,
-	.help_str = "E-tag ... : E-tag insertion enable",
+	.help_str = "flow_director_mask ... : "
+		"Set IP mode flow director's mask on NIC",
 	.tokens = {
-		(void *)&cmd_config_e_tag_e_tag,
-		(void *)&cmd_config_e_tag_set,
-		(void *)&cmd_config_e_tag_insertion,
-		(void *)&cmd_config_e_tag_on,
-		(void *)&cmd_config_e_tag_port_tag_id,
-		(void *)&cmd_config_e_tag_port_tag_id_val,
-		(void *)&cmd_config_e_tag_port,
-		(void *)&cmd_config_e_tag_port_id,
-		(void *)&cmd_config_e_tag_vf,
-		(void *)&cmd_config_e_tag_vf_id,
+		(void *)&cmd_flow_director_mask,
+		(void *)&cmd_flow_director_mask_port_id,
+		(void *)&cmd_flow_director_mask_mode,
+		(void *)&cmd_flow_director_mask_mode_ip,
+		(void *)&cmd_flow_director_mask_vlan,
+		(void *)&cmd_flow_director_mask_vlan_value,
+		(void *)&cmd_flow_director_mask_src,
+		(void *)&cmd_flow_director_mask_ipv4_src,
+		(void *)&cmd_flow_director_mask_ipv6_src,
+		(void *)&cmd_flow_director_mask_port_src,
+		(void *)&cmd_flow_director_mask_dst,
+		(void *)&cmd_flow_director_mask_ipv4_dst,
+		(void *)&cmd_flow_director_mask_ipv6_dst,
+		(void *)&cmd_flow_director_mask_port_dst,
 		NULL,
 	},
 };
 
-cmdline_parse_inst_t cmd_config_e_tag_insertion_dis = {
-	.f = cmd_config_e_tag_insertion_dis_parsed,
+cmdline_parse_inst_t cmd_set_flow_director_mac_vlan_mask = {
+	.f = cmd_flow_director_mask_parsed,
 	.data = NULL,
-	.help_str = "E-tag ... : E-tag insertion disable",
+	.help_str = "flow_director_mask ... : Set MAC VLAN mode "
+		"flow director's mask on NIC",
 	.tokens = {
-		(void *)&cmd_config_e_tag_e_tag,
-		(void *)&cmd_config_e_tag_set,
-		(void *)&cmd_config_e_tag_insertion,
-		(void *)&cmd_config_e_tag_off,
-		(void *)&cmd_config_e_tag_port,
-		(void *)&cmd_config_e_tag_port_id,
-		(void *)&cmd_config_e_tag_vf,
-		(void *)&cmd_config_e_tag_vf_id,
+		(void *)&cmd_flow_director_mask,
+		(void *)&cmd_flow_director_mask_port_id,
+		(void *)&cmd_flow_director_mask_mode,
+		(void *)&cmd_flow_director_mask_mode_mac_vlan,
+		(void *)&cmd_flow_director_mask_vlan,
+		(void *)&cmd_flow_director_mask_vlan_value,
 		NULL,
 	},
 };
 
-/* E-tag stripping configuration */
-static void
-cmd_config_e_tag_stripping_parsed(
-	void *parsed_result,
-	__rte_unused struct cmdline *cl,
-	__rte_unused void *data)
-{
-	struct cmd_config_e_tag_result *res =
-		parsed_result;
-	struct rte_eth_l2_tunnel_conf entry;
-
-	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
-		return;
-
-	entry.l2_tunnel_type = RTE_L2_TUNNEL_TYPE_E_TAG;
-
-	if (!strcmp(res->on_off, "on"))
-		rte_eth_dev_l2_tunnel_offload_set
-			(res->port_id,
-			 &entry,
-			 ETH_L2_TUNNEL_STRIPPING_MASK,
-			 1);
-	else
-		rte_eth_dev_l2_tunnel_offload_set
-			(res->port_id,
-			 &entry,
-			 ETH_L2_TUNNEL_STRIPPING_MASK,
-			 0);
-}
-
-cmdline_parse_inst_t cmd_config_e_tag_stripping_en_dis = {
-	.f = cmd_config_e_tag_stripping_parsed,
+cmdline_parse_inst_t cmd_set_flow_director_tunnel_mask = {
+	.f = cmd_flow_director_mask_parsed,
 	.data = NULL,
-	.help_str = "E-tag ... : E-tag stripping enable/disable",
+	.help_str = "flow_director_mask ... : Set tunnel mode "
+		"flow director's mask on NIC",
 	.tokens = {
-		(void *)&cmd_config_e_tag_e_tag,
-		(void *)&cmd_config_e_tag_set,
-		(void *)&cmd_config_e_tag_stripping,
-		(void *)&cmd_config_e_tag_on_off,
-		(void *)&cmd_config_e_tag_port,
-		(void *)&cmd_config_e_tag_port_id,
+		(void *)&cmd_flow_director_mask,
+		(void *)&cmd_flow_director_mask_port_id,
+		(void *)&cmd_flow_director_mask_mode,
+		(void *)&cmd_flow_director_mask_mode_tunnel,
+		(void *)&cmd_flow_director_mask_vlan,
+		(void *)&cmd_flow_director_mask_vlan_value,
+		(void *)&cmd_flow_director_mask_mac,
+		(void *)&cmd_flow_director_mask_mac_value,
+		(void *)&cmd_flow_director_mask_tunnel_type,
+		(void *)&cmd_flow_director_mask_tunnel_type_value,
+		(void *)&cmd_flow_director_mask_tunnel_id,
+		(void *)&cmd_flow_director_mask_tunnel_id_value,
 		NULL,
 	},
 };
 
-/* E-tag forwarding configuration */
-static void
-cmd_config_e_tag_forwarding_parsed(
-	void *parsed_result,
-	__rte_unused struct cmdline *cl,
-	__rte_unused void *data)
+/* *** deal with flow director flexible payload configuration *** */
+struct cmd_flow_director_flexpayload_result {
+	cmdline_fixed_string_t flow_director_flexpayload;
+	portid_t port_id;
+	cmdline_fixed_string_t payload_layer;
+	cmdline_fixed_string_t payload_cfg;
+};
+
+static inline int
+parse_offsets(const char *q_arg, uint16_t *offsets, uint16_t max_num)
 {
-	struct cmd_config_e_tag_result *res = parsed_result;
-	struct rte_eth_l2_tunnel_conf entry;
+	char s[256];
+	const char *p, *p0 = q_arg;
+	char *end;
+	unsigned long int_fld;
+	char *str_fld[max_num];
+	int i;
+	unsigned size;
+	int ret = -1;
 
-	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
-		return;
+	p = strchr(p0, '(');
+	if (p == NULL)
+		return -1;
+	++p;
+	p0 = strchr(p, ')');
+	if (p0 == NULL)
+		return -1;
 
-	entry.l2_tunnel_type = RTE_L2_TUNNEL_TYPE_E_TAG;
+	size = p0 - p;
+	if (size >= sizeof(s))
+		return -1;
 
-	if (!strcmp(res->on_off, "on"))
-		rte_eth_dev_l2_tunnel_offload_set
-			(res->port_id,
-			 &entry,
-			 ETH_L2_TUNNEL_FORWARDING_MASK,
-			 1);
-	else
-		rte_eth_dev_l2_tunnel_offload_set
-			(res->port_id,
-			 &entry,
-			 ETH_L2_TUNNEL_FORWARDING_MASK,
-			 0);
+	snprintf(s, sizeof(s), "%.*s", size, p);
+	ret = rte_strsplit(s, sizeof(s), str_fld, max_num, ',');
+	if (ret < 0 || ret > max_num)
+		return -1;
+	for (i = 0; i < ret; i++) {
+		errno = 0;
+		int_fld = strtoul(str_fld[i], &end, 0);
+		if (errno != 0 || *end != '\0' || int_fld > UINT16_MAX)
+			return -1;
+		offsets[i] = (uint16_t)int_fld;
+	}
+	return ret;
 }
 
-cmdline_parse_inst_t cmd_config_e_tag_forwarding_en_dis = {
-	.f = cmd_config_e_tag_forwarding_parsed,
-	.data = NULL,
-	.help_str = "E-tag ... : E-tag forwarding enable/disable",
-	.tokens = {
-		(void *)&cmd_config_e_tag_e_tag,
-		(void *)&cmd_config_e_tag_set,
-		(void *)&cmd_config_e_tag_forwarding,
-		(void *)&cmd_config_e_tag_on_off,
-		(void *)&cmd_config_e_tag_port,
-		(void *)&cmd_config_e_tag_port_id,
-		NULL,
-	},
-};
-
-/* E-tag filter configuration */
 static void
-cmd_config_e_tag_filter_add_parsed(
-	void *parsed_result,
-	__rte_unused struct cmdline *cl,
-	__rte_unused void *data)
+cmd_flow_director_flxpld_parsed(void *parsed_result,
+			  __rte_unused struct cmdline *cl,
+			  __rte_unused void *data)
 {
-	struct cmd_config_e_tag_result *res = parsed_result;
-	struct rte_eth_l2_tunnel_conf entry;
+	struct cmd_flow_director_flexpayload_result *res = parsed_result;
+	struct rte_eth_flex_payload_cfg flex_cfg;
+	struct rte_port *port;
 	int ret = 0;
 
-	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
-		return;
-
-	if (res->e_tag_id_val > 0x3fff) {
-		printf("e-tag-id must be equal or less than 0x3fff.\n");
+	port = &ports[res->port_id];
+	/** Check if the port is not started **/
+	if (port->port_status != RTE_PORT_STOPPED) {
+		printf("Please stop port %d first\n", res->port_id);
 		return;
 	}
 
-	ret = rte_eth_dev_filter_supported(res->port_id,
-					   RTE_ETH_FILTER_L2_TUNNEL);
+	memset(&flex_cfg, 0, sizeof(struct rte_eth_flex_payload_cfg));
+
+	if (!strcmp(res->payload_layer, "raw"))
+		flex_cfg.type = RTE_ETH_RAW_PAYLOAD;
+	else if (!strcmp(res->payload_layer, "l2"))
+		flex_cfg.type = RTE_ETH_L2_PAYLOAD;
+	else if (!strcmp(res->payload_layer, "l3"))
+		flex_cfg.type = RTE_ETH_L3_PAYLOAD;
+	else if (!strcmp(res->payload_layer, "l4"))
+		flex_cfg.type = RTE_ETH_L4_PAYLOAD;
+
+	ret = parse_offsets(res->payload_cfg, flex_cfg.src_offset,
+			    RTE_ETH_FDIR_MAX_FLEXLEN);
 	if (ret < 0) {
-		printf("E-tag filter is not supported on port %u.\n",
-		       res->port_id);
+		printf("error: Cannot parse flex payload input.\n");
 		return;
 	}
 
-	entry.l2_tunnel_type = RTE_L2_TUNNEL_TYPE_E_TAG;
-	entry.tunnel_id = res->e_tag_id_val;
-	entry.pool = res->dst_pool_val;
-
-	ret = rte_eth_dev_filter_ctrl(res->port_id,
-				      RTE_ETH_FILTER_L2_TUNNEL,
-				      RTE_ETH_FILTER_ADD,
-				      &entry);
-	if (ret < 0)
-		printf("E-tag filter programming error: (%s)\n",
-		       strerror(-ret));
+	fdir_set_flex_payload(res->port_id, &flex_cfg);
+	cmd_reconfig_device_queue(res->port_id, 1, 1);
 }
 
-cmdline_parse_inst_t cmd_config_e_tag_filter_add = {
-	.f = cmd_config_e_tag_filter_add_parsed,
+cmdline_parse_token_string_t cmd_flow_director_flexpayload =
+	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_flexpayload_result,
+				 flow_director_flexpayload,
+				 "flow_director_flex_payload");
+cmdline_parse_token_num_t cmd_flow_director_flexpayload_port_id =
+	TOKEN_NUM_INITIALIZER(struct cmd_flow_director_flexpayload_result,
+			      port_id, RTE_UINT16);
+cmdline_parse_token_string_t cmd_flow_director_flexpayload_payload_layer =
+	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_flexpayload_result,
+				 payload_layer, "raw#l2#l3#l4");
+cmdline_parse_token_string_t cmd_flow_director_flexpayload_payload_cfg =
+	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_flexpayload_result,
+				 payload_cfg, NULL);
+
+cmdline_parse_inst_t cmd_set_flow_director_flex_payload = {
+	.f = cmd_flow_director_flxpld_parsed,
 	.data = NULL,
-	.help_str = "E-tag ... : E-tag filter add",
+	.help_str = "flow_director_flexpayload ... : "
+		"Set flow director's flex payload on NIC",
 	.tokens = {
-		(void *)&cmd_config_e_tag_e_tag,
-		(void *)&cmd_config_e_tag_set,
-		(void *)&cmd_config_e_tag_filter,
-		(void *)&cmd_config_e_tag_add,
-		(void *)&cmd_config_e_tag_e_tag_id,
-		(void *)&cmd_config_e_tag_e_tag_id_val,
-		(void *)&cmd_config_e_tag_dst_pool,
-		(void *)&cmd_config_e_tag_dst_pool_val,
-		(void *)&cmd_config_e_tag_port,
-		(void *)&cmd_config_e_tag_port_id,
+		(void *)&cmd_flow_director_flexpayload,
+		(void *)&cmd_flow_director_flexpayload_port_id,
+		(void *)&cmd_flow_director_flexpayload_payload_layer,
+		(void *)&cmd_flow_director_flexpayload_payload_cfg,
 		NULL,
 	},
 };
 
-static void
-cmd_config_e_tag_filter_del_parsed(
-	void *parsed_result,
-	__rte_unused struct cmdline *cl,
-	__rte_unused void *data)
-{
-	struct cmd_config_e_tag_result *res = parsed_result;
-	struct rte_eth_l2_tunnel_conf entry;
-	int ret = 0;
+/* Generic flow interface command. */
+extern cmdline_parse_inst_t cmd_flow;
 
-	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
-		return;
+/* *** ADD/REMOVE A MULTICAST MAC ADDRESS TO/FROM A PORT *** */
+struct cmd_mcast_addr_result {
+	cmdline_fixed_string_t mcast_addr_cmd;
+	cmdline_fixed_string_t what;
+	uint16_t port_num;
+	struct rte_ether_addr mc_addr;
+};
 
-	if (res->e_tag_id_val > 0x3fff) {
-		printf("e-tag-id must be less than 0x3fff.\n");
-		return;
-	}
+static void cmd_mcast_addr_parsed(void *parsed_result,
+		__rte_unused struct cmdline *cl,
+		__rte_unused void *data)
+{
+	struct cmd_mcast_addr_result *res = parsed_result;
 
-	ret = rte_eth_dev_filter_supported(res->port_id,
-					   RTE_ETH_FILTER_L2_TUNNEL);
-	if (ret < 0) {
-		printf("E-tag filter is not supported on port %u.\n",
-		       res->port_id);
+	if (!rte_is_multicast_ether_addr(&res->mc_addr)) {
+		printf("Invalid multicast addr %02X:%02X:%02X:%02X:%02X:%02X\n",
+		       res->mc_addr.addr_bytes[0], res->mc_addr.addr_bytes[1],
+		       res->mc_addr.addr_bytes[2], res->mc_addr.addr_bytes[3],
+		       res->mc_addr.addr_bytes[4], res->mc_addr.addr_bytes[5]);
 		return;
 	}
-
-	entry.l2_tunnel_type = RTE_L2_TUNNEL_TYPE_E_TAG;
-	entry.tunnel_id = res->e_tag_id_val;
-
-	ret = rte_eth_dev_filter_ctrl(res->port_id,
-				      RTE_ETH_FILTER_L2_TUNNEL,
-				      RTE_ETH_FILTER_DELETE,
-				      &entry);
-	if (ret < 0)
-		printf("E-tag filter programming error: (%s)\n",
-		       strerror(-ret));
+	if (strcmp(res->what, "add") == 0)
+		mcast_addr_add(res->port_num, &res->mc_addr);
+	else
+		mcast_addr_remove(res->port_num, &res->mc_addr);
 }
 
-cmdline_parse_inst_t cmd_config_e_tag_filter_del = {
-	.f = cmd_config_e_tag_filter_del_parsed,
-	.data = NULL,
-	.help_str = "E-tag ... : E-tag filter delete",
+cmdline_parse_token_string_t cmd_mcast_addr_cmd =
+	TOKEN_STRING_INITIALIZER(struct cmd_mcast_addr_result,
+				 mcast_addr_cmd, "mcast_addr");
+cmdline_parse_token_string_t cmd_mcast_addr_what =
+	TOKEN_STRING_INITIALIZER(struct cmd_mcast_addr_result, what,
+				 "add#remove");
+cmdline_parse_token_num_t cmd_mcast_addr_portnum =
+	TOKEN_NUM_INITIALIZER(struct cmd_mcast_addr_result, port_num,
+				 RTE_UINT16);
+cmdline_parse_token_etheraddr_t cmd_mcast_addr_addr =
+	TOKEN_ETHERADDR_INITIALIZER(struct cmd_mac_addr_result, address);
+
+cmdline_parse_inst_t cmd_mcast_addr = {
+	.f = cmd_mcast_addr_parsed,
+	.data = (void *)0,
+	.help_str = "mcast_addr add|remove <port_id> <mcast_addr>: "
+		"Add/Remove multicast MAC address on port_id",
 	.tokens = {
-		(void *)&cmd_config_e_tag_e_tag,
-		(void *)&cmd_config_e_tag_set,
-		(void *)&cmd_config_e_tag_filter,
-		(void *)&cmd_config_e_tag_del,
-		(void *)&cmd_config_e_tag_e_tag_id,
-		(void *)&cmd_config_e_tag_e_tag_id_val,
-		(void *)&cmd_config_e_tag_port,
-		(void *)&cmd_config_e_tag_port_id,
+		(void *)&cmd_mcast_addr_cmd,
+		(void *)&cmd_mcast_addr_what,
+		(void *)&cmd_mcast_addr_portnum,
+		(void *)&cmd_mcast_addr_addr,
 		NULL,
 	},
 };
@@ -13515,11 +10904,11 @@ cmdline_parse_token_string_t cmd_vf_vlan_anti_spoof_antispoof =
 cmdline_parse_token_num_t cmd_vf_vlan_anti_spoof_port_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_vf_vlan_anti_spoof_result,
-		 port_id, UINT16);
+		 port_id, RTE_UINT16);
 cmdline_parse_token_num_t cmd_vf_vlan_anti_spoof_vf_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_vf_vlan_anti_spoof_result,
-		 vf_id, UINT32);
+		 vf_id, RTE_UINT32);
 cmdline_parse_token_string_t cmd_vf_vlan_anti_spoof_on_off =
 	TOKEN_STRING_INITIALIZER
 		(struct cmd_vf_vlan_anti_spoof_result,
@@ -13539,17 +10928,17 @@ cmd_set_vf_vlan_anti_spoof_parsed(
 	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
 		return;
 
-#ifdef RTE_LIBRTE_IXGBE_PMD
+#ifdef RTE_NET_IXGBE
 	if (ret == -ENOTSUP)
 		ret = rte_pmd_ixgbe_set_vf_vlan_anti_spoof(res->port_id,
 				res->vf_id, is_on);
 #endif
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
 	if (ret == -ENOTSUP)
 		ret = rte_pmd_i40e_set_vf_vlan_anti_spoof(res->port_id,
 				res->vf_id, is_on);
 #endif
-#ifdef RTE_LIBRTE_BNXT_PMD
+#ifdef RTE_NET_BNXT
 	if (ret == -ENOTSUP)
 		ret = rte_pmd_bnxt_set_vf_vlan_anti_spoof(res->port_id,
 				res->vf_id, is_on);
@@ -13621,11 +11010,11 @@ cmdline_parse_token_string_t cmd_vf_mac_anti_spoof_antispoof =
 cmdline_parse_token_num_t cmd_vf_mac_anti_spoof_port_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_vf_mac_anti_spoof_result,
-		 port_id, UINT16);
+		 port_id, RTE_UINT16);
 cmdline_parse_token_num_t cmd_vf_mac_anti_spoof_vf_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_vf_mac_anti_spoof_result,
-		 vf_id, UINT32);
+		 vf_id, RTE_UINT32);
 cmdline_parse_token_string_t cmd_vf_mac_anti_spoof_on_off =
 	TOKEN_STRING_INITIALIZER
 		(struct cmd_vf_mac_anti_spoof_result,
@@ -13645,17 +11034,17 @@ cmd_set_vf_mac_anti_spoof_parsed(
 	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
 		return;
 
-#ifdef RTE_LIBRTE_IXGBE_PMD
+#ifdef RTE_NET_IXGBE
 	if (ret == -ENOTSUP)
 		ret = rte_pmd_ixgbe_set_vf_mac_anti_spoof(res->port_id,
 			res->vf_id, is_on);
 #endif
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
 	if (ret == -ENOTSUP)
 		ret = rte_pmd_i40e_set_vf_mac_anti_spoof(res->port_id,
 			res->vf_id, is_on);
 #endif
-#ifdef RTE_LIBRTE_BNXT_PMD
+#ifdef RTE_NET_BNXT
 	if (ret == -ENOTSUP)
 		ret = rte_pmd_bnxt_set_vf_mac_anti_spoof(res->port_id,
 			res->vf_id, is_on);
@@ -13727,11 +11116,11 @@ cmdline_parse_token_string_t cmd_vf_vlan_stripq_stripq =
 cmdline_parse_token_num_t cmd_vf_vlan_stripq_port_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_vf_vlan_stripq_result,
-		 port_id, UINT16);
+		 port_id, RTE_UINT16);
 cmdline_parse_token_num_t cmd_vf_vlan_stripq_vf_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_vf_vlan_stripq_result,
-		 vf_id, UINT16);
+		 vf_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_vf_vlan_stripq_on_off =
 	TOKEN_STRING_INITIALIZER
 		(struct cmd_vf_vlan_stripq_result,
@@ -13751,17 +11140,17 @@ cmd_set_vf_vlan_stripq_parsed(
 	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
 		return;
 
-#ifdef RTE_LIBRTE_IXGBE_PMD
+#ifdef RTE_NET_IXGBE
 	if (ret == -ENOTSUP)
 		ret = rte_pmd_ixgbe_set_vf_vlan_stripq(res->port_id,
 			res->vf_id, is_on);
 #endif
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
 	if (ret == -ENOTSUP)
 		ret = rte_pmd_i40e_set_vf_vlan_stripq(res->port_id,
 			res->vf_id, is_on);
 #endif
-#ifdef RTE_LIBRTE_BNXT_PMD
+#ifdef RTE_NET_BNXT
 	if (ret == -ENOTSUP)
 		ret = rte_pmd_bnxt_set_vf_vlan_stripq(res->port_id,
 			res->vf_id, is_on);
@@ -13833,15 +11222,15 @@ cmdline_parse_token_string_t cmd_vf_vlan_insert_insert =
 cmdline_parse_token_num_t cmd_vf_vlan_insert_port_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_vf_vlan_insert_result,
-		 port_id, UINT16);
+		 port_id, RTE_UINT16);
 cmdline_parse_token_num_t cmd_vf_vlan_insert_vf_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_vf_vlan_insert_result,
-		 vf_id, UINT16);
+		 vf_id, RTE_UINT16);
 cmdline_parse_token_num_t cmd_vf_vlan_insert_vlan_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_vf_vlan_insert_result,
-		 vlan_id, UINT16);
+		 vlan_id, RTE_UINT16);
 
 static void
 cmd_set_vf_vlan_insert_parsed(
@@ -13855,17 +11244,17 @@ cmd_set_vf_vlan_insert_parsed(
 	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
 		return;
 
-#ifdef RTE_LIBRTE_IXGBE_PMD
+#ifdef RTE_NET_IXGBE
 	if (ret == -ENOTSUP)
 		ret = rte_pmd_ixgbe_set_vf_vlan_insert(res->port_id, res->vf_id,
 			res->vlan_id);
 #endif
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
 	if (ret == -ENOTSUP)
 		ret = rte_pmd_i40e_set_vf_vlan_insert(res->port_id, res->vf_id,
 			res->vlan_id);
 #endif
-#ifdef RTE_LIBRTE_BNXT_PMD
+#ifdef RTE_NET_BNXT
 	if (ret == -ENOTSUP)
 		ret = rte_pmd_bnxt_set_vf_vlan_insert(res->port_id, res->vf_id,
 			res->vlan_id);
@@ -13931,7 +11320,7 @@ cmdline_parse_token_string_t cmd_tx_loopback_loopback =
 cmdline_parse_token_num_t cmd_tx_loopback_port_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_tx_loopback_result,
-		 port_id, UINT16);
+		 port_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_tx_loopback_on_off =
 	TOKEN_STRING_INITIALIZER
 		(struct cmd_tx_loopback_result,
@@ -13951,19 +11340,19 @@ cmd_set_tx_loopback_parsed(
 	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
 		return;
 
-#ifdef RTE_LIBRTE_IXGBE_PMD
+#ifdef RTE_NET_IXGBE
 	if (ret == -ENOTSUP)
 		ret = rte_pmd_ixgbe_set_tx_loopback(res->port_id, is_on);
 #endif
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
 	if (ret == -ENOTSUP)
 		ret = rte_pmd_i40e_set_tx_loopback(res->port_id, is_on);
 #endif
-#ifdef RTE_LIBRTE_BNXT_PMD
+#ifdef RTE_NET_BNXT
 	if (ret == -ENOTSUP)
 		ret = rte_pmd_bnxt_set_tx_loopback(res->port_id, is_on);
 #endif
-#if defined RTE_LIBRTE_DPAA_BUS && defined RTE_LIBRTE_DPAA_PMD
+#if defined RTE_BUS_DPAA && defined RTE_NET_DPAA
 	if (ret == -ENOTSUP)
 		ret = rte_pmd_dpaa_set_tx_loopback(res->port_id, is_on);
 #endif
@@ -14031,7 +11420,7 @@ cmdline_parse_token_string_t cmd_all_queues_drop_en_drop =
 cmdline_parse_token_num_t cmd_all_queues_drop_en_port_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_all_queues_drop_en_result,
-		 port_id, UINT16);
+		 port_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_all_queues_drop_en_on_off =
 	TOKEN_STRING_INITIALIZER
 		(struct cmd_all_queues_drop_en_result,
@@ -14050,11 +11439,11 @@ cmd_set_all_queues_drop_en_parsed(
 	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
 		return;
 
-#ifdef RTE_LIBRTE_IXGBE_PMD
+#ifdef RTE_NET_IXGBE
 	if (ret == -ENOTSUP)
 		ret = rte_pmd_ixgbe_set_all_queues_drop_en(res->port_id, is_on);
 #endif
-#ifdef RTE_LIBRTE_BNXT_PMD
+#ifdef RTE_NET_BNXT
 	if (ret == -ENOTSUP)
 		ret = rte_pmd_bnxt_set_all_queues_drop_en(res->port_id, is_on);
 #endif
@@ -14123,11 +11512,11 @@ cmdline_parse_token_string_t cmd_vf_split_drop_en_drop =
 cmdline_parse_token_num_t cmd_vf_split_drop_en_port_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_vf_split_drop_en_result,
-		 port_id, UINT16);
+		 port_id, RTE_UINT16);
 cmdline_parse_token_num_t cmd_vf_split_drop_en_vf_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_vf_split_drop_en_result,
-		 vf_id, UINT16);
+		 vf_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_vf_split_drop_en_on_off =
 	TOKEN_STRING_INITIALIZER
 		(struct cmd_vf_split_drop_en_result,
@@ -14146,7 +11535,7 @@ cmd_set_vf_split_drop_en_parsed(
 	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
 		return;
 
-#ifdef RTE_LIBRTE_IXGBE_PMD
+#ifdef RTE_NET_IXGBE
 	ret = rte_pmd_ixgbe_set_vf_split_drop_en(res->port_id, res->vf_id,
 			is_on);
 #endif
@@ -14217,11 +11606,11 @@ cmdline_parse_token_string_t cmd_set_vf_mac_addr_addr =
 cmdline_parse_token_num_t cmd_set_vf_mac_addr_port_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_set_vf_mac_addr_result,
-		 port_id, UINT16);
+		 port_id, RTE_UINT16);
 cmdline_parse_token_num_t cmd_set_vf_mac_addr_vf_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_set_vf_mac_addr_result,
-		 vf_id, UINT16);
+		 vf_id, RTE_UINT16);
 cmdline_parse_token_etheraddr_t cmd_set_vf_mac_addr_mac_addr =
 	TOKEN_ETHERADDR_INITIALIZER(struct cmd_set_vf_mac_addr_result,
 		 mac_addr);
@@ -14238,17 +11627,17 @@ cmd_set_vf_mac_addr_parsed(
 	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
 		return;
 
-#ifdef RTE_LIBRTE_IXGBE_PMD
+#ifdef RTE_NET_IXGBE
 	if (ret == -ENOTSUP)
 		ret = rte_pmd_ixgbe_set_vf_mac_addr(res->port_id, res->vf_id,
 				&res->mac_addr);
 #endif
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
 	if (ret == -ENOTSUP)
 		ret = rte_pmd_i40e_set_vf_mac_addr(res->port_id, res->vf_id,
 				&res->mac_addr);
 #endif
-#ifdef RTE_LIBRTE_BNXT_PMD
+#ifdef RTE_NET_BNXT
 	if (ret == -ENOTSUP)
 		ret = rte_pmd_bnxt_set_vf_mac_addr(res->port_id, res->vf_id,
 				&res->mac_addr);
@@ -14318,7 +11707,7 @@ cmdline_parse_token_string_t cmd_macsec_offload_on_offload =
 cmdline_parse_token_num_t cmd_macsec_offload_on_port_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_macsec_offload_on_result,
-		 port_id, UINT16);
+		 port_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_macsec_offload_on_on =
 	TOKEN_STRING_INITIALIZER
 		(struct cmd_macsec_offload_on_result,
@@ -14365,7 +11754,7 @@ cmd_set_macsec_offload_on_parsed(
 		return;
 
 	if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_MACSEC_INSERT) {
-#ifdef RTE_LIBRTE_IXGBE_PMD
+#ifdef RTE_NET_IXGBE
 		ret = rte_pmd_ixgbe_macsec_enable(port_id, en, rp);
 #endif
 	}
@@ -14433,7 +11822,7 @@ cmdline_parse_token_string_t cmd_macsec_offload_off_offload =
 cmdline_parse_token_num_t cmd_macsec_offload_off_port_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_macsec_offload_off_result,
-		 port_id, UINT16);
+		 port_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_macsec_offload_off_off =
 	TOKEN_STRING_INITIALIZER
 		(struct cmd_macsec_offload_off_result,
@@ -14462,7 +11851,7 @@ cmd_set_macsec_offload_off_parsed(
 		return;
 
 	if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_MACSEC_INSERT) {
-#ifdef RTE_LIBRTE_IXGBE_PMD
+#ifdef RTE_NET_IXGBE
 		ret = rte_pmd_ixgbe_macsec_disable(port_id);
 #endif
 	}
@@ -14528,7 +11917,7 @@ cmdline_parse_token_string_t cmd_macsec_sc_tx_rx =
 cmdline_parse_token_num_t cmd_macsec_sc_port_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_macsec_sc_result,
-		 port_id, UINT16);
+		 port_id, RTE_UINT16);
 cmdline_parse_token_etheraddr_t cmd_macsec_sc_mac =
 	TOKEN_ETHERADDR_INITIALIZER
 		(struct cmd_macsec_sc_result,
@@ -14536,7 +11925,7 @@ cmdline_parse_token_etheraddr_t cmd_macsec_sc_mac =
 cmdline_parse_token_num_t cmd_macsec_sc_pi =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_macsec_sc_result,
-		 pi, UINT16);
+		 pi, RTE_UINT16);
 
 static void
 cmd_set_macsec_sc_parsed(
@@ -14548,7 +11937,7 @@ cmd_set_macsec_sc_parsed(
 	int ret = -ENOTSUP;
 	int is_tx = (strcmp(res->tx_rx, "tx") == 0) ? 1 : 0;
 
-#ifdef RTE_LIBRTE_IXGBE_PMD
+#ifdef RTE_NET_IXGBE
 	ret = is_tx ?
 		rte_pmd_ixgbe_macsec_config_txsc(res->port_id,
 				res->mac.addr_bytes) :
@@ -14620,19 +12009,19 @@ cmdline_parse_token_string_t cmd_macsec_sa_tx_rx =
 cmdline_parse_token_num_t cmd_macsec_sa_port_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_macsec_sa_result,
-		 port_id, UINT16);
+		 port_id, RTE_UINT16);
 cmdline_parse_token_num_t cmd_macsec_sa_idx =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_macsec_sa_result,
-		 idx, UINT8);
+		 idx, RTE_UINT8);
 cmdline_parse_token_num_t cmd_macsec_sa_an =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_macsec_sa_result,
-		 an, UINT8);
+		 an, RTE_UINT8);
 cmdline_parse_token_num_t cmd_macsec_sa_pn =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_macsec_sa_result,
-		 pn, UINT32);
+		 pn, RTE_UINT32);
 cmdline_parse_token_string_t cmd_macsec_sa_key =
 	TOKEN_STRING_INITIALIZER
 		(struct cmd_macsec_sa_result,
@@ -14667,7 +12056,7 @@ cmd_set_macsec_sa_parsed(
 		key[i] = (uint8_t) ((xdgt0 * 16) + xdgt1);
 	}
 
-#ifdef RTE_LIBRTE_IXGBE_PMD
+#ifdef RTE_NET_IXGBE
 	ret = is_tx ?
 		rte_pmd_ixgbe_macsec_select_txsa(res->port_id,
 			res->idx, res->an, res->pn, key) :
@@ -14740,11 +12129,11 @@ cmdline_parse_token_string_t cmd_vf_promisc_promisc =
 cmdline_parse_token_num_t cmd_vf_promisc_port_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_vf_promisc_result,
-		 port_id, UINT16);
+		 port_id, RTE_UINT16);
 cmdline_parse_token_num_t cmd_vf_promisc_vf_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_vf_promisc_result,
-		 vf_id, UINT32);
+		 vf_id, RTE_UINT32);
 cmdline_parse_token_string_t cmd_vf_promisc_on_off =
 	TOKEN_STRING_INITIALIZER
 		(struct cmd_vf_promisc_result,
@@ -14764,7 +12153,7 @@ cmd_set_vf_promisc_parsed(
 	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
 		return;
 
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
 	ret = rte_pmd_i40e_set_vf_unicast_promisc(res->port_id,
 						  res->vf_id, is_on);
 #endif
@@ -14830,11 +12219,11 @@ cmdline_parse_token_string_t cmd_vf_allmulti_allmulti =
 cmdline_parse_token_num_t cmd_vf_allmulti_port_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_vf_allmulti_result,
-		 port_id, UINT16);
+		 port_id, RTE_UINT16);
 cmdline_parse_token_num_t cmd_vf_allmulti_vf_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_vf_allmulti_result,
-		 vf_id, UINT32);
+		 vf_id, RTE_UINT32);
 cmdline_parse_token_string_t cmd_vf_allmulti_on_off =
 	TOKEN_STRING_INITIALIZER
 		(struct cmd_vf_allmulti_result,
@@ -14854,7 +12243,7 @@ cmd_set_vf_allmulti_parsed(
 	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
 		return;
 
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
 	ret = rte_pmd_i40e_set_vf_multicast_promisc(res->port_id,
 						    res->vf_id, is_on);
 #endif
@@ -14920,11 +12309,11 @@ cmdline_parse_token_string_t cmd_set_vf_broadcast_broadcast =
 cmdline_parse_token_num_t cmd_set_vf_broadcast_port_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_set_vf_broadcast_result,
-		 port_id, UINT16);
+		 port_id, RTE_UINT16);
 cmdline_parse_token_num_t cmd_set_vf_broadcast_vf_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_set_vf_broadcast_result,
-		 vf_id, UINT16);
+		 vf_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_set_vf_broadcast_on_off =
 	TOKEN_STRING_INITIALIZER
 		(struct cmd_set_vf_broadcast_result,
@@ -14944,7 +12333,7 @@ cmd_set_vf_broadcast_parsed(
 	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
 		return;
 
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
 	ret = rte_pmd_i40e_set_vf_broadcast(res->port_id,
 					    res->vf_id, is_on);
 #endif
@@ -15014,11 +12403,11 @@ cmdline_parse_token_string_t cmd_set_vf_vlan_tag_tag =
 cmdline_parse_token_num_t cmd_set_vf_vlan_tag_port_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_set_vf_vlan_tag_result,
-		 port_id, UINT16);
+		 port_id, RTE_UINT16);
 cmdline_parse_token_num_t cmd_set_vf_vlan_tag_vf_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_set_vf_vlan_tag_result,
-		 vf_id, UINT16);
+		 vf_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_set_vf_vlan_tag_on_off =
 	TOKEN_STRING_INITIALIZER
 		(struct cmd_set_vf_vlan_tag_result,
@@ -15038,7 +12427,7 @@ cmd_set_vf_vlan_tag_parsed(
 	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
 		return;
 
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
 	ret = rte_pmd_i40e_set_vf_vlan_tag(res->port_id,
 					   res->vf_id, is_on);
 #endif
@@ -15124,19 +12513,19 @@ cmdline_parse_token_string_t cmd_vf_tc_bw_max_bw =
 cmdline_parse_token_num_t cmd_vf_tc_bw_port_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_vf_tc_bw_result,
-		 port_id, UINT16);
+		 port_id, RTE_UINT16);
 cmdline_parse_token_num_t cmd_vf_tc_bw_vf_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_vf_tc_bw_result,
-		 vf_id, UINT16);
+		 vf_id, RTE_UINT16);
 cmdline_parse_token_num_t cmd_vf_tc_bw_tc_no =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_vf_tc_bw_result,
-		 tc_no, UINT8);
+		 tc_no, RTE_UINT8);
 cmdline_parse_token_num_t cmd_vf_tc_bw_bw =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_vf_tc_bw_result,
-		 bw, UINT32);
+		 bw, RTE_UINT32);
 cmdline_parse_token_string_t cmd_vf_tc_bw_bw_list =
 	TOKEN_STRING_INITIALIZER
 		(struct cmd_vf_tc_bw_result,
@@ -15144,7 +12533,7 @@ cmdline_parse_token_string_t cmd_vf_tc_bw_bw_list =
 cmdline_parse_token_num_t cmd_vf_tc_bw_tc_map =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_vf_tc_bw_result,
-		 tc_map, UINT8);
+		 tc_map, RTE_UINT8);
 
 /* VF max bandwidth setting */
 static void
@@ -15159,7 +12548,7 @@ cmd_vf_max_bw_parsed(
 	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
 		return;
 
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
 	ret = rte_pmd_i40e_set_vf_max_bw(res->port_id,
 					 res->vf_id, res->bw);
 #endif
@@ -15259,7 +12648,7 @@ cmd_vf_tc_min_bw_parsed(
 	if (ret)
 		return;
 
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
 	ret = rte_pmd_i40e_set_vf_tc_bw_alloc(res->port_id, res->vf_id,
 					      tc_num, bw);
 #endif
@@ -15325,7 +12714,7 @@ cmd_tc_min_bw_parsed(
 	if (ret)
 		return;
 
-#ifdef RTE_LIBRTE_IXGBE_PMD
+#ifdef RTE_NET_IXGBE
 	ret = rte_pmd_ixgbe_set_tc_bw_alloc(res->port_id, tc_num, bw);
 #endif
 
@@ -15374,7 +12763,7 @@ cmd_vf_tc_max_bw_parsed(
 	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
 		return;
 
-#ifdef RTE_LIBRTE_I40E_PMD
+#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
@@ -15455,27 +12844,27 @@ cmdline_parse_token_string_t cmd_set_vxlan_vni =
 	TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, pos_token,
 				 "vni");
 cmdline_parse_token_num_t cmd_set_vxlan_vni_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_vxlan_result, vni, UINT32);
+	TOKEN_NUM_INITIALIZER(struct cmd_set_vxlan_result, vni, RTE_UINT32);
 cmdline_parse_token_string_t cmd_set_vxlan_udp_src =
 	TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, pos_token,
 				 "udp-src");
 cmdline_parse_token_num_t cmd_set_vxlan_udp_src_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_vxlan_result, udp_src, UINT16);
+	TOKEN_NUM_INITIALIZER(struct cmd_set_vxlan_result, udp_src, RTE_UINT16);
 cmdline_parse_token_string_t cmd_set_vxlan_udp_dst =
 	TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, pos_token,
 				 "udp-dst");
 cmdline_parse_token_num_t cmd_set_vxlan_udp_dst_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_vxlan_result, udp_dst, UINT16);
+	TOKEN_NUM_INITIALIZER(struct cmd_set_vxlan_result, udp_dst, RTE_UINT16);
 cmdline_parse_token_string_t cmd_set_vxlan_ip_tos =
 	TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, pos_token,
 				 "ip-tos");
 cmdline_parse_token_num_t cmd_set_vxlan_ip_tos_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_vxlan_result, tos, UINT8);
+	TOKEN_NUM_INITIALIZER(struct cmd_set_vxlan_result, tos, RTE_UINT8);
 cmdline_parse_token_string_t cmd_set_vxlan_ip_ttl =
 	TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, pos_token,
 				 "ip-ttl");
 cmdline_parse_token_num_t cmd_set_vxlan_ip_ttl_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_vxlan_result, ttl, UINT8);
+	TOKEN_NUM_INITIALIZER(struct cmd_set_vxlan_result, ttl, RTE_UINT8);
 cmdline_parse_token_string_t cmd_set_vxlan_ip_src =
 	TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, pos_token,
 				 "ip-src");
@@ -15490,7 +12879,7 @@ cmdline_parse_token_string_t cmd_set_vxlan_vlan =
 	TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, pos_token,
 				 "vlan-tci");
 cmdline_parse_token_num_t cmd_set_vxlan_vlan_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_vxlan_result, tci, UINT16);
+	TOKEN_NUM_INITIALIZER(struct cmd_set_vxlan_result, tci, RTE_UINT16);
 cmdline_parse_token_string_t cmd_set_vxlan_eth_src =
 	TOKEN_STRING_INITIALIZER(struct cmd_set_vxlan_result, pos_token,
 				 "eth-src");
@@ -15675,7 +13064,7 @@ cmdline_parse_token_string_t cmd_set_nvgre_tni =
 	TOKEN_STRING_INITIALIZER(struct cmd_set_nvgre_result, pos_token,
 				 "tni");
 cmdline_parse_token_num_t cmd_set_nvgre_tni_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_nvgre_result, tni, UINT32);
+	TOKEN_NUM_INITIALIZER(struct cmd_set_nvgre_result, tni, RTE_UINT32);
 cmdline_parse_token_string_t cmd_set_nvgre_ip_src =
 	TOKEN_STRING_INITIALIZER(struct cmd_set_nvgre_result, pos_token,
 				 "ip-src");
@@ -15690,7 +13079,7 @@ cmdline_parse_token_string_t cmd_set_nvgre_vlan =
 	TOKEN_STRING_INITIALIZER(struct cmd_set_nvgre_result, pos_token,
 				 "vlan-tci");
 cmdline_parse_token_num_t cmd_set_nvgre_vlan_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_nvgre_result, tci, UINT16);
+	TOKEN_NUM_INITIALIZER(struct cmd_set_nvgre_result, tci, RTE_UINT16);
 cmdline_parse_token_string_t cmd_set_nvgre_eth_src =
 	TOKEN_STRING_INITIALIZER(struct cmd_set_nvgre_result, pos_token,
 				 "eth-src");
@@ -15821,7 +13210,7 @@ cmdline_parse_token_string_t cmd_set_l2_encap_vlan =
 	TOKEN_STRING_INITIALIZER(struct cmd_set_l2_encap_result, pos_token,
 				 "vlan-tci");
 cmdline_parse_token_num_t cmd_set_l2_encap_vlan_value =
-	TOKEN_NUM_INITIALIZER(struct cmd_set_l2_encap_result, tci, UINT16);
+	TOKEN_NUM_INITIALIZER(struct cmd_set_l2_encap_result, tci, RTE_UINT16);
 cmdline_parse_token_string_t cmd_set_l2_encap_eth_src =
 	TOKEN_STRING_INITIALIZER(struct cmd_set_l2_encap_result, pos_token,
 				 "eth-src");
@@ -15981,7 +13370,7 @@ cmdline_parse_token_string_t cmd_set_mplsogre_encap_label =
 				 pos_token, "label");
 cmdline_parse_token_num_t cmd_set_mplsogre_encap_label_value =
 	TOKEN_NUM_INITIALIZER(struct cmd_set_mplsogre_encap_result, label,
-			      UINT32);
+			      RTE_UINT32);
 cmdline_parse_token_string_t cmd_set_mplsogre_encap_ip_src =
 	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_encap_result,
 				 pos_token, "ip-src");
@@ -15997,7 +13386,7 @@ cmdline_parse_token_string_t cmd_set_mplsogre_encap_vlan =
 				 pos_token, "vlan-tci");
 cmdline_parse_token_num_t cmd_set_mplsogre_encap_vlan_value =
 	TOKEN_NUM_INITIALIZER(struct cmd_set_mplsogre_encap_result, tci,
-			      UINT16);
+			      RTE_UINT16);
 cmdline_parse_token_string_t cmd_set_mplsogre_encap_eth_src =
 	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsogre_encap_result,
 				 pos_token, "eth-src");
@@ -16205,19 +13594,19 @@ cmdline_parse_token_string_t cmd_set_mplsoudp_encap_label =
 				 pos_token, "label");
 cmdline_parse_token_num_t cmd_set_mplsoudp_encap_label_value =
 	TOKEN_NUM_INITIALIZER(struct cmd_set_mplsoudp_encap_result, label,
-			      UINT32);
+			      RTE_UINT32);
 cmdline_parse_token_string_t cmd_set_mplsoudp_encap_udp_src =
 	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
 				 pos_token, "udp-src");
 cmdline_parse_token_num_t cmd_set_mplsoudp_encap_udp_src_value =
 	TOKEN_NUM_INITIALIZER(struct cmd_set_mplsoudp_encap_result, udp_src,
-			      UINT16);
+			      RTE_UINT16);
 cmdline_parse_token_string_t cmd_set_mplsoudp_encap_udp_dst =
 	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
 				 pos_token, "udp-dst");
 cmdline_parse_token_num_t cmd_set_mplsoudp_encap_udp_dst_value =
 	TOKEN_NUM_INITIALIZER(struct cmd_set_mplsoudp_encap_result, udp_dst,
-			      UINT16);
+			      RTE_UINT16);
 cmdline_parse_token_string_t cmd_set_mplsoudp_encap_ip_src =
 	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
 				 pos_token, "ip-src");
@@ -16233,7 +13622,7 @@ cmdline_parse_token_string_t cmd_set_mplsoudp_encap_vlan =
 				 pos_token, "vlan-tci");
 cmdline_parse_token_num_t cmd_set_mplsoudp_encap_vlan_value =
 	TOKEN_NUM_INITIALIZER(struct cmd_set_mplsoudp_encap_result, tci,
-			      UINT16);
+			      RTE_UINT16);
 cmdline_parse_token_string_t cmd_set_mplsoudp_encap_eth_src =
 	TOKEN_STRING_INITIALIZER(struct cmd_set_mplsoudp_encap_result,
 				 pos_token, "eth-src");
@@ -16415,6 +13804,359 @@ cmdline_parse_inst_t cmd_set_mplsoudp_decap_with_vlan = {
 	},
 };
 
+/** 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;
+};
+
+cmdline_parse_token_string_t cmd_set_conntrack_set =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+				 set, "set");
+cmdline_parse_token_string_t cmd_set_conntrack_conntrack =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+				 conntrack, "conntrack");
+cmdline_parse_token_string_t cmd_set_conntrack_common_com =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+				 common, "com");
+cmdline_parse_token_string_t cmd_set_conntrack_common_peer =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+				 peer, "peer");
+cmdline_parse_token_num_t cmd_set_conntrack_common_peer_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+			      peer_port, RTE_UINT16);
+cmdline_parse_token_string_t cmd_set_conntrack_common_is_orig =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+				 is_orig, "is_orig");
+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);
+cmdline_parse_token_string_t cmd_set_conntrack_common_enable =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+				 enable, "enable");
+cmdline_parse_token_num_t cmd_set_conntrack_common_enable_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+			      en, RTE_UINT32);
+cmdline_parse_token_string_t cmd_set_conntrack_common_live =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+				 live, "live");
+cmdline_parse_token_num_t cmd_set_conntrack_common_live_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+			      is_live, RTE_UINT32);
+cmdline_parse_token_string_t cmd_set_conntrack_common_sack =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+				 sack, "sack");
+cmdline_parse_token_num_t cmd_set_conntrack_common_sack_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+			      s_ack, RTE_UINT32);
+cmdline_parse_token_string_t cmd_set_conntrack_common_cack =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+				 cack, "cack");
+cmdline_parse_token_num_t cmd_set_conntrack_common_cack_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+			      c_ack, RTE_UINT32);
+cmdline_parse_token_string_t cmd_set_conntrack_common_last_dir =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+				 last_dir, "last_dir");
+cmdline_parse_token_num_t cmd_set_conntrack_common_last_dir_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+			      ld, RTE_UINT32);
+cmdline_parse_token_string_t cmd_set_conntrack_common_liberal =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+				 liberal, "liberal");
+cmdline_parse_token_num_t cmd_set_conntrack_common_liberal_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+			      lb, RTE_UINT32);
+cmdline_parse_token_string_t cmd_set_conntrack_common_state =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+				 state, "state");
+cmdline_parse_token_num_t cmd_set_conntrack_common_state_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+			      stat, RTE_UINT8);
+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");
+cmdline_parse_token_num_t cmd_set_conntrack_common_max_ackwin_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+			      factor, RTE_UINT8);
+cmdline_parse_token_string_t cmd_set_conntrack_common_retrans =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+				 retrans, "r_lim");
+cmdline_parse_token_num_t cmd_set_conntrack_common_retrans_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+			      re_num, RTE_UINT8);
+cmdline_parse_token_string_t cmd_set_conntrack_common_last_win =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+				 last_win, "last_win");
+cmdline_parse_token_num_t cmd_set_conntrack_common_last_win_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+			      lw, RTE_UINT16);
+cmdline_parse_token_string_t cmd_set_conntrack_common_last_seq =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+				 last_seq, "last_seq");
+cmdline_parse_token_num_t cmd_set_conntrack_common_last_seq_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+			      ls, RTE_UINT32);
+cmdline_parse_token_string_t cmd_set_conntrack_common_last_ack =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+				 last_ack, "last_ack");
+cmdline_parse_token_num_t cmd_set_conntrack_common_last_ack_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+			      la, RTE_UINT32);
+cmdline_parse_token_string_t cmd_set_conntrack_common_last_end =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+				 last_end, "last_end");
+cmdline_parse_token_num_t cmd_set_conntrack_common_last_end_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_common_result,
+			      le, RTE_UINT32);
+cmdline_parse_token_string_t cmd_set_conntrack_common_last_index =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_common_result,
+				 last_index, "last_index");
+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;
+}
+
+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_parse_token_string_t cmd_set_conntrack_dir_set =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
+				 set, "set");
+cmdline_parse_token_string_t cmd_set_conntrack_dir_conntrack =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
+				 conntrack, "conntrack");
+cmdline_parse_token_string_t cmd_set_conntrack_dir_dir =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
+				 dir, "orig#rply");
+cmdline_parse_token_string_t cmd_set_conntrack_dir_scale =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
+				 scale, "scale");
+cmdline_parse_token_num_t cmd_set_conntrack_dir_scale_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result,
+			      factor, RTE_UINT32);
+cmdline_parse_token_string_t cmd_set_conntrack_dir_fin =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
+				 fin, "fin");
+cmdline_parse_token_num_t cmd_set_conntrack_dir_fin_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result,
+			      f, RTE_UINT32);
+cmdline_parse_token_string_t cmd_set_conntrack_dir_ack =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
+				 ack_seen, "acked");
+cmdline_parse_token_num_t cmd_set_conntrack_dir_ack_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result,
+			      as, RTE_UINT32);
+cmdline_parse_token_string_t cmd_set_conntrack_dir_unack_data =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
+				 unack, "unack_data");
+cmdline_parse_token_num_t cmd_set_conntrack_dir_unack_data_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result,
+			      un, RTE_UINT32);
+cmdline_parse_token_string_t cmd_set_conntrack_dir_sent_end =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
+				 sent_end, "sent_end");
+cmdline_parse_token_num_t cmd_set_conntrack_dir_sent_end_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result,
+			      se, RTE_UINT32);
+cmdline_parse_token_string_t cmd_set_conntrack_dir_reply_end =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
+				 reply_end, "reply_end");
+cmdline_parse_token_num_t cmd_set_conntrack_dir_reply_end_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result,
+			      re, RTE_UINT32);
+cmdline_parse_token_string_t cmd_set_conntrack_dir_max_win =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
+				 max_win, "max_win");
+cmdline_parse_token_num_t cmd_set_conntrack_dir_max_win_value =
+	TOKEN_NUM_INITIALIZER(struct cmd_set_conntrack_dir_result,
+			      mw, RTE_UINT32);
+cmdline_parse_token_string_t cmd_set_conntrack_dir_max_ack =
+	TOKEN_STRING_INITIALIZER(struct cmd_set_conntrack_dir_result,
+				 max_ack, "max_ack");
+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_set_conntrack_dir_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;
+
+	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;
+	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;
+}
+
+cmdline_parse_inst_t cmd_set_conntrack_dir = {
+	.f = cmd_set_conntrack_dir_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>",
+	.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,
+		NULL,
+	},
+};
+
 /* Strict link priority scheduling mode setting */
 static void
 cmd_strict_link_prio_parsed(
@@ -16428,7 +14170,7 @@ cmd_strict_link_prio_parsed(
 	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
 		return;
 
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
 	ret = rte_pmd_i40e_set_tc_strict_prio(res->port_id, res->tc_map);
 #endif
 
@@ -16476,7 +14218,8 @@ cmdline_parse_token_string_t cmd_ddp_add_ddp =
 cmdline_parse_token_string_t cmd_ddp_add_add =
 	TOKEN_STRING_INITIALIZER(struct cmd_ddp_add_result, add, "add");
 cmdline_parse_token_num_t cmd_ddp_add_port_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_ddp_add_result, port_id, UINT16);
+	TOKEN_NUM_INITIALIZER(struct cmd_ddp_add_result, port_id,
+		RTE_UINT16);
 cmdline_parse_token_string_t cmd_ddp_add_filepath =
 	TOKEN_STRING_INITIALIZER(struct cmd_ddp_add_result, filepath, NULL);
 
@@ -16512,7 +14255,7 @@ cmd_ddp_add_parsed(
 		return;
 	}
 
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
 	if (ret == -ENOTSUP)
 		ret = rte_pmd_i40e_process_ddp_package(res->port_id,
 					       buff, size,
@@ -16556,7 +14299,7 @@ cmdline_parse_token_string_t cmd_ddp_del_ddp =
 cmdline_parse_token_string_t cmd_ddp_del_del =
 	TOKEN_STRING_INITIALIZER(struct cmd_ddp_del_result, del, "del");
 cmdline_parse_token_num_t cmd_ddp_del_port_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_ddp_del_result, port_id, UINT16);
+	TOKEN_NUM_INITIALIZER(struct cmd_ddp_del_result, port_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_ddp_del_filepath =
 	TOKEN_STRING_INITIALIZER(struct cmd_ddp_del_result, filepath, NULL);
 
@@ -16580,7 +14323,7 @@ cmd_ddp_del_parsed(
 	if (!buff)
 		return;
 
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
 	if (ret == -ENOTSUP)
 		ret = rte_pmd_i40e_process_ddp_package(res->port_id,
 					       buff, size,
@@ -16635,7 +14378,7 @@ cmd_ddp_info_parsed(
 	uint8_t *pkg;
 	uint32_t pkg_size;
 	int ret = -ENOTSUP;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
 	uint32_t i, j, n;
 	uint8_t *buff;
 	uint32_t buff_size = 0;
@@ -16656,7 +14399,7 @@ cmd_ddp_info_parsed(
 	if (!pkg)
 		return;
 
-#ifdef RTE_LIBRTE_I40E_PMD
+#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);
@@ -16863,7 +14606,8 @@ cmdline_parse_token_string_t cmd_ddp_get_list_get =
 cmdline_parse_token_string_t cmd_ddp_get_list_list =
 	TOKEN_STRING_INITIALIZER(struct cmd_ddp_get_list_result, list, "list");
 cmdline_parse_token_num_t cmd_ddp_get_list_port_id =
-	TOKEN_NUM_INITIALIZER(struct cmd_ddp_get_list_result, port_id, UINT16);
+	TOKEN_NUM_INITIALIZER(struct cmd_ddp_get_list_result, port_id,
+		RTE_UINT16);
 
 static void
 cmd_ddp_get_list_parsed(
@@ -16871,7 +14615,7 @@ cmd_ddp_get_list_parsed(
 	__rte_unused struct cmdline *cl,
 	__rte_unused void *data)
 {
-#ifdef RTE_LIBRTE_I40E_PMD
+#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;
@@ -16881,7 +14625,7 @@ cmd_ddp_get_list_parsed(
 #endif
 	int ret = -ENOTSUP;
 
-#ifdef RTE_LIBRTE_I40E_PMD
+#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) {
@@ -16949,7 +14693,7 @@ cmd_cfg_input_set_parsed(
 	__rte_unused struct cmdline *cl,
 	__rte_unused void *data)
 {
-#ifdef RTE_LIBRTE_I40E_PMD
+#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;
@@ -16961,7 +14705,7 @@ cmd_cfg_input_set_parsed(
 		return;
 	}
 
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
 	if (!strcmp(res->inset_type, "hash_inset"))
 		inset_type = INSET_HASH;
 	else if (!strcmp(res->inset_type, "fdir_inset"))
@@ -17014,13 +14758,13 @@ cmdline_parse_token_string_t cmd_cfg_input_set_cfg =
 				 cfg, "config");
 cmdline_parse_token_num_t cmd_cfg_input_set_port_id =
 	TOKEN_NUM_INITIALIZER(struct cmd_cfg_input_set_result,
-			      port_id, UINT16);
+			      port_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_cfg_input_set_pctype =
 	TOKEN_STRING_INITIALIZER(struct cmd_cfg_input_set_result,
 				 pctype, "pctype");
 cmdline_parse_token_num_t cmd_cfg_input_set_pctype_id =
 	TOKEN_NUM_INITIALIZER(struct cmd_cfg_input_set_result,
-			      pctype_id, UINT8);
+			      pctype_id, RTE_UINT8);
 cmdline_parse_token_string_t cmd_cfg_input_set_inset_type =
 	TOKEN_STRING_INITIALIZER(struct cmd_cfg_input_set_result,
 				 inset_type,
@@ -17033,7 +14777,7 @@ cmdline_parse_token_string_t cmd_cfg_input_set_field =
 				 field, "field");
 cmdline_parse_token_num_t cmd_cfg_input_set_field_idx =
 	TOKEN_NUM_INITIALIZER(struct cmd_cfg_input_set_result,
-			      field_idx, UINT8);
+			      field_idx, RTE_UINT8);
 
 cmdline_parse_inst_t cmd_cfg_input_set = {
 	.f = cmd_cfg_input_set_parsed,
@@ -17072,7 +14816,7 @@ cmd_clear_input_set_parsed(
 	__rte_unused struct cmdline *cl,
 	__rte_unused void *data)
 {
-#ifdef RTE_LIBRTE_I40E_PMD
+#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;
@@ -17084,7 +14828,7 @@ cmd_clear_input_set_parsed(
 		return;
 	}
 
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
 	if (!strcmp(res->inset_type, "hash_inset"))
 		inset_type = INSET_HASH;
 	else if (!strcmp(res->inset_type, "fdir_inset"))
@@ -17115,13 +14859,13 @@ cmdline_parse_token_string_t cmd_clear_input_set_cfg =
 				 cfg, "config");
 cmdline_parse_token_num_t cmd_clear_input_set_port_id =
 	TOKEN_NUM_INITIALIZER(struct cmd_clear_input_set_result,
-			      port_id, UINT16);
+			      port_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_clear_input_set_pctype =
 	TOKEN_STRING_INITIALIZER(struct cmd_clear_input_set_result,
 				 pctype, "pctype");
 cmdline_parse_token_num_t cmd_clear_input_set_pctype_id =
 	TOKEN_NUM_INITIALIZER(struct cmd_clear_input_set_result,
-			      pctype_id, UINT8);
+			      pctype_id, RTE_UINT8);
 cmdline_parse_token_string_t cmd_clear_input_set_inset_type =
 	TOKEN_STRING_INITIALIZER(struct cmd_clear_input_set_result,
 				 inset_type,
@@ -17178,11 +14922,11 @@ cmdline_parse_token_string_t cmd_show_vf_stats_stats =
 cmdline_parse_token_num_t cmd_show_vf_stats_port_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_show_vf_stats_result,
-		 port_id, UINT16);
+		 port_id, RTE_UINT16);
 cmdline_parse_token_num_t cmd_show_vf_stats_vf_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_show_vf_stats_result,
-		 vf_id, UINT16);
+		 vf_id, RTE_UINT16);
 
 static void
 cmd_show_vf_stats_parsed(
@@ -17200,13 +14944,13 @@ cmd_show_vf_stats_parsed(
 
 	memset(&stats, 0, sizeof(stats));
 
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
 	if (ret == -ENOTSUP)
 		ret = rte_pmd_i40e_get_vf_stats(res->port_id,
 						res->vf_id,
 						&stats);
 #endif
-#ifdef RTE_LIBRTE_BNXT_PMD
+#ifdef RTE_NET_BNXT
 	if (ret == -ENOTSUP)
 		ret = rte_pmd_bnxt_get_vf_stats(res->port_id,
 						res->vf_id,
@@ -17287,11 +15031,11 @@ cmdline_parse_token_string_t cmd_clear_vf_stats_stats =
 cmdline_parse_token_num_t cmd_clear_vf_stats_port_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_clear_vf_stats_result,
-		 port_id, UINT16);
+		 port_id, RTE_UINT16);
 cmdline_parse_token_num_t cmd_clear_vf_stats_vf_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_clear_vf_stats_result,
-		 vf_id, UINT16);
+		 vf_id, RTE_UINT16);
 
 static void
 cmd_clear_vf_stats_parsed(
@@ -17305,12 +15049,12 @@ cmd_clear_vf_stats_parsed(
 	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
 		return;
 
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
 	if (ret == -ENOTSUP)
 		ret = rte_pmd_i40e_reset_vf_stats(res->port_id,
 						  res->vf_id);
 #endif
-#ifdef RTE_LIBRTE_BNXT_PMD
+#ifdef RTE_NET_BNXT
 	if (ret == -ENOTSUP)
 		ret = rte_pmd_bnxt_reset_vf_stats(res->port_id,
 						  res->vf_id);
@@ -17371,7 +15115,7 @@ cmdline_parse_token_string_t cmd_pctype_mapping_reset_config =
 cmdline_parse_token_num_t cmd_pctype_mapping_reset_port_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_pctype_mapping_reset_result,
-		 port_id, UINT16);
+		 port_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_pctype_mapping_reset_pctype =
 	TOKEN_STRING_INITIALIZER
 		(struct cmd_pctype_mapping_reset_result,
@@ -17397,7 +15141,7 @@ cmd_pctype_mapping_reset_parsed(
 	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
 		return;
 
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
 	ret = rte_pmd_i40e_flow_type_mapping_reset(res->port_id);
 #endif
 
@@ -17453,7 +15197,7 @@ cmdline_parse_token_string_t cmd_pctype_mapping_get_port =
 cmdline_parse_token_num_t cmd_pctype_mapping_get_port_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_pctype_mapping_get_result,
-		 port_id, UINT16);
+		 port_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_pctype_mapping_get_pctype =
 	TOKEN_STRING_INITIALIZER
 		(struct cmd_pctype_mapping_get_result,
@@ -17471,7 +15215,7 @@ cmd_pctype_mapping_get_parsed(
 {
 	struct cmd_pctype_mapping_get_result *res = parsed_result;
 	int ret = -ENOTSUP;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
 	struct rte_pmd_i40e_flow_type_mapping
 				mapping[RTE_PMD_I40E_FLOW_TYPE_MAX];
 	int i, j, first_pctype;
@@ -17480,7 +15224,7 @@ cmd_pctype_mapping_get_parsed(
 	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
 		return;
 
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
 	ret = rte_pmd_i40e_flow_type_mapping_get(res->port_id, mapping);
 #endif
 
@@ -17498,7 +15242,7 @@ cmd_pctype_mapping_get_parsed(
 		return;
 	}
 
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
 	for (i = 0; i < RTE_PMD_I40E_FLOW_TYPE_MAX; i++) {
 		if (mapping[i].pctype != 0ULL) {
 			first_pctype = 1;
@@ -17557,7 +15301,7 @@ cmdline_parse_token_string_t cmd_pctype_mapping_update_config =
 cmdline_parse_token_num_t cmd_pctype_mapping_update_port_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_pctype_mapping_update_result,
-		 port_id, UINT16);
+		 port_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_pctype_mapping_update_pctype =
 	TOKEN_STRING_INITIALIZER
 		(struct cmd_pctype_mapping_update_result,
@@ -17577,7 +15321,7 @@ cmdline_parse_token_string_t cmd_pctype_mapping_update_pc_type =
 cmdline_parse_token_num_t cmd_pctype_mapping_update_flow_type =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_pctype_mapping_update_result,
-		 flow_type, UINT16);
+		 flow_type, RTE_UINT16);
 
 static void
 cmd_pctype_mapping_update_parsed(
@@ -17587,7 +15331,7 @@ cmd_pctype_mapping_update_parsed(
 {
 	struct cmd_pctype_mapping_update_result *res = parsed_result;
 	int ret = -ENOTSUP;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
 	struct rte_pmd_i40e_flow_type_mapping mapping;
 	unsigned int i;
 	unsigned int nb_item;
@@ -17597,7 +15341,7 @@ cmd_pctype_mapping_update_parsed(
 	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
 		return;
 
-#ifdef RTE_LIBRTE_I40E_PMD
+#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;
@@ -17671,11 +15415,11 @@ cmdline_parse_token_string_t cmd_ptype_mapping_get_get =
 cmdline_parse_token_num_t cmd_ptype_mapping_get_port_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_ptype_mapping_get_result,
-		 port_id, UINT16);
+		 port_id, RTE_UINT16);
 cmdline_parse_token_num_t cmd_ptype_mapping_get_valid_only =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_ptype_mapping_get_result,
-		 valid_only, UINT8);
+		 valid_only, RTE_UINT8);
 
 static void
 cmd_ptype_mapping_get_parsed(
@@ -17685,7 +15429,7 @@ cmd_ptype_mapping_get_parsed(
 {
 	struct cmd_ptype_mapping_get_result *res = parsed_result;
 	int ret = -ENOTSUP;
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
 	int max_ptype_num = 256;
 	struct rte_pmd_i40e_ptype_mapping mapping[max_ptype_num];
 	uint16_t count;
@@ -17695,7 +15439,7 @@ cmd_ptype_mapping_get_parsed(
 	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
 		return;
 
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
 	ret = rte_pmd_i40e_ptype_mapping_get(res->port_id,
 					mapping,
 					max_ptype_num,
@@ -17716,7 +15460,7 @@ cmd_ptype_mapping_get_parsed(
 		printf("programming error: (%s)\n", strerror(-ret));
 	}
 
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
 	if (!ret) {
 		for (i = 0; i < count; i++)
 			printf("%3d\t0x%08x\n",
@@ -17768,19 +15512,19 @@ cmdline_parse_token_string_t cmd_ptype_mapping_replace_replace =
 cmdline_parse_token_num_t cmd_ptype_mapping_replace_port_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_ptype_mapping_replace_result,
-		 port_id, UINT16);
+		 port_id, RTE_UINT16);
 cmdline_parse_token_num_t cmd_ptype_mapping_replace_target =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_ptype_mapping_replace_result,
-		 target, UINT32);
+		 target, RTE_UINT32);
 cmdline_parse_token_num_t cmd_ptype_mapping_replace_mask =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_ptype_mapping_replace_result,
-		 mask, UINT8);
+		 mask, RTE_UINT8);
 cmdline_parse_token_num_t cmd_ptype_mapping_replace_pkt_type =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_ptype_mapping_replace_result,
-		 pkt_type, UINT32);
+		 pkt_type, RTE_UINT32);
 
 static void
 cmd_ptype_mapping_replace_parsed(
@@ -17794,7 +15538,7 @@ cmd_ptype_mapping_replace_parsed(
 	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
 		return;
 
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
 	ret = rte_pmd_i40e_ptype_mapping_replace(res->port_id,
 					res->target,
 					res->mask,
@@ -17862,7 +15606,7 @@ cmdline_parse_token_string_t cmd_ptype_mapping_reset_reset =
 cmdline_parse_token_num_t cmd_ptype_mapping_reset_port_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_ptype_mapping_reset_result,
-		 port_id, UINT16);
+		 port_id, RTE_UINT16);
 
 static void
 cmd_ptype_mapping_reset_parsed(
@@ -17876,7 +15620,7 @@ cmd_ptype_mapping_reset_parsed(
 	if (port_id_is_invalid(res->port_id, ENABLED_WARN))
 		return;
 
-#ifdef RTE_LIBRTE_I40E_PMD
+#ifdef RTE_NET_I40E
 	ret = rte_pmd_i40e_ptype_mapping_reset(res->port_id);
 #endif
 
@@ -17935,15 +15679,15 @@ cmdline_parse_token_string_t cmd_ptype_mapping_update_update =
 cmdline_parse_token_num_t cmd_ptype_mapping_update_port_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_ptype_mapping_update_result,
-		 port_id, UINT16);
+		 port_id, RTE_UINT16);
 cmdline_parse_token_num_t cmd_ptype_mapping_update_hw_ptype =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_ptype_mapping_update_result,
-		 hw_ptype, UINT8);
+		 hw_ptype, RTE_UINT8);
 cmdline_parse_token_num_t cmd_ptype_mapping_update_sw_ptype =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_ptype_mapping_update_result,
-		 sw_ptype, UINT32);
+		 sw_ptype, RTE_UINT32);
 
 static void
 cmd_ptype_mapping_update_parsed(
@@ -17953,13 +15697,13 @@ cmd_ptype_mapping_update_parsed(
 {
 	struct cmd_ptype_mapping_update_result *res = parsed_result;
 	int ret = -ENOTSUP;
-#ifdef RTE_LIBRTE_I40E_PMD
+#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_LIBRTE_I40E_PMD
+#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,
@@ -18054,7 +15798,7 @@ cmdline_parse_token_string_t cmd_rx_offload_get_capa_port =
 cmdline_parse_token_num_t cmd_rx_offload_get_capa_port_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_rx_offload_get_capa_result,
-		 port_id, UINT16);
+		 port_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_rx_offload_get_capa_rx_offload =
 	TOKEN_STRING_INITIALIZER
 		(struct cmd_rx_offload_get_capa_result,
@@ -18151,7 +15895,7 @@ cmdline_parse_token_string_t cmd_rx_offload_get_configuration_port =
 cmdline_parse_token_num_t cmd_rx_offload_get_configuration_port_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_rx_offload_get_configuration_result,
-		 port_id, UINT16);
+		 port_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_rx_offload_get_configuration_rx_offload =
 	TOKEN_STRING_INITIALIZER
 		(struct cmd_rx_offload_get_configuration_result,
@@ -18233,7 +15977,7 @@ cmdline_parse_token_string_t cmd_config_per_port_rx_offload_result_config =
 cmdline_parse_token_num_t cmd_config_per_port_rx_offload_result_port_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_config_per_port_rx_offload_result,
-		 port_id, UINT16);
+		 port_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_config_per_port_rx_offload_result_rx_offload =
 	TOKEN_STRING_INITIALIZER
 		(struct cmd_config_per_port_rx_offload_result,
@@ -18244,7 +15988,8 @@ cmdline_parse_token_string_t cmd_config_per_port_rx_offload_result_offload =
 		 offload, "vlan_strip#ipv4_cksum#udp_cksum#tcp_cksum#tcp_lro#"
 			   "qinq_strip#outer_ipv4_cksum#macsec_strip#"
 			   "header_split#vlan_filter#vlan_extend#jumbo_frame#"
-			   "scatter#timestamp#security#keep_crc#rss_hash");
+			   "scatter#buffer_split#timestamp#security#"
+			   "keep_crc#rss_hash");
 cmdline_parse_token_string_t cmd_config_per_port_rx_offload_result_on_off =
 	TOKEN_STRING_INITIALIZER
 		(struct cmd_config_per_port_rx_offload_result,
@@ -18324,8 +16069,8 @@ cmdline_parse_inst_t cmd_config_per_port_rx_offload = {
 	.help_str = "port config <port_id> rx_offload vlan_strip|ipv4_cksum|"
 		    "udp_cksum|tcp_cksum|tcp_lro|qinq_strip|outer_ipv4_cksum|"
 		    "macsec_strip|header_split|vlan_filter|vlan_extend|"
-		    "jumbo_frame|scatter|timestamp|security|keep_crc|rss_hash "
-		    "on|off",
+		    "jumbo_frame|scatter|buffer_split|timestamp|security|"
+		    "keep_crc|rss_hash on|off",
 	.tokens = {
 		(void *)&cmd_config_per_port_rx_offload_result_port,
 		(void *)&cmd_config_per_port_rx_offload_result_config,
@@ -18355,7 +16100,7 @@ cmdline_parse_token_string_t cmd_config_per_queue_rx_offload_result_port =
 cmdline_parse_token_num_t cmd_config_per_queue_rx_offload_result_port_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_config_per_queue_rx_offload_result,
-		 port_id, UINT16);
+		 port_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_config_per_queue_rx_offload_result_rxq =
 	TOKEN_STRING_INITIALIZER
 		(struct cmd_config_per_queue_rx_offload_result,
@@ -18363,7 +16108,7 @@ cmdline_parse_token_string_t cmd_config_per_queue_rx_offload_result_rxq =
 cmdline_parse_token_num_t cmd_config_per_queue_rx_offload_result_queue_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_config_per_queue_rx_offload_result,
-		 queue_id, UINT16);
+		 queue_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_config_per_queue_rx_offload_result_rxoffload =
 	TOKEN_STRING_INITIALIZER
 		(struct cmd_config_per_queue_rx_offload_result,
@@ -18374,7 +16119,7 @@ cmdline_parse_token_string_t cmd_config_per_queue_rx_offload_result_offload =
 		 offload, "vlan_strip#ipv4_cksum#udp_cksum#tcp_cksum#tcp_lro#"
 			   "qinq_strip#outer_ipv4_cksum#macsec_strip#"
 			   "header_split#vlan_filter#vlan_extend#jumbo_frame#"
-			   "scatter#timestamp#security#keep_crc");
+			   "scatter#buffer_split#timestamp#security#keep_crc");
 cmdline_parse_token_string_t cmd_config_per_queue_rx_offload_result_on_off =
 	TOKEN_STRING_INITIALIZER
 		(struct cmd_config_per_queue_rx_offload_result,
@@ -18430,8 +16175,8 @@ cmdline_parse_inst_t cmd_config_per_queue_rx_offload = {
 		    "vlan_strip|ipv4_cksum|"
 		    "udp_cksum|tcp_cksum|tcp_lro|qinq_strip|outer_ipv4_cksum|"
 		    "macsec_strip|header_split|vlan_filter|vlan_extend|"
-		    "jumbo_frame|scatter|timestamp|security|keep_crc "
-		    "on|off",
+		    "jumbo_frame|scatter|buffer_split|timestamp|security|"
+		    "keep_crc on|off",
 	.tokens = {
 		(void *)&cmd_config_per_queue_rx_offload_result_port,
 		(void *)&cmd_config_per_queue_rx_offload_result_port_id,
@@ -18464,7 +16209,7 @@ cmdline_parse_token_string_t cmd_tx_offload_get_capa_port =
 cmdline_parse_token_num_t cmd_tx_offload_get_capa_port_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_tx_offload_get_capa_result,
-		 port_id, UINT16);
+		 port_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_tx_offload_get_capa_tx_offload =
 	TOKEN_STRING_INITIALIZER
 		(struct cmd_tx_offload_get_capa_result,
@@ -18561,7 +16306,7 @@ cmdline_parse_token_string_t cmd_tx_offload_get_configuration_port =
 cmdline_parse_token_num_t cmd_tx_offload_get_configuration_port_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_tx_offload_get_configuration_result,
-		 port_id, UINT16);
+		 port_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_tx_offload_get_configuration_tx_offload =
 	TOKEN_STRING_INITIALIZER
 		(struct cmd_tx_offload_get_configuration_result,
@@ -18643,7 +16388,7 @@ cmdline_parse_token_string_t cmd_config_per_port_tx_offload_result_config =
 cmdline_parse_token_num_t cmd_config_per_port_tx_offload_result_port_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_config_per_port_tx_offload_result,
-		 port_id, UINT16);
+		 port_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_config_per_port_tx_offload_result_tx_offload =
 	TOKEN_STRING_INITIALIZER
 		(struct cmd_config_per_port_tx_offload_result,
@@ -18772,7 +16517,7 @@ cmdline_parse_token_string_t cmd_config_per_queue_tx_offload_result_port =
 cmdline_parse_token_num_t cmd_config_per_queue_tx_offload_result_port_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_config_per_queue_tx_offload_result,
-		 port_id, UINT16);
+		 port_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_config_per_queue_tx_offload_result_txq =
 	TOKEN_STRING_INITIALIZER
 		(struct cmd_config_per_queue_tx_offload_result,
@@ -18780,7 +16525,7 @@ cmdline_parse_token_string_t cmd_config_per_queue_tx_offload_result_txq =
 cmdline_parse_token_num_t cmd_config_per_queue_tx_offload_result_queue_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_config_per_queue_tx_offload_result,
-		 queue_id, UINT16);
+		 queue_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_config_per_queue_tx_offload_result_txoffload =
 	TOKEN_STRING_INITIALIZER
 		(struct cmd_config_per_queue_tx_offload_result,
@@ -18898,13 +16643,13 @@ cmdline_parse_token_string_t cmd_config_tx_metadata_specific_keyword =
 			keyword, "config");
 cmdline_parse_token_num_t cmd_config_tx_metadata_specific_id =
 	TOKEN_NUM_INITIALIZER(struct cmd_config_tx_metadata_specific_result,
-			port_id, UINT16);
+			port_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_config_tx_metadata_specific_item =
 	TOKEN_STRING_INITIALIZER(struct cmd_config_tx_metadata_specific_result,
 			item, "tx_metadata");
 cmdline_parse_token_num_t cmd_config_tx_metadata_specific_value =
 	TOKEN_NUM_INITIALIZER(struct cmd_config_tx_metadata_specific_result,
-			value, UINT32);
+			value, RTE_UINT32);
 
 cmdline_parse_inst_t cmd_config_tx_metadata_specific = {
 	.f = cmd_config_tx_metadata_specific_parsed,
@@ -18977,7 +16722,7 @@ cmdline_parse_token_string_t cmd_config_tx_dynf_specific_keyword =
 			keyword, "config");
 cmdline_parse_token_num_t cmd_config_tx_dynf_specific_port_id =
 	TOKEN_NUM_INITIALIZER(struct cmd_config_tx_dynf_specific_result,
-			port_id, UINT16);
+			port_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_config_tx_dynf_specific_item =
 	TOKEN_STRING_INITIALIZER(struct cmd_config_tx_dynf_specific_result,
 			item, "dynf");
@@ -19036,7 +16781,7 @@ cmdline_parse_token_string_t cmd_show_tx_metadata_port =
 			cmd_port, "port");
 cmdline_parse_token_num_t cmd_show_tx_metadata_pid =
 	TOKEN_NUM_INITIALIZER(struct cmd_show_tx_metadata_result,
-			cmd_pid, UINT16);
+			cmd_pid, RTE_UINT16);
 cmdline_parse_token_string_t cmd_show_tx_metadata_keyword =
 	TOKEN_STRING_INITIALIZER(struct cmd_show_tx_metadata_result,
 			cmd_keyword, "tx_metadata");
@@ -19054,6 +16799,238 @@ cmdline_parse_inst_t cmd_show_tx_metadata = {
 	},
 };
 
+/* *** show fec capability per port configuration *** */
+struct cmd_show_fec_capability_result {
+	cmdline_fixed_string_t cmd_show;
+	cmdline_fixed_string_t cmd_port;
+	cmdline_fixed_string_t cmd_fec;
+	cmdline_fixed_string_t cmd_keyword;
+	portid_t cmd_pid;
+};
+
+static void
+cmd_show_fec_capability_parsed(void *parsed_result,
+		__rte_unused struct cmdline *cl,
+		__rte_unused void *data)
+{
+	struct cmd_show_fec_capability_result *res = parsed_result;
+	struct rte_eth_fec_capa *speed_fec_capa;
+	unsigned int num;
+	int ret;
+
+	if (!rte_eth_dev_is_valid_port(res->cmd_pid)) {
+		printf("Invalid port id %u\n", res->cmd_pid);
+		return;
+	}
+
+	ret = rte_eth_fec_get_capability(res->cmd_pid, NULL, 0);
+	if (ret == -ENOTSUP) {
+		printf("Function not implemented\n");
+		return;
+	} else if (ret < 0) {
+		printf("Get FEC capability failed: %d\n", ret);
+		return;
+	}
+
+	num = (unsigned int)ret;
+	speed_fec_capa = calloc(num, sizeof(*speed_fec_capa));
+	if (speed_fec_capa == NULL) {
+		printf("Failed to alloc FEC capability buffer\n");
+		return;
+	}
+
+	ret = rte_eth_fec_get_capability(res->cmd_pid, speed_fec_capa, num);
+	if (ret < 0) {
+		printf("Error getting FEC capability: %d\n", ret);
+		goto out;
+	}
+
+	show_fec_capability(num, speed_fec_capa);
+out:
+	free(speed_fec_capa);
+}
+
+cmdline_parse_token_string_t cmd_show_fec_capability_show =
+	TOKEN_STRING_INITIALIZER(struct cmd_show_fec_capability_result,
+			cmd_show, "show");
+cmdline_parse_token_string_t cmd_show_fec_capability_port =
+	TOKEN_STRING_INITIALIZER(struct cmd_show_fec_capability_result,
+			cmd_port, "port");
+cmdline_parse_token_num_t cmd_show_fec_capability_pid =
+	TOKEN_NUM_INITIALIZER(struct cmd_show_fec_capability_result,
+			cmd_pid, RTE_UINT16);
+cmdline_parse_token_string_t cmd_show_fec_capability_fec =
+	TOKEN_STRING_INITIALIZER(struct cmd_show_fec_capability_result,
+			cmd_fec, "fec");
+cmdline_parse_token_string_t cmd_show_fec_capability_keyword =
+	TOKEN_STRING_INITIALIZER(struct cmd_show_fec_capability_result,
+			cmd_keyword, "capabilities");
+
+cmdline_parse_inst_t cmd_show_capability = {
+	.f = cmd_show_fec_capability_parsed,
+	.data = NULL,
+	.help_str = "show port <port_id> fec capabilities",
+	.tokens = {
+		(void *)&cmd_show_fec_capability_show,
+		(void *)&cmd_show_fec_capability_port,
+		(void *)&cmd_show_fec_capability_pid,
+		(void *)&cmd_show_fec_capability_fec,
+		(void *)&cmd_show_fec_capability_keyword,
+		NULL,
+	},
+};
+
+/* *** show fec mode per port configuration *** */
+struct cmd_show_fec_metadata_result {
+	cmdline_fixed_string_t cmd_show;
+	cmdline_fixed_string_t cmd_port;
+	cmdline_fixed_string_t cmd_keyword;
+	portid_t cmd_pid;
+};
+
+static void
+cmd_show_fec_mode_parsed(void *parsed_result,
+		__rte_unused struct cmdline *cl,
+		__rte_unused void *data)
+{
+#define FEC_NAME_SIZE 16
+	struct cmd_show_fec_metadata_result *res = parsed_result;
+	uint32_t mode;
+	char buf[FEC_NAME_SIZE];
+	int ret;
+
+	if (!rte_eth_dev_is_valid_port(res->cmd_pid)) {
+		printf("Invalid port id %u\n", res->cmd_pid);
+		return;
+	}
+	ret = rte_eth_fec_get(res->cmd_pid, &mode);
+	if (ret == -ENOTSUP) {
+		printf("Function not implemented\n");
+		return;
+	} else if (ret < 0) {
+		printf("Get FEC mode failed\n");
+		return;
+	}
+
+	switch (mode) {
+	case RTE_ETH_FEC_MODE_CAPA_MASK(NOFEC):
+		strlcpy(buf, "off", sizeof(buf));
+		break;
+	case RTE_ETH_FEC_MODE_CAPA_MASK(AUTO):
+		strlcpy(buf, "auto", sizeof(buf));
+		break;
+	case RTE_ETH_FEC_MODE_CAPA_MASK(BASER):
+		strlcpy(buf, "baser", sizeof(buf));
+		break;
+	case RTE_ETH_FEC_MODE_CAPA_MASK(RS):
+		strlcpy(buf, "rs", sizeof(buf));
+		break;
+	default:
+		return;
+	}
+
+	printf("%s\n", buf);
+}
+
+cmdline_parse_token_string_t cmd_show_fec_mode_show =
+	TOKEN_STRING_INITIALIZER(struct cmd_show_fec_metadata_result,
+			cmd_show, "show");
+cmdline_parse_token_string_t cmd_show_fec_mode_port =
+	TOKEN_STRING_INITIALIZER(struct cmd_show_fec_metadata_result,
+			cmd_port, "port");
+cmdline_parse_token_num_t cmd_show_fec_mode_pid =
+	TOKEN_NUM_INITIALIZER(struct cmd_show_fec_metadata_result,
+			cmd_pid, RTE_UINT16);
+cmdline_parse_token_string_t cmd_show_fec_mode_keyword =
+	TOKEN_STRING_INITIALIZER(struct cmd_show_fec_metadata_result,
+			cmd_keyword, "fec_mode");
+
+cmdline_parse_inst_t cmd_show_fec_mode = {
+	.f = cmd_show_fec_mode_parsed,
+	.data = NULL,
+	.help_str = "show port <port_id> fec_mode",
+	.tokens = {
+		(void *)&cmd_show_fec_mode_show,
+		(void *)&cmd_show_fec_mode_port,
+		(void *)&cmd_show_fec_mode_pid,
+		(void *)&cmd_show_fec_mode_keyword,
+		NULL,
+	},
+};
+
+/* *** set fec mode per port configuration *** */
+struct cmd_set_port_fec_mode {
+	cmdline_fixed_string_t set;
+	cmdline_fixed_string_t port;
+	portid_t port_id;
+	cmdline_fixed_string_t fec_mode;
+	cmdline_fixed_string_t fec_value;
+};
+
+/* Common CLI fields for set fec mode */
+cmdline_parse_token_string_t cmd_set_port_fec_mode_set =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_set_port_fec_mode,
+		 set, "set");
+cmdline_parse_token_string_t cmd_set_port_fec_mode_port =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_set_port_fec_mode,
+		 port, "port");
+cmdline_parse_token_num_t cmd_set_port_fec_mode_port_id =
+	TOKEN_NUM_INITIALIZER
+		(struct cmd_set_port_fec_mode,
+		 port_id, RTE_UINT16);
+cmdline_parse_token_string_t cmd_set_port_fec_mode_str =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_set_port_fec_mode,
+		 fec_mode, "fec_mode");
+cmdline_parse_token_string_t cmd_set_port_fec_mode_value =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_set_port_fec_mode,
+		 fec_value, NULL);
+
+static void
+cmd_set_port_fec_mode_parsed(
+	void *parsed_result,
+	__rte_unused struct cmdline *cl,
+	__rte_unused void *data)
+{
+	struct cmd_set_port_fec_mode *res = parsed_result;
+	uint16_t port_id = res->port_id;
+	uint32_t mode;
+	int ret;
+
+	ret = parse_fec_mode(res->fec_value, &mode);
+	if (ret < 0) {
+		printf("Unknown fec mode: %s for Port %d\n", res->fec_value,
+			port_id);
+		return;
+	}
+
+	ret = rte_eth_fec_set(port_id, mode);
+	if (ret == -ENOTSUP) {
+		printf("Function not implemented\n");
+		return;
+	} else if (ret < 0) {
+		printf("Set FEC mode failed\n");
+		return;
+	}
+}
+
+cmdline_parse_inst_t cmd_set_fec_mode = {
+	.f = cmd_set_port_fec_mode_parsed,
+	.data = NULL,
+	.help_str = "set port <port_id> fec_mode auto|off|rs|baser",
+	.tokens = {
+		(void *)&cmd_set_port_fec_mode_set,
+		(void *)&cmd_set_port_fec_mode_port,
+		(void *)&cmd_set_port_fec_mode_port_id,
+		(void *)&cmd_set_port_fec_mode_str,
+		(void *)&cmd_set_port_fec_mode_value,
+		NULL,
+	},
+};
+
 /* show port supported ptypes */
 
 /* Common result structure for show port ptypes */
@@ -19076,7 +17053,7 @@ cmdline_parse_token_string_t cmd_show_port_supported_ptypes_port =
 cmdline_parse_token_num_t cmd_show_port_supported_ptypes_port_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_show_port_supported_ptypes_result,
-		 port_id, UINT16);
+		 port_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_show_port_supported_ptypes_ptypes =
 	TOKEN_STRING_INITIALIZER
 		(struct cmd_show_port_supported_ptypes_result,
@@ -19191,7 +17168,8 @@ cmd_show_rx_tx_desc_status_parsed(void *parsed_result,
 		rc = rte_eth_rx_descriptor_status(res->cmd_pid, res->cmd_qid,
 					     res->cmd_did);
 		if (rc < 0) {
-			printf("Invalid queueid = %d\n", res->cmd_qid);
+			printf("Invalid input: queue id = %d, desc id = %d\n",
+			       res->cmd_qid, res->cmd_did);
 			return;
 		}
 		if (rc == RTE_ETH_RX_DESC_AVAIL)
@@ -19204,7 +17182,8 @@ cmd_show_rx_tx_desc_status_parsed(void *parsed_result,
 		rc = rte_eth_tx_descriptor_status(res->cmd_pid, res->cmd_qid,
 					     res->cmd_did);
 		if (rc < 0) {
-			printf("Invalid queueid = %d\n", res->cmd_qid);
+			printf("Invalid input: queue id = %d, desc id = %d\n",
+			       res->cmd_qid, res->cmd_did);
 			return;
 		}
 		if (rc == RTE_ETH_TX_DESC_FULL)
@@ -19224,19 +17203,19 @@ cmdline_parse_token_string_t cmd_show_rx_tx_desc_status_port =
 			cmd_port, "port");
 cmdline_parse_token_num_t cmd_show_rx_tx_desc_status_pid =
 	TOKEN_NUM_INITIALIZER(struct cmd_show_rx_tx_desc_status_result,
-			cmd_pid, UINT16);
+			cmd_pid, RTE_UINT16);
 cmdline_parse_token_string_t cmd_show_rx_tx_desc_status_keyword =
 	TOKEN_STRING_INITIALIZER(struct cmd_show_rx_tx_desc_status_result,
 			cmd_keyword, "rxq#txq");
 cmdline_parse_token_num_t cmd_show_rx_tx_desc_status_qid =
 	TOKEN_NUM_INITIALIZER(struct cmd_show_rx_tx_desc_status_result,
-			cmd_qid, UINT16);
+			cmd_qid, RTE_UINT16);
 cmdline_parse_token_string_t cmd_show_rx_tx_desc_status_desc =
 	TOKEN_STRING_INITIALIZER(struct cmd_show_rx_tx_desc_status_result,
 			cmd_desc, "desc");
 cmdline_parse_token_num_t cmd_show_rx_tx_desc_status_did =
 	TOKEN_NUM_INITIALIZER(struct cmd_show_rx_tx_desc_status_result,
-			cmd_did, UINT16);
+			cmd_did, RTE_UINT16);
 cmdline_parse_token_string_t cmd_show_rx_tx_desc_status_status =
 	TOKEN_STRING_INITIALIZER(struct cmd_show_rx_tx_desc_status_result,
 			cmd_status, "status");
@@ -19258,6 +17237,88 @@ cmdline_parse_inst_t cmd_show_rx_tx_desc_status = {
 	},
 };
 
+/* *** display rx queue desc used count *** */
+struct cmd_show_rx_queue_desc_used_count_result {
+	cmdline_fixed_string_t cmd_show;
+	cmdline_fixed_string_t cmd_port;
+	cmdline_fixed_string_t cmd_rxq;
+	cmdline_fixed_string_t cmd_desc;
+	cmdline_fixed_string_t cmd_used;
+	cmdline_fixed_string_t cmd_count;
+	portid_t cmd_pid;
+	portid_t cmd_qid;
+};
+
+static void
+cmd_show_rx_queue_desc_used_count_parsed(void *parsed_result,
+		__rte_unused struct cmdline *cl,
+		__rte_unused void *data)
+{
+	struct cmd_show_rx_queue_desc_used_count_result *res = parsed_result;
+	int rc;
+
+	if (!rte_eth_dev_is_valid_port(res->cmd_pid)) {
+		printf("invalid port id %u\n", res->cmd_pid);
+		return;
+	}
+
+	rc = rte_eth_rx_queue_count(res->cmd_pid, res->cmd_qid);
+	if (rc < 0) {
+		printf("Invalid queueid = %d\n", res->cmd_qid);
+		return;
+	}
+	printf("Used desc count = %d\n", rc);
+}
+
+cmdline_parse_token_string_t cmd_show_rx_queue_desc_used_count_show =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_show_rx_queue_desc_used_count_result,
+		 cmd_show, "show");
+cmdline_parse_token_string_t cmd_show_rx_queue_desc_used_count_port =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_show_rx_queue_desc_used_count_result,
+		 cmd_port, "port");
+cmdline_parse_token_num_t cmd_show_rx_queue_desc_used_count_pid =
+	TOKEN_NUM_INITIALIZER
+		(struct cmd_show_rx_queue_desc_used_count_result,
+		 cmd_pid, RTE_UINT16);
+cmdline_parse_token_string_t cmd_show_rx_queue_desc_used_count_rxq =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_show_rx_queue_desc_used_count_result,
+		 cmd_rxq, "rxq");
+cmdline_parse_token_num_t cmd_show_rx_queue_desc_used_count_qid =
+	TOKEN_NUM_INITIALIZER
+		(struct cmd_show_rx_queue_desc_used_count_result,
+		 cmd_qid, RTE_UINT16);
+cmdline_parse_token_string_t cmd_show_rx_queue_desc_used_count_desc =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_show_rx_queue_desc_used_count_result,
+		 cmd_count, "desc");
+cmdline_parse_token_string_t cmd_show_rx_queue_desc_used_count_used =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_show_rx_queue_desc_used_count_result,
+		 cmd_count, "used");
+cmdline_parse_token_string_t cmd_show_rx_queue_desc_used_count_count =
+	TOKEN_STRING_INITIALIZER
+		(struct cmd_show_rx_queue_desc_used_count_result,
+		 cmd_count, "count");
+cmdline_parse_inst_t cmd_show_rx_queue_desc_used_count = {
+	.f = cmd_show_rx_queue_desc_used_count_parsed,
+	.data = NULL,
+	.help_str = "show port <port_id> rxq <queue_id> desc used count",
+	.tokens = {
+		(void *)&cmd_show_rx_queue_desc_used_count_show,
+		(void *)&cmd_show_rx_queue_desc_used_count_port,
+		(void *)&cmd_show_rx_queue_desc_used_count_pid,
+		(void *)&cmd_show_rx_queue_desc_used_count_rxq,
+		(void *)&cmd_show_rx_queue_desc_used_count_qid,
+		(void *)&cmd_show_rx_queue_desc_used_count_desc,
+		(void *)&cmd_show_rx_queue_desc_used_count_used,
+		(void *)&cmd_show_rx_queue_desc_used_count_count,
+		NULL,
+	},
+};
+
 /* Common result structure for set port ptypes */
 struct cmd_set_port_ptypes_result {
 	cmdline_fixed_string_t set;
@@ -19279,7 +17340,7 @@ cmdline_parse_token_string_t cmd_set_port_ptypes_port =
 cmdline_parse_token_num_t cmd_set_port_ptypes_port_id =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_set_port_ptypes_result,
-		 port_id, UINT16);
+		 port_id, RTE_UINT16);
 cmdline_parse_token_string_t cmd_set_port_ptypes_mask_str =
 	TOKEN_STRING_INITIALIZER
 		(struct cmd_set_port_ptypes_result,
@@ -19287,7 +17348,7 @@ cmdline_parse_token_string_t cmd_set_port_ptypes_mask_str =
 cmdline_parse_token_num_t cmd_set_port_ptypes_mask_u32 =
 	TOKEN_NUM_INITIALIZER
 		(struct cmd_set_port_ptypes_result,
-		 mask, UINT32);
+		 mask, RTE_UINT32);
 
 static void
 cmd_set_port_ptypes_parsed(
@@ -19372,7 +17433,7 @@ cmdline_parse_token_string_t cmd_showport_macs_port =
 			cmd_port, "port");
 cmdline_parse_token_num_t cmd_showport_macs_pid =
 	TOKEN_NUM_INITIALIZER(struct cmd_showport_macs_result,
-			cmd_pid, UINT16);
+			cmd_pid, RTE_UINT16);
 cmdline_parse_token_string_t cmd_showport_macs_keyword =
 	TOKEN_STRING_INITIALIZER(struct cmd_showport_macs_result,
 			cmd_keyword, "macs#mcast_macs");
@@ -19400,6 +17461,7 @@ cmdline_parse_ctx_t main_ctx[] = {
 	(cmdline_parse_inst_t *)&cmd_load_from_file,
 	(cmdline_parse_inst_t *)&cmd_showport,
 	(cmdline_parse_inst_t *)&cmd_showqueue,
+	(cmdline_parse_inst_t *)&cmd_showeeprom,
 	(cmdline_parse_inst_t *)&cmd_showportall,
 	(cmdline_parse_inst_t *)&cmd_showdevice,
 	(cmdline_parse_inst_t *)&cmd_showcfg,
@@ -19412,6 +17474,8 @@ cmdline_parse_ctx_t main_ctx[] = {
 	(cmdline_parse_inst_t *)&cmd_reset,
 	(cmdline_parse_inst_t *)&cmd_set_numbers,
 	(cmdline_parse_inst_t *)&cmd_set_log,
+	(cmdline_parse_inst_t *)&cmd_set_rxoffs,
+	(cmdline_parse_inst_t *)&cmd_set_rxpkts,
 	(cmdline_parse_inst_t *)&cmd_set_txpkts,
 	(cmdline_parse_inst_t *)&cmd_set_txsplit,
 	(cmdline_parse_inst_t *)&cmd_set_txtimes,
@@ -19430,7 +17494,7 @@ cmdline_parse_ctx_t main_ctx[] = {
 	(cmdline_parse_inst_t *)&cmd_set_bypass_event,
 	(cmdline_parse_inst_t *)&cmd_set_bypass_timeout,
 	(cmdline_parse_inst_t *)&cmd_show_bypass_config,
-#ifdef RTE_LIBRTE_PMD_BOND
+#ifdef RTE_NET_BOND
 	(cmdline_parse_inst_t *) &cmd_set_bonding_mode,
 	(cmdline_parse_inst_t *) &cmd_show_bonding_config,
 	(cmdline_parse_inst_t *) &cmd_set_bonding_primary,
@@ -19473,6 +17537,7 @@ cmdline_parse_ctx_t main_ctx[] = {
 	(cmdline_parse_inst_t *)&cmd_link_flow_control_set_xon,
 	(cmdline_parse_inst_t *)&cmd_link_flow_control_set_macfwd,
 	(cmdline_parse_inst_t *)&cmd_link_flow_control_set_autoneg,
+	(cmdline_parse_inst_t *)&cmd_link_flow_control_show,
 	(cmdline_parse_inst_t *)&cmd_priority_flow_control_set,
 	(cmdline_parse_inst_t *)&cmd_config_dcb,
 	(cmdline_parse_inst_t *)&cmd_read_reg,
@@ -19487,6 +17552,8 @@ cmdline_parse_ctx_t main_ctx[] = {
 	(cmdline_parse_inst_t *)&cmd_set_fwd_eth_peer,
 	(cmdline_parse_inst_t *)&cmd_set_qmap,
 	(cmdline_parse_inst_t *)&cmd_set_xstats_hide_zero,
+	(cmdline_parse_inst_t *)&cmd_set_record_core_cycles,
+	(cmdline_parse_inst_t *)&cmd_set_record_burst_stats,
 	(cmdline_parse_inst_t *)&cmd_operate_port,
 	(cmdline_parse_inst_t *)&cmd_operate_specific_port,
 	(cmdline_parse_inst_t *)&cmd_operate_attach_port,
@@ -19516,43 +17583,24 @@ cmdline_parse_ctx_t main_ctx[] = {
 	(cmdline_parse_inst_t *)&cmd_set_uc_hash_filter,
 	(cmdline_parse_inst_t *)&cmd_set_uc_all_hash_filter,
 	(cmdline_parse_inst_t *)&cmd_vf_mac_addr_filter,
-	(cmdline_parse_inst_t *)&cmd_set_vf_macvlan_filter,
 	(cmdline_parse_inst_t *)&cmd_queue_rate_limit,
-	(cmdline_parse_inst_t *)&cmd_tunnel_filter,
 	(cmdline_parse_inst_t *)&cmd_tunnel_udp_config,
-	(cmdline_parse_inst_t *)&cmd_global_config,
 	(cmdline_parse_inst_t *)&cmd_set_mirror_mask,
 	(cmdline_parse_inst_t *)&cmd_set_mirror_link,
 	(cmdline_parse_inst_t *)&cmd_reset_mirror_rule,
 	(cmdline_parse_inst_t *)&cmd_showport_rss_hash,
 	(cmdline_parse_inst_t *)&cmd_showport_rss_hash_key,
 	(cmdline_parse_inst_t *)&cmd_config_rss_hash_key,
+	(cmdline_parse_inst_t *)&cmd_cleanup_txq_mbufs,
 	(cmdline_parse_inst_t *)&cmd_dump,
 	(cmdline_parse_inst_t *)&cmd_dump_one,
-	(cmdline_parse_inst_t *)&cmd_ethertype_filter,
-	(cmdline_parse_inst_t *)&cmd_syn_filter,
-	(cmdline_parse_inst_t *)&cmd_2tuple_filter,
-	(cmdline_parse_inst_t *)&cmd_5tuple_filter,
-	(cmdline_parse_inst_t *)&cmd_flex_filter,
-	(cmdline_parse_inst_t *)&cmd_add_del_ip_flow_director,
-	(cmdline_parse_inst_t *)&cmd_add_del_udp_flow_director,
-	(cmdline_parse_inst_t *)&cmd_add_del_sctp_flow_director,
-	(cmdline_parse_inst_t *)&cmd_add_del_l2_flow_director,
-	(cmdline_parse_inst_t *)&cmd_add_del_mac_vlan_flow_director,
-	(cmdline_parse_inst_t *)&cmd_add_del_tunnel_flow_director,
+#ifdef RTE_NET_I40E
 	(cmdline_parse_inst_t *)&cmd_add_del_raw_flow_director,
-	(cmdline_parse_inst_t *)&cmd_flush_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,
-	(cmdline_parse_inst_t *)&cmd_set_flow_director_flex_mask,
 	(cmdline_parse_inst_t *)&cmd_set_flow_director_flex_payload,
-	(cmdline_parse_inst_t *)&cmd_get_sym_hash_ena_per_port,
-	(cmdline_parse_inst_t *)&cmd_set_sym_hash_ena_per_port,
-	(cmdline_parse_inst_t *)&cmd_get_hash_global_config,
-	(cmdline_parse_inst_t *)&cmd_set_hash_global_config,
-	(cmdline_parse_inst_t *)&cmd_set_hash_input_set,
-	(cmdline_parse_inst_t *)&cmd_set_fdir_input_set,
 	(cmdline_parse_inst_t *)&cmd_flow,
 	(cmdline_parse_inst_t *)&cmd_show_port_meter_cap,
 	(cmdline_parse_inst_t *)&cmd_add_port_meter_profile_srtcm,
@@ -19562,22 +17610,12 @@ cmdline_parse_ctx_t main_ctx[] = {
 	(cmdline_parse_inst_t *)&cmd_enable_port_meter,
 	(cmdline_parse_inst_t *)&cmd_disable_port_meter,
 	(cmdline_parse_inst_t *)&cmd_del_port_meter,
+	(cmdline_parse_inst_t *)&cmd_del_port_meter_policy,
 	(cmdline_parse_inst_t *)&cmd_set_port_meter_profile,
 	(cmdline_parse_inst_t *)&cmd_set_port_meter_dscp_table,
-	(cmdline_parse_inst_t *)&cmd_set_port_meter_policer_action,
 	(cmdline_parse_inst_t *)&cmd_set_port_meter_stats_mask,
 	(cmdline_parse_inst_t *)&cmd_show_port_meter_stats,
 	(cmdline_parse_inst_t *)&cmd_mcast_addr,
-	(cmdline_parse_inst_t *)&cmd_config_l2_tunnel_eth_type_all,
-	(cmdline_parse_inst_t *)&cmd_config_l2_tunnel_eth_type_specific,
-	(cmdline_parse_inst_t *)&cmd_config_l2_tunnel_en_dis_all,
-	(cmdline_parse_inst_t *)&cmd_config_l2_tunnel_en_dis_specific,
-	(cmdline_parse_inst_t *)&cmd_config_e_tag_insertion_en,
-	(cmdline_parse_inst_t *)&cmd_config_e_tag_insertion_dis,
-	(cmdline_parse_inst_t *)&cmd_config_e_tag_stripping_en_dis,
-	(cmdline_parse_inst_t *)&cmd_config_e_tag_forwarding_en_dis,
-	(cmdline_parse_inst_t *)&cmd_config_e_tag_filter_add,
-	(cmdline_parse_inst_t *)&cmd_config_e_tag_filter_del,
 	(cmdline_parse_inst_t *)&cmd_set_vf_vlan_anti_spoof,
 	(cmdline_parse_inst_t *)&cmd_set_vf_mac_anti_spoof,
 	(cmdline_parse_inst_t *)&cmd_set_vf_vlan_stripq,
@@ -19620,6 +17658,8 @@ cmdline_parse_ctx_t main_ctx[] = {
 	(cmdline_parse_inst_t *)&cmd_set_mplsoudp_encap_with_vlan,
 	(cmdline_parse_inst_t *)&cmd_set_mplsoudp_decap,
 	(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,
@@ -19656,6 +17696,7 @@ cmdline_parse_ctx_t main_ctx[] = {
 	(cmdline_parse_inst_t *)&cmd_del_port_tm_node_wred_profile,
 	(cmdline_parse_inst_t *)&cmd_set_port_tm_node_shaper_profile,
 	(cmdline_parse_inst_t *)&cmd_add_port_tm_nonleaf_node,
+	(cmdline_parse_inst_t *)&cmd_add_port_tm_nonleaf_node_pmode,
 	(cmdline_parse_inst_t *)&cmd_add_port_tm_leaf_node,
 	(cmdline_parse_inst_t *)&cmd_del_port_tm_node,
 	(cmdline_parse_inst_t *)&cmd_set_port_tm_node_parent,
@@ -19674,17 +17715,21 @@ cmdline_parse_ctx_t main_ctx[] = {
 	(cmdline_parse_inst_t *)&cmd_tx_offload_get_configuration,
 	(cmdline_parse_inst_t *)&cmd_config_per_port_tx_offload,
 	(cmdline_parse_inst_t *)&cmd_config_per_queue_tx_offload,
-#ifdef RTE_LIBRTE_BPF
+#ifdef RTE_LIB_BPF
 	(cmdline_parse_inst_t *)&cmd_operate_bpf_ld_parse,
 	(cmdline_parse_inst_t *)&cmd_operate_bpf_unld_parse,
 #endif
 	(cmdline_parse_inst_t *)&cmd_config_tx_metadata_specific,
 	(cmdline_parse_inst_t *)&cmd_show_tx_metadata,
 	(cmdline_parse_inst_t *)&cmd_show_rx_tx_desc_status,
+	(cmdline_parse_inst_t *)&cmd_show_rx_queue_desc_used_count,
 	(cmdline_parse_inst_t *)&cmd_set_raw,
 	(cmdline_parse_inst_t *)&cmd_show_set_raw,
 	(cmdline_parse_inst_t *)&cmd_show_set_raw_all,
 	(cmdline_parse_inst_t *)&cmd_config_tx_dynf_specific,
+	(cmdline_parse_inst_t *)&cmd_show_fec_mode,
+	(cmdline_parse_inst_t *)&cmd_set_fec_mode,
+	(cmdline_parse_inst_t *)&cmd_show_capability,
 	NULL,
 };
 
@@ -19709,10 +17754,11 @@ cmdline_read_from_file(const char *filename)
 	printf("Read CLI commands from %s\n", filename);
 }
 
-/* prompt function, called from main on MASTER lcore */
+/* prompt function, called from main on MAIN lcore */
 void
 prompt(void)
 {
+	int ret;
 	/* initialize non-constant commands */
 	cmd_set_fwd_mode_init();
 	cmd_set_fwd_retry_mode_init();
@@ -19720,15 +17766,23 @@ prompt(void)
 	testpmd_cl = cmdline_stdin_new(main_ctx, "testpmd> ");
 	if (testpmd_cl == NULL)
 		return;
+
+	ret = atexit(prompt_exit);
+	if (ret != 0)
+		printf("Cannot set exit function for cmdline\n");
+
 	cmdline_interact(testpmd_cl);
-	cmdline_stdin_exit(testpmd_cl);
+	if (ret != 0)
+		cmdline_stdin_exit(testpmd_cl);
 }
 
 void
 prompt_exit(void)
 {
-	if (testpmd_cl != NULL)
+	if (testpmd_cl != NULL) {
 		cmdline_quit(testpmd_cl);
+		cmdline_stdin_exit(testpmd_cl);
+	}
 }
 
 static void