// SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB
/* Copyright (c) 2020 Mellanox Technologies. */

#include <linux/netdevice.h>
#include <linux/if_macvlan.h>
#include <linux/list.h>
#include <linux/rculist.h>
#include <linux/rtnetlink.h>
#include <linux/workqueue.h>
#include <linux/spinlock.h>
#include "tc.h"
#include "neigh.h"
#include "en_rep.h"
#include "eswitch.h"
#include "lib/fs_chains.h"
#include "en/tc_ct.h"
#include "en/mapping.h"
#include "en/tc_tun.h"
#include "lib/port_tun.h"
#include "en/tc/sample.h"
#include "en_accel/ipsec_rxtx.h"
#include "en/tc/int_port.h"
#include "en/tc/act/act.h"

struct mlx5e_rep_indr_block_priv {
        struct net_device *netdev;
        struct mlx5e_rep_priv *rpriv;
        enum flow_block_binder_type binder_type;

        struct list_head list;
};

int mlx5e_rep_encap_entry_attach(struct mlx5e_priv *priv,
                                 struct mlx5e_encap_entry *e,
                                 struct mlx5e_neigh *m_neigh,
                                 struct net_device *neigh_dev)
{
        struct mlx5e_rep_priv *rpriv = priv->ppriv;
        struct mlx5_rep_uplink_priv *uplink_priv = &rpriv->uplink_priv;
        struct mlx5_tun_entropy *tun_entropy = &uplink_priv->tun_entropy;
        struct mlx5e_neigh_hash_entry *nhe;
        int err;

        err = mlx5_tun_entropy_refcount_inc(tun_entropy, e->reformat_type);
        if (err)
                return err;

        mutex_lock(&rpriv->neigh_update.encap_lock);
        nhe = mlx5e_rep_neigh_entry_lookup(priv, m_neigh);
        if (!nhe) {
                err = mlx5e_rep_neigh_entry_create(priv, m_neigh, neigh_dev, &nhe);
                if (err) {
                        mutex_unlock(&rpriv->neigh_update.encap_lock);
                        mlx5_tun_entropy_refcount_dec(tun_entropy,
                                                      e->reformat_type);
                        return err;
                }
        }

        e->nhe = nhe;
        spin_lock(&nhe->encap_list_lock);
        list_add_rcu(&e->encap_list, &nhe->encap_list);
        spin_unlock(&nhe->encap_list_lock);

        mutex_unlock(&rpriv->neigh_update.encap_lock);

        return 0;
}

void mlx5e_rep_encap_entry_detach(struct mlx5e_priv *priv,
                                  struct mlx5e_encap_entry *e)
{
        struct mlx5e_rep_priv *rpriv = priv->ppriv;
        struct mlx5_rep_uplink_priv *uplink_priv = &rpriv->uplink_priv;
        struct mlx5_tun_entropy *tun_entropy = &uplink_priv->tun_entropy;

        if (!e->nhe)
                return;

        spin_lock(&e->nhe->encap_list_lock);
        list_del_rcu(&e->encap_list);
        spin_unlock(&e->nhe->encap_list_lock);

        mlx5e_rep_neigh_entry_release(e->nhe);
        e->nhe = NULL;
        mlx5_tun_entropy_refcount_dec(tun_entropy, e->reformat_type);
}

void mlx5e_rep_update_flows(struct mlx5e_priv *priv,
                            struct mlx5e_encap_entry *e,
                            bool neigh_connected,
                            unsigned char ha[ETH_ALEN])
{
        struct ethhdr *eth = (struct ethhdr *)e->encap_header;
        struct mlx5_eswitch *esw = priv->mdev->priv.eswitch;
        bool encap_connected;
        LIST_HEAD(flow_list);

        ASSERT_RTNL();

        mutex_lock(&esw->offloads.encap_tbl_lock);
        encap_connected = !!(e->flags & MLX5_ENCAP_ENTRY_VALID);
        if (encap_connected == neigh_connected && ether_addr_equal(e->h_dest, ha))
                goto unlock;

        mlx5e_take_all_encap_flows(e, &flow_list);

        if ((e->flags & MLX5_ENCAP_ENTRY_VALID) &&
            (!neigh_connected || !ether_addr_equal(e->h_dest, ha)))
                mlx5e_tc_encap_flows_del(priv, e, &flow_list);

        if (neigh_connected && !(e->flags & MLX5_ENCAP_ENTRY_VALID)) {
                struct net_device *route_dev;

                ether_addr_copy(e->h_dest, ha);
                ether_addr_copy(eth->h_dest, ha);
                /* Update the encap source mac, in case that we delete
                 * the flows when encap source mac changed.
                 */
                route_dev = __dev_get_by_index(dev_net(priv->netdev), e->route_dev_ifindex);
                if (route_dev)
                        ether_addr_copy(eth->h_source, route_dev->dev_addr);

                mlx5e_tc_encap_flows_add(priv, e, &flow_list);
        }
unlock:
        mutex_unlock(&esw->offloads.encap_tbl_lock);
        mlx5e_put_flow_list(priv, &flow_list);
}

