/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright(c) 2001-2024 Intel Corporation
 */

#include "ixgbe_type.h"
#include "ixgbe_mbx.h"

STATIC s32 ixgbe_poll_for_msg(struct ixgbe_hw *hw, u16 mbx_id);
STATIC s32 ixgbe_poll_for_ack(struct ixgbe_hw *hw, u16 mbx_id);

/**
 * ixgbe_read_mbx - Reads a message from the mailbox
 * @hw: pointer to the HW structure
 * @msg: The message buffer
 * @size: Length of buffer
 * @mbx_id: id of mailbox to read
 *
 * returns SUCCESS if it successfully read message from buffer
 **/
s32 ixgbe_read_mbx(struct ixgbe_hw *hw, u32 *msg, u16 size, u16 mbx_id)
{
	struct ixgbe_mbx_info *mbx = &hw->mbx;

	DEBUGFUNC("ixgbe_read_mbx");

	/* limit read to size of mailbox */
	if (size > mbx->size) {
		ERROR_REPORT3(IXGBE_ERROR_ARGUMENT,
			      "Invalid mailbox message size %u, changing to %u",
			      size, mbx->size);
		size = mbx->size;
	}

	if (mbx->ops[mbx_id].read)
		return mbx->ops[mbx_id].read(hw, msg, size, mbx_id);

	return IXGBE_ERR_CONFIG;
}

/**
 * ixgbe_poll_mbx - Wait for message and read it from the mailbox
 * @hw: pointer to the HW structure
 * @msg: The message buffer
 * @size: Length of buffer
 * @mbx_id: id of mailbox to read
 *
 * returns SUCCESS if it successfully read message from buffer
 **/
s32 ixgbe_poll_mbx(struct ixgbe_hw *hw, u32 *msg, u16 size, u16 mbx_id)
{
	struct ixgbe_mbx_info *mbx = &hw->mbx;
	s32 ret_val;

	DEBUGFUNC("ixgbe_poll_mbx");

	if (!mbx->ops[mbx_id].read || !mbx->ops[mbx_id].check_for_msg ||
	    !mbx->timeout)
		return IXGBE_ERR_CONFIG;

	/* limit read to size of mailbox */
	if (size > mbx->size) {
		ERROR_REPORT3(IXGBE_ERROR_ARGUMENT,
			      "Invalid mailbox message size %u, changing to %u",
			      size, mbx->size);
		size = mbx->size;
	}

	ret_val = ixgbe_poll_for_msg(hw, mbx_id);
	/* if ack received read message, otherwise we timed out */
	if (!ret_val)
		return mbx->ops[mbx_id].read(hw, msg, size, mbx_id);

	return ret_val;
}

/**
 * ixgbe_write_mbx - Write a message to the mailbox and wait for ACK
 * @hw: pointer to the HW structure
 * @msg: The message buffer
 * @size: Length of buffer
 * @mbx_id: id of mailbox to write
 *
 * returns SUCCESS if it successfully copied message into the buffer and
 * received an ACK to that message within specified period
 *
 * Note that the caller to this function must lock before calling, since
 * multiple threads can destroy each other messages.
 **/
s32 ixgbe_write_mbx(struct ixgbe_hw *hw, u32 *msg, u16 size, u16 mbx_id)
{
	struct ixgbe_mbx_info *mbx = &hw->mbx;
	s32 ret_val = IXGBE_ERR_MBX;

	DEBUGFUNC("ixgbe_write_mbx");

	/*
	 * exit if either we can't write, release
	 * or there is no timeout defined
	 */
	if (!mbx->ops[mbx_id].write || !mbx->ops[mbx_id].check_for_ack ||
	    !mbx->ops[mbx_id].release || !mbx->timeout)
		return IXGBE_ERR_CONFIG;

	if (size > mbx->size) {
		ret_val = IXGBE_ERR_PARAM;
		ERROR_REPORT2(IXGBE_ERROR_ARGUMENT,
			     "Invalid mailbox message size %u", size);
	} else {
		ret_val = mbx->ops[mbx_id].write(hw, msg, size, mbx_id);
	}

	return ret_val;
}

/**
 * ixgbe_check_for_msg - checks to see if someone sent us mail
 * @hw: pointer to the HW structure
 * @mbx_id: id of mailbox to check
 *
 * returns SUCCESS if the Status bit was found or else ERR_MBX
 **/
s32 ixgbe_check_for_msg(struct ixgbe_hw *hw, u16 mbx_id)
{
	struct ixgbe_mbx_info *mbx = &hw->mbx;
	s32 ret_val = IXGBE_ERR_CONFIG;

	DEBUGFUNC("ixgbe_check_for_msg");

	if (mbx->ops[mbx_id].check_for_msg)
		ret_val = mbx->ops[mbx_id].check_for_msg(hw, mbx_id);

	return ret_val;
}

/**
 * ixgbe_check_for_ack - checks to see if someone sent us ACK
 * @hw: pointer to the HW structure
 * @mbx_id: id of mailbox to check
 *
 * returns SUCCESS if the Status bit was found or else ERR_MBX
 **/
s32 ixgbe_check_for_ack(struct ixgbe_hw *hw, u16 mbx_id)
{
	struct ixgbe_mbx_info *mbx = &hw->mbx;
	s32 ret_val = IXGBE_ERR_CONFIG;

	DEBUGFUNC("ixgbe_check_for_ack");

	if (mbx->ops[mbx_id].check_for_ack)
		ret_val = mbx->ops[mbx_id].check_for_ack(hw, mbx_id);

	return ret_val;
}

/**
 * ixgbe_check_for_rst - checks to see if other side has reset
 * @hw: pointer to the HW structure
 * @mbx_id: id of mailbox to check
 *
 * returns SUCCESS if the Status bit was found or else ERR_MBX
 **/
