/*******************************************************************************
 *
 * Intel Ethernet Controller XL710 Family Linux Driver
 * Copyright(c) 2013 - 2017 Intel Corporation.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 * The full GNU General Public License is included in this distribution in
 * the file called "COPYING".
 *
 * Contact Information:
 * e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
 *
 ******************************************************************************/

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

/* Local includes */
#include "i40e.h"
#include "i40e_diag.h"
#include <net/udp_tunnel.h>
/* All i40e tracepoints are defined by the include below, which
 * must be included exactly once across the whole kernel with
 * CREATE_TRACE_POINTS defined
 */
#define CREATE_TRACE_POINTS
#include "i40e_trace.h"

const char i40e_driver_name[] = "i40e";
static const char i40e_driver_string[] =
                        "Intel(R) Ethernet Connection XL710 Network Driver";

#define DRV_KERN "-k"

#define DRV_VERSION_MAJOR 2
#define DRV_VERSION_MINOR 1
#define DRV_VERSION_BUILD 14
#define DRV_VERSION __stringify(DRV_VERSION_MAJOR) "." \
             __stringify(DRV_VERSION_MINOR) "." \
             __stringify(DRV_VERSION_BUILD)    DRV_KERN
const char i40e_driver_version_str[] = DRV_VERSION;
static const char i40e_copyright[] = "Copyright (c) 2013 - 2014 Intel Corporation.";

/* a bit of forward declarations */
static void i40e_vsi_reinit_locked(struct i40e_vsi *vsi);
static void i40e_handle_reset_warning(struct i40e_pf *pf, bool lock_acquired);
static int i40e_add_vsi(struct i40e_vsi *vsi);
static int i40e_add_veb(struct i40e_veb *veb, struct i40e_vsi *vsi);
static int i40e_setup_pf_switch(struct i40e_pf *pf, bool reinit);
static int i40e_setup_misc_vector(struct i40e_pf *pf);
static void i40e_determine_queue_usage(struct i40e_pf *pf);
static int i40e_setup_pf_filter_control(struct i40e_pf *pf);
static void i40e_prep_for_reset(struct i40e_pf *pf, bool lock_acquired);
static int i40e_reset(struct i40e_pf *pf);
static void i40e_rebuild(struct i40e_pf *pf, bool reinit, bool lock_acquired);
static void i40e_fdir_sb_setup(struct i40e_pf *pf);
static int i40e_veb_get_bw_info(struct i40e_veb *veb);

/* i40e_pci_tbl - PCI Device ID Table
 *
 * Last entry must be all 0s
 *
 * { Vendor ID, Device ID, SubVendor ID, SubDevice ID,
 *   Class, Class Mask, private data (not used) }
 */
static const struct pci_device_id i40e_pci_tbl[] = {
        {PCI_VDEVICE(INTEL, I40E_DEV_ID_SFP_XL710), 0},
        {PCI_VDEVICE(INTEL, I40E_DEV_ID_QEMU), 0},
        {PCI_VDEVICE(INTEL, I40E_DEV_ID_KX_B), 0},
        {PCI_VDEVICE(INTEL, I40E_DEV_ID_KX_C), 0},
        {PCI_VDEVICE(INTEL, I40E_DEV_ID_QSFP_A), 0},
        {PCI_VDEVICE(INTEL, I40E_DEV_ID_QSFP_B), 0},
        {PCI_VDEVICE(INTEL, I40E_DEV_ID_QSFP_C), 0},
        {PCI_VDEVICE(INTEL, I40E_DEV_ID_10G_BASE_T), 0},
        {PCI_VDEVICE(INTEL, I40E_DEV_ID_10G_BASE_T4), 0},
        {PCI_VDEVICE(INTEL, I40E_DEV_ID_KX_X722), 0},
        {PCI_VDEVICE(INTEL, I40E_DEV_ID_QSFP_X722), 0},
        {PCI_VDEVICE(INTEL, I40E_DEV_ID_SFP_X722), 0},
        {PCI_VDEVICE(INTEL, I40E_DEV_ID_1G_BASE_T_X722), 0},
        {PCI_VDEVICE(INTEL, I40E_DEV_ID_10G_BASE_T_X722), 0},
        {PCI_VDEVICE(INTEL, I40E_DEV_ID_SFP_I_X722), 0},
        {PCI_VDEVICE(INTEL, I40E_DEV_ID_20G_KR2), 0},
        {PCI_VDEVICE(INTEL, I40E_DEV_ID_20G_KR2_A), 0},
        {PCI_VDEVICE(INTEL, I40E_DEV_ID_25G_B), 0},
        {PCI_VDEVICE(INTEL, I40E_DEV_ID_25G_SFP28), 0},
        /* required last entry */
        {0, }
};
MODULE_DEVICE_TABLE(pci, i40e_pci_tbl);

#define I40E_MAX_VF_COUNT 128
static int debug = -1;
module_param(debug, uint, 0);
MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all), Debug mask (0x8XXXXXXX)");

MODULE_AUTHOR("Intel Corporation, <e1000-devel@lists.sourceforge.net>");
MODULE_DESCRIPTION("Intel(R) Ethernet Connection XL710 Network Driver");
MODULE_LICENSE("GPL");
MODULE_VERSION(DRV_VERSION);

static struct workqueue_struct *i40e_wq;

/**
 * i40e_allocate_dma_mem_d - OS specific memory alloc for shared code
 * @hw:   pointer to the HW structure
 * @mem:  ptr to mem struct to fill out
 * @size: size of memory requested
 * @alignment: what to align the allocation to
 **/
int i40e_allocate_dma_mem_d(struct i40e_hw *hw, struct i40e_dma_mem *mem,
                            u64 size, u32 alignment)
{
        struct i40e_pf *pf = (struct i40e_pf *)hw->back;

        mem->size = ALIGN(size, alignment);
        mem->va = dma_zalloc_coherent(&pf->pdev->dev, mem->size,
                                      &mem->pa, GFP_KERNEL);
        if (!mem->va)
                return -ENOMEM;

        return 0;
}

/**
 * i40e_free_dma_mem_d - OS specific memory free for shared code
 * @hw:   pointer to the HW structure
 * @mem:  ptr to mem struct to free
 **/
int i40e_free_dma_mem_d(struct i40e_hw *hw, struct i40e_dma_mem *mem)
{
        struct i40e_pf *pf = (struct i40e_pf *)hw->back;

        dma_free_coherent(&pf->pdev->dev, mem->size, mem->va, mem->pa);
        mem->va = NULL;
        mem->pa = 0;
        mem->size = 0;

        return 0;
}

/**
 * i40e_allocate_virt_mem_d - OS specific memory alloc for shared code
 * @hw:   pointer to the HW structure
 * @mem:  ptr to mem struct to fill out
 * @size: size of memory requested
 **/
int i40e_allocate_virt_mem_d(struct i40e_hw *hw, struct i40e_virt_mem *mem,
                             u32 size)
{
        mem->size = size;
        mem->va = kzalloc(size, GFP_KERNEL);

        if (!mem->va)
                return -ENOMEM;

        return 0;
}

/**
 * i40e_free_virt_mem_d - OS specific memory free for shared code
 * @hw:   pointer to the HW structure
 * @mem:  ptr to mem struct to free
 **/
int i40e_free_virt_mem_d(struct i40e_hw *hw, struct i40e_virt_mem *mem)
{
        /* it's ok to kfree a NULL pointer */
        kfree(mem->va);
        mem->va = NULL;
        mem->size = 0;

        return 0;
}

/**
 * i40e_get_lump - find a lump of free generic resource
 * @pf: board private structure
 * @pile: the pile of resource to search
 * @needed: the number of items needed
 * @id: an owner id to stick on the items assigned
 *
 * Returns the base item index of the lump, or negative for error
 *
 * The search_hint trick and lack of advanced fit-finding only work
 * because we're highly likely to have all the same size lump requests.
 * Linear search time and any fragmentation should be minimal.
 **/
static int i40e_get_lump(struct i40e_pf *pf, struct i40e_lump_tracking *pile,
                         u16 needed, u16 id)
{
        int ret = -ENOMEM;
        int i, j;

        if (!pile || needed == 0 || id >= I40E_PILE_VALID_BIT) {
                dev_info(&pf->pdev->dev,
                         "param err: pile=%p needed=%d id=0x%04x\n",
                         pile, needed, id);
                return -EINVAL;
        }

        /* start the linear search with an imperfect hint */
        i = pile->search_hint;
        while (i < pile->num_entries) {
                /* skip already allocated entries */
                if (pile->list[i] & I40E_PILE_VALID_BIT) {
                        i++;
                        continue;
                }

                /* do we have enough in this lump? */
                for (j = 0; (j < needed) && ((i+j) < pile->num_entries); j++) {
                        if (pile->list[i+j] & I40E_PILE_VALID_BIT)
                                break;
                }

                if (j == needed) {
                        /* there was enough, so assign it to the requestor */
                        for (j = 0; j < needed; j++)
                                pile->list[i+j] = id | I40E_PILE_VALID_BIT;
                        ret = i;
                        pile->search_hint = i + j;
                        break;
                }

                /* not enough, so skip over it and continue looking */
                i += j;
        }

        return ret;
}

/**
 * i40e_put_lump - return a lump of generic resource
 * @pile: the pile of resource to search
 * @index: the base item index
 * @id: the owner id of the items assigned
 *
 * Returns the count of items in the lump
 **/
static int i40e_put_lump(struct i40e_lump_tracking *pile, u16 index, u16 id)
{
        int valid_id = (id | I40E_PILE_VALID_BIT);
        int count = 0;
        int i;

        if (!pile || index >= pile->num_entries)
                return -EINVAL;

        for (i = index;
             i < pile->num_entries && pile->list[i] == valid_id;
             i++) {
                pile->list[i] = 0;
                count++;
        }

        if (count && index < pile->search_hint)
                pile->search_hint = index;

        return count;
}

/**
 * i40e_find_vsi_from_id - searches for the vsi with the given id
 * @pf - the pf structure to search for the vsi
 * @id - id of the vsi it is searching for
 **/
struct i40e_vsi *i40e_find_vsi_from_id(struct i40e_pf *pf, u16 id)
{
        int i;

        for (i = 0; i < pf->num_alloc_vsi; i++)
                if (pf->vsi[i] && (pf->vsi[i]->id == id))
                        return pf->vsi[i];

        return NULL;
}

/**
 * i40e_service_event_schedule - Schedule the service task to wake up
 * @pf: board private structure
 *
 * If not already scheduled, this puts the task into the work queue
 **/
void i40e_service_event_schedule(struct i40e_pf *pf)
{
        if (!test_bit(__I40E_DOWN, pf->state) &&
            !test_bit(__I40E_RESET_RECOVERY_PENDING, pf->state))
                queue_work(i40e_wq, &pf->service_task);
}

/**
 * i40e_tx_timeout - Respond to a Tx Hang
 * @netdev: network interface device structure
 *
 * If any port has noticed a Tx timeout, it is likely that the whole
 * device is munged, not just the one netdev port, so go for the full
 * reset.
 **/
static void i40e_tx_timeout(struct net_device *netdev)
{
        struct i40e_netdev_priv *np = netdev_priv(netdev);
        struct i40e_vsi *vsi = np->vsi;
        struct i40e_pf *pf = vsi->back;
        struct i40e_ring *tx_ring = NULL;
        unsigned int i, hung_queue = 0;
        u32 head, val;

        pf->tx_timeout_count++;

        /* find the stopped queue the same way the stack does */
        for (i = 0; i < netdev->num_tx_queues; i++) {
                struct netdev_queue *q;
                unsigned long trans_start;

                q = netdev_get_tx_queue(netdev, i);
                trans_start = q->trans_start;
                if (netif_xmit_stopped(q) &&
                    time_after(jiffies,
                               (trans_start + netdev->watchdog_timeo))) {
                        hung_queue = i;
                        break;
                }
        }

        if (i == netdev->num_tx_queues) {
                netdev_info(netdev, "tx_timeout: no netdev hung queue found\n");
        } else {
                /* now that we have an index, find the tx_ring struct */
                for (i = 0; i < vsi->num_queue_pairs; i++) {
                        if (vsi->tx_rings[i] && vsi->tx_rings[i]->desc) {
                                if (hung_queue ==
                                    vsi->tx_rings[i]->queue_index) {
                                        tx_ring = vsi->tx_rings[i];
                                        break;
                                }
                        }
                }
        }

        if (time_after(jiffies, (pf->tx_timeout_last_recovery + HZ*20)))
                pf->tx_timeout_recovery_level = 1;  /* reset after some time */
        else if (time_before(jiffies,
                      (pf->tx_timeout_last_recovery + netdev->watchdog_timeo)))
                return;   /* don't do any new action before the next timeout */

        if (tx_ring) {
                head = i40e_get_head(tx_ring);
                /* Read interrupt register */
                if (pf->flags & I40E_FLAG_MSIX_ENABLED)
                        val = rd32(&pf->hw,
                             I40E_PFINT_DYN_CTLN(tx_ring->q_vector->v_idx +
                                                tx_ring->vsi->base_vector - 1));
                else
                        val = rd32(&pf->hw, I40E_PFINT_DYN_CTL0);

                netdev_info(netdev, "tx_timeout: VSI_seid: %d, Q %d, NTC: 0x%x, HWB: 0x%x, NTU: 0x%x, TAIL: 0x%x, INT: 0x%x\n",
                            vsi->seid, hung_queue, tx_ring->next_to_clean,
                            head, tx_ring->next_to_use,
                            readl(tx_ring->tail), val);
        }

        pf->tx_timeout_last_recovery = jiffies;
        netdev_info(netdev, "tx_timeout recovery level %d, hung_queue %d\n",
                    pf->tx_timeout_recovery_level, hung_queue);

        switch (pf->tx_timeout_recovery_level) {
        case 1:
                set_bit(__I40E_PF_RESET_REQUESTED, pf->state);
                break;
        case 2:
                set_bit(__I40E_CORE_RESET_REQUESTED, pf->state);
                break;
        case 3:
                set_bit(__I40E_GLOBAL_RESET_REQUESTED, pf->state);
                break;
        default:
                netdev_err(netdev, "tx_timeout recovery unsuccessful\n");
                break;
        }

        i40e_service_event_schedule(pf);
        pf->tx_timeout_recovery_level++;
}

/**
 * i40e_get_vsi_stats_struct - Get System Network Statistics
 * @vsi: the VSI we care about
 *
 * Returns the address of the device statistics structure.
 * The statistics are actually updated from the service task.
 **/
