/*
 * Copyright (C) 2005 - 2016 Broadcom
 * All rights reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License version 2
 * as published by the Free Software Foundation.  The full GNU General
 * Public License is included in this distribution in the file called COPYING.
 *
 * Contact Information:
 * linux-drivers@emulex.com
 *
 * Emulex
 * 3333 Susan Street
 * Costa Mesa, CA 92626
 */

#include <linux/prefetch.h>
#include <linux/module.h>
#include "be.h"
#include "be_cmds.h"
#include <asm/div64.h>
#include <linux/aer.h>
#include <linux/if_bridge.h>
#include <net/busy_poll.h>
#include <net/vxlan.h>

MODULE_VERSION(DRV_VER);
MODULE_DESCRIPTION(DRV_DESC " " DRV_VER);
MODULE_AUTHOR("Emulex Corporation");
MODULE_LICENSE("GPL");

/* num_vfs module param is obsolete.
 * Use sysfs method to enable/disable VFs.
 */
static unsigned int num_vfs;
module_param(num_vfs, uint, S_IRUGO);
MODULE_PARM_DESC(num_vfs, "Number of PCI VFs to initialize");

static ushort rx_frag_size = 2048;
module_param(rx_frag_size, ushort, S_IRUGO);
MODULE_PARM_DESC(rx_frag_size, "Size of a fragment that holds rcvd data.");

/* Per-module error detection/recovery workq shared across all functions.
 * Each function schedules its own work request on this shared workq.
 */
static struct workqueue_struct *be_err_recovery_workq;

static const struct pci_device_id be_dev_ids[] = {
        { PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID1) },
        { PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID2) },
        { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID1) },
        { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID2) },
        { PCI_DEVICE(EMULEX_VENDOR_ID, OC_DEVICE_ID3)},
        { PCI_DEVICE(EMULEX_VENDOR_ID, OC_DEVICE_ID4)},
        { PCI_DEVICE(EMULEX_VENDOR_ID, OC_DEVICE_ID5)},
        { PCI_DEVICE(EMULEX_VENDOR_ID, OC_DEVICE_ID6)},
        { 0 }
};
MODULE_DEVICE_TABLE(pci, be_dev_ids);

/* Workqueue used by all functions for defering cmd calls to the adapter */
static struct workqueue_struct *be_wq;

/* UE Status Low CSR */
static const char * const ue_status_low_desc[] = {
        "CEV",
        "CTX",
        "DBUF",
        "ERX",
        "Host",
        "MPU",
        "NDMA",
        "PTC ",
        "RDMA ",
        "RXF ",
        "RXIPS ",
        "RXULP0 ",
        "RXULP1 ",
        "RXULP2 ",
        "TIM ",
        "TPOST ",
        "TPRE ",
        "TXIPS ",
        "TXULP0 ",
        "TXULP1 ",
        "UC ",
        "WDMA ",
        "TXULP2 ",
        "HOST1 ",
        "P0_OB_LINK ",
        "P1_OB_LINK ",
        "HOST_GPIO ",
        "MBOX ",
        "ERX2 ",
        "SPARE ",
        "JTAG ",
        "MPU_INTPEND "
};

/* UE Status High CSR */
static const char * const ue_status_hi_desc[] = {
        "LPCMEMHOST",
        "MGMT_MAC",
        "PCS0ONLINE",
        "MPU_IRAM",
        "PCS1ONLINE",
        "PCTL0",
        "PCTL1",
        "PMEM",
        "RR",
        "TXPB",
        "RXPP",
        "XAUI",
        "TXP",
        "ARM",
        "IPC",
        "HOST2",
        "HOST3",
        "HOST4",
        "HOST5",
        "HOST6",
        "HOST7",
        "ECRC",
        "Poison TLP",
        "NETC",
        "PERIPH",
        "LLTXULP",
        "D2P",
        "RCON",
        "LDMA",
        "LLTXP",
        "LLTXPB",
        "Unknown"
};

#define BE_VF_IF_EN_FLAGS       (BE_IF_FLAGS_UNTAGGED | \
                                 BE_IF_FLAGS_BROADCAST | \
                                 BE_IF_FLAGS_MULTICAST | \
                                 BE_IF_FLAGS_PASS_L3L4_ERRORS)

static void be_queue_free(struct be_adapter *adapter, struct be_queue_info *q)
{
        struct be_dma_mem *mem = &q->dma_mem;

        if (mem->va) {
                dma_free_coherent(&adapter->pdev->dev, mem->size, mem->va,
                                  mem->dma);
                mem->va = NULL;
        }
}

static int be_queue_alloc(struct be_adapter *adapter, struct be_queue_info *q,
                          u16 len, u16 entry_size)
{
        struct be_dma_mem *mem = &q->dma_mem;

        memset(q, 0, sizeof(*q));
        q->len = len;
        q->entry_size = entry_size;
        mem->size = len * entry_size;
        mem->va = dma_zalloc_coherent(&adapter->pdev->dev, mem->size, &mem->dma,
                                      GFP_KERNEL);
        if (!mem->va)
                return -ENOMEM;
        return 0;
}

static void be_reg_intr_set(struct be_adapter *adapter, bool enable)
{
        u32 reg, enabled;

        pci_read_config_dword(adapter->pdev, PCICFG_MEMBAR_CTRL_INT_CTRL_OFFSET,
                              &reg);
        enabled = reg & MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK;

        if (!enabled && enable)
                reg |= MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK;
        else if (enabled && !enable)
                reg &= ~MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK;
        else
                return;

        pci_write_config_dword(adapter->pdev,
                               PCICFG_MEMBAR_CTRL_INT_CTRL_OFFSET, reg);
}

static void be_intr_set(struct be_adapter *adapter, bool enable)
{
        int status = 0;

        /* On lancer interrupts can't be controlled via this register */
        if (lancer_chip(adapter))
                return;

        if (be_check_error(adapter, BE_ERROR_EEH))
                return;

        status = be_cmd_intr_set(adapter, enable);
        if (status)
                be_reg_intr_set(adapter, enable);
}

static void be_rxq_notify(struct be_adapter *adapter, u16 qid, u16 posted)
{
        u32 val = 0;

        if (be_check_error(adapter, BE_ERROR_HW))
                return;

        val |= qid & DB_RQ_RING_ID_MASK;
        val |= posted << DB_RQ_NUM_POSTED_SHIFT;

        wmb();
        iowrite32(val, adapter->db + DB_RQ_OFFSET);
}

static void be_txq_notify(struct be_adapter *adapter, struct be_tx_obj *txo,
                          u16 posted)
{
        u32 val = 0;

        if (be_check_error(adapter, BE_ERROR_HW))
                return;

        val |= txo->q.id & DB_TXULP_RING_ID_MASK;
        val |= (posted & DB_TXULP_NUM_POSTED_MASK) << DB_TXULP_NUM_POSTED_SHIFT;

        wmb();
        iowrite32(val, adapter->db + txo->db_offset);
}

static void be_eq_notify(struct be_adapter *adapter, u16 qid,
                         bool arm, bool clear_int, u16 num_popped,
                         u32 eq_delay_mult_enc)
{
        u32 val = 0;

        val |= qid & DB_EQ_RING_ID_MASK;
        val |= ((qid & DB_EQ_RING_ID_EXT_MASK) << DB_EQ_RING_ID_EXT_MASK_SHIFT);

        if (be_check_error(adapter, BE_ERROR_HW))
                return;

        if (arm)
                val |= 1 << DB_EQ_REARM_SHIFT;
        if (clear_int)
                val |= 1 << DB_EQ_CLR_SHIFT;
        val |= 1 << DB_EQ_EVNT_SHIFT;
        val |= num_popped << DB_EQ_NUM_POPPED_SHIFT;
        val |= eq_delay_mult_enc << DB_EQ_R2I_DLY_SHIFT;
        iowrite32(val, adapter->db + DB_EQ_OFFSET);
}

void be_cq_notify(struct be_adapter *adapter, u16 qid, bool arm, u16 num_popped)
{
        u32 val = 0;

        val |= qid & DB_CQ_RING_ID_MASK;
        val |= ((qid & DB_CQ_RING_ID_EXT_MASK) <<
                        DB_CQ_RING_ID_EXT_MASK_SHIFT);

        if (be_check_error(adapter, BE_ERROR_HW))
                return;

        if (arm)
                val |= 1 << DB_CQ_REARM_SHIFT;
        val |= num_popped << DB_CQ_NUM_POPPED_SHIFT;
        iowrite32(val, adapter->db + DB_CQ_OFFSET);
}

static int be_dev_mac_add(struct be_adapter *adapter, u8 *mac)
{
        int i;

        /* Check if mac has already been added as part of uc-list */
        for (i = 0; i < adapter->uc_macs; i++) {
                if (ether_addr_equal(adapter->uc_list[i].mac, mac)) {
                        /* mac already added, skip addition */
                        adapter->pmac_id[0] = adapter->pmac_id[i + 1];
                        return 0;
                }
        }

        return be_cmd_pmac_add(adapter, mac, adapter->if_handle,
                               &adapter->pmac_id[0], 0);
}

static void be_dev_mac_del(struct be_adapter *adapter, int pmac_id)
{
        int i;

        /* Skip deletion if the programmed mac is
         * being used in uc-list
         */
        for (i = 0; i < adapter->uc_macs; i++) {
                if (adapter->pmac_id[i + 1] == pmac_id)
                        return;
        }
        be_cmd_pmac_del(adapter, adapter->if_handle, pmac_id, 0);
}

static int be_mac_addr_set(struct net_device *netdev, void *p)
{
        struct be_adapter *adapter = netdev_priv(netdev);
        struct device *dev = &adapter->pdev->dev;
        struct sockaddr *addr = p;
        int status;
        u8 mac[ETH_ALEN];
        u32 old_pmac_id = adapter->pmac_id[0];

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

        /* Proceed further only if, User provided MAC is different
         * from active MAC
         */
        if (ether_addr_equal(addr->sa_data, adapter->dev_mac))
                return 0;

        /* BE3 VFs without FILTMGMT privilege are not allowed to set its MAC
         * address
         */
        if (BEx_chip(adapter) && be_virtfn(adapter) &&
            !check_privilege(adapter, BE_PRIV_FILTMGMT))
                return -EPERM;

        /* if device is not running, copy MAC to netdev->dev_addr */
        if (!netif_running(netdev))
                goto done;

        /* The PMAC_ADD cmd may fail if the VF doesn't have FILTMGMT
         * privilege or if PF did not provision the new MAC address.
         * On BE3, this cmd will always fail if the VF doesn't have the
         * FILTMGMT privilege. This failure is OK, only if the PF programmed
         * the MAC for the VF.
         */
        mutex_lock(&adapter->rx_filter_lock);
        status = be_dev_mac_add(adapter, (u8 *)addr->sa_data);
        if (!status) {

                /* Delete the old programmed MAC. This call may fail if the
                 * old MAC was already deleted by the PF driver.
                 */
                if (adapter->pmac_id[0] != old_pmac_id)
                        be_dev_mac_del(adapter, old_pmac_id);
        }

        mutex_unlock(&adapter->rx_filter_lock);
        /* Decide if the new MAC is successfully activated only after
         * querying the FW
         */
        status = be_cmd_get_active_mac(adapter, adapter->pmac_id[0], mac,
                                       adapter->if_handle, true, 0);
        if (status)
                goto err;

        /* The MAC change did not happen, either due to lack of privilege
         * or PF didn't pre-provision.
         */
        if (!ether_addr_equal(addr->sa_data, mac)) {
                status = -EPERM;
                goto err;
        }

        /* Remember currently programmed MAC */
        ether_addr_copy(adapter->dev_mac, addr->sa_data);
done:
        ether_addr_copy(netdev->dev_addr, addr->sa_data);
        dev_info(dev, "MAC address changed to %pM\n", addr->sa_data);
        return 0;
err:
        dev_warn(dev, "MAC address change to %pM failed\n", addr->sa_data);
        return status;
}

/* BE2 supports only v0 cmd */
static void *hw_stats_from_cmd(struct be_adapter *adapter)
{
        if (BE2_chip(adapter)) {
                struct be_cmd_resp_get_stats_v0 *cmd = adapter->stats_cmd.va;

                return &cmd->hw_stats;
        } else if (BE3_chip(adapter)) {
                struct be_cmd_resp_get_stats_v1 *cmd = adapter->stats_cmd.va;

                return &cmd->hw_stats;
        } else {
                struct be_cmd_resp_get_stats_v2 *cmd = adapter->stats_cmd.va;

                return &cmd->hw_stats;
        }
}

/* BE2 supports only v0 cmd */
static void *be_erx_stats_from_cmd(struct be_adapter *adapter)
{
        if (BE2_chip(adapter)) {
                struct be_hw_stats_v0 *hw_stats = hw_stats_from_cmd(adapter);

                return &hw_stats->erx;
        } else if (BE3_chip(adapter)) {
                struct be_hw_stats_v1 *hw_stats = hw_stats_from_cmd(adapter);

                return &hw_stats->erx;
        } else {
                struct be_hw_stats_v2 *hw_stats = hw_stats_from_cmd(adapter);

                return &hw_stats->erx;
        }
}

