// SPDX-License-Identifier: GPL-2.0+

#include <linux/if_bridge.h>
#include <net/switchdev.h>

#include "lan966x_main.h"

static struct notifier_block lan966x_netdevice_nb __read_mostly;

static void lan966x_port_set_mcast_ip_flood(struct lan966x_port *port,
                                            u32 pgid_ip)
{
        struct lan966x *lan966x = port->lan966x;
        u32 flood_mask_ip;

        flood_mask_ip = lan_rd(lan966x, ANA_PGID(pgid_ip));
        flood_mask_ip = ANA_PGID_PGID_GET(flood_mask_ip);

        /* If mcast snooping is not enabled then use mcast flood mask
         * to decide to enable multicast flooding or not.
         */
        if (!port->mcast_ena) {
                u32 flood_mask;

                flood_mask = lan_rd(lan966x, ANA_PGID(PGID_MC));
                flood_mask = ANA_PGID_PGID_GET(flood_mask);

                if (flood_mask & BIT(port->chip_port))
                        flood_mask_ip |= BIT(port->chip_port);
                else
                        flood_mask_ip &= ~BIT(port->chip_port);
        } else {
                flood_mask_ip &= ~BIT(port->chip_port);
        }

        lan_rmw(ANA_PGID_PGID_SET(flood_mask_ip),
                ANA_PGID_PGID,
                lan966x, ANA_PGID(pgid_ip));
}

static void lan966x_port_set_mcast_flood(struct lan966x_port *port,
                                         bool enabled)
{
        u32 val = lan_rd(port->lan966x, ANA_PGID(PGID_MC));

        val = ANA_PGID_PGID_GET(val);
        if (enabled)
                val |= BIT(port->chip_port);
        else
                val &= ~BIT(port->chip_port);

        lan_rmw(ANA_PGID_PGID_SET(val),
                ANA_PGID_PGID,
                port->lan966x, ANA_PGID(PGID_MC));

        if (!port->mcast_ena) {
                lan966x_port_set_mcast_ip_flood(port, PGID_MCIPV4);
                lan966x_port_set_mcast_ip_flood(port, PGID_MCIPV6);
        }
}

static void lan966x_port_set_ucast_flood(struct lan966x_port *port,
                                         bool enabled)
{
        u32 val = lan_rd(port->lan966x, ANA_PGID(PGID_UC));

        val = ANA_PGID_PGID_GET(val);
        if (enabled)
                val |= BIT(port->chip_port);
        else
                val &= ~BIT(port->chip_port);

        lan_rmw(ANA_PGID_PGID_SET(val),
                ANA_PGID_PGID,
                port->lan966x, ANA_PGID(PGID_UC));
}

static void lan966x_port_set_bcast_flood(struct lan966x_port *port,
                                         bool enabled)
{
        u32 val = lan_rd(port->lan966x, ANA_PGID(PGID_BC));

        val = ANA_PGID_PGID_GET(val);
        if (enabled)
                val |= BIT(port->chip_port);
        else
                val &= ~BIT(port->chip_port);

        lan_rmw(ANA_PGID_PGID_SET(val),
                ANA_PGID_PGID,
                port->lan966x, ANA_PGID(PGID_BC));
}

static void lan966x_port_set_learning(struct lan966x_port *port, bool enabled)
{
        lan_rmw(ANA_PORT_CFG_LEARN_ENA_SET(enabled),
                ANA_PORT_CFG_LEARN_ENA,
                port->lan966x, ANA_PORT_CFG(port->chip_port));

        port->learn_ena = enabled;
}

static void lan966x_port_bridge_flags(struct lan966x_port *port,
                                      struct switchdev_brport_flags flags)
{
        if (flags.mask & BR_MCAST_FLOOD)
                lan966x_port_set_mcast_flood(port,
                                             !!(flags.val & BR_MCAST_FLOOD));

        if (flags.mask & BR_FLOOD)
                lan966x_port_set_ucast_flood(port,
                                             !!(flags.val & BR_FLOOD));

        if (flags.mask & BR_BCAST_FLOOD)
                lan966x_port_set_bcast_flood(port,
                                             !!(flags.val & BR_BCAST_FLOOD));

        if (flags.mask & BR_LEARNING)
                lan966x_port_set_learning(port,
                                          !!(flags.val & BR_LEARNING));
}

static int lan966x_port_pre_bridge_flags(struct lan966x_port *port,
                                         struct switchdev_brport_flags flags)
{
        if (flags.mask & ~(BR_MCAST_FLOOD | BR_FLOOD | BR_BCAST_FLOOD |
                           BR_LEARNING))
                return -EINVAL;

