// SPDX-License-Identifier: GPL-2.0-only
/* Copyright (C) 2023 Intel Corporation */

#include "idpf.h"
#include "idpf_virtchnl.h"
#include "idpf_ptp.h"
#include "xdp.h"
#include "xsk.h"

static const struct net_device_ops idpf_netdev_ops;

/**
 * idpf_init_vector_stack - Fill the MSIX vector stack with vector index
 * @adapter: private data struct
 *
 * Return 0 on success, error on failure
 */
static int idpf_init_vector_stack(struct idpf_adapter *adapter)
{
        struct idpf_vector_lifo *stack;
        u16 min_vec;
        u32 i;

        mutex_lock(&adapter->vector_lock);
        min_vec = adapter->num_msix_entries - adapter->num_avail_msix;
        stack = &adapter->vector_stack;
        stack->size = adapter->num_msix_entries;
        /* set the base and top to point at start of the 'free pool' to
         * distribute the unused vectors on-demand basis
         */
        stack->base = min_vec;
        stack->top = min_vec;

        stack->vec_idx = kcalloc(stack->size, sizeof(u16), GFP_KERNEL);
        if (!stack->vec_idx) {
                mutex_unlock(&adapter->vector_lock);

                return -ENOMEM;
        }

        for (i = 0; i < stack->size; i++)
                stack->vec_idx[i] = i;

        mutex_unlock(&adapter->vector_lock);

        return 0;
}

/**
 * idpf_deinit_vector_stack - zero out the MSIX vector stack
 * @adapter: private data struct
 */
static void idpf_deinit_vector_stack(struct idpf_adapter *adapter)
{
        struct idpf_vector_lifo *stack;

        mutex_lock(&adapter->vector_lock);
        stack = &adapter->vector_stack;
        kfree(stack->vec_idx);
        stack->vec_idx = NULL;
        mutex_unlock(&adapter->vector_lock);
}

/**
 * idpf_mb_intr_rel_irq - Free the IRQ association with the OS
 * @adapter: adapter structure
 *
 * This will also disable interrupt mode and queue up mailbox task. Mailbox
 * task will reschedule itself if not in interrupt mode.
 */
static void idpf_mb_intr_rel_irq(struct idpf_adapter *adapter)
{
        clear_bit(IDPF_MB_INTR_MODE, adapter->flags);
        kfree(free_irq(adapter->msix_entries[0].vector, adapter));
        queue_delayed_work(adapter->mbx_wq, &adapter->mbx_task, 0);
}

/**
 * idpf_intr_rel - Release interrupt capabilities and free memory
 * @adapter: adapter to disable interrupts on
 */
void idpf_intr_rel(struct idpf_adapter *adapter)
{
        if (!adapter->msix_entries)
                return;

        idpf_mb_intr_rel_irq(adapter);
        pci_free_irq_vectors(adapter->pdev);
        idpf_send_dealloc_vectors_msg(adapter);
        idpf_deinit_vector_stack(adapter);
        kfree(adapter->msix_entries);
        adapter->msix_entries = NULL;
        kfree(adapter->rdma_msix_entries);
        adapter->rdma_msix_entries = NULL;
}

/**
 * idpf_mb_intr_clean - Interrupt handler for the mailbox
 * @irq: interrupt number
 * @data: pointer to the adapter structure
 */
static irqreturn_t idpf_mb_intr_clean(int __always_unused irq, void *data)
{
        struct idpf_adapter *adapter = (struct idpf_adapter *)data;

        queue_delayed_work(adapter->mbx_wq, &adapter->mbx_task, 0);

        return IRQ_HANDLED;
}

/**
 * idpf_mb_irq_enable - Enable MSIX interrupt for the mailbox
 * @adapter: adapter to get the hardware address for register write
 */
static void idpf_mb_irq_enable(struct idpf_adapter *adapter)
{
        struct idpf_intr_reg *intr = &adapter->mb_vector.intr_reg;
        u32 val;

        val = intr->dyn_ctl_intena_m | intr->dyn_ctl_itridx_m;
        writel(val, intr->dyn_ctl);
        writel(intr->icr_ena_ctlq_m, intr->icr_ena);
}

/**
 * idpf_mb_intr_req_irq - Request irq for the mailbox interrupt
 * @adapter: adapter structure to pass to the mailbox irq handler
 */
static int idpf_mb_intr_req_irq(struct idpf_adapter *adapter)
{
        int irq_num, mb_vidx = 0, err;
        char *name;

        irq_num = adapter->msix_entries[mb_vidx].vector;
        name = kasprintf(GFP_KERNEL, "%s-%s-%d",
                         dev_driver_string(&adapter->pdev->dev),
                         "Mailbox", mb_vidx);
        err = request_irq(irq_num, adapter->irq_mb_handler, 0, name, adapter);
        if (err) {
                dev_err(&adapter->pdev->dev,
                        "IRQ request for mailbox failed, error: %d\n", err);

                return err;
        }

        set_bit(IDPF_MB_INTR_MODE, adapter->flags);

        return 0;
}

/**
 * idpf_mb_intr_init - Initialize the mailbox interrupt
 * @adapter: adapter structure to store the mailbox vector
 */
static int idpf_mb_intr_init(struct idpf_adapter *adapter)
{
        adapter->dev_ops.reg_ops.mb_intr_reg_init(adapter);
        adapter->irq_mb_handler = idpf_mb_intr_clean;

        return idpf_mb_intr_req_irq(adapter);
}

/**
 * idpf_vector_lifo_push - push MSIX vector index onto stack
 * @adapter: private data struct
 * @vec_idx: vector index to store
 */
static int idpf_vector_lifo_push(struct idpf_adapter *adapter, u16 vec_idx)
{
        struct idpf_vector_lifo *stack = &adapter->vector_stack;

        lockdep_assert_held(&adapter->vector_lock);

        if (stack->top == stack->base) {
                dev_err(&adapter->pdev->dev, "Exceeded the vector stack limit: %d\n",
                        stack->top);
                return -EINVAL;
        }

        stack->vec_idx[--stack->top] = vec_idx;

        return 0;
}

/**
 * idpf_vector_lifo_pop - pop MSIX vector index from stack
 * @adapter: private data struct
 */
static int idpf_vector_lifo_pop(struct idpf_adapter *adapter)
{
        struct idpf_vector_lifo *stack = &adapter->vector_stack;

        lockdep_assert_held(&adapter->vector_lock);

        if (stack->top == stack->size) {
                dev_err(&adapter->pdev->dev, "No interrupt vectors are available to distribute!\n");

                return -EINVAL;
        }

        return stack->vec_idx[stack->top++];
}

/**
 * idpf_vector_stash - Store the vector indexes onto the stack
 * @adapter: private data struct
 * @q_vector_idxs: vector index array
 * @vec_info: info related to the number of vectors
 *
 * This function is a no-op if there are no vectors indexes to be stashed
 */
static void idpf_vector_stash(struct idpf_adapter *adapter, u16 *q_vector_idxs,
                              struct idpf_vector_info *vec_info)
{
        int i, base = 0;
        u16 vec_idx;

        lockdep_assert_held(&adapter->vector_lock);

        if (!vec_info->num_curr_vecs)
                return;

        /* For default vports, no need to stash vector allocated from the
         * default pool onto the stack
         */
        if (vec_info->default_vport)
                base = IDPF_MIN_Q_VEC;

        for (i = vec_info->num_curr_vecs - 1; i >= base ; i--) {
                vec_idx = q_vector_idxs[i];
                idpf_vector_lifo_push(adapter, vec_idx);
                adapter->num_avail_msix++;
        }
}

/**
 * idpf_req_rel_vector_indexes - Request or release MSIX vector indexes
 * @adapter: driver specific private structure
 * @q_vector_idxs: vector index array
 * @vec_info: info related to the number of vectors
 *
 * This is the core function to distribute the MSIX vectors acquired from the
 * OS. It expects the caller to pass the number of vectors required and
 * also previously allocated. First, it stashes previously allocated vector
 * indexes on to the stack and then figures out if it can allocate requested
 * vectors. It can wait on acquiring the mutex lock. If the caller passes 0 as
 * requested vectors, then this function just stashes the already allocated
 * vectors and returns 0.
 *
 * Returns actual number of vectors allocated on success, error value on failure
 * If 0 is returned, implies the stack has no vectors to allocate which is also
 * a failure case for the caller
 */
int idpf_req_rel_vector_indexes(struct idpf_adapter *adapter,
                                u16 *q_vector_idxs,
                                struct idpf_vector_info *vec_info)
{
        u16 num_req_vecs, num_alloc_vecs = 0, max_vecs;
        struct idpf_vector_lifo *stack;
        int i, j, vecid;

        mutex_lock(&adapter->vector_lock);
        stack = &adapter->vector_stack;
        num_req_vecs = vec_info->num_req_vecs;

        /* Stash interrupt vector indexes onto the stack if required */
        idpf_vector_stash(adapter, q_vector_idxs, vec_info);

        if (!num_req_vecs)
                goto rel_lock;

        if (vec_info->default_vport) {
                /* As IDPF_MIN_Q_VEC per default vport is put aside in the
                 * default pool of the stack, use them for default vports
                 */
                j = vec_info->index * IDPF_MIN_Q_VEC + IDPF_MBX_Q_VEC;
                for (i = 0; i < IDPF_MIN_Q_VEC; i++) {
                        q_vector_idxs[num_alloc_vecs++] = stack->vec_idx[j++];
                        num_req_vecs--;
                }
        }

        /* Find if stack has enough vector to allocate */
        max_vecs = min(adapter->num_avail_msix, num_req_vecs);

        for (j = 0; j < max_vecs; j++) {
                vecid = idpf_vector_lifo_pop(adapter);
                q_vector_idxs[num_alloc_vecs++] = vecid;
        }
        adapter->num_avail_msix -= max_vecs;

rel_lock:
        mutex_unlock(&adapter->vector_lock);

        return num_alloc_vecs;
}

/**
 * idpf_intr_req - Request interrupt capabilities
 * @adapter: adapter to enable interrupts on
 *
 * Returns 0 on success, negative on failure
 */
