[deliverable/linux.git] / drivers / net / ethernet / intel / igb / e1000_mbx.c

/*******************************************************************************

  Intel(R) Gigabit Ethernet Linux driver
  Copyright(c) 2007-2014 Intel Corporation.

  This program is free software; you can redistribute it and/or modify it
  under the terms and conditions of the GNU General Public License,
  version 2, as published by the Free Software Foundation.

  This program is distributed in the hope it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  more details.

  You should have received a copy of the GNU General Public License along with
  this program; if not, see <http://www.gnu.org/licenses/>.

  The full GNU General Public License is included in this distribution in
  the file called "COPYING".

  Contact Information:
  e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
  Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497

*******************************************************************************/

#include "e1000_mbx.h"

/**
 *  igb_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 igb_read_mbx(struct e1000_hw *hw, u32 *msg, u16 size, u16 mbx_id)
{
	struct e1000_mbx_info *mbx = &hw->mbx;
	s32 ret_val = -E1000_ERR_MBX;

	/* limit read to size of mailbox */
	if (size > mbx->size)
		size = mbx->size;

	if (mbx->ops.read)
		ret_val = mbx->ops.read(hw, msg, size, mbx_id);

	return ret_val;
}

/**
 *  igb_write_mbx - 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
 **/
s32 igb_write_mbx(struct e1000_hw *hw, u32 *msg, u16 size, u16 mbx_id)
{
	struct e1000_mbx_info *mbx = &hw->mbx;
	s32 ret_val = 0;

	if (size > mbx->size)
		ret_val = -E1000_ERR_MBX;

	else if (mbx->ops.write)
		ret_val = mbx->ops.write(hw, msg, size, mbx_id);

	return ret_val;
}

/**
 *  igb_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 igb_check_for_msg(struct e1000_hw *hw, u16 mbx_id)
{
	struct e1000_mbx_info *mbx = &hw->mbx;
	s32 ret_val = -E1000_ERR_MBX;

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

	return ret_val;
}

/**
 *  igb_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 igb_check_for_ack(struct e1000_hw *hw, u16 mbx_id)
{
	struct e1000_mbx_info *mbx = &hw->mbx;
	s32 ret_val = -E1000_ERR_MBX;

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

	return ret_val;
}

/**
 *  igb_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 igb_check_for_rst(struct e1000_hw *hw, u16 mbx_id)
{
	struct e1000_mbx_info *mbx = &hw->mbx;
	s32 ret_val = -E1000_ERR_MBX;

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

	return ret_val;
}

/**
 *  igb_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 igb_poll_for_msg(struct e1000_hw *hw, u16 mbx_id)
{
	struct e1000_mbx_info *mbx = &hw->mbx;
	int countdown = mbx->timeout;

	if (!countdown || !mbx->ops.check_for_msg)
		goto out;

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

	/* if we failed, all future posted messages fail until reset */
	if (!countdown)
		mbx->timeout = 0;
out:
	return countdown ? 0 : -E1000_ERR_MBX;
}

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

	if (!countdown || !mbx->ops.check_for_ack)
		goto out;

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

	/* if we failed, all future posted messages fail until reset */
	if (!countdown)
		mbx->timeout = 0;
out:
	return countdown ? 0 : -E1000_ERR_MBX;
}

/**
 *  igb_read_posted_mbx - Wait for message notification and receive message
 *  @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 received a message notification and
 *  copied it into the receive buffer.
 **/
static s32 igb_read_posted_mbx(struct e1000_hw *hw, u32 *msg, u16 size,
			       u16 mbx_id)
{
	struct e1000_mbx_info *mbx = &hw->mbx;
	s32 ret_val = -E1000_ERR_MBX;

	if (!mbx->ops.read)
		goto out;

	ret_val = igb_poll_for_msg(hw, mbx_id);

	if (!ret_val)
		ret_val = mbx->ops.read(hw, msg, size, mbx_id);
out:
	return ret_val;
}

/**
 *  igb_write_posted_mbx - Write a message to the mailbox, 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 delay * timeout period
 **/
