// SPDX-License-Identifier: GPL-2.0-only
/****************************************************************************
 * Driver for Solarflare network controllers and boards
 * Copyright 2015 Solarflare Communications Inc.
 */
#include <linux/etherdevice.h>
#include <linux/pci.h>
#include <linux/module.h>
#include "net_driver.h"
#include "ef10_sriov.h"
#include "efx.h"
#include "nic.h"
#include "mcdi_pcol.h"

static int efx_ef10_evb_port_assign(struct efx_nic *efx, unsigned int port_id,
                                    unsigned int vf_fn)
{
        MCDI_DECLARE_BUF(inbuf, MC_CMD_EVB_PORT_ASSIGN_IN_LEN);
        struct efx_ef10_nic_data *nic_data = efx->nic_data;

        MCDI_SET_DWORD(inbuf, EVB_PORT_ASSIGN_IN_PORT_ID, port_id);
        MCDI_POPULATE_DWORD_2(inbuf, EVB_PORT_ASSIGN_IN_FUNCTION,
                              EVB_PORT_ASSIGN_IN_PF, nic_data->pf_index,
                              EVB_PORT_ASSIGN_IN_VF, vf_fn);

        return efx_mcdi_rpc(efx, MC_CMD_EVB_PORT_ASSIGN, inbuf, sizeof(inbuf),
                            NULL, 0, NULL);
}

static int efx_ef10_vswitch_alloc(struct efx_nic *efx, unsigned int port_id,
                                  unsigned int vswitch_type)
{
        MCDI_DECLARE_BUF(inbuf, MC_CMD_VSWITCH_ALLOC_IN_LEN);
        int rc;

        MCDI_SET_DWORD(inbuf, VSWITCH_ALLOC_IN_UPSTREAM_PORT_ID, port_id);
        MCDI_SET_DWORD(inbuf, VSWITCH_ALLOC_IN_TYPE, vswitch_type);
        MCDI_SET_DWORD(inbuf, VSWITCH_ALLOC_IN_NUM_VLAN_TAGS, 2);
        MCDI_POPULATE_DWORD_1(inbuf, VSWITCH_ALLOC_IN_FLAGS,
                              VSWITCH_ALLOC_IN_FLAG_AUTO_PORT, 0);

        /* Quietly try to allocate 2 VLAN tags */
        rc = efx_mcdi_rpc_quiet(efx, MC_CMD_VSWITCH_ALLOC, inbuf, sizeof(inbuf),
                                NULL, 0, NULL);

        /* If 2 VLAN tags is too many, revert to trying with 1 VLAN tags */
        if (rc == -EPROTO) {
                MCDI_SET_DWORD(inbuf, VSWITCH_ALLOC_IN_NUM_VLAN_TAGS, 1);
                rc = efx_mcdi_rpc(efx, MC_CMD_VSWITCH_ALLOC, inbuf,
                                  sizeof(inbuf), NULL, 0, NULL);
        } else if (rc) {
                efx_mcdi_display_error(efx, MC_CMD_VSWITCH_ALLOC,
                                       MC_CMD_VSWITCH_ALLOC_IN_LEN,
                                       NULL, 0, rc);
        }
        return rc;
}

static int efx_ef10_vswitch_free(struct efx_nic *efx, unsigned int port_id)
{
        MCDI_DECLARE_BUF(inbuf, MC_CMD_VSWITCH_FREE_IN_LEN);

        MCDI_SET_DWORD(inbuf, VSWITCH_FREE_IN_UPSTREAM_PORT_ID, port_id);

        return efx_mcdi_rpc(efx, MC_CMD_VSWITCH_FREE, inbuf, sizeof(inbuf),
                            NULL, 0, NULL);
}