        return 0;
}

void lan966x_update_fwd_mask(struct lan966x *lan966x)
{
        int i;

        for (i = 0; i < lan966x->num_phys_ports; i++) {
                struct lan966x_port *port = lan966x->ports[i];
                unsigned long mask = 0;

                if (port && lan966x->bridge_fwd_mask & BIT(i)) {
                        mask = lan966x->bridge_fwd_mask & ~BIT(i);

                        if (port->bond)
                                mask &= ~lan966x_lag_get_mask(lan966x,
                                                              port->bond);
                }

                mask |= BIT(CPU_PORT);

                lan_wr(ANA_PGID_PGID_SET(mask),
                       lan966x, ANA_PGID(PGID_SRC + i));
        }
}

void lan966x_port_stp_state_set(struct lan966x_port *port, u8 state)
{
        struct lan966x *lan966x = port->lan966x;
        bool learn_ena = false;

        if ((state == BR_STATE_FORWARDING || state == BR_STATE_LEARNING) &&
            port->learn_ena)
                learn_ena = true;

        if (state == BR_STATE_FORWARDING)
                lan966x->bridge_fwd_mask |= BIT(port->chip_port);
        else
                lan966x->bridge_fwd_mask &= ~BIT(port->chip_port);

        lan_rmw(ANA_PORT_CFG_LEARN_ENA_SET(learn_ena),
                ANA_PORT_CFG_LEARN_ENA,
                lan966x, ANA_PORT_CFG(port->chip_port));

        lan966x_update_fwd_mask(lan966x);
}

void lan966x_port_ageing_set(struct lan966x_port *port,
                             unsigned long ageing_clock_t)
{
        unsigned long ageing_jiffies = clock_t_to_jiffies(ageing_clock_t);
        u32 ageing_time = jiffies_to_msecs(ageing_jiffies) / 1000;

        lan966x_mac_set_ageing(port->lan966x, ageing_time);
}

static void lan966x_port_mc_set(struct lan966x_port *port, bool mcast_ena)
{
        struct lan966x *lan966x = port->lan966x;

        port->mcast_ena = mcast_ena;
        if (mcast_ena)
                lan966x_mdb_restore_entries(lan966x);
        else
                lan966x_mdb_clear_entries(lan966x);

        lan_rmw(ANA_CPU_FWD_CFG_IGMP_REDIR_ENA_SET(mcast_ena) |
                ANA_CPU_FWD_CFG_MLD_REDIR_ENA_SET(mcast_ena) |
                ANA_CPU_FWD_CFG_IPMC_CTRL_COPY_ENA_SET(mcast_ena),
                ANA_CPU_FWD_CFG_IGMP_REDIR_ENA |
                ANA_CPU_FWD_CFG_MLD_REDIR_ENA |
                ANA_CPU_FWD_CFG_IPMC_CTRL_COPY_ENA,
                lan966x, ANA_CPU_FWD_CFG(port->chip_port));

        lan966x_port_set_mcast_ip_flood(port, PGID_MCIPV4);
        lan966x_port_set_mcast_ip_flood(port, PGID_MCIPV6);
}

static int lan966x_port_attr_set(struct net_device *dev, const void *ctx,
                                 const struct switchdev_attr *attr,
                                 struct netlink_ext_ack *extack)
{
        struct lan966x_port *port = netdev_priv(dev);
        int err = 0;

        if (ctx && ctx != port)
                return 0;

        switch (attr->id) {
        case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS:
                lan966x_port_bridge_flags(port, attr->u.brport_flags);
                break;
        case SWITCHDEV_ATTR_ID_PORT_PRE_BRIDGE_FLAGS:
                err = lan966x_port_pre_bridge_flags(port, attr->u.brport_flags);
                break;
        case SWITCHDEV_ATTR_ID_PORT_STP_STATE:
                lan966x_port_stp_state_set(port, attr->u.stp_state);
                break;
        case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME:
                lan966x_port_ageing_set(port, attr->u.ageing_time);
                break;
        case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING:
                lan966x_vlan_port_set_vlan_aware(port, attr->u.vlan_filtering);
                lan966x_vlan_port_apply(port);
                break;
        case SWITCHDEV_ATTR_ID_BRIDGE_MC_DISABLED:
                lan966x_port_mc_set(port, !attr->u.mc_disabled);
                break;
        default:
                err = -EOPNOTSUPP;
                break;
        }