static s32 igb_write_posted_mbx(struct e1000_hw *hw, u32 *msg, u16 size,
				u16 mbx_id)
{
	struct e1000_mbx_info *mbx = &hw->mbx;
	s32 ret_val = -E1000_ERR_MBX;

	/* exit if either we can't write or there isn't a defined timeout */
	if (!mbx->ops.write || !mbx->timeout)
		goto out;

	/* send msg */
	ret_val = mbx->ops.write(hw, msg, size, mbx_id);

	/* if msg sent wait until we receive an ack */
	if (!ret_val)
		ret_val = igb_poll_for_ack(hw, mbx_id);
out:
	return ret_val;
}

static s32 igb_check_for_bit_pf(struct e1000_hw *hw, u32 mask)
{
	u32 mbvficr = rd32(E1000_MBVFICR);
	s32 ret_val = -E1000_ERR_MBX;

	if (mbvficr & mask) {
		ret_val = 0;
		wr32(E1000_MBVFICR, mask);
	}

	return ret_val;
}

/**
 *  igb_check_for_msg_pf - checks to see if the VF has sent mail
 *  @hw: pointer to the HW structure
 *  @vf_number: the VF index
 *
 *  returns SUCCESS if the VF has set the Status bit or else ERR_MBX
 **/
static s32 igb_check_for_msg_pf(struct e1000_hw *hw, u16 vf_number)
{
	s32 ret_val = -E1000_ERR_MBX;

	if (!igb_check_for_bit_pf(hw, E1000_MBVFICR_VFREQ_VF1 << vf_number)) {
		ret_val = 0;
		hw->mbx.stats.reqs++;
	}

	return ret_val;
}

/**
 *  igb_check_for_ack_pf - checks to see if the VF has ACKed
 *  @hw: pointer to the HW structure
 *  @vf_number: the VF index
 *
 *  returns SUCCESS if the VF has set the Status bit or else ERR_MBX
 **/
static s32 igb_check_for_ack_pf(struct e1000_hw *hw, u16 vf_number)
{
	s32 ret_val = -E1000_ERR_MBX;

	if (!igb_check_for_bit_pf(hw, E1000_MBVFICR_VFACK_VF1 << vf_number)) {
		ret_val = 0;
		hw->mbx.stats.acks++;
	}

	return ret_val;
}

/**
 *  igb_check_for_rst_pf - checks to see if the VF has reset
 *  @hw: pointer to the HW structure
 *  @vf_number: the VF index
 *
 *  returns SUCCESS if the VF has set the Status bit or else ERR_MBX
 **/
static s32 igb_check_for_rst_pf(struct e1000_hw *hw, u16 vf_number)
{
	u32 vflre = rd32(E1000_VFLRE);
	s32 ret_val = -E1000_ERR_MBX;

	if (vflre & (1 << vf_number)) {
		ret_val = 0;
		wr32(E1000_VFLRE, (1 << vf_number));
		hw->mbx.stats.rsts++;
	}

	return ret_val;
}

/**
 *  igb_obtain_mbx_lock_pf - obtain mailbox lock
 *  @hw: pointer to the HW structure
 *  @vf_number: the VF index
 *
 *  return SUCCESS if we obtained the mailbox lock
 **/
static s32 igb_obtain_mbx_lock_pf(struct e1000_hw *hw, u16 vf_number)
{
	s32 ret_val = -E1000_ERR_MBX;
	u32 p2v_mailbox;

	/* Take ownership of the buffer */
	wr32(E1000_P2VMAILBOX(vf_number), E1000_P2VMAILBOX_PFU);

	/* reserve mailbox for vf use */
	p2v_mailbox = rd32(E1000_P2VMAILBOX(vf_number));
	if (p2v_mailbox & E1000_P2VMAILBOX_PFU)
		ret_val = 0;

	return ret_val;
}

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

	/* lock the mailbox to prevent pf/vf race condition */
	ret_val = igb_obtain_mbx_lock_pf(hw, vf_number);
	if (ret_val)
		goto out_no_write;

	/* flush msg and acks as we are overwriting the message buffer */
	igb_check_for_msg_pf(hw, vf_number);
	igb_check_for_ack_pf(hw, vf_number);

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

	/* Interrupt VF to tell it a message has been sent and release buffer*/
	wr32(E1000_P2VMAILBOX(vf_number), E1000_P2VMAILBOX_STS);

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

