// SPDX-License-Identifier: GPL-2.0
// Copyright (c) Huawei Technologies Co., Ltd. 2025. All rights reserved.

#include <linux/kernel.h>
#include <linux/pci.h>
#include <linux/device.h>
#include <linux/types.h>
#include <linux/errno.h>
#include <linux/etherdevice.h>
#include <linux/netdevice.h>
#include <linux/module.h>
#include <linux/moduleparam.h>

#include "hinic3_hwif.h"
#include "hinic3_nic_dev.h"
#include "hinic3_nic_cfg.h"

static int hinic3_filter_addr_sync(struct net_device *netdev, u8 *addr)
{
        struct hinic3_nic_dev *nic_dev = netdev_priv(netdev);

        return hinic3_set_mac(nic_dev->hwdev, addr, 0,
                              hinic3_global_func_id(nic_dev->hwdev));
}

static int hinic3_filter_addr_unsync(struct net_device *netdev, u8 *addr)
{
        struct hinic3_nic_dev *nic_dev = netdev_priv(netdev);

        /* The addr is in use */
        if (ether_addr_equal(addr, netdev->dev_addr))
                return 0;

        return hinic3_del_mac(nic_dev->hwdev, addr, 0,
                              hinic3_global_func_id(nic_dev->hwdev));
}

void hinic3_clean_mac_list_filter(struct net_device *netdev)
{
        struct hinic3_nic_dev *nic_dev = netdev_priv(netdev);
        struct hinic3_mac_filter *ftmp;
        struct hinic3_mac_filter *f;

        list_for_each_entry_safe(f, ftmp, &nic_dev->uc_filter_list, list) {
                if (f->state == HINIC3_MAC_HW_SYNCED)
                        hinic3_filter_addr_unsync(netdev, f->addr);
                list_del(&f->list);
                kfree(f);
        }

        list_for_each_entry_safe(f, ftmp, &nic_dev->mc_filter_list, list) {
                if (f->state == HINIC3_MAC_HW_SYNCED)
                        hinic3_filter_addr_unsync(netdev, f->addr);
                list_del(&f->list);
                kfree(f);
        }
}

static struct hinic3_mac_filter *
hinic3_find_mac(const struct list_head *filter_list, u8 *addr)
{
        struct hinic3_mac_filter *f;

        list_for_each_entry(f, filter_list, list) {
                if (ether_addr_equal(addr, f->addr))
                        return f;
        }
        return NULL;
}

static void hinic3_add_filter(struct net_device *netdev,
                              struct list_head *mac_filter_list,
                              u8 *addr)
{
        struct hinic3_nic_dev *nic_dev = netdev_priv(netdev);
        struct hinic3_mac_filter *f;

        f = kzalloc_obj(*f, GFP_ATOMIC);
        if (!f)
                return;

        ether_addr_copy(f->addr, addr);

        INIT_LIST_HEAD(&f->list);
        list_add_tail(&f->list, mac_filter_list);

        f->state = HINIC3_MAC_WAIT_HW_SYNC;
        set_bit(HINIC3_MAC_FILTER_CHANGED, &nic_dev->flags);
}

static void hinic3_del_filter(struct net_device *netdev,
                              struct hinic3_mac_filter *f)
{
        struct hinic3_nic_dev *nic_dev = netdev_priv(netdev);

        set_bit(HINIC3_MAC_FILTER_CHANGED, &nic_dev->flags);

        if (f->state == HINIC3_MAC_WAIT_HW_SYNC) {
                /* have not added to hw, delete it directly */
                list_del(&f->list);
                kfree(f);
                return;
        }

        f->state = HINIC3_MAC_WAIT_HW_UNSYNC;
}

static struct hinic3_mac_filter *
hinic3_mac_filter_entry_clone(const struct hinic3_mac_filter *src)
{
        struct hinic3_mac_filter *f;

        f = kzalloc_obj(*f, GFP_ATOMIC);
        if (!f)
                return NULL;

        *f = *src;
        INIT_LIST_HEAD(&f->list);

        return f;
}

