// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
/* Copyright (c) 2015-2018 Mellanox Technologies. All rights reserved */

#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/slab.h>
#include <linux/device.h>
#include <linux/skbuff.h>
#include <linux/if_vlan.h>
#include <linux/if_bridge.h>
#include <linux/workqueue.h>
#include <linux/jiffies.h>
#include <linux/rtnetlink.h>
#include <linux/netlink.h>
#include <net/switchdev.h>
#include <net/vxlan.h>

#include "spectrum_span.h"
#include "spectrum_switchdev.h"
#include "spectrum.h"
#include "core.h"
#include "reg.h"

struct mlxsw_sp_bridge_ops;

struct mlxsw_sp_bridge {
        struct mlxsw_sp *mlxsw_sp;
        struct {
                struct delayed_work dw;
#define MLXSW_SP_DEFAULT_LEARNING_INTERVAL 100
                unsigned int interval; /* ms */
        } fdb_notify;
#define MLXSW_SP_MIN_AGEING_TIME 10
#define MLXSW_SP_MAX_AGEING_TIME 1000000
#define MLXSW_SP_DEFAULT_AGEING_TIME 300
        u32 ageing_time;
        bool vlan_enabled_exists;
        struct list_head bridges_list;
        DECLARE_BITMAP(mids_bitmap, MLXSW_SP_MID_MAX);
        const struct mlxsw_sp_bridge_ops *bridge_8021q_ops;
        const struct mlxsw_sp_bridge_ops *bridge_8021d_ops;
        const struct mlxsw_sp_bridge_ops *bridge_8021ad_ops;
};

struct mlxsw_sp_bridge_device {
        struct net_device *dev;
        struct list_head list;
        struct list_head ports_list;
        struct list_head mids_list;
        u8 vlan_enabled:1,
           multicast_enabled:1,
           mrouter:1;
        const struct mlxsw_sp_bridge_ops *ops;
};

struct mlxsw_sp_bridge_port {
        struct net_device *dev;
        struct mlxsw_sp_bridge_device *bridge_device;
        struct list_head list;
        struct list_head vlans_list;
        unsigned int ref_count;
        u8 stp_state;
        unsigned long flags;
        bool mrouter;
        bool lagged;
        union {
                u16 lag_id;
                u16 system_port;
        };
};

struct mlxsw_sp_bridge_vlan {
        struct list_head list;
        struct list_head port_vlan_list;
        u16 vid;
};

struct mlxsw_sp_bridge_ops {
        int (*port_join)(struct mlxsw_sp_bridge_device *bridge_device,
                         struct mlxsw_sp_bridge_port *bridge_port,
                         struct mlxsw_sp_port *mlxsw_sp_port,
                         struct netlink_ext_ack *extack);
        void (*port_leave)(struct mlxsw_sp_bridge_device *bridge_device,
                           struct mlxsw_sp_bridge_port *bridge_port,
                           struct mlxsw_sp_port *mlxsw_sp_port);
        int (*vxlan_join)(struct mlxsw_sp_bridge_device *bridge_device,
                          const struct net_device *vxlan_dev, u16 vid,
                          struct netlink_ext_ack *extack);
        struct mlxsw_sp_fid *
                (*fid_get)(struct mlxsw_sp_bridge_device *bridge_device,
                           u16 vid, struct netlink_ext_ack *extack);
        struct mlxsw_sp_fid *
                (*fid_lookup)(struct mlxsw_sp_bridge_device *bridge_device,
                              u16 vid);
        u16 (*fid_vid)(struct mlxsw_sp_bridge_device *bridge_device,
                       const struct mlxsw_sp_fid *fid);
};

struct mlxsw_sp_switchdev_ops {
        void (*init)(struct mlxsw_sp *mlxsw_sp);
};

static int
mlxsw_sp_bridge_port_fdb_flush(struct mlxsw_sp *mlxsw_sp,
                               struct mlxsw_sp_bridge_port *bridge_port,
                               u16 fid_index);

static void
mlxsw_sp_bridge_port_mdb_flush(struct mlxsw_sp_port *mlxsw_sp_port,
                               struct mlxsw_sp_bridge_port *bridge_port);

static void
mlxsw_sp_bridge_mdb_mc_enable_sync(struct mlxsw_sp_port *mlxsw_sp_port,
                                   struct mlxsw_sp_bridge_device
                                   *bridge_device);

static void
mlxsw_sp_port_mrouter_update_mdb(struct mlxsw_sp_port *mlxsw_sp_port,
                                 struct mlxsw_sp_bridge_port *bridge_port,
                                 bool add);

static struct mlxsw_sp_bridge_device *
mlxsw_sp_bridge_device_find(const struct mlxsw_sp_bridge *bridge,
                            const struct net_device *br_dev)
{
        struct mlxsw_sp_bridge_device *bridge_device;

        list_for_each_entry(bridge_device, &bridge->bridges_list, list)
                if (bridge_device->dev == br_dev)
                        return bridge_device;

        return NULL;
}

bool mlxsw_sp_bridge_device_is_offloaded(const struct mlxsw_sp *mlxsw_sp,
                                         const struct net_device *br_dev)
{
        return !!mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
}

static int mlxsw_sp_bridge_device_upper_rif_destroy(struct net_device *dev,
                                                    struct netdev_nested_priv *priv)
{
        struct mlxsw_sp *mlxsw_sp = priv->data;

        mlxsw_sp_rif_destroy_by_dev(mlxsw_sp, dev);
        return 0;
}

static void mlxsw_sp_bridge_device_rifs_destroy(struct mlxsw_sp *mlxsw_sp,
                                                struct net_device *dev)
{
        struct netdev_nested_priv priv = {
                .data = (void *)mlxsw_sp,
        };

        mlxsw_sp_rif_destroy_by_dev(mlxsw_sp, dev);
        netdev_walk_all_upper_dev_rcu(dev,
                                      mlxsw_sp_bridge_device_upper_rif_destroy,
                                      &priv);
}

static int mlxsw_sp_bridge_device_vxlan_init(struct mlxsw_sp_bridge *bridge,
                                             struct net_device *br_dev,
                                             struct netlink_ext_ack *extack)
{
        struct net_device *dev, *stop_dev;
        struct list_head *iter;
        int err;

        netdev_for_each_lower_dev(br_dev, dev, iter) {
                if (netif_is_vxlan(dev) && netif_running(dev)) {
                        err = mlxsw_sp_bridge_vxlan_join(bridge->mlxsw_sp,
                                                         br_dev, dev, 0,
                                                         extack);
                        if (err) {
                                stop_dev = dev;
                                goto err_vxlan_join;
                        }
                }
        }

        return 0;

err_vxlan_join:
        netdev_for_each_lower_dev(br_dev, dev, iter) {
                if (netif_is_vxlan(dev) && netif_running(dev)) {
                        if (stop_dev == dev)
                                break;
                        mlxsw_sp_bridge_vxlan_leave(bridge->mlxsw_sp, dev);
                }
        }
        return err;
}

static void mlxsw_sp_bridge_device_vxlan_fini(struct mlxsw_sp_bridge *bridge,
                                              struct net_device *br_dev)
{
        struct net_device *dev;
        struct list_head *iter;

        netdev_for_each_lower_dev(br_dev, dev, iter) {
                if (netif_is_vxlan(dev) && netif_running(dev))
                        mlxsw_sp_bridge_vxlan_leave(bridge->mlxsw_sp, dev);
        }
}

static struct mlxsw_sp_bridge_device *
mlxsw_sp_bridge_device_create(struct mlxsw_sp_bridge *bridge,
                              struct net_device *br_dev,
                              struct netlink_ext_ack *extack)
{
        struct device *dev = bridge->mlxsw_sp->bus_info->dev;
        struct mlxsw_sp_bridge_device *bridge_device;
        bool vlan_enabled = br_vlan_enabled(br_dev);
        int err;

        if (vlan_enabled && bridge->vlan_enabled_exists) {
                dev_err(dev, "Only one VLAN-aware bridge is supported\n");
                NL_SET_ERR_MSG_MOD(extack, "Only one VLAN-aware bridge is supported");
                return ERR_PTR(-EINVAL);
        }

        bridge_device = kzalloc(sizeof(*bridge_device), GFP_KERNEL);
        if (!bridge_device)
                return ERR_PTR(-ENOMEM);

        bridge_device->dev = br_dev;
        bridge_device->vlan_enabled = vlan_enabled;
        bridge_device->multicast_enabled = br_multicast_enabled(br_dev);
        bridge_device->mrouter = br_multicast_router(br_dev);
        INIT_LIST_HEAD(&bridge_device->ports_list);
        if (vlan_enabled) {
                u16 proto;

                bridge->vlan_enabled_exists = true;
                br_vlan_get_proto(br_dev, &proto);
                if (proto == ETH_P_8021AD)
                        bridge_device->ops = bridge->bridge_8021ad_ops;
                else
                        bridge_device->ops = bridge->bridge_8021q_ops;
        } else {
                bridge_device->ops = bridge->bridge_8021d_ops;
        }
        INIT_LIST_HEAD(&bridge_device->mids_list);
        list_add(&bridge_device->list, &bridge->bridges_list);

        /* It is possible we already have VXLAN devices enslaved to the bridge.
         * In which case, we need to replay their configuration as if they were
         * just now enslaved to the bridge.
         */
        err = mlxsw_sp_bridge_device_vxlan_init(bridge, br_dev, extack);
        if (err)
                goto err_vxlan_init;

        return bridge_device;

err_vxlan_init:
        list_del(&bridge_device->list);
        if (bridge_device->vlan_enabled)
                bridge->vlan_enabled_exists = false;
        kfree(bridge_device);
        return ERR_PTR(err);
}

static void
mlxsw_sp_bridge_device_destroy(struct mlxsw_sp_bridge *bridge,
                               struct mlxsw_sp_bridge_device *bridge_device)
{
        mlxsw_sp_bridge_device_vxlan_fini(bridge, bridge_device->dev);
        mlxsw_sp_bridge_device_rifs_destroy(bridge->mlxsw_sp,
                                            bridge_device->dev);
        list_del(&bridge_device->list);
        if (bridge_device->vlan_enabled)
                bridge->vlan_enabled_exists = false;
        WARN_ON(!list_empty(&bridge_device->ports_list));
        WARN_ON(!list_empty(&bridge_device->mids_list));
        kfree(bridge_device);
}

static struct mlxsw_sp_bridge_device *
mlxsw_sp_bridge_device_get(struct mlxsw_sp_bridge *bridge,
                           struct net_device *br_dev,
                           struct netlink_ext_ack *extack)
{
        struct mlxsw_sp_bridge_device *bridge_device;

        bridge_device = mlxsw_sp_bridge_device_find(bridge, br_dev);
        if (bridge_device)
                return bridge_device;

        return mlxsw_sp_bridge_device_create(bridge, br_dev, extack);
}

static void
mlxsw_sp_bridge_device_put(struct mlxsw_sp_bridge *bridge,
                           struct mlxsw_sp_bridge_device *bridge_device)
{
        if (list_empty(&bridge_device->ports_list))
                mlxsw_sp_bridge_device_destroy(bridge, bridge_device);
}

static struct mlxsw_sp_bridge_port *
__mlxsw_sp_bridge_port_find(const struct mlxsw_sp_bridge_device *bridge_device,
                            const struct net_device *brport_dev)
{
        struct mlxsw_sp_bridge_port *bridge_port;

        list_for_each_entry(bridge_port, &bridge_device->ports_list, list) {
                if (bridge_port->dev == brport_dev)
                        return bridge_port;
        }

        return NULL;
}

struct mlxsw_sp_bridge_port *
mlxsw_sp_bridge_port_find(struct mlxsw_sp_bridge *bridge,
                          struct net_device *brport_dev)
{
        struct net_device *br_dev = netdev_master_upper_dev_get(brport_dev);
        struct mlxsw_sp_bridge_device *bridge_device;

        if (!br_dev)
                return NULL;

        bridge_device = mlxsw_sp_bridge_device_find(bridge, br_dev);
        if (!bridge_device)
                return NULL;

        return __mlxsw_sp_bridge_port_find(bridge_device, brport_dev);
}

static struct mlxsw_sp_bridge_port *
mlxsw_sp_bridge_port_create(struct mlxsw_sp_bridge_device *bridge_device,
                            struct net_device *brport_dev,
                            struct netlink_ext_ack *extack)
{
        struct mlxsw_sp_bridge_port *bridge_port;
        struct mlxsw_sp_port *mlxsw_sp_port;
        int err;

        bridge_port = kzalloc(sizeof(*bridge_port), GFP_KERNEL);
        if (!bridge_port)
                return ERR_PTR(-ENOMEM);

        mlxsw_sp_port = mlxsw_sp_port_dev_lower_find(brport_dev);
        bridge_port->lagged = mlxsw_sp_port->lagged;
        if (bridge_port->lagged)
                bridge_port->lag_id = mlxsw_sp_port->lag_id;
        else
                bridge_port->system_port = mlxsw_sp_port->local_port;
        bridge_port->dev = brport_dev;
        bridge_port->bridge_device = bridge_device;
        bridge_port->stp_state = BR_STATE_DISABLED;
        bridge_port->flags = BR_LEARNING | BR_FLOOD | BR_LEARNING_SYNC |
                             BR_MCAST_FLOOD;
        INIT_LIST_HEAD(&bridge_port->vlans_list);
        list_add(&bridge_port->list, &bridge_device->ports_list);
        bridge_port->ref_count = 1;

        err = switchdev_bridge_port_offload(brport_dev, mlxsw_sp_port->dev,
                                            NULL, NULL, NULL, false, extack);
        if (err)
                goto err_switchdev_offload;

        return bridge_port;

err_switchdev_offload:
        list_del(&bridge_port->list);
        kfree(bridge_port);
        return ERR_PTR(err);
}

static void
mlxsw_sp_bridge_port_destroy(struct mlxsw_sp_bridge_port *bridge_port)
{
        switchdev_bridge_port_unoffload(bridge_port->dev, NULL, NULL, NULL);
        list_del(&bridge_port->list);
        WARN_ON(!list_empty(&bridge_port->vlans_list));
        kfree(bridge_port);
}

