/* SPDX-License-Identifier: BSD-3-Clause */
/*  Copyright (c) 2025, Intel Corporation
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *   1. Redistributions of source code must retain the above copyright notice,
 *      this list of conditions and the following disclaimer.
 *
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *
 *   3. Neither the name of the Intel Corporation nor the names of its
 *      contributors may be used to endorse or promote products derived from
 *      this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 */

/**
 * @file ice_iov.c
 * @brief Virtualization support functions
 *
 * Contains functions for enabling and managing PCIe virtual function devices,
 * including enabling new VFs, and managing VFs over the virtchnl interface.
 */

#include "ice_iov.h"

static struct ice_vf *ice_iov_get_vf(struct ice_softc *sc, int vf_num);
static void ice_iov_ready_vf(struct ice_softc *sc, struct ice_vf *vf);
static void ice_reset_vf(struct ice_softc *sc, struct ice_vf *vf,
			 bool trigger_vflr);
static void ice_iov_setup_intr_mapping(struct ice_softc *sc, struct ice_vf *vf);

static void ice_vc_version_msg(struct ice_softc *sc, struct ice_vf *vf,
			       u8 *msg_buf);
static void ice_vc_get_vf_res_msg(struct ice_softc *sc, struct ice_vf *vf,
				  u8 *msg_buf);
static void ice_vc_add_eth_addr_msg(struct ice_softc *sc, struct ice_vf *vf,
				    u8 *msg_buf);
static void ice_vc_del_eth_addr_msg(struct ice_softc *sc, struct ice_vf *vf,
				    u8 *msg_buf);
static bool ice_vc_isvalid_ring_len(u16 ring_len);
static void ice_vc_cfg_vsi_qs_msg(struct ice_softc *sc, struct ice_vf *vf,
				  u8 *msg_buf);
static void ice_vc_cfg_rss_key_msg(struct ice_softc *sc, struct ice_vf *vf,
				   u8 *msg_buf);
static void ice_vc_set_rss_hena_msg(struct ice_softc *sc, struct ice_vf *vf,
				    u8 *msg_buf);
static void ice_vc_enable_queues_msg(struct ice_softc *sc, struct ice_vf *vf,
				     u8 *msg_buf);
static void ice_vc_notify_vf_link_state(struct ice_softc *sc, struct ice_vf *vf);
static void ice_vc_disable_queues_msg(struct ice_softc *sc, struct ice_vf *vf,
				      u8 *msg_buf);
static void ice_vc_cfg_irq_map_msg(struct ice_softc *sc, struct ice_vf *vf,
				   u8 *msg_buf);
static void ice_vc_get_stats_msg(struct ice_softc *sc, struct ice_vf *vf,
				 u8 *msg_buf);
static void ice_eth_stats_to_virtchnl_eth_stats(struct ice_eth_stats *istats,
     struct virtchnl_eth_stats *vstats);
static void ice_vc_cfg_rss_lut_msg(struct ice_softc *sc, struct ice_vf *vf,
				   u8 *msg_buf);
static void ice_vc_cfg_promisc_mode_msg(struct ice_softc *sc, struct ice_vf *vf,
				        u8 *msg_buf);
static void ice_vc_add_vlan_msg(struct ice_softc *sc, struct ice_vf *vf,
				u8 *msg_buf);
static void ice_vc_del_vlan_msg(struct ice_softc *sc, struct ice_vf *vf,
				u8 *msg_buf);
static enum virtchnl_status_code ice_iov_err_to_virt_err(int ice_err);
static int ice_vf_validate_mac(struct ice_vf *vf, const uint8_t *addr);

/**
 * ice_iov_attach - Initialize SR-IOV PF host support
 * @sc: device softc structure
 *
 * Initialize SR-IOV PF host support at the end of the driver attach process.
 *
 * @pre Must be called from sleepable context (calls malloc() w/ M_WAITOK)
 *
 * @returns 0 if successful, or
 * - ENOMEM if there is no memory for the PF/VF schemas or iov device
 * - ENXIO if the device isn't PCI-E or doesn't support the same SR-IOV
 *   version as the kernel
 * - ENOENT if the device doesn't have the SR-IOV capability
 */
int
ice_iov_attach(struct ice_softc *sc)
{
	device_t dev = sc->dev;
	nvlist_t *pf_schema, *vf_schema;
	int error;

	pf_schema = pci_iov_schema_alloc_node();
	vf_schema = pci_iov_schema_alloc_node();

	pci_iov_schema_add_unicast_mac(vf_schema, "mac-addr", 0, NULL);
	pci_iov_schema_add_bool(vf_schema, "mac-anti-spoof",
	    IOV_SCHEMA_HASDEFAULT, TRUE);
	pci_iov_schema_add_bool(vf_schema, "allow-set-mac",
	    IOV_SCHEMA_HASDEFAULT, FALSE);
	pci_iov_schema_add_bool(vf_schema, "allow-promisc",
	    IOV_SCHEMA_HASDEFAULT, FALSE);
	pci_iov_schema_add_uint16(vf_schema, "num-queues",
	    IOV_SCHEMA_HASDEFAULT, ICE_DEFAULT_VF_QUEUES);
	pci_iov_schema_add_uint16(vf_schema, "mirror-src-vsi",
	    IOV_SCHEMA_HASDEFAULT, ICE_INVALID_MIRROR_VSI);
	pci_iov_schema_add_uint16(vf_schema, "max-vlan-allowed",
	    IOV_SCHEMA_HASDEFAULT, ICE_DEFAULT_VF_VLAN_LIMIT);
	pci_iov_schema_add_uint16(vf_schema, "max-mac-filters",
	    IOV_SCHEMA_HASDEFAULT, ICE_DEFAULT_VF_FILTER_LIMIT);

	error = pci_iov_attach(dev, pf_schema, vf_schema);
	if (error != 0) {
		device_printf(dev,
		    "pci_iov_attach failed (error=%s)\n",
		    ice_err_str(error));
		ice_clear_bit(ICE_FEATURE_SRIOV, sc->feat_en);
	} else
		ice_set_bit(ICE_FEATURE_SRIOV, sc->feat_en);

	return (error);
}

/**
 * ice_iov_detach - Teardown SR-IOV PF host support
 * @sc: device softc structure
 *
 * Teardown SR-IOV PF host support at the start of the driver detach process.
 *
 * @returns 0 if successful or IOV support hasn't been setup, or
 * - EBUSY if VFs still exist
 */
int
ice_iov_detach(struct ice_softc *sc)
{
	device_t dev = sc->dev;
	int error;

	error = pci_iov_detach(dev);
	if (error != 0) {
		device_printf(dev,
		    "pci_iov_detach failed (error=%s)\n",
		    ice_err_str(error));
	}

	return (error);
}

/**
 * ice_iov_init - Called by the OS before the first VF is created.
 * @sc: device softc structure
 * @num_vfs: number of VFs to setup resources for
 * @params: configuration parameters for the PF
 *
 * @returns 0 if successful or an error code on failure
 */
int
ice_iov_init(struct ice_softc *sc, uint16_t num_vfs, const nvlist_t *params __unused)
{
	/* Allocate array of VFs, for tracking */
	sc->vfs = (struct ice_vf *)malloc(sizeof(struct ice_vf) * num_vfs, M_ICE, M_NOWAIT |
	    M_ZERO);
	if (sc->vfs == NULL)
		return (ENOMEM);

	/* Initialize each VF with basic information */
	for (int i = 0; i < num_vfs; i++)
		sc->vfs[i].vf_num = i;

	/* Save off number of configured VFs */
	sc->num_vfs = num_vfs;

	return (0);
}

/**
 * ice_iov_get_vf - Get pointer to VF at given index
 * @sc: device softc structure
 * @vf_num: Index of VF to retrieve
 *
 * @remark will throw an assertion if vf_num is not in the
 * range of allocated VFs
 *
 * @returns a pointer to the VF structure at the given index
 */
static struct ice_vf *
ice_iov_get_vf(struct ice_softc *sc, int vf_num)
{
	MPASS(vf_num < sc->num_vfs);

	return &sc->vfs[vf_num];
}

/**
 * ice_iov_add_vf - Called by the OS for each VF to create
 * @sc: device softc structure
 * @vfnum: index of VF to configure
 * @params: configuration parameters for the VF
 *
 * @returns 0 if successful or an error code on failure
 */
