// SPDX-License-Identifier: GPL-2.0
/* Copyright (c) 2015 - 2025 Beijing WangXun Technology Co., Ltd. */

#include <linux/etherdevice.h>
#include <linux/pci.h>

#include "wx_type.h"
#include "wx_mbx.h"
#include "wx_lib.h"
#include "wx_vf.h"
#include "wx_vf_lib.h"
#include "wx_vf_common.h"

int wxvf_suspend(struct device *dev_d)
{
        struct pci_dev *pdev = to_pci_dev(dev_d);
        struct wx *wx = pci_get_drvdata(pdev);

        netif_device_detach(wx->netdev);
        wx_clear_interrupt_scheme(wx);
        pci_disable_device(pdev);

        return 0;
}
EXPORT_SYMBOL(wxvf_suspend);

void wxvf_shutdown(struct pci_dev *pdev)
{
        wxvf_suspend(&pdev->dev);
}
EXPORT_SYMBOL(wxvf_shutdown);

int wxvf_resume(struct device *dev_d)
{
        struct pci_dev *pdev = to_pci_dev(dev_d);
        struct wx *wx = pci_get_drvdata(pdev);

        pci_set_master(pdev);
        wx_init_interrupt_scheme(wx);
        netif_device_attach(wx->netdev);

        return 0;
}
EXPORT_SYMBOL(wxvf_resume);

void wxvf_remove(struct pci_dev *pdev)
{
        struct wx *wx = pci_get_drvdata(pdev);
        struct net_device *netdev;

        cancel_work_sync(&wx->service_task);
        netdev = wx->netdev;
        unregister_netdev(netdev);
        kfree(wx->vfinfo);
        kfree(wx->rss_key);
        kfree(wx->mac_table);
        wx_clear_interrupt_scheme(wx);
        pci_release_selected_regions(pdev,
                                     pci_select_bars(pdev, IORESOURCE_MEM));
        pci_disable_device(pdev);
}
EXPORT_SYMBOL(wxvf_remove);

static irqreturn_t wx_msix_misc_vf(int __always_unused irq, void *data)
{
        struct wx *wx = data;

        set_bit(WX_FLAG_NEED_UPDATE_LINK, wx->flags);
        /* Clear the interrupt */
        if (netif_running(wx->netdev))
                wr32(wx, WX_VXIMC, wx->eims_other);

        return IRQ_HANDLED;
}

int wx_request_msix_irqs_vf(struct wx *wx)
{
        struct net_device *netdev = wx->netdev;
        int vector, err;

        for (vector = 0; vector < wx->num_q_vectors; vector++) {
                struct wx_q_vector *q_vector = wx->q_vector[vector];
                struct msix_entry *entry = &wx->msix_q_entries[vector];

                if (q_vector->tx.ring && q_vector->rx.ring)
                        snprintf(q_vector->name, sizeof(q_vector->name) - 1,
                                 "%s-TxRx-%d", netdev->name, entry->entry);
                else
                        /* skip this unused q_vector */
                        continue;

                err = request_irq(entry->vector, wx_msix_clean_rings, 0,
                                  q_vector->name, q_vector);
                if (err) {
                        wx_err(wx, "request_irq failed for MSIX interrupt %s Error: %d\n",
                               q_vector->name, err);
                        goto free_queue_irqs;
                }
        }

        err = request_threaded_irq(wx->msix_entry->vector, wx_msix_misc_vf,
                                   NULL, IRQF_ONESHOT, netdev->name, wx);
        if (err) {
                wx_err(wx, "request_irq for msix_other failed: %d\n", err);
                goto free_queue_irqs;
        }

        return 0;

free_queue_irqs:
        while (vector) {
                vector--;
                free_irq(wx->msix_q_entries[vector].vector,
                         wx->q_vector[vector]);
        }
        wx_reset_interrupt_capability(wx);
        return err;
}
EXPORT_SYMBOL(wx_request_msix_irqs_vf);

void wx_negotiate_api_vf(struct wx *wx)
{
        int api[] = {
                     wx_mbox_api_13,
                     wx_mbox_api_null};
        int err = 0, idx = 0;

        spin_lock_bh(&wx->mbx.mbx_lock);
        while (api[idx] != wx_mbox_api_null) {
                err = wx_negotiate_api_version(wx, api[idx]);
                if (!err)
                        break;
                idx++;
        }
        spin_unlock_bh(&wx->mbx.mbx_lock);
}
EXPORT_SYMBOL(wx_negotiate_api_vf);

