/* $NetBSD: if_sriov.c,v 1.18 2023/10/06 14:37:04 msaitoh Exp $ */
/******************************************************************************

  Copyright (c) 2001-2017, 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.

******************************************************************************/
/*$FreeBSD: head/sys/dev/ixgbe/if_sriov.c 327031 2017-12-20 18:15:06Z erj $*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: if_sriov.c,v 1.18 2023/10/06 14:37:04 msaitoh Exp $");

#include "ixgbe.h"
#include "ixgbe_sriov.h"

#ifdef PCI_IOV

MALLOC_DEFINE(M_IXGBE_SRIOV, "ix_sriov", "ix SR-IOV allocations");

/************************************************************************
 * ixgbe_pci_iov_detach
 ************************************************************************/
int
ixgbe_pci_iov_detach(device_t dev)
{
        return pci_iov_detach(dev);
}

/************************************************************************
 * ixgbe_define_iov_schemas
 ************************************************************************/
void
ixgbe_define_iov_schemas(device_t dev, int *error)
{
        nvlist_t *pf_schema, *vf_schema;

        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);
        *error = pci_iov_attach(dev, pf_schema, vf_schema);
        if (*error != 0) {
                device_printf(dev,
                    "Error %d setting up SR-IOV\n", *error);
        }
} /* ixgbe_define_iov_schemas */

/************************************************************************
 * ixgbe_align_all_queue_indices
 ************************************************************************/
inline void
ixgbe_align_all_queue_indices(struct ixgbe_softc *sc)
{
        int i;
        int index;

        for (i = 0; i < sc->num_queues; i++) {
                index = ixgbe_vf_que_index(sc->iov_mode, sc->pool, i);
                sc->rx_rings[i].me = index;
                sc->tx_rings[i].me = index;
        }
}

/* Support functions for SR-IOV/VF management */
static inline void
ixgbe_send_vf_msg(struct ixgbe_hw *hw, struct ixgbe_vf *vf, u32 msg)
{
        if (vf->flags & IXGBE_VF_CTS)
                msg |= IXGBE_VT_MSGTYPE_CTS;

        hw->mbx.ops[vf->pool].write(hw, &msg, 1, vf->pool);
}

static inline void
ixgbe_send_vf_ack(struct ixgbe_softc *sc, struct ixgbe_vf *vf, u32 msg)
{
        msg &= IXGBE_VT_MSG_MASK;
        ixgbe_send_vf_msg(&sc->hw, vf, msg | IXGBE_VT_MSGTYPE_SUCCESS);
}

static inline void
ixgbe_send_vf_nack(struct ixgbe_softc *sc, struct ixgbe_vf *vf, u32 msg)
{
        msg &= IXGBE_VT_MSG_MASK;
        ixgbe_send_vf_msg(&sc->hw, vf, msg | IXGBE_VT_MSGTYPE_FAILURE);
}

static inline void
ixgbe_process_vf_ack(struct ixgbe_softc *sc, struct ixgbe_vf *vf)
{
        if (!(vf->flags & IXGBE_VF_CTS))
                ixgbe_send_vf_nack(sc, vf, 0);
}

static inline bool
ixgbe_vf_mac_changed(struct ixgbe_vf *vf, const uint8_t *mac)
{
        return (bcmp(mac, vf->ether_addr, ETHER_ADDR_LEN) != 0);
}

static inline int
ixgbe_vf_queues(int mode)
{
        switch (mode) {
        case IXGBE_64_VM:
                return (2);
        case IXGBE_32_VM:
                return (4);
        case IXGBE_NO_VM:
        default:
                return (0);
        }
}

inline int
ixgbe_vf_que_index(int mode, int vfnum, int num)
{
        return ((vfnum * ixgbe_vf_queues(mode)) + num);
}

static inline void
ixgbe_update_max_frame(struct ixgbe_softc * sc, int max_frame)
{
        if (sc->max_frame_size < max_frame)
                sc->max_frame_size = max_frame;
}