struct rtnl_link_stats64 *i40e_get_vsi_stats_struct(struct i40e_vsi *vsi)
{
        return &vsi->net_stats;
}

/**
 * i40e_get_netdev_stats_struct_tx - populate stats from a Tx ring
 * @ring: Tx ring to get statistics from
 * @stats: statistics entry to be updated
 **/
static void i40e_get_netdev_stats_struct_tx(struct i40e_ring *ring,
                                            struct rtnl_link_stats64 *stats)
{
        u64 bytes, packets;
        unsigned int start;

        do {
                start = u64_stats_fetch_begin_irq(&ring->syncp);
                packets = ring->stats.packets;
                bytes   = ring->stats.bytes;
        } while (u64_stats_fetch_retry_irq(&ring->syncp, start));

        stats->tx_packets += packets;
        stats->tx_bytes   += bytes;
}

/**
 * i40e_get_netdev_stats_struct - Get statistics for netdev interface
 * @netdev: network interface device structure
 *
 * Returns the address of the device statistics structure.
 * The statistics are actually updated from the service task.
 **/
static void i40e_get_netdev_stats_struct(struct net_device *netdev,
                                  struct rtnl_link_stats64 *stats)
{
        struct i40e_netdev_priv *np = netdev_priv(netdev);
        struct i40e_ring *tx_ring, *rx_ring;
        struct i40e_vsi *vsi = np->vsi;
        struct rtnl_link_stats64 *vsi_stats = i40e_get_vsi_stats_struct(vsi);
        int i;

        if (test_bit(__I40E_VSI_DOWN, vsi->state))
                return;

        if (!vsi->tx_rings)
                return;

        rcu_read_lock();
        for (i = 0; i < vsi->num_queue_pairs; i++) {
                u64 bytes, packets;
                unsigned int start;

                tx_ring = ACCESS_ONCE(vsi->tx_rings[i]);
                if (!tx_ring)
                        continue;
                i40e_get_netdev_stats_struct_tx(tx_ring, stats);

                rx_ring = &tx_ring[1];

                do {
                        start = u64_stats_fetch_begin_irq(&rx_ring->syncp);
                        packets = rx_ring->stats.packets;
                        bytes   = rx_ring->stats.bytes;
                } while (u64_stats_fetch_retry_irq(&rx_ring->syncp, start));

                stats->rx_packets += packets;
                stats->rx_bytes   += bytes;

                if (i40e_enabled_xdp_vsi(vsi))
                        i40e_get_netdev_stats_struct_tx(&rx_ring[1], stats);
        }
        rcu_read_unlock();

        /* following stats updated by i40e_watchdog_subtask() */
        stats->multicast        = vsi_stats->multicast;
        stats->tx_errors        = vsi_stats->tx_errors;
        stats->tx_dropped       = vsi_stats->tx_dropped;
        stats->rx_errors        = vsi_stats->rx_errors;
        stats->rx_dropped       = vsi_stats->rx_dropped;
        stats->rx_crc_errors    = vsi_stats->rx_crc_errors;
        stats->rx_length_errors = vsi_stats->rx_length_errors;
}

/**
 * i40e_vsi_reset_stats - Resets all stats of the given vsi
 * @vsi: the VSI to have its stats reset
 **/
void i40e_vsi_reset_stats(struct i40e_vsi *vsi)
{
        struct rtnl_link_stats64 *ns;
        int i;

        if (!vsi)
                return;

        ns = i40e_get_vsi_stats_struct(vsi);
        memset(ns, 0, sizeof(*ns));
        memset(&vsi->net_stats_offsets, 0, sizeof(vsi->net_stats_offsets));
        memset(&vsi->eth_stats, 0, sizeof(vsi->eth_stats));
        memset(&vsi->eth_stats_offsets, 0, sizeof(vsi->eth_stats_offsets));
        if (vsi->rx_rings && vsi->rx_rings[0]) {
                for (i = 0; i < vsi->num_queue_pairs; i++) {
                        memset(&vsi->rx_rings[i]->stats, 0,
                               sizeof(vsi->rx_rings[i]->stats));
                        memset(&vsi->rx_rings[i]->rx_stats, 0,
                               sizeof(vsi->rx_rings[i]->rx_stats));
                        memset(&vsi->tx_rings[i]->stats, 0,
                               sizeof(vsi->tx_rings[i]->stats));
                        memset(&vsi->tx_rings[i]->tx_stats, 0,
                               sizeof(vsi->tx_rings[i]->tx_stats));
                }
        }
        vsi->stat_offsets_loaded = false;
}

/**
 * i40e_pf_reset_stats - Reset all of the stats for the given PF
 * @pf: the PF to be reset
 **/
void i40e_pf_reset_stats(struct i40e_pf *pf)
{
        int i;

        memset(&pf->stats, 0, sizeof(pf->stats));
        memset(&pf->stats_offsets, 0, sizeof(pf->stats_offsets));
        pf->stat_offsets_loaded = false;

        for (i = 0; i < I40E_MAX_VEB; i++) {
                if (pf->veb[i]) {
                        memset(&pf->veb[i]->stats, 0,
                               sizeof(pf->veb[i]->stats));
                        memset(&pf->veb[i]->stats_offsets, 0,
                               sizeof(pf->veb[i]->stats_offsets));
                        pf->veb[i]->stat_offsets_loaded = false;
                }
        }
        pf->hw_csum_rx_error = 0;
}

/**
 * i40e_stat_update48 - read and update a 48 bit stat from the chip
 * @hw: ptr to the hardware info
 * @hireg: the high 32 bit reg to read
 * @loreg: the low 32 bit reg to read
 * @offset_loaded: has the initial offset been loaded yet
 * @offset: ptr to current offset value
 * @stat: ptr to the stat
 *
 * Since the device stats are not reset at PFReset, they likely will not
 * be zeroed when the driver starts.  We'll save the first values read
 * and use them as offsets to be subtracted from the raw values in order
 * to report stats that count from zero.  In the process, we also manage
 * the potential roll-over.
 **/
static void i40e_stat_update48(struct i40e_hw *hw, u32 hireg, u32 loreg,
                               bool offset_loaded, u64 *offset, u64 *stat)
{
        u64 new_data;

        if (hw->device_id == I40E_DEV_ID_QEMU) {
                new_data = rd32(hw, loreg);
                new_data |= ((u64)(rd32(hw, hireg) & 0xFFFF)) << 32;
        } else {
                new_data = rd64(hw, loreg);
        }
        if (!offset_loaded)
                *offset = new_data;
        if (likely(new_data >= *offset))
                *stat = new_data - *offset;
        else
                *stat = (new_data + BIT_ULL(48)) - *offset;
        *stat &= 0xFFFFFFFFFFFFULL;
}

/**
 * i40e_stat_update32 - read and update a 32 bit stat from the chip
 * @hw: ptr to the hardware info
 * @reg: the hw reg to read
 * @offset_loaded: has the initial offset been loaded yet
 * @offset: ptr to current offset value
 * @stat: ptr to the stat
 **/
static void i40e_stat_update32(struct i40e_hw *hw, u32 reg,
                               bool offset_loaded, u64 *offset, u64 *stat)
{
        u32 new_data;

        new_data = rd32(hw, reg);
        if (!offset_loaded)
                *offset = new_data;
        if (likely(new_data >= *offset))
                *stat = (u32)(new_data - *offset);
        else
                *stat = (u32)((new_data + BIT_ULL(32)) - *offset);
}

/**
 * i40e_update_eth_stats - Update VSI-specific ethernet statistics counters.
 * @vsi: the VSI to be updated
 **/
void i40e_update_eth_stats(struct i40e_vsi *vsi)
{
        int stat_idx = le16_to_cpu(vsi->info.stat_counter_idx);
        struct i40e_pf *pf = vsi->back;
        struct i40e_hw *hw = &pf->hw;
        struct i40e_eth_stats *oes;
        struct i40e_eth_stats *es;     /* device's eth stats */

        es = &vsi->eth_stats;
        oes = &vsi->eth_stats_offsets;

        /* Gather up the stats that the hw collects */
        i40e_stat_update32(hw, I40E_GLV_TEPC(stat_idx),
                           vsi->stat_offsets_loaded,
                           &oes->tx_errors, &es->tx_errors);
        i40e_stat_update32(hw, I40E_GLV_RDPC(stat_idx),
                           vsi->stat_offsets_loaded,
                           &oes->rx_discards, &es->rx_discards);
        i40e_stat_update32(hw, I40E_GLV_RUPP(stat_idx),
                           vsi->stat_offsets_loaded,
                           &oes->rx_unknown_protocol, &es->rx_unknown_protocol);
        i40e_stat_update32(hw, I40E_GLV_TEPC(stat_idx),
                           vsi->stat_offsets_loaded,
                           &oes->tx_errors, &es->tx_errors);

        i40e_stat_update48(hw, I40E_GLV_GORCH(stat_idx),
                           I40E_GLV_GORCL(stat_idx),
                           vsi->stat_offsets_loaded,
                           &oes->rx_bytes, &es->rx_bytes);
        i40e_stat_update48(hw, I40E_GLV_UPRCH(stat_idx),
                           I40E_GLV_UPRCL(stat_idx),
                           vsi->stat_offsets_loaded,
                           &oes->rx_unicast, &es->rx_unicast);
        i40e_stat_update48(hw, I40E_GLV_MPRCH(stat_idx),
                           I40E_GLV_MPRCL(stat_idx),
                           vsi->stat_offsets_loaded,
                           &oes->rx_multicast, &es->rx_multicast);
        i40e_stat_update48(hw, I40E_GLV_BPRCH(stat_idx),
                           I40E_GLV_BPRCL(stat_idx),
                           vsi->stat_offsets_loaded,
                           &oes->rx_broadcast, &es->rx_broadcast);

        i40e_stat_update48(hw, I40E_GLV_GOTCH(stat_idx),
                           I40E_GLV_GOTCL(stat_idx),
                           vsi->stat_offsets_loaded,
                           &oes->tx_bytes, &es->tx_bytes);
        i40e_stat_update48(hw, I40E_GLV_UPTCH(stat_idx),
                           I40E_GLV_UPTCL(stat_idx),
                           vsi->stat_offsets_loaded,
                           &oes->tx_unicast, &es->tx_unicast);
        i40e_stat_update48(hw, I40E_GLV_MPTCH(stat_idx),
                           I40E_GLV_MPTCL(stat_idx),
                           vsi->stat_offsets_loaded,
                           &oes->tx_multicast, &es->tx_multicast);
        i40e_stat_update48(hw, I40E_GLV_BPTCH(stat_idx),
                           I40E_GLV_BPTCL(stat_idx),
                           vsi->stat_offsets_loaded,
                           &oes->tx_broadcast, &es->tx_broadcast);
        vsi->stat_offsets_loaded = true;
}

/**
 * i40e_update_veb_stats - Update Switch component statistics
 * @veb: the VEB being updated
 **/
static void i40e_update_veb_stats(struct i40e_veb *veb)
{
        struct i40e_pf *pf = veb->pf;
        struct i40e_hw *hw = &pf->hw;
        struct i40e_eth_stats *oes;
        struct i40e_eth_stats *es;     /* device's eth stats */
        struct i40e_veb_tc_stats *veb_oes;
        struct i40e_veb_tc_stats *veb_es;
        int i, idx = 0;

        idx = veb->stats_idx;
        es = &veb->stats;
        oes = &veb->stats_offsets;
        veb_es = &veb->tc_stats;
        veb_oes = &veb->tc_stats_offsets;

        /* Gather up the stats that the hw collects */
        i40e_stat_update32(hw, I40E_GLSW_TDPC(idx),
                           veb->stat_offsets_loaded,
                           &oes->tx_discards, &es->tx_discards);
        if (hw->revision_id > 0)
                i40e_stat_update32(hw, I40E_GLSW_RUPP(idx),
                                   veb->stat_offsets_loaded,
                                   &oes->rx_unknown_protocol,
                                   &es->rx_unknown_protocol);
        i40e_stat_update48(hw, I40E_GLSW_GORCH(idx), I40E_GLSW_GORCL(idx),
                           veb->stat_offsets_loaded,
                           &oes->rx_bytes, &es->rx_bytes);
        i40e_stat_update48(hw, I40E_GLSW_UPRCH(idx), I40E_GLSW_UPRCL(idx),
                           veb->stat_offsets_loaded,
                           &oes->rx_unicast, &es->rx_unicast);
        i40e_stat_update48(hw, I40E_GLSW_MPRCH(idx), I40E_GLSW_MPRCL(idx),
                           veb->stat_offsets_loaded,
                           &oes->rx_multicast, &es->rx_multicast);
        i40e_stat_update48(hw, I40E_GLSW_BPRCH(idx), I40E_GLSW_BPRCL(idx),
                           veb->stat_offsets_loaded,
                           &oes->rx_broadcast, &es->rx_broadcast);

        i40e_stat_update48(hw, I40E_GLSW_GOTCH(idx), I40E_GLSW_GOTCL(idx),
                           veb->stat_offsets_loaded,
                           &oes->tx_bytes, &es->tx_bytes);
        i40e_stat_update48(hw, I40E_GLSW_UPTCH(idx), I40E_GLSW_UPTCL(idx),
                           veb->stat_offsets_loaded,
                           &oes->tx_unicast, &es->tx_unicast);
        i40e_stat_update48(hw, I40E_GLSW_MPTCH(idx), I40E_GLSW_MPTCL(idx),
                           veb->stat_offsets_loaded,
                           &oes->tx_multicast, &es->tx_multicast);
        i40e_stat_update48(hw, I40E_GLSW_BPTCH(idx), I40E_GLSW_BPTCL(idx),
                           veb->stat_offsets_loaded,
                           &oes->tx_broadcast, &es->tx_broadcast);
        for (i = 0; i < I40E_MAX_TRAFFIC_CLASS; i++) {
                i40e_stat_update48(hw, I40E_GLVEBTC_RPCH(i, idx),
                                   I40E_GLVEBTC_RPCL(i, idx),
                                   veb->stat_offsets_loaded,
                                   &veb_oes->tc_rx_packets[i],
                                   &veb_es->tc_rx_packets[i]);
                i40e_stat_update48(hw, I40E_GLVEBTC_RBCH(i, idx),
                                   I40E_GLVEBTC_RBCL(i, idx),
                                   veb->stat_offsets_loaded,
                                   &veb_oes->tc_rx_bytes[i],
                                   &veb_es->tc_rx_bytes[i]);
                i40e_stat_update48(hw, I40E_GLVEBTC_TPCH(i, idx),
                                   I40E_GLVEBTC_TPCL(i, idx),
                                   veb->stat_offsets_loaded,
                                   &veb_oes->tc_tx_packets[i],
                                   &veb_es->tc_tx_packets[i]);
                i40e_stat_update48(hw, I40E_GLVEBTC_TBCH(i, idx),
                                   I40E_GLVEBTC_TBCL(i, idx),
                                   veb->stat_offsets_loaded,
                                   &veb_oes->tc_tx_bytes[i],
                                   &veb_es->tc_tx_bytes[i]);
        }
        veb->stat_offsets_loaded = true;
}

