/* bnx2x_esx.c: Broadcom Everest network driver.
 *
 * Copyright 2008-2013 Broadcom Corporation
 *
 * Portions Copyright (c) VMware, Inc. 2008-2013, All Rights Reserved.
 * Copyright (c) 2007-2013 Broadcom Corporation
 *
 * Unless you and Broadcom execute a separate written software license
 * agreement governing use of this software, this software is licensed to you
 * under the terms of the GNU General Public License version 2, available
 * at http://www.gnu.org/licenses/old-licenses/gpl-2.0.html (the "GPL").
 *
 * Notwithstanding the above, under no circumstances may you combine this
 * software in any way with any other Broadcom software provided under a
 * license other than the GPL, without Broadcom's express prior written
 * consent.
 *
 * Maintained by: Benjamin Li <benli@broadcom.com>
 * NetQueue code from VMware
 * IOCTL code by: Benjamin Li
 * PASSTHRU code by: Shmulik Ravid
 *
 */

#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/pci.h>
#include <linux/netdevice.h>
#include <linux/delay.h>
#include <linux/ethtool.h>
#ifdef __LINUX_MUTEX_H
#include <linux/mutex.h>
#endif
#include <linux/version.h>

#include "bnx2x.h"
#include "bnx2x_cmn.h"
#include "bnx2x_esx.h"
#include "bnx2x_init.h"

/* empty implementations for thes kernel primitives because they seems to be compiled out */
inline void local_bh_enable(void) {}
inline void local_bh_disable(void) {}

#if defined(VMX86_DEBUG)
int psod_on_panic = 1;
#else
int psod_on_panic;
#endif /* VMX86_DEBUG */
module_param(psod_on_panic, int, 0);
MODULE_PARM_DESC(psod_on_panic, " PSOD on panic");

#ifdef BNX2X_NETQ
static int multi_rx_filters = -1;
module_param(multi_rx_filters, int, 0);
MODULE_PARM_DESC(multi_rx_filters, "Define the number of RX filters per "
				   "NetQueue: (allowed values: -1 to "
				   "Max # of RX filters per NetQueue, "
				   "-1: use the default number of RX filters; "
				   "0: Disable use of multiple RX filters; "
				   "1..Max # the number of RX filters "
				   "per NetQueue: will force the number "
				   "of RX filters to use for NetQueue");
#endif

#ifdef BNX2X_VMWARE_BMAPILNX
int
bnx2x_ioctl_cim(struct net_device *dev, struct ifreq *ifr)
{
	struct bnx2x *bp = netdev_priv(dev);
	void __user *useraddr = ifr->ifr_data;
	struct bnx2x_ioctl_req req;
	int rc = 0;
	u32 val;

	/* We assume all userworld apps are 32 bits ==> ifr->ifr_data is
	   a 32 bit pointer so we truncate useraddr */
	unsigned long uaddr32 = (unsigned long)useraddr & 0xffffffff;

	if (copy_from_user(&req, (void __user *)uaddr32, sizeof(req))) {
		BNX2X_ERR("%s: bnx2x_ioctl() could not copy from user\n",
			  bp->dev->name);
		return -EFAULT;
	}

	DP(NETIF_MSG_LINK, "%s: bnx2x_ioctl() CIM cmd: 0x%x\n",
	       bp->dev->name, req.cmd);

	switch(req.cmd) {
	case BNX2X_VMWARE_CIM_CMD_ENABLE_NIC:
		DP(NETIF_MSG_LINK, "%s: bnx2x_ioctl() enable NIC\n",
		       bp->dev->name);

		rc = bnx2x_open(bp->dev);
		break;
	case BNX2X_VMWARE_CIM_CMD_DISABLE_NIC:
		DP(NETIF_MSG_LINK, "%s: bnx2x_ioctl() enable NIC\n",
		       bp->dev->name);

		rc = bnx2x_close(bp->dev);
		break;
	case BNX2X_VMWARE_CIM_CMD_REG_READ: {
		u32 mem_len;

		mem_len = pci_resource_len(bp->pdev, 0);
		if(mem_len < req.cmd_req.reg_read.reg_offset) {
			BNX2X_ERR("%s: bnx2x_ioctl() reg read: "
				  "out of range: max reg: 0x%x "
				  "req reg: 0x%x\n",
				bp->dev->name,
				mem_len, req.cmd_req.reg_read.reg_offset);
			rc = -EINVAL;
			break;
		}

		val = REG_RD(bp, req.cmd_req.reg_read.reg_offset);

		DP(NETIF_MSG_LINK, "%s: bnx2x_ioctl() reg read: "
				   "reg: 0x%x value:0x%x",
		       bp->dev->name,
		       req.cmd_req.reg_read.reg_offset,
		       req.cmd_req.reg_read.reg_value);

		req.cmd_req.reg_read.reg_value = val;

		break;
	} case BNX2X_VMWARE_CIM_CMD_REG_WRITE: {
		u32 mem_len;

		mem_len = pci_resource_len(bp->pdev, 0);
		if(mem_len < req.cmd_req.reg_write.reg_offset) {
			BNX2X_ERR("%s: bnx2x_ioctl() reg write: "
				  "out of range: max reg: 0x%x "
				  "req reg: 0x%x\n",
				bp->dev->name,
				mem_len, req.cmd_req.reg_write.reg_offset);
			rc = -EINVAL;
			break;
		}
		DP(NETIF_MSG_LINK, "%s: bnx2x_ioctl() reg write: "
				   "reg: 0x%x value:0x%x",
		       bp->dev->name,
		       req.cmd_req.reg_write.reg_offset,
		       req.cmd_req.reg_write.reg_value);

		REG_WR(bp, req.cmd_req.reg_write.reg_offset,
			   req.cmd_req.reg_write.reg_value);

		break;
	} case BNX2X_VMWARE_CIM_CMD_GET_NIC_PARAM:
		DP(NETIF_MSG_LINK, "%s: bnx2x_ioctl() get NIC param\n",
		       bp->dev->name);

		req.cmd_req.get_nic_param.mtu = dev->mtu;
		memcpy(req.cmd_req.get_nic_param.current_mac_addr,
		       dev->dev_addr,
		       sizeof(req.cmd_req.get_nic_param.current_mac_addr));
		break;
	case BNX2X_VMWARE_CIM_CMD_GET_NIC_STATUS:
		DP(NETIF_MSG_LINK, "%s: bnx2x_ioctl() get NIC status\n",
		       bp->dev->name);

		req.cmd_req.get_nic_status.nic_status = netif_running(dev);
		break;
	default:
		BNX2X_ERR("%s: bnx2x_ioctl() unknown req.cmd: 0x%x\n",
		       bp->dev->name, req.cmd);
		rc = -EINVAL;
	}

	if (rc == 0 &&
	    copy_to_user((void __user *)uaddr32, &req, sizeof(req))) {
		BNX2X_ERR("%s: bnx2x_ioctl() couldn't copy to user "
			  "bnx2_ioctl_req\n", bp->dev->name);
		return -EFAULT;
	}

	return rc;
}
#endif

#ifdef BNX2X_NETQ

/* not including the default queue - qid 0*/
static inline int bnx2x_netq_valid_qid(struct bnx2x *bp, u16 qid)
{
	return ((qid > 0) && (qid <= BNX2X_NUM_NETQUEUES(bp)));
}

static int bnx2x_num_active_rx_mac_filters(struct bnx2x_fastpath *fp)

{
	struct bnx2x *bp = fp->bp;
	int i, count = 0;

	for (i = 0; i < bp->number_of_mac_filters; i++) {
		if (BNX2X_IS_NETQ_RX_FILTER_ACTIVE(fp, i))
			count++;
	}

	return count;
}

static int bnx2x_is_last_rx_mac_filter(struct bnx2x_fastpath *fp)
{
	return (bnx2x_num_active_rx_mac_filters(fp) == 1 ? 1 : 0);
}

static void bnx2x_add_rx_mac_entry(struct netq_mac_filter *filter,
				  u8 *mac)
{
	memcpy(filter->mac, mac, ETH_ALEN);
	filter->flags |= BNX2X_NETQ_RX_FILTER_ACTIVE;
}

static void bnx2x_clear_rx_mac_entry(struct netq_mac_filter *filter)
{
	memset(filter->mac, 0, ETH_ALEN);
	filter->flags &= ~BNX2X_NETQ_RX_FILTER_ACTIVE;
}

static int bnx2x_find_rx_mac_filter_add(struct bnx2x *bp,
					struct bnx2x_fastpath *fp, u8 *mac)
{
	int i;

	if (fp->mac_filters == NULL) {
		if (bp->number_of_mac_filters == 0) {
			DP(BNX2X_MSG_NETQ, "number_of_mac_filters == 0\n");
			return -ENODEV;
		}

		fp->mac_filters = kzalloc(sizeof(struct netq_mac_filter) *
					  bp->number_of_mac_filters,
					  GFP_ATOMIC);
		if (fp->mac_filters == NULL) {
			DP(BNX2X_MSG_NETQ, "Failed to allocate "
					   "RX MAC filter table\n");
			return -ENOMEM;
		}
		DP(BNX2X_MSG_NETQ, "Allocated RX MAC filter table with %d "
				   "entries on RX queue %d\n",
				   bp->number_of_mac_filters, fp->index);

		bnx2x_add_rx_mac_entry(&fp->mac_filters[0], mac);
		return 0;
	}

	for (i = 0; i < bp->number_of_mac_filters; i++) {
		if (!BNX2X_IS_NETQ_RX_FILTER_ACTIVE(fp, i)) {
			bnx2x_add_rx_mac_entry(&fp->mac_filters[i], mac);
			return i;
		}
	}

	DP(BNX2X_MSG_NETQ, "RX filters on NetQ RX Queue %d exhausted\n",
	   fp->index);
	return -ENODEV;
}

static void bnx2x_remove_rx_mac_filter(struct bnx2x *bp,
				       struct bnx2x_fastpath *fp, u16 fid,
				       int is_last_mac_filter)
{
	fp->mac_filters[fid].flags &= ~BNX2X_NETQ_RX_FILTER_ACTIVE;

	if (is_last_mac_filter) {
		fp->netq_flags &= ~BNX2X_NETQ_RX_QUEUE_ACTIVE;
		kfree(fp->mac_filters);
		fp->mac_filters = NULL;

		DP(BNX2X_MSG_NETQ, "Freed RX MAC filter table\n");
	}
}

void bnx2x_reserve_netq_feature(struct bnx2x *bp)
{
	int i;

#if (VMWARE_ESX_DDK_VERSION >= 41000)
	int num_lro_reserved = 0;
	int max_features = BNX2X_NETQ_FP_FEATURES_RESERVED + 1;
#endif

	for_each_net_queue(bp, i) {
		struct bnx2x_fastpath *fp = &bp->fp[i];
	#if (VMWARE_ESX_DDK_VERSION < 41000)
		fp->disable_tpa = 1;
	#else
		/* clear features flags */
		fp->netq_flags &= ~BNX2X_NETQ_FP_FEATURES_RESERVED_MASK;

		switch ((i % max_features) <<
			BNX2X_NETQ_FP_FEATURE_RESERVED_SHIFT_BIT) {
		case BNX2X_NETQ_FP_LRO_RESERVED:
			if ((num_lro_reserved <
			     BNX2X_NETQ_FP_LRO_RESERVED_MAX_NUM(bp)) &&
			    (bp->flags & TPA_ENABLE_FLAG)) {
				fp->netq_flags |= BNX2X_NETQ_FP_LRO_RESERVED;
				DP(BNX2X_MSG_NETQ, "Queue[%d] is reserved "
						   "for LRO\n", i);
				num_lro_reserved++;
			} else {
				/* either TPA is glabally disabled or we
				 * already reserved the max number of LRO queues
				 */
				DP(BNX2X_MSG_NETQ, "Queue[%d] is non-LRO\n", i);
				fp->netq_flags |= BNX2X_NETQ_FP_NONE_RESERVED;
				fp->disable_tpa = 1;
			}
			break;

		default:
			/* Do not reserve for LRO */
			DP(BNX2X_MSG_NETQ, "Queue[%d] is non-LRO\n", i);
			fp->netq_flags |= BNX2X_NETQ_FP_NONE_RESERVED;
			fp->disable_tpa = 1;
			break;
		}
	#endif
	}
}

static int bnx2x_get_netqueue_features(vmknetddi_queueop_get_features_args_t *args)
{
	args->features = VMKNETDDI_QUEUEOPS_FEATURE_NONE;
	args->features |= VMKNETDDI_QUEUEOPS_FEATURE_RXQUEUES;
	args->features |= VMKNETDDI_QUEUEOPS_FEATURE_TXQUEUES;
	return VMKNETDDI_QUEUEOPS_OK;
}

static int bnx2x_get_queue_count(vmknetddi_queueop_get_queue_count_args_t *args)
{
	struct bnx2x *bp = netdev_priv(args->netdev);
	u16 netq_count = max_t(u16, BNX2X_NUM_NETQUEUES(bp), 0);

	if (args->type == VMKNETDDI_QUEUEOPS_QUEUE_TYPE_RX) {
		args->count = netq_count;
		return VMKNETDDI_QUEUEOPS_OK;

	} else if (args->type == VMKNETDDI_QUEUEOPS_QUEUE_TYPE_TX) {
		args->count = netq_count;
		return VMKNETDDI_QUEUEOPS_OK;

	} else {
		DP(BNX2X_MSG_NETQ, "invalid queue type: %x\n", args->type);
		return VMKNETDDI_QUEUEOPS_ERR;
	}
}

static int bnx2x_get_filter_count(vmknetddi_queueop_get_filter_count_args_t *args)
{
	struct bnx2x *bp;
	int total_filters = 0;

	bp = netdev_priv(args->netdev);

	if ((BNX2X_NUM_NETQUEUES(bp) == 0 && !IS_MF_FCOE_AFEX(bp)) ||
	    (BNX2X_NUM_NETQUEUES(bp) == 0 && IS_MF_FCOE_AFEX(bp) &&
	     !BNX2X_IS_MF_SD_PROTOCOL_FCOE(bp))) {
		bp->number_of_mac_filters = 0;
		args->count = 0;
		return VMKNETDDI_QUEUEOPS_OK;
	}

	if (multi_rx_filters == 0) {
		DP(BNX2X_MSG_NETQ, "Multiple RX filters disabled forced to "
				   "use only 1 filter.\n");
		bp->number_of_mac_filters = 1;
		args->count = 1;
		return VMKNETDDI_QUEUEOPS_OK;
	}

#if defined(BNX2X_ESX_CNA)
	if (args->netdev->features & NETIF_F_CNA) {
		args->count = 2;
		return VMKNETDDI_QUEUEOPS_OK;
	}
#endif
	/*  Calculate the number of credits left */
	total_filters = bp->macs_pool.check(&bp->macs_pool);
	if (total_filters > 3)
		total_filters = total_filters - 3;
	else
		total_filters = 0;

	DP(BNX2X_MSG_NETQ, "Total Avaiable filters: %d\n", total_filters);
	DP(BNX2X_MSG_NETQ, "# NetQueue: %d\n", BNX2X_NUM_NETQUEUES(bp));
	bp->number_of_mac_filters = (total_filters / BNX2X_NUM_NETQUEUES(bp));

	if (multi_rx_filters > 0) {
		if (bp->number_of_mac_filters < multi_rx_filters)
			DP(BNX2X_MSG_NETQ, "Forced RX filter setting %d higher "
					   "then checked value %d\n",
					   multi_rx_filters,
					   bp->number_of_mac_filters);


		bp->number_of_mac_filters = min_t(int,
						  bp->number_of_mac_filters,
						  multi_rx_filters);
	}
		
	DP(BNX2X_MSG_NETQ, "NetQueue assigned per filters: %d\n",
	   bp->number_of_mac_filters);

	args->count = bp->number_of_mac_filters;
	return VMKNETDDI_QUEUEOPS_OK;
}

static int bnx2x_alloc_rx_queue(struct net_device *netdev,
				vmknetddi_queueops_queueid_t *p_qid,
				struct napi_struct **napi_p)
{
	struct bnx2x *bp = netdev_priv(netdev);
	int i;

	if (bp->n_rx_queues_allocated >= BNX2X_NUM_NETQUEUES(bp)) {
		BNX2X_ERR("NetQ RX Queue %d >= BNX2X_NUM_NETQUEUES(%d)\n",
			  bp->n_rx_queues_allocated, BNX2X_NUM_NETQUEUES(bp));
		return VMKNETDDI_QUEUEOPS_ERR;
	}

	for_each_net_queue(bp, i) {
		struct bnx2x_fastpath *fp = &bp->fp[i];

		if ((!BNX2X_IS_NETQ_RX_QUEUE_ALLOCATED(fp)) &&
		    BNX2X_IS_NETQ_FP_FEAT_NONE_RESERVED(fp)) {
			fp->netq_flags |= BNX2X_NETQ_RX_QUEUE_ALLOCATED;
			bp->n_rx_queues_allocated++;
			*p_qid = VMKNETDDI_QUEUEOPS_MK_RX_QUEUEID(fp->index);
			*napi_p = &fp->napi;

			DP(BNX2X_MSG_NETQ, "RX NetQ allocated on %d\n", i);
			return VMKNETDDI_QUEUEOPS_OK;
		}
	}
	DP(BNX2X_MSG_NETQ, "No free rx queues found!\n");
	return VMKNETDDI_QUEUEOPS_ERR;
}

static int bnx2x_alloc_tx_queue(struct net_device *netdev,
				vmknetddi_queueops_queueid_t *p_qid,
				u16 *queue_mapping)
{
	struct bnx2x *bp = netdev_priv(netdev);
	int i;

	if (bp->n_tx_queues_allocated >= BNX2X_NUM_NETQUEUES(bp)) {
		BNX2X_ERR("NetQ TX Queue %d >= BNX2X_NUM_NETQUEUES(%d)\n",
			  bp->n_tx_queues_allocated, BNX2X_NUM_NETQUEUES(bp));
		return VMKNETDDI_QUEUEOPS_ERR;
	}

	for_each_net_queue(bp, i) {
		struct bnx2x_fastpath *fp = &bp->fp[i];

		if (!BNX2X_IS_NETQ_TX_QUEUE_ALLOCATED(fp)) {
			fp->netq_flags |= BNX2X_NETQ_TX_QUEUE_ALLOCATED;
			bp->n_tx_queues_allocated++;
			*p_qid = VMKNETDDI_QUEUEOPS_MK_TX_QUEUEID(fp->index);
			*queue_mapping = fp->index;

			DP(BNX2X_MSG_NETQ, "TX NetQ allocated on %d\n", i);
			return VMKNETDDI_QUEUEOPS_OK;
		}
	}
	DP(BNX2X_MSG_NETQ, "No free tx queues found!\n");
	return VMKNETDDI_QUEUEOPS_ERR;
}