inline u32
ixgbe_get_mrqc(int iov_mode)
{
        u32 mrqc;

        switch (iov_mode) {
        case IXGBE_64_VM:
                mrqc = IXGBE_MRQC_VMDQRSS64EN;
                break;
        case IXGBE_32_VM:
                mrqc = IXGBE_MRQC_VMDQRSS32EN;
                break;
        case IXGBE_NO_VM:
                mrqc = 0;
                break;
        default:
                panic("Unexpected SR-IOV mode %d", iov_mode);
        }

        return mrqc;
}


inline u32
ixgbe_get_mtqc(int iov_mode)
{
        uint32_t mtqc;

        switch (iov_mode) {
        case IXGBE_64_VM:
                mtqc = IXGBE_MTQC_64VF | IXGBE_MTQC_VT_ENA;
                break;
        case IXGBE_32_VM:
                mtqc = IXGBE_MTQC_32VF | IXGBE_MTQC_VT_ENA;
                break;
        case IXGBE_NO_VM:
                mtqc = IXGBE_MTQC_64Q_1PB;
                break;
        default:
                panic("Unexpected SR-IOV mode %d", iov_mode);
        }

        return mtqc;
}

void
ixgbe_ping_all_vfs(struct ixgbe_softc *sc)
{
        struct ixgbe_vf *vf;

        for (int i = 0; i < sc->num_vfs; i++) {
                vf = &sc->vfs[i];
                if (vf->flags & IXGBE_VF_ACTIVE)
                        ixgbe_send_vf_msg(&sc->hw, vf, IXGBE_PF_CONTROL_MSG);
        }
} /* ixgbe_ping_all_vfs */


static void
ixgbe_vf_set_default_vlan(struct ixgbe_softc *sc, struct ixgbe_vf *vf,
                          uint16_t tag)
{
        struct ixgbe_hw *hw;
        uint32_t vmolr, vmvir;

        hw = &sc->hw;

        vf->vlan_tag = tag;

        vmolr = IXGBE_READ_REG(hw, IXGBE_VMOLR(vf->pool));

        /* Do not receive packets that pass inexact filters. */
        vmolr &= ~(IXGBE_VMOLR_ROMPE | IXGBE_VMOLR_ROPE);

        /* Disable Multicast Promicuous Mode. */
        vmolr &= ~IXGBE_VMOLR_MPE;

        /* Accept broadcasts. */
        vmolr |= IXGBE_VMOLR_BAM;

        if (tag == 0) {
                /* Accept non-vlan tagged traffic. */
                vmolr |= IXGBE_VMOLR_AUPE;

                /* Allow VM to tag outgoing traffic; no default tag. */
                vmvir = 0;
        } else {
                /* Require vlan-tagged traffic. */
                vmolr &= ~IXGBE_VMOLR_AUPE;

                /* Tag all traffic with provided vlan tag. */
                vmvir = (tag | IXGBE_VMVIR_VLANA_DEFAULT);
        }
        IXGBE_WRITE_REG(hw, IXGBE_VMOLR(vf->pool), vmolr);
        IXGBE_WRITE_REG(hw, IXGBE_VMVIR(vf->pool), vmvir);
} /* ixgbe_vf_set_default_vlan */


static void
ixgbe_clear_vfmbmem(struct ixgbe_softc *sc, struct ixgbe_vf *vf)
{
        struct ixgbe_hw *hw = &sc->hw;
        uint32_t vf_index = IXGBE_VF_INDEX(vf->pool);
        uint16_t mbx_size = hw->mbx.size;
        uint16_t i;

        IXGBE_CORE_LOCK_ASSERT(sc);

        for (i = 0; i < mbx_size; ++i)
                IXGBE_WRITE_REG_ARRAY(hw, IXGBE_PFMBMEM(vf_index), i, 0x0);
} /* ixgbe_clear_vfmbmem */