static int
mlx5e_rep_setup_tc_cls_flower(struct mlx5e_priv *priv,
                              struct flow_cls_offload *cls_flower, int flags)
{
        switch (cls_flower->command) {
        case FLOW_CLS_REPLACE:
                return mlx5e_configure_flower(priv->netdev, priv, cls_flower,
                                              flags);
        case FLOW_CLS_DESTROY:
                return mlx5e_delete_flower(priv->netdev, priv, cls_flower,
                                           flags);
        case FLOW_CLS_STATS:
                return mlx5e_stats_flower(priv->netdev, priv, cls_flower,
                                          flags);
        default:
                return -EOPNOTSUPP;
        }
}

static void mlx5e_tc_stats_matchall(struct mlx5e_priv *priv,
                                    struct tc_cls_matchall_offload *ma)
{
        struct mlx5e_rep_priv *rpriv = priv->ppriv;
        u64 dbytes;
        u64 dpkts;

        dpkts = priv->stats.rep_stats.vport_rx_packets - rpriv->prev_vf_vport_stats.rx_packets;
        dbytes = priv->stats.rep_stats.vport_rx_bytes - rpriv->prev_vf_vport_stats.rx_bytes;
        mlx5e_stats_copy_rep_stats(&rpriv->prev_vf_vport_stats, &priv->stats.rep_stats);
        flow_stats_update(&ma->stats, dbytes, dpkts, 0, jiffies,
                          FLOW_ACTION_HW_STATS_DELAYED);
}

static
int mlx5e_rep_setup_tc_cls_matchall(struct mlx5e_priv *priv,
                                    struct tc_cls_matchall_offload *ma)
{
        switch (ma->command) {
        case TC_CLSMATCHALL_REPLACE:
                return mlx5e_tc_configure_matchall(priv, ma);
        case TC_CLSMATCHALL_DESTROY:
                return mlx5e_tc_delete_matchall(priv, ma);
        case TC_CLSMATCHALL_STATS:
                mlx5e_tc_stats_matchall(priv, ma);
                return 0;
        default:
                return -EOPNOTSUPP;
        }
}

static int mlx5e_rep_setup_tc_cb(enum tc_setup_type type, void *type_data,
                                 void *cb_priv)
{
        unsigned long flags = MLX5_TC_FLAG(INGRESS) | MLX5_TC_FLAG(ESW_OFFLOAD);
        struct mlx5e_priv *priv = cb_priv;

        if (!priv->netdev || !netif_device_present(priv->netdev))
                return -EOPNOTSUPP;

        switch (type) {
        case TC_SETUP_CLSFLOWER:
                return mlx5e_rep_setup_tc_cls_flower(priv, type_data, flags);
        case TC_SETUP_CLSMATCHALL:
                return mlx5e_rep_setup_tc_cls_matchall(priv, type_data);
        default:
                return -EOPNOTSUPP;
        }
}