static int bnx2x_alloc_queue(vmknetddi_queueop_alloc_queue_args_t *args)
{

	if (args->type == VMKNETDDI_QUEUEOPS_QUEUE_TYPE_TX)
		return bnx2x_alloc_tx_queue(args->netdev, &args->queueid,
					    &args->queue_mapping);

	else if (args->type == VMKNETDDI_QUEUEOPS_QUEUE_TYPE_RX)
		return bnx2x_alloc_rx_queue(args->netdev, &args->queueid,
					    &args->napi);
	else {
		struct bnx2x *bp = netdev_priv(args->netdev);

		DP(BNX2X_MSG_NETQ, "invalid queue type: %x\n", args->queueid);
		return VMKNETDDI_QUEUEOPS_ERR;
	}
}

#if (VMWARE_ESX_DDK_VERSION >= 41000)

static int
bnx2x_alloc_rx_queue_with_lro(struct net_device *netdev,
				vmknetddi_queueops_queueid_t *p_qid,
				struct napi_struct **napi_p)
{
	int i;
	struct bnx2x *bp;

	if (!netdev || !p_qid || !napi_p) {
		printk(KERN_ERR "bnx2x_alloc_rx_queue_with_lro: "
			"Invalid parameters! netdev(%p) p_qid(%p) napi_p(%p)\n",
			netdev, p_qid, napi_p);
		return VMKNETDDI_QUEUEOPS_ERR;
	}

	bp = netdev_priv(netdev);
	if (bp->n_rx_queues_allocated >= BNX2X_NUM_QUEUES(bp)) {
		BNX2X_ERR("NetQ RX Queue %d >= BNX2X_NUM_QUEUES(%d)\n",
			  bp->n_rx_queues_allocated, BNX2X_NUM_QUEUES(bp));
		return VMKNETDDI_QUEUEOPS_ERR;
	}

	for_each_net_queue(bp, i) {
		struct bnx2x_fastpath *fp = &bp->fp[i];
		/* if this Rx queue is not used */
		if (!BNX2X_IS_NETQ_RX_QUEUE_ALLOCATED(fp) &&
				BNX2X_IS_NETQ_FP_FEAT_LRO_RESERVED(fp)) {
			fp->netq_flags |= BNX2X_NETQ_RX_QUEUE_ALLOCATED;
			bp->n_rx_queues_allocated++;
			*p_qid = VMKNETDDI_QUEUEOPS_MK_RX_QUEUEID(fp->index);
			*napi_p = &fp->napi;
			 DP(BNX2X_MSG_NETQ,
			    "RX NetQ allocated on %d with LRO feature\n", i);
			return VMKNETDDI_QUEUEOPS_OK;
		}
	}
	DP(BNX2X_MSG_NETQ, "no free rx queues with LRO feature found!\n");
	return VMKNETDDI_QUEUEOPS_ERR;
}

#if (VMWARE_ESX_DDK_VERSION >= 50000)
#define BNX2X_NETQ_SUPPORTED_FEATURES \
	(VMKNETDDI_QUEUEOPS_QUEUE_FEAT_PAIR | \
	((bp->flags & TPA_ENABLE_FLAG) ? VMKNETDDI_QUEUEOPS_QUEUE_FEAT_LRO : 0))
#else
#define BNX2X_NETQ_SUPPORTED_FEATURES \
	((bp->flags & TPA_ENABLE_FLAG) ? VMKNETDDI_QUEUEOPS_QUEUE_FEAT_LRO : 0)
#endif
/*
 * bnx2x_alloc_queue_with_attr - Alloc queue with NETQ features.
 *
 */
static int
bnx2x_alloc_queue_with_attr(
			vmknetddi_queueop_alloc_queue_with_attr_args_t *args)
{
	int i;
	struct bnx2x *bp = netdev_priv(args->netdev);
	vmknetddi_queueops_queue_features_t feat;

	if (!args->attr || !args->nattr) {
		BNX2X_ERR("Attributes are invalid! attr(%p), nattr(%d).\n",
			args->attr, args->nattr);
		return VMKNETDDI_QUEUEOPS_ERR;
	}

	DP(BNX2X_MSG_NETQ, "Attributes number: %d\n", args->nattr);
	for (i = 0; i < args->nattr; i++) {
		DP(BNX2X_MSG_NETQ, "Attribute[%d] type: 0x%x\n",
				i, args->attr[i].type);
		switch (args->attr[i].type) {
		case VMKNETDDI_QUEUEOPS_QUEUE_ATTR_PRIOR:
			/* Nothing to do */
			BNX2X_ERR("VMKNETDDI_QUEUEOPS_QUEUE_ATTR_PRIOR "
				"isn't supported now.\n");
			break;
		case VMKNETDDI_QUEUEOPS_QUEUE_ATTR_FEAT:
			feat = args->attr[i].args.features;
			DP(BNX2X_MSG_NETQ, "Features 0x%x needed.\n", feat);

			/* Unsupported features */
			if (feat & ~BNX2X_NETQ_SUPPORTED_FEATURES) {
				BNX2X_ERR("Failed... "
					"unsupported feature 0x%x\n",
					feat & ~BNX2X_NETQ_SUPPORTED_FEATURES);
				return VMKNETDDI_QUEUEOPS_ERR;
			}

			if (feat & VMKNETDDI_QUEUEOPS_QUEUE_FEAT_LRO) {
				if (args->type !=
					    VMKNETDDI_QUEUEOPS_QUEUE_TYPE_RX) {
					BNX2X_ERR("Invalid queue type, "
						"LRO feature is only "
						"for RX queue\n");
					break;
				}
				return bnx2x_alloc_rx_queue_with_lro(
						args->netdev, &args->queueid,
						&args->napi);
			}

			/* No feature isn't allowed */
			if (!feat)
				BNX2X_ERR("Invalid feature: "
						"features is NONE!\n");
			break;
		default:
			BNX2X_ERR("Invalid attribute type\n");
			return VMKNETDDI_QUEUEOPS_ERR;
			break;
		}
	}
	BNX2X_ERR("No queue is allocated.\n");
	return VMKNETDDI_QUEUEOPS_ERR;
}

static int
bnx2x_get_supported_feature(vmknetddi_queueop_get_sup_feat_args_t *args)
{
	struct bnx2x *bp = netdev_priv(args->netdev);

	args->features = BNX2X_NETQ_SUPPORTED_FEATURES;
#if (VMWARE_ESX_DDK_VERSION >= 50000)
	DP(BNX2X_MSG_NETQ, "Netq features supported: %s %s %s\n",
	     (args->features & VMKNETDDI_QUEUEOPS_QUEUE_FEAT_LRO) ? "LRO" : "",
	     (args->features & VMKNETDDI_QUEUEOPS_QUEUE_FEAT_PAIR) ? "PAIR" : "",
	     (args->features) ? "" : "NONE"
	     );
#else
	DP(BNX2X_MSG_NETQ, "Netq features supported: %s %s\n",
	     (args->features & VMKNETDDI_QUEUEOPS_QUEUE_FEAT_LRO) ? "LRO" : "",
	     (args->features) ? "" : "NONE"
	     );
#endif

	return VMKNETDDI_QUEUEOPS_OK;
}

#if (VMWARE_ESX_DDK_VERSION >= 50000)
static int
bnx2x_get_supported_filter_class(vmknetddi_queueop_get_sup_filter_class_args_t *args)
{
	args->class = VMKNETDDI_QUEUEOPS_FILTER_MACADDR;

	return VMKNETDDI_QUEUEOPS_OK;
}
#endif
#endif

static int bnx2x_free_tx_queue(struct net_device *netdev,
			       vmknetddi_queueops_queueid_t qid)
{
	struct bnx2x *bp = netdev_priv(netdev);
	u16 index = VMKNETDDI_QUEUEOPS_QUEUEID_VAL(qid);
	struct bnx2x_fastpath *fp;

	if (!bnx2x_netq_valid_qid(bp, index))
		return VMKNETDDI_QUEUEOPS_ERR;

	fp = &bp->fp[index];

	if (!BNX2X_IS_NETQ_TX_QUEUE_ALLOCATED(fp)) {
		DP(BNX2X_MSG_NETQ, "NetQ TX Queue %d is not allocated\n",
		   index);
		return VMKNETDDI_QUEUEOPS_ERR;
	}

	fp->netq_flags &= ~BNX2X_NETQ_TX_QUEUE_ALLOCATED;
	if (bp->n_tx_queues_allocated)
		bp->n_tx_queues_allocated--;

	DP(BNX2X_MSG_NETQ, "Free NetQ TX Queue: %x\n", index);

	return VMKNETDDI_QUEUEOPS_OK;
}

static inline void bnx2x_netq_free_rx_queue(struct bnx2x *bp,
					    struct bnx2x_fastpath *fp)
{
	fp->netq_flags &= ~BNX2X_NETQ_RX_QUEUE_ALLOCATED;

	if (bp->n_rx_queues_allocated)
		bp->n_rx_queues_allocated--;
}

static int bnx2x_free_rx_queue(struct net_device *netdev,
			       vmknetddi_queueops_queueid_t qid)
{
	struct bnx2x *bp = netdev_priv(netdev);
	u16 index = VMKNETDDI_QUEUEOPS_QUEUEID_VAL(qid);
	struct bnx2x_fastpath *fp;

	if (!bnx2x_netq_valid_qid(bp, index)) {
		DP(BNX2X_MSG_NETQ, "NetQ RX Queue %d is invalid\n", index);
		return VMKNETDDI_QUEUEOPS_ERR;
	}

	fp = &bp->fp[index];

	if (!BNX2X_IS_NETQ_RX_QUEUE_ALLOCATED(fp)) {
		DP(BNX2X_MSG_NETQ, "NetQ RX Queue %d is not allocated\n",
		   index);
		return VMKNETDDI_QUEUEOPS_ERR;
	}

	bnx2x_netq_free_rx_queue(bp, fp);
	DP(BNX2X_MSG_NETQ, "Free NetQ RX Queue: %x\n", index);

	return VMKNETDDI_QUEUEOPS_OK;
}

static int bnx2x_free_queue(vmknetddi_queueop_free_queue_args_t *args)
{
	if (VMKNETDDI_QUEUEOPS_IS_TX_QUEUEID(args->queueid))
		return bnx2x_free_tx_queue(args->netdev, args->queueid);

	else if (VMKNETDDI_QUEUEOPS_IS_RX_QUEUEID(args->queueid))
		return bnx2x_free_rx_queue(args->netdev, args->queueid);

	else {
		struct net_device *netdev = args->netdev;
		struct bnx2x *bp = netdev_priv(netdev);

		DP(BNX2X_MSG_NETQ, "invalid queue type: %x\n", args->queueid);
		return VMKNETDDI_QUEUEOPS_ERR;
	}
}

static int bnx2x_get_queue_vector(vmknetddi_queueop_get_queue_vector_args_t *args)
{
	struct net_device *netdev = args->netdev;
	struct bnx2x *bp = netdev_priv(netdev);
	int qid;

	qid = VMKNETDDI_QUEUEOPS_QUEUEID_VAL(args->queueid);

	/* may be invoked also for the default queue */
	if (qid > BNX2X_NUM_NETQUEUES(bp)) {
		DP(BNX2X_MSG_NETQ, "NetQ Queue %d is invalid\n", qid);
		return VMKNETDDI_QUEUEOPS_ERR;
	}

	/*
	 * msix_table indices:
	 * 0 - default SB (slow-path operations)
	 * 1 - CNIC fast-path operations (if compiled in)
	 * 2 - Max NetQs - Net-queues starting form the default queue
	 */
	qid += (1 + CNIC_PRESENT);

	args->vector = bp->msix_table[qid].vector;
	return VMKNETDDI_QUEUEOPS_OK;
}

static int bnx2x_get_default_queue(vmknetddi_queueop_get_default_queue_args_t *args)
{
	struct net_device *netdev = args->netdev;
	struct bnx2x *bp = netdev_priv(netdev);

	if (args->type == VMKNETDDI_QUEUEOPS_QUEUE_TYPE_RX) {
		args->queueid = VMKNETDDI_QUEUEOPS_MK_RX_QUEUEID(0);
		args->napi = &bp->fp[0].napi;
		return VMKNETDDI_QUEUEOPS_OK;

	} else if (args->type == VMKNETDDI_QUEUEOPS_QUEUE_TYPE_TX) {
		args->queueid = VMKNETDDI_QUEUEOPS_MK_TX_QUEUEID(0);
		args->queue_mapping = 0;
		return VMKNETDDI_QUEUEOPS_OK;

	} else
		return VMKNETDDI_QUEUEOPS_ERR;
}


static inline int bnx2x_netq_set_mac_one(u8 *mac, struct bnx2x *bp,
					 struct bnx2x_fastpath *fp, bool add)
{
	unsigned long ramrod_flags = 0;

	set_bit(RAMROD_COMP_WAIT, &ramrod_flags);

	return bnx2x_set_mac_one(bp, mac, &fp->mac_obj, add,
				 BNX2X_NETQ_ETH_MAC, &ramrod_flags);
}

static int bnx2x_netq_remove_rx_filter(struct bnx2x *bp,
				       struct bnx2x_fastpath *fp, u16 fid)
{
	unsigned long ramrod_flags = 0;
	struct bnx2x_queue_state_params qstate = {0};
	u8 *macaddr;
	int is_last_mac_filter, rc;
	DECLARE_MAC_BUF(mac);

	if (fid >= bp->number_of_mac_filters) {
		DP(BNX2X_MSG_NETQ, "Couldn't remove invalid RX filter %d "
		   "on NetQ RX Queue %d\n", fid, fp->index);
		return VMKNETDDI_QUEUEOPS_ERR;
	} else {
		if (fp->mac_filters == NULL) {
			DP(BNX2X_MSG_NETQ, "Error Freeing RX filter "
					   "with empty RX MAC filter table\n");
			return VMKNETDDI_QUEUEOPS_ERR;
		}

		macaddr = fp->mac_filters[fid].mac;

		DP(BNX2X_MSG_NETQ, "NetQ remove RX filter: queue:%d mac:%s "
		   "filter id:%d]\n",
		   fp->index, print_mac(mac, macaddr), fid);
	}

	is_last_mac_filter = bnx2x_is_last_rx_mac_filter(fp);

	/* clear MAC */

	/* set to drop-all*/
	if (is_last_mac_filter) {
		set_bit(RAMROD_RX, &ramrod_flags);
		set_bit(RAMROD_TX, &ramrod_flags);
		set_bit(RAMROD_COMP_WAIT, &ramrod_flags);
		rc = bnx2x_set_q_rx_mode(bp, fp->cl_id, 0, 0, 0, ramrod_flags);

		if (rc) {
			BNX2X_ERR("NetQ could not remove RX filter, "
				  "rx mode failed: queue:%d mac:%s "
				  "filter id:%d]\n",
				  fp->index, print_mac(mac, macaddr), fid);
			return VMKNETDDI_QUEUEOPS_ERR;
		}
	}

	/* delete MAC */
	rc = bnx2x_netq_set_mac_one(macaddr, bp, fp, 0);
	if (rc) {
		BNX2X_ERR("NetQ could not remove RX filter: queue:%d mac:%s "
			  "filter id:%d]\n",
			  fp->index, print_mac(mac, macaddr), fid);
		return VMKNETDDI_QUEUEOPS_ERR;
	}

	/* send empty-ramrod to flush packets lurking in the HW */
	qstate.q_obj = &fp->q_obj;
	ramrod_flags = 0;
	set_bit(RAMROD_COMP_WAIT, &ramrod_flags);
	qstate.ramrod_flags = ramrod_flags; /* wait for completion */
	qstate.cmd = BNX2X_Q_CMD_EMPTY;
	if (bnx2x_queue_state_change(bp, &qstate)) {
		BNX2X_ERR("RX %d queue state not changed for fid: %d\n",
			  fp->index, fid);
		return VMKNETDDI_QUEUEOPS_ERR;
	}
	bnx2x_remove_rx_mac_filter(bp, fp, fid, is_last_mac_filter);

	return VMKNETDDI_QUEUEOPS_OK;
}

static int bnx2x_remove_rx_filter(vmknetddi_queueop_remove_rx_filter_args_t *args)
{
	struct bnx2x *bp = netdev_priv(args->netdev);
	u16 qid = VMKNETDDI_QUEUEOPS_QUEUEID_VAL(args->queueid);
	u16 fid = VMKNETDDI_QUEUEOPS_FILTERID_VAL(args->filterid);
	struct bnx2x_fastpath *fp = &bp->fp[qid];
	int rc;

	if (!VMKNETDDI_QUEUEOPS_IS_RX_QUEUEID(args->queueid)) {
		BNX2X_ERR("Queue ID %d is not RX queue\n", args->queueid);
		return VMKNETDDI_QUEUEOPS_ERR;
	}

	/* not invoked for the default queue */
	if (!bnx2x_netq_valid_qid(bp, qid)) {
		DP(BNX2X_MSG_NETQ, "NetQ RX Queue %d is invalid\n", qid);
		return VMKNETDDI_QUEUEOPS_ERR;
	}

	/* Verfiy the queue is allocated and has an active filter */
	if (!BNX2X_IS_NETQ_RX_QUEUE_ACTIVE(fp) ||
	    !BNX2X_IS_NETQ_RX_QUEUE_ALLOCATED(fp)) {
		DP(BNX2X_MSG_NETQ, "NetQ RX Queue %d is not allocated/active "
				   "0x%x\n", qid, fp->netq_flags);
		return VMKNETDDI_QUEUEOPS_ERR;
	}

	/* Do the work */
	rc = bnx2x_netq_remove_rx_filter(bp, fp, fid);
	if (!rc)
		DP(BNX2X_MSG_NETQ, "NetQ %d remove RX filter %d\n", qid, fid);

	return rc;
}