int
ice_iov_add_vf(struct ice_softc *sc, uint16_t vfnum, const nvlist_t *params)
{
	struct ice_tx_queue *txq;
	struct ice_rx_queue *rxq;
	device_t dev = sc->dev;
	struct ice_vsi *vsi;
	struct ice_vf *vf;
	int vf_num_queues;
	const void *mac;
	size_t size;
	int error;
	int i;

	vf = ice_iov_get_vf(sc, vfnum);
	vf->vf_flags = VF_FLAG_ENABLED;

	/* This VF needs at least one VSI */
	vsi = ice_alloc_vsi(sc, ICE_VSI_VF);
	if (vsi == NULL)
		return (ENOMEM);
	vf->vsi = vsi;
	vsi->vf_num = vfnum;

	vf_num_queues = nvlist_get_number(params, "num-queues");
	/* Validate and clamp value if invalid */
	if (vf_num_queues < 1 || vf_num_queues > ICE_MAX_SCATTERED_QUEUES)
		device_printf(dev, "Invalid num-queues (%d) for VF %d\n",
		    vf_num_queues, vf->vf_num);
	if (vf_num_queues < 1) {
		device_printf(dev, "Setting VF %d num-queues to 1\n", vf->vf_num);
		vf_num_queues = 1;
	} else if (vf_num_queues > ICE_MAX_SCATTERED_QUEUES) {
		device_printf(dev, "Setting VF %d num-queues to %d\n",
		    vf->vf_num, ICE_MAX_SCATTERED_QUEUES);
		vf_num_queues = ICE_MAX_SCATTERED_QUEUES;
	}
	vsi->qmap_type = ICE_RESMGR_ALLOC_SCATTERED;

	/* Reserve VF queue allocation from PF queues */
	ice_alloc_vsi_qmap(vsi, vf_num_queues, vf_num_queues);
	vsi->num_tx_queues = vsi->num_rx_queues = vf_num_queues;

	/* Assign Tx queues from PF space */
	error = ice_resmgr_assign_scattered(&sc->tx_qmgr, vsi->tx_qmap,
					     vsi->num_tx_queues);
	if (error) {
		device_printf(sc->dev, "Unable to assign VF Tx queues: %s\n",
			      ice_err_str(error));
		goto release_vsi;
	}

	/* Assign Rx queues from PF space */
	error = ice_resmgr_assign_scattered(&sc->rx_qmgr, vsi->rx_qmap,
					     vsi->num_rx_queues);
	if (error) {
		device_printf(sc->dev, "Unable to assign VF Rx queues: %s\n",
			      ice_err_str(error));
		goto release_vsi;
	}

	vsi->max_frame_size = ICE_MAX_FRAME_SIZE;

	/* Allocate queue structure memory */
	vsi->tx_queues = (struct ice_tx_queue *)
	    malloc(sizeof(struct ice_tx_queue) * vsi->num_tx_queues, M_ICE,
		   M_NOWAIT | M_ZERO);
	if (!vsi->tx_queues) {
		device_printf(sc->dev, "VF-%d: Unable to allocate Tx queue memory\n",
			      vfnum);
		error = ENOMEM;
		goto release_vsi;
	}
	for (i = 0, txq = vsi->tx_queues; i < vsi->num_tx_queues; i++, txq++) {
		txq->me = i;
		txq->vsi = vsi;
	}

	/* Allocate queue structure memory */
	vsi->rx_queues = (struct ice_rx_queue *)
	    malloc(sizeof(struct ice_rx_queue) * vsi->num_rx_queues, M_ICE,
		   M_NOWAIT | M_ZERO);
	if (!vsi->rx_queues) {
		device_printf(sc->dev, "VF-%d: Unable to allocate Rx queue memory\n",
			      vfnum);
		error = ENOMEM;
		goto free_txqs;
	}
	for (i = 0, rxq = vsi->rx_queues; i < vsi->num_rx_queues; i++, rxq++) {
		rxq->me = i;
		rxq->vsi = vsi;
	}

	/* Allocate space to store the IRQ vector data */
	vf->num_irq_vectors = vf_num_queues + 1;
	vf->tx_irqvs = (struct ice_irq_vector *)
	    malloc(sizeof(struct ice_irq_vector) * (vf->num_irq_vectors),
		   M_ICE, M_NOWAIT);
	if (!vf->tx_irqvs) {
		device_printf(sc->dev,
			      "Unable to allocate TX irqv memory for VF-%d's %d vectors\n",
			      vfnum, vf->num_irq_vectors);
		error = ENOMEM;
		goto free_rxqs;
	}
	vf->rx_irqvs = (struct ice_irq_vector *)
	    malloc(sizeof(struct ice_irq_vector) * (vf->num_irq_vectors),
		   M_ICE, M_NOWAIT);
	if (!vf->rx_irqvs) {
		device_printf(sc->dev,
			      "Unable to allocate RX irqv memory for VF-%d's %d vectors\n",
			      vfnum, vf->num_irq_vectors);
		error = ENOMEM;
		goto free_txirqvs;
	}

	/* Assign VF interrupts from PF space */
	if (!(vf->vf_imap =
	      (u16 *)malloc(sizeof(u16) * vf->num_irq_vectors,
	      M_ICE, M_NOWAIT))) {
		device_printf(dev, "Unable to allocate VF-%d imap memory\n", vfnum);
		error = ENOMEM;
		goto free_rxirqvs;
	}
	error = ice_resmgr_assign_contiguous(&sc->dev_imgr, vf->vf_imap, vf->num_irq_vectors);
	if (error) {
		device_printf(dev, "Unable to assign VF-%d interrupt mapping: %s\n",
			      vfnum, ice_err_str(error));
		goto free_imap;
	}

	if (nvlist_exists_binary(params, "mac-addr")) {
		mac = nvlist_get_binary(params, "mac-addr", &size);
		memcpy(vf->mac, mac, ETHER_ADDR_LEN);

		if (nvlist_get_bool(params, "allow-set-mac"))
			vf->vf_flags |= VF_FLAG_SET_MAC_CAP;
	} else
		/*
		 * If the administrator has not specified a MAC address then
		 * we must allow the VF to choose one.
		 */
		vf->vf_flags |= VF_FLAG_SET_MAC_CAP;

	if (nvlist_get_bool(params, "mac-anti-spoof"))
		vf->vf_flags |= VF_FLAG_MAC_ANTI_SPOOF;

	if (nvlist_get_bool(params, "allow-promisc"))
		vf->vf_flags |= VF_FLAG_PROMISC_CAP;

	vsi->mirror_src_vsi = nvlist_get_number(params, "mirror-src-vsi");

	vf->vlan_limit = nvlist_get_number(params, "max-vlan-allowed");
	vf->mac_filter_limit = nvlist_get_number(params, "max-mac-filters");

	vf->vf_flags |= VF_FLAG_VLAN_CAP;

	/* Create and setup VSI in HW */
	error = ice_initialize_vsi(vsi);
	if (error) {
		device_printf(sc->dev, "Unable to initialize VF %d VSI: %s\n",
			      vfnum, ice_err_str(error));
		goto release_imap;
	}

	/* Add the broadcast address */
	error = ice_add_vsi_mac_filter(vsi, broadcastaddr);
	if (error) {
		device_printf(sc->dev, "Unable to add broadcast filter VF %d VSI: %s\n",
			      vfnum, ice_err_str(error));
		goto release_imap;
	}

	ice_iov_ready_vf(sc, vf);

	return (0);

release_imap:
	ice_resmgr_release_map(&sc->dev_imgr, vf->vf_imap,
			       vf->num_irq_vectors);
free_imap:
	free(vf->vf_imap, M_ICE);
	vf->vf_imap = NULL;
free_rxirqvs:
	free(vf->rx_irqvs, M_ICE);
	vf->rx_irqvs = NULL;
free_txirqvs:
	free(vf->tx_irqvs, M_ICE);
	vf->tx_irqvs = NULL;
free_rxqs:
	free(vsi->rx_queues, M_ICE);
	vsi->rx_queues = NULL;
free_txqs:
	free(vsi->tx_queues, M_ICE);
	vsi->tx_queues = NULL;
release_vsi:
	ice_release_vsi(vsi);
	vf->vsi = NULL;
	return (error);
}

/**
 * ice_iov_uninit - Called by the OS when VFs are destroyed
 * @sc: device softc structure
 */
void
ice_iov_uninit(struct ice_softc *sc)
{
	struct ice_vf *vf;
	struct ice_vsi *vsi;

	/* Release per-VF resources */
	for (int i = 0; i < sc->num_vfs; i++) {
		vf = &sc->vfs[i];
		vsi = vf->vsi;

		/* Free VF interrupt reservation */
		if (vf->vf_imap) {
			free(vf->vf_imap, M_ICE);
			vf->vf_imap = NULL;
		}

		/* Free queue interrupt mapping trackers */
		if (vf->tx_irqvs) {
			free(vf->tx_irqvs, M_ICE);
			vf->tx_irqvs = NULL;
		}
		if (vf->rx_irqvs) {
			free(vf->rx_irqvs, M_ICE);
			vf->rx_irqvs = NULL;
		}

		if (!vsi)
			continue;

		/* Free VSI queues */
		if (vsi->tx_queues) {
			free(vsi->tx_queues, M_ICE);
			vsi->tx_queues = NULL;
		}
		if (vsi->rx_queues) {
			free(vsi->rx_queues, M_ICE);
			vsi->rx_queues = NULL;
		}

		ice_release_vsi(vsi);
		vf->vsi = NULL;
	}

	/* Release memory used for VF tracking */
	if (sc->vfs) {
		free(sc->vfs, M_ICE);
		sc->vfs = NULL;
	}
	sc->num_vfs = 0;
}

/**
 * ice_iov_handle_vflr - Process VFLR event
 * @sc: device softc structure
 *
 * Identifys which VFs have been reset and re-configure
 * them.
 */
void
ice_iov_handle_vflr(struct ice_softc *sc)
{
	struct ice_hw *hw = &sc->hw;
	struct ice_vf *vf;
	u32 reg, reg_idx, bit_idx;

	for (int i = 0; i < sc->num_vfs; i++) {
		vf = &sc->vfs[i];

		reg_idx = (hw->func_caps.vf_base_id + vf->vf_num) / 32;
		bit_idx = (hw->func_caps.vf_base_id + vf->vf_num) % 32;
		reg = rd32(hw, GLGEN_VFLRSTAT(reg_idx));
		if (reg & BIT(bit_idx))
			ice_reset_vf(sc, vf, false);
	}
}

/**
 * ice_iov_ready_vf - Setup VF interrupts and mark it as ready
 * @sc: device softc structure
 * @vf: driver's VF structure for the VF to update
 *
 * Clears VF reset triggering bit, sets up the PF<->VF interrupt
 * mapping and marks the VF as active in the HW so that the VF
 * driver can use it.
 */