int idpf_intr_req(struct idpf_adapter *adapter)
{
        u16 num_lan_vecs, min_lan_vecs, num_rdma_vecs = 0, min_rdma_vecs = 0;
        u16 default_vports = idpf_get_default_vports(adapter);
        int num_q_vecs, total_vecs, num_vec_ids;
        int min_vectors, actual_vecs, err;
        unsigned int vector;
        u16 *vecids;
        int i;

        total_vecs = idpf_get_reserved_vecs(adapter);
        num_lan_vecs = total_vecs;
        if (idpf_is_rdma_cap_ena(adapter)) {
                num_rdma_vecs = idpf_get_reserved_rdma_vecs(adapter);
                min_rdma_vecs = IDPF_MIN_RDMA_VEC;

                if (!num_rdma_vecs) {
                        /* If idpf_get_reserved_rdma_vecs is 0, vectors are
                         * pulled from the LAN pool.
                         */
                        num_rdma_vecs = min_rdma_vecs;
                } else if (num_rdma_vecs < min_rdma_vecs) {
                        dev_err(&adapter->pdev->dev,
                                "Not enough vectors reserved for RDMA (min: %u, current: %u)\n",
                                min_rdma_vecs, num_rdma_vecs);
                        return -EINVAL;
                }
        }

        num_q_vecs = total_vecs - IDPF_MBX_Q_VEC;

        err = idpf_send_alloc_vectors_msg(adapter, num_q_vecs);
        if (err) {
                dev_err(&adapter->pdev->dev,
                        "Failed to allocate %d vectors: %d\n", num_q_vecs, err);

                return -EAGAIN;
        }

        min_lan_vecs = IDPF_MBX_Q_VEC + IDPF_MIN_Q_VEC * default_vports;
        min_vectors = min_lan_vecs + min_rdma_vecs;
        actual_vecs = pci_alloc_irq_vectors(adapter->pdev, min_vectors,
                                            total_vecs, PCI_IRQ_MSIX);
        if (actual_vecs < 0) {
                dev_err(&adapter->pdev->dev, "Failed to allocate minimum MSIX vectors required: %d\n",
                        min_vectors);
                err = actual_vecs;
                goto send_dealloc_vecs;
        }

        if (idpf_is_rdma_cap_ena(adapter)) {
                if (actual_vecs < total_vecs) {
                        dev_warn(&adapter->pdev->dev,
                                 "Warning: %d vectors requested, only %d available. Defaulting to minimum (%d) for RDMA and remaining for LAN.\n",
                                 total_vecs, actual_vecs, IDPF_MIN_RDMA_VEC);
                        num_rdma_vecs = IDPF_MIN_RDMA_VEC;
                }

                adapter->rdma_msix_entries = kzalloc_objs(struct msix_entry,
                                                          num_rdma_vecs);
                if (!adapter->rdma_msix_entries) {
                        err = -ENOMEM;
                        goto free_irq;
                }
        }

        num_lan_vecs = actual_vecs - num_rdma_vecs;
        adapter->msix_entries = kzalloc_objs(struct msix_entry, num_lan_vecs);
        if (!adapter->msix_entries) {
                err = -ENOMEM;
                goto free_rdma_msix;
        }

        adapter->mb_vector.v_idx = le16_to_cpu(adapter->caps.mailbox_vector_id);

        vecids = kcalloc(actual_vecs, sizeof(u16), GFP_KERNEL);
        if (!vecids) {
                err = -ENOMEM;
                goto free_msix;
        }

        num_vec_ids = idpf_get_vec_ids(adapter, vecids, actual_vecs,
                                       &adapter->req_vec_chunks->vchunks);
        if (num_vec_ids < actual_vecs) {
                err = -EINVAL;
                goto free_vecids;
        }

        for (vector = 0; vector < num_lan_vecs; vector++) {
                adapter->msix_entries[vector].entry = vecids[vector];
                adapter->msix_entries[vector].vector =
                        pci_irq_vector(adapter->pdev, vector);
        }
        for (i = 0; i < num_rdma_vecs; vector++, i++) {
                adapter->rdma_msix_entries[i].entry = vecids[vector];
                adapter->rdma_msix_entries[i].vector =
                        pci_irq_vector(adapter->pdev, vector);
        }

        /* 'num_avail_msix' is used to distribute excess vectors to the vports
         * after considering the minimum vectors required per each default
         * vport
         */
        adapter->num_avail_msix = num_lan_vecs - min_lan_vecs;
        adapter->num_msix_entries = num_lan_vecs;
        if (idpf_is_rdma_cap_ena(adapter))
                adapter->num_rdma_msix_entries = num_rdma_vecs;

        /* Fill MSIX vector lifo stack with vector indexes */
        err = idpf_init_vector_stack(adapter);
        if (err)
                goto free_vecids;

        err = idpf_mb_intr_init(adapter);
        if (err)
                goto deinit_vec_stack;
        idpf_mb_irq_enable(adapter);
        kfree(vecids);

        return 0;

deinit_vec_stack:
        idpf_deinit_vector_stack(adapter);
free_vecids:
        kfree(vecids);
free_msix:
        kfree(adapter->msix_entries);
        adapter->msix_entries = NULL;
free_rdma_msix:
        kfree(adapter->rdma_msix_entries);
        adapter->rdma_msix_entries = NULL;
free_irq:
        pci_free_irq_vectors(adapter->pdev);
send_dealloc_vecs:
        idpf_send_dealloc_vectors_msg(adapter);

        return err;
}

/**
 * idpf_del_all_flow_steer_filters - Delete all flow steer filters in list
 * @vport: main vport struct
 *
 * Takes flow_steer_list_lock spinlock.  Deletes all filters
 */
static void idpf_del_all_flow_steer_filters(struct idpf_vport *vport)
{
        struct idpf_vport_config *vport_config;
        struct idpf_fsteer_fltr *f, *ftmp;

        vport_config = vport->adapter->vport_config[vport->idx];

        spin_lock_bh(&vport_config->flow_steer_list_lock);
        list_for_each_entry_safe(f, ftmp, &vport_config->user_config.flow_steer_list,
                                 list) {
                list_del(&f->list);
                kfree(f);
        }
        vport_config->user_config.num_fsteer_fltrs = 0;
        spin_unlock_bh(&vport_config->flow_steer_list_lock);
}

/**
 * idpf_find_mac_filter - Search filter list for specific mac filter
 * @vconfig: Vport config structure
 * @macaddr: The MAC address
 *
 * Returns ptr to the filter object or NULL. Must be called while holding the
 * mac_filter_list_lock.
 **/
static struct idpf_mac_filter *idpf_find_mac_filter(struct idpf_vport_config *vconfig,
                                                    const u8 *macaddr)
{
        struct idpf_mac_filter *f;

        if (!macaddr)
                return NULL;

        list_for_each_entry(f, &vconfig->user_config.mac_filter_list, list) {
                if (ether_addr_equal(macaddr, f->macaddr))
                        return f;
        }

        return NULL;
}

/**
 * __idpf_del_mac_filter - Delete a MAC filter from the filter list
 * @vport_config: Vport config structure
 * @macaddr: The MAC address
 *
 * Returns 0 on success, error value on failure
 **/
static int __idpf_del_mac_filter(struct idpf_vport_config *vport_config,
                                 const u8 *macaddr)
{
        struct idpf_mac_filter *f;

        spin_lock_bh(&vport_config->mac_filter_list_lock);
        f = idpf_find_mac_filter(vport_config, macaddr);
        if (f) {
                list_del(&f->list);
                kfree(f);
        }
        spin_unlock_bh(&vport_config->mac_filter_list_lock);

        return 0;
}

/**
 * idpf_del_mac_filter - Delete a MAC filter from the filter list
 * @vport: Main vport structure
 * @np: Netdev private structure
 * @macaddr: The MAC address
 * @async: Don't wait for return message
 *
 * Removes filter from list and if interface is up, tells hardware about the
 * removed filter.
 **/
static int idpf_del_mac_filter(struct idpf_vport *vport,
                               struct idpf_netdev_priv *np,
                               const u8 *macaddr, bool async)
{
        struct idpf_vport_config *vport_config;
        struct idpf_mac_filter *f;

        vport_config = np->adapter->vport_config[np->vport_idx];

        spin_lock_bh(&vport_config->mac_filter_list_lock);
        f = idpf_find_mac_filter(vport_config, macaddr);
        if (f) {
                f->remove = true;
        } else {
                spin_unlock_bh(&vport_config->mac_filter_list_lock);

                return -EINVAL;
        }
        spin_unlock_bh(&vport_config->mac_filter_list_lock);

        if (test_bit(IDPF_VPORT_UP, np->state)) {
                int err;

                err = idpf_add_del_mac_filters(np->adapter, vport_config,
                                               vport->default_mac_addr,
                                               np->vport_id, false, async);
                if (err)
                        return err;
        }

        return  __idpf_del_mac_filter(vport_config, macaddr);
}

/**
 * __idpf_add_mac_filter - Add mac filter helper function
 * @vport_config: Vport config structure
 * @macaddr: Address to add
 *
 * Takes mac_filter_list_lock spinlock to add new filter to list.
 */
static int __idpf_add_mac_filter(struct idpf_vport_config *vport_config,
                                 const u8 *macaddr)
{
        struct idpf_mac_filter *f;

        spin_lock_bh(&vport_config->mac_filter_list_lock);

        f = idpf_find_mac_filter(vport_config, macaddr);
        if (f) {
                f->remove = false;
                spin_unlock_bh(&vport_config->mac_filter_list_lock);

                return 0;
        }

        f = kzalloc_obj(*f, GFP_ATOMIC);
        if (!f) {
                spin_unlock_bh(&vport_config->mac_filter_list_lock);

                return -ENOMEM;
        }

        ether_addr_copy(f->macaddr, macaddr);
        list_add_tail(&f->list, &vport_config->user_config.mac_filter_list);
        f->add = true;

        spin_unlock_bh(&vport_config->mac_filter_list_lock);

        return 0;
}

/**
 * idpf_add_mac_filter - Add a mac filter to the filter list
 * @vport: Main vport structure
 * @np: Netdev private structure
 * @macaddr: The MAC address
 * @async: Don't wait for return message
 *
 * Returns 0 on success or error on failure. If interface is up, we'll also
 * send the virtchnl message to tell hardware about the filter.
 **/
static int idpf_add_mac_filter(struct idpf_vport *vport,
                               struct idpf_netdev_priv *np,
                               const u8 *macaddr, bool async)
{
        struct idpf_vport_config *vport_config;
        int err;

        vport_config = np->adapter->vport_config[np->vport_idx];
        err = __idpf_add_mac_filter(vport_config, macaddr);
        if (err)
                return err;

        if (test_bit(IDPF_VPORT_UP, np->state))
                err = idpf_add_del_mac_filters(np->adapter, vport_config,
                                               vport->default_mac_addr,
                                               np->vport_id, true, async);

        return err;
}

/**
 * idpf_del_all_mac_filters - Delete all MAC filters in list
 * @vport: main vport struct
 *
 * Takes mac_filter_list_lock spinlock.  Deletes all filters
 */
static void idpf_del_all_mac_filters(struct idpf_vport *vport)
{
        struct idpf_vport_config *vport_config;
        struct idpf_mac_filter *f, *ftmp;

        vport_config = vport->adapter->vport_config[vport->idx];
        spin_lock_bh(&vport_config->mac_filter_list_lock);

        list_for_each_entry_safe(f, ftmp, &vport_config->user_config.mac_filter_list,
                                 list) {
                list_del(&f->list);
                kfree(f);
        }

        spin_unlock_bh(&vport_config->mac_filter_list_lock);
}

/**
 * idpf_restore_mac_filters - Re-add all MAC filters in list
 * @vport: main vport struct
 *
 * Takes mac_filter_list_lock spinlock.  Sets add field to true for filters to
 * resync filters back to HW.
 */
static void idpf_restore_mac_filters(struct idpf_vport *vport)
{
        struct idpf_vport_config *vport_config;
        struct idpf_mac_filter *f;

        vport_config = vport->adapter->vport_config[vport->idx];
        spin_lock_bh(&vport_config->mac_filter_list_lock);

        list_for_each_entry(f, &vport_config->user_config.mac_filter_list, list)
                f->add = true;

        spin_unlock_bh(&vport_config->mac_filter_list_lock);

        idpf_add_del_mac_filters(vport->adapter, vport_config,
                                 vport->default_mac_addr, vport->vport_id,
                                 true, false);
}

/**
 * idpf_remove_mac_filters - Remove all MAC filters in list
 * @vport: main vport struct
 *
 * Takes mac_filter_list_lock spinlock. Sets remove field to true for filters
 * to remove filters in HW.
 */
static void idpf_remove_mac_filters(struct idpf_vport *vport)
{
        struct idpf_vport_config *vport_config;
        struct idpf_mac_filter *f;

        vport_config = vport->adapter->vport_config[vport->idx];
        spin_lock_bh(&vport_config->mac_filter_list_lock);

        list_for_each_entry(f, &vport_config->user_config.mac_filter_list, list)
                f->remove = true;

        spin_unlock_bh(&vport_config->mac_filter_list_lock);

        idpf_add_del_mac_filters(vport->adapter, vport_config,
                                 vport->default_mac_addr, vport->vport_id,
                                 false, false);
}