static int mlx5e_rep_setup_ft_cb(enum tc_setup_type type, void *type_data,
                                 void *cb_priv)
{
        struct flow_cls_offload tmp, *f = type_data;
        struct mlx5e_priv *priv = cb_priv;
        struct mlx5_eswitch *esw;
        unsigned long flags;
        int err;

        flags = MLX5_TC_FLAG(INGRESS) |
                MLX5_TC_FLAG(ESW_OFFLOAD) |
                MLX5_TC_FLAG(FT_OFFLOAD);
        esw = priv->mdev->priv.eswitch;

        switch (type) {
        case TC_SETUP_CLSFLOWER:
                memcpy(&tmp, f, sizeof(*f));

                if (!mlx5_chains_prios_supported(esw_chains(esw)))
                        return -EOPNOTSUPP;

                /* Re-use tc offload path by moving the ft flow to the
                 * reserved ft chain.
                 *
                 * FT offload can use prio range [0, INT_MAX], so we normalize
                 * it to range [1, mlx5_esw_chains_get_prio_range(esw)]
                 * as with tc, where prio 0 isn't supported.
                 *
                 * We only support chain 0 of FT offload.
                 */
                if (tmp.common.prio >= mlx5_chains_get_prio_range(esw_chains(esw)))
                        return -EOPNOTSUPP;
                if (tmp.common.chain_index != 0)
                        return -EOPNOTSUPP;

                tmp.common.chain_index = mlx5_chains_get_nf_ft_chain(esw_chains(esw));
                tmp.common.prio++;
                err = mlx5e_rep_setup_tc_cls_flower(priv, &tmp, flags);
                memcpy(&f->stats, &tmp.stats, sizeof(f->stats));
                return err;
        default:
                return -EOPNOTSUPP;
        }
}

static LIST_HEAD(mlx5e_rep_block_tc_cb_list);
static LIST_HEAD(mlx5e_rep_block_ft_cb_list);
int mlx5e_rep_setup_tc(struct net_device *dev, enum tc_setup_type type,
                       void *type_data)
{
        struct mlx5e_priv *priv = netdev_priv(dev);
        struct flow_block_offload *f = type_data;

        f->unlocked_driver_cb = true;

        switch (type) {
        case TC_SETUP_BLOCK:
                return flow_block_cb_setup_simple(type_data,
                                                  &mlx5e_rep_block_tc_cb_list,
                                                  mlx5e_rep_setup_tc_cb,
                                                  priv, priv, true);
        case TC_SETUP_FT:
                return flow_block_cb_setup_simple(type_data,
                                                  &mlx5e_rep_block_ft_cb_list,
                                                  mlx5e_rep_setup_ft_cb,
                                                  priv, priv, true);
        default:
                return -EOPNOTSUPP;
        }
}

int mlx5e_rep_tc_init(struct mlx5e_rep_priv *rpriv)
{
        struct mlx5_rep_uplink_priv *uplink_priv = &rpriv->uplink_priv;
        int err;

        mutex_init(&uplink_priv->unready_flows_lock);
        INIT_LIST_HEAD(&uplink_priv->unready_flows);

        /* init shared tc flow table */
        err = mlx5e_tc_esw_init(uplink_priv);
        return err;
}

void mlx5e_rep_tc_cleanup(struct mlx5e_rep_priv *rpriv)
{
        /* delete shared tc flow table */
        mlx5e_tc_esw_cleanup(&rpriv->uplink_priv);
        mutex_destroy(&rpriv->uplink_priv.unready_flows_lock);
}

void mlx5e_rep_tc_enable(struct mlx5e_priv *priv)
{
        struct mlx5e_rep_priv *rpriv = priv->ppriv;

        INIT_WORK(&rpriv->uplink_priv.reoffload_flows_work,
                  mlx5e_tc_reoffload_flows_work);
}

void mlx5e_rep_tc_disable(struct mlx5e_priv *priv)
{
        struct mlx5e_rep_priv *rpriv = priv->ppriv;

        cancel_work_sync(&rpriv->uplink_priv.reoffload_flows_work);
}

int mlx5e_rep_tc_event_port_affinity(struct mlx5e_priv *priv)
{
        struct mlx5e_rep_priv *rpriv = priv->ppriv;

        queue_work(priv->wq, &rpriv->uplink_priv.reoffload_flows_work);

        return NOTIFY_OK;
}

static struct mlx5e_rep_indr_block_priv *
mlx5e_rep_indr_block_priv_lookup(struct mlx5e_rep_priv *rpriv,
                                 struct net_device *netdev,
                                 enum flow_block_binder_type binder_type)
{
        struct mlx5e_rep_indr_block_priv *cb_priv;