static int bnx2x_apply_rx_filter(vmknetddi_queueop_apply_rx_filter_args_t *args)
{
	u8 *macaddr;
	struct bnx2x *bp = netdev_priv(args->netdev);
	struct bnx2x_fastpath *fp;
	u16 qid = VMKNETDDI_QUEUEOPS_QUEUEID_VAL(args->queueid);
	u16 vlan_id;
	unsigned long accept_flags = 0, ramrod_flags = 0;
	int filter_id, rc;

	vmknetddi_queueops_filter_class_t filter;
	DECLARE_MAC_BUF(mac);

	if (!VMKNETDDI_QUEUEOPS_IS_RX_QUEUEID(args->queueid)) {
		BNX2X_ERR("Queue ID %d is not RX queue\n", args->queueid);
		return VMKNETDDI_QUEUEOPS_ERR;
	}

	filter = vmknetddi_queueops_get_filter_class(&args->filter);
	if (filter != VMKNETDDI_QUEUEOPS_FILTER_MACADDR) {
		BNX2X_ERR("Queue filter %x not MACADDR filter\n", filter);
		return VMKNETDDI_QUEUEOPS_ERR;
	}

	/* not invoked for the default queue */
	if (!bnx2x_netq_valid_qid(bp, qid)) {
		DP(BNX2X_MSG_NETQ, "NetQ RX Queue %d is invalid\n", qid);
		return VMKNETDDI_QUEUEOPS_ERR;
	}

	fp = &bp->fp[qid];

	if (!BNX2X_IS_NETQ_RX_QUEUE_ALLOCATED(fp)) {
		BNX2X_ERR("Trying to apply filter on non allocated Queue %d\n",
			  qid);
		return VMKNETDDI_QUEUEOPS_ERR;
	}

	macaddr = (void *)vmknetddi_queueops_get_filter_macaddr(&args->filter);
	vlan_id = vmknetddi_queueops_get_filter_vlanid(&args->filter);

	filter_id = bnx2x_find_rx_mac_filter_add(bp, fp, macaddr);
	if (filter_id < 0) {
		BNX2X_ERR("NetQ could not add RX filter, no filters "
			  "avaliable: queue:%d mac:%s "
			  "vlan id:%d]\n",
			   qid, print_mac(mac, macaddr), vlan_id);
		return VMKNETDDI_QUEUEOPS_ERR;
	}

	if (bnx2x_num_active_rx_mac_filters(fp) == 1) {
		/* set to recv-unicast */
		set_bit(BNX2X_ACCEPT_UNICAST, &accept_flags);
		set_bit(BNX2X_ACCEPT_ANY_VLAN, &accept_flags);
		set_bit(RAMROD_RX, &ramrod_flags);
		set_bit(RAMROD_TX, &ramrod_flags);
		set_bit(RAMROD_COMP_WAIT, &ramrod_flags);
		rc = bnx2x_set_q_rx_mode(bp, fp->cl_id, 0, accept_flags,
					 accept_flags, ramrod_flags);

		if (rc) {
			BNX2X_ERR("NetQ could not add RX filter, "
				  " rx mode failed: queue:%d mac:%s "
				  "vlan id:%d filter id:%d]\n",
				   qid, print_mac(mac, macaddr), vlan_id,
				  filter_id);
			return VMKNETDDI_QUEUEOPS_ERR;
		}
	}

	/* add MAC */
	rc = bnx2x_netq_set_mac_one(macaddr, bp, fp, 1);
	if (rc) {
		BNX2X_ERR("NetQ could not add RX filter: queue:%d mac:%s "
			  "vlan id:%d filter id:%d]\n",
			   qid, print_mac(mac, macaddr), vlan_id, filter_id);
		bnx2x_clear_rx_mac_entry(&fp->mac_filters[filter_id]);
		return VMKNETDDI_QUEUEOPS_ERR;
	}

	fp->netq_flags |= BNX2X_NETQ_RX_QUEUE_ACTIVE;
	args->filterid = VMKNETDDI_QUEUEOPS_MK_FILTERID(filter_id);
#if (VMWARE_ESX_DDK_VERSION >= 50000)
	/* Need by feature: VMKNETDDI_QUEUEOPS_FEATURE_PAIRQUEUE  */
	args->pairtxqid = qid;
#endif
	DP(BNX2X_MSG_NETQ, "NetQ set RX filter: queue:%d mac:%s "
			   "vlan id:%d filter id:%d]\n",
	   qid, print_mac(mac, macaddr), vlan_id, filter_id);

	return VMKNETDDI_QUEUEOPS_OK;
}

static int bnx2x_get_queue_stats(vmknetddi_queueop_get_stats_args_t *args)
{
	return VMKNETDDI_QUEUEOPS_ERR;
}

static int bnx2x_get_netqueue_version(vmknetddi_queueop_get_version_args_t *args)
{
	return vmknetddi_queueops_version(args);
}


void bnx2x_netq_clear_rx_queues(struct bnx2x *bp)
{
	int i;

	spin_lock(&bp->netq_lock);

	for_each_net_queue(bp, i) {
		struct bnx2x_fastpath *fp = &bp->fp[i];

		if (BNX2X_IS_NETQ_RX_QUEUE_ACTIVE(fp)) {
			int j;

			for (j = 0; j < bp->number_of_mac_filters; j++)
				if (fp->mac_filters != NULL &&
				    BNX2X_IS_NETQ_RX_FILTER_ACTIVE(fp, j))
					bnx2x_netq_remove_rx_filter(bp, fp, j);
		}

		if (BNX2X_IS_NETQ_RX_QUEUE_ALLOCATED(fp))
			bnx2x_netq_free_rx_queue(bp, fp);
	}

	spin_unlock(&bp->netq_lock);
}

int bnx2x_netqueue_ops(vmknetddi_queueops_op_t op, void *args)
{
	vmknetddi_queueop_get_queue_count_args_t *p;
	struct bnx2x *bp;
	int rc = VMKNETDDI_QUEUEOPS_ERR;

	if (op == VMKNETDDI_QUEUEOPS_OP_GET_VERSION)
		return bnx2x_get_netqueue_version(
			(vmknetddi_queueop_get_version_args_t *)args);
	else if(op == VMKNETDDI_QUEUEOPS_OP_GET_FEATURES)
		return bnx2x_get_netqueue_features(
			(vmknetddi_queueop_get_features_args_t *)args);

	p = (vmknetddi_queueop_get_queue_count_args_t *)args;
	bp = netdev_priv(p->netdev);

	spin_lock(&bp->netq_lock);

	switch (op) {
	case VMKNETDDI_QUEUEOPS_OP_GET_QUEUE_COUNT:
		rc = bnx2x_get_queue_count(
			(vmknetddi_queueop_get_queue_count_args_t *)args);
		break;

	case VMKNETDDI_QUEUEOPS_OP_GET_FILTER_COUNT:
		rc = bnx2x_get_filter_count(
			(vmknetddi_queueop_get_filter_count_args_t *)args);
		break;

	case VMKNETDDI_QUEUEOPS_OP_ALLOC_QUEUE:
		rc = bnx2x_alloc_queue(
			(vmknetddi_queueop_alloc_queue_args_t *)args);
		break;

	case VMKNETDDI_QUEUEOPS_OP_FREE_QUEUE:
		rc = bnx2x_free_queue(
			(vmknetddi_queueop_free_queue_args_t *)args);
		break;

	case VMKNETDDI_QUEUEOPS_OP_GET_QUEUE_VECTOR:
		rc = bnx2x_get_queue_vector(
			(vmknetddi_queueop_get_queue_vector_args_t *)args);
		break;

	case VMKNETDDI_QUEUEOPS_OP_GET_DEFAULT_QUEUE:
		rc = bnx2x_get_default_queue(
			(vmknetddi_queueop_get_default_queue_args_t *)args);
		break;

	case VMKNETDDI_QUEUEOPS_OP_APPLY_RX_FILTER:
		rc = bnx2x_apply_rx_filter(
			(vmknetddi_queueop_apply_rx_filter_args_t *)args);
		break;

	case VMKNETDDI_QUEUEOPS_OP_REMOVE_RX_FILTER:
		rc = bnx2x_remove_rx_filter(
			(vmknetddi_queueop_remove_rx_filter_args_t *)args);
		break;

	case VMKNETDDI_QUEUEOPS_OP_GET_STATS:
		rc = bnx2x_get_queue_stats(
			(vmknetddi_queueop_get_stats_args_t *)args);
		break;

#if (VMWARE_ESX_DDK_VERSION >= 41000)
	case VMKNETDDI_QUEUEOPS_OP_ALLOC_QUEUE_WITH_ATTR:
		rc = bnx2x_alloc_queue_with_attr(
			(vmknetddi_queueop_alloc_queue_with_attr_args_t *)args);
		break;

	case VMKNETDDI_QUEUEOPS_OP_GET_SUPPORTED_FEAT:
		rc = bnx2x_get_supported_feature(
			(vmknetddi_queueop_get_sup_feat_args_t *)args);
		break;
#if (VMWARE_ESX_DDK_VERSION >= 50000)
	case VMKNETDDI_QUEUEOPS_OP_GET_SUPPORTED_FILTER_CLASS:
		rc = bnx2x_get_supported_filter_class(
			(vmknetddi_queueop_get_sup_filter_class_args_t *)args);
		break;
#endif
#endif

	default:
		printk("Unhandled NETQUEUE OP %d\n", op);
		rc = VMKNETDDI_QUEUEOPS_ERR;
	}

	spin_unlock(&bp->netq_lock);

	return rc;
}

#endif /* BNX2X_NETQ */

#if defined(BNX2X_ESX_CNA) /* ! BNX2X_UPSTREAM */
static int bnx2x_cna_get_queue_count(
	vmknetddi_queueop_get_queue_count_args_t *args)
{
	struct net_device *netdev = args->netdev;
	struct bnx2x *bp = netdev->priv;

	if (args->type == VMKNETDDI_QUEUEOPS_QUEUE_TYPE_RX) {
		args->count = 2;
		return VMKNETDDI_QUEUEOPS_OK;

	} else if (args->type == VMKNETDDI_QUEUEOPS_QUEUE_TYPE_TX) {
		args->count = 2;
		return VMKNETDDI_QUEUEOPS_OK;

	} else {
		DP(BNX2X_MSG_NETQ, "invalid queue type: %x\n", args->type);
		return VMKNETDDI_QUEUEOPS_ERR;
	}
}
static int bnx2x_cna_alloc_rx_queue(struct net_device *netdev,
				    vmknetddi_queueops_queueid_t *p_qid,
				    struct napi_struct **napi_p)
{
	struct bnx2x *bp = netdev->priv;
	struct bnx2x_fastpath *fp = bnx2x_fcoe_fp(bp);

	if (!BNX2X_IS_NETQ_RX_QUEUE_ALLOCATED(fp)) {
		napi_synchronize(&bnx2x_fcoe(bp, napi));

		fp->netq_flags |= BNX2X_NETQ_RX_QUEUE_ALLOCATED;
		*p_qid = VMKNETDDI_QUEUEOPS_MK_RX_QUEUEID(1);
		*napi_p = &fp->napi;

		DP(BNX2X_MSG_NETQ, "RX CNA NetQ allocated on %d\n", 1);
		return VMKNETDDI_QUEUEOPS_OK;
	}

	DP(BNX2X_MSG_NETQ, "No free CNA rx queues found!\n");
	return VMKNETDDI_QUEUEOPS_ERR;
}

static int bnx2x_cna_get_filter_count(vmknetddi_queueop_get_filter_count_args_t *args)
{
	args->count = 2;
	return VMKNETDDI_QUEUEOPS_OK;
}

static int bnx2x_cna_alloc_tx_queue(struct net_device *netdev,
				    vmknetddi_queueops_queueid_t *p_qid,
				    u16 *queue_mapping)
{
	struct bnx2x *bp = netdev->priv;
	struct bnx2x_fastpath *fp = bnx2x_fcoe_fp(bp);

	if (!BNX2X_IS_NETQ_TX_QUEUE_ALLOCATED(fp)) {
		fp->netq_flags |= BNX2X_NETQ_TX_QUEUE_ALLOCATED;

		/*  TODO determine remapping */
		*p_qid = VMKNETDDI_QUEUEOPS_MK_TX_QUEUEID(1);
		*queue_mapping = 1;

		/* Start Tx */
		netif_tx_start_all_queues(netdev);

		DP(BNX2X_MSG_NETQ, "CNA NetQ TX Queue ID %d Mapping: %d\n",
			*p_qid, *queue_mapping);

		return VMKNETDDI_QUEUEOPS_OK;
	}

	DP(BNX2X_MSG_NETQ, "No free tx queues for CNA device found!\n");
	return VMKNETDDI_QUEUEOPS_ERR;
}

static int bnx2x_cna_alloc_queue(vmknetddi_queueop_alloc_queue_args_t *args)
{
	struct bnx2x *bp;

	if (args->netdev->features & NETIF_F_CNA)
		bp = args->netdev->priv;
	else
		bp = netdev_priv(args->netdev);

	if (args->type == VMKNETDDI_QUEUEOPS_QUEUE_TYPE_TX) {
		return bnx2x_cna_alloc_tx_queue(args->netdev, &args->queueid,
						&args->queue_mapping);

	} else if (args->type == VMKNETDDI_QUEUEOPS_QUEUE_TYPE_RX) {
		return bnx2x_cna_alloc_rx_queue(args->netdev, &args->queueid,
						&args->napi);
	} else {
		DP(BNX2X_MSG_NETQ, "invalid queue type: %x\n", args->queueid);
		return VMKNETDDI_QUEUEOPS_ERR;
	}
}

static int bnx2x_cna_free_tx_queue(struct net_device *netdev,
			       vmknetddi_queueops_queueid_t qid)
{
	struct bnx2x *bp = netdev->priv;
	struct bnx2x_fastpath *fp = bnx2x_fcoe_fp(bp);

	if (!BNX2X_IS_NETQ_TX_QUEUE_ALLOCATED(fp)) {
		DP(BNX2X_MSG_NETQ, "CNA NetQ TX Queue is not allocated\n");
		return VMKNETDDI_QUEUEOPS_ERR;
	}

	fp->netq_flags &= ~BNX2X_NETQ_TX_QUEUE_ALLOCATED;

	/* Stop TX */
	netif_tx_disable(netdev);
	netif_carrier_off(netdev);

	DP(BNX2X_MSG_NETQ, "Free CNA NetQ TX Queue\n");

	return VMKNETDDI_QUEUEOPS_OK;
}

static int bnx2x_cna_free_rx_queue(struct net_device *netdev,
				   vmknetddi_queueops_queueid_t qid)
{
	struct bnx2x *bp = netdev->priv;
	u16 index = VMKNETDDI_QUEUEOPS_QUEUEID_VAL(qid);
	struct bnx2x_fastpath *fp = bnx2x_fcoe_fp(bp);

	if (!BNX2X_IS_NETQ_RX_QUEUE_ALLOCATED(fp)) {
		DP(BNX2X_MSG_NETQ, "CNA NetQ RX Queue is not allocated\n");
		return VMKNETDDI_QUEUEOPS_ERR;
	}

	bnx2x_netq_free_rx_queue(bp, fp);

	DP(BNX2X_MSG_NETQ, "Free CNA NetQ RX Queue: %x\n", index);

	return VMKNETDDI_QUEUEOPS_OK;
}

static int bnx2x_cna_free_queue(vmknetddi_queueop_free_queue_args_t *args)
{
	if (VMKNETDDI_QUEUEOPS_IS_TX_QUEUEID(args->queueid))
		return bnx2x_cna_free_tx_queue(args->netdev, args->queueid);

	else if (VMKNETDDI_QUEUEOPS_IS_RX_QUEUEID(args->queueid))
		return bnx2x_cna_free_rx_queue(args->netdev, args->queueid);

	else {
		struct net_device *netdev = args->netdev;
		struct bnx2x *bp = netdev_priv(netdev);

		DP(BNX2X_MSG_NETQ, "invalid queue type: %x\n", args->queueid);
		return VMKNETDDI_QUEUEOPS_ERR;
	}
}

static int bnx2x_cna_get_queue_vector(vmknetddi_queueop_get_queue_vector_args_t *args)
{
	struct net_device *netdev = args->netdev;
	struct bnx2x *bp = netdev->priv;
	int qid;

	qid = VMKNETDDI_QUEUEOPS_QUEUEID_VAL(args->queueid);

	/* may be invoked also for the default queue */
	if (qid > BNX2X_NUM_NETQUEUES(bp)) {
		DP(BNX2X_MSG_NETQ, "NetQ Queue %d is invalid\n", qid);
		return VMKNETDDI_QUEUEOPS_ERR;
	}

	/*
	 * msix_table indices:
	 * 0 - default SB (slow-path operations)
	 * 1 - CNIC fast-path operations (if compiled in)
	 * 2 - Max NetQs - Net-queues starting form the default queue
	 */
	qid += (1 + CNIC_PRESENT);

	args->vector = bp->msix_table[qid].vector;
	return VMKNETDDI_QUEUEOPS_OK;
}

static int bnx2x_cna_get_default_queue(vmknetddi_queueop_get_default_queue_args_t *args)
{
	struct bnx2x *bp = args->netdev->priv;

	if (args->type == VMKNETDDI_QUEUEOPS_QUEUE_TYPE_RX) {
		args->queueid = VMKNETDDI_QUEUEOPS_MK_RX_QUEUEID(0);
		args->napi = &bp->fp[0].napi;
		return VMKNETDDI_QUEUEOPS_OK;

	} else if (args->type == VMKNETDDI_QUEUEOPS_QUEUE_TYPE_TX) {
		args->queueid = VMKNETDDI_QUEUEOPS_MK_TX_QUEUEID(0);
		args->queue_mapping = 0;
		return VMKNETDDI_QUEUEOPS_OK;

	} else
		return VMKNETDDI_QUEUEOPS_ERR;
}

static int bnx2x_cna_remove_rx_filter(
	vmknetddi_queueop_remove_rx_filter_args_t *args)
{
	struct bnx2x *bp = args->netdev->priv;
	u16 qid = VMKNETDDI_QUEUEOPS_QUEUEID_VAL(args->queueid);
	struct bnx2x_fastpath *fp = bnx2x_fcoe_fp(bp);
	struct bnx2x_queue_state_params qstate = {0};
	unsigned long sp_bits = 0;

	if (!VMKNETDDI_QUEUEOPS_IS_RX_QUEUEID(args->queueid)) {
		BNX2X_ERR("Queue ID %d is not RX queue\n",
			  args->queueid);
		return VMKNETDDI_QUEUEOPS_ERR;
	}

	/* Verfiy the queue is allocated and has an active filter */
	if (!BNX2X_IS_NETQ_RX_QUEUE_ACTIVE(fp) ||
	    !BNX2X_IS_NETQ_RX_QUEUE_ALLOCATED(fp)) {
		DP(BNX2X_MSG_NETQ, "NetQ RX Queue %d is not allocated/active "
				   "0x%x\n", qid, fp->netq_flags);
		return VMKNETDDI_QUEUEOPS_ERR;
	}

	/* Stop receiving */
	netif_addr_lock_bh(bp->dev);
	bnx2x_set_fcoe_eth_rx_mode(bp, false);
	netif_addr_unlock_bh(bp->dev);

	/* bits to wait on */
	set_bit(BNX2X_FILTER_RX_MODE_PENDING, &sp_bits);
	set_bit(BNX2X_FILTER_FCOE_ETH_STOP_SCHED, &sp_bits);

	if (!bnx2x_wait_sp_comp(bp, sp_bits)) {
		BNX2X_ERR("rx_mode completion timed out!\n");
		return VMKNETDDI_QUEUEOPS_ERR;
	} else {
		/* send empty-ramrod to flush packets lurking in the HW */
		qstate.q_obj = &fp->q_obj;
		qstate.cmd = BNX2X_Q_CMD_EMPTY;
		/* wait for completion */
		set_bit(RAMROD_COMP_WAIT, &qstate.ramrod_flags);
		if (bnx2x_queue_state_change(bp, &qstate))
			return VMKNETDDI_QUEUEOPS_ERR;
	}

	DP(BNX2X_MSG_NETQ, "Free CNA NetQ RX Queue: %x\n", qid);
	return VMKNETDDI_QUEUEOPS_OK;
}

