[linux-block.git] / drivers / net / ethernet / mellanox / mlxsw / spectrum2_mr_tcam.c

// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
/* Copyright (c) 2018 Mellanox Technologies. All rights reserved */

#include <linux/kernel.h>

#include "core_acl_flex_actions.h"
#include "spectrum.h"
#include "spectrum_mr.h"

struct mlxsw_sp2_mr_tcam {
	struct mlxsw_sp *mlxsw_sp;
	struct mlxsw_sp_flow_block *flow_block;
	struct mlxsw_sp_acl_ruleset *ruleset4;
	struct mlxsw_sp_acl_ruleset *ruleset6;
};

struct mlxsw_sp2_mr_route {
	struct mlxsw_sp2_mr_tcam *mr_tcam;
};

static struct mlxsw_sp_acl_ruleset *
mlxsw_sp2_mr_tcam_proto_ruleset(struct mlxsw_sp2_mr_tcam *mr_tcam,
				enum mlxsw_sp_l3proto proto)
{
	switch (proto) {
	case MLXSW_SP_L3_PROTO_IPV4:
		return mr_tcam->ruleset4;
	case MLXSW_SP_L3_PROTO_IPV6:
		return mr_tcam->ruleset6;
	}
	return NULL;
}

static int mlxsw_sp2_mr_tcam_bind_group(struct mlxsw_sp *mlxsw_sp,
					enum mlxsw_reg_pemrbt_protocol protocol,
					struct mlxsw_sp_acl_ruleset *ruleset)
{
	char pemrbt_pl[MLXSW_REG_PEMRBT_LEN];
	u16 group_id;

	group_id = mlxsw_sp_acl_ruleset_group_id(ruleset);

	mlxsw_reg_pemrbt_pack(pemrbt_pl, protocol, group_id);
	return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(pemrbt), pemrbt_pl);
}

static const enum mlxsw_afk_element mlxsw_sp2_mr_tcam_usage_ipv4[] = {
		MLXSW_AFK_ELEMENT_VIRT_ROUTER_MSB,
		MLXSW_AFK_ELEMENT_VIRT_ROUTER_LSB,
		MLXSW_AFK_ELEMENT_SRC_IP_0_31,
		MLXSW_AFK_ELEMENT_DST_IP_0_31,
};

static int mlxsw_sp2_mr_tcam_ipv4_init(struct mlxsw_sp2_mr_tcam *mr_tcam)
{
	struct mlxsw_afk_element_usage elusage;
	int err;

	/* Initialize IPv4 ACL group. */
	mlxsw_afk_element_usage_fill(&elusage,
				     mlxsw_sp2_mr_tcam_usage_ipv4,
				     ARRAY_SIZE(mlxsw_sp2_mr_tcam_usage_ipv4));
	mr_tcam->ruleset4 = mlxsw_sp_acl_ruleset_get(mr_tcam->mlxsw_sp,
						     mr_tcam->flow_block,
						     MLXSW_SP_L3_PROTO_IPV4,
						     MLXSW_SP_ACL_PROFILE_MR,
						     &elusage);

	if (IS_ERR(mr_tcam->ruleset4))
		return PTR_ERR(mr_tcam->ruleset4);

	/* MC Router groups should be bound before routes are inserted. */
	err = mlxsw_sp2_mr_tcam_bind_group(mr_tcam->mlxsw_sp,
					   MLXSW_REG_PEMRBT_PROTO_IPV4,
					   mr_tcam->ruleset4);
	if (err)
		goto err_bind_group;

	return 0;

err_bind_group:
	mlxsw_sp_acl_ruleset_put(mr_tcam->mlxsw_sp, mr_tcam->ruleset4);
	return err;
}

static void mlxsw_sp2_mr_tcam_ipv4_fini(struct mlxsw_sp2_mr_tcam *mr_tcam)
{
	mlxsw_sp_acl_ruleset_put(mr_tcam->mlxsw_sp, mr_tcam->ruleset4);
}