        list_for_each_entry(cb_priv,
                            &rpriv->uplink_priv.tc_indr_block_priv_list,
                            list)
                if (cb_priv->netdev == netdev &&
                    cb_priv->binder_type == binder_type)
                        return cb_priv;

        return NULL;
}

static int
mlx5e_rep_indr_offload(struct net_device *netdev,
                       struct flow_cls_offload *flower,
                       struct mlx5e_rep_indr_block_priv *indr_priv,
                       unsigned long flags)
{
        struct mlx5e_priv *priv = netdev_priv(indr_priv->rpriv->netdev);
        int err = 0;

        if (!netif_device_present(indr_priv->rpriv->netdev))
                return -EOPNOTSUPP;

        switch (flower->command) {
        case FLOW_CLS_REPLACE:
                err = mlx5e_configure_flower(netdev, priv, flower, flags);
                break;
        case FLOW_CLS_DESTROY:
                err = mlx5e_delete_flower(netdev, priv, flower, flags);
                break;
        case FLOW_CLS_STATS:
                err = mlx5e_stats_flower(netdev, priv, flower, flags);
                break;
        default:
                err = -EOPNOTSUPP;
        }

        return err;
}

static int mlx5e_rep_indr_setup_tc_cb(enum tc_setup_type type,
                                      void *type_data, void *indr_priv)
{
        unsigned long flags = MLX5_TC_FLAG(ESW_OFFLOAD);
        struct mlx5e_rep_indr_block_priv *priv = indr_priv;

        flags |= (priv->binder_type == FLOW_BLOCK_BINDER_TYPE_CLSACT_EGRESS) ?
                MLX5_TC_FLAG(EGRESS) :
                MLX5_TC_FLAG(INGRESS);

        switch (type) {
        case TC_SETUP_CLSFLOWER:
                return mlx5e_rep_indr_offload(priv->netdev, type_data, priv,
                                              flags);
        default:
                return -EOPNOTSUPP;
        }
}

static int mlx5e_rep_indr_setup_ft_cb(enum tc_setup_type type,
                                      void *type_data, void *indr_priv)
{
        struct mlx5e_rep_indr_block_priv *priv = indr_priv;
        struct flow_cls_offload *f = type_data;
        struct flow_cls_offload tmp;
        struct mlx5e_priv *mpriv;
        struct mlx5_eswitch *esw;
        unsigned long flags;
        int err;

        mpriv = netdev_priv(priv->rpriv->netdev);
        esw = mpriv->mdev->priv.eswitch;

        flags = MLX5_TC_FLAG(EGRESS) |
                MLX5_TC_FLAG(ESW_OFFLOAD) |
                MLX5_TC_FLAG(FT_OFFLOAD);

        switch (type) {
        case TC_SETUP_CLSFLOWER:
                memcpy(&tmp, f, sizeof(*f));

                /* Re-use tc offload path by moving the ft flow to the
                 * reserved ft chain.
                 *
                 * FT offload can use prio range [0, INT_MAX], so we normalize
                 * it to range [1, mlx5_esw_chains_get_prio_range(esw)]
                 * as with tc, where prio 0 isn't supported.
                 *
                 * We only support chain 0 of FT offload.
                 */
                if (!mlx5_chains_prios_supported(esw_chains(esw)) ||
                    tmp.common.prio >= mlx5_chains_get_prio_range(esw_chains(esw)) ||
                    tmp.common.chain_index)
                        return -EOPNOTSUPP;

                tmp.common.chain_index = mlx5_chains_get_nf_ft_chain(esw_chains(esw));
                tmp.common.prio++;
                err = mlx5e_rep_indr_offload(priv->netdev, &tmp, priv, flags);
                memcpy(&f->stats, &tmp.stats, sizeof(f->stats));
                return err;
        default:
                return -EOPNOTSUPP;
        }
}

static void mlx5e_rep_indr_block_unbind(void *cb_priv)
{
        struct mlx5e_rep_indr_block_priv *indr_priv = cb_priv;

        list_del(&indr_priv->list);
        kfree(indr_priv);
}

static LIST_HEAD(mlx5e_block_cb_list);