s32 ixgbe_check_for_rst(struct ixgbe_hw *hw, u16 mbx_id)
{
	struct ixgbe_mbx_info *mbx = &hw->mbx;
	s32 ret_val = IXGBE_ERR_CONFIG;

	DEBUGFUNC("ixgbe_check_for_rst");

	if (mbx->ops[mbx_id].check_for_rst)
		ret_val = mbx->ops[mbx_id].check_for_rst(hw, mbx_id);

	return ret_val;
}

/**
 * ixgbe_clear_mbx - Clear Mailbox Memory
 * @hw: pointer to the HW structure
 * @mbx_id: id of mailbox to write
 *
 * Set VFMBMEM of given VF to 0x0.
 **/
s32 ixgbe_clear_mbx(struct ixgbe_hw *hw, u16 mbx_id)
{
	struct ixgbe_mbx_info *mbx = &hw->mbx;
	s32 ret_val = IXGBE_ERR_CONFIG;

	DEBUGFUNC("ixgbe_clear_mbx");

	if (mbx->ops[mbx_id].clear)
		ret_val = mbx->ops[mbx_id].clear(hw, mbx_id);

	return ret_val;
}

/**
 * ixgbe_poll_for_msg - Wait for message notification
 * @hw: pointer to the HW structure
 * @mbx_id: id of mailbox to write
 *
 * returns SUCCESS if it successfully received a message notification
 **/
STATIC s32 ixgbe_poll_for_msg(struct ixgbe_hw *hw, u16 mbx_id)
{
	struct ixgbe_mbx_info *mbx = &hw->mbx;
	int countdown = mbx->timeout;

	DEBUGFUNC("ixgbe_poll_for_msg");

	if (!countdown || !mbx->ops[mbx_id].check_for_msg)
		return IXGBE_ERR_CONFIG;

	while (countdown && mbx->ops[mbx_id].check_for_msg(hw, mbx_id)) {
		countdown--;
		if (!countdown)
			break;
		usec_delay(mbx->usec_delay);
	}

	if (countdown == 0) {
		ERROR_REPORT2(IXGBE_ERROR_POLLING,
			   "Polling for VF%u mailbox message timedout", mbx_id);
		return IXGBE_ERR_TIMEOUT;
	}

	return IXGBE_SUCCESS;
}

/**
 * ixgbe_poll_for_ack - Wait for message acknowledgment
 * @hw: pointer to the HW structure
 * @mbx_id: id of mailbox to write
 *
 * returns SUCCESS if it successfully received a message acknowledgment
 **/
STATIC s32 ixgbe_poll_for_ack(struct ixgbe_hw *hw, u16 mbx_id)
{
	struct ixgbe_mbx_info *mbx = &hw->mbx;
	int countdown = mbx->timeout;

	DEBUGFUNC("ixgbe_poll_for_ack");

	if (!countdown || !mbx->ops[mbx_id].check_for_ack)
		return IXGBE_ERR_CONFIG;

	while (countdown && mbx->ops[mbx_id].check_for_ack(hw, mbx_id)) {
		countdown--;
		if (!countdown)
			break;
		usec_delay(mbx->usec_delay);
	}

	if (countdown == 0) {
		ERROR_REPORT2(IXGBE_ERROR_POLLING,
			     "Polling for VF%u mailbox ack timedout", mbx_id);
		return IXGBE_ERR_TIMEOUT;
	}

	return IXGBE_SUCCESS;
}

/**
 * ixgbe_read_mailbox_vf - read VF's mailbox register
 * @hw: pointer to the HW structure
 *
 * This function is used to read the mailbox register dedicated for VF without
 * losing the read to clear status bits.
 **/
STATIC u32 ixgbe_read_mailbox_vf(struct ixgbe_hw *hw)
{
	u32 vf_mailbox = IXGBE_READ_REG(hw, IXGBE_VFMAILBOX);

	vf_mailbox |= hw->mbx.vf_mailbox;
	hw->mbx.vf_mailbox |= vf_mailbox & IXGBE_VFMAILBOX_R2C_BITS;

	return vf_mailbox;
}

STATIC void ixgbe_clear_msg_vf(struct ixgbe_hw *hw)
{
	u32 vf_mailbox = ixgbe_read_mailbox_vf(hw);

	if (vf_mailbox & IXGBE_VFMAILBOX_PFSTS) {
		hw->mbx.stats.reqs++;
		hw->mbx.vf_mailbox &= ~IXGBE_VFMAILBOX_PFSTS;
	}
}

STATIC void ixgbe_clear_ack_vf(struct ixgbe_hw *hw)
{
	u32 vf_mailbox = ixgbe_read_mailbox_vf(hw);

	if (vf_mailbox & IXGBE_VFMAILBOX_PFACK) {
		hw->mbx.stats.acks++;
		hw->mbx.vf_mailbox &= ~IXGBE_VFMAILBOX_PFACK;
	}
}

STATIC void ixgbe_clear_rst_vf(struct ixgbe_hw *hw)
{
	u32 vf_mailbox = ixgbe_read_mailbox_vf(hw);

	if (vf_mailbox & (IXGBE_VFMAILBOX_RSTI | IXGBE_VFMAILBOX_RSTD)) {
		hw->mbx.stats.rsts++;
		hw->mbx.vf_mailbox &= ~(IXGBE_VFMAILBOX_RSTI |
					IXGBE_VFMAILBOX_RSTD);
	}
}

/**
 * ixgbe_check_for_bit_vf - Determine if a status bit was set
 * @hw: pointer to the HW structure
 * @mask: bitmask for bits to be tested and cleared
 *
 * This function is used to check for the read to clear bits within
 * the V2P mailbox.
 **/