static bool
ixgbe_vf_frame_size_compatible(struct ixgbe_softc *sc, struct ixgbe_vf *vf)
{

        /*
         * Frame size compatibility between PF and VF is only a problem on
         * 82599-based cards.  X540 and later support any combination of jumbo
         * frames on PFs and VFs.
         */
        if (sc->hw.mac.type != ixgbe_mac_82599EB)
                return (TRUE);

        switch (vf->api_ver) {
        case IXGBE_API_VER_1_0:
        case IXGBE_API_VER_UNKNOWN:
                /*
                 * On legacy (1.0 and older) VF versions, we don't support jumbo
                 * frames on either the PF or the VF.
                 */
                if (sc->max_frame_size > ETHER_MAX_LEN ||
                    vf->max_frame_size > ETHER_MAX_LEN)
                        return (FALSE);

                return (TRUE);

                break;
        case IXGBE_API_VER_1_1:
        default:
                /*
                 * 1.1 or later VF versions always work if they aren't using
                 * jumbo frames.
                 */
                if (vf->max_frame_size <= ETHER_MAX_LEN)
                        return (TRUE);

                /*
                 * Jumbo frames only work with VFs if the PF is also using jumbo
                 * frames.
                 */
                if (sc->max_frame_size <= ETHER_MAX_LEN)
                        return (TRUE);

                return (FALSE);
        }
} /* ixgbe_vf_frame_size_compatible */


static void
ixgbe_process_vf_reset(struct ixgbe_softc *sc, struct ixgbe_vf *vf)
{
        ixgbe_vf_set_default_vlan(sc, vf, vf->default_vlan);

        // XXX clear multicast addresses

        ixgbe_clear_rar(&sc->hw, vf->rar_index);
        ixgbe_clear_vfmbmem(sc, vf);
        ixgbe_toggle_txdctl(&sc->hw, IXGBE_VF_INDEX(vf->pool));

        vf->api_ver = IXGBE_API_VER_UNKNOWN;
} /* ixgbe_process_vf_reset */


static void
ixgbe_vf_enable_transmit(struct ixgbe_softc *sc, struct ixgbe_vf *vf)
{
        struct ixgbe_hw *hw;
        uint32_t vf_index, vfte;

        hw = &sc->hw;

        vf_index = IXGBE_VF_INDEX(vf->pool);
        vfte = IXGBE_READ_REG(hw, IXGBE_VFTE(vf_index));
        vfte |= IXGBE_VF_BIT(vf->pool);
        IXGBE_WRITE_REG(hw, IXGBE_VFTE(vf_index), vfte);
} /* ixgbe_vf_enable_transmit */


static void
ixgbe_vf_enable_receive(struct ixgbe_softc *sc, struct ixgbe_vf *vf)
{
        struct ixgbe_hw *hw;
        uint32_t vf_index, vfre;

        hw = &sc->hw;

        vf_index = IXGBE_VF_INDEX(vf->pool);
        vfre = IXGBE_READ_REG(hw, IXGBE_VFRE(vf_index));
        if (ixgbe_vf_frame_size_compatible(sc, vf))
                vfre |= IXGBE_VF_BIT(vf->pool);
        else
                vfre &= ~IXGBE_VF_BIT(vf->pool);
        IXGBE_WRITE_REG(hw, IXGBE_VFRE(vf_index), vfre);
} /* ixgbe_vf_enable_receive */


static void
ixgbe_vf_reset_msg(struct ixgbe_softc *sc, struct ixgbe_vf *vf, uint32_t *msg)
{
        struct ixgbe_hw *hw;
        uint32_t ack;
        uint32_t resp[IXGBE_VF_PERMADDR_MSG_LEN];

        hw = &sc->hw;

        ixgbe_process_vf_reset(sc, vf);

        if (ixgbe_validate_mac_addr(vf->ether_addr) == 0) {
                ixgbe_set_rar(&sc->hw, vf->rar_index, vf->ether_addr,
                    vf->pool, TRUE);
                ack = IXGBE_VT_MSGTYPE_SUCCESS;
        } else
                ack = IXGBE_VT_MSGTYPE_FAILURE;

        ixgbe_vf_enable_transmit(sc, vf);
        ixgbe_vf_enable_receive(sc, vf);

        vf->flags |= IXGBE_VF_CTS;

        resp[0] = IXGBE_VF_RESET | ack;
        bcopy(vf->ether_addr, &resp[1], ETHER_ADDR_LEN);
        resp[3] = hw->mac.mc_filter_type;
        hw->mbx.ops.write(hw, resp, IXGBE_VF_PERMADDR_MSG_LEN, vf->pool);
} /* ixgbe_vf_reset_msg */