static void populate_be_v0_stats(struct be_adapter *adapter)
{
        struct be_hw_stats_v0 *hw_stats = hw_stats_from_cmd(adapter);
        struct be_pmem_stats *pmem_sts = &hw_stats->pmem;
        struct be_rxf_stats_v0 *rxf_stats = &hw_stats->rxf;
        struct be_port_rxf_stats_v0 *port_stats =
                                        &rxf_stats->port[adapter->port_num];
        struct be_drv_stats *drvs = &adapter->drv_stats;

        be_dws_le_to_cpu(hw_stats, sizeof(*hw_stats));
        drvs->rx_pause_frames = port_stats->rx_pause_frames;
        drvs->rx_crc_errors = port_stats->rx_crc_errors;
        drvs->rx_control_frames = port_stats->rx_control_frames;
        drvs->rx_in_range_errors = port_stats->rx_in_range_errors;
        drvs->rx_frame_too_long = port_stats->rx_frame_too_long;
        drvs->rx_dropped_runt = port_stats->rx_dropped_runt;
        drvs->rx_ip_checksum_errs = port_stats->rx_ip_checksum_errs;
        drvs->rx_tcp_checksum_errs = port_stats->rx_tcp_checksum_errs;
        drvs->rx_udp_checksum_errs = port_stats->rx_udp_checksum_errs;
        drvs->rxpp_fifo_overflow_drop = port_stats->rx_fifo_overflow;
        drvs->rx_dropped_tcp_length = port_stats->rx_dropped_tcp_length;
        drvs->rx_dropped_too_small = port_stats->rx_dropped_too_small;
        drvs->rx_dropped_too_short = port_stats->rx_dropped_too_short;
        drvs->rx_out_range_errors = port_stats->rx_out_range_errors;
        drvs->rx_input_fifo_overflow_drop = port_stats->rx_input_fifo_overflow;
        drvs->rx_dropped_header_too_small =
                port_stats->rx_dropped_header_too_small;
        drvs->rx_address_filtered =
                                        port_stats->rx_address_filtered +
                                        port_stats->rx_vlan_filtered;
        drvs->rx_alignment_symbol_errors =
                port_stats->rx_alignment_symbol_errors;

        drvs->tx_pauseframes = port_stats->tx_pauseframes;
        drvs->tx_controlframes = port_stats->tx_controlframes;

        if (adapter->port_num)
                drvs->jabber_events = rxf_stats->port1_jabber_events;
        else
                drvs->jabber_events = rxf_stats->port0_jabber_events;
        drvs->rx_drops_no_pbuf = rxf_stats->rx_drops_no_pbuf;
        drvs->rx_drops_no_erx_descr = rxf_stats->rx_drops_no_erx_descr;
        drvs->forwarded_packets = rxf_stats->forwarded_packets;
        drvs->rx_drops_mtu = rxf_stats->rx_drops_mtu;
        drvs->rx_drops_no_tpre_descr = rxf_stats->rx_drops_no_tpre_descr;
        drvs->rx_drops_too_many_frags = rxf_stats->rx_drops_too_many_frags;
        adapter->drv_stats.eth_red_drops = pmem_sts->eth_red_drops;
}

static void populate_be_v1_stats(struct be_adapter *adapter)
{
        struct be_hw_stats_v1 *hw_stats = hw_stats_from_cmd(adapter);
        struct be_pmem_stats *pmem_sts = &hw_stats->pmem;
        struct be_rxf_stats_v1 *rxf_stats = &hw_stats->rxf;
        struct be_port_rxf_stats_v1 *port_stats =
                                        &rxf_stats->port[adapter->port_num];
        struct be_drv_stats *drvs = &adapter->drv_stats;

        be_dws_le_to_cpu(hw_stats, sizeof(*hw_stats));
        drvs->pmem_fifo_overflow_drop = port_stats->pmem_fifo_overflow_drop;
        drvs->rx_priority_pause_frames = port_stats->rx_priority_pause_frames;
        drvs->rx_pause_frames = port_stats->rx_pause_frames;
        drvs->rx_crc_errors = port_stats->rx_crc_errors;
        drvs->rx_control_frames = port_stats->rx_control_frames;
        drvs->rx_in_range_errors = port_stats->rx_in_range_errors;
        drvs->rx_frame_too_long = port_stats->rx_frame_too_long;
        drvs->rx_dropped_runt = port_stats->rx_dropped_runt;
        drvs->rx_ip_checksum_errs = port_stats->rx_ip_checksum_errs;
        drvs->rx_tcp_checksum_errs = port_stats->rx_tcp_checksum_errs;
        drvs->rx_udp_checksum_errs = port_stats->rx_udp_checksum_errs;
        drvs->rx_dropped_tcp_length = port_stats->rx_dropped_tcp_length;
        drvs->rx_dropped_too_small = port_stats->rx_dropped_too_small;
        drvs->rx_dropped_too_short = port_stats->rx_dropped_too_short;
        drvs->rx_out_range_errors = port_stats->rx_out_range_errors;
        drvs->rx_dropped_header_too_small =
                port_stats->rx_dropped_header_too_small;
        drvs->rx_input_fifo_overflow_drop =
                port_stats->rx_input_fifo_overflow_drop;
        drvs->rx_address_filtered = port_stats->rx_address_filtered;
        drvs->rx_alignment_symbol_errors =
                port_stats->rx_alignment_symbol_errors;
        drvs->rxpp_fifo_overflow_drop = port_stats->rxpp_fifo_overflow_drop;
        drvs->tx_pauseframes = port_stats->tx_pauseframes;
        drvs->tx_controlframes = port_stats->tx_controlframes;
        drvs->tx_priority_pauseframes = port_stats->tx_priority_pauseframes;
        drvs->jabber_events = port_stats->jabber_events;
        drvs->rx_drops_no_pbuf = rxf_stats->rx_drops_no_pbuf;
        drvs->rx_drops_no_erx_descr = rxf_stats->rx_drops_no_erx_descr;
        drvs->forwarded_packets = rxf_stats->forwarded_packets;
        drvs->rx_drops_mtu = rxf_stats->rx_drops_mtu;
        drvs->rx_drops_no_tpre_descr = rxf_stats->rx_drops_no_tpre_descr;
        drvs->rx_drops_too_many_frags = rxf_stats->rx_drops_too_many_frags;
        adapter->drv_stats.eth_red_drops = pmem_sts->eth_red_drops;
}

static void populate_be_v2_stats(struct be_adapter *adapter)
{
        struct be_hw_stats_v2 *hw_stats = hw_stats_from_cmd(adapter);
        struct be_pmem_stats *pmem_sts = &hw_stats->pmem;
        struct be_rxf_stats_v2 *rxf_stats = &hw_stats->rxf;
        struct be_port_rxf_stats_v2 *port_stats =
                                        &rxf_stats->port[adapter->port_num];
        struct be_drv_stats *drvs = &adapter->drv_stats;

        be_dws_le_to_cpu(hw_stats, sizeof(*hw_stats));
        drvs->pmem_fifo_overflow_drop = port_stats->pmem_fifo_overflow_drop;
        drvs->rx_priority_pause_frames = port_stats->rx_priority_pause_frames;
        drvs->rx_pause_frames = port_stats->rx_pause_frames;
        drvs->rx_crc_errors = port_stats->rx_crc_errors;
        drvs->rx_control_frames = port_stats->rx_control_frames;
        drvs->rx_in_range_errors = port_stats->rx_in_range_errors;
        drvs->rx_frame_too_long = port_stats->rx_frame_too_long;
        drvs->rx_dropped_runt = port_stats->rx_dropped_runt;
        drvs->rx_ip_checksum_errs = port_stats->rx_ip_checksum_errs;
        drvs->rx_tcp_checksum_errs = port_stats->rx_tcp_checksum_errs;
        drvs->rx_udp_checksum_errs = port_stats->rx_udp_checksum_errs;
        drvs->rx_dropped_tcp_length = port_stats->rx_dropped_tcp_length;
        drvs->rx_dropped_too_small = port_stats->rx_dropped_too_small;
        drvs->rx_dropped_too_short = port_stats->rx_dropped_too_short;
        drvs->rx_out_range_errors = port_stats->rx_out_range_errors;
        drvs->rx_dropped_header_too_small =
                port_stats->rx_dropped_header_too_small;
        drvs->rx_input_fifo_overflow_drop =
                port_stats->rx_input_fifo_overflow_drop;
        drvs->rx_address_filtered = port_stats->rx_address_filtered;
        drvs->rx_alignment_symbol_errors =
                port_stats->rx_alignment_symbol_errors;
        drvs->rxpp_fifo_overflow_drop = port_stats->rxpp_fifo_overflow_drop;
        drvs->tx_pauseframes = port_stats->tx_pauseframes;
        drvs->tx_controlframes = port_stats->tx_controlframes;
        drvs->tx_priority_pauseframes = port_stats->tx_priority_pauseframes;
        drvs->jabber_events = port_stats->jabber_events;
        drvs->rx_drops_no_pbuf = rxf_stats->rx_drops_no_pbuf;
        drvs->rx_drops_no_erx_descr = rxf_stats->rx_drops_no_erx_descr;
        drvs->forwarded_packets = rxf_stats->forwarded_packets;
        drvs->rx_drops_mtu = rxf_stats->rx_drops_mtu;
        drvs->rx_drops_no_tpre_descr = rxf_stats->rx_drops_no_tpre_descr;
        drvs->rx_drops_too_many_frags = rxf_stats->rx_drops_too_many_frags;
        adapter->drv_stats.eth_red_drops = pmem_sts->eth_red_drops;
        if (be_roce_supported(adapter)) {
                drvs->rx_roce_bytes_lsd = port_stats->roce_bytes_received_lsd;
                drvs->rx_roce_bytes_msd = port_stats->roce_bytes_received_msd;
                drvs->rx_roce_frames = port_stats->roce_frames_received;
                drvs->roce_drops_crc = port_stats->roce_drops_crc;
                drvs->roce_drops_payload_len =
                        port_stats->roce_drops_payload_len;
        }
}

static void populate_lancer_stats(struct be_adapter *adapter)
{
        struct be_drv_stats *drvs = &adapter->drv_stats;
        struct lancer_pport_stats *pport_stats = pport_stats_from_cmd(adapter);

        be_dws_le_to_cpu(pport_stats, sizeof(*pport_stats));
        drvs->rx_pause_frames = pport_stats->rx_pause_frames_lo;
        drvs->rx_crc_errors = pport_stats->rx_crc_errors_lo;
        drvs->rx_control_frames = pport_stats->rx_control_frames_lo;
        drvs->rx_in_range_errors = pport_stats->rx_in_range_errors;
        drvs->rx_frame_too_long = pport_stats->rx_frames_too_long_lo;
        drvs->rx_dropped_runt = pport_stats->rx_dropped_runt;
        drvs->rx_ip_checksum_errs = pport_stats->rx_ip_checksum_errors;
        drvs->rx_tcp_checksum_errs = pport_stats->rx_tcp_checksum_errors;
        drvs->rx_udp_checksum_errs = pport_stats->rx_udp_checksum_errors;
        drvs->rx_dropped_tcp_length =
                                pport_stats->rx_dropped_invalid_tcp_length;
        drvs->rx_dropped_too_small = pport_stats->rx_dropped_too_small;
        drvs->rx_dropped_too_short = pport_stats->rx_dropped_too_short;
        drvs->rx_out_range_errors = pport_stats->rx_out_of_range_errors;
        drvs->rx_dropped_header_too_small =
                                pport_stats->rx_dropped_header_too_small;
        drvs->rx_input_fifo_overflow_drop = pport_stats->rx_fifo_overflow;
        drvs->rx_address_filtered =
                                        pport_stats->rx_address_filtered +
                                        pport_stats->rx_vlan_filtered;
        drvs->rx_alignment_symbol_errors = pport_stats->rx_symbol_errors_lo;
        drvs->rxpp_fifo_overflow_drop = pport_stats->rx_fifo_overflow;
        drvs->tx_pauseframes = pport_stats->tx_pause_frames_lo;
        drvs->tx_controlframes = pport_stats->tx_control_frames_lo;
        drvs->jabber_events = pport_stats->rx_jabbers;
        drvs->forwarded_packets = pport_stats->num_forwards_lo;
        drvs->rx_drops_mtu = pport_stats->rx_drops_mtu_lo;
        drvs->rx_drops_too_many_frags =
                                pport_stats->rx_drops_too_many_frags_lo;
}

static void accumulate_16bit_val(u32 *acc, u16 val)
{
#define lo(x)                   (x & 0xFFFF)
#define hi(x)                   (x & 0xFFFF0000)
        bool wrapped = val < lo(*acc);
        u32 newacc = hi(*acc) + val;

        if (wrapped)
                newacc += 65536;
        ACCESS_ONCE(*acc) = newacc;
}

static void populate_erx_stats(struct be_adapter *adapter,
                               struct be_rx_obj *rxo, u32 erx_stat)
{
        if (!BEx_chip(adapter))
                rx_stats(rxo)->rx_drops_no_frags = erx_stat;
        else
                /* below erx HW counter can actually wrap around after
                 * 65535. Driver accumulates a 32-bit value
                 */
                accumulate_16bit_val(&rx_stats(rxo)->rx_drops_no_frags,
                                     (u16)erx_stat);
}

void be_parse_stats(struct be_adapter *adapter)
{
        struct be_erx_stats_v2 *erx = be_erx_stats_from_cmd(adapter);
        struct be_rx_obj *rxo;
        int i;
        u32 erx_stat;

        if (lancer_chip(adapter)) {
                populate_lancer_stats(adapter);
        } else {
                if (BE2_chip(adapter))
                        populate_be_v0_stats(adapter);
                else if (BE3_chip(adapter))
                        /* for BE3 */
                        populate_be_v1_stats(adapter);
                else
                        populate_be_v2_stats(adapter);

                /* erx_v2 is longer than v0, v1. use v2 for v0, v1 access */
                for_all_rx_queues(adapter, rxo, i) {
                        erx_stat = erx->rx_drops_no_fragments[rxo->q.id];
                        populate_erx_stats(adapter, rxo, erx_stat);
                }
        }
}

static struct rtnl_link_stats64 *be_get_stats64(struct net_device *netdev,
                                                struct rtnl_link_stats64 *stats)
{
        struct be_adapter *adapter = netdev_priv(netdev);
        struct be_drv_stats *drvs = &adapter->drv_stats;
        struct be_rx_obj *rxo;
        struct be_tx_obj *txo;
        u64 pkts, bytes;
        unsigned int start;
        int i;

        for_all_rx_queues(adapter, rxo, i) {
                const struct be_rx_stats *rx_stats = rx_stats(rxo);

                do {
                        start = u64_stats_fetch_begin_irq(&rx_stats->sync);
                        pkts = rx_stats(rxo)->rx_pkts;
                        bytes = rx_stats(rxo)->rx_bytes;
                } while (u64_stats_fetch_retry_irq(&rx_stats->sync, start));
                stats->rx_packets += pkts;
                stats->rx_bytes += bytes;
                stats->multicast += rx_stats(rxo)->rx_mcast_pkts;
                stats->rx_dropped += rx_stats(rxo)->rx_drops_no_skbs +
                                        rx_stats(rxo)->rx_drops_no_frags;
        }