static int efx_ef10_vport_alloc(struct efx_nic *efx,
                                unsigned int port_id_in,
                                unsigned int vport_type,
                                u16 vlan,
                                unsigned int *port_id_out)
{
        MCDI_DECLARE_BUF(inbuf, MC_CMD_VPORT_ALLOC_IN_LEN);
        MCDI_DECLARE_BUF(outbuf, MC_CMD_VPORT_ALLOC_OUT_LEN);
        size_t outlen;
        int rc;

        EFX_WARN_ON_PARANOID(!port_id_out);

        MCDI_SET_DWORD(inbuf, VPORT_ALLOC_IN_UPSTREAM_PORT_ID, port_id_in);
        MCDI_SET_DWORD(inbuf, VPORT_ALLOC_IN_TYPE, vport_type);
        MCDI_SET_DWORD(inbuf, VPORT_ALLOC_IN_NUM_VLAN_TAGS,
                       (vlan != EFX_EF10_NO_VLAN));
        MCDI_POPULATE_DWORD_1(inbuf, VPORT_ALLOC_IN_FLAGS,
                              VPORT_ALLOC_IN_FLAG_AUTO_PORT, 0);
        if (vlan != EFX_EF10_NO_VLAN)
                MCDI_POPULATE_DWORD_1(inbuf, VPORT_ALLOC_IN_VLAN_TAGS,
                                      VPORT_ALLOC_IN_VLAN_TAG_0, vlan);

        rc = efx_mcdi_rpc(efx, MC_CMD_VPORT_ALLOC, inbuf, sizeof(inbuf),
                          outbuf, sizeof(outbuf), &outlen);
        if (rc)
                return rc;
        if (outlen < MC_CMD_VPORT_ALLOC_OUT_LEN)
                return -EIO;

        *port_id_out = MCDI_DWORD(outbuf, VPORT_ALLOC_OUT_VPORT_ID);
        return 0;
}

static int efx_ef10_vport_free(struct efx_nic *efx, unsigned int port_id)
{
        MCDI_DECLARE_BUF(inbuf, MC_CMD_VPORT_FREE_IN_LEN);

        MCDI_SET_DWORD(inbuf, VPORT_FREE_IN_VPORT_ID, port_id);

        return efx_mcdi_rpc(efx, MC_CMD_VPORT_FREE, inbuf, sizeof(inbuf),
                            NULL, 0, NULL);
}

static void efx_ef10_sriov_free_vf_vports(struct efx_nic *efx)
{
        struct efx_ef10_nic_data *nic_data = efx->nic_data;
        int i;

        if (!nic_data->vf)
                return;

        for (i = 0; i < efx->vf_count; i++) {
                struct ef10_vf *vf = nic_data->vf + i;

                /* If VF is assigned, do not free the vport  */
                if (vf->pci_dev && pci_is_dev_assigned(vf->pci_dev))
                        continue;

                if (vf->vport_assigned) {
                        efx_ef10_evb_port_assign(efx, EVB_PORT_ID_NULL, i);
                        vf->vport_assigned = 0;
                }

                if (!is_zero_ether_addr(vf->mac)) {
                        efx_ef10_vport_del_mac(efx, vf->vport_id, vf->mac);
                        eth_zero_addr(vf->mac);
                }

                if (vf->vport_id) {
                        efx_ef10_vport_free(efx, vf->vport_id);
                        vf->vport_id = 0;
                }

                vf->efx = NULL;
        }
}

static void efx_ef10_sriov_free_vf_vswitching(struct efx_nic *efx)
{
        struct efx_ef10_nic_data *nic_data = efx->nic_data;

        efx_ef10_sriov_free_vf_vports(efx);
        kfree(nic_data->vf);
        nic_data->vf = NULL;
}

static int efx_ef10_sriov_assign_vf_vport(struct efx_nic *efx,
                                          unsigned int vf_i)
{
        struct efx_ef10_nic_data *nic_data = efx->nic_data;
        struct ef10_vf *vf = nic_data->vf + vf_i;
        int rc;

        if (WARN_ON_ONCE(!nic_data->vf))
                return -EOPNOTSUPP;

        rc = efx_ef10_vport_alloc(efx, EVB_PORT_ID_ASSIGNED,
                                  MC_CMD_VPORT_ALLOC_IN_VPORT_TYPE_NORMAL,
                                  vf->vlan, &vf->vport_id);
        if (rc)
                return rc;

        rc = efx_ef10_vport_add_mac(efx, vf->vport_id, vf->mac);
        if (rc) {
                eth_zero_addr(vf->mac);
                return rc;
        }

        rc =  efx_ef10_evb_port_assign(efx, vf->vport_id, vf_i);
        if (rc)
                return rc;

        vf->vport_assigned = 1;
        return 0;
}