static void
ixgbe_vf_set_mac(struct ixgbe_softc *sc, struct ixgbe_vf *vf, uint32_t *msg)
{
        uint8_t *mac;

        mac = (uint8_t*)&msg[1];

        /* Check that the VF has permission to change the MAC address. */
        if (!(vf->flags & IXGBE_VF_CAP_MAC) && ixgbe_vf_mac_changed(vf, mac)) {
                ixgbe_send_vf_nack(sc, vf, msg[0]);
                return;
        }

        if (ixgbe_validate_mac_addr(mac) != 0) {
                ixgbe_send_vf_nack(sc, vf, msg[0]);
                return;
        }

        bcopy(mac, vf->ether_addr, ETHER_ADDR_LEN);

        ixgbe_set_rar(&sc->hw, vf->rar_index, vf->ether_addr, vf->pool,
            TRUE);

        ixgbe_send_vf_ack(sc, vf, msg[0]);
} /* ixgbe_vf_set_mac */


/*
 * VF multicast addresses are set by using the appropriate bit in
 * 1 of 128 32 bit addresses (4096 possible).
 */
static void
ixgbe_vf_set_mc_addr(struct ixgbe_softc *sc, struct ixgbe_vf *vf, u32 *msg)
{
        u16     *list = (u16*)&msg[1];
        int     entries;
        u32     vmolr, vec_bit, vec_reg, mta_reg;

        entries = (msg[0] & IXGBE_VT_MSGINFO_MASK) >> IXGBE_VT_MSGINFO_SHIFT;
        entries = uimin(entries, IXGBE_MAX_VF_MC);

        vmolr = IXGBE_READ_REG(&sc->hw, IXGBE_VMOLR(vf->pool));

        vf->num_mc_hashes = entries;

        /* Set the appropriate MTA bit */
        for (int i = 0; i < entries; i++) {
                vf->mc_hash[i] = list[i];
                vec_reg = (vf->mc_hash[i] >> 5) & 0x7F;
                vec_bit = vf->mc_hash[i] & 0x1F;
                mta_reg = IXGBE_READ_REG(&sc->hw, IXGBE_MTA(vec_reg));
                mta_reg |= (1 << vec_bit);
                IXGBE_WRITE_REG(&sc->hw, IXGBE_MTA(vec_reg), mta_reg);
        }

        vmolr |= IXGBE_VMOLR_ROMPE;
        IXGBE_WRITE_REG(&sc->hw, IXGBE_VMOLR(vf->pool), vmolr);
        ixgbe_send_vf_ack(sc, vf, msg[0]);
} /* ixgbe_vf_set_mc_addr */


static void
ixgbe_vf_set_vlan(struct ixgbe_softc *sc, struct ixgbe_vf *vf, uint32_t *msg)
{
        struct ixgbe_hw *hw;
        int enable;
        uint16_t tag;

        hw = &sc->hw;
        enable = IXGBE_VT_MSGINFO(msg[0]);
        tag = msg[1] & IXGBE_VLVF_VLANID_MASK;

        if (!(vf->flags & IXGBE_VF_CAP_VLAN)) {
                ixgbe_send_vf_nack(sc, vf, msg[0]);
                return;
        }

        /* It is illegal to enable vlan tag 0. */
        if (tag == 0 && enable != 0) {
                ixgbe_send_vf_nack(sc, vf, msg[0]);
                return;
        }

        ixgbe_set_vfta(hw, tag, vf->pool, enable, false);
        ixgbe_send_vf_ack(sc, vf, msg[0]);
} /* ixgbe_vf_set_vlan */