static struct mlxsw_sp_bridge_port *
mlxsw_sp_bridge_port_get(struct mlxsw_sp_bridge *bridge,
                         struct net_device *brport_dev,
                         struct netlink_ext_ack *extack)
{
        struct net_device *br_dev = netdev_master_upper_dev_get(brport_dev);
        struct mlxsw_sp_bridge_device *bridge_device;
        struct mlxsw_sp_bridge_port *bridge_port;
        int err;

        bridge_port = mlxsw_sp_bridge_port_find(bridge, brport_dev);
        if (bridge_port) {
                bridge_port->ref_count++;
                return bridge_port;
        }

        bridge_device = mlxsw_sp_bridge_device_get(bridge, br_dev, extack);
        if (IS_ERR(bridge_device))
                return ERR_CAST(bridge_device);

        bridge_port = mlxsw_sp_bridge_port_create(bridge_device, brport_dev,
                                                  extack);
        if (IS_ERR(bridge_port)) {
                err = PTR_ERR(bridge_port);
                goto err_bridge_port_create;
        }

        return bridge_port;

err_bridge_port_create:
        mlxsw_sp_bridge_device_put(bridge, bridge_device);
        return ERR_PTR(err);
}

static void mlxsw_sp_bridge_port_put(struct mlxsw_sp_bridge *bridge,
                                     struct mlxsw_sp_bridge_port *bridge_port)
{
        struct mlxsw_sp_bridge_device *bridge_device;

        if (--bridge_port->ref_count != 0)
                return;
        bridge_device = bridge_port->bridge_device;
        mlxsw_sp_bridge_port_destroy(bridge_port);
        mlxsw_sp_bridge_device_put(bridge, bridge_device);
}

static struct mlxsw_sp_port_vlan *
mlxsw_sp_port_vlan_find_by_bridge(struct mlxsw_sp_port *mlxsw_sp_port,
                                  const struct mlxsw_sp_bridge_device *
                                  bridge_device,
                                  u16 vid)
{
        struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;

        list_for_each_entry(mlxsw_sp_port_vlan, &mlxsw_sp_port->vlans_list,
                            list) {
                if (!mlxsw_sp_port_vlan->bridge_port)
                        continue;
                if (mlxsw_sp_port_vlan->bridge_port->bridge_device !=
                    bridge_device)
                        continue;
                if (bridge_device->vlan_enabled &&
                    mlxsw_sp_port_vlan->vid != vid)
                        continue;
                return mlxsw_sp_port_vlan;
        }

        return NULL;
}

static struct mlxsw_sp_port_vlan*
mlxsw_sp_port_vlan_find_by_fid(struct mlxsw_sp_port *mlxsw_sp_port,
                               u16 fid_index)
{
        struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;

        list_for_each_entry(mlxsw_sp_port_vlan, &mlxsw_sp_port->vlans_list,
                            list) {
                struct mlxsw_sp_fid *fid = mlxsw_sp_port_vlan->fid;

                if (fid && mlxsw_sp_fid_index(fid) == fid_index)
                        return mlxsw_sp_port_vlan;
        }

        return NULL;
}

static struct mlxsw_sp_bridge_vlan *
mlxsw_sp_bridge_vlan_find(const struct mlxsw_sp_bridge_port *bridge_port,
                          u16 vid)
{
        struct mlxsw_sp_bridge_vlan *bridge_vlan;

        list_for_each_entry(bridge_vlan, &bridge_port->vlans_list, list) {
                if (bridge_vlan->vid == vid)
                        return bridge_vlan;
        }

        return NULL;
}

static struct mlxsw_sp_bridge_vlan *
mlxsw_sp_bridge_vlan_create(struct mlxsw_sp_bridge_port *bridge_port, u16 vid)
{
        struct mlxsw_sp_bridge_vlan *bridge_vlan;

        bridge_vlan = kzalloc(sizeof(*bridge_vlan), GFP_KERNEL);
        if (!bridge_vlan)
                return NULL;

        INIT_LIST_HEAD(&bridge_vlan->port_vlan_list);
        bridge_vlan->vid = vid;
        list_add(&bridge_vlan->list, &bridge_port->vlans_list);

        return bridge_vlan;
}

static void
mlxsw_sp_bridge_vlan_destroy(struct mlxsw_sp_bridge_vlan *bridge_vlan)
{
        list_del(&bridge_vlan->list);
        WARN_ON(!list_empty(&bridge_vlan->port_vlan_list));
        kfree(bridge_vlan);
}

static struct mlxsw_sp_bridge_vlan *
mlxsw_sp_bridge_vlan_get(struct mlxsw_sp_bridge_port *bridge_port, u16 vid)
{
        struct mlxsw_sp_bridge_vlan *bridge_vlan;

        bridge_vlan = mlxsw_sp_bridge_vlan_find(bridge_port, vid);
        if (bridge_vlan)
                return bridge_vlan;

        return mlxsw_sp_bridge_vlan_create(bridge_port, vid);
}

static void mlxsw_sp_bridge_vlan_put(struct mlxsw_sp_bridge_vlan *bridge_vlan)
{
        if (list_empty(&bridge_vlan->port_vlan_list))
                mlxsw_sp_bridge_vlan_destroy(bridge_vlan);
}

static int
mlxsw_sp_port_bridge_vlan_stp_set(struct mlxsw_sp_port *mlxsw_sp_port,
                                  struct mlxsw_sp_bridge_vlan *bridge_vlan,
                                  u8 state)
{
        struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;

        list_for_each_entry(mlxsw_sp_port_vlan, &bridge_vlan->port_vlan_list,
                            bridge_vlan_node) {
                if (mlxsw_sp_port_vlan->mlxsw_sp_port != mlxsw_sp_port)
                        continue;
                return mlxsw_sp_port_vid_stp_set(mlxsw_sp_port,
                                                 bridge_vlan->vid, state);
        }

        return 0;
}

static int mlxsw_sp_port_attr_stp_state_set(struct mlxsw_sp_port *mlxsw_sp_port,
                                            struct net_device *orig_dev,
                                            u8 state)
{
        struct mlxsw_sp_bridge_port *bridge_port;
        struct mlxsw_sp_bridge_vlan *bridge_vlan;
        int err;

        /* It's possible we failed to enslave the port, yet this
         * operation is executed due to it being deferred.
         */
        bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp_port->mlxsw_sp->bridge,
                                                orig_dev);
        if (!bridge_port)
                return 0;

        list_for_each_entry(bridge_vlan, &bridge_port->vlans_list, list) {
                err = mlxsw_sp_port_bridge_vlan_stp_set(mlxsw_sp_port,
                                                        bridge_vlan, state);
                if (err)
                        goto err_port_bridge_vlan_stp_set;
        }

        bridge_port->stp_state = state;

        return 0;

err_port_bridge_vlan_stp_set:
        list_for_each_entry_continue_reverse(bridge_vlan,
                                             &bridge_port->vlans_list, list)
                mlxsw_sp_port_bridge_vlan_stp_set(mlxsw_sp_port, bridge_vlan,
                                                  bridge_port->stp_state);
        return err;
}

static int
mlxsw_sp_port_bridge_vlan_flood_set(struct mlxsw_sp_port *mlxsw_sp_port,
                                    struct mlxsw_sp_bridge_vlan *bridge_vlan,
                                    enum mlxsw_sp_flood_type packet_type,
                                    bool member)
{
        struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;

        list_for_each_entry(mlxsw_sp_port_vlan, &bridge_vlan->port_vlan_list,
                            bridge_vlan_node) {
                if (mlxsw_sp_port_vlan->mlxsw_sp_port != mlxsw_sp_port)
                        continue;
                return mlxsw_sp_fid_flood_set(mlxsw_sp_port_vlan->fid,
                                              packet_type,
                                              mlxsw_sp_port->local_port,
                                              member);
        }

        return 0;
}

static int
mlxsw_sp_bridge_port_flood_table_set(struct mlxsw_sp_port *mlxsw_sp_port,
                                     struct mlxsw_sp_bridge_port *bridge_port,
                                     enum mlxsw_sp_flood_type packet_type,
                                     bool member)
{
        struct mlxsw_sp_bridge_vlan *bridge_vlan;
        int err;

        list_for_each_entry(bridge_vlan, &bridge_port->vlans_list, list) {
                err = mlxsw_sp_port_bridge_vlan_flood_set(mlxsw_sp_port,
                                                          bridge_vlan,
                                                          packet_type,
                                                          member);
                if (err)
                        goto err_port_bridge_vlan_flood_set;
        }

        return 0;

err_port_bridge_vlan_flood_set:
        list_for_each_entry_continue_reverse(bridge_vlan,
                                             &bridge_port->vlans_list, list)
                mlxsw_sp_port_bridge_vlan_flood_set(mlxsw_sp_port, bridge_vlan,
                                                    packet_type, !member);
        return err;
}

static int
mlxsw_sp_port_bridge_vlan_learning_set(struct mlxsw_sp_port *mlxsw_sp_port,
                                       struct mlxsw_sp_bridge_vlan *bridge_vlan,
                                       bool set)
{
        struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
        u16 vid = bridge_vlan->vid;

        list_for_each_entry(mlxsw_sp_port_vlan, &bridge_vlan->port_vlan_list,
                            bridge_vlan_node) {
                if (mlxsw_sp_port_vlan->mlxsw_sp_port != mlxsw_sp_port)
                        continue;
                return mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid, set);
        }

        return 0;
}

static int
mlxsw_sp_bridge_port_learning_set(struct mlxsw_sp_port *mlxsw_sp_port,
                                  struct mlxsw_sp_bridge_port *bridge_port,
                                  bool set)
{
        struct mlxsw_sp_bridge_vlan *bridge_vlan;
        int err;

        list_for_each_entry(bridge_vlan, &bridge_port->vlans_list, list) {
                err = mlxsw_sp_port_bridge_vlan_learning_set(mlxsw_sp_port,
                                                             bridge_vlan, set);
                if (err)
                        goto err_port_bridge_vlan_learning_set;
        }

        return 0;

err_port_bridge_vlan_learning_set:
        list_for_each_entry_continue_reverse(bridge_vlan,
                                             &bridge_port->vlans_list, list)
                mlxsw_sp_port_bridge_vlan_learning_set(mlxsw_sp_port,
                                                       bridge_vlan, !set);
        return err;
}

static int
mlxsw_sp_port_attr_br_pre_flags_set(struct mlxsw_sp_port *mlxsw_sp_port,
                                    struct switchdev_brport_flags flags)
{
        if (flags.mask & ~(BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD))
                return -EINVAL;

        return 0;
}

static int mlxsw_sp_port_attr_br_flags_set(struct mlxsw_sp_port *mlxsw_sp_port,
                                           struct net_device *orig_dev,
                                           struct switchdev_brport_flags flags)
{
        struct mlxsw_sp_bridge_port *bridge_port;
        int err;

        bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp_port->mlxsw_sp->bridge,
                                                orig_dev);
        if (!bridge_port)
                return 0;

        if (flags.mask & BR_FLOOD) {
                err = mlxsw_sp_bridge_port_flood_table_set(mlxsw_sp_port,
                                                           bridge_port,
                                                           MLXSW_SP_FLOOD_TYPE_UC,
                                                           flags.val & BR_FLOOD);
                if (err)
                        return err;
        }

        if (flags.mask & BR_LEARNING) {
                err = mlxsw_sp_bridge_port_learning_set(mlxsw_sp_port,
                                                        bridge_port,
                                                        flags.val & BR_LEARNING);
                if (err)
                        return err;
        }

        if (bridge_port->bridge_device->multicast_enabled)
                goto out;

        if (flags.mask & BR_MCAST_FLOOD) {
                err = mlxsw_sp_bridge_port_flood_table_set(mlxsw_sp_port,
                                                           bridge_port,
                                                           MLXSW_SP_FLOOD_TYPE_MC,
                                                           flags.val & BR_MCAST_FLOOD);
                if (err)
                        return err;
        }

out:
        memcpy(&bridge_port->flags, &flags.val, sizeof(flags.val));
        return 0;
}

static int mlxsw_sp_ageing_set(struct mlxsw_sp *mlxsw_sp, u32 ageing_time)
{
        char sfdat_pl[MLXSW_REG_SFDAT_LEN];
        int err;

        mlxsw_reg_sfdat_pack(sfdat_pl, ageing_time);
        err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfdat), sfdat_pl);
        if (err)
                return err;
        mlxsw_sp->bridge->ageing_time = ageing_time;
        return 0;
}

static int mlxsw_sp_port_attr_br_ageing_set(struct mlxsw_sp_port *mlxsw_sp_port,
                                            unsigned long ageing_clock_t)
{
        struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
        unsigned long ageing_jiffies = clock_t_to_jiffies(ageing_clock_t);
        u32 ageing_time = jiffies_to_msecs(ageing_jiffies) / 1000;

        if (ageing_time < MLXSW_SP_MIN_AGEING_TIME ||
            ageing_time > MLXSW_SP_MAX_AGEING_TIME)
                return -ERANGE;

        return mlxsw_sp_ageing_set(mlxsw_sp, ageing_time);
}

static int mlxsw_sp_port_attr_br_vlan_set(struct mlxsw_sp_port *mlxsw_sp_port,
                                          struct net_device *orig_dev,
                                          bool vlan_enabled)
{
        struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
        struct mlxsw_sp_bridge_device *bridge_device;

        bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, orig_dev);
        if (WARN_ON(!bridge_device))
                return -EINVAL;

        if (bridge_device->vlan_enabled == vlan_enabled)
                return 0;

        netdev_err(bridge_device->dev, "VLAN filtering can't be changed for existing bridge\n");
        return -EINVAL;
}

