1 /******************************************************************************
3 Copyright (c) 2001-2012, Intel Corporation
6 Redistribution and use in source and binary forms, with or without
7 modification, are permitted provided that the following conditions are met:
9 1. Redistributions of source code must retain the above copyright notice,
10 this list of conditions and the following disclaimer.
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.
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.
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.
32 ******************************************************************************/
35 #include "ixgbe_type.h"
36 #include "ixgbe_mbx.h"
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
45 * returns SUCCESS if it successfuly read message from buffer
47 s32 ixgbe_read_mbx(struct ixgbe_hw *hw, u32 *msg, u16 size, u16 mbx_id)
49 struct ixgbe_mbx_info *mbx = &hw->mbx;
50 s32 ret_val = IXGBE_ERR_MBX;
52 DEBUGFUNC("ixgbe_read_mbx");
54 /* limit read to size of mailbox */
59 ret_val = mbx->ops.read(hw, msg, size, mbx_id);
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
71 * returns SUCCESS if it successfully copied message into the buffer
73 s32 ixgbe_write_mbx(struct ixgbe_hw *hw, u32 *msg, u16 size, u16 mbx_id)
75 struct ixgbe_mbx_info *mbx = &hw->mbx;
76 s32 ret_val = IXGBE_SUCCESS;
78 DEBUGFUNC("ixgbe_write_mbx");
81 ret_val = IXGBE_ERR_MBX;
83 else if (mbx->ops.write)
84 ret_val = mbx->ops.write(hw, msg, size, mbx_id);
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
94 * returns SUCCESS if the Status bit was found or else ERR_MBX
96 s32 ixgbe_check_for_msg(struct ixgbe_hw *hw, u16 mbx_id)
98 struct ixgbe_mbx_info *mbx = &hw->mbx;
99 s32 ret_val = IXGBE_ERR_MBX;
101 DEBUGFUNC("ixgbe_check_for_msg");
103 if (mbx->ops.check_for_msg)
104 ret_val = mbx->ops.check_for_msg(hw, mbx_id);
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
114 * returns SUCCESS if the Status bit was found or else ERR_MBX
116 s32 ixgbe_check_for_ack(struct ixgbe_hw *hw, u16 mbx_id)
118 struct ixgbe_mbx_info *mbx = &hw->mbx;
119 s32 ret_val = IXGBE_ERR_MBX;
121 DEBUGFUNC("ixgbe_check_for_ack");
123 if (mbx->ops.check_for_ack)
124 ret_val = mbx->ops.check_for_ack(hw, mbx_id);
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
134 * returns SUCCESS if the Status bit was found or else ERR_MBX
136 s32 ixgbe_check_for_rst(struct ixgbe_hw *hw, u16 mbx_id)
138 struct ixgbe_mbx_info *mbx = &hw->mbx;
139 s32 ret_val = IXGBE_ERR_MBX;
141 DEBUGFUNC("ixgbe_check_for_rst");
143 if (mbx->ops.check_for_rst)
144 ret_val = mbx->ops.check_for_rst(hw, mbx_id);
150 * ixgbe_poll_for_msg - Wait for message notification
151 * @hw: pointer to the HW structure
152 * @mbx_id: id of mailbox to write
154 * returns SUCCESS if it successfully received a message notification
156 static s32 ixgbe_poll_for_msg(struct ixgbe_hw *hw, u16 mbx_id)
158 struct ixgbe_mbx_info *mbx = &hw->mbx;
159 int countdown = mbx->timeout;
161 DEBUGFUNC("ixgbe_poll_for_msg");
163 if (!countdown || !mbx->ops.check_for_msg)
166 while (countdown && mbx->ops.check_for_msg(hw, mbx_id)) {
170 usec_delay(mbx->usec_delay);
174 return countdown ? IXGBE_SUCCESS : IXGBE_ERR_MBX;
178 * ixgbe_poll_for_ack - Wait for message acknowledgement
179 * @hw: pointer to the HW structure
180 * @mbx_id: id of mailbox to write
182 * returns SUCCESS if it successfully received a message acknowledgement
184 static s32 ixgbe_poll_for_ack(struct ixgbe_hw *hw, u16 mbx_id)
186 struct ixgbe_mbx_info *mbx = &hw->mbx;
187 int countdown = mbx->timeout;
189 DEBUGFUNC("ixgbe_poll_for_ack");
191 if (!countdown || !mbx->ops.check_for_ack)
194 while (countdown && mbx->ops.check_for_ack(hw, mbx_id)) {
198 usec_delay(mbx->usec_delay);
202 return countdown ? IXGBE_SUCCESS : IXGBE_ERR_MBX;
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
212 * returns SUCCESS if it successfully received a message notification and
213 * copied it into the receive buffer.
215 s32 ixgbe_read_posted_mbx(struct ixgbe_hw *hw, u32 *msg, u16 size, u16 mbx_id)
217 struct ixgbe_mbx_info *mbx = &hw->mbx;
218 s32 ret_val = IXGBE_ERR_MBX;
220 DEBUGFUNC("ixgbe_read_posted_mbx");
225 ret_val = ixgbe_poll_for_msg(hw, mbx_id);
227 /* if ack received read message, otherwise we timed out */
229 ret_val = mbx->ops.read(hw, msg, size, mbx_id);
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
241 * returns SUCCESS if it successfully copied message into the buffer and
242 * received an ack to that message within delay * timeout period
244 s32 ixgbe_write_posted_mbx(struct ixgbe_hw *hw, u32 *msg, u16 size,
247 struct ixgbe_mbx_info *mbx = &hw->mbx;
248 s32 ret_val = IXGBE_ERR_MBX;
250 DEBUGFUNC("ixgbe_write_posted_mbx");
252 /* exit if either we can't write or there isn't a defined timeout */
253 if (!mbx->ops.write || !mbx->timeout)
257 ret_val = mbx->ops.write(hw, msg, size, mbx_id);
259 /* if msg sent wait until we receive an ack */
261 ret_val = ixgbe_poll_for_ack(hw, mbx_id);
267 * ixgbe_init_mbx_ops_generic - Initialize MB function pointers
268 * @hw: pointer to the HW structure
270 * Setups up the mailbox read and write message function pointers
272 void ixgbe_init_mbx_ops_generic(struct ixgbe_hw *hw)
274 struct ixgbe_mbx_info *mbx = &hw->mbx;
276 mbx->ops.read_posted = ixgbe_read_posted_mbx;
277 mbx->ops.write_posted = ixgbe_write_posted_mbx;
281 * ixgbe_read_v2p_mailbox - read v2p mailbox
282 * @hw: pointer to the HW structure
284 * This function is used to read the v2p mailbox without losing the read to
287 static u32 ixgbe_read_v2p_mailbox(struct ixgbe_hw *hw)
289 u32 v2p_mailbox = IXGBE_READ_REG(hw, IXGBE_VFMAILBOX);
291 v2p_mailbox |= hw->mbx.v2p_mailbox;
292 hw->mbx.v2p_mailbox |= v2p_mailbox & IXGBE_VFMAILBOX_R2C_BITS;
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
302 * This function is used to check for the read to clear bits within
305 static s32 ixgbe_check_for_bit_vf(struct ixgbe_hw *hw, u32 mask)
307 u32 v2p_mailbox = ixgbe_read_v2p_mailbox(hw);
308 s32 ret_val = IXGBE_ERR_MBX;
310 if (v2p_mailbox & mask)
311 ret_val = IXGBE_SUCCESS;
313 hw->mbx.v2p_mailbox &= ~mask;
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
323 * returns SUCCESS if the PF has set the Status bit or else ERR_MBX
325 static s32 ixgbe_check_for_msg_vf(struct ixgbe_hw *hw, u16 mbx_id)
327 s32 ret_val = IXGBE_ERR_MBX;
329 UNREFERENCED_1PARAMETER(mbx_id);
330 DEBUGFUNC("ixgbe_check_for_msg_vf");
332 if (!ixgbe_check_for_bit_vf(hw, IXGBE_VFMAILBOX_PFSTS)) {
333 ret_val = IXGBE_SUCCESS;
334 hw->mbx.stats.reqs++;
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
345 * returns SUCCESS if the PF has set the ACK bit or else ERR_MBX
347 static s32 ixgbe_check_for_ack_vf(struct ixgbe_hw *hw, u16 mbx_id)
349 s32 ret_val = IXGBE_ERR_MBX;
351 UNREFERENCED_1PARAMETER(mbx_id);
352 DEBUGFUNC("ixgbe_check_for_ack_vf");
354 if (!ixgbe_check_for_bit_vf(hw, IXGBE_VFMAILBOX_PFACK)) {
355 ret_val = IXGBE_SUCCESS;
356 hw->mbx.stats.acks++;
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
367 * returns TRUE if the PF has set the reset done bit or else FALSE
369 static s32 ixgbe_check_for_rst_vf(struct ixgbe_hw *hw, u16 mbx_id)
371 s32 ret_val = IXGBE_ERR_MBX;
373 UNREFERENCED_1PARAMETER(mbx_id);
374 DEBUGFUNC("ixgbe_check_for_rst_vf");
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++;
386 * ixgbe_obtain_mbx_lock_vf - obtain mailbox lock
387 * @hw: pointer to the HW structure
389 * return SUCCESS if we obtained the mailbox lock
391 static s32 ixgbe_obtain_mbx_lock_vf(struct ixgbe_hw *hw)
393 s32 ret_val = IXGBE_ERR_MBX;
395 DEBUGFUNC("ixgbe_obtain_mbx_lock_vf");
397 /* Take ownership of the buffer */
398 IXGBE_WRITE_REG(hw, IXGBE_VFMAILBOX, IXGBE_VFMAILBOX_VFU);
400 /* reserve mailbox for vf use */
401 if (ixgbe_read_v2p_mailbox(hw) & IXGBE_VFMAILBOX_VFU)
402 ret_val = IXGBE_SUCCESS;
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
414 * returns SUCCESS if it successfully copied message into the buffer
416 static s32 ixgbe_write_mbx_vf(struct ixgbe_hw *hw, u32 *msg, u16 size,
422 UNREFERENCED_1PARAMETER(mbx_id);
424 DEBUGFUNC("ixgbe_write_mbx_vf");
426 /* lock the mailbox to prevent pf/vf race condition */
427 ret_val = ixgbe_obtain_mbx_lock_vf(hw);
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);
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]);
440 hw->mbx.stats.msgs_tx++;
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);
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
456 * returns SUCCESS if it successfuly read message from buffer
458 static s32 ixgbe_read_mbx_vf(struct ixgbe_hw *hw, u32 *msg, u16 size,
461 s32 ret_val = IXGBE_SUCCESS;
464 DEBUGFUNC("ixgbe_read_mbx_vf");
465 UNREFERENCED_1PARAMETER(mbx_id);
467 /* lock the mailbox to prevent pf/vf race condition */
468 ret_val = ixgbe_obtain_mbx_lock_vf(hw);
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);
476 /* Acknowledge receipt and release mailbox, then we're done */
477 IXGBE_WRITE_REG(hw, IXGBE_VFMAILBOX, IXGBE_VFMAILBOX_ACK);
480 hw->mbx.stats.msgs_rx++;
487 * ixgbe_init_mbx_params_vf - set initial values for vf mailbox
488 * @hw: pointer to the HW structure
490 * Initializes the hw->mbx struct to correct values for vf mailbox
492 void ixgbe_init_mbx_params_vf(struct ixgbe_hw *hw)
494 struct ixgbe_mbx_info *mbx = &hw->mbx;
496 /* start mailbox as timed out and let the reset_hw call set the timeout
497 * value to begin communications */
499 mbx->usec_delay = IXGBE_VF_MBX_INIT_DELAY;
501 mbx->size = IXGBE_VFMAILBOX_SIZE;
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;
511 mbx->stats.msgs_tx = 0;
512 mbx->stats.msgs_rx = 0;
518 static s32 ixgbe_check_for_bit_pf(struct ixgbe_hw *hw, u32 mask, s32 index)
520 u32 mbvficr = IXGBE_READ_REG(hw, IXGBE_MBVFICR(index));
521 s32 ret_val = IXGBE_ERR_MBX;
523 if (mbvficr & mask) {
524 ret_val = IXGBE_SUCCESS;
525 IXGBE_WRITE_REG(hw, IXGBE_MBVFICR(index), mask);
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
536 * returns SUCCESS if the VF has set the Status bit or else ERR_MBX
538 static s32 ixgbe_check_for_msg_pf(struct ixgbe_hw *hw, u16 vf_number)
540 s32 ret_val = IXGBE_ERR_MBX;
541 s32 index = IXGBE_MBVFICR_INDEX(vf_number);
542 u32 vf_bit = vf_number % 16;
544 DEBUGFUNC("ixgbe_check_for_msg_pf");
546 if (!ixgbe_check_for_bit_pf(hw, IXGBE_MBVFICR_VFREQ_VF1 << vf_bit,
548 ret_val = IXGBE_SUCCESS;
549 hw->mbx.stats.reqs++;
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
560 * returns SUCCESS if the VF has set the Status bit or else ERR_MBX
562 static s32 ixgbe_check_for_ack_pf(struct ixgbe_hw *hw, u16 vf_number)
564 s32 ret_val = IXGBE_ERR_MBX;
565 s32 index = IXGBE_MBVFICR_INDEX(vf_number);
566 u32 vf_bit = vf_number % 16;
568 DEBUGFUNC("ixgbe_check_for_ack_pf");
570 if (!ixgbe_check_for_bit_pf(hw, IXGBE_MBVFICR_VFACK_VF1 << vf_bit,
572 ret_val = IXGBE_SUCCESS;
573 hw->mbx.stats.acks++;
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
584 * returns SUCCESS if the VF has set the Status bit or else ERR_MBX
586 static s32 ixgbe_check_for_rst_pf(struct ixgbe_hw *hw, u16 vf_number)
588 u32 reg_offset = (vf_number < 32) ? 0 : 1;
589 u32 vf_shift = vf_number % 32;
591 s32 ret_val = IXGBE_ERR_MBX;
593 DEBUGFUNC("ixgbe_check_for_rst_pf");
595 switch (hw->mac.type) {
596 case ixgbe_mac_82599EB:
597 vflre = IXGBE_READ_REG(hw, IXGBE_VFLRE(reg_offset));
600 vflre = IXGBE_READ_REG(hw, IXGBE_VFLREC(reg_offset));
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++;
616 * ixgbe_obtain_mbx_lock_pf - obtain mailbox lock
617 * @hw: pointer to the HW structure
618 * @vf_number: the VF index
620 * return SUCCESS if we obtained the mailbox lock
622 static s32 ixgbe_obtain_mbx_lock_pf(struct ixgbe_hw *hw, u16 vf_number)
624 s32 ret_val = IXGBE_ERR_MBX;
627 DEBUGFUNC("ixgbe_obtain_mbx_lock_pf");
629 /* Take ownership of the buffer */
630 IXGBE_WRITE_REG(hw, IXGBE_PFMAILBOX(vf_number), IXGBE_PFMAILBOX_PFU);
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;
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
647 * returns SUCCESS if it successfully copied message into the buffer
649 static s32 ixgbe_write_mbx_pf(struct ixgbe_hw *hw, u32 *msg, u16 size,
655 DEBUGFUNC("ixgbe_write_mbx_pf");
657 /* lock the mailbox to prevent pf/vf race condition */
658 ret_val = ixgbe_obtain_mbx_lock_pf(hw, vf_number);
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);
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]);
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);
674 hw->mbx.stats.msgs_tx++;
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
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.
692 static s32 ixgbe_read_mbx_pf(struct ixgbe_hw *hw, u32 *msg, u16 size,
698 DEBUGFUNC("ixgbe_read_mbx_pf");
700 /* lock the mailbox to prevent pf/vf race condition */
701 ret_val = ixgbe_obtain_mbx_lock_pf(hw, vf_number);
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);
709 /* Acknowledge the message and release buffer */
710 IXGBE_WRITE_REG(hw, IXGBE_PFMAILBOX(vf_number), IXGBE_PFMAILBOX_ACK);
713 hw->mbx.stats.msgs_rx++;
720 * ixgbe_init_mbx_params_pf - set initial values for pf mailbox
721 * @hw: pointer to the HW structure
723 * Initializes the hw->mbx struct to correct values for pf mailbox
725 void ixgbe_init_mbx_params_pf(struct ixgbe_hw *hw)
727 struct ixgbe_mbx_info *mbx = &hw->mbx;
729 if (hw->mac.type != ixgbe_mac_82599EB &&
730 hw->mac.type != ixgbe_mac_X540)
736 mbx->size = IXGBE_VFMAILBOX_SIZE;
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;
746 mbx->stats.msgs_tx = 0;
747 mbx->stats.msgs_rx = 0;