STATIC s32 ixgbe_check_for_bit_vf(struct ixgbe_hw *hw, u32 mask)
{
	u32 vf_mailbox = ixgbe_read_mailbox_vf(hw);

	if (vf_mailbox & mask)
		return IXGBE_SUCCESS;

	return IXGBE_ERR_MBX;
}

/**
 * ixgbe_check_for_msg_vf - checks to see if the PF has sent mail
 * @hw: pointer to the HW structure
 * @mbx_id: id of mailbox to check
 *
 * returns SUCCESS if the PF has set the Status bit or else ERR_MBX
 **/
STATIC s32 ixgbe_check_for_msg_vf(struct ixgbe_hw *hw, u16 mbx_id)
{
	UNREFERENCED_1PARAMETER(mbx_id);
	DEBUGFUNC("ixgbe_check_for_msg_vf");

	if (!ixgbe_check_for_bit_vf(hw, IXGBE_VFMAILBOX_PFSTS))
		return IXGBE_SUCCESS;

	return IXGBE_ERR_MBX;
}

/**
 * ixgbe_check_for_ack_vf - checks to see if the PF has ACK'd
 * @hw: pointer to the HW structure
 * @mbx_id: id of mailbox to check
 *
 * returns SUCCESS if the PF has set the ACK bit or else ERR_MBX
 **/
STATIC s32 ixgbe_check_for_ack_vf(struct ixgbe_hw *hw, u16 mbx_id)
{
	UNREFERENCED_1PARAMETER(mbx_id);
	DEBUGFUNC("ixgbe_check_for_ack_vf");

	if (!ixgbe_check_for_bit_vf(hw, IXGBE_VFMAILBOX_PFACK)) {
		/* TODO: should this be autocleared? */
		ixgbe_clear_ack_vf(hw);
		return IXGBE_SUCCESS;
	}

	return IXGBE_ERR_MBX;
}

/**
 * ixgbe_check_for_rst_vf - checks to see if the PF has reset
 * @hw: pointer to the HW structure
 * @mbx_id: id of mailbox to check
 *
 * returns true if the PF has set the reset done bit or else false
 **/
STATIC s32 ixgbe_check_for_rst_vf(struct ixgbe_hw *hw, u16 mbx_id)
{
	UNREFERENCED_1PARAMETER(mbx_id);
	DEBUGFUNC("ixgbe_check_for_rst_vf");

	if (!ixgbe_check_for_bit_vf(hw, IXGBE_VFMAILBOX_RSTI |
					  IXGBE_VFMAILBOX_RSTD)) {
		/* TODO: should this be autocleared? */
		ixgbe_clear_rst_vf(hw);
		return IXGBE_SUCCESS;
	}

	return IXGBE_ERR_MBX;
}

/**
 * ixgbe_obtain_mbx_lock_vf - obtain mailbox lock
 * @hw: pointer to the HW structure
 *
 * return SUCCESS if we obtained the mailbox lock
 **/
STATIC s32 ixgbe_obtain_mbx_lock_vf(struct ixgbe_hw *hw)
{
	struct ixgbe_mbx_info *mbx = &hw->mbx;
	int countdown = mbx->timeout;
	s32 ret_val = IXGBE_ERR_MBX;
	u32 vf_mailbox;

	DEBUGFUNC("ixgbe_obtain_mbx_lock_vf");

	if (!mbx->timeout)
		return IXGBE_ERR_CONFIG;

	while (countdown--) {
		/* Reserve mailbox for VF use */
		vf_mailbox = ixgbe_read_mailbox_vf(hw);
		vf_mailbox |= IXGBE_VFMAILBOX_VFU;
		IXGBE_WRITE_REG(hw, IXGBE_VFMAILBOX, vf_mailbox);

		/* Verify that VF is the owner of the lock */
		if (ixgbe_read_mailbox_vf(hw) & IXGBE_VFMAILBOX_VFU) {
			ret_val = IXGBE_SUCCESS;
			break;
		}

		/* Wait a bit before trying again */
		usec_delay(mbx->usec_delay);
	}

	if (ret_val != IXGBE_SUCCESS) {
		ERROR_REPORT1(IXGBE_ERROR_INVALID_STATE,
				"Failed to obtain mailbox lock");
		ret_val = IXGBE_ERR_TIMEOUT;
	}

	return ret_val;
}

/**
 * ixgbe_release_mbx_lock_dummy - release mailbox lock
 * @hw: pointer to the HW structure
 * @mbx_id: id of mailbox to read
 **/
STATIC void ixgbe_release_mbx_lock_dummy(struct ixgbe_hw *hw, u16 mbx_id)
{
	UNREFERENCED_2PARAMETER(hw, mbx_id);

	DEBUGFUNC("ixgbe_release_mbx_lock_dummy");
}

/**
 * ixgbe_release_mbx_lock_vf - release mailbox lock
 * @hw: pointer to the HW structure
 * @mbx_id: id of mailbox to read
 **/
STATIC void ixgbe_release_mbx_lock_vf(struct ixgbe_hw *hw, u16 mbx_id)
{
	u32 vf_mailbox;

	UNREFERENCED_1PARAMETER(mbx_id);

	DEBUGFUNC("ixgbe_release_mbx_lock_vf");

	/* Return ownership of the buffer */
	vf_mailbox = ixgbe_read_mailbox_vf(hw);
	vf_mailbox &= ~IXGBE_VFMAILBOX_VFU;
	IXGBE_WRITE_REG(hw, IXGBE_VFMAILBOX, vf_mailbox);
}

/**
 * ixgbe_write_mbx_vf_legacy - Write a message to the mailbox
 * @hw: pointer to the HW structure
 * @msg: The message buffer
 * @size: Length of buffer
 * @mbx_id: id of mailbox to write
 *
 * returns SUCCESS if it successfully copied message into the buffer
 **/