static int mlxsw_sp_port_attr_br_vlan_proto_set(struct mlxsw_sp_port *mlxsw_sp_port,
                                                struct net_device *orig_dev,
                                                u16 vlan_proto)
{
        struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
        struct mlxsw_sp_bridge_device *bridge_device;

        bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, orig_dev);
        if (WARN_ON(!bridge_device))
                return -EINVAL;

        netdev_err(bridge_device->dev, "VLAN protocol can't be changed on existing bridge\n");
        return -EINVAL;
}

static int mlxsw_sp_port_attr_mrouter_set(struct mlxsw_sp_port *mlxsw_sp_port,
                                          struct net_device *orig_dev,
                                          bool is_port_mrouter)
{
        struct mlxsw_sp_bridge_port *bridge_port;
        int err;

        bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp_port->mlxsw_sp->bridge,
                                                orig_dev);
        if (!bridge_port)
                return 0;

        if (!bridge_port->bridge_device->multicast_enabled)
                goto out;

        err = mlxsw_sp_bridge_port_flood_table_set(mlxsw_sp_port, bridge_port,
                                                   MLXSW_SP_FLOOD_TYPE_MC,
                                                   is_port_mrouter);
        if (err)
                return err;

        mlxsw_sp_port_mrouter_update_mdb(mlxsw_sp_port, bridge_port,
                                         is_port_mrouter);
out:
        bridge_port->mrouter = is_port_mrouter;
        return 0;
}

static bool mlxsw_sp_mc_flood(const struct mlxsw_sp_bridge_port *bridge_port)
{
        const struct mlxsw_sp_bridge_device *bridge_device;

        bridge_device = bridge_port->bridge_device;
        return bridge_device->multicast_enabled ? bridge_port->mrouter :
                                        bridge_port->flags & BR_MCAST_FLOOD;
}

static int mlxsw_sp_port_mc_disabled_set(struct mlxsw_sp_port *mlxsw_sp_port,
                                         struct net_device *orig_dev,
                                         bool mc_disabled)
{
        struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
        struct mlxsw_sp_bridge_device *bridge_device;
        struct mlxsw_sp_bridge_port *bridge_port;
        int err;

        /* It's possible we failed to enslave the port, yet this
         * operation is executed due to it being deferred.
         */
        bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, orig_dev);
        if (!bridge_device)
                return 0;

        if (bridge_device->multicast_enabled != !mc_disabled) {
                bridge_device->multicast_enabled = !mc_disabled;
                mlxsw_sp_bridge_mdb_mc_enable_sync(mlxsw_sp_port,
                                                   bridge_device);
        }

        list_for_each_entry(bridge_port, &bridge_device->ports_list, list) {
                enum mlxsw_sp_flood_type packet_type = MLXSW_SP_FLOOD_TYPE_MC;
                bool member = mlxsw_sp_mc_flood(bridge_port);

                err = mlxsw_sp_bridge_port_flood_table_set(mlxsw_sp_port,
                                                           bridge_port,
                                                           packet_type, member);
                if (err)
                        return err;
        }

        bridge_device->multicast_enabled = !mc_disabled;

        return 0;
}

static int mlxsw_sp_smid_router_port_set(struct mlxsw_sp *mlxsw_sp,
                                         u16 mid_idx, bool add)
{
        char *smid_pl;
        int err;

        smid_pl = kmalloc(MLXSW_REG_SMID_LEN, GFP_KERNEL);
        if (!smid_pl)
                return -ENOMEM;

        mlxsw_reg_smid_pack(smid_pl, mid_idx,
                            mlxsw_sp_router_port(mlxsw_sp), add);
        err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(smid), smid_pl);
        kfree(smid_pl);
        return err;
}

static void
mlxsw_sp_bridge_mrouter_update_mdb(struct mlxsw_sp *mlxsw_sp,
                                   struct mlxsw_sp_bridge_device *bridge_device,
                                   bool add)
{
        struct mlxsw_sp_mid *mid;

        list_for_each_entry(mid, &bridge_device->mids_list, list)
                mlxsw_sp_smid_router_port_set(mlxsw_sp, mid->mid, add);
}

static int
mlxsw_sp_port_attr_br_mrouter_set(struct mlxsw_sp_port *mlxsw_sp_port,
                                  struct net_device *orig_dev,
                                  bool is_mrouter)
{
        struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
        struct mlxsw_sp_bridge_device *bridge_device;

        /* It's possible we failed to enslave the port, yet this
         * operation is executed due to it being deferred.
         */
        bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, orig_dev);
        if (!bridge_device)
                return 0;

        if (bridge_device->mrouter != is_mrouter)
                mlxsw_sp_bridge_mrouter_update_mdb(mlxsw_sp, bridge_device,
                                                   is_mrouter);
        bridge_device->mrouter = is_mrouter;
        return 0;
}

static int mlxsw_sp_port_attr_set(struct net_device *dev, const void *ctx,
                                  const struct switchdev_attr *attr,
                                  struct netlink_ext_ack *extack)
{
        struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
        int err;

        switch (attr->id) {
        case SWITCHDEV_ATTR_ID_PORT_STP_STATE:
                err = mlxsw_sp_port_attr_stp_state_set(mlxsw_sp_port,
                                                       attr->orig_dev,
                                                       attr->u.stp_state);
                break;
        case SWITCHDEV_ATTR_ID_PORT_PRE_BRIDGE_FLAGS:
                err = mlxsw_sp_port_attr_br_pre_flags_set(mlxsw_sp_port,
                                                          attr->u.brport_flags);
                break;
        case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS:
                err = mlxsw_sp_port_attr_br_flags_set(mlxsw_sp_port,
                                                      attr->orig_dev,
                                                      attr->u.brport_flags);
                break;
        case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME:
                err = mlxsw_sp_port_attr_br_ageing_set(mlxsw_sp_port,
                                                       attr->u.ageing_time);
                break;
        case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING:
                err = mlxsw_sp_port_attr_br_vlan_set(mlxsw_sp_port,
                                                     attr->orig_dev,
                                                     attr->u.vlan_filtering);
                break;
        case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_PROTOCOL:
                err = mlxsw_sp_port_attr_br_vlan_proto_set(mlxsw_sp_port,
                                                           attr->orig_dev,
                                                           attr->u.vlan_protocol);
                break;
        case SWITCHDEV_ATTR_ID_PORT_MROUTER:
                err = mlxsw_sp_port_attr_mrouter_set(mlxsw_sp_port,
                                                     attr->orig_dev,
                                                     attr->u.mrouter);
                break;
        case SWITCHDEV_ATTR_ID_BRIDGE_MC_DISABLED:
                err = mlxsw_sp_port_mc_disabled_set(mlxsw_sp_port,
                                                    attr->orig_dev,
                                                    attr->u.mc_disabled);
                break;
        case SWITCHDEV_ATTR_ID_BRIDGE_MROUTER:
                err = mlxsw_sp_port_attr_br_mrouter_set(mlxsw_sp_port,
                                                        attr->orig_dev,
                                                        attr->u.mrouter);
                break;
        default:
                err = -EOPNOTSUPP;
                break;
        }

        mlxsw_sp_span_respin(mlxsw_sp_port->mlxsw_sp);

        return err;
}

static int
mlxsw_sp_port_vlan_fid_join(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan,
                            struct mlxsw_sp_bridge_port *bridge_port,
                            struct netlink_ext_ack *extack)
{
        struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
        struct mlxsw_sp_bridge_device *bridge_device;
        u8 local_port = mlxsw_sp_port->local_port;
        u16 vid = mlxsw_sp_port_vlan->vid;
        struct mlxsw_sp_fid *fid;
        int err;

        bridge_device = bridge_port->bridge_device;
        fid = bridge_device->ops->fid_get(bridge_device, vid, extack);
        if (IS_ERR(fid))
                return PTR_ERR(fid);

        err = mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_UC, local_port,
                                     bridge_port->flags & BR_FLOOD);
        if (err)
                goto err_fid_uc_flood_set;

        err = mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_MC, local_port,
                                     mlxsw_sp_mc_flood(bridge_port));
        if (err)

                goto err_fid_mc_flood_set;

        err = mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_BC, local_port,
                                     true);
        if (err)
                goto err_fid_bc_flood_set;

        err = mlxsw_sp_fid_port_vid_map(fid, mlxsw_sp_port, vid);
        if (err)
                goto err_fid_port_vid_map;

        mlxsw_sp_port_vlan->fid = fid;

        return 0;

err_fid_port_vid_map:
        mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_BC, local_port, false);
err_fid_bc_flood_set:
        mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_MC, local_port, false);
err_fid_mc_flood_set:
        mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_UC, local_port, false);
err_fid_uc_flood_set:
        mlxsw_sp_fid_put(fid);
        return err;
}

static void
mlxsw_sp_port_vlan_fid_leave(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan)
{
        struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
        struct mlxsw_sp_fid *fid = mlxsw_sp_port_vlan->fid;
        u8 local_port = mlxsw_sp_port->local_port;
        u16 vid = mlxsw_sp_port_vlan->vid;

        mlxsw_sp_port_vlan->fid = NULL;
        mlxsw_sp_fid_port_vid_unmap(fid, mlxsw_sp_port, vid);
        mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_BC, local_port, false);
        mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_MC, local_port, false);
        mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_UC, local_port, false);
        mlxsw_sp_fid_put(fid);
}

static u16
mlxsw_sp_port_pvid_determine(const struct mlxsw_sp_port *mlxsw_sp_port,
                             u16 vid, bool is_pvid)
{
        if (is_pvid)
                return vid;
        else if (mlxsw_sp_port->pvid == vid)
                return 0;       /* Dis-allow untagged packets */
        else
                return mlxsw_sp_port->pvid;
}

static int
mlxsw_sp_port_vlan_bridge_join(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan,
                               struct mlxsw_sp_bridge_port *bridge_port,
                               struct netlink_ext_ack *extack)
{
        struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
        struct mlxsw_sp_bridge_vlan *bridge_vlan;
        u16 vid = mlxsw_sp_port_vlan->vid;
        int err;

        /* No need to continue if only VLAN flags were changed */
        if (mlxsw_sp_port_vlan->bridge_port)
                return 0;

        err = mlxsw_sp_port_vlan_fid_join(mlxsw_sp_port_vlan, bridge_port,
                                          extack);
        if (err)
                return err;

        err = mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid,
                                             bridge_port->flags & BR_LEARNING);
        if (err)
                goto err_port_vid_learning_set;

        err = mlxsw_sp_port_vid_stp_set(mlxsw_sp_port, vid,
                                        bridge_port->stp_state);
        if (err)
                goto err_port_vid_stp_set;

        bridge_vlan = mlxsw_sp_bridge_vlan_get(bridge_port, vid);
        if (!bridge_vlan) {
                err = -ENOMEM;
                goto err_bridge_vlan_get;
        }

        list_add(&mlxsw_sp_port_vlan->bridge_vlan_node,
                 &bridge_vlan->port_vlan_list);

        mlxsw_sp_bridge_port_get(mlxsw_sp_port->mlxsw_sp->bridge,
                                 bridge_port->dev, extack);
        mlxsw_sp_port_vlan->bridge_port = bridge_port;

        return 0;

err_bridge_vlan_get:
        mlxsw_sp_port_vid_stp_set(mlxsw_sp_port, vid, BR_STATE_DISABLED);
err_port_vid_stp_set:
        mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid, false);
err_port_vid_learning_set:
        mlxsw_sp_port_vlan_fid_leave(mlxsw_sp_port_vlan);
        return err;
}

void
mlxsw_sp_port_vlan_bridge_leave(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan)
{
        struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
        struct mlxsw_sp_fid *fid = mlxsw_sp_port_vlan->fid;
        struct mlxsw_sp_bridge_vlan *bridge_vlan;
        struct mlxsw_sp_bridge_port *bridge_port;
        u16 vid = mlxsw_sp_port_vlan->vid;
        bool last_port, last_vlan;

        if (WARN_ON(mlxsw_sp_fid_type(fid) != MLXSW_SP_FID_TYPE_8021Q &&
                    mlxsw_sp_fid_type(fid) != MLXSW_SP_FID_TYPE_8021D))
                return;

        bridge_port = mlxsw_sp_port_vlan->bridge_port;
        last_vlan = list_is_singular(&bridge_port->vlans_list);
        bridge_vlan = mlxsw_sp_bridge_vlan_find(bridge_port, vid);
        last_port = list_is_singular(&bridge_vlan->port_vlan_list);

        list_del(&mlxsw_sp_port_vlan->bridge_vlan_node);
        mlxsw_sp_bridge_vlan_put(bridge_vlan);
        mlxsw_sp_port_vid_stp_set(mlxsw_sp_port, vid, BR_STATE_DISABLED);
        mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid, false);
        if (last_port)
                mlxsw_sp_bridge_port_fdb_flush(mlxsw_sp_port->mlxsw_sp,
                                               bridge_port,
                                               mlxsw_sp_fid_index(fid));
        if (last_vlan)
                mlxsw_sp_bridge_port_mdb_flush(mlxsw_sp_port, bridge_port);

        mlxsw_sp_port_vlan_fid_leave(mlxsw_sp_port_vlan);

        mlxsw_sp_bridge_port_put(mlxsw_sp_port->mlxsw_sp->bridge, bridge_port);
        mlxsw_sp_port_vlan->bridge_port = NULL;
}

static int
mlxsw_sp_bridge_port_vlan_add(struct mlxsw_sp_port *mlxsw_sp_port,
                              struct mlxsw_sp_bridge_port *bridge_port,
                              u16 vid, bool is_untagged, bool is_pvid,
                              struct netlink_ext_ack *extack)
{
        u16 pvid = mlxsw_sp_port_pvid_determine(mlxsw_sp_port, vid, is_pvid);
        struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
        u16 old_pvid = mlxsw_sp_port->pvid;
        u16 proto;
        int err;

        /* The only valid scenario in which a port-vlan already exists, is if
         * the VLAN flags were changed and the port-vlan is associated with the
         * correct bridge port
         */
        mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_vid(mlxsw_sp_port, vid);
        if (mlxsw_sp_port_vlan &&
            mlxsw_sp_port_vlan->bridge_port != bridge_port)
                return -EEXIST;