/**
 * idpf_deinit_mac_addr - deinitialize mac address for vport
 * @vport: main vport structure
 */
static void idpf_deinit_mac_addr(struct idpf_vport *vport)
{
        struct idpf_vport_config *vport_config;
        struct idpf_mac_filter *f;

        vport_config = vport->adapter->vport_config[vport->idx];

        spin_lock_bh(&vport_config->mac_filter_list_lock);

        f = idpf_find_mac_filter(vport_config, vport->default_mac_addr);
        if (f) {
                list_del(&f->list);
                kfree(f);
        }

        spin_unlock_bh(&vport_config->mac_filter_list_lock);
}

/**
 * idpf_init_mac_addr - initialize mac address for vport
 * @vport: main vport structure
 * @netdev: pointer to netdev struct associated with this vport
 */
static int idpf_init_mac_addr(struct idpf_vport *vport,
                              struct net_device *netdev)
{
        struct idpf_netdev_priv *np = netdev_priv(netdev);
        struct idpf_adapter *adapter = vport->adapter;
        int err;

        if (is_valid_ether_addr(vport->default_mac_addr)) {
                eth_hw_addr_set(netdev, vport->default_mac_addr);
                ether_addr_copy(netdev->perm_addr, vport->default_mac_addr);

                return idpf_add_mac_filter(vport, np, vport->default_mac_addr,
                                           false);
        }

        if (!idpf_is_cap_ena(adapter, IDPF_OTHER_CAPS,
                             VIRTCHNL2_CAP_MACFILTER)) {
                dev_err(&adapter->pdev->dev,
                        "MAC address is not provided and capability is not set\n");

                return -EINVAL;
        }

        eth_hw_addr_random(netdev);
        err = idpf_add_mac_filter(vport, np, netdev->dev_addr, false);
        if (err)
                return err;

        dev_info(&adapter->pdev->dev, "Invalid MAC address %pM, using random %pM\n",
                 vport->default_mac_addr, netdev->dev_addr);
        ether_addr_copy(vport->default_mac_addr, netdev->dev_addr);

        return 0;
}

static void idpf_detach_and_close(struct idpf_adapter *adapter)
{
        int max_vports = adapter->max_vports;

        for (int i = 0; i < max_vports; i++) {
                struct net_device *netdev = adapter->netdevs[i];

                /* If the interface is in detached state, that means the
                 * previous reset was not handled successfully for this
                 * vport.
                 */
                if (!netif_device_present(netdev))
                        continue;

                /* Hold RTNL to protect racing with callbacks */
                rtnl_lock();
                netif_device_detach(netdev);
                if (netif_running(netdev)) {
                        set_bit(IDPF_VPORT_UP_REQUESTED,
                                adapter->vport_config[i]->flags);
                        dev_close(netdev);
                }
                rtnl_unlock();
        }
}

static void idpf_attach_and_open(struct idpf_adapter *adapter)
{
        int max_vports = adapter->max_vports;

        for (int i = 0; i < max_vports; i++) {
                struct idpf_vport *vport = adapter->vports[i];
                struct idpf_vport_config *vport_config;
                struct net_device *netdev;

                /* In case of a critical error in the init task, the vport
                 * will be freed. Only continue to restore the netdevs
                 * if the vport is allocated.
                 */
                if (!vport)
                        continue;

                /* No need for RTNL on attach as this function is called
                 * following detach and dev_close(). We do take RTNL for
                 * dev_open() below as it can race with external callbacks
                 * following the call to netif_device_attach().
                 */
                netdev = adapter->netdevs[i];
                netif_device_attach(netdev);
                vport_config = adapter->vport_config[vport->idx];
                if (test_and_clear_bit(IDPF_VPORT_UP_REQUESTED,
                                       vport_config->flags)) {
                        rtnl_lock();
                        dev_open(netdev, NULL);
                        rtnl_unlock();
                }
        }
}

/**
 * idpf_cfg_netdev - Allocate, configure and register a netdev
 * @vport: main vport structure
 *
 * Returns 0 on success, negative value on failure.
 */
static int idpf_cfg_netdev(struct idpf_vport *vport)
{
        struct idpf_adapter *adapter = vport->adapter;
        struct idpf_vport_config *vport_config;
        netdev_features_t other_offloads = 0;
        netdev_features_t csum_offloads = 0;
        netdev_features_t tso_offloads = 0;
        netdev_features_t dflt_features;
        struct idpf_netdev_priv *np;
        struct net_device *netdev;
        u16 idx = vport->idx;
        int err;

        vport_config = adapter->vport_config[idx];

        /* It's possible we already have a netdev allocated and registered for
         * this vport
         */
        if (test_bit(IDPF_VPORT_REG_NETDEV, vport_config->flags)) {
                netdev = adapter->netdevs[idx];
                np = netdev_priv(netdev);
                np->vport = vport;
                np->vport_idx = vport->idx;
                np->vport_id = vport->vport_id;
                np->max_tx_hdr_size = idpf_get_max_tx_hdr_size(adapter);
                vport->netdev = netdev;

                return idpf_init_mac_addr(vport, netdev);
        }

        netdev = alloc_etherdev_mqs(sizeof(struct idpf_netdev_priv),
                                    vport_config->max_q.max_txq,
                                    vport_config->max_q.max_rxq);
        if (!netdev)
                return -ENOMEM;

        vport->netdev = netdev;
        np = netdev_priv(netdev);
        np->vport = vport;
        np->adapter = adapter;
        np->vport_idx = vport->idx;
        np->vport_id = vport->vport_id;
        np->max_tx_hdr_size = idpf_get_max_tx_hdr_size(adapter);
        np->tx_max_bufs = idpf_get_max_tx_bufs(adapter);

        spin_lock_init(&np->stats_lock);

        err = idpf_init_mac_addr(vport, netdev);
        if (err) {
                free_netdev(vport->netdev);
                vport->netdev = NULL;

                return err;
        }

        /* assign netdev_ops */
        netdev->netdev_ops = &idpf_netdev_ops;

        /* setup watchdog timeout value to be 5 second */
        netdev->watchdog_timeo = 5 * HZ;

        netdev->dev_port = idx;

        /* configure default MTU size */
        netdev->min_mtu = ETH_MIN_MTU;
        netdev->max_mtu = vport->max_mtu;

        dflt_features = NETIF_F_SG      |
                        NETIF_F_HIGHDMA;

        if (idpf_is_cap_ena_all(adapter, IDPF_RSS_CAPS, IDPF_CAP_RSS))
                dflt_features |= NETIF_F_RXHASH;
        if (idpf_is_cap_ena(adapter, IDPF_OTHER_CAPS,
                            VIRTCHNL2_CAP_FLOW_STEER) &&
            idpf_vport_is_cap_ena(vport, VIRTCHNL2_VPORT_SIDEBAND_FLOW_STEER))
                dflt_features |= NETIF_F_NTUPLE;
        if (idpf_is_cap_ena_all(adapter, IDPF_CSUM_CAPS, IDPF_CAP_TX_CSUM_L4V4))
                csum_offloads |= NETIF_F_IP_CSUM;
        if (idpf_is_cap_ena_all(adapter, IDPF_CSUM_CAPS, IDPF_CAP_TX_CSUM_L4V6))
                csum_offloads |= NETIF_F_IPV6_CSUM;
        if (idpf_is_cap_ena(adapter, IDPF_CSUM_CAPS, IDPF_CAP_RX_CSUM))
                csum_offloads |= NETIF_F_RXCSUM;
        if (idpf_is_cap_ena_all(adapter, IDPF_CSUM_CAPS, IDPF_CAP_TX_SCTP_CSUM))
                csum_offloads |= NETIF_F_SCTP_CRC;

        if (idpf_is_cap_ena(adapter, IDPF_SEG_CAPS, VIRTCHNL2_CAP_SEG_IPV4_TCP))
                tso_offloads |= NETIF_F_TSO;
        if (idpf_is_cap_ena(adapter, IDPF_SEG_CAPS, VIRTCHNL2_CAP_SEG_IPV6_TCP))
                tso_offloads |= NETIF_F_TSO6;
        if (idpf_is_cap_ena_all(adapter, IDPF_SEG_CAPS,
                                VIRTCHNL2_CAP_SEG_IPV4_UDP |
                                VIRTCHNL2_CAP_SEG_IPV6_UDP))
                tso_offloads |= NETIF_F_GSO_UDP_L4;
        if (idpf_is_cap_ena_all(adapter, IDPF_RSC_CAPS, IDPF_CAP_RSC))
                other_offloads |= NETIF_F_GRO_HW;
        if (idpf_is_cap_ena(adapter, IDPF_OTHER_CAPS, VIRTCHNL2_CAP_LOOPBACK))
                other_offloads |= NETIF_F_LOOPBACK;

        netdev->features |= dflt_features | csum_offloads | tso_offloads;
        netdev->hw_features |=  netdev->features | other_offloads;
        netdev->vlan_features |= netdev->features | other_offloads;
        netdev->hw_enc_features |= dflt_features | other_offloads;
        idpf_xdp_set_features(vport);

        idpf_set_ethtool_ops(netdev);
        netif_set_affinity_auto(netdev);
        SET_NETDEV_DEV(netdev, &adapter->pdev->dev);

        /* carrier off on init to avoid Tx hangs */
        netif_carrier_off(netdev);

        /* make sure transmit queues start off as stopped */
        netif_tx_stop_all_queues(netdev);

        /* The vport can be arbitrarily released so we need to also track
         * netdevs in the adapter struct
         */
        adapter->netdevs[idx] = netdev;

        return 0;
}

/**
 * idpf_get_free_slot - get the next non-NULL location index in array
 * @adapter: adapter in which to look for a free vport slot
 */
static int idpf_get_free_slot(struct idpf_adapter *adapter)
{
        unsigned int i;

        for (i = 0; i < adapter->max_vports; i++) {
                if (!adapter->vports[i])
                        return i;
        }

        return IDPF_NO_FREE_SLOT;
}

/**
 * idpf_remove_features - Turn off feature configs
 * @vport: virtual port structure
 */
static void idpf_remove_features(struct idpf_vport *vport)
{
        struct idpf_adapter *adapter = vport->adapter;

        if (idpf_is_cap_ena(adapter, IDPF_OTHER_CAPS, VIRTCHNL2_CAP_MACFILTER))
                idpf_remove_mac_filters(vport);
}

/**
 * idpf_vport_stop - Disable a vport
 * @vport: vport to disable
 * @rtnl: whether to take RTNL lock
 */
static void idpf_vport_stop(struct idpf_vport *vport, bool rtnl)
{
        struct idpf_netdev_priv *np = netdev_priv(vport->netdev);
        struct idpf_q_vec_rsrc *rsrc = &vport->dflt_qv_rsrc;
        struct idpf_adapter *adapter = vport->adapter;
        struct idpf_queue_id_reg_info *chunks;
        u32 vport_id = vport->vport_id;

        if (!test_bit(IDPF_VPORT_UP, np->state))
                return;

        if (rtnl)
                rtnl_lock();

        netif_carrier_off(vport->netdev);
        netif_tx_disable(vport->netdev);

        chunks = &adapter->vport_config[vport->idx]->qid_reg_info;

        idpf_send_disable_vport_msg(adapter, vport_id);
        idpf_send_disable_queues_msg(vport);
        idpf_send_map_unmap_queue_vector_msg(adapter, rsrc, vport_id, false);
        /* Normally we ask for queues in create_vport, but if the number of
         * initially requested queues have changed, for example via ethtool
         * set channels, we do delete queues and then add the queues back
         * instead of deleting and reallocating the vport.
         */
        if (test_and_clear_bit(IDPF_VPORT_DEL_QUEUES, vport->flags))
                idpf_send_delete_queues_msg(adapter, chunks, vport_id);

        idpf_remove_features(vport);

        vport->link_up = false;
        idpf_vport_intr_deinit(vport, rsrc);
        idpf_xdp_rxq_info_deinit_all(rsrc);
        idpf_vport_queues_rel(vport, rsrc);
        idpf_vport_intr_rel(rsrc);
        clear_bit(IDPF_VPORT_UP, np->state);

        if (rtnl)
                rtnl_unlock();
}