STATIC s32 ixgbe_write_mbx_vf_legacy(struct ixgbe_hw *hw, u32 *msg, u16 size,
				     u16 mbx_id)
{
	s32 ret_val;
	u16 i;

	UNREFERENCED_1PARAMETER(mbx_id);
	DEBUGFUNC("ixgbe_write_mbx_vf_legacy");

	/* lock the mailbox to prevent pf/vf race condition */
	ret_val = ixgbe_obtain_mbx_lock_vf(hw);
	if (ret_val)
		return ret_val;

	/* flush msg and acks as we are overwriting the message buffer */
	ixgbe_check_for_msg_vf(hw, 0);
	ixgbe_clear_msg_vf(hw);
	ixgbe_check_for_ack_vf(hw, 0);
	ixgbe_clear_ack_vf(hw);

	/* copy the caller specified message to the mailbox memory buffer */
	for (i = 0; i < size; i++)
		IXGBE_WRITE_REG_ARRAY(hw, IXGBE_VFMBMEM, i, msg[i]);

	/* update stats */
	hw->mbx.stats.msgs_tx++;

	/* interrupt the PF to tell it a message has been sent */
	IXGBE_WRITE_REG(hw, IXGBE_VFMAILBOX, IXGBE_VFMAILBOX_REQ);

	return IXGBE_SUCCESS;
}

/**
 * ixgbe_write_mbx_vf - Write a message to the mailbox
 * @hw: pointer to the HW structure
 * @msg: The message buffer
 * @size: Length of buffer
 * @mbx_id: id of mailbox to write
 *
 * returns SUCCESS if it successfully copied message into the buffer
 **/
STATIC s32 ixgbe_write_mbx_vf(struct ixgbe_hw *hw, u32 *msg, u16 size,
			      u16 mbx_id)
{
	u32 vf_mailbox;
	s32 ret_val;
	u16 i;

	UNREFERENCED_1PARAMETER(mbx_id);

	DEBUGFUNC("ixgbe_write_mbx_vf");

	/* lock the mailbox to prevent pf/vf race condition */
	ret_val = ixgbe_obtain_mbx_lock_vf(hw);
	if (ret_val)
		goto out;

	/* flush msg and acks as we are overwriting the message buffer */
	ixgbe_clear_msg_vf(hw);
	ixgbe_clear_ack_vf(hw);

	/* copy the caller specified message to the mailbox memory buffer */
	for (i = 0; i < size; i++)
		IXGBE_WRITE_REG_ARRAY(hw, IXGBE_VFMBMEM, i, msg[i]);

	/* update stats */
	hw->mbx.stats.msgs_tx++;

	/* interrupt the PF to tell it a message has been sent */
	vf_mailbox = ixgbe_read_mailbox_vf(hw);
	vf_mailbox |= IXGBE_VFMAILBOX_REQ;
	IXGBE_WRITE_REG(hw, IXGBE_VFMAILBOX, vf_mailbox);

	/* if msg sent wait until we receive an ack */
	ixgbe_poll_for_ack(hw, mbx_id);

out:
	hw->mbx.ops[mbx_id].release(hw, mbx_id);

	return ret_val;
}

/**
 * ixgbe_read_mbx_vf_legacy - Reads a message from the inbox intended for vf
 * @hw: pointer to the HW structure
 * @msg: The message buffer
 * @size: Length of buffer
 * @mbx_id: id of mailbox to read
 *
 * returns SUCCESS if it successfully read message from buffer
 **/
STATIC s32 ixgbe_read_mbx_vf_legacy(struct ixgbe_hw *hw, u32 *msg, u16 size,
				    u16 mbx_id)
{
	s32 ret_val;
	u16 i;

	DEBUGFUNC("ixgbe_read_mbx_vf_legacy");
	UNREFERENCED_1PARAMETER(mbx_id);

	/* lock the mailbox to prevent pf/vf race condition */
	ret_val = ixgbe_obtain_mbx_lock_vf(hw);
	if (ret_val)
		return ret_val;

	/* copy the message from the mailbox memory buffer */
	for (i = 0; i < size; i++)
		msg[i] = IXGBE_READ_REG_ARRAY(hw, IXGBE_VFMBMEM, i);

	/* Acknowledge receipt and release mailbox, then we're done */
	IXGBE_WRITE_REG(hw, IXGBE_VFMAILBOX, IXGBE_VFMAILBOX_ACK);

	/* update stats */
	hw->mbx.stats.msgs_rx++;

	return IXGBE_SUCCESS;
}

/**
 * ixgbe_read_mbx_vf - Reads a message from the inbox intended for vf
 * @hw: pointer to the HW structure
 * @msg: The message buffer
 * @size: Length of buffer
 * @mbx_id: id of mailbox to read
 *
 * returns SUCCESS if it successfully read message from buffer
 **/
STATIC s32 ixgbe_read_mbx_vf(struct ixgbe_hw *hw, u32 *msg, u16 size,
			     u16 mbx_id)
{
	u32 vf_mailbox;
	s32 ret_val;
	u16 i;

	DEBUGFUNC("ixgbe_read_mbx_vf");
	UNREFERENCED_1PARAMETER(mbx_id);

	/* check if there is a message from PF */
	ret_val = ixgbe_check_for_msg_vf(hw, 0);
	if (ret_val != IXGBE_SUCCESS)
		return IXGBE_ERR_MBX_NOMSG;

	ixgbe_clear_msg_vf(hw);

	/* copy the message from the mailbox memory buffer */
	for (i = 0; i < size; i++)
		msg[i] = IXGBE_READ_REG_ARRAY(hw, IXGBE_VFMBMEM, i);

	/* Acknowledge receipt */
	vf_mailbox = ixgbe_read_mailbox_vf(hw);
	vf_mailbox |= IXGBE_VFMAILBOX_ACK;
	IXGBE_WRITE_REG(hw, IXGBE_VFMAILBOX, vf_mailbox);

	/* update stats */
	hw->mbx.stats.msgs_rx++;

	return IXGBE_SUCCESS;
}