static void hinic3_undo_del_filter_entries(struct list_head *filter_list,
                                           const struct list_head *from)
{
        struct hinic3_mac_filter *ftmp;
        struct hinic3_mac_filter *f;

        list_for_each_entry_safe(f, ftmp, from, list) {
                if (hinic3_find_mac(filter_list, f->addr))
                        continue;

                if (f->state == HINIC3_MAC_HW_UNSYNCED)
                        f->state = HINIC3_MAC_WAIT_HW_UNSYNC;

                list_move_tail(&f->list, filter_list);
        }
}

static void hinic3_undo_add_filter_entries(struct list_head *filter_list,
                                           const struct list_head *from)
{
        struct hinic3_mac_filter *ftmp;
        struct hinic3_mac_filter *tmp;
        struct hinic3_mac_filter *f;

        list_for_each_entry_safe(f, ftmp, from, list) {
                tmp = hinic3_find_mac(filter_list, f->addr);
                if (tmp && tmp->state == HINIC3_MAC_HW_SYNCING)
                        tmp->state = HINIC3_MAC_WAIT_HW_SYNC;
        }
}

static void hinic3_cleanup_filter_list(const struct list_head *head)
{
        struct hinic3_mac_filter *ftmp;
        struct hinic3_mac_filter *f;

        list_for_each_entry_safe(f, ftmp, head, list) {
                list_del(&f->list);
                kfree(f);
        }
}

static int hinic3_mac_filter_sync_hw(struct net_device *netdev,
                                     struct list_head *del_list,
                                     struct list_head *add_list,
                                     int *add_count)
{
        struct hinic3_mac_filter *ftmp;
        struct hinic3_mac_filter *f;
        int err;

        if (!list_empty(del_list)) {
                list_for_each_entry_safe(f, ftmp, del_list, list) {
                        /* ignore errors when deleting mac */
                        hinic3_filter_addr_unsync(netdev, f->addr);
                        list_del(&f->list);
                        kfree(f);
                }
        }

        if (!list_empty(add_list)) {
                list_for_each_entry_safe(f, ftmp, add_list, list) {
                        if (f->state != HINIC3_MAC_HW_SYNCING)
                                continue;

                        err = hinic3_filter_addr_sync(netdev, f->addr);
                        if (err) {
                                netdev_err(netdev, "Failed to add mac\n");
                                return err;
                        }

                        f->state = HINIC3_MAC_HW_SYNCED;
                        (*add_count)++;
                }
        }

        return 0;
}

static int hinic3_mac_filter_sync(struct net_device *netdev,
                                  struct list_head *mac_filter_list, bool uc)
{
        struct hinic3_nic_dev *nic_dev = netdev_priv(netdev);
        struct list_head tmp_del_list, tmp_add_list;
        struct hinic3_mac_filter *fclone;
        struct hinic3_mac_filter *ftmp;
        struct hinic3_mac_filter *f;
        int err = 0, add_count = 0;

        INIT_LIST_HEAD(&tmp_del_list);
        INIT_LIST_HEAD(&tmp_add_list);

        list_for_each_entry_safe(f, ftmp, mac_filter_list, list) {
                if (f->state != HINIC3_MAC_WAIT_HW_UNSYNC)
                        continue;

                f->state = HINIC3_MAC_HW_UNSYNCED;
                list_move_tail(&f->list, &tmp_del_list);
        }

        list_for_each_entry_safe(f, ftmp, mac_filter_list, list) {
                if (f->state != HINIC3_MAC_WAIT_HW_SYNC)
                        continue;

                fclone = hinic3_mac_filter_entry_clone(f);
                if (!fclone) {
                        hinic3_undo_del_filter_entries(mac_filter_list,
                                                       &tmp_del_list);
                        hinic3_undo_add_filter_entries(mac_filter_list,
                                                       &tmp_add_list);

                        netdev_err(netdev,
                                   "Failed to clone mac_filter_entry\n");
                        err = -ENOMEM;
                        goto cleanup_tmp_filter_list;
                }

                f->state = HINIC3_MAC_HW_SYNCING;
                list_add_tail(&fclone->list, &tmp_add_list);
        }