static void
ice_iov_ready_vf(struct ice_softc *sc, struct ice_vf *vf)
{
	struct ice_hw *hw = &sc->hw;
	u32 reg;

	/* Clear the triggering bit */
	reg = rd32(hw, VPGEN_VFRTRIG(vf->vf_num));
	reg &= ~VPGEN_VFRTRIG_VFSWR_M;
	wr32(hw, VPGEN_VFRTRIG(vf->vf_num), reg);

	/* Setup VF interrupt allocation and mapping */
	ice_iov_setup_intr_mapping(sc, vf);

	/* Indicate to the VF that reset is done */
	wr32(hw, VFGEN_RSTAT(vf->vf_num), VIRTCHNL_VFR_VFACTIVE);

	ice_flush(hw);
}

/**
 * ice_reset_vf - Perform a hardware reset (VFR) on a VF
 * @sc: device softc structure
 * @vf: driver's VF structure for VF to be reset
 * @trigger_vflr: trigger a reset or only handle already executed reset
 *
 * Performs a VFR for the given VF. This function busy waits until the
 * reset completes in the HW, notifies the VF that the reset is done
 * by setting a bit in a HW register, then returns.
 *
 * @remark This also sets up the PF<->VF interrupt mapping and allocations in
 * the hardware after the hardware reset is finished, via
 * ice_iov_setup_intr_mapping()
 */
static void
ice_reset_vf(struct ice_softc *sc, struct ice_vf *vf, bool trigger_vflr)
{
	u16 global_vf_num, reg_idx, bit_idx;
	struct ice_hw *hw = &sc->hw;
	int status;
	u32 reg;
	int i;

	global_vf_num = vf->vf_num + hw->func_caps.vf_base_id;

	if (trigger_vflr) {
		reg = rd32(hw, VPGEN_VFRTRIG(vf->vf_num));
		reg |= VPGEN_VFRTRIG_VFSWR_M;
		wr32(hw, VPGEN_VFRTRIG(vf->vf_num), reg);
	}

	/* clear the VFLR bit for the VF in a GLGEN_VFLRSTAT register */
	reg_idx = (global_vf_num) / 32;
	bit_idx = (global_vf_num) % 32;
	wr32(hw, GLGEN_VFLRSTAT(reg_idx), BIT(bit_idx));
	ice_flush(hw);

	/* Wait until there are no pending PCI transactions */
	wr32(hw, PF_PCI_CIAA,
	     ICE_PCIE_DEV_STATUS | (global_vf_num << PF_PCI_CIAA_VF_NUM_S));

	for (i = 0; i < ICE_PCI_CIAD_WAIT_COUNT; i++) {
		reg = rd32(hw, PF_PCI_CIAD);
		if (!(reg & PCIEM_STA_TRANSACTION_PND))
			break;

		DELAY(ICE_PCI_CIAD_WAIT_DELAY_US);
	}
	if (i == ICE_PCI_CIAD_WAIT_COUNT)
		device_printf(sc->dev,
			"VF-%d PCI transactions stuck\n", vf->vf_num);

	/* Disable TX queues, which is required during VF reset */
	status = ice_dis_vsi_txq(hw->port_info, vf->vsi->idx, 0, 0, NULL, NULL,
			NULL, ICE_VF_RESET, vf->vf_num, NULL);
	if (status)
		device_printf(sc->dev,
			      "%s: Failed to disable LAN Tx queues: err %s aq_err %s\n",
			      __func__, ice_status_str(status),
			      ice_aq_str(hw->adminq.sq_last_status));

	/* Then check for the VF reset to finish in HW */
	for (i = 0; i < ICE_VPGEN_VFRSTAT_WAIT_COUNT; i++) {
		reg = rd32(hw, VPGEN_VFRSTAT(vf->vf_num));
		if ((reg & VPGEN_VFRSTAT_VFRD_M))
			break;

		DELAY(ICE_VPGEN_VFRSTAT_WAIT_DELAY_US);
	}
	if (i == ICE_VPGEN_VFRSTAT_WAIT_COUNT)
		device_printf(sc->dev,
			"VF-%d Reset is stuck\n", vf->vf_num);

	ice_iov_ready_vf(sc, vf);
}

/**
 * ice_vc_get_vf_res_msg - Handle VIRTCHNL_OP_GET_VF_RESOURCES msg from VF
 * @sc: device private structure
 * @vf: VF tracking structure
 * @msg_buf: raw message buffer from the VF
 *
 * Receives a message from the VF listing its supported capabilities, and
 * replies to the VF with information about what resources the PF has
 * allocated for the VF.
 *
 * @remark This always replies to the VF with a success status; it does not
 * fail. It's up to the VF driver to reject or complain about the PF's response.
 */
static void
ice_vc_get_vf_res_msg(struct ice_softc *sc, struct ice_vf *vf, u8 *msg_buf)
{
	struct ice_hw *hw = &sc->hw;
	struct virtchnl_vf_resource *vf_res;
	struct virtchnl_vsi_resource *vsi_res;
	u16 vf_res_len;
	u32 vf_caps;

	/* XXX: Only support one VSI per VF, so this size doesn't need adjusting */
	vf_res_len = sizeof(struct virtchnl_vf_resource);
	vf_res = (struct virtchnl_vf_resource *)malloc(vf_res_len, M_ICE,
	    M_WAITOK | M_ZERO);

	vf_res->num_vsis = 1;
	vf_res->num_queue_pairs = vf->vsi->num_tx_queues;
	vf_res->max_vectors = vf_res->num_queue_pairs + 1;

	vf_res->rss_key_size = ICE_GET_SET_RSS_KEY_EXTEND_KEY_SIZE;
	vf_res->rss_lut_size = ICE_VSIQF_HLUT_ARRAY_SIZE;
	vf_res->max_mtu = 0;

	vf_res->vf_cap_flags = VF_BASE_MODE_OFFLOADS;
	if (msg_buf != NULL) {
		vf_caps = *((u32 *)(msg_buf));

		if (vf_caps & VIRTCHNL_VF_CAP_ADV_LINK_SPEED)
			vf_res->vf_cap_flags |= VIRTCHNL_VF_CAP_ADV_LINK_SPEED;

		if (vf_caps & VIRTCHNL_VF_OFFLOAD_WB_ON_ITR)
                        vf_res->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_WB_ON_ITR;
	}

	vsi_res = &vf_res->vsi_res[0];
	vsi_res->vsi_id = vf->vsi->idx;
	vsi_res->num_queue_pairs = vf->vsi->num_tx_queues;
	vsi_res->vsi_type = VIRTCHNL_VSI_SRIOV;
	vsi_res->qset_handle = 0;
	if (!ETHER_IS_ZERO(vf->mac))
		memcpy(vsi_res->default_mac_addr, vf->mac, ETHER_ADDR_LEN);

	ice_aq_send_msg_to_vf(hw, vf->vf_num, VIRTCHNL_OP_GET_VF_RESOURCES,
	    VIRTCHNL_STATUS_SUCCESS, (u8 *)vf_res, vf_res_len, NULL);

	free(vf_res, M_ICE);
}

/**
 * ice_vc_version_msg - Handle VIRTCHNL_OP_VERSION msg from VF
 * @sc: device private structure
 * @vf: VF tracking structure
 * @msg_buf: raw message buffer from the VF
 *
 * Receives a version message from the VF, and responds to the VF with
 * the version number that the PF will use.
 *
 * @remark This always replies to the VF with a success status; it does not
 * fail.
 */
static void
ice_vc_version_msg(struct ice_softc *sc, struct ice_vf *vf, u8 *msg_buf)
{
	struct virtchnl_version_info *recv_vf_version;
	struct ice_hw *hw = &sc->hw;
	device_t dev = sc->dev;

	recv_vf_version = (struct virtchnl_version_info *)msg_buf;

	/* VFs running the 1.0 API expect to get 1.0 back */
	if (VF_IS_V10(recv_vf_version)) {
		vf->version.major = 1;
		vf->version.minor = VIRTCHNL_VERSION_MINOR_NO_VF_CAPS;
	} else {
		vf->version.major = VIRTCHNL_VERSION_MAJOR;
		vf->version.minor = VIRTCHNL_VERSION_MINOR;

		if ((recv_vf_version->major != VIRTCHNL_VERSION_MAJOR) ||
		    (recv_vf_version->minor != VIRTCHNL_VERSION_MINOR))
		    device_printf(dev,
		        "%s: VF-%d requested version (%d.%d) differs from PF version (%d.%d)\n",
			__func__, vf->vf_num,
			recv_vf_version->major, recv_vf_version->minor,
			VIRTCHNL_VERSION_MAJOR, VIRTCHNL_VERSION_MINOR);
	}

	ice_aq_send_msg_to_vf(hw, vf->vf_num, VIRTCHNL_OP_VERSION,
	    VIRTCHNL_STATUS_SUCCESS, (u8 *)&vf->version, sizeof(vf->version),
	    NULL);
}

/**
 * ice_vf_validate_mac - Validate MAC address before adding it
 * @vf: VF tracking structure
 * @addr: MAC address to validate
 *
 * Validate a MAC address before adding it to a VF during the handling
 * of a VIRTCHNL_OP_ADD_ETH_ADDR operation. Notably, this also checks if
 * the VF is allowed to set its own arbitrary MAC addresses.
 *
 * Returns 0 if MAC address is valid for the given vf
 */
static int
ice_vf_validate_mac(struct ice_vf *vf, const uint8_t *addr)
{

	if (ETHER_IS_ZERO(addr) || ETHER_IS_BROADCAST(addr))
		return (EINVAL);

	/*
	 * If the VF is not allowed to change its MAC address, don't let it
	 * set a MAC filter for an address that is not a multicast address and
	 * is not its assigned MAC.
	 */
	if (!(vf->vf_flags & VF_FLAG_SET_MAC_CAP) &&
	    !(ETHER_IS_MULTICAST(addr) || !bcmp(addr, vf->mac, ETHER_ADDR_LEN)))
		return (EPERM);

	return (0);
}