static int efx_ef10_sriov_alloc_vf_vswitching(struct efx_nic *efx)
{
        struct efx_ef10_nic_data *nic_data = efx->nic_data;
        unsigned int i;
        int rc;

        nic_data->vf = kzalloc_objs(struct ef10_vf, efx->vf_count);
        if (!nic_data->vf)
                return -ENOMEM;

        for (i = 0; i < efx->vf_count; i++) {
                eth_random_addr(nic_data->vf[i].mac);
                nic_data->vf[i].efx = NULL;
                nic_data->vf[i].vlan = EFX_EF10_NO_VLAN;

                rc = efx_ef10_sriov_assign_vf_vport(efx, i);
                if (rc)
                        goto fail;
        }

        return 0;
fail:
        efx_ef10_sriov_free_vf_vswitching(efx);
        return rc;
}

static int efx_ef10_sriov_restore_vf_vswitching(struct efx_nic *efx)
{
        unsigned int i;
        int rc;

        for (i = 0; i < efx->vf_count; i++) {
                rc = efx_ef10_sriov_assign_vf_vport(efx, i);
                if (rc)
                        goto fail;
        }

        return 0;
fail:
        efx_ef10_sriov_free_vf_vswitching(efx);
        return rc;
}

static int efx_ef10_vadaptor_alloc_set_features(struct efx_nic *efx)
{
        u32 port_flags;
        int rc;

        rc = efx_ef10_vadaptor_alloc(efx, efx->vport_id);
        if (rc)
                goto fail_vadaptor_alloc;

        rc = efx_ef10_vadaptor_query(efx, efx->vport_id,
                                     &port_flags, NULL, NULL);
        if (rc)
                goto fail_vadaptor_query;

        if (port_flags &
            (1 << MC_CMD_VPORT_ALLOC_IN_FLAG_VLAN_RESTRICT_LBN))
                efx->fixed_features |= NETIF_F_HW_VLAN_CTAG_FILTER;
        else
                efx->fixed_features &= ~NETIF_F_HW_VLAN_CTAG_FILTER;

        return 0;

fail_vadaptor_query:
        efx_ef10_vadaptor_free(efx, EVB_PORT_ID_ASSIGNED);
fail_vadaptor_alloc:
        return rc;
}

/* On top of the default firmware vswitch setup, create a VEB vswitch and
 * expansion vport for use by this function.
 */
int efx_ef10_vswitching_probe_pf(struct efx_nic *efx)
{
        struct efx_ef10_nic_data *nic_data = efx->nic_data;
        struct net_device *net_dev = efx->net_dev;
        int rc;

        if (pci_sriov_get_totalvfs(efx->pci_dev) <= 0) {
                /* vswitch not needed as we have no VFs */
                efx_ef10_vadaptor_alloc_set_features(efx);
                return 0;
        }

        rc = efx_ef10_vswitch_alloc(efx, EVB_PORT_ID_ASSIGNED,
                                    MC_CMD_VSWITCH_ALLOC_IN_VSWITCH_TYPE_VEB);
        if (rc)
                goto fail1;

        rc = efx_ef10_vport_alloc(efx, EVB_PORT_ID_ASSIGNED,
                                  MC_CMD_VPORT_ALLOC_IN_VPORT_TYPE_NORMAL,
                                  EFX_EF10_NO_VLAN, &efx->vport_id);
        if (rc)
                goto fail2;

        rc = efx_ef10_vport_add_mac(efx, efx->vport_id, net_dev->dev_addr);
        if (rc)
                goto fail3;
        ether_addr_copy(nic_data->vport_mac, net_dev->dev_addr);

        rc = efx_ef10_vadaptor_alloc_set_features(efx);
        if (rc)
                goto fail4;

        return 0;
fail4:
        efx_ef10_vport_del_mac(efx, efx->vport_id, nic_data->vport_mac);
        eth_zero_addr(nic_data->vport_mac);
fail3:
        efx_ef10_vport_free(efx, efx->vport_id);
        efx->vport_id = EVB_PORT_ID_ASSIGNED;
fail2:
        efx_ef10_vswitch_free(efx, EVB_PORT_ID_ASSIGNED);
fail1:
        return rc;
}