static int bnx2x_cna_apply_rx_filter(
	vmknetddi_queueop_apply_rx_filter_args_t *args)
{
	struct bnx2x *bp = args->netdev->priv;
	struct bnx2x_fastpath *fp;
	u16 qid = VMKNETDDI_QUEUEOPS_QUEUEID_VAL(args->queueid);
	unsigned long sp_bits = 0;

	fp = bnx2x_fcoe_fp(bp);

	fp->netq_flags |= BNX2X_NETQ_RX_QUEUE_ACTIVE;
	args->filterid = VMKNETDDI_QUEUEOPS_MK_FILTERID(0);

	/* Need by feature: VMKNETDDI_QUEUEOPS_FEATURE_PAIRQUEUE  */
	args->pairtxqid = qid;

	/* Start receiving */
	netif_addr_lock_bh(bp->dev);
	bnx2x_set_fcoe_eth_rx_mode(bp, true);
	netif_addr_unlock_bh(bp->dev);

	/* bits to wait on */
	set_bit(BNX2X_FILTER_RX_MODE_PENDING, &sp_bits);
	set_bit(BNX2X_FILTER_FCOE_ETH_START_SCHED, &sp_bits);

	if (!bnx2x_wait_sp_comp(bp, sp_bits))
		BNX2X_ERR("rx_mode completion timed out!\n");

	DP(BNX2X_MSG_NETQ, "NetQ set CNA RX filter\n");

	return VMKNETDDI_QUEUEOPS_OK;
}

int bnx2x_cna_netqueue_ops(vmknetddi_queueops_op_t op, void *args)
{
	vmknetddi_queueop_get_queue_count_args_t *p;
	struct bnx2x *bp;
	int rc = VMKNETDDI_QUEUEOPS_ERR;

	if (op == VMKNETDDI_QUEUEOPS_OP_GET_VERSION)
		return bnx2x_get_netqueue_version(
			(vmknetddi_queueop_get_version_args_t *)args);
	else if (op == VMKNETDDI_QUEUEOPS_OP_GET_FEATURES)
		return bnx2x_get_netqueue_features(
			(vmknetddi_queueop_get_features_args_t *)args);

	p = (vmknetddi_queueop_get_queue_count_args_t *)args;

	bp = p->netdev->priv;

	spin_lock(&bp->netq_lock);

	switch (op) {
	case VMKNETDDI_QUEUEOPS_OP_GET_QUEUE_COUNT:
		rc = bnx2x_cna_get_queue_count(
			(vmknetddi_queueop_get_queue_count_args_t *)args);
		break;

	case VMKNETDDI_QUEUEOPS_OP_GET_FILTER_COUNT:
		rc = bnx2x_cna_get_filter_count(
			(vmknetddi_queueop_get_filter_count_args_t *)args);
		break;

	case VMKNETDDI_QUEUEOPS_OP_ALLOC_QUEUE:
		rc = bnx2x_cna_alloc_queue(
			(vmknetddi_queueop_alloc_queue_args_t *)args);
		break;

	case VMKNETDDI_QUEUEOPS_OP_FREE_QUEUE:
		rc = bnx2x_cna_free_queue(
			(vmknetddi_queueop_free_queue_args_t *)args);
		break;

	case VMKNETDDI_QUEUEOPS_OP_GET_QUEUE_VECTOR:
		rc = bnx2x_cna_get_queue_vector(
			(vmknetddi_queueop_get_queue_vector_args_t *)args);
		break;

	case VMKNETDDI_QUEUEOPS_OP_GET_DEFAULT_QUEUE:
		rc = bnx2x_cna_get_default_queue(
			(vmknetddi_queueop_get_default_queue_args_t *)args);
		break;

	case VMKNETDDI_QUEUEOPS_OP_APPLY_RX_FILTER:
		rc = bnx2x_cna_apply_rx_filter(
			(vmknetddi_queueop_apply_rx_filter_args_t *)args);
		break;

	case VMKNETDDI_QUEUEOPS_OP_REMOVE_RX_FILTER:
		rc = bnx2x_cna_remove_rx_filter(
			(vmknetddi_queueop_remove_rx_filter_args_t *)args);
		break;

	case VMKNETDDI_QUEUEOPS_OP_GET_STATS:
		rc = bnx2x_get_queue_stats(
			(vmknetddi_queueop_get_stats_args_t *)args);
		break;

#if (VMWARE_ESX_DDK_VERSION >= 41000)
	case VMKNETDDI_QUEUEOPS_OP_ALLOC_QUEUE_WITH_ATTR:
		rc = VMKNETDDI_QUEUEOPS_ERR;
		break;

	case VMKNETDDI_QUEUEOPS_OP_GET_SUPPORTED_FEAT:
		rc = bnx2x_get_supported_feature(
			(vmknetddi_queueop_get_sup_feat_args_t *)args);
		break;


#endif

	default:
		printk(KERN_WARNING "Unhandled NETQUEUE OP %d\n", op);
		rc = VMKNETDDI_QUEUEOPS_ERR;
	}

	spin_unlock(&bp->netq_lock);

	return rc;
}
/* CNA related */
static int bnx2x_cna_open(struct net_device *cnadev)
{
	struct bnx2x *bp = cnadev->priv;
	strcpy(cnadev->name, bp->dev->name);

	netif_set_poll_cna(&bnx2x_fcoe(bp, napi));

	vmknetddi_queueops_invalidate_state(cnadev);

	if (BNX2X_IS_NETQ_TX_QUEUE_ALLOCATED(bnx2x_fcoe_fp(bp)))
		netif_tx_start_all_queues(cnadev);

	DP(NETIF_MSG_PROBE, "CNA pseudo device opened %s\n", cnadev->name);
	return 0;
}

static int bnx2x_cna_close(struct net_device *cnadev)
{
	struct bnx2x *bp = cnadev->priv;

	netif_tx_disable(cnadev);
	netif_carrier_off(cnadev);

	DP(NETIF_MSG_PROBE, "CNA pseudo device closed %s\n", cnadev->name);
	return 0;
}

static int bnx2x_cna_change_mtu(struct net_device *cnadev, int new_mtu)
{
	struct bnx2x *bp = cnadev->priv;

	if (cnadev->mtu == new_mtu)
		return 0;

	if ((new_mtu > ETH_MAX_JUMBO_PACKET_SIZE) ||
		((new_mtu + ETH_HLEN) < ETH_MIN_PACKET_SIZE))
		return -EINVAL;



	DP(BNX2X_MSG_SP,  "changing MTU from %d to %d\n",
		cnadev->mtu, new_mtu);

	/* must set new MTU before calling down or up */
	cnadev->mtu = new_mtu;

	return dev_close(cnadev) || dev_open(cnadev);
}

static inline int bnx2x_cna_set_vlan_stripping(struct bnx2x *bp, bool set)
{
	struct bnx2x_queue_state_params q_params = {0};
	struct bnx2x_queue_update_params *update_params =
		&q_params.params.update;
	int rc;
	struct bnx2x_fastpath *fp = bnx2x_fcoe_fp(bp);

	/* We want to wait for completion in this context */
	set_bit(RAMROD_COMP_WAIT, &q_params.ramrod_flags);

	/* Set the command */
	q_params.cmd = BNX2X_Q_CMD_UPDATE;

	/* Enable VLAN stripping if requested */
	if (set)
		set_bit(BNX2X_Q_UPDATE_IN_VLAN_REM,
			&update_params->update_flags);

	/* Indicate that VLAN stripping configuration has changed */
	set_bit(BNX2X_Q_UPDATE_IN_VLAN_REM_CHNG, &update_params->update_flags);

	/* Set the appropriate Queue object */
	q_params.q_obj = &fp->q_obj;

	/* Update the Queue state */
	rc = bnx2x_queue_state_change(bp, &q_params);
	if (rc) {
		BNX2X_ERR("Failed to configure VLAN stripping "
			  "for CNA FCoE ring\n");
		return rc;
	}

	return 0;
}

/* called with rtnl_lock */
static void bnx2x_cna_vlan_rx_register(struct net_device *dev,
				       struct vlan_group *vlgrp)
{
	struct bnx2x *bp = dev->priv;
	int rc;

	/* Configure VLAN stripping if NIC is up.
	 * Otherwise just set the bp->vlgrp and stripping will be
	 * configured in bnx2x_nic_load().
	 */
	if (bp->state == BNX2X_STATE_OPEN) {
		if (vlgrp != NULL) {
			rc = bnx2x_cna_set_vlan_stripping(bp, true);

			/* If we failed to configure VLAN stripping we don't
			 * want to use HW accelerated flow in bnx2x_rx_int().
			 * Thus we will leave bp->vlgrp to be equal to NULL to
			 * disable it.
			 */
			if (rc) {
				netdev_err(dev, "Failed to set HW "
						"VLAN stripping for a CNA "
						"device\n");
				bnx2x_cna_set_vlan_stripping(bp, false);
			} else
				bp->cna_vlgrp = vlgrp;
		} else {
			rc = bnx2x_cna_set_vlan_stripping(bp, false);

			if (rc)
				netdev_err(dev, "Failed to clear HW "
						"VLAN strippingfor a CNA "
						"device\n");

			bp->cna_vlgrp = NULL;
		}
	} else
		bp->cna_vlgrp = vlgrp;
}

static void bnx2x_cna_vlan_rx_add_vid(struct net_device *dev, uint16_t vid)
{
	struct bnx2x *bp = dev->priv;

	if (bp->cna_vlgrp)
		vlan_group_set_device(bp->cna_vlgrp, vid, dev);
}

static void bnx2x_cna_vlan_rx_kill_vid(struct net_device *dev, uint16_t vid)
{
	struct bnx2x *bp = dev->priv;

	if (bp->cna_vlgrp)
		vlan_group_set_device(bp->cna_vlgrp, vid, NULL);
}

/* TODO: think of a better name */
int bnx2x_cna_enable(struct bnx2x *bp, int tx_count, int rx_count)
{
	struct net_device *cnadev;
	struct net_device *netdev;
	int err;

	//u16 device_caps;
	if (NO_FCOE(bp))
		return -EINVAL;

	bp->flags |= CNA_ENABLED;

	netdev = bp->dev;

	/**
	 * Oppositely to regular net device, CNA device doesn't have
	 * a private allocated region as we don't want to duplicate
	 * bnx2x information. Though, the CNA device still need
	 * to access the bnx2x if FP. Thereby, cnadev->priv needs to
	 * point to netdev->priv.
	 */
	cnadev = alloc_etherdev_mqs(0, tx_count, rx_count);
	if (!cnadev) {
		err = -ENOMEM;
		goto err_alloc_etherdev;
	}
	bp->cnadev = cnadev;

	cnadev->priv = bp;

	cnadev->open             = &bnx2x_cna_open;
	cnadev->stop             = &bnx2x_cna_close;
	cnadev->change_mtu       = &bnx2x_cna_change_mtu;
	cnadev->do_ioctl         = netdev->do_ioctl;
	cnadev->hard_start_xmit  = netdev->hard_start_xmit;
#ifdef NETIF_F_HW_VLAN_TX
	cnadev->vlan_rx_register = bnx2x_cna_vlan_rx_register;
	cnadev->vlan_rx_add_vid  = bnx2x_cna_vlan_rx_add_vid;
	cnadev->vlan_rx_kill_vid = bnx2x_cna_vlan_rx_kill_vid;
#endif
	bnx2x_set_ethtool_ops(cnadev);

#ifdef CONFIG_DCB
	cnadev->dcbnl_ops = netdev->dcbnl_ops;
#endif

	cnadev->mtu = netdev->mtu;
	cnadev->pdev = netdev->pdev;
	cnadev->gso_max_size = GSO_MAX_SIZE;
	cnadev->features = netdev->features | NETIF_F_HWDCB | NETIF_F_CNA |
			   NETIF_F_HW_VLAN_FILTER;

	/* set the MAC address to SAN mac address */
	memcpy(cnadev->dev_addr, bp->fip_mac, ETH_ALEN);

	netif_carrier_off(cnadev);
	netif_tx_stop_all_queues(cnadev);

	VMKNETDDI_REGISTER_QUEUEOPS(cnadev, bnx2x_cna_netqueue_ops);

	netif_napi_add(bp->cnadev, &bnx2x_fp(bp, FCOE_IDX, napi),
		       bnx2x_poll, BNX2X_NAPI_WEIGHT);

	err = register_netdev(cnadev);
	if (err)
		goto err_register;

	DP(NETIF_MSG_PROBE, "CNA pseudo device registered %s\n", netdev->name);

	return err;

err_register:
	DP(NETIF_MSG_PROBE, "CNA pseudo device cannot be registered %s\n",
		netdev->name);
	free_netdev(cnadev);
err_alloc_etherdev:
	DP(NETIF_MSG_PROBE, "CNA cannot be enabled on %s\n", netdev->name);
	bp->flags &= ~CNA_ENABLED;
	return err;
}

void bnx2x_cna_disable(struct bnx2x *bp)
{
	struct net_device *cnadev = bp->cnadev;

	if (bp->flags & CNA_ENABLED) {
		bp->flags &= ~CNA_ENABLED;
		unregister_netdev(cnadev);
		DP(NETIF_MSG_PROBE, "CNA pseudo device unregistered %s\n",
			cnadev->name);

		free_netdev(cnadev);
		bp->cnadev = NULL;
	}
}
#endif
/*******************/


/*
 * NPA - Pass-Through
 */
#ifdef BCM_IOV

#include <linux/pci.h>
#include <linux/types.h>
#include <linux/netdevice.h>

#include "bnx2x_sriov.h"

#define BNX2X_UNREFERENCED(x)	(void)(x)
#define ENABLE_STR(en)		((en) ? "enable" : "disable")

#define VMK_RET(rc)				\
	((rc == 0) ? VMK_OK :			\
	 (rc == -ENOMEM) ? VMK_NO_MEMORY :	\
	 VMK_FAILURE)

/* useful wrappers */
inline int
bnx2x_vmk_pci_dev(struct bnx2x *bp, vmk_PCIDevice *vmkPfDev)
{
	struct pci_dev *pdev = bp->pdev;
	return (vmk_PCIGetPCIDevice(pci_domain_nr(pdev->bus),
				    pdev->bus->number,
				    PCI_SLOT(pdev->devfn),
				    PCI_FUNC(pdev->devfn),
				    vmkPfDev) != VMK_OK);
}

inline int
bnx2x_vmk_vf_pci_dev(struct bnx2x *bp, u16 abs_vfid, vmk_PCIDevice *vmkVfDev)
{
	vmk_PCIDevice vmkPfDev;

	if (bnx2x_vmk_pci_dev(bp, &vmkPfDev))
		return -1;

	return (vmk_PCIGetVFPCIDevice(vmkPfDev, abs_vfid, vmkVfDev) != VMK_OK);
}

inline int
bnx2x_vmk_pci_read_config_byte(vmk_PCIDevice dev, vmk_uint16 offset,
			       vmk_uint8 *val)
{
	vmk_uint32 val32;
	VMK_ReturnStatus vmkRet = vmk_PCIReadConfig(dev, VMK_PCI_CONFIG_ACCESS_8,
						    offset, &val32);
	*val = (vmk_uint8)val32;
	return vmkRet;

}

inline int
bnx2x_vmk_pci_read_config_word(vmk_PCIDevice dev, vmk_uint16 offset,
			       vmk_uint16 *val)
{
	vmk_uint32 val32;
	VMK_ReturnStatus vmkRet = vmk_PCIReadConfig(dev, VMK_PCI_CONFIG_ACCESS_16,
						    offset, &val32);
	*val = (vmk_uint16)val32;
	return vmkRet;

}

inline int
bnx2x_vmk_pci_read_config_dword(vmk_PCIDevice dev, vmk_uint16 offset,
			       vmk_uint32 *val)
{
	return vmk_PCIReadConfig(dev, VMK_PCI_CONFIG_ACCESS_32, offset, val);
}

/* Must be called only after VF-Enable*/
inline int
bnx2x_vmk_vf_bus(struct bnx2x *bp, int vfid)
{
	vmk_PCIDevice vfDev;
	u16 seg;
	u8 bus, slot, func;

	bnx2x_vmk_vf_pci_dev(bp, vfid, &vfDev);
	vmk_PCIGetSegmentBusDevFunc(vfDev, &seg, &bus, &slot, &func);
	return bus;
}

/* Must be called only after VF-Enable*/
inline int
bnx2x_vmk_vf_devfn(struct bnx2x *bp, int vfid)
{
	vmk_PCIDevice vfDev;
	u16 seg;
	u8 bus, slot, func;

	bnx2x_vmk_vf_pci_dev(bp, vfid, &vfDev);
	vmk_PCIGetSegmentBusDevFunc(vfDev, &seg, &bus, &slot, &func);
	return PCI_DEVFN(slot, func);
}

void
bnx2x_vmk_vf_set_bars(struct bnx2x *bp, struct bnx2x_virtf *vf)
{
	struct pci_dev *pdev;
	vmk_PCIDevice vfDev;
	u16 seg;
	u8 bus, slot, func;
	int i, n;

	bnx2x_vmk_vf_pci_dev(bp, vf->index, &vfDev);
	vmk_PCIGetSegmentBusDevFunc(vfDev, &seg, &bus, &slot, &func);



#if VMKLNX_DDI_VERSION >= VMKLNX_MAKE_VERSION(9, 2, 0, 0)
/*#if VMKLNX_DDI_VERSION >= VMKLNX_MAKE_VERSION(10, 0)*/
	pdev = pci_find_slot(seg, bus, PCI_DEVFN(slot, func));
#else
	pdev = pci_find_slot(bus, PCI_DEVFN(slot, func));
#endif

	if (!pdev) {
		printk(KERN_ERR"Cannot get pci_dev of VF %d.\n", vf->abs_vfid);
		return;
	}

	for (i = 0, n = 0; i < PCI_SRIOV_NUM_BARS; i += 2, n++) {
		vf->bars[n].bar = pci_resource_start(pdev, i);
		vf->bars[n].size = pci_resource_len(pdev, i);
	}
}


#define PCI_SRIOV_CAP_POS_E2	0x1c0

void
bnx2x_vmk_get_sriov_cap_pos(struct bnx2x *bp, vmk_uint16 *pos)
{
	if (pos)
		/* check for E2 TODO */
		*pos = PCI_SRIOV_CAP_POS_E2;
}


static inline
struct bnx2x_virtf *vf_by_vmkVFID(struct bnx2x *bp, vmk_VFID vmkVf)
{
	return (vmkVf < BNX2X_NR_VIRTFN(bp) ? BP_VF(bp, vmkVf) : NULL);
}