/**
 * ice_vc_add_eth_addr_msg - Handle VIRTCHNL_OP_ADD_ETH_ADDR msg from VF
 * @sc: device private structure
 * @vf: VF tracking structure
 * @msg_buf: raw message buffer from the VF
 *
 * Receives a list of MAC addresses from the VF and adds those addresses
 * to the VSI's filter list.
 */
static void
ice_vc_add_eth_addr_msg(struct ice_softc *sc, struct ice_vf *vf, u8 *msg_buf)
{
	enum virtchnl_status_code v_status = VIRTCHNL_STATUS_SUCCESS;
	struct virtchnl_ether_addr_list *addr_list;
	struct ice_hw *hw = &sc->hw;
	u16 added_addr_cnt = 0;
	int error = 0;

	addr_list = (struct virtchnl_ether_addr_list *)msg_buf;

	if (addr_list->num_elements >
	    (vf->mac_filter_limit - vf->mac_filter_cnt)) {
		v_status = VIRTCHNL_STATUS_ERR_NO_MEMORY;
		goto done;
	}

	for (int i = 0; i < addr_list->num_elements; i++) {
		u8 *addr = addr_list->list[i].addr;

		/* The type flag is currently ignored; every MAC address is
		 * treated as the LEGACY type
		 */

		error = ice_vf_validate_mac(vf, addr);
		if (error == EPERM) {
			device_printf(sc->dev,
			    "%s: VF-%d: Not permitted to add MAC addr for VSI %d\n",
			    __func__, vf->vf_num, vf->vsi->idx);
			v_status = VIRTCHNL_STATUS_ERR_PARAM;
			continue;
		} else if (error) {
			device_printf(sc->dev,
			    "%s: VF-%d: Did not add invalid MAC addr for VSI %d\n",
			    __func__, vf->vf_num, vf->vsi->idx);
			v_status = VIRTCHNL_STATUS_ERR_PARAM;
			continue;
		}

		error = ice_add_vsi_mac_filter(vf->vsi, addr);
		if (error) {
			device_printf(sc->dev,
			    "%s: VF-%d: Error adding MAC addr for VSI %d\n",
			    __func__, vf->vf_num, vf->vsi->idx);
			v_status = VIRTCHNL_STATUS_ERR_PARAM;
			continue;
		}
		/* Don't count VF's MAC against its MAC filter limit */
		if (memcmp(addr, vf->mac, ETHER_ADDR_LEN))
			added_addr_cnt++;
	}

	vf->mac_filter_cnt += added_addr_cnt;

done:
	ice_aq_send_msg_to_vf(hw, vf->vf_num, VIRTCHNL_OP_ADD_ETH_ADDR,
	    v_status, NULL, 0, NULL);
}

/**
 * ice_vc_del_eth_addr_msg - Handle VIRTCHNL_OP_DEL_ETH_ADDR msg from VF
 * @sc: device private structure
 * @vf: VF tracking structure
 * @msg_buf: raw message buffer from the VF
 *
 * Receives a list of MAC addresses from the VF and removes those addresses
 * from the VSI's filter list.
 */
static void
ice_vc_del_eth_addr_msg(struct ice_softc *sc, struct ice_vf *vf, u8 *msg_buf)
{
	enum virtchnl_status_code v_status = VIRTCHNL_STATUS_SUCCESS;
	struct virtchnl_ether_addr_list *addr_list;
	struct ice_hw *hw = &sc->hw;
	u16 deleted_addr_cnt = 0;
	int error = 0;

	addr_list = (struct virtchnl_ether_addr_list *)msg_buf;

	for (int i = 0; i < addr_list->num_elements; i++) {
		error = ice_remove_vsi_mac_filter(vf->vsi, addr_list->list[i].addr);
		if (error) {
			device_printf(sc->dev,
			    "%s: VF-%d: Error removing MAC addr for VSI %d\n",
			    __func__, vf->vf_num, vf->vsi->idx);
			v_status = VIRTCHNL_STATUS_ERR_PARAM;
			continue;
		}
		/* Don't count VF's MAC against its MAC filter limit */
		if (memcmp(addr_list->list[i].addr, vf->mac, ETHER_ADDR_LEN))
			deleted_addr_cnt++;
	}

	if (deleted_addr_cnt >= vf->mac_filter_cnt)
		vf->mac_filter_cnt = 0;
	else
		vf->mac_filter_cnt -= deleted_addr_cnt;

	ice_aq_send_msg_to_vf(hw, vf->vf_num, VIRTCHNL_OP_DEL_ETH_ADDR,
	    v_status, NULL, 0, NULL);
}

/**
 * ice_vc_add_vlan_msg - Handle VIRTCHNL_OP_ADD_VLAN msg from VF
 * @sc: PF's softc structure
 * @vf: VF tracking structure
 * @msg_buf: message buffer from VF
 *
 * Adds the VLANs in msg_buf to the VF's VLAN filter list.
 */
static void
ice_vc_add_vlan_msg(struct ice_softc *sc, struct ice_vf *vf, u8 *msg_buf)
{
	struct ice_hw *hw = &sc->hw;
	struct virtchnl_vlan_filter_list *vlan_list;
	int status = 0;
	enum virtchnl_status_code v_status = VIRTCHNL_STATUS_SUCCESS;
	struct ice_vsi *vsi = vf->vsi;

	vlan_list = (struct virtchnl_vlan_filter_list *)msg_buf;

	if (vlan_list->vsi_id != vsi->idx) {
		device_printf(sc->dev,
			      "VF-%d: Message has invalid VSI ID (expected %d, got %d)\n",
			      vf->vf_num, vsi->idx, vlan_list->vsi_id);
		v_status = VIRTCHNL_STATUS_ERR_PARAM;
		goto done;
	}

	if (vlan_list->num_elements > (vf->vlan_limit - vf->vlan_cnt)) {
		v_status = VIRTCHNL_STATUS_ERR_NO_MEMORY;
		goto done;
	}

	status = ice_add_vlan_hw_filters(vsi, vlan_list->vlan_id,
					vlan_list->num_elements);
	if (status) {
		device_printf(sc->dev,
			      "VF-%d: Failure adding VLANs to VSI %d, err %s aq_err %s\n",
			      vf->vf_num, vsi->idx, ice_status_str(status),
			      ice_aq_str(sc->hw.adminq.sq_last_status));
		v_status = ice_iov_err_to_virt_err(status);
		goto done;
	}

	vf->vlan_cnt += vlan_list->num_elements;

done:
	ice_aq_send_msg_to_vf(hw, vf->vf_num, VIRTCHNL_OP_ADD_VLAN,
	    v_status, NULL, 0, NULL);
}

/**
 * ice_vc_del_vlan_msg - Handle VIRTCHNL_OP_DEL_VLAN msg from VF
 * @sc: PF's softc structure
 * @vf: VF tracking structure
 * @msg_buf: message buffer from VF
 *
 * Removes the VLANs in msg_buf from the VF's VLAN filter list.
 */
static void
ice_vc_del_vlan_msg(struct ice_softc *sc, struct ice_vf *vf, u8 *msg_buf)
{
	struct ice_hw *hw = &sc->hw;
	struct virtchnl_vlan_filter_list *vlan_list;
	int status = 0;
	enum virtchnl_status_code v_status = VIRTCHNL_STATUS_SUCCESS;
	struct ice_vsi *vsi = vf->vsi;

	vlan_list = (struct virtchnl_vlan_filter_list *)msg_buf;

	if (vlan_list->vsi_id != vsi->idx) {
		device_printf(sc->dev,
			      "VF-%d: Message has invalid VSI ID (expected %d, got %d)\n",
			      vf->vf_num, vsi->idx, vlan_list->vsi_id);
		v_status = VIRTCHNL_STATUS_ERR_PARAM;
		goto done;
	}

	status = ice_remove_vlan_hw_filters(vsi, vlan_list->vlan_id,
					vlan_list->num_elements);
	if (status) {
		device_printf(sc->dev,
			      "VF-%d: Failure deleting VLANs from VSI %d, err %s aq_err %s\n",
			      vf->vf_num, vsi->idx, ice_status_str(status),
			      ice_aq_str(sc->hw.adminq.sq_last_status));
		v_status = ice_iov_err_to_virt_err(status);
		goto done;
	}

	if (vlan_list->num_elements >= vf->vlan_cnt)
		vf->vlan_cnt = 0;
	else
		vf->vlan_cnt -= vlan_list->num_elements;

done:
	ice_aq_send_msg_to_vf(hw, vf->vf_num, VIRTCHNL_OP_DEL_VLAN,
	    v_status, NULL, 0, NULL);
}

/**
 * ice_vc_validate_ring_len - Check to see if a descriptor ring length is valid
 * @ring_len: length of ring
 *
 * Check whether a ring size value is valid.
 *
 * @returns true if given ring size is valid
 */
static bool
ice_vc_isvalid_ring_len(u16 ring_len)
{
	return (ring_len >= ICE_MIN_DESC_COUNT &&
		ring_len <= ICE_MAX_DESC_COUNT &&
		!(ring_len % ICE_DESC_COUNT_INCR));
}

/**
 * ice_vc_cfg_vsi_qs_msg - Handle VIRTCHNL_OP_CONFIG_VSI_QUEUES msg from VF
 * @sc: PF's softc structure
 * @vf: VF tracking structure
 * @msg_buf: message buffer from VF
 */
