Commit f53e1432 authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'sparx5-TC-key' 

Steen Hegelund says:

====================
Extend TC key support for Sparx5 IS2 VCAP

This provides extended tc flower filter key support for the Sparx5 VCAP
functionality.

It builds on top of the initial IS2 VCAP support found in this series:

https://lore.kernel.org/all/20221020130904.1215072-1-steen.hegelund@microchip.com/



Overview:
=========

The added flower filter key (dissector) support is this:

- ipv4_addr (sip and dip)
- ipv6_addr (sip and dip)
- control (IPv4 fragments)
- portnum (tcp and udp port numbers)
- basic (L3 and L4 protocol)
- vlan (outer vlan tag info)
- tcp (tcp flags)
- ip (tos field)

The IS2 VCAP supports classified VLAN information which amounts to the
outer VLAN info in case of multiple tags.

Functionality:
==============

Before frames can match IS2 VCAP rules with e.g an IPv4 source address, the
IS2 VCAPs keyset configuration must include keyset that contains a IPv4
source address and this must be configured for the lookup/port/traffic-type
that you want to match on.

The Sparx5 IS2 VCAP has the following traffic types:

- Non-Ethernet frames
- IPv4 Unicast frames
- IPv4 Multicast frames
- IPv6 Unicast frames
- IPv6 Multicast frames
- ARP frames

So to cover IPv4 traffic the two IPv4 categories must be configured with a
keyset that contains IPv4 address information such as the
VCAP_KFS_IP4_TCP_UDP keyset.

The IPv4 and IPv6 traffic types are configured with useful default keysets,
in later series we will use the tc template functionality when we want to
change these defaults.

The flower filter must contain a goto action as its last action and the
chain id must specify the chain id of the next lookup in a VCAP or a
destination outside the VCAP ranges.

To activate the VCAP lookups on a port you must add a TC matchall filter on
the port containing a single goto action that points to the chain id of the
first lookup in the IS2 VCAP.

From then on frames arriving on this port will be matched against the
rules in the IS2 VCAP lookups.

Removing the matchall filter will deactivate the IS2 lookups, but will
leave the VCAP rules in the memory of the VCAP instance, and from then in
frames will no longer be matched against the rules the in IS2 VCAP.

If the matchall rule is added back again the IS2 rules will be active
once more.

Delivery:
=========

This is current plan for delivering the full VCAP feature set of Sparx5:

- TC flower filter statistics and rule order by size and priority
- debugfs support for inspecting rules
- support for TC protocol all
- Sparx5 IS0 VCAP support
- add TC policer and drop action support (depends on the Sparx5 QoS support
  upstreamed separately)
- Sparx5 ES0 VCAP support
- TC flower template support
- TC matchall filter support for mirroring and policing ports
- TC flower filter mirror action support
- Sparx5 ES2 VCAP support

Version History:
================
v6      Rebased on the latest next-next master branch.
        No other implementation changes.

v5      Add support for a TC matchall filter with a single goto action
        which will activate the lookups of the VCAP.  Removing this filter
        will deactivate the VCAP lookups again.

v4      Add support for TC flower filter goto action and a check of the
        actions: check action combinations and the goto chain id.

v3      Add some more details to the explanation in the commit message
        about support for MAC_ETYPE keysets and "protocol all" as well as
        the classified VLAN information.  This is done to help testing the
        feature.
        No implementation changes in this version.

v2      Split one of the KUNIT tests into 3 tests to fix a kernel robot
        build warning.

v1      Initial version
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 573c3853 c956b9b3

drivers/net/ethernet/microchip/sparx5/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -9,7 +9,7 @@ sparx5-switch-y := sparx5_main.o sparx5_packet.o \ 
 sparx5_netdev.o sparx5_phylink.o sparx5_port.o sparx5_mactable.o sparx5_vlan.o \

 sparx5_switchdev.o sparx5_calendar.o sparx5_ethtool.o sparx5_fdma.o \

 sparx5_ptp.o sparx5_pgid.o sparx5_tc.o sparx5_qos.o \

 sparx5_vcap_impl.o sparx5_vcap_ag_api.o sparx5_tc_flower.o

 sparx5_vcap_impl.o sparx5_vcap_ag_api.o sparx5_tc_flower.o sparx5_tc_matchall.o