out_no_write:
	return ret_val;

}

/**
 *  igb_read_mbx_pf - Read a message from the mailbox
 *  @hw: pointer to the HW structure
 *  @msg: The message buffer
 *  @size: Length of buffer
 *  @vf_number: 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 igb_read_mbx_pf(struct e1000_hw *hw, u32 *msg, u16 size,
			   u16 vf_number)
{
	s32 ret_val;
	u16 i;

	/* lock the mailbox to prevent pf/vf race condition */
	ret_val = igb_obtain_mbx_lock_pf(hw, vf_number);
	if (ret_val)
		goto out_no_read;

	/* copy the message to the mailbox memory buffer */
	for (i = 0; i < size; i++)
		msg[i] = array_rd32(E1000_VMBMEM(vf_number), i);

	/* Acknowledge the message and release buffer */
	wr32(E1000_P2VMAILBOX(vf_number), E1000_P2VMAILBOX_ACK);

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

out_no_read:
	return ret_val;
}

/**
 *  e1000_init_mbx_params_pf - set initial values for pf mailbox
 *  @hw: pointer to the HW structure
 *
 *  Initializes the hw->mbx struct to correct values for pf mailbox
 */
s32 igb_init_mbx_params_pf(struct e1000_hw *hw)
{
	struct e1000_mbx_info *mbx = &hw->mbx;

	mbx->timeout = 0;
	mbx->usec_delay = 0;

	mbx->size = E1000_VFMAILBOX_SIZE;

	mbx->ops.read = igb_read_mbx_pf;
	mbx->ops.write = igb_write_mbx_pf;
	mbx->ops.read_posted = igb_read_posted_mbx;
	mbx->ops.write_posted = igb_write_posted_mbx;
	mbx->ops.check_for_msg = igb_check_for_msg_pf;
	mbx->ops.check_for_ack = igb_check_for_ack_pf;
	mbx->ops.check_for_rst = igb_check_for_rst_pf;

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

	return 0;
}
Commit	Line	Data
4ae196df AD	1	/*******************************************************************************
	2
	3	Intel(R) Gigabit Ethernet Linux driver
74cfb2e1	4	Copyright(c) 2007-2014 Intel Corporation.
4ae196df AD	5
	6	This program is free software; you can redistribute it and/or modify it
	7	under the terms and conditions of the GNU General Public License,
	8	version 2, as published by the Free Software Foundation.
	9
	10	This program is distributed in the hope it will be useful, but WITHOUT
	11	ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	12	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	13	more details.
	14
	15	You should have received a copy of the GNU General Public License along with
74cfb2e1	16	this program; if not, see <http://www.gnu.org/licenses/>.
4ae196df AD	17
	18	The full GNU General Public License is included in this distribution in
	19	the file called "COPYING".
	20
	21	Contact Information:
	22	e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
	23	Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
	24
	25	*******************************************************************************/
	26
	27	#include "e1000_mbx.h"
	28
	29	/**
	30	* igb_read_mbx - Reads a message from the mailbox
	31	* @hw: pointer to the HW structure
	32	* @msg: The message buffer
	33	* @size: Length of buffer
	34	* @mbx_id: id of mailbox to read
	35	*
bfb9035c	36	* returns SUCCESS if it successfully read message from buffer
4ae196df AD	37	**/
	38	s32 igb_read_mbx(struct e1000_hw hw, u32 msg, u16 size, u16 mbx_id)
	39	{
	40	struct e1000_mbx_info *mbx = &hw->mbx;
	41	s32 ret_val = -E1000_ERR_MBX;
	42
	43	/* limit read to size of mailbox */
	44	if (size > mbx->size)
	45	size = mbx->size;
	46
	47	if (mbx->ops.read)
	48	ret_val = mbx->ops.read(hw, msg, size, mbx_id);
	49
	50	return ret_val;
	51	}
	52
	53	/**
	54	* igb_write_mbx - Write a message to the mailbox
	55	* @hw: pointer to the HW structure
	56	* @msg: The message buffer
	57	* @size: Length of buffer
	58	* @mbx_id: id of mailbox to write
	59	*
	60	* returns SUCCESS if it successfully copied message into the buffer
	61	**/
	62	s32 igb_write_mbx(struct e1000_hw hw, u32 msg, u16 size, u16 mbx_id)
	63	{
	64	struct e1000_mbx_info *mbx = &hw->mbx;
	65	s32 ret_val = 0;
	66
	67	if (size > mbx->size)
	68	ret_val = -E1000_ERR_MBX;
	69
	70	else if (mbx->ops.write)
	71	ret_val = mbx->ops.write(hw, msg, size, mbx_id);
	72
	73	return ret_val;
	74	}
	75
	76	/**
	77	* igb_check_for_msg - checks to see if someone sent us mail
	78	* @hw: pointer to the HW structure
	79	* @mbx_id: id of mailbox to check
	80	*
	81	* returns SUCCESS if the Status bit was found or else ERR_MBX
	82	**/
	83	s32 igb_check_for_msg(struct e1000_hw *hw, u16 mbx_id)
	84	{
	85	struct e1000_mbx_info *mbx = &hw->mbx;
	86	s32 ret_val = -E1000_ERR_MBX;
	87
	88	if (mbx->ops.check_for_msg)
	89	ret_val = mbx->ops.check_for_msg(hw, mbx_id);
	90
	91	return ret_val;
	92	}
	93
	94	/**
	95	* igb_check_for_ack - checks to see if someone sent us ACK
	96	* @hw: pointer to the HW structure
	97	* @mbx_id: id of mailbox to check
	98	*
	99	* returns SUCCESS if the Status bit was found or else ERR_MBX
	100	**/