/**
 * idpf_stop - Disables a network interface
 * @netdev: network interface device structure
 *
 * The stop entry point is called when an interface is de-activated by the OS,
 * and the netdevice enters the DOWN state.  The hardware is still under the
 * driver's control, but the netdev interface is disabled.
 *
 * Returns success only - not allowed to fail
 */
static int idpf_stop(struct net_device *netdev)
{
        struct idpf_netdev_priv *np = netdev_priv(netdev);
        struct idpf_vport *vport;

        if (test_bit(IDPF_REMOVE_IN_PROG, np->adapter->flags))
                return 0;

        idpf_vport_ctrl_lock(netdev);
        vport = idpf_netdev_to_vport(netdev);

        idpf_vport_stop(vport, false);

        idpf_vport_ctrl_unlock(netdev);

        return 0;
}

/**
 * idpf_decfg_netdev - Unregister the netdev
 * @vport: vport for which netdev to be unregistered
 */
static void idpf_decfg_netdev(struct idpf_vport *vport)
{
        struct idpf_adapter *adapter = vport->adapter;
        u16 idx = vport->idx;

        if (test_and_clear_bit(IDPF_VPORT_REG_NETDEV,
                               adapter->vport_config[idx]->flags)) {
                unregister_netdev(vport->netdev);
                free_netdev(vport->netdev);
        }
        vport->netdev = NULL;

        adapter->netdevs[idx] = NULL;
}

/**
 * idpf_vport_rel - Delete a vport and free its resources
 * @vport: the vport being removed
 */
static void idpf_vport_rel(struct idpf_vport *vport)
{
        struct idpf_q_vec_rsrc *rsrc = &vport->dflt_qv_rsrc;
        struct idpf_adapter *adapter = vport->adapter;
        struct idpf_vport_config *vport_config;
        struct idpf_vector_info vec_info;
        struct idpf_rss_data *rss_data;
        struct idpf_vport_max_q max_q;
        u16 idx = vport->idx;

        vport_config = adapter->vport_config[vport->idx];
        rss_data = &vport_config->user_config.rss_data;
        idpf_deinit_rss_lut(rss_data);
        kfree(rss_data->rss_key);
        rss_data->rss_key = NULL;

        idpf_send_destroy_vport_msg(adapter, vport->vport_id);

        /* Release all max queues allocated to the adapter's pool */
        max_q.max_rxq = vport_config->max_q.max_rxq;
        max_q.max_txq = vport_config->max_q.max_txq;
        max_q.max_bufq = vport_config->max_q.max_bufq;
        max_q.max_complq = vport_config->max_q.max_complq;
        idpf_vport_dealloc_max_qs(adapter, &max_q);

        /* Release all the allocated vectors on the stack */
        vec_info.num_req_vecs = 0;
        vec_info.num_curr_vecs = rsrc->num_q_vectors;
        vec_info.default_vport = vport->default_vport;

        idpf_req_rel_vector_indexes(adapter, rsrc->q_vector_idxs, &vec_info);

        kfree(rsrc->q_vector_idxs);
        rsrc->q_vector_idxs = NULL;

        idpf_vport_deinit_queue_reg_chunks(vport_config);

        kfree(adapter->vport_params_recvd[idx]);
        adapter->vport_params_recvd[idx] = NULL;
        kfree(adapter->vport_params_reqd[idx]);
        adapter->vport_params_reqd[idx] = NULL;

        kfree(vport);
        adapter->num_alloc_vports--;
}

/**
 * idpf_vport_dealloc - cleanup and release a given vport
 * @vport: pointer to idpf vport structure
 *
 * returns nothing
 */
static void idpf_vport_dealloc(struct idpf_vport *vport)
{
        struct idpf_adapter *adapter = vport->adapter;
        unsigned int i = vport->idx;

        idpf_idc_deinit_vport_aux_device(vport->vdev_info);

        idpf_deinit_mac_addr(vport);

        if (!test_bit(IDPF_HR_RESET_IN_PROG, adapter->flags)) {
                idpf_vport_stop(vport, true);
                idpf_decfg_netdev(vport);
        }
        if (test_bit(IDPF_REMOVE_IN_PROG, adapter->flags)) {
                idpf_del_all_mac_filters(vport);
                idpf_del_all_flow_steer_filters(vport);
        }

        if (adapter->netdevs[i]) {
                struct idpf_netdev_priv *np = netdev_priv(adapter->netdevs[i]);

                np->vport = NULL;
        }

        idpf_vport_rel(vport);

        adapter->vports[i] = NULL;
        adapter->next_vport = idpf_get_free_slot(adapter);
}

/**
 * idpf_is_hsplit_supported - check whether the header split is supported
 * @vport: virtual port to check the capability for
 *
 * Return: true if it's supported by the HW/FW, false if not.
 */
static bool idpf_is_hsplit_supported(const struct idpf_vport *vport)
{
        return idpf_is_queue_model_split(vport->dflt_qv_rsrc.rxq_model) &&
               idpf_is_cap_ena_all(vport->adapter, IDPF_HSPLIT_CAPS,
                                   IDPF_CAP_HSPLIT);
}

/**
 * idpf_vport_get_hsplit - get the current header split feature state
 * @vport: virtual port to query the state for
 *
 * Return: ``ETHTOOL_TCP_DATA_SPLIT_UNKNOWN`` if not supported,
 *         ``ETHTOOL_TCP_DATA_SPLIT_DISABLED`` if disabled,
 *         ``ETHTOOL_TCP_DATA_SPLIT_ENABLED`` if active.
 */
u8 idpf_vport_get_hsplit(const struct idpf_vport *vport)
{
        const struct idpf_vport_user_config_data *config;

        if (!idpf_is_hsplit_supported(vport))
                return ETHTOOL_TCP_DATA_SPLIT_UNKNOWN;

        config = &vport->adapter->vport_config[vport->idx]->user_config;

        return test_bit(__IDPF_USER_FLAG_HSPLIT, config->user_flags) ?
               ETHTOOL_TCP_DATA_SPLIT_ENABLED :
               ETHTOOL_TCP_DATA_SPLIT_DISABLED;
}

/**
 * idpf_vport_set_hsplit - enable or disable header split on a given vport
 * @vport: virtual port to configure
 * @val: Ethtool flag controlling the header split state
 *
 * Return: true on success, false if not supported by the HW.
 */
bool idpf_vport_set_hsplit(const struct idpf_vport *vport, u8 val)
{
        struct idpf_vport_user_config_data *config;

        if (!idpf_is_hsplit_supported(vport))
                return val == ETHTOOL_TCP_DATA_SPLIT_UNKNOWN;

        config = &vport->adapter->vport_config[vport->idx]->user_config;

        switch (val) {
        case ETHTOOL_TCP_DATA_SPLIT_UNKNOWN:
                /* Default is to enable */
        case ETHTOOL_TCP_DATA_SPLIT_ENABLED:
                __set_bit(__IDPF_USER_FLAG_HSPLIT, config->user_flags);
                return true;
        case ETHTOOL_TCP_DATA_SPLIT_DISABLED:
                __clear_bit(__IDPF_USER_FLAG_HSPLIT, config->user_flags);
                return true;
        default:
                return false;
        }
}

/**
 * idpf_vport_alloc - Allocates the next available struct vport in the adapter
 * @adapter: board private structure
 * @max_q: vport max queue info
 *
 * returns a pointer to a vport on success, NULL on failure.
 */
static struct idpf_vport *idpf_vport_alloc(struct idpf_adapter *adapter,
                                           struct idpf_vport_max_q *max_q)
{
        struct idpf_rss_data *rss_data;
        u16 idx = adapter->next_vport;
        struct idpf_q_vec_rsrc *rsrc;
        struct idpf_vport *vport;
        u16 num_max_q;
        int err;

        if (idx == IDPF_NO_FREE_SLOT)
                return NULL;

        vport = kzalloc_obj(*vport);
        if (!vport)
                return vport;

        num_max_q = max(max_q->max_txq, max_q->max_rxq) + IDPF_RESERVED_VECS;
        if (!adapter->vport_config[idx]) {
                struct idpf_vport_config *vport_config;
                struct idpf_q_coalesce *q_coal;

                vport_config = kzalloc_obj(*vport_config);
                if (!vport_config) {
                        kfree(vport);

                        return NULL;
                }

                q_coal = kzalloc_objs(*q_coal, num_max_q);
                if (!q_coal) {
                        kfree(vport_config);
                        kfree(vport);

                        return NULL;
                }
                for (int i = 0; i < num_max_q; i++) {
                        q_coal[i].tx_intr_mode = IDPF_ITR_DYNAMIC;
                        q_coal[i].tx_coalesce_usecs = IDPF_ITR_TX_DEF;
                        q_coal[i].rx_intr_mode = IDPF_ITR_DYNAMIC;
                        q_coal[i].rx_coalesce_usecs = IDPF_ITR_RX_DEF;
                }
                vport_config->user_config.q_coalesce = q_coal;

                adapter->vport_config[idx] = vport_config;
        }

        vport->idx = idx;
        vport->adapter = adapter;
        vport->compln_clean_budget = IDPF_TX_COMPLQ_CLEAN_BUDGET;
        vport->default_vport = adapter->num_alloc_vports <
                               idpf_get_default_vports(adapter);

        rsrc = &vport->dflt_qv_rsrc;
        rsrc->dev = &adapter->pdev->dev;
        rsrc->q_vector_idxs = kcalloc(num_max_q, sizeof(u16), GFP_KERNEL);
        if (!rsrc->q_vector_idxs)
                goto free_vport;

        err = idpf_vport_init(vport, max_q);
        if (err)
                goto free_vector_idxs;

        /* LUT and key are both initialized here. Key is not strictly dependent
         * on how many queues we have. If we change number of queues and soft
         * reset is initiated, LUT will be freed and a new LUT will be allocated
         * as per the updated number of queues during vport bringup. However,
         * the key remains the same for as long as the vport exists.
         */
        rss_data = &adapter->vport_config[idx]->user_config.rss_data;
        rss_data->rss_key = kzalloc(rss_data->rss_key_size, GFP_KERNEL);
        if (!rss_data->rss_key)
                goto free_qreg_chunks;

        /* Initialize default RSS key */
        netdev_rss_key_fill((void *)rss_data->rss_key, rss_data->rss_key_size);

        /* Initialize default RSS LUT */
        err = idpf_init_rss_lut(vport, rss_data);
        if (err)
                goto free_rss_key;

        /* fill vport slot in the adapter struct */
        adapter->vports[idx] = vport;
        adapter->vport_ids[idx] = idpf_get_vport_id(vport);

        adapter->num_alloc_vports++;
        /* prepare adapter->next_vport for next use */
        adapter->next_vport = idpf_get_free_slot(adapter);

