Re: [dpdk-dev] [PATCH 5/7] ethdev: unification of flow types

["Zhang, Helin" <helin.zhang@intel.com>]

Hi Vithal

Exactly! Some types of NIC (e.g. i40e) support it.

Regards,
Helin

> -----Original Message-----
> From: Vithal S Mohare [mailto:vmohare@arubanetworks.com]
> Sent: Tuesday, January 27, 2015 12:31 PM
> To: Zhang, Helin
> Subject: RE: [dpdk-dev] [PATCH 5/7] ethdev: unification of flow types
> 
> Hi Helin,
> 
> I see a new type *_L2_PAYLOAD added for RSS types.  Is this for spraying of
> pure L2 packets (non-ip)?
> 
> Thanks,
> -Vithal
> 
> -----Original Message-----
> From: dev [mailto:dev-bounces@dpdk.org] On Behalf Of Helin Zhang
> Sent: Monday, January 19, 2015 12:26 PM
> To: dev@dpdk.org
> Subject: [dpdk-dev] [PATCH 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
> 4618b92..80b9c32 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..f2b39fc 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 an 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;
> 
> --
> 1.9.3