        for_all_tx_queues(adapter, txo, i) {
                const struct be_tx_stats *tx_stats = tx_stats(txo);

                do {
                        start = u64_stats_fetch_begin_irq(&tx_stats->sync);
                        pkts = tx_stats(txo)->tx_pkts;
                        bytes = tx_stats(txo)->tx_bytes;
                } while (u64_stats_fetch_retry_irq(&tx_stats->sync, start));
                stats->tx_packets += pkts;
                stats->tx_bytes += bytes;
        }

        /* bad pkts received */
        stats->rx_errors = drvs->rx_crc_errors +
                drvs->rx_alignment_symbol_errors +
                drvs->rx_in_range_errors +
                drvs->rx_out_range_errors +
                drvs->rx_frame_too_long +
                drvs->rx_dropped_too_small +
                drvs->rx_dropped_too_short +
                drvs->rx_dropped_header_too_small +
                drvs->rx_dropped_tcp_length +
                drvs->rx_dropped_runt;

        /* detailed rx errors */
        stats->rx_length_errors = drvs->rx_in_range_errors +
                drvs->rx_out_range_errors +
                drvs->rx_frame_too_long;

        stats->rx_crc_errors = drvs->rx_crc_errors;

        /* frame alignment errors */
        stats->rx_frame_errors = drvs->rx_alignment_symbol_errors;

        /* receiver fifo overrun */
        /* drops_no_pbuf is no per i/f, it's per BE card */
        stats->rx_fifo_errors = drvs->rxpp_fifo_overflow_drop +
                                drvs->rx_input_fifo_overflow_drop +
                                drvs->rx_drops_no_pbuf;
        return stats;
}

void be_link_status_update(struct be_adapter *adapter, u8 link_status)
{
        struct net_device *netdev = adapter->netdev;

        if (!(adapter->flags & BE_FLAGS_LINK_STATUS_INIT)) {
                netif_carrier_off(netdev);
                adapter->flags |= BE_FLAGS_LINK_STATUS_INIT;
        }

        if (link_status)
                netif_carrier_on(netdev);
        else
                netif_carrier_off(netdev);

        netdev_info(netdev, "Link is %s\n", link_status ? "Up" : "Down");
}

static int be_gso_hdr_len(struct sk_buff *skb)
{
        if (skb->encapsulation)
                return skb_inner_transport_offset(skb) +
                       inner_tcp_hdrlen(skb);
        return skb_transport_offset(skb) + tcp_hdrlen(skb);
}

static void be_tx_stats_update(struct be_tx_obj *txo, struct sk_buff *skb)
{
        struct be_tx_stats *stats = tx_stats(txo);
        u32 tx_pkts = skb_shinfo(skb)->gso_segs ? : 1;
        /* Account for headers which get duplicated in TSO pkt */
        u32 dup_hdr_len = tx_pkts > 1 ? be_gso_hdr_len(skb) * (tx_pkts - 1) : 0;

        u64_stats_update_begin(&stats->sync);
        stats->tx_reqs++;
        stats->tx_bytes += skb->len + dup_hdr_len;
        stats->tx_pkts += tx_pkts;
        if (skb->encapsulation && skb->ip_summed == CHECKSUM_PARTIAL)
                stats->tx_vxlan_offload_pkts += tx_pkts;
        u64_stats_update_end(&stats->sync);
}

/* Returns number of WRBs needed for the skb */
static u32 skb_wrb_cnt(struct sk_buff *skb)
{
        /* +1 for the header wrb */
        return 1 + (skb_headlen(skb) ? 1 : 0) + skb_shinfo(skb)->nr_frags;
}

static inline void wrb_fill(struct be_eth_wrb *wrb, u64 addr, int len)
{
        wrb->frag_pa_hi = cpu_to_le32(upper_32_bits(addr));
        wrb->frag_pa_lo = cpu_to_le32(lower_32_bits(addr));
        wrb->frag_len = cpu_to_le32(len & ETH_WRB_FRAG_LEN_MASK);
        wrb->rsvd0 = 0;
}

/* A dummy wrb is just all zeros. Using a separate routine for dummy-wrb
 * to avoid the swap and shift/mask operations in wrb_fill().
 */
static inline void wrb_fill_dummy(struct be_eth_wrb *wrb)
{
        wrb->frag_pa_hi = 0;
        wrb->frag_pa_lo = 0;
        wrb->frag_len = 0;
        wrb->rsvd0 = 0;
}

static inline u16 be_get_tx_vlan_tag(struct be_adapter *adapter,
                                     struct sk_buff *skb)
{
        u8 vlan_prio;
        u16 vlan_tag;

        vlan_tag = skb_vlan_tag_get(skb);
        vlan_prio = (vlan_tag & VLAN_PRIO_MASK) >> VLAN_PRIO_SHIFT;
        /* If vlan priority provided by OS is NOT in available bmap */
        if (!(adapter->vlan_prio_bmap & (1 << vlan_prio)))
                vlan_tag = (vlan_tag & ~VLAN_PRIO_MASK) |
                                adapter->recommended_prio_bits;

        return vlan_tag;
}

/* Used only for IP tunnel packets */
static u16 skb_inner_ip_proto(struct sk_buff *skb)
{
        return (inner_ip_hdr(skb)->version == 4) ?
                inner_ip_hdr(skb)->protocol : inner_ipv6_hdr(skb)->nexthdr;
}

static u16 skb_ip_proto(struct sk_buff *skb)
{
        return (ip_hdr(skb)->version == 4) ?
                ip_hdr(skb)->protocol : ipv6_hdr(skb)->nexthdr;
}

static inline bool be_is_txq_full(struct be_tx_obj *txo)
{
        return atomic_read(&txo->q.used) + BE_MAX_TX_FRAG_COUNT >= txo->q.len;
}

static inline bool be_can_txq_wake(struct be_tx_obj *txo)
{
        return atomic_read(&txo->q.used) < txo->q.len / 2;
}

static inline bool be_is_tx_compl_pending(struct be_tx_obj *txo)
{
        return atomic_read(&txo->q.used) > txo->pend_wrb_cnt;
}

static void be_get_wrb_params_from_skb(struct be_adapter *adapter,
                                       struct sk_buff *skb,
                                       struct be_wrb_params *wrb_params)
{
        u16 proto;

        if (skb_is_gso(skb)) {
                BE_WRB_F_SET(wrb_params->features, LSO, 1);
                wrb_params->lso_mss = skb_shinfo(skb)->gso_size;
                if (skb_is_gso_v6(skb) && !lancer_chip(adapter))
                        BE_WRB_F_SET(wrb_params->features, LSO6, 1);
        } else if (skb->ip_summed == CHECKSUM_PARTIAL) {
                if (skb->encapsulation) {
                        BE_WRB_F_SET(wrb_params->features, IPCS, 1);
                        proto = skb_inner_ip_proto(skb);
                } else {
                        proto = skb_ip_proto(skb);
                }
                if (proto == IPPROTO_TCP)
                        BE_WRB_F_SET(wrb_params->features, TCPCS, 1);
                else if (proto == IPPROTO_UDP)
                        BE_WRB_F_SET(wrb_params->features, UDPCS, 1);
        }

        if (skb_vlan_tag_present(skb)) {
                BE_WRB_F_SET(wrb_params->features, VLAN, 1);
                wrb_params->vlan_tag = be_get_tx_vlan_tag(adapter, skb);
        }

        BE_WRB_F_SET(wrb_params->features, CRC, 1);
}

static void wrb_fill_hdr(struct be_adapter *adapter,
                         struct be_eth_hdr_wrb *hdr,
                         struct be_wrb_params *wrb_params,
                         struct sk_buff *skb)
{
        memset(hdr, 0, sizeof(*hdr));

        SET_TX_WRB_HDR_BITS(crc, hdr,
                            BE_WRB_F_GET(wrb_params->features, CRC));
        SET_TX_WRB_HDR_BITS(ipcs, hdr,
                            BE_WRB_F_GET(wrb_params->features, IPCS));
        SET_TX_WRB_HDR_BITS(tcpcs, hdr,
                            BE_WRB_F_GET(wrb_params->features, TCPCS));
        SET_TX_WRB_HDR_BITS(udpcs, hdr,
                            BE_WRB_F_GET(wrb_params->features, UDPCS));

        SET_TX_WRB_HDR_BITS(lso, hdr,
                            BE_WRB_F_GET(wrb_params->features, LSO));
        SET_TX_WRB_HDR_BITS(lso6, hdr,
                            BE_WRB_F_GET(wrb_params->features, LSO6));
        SET_TX_WRB_HDR_BITS(lso_mss, hdr, wrb_params->lso_mss);

        /* Hack to skip HW VLAN tagging needs evt = 1, compl = 0. When this
         * hack is not needed, the evt bit is set while ringing DB.
         */
        SET_TX_WRB_HDR_BITS(event, hdr,
                            BE_WRB_F_GET(wrb_params->features, VLAN_SKIP_HW));
        SET_TX_WRB_HDR_BITS(vlan, hdr,
                            BE_WRB_F_GET(wrb_params->features, VLAN));
        SET_TX_WRB_HDR_BITS(vlan_tag, hdr, wrb_params->vlan_tag);

        SET_TX_WRB_HDR_BITS(num_wrb, hdr, skb_wrb_cnt(skb));
        SET_TX_WRB_HDR_BITS(len, hdr, skb->len);
        SET_TX_WRB_HDR_BITS(mgmt, hdr,
                            BE_WRB_F_GET(wrb_params->features, OS2BMC));
}

static void unmap_tx_frag(struct device *dev, struct be_eth_wrb *wrb,
                          bool unmap_single)
{
        dma_addr_t dma;
        u32 frag_len = le32_to_cpu(wrb->frag_len);


        dma = (u64)le32_to_cpu(wrb->frag_pa_hi) << 32 |
                (u64)le32_to_cpu(wrb->frag_pa_lo);
        if (frag_len) {
                if (unmap_single)
                        dma_unmap_single(dev, dma, frag_len, DMA_TO_DEVICE);
                else
                        dma_unmap_page(dev, dma, frag_len, DMA_TO_DEVICE);
        }
}

/* Grab a WRB header for xmit */
static u32 be_tx_get_wrb_hdr(struct be_tx_obj *txo)
{
        u32 head = txo->q.head;

        queue_head_inc(&txo->q);
        return head;
}

/* Set up the WRB header for xmit */
static void be_tx_setup_wrb_hdr(struct be_adapter *adapter,
                                struct be_tx_obj *txo,
                                struct be_wrb_params *wrb_params,
                                struct sk_buff *skb, u16 head)
{
        u32 num_frags = skb_wrb_cnt(skb);
        struct be_queue_info *txq = &txo->q;
        struct be_eth_hdr_wrb *hdr = queue_index_node(txq, head);

        wrb_fill_hdr(adapter, hdr, wrb_params, skb);
        be_dws_cpu_to_le(hdr, sizeof(*hdr));

        BUG_ON(txo->sent_skb_list[head]);
        txo->sent_skb_list[head] = skb;
        txo->last_req_hdr = head;
        atomic_add(num_frags, &txq->used);
        txo->last_req_wrb_cnt = num_frags;
        txo->pend_wrb_cnt += num_frags;
}

/* Setup a WRB fragment (buffer descriptor) for xmit */
static void be_tx_setup_wrb_frag(struct be_tx_obj *txo, dma_addr_t busaddr,
                                 int len)
{
        struct be_eth_wrb *wrb;
        struct be_queue_info *txq = &txo->q;

        wrb = queue_head_node(txq);
        wrb_fill(wrb, busaddr, len);
        queue_head_inc(txq);
}

/* Bring the queue back to the state it was in before be_xmit_enqueue() routine
 * was invoked. The producer index is restored to the previous packet and the
 * WRBs of the current packet are unmapped. Invoked to handle tx setup errors.
 */
static void be_xmit_restore(struct be_adapter *adapter,
                            struct be_tx_obj *txo, u32 head, bool map_single,
                            u32 copied)
{
        struct device *dev;
        struct be_eth_wrb *wrb;
        struct be_queue_info *txq = &txo->q;

        dev = &adapter->pdev->dev;
        txq->head = head;

        /* skip the first wrb (hdr); it's not mapped */
        queue_head_inc(txq);
        while (copied) {
                wrb = queue_head_node(txq);
                unmap_tx_frag(dev, wrb, map_single);
                map_single = false;
                copied -= le32_to_cpu(wrb->frag_len);
                queue_head_inc(txq);
        }

        txq->head = head;
}

/* Enqueue the given packet for transmit. This routine allocates WRBs for the
 * packet, dma maps the packet buffers and sets up the WRBs. Returns the number
 * of WRBs used up by the packet.
 */
static u32 be_xmit_enqueue(struct be_adapter *adapter, struct be_tx_obj *txo,
                           struct sk_buff *skb,
                           struct be_wrb_params *wrb_params)
{
        u32 i, copied = 0, wrb_cnt = skb_wrb_cnt(skb);
        struct device *dev = &adapter->pdev->dev;
        struct be_queue_info *txq = &txo->q;
        bool map_single = false;
        u32 head = txq->head;
        dma_addr_t busaddr;
        int len;

        head = be_tx_get_wrb_hdr(txo);

        if (skb->len > skb->data_len) {
                len = skb_headlen(skb);

                busaddr = dma_map_single(dev, skb->data, len, DMA_TO_DEVICE);
                if (dma_mapping_error(dev, busaddr))
                        goto dma_err;
                map_single = true;
                be_tx_setup_wrb_frag(txo, busaddr, len);
                copied += len;
        }

        for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
                const struct skb_frag_struct *frag = &skb_shinfo(skb)->frags[i];
                len = skb_frag_size(frag);

                busaddr = skb_frag_dma_map(dev, frag, 0, len, DMA_TO_DEVICE);
                if (dma_mapping_error(dev, busaddr))
                        goto dma_err;
                be_tx_setup_wrb_frag(txo, busaddr, len);
                copied += len;
        }

        be_tx_setup_wrb_hdr(adapter, txo, wrb_params, skb, head);

        be_tx_stats_update(txo, skb);
        return wrb_cnt;