int efx_ef10_vswitching_probe_vf(struct efx_nic *efx)
{
        return efx_ef10_vadaptor_alloc_set_features(efx);
}

int efx_ef10_vswitching_restore_pf(struct efx_nic *efx)
{
        struct efx_ef10_nic_data *nic_data = efx->nic_data;
        int rc;

        if (!nic_data->must_probe_vswitching)
                return 0;

        rc = efx_ef10_vswitching_probe_pf(efx);
        if (rc)
                goto fail;

        rc = efx_ef10_sriov_restore_vf_vswitching(efx);
        if (rc)
                goto fail;

        nic_data->must_probe_vswitching = false;
fail:
        return rc;
}

int efx_ef10_vswitching_restore_vf(struct efx_nic *efx)
{
        struct efx_ef10_nic_data *nic_data = efx->nic_data;
        int rc;

        if (!nic_data->must_probe_vswitching)
                return 0;

        rc = efx_ef10_vadaptor_free(efx, EVB_PORT_ID_ASSIGNED);
        if (rc)
                return rc;

        nic_data->must_probe_vswitching = false;
        return 0;
}

void efx_ef10_vswitching_remove_pf(struct efx_nic *efx)
{
        struct efx_ef10_nic_data *nic_data = efx->nic_data;

        efx_ef10_sriov_free_vf_vswitching(efx);

        efx_ef10_vadaptor_free(efx, efx->vport_id);

        if (efx->vport_id == EVB_PORT_ID_ASSIGNED)
                return; /* No vswitch was ever created */

        if (!is_zero_ether_addr(nic_data->vport_mac)) {
                efx_ef10_vport_del_mac(efx, efx->vport_id,
                                       efx->net_dev->dev_addr);
                eth_zero_addr(nic_data->vport_mac);
        }
        efx_ef10_vport_free(efx, efx->vport_id);
        efx->vport_id = EVB_PORT_ID_ASSIGNED;

        /* Only free the vswitch if no VFs are assigned */
        if (!pci_vfs_assigned(efx->pci_dev))
                efx_ef10_vswitch_free(efx, efx->vport_id);
}

void efx_ef10_vswitching_remove_vf(struct efx_nic *efx)
{
        efx_ef10_vadaptor_free(efx, EVB_PORT_ID_ASSIGNED);
}

static int efx_ef10_pci_sriov_enable(struct efx_nic *efx, int num_vfs)
{
        int rc = 0;
        struct pci_dev *dev = efx->pci_dev;

        efx->vf_count = num_vfs;

        rc = efx_ef10_sriov_alloc_vf_vswitching(efx);
        if (rc)
                goto fail1;

        rc = pci_enable_sriov(dev, num_vfs);
        if (rc)
                goto fail2;

        return 0;
fail2:
        efx_ef10_sriov_free_vf_vswitching(efx);
fail1:
        efx->vf_count = 0;
        netif_err(efx, probe, efx->net_dev,
                  "Failed to enable SRIOV VFs\n");
        return rc;
}

/* Disable SRIOV and remove VFs
 * If some VFs are attached to a guest (using Xen, only) nothing is
 * done if force=false, and vports are freed if force=true (for the non
 * attachedc ones, only) but SRIOV is not disabled and VFs are not
 * removed in either case.
 */