static void
ixgbe_vf_set_lpe(struct ixgbe_softc *sc, struct ixgbe_vf *vf, uint32_t *msg)
{
        struct ixgbe_hw *hw;
        uint32_t vf_max_size, pf_max_size, mhadd;

        hw = &sc->hw;
        vf_max_size = msg[1];

        if (vf_max_size < ETHER_CRC_LEN) {
                /* We intentionally ACK invalid LPE requests. */
                ixgbe_send_vf_ack(sc, vf, msg[0]);
                return;
        }

        vf_max_size -= ETHER_CRC_LEN;

        if (vf_max_size > IXGBE_MAX_FRAME_SIZE) {
                /* We intentionally ACK invalid LPE requests. */
                ixgbe_send_vf_ack(sc, vf, msg[0]);
                return;
        }

        vf->max_frame_size = vf_max_size;
        ixgbe_update_max_frame(sc, vf->max_frame_size);

        /*
         * We might have to disable reception to this VF if the frame size is
         * not compatible with the config on the PF.
         */
        ixgbe_vf_enable_receive(sc, vf);

        mhadd = IXGBE_READ_REG(hw, IXGBE_MHADD);
        pf_max_size = (mhadd & IXGBE_MHADD_MFS_MASK) >> IXGBE_MHADD_MFS_SHIFT;

        if (pf_max_size < sc->max_frame_size) {
                mhadd &= ~IXGBE_MHADD_MFS_MASK;
                mhadd |= sc->max_frame_size << IXGBE_MHADD_MFS_SHIFT;
                IXGBE_WRITE_REG(hw, IXGBE_MHADD, mhadd);
        }

        ixgbe_send_vf_ack(sc, vf, msg[0]);
} /* ixgbe_vf_set_lpe */


static void
ixgbe_vf_set_macvlan(struct ixgbe_softc *sc, struct ixgbe_vf *vf,
                     uint32_t *msg)
{
        //XXX implement this
        ixgbe_send_vf_nack(sc, vf, msg[0]);
} /* ixgbe_vf_set_macvlan */


static void
ixgbe_vf_api_negotiate(struct ixgbe_softc *sc, struct ixgbe_vf *vf,
    uint32_t *msg)
{

        switch (msg[1]) {
        case IXGBE_API_VER_1_0:
        case IXGBE_API_VER_1_1:
                vf->api_ver = msg[1];
                ixgbe_send_vf_ack(sc, vf, msg[0]);
                break;
        default:
                vf->api_ver = IXGBE_API_VER_UNKNOWN;
                ixgbe_send_vf_nack(sc, vf, msg[0]);
                break;
        }
} /* ixgbe_vf_api_negotiate */


static void
ixgbe_vf_get_queues(struct ixgbe_softc *sc, struct ixgbe_vf *vf, uint32_t *msg)
{
        struct ixgbe_hw *hw;
        uint32_t resp[IXGBE_VF_GET_QUEUES_RESP_LEN];
        int num_queues;

        hw = &sc->hw;

        /* GET_QUEUES is not supported on pre-1.1 APIs. */
        switch (msg[0]) {
        case IXGBE_API_VER_1_0:
        case IXGBE_API_VER_UNKNOWN:
                ixgbe_send_vf_nack(sc, vf, msg[0]);
                return;
        }

        resp[0] = IXGBE_VF_GET_QUEUES | IXGBE_VT_MSGTYPE_SUCCESS |
            IXGBE_VT_MSGTYPE_CTS;

        num_queues = ixgbe_vf_queues(sc->iov_mode);
        resp[IXGBE_VF_TX_QUEUES] = num_queues;
        resp[IXGBE_VF_RX_QUEUES] = num_queues;
        resp[IXGBE_VF_TRANS_VLAN] = (vf->default_vlan != 0);
        resp[IXGBE_VF_DEF_QUEUE] = 0;

        hw->mbx.ops.write(hw, resp, IXGBE_VF_GET_QUEUES_RESP_LEN, vf->pool);
} /* ixgbe_vf_get_queues */


static void
ixgbe_process_vf_msg(struct ixgbe_softc *sc, struct ixgbe_vf *vf)
{
        struct ixgbe_hw *hw;
        uint32_t msg[IXGBE_VFMAILBOX_SIZE];
        int error;

        hw = &sc->hw;

        error = hw->mbx.ops[vf->pool].read(hw, msg, IXGBE_VFMAILBOX_SIZE,
            vf->pool);

        if (error != 0)
                return;

        CTR3(KTR_MALLOC, "%s: received msg %x from %d",
            sc->ifp->if_xname, msg[0], vf->pool);
        if (msg[0] == IXGBE_VF_RESET) {
                ixgbe_vf_reset_msg(sc, vf, msg);
                return;
        }

        if (!(vf->flags & IXGBE_VF_CTS)) {
                ixgbe_send_vf_nack(sc, vf, msg[0]);
                return;
        }

        switch (msg[0] & IXGBE_VT_MSG_MASK) {
        case IXGBE_VF_SET_MAC_ADDR:
                ixgbe_vf_set_mac(sc, vf, msg);
                break;
        case IXGBE_VF_SET_MULTICAST:
                ixgbe_vf_set_mc_addr(sc, vf, msg);
                break;
        case IXGBE_VF_SET_VLAN:
                ixgbe_vf_set_vlan(sc, vf, msg);
                break;
        case IXGBE_VF_SET_LPE:
                ixgbe_vf_set_lpe(sc, vf, msg);
                break;
        case IXGBE_VF_SET_MACVLAN:
                ixgbe_vf_set_macvlan(sc, vf, msg);
                break;
        case IXGBE_VF_API_NEGOTIATE:
                ixgbe_vf_api_negotiate(sc, vf, msg);
                break;
        case IXGBE_VF_GET_QUEUES:
                ixgbe_vf_get_queues(sc, vf, msg);
                break;
        default:
                ixgbe_send_vf_nack(sc, vf, msg[0]);
        }
} /* ixgbe_process_vf_msg */