/**
 * i40e_update_vsi_stats - Update the vsi statistics counters.
 * @vsi: the VSI to be updated
 *
 * There are a few instances where we store the same stat in a
 * couple of different structs.  This is partly because we have
 * the netdev stats that need to be filled out, which is slightly
 * different from the "eth_stats" defined by the chip and used in
 * VF communications.  We sort it out here.
 **/
static void i40e_update_vsi_stats(struct i40e_vsi *vsi)
{
        struct i40e_pf *pf = vsi->back;
        struct rtnl_link_stats64 *ons;
        struct rtnl_link_stats64 *ns;   /* netdev stats */
        struct i40e_eth_stats *oes;
        struct i40e_eth_stats *es;     /* device's eth stats */
        u32 tx_restart, tx_busy;
        struct i40e_ring *p;
        u32 rx_page, rx_buf;
        u64 bytes, packets;
        unsigned int start;
        u64 tx_linearize;
        u64 tx_force_wb;
        u64 rx_p, rx_b;
        u64 tx_p, tx_b;
        u16 q;

        if (test_bit(__I40E_VSI_DOWN, vsi->state) ||
            test_bit(__I40E_CONFIG_BUSY, pf->state))
                return;

        ns = i40e_get_vsi_stats_struct(vsi);
        ons = &vsi->net_stats_offsets;
        es = &vsi->eth_stats;
        oes = &vsi->eth_stats_offsets;

        /* Gather up the netdev and vsi stats that the driver collects
         * on the fly during packet processing
         */
        rx_b = rx_p = 0;
        tx_b = tx_p = 0;
        tx_restart = tx_busy = tx_linearize = tx_force_wb = 0;
        rx_page = 0;
        rx_buf = 0;
        rcu_read_lock();
        for (q = 0; q < vsi->num_queue_pairs; q++) {
                /* locate Tx ring */
                p = ACCESS_ONCE(vsi->tx_rings[q]);

                do {
                        start = u64_stats_fetch_begin_irq(&p->syncp);
                        packets = p->stats.packets;
                        bytes = p->stats.bytes;
                } while (u64_stats_fetch_retry_irq(&p->syncp, start));
                tx_b += bytes;
                tx_p += packets;
                tx_restart += p->tx_stats.restart_queue;
                tx_busy += p->tx_stats.tx_busy;
                tx_linearize += p->tx_stats.tx_linearize;
                tx_force_wb += p->tx_stats.tx_force_wb;

                /* Rx queue is part of the same block as Tx queue */
                p = &p[1];
                do {
                        start = u64_stats_fetch_begin_irq(&p->syncp);
                        packets = p->stats.packets;
                        bytes = p->stats.bytes;
                } while (u64_stats_fetch_retry_irq(&p->syncp, start));
                rx_b += bytes;
                rx_p += packets;
                rx_buf += p->rx_stats.alloc_buff_failed;
                rx_page += p->rx_stats.alloc_page_failed;
        }
        rcu_read_unlock();
        vsi->tx_restart = tx_restart;
        vsi->tx_busy = tx_busy;
        vsi->tx_linearize = tx_linearize;
        vsi->tx_force_wb = tx_force_wb;
        vsi->rx_page_failed = rx_page;
        vsi->rx_buf_failed = rx_buf;

        ns->rx_packets = rx_p;
        ns->rx_bytes = rx_b;
        ns->tx_packets = tx_p;
        ns->tx_bytes = tx_b;

        /* update netdev stats from eth stats */
        i40e_update_eth_stats(vsi);
        ons->tx_errors = oes->tx_errors;
        ns->tx_errors = es->tx_errors;
        ons->multicast = oes->rx_multicast;
        ns->multicast = es->rx_multicast;
        ons->rx_dropped = oes->rx_discards;
        ns->rx_dropped = es->rx_discards;
        ons->tx_dropped = oes->tx_discards;
        ns->tx_dropped = es->tx_discards;

        /* pull in a couple PF stats if this is the main vsi */
        if (vsi == pf->vsi[pf->lan_vsi]) {
                ns->rx_crc_errors = pf->stats.crc_errors;
                ns->rx_errors = pf->stats.crc_errors + pf->stats.illegal_bytes;
                ns->rx_length_errors = pf->stats.rx_length_errors;
        }
}

/**
 * i40e_update_pf_stats - Update the PF statistics counters.
 * @pf: the PF to be updated
 **/
static void i40e_update_pf_stats(struct i40e_pf *pf)
{
        struct i40e_hw_port_stats *osd = &pf->stats_offsets;
        struct i40e_hw_port_stats *nsd = &pf->stats;
        struct i40e_hw *hw = &pf->hw;
        u32 val;
        int i;

        i40e_stat_update48(hw, I40E_GLPRT_GORCH(hw->port),
                           I40E_GLPRT_GORCL(hw->port),
                           pf->stat_offsets_loaded,
                           &osd->eth.rx_bytes, &nsd->eth.rx_bytes);
        i40e_stat_update48(hw, I40E_GLPRT_GOTCH(hw->port),
                           I40E_GLPRT_GOTCL(hw->port),
                           pf->stat_offsets_loaded,
                           &osd->eth.tx_bytes, &nsd->eth.tx_bytes);
        i40e_stat_update32(hw, I40E_GLPRT_RDPC(hw->port),
                           pf->stat_offsets_loaded,
                           &osd->eth.rx_discards,
                           &nsd->eth.rx_discards);
        i40e_stat_update48(hw, I40E_GLPRT_UPRCH(hw->port),
                           I40E_GLPRT_UPRCL(hw->port),
                           pf->stat_offsets_loaded,
                           &osd->eth.rx_unicast,
                           &nsd->eth.rx_unicast);
        i40e_stat_update48(hw, I40E_GLPRT_MPRCH(hw->port),
                           I40E_GLPRT_MPRCL(hw->port),
                           pf->stat_offsets_loaded,
                           &osd->eth.rx_multicast,
                           &nsd->eth.rx_multicast);
        i40e_stat_update48(hw, I40E_GLPRT_BPRCH(hw->port),
                           I40E_GLPRT_BPRCL(hw->port),
                           pf->stat_offsets_loaded,
                           &osd->eth.rx_broadcast,
                           &nsd->eth.rx_broadcast);
        i40e_stat_update48(hw, I40E_GLPRT_UPTCH(hw->port),
                           I40E_GLPRT_UPTCL(hw->port),
                           pf->stat_offsets_loaded,
                           &osd->eth.tx_unicast,
                           &nsd->eth.tx_unicast);
        i40e_stat_update48(hw, I40E_GLPRT_MPTCH(hw->port),
                           I40E_GLPRT_MPTCL(hw->port),
                           pf->stat_offsets_loaded,
                           &osd->eth.tx_multicast,
                           &nsd->eth.tx_multicast);
        i40e_stat_update48(hw, I40E_GLPRT_BPTCH(hw->port),
                           I40E_GLPRT_BPTCL(hw->port),
                           pf->stat_offsets_loaded,
                           &osd->eth.tx_broadcast,
                           &nsd->eth.tx_broadcast);

        i40e_stat_update32(hw, I40E_GLPRT_TDOLD(hw->port),
                           pf->stat_offsets_loaded,
                           &osd->tx_dropped_link_down,
                           &nsd->tx_dropped_link_down);

        i40e_stat_update32(hw, I40E_GLPRT_CRCERRS(hw->port),
                           pf->stat_offsets_loaded,
                           &osd->crc_errors, &nsd->crc_errors);

        i40e_stat_update32(hw, I40E_GLPRT_ILLERRC(hw->port),
                           pf->stat_offsets_loaded,
                           &osd->illegal_bytes, &nsd->illegal_bytes);

        i40e_stat_update32(hw, I40E_GLPRT_MLFC(hw->port),
                           pf->stat_offsets_loaded,
                           &osd->mac_local_faults,
                           &nsd->mac_local_faults);
        i40e_stat_update32(hw, I40E_GLPRT_MRFC(hw->port),
                           pf->stat_offsets_loaded,
                           &osd->mac_remote_faults,
                           &nsd->mac_remote_faults);

        i40e_stat_update32(hw, I40E_GLPRT_RLEC(hw->port),
                           pf->stat_offsets_loaded,
                           &osd->rx_length_errors,
                           &nsd->rx_length_errors);

        i40e_stat_update32(hw, I40E_GLPRT_LXONRXC(hw->port),
                           pf->stat_offsets_loaded,
                           &osd->link_xon_rx, &nsd->link_xon_rx);
        i40e_stat_update32(hw, I40E_GLPRT_LXONTXC(hw->port),
                           pf->stat_offsets_loaded,
                           &osd->link_xon_tx, &nsd->link_xon_tx);
        i40e_stat_update32(hw, I40E_GLPRT_LXOFFRXC(hw->port),
                           pf->stat_offsets_loaded,
                           &osd->link_xoff_rx, &nsd->link_xoff_rx);
        i40e_stat_update32(hw, I40E_GLPRT_LXOFFTXC(hw->port),
                           pf->stat_offsets_loaded,
                           &osd->link_xoff_tx, &nsd->link_xoff_tx);

        for (i = 0; i < 8; i++) {
                i40e_stat_update32(hw, I40E_GLPRT_PXOFFRXC(hw->port, i),
                                   pf->stat_offsets_loaded,
                                   &osd->priority_xoff_rx[i],
                                   &nsd->priority_xoff_rx[i]);
                i40e_stat_update32(hw, I40E_GLPRT_PXONRXC(hw->port, i),
                                   pf->stat_offsets_loaded,
                                   &osd->priority_xon_rx[i],
                                   &nsd->priority_xon_rx[i]);
                i40e_stat_update32(hw, I40E_GLPRT_PXONTXC(hw->port, i),
                                   pf->stat_offsets_loaded,
                                   &osd->priority_xon_tx[i],
                                   &nsd->priority_xon_tx[i]);
                i40e_stat_update32(hw, I40E_GLPRT_PXOFFTXC(hw->port, i),
                                   pf->stat_offsets_loaded,
                                   &osd->priority_xoff_tx[i],
                                   &nsd->priority_xoff_tx[i]);
                i40e_stat_update32(hw,
                                   I40E_GLPRT_RXON2OFFCNT(hw->port, i),
                                   pf->stat_offsets_loaded,
                                   &osd->priority_xon_2_xoff[i],
                                   &nsd->priority_xon_2_xoff[i]);
        }

        i40e_stat_update48(hw, I40E_GLPRT_PRC64H(hw->port),
                           I40E_GLPRT_PRC64L(hw->port),
                           pf->stat_offsets_loaded,
                           &osd->rx_size_64, &nsd->rx_size_64);
        i40e_stat_update48(hw, I40E_GLPRT_PRC127H(hw->port),
                           I40E_GLPRT_PRC127L(hw->port),
                           pf->stat_offsets_loaded,
                           &osd->rx_size_127, &nsd->rx_size_127);
        i40e_stat_update48(hw, I40E_GLPRT_PRC255H(hw->port),
                           I40E_GLPRT_PRC255L(hw->port),
                           pf->stat_offsets_loaded,
                           &osd->rx_size_255, &nsd->rx_size_255);
        i40e_stat_update48(hw, I40E_GLPRT_PRC511H(hw->port),
                           I40E_GLPRT_PRC511L(hw->port),
                           pf->stat_offsets_loaded,
                           &osd->rx_size_511, &nsd->rx_size_511);
        i40e_stat_update48(hw, I40E_GLPRT_PRC1023H(hw->port),
                           I40E_GLPRT_PRC1023L(hw->port),
                           pf->stat_offsets_loaded,
                           &osd->rx_size_1023, &nsd->rx_size_1023);
        i40e_stat_update48(hw, I40E_GLPRT_PRC1522H(hw->port),
                           I40E_GLPRT_PRC1522L(hw->port),
                           pf->stat_offsets_loaded,
                           &osd->rx_size_1522, &nsd->rx_size_1522);
        i40e_stat_update48(hw, I40E_GLPRT_PRC9522H(hw->port),
                           I40E_GLPRT_PRC9522L(hw->port),
                           pf->stat_offsets_loaded,
                           &osd->rx_size_big, &nsd->rx_size_big);

        i40e_stat_update48(hw, I40E_GLPRT_PTC64H(hw->port),

                           I40E_GLPRT_PTC64L(hw->port),
                           pf->stat_offsets_loaded,
                           &osd->tx_size_64, &nsd->tx_size_64);
        i40e_stat_update48(hw, I40E_GLPRT_PTC127H(hw->port),
                           I40E_GLPRT_PTC127L(hw->port),
                           pf->stat_offsets_loaded,
                           &osd->tx_size_127, &nsd->tx_size_127);
        i40e_stat_update48(hw, I40E_GLPRT_PTC255H(hw->port),
                           I40E_GLPRT_PTC255L(hw->port),
                           pf->stat_offsets_loaded,
                           &osd->tx_size_255, &nsd->tx_size_255);
        i40e_stat_update48(hw, I40E_GLPRT_PTC511H(hw->port),
                           I40E_GLPRT_PTC511L(hw->port),
                           pf->stat_offsets_loaded,
                           &osd->tx_size_511, &nsd->tx_size_511);
        i40e_stat_update48(hw, I40E_GLPRT_PTC1023H(hw->port),
                           I40E_GLPRT_PTC1023L(hw->port),
                           pf->stat_offsets_loaded,
                           &osd->tx_size_1023, &nsd->tx_size_1023);
        i40e_stat_update48(hw, I40E_GLPRT_PTC1522H(hw->port),
                           I40E_GLPRT_PTC1522L(hw->port),
                           pf->stat_offsets_loaded,
                           &osd->tx_size_1522, &nsd->tx_size_1522);
        i40e_stat_update48(hw, I40E_GLPRT_PTC9522H(hw->port),
                           I40E_GLPRT_PTC9522L(hw->port),
                           pf->stat_offsets_loaded,
                           &osd->tx_size_big, &nsd->tx_size_big);

        i40e_stat_update32(hw, I40E_GLPRT_RUC(hw->port),
                           pf->stat_offsets_loaded,
                           &osd->rx_undersize, &nsd->rx_undersize);
        i40e_stat_update32(hw, I40E_GLPRT_RFC(hw->port),
                           pf->stat_offsets_loaded,
                           &osd->rx_fragments, &nsd->rx_fragments);
        i40e_stat_update32(hw, I40E_GLPRT_ROC(hw->port),
                           pf->stat_offsets_loaded,
                           &osd->rx_oversize, &nsd->rx_oversize);
        i40e_stat_update32(hw, I40E_GLPRT_RJC(hw->port),
                           pf->stat_offsets_loaded,
                           &osd->rx_jabber, &nsd->rx_jabber);

        /* FDIR stats */
        i40e_stat_update32(hw,
                           I40E_GLQF_PCNT(I40E_FD_ATR_STAT_IDX(pf->hw.pf_id)),
                           pf->stat_offsets_loaded,
                           &osd->fd_atr_match, &nsd->fd_atr_match);
        i40e_stat_update32(hw,
                           I40E_GLQF_PCNT(I40E_FD_SB_STAT_IDX(pf->hw.pf_id)),
                           pf->stat_offsets_loaded,
                           &osd->fd_sb_match, &nsd->fd_sb_match);
        i40e_stat_update32(hw,
                      I40E_GLQF_PCNT(I40E_FD_ATR_TUNNEL_STAT_IDX(pf->hw.pf_id)),
                      pf->stat_offsets_loaded,
                      &osd->fd_atr_tunnel_match, &nsd->fd_atr_tunnel_match);

        val = rd32(hw, I40E_PRTPM_EEE_STAT);
        nsd->tx_lpi_status =
                       (val & I40E_PRTPM_EEE_STAT_TX_LPI_STATUS_MASK) >>
                        I40E_PRTPM_EEE_STAT_TX_LPI_STATUS_SHIFT;
        nsd->rx_lpi_status =
                       (val & I40E_PRTPM_EEE_STAT_RX_LPI_STATUS_MASK) >>
                        I40E_PRTPM_EEE_STAT_RX_LPI_STATUS_SHIFT;
        i40e_stat_update32(hw, I40E_PRTPM_TLPIC,
                           pf->stat_offsets_loaded,
                           &osd->tx_lpi_count, &nsd->tx_lpi_count);
        i40e_stat_update32(hw, I40E_PRTPM_RLPIC,
                           pf->stat_offsets_loaded,
                           &osd->rx_lpi_count, &nsd->rx_lpi_count);

        if (pf->flags & I40E_FLAG_FD_SB_ENABLED &&
            !(pf->flags & I40E_FLAG_FD_SB_AUTO_DISABLED))
                nsd->fd_sb_status = true;
        else
                nsd->fd_sb_status = false;

        if (pf->flags & I40E_FLAG_FD_ATR_ENABLED &&
            !(pf->flags & I40E_FLAG_FD_ATR_AUTO_DISABLED))
                nsd->fd_atr_status = true;
        else
                nsd->fd_atr_status = false;

        pf->stat_offsets_loaded = true;
}