static int efx_ef10_pci_sriov_disable(struct efx_nic *efx, bool force)
{
        struct pci_dev *dev = efx->pci_dev;
        struct efx_ef10_nic_data *nic_data = efx->nic_data;
        unsigned int vfs_assigned = pci_vfs_assigned(dev);
        int i, rc = 0;

        if (vfs_assigned && !force) {
                netif_info(efx, drv, efx->net_dev, "VFs are assigned to guests; "
                           "please detach them before disabling SR-IOV\n");
                return -EBUSY;
        }

        if (!vfs_assigned) {
                for (i = 0; i < efx->vf_count; i++)
                        nic_data->vf[i].pci_dev = NULL;
                pci_disable_sriov(dev);
        } else {
                rc = -EBUSY;
        }

        efx_ef10_sriov_free_vf_vswitching(efx);
        efx->vf_count = 0;
        return rc;
}

int efx_ef10_sriov_configure(struct efx_nic *efx, int num_vfs)
{
        if (num_vfs == 0)
                return efx_ef10_pci_sriov_disable(efx, false);
        else
                return efx_ef10_pci_sriov_enable(efx, num_vfs);
}

int efx_ef10_sriov_init(struct efx_nic *efx)
{
        return 0;
}

void efx_ef10_sriov_fini(struct efx_nic *efx)
{
        struct efx_ef10_nic_data *nic_data = efx->nic_data;
        int rc;

        if (!nic_data->vf) {
                /* Remove any un-assigned orphaned VFs. This can happen if the PF driver
                 * was unloaded while any VF was assigned to a guest (using Xen, only).
                 */
                if (pci_num_vf(efx->pci_dev) && !pci_vfs_assigned(efx->pci_dev))
                        pci_disable_sriov(efx->pci_dev);
                return;
        }

        /* Disable SRIOV and remove any VFs in the host */
        rc = efx_ef10_pci_sriov_disable(efx, true);
        if (rc)
                netif_dbg(efx, drv, efx->net_dev,
                          "Disabling SRIOV was not successful rc=%d\n", rc);
        else
                netif_dbg(efx, drv, efx->net_dev, "SRIOV disabled\n");
}

static int efx_ef10_vport_del_vf_mac(struct efx_nic *efx, unsigned int port_id,
                                     u8 *mac)
{
        MCDI_DECLARE_BUF(inbuf, MC_CMD_VPORT_DEL_MAC_ADDRESS_IN_LEN);
        MCDI_DECLARE_BUF_ERR(outbuf);
        size_t outlen;
        int rc;

        MCDI_SET_DWORD(inbuf, VPORT_DEL_MAC_ADDRESS_IN_VPORT_ID, port_id);
        ether_addr_copy(MCDI_PTR(inbuf, VPORT_DEL_MAC_ADDRESS_IN_MACADDR), mac);

        rc = efx_mcdi_rpc(efx, MC_CMD_VPORT_DEL_MAC_ADDRESS, inbuf,
                          sizeof(inbuf), outbuf, sizeof(outbuf), &outlen);

        return rc;
}

