1 /******************************************************************************
2
3 Copyright (c) 2001-2012, Intel Corporation
4 All rights reserved.
5
6 Redistribution and use in source and binary forms, with or without
7 modification, are permitted provided that the following conditions are met:
8
9 1. Redistributions of source code must retain the above copyright notice,
10 this list of conditions and the following disclaimer.
11
12 2. Redistributions in binary form must reproduce the above copyright
13 notice, this list of conditions and the following disclaimer in the
14 documentation and/or other materials provided with the distribution.
15
16 3. Neither the name of the Intel Corporation nor the names of its
17 contributors may be used to endorse or promote products derived from
18 this software without specific prior written permission.
19
20 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
24 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 POSSIBILITY OF SUCH DAMAGE.
31
32 ******************************************************************************/
33 /*$FreeBSD$*/
34
35 #include "ixgbe_type.h"
36 #include "ixgbe_mbx.h"
37
38 /**
39 * ixgbe_read_mbx - Reads a message from the mailbox
40 * @hw: pointer to the HW structure
41 * @msg: The message buffer
42 * @size: Length of buffer
43 * @mbx_id: id of mailbox to read
44 *
45 * returns SUCCESS if it successfuly read message from buffer
46 **/
47 s32 ixgbe_read_mbx(struct ixgbe_hw *hw, u32 *msg, u16 size, u16 mbx_id)
48 {
49 struct ixgbe_mbx_info *mbx = &hw->mbx;
50 s32 ret_val = IXGBE_ERR_MBX;
51
52 DEBUGFUNC("ixgbe_read_mbx");
53
54 /* limit read to size of mailbox */
55 if (size > mbx->size)
56 size = mbx->size;
57
58 if (mbx->ops.read)
59 ret_val = mbx->ops.read(hw, msg, size, mbx_id);
60
61 return ret_val;
62 }
63
64 /**
65 * ixgbe_write_mbx - Write a message to the mailbox
66 * @hw: pointer to the HW structure
67 * @msg: The message buffer
68 * @size: Length of buffer
69 * @mbx_id: id of mailbox to write
70 *
71 * returns SUCCESS if it successfully copied message into the buffer
72 **/
73 s32 ixgbe_write_mbx(struct ixgbe_hw *hw, u32 *msg, u16 size, u16 mbx_id)
74 {
75 struct ixgbe_mbx_info *mbx = &hw->mbx;
76 s32 ret_val = IXGBE_SUCCESS;
77
78 DEBUGFUNC("ixgbe_write_mbx");
79
80 if (size > mbx->size)
81 ret_val = IXGBE_ERR_MBX;
82
83 else if (mbx->ops.write)
84 ret_val = mbx->ops.write(hw, msg, size, mbx_id);
85
86 return ret_val;
87 }
88
89 /**
90 * ixgbe_check_for_msg - checks to see if someone sent us mail
91 * @hw: pointer to the HW structure
92 * @mbx_id: id of mailbox to check
93 *
94 * returns SUCCESS if the Status bit was found or else ERR_MBX
95 **/
96 s32 ixgbe_check_for_msg(struct ixgbe_hw *hw, u16 mbx_id)
97 {
98 struct ixgbe_mbx_info *mbx = &hw->mbx;
99 s32 ret_val = IXGBE_ERR_MBX;
100
101 DEBUGFUNC("ixgbe_check_for_msg");
102
103 if (mbx->ops.check_for_msg)
104 ret_val = mbx->ops.check_for_msg(hw, mbx_id);
105
106 return ret_val;
107 }
108
109 /**
110 * ixgbe_check_for_ack - checks to see if someone sent us ACK
111 * @hw: pointer to the HW structure
112 * @mbx_id: id of mailbox to check
113 *
114 * returns SUCCESS if the Status bit was found or else ERR_MBX
115 **/
116 s32 ixgbe_check_for_ack(struct ixgbe_hw *hw, u16 mbx_id)
117 {
118 struct ixgbe_mbx_info *mbx = &hw->mbx;
119 s32 ret_val = IXGBE_ERR_MBX;
120
121 DEBUGFUNC("ixgbe_check_for_ack");
122
123 if (mbx->ops.check_for_ack)
124 ret_val = mbx->ops.check_for_ack(hw, mbx_id);
125
126 return ret_val;
127 }
128
129 /**
130 * ixgbe_check_for_rst - checks to see if other side has reset
131 * @hw: pointer to the HW structure
132 * @mbx_id: id of mailbox to check
133 *
134 * returns SUCCESS if the Status bit was found or else ERR_MBX
135 **/
136 s32 ixgbe_check_for_rst(struct ixgbe_hw *hw, u16 mbx_id)
137 {
138 struct ixgbe_mbx_info *mbx = &hw->mbx;
139 s32 ret_val = IXGBE_ERR_MBX;
140
141 DEBUGFUNC("ixgbe_check_for_rst");
142
143 if (mbx->ops.check_for_rst)
144 ret_val = mbx->ops.check_for_rst(hw, mbx_id);
145
146 return ret_val;
147 }
148
149 /**
150 * ixgbe_poll_for_msg - Wait for message notification
151 * @hw: pointer to the HW structure
152 * @mbx_id: id of mailbox to write
153 *
154 * returns SUCCESS if it successfully received a message notification
155 **/
156 static s32 ixgbe_poll_for_msg(struct ixgbe_hw *hw, u16 mbx_id)
157 {
158 struct ixgbe_mbx_info *mbx = &hw->mbx;
159 int countdown = mbx->timeout;
160
161 DEBUGFUNC("ixgbe_poll_for_msg");
162
163 if (!countdown || !mbx->ops.check_for_msg)
164 goto out;
165
166 while (countdown && mbx->ops.check_for_msg(hw, mbx_id)) {
167 countdown--;
168 if (!countdown)
169 break;
170 usec_delay(mbx->usec_delay);
171 }
172
173 out:
174 return countdown ? IXGBE_SUCCESS : IXGBE_ERR_MBX;
175 }
176
177 /**
178 * ixgbe_poll_for_ack - Wait for message acknowledgement
179 * @hw: pointer to the HW structure
180 * @mbx_id: id of mailbox to write
181 *
182 * returns SUCCESS if it successfully received a message acknowledgement
183 **/
184 static s32 ixgbe_poll_for_ack(struct ixgbe_hw *hw, u16 mbx_id)
185 {
186 struct ixgbe_mbx_info *mbx = &hw->mbx;
187 int countdown = mbx->timeout;
188
189 DEBUGFUNC("ixgbe_poll_for_ack");
190
191 if (!countdown || !mbx->ops.check_for_ack)
192 goto out;
193
194 while (countdown && mbx->ops.check_for_ack(hw, mbx_id)) {
195 countdown--;
196 if (!countdown)
197 break;
198 usec_delay(mbx->usec_delay);
199 }
200
201 out:
202 return countdown ? IXGBE_SUCCESS : IXGBE_ERR_MBX;
203 }
204
205 /**
206 * ixgbe_read_posted_mbx - Wait for message notification and receive message
207 * @hw: pointer to the HW structure
208 * @msg: The message buffer
209 * @size: Length of buffer
210 * @mbx_id: id of mailbox to write
211 *
212 * returns SUCCESS if it successfully received a message notification and
213 * copied it into the receive buffer.
214 **/
215 s32 ixgbe_read_posted_mbx(struct ixgbe_hw *hw, u32 *msg, u16 size, u16 mbx_id)
216 {
217 struct ixgbe_mbx_info *mbx = &hw->mbx;
218 s32 ret_val = IXGBE_ERR_MBX;
219
220 DEBUGFUNC("ixgbe_read_posted_mbx");
221
222 if (!mbx->ops.read)
223 goto out;
224
225 ret_val = ixgbe_poll_for_msg(hw, mbx_id);
226
227 /* if ack received read message, otherwise we timed out */
228 if (!ret_val)
229 ret_val = mbx->ops.read(hw, msg, size, mbx_id);
230 out:
231 return ret_val;
232 }
233
234 /**
235 * ixgbe_write_posted_mbx - Write a message to the mailbox, wait for ack
236 * @hw: pointer to the HW structure
237 * @msg: The message buffer
238 * @size: Length of buffer
239 * @mbx_id: id of mailbox to write
240 *
241 * returns SUCCESS if it successfully copied message into the buffer and
242 * received an ack to that message within delay * timeout period
243 **/
244 s32 ixgbe_write_posted_mbx(struct ixgbe_hw *hw, u32 *msg, u16 size,
245 u16 mbx_id)
246 {
247 struct ixgbe_mbx_info *mbx = &hw->mbx;
248 s32 ret_val = IXGBE_ERR_MBX;
249
250 DEBUGFUNC("ixgbe_write_posted_mbx");
251
252 /* exit if either we can't write or there isn't a defined timeout */
253 if (!mbx->ops.write || !mbx->timeout)
254 goto out;
255
256 /* send msg */
257 ret_val = mbx->ops.write(hw, msg, size, mbx_id);
258
259 /* if msg sent wait until we receive an ack */
260 if (!ret_val)
261 ret_val = ixgbe_poll_for_ack(hw, mbx_id);
262 out:
263 return ret_val;
264 }
265
266 /**
267 * ixgbe_init_mbx_ops_generic - Initialize MB function pointers
268 * @hw: pointer to the HW structure
269 *
270 * Setups up the mailbox read and write message function pointers
271 **/
272 void ixgbe_init_mbx_ops_generic(struct ixgbe_hw *hw)
273 {
274 struct ixgbe_mbx_info *mbx = &hw->mbx;
275
276 mbx->ops.read_posted = ixgbe_read_posted_mbx;
277 mbx->ops.write_posted = ixgbe_write_posted_mbx;
278 }
279
280 /**
281 * ixgbe_read_v2p_mailbox - read v2p mailbox
282 * @hw: pointer to the HW structure
283 *
284 * This function is used to read the v2p mailbox without losing the read to
285 * clear status bits.
286 **/
287 static u32 ixgbe_read_v2p_mailbox(struct ixgbe_hw *hw)
288 {
289 u32 v2p_mailbox = IXGBE_READ_REG(hw, IXGBE_VFMAILBOX);
290
291 v2p_mailbox |= hw->mbx.v2p_mailbox;
292 hw->mbx.v2p_mailbox |= v2p_mailbox & IXGBE_VFMAILBOX_R2C_BITS;
293
294 return v2p_mailbox;
295 }
296
297 /**
298 * ixgbe_check_for_bit_vf - Determine if a status bit was set
299 * @hw: pointer to the HW structure
300 * @mask: bitmask for bits to be tested and cleared
301 *
302 * This function is used to check for the read to clear bits within
303 * the V2P mailbox.
304 **/
305 static s32 ixgbe_check_for_bit_vf(struct ixgbe_hw *hw, u32 mask)
306 {
307 u32 v2p_mailbox = ixgbe_read_v2p_mailbox(hw);
308 s32 ret_val = IXGBE_ERR_MBX;
309
310 if (v2p_mailbox & mask)
311 ret_val = IXGBE_SUCCESS;
312
313 hw->mbx.v2p_mailbox &= ~mask;
314
315 return ret_val;
316 }
317
318 /**
319 * ixgbe_check_for_msg_vf - checks to see if the PF has sent mail
320 * @hw: pointer to the HW structure
321 * @mbx_id: id of mailbox to check
322 *
323 * returns SUCCESS if the PF has set the Status bit or else ERR_MBX
324 **/
325 static s32 ixgbe_check_for_msg_vf(struct ixgbe_hw *hw, u16 mbx_id)
326 {
327 s32 ret_val = IXGBE_ERR_MBX;
328
329 UNREFERENCED_1PARAMETER(mbx_id);
330 DEBUGFUNC("ixgbe_check_for_msg_vf");
331
332 if (!ixgbe_check_for_bit_vf(hw, IXGBE_VFMAILBOX_PFSTS)) {
333 ret_val = IXGBE_SUCCESS;
334 hw->mbx.stats.reqs++;
335 }
336
337 return ret_val;
338 }
339
340 /**
341 * ixgbe_check_for_ack_vf - checks to see if the PF has ACK'd
342 * @hw: pointer to the HW structure
343 * @mbx_id: id of mailbox to check
344 *
345 * returns SUCCESS if the PF has set the ACK bit or else ERR_MBX
346 **/
347 static s32 ixgbe_check_for_ack_vf(struct ixgbe_hw *hw, u16 mbx_id)
348 {
349 s32 ret_val = IXGBE_ERR_MBX;
350
351 UNREFERENCED_1PARAMETER(mbx_id);
352 DEBUGFUNC("ixgbe_check_for_ack_vf");
353
354 if (!ixgbe_check_for_bit_vf(hw, IXGBE_VFMAILBOX_PFACK)) {
355 ret_val = IXGBE_SUCCESS;
356 hw->mbx.stats.acks++;
357 }
358
359 return ret_val;
360 }
361
362 /**
363 * ixgbe_check_for_rst_vf - checks to see if the PF has reset
364 * @hw: pointer to the HW structure
365 * @mbx_id: id of mailbox to check
366 *
367 * returns TRUE if the PF has set the reset done bit or else FALSE
368 **/
369 static s32 ixgbe_check_for_rst_vf(struct ixgbe_hw *hw, u16 mbx_id)
370 {
371 s32 ret_val = IXGBE_ERR_MBX;
372
373 UNREFERENCED_1PARAMETER(mbx_id);
374 DEBUGFUNC("ixgbe_check_for_rst_vf");
375
376 if (!ixgbe_check_for_bit_vf(hw, (IXGBE_VFMAILBOX_RSTD |
377 IXGBE_VFMAILBOX_RSTI))) {
378 ret_val = IXGBE_SUCCESS;
379 hw->mbx.stats.rsts++;
380 }
381
382 return ret_val;
383 }
384
385 /**
386 * ixgbe_obtain_mbx_lock_vf - obtain mailbox lock
387 * @hw: pointer to the HW structure
388 *
389 * return SUCCESS if we obtained the mailbox lock
390 **/
391 static s32 ixgbe_obtain_mbx_lock_vf(struct ixgbe_hw *hw)
392 {
393 s32 ret_val = IXGBE_ERR_MBX;
394
395 DEBUGFUNC("ixgbe_obtain_mbx_lock_vf");
396
397 /* Take ownership of the buffer */
398 IXGBE_WRITE_REG(hw, IXGBE_VFMAILBOX, IXGBE_VFMAILBOX_VFU);
399
400 /* reserve mailbox for vf use */
401 if (ixgbe_read_v2p_mailbox(hw) & IXGBE_VFMAILBOX_VFU)
402 ret_val = IXGBE_SUCCESS;
403
404 return ret_val;
405 }
406
407 /**
408 * ixgbe_write_mbx_vf - Write a message to the mailbox
409 * @hw: pointer to the HW structure
410 * @msg: The message buffer
411 * @size: Length of buffer
412 * @mbx_id: id of mailbox to write
413 *
414 * returns SUCCESS if it successfully copied message into the buffer
415 **/
416 static s32 ixgbe_write_mbx_vf(struct ixgbe_hw *hw, u32 *msg, u16 size,
417 u16 mbx_id)
418 {
419 s32 ret_val;
420 u16 i;
421
422 UNREFERENCED_1PARAMETER(mbx_id);
423
424 DEBUGFUNC("ixgbe_write_mbx_vf");
425
426 /* lock the mailbox to prevent pf/vf race condition */
427 ret_val = ixgbe_obtain_mbx_lock_vf(hw);
428 if (ret_val)
429 goto out_no_write;
430
431 /* flush msg and acks as we are overwriting the message buffer */
432 ixgbe_check_for_msg_vf(hw, 0);
433 ixgbe_check_for_ack_vf(hw, 0);
434
435 /* copy the caller specified message to the mailbox memory buffer */
436 for (i = 0; i < size; i++)
437 IXGBE_WRITE_REG_ARRAY(hw, IXGBE_VFMBMEM, i, msg[i]);
438
439 /* update stats */
440 hw->mbx.stats.msgs_tx++;
441
442 /* Drop VFU and interrupt the PF to tell it a message has been sent */
443 IXGBE_WRITE_REG(hw, IXGBE_VFMAILBOX, IXGBE_VFMAILBOX_REQ);
444
445 out_no_write:
446 return ret_val;
447 }
448
449 /**
450 * ixgbe_read_mbx_vf - Reads a message from the inbox intended for vf
451 * @hw: pointer to the HW structure
452 * @msg: The message buffer
453 * @size: Length of buffer
454 * @mbx_id: id of mailbox to read
455 *
456 * returns SUCCESS if it successfuly read message from buffer
457 **/
458 static s32 ixgbe_read_mbx_vf(struct ixgbe_hw *hw, u32 *msg, u16 size,
459 u16 mbx_id)
460 {
461 s32 ret_val = IXGBE_SUCCESS;
462 u16 i;
463
464 DEBUGFUNC("ixgbe_read_mbx_vf");
465 UNREFERENCED_1PARAMETER(mbx_id);
466
467 /* lock the mailbox to prevent pf/vf race condition */
468 ret_val = ixgbe_obtain_mbx_lock_vf(hw);
469 if (ret_val)
470 goto out_no_read;
471
472 /* copy the message from the mailbox memory buffer */
473 for (i = 0; i < size; i++)
474 msg[i] = IXGBE_READ_REG_ARRAY(hw, IXGBE_VFMBMEM, i);
475
476 /* Acknowledge receipt and release mailbox, then we're done */
477 IXGBE_WRITE_REG(hw, IXGBE_VFMAILBOX, IXGBE_VFMAILBOX_ACK);
478
479 /* update stats */
480 hw->mbx.stats.msgs_rx++;
481
482 out_no_read:
483 return ret_val;
484 }
485
486 /**
487 * ixgbe_init_mbx_params_vf - set initial values for vf mailbox
488 * @hw: pointer to the HW structure
489 *
490 * Initializes the hw->mbx struct to correct values for vf mailbox
491 */
492 void ixgbe_init_mbx_params_vf(struct ixgbe_hw *hw)
493 {
494 struct ixgbe_mbx_info *mbx = &hw->mbx;
495
496 /* start mailbox as timed out and let the reset_hw call set the timeout
497 * value to begin communications */
498 mbx->timeout = 0;
499 mbx->usec_delay = IXGBE_VF_MBX_INIT_DELAY;
500
501 mbx->size = IXGBE_VFMAILBOX_SIZE;
502
503 mbx->ops.read = ixgbe_read_mbx_vf;
504 mbx->ops.write = ixgbe_write_mbx_vf;
505 mbx->ops.read_posted = ixgbe_read_posted_mbx;
506 mbx->ops.write_posted = ixgbe_write_posted_mbx;
507 mbx->ops.check_for_msg = ixgbe_check_for_msg_vf;
508 mbx->ops.check_for_ack = ixgbe_check_for_ack_vf;
509 mbx->ops.check_for_rst = ixgbe_check_for_rst_vf;
510
511 mbx->stats.msgs_tx = 0;
512 mbx->stats.msgs_rx = 0;
513 mbx->stats.reqs = 0;
514 mbx->stats.acks = 0;
515 mbx->stats.rsts = 0;
516 }
517
518 static s32 ixgbe_check_for_bit_pf(struct ixgbe_hw *hw, u32 mask, s32 index)
519 {
520 u32 mbvficr = IXGBE_READ_REG(hw, IXGBE_MBVFICR(index));
521 s32 ret_val = IXGBE_ERR_MBX;
522
523 if (mbvficr & mask) {
524 ret_val = IXGBE_SUCCESS;
525 IXGBE_WRITE_REG(hw, IXGBE_MBVFICR(index), mask);
526 }
527
528 return ret_val;
529 }
530
531 /**
532 * ixgbe_check_for_msg_pf - checks to see if the VF has sent mail
533 * @hw: pointer to the HW structure
534 * @vf_number: the VF index
535 *
536 * returns SUCCESS if the VF has set the Status bit or else ERR_MBX
537 **/
538 static s32 ixgbe_check_for_msg_pf(struct ixgbe_hw *hw, u16 vf_number)
539 {
540 s32 ret_val = IXGBE_ERR_MBX;
541 s32 index = IXGBE_MBVFICR_INDEX(vf_number);
542 u32 vf_bit = vf_number % 16;
543
544 DEBUGFUNC("ixgbe_check_for_msg_pf");
545
546 if (!ixgbe_check_for_bit_pf(hw, IXGBE_MBVFICR_VFREQ_VF1 << vf_bit,
547 index)) {
548 ret_val = IXGBE_SUCCESS;
549 hw->mbx.stats.reqs++;
550 }
551
552 return ret_val;
553 }
554
555 /**
556 * ixgbe_check_for_ack_pf - checks to see if the VF has ACKed
557 * @hw: pointer to the HW structure
558 * @vf_number: the VF index
559 *
560 * returns SUCCESS if the VF has set the Status bit or else ERR_MBX
561 **/
562 static s32 ixgbe_check_for_ack_pf(struct ixgbe_hw *hw, u16 vf_number)
563 {
564 s32 ret_val = IXGBE_ERR_MBX;
565 s32 index = IXGBE_MBVFICR_INDEX(vf_number);
566 u32 vf_bit = vf_number % 16;
567
568 DEBUGFUNC("ixgbe_check_for_ack_pf");
569
570 if (!ixgbe_check_for_bit_pf(hw, IXGBE_MBVFICR_VFACK_VF1 << vf_bit,
571 index)) {
572 ret_val = IXGBE_SUCCESS;
573 hw->mbx.stats.acks++;
574 }
575
576 return ret_val;
577 }
578
579 /**
580 * ixgbe_check_for_rst_pf - checks to see if the VF has reset
581 * @hw: pointer to the HW structure
582 * @vf_number: the VF index
583 *
584 * returns SUCCESS if the VF has set the Status bit or else ERR_MBX
585 **/
586 static s32 ixgbe_check_for_rst_pf(struct ixgbe_hw *hw, u16 vf_number)
587 {
588 u32 reg_offset = (vf_number < 32) ? 0 : 1;
589 u32 vf_shift = vf_number % 32;
590 u32 vflre = 0;
591 s32 ret_val = IXGBE_ERR_MBX;
592
593 DEBUGFUNC("ixgbe_check_for_rst_pf");
594
595 switch (hw->mac.type) {
596 case ixgbe_mac_82599EB:
597 vflre = IXGBE_READ_REG(hw, IXGBE_VFLRE(reg_offset));
598 break;
599 case ixgbe_mac_X540:
600 vflre = IXGBE_READ_REG(hw, IXGBE_VFLREC(reg_offset));
601 break;
602 default:
603 break;
604 }
605
606 if (vflre & (1 << vf_shift)) {
607 ret_val = IXGBE_SUCCESS;
608 IXGBE_WRITE_REG(hw, IXGBE_VFLREC(reg_offset), (1 << vf_shift));
609 hw->mbx.stats.rsts++;
610 }
611
612 return ret_val;
613 }
614
615 /**
616 * ixgbe_obtain_mbx_lock_pf - obtain mailbox lock
617 * @hw: pointer to the HW structure
618 * @vf_number: the VF index
619 *
620 * return SUCCESS if we obtained the mailbox lock
621 **/
622 static s32 ixgbe_obtain_mbx_lock_pf(struct ixgbe_hw *hw, u16 vf_number)
623 {
624 s32 ret_val = IXGBE_ERR_MBX;
625 u32 p2v_mailbox;
626
627 DEBUGFUNC("ixgbe_obtain_mbx_lock_pf");
628
629 /* Take ownership of the buffer */
630 IXGBE_WRITE_REG(hw, IXGBE_PFMAILBOX(vf_number), IXGBE_PFMAILBOX_PFU);
631
632 /* reserve mailbox for vf use */
633 p2v_mailbox = IXGBE_READ_REG(hw, IXGBE_PFMAILBOX(vf_number));
634 if (p2v_mailbox & IXGBE_PFMAILBOX_PFU)
635 ret_val = IXGBE_SUCCESS;
636
637 return ret_val;
638 }
639
640 /**
641 * ixgbe_write_mbx_pf - Places a message in the mailbox
642 * @hw: pointer to the HW structure
643 * @msg: The message buffer
644 * @size: Length of buffer
645 * @vf_number: the VF index
646 *
647 * returns SUCCESS if it successfully copied message into the buffer
648 **/
649 static s32 ixgbe_write_mbx_pf(struct ixgbe_hw *hw, u32 *msg, u16 size,
650 u16 vf_number)
651 {
652 s32 ret_val;
653 u16 i;
654
655 DEBUGFUNC("ixgbe_write_mbx_pf");
656
657 /* lock the mailbox to prevent pf/vf race condition */
658 ret_val = ixgbe_obtain_mbx_lock_pf(hw, vf_number);
659 if (ret_val)
660 goto out_no_write;
661
662 /* flush msg and acks as we are overwriting the message buffer */
663 ixgbe_check_for_msg_pf(hw, vf_number);
664 ixgbe_check_for_ack_pf(hw, vf_number);
665
666 /* copy the caller specified message to the mailbox memory buffer */
667 for (i = 0; i < size; i++)
668 IXGBE_WRITE_REG_ARRAY(hw, IXGBE_PFMBMEM(vf_number), i, msg[i]);
669
670 /* Interrupt VF to tell it a message has been sent and release buffer*/
671 IXGBE_WRITE_REG(hw, IXGBE_PFMAILBOX(vf_number), IXGBE_PFMAILBOX_STS);
672
673 /* update stats */
674 hw->mbx.stats.msgs_tx++;
675
676 out_no_write:
677 return ret_val;
678
679 }
680
681 /**
682 * ixgbe_read_mbx_pf - Read a message from the mailbox
683 * @hw: pointer to the HW structure
684 * @msg: The message buffer
685 * @size: Length of buffer
686 * @vf_number: the VF index
687 *
688 * This function copies a message from the mailbox buffer to the caller's
689 * memory buffer. The presumption is that the caller knows that there was
690 * a message due to a VF request so no polling for message is needed.
691 **/
692 static s32 ixgbe_read_mbx_pf(struct ixgbe_hw *hw, u32 *msg, u16 size,
693 u16 vf_number)
694 {
695 s32 ret_val;
696 u16 i;
697
698 DEBUGFUNC("ixgbe_read_mbx_pf");
699
700 /* lock the mailbox to prevent pf/vf race condition */
701 ret_val = ixgbe_obtain_mbx_lock_pf(hw, vf_number);
702 if (ret_val)
703 goto out_no_read;
704
705 /* copy the message to the mailbox memory buffer */
706 for (i = 0; i < size; i++)
707 msg[i] = IXGBE_READ_REG_ARRAY(hw, IXGBE_PFMBMEM(vf_number), i);
708
709 /* Acknowledge the message and release buffer */
710 IXGBE_WRITE_REG(hw, IXGBE_PFMAILBOX(vf_number), IXGBE_PFMAILBOX_ACK);
711
712 /* update stats */
713 hw->mbx.stats.msgs_rx++;
714
715 out_no_read:
716 return ret_val;
717 }
718
719 /**
720 * ixgbe_init_mbx_params_pf - set initial values for pf mailbox
721 * @hw: pointer to the HW structure
722 *
723 * Initializes the hw->mbx struct to correct values for pf mailbox
724 */
725 void ixgbe_init_mbx_params_pf(struct ixgbe_hw *hw)
726 {
727 struct ixgbe_mbx_info *mbx = &hw->mbx;
728
729 if (hw->mac.type != ixgbe_mac_82599EB &&
730 hw->mac.type != ixgbe_mac_X540)
731 return;
732
733 mbx->timeout = 0;
734 mbx->usec_delay = 0;
735
736 mbx->size = IXGBE_VFMAILBOX_SIZE;
737
738 mbx->ops.read = ixgbe_read_mbx_pf;
739 mbx->ops.write = ixgbe_write_mbx_pf;
740 mbx->ops.read_posted = ixgbe_read_posted_mbx;
741 mbx->ops.write_posted = ixgbe_write_posted_mbx;
742 mbx->ops.check_for_msg = ixgbe_check_for_msg_pf;
743 mbx->ops.check_for_ack = ixgbe_check_for_ack_pf;
744 mbx->ops.check_for_rst = ixgbe_check_for_rst_pf;
745
746 mbx->stats.msgs_tx = 0;
747 mbx->stats.msgs_rx = 0;
748 mbx->stats.reqs = 0;
749 mbx->stats.acks = 0;
750 mbx->stats.rsts = 0;
751 }