diff mbox

[dpdk-dev,RFC,5/7] ethdev: unification of flow types

Message ID 1418974005-15536-6-git-send-email-helin.zhang@intel.com (mailing list archive)
State Superseded, archived
Headers show

Commit Message

Helin Zhang Dec. 19, 2014, 7:26 a.m. UTC
Flow types was defined actually for i40e hardware specifically,
and wasn't able to be used for defining RSS offload types of all
PMDs. It removed the enum flow types, and uses macros instead
with new names. The new macros can be used for defining RSS
offload types later. Also modifications are made in i40e and
testpmd accordingly.

Signed-off-by: Helin Zhang <helin.zhang@intel.com>
---
 app/test-pmd/cmdline.c            | 88 ++++++++++++++++++++++++---------------
 app/test-pmd/config.c             | 71 +++++++++++++++++++++----------
 lib/librte_ether/rte_eth_ctrl.h   | 55 ++++++++++++++----------
 lib/librte_pmd_i40e/i40e_ethdev.c | 68 +++++++++++++++++-------------
 lib/librte_pmd_i40e/i40e_ethdev.h | 34 +++++++--------
 lib/librte_pmd_i40e/i40e_fdir.c   | 84 ++++++++++++++++++-------------------
 6 files changed, 235 insertions(+), 165 deletions(-)

Comments

Ananyev, Konstantin Dec. 19, 2014, 2:59 p.m. UTC | #1
Hi Helin,