static bool mlx5e_rep_macvlan_mode_supported(const struct net_device *dev)
{
        struct macvlan_dev *macvlan = netdev_priv(dev);

        return macvlan->mode == MACVLAN_MODE_PASSTHRU;
}

static bool
mlx5e_rep_check_indr_block_supported(struct mlx5e_rep_priv *rpriv,
                                     struct net_device *netdev,
                                     struct flow_block_offload *f)
{
        struct mlx5e_priv *priv = netdev_priv(rpriv->netdev);
        struct mlx5_eswitch *esw = priv->mdev->priv.eswitch;
        struct net_device *macvlan_real_dev;

        if (f->binder_type != FLOW_BLOCK_BINDER_TYPE_CLSACT_INGRESS &&
            f->binder_type != FLOW_BLOCK_BINDER_TYPE_CLSACT_EGRESS)
                return false;

        if (mlx5e_tc_tun_device_to_offload(priv, netdev))
                return true;

        if (is_vlan_dev(netdev) && vlan_dev_real_dev(netdev) == rpriv->netdev)
                return true;

        if (netif_is_macvlan(netdev)) {
                if (!mlx5e_rep_macvlan_mode_supported(netdev)) {
                        netdev_warn(netdev, "Offloading ingress filter is supported only with macvlan passthru mode");
                        return false;
                }

                macvlan_real_dev = macvlan_dev_real_dev(netdev);

                if (macvlan_real_dev == rpriv->netdev)
                        return true;
                if (netif_is_bond_master(macvlan_real_dev))
                        return true;
        }

        if (netif_is_ovs_master(netdev) && f->binder_type == FLOW_BLOCK_BINDER_TYPE_CLSACT_EGRESS &&
            mlx5e_tc_int_port_supported(esw))
                return true;

        return false;
}

static int
mlx5e_rep_indr_setup_block(struct net_device *netdev, struct Qdisc *sch,
                           struct mlx5e_rep_priv *rpriv,
                           struct flow_block_offload *f,
                           flow_setup_cb_t *setup_cb,
                           void *data,
                           void (*cleanup)(struct flow_block_cb *block_cb))
{
        struct mlx5e_rep_indr_block_priv *indr_priv;
        struct flow_block_cb *block_cb;

        if (!mlx5e_rep_check_indr_block_supported(rpriv, netdev, f))
                return -EOPNOTSUPP;

        f->unlocked_driver_cb = true;
        f->driver_block_list = &mlx5e_block_cb_list;

        switch (f->command) {
        case FLOW_BLOCK_BIND:
                indr_priv = mlx5e_rep_indr_block_priv_lookup(rpriv, netdev, f->binder_type);
                if (indr_priv)
                        return -EEXIST;

                indr_priv = kmalloc_obj(*indr_priv);
                if (!indr_priv)
                        return -ENOMEM;

                indr_priv->netdev = netdev;
                indr_priv->rpriv = rpriv;
                indr_priv->binder_type = f->binder_type;
                list_add(&indr_priv->list,
                         &rpriv->uplink_priv.tc_indr_block_priv_list);

                block_cb = flow_indr_block_cb_alloc(setup_cb, indr_priv, indr_priv,
                                                    mlx5e_rep_indr_block_unbind,
                                                    f, netdev, sch, data, rpriv,
                                                    cleanup);
                if (IS_ERR(block_cb)) {
                        list_del(&indr_priv->list);
                        kfree(indr_priv);
                        return PTR_ERR(block_cb);
                }
                flow_block_cb_add(block_cb, f);
                list_add_tail(&block_cb->driver_list, &mlx5e_block_cb_list);

                return 0;
        case FLOW_BLOCK_UNBIND:
                indr_priv = mlx5e_rep_indr_block_priv_lookup(rpriv, netdev, f->binder_type);
                if (!indr_priv)
                        return -ENOENT;

                block_cb = flow_block_cb_lookup(f->block, setup_cb, indr_priv);
                if (!block_cb)
                        return -ENOENT;

                flow_indr_block_cb_remove(block_cb, f);
                list_del(&block_cb->driver_list);
                return 0;
        default:
                return -EOPNOTSUPP;
        }
        return 0;
}

static int
mlx5e_rep_indr_replace_act(struct mlx5e_rep_priv *rpriv,
                           struct flow_offload_action *fl_act)

