net: prestera: acl: add multi-chain support offload

Add support of rule offloading added to the non-zero index chain,
which was previously forbidden. Also, goto action is offloaded
allowing to jump for processing of desired chain.

Note that only implicit chain 0 is bound to the device port(s) for
processing. The rest of chains have to be jumped by actions.

Signed-off-by: Volodymyr Mytnyk <vmytnyk@marvell.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/drivers/net/ethernet/marvell/prestera/prestera_acl.c b/drivers/net/ethernet/marvell/prestera/prestera_acl.c
index f0d9f59..06303e3 100644 (file)
--- a/drivers/net/ethernet/marvell/prestera/prestera_acl.c
+++ b/drivers/net/ethernet/marvell/prestera/prestera_acl.c
@@ -22,6 +22,7 @@ struct prestera_acl {
 
 struct prestera_acl_ruleset_ht_key {
        struct prestera_flow_block *block;
+       u32 chain_index;
 };
 
 struct prestera_acl_rule_entry {
@@ -34,6 +35,10 @@ struct prestera_acl_rule_entry {
                        u8 valid:1;
                } accept, drop, trap;
                struct {
+                       struct prestera_acl_action_jump i;
+                       u8 valid:1;
+               } jump;
+               struct {
                        u32 id;
                        struct prestera_counter_block *block;
                } counter;
@@ -49,6 +54,7 @@ struct prestera_acl_ruleset {
        refcount_t refcount;
        void *keymask;
        u32 vtcam_id;
+       u32 index;
        u16 pcl_id;
        bool offload;
 };
@@ -83,20 +89,45 @@ static const struct rhashtable_params __prestera_acl_rule_entry_ht_params = {
        .automatic_shrinking = true,
 };
 
+int prestera_acl_chain_to_client(u32 chain_index, u32 *client)
+{
+       u32 client_map[] = {
+               PRESTERA_HW_COUNTER_CLIENT_LOOKUP_0,
+               PRESTERA_HW_COUNTER_CLIENT_LOOKUP_1,
+               PRESTERA_HW_COUNTER_CLIENT_LOOKUP_2
+       };
+
+       if (chain_index > ARRAY_SIZE(client_map))
+               return -EINVAL;
+
+       *client = client_map[chain_index];
+       return 0;
+}
+
+static bool prestera_acl_chain_is_supported(u32 chain_index)
+{
+       return (chain_index & ~PRESTERA_ACL_CHAIN_MASK) == 0;
+}
+
 static struct prestera_acl_ruleset *
 prestera_acl_ruleset_create(struct prestera_acl *acl,
-                           struct prestera_flow_block *block)
+                           struct prestera_flow_block *block,
+                           u32 chain_index)
 {
        struct prestera_acl_ruleset *ruleset;
        u32 uid = 0;
        int err;
 
+       if (!prestera_acl_chain_is_supported(chain_index))
+               return ERR_PTR(-EINVAL);
+
        ruleset = kzalloc(sizeof(*ruleset), GFP_KERNEL);
        if (!ruleset)
                return ERR_PTR(-ENOMEM);
 
        ruleset->acl = acl;
        ruleset->ht_key.block = block;
+       ruleset->ht_key.chain_index = chain_index;
        refcount_set(&ruleset->refcount, 1);
 
        err = rhashtable_init(&ruleset->rule_ht, &prestera_acl_rule_ht_params);
@@ -108,7 +139,9 @@ prestera_acl_ruleset_create(struct prestera_acl *acl,
                goto err_ruleset_create;
 
        /* make pcl-id based on uid */
-       ruleset->pcl_id = (u8)uid;
+       ruleset->pcl_id = PRESTERA_ACL_PCL_ID_MAKE((u8)uid, chain_index);
+       ruleset->index = uid;
+
        err = rhashtable_insert_fast(&acl->ruleset_ht, &ruleset->ht_node,
                                     prestera_acl_ruleset_ht_params);
        if (err)
@@ -133,35 +166,64 @@ void prestera_acl_ruleset_keymask_set(struct prestera_acl_ruleset *ruleset,
 
 int prestera_acl_ruleset_offload(struct prestera_acl_ruleset *ruleset)
 {
+       struct prestera_acl_iface iface;
        u32 vtcam_id;
        int err;
 
        if (ruleset->offload)
                return -EEXIST;
 
-       err = prestera_acl_vtcam_id_get(ruleset->acl, 0,
+       err = prestera_acl_vtcam_id_get(ruleset->acl,
+                                       ruleset->ht_key.chain_index,
                                        ruleset->keymask, &vtcam_id);
        if (err)
-               return err;
+               goto err_vtcam_create;
+
+       if (ruleset->ht_key.chain_index) {
+               /* for chain > 0, bind iface index to pcl-id to be able
+                * to jump from any other ruleset to this one using the index.
+                */
+               iface.index = ruleset->index;
+               iface.type = PRESTERA_ACL_IFACE_TYPE_INDEX;
+               err = prestera_hw_vtcam_iface_bind(ruleset->acl->sw, &iface,
+                                                  vtcam_id, ruleset->pcl_id);
+               if (err)
+                       goto err_ruleset_bind;
+       }
 
        ruleset->vtcam_id = vtcam_id;
        ruleset->offload = true;
        return 0;
+
+err_ruleset_bind:
+       prestera_acl_vtcam_id_put(ruleset->acl, ruleset->vtcam_id);
+err_vtcam_create:
+       return err;
 }
 
 static void prestera_acl_ruleset_destroy(struct prestera_acl_ruleset *ruleset)
 {
        struct prestera_acl *acl = ruleset->acl;
        u8 uid = ruleset->pcl_id & PRESTERA_ACL_KEYMASK_PCL_ID_USER;
+       int err;
 
        rhashtable_remove_fast(&acl->ruleset_ht, &ruleset->ht_node,
                               prestera_acl_ruleset_ht_params);
 
-       if (ruleset->offload)
+       if (ruleset->offload) {
+               if (ruleset->ht_key.chain_index) {
+                       struct prestera_acl_iface iface = {
+                               .type = PRESTERA_ACL_IFACE_TYPE_INDEX,
+                               .index = ruleset->index
+                       };
+                       err = prestera_hw_vtcam_iface_unbind(acl->sw, &iface,
+                                                            ruleset->vtcam_id);
+                       WARN_ON(err);
+               }
                WARN_ON(prestera_acl_vtcam_id_put(acl, ruleset->vtcam_id));
+       }
 
        idr_remove(&acl->uid, uid);
-
        rhashtable_destroy(&ruleset->rule_ht);
        kfree(ruleset->keymask);
        kfree(ruleset);
@@ -169,23 +231,26 @@ static void prestera_acl_ruleset_destroy(struct prestera_acl_ruleset *ruleset)
 
 static struct prestera_acl_ruleset *
 __prestera_acl_ruleset_lookup(struct prestera_acl *acl,
-                             struct prestera_flow_block *block)
+                             struct prestera_flow_block *block,
+                             u32 chain_index)
 {
        struct prestera_acl_ruleset_ht_key ht_key;
 
        memset(&ht_key, 0, sizeof(ht_key));
        ht_key.block = block;
+       ht_key.chain_index = chain_index;
        return rhashtable_lookup_fast(&acl->ruleset_ht, &ht_key,
                                      prestera_acl_ruleset_ht_params);
 }
 
 struct prestera_acl_ruleset *
 prestera_acl_ruleset_lookup(struct prestera_acl *acl,
-                           struct prestera_flow_block *block)
+                           struct prestera_flow_block *block,
+                           u32 chain_index)
 {
        struct prestera_acl_ruleset *ruleset;
 
-       ruleset = __prestera_acl_ruleset_lookup(acl, block);
+       ruleset = __prestera_acl_ruleset_lookup(acl, block, chain_index);
        if (!ruleset)
                return ERR_PTR(-ENOENT);
 
@@ -195,17 +260,18 @@ prestera_acl_ruleset_lookup(struct prestera_acl *acl,
 
 struct prestera_acl_ruleset *
 prestera_acl_ruleset_get(struct prestera_acl *acl,
-                        struct prestera_flow_block *block)
+                        struct prestera_flow_block *block,
+                        u32 chain_index)
 {
        struct prestera_acl_ruleset *ruleset;
 
-       ruleset = __prestera_acl_ruleset_lookup(acl, block);
+       ruleset = __prestera_acl_ruleset_lookup(acl, block, chain_index);
        if (ruleset) {
                refcount_inc(&ruleset->refcount);
                return ruleset;
        }
 
-       return prestera_acl_ruleset_create(acl, block);
+       return prestera_acl_ruleset_create(acl, block, chain_index);
 }
 
 void prestera_acl_ruleset_put(struct prestera_acl_ruleset *ruleset)
@@ -293,6 +359,11 @@ prestera_acl_rule_lookup(struct prestera_acl_ruleset *ruleset,
                                      prestera_acl_rule_ht_params);
 }
 
+u32 prestera_acl_ruleset_index_get(const struct prestera_acl_ruleset *ruleset)
+{
+       return ruleset->index;
+}
+
 bool prestera_acl_ruleset_is_offload(struct prestera_acl_ruleset *ruleset)
 {
        return ruleset->offload;
@@ -300,7 +371,7 @@ bool prestera_acl_ruleset_is_offload(struct prestera_acl_ruleset *ruleset)
 
 struct prestera_acl_rule *
 prestera_acl_rule_create(struct prestera_acl_ruleset *ruleset,
-                        unsigned long cookie)
+                        unsigned long cookie, u32 chain_index)
 {
        struct prestera_acl_rule *rule;
 
@@ -310,6 +381,7 @@ prestera_acl_rule_create(struct prestera_acl_ruleset *ruleset,
 
        rule->ruleset = ruleset;
        rule->cookie = cookie;
+       rule->chain_index = chain_index;
 
        refcount_inc(&ruleset->refcount);
 
@@ -324,6 +396,10 @@ void prestera_acl_rule_priority_set(struct prestera_acl_rule *rule,
 
 void prestera_acl_rule_destroy(struct prestera_acl_rule *rule)
 {
+       if (rule->jump_ruleset)
+               /* release ruleset kept by jump action */
+               prestera_acl_ruleset_put(rule->jump_ruleset);
+
        prestera_acl_ruleset_put(rule->ruleset);
        kfree(rule);
 }
@@ -347,7 +423,10 @@ int prestera_acl_rule_add(struct prestera_switch *sw,
 
        /* setup counter */
        rule->re_arg.count.valid = true;
-       rule->re_arg.count.client = PRESTERA_HW_COUNTER_CLIENT_LOOKUP_0;
+       err = prestera_acl_chain_to_client(ruleset->ht_key.chain_index,
+                                          &rule->re_arg.count.client);
+       if (err)
+               goto err_rule_add;
 
        rule->re = prestera_acl_rule_entry_find(sw->acl, &rule->re_key);
        err = WARN_ON(rule->re) ? -EEXIST : 0;
@@ -360,8 +439,10 @@ int prestera_acl_rule_add(struct prestera_switch *sw,
        if (err)
                goto err_rule_add;
 
-       /* bind the block (all ports) to chain index 0 */
-       if (!ruleset->rule_count) {
+       /* bind the block (all ports) to chain index 0, rest of
+        * the chains are bound to goto action
+        */
+       if (!ruleset->ht_key.chain_index && !ruleset->rule_count) {
                err = prestera_acl_ruleset_block_bind(ruleset, block);
                if (err)
                        goto err_acl_block_bind;
@@ -395,7 +476,7 @@ void prestera_acl_rule_del(struct prestera_switch *sw,
        prestera_acl_rule_entry_destroy(sw->acl, rule->re);
 
        /* unbind block (all ports) */
-       if (!ruleset->rule_count)
+       if (!ruleset->ht_key.chain_index && !ruleset->rule_count)
                prestera_acl_ruleset_block_unbind(ruleset, block);
 }
 
@@ -459,6 +540,12 @@ static int __prestera_acl_rule_entry2hw_add(struct prestera_switch *sw,
                act_hw[act_num].id = PRESTERA_ACL_RULE_ACTION_TRAP;
                act_num++;
        }
+       /* jump */
+       if (e->jump.valid) {
+               act_hw[act_num].id = PRESTERA_ACL_RULE_ACTION_JUMP;
+               act_hw[act_num].jump = e->jump.i;
+               act_num++;
+       }
        /* counter */
        if (e->counter.block) {
                act_hw[act_num].id = PRESTERA_ACL_RULE_ACTION_COUNT;
@@ -505,6 +592,9 @@ __prestera_acl_rule_entry_act_construct(struct prestera_switch *sw,
        e->drop.valid = arg->drop.valid;
        /* trap */
        e->trap.valid = arg->trap.valid;
+       /* jump */
+       e->jump.valid = arg->jump.valid;
+       e->jump.i = arg->jump.i;
        /* counter */
        if (arg->count.valid) {
                int err;

diff --git a/drivers/net/ethernet/marvell/prestera/prestera_acl.h b/drivers/net/ethernet/marvell/prestera/prestera_acl.h
index 40f6c1d..6d2ad27 100644 (file)
--- a/drivers/net/ethernet/marvell/prestera/prestera_acl.h
+++ b/drivers/net/ethernet/marvell/prestera/prestera_acl.h
@@ -10,6 +10,14 @@
 #define PRESTERA_ACL_KEYMASK_PCL_ID            0x3FF
 #define PRESTERA_ACL_KEYMASK_PCL_ID_USER                       \
        (PRESTERA_ACL_KEYMASK_PCL_ID & 0x00FF)
+#define PRESTERA_ACL_KEYMASK_PCL_ID_CHAIN                      \
+       (PRESTERA_ACL_KEYMASK_PCL_ID & 0xFF00)
+#define PRESTERA_ACL_CHAIN_MASK                                        \
+       (PRESTERA_ACL_KEYMASK_PCL_ID >> 8)
+
+#define PRESTERA_ACL_PCL_ID_MAKE(uid, chain_id)                        \
+       (((uid) & PRESTERA_ACL_KEYMASK_PCL_ID_USER) |           \
+       (((chain_id) << 8) & PRESTERA_ACL_KEYMASK_PCL_ID_CHAIN))
 
 #define rule_match_set_n(match_p, type, val_p, size)           \
        memcpy(&(match_p)[PRESTERA_ACL_RULE_MATCH_TYPE_##type], \
@@ -46,6 +54,7 @@ enum prestera_acl_rule_action {
        PRESTERA_ACL_RULE_ACTION_ACCEPT = 0,
        PRESTERA_ACL_RULE_ACTION_DROP = 1,
        PRESTERA_ACL_RULE_ACTION_TRAP = 2,
+       PRESTERA_ACL_RULE_ACTION_JUMP = 5,
        PRESTERA_ACL_RULE_ACTION_COUNT = 7,
 
        PRESTERA_ACL_RULE_ACTION_MAX
@@ -61,6 +70,10 @@ struct prestera_acl_match {
        __be32 mask[__PRESTERA_ACL_RULE_MATCH_TYPE_MAX];
 };
 
+struct prestera_acl_action_jump {
+       u32 index;
+};
+
 struct prestera_acl_action_count {
        u32 id;
 };
@@ -74,6 +87,7 @@ struct prestera_acl_hw_action_info {
        enum prestera_acl_rule_action id;
        union {
                struct prestera_acl_action_count count;
+               struct prestera_acl_action_jump jump;
        };
 };
 
@@ -88,6 +102,10 @@ struct prestera_acl_rule_entry_arg {
                        u8 valid:1;
                } accept, drop, trap;
                struct {
+                       struct prestera_acl_action_jump i;
+                       u8 valid:1;
+               } jump;
+               struct {
                        u8 valid:1;
                        u32 client;
                } count;
@@ -98,7 +116,9 @@ struct prestera_acl_rule {
        struct rhash_head ht_node; /* Member of acl HT */
        struct list_head list;
        struct prestera_acl_ruleset *ruleset;
+       struct prestera_acl_ruleset *jump_ruleset;
        unsigned long cookie;
+       u32 chain_index;
        u32 priority;
        struct prestera_acl_rule_entry_key re_key;
        struct prestera_acl_rule_entry_arg re_arg;
@@ -122,7 +142,7 @@ void prestera_acl_fini(struct prestera_switch *sw);
 
 struct prestera_acl_rule *
 prestera_acl_rule_create(struct prestera_acl_ruleset *ruleset,
-                        unsigned long cookie);
+                        unsigned long cookie, u32 chain_index);
 void prestera_acl_rule_priority_set(struct prestera_acl_rule *rule,
                                    u32 priority);
 void prestera_acl_rule_destroy(struct prestera_acl_rule *rule);
@@ -147,10 +167,12 @@ prestera_acl_rule_entry_create(struct prestera_acl *acl,
                               struct prestera_acl_rule_entry_arg *arg);
 struct prestera_acl_ruleset *
 prestera_acl_ruleset_get(struct prestera_acl *acl,
-                        struct prestera_flow_block *block);
+                        struct prestera_flow_block *block,
+                        u32 chain_index);
 struct prestera_acl_ruleset *
 prestera_acl_ruleset_lookup(struct prestera_acl *acl,
-                           struct prestera_flow_block *block);
+                           struct prestera_flow_block *block,
+                           u32 chain_index);
 void prestera_acl_ruleset_keymask_set(struct prestera_acl_ruleset *ruleset,
                                      void *keymask);
 bool prestera_acl_ruleset_is_offload(struct prestera_acl_ruleset *ruleset);
@@ -160,6 +182,7 @@ int prestera_acl_ruleset_bind(struct prestera_acl_ruleset *ruleset,
                              struct prestera_port *port);
 int prestera_acl_ruleset_unbind(struct prestera_acl_ruleset *ruleset,
                                struct prestera_port *port);
+u32 prestera_acl_ruleset_index_get(const struct prestera_acl_ruleset *ruleset);
 void
 prestera_acl_rule_keymask_pcl_id_set(struct prestera_acl_rule *rule,
                                     u16 pcl_id);
@@ -167,5 +190,6 @@ prestera_acl_rule_keymask_pcl_id_set(struct prestera_acl_rule *rule,
 int prestera_acl_vtcam_id_get(struct prestera_acl *acl, u8 lookup,
                              void *keymask, u32 *vtcam_id);
 int prestera_acl_vtcam_id_put(struct prestera_acl *acl, u32 vtcam_id);
+int prestera_acl_chain_to_client(u32 chain_index, u32 *client);
 
 #endif /* _PRESTERA_ACL_H_ */

diff --git a/drivers/net/ethernet/marvell/prestera/prestera_flow.c b/drivers/net/ethernet/marvell/prestera/prestera_flow.c
index d849f04..05c3ad9 100644 (file)
--- a/drivers/net/ethernet/marvell/prestera/prestera_flow.c
+++ b/drivers/net/ethernet/marvell/prestera/prestera_flow.c
@@ -29,9 +29,6 @@ static int prestera_flow_block_mall_cb(struct prestera_flow_block *block,
 static int prestera_flow_block_flower_cb(struct prestera_flow_block *block,
                                         struct flow_cls_offload *f)
 {
-       if (f->common.chain_index != 0)
-               return -EOPNOTSUPP;
-
        switch (f->command) {
        case FLOW_CLS_REPLACE:
                return prestera_flower_replace(block, f);
@@ -71,6 +68,7 @@ static void prestera_flow_block_destroy(void *cb_priv)
 
        prestera_flower_template_cleanup(block);
 
+       WARN_ON(!list_empty(&block->template_list));
        WARN_ON(!list_empty(&block->binding_list));
 
        kfree(block);
@@ -86,6 +84,7 @@ prestera_flow_block_create(struct prestera_switch *sw, struct net *net)
                return NULL;
 
        INIT_LIST_HEAD(&block->binding_list);
+       INIT_LIST_HEAD(&block->template_list);
        block->net = net;
        block->sw = sw;
 

diff --git a/drivers/net/ethernet/marvell/prestera/prestera_flow.h b/drivers/net/ethernet/marvell/prestera/prestera_flow.h
index 1ea5b74..6550278 100644 (file)
--- a/drivers/net/ethernet/marvell/prestera/prestera_flow.h
+++ b/drivers/net/ethernet/marvell/prestera/prestera_flow.h
@@ -8,7 +8,6 @@
 
 struct prestera_port;
 struct prestera_switch;
-struct prestera_flower_template;
 
 struct prestera_flow_block_binding {
        struct list_head list;
@@ -22,7 +21,7 @@ struct prestera_flow_block {
        struct net *net;
        struct prestera_acl_ruleset *ruleset_zero;
        struct flow_block_cb *block_cb;
-       struct prestera_flower_template *tmplt;
+       struct list_head template_list;
        unsigned int rule_count;
 };
 

diff --git a/drivers/net/ethernet/marvell/prestera/prestera_flower.c b/drivers/net/ethernet/marvell/prestera/prestera_flower.c
index 19c1417..580fb98 100644 (file)
--- a/drivers/net/ethernet/marvell/prestera/prestera_flower.c
+++ b/drivers/net/ethernet/marvell/prestera/prestera_flower.c
@@ -8,26 +8,60 @@
 
 struct prestera_flower_template {
        struct prestera_acl_ruleset *ruleset;
+       struct list_head list;
+       u32 chain_index;
 };
 
 void prestera_flower_template_cleanup(struct prestera_flow_block *block)
 {
-       if (block->tmplt) {
-               /* put the reference to the ruleset kept in create */
-               prestera_acl_ruleset_put(block->tmplt->ruleset);
-               kfree(block->tmplt);
-               block->tmplt = NULL;
-               return;
+       struct prestera_flower_template *template;
+       struct list_head *pos, *n;
+
+       /* put the reference to all rulesets kept in tmpl create */
+       list_for_each_safe(pos, n, &block->template_list) {
+               template = list_entry(pos, typeof(*template), list);
+               prestera_acl_ruleset_put(template->ruleset);
+               list_del(&template->list);
+               kfree(template);
        }
 }
 
+static int
+prestera_flower_parse_goto_action(struct prestera_flow_block *block,
+                                 struct prestera_acl_rule *rule,
+                                 u32 chain_index,
+                                 const struct flow_action_entry *act)
+{
+       struct prestera_acl_ruleset *ruleset;
+
+       if (act->chain_index <= chain_index)
+               /* we can jump only forward */
+               return -EINVAL;
+
+       if (rule->re_arg.jump.valid)
+               return -EEXIST;
+
+       ruleset = prestera_acl_ruleset_get(block->sw->acl, block,
+                                          act->chain_index);
+       if (IS_ERR(ruleset))
+               return PTR_ERR(ruleset);
+
+       rule->re_arg.jump.valid = 1;
+       rule->re_arg.jump.i.index = prestera_acl_ruleset_index_get(ruleset);
+
+       rule->jump_ruleset = ruleset;
+
+       return 0;
+}
+
 static int prestera_flower_parse_actions(struct prestera_flow_block *block,
                                         struct prestera_acl_rule *rule,
                                         struct flow_action *flow_action,
+                                        u32 chain_index,
                                         struct netlink_ext_ack *extack)
 {
        const struct flow_action_entry *act;
-       int i;
+       int err, i;
 
        /* whole struct (rule->re_arg) must be initialized with 0 */
        if (!flow_action_has_entries(flow_action))
@@ -53,6 +87,13 @@ static int prestera_flower_parse_actions(struct prestera_flow_block *block,
 
                        rule->re_arg.trap.valid = 1;
                        break;
+               case FLOW_ACTION_GOTO:
+                       err = prestera_flower_parse_goto_action(block, rule,
+                                                               chain_index,
+                                                               act);
+                       if (err)
+                               return err;
+                       break;
                default:
                        NL_SET_ERR_MSG_MOD(extack, "Unsupported action");
                        pr_err("Unsupported action\n");
@@ -259,6 +300,7 @@ static int prestera_flower_parse(struct prestera_flow_block *block,
        }
 
        return prestera_flower_parse_actions(block, rule, &f->rule->action,
+                                            f->common.chain_index,
                                             f->common.extack);
 }
 
@@ -270,12 +312,13 @@ int prestera_flower_replace(struct prestera_flow_block *block,
        struct prestera_acl_rule *rule;
        int err;
 
-       ruleset = prestera_acl_ruleset_get(acl, block);
+       ruleset = prestera_acl_ruleset_get(acl, block, f->common.chain_index);
        if (IS_ERR(ruleset))
                return PTR_ERR(ruleset);
 
        /* increments the ruleset reference */
-       rule = prestera_acl_rule_create(ruleset, f->cookie);
+       rule = prestera_acl_rule_create(ruleset, f->cookie,
+                                       f->common.chain_index);
        if (IS_ERR(rule)) {
                err = PTR_ERR(rule);
                goto err_rule_create;
@@ -312,7 +355,8 @@ void prestera_flower_destroy(struct prestera_flow_block *block,
        struct prestera_acl_ruleset *ruleset;
        struct prestera_acl_rule *rule;
 
-       ruleset = prestera_acl_ruleset_lookup(block->sw->acl, block);
+       ruleset = prestera_acl_ruleset_lookup(block->sw->acl, block,
+                                             f->common.chain_index);
        if (IS_ERR(ruleset))
                return;
 
@@ -345,7 +389,8 @@ int prestera_flower_tmplt_create(struct prestera_flow_block *block,
        }
 
        prestera_acl_rule_keymask_pcl_id_set(&rule, 0);
-       ruleset = prestera_acl_ruleset_get(block->sw->acl, block);
+       ruleset = prestera_acl_ruleset_get(block->sw->acl, block,
+                                          f->common.chain_index);
        if (IS_ERR_OR_NULL(ruleset)) {
                err = -EINVAL;
                goto err_ruleset_get;
@@ -364,7 +409,8 @@ int prestera_flower_tmplt_create(struct prestera_flow_block *block,
 
        /* keep the reference to the ruleset */
        template->ruleset = ruleset;
-       block->tmplt = template;
+       template->chain_index = f->common.chain_index;
+       list_add_rcu(&template->list, &block->template_list);
        return 0;
 
 err_ruleset_get:
@@ -390,7 +436,8 @@ int prestera_flower_stats(struct prestera_flow_block *block,
        u64 bytes;
        int err;
 
-       ruleset = prestera_acl_ruleset_lookup(block->sw->acl, block);
+       ruleset = prestera_acl_ruleset_lookup(block->sw->acl, block,
+                                             f->common.chain_index);
        if (IS_ERR(ruleset))
                return PTR_ERR(ruleset);
 

diff --git a/drivers/net/ethernet/marvell/prestera/prestera_flower.h b/drivers/net/ethernet/marvell/prestera/prestera_flower.h
index dc3aa42..495f151 100644 (file)
--- a/drivers/net/ethernet/marvell/prestera/prestera_flower.h
+++ b/drivers/net/ethernet/marvell/prestera/prestera_flower.h
@@ -6,7 +6,6 @@
 
 #include <net/pkt_cls.h>
 
-struct prestera_switch;
 struct prestera_flow_block;
 
 int prestera_flower_replace(struct prestera_flow_block *block,

diff --git a/drivers/net/ethernet/marvell/prestera/prestera_hw.c b/drivers/net/ethernet/marvell/prestera/prestera_hw.c
index e6bfadc..d4c0f05 100644 (file)
--- a/drivers/net/ethernet/marvell/prestera/prestera_hw.c
+++ b/drivers/net/ethernet/marvell/prestera/prestera_hw.c
@@ -424,6 +424,9 @@ struct prestera_msg_acl_action {
        __le32 __reserved;
        union {
                struct {
+                       __le32 index;
+               } jump;
+               struct {
                        __le32 id;
                } count;
                __le32 reserved[6];
@@ -1164,6 +1167,9 @@ prestera_acl_rule_add_put_action(struct prestera_msg_acl_action *action,
        case PRESTERA_ACL_RULE_ACTION_TRAP:
                /* just rule action id, no specific data */
                break;
+       case PRESTERA_ACL_RULE_ACTION_JUMP:
+               action->jump.index = __cpu_to_le32(info->jump.index);
+               break;
        case PRESTERA_ACL_RULE_ACTION_COUNT:
                action->count.id = __cpu_to_le32(info->count.id);
                break;