/* Tasklet for handling VF -> PF mailbox messages */
void
ixgbe_handle_mbx(void *context)
{
        struct ixgbe_softc *sc = context;
        struct ixgbe_hw *hw;
        struct ixgbe_vf *vf;
        int i;

        KASSERT(mutex_owned(&sc->core_mtx));

        hw = &sc->hw;

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

                if ((vf->flags & IXGBE_VF_ACTIVE) == 0)
                        continue;

                if (hw->mbx.ops[vf->pool].check_for_rst(hw, vf->pool) == 0)
                        ixgbe_process_vf_reset(sc, vf);

                if (hw->mbx.ops[vf->pool].check_for_msg(hw, vf->pool) == 0)
                        ixgbe_process_vf_msg(sc, vf);

                if (hw->mbx.ops[vf->pool].check_for_ack(hw, vf->pool) == 0)
                        ixgbe_process_vf_ack(sc, vf);
        }
} /* ixgbe_handle_mbx */

int
ixgbe_init_iov(device_t dev, u16 num_vfs, const nvlist_t *config)
{
        struct ixgbe_softc *sc;
        int retval = 0;

        sc = device_get_softc(dev);
        sc->iov_mode = IXGBE_NO_VM;

        if (num_vfs == 0) {
                /* Would we ever get num_vfs = 0? */
                retval = EINVAL;
                goto err_init_iov;
        }

        /*
         * We've got to reserve a VM's worth of queues for the PF,
         * thus we go into "64 VF mode" if 32+ VFs are requested.
         * With 64 VFs, you can only have two queues per VF.
         * With 32 VFs, you can have up to four queues per VF.
         */
        if (num_vfs >= IXGBE_32_VM)
                sc->iov_mode = IXGBE_64_VM;
        else
                sc->iov_mode = IXGBE_32_VM;

        /* Again, reserving 1 VM's worth of queues for the PF */
        sc->pool = sc->iov_mode - 1;

        if ((num_vfs > sc->pool) || (num_vfs >= IXGBE_64_VM)) {
                retval = ENOSPC;
                goto err_init_iov;
        }

        IXGBE_CORE_LOCK(sc);

        sc->vfs = malloc(sizeof(*sc->vfs) * num_vfs, M_IXGBE_SRIOV,
            M_NOWAIT | M_ZERO);

        if (sc->vfs == NULL) {
                retval = ENOMEM;
                IXGBE_CORE_UNLOCK(sc);
                goto err_init_iov;
        }

        sc->num_vfs = num_vfs;
        ixgbe_init_mbx_params_pf(&sc->hw);

        /* set the SRIOV flag now as it's needed
         * by ixgbe_init_locked() */
        sc->feat_en |= IXGBE_FEATURE_SRIOV;
        sc->init_locked(sc);

        IXGBE_CORE_UNLOCK(sc);

        return retval;

err_init_iov:
        sc->num_vfs = 0;
        sc->pool = 0;
        sc->iov_mode = IXGBE_NO_VM;

        return retval;
} /* ixgbe_init_iov */