static const enum mlxsw_afk_element mlxsw_sp2_mr_tcam_usage_ipv6[] = {
		MLXSW_AFK_ELEMENT_VIRT_ROUTER_MSB,
		MLXSW_AFK_ELEMENT_VIRT_ROUTER_LSB,
		MLXSW_AFK_ELEMENT_SRC_IP_96_127,
		MLXSW_AFK_ELEMENT_SRC_IP_64_95,
		MLXSW_AFK_ELEMENT_SRC_IP_32_63,
		MLXSW_AFK_ELEMENT_SRC_IP_0_31,
		MLXSW_AFK_ELEMENT_DST_IP_96_127,
		MLXSW_AFK_ELEMENT_DST_IP_64_95,
		MLXSW_AFK_ELEMENT_DST_IP_32_63,
		MLXSW_AFK_ELEMENT_DST_IP_0_31,
};

static int mlxsw_sp2_mr_tcam_ipv6_init(struct mlxsw_sp2_mr_tcam *mr_tcam)
{
	struct mlxsw_afk_element_usage elusage;
	int err;

	/* Initialize IPv6 ACL group */
	mlxsw_afk_element_usage_fill(&elusage,
				     mlxsw_sp2_mr_tcam_usage_ipv6,
				     ARRAY_SIZE(mlxsw_sp2_mr_tcam_usage_ipv6));
	mr_tcam->ruleset6 = mlxsw_sp_acl_ruleset_get(mr_tcam->mlxsw_sp,
						     mr_tcam->flow_block,
						     MLXSW_SP_L3_PROTO_IPV6,
						     MLXSW_SP_ACL_PROFILE_MR,
						     &elusage);

	if (IS_ERR(mr_tcam->ruleset6))
		return PTR_ERR(mr_tcam->ruleset6);

	/* MC Router groups should be bound before routes are inserted. */
	err = mlxsw_sp2_mr_tcam_bind_group(mr_tcam->mlxsw_sp,
					   MLXSW_REG_PEMRBT_PROTO_IPV6,
					   mr_tcam->ruleset6);
	if (err)
		goto err_bind_group;

	return 0;

err_bind_group:
	mlxsw_sp_acl_ruleset_put(mr_tcam->mlxsw_sp, mr_tcam->ruleset6);
	return err;
}

static void mlxsw_sp2_mr_tcam_ipv6_fini(struct mlxsw_sp2_mr_tcam *mr_tcam)
{
	mlxsw_sp_acl_ruleset_put(mr_tcam->mlxsw_sp, mr_tcam->ruleset6);
}

static void
mlxsw_sp2_mr_tcam_rule_parse4(struct mlxsw_sp_acl_rule_info *rulei,
			      struct mlxsw_sp_mr_route_key *key)
{
	mlxsw_sp_acl_rulei_keymask_buf(rulei, MLXSW_AFK_ELEMENT_SRC_IP_0_31,
				       (char *) &key->source.addr4,
				       (char *) &key->source_mask.addr4, 4);
	mlxsw_sp_acl_rulei_keymask_buf(rulei, MLXSW_AFK_ELEMENT_DST_IP_0_31,
				       (char *) &key->group.addr4,
				       (char *) &key->group_mask.addr4, 4);
}

static void
mlxsw_sp2_mr_tcam_rule_parse6(struct mlxsw_sp_acl_rule_info *rulei,
			      struct mlxsw_sp_mr_route_key *key)
{
	mlxsw_sp_acl_rulei_keymask_buf(rulei, MLXSW_AFK_ELEMENT_SRC_IP_96_127,
				       &key->source.addr6.s6_addr[0x0],
				       &key->source_mask.addr6.s6_addr[0x0], 4);
	mlxsw_sp_acl_rulei_keymask_buf(rulei, MLXSW_AFK_ELEMENT_SRC_IP_64_95,
				       &key->source.addr6.s6_addr[0x4],
				       &key->source_mask.addr6.s6_addr[0x4], 4);
	mlxsw_sp_acl_rulei_keymask_buf(rulei, MLXSW_AFK_ELEMENT_SRC_IP_32_63,
				       &key->source.addr6.s6_addr[0x8],
				       &key->source_mask.addr6.s6_addr[0x8], 4);
	mlxsw_sp_acl_rulei_keymask_buf(rulei, MLXSW_AFK_ELEMENT_SRC_IP_0_31,
				       &key->source.addr6.s6_addr[0xc],
				       &key->source_mask.addr6.s6_addr[0xc], 4);
	mlxsw_sp_acl_rulei_keymask_buf(rulei, MLXSW_AFK_ELEMENT_DST_IP_96_127,
				       &key->group.addr6.s6_addr[0x0],
				       &key->group_mask.addr6.s6_addr[0x0], 4);
	mlxsw_sp_acl_rulei_keymask_buf(rulei, MLXSW_AFK_ELEMENT_DST_IP_64_95,
				       &key->group.addr6.s6_addr[0x4],
				       &key->group_mask.addr6.s6_addr[0x4], 4);
	mlxsw_sp_acl_rulei_keymask_buf(rulei, MLXSW_AFK_ELEMENT_DST_IP_32_63,
				       &key->group.addr6.s6_addr[0x8],
				       &key->group_mask.addr6.s6_addr[0x8], 4);
	mlxsw_sp_acl_rulei_keymask_buf(rulei, MLXSW_AFK_ELEMENT_DST_IP_0_31,
				       &key->group.addr6.s6_addr[0xc],
				       &key->group_mask.addr6.s6_addr[0xc], 4);
}