static void
ice_vc_cfg_vsi_qs_msg(struct ice_softc *sc, struct ice_vf *vf, u8 *msg_buf)
{
	device_t dev = sc->dev;
	struct ice_hw *hw = &sc->hw;
	struct virtchnl_vsi_queue_config_info *vqci;
	struct virtchnl_queue_pair_info *vqpi;
	enum virtchnl_status_code status = VIRTCHNL_STATUS_SUCCESS;
	struct ice_vsi *vsi = vf->vsi;
	struct ice_tx_queue *txq;
	struct ice_rx_queue *rxq;
	int i, error = 0;

	vqci = (struct virtchnl_vsi_queue_config_info *)msg_buf;

	if (vqci->num_queue_pairs > vf->vsi->num_tx_queues &&
	    vqci->num_queue_pairs > vf->vsi->num_rx_queues) {
		status = VIRTCHNL_STATUS_ERR_PARAM;
		goto done;
	}

	ice_vsi_disable_tx(vf->vsi);
	ice_control_all_rx_queues(vf->vsi, false);

	/*
	 * Clear TX and RX queues config in case VF
	 * requests different number of queues.
	 */
	for (i = 0; i < vsi->num_tx_queues; i++) {
		txq = &vsi->tx_queues[i];

		txq->desc_count = 0;
		txq->tx_paddr = 0;
		txq->tc = 0;
	}

	for (i = 0; i < vsi->num_rx_queues; i++) {
		rxq = &vsi->rx_queues[i];

		rxq->desc_count = 0;
		rxq->rx_paddr = 0;
	}

	vqpi = vqci->qpair;
	for (i = 0; i < vqci->num_queue_pairs; i++, vqpi++) {
		/* Initial parameter validation */
		if (vqpi->txq.vsi_id != vf->vsi->idx ||
		    vqpi->rxq.vsi_id != vf->vsi->idx ||
		    vqpi->txq.queue_id != vqpi->rxq.queue_id ||
		    vqpi->txq.headwb_enabled ||
		    vqpi->rxq.splithdr_enabled ||
		    vqpi->rxq.crc_disable ||
		    !(ice_vc_isvalid_ring_len(vqpi->txq.ring_len)) ||
		    !(ice_vc_isvalid_ring_len(vqpi->rxq.ring_len))) {
			status = VIRTCHNL_STATUS_ERR_PARAM;
			goto done;
		}

		/* Copy parameters into VF's queue/VSI structs */
		txq = &vsi->tx_queues[vqpi->txq.queue_id];

		txq->desc_count = vqpi->txq.ring_len;
		txq->tx_paddr = vqpi->txq.dma_ring_addr;
		txq->q_handle = vqpi->txq.queue_id;
		txq->tc = 0;

		rxq = &vsi->rx_queues[vqpi->rxq.queue_id];

		rxq->desc_count = vqpi->rxq.ring_len;
		rxq->rx_paddr = vqpi->rxq.dma_ring_addr;
		vsi->mbuf_sz = vqpi->rxq.databuffer_size;
	}

	/* Configure TX queues in HW */
	error = ice_cfg_vsi_for_tx(vsi);
	if (error) {
		device_printf(dev,
			      "VF-%d: Unable to configure VSI for Tx: %s\n",
			      vf->vf_num, ice_err_str(error));
		status = VIRTCHNL_STATUS_ERR_ADMIN_QUEUE_ERROR;
		goto done;
	}

	/* Configure RX queues in HW */
	error = ice_cfg_vsi_for_rx(vsi);
	if (error) {
		device_printf(dev,
			      "VF-%d: Unable to configure VSI for Rx: %s\n",
			      vf->vf_num, ice_err_str(error));
		status = VIRTCHNL_STATUS_ERR_ADMIN_QUEUE_ERROR;
		ice_vsi_disable_tx(vsi);
		goto done;
	}

done:
	ice_aq_send_msg_to_vf(hw, vf->vf_num, VIRTCHNL_OP_CONFIG_VSI_QUEUES,
	    status, NULL, 0, NULL);
}

/**
 * ice_vc_cfg_rss_key_msg - Handle VIRTCHNL_OP_CONFIG_RSS_KEY msg from VF
 * @sc: PF's softc structure
 * @vf: VF tracking structure
 * @msg_buf: message buffer from VF
 *
 * Sets the RSS key for the given VF, using the contents of msg_buf.
 */
static void
ice_vc_cfg_rss_key_msg(struct ice_softc *sc, struct ice_vf *vf, u8 *msg_buf)
{
	struct ice_aqc_get_set_rss_keys keydata =
	    { .standard_rss_key = {0}, .extended_hash_key = {0} };
	struct ice_hw *hw = &sc->hw;
	struct virtchnl_rss_key *vrk;
	int status = 0;
	enum virtchnl_status_code v_status = VIRTCHNL_STATUS_SUCCESS;
	struct ice_vsi *vsi = vf->vsi;

	vrk = (struct virtchnl_rss_key *)msg_buf;

	if (vrk->vsi_id != vsi->idx) {
		device_printf(sc->dev,
		    "VF-%d: Message has invalid VSI ID (expected %d, got %d)\n",
		    vf->vf_num, vsi->idx, vrk->vsi_id);
		v_status = VIRTCHNL_STATUS_ERR_PARAM;
		goto done;
	}

	if ((vrk->key_len >
	   (ICE_AQC_GET_SET_RSS_KEY_DATA_RSS_KEY_SIZE +
	    ICE_AQC_GET_SET_RSS_KEY_DATA_HASH_KEY_SIZE)) ||
	    vrk->key_len == 0) {
		v_status = VIRTCHNL_STATUS_ERR_PARAM;
		goto done;
	}

	memcpy(&keydata, vrk->key, vrk->key_len);

	status = ice_aq_set_rss_key(hw, vsi->idx, &keydata);
	if (status) {
		device_printf(sc->dev,
			      "ice_aq_set_rss_key status %s, error %s\n",
			      ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status));
		v_status = ice_iov_err_to_virt_err(status);
		goto done;
	}

done:
	ice_aq_send_msg_to_vf(hw, vf->vf_num, VIRTCHNL_OP_CONFIG_RSS_KEY,
	    v_status, NULL, 0, NULL);
}

/**
 * ice_vc_cfg_rss_lut_msg - Handle VIRTCHNL_OP_CONFIG_RSS_LUT msg from VF
 * @sc: PF's softc structure
 * @vf: VF tracking structure
 * @msg_buf: message buffer from VF
 *
 * Adds the LUT from the VF in msg_buf to the PF via an admin queue call.
 */
static void
ice_vc_cfg_rss_lut_msg(struct ice_softc *sc, struct ice_vf *vf, u8 *msg_buf)
{
	struct ice_hw *hw = &sc->hw;
	struct virtchnl_rss_lut *vrl;
	int status = 0;
	enum virtchnl_status_code v_status = VIRTCHNL_STATUS_SUCCESS;
	struct ice_aq_get_set_rss_lut_params lut_params = {};
	struct ice_vsi *vsi = vf->vsi;

	vrl = (struct virtchnl_rss_lut *)msg_buf;

	if (vrl->vsi_id != vsi->idx) {
		device_printf(sc->dev,
		    "VF-%d: Message has invalid VSI ID (expected %d, got %d)\n",
		    vf->vf_num, vsi->idx, vrl->vsi_id);
		v_status = VIRTCHNL_STATUS_ERR_PARAM;
		goto done;
	}

	if (vrl->lut_entries > ICE_VSIQF_HLUT_ARRAY_SIZE) {
		v_status = VIRTCHNL_STATUS_ERR_PARAM;
		goto done;
	}

	lut_params.vsi_handle = vsi->idx;
	lut_params.lut_size = vsi->rss_table_size;
	lut_params.lut_type = vsi->rss_lut_type;
	lut_params.lut = vrl->lut;
	lut_params.global_lut_id = 0;

	status = ice_aq_set_rss_lut(hw, &lut_params);
	if (status) {
		device_printf(sc->dev,
			      "VF-%d: Cannot set RSS lut, err %s aq_err %s\n",
			      vf->vf_num, ice_status_str(status),
			      ice_aq_str(hw->adminq.sq_last_status));
		v_status = ice_iov_err_to_virt_err(status);
	}

done:
	ice_aq_send_msg_to_vf(hw, vf->vf_num, VIRTCHNL_OP_CONFIG_RSS_LUT,
	    v_status, NULL, 0, NULL);
}

/**
 * ice_vc_set_rss_hena_msg - Handle VIRTCHNL_OP_SET_RSS_HENA msg from VF
 * @sc: PF's softc structure
 * @vf: VF tracking structure
 * @msg_buf: message buffer from VF
 *
 * Adds the VF's hena (hash enable) bits as flow types to the PF's RSS flow
 * type list.
 */
static void
ice_vc_set_rss_hena_msg(struct ice_softc *sc, struct ice_vf *vf, u8 *msg_buf)
{
	struct ice_hw *hw = &sc->hw;
	struct virtchnl_rss_hena *vrh;
	int status = 0;
	enum virtchnl_status_code v_status = VIRTCHNL_STATUS_SUCCESS;
	struct ice_vsi *vsi = vf->vsi;

	MPASS(vsi != NULL);

	vrh = (struct virtchnl_rss_hena *)msg_buf;

	/*
	 * Remove existing configuration to make sure only requested
	 * config is applied and allow VFs to disable RSS completly.
	 */
	status = ice_rem_vsi_rss_cfg(hw, vsi->idx);
	if (vrh->hena) {
		/*
		 * Problem with removing config is not fatal, when new one
		 * is requested. Warn about it but try to apply new config
		 * anyway.
		 */
		if (status)
			device_printf(sc->dev,
			    "ice_rem_vsi_rss_cfg status %s, error %s\n",
			    ice_status_str(status),
			    ice_aq_str(hw->adminq.sq_last_status));
		status = ice_add_avf_rss_cfg(hw, vsi->idx, vrh->hena);
		if (status)
			device_printf(sc->dev,
			    "ice_add_avf_rss_cfg status %s, error %s\n",
			    ice_status_str(status),
			    ice_aq_str(hw->adminq.sq_last_status));
	}
	v_status = ice_iov_err_to_virt_err(status);
	ice_aq_send_msg_to_vf(hw, vf->vf_num, VIRTCHNL_OP_SET_RSS_HENA,
	    v_status, NULL, 0, NULL);
}

