1 /*******************************************************************************
3 Intel(R) Gigabit Ethernet Linux driver
4 Copyright(c) 2007-2009 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 "e1000_mbx.h"
31 * igb_read_mbx - Reads a message from the mailbox
32 * @hw: pointer to the HW structure
33 * @msg: The message buffer
34 * @size: Length of buffer
35 * @mbx_id: id of mailbox to read
37 * returns SUCCESS if it successfuly read message from buffer
39 s32
igb_read_mbx(struct e1000_hw
*hw
, u32
*msg
, u16 size
, u16 mbx_id
)
41 struct e1000_mbx_info
*mbx
= &hw
->mbx
;
42 s32 ret_val
= -E1000_ERR_MBX
;
44 /* limit read to size of mailbox */
49 ret_val
= mbx
->ops
.read(hw
, msg
, size
, mbx_id
);
55 * igb_write_mbx - Write a message to the mailbox
56 * @hw: pointer to the HW structure
57 * @msg: The message buffer
58 * @size: Length of buffer
59 * @mbx_id: id of mailbox to write
61 * returns SUCCESS if it successfully copied message into the buffer
63 s32
igb_write_mbx(struct e1000_hw
*hw
, u32
*msg
, u16 size
, u16 mbx_id
)
65 struct e1000_mbx_info
*mbx
= &hw
->mbx
;
69 ret_val
= -E1000_ERR_MBX
;
71 else if (mbx
->ops
.write
)
72 ret_val
= mbx
->ops
.write(hw
, msg
, size
, mbx_id
);
78 * igb_check_for_msg - checks to see if someone sent us mail
79 * @hw: pointer to the HW structure
80 * @mbx_id: id of mailbox to check
82 * returns SUCCESS if the Status bit was found or else ERR_MBX
84 s32
igb_check_for_msg(struct e1000_hw
*hw
, u16 mbx_id
)
86 struct e1000_mbx_info
*mbx
= &hw
->mbx
;
87 s32 ret_val
= -E1000_ERR_MBX
;
89 if (mbx
->ops
.check_for_msg
)
90 ret_val
= mbx
->ops
.check_for_msg(hw
, mbx_id
);
96 * igb_check_for_ack - checks to see if someone sent us ACK
97 * @hw: pointer to the HW structure
98 * @mbx_id: id of mailbox to check
100 * returns SUCCESS if the Status bit was found or else ERR_MBX
102 s32
igb_check_for_ack(struct e1000_hw
*hw
, u16 mbx_id
)
104 struct e1000_mbx_info
*mbx
= &hw
->mbx
;
105 s32 ret_val
= -E1000_ERR_MBX
;
107 if (mbx
->ops
.check_for_ack
)
108 ret_val
= mbx
->ops
.check_for_ack(hw
, mbx_id
);
114 * igb_check_for_rst - checks to see if other side has reset
115 * @hw: pointer to the HW structure
116 * @mbx_id: id of mailbox to check
118 * returns SUCCESS if the Status bit was found or else ERR_MBX
120 s32
igb_check_for_rst(struct e1000_hw
*hw
, u16 mbx_id
)
122 struct e1000_mbx_info
*mbx
= &hw
->mbx
;
123 s32 ret_val
= -E1000_ERR_MBX
;
125 if (mbx
->ops
.check_for_rst
)
126 ret_val
= mbx
->ops
.check_for_rst(hw
, mbx_id
);
132 * igb_poll_for_msg - Wait for message notification
133 * @hw: pointer to the HW structure
134 * @mbx_id: id of mailbox to write
136 * returns SUCCESS if it successfully received a message notification
138 static s32
igb_poll_for_msg(struct e1000_hw
*hw
, u16 mbx_id
)
140 struct e1000_mbx_info
*mbx
= &hw
->mbx
;
141 int countdown
= mbx
->timeout
;
143 if (!countdown
|| !mbx
->ops
.check_for_msg
)
146 while (countdown
&& mbx
->ops
.check_for_msg(hw
, mbx_id
)) {
150 udelay(mbx
->usec_delay
);
153 /* if we failed, all future posted messages fail until reset */
157 return countdown
? 0 : -E1000_ERR_MBX
;
161 * igb_poll_for_ack - Wait for message acknowledgement
162 * @hw: pointer to the HW structure
163 * @mbx_id: id of mailbox to write
165 * returns SUCCESS if it successfully received a message acknowledgement
167 static s32
igb_poll_for_ack(struct e1000_hw
*hw
, u16 mbx_id
)
169 struct e1000_mbx_info
*mbx
= &hw
->mbx
;
170 int countdown
= mbx
->timeout
;
172 if (!countdown
|| !mbx
->ops
.check_for_ack
)
175 while (countdown
&& mbx
->ops
.check_for_ack(hw
, mbx_id
)) {
179 udelay(mbx
->usec_delay
);
182 /* if we failed, all future posted messages fail until reset */
186 return countdown
? 0 : -E1000_ERR_MBX
;
190 * igb_read_posted_mbx - Wait for message notification and receive message
191 * @hw: pointer to the HW structure
192 * @msg: The message buffer
193 * @size: Length of buffer
194 * @mbx_id: id of mailbox to write
196 * returns SUCCESS if it successfully received a message notification and
197 * copied it into the receive buffer.
199 static s32
igb_read_posted_mbx(struct e1000_hw
*hw
, u32
*msg
, u16 size
, u16 mbx_id
)
201 struct e1000_mbx_info
*mbx
= &hw
->mbx
;
202 s32 ret_val
= -E1000_ERR_MBX
;
207 ret_val
= igb_poll_for_msg(hw
, mbx_id
);
210 ret_val
= mbx
->ops
.read(hw
, msg
, size
, mbx_id
);
216 * igb_write_posted_mbx - Write a message to the mailbox, wait for ack
217 * @hw: pointer to the HW structure
218 * @msg: The message buffer
219 * @size: Length of buffer
220 * @mbx_id: id of mailbox to write
222 * returns SUCCESS if it successfully copied message into the buffer and
223 * received an ack to that message within delay * timeout period
225 static s32
igb_write_posted_mbx(struct e1000_hw
*hw
, u32
*msg
, u16 size
, u16 mbx_id
)
227 struct e1000_mbx_info
*mbx
= &hw
->mbx
;
228 s32 ret_val
= -E1000_ERR_MBX
;
230 /* exit if either we can't write or there isn't a defined timeout */
231 if (!mbx
->ops
.write
|| !mbx
->timeout
)
235 ret_val
= mbx
->ops
.write(hw
, msg
, size
, mbx_id
);
237 /* if msg sent wait until we receive an ack */
239 ret_val
= igb_poll_for_ack(hw
, mbx_id
);
244 static s32
igb_check_for_bit_pf(struct e1000_hw
*hw
, u32 mask
)
246 u32 mbvficr
= rd32(E1000_MBVFICR
);
247 s32 ret_val
= -E1000_ERR_MBX
;
249 if (mbvficr
& mask
) {
251 wr32(E1000_MBVFICR
, mask
);
258 * igb_check_for_msg_pf - checks to see if the VF has sent mail
259 * @hw: pointer to the HW structure
260 * @vf_number: the VF index
262 * returns SUCCESS if the VF has set the Status bit or else ERR_MBX
264 static s32
igb_check_for_msg_pf(struct e1000_hw
*hw
, u16 vf_number
)
266 s32 ret_val
= -E1000_ERR_MBX
;
268 if (!igb_check_for_bit_pf(hw
, E1000_MBVFICR_VFREQ_VF1
<< vf_number
)) {
270 hw
->mbx
.stats
.reqs
++;
277 * igb_check_for_ack_pf - checks to see if the VF has ACKed
278 * @hw: pointer to the HW structure
279 * @vf_number: the VF index
281 * returns SUCCESS if the VF has set the Status bit or else ERR_MBX
283 static s32
igb_check_for_ack_pf(struct e1000_hw
*hw
, u16 vf_number
)
285 s32 ret_val
= -E1000_ERR_MBX
;
287 if (!igb_check_for_bit_pf(hw
, E1000_MBVFICR_VFACK_VF1
<< vf_number
)) {
289 hw
->mbx
.stats
.acks
++;
296 * igb_check_for_rst_pf - checks to see if the VF has reset
297 * @hw: pointer to the HW structure
298 * @vf_number: the VF index
300 * returns SUCCESS if the VF has set the Status bit or else ERR_MBX
302 static s32
igb_check_for_rst_pf(struct e1000_hw
*hw
, u16 vf_number
)
304 u32 vflre
= rd32(E1000_VFLRE
);
305 s32 ret_val
= -E1000_ERR_MBX
;
307 if (vflre
& (1 << vf_number
)) {
309 wr32(E1000_VFLRE
, (1 << vf_number
));
310 hw
->mbx
.stats
.rsts
++;
317 * igb_obtain_mbx_lock_pf - obtain mailbox lock
318 * @hw: pointer to the HW structure
319 * @vf_number: the VF index
321 * return SUCCESS if we obtained the mailbox lock
323 static s32
igb_obtain_mbx_lock_pf(struct e1000_hw
*hw
, u16 vf_number
)
325 s32 ret_val
= -E1000_ERR_MBX
;
329 /* Take ownership of the buffer */
330 wr32(E1000_P2VMAILBOX(vf_number
), E1000_P2VMAILBOX_PFU
);
332 /* reserve mailbox for vf use */
333 p2v_mailbox
= rd32(E1000_P2VMAILBOX(vf_number
));
334 if (p2v_mailbox
& E1000_P2VMAILBOX_PFU
)
341 * igb_write_mbx_pf - Places a message in the mailbox
342 * @hw: pointer to the HW structure
343 * @msg: The message buffer
344 * @size: Length of buffer
345 * @vf_number: the VF index
347 * returns SUCCESS if it successfully copied message into the buffer
349 static s32
igb_write_mbx_pf(struct e1000_hw
*hw
, u32
*msg
, u16 size
,
355 /* lock the mailbox to prevent pf/vf race condition */
356 ret_val
= igb_obtain_mbx_lock_pf(hw
, vf_number
);
360 /* flush msg and acks as we are overwriting the message buffer */
361 igb_check_for_msg_pf(hw
, vf_number
);
362 igb_check_for_ack_pf(hw
, vf_number
);
364 /* copy the caller specified message to the mailbox memory buffer */
365 for (i
= 0; i
< size
; i
++)
366 array_wr32(E1000_VMBMEM(vf_number
), i
, msg
[i
]);
368 /* Interrupt VF to tell it a message has been sent and release buffer*/
369 wr32(E1000_P2VMAILBOX(vf_number
), E1000_P2VMAILBOX_STS
);
372 hw
->mbx
.stats
.msgs_tx
++;
380 * igb_read_mbx_pf - Read a message from the mailbox
381 * @hw: pointer to the HW structure
382 * @msg: The message buffer
383 * @size: Length of buffer
384 * @vf_number: the VF index
386 * This function copies a message from the mailbox buffer to the caller's
387 * memory buffer. The presumption is that the caller knows that there was
388 * a message due to a VF request so no polling for message is needed.
390 static s32
igb_read_mbx_pf(struct e1000_hw
*hw
, u32
*msg
, u16 size
,
396 /* lock the mailbox to prevent pf/vf race condition */
397 ret_val
= igb_obtain_mbx_lock_pf(hw
, vf_number
);
401 /* copy the message to the mailbox memory buffer */
402 for (i
= 0; i
< size
; i
++)
403 msg
[i
] = array_rd32(E1000_VMBMEM(vf_number
), i
);
405 /* Acknowledge the message and release buffer */
406 wr32(E1000_P2VMAILBOX(vf_number
), E1000_P2VMAILBOX_ACK
);
409 hw
->mbx
.stats
.msgs_rx
++;
416 * e1000_init_mbx_params_pf - set initial values for pf mailbox
417 * @hw: pointer to the HW structure
419 * Initializes the hw->mbx struct to correct values for pf mailbox
421 s32
igb_init_mbx_params_pf(struct e1000_hw
*hw
)
423 struct e1000_mbx_info
*mbx
= &hw
->mbx
;
425 if (hw
->mac
.type
== e1000_82576
) {
429 mbx
->size
= E1000_VFMAILBOX_SIZE
;
431 mbx
->ops
.read
= igb_read_mbx_pf
;
432 mbx
->ops
.write
= igb_write_mbx_pf
;
433 mbx
->ops
.read_posted
= igb_read_posted_mbx
;
434 mbx
->ops
.write_posted
= igb_write_posted_mbx
;
435 mbx
->ops
.check_for_msg
= igb_check_for_msg_pf
;
436 mbx
->ops
.check_for_ack
= igb_check_for_ack_pf
;
437 mbx
->ops
.check_for_rst
= igb_check_for_rst_pf
;
439 mbx
->stats
.msgs_tx
= 0;
440 mbx
->stats
.msgs_rx
= 0;
This page took 0.039098 seconds and 5 git commands to generate.