#ifdef BNX2X_PASSTHRU
// ---------------------------------------------------------------------------
//
// VF allocation
//
static int
bnx2x_pt_vf_acquire(struct net_device *netdev, vmk_NetVFRequirements *props,
		  vmk_VFID *vmkVf)
{
	struct bnx2x *bp = netdev_priv(netdev);
	struct bnx2x_virtf *vf = NULL;	/* make this compile */
	struct vf_pf_resc_request resc;
	int i;

	DP(BNX2X_MSG_IOV, "Features 0x%x, opt-Features 0x%x\n",
	   props->features, props->optFeatures);

	/* verfiy version TODO */
	/* find the first VF which is in either FREE or RESET states */
	for_each_vf(bp, i) {
		vf = BP_VF(bp, i);
		if ((vf->state == VF_FREE) || (vf->state == VF_RESET))
			break;
	}
	if (i == BNX2X_NR_VIRTFN(bp)) {
		BNX2X_ERR("No available VFs\n");
		return VMK_NO_RESOURCES;
	}

	/* acquire the resources */
	resc.num_rxqs = props->numRxQueues;
	resc.num_txqs = props->numTxQueues;
	resc.num_sbs = props->numIntrs;
	resc.num_mac_filters = 1;
	resc.num_mc_filters = 0;
	resc.num_vlan_filters = 0;

	if (bnx2x_vf_acquire(bp, vf, &resc)) {
		BNX2X_ERR("VF[%d] - Failed to provision resources, rxqs=%d, txqs=%d, intr=%d\n",
			  vf->abs_vfid,
			  props->numRxQueues,
			  props->numTxQueues,
			  props->numIntrs);
		return VMK_NO_RESOURCES;
	}

	*vmkVf = i;

	/**
	 * set the identity mapping between queues and SBs
	 * (must be done prior to get_info)
	 */
	for_each_vfq(vf, i)
		bnx2x_vfq(vf, i, sb_idx) = i;


	/*
	 * save features and MTU to be set on a per queue basis later
	 * during VF init.
	 */
	vf->mtu = props->mtu;
	vf->queue_flags = 0;

	if ((props->features | props->optFeatures) & VMK_NETVF_F_RXVLAN)
		set_bit(BNX2X_Q_FLG_VLAN, &vf->queue_flags);
	if ((props->features | props->optFeatures) & VMK_NETVF_F_LRO)
		set_bit(BNX2X_Q_FLG_TPA, &vf->queue_flags);

#ifdef BNX2X_PASSTHRU_NO_BC_FLR
	if (BP_NOMCP(bp))
		mod_timer(&bp->vfdb->flr_timer, jiffies + HZ/100);
#endif

	return VMK_OK;
}

static int
bnx2x_pt_vf_init(struct net_device *netdev, vmk_VFID vmkVf,
		 vmk_NetVFParameters *params)
{
	struct bnx2x *bp = netdev_priv(netdev);
	struct bnx2x_virtf *vf = vf_by_vmkVFID(bp, vmkVf);
	struct bnx2x_vfop_cmd cmd = {
		.done = NULL,
		.block = true,
	};
	u64 *sb_map;
	int i, rc;

	DP(BNX2X_MSG_IOV, "VF index %d\n", vmkVf);


	/* sanity */
	if (!vf || vf->state != VF_ACQUIRED)
		return VMK_BAD_PARAM;

	/* initialize function */
#ifdef BNX2X_PASSTHRU_NO_BC_FLR
	if (BP_NOMCP(bp))
		mod_timer(&bp->vfdb->flr_timer, jiffies + HZ/100);
#endif

	/* verify shared region and save plugin stats pointer */
	if (!params->u.npa.sharedRegion || params->u.npa.sharedRegionLength <
	    sizeof(struct bnx2x_vf_plugin_stats))
		return VMK_BAD_PARAM;

	vf->plugin_stats =
		(struct bnx2x_vf_plugin_stats *)params->u.npa.sharedRegion;

	memset((u8*)vf->plugin_stats, 0, sizeof(struct bnx2x_vf_plugin_stats));

	/* set GPA of sbs */
	sb_map = kzalloc(sizeof(*sb_map) * sb_count(vf), GFP_ATOMIC);
	if (!sb_map)
		return VMK_NO_MEMORY;

	for_each_vf_sb(vf, i) {
		sb_map[i] = SB_OFFSET(params->u.npa.txQueues[i].basePA,
				      params->u.npa.txQueues[i].size);
		DP(BNX2X_MSG_IOV, "VF[%d], SB[%d] - map 0x%llx, igu %d, fw %d "
				  "hc %d, mod-level %d\n",
		   vf->abs_vfid, i, sb_map[i],
		   vf_igu_sb(vf,i),
		   vf_fw_sb(vf,i),
		   vf_hc_qzone(vf,i),
		   params->u.npa.intr[i].modLevel);
	}

	rc = bnx2x_vf_init(bp, vf, sb_map);
	kfree(sb_map);

	if (rc)
		goto vf_init_error;

	/* queues */
	for_each_vfq(vf, i) {
		struct bnx2x_vf_queue *q = vfq_get(vf,i);
		struct bnx2xpi_txrx_params txrxp = {{0}};
		struct bnx2x_queue_setup_params *setup_p;
		struct bnx2x_queue_init_params *init_p;
		unsigned long q_type = 0, q_flags = 0;

		/**
		 * reinit the VF operation context
		 */
		memset(&vf->op_params.qctor, 0 , sizeof(vf->op_params.qctor));
		setup_p = &vf->op_params.qctor.prep_qsetup;
		init_p =  &vf->op_params.qctor.qstate.params.init;

		/* prepare flags */
		q_flags = vf->queue_flags;
		__set_bit(BNX2X_Q_FLG_HC, &q_flags);
		__set_bit(BNX2X_Q_FLG_STATS, &q_flags);
		if (IS_MF_SD(bp))
			__set_bit(BNX2X_Q_FLG_OV, &q_flags);

		/* TXQ */
		if (i < txq_count(vf)) {
			struct bnx2x_txq_setup_params *txq_params =
				&setup_p->txq_params;

			set_bit(BNX2X_Q_TYPE_HAS_TX, &q_type);
			txrxp.tx.base = params->u.npa.txQueues[i].basePA;
			txrxp.tx.nr_desc = params->u.npa.txQueues[i].size;
			txrxp.tx.byte_len = params->u.npa.txQueues[i].length;

			DP(BNX2X_MSG_IOV, "VF[%d], TXQ[%d] - base 0x%llx, "
					  "nr_desc %d, len %d\n",
			   vf->abs_vfid,
			   q->index,
			   txrxp.tx.base,
			   txrxp.tx.nr_desc,
			   txrxp.tx.byte_len);


			/* tx init */
			init_p->tx.hc_rate = 20000; /* intr p/s default */
			init_p->tx.sb_cq_index = PLUGIN_SB_ETH_TX_CQ_INDEX;
			init_p->tx.flags = q_flags;

			/* tx setup flags */
			setup_p->flags = q_flags;

			/* tx setup general - nothing */

			/**
			 *  TODO: We need to add the mtu for txq as well
			 */

			/* tx setup tx */
			txq_params->dscr_map = bnx2xpi_tx_decr_offset(&txrxp);
			txq_params->sb_cq_index = PLUGIN_SB_ETH_TX_CQ_INDEX;
			txq_params->traffic_type = LLFC_TRAFFIC_TYPE_NW;

			bnx2x_vfop_qctor_dump_tx(bp, vf, init_p, setup_p,
						 q->index, q->sb_idx);
		}

		/* RXQ */
		if (i < rxq_count(vf)) {
			struct bnx2x_rxq_setup_params *rxq_params =
							&setup_p->rxq_params;

			set_bit(BNX2X_Q_TYPE_HAS_RX, &q_type);
			txrxp.rx.base = params->u.npa.rxQueues[i].basePA;
			txrxp.rx.nr_desc = params->u.npa.rxQueues[i].size;
			txrxp.rx.byte_len = params->u.npa.rxQueues[i].length;

			DP(BNX2X_MSG_IOV, "VF[%d], RXQ[%d] - base 0x%llx, "
					  "nr_desc %d, len %d\n",
			   vf->abs_vfid,
			   q->index,
			   txrxp.rx.base,
			   txrxp.rx.nr_desc,
			   txrxp.rx.byte_len);

			/* rx init */
			init_p->rx.hc_rate = 40000; /* intr p/s default */
			init_p->rx.sb_cq_index = PLUGIN_SB_ETH_RX_CQ_INDEX;
			init_p->rx.flags = q_flags;

			/* rx setup flags */
			setup_p->flags = q_flags;

			/* rx setup general */
			setup_p->gen_params.mtu = vf->mtu;

			/* rx setup rx */
			rxq_params->drop_flags = 0;
			rxq_params->dscr_map = bnx2xpi_rx_decr_offset(&txrxp);
			rxq_params->sge_map = bnx2xpi_sge_offset(&txrxp);
			rxq_params->rcq_map = bnx2xpi_rcq_offset(&txrxp);
			rxq_params->rcq_np_map = bnx2xpi_rcq_np_offset(&txrxp);
			rxq_params->buf_sz = SHELL_SMALL_RECV_BUFFER_SIZE -
				PLUGIN_RX_ALIGN - IP_HEADER_ALIGNMENT_PADDING;
			rxq_params->cache_line_log = PLUGIN_RX_ALIGN_SHIFT;
			rxq_params->sb_cq_index = PLUGIN_SB_ETH_RX_CQ_INDEX;

			if (test_bit(BNX2X_Q_FLG_TPA, &vf->queue_flags)) {
				rxq_params->tpa_agg_sz =
					min_t(u32,
					      PLUGIN_MAX_SGES *
					      SHELL_LARGE_RECV_BUFFER_SIZE,
					      0xffff);

				rxq_params->max_sges_pkt = DIV_ROUND_UP(
					vf->mtu, SHELL_LARGE_RECV_BUFFER_SIZE);

				rxq_params->sge_buf_sz =
					min_t(u32,
					      SHELL_LARGE_RECV_BUFFER_SIZE,
					      0xffff);
			}
			bnx2x_vfop_qctor_dump_rx(bp, vf, init_p, setup_p,
						 q->index, q->sb_idx);
		}

		/* complete the prepareations */
		bnx2x_vfop_qctor_prep(bp, vf, q, &vf->op_params.qctor, q_type);

		/* invoke setup operation - blocking */
		DP(BNX2X_MSG_IOV, "VFQ SETUP[%d:%d]\n", vf->abs_vfid, i);
		if (bnx2x_vfop_qsetup_cmd(bp, vf, &cmd, i))
			goto vf_init_error;

		/**
		 * set the next-page directly in the storm RAM.
		 */
		storm_memset_rcq_np(bp, setup_p->rxq_params.rcq_np_map,
				    vfq_cl_id(vf,q));
	}
	return VMK_OK;

vf_init_error:
	/* release the VF (blocking) */
	bnx2x_vf_release(bp, vf, true);
	return VMK_FAILURE;

}

static int
bnx2x_pt_vf_release(struct net_device *netdev, vmk_VFID vmkVf)
{
	struct bnx2x *bp = netdev_priv(netdev);
	struct bnx2x_virtf *vf = vf_by_vmkVFID(bp, vmkVf);

	DP(BNX2X_MSG_IOV, "VF index %d\n", vmkVf);

	/* sanity */
	if (!vf)
		return VMK_BAD_PARAM;

	bnx2x_vf_release(bp, vf, true);	/* blocking */
	return VMK_OK;
}

// ---------------------------------------------------------------------------
//
// VF basic control
//
static int
bnx2x_pt_vf_get_info(struct net_device *netdev, vmk_VFID vmkVf,
		     vmk_NetVFInfo *info)
{
	struct bnx2x *bp = netdev_priv(netdev);
	struct bnx2x_virtf *vf = vf_by_vmkVFID(bp, vmkVf);
	struct bnx2x_plugin_device_info *plugin_data;
	vmk_uint8 numPtRegions;
	int i;

	DP(BNX2X_MSG_IOV, "VF index %d\n", vmkVf);

	/* sanity */
	if (!vf || vf->state != VF_ACQUIRED)
		return VMK_BAD_PARAM;

	/* build sbdf */
	info->sbdf = (vf->devfn) | ((vf->bus & 0xff) << 8) |
		((pci_domain_nr(bp->pdev->bus) & 0xffff) << 16);

	/* copy bar info */
	for (i = 0, numPtRegions = 0; i < 3; i++) {
		if(vf->bars[i].size) {
			info->ptRegions[numPtRegions].MA = vf->bars[i].bar;
			info->ptRegions[numPtRegions++].numPages =
				vf->bars[i].size / 4096;
		}
	}
	info->numPtRegions = numPtRegions;

	DP(BNX2X_MSG_IOV, "sbdf %08x (%04x:%02x:%02x.%01x), no pages: %d ",
	   info->sbdf,
	   (info->sbdf >> 16) & 0xffff,
	   (info->sbdf >> 8) & 0xff,
	   PCI_SLOT(info->sbdf &0xff),
	   PCI_FUNC(info->sbdf &0xff),
	   info->numPtRegions);

	for (i = 0; i < numPtRegions; i++)
		DP_CONT(BNX2X_MSG_IOV, " [ 0x%llx, %d ]" ,
			(unsigned long long int)info->ptRegions[i].MA,
			info->ptRegions[i].numPages);
	DP_CONT(BNX2X_MSG_IOV, "\n");

	/* plugin information */
	strcpy(info->u.npa.pluginName, "bnx2x_plugin-%b.so");

	/* build plugin private data  */
	memset(info->u.npa.pluginData, 0, sizeof (info->u.npa.pluginData));
	plugin_data = (struct bnx2x_plugin_device_info *)(info->u.npa.pluginData);

	for_each_vfq(vf, i) {
		struct bnx2x_vf_queue *q = vfq_get(vf, i);
		plugin_data->sb_info[i].sb_qid = vfq_qzone_id(vf, q);
		plugin_data->sb_info[i].hw_sb_id = vf_igu_sb(vf ,q->sb_idx);
		plugin_data->hw_qid[i] = vfq_qzone_id(vf, q);
	}
	plugin_data->chip_id = bp->common.chip_id;
	plugin_data->pci_func = bp->pf_num;

	plugin_data->fp_flags = BNX2X_PLUGIN_SHARED_SB_IDX;

	plugin_data->fp_flags |= test_bit(BNX2X_Q_FLG_TPA, &vf->queue_flags) ?
		0 : BNX2X_PLUGIN_DISABLE_TPA;

	return VMK_OK;
}

static int
bnx2x_pt_vf_quiesce(struct net_device *netdev, vmk_VFID vmkVf)
{
	struct bnx2x *bp = netdev_priv(netdev);
	struct bnx2x_virtf *vf = vf_by_vmkVFID(bp, vmkVf);
	struct bnx2x_vfop_cmd cmd;

	DP(BNX2X_MSG_IOV, "Invoked\n");

	/* sanity */
	if (!vf)
		return VMK_BAD_PARAM;

	/* quiesce only if vf is enabled otherwise exit gracefully */
	if (vf->state != VF_ENABLED)
		return VMK_OK;

	cmd.done = NULL;
	cmd.block = true;
	return VMK_RET(bnx2x_vfop_trigger_cmd(bp, vf, &cmd, false));
}

static int
bnx2x_pt_vf_activate(struct net_device *netdev, vmk_VFID vmkVf)
{
	struct bnx2x *bp = netdev_priv(netdev);
	struct bnx2x_virtf *vf = vf_by_vmkVFID(bp, vmkVf);
	struct bnx2x_vfop_cmd cmd;

	DP(BNX2X_MSG_IOV, "Invoked\n");

	/* sanity */
	if (!vf || vf->state != VF_ENABLED)
		return VMK_BAD_PARAM;

	cmd.done = NULL;
	cmd.block = true;
	return VMK_RET(bnx2x_vfop_trigger_cmd(bp, vf, &cmd, true));
}


static int
bnx2x_pt_vf_set_mac(struct net_device *netdev, vmk_VFID vmkVf,
		    vmk_EthAddress mac)
{
	struct bnx2x *bp = netdev_priv(netdev);
	struct bnx2x_virtf *vf = vf_by_vmkVFID(bp, vmkVf);
	struct bnx2x_vfop_cmd cmd;
	int rc;

	DECLARE_MAC_BUF(mac_buf);
	DP(BNX2X_MSG_IOV, "%s\n", print_mac(mac_buf, mac));

	/* sanity */
	if (!vf || vf->state != VF_ENABLED)
		return VMK_BAD_PARAM;

	cmd.done = NULL;
	cmd.block = true;
	rc = bnx2x_vfop_mac_set_cmd(bp, vf, &cmd, 0, mac, true);
	if (rc)
		BNX2X_ERR("Failed to add mac-vlan rule rc=%d\n", rc);

	return VMK_RET(rc);
}

// ---------------------------------------------------------------------------
//
// Multicast control
//
static int
bnx2x_pt_vf_set_multicast(struct net_device *netdev, vmk_VFID vmkVf,
			  size_t nmac, vmk_EthAddress *mac)
{
	struct bnx2x *bp = netdev_priv(netdev);
	struct bnx2x_virtf *vf = vf_by_vmkVFID(bp, vmkVf);
	struct bnx2x_vfop_cmd cmd;


	DP(BNX2X_MSG_IOV, "VF index %d, mcast_num %d\n", vmkVf, (int)nmac);

	/* sanity */
	if (!vf || vf->state != VF_ENABLED)
		return VMK_BAD_PARAM;

	if (nmac > VMK_NPA_MAX_MULTICAST_FILTERS)
		return VMK_BAD_PARAM;

	cmd.done = NULL;
	cmd.block = true;
	return VMK_RET(bnx2x_vfop_mcast_cmd(bp, vf, &cmd,
					    (bnx2x_mac_addr_t *)mac, nmac,
					    false));
}

static int
bnx2x_pt_vf_set_rx_mode(struct net_device *netdev, vmk_VFID vmkVf,
			uint8_t unicast,
			uint8_t multicast,
			uint8_t broadcast,
			uint8_t allmulti)
{
	struct bnx2x *bp = netdev_priv(netdev);
	struct bnx2x_virtf *vf = vf_by_vmkVFID(bp, vmkVf);
	unsigned long accept_flags = 0;
	struct bnx2x_vfop_cmd cmd;

	DP(BNX2X_MSG_IOV, "VF index %d, ucast %d, mcast %d, bcast %d, "
			  "allmulti %d\n",
	   vmkVf, unicast, multicast, broadcast, allmulti);

	/* sanity */
	if (!vf || vf->state != VF_ENABLED)
		return VMK_BAD_PARAM;

	/* build accept flags */
	if (unicast)
		set_bit(BNX2X_ACCEPT_UNICAST, &accept_flags);
	if (multicast)
		set_bit(BNX2X_ACCEPT_MULTICAST, &accept_flags);
	if (broadcast)
		set_bit(BNX2X_ACCEPT_BROADCAST, &accept_flags);
	if (allmulti)
		set_bit(BNX2X_ACCEPT_ALL_MULTICAST, &accept_flags);

	/**
	 * Emulation/FPGA CAM is narrow so use ANY_VLAN instead of vlan 0
	 */
	if (CHIP_REV_IS_SLOW(bp))
		set_bit(BNX2X_ACCEPT_ANY_VLAN, &accept_flags);

	DP(BNX2X_MSG_IOV, "RX-MASK=0x%lx\n", accept_flags);

	cmd.done = NULL;
	cmd.block = true;
	return VMK_RET(bnx2x_vfop_rxmode_cmd(bp, vf, &cmd, 0, accept_flags));
}

