[deliverable/linux.git] / drivers / net / ethernet / intel / igbvf / mbx.c

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

  Intel(R) 82576 Virtual Function Linux driver
  Copyright(c) 2009 - 2012 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 "mbx.h"

/**
 *  e1000_poll_for_msg - Wait for message notification
 *  @hw: pointer to the HW structure
 *
 *  returns SUCCESS if it successfully received a message notification
 **/
static s32 e1000_poll_for_msg(struct e1000_hw *hw)
{
	struct e1000_mbx_info *mbx = &hw->mbx;
	int countdown = mbx->timeout;

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

	while (countdown && mbx->ops.check_for_msg(hw)) {
		countdown--;
		udelay(mbx->usec_delay);
	}

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

/**
 *  e1000_poll_for_ack - Wait for message acknowledgment
 *  @hw: pointer to the HW structure
 *
 *  returns SUCCESS if it successfully received a message acknowledgment
 **/
static s32 e1000_poll_for_ack(struct e1000_hw *hw)
{
	struct e1000_mbx_info *mbx = &hw->mbx;
	int countdown = mbx->timeout;

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

	while (countdown && mbx->ops.check_for_ack(hw)) {
		countdown--;
		udelay(mbx->usec_delay);
	}

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

/**
 *  e1000_read_posted_mbx - Wait for message notification and receive message
 *  @hw: pointer to the HW structure
 *  @msg: The message buffer
 *  @size: Length of buffer
 *
 *  returns SUCCESS if it successfully received a message notification and
 *  copied it into the receive buffer.
 **/
static s32 e1000_read_posted_mbx(struct e1000_hw *hw, u32 *msg, u16 size)
{
	struct e1000_mbx_info *mbx = &hw->mbx;
	s32 ret_val = -E1000_ERR_MBX;

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

	ret_val = e1000_poll_for_msg(hw);

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

/**
 *  e1000_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
 *
 *  returns SUCCESS if it successfully copied message into the buffer and
 *  received an ack to that message within delay * timeout period
 **/
static s32 e1000_write_posted_mbx(struct e1000_hw *hw, u32 *msg, u16 size)
{
	struct e1000_mbx_info *mbx = &hw->mbx;
	s32 ret_val = -E1000_ERR_MBX;

	/* exit if we either 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);

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

/**
 *  e1000_read_v2p_mailbox - read v2p mailbox
 *  @hw: pointer to the HW structure
 *
 *  This function is used to read the v2p mailbox without losing the read to
 *  clear status bits.
 **/
static u32 e1000_read_v2p_mailbox(struct e1000_hw *hw)
{
	u32 v2p_mailbox = er32(V2PMAILBOX(0));

	v2p_mailbox |= hw->dev_spec.vf.v2p_mailbox;
	hw->dev_spec.vf.v2p_mailbox |= v2p_mailbox & E1000_V2PMAILBOX_R2C_BITS;

	return v2p_mailbox;
}

/**
 *  e1000_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 e1000_check_for_bit_vf(struct e1000_hw *hw, u32 mask)
{
	u32 v2p_mailbox = e1000_read_v2p_mailbox(hw);
	s32 ret_val = -E1000_ERR_MBX;

	if (v2p_mailbox & mask)
		ret_val = E1000_SUCCESS;

	hw->dev_spec.vf.v2p_mailbox &= ~mask;

	return ret_val;
}

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

	if (!e1000_check_for_bit_vf(hw, E1000_V2PMAILBOX_PFSTS)) {
		ret_val = E1000_SUCCESS;
		hw->mbx.stats.reqs++;
	}

	return ret_val;
}

/**
 *  e1000_check_for_ack_vf - checks to see if the PF has ACK'd
 *  @hw: pointer to the HW structure
 *
 *  returns SUCCESS if the PF has set the ACK bit or else ERR_MBX
 **/
static s32 e1000_check_for_ack_vf(struct e1000_hw *hw)
{
	s32 ret_val = -E1000_ERR_MBX;

	if (!e1000_check_for_bit_vf(hw, E1000_V2PMAILBOX_PFACK)) {
		ret_val = E1000_SUCCESS;
		hw->mbx.stats.acks++;
	}

	return ret_val;
}

/**
 *  e1000_check_for_rst_vf - checks to see if the PF has reset
 *  @hw: pointer to the HW structure
 *
 *  returns true if the PF has set the reset done bit or else false
 **/
static s32 e1000_check_for_rst_vf(struct e1000_hw *hw)
{
	s32 ret_val = -E1000_ERR_MBX;

	if (!e1000_check_for_bit_vf(hw, (E1000_V2PMAILBOX_RSTD |
					 E1000_V2PMAILBOX_RSTI))) {
		ret_val = E1000_SUCCESS;
		hw->mbx.stats.rsts++;
	}

	return ret_val;
}

/**
 *  e1000_obtain_mbx_lock_vf - obtain mailbox lock
 *  @hw: pointer to the HW structure
 *
 *  return SUCCESS if we obtained the mailbox lock
 **/
static s32 e1000_obtain_mbx_lock_vf(struct e1000_hw *hw)
{
	s32 ret_val = -E1000_ERR_MBX;

	/* Take ownership of the buffer */
	ew32(V2PMAILBOX(0), E1000_V2PMAILBOX_VFU);

	/* reserve mailbox for VF use */
	if (e1000_read_v2p_mailbox(hw) & E1000_V2PMAILBOX_VFU)
		ret_val = E1000_SUCCESS;

	return ret_val;
}

/**
 *  e1000_write_mbx_vf - Write a message to the mailbox
 *  @hw: pointer to the HW structure
 *  @msg: The message buffer
 *  @size: Length of buffer
 *
 *  returns SUCCESS if it successfully copied message into the buffer
 **/
static s32 e1000_write_mbx_vf(struct e1000_hw *hw, u32 *msg, u16 size)
{
	s32 err;
	u16 i;

	/* lock the mailbox to prevent pf/vf race condition */
	err = e1000_obtain_mbx_lock_vf(hw);
	if (err)
		goto out_no_write;

	/* flush any ack or msg as we are going to overwrite mailbox */
	e1000_check_for_ack_vf(hw);
	e1000_check_for_msg_vf(hw);

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

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

	/* Drop VFU and interrupt the PF to tell it a message has been sent */
	ew32(V2PMAILBOX(0), E1000_V2PMAILBOX_REQ);

out_no_write:
	return err;
}

/**
 *  e1000_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
 *
 *  returns SUCCESS if it successfully read message from buffer
 **/
static s32 e1000_read_mbx_vf(struct e1000_hw *hw, u32 *msg, u16 size)
{
	s32 err;
	u16 i;

	/* lock the mailbox to prevent pf/vf race condition */
	err = e1000_obtain_mbx_lock_vf(hw);
	if (err)
		goto out_no_read;

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

	/* Acknowledge receipt and release mailbox, then we're done */
	ew32(V2PMAILBOX(0), E1000_V2PMAILBOX_ACK);

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

out_no_read:
	return err;
}

/**
 *  e1000_init_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
 */
s32 e1000_init_mbx_params_vf(struct e1000_hw *hw)
{
	struct e1000_mbx_info *mbx = &hw->mbx;

	/* start mailbox as timed out and let the reset_hw call set the timeout
	 * value to being communications
	 */
	mbx->timeout = 0;
	mbx->usec_delay = E1000_VF_MBX_INIT_DELAY;

	mbx->size = E1000_VFMAILBOX_SIZE;

	mbx->ops.read = e1000_read_mbx_vf;
	mbx->ops.write = e1000_write_mbx_vf;
	mbx->ops.read_posted = e1000_read_posted_mbx;
	mbx->ops.write_posted = e1000_write_posted_mbx;
	mbx->ops.check_for_msg = e1000_check_for_msg_vf;
	mbx->ops.check_for_ack = e1000_check_for_ack_vf;
	mbx->ops.check_for_rst = e1000_check_for_rst_vf;

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

	return E1000_SUCCESS;
}
Commit	Line	Data
d4e0fe01 AD	1	/*******************************************************************************
	2
	3	Intel(R) 82576 Virtual Function Linux driver
2a06ed92	4	Copyright(c) 2009 - 2012 Intel Corporation.
d4e0fe01 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
0340501b	16	this program; if not, see <http://www.gnu.org/licenses/>.
d4e0fe01 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 "mbx.h"
	28
	29	/**
	30	* e1000_poll_for_msg - Wait for message notification
	31	* @hw: pointer to the HW structure
	32	*
	33	* returns SUCCESS if it successfully received a message notification
	34	**/
	35	static s32 e1000_poll_for_msg(struct e1000_hw *hw)
	36	{
	37	struct e1000_mbx_info *mbx = &hw->mbx;
	38	int countdown = mbx->timeout;
	39
	40	if (!mbx->ops.check_for_msg)
	41	goto out;
	42
	43	while (countdown && mbx->ops.check_for_msg(hw)) {
	44	countdown--;
	45	udelay(mbx->usec_delay);
	46	}
	47
	48	/* if we failed, all future posted messages fail until reset */
	49	if (!countdown)
	50	mbx->timeout = 0;
	51	out:
	52	return countdown ? E1000_SUCCESS : -E1000_ERR_MBX;
	53	}
	54
	55	/**
0340501b	56	* e1000_poll_for_ack - Wait for message acknowledgment
d4e0fe01 AD	57	* @hw: pointer to the HW structure
d4e0fe01 AD	58	*
0340501b	59	* returns SUCCESS if it successfully received a message acknowledgment
d4e0fe01 AD	60	**/
	61	static s32 e1000_poll_for_ack(struct e1000_hw *hw)
	62	{
	63	struct e1000_mbx_info *mbx = &hw->mbx;
	64	int countdown = mbx->timeout;
	65
	66	if (!mbx->ops.check_for_ack)
	67	goto out;
	68
	69	while (countdown && mbx->ops.check_for_ack(hw)) {
	70	countdown--;
	71	udelay(mbx->usec_delay);
	72	}
	73
	74	/* if we failed, all future posted messages fail until reset */
	75	if (!countdown)
	76	mbx->timeout = 0;
	77	out:
	78	return countdown ? E1000_SUCCESS : -E1000_ERR_MBX;
	79	}
	80
	81	/**
	82	* e1000_read_posted_mbx - Wait for message notification and receive message
	83	* @hw: pointer to the HW structure
	84	* @msg: The message buffer
	85	* @size: Length of buffer
	86	*
	87	* returns SUCCESS if it successfully received a message notification and
	88	* copied it into the receive buffer.
	89	**/
	90	static s32 e1000_read_posted_mbx(struct e1000_hw hw, u32 msg, u16 size)
	91	{
	92	struct e1000_mbx_info *mbx = &hw->mbx;
	93	s32 ret_val = -E1000_ERR_MBX;
	94
	95	if (!mbx->ops.read)
	96	goto out;
	97
	98	ret_val = e1000_poll_for_msg(hw);
	99
	100	/* if ack received read message, otherwise we timed out */
	101	if (!ret_val)
	102	ret_val = mbx->ops.read(hw, msg, size);
	103	out:
	104	return ret_val;
	105	}
	106
	107	/**
	108	* e1000_write_posted_mbx - Write a message to the mailbox, wait for ack
	109	* @hw: pointer to the HW structure
	110	* @msg: The message buffer
	111	* @size: Length of buffer
	112	*
	113	* returns SUCCESS if it successfully copied message into the buffer and
	114	* received an ack to that message within delay * timeout period
	115	**/
	116	static s32 e1000_write_posted_mbx(struct e1000_hw hw, u32 msg, u16 size)
	117	{
	118	struct e1000_mbx_info *mbx = &hw->mbx;
	119	s32 ret_val = -E1000_ERR_MBX;
	120
	121	/* exit if we either can't write or there isn't a defined timeout */
	122	if (!mbx->ops.write \|\| !mbx->timeout)
	123	goto out;
124
125	/* send msg*/
126	ret_val = mbx->ops.write(hw, msg, size);
127
128	/* if msg sent wait until we receive an ack */
129	if (!ret_val)
130	ret_val = e1000_poll_for_ack(hw);
131	out:
132	return ret_val;
133	}
134
135	/**
136	* e1000_read_v2p_mailbox - read v2p mailbox
137	* @hw: pointer to the HW structure
138	*
139	* This function is used to read the v2p mailbox without losing the read to
140	* clear status bits.
141	**/
142	static u32 e1000_read_v2p_mailbox(struct e1000_hw *hw)
143	{
144	u32 v2p_mailbox = er32(V2PMAILBOX(0));
145
146	v2p_mailbox \|= hw->dev_spec.vf.v2p_mailbox;
147	hw->dev_spec.vf.v2p_mailbox \|= v2p_mailbox & E1000_V2PMAILBOX_R2C_BITS;
148
149	return v2p_mailbox;
150	}
151
152	/**
153	* e1000_check_for_bit_vf - Determine if a status bit was set
154	* @hw: pointer to the HW structure
155	* @mask: bitmask for bits to be tested and cleared
156	*
157	* This function is used to check for the read to clear bits within
158	* the V2P mailbox.
159	**/
160	static s32 e1000_check_for_bit_vf(struct e1000_hw *hw, u32 mask)
161	{
162	u32 v2p_mailbox = e1000_read_v2p_mailbox(hw);
163	s32 ret_val = -E1000_ERR_MBX;
164
165	if (v2p_mailbox & mask)
166	ret_val = E1000_SUCCESS;
167
168	hw->dev_spec.vf.v2p_mailbox &= ~mask;
169
170	return ret_val;
171	}
172
173	/**
174	* e1000_check_for_msg_vf - checks to see if the PF has sent mail
175	* @hw: pointer to the HW structure
176	*
177	* returns SUCCESS if the PF has set the Status bit or else ERR_MBX
178	**/
179	static s32 e1000_check_for_msg_vf(struct e1000_hw *hw)
180	{
181	s32 ret_val = -E1000_ERR_MBX;
182
183	if (!e1000_check_for_bit_vf(hw, E1000_V2PMAILBOX_PFSTS)) {
184	ret_val = E1000_SUCCESS;
185	hw->mbx.stats.reqs++;
186	}
187
188	return ret_val;
189	}
190
191	/**
192	* e1000_check_for_ack_vf - checks to see if the PF has ACK'd
193	* @hw: pointer to the HW structure
194	*
195	* returns SUCCESS if the PF has set the ACK bit or else ERR_MBX
196	**/
197	static s32 e1000_check_for_ack_vf(struct e1000_hw *hw)
198	{
199	s32 ret_val = -E1000_ERR_MBX;
200
201	if (!e1000_check_for_bit_vf(hw, E1000_V2PMAILBOX_PFACK)) {
202	ret_val = E1000_SUCCESS;
203	hw->mbx.stats.acks++;
204	}
205
206	return ret_val;
207	}
208
209	/**
210	* e1000_check_for_rst_vf - checks to see if the PF has reset
211	* @hw: pointer to the HW structure
212	*
213	* returns true if the PF has set the reset done bit or else false
214	**/
215	static s32 e1000_check_for_rst_vf(struct e1000_hw *hw)
216	{
217	s32 ret_val = -E1000_ERR_MBX;
218
219	if (!e1000_check_for_bit_vf(hw, (E1000_V2PMAILBOX_RSTD \|
0340501b	220	E1000_V2PMAILBOX_RSTI))) {
d4e0fe01 AD	221	ret_val = E1000_SUCCESS;
	222	hw->mbx.stats.rsts++;
	223	}
	224
	225	return ret_val;
	226	}
	227
	228	/**
	229	* e1000_obtain_mbx_lock_vf - obtain mailbox lock
	230	* @hw: pointer to the HW structure
	231	*
	232	* return SUCCESS if we obtained the mailbox lock
	233	**/
	234	static s32 e1000_obtain_mbx_lock_vf(struct e1000_hw *hw)
	235	{
	236	s32 ret_val = -E1000_ERR_MBX;
	237
	238	/* Take ownership of the buffer */
	239	ew32(V2PMAILBOX(0), E1000_V2PMAILBOX_VFU);
	240
0340501b	241	/* reserve mailbox for VF use */
d4e0fe01 AD	242	if (e1000_read_v2p_mailbox(hw) & E1000_V2PMAILBOX_VFU)
	243	ret_val = E1000_SUCCESS;
	244
	245	return ret_val;
	246	}
	247
	248	/**
	249	* e1000_write_mbx_vf - Write a message to the mailbox
	250	* @hw: pointer to the HW structure
	251	* @msg: The message buffer
	252	* @size: Length of buffer
	253	*
	254	* returns SUCCESS if it successfully copied message into the buffer
	255	**/
	256	static s32 e1000_write_mbx_vf(struct e1000_hw hw, u32 msg, u16 size)
	257	{
	258	s32 err;
	259	u16 i;
	260
	261	/* lock the mailbox to prevent pf/vf race condition */
	262	err = e1000_obtain_mbx_lock_vf(hw);
	263	if (err)
	264	goto out_no_write;
	265
	266	/* flush any ack or msg as we are going to overwrite mailbox */
	267	e1000_check_for_ack_vf(hw);
	268	e1000_check_for_msg_vf(hw);
	269
	270	/* copy the caller specified message to the mailbox memory buffer */
	271	for (i = 0; i < size; i++)
	272	array_ew32(VMBMEM(0), i, msg[i]);
	273
	274	/* update stats */
	275	hw->mbx.stats.msgs_tx++;
	276
	277	/* Drop VFU and interrupt the PF to tell it a message has been sent */
	278	ew32(V2PMAILBOX(0), E1000_V2PMAILBOX_REQ);
	279
	280	out_no_write:
	281	return err;
	282	}
	283
	284	/**
0340501b	285	* e1000_read_mbx_vf - Reads a message from the inbox intended for VF
d4e0fe01 AD	286	* @hw: pointer to the HW structure
	287	* @msg: The message buffer
	288	* @size: Length of buffer
	289	*
bfb9035c	290	* returns SUCCESS if it successfully read message from buffer
d4e0fe01 AD	291	**/
	292	static s32 e1000_read_mbx_vf(struct e1000_hw hw, u32 msg, u16 size)
	293	{
	294	s32 err;
	295	u16 i;
	296
	297	/* lock the mailbox to prevent pf/vf race condition */
	298	err = e1000_obtain_mbx_lock_vf(hw);
	299	if (err)
	300	goto out_no_read;
	301
	302	/* copy the message from the mailbox memory buffer */
	303	for (i = 0; i < size; i++)
	304	msg[i] = array_er32(VMBMEM(0), i);
	305
	306	/* Acknowledge receipt and release mailbox, then we're done */
	307	ew32(V2PMAILBOX(0), E1000_V2PMAILBOX_ACK);
	308
	309	/* update stats */
	310	hw->mbx.stats.msgs_rx++;
	311
	312	out_no_read:
	313	return err;
	314	}
	315
	316	/**
0340501b	317	* e1000_init_mbx_params_vf - set initial values for VF mailbox
d4e0fe01 AD	318	* @hw: pointer to the HW structure
d4e0fe01 AD	319	*
0340501b	320	* Initializes the hw->mbx struct to correct values for VF mailbox
d4e0fe01 AD	321	*/
	322	s32 e1000_init_mbx_params_vf(struct e1000_hw *hw)
	323	{
	324	struct e1000_mbx_info *mbx = &hw->mbx;
	325
	326	/* start mailbox as timed out and let the reset_hw call set the timeout
0340501b JK	327	* value to being communications
0340501b JK	328	*/
d4e0fe01 AD	329	mbx->timeout = 0;
	330	mbx->usec_delay = E1000_VF_MBX_INIT_DELAY;
	331
	332	mbx->size = E1000_VFMAILBOX_SIZE;
	333
	334	mbx->ops.read = e1000_read_mbx_vf;
	335	mbx->ops.write = e1000_write_mbx_vf;
	336	mbx->ops.read_posted = e1000_read_posted_mbx;
	337	mbx->ops.write_posted = e1000_write_posted_mbx;
	338	mbx->ops.check_for_msg = e1000_check_for_msg_vf;
	339	mbx->ops.check_for_ack = e1000_check_for_ack_vf;
	340	mbx->ops.check_for_rst = e1000_check_for_rst_vf;
	341
	342	mbx->stats.msgs_tx = 0;
	343	mbx->stats.msgs_rx = 0;
	344	mbx->stats.reqs = 0;
	345	mbx->stats.acks = 0;
	346	mbx->stats.rsts = 0;
	347
	348	return E1000_SUCCESS;
	349	}