        return vport;

free_rss_key:
        kfree(rss_data->rss_key);
        rss_data->rss_key = NULL;
free_qreg_chunks:
        idpf_vport_deinit_queue_reg_chunks(adapter->vport_config[idx]);
free_vector_idxs:
        kfree(rsrc->q_vector_idxs);
free_vport:
        kfree(vport);

        return NULL;
}

/**
 * idpf_get_stats64 - get statistics for network device structure
 * @netdev: network interface device structure
 * @stats: main device statistics structure
 */
static void idpf_get_stats64(struct net_device *netdev,
                             struct rtnl_link_stats64 *stats)
{
        struct idpf_netdev_priv *np = netdev_priv(netdev);

        spin_lock_bh(&np->stats_lock);
        *stats = np->netstats;
        spin_unlock_bh(&np->stats_lock);
}

/**
 * idpf_statistics_task - Delayed task to get statistics over mailbox
 * @work: work_struct handle to our data
 */
void idpf_statistics_task(struct work_struct *work)
{
        struct idpf_adapter *adapter;
        int i;

        adapter = container_of(work, struct idpf_adapter, stats_task.work);

        for (i = 0; i < adapter->max_vports; i++) {
                struct idpf_vport *vport = adapter->vports[i];

                if (vport && !test_bit(IDPF_HR_RESET_IN_PROG, adapter->flags))
                        idpf_send_get_stats_msg(netdev_priv(vport->netdev),
                                                &vport->port_stats);
        }

        queue_delayed_work(adapter->stats_wq, &adapter->stats_task,
                           msecs_to_jiffies(10000));
}

/**
 * idpf_mbx_task - Delayed task to handle mailbox responses
 * @work: work_struct handle
 */
void idpf_mbx_task(struct work_struct *work)
{
        struct idpf_adapter *adapter;

        adapter = container_of(work, struct idpf_adapter, mbx_task.work);

        if (test_bit(IDPF_MB_INTR_MODE, adapter->flags))
                idpf_mb_irq_enable(adapter);
        else
                queue_delayed_work(adapter->mbx_wq, &adapter->mbx_task,
                                   usecs_to_jiffies(300));

        idpf_recv_mb_msg(adapter, adapter->hw.arq);
}

/**
 * idpf_service_task - Delayed task for handling mailbox responses
 * @work: work_struct handle to our data
 *
 */
void idpf_service_task(struct work_struct *work)
{
        struct idpf_adapter *adapter;

        adapter = container_of(work, struct idpf_adapter, serv_task.work);

        if (idpf_is_reset_detected(adapter) &&
            !idpf_is_reset_in_prog(adapter) &&
            !test_bit(IDPF_REMOVE_IN_PROG, adapter->flags)) {
                dev_info(&adapter->pdev->dev, "HW reset detected\n");
                set_bit(IDPF_HR_FUNC_RESET, adapter->flags);
                queue_delayed_work(adapter->vc_event_wq,
                                   &adapter->vc_event_task,
                                   msecs_to_jiffies(10));
        }

        queue_delayed_work(adapter->serv_wq, &adapter->serv_task,
                           msecs_to_jiffies(300));
}

/**
 * idpf_restore_features - Restore feature configs
 * @vport: virtual port structure
 */
static void idpf_restore_features(struct idpf_vport *vport)
{
        struct idpf_adapter *adapter = vport->adapter;

        if (idpf_is_cap_ena(adapter, IDPF_OTHER_CAPS, VIRTCHNL2_CAP_MACFILTER))
                idpf_restore_mac_filters(vport);
}

/**
 * idpf_set_real_num_queues - set number of queues for netdev
 * @vport: virtual port structure
 *
 * Returns 0 on success, negative on failure.
 */
static int idpf_set_real_num_queues(struct idpf_vport *vport)
{
        int err, txq = vport->dflt_qv_rsrc.num_txq - vport->num_xdp_txq;

        err = netif_set_real_num_rx_queues(vport->netdev,
                                           vport->dflt_qv_rsrc.num_rxq);
        if (err)
                return err;

        return netif_set_real_num_tx_queues(vport->netdev, txq);
}

/**
 * idpf_up_complete - Complete interface up sequence
 * @vport: virtual port structure
 */
static void idpf_up_complete(struct idpf_vport *vport)
{
        struct idpf_netdev_priv *np = netdev_priv(vport->netdev);

        if (vport->link_up && !netif_carrier_ok(vport->netdev)) {
                netif_carrier_on(vport->netdev);
                netif_tx_start_all_queues(vport->netdev);
        }

        set_bit(IDPF_VPORT_UP, np->state);
}

/**
 * idpf_rx_init_buf_tail - Write initial buffer ring tail value
 * @rsrc: pointer to queue and vector resources
 */
static void idpf_rx_init_buf_tail(struct idpf_q_vec_rsrc *rsrc)
{
        for (unsigned int i = 0; i < rsrc->num_rxq_grp; i++) {
                struct idpf_rxq_group *grp = &rsrc->rxq_grps[i];

                if (idpf_is_queue_model_split(rsrc->rxq_model)) {
                        for (unsigned int j = 0; j < rsrc->num_bufqs_per_qgrp; j++) {
                                const struct idpf_buf_queue *q =
                                        &grp->splitq.bufq_sets[j].bufq;

                                writel(q->next_to_alloc, q->tail);
                        }
                } else {
                        for (unsigned int j = 0; j < grp->singleq.num_rxq; j++) {
                                const struct idpf_rx_queue *q =
                                        grp->singleq.rxqs[j];

                                writel(q->next_to_alloc, q->tail);
                        }
                }
        }
}

/**
 * idpf_vport_open - Bring up a vport
 * @vport: vport to bring up
 * @rtnl: whether to take RTNL lock
 */
static int idpf_vport_open(struct idpf_vport *vport, bool rtnl)
{
        struct idpf_netdev_priv *np = netdev_priv(vport->netdev);
        struct idpf_q_vec_rsrc *rsrc = &vport->dflt_qv_rsrc;
        struct idpf_adapter *adapter = vport->adapter;
        struct idpf_vport_config *vport_config;
        struct idpf_queue_id_reg_info *chunks;
        struct idpf_rss_data *rss_data;
        u32 vport_id = vport->vport_id;
        int err;

        if (test_bit(IDPF_VPORT_UP, np->state))
                return -EBUSY;

        if (rtnl)
                rtnl_lock();

        /* we do not allow interface up just yet */
        netif_carrier_off(vport->netdev);

        err = idpf_vport_intr_alloc(vport, rsrc);
        if (err) {
                dev_err(&adapter->pdev->dev, "Failed to allocate interrupts for vport %u: %d\n",
                        vport->vport_id, err);
                goto err_rtnl_unlock;
        }

        err = idpf_vport_queues_alloc(vport, rsrc);
        if (err)
                goto intr_rel;

        vport_config = adapter->vport_config[vport->idx];
        chunks = &vport_config->qid_reg_info;

        err = idpf_vport_queue_ids_init(vport, rsrc, chunks);
        if (err) {
                dev_err(&adapter->pdev->dev, "Failed to initialize queue ids for vport %u: %d\n",
                        vport->vport_id, err);
                goto queues_rel;
        }

        err = idpf_vport_intr_init(vport, rsrc);
        if (err) {
                dev_err(&adapter->pdev->dev, "Failed to initialize interrupts for vport %u: %d\n",
                        vport->vport_id, err);
                goto queues_rel;
        }

        err = idpf_queue_reg_init(vport, rsrc, chunks);
        if (err) {
                dev_err(&adapter->pdev->dev, "Failed to initialize queue registers for vport %u: %d\n",
                        vport->vport_id, err);
                goto intr_deinit;
        }

        err = idpf_rx_bufs_init_all(vport, rsrc);
        if (err) {
                dev_err(&adapter->pdev->dev, "Failed to initialize RX buffers for vport %u: %d\n",
                        vport->vport_id, err);
                goto intr_deinit;
        }

        idpf_rx_init_buf_tail(rsrc);

        err = idpf_xdp_rxq_info_init_all(rsrc);
        if (err) {
                netdev_err(vport->netdev,
                           "Failed to initialize XDP RxQ info for vport %u: %pe\n",
                           vport->vport_id, ERR_PTR(err));
                goto intr_deinit;
        }

        idpf_vport_intr_ena(vport, rsrc);

        err = idpf_send_config_queues_msg(adapter, rsrc, vport_id);
        if (err) {
                dev_err(&adapter->pdev->dev, "Failed to configure queues for vport %u, %d\n",
                        vport->vport_id, err);
                goto rxq_deinit;
        }

        err = idpf_send_map_unmap_queue_vector_msg(adapter, rsrc, vport_id,
                                                   true);
        if (err) {
                dev_err(&adapter->pdev->dev, "Failed to map queue vectors for vport %u: %d\n",
                        vport->vport_id, err);
                goto rxq_deinit;
        }

        err = idpf_send_enable_queues_msg(vport);
        if (err) {
                dev_err(&adapter->pdev->dev, "Failed to enable queues for vport %u: %d\n",
                        vport->vport_id, err);
                goto unmap_queue_vectors;
        }

        err = idpf_send_enable_vport_msg(adapter, vport_id);
        if (err) {
                dev_err(&adapter->pdev->dev, "Failed to enable vport %u: %d\n",
                        vport->vport_id, err);
                err = -EAGAIN;
                goto disable_queues;
        }

        idpf_restore_features(vport);

        rss_data = &vport_config->user_config.rss_data;
        err = idpf_config_rss(vport, rss_data);
        if (err) {
                dev_err(&adapter->pdev->dev, "Failed to configure RSS for vport %u: %d\n",
                        vport->vport_id, err);
                goto disable_vport;
        }

        idpf_up_complete(vport);

        if (rtnl)
                rtnl_unlock();

        return 0;

disable_vport:
        idpf_send_disable_vport_msg(adapter, vport_id);
disable_queues:
        idpf_send_disable_queues_msg(vport);
unmap_queue_vectors:
        idpf_send_map_unmap_queue_vector_msg(adapter, rsrc, vport_id, false);
rxq_deinit:
        idpf_xdp_rxq_info_deinit_all(rsrc);
intr_deinit:
        idpf_vport_intr_deinit(vport, rsrc);
queues_rel:
        idpf_vport_queues_rel(vport, rsrc);
intr_rel:
        idpf_vport_intr_rel(rsrc);

err_rtnl_unlock:
        if (rtnl)
                rtnl_unlock();

        return err;
}

/**
 * idpf_init_task - Delayed initialization task
 * @work: work_struct handle to our data
 *
 * Init task finishes up pending work started in probe. Due to the asynchronous
 * nature in which the device communicates with hardware, we may have to wait
 * several milliseconds to get a response.  Instead of busy polling in probe,
 * pulling it out into a delayed work task prevents us from bogging down the
 * whole system waiting for a response from hardware.
 */