// ---------------------------------------------------------------------------
//
// VLAN control
//

static inline int
bnx2x_vf_set_vlan(struct bnx2x *bp, struct bnx2x_virtf *vf, int qid,
		  u16 vtag, bool add)
{
	struct bnx2x_vfop_cmd cmd = {
		.done = NULL,
		.block = true,
	};
	return VMK_RET(bnx2x_vfop_vlan_set_cmd(bp, vf, &cmd, qid, vtag, add));
}

static int bnx2x_pt_vf_vlan_range(struct net_device *netdev, vmk_VFID vmkVf,
			   vmk_VlanID first, vmk_VlanID last, bool add)
{
	struct bnx2x *bp = netdev_priv(netdev);
	struct bnx2x_virtf *vf = vf_by_vmkVFID(bp, vmkVf);
	struct bnx2x_vfop_filters *vlans = NULL;
	size_t fsz;
	vmk_VlanID vid;

	struct bnx2x_vfop_cmd cmd = {
		.done = NULL,
		.block = true,
	};

	DP(BNX2X_MSG_IOV, "VF index %d, first %d, last %d\n",
	   vmkVf, first, last);

	/* sanity */
	if (!vf || vf->state != VF_ENABLED)
		return VMK_BAD_PARAM;

	/* a valid range does not include vlan 0 - igonre first == 0 */
	if (first > last || first > 4095 || last > 4095)
		return VMK_BAD_PARAM;

	fsz = (last-first+1)*sizeof(struct bnx2x_vfop_filter) +
		sizeof(struct bnx2x_vfop_filters);

	vlans = kzalloc(fsz, GFP_KERNEL);
	if (!vlans)
		return VMK_NO_MEMORY;

	INIT_LIST_HEAD(&vlans->head);
	for (vid = first; vid <= last; vid++) {
		list_add_tail(&vlans->filters[vid].link, &vlans->head);
		vlans->filters[vid].vid = vid;
		vlans->filters[vid].add = add;
		vlans->filters[vid].type = BNX2X_VFOP_FILTER_VLAN;
	}

	return VMK_RET(bnx2x_vfop_vlan_list_cmd(bp, vf, &cmd, vlans, 0, false));
}

static inline int
bnx2x_pt_vf_add_vlan_range(struct net_device *netdev, vmk_VFID vmkVf,
			   vmk_VlanID first, vmk_VlanID last)
{
	return bnx2x_pt_vf_vlan_range(netdev, vmkVf, first, last, true);
}

static inline int
bnx2x_pt_vf_del_vlan_range(struct net_device *netdev, vmk_VFID vmkVf,
			   vmk_VlanID first, vmk_VlanID last)
{
	return bnx2x_pt_vf_vlan_range(netdev, vmkVf, first, last, false);
}

static int bnx2x_vf_defvlan(struct bnx2x *bp, struct bnx2x_virtf *vf,
			    bool enable, u16 vid, u8 prio)
{
	struct bnx2x_vfop_cmd cmd = {
		.done = NULL,
		.block = true,
	};
	return VMK_RET(bnx2x_vfop_defvlan_cmd(bp, vf, &cmd, enable, vid, prio));
}

static inline int
bnx2x_vf_clear_vlans(struct bnx2x *bp, struct bnx2x_virtf *vf, int qid)
{
	struct bnx2x_vfop_cmd cmd = {
		.done = NULL,
		.block = true,
	};
	return VMK_RET(bnx2x_vfop_vlan_delall_cmd(bp, vf, &cmd, qid, false));
}

static int
bnx2x_pt_vf_set_default_vlan(struct net_device *netdev, vmk_VFID vmkVf,
			   uint8_t enable, vmk_VlanID vid,
			   vmk_VlanPriority prio)
{
	struct bnx2x *bp = netdev_priv(netdev);
	struct bnx2x_virtf *vf = vf_by_vmkVFID(bp, vmkVf);
	int rc = 0;

	DP(BNX2X_MSG_IOV, "VF index %d, vid %d, pri %d, %s\n",
	   vmkVf, vid, prio, ENABLE_STR(enable));

	/* sanity */
	if (!vf || vf->state != VF_ENABLED)
		return VMK_BAD_PARAM;

	if ((enable && vid == 0 && prio == 0) || vid > 4095 || prio > 7)
		return VMK_BAD_PARAM;

	if (!enable) {
		/* disable */
		if (!vf->def_vlan_enabled)
			/* nothing to do */
			return VMK_OK;

		/* turn off default vlan */
		rc = bnx2x_vf_defvlan(bp, vf, false, vid, prio);
		if (rc)
			goto vmkpt_err;

		/**
		 * reset vlan classification - remove the default vlan
		 * (remove all) and add vlan 0
		 */
		rc = bnx2x_vf_clear_vlans(bp, vf, 0);
		if (rc)
			goto vmkpt_err;

		rc = bnx2x_vf_set_vlan(bp, vf, 0, 0, true);
		if (rc)
			goto vmkpt_err;

		vf->def_vlan_enabled = false;
	}
	else {
		/* enable */
		if (vf->def_vlan_enabled)
			/* nothing to do */
			return VMK_OK;

		/**
		 * set vlan classifiaction - clear all vlans and add the
		 * default vlan
		 */
		rc = bnx2x_vf_clear_vlans(bp, vf, 0);
		if (rc)
			goto vmkpt_err;

		rc = bnx2x_vf_set_vlan(bp, vf, 0, vid, true);
		if (rc)
			goto vmkpt_err;

		/* turn on default vlan */
		rc = bnx2x_vf_defvlan(bp, vf, true, vid, prio);
		if (rc)
			goto vmkpt_err;

		vf->def_vlan_enabled = true;
	}
vmkpt_done:
	return VMK_RET(rc);
vmkpt_err:
	BNX2X_ERR("failed to set default vlan, VF[%d], vid %d, pri %d, %s "
		  "rc %d\n", vmkVf, vid, prio, ENABLE_STR(enable), rc);
	goto vmkpt_done;
}

// ---------------------------------------------------------------------------
//
// Misc operations
//
static int
bnx2x_pt_vf_set_antispoof(struct net_device *netdev, vmk_VFID vmkVf,
			  uint8_t enable)
{
	struct bnx2x *bp = netdev_priv(netdev);
	struct bnx2x_virtf *vf = vf_by_vmkVFID(bp, vmkVf);
	struct bnx2x_vfop_cmd cmd = {
		.done = NULL,
		.block = true,
	};
	return VMK_RET(bnx2x_vfop_antispoof_cmd(bp, vf, &cmd, enable));
}

static int
bnx2x_pt_vf_set_rss_ind_table(struct net_device *netdev, vmk_VFID vmkVf,
			    vmk_NetVFRSSIndTable *table)
{
	struct bnx2x *bp = netdev_priv(netdev);
	struct bnx2x_virtf *vf = vf_by_vmkVFID(bp, vmkVf);


	DP(BNX2X_MSG_IOV, "VF index %d\n", vmkVf);

	/* sanity */
	if (!vf || vf->state != VF_ENABLED)
		return VMK_BAD_PARAM;

	// Check table size.
	if (table->indTableSize > VMK_NETVF_RSS_MAX_IND_TABLE_SIZE)
		return VMK_BAD_PARAM;

	return VMK_OK;
}

static int
bnx2x_pt_vf_get_queue_status(struct net_device *netdev, vmk_VFID vmkVf,
			   uint8_t numTxQueues, uint8_t numRxQueues,
			   vmk_NetVFQueueStatus *tqStatus,
			   vmk_NetVFQueueStatus *rqStatus)
{
	struct bnx2x *bp = netdev_priv(netdev);
	DP(BNX2X_MSG_IOV, "VF index %d - NOT SUPPORTED \n", vmkVf);
	return VMK_OK;
}


static inline
vmk_uint64 __pt_update_single_stat(vmk_uint64 cur, vmk_uint64 *p_old)
{
	vmk_uint64 diff = (s64)cur - (s64)(*p_old);
	*p_old = cur;
	return diff;
}

static int
bnx2x_pt_vf_get_queue_stats(struct net_device *netdev, vmk_VFID vmkVf,
			  uint8_t numTxQueues, uint8_t numRxQueues,
			  vmk_NetVFTXQueueStats *tqStats,
			  vmk_NetVFRXQueueStats *rqStats)
{
	int i;
	struct bnx2x *bp = netdev_priv(netdev);
	struct bnx2x_virtf *vf = vf_by_vmkVFID(bp, vmkVf);

	/* sanity */
	if (!vf || vf->state != VF_ENABLED)
		return VMK_BAD_PARAM;

	if (rxq_count(vf) < numRxQueues || txq_count(vf) < numTxQueues)
		return VMK_BAD_PARAM;

	// First clear output structures.
	memset(tqStats, 0, numTxQueues * sizeof (vmk_NetVFTXQueueStats));
	memset(rqStats, 0, numRxQueues * sizeof (vmk_NetVFRXQueueStats));

	for (i = 0; i < numRxQueues; i++) {
		struct bnx2x_vfq_fw_stats *qstats = &vf->vfq_stats[i].qstats;
		vmk_NetVFRXQueueStats *old_vmk_rxq = &vf->vfq_stats[i].old_vmk_rxq;

		rqStats[i].unicastPkts = __pt_update_single_stat(
			HILO_U64(qstats->total_unicast_packets_received_hi,
				 qstats->total_unicast_packets_received_lo),
			&old_vmk_rxq->unicastPkts);

		rqStats[i].unicastBytes = __pt_update_single_stat(
			HILO_U64(qstats->total_unicast_bytes_received_hi,
				 qstats->total_unicast_bytes_received_lo),
			&old_vmk_rxq->unicastBytes);

		rqStats[i].multicastPkts = __pt_update_single_stat(
			HILO_U64(qstats->total_multicast_packets_received_hi,
				 qstats->total_multicast_packets_received_lo),
			&old_vmk_rxq->multicastPkts);

		rqStats[i].multicastBytes = __pt_update_single_stat(
			HILO_U64(qstats->total_multicast_bytes_received_hi,
				 qstats->total_multicast_bytes_received_lo),
			&old_vmk_rxq->multicastBytes);

		rqStats[i].broadcastPkts = __pt_update_single_stat(
			HILO_U64(qstats->total_broadcast_packets_received_hi,
				 qstats->total_broadcast_packets_received_lo),
			&old_vmk_rxq->broadcastPkts);

		rqStats[i].broadcastBytes = __pt_update_single_stat(
			HILO_U64(qstats->total_broadcast_bytes_received_hi,
				 qstats->total_broadcast_bytes_received_lo),
			&old_vmk_rxq->broadcastBytes);

		rqStats[i].outOfBufferDrops = __pt_update_single_stat(
			HILO_U64(qstats->no_buff_discard_hi,
				 qstats->no_buff_discard_lo),
			&old_vmk_rxq->outOfBufferDrops);

		rqStats[i].errorDrops = __pt_update_single_stat(
			HILO_U64(qstats->etherstatsoverrsizepkts_hi,
				 qstats->etherstatsoverrsizepkts_lo) +
			HILO_U64(qstats->error_discard_hi,
				 qstats->error_discard_lo),
			&old_vmk_rxq->errorDrops);

		rqStats[i].LROPkts = __pt_update_single_stat(
			vf->plugin_stats->rxq_stats[i].lro_pkts,
			&old_vmk_rxq->LROPkts);

		rqStats[i].LROBytes = __pt_update_single_stat(
			vf->plugin_stats->rxq_stats[i].lro_bytes,
			&old_vmk_rxq->LROBytes);
	}
	for (i = 0; i < numTxQueues; i++) {
		struct bnx2x_vfq_fw_stats *qstats = &vf->vfq_stats[i].qstats;
		vmk_NetVFTXQueueStats *old_vmk_txq = &vf->vfq_stats[i].old_vmk_txq;

		tqStats[i].unicastPkts = __pt_update_single_stat(
			HILO_U64(qstats->total_unicast_packets_sent_hi,
				 qstats->total_unicast_packets_sent_lo),
			&old_vmk_txq->unicastPkts);

		tqStats[i].unicastBytes = __pt_update_single_stat(
			HILO_U64(qstats->total_unicast_bytes_sent_hi,
				 qstats->total_unicast_bytes_sent_lo),
			&old_vmk_txq->unicastBytes);

		tqStats[i].multicastPkts = __pt_update_single_stat(
			HILO_U64(qstats->total_multicast_packets_sent_hi,
				 qstats->total_multicast_packets_sent_lo),
			&old_vmk_txq->multicastPkts);

		tqStats[i].multicastBytes = __pt_update_single_stat(
			HILO_U64(qstats->total_multicast_bytes_sent_hi,
				 qstats->total_multicast_bytes_sent_lo),
			&old_vmk_txq->multicastBytes);

		tqStats[i].broadcastPkts = __pt_update_single_stat(
			HILO_U64(qstats->total_broadcast_packets_sent_hi,
				 qstats->total_broadcast_packets_sent_lo),
			&old_vmk_txq->broadcastPkts);

		tqStats[i].broadcastBytes = __pt_update_single_stat(
			HILO_U64(qstats->total_broadcast_bytes_sent_hi,
				 qstats->total_broadcast_bytes_sent_lo),
			&old_vmk_txq->broadcastBytes);

		tqStats[i].errors = __pt_update_single_stat(
			HILO_U64(qstats->tx_error_packets_hi,
				 qstats->tx_error_packets_lo),
			&old_vmk_txq->errors);

		tqStats[i].TSOPkts = __pt_update_single_stat(
			vf->plugin_stats->txq_stats[i].tso_pkts,
			&old_vmk_txq->TSOPkts);

		tqStats[i].TSOBytes = __pt_update_single_stat(
			vf->plugin_stats->txq_stats[i].tso_bytes,
			&old_vmk_txq->TSOBytes);

		tqStats[i].discards = 0;
	}
	return VMK_OK;
}

// ---------------------------------------------------------------------------
//
// Non-passthrough vNIC control
//
static inline int bnx2x_pt_pf_mac_filter(struct bnx2x *bp, vmk_EthAddress mac,
					 bool add)
{
	unsigned long ramrod_flags = 0;
	int rc;

	set_bit(RAMROD_COMP_WAIT, &ramrod_flags);

	DECLARE_MAC_BUF(mac_buf);
	DP(BNX2X_MSG_IOV, "%s %s\n", add ? "Adding" : "Deleting",
	   print_mac(mac_buf, mac));

	rc = bnx2x_set_mac_one(bp, mac, &bp->fp->mac_obj, add,
			       BNX2X_ETH_MAC, &ramrod_flags);
	if (rc == -EEXIST)
		rc = 0;

	return rc;
}

static inline int
bnx2x_pt_pf_add_mac_filter(struct net_device *netdev, vmk_EthAddress mac)
{
	return VMK_RET(bnx2x_pt_pf_mac_filter(netdev_priv(netdev), mac, true));
}

static inline int
bnx2x_pt_pf_del_mac_filter(struct net_device *netdev, vmk_EthAddress mac)
{
	return VMK_RET(bnx2x_pt_pf_mac_filter(netdev_priv(netdev), mac, false));
}

static int
bnx2x_pt_pf_mirror_all(struct net_device *netdev, uint8_t enable)
{
	struct bnx2x *bp = netdev_priv(netdev);
	unsigned long rx_accept_flags = 0, tx_accept_flags = 0;
	unsigned long ramrod_flags = 0;

	DP(BNX2X_MSG_IOV, "%s\n", ENABLE_STR(enable));

	if (!enable) {
		/* restore rx_mode */
		bnx2x_set_rx_mode(bp->dev);
		return VMK_OK;
	}
	if (test_bit(BNX2X_FILTER_RX_MODE_PENDING, &bp->sp_state))
		/* no support for concurrent rx_mode requests */
		return VMK_BUSY;

	/* rx -promiscuous */
	set_bit(BNX2X_ACCEPT_ALL_UNICAST, &rx_accept_flags);
	set_bit(BNX2X_ACCEPT_ALL_MULTICAST, &rx_accept_flags);
	set_bit(BNX2X_ACCEPT_BROADCAST, &rx_accept_flags);

	/* tx all-multi */
	set_bit(BNX2X_ACCEPT_UNICAST, &tx_accept_flags);
	set_bit(BNX2X_ACCEPT_ALL_MULTICAST, &tx_accept_flags);
	set_bit(BNX2X_ACCEPT_BROADCAST, &tx_accept_flags);

	set_bit(RAMROD_RX, &ramrod_flags);
	set_bit(RAMROD_TX, &ramrod_flags);
	set_bit(RAMROD_COMP_WAIT, &ramrod_flags);
	bnx2x_set_q_rx_mode(bp, bp->fp->cl_id, 0, rx_accept_flags,
			    tx_accept_flags, ramrod_flags);
	return VMK_OK;
}

