void lan966x_vcap_deinit(struct lan966x *lan966x);
 
 int lan966x_tc_flower(struct lan966x_port *port,
-                     struct flow_cls_offload *f);
+                     struct flow_cls_offload *f,
+                     bool ingress);
 
 int lan966x_goto_port_add(struct lan966x_port *port,
                          int from_cid, int to_cid,
 
        case TC_SETUP_CLSMATCHALL:
                return lan966x_tc_matchall(port, type_data, ingress);
        case TC_SETUP_CLSFLOWER:
-               return lan966x_tc_flower(port, type_data);
+               return lan966x_tc_flower(port, type_data, ingress);
        default:
                return -EOPNOTSUPP;
        }
 
 
 static int lan966x_tc_flower_action_check(struct vcap_control *vctrl,
                                          struct net_device *dev,
-                                         struct flow_cls_offload *fco)
+                                         struct flow_cls_offload *fco,
+                                         bool ingress)
 {
        struct flow_rule *rule = flow_cls_offload_flow_rule(fco);
        struct flow_action_entry *actent, *last_actent = NULL;
                                           "Invalid goto chain");
                        return -EINVAL;
                }
-       } else if (!vcap_is_last_chain(vctrl, fco->common.chain_index)) {
+       } else if (!vcap_is_last_chain(vctrl, fco->common.chain_index,
+                                      ingress)) {
                NL_SET_ERR_MSG_MOD(fco->common.extack,
                                   "Last action must be 'goto'");
                return -EINVAL;
 
 static int lan966x_tc_flower_add(struct lan966x_port *port,
                                 struct flow_cls_offload *f,
-                                struct vcap_admin *admin)
+                                struct vcap_admin *admin,
+                                bool ingress)
 {
        struct flow_action_entry *act;
        u16 l3_proto = ETH_P_ALL;
        int err, idx;
 
        err = lan966x_tc_flower_action_check(port->lan966x->vcap_ctrl,
-                                            port->dev, f);
+                                            port->dev, f, ingress);
        if (err)
                return err;
 
 }
 
 int lan966x_tc_flower(struct lan966x_port *port,
-                     struct flow_cls_offload *f)
+                     struct flow_cls_offload *f,
+                     bool ingress)
 {
        struct vcap_admin *admin;
 
 
        switch (f->command) {
        case FLOW_CLS_REPLACE:
-               return lan966x_tc_flower_add(port, f, admin);
+               return lan966x_tc_flower_add(port, f, admin, ingress);
        case FLOW_CLS_DESTROY:
                return lan966x_tc_flower_del(port, f, admin);
        default:
 
        int first_cid; /* first chain id in this vcap */
        int last_cid; /* last chain id in this vcap */
        int count; /* number of available addresses */
+       bool ingress; /* is vcap in the ingress path */
 } lan966x_vcap_inst_cfg[] = {
        {
                .vtype = VCAP_TYPE_IS2, /* IS2-0 */
                .first_cid = LAN966X_VCAP_CID_IS2_L0,
                .last_cid = LAN966X_VCAP_CID_IS2_MAX,
                .count = 256,
+               .ingress = true,
        },
 };
 
 
        admin->vtype = cfg->vtype;
        admin->vinst = 0;
+       admin->ingress = cfg->ingress;
        admin->w32be = true;
        admin->tgt_inst = cfg->tgt_inst;
 
 
 
 static int sparx5_tc_flower_action_check(struct vcap_control *vctrl,
                                         struct net_device *ndev,
-                                        struct flow_cls_offload *fco)
+                                        struct flow_cls_offload *fco,
+                                        bool ingress)
 {
        struct flow_rule *rule = flow_cls_offload_flow_rule(fco);
        struct flow_action_entry *actent, *last_actent = NULL;
                                           "Invalid goto chain");
                        return -EINVAL;
                }