void wx_reset_vf(struct wx *wx)
{
        struct net_device *netdev = wx->netdev;
        int ret = 0;

        ret = wx_reset_hw_vf(wx);
        if (!ret)
                wx_init_hw_vf(wx);
        wx_negotiate_api_vf(wx);
        if (is_valid_ether_addr(wx->mac.addr)) {
                eth_hw_addr_set(netdev, wx->mac.addr);
                ether_addr_copy(netdev->perm_addr, wx->mac.addr);
        }
}
EXPORT_SYMBOL(wx_reset_vf);

void wx_set_rx_mode_vf(struct net_device *netdev)
{
        struct wx *wx = netdev_priv(netdev);
        unsigned int flags = netdev->flags;
        int xcast_mode;

        xcast_mode = (flags & IFF_ALLMULTI) ? WXVF_XCAST_MODE_ALLMULTI :
                     (flags & (IFF_BROADCAST | IFF_MULTICAST)) ?
                     WXVF_XCAST_MODE_MULTI : WXVF_XCAST_MODE_NONE;
        /* request the most inclusive mode we need */
        if (flags & IFF_PROMISC)
                xcast_mode = WXVF_XCAST_MODE_PROMISC;
        else if (flags & IFF_ALLMULTI)
                xcast_mode = WXVF_XCAST_MODE_ALLMULTI;
        else if (flags & (IFF_BROADCAST | IFF_MULTICAST))
                xcast_mode = WXVF_XCAST_MODE_MULTI;
        else
                xcast_mode = WXVF_XCAST_MODE_NONE;

        spin_lock_bh(&wx->mbx.mbx_lock);
        wx_update_xcast_mode_vf(wx, xcast_mode);
        wx_update_mc_addr_list_vf(wx, netdev);
        wx_write_uc_addr_list_vf(netdev);
        spin_unlock_bh(&wx->mbx.mbx_lock);
}
EXPORT_SYMBOL(wx_set_rx_mode_vf);

/**
 * wx_configure_rx_vf - Configure Receive Unit after Reset
 * @wx: board private structure
 *
 * Configure the Rx unit of the MAC after a reset.
 **/
static void wx_configure_rx_vf(struct wx *wx)
{
        struct net_device *netdev = wx->netdev;
        int i, ret;

        wx_setup_psrtype_vf(wx);
        wx_setup_vfmrqc_vf(wx);

        spin_lock_bh(&wx->mbx.mbx_lock);
        ret = wx_rlpml_set_vf(wx,
                              netdev->mtu + ETH_HLEN + ETH_FCS_LEN + VLAN_HLEN);
        spin_unlock_bh(&wx->mbx.mbx_lock);
        if (ret)
                wx_dbg(wx, "Failed to set MTU at %d\n", netdev->mtu);

        /* Setup the HW Rx Head and Tail Descriptor Pointers and
         * the Base and Length of the Rx Descriptor Ring
         */
        for (i = 0; i < wx->num_rx_queues; i++) {
                struct wx_ring *rx_ring = wx->rx_ring[i];
#ifdef HAVE_SWIOTLB_SKIP_CPU_SYNC
                wx_set_rx_buffer_len_vf(wx, rx_ring);
#endif
                wx_configure_rx_ring_vf(wx, rx_ring);
        }
}

void wx_configure_vf(struct wx *wx)
{
        wx_set_rx_mode_vf(wx->netdev);
        wx_configure_tx_vf(wx);
        wx_configure_rx_vf(wx);
}
EXPORT_SYMBOL(wx_configure_vf);

int wx_set_mac_vf(struct net_device *netdev, void *p)
{
        struct wx *wx = netdev_priv(netdev);
        struct sockaddr *addr = p;
        int ret;

        ret = eth_prepare_mac_addr_change(netdev, addr);
        if (ret)
                return ret;

        spin_lock_bh(&wx->mbx.mbx_lock);
        ret = wx_set_rar_vf(wx, 1, (u8 *)addr->sa_data, 1);
        spin_unlock_bh(&wx->mbx.mbx_lock);

        if (ret)
                return -EPERM;

        memcpy(wx->mac.addr, addr->sa_data, netdev->addr_len);
        memcpy(wx->mac.perm_addr, addr->sa_data, netdev->addr_len);
        eth_hw_addr_set(netdev, addr->sa_data);

        return 0;
}
EXPORT_SYMBOL(wx_set_mac_vf);

void wxvf_watchdog_update_link(struct wx *wx)
{
        int err;

        if (!test_bit(WX_FLAG_NEED_UPDATE_LINK, wx->flags))
                return;

        spin_lock_bh(&wx->mbx.mbx_lock);
        err = wx_check_mac_link_vf(wx);
        spin_unlock_bh(&wx->mbx.mbx_lock);
        if (err) {
                wx->link = false;
                set_bit(WX_FLAG_NEED_DO_RESET, wx->flags);
        }
        clear_bit(WX_FLAG_NEED_UPDATE_LINK, wx->flags);
}
EXPORT_SYMBOL(wxvf_watchdog_update_link);