void idpf_init_task(struct work_struct *work)
{
        struct idpf_vport_config *vport_config;
        struct idpf_vport_max_q max_q;
        struct idpf_adapter *adapter;
        struct idpf_vport *vport;
        u16 num_default_vports;
        struct pci_dev *pdev;
        bool default_vport;
        int index, err;

        adapter = container_of(work, struct idpf_adapter, init_task.work);

        num_default_vports = idpf_get_default_vports(adapter);
        if (adapter->num_alloc_vports < num_default_vports)
                default_vport = true;
        else
                default_vport = false;

        err = idpf_vport_alloc_max_qs(adapter, &max_q);
        if (err)
                goto unwind_vports;

        err = idpf_send_create_vport_msg(adapter, &max_q);
        if (err) {
                idpf_vport_dealloc_max_qs(adapter, &max_q);
                goto unwind_vports;
        }

        pdev = adapter->pdev;
        vport = idpf_vport_alloc(adapter, &max_q);
        if (!vport) {
                err = -EFAULT;
                dev_err(&pdev->dev, "failed to allocate vport: %d\n",
                        err);
                idpf_vport_dealloc_max_qs(adapter, &max_q);
                goto unwind_vports;
        }

        index = vport->idx;
        vport_config = adapter->vport_config[index];

        spin_lock_init(&vport_config->mac_filter_list_lock);
        spin_lock_init(&vport_config->flow_steer_list_lock);

        INIT_LIST_HEAD(&vport_config->user_config.mac_filter_list);
        INIT_LIST_HEAD(&vport_config->user_config.flow_steer_list);

        err = idpf_check_supported_desc_ids(vport);
        if (err) {
                dev_err(&pdev->dev, "failed to get required descriptor ids\n");
                goto unwind_vports;
        }

        if (idpf_cfg_netdev(vport))
                goto unwind_vports;

        /* Spawn and return 'idpf_init_task' work queue until all the
         * default vports are created
         */
        if (adapter->num_alloc_vports < num_default_vports) {
                queue_delayed_work(adapter->init_wq, &adapter->init_task,
                                   msecs_to_jiffies(5 * (adapter->pdev->devfn & 0x07)));

                return;
        }

        for (index = 0; index < adapter->max_vports; index++) {
                struct net_device *netdev = adapter->netdevs[index];
                struct idpf_vport_config *vport_config;

                vport_config = adapter->vport_config[index];

                if (!netdev ||
                    test_bit(IDPF_VPORT_REG_NETDEV, vport_config->flags))
                        continue;

                err = register_netdev(netdev);
                if (err) {
                        dev_err(&pdev->dev, "failed to register netdev for vport %d: %pe\n",
                                index, ERR_PTR(err));
                        continue;
                }
                set_bit(IDPF_VPORT_REG_NETDEV, vport_config->flags);
        }

        /* Clear the reset and load bits as all vports are created */
        clear_bit(IDPF_HR_RESET_IN_PROG, adapter->flags);
        clear_bit(IDPF_HR_DRV_LOAD, adapter->flags);
        /* Start the statistics task now */
        queue_delayed_work(adapter->stats_wq, &adapter->stats_task,
                           msecs_to_jiffies(10 * (pdev->devfn & 0x07)));

        return;

unwind_vports:
        if (default_vport) {
                for (index = 0; index < adapter->max_vports; index++) {
                        if (adapter->vports[index])
                                idpf_vport_dealloc(adapter->vports[index]);
                }
        }
        /* Cleanup after vc_core_init, which has no way of knowing the
         * init task failed on driver load.
         */
        if (test_and_clear_bit(IDPF_HR_DRV_LOAD, adapter->flags)) {
                cancel_delayed_work_sync(&adapter->serv_task);
                cancel_delayed_work_sync(&adapter->mbx_task);
        }
        idpf_ptp_release(adapter);

        clear_bit(IDPF_HR_RESET_IN_PROG, adapter->flags);
}

/**
 * idpf_sriov_ena - Enable or change number of VFs
 * @adapter: private data struct
 * @num_vfs: number of VFs to allocate
 */
static int idpf_sriov_ena(struct idpf_adapter *adapter, int num_vfs)
{
        struct device *dev = &adapter->pdev->dev;
        int err;

        err = idpf_send_set_sriov_vfs_msg(adapter, num_vfs);
        if (err) {
                dev_err(dev, "Failed to allocate VFs: %d\n", err);

                return err;
        }

        err = pci_enable_sriov(adapter->pdev, num_vfs);
        if (err) {
                idpf_send_set_sriov_vfs_msg(adapter, 0);
                dev_err(dev, "Failed to enable SR-IOV: %d\n", err);

                return err;
        }

        adapter->num_vfs = num_vfs;

        return num_vfs;
}

/**
 * idpf_sriov_configure - Configure the requested VFs
 * @pdev: pointer to a pci_dev structure
 * @num_vfs: number of vfs to allocate
 *
 * Enable or change the number of VFs. Called when the user updates the number
 * of VFs in sysfs.
 **/
int idpf_sriov_configure(struct pci_dev *pdev, int num_vfs)
{
        struct idpf_adapter *adapter = pci_get_drvdata(pdev);

        if (!idpf_is_cap_ena(adapter, IDPF_OTHER_CAPS, VIRTCHNL2_CAP_SRIOV)) {
                dev_info(&pdev->dev, "SR-IOV is not supported on this device\n");

                return -EOPNOTSUPP;
        }

        if (num_vfs)
                return idpf_sriov_ena(adapter, num_vfs);

        if (pci_vfs_assigned(pdev)) {
                dev_warn(&pdev->dev, "Unable to free VFs because some are assigned to VMs\n");

                return -EBUSY;
        }

        pci_disable_sriov(adapter->pdev);
        idpf_send_set_sriov_vfs_msg(adapter, 0);
        adapter->num_vfs = 0;

        return 0;
}

/**
 * idpf_deinit_task - Device deinit routine
 * @adapter: Driver specific private structure
 *
 * Extended remove logic which will be used for
 * hard reset as well
 */
void idpf_deinit_task(struct idpf_adapter *adapter)
{
        unsigned int i;

        /* Wait until the init_task is done else this thread might release
         * the resources first and the other thread might end up in a bad state
         */
        cancel_delayed_work_sync(&adapter->init_task);

        if (!adapter->vports)
                return;

        cancel_delayed_work_sync(&adapter->stats_task);

        for (i = 0; i < adapter->max_vports; i++) {
                if (adapter->vports[i])
                        idpf_vport_dealloc(adapter->vports[i]);
        }
}

/**
 * idpf_check_reset_complete - check that reset is complete
 * @hw: pointer to hw struct
 * @reset_reg: struct with reset registers
 *
 * Returns 0 if device is ready to use, or -EBUSY if it's in reset.
 **/
static int idpf_check_reset_complete(struct idpf_hw *hw,
                                     struct idpf_reset_reg *reset_reg)
{
        struct idpf_adapter *adapter = hw->back;
        int i;

        for (i = 0; i < 2000; i++) {
                u32 reg_val = readl(reset_reg->rstat);

                /* 0xFFFFFFFF might be read if other side hasn't cleared the
                 * register for us yet and 0xFFFFFFFF is not a valid value for
                 * the register, so treat that as invalid.
                 */
                if (reg_val != 0xFFFFFFFF && (reg_val & reset_reg->rstat_m))
                        return 0;

                usleep_range(5000, 10000);
        }

        dev_warn(&adapter->pdev->dev, "Device reset timeout!\n");
        /* Clear the reset flag unconditionally here since the reset
         * technically isn't in progress anymore from the driver's perspective
         */
        clear_bit(IDPF_HR_RESET_IN_PROG, adapter->flags);

        return -EBUSY;
}

/**
 * idpf_init_hard_reset - Initiate a hardware reset
 * @adapter: Driver specific private structure
 *
 * Deallocate the vports and all the resources associated with them and
 * reallocate. Also reinitialize the mailbox. Return 0 on success,
 * negative on failure.
 */
static void idpf_init_hard_reset(struct idpf_adapter *adapter)
{
        struct idpf_reg_ops *reg_ops = &adapter->dev_ops.reg_ops;
        struct device *dev = &adapter->pdev->dev;
        int err;

        idpf_detach_and_close(adapter);
        mutex_lock(&adapter->vport_ctrl_lock);

        dev_info(dev, "Device HW Reset initiated\n");

        /* Prepare for reset */
        if (test_bit(IDPF_HR_DRV_LOAD, adapter->flags)) {
                reg_ops->trigger_reset(adapter, IDPF_HR_DRV_LOAD);
        } else if (test_and_clear_bit(IDPF_HR_FUNC_RESET, adapter->flags)) {
                bool is_reset = idpf_is_reset_detected(adapter);

                idpf_idc_issue_reset_event(adapter->cdev_info);

                idpf_vc_core_deinit(adapter);
                if (!is_reset)
                        reg_ops->trigger_reset(adapter, IDPF_HR_FUNC_RESET);
                idpf_deinit_dflt_mbx(adapter);
        } else {
                dev_err(dev, "Unhandled hard reset cause\n");
                err = -EBADRQC;
                goto unlock_mutex;
        }

        /* Wait for reset to complete */
        err = idpf_check_reset_complete(&adapter->hw, &adapter->reset_reg);
        if (err) {
                dev_err(dev, "The driver was unable to contact the device's firmware. Check that the FW is running. Driver state= 0x%x\n",
                        adapter->state);
                goto unlock_mutex;
        }

        /* Reset is complete and so start building the driver resources again */
        err = idpf_init_dflt_mbx(adapter);
        if (err) {
                dev_err(dev, "Failed to initialize default mailbox: %d\n", err);
                goto unlock_mutex;
        }

        queue_delayed_work(adapter->mbx_wq, &adapter->mbx_task, 0);

        /* Initialize the state machine, also allocate memory and request
         * resources
         */
        err = idpf_vc_core_init(adapter);
        if (err) {
                cancel_delayed_work_sync(&adapter->mbx_task);
                idpf_deinit_dflt_mbx(adapter);
                goto unlock_mutex;
        }

        /* Wait till all the vports are initialized to release the reset lock,
         * else user space callbacks may access uninitialized vports
         */
        while (test_bit(IDPF_HR_RESET_IN_PROG, adapter->flags))
                msleep(100);

unlock_mutex:
        mutex_unlock(&adapter->vport_ctrl_lock);

        /* Attempt to restore netdevs and initialize RDMA CORE AUX device,
         * provided vc_core_init succeeded. It is still possible that
         * vports are not allocated at this point if the init task failed.
         */
        if (!err) {
                idpf_attach_and_open(adapter);
                idpf_idc_init(adapter);
        }
}

/**
 * idpf_vc_event_task - Handle virtchannel event logic
 * @work: work queue struct
 */
void idpf_vc_event_task(struct work_struct *work)
{
        struct idpf_adapter *adapter;

        adapter = container_of(work, struct idpf_adapter, vc_event_task.work);

        if (test_bit(IDPF_REMOVE_IN_PROG, adapter->flags))
                return;

        if (test_bit(IDPF_HR_FUNC_RESET, adapter->flags))
                goto func_reset;

        if (test_bit(IDPF_HR_DRV_LOAD, adapter->flags))
                goto drv_load;

        return;

func_reset:
        idpf_vc_xn_shutdown(adapter->vcxn_mngr);
drv_load:
        set_bit(IDPF_HR_RESET_IN_PROG, adapter->flags);
        idpf_init_hard_reset(adapter);
}

/**
 * idpf_initiate_soft_reset - Initiate a software reset
 * @vport: virtual port data struct
 * @reset_cause: reason for the soft reset
 *
 * Soft reset only reallocs vport queue resources. Returns 0 on success,
 * negative on failure.
 */
int idpf_initiate_soft_reset(struct idpf_vport *vport,
                             enum idpf_vport_reset_cause reset_cause)
{
        struct idpf_netdev_priv *np = netdev_priv(vport->netdev);
        bool vport_is_up = test_bit(IDPF_VPORT_UP, np->state);
        struct idpf_q_vec_rsrc *rsrc = &vport->dflt_qv_rsrc;
        struct idpf_adapter *adapter = vport->adapter;
        struct idpf_vport_config *vport_config;
        struct idpf_q_vec_rsrc *new_rsrc;
        u32 vport_id = vport->vport_id;
        struct idpf_vport *new_vport;
        int err, tmp_err = 0;

