1 /*******************************************************************************
3 Intel 82599 Virtual Function driver
4 Copyright(c) 1999 - 2010 Intel Corporation.
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.
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
15 You should have received a copy of the GNU General Public License along with
16 this program; if not, write to the Free Software Foundation, Inc.,
17 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
19 The full GNU General Public License is included in this distribution in
20 the file called "COPYING".
23 e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
24 Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
26 *******************************************************************************/
31 * ixgbevf_poll_for_msg - Wait for message notification
32 * @hw: pointer to the HW structure
34 * returns 0 if it successfully received a message notification
36 static s32 ixgbevf_poll_for_msg(struct ixgbe_hw *hw)
38 struct ixgbe_mbx_info *mbx = &hw->mbx;
39 int countdown = mbx->timeout;
41 while (countdown && mbx->ops.check_for_msg(hw)) {
46 /* if we failed, all future posted messages fail until reset */
50 return countdown ? 0 : IXGBE_ERR_MBX;
54 * ixgbevf_poll_for_ack - Wait for message acknowledgement
55 * @hw: pointer to the HW structure
57 * returns 0 if it successfully received a message acknowledgement
59 static s32 ixgbevf_poll_for_ack(struct ixgbe_hw *hw)
61 struct ixgbe_mbx_info *mbx = &hw->mbx;
62 int countdown = mbx->timeout;
64 while (countdown && mbx->ops.check_for_ack(hw)) {
69 /* if we failed, all future posted messages fail until reset */
73 return countdown ? 0 : IXGBE_ERR_MBX;
77 * ixgbevf_read_posted_mbx - Wait for message notification and receive message
78 * @hw: pointer to the HW structure
79 * @msg: The message buffer
80 * @size: Length of buffer
82 * returns 0 if it successfully received a message notification and
83 * copied it into the receive buffer.
85 static s32 ixgbevf_read_posted_mbx(struct ixgbe_hw *hw, u32 *msg, u16 size)
87 struct ixgbe_mbx_info *mbx = &hw->mbx;
88 s32 ret_val = IXGBE_ERR_MBX;
90 ret_val = ixgbevf_poll_for_msg(hw);
92 /* if ack received read message, otherwise we timed out */
94 ret_val = mbx->ops.read(hw, msg, size);
100 * ixgbevf_write_posted_mbx - Write a message to the mailbox, wait for ack
101 * @hw: pointer to the HW structure
102 * @msg: The message buffer
103 * @size: Length of buffer
105 * returns 0 if it successfully copied message into the buffer and
106 * received an ack to that message within delay * timeout period
108 static s32 ixgbevf_write_posted_mbx(struct ixgbe_hw *hw, u32 *msg, u16 size)
110 struct ixgbe_mbx_info *mbx = &hw->mbx;
114 ret_val = mbx->ops.write(hw, msg, size);
116 /* if msg sent wait until we receive an ack */
118 ret_val = ixgbevf_poll_for_ack(hw);
124 * ixgbevf_read_v2p_mailbox - read v2p mailbox
125 * @hw: pointer to the HW structure
127 * This function is used to read the v2p mailbox without losing the read to
130 static u32 ixgbevf_read_v2p_mailbox(struct ixgbe_hw *hw)
132 u32 v2p_mailbox = IXGBE_READ_REG(hw, IXGBE_VFMAILBOX);
134 v2p_mailbox |= hw->mbx.v2p_mailbox;
135 hw->mbx.v2p_mailbox |= v2p_mailbox & IXGBE_VFMAILBOX_R2C_BITS;
141 * ixgbevf_check_for_bit_vf - Determine if a status bit was set
142 * @hw: pointer to the HW structure
143 * @mask: bitmask for bits to be tested and cleared
145 * This function is used to check for the read to clear bits within
148 static s32 ixgbevf_check_for_bit_vf(struct ixgbe_hw *hw, u32 mask)
150 u32 v2p_mailbox = ixgbevf_read_v2p_mailbox(hw);
151 s32 ret_val = IXGBE_ERR_MBX;
153 if (v2p_mailbox & mask)
156 hw->mbx.v2p_mailbox &= ~mask;
162 * ixgbevf_check_for_msg_vf - checks to see if the PF has sent mail
163 * @hw: pointer to the HW structure
165 * returns 0 if the PF has set the Status bit or else ERR_MBX
167 static s32 ixgbevf_check_for_msg_vf(struct ixgbe_hw *hw)
169 s32 ret_val = IXGBE_ERR_MBX;
171 if (!ixgbevf_check_for_bit_vf(hw, IXGBE_VFMAILBOX_PFSTS)) {
173 hw->mbx.stats.reqs++;
180 * ixgbevf_check_for_ack_vf - checks to see if the PF has ACK'd
181 * @hw: pointer to the HW structure
183 * returns 0 if the PF has set the ACK bit or else ERR_MBX
185 static s32 ixgbevf_check_for_ack_vf(struct ixgbe_hw *hw)
187 s32 ret_val = IXGBE_ERR_MBX;
189 if (!ixgbevf_check_for_bit_vf(hw, IXGBE_VFMAILBOX_PFACK)) {
191 hw->mbx.stats.acks++;
198 * ixgbevf_check_for_rst_vf - checks to see if the PF has reset
199 * @hw: pointer to the HW structure
201 * returns true if the PF has set the reset done bit or else false
203 static s32 ixgbevf_check_for_rst_vf(struct ixgbe_hw *hw)
205 s32 ret_val = IXGBE_ERR_MBX;
207 if (!ixgbevf_check_for_bit_vf(hw, (IXGBE_VFMAILBOX_RSTD |
208 IXGBE_VFMAILBOX_RSTI))) {
210 hw->mbx.stats.rsts++;
217 * ixgbevf_obtain_mbx_lock_vf - obtain mailbox lock
218 * @hw: pointer to the HW structure
220 * return 0 if we obtained the mailbox lock
222 static s32 ixgbevf_obtain_mbx_lock_vf(struct ixgbe_hw *hw)
224 s32 ret_val = IXGBE_ERR_MBX;
226 /* Take ownership of the buffer */
227 IXGBE_WRITE_REG(hw, IXGBE_VFMAILBOX, IXGBE_VFMAILBOX_VFU);
229 /* reserve mailbox for vf use */
230 if (ixgbevf_read_v2p_mailbox(hw) & IXGBE_VFMAILBOX_VFU)
237 * ixgbevf_write_mbx_vf - Write a message to the mailbox
238 * @hw: pointer to the HW structure
239 * @msg: The message buffer
240 * @size: Length of buffer
242 * returns 0 if it successfully copied message into the buffer
244 static s32 ixgbevf_write_mbx_vf(struct ixgbe_hw *hw, u32 *msg, u16 size)
250 /* lock the mailbox to prevent pf/vf race condition */
251 ret_val = ixgbevf_obtain_mbx_lock_vf(hw);
255 /* flush msg and acks as we are overwriting the message buffer */
256 ixgbevf_check_for_msg_vf(hw);
257 ixgbevf_check_for_ack_vf(hw);
259 /* copy the caller specified message to the mailbox memory buffer */
260 for (i = 0; i < size; i++)
261 IXGBE_WRITE_REG_ARRAY(hw, IXGBE_VFMBMEM, i, msg[i]);
264 hw->mbx.stats.msgs_tx++;
266 /* Drop VFU and interrupt the PF to tell it a message has been sent */
267 IXGBE_WRITE_REG(hw, IXGBE_VFMAILBOX, IXGBE_VFMAILBOX_REQ);
274 * ixgbevf_read_mbx_vf - Reads a message from the inbox intended for vf
275 * @hw: pointer to the HW structure
276 * @msg: The message buffer
277 * @size: Length of buffer
279 * returns 0 if it successfully read message from buffer
281 static s32 ixgbevf_read_mbx_vf(struct ixgbe_hw *hw, u32 *msg, u16 size)
286 /* lock the mailbox to prevent pf/vf race condition */
287 ret_val = ixgbevf_obtain_mbx_lock_vf(hw);
291 /* copy the message from the mailbox memory buffer */
292 for (i = 0; i < size; i++)
293 msg[i] = IXGBE_READ_REG_ARRAY(hw, IXGBE_VFMBMEM, i);
295 /* Acknowledge receipt and release mailbox, then we're done */
296 IXGBE_WRITE_REG(hw, IXGBE_VFMAILBOX, IXGBE_VFMAILBOX_ACK);
299 hw->mbx.stats.msgs_rx++;
306 * ixgbevf_init_mbx_params_vf - set initial values for vf mailbox
307 * @hw: pointer to the HW structure
309 * Initializes the hw->mbx struct to correct values for vf mailbox
311 static s32 ixgbevf_init_mbx_params_vf(struct ixgbe_hw *hw)
313 struct ixgbe_mbx_info *mbx = &hw->mbx;
315 /* start mailbox as timed out and let the reset_hw call set the timeout
316 * value to begin communications */
318 mbx->udelay = IXGBE_VF_MBX_INIT_DELAY;
320 mbx->size = IXGBE_VFMAILBOX_SIZE;
322 mbx->stats.msgs_tx = 0;
323 mbx->stats.msgs_rx = 0;
331 struct ixgbe_mbx_operations ixgbevf_mbx_ops = {
332 .init_params = ixgbevf_init_mbx_params_vf,
333 .read = ixgbevf_read_mbx_vf,
334 .write = ixgbevf_write_mbx_vf,
335 .read_posted = ixgbevf_read_posted_mbx,
336 .write_posted = ixgbevf_write_posted_mbx,
337 .check_for_msg = ixgbevf_check_for_msg_vf,
338 .check_for_ack = ixgbevf_check_for_ack_vf,
339 .check_for_rst = ixgbevf_check_for_rst_vf,