static void
mlxsw_sp2_mr_tcam_rule_parse(struct mlxsw_sp_acl_rule *rule,
			     struct mlxsw_sp_mr_route_key *key,
			     unsigned int priority)
{
	struct mlxsw_sp_acl_rule_info *rulei;

	rulei = mlxsw_sp_acl_rule_rulei(rule);
	rulei->priority = priority;
	mlxsw_sp_acl_rulei_keymask_u32(rulei, MLXSW_AFK_ELEMENT_VIRT_ROUTER_LSB,
				       key->vrid, GENMASK(7, 0));
	mlxsw_sp_acl_rulei_keymask_u32(rulei,
				       MLXSW_AFK_ELEMENT_VIRT_ROUTER_MSB,
				       key->vrid >> 8, GENMASK(2, 0));
	switch (key->proto) {
	case MLXSW_SP_L3_PROTO_IPV4:
		return mlxsw_sp2_mr_tcam_rule_parse4(rulei, key);
	case MLXSW_SP_L3_PROTO_IPV6:
		return mlxsw_sp2_mr_tcam_rule_parse6(rulei, key);
	}
}

static int
mlxsw_sp2_mr_tcam_route_create(struct mlxsw_sp *mlxsw_sp, void *priv,
			       void *route_priv,
			       struct mlxsw_sp_mr_route_key *key,
			       struct mlxsw_afa_block *afa_block,
			       enum mlxsw_sp_mr_route_prio prio)
{
	struct mlxsw_sp2_mr_route *mr_route = route_priv;
	struct mlxsw_sp2_mr_tcam *mr_tcam = priv;
	struct mlxsw_sp_acl_ruleset *ruleset;
	struct mlxsw_sp_acl_rule *rule;
	int err;

	mr_route->mr_tcam = mr_tcam;
	ruleset = mlxsw_sp2_mr_tcam_proto_ruleset(mr_tcam, key->proto);
	if (WARN_ON(!ruleset))
		return -EINVAL;

	rule = mlxsw_sp_acl_rule_create(mlxsw_sp, ruleset,
					(unsigned long) route_priv, afa_block,
					NULL);
	if (IS_ERR(rule))
		return PTR_ERR(rule);

	mlxsw_sp2_mr_tcam_rule_parse(rule, key, prio);
	err = mlxsw_sp_acl_rule_add(mlxsw_sp, rule);
	if (err)
		goto err_rule_add;

	return 0;

err_rule_add:
	mlxsw_sp_acl_rule_destroy(mlxsw_sp, rule);
	return err;
}

static void
mlxsw_sp2_mr_tcam_route_destroy(struct mlxsw_sp *mlxsw_sp, void *priv,
				void *route_priv,
				struct mlxsw_sp_mr_route_key *key)
{
	struct mlxsw_sp2_mr_tcam *mr_tcam = priv;
	struct mlxsw_sp_acl_ruleset *ruleset;
	struct mlxsw_sp_acl_rule *rule;

	ruleset = mlxsw_sp2_mr_tcam_proto_ruleset(mr_tcam, key->proto);
	if (WARN_ON(!ruleset))
		return;

	rule = mlxsw_sp_acl_rule_lookup(mlxsw_sp, ruleset,
					(unsigned long) route_priv);
	if (WARN_ON(!rule))
		return;

	mlxsw_sp_acl_rule_del(mlxsw_sp, rule);
	mlxsw_sp_acl_rule_destroy(mlxsw_sp, rule);
}