sparx5-switch-$(CONFIG_SPARX5_DCB) += sparx5_dcb.o

drivers/net/ethernet/microchip/sparx5/sparx5_tc.c

+7 −2
Original line number Diff line number Diff line
@@ -19,10 +19,15 @@ static int sparx5_tc_block_cb(enum tc_setup_type type, 
{

	struct net_device *ndev = cb_priv;



	if (type == TC_SETUP_CLSFLOWER)

	switch (type) {

	case TC_SETUP_CLSMATCHALL:

		return sparx5_tc_matchall(ndev, type_data, ingress);

	case TC_SETUP_CLSFLOWER:

		return sparx5_tc_flower(ndev, type_data, ingress);

	default:

		return -EOPNOTSUPP;

	}

}



static int sparx5_tc_block_cb_ingress(enum tc_setup_type type,

				      void *type_data,

drivers/net/ethernet/microchip/sparx5/sparx5_tc.h

+5 −0
Original line number Diff line number Diff line
@@ -8,6 +8,7 @@ 
#define __SPARX5_TC_H__



#include <net/flow_offload.h>

#include <net/pkt_cls.h>

#include <linux/netdevice.h>



/* Controls how PORT_MASK is applied */
@@ -23,6 +24,10 @@ enum SPX5_PORT_MASK_MODE { 
int sparx5_port_setup_tc(struct net_device *ndev, enum tc_setup_type type,

			 void *type_data);



int sparx5_tc_matchall(struct net_device *ndev,

		       struct tc_cls_matchall_offload *tmo,

		       bool ingress);



int sparx5_tc_flower(struct net_device *ndev, struct flow_cls_offload *fco,

		     bool ingress);

drivers/net/ethernet/microchip/sparx5/sparx5_tc_flower.c

+461 −19
Original line number Diff line number Diff line
@@ -16,9 +16,32 @@ struct sparx5_tc_flower_parse_usage { 
	struct flow_cls_offload *fco;

	struct flow_rule *frule;

	struct vcap_rule *vrule;

	u16 l3_proto;

	u8 l4_proto;

	unsigned int used_keys;

};



/* These protocols have dedicated keysets in IS2 and a TC dissector

 * ETH_P_ARP does not have a TC dissector

 */

static u16 sparx5_tc_known_etypes[] = {

	ETH_P_ALL,

	ETH_P_IP,

	ETH_P_IPV6,

};



static bool sparx5_tc_is_known_etype(u16 etype)

{

	int idx;



	/* For now this only knows about IS2 traffic classification */

	for (idx = 0; idx < ARRAY_SIZE(sparx5_tc_known_etypes); ++idx)

		if (sparx5_tc_known_etypes[idx] == etype)

			return true;



	return false;

}



static int sparx5_tc_flower_handler_ethaddr_usage(struct sparx5_tc_flower_parse_usage *st)

{

	enum vcap_key_field smac_key = VCAP_KF_L2_SMAC;
@@ -54,18 +77,379 @@ static int sparx5_tc_flower_handler_ethaddr_usage(struct sparx5_tc_flower_parse_ 
	return err;

}



static int

sparx5_tc_flower_handler_ipv4_usage(struct sparx5_tc_flower_parse_usage *st)

{

	int err = 0;



	if (st->l3_proto == ETH_P_IP) {

		struct flow_match_ipv4_addrs mt;



		flow_rule_match_ipv4_addrs(st->frule, &mt);

		if (mt.mask->src) {

			err = vcap_rule_add_key_u32(st->vrule,

						    VCAP_KF_L3_IP4_SIP,

						    be32_to_cpu(mt.key->src),

						    be32_to_cpu(mt.mask->src));

			if (err)

				goto out;

		}

		if (mt.mask->dst) {

			err = vcap_rule_add_key_u32(st->vrule,

						    VCAP_KF_L3_IP4_DIP,

						    be32_to_cpu(mt.key->dst),

						    be32_to_cpu(mt.mask->dst));

			if (err)

				goto out;

		}

	}



	st->used_keys |= BIT(FLOW_DISSECTOR_KEY_IPV4_ADDRS);



	return err;



out:

	NL_SET_ERR_MSG_MOD(st->fco->common.extack, "ipv4_addr parse error");

	return err;

}



static int

sparx5_tc_flower_handler_ipv6_usage(struct sparx5_tc_flower_parse_usage *st)

{

	int err = 0;



	if (st->l3_proto == ETH_P_IPV6) {

		struct flow_match_ipv6_addrs mt;

		struct vcap_u128_key sip;

		struct vcap_u128_key dip;



		flow_rule_match_ipv6_addrs(st->frule, &mt);

		/* Check if address masks are non-zero */

		if (!ipv6_addr_any(&mt.mask->src)) {

			vcap_netbytes_copy(sip.value, mt.key->src.s6_addr, 16);

			vcap_netbytes_copy(sip.mask, mt.mask->src.s6_addr, 16);

			err = vcap_rule_add_key_u128(st->vrule,

						     VCAP_KF_L3_IP6_SIP, &sip);

			if (err)

				goto out;

		}

		if (!ipv6_addr_any(&mt.mask->dst)) {

			vcap_netbytes_copy(dip.value, mt.key->dst.s6_addr, 16);

			vcap_netbytes_copy(dip.mask, mt.mask->dst.s6_addr, 16);

			err = vcap_rule_add_key_u128(st->vrule,

						     VCAP_KF_L3_IP6_DIP, &dip);

			if (err)

				goto out;

		}

	}

	st->used_keys |= BIT(FLOW_DISSECTOR_KEY_IPV6_ADDRS);

	return err;

out:

	NL_SET_ERR_MSG_MOD(st->fco->common.extack, "ipv6_addr parse error");

	return err;

}



static int

sparx5_tc_flower_handler_control_usage(struct sparx5_tc_flower_parse_usage *st)

{

	struct flow_match_control mt;

	u32 value, mask;

	int err = 0;



	flow_rule_match_control(st->frule, &mt);



	if (mt.mask->flags) {

		if (mt.mask->flags & FLOW_DIS_FIRST_FRAG) {

			if (mt.key->flags & FLOW_DIS_FIRST_FRAG) {

				value = 1; /* initial fragment */

				mask = 0x3;

			} else {

				if (mt.mask->flags & FLOW_DIS_IS_FRAGMENT) {

					value = 3; /* follow up fragment */

					mask = 0x3;

				} else {

					value = 0; /* no fragment */

					mask = 0x3;

				}

			}

		} else {

			if (mt.mask->flags & FLOW_DIS_IS_FRAGMENT) {

				value = 3; /* follow up fragment */

				mask = 0x3;

			} else {

				value = 0; /* no fragment */

				mask = 0x3;

			}

		}



		err = vcap_rule_add_key_u32(st->vrule,

					    VCAP_KF_L3_FRAGMENT_TYPE,

					    value, mask);

		if (err)

			goto out;

	}



	st->used_keys |= BIT(FLOW_DISSECTOR_KEY_CONTROL);



	return err;



out:

	NL_SET_ERR_MSG_MOD(st->fco->common.extack, "ip_frag parse error");

	return err;

}



static int

sparx5_tc_flower_handler_portnum_usage(struct sparx5_tc_flower_parse_usage *st)

{

	struct flow_match_ports mt;

	u16 value, mask;

	int err = 0;



	flow_rule_match_ports(st->frule, &mt);



	if (mt.mask->src) {

		value = be16_to_cpu(mt.key->src);

		mask = be16_to_cpu(mt.mask->src);

		err = vcap_rule_add_key_u32(st->vrule, VCAP_KF_L4_SPORT, value,

					    mask);

		if (err)

			goto out;

	}



	if (mt.mask->dst) {

		value = be16_to_cpu(mt.key->dst);

		mask = be16_to_cpu(mt.mask->dst);

		err = vcap_rule_add_key_u32(st->vrule, VCAP_KF_L4_DPORT, value,

					    mask);

		if (err)

			goto out;

	}



	st->used_keys |= BIT(FLOW_DISSECTOR_KEY_PORTS);



	return err;



out:

	NL_SET_ERR_MSG_MOD(st->fco->common.extack, "port parse error");

	return err;

}



static int

sparx5_tc_flower_handler_basic_usage(struct sparx5_tc_flower_parse_usage *st)

{

	struct flow_match_basic mt;

	int err = 0;



	flow_rule_match_basic(st->frule, &mt);



	if (mt.mask->n_proto) {

		st->l3_proto = be16_to_cpu(mt.key->n_proto);

		if (!sparx5_tc_is_known_etype(st->l3_proto)) {

			err = vcap_rule_add_key_u32(st->vrule, VCAP_KF_ETYPE,

						    st->l3_proto, ~0);

			if (err)

				goto out;

		} else if (st->l3_proto == ETH_P_IP) {

			err = vcap_rule_add_key_bit(st->vrule, VCAP_KF_IP4_IS,

						    VCAP_BIT_1);

			if (err)

				goto out;

		} else if (st->l3_proto == ETH_P_IPV6) {

			err = vcap_rule_add_key_bit(st->vrule, VCAP_KF_IP4_IS,

						    VCAP_BIT_0);

			if (err)

				goto out;

		}

	}



	if (mt.mask->ip_proto) {

		st->l4_proto = mt.key->ip_proto;

		if (st->l4_proto == IPPROTO_TCP) {

			err = vcap_rule_add_key_bit(st->vrule,

						    VCAP_KF_TCP_IS,

						    VCAP_BIT_1);

			if (err)

				goto out;

		} else if (st->l4_proto == IPPROTO_UDP) {

			err = vcap_rule_add_key_bit(st->vrule,

						    VCAP_KF_TCP_IS,

						    VCAP_BIT_0);

			if (err)

				goto out;

		} else {

			err = vcap_rule_add_key_u32(st->vrule,

						    VCAP_KF_L3_IP_PROTO,

						    st->l4_proto, ~0);

			if (err)

				goto out;

		}

	}



	st->used_keys |= BIT(FLOW_DISSECTOR_KEY_BASIC);



	return err;



out:

	NL_SET_ERR_MSG_MOD(st->fco->common.extack, "ip_proto parse error");

	return err;

}



static int

sparx5_tc_flower_handler_vlan_usage(struct sparx5_tc_flower_parse_usage *st)

{

	enum vcap_key_field vid_key = VCAP_KF_8021Q_VID_CLS;

	enum vcap_key_field pcp_key = VCAP_KF_8021Q_PCP_CLS;

	struct flow_match_vlan mt;

	int err;



	flow_rule_match_vlan(st->frule, &mt);



	if (mt.mask->vlan_id) {

		err = vcap_rule_add_key_u32(st->vrule, vid_key,

					    mt.key->vlan_id,

					    mt.mask->vlan_id);

		if (err)

			goto out;

	}



	if (mt.mask->vlan_priority) {

		err = vcap_rule_add_key_u32(st->vrule, pcp_key,

					    mt.key->vlan_priority,

					    mt.mask->vlan_priority);

		if (err)

			goto out;

	}



	st->used_keys |= BIT(FLOW_DISSECTOR_KEY_VLAN);



	return err;

out:

	NL_SET_ERR_MSG_MOD(st->fco->common.extack, "vlan parse error");

	return err;

}



static int

sparx5_tc_flower_handler_tcp_usage(struct sparx5_tc_flower_parse_usage *st)

{

	struct flow_match_tcp mt;

	u16 tcp_flags_mask;

	u16 tcp_flags_key;

	enum vcap_bit val;

	int err = 0;



	flow_rule_match_tcp(st->frule, &mt);

	tcp_flags_key = be16_to_cpu(mt.key->flags);

	tcp_flags_mask = be16_to_cpu(mt.mask->flags);



	if (tcp_flags_mask & TCPHDR_FIN) {

		val = VCAP_BIT_0;

		if (tcp_flags_key & TCPHDR_FIN)

			val = VCAP_BIT_1;

		err = vcap_rule_add_key_bit(st->vrule, VCAP_KF_L4_FIN, val);

		if (err)

			goto out;

	}



	if (tcp_flags_mask & TCPHDR_SYN) {

		val = VCAP_BIT_0;

		if (tcp_flags_key & TCPHDR_SYN)

			val = VCAP_BIT_1;

		err = vcap_rule_add_key_bit(st->vrule, VCAP_KF_L4_SYN, val);

		if (err)

			goto out;

	}



	if (tcp_flags_mask & TCPHDR_RST) {

		val = VCAP_BIT_0;

		if (tcp_flags_key & TCPHDR_RST)

			val = VCAP_BIT_1;

		err = vcap_rule_add_key_bit(st->vrule, VCAP_KF_L4_RST, val);

		if (err)

			goto out;

	}



	if (tcp_flags_mask & TCPHDR_PSH) {

		val = VCAP_BIT_0;

		if (tcp_flags_key & TCPHDR_PSH)

			val = VCAP_BIT_1;

		err = vcap_rule_add_key_bit(st->vrule, VCAP_KF_L4_PSH, val);

		if (err)

			goto out;

	}



	if (tcp_flags_mask & TCPHDR_ACK) {

		val = VCAP_BIT_0;

		if (tcp_flags_key & TCPHDR_ACK)

			val = VCAP_BIT_1;

		err = vcap_rule_add_key_bit(st->vrule, VCAP_KF_L4_ACK, val);

		if (err)

			goto out;

	}



	if (tcp_flags_mask & TCPHDR_URG) {

		val = VCAP_BIT_0;

		if (tcp_flags_key & TCPHDR_URG)

			val = VCAP_BIT_1;

		err = vcap_rule_add_key_bit(st->vrule, VCAP_KF_L4_URG, val);

		if (err)

			goto out;

	}



	st->used_keys |= BIT(FLOW_DISSECTOR_KEY_TCP);



	return err;



out:

	NL_SET_ERR_MSG_MOD(st->fco->common.extack, "tcp_flags parse error");

	return err;

}



static int

sparx5_tc_flower_handler_ip_usage(struct sparx5_tc_flower_parse_usage *st)

{

	struct flow_match_ip mt;

	int err = 0;



	flow_rule_match_ip(st->frule, &mt);



	if (mt.mask->tos) {

		err = vcap_rule_add_key_u32(st->vrule, VCAP_KF_L3_TOS,

					    mt.key->tos,

					    mt.mask->tos);

		if (err)

			goto out;

	}



	st->used_keys |= BIT(FLOW_DISSECTOR_KEY_IP);



	return err;



out:

	NL_SET_ERR_MSG_MOD(st->fco->common.extack, "ip_tos parse error");

	return err;

}



static int (*sparx5_tc_flower_usage_handlers[])(struct sparx5_tc_flower_parse_usage *st) = {

	/* More dissector handlers will be added here later */

	[FLOW_DISSECTOR_KEY_ETH_ADDRS] = sparx5_tc_flower_handler_ethaddr_usage,

	[FLOW_DISSECTOR_KEY_IPV4_ADDRS] = sparx5_tc_flower_handler_ipv4_usage,

	[FLOW_DISSECTOR_KEY_IPV6_ADDRS] = sparx5_tc_flower_handler_ipv6_usage,

	[FLOW_DISSECTOR_KEY_CONTROL] = sparx5_tc_flower_handler_control_usage,

	[FLOW_DISSECTOR_KEY_PORTS] = sparx5_tc_flower_handler_portnum_usage,

	[FLOW_DISSECTOR_KEY_BASIC] = sparx5_tc_flower_handler_basic_usage,

	[FLOW_DISSECTOR_KEY_VLAN] = sparx5_tc_flower_handler_vlan_usage,

	[FLOW_DISSECTOR_KEY_TCP] = sparx5_tc_flower_handler_tcp_usage,

	[FLOW_DISSECTOR_KEY_IP] = sparx5_tc_flower_handler_ip_usage,

};



static int sparx5_tc_use_dissectors(struct flow_cls_offload *fco,

				    struct vcap_admin *admin,

				    struct vcap_rule *vrule)

				    struct vcap_rule *vrule,

				    u16 *l3_proto)

{

	struct sparx5_tc_flower_parse_usage state = {

		.fco = fco,

		.vrule = vrule,

		.l3_proto = ETH_P_ALL,

	};

	int idx, err = 0;
@@ -79,9 +463,72 @@ static int sparx5_tc_use_dissectors(struct flow_cls_offload *fco, 
		if (err)

			return err;

	}



	if (state.frule->match.dissector->used_keys ^ state.used_keys) {

		NL_SET_ERR_MSG_MOD(fco->common.extack,

				   "Unsupported match item");

		return -ENOENT;

	}



	if (l3_proto)

		*l3_proto = state.l3_proto;

	return err;

}



static int sparx5_tc_flower_action_check(struct vcap_control *vctrl,

					 struct flow_cls_offload *fco,

					 struct vcap_admin *admin)

{

	struct flow_rule *rule = flow_cls_offload_flow_rule(fco);

	struct flow_action_entry *actent, *last_actent = NULL;

	struct flow_action *act = &rule->action;

	u64 action_mask = 0;

	int idx;



	if (!flow_action_has_entries(act)) {

		NL_SET_ERR_MSG_MOD(fco->common.extack, "No actions");

		return -EINVAL;

	}



	if (!flow_action_basic_hw_stats_check(act, fco->common.extack))

		return -EOPNOTSUPP;



	flow_action_for_each(idx, actent, act) {

		if (action_mask & BIT(actent->id)) {

			NL_SET_ERR_MSG_MOD(fco->common.extack,

					   "More actions of the same type");

			return -EINVAL;

		}

		action_mask |= BIT(actent->id);

		last_actent = actent; /* Save last action for later check */

	}



	/* Check that last action is a goto */

	if (last_actent->id != FLOW_ACTION_GOTO) {

		NL_SET_ERR_MSG_MOD(fco->common.extack,

				   "Last action must be 'goto'");

		return -EINVAL;

	}



	/* Check if the goto chain is in the next lookup */

	if (!vcap_is_next_lookup(vctrl, fco->common.chain_index,

				 last_actent->chain_index)) {

		NL_SET_ERR_MSG_MOD(fco->common.extack,

				   "Invalid goto chain");

		return -EINVAL;

	}



	/* Catch unsupported combinations of actions */

	if (action_mask & BIT(FLOW_ACTION_TRAP) &&

	    action_mask & BIT(FLOW_ACTION_ACCEPT)) {

		NL_SET_ERR_MSG_MOD(fco->common.extack,

				   "Cannot combine pass and trap action");

		return -EOPNOTSUPP;

	}



	return 0;

}



static int sparx5_tc_flower_replace(struct net_device *ndev,

				    struct flow_cls_offload *fco,

				    struct vcap_admin *admin)
@@ -91,25 +538,23 @@ static int sparx5_tc_flower_replace(struct net_device *ndev, 
	struct vcap_control *vctrl;

	struct flow_rule *frule;

	struct vcap_rule *vrule;

	u16 l3_proto;

	int err, idx;



	frule = flow_cls_offload_flow_rule(fco);

	if (!flow_action_has_entries(&frule->action)) {

		NL_SET_ERR_MSG_MOD(fco->common.extack, "No actions");

		return -EINVAL;

	}

	vctrl = port->sparx5->vcap_ctrl;



	if (!flow_action_basic_hw_stats_check(&frule->action, fco->common.extack))

		return -EOPNOTSUPP;

	err = sparx5_tc_flower_action_check(vctrl, fco, admin);

	if (err)

		return err;



	vctrl = port->sparx5->vcap_ctrl;

	vrule = vcap_alloc_rule(vctrl, ndev, fco->common.chain_index, VCAP_USER_TC,

				fco->common.prio, 0);

	if (IS_ERR(vrule))

		return PTR_ERR(vrule);



	vrule->cookie = fco->cookie;

	sparx5_tc_use_dissectors(fco, admin, vrule);

	sparx5_tc_use_dissectors(fco, admin, vrule, &l3_proto);

	frule = flow_cls_offload_flow_rule(fco);

	flow_action_for_each(idx, act, &frule->action) {

		switch (act->id) {

		case FLOW_ACTION_TRAP:
@@ -139,6 +584,9 @@ static int sparx5_tc_flower_replace(struct net_device *ndev, 
			if (err)

				goto out;

			break;

		case FLOW_ACTION_GOTO:

			/* Links between VCAPs will be added later */

			break;

		default:

			NL_SET_ERR_MSG_MOD(fco->common.extack,

					   "Unsupported TC action");
@@ -146,14 +594,8 @@ static int sparx5_tc_flower_replace(struct net_device *ndev, 
			goto out;

		}

	}

	/* For now the keyset is hardcoded */

	err = vcap_set_rule_set_keyset(vrule, VCAP_KFS_MAC_ETYPE);

	if (err) {

		NL_SET_ERR_MSG_MOD(fco->common.extack,

				   "No matching port keyset for filter protocol and keys");

		goto out;

	}

	err = vcap_val_rule(vrule, ETH_P_ALL);

	/* provide the l3 protocol to guide the keyset selection */

	err = vcap_val_rule(vrule, l3_proto);

	if (err) {

		vcap_set_tc_exterr(fco, vrule);

		goto out;

drivers/net/ethernet/microchip/sparx5/sparx5_tc_matchall.c

0 → 100644
+97 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0+

/* Microchip VCAP API

 *

 * Copyright (c) 2022 Microchip Technology Inc. and its subsidiaries.

 */



#include "sparx5_tc.h"

#include "vcap_api.h"

#include "vcap_api_client.h"

#include "sparx5_main_regs.h"

#include "sparx5_main.h"

#include "sparx5_vcap_impl.h"



static int sparx5_tc_matchall_replace(struct net_device *ndev,

				      struct tc_cls_matchall_offload *tmo,

				      bool ingress)

{

	struct sparx5_port *port = netdev_priv(ndev);

	struct flow_action_entry *action;

	struct sparx5 *sparx5;

	int err;



	if (!flow_offload_has_one_action(&tmo->rule->action)) {

		NL_SET_ERR_MSG_MOD(tmo->common.extack,

				   "Only one action per filter is supported");

		return -EOPNOTSUPP;

	}

	action = &tmo->rule->action.entries[0];



	sparx5 = port->sparx5;

	switch (action->id) {

	case FLOW_ACTION_GOTO:

		err = vcap_enable_lookups(sparx5->vcap_ctrl, ndev,

					  action->chain_index, tmo->cookie,

					  true);

		if (err == -EFAULT) {

			NL_SET_ERR_MSG_MOD(tmo->common.extack,

					   "Unsupported goto chain");

			return -EOPNOTSUPP;

		}

		if (err == -EADDRINUSE) {

			NL_SET_ERR_MSG_MOD(tmo->common.extack,

					   "VCAP already enabled");

			return -EOPNOTSUPP;

		}

		if (err) {

			NL_SET_ERR_MSG_MOD(tmo->common.extack,

					   "Could not enable VCAP lookups");

			return err;

		}

		break;

	default:

		NL_SET_ERR_MSG_MOD(tmo->common.extack, "Unsupported action");

		return -EOPNOTSUPP;

	}

	return 0;

}



static int sparx5_tc_matchall_destroy(struct net_device *ndev,

				      struct tc_cls_matchall_offload *tmo,

				      bool ingress)

{

	struct sparx5_port *port = netdev_priv(ndev);

	struct sparx5 *sparx5;

	int err;



	sparx5 = port->sparx5;

	if (!tmo->rule && tmo->cookie) {

		err = vcap_enable_lookups(sparx5->vcap_ctrl, ndev, 0,

					  tmo->cookie, false);

		if (err)

			return err;

		return 0;

	}

	NL_SET_ERR_MSG_MOD(tmo->common.extack, "Unsupported action");

	return -EOPNOTSUPP;

}



int sparx5_tc_matchall(struct net_device *ndev,

		       struct tc_cls_matchall_offload *tmo,

		       bool ingress)

{

	if (!tc_cls_can_offload_and_chain0(ndev, &tmo->common)) {

		NL_SET_ERR_MSG_MOD(tmo->common.extack,

				   "Only chain zero is supported");

		return -EOPNOTSUPP;

	}



	switch (tmo->command) {

	case TC_CLSMATCHALL_REPLACE:

		return sparx5_tc_matchall_replace(ndev, tmo, ingress);

	case TC_CLSMATCHALL_DESTROY:

		return sparx5_tc_matchall_destroy(ndev, tmo, ingress);

	default:

		return -EOPNOTSUPP;

	}

}