dma_err:
        adapter->drv_stats.dma_map_errors++;
        be_xmit_restore(adapter, txo, head, map_single, copied);
        return 0;
}

static inline int qnq_async_evt_rcvd(struct be_adapter *adapter)
{
        return adapter->flags & BE_FLAGS_QNQ_ASYNC_EVT_RCVD;
}

static struct sk_buff *be_insert_vlan_in_pkt(struct be_adapter *adapter,
                                             struct sk_buff *skb,
                                             struct be_wrb_params
                                             *wrb_params)
{
        u16 vlan_tag = 0;

        skb = skb_share_check(skb, GFP_ATOMIC);
        if (unlikely(!skb))
                return skb;

        if (skb_vlan_tag_present(skb))
                vlan_tag = be_get_tx_vlan_tag(adapter, skb);

        if (qnq_async_evt_rcvd(adapter) && adapter->pvid) {
                if (!vlan_tag)
                        vlan_tag = adapter->pvid;
                /* f/w workaround to set skip_hw_vlan = 1, informs the F/W to
                 * skip VLAN insertion
                 */
                BE_WRB_F_SET(wrb_params->features, VLAN_SKIP_HW, 1);
        }

        if (vlan_tag) {
                skb = vlan_insert_tag_set_proto(skb, htons(ETH_P_8021Q),
                                                vlan_tag);
                if (unlikely(!skb))
                        return skb;
                skb->vlan_tci = 0;
        }

        /* Insert the outer VLAN, if any */
        if (adapter->qnq_vid) {
                vlan_tag = adapter->qnq_vid;
                skb = vlan_insert_tag_set_proto(skb, htons(ETH_P_8021Q),
                                                vlan_tag);
                if (unlikely(!skb))
                        return skb;
                BE_WRB_F_SET(wrb_params->features, VLAN_SKIP_HW, 1);
        }

        return skb;
}

static bool be_ipv6_exthdr_check(struct sk_buff *skb)
{
        struct ethhdr *eh = (struct ethhdr *)skb->data;
        u16 offset = ETH_HLEN;

        if (eh->h_proto == htons(ETH_P_IPV6)) {
                struct ipv6hdr *ip6h = (struct ipv6hdr *)(skb->data + offset);

                offset += sizeof(struct ipv6hdr);
                if (ip6h->nexthdr != NEXTHDR_TCP &&
                    ip6h->nexthdr != NEXTHDR_UDP) {
                        struct ipv6_opt_hdr *ehdr =
                                (struct ipv6_opt_hdr *)(skb->data + offset);

                        /* offending pkt: 2nd byte following IPv6 hdr is 0xff */
                        if (ehdr->hdrlen == 0xff)
                                return true;
                }
        }
        return false;
}

static int be_vlan_tag_tx_chk(struct be_adapter *adapter, struct sk_buff *skb)
{
        return skb_vlan_tag_present(skb) || adapter->pvid || adapter->qnq_vid;
}

static int be_ipv6_tx_stall_chk(struct be_adapter *adapter, struct sk_buff *skb)
{
        return BE3_chip(adapter) && be_ipv6_exthdr_check(skb);
}

static struct sk_buff *be_lancer_xmit_workarounds(struct be_adapter *adapter,
                                                  struct sk_buff *skb,
                                                  struct be_wrb_params
                                                  *wrb_params)
{
        struct vlan_ethhdr *veh = (struct vlan_ethhdr *)skb->data;
        unsigned int eth_hdr_len;
        struct iphdr *ip;

        /* For padded packets, BE HW modifies tot_len field in IP header
         * incorrecly when VLAN tag is inserted by HW.
         * For padded packets, Lancer computes incorrect checksum.
         */
        eth_hdr_len = ntohs(skb->protocol) == ETH_P_8021Q ?
                                                VLAN_ETH_HLEN : ETH_HLEN;
        if (skb->len <= 60 &&
            (lancer_chip(adapter) || skb_vlan_tag_present(skb)) &&
            is_ipv4_pkt(skb)) {
                ip = (struct iphdr *)ip_hdr(skb);
                pskb_trim(skb, eth_hdr_len + ntohs(ip->tot_len));
        }

        /* If vlan tag is already inlined in the packet, skip HW VLAN
         * tagging in pvid-tagging mode
         */
        if (be_pvid_tagging_enabled(adapter) &&
            veh->h_vlan_proto == htons(ETH_P_8021Q))
                BE_WRB_F_SET(wrb_params->features, VLAN_SKIP_HW, 1);

        /* HW has a bug wherein it will calculate CSUM for VLAN
         * pkts even though it is disabled.
         * Manually insert VLAN in pkt.
         */
        if (skb->ip_summed != CHECKSUM_PARTIAL &&
            skb_vlan_tag_present(skb)) {
                skb = be_insert_vlan_in_pkt(adapter, skb, wrb_params);
                if (unlikely(!skb))
                        goto err;
        }

        /* HW may lockup when VLAN HW tagging is requested on
         * certain ipv6 packets. Drop such pkts if the HW workaround to
         * skip HW tagging is not enabled by FW.
         */
        if (unlikely(be_ipv6_tx_stall_chk(adapter, skb) &&
                     (adapter->pvid || adapter->qnq_vid) &&
                     !qnq_async_evt_rcvd(adapter)))
                goto tx_drop;

        /* Manual VLAN tag insertion to prevent:
         * ASIC lockup when the ASIC inserts VLAN tag into
         * certain ipv6 packets. Insert VLAN tags in driver,
         * and set event, completion, vlan bits accordingly
         * in the Tx WRB.
         */
        if (be_ipv6_tx_stall_chk(adapter, skb) &&
            be_vlan_tag_tx_chk(adapter, skb)) {
                skb = be_insert_vlan_in_pkt(adapter, skb, wrb_params);
                if (unlikely(!skb))
                        goto err;
        }

        return skb;
tx_drop:
        dev_kfree_skb_any(skb);
err:
        return NULL;
}

static struct sk_buff *be_xmit_workarounds(struct be_adapter *adapter,
                                           struct sk_buff *skb,
                                           struct be_wrb_params *wrb_params)
{
        int err;

        /* Lancer, SH and BE3 in SRIOV mode have a bug wherein
         * packets that are 32b or less may cause a transmit stall
         * on that port. The workaround is to pad such packets
         * (len <= 32 bytes) to a minimum length of 36b.
         */
        if (skb->len <= 32) {
                if (skb_put_padto(skb, 36))
                        return NULL;
        }

        if (BEx_chip(adapter) || lancer_chip(adapter)) {
                skb = be_lancer_xmit_workarounds(adapter, skb, wrb_params);
                if (!skb)
                        return NULL;
        }

        /* The stack can send us skbs with length greater than
         * what the HW can handle. Trim the extra bytes.
         */
        WARN_ON_ONCE(skb->len > BE_MAX_GSO_SIZE);
        err = pskb_trim(skb, BE_MAX_GSO_SIZE);
        WARN_ON(err);

        return skb;
}

static void be_xmit_flush(struct be_adapter *adapter, struct be_tx_obj *txo)
{
        struct be_queue_info *txq = &txo->q;
        struct be_eth_hdr_wrb *hdr = queue_index_node(txq, txo->last_req_hdr);

        /* Mark the last request eventable if it hasn't been marked already */
        if (!(hdr->dw[2] & cpu_to_le32(TX_HDR_WRB_EVT)))
                hdr->dw[2] |= cpu_to_le32(TX_HDR_WRB_EVT | TX_HDR_WRB_COMPL);

        /* compose a dummy wrb if there are odd set of wrbs to notify */
        if (!lancer_chip(adapter) && (txo->pend_wrb_cnt & 1)) {
                wrb_fill_dummy(queue_head_node(txq));
                queue_head_inc(txq);
                atomic_inc(&txq->used);
                txo->pend_wrb_cnt++;
                hdr->dw[2] &= ~cpu_to_le32(TX_HDR_WRB_NUM_MASK <<
                                           TX_HDR_WRB_NUM_SHIFT);
                hdr->dw[2] |= cpu_to_le32((txo->last_req_wrb_cnt + 1) <<
                                          TX_HDR_WRB_NUM_SHIFT);
        }
        be_txq_notify(adapter, txo, txo->pend_wrb_cnt);
        txo->pend_wrb_cnt = 0;
}

/* OS2BMC related */

#define DHCP_CLIENT_PORT        68
#define DHCP_SERVER_PORT        67
#define NET_BIOS_PORT1          137
#define NET_BIOS_PORT2          138
#define DHCPV6_RAS_PORT         547

#define is_mc_allowed_on_bmc(adapter, eh)       \
        (!is_multicast_filt_enabled(adapter) && \
         is_multicast_ether_addr(eh->h_dest) && \
         !is_broadcast_ether_addr(eh->h_dest))

#define is_bc_allowed_on_bmc(adapter, eh)       \
        (!is_broadcast_filt_enabled(adapter) && \
         is_broadcast_ether_addr(eh->h_dest))

#define is_arp_allowed_on_bmc(adapter, skb)     \
        (is_arp(skb) && is_arp_filt_enabled(adapter))

#define is_broadcast_packet(eh, adapter)        \
                (is_multicast_ether_addr(eh->h_dest) && \
                !compare_ether_addr(eh->h_dest, adapter->netdev->broadcast))

#define is_arp(skb)     (skb->protocol == htons(ETH_P_ARP))

#define is_arp_filt_enabled(adapter)    \
                (adapter->bmc_filt_mask & (BMC_FILT_BROADCAST_ARP))

#define is_dhcp_client_filt_enabled(adapter)    \
                (adapter->bmc_filt_mask & BMC_FILT_BROADCAST_DHCP_CLIENT)

#define is_dhcp_srvr_filt_enabled(adapter)      \
                (adapter->bmc_filt_mask & BMC_FILT_BROADCAST_DHCP_SERVER)

#define is_nbios_filt_enabled(adapter)  \
                (adapter->bmc_filt_mask & BMC_FILT_BROADCAST_NET_BIOS)

#define is_ipv6_na_filt_enabled(adapter)        \
                (adapter->bmc_filt_mask &       \
                        BMC_FILT_MULTICAST_IPV6_NEIGH_ADVER)

#define is_ipv6_ra_filt_enabled(adapter)        \
                (adapter->bmc_filt_mask & BMC_FILT_MULTICAST_IPV6_RA)

#define is_ipv6_ras_filt_enabled(adapter)       \
                (adapter->bmc_filt_mask & BMC_FILT_MULTICAST_IPV6_RAS)

#define is_broadcast_filt_enabled(adapter)      \
                (adapter->bmc_filt_mask & BMC_FILT_BROADCAST)

#define is_multicast_filt_enabled(adapter)      \
                (adapter->bmc_filt_mask & BMC_FILT_MULTICAST)

static bool be_send_pkt_to_bmc(struct be_adapter *adapter,
                               struct sk_buff **skb)
{
        struct ethhdr *eh = (struct ethhdr *)(*skb)->data;
        bool os2bmc = false;

        if (!be_is_os2bmc_enabled(adapter))
                goto done;

        if (!is_multicast_ether_addr(eh->h_dest))
                goto done;

        if (is_mc_allowed_on_bmc(adapter, eh) ||
            is_bc_allowed_on_bmc(adapter, eh) ||
            is_arp_allowed_on_bmc(adapter, (*skb))) {
                os2bmc = true;
                goto done;
        }

        if ((*skb)->protocol == htons(ETH_P_IPV6)) {
                struct ipv6hdr *hdr = ipv6_hdr((*skb));
                u8 nexthdr = hdr->nexthdr;

                if (nexthdr == IPPROTO_ICMPV6) {
                        struct icmp6hdr *icmp6 = icmp6_hdr((*skb));

                        switch (icmp6->icmp6_type) {
                        case NDISC_ROUTER_ADVERTISEMENT:
                                os2bmc = is_ipv6_ra_filt_enabled(adapter);
                                goto done;
                        case NDISC_NEIGHBOUR_ADVERTISEMENT:
                                os2bmc = is_ipv6_na_filt_enabled(adapter);
                                goto done;
                        default:
                                break;
                        }
                }
        }

        if (is_udp_pkt((*skb))) {
                struct udphdr *udp = udp_hdr((*skb));

                switch (ntohs(udp->dest)) {
                case DHCP_CLIENT_PORT:
                        os2bmc = is_dhcp_client_filt_enabled(adapter);
                        goto done;
                case DHCP_SERVER_PORT:
                        os2bmc = is_dhcp_srvr_filt_enabled(adapter);
                        goto done;
                case NET_BIOS_PORT1:
                case NET_BIOS_PORT2:
                        os2bmc = is_nbios_filt_enabled(adapter);
                        goto done;
                case DHCPV6_RAS_PORT:
                        os2bmc = is_ipv6_ras_filt_enabled(adapter);
                        goto done;
                default:
                        break;
                }
        }
done:
        /* For packets over a vlan, which are destined
         * to BMC, asic expects the vlan to be inline in the packet.
         */
        if (os2bmc)
                *skb = be_insert_vlan_in_pkt(adapter, *skb, NULL);

        return os2bmc;
}

static netdev_tx_t be_xmit(struct sk_buff *skb, struct net_device *netdev)
{
        struct be_adapter *adapter = netdev_priv(netdev);
        u16 q_idx = skb_get_queue_mapping(skb);
        struct be_tx_obj *txo = &adapter->tx_obj[q_idx];
        struct be_wrb_params wrb_params = { 0 };
        bool flush = !skb->xmit_more;
        u16 wrb_cnt;

        skb = be_xmit_workarounds(adapter, skb, &wrb_params);
        if (unlikely(!skb))
                goto drop;

        be_get_wrb_params_from_skb(adapter, skb, &wrb_params);

        wrb_cnt = be_xmit_enqueue(adapter, txo, skb, &wrb_params);
        if (unlikely(!wrb_cnt)) {
                dev_kfree_skb_any(skb);
                goto drop;
        }

        /* if os2bmc is enabled and if the pkt is destined to bmc,
         * enqueue the pkt a 2nd time with mgmt bit set.
         */
        if (be_send_pkt_to_bmc(adapter, &skb)) {
                BE_WRB_F_SET(wrb_params.features, OS2BMC, 1);
                wrb_cnt = be_xmit_enqueue(adapter, txo, skb, &wrb_params);
                if (unlikely(!wrb_cnt))
                        goto drop;
                else
                        skb_get(skb);
        }

        if (be_is_txq_full(txo)) {
                netif_stop_subqueue(netdev, q_idx);
                tx_stats(txo)->tx_stops++;
        }

        if (flush || __netif_subqueue_stopped(netdev, q_idx))
                be_xmit_flush(adapter, txo);

        return NETDEV_TX_OK;
drop:
        tx_stats(txo)->tx_drv_drops++;
        /* Flush the already enqueued tx requests */
        if (flush && txo->pend_wrb_cnt)
                be_xmit_flush(adapter, txo);

        return NETDEV_TX_OK;
}