/**
 * ixgbe_init_mbx_params_vf - set initial values for vf mailbox
 * @hw: pointer to the HW structure
 *
 * Initializes single set the hw->mbx struct to correct values for vf mailbox
 * Set of legacy functions is being used here
 */
void ixgbe_init_mbx_params_vf(struct ixgbe_hw *hw)
{
	struct ixgbe_mbx_info *mbx = &hw->mbx;

	mbx->timeout = IXGBE_VF_MBX_INIT_TIMEOUT;
	mbx->usec_delay = IXGBE_VF_MBX_INIT_DELAY;

	mbx->size = IXGBE_VFMAILBOX_SIZE;

	/* VF has only one mailbox connection, no need for more IDs */
	mbx->ops[0].release = ixgbe_release_mbx_lock_dummy;
	mbx->ops[0].read = ixgbe_read_mbx_vf_legacy;
	mbx->ops[0].write = ixgbe_write_mbx_vf_legacy;
	mbx->ops[0].check_for_msg = ixgbe_check_for_msg_vf;
	mbx->ops[0].check_for_ack = ixgbe_check_for_ack_vf;
	mbx->ops[0].check_for_rst = ixgbe_check_for_rst_vf;
	mbx->ops[0].clear = NULL;

	mbx->stats.msgs_tx = 0;
	mbx->stats.msgs_rx = 0;
	mbx->stats.reqs = 0;
	mbx->stats.acks = 0;
	mbx->stats.rsts = 0;
}

/**
 * ixgbe_upgrade_mbx_params_vf - set initial values for vf mailbox
 * @hw: pointer to the HW structure
 *
 * Initializes the hw->mbx struct to correct values for vf mailbox
 */
void ixgbe_upgrade_mbx_params_vf(struct ixgbe_hw *hw)
{
	struct ixgbe_mbx_info *mbx = &hw->mbx;

	mbx->timeout = IXGBE_VF_MBX_INIT_TIMEOUT;
	mbx->usec_delay = IXGBE_VF_MBX_INIT_DELAY;

	mbx->size = IXGBE_VFMAILBOX_SIZE;

	/* VF has only one mailbox connection, no need for more IDs */
	mbx->ops[0].release = ixgbe_release_mbx_lock_vf;
	mbx->ops[0].read = ixgbe_read_mbx_vf;
	mbx->ops[0].write = ixgbe_write_mbx_vf;
	mbx->ops[0].check_for_msg = ixgbe_check_for_msg_vf;
	mbx->ops[0].check_for_ack = ixgbe_check_for_ack_vf;
	mbx->ops[0].check_for_rst = ixgbe_check_for_rst_vf;
	mbx->ops[0].clear = NULL;

	mbx->stats.msgs_tx = 0;
	mbx->stats.msgs_rx = 0;
	mbx->stats.reqs = 0;
	mbx->stats.acks = 0;
	mbx->stats.rsts = 0;
}

STATIC void ixgbe_clear_msg_pf(struct ixgbe_hw *hw, u16 vf_id)
{
	u32 vf_shift = IXGBE_PFMBICR_SHIFT(vf_id);
	s32 index = IXGBE_PFMBICR_INDEX(vf_id);
	u32 pfmbicr;

	pfmbicr = IXGBE_READ_REG(hw, IXGBE_PFMBICR(index));

	if (pfmbicr & (IXGBE_PFMBICR_VFREQ_VF1 << vf_shift))
		hw->mbx.stats.reqs++;

	IXGBE_WRITE_REG(hw, IXGBE_PFMBICR(index),
			IXGBE_PFMBICR_VFREQ_VF1 << vf_shift);
}

STATIC void ixgbe_clear_ack_pf(struct ixgbe_hw *hw, u16 vf_id)
{
	u32 vf_shift = IXGBE_PFMBICR_SHIFT(vf_id);
	s32 index = IXGBE_PFMBICR_INDEX(vf_id);
	u32 pfmbicr;

	pfmbicr = IXGBE_READ_REG(hw, IXGBE_PFMBICR(index));

	if (pfmbicr & (IXGBE_PFMBICR_VFACK_VF1 << vf_shift))
		hw->mbx.stats.acks++;

	IXGBE_WRITE_REG(hw, IXGBE_PFMBICR(index),
			IXGBE_PFMBICR_VFACK_VF1 << vf_shift);
}

STATIC s32 ixgbe_check_for_bit_pf(struct ixgbe_hw *hw, u32 mask, s32 index)
{
	u32 pfmbicr = IXGBE_READ_REG(hw, IXGBE_PFMBICR(index));

	if (pfmbicr & mask)
		return IXGBE_SUCCESS;

	return IXGBE_ERR_MBX;
}

/**
 * ixgbe_check_for_msg_pf - checks to see if the VF has sent mail
 * @hw: pointer to the HW structure
 * @vf_id: the VF index
 *
 * returns SUCCESS if the VF has set the Status bit or else ERR_MBX
 **/
STATIC s32 ixgbe_check_for_msg_pf(struct ixgbe_hw *hw, u16 vf_id)
{
	u32 vf_shift = IXGBE_PFMBICR_SHIFT(vf_id);
	s32 index = IXGBE_PFMBICR_INDEX(vf_id);

	DEBUGFUNC("ixgbe_check_for_msg_pf");

	if (!ixgbe_check_for_bit_pf(hw, IXGBE_PFMBICR_VFREQ_VF1 << vf_shift,
				    index))
		return IXGBE_SUCCESS;

	return IXGBE_ERR_MBX;
}

/**
 * ixgbe_check_for_ack_pf - checks to see if the VF has ACKed
 * @hw: pointer to the HW structure
 * @vf_id: the VF index
 *
 * returns SUCCESS if the VF has set the Status bit or else ERR_MBX
 **/
