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 ***************************************************************************/
34 #include "ixgbe_type.h"
35 #include "ixgbe_mbx.h"
38 * ixgbe_read_mbx - Reads a message from the mailbox
39 * @hw: pointer to the HW structure
40 * @msg: The message buffer
41 * @size: Length of buffer
42 * @mbx_id: id of mailbox to read
44 * returns SUCCESS if it successfuly read message from buffer
46 s32 ixgbe_read_mbx(struct ixgbe_hw *hw, u32 *msg, u16 size, u16 mbx_id)
48 struct ixgbe_mbx_info *mbx = &hw->mbx;
49 s32 ret_val = IXGBE_ERR_MBX;
51 DEBUGFUNC("ixgbe_read_mbx");
53 /* limit read to size of mailbox */
58 ret_val = mbx->ops.read(hw, msg, size, mbx_id);
64 * ixgbe_write_mbx - Write a message to the mailbox
65 * @hw: pointer to the HW structure
66 * @msg: The message buffer
67 * @size: Length of buffer
68 * @mbx_id: id of mailbox to write
70 * returns SUCCESS if it successfully copied message into the buffer
72 s32 ixgbe_write_mbx(struct ixgbe_hw *hw, u32 *msg, u16 size, u16 mbx_id)
74 struct ixgbe_mbx_info *mbx = &hw->mbx;
75 s32 ret_val = IXGBE_SUCCESS;
77 DEBUGFUNC("ixgbe_write_mbx");
80 ret_val = IXGBE_ERR_MBX;
82 else if (mbx->ops.write)
83 ret_val = mbx->ops.write(hw, msg, size, mbx_id);
89 * ixgbe_check_for_msg - checks to see if someone sent us mail
90 * @hw: pointer to the HW structure
91 * @mbx_id: id of mailbox to check
93 * returns SUCCESS if the Status bit was found or else ERR_MBX
95 s32 ixgbe_check_for_msg(struct ixgbe_hw *hw, u16 mbx_id)
97 struct ixgbe_mbx_info *mbx = &hw->mbx;
98 s32 ret_val = IXGBE_ERR_MBX;
100 DEBUGFUNC("ixgbe_check_for_msg");
102 if (mbx->ops.check_for_msg)
103 ret_val = mbx->ops.check_for_msg(hw, mbx_id);
109 * ixgbe_check_for_ack - checks to see if someone sent us ACK
110 * @hw: pointer to the HW structure
111 * @mbx_id: id of mailbox to check
113 * returns SUCCESS if the Status bit was found or else ERR_MBX
115 s32 ixgbe_check_for_ack(struct ixgbe_hw *hw, u16 mbx_id)
117 struct ixgbe_mbx_info *mbx = &hw->mbx;
118 s32 ret_val = IXGBE_ERR_MBX;
120 DEBUGFUNC("ixgbe_check_for_ack");
122 if (mbx->ops.check_for_ack)
123 ret_val = mbx->ops.check_for_ack(hw, mbx_id);
129 * ixgbe_check_for_rst - checks to see if other side has reset
130 * @hw: pointer to the HW structure
131 * @mbx_id: id of mailbox to check
133 * returns SUCCESS if the Status bit was found or else ERR_MBX
135 s32 ixgbe_check_for_rst(struct ixgbe_hw *hw, u16 mbx_id)
137 struct ixgbe_mbx_info *mbx = &hw->mbx;
138 s32 ret_val = IXGBE_ERR_MBX;
140 DEBUGFUNC("ixgbe_check_for_rst");
142 if (mbx->ops.check_for_rst)
143 ret_val = mbx->ops.check_for_rst(hw, mbx_id);
149 * ixgbe_poll_for_msg - Wait for message notification
150 * @hw: pointer to the HW structure
151 * @mbx_id: id of mailbox to write
153 * returns SUCCESS if it successfully received a message notification
155 STATIC s32 ixgbe_poll_for_msg(struct ixgbe_hw *hw, u16 mbx_id)
157 struct ixgbe_mbx_info *mbx = &hw->mbx;
158 int countdown = mbx->timeout;
160 DEBUGFUNC("ixgbe_poll_for_msg");
162 if (!countdown || !mbx->ops.check_for_msg)
165 while (countdown && mbx->ops.check_for_msg(hw, mbx_id)) {
169 usec_delay(mbx->usec_delay);
173 return countdown ? IXGBE_SUCCESS : IXGBE_ERR_MBX;
177 * ixgbe_poll_for_ack - Wait for message acknowledgement
178 * @hw: pointer to the HW structure
179 * @mbx_id: id of mailbox to write
181 * returns SUCCESS if it successfully received a message acknowledgement
183 STATIC s32 ixgbe_poll_for_ack(struct ixgbe_hw *hw, u16 mbx_id)
185 struct ixgbe_mbx_info *mbx = &hw->mbx;
186 int countdown = mbx->timeout;
188 DEBUGFUNC("ixgbe_poll_for_ack");
190 if (!countdown || !mbx->ops.check_for_ack)
193 while (countdown && mbx->ops.check_for_ack(hw, mbx_id)) {
197 usec_delay(mbx->usec_delay);
201 return countdown ? IXGBE_SUCCESS : IXGBE_ERR_MBX;
205 * ixgbe_read_posted_mbx - Wait for message notification and receive message
206 * @hw: pointer to the HW structure
207 * @msg: The message buffer
208 * @size: Length of buffer
209 * @mbx_id: id of mailbox to write
211 * returns SUCCESS if it successfully received a message notification and
212 * copied it into the receive buffer.
214 s32 ixgbe_read_posted_mbx(struct ixgbe_hw *hw, u32 *msg, u16 size, u16 mbx_id)
216 struct ixgbe_mbx_info *mbx = &hw->mbx;
217 s32 ret_val = IXGBE_ERR_MBX;
219 DEBUGFUNC("ixgbe_read_posted_mbx");
224 ret_val = ixgbe_poll_for_msg(hw, mbx_id);
226 /* if ack received read message, otherwise we timed out */
228 ret_val = mbx->ops.read(hw, msg, size, mbx_id);
234 * ixgbe_write_posted_mbx - Write a message to the mailbox, wait for ack
235 * @hw: pointer to the HW structure
236 * @msg: The message buffer
237 * @size: Length of buffer
238 * @mbx_id: id of mailbox to write
240 * returns SUCCESS if it successfully copied message into the buffer and
241 * received an ack to that message within delay * timeout period
243 s32 ixgbe_write_posted_mbx(struct ixgbe_hw *hw, u32 *msg, u16 size,
246 struct ixgbe_mbx_info *mbx = &hw->mbx;
247 s32 ret_val = IXGBE_ERR_MBX;
249 DEBUGFUNC("ixgbe_write_posted_mbx");
251 /* exit if either we can't write or there isn't a defined timeout */
252 if (!mbx->ops.write || !mbx->timeout)
256 ret_val = mbx->ops.write(hw, msg, size, mbx_id);
258 /* if msg sent wait until we receive an ack */
260 ret_val = ixgbe_poll_for_ack(hw, mbx_id);
266 * ixgbe_init_mbx_ops_generic - Initialize MB function pointers
267 * @hw: pointer to the HW structure
269 * Setups up the mailbox read and write message function pointers
271 void ixgbe_init_mbx_ops_generic(struct ixgbe_hw *hw)
273 struct ixgbe_mbx_info *mbx = &hw->mbx;
275 mbx->ops.read_posted = ixgbe_read_posted_mbx;
276 mbx->ops.write_posted = ixgbe_write_posted_mbx;
280 * ixgbe_read_v2p_mailbox - read v2p mailbox
281 * @hw: pointer to the HW structure
283 * This function is used to read the v2p mailbox without losing the read to
286 STATIC u32 ixgbe_read_v2p_mailbox(struct ixgbe_hw *hw)
288 u32 v2p_mailbox = IXGBE_READ_REG(hw, IXGBE_VFMAILBOX);
290 v2p_mailbox |= hw->mbx.v2p_mailbox;
291 hw->mbx.v2p_mailbox |= v2p_mailbox & IXGBE_VFMAILBOX_R2C_BITS;
297 * ixgbe_check_for_bit_vf - Determine if a status bit was set
298 * @hw: pointer to the HW structure
299 * @mask: bitmask for bits to be tested and cleared
301 * This function is used to check for the read to clear bits within
304 STATIC s32 ixgbe_check_for_bit_vf(struct ixgbe_hw *hw, u32 mask)
306 u32 v2p_mailbox = ixgbe_read_v2p_mailbox(hw);
307 s32 ret_val = IXGBE_ERR_MBX;
309 if (v2p_mailbox & mask)
310 ret_val = IXGBE_SUCCESS;
312 hw->mbx.v2p_mailbox &= ~mask;
318 * ixgbe_check_for_msg_vf - checks to see if the PF has sent mail
319 * @hw: pointer to the HW structure
320 * @mbx_id: id of mailbox to check
322 * returns SUCCESS if the PF has set the Status bit or else ERR_MBX
324 STATIC s32 ixgbe_check_for_msg_vf(struct ixgbe_hw *hw, u16 mbx_id)
326 s32 ret_val = IXGBE_ERR_MBX;
328 UNREFERENCED_1PARAMETER(mbx_id);
329 DEBUGFUNC("ixgbe_check_for_msg_vf");
331 if (!ixgbe_check_for_bit_vf(hw, IXGBE_VFMAILBOX_PFSTS)) {
332 ret_val = IXGBE_SUCCESS;
333 hw->mbx.stats.reqs++;
340 * ixgbe_check_for_ack_vf - checks to see if the PF has ACK'd
341 * @hw: pointer to the HW structure
342 * @mbx_id: id of mailbox to check
344 * returns SUCCESS if the PF has set the ACK bit or else ERR_MBX
346 STATIC s32 ixgbe_check_for_ack_vf(struct ixgbe_hw *hw, u16 mbx_id)
348 s32 ret_val = IXGBE_ERR_MBX;
350 UNREFERENCED_1PARAMETER(mbx_id);
351 DEBUGFUNC("ixgbe_check_for_ack_vf");
353 if (!ixgbe_check_for_bit_vf(hw, IXGBE_VFMAILBOX_PFACK)) {
354 ret_val = IXGBE_SUCCESS;
355 hw->mbx.stats.acks++;
362 * ixgbe_check_for_rst_vf - checks to see if the PF has reset
363 * @hw: pointer to the HW structure
364 * @mbx_id: id of mailbox to check
366 * returns true if the PF has set the reset done bit or else false
368 STATIC s32 ixgbe_check_for_rst_vf(struct ixgbe_hw *hw, u16 mbx_id)
370 s32 ret_val = IXGBE_ERR_MBX;
372 UNREFERENCED_1PARAMETER(mbx_id);
373 DEBUGFUNC("ixgbe_check_for_rst_vf");
375 if (!ixgbe_check_for_bit_vf(hw, (IXGBE_VFMAILBOX_RSTD |
376 IXGBE_VFMAILBOX_RSTI))) {
377 ret_val = IXGBE_SUCCESS;
378 hw->mbx.stats.rsts++;
385 * ixgbe_obtain_mbx_lock_vf - obtain mailbox lock
386 * @hw: pointer to the HW structure
388 * return SUCCESS if we obtained the mailbox lock
390 STATIC s32 ixgbe_obtain_mbx_lock_vf(struct ixgbe_hw *hw)
392 s32 ret_val = IXGBE_ERR_MBX;
394 DEBUGFUNC("ixgbe_obtain_mbx_lock_vf");
396 /* Take ownership of the buffer */
397 IXGBE_WRITE_REG(hw, IXGBE_VFMAILBOX, IXGBE_VFMAILBOX_VFU);
399 /* reserve mailbox for vf use */
400 if (ixgbe_read_v2p_mailbox(hw) & IXGBE_VFMAILBOX_VFU)
401 ret_val = IXGBE_SUCCESS;
407 * ixgbe_write_mbx_vf - Write a message to the mailbox
408 * @hw: pointer to the HW structure
409 * @msg: The message buffer
410 * @size: Length of buffer
411 * @mbx_id: id of mailbox to write
413 * returns SUCCESS if it successfully copied message into the buffer
415 STATIC s32 ixgbe_write_mbx_vf(struct ixgbe_hw *hw, u32 *msg, u16 size,
421 UNREFERENCED_1PARAMETER(mbx_id);
423 DEBUGFUNC("ixgbe_write_mbx_vf");
425 /* lock the mailbox to prevent pf/vf race condition */
426 ret_val = ixgbe_obtain_mbx_lock_vf(hw);
430 /* flush msg and acks as we are overwriting the message buffer */
431 ixgbe_check_for_msg_vf(hw, 0);
432 ixgbe_check_for_ack_vf(hw, 0);
434 /* copy the caller specified message to the mailbox memory buffer */
435 for (i = 0; i < size; i++)
436 IXGBE_WRITE_REG_ARRAY(hw, IXGBE_VFMBMEM, i, msg[i]);
439 hw->mbx.stats.msgs_tx++;
441 /* Drop VFU and interrupt the PF to tell it a message has been sent */
442 IXGBE_WRITE_REG(hw, IXGBE_VFMAILBOX, IXGBE_VFMAILBOX_REQ);
449 * ixgbe_read_mbx_vf - Reads a message from the inbox intended for vf
450 * @hw: pointer to the HW structure
451 * @msg: The message buffer
452 * @size: Length of buffer
453 * @mbx_id: id of mailbox to read
455 * returns SUCCESS if it successfuly read message from buffer
457 STATIC s32 ixgbe_read_mbx_vf(struct ixgbe_hw *hw, u32 *msg, u16 size,
460 s32 ret_val = IXGBE_SUCCESS;
463 DEBUGFUNC("ixgbe_read_mbx_vf");
464 UNREFERENCED_1PARAMETER(mbx_id);
466 /* lock the mailbox to prevent pf/vf race condition */
467 ret_val = ixgbe_obtain_mbx_lock_vf(hw);
471 /* copy the message from the mailbox memory buffer */
472 for (i = 0; i < size; i++)
473 msg[i] = IXGBE_READ_REG_ARRAY(hw, IXGBE_VFMBMEM, i);
475 /* Acknowledge receipt and release mailbox, then we're done */
476 IXGBE_WRITE_REG(hw, IXGBE_VFMAILBOX, IXGBE_VFMAILBOX_ACK);
479 hw->mbx.stats.msgs_rx++;
486 * ixgbe_init_mbx_params_vf - set initial values for vf mailbox
487 * @hw: pointer to the HW structure
489 * Initializes the hw->mbx struct to correct values for vf mailbox
491 void ixgbe_init_mbx_params_vf(struct ixgbe_hw *hw)
493 struct ixgbe_mbx_info *mbx = &hw->mbx;
495 /* start mailbox as timed out and let the reset_hw call set the timeout
496 * value to begin communications */
498 mbx->usec_delay = IXGBE_VF_MBX_INIT_DELAY;
500 mbx->size = IXGBE_VFMAILBOX_SIZE;
502 mbx->ops.read = ixgbe_read_mbx_vf;
503 mbx->ops.write = ixgbe_write_mbx_vf;
504 mbx->ops.read_posted = ixgbe_read_posted_mbx;
505 mbx->ops.write_posted = ixgbe_write_posted_mbx;
506 mbx->ops.check_for_msg = ixgbe_check_for_msg_vf;
507 mbx->ops.check_for_ack = ixgbe_check_for_ack_vf;
508 mbx->ops.check_for_rst = ixgbe_check_for_rst_vf;
510 mbx->stats.msgs_tx = 0;
511 mbx->stats.msgs_rx = 0;
517 STATIC s32 ixgbe_check_for_bit_pf(struct ixgbe_hw *hw, u32 mask, s32 index)
519 u32 mbvficr = IXGBE_READ_REG(hw, IXGBE_MBVFICR(index));
520 s32 ret_val = IXGBE_ERR_MBX;
522 if (mbvficr & mask) {
523 ret_val = IXGBE_SUCCESS;
524 IXGBE_WRITE_REG(hw, IXGBE_MBVFICR(index), mask);
531 * ixgbe_check_for_msg_pf - checks to see if the VF has sent mail
532 * @hw: pointer to the HW structure
533 * @vf_number: the VF index
535 * returns SUCCESS if the VF has set the Status bit or else ERR_MBX
537 STATIC s32 ixgbe_check_for_msg_pf(struct ixgbe_hw *hw, u16 vf_number)
539 s32 ret_val = IXGBE_ERR_MBX;
540 s32 index = IXGBE_MBVFICR_INDEX(vf_number);
541 u32 vf_bit = vf_number % 16;
543 DEBUGFUNC("ixgbe_check_for_msg_pf");
545 if (!ixgbe_check_for_bit_pf(hw, IXGBE_MBVFICR_VFREQ_VF1 << vf_bit,
547 ret_val = IXGBE_SUCCESS;
548 hw->mbx.stats.reqs++;
555 * ixgbe_check_for_ack_pf - checks to see if the VF has ACKed
556 * @hw: pointer to the HW structure
557 * @vf_number: the VF index
559 * returns SUCCESS if the VF has set the Status bit or else ERR_MBX
561 STATIC s32 ixgbe_check_for_ack_pf(struct ixgbe_hw *hw, u16 vf_number)
563 s32 ret_val = IXGBE_ERR_MBX;
564 s32 index = IXGBE_MBVFICR_INDEX(vf_number);
565 u32 vf_bit = vf_number % 16;
567 DEBUGFUNC("ixgbe_check_for_ack_pf");
569 if (!ixgbe_check_for_bit_pf(hw, IXGBE_MBVFICR_VFACK_VF1 << vf_bit,
571 ret_val = IXGBE_SUCCESS;
572 hw->mbx.stats.acks++;
579 * ixgbe_check_for_rst_pf - checks to see if the VF has reset
580 * @hw: pointer to the HW structure
581 * @vf_number: the VF index
583 * returns SUCCESS if the VF has set the Status bit or else ERR_MBX
585 STATIC s32 ixgbe_check_for_rst_pf(struct ixgbe_hw *hw, u16 vf_number)
587 u32 reg_offset = (vf_number < 32) ? 0 : 1;
588 u32 vf_shift = vf_number % 32;
590 s32 ret_val = IXGBE_ERR_MBX;
592 DEBUGFUNC("ixgbe_check_for_rst_pf");
594 switch (hw->mac.type) {
595 case ixgbe_mac_82599EB:
596 vflre = IXGBE_READ_REG(hw, IXGBE_VFLRE(reg_offset));
599 vflre = IXGBE_READ_REG(hw, IXGBE_VFLREC(reg_offset));
605 if (vflre & (1 << vf_shift)) {
606 ret_val = IXGBE_SUCCESS;
607 IXGBE_WRITE_REG(hw, IXGBE_VFLREC(reg_offset), (1 << vf_shift));
608 hw->mbx.stats.rsts++;
615 * ixgbe_obtain_mbx_lock_pf - obtain mailbox lock
616 * @hw: pointer to the HW structure
617 * @vf_number: the VF index
619 * return SUCCESS if we obtained the mailbox lock
621 STATIC s32 ixgbe_obtain_mbx_lock_pf(struct ixgbe_hw *hw, u16 vf_number)
623 s32 ret_val = IXGBE_ERR_MBX;
626 DEBUGFUNC("ixgbe_obtain_mbx_lock_pf");
628 /* Take ownership of the buffer */
629 IXGBE_WRITE_REG(hw, IXGBE_PFMAILBOX(vf_number), IXGBE_PFMAILBOX_PFU);
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;
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
646 * returns SUCCESS if it successfully copied message into the buffer
648 STATIC s32 ixgbe_write_mbx_pf(struct ixgbe_hw *hw, u32 *msg, u16 size,
654 DEBUGFUNC("ixgbe_write_mbx_pf");
656 /* lock the mailbox to prevent pf/vf race condition */
657 ret_val = ixgbe_obtain_mbx_lock_pf(hw, vf_number);
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);
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]);
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);
673 hw->mbx.stats.msgs_tx++;
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
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.
691 STATIC s32 ixgbe_read_mbx_pf(struct ixgbe_hw *hw, u32 *msg, u16 size,
697 DEBUGFUNC("ixgbe_read_mbx_pf");
699 /* lock the mailbox to prevent pf/vf race condition */
700 ret_val = ixgbe_obtain_mbx_lock_pf(hw, vf_number);
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);
708 /* Acknowledge the message and release buffer */
709 IXGBE_WRITE_REG(hw, IXGBE_PFMAILBOX(vf_number), IXGBE_PFMAILBOX_ACK);
712 hw->mbx.stats.msgs_rx++;
719 * ixgbe_init_mbx_params_pf - set initial values for pf mailbox
720 * @hw: pointer to the HW structure
722 * Initializes the hw->mbx struct to correct values for pf mailbox
724 void ixgbe_init_mbx_params_pf(struct ixgbe_hw *hw)
726 struct ixgbe_mbx_info *mbx = &hw->mbx;
728 if (hw->mac.type != ixgbe_mac_82599EB &&
729 hw->mac.type != ixgbe_mac_X540)
735 mbx->size = IXGBE_VFMAILBOX_SIZE;
737 mbx->ops.read = ixgbe_read_mbx_pf;
738 mbx->ops.write = ixgbe_write_mbx_pf;
739 mbx->ops.read_posted = ixgbe_read_posted_mbx;
740 mbx->ops.write_posted = ixgbe_write_posted_mbx;
741 mbx->ops.check_for_msg = ixgbe_check_for_msg_pf;
742 mbx->ops.check_for_ack = ixgbe_check_for_ack_pf;
743 mbx->ops.check_for_rst = ixgbe_check_for_rst_pf;
745 mbx->stats.msgs_tx = 0;
746 mbx->stats.msgs_rx = 0;