{
        struct mlx5e_priv *priv = netdev_priv(rpriv->netdev);
        struct mlx5_eswitch *esw = priv->mdev->priv.eswitch;
        enum mlx5_flow_namespace_type ns_type;
        struct flow_action_entry *action;
        struct mlx5e_tc_act *act;
        bool add = false;
        int i;

        /* There is no use case currently for more than one action (e.g. pedit).
         * when there will be, need to handle cleaning multiple actions on err.
         */
        if (!flow_offload_has_one_action(&fl_act->action))
                return -EOPNOTSUPP;

        if (esw && esw->mode == MLX5_ESWITCH_OFFLOADS)
                ns_type = MLX5_FLOW_NAMESPACE_FDB;
        else
                ns_type = MLX5_FLOW_NAMESPACE_KERNEL;

        flow_action_for_each(i, action, &fl_act->action) {
                act = mlx5e_tc_act_get(action->id, ns_type);
                if (!act)
                        continue;

                if (!act->offload_action)
                        continue;

                if (!act->offload_action(priv, fl_act, action))
                        add = true;
        }

        return add ? 0 : -EOPNOTSUPP;
}

static int
mlx5e_rep_indr_destroy_act(struct mlx5e_rep_priv *rpriv,
                           struct flow_offload_action *fl_act)
{
        struct mlx5e_priv *priv = netdev_priv(rpriv->netdev);
        struct mlx5_eswitch *esw = priv->mdev->priv.eswitch;
        enum mlx5_flow_namespace_type ns_type;
        struct mlx5e_tc_act *act;

        if (esw && esw->mode == MLX5_ESWITCH_OFFLOADS)
                ns_type = MLX5_FLOW_NAMESPACE_FDB;
        else
                ns_type = MLX5_FLOW_NAMESPACE_KERNEL;

        act = mlx5e_tc_act_get(fl_act->id, ns_type);
        if (!act || !act->destroy_action)
                return -EOPNOTSUPP;

        return act->destroy_action(priv, fl_act);
}

static int
mlx5e_rep_indr_stats_act(struct mlx5e_rep_priv *rpriv,
                         struct flow_offload_action *fl_act)

{
        struct mlx5e_priv *priv = netdev_priv(rpriv->netdev);
        struct mlx5_eswitch *esw = priv->mdev->priv.eswitch;
        enum mlx5_flow_namespace_type ns_type;
        struct mlx5e_tc_act *act;

        if (esw && esw->mode == MLX5_ESWITCH_OFFLOADS)
                ns_type = MLX5_FLOW_NAMESPACE_FDB;
        else
                ns_type = MLX5_FLOW_NAMESPACE_KERNEL;

        act = mlx5e_tc_act_get(fl_act->id, ns_type);
        if (!act || !act->stats_action)
                return mlx5e_tc_fill_action_stats(priv, fl_act);

        return act->stats_action(priv, fl_act);
}

static int
mlx5e_rep_indr_setup_act(struct mlx5e_rep_priv *rpriv,
                         struct flow_offload_action *fl_act)
{
        switch (fl_act->command) {
        case FLOW_ACT_REPLACE:
                return mlx5e_rep_indr_replace_act(rpriv, fl_act);
        case FLOW_ACT_DESTROY:
                return mlx5e_rep_indr_destroy_act(rpriv, fl_act);
        case FLOW_ACT_STATS:
                return mlx5e_rep_indr_stats_act(rpriv, fl_act);
        default:
                return -EOPNOTSUPP;
        }
}

static int
mlx5e_rep_indr_no_dev_setup(struct mlx5e_rep_priv *rpriv,
                            enum tc_setup_type type,
                            void *data)
{
        if (!data)
                return -EOPNOTSUPP;

        switch (type) {
        case TC_SETUP_ACT:
                return mlx5e_rep_indr_setup_act(rpriv, data);
        default:
                return -EOPNOTSUPP;
        }
}