101	s32 igb_check_for_ack(struct e1000_hw *hw, u16 mbx_id)
102	{
103	struct e1000_mbx_info *mbx = &hw->mbx;
104	s32 ret_val = -E1000_ERR_MBX;
105
106	if (mbx->ops.check_for_ack)
107	ret_val = mbx->ops.check_for_ack(hw, mbx_id);
108
109	return ret_val;
110	}
111
112	/**
113	* igb_check_for_rst - checks to see if other side has reset
114	* @hw: pointer to the HW structure
115	* @mbx_id: id of mailbox to check
116	*
117	* returns SUCCESS if the Status bit was found or else ERR_MBX
118	**/
119	s32 igb_check_for_rst(struct e1000_hw *hw, u16 mbx_id)
120	{
121	struct e1000_mbx_info *mbx = &hw->mbx;
122	s32 ret_val = -E1000_ERR_MBX;
123
124	if (mbx->ops.check_for_rst)
125	ret_val = mbx->ops.check_for_rst(hw, mbx_id);
126
127	return ret_val;
128	}
129
130	/**
131	* igb_poll_for_msg - Wait for message notification
132	* @hw: pointer to the HW structure
133	* @mbx_id: id of mailbox to write
134	*
135	* returns SUCCESS if it successfully received a message notification
136	**/
137	static s32 igb_poll_for_msg(struct e1000_hw *hw, u16 mbx_id)
138	{
139	struct e1000_mbx_info *mbx = &hw->mbx;
140	int countdown = mbx->timeout;
141
3935358e	142	if (!countdown \|\| !mbx->ops.check_for_msg)
4ae196df AD	143	goto out;
4ae196df AD	144
3272686c	145	while (countdown && mbx->ops.check_for_msg(hw, mbx_id)) {
3935358e	146	countdown--;
4ae196df AD	147	if (!countdown)
4ae196df AD	148	break;
4ae196df AD	149	udelay(mbx->usec_delay);
4ae196df AD	150	}
3272686c AD	151
	152	/* if we failed, all future posted messages fail until reset */
	153	if (!countdown)
	154	mbx->timeout = 0;
4ae196df AD	155	out:
	156	return countdown ? 0 : -E1000_ERR_MBX;
	157	}
	158
	159	/**
	160	* igb_poll_for_ack - Wait for message acknowledgement
	161	* @hw: pointer to the HW structure
	162	* @mbx_id: id of mailbox to write
	163	*
	164	* returns SUCCESS if it successfully received a message acknowledgement
	165	**/
	166	static s32 igb_poll_for_ack(struct e1000_hw *hw, u16 mbx_id)
	167	{
	168	struct e1000_mbx_info *mbx = &hw->mbx;
	169	int countdown = mbx->timeout;
	170
3935358e	171	if (!countdown \|\| !mbx->ops.check_for_ack)
4ae196df AD	172	goto out;
4ae196df AD	173
3272686c	174	while (countdown && mbx->ops.check_for_ack(hw, mbx_id)) {
3935358e	175	countdown--;
4ae196df AD	176	if (!countdown)
4ae196df AD	177	break;
4ae196df AD	178	udelay(mbx->usec_delay);
4ae196df AD	179	}
3272686c AD	180
	181	/* if we failed, all future posted messages fail until reset */
	182	if (!countdown)
	183	mbx->timeout = 0;
4ae196df AD	184	out:
	185	return countdown ? 0 : -E1000_ERR_MBX;
	186	}
	187
	188	/**
	189	* igb_read_posted_mbx - Wait for message notification and receive message
	190	* @hw: pointer to the HW structure
	191	* @msg: The message buffer
	192	* @size: Length of buffer
	193	* @mbx_id: id of mailbox to write
	194	*
	195	* returns SUCCESS if it successfully received a message notification and
	196	* copied it into the receive buffer.
	197	**/
