PSFP support gate and police action. This patch add the gate and police
action to flower parse action, check chain ID to determine which block
to offload. Adding psfp callback functions to add, delete and update gate
and police in PSFP table if hardware supports it.
Signed-off-by: Xiaoliang Yang <[email protected]>
---
drivers/net/ethernet/mscc/ocelot_flower.c | 52 ++++++++++++++++++++++-
include/soc/mscc/ocelot.h | 4 ++
include/soc/mscc/ocelot_vcap.h | 1 +
3 files changed, 55 insertions(+), 2 deletions(-)
diff --git a/drivers/net/ethernet/mscc/ocelot_flower.c b/drivers/net/ethernet/mscc/ocelot_flower.c
index ce812194e44c..daeaee99933d 100644
--- a/drivers/net/ethernet/mscc/ocelot_flower.c
+++ b/drivers/net/ethernet/mscc/ocelot_flower.c
@@ -220,10 +220,14 @@ static int ocelot_flower_parse_action(struct ocelot *ocelot, int port,
filter->type = OCELOT_VCAP_FILTER_OFFLOAD;
break;
case FLOW_ACTION_POLICE:
+ if (filter->block_id == PSFP_BLOCK_ID) {
+ filter->type = OCELOT_PSFP_FILTER_OFFLOAD;
+ break;
+ }
if (filter->block_id != VCAP_IS2 ||
filter->lookup != 0) {
NL_SET_ERR_MSG_MOD(extack,
- "Police action can only be offloaded to VCAP IS2 lookup 0");
+ "Police action can only be offloaded to VCAP IS2 lookup 0 or PSFP");
return -EOPNOTSUPP;
}
if (filter->goto_target != -1) {
@@ -356,6 +360,14 @@ static int ocelot_flower_parse_action(struct ocelot *ocelot, int port,
filter->action.pcp_a_val = a->vlan.prio;
filter->type = OCELOT_VCAP_FILTER_OFFLOAD;
break;
+ case FLOW_ACTION_GATE:
+ if (filter->block_id != PSFP_BLOCK_ID) {
+ NL_SET_ERR_MSG_MOD(extack,
+ "Gate action can only be offloaded to PSFP chain");
+ return -EOPNOTSUPP;
+ }
+ filter->type = OCELOT_PSFP_FILTER_OFFLOAD;
+ break;
default:
NL_SET_ERR_MSG_MOD(extack, "Cannot offload action");
return -EOPNOTSUPP;
@@ -646,6 +658,10 @@ static int ocelot_flower_parse(struct ocelot *ocelot, int port, bool ingress,
if (ret)
return ret;
+ /* PSFP filter need to parse key by stream identification function. */
+ if (filter->type == OCELOT_PSFP_FILTER_OFFLOAD)
+ return 0;
+
return ocelot_flower_parse_key(ocelot, port, ingress, f, filter);
}
@@ -718,6 +734,15 @@ int ocelot_cls_flower_replace(struct ocelot *ocelot, int port,
if (filter->type == OCELOT_VCAP_FILTER_DUMMY)
return ocelot_vcap_dummy_filter_add(ocelot, filter);
+ if (filter->type == OCELOT_PSFP_FILTER_OFFLOAD) {
+ kfree(filter);
+ if (ocelot->ops->psfp_filter_add)
+ return ocelot->ops->psfp_filter_add(ocelot, f);
+
+ NL_SET_ERR_MSG_MOD(extack, "PSFP chain is not supported in HW");
+ return -EOPNOTSUPP;
+ }
+
return ocelot_vcap_filter_add(ocelot, filter, f->common.extack);
}
EXPORT_SYMBOL_GPL(ocelot_cls_flower_replace);
@@ -733,6 +758,13 @@ int ocelot_cls_flower_destroy(struct ocelot *ocelot, int port,
if (block_id < 0)
return 0;
+ if (block_id == PSFP_BLOCK_ID) {
+ if (ocelot->ops->psfp_filter_del)
+ return ocelot->ops->psfp_filter_del(ocelot, f);
+
+ return -EOPNOTSUPP;
+ }
+
block = &ocelot->block[block_id];
filter = ocelot_vcap_block_find_filter_by_id(block, f->cookie, true);
@@ -751,12 +783,25 @@ int ocelot_cls_flower_stats(struct ocelot *ocelot, int port,
{
struct ocelot_vcap_filter *filter;
struct ocelot_vcap_block *block;
+ struct flow_stats stats;
int block_id, ret;
block_id = ocelot_chain_to_block(f->common.chain_index, ingress);
if (block_id < 0)
return 0;
+ if (block_id == PSFP_BLOCK_ID) {
+ if (ocelot->ops->psfp_stats_get) {
+ ret = ocelot->ops->psfp_stats_get(ocelot, f, &stats);
+ if (ret)
+ return ret;
+
+ goto stats_update;
+ }
+
+ return -EOPNOTSUPP;
+ }
+
block = &ocelot->block[block_id];
filter = ocelot_vcap_block_find_filter_by_id(block, f->cookie, true);
@@ -767,7 +812,10 @@ int ocelot_cls_flower_stats(struct ocelot *ocelot, int port,
if (ret)
return ret;
- flow_stats_update(&f->stats, 0x0, filter->stats.pkts, 0, 0x0,
+ stats.pkts = filter->stats.pkts;
+
+stats_update:
+ flow_stats_update(&f->stats, 0x0, stats.pkts, 0, 0x0,
FLOW_ACTION_HW_STATS_IMMEDIATE);
return 0;
}
diff --git a/include/soc/mscc/ocelot.h b/include/soc/mscc/ocelot.h
index 1bbba424c189..eacae512e434 100644
--- a/include/soc/mscc/ocelot.h
+++ b/include/soc/mscc/ocelot.h
@@ -564,6 +564,10 @@ struct ocelot_ops {
u16 (*wm_enc)(u16 value);
u16 (*wm_dec)(u16 value);
void (*wm_stat)(u32 val, u32 *inuse, u32 *maxuse);
+ int (*psfp_filter_add)(struct ocelot *ocelot, struct flow_cls_offload *f);
+ int (*psfp_filter_del)(struct ocelot *ocelot, struct flow_cls_offload *f);
+ int (*psfp_stats_get)(struct ocelot *ocelot, struct flow_cls_offload *f,
+ struct flow_stats *stats);
};
struct ocelot_vcap_block {
diff --git a/include/soc/mscc/ocelot_vcap.h b/include/soc/mscc/ocelot_vcap.h
index 25fd525aaf92..24b495ce140c 100644
--- a/include/soc/mscc/ocelot_vcap.h
+++ b/include/soc/mscc/ocelot_vcap.h
@@ -646,6 +646,7 @@ enum ocelot_vcap_filter_type {
OCELOT_VCAP_FILTER_DUMMY,
OCELOT_VCAP_FILTER_PAG,
OCELOT_VCAP_FILTER_OFFLOAD,
+ OCELOT_PSFP_FILTER_OFFLOAD,
};
struct ocelot_vcap_id {
--
2.17.1
On Wed, Aug 18, 2021 at 02:19:18PM +0800, Xiaoliang Yang wrote:
> @@ -718,6 +734,15 @@ int ocelot_cls_flower_replace(struct ocelot *ocelot, int port,
> if (filter->type == OCELOT_VCAP_FILTER_DUMMY)
> return ocelot_vcap_dummy_filter_add(ocelot, filter);
>
> + if (filter->type == OCELOT_PSFP_FILTER_OFFLOAD) {
> + kfree(filter);
> + if (ocelot->ops->psfp_filter_add)
> + return ocelot->ops->psfp_filter_add(ocelot, f);
> +
> + NL_SET_ERR_MSG_MOD(extack, "PSFP chain is not supported in HW");
> + return -EOPNOTSUPP;
> + }
> +
> return ocelot_vcap_filter_add(ocelot, filter, f->common.extack);
> }
Hmm, I don't really like the idea of allocating an ocelot_vcap_filter
which we don't need for PSFP filters, just to kfree it later.
Is it that much more complicated to not allocate it at all in the first
place, add a bunch of "if" conditions that allocate a VCAP filter only
if we are offloading a VCAP chain?
And that means, don't create ocelot_vcap_filter::type == OCELOT_PSFP_FILTER_OFFLOAD,
because PSFP filters are not VCAP filters.
Hi Vladimir,
On Wed, Aug 18, 2021 at 23:01:23PM +0800, Vladimir Oltean wrote:
> > @@ -718,6 +734,15 @@ int ocelot_cls_flower_replace(struct ocelot *ocelot,
> int port,
> > if (filter->type == OCELOT_VCAP_FILTER_DUMMY)
> > return ocelot_vcap_dummy_filter_add(ocelot, filter);
> >
> > + if (filter->type == OCELOT_PSFP_FILTER_OFFLOAD) {
> > + kfree(filter);
> > + if (ocelot->ops->psfp_filter_add)
> > + return ocelot->ops->psfp_filter_add(ocelot, f);
> > +
> > + NL_SET_ERR_MSG_MOD(extack, "PSFP chain is not supported in
> HW");
> > + return -EOPNOTSUPP;
> > + }
> > +
> > return ocelot_vcap_filter_add(ocelot, filter, f->common.extack); }
>
> Hmm, I don't really like the idea of allocating an ocelot_vcap_filter which we
> don't need for PSFP filters, just to kfree it later.
>
> Is it that much more complicated to not allocate it at all in the first place, add
> a bunch of "if" conditions that allocate a VCAP filter only if we are offloading a
> VCAP chain?
>
> And that means, don't create ocelot_vcap_filter::type ==
> OCELOT_PSFP_FILTER_OFFLOAD, because PSFP filters are not VCAP filters.
The "vcap filter" variable need to be created and use ocelot_flower_parse() to get the type. If the rule is checked as a OCELOT_VCAP_FILTER_DUMMY, the chain 30000 dummy rule will be added in vcap_dummy_filter. And not offload to PSFP filter function. So I created the "vcap filter" and free it before offload to PSFP filter function.
Thanks,
xiaoliang