        if (!mlxsw_sp_port_vlan) {
                mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_create(mlxsw_sp_port,
                                                               vid);
                if (IS_ERR(mlxsw_sp_port_vlan))
                        return PTR_ERR(mlxsw_sp_port_vlan);
        }

        err = mlxsw_sp_port_vlan_set(mlxsw_sp_port, vid, vid, true,
                                     is_untagged);
        if (err)
                goto err_port_vlan_set;

        br_vlan_get_proto(bridge_port->bridge_device->dev, &proto);
        err = mlxsw_sp_port_pvid_set(mlxsw_sp_port, pvid, proto);
        if (err)
                goto err_port_pvid_set;

        err = mlxsw_sp_port_vlan_bridge_join(mlxsw_sp_port_vlan, bridge_port,
                                             extack);
        if (err)
                goto err_port_vlan_bridge_join;

        return 0;

err_port_vlan_bridge_join:
        mlxsw_sp_port_pvid_set(mlxsw_sp_port, old_pvid, proto);
err_port_pvid_set:
        mlxsw_sp_port_vlan_set(mlxsw_sp_port, vid, vid, false, false);
err_port_vlan_set:
        mlxsw_sp_port_vlan_destroy(mlxsw_sp_port_vlan);
        return err;
}

static int
mlxsw_sp_br_ban_rif_pvid_change(struct mlxsw_sp *mlxsw_sp,
                                const struct net_device *br_dev,
                                const struct switchdev_obj_port_vlan *vlan)
{
        u16 pvid;

        pvid = mlxsw_sp_rif_vid(mlxsw_sp, br_dev);
        if (!pvid)
                return 0;

        if (vlan->flags & BRIDGE_VLAN_INFO_PVID) {
                if (vlan->vid != pvid) {
                        netdev_err(br_dev, "Can't change PVID, it's used by router interface\n");
                        return -EBUSY;
                }
        } else {
                if (vlan->vid == pvid) {
                        netdev_err(br_dev, "Can't remove PVID, it's used by router interface\n");
                        return -EBUSY;
                }
        }

        return 0;
}

static int mlxsw_sp_port_vlans_add(struct mlxsw_sp_port *mlxsw_sp_port,
                                   const struct switchdev_obj_port_vlan *vlan,
                                   struct netlink_ext_ack *extack)
{
        bool flag_untagged = vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED;
        bool flag_pvid = vlan->flags & BRIDGE_VLAN_INFO_PVID;
        struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
        struct net_device *orig_dev = vlan->obj.orig_dev;
        struct mlxsw_sp_bridge_port *bridge_port;

        if (netif_is_bridge_master(orig_dev)) {
                int err = 0;

                if ((vlan->flags & BRIDGE_VLAN_INFO_BRENTRY) &&
                    br_vlan_enabled(orig_dev))
                        err = mlxsw_sp_br_ban_rif_pvid_change(mlxsw_sp,
                                                              orig_dev, vlan);
                if (!err)
                        err = -EOPNOTSUPP;
                return err;
        }

        bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp->bridge, orig_dev);
        if (WARN_ON(!bridge_port))
                return -EINVAL;

        if (!bridge_port->bridge_device->vlan_enabled)
                return 0;

        return mlxsw_sp_bridge_port_vlan_add(mlxsw_sp_port, bridge_port,
                                             vlan->vid, flag_untagged,
                                             flag_pvid, extack);
}

static enum mlxsw_reg_sfdf_flush_type mlxsw_sp_fdb_flush_type(bool lagged)
{
        return lagged ? MLXSW_REG_SFDF_FLUSH_PER_LAG_AND_FID :
                        MLXSW_REG_SFDF_FLUSH_PER_PORT_AND_FID;
}

static int
mlxsw_sp_bridge_port_fdb_flush(struct mlxsw_sp *mlxsw_sp,
                               struct mlxsw_sp_bridge_port *bridge_port,
                               u16 fid_index)
{
        bool lagged = bridge_port->lagged;
        char sfdf_pl[MLXSW_REG_SFDF_LEN];
        u16 system_port;

        system_port = lagged ? bridge_port->lag_id : bridge_port->system_port;
        mlxsw_reg_sfdf_pack(sfdf_pl, mlxsw_sp_fdb_flush_type(lagged));
        mlxsw_reg_sfdf_fid_set(sfdf_pl, fid_index);
        mlxsw_reg_sfdf_port_fid_system_port_set(sfdf_pl, system_port);

        return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfdf), sfdf_pl);
}

static enum mlxsw_reg_sfd_rec_policy mlxsw_sp_sfd_rec_policy(bool dynamic)
{
        return dynamic ? MLXSW_REG_SFD_REC_POLICY_DYNAMIC_ENTRY_INGRESS :
                         MLXSW_REG_SFD_REC_POLICY_DYNAMIC_ENTRY_MLAG;
}

static enum mlxsw_reg_sfd_op mlxsw_sp_sfd_op(bool adding)
{
        return adding ? MLXSW_REG_SFD_OP_WRITE_EDIT :
                        MLXSW_REG_SFD_OP_WRITE_REMOVE;
}

static int mlxsw_sp_port_fdb_tunnel_uc_op(struct mlxsw_sp *mlxsw_sp,
                                          const char *mac, u16 fid,
                                          enum mlxsw_sp_l3proto proto,
                                          const union mlxsw_sp_l3addr *addr,
                                          bool adding, bool dynamic)
{
        enum mlxsw_reg_sfd_uc_tunnel_protocol sfd_proto;
        char *sfd_pl;
        u8 num_rec;
        u32 uip;
        int err;

        switch (proto) {
        case MLXSW_SP_L3_PROTO_IPV4:
                uip = be32_to_cpu(addr->addr4);
                sfd_proto = MLXSW_REG_SFD_UC_TUNNEL_PROTOCOL_IPV4;
                break;
        case MLXSW_SP_L3_PROTO_IPV6:
        default:
                WARN_ON(1);
                return -EOPNOTSUPP;
        }

        sfd_pl = kmalloc(MLXSW_REG_SFD_LEN, GFP_KERNEL);
        if (!sfd_pl)
                return -ENOMEM;

        mlxsw_reg_sfd_pack(sfd_pl, mlxsw_sp_sfd_op(adding), 0);
        mlxsw_reg_sfd_uc_tunnel_pack(sfd_pl, 0,
                                     mlxsw_sp_sfd_rec_policy(dynamic), mac, fid,
                                     MLXSW_REG_SFD_REC_ACTION_NOP, uip,
                                     sfd_proto);
        num_rec = mlxsw_reg_sfd_num_rec_get(sfd_pl);
        err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfd), sfd_pl);
        if (err)
                goto out;

        if (num_rec != mlxsw_reg_sfd_num_rec_get(sfd_pl))
                err = -EBUSY;

out:
        kfree(sfd_pl);
        return err;
}

static int __mlxsw_sp_port_fdb_uc_op(struct mlxsw_sp *mlxsw_sp, u8 local_port,
                                     const char *mac, u16 fid, bool adding,
                                     enum mlxsw_reg_sfd_rec_action action,
                                     enum mlxsw_reg_sfd_rec_policy policy)
{
        char *sfd_pl;
        u8 num_rec;
        int err;

        sfd_pl = kmalloc(MLXSW_REG_SFD_LEN, GFP_KERNEL);
        if (!sfd_pl)
                return -ENOMEM;

        mlxsw_reg_sfd_pack(sfd_pl, mlxsw_sp_sfd_op(adding), 0);
        mlxsw_reg_sfd_uc_pack(sfd_pl, 0, policy, mac, fid, action, local_port);
        num_rec = mlxsw_reg_sfd_num_rec_get(sfd_pl);
        err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfd), sfd_pl);
        if (err)
                goto out;

        if (num_rec != mlxsw_reg_sfd_num_rec_get(sfd_pl))
                err = -EBUSY;

out:
        kfree(sfd_pl);
        return err;
}

static int mlxsw_sp_port_fdb_uc_op(struct mlxsw_sp *mlxsw_sp, u8 local_port,
                                   const char *mac, u16 fid, bool adding,
                                   bool dynamic)
{
        return __mlxsw_sp_port_fdb_uc_op(mlxsw_sp, local_port, mac, fid, adding,
                                         MLXSW_REG_SFD_REC_ACTION_NOP,
                                         mlxsw_sp_sfd_rec_policy(dynamic));
}

int mlxsw_sp_rif_fdb_op(struct mlxsw_sp *mlxsw_sp, const char *mac, u16 fid,
                        bool adding)
{
        return __mlxsw_sp_port_fdb_uc_op(mlxsw_sp, 0, mac, fid, adding,
                                         MLXSW_REG_SFD_REC_ACTION_FORWARD_IP_ROUTER,
                                         MLXSW_REG_SFD_REC_POLICY_STATIC_ENTRY);
}

static int mlxsw_sp_port_fdb_uc_lag_op(struct mlxsw_sp *mlxsw_sp, u16 lag_id,
                                       const char *mac, u16 fid, u16 lag_vid,
                                       bool adding, bool dynamic)
{
        char *sfd_pl;
        u8 num_rec;
        int err;

        sfd_pl = kmalloc(MLXSW_REG_SFD_LEN, GFP_KERNEL);
        if (!sfd_pl)
                return -ENOMEM;

        mlxsw_reg_sfd_pack(sfd_pl, mlxsw_sp_sfd_op(adding), 0);
        mlxsw_reg_sfd_uc_lag_pack(sfd_pl, 0, mlxsw_sp_sfd_rec_policy(dynamic),
                                  mac, fid, MLXSW_REG_SFD_REC_ACTION_NOP,
                                  lag_vid, lag_id);
        num_rec = mlxsw_reg_sfd_num_rec_get(sfd_pl);
        err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfd), sfd_pl);
        if (err)
                goto out;

        if (num_rec != mlxsw_reg_sfd_num_rec_get(sfd_pl))
                err = -EBUSY;

out:
        kfree(sfd_pl);
        return err;
}

static int
mlxsw_sp_port_fdb_set(struct mlxsw_sp_port *mlxsw_sp_port,
                      struct switchdev_notifier_fdb_info *fdb_info, bool adding)
{
        struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
        struct net_device *orig_dev = fdb_info->info.dev;
        struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
        struct mlxsw_sp_bridge_device *bridge_device;
        struct mlxsw_sp_bridge_port *bridge_port;
        u16 fid_index, vid;

        bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp->bridge, orig_dev);
        if (!bridge_port)
                return -EINVAL;

        bridge_device = bridge_port->bridge_device;
        mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_bridge(mlxsw_sp_port,
                                                               bridge_device,
                                                               fdb_info->vid);
        if (!mlxsw_sp_port_vlan)
                return 0;

        fid_index = mlxsw_sp_fid_index(mlxsw_sp_port_vlan->fid);
        vid = mlxsw_sp_port_vlan->vid;

        if (!bridge_port->lagged)
                return mlxsw_sp_port_fdb_uc_op(mlxsw_sp,
                                               bridge_port->system_port,
                                               fdb_info->addr, fid_index,
                                               adding, false);
        else
                return mlxsw_sp_port_fdb_uc_lag_op(mlxsw_sp,
                                                   bridge_port->lag_id,
                                                   fdb_info->addr, fid_index,
                                                   vid, adding, false);
}

static int mlxsw_sp_port_mdb_op(struct mlxsw_sp *mlxsw_sp, const char *addr,
                                u16 fid, u16 mid_idx, bool adding)
{
        char *sfd_pl;
        u8 num_rec;
        int err;

        sfd_pl = kmalloc(MLXSW_REG_SFD_LEN, GFP_KERNEL);
        if (!sfd_pl)
                return -ENOMEM;

        mlxsw_reg_sfd_pack(sfd_pl, mlxsw_sp_sfd_op(adding), 0);
        mlxsw_reg_sfd_mc_pack(sfd_pl, 0, addr, fid,
                              MLXSW_REG_SFD_REC_ACTION_NOP, mid_idx);
        num_rec = mlxsw_reg_sfd_num_rec_get(sfd_pl);
        err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfd), sfd_pl);
        if (err)
                goto out;

        if (num_rec != mlxsw_reg_sfd_num_rec_get(sfd_pl))
                err = -EBUSY;

out:
        kfree(sfd_pl);
        return err;
}

static int mlxsw_sp_port_smid_full_entry(struct mlxsw_sp *mlxsw_sp, u16 mid_idx,
                                         long *ports_bitmap,
                                         bool set_router_port)
{
        char *smid_pl;
        int err, i;

        smid_pl = kmalloc(MLXSW_REG_SMID_LEN, GFP_KERNEL);
        if (!smid_pl)
                return -ENOMEM;

        mlxsw_reg_smid_pack(smid_pl, mid_idx, 0, false);
        for (i = 1; i < mlxsw_core_max_ports(mlxsw_sp->core); i++) {
                if (mlxsw_sp->ports[i])
                        mlxsw_reg_smid_port_mask_set(smid_pl, i, 1);
        }

        mlxsw_reg_smid_port_mask_set(smid_pl,
                                     mlxsw_sp_router_port(mlxsw_sp), 1);

        for_each_set_bit(i, ports_bitmap, mlxsw_core_max_ports(mlxsw_sp->core))
                mlxsw_reg_smid_port_set(smid_pl, i, 1);

        mlxsw_reg_smid_port_set(smid_pl, mlxsw_sp_router_port(mlxsw_sp),
                                set_router_port);

        err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(smid), smid_pl);
        kfree(smid_pl);
        return err;
}

static int mlxsw_sp_port_smid_set(struct mlxsw_sp_port *mlxsw_sp_port,
                                  u16 mid_idx, bool add)
{
        struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
        char *smid_pl;
        int err;

        smid_pl = kmalloc(MLXSW_REG_SMID_LEN, GFP_KERNEL);
        if (!smid_pl)
                return -ENOMEM;

        mlxsw_reg_smid_pack(smid_pl, mid_idx, mlxsw_sp_port->local_port, add);
        err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(smid), smid_pl);
        kfree(smid_pl);
        return err;
}

