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 ret_val = ixgbe_check_for_msg_vf(hw, 0);
433 if (ret_val)
434 goto out_no_write;
435 ret_val = ixgbe_check_for_ack_vf(hw, 0);
436 if (ret_val)
437 goto out_no_write;
438
439 /* copy the caller specified message to the mailbox memory buffer */
440 for (i = 0; i < size; i++)
441 IXGBE_WRITE_REG_ARRAY(hw, IXGBE_VFMBMEM, i, msg[i]);
442
443 /* update stats */
444 hw->mbx.stats.msgs_tx++;
445
446 /* Drop VFU and interrupt the PF to tell it a message has been sent */
447 IXGBE_WRITE_REG(hw, IXGBE_VFMAILBOX, IXGBE_VFMAILBOX_REQ);
448
449 out_no_write:
450 return ret_val;
451 }
452
453 /**
454 * ixgbe_read_mbx_vf - Reads a message from the inbox intended for vf
455 * @hw: pointer to the HW structure
456 * @msg: The message buffer
457 * @size: Length of buffer
458 * @mbx_id: id of mailbox to read
459 *
460 * returns SUCCESS if it successfuly read message from buffer
461 **/
462 static s32 ixgbe_read_mbx_vf(struct ixgbe_hw *hw, u32 *msg, u16 size,
463 u16 mbx_id)
464 {
465 s32 ret_val = IXGBE_SUCCESS;
466 u16 i;
467
468 DEBUGFUNC("ixgbe_read_mbx_vf");
469 UNREFERENCED_1PARAMETER(mbx_id);
470
471 /* lock the mailbox to prevent pf/vf race condition */
472 ret_val = ixgbe_obtain_mbx_lock_vf(hw);
473 if (ret_val)
474 goto out_no_read;
475
476 /* copy the message from the mailbox memory buffer */
477 for (i = 0; i < size; i++)
478 msg[i] = IXGBE_READ_REG_ARRAY(hw, IXGBE_VFMBMEM, i);
479
480 /* Acknowledge receipt and release mailbox, then we're done */
481 IXGBE_WRITE_REG(hw, IXGBE_VFMAILBOX, IXGBE_VFMAILBOX_ACK);
482
483 /* update stats */
484 hw->mbx.stats.msgs_rx++;
485
486 out_no_read:
487 return ret_val;
488 }
489
490 /**
491 * ixgbe_init_mbx_params_vf - set initial values for vf mailbox
492 * @hw: pointer to the HW structure
493 *
494 * Initializes the hw->mbx struct to correct values for vf mailbox
495 */
496 void ixgbe_init_mbx_params_vf(struct ixgbe_hw *hw)
497 {
498 struct ixgbe_mbx_info *mbx = &hw->mbx;
499
500 /* start mailbox as timed out and let the reset_hw call set the timeout
501 * value to begin communications */
502 mbx->timeout = 0;
503 mbx->usec_delay = IXGBE_VF_MBX_INIT_DELAY;
504
505 mbx->size = IXGBE_VFMAILBOX_SIZE;
506
507 mbx->ops.read = ixgbe_read_mbx_vf;
508 mbx->ops.write = ixgbe_write_mbx_vf;
509 mbx->ops.read_posted = ixgbe_read_posted_mbx;
510 mbx->ops.write_posted = ixgbe_write_posted_mbx;
511 mbx->ops.check_for_msg = ixgbe_check_for_msg_vf;
512 mbx->ops.check_for_ack = ixgbe_check_for_ack_vf;
513 mbx->ops.check_for_rst = ixgbe_check_for_rst_vf;
514
515 mbx->stats.msgs_tx = 0;
516 mbx->stats.msgs_rx = 0;
517 mbx->stats.reqs = 0;
518 mbx->stats.acks = 0;
519 mbx->stats.rsts = 0;
520 }
521
522 static s32 ixgbe_check_for_bit_pf(struct ixgbe_hw *hw, u32 mask, s32 index)
523 {
524 u32 mbvficr = IXGBE_READ_REG(hw, IXGBE_MBVFICR(index));
525 s32 ret_val = IXGBE_ERR_MBX;
526
527 if (mbvficr & mask) {
528 ret_val = IXGBE_SUCCESS;
529 IXGBE_WRITE_REG(hw, IXGBE_MBVFICR(index), mask);
530 }
531
532 return ret_val;
533 }
534
535 /**
536 * ixgbe_check_for_msg_pf - checks to see if the VF has sent mail
537 * @hw: pointer to the HW structure
538 * @vf_number: the VF index
539 *
540 * returns SUCCESS if the VF has set the Status bit or else ERR_MBX
541 **/
542 static s32 ixgbe_check_for_msg_pf(struct ixgbe_hw *hw, u16 vf_number)
543 {
544 s32 ret_val = IXGBE_ERR_MBX;
545 s32 index = IXGBE_MBVFICR_INDEX(vf_number);
546 u32 vf_bit = vf_number % 16;
547
548 DEBUGFUNC("ixgbe_check_for_msg_pf");
549
550 if (!ixgbe_check_for_bit_pf(hw, IXGBE_MBVFICR_VFREQ_VF1 << vf_bit,
551 index)) {
552 ret_val = IXGBE_SUCCESS;
553 hw->mbx.stats.reqs++;
554 }
555
556 return ret_val;
557 }
558
559 /**
560 * ixgbe_check_for_ack_pf - checks to see if the VF has ACKed
561 * @hw: pointer to the HW structure
562 * @vf_number: the VF index
563 *
564 * returns SUCCESS if the VF has set the Status bit or else ERR_MBX
565 **/
566 static s32 ixgbe_check_for_ack_pf(struct ixgbe_hw *hw, u16 vf_number)
567 {
568 s32 ret_val = IXGBE_ERR_MBX;
569 s32 index = IXGBE_MBVFICR_INDEX(vf_number);
570 u32 vf_bit = vf_number % 16;
571
572 DEBUGFUNC("ixgbe_check_for_ack_pf");
573
574 if (!ixgbe_check_for_bit_pf(hw, IXGBE_MBVFICR_VFACK_VF1 << vf_bit,
575 index)) {
576 ret_val = IXGBE_SUCCESS;
577 hw->mbx.stats.acks++;
578 }
579
580 return ret_val;
581 }
582
583 /**
584 * ixgbe_check_for_rst_pf - checks to see if the VF has reset
585 * @hw: pointer to the HW structure
586 * @vf_number: the VF index
587 *
588 * returns SUCCESS if the VF has set the Status bit or else ERR_MBX
589 **/
590 static s32 ixgbe_check_for_rst_pf(struct ixgbe_hw *hw, u16 vf_number)
591 {
592 u32 reg_offset = (vf_number < 32) ? 0 : 1;
593 u32 vf_shift = vf_number % 32;
594 u32 vflre = 0;
595 s32 ret_val = IXGBE_ERR_MBX;
596
597 DEBUGFUNC("ixgbe_check_for_rst_pf");
598
599 switch (hw->mac.type) {
600 case ixgbe_mac_82599EB:
601 vflre = IXGBE_READ_REG(hw, IXGBE_VFLRE(reg_offset));
602 break;
603 case ixgbe_mac_X540:
604 vflre = IXGBE_READ_REG(hw, IXGBE_VFLREC(reg_offset));
605 break;
606 default:
607 break;
608 }
609
610 if (vflre & (1 << vf_shift)) {
611 ret_val = IXGBE_SUCCESS;
612 IXGBE_WRITE_REG(hw, IXGBE_VFLREC(reg_offset), (1 << vf_shift));
613 hw->mbx.stats.rsts++;
614 }
615
616 return ret_val;
617 }
618
619 /**
620 * ixgbe_obtain_mbx_lock_pf - obtain mailbox lock
621 * @hw: pointer to the HW structure
622 * @vf_number: the VF index
623 *
624 * return SUCCESS if we obtained the mailbox lock
625 **/
626 static s32 ixgbe_obtain_mbx_lock_pf(struct ixgbe_hw *hw, u16 vf_number)
627 {
628 s32 ret_val = IXGBE_ERR_MBX;
629 u32 p2v_mailbox;
630
631 DEBUGFUNC("ixgbe_obtain_mbx_lock_pf");
632
633 /* Take ownership of the buffer */
634 IXGBE_WRITE_REG(hw, IXGBE_PFMAILBOX(vf_number), IXGBE_PFMAILBOX_PFU);
635
636 /* reserve mailbox for vf use */
637 p2v_mailbox = IXGBE_READ_REG(hw, IXGBE_PFMAILBOX(vf_number));
638 if (p2v_mailbox & IXGBE_PFMAILBOX_PFU)
639 ret_val = IXGBE_SUCCESS;
640
641 return ret_val;
642 }
643
644 /**
645 * ixgbe_write_mbx_pf - Places a message in the mailbox
646 * @hw: pointer to the HW structure
647 * @msg: The message buffer
648 * @size: Length of buffer
649 * @vf_number: the VF index
650 *
651 * returns SUCCESS if it successfully copied message into the buffer
652 **/
653 static s32 ixgbe_write_mbx_pf(struct ixgbe_hw *hw, u32 *msg, u16 size,
654 u16 vf_number)
655 {
656 s32 ret_val;
657 u16 i;
658
659 DEBUGFUNC("ixgbe_write_mbx_pf");
660
661 /* lock the mailbox to prevent pf/vf race condition */
662 ret_val = ixgbe_obtain_mbx_lock_pf(hw, vf_number);
663 if (ret_val)
664 goto out_no_write;
665
666 /* flush msg and acks as we are overwriting the message buffer */
667 ret_val = ixgbe_check_for_msg_vf(hw, 0);
668 if (ret_val)
669 goto out_no_write;
670 ret_val = ixgbe_check_for_ack_vf(hw, 0);
671 if (ret_val)
672 goto out_no_write;
673
674 /* copy the caller specified message to the mailbox memory buffer */
675 for (i = 0; i < size; i++)
676 IXGBE_WRITE_REG_ARRAY(hw, IXGBE_PFMBMEM(vf_number), i, msg[i]);
677
678 /* Interrupt VF to tell it a message has been sent and release buffer*/
679 IXGBE_WRITE_REG(hw, IXGBE_PFMAILBOX(vf_number), IXGBE_PFMAILBOX_STS);
680
681 /* update stats */
682 hw->mbx.stats.msgs_tx++;
683
684 out_no_write:
685 return ret_val;
686
687 }
688
689 /**
690 * ixgbe_read_mbx_pf - Read a message from the mailbox
691 * @hw: pointer to the HW structure
692 * @msg: The message buffer
693 * @size: Length of buffer
694 * @vf_number: the VF index
695 *
696 * This function copies a message from the mailbox buffer to the caller's
697 * memory buffer. The presumption is that the caller knows that there was
698 * a message due to a VF request so no polling for message is needed.
699 **/
700 static s32 ixgbe_read_mbx_pf(struct ixgbe_hw *hw, u32 *msg, u16 size,
701 u16 vf_number)
702 {
703 s32 ret_val;
704 u16 i;
705
706 DEBUGFUNC("ixgbe_read_mbx_pf");
707
708 /* lock the mailbox to prevent pf/vf race condition */
709 ret_val = ixgbe_obtain_mbx_lock_pf(hw, vf_number);
710 if (ret_val)
711 goto out_no_read;
712
713 /* copy the message to the mailbox memory buffer */
714 for (i = 0; i < size; i++)
715 msg[i] = IXGBE_READ_REG_ARRAY(hw, IXGBE_PFMBMEM(vf_number), i);
716
717 /* Acknowledge the message and release buffer */
718 IXGBE_WRITE_REG(hw, IXGBE_PFMAILBOX(vf_number), IXGBE_PFMAILBOX_ACK);
719
720 /* update stats */
721 hw->mbx.stats.msgs_rx++;
722
723 out_no_read:
724 return ret_val;
725 }
726
727 /**
728 * ixgbe_init_mbx_params_pf - set initial values for pf mailbox
729 * @hw: pointer to the HW structure
730 *
731 * Initializes the hw->mbx struct to correct values for pf mailbox
732 */
733 void ixgbe_init_mbx_params_pf(struct ixgbe_hw *hw)
734 {
735 struct ixgbe_mbx_info *mbx = &hw->mbx;
736
737 if (hw->mac.type != ixgbe_mac_82599EB &&
738 hw->mac.type != ixgbe_mac_X540)
739 return;
740
741 mbx->timeout = 0;
742 mbx->usec_delay = 0;
743
744 mbx->size = IXGBE_VFMAILBOX_SIZE;
745
746 mbx->ops.read = ixgbe_read_mbx_pf;
747 mbx->ops.write = ixgbe_write_mbx_pf;
748 mbx->ops.read_posted = ixgbe_read_posted_mbx;
749 mbx->ops.write_posted = ixgbe_write_posted_mbx;
750 mbx->ops.check_for_msg = ixgbe_check_for_msg_pf;
751 mbx->ops.check_for_ack = ixgbe_check_for_ack_pf;
752 mbx->ops.check_for_rst = ixgbe_check_for_rst_pf;
753
754 mbx->stats.msgs_tx = 0;
755 mbx->stats.msgs_rx = 0;
756 mbx->stats.reqs = 0;
757 mbx->stats.acks = 0;
758 mbx->stats.rsts = 0;
759 }