int efx_ef10_sriov_set_vf_mac(struct efx_nic *efx, int vf_i, const u8 *mac)
{
        struct efx_ef10_nic_data *nic_data = efx->nic_data;
        struct ef10_vf *vf;
        int rc;

        if (!nic_data->vf)
                return -EOPNOTSUPP;

        if (vf_i >= efx->vf_count)
                return -EINVAL;
        vf = nic_data->vf + vf_i;

        if (vf->efx) {
                efx_device_detach_sync(vf->efx);
                efx_net_stop(vf->efx->net_dev);

                vf->efx->type->filter_table_remove(vf->efx);

                rc = efx_ef10_vadaptor_free(vf->efx, EVB_PORT_ID_ASSIGNED);
                if (rc)
                        return rc;
        }

        rc = efx_ef10_evb_port_assign(efx, EVB_PORT_ID_NULL, vf_i);
        if (rc)
                return rc;

        if (!is_zero_ether_addr(vf->mac)) {
                rc = efx_ef10_vport_del_vf_mac(efx, vf->vport_id, vf->mac);
                if (rc)
                        return rc;
        }

        if (!is_zero_ether_addr(mac)) {
                rc = efx_ef10_vport_add_mac(efx, vf->vport_id, mac);
                if (rc)
                        goto fail;

                if (vf->efx)
                        eth_hw_addr_set(vf->efx->net_dev, mac);
        }

        ether_addr_copy(vf->mac, mac);

        rc = efx_ef10_evb_port_assign(efx, vf->vport_id, vf_i);
        if (rc)
                goto fail;

        if (vf->efx) {
                /* VF cannot use the vport_id that the PF created */
                rc = efx_ef10_vadaptor_alloc(vf->efx, EVB_PORT_ID_ASSIGNED);
                if (rc)
                        return rc;
                vf->efx->type->filter_table_probe(vf->efx);
                efx_net_open(vf->efx->net_dev);
                efx_device_attach_if_not_resetting(vf->efx);
        }

        return 0;

fail:
        eth_zero_addr(vf->mac);
        return rc;
}

int efx_ef10_sriov_set_vf_vlan(struct efx_nic *efx, int vf_i, u16 vlan,
                               u8 qos)
{
        struct efx_ef10_nic_data *nic_data = efx->nic_data;
        struct ef10_vf *vf;
        u16 new_vlan;
        int rc = 0, rc2 = 0;

        if (vf_i >= efx->vf_count)
                return -EINVAL;
        if (qos != 0)
                return -EINVAL;

        vf = nic_data->vf + vf_i;

        new_vlan = (vlan == 0) ? EFX_EF10_NO_VLAN : vlan;
        if (new_vlan == vf->vlan)
                return 0;

        if (vf->efx) {
                efx_device_detach_sync(vf->efx);
                efx_net_stop(vf->efx->net_dev);

                mutex_lock(&vf->efx->mac_lock);
                vf->efx->type->filter_table_remove(vf->efx);

                rc = efx_ef10_vadaptor_free(vf->efx, EVB_PORT_ID_ASSIGNED);
                if (rc)
                        goto restore_filters;
        }

        if (vf->vport_assigned) {
                rc = efx_ef10_evb_port_assign(efx, EVB_PORT_ID_NULL, vf_i);
                if (rc) {
                        netif_warn(efx, drv, efx->net_dev,
                                   "Failed to change vlan on VF %d.\n", vf_i);
                        netif_warn(efx, drv, efx->net_dev,
                                   "This is likely because the VF is bound to a driver in a VM.\n");
                        netif_warn(efx, drv, efx->net_dev,
                                   "Please unload the driver in the VM.\n");
                        goto restore_vadaptor;
                }
                vf->vport_assigned = 0;
        }

        if (!is_zero_ether_addr(vf->mac)) {
                rc = efx_ef10_vport_del_mac(efx, vf->vport_id, vf->mac);
                if (rc)
                        goto restore_evb_port;
        }

        if (vf->vport_id) {
                rc = efx_ef10_vport_free(efx, vf->vport_id);
                if (rc)
                        goto restore_mac;
                vf->vport_id = 0;
        }

        /* Do the actual vlan change */
        vf->vlan = new_vlan;

        /* Restore everything in reverse order */
        rc = efx_ef10_vport_alloc(efx, EVB_PORT_ID_ASSIGNED,
                                  MC_CMD_VPORT_ALLOC_IN_VPORT_TYPE_NORMAL,
                                  vf->vlan, &vf->vport_id);
        if (rc)
                goto reset_nic_up_write;

restore_mac:
        if (!is_zero_ether_addr(vf->mac)) {
                rc2 = efx_ef10_vport_add_mac(efx, vf->vport_id, vf->mac);
                if (rc2) {
                        eth_zero_addr(vf->mac);
                        goto reset_nic_up_write;
                }
        }

restore_evb_port:
        rc2 = efx_ef10_evb_port_assign(efx, vf->vport_id, vf_i);
        if (rc2)
                goto reset_nic_up_write;
        else
                vf->vport_assigned = 1;

restore_vadaptor:
        if (vf->efx) {
                rc2 = efx_ef10_vadaptor_alloc(vf->efx, EVB_PORT_ID_ASSIGNED);
                if (rc2)
                        goto reset_nic_up_write;
        }

restore_filters:
        if (vf->efx) {
                rc2 = vf->efx->type->filter_table_probe(vf->efx);
                if (rc2)
                        goto reset_nic_up_write;

                mutex_unlock(&vf->efx->mac_lock);

                rc2 = efx_net_open(vf->efx->net_dev);
                if (rc2)
                        goto reset_nic;

                efx_device_attach_if_not_resetting(vf->efx);
        }
        return rc;

reset_nic_up_write:
        if (vf->efx)
                mutex_unlock(&vf->efx->mac_lock);
reset_nic:
        if (vf->efx) {
                netif_err(efx, drv, efx->net_dev,
                          "Failed to restore VF - scheduling reset.\n");
                efx_schedule_reset(vf->efx, RESET_TYPE_DATAPATH);
        } else {
                netif_err(efx, drv, efx->net_dev,
                          "Failed to restore the VF and cannot reset the VF "
                          "- VF is not functional.\n");
                netif_err(efx, drv, efx->net_dev,
                          "Please reload the driver attached to the VF.\n");
        }

        return rc ? rc : rc2;
}