/**
 * ice_vc_enable_queues_msg - Handle VIRTCHNL_OP_ENABLE_QUEUES msg from VF
 * @sc: PF's softc structure
 * @vf: VF tracking structure
 * @msg_buf: message buffer from VF
 *
 * Enables VF queues selected in msg_buf for Tx/Rx traffic.
 *
 * @remark Only actually operates on Rx queues; Tx queues are enabled in
 * CONFIG_VSI_QUEUES message handler.
 */
static void
ice_vc_enable_queues_msg(struct ice_softc *sc, struct ice_vf *vf, u8 *msg_buf)
{
	struct ice_hw *hw = &sc->hw;
	struct virtchnl_queue_select *vqs;
	enum virtchnl_status_code v_status = VIRTCHNL_STATUS_SUCCESS;
	struct ice_vsi *vsi = vf->vsi;
	int bit, error = 0;

	vqs = (struct virtchnl_queue_select *)msg_buf;

	if (vqs->vsi_id != vsi->idx) {
		device_printf(sc->dev,
		    "%s: VF-%d: Message has invalid VSI ID (expected %d, got %d)\n",
		    __func__, vf->vf_num, vsi->idx, vqs->vsi_id);
		v_status = VIRTCHNL_STATUS_ERR_PARAM;
		goto done;
	}

	if (!vqs->rx_queues && !vqs->tx_queues) {
		device_printf(sc->dev,
		    "%s: VF-%d: message queue masks are empty\n",
		    __func__, vf->vf_num);
		v_status = VIRTCHNL_STATUS_ERR_PARAM;
		goto done;
	}

	/* Validate rx_queue mask */
	bit = fls(vqs->rx_queues);
	if (bit > vsi->num_rx_queues) {
		device_printf(sc->dev,
		    "%s: VF-%d: message's rx_queues map (0x%08x) has invalid bit set (%d)\n",
		    __func__, vf->vf_num, vqs->rx_queues, bit);
		v_status = VIRTCHNL_STATUS_ERR_PARAM;
		goto done;
	}

	/* Tx ring enable is handled in an earlier message. */
	for_each_set_bit(bit, &vqs->rx_queues, 32) {
		error = ice_control_rx_queue(vsi, bit, true);
		if (error) {
			device_printf(sc->dev,
				      "Unable to enable Rx ring %d for receive: %s\n",
				      bit, ice_err_str(error));
			v_status = VIRTCHNL_STATUS_ERR_PARAM;
			goto done;
		}
	}

done:
	ice_aq_send_msg_to_vf(hw, vf->vf_num, VIRTCHNL_OP_ENABLE_QUEUES,
	    v_status, NULL, 0, NULL);
}

/**
 * ice_vc_disable_queues_msg - Handle VIRTCHNL_OP_DISABLE_QUEUES msg
 * @sc: PF's softc structure
 * @vf: VF tracking structure
 * @msg_buf: message buffer from VF
 *
 * Disables all VF queues for the VF's VSI.
 *
 * @remark Unlike the ENABLE_QUEUES handler, this operates on both
 * Tx and Rx queues
 */
static void
ice_vc_disable_queues_msg(struct ice_softc *sc, struct ice_vf *vf,
			  u8 *msg_buf __unused)
{
	struct ice_hw *hw = &sc->hw;
	enum virtchnl_status_code v_status = VIRTCHNL_STATUS_SUCCESS;
	struct ice_vsi *vsi = vf->vsi;
	int error = 0;

	error = ice_control_all_rx_queues(vsi, false);
	if (error) {
		device_printf(sc->dev,
			      "Unable to disable Rx rings for transmit: %s\n",
			      ice_err_str(error));
		v_status = VIRTCHNL_STATUS_ERR_PARAM;
		goto done;
	}

	error = ice_vsi_disable_tx(vsi);
	if (error) {
		/* Already prints an error message */
		v_status = VIRTCHNL_STATUS_ERR_PARAM;
	}

done:
	ice_aq_send_msg_to_vf(hw, vf->vf_num, VIRTCHNL_OP_DISABLE_QUEUES,
	    v_status, NULL, 0, NULL);
}

/**
 * ice_vc_cfg_irq_map_msg - Handle VIRTCHNL_OP_CFG_IRQ_MAP msg from VF
 * @sc: PF's softc structure
 * @vf: VF tracking structure
 * @msg_buf: message buffer from VF
 *
 * Configures the interrupt vectors described in the message in msg_buf. The
 * VF needs to send this message during init, so that queues can be allowed
 * to generate interrupts.
 */
static void
ice_vc_cfg_irq_map_msg(struct ice_softc *sc, struct ice_vf *vf, u8 *msg_buf)
{
#define ICE_VIRTCHNL_QUEUE_MAP_SIZE	16
	struct ice_hw *hw = &sc->hw;
	struct virtchnl_irq_map_info *vimi;
	struct virtchnl_vector_map *vvm;
	enum virtchnl_status_code v_status = VIRTCHNL_STATUS_SUCCESS;
	struct ice_vsi *vsi = vf->vsi;
	u16 vector;

	vimi = (struct virtchnl_irq_map_info *)msg_buf;

	if (vimi->num_vectors > vf->num_irq_vectors) {
		device_printf(sc->dev,
		    "%s: VF-%d: message has more vectors (%d) than configured for VF (%d)\n",
		    __func__, vf->vf_num, vimi->num_vectors, vf->num_irq_vectors);
		v_status = VIRTCHNL_STATUS_ERR_PARAM;
		goto done;
	}

	vvm = vimi->vecmap;
	/* Save off information from message */
	for (int i = 0; i < vimi->num_vectors; i++, vvm++) {
		struct ice_tx_queue *txq;
		struct ice_rx_queue *rxq;
		int bit;

		if (vvm->vsi_id != vf->vsi->idx) {
			device_printf(sc->dev,
			    "%s: VF-%d: message's VSI ID (%d) does not match VF's (%d) for vector %d\n",
			    __func__, vf->vf_num, vvm->vsi_id, vf->vsi->idx, i);
			v_status = VIRTCHNL_STATUS_ERR_PARAM;
			goto done;
		}

		/* vvm->vector_id is relative to VF space */
		vector = vvm->vector_id;

		if (vector >= vf->num_irq_vectors) {
			device_printf(sc->dev,
			    "%s: VF-%d: message's vector ID (%d) is greater than VF's max ID (%d)\n",
			    __func__, vf->vf_num, vector, vf->num_irq_vectors - 1);
			v_status = VIRTCHNL_STATUS_ERR_PARAM;
			goto done;
		}

		/* The Misc/Admin Queue vector doesn't need mapping */
		if (vector == 0)
			continue;

		/* coverity[address_of] */
		for_each_set_bit(bit, &vvm->txq_map, ICE_VIRTCHNL_QUEUE_MAP_SIZE) {
			if (bit >= vsi->num_tx_queues) {
				device_printf(sc->dev,
				    "%s: VF-%d: txq map has invalid bit set\n",
				    __func__, vf->vf_num);
				v_status = VIRTCHNL_STATUS_ERR_PARAM;
				goto done;
			}

			vf->tx_irqvs[vector].me = vector;

			txq = &vsi->tx_queues[bit];
			txq->irqv = &vf->tx_irqvs[vector];
			txq->itr_idx = vvm->txitr_idx;
		}
		/* coverity[address_of] */
		for_each_set_bit(bit, &vvm->rxq_map, ICE_VIRTCHNL_QUEUE_MAP_SIZE) {
			if (bit >= vsi->num_rx_queues) {
				device_printf(sc->dev,
				    "%s: VF-%d: rxq map has invalid bit set\n",
				    __func__, vf->vf_num);
				v_status = VIRTCHNL_STATUS_ERR_PARAM;
				goto done;
			}
			vf->rx_irqvs[vector].me = vector;

			rxq = &vsi->rx_queues[bit];
			rxq->irqv = &vf->rx_irqvs[vector];
			rxq->itr_idx = vvm->rxitr_idx;
		}
	}

	/* Write to T/RQCTL registers to actually map vectors to queues */
	for (int i = 0; i < vf->vsi->num_rx_queues; i++)
		if (vsi->rx_queues[i].irqv != NULL)
			ice_configure_rxq_interrupt(hw, vsi->rx_qmap[i],
			    vsi->rx_queues[i].irqv->me, vsi->rx_queues[i].itr_idx);

	for (int i = 0; i < vf->vsi->num_tx_queues; i++)
		if (vsi->tx_queues[i].irqv != NULL)
			ice_configure_txq_interrupt(hw, vsi->tx_qmap[i],
			    vsi->tx_queues[i].irqv->me, vsi->tx_queues[i].itr_idx);

	ice_flush(hw);

done:
	ice_aq_send_msg_to_vf(hw, vf->vf_num, VIRTCHNL_OP_CONFIG_IRQ_MAP,
	    v_status, NULL, 0, NULL);
}

/**
 * ice_eth_stats_to_virtchnl_eth_stats - Convert stats for virtchnl
 * @istats: VSI stats from HW to convert
 * @vstats: stats struct to copy to
 *
 * This function copies all known stats in struct virtchnl_eth_stats from the
 * input struct ice_eth_stats to an output struct virtchnl_eth_stats.
 *
 * @remark These two structure types currently have the same definition up to
 * the size of struct virtchnl_eth_stats (on FreeBSD), but that could change
 * in the future.
 */