static inline bool be_in_all_promisc(struct be_adapter *adapter)
{
        return (adapter->if_flags & BE_IF_FLAGS_ALL_PROMISCUOUS) ==
                        BE_IF_FLAGS_ALL_PROMISCUOUS;
}

static int be_set_vlan_promisc(struct be_adapter *adapter)
{
        struct device *dev = &adapter->pdev->dev;
        int status;

        if (adapter->if_flags & BE_IF_FLAGS_VLAN_PROMISCUOUS)
                return 0;

        status = be_cmd_rx_filter(adapter, BE_IF_FLAGS_VLAN_PROMISCUOUS, ON);
        if (!status) {
                dev_info(dev, "Enabled VLAN promiscuous mode\n");
                adapter->if_flags |= BE_IF_FLAGS_VLAN_PROMISCUOUS;
        } else {
                dev_err(dev, "Failed to enable VLAN promiscuous mode\n");
        }
        return status;
}

static int be_clear_vlan_promisc(struct be_adapter *adapter)
{
        struct device *dev = &adapter->pdev->dev;
        int status;

        status = be_cmd_rx_filter(adapter, BE_IF_FLAGS_VLAN_PROMISCUOUS, OFF);
        if (!status) {
                dev_info(dev, "Disabling VLAN promiscuous mode\n");
                adapter->if_flags &= ~BE_IF_FLAGS_VLAN_PROMISCUOUS;
        }
        return status;
}

/*
 * A max of 64 (BE_NUM_VLANS_SUPPORTED) vlans can be configured in BE.
 * If the user configures more, place BE in vlan promiscuous mode.
 */
static int be_vid_config(struct be_adapter *adapter)
{
        struct device *dev = &adapter->pdev->dev;
        u16 vids[BE_NUM_VLANS_SUPPORTED];
        u16 num = 0, i = 0;
        int status = 0;

        /* No need to change the VLAN state if the I/F is in promiscuous */
        if (adapter->netdev->flags & IFF_PROMISC)
                return 0;

        if (adapter->vlans_added > be_max_vlans(adapter))
                return be_set_vlan_promisc(adapter);

        if (adapter->if_flags & BE_IF_FLAGS_VLAN_PROMISCUOUS) {
                status = be_clear_vlan_promisc(adapter);
                if (status)
                        return status;
        }
        /* Construct VLAN Table to give to HW */
        for_each_set_bit(i, adapter->vids, VLAN_N_VID)
                vids[num++] = cpu_to_le16(i);

        status = be_cmd_vlan_config(adapter, adapter->if_handle, vids, num, 0);
        if (status) {
                dev_err(dev, "Setting HW VLAN filtering failed\n");
                /* Set to VLAN promisc mode as setting VLAN filter failed */
                if (addl_status(status) == MCC_ADDL_STATUS_INSUFFICIENT_VLANS ||
                    addl_status(status) ==
                                MCC_ADDL_STATUS_INSUFFICIENT_RESOURCES)
                        return be_set_vlan_promisc(adapter);
        }
        return status;
}

static int be_vlan_add_vid(struct net_device *netdev, __be16 proto, u16 vid)
{
        struct be_adapter *adapter = netdev_priv(netdev);
        int status = 0;

        mutex_lock(&adapter->rx_filter_lock);

        /* Packets with VID 0 are always received by Lancer by default */
        if (lancer_chip(adapter) && vid == 0)
                goto done;

        if (test_bit(vid, adapter->vids))
                goto done;

        set_bit(vid, adapter->vids);
        adapter->vlans_added++;

        status = be_vid_config(adapter);
done:
        mutex_unlock(&adapter->rx_filter_lock);
        return status;
}

static int be_vlan_rem_vid(struct net_device *netdev, __be16 proto, u16 vid)
{
        struct be_adapter *adapter = netdev_priv(netdev);
        int status = 0;

        mutex_lock(&adapter->rx_filter_lock);

        /* Packets with VID 0 are always received by Lancer by default */
        if (lancer_chip(adapter) && vid == 0)
                goto done;

        if (!test_bit(vid, adapter->vids))
                goto done;

        clear_bit(vid, adapter->vids);
        adapter->vlans_added--;

        status = be_vid_config(adapter);
done:
        mutex_unlock(&adapter->rx_filter_lock);
        return status;
}

static void be_set_all_promisc(struct be_adapter *adapter)
{
        be_cmd_rx_filter(adapter, BE_IF_FLAGS_ALL_PROMISCUOUS, ON);
        adapter->if_flags |= BE_IF_FLAGS_ALL_PROMISCUOUS;
}

static void be_set_mc_promisc(struct be_adapter *adapter)
{
        int status;

        if (adapter->if_flags & BE_IF_FLAGS_MCAST_PROMISCUOUS)
                return;

        status = be_cmd_rx_filter(adapter, BE_IF_FLAGS_MCAST_PROMISCUOUS, ON);
        if (!status)
                adapter->if_flags |= BE_IF_FLAGS_MCAST_PROMISCUOUS;
}

static void be_set_uc_promisc(struct be_adapter *adapter)
{
        int status;

        if (adapter->if_flags & BE_IF_FLAGS_PROMISCUOUS)
                return;

        status = be_cmd_rx_filter(adapter, BE_IF_FLAGS_PROMISCUOUS, ON);
        if (!status)
                adapter->if_flags |= BE_IF_FLAGS_PROMISCUOUS;
}

static void be_clear_uc_promisc(struct be_adapter *adapter)
{
        int status;

        if (!(adapter->if_flags & BE_IF_FLAGS_PROMISCUOUS))
                return;

        status = be_cmd_rx_filter(adapter, BE_IF_FLAGS_PROMISCUOUS, OFF);
        if (!status)
                adapter->if_flags &= ~BE_IF_FLAGS_PROMISCUOUS;
}

/* The below 2 functions are the callback args for __dev_mc_sync/dev_uc_sync().
 * We use a single callback function for both sync and unsync. We really don't
 * add/remove addresses through this callback. But, we use it to detect changes
 * to the uc/mc lists. The entire uc/mc list is programmed in be_set_rx_mode().
 */
static int be_uc_list_update(struct net_device *netdev,
                             const unsigned char *addr)
{
        struct be_adapter *adapter = netdev_priv(netdev);

        adapter->update_uc_list = true;
        return 0;
}

static int be_mc_list_update(struct net_device *netdev,
                             const unsigned char *addr)
{
        struct be_adapter *adapter = netdev_priv(netdev);

        adapter->update_mc_list = true;
        return 0;
}

static void be_set_mc_list(struct be_adapter *adapter)
{
        struct net_device *netdev = adapter->netdev;
        struct netdev_hw_addr *ha;
        bool mc_promisc = false;
        int status;

        netif_addr_lock_bh(netdev);
        __dev_mc_sync(netdev, be_mc_list_update, be_mc_list_update);

        if (netdev->flags & IFF_PROMISC) {
                adapter->update_mc_list = false;
        } else if (netdev->flags & IFF_ALLMULTI ||
                   netdev_mc_count(netdev) > be_max_mc(adapter)) {
                /* Enable multicast promisc if num configured exceeds
                 * what we support
                 */
                mc_promisc = true;
                adapter->update_mc_list = false;
        } else if (adapter->if_flags & BE_IF_FLAGS_MCAST_PROMISCUOUS) {
                /* Update mc-list unconditionally if the iface was previously
                 * in mc-promisc mode and now is out of that mode.
                 */
                adapter->update_mc_list = true;
        }

        if (adapter->update_mc_list) {
                int i = 0;

                /* cache the mc-list in adapter */
                netdev_for_each_mc_addr(ha, netdev) {
                        ether_addr_copy(adapter->mc_list[i].mac, ha->addr);
                        i++;
                }
                adapter->mc_count = netdev_mc_count(netdev);
        }
        netif_addr_unlock_bh(netdev);

        if (mc_promisc) {
                be_set_mc_promisc(adapter);
        } else if (adapter->update_mc_list) {
                status = be_cmd_rx_filter(adapter, BE_IF_FLAGS_MULTICAST, ON);
                if (!status)
                        adapter->if_flags &= ~BE_IF_FLAGS_MCAST_PROMISCUOUS;
                else
                        be_set_mc_promisc(adapter);

                adapter->update_mc_list = false;
        }
}

static void be_clear_mc_list(struct be_adapter *adapter)
{
        struct net_device *netdev = adapter->netdev;

        __dev_mc_unsync(netdev, NULL);
        be_cmd_rx_filter(adapter, BE_IF_FLAGS_MULTICAST, OFF);
        adapter->mc_count = 0;
}

static int be_uc_mac_add(struct be_adapter *adapter, int uc_idx)
{
        if (ether_addr_equal(adapter->uc_list[uc_idx].mac, adapter->dev_mac)) {
                adapter->pmac_id[uc_idx + 1] = adapter->pmac_id[0];
                return 0;
        }

        return be_cmd_pmac_add(adapter, adapter->uc_list[uc_idx].mac,
                               adapter->if_handle,
                               &adapter->pmac_id[uc_idx + 1], 0);
}

static void be_uc_mac_del(struct be_adapter *adapter, int pmac_id)
{
        if (pmac_id == adapter->pmac_id[0])
                return;

        be_cmd_pmac_del(adapter, adapter->if_handle, pmac_id, 0);
}

static void be_set_uc_list(struct be_adapter *adapter)
{
        struct net_device *netdev = adapter->netdev;
        struct netdev_hw_addr *ha;
        bool uc_promisc = false;
        int curr_uc_macs = 0, i;

        netif_addr_lock_bh(netdev);
        __dev_uc_sync(netdev, be_uc_list_update, be_uc_list_update);

        if (netdev->flags & IFF_PROMISC) {
                adapter->update_uc_list = false;
        } else if (netdev_uc_count(netdev) > (be_max_uc(adapter) - 1)) {
                uc_promisc = true;
                adapter->update_uc_list = false;
        }  else if (adapter->if_flags & BE_IF_FLAGS_PROMISCUOUS) {
                /* Update uc-list unconditionally if the iface was previously
                 * in uc-promisc mode and now is out of that mode.
                 */
                adapter->update_uc_list = true;
        }

        if (adapter->update_uc_list) {
                /* cache the uc-list in adapter array */
                i = 0;
                netdev_for_each_uc_addr(ha, netdev) {
                        ether_addr_copy(adapter->uc_list[i].mac, ha->addr);
                        i++;
                }
                curr_uc_macs = netdev_uc_count(netdev);
        }
        netif_addr_unlock_bh(netdev);

        if (uc_promisc) {
                be_set_uc_promisc(adapter);
        } else if (adapter->update_uc_list) {
                be_clear_uc_promisc(adapter);

                for (i = 0; i < adapter->uc_macs; i++)
                        be_uc_mac_del(adapter, adapter->pmac_id[i + 1]);

                for (i = 0; i < curr_uc_macs; i++)
                        be_uc_mac_add(adapter, i);
                adapter->uc_macs = curr_uc_macs;
                adapter->update_uc_list = false;
        }
}

static void be_clear_uc_list(struct be_adapter *adapter)
{
        struct net_device *netdev = adapter->netdev;
        int i;

        __dev_uc_unsync(netdev, NULL);
        for (i = 0; i < adapter->uc_macs; i++)
                be_uc_mac_del(adapter, adapter->pmac_id[i + 1]);

        adapter->uc_macs = 0;
}

static void __be_set_rx_mode(struct be_adapter *adapter)
{
        struct net_device *netdev = adapter->netdev;

        mutex_lock(&adapter->rx_filter_lock);

        if (netdev->flags & IFF_PROMISC) {
                if (!be_in_all_promisc(adapter))
                        be_set_all_promisc(adapter);
        } else if (be_in_all_promisc(adapter)) {
                /* We need to re-program the vlan-list or clear
                 * vlan-promisc mode (if needed) when the interface
                 * comes out of promisc mode.
                 */
                be_vid_config(adapter);
        }

        be_set_uc_list(adapter);
        be_set_mc_list(adapter);

        mutex_unlock(&adapter->rx_filter_lock);
}

static void be_work_set_rx_mode(struct work_struct *work)
{
        struct be_cmd_work *cmd_work =
                                container_of(work, struct be_cmd_work, work);

        __be_set_rx_mode(cmd_work->adapter);
        kfree(cmd_work);
}

static int be_set_vf_mac(struct net_device *netdev, int vf, u8 *mac)
{
        struct be_adapter *adapter = netdev_priv(netdev);
        struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf];
        int status;

        if (!sriov_enabled(adapter))
                return -EPERM;

        if (!is_valid_ether_addr(mac) || vf >= adapter->num_vfs)
                return -EINVAL;

        /* Proceed further only if user provided MAC is different
         * from active MAC
         */
        if (ether_addr_equal(mac, vf_cfg->mac_addr))
                return 0;

        if (BEx_chip(adapter)) {
                be_cmd_pmac_del(adapter, vf_cfg->if_handle, vf_cfg->pmac_id,
                                vf + 1);

                status = be_cmd_pmac_add(adapter, mac, vf_cfg->if_handle,
                                         &vf_cfg->pmac_id, vf + 1);
        } else {
                status = be_cmd_set_mac(adapter, mac, vf_cfg->if_handle,
                                        vf + 1);
        }

        if (status) {
                dev_err(&adapter->pdev->dev, "MAC %pM set on VF %d Failed: %#x",
                        mac, vf, status);
                return be_cmd_status(status);
        }

        ether_addr_copy(vf_cfg->mac_addr, mac);

        return 0;
}