        /* If the system is low on memory, we can end up in bad state if we
         * free all the memory for queue resources and try to allocate them
         * again. Instead, we can pre-allocate the new resources before doing
         * anything and bailing if the alloc fails.
         *
         * Make a clone of the existing vport to mimic its current
         * configuration, then modify the new structure with any requested
         * changes. Once the allocation of the new resources is done, stop the
         * existing vport and copy the configuration to the main vport. If an
         * error occurred, the existing vport will be untouched.
         *
         */
        new_vport = kzalloc_obj(*vport);
        if (!new_vport)
                return -ENOMEM;

        /* This purposely avoids copying the end of the struct because it
         * contains wait_queues and mutexes and other stuff we don't want to
         * mess with. Nothing below should use those variables from new_vport
         * and should instead always refer to them in vport if they need to.
         */
        memcpy(new_vport, vport, offsetof(struct idpf_vport, link_up));

        new_rsrc = &new_vport->dflt_qv_rsrc;

        /* Adjust resource parameters prior to reallocating resources */
        switch (reset_cause) {
        case IDPF_SR_Q_CHANGE:
                err = idpf_vport_adjust_qs(new_vport, new_rsrc);
                if (err)
                        goto free_vport;
                break;
        case IDPF_SR_Q_DESC_CHANGE:
                /* Update queue parameters before allocating resources */
                idpf_vport_calc_num_q_desc(new_vport, new_rsrc);
                break;
        case IDPF_SR_MTU_CHANGE:
                idpf_idc_vdev_mtu_event(vport->vdev_info,
                                        IIDC_RDMA_EVENT_BEFORE_MTU_CHANGE);
                break;
        case IDPF_SR_RSC_CHANGE:
                break;
        default:
                dev_err(&adapter->pdev->dev, "Unhandled soft reset cause\n");
                err = -EINVAL;
                goto free_vport;
        }

        vport_config = adapter->vport_config[vport->idx];

        if (!vport_is_up) {
                idpf_send_delete_queues_msg(adapter, &vport_config->qid_reg_info,
                                            vport_id);
        } else {
                set_bit(IDPF_VPORT_DEL_QUEUES, vport->flags);
                idpf_vport_stop(vport, false);
        }

        err = idpf_send_add_queues_msg(adapter, vport_config, new_rsrc,
                                       vport_id);
        if (err)
                goto err_reset;

        /* Avoid copying the wait_queues and mutexes. We do not want to mess
         * with those if possible.
         */
        memcpy(vport, new_vport, offsetof(struct idpf_vport, link_up));

        if (reset_cause == IDPF_SR_Q_CHANGE)
                idpf_vport_alloc_vec_indexes(vport, &vport->dflt_qv_rsrc);

        err = idpf_set_real_num_queues(vport);
        if (err)
                goto err_open;

        if (reset_cause == IDPF_SR_Q_CHANGE &&
            !netif_is_rxfh_configured(vport->netdev)) {
                struct idpf_rss_data *rss_data;

                rss_data = &vport_config->user_config.rss_data;
                idpf_fill_dflt_rss_lut(vport, rss_data);
        }

        if (vport_is_up)
                err = idpf_vport_open(vport, false);

        goto free_vport;

err_reset:
        tmp_err = idpf_send_add_queues_msg(adapter, vport_config, rsrc,
                                           vport_id);

err_open:
        if (!tmp_err && vport_is_up)
                idpf_vport_open(vport, false);

free_vport:
        kfree(new_vport);

        if (reset_cause == IDPF_SR_MTU_CHANGE)
                idpf_idc_vdev_mtu_event(vport->vdev_info,
                                        IIDC_RDMA_EVENT_AFTER_MTU_CHANGE);

        return err;
}

/**
 * idpf_addr_sync - Callback for dev_(mc|uc)_sync to add address
 * @netdev: the netdevice
 * @addr: address to add
 *
 * Called by __dev_(mc|uc)_sync when an address needs to be added. We call
 * __dev_(uc|mc)_sync from .set_rx_mode. Kernel takes addr_list_lock spinlock
 * meaning we cannot sleep in this context. Due to this, we have to add the
 * filter and send the virtchnl message asynchronously without waiting for the
 * response from the other side. We won't know whether or not the operation
 * actually succeeded until we get the message back.  Returns 0 on success,
 * negative on failure.
 */
static int idpf_addr_sync(struct net_device *netdev, const u8 *addr)
{
        struct idpf_netdev_priv *np = netdev_priv(netdev);

        return idpf_add_mac_filter(np->vport, np, addr, true);
}

/**
 * idpf_addr_unsync - Callback for dev_(mc|uc)_sync to remove address
 * @netdev: the netdevice
 * @addr: address to add
 *
 * Called by __dev_(mc|uc)_sync when an address needs to be added. We call
 * __dev_(uc|mc)_sync from .set_rx_mode. Kernel takes addr_list_lock spinlock
 * meaning we cannot sleep in this context. Due to this we have to delete the
 * filter and send the virtchnl message asynchronously without waiting for the
 * return from the other side.  We won't know whether or not the operation
 * actually succeeded until we get the message back. Returns 0 on success,
 * negative on failure.
 */
static int idpf_addr_unsync(struct net_device *netdev, const u8 *addr)
{
        struct idpf_netdev_priv *np = netdev_priv(netdev);

        /* Under some circumstances, we might receive a request to delete
         * our own device address from our uc list. Because we store the
         * device address in the VSI's MAC filter list, we need to ignore
         * such requests and not delete our device address from this list.
         */
        if (ether_addr_equal(addr, netdev->dev_addr))
                return 0;

        idpf_del_mac_filter(np->vport, np, addr, true);

        return 0;
}

/**
 * idpf_set_rx_mode - NDO callback to set the netdev filters
 * @netdev: network interface device structure
 *
 * Stack takes addr_list_lock spinlock before calling our .set_rx_mode.  We
 * cannot sleep in this context.
 */
static void idpf_set_rx_mode(struct net_device *netdev)
{
        struct idpf_netdev_priv *np = netdev_priv(netdev);
        struct idpf_vport_user_config_data *config_data;
        struct idpf_adapter *adapter;
        bool changed = false;
        struct device *dev;
        int err;

        adapter = np->adapter;
        dev = &adapter->pdev->dev;

        if (idpf_is_cap_ena(adapter, IDPF_OTHER_CAPS, VIRTCHNL2_CAP_MACFILTER)) {
                __dev_uc_sync(netdev, idpf_addr_sync, idpf_addr_unsync);
                __dev_mc_sync(netdev, idpf_addr_sync, idpf_addr_unsync);
        }

        if (!idpf_is_cap_ena(adapter, IDPF_OTHER_CAPS, VIRTCHNL2_CAP_PROMISC))
                return;

        config_data = &adapter->vport_config[np->vport_idx]->user_config;
        /* IFF_PROMISC enables both unicast and multicast promiscuous,
         * while IFF_ALLMULTI only enables multicast such that:
         *
         * promisc  + allmulti          = unicast | multicast
         * promisc  + !allmulti         = unicast | multicast
         * !promisc + allmulti          = multicast
         */
        if ((netdev->flags & IFF_PROMISC) &&
            !test_and_set_bit(__IDPF_PROMISC_UC, config_data->user_flags)) {
                changed = true;
                dev_info(&adapter->pdev->dev, "Entering promiscuous mode\n");
                if (!test_and_set_bit(__IDPF_PROMISC_MC, adapter->flags))
                        dev_info(dev, "Entering multicast promiscuous mode\n");
        }

        if (!(netdev->flags & IFF_PROMISC) &&
            test_and_clear_bit(__IDPF_PROMISC_UC, config_data->user_flags)) {
                changed = true;
                dev_info(dev, "Leaving promiscuous mode\n");
        }

        if (netdev->flags & IFF_ALLMULTI &&
            !test_and_set_bit(__IDPF_PROMISC_MC, config_data->user_flags)) {
                changed = true;
                dev_info(dev, "Entering multicast promiscuous mode\n");
        }

        if (!(netdev->flags & (IFF_ALLMULTI | IFF_PROMISC)) &&
            test_and_clear_bit(__IDPF_PROMISC_MC, config_data->user_flags)) {
                changed = true;
                dev_info(dev, "Leaving multicast promiscuous mode\n");
        }

        if (!changed)
                return;

        err = idpf_set_promiscuous(adapter, config_data, np->vport_id);
        if (err)
                dev_err(dev, "Failed to set promiscuous mode: %d\n", err);
}

/**
 * idpf_set_features - set the netdev feature flags
 * @netdev: ptr to the netdev being adjusted
 * @features: the feature set that the stack is suggesting
 */
static int idpf_set_features(struct net_device *netdev,
                             netdev_features_t features)
{
        netdev_features_t changed = netdev->features ^ features;
        struct idpf_adapter *adapter;
        struct idpf_vport *vport;
        int err = 0;

        idpf_vport_ctrl_lock(netdev);
        vport = idpf_netdev_to_vport(netdev);

        adapter = vport->adapter;

        if (idpf_is_reset_in_prog(adapter)) {
                dev_err(&adapter->pdev->dev, "Device is resetting, changing netdev features temporarily unavailable.\n");
                err = -EBUSY;
                goto unlock_mutex;
        }

        if (changed & NETIF_F_RXHASH) {
                struct idpf_netdev_priv *np = netdev_priv(netdev);

                netdev->features ^= NETIF_F_RXHASH;

                /* If the interface is not up when changing the rxhash, update
                 * to the HW is skipped. The updated LUT will be committed to
                 * the HW when the interface is brought up.
                 */
                if (test_bit(IDPF_VPORT_UP, np->state)) {
                        struct idpf_vport_config *vport_config;
                        struct idpf_rss_data *rss_data;

                        vport_config = adapter->vport_config[vport->idx];
                        rss_data = &vport_config->user_config.rss_data;
                        err = idpf_config_rss(vport, rss_data);
                        if (err)
                                goto unlock_mutex;
                }
        }

        if (changed & NETIF_F_GRO_HW) {
                netdev->features ^= NETIF_F_GRO_HW;
                err = idpf_initiate_soft_reset(vport, IDPF_SR_RSC_CHANGE);
                if (err)
                        goto unlock_mutex;
        }

        if (changed & NETIF_F_LOOPBACK) {
                bool loopback_ena;

                netdev->features ^= NETIF_F_LOOPBACK;
                loopback_ena = idpf_is_feature_ena(vport, NETIF_F_LOOPBACK);

                err = idpf_send_ena_dis_loopback_msg(adapter, vport->vport_id,
                                                     loopback_ena);
        }

unlock_mutex:
        idpf_vport_ctrl_unlock(netdev);

        return err;
}

/**
 * idpf_open - Called when a network interface becomes active
 * @netdev: network interface device structure
 *
 * The open entry point is called when a network interface is made
 * active by the system (IFF_UP).  At this point all resources needed
 * for transmit and receive operations are allocated, the interrupt
 * handler is registered with the OS, the netdev watchdog is enabled,
 * and the stack is notified that the interface is ready.
 *
 * Returns 0 on success, negative value on failure
 */
static int idpf_open(struct net_device *netdev)
{
        struct idpf_vport *vport;
        int err;

        idpf_vport_ctrl_lock(netdev);
        vport = idpf_netdev_to_vport(netdev);

        err = idpf_set_real_num_queues(vport);
        if (err)
                goto unlock;

        err = idpf_vport_open(vport, false);

unlock:
        idpf_vport_ctrl_unlock(netdev);

        return err;
}

/**
 * idpf_change_mtu - NDO callback to change the MTU
 * @netdev: network interface device structure
 * @new_mtu: new value for maximum frame size
 *
 * Returns 0 on success, negative on failure
 */