static struct
mlxsw_sp_mid *__mlxsw_sp_mc_get(struct mlxsw_sp_bridge_device *bridge_device,
                                const unsigned char *addr,
                                u16 fid)
{
        struct mlxsw_sp_mid *mid;

        list_for_each_entry(mid, &bridge_device->mids_list, list) {
                if (ether_addr_equal(mid->addr, addr) && mid->fid == fid)
                        return mid;
        }
        return NULL;
}

static void
mlxsw_sp_bridge_port_get_ports_bitmap(struct mlxsw_sp *mlxsw_sp,
                                      struct mlxsw_sp_bridge_port *bridge_port,
                                      unsigned long *ports_bitmap)
{
        struct mlxsw_sp_port *mlxsw_sp_port;
        u64 max_lag_members, i;
        int lag_id;

        if (!bridge_port->lagged) {
                set_bit(bridge_port->system_port, ports_bitmap);
        } else {
                max_lag_members = MLXSW_CORE_RES_GET(mlxsw_sp->core,
                                                     MAX_LAG_MEMBERS);
                lag_id = bridge_port->lag_id;
                for (i = 0; i < max_lag_members; i++) {
                        mlxsw_sp_port = mlxsw_sp_port_lagged_get(mlxsw_sp,
                                                                 lag_id, i);
                        if (mlxsw_sp_port)
                                set_bit(mlxsw_sp_port->local_port,
                                        ports_bitmap);
                }
        }
}

static void
mlxsw_sp_mc_get_mrouters_bitmap(unsigned long *flood_bitmap,
                                struct mlxsw_sp_bridge_device *bridge_device,
                                struct mlxsw_sp *mlxsw_sp)
{
        struct mlxsw_sp_bridge_port *bridge_port;

        list_for_each_entry(bridge_port, &bridge_device->ports_list, list) {
                if (bridge_port->mrouter) {
                        mlxsw_sp_bridge_port_get_ports_bitmap(mlxsw_sp,
                                                              bridge_port,
                                                              flood_bitmap);
                }
        }
}

static bool
mlxsw_sp_mc_write_mdb_entry(struct mlxsw_sp *mlxsw_sp,
                            struct mlxsw_sp_mid *mid,
                            struct mlxsw_sp_bridge_device *bridge_device)
{
        long *flood_bitmap;
        int num_of_ports;
        u16 mid_idx;
        int err;

        mid_idx = find_first_zero_bit(mlxsw_sp->bridge->mids_bitmap,
                                      MLXSW_SP_MID_MAX);
        if (mid_idx == MLXSW_SP_MID_MAX)
                return false;

        num_of_ports = mlxsw_core_max_ports(mlxsw_sp->core);
        flood_bitmap = bitmap_alloc(num_of_ports, GFP_KERNEL);
        if (!flood_bitmap)
                return false;

        bitmap_copy(flood_bitmap, mid->ports_in_mid, num_of_ports);
        mlxsw_sp_mc_get_mrouters_bitmap(flood_bitmap, bridge_device, mlxsw_sp);

        mid->mid = mid_idx;
        err = mlxsw_sp_port_smid_full_entry(mlxsw_sp, mid_idx, flood_bitmap,
                                            bridge_device->mrouter);
        bitmap_free(flood_bitmap);
        if (err)
                return false;

        err = mlxsw_sp_port_mdb_op(mlxsw_sp, mid->addr, mid->fid, mid_idx,
                                   true);
        if (err)
                return false;

        set_bit(mid_idx, mlxsw_sp->bridge->mids_bitmap);
        mid->in_hw = true;
        return true;
}

static int mlxsw_sp_mc_remove_mdb_entry(struct mlxsw_sp *mlxsw_sp,
                                        struct mlxsw_sp_mid *mid)
{
        if (!mid->in_hw)
                return 0;

        clear_bit(mid->mid, mlxsw_sp->bridge->mids_bitmap);
        mid->in_hw = false;
        return mlxsw_sp_port_mdb_op(mlxsw_sp, mid->addr, mid->fid, mid->mid,
                                    false);
}

static struct
mlxsw_sp_mid *__mlxsw_sp_mc_alloc(struct mlxsw_sp *mlxsw_sp,
                                  struct mlxsw_sp_bridge_device *bridge_device,
                                  const unsigned char *addr,
                                  u16 fid)
{
        struct mlxsw_sp_mid *mid;
        size_t alloc_size;

        mid = kzalloc(sizeof(*mid), GFP_KERNEL);
        if (!mid)
                return NULL;

        alloc_size = sizeof(unsigned long) *
                     BITS_TO_LONGS(mlxsw_core_max_ports(mlxsw_sp->core));

        mid->ports_in_mid = kzalloc(alloc_size, GFP_KERNEL);
        if (!mid->ports_in_mid)
                goto err_ports_in_mid_alloc;

        ether_addr_copy(mid->addr, addr);
        mid->fid = fid;
        mid->in_hw = false;

        if (!bridge_device->multicast_enabled)
                goto out;

        if (!mlxsw_sp_mc_write_mdb_entry(mlxsw_sp, mid, bridge_device))
                goto err_write_mdb_entry;

out:
        list_add_tail(&mid->list, &bridge_device->mids_list);
        return mid;

err_write_mdb_entry:
        kfree(mid->ports_in_mid);
err_ports_in_mid_alloc:
        kfree(mid);
        return NULL;
}

static int mlxsw_sp_port_remove_from_mid(struct mlxsw_sp_port *mlxsw_sp_port,
                                         struct mlxsw_sp_mid *mid)
{
        struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
        int err = 0;

        clear_bit(mlxsw_sp_port->local_port, mid->ports_in_mid);
        if (bitmap_empty(mid->ports_in_mid,
                         mlxsw_core_max_ports(mlxsw_sp->core))) {
                err = mlxsw_sp_mc_remove_mdb_entry(mlxsw_sp, mid);
                list_del(&mid->list);
                kfree(mid->ports_in_mid);
                kfree(mid);
        }
        return err;
}

static int mlxsw_sp_port_mdb_add(struct mlxsw_sp_port *mlxsw_sp_port,
                                 const struct switchdev_obj_port_mdb *mdb)
{
        struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
        struct net_device *orig_dev = mdb->obj.orig_dev;
        struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
        struct net_device *dev = mlxsw_sp_port->dev;
        struct mlxsw_sp_bridge_device *bridge_device;
        struct mlxsw_sp_bridge_port *bridge_port;
        struct mlxsw_sp_mid *mid;
        u16 fid_index;
        int err = 0;

        bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp->bridge, orig_dev);
        if (!bridge_port)
                return 0;

        bridge_device = bridge_port->bridge_device;
        mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_bridge(mlxsw_sp_port,
                                                               bridge_device,
                                                               mdb->vid);
        if (!mlxsw_sp_port_vlan)
                return 0;

        fid_index = mlxsw_sp_fid_index(mlxsw_sp_port_vlan->fid);

        mid = __mlxsw_sp_mc_get(bridge_device, mdb->addr, fid_index);
        if (!mid) {
                mid = __mlxsw_sp_mc_alloc(mlxsw_sp, bridge_device, mdb->addr,
                                          fid_index);
                if (!mid) {
                        netdev_err(dev, "Unable to allocate MC group\n");
                        return -ENOMEM;
                }
        }
        set_bit(mlxsw_sp_port->local_port, mid->ports_in_mid);

        if (!bridge_device->multicast_enabled)
                return 0;

        if (bridge_port->mrouter)
                return 0;

        err = mlxsw_sp_port_smid_set(mlxsw_sp_port, mid->mid, true);
        if (err) {
                netdev_err(dev, "Unable to set SMID\n");
                goto err_out;
        }

        return 0;

err_out:
        mlxsw_sp_port_remove_from_mid(mlxsw_sp_port, mid);
        return err;
}

static void
mlxsw_sp_bridge_mdb_mc_enable_sync(struct mlxsw_sp_port *mlxsw_sp_port,
                                   struct mlxsw_sp_bridge_device
                                   *bridge_device)
{
        struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
        struct mlxsw_sp_mid *mid;
        bool mc_enabled;

        mc_enabled = bridge_device->multicast_enabled;

        list_for_each_entry(mid, &bridge_device->mids_list, list) {
                if (mc_enabled)
                        mlxsw_sp_mc_write_mdb_entry(mlxsw_sp, mid,
                                                    bridge_device);
                else
                        mlxsw_sp_mc_remove_mdb_entry(mlxsw_sp, mid);
        }
}

static void
mlxsw_sp_port_mrouter_update_mdb(struct mlxsw_sp_port *mlxsw_sp_port,
                                 struct mlxsw_sp_bridge_port *bridge_port,
                                 bool add)
{
        struct mlxsw_sp_bridge_device *bridge_device;
        struct mlxsw_sp_mid *mid;

        bridge_device = bridge_port->bridge_device;

        list_for_each_entry(mid, &bridge_device->mids_list, list) {
                if (!test_bit(mlxsw_sp_port->local_port, mid->ports_in_mid))
                        mlxsw_sp_port_smid_set(mlxsw_sp_port, mid->mid, add);
        }
}

static int mlxsw_sp_port_obj_add(struct net_device *dev, const void *ctx,
                                 const struct switchdev_obj *obj,
                                 struct netlink_ext_ack *extack)
{
        struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
        const struct switchdev_obj_port_vlan *vlan;
        int err = 0;

        switch (obj->id) {
        case SWITCHDEV_OBJ_ID_PORT_VLAN:
                vlan = SWITCHDEV_OBJ_PORT_VLAN(obj);

                err = mlxsw_sp_port_vlans_add(mlxsw_sp_port, vlan, extack);

                /* The event is emitted before the changes are actually
                 * applied to the bridge. Therefore schedule the respin
                 * call for later, so that the respin logic sees the
                 * updated bridge state.
                 */
                mlxsw_sp_span_respin(mlxsw_sp_port->mlxsw_sp);
                break;
        case SWITCHDEV_OBJ_ID_PORT_MDB:
                err = mlxsw_sp_port_mdb_add(mlxsw_sp_port,
                                            SWITCHDEV_OBJ_PORT_MDB(obj));
                break;
        default:
                err = -EOPNOTSUPP;
                break;
        }

        return err;
}

static void
mlxsw_sp_bridge_port_vlan_del(struct mlxsw_sp_port *mlxsw_sp_port,
                              struct mlxsw_sp_bridge_port *bridge_port, u16 vid)
{
        u16 pvid = mlxsw_sp_port->pvid == vid ? 0 : mlxsw_sp_port->pvid;
        struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
        u16 proto;

        mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_vid(mlxsw_sp_port, vid);
        if (WARN_ON(!mlxsw_sp_port_vlan))
                return;

        mlxsw_sp_port_vlan_bridge_leave(mlxsw_sp_port_vlan);
        br_vlan_get_proto(bridge_port->bridge_device->dev, &proto);
        mlxsw_sp_port_pvid_set(mlxsw_sp_port, pvid, proto);
        mlxsw_sp_port_vlan_set(mlxsw_sp_port, vid, vid, false, false);
        mlxsw_sp_port_vlan_destroy(mlxsw_sp_port_vlan);
}

static int mlxsw_sp_port_vlans_del(struct mlxsw_sp_port *mlxsw_sp_port,
                                   const struct switchdev_obj_port_vlan *vlan)
{
        struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
        struct net_device *orig_dev = vlan->obj.orig_dev;
        struct mlxsw_sp_bridge_port *bridge_port;

        if (netif_is_bridge_master(orig_dev))
                return -EOPNOTSUPP;

        bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp->bridge, orig_dev);
        if (WARN_ON(!bridge_port))
                return -EINVAL;

        if (!bridge_port->bridge_device->vlan_enabled)
                return 0;

        mlxsw_sp_bridge_port_vlan_del(mlxsw_sp_port, bridge_port, vlan->vid);

        return 0;
}

static int
__mlxsw_sp_port_mdb_del(struct mlxsw_sp_port *mlxsw_sp_port,
                        struct mlxsw_sp_bridge_port *bridge_port,
                        struct mlxsw_sp_mid *mid)
{
        struct net_device *dev = mlxsw_sp_port->dev;
        int err;

        if (bridge_port->bridge_device->multicast_enabled &&
            !bridge_port->mrouter) {
                err = mlxsw_sp_port_smid_set(mlxsw_sp_port, mid->mid, false);
                if (err)
                        netdev_err(dev, "Unable to remove port from SMID\n");
        }

        err = mlxsw_sp_port_remove_from_mid(mlxsw_sp_port, mid);
        if (err)
                netdev_err(dev, "Unable to remove MC SFD\n");

        return err;
}

static int mlxsw_sp_port_mdb_del(struct mlxsw_sp_port *mlxsw_sp_port,
                                 const struct switchdev_obj_port_mdb *mdb)
{
        struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
        struct net_device *orig_dev = mdb->obj.orig_dev;
        struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
        struct mlxsw_sp_bridge_device *bridge_device;
        struct net_device *dev = mlxsw_sp_port->dev;
        struct mlxsw_sp_bridge_port *bridge_port;
        struct mlxsw_sp_mid *mid;
        u16 fid_index;

        bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp->bridge, orig_dev);
        if (!bridge_port)
                return 0;

        bridge_device = bridge_port->bridge_device;
        mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_bridge(mlxsw_sp_port,
                                                               bridge_device,
                                                               mdb->vid);
        if (!mlxsw_sp_port_vlan)
                return 0;

        fid_index = mlxsw_sp_fid_index(mlxsw_sp_port_vlan->fid);

        mid = __mlxsw_sp_mc_get(bridge_device, mdb->addr, fid_index);
        if (!mid) {
                netdev_err(dev, "Unable to remove port from MC DB\n");
                return -EINVAL;
        }

        return __mlxsw_sp_port_mdb_del(mlxsw_sp_port, bridge_port, mid);
}

static void
mlxsw_sp_bridge_port_mdb_flush(struct mlxsw_sp_port *mlxsw_sp_port,
                               struct mlxsw_sp_bridge_port *bridge_port)
{
        struct mlxsw_sp_bridge_device *bridge_device;
        struct mlxsw_sp_mid *mid, *tmp;