        return err;
}

static int lan966x_port_bridge_join(struct lan966x_port *port,
                                    struct net_device *brport_dev,
                                    struct net_device *bridge,
                                    struct netlink_ext_ack *extack)
{
        struct switchdev_brport_flags flags = {0};
        struct lan966x *lan966x = port->lan966x;
        struct net_device *dev = port->dev;
        int err;

        if (!lan966x->bridge_mask) {
                lan966x->bridge = bridge;
        } else {
                if (lan966x->bridge != bridge) {
                        NL_SET_ERR_MSG_MOD(extack, "Not allow to add port to different bridge");
                        return -ENODEV;
                }
        }

        err = switchdev_bridge_port_offload(brport_dev, dev, port,
                                            &lan966x_switchdev_nb,
                                            &lan966x_switchdev_blocking_nb,
                                            false, extack);
        if (err)
                return err;

        lan966x->bridge_mask |= BIT(port->chip_port);

        flags.mask = BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD | BR_BCAST_FLOOD;
        flags.val = flags.mask;
        lan966x_port_bridge_flags(port, flags);

        return 0;
}

static void lan966x_port_bridge_leave(struct lan966x_port *port,
                                      struct net_device *bridge)
{
        struct switchdev_brport_flags flags = {0};
        struct lan966x *lan966x = port->lan966x;

        flags.mask = BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD | BR_BCAST_FLOOD;
        flags.val = flags.mask & ~BR_LEARNING;
        lan966x_port_bridge_flags(port, flags);

        lan966x->bridge_mask &= ~BIT(port->chip_port);

        if (!lan966x->bridge_mask)
                lan966x->bridge = NULL;

        /* Set the port back to host mode */
        lan966x_vlan_port_set_vlan_aware(port, false);
        lan966x_vlan_port_set_vid(port, HOST_PVID, false, false);
        lan966x_vlan_port_apply(port);
        lan966x_vlan_port_rew_host(port);
}

int lan966x_port_changeupper(struct net_device *dev,
                             struct net_device *brport_dev,
                             struct netdev_notifier_changeupper_info *info)
{
        struct lan966x_port *port = netdev_priv(dev);
        struct netlink_ext_ack *extack;
        int err = 0;

        extack = netdev_notifier_info_to_extack(&info->info);

        if (netif_is_bridge_master(info->upper_dev)) {
                if (info->linking)
                        err = lan966x_port_bridge_join(port, brport_dev,
                                                       info->upper_dev,
                                                       extack);
                else
                        lan966x_port_bridge_leave(port, info->upper_dev);
        }

        if (netif_is_lag_master(info->upper_dev)) {
                if (info->linking)
                        err = lan966x_lag_port_join(port, info->upper_dev,
                                                    info->upper_dev,
                                                    extack);
                else
                        lan966x_lag_port_leave(port, info->upper_dev);
        }

        return err;
}

int lan966x_port_prechangeupper(struct net_device *dev,
                                struct net_device *brport_dev,
                                struct netdev_notifier_changeupper_info *info)
{
        struct lan966x_port *port = netdev_priv(dev);
        int err = NOTIFY_DONE;

        if (netif_is_bridge_master(info->upper_dev) && !info->linking) {
                switchdev_bridge_port_unoffload(port->dev, port, NULL, NULL);
                lan966x_fdb_flush_workqueue(port->lan966x);
        }

        if (netif_is_lag_master(info->upper_dev)) {
                err = lan966x_lag_port_prechangeupper(dev, info);
                if (err || info->linking)
                        return err;

                switchdev_bridge_port_unoffload(brport_dev, port, NULL, NULL);
                lan966x_fdb_flush_workqueue(port->lan966x);
        }

        return err;
}

static int lan966x_foreign_bridging_check(struct net_device *upper,
                                          bool *has_foreign,
                                          bool *seen_lan966x,
                                          struct netlink_ext_ack *extack)
{
        struct lan966x *lan966x = NULL;
        struct net_device *dev;
        struct list_head *iter;

        if (!netif_is_bridge_master(upper) &&
            !netif_is_lag_master(upper))
                return 0;