b980ac18 JK	198	static s32 igb_read_posted_mbx(struct e1000_hw hw, u32 msg, u16 size,
b980ac18 JK	199	u16 mbx_id)
4ae196df AD	200	{
	201	struct e1000_mbx_info *mbx = &hw->mbx;
	202	s32 ret_val = -E1000_ERR_MBX;
	203
	204	if (!mbx->ops.read)
	205	goto out;
	206
	207	ret_val = igb_poll_for_msg(hw, mbx_id);
	208
	209	if (!ret_val)
	210	ret_val = mbx->ops.read(hw, msg, size, mbx_id);
	211	out:
	212	return ret_val;
	213	}
	214
	215	/**
	216	* igb_write_posted_mbx - Write a message to the mailbox, wait for ack
	217	* @hw: pointer to the HW structure
	218	* @msg: The message buffer
	219	* @size: Length of buffer
	220	* @mbx_id: id of mailbox to write
	221	*
	222	* returns SUCCESS if it successfully copied message into the buffer and
	223	* received an ack to that message within delay * timeout period
	224	**/
b980ac18 JK	225	static s32 igb_write_posted_mbx(struct e1000_hw hw, u32 msg, u16 size,
b980ac18 JK	226	u16 mbx_id)
4ae196df AD	227	{
4ae196df AD	228	struct e1000_mbx_info *mbx = &hw->mbx;
3272686c	229	s32 ret_val = -E1000_ERR_MBX;
4ae196df	230
3272686c AD	231	/* exit if either we can't write or there isn't a defined timeout */
3272686c AD	232	if (!mbx->ops.write \|\| !mbx->timeout)
4ae196df AD	233	goto out;
4ae196df AD	234
3272686c	235	/* send msg */
4ae196df AD	236	ret_val = mbx->ops.write(hw, msg, size, mbx_id);
	237
	238	/* if msg sent wait until we receive an ack */
	239	if (!ret_val)
	240	ret_val = igb_poll_for_ack(hw, mbx_id);
	241	out:
	242	return ret_val;
	243	}
	244