static int
mlxsw_sp2_mr_tcam_route_update(struct mlxsw_sp *mlxsw_sp,
			       void *route_priv,
			       struct mlxsw_sp_mr_route_key *key,
			       struct mlxsw_afa_block *afa_block)
{
	struct mlxsw_sp2_mr_route *mr_route = route_priv;
	struct mlxsw_sp2_mr_tcam *mr_tcam = mr_route->mr_tcam;
	struct mlxsw_sp_acl_ruleset *ruleset;
	struct mlxsw_sp_acl_rule *rule;

	ruleset = mlxsw_sp2_mr_tcam_proto_ruleset(mr_tcam, key->proto);
	if (WARN_ON(!ruleset))
		return -EINVAL;

	rule = mlxsw_sp_acl_rule_lookup(mlxsw_sp, ruleset,
					(unsigned long) route_priv);
	if (WARN_ON(!rule))
		return -EINVAL;

	return mlxsw_sp_acl_rule_action_replace(mlxsw_sp, rule, afa_block);
}

static int mlxsw_sp2_mr_tcam_init(struct mlxsw_sp *mlxsw_sp, void *priv)
{
	struct mlxsw_sp2_mr_tcam *mr_tcam = priv;
	int err;

	mr_tcam->mlxsw_sp = mlxsw_sp;
	mr_tcam->flow_block = mlxsw_sp_flow_block_create(mlxsw_sp, NULL);
	if (!mr_tcam->flow_block)
		return -ENOMEM;

	err = mlxsw_sp2_mr_tcam_ipv4_init(mr_tcam);
	if (err)
		goto err_ipv4_init;

	err = mlxsw_sp2_mr_tcam_ipv6_init(mr_tcam);
	if (err)
		goto err_ipv6_init;

	return 0;

err_ipv6_init:
	mlxsw_sp2_mr_tcam_ipv4_fini(mr_tcam);
err_ipv4_init:
	mlxsw_sp_flow_block_destroy(mr_tcam->flow_block);
	return err;
}

static void mlxsw_sp2_mr_tcam_fini(void *priv)
{
	struct mlxsw_sp2_mr_tcam *mr_tcam = priv;

	mlxsw_sp2_mr_tcam_ipv6_fini(mr_tcam);
	mlxsw_sp2_mr_tcam_ipv4_fini(mr_tcam);
	mlxsw_sp_flow_block_destroy(mr_tcam->flow_block);
}

const struct mlxsw_sp_mr_tcam_ops mlxsw_sp2_mr_tcam_ops = {
	.priv_size = sizeof(struct mlxsw_sp2_mr_tcam),
	.init = mlxsw_sp2_mr_tcam_init,
	.fini = mlxsw_sp2_mr_tcam_fini,
	.route_priv_size = sizeof(struct mlxsw_sp2_mr_route),
	.route_create = mlxsw_sp2_mr_tcam_route_create,
	.route_destroy = mlxsw_sp2_mr_tcam_route_destroy,
	.route_update = mlxsw_sp2_mr_tcam_route_update,
};
Commit	Line	Data
9948a064 JP	1	// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
9948a064 JP	2	/* Copyright (c) 2018 Mellanox Technologies. All rights reserved */
18ce0e4e JP	3
	4	#include <linux/kernel.h>
	5
	6	#include "core_acl_flex_actions.h"
	7	#include "spectrum.h"
	8	#include "spectrum_mr.h"
	9
