[09/14] ethdev: remove legacy HASH filter type support
diff mbox series

Message ID 1603030152-13451-10-git-send-email-arybchenko@solarflare.com
State Superseded
Delegated to: Ferruh Yigit
Headers show
Series
  • ethdev: remove legacy filter API
Related show

Checks

Context Check Description
ci/checkpatch success coding style OK

Commit Message

Andrew Rybchenko Oct. 18, 2020, 2:09 p.m. UTC
RTE flow API should be used for filtering.

Preserve RTE_ETH_FILTER_HASH since it is used in drivers
internally in RTE flow API support.

Signed-off-by: Andrew Rybchenko <arybchenko@solarflare.com>
---
 app/test-pmd/cmdline.c               | 434 ---------------------------
 doc/guides/rel_notes/deprecation.rst |   4 +-
 drivers/net/i40e/i40e_ethdev.c       | 268 -----------------
 drivers/net/qede/qede_filter.c       |   1 -
 drivers/net/sfc/sfc_ethdev.c         |   3 -
 lib/librte_ethdev/rte_eth_ctrl.h     |  57 ----
 6 files changed, 2 insertions(+), 765 deletions(-)

Patch
diff mbox series

diff --git a/app/test-pmd/cmdline.c b/app/test-pmd/cmdline.c
index f7169c7b9e..713e1cad83 100644
--- a/app/test-pmd/cmdline.c
+++ b/app/test-pmd/cmdline.c
@@ -1048,34 +1048,6 @@  static void cmd_help_long_parsed(void *parsed_result,
 			" (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|"
@@ -11503,343 +11475,6 @@  cmdline_parse_inst_t cmd_set_flow_director_flex_payload = {
 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)
@@ -11891,70 +11526,6 @@  str2inset(char *string)
 	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;
@@ -19026,11 +18597,6 @@  cmdline_parse_ctx_t main_ctx[] = {
 	(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,
diff --git a/doc/guides/rel_notes/deprecation.rst b/doc/guides/rel_notes/deprecation.rst
index a807cb9ad9..e245d04bf4 100644
--- a/doc/guides/rel_notes/deprecation.rst
+++ b/doc/guides/rel_notes/deprecation.rst
@@ -108,8 +108,8 @@  Deprecation Notices
 
 * ethdev: the legacy filter API, including
   ``rte_eth_dev_filter_supported()``, ``rte_eth_dev_filter_ctrl()`` as well
-  as filter types FDIR,
-  HASH and L2_TUNNEL, is superseded by the generic flow API (rte_flow) in
+  as filter types FDIR
+  and L2_TUNNEL, is superseded by the generic flow API (rte_flow) in
   PMDs that implement the latter.
   The legacy API will be removed in DPDK 20.11.
 
diff --git a/drivers/net/i40e/i40e_ethdev.c b/drivers/net/i40e/i40e_ethdev.c
index 2badd024f1..cd57126aa5 100644
--- a/drivers/net/i40e/i40e_ethdev.c
+++ b/drivers/net/i40e/i40e_ethdev.c
@@ -8950,15 +8950,6 @@  i40e_filter_ctrl_global_config(struct rte_eth_dev *dev,
 	return ret;
 }
 
-/* Get the symmetric hash enable configurations per port */
-static void
-i40e_get_symmetric_hash_enable_per_port(struct i40e_hw *hw, uint8_t *enable)
-{
-	uint32_t reg = i40e_read_rx_ctl(hw, I40E_PRTQF_CTL_0);
-
-	*enable = reg & I40E_PRTQF_CTL_0_HSYM_ENA_MASK ? 1 : 0;
-}
-
 /* Set the symmetric hash enable configurations per port */
 static void
 i40e_set_symmetric_hash_enable_per_port(struct i40e_hw *hw, uint8_t enable)
@@ -8984,170 +8975,6 @@  i40e_set_symmetric_hash_enable_per_port(struct i40e_hw *hw, uint8_t enable)
 	I40E_WRITE_FLUSH(hw);
 }
 
-/*
- * Get global configurations of hash function type and symmetric hash enable
- * per flow type (pctype). Note that global configuration means it affects all
- * the ports on the same NIC.
- */
-static int
-i40e_get_hash_filter_global_config(struct i40e_hw *hw,
-				   struct rte_eth_hash_global_conf *g_cfg)
-{
-	struct i40e_adapter *adapter = (struct i40e_adapter *)hw->back;
-	uint32_t reg;
-	uint16_t i, j;
-
-	memset(g_cfg, 0, sizeof(*g_cfg));
-	reg = i40e_read_rx_ctl(hw, I40E_GLQF_CTL);
-	if (reg & I40E_GLQF_CTL_HTOEP_MASK)
-		g_cfg->hash_func = RTE_ETH_HASH_FUNCTION_TOEPLITZ;
-	else
-		g_cfg->hash_func = RTE_ETH_HASH_FUNCTION_SIMPLE_XOR;
-	PMD_DRV_LOG(DEBUG, "Hash function is %s",
-		(reg & I40E_GLQF_CTL_HTOEP_MASK) ? "Toeplitz" : "Simple XOR");
-
-	/*
-	 * As i40e supports less than 64 flow types, only first 64 bits need to
-	 * be checked.
-	 */
-	for (i = 1; i < RTE_SYM_HASH_MASK_ARRAY_SIZE; i++) {
-		g_cfg->valid_bit_mask[i] = 0ULL;
-		g_cfg->sym_hash_enable_mask[i] = 0ULL;
-	}
-
-	g_cfg->valid_bit_mask[0] = adapter->flow_types_mask;
-
-	for (i = RTE_ETH_FLOW_UNKNOWN + 1; i < UINT64_BIT; i++) {
-		if (!adapter->pctypes_tbl[i])
-			continue;
-		for (j = I40E_FILTER_PCTYPE_INVALID + 1;
-		     j < I40E_FILTER_PCTYPE_MAX; j++) {
-			if (adapter->pctypes_tbl[i] & (1ULL << j)) {
-				reg = i40e_read_rx_ctl(hw, I40E_GLQF_HSYM(j));
-				if (reg & I40E_GLQF_HSYM_SYMH_ENA_MASK) {
-					g_cfg->sym_hash_enable_mask[0] |=
-								(1ULL << i);
-				}
-			}
-		}
-	}
-
-	return 0;
-}
-
-static int
-i40e_hash_global_config_check(const struct i40e_adapter *adapter,
-			      const struct rte_eth_hash_global_conf *g_cfg)
-{
-	uint32_t i;
-	uint64_t mask0, i40e_mask = adapter->flow_types_mask;
-
-	if (g_cfg->hash_func != RTE_ETH_HASH_FUNCTION_TOEPLITZ &&
-		g_cfg->hash_func != RTE_ETH_HASH_FUNCTION_SIMPLE_XOR &&
-		g_cfg->hash_func != RTE_ETH_HASH_FUNCTION_DEFAULT) {
-		PMD_DRV_LOG(ERR, "Unsupported hash function type %d",
-						g_cfg->hash_func);
-		return -EINVAL;
-	}
-
-	/*
-	 * As i40e supports less than 64 flow types, only first 64 bits need to
-	 * be checked.
-	 */
-	mask0 = g_cfg->valid_bit_mask[0];
-	for (i = 0; i < RTE_SYM_HASH_MASK_ARRAY_SIZE; i++) {
-		if (i == 0) {
-			/* Check if any unsupported flow type configured */
-			if ((mask0 | i40e_mask) ^ i40e_mask)
-				goto mask_err;
-		} else {
-			if (g_cfg->valid_bit_mask[i])
-				goto mask_err;
-		}
-	}
-
-	return 0;
-
-mask_err:
-	PMD_DRV_LOG(ERR, "i40e unsupported flow type bit(s) configured");
-
-	return -EINVAL;
-}
-
-/*
- * Set global configurations of hash function type and symmetric hash enable
- * per flow type (pctype). Note any modifying global configuration will affect
- * all the ports on the same NIC.
- */
-static int
-i40e_set_hash_filter_global_config(struct i40e_hw *hw,
-				   struct rte_eth_hash_global_conf *g_cfg)
-{
-	struct i40e_adapter *adapter = (struct i40e_adapter *)hw->back;
-	struct i40e_pf *pf = &((struct i40e_adapter *)hw->back)->pf;
-	int ret;
-	uint16_t i, j;
-	uint32_t reg;
-	uint64_t mask0 = g_cfg->valid_bit_mask[0] & adapter->flow_types_mask;
-
-	if (pf->support_multi_driver) {
-		PMD_DRV_LOG(ERR, "Hash global configuration is not supported.");
-		return -ENOTSUP;
-	}
-
-	/* Check the input parameters */
-	ret = i40e_hash_global_config_check(adapter, g_cfg);
-	if (ret < 0)
-		return ret;
-
-	/*
-	 * As i40e supports less than 64 flow types, only first 64 bits need to
-	 * be configured.
-	 */
-	for (i = RTE_ETH_FLOW_UNKNOWN + 1; mask0 && i < UINT64_BIT; i++) {
-		if (mask0 & (1UL << i)) {
-			reg = (g_cfg->sym_hash_enable_mask[0] & (1ULL << i)) ?
-					I40E_GLQF_HSYM_SYMH_ENA_MASK : 0;
-
-			for (j = I40E_FILTER_PCTYPE_INVALID + 1;
-			     j < I40E_FILTER_PCTYPE_MAX; j++) {
-				if (adapter->pctypes_tbl[i] & (1ULL << j))
-					i40e_write_global_rx_ctl(hw,
-							  I40E_GLQF_HSYM(j),
-							  reg);
-			}
-		}
-	}
-
-	reg = i40e_read_rx_ctl(hw, I40E_GLQF_CTL);
-	if (g_cfg->hash_func == RTE_ETH_HASH_FUNCTION_TOEPLITZ) {
-		/* Toeplitz */
-		if (reg & I40E_GLQF_CTL_HTOEP_MASK) {
-			PMD_DRV_LOG(DEBUG,
-				"Hash function already set to Toeplitz");
-			goto out;
-		}
-		reg |= I40E_GLQF_CTL_HTOEP_MASK;
-	} else if (g_cfg->hash_func == RTE_ETH_HASH_FUNCTION_SIMPLE_XOR) {
-		/* Simple XOR */
-		if (!(reg & I40E_GLQF_CTL_HTOEP_MASK)) {
-			PMD_DRV_LOG(DEBUG,
-				"Hash function already set to Simple XOR");
-			goto out;
-		}
-		reg &= ~I40E_GLQF_CTL_HTOEP_MASK;
-	} else
-		/* Use the default, and keep it as it is */
-		goto out;
-
-	i40e_write_global_rx_ctl(hw, I40E_GLQF_CTL, reg);
-
-out:
-	I40E_WRITE_FLUSH(hw);
-
-	return 0;
-}
-
 /**
  * Valid input sets for hash and flow director filters per PCTYPE
  */
@@ -9982,98 +9809,6 @@  i40e_fdir_filter_inset_select(struct i40e_pf *pf,
 	return 0;
 }
 
-static int
-i40e_hash_filter_get(struct i40e_hw *hw, struct rte_eth_hash_filter_info *info)
-{
-	int ret = 0;
-
-	if (!hw || !info) {
-		PMD_DRV_LOG(ERR, "Invalid pointer");
-		return -EFAULT;
-	}
-
-	switch (info->info_type) {
-	case RTE_ETH_HASH_FILTER_SYM_HASH_ENA_PER_PORT:
-		i40e_get_symmetric_hash_enable_per_port(hw,
-					&(info->info.enable));
-		break;
-	case RTE_ETH_HASH_FILTER_GLOBAL_CONFIG:
-		ret = i40e_get_hash_filter_global_config(hw,
-				&(info->info.global_conf));
-		break;
-	default:
-		PMD_DRV_LOG(ERR, "Hash filter info type (%d) not supported",
-							info->info_type);
-		ret = -EINVAL;
-		break;
-	}
-
-	return ret;
-}
-
-static int
-i40e_hash_filter_set(struct i40e_hw *hw, struct rte_eth_hash_filter_info *info)
-{
-	int ret = 0;
-
-	if (!hw || !info) {
-		PMD_DRV_LOG(ERR, "Invalid pointer");
-		return -EFAULT;
-	}
-
-	switch (info->info_type) {
-	case RTE_ETH_HASH_FILTER_SYM_HASH_ENA_PER_PORT:
-		i40e_set_symmetric_hash_enable_per_port(hw, info->info.enable);
-		break;
-	case RTE_ETH_HASH_FILTER_GLOBAL_CONFIG:
-		ret = i40e_set_hash_filter_global_config(hw,
-				&(info->info.global_conf));
-		break;
-	case RTE_ETH_HASH_FILTER_INPUT_SET_SELECT:
-		ret = i40e_hash_filter_inset_select(hw,
-					       &(info->info.input_set_conf));
-		break;
-
-	default:
-		PMD_DRV_LOG(ERR, "Hash filter info type (%d) not supported",
-							info->info_type);
-		ret = -EINVAL;
-		break;
-	}
-
-	return ret;
-}
-
-/* Operations for hash function */
-static int
-i40e_hash_filter_ctrl(struct rte_eth_dev *dev,
-		      enum rte_filter_op filter_op,
-		      void *arg)
-{
-	struct i40e_hw *hw = I40E_DEV_PRIVATE_TO_HW(dev->data->dev_private);
-	int ret = 0;
-
-	switch (filter_op) {
-	case RTE_ETH_FILTER_NOP:
-		break;
-	case RTE_ETH_FILTER_GET:
-		ret = i40e_hash_filter_get(hw,
-			(struct rte_eth_hash_filter_info *)arg);
-		break;
-	case RTE_ETH_FILTER_SET:
-		ret = i40e_hash_filter_set(hw,
-			(struct rte_eth_hash_filter_info *)arg);
-		break;
-	default:
-		PMD_DRV_LOG(WARNING, "Filter operation (%d) not supported",
-								filter_op);
-		ret = -ENOTSUP;
-		break;
-	}
-
-	return ret;
-}
-
 /* Convert ethertype filter structure */
 static int
 i40e_ethertype_filter_convert(const struct rte_eth_ethertype_filter *input,
@@ -10255,9 +9990,6 @@  i40e_dev_filter_ctrl(struct rte_eth_dev *dev,
 		/* For global configuration */
 		ret = i40e_filter_ctrl_global_config(dev, filter_op, arg);
 		break;
-	case RTE_ETH_FILTER_HASH:
-		ret = i40e_hash_filter_ctrl(dev, filter_op, arg);
-		break;
 	case RTE_ETH_FILTER_FDIR:
 		ret = i40e_fdir_ctrl_func(dev, filter_op, arg);
 		break;
diff --git a/drivers/net/qede/qede_filter.c b/drivers/net/qede/qede_filter.c
index ba4e4d9e16..283e7322cb 100644
--- a/drivers/net/qede/qede_filter.c
+++ b/drivers/net/qede/qede_filter.c
@@ -1241,7 +1241,6 @@  int qede_dev_filter_ctrl(struct rte_eth_dev *eth_dev,
 
 		*(const void **)arg = &qede_flow_ops;
 		return 0;
-	case RTE_ETH_FILTER_HASH:
 	case RTE_ETH_FILTER_L2_TUNNEL:
 	case RTE_ETH_FILTER_MAX:
 	default:
diff --git a/drivers/net/sfc/sfc_ethdev.c b/drivers/net/sfc/sfc_ethdev.c
index 51d33f3710..c47f282450 100644
--- a/drivers/net/sfc/sfc_ethdev.c
+++ b/drivers/net/sfc/sfc_ethdev.c
@@ -1751,9 +1751,6 @@  sfc_dev_filter_ctrl(struct rte_eth_dev *dev, enum rte_filter_type filter_type,
 	case RTE_ETH_FILTER_FDIR:
 		sfc_err(sa, "Flow Director filters not supported");
 		break;
-	case RTE_ETH_FILTER_HASH:
-		sfc_err(sa, "Hash filters not supported");
-		break;
 	case RTE_ETH_FILTER_GENERIC:
 		if (filter_op != RTE_ETH_FILTER_GET) {
 			rc = EINVAL;
diff --git a/lib/librte_ethdev/rte_eth_ctrl.h b/lib/librte_ethdev/rte_eth_ctrl.h
index b4cc163e3e..4c9bd9b0fa 100644
--- a/lib/librte_ethdev/rte_eth_ctrl.h
+++ b/lib/librte_ethdev/rte_eth_ctrl.h
@@ -616,63 +616,6 @@  struct rte_eth_fdir_filter_info {
 	} info;
 };
 
-/**
- * Hash filter information types.
- * - RTE_ETH_HASH_FILTER_SYM_HASH_ENA_PER_PORT is for getting/setting the
- *   information/configuration of 'symmetric hash enable' per port.
- * - RTE_ETH_HASH_FILTER_GLOBAL_CONFIG is for getting/setting the global
- *   configurations of hash filters. Those global configurations are valid
- *   for all ports of the same NIC.
- * - RTE_ETH_HASH_FILTER_INPUT_SET_SELECT is for setting the global
- *   hash input set fields
- */
-enum rte_eth_hash_filter_info_type {
-	RTE_ETH_HASH_FILTER_INFO_TYPE_UNKNOWN = 0,
-	/** Symmetric hash enable per port */
-	RTE_ETH_HASH_FILTER_SYM_HASH_ENA_PER_PORT,
-	/** Configure globally for hash filter */
-	RTE_ETH_HASH_FILTER_GLOBAL_CONFIG,
-	/** Global Hash filter input set configuration */
-	RTE_ETH_HASH_FILTER_INPUT_SET_SELECT,
-	RTE_ETH_HASH_FILTER_INFO_TYPE_MAX,
-};
-
-#define RTE_SYM_HASH_MASK_ARRAY_SIZE \
-	(RTE_ALIGN(RTE_ETH_FLOW_MAX, UINT64_BIT)/UINT64_BIT)
-/**
- * A structure used to set or get global hash function configurations which
- * include symmetric hash enable per flow type and hash function type.
- * Each bit in sym_hash_enable_mask[] indicates if the symmetric hash of the
- * corresponding flow type is enabled or not.
- * Each bit in valid_bit_mask[] indicates if the corresponding bit in
- * sym_hash_enable_mask[] is valid or not. For the configurations gotten, it
- * also means if the flow type is supported by hardware or not.
- */
-struct rte_eth_hash_global_conf {
-	enum rte_eth_hash_function hash_func; /**< Hash function type */
-	/** Bit mask for symmetric hash enable per flow type */
-	uint64_t sym_hash_enable_mask[RTE_SYM_HASH_MASK_ARRAY_SIZE];
-	/** Bit mask indicates if the corresponding bit is valid */
-	uint64_t valid_bit_mask[RTE_SYM_HASH_MASK_ARRAY_SIZE];
-};
-
-/**
- * A structure used to set or get hash filter information, to support filter
- * type of 'RTE_ETH_FILTER_HASH' and its operations.
- */
-struct rte_eth_hash_filter_info {
-	enum rte_eth_hash_filter_info_type info_type; /**< Information type */
-	/** Details of hash filter information */
-	union {
-		/** For RTE_ETH_HASH_FILTER_SYM_HASH_ENA_PER_PORT */
-		uint8_t enable;
-		/** Global configurations of hash filter */
-		struct rte_eth_hash_global_conf global_conf;
-		/** Global configurations of hash filter input set */
-		struct rte_eth_input_set_conf input_set_conf;
-	} info;
-};
-
 /**
  * l2 tunnel configuration.
  */