1 /*******************************************************************************
3 Intel 10 Gigabit PCI Express Linux 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 *******************************************************************************/
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 if (hw
->mac
.type
== ixgbe_mac_82599EB
)
323 vflre
= IXGBE_READ_REG(hw
, IXGBE_VFLRE(reg_offset
));
325 if (vflre
& (1 << vf_shift
)) {
327 IXGBE_WRITE_REG(hw
, IXGBE_VFLREC(reg_offset
), (1 << vf_shift
));
328 hw
->mbx
.stats
.rsts
++;
335 * ixgbe_obtain_mbx_lock_pf - obtain mailbox lock
336 * @hw: pointer to the HW structure
337 * @vf_number: the VF index
339 * return SUCCESS if we obtained the mailbox lock
341 static s32
ixgbe_obtain_mbx_lock_pf(struct ixgbe_hw
*hw
, u16 vf_number
)
343 s32 ret_val
= IXGBE_ERR_MBX
;
346 /* Take ownership of the buffer */
347 IXGBE_WRITE_REG(hw
, IXGBE_PFMAILBOX(vf_number
), IXGBE_PFMAILBOX_PFU
);
349 /* reserve mailbox for vf use */
350 p2v_mailbox
= IXGBE_READ_REG(hw
, IXGBE_PFMAILBOX(vf_number
));
351 if (p2v_mailbox
& IXGBE_PFMAILBOX_PFU
)
358 * ixgbe_write_mbx_pf - Places a message in the mailbox
359 * @hw: pointer to the HW structure
360 * @msg: The message buffer
361 * @size: Length of buffer
362 * @vf_number: the VF index
364 * returns SUCCESS if it successfully copied message into the buffer
366 static s32
ixgbe_write_mbx_pf(struct ixgbe_hw
*hw
, u32
*msg
, u16 size
,
372 /* lock the mailbox to prevent pf/vf race condition */
373 ret_val
= ixgbe_obtain_mbx_lock_pf(hw
, vf_number
);
377 /* flush msg and acks as we are overwriting the message buffer */
378 ixgbe_check_for_msg_pf(hw
, vf_number
);
379 ixgbe_check_for_ack_pf(hw
, vf_number
);
381 /* copy the caller specified message to the mailbox memory buffer */
382 for (i
= 0; i
< size
; i
++)
383 IXGBE_WRITE_REG_ARRAY(hw
, IXGBE_PFMBMEM(vf_number
), i
, msg
[i
]);
385 /* Interrupt VF to tell it a message has been sent and release buffer*/
386 IXGBE_WRITE_REG(hw
, IXGBE_PFMAILBOX(vf_number
), IXGBE_PFMAILBOX_STS
);
389 hw
->mbx
.stats
.msgs_tx
++;
397 * ixgbe_read_mbx_pf - Read a message from the mailbox
398 * @hw: pointer to the HW structure
399 * @msg: The message buffer
400 * @size: Length of buffer
401 * @vf_number: the VF index
403 * This function copies a message from the mailbox buffer to the caller's
404 * memory buffer. The presumption is that the caller knows that there was
405 * a message due to a VF request so no polling for message is needed.
407 static s32
ixgbe_read_mbx_pf(struct ixgbe_hw
*hw
, u32
*msg
, u16 size
,
413 /* lock the mailbox to prevent pf/vf race condition */
414 ret_val
= ixgbe_obtain_mbx_lock_pf(hw
, vf_number
);
418 /* copy the message to the mailbox memory buffer */
419 for (i
= 0; i
< size
; i
++)
420 msg
[i
] = IXGBE_READ_REG_ARRAY(hw
, IXGBE_PFMBMEM(vf_number
), i
);
422 /* Acknowledge the message and release buffer */
423 IXGBE_WRITE_REG(hw
, IXGBE_PFMAILBOX(vf_number
), IXGBE_PFMAILBOX_ACK
);
426 hw
->mbx
.stats
.msgs_rx
++;
433 * ixgbe_init_mbx_params_pf - set initial values for pf mailbox
434 * @hw: pointer to the HW structure
436 * Initializes the hw->mbx struct to correct values for pf mailbox
438 void ixgbe_init_mbx_params_pf(struct ixgbe_hw
*hw
)
440 struct ixgbe_mbx_info
*mbx
= &hw
->mbx
;
442 if (hw
->mac
.type
!= ixgbe_mac_82599EB
)
448 mbx
->size
= IXGBE_VFMAILBOX_SIZE
;
450 mbx
->stats
.msgs_tx
= 0;
451 mbx
->stats
.msgs_rx
= 0;
457 struct ixgbe_mbx_operations mbx_ops_82599
= {
458 .read
= ixgbe_read_mbx_pf
,
459 .write
= ixgbe_write_mbx_pf
,
460 .read_posted
= ixgbe_read_posted_mbx
,
461 .write_posted
= ixgbe_write_posted_mbx
,
462 .check_for_msg
= ixgbe_check_for_msg_pf
,
463 .check_for_ack
= ixgbe_check_for_ack_pf
,
464 .check_for_rst
= ixgbe_check_for_rst_pf
,