        bridge_device = bridge_port->bridge_device;

        list_for_each_entry_safe(mid, tmp, &bridge_device->mids_list, list) {
                if (test_bit(mlxsw_sp_port->local_port, mid->ports_in_mid)) {
                        __mlxsw_sp_port_mdb_del(mlxsw_sp_port, bridge_port,
                                                mid);
                } else if (bridge_device->multicast_enabled &&
                           bridge_port->mrouter) {
                        mlxsw_sp_port_smid_set(mlxsw_sp_port, mid->mid, false);
                }
        }
}

static int mlxsw_sp_port_obj_del(struct net_device *dev, const void *ctx,
                                 const struct switchdev_obj *obj)
{
        struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
        int err = 0;

        switch (obj->id) {
        case SWITCHDEV_OBJ_ID_PORT_VLAN:
                err = mlxsw_sp_port_vlans_del(mlxsw_sp_port,
                                              SWITCHDEV_OBJ_PORT_VLAN(obj));
                break;
        case SWITCHDEV_OBJ_ID_PORT_MDB:
                err = mlxsw_sp_port_mdb_del(mlxsw_sp_port,
                                            SWITCHDEV_OBJ_PORT_MDB(obj));
                break;
        default:
                err = -EOPNOTSUPP;
                break;
        }

        mlxsw_sp_span_respin(mlxsw_sp_port->mlxsw_sp);

        return err;
}

static struct mlxsw_sp_port *mlxsw_sp_lag_rep_port(struct mlxsw_sp *mlxsw_sp,
                                                   u16 lag_id)
{
        struct mlxsw_sp_port *mlxsw_sp_port;
        u64 max_lag_members;
        int i;

        max_lag_members = MLXSW_CORE_RES_GET(mlxsw_sp->core,
                                             MAX_LAG_MEMBERS);
        for (i = 0; i < max_lag_members; i++) {
                mlxsw_sp_port = mlxsw_sp_port_lagged_get(mlxsw_sp, lag_id, i);
                if (mlxsw_sp_port)
                        return mlxsw_sp_port;
        }
        return NULL;
}

static int
mlxsw_sp_bridge_vlan_aware_port_join(struct mlxsw_sp_bridge_port *bridge_port,
                                     struct mlxsw_sp_port *mlxsw_sp_port,
                                     struct netlink_ext_ack *extack)
{
        if (is_vlan_dev(bridge_port->dev)) {
                NL_SET_ERR_MSG_MOD(extack, "Can not enslave a VLAN device to a VLAN-aware bridge");
                return -EINVAL;
        }

        /* Port is no longer usable as a router interface */
        if (mlxsw_sp_port->default_vlan->fid)
                mlxsw_sp_port_vlan_router_leave(mlxsw_sp_port->default_vlan);

        return 0;
}

static int
mlxsw_sp_bridge_8021q_port_join(struct mlxsw_sp_bridge_device *bridge_device,
                                struct mlxsw_sp_bridge_port *bridge_port,
                                struct mlxsw_sp_port *mlxsw_sp_port,
                                struct netlink_ext_ack *extack)
{
        return mlxsw_sp_bridge_vlan_aware_port_join(bridge_port, mlxsw_sp_port,
                                                    extack);
}

static void

mlxsw_sp_bridge_vlan_aware_port_leave(struct mlxsw_sp_port *mlxsw_sp_port)
{
        /* Make sure untagged frames are allowed to ingress */
        mlxsw_sp_port_pvid_set(mlxsw_sp_port, MLXSW_SP_DEFAULT_VID,
                               ETH_P_8021Q);
}

static void
mlxsw_sp_bridge_8021q_port_leave(struct mlxsw_sp_bridge_device *bridge_device,
                                 struct mlxsw_sp_bridge_port *bridge_port,
                                 struct mlxsw_sp_port *mlxsw_sp_port)
{
        mlxsw_sp_bridge_vlan_aware_port_leave(mlxsw_sp_port);
}

static int
mlxsw_sp_bridge_vlan_aware_vxlan_join(struct mlxsw_sp_bridge_device *bridge_device,
                                      const struct net_device *vxlan_dev,
                                      u16 vid, u16 ethertype,
                                      struct netlink_ext_ack *extack)
{
        struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_device->dev);
        struct vxlan_dev *vxlan = netdev_priv(vxlan_dev);
        struct mlxsw_sp_nve_params params = {
                .type = MLXSW_SP_NVE_TYPE_VXLAN,
                .vni = vxlan->cfg.vni,
                .dev = vxlan_dev,
                .ethertype = ethertype,
        };
        struct mlxsw_sp_fid *fid;
        int err;

        /* If the VLAN is 0, we need to find the VLAN that is configured as
         * PVID and egress untagged on the bridge port of the VxLAN device.
         * It is possible no such VLAN exists
         */
        if (!vid) {
                err = mlxsw_sp_vxlan_mapped_vid(vxlan_dev, &vid);
                if (err || !vid)
                        return err;
        }

        fid = mlxsw_sp_fid_8021q_get(mlxsw_sp, vid);
        if (IS_ERR(fid)) {
                NL_SET_ERR_MSG_MOD(extack, "Failed to create 802.1Q FID");
                return PTR_ERR(fid);
        }

        if (mlxsw_sp_fid_vni_is_set(fid)) {
                NL_SET_ERR_MSG_MOD(extack, "VNI is already set on FID");
                err = -EINVAL;
                goto err_vni_exists;
        }

        err = mlxsw_sp_nve_fid_enable(mlxsw_sp, fid, &params, extack);
        if (err)
                goto err_nve_fid_enable;

        return 0;

err_nve_fid_enable:
err_vni_exists:
        mlxsw_sp_fid_put(fid);
        return err;
}

static int
mlxsw_sp_bridge_8021q_vxlan_join(struct mlxsw_sp_bridge_device *bridge_device,
                                 const struct net_device *vxlan_dev, u16 vid,
                                 struct netlink_ext_ack *extack)
{
        return mlxsw_sp_bridge_vlan_aware_vxlan_join(bridge_device, vxlan_dev,
                                                     vid, ETH_P_8021Q, extack);
}

static struct net_device *
mlxsw_sp_bridge_8021q_vxlan_dev_find(struct net_device *br_dev, u16 vid)
{
        struct net_device *dev;
        struct list_head *iter;

        netdev_for_each_lower_dev(br_dev, dev, iter) {
                u16 pvid;
                int err;

                if (!netif_is_vxlan(dev))
                        continue;

                err = mlxsw_sp_vxlan_mapped_vid(dev, &pvid);
                if (err || pvid != vid)
                        continue;

                return dev;
        }

        return NULL;
}

static struct mlxsw_sp_fid *
mlxsw_sp_bridge_8021q_fid_get(struct mlxsw_sp_bridge_device *bridge_device,
                              u16 vid, struct netlink_ext_ack *extack)
{
        struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_device->dev);

        return mlxsw_sp_fid_8021q_get(mlxsw_sp, vid);
}

static struct mlxsw_sp_fid *
mlxsw_sp_bridge_8021q_fid_lookup(struct mlxsw_sp_bridge_device *bridge_device,
                                 u16 vid)
{
        struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_device->dev);

        return mlxsw_sp_fid_8021q_lookup(mlxsw_sp, vid);
}

static u16
mlxsw_sp_bridge_8021q_fid_vid(struct mlxsw_sp_bridge_device *bridge_device,
                              const struct mlxsw_sp_fid *fid)
{
        return mlxsw_sp_fid_8021q_vid(fid);
}

static const struct mlxsw_sp_bridge_ops mlxsw_sp_bridge_8021q_ops = {
        .port_join      = mlxsw_sp_bridge_8021q_port_join,
        .port_leave     = mlxsw_sp_bridge_8021q_port_leave,
        .vxlan_join     = mlxsw_sp_bridge_8021q_vxlan_join,
        .fid_get        = mlxsw_sp_bridge_8021q_fid_get,
        .fid_lookup     = mlxsw_sp_bridge_8021q_fid_lookup,
        .fid_vid        = mlxsw_sp_bridge_8021q_fid_vid,
};

static bool
mlxsw_sp_port_is_br_member(const struct mlxsw_sp_port *mlxsw_sp_port,
                           const struct net_device *br_dev)
{
        struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;

        list_for_each_entry(mlxsw_sp_port_vlan, &mlxsw_sp_port->vlans_list,
                            list) {
                if (mlxsw_sp_port_vlan->bridge_port &&
                    mlxsw_sp_port_vlan->bridge_port->bridge_device->dev ==
                    br_dev)
                        return true;
        }

        return false;
}

static int
mlxsw_sp_bridge_8021d_port_join(struct mlxsw_sp_bridge_device *bridge_device,
                                struct mlxsw_sp_bridge_port *bridge_port,
                                struct mlxsw_sp_port *mlxsw_sp_port,
                                struct netlink_ext_ack *extack)
{
        struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
        struct net_device *dev = bridge_port->dev;
        u16 vid;

        vid = is_vlan_dev(dev) ? vlan_dev_vlan_id(dev) : MLXSW_SP_DEFAULT_VID;
        mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_vid(mlxsw_sp_port, vid);
        if (WARN_ON(!mlxsw_sp_port_vlan))
                return -EINVAL;

        if (mlxsw_sp_port_is_br_member(mlxsw_sp_port, bridge_device->dev)) {
                NL_SET_ERR_MSG_MOD(extack, "Can not bridge VLAN uppers of the same port");
                return -EINVAL;
        }

        /* Port is no longer usable as a router interface */
        if (mlxsw_sp_port_vlan->fid)
                mlxsw_sp_port_vlan_router_leave(mlxsw_sp_port_vlan);

        return mlxsw_sp_port_vlan_bridge_join(mlxsw_sp_port_vlan, bridge_port,
                                              extack);
}

static void
mlxsw_sp_bridge_8021d_port_leave(struct mlxsw_sp_bridge_device *bridge_device,
                                 struct mlxsw_sp_bridge_port *bridge_port,
                                 struct mlxsw_sp_port *mlxsw_sp_port)
{
        struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
        struct net_device *dev = bridge_port->dev;
        u16 vid;

        vid = is_vlan_dev(dev) ? vlan_dev_vlan_id(dev) : MLXSW_SP_DEFAULT_VID;
        mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_vid(mlxsw_sp_port, vid);
        if (!mlxsw_sp_port_vlan || !mlxsw_sp_port_vlan->bridge_port)
                return;

        mlxsw_sp_port_vlan_bridge_leave(mlxsw_sp_port_vlan);
}

static int
mlxsw_sp_bridge_8021d_vxlan_join(struct mlxsw_sp_bridge_device *bridge_device,
                                 const struct net_device *vxlan_dev, u16 vid,
                                 struct netlink_ext_ack *extack)
{
        struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_device->dev);
        struct vxlan_dev *vxlan = netdev_priv(vxlan_dev);
        struct mlxsw_sp_nve_params params = {
                .type = MLXSW_SP_NVE_TYPE_VXLAN,
                .vni = vxlan->cfg.vni,
                .dev = vxlan_dev,
                .ethertype = ETH_P_8021Q,
        };
        struct mlxsw_sp_fid *fid;
        int err;

        fid = mlxsw_sp_fid_8021d_get(mlxsw_sp, bridge_device->dev->ifindex);
        if (IS_ERR(fid)) {
                NL_SET_ERR_MSG_MOD(extack, "Failed to create 802.1D FID");
                return -EINVAL;
        }

        if (mlxsw_sp_fid_vni_is_set(fid)) {
                NL_SET_ERR_MSG_MOD(extack, "VNI is already set on FID");
                err = -EINVAL;
                goto err_vni_exists;
        }

        err = mlxsw_sp_nve_fid_enable(mlxsw_sp, fid, &params, extack);
        if (err)
                goto err_nve_fid_enable;

        return 0;

err_nve_fid_enable:
err_vni_exists:
        mlxsw_sp_fid_put(fid);
        return err;
}

static struct mlxsw_sp_fid *
mlxsw_sp_bridge_8021d_fid_get(struct mlxsw_sp_bridge_device *bridge_device,
                              u16 vid, struct netlink_ext_ack *extack)
{
        struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_device->dev);

        return mlxsw_sp_fid_8021d_get(mlxsw_sp, bridge_device->dev->ifindex);
}

static struct mlxsw_sp_fid *
mlxsw_sp_bridge_8021d_fid_lookup(struct mlxsw_sp_bridge_device *bridge_device,
                                 u16 vid)
{
        struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_device->dev);

        /* The only valid VLAN for a VLAN-unaware bridge is 0 */
        if (vid)
                return NULL;

        return mlxsw_sp_fid_8021d_lookup(mlxsw_sp, bridge_device->dev->ifindex);
}

static u16
mlxsw_sp_bridge_8021d_fid_vid(struct mlxsw_sp_bridge_device *bridge_device,
                              const struct mlxsw_sp_fid *fid)
{
        return 0;
}

static const struct mlxsw_sp_bridge_ops mlxsw_sp_bridge_8021d_ops = {
        .port_join      = mlxsw_sp_bridge_8021d_port_join,
        .port_leave     = mlxsw_sp_bridge_8021d_port_leave,
        .vxlan_join     = mlxsw_sp_bridge_8021d_vxlan_join,
        .fid_get        = mlxsw_sp_bridge_8021d_fid_get,
        .fid_lookup     = mlxsw_sp_bridge_8021d_fid_lookup,
        .fid_vid        = mlxsw_sp_bridge_8021d_fid_vid,
};

static int
mlxsw_sp_bridge_8021ad_port_join(struct mlxsw_sp_bridge_device *bridge_device,
                                 struct mlxsw_sp_bridge_port *bridge_port,
                                 struct mlxsw_sp_port *mlxsw_sp_port,
                                 struct netlink_ext_ack *extack)
{
        int err;

        err = mlxsw_sp_port_vlan_classification_set(mlxsw_sp_port, true, false);
        if (err)
                return err;

