1 /*******************************************************************************
3 Intel 10 Gigabit PCI Express Linux driver
4 Copyright(c) 1999 - 2011 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 *******************************************************************************/
28 #include <linux/pci.h>
29 #include <linux/delay.h>
30 #include "ixgbe_type.h"
31 #include "ixgbe_common.h"
32 #include "ixgbe_mbx.h"
35 * ixgbe_read_mbx - Reads a message from the mailbox
36 * @hw: pointer to the HW structure
37 * @msg: The message buffer
38 * @size: Length of buffer
39 * @mbx_id: id of mailbox to read
41 * returns SUCCESS if it successfuly read message from buffer
43 s32 ixgbe_read_mbx(struct ixgbe_hw *hw, u32 *msg, u16 size, u16 mbx_id)
45 struct ixgbe_mbx_info *mbx = &hw->mbx;
46 s32 ret_val = IXGBE_ERR_MBX;
48 /* limit read to size of mailbox */
53 ret_val = mbx->ops.read(hw, msg, size, mbx_id);
59 * ixgbe_write_mbx - Write a message to the mailbox
60 * @hw: pointer to the HW structure
61 * @msg: The message buffer
62 * @size: Length of buffer
63 * @mbx_id: id of mailbox to write
65 * returns SUCCESS if it successfully copied message into the buffer
67 s32 ixgbe_write_mbx(struct ixgbe_hw *hw, u32 *msg, u16 size, u16 mbx_id)
69 struct ixgbe_mbx_info *mbx = &hw->mbx;
73 ret_val = IXGBE_ERR_MBX;
75 else if (mbx->ops.write)
76 ret_val = mbx->ops.write(hw, msg, size, mbx_id);
82 * ixgbe_check_for_msg - checks to see if someone sent us mail
83 * @hw: pointer to the HW structure
84 * @mbx_id: id of mailbox to check
86 * returns SUCCESS if the Status bit was found or else ERR_MBX
88 s32 ixgbe_check_for_msg(struct ixgbe_hw *hw, u16 mbx_id)
90 struct ixgbe_mbx_info *mbx = &hw->mbx;
91 s32 ret_val = IXGBE_ERR_MBX;
93 if (mbx->ops.check_for_msg)
94 ret_val = mbx->ops.check_for_msg(hw, mbx_id);
100 * ixgbe_check_for_ack - checks to see if someone sent us ACK
101 * @hw: pointer to the HW structure
102 * @mbx_id: id of mailbox to check
104 * returns SUCCESS if the Status bit was found or else ERR_MBX
106 s32 ixgbe_check_for_ack(struct ixgbe_hw *hw, u16 mbx_id)
108 struct ixgbe_mbx_info *mbx = &hw->mbx;
109 s32 ret_val = IXGBE_ERR_MBX;
111 if (mbx->ops.check_for_ack)
112 ret_val = mbx->ops.check_for_ack(hw, mbx_id);
118 * ixgbe_check_for_rst - checks to see if other side has reset
119 * @hw: pointer to the HW structure
120 * @mbx_id: id of mailbox to check
122 * returns SUCCESS if the Status bit was found or else ERR_MBX
124 s32 ixgbe_check_for_rst(struct ixgbe_hw *hw, u16 mbx_id)
126 struct ixgbe_mbx_info *mbx = &hw->mbx;
127 s32 ret_val = IXGBE_ERR_MBX;
129 if (mbx->ops.check_for_rst)
130 ret_val = mbx->ops.check_for_rst(hw, mbx_id);
136 * ixgbe_poll_for_msg - Wait for message notification
137 * @hw: pointer to the HW structure
138 * @mbx_id: id of mailbox to write
140 * returns SUCCESS if it successfully received a message notification
142 static s32 ixgbe_poll_for_msg(struct ixgbe_hw *hw, u16 mbx_id)
144 struct ixgbe_mbx_info *mbx = &hw->mbx;
145 int countdown = mbx->timeout;
147 if (!countdown || !mbx->ops.check_for_msg)
150 while (countdown && mbx->ops.check_for_msg(hw, mbx_id)) {
154 udelay(mbx->usec_delay);
157 /* if we failed, all future posted messages fail until reset */
161 return countdown ? 0 : IXGBE_ERR_MBX;
165 * ixgbe_poll_for_ack - Wait for message acknowledgement
166 * @hw: pointer to the HW structure
167 * @mbx_id: id of mailbox to write
169 * returns SUCCESS if it successfully received a message acknowledgement
171 static s32 ixgbe_poll_for_ack(struct ixgbe_hw *hw, u16 mbx_id)
173 struct ixgbe_mbx_info *mbx = &hw->mbx;
174 int countdown = mbx->timeout;
176 if (!countdown || !mbx->ops.check_for_ack)
179 while (countdown && mbx->ops.check_for_ack(hw, mbx_id)) {
183 udelay(mbx->usec_delay);
186 /* if we failed, all future posted messages fail until reset */
190 return countdown ? 0 : IXGBE_ERR_MBX;
194 * ixgbe_read_posted_mbx - Wait for message notification and receive message
195 * @hw: pointer to the HW structure
196 * @msg: The message buffer
197 * @size: Length of buffer
198 * @mbx_id: id of mailbox to write
200 * returns SUCCESS if it successfully received a message notification and
201 * copied it into the receive buffer.
203 static s32 ixgbe_read_posted_mbx(struct ixgbe_hw *hw, u32 *msg, u16 size,
206 struct ixgbe_mbx_info *mbx = &hw->mbx;
207 s32 ret_val = IXGBE_ERR_MBX;
212 ret_val = ixgbe_poll_for_msg(hw, mbx_id);
214 /* if ack received read message, otherwise we timed out */
216 ret_val = mbx->ops.read(hw, msg, size, mbx_id);
222 * ixgbe_write_posted_mbx - Write a message to the mailbox, wait for ack
223 * @hw: pointer to the HW structure
224 * @msg: The message buffer
225 * @size: Length of buffer
226 * @mbx_id: id of mailbox to write
228 * returns SUCCESS if it successfully copied message into the buffer and
229 * received an ack to that message within delay * timeout period
231 static s32 ixgbe_write_posted_mbx(struct ixgbe_hw *hw, u32 *msg, u16 size,
234 struct ixgbe_mbx_info *mbx = &hw->mbx;
235 s32 ret_val = IXGBE_ERR_MBX;
237 /* exit if either we can't write or there isn't a defined timeout */
238 if (!mbx->ops.write || !mbx->timeout)
242 ret_val = mbx->ops.write(hw, msg, size, mbx_id);
244 /* if msg sent wait until we receive an ack */
246 ret_val = ixgbe_poll_for_ack(hw, mbx_id);
251 static s32 ixgbe_check_for_bit_pf(struct ixgbe_hw *hw, u32 mask, s32 index)
253 u32 mbvficr = IXGBE_READ_REG(hw, IXGBE_MBVFICR(index));
254 s32 ret_val = IXGBE_ERR_MBX;
256 if (mbvficr & mask) {
258 IXGBE_WRITE_REG(hw, IXGBE_MBVFICR(index), mask);
265 * ixgbe_check_for_msg_pf - checks to see if the VF has sent mail
266 * @hw: pointer to the HW structure
267 * @vf_number: the VF index
269 * returns SUCCESS if the VF has set the Status bit or else ERR_MBX
271 static s32 ixgbe_check_for_msg_pf(struct ixgbe_hw *hw, u16 vf_number)
273 s32 ret_val = IXGBE_ERR_MBX;
274 s32 index = IXGBE_MBVFICR_INDEX(vf_number);
275 u32 vf_bit = vf_number % 16;
277 if (!ixgbe_check_for_bit_pf(hw, IXGBE_MBVFICR_VFREQ_VF1 << vf_bit,
280 hw->mbx.stats.reqs++;
287 * ixgbe_check_for_ack_pf - checks to see if the VF has ACKed
288 * @hw: pointer to the HW structure
289 * @vf_number: the VF index
291 * returns SUCCESS if the VF has set the Status bit or else ERR_MBX
293 static s32 ixgbe_check_for_ack_pf(struct ixgbe_hw *hw, u16 vf_number)
295 s32 ret_val = IXGBE_ERR_MBX;
296 s32 index = IXGBE_MBVFICR_INDEX(vf_number);
297 u32 vf_bit = vf_number % 16;
299 if (!ixgbe_check_for_bit_pf(hw, IXGBE_MBVFICR_VFACK_VF1 << vf_bit,
302 hw->mbx.stats.acks++;
309 * ixgbe_check_for_rst_pf - checks to see if the VF has reset
310 * @hw: pointer to the HW structure
311 * @vf_number: the VF index
313 * returns SUCCESS if the VF has set the Status bit or else ERR_MBX
315 static s32 ixgbe_check_for_rst_pf(struct ixgbe_hw *hw, u16 vf_number)
317 u32 reg_offset = (vf_number < 32) ? 0 : 1;
318 u32 vf_shift = vf_number % 32;
320 s32 ret_val = IXGBE_ERR_MBX;
322 switch (hw->mac.type) {
323 case ixgbe_mac_82599EB:
324 vflre = IXGBE_READ_REG(hw, IXGBE_VFLRE(reg_offset));
327 vflre = IXGBE_READ_REG(hw, IXGBE_VFLREC(reg_offset));
333 if (vflre & (1 << vf_shift)) {
335 IXGBE_WRITE_REG(hw, IXGBE_VFLREC(reg_offset), (1 << vf_shift));
336 hw->mbx.stats.rsts++;
343 * ixgbe_obtain_mbx_lock_pf - obtain mailbox lock
344 * @hw: pointer to the HW structure
345 * @vf_number: the VF index
347 * return SUCCESS if we obtained the mailbox lock
349 static s32 ixgbe_obtain_mbx_lock_pf(struct ixgbe_hw *hw, u16 vf_number)
351 s32 ret_val = IXGBE_ERR_MBX;
354 /* Take ownership of the buffer */
355 IXGBE_WRITE_REG(hw, IXGBE_PFMAILBOX(vf_number), IXGBE_PFMAILBOX_PFU);
357 /* reserve mailbox for vf use */
358 p2v_mailbox = IXGBE_READ_REG(hw, IXGBE_PFMAILBOX(vf_number));
359 if (p2v_mailbox & IXGBE_PFMAILBOX_PFU)
366 * ixgbe_write_mbx_pf - Places a message in the mailbox
367 * @hw: pointer to the HW structure
368 * @msg: The message buffer
369 * @size: Length of buffer
370 * @vf_number: the VF index
372 * returns SUCCESS if it successfully copied message into the buffer
374 static s32 ixgbe_write_mbx_pf(struct ixgbe_hw *hw, u32 *msg, u16 size,
380 /* lock the mailbox to prevent pf/vf race condition */
381 ret_val = ixgbe_obtain_mbx_lock_pf(hw, vf_number);
385 /* flush msg and acks as we are overwriting the message buffer */
386 ixgbe_check_for_msg_pf(hw, vf_number);
387 ixgbe_check_for_ack_pf(hw, vf_number);
389 /* copy the caller specified message to the mailbox memory buffer */
390 for (i = 0; i < size; i++)
391 IXGBE_WRITE_REG_ARRAY(hw, IXGBE_PFMBMEM(vf_number), i, msg[i]);
393 /* Interrupt VF to tell it a message has been sent and release buffer*/
394 IXGBE_WRITE_REG(hw, IXGBE_PFMAILBOX(vf_number), IXGBE_PFMAILBOX_STS);
397 hw->mbx.stats.msgs_tx++;
405 * ixgbe_read_mbx_pf - Read a message from the mailbox
406 * @hw: pointer to the HW structure
407 * @msg: The message buffer
408 * @size: Length of buffer
409 * @vf_number: the VF index
411 * This function copies a message from the mailbox buffer to the caller's
412 * memory buffer. The presumption is that the caller knows that there was
413 * a message due to a VF request so no polling for message is needed.
415 static s32 ixgbe_read_mbx_pf(struct ixgbe_hw *hw, u32 *msg, u16 size,
421 /* lock the mailbox to prevent pf/vf race condition */
422 ret_val = ixgbe_obtain_mbx_lock_pf(hw, vf_number);
426 /* copy the message to the mailbox memory buffer */
427 for (i = 0; i < size; i++)
428 msg[i] = IXGBE_READ_REG_ARRAY(hw, IXGBE_PFMBMEM(vf_number), i);
430 /* Acknowledge the message and release buffer */
431 IXGBE_WRITE_REG(hw, IXGBE_PFMAILBOX(vf_number), IXGBE_PFMAILBOX_ACK);
434 hw->mbx.stats.msgs_rx++;
440 #ifdef CONFIG_PCI_IOV
442 * ixgbe_init_mbx_params_pf - set initial values for pf mailbox
443 * @hw: pointer to the HW structure
445 * Initializes the hw->mbx struct to correct values for pf mailbox
447 void ixgbe_init_mbx_params_pf(struct ixgbe_hw *hw)
449 struct ixgbe_mbx_info *mbx = &hw->mbx;
451 if (hw->mac.type != ixgbe_mac_82599EB &&
452 hw->mac.type != ixgbe_mac_X540)
458 mbx->stats.msgs_tx = 0;
459 mbx->stats.msgs_rx = 0;
464 mbx->size = IXGBE_VFMAILBOX_SIZE;
466 #endif /* CONFIG_PCI_IOV */
468 struct ixgbe_mbx_operations mbx_ops_generic = {
469 .read = ixgbe_read_mbx_pf,
470 .write = ixgbe_write_mbx_pf,
471 .read_posted = ixgbe_read_posted_mbx,
472 .write_posted = ixgbe_write_posted_mbx,
473 .check_for_msg = ixgbe_check_for_msg_pf,
474 .check_for_ack = ixgbe_check_for_ack_pf,
475 .check_for_rst = ixgbe_check_for_rst_pf,