1dc13dc3f00bb3dd013c60c6f47f2ff529b69802
[dpdk.git] / lib / librte_pmd_ixgbe / ixgbe / ixgbe_mbx.c
1 /*******************************************************************************
2
3 Copyright (c) 2001-2012, 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
34 #include "ixgbe_type.h"
35 #include "ixgbe_mbx.h"
36
37 /**
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
43  *
44  *  returns SUCCESS if it successfuly read message from buffer
45  **/
46 s32 ixgbe_read_mbx(struct ixgbe_hw *hw, u32 *msg, u16 size, u16 mbx_id)
47 {
48         struct ixgbe_mbx_info *mbx = &hw->mbx;
49         s32 ret_val = IXGBE_ERR_MBX;
50
51         DEBUGFUNC("ixgbe_read_mbx");
52
53         /* limit read to size of mailbox */
54         if (size > mbx->size)
55                 size = mbx->size;
56
57         if (mbx->ops.read)
58                 ret_val = mbx->ops.read(hw, msg, size, mbx_id);
59
60         return ret_val;
61 }
62
63 /**
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
69  *
70  *  returns SUCCESS if it successfully copied message into the buffer
71  **/
72 s32 ixgbe_write_mbx(struct ixgbe_hw *hw, u32 *msg, u16 size, u16 mbx_id)
73 {
74         struct ixgbe_mbx_info *mbx = &hw->mbx;
75         s32 ret_val = IXGBE_SUCCESS;
76
77         DEBUGFUNC("ixgbe_write_mbx");
78
79         if (size > mbx->size)
80                 ret_val = IXGBE_ERR_MBX;
81
82         else if (mbx->ops.write)
83                 ret_val = mbx->ops.write(hw, msg, size, mbx_id);
84
85         return ret_val;
86 }
87
88 /**
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
92  *
93  *  returns SUCCESS if the Status bit was found or else ERR_MBX
94  **/
95 s32 ixgbe_check_for_msg(struct ixgbe_hw *hw, u16 mbx_id)
96 {
97         struct ixgbe_mbx_info *mbx = &hw->mbx;
98         s32 ret_val = IXGBE_ERR_MBX;
99
100         DEBUGFUNC("ixgbe_check_for_msg");
101
102         if (mbx->ops.check_for_msg)
103                 ret_val = mbx->ops.check_for_msg(hw, mbx_id);
104
105         return ret_val;
106 }
107
108 /**
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
112  *
113  *  returns SUCCESS if the Status bit was found or else ERR_MBX
114  **/
115 s32 ixgbe_check_for_ack(struct ixgbe_hw *hw, u16 mbx_id)
116 {
117         struct ixgbe_mbx_info *mbx = &hw->mbx;
118         s32 ret_val = IXGBE_ERR_MBX;
119
120         DEBUGFUNC("ixgbe_check_for_ack");
121
122         if (mbx->ops.check_for_ack)
123                 ret_val = mbx->ops.check_for_ack(hw, mbx_id);
124
125         return ret_val;
126 }
127
128 /**
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
132  *
133  *  returns SUCCESS if the Status bit was found or else ERR_MBX
134  **/
135 s32 ixgbe_check_for_rst(struct ixgbe_hw *hw, u16 mbx_id)
136 {
137         struct ixgbe_mbx_info *mbx = &hw->mbx;
138         s32 ret_val = IXGBE_ERR_MBX;
139
140         DEBUGFUNC("ixgbe_check_for_rst");
141
142         if (mbx->ops.check_for_rst)
143                 ret_val = mbx->ops.check_for_rst(hw, mbx_id);
144
145         return ret_val;
146 }
147
148 /**
149  *  ixgbe_poll_for_msg - Wait for message notification
150  *  @hw: pointer to the HW structure
151  *  @mbx_id: id of mailbox to write
152  *
153  *  returns SUCCESS if it successfully received a message notification
154  **/
155 STATIC s32 ixgbe_poll_for_msg(struct ixgbe_hw *hw, u16 mbx_id)
156 {
157         struct ixgbe_mbx_info *mbx = &hw->mbx;
158         int countdown = mbx->timeout;
159
160         DEBUGFUNC("ixgbe_poll_for_msg");
161
162         if (!countdown || !mbx->ops.check_for_msg)
163                 goto out;
164
165         while (countdown && mbx->ops.check_for_msg(hw, mbx_id)) {
166                 countdown--;
167                 if (!countdown)
168                         break;
169                 usec_delay(mbx->usec_delay);
170         }
171
172 out:
173         return countdown ? IXGBE_SUCCESS : IXGBE_ERR_MBX;
174 }
175
176 /**
177  *  ixgbe_poll_for_ack - Wait for message acknowledgement
178  *  @hw: pointer to the HW structure
179  *  @mbx_id: id of mailbox to write
180  *
181  *  returns SUCCESS if it successfully received a message acknowledgement
182  **/
183 STATIC s32 ixgbe_poll_for_ack(struct ixgbe_hw *hw, u16 mbx_id)
184 {
185         struct ixgbe_mbx_info *mbx = &hw->mbx;
186         int countdown = mbx->timeout;
187
188         DEBUGFUNC("ixgbe_poll_for_ack");
189
190         if (!countdown || !mbx->ops.check_for_ack)
191                 goto out;
192
193         while (countdown && mbx->ops.check_for_ack(hw, mbx_id)) {
194                 countdown--;
195                 if (!countdown)
196                         break;
197                 usec_delay(mbx->usec_delay);
198         }
199
200 out:
201         return countdown ? IXGBE_SUCCESS : IXGBE_ERR_MBX;
202 }
203
204 /**
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
210  *
211  *  returns SUCCESS if it successfully received a message notification and
212  *  copied it into the receive buffer.
213  **/
214 s32 ixgbe_read_posted_mbx(struct ixgbe_hw *hw, u32 *msg, u16 size, u16 mbx_id)
215 {
216         struct ixgbe_mbx_info *mbx = &hw->mbx;
217         s32 ret_val = IXGBE_ERR_MBX;
218
219         DEBUGFUNC("ixgbe_read_posted_mbx");
220
221         if (!mbx->ops.read)
222                 goto out;
223
224         ret_val = ixgbe_poll_for_msg(hw, mbx_id);
225
226         /* if ack received read message, otherwise we timed out */
227         if (!ret_val)
228                 ret_val = mbx->ops.read(hw, msg, size, mbx_id);
229 out:
230         return ret_val;
231 }
232
233 /**
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
239  *
240  *  returns SUCCESS if it successfully copied message into the buffer and
241  *  received an ack to that message within delay * timeout period
242  **/
243 s32 ixgbe_write_posted_mbx(struct ixgbe_hw *hw, u32 *msg, u16 size,
244                            u16 mbx_id)
245 {
246         struct ixgbe_mbx_info *mbx = &hw->mbx;
247         s32 ret_val = IXGBE_ERR_MBX;
248
249         DEBUGFUNC("ixgbe_write_posted_mbx");
250
251         /* exit if either we can't write or there isn't a defined timeout */
252         if (!mbx->ops.write || !mbx->timeout)
253                 goto out;
254
255         /* send msg */
256         ret_val = mbx->ops.write(hw, msg, size, mbx_id);
257
258         /* if msg sent wait until we receive an ack */
259         if (!ret_val)
260                 ret_val = ixgbe_poll_for_ack(hw, mbx_id);
261 out:
262         return ret_val;
263 }
264
265 /**
266  *  ixgbe_init_mbx_ops_generic - Initialize MB function pointers
267  *  @hw: pointer to the HW structure
268  *
269  *  Setups up the mailbox read and write message function pointers
270  **/
271 void ixgbe_init_mbx_ops_generic(struct ixgbe_hw *hw)
272 {
273         struct ixgbe_mbx_info *mbx = &hw->mbx;
274
275         mbx->ops.read_posted = ixgbe_read_posted_mbx;
276         mbx->ops.write_posted = ixgbe_write_posted_mbx;
277 }
278
279 /**
280  *  ixgbe_read_v2p_mailbox - read v2p mailbox
281  *  @hw: pointer to the HW structure
282  *
283  *  This function is used to read the v2p mailbox without losing the read to
284  *  clear status bits.
285  **/
286 STATIC u32 ixgbe_read_v2p_mailbox(struct ixgbe_hw *hw)
287 {
288         u32 v2p_mailbox = IXGBE_READ_REG(hw, IXGBE_VFMAILBOX);
289
290         v2p_mailbox |= hw->mbx.v2p_mailbox;
291         hw->mbx.v2p_mailbox |= v2p_mailbox & IXGBE_VFMAILBOX_R2C_BITS;
292
293         return v2p_mailbox;
294 }
295
296 /**
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
300  *
301  *  This function is used to check for the read to clear bits within
302  *  the V2P mailbox.
303  **/
304 STATIC s32 ixgbe_check_for_bit_vf(struct ixgbe_hw *hw, u32 mask)
305 {
306         u32 v2p_mailbox = ixgbe_read_v2p_mailbox(hw);
307         s32 ret_val = IXGBE_ERR_MBX;
308
309         if (v2p_mailbox & mask)
310                 ret_val = IXGBE_SUCCESS;
311
312         hw->mbx.v2p_mailbox &= ~mask;
313
314         return ret_val;
315 }
316
317 /**
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
321  *
322  *  returns SUCCESS if the PF has set the Status bit or else ERR_MBX
323  **/
324 STATIC s32 ixgbe_check_for_msg_vf(struct ixgbe_hw *hw, u16 mbx_id)
325 {
326         s32 ret_val = IXGBE_ERR_MBX;
327
328         DEBUGFUNC("ixgbe_check_for_msg_vf");
329
330         if (!ixgbe_check_for_bit_vf(hw, IXGBE_VFMAILBOX_PFSTS)) {
331                 ret_val = IXGBE_SUCCESS;
332                 hw->mbx.stats.reqs++;
333         }
334
335         return ret_val;
336 }
337
338 /**
339  *  ixgbe_check_for_ack_vf - checks to see if the PF has ACK'd
340  *  @hw: pointer to the HW structure
341  *  @mbx_id: id of mailbox to check
342  *
343  *  returns SUCCESS if the PF has set the ACK bit or else ERR_MBX
344  **/
345 STATIC s32 ixgbe_check_for_ack_vf(struct ixgbe_hw *hw, u16 mbx_id)
346 {
347         s32 ret_val = IXGBE_ERR_MBX;
348
349         DEBUGFUNC("ixgbe_check_for_ack_vf");
350
351         if (!ixgbe_check_for_bit_vf(hw, IXGBE_VFMAILBOX_PFACK)) {
352                 ret_val = IXGBE_SUCCESS;
353                 hw->mbx.stats.acks++;
354         }
355
356         return ret_val;
357 }
358
359 /**
360  *  ixgbe_check_for_rst_vf - checks to see if the PF has reset
361  *  @hw: pointer to the HW structure
362  *  @mbx_id: id of mailbox to check
363  *
364  *  returns true if the PF has set the reset done bit or else false
365  **/
366 STATIC s32 ixgbe_check_for_rst_vf(struct ixgbe_hw *hw, u16 mbx_id)
367 {
368         s32 ret_val = IXGBE_ERR_MBX;
369
370         DEBUGFUNC("ixgbe_check_for_rst_vf");
371
372         if (!ixgbe_check_for_bit_vf(hw, (IXGBE_VFMAILBOX_RSTD |
373             IXGBE_VFMAILBOX_RSTI))) {
374                 ret_val = IXGBE_SUCCESS;
375                 hw->mbx.stats.rsts++;
376         }
377
378         return ret_val;
379 }
380
381 /**
382  *  ixgbe_obtain_mbx_lock_vf - obtain mailbox lock
383  *  @hw: pointer to the HW structure
384  *
385  *  return SUCCESS if we obtained the mailbox lock
386  **/
387 STATIC s32 ixgbe_obtain_mbx_lock_vf(struct ixgbe_hw *hw)
388 {
389         s32 ret_val = IXGBE_ERR_MBX;
390
391         DEBUGFUNC("ixgbe_obtain_mbx_lock_vf");
392
393         /* Take ownership of the buffer */
394         IXGBE_WRITE_REG(hw, IXGBE_VFMAILBOX, IXGBE_VFMAILBOX_VFU);
395
396         /* reserve mailbox for vf use */
397         if (ixgbe_read_v2p_mailbox(hw) & IXGBE_VFMAILBOX_VFU)
398                 ret_val = IXGBE_SUCCESS;
399
400         return ret_val;
401 }
402
403 /**
404  *  ixgbe_write_mbx_vf - Write a message to the mailbox
405  *  @hw: pointer to the HW structure
406  *  @msg: The message buffer
407  *  @size: Length of buffer
408  *  @mbx_id: id of mailbox to write
409  *
410  *  returns SUCCESS if it successfully copied message into the buffer
411  **/
412 STATIC s32 ixgbe_write_mbx_vf(struct ixgbe_hw *hw, u32 *msg, u16 size,
413                               u16 mbx_id)
414 {
415         s32 ret_val;
416         u16 i;
417
418
419         DEBUGFUNC("ixgbe_write_mbx_vf");
420
421         /* lock the mailbox to prevent pf/vf race condition */
422         ret_val = ixgbe_obtain_mbx_lock_vf(hw);
423         if (ret_val)
424                 goto out_no_write;
425
426         /* flush msg and acks as we are overwriting the message buffer */
427         ixgbe_check_for_msg_vf(hw, 0);
428         ixgbe_check_for_ack_vf(hw, 0);
429
430         /* copy the caller specified message to the mailbox memory buffer */
431         for (i = 0; i < size; i++)
432                 IXGBE_WRITE_REG_ARRAY(hw, IXGBE_VFMBMEM, i, msg[i]);
433
434         /* update stats */
435         hw->mbx.stats.msgs_tx++;
436
437         /* Drop VFU and interrupt the PF to tell it a message has been sent */
438         IXGBE_WRITE_REG(hw, IXGBE_VFMAILBOX, IXGBE_VFMAILBOX_REQ);
439
440 out_no_write:
441         return ret_val;
442 }
443
444 /**
445  *  ixgbe_read_mbx_vf - Reads a message from the inbox intended for vf
446  *  @hw: pointer to the HW structure
447  *  @msg: The message buffer
448  *  @size: Length of buffer
449  *  @mbx_id: id of mailbox to read
450  *
451  *  returns SUCCESS if it successfuly read message from buffer
452  **/
453 STATIC s32 ixgbe_read_mbx_vf(struct ixgbe_hw *hw, u32 *msg, u16 size,
454                              u16 mbx_id)
455 {
456         s32 ret_val = IXGBE_SUCCESS;
457         u16 i;
458
459         DEBUGFUNC("ixgbe_read_mbx_vf");
460
461         /* lock the mailbox to prevent pf/vf race condition */
462         ret_val = ixgbe_obtain_mbx_lock_vf(hw);
463         if (ret_val)
464                 goto out_no_read;
465
466         /* copy the message from the mailbox memory buffer */
467         for (i = 0; i < size; i++)
468                 msg[i] = IXGBE_READ_REG_ARRAY(hw, IXGBE_VFMBMEM, i);
469
470         /* Acknowledge receipt and release mailbox, then we're done */
471         IXGBE_WRITE_REG(hw, IXGBE_VFMAILBOX, IXGBE_VFMAILBOX_ACK);
472
473         /* update stats */
474         hw->mbx.stats.msgs_rx++;
475
476 out_no_read:
477         return ret_val;
478 }
479
480 /**
481  *  ixgbe_init_mbx_params_vf - set initial values for vf mailbox
482  *  @hw: pointer to the HW structure
483  *
484  *  Initializes the hw->mbx struct to correct values for vf mailbox
485  */
486 void ixgbe_init_mbx_params_vf(struct ixgbe_hw *hw)
487 {
488         struct ixgbe_mbx_info *mbx = &hw->mbx;
489
490         /* start mailbox as timed out and let the reset_hw call set the timeout
491          * value to begin communications */
492         mbx->timeout = 0;
493         mbx->usec_delay = IXGBE_VF_MBX_INIT_DELAY;
494
495         mbx->size = IXGBE_VFMAILBOX_SIZE;
496
497         mbx->ops.read = ixgbe_read_mbx_vf;
498         mbx->ops.write = ixgbe_write_mbx_vf;
499         mbx->ops.read_posted = ixgbe_read_posted_mbx;
500         mbx->ops.write_posted = ixgbe_write_posted_mbx;
501         mbx->ops.check_for_msg = ixgbe_check_for_msg_vf;
502         mbx->ops.check_for_ack = ixgbe_check_for_ack_vf;
503         mbx->ops.check_for_rst = ixgbe_check_for_rst_vf;
504
505         mbx->stats.msgs_tx = 0;
506         mbx->stats.msgs_rx = 0;
507         mbx->stats.reqs = 0;
508         mbx->stats.acks = 0;
509         mbx->stats.rsts = 0;
510 }
511
512 STATIC s32 ixgbe_check_for_bit_pf(struct ixgbe_hw *hw, u32 mask, s32 index)
513 {
514         u32 mbvficr = IXGBE_READ_REG(hw, IXGBE_MBVFICR(index));
515         s32 ret_val = IXGBE_ERR_MBX;
516
517         if (mbvficr & mask) {
518                 ret_val = IXGBE_SUCCESS;
519                 IXGBE_WRITE_REG(hw, IXGBE_MBVFICR(index), mask);
520         }
521
522         return ret_val;
523 }
524
525 /**
526  *  ixgbe_check_for_msg_pf - checks to see if the VF has sent mail
527  *  @hw: pointer to the HW structure
528  *  @vf_number: the VF index
529  *
530  *  returns SUCCESS if the VF has set the Status bit or else ERR_MBX
531  **/
532 STATIC s32 ixgbe_check_for_msg_pf(struct ixgbe_hw *hw, u16 vf_number)
533 {
534         s32 ret_val = IXGBE_ERR_MBX;
535         s32 index = IXGBE_MBVFICR_INDEX(vf_number);
536         u32 vf_bit = vf_number % 16;
537
538         DEBUGFUNC("ixgbe_check_for_msg_pf");
539
540         if (!ixgbe_check_for_bit_pf(hw, IXGBE_MBVFICR_VFREQ_VF1 << vf_bit,
541                                     index)) {
542                 ret_val = IXGBE_SUCCESS;
543                 hw->mbx.stats.reqs++;
544         }
545
546         return ret_val;
547 }
548
549 /**
550  *  ixgbe_check_for_ack_pf - checks to see if the VF has ACKed
551  *  @hw: pointer to the HW structure
552  *  @vf_number: the VF index
553  *
554  *  returns SUCCESS if the VF has set the Status bit or else ERR_MBX
555  **/
556 STATIC s32 ixgbe_check_for_ack_pf(struct ixgbe_hw *hw, u16 vf_number)
557 {
558         s32 ret_val = IXGBE_ERR_MBX;
559         s32 index = IXGBE_MBVFICR_INDEX(vf_number);
560         u32 vf_bit = vf_number % 16;
561
562         DEBUGFUNC("ixgbe_check_for_ack_pf");
563
564         if (!ixgbe_check_for_bit_pf(hw, IXGBE_MBVFICR_VFACK_VF1 << vf_bit,
565                                     index)) {
566                 ret_val = IXGBE_SUCCESS;
567                 hw->mbx.stats.acks++;
568         }
569
570         return ret_val;
571 }
572
573 /**
574  *  ixgbe_check_for_rst_pf - checks to see if the VF has reset
575  *  @hw: pointer to the HW structure
576  *  @vf_number: the VF index
577  *
578  *  returns SUCCESS if the VF has set the Status bit or else ERR_MBX
579  **/
580 STATIC s32 ixgbe_check_for_rst_pf(struct ixgbe_hw *hw, u16 vf_number)
581 {
582         u32 reg_offset = (vf_number < 32) ? 0 : 1;
583         u32 vf_shift = vf_number % 32;
584         u32 vflre = 0;
585         s32 ret_val = IXGBE_ERR_MBX;
586
587         DEBUGFUNC("ixgbe_check_for_rst_pf");
588
589         switch (hw->mac.type) {
590         case ixgbe_mac_82599EB:
591                 vflre = IXGBE_READ_REG(hw, IXGBE_VFLRE(reg_offset));
592                 break;
593         case ixgbe_mac_X540:
594                 vflre = IXGBE_READ_REG(hw, IXGBE_VFLREC(reg_offset));
595                 break;
596         default:
597                 break;
598         }
599
600         if (vflre & (1 << vf_shift)) {
601                 ret_val = IXGBE_SUCCESS;
602                 IXGBE_WRITE_REG(hw, IXGBE_VFLREC(reg_offset), (1 << vf_shift));
603                 hw->mbx.stats.rsts++;
604         }
605
606         return ret_val;
607 }
608
609 /**
610  *  ixgbe_obtain_mbx_lock_pf - obtain mailbox lock
611  *  @hw: pointer to the HW structure
612  *  @vf_number: the VF index
613  *
614  *  return SUCCESS if we obtained the mailbox lock
615  **/
616 STATIC s32 ixgbe_obtain_mbx_lock_pf(struct ixgbe_hw *hw, u16 vf_number)
617 {
618         s32 ret_val = IXGBE_ERR_MBX;
619         u32 p2v_mailbox;
620
621         DEBUGFUNC("ixgbe_obtain_mbx_lock_pf");
622
623         /* Take ownership of the buffer */
624         IXGBE_WRITE_REG(hw, IXGBE_PFMAILBOX(vf_number), IXGBE_PFMAILBOX_PFU);
625
626         /* reserve mailbox for vf use */
627         p2v_mailbox = IXGBE_READ_REG(hw, IXGBE_PFMAILBOX(vf_number));
628         if (p2v_mailbox & IXGBE_PFMAILBOX_PFU)
629                 ret_val = IXGBE_SUCCESS;
630
631         return ret_val;
632 }
633
634 /**
635  *  ixgbe_write_mbx_pf - Places a message in the mailbox
636  *  @hw: pointer to the HW structure
637  *  @msg: The message buffer
638  *  @size: Length of buffer
639  *  @vf_number: the VF index
640  *
641  *  returns SUCCESS if it successfully copied message into the buffer
642  **/
643 STATIC s32 ixgbe_write_mbx_pf(struct ixgbe_hw *hw, u32 *msg, u16 size,
644                               u16 vf_number)
645 {
646         s32 ret_val;
647         u16 i;
648
649         DEBUGFUNC("ixgbe_write_mbx_pf");
650
651         /* lock the mailbox to prevent pf/vf race condition */
652         ret_val = ixgbe_obtain_mbx_lock_pf(hw, vf_number);
653         if (ret_val)
654                 goto out_no_write;
655
656         /* flush msg and acks as we are overwriting the message buffer */
657         ixgbe_check_for_msg_pf(hw, vf_number);
658         ixgbe_check_for_ack_pf(hw, vf_number);
659
660         /* copy the caller specified message to the mailbox memory buffer */
661         for (i = 0; i < size; i++)
662                 IXGBE_WRITE_REG_ARRAY(hw, IXGBE_PFMBMEM(vf_number), i, msg[i]);
663
664         /* Interrupt VF to tell it a message has been sent and release buffer*/
665         IXGBE_WRITE_REG(hw, IXGBE_PFMAILBOX(vf_number), IXGBE_PFMAILBOX_STS);
666
667         /* update stats */
668         hw->mbx.stats.msgs_tx++;
669
670 out_no_write:
671         return ret_val;
672
673 }
674
675 /**
676  *  ixgbe_read_mbx_pf - Read a message from the mailbox
677  *  @hw: pointer to the HW structure
678  *  @msg: The message buffer
679  *  @size: Length of buffer
680  *  @vf_number: the VF index
681  *
682  *  This function copies a message from the mailbox buffer to the caller's
683  *  memory buffer.  The presumption is that the caller knows that there was
684  *  a message due to a VF request so no polling for message is needed.
685  **/
686 STATIC s32 ixgbe_read_mbx_pf(struct ixgbe_hw *hw, u32 *msg, u16 size,
687                              u16 vf_number)
688 {
689         s32 ret_val;
690         u16 i;
691
692         DEBUGFUNC("ixgbe_read_mbx_pf");
693
694         /* lock the mailbox to prevent pf/vf race condition */
695         ret_val = ixgbe_obtain_mbx_lock_pf(hw, vf_number);
696         if (ret_val)
697                 goto out_no_read;
698
699         /* copy the message to the mailbox memory buffer */
700         for (i = 0; i < size; i++)
701                 msg[i] = IXGBE_READ_REG_ARRAY(hw, IXGBE_PFMBMEM(vf_number), i);
702
703         /* Acknowledge the message and release buffer */
704         IXGBE_WRITE_REG(hw, IXGBE_PFMAILBOX(vf_number), IXGBE_PFMAILBOX_ACK);
705
706         /* update stats */
707         hw->mbx.stats.msgs_rx++;
708
709 out_no_read:
710         return ret_val;
711 }
712
713 /**
714  *  ixgbe_init_mbx_params_pf - set initial values for pf mailbox
715  *  @hw: pointer to the HW structure
716  *
717  *  Initializes the hw->mbx struct to correct values for pf mailbox
718  */
719 void ixgbe_init_mbx_params_pf(struct ixgbe_hw *hw)
720 {
721         struct ixgbe_mbx_info *mbx = &hw->mbx;
722
723         if (hw->mac.type != ixgbe_mac_82599EB &&
724             hw->mac.type != ixgbe_mac_X540)
725                 return;
726
727         mbx->timeout = 0;
728         mbx->usec_delay = 0;
729
730         mbx->size = IXGBE_VFMAILBOX_SIZE;
731
732         mbx->ops.read = ixgbe_read_mbx_pf;
733         mbx->ops.write = ixgbe_write_mbx_pf;
734         mbx->ops.read_posted = ixgbe_read_posted_mbx;
735         mbx->ops.write_posted = ixgbe_write_posted_mbx;
736         mbx->ops.check_for_msg = ixgbe_check_for_msg_pf;
737         mbx->ops.check_for_ack = ixgbe_check_for_ack_pf;
738         mbx->ops.check_for_rst = ixgbe_check_for_rst_pf;
739
740         mbx->stats.msgs_tx = 0;
741         mbx->stats.msgs_rx = 0;
742         mbx->stats.reqs = 0;
743         mbx->stats.acks = 0;
744         mbx->stats.rsts = 0;
745 }