4ae196df AD	245	static s32 igb_check_for_bit_pf(struct e1000_hw *hw, u32 mask)
	246	{
	247	u32 mbvficr = rd32(E1000_MBVFICR);
	248	s32 ret_val = -E1000_ERR_MBX;
	249
	250	if (mbvficr & mask) {
	251	ret_val = 0;
	252	wr32(E1000_MBVFICR, mask);
	253	}
	254
	255	return ret_val;
	256	}
	257
	258	/**
	259	* igb_check_for_msg_pf - checks to see if the VF has sent mail
	260	* @hw: pointer to the HW structure
	261	* @vf_number: the VF index
	262	*
	263	* returns SUCCESS if the VF has set the Status bit or else ERR_MBX
	264	**/
	265	static s32 igb_check_for_msg_pf(struct e1000_hw *hw, u16 vf_number)
	266	{
	267	s32 ret_val = -E1000_ERR_MBX;
	268
	269	if (!igb_check_for_bit_pf(hw, E1000_MBVFICR_VFREQ_VF1 << vf_number)) {
	270	ret_val = 0;
	271	hw->mbx.stats.reqs++;
	272	}
	273
	274	return ret_val;
	275	}
	276
	277	/**
	278	* igb_check_for_ack_pf - checks to see if the VF has ACKed
	279	* @hw: pointer to the HW structure
	280	* @vf_number: the VF index
	281	*
	282	* returns SUCCESS if the VF has set the Status bit or else ERR_MBX
	283	**/
	284	static s32 igb_check_for_ack_pf(struct e1000_hw *hw, u16 vf_number)
	285	{
	286	s32 ret_val = -E1000_ERR_MBX;
	287
	288	if (!igb_check_for_bit_pf(hw, E1000_MBVFICR_VFACK_VF1 << vf_number)) {
	289	ret_val = 0;
	290	hw->mbx.stats.acks++;
	291	}
	292
	293	return ret_val;
	294	}
	295
	296	/**
	297	* igb_check_for_rst_pf - checks to see if the VF has reset
	298	* @hw: pointer to the HW structure
	299	* @vf_number: the VF index
	300	*
	301	* returns SUCCESS if the VF has set the Status bit or else ERR_MBX
	302	**/
	303	static s32 igb_check_for_rst_pf(struct e1000_hw *hw, u16 vf_number)
	304	{
	305	u32 vflre = rd32(E1000_VFLRE);
	306	s32 ret_val = -E1000_ERR_MBX;
	307
	308	if (vflre & (1 << vf_number)) {
309	ret_val = 0;
310	wr32(E1000_VFLRE, (1 << vf_number));
311	hw->mbx.stats.rsts++;
312	}
313
314	return ret_val;
315	}
316
0acb6fde AD	317	/**
	318	* igb_obtain_mbx_lock_pf - obtain mailbox lock
	319	* @hw: pointer to the HW structure
	320	* @vf_number: the VF index
	321	*
	322	* return SUCCESS if we obtained the mailbox lock
	323	**/
	324	static s32 igb_obtain_mbx_lock_pf(struct e1000_hw *hw, u16 vf_number)
	325	{
	326	s32 ret_val = -E1000_ERR_MBX;
	327	u32 p2v_mailbox;
	328
0acb6fde AD	329	/* Take ownership of the buffer */
	330	wr32(E1000_P2VMAILBOX(vf_number), E1000_P2VMAILBOX_PFU);
	331
	332	/* reserve mailbox for vf use */
	333	p2v_mailbox = rd32(E1000_P2VMAILBOX(vf_number));
	334	if (p2v_mailbox & E1000_P2VMAILBOX_PFU)
	335	ret_val = 0;
	336
	337	return ret_val;
	338	}
	339