/**
 * i40e_update_stats - Update the various statistics counters.
 * @vsi: the VSI to be updated
 *
 * Update the various stats for this VSI and its related entities.
 **/
void i40e_update_stats(struct i40e_vsi *vsi)
{
        struct i40e_pf *pf = vsi->back;

        if (vsi == pf->vsi[pf->lan_vsi])
                i40e_update_pf_stats(pf);

        i40e_update_vsi_stats(vsi);
}

/**
 * i40e_find_filter - Search VSI filter list for specific mac/vlan filter
 * @vsi: the VSI to be searched
 * @macaddr: the MAC address
 * @vlan: the vlan
 *
 * Returns ptr to the filter object or NULL
 **/
static struct i40e_mac_filter *i40e_find_filter(struct i40e_vsi *vsi,
                                                const u8 *macaddr, s16 vlan)
{
        struct i40e_mac_filter *f;
        u64 key;

        if (!vsi || !macaddr)
                return NULL;

        key = i40e_addr_to_hkey(macaddr);
        hash_for_each_possible(vsi->mac_filter_hash, f, hlist, key) {
                if ((ether_addr_equal(macaddr, f->macaddr)) &&
                    (vlan == f->vlan))
                        return f;
        }
        return NULL;
}

/**
 * i40e_find_mac - Find a mac addr in the macvlan filters list
 * @vsi: the VSI to be searched
 * @macaddr: the MAC address we are searching for
 *
 * Returns the first filter with the provided MAC address or NULL if
 * MAC address was not found
 **/
struct i40e_mac_filter *i40e_find_mac(struct i40e_vsi *vsi, const u8 *macaddr)
{
        struct i40e_mac_filter *f;
        u64 key;

        if (!vsi || !macaddr)
                return NULL;

        key = i40e_addr_to_hkey(macaddr);
        hash_for_each_possible(vsi->mac_filter_hash, f, hlist, key) {
                if ((ether_addr_equal(macaddr, f->macaddr)))
                        return f;
        }
        return NULL;
}

/**
 * i40e_is_vsi_in_vlan - Check if VSI is in vlan mode
 * @vsi: the VSI to be searched
 *
 * Returns true if VSI is in vlan mode or false otherwise
 **/
bool i40e_is_vsi_in_vlan(struct i40e_vsi *vsi)
{
        /* If we have a PVID, always operate in VLAN mode */
        if (vsi->info.pvid)
                return true;

        /* We need to operate in VLAN mode whenever we have any filters with
         * a VLAN other than I40E_VLAN_ALL. We could check the table each
         * time, incurring search cost repeatedly. However, we can notice two
         * things:
         *
         * 1) the only place where we can gain a VLAN filter is in
         *    i40e_add_filter.
         *
         * 2) the only place where filters are actually removed is in
         *    i40e_sync_filters_subtask.
         *
         * Thus, we can simply use a boolean value, has_vlan_filters which we
         * will set to true when we add a VLAN filter in i40e_add_filter. Then
         * we have to perform the full search after deleting filters in
         * i40e_sync_filters_subtask, but we already have to search
         * filters here and can perform the check at the same time. This
         * results in avoiding embedding a loop for VLAN mode inside another
         * loop over all the filters, and should maintain correctness as noted
         * above.
         */
        return vsi->has_vlan_filter;
}

/**
 * i40e_correct_mac_vlan_filters - Correct non-VLAN filters if necessary
 * @vsi: the VSI to configure
 * @tmp_add_list: list of filters ready to be added
 * @tmp_del_list: list of filters ready to be deleted
 * @vlan_filters: the number of active VLAN filters
 *
 * Update VLAN=0 and VLAN=-1 (I40E_VLAN_ANY) filters properly so that they
 * behave as expected. If we have any active VLAN filters remaining or about
 * to be added then we need to update non-VLAN filters to be marked as VLAN=0
 * so that they only match against untagged traffic. If we no longer have any
 * active VLAN filters, we need to make all non-VLAN filters marked as VLAN=-1
 * so that they match against both tagged and untagged traffic. In this way,
 * we ensure that we correctly receive the desired traffic. This ensures that
 * when we have an active VLAN we will receive only untagged traffic and
 * traffic matching active VLANs. If we have no active VLANs then we will
 * operate in non-VLAN mode and receive all traffic, tagged or untagged.
 *
 * Finally, in a similar fashion, this function also corrects filters when
 * there is an active PVID assigned to this VSI.
 *
 * In case of memory allocation failure return -ENOMEM. Otherwise, return 0.
 *
 * This function is only expected to be called from within
 * i40e_sync_vsi_filters.
 *
 * NOTE: This function expects to be called while under the
 * mac_filter_hash_lock
 */
static int i40e_correct_mac_vlan_filters(struct i40e_vsi *vsi,
                                         struct hlist_head *tmp_add_list,
                                         struct hlist_head *tmp_del_list,
                                         int vlan_filters)
{
        s16 pvid = le16_to_cpu(vsi->info.pvid);
        struct i40e_mac_filter *f, *add_head;
        struct i40e_new_mac_filter *new;
        struct hlist_node *h;
        int bkt, new_vlan;

        /* To determine if a particular filter needs to be replaced we
         * have the three following conditions:
         *
         * a) if we have a PVID assigned, then all filters which are
         *    not marked as VLAN=PVID must be replaced with filters that
         *    are.
         * b) otherwise, if we have any active VLANS, all filters
         *    which are marked as VLAN=-1 must be replaced with
         *    filters marked as VLAN=0
         * c) finally, if we do not have any active VLANS, all filters
         *    which are marked as VLAN=0 must be replaced with filters
         *    marked as VLAN=-1
         */

        /* Update the filters about to be added in place */
        hlist_for_each_entry(new, tmp_add_list, hlist) {
                if (pvid && new->f->vlan != pvid)
                        new->f->vlan = pvid;
                else if (vlan_filters && new->f->vlan == I40E_VLAN_ANY)
                        new->f->vlan = 0;
                else if (!vlan_filters && new->f->vlan == 0)
                        new->f->vlan = I40E_VLAN_ANY;
        }

        /* Update the remaining active filters */
        hash_for_each_safe(vsi->mac_filter_hash, bkt, h, f, hlist) {
                /* Combine the checks for whether a filter needs to be changed
                 * and then determine the new VLAN inside the if block, in
                 * order to avoid duplicating code for adding the new filter
                 * then deleting the old filter.
                 */
                if ((pvid && f->vlan != pvid) ||
                    (vlan_filters && f->vlan == I40E_VLAN_ANY) ||
                    (!vlan_filters && f->vlan == 0)) {
                        /* Determine the new vlan we will be adding */
                        if (pvid)
                                new_vlan = pvid;
                        else if (vlan_filters)
                                new_vlan = 0;
                        else
                                new_vlan = I40E_VLAN_ANY;

                        /* Create the new filter */
                        add_head = i40e_add_filter(vsi, f->macaddr, new_vlan);
                        if (!add_head)
                                return -ENOMEM;

                        /* Create a temporary i40e_new_mac_filter */
                        new = kzalloc(sizeof(*new), GFP_ATOMIC);
                        if (!new)
                                return -ENOMEM;

                        new->f = add_head;
                        new->state = add_head->state;

                        /* Add the new filter to the tmp list */
                        hlist_add_head(&new->hlist, tmp_add_list);

                        /* Put the original filter into the delete list */
                        f->state = I40E_FILTER_REMOVE;
                        hash_del(&f->hlist);
                        hlist_add_head(&f->hlist, tmp_del_list);
                }
        }

        vsi->has_vlan_filter = !!vlan_filters;

        return 0;
}

/**
 * i40e_rm_default_mac_filter - Remove the default MAC filter set by NVM
 * @vsi: the PF Main VSI - inappropriate for any other VSI
 * @macaddr: the MAC address
 *
 * Remove whatever filter the firmware set up so the driver can manage
 * its own filtering intelligently.
 **/
static void i40e_rm_default_mac_filter(struct i40e_vsi *vsi, u8 *macaddr)
{
        struct i40e_aqc_remove_macvlan_element_data element;
        struct i40e_pf *pf = vsi->back;

        /* Only appropriate for the PF main VSI */
        if (vsi->type != I40E_VSI_MAIN)
                return;

        memset(&element, 0, sizeof(element));
        ether_addr_copy(element.mac_addr, macaddr);
        element.vlan_tag = 0;
        /* Ignore error returns, some firmware does it this way... */
        element.flags = I40E_AQC_MACVLAN_DEL_PERFECT_MATCH;
        i40e_aq_remove_macvlan(&pf->hw, vsi->seid, &element, 1, NULL);

        memset(&element, 0, sizeof(element));
        ether_addr_copy(element.mac_addr, macaddr);
        element.vlan_tag = 0;
        /* ...and some firmware does it this way. */
        element.flags = I40E_AQC_MACVLAN_DEL_PERFECT_MATCH |
                        I40E_AQC_MACVLAN_DEL_IGNORE_VLAN;
        i40e_aq_remove_macvlan(&pf->hw, vsi->seid, &element, 1, NULL);
}

/**
 * i40e_add_filter - Add a mac/vlan filter to the VSI
 * @vsi: the VSI to be searched
 * @macaddr: the MAC address
 * @vlan: the vlan
 *
 * Returns ptr to the filter object or NULL when no memory available.
 *
 * NOTE: This function is expected to be called with mac_filter_hash_lock
 * being held.
 **/
struct i40e_mac_filter *i40e_add_filter(struct i40e_vsi *vsi,
                                        const u8 *macaddr, s16 vlan)
{
        struct i40e_mac_filter *f;
        u64 key;

        if (!vsi || !macaddr)
                return NULL;

        f = i40e_find_filter(vsi, macaddr, vlan);
        if (!f) {
                f = kzalloc(sizeof(*f), GFP_ATOMIC);
                if (!f)
                        return NULL;

                /* Update the boolean indicating if we need to function in
                 * VLAN mode.
                 */
                if (vlan >= 0)
                        vsi->has_vlan_filter = true;

                ether_addr_copy(f->macaddr, macaddr);
                f->vlan = vlan;
                /* If we're in overflow promisc mode, set the state directly
                 * to failed, so we don't bother to try sending the filter
                 * to the hardware.
                 */
                if (test_bit(__I40E_VSI_OVERFLOW_PROMISC, vsi->state))
                        f->state = I40E_FILTER_FAILED;
                else
                        f->state = I40E_FILTER_NEW;
                INIT_HLIST_NODE(&f->hlist);

                key = i40e_addr_to_hkey(macaddr);
                hash_add(vsi->mac_filter_hash, &f->hlist, key);

                vsi->flags |= I40E_VSI_FLAG_FILTER_CHANGED;
                vsi->back->flags |= I40E_FLAG_FILTER_SYNC;
        }

        /* If we're asked to add a filter that has been marked for removal, it
         * is safe to simply restore it to active state. __i40e_del_filter
         * will have simply deleted any filters which were previously marked
         * NEW or FAILED, so if it is currently marked REMOVE it must have
         * previously been ACTIVE. Since we haven't yet run the sync filters
         * task, just restore this filter to the ACTIVE state so that the
         * sync task leaves it in place
         */
        if (f->state == I40E_FILTER_REMOVE)
                f->state = I40E_FILTER_ACTIVE;

        return f;
}

/**
 * __i40e_del_filter - Remove a specific filter from the VSI
 * @vsi: VSI to remove from
 * @f: the filter to remove from the list
 *
 * This function should be called instead of i40e_del_filter only if you know
 * the exact filter you will remove already, such as via i40e_find_filter or
 * i40e_find_mac.
 *
 * NOTE: This function is expected to be called with mac_filter_hash_lock
 * being held.
 * ANOTHER NOTE: This function MUST be called from within the context of
 * the "safe" variants of any list iterators, e.g. list_for_each_entry_safe()
 * instead of list_for_each_entry().
 **/
