1 /*******************************************************************************
3 Copyright (c) 2001-2014, 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 "e1000_mbx.h"
37 * e1000_null_mbx_check_for_flag - No-op function, return 0
38 * @hw: pointer to the HW structure
40 STATIC s32 e1000_null_mbx_check_for_flag(struct e1000_hw E1000_UNUSEDARG *hw,
41 u16 E1000_UNUSEDARG mbx_id)
43 DEBUGFUNC("e1000_null_mbx_check_flag");
44 UNREFERENCED_2PARAMETER(hw, mbx_id);
50 * e1000_null_mbx_transact - No-op function, return 0
51 * @hw: pointer to the HW structure
53 STATIC s32 e1000_null_mbx_transact(struct e1000_hw E1000_UNUSEDARG *hw,
54 u32 E1000_UNUSEDARG *msg,
55 u16 E1000_UNUSEDARG size,
56 u16 E1000_UNUSEDARG mbx_id)
58 DEBUGFUNC("e1000_null_mbx_rw_msg");
59 UNREFERENCED_4PARAMETER(hw, msg, size, mbx_id);
65 * e1000_read_mbx - Reads a message from 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 read
71 * returns SUCCESS if it successfully read message from buffer
73 s32 e1000_read_mbx(struct e1000_hw *hw, u32 *msg, u16 size, u16 mbx_id)
75 struct e1000_mbx_info *mbx = &hw->mbx;
76 s32 ret_val = -E1000_ERR_MBX;
78 DEBUGFUNC("e1000_read_mbx");
80 /* limit read to size of mailbox */
85 ret_val = mbx->ops.read(hw, msg, size, mbx_id);
91 * e1000_write_mbx - Write a message to the mailbox
92 * @hw: pointer to the HW structure
93 * @msg: The message buffer
94 * @size: Length of buffer
95 * @mbx_id: id of mailbox to write
97 * returns SUCCESS if it successfully copied message into the buffer
99 s32 e1000_write_mbx(struct e1000_hw *hw, u32 *msg, u16 size, u16 mbx_id)
101 struct e1000_mbx_info *mbx = &hw->mbx;
102 s32 ret_val = E1000_SUCCESS;
104 DEBUGFUNC("e1000_write_mbx");
106 if (size > mbx->size)
107 ret_val = -E1000_ERR_MBX;
109 else if (mbx->ops.write)
110 ret_val = mbx->ops.write(hw, msg, size, mbx_id);
116 * e1000_check_for_msg - checks to see if someone sent us mail
117 * @hw: pointer to the HW structure
118 * @mbx_id: id of mailbox to check
120 * returns SUCCESS if the Status bit was found or else ERR_MBX
122 s32 e1000_check_for_msg(struct e1000_hw *hw, u16 mbx_id)
124 struct e1000_mbx_info *mbx = &hw->mbx;
125 s32 ret_val = -E1000_ERR_MBX;
127 DEBUGFUNC("e1000_check_for_msg");
129 if (mbx->ops.check_for_msg)
130 ret_val = mbx->ops.check_for_msg(hw, mbx_id);
136 * e1000_check_for_ack - checks to see if someone sent us ACK
137 * @hw: pointer to the HW structure
138 * @mbx_id: id of mailbox to check
140 * returns SUCCESS if the Status bit was found or else ERR_MBX
142 s32 e1000_check_for_ack(struct e1000_hw *hw, u16 mbx_id)
144 struct e1000_mbx_info *mbx = &hw->mbx;
145 s32 ret_val = -E1000_ERR_MBX;
147 DEBUGFUNC("e1000_check_for_ack");
149 if (mbx->ops.check_for_ack)
150 ret_val = mbx->ops.check_for_ack(hw, mbx_id);
156 * e1000_check_for_rst - checks to see if other side has reset
157 * @hw: pointer to the HW structure
158 * @mbx_id: id of mailbox to check
160 * returns SUCCESS if the Status bit was found or else ERR_MBX
162 s32 e1000_check_for_rst(struct e1000_hw *hw, u16 mbx_id)
164 struct e1000_mbx_info *mbx = &hw->mbx;
165 s32 ret_val = -E1000_ERR_MBX;
167 DEBUGFUNC("e1000_check_for_rst");
169 if (mbx->ops.check_for_rst)
170 ret_val = mbx->ops.check_for_rst(hw, mbx_id);
176 * e1000_poll_for_msg - Wait for message notification
177 * @hw: pointer to the HW structure
178 * @mbx_id: id of mailbox to write
180 * returns SUCCESS if it successfully received a message notification
182 STATIC s32 e1000_poll_for_msg(struct e1000_hw *hw, u16 mbx_id)
184 struct e1000_mbx_info *mbx = &hw->mbx;
185 int countdown = mbx->timeout;
187 DEBUGFUNC("e1000_poll_for_msg");
189 if (!countdown || !mbx->ops.check_for_msg)
192 while (countdown && mbx->ops.check_for_msg(hw, mbx_id)) {
196 usec_delay(mbx->usec_delay);
199 /* if we failed, all future posted messages fail until reset */
203 return countdown ? E1000_SUCCESS : -E1000_ERR_MBX;
207 * e1000_poll_for_ack - Wait for message acknowledgement
208 * @hw: pointer to the HW structure
209 * @mbx_id: id of mailbox to write
211 * returns SUCCESS if it successfully received a message acknowledgement
213 STATIC s32 e1000_poll_for_ack(struct e1000_hw *hw, u16 mbx_id)
215 struct e1000_mbx_info *mbx = &hw->mbx;
216 int countdown = mbx->timeout;
218 DEBUGFUNC("e1000_poll_for_ack");
220 if (!countdown || !mbx->ops.check_for_ack)
223 while (countdown && mbx->ops.check_for_ack(hw, mbx_id)) {
227 usec_delay(mbx->usec_delay);
230 /* if we failed, all future posted messages fail until reset */
234 return countdown ? E1000_SUCCESS : -E1000_ERR_MBX;
238 * e1000_read_posted_mbx - Wait for message notification and receive message
239 * @hw: pointer to the HW structure
240 * @msg: The message buffer
241 * @size: Length of buffer
242 * @mbx_id: id of mailbox to write
244 * returns SUCCESS if it successfully received a message notification and
245 * copied it into the receive buffer.
247 s32 e1000_read_posted_mbx(struct e1000_hw *hw, u32 *msg, u16 size, u16 mbx_id)
249 struct e1000_mbx_info *mbx = &hw->mbx;
250 s32 ret_val = -E1000_ERR_MBX;
252 DEBUGFUNC("e1000_read_posted_mbx");
257 ret_val = e1000_poll_for_msg(hw, mbx_id);
259 /* if ack received read message, otherwise we timed out */
261 ret_val = mbx->ops.read(hw, msg, size, mbx_id);
267 * e1000_write_posted_mbx - Write a message to the mailbox, wait for ack
268 * @hw: pointer to the HW structure
269 * @msg: The message buffer
270 * @size: Length of buffer
271 * @mbx_id: id of mailbox to write
273 * returns SUCCESS if it successfully copied message into the buffer and
274 * received an ack to that message within delay * timeout period
276 s32 e1000_write_posted_mbx(struct e1000_hw *hw, u32 *msg, u16 size, u16 mbx_id)
278 struct e1000_mbx_info *mbx = &hw->mbx;
279 s32 ret_val = -E1000_ERR_MBX;
281 DEBUGFUNC("e1000_write_posted_mbx");
283 /* exit if either we can't write or there isn't a defined timeout */
284 if (!mbx->ops.write || !mbx->timeout)
288 ret_val = mbx->ops.write(hw, msg, size, mbx_id);
290 /* if msg sent wait until we receive an ack */
292 ret_val = e1000_poll_for_ack(hw, mbx_id);
298 * e1000_init_mbx_ops_generic - Initialize mbx function pointers
299 * @hw: pointer to the HW structure
301 * Sets the function pointers to no-op functions
303 void e1000_init_mbx_ops_generic(struct e1000_hw *hw)
305 struct e1000_mbx_info *mbx = &hw->mbx;
306 mbx->ops.init_params = e1000_null_ops_generic;
307 mbx->ops.read = e1000_null_mbx_transact;
308 mbx->ops.write = e1000_null_mbx_transact;
309 mbx->ops.check_for_msg = e1000_null_mbx_check_for_flag;
310 mbx->ops.check_for_ack = e1000_null_mbx_check_for_flag;
311 mbx->ops.check_for_rst = e1000_null_mbx_check_for_flag;
312 mbx->ops.read_posted = e1000_read_posted_mbx;
313 mbx->ops.write_posted = e1000_write_posted_mbx;
317 * e1000_read_v2p_mailbox - read v2p mailbox
318 * @hw: pointer to the HW structure
320 * This function is used to read the v2p mailbox without losing the read to
323 STATIC u32 e1000_read_v2p_mailbox(struct e1000_hw *hw)
325 u32 v2p_mailbox = E1000_READ_REG(hw, E1000_V2PMAILBOX(0));
327 v2p_mailbox |= hw->dev_spec.vf.v2p_mailbox;
328 hw->dev_spec.vf.v2p_mailbox |= v2p_mailbox & E1000_V2PMAILBOX_R2C_BITS;
334 * e1000_check_for_bit_vf - Determine if a status bit was set
335 * @hw: pointer to the HW structure
336 * @mask: bitmask for bits to be tested and cleared
338 * This function is used to check for the read to clear bits within
341 STATIC s32 e1000_check_for_bit_vf(struct e1000_hw *hw, u32 mask)
343 u32 v2p_mailbox = e1000_read_v2p_mailbox(hw);
344 s32 ret_val = -E1000_ERR_MBX;
346 if (v2p_mailbox & mask)
347 ret_val = E1000_SUCCESS;
349 hw->dev_spec.vf.v2p_mailbox &= ~mask;
355 * e1000_check_for_msg_vf - checks to see if the PF has sent mail
356 * @hw: pointer to the HW structure
357 * @mbx_id: id of mailbox to check
359 * returns SUCCESS if the PF has set the Status bit or else ERR_MBX
361 STATIC s32 e1000_check_for_msg_vf(struct e1000_hw *hw,
362 u16 E1000_UNUSEDARG mbx_id)
364 s32 ret_val = -E1000_ERR_MBX;
366 UNREFERENCED_1PARAMETER(mbx_id);
367 DEBUGFUNC("e1000_check_for_msg_vf");
369 if (!e1000_check_for_bit_vf(hw, E1000_V2PMAILBOX_PFSTS)) {
370 ret_val = E1000_SUCCESS;
371 hw->mbx.stats.reqs++;
378 * e1000_check_for_ack_vf - checks to see if the PF has ACK'd
379 * @hw: pointer to the HW structure
380 * @mbx_id: id of mailbox to check
382 * returns SUCCESS if the PF has set the ACK bit or else ERR_MBX
384 STATIC s32 e1000_check_for_ack_vf(struct e1000_hw *hw,
385 u16 E1000_UNUSEDARG mbx_id)
387 s32 ret_val = -E1000_ERR_MBX;
389 UNREFERENCED_1PARAMETER(mbx_id);
390 DEBUGFUNC("e1000_check_for_ack_vf");
392 if (!e1000_check_for_bit_vf(hw, E1000_V2PMAILBOX_PFACK)) {
393 ret_val = E1000_SUCCESS;
394 hw->mbx.stats.acks++;
401 * e1000_check_for_rst_vf - checks to see if the PF has reset
402 * @hw: pointer to the HW structure
403 * @mbx_id: id of mailbox to check
405 * returns true if the PF has set the reset done bit or else false
407 STATIC s32 e1000_check_for_rst_vf(struct e1000_hw *hw,
408 u16 E1000_UNUSEDARG mbx_id)
410 s32 ret_val = -E1000_ERR_MBX;
412 UNREFERENCED_1PARAMETER(mbx_id);
413 DEBUGFUNC("e1000_check_for_rst_vf");
415 if (!e1000_check_for_bit_vf(hw, (E1000_V2PMAILBOX_RSTD |
416 E1000_V2PMAILBOX_RSTI))) {
417 ret_val = E1000_SUCCESS;
418 hw->mbx.stats.rsts++;
425 * e1000_obtain_mbx_lock_vf - obtain mailbox lock
426 * @hw: pointer to the HW structure
428 * return SUCCESS if we obtained the mailbox lock
430 STATIC s32 e1000_obtain_mbx_lock_vf(struct e1000_hw *hw)
432 s32 ret_val = -E1000_ERR_MBX;
434 DEBUGFUNC("e1000_obtain_mbx_lock_vf");
436 /* Take ownership of the buffer */
437 E1000_WRITE_REG(hw, E1000_V2PMAILBOX(0), E1000_V2PMAILBOX_VFU);
439 /* reserve mailbox for vf use */
440 if (e1000_read_v2p_mailbox(hw) & E1000_V2PMAILBOX_VFU)
441 ret_val = E1000_SUCCESS;
447 * e1000_write_mbx_vf - Write a message to the mailbox
448 * @hw: pointer to the HW structure
449 * @msg: The message buffer
450 * @size: Length of buffer
451 * @mbx_id: id of mailbox to write
453 * returns SUCCESS if it successfully copied message into the buffer
455 STATIC s32 e1000_write_mbx_vf(struct e1000_hw *hw, u32 *msg, u16 size,
456 u16 E1000_UNUSEDARG mbx_id)
461 UNREFERENCED_1PARAMETER(mbx_id);
463 DEBUGFUNC("e1000_write_mbx_vf");
465 /* lock the mailbox to prevent pf/vf race condition */
466 ret_val = e1000_obtain_mbx_lock_vf(hw);
470 /* flush msg and acks as we are overwriting the message buffer */
471 e1000_check_for_msg_vf(hw, 0);
472 e1000_check_for_ack_vf(hw, 0);
474 /* copy the caller specified message to the mailbox memory buffer */
475 for (i = 0; i < size; i++)
476 E1000_WRITE_REG_ARRAY(hw, E1000_VMBMEM(0), i, msg[i]);
479 hw->mbx.stats.msgs_tx++;
481 /* Drop VFU and interrupt the PF to tell it a message has been sent */
482 E1000_WRITE_REG(hw, E1000_V2PMAILBOX(0), E1000_V2PMAILBOX_REQ);
489 * e1000_read_mbx_vf - Reads a message from the inbox intended for vf
490 * @hw: pointer to the HW structure
491 * @msg: The message buffer
492 * @size: Length of buffer
493 * @mbx_id: id of mailbox to read
495 * returns SUCCESS if it successfully read message from buffer
497 STATIC s32 e1000_read_mbx_vf(struct e1000_hw *hw, u32 *msg, u16 size,
498 u16 E1000_UNUSEDARG mbx_id)
500 s32 ret_val = E1000_SUCCESS;
503 DEBUGFUNC("e1000_read_mbx_vf");
504 UNREFERENCED_1PARAMETER(mbx_id);
506 /* lock the mailbox to prevent pf/vf race condition */
507 ret_val = e1000_obtain_mbx_lock_vf(hw);
511 /* copy the message from the mailbox memory buffer */
512 for (i = 0; i < size; i++)
513 msg[i] = E1000_READ_REG_ARRAY(hw, E1000_VMBMEM(0), i);
515 /* Acknowledge receipt and release mailbox, then we're done */
516 E1000_WRITE_REG(hw, E1000_V2PMAILBOX(0), E1000_V2PMAILBOX_ACK);
519 hw->mbx.stats.msgs_rx++;
526 * e1000_init_mbx_params_vf - set initial values for vf mailbox
527 * @hw: pointer to the HW structure
529 * Initializes the hw->mbx struct to correct values for vf mailbox
531 s32 e1000_init_mbx_params_vf(struct e1000_hw *hw)
533 struct e1000_mbx_info *mbx = &hw->mbx;
535 /* start mailbox as timed out and let the reset_hw call set the timeout
536 * value to begin communications */
538 mbx->usec_delay = E1000_VF_MBX_INIT_DELAY;
540 mbx->size = E1000_VFMAILBOX_SIZE;
542 mbx->ops.read = e1000_read_mbx_vf;
543 mbx->ops.write = e1000_write_mbx_vf;
544 mbx->ops.read_posted = e1000_read_posted_mbx;
545 mbx->ops.write_posted = e1000_write_posted_mbx;
546 mbx->ops.check_for_msg = e1000_check_for_msg_vf;
547 mbx->ops.check_for_ack = e1000_check_for_ack_vf;
548 mbx->ops.check_for_rst = e1000_check_for_rst_vf;
550 mbx->stats.msgs_tx = 0;
551 mbx->stats.msgs_rx = 0;
556 return E1000_SUCCESS;
559 STATIC s32 e1000_check_for_bit_pf(struct e1000_hw *hw, u32 mask)
561 u32 mbvficr = E1000_READ_REG(hw, E1000_MBVFICR);
562 s32 ret_val = -E1000_ERR_MBX;
564 if (mbvficr & mask) {
565 ret_val = E1000_SUCCESS;
566 E1000_WRITE_REG(hw, E1000_MBVFICR, mask);
573 * e1000_check_for_msg_pf - checks to see if the VF has sent mail
574 * @hw: pointer to the HW structure
575 * @vf_number: the VF index
577 * returns SUCCESS if the VF has set the Status bit or else ERR_MBX
579 STATIC s32 e1000_check_for_msg_pf(struct e1000_hw *hw, u16 vf_number)
581 s32 ret_val = -E1000_ERR_MBX;
583 DEBUGFUNC("e1000_check_for_msg_pf");
585 if (!e1000_check_for_bit_pf(hw, E1000_MBVFICR_VFREQ_VF1 << vf_number)) {
586 ret_val = E1000_SUCCESS;
587 hw->mbx.stats.reqs++;
594 * e1000_check_for_ack_pf - checks to see if the VF has ACKed
595 * @hw: pointer to the HW structure
596 * @vf_number: the VF index
598 * returns SUCCESS if the VF has set the Status bit or else ERR_MBX
600 STATIC s32 e1000_check_for_ack_pf(struct e1000_hw *hw, u16 vf_number)
602 s32 ret_val = -E1000_ERR_MBX;
604 DEBUGFUNC("e1000_check_for_ack_pf");
606 if (!e1000_check_for_bit_pf(hw, E1000_MBVFICR_VFACK_VF1 << vf_number)) {
607 ret_val = E1000_SUCCESS;
608 hw->mbx.stats.acks++;
615 * e1000_check_for_rst_pf - checks to see if the VF has reset
616 * @hw: pointer to the HW structure
617 * @vf_number: the VF index
619 * returns SUCCESS if the VF has set the Status bit or else ERR_MBX
621 STATIC s32 e1000_check_for_rst_pf(struct e1000_hw *hw, u16 vf_number)
623 u32 vflre = E1000_READ_REG(hw, E1000_VFLRE);
624 s32 ret_val = -E1000_ERR_MBX;
626 DEBUGFUNC("e1000_check_for_rst_pf");
628 if (vflre & (1 << vf_number)) {
629 ret_val = E1000_SUCCESS;
630 E1000_WRITE_REG(hw, E1000_VFLRE, (1 << vf_number));
631 hw->mbx.stats.rsts++;
638 * e1000_obtain_mbx_lock_pf - obtain mailbox lock
639 * @hw: pointer to the HW structure
640 * @vf_number: the VF index
642 * return SUCCESS if we obtained the mailbox lock
644 STATIC s32 e1000_obtain_mbx_lock_pf(struct e1000_hw *hw, u16 vf_number)
646 s32 ret_val = -E1000_ERR_MBX;
649 DEBUGFUNC("e1000_obtain_mbx_lock_pf");
651 /* Take ownership of the buffer */
652 E1000_WRITE_REG(hw, E1000_P2VMAILBOX(vf_number), E1000_P2VMAILBOX_PFU);
654 /* reserve mailbox for vf use */
655 p2v_mailbox = E1000_READ_REG(hw, E1000_P2VMAILBOX(vf_number));
656 if (p2v_mailbox & E1000_P2VMAILBOX_PFU)
657 ret_val = E1000_SUCCESS;
663 * e1000_write_mbx_pf - Places a message in the mailbox
664 * @hw: pointer to the HW structure
665 * @msg: The message buffer
666 * @size: Length of buffer
667 * @vf_number: the VF index
669 * returns SUCCESS if it successfully copied message into the buffer
671 STATIC s32 e1000_write_mbx_pf(struct e1000_hw *hw, u32 *msg, u16 size,
677 DEBUGFUNC("e1000_write_mbx_pf");
679 /* lock the mailbox to prevent pf/vf race condition */
680 ret_val = e1000_obtain_mbx_lock_pf(hw, vf_number);
684 /* flush msg and acks as we are overwriting the message buffer */
685 e1000_check_for_msg_pf(hw, vf_number);
686 e1000_check_for_ack_pf(hw, vf_number);
688 /* copy the caller specified message to the mailbox memory buffer */
689 for (i = 0; i < size; i++)
690 E1000_WRITE_REG_ARRAY(hw, E1000_VMBMEM(vf_number), i, msg[i]);
692 /* Interrupt VF to tell it a message has been sent and release buffer*/
693 E1000_WRITE_REG(hw, E1000_P2VMAILBOX(vf_number), E1000_P2VMAILBOX_STS);
696 hw->mbx.stats.msgs_tx++;
704 * e1000_read_mbx_pf - Read a message from the mailbox
705 * @hw: pointer to the HW structure
706 * @msg: The message buffer
707 * @size: Length of buffer
708 * @vf_number: the VF index
710 * This function copies a message from the mailbox buffer to the caller's
711 * memory buffer. The presumption is that the caller knows that there was
712 * a message due to a VF request so no polling for message is needed.
714 STATIC s32 e1000_read_mbx_pf(struct e1000_hw *hw, u32 *msg, u16 size,
720 DEBUGFUNC("e1000_read_mbx_pf");
722 /* lock the mailbox to prevent pf/vf race condition */
723 ret_val = e1000_obtain_mbx_lock_pf(hw, vf_number);
727 /* copy the message to the mailbox memory buffer */
728 for (i = 0; i < size; i++)
729 msg[i] = E1000_READ_REG_ARRAY(hw, E1000_VMBMEM(vf_number), i);
731 /* Acknowledge the message and release buffer */
732 E1000_WRITE_REG(hw, E1000_P2VMAILBOX(vf_number), E1000_P2VMAILBOX_ACK);
735 hw->mbx.stats.msgs_rx++;
742 * e1000_init_mbx_params_pf - set initial values for pf mailbox
743 * @hw: pointer to the HW structure
745 * Initializes the hw->mbx struct to correct values for pf mailbox
747 s32 e1000_init_mbx_params_pf(struct e1000_hw *hw)
749 struct e1000_mbx_info *mbx = &hw->mbx;
751 switch (hw->mac.type) {
758 mbx->size = E1000_VFMAILBOX_SIZE;
760 mbx->ops.read = e1000_read_mbx_pf;
761 mbx->ops.write = e1000_write_mbx_pf;
762 mbx->ops.read_posted = e1000_read_posted_mbx;
763 mbx->ops.write_posted = e1000_write_posted_mbx;
764 mbx->ops.check_for_msg = e1000_check_for_msg_pf;
765 mbx->ops.check_for_ack = e1000_check_for_ack_pf;
766 mbx->ops.check_for_rst = e1000_check_for_rst_pf;
768 mbx->stats.msgs_tx = 0;
769 mbx->stats.msgs_rx = 0;
774 return E1000_SUCCESS;