void
ixgbe_uninit_iov(device_t dev)
{
        struct ixgbe_hw *hw;
        struct ixgbe_softc *sc;
        uint32_t pf_reg, vf_reg;

        sc = device_get_softc(dev);
        hw = &sc->hw;

        IXGBE_CORE_LOCK(sc);

        /* Enable rx/tx for the PF and disable it for all VFs. */
        pf_reg = IXGBE_VF_INDEX(sc->pool);
        IXGBE_WRITE_REG(hw, IXGBE_VFRE(pf_reg), IXGBE_VF_BIT(sc->pool));
        IXGBE_WRITE_REG(hw, IXGBE_VFTE(pf_reg), IXGBE_VF_BIT(sc->pool));

        if (pf_reg == 0)
                vf_reg = 1;
        else
                vf_reg = 0;
        IXGBE_WRITE_REG(hw, IXGBE_VFRE(vf_reg), 0);
        IXGBE_WRITE_REG(hw, IXGBE_VFTE(vf_reg), 0);

        IXGBE_WRITE_REG(hw, IXGBE_VT_CTL, 0);

        free(sc->vfs, M_IXGBE_SRIOV);
        sc->vfs = NULL;
        sc->num_vfs = 0;
        sc->feat_en &= ~IXGBE_FEATURE_SRIOV;

        IXGBE_CORE_UNLOCK(sc);
} /* ixgbe_uninit_iov */

static void
ixgbe_init_vf(struct ixgbe_softc *sc, struct ixgbe_vf *vf)
{
        struct ixgbe_hw *hw;
        uint32_t vf_index, pfmbimr;

        IXGBE_CORE_LOCK_ASSERT(sc);

        hw = &sc->hw;

        if (!(vf->flags & IXGBE_VF_ACTIVE))
                return;

        vf_index = IXGBE_VF_INDEX(vf->pool);
        pfmbimr = IXGBE_READ_REG(hw, IXGBE_PFMBIMR(vf_index));
        pfmbimr |= IXGBE_VF_BIT(vf->pool);
        IXGBE_WRITE_REG(hw, IXGBE_PFMBIMR(vf_index), pfmbimr);

        ixgbe_vf_set_default_vlan(sc, vf, vf->vlan_tag);

        // XXX multicast addresses

        if (ixgbe_validate_mac_addr(vf->ether_addr) == 0) {
                ixgbe_set_rar(&sc->hw, vf->rar_index,
                    vf->ether_addr, vf->pool, TRUE);
        }

        ixgbe_vf_enable_transmit(sc, vf);
        ixgbe_vf_enable_receive(sc, vf);

        ixgbe_send_vf_msg(&sc->hw, vf, IXGBE_PF_CONTROL_MSG);
} /* ixgbe_init_vf */

