[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;
	int count = 10;

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