cf7221a4 ND	10	struct mlxsw_sp2_mr_tcam {
cf7221a4 ND	11	struct mlxsw_sp *mlxsw_sp;
3bc3ffb6	12	struct mlxsw_sp_flow_block *flow_block;
cf7221a4 ND	13	struct mlxsw_sp_acl_ruleset *ruleset4;
	14	struct mlxsw_sp_acl_ruleset *ruleset6;
	15	};
	16
	17	struct mlxsw_sp2_mr_route {
	18	struct mlxsw_sp2_mr_tcam *mr_tcam;
	19	};
	20
	21	static struct mlxsw_sp_acl_ruleset *
	22	mlxsw_sp2_mr_tcam_proto_ruleset(struct mlxsw_sp2_mr_tcam *mr_tcam,
	23	enum mlxsw_sp_l3proto proto)
	24	{
	25	switch (proto) {
	26	case MLXSW_SP_L3_PROTO_IPV4:
	27	return mr_tcam->ruleset4;
	28	case MLXSW_SP_L3_PROTO_IPV6:
	29	return mr_tcam->ruleset6;
	30	}
	31	return NULL;
	32	}
	33
	34	static int mlxsw_sp2_mr_tcam_bind_group(struct mlxsw_sp *mlxsw_sp,
	35	enum mlxsw_reg_pemrbt_protocol protocol,
	36	struct mlxsw_sp_acl_ruleset *ruleset)
	37	{
	38	char pemrbt_pl[MLXSW_REG_PEMRBT_LEN];
	39	u16 group_id;
	40
	41	group_id = mlxsw_sp_acl_ruleset_group_id(ruleset);
	42
	43	mlxsw_reg_pemrbt_pack(pemrbt_pl, protocol, group_id);
	44	return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(pemrbt), pemrbt_pl);
	45	}
	46
	47	static const enum mlxsw_afk_element mlxsw_sp2_mr_tcam_usage_ipv4[] = {
6d5d8ebb AC	48	MLXSW_AFK_ELEMENT_VIRT_ROUTER_MSB,
6d5d8ebb AC	49	MLXSW_AFK_ELEMENT_VIRT_ROUTER_LSB,
cf7221a4 ND	50	MLXSW_AFK_ELEMENT_SRC_IP_0_31,
	51	MLXSW_AFK_ELEMENT_DST_IP_0_31,
	52	};
	53
	54	static int mlxsw_sp2_mr_tcam_ipv4_init(struct mlxsw_sp2_mr_tcam *mr_tcam)
	55	{
	56	struct mlxsw_afk_element_usage elusage;
	57	int err;
	58
	59	/* Initialize IPv4 ACL group. */
	60	mlxsw_afk_element_usage_fill(&elusage,
	61	mlxsw_sp2_mr_tcam_usage_ipv4,
	62	ARRAY_SIZE(mlxsw_sp2_mr_tcam_usage_ipv4));
	63	mr_tcam->ruleset4 = mlxsw_sp_acl_ruleset_get(mr_tcam->mlxsw_sp,
3bc3ffb6	64	mr_tcam->flow_block,
cf7221a4 ND	65	MLXSW_SP_L3_PROTO_IPV4,
	66	MLXSW_SP_ACL_PROFILE_MR,
	67	&elusage);
	68
	69	if (IS_ERR(mr_tcam->ruleset4))
	70	return PTR_ERR(mr_tcam->ruleset4);
	71
	72	/* MC Router groups should be bound before routes are inserted. */
	73	err = mlxsw_sp2_mr_tcam_bind_group(mr_tcam->mlxsw_sp,
	74	MLXSW_REG_PEMRBT_PROTO_IPV4,
	75	mr_tcam->ruleset4);
	76	if (err)
	77	goto err_bind_group;
	78
	79	return 0;
	80
	81	err_bind_group:
	82	mlxsw_sp_acl_ruleset_put(mr_tcam->mlxsw_sp, mr_tcam->ruleset4);
	83	return err;
	84	}
	85
	86	static void mlxsw_sp2_mr_tcam_ipv4_fini(struct mlxsw_sp2_mr_tcam *mr_tcam)
	87	{
	88	mlxsw_sp_acl_ruleset_put(mr_tcam->mlxsw_sp, mr_tcam->ruleset4);
	89	}
	90
	91	static const enum mlxsw_afk_element mlxsw_sp2_mr_tcam_usage_ipv6[] = {
6d5d8ebb AC	92	MLXSW_AFK_ELEMENT_VIRT_ROUTER_MSB,
6d5d8ebb AC	93	MLXSW_AFK_ELEMENT_VIRT_ROUTER_LSB,
cf7221a4 ND	94	MLXSW_AFK_ELEMENT_SRC_IP_96_127,
	95	MLXSW_AFK_ELEMENT_SRC_IP_64_95,
	96	MLXSW_AFK_ELEMENT_SRC_IP_32_63,
	97	MLXSW_AFK_ELEMENT_SRC_IP_0_31,
	98	MLXSW_AFK_ELEMENT_DST_IP_96_127,
	99	MLXSW_AFK_ELEMENT_DST_IP_64_95,
	100	MLXSW_AFK_ELEMENT_DST_IP_32_63,
	101	MLXSW_AFK_ELEMENT_DST_IP_0_31,
	102	};
	103
	104	static int mlxsw_sp2_mr_tcam_ipv6_init(struct mlxsw_sp2_mr_tcam *mr_tcam)
	105	{
	106	struct mlxsw_afk_element_usage elusage;
	107	int err;
	108
	109	/* Initialize IPv6 ACL group */
	110	mlxsw_afk_element_usage_fill(&elusage,
	111	mlxsw_sp2_mr_tcam_usage_ipv6,
	112	ARRAY_SIZE(mlxsw_sp2_mr_tcam_usage_ipv6));
	113	mr_tcam->ruleset6 = mlxsw_sp_acl_ruleset_get(mr_tcam->mlxsw_sp,
3bc3ffb6	114	mr_tcam->flow_block,
cf7221a4 ND	115	MLXSW_SP_L3_PROTO_IPV6,
	116	MLXSW_SP_ACL_PROFILE_MR,
	117	&elusage);
	118
	119	if (IS_ERR(mr_tcam->ruleset6))
	120	return PTR_ERR(mr_tcam->ruleset6);
	121
	122	/* MC Router groups should be bound before routes are inserted. */
	123	err = mlxsw_sp2_mr_tcam_bind_group(mr_tcam->mlxsw_sp,
	124	MLXSW_REG_PEMRBT_PROTO_IPV6,
	125	mr_tcam->ruleset6);
	126	if (err)
	127	goto err_bind_group;
	128
	129	return 0;
	130
	131	err_bind_group:
	132	mlxsw_sp_acl_ruleset_put(mr_tcam->mlxsw_sp, mr_tcam->ruleset6);
	133	return err;
	134	}
	135
	136	static void mlxsw_sp2_mr_tcam_ipv6_fini(struct mlxsw_sp2_mr_tcam *mr_tcam)
	137	{
	138	mlxsw_sp_acl_ruleset_put(mr_tcam->mlxsw_sp, mr_tcam->ruleset6);
	139	}
	140
	141	static void
	142	mlxsw_sp2_mr_tcam_rule_parse4(struct mlxsw_sp_acl_rule_info *rulei,
	143	struct mlxsw_sp_mr_route_key *key)
	144	{
	145	mlxsw_sp_acl_rulei_keymask_buf(rulei, MLXSW_AFK_ELEMENT_SRC_IP_0_31,
	146	(char *) &key->source.addr4,
	147	(char *) &key->source_mask.addr4, 4);
	148	mlxsw_sp_acl_rulei_keymask_buf(rulei, MLXSW_AFK_ELEMENT_DST_IP_0_31,
	149	(char *) &key->group.addr4,
	150	(char *) &key->group_mask.addr4, 4);
	151	}
	152
	153	static void
	154	mlxsw_sp2_mr_tcam_rule_parse6(struct mlxsw_sp_acl_rule_info *rulei,
	155	struct mlxsw_sp_mr_route_key *key)
	156	{
	157	mlxsw_sp_acl_rulei_keymask_buf(rulei, MLXSW_AFK_ELEMENT_SRC_IP_96_127,
	158	&key->source.addr6.s6_addr[0x0],
	159	&key->source_mask.addr6.s6_addr[0x0], 4);
	160	mlxsw_sp_acl_rulei_keymask_buf(rulei, MLXSW_AFK_ELEMENT_SRC_IP_64_95,
	161	&key->source.addr6.s6_addr[0x4],
	162	&key->source_mask.addr6.s6_addr[0x4], 4);
	163	mlxsw_sp_acl_rulei_keymask_buf(rulei, MLXSW_AFK_ELEMENT_SRC_IP_32_63,
	164	&key->source.addr6.s6_addr[0x8],
	165	&key->source_mask.addr6.s6_addr[0x8], 4);
	166	mlxsw_sp_acl_rulei_keymask_buf(rulei, MLXSW_AFK_ELEMENT_SRC_IP_0_31,
	167	&key->source.addr6.s6_addr[0xc],
	168	&key->source_mask.addr6.s6_addr[0xc], 4);
	169	mlxsw_sp_acl_rulei_keymask_buf(rulei, MLXSW_AFK_ELEMENT_DST_IP_96_127,
	170	&key->group.addr6.s6_addr[0x0],
	171	&key->group_mask.addr6.s6_addr[0x0], 4);
	172	mlxsw_sp_acl_rulei_keymask_buf(rulei, MLXSW_AFK_ELEMENT_DST_IP_64_95,
	173	&key->group.addr6.s6_addr[0x4],
	174	&key->group_mask.addr6.s6_addr[0x4], 4);
	175	mlxsw_sp_acl_rulei_keymask_buf(rulei, MLXSW_AFK_ELEMENT_DST_IP_32_63,
	176	&key->group.addr6.s6_addr[0x8],
	177	&key->group_mask.addr6.s6_addr[0x8], 4);
	178	mlxsw_sp_acl_rulei_keymask_buf(rulei, MLXSW_AFK_ELEMENT_DST_IP_0_31,
179	&key->group.addr6.s6_addr[0xc],
180	&key->group_mask.addr6.s6_addr[0xc], 4);
181	}
182
183	static void
184	mlxsw_sp2_mr_tcam_rule_parse(struct mlxsw_sp_acl_rule *rule,
185	struct mlxsw_sp_mr_route_key *key,
186	unsigned int priority)
187	{
188	struct mlxsw_sp_acl_rule_info *rulei;
189
190	rulei = mlxsw_sp_acl_rule_rulei(rule);
191	rulei->priority = priority;
6d5d8ebb	192	mlxsw_sp_acl_rulei_keymask_u32(rulei, MLXSW_AFK_ELEMENT_VIRT_ROUTER_LSB,
cf7221a4 ND	193	key->vrid, GENMASK(7, 0));
cf7221a4 ND	194	mlxsw_sp_acl_rulei_keymask_u32(rulei,
6d5d8ebb	195	MLXSW_AFK_ELEMENT_VIRT_ROUTER_MSB,
cf7221a4 ND	196	key->vrid >> 8, GENMASK(2, 0));
	197	switch (key->proto) {
	198	case MLXSW_SP_L3_PROTO_IPV4:
	199	return mlxsw_sp2_mr_tcam_rule_parse4(rulei, key);
	200	case MLXSW_SP_L3_PROTO_IPV6:
	201	return mlxsw_sp2_mr_tcam_rule_parse6(rulei, key);
	202	}
	203	}
	204