        netdev_for_each_lower_dev(upper, dev, iter) {
                if (lan966x_netdevice_check(dev)) {
                        struct lan966x_port *port = netdev_priv(dev);

                        if (lan966x) {
                                /* Upper already has at least one port of a
                                 * lan966x switch inside it, check that it's
                                 * the same instance of the driver.
                                 */
                                if (port->lan966x != lan966x) {
                                        NL_SET_ERR_MSG_MOD(extack,
                                                           "Bridging between multiple lan966x switches disallowed");
                                        return -EINVAL;
                                }
                        } else {
                                /* This is the first lan966x port inside this
                                 * upper device
                                 */
                                lan966x = port->lan966x;
                                *seen_lan966x = true;
                        }
                } else if (netif_is_lag_master(dev)) {
                        /* Allow to have bond interfaces that have only lan966x
                         * devices
                         */
                        if (lan966x_foreign_bridging_check(dev, has_foreign,
                                                           seen_lan966x,
                                                           extack))
                                return -EINVAL;
                } else {
                        *has_foreign = true;
                }

                if (*seen_lan966x && *has_foreign) {
                        NL_SET_ERR_MSG_MOD(extack,
                                           "Bridging lan966x ports with foreign interfaces disallowed");
                        return -EINVAL;
                }
        }

        return 0;
}

static int lan966x_bridge_check(struct net_device *dev,
                                struct netdev_notifier_changeupper_info *info)
{
        bool has_foreign = false;
        bool seen_lan966x = false;

        return lan966x_foreign_bridging_check(info->upper_dev,
                                              &has_foreign,
                                              &seen_lan966x,
                                              info->info.extack);
}

static int lan966x_netdevice_port_event(struct net_device *dev,
                                        struct notifier_block *nb,
                                        unsigned long event, void *ptr)
{
        int err = 0;

        if (!lan966x_netdevice_check(dev)) {
                switch (event) {
                case NETDEV_CHANGEUPPER:
                case NETDEV_PRECHANGEUPPER:
                        err = lan966x_bridge_check(dev, ptr);
                        if (err)
                                return err;

                        if (netif_is_lag_master(dev)) {
                                if (event == NETDEV_CHANGEUPPER)
                                        err = lan966x_lag_netdev_changeupper(dev,
                                                                             ptr);
                                else
                                        err = lan966x_lag_netdev_prechangeupper(dev,
                                                                                ptr);

                                return err;
                        }
                        break;
                default:
                        return 0;
                }

                return 0;
        }

        switch (event) {
        case NETDEV_PRECHANGEUPPER:
                err = lan966x_port_prechangeupper(dev, dev, ptr);
                break;
        case NETDEV_CHANGEUPPER:
                err = lan966x_bridge_check(dev, ptr);
                if (err)
                        return err;

                err = lan966x_port_changeupper(dev, dev, ptr);
                break;
        case NETDEV_CHANGELOWERSTATE:
                err = lan966x_lag_port_changelowerstate(dev, ptr);
                break;
        }

        return err;
}

static int lan966x_netdevice_event(struct notifier_block *nb,
                                   unsigned long event, void *ptr)
{
        struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        int ret;

        ret = lan966x_netdevice_port_event(dev, nb, event, ptr);

        return notifier_from_errno(ret);
}

static bool lan966x_foreign_dev_check(const struct net_device *dev,
                                      const struct net_device *foreign_dev)
{
        struct lan966x_port *port = netdev_priv(dev);
        struct lan966x *lan966x = port->lan966x;
        int i;

        if (netif_is_bridge_master(foreign_dev))
                if (lan966x->bridge == foreign_dev)
                        return false;

        if (netif_is_lag_master(foreign_dev))
                for (i = 0; i < lan966x->num_phys_ports; ++i)
                        if (lan966x->ports[i] &&
                            lan966x->ports[i]->bond == foreign_dev)
                                return false;

        return true;
}

static int lan966x_switchdev_event(struct notifier_block *nb,
                                   unsigned long event, void *ptr)
{
        struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
        int err;

        switch (event) {
        case SWITCHDEV_PORT_ATTR_SET:
                err = switchdev_handle_port_attr_set(dev, ptr,
                                                     lan966x_netdevice_check,
                                                     lan966x_port_attr_set);
                return notifier_from_errno(err);
        case SWITCHDEV_FDB_ADD_TO_DEVICE:
        case SWITCHDEV_FDB_DEL_TO_DEVICE:
                err = switchdev_handle_fdb_event_to_device(dev, event, ptr,
                                                           lan966x_netdevice_check,
                                                           lan966x_foreign_dev_check,
                                                           lan966x_handle_fdb);
                return notifier_from_errno(err);
        }

        return NOTIFY_DONE;
}