static int be_get_vf_config(struct net_device *netdev, int vf,
                            struct ifla_vf_info *vi)
{
        struct be_adapter *adapter = netdev_priv(netdev);
        struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf];

        if (!sriov_enabled(adapter))
                return -EPERM;

        if (vf >= adapter->num_vfs)
                return -EINVAL;

        vi->vf = vf;
        vi->max_tx_rate = vf_cfg->tx_rate;
        vi->min_tx_rate = 0;
        vi->vlan = vf_cfg->vlan_tag & VLAN_VID_MASK;
        vi->qos = vf_cfg->vlan_tag >> VLAN_PRIO_SHIFT;
        memcpy(&vi->mac, vf_cfg->mac_addr, ETH_ALEN);
        vi->linkstate = adapter->vf_cfg[vf].plink_tracking;
        vi->spoofchk = adapter->vf_cfg[vf].spoofchk;

        return 0;
}

static int be_set_vf_tvt(struct be_adapter *adapter, int vf, u16 vlan)
{
        struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf];
        u16 vids[BE_NUM_VLANS_SUPPORTED];
        int vf_if_id = vf_cfg->if_handle;
        int status;

        /* Enable Transparent VLAN Tagging */
        status = be_cmd_set_hsw_config(adapter, vlan, vf + 1, vf_if_id, 0, 0);
        if (status)
                return status;

        /* Clear pre-programmed VLAN filters on VF if any, if TVT is enabled */
        vids[0] = 0;
        status = be_cmd_vlan_config(adapter, vf_if_id, vids, 1, vf + 1);
        if (!status)
                dev_info(&adapter->pdev->dev,
                         "Cleared guest VLANs on VF%d", vf);

        /* After TVT is enabled, disallow VFs to program VLAN filters */
        if (vf_cfg->privileges & BE_PRIV_FILTMGMT) {
                status = be_cmd_set_fn_privileges(adapter, vf_cfg->privileges &
                                                  ~BE_PRIV_FILTMGMT, vf + 1);
                if (!status)
                        vf_cfg->privileges &= ~BE_PRIV_FILTMGMT;
        }
        return 0;
}

static int be_clear_vf_tvt(struct be_adapter *adapter, int vf)
{
        struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf];
        struct device *dev = &adapter->pdev->dev;
        int status;

        /* Reset Transparent VLAN Tagging. */
        status = be_cmd_set_hsw_config(adapter, BE_RESET_VLAN_TAG_ID, vf + 1,
                                       vf_cfg->if_handle, 0, 0);
        if (status)
                return status;

        /* Allow VFs to program VLAN filtering */
        if (!(vf_cfg->privileges & BE_PRIV_FILTMGMT)) {
                status = be_cmd_set_fn_privileges(adapter, vf_cfg->privileges |
                                                  BE_PRIV_FILTMGMT, vf + 1);
                if (!status) {
                        vf_cfg->privileges |= BE_PRIV_FILTMGMT;
                        dev_info(dev, "VF%d: FILTMGMT priv enabled", vf);
                }
        }

        dev_info(dev,
                 "Disable/re-enable i/f in VM to clear Transparent VLAN tag");
        return 0;
}

static int be_set_vf_vlan(struct net_device *netdev, int vf, u16 vlan, u8 qos,
                          __be16 vlan_proto)
{
        struct be_adapter *adapter = netdev_priv(netdev);
        struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf];
        int status;

        if (!sriov_enabled(adapter))
                return -EPERM;

        if (vf >= adapter->num_vfs || vlan > 4095 || qos > 7)
                return -EINVAL;

        if (vlan_proto != htons(ETH_P_8021Q))
                return -EPROTONOSUPPORT;

        if (vlan || qos) {
                vlan |= qos << VLAN_PRIO_SHIFT;
                status = be_set_vf_tvt(adapter, vf, vlan);
        } else {
                status = be_clear_vf_tvt(adapter, vf);
        }

        if (status) {
                dev_err(&adapter->pdev->dev,
                        "VLAN %d config on VF %d failed : %#x\n", vlan, vf,
                        status);
                return be_cmd_status(status);
        }

        vf_cfg->vlan_tag = vlan;
        return 0;
}

static int be_set_vf_tx_rate(struct net_device *netdev, int vf,
                             int min_tx_rate, int max_tx_rate)
{
        struct be_adapter *adapter = netdev_priv(netdev);
        struct device *dev = &adapter->pdev->dev;
        int percent_rate, status = 0;
        u16 link_speed = 0;
        u8 link_status;

        if (!sriov_enabled(adapter))
                return -EPERM;

        if (vf >= adapter->num_vfs)
                return -EINVAL;

        if (min_tx_rate)
                return -EINVAL;

        if (!max_tx_rate)
                goto config_qos;

        status = be_cmd_link_status_query(adapter, &link_speed,
                                          &link_status, 0);
        if (status)
                goto err;

        if (!link_status) {
                dev_err(dev, "TX-rate setting not allowed when link is down\n");
                status = -ENETDOWN;
                goto err;
        }

        if (max_tx_rate < 100 || max_tx_rate > link_speed) {
                dev_err(dev, "TX-rate must be between 100 and %d Mbps\n",
                        link_speed);
                status = -EINVAL;
                goto err;
        }

        /* On Skyhawk the QOS setting must be done only as a % value */
        percent_rate = link_speed / 100;
        if (skyhawk_chip(adapter) && (max_tx_rate % percent_rate)) {
                dev_err(dev, "TX-rate must be a multiple of %d Mbps\n",
                        percent_rate);
                status = -EINVAL;
                goto err;
        }

config_qos:
        status = be_cmd_config_qos(adapter, max_tx_rate, link_speed, vf + 1);
        if (status)
                goto err;

        adapter->vf_cfg[vf].tx_rate = max_tx_rate;
        return 0;

err:
        dev_err(dev, "TX-rate setting of %dMbps on VF%d failed\n",
                max_tx_rate, vf);
        return be_cmd_status(status);
}

static int be_set_vf_link_state(struct net_device *netdev, int vf,
                                int link_state)
{
        struct be_adapter *adapter = netdev_priv(netdev);
        int status;

        if (!sriov_enabled(adapter))
                return -EPERM;

        if (vf >= adapter->num_vfs)
                return -EINVAL;

        status = be_cmd_set_logical_link_config(adapter, link_state, vf+1);
        if (status) {
                dev_err(&adapter->pdev->dev,
                        "Link state change on VF %d failed: %#x\n", vf, status);
                return be_cmd_status(status);
        }

        adapter->vf_cfg[vf].plink_tracking = link_state;

        return 0;
}

static int be_set_vf_spoofchk(struct net_device *netdev, int vf, bool enable)
{
        struct be_adapter *adapter = netdev_priv(netdev);
        struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf];
        u8 spoofchk;
        int status;

        if (!sriov_enabled(adapter))
                return -EPERM;

        if (vf >= adapter->num_vfs)
                return -EINVAL;

        if (BEx_chip(adapter))
                return -EOPNOTSUPP;

        if (enable == vf_cfg->spoofchk)
                return 0;

        spoofchk = enable ? ENABLE_MAC_SPOOFCHK : DISABLE_MAC_SPOOFCHK;

        status = be_cmd_set_hsw_config(adapter, 0, vf + 1, vf_cfg->if_handle,
                                       0, spoofchk);
        if (status) {
                dev_err(&adapter->pdev->dev,
                        "Spoofchk change on VF %d failed: %#x\n", vf, status);
                return be_cmd_status(status);
        }

        vf_cfg->spoofchk = enable;
        return 0;
}

static void be_aic_update(struct be_aic_obj *aic, u64 rx_pkts, u64 tx_pkts,
                          ulong now)
{
        aic->rx_pkts_prev = rx_pkts;
        aic->tx_reqs_prev = tx_pkts;
        aic->jiffies = now;
}

static int be_get_new_eqd(struct be_eq_obj *eqo)
{
        struct be_adapter *adapter = eqo->adapter;
        int eqd, start;
        struct be_aic_obj *aic;
        struct be_rx_obj *rxo;
        struct be_tx_obj *txo;
        u64 rx_pkts = 0, tx_pkts = 0;
        ulong now;
        u32 pps, delta;
        int i;

        aic = &adapter->aic_obj[eqo->idx];
        if (!aic->enable) {
                if (aic->jiffies)
                        aic->jiffies = 0;
                eqd = aic->et_eqd;
                return eqd;
        }

        for_all_rx_queues_on_eq(adapter, eqo, rxo, i) {
                do {
                        start = u64_stats_fetch_begin_irq(&rxo->stats.sync);
                        rx_pkts += rxo->stats.rx_pkts;
                } while (u64_stats_fetch_retry_irq(&rxo->stats.sync, start));
        }

        for_all_tx_queues_on_eq(adapter, eqo, txo, i) {
                do {
                        start = u64_stats_fetch_begin_irq(&txo->stats.sync);
                        tx_pkts += txo->stats.tx_reqs;
                } while (u64_stats_fetch_retry_irq(&txo->stats.sync, start));
        }

        /* Skip, if wrapped around or first calculation */
        now = jiffies;
        if (!aic->jiffies || time_before(now, aic->jiffies) ||
            rx_pkts < aic->rx_pkts_prev ||
            tx_pkts < aic->tx_reqs_prev) {
                be_aic_update(aic, rx_pkts, tx_pkts, now);
                return aic->prev_eqd;
        }

        delta = jiffies_to_msecs(now - aic->jiffies);
        if (delta == 0)
                return aic->prev_eqd;

        pps = (((u32)(rx_pkts - aic->rx_pkts_prev) * 1000) / delta) +
                (((u32)(tx_pkts - aic->tx_reqs_prev) * 1000) / delta);
        eqd = (pps / 15000) << 2;

        if (eqd < 8)
                eqd = 0;
        eqd = min_t(u32, eqd, aic->max_eqd);
        eqd = max_t(u32, eqd, aic->min_eqd);

        be_aic_update(aic, rx_pkts, tx_pkts, now);

        return eqd;
}

/* For Skyhawk-R only */
static u32 be_get_eq_delay_mult_enc(struct be_eq_obj *eqo)
{
        struct be_adapter *adapter = eqo->adapter;
        struct be_aic_obj *aic = &adapter->aic_obj[eqo->idx];
        ulong now = jiffies;
        int eqd;
        u32 mult_enc;

        if (!aic->enable)
                return 0;

        if (jiffies_to_msecs(now - aic->jiffies) < 1)
                eqd = aic->prev_eqd;
        else
                eqd = be_get_new_eqd(eqo);

        if (eqd > 100)
                mult_enc = R2I_DLY_ENC_1;
        else if (eqd > 60)
                mult_enc = R2I_DLY_ENC_2;
        else if (eqd > 20)
                mult_enc = R2I_DLY_ENC_3;
        else
                mult_enc = R2I_DLY_ENC_0;

        aic->prev_eqd = eqd;

        return mult_enc;
}

void be_eqd_update(struct be_adapter *adapter, bool force_update)
{
        struct be_set_eqd set_eqd[MAX_EVT_QS];
        struct be_aic_obj *aic;
        struct be_eq_obj *eqo;
        int i, num = 0, eqd;

        for_all_evt_queues(adapter, eqo, i) {
                aic = &adapter->aic_obj[eqo->idx];
                eqd = be_get_new_eqd(eqo);
                if (force_update || eqd != aic->prev_eqd) {
                        set_eqd[num].delay_multiplier = (eqd * 65)/100;
                        set_eqd[num].eq_id = eqo->q.id;
                        aic->prev_eqd = eqd;
                        num++;
                }
        }

        if (num)
                be_cmd_modify_eqd(adapter, set_eqd, num);
}

static void be_rx_stats_update(struct be_rx_obj *rxo,
                               struct be_rx_compl_info *rxcp)
{
        struct be_rx_stats *stats = rx_stats(rxo);

        u64_stats_update_begin(&stats->sync);
        stats->rx_compl++;
        stats->rx_bytes += rxcp->pkt_size;
        stats->rx_pkts++;
        if (rxcp->tunneled)
                stats->rx_vxlan_offload_pkts++;
        if (rxcp->pkt_type == BE_MULTICAST_PACKET)
                stats->rx_mcast_pkts++;
        if (rxcp->err)
                stats->rx_compl_err++;
        u64_stats_update_end(&stats->sync);
}

static inline bool csum_passed(struct be_rx_compl_info *rxcp)
{
        /* L4 checksum is not reliable for non TCP/UDP packets.
         * Also ignore ipcksm for ipv6 pkts
         */
        return (rxcp->tcpf || rxcp->udpf) && rxcp->l4_csum &&
                (rxcp->ip_csum || rxcp->ipv6) && !rxcp->err;
}

static struct be_rx_page_info *get_rx_page_info(struct be_rx_obj *rxo)
{
        struct be_adapter *adapter = rxo->adapter;
        struct be_rx_page_info *rx_page_info;
        struct be_queue_info *rxq = &rxo->q;
        u32 frag_idx = rxq->tail;

        rx_page_info = &rxo->page_info_tbl[frag_idx];
        BUG_ON(!rx_page_info->page);

        if (rx_page_info->last_frag) {
                dma_unmap_page(&adapter->pdev->dev,
                               dma_unmap_addr(rx_page_info, bus),
                               adapter->big_page_size, DMA_FROM_DEVICE);
                rx_page_info->last_frag = false;
        } else {
                dma_sync_single_for_cpu(&adapter->pdev->dev,
                                        dma_unmap_addr(rx_page_info, bus),
                                        rx_frag_size, DMA_FROM_DEVICE);
        }

        queue_tail_inc(rxq);
        atomic_dec(&rxq->used);
        return rx_page_info;
}

/* Throwaway the data in the Rx completion */
static void be_rx_compl_discard(struct be_rx_obj *rxo,
                                struct be_rx_compl_info *rxcp)
{
        struct be_rx_page_info *page_info;
        u16 i, num_rcvd = rxcp->num_rcvd;

        for (i = 0; i < num_rcvd; i++) {
                page_info = get_rx_page_info(rxo);
                put_page(page_info->page);
                memset(page_info, 0, sizeof(*page_info));
        }
}