18ce0e4e JP	205	static int
	206	mlxsw_sp2_mr_tcam_route_create(struct mlxsw_sp mlxsw_sp, void priv,
	207	void *route_priv,
	208	struct mlxsw_sp_mr_route_key *key,
	209	struct mlxsw_afa_block *afa_block,
	210	enum mlxsw_sp_mr_route_prio prio)
	211	{
cf7221a4 ND	212	struct mlxsw_sp2_mr_route *mr_route = route_priv;
	213	struct mlxsw_sp2_mr_tcam *mr_tcam = priv;
	214	struct mlxsw_sp_acl_ruleset *ruleset;
	215	struct mlxsw_sp_acl_rule *rule;
	216	int err;
	217
	218	mr_route->mr_tcam = mr_tcam;
	219	ruleset = mlxsw_sp2_mr_tcam_proto_ruleset(mr_tcam, key->proto);
	220	if (WARN_ON(!ruleset))
	221	return -EINVAL;
	222
	223	rule = mlxsw_sp_acl_rule_create(mlxsw_sp, ruleset,
	224	(unsigned long) route_priv, afa_block,
	225	NULL);
	226	if (IS_ERR(rule))
	227	return PTR_ERR(rule);
	228
	229	mlxsw_sp2_mr_tcam_rule_parse(rule, key, prio);
	230	err = mlxsw_sp_acl_rule_add(mlxsw_sp, rule);
	231	if (err)
	232	goto err_rule_add;
	233
18ce0e4e	234	return 0;
cf7221a4 ND	235
	236	err_rule_add:
	237	mlxsw_sp_acl_rule_destroy(mlxsw_sp, rule);
	238	return err;
18ce0e4e JP	239	}
	240
	241	static void
	242	mlxsw_sp2_mr_tcam_route_destroy(struct mlxsw_sp mlxsw_sp, void priv,
	243	void *route_priv,
	244	struct mlxsw_sp_mr_route_key *key)
	245	{
cf7221a4 ND	246	struct mlxsw_sp2_mr_tcam *mr_tcam = priv;
	247	struct mlxsw_sp_acl_ruleset *ruleset;
	248	struct mlxsw_sp_acl_rule *rule;
	249
	250	ruleset = mlxsw_sp2_mr_tcam_proto_ruleset(mr_tcam, key->proto);
	251	if (WARN_ON(!ruleset))
	252	return;
	253
	254	rule = mlxsw_sp_acl_rule_lookup(mlxsw_sp, ruleset,
	255	(unsigned long) route_priv);
	256	if (WARN_ON(!rule))
	257	return;
	258
	259	mlxsw_sp_acl_rule_del(mlxsw_sp, rule);
	260	mlxsw_sp_acl_rule_destroy(mlxsw_sp, rule);
18ce0e4e JP	261	}
	262
	263	static int
	264	mlxsw_sp2_mr_tcam_route_update(struct mlxsw_sp *mlxsw_sp,
	265	void *route_priv,
	266	struct mlxsw_sp_mr_route_key *key,
	267	struct mlxsw_afa_block *afa_block)
	268	{
cf7221a4 ND	269	struct mlxsw_sp2_mr_route *mr_route = route_priv;
	270	struct mlxsw_sp2_mr_tcam *mr_tcam = mr_route->mr_tcam;
	271	struct mlxsw_sp_acl_ruleset *ruleset;
	272	struct mlxsw_sp_acl_rule *rule;
	273
	274	ruleset = mlxsw_sp2_mr_tcam_proto_ruleset(mr_tcam, key->proto);
	275	if (WARN_ON(!ruleset))
	276	return -EINVAL;
	277
	278	rule = mlxsw_sp_acl_rule_lookup(mlxsw_sp, ruleset,
	279	(unsigned long) route_priv);
	280	if (WARN_ON(!rule))
	281	return -EINVAL;
	282
	283	return mlxsw_sp_acl_rule_action_replace(mlxsw_sp, rule, afa_block);
18ce0e4e JP	284	}
	285
	286	static int mlxsw_sp2_mr_tcam_init(struct mlxsw_sp mlxsw_sp, void priv)
	287	{
cf7221a4 ND	288	struct mlxsw_sp2_mr_tcam *mr_tcam = priv;
	289	int err;
	290
	291	mr_tcam->mlxsw_sp = mlxsw_sp;
3bc3ffb6 JP	292	mr_tcam->flow_block = mlxsw_sp_flow_block_create(mlxsw_sp, NULL);
3bc3ffb6 JP	293	if (!mr_tcam->flow_block)
cf7221a4 ND	294	return -ENOMEM;
	295
	296	err = mlxsw_sp2_mr_tcam_ipv4_init(mr_tcam);
	297	if (err)
	298	goto err_ipv4_init;
	299
	300	err = mlxsw_sp2_mr_tcam_ipv6_init(mr_tcam);
	301	if (err)
	302	goto err_ipv6_init;
	303
18ce0e4e	304	return 0;
cf7221a4 ND	305
	306	err_ipv6_init:
	307	mlxsw_sp2_mr_tcam_ipv4_fini(mr_tcam);
	308	err_ipv4_init:
3bc3ffb6	309	mlxsw_sp_flow_block_destroy(mr_tcam->flow_block);
cf7221a4	310	return err;
18ce0e4e JP	311	}
	312
	313	static void mlxsw_sp2_mr_tcam_fini(void *priv)
	314	{
cf7221a4 ND	315	struct mlxsw_sp2_mr_tcam *mr_tcam = priv;
	316
	317	mlxsw_sp2_mr_tcam_ipv6_fini(mr_tcam);
	318	mlxsw_sp2_mr_tcam_ipv4_fini(mr_tcam);
3bc3ffb6	319	mlxsw_sp_flow_block_destroy(mr_tcam->flow_block);
18ce0e4e JP	320	}
	321
	322	const struct mlxsw_sp_mr_tcam_ops mlxsw_sp2_mr_tcam_ops = {
cf7221a4	323	.priv_size = sizeof(struct mlxsw_sp2_mr_tcam),
18ce0e4e JP	324	.init = mlxsw_sp2_mr_tcam_init,
18ce0e4e JP	325	.fini = mlxsw_sp2_mr_tcam_fini,
cf7221a4	326	.route_priv_size = sizeof(struct mlxsw_sp2_mr_route),
18ce0e4e JP	327	.route_create = mlxsw_sp2_mr_tcam_route_create,
	328	.route_destroy = mlxsw_sp2_mr_tcam_route_destroy,
	329	.route_update = mlxsw_sp2_mr_tcam_route_update,
	330	};