> -----Original Message-----
> From: dev [mailto:dev-bounces@dpdk.org] On Behalf Of Helin Zhang
> Sent: Friday, December 19, 2014 7:27 AM
> To: dev@dpdk.org
> Subject: [dpdk-dev] [PATCH RFC 5/7] ethdev: unification of flow types
> 
> Flow types was defined actually for i40e hardware specifically,
> and wasn't able to be used for defining RSS offload types of all
> PMDs. It removed the enum flow types, and uses macros instead
> with new names. The new macros can be used for defining RSS
> offload types later. Also modifications are made in i40e and
> testpmd accordingly.
> 
> Signed-off-by: Helin Zhang <helin.zhang@intel.com>
> ---
>  app/test-pmd/cmdline.c            | 88 ++++++++++++++++++++++++---------------
>  app/test-pmd/config.c             | 71 +++++++++++++++++++++----------
>  lib/librte_ether/rte_eth_ctrl.h   | 55 ++++++++++++++----------
>  lib/librte_pmd_i40e/i40e_ethdev.c | 68 +++++++++++++++++-------------
>  lib/librte_pmd_i40e/i40e_ethdev.h | 34 +++++++--------
>  lib/librte_pmd_i40e/i40e_fdir.c   | 84 ++++++++++++++++++-------------------
>  6 files changed, 235 insertions(+), 165 deletions(-)
> 
> diff --git a/app/test-pmd/cmdline.c b/app/test-pmd/cmdline.c
> index 882a5a2..e7bab0c 100644
> --- a/app/test-pmd/cmdline.c
> +++ b/app/test-pmd/cmdline.c
> @@ -707,7 +707,7 @@ static void cmd_help_long_parsed(void *parsed_result,
>  			"    get info of a flex filter.\n\n"
> 
>  			"flow_director_filter (port_id) (add|del)"
> -			" flow (ip4|ip4-frag|ip6|ip6-frag)"
> +			" flow (ipv4-other|ipv4-frag|ipv6-other|ipv6-frag)"
>  			" src (src_ip_address) dst (dst_ip_address)"
>  			" flexbytes (flexbytes_value)"
>  			" (drop|fwd) queue (queue_id) fd_id (fd_id_value)\n"
> @@ -733,7 +733,8 @@ static void cmd_help_long_parsed(void *parsed_result,
>  			"    Flush all flow director entries of a device.\n\n"
> 
>  			"flow_director_flex_mask (port_id)"
> -			" flow (ip4|ip4-frag|tcp4|udp4|sctp4|ip6|ip6-frag|tcp6|udp6|sctp6|all)"
> +			" flow (ipv4-other|ipv4-frag|ipv4-tcp|ipv4-udp|ipv4-sctp|"
> +			"ipv6-other|ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|all)"
>  			" (mask)\n"
>  			"    Configure mask of flex payload.\n\n"
> 
> @@ -8158,31 +8159,34 @@ parse_flexbytes(const char *q_arg, uint8_t *flexbytes, uint16_t max_num)
>  	return ret;
>  }
> 
> -static enum rte_eth_flow_type
> +static uint16_t
>  str2flowtype(char *string)
>  {
>  	uint8_t i = 0;
>  	static const struct {
>  		char str[32];
> -		enum rte_eth_flow_type type;
> +		uint16_t type;
>  	} flowtype_str[] = {
> -		{"ip4", RTE_ETH_FLOW_TYPE_IPV4_OTHER},
> -		{"ip4-frag", RTE_ETH_FLOW_TYPE_FRAG_IPV4},
> -		{"udp4", RTE_ETH_FLOW_TYPE_UDPV4},
> -		{"tcp4", RTE_ETH_FLOW_TYPE_TCPV4},
> -		{"sctp4", RTE_ETH_FLOW_TYPE_SCTPV4},
> -		{"ip6", RTE_ETH_FLOW_TYPE_IPV6_OTHER},
> -		{"ip6-frag", RTE_ETH_FLOW_TYPE_FRAG_IPV6},
> -		{"udp6", RTE_ETH_FLOW_TYPE_UDPV6},
> -		{"tcp6", RTE_ETH_FLOW_TYPE_TCPV6},
> -		{"sctp6", RTE_ETH_FLOW_TYPE_TCPV6},
> +		{"ipv4", ETH_FLOW_TYPE_IPV4},
> +		{"ipv4-frag", ETH_FLOW_TYPE_FRAG_IPV4},
> +		{"ipv4-tcp", ETH_FLOW_TYPE_NONFRAG_IPV4_TCP},
> +		{"ipv4-udp", ETH_FLOW_TYPE_NONFRAG_IPV4_UDP},
> +		{"ipv4-sctp", ETH_FLOW_TYPE_NONFRAG_IPV4_SCTP},
> +		{"ipv4-other", ETH_FLOW_TYPE_NONFRAG_IPV4_OTHER},
> +		{"ipv6", ETH_FLOW_TYPE_IPV6},
> +		{"ipv6-frag", ETH_FLOW_TYPE_FRAG_IPV6},
> +		{"ipv6-tcp", ETH_FLOW_TYPE_NONFRAG_IPV6_TCP},
> +		{"ipv6-udp", ETH_FLOW_TYPE_NONFRAG_IPV6_UDP},
> +		{"ipv6-sctp", ETH_FLOW_TYPE_NONFRAG_IPV6_SCTP},
> +		{"ipv6-other", ETH_FLOW_TYPE_NONFRAG_IPV6_OTHER},
> +		{"l2_payload", ETH_FLOW_TYPE_L2_PAYLOAD},
>  	};
> 
>  	for (i = 0; i < RTE_DIM(flowtype_str); i++) {
>  		if (!strcmp(flowtype_str[i].str, string))
>  			return flowtype_str[i].type;
>  	}
> -	return RTE_ETH_FLOW_TYPE_NONE;
> +	return ETH_FLOW_TYPE_UNKNOWN;
>  }
> 
>  #define IPV4_ADDR_TO_UINT(ip_addr, ip) \
> @@ -8235,9 +8239,9 @@ cmd_flow_director_filter_parsed(void *parsed_result,
> 
>  	entry.input.flow_type = str2flowtype(res->flow_type);
>  	switch (entry.input.flow_type) {
> -	case RTE_ETH_FLOW_TYPE_IPV4_OTHER:
> -	case RTE_ETH_FLOW_TYPE_UDPV4:
> -	case RTE_ETH_FLOW_TYPE_TCPV4:
> +	case ETH_FLOW_TYPE_NONFRAG_IPV4_OTHER:
> +	case ETH_FLOW_TYPE_NONFRAG_IPV4_UDP:
> +	case ETH_FLOW_TYPE_NONFRAG_IPV4_TCP:
>  		IPV4_ADDR_TO_UINT(res->ip_dst,
>  			entry.input.flow.ip4_flow.dst_ip);
>  		IPV4_ADDR_TO_UINT(res->ip_src,
> @@ -8248,7 +8252,7 @@ cmd_flow_director_filter_parsed(void *parsed_result,
>  		entry.input.flow.udp4_flow.src_port =
>  				rte_cpu_to_be_16(res->port_src);
>  		break;
> -	case RTE_ETH_FLOW_TYPE_SCTPV4:
> +	case ETH_FLOW_TYPE_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,
> @@ -8257,9 +8261,9 @@ cmd_flow_director_filter_parsed(void *parsed_result,
>  		entry.input.flow.sctp4_flow.verify_tag =
>  				rte_cpu_to_be_32(res->verify_tag_value);
>  		break;
> -	case RTE_ETH_FLOW_TYPE_IPV6_OTHER:
> -	case RTE_ETH_FLOW_TYPE_UDPV6:
> -	case RTE_ETH_FLOW_TYPE_TCPV6:
> +	case ETH_FLOW_TYPE_NONFRAG_IPV6_OTHER:
> +	case ETH_FLOW_TYPE_NONFRAG_IPV6_UDP:
> +	case ETH_FLOW_TYPE_NONFRAG_IPV6_TCP:
>  		IPV6_ADDR_TO_ARRAY(res->ip_dst,
>  			entry.input.flow.ipv6_flow.dst_ip);
>  		IPV6_ADDR_TO_ARRAY(res->ip_src,
> @@ -8270,7 +8274,7 @@ cmd_flow_director_filter_parsed(void *parsed_result,
>  		entry.input.flow.udp6_flow.src_port =
>  				rte_cpu_to_be_16(res->port_src);
>  		break;
> -	case RTE_ETH_FLOW_TYPE_SCTPV6:
> +	case ETH_FLOW_TYPE_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,
> @@ -8321,9 +8325,8 @@ cmdline_parse_token_string_t cmd_flow_director_flow =
>  				 flow, "flow");
>  cmdline_parse_token_string_t cmd_flow_director_flow_type =
>  	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
> -				 flow_type,
> -				 "ip4#ip4-frag#tcp4#udp4#sctp4#"
> -				 "ip6#ip6-frag#tcp6#udp6#sctp6");
> +		flow_type, "ipv4-other#ipv4-frag#ipv4-tcp#ipv4-udp#ipv4-sctp#"
> +		"ipv6-other#ipv6-frag#ipv6-tcp#ipv6-udp#ipv6-sctp");
>  cmdline_parse_token_string_t cmd_flow_director_src =
>  	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
>  				 src, "src");
> @@ -8511,7 +8514,9 @@ cmd_flow_director_flex_mask_parsed(void *parsed_result,
>  	struct cmd_flow_director_flex_mask_result *res = parsed_result;
>  	struct rte_eth_fdir_flex_mask flex_mask;
>  	struct rte_port *port;
> -	enum rte_eth_flow_type i;
> +	struct rte_eth_fdir_info fdir_info;
> +	uint32_t flow_type_mask;
> +	uint16_t i;
>  	int ret;
> 
>  	if (res->port_id > nb_ports) {
> @@ -8534,10 +8539,23 @@ cmd_flow_director_flex_mask_parsed(void *parsed_result,
>  		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;
> +	}
> +	flow_type_mask = fdir_info.flow_types_mask[0];
>  	if (!strcmp(res->flow_type, "all")) {
> -		for (i = RTE_ETH_FLOW_TYPE_UDPV4;
> -		     i <= RTE_ETH_FLOW_TYPE_FRAG_IPV6;
> -		     i++) {
> +		if (!flow_type_mask) {
> +			printf("No flow type supported\n");
> +			return;
> +		}
> +		for (i = ETH_FLOW_TYPE_UNKNOWN; i < ETH_FLOW_TYPE_MAX; i++) {
> +			if (!(flow_type_mask & (1 << i)))
> +				continue;
>  			flex_mask.flow_type = i;
>  			fdir_set_flex_mask(res->port_id, &flex_mask);
>  		}
> @@ -8545,6 +8563,11 @@ cmd_flow_director_flex_mask_parsed(void *parsed_result,
>  		return;
>  	}
>  	flex_mask.flow_type = str2flowtype(res->flow_type);
> +	if (!(flow_type_mask & (1 << 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);
>  }
> @@ -8561,9 +8584,8 @@ cmdline_parse_token_string_t cmd_flow_director_flexmask_flow =
>  				 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,
> -				"ip4#ip4-frag#tcp4#udp4#sctp4#"
> -				"ip6#ip6-frag#tcp6#udp6#sctp6#all");
> +		flow_type, "ipv4-other#ipv4-frag#ipv4-tcp#ipv4-udp#ipv4-sctp#"
> +		"ipv6-other#ipv6-frag#ipv6-tcp#ipv6-udp#ipv6-sctp#all");
>  cmdline_parse_token_string_t cmd_flow_director_flexmask_mask =
>  	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_flex_mask_result,
>  				 mask, NULL);
> diff --git a/app/test-pmd/config.c b/app/test-pmd/config.c
> index 87dedf9..4c61a07 100644
> --- a/app/test-pmd/config.c
> +++ b/app/test-pmd/config.c
> @@ -96,19 +96,7 @@
> 
>  #include "testpmd.h"
> 
> -static const char *flowtype_str[RTE_ETH_FLOW_TYPE_MAX] = {
> -	NULL,
> -	"udp4",
> -	"tcp4",
> -	"sctp4",
> -	"ip4",
> -	"ip4-frag",
> -	"udp6",
> -	"tcp6",
> -	"sctp6",
> -	"ip6",
> -	"ip6-frag",
> -};
> +static char *flowtype_to_str(uint16_t flow_type);
> 
>  static void
>  print_ethaddr(const char *name, struct ether_addr *eth_addr)
> @@ -1843,15 +1831,50 @@ print_fdir_flex_payload(struct rte_eth_fdir_flex_conf *flex_conf)
>  	printf("\n");
>  }
> 
> +static char *
> +flowtype_to_str(uint16_t flow_type)
> +{
> +	struct flow_type_info {
> +		char str[32];
> +		uint16_t ftype;
> +	};
> +
> +	uint8_t i;
> +	static struct flow_type_info flowtype_str_table[] = {
> +		{"ipv4", ETH_FLOW_TYPE_IPV4},
> +		{"ipv4-frag", ETH_FLOW_TYPE_FRAG_IPV4},
> +		{"ipv4-tcp", ETH_FLOW_TYPE_NONFRAG_IPV4_TCP},
> +		{"ipv4-udp", ETH_FLOW_TYPE_NONFRAG_IPV4_UDP},
> +		{"ipv4-sctp", ETH_FLOW_TYPE_NONFRAG_IPV4_SCTP},
> +		{"ipv4-other", ETH_FLOW_TYPE_NONFRAG_IPV4_OTHER},
> +		{"ipv6", ETH_FLOW_TYPE_IPV6},
> +		{"ipv6-frag", ETH_FLOW_TYPE_FRAG_IPV6},
> +		{"ipv6-tcp", ETH_FLOW_TYPE_NONFRAG_IPV6_TCP},
> +		{"ipv6-udp", ETH_FLOW_TYPE_NONFRAG_IPV6_UDP},
> +		{"ipv6-sctp", ETH_FLOW_TYPE_NONFRAG_IPV6_SCTP},
> +		{"ipv6-other", ETH_FLOW_TYPE_NONFRAG_IPV6_OTHER},
> +		{"l2_payload", ETH_FLOW_TYPE_L2_PAYLOAD},
> +	};
> +
> +	for (i = 0; i < RTE_DIM(flowtype_str_table); i++) {
> +		if (flowtype_str_table[i].ftype == flow_type)
> +			return flowtype_str_table[i].str;
> +	}
> +
> +	return NULL;
> +}
> +
>  static inline void
>  print_fdir_flex_mask(struct rte_eth_fdir_flex_conf *flex_conf)
>  {
>  	struct rte_eth_fdir_flex_mask *mask;
>  	int i, j;
> +	char *p;
> 
>  	for (i = 0; i < flex_conf->nb_flexmasks; i++) {
>  		mask = &flex_conf->flex_mask[i];
> -		printf("\n    %s:\t", flowtype_str[mask->flow_type]);
> +		p = flowtype_to_str(mask->flow_type);
> +		printf("\n    %s:\t", p ? p : "unknown");
>  		for (j = 0; j < RTE_ETH_FDIR_MAX_FLEXLEN; j++)
>  			printf(" %02x", mask->mask[j]);
>  	}
> @@ -1861,13 +1884,17 @@ print_fdir_flex_mask(struct rte_eth_fdir_flex_conf *flex_conf)
>  static inline void
>  print_fdir_flow_type(uint32_t flow_types_mask)
>  {
> -	int i = 0;
> +	int i;
> +	char *p;
> 
> -	for (i = RTE_ETH_FLOW_TYPE_UDPV4;
> -	     i <= RTE_ETH_FLOW_TYPE_FRAG_IPV6;
> -	     i++) {
> -		if (flow_types_mask & (1 << i))
> -			printf(" %s", flowtype_str[i]);
> +	for (i = ETH_FLOW_TYPE_UNKNOWN; i < ETH_FLOW_TYPE_MAX; i++) {
> +		if (!(flow_types_mask & (1 << i)))
> +			continue;
> +		p = flowtype_to_str(i);
> +		if (p)
> +			printf(" %s", p);
> +		else
> +			printf(" unknown");
>  	}
>  	printf("\n");
>  }
> @@ -2028,13 +2055,13 @@ fdir_set_flex_mask(portid_t port_id, struct rte_eth_fdir_flex_mask *cfg)
> 
>  	port = &ports[port_id];
>  	flex_conf = &port->dev_conf.fdir_conf.flex_conf;
> -	for (i = 0; i < RTE_ETH_FLOW_TYPE_MAX; i++) {
> +	for (i = 0; i < ETH_FLOW_TYPE_MAX; i++) {
>  		if (cfg->flow_type == flex_conf->flex_mask[i].flow_type) {
>  			idx = i;
>  			break;
>  		}
>  	}
> -	if (i >= RTE_ETH_FLOW_TYPE_MAX) {
> +	if (i >= ETH_FLOW_TYPE_MAX) {
>  		if (flex_conf->nb_flexmasks < RTE_DIM(flex_conf->flex_mask)) {
>  			idx = flex_conf->nb_flexmasks;
>  			flex_conf->nb_flexmasks++;
> diff --git a/lib/librte_ether/rte_eth_ctrl.h b/lib/librte_ether/rte_eth_ctrl.h
> index 1c15ed0..9f99fe7 100644
> --- a/lib/librte_ether/rte_eth_ctrl.h
> +++ b/lib/librte_ether/rte_eth_ctrl.h
> @@ -46,6 +46,35 @@
>  extern "C" {
>  #endif
> 
> +/*
> + * A packet can be identified by hardware as different flow types. Different
> + * NIC hardwares may support different flow types.
> + * Basically, the NIC hardware identifies the flow type as deep protocol as
> + * possible, and exclusively. For example, if a packet is identified as
> + * 'ETH_FLOW_TYPE_NONFRAG_IPV4_TCP', it will not be any of other flow types,
> + * though it is a actual IPV4 packet.
> + * Note that the flow types are used to define RSS offload types in
> + * rte_ethdev.h.
> + */
> +#define ETH_FLOW_TYPE_UNKNOWN            0
> +#define ETH_FLOW_TYPE_IPV4               1
> +#define ETH_FLOW_TYPE_FRAG_IPV4          2
> +#define ETH_FLOW_TYPE_NONFRAG_IPV4_TCP   3
> +#define ETH_FLOW_TYPE_NONFRAG_IPV4_UDP   4
> +#define ETH_FLOW_TYPE_NONFRAG_IPV4_SCTP  5
> +#define ETH_FLOW_TYPE_NONFRAG_IPV4_OTHER 6
> +#define ETH_FLOW_TYPE_IPV6               7
> +#define ETH_FLOW_TYPE_FRAG_IPV6          8
> +#define ETH_FLOW_TYPE_NONFRAG_IPV6_TCP   9
> +#define ETH_FLOW_TYPE_NONFRAG_IPV6_UDP   10
> +#define ETH_FLOW_TYPE_NONFRAG_IPV6_SCTP  11
> +#define ETH_FLOW_TYPE_NONFRAG_IPV6_OTHER 12
> +#define ETH_FLOW_TYPE_L2_PAYLOAD         13
> +#define ETH_FLOW_TYPE_IPV6_EX            14
> +#define ETH_FLOW_TYPE_IPV6_TCP_EX        15
> +#define ETH_FLOW_TYPE_IPV6_UDP_EX        16
> +#define ETH_FLOW_TYPE_MAX                17
> +
>  /**
>   * Feature filter types
>   */
> @@ -179,24 +208,6 @@ struct rte_eth_tunnel_filter_conf {
>  #define RTE_ETH_FDIR_MAX_FLEXLEN         16 /** < Max length of flexbytes. */
> 
>  /**
> - * Flow type
> - */
> -enum rte_eth_flow_type {
> -	RTE_ETH_FLOW_TYPE_NONE = 0,
> -	RTE_ETH_FLOW_TYPE_UDPV4,
> -	RTE_ETH_FLOW_TYPE_TCPV4,
> -	RTE_ETH_FLOW_TYPE_SCTPV4,
> -	RTE_ETH_FLOW_TYPE_IPV4_OTHER,
> -	RTE_ETH_FLOW_TYPE_FRAG_IPV4,
> -	RTE_ETH_FLOW_TYPE_UDPV6,
> -	RTE_ETH_FLOW_TYPE_TCPV6,
> -	RTE_ETH_FLOW_TYPE_SCTPV6,
> -	RTE_ETH_FLOW_TYPE_IPV6_OTHER,
> -	RTE_ETH_FLOW_TYPE_FRAG_IPV6,
> -	RTE_ETH_FLOW_TYPE_MAX = 64,
> -};
> -
> -/**
>   * A structure used to define the input for IPV4 flow
>   */
>  struct rte_eth_ipv4_flow {
> @@ -291,7 +302,7 @@ struct rte_eth_fdir_flow_ext {
>   * A structure used to define the input for a flow director filter entry
>   */
>  struct rte_eth_fdir_input {
> -	enum rte_eth_flow_type flow_type;      /**< Type of flow */
> +	uint16_t flow_type;      /**< Type of flow */

Wonder, why do you need to switch from int to uinsigned short for flow_type?
Konstantin

>  	union rte_eth_fdir_flow flow;
>  	/**< Flow fields to match, dependent on flow_type */
>  	struct rte_eth_fdir_flow_ext flow_ext;
> @@ -371,7 +382,7 @@ struct rte_eth_flex_payload_cfg {
>   * for each flow type
>   */
>  struct rte_eth_fdir_flex_mask {
> -	enum rte_eth_flow_type flow_type;  /**< Flow type */
> +	uint16_t flow_type;  /**< Flow type */
>  	uint8_t mask[RTE_ETH_FDIR_MAX_FLEXLEN];
>  	/**< Mask for the whole flexible payload */
>  };
> @@ -385,7 +396,7 @@ struct rte_eth_fdir_flex_conf {
>  	uint16_t nb_flexmasks; /**< The number of following mask */
>  	struct rte_eth_flex_payload_cfg flex_set[RTE_ETH_PAYLOAD_MAX];
>  	/**< Flex payload configuration for each payload type */
> -	struct rte_eth_fdir_flex_mask flex_mask[RTE_ETH_FLOW_TYPE_MAX];
> +	struct rte_eth_fdir_flex_mask flex_mask[ETH_FLOW_TYPE_MAX];
>  	/**< Flex mask configuration for each flow type */
>  };
> 
> @@ -400,7 +411,7 @@ enum rte_fdir_mode {
> 
>  #define UINT32_BIT (CHAR_BIT * sizeof(uint32_t))
>  #define RTE_FLOW_TYPE_MASK_ARRAY_SIZE \
> -	(RTE_ALIGN(RTE_ETH_FLOW_TYPE_MAX, UINT32_BIT)/UINT32_BIT)
> +	(RTE_ALIGN(ETH_FLOW_TYPE_MAX, UINT32_BIT)/UINT32_BIT)
> 
>  /**
>   * A structure used to get the information of flow director filter.
> diff --git a/lib/librte_pmd_i40e/i40e_ethdev.c b/lib/librte_pmd_i40e/i40e_ethdev.c
> index b47a3d2..de1eff4 100644
> --- a/lib/librte_pmd_i40e/i40e_ethdev.c
> +++ b/lib/librte_pmd_i40e/i40e_ethdev.c
> @@ -5261,46 +5261,56 @@ i40e_dev_filter_ctrl(struct rte_eth_dev *dev,
>  }
> 
>  enum i40e_filter_pctype
> -i40e_flowtype_to_pctype(enum rte_eth_flow_type flow_type)
> +i40e_flowtype_to_pctype(uint16_t flow_type)
>  {
>  	static const enum i40e_filter_pctype pctype_table[] = {
> -		[RTE_ETH_FLOW_TYPE_UDPV4] = I40E_FILTER_PCTYPE_NONF_IPV4_UDP,
> -		[RTE_ETH_FLOW_TYPE_TCPV4] = I40E_FILTER_PCTYPE_NONF_IPV4_TCP,
> -		[RTE_ETH_FLOW_TYPE_SCTPV4] = I40E_FILTER_PCTYPE_NONF_IPV4_SCTP,
> -		[RTE_ETH_FLOW_TYPE_IPV4_OTHER] =
> -					I40E_FILTER_PCTYPE_NONF_IPV4_OTHER,
> -		[RTE_ETH_FLOW_TYPE_FRAG_IPV4] =
> -					I40E_FILTER_PCTYPE_FRAG_IPV4,
> -		[RTE_ETH_FLOW_TYPE_UDPV6] = I40E_FILTER_PCTYPE_NONF_IPV6_UDP,
> -		[RTE_ETH_FLOW_TYPE_TCPV6] = I40E_FILTER_PCTYPE_NONF_IPV6_TCP,
> -		[RTE_ETH_FLOW_TYPE_SCTPV6] = I40E_FILTER_PCTYPE_NONF_IPV6_SCTP,
> -		[RTE_ETH_FLOW_TYPE_IPV6_OTHER] =
> -					I40E_FILTER_PCTYPE_NONF_IPV6_OTHER,
> -		[RTE_ETH_FLOW_TYPE_FRAG_IPV6] =
> -					I40E_FILTER_PCTYPE_FRAG_IPV6,
> +		[ETH_FLOW_TYPE_FRAG_IPV4] = I40E_FILTER_PCTYPE_FRAG_IPV4,
> +		[ETH_FLOW_TYPE_NONFRAG_IPV4_UDP] =
> +			I40E_FILTER_PCTYPE_NONF_IPV4_UDP,
> +		[ETH_FLOW_TYPE_NONFRAG_IPV4_TCP] =
> +			I40E_FILTER_PCTYPE_NONF_IPV4_TCP,
> +		[ETH_FLOW_TYPE_NONFRAG_IPV4_SCTP] =
> +			I40E_FILTER_PCTYPE_NONF_IPV4_SCTP,
> +		[ETH_FLOW_TYPE_NONFRAG_IPV4_OTHER] =
> +			I40E_FILTER_PCTYPE_NONF_IPV4_OTHER,
> +		[ETH_FLOW_TYPE_FRAG_IPV6] = I40E_FILTER_PCTYPE_FRAG_IPV6,
> +		[ETH_FLOW_TYPE_NONFRAG_IPV6_UDP] =
> +			I40E_FILTER_PCTYPE_NONF_IPV6_UDP,
> +		[ETH_FLOW_TYPE_NONFRAG_IPV6_TCP] =
> +			I40E_FILTER_PCTYPE_NONF_IPV6_TCP,
> +		[ETH_FLOW_TYPE_NONFRAG_IPV6_SCTP] =
> +			I40E_FILTER_PCTYPE_NONF_IPV6_SCTP,
> +		[ETH_FLOW_TYPE_NONFRAG_IPV6_OTHER] =
> +			I40E_FILTER_PCTYPE_NONF_IPV6_OTHER,
> +		[ETH_FLOW_TYPE_L2_PAYLOAD] = I40E_FILTER_PCTYPE_L2_PAYLOAD,
>  	};
> 
>  	return pctype_table[flow_type];
>  }
> 
> -enum rte_eth_flow_type
> +uint16_t
>  i40e_pctype_to_flowtype(enum i40e_filter_pctype pctype)
>  {
> -	static const enum rte_eth_flow_type flowtype_table[] = {
> -		[I40E_FILTER_PCTYPE_NONF_IPV4_UDP] = RTE_ETH_FLOW_TYPE_UDPV4,
> -		[I40E_FILTER_PCTYPE_NONF_IPV4_TCP] = RTE_ETH_FLOW_TYPE_TCPV4,
> -		[I40E_FILTER_PCTYPE_NONF_IPV4_SCTP] = RTE_ETH_FLOW_TYPE_SCTPV4,
> +	static const uint16_t flowtype_table[] = {
> +		[I40E_FILTER_PCTYPE_FRAG_IPV4] = ETH_FLOW_TYPE_FRAG_IPV4,
> +		[I40E_FILTER_PCTYPE_NONF_IPV4_UDP] =
> +			ETH_FLOW_TYPE_NONFRAG_IPV4_UDP,
> +		[I40E_FILTER_PCTYPE_NONF_IPV4_TCP] =
> +			ETH_FLOW_TYPE_NONFRAG_IPV4_TCP,
> +		[I40E_FILTER_PCTYPE_NONF_IPV4_SCTP] =
> +			ETH_FLOW_TYPE_NONFRAG_IPV4_SCTP,
>  		[I40E_FILTER_PCTYPE_NONF_IPV4_OTHER] =
> -					RTE_ETH_FLOW_TYPE_IPV4_OTHER,
> -		[I40E_FILTER_PCTYPE_FRAG_IPV4] =
> -					RTE_ETH_FLOW_TYPE_FRAG_IPV4,
> -		[I40E_FILTER_PCTYPE_NONF_IPV6_UDP] = RTE_ETH_FLOW_TYPE_UDPV6,
> -		[I40E_FILTER_PCTYPE_NONF_IPV6_TCP] = RTE_ETH_FLOW_TYPE_TCPV6,
> -		[I40E_FILTER_PCTYPE_NONF_IPV6_SCTP] = RTE_ETH_FLOW_TYPE_SCTPV6,
> +			ETH_FLOW_TYPE_NONFRAG_IPV4_OTHER,
> +		[I40E_FILTER_PCTYPE_FRAG_IPV6] = ETH_FLOW_TYPE_FRAG_IPV6,
> +		[I40E_FILTER_PCTYPE_NONF_IPV6_UDP] =
> +			ETH_FLOW_TYPE_NONFRAG_IPV6_UDP,
> +		[I40E_FILTER_PCTYPE_NONF_IPV6_TCP] =
> +			ETH_FLOW_TYPE_NONFRAG_IPV6_TCP,
> +		[I40E_FILTER_PCTYPE_NONF_IPV6_SCTP] =
> +			ETH_FLOW_TYPE_NONFRAG_IPV6_SCTP,
>  		[I40E_FILTER_PCTYPE_NONF_IPV6_OTHER] =
> -					RTE_ETH_FLOW_TYPE_IPV6_OTHER,
> -		[I40E_FILTER_PCTYPE_FRAG_IPV6] =
> -					RTE_ETH_FLOW_TYPE_FRAG_IPV6,
> +			ETH_FLOW_TYPE_NONFRAG_IPV6_OTHER,
> +		[I40E_FILTER_PCTYPE_L2_PAYLOAD] = ETH_FLOW_TYPE_L2_PAYLOAD,
>  	};
> 
>  	return flowtype_table[pctype];
> diff --git a/lib/librte_pmd_i40e/i40e_ethdev.h b/lib/librte_pmd_i40e/i40e_ethdev.h
> index f913ea9..e2a8db3 100644
> --- a/lib/librte_pmd_i40e/i40e_ethdev.h
> +++ b/lib/librte_pmd_i40e/i40e_ethdev.h
> @@ -471,10 +471,8 @@ const struct rte_memzone *i40e_memzone_reserve(const char *name,
>  					int socket_id);
>  int i40e_fdir_configure(struct rte_eth_dev *dev);
>  void i40e_fdir_teardown(struct i40e_pf *pf);
> -enum i40e_filter_pctype i40e_flowtype_to_pctype(
> -				enum rte_eth_flow_type flow_type);
> -enum rte_eth_flow_type i40e_pctype_to_flowtype(
> -				enum i40e_filter_pctype pctype);
> +enum i40e_filter_pctype i40e_flowtype_to_pctype(uint16_t flow_type);
> +uint16_t i40e_pctype_to_flowtype(enum i40e_filter_pctype pctype);
>  int i40e_fdir_ctrl_func(struct rte_eth_dev *dev,
>  			  enum rte_filter_op filter_op,
>  			  void *arg);
> @@ -541,27 +539,29 @@ i40e_init_adminq_parameter(struct i40e_hw *hw)
>  }
> 
>  #define I40E_VALID_FLOW_TYPE(flow_type) \
> -	((flow_type) == RTE_ETH_FLOW_TYPE_UDPV4 || \
> -	(flow_type) == RTE_ETH_FLOW_TYPE_TCPV4 || \
> -	(flow_type) == RTE_ETH_FLOW_TYPE_SCTPV4 || \
> -	(flow_type) == RTE_ETH_FLOW_TYPE_IPV4_OTHER || \
> -	(flow_type) == RTE_ETH_FLOW_TYPE_FRAG_IPV4 || \
> -	(flow_type) == RTE_ETH_FLOW_TYPE_UDPV6 || \
> -	(flow_type) == RTE_ETH_FLOW_TYPE_TCPV6 || \
> -	(flow_type) == RTE_ETH_FLOW_TYPE_SCTPV6 || \
> -	(flow_type) == RTE_ETH_FLOW_TYPE_IPV6_OTHER || \
> -	(flow_type) == RTE_ETH_FLOW_TYPE_FRAG_IPV6)
> +	((flow_type) == ETH_FLOW_TYPE_FRAG_IPV4 || \
> +	(flow_type) == ETH_FLOW_TYPE_NONFRAG_IPV4_TCP || \
> +	(flow_type) == ETH_FLOW_TYPE_NONFRAG_IPV4_UDP || \
> +	(flow_type) == ETH_FLOW_TYPE_NONFRAG_IPV4_SCTP || \
> +	(flow_type) == ETH_FLOW_TYPE_NONFRAG_IPV4_OTHER || \
> +	(flow_type) == ETH_FLOW_TYPE_FRAG_IPV6 || \
> +	(flow_type) == ETH_FLOW_TYPE_NONFRAG_IPV6_TCP || \
> +	(flow_type) == ETH_FLOW_TYPE_NONFRAG_IPV6_UDP || \
> +	(flow_type) == ETH_FLOW_TYPE_NONFRAG_IPV6_SCTP || \
> +	(flow_type) == ETH_FLOW_TYPE_NONFRAG_IPV6_OTHER || \
> +	(flow_type) == ETH_FLOW_TYPE_L2_PAYLOAD)
> 
>  #define I40E_VALID_PCTYPE(pctype) \
> -	((pctype) == I40E_FILTER_PCTYPE_NONF_IPV4_UDP || \
> +	((pctype) == I40E_FILTER_PCTYPE_FRAG_IPV4 || \
>  	(pctype) == I40E_FILTER_PCTYPE_NONF_IPV4_TCP || \
> +	(pctype) == I40E_FILTER_PCTYPE_NONF_IPV4_UDP || \
>  	(pctype) == I40E_FILTER_PCTYPE_NONF_IPV4_SCTP || \
>  	(pctype) == I40E_FILTER_PCTYPE_NONF_IPV4_OTHER || \
> -	(pctype) == I40E_FILTER_PCTYPE_FRAG_IPV4 || \
> +	(pctype) == I40E_FILTER_PCTYPE_FRAG_IPV6 || \
>  	(pctype) == I40E_FILTER_PCTYPE_NONF_IPV6_UDP || \
>  	(pctype) == I40E_FILTER_PCTYPE_NONF_IPV6_TCP || \
>  	(pctype) == I40E_FILTER_PCTYPE_NONF_IPV6_SCTP || \
>  	(pctype) == I40E_FILTER_PCTYPE_NONF_IPV6_OTHER || \
> -	(pctype) == I40E_FILTER_PCTYPE_FRAG_IPV6)
> +	(pctype) == I40E_FILTER_PCTYPE_L2_PAYLOAD)
> 
>  #endif /* _I40E_ETHDEV_H_ */
> diff --git a/lib/librte_pmd_i40e/i40e_fdir.c b/lib/librte_pmd_i40e/i40e_fdir.c
> index c9e535b..9bdcabf 100644
> --- a/lib/librte_pmd_i40e/i40e_fdir.c
> +++ b/lib/librte_pmd_i40e/i40e_fdir.c
> @@ -95,16 +95,16 @@
>  			I40E_PRTQF_FLX_PIT_DEST_OFF_MASK))
> 
>  #define I40E_FDIR_FLOW_TYPES ( \
> -	(1 << RTE_ETH_FLOW_TYPE_UDPV4) | \
> -	(1 << RTE_ETH_FLOW_TYPE_TCPV4) | \
> -	(1 << RTE_ETH_FLOW_TYPE_SCTPV4) | \
> -	(1 << RTE_ETH_FLOW_TYPE_IPV4_OTHER) | \
> -	(1 << RTE_ETH_FLOW_TYPE_FRAG_IPV4) | \
> -	(1 << RTE_ETH_FLOW_TYPE_UDPV6) | \
> -	(1 << RTE_ETH_FLOW_TYPE_TCPV6) | \
> -	(1 << RTE_ETH_FLOW_TYPE_SCTPV6) | \
> -	(1 << RTE_ETH_FLOW_TYPE_IPV6_OTHER) | \
> -	(1 << RTE_ETH_FLOW_TYPE_FRAG_IPV6))
> +	(1 << ETH_FLOW_TYPE_FRAG_IPV4) | \
> +	(1 << ETH_FLOW_TYPE_NONFRAG_IPV4_UDP) | \
> +	(1 << ETH_FLOW_TYPE_NONFRAG_IPV4_TCP) | \
> +	(1 << ETH_FLOW_TYPE_NONFRAG_IPV4_SCTP) | \
> +	(1 << ETH_FLOW_TYPE_NONFRAG_IPV4_OTHER) | \
> +	(1 << ETH_FLOW_TYPE_FRAG_IPV6) | \
> +	(1 << ETH_FLOW_TYPE_NONFRAG_IPV6_UDP) | \
> +	(1 << ETH_FLOW_TYPE_NONFRAG_IPV6_TCP) | \
> +	(1 << ETH_FLOW_TYPE_NONFRAG_IPV6_SCTP) | \
> +	(1 << ETH_FLOW_TYPE_NONFRAG_IPV6_OTHER))
> 
>  #define I40E_FLEX_WORD_MASK(off) (0x80 >> (off))
> 
> @@ -498,7 +498,7 @@ i40e_check_fdir_flex_conf(const struct rte_eth_fdir_flex_conf *conf)
>  	}
> 
>  	/* check flex mask setting configuration */
> -	if (conf->nb_flexmasks > RTE_ETH_FLOW_TYPE_FRAG_IPV6) {
> +	if (conf->nb_flexmasks >= ETH_FLOW_TYPE_MAX) {
>  		PMD_DRV_LOG(ERR, "invalid number of flex masks.");
>  		return -EINVAL;
>  	}
> @@ -692,24 +692,24 @@ i40e_fdir_fill_eth_ip_head(const struct rte_eth_fdir_input *fdir_input,
>  	struct ipv4_hdr *ip;
>  	struct ipv6_hdr *ip6;
>  	static const uint8_t next_proto[] = {
> -		[RTE_ETH_FLOW_TYPE_UDPV4] = IPPROTO_UDP,
> -		[RTE_ETH_FLOW_TYPE_TCPV4] = IPPROTO_TCP,
> -		[RTE_ETH_FLOW_TYPE_SCTPV4] = IPPROTO_SCTP,
> -		[RTE_ETH_FLOW_TYPE_IPV4_OTHER] = IPPROTO_IP,
> -		[RTE_ETH_FLOW_TYPE_FRAG_IPV4] = IPPROTO_IP,
> -		[RTE_ETH_FLOW_TYPE_UDPV6] = IPPROTO_UDP,
> -		[RTE_ETH_FLOW_TYPE_TCPV6] = IPPROTO_TCP,
> -		[RTE_ETH_FLOW_TYPE_SCTPV6] = IPPROTO_SCTP,
> -		[RTE_ETH_FLOW_TYPE_IPV6_OTHER] = IPPROTO_NONE,
> -		[RTE_ETH_FLOW_TYPE_FRAG_IPV6] = IPPROTO_NONE,
> +		[ETH_FLOW_TYPE_FRAG_IPV4] = IPPROTO_IP,
> +		[ETH_FLOW_TYPE_NONFRAG_IPV4_TCP] = IPPROTO_TCP,
> +		[ETH_FLOW_TYPE_NONFRAG_IPV4_UDP] = IPPROTO_UDP,
> +		[ETH_FLOW_TYPE_NONFRAG_IPV4_SCTP] = IPPROTO_SCTP,
> +		[ETH_FLOW_TYPE_NONFRAG_IPV4_OTHER] = IPPROTO_IP,
> +		[ETH_FLOW_TYPE_FRAG_IPV6] = IPPROTO_NONE,
> +		[ETH_FLOW_TYPE_NONFRAG_IPV6_TCP] = IPPROTO_TCP,
> +		[ETH_FLOW_TYPE_NONFRAG_IPV6_UDP] = IPPROTO_UDP,
> +		[ETH_FLOW_TYPE_NONFRAG_IPV6_SCTP] = IPPROTO_SCTP,
> +		[ETH_FLOW_TYPE_NONFRAG_IPV6_OTHER] = IPPROTO_NONE,
>  	};
> 
>  	switch (fdir_input->flow_type) {
> -	case RTE_ETH_FLOW_TYPE_UDPV4:
> -	case RTE_ETH_FLOW_TYPE_TCPV4:
> -	case RTE_ETH_FLOW_TYPE_SCTPV4:
> -	case RTE_ETH_FLOW_TYPE_IPV4_OTHER:
> -	case RTE_ETH_FLOW_TYPE_FRAG_IPV4:
> +	case ETH_FLOW_TYPE_NONFRAG_IPV4_TCP:
> +	case ETH_FLOW_TYPE_NONFRAG_IPV4_UDP:
> +	case ETH_FLOW_TYPE_NONFRAG_IPV4_SCTP:
> +	case ETH_FLOW_TYPE_NONFRAG_IPV4_OTHER:
> +	case ETH_FLOW_TYPE_FRAG_IPV4:
>  		ip = (struct ipv4_hdr *)(raw_pkt + sizeof(struct ether_hdr));
> 
>  		ether->ether_type = rte_cpu_to_be_16(ETHER_TYPE_IPv4);
> @@ -726,11 +726,11 @@ i40e_fdir_fill_eth_ip_head(const struct rte_eth_fdir_input *fdir_input,
>  		ip->dst_addr = fdir_input->flow.ip4_flow.src_ip;
>  		ip->next_proto_id = next_proto[fdir_input->flow_type];
>  		break;
> -	case RTE_ETH_FLOW_TYPE_UDPV6:
> -	case RTE_ETH_FLOW_TYPE_TCPV6:
> -	case RTE_ETH_FLOW_TYPE_SCTPV6:
> -	case RTE_ETH_FLOW_TYPE_IPV6_OTHER:
> -	case RTE_ETH_FLOW_TYPE_FRAG_IPV6:
> +	case ETH_FLOW_TYPE_NONFRAG_IPV6_TCP:
> +	case ETH_FLOW_TYPE_NONFRAG_IPV6_UDP:
> +	case ETH_FLOW_TYPE_NONFRAG_IPV6_SCTP:
> +	case ETH_FLOW_TYPE_NONFRAG_IPV6_OTHER:
> +	case ETH_FLOW_TYPE_FRAG_IPV6:
>  		ip6 = (struct ipv6_hdr *)(raw_pkt + sizeof(struct ether_hdr));
> 
>  		ether->ether_type = rte_cpu_to_be_16(ETHER_TYPE_IPv6);
> @@ -784,7 +784,7 @@ i40e_fdir_construct_pkt(struct i40e_pf *pf,
> 
>  	/* fill the L4 head */
>  	switch (fdir_input->flow_type) {
> -	case RTE_ETH_FLOW_TYPE_UDPV4:
> +	case ETH_FLOW_TYPE_NONFRAG_IPV4_UDP:
>  		udp = (struct udp_hdr *)(raw_pkt + sizeof(struct ether_hdr) +
>  				sizeof(struct ipv4_hdr));
>  		payload = (unsigned char *)udp + sizeof(struct udp_hdr);
> @@ -798,7 +798,7 @@ i40e_fdir_construct_pkt(struct i40e_pf *pf,
>  		udp->dgram_len = rte_cpu_to_be_16(I40E_FDIR_UDP_DEFAULT_LEN);
>  		break;
> 
> -	case RTE_ETH_FLOW_TYPE_TCPV4:
> +	case ETH_FLOW_TYPE_NONFRAG_IPV4_TCP:
>  		tcp = (struct tcp_hdr *)(raw_pkt + sizeof(struct ether_hdr) +
>  					 sizeof(struct ipv4_hdr));
>  		payload = (unsigned char *)tcp + sizeof(struct tcp_hdr);
> @@ -812,21 +812,21 @@ i40e_fdir_construct_pkt(struct i40e_pf *pf,
>  		tcp->data_off = I40E_FDIR_TCP_DEFAULT_DATAOFF;
>  		break;
> 
> -	case RTE_ETH_FLOW_TYPE_SCTPV4:
> +	case ETH_FLOW_TYPE_NONFRAG_IPV4_SCTP:
>  		sctp = (struct sctp_hdr *)(raw_pkt + sizeof(struct ether_hdr) +
>  					   sizeof(struct ipv4_hdr));
>  		payload = (unsigned char *)sctp + sizeof(struct sctp_hdr);
>  		sctp->tag = fdir_input->flow.sctp4_flow.verify_tag;
>  		break;
> 
> -	case RTE_ETH_FLOW_TYPE_IPV4_OTHER:
> -	case RTE_ETH_FLOW_TYPE_FRAG_IPV4:
> +	case ETH_FLOW_TYPE_NONFRAG_IPV4_OTHER:
> +	case ETH_FLOW_TYPE_FRAG_IPV4:
>  		payload = raw_pkt + sizeof(struct ether_hdr) +
>  			  sizeof(struct ipv4_hdr);
>  		set_idx = I40E_FLXPLD_L3_IDX;
>  		break;
> 
> -	case RTE_ETH_FLOW_TYPE_UDPV6:
> +	case ETH_FLOW_TYPE_NONFRAG_IPV6_UDP:
>  		udp = (struct udp_hdr *)(raw_pkt + sizeof(struct ether_hdr) +
>  					 sizeof(struct ipv6_hdr));
>  		payload = (unsigned char *)udp + sizeof(struct udp_hdr);
> @@ -840,7 +840,7 @@ i40e_fdir_construct_pkt(struct i40e_pf *pf,
>  		udp->dgram_len = rte_cpu_to_be_16(I40E_FDIR_IPv6_PAYLOAD_LEN);
>  		break;
> 
> -	case RTE_ETH_FLOW_TYPE_TCPV6:
> +	case ETH_FLOW_TYPE_NONFRAG_IPV6_TCP:
>  		tcp = (struct tcp_hdr *)(raw_pkt + sizeof(struct ether_hdr) +
>  					 sizeof(struct ipv6_hdr));
>  		payload = (unsigned char *)tcp + sizeof(struct tcp_hdr);
> @@ -854,15 +854,15 @@ i40e_fdir_construct_pkt(struct i40e_pf *pf,
>  		tcp->dst_port = fdir_input->flow.udp6_flow.src_port;
>  		break;
> 
> -	case RTE_ETH_FLOW_TYPE_SCTPV6:
> +	case ETH_FLOW_TYPE_NONFRAG_IPV6_SCTP:
>  		sctp = (struct sctp_hdr *)(raw_pkt + sizeof(struct ether_hdr) +
>  					   sizeof(struct ipv6_hdr));
>  		payload = (unsigned char *)sctp + sizeof(struct sctp_hdr);
>  		sctp->tag = fdir_input->flow.sctp6_flow.verify_tag;
>  		break;
> 
> -	case RTE_ETH_FLOW_TYPE_IPV6_OTHER:
> -	case RTE_ETH_FLOW_TYPE_FRAG_IPV6:
> +	case ETH_FLOW_TYPE_NONFRAG_IPV6_OTHER:
> +	case ETH_FLOW_TYPE_FRAG_IPV6:
>  		payload = raw_pkt + sizeof(struct ether_hdr) +
>  			  sizeof(struct ipv6_hdr);
>  		set_idx = I40E_FLXPLD_L3_IDX;
> @@ -1214,7 +1214,7 @@ i40e_fdir_info_get_flex_mask(struct i40e_pf *pf,
>  {
>  	struct i40e_fdir_flex_mask *mask;
>  	struct rte_eth_fdir_flex_mask *ptr = flex_mask;
> -	enum rte_eth_flow_type flow_type;
> +	uint16_t flow_type;
>  	uint8_t i, j;
>  	uint16_t off_bytes, mask_tmp;
> 
> --
> 1.9.3
Helin Zhang Dec. 22, 2014, 2:33 a.m. UTC | #2
Hi Konstantin

> > -
> > -/**
> >   * A structure used to define the input for IPV4 flow
> >   */
> >  struct rte_eth_ipv4_flow {
> > @@ -291,7 +302,7 @@ struct rte_eth_fdir_flow_ext {
> >   * A structure used to define the input for a flow director filter entry
> >   */
> >  struct rte_eth_fdir_input {
> > -	enum rte_eth_flow_type flow_type;      /**< Type of flow */
> > +	uint16_t flow_type;      /**< Type of flow */
> 
> Wonder, why do you need to switch from int to uinsigned short for flow_type?
> Konstantin

Actually there are same things in rte_ethdev.h and rte_eth_ctrl.h, though seems different.
The goal is to unify them, so the original type of MACRO was chosen. Using uint16_t but
not enum is also beneficial for compilation, as rte_eth_ctrl.h is included in rte_ethdev.h.

In rte_ethdev.h, it is,
/* Supported RSS offloads */
/* for 1G & 10G */
#define ETH_RSS_IPV4_SHIFT                    0
#define ETH_RSS_IPV4_TCP_SHIFT                1
#define ETH_RSS_IPV6_SHIFT                    2
#define ETH_RSS_IPV6_EX_SHIFT                 3
#define ETH_RSS_IPV6_TCP_SHIFT                4
#define ETH_RSS_IPV6_TCP_EX_SHIFT             5
#define ETH_RSS_IPV4_UDP_SHIFT                6
#define ETH_RSS_IPV6_UDP_SHIFT                7
#define ETH_RSS_IPV6_UDP_EX_SHIFT             8
/* for 40G only */
#define ETH_RSS_NONF_IPV4_UDP_SHIFT           31
#define ETH_RSS_NONF_IPV4_TCP_SHIFT           33
#define ETH_RSS_NONF_IPV4_SCTP_SHIFT          34
#define ETH_RSS_NONF_IPV4_OTHER_SHIFT         35
#define ETH_RSS_FRAG_IPV4_SHIFT               36
#define ETH_RSS_NONF_IPV6_UDP_SHIFT           41
#define ETH_RSS_NONF_IPV6_TCP_SHIFT           43
#define ETH_RSS_NONF_IPV6_SCTP_SHIFT          44
#define ETH_RSS_NONF_IPV6_OTHER_SHIFT         45
#define ETH_RSS_FRAG_IPV6_SHIFT               46
#define ETH_RSS_FCOE_OX_SHIFT                 48
#define ETH_RSS_FCOE_RX_SHIFT                 49
#define ETH_RSS_FCOE_OTHER_SHIFT              50
#define ETH_RSS_L2_PAYLOAD_SHIFT              63

In rte_eth_ctrl.h, it is,
/**
 * Flow type
 */
enum rte_eth_flow_type {
	RTE_ETH_FLOW_TYPE_NONE = 0,
	RTE_ETH_FLOW_TYPE_UDPV4,
	RTE_ETH_FLOW_TYPE_TCPV4,
	RTE_ETH_FLOW_TYPE_SCTPV4,
	RTE_ETH_FLOW_TYPE_IPV4_OTHER,
	RTE_ETH_FLOW_TYPE_FRAG_IPV4,
	RTE_ETH_FLOW_TYPE_UDPV6,
	RTE_ETH_FLOW_TYPE_TCPV6,
	RTE_ETH_FLOW_TYPE_SCTPV6,
	RTE_ETH_FLOW_TYPE_IPV6_OTHER,
	RTE_ETH_FLOW_TYPE_FRAG_IPV6,
	RTE_ETH_FLOW_TYPE_MAX = 64,
};

Regards,
Helin

> 
> >  	union rte_eth_fdir_flow flow;
> >  	/**< Flow fields to match, dependent on flow_type */
> >  	struct rte_eth_fdir_flow_ext flow_ext; @@ -371,7 +382,7 @@ struct
> > rte_eth_flex_payload_cfg {
> >   * for each flow type
> >   */
> >  struct rte_eth_fdir_flex_mask {
> > -	enum rte_eth_flow_type flow_type;  /**< Flow type */
> > +	uint16_t flow_type;  /**< Flow type */
> >  	uint8_t mask[RTE_ETH_FDIR_MAX_FLEXLEN];
> >  	/**< Mask for the whole flexible payload */  }; @@ -385,7 +396,7 @@
> > struct rte_eth_fdir_flex_conf {
> >  	uint16_t nb_flexmasks; /**< The number of following mask */
> >  	struct rte_eth_flex_payload_cfg flex_set[RTE_ETH_PAYLOAD_MAX];
> >  	/**< Flex payload configuration for each payload type */
> > -	struct rte_eth_fdir_flex_mask flex_mask[RTE_ETH_FLOW_TYPE_MAX];
> > +	struct rte_eth_fdir_flex_mask flex_mask[ETH_FLOW_TYPE_MAX];
> >  	/**< Flex mask configuration for each flow type */  };
diff mbox

Patch

diff --git a/app/test-pmd/cmdline.c b/app/test-pmd/cmdline.c
index 882a5a2..e7bab0c 100644
--- a/app/test-pmd/cmdline.c
+++ b/app/test-pmd/cmdline.c
@@ -707,7 +707,7 @@  static void cmd_help_long_parsed(void *parsed_result,
 			"    get info of a flex filter.\n\n"
 
 			"flow_director_filter (port_id) (add|del)"
-			" flow (ip4|ip4-frag|ip6|ip6-frag)"
+			" flow (ipv4-other|ipv4-frag|ipv6-other|ipv6-frag)"
 			" src (src_ip_address) dst (dst_ip_address)"
 			" flexbytes (flexbytes_value)"
 			" (drop|fwd) queue (queue_id) fd_id (fd_id_value)\n"
@@ -733,7 +733,8 @@  static void cmd_help_long_parsed(void *parsed_result,
 			"    Flush all flow director entries of a device.\n\n"
 
 			"flow_director_flex_mask (port_id)"
-			" flow (ip4|ip4-frag|tcp4|udp4|sctp4|ip6|ip6-frag|tcp6|udp6|sctp6|all)"
+			" flow (ipv4-other|ipv4-frag|ipv4-tcp|ipv4-udp|ipv4-sctp|"
+			"ipv6-other|ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|all)"
 			" (mask)\n"
 			"    Configure mask of flex payload.\n\n"
 
@@ -8158,31 +8159,34 @@  parse_flexbytes(const char *q_arg, uint8_t *flexbytes, uint16_t max_num)
 	return ret;
 }
 
-static enum rte_eth_flow_type
+static uint16_t
 str2flowtype(char *string)
 {
 	uint8_t i = 0;
 	static const struct {
 		char str[32];
-		enum rte_eth_flow_type type;
+		uint16_t type;
 	} flowtype_str[] = {
-		{"ip4", RTE_ETH_FLOW_TYPE_IPV4_OTHER},
-		{"ip4-frag", RTE_ETH_FLOW_TYPE_FRAG_IPV4},
-		{"udp4", RTE_ETH_FLOW_TYPE_UDPV4},
-		{"tcp4", RTE_ETH_FLOW_TYPE_TCPV4},
-		{"sctp4", RTE_ETH_FLOW_TYPE_SCTPV4},
-		{"ip6", RTE_ETH_FLOW_TYPE_IPV6_OTHER},
-		{"ip6-frag", RTE_ETH_FLOW_TYPE_FRAG_IPV6},
-		{"udp6", RTE_ETH_FLOW_TYPE_UDPV6},
-		{"tcp6", RTE_ETH_FLOW_TYPE_TCPV6},
-		{"sctp6", RTE_ETH_FLOW_TYPE_TCPV6},
+		{"ipv4", ETH_FLOW_TYPE_IPV4},
+		{"ipv4-frag", ETH_FLOW_TYPE_FRAG_IPV4},
+		{"ipv4-tcp", ETH_FLOW_TYPE_NONFRAG_IPV4_TCP},
+		{"ipv4-udp", ETH_FLOW_TYPE_NONFRAG_IPV4_UDP},
+		{"ipv4-sctp", ETH_FLOW_TYPE_NONFRAG_IPV4_SCTP},
+		{"ipv4-other", ETH_FLOW_TYPE_NONFRAG_IPV4_OTHER},
+		{"ipv6", ETH_FLOW_TYPE_IPV6},
+		{"ipv6-frag", ETH_FLOW_TYPE_FRAG_IPV6},
+		{"ipv6-tcp", ETH_FLOW_TYPE_NONFRAG_IPV6_TCP},
+		{"ipv6-udp", ETH_FLOW_TYPE_NONFRAG_IPV6_UDP},
+		{"ipv6-sctp", ETH_FLOW_TYPE_NONFRAG_IPV6_SCTP},
+		{"ipv6-other", ETH_FLOW_TYPE_NONFRAG_IPV6_OTHER},
+		{"l2_payload", ETH_FLOW_TYPE_L2_PAYLOAD},
 	};
 
 	for (i = 0; i < RTE_DIM(flowtype_str); i++) {
 		if (!strcmp(flowtype_str[i].str, string))
 			return flowtype_str[i].type;
 	}
-	return RTE_ETH_FLOW_TYPE_NONE;
+	return ETH_FLOW_TYPE_UNKNOWN;
 }
 
 #define IPV4_ADDR_TO_UINT(ip_addr, ip) \
@@ -8235,9 +8239,9 @@  cmd_flow_director_filter_parsed(void *parsed_result,
 
 	entry.input.flow_type = str2flowtype(res->flow_type);
 	switch (entry.input.flow_type) {
-	case RTE_ETH_FLOW_TYPE_IPV4_OTHER:
-	case RTE_ETH_FLOW_TYPE_UDPV4:
-	case RTE_ETH_FLOW_TYPE_TCPV4:
+	case ETH_FLOW_TYPE_NONFRAG_IPV4_OTHER:
+	case ETH_FLOW_TYPE_NONFRAG_IPV4_UDP:
+	case ETH_FLOW_TYPE_NONFRAG_IPV4_TCP:
 		IPV4_ADDR_TO_UINT(res->ip_dst,
 			entry.input.flow.ip4_flow.dst_ip);
 		IPV4_ADDR_TO_UINT(res->ip_src,
@@ -8248,7 +8252,7 @@  cmd_flow_director_filter_parsed(void *parsed_result,
 		entry.input.flow.udp4_flow.src_port =
 				rte_cpu_to_be_16(res->port_src);
 		break;
-	case RTE_ETH_FLOW_TYPE_SCTPV4:
+	case ETH_FLOW_TYPE_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,
@@ -8257,9 +8261,9 @@  cmd_flow_director_filter_parsed(void *parsed_result,
 		entry.input.flow.sctp4_flow.verify_tag =
 				rte_cpu_to_be_32(res->verify_tag_value);
 		break;
-	case RTE_ETH_FLOW_TYPE_IPV6_OTHER:
-	case RTE_ETH_FLOW_TYPE_UDPV6:
-	case RTE_ETH_FLOW_TYPE_TCPV6:
+	case ETH_FLOW_TYPE_NONFRAG_IPV6_OTHER:
+	case ETH_FLOW_TYPE_NONFRAG_IPV6_UDP:
+	case ETH_FLOW_TYPE_NONFRAG_IPV6_TCP:
 		IPV6_ADDR_TO_ARRAY(res->ip_dst,
 			entry.input.flow.ipv6_flow.dst_ip);
 		IPV6_ADDR_TO_ARRAY(res->ip_src,
@@ -8270,7 +8274,7 @@  cmd_flow_director_filter_parsed(void *parsed_result,
 		entry.input.flow.udp6_flow.src_port =
 				rte_cpu_to_be_16(res->port_src);
 		break;
-	case RTE_ETH_FLOW_TYPE_SCTPV6:
+	case ETH_FLOW_TYPE_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,
@@ -8321,9 +8325,8 @@  cmdline_parse_token_string_t cmd_flow_director_flow =
 				 flow, "flow");
 cmdline_parse_token_string_t cmd_flow_director_flow_type =
 	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
-				 flow_type,
-				 "ip4#ip4-frag#tcp4#udp4#sctp4#"
-				 "ip6#ip6-frag#tcp6#udp6#sctp6");
+		flow_type, "ipv4-other#ipv4-frag#ipv4-tcp#ipv4-udp#ipv4-sctp#"
+		"ipv6-other#ipv6-frag#ipv6-tcp#ipv6-udp#ipv6-sctp");
 cmdline_parse_token_string_t cmd_flow_director_src =
 	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_result,
 				 src, "src");
@@ -8511,7 +8514,9 @@  cmd_flow_director_flex_mask_parsed(void *parsed_result,
 	struct cmd_flow_director_flex_mask_result *res = parsed_result;
 	struct rte_eth_fdir_flex_mask flex_mask;
 	struct rte_port *port;
-	enum rte_eth_flow_type i;
+	struct rte_eth_fdir_info fdir_info;
+	uint32_t flow_type_mask;
+	uint16_t i;
 	int ret;
 
 	if (res->port_id > nb_ports) {
@@ -8534,10 +8539,23 @@  cmd_flow_director_flex_mask_parsed(void *parsed_result,
 		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;
+	}
+	flow_type_mask = fdir_info.flow_types_mask[0];
 	if (!strcmp(res->flow_type, "all")) {
-		for (i = RTE_ETH_FLOW_TYPE_UDPV4;
-		     i <= RTE_ETH_FLOW_TYPE_FRAG_IPV6;
-		     i++) {
+		if (!flow_type_mask) {
+			printf("No flow type supported\n");
+			return;
+		}
+		for (i = ETH_FLOW_TYPE_UNKNOWN; i < ETH_FLOW_TYPE_MAX; i++) {
+			if (!(flow_type_mask & (1 << i)))
+				continue;
 			flex_mask.flow_type = i;
 			fdir_set_flex_mask(res->port_id, &flex_mask);
 		}
@@ -8545,6 +8563,11 @@  cmd_flow_director_flex_mask_parsed(void *parsed_result,
 		return;
 	}
 	flex_mask.flow_type = str2flowtype(res->flow_type);
+	if (!(flow_type_mask & (1 << 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);
 }
@@ -8561,9 +8584,8 @@  cmdline_parse_token_string_t cmd_flow_director_flexmask_flow =
 				 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,
-				"ip4#ip4-frag#tcp4#udp4#sctp4#"
-				"ip6#ip6-frag#tcp6#udp6#sctp6#all");
+		flow_type, "ipv4-other#ipv4-frag#ipv4-tcp#ipv4-udp#ipv4-sctp#"
+		"ipv6-other#ipv6-frag#ipv6-tcp#ipv6-udp#ipv6-sctp#all");
 cmdline_parse_token_string_t cmd_flow_director_flexmask_mask =
 	TOKEN_STRING_INITIALIZER(struct cmd_flow_director_flex_mask_result,
 				 mask, NULL);
diff --git a/app/test-pmd/config.c b/app/test-pmd/config.c
index 87dedf9..4c61a07 100644
--- a/app/test-pmd/config.c
+++ b/app/test-pmd/config.c
@@ -96,19 +96,7 @@ 
 
 #include "testpmd.h"
 
-static const char *flowtype_str[RTE_ETH_FLOW_TYPE_MAX] = {
-	NULL,
-	"udp4",
-	"tcp4",
-	"sctp4",
-	"ip4",
-	"ip4-frag",
-	"udp6",
-	"tcp6",
-	"sctp6",
-	"ip6",
-	"ip6-frag",
-};
+static char *flowtype_to_str(uint16_t flow_type);
 
 static void
 print_ethaddr(const char *name, struct ether_addr *eth_addr)
@@ -1843,15 +1831,50 @@  print_fdir_flex_payload(struct rte_eth_fdir_flex_conf *flex_conf)
 	printf("\n");
 }
 
+static char *
+flowtype_to_str(uint16_t flow_type)
+{
+	struct flow_type_info {
+		char str[32];
+		uint16_t ftype;
+	};
+
+	uint8_t i;
+	static struct flow_type_info flowtype_str_table[] = {
+		{"ipv4", ETH_FLOW_TYPE_IPV4},
+		{"ipv4-frag", ETH_FLOW_TYPE_FRAG_IPV4},
+		{"ipv4-tcp", ETH_FLOW_TYPE_NONFRAG_IPV4_TCP},
+		{"ipv4-udp", ETH_FLOW_TYPE_NONFRAG_IPV4_UDP},
+		{"ipv4-sctp", ETH_FLOW_TYPE_NONFRAG_IPV4_SCTP},
+		{"ipv4-other", ETH_FLOW_TYPE_NONFRAG_IPV4_OTHER},
+		{"ipv6", ETH_FLOW_TYPE_IPV6},
+		{"ipv6-frag", ETH_FLOW_TYPE_FRAG_IPV6},
+		{"ipv6-tcp", ETH_FLOW_TYPE_NONFRAG_IPV6_TCP},
+		{"ipv6-udp", ETH_FLOW_TYPE_NONFRAG_IPV6_UDP},
+		{"ipv6-sctp", ETH_FLOW_TYPE_NONFRAG_IPV6_SCTP},
+		{"ipv6-other", ETH_FLOW_TYPE_NONFRAG_IPV6_OTHER},
+		{"l2_payload", ETH_FLOW_TYPE_L2_PAYLOAD},
+	};
+
+	for (i = 0; i < RTE_DIM(flowtype_str_table); i++) {
+		if (flowtype_str_table[i].ftype == flow_type)
+			return flowtype_str_table[i].str;
+	}
+
+	return NULL;
+}
+
 static inline void
 print_fdir_flex_mask(struct rte_eth_fdir_flex_conf *flex_conf)
 {
 	struct rte_eth_fdir_flex_mask *mask;
 	int i, j;
+	char *p;
 
 	for (i = 0; i < flex_conf->nb_flexmasks; i++) {
 		mask = &flex_conf->flex_mask[i];
-		printf("\n    %s:\t", flowtype_str[mask->flow_type]);
+		p = flowtype_to_str(mask->flow_type);
+		printf("\n    %s:\t", p ? p : "unknown");
 		for (j = 0; j < RTE_ETH_FDIR_MAX_FLEXLEN; j++)
 			printf(" %02x", mask->mask[j]);
 	}
@@ -1861,13 +1884,17 @@  print_fdir_flex_mask(struct rte_eth_fdir_flex_conf *flex_conf)
 static inline void
 print_fdir_flow_type(uint32_t flow_types_mask)
 {
-	int i = 0;
+	int i;
+	char *p;
 
-	for (i = RTE_ETH_FLOW_TYPE_UDPV4;
-	     i <= RTE_ETH_FLOW_TYPE_FRAG_IPV6;
-	     i++) {
-		if (flow_types_mask & (1 << i))
-			printf(" %s", flowtype_str[i]);
+	for (i = ETH_FLOW_TYPE_UNKNOWN; i < ETH_FLOW_TYPE_MAX; i++) {
+		if (!(flow_types_mask & (1 << i)))
+			continue;
+		p = flowtype_to_str(i);
+		if (p)
+			printf(" %s", p);
+		else
+			printf(" unknown");
 	}
 	printf("\n");
 }
@@ -2028,13 +2055,13 @@  fdir_set_flex_mask(portid_t port_id, struct rte_eth_fdir_flex_mask *cfg)
 
 	port = &ports[port_id];
 	flex_conf = &port->dev_conf.fdir_conf.flex_conf;
-	for (i = 0; i < RTE_ETH_FLOW_TYPE_MAX; i++) {
+	for (i = 0; i < ETH_FLOW_TYPE_MAX; i++) {
 		if (cfg->flow_type == flex_conf->flex_mask[i].flow_type) {
 			idx = i;
 			break;
 		}
 	}
-	if (i >= RTE_ETH_FLOW_TYPE_MAX) {
+	if (i >= ETH_FLOW_TYPE_MAX) {
 		if (flex_conf->nb_flexmasks < RTE_DIM(flex_conf->flex_mask)) {
 			idx = flex_conf->nb_flexmasks;
 			flex_conf->nb_flexmasks++;
diff --git a/lib/librte_ether/rte_eth_ctrl.h b/lib/librte_ether/rte_eth_ctrl.h
index 1c15ed0..9f99fe7 100644
--- a/lib/librte_ether/rte_eth_ctrl.h
+++ b/lib/librte_ether/rte_eth_ctrl.h
@@ -46,6 +46,35 @@ 
 extern "C" {
 #endif
 
+/*
+ * A packet can be identified by hardware as different flow types. Different
+ * NIC hardwares may support different flow types.
+ * Basically, the NIC hardware identifies the flow type as deep protocol as
+ * possible, and exclusively. For example, if a packet is identified as
+ * 'ETH_FLOW_TYPE_NONFRAG_IPV4_TCP', it will not be any of other flow types,
+ * though it is a actual IPV4 packet.
+ * Note that the flow types are used to define RSS offload types in
+ * rte_ethdev.h.
+ */
+#define ETH_FLOW_TYPE_UNKNOWN            0
+#define ETH_FLOW_TYPE_IPV4               1
+#define ETH_FLOW_TYPE_FRAG_IPV4          2
+#define ETH_FLOW_TYPE_NONFRAG_IPV4_TCP   3
+#define ETH_FLOW_TYPE_NONFRAG_IPV4_UDP   4
+#define ETH_FLOW_TYPE_NONFRAG_IPV4_SCTP  5
+#define ETH_FLOW_TYPE_NONFRAG_IPV4_OTHER 6
+#define ETH_FLOW_TYPE_IPV6               7
+#define ETH_FLOW_TYPE_FRAG_IPV6          8
+#define ETH_FLOW_TYPE_NONFRAG_IPV6_TCP   9
+#define ETH_FLOW_TYPE_NONFRAG_IPV6_UDP   10
+#define ETH_FLOW_TYPE_NONFRAG_IPV6_SCTP  11
+#define ETH_FLOW_TYPE_NONFRAG_IPV6_OTHER 12
+#define ETH_FLOW_TYPE_L2_PAYLOAD         13
+#define ETH_FLOW_TYPE_IPV6_EX            14
+#define ETH_FLOW_TYPE_IPV6_TCP_EX        15
+#define ETH_FLOW_TYPE_IPV6_UDP_EX        16
+#define ETH_FLOW_TYPE_MAX                17
+
 /**
  * Feature filter types
  */
@@ -179,24 +208,6 @@  struct rte_eth_tunnel_filter_conf {
 #define RTE_ETH_FDIR_MAX_FLEXLEN         16 /** < Max length of flexbytes. */
 
 /**
- * Flow type
- */
-enum rte_eth_flow_type {
-	RTE_ETH_FLOW_TYPE_NONE = 0,
-	RTE_ETH_FLOW_TYPE_UDPV4,
-	RTE_ETH_FLOW_TYPE_TCPV4,
-	RTE_ETH_FLOW_TYPE_SCTPV4,
-	RTE_ETH_FLOW_TYPE_IPV4_OTHER,
-	RTE_ETH_FLOW_TYPE_FRAG_IPV4,
-	RTE_ETH_FLOW_TYPE_UDPV6,
-	RTE_ETH_FLOW_TYPE_TCPV6,
-	RTE_ETH_FLOW_TYPE_SCTPV6,
-	RTE_ETH_FLOW_TYPE_IPV6_OTHER,
-	RTE_ETH_FLOW_TYPE_FRAG_IPV6,
-	RTE_ETH_FLOW_TYPE_MAX = 64,
-};
-
-/**
  * A structure used to define the input for IPV4 flow
  */
 struct rte_eth_ipv4_flow {
@@ -291,7 +302,7 @@  struct rte_eth_fdir_flow_ext {
  * A structure used to define the input for a flow director filter entry
  */
 struct rte_eth_fdir_input {
-	enum rte_eth_flow_type flow_type;      /**< Type of flow */
+	uint16_t flow_type;      /**< Type of flow */
 	union rte_eth_fdir_flow flow;
 	/**< Flow fields to match, dependent on flow_type */
 	struct rte_eth_fdir_flow_ext flow_ext;
@@ -371,7 +382,7 @@  struct rte_eth_flex_payload_cfg {
  * for each flow type
  */
 struct rte_eth_fdir_flex_mask {
-	enum rte_eth_flow_type flow_type;  /**< Flow type */
+	uint16_t flow_type;  /**< Flow type */
 	uint8_t mask[RTE_ETH_FDIR_MAX_FLEXLEN];
 	/**< Mask for the whole flexible payload */
 };
@@ -385,7 +396,7 @@  struct rte_eth_fdir_flex_conf {
 	uint16_t nb_flexmasks; /**< The number of following mask */
 	struct rte_eth_flex_payload_cfg flex_set[RTE_ETH_PAYLOAD_MAX];
 	/**< Flex payload configuration for each payload type */
-	struct rte_eth_fdir_flex_mask flex_mask[RTE_ETH_FLOW_TYPE_MAX];
+	struct rte_eth_fdir_flex_mask flex_mask[ETH_FLOW_TYPE_MAX];
 	/**< Flex mask configuration for each flow type */
 };
 
@@ -400,7 +411,7 @@  enum rte_fdir_mode {
 
 #define UINT32_BIT (CHAR_BIT * sizeof(uint32_t))
 #define RTE_FLOW_TYPE_MASK_ARRAY_SIZE \
-	(RTE_ALIGN(RTE_ETH_FLOW_TYPE_MAX, UINT32_BIT)/UINT32_BIT)
+	(RTE_ALIGN(ETH_FLOW_TYPE_MAX, UINT32_BIT)/UINT32_BIT)
 
 /**
  * A structure used to get the information of flow director filter.
diff --git a/lib/librte_pmd_i40e/i40e_ethdev.c b/lib/librte_pmd_i40e/i40e_ethdev.c
index b47a3d2..de1eff4 100644
--- a/lib/librte_pmd_i40e/i40e_ethdev.c
+++ b/lib/librte_pmd_i40e/i40e_ethdev.c
@@ -5261,46 +5261,56 @@  i40e_dev_filter_ctrl(struct rte_eth_dev *dev,
 }
 
 enum i40e_filter_pctype
-i40e_flowtype_to_pctype(enum rte_eth_flow_type flow_type)
+i40e_flowtype_to_pctype(uint16_t flow_type)
 {
 	static const enum i40e_filter_pctype pctype_table[] = {
-		[RTE_ETH_FLOW_TYPE_UDPV4] = I40E_FILTER_PCTYPE_NONF_IPV4_UDP,
-		[RTE_ETH_FLOW_TYPE_TCPV4] = I40E_FILTER_PCTYPE_NONF_IPV4_TCP,
-		[RTE_ETH_FLOW_TYPE_SCTPV4] = I40E_FILTER_PCTYPE_NONF_IPV4_SCTP,
-		[RTE_ETH_FLOW_TYPE_IPV4_OTHER] =
-					I40E_FILTER_PCTYPE_NONF_IPV4_OTHER,
-		[RTE_ETH_FLOW_TYPE_FRAG_IPV4] =
-					I40E_FILTER_PCTYPE_FRAG_IPV4,
-		[RTE_ETH_FLOW_TYPE_UDPV6] = I40E_FILTER_PCTYPE_NONF_IPV6_UDP,
-		[RTE_ETH_FLOW_TYPE_TCPV6] = I40E_FILTER_PCTYPE_NONF_IPV6_TCP,
-		[RTE_ETH_FLOW_TYPE_SCTPV6] = I40E_FILTER_PCTYPE_NONF_IPV6_SCTP,
-		[RTE_ETH_FLOW_TYPE_IPV6_OTHER] =
-					I40E_FILTER_PCTYPE_NONF_IPV6_OTHER,
-		[RTE_ETH_FLOW_TYPE_FRAG_IPV6] =
-					I40E_FILTER_PCTYPE_FRAG_IPV6,
+		[ETH_FLOW_TYPE_FRAG_IPV4] = I40E_FILTER_PCTYPE_FRAG_IPV4,
+		[ETH_FLOW_TYPE_NONFRAG_IPV4_UDP] =
+			I40E_FILTER_PCTYPE_NONF_IPV4_UDP,
+		[ETH_FLOW_TYPE_NONFRAG_IPV4_TCP] =
+			I40E_FILTER_PCTYPE_NONF_IPV4_TCP,
+		[ETH_FLOW_TYPE_NONFRAG_IPV4_SCTP] =
+			I40E_FILTER_PCTYPE_NONF_IPV4_SCTP,
+		[ETH_FLOW_TYPE_NONFRAG_IPV4_OTHER] =
+			I40E_FILTER_PCTYPE_NONF_IPV4_OTHER,
+		[ETH_FLOW_TYPE_FRAG_IPV6] = I40E_FILTER_PCTYPE_FRAG_IPV6,
+		[ETH_FLOW_TYPE_NONFRAG_IPV6_UDP] =
+			I40E_FILTER_PCTYPE_NONF_IPV6_UDP,
+		[ETH_FLOW_TYPE_NONFRAG_IPV6_TCP] =
+			I40E_FILTER_PCTYPE_NONF_IPV6_TCP,
+		[ETH_FLOW_TYPE_NONFRAG_IPV6_SCTP] =
+			I40E_FILTER_PCTYPE_NONF_IPV6_SCTP,
+		[ETH_FLOW_TYPE_NONFRAG_IPV6_OTHER] =
+			I40E_FILTER_PCTYPE_NONF_IPV6_OTHER,
+		[ETH_FLOW_TYPE_L2_PAYLOAD] = I40E_FILTER_PCTYPE_L2_PAYLOAD,
 	};
 
 	return pctype_table[flow_type];
 }
 
-enum rte_eth_flow_type
+uint16_t
 i40e_pctype_to_flowtype(enum i40e_filter_pctype pctype)
 {
-	static const enum rte_eth_flow_type flowtype_table[] = {
-		[I40E_FILTER_PCTYPE_NONF_IPV4_UDP] = RTE_ETH_FLOW_TYPE_UDPV4,
-		[I40E_FILTER_PCTYPE_NONF_IPV4_TCP] = RTE_ETH_FLOW_TYPE_TCPV4,
-		[I40E_FILTER_PCTYPE_NONF_IPV4_SCTP] = RTE_ETH_FLOW_TYPE_SCTPV4,
+	static const uint16_t flowtype_table[] = {
+		[I40E_FILTER_PCTYPE_FRAG_IPV4] = ETH_FLOW_TYPE_FRAG_IPV4,
+		[I40E_FILTER_PCTYPE_NONF_IPV4_UDP] =
+			ETH_FLOW_TYPE_NONFRAG_IPV4_UDP,
+		[I40E_FILTER_PCTYPE_NONF_IPV4_TCP] =
+			ETH_FLOW_TYPE_NONFRAG_IPV4_TCP,
+		[I40E_FILTER_PCTYPE_NONF_IPV4_SCTP] =
+			ETH_FLOW_TYPE_NONFRAG_IPV4_SCTP,
 		[I40E_FILTER_PCTYPE_NONF_IPV4_OTHER] =
-					RTE_ETH_FLOW_TYPE_IPV4_OTHER,
-		[I40E_FILTER_PCTYPE_FRAG_IPV4] =
-					RTE_ETH_FLOW_TYPE_FRAG_IPV4,
-		[I40E_FILTER_PCTYPE_NONF_IPV6_UDP] = RTE_ETH_FLOW_TYPE_UDPV6,
-		[I40E_FILTER_PCTYPE_NONF_IPV6_TCP] = RTE_ETH_FLOW_TYPE_TCPV6,
-		[I40E_FILTER_PCTYPE_NONF_IPV6_SCTP] = RTE_ETH_FLOW_TYPE_SCTPV6,
+			ETH_FLOW_TYPE_NONFRAG_IPV4_OTHER,
+		[I40E_FILTER_PCTYPE_FRAG_IPV6] = ETH_FLOW_TYPE_FRAG_IPV6,
+		[I40E_FILTER_PCTYPE_NONF_IPV6_UDP] =
+			ETH_FLOW_TYPE_NONFRAG_IPV6_UDP,
+		[I40E_FILTER_PCTYPE_NONF_IPV6_TCP] =
+			ETH_FLOW_TYPE_NONFRAG_IPV6_TCP,
+		[I40E_FILTER_PCTYPE_NONF_IPV6_SCTP] =
+			ETH_FLOW_TYPE_NONFRAG_IPV6_SCTP,
 		[I40E_FILTER_PCTYPE_NONF_IPV6_OTHER] =
-					RTE_ETH_FLOW_TYPE_IPV6_OTHER,
-		[I40E_FILTER_PCTYPE_FRAG_IPV6] =
-					RTE_ETH_FLOW_TYPE_FRAG_IPV6,
+			ETH_FLOW_TYPE_NONFRAG_IPV6_OTHER,
+		[I40E_FILTER_PCTYPE_L2_PAYLOAD] = ETH_FLOW_TYPE_L2_PAYLOAD,
 	};
 
 	return flowtype_table[pctype];
diff --git a/lib/librte_pmd_i40e/i40e_ethdev.h b/lib/librte_pmd_i40e/i40e_ethdev.h
index f913ea9..e2a8db3 100644
--- a/lib/librte_pmd_i40e/i40e_ethdev.h
+++ b/lib/librte_pmd_i40e/i40e_ethdev.h
@@ -471,10 +471,8 @@  const struct rte_memzone *i40e_memzone_reserve(const char *name,
 					int socket_id);
 int i40e_fdir_configure(struct rte_eth_dev *dev);
 void i40e_fdir_teardown(struct i40e_pf *pf);
-enum i40e_filter_pctype i40e_flowtype_to_pctype(
-				enum rte_eth_flow_type flow_type);
-enum rte_eth_flow_type i40e_pctype_to_flowtype(
-				enum i40e_filter_pctype pctype);
+enum i40e_filter_pctype i40e_flowtype_to_pctype(uint16_t flow_type);
+uint16_t i40e_pctype_to_flowtype(enum i40e_filter_pctype pctype);
 int i40e_fdir_ctrl_func(struct rte_eth_dev *dev,
 			  enum rte_filter_op filter_op,
 			  void *arg);
@@ -541,27 +539,29 @@  i40e_init_adminq_parameter(struct i40e_hw *hw)
 }
 
 #define I40E_VALID_FLOW_TYPE(flow_type) \
-	((flow_type) == RTE_ETH_FLOW_TYPE_UDPV4 || \
-	(flow_type) == RTE_ETH_FLOW_TYPE_TCPV4 || \
-	(flow_type) == RTE_ETH_FLOW_TYPE_SCTPV4 || \
-	(flow_type) == RTE_ETH_FLOW_TYPE_IPV4_OTHER || \
-	(flow_type) == RTE_ETH_FLOW_TYPE_FRAG_IPV4 || \
-	(flow_type) == RTE_ETH_FLOW_TYPE_UDPV6 || \
-	(flow_type) == RTE_ETH_FLOW_TYPE_TCPV6 || \
-	(flow_type) == RTE_ETH_FLOW_TYPE_SCTPV6 || \
-	(flow_type) == RTE_ETH_FLOW_TYPE_IPV6_OTHER || \
-	(flow_type) == RTE_ETH_FLOW_TYPE_FRAG_IPV6)
+	((flow_type) == ETH_FLOW_TYPE_FRAG_IPV4 || \
+	(flow_type) == ETH_FLOW_TYPE_NONFRAG_IPV4_TCP || \
+	(flow_type) == ETH_FLOW_TYPE_NONFRAG_IPV4_UDP || \
+	(flow_type) == ETH_FLOW_TYPE_NONFRAG_IPV4_SCTP || \
+	(flow_type) == ETH_FLOW_TYPE_NONFRAG_IPV4_OTHER || \
+	(flow_type) == ETH_FLOW_TYPE_FRAG_IPV6 || \
+	(flow_type) == ETH_FLOW_TYPE_NONFRAG_IPV6_TCP || \
+	(flow_type) == ETH_FLOW_TYPE_NONFRAG_IPV6_UDP || \
+	(flow_type) == ETH_FLOW_TYPE_NONFRAG_IPV6_SCTP || \
+	(flow_type) == ETH_FLOW_TYPE_NONFRAG_IPV6_OTHER || \
+	(flow_type) == ETH_FLOW_TYPE_L2_PAYLOAD)
 
 #define I40E_VALID_PCTYPE(pctype) \
-	((pctype) == I40E_FILTER_PCTYPE_NONF_IPV4_UDP || \
+	((pctype) == I40E_FILTER_PCTYPE_FRAG_IPV4 || \
 	(pctype) == I40E_FILTER_PCTYPE_NONF_IPV4_TCP || \
+	(pctype) == I40E_FILTER_PCTYPE_NONF_IPV4_UDP || \
 	(pctype) == I40E_FILTER_PCTYPE_NONF_IPV4_SCTP || \
 	(pctype) == I40E_FILTER_PCTYPE_NONF_IPV4_OTHER || \
-	(pctype) == I40E_FILTER_PCTYPE_FRAG_IPV4 || \
+	(pctype) == I40E_FILTER_PCTYPE_FRAG_IPV6 || \
 	(pctype) == I40E_FILTER_PCTYPE_NONF_IPV6_UDP || \
 	(pctype) == I40E_FILTER_PCTYPE_NONF_IPV6_TCP || \
 	(pctype) == I40E_FILTER_PCTYPE_NONF_IPV6_SCTP || \
 	(pctype) == I40E_FILTER_PCTYPE_NONF_IPV6_OTHER || \
-	(pctype) == I40E_FILTER_PCTYPE_FRAG_IPV6)
+	(pctype) == I40E_FILTER_PCTYPE_L2_PAYLOAD)
 
 #endif /* _I40E_ETHDEV_H_ */
diff --git a/lib/librte_pmd_i40e/i40e_fdir.c b/lib/librte_pmd_i40e/i40e_fdir.c
index c9e535b..9bdcabf 100644
--- a/lib/librte_pmd_i40e/i40e_fdir.c
+++ b/lib/librte_pmd_i40e/i40e_fdir.c
@@ -95,16 +95,16 @@ 
 			I40E_PRTQF_FLX_PIT_DEST_OFF_MASK))
 
 #define I40E_FDIR_FLOW_TYPES ( \
-	(1 << RTE_ETH_FLOW_TYPE_UDPV4) | \
-	(1 << RTE_ETH_FLOW_TYPE_TCPV4) | \
-	(1 << RTE_ETH_FLOW_TYPE_SCTPV4) | \
-	(1 << RTE_ETH_FLOW_TYPE_IPV4_OTHER) | \
-	(1 << RTE_ETH_FLOW_TYPE_FRAG_IPV4) | \
-	(1 << RTE_ETH_FLOW_TYPE_UDPV6) | \
-	(1 << RTE_ETH_FLOW_TYPE_TCPV6) | \
-	(1 << RTE_ETH_FLOW_TYPE_SCTPV6) | \
-	(1 << RTE_ETH_FLOW_TYPE_IPV6_OTHER) | \
-	(1 << RTE_ETH_FLOW_TYPE_FRAG_IPV6))
+	(1 << ETH_FLOW_TYPE_FRAG_IPV4) | \
+	(1 << ETH_FLOW_TYPE_NONFRAG_IPV4_UDP) | \
+	(1 << ETH_FLOW_TYPE_NONFRAG_IPV4_TCP) | \
+	(1 << ETH_FLOW_TYPE_NONFRAG_IPV4_SCTP) | \
+	(1 << ETH_FLOW_TYPE_NONFRAG_IPV4_OTHER) | \
+	(1 << ETH_FLOW_TYPE_FRAG_IPV6) | \
+	(1 << ETH_FLOW_TYPE_NONFRAG_IPV6_UDP) | \
+	(1 << ETH_FLOW_TYPE_NONFRAG_IPV6_TCP) | \
+	(1 << ETH_FLOW_TYPE_NONFRAG_IPV6_SCTP) | \
+	(1 << ETH_FLOW_TYPE_NONFRAG_IPV6_OTHER))
 
 #define I40E_FLEX_WORD_MASK(off) (0x80 >> (off))
 
@@ -498,7 +498,7 @@  i40e_check_fdir_flex_conf(const struct rte_eth_fdir_flex_conf *conf)
 	}
 
 	/* check flex mask setting configuration */
-	if (conf->nb_flexmasks > RTE_ETH_FLOW_TYPE_FRAG_IPV6) {
+	if (conf->nb_flexmasks >= ETH_FLOW_TYPE_MAX) {
 		PMD_DRV_LOG(ERR, "invalid number of flex masks.");
 		return -EINVAL;
 	}
@@ -692,24 +692,24 @@  i40e_fdir_fill_eth_ip_head(const struct rte_eth_fdir_input *fdir_input,
 	struct ipv4_hdr *ip;
 	struct ipv6_hdr *ip6;
 	static const uint8_t next_proto[] = {
-		[RTE_ETH_FLOW_TYPE_UDPV4] = IPPROTO_UDP,
-		[RTE_ETH_FLOW_TYPE_TCPV4] = IPPROTO_TCP,
-		[RTE_ETH_FLOW_TYPE_SCTPV4] = IPPROTO_SCTP,
-		[RTE_ETH_FLOW_TYPE_IPV4_OTHER] = IPPROTO_IP,
-		[RTE_ETH_FLOW_TYPE_FRAG_IPV4] = IPPROTO_IP,
-		[RTE_ETH_FLOW_TYPE_UDPV6] = IPPROTO_UDP,
-		[RTE_ETH_FLOW_TYPE_TCPV6] = IPPROTO_TCP,
-		[RTE_ETH_FLOW_TYPE_SCTPV6] = IPPROTO_SCTP,
-		[RTE_ETH_FLOW_TYPE_IPV6_OTHER] = IPPROTO_NONE,
-		[RTE_ETH_FLOW_TYPE_FRAG_IPV6] = IPPROTO_NONE,
+		[ETH_FLOW_TYPE_FRAG_IPV4] = IPPROTO_IP,
+		[ETH_FLOW_TYPE_NONFRAG_IPV4_TCP] = IPPROTO_TCP,
+		[ETH_FLOW_TYPE_NONFRAG_IPV4_UDP] = IPPROTO_UDP,
+		[ETH_FLOW_TYPE_NONFRAG_IPV4_SCTP] = IPPROTO_SCTP,
+		[ETH_FLOW_TYPE_NONFRAG_IPV4_OTHER] = IPPROTO_IP,
+		[ETH_FLOW_TYPE_FRAG_IPV6] = IPPROTO_NONE,
+		[ETH_FLOW_TYPE_NONFRAG_IPV6_TCP] = IPPROTO_TCP,
+		[ETH_FLOW_TYPE_NONFRAG_IPV6_UDP] = IPPROTO_UDP,
+		[ETH_FLOW_TYPE_NONFRAG_IPV6_SCTP] = IPPROTO_SCTP,
+		[ETH_FLOW_TYPE_NONFRAG_IPV6_OTHER] = IPPROTO_NONE,
 	};
 
 	switch (fdir_input->flow_type) {
-	case RTE_ETH_FLOW_TYPE_UDPV4:
-	case RTE_ETH_FLOW_TYPE_TCPV4:
-	case RTE_ETH_FLOW_TYPE_SCTPV4:
-	case RTE_ETH_FLOW_TYPE_IPV4_OTHER:
-	case RTE_ETH_FLOW_TYPE_FRAG_IPV4:
+	case ETH_FLOW_TYPE_NONFRAG_IPV4_TCP:
+	case ETH_FLOW_TYPE_NONFRAG_IPV4_UDP:
+	case ETH_FLOW_TYPE_NONFRAG_IPV4_SCTP:
+	case ETH_FLOW_TYPE_NONFRAG_IPV4_OTHER:
+	case ETH_FLOW_TYPE_FRAG_IPV4:
 		ip = (struct ipv4_hdr *)(raw_pkt + sizeof(struct ether_hdr));
 
 		ether->ether_type = rte_cpu_to_be_16(ETHER_TYPE_IPv4);
@@ -726,11 +726,11 @@  i40e_fdir_fill_eth_ip_head(const struct rte_eth_fdir_input *fdir_input,
 		ip->dst_addr = fdir_input->flow.ip4_flow.src_ip;
 		ip->next_proto_id = next_proto[fdir_input->flow_type];
 		break;
-	case RTE_ETH_FLOW_TYPE_UDPV6:
-	case RTE_ETH_FLOW_TYPE_TCPV6:
-	case RTE_ETH_FLOW_TYPE_SCTPV6:
-	case RTE_ETH_FLOW_TYPE_IPV6_OTHER:
-	case RTE_ETH_FLOW_TYPE_FRAG_IPV6:
+	case ETH_FLOW_TYPE_NONFRAG_IPV6_TCP:
+	case ETH_FLOW_TYPE_NONFRAG_IPV6_UDP:
+	case ETH_FLOW_TYPE_NONFRAG_IPV6_SCTP:
+	case ETH_FLOW_TYPE_NONFRAG_IPV6_OTHER:
+	case ETH_FLOW_TYPE_FRAG_IPV6:
 		ip6 = (struct ipv6_hdr *)(raw_pkt + sizeof(struct ether_hdr));
 
 		ether->ether_type = rte_cpu_to_be_16(ETHER_TYPE_IPv6);
@@ -784,7 +784,7 @@  i40e_fdir_construct_pkt(struct i40e_pf *pf,
 
 	/* fill the L4 head */
 	switch (fdir_input->flow_type) {
-	case RTE_ETH_FLOW_TYPE_UDPV4:
+	case ETH_FLOW_TYPE_NONFRAG_IPV4_UDP:
 		udp = (struct udp_hdr *)(raw_pkt + sizeof(struct ether_hdr) +
 				sizeof(struct ipv4_hdr));
 		payload = (unsigned char *)udp + sizeof(struct udp_hdr);
@@ -798,7 +798,7 @@  i40e_fdir_construct_pkt(struct i40e_pf *pf,
 		udp->dgram_len = rte_cpu_to_be_16(I40E_FDIR_UDP_DEFAULT_LEN);
 		break;
 
-	case RTE_ETH_FLOW_TYPE_TCPV4:
+	case ETH_FLOW_TYPE_NONFRAG_IPV4_TCP:
 		tcp = (struct tcp_hdr *)(raw_pkt + sizeof(struct ether_hdr) +
 					 sizeof(struct ipv4_hdr));
 		payload = (unsigned char *)tcp + sizeof(struct tcp_hdr);
@@ -812,21 +812,21 @@  i40e_fdir_construct_pkt(struct i40e_pf *pf,
 		tcp->data_off = I40E_FDIR_TCP_DEFAULT_DATAOFF;
 		break;
 
-	case RTE_ETH_FLOW_TYPE_SCTPV4:
+	case ETH_FLOW_TYPE_NONFRAG_IPV4_SCTP:
 		sctp = (struct sctp_hdr *)(raw_pkt + sizeof(struct ether_hdr) +
 					   sizeof(struct ipv4_hdr));
 		payload = (unsigned char *)sctp + sizeof(struct sctp_hdr);
 		sctp->tag = fdir_input->flow.sctp4_flow.verify_tag;
 		break;
 
-	case RTE_ETH_FLOW_TYPE_IPV4_OTHER:
-	case RTE_ETH_FLOW_TYPE_FRAG_IPV4:
+	case ETH_FLOW_TYPE_NONFRAG_IPV4_OTHER:
+	case ETH_FLOW_TYPE_FRAG_IPV4:
 		payload = raw_pkt + sizeof(struct ether_hdr) +
 			  sizeof(struct ipv4_hdr);
 		set_idx = I40E_FLXPLD_L3_IDX;
 		break;
 
-	case RTE_ETH_FLOW_TYPE_UDPV6:
+	case ETH_FLOW_TYPE_NONFRAG_IPV6_UDP:
 		udp = (struct udp_hdr *)(raw_pkt + sizeof(struct ether_hdr) +
 					 sizeof(struct ipv6_hdr));
 		payload = (unsigned char *)udp + sizeof(struct udp_hdr);
@@ -840,7 +840,7 @@  i40e_fdir_construct_pkt(struct i40e_pf *pf,
 		udp->dgram_len = rte_cpu_to_be_16(I40E_FDIR_IPv6_PAYLOAD_LEN);
 		break;
 
-	case RTE_ETH_FLOW_TYPE_TCPV6:
+	case ETH_FLOW_TYPE_NONFRAG_IPV6_TCP:
 		tcp = (struct tcp_hdr *)(raw_pkt + sizeof(struct ether_hdr) +
 					 sizeof(struct ipv6_hdr));
 		payload = (unsigned char *)tcp + sizeof(struct tcp_hdr);
@@ -854,15 +854,15 @@  i40e_fdir_construct_pkt(struct i40e_pf *pf,
 		tcp->dst_port = fdir_input->flow.udp6_flow.src_port;
 		break;
 
-	case RTE_ETH_FLOW_TYPE_SCTPV6:
+	case ETH_FLOW_TYPE_NONFRAG_IPV6_SCTP:
 		sctp = (struct sctp_hdr *)(raw_pkt + sizeof(struct ether_hdr) +
 					   sizeof(struct ipv6_hdr));
 		payload = (unsigned char *)sctp + sizeof(struct sctp_hdr);
 		sctp->tag = fdir_input->flow.sctp6_flow.verify_tag;
 		break;
 
-	case RTE_ETH_FLOW_TYPE_IPV6_OTHER:
-	case RTE_ETH_FLOW_TYPE_FRAG_IPV6:
+	case ETH_FLOW_TYPE_NONFRAG_IPV6_OTHER:
+	case ETH_FLOW_TYPE_FRAG_IPV6:
 		payload = raw_pkt + sizeof(struct ether_hdr) +
 			  sizeof(struct ipv6_hdr);
 		set_idx = I40E_FLXPLD_L3_IDX;
@@ -1214,7 +1214,7 @@  i40e_fdir_info_get_flex_mask(struct i40e_pf *pf,
 {
 	struct i40e_fdir_flex_mask *mask;
 	struct rte_eth_fdir_flex_mask *ptr = flex_mask;
-	enum rte_eth_flow_type flow_type;
+	uint16_t flow_type;
 	uint8_t i, j;
 	uint16_t off_bytes, mask_tmp;