/*
 * skb_fill_rx_data forms a complete skb for an ether frame
 * indicated by rxcp.
 */
static void skb_fill_rx_data(struct be_rx_obj *rxo, struct sk_buff *skb,
                             struct be_rx_compl_info *rxcp)
{
        struct be_rx_page_info *page_info;
        u16 i, j;
        u16 hdr_len, curr_frag_len, remaining;
        u8 *start;

        page_info = get_rx_page_info(rxo);
        start = page_address(page_info->page) + page_info->page_offset;
        prefetch(start);

        /* Copy data in the first descriptor of this completion */
        curr_frag_len = min(rxcp->pkt_size, rx_frag_size);

        skb->len = curr_frag_len;
        if (curr_frag_len <= BE_HDR_LEN) { /* tiny packet */
                memcpy(skb->data, start, curr_frag_len);
                /* Complete packet has now been moved to data */
                put_page(page_info->page);
                skb->data_len = 0;
                skb->tail += curr_frag_len;
        } else {
                hdr_len = ETH_HLEN;
                memcpy(skb->data, start, hdr_len);
                skb_shinfo(skb)->nr_frags = 1;
                skb_frag_set_page(skb, 0, page_info->page);
                skb_shinfo(skb)->frags[0].page_offset =
                                        page_info->page_offset + hdr_len;
                skb_frag_size_set(&skb_shinfo(skb)->frags[0],
                                  curr_frag_len - hdr_len);
                skb->data_len = curr_frag_len - hdr_len;
                skb->truesize += rx_frag_size;
                skb->tail += hdr_len;
        }
        page_info->page = NULL;

        if (rxcp->pkt_size <= rx_frag_size) {
                BUG_ON(rxcp->num_rcvd != 1);
                return;
        }

        /* More frags present for this completion */
        remaining = rxcp->pkt_size - curr_frag_len;
        for (i = 1, j = 0; i < rxcp->num_rcvd; i++) {
                page_info = get_rx_page_info(rxo);
                curr_frag_len = min(remaining, rx_frag_size);

                /* Coalesce all frags from the same physical page in one slot */
                if (page_info->page_offset == 0) {
                        /* Fresh page */
                        j++;
                        skb_frag_set_page(skb, j, page_info->page);
                        skb_shinfo(skb)->frags[j].page_offset =
                                                        page_info->page_offset;
                        skb_frag_size_set(&skb_shinfo(skb)->frags[j], 0);
                        skb_shinfo(skb)->nr_frags++;
                } else {
                        put_page(page_info->page);
                }

                skb_frag_size_add(&skb_shinfo(skb)->frags[j], curr_frag_len);
                skb->len += curr_frag_len;
                skb->data_len += curr_frag_len;
                skb->truesize += rx_frag_size;
                remaining -= curr_frag_len;
                page_info->page = NULL;
        }
        BUG_ON(j > MAX_SKB_FRAGS);
}

/* Process the RX completion indicated by rxcp when GRO is disabled */
static void be_rx_compl_process(struct be_rx_obj *rxo, struct napi_struct *napi,
                                struct be_rx_compl_info *rxcp)
{
        struct be_adapter *adapter = rxo->adapter;
        struct net_device *netdev = adapter->netdev;
        struct sk_buff *skb;

        skb = netdev_alloc_skb_ip_align(netdev, BE_RX_SKB_ALLOC_SIZE);
        if (unlikely(!skb)) {
                rx_stats(rxo)->rx_drops_no_skbs++;
                be_rx_compl_discard(rxo, rxcp);
                return;
        }

        skb_fill_rx_data(rxo, skb, rxcp);

        if (likely((netdev->features & NETIF_F_RXCSUM) && csum_passed(rxcp)))
                skb->ip_summed = CHECKSUM_UNNECESSARY;
        else
                skb_checksum_none_assert(skb);

        skb->protocol = eth_type_trans(skb, netdev);
        skb_record_rx_queue(skb, rxo - &adapter->rx_obj[0]);
        if (netdev->features & NETIF_F_RXHASH)
                skb_set_hash(skb, rxcp->rss_hash, PKT_HASH_TYPE_L3);

        skb->csum_level = rxcp->tunneled;
        skb_mark_napi_id(skb, napi);

        if (rxcp->vlanf)
                __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), rxcp->vlan_tag);

        netif_receive_skb(skb);
}

/* Process the RX completion indicated by rxcp when GRO is enabled */
static void be_rx_compl_process_gro(struct be_rx_obj *rxo,
                                    struct napi_struct *napi,
                                    struct be_rx_compl_info *rxcp)
{
        struct be_adapter *adapter = rxo->adapter;
        struct be_rx_page_info *page_info;
        struct sk_buff *skb = NULL;
        u16 remaining, curr_frag_len;
        u16 i, j;

        skb = napi_get_frags(napi);
        if (!skb) {
                be_rx_compl_discard(rxo, rxcp);
                return;
        }

        remaining = rxcp->pkt_size;
        for (i = 0, j = -1; i < rxcp->num_rcvd; i++) {
                page_info = get_rx_page_info(rxo);

                curr_frag_len = min(remaining, rx_frag_size);

                /* Coalesce all frags from the same physical page in one slot */
                if (i == 0 || page_info->page_offset == 0) {
                        /* First frag or Fresh page */
                        j++;
                        skb_frag_set_page(skb, j, page_info->page);
                        skb_shinfo(skb)->frags[j].page_offset =
                                                        page_info->page_offset;
                        skb_frag_size_set(&skb_shinfo(skb)->frags[j], 0);
                } else {
                        put_page(page_info->page);
                }
                skb_frag_size_add(&skb_shinfo(skb)->frags[j], curr_frag_len);
                skb->truesize += rx_frag_size;
                remaining -= curr_frag_len;
                memset(page_info, 0, sizeof(*page_info));
        }
        BUG_ON(j > MAX_SKB_FRAGS);

        skb_shinfo(skb)->nr_frags = j + 1;
        skb->len = rxcp->pkt_size;
        skb->data_len = rxcp->pkt_size;
        skb->ip_summed = CHECKSUM_UNNECESSARY;
        skb_record_rx_queue(skb, rxo - &adapter->rx_obj[0]);
        if (adapter->netdev->features & NETIF_F_RXHASH)
                skb_set_hash(skb, rxcp->rss_hash, PKT_HASH_TYPE_L3);

        skb->csum_level = rxcp->tunneled;

        if (rxcp->vlanf)
                __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), rxcp->vlan_tag);

        napi_gro_frags(napi);
}

static void be_parse_rx_compl_v1(struct be_eth_rx_compl *compl,
                                 struct be_rx_compl_info *rxcp)
{
        rxcp->pkt_size = GET_RX_COMPL_V1_BITS(pktsize, compl);
        rxcp->vlanf = GET_RX_COMPL_V1_BITS(vtp, compl);
        rxcp->err = GET_RX_COMPL_V1_BITS(err, compl);
        rxcp->tcpf = GET_RX_COMPL_V1_BITS(tcpf, compl);
        rxcp->udpf = GET_RX_COMPL_V1_BITS(udpf, compl);
        rxcp->ip_csum = GET_RX_COMPL_V1_BITS(ipcksm, compl);
        rxcp->l4_csum = GET_RX_COMPL_V1_BITS(l4_cksm, compl);
        rxcp->ipv6 = GET_RX_COMPL_V1_BITS(ip_version, compl);
        rxcp->num_rcvd = GET_RX_COMPL_V1_BITS(numfrags, compl);
        rxcp->pkt_type = GET_RX_COMPL_V1_BITS(cast_enc, compl);
        rxcp->rss_hash = GET_RX_COMPL_V1_BITS(rsshash, compl);
        if (rxcp->vlanf) {
                rxcp->qnq = GET_RX_COMPL_V1_BITS(qnq, compl);
                rxcp->vlan_tag = GET_RX_COMPL_V1_BITS(vlan_tag, compl);
        }
        rxcp->port = GET_RX_COMPL_V1_BITS(port, compl);
        rxcp->tunneled =
                GET_RX_COMPL_V1_BITS(tunneled, compl);
}

static void be_parse_rx_compl_v0(struct be_eth_rx_compl *compl,
                                 struct be_rx_compl_info *rxcp)
{
        rxcp->pkt_size = GET_RX_COMPL_V0_BITS(pktsize, compl);
        rxcp->vlanf = GET_RX_COMPL_V0_BITS(vtp, compl);
        rxcp->err = GET_RX_COMPL_V0_BITS(err, compl);
        rxcp->tcpf = GET_RX_COMPL_V0_BITS(tcpf, compl);
        rxcp->udpf = GET_RX_COMPL_V0_BITS(udpf, compl);
        rxcp->ip_csum = GET_RX_COMPL_V0_BITS(ipcksm, compl);
        rxcp->l4_csum = GET_RX_COMPL_V0_BITS(l4_cksm, compl);
        rxcp->ipv6 = GET_RX_COMPL_V0_BITS(ip_version, compl);
        rxcp->num_rcvd = GET_RX_COMPL_V0_BITS(numfrags, compl);
        rxcp->pkt_type = GET_RX_COMPL_V0_BITS(cast_enc, compl);
        rxcp->rss_hash = GET_RX_COMPL_V0_BITS(rsshash, compl);
        if (rxcp->vlanf) {
                rxcp->qnq = GET_RX_COMPL_V0_BITS(qnq, compl);
                rxcp->vlan_tag = GET_RX_COMPL_V0_BITS(vlan_tag, compl);
        }
        rxcp->port = GET_RX_COMPL_V0_BITS(port, compl);
        rxcp->ip_frag = GET_RX_COMPL_V0_BITS(ip_frag, compl);
}

static struct be_rx_compl_info *be_rx_compl_get(struct be_rx_obj *rxo)
{
        struct be_eth_rx_compl *compl = queue_tail_node(&rxo->cq);
        struct be_rx_compl_info *rxcp = &rxo->rxcp;
        struct be_adapter *adapter = rxo->adapter;

        /* For checking the valid bit it is Ok to use either definition as the
         * valid bit is at the same position in both v0 and v1 Rx compl */
        if (compl->dw[offsetof(struct amap_eth_rx_compl_v1, valid) / 32] == 0)
                return NULL;

        rmb();
        be_dws_le_to_cpu(compl, sizeof(*compl));

        if (adapter->be3_native)
                be_parse_rx_compl_v1(compl, rxcp);
        else
                be_parse_rx_compl_v0(compl, rxcp);

        if (rxcp->ip_frag)
                rxcp->l4_csum = 0;

        if (rxcp->vlanf) {
                /* In QNQ modes, if qnq bit is not set, then the packet was
                 * tagged only with the transparent outer vlan-tag and must
                 * not be treated as a vlan packet by host
                 */
                if (be_is_qnq_mode(adapter) && !rxcp->qnq)
                        rxcp->vlanf = 0;

                if (!lancer_chip(adapter))
                        rxcp->vlan_tag = swab16(rxcp->vlan_tag);

                if (adapter->pvid == (rxcp->vlan_tag & VLAN_VID_MASK) &&
                    !test_bit(rxcp->vlan_tag, adapter->vids))
                        rxcp->vlanf = 0;
        }

        /* As the compl has been parsed, reset it; we wont touch it again */
        compl->dw[offsetof(struct amap_eth_rx_compl_v1, valid) / 32] = 0;

        queue_tail_inc(&rxo->cq);
        return rxcp;
}

static inline struct page *be_alloc_pages(u32 size, gfp_t gfp)
{
        u32 order = get_order(size);

        if (order > 0)
                gfp |= __GFP_COMP;
        return  alloc_pages(gfp, order);
}

/*
 * Allocate a page, split it to fragments of size rx_frag_size and post as
 * receive buffers to BE
 */
static void be_post_rx_frags(struct be_rx_obj *rxo, gfp_t gfp, u32 frags_needed)
{
        struct be_adapter *adapter = rxo->adapter;
        struct be_rx_page_info *page_info = NULL, *prev_page_info = NULL;
        struct be_queue_info *rxq = &rxo->q;
        struct page *pagep = NULL;
        struct device *dev = &adapter->pdev->dev;
        struct be_eth_rx_d *rxd;
        u64 page_dmaaddr = 0, frag_dmaaddr;
        u32 posted, page_offset = 0, notify = 0;

        page_info = &rxo->page_info_tbl[rxq->head];
        for (posted = 0; posted < frags_needed && !page_info->page; posted++) {
                if (!pagep) {
                        pagep = be_alloc_pages(adapter->big_page_size, gfp);
                        if (unlikely(!pagep)) {
                                rx_stats(rxo)->rx_post_fail++;
                                break;
                        }
                        page_dmaaddr = dma_map_page(dev, pagep, 0,
                                                    adapter->big_page_size,
                                                    DMA_FROM_DEVICE);
                        if (dma_mapping_error(dev, page_dmaaddr)) {
                                put_page(pagep);
                                pagep = NULL;
                                adapter->drv_stats.dma_map_errors++;
                                break;
                        }
                        page_offset = 0;
                } else {
                        get_page(pagep);
                        page_offset += rx_frag_size;
                }
                page_info->page_offset = page_offset;
                page_info->page = pagep;

                rxd = queue_head_node(rxq);
                frag_dmaaddr = page_dmaaddr + page_info->page_offset;
                rxd->fragpa_lo = cpu_to_le32(frag_dmaaddr & 0xFFFFFFFF);
                rxd->fragpa_hi = cpu_to_le32(upper_32_bits(frag_dmaaddr));

                /* Any space left in the current big page for another frag? */
                if ((page_offset + rx_frag_size + rx_frag_size) >
                                        adapter->big_page_size) {
                        pagep = NULL;
                        page_info->last_frag = true;
                        dma_unmap_addr_set(page_info, bus, page_dmaaddr);
                } else {
                        dma_unmap_addr_set(page_info, bus, frag_dmaaddr);
                }

                prev_page_info = page_info;
                queue_head_inc(rxq);
                page_info = &rxo->page_info_tbl[rxq->head];
        }

        /* Mark the last frag of a page when we break out of the above loop
         * with no more slots available in the RXQ
         */
        if (pagep) {
                prev_page_info->last_frag = true;
                dma_unmap_addr_set(prev_page_info, bus, page_dmaaddr);
        }

        if (posted) {
                atomic_add(posted, &rxq->used);
                if (rxo->rx_post_starved)
                        rxo->rx_post_starved = false;
                do {
                        notify = min(MAX_NUM_POST_ERX_DB, posted);
                        be_rxq_notify(adapter, rxq->id, notify);
                        posted -= notify;
                } while (posted);
        } else if (atomic_read(&rxq->used) == 0) {
                /* Let be_worker replenish when memory is available */
                rxo->rx_post_starved = true;
        }
}