// ---------------------------------------------------------------------------
//
// Dispatch & logging operations
//
static VMK_ReturnStatus
bnx2x_pt_passthru_ops2(struct net_device *netdev, vmk_NetPTOP op, void *pargs)
{
	switch (op) {
	case VMK_NETPTOP_VF_ACQUIRE:
	{
		vmk_NetPTOPVFAcquireArgs *args = pargs;
		return bnx2x_pt_vf_acquire(netdev, &args->props, &args->vf);
	}
	case VMK_NETPTOP_VF_INIT:
	{
		vmk_NetPTOPVFInitArgs *args = pargs;
		return bnx2x_pt_vf_init(netdev, args->vf, &args->params);
	}
	case VMK_NETPTOP_VF_ACTIVATE:
	{
		vmk_NetPTOPVFSimpleArgs *args = pargs;
		return bnx2x_pt_vf_activate(netdev, args->vf);
	}
	case VMK_NETPTOP_VF_QUIESCE:
	{
		vmk_NetPTOPVFSimpleArgs *args = pargs;
		return bnx2x_pt_vf_quiesce(netdev, args->vf);
	}
	case VMK_NETPTOP_VF_RELEASE:
	{
		vmk_NetPTOPVFSimpleArgs *args = pargs;
		return bnx2x_pt_vf_release(netdev, args->vf);
	}
	case VMK_NETPTOP_VF_GET_INFO:
	{
		vmk_NetPTOPVFGetInfoArgs *args = pargs;
		return bnx2x_pt_vf_get_info(netdev, args->vf, &args->info);
	}
	case VMK_NETPTOP_VF_SET_RSS_IND_TABLE:
	{
		vmk_NetPTOPVFSetRSSIndTableArgs *args = pargs;
		return bnx2x_pt_vf_set_rss_ind_table(netdev, args->vf,
						     &args->table);
	}
	case VMK_NETPTOP_VF_GET_QUEUE_STATS:
	{
		vmk_NetPTOPVFGetQueueStatsArgs *args = pargs;
		return bnx2x_pt_vf_get_queue_stats(netdev, args->vf,
						   args->numTxQueues,
						   args->numRxQueues,
						   args->tqStats,
						   args->rqStats);
	}
	case VMK_NETPTOP_VF_GET_QUEUE_STATUS:
	{
		vmk_NetPTOPVFGetQueueStatusArgs *args = pargs;
		return bnx2x_pt_vf_get_queue_status(netdev,
						    args->vf,
						    args->numTxQueues,
						    args->numRxQueues,
						    args->tqStatus,
						    args->rqStatus);
	}
	case VMK_NETPTOP_VF_SET_MAC:
	{
		vmk_NetPTOPVFSetMacArgs *args = pargs;
		return bnx2x_pt_vf_set_mac(netdev, args->vf, args->mac);
	}
	case VMK_NETPTOP_VF_SET_MULTICAST:
	{
		vmk_NetPTOPVFSetMulticastArgs *args = pargs;
		return bnx2x_pt_vf_set_multicast(netdev,
						 args->vf,
						 args->nmac,
						 args->macList);
	}
	case VMK_NETPTOP_VF_SET_RX_MODE:
	{
		vmk_NetPTOPVFSetRxModeArgs *args = pargs;
		// promiscuous is not supported by NPA
		return bnx2x_pt_vf_set_rx_mode(netdev,
					       args->vf,
					       args->unicast,
					       args->multicast,
					       args->broadcast,
					       args->allmulti);
	}
	case VMK_NETPTOP_VF_ADD_VLAN_RANGE:
	{
		vmk_NetPTOPVFVlanRangeArgs *args = pargs;
		return bnx2x_pt_vf_add_vlan_range(netdev,
						  args->vf,
						  args->first,
						  args->last);
	}
	case VMK_NETPTOP_VF_DEL_VLAN_RANGE:
	{
		vmk_NetPTOPVFVlanRangeArgs *args = pargs;
		return bnx2x_pt_vf_del_vlan_range(netdev,
						  args->vf,
						  args->first,
						  args->last);
	}
	case VMK_NETPTOP_VF_SET_DEFAULT_VLAN:
	{
		vmk_NetPTOPVFSetDefaultVlanArgs *args = pargs;
		return bnx2x_pt_vf_set_default_vlan(netdev,
						    args->vf,
						    args->enable,
						    args->vid,
						    args->prio);
	}
	case VMK_NETPTOP_VF_SET_ANTISPOOF:
	{
		vmk_NetPTOPVFSetAntispoofArgs *args = pargs;
		return bnx2x_pt_vf_set_antispoof(netdev,
						 args->vf,
						 args->enable);
	}
	case VMK_NETPTOP_PF_ADD_MAC_FILTER:
	{
		vmk_NetPTOPPFMacFilterArgs *args = pargs;
		return bnx2x_pt_pf_add_mac_filter(netdev, args->mac);
	}
	case VMK_NETPTOP_PF_DEL_MAC_FILTER:
	{
		vmk_NetPTOPPFMacFilterArgs *args = pargs;
		return bnx2x_pt_pf_del_mac_filter(netdev, args->mac);
	}
	case VMK_NETPTOP_PF_MIRROR_ALL:
	{
		vmk_NetPTOPPFMirrorAllArgs *args = pargs;
		return bnx2x_pt_pf_mirror_all(netdev, args->enable);
	}
	default:
		printk("Unhandled NPA OP %d\n", op);
		return VMK_FAILURE;
	}
}

/*
 * This wrapper is here to dump registers before/after doing an
 * operation.
 */
VMK_ReturnStatus
bnx2x_pt_passthru_ops(void *client_data, vmk_NetPTOP op, void *args)
{
	VMK_ReturnStatus ret;

	// Do the job
	ret = bnx2x_pt_passthru_ops2(client_data, op, args);

	if (ret != VMK_OK) {
		printk("PT OP %d failed, ret=%X\n", op, ret);
	}
	return ret;
}

#endif /* BNX2X_PASSTHRU */
#endif /* BCM_IOV */

#if (VMWARE_ESX_DDK_VERSION >= 55000)
#define MISC_REG_AEU_MASK_ATTN_MCP 0xa068
#define NIG_REG_BMAC1_PAUSE_OUT_EN 0x10114
#define NIG_REG_EMAC1_PAUSE_OUT_EN 0x1011c

static struct dmp_config dmpcfg;
vmklnx_DumpFileHandle bnx2x_fwdmp_dh;
void *bnx2x_fwdmp_va;
struct bnx2x_fwdmp_info bnx2x_fwdmp_bp[BNX2X_MAX_NIC+1];

static void esx_reg_wr_ind(struct bnx2x *bp, u32 addr, u32 val)
{
	pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS, addr);
	pci_write_config_dword(bp->pdev, PCICFG_GRC_DATA, val);
	pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS,
			       PCICFG_VENDOR_ID_OFFSET);
}

static u32 esx_reg_rd_ind(struct bnx2x *bp, u32 addr)
{
	u32 val;

	pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS, addr);
	pci_read_config_dword(bp->pdev, PCICFG_GRC_DATA, &val);
	pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS,
			       PCICFG_VENDOR_ID_OFFSET);

	return val;
}

static u32 *
read_idle_chk(struct bnx2x *bp, u32 *dst, struct chip_core_dmp *dmp)
{
	u32 i, j;

	/* Read the idle chk registers */
	for (i = 0; i < IDLE_REGS_COUNT; i++)
		if (dmpcfg.mode == (idle_addrs[i].info & dmpcfg.mode))
			for (j = 0; j < idle_addrs[i].size; j++) {
				if ((dmp->fw_hdr.dmp_size + 4) >
				    DRV_DUMP_CRASH_DMP_BUF_SIZE_E3B0) {
					SET_FLAGS(dmp->fw_hdr.flags,
						  FWDMP_FLAGS_SPACE_NEEDED);
					break;
				}
				*dst++ = RD_IND(bp,
						idle_addrs[i].addr + j*4);
				dmp->fw_hdr.dmp_size += 4;
			}
	return dst;
}

static u32 *
read_mcp_traces(struct bnx2x *bp, u32 *dst, struct chip_core_dmp *dmp)
{
	u32 trace_shmem_base;
	u32 addr;
	u32 i;

	if (dmp->fw_hdr.dmp_size + DBG_DMP_TRACE_BUFFER_SIZE >
		DRV_DUMP_CRASH_DMP_BUF_SIZE_E3B0) {
		SET_FLAGS(dmp->fw_hdr.flags, FWDMP_FLAGS_SPACE_NEEDED);
		return dst;
	}

	if (BP_PATH(bp) == 0)
		trace_shmem_base = bp->common.shmem_base;
	else
		trace_shmem_base = SHMEM2_RD(bp, other_shmem_base_addr);

	addr = trace_shmem_base - DBG_DMP_TRACE_BUFFER_SIZE;
	for (i = 0; i < DBG_DMP_TRACE_BUFFER_SIZE;) {
		if ((dmp->fw_hdr.dmp_size + 4)
			> DRV_DUMP_CRASH_DMP_BUF_SIZE_E3B0) {
			SET_FLAGS(dmp->fw_hdr.flags, FWDMP_FLAGS_SPACE_NEEDED);
			break;
		}
		*dst++ = RD_IND(bp, addr + i);
		i += 4;
		dmp->fw_hdr.dmp_size += 4;
	}
	return dst;
}

static u32 *
read_regular_regs(struct bnx2x *bp, u32 *dst, struct chip_core_dmp *dmp)
{
	u32 i, j;

	/* Read the regular address registers */
	for (i = 0; i < REGS_COUNT; i++)
		if (dmpcfg.mode == (reg_addrs[i].info & dmpcfg.mode))
			for (j = 0; j < reg_addrs[i].size; j++) {
				if ((dmp->fw_hdr.dmp_size + 4) >
				    DRV_DUMP_CRASH_DMP_BUF_SIZE_E3B0) {
					SET_FLAGS(dmp->fw_hdr.flags,
						  FWDMP_FLAGS_SPACE_NEEDED);
					break;
				}
				*dst++ = RD_IND(bp, reg_addrs[i].addr + j*4);
				dmp->fw_hdr.dmp_size += 4;
			}
	return dst;
}

static u32 *
read_wregs(struct bnx2x *bp, u32 *dst, struct chip_core_dmp *dmp)
{
	u32 i, j, k;
	u32 reg_add_read = 0;
	const struct wreg_addr *pwreg_addrs = dmpcfg.pwreg_addrs;

	for (i = 0; i < dmpcfg.wregs_count; i++) {
		if (dmpcfg.mode == (pwreg_addrs[i].info & dmpcfg.mode)) {
			reg_add_read = pwreg_addrs[i].addr;
			for (j = 0; j < pwreg_addrs[i].size; j++) {
				if ((dmp->fw_hdr.dmp_size + 4) >
				    DRV_DUMP_CRASH_DMP_BUF_SIZE_E3B0) {
					SET_FLAGS(dmp->fw_hdr.flags,
						  FWDMP_FLAGS_SPACE_NEEDED);
					break;
				}
				*dst++ = RD_IND(bp, reg_add_read);
				reg_add_read += 4;
				dmp->fw_hdr.dmp_size += 4;
				for (k = 0;
				     k < pwreg_addrs[i].read_regs_count; k++) {
					if ((dmp->fw_hdr.dmp_size + 4) >
					    DRV_DUMP_CRASH_DMP_BUF_SIZE_E3B0) {
						SET_FLAGS(dmp->fw_hdr.flags,
						      FWDMP_FLAGS_SPACE_NEEDED);
						break;
					}
					*dst++ = RD_IND(bp,
						   pwreg_addrs[i].read_regs[k]);
					dmp->fw_hdr.dmp_size += 4;
				}
			}
		}
	}
	return dst;
}

static u32 *
read_page_mode(struct bnx2x *bp, u32 *dst, struct chip_core_dmp *dmp)
{
	u32 index_page_vals       = 0;
	u32 index_page_write_regs = 0;
	const struct reg_addr *page_read_regs = dmpcfg.page_read_regs;
	u32 i, j;

	/* If one of the array size is zero, this means that
	   page mode is disabled. */
	if ((0 == dmpcfg.page_mode_values_count) ||
	    (0 == dmpcfg.page_write_regs_count) ||
	    (0 == dmpcfg.page_read_regs_count))
		return dst;

	for (index_page_vals = 0;
	     index_page_vals < dmpcfg.page_mode_values_count;
	     index_page_vals++) {
		for (index_page_write_regs = 0;
		     index_page_write_regs < dmpcfg.page_write_regs_count;
		     index_page_write_regs++) {
			WR_IND(bp,
			       dmpcfg.page_write_regs[index_page_write_regs],
			       dmpcfg.page_vals[index_page_vals]);
		}
		for (i = 0; i < dmpcfg.page_read_regs_count; i++) {
			if (dmpcfg.mode ==
				(page_read_regs[i].info & dmpcfg.mode)) {
				for (j = 0; j < page_read_regs[i].size; j++) {
					if ((dmp->fw_hdr.dmp_size + 4) >
					    DRV_DUMP_CRASH_DMP_BUF_SIZE_E3B0) {
						SET_FLAGS(dmp->fw_hdr.flags,
						   FWDMP_FLAGS_SPACE_NEEDED);
						break;
					}
					*dst++ = RD_IND(bp,
						  page_read_regs[i].addr + j*4);
					dmp->fw_hdr.dmp_size += 4;
				}
			}
		}
	}
	return dst;
}

static void
get_vfc_info(struct bnx2x *bp,
	     const struct vfc_general **xvfc_info,
	     const struct vfc_general **tvfc_info)
{
	if (CHIP_IS_E1(bp)) {
		*xvfc_info = &vfc_general_x_e1;
		*tvfc_info = &vfc_general_t_e1;
	} else if (CHIP_IS_E1H(bp)) {
		*xvfc_info = &vfc_general_x_e1h;
		*tvfc_info = &vfc_general_t_e1h;
	} else if (CHIP_IS_E2(bp)) {
		*xvfc_info = &vfc_general_x_e2;
		*tvfc_info = &vfc_general_t_e2;
	} else if (CHIP_IS_E3(bp)) {
		*xvfc_info = &vfc_general_x_e3;
		*tvfc_info = &vfc_general_t_e3;
	} else {
		*xvfc_info = NULL;
		*tvfc_info = NULL;
	}
}

static void get_vfc_ops(struct bnx2x *bp,
		   const struct vfc_read_task **xvfc_ops,
		   const struct vfc_read_task **tvfc_ops)
{
	if (CHIP_IS_E2(bp)) {
		*xvfc_ops = &vfc_task_x_e2;
		*tvfc_ops = &vfc_task_t_e2;
	} else if (CHIP_IS_E3(bp)) {
		*xvfc_ops = &vfc_task_x_e3;
		*tvfc_ops = &vfc_task_t_e3;
	} else {
		*xvfc_ops = NULL;
		*tvfc_ops = NULL;
	}
}

static void
init_extension_header(u32 data_type,
		      u32 data_source,
		      struct extension_hdr *header)
{
	header->hdr_signature = HDR_SIGNATURE;
	header->hdr_size = (sizeof(*header) -
			    sizeof(header->hdr_size)) / sizeof(u32);
	header->data_type = data_type;
	header->data_source = data_source;
}

static u8
wait_for_reg_value_equals(struct bnx2x *bp,
	u32 offset,
	u32 mask,
	u32 expected_value,
	u32 timeout_us)
{
	u32 reg_value = 0;
	u32 wait_cnt = 0;
	u32 wait_cnt_limit = timeout_us/DEFAULT_WAIT_INTERVAL_MICSEC;

	reg_value = RD_IND(bp, offset);
	while (((reg_value & mask) != expected_value) &&
		(wait_cnt++ != wait_cnt_limit)) {
		udelay(DEFAULT_WAIT_INTERVAL_MICSEC);
		reg_value = RD_IND(bp, offset);
	}
	return ((reg_value & mask) == expected_value);
}

static u32 *
read_vfc_block(struct bnx2x *bp,
		const struct vfc_general *vfc_info,
		const struct vfc_read_task *vfc_ops,
		struct extension_hdr *header,
		u32 *dst,
		struct chip_core_dmp *dmp,
		u8 *rc)
{
	u32 cur_op_idx, i;
	const struct vfc_read_write_vector *current_entry = NULL;
	u32 *dst_start = dst;

	if (!vfc_info->valid || !vfc_info->valid) {
		*rc = false;
		return dst;
	}
	if (!wait_for_reg_value_equals(bp, vfc_info->vfc_status,
				0xFFFFFFFF, 0, 1000)) {
		header->error = true;
		*rc = false;
		goto exit;
	}
	if (dmp->fw_hdr.dmp_size + sizeof(*header) >
		DRV_DUMP_CRASH_DMP_BUF_SIZE_E3B0) {
		SET_FLAGS(dmp->fw_hdr.flags, FWDMP_FLAGS_SPACE_NEEDED);
		*rc = false;
		return dst;
	}
	dst += sizeof(*header)/sizeof(u32);
	dmp->fw_hdr.dmp_size += sizeof(*header);
	for (cur_op_idx = 0; cur_op_idx < vfc_ops->array_size; ++cur_op_idx) {
		current_entry = &vfc_ops->read_write_vectors[cur_op_idx];
		for (i = 0; i < current_entry->write_value_num_valid; ++i) {
			WR_IND(bp,
				vfc_info->vfc_data_write,
				current_entry->write_value[i]);
		}
		WR_IND(bp,
			vfc_info->vfc_address, current_entry->address_value);
		for (i = 0; i < current_entry->read_size; ++i) {
			if (!wait_for_reg_value_equals(bp, vfc_info->vfc_status,
				RI_VFC_IS_READY, RI_VFC_IS_READY, 1000)) {
				u32 reg_value;

				reg_value =
					RD_IND(bp, vfc_info->vfc_status);
				header->error = true;
				*rc = false;
				goto exit;
			}
			if ((dmp->fw_hdr.dmp_size + 4) >
			    DRV_DUMP_CRASH_DMP_BUF_SIZE_E3B0) {
				SET_FLAGS(dmp->fw_hdr.flags,
					  FWDMP_FLAGS_SPACE_NEEDED);
				*rc = false;
				break;
			}
			*dst++ = RD_IND(bp, vfc_info->vfc_data_read);
			header->data_size++;
			dmp->fw_hdr.dmp_size += 4;
		}
	}
exit:
	memcpy((u8 *)dst_start, header, sizeof(*header));
	return dst;
}

static u32 *
read_vfc(struct bnx2x *bp, u32 *dst, struct chip_core_dmp *dmp, u8 *status)
{
	u8 rc = false;
	struct extension_hdr xvfc_header = {0};
	struct extension_hdr tvfc_header = {0};

	const struct vfc_general *xvfc_info = NULL;
	const struct vfc_general *tvfc_info = NULL;
	const struct vfc_read_task *xvfc_ops = NULL;
	const struct vfc_read_task *tvfc_ops = NULL;

	get_vfc_info(bp, &xvfc_info, &tvfc_info);
	get_vfc_ops(bp, &xvfc_ops, &tvfc_ops);
	if ((xvfc_info == NULL) || (tvfc_info == NULL)) {
		*status = false;
		return dst;
	}
	init_extension_header(RI_TYPE_VFC, RI_SRC_XSTORM, &xvfc_header);
	init_extension_header(RI_TYPE_VFC, RI_SRC_TSTORM, &tvfc_header);
	dst = read_vfc_block(bp,
		xvfc_info, xvfc_ops, &xvfc_header, dst, dmp, &rc);
	if (!rc) {
		*status = rc;
		return dst;
	}
	dst = read_vfc_block(bp,
		tvfc_info, tvfc_ops, &tvfc_header, dst, dmp, &rc);
	*status = rc;
	return dst;
}

static const struct igu_data *get_igu_info(struct bnx2x *bp)
{
	if (CHIP_IS_E1(bp))
		return &igu_address_e1;
	else if (CHIP_IS_E1H(bp))
		return &igu_address_e1h;
	else if (CHIP_IS_E2(bp))
		return &igu_address_e2;
	else if (CHIP_IS_E3(bp))
		return &igu_address_e3;
	else
		return NULL;
}