void __i40e_del_filter(struct i40e_vsi *vsi, struct i40e_mac_filter *f)
{
        if (!f)
                return;

        /* If the filter was never added to firmware then we can just delete it
         * directly and we don't want to set the status to remove or else an
         * admin queue command will unnecessarily fire.
         */
        if ((f->state == I40E_FILTER_FAILED) ||
            (f->state == I40E_FILTER_NEW)) {
                hash_del(&f->hlist);
                kfree(f);
        } else {
                f->state = I40E_FILTER_REMOVE;
        }

        vsi->flags |= I40E_VSI_FLAG_FILTER_CHANGED;
        vsi->back->flags |= I40E_FLAG_FILTER_SYNC;
}

/**
 * i40e_del_filter - Remove a MAC/VLAN filter from the VSI
 * @vsi: the VSI to be searched
 * @macaddr: the MAC address
 * @vlan: the VLAN
 *
 * NOTE: This function is expected to be called with mac_filter_hash_lock
 * being held.
 * ANOTHER NOTE: This function MUST be called from within the context of
 * the "safe" variants of any list iterators, e.g. list_for_each_entry_safe()
 * instead of list_for_each_entry().
 **/
void i40e_del_filter(struct i40e_vsi *vsi, const u8 *macaddr, s16 vlan)
{
        struct i40e_mac_filter *f;

        if (!vsi || !macaddr)
                return;

        f = i40e_find_filter(vsi, macaddr, vlan);
        __i40e_del_filter(vsi, f);
}

/**
 * i40e_add_mac_filter - Add a MAC filter for all active VLANs
 * @vsi: the VSI to be searched
 * @macaddr: the mac address to be filtered
 *
 * If we're not in VLAN mode, just add the filter to I40E_VLAN_ANY. Otherwise,
 * go through all the macvlan filters and add a macvlan filter for each
 * unique vlan that already exists. If a PVID has been assigned, instead only
 * add the macaddr to that VLAN.
 *
 * Returns last filter added on success, else NULL
 **/
struct i40e_mac_filter *i40e_add_mac_filter(struct i40e_vsi *vsi,
                                            const u8 *macaddr)
{
        struct i40e_mac_filter *f, *add = NULL;
        struct hlist_node *h;
        int bkt;

        if (vsi->info.pvid)
                return i40e_add_filter(vsi, macaddr,
                                       le16_to_cpu(vsi->info.pvid));

        if (!i40e_is_vsi_in_vlan(vsi))
                return i40e_add_filter(vsi, macaddr, I40E_VLAN_ANY);

        hash_for_each_safe(vsi->mac_filter_hash, bkt, h, f, hlist) {
                if (f->state == I40E_FILTER_REMOVE)
                        continue;
                add = i40e_add_filter(vsi, macaddr, f->vlan);
                if (!add)
                        return NULL;
        }

        return add;
}

/**
 * i40e_del_mac_filter - Remove a MAC filter from all VLANs
 * @vsi: the VSI to be searched
 * @macaddr: the mac address to be removed
 *
 * Removes a given MAC address from a VSI regardless of what VLAN it has been
 * associated with.
 *
 * Returns 0 for success, or error
 **/
int i40e_del_mac_filter(struct i40e_vsi *vsi, const u8 *macaddr)
{
        struct i40e_mac_filter *f;
        struct hlist_node *h;
        bool found = false;
        int bkt;

        WARN(!spin_is_locked(&vsi->mac_filter_hash_lock),
             "Missing mac_filter_hash_lock\n");
        hash_for_each_safe(vsi->mac_filter_hash, bkt, h, f, hlist) {
                if (ether_addr_equal(macaddr, f->macaddr)) {
                        __i40e_del_filter(vsi, f);
                        found = true;
                }
        }

        if (found)
                return 0;
        else
                return -ENOENT;
}

/**
 * i40e_set_mac - NDO callback to set mac address
 * @netdev: network interface device structure
 * @p: pointer to an address structure
 *
 * Returns 0 on success, negative on failure
 **/
static int i40e_set_mac(struct net_device *netdev, void *p)
{
        struct i40e_netdev_priv *np = netdev_priv(netdev);
        struct i40e_vsi *vsi = np->vsi;
        struct i40e_pf *pf = vsi->back;
        struct i40e_hw *hw = &pf->hw;
        struct sockaddr *addr = p;

        if (!is_valid_ether_addr(addr->sa_data))
                return -EADDRNOTAVAIL;

        if (ether_addr_equal(netdev->dev_addr, addr->sa_data)) {
                netdev_info(netdev, "already using mac address %pM\n",
                            addr->sa_data);
                return 0;
        }

        if (test_bit(__I40E_VSI_DOWN, vsi->back->state) ||
            test_bit(__I40E_RESET_RECOVERY_PENDING, vsi->back->state))
                return -EADDRNOTAVAIL;

        if (ether_addr_equal(hw->mac.addr, addr->sa_data))
                netdev_info(netdev, "returning to hw mac address %pM\n",
                            hw->mac.addr);
        else
                netdev_info(netdev, "set new mac address %pM\n", addr->sa_data);

        spin_lock_bh(&vsi->mac_filter_hash_lock);
        i40e_del_mac_filter(vsi, netdev->dev_addr);
        i40e_add_mac_filter(vsi, addr->sa_data);
        spin_unlock_bh(&vsi->mac_filter_hash_lock);
        ether_addr_copy(netdev->dev_addr, addr->sa_data);
        if (vsi->type == I40E_VSI_MAIN) {
                i40e_status ret;

                ret = i40e_aq_mac_address_write(&vsi->back->hw,
                                                I40E_AQC_WRITE_TYPE_LAA_WOL,
                                                addr->sa_data, NULL);
                if (ret)
                        netdev_info(netdev, "Ignoring error from firmware on LAA update, status %s, AQ ret %s\n",
                                    i40e_stat_str(hw, ret),
                                    i40e_aq_str(hw, hw->aq.asq_last_status));
        }

        /* schedule our worker thread which will take care of
         * applying the new filter changes
         */
        i40e_service_event_schedule(vsi->back);
        return 0;
}

/**
 * i40e_vsi_setup_queue_map - Setup a VSI queue map based on enabled_tc
 * @vsi: the VSI being setup
 * @ctxt: VSI context structure
 * @enabled_tc: Enabled TCs bitmap
 * @is_add: True if called before Add VSI
 *
 * Setup VSI queue mapping for enabled traffic classes.
 **/
static void i40e_vsi_setup_queue_map(struct i40e_vsi *vsi,
                                     struct i40e_vsi_context *ctxt,
                                     u8 enabled_tc,
                                     bool is_add)
{
        struct i40e_pf *pf = vsi->back;
        u16 sections = 0;
        u8 netdev_tc = 0;
        u16 numtc = 0;
        u16 qcount;
        u8 offset;
        u16 qmap;
        int i;
        u16 num_tc_qps = 0;

        sections = I40E_AQ_VSI_PROP_QUEUE_MAP_VALID;
        offset = 0;

        if (enabled_tc && (vsi->back->flags & I40E_FLAG_DCB_ENABLED)) {
                /* Find numtc from enabled TC bitmap */
                for (i = 0; i < I40E_MAX_TRAFFIC_CLASS; i++) {
                        if (enabled_tc & BIT(i)) /* TC is enabled */
                                numtc++;
                }
                if (!numtc) {
                        dev_warn(&pf->pdev->dev, "DCB is enabled but no TC enabled, forcing TC0\n");
                        numtc = 1;
                }
        } else {
                /* At least TC0 is enabled in case of non-DCB case */
                numtc = 1;
        }

        vsi->tc_config.numtc = numtc;
        vsi->tc_config.enabled_tc = enabled_tc ? enabled_tc : 1;
        /* Number of queues per enabled TC */
        qcount = vsi->alloc_queue_pairs;

        num_tc_qps = qcount / numtc;
        num_tc_qps = min_t(int, num_tc_qps, i40e_pf_get_max_q_per_tc(pf));

        /* Setup queue offset/count for all TCs for given VSI */
        for (i = 0; i < I40E_MAX_TRAFFIC_CLASS; i++) {
                /* See if the given TC is enabled for the given VSI */
                if (vsi->tc_config.enabled_tc & BIT(i)) {
                        /* TC is enabled */
                        int pow, num_qps;

                        switch (vsi->type) {
                        case I40E_VSI_MAIN:
                                qcount = min_t(int, pf->alloc_rss_size,
                                               num_tc_qps);
                                break;
                        case I40E_VSI_FDIR:
                        case I40E_VSI_SRIOV:
                        case I40E_VSI_VMDQ2:
                        default:
                                qcount = num_tc_qps;
                                WARN_ON(i != 0);
                                break;
                        }
                        vsi->tc_config.tc_info[i].qoffset = offset;
                        vsi->tc_config.tc_info[i].qcount = qcount;

                        /* find the next higher power-of-2 of num queue pairs */
                        num_qps = qcount;
                        pow = 0;
                        while (num_qps && (BIT_ULL(pow) < qcount)) {
                                pow++;
                                num_qps >>= 1;
                        }

                        vsi->tc_config.tc_info[i].netdev_tc = netdev_tc++;
                        qmap =
                            (offset << I40E_AQ_VSI_TC_QUE_OFFSET_SHIFT) |
                            (pow << I40E_AQ_VSI_TC_QUE_NUMBER_SHIFT);

                        offset += qcount;
                } else {
                        /* TC is not enabled so set the offset to
                         * default queue and allocate one queue
                         * for the given TC.
                         */
                        vsi->tc_config.tc_info[i].qoffset = 0;
                        vsi->tc_config.tc_info[i].qcount = 1;
                        vsi->tc_config.tc_info[i].netdev_tc = 0;

                        qmap = 0;
                }
                ctxt->info.tc_mapping[i] = cpu_to_le16(qmap);
        }

        /* Set actual Tx/Rx queue pairs */
        vsi->num_queue_pairs = offset;
        if ((vsi->type == I40E_VSI_MAIN) && (numtc == 1)) {
                if (vsi->req_queue_pairs > 0)
                        vsi->num_queue_pairs = vsi->req_queue_pairs;
                else if (pf->flags & I40E_FLAG_MSIX_ENABLED)
                        vsi->num_queue_pairs = pf->num_lan_msix;
        }

        /* Scheduler section valid can only be set for ADD VSI */
        if (is_add) {
                sections |= I40E_AQ_VSI_PROP_SCHED_VALID;

                ctxt->info.up_enable_bits = enabled_tc;
        }
        if (vsi->type == I40E_VSI_SRIOV) {
                ctxt->info.mapping_flags |=
                                     cpu_to_le16(I40E_AQ_VSI_QUE_MAP_NONCONTIG);
                for (i = 0; i < vsi->num_queue_pairs; i++)
                        ctxt->info.queue_mapping[i] =
                                               cpu_to_le16(vsi->base_queue + i);
        } else {
                ctxt->info.mapping_flags |=
                                        cpu_to_le16(I40E_AQ_VSI_QUE_MAP_CONTIG);
                ctxt->info.queue_mapping[0] = cpu_to_le16(vsi->base_queue);
        }
        ctxt->info.valid_sections |= cpu_to_le16(sections);
}

/**
 * i40e_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 and guarantee to hold the hash lock.
 */
static int i40e_addr_sync(struct net_device *netdev, const u8 *addr)
{
        struct i40e_netdev_priv *np = netdev_priv(netdev);
        struct i40e_vsi *vsi = np->vsi;

        if (i40e_add_mac_filter(vsi, addr))
                return 0;
        else
                return -ENOMEM;
}

/**
 * i40e_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 removed. We call
 * __dev_(uc|mc)_sync from .set_rx_mode and guarantee to hold the hash lock.
 */
static int i40e_addr_unsync(struct net_device *netdev, const u8 *addr)
{
        struct i40e_netdev_priv *np = netdev_priv(netdev);
        struct i40e_vsi *vsi = np->vsi;

        i40e_del_mac_filter(vsi, addr);

        return 0;
}

/**
 * i40e_set_rx_mode - NDO callback to set the netdev filters
 * @netdev: network interface device structure
 **/
static void i40e_set_rx_mode(struct net_device *netdev)
{
        struct i40e_netdev_priv *np = netdev_priv(netdev);
        struct i40e_vsi *vsi = np->vsi;

        spin_lock_bh(&vsi->mac_filter_hash_lock);

        __dev_uc_sync(netdev, i40e_addr_sync, i40e_addr_unsync);
        __dev_mc_sync(netdev, i40e_addr_sync, i40e_addr_unsync);

        spin_unlock_bh(&vsi->mac_filter_hash_lock);

        /* check for other flag changes */
        if (vsi->current_netdev_flags != vsi->netdev->flags) {
                vsi->flags |= I40E_VSI_FLAG_FILTER_CHANGED;
                vsi->back->flags |= I40E_FLAG_FILTER_SYNC;
        }

        /* schedule our worker thread which will take care of
         * applying the new filter changes
         */
        i40e_service_event_schedule(vsi->back);
}

/**
 * i40e_undo_del_filter_entries - Undo the changes made to MAC filter entries
 * @vsi: Pointer to VSI struct
 * @from: Pointer to list which contains MAC filter entries - changes to
 *        those entries needs to be undone.
 *
 * MAC filter entries from this list were slated for deletion.
 **/
static void i40e_undo_del_filter_entries(struct i40e_vsi *vsi,
                                         struct hlist_head *from)
{
        struct i40e_mac_filter *f;
        struct hlist_node *h;

        hlist_for_each_entry_safe(f, h, from, hlist) {
                u64 key = i40e_addr_to_hkey(f->macaddr);

                /* Move the element back into MAC filter list*/
                hlist_del(&f->hlist);
                hash_add(vsi->mac_filter_hash, &f->hlist, key);
        }
}

/**
 * i40e_undo_add_filter_entries - Undo the changes made to MAC filter entries
 * @vsi: Pointer to vsi struct
 * @from: Pointer to list which contains MAC filter entries - changes to
 *        those entries needs to be undone.
 *
 * MAC filter entries from this list were slated for addition.
 **/
static void i40e_undo_add_filter_entries(struct i40e_vsi *vsi,
                                         struct hlist_head *from)
{
        struct i40e_new_mac_filter *new;
        struct hlist_node *h;

        hlist_for_each_entry_safe(new, h, from, hlist) {
                /* We can simply free the wrapper structure */
                hlist_del(&new->hlist);
                kfree(new);
        }
}