static
int mlx5e_rep_indr_setup_cb(struct net_device *netdev, struct Qdisc *sch, void *cb_priv,
                            enum tc_setup_type type, void *type_data,
                            void *data,
                            void (*cleanup)(struct flow_block_cb *block_cb))
{
        if (!netdev)
                return mlx5e_rep_indr_no_dev_setup(cb_priv, type, data);

        switch (type) {
        case TC_SETUP_BLOCK:
                return mlx5e_rep_indr_setup_block(netdev, sch, cb_priv, type_data,
                                                  mlx5e_rep_indr_setup_tc_cb,
                                                  data, cleanup);
        case TC_SETUP_FT:
                return mlx5e_rep_indr_setup_block(netdev, sch, cb_priv, type_data,
                                                  mlx5e_rep_indr_setup_ft_cb,
                                                  data, cleanup);
        default:
                return -EOPNOTSUPP;
        }
}

int mlx5e_rep_tc_netdevice_event_register(struct mlx5e_rep_priv *rpriv)
{
        struct mlx5_rep_uplink_priv *uplink_priv = &rpriv->uplink_priv;

        /* init indirect block notifications */
        INIT_LIST_HEAD(&uplink_priv->tc_indr_block_priv_list);

        return flow_indr_dev_register(mlx5e_rep_indr_setup_cb, rpriv);
}

void mlx5e_rep_tc_netdevice_event_unregister(struct mlx5e_rep_priv *rpriv)
{
        flow_indr_dev_unregister(mlx5e_rep_indr_setup_cb, rpriv,
                                 mlx5e_rep_indr_block_unbind);
}

void mlx5e_rep_tc_receive(struct mlx5_cqe64 *cqe, struct mlx5e_rq *rq,
                          struct sk_buff *skb)
{
        u32 reg_c0, reg_c1, zone_restore_id, tunnel_id;
        struct mlx5e_tc_update_priv tc_priv = {};
        struct mlx5_rep_uplink_priv *uplink_priv;
        struct mlx5e_rep_priv *uplink_rpriv;
        struct mlx5_tc_ct_priv *ct_priv;
        struct mapping_ctx *mapping_ctx;
        struct mlx5_eswitch *esw;
        struct mlx5e_priv *priv;

        reg_c0 = (be32_to_cpu(cqe->sop_drop_qpn) & MLX5E_TC_FLOW_ID_MASK);
        if (!reg_c0 || reg_c0 == MLX5_FS_DEFAULT_FLOW_TAG)
                goto forward;

        /* If mapped_obj_id is not equal to the default flow tag then skb->mark
         * is not supported and must be reset back to 0.
         */
        skb->mark = 0;

        priv = netdev_priv(skb->dev);
        esw = priv->mdev->priv.eswitch;
        mapping_ctx = esw->offloads.reg_c0_obj_pool;
        reg_c1 = be32_to_cpu(cqe->ft_metadata);
        zone_restore_id = reg_c1 & ESW_ZONE_ID_MASK;
        tunnel_id = (reg_c1 >> ESW_TUN_OFFSET) & TUNNEL_ID_MASK;

        uplink_rpriv = mlx5_eswitch_get_uplink_priv(esw, REP_ETH);
        uplink_priv = &uplink_rpriv->uplink_priv;
        ct_priv = uplink_priv->ct_priv;

#ifdef CONFIG_MLX5_EN_IPSEC
        if (!(tunnel_id >> ESW_TUN_OPTS_BITS)) {
                u32 mapped_id;
                u32 metadata;

                mapped_id = tunnel_id & ESW_IPSEC_RX_MAPPED_ID_MASK;
                if (mapped_id &&
                    !mlx5_esw_ipsec_rx_make_metadata(priv, mapped_id, &metadata))
                        mlx5e_ipsec_offload_handle_rx_skb(priv->netdev, skb, metadata);
        }
#endif

        if (!mlx5e_tc_update_skb(cqe, skb, mapping_ctx, reg_c0, ct_priv,
                                 zone_restore_id, tunnel_id, &tc_priv))
                goto free_skb;

forward:
        if (tc_priv.skb_done)
                goto free_skb;

        if (tc_priv.forward_tx)
                dev_queue_xmit(skb);
        else
                napi_gro_receive(rq->cq.napi, skb);

        dev_put(tc_priv.fwd_dev);

        return;

free_skb:
        dev_put(tc_priv.fwd_dev);
        dev_kfree_skb_any(skb);
}