static int efx_ef10_sriov_set_privilege_mask(struct efx_nic *efx, int vf_i,
                                             u32 mask, u32 value)
{
        MCDI_DECLARE_BUF(pm_outbuf, MC_CMD_PRIVILEGE_MASK_OUT_LEN);
        MCDI_DECLARE_BUF(pm_inbuf, MC_CMD_PRIVILEGE_MASK_IN_LEN);
        struct efx_ef10_nic_data *nic_data = efx->nic_data;
        u32 old_mask, new_mask;
        size_t outlen;
        int rc;

        EFX_WARN_ON_PARANOID((value & ~mask) != 0);

        /* Get privilege mask */
        MCDI_POPULATE_DWORD_2(pm_inbuf, PRIVILEGE_MASK_IN_FUNCTION,
                              PRIVILEGE_MASK_IN_FUNCTION_PF, nic_data->pf_index,
                              PRIVILEGE_MASK_IN_FUNCTION_VF, vf_i);

        rc = efx_mcdi_rpc(efx, MC_CMD_PRIVILEGE_MASK,
                          pm_inbuf, sizeof(pm_inbuf),
                          pm_outbuf, sizeof(pm_outbuf), &outlen);

        if (rc != 0)
                return rc;
        if (outlen != MC_CMD_PRIVILEGE_MASK_OUT_LEN)
                return -EIO;

        old_mask = MCDI_DWORD(pm_outbuf, PRIVILEGE_MASK_OUT_OLD_MASK);

        new_mask = old_mask & ~mask;
        new_mask |= value;

        if (new_mask == old_mask)
                return 0;

        new_mask |= MC_CMD_PRIVILEGE_MASK_IN_DO_CHANGE;

        /* Set privilege mask */
        MCDI_SET_DWORD(pm_inbuf, PRIVILEGE_MASK_IN_NEW_MASK, new_mask);

        rc = efx_mcdi_rpc(efx, MC_CMD_PRIVILEGE_MASK,
                          pm_inbuf, sizeof(pm_inbuf),
                          pm_outbuf, sizeof(pm_outbuf), &outlen);

        if (rc != 0)
                return rc;
        if (outlen != MC_CMD_PRIVILEGE_MASK_OUT_LEN)
                return -EIO;

        return 0;
}