static int idpf_change_mtu(struct net_device *netdev, int new_mtu)
{
        struct idpf_vport *vport;
        int err;

        idpf_vport_ctrl_lock(netdev);
        vport = idpf_netdev_to_vport(netdev);

        WRITE_ONCE(netdev->mtu, new_mtu);

        err = idpf_initiate_soft_reset(vport, IDPF_SR_MTU_CHANGE);

        idpf_vport_ctrl_unlock(netdev);

        return err;
}

/**
 * idpf_chk_tso_segment - Check skb is not using too many buffers
 * @skb: send buffer
 * @max_bufs: maximum number of buffers
 *
 * For TSO we need to count the TSO header and segment payload separately.  As
 * such we need to check cases where we have max_bufs-1 fragments or more as we
 * can potentially require max_bufs+1 DMA transactions, 1 for the TSO header, 1
 * for the segment payload in the first descriptor, and another max_buf-1 for
 * the fragments.
 *
 * Returns true if the packet needs to be software segmented by core stack.
 */
static bool idpf_chk_tso_segment(const struct sk_buff *skb,
                                 unsigned int max_bufs)
{
        const struct skb_shared_info *shinfo = skb_shinfo(skb);
        const skb_frag_t *frag, *stale;
        int nr_frags, sum;

        /* no need to check if number of frags is less than max_bufs - 1 */
        nr_frags = shinfo->nr_frags;
        if (nr_frags < (max_bufs - 1))
                return false;

        /* We need to walk through the list and validate that each group
         * of max_bufs-2 fragments totals at least gso_size.
         */
        nr_frags -= max_bufs - 2;
        frag = &shinfo->frags[0];

        /* Initialize size to the negative value of gso_size minus 1.  We use
         * this as the worst case scenario in which the frag ahead of us only
         * provides one byte which is why we are limited to max_bufs-2
         * descriptors for a single transmit as the header and previous
         * fragment are already consuming 2 descriptors.
         */
        sum = 1 - shinfo->gso_size;

        /* Add size of frags 0 through 4 to create our initial sum */
        sum += skb_frag_size(frag++);
        sum += skb_frag_size(frag++);
        sum += skb_frag_size(frag++);
        sum += skb_frag_size(frag++);
        sum += skb_frag_size(frag++);

        /* Walk through fragments adding latest fragment, testing it, and
         * then removing stale fragments from the sum.
         */
        for (stale = &shinfo->frags[0];; stale++) {
                int stale_size = skb_frag_size(stale);

                sum += skb_frag_size(frag++);

                /* The stale fragment may present us with a smaller
                 * descriptor than the actual fragment size. To account
                 * for that we need to remove all the data on the front and
                 * figure out what the remainder would be in the last
                 * descriptor associated with the fragment.
                 */
                if (stale_size > IDPF_TX_MAX_DESC_DATA) {
                        int align_pad = -(skb_frag_off(stale)) &
                                        (IDPF_TX_MAX_READ_REQ_SIZE - 1);

                        sum -= align_pad;
                        stale_size -= align_pad;

                        do {
                                sum -= IDPF_TX_MAX_DESC_DATA_ALIGNED;
                                stale_size -= IDPF_TX_MAX_DESC_DATA_ALIGNED;
                        } while (stale_size > IDPF_TX_MAX_DESC_DATA);
                }

                /* if sum is negative we failed to make sufficient progress */
                if (sum < 0)
                        return true;

                if (!nr_frags--)
                        break;

                sum -= stale_size;
        }

        return false;
}

/**
 * idpf_features_check - Validate packet conforms to limits
 * @skb: skb buffer
 * @netdev: This port's netdev
 * @features: Offload features that the stack believes apply
 */
static netdev_features_t idpf_features_check(struct sk_buff *skb,
                                             struct net_device *netdev,
                                             netdev_features_t features)
{
        struct idpf_netdev_priv *np = netdev_priv(netdev);
        u16 max_tx_hdr_size = np->max_tx_hdr_size;
        size_t len;

        /* No point in doing any of this if neither checksum nor GSO are
         * being requested for this frame.  We can rule out both by just
         * checking for CHECKSUM_PARTIAL
         */
        if (skb->ip_summed != CHECKSUM_PARTIAL)
                return features;

        if (skb_is_gso(skb)) {
                /* We cannot support GSO if the MSS is going to be less than
                 * 88 bytes. If it is then we need to drop support for GSO.
                 */
                if (skb_shinfo(skb)->gso_size < IDPF_TX_TSO_MIN_MSS)
                        features &= ~NETIF_F_GSO_MASK;
                else if (idpf_chk_tso_segment(skb, np->tx_max_bufs))
                        features &= ~NETIF_F_GSO_MASK;
        }

        /* Ensure MACLEN is <= 126 bytes (63 words) and not an odd size */
        len = skb_network_offset(skb);
        if (unlikely(len & ~(126)))
                goto unsupported;

        len = skb_network_header_len(skb);
        if (unlikely(len > max_tx_hdr_size))
                goto unsupported;

        if (!skb->encapsulation)
                return features;

        /* L4TUNLEN can support 127 words */
        len = skb_inner_network_header(skb) - skb_transport_header(skb);
        if (unlikely(len & ~(127 * 2)))
                goto unsupported;

        /* IPLEN can support at most 127 dwords */
        len = skb_inner_network_header_len(skb);
        if (unlikely(len > max_tx_hdr_size))
                goto unsupported;

        /* No need to validate L4LEN as TCP is the only protocol with a
         * a flexible value and we support all possible values supported
         * by TCP, which is at most 15 dwords
         */

        return features;

unsupported:
        return features & ~(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK);
}

/**
 * idpf_set_mac - NDO callback to set port mac address
 * @netdev: network interface device structure
 * @p: pointer to an address structure
 *
 * Returns 0 on success, negative on failure
 **/
static int idpf_set_mac(struct net_device *netdev, void *p)
{
        struct idpf_netdev_priv *np = netdev_priv(netdev);
        struct idpf_vport_config *vport_config;
        struct sockaddr *addr = p;
        u8 old_mac_addr[ETH_ALEN];
        struct idpf_vport *vport;
        int err = 0;

        idpf_vport_ctrl_lock(netdev);
        vport = idpf_netdev_to_vport(netdev);

        if (!idpf_is_cap_ena(vport->adapter, IDPF_OTHER_CAPS,
                             VIRTCHNL2_CAP_MACFILTER)) {
                dev_info(&vport->adapter->pdev->dev, "Setting MAC address is not supported\n");
                err = -EOPNOTSUPP;
                goto unlock_mutex;
        }

        if (!is_valid_ether_addr(addr->sa_data)) {
                dev_info(&vport->adapter->pdev->dev, "Invalid MAC address: %pM\n",
                         addr->sa_data);
                err = -EADDRNOTAVAIL;
                goto unlock_mutex;
        }

        if (ether_addr_equal(netdev->dev_addr, addr->sa_data))
                goto unlock_mutex;

        ether_addr_copy(old_mac_addr, vport->default_mac_addr);
        ether_addr_copy(vport->default_mac_addr, addr->sa_data);
        vport_config = vport->adapter->vport_config[vport->idx];
        err = idpf_add_mac_filter(vport, np, addr->sa_data, false);
        if (err) {
                __idpf_del_mac_filter(vport_config, addr->sa_data);
                ether_addr_copy(vport->default_mac_addr, netdev->dev_addr);
                goto unlock_mutex;
        }

        if (is_valid_ether_addr(old_mac_addr))
                __idpf_del_mac_filter(vport_config, old_mac_addr);

        eth_hw_addr_set(netdev, addr->sa_data);

unlock_mutex:
        idpf_vport_ctrl_unlock(netdev);

        return err;
}

/**
 * idpf_alloc_dma_mem - Allocate dma memory
 * @hw: pointer to hw struct
 * @mem: pointer to dma_mem struct
 * @size: size of the memory to allocate
 */
void *idpf_alloc_dma_mem(struct idpf_hw *hw, struct idpf_dma_mem *mem, u64 size)
{
        struct idpf_adapter *adapter = hw->back;
        size_t sz = ALIGN(size, 4096);

        /* The control queue resources are freed under a spinlock, contiguous
         * pages will avoid IOMMU remapping and the use vmap (and vunmap in
         * dma_free_*() path.
         */
        mem->va = dma_alloc_attrs(&adapter->pdev->dev, sz, &mem->pa,
                                  GFP_KERNEL, DMA_ATTR_FORCE_CONTIGUOUS);
        mem->size = sz;

        return mem->va;
}

/**
 * idpf_free_dma_mem - Free the allocated dma memory
 * @hw: pointer to hw struct
 * @mem: pointer to dma_mem struct
 */
void idpf_free_dma_mem(struct idpf_hw *hw, struct idpf_dma_mem *mem)
{
        struct idpf_adapter *adapter = hw->back;

        dma_free_attrs(&adapter->pdev->dev, mem->size,
                       mem->va, mem->pa, DMA_ATTR_FORCE_CONTIGUOUS);
        mem->size = 0;
        mem->va = NULL;
        mem->pa = 0;
}

static int idpf_hwtstamp_set(struct net_device *netdev,
                             struct kernel_hwtstamp_config *config,
                             struct netlink_ext_ack *extack)
{
        struct idpf_vport *vport;
        int err;

        idpf_vport_ctrl_lock(netdev);
        vport = idpf_netdev_to_vport(netdev);

        if (!vport->link_up) {
                idpf_vport_ctrl_unlock(netdev);
                return -EPERM;
        }

        if (!idpf_ptp_is_vport_tx_tstamp_ena(vport) &&
            !idpf_ptp_is_vport_rx_tstamp_ena(vport)) {
                idpf_vport_ctrl_unlock(netdev);
                return -EOPNOTSUPP;
        }

        err = idpf_ptp_set_timestamp_mode(vport, config);

        idpf_vport_ctrl_unlock(netdev);

        return err;
}

static int idpf_hwtstamp_get(struct net_device *netdev,
                             struct kernel_hwtstamp_config *config)
{
        struct idpf_vport *vport;

        idpf_vport_ctrl_lock(netdev);
        vport = idpf_netdev_to_vport(netdev);

        if (!vport->link_up) {
                idpf_vport_ctrl_unlock(netdev);
                return -EPERM;
        }

        if (!idpf_ptp_is_vport_tx_tstamp_ena(vport) &&
            !idpf_ptp_is_vport_rx_tstamp_ena(vport)) {
                idpf_vport_ctrl_unlock(netdev);
                return 0;
        }

        *config = vport->tstamp_config;

        idpf_vport_ctrl_unlock(netdev);

        return 0;
}

static const struct net_device_ops idpf_netdev_ops = {
        .ndo_open = idpf_open,
        .ndo_stop = idpf_stop,
        .ndo_start_xmit = idpf_tx_start,
        .ndo_features_check = idpf_features_check,
        .ndo_set_rx_mode = idpf_set_rx_mode,
        .ndo_validate_addr = eth_validate_addr,
        .ndo_set_mac_address = idpf_set_mac,
        .ndo_change_mtu = idpf_change_mtu,
        .ndo_get_stats64 = idpf_get_stats64,
        .ndo_set_features = idpf_set_features,
        .ndo_tx_timeout = idpf_tx_timeout,
        .ndo_hwtstamp_get = idpf_hwtstamp_get,
        .ndo_hwtstamp_set = idpf_hwtstamp_set,
        .ndo_bpf = idpf_xdp,
        .ndo_xdp_xmit = idpf_xdp_xmit,
        .ndo_xsk_wakeup = idpf_xsk_wakeup,
};