/**
 * i40e_next_entry - Get the next non-broadcast filter from a list
 * @next: pointer to filter in list
 *
 * Returns the next non-broadcast filter in the list. Required so that we
 * ignore broadcast filters within the list, since these are not handled via
 * the normal firmware update path.
 */
static
struct i40e_new_mac_filter *i40e_next_filter(struct i40e_new_mac_filter *next)
{
        hlist_for_each_entry_continue(next, hlist) {
                if (!is_broadcast_ether_addr(next->f->macaddr))
                        return next;
        }

        return NULL;
}

/**
 * i40e_update_filter_state - Update filter state based on return data
 * from firmware
 * @count: Number of filters added
 * @add_list: return data from fw
 * @head: pointer to first filter in current batch
 *
 * MAC filter entries from list were slated to be added to device. Returns
 * number of successful filters. Note that 0 does NOT mean success!
 **/
static int
i40e_update_filter_state(int count,
                         struct i40e_aqc_add_macvlan_element_data *add_list,
                         struct i40e_new_mac_filter *add_head)
{
        int retval = 0;
        int i;

        for (i = 0; i < count; i++) {
                /* Always check status of each filter. We don't need to check
                 * the firmware return status because we pre-set the filter
                 * status to I40E_AQC_MM_ERR_NO_RES when sending the filter
                 * request to the adminq. Thus, if it no longer matches then
                 * we know the filter is active.
                 */
                if (add_list[i].match_method == I40E_AQC_MM_ERR_NO_RES) {
                        add_head->state = I40E_FILTER_FAILED;
                } else {
                        add_head->state = I40E_FILTER_ACTIVE;
                        retval++;
                }

                add_head = i40e_next_filter(add_head);
                if (!add_head)
                        break;
        }

        return retval;
}

/**
 * i40e_aqc_del_filters - Request firmware to delete a set of filters
 * @vsi: ptr to the VSI
 * @vsi_name: name to display in messages
 * @list: the list of filters to send to firmware
 * @num_del: the number of filters to delete
 * @retval: Set to -EIO on failure to delete
 *
 * Send a request to firmware via AdminQ to delete a set of filters. Uses
 * *retval instead of a return value so that success does not force ret_val to
 * be set to 0. This ensures that a sequence of calls to this function
 * preserve the previous value of *retval on successful delete.
 */
static
void i40e_aqc_del_filters(struct i40e_vsi *vsi, const char *vsi_name,
                          struct i40e_aqc_remove_macvlan_element_data *list,
                          int num_del, int *retval)
{
        struct i40e_hw *hw = &vsi->back->hw;
        i40e_status aq_ret;
        int aq_err;

        aq_ret = i40e_aq_remove_macvlan(hw, vsi->seid, list, num_del, NULL);
        aq_err = hw->aq.asq_last_status;

        /* Explicitly ignore and do not report when firmware returns ENOENT */
        if (aq_ret && !(aq_err == I40E_AQ_RC_ENOENT)) {
                *retval = -EIO;
                dev_info(&vsi->back->pdev->dev,
                         "ignoring delete macvlan error on %s, err %s, aq_err %s\n",
                         vsi_name, i40e_stat_str(hw, aq_ret),
                         i40e_aq_str(hw, aq_err));
        }
}

/**
 * i40e_aqc_add_filters - Request firmware to add a set of filters
 * @vsi: ptr to the VSI
 * @vsi_name: name to display in messages
 * @list: the list of filters to send to firmware
 * @add_head: Position in the add hlist
 * @num_add: the number of filters to add
 * @promisc_change: set to true on exit if promiscuous mode was forced on
 *
 * Send a request to firmware via AdminQ to add a chunk of filters. Will set
 * promisc_changed to true if the firmware has run out of space for more
 * filters.
 */
static
void i40e_aqc_add_filters(struct i40e_vsi *vsi, const char *vsi_name,
                          struct i40e_aqc_add_macvlan_element_data *list,
                          struct i40e_new_mac_filter *add_head,
                          int num_add, bool *promisc_changed)
{
        struct i40e_hw *hw = &vsi->back->hw;
        int aq_err, fcnt;

        i40e_aq_add_macvlan(hw, vsi->seid, list, num_add, NULL);
        aq_err = hw->aq.asq_last_status;
        fcnt = i40e_update_filter_state(num_add, list, add_head);

        if (fcnt != num_add) {
                *promisc_changed = true;
                set_bit(__I40E_VSI_OVERFLOW_PROMISC, vsi->state);
                dev_warn(&vsi->back->pdev->dev,
                         "Error %s adding RX filters on %s, promiscuous mode forced on\n",
                         i40e_aq_str(hw, aq_err),
                         vsi_name);
        }
}

/**
 * i40e_aqc_broadcast_filter - Set promiscuous broadcast flags
 * @vsi: pointer to the VSI
 * @f: filter data
 *
 * This function sets or clears the promiscuous broadcast flags for VLAN
 * filters in order to properly receive broadcast frames. Assumes that only
 * broadcast filters are passed.
 *
 * Returns status indicating success or failure;
 **/
static i40e_status
i40e_aqc_broadcast_filter(struct i40e_vsi *vsi, const char *vsi_name,
                          struct i40e_mac_filter *f)
{
        bool enable = f->state == I40E_FILTER_NEW;
        struct i40e_hw *hw = &vsi->back->hw;
        i40e_status aq_ret;

        if (f->vlan == I40E_VLAN_ANY) {
                aq_ret = i40e_aq_set_vsi_broadcast(hw,
                                                   vsi->seid,
                                                   enable,
                                                   NULL);
        } else {
                aq_ret = i40e_aq_set_vsi_bc_promisc_on_vlan(hw,
                                                            vsi->seid,
                                                            enable,
                                                            f->vlan,
                                                            NULL);
        }

        if (aq_ret)
                dev_warn(&vsi->back->pdev->dev,
                         "Error %s setting broadcast promiscuous mode on %s\n",
                         i40e_aq_str(hw, hw->aq.asq_last_status),
                         vsi_name);

        return aq_ret;
}

/**
 * i40e_sync_vsi_filters - Update the VSI filter list to the HW
 * @vsi: ptr to the VSI
 *
 * Push any outstanding VSI filter changes through the AdminQ.
 *
 * Returns 0 or error value
 **/
int i40e_sync_vsi_filters(struct i40e_vsi *vsi)
{
        struct hlist_head tmp_add_list, tmp_del_list;

        struct i40e_mac_filter *f;
        struct i40e_new_mac_filter *new, *add_head = NULL;
        struct i40e_hw *hw = &vsi->back->hw;
        unsigned int failed_filters = 0;
        unsigned int vlan_filters = 0;
        bool promisc_changed = false;
        char vsi_name[16] = "PF";
        int filter_list_len = 0;
        i40e_status aq_ret = 0;
        u32 changed_flags = 0;
        struct hlist_node *h;
        struct i40e_pf *pf;
        int num_add = 0;
        int num_del = 0;
        int retval = 0;
        u16 cmd_flags;
        int list_size;
        int bkt;

        /* empty array typed pointers, kcalloc later */
        struct i40e_aqc_add_macvlan_element_data *add_list;
        struct i40e_aqc_remove_macvlan_element_data *del_list;

        while (test_and_set_bit(__I40E_VSI_SYNCING_FILTERS, vsi->state))
                usleep_range(1000, 2000);
        pf = vsi->back;

        if (vsi->netdev) {
                changed_flags = vsi->current_netdev_flags ^ vsi->netdev->flags;
                vsi->current_netdev_flags = vsi->netdev->flags;
        }

        INIT_HLIST_HEAD(&tmp_add_list);
        INIT_HLIST_HEAD(&tmp_del_list);

        if (vsi->type == I40E_VSI_SRIOV)
                snprintf(vsi_name, sizeof(vsi_name) - 1, "VF %d", vsi->vf_id);
        else if (vsi->type != I40E_VSI_MAIN)
                snprintf(vsi_name, sizeof(vsi_name) - 1, "vsi %d", vsi->seid);

        if (vsi->flags & I40E_VSI_FLAG_FILTER_CHANGED) {
                vsi->flags &= ~I40E_VSI_FLAG_FILTER_CHANGED;

                spin_lock_bh(&vsi->mac_filter_hash_lock);
                /* Create a list of filters to delete. */
                hash_for_each_safe(vsi->mac_filter_hash, bkt, h, f, hlist) {
                        if (f->state == I40E_FILTER_REMOVE) {
                                /* Move the element into temporary del_list */
                                hash_del(&f->hlist);
                                hlist_add_head(&f->hlist, &tmp_del_list);

                                /* Avoid counting removed filters */
                                continue;
                        }
                        if (f->state == I40E_FILTER_NEW) {
                                /* Create a temporary i40e_new_mac_filter */
                                new = kzalloc(sizeof(*new), GFP_ATOMIC);
                                if (!new)
                                        goto err_no_memory_locked;

                                /* Store pointer to the real filter */
                                new->f = f;
                                new->state = f->state;

                                /* Add it to the hash list */
                                hlist_add_head(&new->hlist, &tmp_add_list);
                        }

                        /* Count the number of active (current and new) VLAN
                         * filters we have now. Does not count filters which
                         * are marked for deletion.
                         */
                        if (f->vlan > 0)
                                vlan_filters++;
                }

                retval = i40e_correct_mac_vlan_filters(vsi,
                                                       &tmp_add_list,
                                                       &tmp_del_list,
                                                       vlan_filters);
                if (retval)
                        goto err_no_memory_locked;

                spin_unlock_bh(&vsi->mac_filter_hash_lock);
        }

        /* Now process 'del_list' outside the lock */
        if (!hlist_empty(&tmp_del_list)) {
                filter_list_len = hw->aq.asq_buf_size /
                            sizeof(struct i40e_aqc_remove_macvlan_element_data);
                list_size = filter_list_len *
                            sizeof(struct i40e_aqc_remove_macvlan_element_data);
                del_list = kzalloc(list_size, GFP_ATOMIC);
                if (!del_list)
                        goto err_no_memory;

                hlist_for_each_entry_safe(f, h, &tmp_del_list, hlist) {
                        cmd_flags = 0;

                        /* handle broadcast filters by updating the broadcast
                         * promiscuous flag and release filter list.
                         */
                        if (is_broadcast_ether_addr(f->macaddr)) {
                                i40e_aqc_broadcast_filter(vsi, vsi_name, f);

                                hlist_del(&f->hlist);
                                kfree(f);
                                continue;
                        }

                        /* add to delete list */
                        ether_addr_copy(del_list[num_del].mac_addr, f->macaddr);
                        if (f->vlan == I40E_VLAN_ANY) {
                                del_list[num_del].vlan_tag = 0;
                                cmd_flags |= I40E_AQC_MACVLAN_DEL_IGNORE_VLAN;
                        } else {
                                del_list[num_del].vlan_tag =
                                        cpu_to_le16((u16)(f->vlan));
                        }

                        cmd_flags |= I40E_AQC_MACVLAN_DEL_PERFECT_MATCH;
                        del_list[num_del].flags = cmd_flags;
                        num_del++;

                        /* flush a full buffer */
                        if (num_del == filter_list_len) {
                                i40e_aqc_del_filters(vsi, vsi_name, del_list,
                                                     num_del, &retval);
                                memset(del_list, 0, list_size);
                                num_del = 0;
                        }
                        /* Release memory for MAC filter entries which were
                         * synced up with HW.
                         */
                        hlist_del(&f->hlist);
                        kfree(f);
                }

                if (num_del) {
                        i40e_aqc_del_filters(vsi, vsi_name, del_list,
                                             num_del, &retval);
                }

                kfree(del_list);
                del_list = NULL;
        }

        if (!hlist_empty(&tmp_add_list)) {
                /* Do all the adds now. */
                filter_list_len = hw->aq.asq_buf_size /
                               sizeof(struct i40e_aqc_add_macvlan_element_data);
                list_size = filter_list_len *
                               sizeof(struct i40e_aqc_add_macvlan_element_data);
                add_list = kzalloc(list_size, GFP_ATOMIC);
                if (!add_list)
                        goto err_no_memory;

                num_add = 0;
                hlist_for_each_entry_safe(new, h, &tmp_add_list, hlist) {
                        if (test_bit(__I40E_VSI_OVERFLOW_PROMISC,
                                     vsi->state)) {
                                new->state = I40E_FILTER_FAILED;
                                continue;
                        }

                        /* handle broadcast filters by updating the broadcast
                         * promiscuous flag instead of adding a MAC filter.
                         */
                        if (is_broadcast_ether_addr(new->f->macaddr)) {
                                if (i40e_aqc_broadcast_filter(vsi, vsi_name,
                                                              new->f))
                                        new->state = I40E_FILTER_FAILED;
                                else
                                        new->state = I40E_FILTER_ACTIVE;
                                continue;
                        }

                        /* add to add array */
                        if (num_add == 0)
                                add_head = new;
                        cmd_flags = 0;
                        ether_addr_copy(add_list[num_add].mac_addr,
                                        new->f->macaddr);
                        if (new->f->vlan == I40E_VLAN_ANY) {
                                add_list[num_add].vlan_tag = 0;
                                cmd_flags |= I40E_AQC_MACVLAN_ADD_IGNORE_VLAN;
                        } else {
                                add_list[num_add].vlan_tag =
                                        cpu_to_le16((u16)(new->f->vlan));
                        }
                        add_list[num_add].queue_number = 0;
                        /* set invalid match method for later detection */
                        add_list[num_add].match_method = I40E_AQC_MM_ERR_NO_RES;
                        cmd_flags |= I40E_AQC_MACVLAN_ADD_PERFECT_MATCH;
                        add_list[num_add].flags = cpu_to_le16(cmd_flags);
                        num_add++;

                        /* flush a full buffer */
                        if (num_add == filter_list_len) {
                                i40e_aqc_add_filters(vsi, vsi_name, add_list,
                                                     add_head, num_add,
                                                     &promisc_changed);
                                memset(add_list, 0, list_size);
                                num_add = 0;
                        }
                }
                if (num_add) {
                        i40e_aqc_add_filters(vsi, vsi_name, add_list, add_head,
                                             num_add, &promisc_changed);
                }
                /* Now move all of the filters from the temp add list back to
                 * the VSI's list.
                 */
                spin_lock_bh(&vsi->mac_filter_hash_lock);
                hlist_for_each_entry_safe(new, h, &tmp_add_list, hlist) {
                        /* Only update the state if we're still NEW */
                        if (new->f->state == I40E_FILTER_NEW)
                                new->f->state = new->state;
                        hlist_del(&new->hlist);
                        kfree(new);
                }
                spin_unlock_bh(&vsi->mac_filter_hash_lock);
                kfree(add_list);
                add_list = NULL;
        }

        /* Determine the number of active and failed filters. */
        spin_lock_bh(&vsi->mac_filter_hash_lock);
        vsi->active_filters = 0;
        hash_for_each(vsi->mac_filter_hash, bkt, f, hlist) {
                if (f->state == I40E_FILTER_ACTIVE)
                        vsi->active_filters++;
                else if (f->state == I40E_FILTER_FAILED)
                        failed_filters++;
        }
        spin_unlock_bh(&vsi->mac_filter_hash_lock);

        /* If promiscuous mode has changed, we need to calculate a new
         * threshold for when we are safe to exit
         */
        if (promisc_changed)
                vsi->promisc_threshold = (vsi->active_filters * 3) / 4;

        /* Check if we are able to exit overflow promiscuous mode. We can
         * safely exit if we didn't just enter, we no longer have any failed
         * filters, and we have reduced filters below the threshold value.
         */
        if (test_bit(__I40E_VSI_OVERFLOW_PROMISC, vsi->state) &&
            !promisc_changed && !failed_filters &&
            (vsi->active_filters < vsi->promisc_threshold)) {
                dev_info(&pf->pdev->dev,
                         "filter logjam cleared on %s, leaving overflow promiscuous mode\n",
                         vsi_name);
                clear_bit(__I40E_VSI_OVERFLOW_PROMISC, vsi->state);
                promisc_changed = true;
                vsi->promisc_threshold = 0;
        }

        /* if the VF is not trusted do not do promisc */
        if ((vsi->type == I40E_VSI_SRIOV) && !pf->vf[vsi->vf_id].trusted) {
                clear_bit(__I40E_VSI_OVERFLOW_PROMISC, vsi->state);
                goto out;
        }

        /* check for changes in promiscuous modes */
        if (changed_flags & IFF_ALLMULTI) {
                bool cur_multipromisc;

                cur_multipromisc = !!(vsi->current_netdev_flags & IFF_ALLMULTI);
                aq_ret = i40e_aq_set_vsi_multicast_promiscuous(&vsi->back->hw,
                                                               vsi->seid,
                                                               cur_multipromisc,
                                                               NULL);
                if (aq_ret) {
                        retval = i40e_aq_rc_to_posix(aq_ret,
                                                     hw->aq.asq_last_status);
                        dev_info(&pf->pdev->dev,
                                 "set multi promisc failed on %s, err %s aq_err %s\n",
                                 vsi_name,
                                 i40e_stat_str(hw, aq_ret),
                                 i40e_aq_str(hw, hw->aq.asq_last_status));
                }
        }

        if ((changed_flags & IFF_PROMISC) || promisc_changed) {
                bool cur_promisc;

                cur_promisc = (!!(vsi->current_netdev_flags & IFF_PROMISC) ||
                               test_bit(__I40E_VSI_OVERFLOW_PROMISC,
                                        vsi->state));
                if ((vsi->type == I40E_VSI_MAIN) &&
                    (pf->lan_veb != I40E_NO_VEB) &&
                    !(pf->flags & I40E_FLAG_MFP_ENABLED)) {
                        /* set defport ON for Main VSI instead of true promisc
                         * this way we will get all unicast/multicast and VLAN
                         * promisc behavior but will not get VF or VMDq traffic
                         * replicated on the Main VSI.
                         */
                        if (pf->cur_promisc != cur_promisc) {
                                pf->cur_promisc = cur_promisc;
                                if (cur_promisc)
                                        aq_ret =
                                              i40e_aq_set_default_vsi(hw,
                                                                      vsi->seid,
                                                                      NULL);
                                else
                                        aq_ret =
                                            i40e_aq_clear_default_vsi(hw,
                                                                      vsi->seid,
                                                                      NULL);
                                if (aq_ret) {
                                        retval = i40e_aq_rc_to_posix(aq_ret,
                                                        hw->aq.asq_last_status);
                                        dev_info(&pf->pdev->dev,
                                                 "Set default VSI failed on %s, err %s, aq_err %s\n",
                                                 vsi_name,
                                                 i40e_stat_str(hw, aq_ret),
                                                 i40e_aq_str(hw,
                                                     hw->aq.asq_last_status));
                                }
                        }
                } else {
                        aq_ret = i40e_aq_set_vsi_unicast_promiscuous(
                                                          hw,
                                                          vsi->seid,
                                                          cur_promisc, NULL,
                                                          true);
                        if (aq_ret) {
                                retval =
                                i40e_aq_rc_to_posix(aq_ret,
                                                    hw->aq.asq_last_status);
                                dev_info(&pf->pdev->dev,
                                         "set unicast promisc failed on %s, err %s, aq_err %s\n",
                                         vsi_name,
                                         i40e_stat_str(hw, aq_ret),
                                         i40e_aq_str(hw,
                                                     hw->aq.asq_last_status));
                        }
                        aq_ret = i40e_aq_set_vsi_multicast_promiscuous(
                                                          hw,
                                                          vsi->seid,
                                                          cur_promisc, NULL);
                        if (aq_ret) {
                                retval =
                                i40e_aq_rc_to_posix(aq_ret,
                                                    hw->aq.asq_last_status);
                                dev_info(&pf->pdev->dev,
                                         "set multicast promisc failed on %s, err %s, aq_err %s\n",
                                         vsi_name,
                                         i40e_stat_str(hw, aq_ret),
                                         i40e_aq_str(hw,
                                                     hw->aq.asq_last_status));
                        }
                }
                aq_ret = i40e_aq_set_vsi_broadcast(&vsi->back->hw,
                                                   vsi->seid,
                                                   cur_promisc, NULL);
                if (aq_ret) {
                        retval = i40e_aq_rc_to_posix(aq_ret,
                                                     pf->hw.aq.asq_last_status);
                        dev_info(&pf->pdev->dev,
                                 "set brdcast promisc failed, err %s, aq_err %s\n",
                                         i40e_stat_str(hw, aq_ret),
                                         i40e_aq_str(hw,
                                                     hw->aq.asq_last_status));
                }
        }
out:
        /* if something went wrong then set the changed flag so we try again */
        if (retval)
                vsi->flags |= I40E_VSI_FLAG_FILTER_CHANGED;

        clear_bit(__I40E_VSI_SYNCING_FILTERS, vsi->state);
        return retval;

err_no_memory:
        /* Restore elements on the temporary add and delete lists */
        spin_lock_bh(&vsi->mac_filter_hash_lock);
err_no_memory_locked:
        i40e_undo_del_filter_entries(vsi, &tmp_del_list);
        i40e_undo_add_filter_entries(vsi, &tmp_add_list);
        spin_unlock_bh(&vsi->mac_filter_hash_lock);

        vsi->flags |= I40E_VSI_FLAG_FILTER_CHANGED;
        clear_bit(__I40E_VSI_SYNCING_FILTERS, vsi->state);
        return -ENOMEM;
}