4ae196df AD	340	/**
	341	* igb_write_mbx_pf - Places a message in the mailbox
	342	* @hw: pointer to the HW structure
	343	* @msg: The message buffer
	344	* @size: Length of buffer
	345	* @vf_number: the VF index
	346	*
	347	* returns SUCCESS if it successfully copied message into the buffer
	348	**/
	349	static s32 igb_write_mbx_pf(struct e1000_hw hw, u32 msg, u16 size,
b980ac18	350	u16 vf_number)
4ae196df	351	{
0acb6fde	352	s32 ret_val;
4ae196df AD	353	u16 i;
4ae196df AD	354
0acb6fde AD	355	/* lock the mailbox to prevent pf/vf race condition */
	356	ret_val = igb_obtain_mbx_lock_pf(hw, vf_number);
	357	if (ret_val)
4ae196df	358	goto out_no_write;
4ae196df	359
0acb6fde	360	/* flush msg and acks as we are overwriting the message buffer */
4ae196df	361	igb_check_for_msg_pf(hw, vf_number);
0acb6fde	362	igb_check_for_ack_pf(hw, vf_number);
4ae196df AD	363
	364	/* copy the caller specified message to the mailbox memory buffer */
	365	for (i = 0; i < size; i++)
	366	array_wr32(E1000_VMBMEM(vf_number), i, msg[i]);
	367
	368	/* Interrupt VF to tell it a message has been sent and release buffer*/
	369	wr32(E1000_P2VMAILBOX(vf_number), E1000_P2VMAILBOX_STS);
	370
	371	/* update stats */
	372	hw->mbx.stats.msgs_tx++;
	373
	374	out_no_write:
	375	return ret_val;
	376
	377	}
	378
	379	/**
	380	* igb_read_mbx_pf - Read a message from the mailbox
	381	* @hw: pointer to the HW structure
	382	* @msg: The message buffer
	383	* @size: Length of buffer
	384	* @vf_number: the VF index
	385	*
	386	* This function copies a message from the mailbox buffer to the caller's
	387	* memory buffer. The presumption is that the caller knows that there was
	388	* a message due to a VF request so no polling for message is needed.
	389	**/
	390	static s32 igb_read_mbx_pf(struct e1000_hw hw, u32 msg, u16 size,
b980ac18	391	u16 vf_number)
4ae196df	392	{
0acb6fde	393	s32 ret_val;
4ae196df AD	394	u16 i;
4ae196df AD	395
0acb6fde AD	396	/* lock the mailbox to prevent pf/vf race condition */
	397	ret_val = igb_obtain_mbx_lock_pf(hw, vf_number);
	398	if (ret_val)
4ae196df	399	goto out_no_read;
4ae196df AD	400
	401	/* copy the message to the mailbox memory buffer */
	402	for (i = 0; i < size; i++)
	403	msg[i] = array_rd32(E1000_VMBMEM(vf_number), i);
	404
	405	/* Acknowledge the message and release buffer */
	406	wr32(E1000_P2VMAILBOX(vf_number), E1000_P2VMAILBOX_ACK);
	407
	408	/* update stats */
	409	hw->mbx.stats.msgs_rx++;
	410
4ae196df AD	411	out_no_read:
	412	return ret_val;
	413	}
	414
	415	/**
	416	* e1000_init_mbx_params_pf - set initial values for pf mailbox
	417	* @hw: pointer to the HW structure
	418	*
	419	* Initializes the hw->mbx struct to correct values for pf mailbox
	420	*/
	421	s32 igb_init_mbx_params_pf(struct e1000_hw *hw)
	422	{
	423	struct e1000_mbx_info *mbx = &hw->mbx;
	424
6b78bb1d CW	425	mbx->timeout = 0;
	426	mbx->usec_delay = 0;
	427
	428	mbx->size = E1000_VFMAILBOX_SIZE;
	429
	430	mbx->ops.read = igb_read_mbx_pf;
	431	mbx->ops.write = igb_write_mbx_pf;
	432	mbx->ops.read_posted = igb_read_posted_mbx;
	433	mbx->ops.write_posted = igb_write_posted_mbx;
	434	mbx->ops.check_for_msg = igb_check_for_msg_pf;
	435	mbx->ops.check_for_ack = igb_check_for_ack_pf;
	436	mbx->ops.check_for_rst = igb_check_for_rst_pf;
	437
	438	mbx->stats.msgs_tx = 0;
	439	mbx->stats.msgs_rx = 0;
	440	mbx->stats.reqs = 0;
	441	mbx->stats.acks = 0;
	442	mbx->stats.rsts = 0;
4ae196df AD	443
	444	return 0;
	445	}
	446