static void
ice_eth_stats_to_virtchnl_eth_stats(struct ice_eth_stats *istats,
				    struct virtchnl_eth_stats *vstats)
{
	vstats->rx_bytes = istats->rx_bytes;
	vstats->rx_unicast = istats->rx_unicast;
	vstats->rx_multicast = istats->rx_multicast;
	vstats->rx_broadcast = istats->rx_broadcast;
	vstats->rx_discards = istats->rx_discards;
	vstats->rx_unknown_protocol = istats->rx_unknown_protocol;
	vstats->tx_bytes = istats->tx_bytes;
	vstats->tx_unicast = istats->tx_unicast;
	vstats->tx_multicast = istats->tx_multicast;
	vstats->tx_broadcast = istats->tx_broadcast;
	vstats->tx_discards = istats->tx_discards;
	vstats->tx_errors = istats->tx_errors;
}

/**
 * ice_vc_get_stats_msg - Handle VIRTCHNL_OP_GET_STATS msg
 * @sc: device private structure
 * @vf: VF tracking structure
 * @msg_buf: raw message buffer from the VF
 *
 * Updates the VF's VSI stats and sends those stats back to the VF.
 */
static void
ice_vc_get_stats_msg(struct ice_softc *sc, struct ice_vf *vf, u8 *msg_buf)
{
	struct virtchnl_queue_select *vqs;
	struct virtchnl_eth_stats stats;
	struct ice_vsi *vsi = vf->vsi;
	struct ice_hw *hw = &sc->hw;

	vqs = (struct virtchnl_queue_select *)msg_buf;

	if (vqs->vsi_id != vsi->idx) {
		device_printf(sc->dev,
		    "%s: VF-%d: message has invalid VSI ID %d (VF has VSI ID %d)\n",
		    __func__, vf->vf_num, vqs->vsi_id, vsi->idx);
		ice_aq_send_msg_to_vf(hw, vf->vf_num, VIRTCHNL_OP_GET_STATS,
		    VIRTCHNL_STATUS_ERR_PARAM, NULL, 0, NULL);
	}

	ice_update_vsi_hw_stats(vf->vsi);
	ice_eth_stats_to_virtchnl_eth_stats(&vsi->hw_stats.cur, &stats);

	ice_aq_send_msg_to_vf(hw, vf->vf_num, VIRTCHNL_OP_GET_STATS,
	    VIRTCHNL_STATUS_SUCCESS, (u8 *)&stats,
	    sizeof(struct virtchnl_eth_stats), NULL);
}

/**
 * ice_vc_cfg_promisc_mode_msg - Handle VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE
 * @sc: PF's softc structure
 * @vf: VF tracking structure
 * @msg_buf: message buffer from VF
 *
 * Configures the promiscuous modes for the given VSI in msg_buf.
 */
static void
ice_vc_cfg_promisc_mode_msg(struct ice_softc *sc, struct ice_vf *vf, u8 *msg_buf)
{
	struct ice_hw *hw = &sc->hw;
	struct virtchnl_promisc_info *vpi;
	enum virtchnl_status_code v_status = VIRTCHNL_STATUS_SUCCESS;
	int status = 0;
	struct ice_vsi *vsi = vf->vsi;
	ice_declare_bitmap(old_promisc_mask, ICE_PROMISC_MAX);
	ice_declare_bitmap(req_promisc_mask, ICE_PROMISC_MAX);
	ice_declare_bitmap(clear_promisc_mask, ICE_PROMISC_MAX);
	ice_declare_bitmap(set_promisc_mask, ICE_PROMISC_MAX);
	ice_declare_bitmap(old_req_xor_mask, ICE_PROMISC_MAX);
	u16 vid;

	vpi = (struct virtchnl_promisc_info *)msg_buf;

	/* Check to see if VF has permission to configure promiscuous mode */
	if (!(vf->vf_flags & VF_FLAG_PROMISC_CAP)) {
		device_printf(sc->dev,
			      "VF-%d: attempted to configure promiscuous mode\n",
			      vf->vf_num);
		/* Don't reply to VF with an error */
		goto done;
	}

	if (vpi->vsi_id != vsi->idx) {
		device_printf(sc->dev,
			      "VF-%d: Message has invalid VSI ID (expected %d, got %d)\n",
			      vf->vf_num, vsi->idx, vpi->vsi_id);
		v_status = VIRTCHNL_STATUS_ERR_PARAM;
		goto done;
	}

	if (vpi->flags & ~ICE_VIRTCHNL_VALID_PROMISC_FLAGS) {
		device_printf(sc->dev,
			      "VF-%d: Message has invalid promiscuous flags set (valid 0x%02x, got 0x%02x)\n",
			      vf->vf_num, ICE_VIRTCHNL_VALID_PROMISC_FLAGS,
			      vpi->flags);
		v_status = VIRTCHNL_STATUS_ERR_PARAM;
		goto done;

	}

	ice_zero_bitmap(req_promisc_mask, ICE_PROMISC_MAX);
	/* Convert virtchnl flags to ice AQ promiscuous mode flags */
	if (vpi->flags & FLAG_VF_UNICAST_PROMISC) {
		ice_set_bit(ICE_PROMISC_UCAST_TX, req_promisc_mask);
		ice_set_bit(ICE_PROMISC_UCAST_RX, req_promisc_mask);
	}
	if (vpi->flags & FLAG_VF_MULTICAST_PROMISC) {
		ice_set_bit(ICE_PROMISC_MCAST_TX, req_promisc_mask);
		ice_set_bit(ICE_PROMISC_MCAST_RX, req_promisc_mask);
	}

	status = ice_get_vsi_promisc(hw, vsi->idx, old_promisc_mask, &vid);
	if (status) {
		device_printf(sc->dev,
			      "VF-%d: Failed to get promiscuous mode mask for VSI %d, err %s aq_err %s\n",
			      vf->vf_num, vsi->idx,
			      ice_status_str(status),
			      ice_aq_str(hw->adminq.sq_last_status));
		v_status = ice_iov_err_to_virt_err(status);
		goto done;
	}

	/* Figure out what got added and what got removed */
	ice_zero_bitmap(old_req_xor_mask, ICE_PROMISC_MAX);
	ice_xor_bitmap(old_req_xor_mask, old_promisc_mask, req_promisc_mask, ICE_PROMISC_MAX);
	ice_and_bitmap(clear_promisc_mask, old_req_xor_mask, old_promisc_mask, ICE_PROMISC_MAX);
	ice_and_bitmap(set_promisc_mask, old_req_xor_mask, req_promisc_mask, ICE_PROMISC_MAX);

	if (ice_is_any_bit_set(clear_promisc_mask, ICE_PROMISC_MAX)) {
		status = ice_clear_vsi_promisc(hw, vsi->idx,
					       clear_promisc_mask, 0);
		if (status) {
			device_printf(sc->dev,
				      "VF-%d: Failed to clear promiscuous mode for VSI %d, err %s aq_err %s\n",
				      vf->vf_num, vsi->idx,
				      ice_status_str(status),
				      ice_aq_str(hw->adminq.sq_last_status));
			v_status = ice_iov_err_to_virt_err(status);
			goto done;
		}
	}

	if (ice_is_any_bit_set(set_promisc_mask, ICE_PROMISC_MAX)) {
		status = ice_set_vsi_promisc(hw, vsi->idx, set_promisc_mask, 0);
		if (status) {
			device_printf(sc->dev,
				      "VF-%d: Failed to set promiscuous mode for VSI %d, err %s aq_err %s\n",
				      vf->vf_num, vsi->idx,
				      ice_status_str(status),
				      ice_aq_str(hw->adminq.sq_last_status));
			v_status = ice_iov_err_to_virt_err(status);
			goto done;
		}
	}

done:
	ice_aq_send_msg_to_vf(hw, vf->vf_num, VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE,
	    v_status, NULL, 0, NULL);
}

/**
 * ice_vc_notify_all_vfs_link_state - Notify all VFs of PF link state
 * @sc: device private structure
 *
 * Sends a message to all VFs about the status of the PF's link
 * state. For more details, @see ice_vc_notify_vf_link_state.
 */
void
ice_vc_notify_all_vfs_link_state(struct ice_softc *sc)
{
	for (int i = 0; i < sc->num_vfs; i++)
		ice_vc_notify_vf_link_state(sc, &sc->vfs[i]);
}

/**
 * ice_vc_notify_vf_link_state - Notify VF of PF link state
 * @sc: device private structure
 * @vf: VF tracking structure
 *
 * Sends an event message to the specified VF with information about
 * the current link state from the PF's port. This includes whether
 * link is up or down, and the link speed in 100Mbps units.
 */
static void
ice_vc_notify_vf_link_state(struct ice_softc *sc, struct ice_vf *vf)
{
	struct virtchnl_pf_event event = {};
	struct ice_hw *hw = &sc->hw;

	event.event = VIRTCHNL_EVENT_LINK_CHANGE;
	event.severity = PF_EVENT_SEVERITY_INFO;
	event.event_data.link_event_adv.link_status = sc->link_up;
	event.event_data.link_event_adv.link_speed =
		(u32)ice_conv_link_speed_to_virtchnl(true,
		    hw->port_info->phy.link_info.link_speed);

	ice_aq_send_msg_to_vf(hw, vf->vf_num, VIRTCHNL_OP_EVENT,
	    VIRTCHNL_STATUS_SUCCESS, (u8 *)&event, sizeof(event), NULL);
}

/**
 * ice_vc_handle_vf_msg - Handle a message from a VF
 * @sc: device private structure
 * @event: event received from the HW MBX queue
 *
 * Called whenever an event is received from a VF on the HW mailbox queue.
 * Responsible for handling these messages as well as responding to the
 * VF afterwards, depending on the received message type.
 */