STATIC s32 ixgbe_check_for_ack_pf(struct ixgbe_hw *hw, u16 vf_id)
{
	u32 vf_shift = IXGBE_PFMBICR_SHIFT(vf_id);
	s32 index = IXGBE_PFMBICR_INDEX(vf_id);
	s32 ret_val = IXGBE_ERR_MBX;

	DEBUGFUNC("ixgbe_check_for_ack_pf");

	if (!ixgbe_check_for_bit_pf(hw, IXGBE_PFMBICR_VFACK_VF1 << vf_shift,
				    index)) {
		ret_val = IXGBE_SUCCESS;
		/* TODO: should this be autocleared? */
		ixgbe_clear_ack_pf(hw, vf_id);
	}

	return ret_val;
}

/**
 * ixgbe_check_for_rst_pf - checks to see if the VF has reset
 * @hw: pointer to the HW structure
 * @vf_id: the VF index
 *
 * returns SUCCESS if the VF has set the Status bit or else ERR_MBX
 **/
STATIC s32 ixgbe_check_for_rst_pf(struct ixgbe_hw *hw, u16 vf_id)
{
	u32 vf_shift = IXGBE_PFVFLRE_SHIFT(vf_id);
	u32 index = IXGBE_PFVFLRE_INDEX(vf_id);
	s32 ret_val = IXGBE_ERR_MBX;
	u32 vflre = 0;

	DEBUGFUNC("ixgbe_check_for_rst_pf");

	switch (hw->mac.type) {
	case ixgbe_mac_82599EB:
		vflre = IXGBE_READ_REG(hw, IXGBE_PFVFLRE(index));
		break;
	case ixgbe_mac_X550:
	case ixgbe_mac_X550EM_x:
	case ixgbe_mac_X550EM_a:
	case ixgbe_mac_X540:
	case ixgbe_mac_E610:
		vflre = IXGBE_READ_REG(hw, IXGBE_PFVFLREC(index));
		break;
	default:
		break;
	}

	if (vflre & (1 << vf_shift)) {
		ret_val = IXGBE_SUCCESS;
		IXGBE_WRITE_REG(hw, IXGBE_PFVFLREC(index), (1 << vf_shift));
		hw->mbx.stats.rsts++;
	}

	return ret_val;
}

/**
 * ixgbe_obtain_mbx_lock_pf - obtain mailbox lock
 * @hw: pointer to the HW structure
 * @vf_id: the VF index
 *
 * return SUCCESS if we obtained the mailbox lock
 **/
STATIC s32 ixgbe_obtain_mbx_lock_pf(struct ixgbe_hw *hw, u16 vf_id)
{
	struct ixgbe_mbx_info *mbx = &hw->mbx;
	int countdown = mbx->timeout;
	s32 ret_val = IXGBE_ERR_MBX;
	u32 pf_mailbox;

	DEBUGFUNC("ixgbe_obtain_mbx_lock_pf");

	if (!mbx->timeout)
		return IXGBE_ERR_CONFIG;

	while (countdown--) {
		/* Reserve mailbox for PF use */
		pf_mailbox = IXGBE_READ_REG(hw, IXGBE_PFMAILBOX(vf_id));

		/* Check if other thread holds the PF lock already */
		if (pf_mailbox & IXGBE_PFMAILBOX_PFU)
			goto retry;

		pf_mailbox |= IXGBE_PFMAILBOX_PFU;
		IXGBE_WRITE_REG(hw, IXGBE_PFMAILBOX(vf_id), pf_mailbox);

		/* Verify that PF is the owner of the lock */
		pf_mailbox = IXGBE_READ_REG(hw, IXGBE_PFMAILBOX(vf_id));
		if (pf_mailbox & IXGBE_PFMAILBOX_PFU) {
			ret_val = IXGBE_SUCCESS;
			break;
		}

	retry:
		/* Wait a bit before trying again */
		usec_delay(mbx->usec_delay);
	}

	if (ret_val != IXGBE_SUCCESS) {
		ERROR_REPORT1(IXGBE_ERROR_INVALID_STATE,
			      "Failed to obtain mailbox lock");
		ret_val = IXGBE_ERR_TIMEOUT;
	}

	return ret_val;
}

/**
 * ixgbe_release_mbx_lock_pf - release mailbox lock
 * @hw: pointer to the HW structure
 * @vf_id: the VF index
 **/
STATIC void ixgbe_release_mbx_lock_pf(struct ixgbe_hw *hw, u16 vf_id)
{
	u32 pf_mailbox;

	DEBUGFUNC("ixgbe_release_mbx_lock_pf");

	/* Return ownership of the buffer */
	pf_mailbox = IXGBE_READ_REG(hw, IXGBE_PFMAILBOX(vf_id));
	pf_mailbox &= ~IXGBE_PFMAILBOX_PFU;
	IXGBE_WRITE_REG(hw, IXGBE_PFMAILBOX(vf_id), pf_mailbox);
}

/**
 * ixgbe_write_mbx_pf_legacy - Places a message in the mailbox
 * @hw: pointer to the HW structure
 * @msg: The message buffer
 * @size: Length of buffer
 * @vf_id: the VF index
 *
 * returns SUCCESS if it successfully copied message into the buffer
 **/