/**
 * i40e_sync_filters_subtask - Sync the VSI filter list with HW
 * @pf: board private structure
 **/
static void i40e_sync_filters_subtask(struct i40e_pf *pf)
{
        int v;

        if (!pf || !(pf->flags & I40E_FLAG_FILTER_SYNC))
                return;
        pf->flags &= ~I40E_FLAG_FILTER_SYNC;

        for (v = 0; v < pf->num_alloc_vsi; v++) {
                if (pf->vsi[v] &&
                    (pf->vsi[v]->flags & I40E_VSI_FLAG_FILTER_CHANGED)) {
                        int ret = i40e_sync_vsi_filters(pf->vsi[v]);

                        if (ret) {
                                /* come back and try again later */
                                pf->flags |= I40E_FLAG_FILTER_SYNC;
                                break;
                        }
                }
        }
}

/**
 * i40e_max_xdp_frame_size - returns the maximum allowed frame size for XDP
 * @vsi: the vsi
 **/
static int i40e_max_xdp_frame_size(struct i40e_vsi *vsi)
{
        if (PAGE_SIZE >= 8192 || (vsi->back->flags & I40E_FLAG_LEGACY_RX))
                return I40E_RXBUFFER_2048;
        else
                return I40E_RXBUFFER_3072;
}

/**
 * i40e_change_mtu - NDO callback to change the Maximum Transfer Unit
 * @netdev: network interface device structure
 * @new_mtu: new value for maximum frame size
 *
 * Returns 0 on success, negative on failure
 **/
static int i40e_change_mtu(struct net_device *netdev, int new_mtu)
{
        struct i40e_netdev_priv *np = netdev_priv(netdev);
        struct i40e_vsi *vsi = np->vsi;
        struct i40e_pf *pf = vsi->back;

        if (i40e_enabled_xdp_vsi(vsi)) {
                int frame_size = new_mtu + ETH_HLEN + ETH_FCS_LEN + VLAN_HLEN;

                if (frame_size > i40e_max_xdp_frame_size(vsi))
                        return -EINVAL;
        }

        netdev_info(netdev, "changing MTU from %d to %d\n",
                    netdev->mtu, new_mtu);
        netdev->mtu = new_mtu;
        if (netif_running(netdev))
                i40e_vsi_reinit_locked(vsi);
        pf->flags |= (I40E_FLAG_SERVICE_CLIENT_REQUESTED |
                      I40E_FLAG_CLIENT_L2_CHANGE);
        return 0;
}

/**
 * i40e_ioctl - Access the hwtstamp interface
 * @netdev: network interface device structure
 * @ifr: interface request data
 * @cmd: ioctl command
 **/
int i40e_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
{
        struct i40e_netdev_priv *np = netdev_priv(netdev);
        struct i40e_pf *pf = np->vsi->back;

        switch (cmd) {
        case SIOCGHWTSTAMP:
                return i40e_ptp_get_ts_config(pf, ifr);
        case SIOCSHWTSTAMP:
                return i40e_ptp_set_ts_config(pf, ifr);
        default:
                return -EOPNOTSUPP;
        }
}

/**
 * i40e_vlan_stripping_enable - Turn on vlan stripping for the VSI
 * @vsi: the vsi being adjusted
 **/
void i40e_vlan_stripping_enable(struct i40e_vsi *vsi)
{
        struct i40e_vsi_context ctxt;
        i40e_status ret;

        if ((vsi->info.valid_sections &
             cpu_to_le16(I40E_AQ_VSI_PROP_VLAN_VALID)) &&
            ((vsi->info.port_vlan_flags & I40E_AQ_VSI_PVLAN_MODE_MASK) == 0))
                return;  /* already enabled */

        vsi->info.valid_sections = cpu_to_le16(I40E_AQ_VSI_PROP_VLAN_VALID);
        vsi->info.port_vlan_flags = I40E_AQ_VSI_PVLAN_MODE_ALL |
                                    I40E_AQ_VSI_PVLAN_EMOD_STR_BOTH;

        ctxt.seid = vsi->seid;
        ctxt.info = vsi->info;
        ret = i40e_aq_update_vsi_params(&vsi->back->hw, &ctxt, NULL);
        if (ret) {
                dev_info(&vsi->back->pdev->dev,
                         "update vlan stripping failed, err %s aq_err %s\n",
                         i40e_stat_str(&vsi->back->hw, ret),
                         i40e_aq_str(&vsi->back->hw,
                                     vsi->back->hw.aq.asq_last_status));
        }
}

/**
 * i40e_vlan_stripping_disable - Turn off vlan stripping for the VSI
 * @vsi: the vsi being adjusted
 **/
void i40e_vlan_stripping_disable(struct i40e_vsi *vsi)
{
        struct i40e_vsi_context ctxt;
        i40e_status ret;

        if ((vsi->info.valid_sections &
             cpu_to_le16(I40E_AQ_VSI_PROP_VLAN_VALID)) &&
            ((vsi->info.port_vlan_flags & I40E_AQ_VSI_PVLAN_EMOD_MASK) ==
             I40E_AQ_VSI_PVLAN_EMOD_MASK))
                return;  /* already disabled */

        vsi->info.valid_sections = cpu_to_le16(I40E_AQ_VSI_PROP_VLAN_VALID);
        vsi->info.port_vlan_flags = I40E_AQ_VSI_PVLAN_MODE_ALL |
                                    I40E_AQ_VSI_PVLAN_EMOD_NOTHING;

        ctxt.seid = vsi->seid;
        ctxt.info = vsi->info;
        ret = i40e_aq_update_vsi_params(&vsi->back->hw, &ctxt, NULL);
        if (ret) {
                dev_info(&vsi->back->pdev->dev,
                         "update vlan stripping failed, err %s aq_err %s\n",
                         i40e_stat_str(&vsi->back->hw, ret),
                         i40e_aq_str(&vsi->back->hw,
                                     vsi->back->hw.aq.asq_last_status));
        }
}

/**
 * i40e_vlan_rx_register - Setup or shutdown vlan offload
 * @netdev: network interface to be adjusted
 * @features: netdev features to test if VLAN offload is enabled or not
 **/
static void i40e_vlan_rx_register(struct net_device *netdev, u32 features)
{
        struct i40e_netdev_priv *np = netdev_priv(netdev);
        struct i40e_vsi *vsi = np->vsi;

        if (features & NETIF_F_HW_VLAN_CTAG_RX)
                i40e_vlan_stripping_enable(vsi);
        else
                i40e_vlan_stripping_disable(vsi);
}

/**
 * i40e_add_vlan_all_mac - Add a MAC/VLAN filter for each existing MAC address
 * @vsi: the vsi being configured
 * @vid: vlan id to be added (0 = untagged only , -1 = any)
 *
 * This is a helper function for adding a new MAC/VLAN filter with the
 * specified VLAN for each existing MAC address already in the hash table.
 * This function does *not* perform any accounting to update filters based on
 * VLAN mode.
 *
 * NOTE: this function expects to be called while under the
 * mac_filter_hash_lock
 **/
int i40e_add_vlan_all_mac(struct i40e_vsi *vsi, s16 vid)
{
        struct i40e_mac_filter *f, *add_f;
        struct hlist_node *h;
        int bkt;

        hash_for_each_safe(vsi->mac_filter_hash, bkt, h, f, hlist) {
                if (f->state == I40E_FILTER_REMOVE)
                        continue;
                add_f = i40e_add_filter(vsi, f->macaddr, vid);
                if (!add_f) {
                        dev_info(&vsi->back->pdev->dev,
                                 "Could not add vlan filter %d for %pM\n",
                                 vid, f->macaddr);
                        return -ENOMEM;
                }
        }

        return 0;
}

/**
 * i40e_vsi_add_vlan - Add VSI membership for given VLAN
 * @vsi: the VSI being configured
 * @vid: VLAN id to be added
 **/