void
ice_vc_handle_vf_msg(struct ice_softc *sc, struct ice_rq_event_info *event)
{
	struct ice_hw *hw = &sc->hw;
	device_t dev = sc->dev;
	struct ice_vf *vf;
	int err = 0;

	u32 v_opcode = event->desc.cookie_high;
	u16 v_id = event->desc.retval;
	u8 *msg = event->msg_buf;
	u16 msglen = event->msg_len;

	if (v_id >= sc->num_vfs) {
		device_printf(dev, "%s: Received msg from invalid VF-%d: opcode %d, len %d\n",
		    __func__, v_id, v_opcode, msglen);
		return;
	}

	vf = &sc->vfs[v_id];

	/* Perform basic checks on the msg */
	err = virtchnl_vc_validate_vf_msg(&vf->version, v_opcode, msg, msglen);
	if (err) {
		device_printf(dev, "%s: Received invalid msg from VF-%d: opcode %d, len %d, error %d\n",
		    __func__, vf->vf_num, v_opcode, msglen, err);
		ice_aq_send_msg_to_vf(hw, v_id, v_opcode, VIRTCHNL_STATUS_ERR_PARAM, NULL, 0, NULL);
		return;
	}

	switch (v_opcode) {
	case VIRTCHNL_OP_VERSION:
		ice_vc_version_msg(sc, vf, msg);
		break;
	case VIRTCHNL_OP_RESET_VF:
		ice_reset_vf(sc, vf, true);
		break;
	case VIRTCHNL_OP_GET_VF_RESOURCES:
		ice_vc_get_vf_res_msg(sc, vf, msg);
		break;
	case VIRTCHNL_OP_ADD_ETH_ADDR:
		ice_vc_add_eth_addr_msg(sc, vf, msg);
		break;
	case VIRTCHNL_OP_DEL_ETH_ADDR:
		ice_vc_del_eth_addr_msg(sc, vf, msg);
		break;
	case VIRTCHNL_OP_ADD_VLAN:
		ice_vc_add_vlan_msg(sc, vf, msg);
		break;
	case VIRTCHNL_OP_DEL_VLAN:
		ice_vc_del_vlan_msg(sc, vf, msg);
		break;
	case VIRTCHNL_OP_CONFIG_VSI_QUEUES:
		ice_vc_cfg_vsi_qs_msg(sc, vf, msg);
		break;
	case VIRTCHNL_OP_CONFIG_RSS_KEY:
		ice_vc_cfg_rss_key_msg(sc, vf, msg);
		break;
	case VIRTCHNL_OP_CONFIG_RSS_LUT:
		ice_vc_cfg_rss_lut_msg(sc, vf, msg);
		break;
	case VIRTCHNL_OP_SET_RSS_HENA:
		ice_vc_set_rss_hena_msg(sc, vf, msg);
		break;
	case VIRTCHNL_OP_ENABLE_QUEUES:
		ice_vc_enable_queues_msg(sc, vf, msg);
		ice_vc_notify_vf_link_state(sc, vf);
		break;
	case VIRTCHNL_OP_DISABLE_QUEUES:
		ice_vc_disable_queues_msg(sc, vf, msg);
		break;
	case VIRTCHNL_OP_CONFIG_IRQ_MAP:
		ice_vc_cfg_irq_map_msg(sc, vf, msg);
		break;
	case VIRTCHNL_OP_GET_STATS:
		ice_vc_get_stats_msg(sc, vf, msg);
		break;
	case VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE:
		ice_vc_cfg_promisc_mode_msg(sc, vf, msg);
		break;
	default:
		device_printf(dev, "%s: Received unknown msg from VF-%d: opcode %d, len %d\n",
		    __func__, vf->vf_num, v_opcode, msglen);
		ice_aq_send_msg_to_vf(hw, v_id, v_opcode,
		    VIRTCHNL_STATUS_ERR_NOT_SUPPORTED, NULL, 0, NULL);
		break;
	}
}

/**
 * ice_iov_setup_intr_mapping - Setup interrupt config for a VF
 * @sc: device softc structure
 * @vf: driver's VF structure for VF to be configured
 *
 * Before a VF can be used, and after a VF reset, the PF must configure
 * the VF's interrupt allocation registers. This includes allocating
 * interrupts from the PF's interrupt pool to the VF using the
 * VPINT_ALLOC(_PCI) registers, and setting up a mapping from PF vectors
 * to VF vectors in GLINT_VECT2FUNC.
 *
 * As well, this sets up queue allocation registers and maps the mailbox
 * interrupt for the VF.
 */
static void
ice_iov_setup_intr_mapping(struct ice_softc *sc, struct ice_vf *vf)
{
	struct ice_hw *hw = &sc->hw;
	struct ice_vsi *vsi = vf->vsi;
	u16 v;

	/* Calculate indices for register ops below */
	u16 vf_first_irq_idx = vf->vf_imap[0];
	u16 vf_last_irq_idx = (vf_first_irq_idx + vf->num_irq_vectors) - 1;
	u16 abs_vf_first_irq_idx = hw->func_caps.common_cap.msix_vector_first_id +
	    vf_first_irq_idx;
	u16 abs_vf_last_irq_idx = (abs_vf_first_irq_idx + vf->num_irq_vectors) - 1;
	u16 abs_vf_num = vf->vf_num + hw->func_caps.vf_base_id;

	/* Map out VF interrupt allocation in global device space. Both
	 * VPINT_ALLOC and VPINT_ALLOC_PCI use the same values.
	 */
	wr32(hw, VPINT_ALLOC(vf->vf_num),
	    (((abs_vf_first_irq_idx << VPINT_ALLOC_FIRST_S) & VPINT_ALLOC_FIRST_M) |
	    ((abs_vf_last_irq_idx << VPINT_ALLOC_LAST_S) & VPINT_ALLOC_LAST_M) |
	    VPINT_ALLOC_VALID_M));
	wr32(hw, VPINT_ALLOC_PCI(vf->vf_num),
	    (((abs_vf_first_irq_idx << VPINT_ALLOC_PCI_FIRST_S) & VPINT_ALLOC_PCI_FIRST_M) |
	    ((abs_vf_last_irq_idx << VPINT_ALLOC_PCI_LAST_S) & VPINT_ALLOC_PCI_LAST_M) |
	    VPINT_ALLOC_PCI_VALID_M));

	/* Create inverse mapping of vectors to PF/VF combinations */
	for (v = vf_first_irq_idx; v <= vf_last_irq_idx; v++)
	{
		wr32(hw, GLINT_VECT2FUNC(v),
		    (((abs_vf_num << GLINT_VECT2FUNC_VF_NUM_S) & GLINT_VECT2FUNC_VF_NUM_M) |
		     ((hw->pf_id << GLINT_VECT2FUNC_PF_NUM_S) & GLINT_VECT2FUNC_PF_NUM_M)));
	}

	/* Map mailbox interrupt to MSI-X index 0. Disable ITR for it, too. */
	wr32(hw, VPINT_MBX_CTL(abs_vf_num),
	    ((0 << VPINT_MBX_CTL_MSIX_INDX_S) & VPINT_MBX_CTL_MSIX_INDX_M) |
	    ((0x3 << VPINT_MBX_CTL_ITR_INDX_S) & VPINT_MBX_CTL_ITR_INDX_M) |
	    VPINT_MBX_CTL_CAUSE_ENA_M);

	/* Mark the TX queue mapping registers as valid */
	wr32(hw, VPLAN_TXQ_MAPENA(vf->vf_num), VPLAN_TXQ_MAPENA_TX_ENA_M);

	/* Indicate to HW that VF has scattered queue allocation */
	wr32(hw, VPLAN_TX_QBASE(vf->vf_num), VPLAN_TX_QBASE_VFQTABLE_ENA_M);
	for (int i = 0; i < vsi->num_tx_queues; i++) {
		wr32(hw, VPLAN_TX_QTABLE(i, vf->vf_num),
		    (vsi->tx_qmap[i] << VPLAN_TX_QTABLE_QINDEX_S) & VPLAN_TX_QTABLE_QINDEX_M);
	}

	/* Mark the RX queue mapping registers as valid */
	wr32(hw, VPLAN_RXQ_MAPENA(vf->vf_num), VPLAN_RXQ_MAPENA_RX_ENA_M);
	wr32(hw, VPLAN_RX_QBASE(vf->vf_num), VPLAN_RX_QBASE_VFQTABLE_ENA_M);
	for (int i = 0; i < vsi->num_rx_queues; i++) {
		wr32(hw, VPLAN_RX_QTABLE(i, vf->vf_num),
		    (vsi->rx_qmap[i] << VPLAN_RX_QTABLE_QINDEX_S) & VPLAN_RX_QTABLE_QINDEX_M);
	}
}

/**
 * ice_err_to_virt err - translate ice errors into virtchnl errors
 * @ice_err: status returned from ice function
 */
static enum virtchnl_status_code
ice_iov_err_to_virt_err(int ice_err)
{
	switch (ice_err) {
	case 0:
		return VIRTCHNL_STATUS_SUCCESS;
	case ICE_ERR_BAD_PTR:
	case ICE_ERR_INVAL_SIZE:
	case ICE_ERR_DEVICE_NOT_SUPPORTED:
	case ICE_ERR_PARAM:
	case ICE_ERR_CFG:
		return VIRTCHNL_STATUS_ERR_PARAM;
	case ICE_ERR_NO_MEMORY:
		return VIRTCHNL_STATUS_ERR_NO_MEMORY;
	case ICE_ERR_NOT_READY:
	case ICE_ERR_RESET_FAILED:
	case ICE_ERR_FW_API_VER:
	case ICE_ERR_AQ_ERROR:
	case ICE_ERR_AQ_TIMEOUT:
	case ICE_ERR_AQ_FULL:
	case ICE_ERR_AQ_NO_WORK:
	case ICE_ERR_AQ_EMPTY:
		return VIRTCHNL_STATUS_ERR_ADMIN_QUEUE_ERROR;
	default:
		return VIRTCHNL_STATUS_ERR_NOT_SUPPORTED;
	}
}