STATIC s32 ixgbe_write_mbx_pf_legacy(struct ixgbe_hw *hw, u32 *msg, u16 size,
				     u16 vf_id)
{
	s32 ret_val;
	u16 i;

	DEBUGFUNC("ixgbe_write_mbx_pf_legacy");

	/* lock the mailbox to prevent pf/vf race condition */
	ret_val = ixgbe_obtain_mbx_lock_pf(hw, vf_id);
	if (ret_val)
		return ret_val;

	/* flush msg and acks as we are overwriting the message buffer */
	ixgbe_check_for_msg_pf(hw, vf_id);
	ixgbe_clear_msg_pf(hw, vf_id);
	ixgbe_check_for_ack_pf(hw, vf_id);
	ixgbe_clear_ack_pf(hw, vf_id);

	/* copy the caller specified message to the mailbox memory buffer */
	for (i = 0; i < size; i++)
		IXGBE_WRITE_REG_ARRAY(hw, IXGBE_PFMBMEM(vf_id), i, msg[i]);

	/* Interrupt VF to tell it a message has been sent and release buffer*/
	IXGBE_WRITE_REG(hw, IXGBE_PFMAILBOX(vf_id), IXGBE_PFMAILBOX_STS);

	/* update stats */
	hw->mbx.stats.msgs_tx++;

	return IXGBE_SUCCESS;
}

/**
 * ixgbe_write_mbx_pf - Places a message in the mailbox
 * @hw: pointer to the HW structure
 * @msg: The message buffer
 * @size: Length of buffer
 * @vf_id: the VF index
 *
 * returns SUCCESS if it successfully copied message into the buffer
 **/
STATIC s32 ixgbe_write_mbx_pf(struct ixgbe_hw *hw, u32 *msg, u16 size,
			      u16 vf_id)
{
	u32 pf_mailbox;
	s32 ret_val;
	u16 i;

	DEBUGFUNC("ixgbe_write_mbx_pf");

	/* lock the mailbox to prevent pf/vf race condition */
	ret_val = ixgbe_obtain_mbx_lock_pf(hw, vf_id);
	if (ret_val)
		goto out;

	/* flush msg and acks as we are overwriting the message buffer */
	ixgbe_clear_msg_pf(hw, vf_id);
	ixgbe_clear_ack_pf(hw, vf_id);

	/* copy the caller specified message to the mailbox memory buffer */
	for (i = 0; i < size; i++)
		IXGBE_WRITE_REG_ARRAY(hw, IXGBE_PFMBMEM(vf_id), i, msg[i]);

	/* interrupt VF to tell it a message has been sent */
	pf_mailbox = IXGBE_READ_REG(hw, IXGBE_PFMAILBOX(vf_id));
	pf_mailbox |= IXGBE_PFMAILBOX_STS;
	IXGBE_WRITE_REG(hw, IXGBE_PFMAILBOX(vf_id), pf_mailbox);

	/* if msg sent wait until we receive an ack */
	if (msg[0] & IXGBE_VT_MSGTYPE_CTS)
		ixgbe_poll_for_ack(hw, vf_id);

	/* update stats */
	hw->mbx.stats.msgs_tx++;

out:
	hw->mbx.ops[vf_id].release(hw, vf_id);

	return ret_val;

}

/**
 * ixgbe_read_mbx_pf_legacy - Read a message from the mailbox
 * @hw: pointer to the HW structure
 * @msg: The message buffer
 * @size: Length of buffer
 * @vf_id: the VF index
 *
 * This function copies a message from the mailbox buffer to the caller's
 * memory buffer.  The presumption is that the caller knows that there was
 * a message due to a VF request so no polling for message is needed.
 **/
STATIC s32 ixgbe_read_mbx_pf_legacy(struct ixgbe_hw *hw, u32 *msg, u16 size,
				    u16 vf_id)
{
	s32 ret_val;
	u16 i;

	DEBUGFUNC("ixgbe_read_mbx_pf_legacy");

	/* lock the mailbox to prevent pf/vf race condition */
	ret_val = ixgbe_obtain_mbx_lock_pf(hw, vf_id);
	if (ret_val != IXGBE_SUCCESS)
		return ret_val;

	/* copy the message to the mailbox memory buffer */
	for (i = 0; i < size; i++)
		msg[i] = IXGBE_READ_REG_ARRAY(hw, IXGBE_PFMBMEM(vf_id), i);

	/* Acknowledge the message and release buffer */
	IXGBE_WRITE_REG(hw, IXGBE_PFMAILBOX(vf_id), IXGBE_PFMAILBOX_ACK);

	/* update stats */
	hw->mbx.stats.msgs_rx++;

	return IXGBE_SUCCESS;
}

/**
 * ixgbe_read_mbx_pf - Read a message from the mailbox
 * @hw: pointer to the HW structure
 * @msg: The message buffer
 * @size: Length of buffer
 * @vf_id: the VF index
 *
 * This function copies a message from the mailbox buffer to the caller's
 * memory buffer.  The presumption is that the caller knows that there was
 * a message due to a VF request so no polling for message is needed.
 **/
STATIC s32 ixgbe_read_mbx_pf(struct ixgbe_hw *hw, u32 *msg, u16 size,
			     u16 vf_id)
{
	u32 pf_mailbox;
	s32 ret_val;
	u16 i;

	DEBUGFUNC("ixgbe_read_mbx_pf");

	/* check if there is a message from VF */
	ret_val = ixgbe_check_for_msg_pf(hw, vf_id);
	if (ret_val != IXGBE_SUCCESS)
		return IXGBE_ERR_MBX_NOMSG;

	ixgbe_clear_msg_pf(hw, vf_id);

	/* copy the message to the mailbox memory buffer */
	for (i = 0; i < size; i++)
		msg[i] = IXGBE_READ_REG_ARRAY(hw, IXGBE_PFMBMEM(vf_id), i);

	/* Acknowledge the message and release buffer */
	pf_mailbox = IXGBE_READ_REG(hw, IXGBE_PFMAILBOX(vf_id));
	pf_mailbox |= IXGBE_PFMAILBOX_ACK;
	IXGBE_WRITE_REG(hw, IXGBE_PFMAILBOX(vf_id), pf_mailbox);

	/* update stats */
	hw->mbx.stats.msgs_rx++;

	return IXGBE_SUCCESS;
}