-       } else if (!vcap_is_last_chain(vctrl, fco->common.chain_index)) {
+       } else if (!vcap_is_last_chain(vctrl, fco->common.chain_index,
+                                      ingress)) {
                NL_SET_ERR_MSG_MOD(fco->common.extack,
                                   "Last action must be 'goto'");
                return -EINVAL;
 
 static int sparx5_tc_flower_replace(struct net_device *ndev,
                                    struct flow_cls_offload *fco,
-                                   struct vcap_admin *admin)
+                                   struct vcap_admin *admin,
+                                   bool ingress)
 {
        struct sparx5_port *port = netdev_priv(ndev);
        struct sparx5_multiple_rules multi = {};
 
        vctrl = port->sparx5->vcap_ctrl;
 
-       err = sparx5_tc_flower_action_check(vctrl, ndev, fco);
+       err = sparx5_tc_flower_action_check(vctrl, ndev, fco, ingress);
        if (err)
                return err;
 
 
        switch (fco->command) {
        case FLOW_CLS_REPLACE:
-               return sparx5_tc_flower_replace(ndev, fco, admin);
+               return sparx5_tc_flower_replace(ndev, fco, admin, ingress);
        case FLOW_CLS_DESTROY:
                return sparx5_tc_flower_destroy(ndev, fco, admin);
        case FLOW_CLS_STATS:
 
        int map_id; /* id in the super vcap block mapping (if applicable) */
        int blockno; /* starting block in super vcap (if applicable) */
        int blocks; /* number of blocks in super vcap (if applicable) */
+       bool ingress; /* is vcap in the ingress path */
 } sparx5_vcap_inst_cfg[] = {
        {
                .vtype = VCAP_TYPE_IS0, /* CLM-0 */
                .last_cid = SPARX5_VCAP_CID_IS0_L2 - 1,
                .blockno = 8, /* Maps block 8-9 */
                .blocks = 2,
+               .ingress = true,
        },
        {
                .vtype = VCAP_TYPE_IS0, /* CLM-1 */
                .last_cid = SPARX5_VCAP_CID_IS0_L4 - 1,
                .blockno = 6, /* Maps block 6-7 */
                .blocks = 2,
+               .ingress = true,
        },
        {
                .vtype = VCAP_TYPE_IS0, /* CLM-2 */
                .last_cid = SPARX5_VCAP_CID_IS0_MAX,
                .blockno = 4, /* Maps block 4-5 */
                .blocks = 2,
+               .ingress = true,
        },
        {
                .vtype = VCAP_TYPE_IS2, /* IS2-0 */
                .last_cid = SPARX5_VCAP_CID_IS2_L2 - 1,
                .blockno = 0, /* Maps block 0-1 */
                .blocks = 2,
+               .ingress = true,
        },
        {
                .vtype = VCAP_TYPE_IS2, /* IS2-1 */
                .last_cid = SPARX5_VCAP_CID_IS2_MAX,
                .blockno = 2, /* Maps block 2-3 */
                .blocks = 2,
+               .ingress = true,
        },
        {
                .vtype = VCAP_TYPE_ES2,
                .first_cid = SPARX5_VCAP_CID_ES2_L0,
                .last_cid = SPARX5_VCAP_CID_ES2_MAX,
                .count = 12288, /* Addresses according to datasheet */
+               .ingress = false,
        },
 };
 
        mutex_init(&admin->lock);
        admin->vtype = cfg->vtype;
        admin->vinst = cfg->vinst;
+       admin->ingress = cfg->ingress;
        admin->lookups = cfg->lookups;
        admin->lookups_per_instance = cfg->lookups_per_instance;
        admin->first_cid = cfg->first_cid;
 
 }
 EXPORT_SYMBOL_GPL(vcap_find_admin);
 
-/* Is this the last admin instance ordered by chain id */
+/* Is this the last admin instance ordered by chain id and direction */
 static bool vcap_admin_is_last(struct vcap_control *vctrl,
-                              struct vcap_admin *admin)
+                              struct vcap_admin *admin,
+                              bool ingress)
 {
        struct vcap_admin *iter, *last = NULL;
        int max_cid = 0;
 
        list_for_each_entry(iter, &vctrl->list, list) {
-               if (iter->first_cid > max_cid) {
+               if (iter->first_cid > max_cid &&
+                   iter->ingress == ingress) {
                        last = iter;
                        max_cid = iter->first_cid;
                }
 EXPORT_SYMBOL_GPL(vcap_enable_lookups);
 
 /* Is this chain id the last lookup of all VCAPs */
-bool vcap_is_last_chain(struct vcap_control *vctrl, int cid)
+bool vcap_is_last_chain(struct vcap_control *vctrl, int cid, bool ingress)
 {
        struct vcap_admin *admin;
        int lookup;
        if (!admin)
                return false;
 
-       if (!vcap_admin_is_last(vctrl, admin))
+       if (!vcap_admin_is_last(vctrl, admin, ingress))
                return false;
 
        /* This must be the last lookup in this VCAP type */
 
        int first_valid_addr; /* bottom of address range to be used */
        int last_used_addr;  /* address of lowest added rule */
        bool w32be; /* vcap uses "32bit-word big-endian" encoding */
+       bool ingress; /* chain traffic direction */
        struct vcap_cache_data cache; /* encoded rule data */
 };
 
 
 /* Is the next chain id in the following lookup, possible in another VCAP */
 bool vcap_is_next_lookup(struct vcap_control *vctrl, int cur_cid, int next_cid);
 /* Is this chain id the last lookup of all VCAPs */
-bool vcap_is_last_chain(struct vcap_control *vctrl, int cid);
+bool vcap_is_last_chain(struct vcap_control *vctrl, int cid, bool ingress);
 /* Provide all rules via a callback interface */
 int vcap_rule_iter(struct vcap_control *vctrl,
                   int (*callback)(void *, struct vcap_rule *), void *arg);
 
        out->prf(out->dst, "version: %d\n", vcap->version);
        out->prf(out->dst, "vtype: %d\n", admin->vtype);
        out->prf(out->dst, "vinst: %d\n", admin->vinst);
+       out->prf(out->dst, "ingress: %d\n", admin->ingress);
        out->prf(out->dst, "first_cid: %d\n", admin->first_cid);
        out->prf(out->dst, "last_cid: %d\n", admin->last_cid);
        out->prf(out->dst, "lookups: %d\n", admin->lookups);
 
        "version: 1\n",
        "vtype: 2\n",
        "vinst: 0\n",
+       "ingress: 1\n",
        "first_cid: 10000\n",
        "last_cid: 19999\n",
        "lookups: 4\n",
                .last_valid_addr = 3071,
                .first_valid_addr = 0,
                .last_used_addr = 794,
+               .ingress = true,
        };
        struct vcap_output_print out = {
                .prf = (void *)test_prf,
        "version: 1\n",
        "vtype: 2\n",
        "vinst: 0\n",
+       "ingress: 1\n",
        "first_cid: 8000000\n",
        "last_cid: 8199999\n",
        "lookups: 4\n",
                .last_valid_addr = 3071,
                .first_valid_addr = 0,
                .last_used_addr = 794,
+               .ingress = true,
                .cache = {
                        .keystream = keydata,
                        .maskstream = mskdata,