void
ixgbe_initialize_iov(struct ixgbe_softc *sc)
{
        struct ixgbe_hw *hw = &sc->hw;
        uint32_t mrqc, mtqc, vt_ctl, vf_reg, gcr_ext, gpie;
        int i;

        if (sc->iov_mode == IXGBE_NO_VM)
                return;

        IXGBE_CORE_LOCK_ASSERT(sc);

        /* RMW appropriate registers based on IOV mode */
        /* Read... */
        mrqc    = IXGBE_READ_REG(hw, IXGBE_MRQC);
        gcr_ext = IXGBE_READ_REG(hw, IXGBE_GCR_EXT);
        gpie    = IXGBE_READ_REG(hw, IXGBE_GPIE);
        /* Modify... */
        mrqc    &= ~IXGBE_MRQC_MRQE_MASK;
        mtqc     =  IXGBE_MTQC_VT_ENA;      /* No initial MTQC read needed */
        gcr_ext |=  IXGBE_GCR_EXT_MSIX_EN;
        gcr_ext &= ~IXGBE_GCR_EXT_VT_MODE_MASK;
        gpie    &= ~IXGBE_GPIE_VTMODE_MASK;
        switch (sc->iov_mode) {
        case IXGBE_64_VM:
                mrqc    |= IXGBE_MRQC_VMDQRSS64EN;
                mtqc    |= IXGBE_MTQC_64VF;
                gcr_ext |= IXGBE_GCR_EXT_VT_MODE_64;
                gpie    |= IXGBE_GPIE_VTMODE_64;
                break;
        case IXGBE_32_VM:
                mrqc    |= IXGBE_MRQC_VMDQRSS32EN;
                mtqc    |= IXGBE_MTQC_32VF;
                gcr_ext |= IXGBE_GCR_EXT_VT_MODE_32;
                gpie    |= IXGBE_GPIE_VTMODE_32;
                break;
        default:
                panic("Unexpected SR-IOV mode %d", sc->iov_mode);
        }
        /* Write... */
        IXGBE_WRITE_REG(hw, IXGBE_MRQC, mrqc);
        IXGBE_WRITE_REG(hw, IXGBE_MTQC, mtqc);
        IXGBE_WRITE_REG(hw, IXGBE_GCR_EXT, gcr_ext);
        IXGBE_WRITE_REG(hw, IXGBE_GPIE, gpie);

        /* Enable rx/tx for the PF. */
        vf_reg = IXGBE_VF_INDEX(sc->pool);
        IXGBE_WRITE_REG(hw, IXGBE_VFRE(vf_reg), IXGBE_VF_BIT(sc->pool));
        IXGBE_WRITE_REG(hw, IXGBE_VFTE(vf_reg), IXGBE_VF_BIT(sc->pool));

        /* Allow VM-to-VM communication. */
        IXGBE_WRITE_REG(hw, IXGBE_PFDTXGSWC, IXGBE_PFDTXGSWC_VT_LBEN);

        vt_ctl = IXGBE_VT_CTL_VT_ENABLE | IXGBE_VT_CTL_REPLEN;
        vt_ctl |= (sc->pool << IXGBE_VT_CTL_POOL_SHIFT);
        IXGBE_WRITE_REG(hw, IXGBE_VT_CTL, vt_ctl);

        for (i = 0; i < sc->num_vfs; i++)
                ixgbe_init_vf(sc, &sc->vfs[i]);
} /* ixgbe_initialize_iov */


/* Check the max frame setting of all active VF's */
void
ixgbe_recalculate_max_frame(struct ixgbe_softc *sc)
{
        struct ixgbe_vf *vf;

        IXGBE_CORE_LOCK_ASSERT(sc);

        for (int i = 0; i < sc->num_vfs; i++) {
                vf = &sc->vfs[i];
                if (vf->flags & IXGBE_VF_ACTIVE)
                        ixgbe_update_max_frame(sc, vf->max_frame_size);
        }
} /* ixgbe_recalculate_max_frame */

int
ixgbe_add_vf(device_t dev, u16 vfnum, const nvlist_t *config)
{
        struct ixgbe_softc *sc;
        struct ixgbe_vf *vf;
        const void *mac;

        sc = device_get_softc(dev);

        KASSERT(vfnum < sc->num_vfs, ("VF index %d is out of range %d",
            vfnum, sc->num_vfs));

        IXGBE_CORE_LOCK(sc);
        vf = &sc->vfs[vfnum];
        vf->pool= vfnum;

        /* RAR[0] is used by the PF so use vfnum + 1 for VF RAR. */
        vf->rar_index = vfnum + 1;
        vf->default_vlan = 0;
        vf->max_frame_size = ETHER_MAX_LEN;
        ixgbe_update_max_frame(sc, vf->max_frame_size);

        if (nvlist_exists_binary(config, "mac-addr")) {
                mac = nvlist_get_binary(config, "mac-addr", NULL);
                bcopy(mac, vf->ether_addr, ETHER_ADDR_LEN);
                if (nvlist_get_bool(config, "allow-set-mac"))
                        vf->flags |= IXGBE_VF_CAP_MAC;
        } else
                /*
                 * If the administrator has not specified a MAC address then
                 * we must allow the VF to choose one.
                 */
                vf->flags |= IXGBE_VF_CAP_MAC;

        vf->flags |= IXGBE_VF_ACTIVE;

        ixgbe_init_vf(sc, vf);
        IXGBE_CORE_UNLOCK(sc);

        return (0);
} /* ixgbe_add_vf */

#else

void
ixgbe_handle_mbx(void *context)
{
        UNREFERENCED_1PARAMETER(context);
} /* ixgbe_handle_mbx */

inline int
ixgbe_vf_que_index(int mode, int vfnum, int num)
{
        UNREFERENCED_2PARAMETER(mode, vfnum);

        return num;
} /* ixgbe_vf_que_index */

#endif