int efx_ef10_sriov_set_vf_spoofchk(struct efx_nic *efx, int vf_i, bool spoofchk)
{
        struct efx_ef10_nic_data *nic_data = efx->nic_data;

        /* Can't enable spoofchk if firmware doesn't support it. */
        if (!(nic_data->datapath_caps &
              BIT(MC_CMD_GET_CAPABILITIES_OUT_TX_MAC_SECURITY_FILTERING_LBN)) &&
            spoofchk)
                return -EOPNOTSUPP;

        return efx_ef10_sriov_set_privilege_mask(efx, vf_i,
                MC_CMD_PRIVILEGE_MASK_IN_GRP_MAC_SPOOFING_TX,
                spoofchk ? 0 : MC_CMD_PRIVILEGE_MASK_IN_GRP_MAC_SPOOFING_TX);
}

int efx_ef10_sriov_set_vf_link_state(struct efx_nic *efx, int vf_i,
                                     int link_state)
{
        MCDI_DECLARE_BUF(inbuf, MC_CMD_LINK_STATE_MODE_IN_LEN);
        struct efx_ef10_nic_data *nic_data = efx->nic_data;

        BUILD_BUG_ON(IFLA_VF_LINK_STATE_AUTO !=
                     MC_CMD_LINK_STATE_MODE_IN_LINK_STATE_AUTO);
        BUILD_BUG_ON(IFLA_VF_LINK_STATE_ENABLE !=
                     MC_CMD_LINK_STATE_MODE_IN_LINK_STATE_UP);
        BUILD_BUG_ON(IFLA_VF_LINK_STATE_DISABLE !=
                     MC_CMD_LINK_STATE_MODE_IN_LINK_STATE_DOWN);
        MCDI_POPULATE_DWORD_2(inbuf, LINK_STATE_MODE_IN_FUNCTION,
                              LINK_STATE_MODE_IN_FUNCTION_PF,
                              nic_data->pf_index,
                              LINK_STATE_MODE_IN_FUNCTION_VF, vf_i);
        MCDI_SET_DWORD(inbuf, LINK_STATE_MODE_IN_NEW_MODE, link_state);
        return efx_mcdi_rpc(efx, MC_CMD_LINK_STATE_MODE, inbuf, sizeof(inbuf),
                            NULL, 0, NULL); /* don't care what old mode was */
}

int efx_ef10_sriov_get_vf_config(struct efx_nic *efx, int vf_i,
                                 struct ifla_vf_info *ivf)
{
        MCDI_DECLARE_BUF(inbuf, MC_CMD_LINK_STATE_MODE_IN_LEN);
        MCDI_DECLARE_BUF(outbuf, MC_CMD_LINK_STATE_MODE_OUT_LEN);

        struct efx_ef10_nic_data *nic_data = efx->nic_data;
        struct ef10_vf *vf;
        size_t outlen;
        int rc;

        if (vf_i >= efx->vf_count)
                return -EINVAL;

        if (!nic_data->vf)
                return -EOPNOTSUPP;

        vf = nic_data->vf + vf_i;

        ivf->vf = vf_i;
        ivf->min_tx_rate = 0;
        ivf->max_tx_rate = 0;
        ether_addr_copy(ivf->mac, vf->mac);
        ivf->vlan = (vf->vlan == EFX_EF10_NO_VLAN) ? 0 : vf->vlan;
        ivf->qos = 0;

        MCDI_POPULATE_DWORD_2(inbuf, LINK_STATE_MODE_IN_FUNCTION,
                              LINK_STATE_MODE_IN_FUNCTION_PF,
                              nic_data->pf_index,
                              LINK_STATE_MODE_IN_FUNCTION_VF, vf_i);
        MCDI_SET_DWORD(inbuf, LINK_STATE_MODE_IN_NEW_MODE,
                       MC_CMD_LINK_STATE_MODE_IN_DO_NOT_CHANGE);
        rc = efx_mcdi_rpc(efx, MC_CMD_LINK_STATE_MODE, inbuf, sizeof(inbuf),
                          outbuf, sizeof(outbuf), &outlen);
        if (rc)
                return rc;
        if (outlen < MC_CMD_LINK_STATE_MODE_OUT_LEN)
                return -EIO;
        ivf->linkstate = MCDI_DWORD(outbuf, LINK_STATE_MODE_OUT_OLD_MODE);

        return 0;
}