int i40e_vsi_add_vlan(struct i40e_vsi *vsi, u16 vid)
{
        int err;

        if (!vid || vsi->info.pvid)
                return -EINVAL;

        /* Locked once because all functions invoked below iterates list*/
        spin_lock_bh(&vsi->mac_filter_hash_lock);
        err = i40e_add_vlan_all_mac(vsi, vid);
        spin_unlock_bh(&vsi->mac_filter_hash_lock);
        if (err)
                return err;

        /* schedule our worker thread which will take care of
         * applying the new filter changes
         */
        i40e_service_event_schedule(vsi->back);
        return 0;
}

/**
 * i40e_rm_vlan_all_mac - Remove MAC/VLAN pair for all MAC with the given VLAN
 * @vsi: the vsi being configured
 * @vid: vlan id to be removed (0 = untagged only , -1 = any)
 *
 * This function should be used to remove all VLAN filters which match the
 * given VID. It does not schedule the service event and does not take the
 * mac_filter_hash_lock so it may be combined with other operations under
 * a single invocation of the mac_filter_hash_lock.
 *
 * NOTE: this function expects to be called while under the
 * mac_filter_hash_lock
 */
void i40e_rm_vlan_all_mac(struct i40e_vsi *vsi, s16 vid)
{
        struct i40e_mac_filter *f;
        struct hlist_node *h;
        int bkt;

        hash_for_each_safe(vsi->mac_filter_hash, bkt, h, f, hlist) {
                if (f->vlan == vid)
                        __i40e_del_filter(vsi, f);
        }
}

/**
 * i40e_vsi_kill_vlan - Remove VSI membership for given VLAN
 * @vsi: the VSI being configured
 * @vid: VLAN id to be removed
 **/
void i40e_vsi_kill_vlan(struct i40e_vsi *vsi, u16 vid)
{
        if (!vid || vsi->info.pvid)
                return;

        spin_lock_bh(&vsi->mac_filter_hash_lock);
        i40e_rm_vlan_all_mac(vsi, vid);
        spin_unlock_bh(&vsi->mac_filter_hash_lock);

        /* schedule our worker thread which will take care of
         * applying the new filter changes
         */
        i40e_service_event_schedule(vsi->back);
}

/**
 * i40e_vlan_rx_add_vid - Add a vlan id filter to HW offload
 * @netdev: network interface to be adjusted
 * @vid: vlan id to be added
 *
 * net_device_ops implementation for adding vlan ids
 **/
static int i40e_vlan_rx_add_vid(struct net_device *netdev,
                                __always_unused __be16 proto, u16 vid)
{
        struct i40e_netdev_priv *np = netdev_priv(netdev);
        struct i40e_vsi *vsi = np->vsi;
        int ret = 0;

        if (vid >= VLAN_N_VID)
                return -EINVAL;

        /* If the network stack called us with vid = 0 then
         * it is asking to receive priority tagged packets with
         * vlan id 0.  Our HW receives them by default when configured
         * to receive untagged packets so there is no need to add an
         * extra filter for vlan 0 tagged packets.
         */
        if (vid)
                ret = i40e_vsi_add_vlan(vsi, vid);

        if (!ret)
                set_bit(vid, vsi->active_vlans);

        return ret;
}

/**
 * i40e_vlan_rx_kill_vid - Remove a vlan id filter from HW offload
 * @netdev: network interface to be adjusted
 * @vid: vlan id to be removed
 *
 * net_device_ops implementation for removing vlan ids
 **/
static int i40e_vlan_rx_kill_vid(struct net_device *netdev,
                                 __always_unused __be16 proto, u16 vid)
{
        struct i40e_netdev_priv *np = netdev_priv(netdev);
        struct i40e_vsi *vsi = np->vsi;

        /* return code is ignored as there is nothing a user
         * can do about failure to remove and a log message was
         * already printed from the other function
         */
        i40e_vsi_kill_vlan(vsi, vid);

        clear_bit(vid, vsi->active_vlans);

        return 0;
}

/**
 * i40e_macaddr_init - explicitly write the mac address filters
 *
 * @vsi: pointer to the vsi
 * @macaddr: the MAC address
 *
 * This is needed when the macaddr has been obtained by other
 * means than the default, e.g., from Open Firmware or IDPROM.
 * Returns 0 on success, negative on failure
 **/
static int i40e_macaddr_init(struct i40e_vsi *vsi, u8 *macaddr)
{
        int ret;
        struct i40e_aqc_add_macvlan_element_data element;

        ret = i40e_aq_mac_address_write(&vsi->back->hw,
                                        I40E_AQC_WRITE_TYPE_LAA_WOL,
                                        macaddr, NULL);
        if (ret) {
                dev_info(&vsi->back->pdev->dev,
                         "Addr change for VSI failed: %d\n", ret);
                return -EADDRNOTAVAIL;
        }

        memset(&element, 0, sizeof(element));
        ether_addr_copy(element.mac_addr, macaddr);
        element.flags = cpu_to_le16(I40E_AQC_MACVLAN_ADD_PERFECT_MATCH);
        ret = i40e_aq_add_macvlan(&vsi->back->hw, vsi->seid, &element, 1, NULL);
        if (ret) {
                dev_info(&vsi->back->pdev->dev,
                         "add filter failed err %s aq_err %s\n",
                         i40e_stat_str(&vsi->back->hw, ret),
                         i40e_aq_str(&vsi->back->hw,
                                     vsi->back->hw.aq.asq_last_status));
        }
        return ret;
}

/**
 * i40e_restore_vlan - Reinstate vlans when vsi/netdev comes back up
 * @vsi: the vsi being brought back up
 **/
static void i40e_restore_vlan(struct i40e_vsi *vsi)
{
        u16 vid;

        if (!vsi->netdev)
                return;

        i40e_vlan_rx_register(vsi->netdev, vsi->netdev->features);

        for_each_set_bit(vid, vsi->active_vlans, VLAN_N_VID)
                i40e_vlan_rx_add_vid(vsi->netdev, htons(ETH_P_8021Q),
                                     vid);
}

/**
 * i40e_vsi_add_pvid - Add pvid for the VSI
 * @vsi: the vsi being adjusted
 * @vid: the vlan id to set as a PVID
 **/
int i40e_vsi_add_pvid(struct i40e_vsi *vsi, u16 vid)
{
        struct i40e_vsi_context ctxt;
        i40e_status ret;

        vsi->info.valid_sections = cpu_to_le16(I40E_AQ_VSI_PROP_VLAN_VALID);
        vsi->info.pvid = cpu_to_le16(vid);
        vsi->info.port_vlan_flags = I40E_AQ_VSI_PVLAN_MODE_TAGGED |
                                    I40E_AQ_VSI_PVLAN_INSERT_PVID |
                                    I40E_AQ_VSI_PVLAN_EMOD_STR;

        ctxt.seid = vsi->seid;
        ctxt.info = vsi->info;
        ret = i40e_aq_update_vsi_params(&vsi->back->hw, &ctxt, NULL);
        if (ret) {
                dev_info(&vsi->back->pdev->dev,
                         "add pvid failed, err %s aq_err %s\n",
                         i40e_stat_str(&vsi->back->hw, ret),
                         i40e_aq_str(&vsi->back->hw,
                                     vsi->back->hw.aq.asq_last_status));
                return -ENOENT;
        }

        return 0;
}

/**
 * i40e_vsi_remove_pvid - Remove the pvid from the VSI
 * @vsi: the vsi being adjusted
 *
 * Just use the vlan_rx_register() service to put it back to normal
 **/
void i40e_vsi_remove_pvid(struct i40e_vsi *vsi)
{
        i40e_vlan_stripping_disable(vsi);

        vsi->info.pvid = 0;
}

/**
 * i40e_vsi_setup_tx_resources - Allocate VSI Tx queue resources
 * @vsi: ptr to the VSI
 *
 * If this function returns with an error, then it's possible one or
 * more of the rings is populated (while the rest are not).  It is the
 * callers duty to clean those orphaned rings.
 *
 * Return 0 on success, negative on failure
 **/
static int i40e_vsi_setup_tx_resources(struct i40e_vsi *vsi)
{
        int i, err = 0;

        for (i = 0; i < vsi->num_queue_pairs && !err; i++)
                err = i40e_setup_tx_descriptors(vsi->tx_rings[i]);

        if (!i40e_enabled_xdp_vsi(vsi))
                return err;

        for (i = 0; i < vsi->num_queue_pairs && !err; i++)
                err = i40e_setup_tx_descriptors(vsi->xdp_rings[i]);

        return err;
}

/**
 * i40e_vsi_free_tx_resources - Free Tx resources for VSI queues
 * @vsi: ptr to the VSI
 *
 * Free VSI's transmit software resources
 **/
static void i40e_vsi_free_tx_resources(struct i40e_vsi *vsi)
{
        int i;

        if (vsi->tx_rings) {
                for (i = 0; i < vsi->num_queue_pairs; i++)
                        if (vsi->tx_rings[i] && vsi->tx_rings[i]->desc)
                                i40e_free_tx_resources(vsi->tx_rings[i]);
        }

        if (vsi->xdp_rings) {
                for (i = 0; i < vsi->num_queue_pairs; i++)
                        if (vsi->xdp_rings[i] && vsi->xdp_rings[i]->desc)
                                i40e_free_tx_resources(vsi->xdp_rings[i]);
        }
}

/**
 * i40e_vsi_setup_rx_resources - Allocate VSI queues Rx resources
 * @vsi: ptr to the VSI
 *
 * If this function returns with an error, then it's possible one or
 * more of the rings is populated (while the rest are not).  It is the
 * callers duty to clean those orphaned rings.
 *
 * Return 0 on success, negative on failure
 **/
static int i40e_vsi_setup_rx_resources(struct i40e_vsi *vsi)
{
        int i, err = 0;

        for (i = 0; i < vsi->num_queue_pairs && !err; i++)
                err = i40e_setup_rx_descriptors(vsi->rx_rings[i]);
        return err;
}

/**
 * i40e_vsi_free_rx_resources - Free Rx Resources for VSI queues
 * @vsi: ptr to the VSI
 *
 * Free all receive software resources
 **/
static void i40e_vsi_free_rx_resources(struct i40e_vsi *vsi)
{
        int i;

        if (!vsi->rx_rings)
                return;

        for (i = 0; i < vsi->num_queue_pairs; i++)
                if (vsi->rx_rings[i] && vsi->rx_rings[i]->desc)
                        i40e_free_rx_resources(vsi->rx_rings[i]);
}

/**
 * i40e_config_xps_tx_ring - Configure XPS for a Tx ring
 * @ring: The Tx ring to configure
 *
 * This enables/disables XPS for a given Tx descriptor ring
 * based on the TCs enabled for the VSI that ring belongs to.
 **/
static void i40e_config_xps_tx_ring(struct i40e_ring *ring)
{
        struct i40e_vsi *vsi = ring->vsi;
        cpumask_var_t mask;

        if (!ring->q_vector || !ring->netdev)
                return;

        /* Single TC mode enable XPS */
        if (vsi->tc_config.numtc <= 1) {
                if (!test_and_set_bit(__I40E_TX_XPS_INIT_DONE, &ring->state))
                        netif_set_xps_queue(ring->netdev,
                                            &ring->q_vector->affinity_mask,
                                            ring->queue_index);
        } else if (alloc_cpumask_var(&mask, GFP_KERNEL)) {
                /* Disable XPS to allow selection based on TC */
                bitmap_zero(cpumask_bits(mask), nr_cpumask_bits);
                netif_set_xps_queue(ring->netdev, mask, ring->queue_index);
                free_cpumask_var(mask);
        }

        /* schedule our worker thread which will take care of
         * applying the new filter changes
         */
        i40e_service_event_schedule(vsi->back);
}

/**
 * i40e_configure_tx_ring - Configure a transmit ring context and rest
 * @ring: The Tx ring to configure
 *
 * Configure the Tx descriptor ring in the HMC context.
 **/
static int i40e_configure_tx_ring(struct i40e_ring *ring)
{
        struct i40e_vsi *vsi = ring->vsi;
        u16 pf_q = vsi->base_queue + ring->queue_index;
        struct i40e_hw *hw = &vsi->back->hw;
        struct i40e_hmc_obj_txq tx_ctx;
        i40e_status err = 0;
        u32 qtx_ctl = 0;

        /* some ATR related tx ring init */
        if (vsi->back->flags & I40E_FLAG_FD_ATR_ENABLED) {
                ring->atr_sample_rate = vsi->back->atr_sample_rate;
                ring->atr_count = 0;
        } else {
                ring->atr_sample_rate = 0;
        }

        /* configure XPS */
        i40e_config_xps_tx_ring(ring);

        /* clear the context structure first */
        memset(&tx_ctx, 0, sizeof(tx_ctx));

        tx_ctx.new_context = 1;
        tx_ctx.base = (ring->dma / 128);
        tx_ctx.qlen = ring->count;
        tx_ctx.fd_ena = !!(vsi->back->flags & (I40E_FLAG_FD_SB_ENABLED |
                                               I40E_FLAG_FD_ATR_ENABLED));
        tx_ctx.timesync_ena = !!(vsi->back->flags & I40E_FLAG_PTP);
        /* FDIR VSI tx ring can still use RS bit and writebacks */
        if (vsi->type != I40E_VSI_FDIR)
                tx_ctx.head_wb_ena = 1;
        tx_ctx.head_wb_addr = ring->dma +
                              (ring->count * sizeof(struct i40e_tx_desc));

        /* As part of VSI creation/update, FW allocates certain
         * Tx arbitration queue sets for each TC enabled for
         * the VSI. The FW returns the handles to these queue
         * sets as part of the response buffer to Add VSI,
         * Update VSI, etc. AQ commands. It is expected that
         * these queue set handles be associated with the Tx
         * queues by the driver as part of the TX queue context
         * initialization. This has to be done regardless of
         * DCB as by default everything is mapped to TC0.
         */
        tx_ctx.rdylist = le16_to_cpu(vsi->info.qs_handle[ring->dcb_tc]);
        tx_ctx.rdylist_act = 0;

        /* clear the context in the HMC */
        err = i40e_clear_lan_tx_queue_context(hw, pf_q);
        if (err) {
                dev_info(&vsi->back->pdev->dev,
                         "Failed to clear LAN Tx queue context on Tx ring %d (pf_q %d), error: %d\n",
                         ring->queue_index, pf_q, err);
                return -ENOMEM;
        }

        /* set the context in the HMC */
        err = i40e_set_lan_tx_queue_context(hw, pf_q, &tx_ctx);