static int lan966x_handle_port_vlan_add(struct lan966x_port *port,
                                        const struct switchdev_obj *obj)
{
        const struct switchdev_obj_port_vlan *v = SWITCHDEV_OBJ_PORT_VLAN(obj);
        struct lan966x *lan966x = port->lan966x;

        if (!netif_is_bridge_master(obj->orig_dev))
                lan966x_vlan_port_add_vlan(port, v->vid,
                                           v->flags & BRIDGE_VLAN_INFO_PVID,
                                           v->flags & BRIDGE_VLAN_INFO_UNTAGGED);
        else
                lan966x_vlan_cpu_add_vlan(lan966x, v->vid);

        return 0;
}

static int lan966x_handle_port_obj_add(struct net_device *dev, const void *ctx,
                                       const struct switchdev_obj *obj,
                                       struct netlink_ext_ack *extack)
{
        struct lan966x_port *port = netdev_priv(dev);
        int err;

        if (ctx && ctx != port)
                return 0;

        switch (obj->id) {
        case SWITCHDEV_OBJ_ID_PORT_VLAN:
                err = lan966x_handle_port_vlan_add(port, obj);
                break;
        case SWITCHDEV_OBJ_ID_PORT_MDB:
        case SWITCHDEV_OBJ_ID_HOST_MDB:
                err = lan966x_handle_port_mdb_add(port, obj);
                break;
        default:
                err = -EOPNOTSUPP;
                break;
        }

        return err;
}

static int lan966x_handle_port_vlan_del(struct lan966x_port *port,
                                        const struct switchdev_obj *obj)
{
        const struct switchdev_obj_port_vlan *v = SWITCHDEV_OBJ_PORT_VLAN(obj);
        struct lan966x *lan966x = port->lan966x;

        if (!netif_is_bridge_master(obj->orig_dev))
                lan966x_vlan_port_del_vlan(port, v->vid);
        else
                lan966x_vlan_cpu_del_vlan(lan966x, v->vid);

        return 0;
}

static int lan966x_handle_port_obj_del(struct net_device *dev, const void *ctx,
                                       const struct switchdev_obj *obj)
{
        struct lan966x_port *port = netdev_priv(dev);
        int err;

        if (ctx && ctx != port)
                return 0;

        switch (obj->id) {
        case SWITCHDEV_OBJ_ID_PORT_VLAN:
                err = lan966x_handle_port_vlan_del(port, obj);
                break;
        case SWITCHDEV_OBJ_ID_PORT_MDB:
        case SWITCHDEV_OBJ_ID_HOST_MDB:
                err = lan966x_handle_port_mdb_del(port, obj);
                break;
        default:
                err = -EOPNOTSUPP;
                break;
        }

        return err;
}

static int lan966x_switchdev_blocking_event(struct notifier_block *nb,
                                            unsigned long event,
                                            void *ptr)
{
        struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
        int err;

        switch (event) {
        case SWITCHDEV_PORT_OBJ_ADD:
                err = switchdev_handle_port_obj_add(dev, ptr,
                                                    lan966x_netdevice_check,
                                                    lan966x_handle_port_obj_add);
                return notifier_from_errno(err);
        case SWITCHDEV_PORT_OBJ_DEL:
                err = switchdev_handle_port_obj_del(dev, ptr,
                                                    lan966x_netdevice_check,
                                                    lan966x_handle_port_obj_del);
                return notifier_from_errno(err);
        case SWITCHDEV_PORT_ATTR_SET:
                err = switchdev_handle_port_attr_set(dev, ptr,
                                                     lan966x_netdevice_check,
                                                     lan966x_port_attr_set);
                return notifier_from_errno(err);
        }

        return NOTIFY_DONE;
}

static struct notifier_block lan966x_netdevice_nb __read_mostly = {
        .notifier_call = lan966x_netdevice_event,
};

struct notifier_block lan966x_switchdev_nb __read_mostly = {
        .notifier_call = lan966x_switchdev_event,
};

struct notifier_block lan966x_switchdev_blocking_nb __read_mostly = {
        .notifier_call = lan966x_switchdev_blocking_event,
};

void lan966x_register_notifier_blocks(void)
{
        register_netdevice_notifier(&lan966x_netdevice_nb);
        register_switchdev_notifier(&lan966x_switchdev_nb);
        register_switchdev_blocking_notifier(&lan966x_switchdev_blocking_nb);
}

void lan966x_unregister_notifier_blocks(void)
{
        unregister_switchdev_blocking_notifier(&lan966x_switchdev_blocking_nb);
        unregister_switchdev_notifier(&lan966x_switchdev_nb);
        unregister_netdevice_notifier(&lan966x_netdevice_nb);
}