static struct be_tx_compl_info *be_tx_compl_get(struct be_tx_obj *txo)
{
        struct be_queue_info *tx_cq = &txo->cq;
        struct be_tx_compl_info *txcp = &txo->txcp;
        struct be_eth_tx_compl *compl = queue_tail_node(tx_cq);

        if (compl->dw[offsetof(struct amap_eth_tx_compl, valid) / 32] == 0)
                return NULL;

        /* Ensure load ordering of valid bit dword and other dwords below */
        rmb();
        be_dws_le_to_cpu(compl, sizeof(*compl));

        txcp->status = GET_TX_COMPL_BITS(status, compl);
        txcp->end_index = GET_TX_COMPL_BITS(wrb_index, compl);

        compl->dw[offsetof(struct amap_eth_tx_compl, valid) / 32] = 0;
        queue_tail_inc(tx_cq);
        return txcp;
}

static u16 be_tx_compl_process(struct be_adapter *adapter,
                               struct be_tx_obj *txo, u16 last_index)
{
        struct sk_buff **sent_skbs = txo->sent_skb_list;
        struct be_queue_info *txq = &txo->q;
        struct sk_buff *skb = NULL;
        bool unmap_skb_hdr = false;
        struct be_eth_wrb *wrb;
        u16 num_wrbs = 0;
        u32 frag_index;

        do {
                if (sent_skbs[txq->tail]) {
                        /* Free skb from prev req */
                        if (skb)
                                dev_consume_skb_any(skb);
                        skb = sent_skbs[txq->tail];
                        sent_skbs[txq->tail] = NULL;
                        queue_tail_inc(txq);  /* skip hdr wrb */
                        num_wrbs++;
                        unmap_skb_hdr = true;
                }
                wrb = queue_tail_node(txq);
                frag_index = txq->tail;
                unmap_tx_frag(&adapter->pdev->dev, wrb,
                              (unmap_skb_hdr && skb_headlen(skb)));
                unmap_skb_hdr = false;
                queue_tail_inc(txq);
                num_wrbs++;
        } while (frag_index != last_index);
        dev_consume_skb_any(skb);

        return num_wrbs;
}

/* Return the number of events in the event queue */
static inline int events_get(struct be_eq_obj *eqo)
{
        struct be_eq_entry *eqe;
        int num = 0;

        do {
                eqe = queue_tail_node(&eqo->q);
                if (eqe->evt == 0)
                        break;

                rmb();
                eqe->evt = 0;
                num++;
                queue_tail_inc(&eqo->q);
        } while (true);

        return num;
}

/* Leaves the EQ is disarmed state */
static void be_eq_clean(struct be_eq_obj *eqo)
{
        int num = events_get(eqo);

        be_eq_notify(eqo->adapter, eqo->q.id, false, true, num, 0);
}

/* Free posted rx buffers that were not used */
static void be_rxq_clean(struct be_rx_obj *rxo)
{
        struct be_queue_info *rxq = &rxo->q;
        struct be_rx_page_info *page_info;

        while (atomic_read(&rxq->used) > 0) {
                page_info = get_rx_page_info(rxo);
                put_page(page_info->page);
                memset(page_info, 0, sizeof(*page_info));
        }
        BUG_ON(atomic_read(&rxq->used));
        rxq->tail = 0;
        rxq->head = 0;
}

static void be_rx_cq_clean(struct be_rx_obj *rxo)
{
        struct be_queue_info *rx_cq = &rxo->cq;
        struct be_rx_compl_info *rxcp;
        struct be_adapter *adapter = rxo->adapter;
        int flush_wait = 0;

        /* Consume pending rx completions.
         * Wait for the flush completion (identified by zero num_rcvd)
         * to arrive. Notify CQ even when there are no more CQ entries
         * for HW to flush partially coalesced CQ entries.
         * In Lancer, there is no need to wait for flush compl.
         */
        for (;;) {
                rxcp = be_rx_compl_get(rxo);
                if (!rxcp) {
                        if (lancer_chip(adapter))
                                break;

                        if (flush_wait++ > 50 ||
                            be_check_error(adapter,
                                           BE_ERROR_HW)) {
                                dev_warn(&adapter->pdev->dev,
                                         "did not receive flush compl\n");
                                break;
                        }
                        be_cq_notify(adapter, rx_cq->id, true, 0);
                        mdelay(1);
                } else {
                        be_rx_compl_discard(rxo, rxcp);
                        be_cq_notify(adapter, rx_cq->id, false, 1);
                        if (rxcp->num_rcvd == 0)
                                break;
                }
        }

        /* After cleanup, leave the CQ in unarmed state */
        be_cq_notify(adapter, rx_cq->id, false, 0);
}

static void be_tx_compl_clean(struct be_adapter *adapter)
{
        struct device *dev = &adapter->pdev->dev;
        u16 cmpl = 0, timeo = 0, num_wrbs = 0;
        struct be_tx_compl_info *txcp;
        struct be_queue_info *txq;
        u32 end_idx, notified_idx;
        struct be_tx_obj *txo;
        int i, pending_txqs;

        /* Stop polling for compls when HW has been silent for 10ms */
        do {
                pending_txqs = adapter->num_tx_qs;

                for_all_tx_queues(adapter, txo, i) {
                        cmpl = 0;
                        num_wrbs = 0;
                        txq = &txo->q;
                        while ((txcp = be_tx_compl_get(txo))) {
                                num_wrbs +=
                                        be_tx_compl_process(adapter, txo,
                                                            txcp->end_index);
                                cmpl++;
                        }
                        if (cmpl) {
                                be_cq_notify(adapter, txo->cq.id, false, cmpl);
                                atomic_sub(num_wrbs, &txq->used);
                                timeo = 0;
                        }
                        if (!be_is_tx_compl_pending(txo))
                                pending_txqs--;
                }

                if (pending_txqs == 0 || ++timeo > 10 ||
                    be_check_error(adapter, BE_ERROR_HW))
                        break;

                mdelay(1);
        } while (true);

        /* Free enqueued TX that was never notified to HW */
        for_all_tx_queues(adapter, txo, i) {
                txq = &txo->q;

                if (atomic_read(&txq->used)) {
                        dev_info(dev, "txq%d: cleaning %d pending tx-wrbs\n",
                                 i, atomic_read(&txq->used));
                        notified_idx = txq->tail;
                        end_idx = txq->tail;
                        index_adv(&end_idx, atomic_read(&txq->used) - 1,
                                  txq->len);
                        /* Use the tx-compl process logic to handle requests
                         * that were not sent to the HW.
                         */
                        num_wrbs = be_tx_compl_process(adapter, txo, end_idx);
                        atomic_sub(num_wrbs, &txq->used);
                        BUG_ON(atomic_read(&txq->used));
                        txo->pend_wrb_cnt = 0;
                        /* Since hw was never notified of these requests,
                         * reset TXQ indices
                         */
                        txq->head = notified_idx;
                        txq->tail = notified_idx;
                }
        }
}

static void be_evt_queues_destroy(struct be_adapter *adapter)
{
        struct be_eq_obj *eqo;
        int i;

        for_all_evt_queues(adapter, eqo, i) {
                if (eqo->q.created) {
                        be_eq_clean(eqo);
                        be_cmd_q_destroy(adapter, &eqo->q, QTYPE_EQ);
                        netif_napi_del(&eqo->napi);
                        free_cpumask_var(eqo->affinity_mask);
                }
                be_queue_free(adapter, &eqo->q);
        }
}

static int be_evt_queues_create(struct be_adapter *adapter)
{
        struct be_queue_info *eq;
        struct be_eq_obj *eqo;
        struct be_aic_obj *aic;
        int i, rc;

        /* need enough EQs to service both RX and TX queues */
        adapter->num_evt_qs = min_t(u16, num_irqs(adapter),
                                    max(adapter->cfg_num_rx_irqs,
                                        adapter->cfg_num_tx_irqs));

        for_all_evt_queues(adapter, eqo, i) {
                int numa_node = dev_to_node(&adapter->pdev->dev);

                aic = &adapter->aic_obj[i];
                eqo->adapter = adapter;
                eqo->idx = i;
                aic->max_eqd = BE_MAX_EQD;
                aic->enable = true;

                eq = &eqo->q;
                rc = be_queue_alloc(adapter, eq, EVNT_Q_LEN,
                                    sizeof(struct be_eq_entry));
                if (rc)
                        return rc;

                rc = be_cmd_eq_create(adapter, eqo);
                if (rc)
                        return rc;

                if (!zalloc_cpumask_var(&eqo->affinity_mask, GFP_KERNEL))
                        return -ENOMEM;
                cpumask_set_cpu(cpumask_local_spread(i, numa_node),
                                eqo->affinity_mask);
                netif_napi_add(adapter->netdev, &eqo->napi, be_poll,
                               BE_NAPI_WEIGHT);
        }
        return 0;
}

static void be_mcc_queues_destroy(struct be_adapter *adapter)
{
        struct be_queue_info *q;

        q = &adapter->mcc_obj.q;
        if (q->created)
                be_cmd_q_destroy(adapter, q, QTYPE_MCCQ);
        be_queue_free(adapter, q);

        q = &adapter->mcc_obj.cq;
        if (q->created)
                be_cmd_q_destroy(adapter, q, QTYPE_CQ);
        be_queue_free(adapter, q);
}

/* Must be called only after TX qs are created as MCC shares TX EQ */
static int be_mcc_queues_create(struct be_adapter *adapter)
{
        struct be_queue_info *q, *cq;

        cq = &adapter->mcc_obj.cq;
        if (be_queue_alloc(adapter, cq, MCC_CQ_LEN,
                           sizeof(struct be_mcc_compl)))
                goto err;

        /* Use the default EQ for MCC completions */
        if (be_cmd_cq_create(adapter, cq, &mcc_eqo(adapter)->q, true, 0))
                goto mcc_cq_free;

        q = &adapter->mcc_obj.q;
        if (be_queue_alloc(adapter, q, MCC_Q_LEN, sizeof(struct be_mcc_wrb)))
                goto mcc_cq_destroy;

        if (be_cmd_mccq_create(adapter, q, cq))
                goto mcc_q_free;

        return 0;

mcc_q_free:
        be_queue_free(adapter, q);
mcc_cq_destroy:
        be_cmd_q_destroy(adapter, cq, QTYPE_CQ);
mcc_cq_free:
        be_queue_free(adapter, cq);
err:
        return -1;
}

static void be_tx_queues_destroy(struct be_adapter *adapter)
{
        struct be_queue_info *q;
        struct be_tx_obj *txo;
        u8 i;

        for_all_tx_queues(adapter, txo, i) {
                q = &txo->q;
                if (q->created)
                        be_cmd_q_destroy(adapter, q, QTYPE_TXQ);
                be_queue_free(adapter, q);

                q = &txo->cq;
                if (q->created)
                        be_cmd_q_destroy(adapter, q, QTYPE_CQ);
                be_queue_free(adapter, q);
        }
}

static int be_tx_qs_create(struct be_adapter *adapter)
{
        struct be_queue_info *cq;
        struct be_tx_obj *txo;
        struct be_eq_obj *eqo;
        int status, i;

        adapter->num_tx_qs = min(adapter->num_evt_qs, adapter->cfg_num_tx_irqs);

        for_all_tx_queues(adapter, txo, i) {
                cq = &txo->cq;
                status = be_queue_alloc(adapter, cq, TX_CQ_LEN,
                                        sizeof(struct be_eth_tx_compl));
                if (status)
                        return status;

                u64_stats_init(&txo->stats.sync);
                u64_stats_init(&txo->stats.sync_compl);

                /* If num_evt_qs is less than num_tx_qs, then more than
                 * one txq share an eq
                 */
                eqo = &adapter->eq_obj[i % adapter->num_evt_qs];
                status = be_cmd_cq_create(adapter, cq, &eqo->q, false, 3);
                if (status)
                        return status;

                status = be_queue_alloc(adapter, &txo->q, TX_Q_LEN,
                                        sizeof(struct be_eth_wrb));
                if (status)
                        return status;

                status = be_cmd_txq_create(adapter, txo);
                if (status)
                        return status;

                netif_set_xps_queue(adapter->netdev, eqo->affinity_mask,
                                    eqo->idx);
        }

        dev_info(&adapter->pdev->dev, "created %d TX queue(s)\n",
                 adapter->num_tx_qs);
        return 0;
}

static void be_rx_cqs_destroy(struct be_adapter *adapter)
{
        struct be_queue_info *q;
        struct be_rx_obj *rxo;
        int i;

        for_all_rx_queues(adapter, rxo, i) {
                q = &rxo->cq;
                if (q->created)
                        be_cmd_q_destroy(adapter, q, QTYPE_CQ);
                be_queue_free(adapter, q);
        }
}

static int be_rx_cqs_create(struct be_adapter *adapter)
{
        struct be_queue_info *eq, *cq;
        struct be_rx_obj *rxo;
        int rc, i;

        adapter->num_rss_qs =
                        min(adapter->num_evt_qs, adapter->cfg_num_rx_irqs);

        /* We'll use RSS only if atleast 2 RSS rings are supported. */
        if (adapter->num_rss_qs < 2)
                adapter->num_rss_qs = 0;

        adapter->num_rx_qs = adapter->num_rss_qs + adapter->need_def_rxq;

        /* When the interface is not capable of RSS rings (and there is no
         * need to create a default RXQ) we'll still need one RXQ
         */
        if (adapter->num_rx_qs == 0)
                adapter->num_rx_qs = 1;

        adapter->big_page_size = (1 << get_order(rx_frag_size)) * PAGE_SIZE;
        for_all_rx_queues(adapter, rxo, i) {