static void wxvf_irq_enable(struct wx *wx)
{
        wr32(wx, WX_VXIMC, wx->eims_enable_mask);
}

static void wxvf_up_complete(struct wx *wx)
{
        /* Always set the carrier off */
        netif_carrier_off(wx->netdev);
        mod_timer(&wx->service_timer, jiffies + HZ);
        set_bit(WX_FLAG_NEED_UPDATE_LINK, wx->flags);

        wx_configure_msix_vf(wx);
        smp_mb__before_atomic();
        wx_napi_enable_all(wx);

        /* clear any pending interrupts, may auto mask */
        wr32(wx, WX_VXICR, U32_MAX);
        wxvf_irq_enable(wx);
        /* enable transmits */
        netif_tx_start_all_queues(wx->netdev);
}

int wxvf_open(struct net_device *netdev)
{
        struct wx *wx = netdev_priv(netdev);
        int err;

        err = wx_setup_resources(wx);
        if (err)
                goto err_reset;
        wx_configure_vf(wx);

        err = wx_request_msix_irqs_vf(wx);
        if (err)
                goto err_free_resources;

        /* Notify the stack of the actual queue counts. */
        err = netif_set_real_num_tx_queues(netdev, wx->num_tx_queues);
        if (err)
                goto err_free_irq;

        err = netif_set_real_num_rx_queues(netdev, wx->num_rx_queues);
        if (err)
                goto err_free_irq;

        wxvf_up_complete(wx);

        return 0;
err_free_irq:
        wx_free_irq(wx);
err_free_resources:
        wx_free_resources(wx);
err_reset:
        wx_reset_vf(wx);
        return err;
}
EXPORT_SYMBOL(wxvf_open);

static void wxvf_down(struct wx *wx)
{
        struct net_device *netdev = wx->netdev;

        timer_delete_sync(&wx->service_timer);
        netif_tx_stop_all_queues(netdev);
        netif_tx_disable(netdev);
        netif_carrier_off(netdev);
        wx_napi_disable_all(wx);
        wx_reset_vf(wx);

        wx_clean_all_tx_rings(wx);
        wx_clean_all_rx_rings(wx);
}

static void wxvf_reinit_locked(struct wx *wx)
{
        while (test_and_set_bit(WX_STATE_RESETTING, wx->state))
                usleep_range(1000, 2000);
        wxvf_down(wx);
        wx_free_irq(wx);
        wx_configure_vf(wx);
        wx_request_msix_irqs_vf(wx);
        wxvf_up_complete(wx);
        clear_bit(WX_STATE_RESETTING, wx->state);
}

static void wxvf_reset_subtask(struct wx *wx)
{
        if (!test_bit(WX_FLAG_NEED_DO_RESET, wx->flags))
                return;
        clear_bit(WX_FLAG_NEED_DO_RESET, wx->flags);

        rtnl_lock();
        if (test_bit(WX_STATE_RESETTING, wx->state) ||
            !(netif_running(wx->netdev))) {
                rtnl_unlock();
                return;
        }
        wxvf_reinit_locked(wx);
        rtnl_unlock();
}

int wxvf_close(struct net_device *netdev)
{
        struct wx *wx = netdev_priv(netdev);

        wxvf_down(wx);
        wx_free_irq(wx);
        wx_free_resources(wx);

        return 0;
}
EXPORT_SYMBOL(wxvf_close);

static void wxvf_link_config_subtask(struct wx *wx)
{
        struct net_device *netdev = wx->netdev;

        wxvf_watchdog_update_link(wx);
        if (wx->link) {
                if (netif_carrier_ok(netdev))
                        return;
                netif_carrier_on(netdev);
                netdev_info(netdev, "Link is Up - %s\n",
                            phy_speed_to_str(wx->speed));
        } else {
                if (!netif_carrier_ok(netdev))
                        return;
                netif_carrier_off(netdev);
                netdev_info(netdev, "Link is Down\n");
        }
}

static void wxvf_service_task(struct work_struct *work)
{
        struct wx *wx = container_of(work, struct wx, service_task);

        wxvf_link_config_subtask(wx);
        wxvf_reset_subtask(wx);
        wx_service_event_complete(wx);
}

void wxvf_init_service(struct wx *wx)
{
        timer_setup(&wx->service_timer, wx_service_timer, 0);
        INIT_WORK(&wx->service_task, wxvf_service_task);
        clear_bit(WX_STATE_SERVICE_SCHED, wx->state);
}
EXPORT_SYMBOL(wxvf_init_service);