        err = hinic3_mac_filter_sync_hw(netdev, &tmp_del_list,
                                        &tmp_add_list, &add_count);
        if (err) {
                /* there were errors, delete all mac in hw */
                hinic3_undo_add_filter_entries(mac_filter_list, &tmp_add_list);
                add_count = 0;
                /* VF does not support promiscuous mode,
                 * don't delete any other uc mac.
                 */
                if (!HINIC3_IS_VF(nic_dev->hwdev) || !uc) {
                        list_for_each_entry_safe(f, ftmp, mac_filter_list,
                                                 list) {
                                if (f->state != HINIC3_MAC_HW_SYNCED)
                                        continue;

                                fclone = hinic3_mac_filter_entry_clone(f);
                                if (!fclone)
                                        break;

                                f->state = HINIC3_MAC_WAIT_HW_SYNC;
                                list_add_tail(&fclone->list, &tmp_del_list);
                        }
                }

                hinic3_mac_filter_sync_hw(netdev, &tmp_del_list,
                                          &tmp_add_list, &add_count);
        }

cleanup_tmp_filter_list:
        hinic3_cleanup_filter_list(&tmp_del_list);
        hinic3_cleanup_filter_list(&tmp_add_list);

        return err ? err : add_count;
}

static void hinic3_mac_filter_sync_all(struct net_device *netdev)
{
        struct hinic3_nic_dev *nic_dev = netdev_priv(netdev);
        int add_count;

        if (test_bit(HINIC3_MAC_FILTER_CHANGED, &nic_dev->flags)) {
                clear_bit(HINIC3_MAC_FILTER_CHANGED, &nic_dev->flags);
                add_count = hinic3_mac_filter_sync(netdev,
                                                   &nic_dev->uc_filter_list,
                                                   true);
                if (add_count < 0 &&
                    hinic3_test_support(nic_dev, HINIC3_NIC_F_PROMISC))
                        set_bit(HINIC3_PROMISC_FORCE_ON,
                                &nic_dev->rx_mod_state);
                else if (add_count)
                        clear_bit(HINIC3_PROMISC_FORCE_ON,
                                  &nic_dev->rx_mod_state);

                add_count = hinic3_mac_filter_sync(netdev,
                                                   &nic_dev->mc_filter_list,
                                                   false);
                if (add_count < 0 &&
                    hinic3_test_support(nic_dev, HINIC3_NIC_F_ALLMULTI))
                        set_bit(HINIC3_ALLMULTI_FORCE_ON,
                                &nic_dev->rx_mod_state);
                else if (add_count)
                        clear_bit(HINIC3_ALLMULTI_FORCE_ON,
                                  &nic_dev->rx_mod_state);
        }
}

#define HINIC3_DEFAULT_RX_MODE \
        (L2NIC_RX_MODE_UC | L2NIC_RX_MODE_MC | L2NIC_RX_MODE_BC)

static void hinic3_update_mac_filter(struct net_device *netdev,
                                     const struct netdev_hw_addr_list *src_list,
                                     struct list_head *filter_list)
{
        struct hinic3_mac_filter *filter;
        struct hinic3_mac_filter *ftmp;
        struct hinic3_mac_filter *f;
        struct netdev_hw_addr *ha;

        /* add addr if not already in the filter list */
        netif_addr_lock_bh(netdev);
        netdev_hw_addr_list_for_each(ha, src_list) {
                filter = hinic3_find_mac(filter_list, ha->addr);
                if (!filter)
                        hinic3_add_filter(netdev, filter_list, ha->addr);
                else if (filter->state == HINIC3_MAC_WAIT_HW_UNSYNC)
                        filter->state = HINIC3_MAC_HW_SYNCED;
        }
        netif_addr_unlock_bh(netdev);

        /* delete addr if not in netdev list */
        list_for_each_entry_safe(f, ftmp, filter_list, list) {
                bool found = false;

                netif_addr_lock_bh(netdev);
                netdev_hw_addr_list_for_each(ha, src_list)
                        if (ether_addr_equal(ha->addr, f->addr)) {
                                found = true;
                                break;
                        }
                netif_addr_unlock_bh(netdev);

                if (found)
                        continue;

                hinic3_del_filter(netdev, f);
        }
}

static void hinic3_sync_rx_mode_to_hw(struct net_device *netdev, int promisc_en,
                                      int allmulti_en)
{
        struct hinic3_nic_dev *nic_dev = netdev_priv(netdev);
        u32 rx_mode = HINIC3_DEFAULT_RX_MODE;
        int err;

        rx_mode |= (promisc_en ? L2NIC_RX_MODE_PROMISC : 0);
        rx_mode |= (allmulti_en ? L2NIC_RX_MODE_MC_ALL : 0);

        if (promisc_en != test_bit(HINIC3_HW_PROMISC_ON,
                                   &nic_dev->rx_mod_state))
                netdev_dbg(netdev, "%s promisc mode\n",
                           promisc_en ? "Enter" : "Left");
        if (allmulti_en !=
            test_bit(HINIC3_HW_ALLMULTI_ON, &nic_dev->rx_mod_state))
                netdev_dbg(netdev, "%s all_multi mode\n",
                           allmulti_en ? "Enter" : "Left");

        err = hinic3_set_rx_mode(nic_dev->hwdev, rx_mode);
        if (err) {
                netdev_err(netdev, "Failed to set rx_mode\n");
                return;
        }

        promisc_en ? set_bit(HINIC3_HW_PROMISC_ON, &nic_dev->rx_mod_state) :
                clear_bit(HINIC3_HW_PROMISC_ON, &nic_dev->rx_mod_state);

        allmulti_en ? set_bit(HINIC3_HW_ALLMULTI_ON, &nic_dev->rx_mod_state) :
                clear_bit(HINIC3_HW_ALLMULTI_ON, &nic_dev->rx_mod_state);
}

void hinic3_set_rx_mode_work(struct work_struct *work)
{
        int promisc_en = 0, allmulti_en = 0;
        struct hinic3_nic_dev *nic_dev;
        struct net_device *netdev;

        nic_dev = container_of(work, struct hinic3_nic_dev, rx_mode_work);
        netdev = nic_dev->netdev;

        if (test_and_clear_bit(HINIC3_UPDATE_MAC_FILTER, &nic_dev->flags)) {
                hinic3_update_mac_filter(netdev, &netdev->uc,
                                         &nic_dev->uc_filter_list);
                hinic3_update_mac_filter(netdev, &netdev->mc,
                                         &nic_dev->mc_filter_list);
        }

        hinic3_mac_filter_sync_all(netdev);

        if (hinic3_test_support(nic_dev, HINIC3_NIC_F_PROMISC))
                promisc_en = !!(netdev->flags & IFF_PROMISC) ||
                        test_bit(HINIC3_PROMISC_FORCE_ON,
                                 &nic_dev->rx_mod_state);

        if (hinic3_test_support(nic_dev, HINIC3_NIC_F_ALLMULTI))
                allmulti_en = !!(netdev->flags & IFF_ALLMULTI) ||
                        test_bit(HINIC3_ALLMULTI_FORCE_ON,
                                 &nic_dev->rx_mod_state);

        if (promisc_en != test_bit(HINIC3_HW_PROMISC_ON,
                                   &nic_dev->rx_mod_state) ||
            allmulti_en != test_bit(HINIC3_HW_ALLMULTI_ON,
                                    &nic_dev->rx_mod_state))
                hinic3_sync_rx_mode_to_hw(netdev, promisc_en, allmulti_en);
}