1 /*******************************************************************************
3 Copyright (c) 2001-2015, 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;
435 DEBUGFUNC("e1000_obtain_mbx_lock_vf");
438 /* Take ownership of the buffer */
439 E1000_WRITE_REG(hw, E1000_V2PMAILBOX(0), E1000_V2PMAILBOX_VFU);
441 /* reserve mailbox for vf use */
442 if (e1000_read_v2p_mailbox(hw) & E1000_V2PMAILBOX_VFU) {
443 ret_val = E1000_SUCCESS;
447 } while (count-- > 0);
453 * e1000_write_mbx_vf - Write a message to the mailbox
454 * @hw: pointer to the HW structure
455 * @msg: The message buffer
456 * @size: Length of buffer
457 * @mbx_id: id of mailbox to write
459 * returns SUCCESS if it successfully copied message into the buffer
461 STATIC s32 e1000_write_mbx_vf(struct e1000_hw *hw, u32 *msg, u16 size,
462 u16 E1000_UNUSEDARG mbx_id)
467 UNREFERENCED_1PARAMETER(mbx_id);
469 DEBUGFUNC("e1000_write_mbx_vf");
471 /* lock the mailbox to prevent pf/vf race condition */
472 ret_val = e1000_obtain_mbx_lock_vf(hw);
476 /* flush msg and acks as we are overwriting the message buffer */
477 e1000_check_for_msg_vf(hw, 0);
478 e1000_check_for_ack_vf(hw, 0);
480 /* copy the caller specified message to the mailbox memory buffer */
481 for (i = 0; i < size; i++)
482 E1000_WRITE_REG_ARRAY(hw, E1000_VMBMEM(0), i, msg[i]);
485 hw->mbx.stats.msgs_tx++;
487 /* Drop VFU and interrupt the PF to tell it a message has been sent */
488 E1000_WRITE_REG(hw, E1000_V2PMAILBOX(0), E1000_V2PMAILBOX_REQ);
495 * e1000_read_mbx_vf - Reads a message from the inbox intended for vf
496 * @hw: pointer to the HW structure
497 * @msg: The message buffer
498 * @size: Length of buffer
499 * @mbx_id: id of mailbox to read
501 * returns SUCCESS if it successfully read message from buffer
503 STATIC s32 e1000_read_mbx_vf(struct e1000_hw *hw, u32 *msg, u16 size,
504 u16 E1000_UNUSEDARG mbx_id)
506 s32 ret_val = E1000_SUCCESS;
509 DEBUGFUNC("e1000_read_mbx_vf");
510 UNREFERENCED_1PARAMETER(mbx_id);
512 /* lock the mailbox to prevent pf/vf race condition */
513 ret_val = e1000_obtain_mbx_lock_vf(hw);
517 /* copy the message from the mailbox memory buffer */
518 for (i = 0; i < size; i++)
519 msg[i] = E1000_READ_REG_ARRAY(hw, E1000_VMBMEM(0), i);
521 /* Acknowledge receipt and release mailbox, then we're done */
522 E1000_WRITE_REG(hw, E1000_V2PMAILBOX(0), E1000_V2PMAILBOX_ACK);
525 hw->mbx.stats.msgs_rx++;
532 * e1000_init_mbx_params_vf - set initial values for vf mailbox
533 * @hw: pointer to the HW structure
535 * Initializes the hw->mbx struct to correct values for vf mailbox
537 s32 e1000_init_mbx_params_vf(struct e1000_hw *hw)
539 struct e1000_mbx_info *mbx = &hw->mbx;
541 /* start mailbox as timed out and let the reset_hw call set the timeout
542 * value to begin communications */
544 mbx->usec_delay = E1000_VF_MBX_INIT_DELAY;
546 mbx->size = E1000_VFMAILBOX_SIZE;
548 mbx->ops.read = e1000_read_mbx_vf;
549 mbx->ops.write = e1000_write_mbx_vf;
550 mbx->ops.read_posted = e1000_read_posted_mbx;
551 mbx->ops.write_posted = e1000_write_posted_mbx;
552 mbx->ops.check_for_msg = e1000_check_for_msg_vf;
553 mbx->ops.check_for_ack = e1000_check_for_ack_vf;
554 mbx->ops.check_for_rst = e1000_check_for_rst_vf;
556 mbx->stats.msgs_tx = 0;
557 mbx->stats.msgs_rx = 0;
562 return E1000_SUCCESS;
565 STATIC s32 e1000_check_for_bit_pf(struct e1000_hw *hw, u32 mask)
567 u32 mbvficr = E1000_READ_REG(hw, E1000_MBVFICR);
568 s32 ret_val = -E1000_ERR_MBX;
570 if (mbvficr & mask) {
571 ret_val = E1000_SUCCESS;
572 E1000_WRITE_REG(hw, E1000_MBVFICR, mask);
579 * e1000_check_for_msg_pf - checks to see if the VF has sent mail
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 e1000_check_for_msg_pf(struct e1000_hw *hw, u16 vf_number)
587 s32 ret_val = -E1000_ERR_MBX;
589 DEBUGFUNC("e1000_check_for_msg_pf");
591 if (!e1000_check_for_bit_pf(hw, E1000_MBVFICR_VFREQ_VF1 << vf_number)) {
592 ret_val = E1000_SUCCESS;
593 hw->mbx.stats.reqs++;
600 * e1000_check_for_ack_pf - checks to see if the VF has ACKed
601 * @hw: pointer to the HW structure
602 * @vf_number: the VF index
604 * returns SUCCESS if the VF has set the Status bit or else ERR_MBX
606 STATIC s32 e1000_check_for_ack_pf(struct e1000_hw *hw, u16 vf_number)
608 s32 ret_val = -E1000_ERR_MBX;
610 DEBUGFUNC("e1000_check_for_ack_pf");
612 if (!e1000_check_for_bit_pf(hw, E1000_MBVFICR_VFACK_VF1 << vf_number)) {
613 ret_val = E1000_SUCCESS;
614 hw->mbx.stats.acks++;
621 * e1000_check_for_rst_pf - checks to see if the VF has reset
622 * @hw: pointer to the HW structure
623 * @vf_number: the VF index
625 * returns SUCCESS if the VF has set the Status bit or else ERR_MBX
627 STATIC s32 e1000_check_for_rst_pf(struct e1000_hw *hw, u16 vf_number)
629 u32 vflre = E1000_READ_REG(hw, E1000_VFLRE);
630 s32 ret_val = -E1000_ERR_MBX;
632 DEBUGFUNC("e1000_check_for_rst_pf");
634 if (vflre & (1 << vf_number)) {
635 ret_val = E1000_SUCCESS;
636 E1000_WRITE_REG(hw, E1000_VFLRE, (1 << vf_number));
637 hw->mbx.stats.rsts++;
644 * e1000_obtain_mbx_lock_pf - obtain mailbox lock
645 * @hw: pointer to the HW structure
646 * @vf_number: the VF index
648 * return SUCCESS if we obtained the mailbox lock
650 STATIC s32 e1000_obtain_mbx_lock_pf(struct e1000_hw *hw, u16 vf_number)
652 s32 ret_val = -E1000_ERR_MBX;
656 DEBUGFUNC("e1000_obtain_mbx_lock_pf");
659 /* Take ownership of the buffer */
660 E1000_WRITE_REG(hw, E1000_P2VMAILBOX(vf_number),
661 E1000_P2VMAILBOX_PFU);
663 /* reserve mailbox for pf use */
664 p2v_mailbox = E1000_READ_REG(hw, E1000_P2VMAILBOX(vf_number));
665 if (p2v_mailbox & E1000_P2VMAILBOX_PFU) {
666 ret_val = E1000_SUCCESS;
670 } while (count-- > 0);
677 * e1000_write_mbx_pf - Places a message in the mailbox
678 * @hw: pointer to the HW structure
679 * @msg: The message buffer
680 * @size: Length of buffer
681 * @vf_number: the VF index
683 * returns SUCCESS if it successfully copied message into the buffer
685 STATIC s32 e1000_write_mbx_pf(struct e1000_hw *hw, u32 *msg, u16 size,
691 DEBUGFUNC("e1000_write_mbx_pf");
693 /* lock the mailbox to prevent pf/vf race condition */
694 ret_val = e1000_obtain_mbx_lock_pf(hw, vf_number);
698 /* flush msg and acks as we are overwriting the message buffer */
699 e1000_check_for_msg_pf(hw, vf_number);
700 e1000_check_for_ack_pf(hw, vf_number);
702 /* copy the caller specified message to the mailbox memory buffer */
703 for (i = 0; i < size; i++)
704 E1000_WRITE_REG_ARRAY(hw, E1000_VMBMEM(vf_number), i, msg[i]);
706 /* Interrupt VF to tell it a message has been sent and release buffer*/
707 E1000_WRITE_REG(hw, E1000_P2VMAILBOX(vf_number), E1000_P2VMAILBOX_STS);
710 hw->mbx.stats.msgs_tx++;
718 * e1000_read_mbx_pf - Read a message from the mailbox
719 * @hw: pointer to the HW structure
720 * @msg: The message buffer
721 * @size: Length of buffer
722 * @vf_number: the VF index
724 * This function copies a message from the mailbox buffer to the caller's
725 * memory buffer. The presumption is that the caller knows that there was
726 * a message due to a VF request so no polling for message is needed.
728 STATIC s32 e1000_read_mbx_pf(struct e1000_hw *hw, u32 *msg, u16 size,
734 DEBUGFUNC("e1000_read_mbx_pf");
736 /* lock the mailbox to prevent pf/vf race condition */
737 ret_val = e1000_obtain_mbx_lock_pf(hw, vf_number);
741 /* copy the message to the mailbox memory buffer */
742 for (i = 0; i < size; i++)
743 msg[i] = E1000_READ_REG_ARRAY(hw, E1000_VMBMEM(vf_number), i);
745 /* Acknowledge the message and release buffer */
746 E1000_WRITE_REG(hw, E1000_P2VMAILBOX(vf_number), E1000_P2VMAILBOX_ACK);
749 hw->mbx.stats.msgs_rx++;
756 * e1000_init_mbx_params_pf - set initial values for pf mailbox
757 * @hw: pointer to the HW structure
759 * Initializes the hw->mbx struct to correct values for pf mailbox
761 s32 e1000_init_mbx_params_pf(struct e1000_hw *hw)
763 struct e1000_mbx_info *mbx = &hw->mbx;
765 switch (hw->mac.type) {
772 mbx->size = E1000_VFMAILBOX_SIZE;
774 mbx->ops.read = e1000_read_mbx_pf;
775 mbx->ops.write = e1000_write_mbx_pf;
776 mbx->ops.read_posted = e1000_read_posted_mbx;
777 mbx->ops.write_posted = e1000_write_posted_mbx;
778 mbx->ops.check_for_msg = e1000_check_for_msg_pf;
779 mbx->ops.check_for_ack = e1000_check_for_ack_pf;
780 mbx->ops.check_for_rst = e1000_check_for_rst_pf;
782 mbx->stats.msgs_tx = 0;
783 mbx->stats.msgs_rx = 0;
788 return E1000_SUCCESS;