        err = mlxsw_sp_bridge_vlan_aware_port_join(bridge_port, mlxsw_sp_port,
                                                   extack);
        if (err)
                goto err_bridge_vlan_aware_port_join;

        return 0;

err_bridge_vlan_aware_port_join:
        mlxsw_sp_port_vlan_classification_set(mlxsw_sp_port, false, true);
        return err;
}

static void
mlxsw_sp_bridge_8021ad_port_leave(struct mlxsw_sp_bridge_device *bridge_device,
                                  struct mlxsw_sp_bridge_port *bridge_port,
                                  struct mlxsw_sp_port *mlxsw_sp_port)
{
        mlxsw_sp_bridge_vlan_aware_port_leave(mlxsw_sp_port);
        mlxsw_sp_port_vlan_classification_set(mlxsw_sp_port, false, true);
}

static int
mlxsw_sp_bridge_8021ad_vxlan_join(struct mlxsw_sp_bridge_device *bridge_device,
                                  const struct net_device *vxlan_dev, u16 vid,
                                  struct netlink_ext_ack *extack)
{
        return mlxsw_sp_bridge_vlan_aware_vxlan_join(bridge_device, vxlan_dev,
                                                     vid, ETH_P_8021AD, extack);
}

static const struct mlxsw_sp_bridge_ops mlxsw_sp1_bridge_8021ad_ops = {
        .port_join      = mlxsw_sp_bridge_8021ad_port_join,
        .port_leave     = mlxsw_sp_bridge_8021ad_port_leave,
        .vxlan_join     = mlxsw_sp_bridge_8021ad_vxlan_join,
        .fid_get        = mlxsw_sp_bridge_8021q_fid_get,
        .fid_lookup     = mlxsw_sp_bridge_8021q_fid_lookup,
        .fid_vid        = mlxsw_sp_bridge_8021q_fid_vid,
};

static int
mlxsw_sp2_bridge_8021ad_port_join(struct mlxsw_sp_bridge_device *bridge_device,
                                  struct mlxsw_sp_bridge_port *bridge_port,
                                  struct mlxsw_sp_port *mlxsw_sp_port,
                                  struct netlink_ext_ack *extack)
{
        int err;

        /* The EtherType of decapsulated packets is determined at the egress
         * port to allow 802.1d and 802.1ad bridges with VXLAN devices to
         * co-exist.
         */
        err = mlxsw_sp_port_egress_ethtype_set(mlxsw_sp_port, ETH_P_8021AD);
        if (err)
                return err;

        err = mlxsw_sp_bridge_8021ad_port_join(bridge_device, bridge_port,
                                               mlxsw_sp_port, extack);
        if (err)
                goto err_bridge_8021ad_port_join;

        return 0;

err_bridge_8021ad_port_join:
        mlxsw_sp_port_egress_ethtype_set(mlxsw_sp_port, ETH_P_8021Q);
        return err;
}

static void
mlxsw_sp2_bridge_8021ad_port_leave(struct mlxsw_sp_bridge_device *bridge_device,
                                   struct mlxsw_sp_bridge_port *bridge_port,
                                   struct mlxsw_sp_port *mlxsw_sp_port)
{
        mlxsw_sp_bridge_8021ad_port_leave(bridge_device, bridge_port,
                                          mlxsw_sp_port);
        mlxsw_sp_port_egress_ethtype_set(mlxsw_sp_port, ETH_P_8021Q);
}

static const struct mlxsw_sp_bridge_ops mlxsw_sp2_bridge_8021ad_ops = {
        .port_join      = mlxsw_sp2_bridge_8021ad_port_join,
        .port_leave     = mlxsw_sp2_bridge_8021ad_port_leave,
        .vxlan_join     = mlxsw_sp_bridge_8021ad_vxlan_join,
        .fid_get        = mlxsw_sp_bridge_8021q_fid_get,
        .fid_lookup     = mlxsw_sp_bridge_8021q_fid_lookup,
        .fid_vid        = mlxsw_sp_bridge_8021q_fid_vid,
};

int mlxsw_sp_port_bridge_join(struct mlxsw_sp_port *mlxsw_sp_port,
                              struct net_device *brport_dev,
                              struct net_device *br_dev,
                              struct netlink_ext_ack *extack)
{
        struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
        struct mlxsw_sp_bridge_device *bridge_device;
        struct mlxsw_sp_bridge_port *bridge_port;
        int err;

        bridge_port = mlxsw_sp_bridge_port_get(mlxsw_sp->bridge, brport_dev,
                                               extack);
        if (IS_ERR(bridge_port))
                return PTR_ERR(bridge_port);
        bridge_device = bridge_port->bridge_device;

        err = bridge_device->ops->port_join(bridge_device, bridge_port,
                                            mlxsw_sp_port, extack);
        if (err)
                goto err_port_join;

        return 0;

err_port_join:
        mlxsw_sp_bridge_port_put(mlxsw_sp->bridge, bridge_port);
        return err;
}

void mlxsw_sp_port_bridge_leave(struct mlxsw_sp_port *mlxsw_sp_port,
                                struct net_device *brport_dev,
                                struct net_device *br_dev)
{
        struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
        struct mlxsw_sp_bridge_device *bridge_device;
        struct mlxsw_sp_bridge_port *bridge_port;

        bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
        if (!bridge_device)
                return;
        bridge_port = __mlxsw_sp_bridge_port_find(bridge_device, brport_dev);
        if (!bridge_port)
                return;

        bridge_device->ops->port_leave(bridge_device, bridge_port,
                                       mlxsw_sp_port);
        mlxsw_sp_bridge_port_put(mlxsw_sp->bridge, bridge_port);
}

int mlxsw_sp_bridge_vxlan_join(struct mlxsw_sp *mlxsw_sp,
                               const struct net_device *br_dev,
                               const struct net_device *vxlan_dev, u16 vid,
                               struct netlink_ext_ack *extack)
{
        struct mlxsw_sp_bridge_device *bridge_device;

        bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
        if (WARN_ON(!bridge_device))
                return -EINVAL;

        return bridge_device->ops->vxlan_join(bridge_device, vxlan_dev, vid,
                                              extack);
}

void mlxsw_sp_bridge_vxlan_leave(struct mlxsw_sp *mlxsw_sp,
                                 const struct net_device *vxlan_dev)
{
        struct vxlan_dev *vxlan = netdev_priv(vxlan_dev);
        struct mlxsw_sp_fid *fid;

        /* If the VxLAN device is down, then the FID does not have a VNI */
        fid = mlxsw_sp_fid_lookup_by_vni(mlxsw_sp, vxlan->cfg.vni);
        if (!fid)
                return;

        mlxsw_sp_nve_fid_disable(mlxsw_sp, fid);
        /* Drop both the reference we just took during lookup and the reference
         * the VXLAN device took.
         */
        mlxsw_sp_fid_put(fid);
        mlxsw_sp_fid_put(fid);
}

static void
mlxsw_sp_switchdev_vxlan_addr_convert(const union vxlan_addr *vxlan_addr,
                                      enum mlxsw_sp_l3proto *proto,
                                      union mlxsw_sp_l3addr *addr)
{
        if (vxlan_addr->sa.sa_family == AF_INET) {
                addr->addr4 = vxlan_addr->sin.sin_addr.s_addr;
                *proto = MLXSW_SP_L3_PROTO_IPV4;
        } else {
                addr->addr6 = vxlan_addr->sin6.sin6_addr;
                *proto = MLXSW_SP_L3_PROTO_IPV6;
        }
}

static void
mlxsw_sp_switchdev_addr_vxlan_convert(enum mlxsw_sp_l3proto proto,
                                      const union mlxsw_sp_l3addr *addr,
                                      union vxlan_addr *vxlan_addr)
{
        switch (proto) {
        case MLXSW_SP_L3_PROTO_IPV4:
                vxlan_addr->sa.sa_family = AF_INET;
                vxlan_addr->sin.sin_addr.s_addr = addr->addr4;
                break;
        case MLXSW_SP_L3_PROTO_IPV6:
                vxlan_addr->sa.sa_family = AF_INET6;
                vxlan_addr->sin6.sin6_addr = addr->addr6;
                break;
        }
}

static void mlxsw_sp_fdb_vxlan_call_notifiers(struct net_device *dev,
                                              const char *mac,
                                              enum mlxsw_sp_l3proto proto,
                                              union mlxsw_sp_l3addr *addr,
                                              __be32 vni, bool adding)
{
        struct switchdev_notifier_vxlan_fdb_info info;
        struct vxlan_dev *vxlan = netdev_priv(dev);
        enum switchdev_notifier_type type;

        type = adding ? SWITCHDEV_VXLAN_FDB_ADD_TO_BRIDGE :
                        SWITCHDEV_VXLAN_FDB_DEL_TO_BRIDGE;
        mlxsw_sp_switchdev_addr_vxlan_convert(proto, addr, &info.remote_ip);
        info.remote_port = vxlan->cfg.dst_port;
        info.remote_vni = vni;
        info.remote_ifindex = 0;
        ether_addr_copy(info.eth_addr, mac);
        info.vni = vni;
        info.offloaded = adding;
        call_switchdev_notifiers(type, dev, &info.info, NULL);
}

static void mlxsw_sp_fdb_nve_call_notifiers(struct net_device *dev,
                                            const char *mac,
                                            enum mlxsw_sp_l3proto proto,
                                            union mlxsw_sp_l3addr *addr,
                                            __be32 vni,
                                            bool adding)
{
        if (netif_is_vxlan(dev))
                mlxsw_sp_fdb_vxlan_call_notifiers(dev, mac, proto, addr, vni,
                                                  adding);
}

static void
mlxsw_sp_fdb_call_notifiers(enum switchdev_notifier_type type,
                            const char *mac, u16 vid,
                            struct net_device *dev, bool offloaded)
{
        struct switchdev_notifier_fdb_info info = {};

        info.addr = mac;
        info.vid = vid;
        info.offloaded = offloaded;
        call_switchdev_notifiers(type, dev, &info.info, NULL);
}

static void mlxsw_sp_fdb_notify_mac_process(struct mlxsw_sp *mlxsw_sp,
                                            char *sfn_pl, int rec_index,
                                            bool adding)
{
        unsigned int max_ports = mlxsw_core_max_ports(mlxsw_sp->core);
        struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
        struct mlxsw_sp_bridge_device *bridge_device;
        struct mlxsw_sp_bridge_port *bridge_port;
        struct mlxsw_sp_port *mlxsw_sp_port;
        enum switchdev_notifier_type type;
        char mac[ETH_ALEN];
        u8 local_port;
        u16 vid, fid;
        bool do_notification = true;
        int err;

        mlxsw_reg_sfn_mac_unpack(sfn_pl, rec_index, mac, &fid, &local_port);

        if (WARN_ON_ONCE(local_port >= max_ports))
                return;
        mlxsw_sp_port = mlxsw_sp->ports[local_port];
        if (!mlxsw_sp_port) {
                dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Incorrect local port in FDB notification\n");
                goto just_remove;
        }

        if (mlxsw_sp_fid_is_dummy(mlxsw_sp, fid))
                goto just_remove;

        mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_fid(mlxsw_sp_port, fid);
        if (!mlxsw_sp_port_vlan) {
                netdev_err(mlxsw_sp_port->dev, "Failed to find a matching {Port, VID} following FDB notification\n");
                goto just_remove;
        }

        bridge_port = mlxsw_sp_port_vlan->bridge_port;
        if (!bridge_port) {
                netdev_err(mlxsw_sp_port->dev, "{Port, VID} not associated with a bridge\n");
                goto just_remove;
        }

        bridge_device = bridge_port->bridge_device;
        vid = bridge_device->vlan_enabled ? mlxsw_sp_port_vlan->vid : 0;

do_fdb_op:
        err = mlxsw_sp_port_fdb_uc_op(mlxsw_sp, local_port, mac, fid,
                                      adding, true);
        if (err) {
                dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Failed to set FDB entry\n");
                return;
        }

        if (!do_notification)
                return;
        type = adding ? SWITCHDEV_FDB_ADD_TO_BRIDGE : SWITCHDEV_FDB_DEL_TO_BRIDGE;
        mlxsw_sp_fdb_call_notifiers(type, mac, vid, bridge_port->dev, adding);

        return;

just_remove:
        adding = false;
        do_notification = false;
        goto do_fdb_op;
}

static void mlxsw_sp_fdb_notify_mac_lag_process(struct mlxsw_sp *mlxsw_sp,
                                                char *sfn_pl, int rec_index,
                                                bool adding)
{
        struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
        struct mlxsw_sp_bridge_device *bridge_device;
        struct mlxsw_sp_bridge_port *bridge_port;
        struct mlxsw_sp_port *mlxsw_sp_port;
        enum switchdev_notifier_type type;
        char mac[ETH_ALEN];
        u16 lag_vid = 0;
        u16 lag_id;
        u16 vid, fid;
        bool do_notification = true;
        int err;

        mlxsw_reg_sfn_mac_lag_unpack(sfn_pl, rec_index, mac, &fid, &lag_id);
        mlxsw_sp_port = mlxsw_sp_lag_rep_port(mlxsw_sp, lag_id);
        if (!mlxsw_sp_port) {
                dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Cannot find port representor for LAG\n");
                goto just_remove;
        }

        if (mlxsw_sp_fid_is_dummy(mlxsw_sp, fid))
                goto just_remove;

        mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_fid(mlxsw_sp_port, fid);
        if (!mlxsw_sp_port_vlan) {
                netdev_err(mlxsw_sp_port->dev, "Failed to find a matching {Port, VID} following FDB notification\n");
                goto just_remove;
        }

        bridge_port = mlxsw_sp_port_vlan->bridge_port;
        if (!bridge_port) {
                netdev_err(mlxsw_sp_port->dev, "{Port, VID} not associated with a bridge\n");
                goto just_remove;
        }

        bridge_device = bridge_port->bridge_device;
        vid = bridge_device->vlan_enabled ? mlxsw_sp_port_vlan->vid : 0;
        lag_vid = mlxsw_sp_fid_lag_vid_valid(mlxsw_sp_port_vlan->fid) ?
                  mlxsw_sp_port_vlan->vid : 0;

do_fdb_op:
        err = mlxsw_sp_port_fdb_uc_lag_op(mlxsw_sp, lag_id, mac, fid, lag_vid,
                                          adding, true);
        if (err) {
                dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Failed to set FDB entry\n");
                return;
        }

        if (!do_notification)
                return;
        type = adding ? SWITCHDEV_FDB_ADD_TO_BRIDGE : SWITCHDEV_FDB_DEL_TO_BRIDGE;
        mlxsw_sp_fdb_call_notifiers(type, mac, vid, bridge_port->dev, adding);

        return;

just_remove:
        adding = false;
        do_notification = false;
        goto do_fdb_op;
}