static u32 *
read_igu(struct bnx2x *bp, u32 *dst, struct chip_core_dmp *dmp, u8 *status)
{
	struct extension_hdr igu_header = {0};
	const struct igu_data *igu_info = get_igu_info(bp);
	u32 iter_cnt = 0;
	u32 more_data = 0;
	u32 *dst_start = dst;

	init_extension_header(RI_TYPE_IGU, RI_OTHER_BLOCK, &igu_header);
	if (!igu_info) {
		*status = false;
		return dst;
	}
	if (!igu_info->valid) {
		*status = true;
		return dst;
	}
	more_data = RD_IND(bp, igu_info->is_data_valid);
	if (!more_data) {
		*status = true;
		return dst;
	}
	if (dmp->fw_hdr.dmp_size + sizeof(igu_header) >
		DRV_DUMP_CRASH_DMP_BUF_SIZE_E3B0) {
		SET_FLAGS(dmp->fw_hdr.flags, FWDMP_FLAGS_SPACE_NEEDED);
		*status = false;
		return dst;
	}
	dst += sizeof(igu_header)/sizeof(u32);
	dmp->fw_hdr.dmp_size += sizeof(igu_header);
	igu_header.additional_data = RD_IND(bp, igu_info->is_last_commands);
	do {
		if ((dmp->fw_hdr.dmp_size + 4) >
		    DRV_DUMP_CRASH_DMP_BUF_SIZE_E3B0) {
			SET_FLAGS(dmp->fw_hdr.flags,
				  FWDMP_FLAGS_SPACE_NEEDED);
			igu_header.error = true;
			*status = false;
			break;
		}
		*dst++ = RD_IND(bp, igu_info->data[0]);
		++igu_header.data_size;
		dmp->fw_hdr.dmp_size += 4;
		if ((dmp->fw_hdr.dmp_size + 4) >
		    DRV_DUMP_CRASH_DMP_BUF_SIZE_E3B0) {
			SET_FLAGS(dmp->fw_hdr.flags,
				  FWDMP_FLAGS_SPACE_NEEDED);
			igu_header.error = true;
			*status = false;
			break;
		}
		*dst++ = RD_IND(bp, igu_info->data[1]);
		++igu_header.data_size;
		dmp->fw_hdr.dmp_size += 4;
		more_data = RD_IND(bp, igu_info->is_data_valid);
		++iter_cnt;
	} while (more_data && (iter_cnt < igu_info->max_size));

	memcpy((u8 *)dst_start, &igu_header, sizeof(igu_header));
	return dst;
}

static u32 *
read_additional_blocks(struct bnx2x *bp, u32 *dst, struct chip_core_dmp *dmp)
{
	u8 dmp_status = false;

	dst = read_vfc(bp, dst, dmp, &dmp_status);
	if (dmp_status)
		dst = read_igu(bp, dst, dmp, &dmp_status);
	return dst;
}

static u32 *
dmp_stop_timer(struct bnx2x *bp, u32 *dst, struct chip_core_dmp *dmp)
{
	u32 i, j;
	u32 *timer_scan_reg;

	if ((dmp->fw_hdr.dmp_size + (2 * dmpcfg.regs_timer_count)) >=
	    DRV_DUMP_CRASH_DMP_BUF_SIZE_E3B0) {
		SET_FLAGS(dmp->fw_hdr.flags,
			  FWDMP_FLAGS_SPACE_NEEDED);
		return dst;
	}
	if (dmp->fw_hdr.flags & FWDMP_FLAGS_LIVE_DUMP) {
		/* driver shouldn't read the timer in online
		   since it could cause attention. However,
		   it should fills the buffer and move on */
		for (i = 0;
		     i < 2 * dmpcfg.regs_timer_count;
		     i++) {
			*dst++ = 0;
			dmp->fw_hdr.dmp_size += 4;
		}
		return dst;
	}
	for (i = 0; i < dmpcfg.regs_timer_count; i++) {
		*dst = RD_IND(bp, dmpcfg.regs_timer_status_addrs[i]);
		timer_scan_reg = dst + dmpcfg.regs_timer_count;
		if (*dst == 1) {
			WR_IND(bp, dmpcfg.regs_timer_status_addrs[i], 0);
			for (j = 0; j < DRV_DUMP_MAX_TIMER_PENDING; j++) {
				*timer_scan_reg = RD_IND(bp,
					 dmpcfg.regs_timer_scan_addrs[i]);
				if (*timer_scan_reg == 0)
					break;
			}
		} else {
			*timer_scan_reg = DRV_DUMP_TIMER_SCAN_DONT_CARE;
		}
		dst++;
		dmp->fw_hdr.dmp_size += 4;
	}
	dst += dmpcfg.regs_timer_count;
	dmp->fw_hdr.dmp_size += 4 * dmpcfg.regs_timer_count;
	return dst;
}

static void
dmp_rollback_timer(struct bnx2x *bp,
	struct chip_core_dmp *dmp,
	u32 *tmr_status)
{
	u32 i;

	if (dmp->fw_hdr.flags & FWDMP_FLAGS_LIVE_DUMP)
		return;
	for (i = 0; i < dmpcfg.regs_timer_count; i++) {
		if (*tmr_status == 1)
			WR_IND(bp, dmpcfg.regs_timer_status_addrs[i], 1);
		tmr_status++;
	}
}

static void
init_dump_header(struct bnx2x *bp,
	struct esx_dump_hdr *dump_hdr,
	struct dmp_config *dmpcfg,
	struct chip_core_dmp *dmp)
{
	dump_hdr->hdr_size = (sizeof(struct esx_dump_hdr)/4) - 1;
	dump_hdr->dump_sign = hd_param_all;
	dump_hdr->idle_chk = 1;
	dump_hdr->xstorm_waitp = RD_IND(bp, DRV_DUMP_XSTORM_WAITP_ADDRESS);
	dump_hdr->tstorm_waitp = RD_IND(bp, DRV_DUMP_TSTORM_WAITP_ADDRESS);
	dump_hdr->ustorm_waitp = RD_IND(bp, DRV_DUMP_USTORM_WAITP_ADDRESS);
	dump_hdr->cstorm_waitp = RD_IND(bp, DRV_DUMP_CSTORM_WAITP_ADDRESS);

	if (CHIP_IS_E1(bp)) {
		if (dmp->fw_hdr.flags & FWDMP_FLAGS_LIVE_DUMP)
			dump_hdr->info = RI_E1_ONLINE;
		else
			dump_hdr->info = RI_E1_OFFLINE;
		dmpcfg->wregs_count = WREGS_COUNT_E1;
		dmpcfg->pwreg_addrs = wreg_addrs_e1;
		dmpcfg->regs_timer_count = TIMER_REGS_COUNT_E1;
		dmpcfg->regs_timer_status_addrs = timer_status_regs_e1;
		dmpcfg->regs_timer_scan_addrs = timer_scan_regs_e1;
		dmpcfg->page_mode_values_count =
				PAGE_MODE_VALUES_E1;
		dmpcfg->page_vals = page_vals_e1;
		dmpcfg->page_write_regs_count = PAGE_WRITE_REGS_E1;
		dmpcfg->page_write_regs = page_write_regs_e1;
		dmpcfg->page_read_regs_count = PAGE_READ_REGS_E1;
		dmpcfg->page_read_regs = page_read_regs_e1;
	} else if (CHIP_IS_E1H(bp)) {
		if (dmp->fw_hdr.flags & FWDMP_FLAGS_LIVE_DUMP)
			dump_hdr->info = RI_E1H_ONLINE;
		else
			dump_hdr->info = RI_E1H_OFFLINE;
		dmpcfg->wregs_count = WREGS_COUNT_E1H;
		dmpcfg->pwreg_addrs = wreg_addrs_e1h;
		dmpcfg->regs_timer_count = TIMER_REGS_COUNT_E1H;
		dmpcfg->regs_timer_status_addrs = timer_status_regs_e1h;
		dmpcfg->regs_timer_scan_addrs = timer_scan_regs_e1h;
		dmpcfg->page_mode_values_count =
				PAGE_MODE_VALUES_E1H;
		dmpcfg->page_vals = page_vals_e1h;
		dmpcfg->page_write_regs_count = PAGE_WRITE_REGS_E1H;
		dmpcfg->page_write_regs = page_write_regs_e1h;
		dmpcfg->page_read_regs_count = PAGE_READ_REGS_E1H;
		dmpcfg->page_read_regs = page_read_regs_e1h;
	} else if (CHIP_IS_E2(bp)) {
		if (dmp->fw_hdr.flags & FWDMP_FLAGS_LIVE_DUMP)
			dump_hdr->info = RI_E2_ONLINE |
			(BP_PATH(bp) ? RI_PATH1_DUMP : RI_PATH0_DUMP);
		else
			dump_hdr->info = RI_E2_OFFLINE |
			(BP_PATH(bp) ? RI_PATH1_DUMP : RI_PATH0_DUMP);
		dmpcfg->wregs_count = WREGS_COUNT_E2;
		dmpcfg->pwreg_addrs = wreg_addrs_e2;
		dmpcfg->regs_timer_count = TIMER_REGS_COUNT_E2;
		dmpcfg->regs_timer_status_addrs = timer_status_regs_e2;
		dmpcfg->regs_timer_scan_addrs = timer_scan_regs_e2;
		dmpcfg->page_mode_values_count =
				PAGE_MODE_VALUES_E2;
		dmpcfg->page_vals = page_vals_e2;
		dmpcfg->page_write_regs_count = PAGE_WRITE_REGS_E2;
		dmpcfg->page_write_regs = page_write_regs_e2;
		dmpcfg->page_read_regs_count = PAGE_READ_REGS_E2;
		dmpcfg->page_read_regs = page_read_regs_e2;
	} else if (CHIP_IS_E3A0(bp)) {
		if (dmp->fw_hdr.flags & FWDMP_FLAGS_LIVE_DUMP)
			dump_hdr->info = RI_E3_ONLINE |
			(BP_PATH(bp) ? RI_PATH1_DUMP : RI_PATH0_DUMP);
		else
			dump_hdr->info = RI_E3_OFFLINE |
			(BP_PATH(bp) ? RI_PATH1_DUMP : RI_PATH0_DUMP);
		dmpcfg->wregs_count = WREGS_COUNT_E3;
		dmpcfg->pwreg_addrs = wreg_addrs_e3;
		dmpcfg->regs_timer_count = TIMER_REGS_COUNT_E3;
		dmpcfg->regs_timer_status_addrs = timer_status_regs_e3;
		dmpcfg->regs_timer_scan_addrs = timer_scan_regs_e3;
		dmpcfg->page_mode_values_count =
				PAGE_MODE_VALUES_E3;
		dmpcfg->page_vals = page_vals_e3;
		dmpcfg->page_write_regs_count = PAGE_WRITE_REGS_E3;
		dmpcfg->page_write_regs = page_write_regs_e3;
		dmpcfg->page_read_regs_count = PAGE_READ_REGS_E3; 
		dmpcfg->page_read_regs = page_read_regs_e3;
	} else if (CHIP_IS_E3B0(bp)) {
		if (dmp->fw_hdr.flags & FWDMP_FLAGS_LIVE_DUMP)
			dump_hdr->info = RI_E3B0_ONLINE |
			(BP_PATH(bp) ? RI_PATH1_DUMP : RI_PATH0_DUMP);
		else
			dump_hdr->info = RI_E3B0_OFFLINE |
			(BP_PATH(bp) ? RI_PATH1_DUMP : RI_PATH0_DUMP);
		dmpcfg->wregs_count = WREGS_COUNT_E3B0;
		dmpcfg->pwreg_addrs = wreg_addrs_e3b0;
		dmpcfg->regs_timer_count = TIMER_REGS_COUNT_E3B0;
		dmpcfg->regs_timer_status_addrs = timer_status_regs_e3b0;
		dmpcfg->regs_timer_scan_addrs = timer_scan_regs_e3b0;
		dmpcfg->page_mode_values_count =
				PAGE_MODE_VALUES_E3;
		dmpcfg->page_vals = page_vals_e3;
		dmpcfg->page_write_regs_count = PAGE_WRITE_REGS_E3;
		dmpcfg->page_write_regs = page_write_regs_e3;
		dmpcfg->page_read_regs_count = PAGE_READ_REGS_E3;
		dmpcfg->page_read_regs = page_read_regs_e3;
	}
	dmpcfg->mode = dump_hdr->info & ~(RI_PATH1_DUMP |  RI_PATH0_DUMP);
}

static void disable_pause(struct bnx2x *bp)
{
	if (CHIP_IS_E1x(bp) || CHIP_IS_E2(bp)) {
		WR_IND(bp, NIG_REG_BMAC0_PAUSE_OUT_EN, 0);
		WR_IND(bp, NIG_REG_BMAC1_PAUSE_OUT_EN, 0);
		WR_IND(bp, NIG_REG_EMAC0_PAUSE_OUT_EN, 0);
		WR_IND(bp, NIG_REG_EMAC1_PAUSE_OUT_EN, 0);
	} else {
		WR_IND(bp, NIG_REG_P0_MAC_PAUSE_OUT_EN, 0);
		WR_IND(bp, NIG_REG_P1_MAC_PAUSE_OUT_EN, 0);
	}
}

VMK_ReturnStatus bnx2x_fwdmp_callback(void *cookie, vmk_Bool liveDump)
{
	VMK_ReturnStatus status = VMK_OK;
	u32 idx;
	u32 *dst, *tmr_status;
	struct bnx2x *bp;
	struct esx_dump_hdr dump_hdr = {0};
	struct chip_core_dmp *dmp;

	for (idx = 0; idx < BNX2X_MAX_NIC; idx++) {
		if (bnx2x_fwdmp_va && bnx2x_fwdmp_bp[idx].bp) {
			if (bnx2x_fwdmp_bp[idx].disable_fwdmp)
				continue;
			bp = bnx2x_fwdmp_bp[idx].bp;
			dst = bnx2x_fwdmp_va;
			/* build the fw dump header */
			dmp = (struct chip_core_dmp *)dst;
			snprintf(dmp->fw_hdr.name, sizeof(dmp->fw_hdr.name),
				"%s", bp->dev->name);
			dmp->fw_hdr.bp = (void *)bp;
			dmp->fw_hdr.chip_id = bp->common.chip_id;
			dmp->fw_hdr.len = sizeof(struct fw_dmp_hdr);
			dmp->fw_hdr.ver = 0x000700006;
			dmp->fw_hdr.dmp_size = dmp->fw_hdr.len;
			dmp->fw_hdr.flags = 0;
			if (liveDump)
				SET_FLAGS(dmp->fw_hdr.flags, FWDMP_FLAGS_LIVE_DUMP);
			memset(&dmpcfg, 0, sizeof(struct dmp_config));
			memset(&dump_hdr, 0, sizeof(struct esx_dump_hdr));
			dst = dmp->fw_dmp_buf;
			bnx2x_disable_blocks_parity(bp);
			/* build the GRC dump header */
			init_dump_header(bp, &dump_hdr, &dmpcfg, dmp);
			memcpy(dst, &dump_hdr, sizeof(struct esx_dump_hdr));
			dst += dump_hdr.hdr_size + 1;
			dmp->fw_hdr.dmp_size += (dump_hdr.hdr_size + 1) * 4;
			/* stop the timers before idle check. */
			tmr_status = dst;
			dst = dmp_stop_timer(bp, dst, dmp);
			if (dmp->fw_hdr.flags & FWDMP_FLAGS_SPACE_NEEDED)
				goto write_file;
			/* dump 1st idle check */
			dst = read_idle_chk(bp, dst, dmp);
			if (dmp->fw_hdr.flags & FWDMP_FLAGS_SPACE_NEEDED)
				goto write_file;
			/* dump 2nd idle check */
			dst = read_idle_chk(bp, dst, dmp);
			/* Enable the timers after idle check. */
			dmp_rollback_timer(bp, dmp, tmr_status);
			if (dmp->fw_hdr.flags & FWDMP_FLAGS_SPACE_NEEDED)
				goto write_file;
			/* dump mcp traces */
			dst = read_mcp_traces(bp, dst, dmp);
			if (dmp->fw_hdr.flags & FWDMP_FLAGS_SPACE_NEEDED)
				goto write_file;
			/* dump regular address registers */
			dst = read_regular_regs(bp, dst, dmp);
			if (dmp->fw_hdr.flags & FWDMP_FLAGS_SPACE_NEEDED)
				goto write_file;
			/* dump wide bus registers */
			dst = read_wregs(bp, dst, dmp);
			if (dmp->fw_hdr.flags & FWDMP_FLAGS_SPACE_NEEDED)
				goto write_file;
			/* dump read page mode registers */
			dst = read_page_mode(bp, dst, dmp);
			if (dmp->fw_hdr.flags & FWDMP_FLAGS_SPACE_NEEDED)
				goto write_file;
			/* dump additional blocks */
			dst = read_additional_blocks(bp, dst, dmp);
			if (((dmp->fw_hdr.dmp_size + 4) <=
			      DRV_DUMP_CRASH_DMP_BUF_SIZE_E3B0)) {
				*dst++ = BNX2X_FWDMP_MARKER_END;
				dmp->fw_hdr.dmp_size += 4;
			}
write_file:
			status = vmklnx_dump_range(bnx2x_fwdmp_dh,
					bnx2x_fwdmp_va, dmp->fw_hdr.dmp_size);
			if (status != VMK_OK) {
				BNX2X_ERR("failed to dump firmware/chip "
					  "data %x %d!\n", status, idx);
				break;
			}
			/* Re-enable parity attentions */
			bnx2x_clear_blocks_parity(bp);
			bnx2x_enable_blocks_parity(bp);
			if (!(dmp->fw_hdr.flags & FWDMP_FLAGS_LIVE_DUMP))
				disable_pause(bp);
		}
	}
	/* restore firmware dump on disabled adapters */
	for (idx = 0; idx < BNX2X_MAX_NIC; idx++) {
		if (bnx2x_fwdmp_bp[idx].bp && bnx2x_fwdmp_bp[idx].disable_fwdmp)
			bnx2x_fwdmp_bp[idx].disable_fwdmp = 0;
	}
	return status;
}

/*
 * Disable firmware dump on netdump worker NIC (bp) such that, the
 * grcDump, which is very intrusive, won't interrupt netdump
 * traffic. Besides the netdump worker NIC, we also need to disable
 * grcDump on other functions that shared the same device as worker
 * NIC function.
 */
void bnx2x_disable_esx_fwdmp(struct bnx2x *bp)
{
	u32 i, j;
	for (i = 0; i < BNX2X_MAX_NIC; i++) {
		if (bnx2x_fwdmp_bp[i].bp == bp) {
			struct bnx2x *fw_bp;

			bnx2x_fwdmp_bp[i].disable_fwdmp = 1;
			netdev_info(bp->dev,
			   "Firmware dump disabled on netdump worker "
			   "(bp=%p, %d).\n",
			   bp, i);
			for (j = 0; j < BNX2X_MAX_NIC; j++) {
				fw_bp = bnx2x_fwdmp_bp[j].bp;
				/* disable fw dmp on the functions that
				   shared the same device as well */
				if (fw_bp && fw_bp != bp &&
				    fw_bp->pdev->bus == bp->pdev->bus) {
					bnx2x_fwdmp_bp[j].disable_fwdmp = 1;
					netdev_info(fw_bp->dev,
					   "Firmware dump disabled on function "
					   "sharing the same device (bp=%p, %d).\n",
					   fw_bp, j);
					fw_bp->poll_disable_fwdmp = 1;
				}
			}
			bp->poll_disable_fwdmp = 1;
			break;
		}
	}
}
#endif
/*******************/