/**
 * ixgbe_clear_mbx_pf - Clear Mailbox Memory
 * @hw: pointer to the HW structure
 * @vf_id: the VF index
 *
 * Set VFMBMEM of given VF to 0x0.
 **/
STATIC s32 ixgbe_clear_mbx_pf(struct ixgbe_hw *hw, u16 vf_id)
{
	u16 mbx_size = hw->mbx.size;
	u16 i;

	if (vf_id > 63)
		return IXGBE_ERR_PARAM;

	for (i = 0; i < mbx_size; ++i)
		IXGBE_WRITE_REG_ARRAY(hw, IXGBE_PFMBMEM(vf_id), i, 0x0);

	return IXGBE_SUCCESS;
}

/**
 * ixgbe_init_mbx_params_pf_id - set initial values for pf mailbox
 * @hw: pointer to the HW structure
 * @vf_id: the VF index
 *
 * Initializes single set of the hw->mbx struct to correct values for pf mailbox
 * Set of legacy functions is being used here
 */
void ixgbe_init_mbx_params_pf_id(struct ixgbe_hw *hw, u16 vf_id)
{
	struct ixgbe_mbx_info *mbx = &hw->mbx;

	mbx->ops[vf_id].release = ixgbe_release_mbx_lock_dummy;
	mbx->ops[vf_id].read = ixgbe_read_mbx_pf_legacy;
	mbx->ops[vf_id].write = ixgbe_write_mbx_pf_legacy;
	mbx->ops[vf_id].check_for_msg = ixgbe_check_for_msg_pf;
	mbx->ops[vf_id].check_for_ack = ixgbe_check_for_ack_pf;
	mbx->ops[vf_id].check_for_rst = ixgbe_check_for_rst_pf;
	mbx->ops[vf_id].clear = ixgbe_clear_mbx_pf;
}

/**
 * ixgbe_init_mbx_params_pf - set initial values for pf mailbox
 * @hw: pointer to the HW structure
 *
 * Initializes all sets of the hw->mbx struct to correct values for pf
 * mailbox. One set corresponds to single VF. It also initializes counters
 * and general variables. A set of legacy functions is used by default.
 */
void ixgbe_init_mbx_params_pf(struct ixgbe_hw *hw)
{
	u16 i;
	struct ixgbe_mbx_info *mbx = &hw->mbx;

	/* Ensure we are not calling this function from VF */
	if (hw->mac.type != ixgbe_mac_82599EB &&
	    hw->mac.type != ixgbe_mac_X550 &&
	    hw->mac.type != ixgbe_mac_X550EM_x &&
	    hw->mac.type != ixgbe_mac_X550EM_a &&
	    hw->mac.type != ixgbe_mac_E610 &&
	    hw->mac.type != ixgbe_mac_X540)
		return;

	/* Initialize common mailbox settings */
	mbx->timeout = IXGBE_VF_MBX_INIT_TIMEOUT;
	mbx->usec_delay = IXGBE_VF_MBX_INIT_DELAY;
	mbx->size = IXGBE_VFMAILBOX_SIZE;

	/* Initialize counters with zeroes */
	mbx->stats.msgs_tx = 0;
	mbx->stats.msgs_rx = 0;
	mbx->stats.reqs = 0;
	mbx->stats.acks = 0;
	mbx->stats.rsts = 0;

	/* No matter of VF number, we initialize params for all 64 VFs. */
	/* TODO: 1. Add a define for max VF and refactor SHARED to get rid
	 * of magic number for that (63 or 64 depending on use case.)
	 * 2. rewrite the code to dynamically allocate mbx->ops[vf_id] for
	 * certain number of VFs instead of default maximum value of 64 (0..63)
	 */
	for (i = 0; i < 64; i++)
		ixgbe_init_mbx_params_pf_id(hw, i);
}

/**
 * ixgbe_upgrade_mbx_params_pf - Upgrade initial values for pf mailbox
 * @hw: pointer to the HW structure
 * @vf_id: the VF index
 *
 * Initializes the hw->mbx struct to new function set for improved
 * stability and handling of messages.
 */
void ixgbe_upgrade_mbx_params_pf(struct ixgbe_hw *hw, u16 vf_id)
{
	struct ixgbe_mbx_info *mbx = &hw->mbx;

	/* Ensure we are not calling this function from VF */
	if (hw->mac.type != ixgbe_mac_82599EB &&
	    hw->mac.type != ixgbe_mac_X550 &&
	    hw->mac.type != ixgbe_mac_X550EM_x &&
	    hw->mac.type != ixgbe_mac_X550EM_a &&
	    hw->mac.type != ixgbe_mac_E610 &&
	    hw->mac.type != ixgbe_mac_X540)
		return;

	mbx->timeout = IXGBE_VF_MBX_INIT_TIMEOUT;
	mbx->usec_delay = IXGBE_VF_MBX_INIT_DELAY;
	mbx->size = IXGBE_VFMAILBOX_SIZE;

	mbx->ops[vf_id].release = ixgbe_release_mbx_lock_pf;
	mbx->ops[vf_id].read = ixgbe_read_mbx_pf;
	mbx->ops[vf_id].write = ixgbe_write_mbx_pf;
	mbx->ops[vf_id].check_for_msg = ixgbe_check_for_msg_pf;
	mbx->ops[vf_id].check_for_ack = ixgbe_check_for_ack_pf;
	mbx->ops[vf_id].check_for_rst = ixgbe_check_for_rst_pf;
	mbx->ops[vf_id].clear = ixgbe_clear_mbx_pf;

	mbx->stats.msgs_tx = 0;
	mbx->stats.msgs_rx = 0;
	mbx->stats.reqs = 0;
	mbx->stats.acks = 0;
	mbx->stats.rsts = 0;
}