static int
__mlxsw_sp_fdb_notify_mac_uc_tunnel_process(struct mlxsw_sp *mlxsw_sp,
                                            const struct mlxsw_sp_fid *fid,
                                            bool adding,
                                            struct net_device **nve_dev,
                                            u16 *p_vid, __be32 *p_vni)
{
        struct mlxsw_sp_bridge_device *bridge_device;
        struct net_device *br_dev, *dev;
        int nve_ifindex;
        int err;

        err = mlxsw_sp_fid_nve_ifindex(fid, &nve_ifindex);
        if (err)
                return err;

        err = mlxsw_sp_fid_vni(fid, p_vni);
        if (err)
                return err;

        dev = __dev_get_by_index(mlxsw_sp_net(mlxsw_sp), nve_ifindex);
        if (!dev)
                return -EINVAL;
        *nve_dev = dev;

        if (!netif_running(dev))
                return -EINVAL;

        if (adding && !br_port_flag_is_set(dev, BR_LEARNING))
                return -EINVAL;

        if (adding && netif_is_vxlan(dev)) {
                struct vxlan_dev *vxlan = netdev_priv(dev);

                if (!(vxlan->cfg.flags & VXLAN_F_LEARN))
                        return -EINVAL;
        }

        br_dev = netdev_master_upper_dev_get(dev);
        if (!br_dev)
                return -EINVAL;

        bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
        if (!bridge_device)
                return -EINVAL;

        *p_vid = bridge_device->ops->fid_vid(bridge_device, fid);

        return 0;
}

static void mlxsw_sp_fdb_notify_mac_uc_tunnel_process(struct mlxsw_sp *mlxsw_sp,
                                                      char *sfn_pl,
                                                      int rec_index,
                                                      bool adding)
{
        enum mlxsw_reg_sfn_uc_tunnel_protocol sfn_proto;
        enum switchdev_notifier_type type;
        struct net_device *nve_dev;
        union mlxsw_sp_l3addr addr;
        struct mlxsw_sp_fid *fid;
        char mac[ETH_ALEN];
        u16 fid_index, vid;
        __be32 vni;
        u32 uip;
        int err;

        mlxsw_reg_sfn_uc_tunnel_unpack(sfn_pl, rec_index, mac, &fid_index,
                                       &uip, &sfn_proto);

        fid = mlxsw_sp_fid_lookup_by_index(mlxsw_sp, fid_index);
        if (!fid)
                goto err_fid_lookup;

        err = mlxsw_sp_nve_learned_ip_resolve(mlxsw_sp, uip,
                                              (enum mlxsw_sp_l3proto) sfn_proto,
                                              &addr);
        if (err)
                goto err_ip_resolve;

        err = __mlxsw_sp_fdb_notify_mac_uc_tunnel_process(mlxsw_sp, fid, adding,
                                                          &nve_dev, &vid, &vni);
        if (err)
                goto err_fdb_process;

        err = mlxsw_sp_port_fdb_tunnel_uc_op(mlxsw_sp, mac, fid_index,
                                             (enum mlxsw_sp_l3proto) sfn_proto,
                                             &addr, adding, true);
        if (err)
                goto err_fdb_op;

        mlxsw_sp_fdb_nve_call_notifiers(nve_dev, mac,
                                        (enum mlxsw_sp_l3proto) sfn_proto,
                                        &addr, vni, adding);

        type = adding ? SWITCHDEV_FDB_ADD_TO_BRIDGE :
                        SWITCHDEV_FDB_DEL_TO_BRIDGE;
        mlxsw_sp_fdb_call_notifiers(type, mac, vid, nve_dev, adding);

        mlxsw_sp_fid_put(fid);

        return;

err_fdb_op:
err_fdb_process:
err_ip_resolve:
        mlxsw_sp_fid_put(fid);
err_fid_lookup:
        /* Remove an FDB entry in case we cannot process it. Otherwise the
         * device will keep sending the same notification over and over again.
         */
        mlxsw_sp_port_fdb_tunnel_uc_op(mlxsw_sp, mac, fid_index,
                                       (enum mlxsw_sp_l3proto) sfn_proto, &addr,
                                       false, true);
}

static void mlxsw_sp_fdb_notify_rec_process(struct mlxsw_sp *mlxsw_sp,
                                            char *sfn_pl, int rec_index)
{
        switch (mlxsw_reg_sfn_rec_type_get(sfn_pl, rec_index)) {
        case MLXSW_REG_SFN_REC_TYPE_LEARNED_MAC:
                mlxsw_sp_fdb_notify_mac_process(mlxsw_sp, sfn_pl,
                                                rec_index, true);
                break;
        case MLXSW_REG_SFN_REC_TYPE_AGED_OUT_MAC:
                mlxsw_sp_fdb_notify_mac_process(mlxsw_sp, sfn_pl,
                                                rec_index, false);
                break;
        case MLXSW_REG_SFN_REC_TYPE_LEARNED_MAC_LAG:
                mlxsw_sp_fdb_notify_mac_lag_process(mlxsw_sp, sfn_pl,
                                                    rec_index, true);
                break;
        case MLXSW_REG_SFN_REC_TYPE_AGED_OUT_MAC_LAG:
                mlxsw_sp_fdb_notify_mac_lag_process(mlxsw_sp, sfn_pl,
                                                    rec_index, false);
                break;
        case MLXSW_REG_SFN_REC_TYPE_LEARNED_UNICAST_TUNNEL:
                mlxsw_sp_fdb_notify_mac_uc_tunnel_process(mlxsw_sp, sfn_pl,
                                                          rec_index, true);
                break;
        case MLXSW_REG_SFN_REC_TYPE_AGED_OUT_UNICAST_TUNNEL:
                mlxsw_sp_fdb_notify_mac_uc_tunnel_process(mlxsw_sp, sfn_pl,
                                                          rec_index, false);
                break;
        }
}

static void mlxsw_sp_fdb_notify_work_schedule(struct mlxsw_sp *mlxsw_sp,
                                              bool no_delay)
{
        struct mlxsw_sp_bridge *bridge = mlxsw_sp->bridge;
        unsigned int interval = no_delay ? 0 : bridge->fdb_notify.interval;

        mlxsw_core_schedule_dw(&bridge->fdb_notify.dw,
                               msecs_to_jiffies(interval));
}

#define MLXSW_SP_FDB_SFN_QUERIES_PER_SESSION 10

static void mlxsw_sp_fdb_notify_work(struct work_struct *work)
{
        struct mlxsw_sp_bridge *bridge;
        struct mlxsw_sp *mlxsw_sp;
        char *sfn_pl;
        int queries;
        u8 num_rec;
        int i;
        int err;

        sfn_pl = kmalloc(MLXSW_REG_SFN_LEN, GFP_KERNEL);
        if (!sfn_pl)
                return;

        bridge = container_of(work, struct mlxsw_sp_bridge, fdb_notify.dw.work);
        mlxsw_sp = bridge->mlxsw_sp;

        rtnl_lock();
        queries = MLXSW_SP_FDB_SFN_QUERIES_PER_SESSION;
        while (queries > 0) {
                mlxsw_reg_sfn_pack(sfn_pl);
                err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(sfn), sfn_pl);
                if (err) {
                        dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Failed to get FDB notifications\n");
                        goto out;
                }
                num_rec = mlxsw_reg_sfn_num_rec_get(sfn_pl);
                for (i = 0; i < num_rec; i++)
                        mlxsw_sp_fdb_notify_rec_process(mlxsw_sp, sfn_pl, i);
                if (num_rec != MLXSW_REG_SFN_REC_MAX_COUNT)
                        goto out;
                queries--;
        }

out:
        rtnl_unlock();
        kfree(sfn_pl);
        mlxsw_sp_fdb_notify_work_schedule(mlxsw_sp, !queries);
}

struct mlxsw_sp_switchdev_event_work {
        struct work_struct work;
        union {
                struct switchdev_notifier_fdb_info fdb_info;
                struct switchdev_notifier_vxlan_fdb_info vxlan_fdb_info;
        };
        struct net_device *dev;
        unsigned long event;
};

static void
mlxsw_sp_switchdev_bridge_vxlan_fdb_event(struct mlxsw_sp *mlxsw_sp,
                                          struct mlxsw_sp_switchdev_event_work *
                                          switchdev_work,
                                          struct mlxsw_sp_fid *fid, __be32 vni)
{
        struct switchdev_notifier_vxlan_fdb_info vxlan_fdb_info;
        struct switchdev_notifier_fdb_info *fdb_info;
        struct net_device *dev = switchdev_work->dev;
        enum mlxsw_sp_l3proto proto;
        union mlxsw_sp_l3addr addr;
        int err;

        fdb_info = &switchdev_work->fdb_info;
        err = vxlan_fdb_find_uc(dev, fdb_info->addr, vni, &vxlan_fdb_info);
        if (err)
                return;

        mlxsw_sp_switchdev_vxlan_addr_convert(&vxlan_fdb_info.remote_ip,
                                              &proto, &addr);

        switch (switchdev_work->event) {
        case SWITCHDEV_FDB_ADD_TO_DEVICE:
                err = mlxsw_sp_port_fdb_tunnel_uc_op(mlxsw_sp,
                                                     vxlan_fdb_info.eth_addr,
                                                     mlxsw_sp_fid_index(fid),
                                                     proto, &addr, true, false);
                if (err)
                        return;
                vxlan_fdb_info.offloaded = true;
                call_switchdev_notifiers(SWITCHDEV_VXLAN_FDB_OFFLOADED, dev,
                                         &vxlan_fdb_info.info, NULL);
                mlxsw_sp_fdb_call_notifiers(SWITCHDEV_FDB_OFFLOADED,
                                            vxlan_fdb_info.eth_addr,
                                            fdb_info->vid, dev, true);
                break;
        case SWITCHDEV_FDB_DEL_TO_DEVICE:
                err = mlxsw_sp_port_fdb_tunnel_uc_op(mlxsw_sp,
                                                     vxlan_fdb_info.eth_addr,
                                                     mlxsw_sp_fid_index(fid),
                                                     proto, &addr, false,
                                                     false);
                vxlan_fdb_info.offloaded = false;
                call_switchdev_notifiers(SWITCHDEV_VXLAN_FDB_OFFLOADED, dev,
                                         &vxlan_fdb_info.info, NULL);
                break;
        }
}

static void
mlxsw_sp_switchdev_bridge_nve_fdb_event(struct mlxsw_sp_switchdev_event_work *
                                        switchdev_work)
{
        struct mlxsw_sp_bridge_device *bridge_device;
        struct net_device *dev = switchdev_work->dev;
        struct net_device *br_dev;
        struct mlxsw_sp *mlxsw_sp;
        struct mlxsw_sp_fid *fid;
        __be32 vni;
        int err;

        if (switchdev_work->event != SWITCHDEV_FDB_ADD_TO_DEVICE &&
            switchdev_work->event != SWITCHDEV_FDB_DEL_TO_DEVICE)
                return;

        if (switchdev_work->event == SWITCHDEV_FDB_ADD_TO_DEVICE &&
            (!switchdev_work->fdb_info.added_by_user ||
             switchdev_work->fdb_info.is_local))
                return;

        if (!netif_running(dev))
                return;
        br_dev = netdev_master_upper_dev_get(dev);
        if (!br_dev)
                return;
        if (!netif_is_bridge_master(br_dev))
                return;
        mlxsw_sp = mlxsw_sp_lower_get(br_dev);
        if (!mlxsw_sp)
                return;
        bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
        if (!bridge_device)
                return;

        fid = bridge_device->ops->fid_lookup(bridge_device,
                                             switchdev_work->fdb_info.vid);
        if (!fid)
                return;

        err = mlxsw_sp_fid_vni(fid, &vni);
        if (err)
                goto out;

        mlxsw_sp_switchdev_bridge_vxlan_fdb_event(mlxsw_sp, switchdev_work, fid,
                                                  vni);

out:
        mlxsw_sp_fid_put(fid);
}

static void mlxsw_sp_switchdev_bridge_fdb_event_work(struct work_struct *work)
{
        struct mlxsw_sp_switchdev_event_work *switchdev_work =
                container_of(work, struct mlxsw_sp_switchdev_event_work, work);
        struct net_device *dev = switchdev_work->dev;
        struct switchdev_notifier_fdb_info *fdb_info;
        struct mlxsw_sp_port *mlxsw_sp_port;
        int err;

        rtnl_lock();
        if (netif_is_vxlan(dev)) {
                mlxsw_sp_switchdev_bridge_nve_fdb_event(switchdev_work);
                goto out;
        }

        mlxsw_sp_port = mlxsw_sp_port_dev_lower_find(dev);
        if (!mlxsw_sp_port)
                goto out;

        switch (switchdev_work->event) {
        case SWITCHDEV_FDB_ADD_TO_DEVICE:
                fdb_info = &switchdev_work->fdb_info;
                if (!fdb_info->added_by_user || fdb_info->is_local)
                        break;
                err = mlxsw_sp_port_fdb_set(mlxsw_sp_port, fdb_info, true);
                if (err)
                        break;
                mlxsw_sp_fdb_call_notifiers(SWITCHDEV_FDB_OFFLOADED,
                                            fdb_info->addr,
                                            fdb_info->vid, dev, true);
                break;
        case SWITCHDEV_FDB_DEL_TO_DEVICE: