Loading...
1// SPDX-License-Identifier: GPL-2.0
2/* Copyright(c) 1999 - 2018 Intel Corporation. */
3
4#include "mbx.h"
5#include "ixgbevf.h"
6
7/**
8 * ixgbevf_poll_for_msg - Wait for message notification
9 * @hw: pointer to the HW structure
10 *
11 * returns 0 if it successfully received a message notification
12 **/
13static s32 ixgbevf_poll_for_msg(struct ixgbe_hw *hw)
14{
15 struct ixgbe_mbx_info *mbx = &hw->mbx;
16 int countdown = mbx->timeout;
17
18 if (!countdown || !mbx->ops.check_for_msg)
19 return IXGBE_ERR_CONFIG;
20
21 while (countdown && mbx->ops.check_for_msg(hw)) {
22 countdown--;
23 udelay(mbx->udelay);
24 }
25
26 return countdown ? 0 : IXGBE_ERR_TIMEOUT;
27}
28
29/**
30 * ixgbevf_poll_for_ack - Wait for message acknowledgment
31 * @hw: pointer to the HW structure
32 *
33 * returns 0 if it successfully received a message acknowledgment
34 **/
35static s32 ixgbevf_poll_for_ack(struct ixgbe_hw *hw)
36{
37 struct ixgbe_mbx_info *mbx = &hw->mbx;
38 int countdown = mbx->timeout;
39
40 if (!countdown || !mbx->ops.check_for_ack)
41 return IXGBE_ERR_CONFIG;
42
43 while (countdown && mbx->ops.check_for_ack(hw)) {
44 countdown--;
45 udelay(mbx->udelay);
46 }
47
48 return countdown ? 0 : IXGBE_ERR_TIMEOUT;
49}
50
51/**
52 * ixgbevf_read_mailbox_vf - read VF's mailbox register
53 * @hw: pointer to the HW structure
54 *
55 * This function is used to read the mailbox register dedicated for VF without
56 * losing the read to clear status bits.
57 **/
58static u32 ixgbevf_read_mailbox_vf(struct ixgbe_hw *hw)
59{
60 u32 vf_mailbox = IXGBE_READ_REG(hw, IXGBE_VFMAILBOX);
61
62 vf_mailbox |= hw->mbx.vf_mailbox;
63 hw->mbx.vf_mailbox |= vf_mailbox & IXGBE_VFMAILBOX_R2C_BITS;
64
65 return vf_mailbox;
66}
67
68/**
69 * ixgbevf_clear_msg_vf - clear PF status bit
70 * @hw: pointer to the HW structure
71 *
72 * This function is used to clear PFSTS bit in the VFMAILBOX register
73 **/
74static void ixgbevf_clear_msg_vf(struct ixgbe_hw *hw)
75{
76 u32 vf_mailbox = ixgbevf_read_mailbox_vf(hw);
77
78 if (vf_mailbox & IXGBE_VFMAILBOX_PFSTS) {
79 hw->mbx.stats.reqs++;
80 hw->mbx.vf_mailbox &= ~IXGBE_VFMAILBOX_PFSTS;
81 }
82}
83
84/**
85 * ixgbevf_clear_ack_vf - clear PF ACK bit
86 * @hw: pointer to the HW structure
87 *
88 * This function is used to clear PFACK bit in the VFMAILBOX register
89 **/
90static void ixgbevf_clear_ack_vf(struct ixgbe_hw *hw)
91{
92 u32 vf_mailbox = ixgbevf_read_mailbox_vf(hw);
93
94 if (vf_mailbox & IXGBE_VFMAILBOX_PFACK) {
95 hw->mbx.stats.acks++;
96 hw->mbx.vf_mailbox &= ~IXGBE_VFMAILBOX_PFACK;
97 }
98}
99
100/**
101 * ixgbevf_clear_rst_vf - clear PF reset bit
102 * @hw: pointer to the HW structure
103 *
104 * This function is used to clear reset indication and reset done bit in
105 * VFMAILBOX register after reset the shared resources and the reset sequence.
106 **/
107static void ixgbevf_clear_rst_vf(struct ixgbe_hw *hw)
108{
109 u32 vf_mailbox = ixgbevf_read_mailbox_vf(hw);
110
111 if (vf_mailbox & (IXGBE_VFMAILBOX_RSTI | IXGBE_VFMAILBOX_RSTD)) {
112 hw->mbx.stats.rsts++;
113 hw->mbx.vf_mailbox &= ~(IXGBE_VFMAILBOX_RSTI |
114 IXGBE_VFMAILBOX_RSTD);
115 }
116}
117
118/**
119 * ixgbevf_check_for_bit_vf - Determine if a status bit was set
120 * @hw: pointer to the HW structure
121 * @mask: bitmask for bits to be tested and cleared
122 *
123 * This function is used to check for the read to clear bits within
124 * the V2P mailbox.
125 **/
126static s32 ixgbevf_check_for_bit_vf(struct ixgbe_hw *hw, u32 mask)
127{
128 u32 vf_mailbox = ixgbevf_read_mailbox_vf(hw);
129 s32 ret_val = IXGBE_ERR_MBX;
130
131 if (vf_mailbox & mask)
132 ret_val = 0;
133
134 return ret_val;
135}
136
137/**
138 * ixgbevf_check_for_msg_vf - checks to see if the PF has sent mail
139 * @hw: pointer to the HW structure
140 *
141 * returns 0 if the PF has set the Status bit or else ERR_MBX
142 **/
143static s32 ixgbevf_check_for_msg_vf(struct ixgbe_hw *hw)
144{
145 s32 ret_val = IXGBE_ERR_MBX;
146
147 if (!ixgbevf_check_for_bit_vf(hw, IXGBE_VFMAILBOX_PFSTS)) {
148 ret_val = 0;
149 hw->mbx.stats.reqs++;
150 }
151
152 return ret_val;
153}
154
155/**
156 * ixgbevf_check_for_ack_vf - checks to see if the PF has ACK'd
157 * @hw: pointer to the HW structure
158 *
159 * returns 0 if the PF has set the ACK bit or else ERR_MBX
160 **/
161static s32 ixgbevf_check_for_ack_vf(struct ixgbe_hw *hw)
162{
163 s32 ret_val = IXGBE_ERR_MBX;
164
165 if (!ixgbevf_check_for_bit_vf(hw, IXGBE_VFMAILBOX_PFACK)) {
166 ret_val = 0;
167 ixgbevf_clear_ack_vf(hw);
168 hw->mbx.stats.acks++;
169 }
170
171 return ret_val;
172}
173
174/**
175 * ixgbevf_check_for_rst_vf - checks to see if the PF has reset
176 * @hw: pointer to the HW structure
177 *
178 * returns true if the PF has set the reset done bit or else false
179 **/
180static s32 ixgbevf_check_for_rst_vf(struct ixgbe_hw *hw)
181{
182 s32 ret_val = IXGBE_ERR_MBX;
183
184 if (!ixgbevf_check_for_bit_vf(hw, (IXGBE_VFMAILBOX_RSTD |
185 IXGBE_VFMAILBOX_RSTI))) {
186 ret_val = 0;
187 ixgbevf_clear_rst_vf(hw);
188 hw->mbx.stats.rsts++;
189 }
190
191 return ret_val;
192}
193
194/**
195 * ixgbevf_obtain_mbx_lock_vf - obtain mailbox lock
196 * @hw: pointer to the HW structure
197 *
198 * return 0 if we obtained the mailbox lock
199 **/
200static s32 ixgbevf_obtain_mbx_lock_vf(struct ixgbe_hw *hw)
201{
202 struct ixgbe_mbx_info *mbx = &hw->mbx;
203 s32 ret_val = IXGBE_ERR_CONFIG;
204 int countdown = mbx->timeout;
205 u32 vf_mailbox;
206
207 if (!mbx->timeout)
208 return ret_val;
209
210 while (countdown--) {
211 /* Reserve mailbox for VF use */
212 vf_mailbox = ixgbevf_read_mailbox_vf(hw);
213 vf_mailbox |= IXGBE_VFMAILBOX_VFU;
214 IXGBE_WRITE_REG(hw, IXGBE_VFMAILBOX, vf_mailbox);
215
216 /* Verify that VF is the owner of the lock */
217 if (ixgbevf_read_mailbox_vf(hw) & IXGBE_VFMAILBOX_VFU) {
218 ret_val = 0;
219 break;
220 }
221
222 /* Wait a bit before trying again */
223 udelay(mbx->udelay);
224 }
225
226 if (ret_val)
227 ret_val = IXGBE_ERR_TIMEOUT;
228
229 return ret_val;
230}
231
232/**
233 * ixgbevf_release_mbx_lock_vf - release mailbox lock
234 * @hw: pointer to the HW structure
235 **/
236static void ixgbevf_release_mbx_lock_vf(struct ixgbe_hw *hw)
237{
238 u32 vf_mailbox;
239
240 /* Return ownership of the buffer */
241 vf_mailbox = ixgbevf_read_mailbox_vf(hw);
242 vf_mailbox &= ~IXGBE_VFMAILBOX_VFU;
243 IXGBE_WRITE_REG(hw, IXGBE_VFMAILBOX, vf_mailbox);
244}
245
246/**
247 * ixgbevf_release_mbx_lock_vf_legacy - release mailbox lock
248 * @hw: pointer to the HW structure
249 **/
250static void ixgbevf_release_mbx_lock_vf_legacy(struct ixgbe_hw *__always_unused hw)
251{
252}
253
254/**
255 * ixgbevf_write_mbx_vf - Write a message to the mailbox
256 * @hw: pointer to the HW structure
257 * @msg: The message buffer
258 * @size: Length of buffer
259 *
260 * returns 0 if it successfully copied message into the buffer
261 **/
262static s32 ixgbevf_write_mbx_vf(struct ixgbe_hw *hw, u32 *msg, u16 size)
263{
264 u32 vf_mailbox;
265 s32 ret_val;
266 u16 i;
267
268 /* lock the mailbox to prevent PF/VF race condition */
269 ret_val = ixgbevf_obtain_mbx_lock_vf(hw);
270 if (ret_val)
271 goto out_no_write;
272
273 /* flush msg and acks as we are overwriting the message buffer */
274 ixgbevf_clear_msg_vf(hw);
275 ixgbevf_clear_ack_vf(hw);
276
277 /* copy the caller specified message to the mailbox memory buffer */
278 for (i = 0; i < size; i++)
279 IXGBE_WRITE_REG_ARRAY(hw, IXGBE_VFMBMEM, i, msg[i]);
280
281 /* update stats */
282 hw->mbx.stats.msgs_tx++;
283
284 /* interrupt the PF to tell it a message has been sent */
285 vf_mailbox = ixgbevf_read_mailbox_vf(hw);
286 vf_mailbox |= IXGBE_VFMAILBOX_REQ;
287 IXGBE_WRITE_REG(hw, IXGBE_VFMAILBOX, vf_mailbox);
288
289 /* if msg sent wait until we receive an ack */
290 ret_val = ixgbevf_poll_for_ack(hw);
291
292out_no_write:
293 hw->mbx.ops.release(hw);
294
295 return ret_val;
296}
297
298/**
299 * ixgbevf_write_mbx_vf_legacy - Write a message to the mailbox
300 * @hw: pointer to the HW structure
301 * @msg: The message buffer
302 * @size: Length of buffer
303 *
304 * returns 0 if it successfully copied message into the buffer
305 **/
306static s32 ixgbevf_write_mbx_vf_legacy(struct ixgbe_hw *hw, u32 *msg, u16 size)
307{
308 s32 ret_val;
309 u16 i;
310
311 /* lock the mailbox to prevent PF/VF race condition */
312 ret_val = ixgbevf_obtain_mbx_lock_vf(hw);
313 if (ret_val)
314 goto out_no_write;
315
316 /* flush msg and acks as we are overwriting the message buffer */
317 ixgbevf_check_for_msg_vf(hw);
318 ixgbevf_clear_msg_vf(hw);
319 ixgbevf_check_for_ack_vf(hw);
320 ixgbevf_clear_ack_vf(hw);
321
322 /* copy the caller specified message to the mailbox memory buffer */
323 for (i = 0; i < size; i++)
324 IXGBE_WRITE_REG_ARRAY(hw, IXGBE_VFMBMEM, i, msg[i]);
325
326 /* update stats */
327 hw->mbx.stats.msgs_tx++;
328
329 /* Drop VFU and interrupt the PF to tell it a message has been sent */
330 IXGBE_WRITE_REG(hw, IXGBE_VFMAILBOX, IXGBE_VFMAILBOX_REQ);
331
332out_no_write:
333 return ret_val;
334}
335
336/**
337 * ixgbevf_read_mbx_vf - Reads a message from the inbox intended for VF
338 * @hw: pointer to the HW structure
339 * @msg: The message buffer
340 * @size: Length of buffer
341 *
342 * returns 0 if it successfully read message from buffer
343 **/
344static s32 ixgbevf_read_mbx_vf(struct ixgbe_hw *hw, u32 *msg, u16 size)
345{
346 u32 vf_mailbox;
347 s32 ret_val;
348 u16 i;
349
350 /* check if there is a message from PF */
351 ret_val = ixgbevf_check_for_msg_vf(hw);
352 if (ret_val)
353 return ret_val;
354
355 ixgbevf_clear_msg_vf(hw);
356
357 /* copy the message from the mailbox memory buffer */
358 for (i = 0; i < size; i++)
359 msg[i] = IXGBE_READ_REG_ARRAY(hw, IXGBE_VFMBMEM, i);
360
361 /* Acknowledge receipt */
362 vf_mailbox = ixgbevf_read_mailbox_vf(hw);
363 vf_mailbox |= IXGBE_VFMAILBOX_ACK;
364 IXGBE_WRITE_REG(hw, IXGBE_VFMAILBOX, vf_mailbox);
365
366 /* update stats */
367 hw->mbx.stats.msgs_rx++;
368
369 return ret_val;
370}
371
372/**
373 * ixgbevf_read_mbx_vf_legacy - Reads a message from the inbox intended for VF
374 * @hw: pointer to the HW structure
375 * @msg: The message buffer
376 * @size: Length of buffer
377 *
378 * returns 0 if it successfully read message from buffer
379 **/
380static s32 ixgbevf_read_mbx_vf_legacy(struct ixgbe_hw *hw, u32 *msg, u16 size)
381{
382 s32 ret_val = 0;
383 u16 i;
384
385 /* lock the mailbox to prevent PF/VF race condition */
386 ret_val = ixgbevf_obtain_mbx_lock_vf(hw);
387 if (ret_val)
388 goto out_no_read;
389
390 /* copy the message from the mailbox memory buffer */
391 for (i = 0; i < size; i++)
392 msg[i] = IXGBE_READ_REG_ARRAY(hw, IXGBE_VFMBMEM, i);
393
394 /* Acknowledge receipt and release mailbox, then we're done */
395 IXGBE_WRITE_REG(hw, IXGBE_VFMAILBOX, IXGBE_VFMAILBOX_ACK);
396
397 /* update stats */
398 hw->mbx.stats.msgs_rx++;
399
400out_no_read:
401 return ret_val;
402}
403
404/**
405 * ixgbevf_init_mbx_params_vf - set initial values for VF mailbox
406 * @hw: pointer to the HW structure
407 *
408 * Initializes the hw->mbx struct to correct values for VF mailbox
409 */
410static s32 ixgbevf_init_mbx_params_vf(struct ixgbe_hw *hw)
411{
412 struct ixgbe_mbx_info *mbx = &hw->mbx;
413
414 /* start mailbox as timed out and let the reset_hw call set the timeout
415 * value to begin communications
416 */
417 mbx->timeout = IXGBE_VF_MBX_INIT_TIMEOUT;
418 mbx->udelay = IXGBE_VF_MBX_INIT_DELAY;
419
420 mbx->size = IXGBE_VFMAILBOX_SIZE;
421
422 mbx->stats.msgs_tx = 0;
423 mbx->stats.msgs_rx = 0;
424 mbx->stats.reqs = 0;
425 mbx->stats.acks = 0;
426 mbx->stats.rsts = 0;
427
428 return 0;
429}
430
431/**
432 * ixgbevf_poll_mbx - Wait for message and read it from the mailbox
433 * @hw: pointer to the HW structure
434 * @msg: The message buffer
435 * @size: Length of buffer
436 *
437 * returns 0 if it successfully read message from buffer
438 **/
439s32 ixgbevf_poll_mbx(struct ixgbe_hw *hw, u32 *msg, u16 size)
440{
441 struct ixgbe_mbx_info *mbx = &hw->mbx;
442 s32 ret_val = IXGBE_ERR_CONFIG;
443
444 if (!mbx->ops.read || !mbx->ops.check_for_msg || !mbx->timeout)
445 return ret_val;
446
447 /* limit read to size of mailbox */
448 if (size > mbx->size)
449 size = mbx->size;
450
451 ret_val = ixgbevf_poll_for_msg(hw);
452 /* if ack received read message, otherwise we timed out */
453 if (!ret_val)
454 ret_val = mbx->ops.read(hw, msg, size);
455
456 return ret_val;
457}
458
459/**
460 * ixgbevf_write_mbx - Write a message to the mailbox and wait for ACK
461 * @hw: pointer to the HW structure
462 * @msg: The message buffer
463 * @size: Length of buffer
464 *
465 * returns 0 if it successfully copied message into the buffer and
466 * received an ACK to that message within specified period
467 **/
468s32 ixgbevf_write_mbx(struct ixgbe_hw *hw, u32 *msg, u16 size)
469{
470 struct ixgbe_mbx_info *mbx = &hw->mbx;
471 s32 ret_val = IXGBE_ERR_CONFIG;
472
473 /**
474 * exit if either we can't write, release
475 * or there is no timeout defined
476 */
477 if (!mbx->ops.write || !mbx->ops.check_for_ack || !mbx->ops.release ||
478 !mbx->timeout)
479 return ret_val;
480
481 if (size > mbx->size)
482 ret_val = IXGBE_ERR_PARAM;
483 else
484 ret_val = mbx->ops.write(hw, msg, size);
485
486 return ret_val;
487}
488
489const struct ixgbe_mbx_operations ixgbevf_mbx_ops = {
490 .init_params = ixgbevf_init_mbx_params_vf,
491 .release = ixgbevf_release_mbx_lock_vf,
492 .read = ixgbevf_read_mbx_vf,
493 .write = ixgbevf_write_mbx_vf,
494 .check_for_msg = ixgbevf_check_for_msg_vf,
495 .check_for_ack = ixgbevf_check_for_ack_vf,
496 .check_for_rst = ixgbevf_check_for_rst_vf,
497};
498
499const struct ixgbe_mbx_operations ixgbevf_mbx_ops_legacy = {
500 .init_params = ixgbevf_init_mbx_params_vf,
501 .release = ixgbevf_release_mbx_lock_vf_legacy,
502 .read = ixgbevf_read_mbx_vf_legacy,
503 .write = ixgbevf_write_mbx_vf_legacy,
504 .check_for_msg = ixgbevf_check_for_msg_vf,
505 .check_for_ack = ixgbevf_check_for_ack_vf,
506 .check_for_rst = ixgbevf_check_for_rst_vf,
507};
508
509/* Mailbox operations when running on Hyper-V.
510 * On Hyper-V, PF/VF communication is not through the
511 * hardware mailbox; this communication is through
512 * a software mediated path.
513 * Most mail box operations are noop while running on
514 * Hyper-V.
515 */
516const struct ixgbe_mbx_operations ixgbevf_hv_mbx_ops = {
517 .init_params = ixgbevf_init_mbx_params_vf,
518 .check_for_rst = ixgbevf_check_for_rst_vf,
519};
1/*******************************************************************************
2
3 Intel 82599 Virtual Function driver
4 Copyright(c) 1999 - 2012 Intel Corporation.
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
16 this program; if not, write to the Free Software Foundation, Inc.,
17 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
18
19 The full GNU General Public License is included in this distribution in
20 the file called "COPYING".
21
22 Contact Information:
23 e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
24 Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
25
26*******************************************************************************/
27
28#include "mbx.h"
29#include "ixgbevf.h"
30
31/**
32 * ixgbevf_poll_for_msg - Wait for message notification
33 * @hw: pointer to the HW structure
34 *
35 * returns 0 if it successfully received a message notification
36 **/
37static s32 ixgbevf_poll_for_msg(struct ixgbe_hw *hw)
38{
39 struct ixgbe_mbx_info *mbx = &hw->mbx;
40 int countdown = mbx->timeout;
41
42 while (countdown && mbx->ops.check_for_msg(hw)) {
43 countdown--;
44 udelay(mbx->udelay);
45 }
46
47 /* if we failed, all future posted messages fail until reset */
48 if (!countdown)
49 mbx->timeout = 0;
50
51 return countdown ? 0 : IXGBE_ERR_MBX;
52}
53
54/**
55 * ixgbevf_poll_for_ack - Wait for message acknowledgement
56 * @hw: pointer to the HW structure
57 *
58 * returns 0 if it successfully received a message acknowledgement
59 **/
60static s32 ixgbevf_poll_for_ack(struct ixgbe_hw *hw)
61{
62 struct ixgbe_mbx_info *mbx = &hw->mbx;
63 int countdown = mbx->timeout;
64
65 while (countdown && mbx->ops.check_for_ack(hw)) {
66 countdown--;
67 udelay(mbx->udelay);
68 }
69
70 /* if we failed, all future posted messages fail until reset */
71 if (!countdown)
72 mbx->timeout = 0;
73
74 return countdown ? 0 : IXGBE_ERR_MBX;
75}
76
77/**
78 * ixgbevf_read_posted_mbx - Wait for message notification and receive message
79 * @hw: pointer to the HW structure
80 * @msg: The message buffer
81 * @size: Length of buffer
82 *
83 * returns 0 if it successfully received a message notification and
84 * copied it into the receive buffer.
85 **/
86static s32 ixgbevf_read_posted_mbx(struct ixgbe_hw *hw, u32 *msg, u16 size)
87{
88 struct ixgbe_mbx_info *mbx = &hw->mbx;
89 s32 ret_val = -IXGBE_ERR_MBX;
90
91 if (!mbx->ops.read)
92 goto out;
93
94 ret_val = ixgbevf_poll_for_msg(hw);
95
96 /* if ack received read message, otherwise we timed out */
97 if (!ret_val)
98 ret_val = mbx->ops.read(hw, msg, size);
99out:
100 return ret_val;
101}
102
103/**
104 * ixgbevf_write_posted_mbx - Write a message to the mailbox, wait for ack
105 * @hw: pointer to the HW structure
106 * @msg: The message buffer
107 * @size: Length of buffer
108 *
109 * returns 0 if it successfully copied message into the buffer and
110 * received an ack to that message within delay * timeout period
111 **/
112static s32 ixgbevf_write_posted_mbx(struct ixgbe_hw *hw, u32 *msg, u16 size)
113{
114 struct ixgbe_mbx_info *mbx = &hw->mbx;
115 s32 ret_val = -IXGBE_ERR_MBX;
116
117 /* exit if either we can't write or there isn't a defined timeout */
118 if (!mbx->ops.write || !mbx->timeout)
119 goto out;
120
121 /* send msg */
122 ret_val = mbx->ops.write(hw, msg, size);
123
124 /* if msg sent wait until we receive an ack */
125 if (!ret_val)
126 ret_val = ixgbevf_poll_for_ack(hw);
127out:
128 return ret_val;
129}
130
131/**
132 * ixgbevf_read_v2p_mailbox - read v2p mailbox
133 * @hw: pointer to the HW structure
134 *
135 * This function is used to read the v2p mailbox without losing the read to
136 * clear status bits.
137 **/
138static u32 ixgbevf_read_v2p_mailbox(struct ixgbe_hw *hw)
139{
140 u32 v2p_mailbox = IXGBE_READ_REG(hw, IXGBE_VFMAILBOX);
141
142 v2p_mailbox |= hw->mbx.v2p_mailbox;
143 hw->mbx.v2p_mailbox |= v2p_mailbox & IXGBE_VFMAILBOX_R2C_BITS;
144
145 return v2p_mailbox;
146}
147
148/**
149 * ixgbevf_check_for_bit_vf - Determine if a status bit was set
150 * @hw: pointer to the HW structure
151 * @mask: bitmask for bits to be tested and cleared
152 *
153 * This function is used to check for the read to clear bits within
154 * the V2P mailbox.
155 **/
156static s32 ixgbevf_check_for_bit_vf(struct ixgbe_hw *hw, u32 mask)
157{
158 u32 v2p_mailbox = ixgbevf_read_v2p_mailbox(hw);
159 s32 ret_val = IXGBE_ERR_MBX;
160
161 if (v2p_mailbox & mask)
162 ret_val = 0;
163
164 hw->mbx.v2p_mailbox &= ~mask;
165
166 return ret_val;
167}
168
169/**
170 * ixgbevf_check_for_msg_vf - checks to see if the PF has sent mail
171 * @hw: pointer to the HW structure
172 *
173 * returns 0 if the PF has set the Status bit or else ERR_MBX
174 **/
175static s32 ixgbevf_check_for_msg_vf(struct ixgbe_hw *hw)
176{
177 s32 ret_val = IXGBE_ERR_MBX;
178
179 if (!ixgbevf_check_for_bit_vf(hw, IXGBE_VFMAILBOX_PFSTS)) {
180 ret_val = 0;
181 hw->mbx.stats.reqs++;
182 }
183
184 return ret_val;
185}
186
187/**
188 * ixgbevf_check_for_ack_vf - checks to see if the PF has ACK'd
189 * @hw: pointer to the HW structure
190 *
191 * returns 0 if the PF has set the ACK bit or else ERR_MBX
192 **/
193static s32 ixgbevf_check_for_ack_vf(struct ixgbe_hw *hw)
194{
195 s32 ret_val = IXGBE_ERR_MBX;
196
197 if (!ixgbevf_check_for_bit_vf(hw, IXGBE_VFMAILBOX_PFACK)) {
198 ret_val = 0;
199 hw->mbx.stats.acks++;
200 }
201
202 return ret_val;
203}
204
205/**
206 * ixgbevf_check_for_rst_vf - checks to see if the PF has reset
207 * @hw: pointer to the HW structure
208 *
209 * returns true if the PF has set the reset done bit or else false
210 **/
211static s32 ixgbevf_check_for_rst_vf(struct ixgbe_hw *hw)
212{
213 s32 ret_val = IXGBE_ERR_MBX;
214
215 if (!ixgbevf_check_for_bit_vf(hw, (IXGBE_VFMAILBOX_RSTD |
216 IXGBE_VFMAILBOX_RSTI))) {
217 ret_val = 0;
218 hw->mbx.stats.rsts++;
219 }
220
221 return ret_val;
222}
223
224/**
225 * ixgbevf_obtain_mbx_lock_vf - obtain mailbox lock
226 * @hw: pointer to the HW structure
227 *
228 * return 0 if we obtained the mailbox lock
229 **/
230static s32 ixgbevf_obtain_mbx_lock_vf(struct ixgbe_hw *hw)
231{
232 s32 ret_val = IXGBE_ERR_MBX;
233
234 /* Take ownership of the buffer */
235 IXGBE_WRITE_REG(hw, IXGBE_VFMAILBOX, IXGBE_VFMAILBOX_VFU);
236
237 /* reserve mailbox for vf use */
238 if (ixgbevf_read_v2p_mailbox(hw) & IXGBE_VFMAILBOX_VFU)
239 ret_val = 0;
240
241 return ret_val;
242}
243
244/**
245 * ixgbevf_write_mbx_vf - Write a message to the mailbox
246 * @hw: pointer to the HW structure
247 * @msg: The message buffer
248 * @size: Length of buffer
249 *
250 * returns 0 if it successfully copied message into the buffer
251 **/
252static s32 ixgbevf_write_mbx_vf(struct ixgbe_hw *hw, u32 *msg, u16 size)
253{
254 s32 ret_val;
255 u16 i;
256
257
258 /* lock the mailbox to prevent pf/vf race condition */
259 ret_val = ixgbevf_obtain_mbx_lock_vf(hw);
260 if (ret_val)
261 goto out_no_write;
262
263 /* flush msg and acks as we are overwriting the message buffer */
264 ixgbevf_check_for_msg_vf(hw);
265 ixgbevf_check_for_ack_vf(hw);
266
267 /* copy the caller specified message to the mailbox memory buffer */
268 for (i = 0; i < size; i++)
269 IXGBE_WRITE_REG_ARRAY(hw, IXGBE_VFMBMEM, i, msg[i]);
270
271 /* update stats */
272 hw->mbx.stats.msgs_tx++;
273
274 /* Drop VFU and interrupt the PF to tell it a message has been sent */
275 IXGBE_WRITE_REG(hw, IXGBE_VFMAILBOX, IXGBE_VFMAILBOX_REQ);
276
277out_no_write:
278 return ret_val;
279}
280
281/**
282 * ixgbevf_read_mbx_vf - Reads a message from the inbox intended for vf
283 * @hw: pointer to the HW structure
284 * @msg: The message buffer
285 * @size: Length of buffer
286 *
287 * returns 0 if it successfully read message from buffer
288 **/
289static s32 ixgbevf_read_mbx_vf(struct ixgbe_hw *hw, u32 *msg, u16 size)
290{
291 s32 ret_val = 0;
292 u16 i;
293
294 /* lock the mailbox to prevent pf/vf race condition */
295 ret_val = ixgbevf_obtain_mbx_lock_vf(hw);
296 if (ret_val)
297 goto out_no_read;
298
299 /* copy the message from the mailbox memory buffer */
300 for (i = 0; i < size; i++)
301 msg[i] = IXGBE_READ_REG_ARRAY(hw, IXGBE_VFMBMEM, i);
302
303 /* Acknowledge receipt and release mailbox, then we're done */
304 IXGBE_WRITE_REG(hw, IXGBE_VFMAILBOX, IXGBE_VFMAILBOX_ACK);
305
306 /* update stats */
307 hw->mbx.stats.msgs_rx++;
308
309out_no_read:
310 return ret_val;
311}
312
313/**
314 * ixgbevf_init_mbx_params_vf - set initial values for vf mailbox
315 * @hw: pointer to the HW structure
316 *
317 * Initializes the hw->mbx struct to correct values for vf mailbox
318 */
319static s32 ixgbevf_init_mbx_params_vf(struct ixgbe_hw *hw)
320{
321 struct ixgbe_mbx_info *mbx = &hw->mbx;
322
323 /* start mailbox as timed out and let the reset_hw call set the timeout
324 * value to begin communications */
325 mbx->timeout = 0;
326 mbx->udelay = IXGBE_VF_MBX_INIT_DELAY;
327
328 mbx->size = IXGBE_VFMAILBOX_SIZE;
329
330 mbx->stats.msgs_tx = 0;
331 mbx->stats.msgs_rx = 0;
332 mbx->stats.reqs = 0;
333 mbx->stats.acks = 0;
334 mbx->stats.rsts = 0;
335
336 return 0;
337}
338
339const struct ixgbe_mbx_operations ixgbevf_mbx_ops = {
340 .init_params = ixgbevf_init_mbx_params_vf,
341 .read = ixgbevf_read_mbx_vf,
342 .write = ixgbevf_write_mbx_vf,
343 .read_posted = ixgbevf_read_posted_mbx,
344 .write_posted = ixgbevf_write_posted_mbx,
345 .check_for_msg = ixgbevf_check_for_msg_vf,
346 .check_for_ack = ixgbevf_check_for_ack_vf,
347 .check_for_rst = ixgbevf_check_for_rst_vf,
348};
349