1 /******************************************************************************
2
3 Copyright (c) 2001-2010, 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: releng/9.0/sys/dev/ixgbe/ixgbe_mbx.c 217593 2011-01-19 19:36:27Z jfv $*/
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_PARAMETER(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_PARAMETER(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_PARAMETER(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_PARAMETER(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_PARAMETER(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 default:
600 goto out;
601 break;
602 }
603
604 if (vflre & (1 << vf_shift)) {
605 ret_val = IXGBE_SUCCESS;
606 IXGBE_WRITE_REG(hw, IXGBE_VFLREC(reg_offset), (1 << vf_shift));
607 hw->mbx.stats.rsts++;
608 }
609
610 out:
611 return ret_val;
612 }
613
614 /**
615 * ixgbe_obtain_mbx_lock_pf - obtain mailbox lock
616 * @hw: pointer to the HW structure
617 * @vf_number: the VF index
618 *
619 * return SUCCESS if we obtained the mailbox lock
620 **/
621 static s32 ixgbe_obtain_mbx_lock_pf(struct ixgbe_hw *hw, u16 vf_number)
622 {
623 s32 ret_val = IXGBE_ERR_MBX;
624 u32 p2v_mailbox;
625
626 DEBUGFUNC("ixgbe_obtain_mbx_lock_pf");
627
628 /* Take ownership of the buffer */
629 IXGBE_WRITE_REG(hw, IXGBE_PFMAILBOX(vf_number), IXGBE_PFMAILBOX_PFU);
630
631 /* reserve mailbox for vf use */
632 p2v_mailbox = IXGBE_READ_REG(hw, IXGBE_PFMAILBOX(vf_number));
633 if (p2v_mailbox & IXGBE_PFMAILBOX_PFU)
634 ret_val = IXGBE_SUCCESS;
635
636 return ret_val;
637 }
638
639 /**
640 * ixgbe_write_mbx_pf - Places a message in the mailbox
641 * @hw: pointer to the HW structure
642 * @msg: The message buffer
643 * @size: Length of buffer
644 * @vf_number: the VF index
645 *
646 * returns SUCCESS if it successfully copied message into the buffer
647 **/
648 static s32 ixgbe_write_mbx_pf(struct ixgbe_hw *hw, u32 *msg, u16 size,
649 u16 vf_number)
650 {
651 s32 ret_val;
652 u16 i;
653
654 DEBUGFUNC("ixgbe_write_mbx_pf");
655
656 /* lock the mailbox to prevent pf/vf race condition */
657 ret_val = ixgbe_obtain_mbx_lock_pf(hw, vf_number);
658 if (ret_val)
659 goto out_no_write;
660
661 /* flush msg and acks as we are overwriting the message buffer */
662 ixgbe_check_for_msg_pf(hw, vf_number);
663 ixgbe_check_for_ack_pf(hw, vf_number);
664
665 /* copy the caller specified message to the mailbox memory buffer */
666 for (i = 0; i < size; i++)
667 IXGBE_WRITE_REG_ARRAY(hw, IXGBE_PFMBMEM(vf_number), i, msg[i]);
668
669 /* Interrupt VF to tell it a message has been sent and release buffer*/
670 IXGBE_WRITE_REG(hw, IXGBE_PFMAILBOX(vf_number), IXGBE_PFMAILBOX_STS);
671
672 /* update stats */
673 hw->mbx.stats.msgs_tx++;
674
675 out_no_write:
676 return ret_val;
677
678 }
679
680 /**
681 * ixgbe_read_mbx_pf - Read a message from the mailbox
682 * @hw: pointer to the HW structure
683 * @msg: The message buffer
684 * @size: Length of buffer
685 * @vf_number: the VF index
686 *
687 * This function copies a message from the mailbox buffer to the caller's
688 * memory buffer. The presumption is that the caller knows that there was
689 * a message due to a VF request so no polling for message is needed.
690 **/
691 static s32 ixgbe_read_mbx_pf(struct ixgbe_hw *hw, u32 *msg, u16 size,
692 u16 vf_number)
693 {
694 s32 ret_val;
695 u16 i;
696
697 DEBUGFUNC("ixgbe_read_mbx_pf");
698
699 /* lock the mailbox to prevent pf/vf race condition */
700 ret_val = ixgbe_obtain_mbx_lock_pf(hw, vf_number);
701 if (ret_val)
702 goto out_no_read;
703
704 /* copy the message to the mailbox memory buffer */
705 for (i = 0; i < size; i++)
706 msg[i] = IXGBE_READ_REG_ARRAY(hw, IXGBE_PFMBMEM(vf_number), i);
707
708 /* Acknowledge the message and release buffer */
709 IXGBE_WRITE_REG(hw, IXGBE_PFMAILBOX(vf_number), IXGBE_PFMAILBOX_ACK);
710
711 /* update stats */
712 hw->mbx.stats.msgs_rx++;
713
714 out_no_read:
715 return ret_val;
716 }
717
718 /**
719 * ixgbe_init_mbx_params_pf - set initial values for pf mailbox
720 * @hw: pointer to the HW structure
721 *
722 * Initializes the hw->mbx struct to correct values for pf mailbox
723 */
724 void ixgbe_init_mbx_params_pf(struct ixgbe_hw *hw)
725 {
726 struct ixgbe_mbx_info *mbx = &hw->mbx;
727
728 if (hw->mac.type != ixgbe_mac_82599EB)
729 return;
730
731 mbx->timeout = 0;
732 mbx->usec_delay = 0;
733
734 mbx->size = IXGBE_VFMAILBOX_SIZE;
735
736 mbx->ops.read = ixgbe_read_mbx_pf;
737 mbx->ops.write = ixgbe_write_mbx_pf;
738 mbx->ops.read_posted = ixgbe_read_posted_mbx;
739 mbx->ops.write_posted = ixgbe_write_posted_mbx;
740 mbx->ops.check_for_msg = ixgbe_check_for_msg_pf;
741 mbx->ops.check_for_ack = ixgbe_check_for_ack_pf;
742 mbx->ops.check_for_rst = ixgbe_check_for_rst_pf;
743
744 mbx->stats.msgs_tx = 0;
745 mbx->stats.msgs_rx = 0;
746 mbx->stats.reqs = 0;
747 mbx->stats.acks = 0;
748 mbx->stats.rsts = 0;
749 }
750
Cache object: 1357e4989cec492fd699668caa4fb40d
|