1/*******************************************************************************
2
3Copyright (c) 2001-2015, Intel Corporation
4All rights reserved.
5
6Redistribution and use in source and binary forms, with or without
7modification, 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
20THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
24LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30POSSIBILITY OF SUCH DAMAGE.
31
32***************************************************************************/
33
34#include "e1000_mbx.h"
35
36/**
37 *  e1000_null_mbx_check_for_flag - No-op function, return 0
38 *  @hw: pointer to the HW structure
39 **/
40STATIC s32 e1000_null_mbx_check_for_flag(struct e1000_hw E1000_UNUSEDARG *hw,
41					 u16 E1000_UNUSEDARG mbx_id)
42{
43	DEBUGFUNC("e1000_null_mbx_check_flag");
44	UNREFERENCED_2PARAMETER(hw, mbx_id);
45
46	return E1000_SUCCESS;
47}
48
49/**
50 *  e1000_null_mbx_transact - No-op function, return 0
51 *  @hw: pointer to the HW structure
52 **/
53STATIC 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)
57{
58	DEBUGFUNC("e1000_null_mbx_rw_msg");
59	UNREFERENCED_4PARAMETER(hw, msg, size, mbx_id);
60
61	return E1000_SUCCESS;
62}
63
64/**
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
70 *
71 *  returns SUCCESS if it successfully read message from buffer
72 **/
73s32 e1000_read_mbx(struct e1000_hw *hw, u32 *msg, u16 size, u16 mbx_id)
74{
75	struct e1000_mbx_info *mbx = &hw->mbx;
76	s32 ret_val = -E1000_ERR_MBX;
77
78	DEBUGFUNC("e1000_read_mbx");
79
80	/* limit read to size of mailbox */
81	if (size > mbx->size)
82		size = mbx->size;
83
84	if (mbx->ops.read)
85		ret_val = mbx->ops.read(hw, msg, size, mbx_id);
86
87	return ret_val;
88}
89
90/**
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
96 *
97 *  returns SUCCESS if it successfully copied message into the buffer
98 **/
99s32 e1000_write_mbx(struct e1000_hw *hw, u32 *msg, u16 size, u16 mbx_id)
100{
101	struct e1000_mbx_info *mbx = &hw->mbx;
102	s32 ret_val = E1000_SUCCESS;
103
104	DEBUGFUNC("e1000_write_mbx");
105
106	if (size > mbx->size)
107		ret_val = -E1000_ERR_MBX;
108
109	else if (mbx->ops.write)
110		ret_val = mbx->ops.write(hw, msg, size, mbx_id);
111
112	return ret_val;
113}
114
115/**
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
119 *
120 *  returns SUCCESS if the Status bit was found or else ERR_MBX
121 **/
122s32 e1000_check_for_msg(struct e1000_hw *hw, u16 mbx_id)
123{
124	struct e1000_mbx_info *mbx = &hw->mbx;
125	s32 ret_val = -E1000_ERR_MBX;
126
127	DEBUGFUNC("e1000_check_for_msg");
128
129	if (mbx->ops.check_for_msg)
130		ret_val = mbx->ops.check_for_msg(hw, mbx_id);
131
132	return ret_val;
133}
134
135/**
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
139 *
140 *  returns SUCCESS if the Status bit was found or else ERR_MBX
141 **/
142s32 e1000_check_for_ack(struct e1000_hw *hw, u16 mbx_id)
143{
144	struct e1000_mbx_info *mbx = &hw->mbx;
145	s32 ret_val = -E1000_ERR_MBX;
146
147	DEBUGFUNC("e1000_check_for_ack");
148
149	if (mbx->ops.check_for_ack)
150		ret_val = mbx->ops.check_for_ack(hw, mbx_id);
151
152	return ret_val;
153}
154
155/**
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
159 *
160 *  returns SUCCESS if the Status bit was found or else ERR_MBX
161 **/
162s32 e1000_check_for_rst(struct e1000_hw *hw, u16 mbx_id)
163{
164	struct e1000_mbx_info *mbx = &hw->mbx;
165	s32 ret_val = -E1000_ERR_MBX;
166
167	DEBUGFUNC("e1000_check_for_rst");
168
169	if (mbx->ops.check_for_rst)
170		ret_val = mbx->ops.check_for_rst(hw, mbx_id);
171
172	return ret_val;
173}
174
175/**
176 *  e1000_poll_for_msg - Wait for message notification
177 *  @hw: pointer to the HW structure
178 *  @mbx_id: id of mailbox to write
179 *
180 *  returns SUCCESS if it successfully received a message notification
181 **/
182STATIC s32 e1000_poll_for_msg(struct e1000_hw *hw, u16 mbx_id)
183{
184	struct e1000_mbx_info *mbx = &hw->mbx;
185	int countdown = mbx->timeout;
186
187	DEBUGFUNC("e1000_poll_for_msg");
188
189	if (!countdown || !mbx->ops.check_for_msg)
190		goto out;
191
192	while (countdown && mbx->ops.check_for_msg(hw, mbx_id)) {
193		countdown--;
194		if (!countdown)
195			break;
196		usec_delay(mbx->usec_delay);
197	}
198
199	/* if we failed, all future posted messages fail until reset */
200	if (!countdown)
201		mbx->timeout = 0;
202out:
203	return countdown ? E1000_SUCCESS : -E1000_ERR_MBX;
204}
205
206/**
207 *  e1000_poll_for_ack - Wait for message acknowledgement
208 *  @hw: pointer to the HW structure
209 *  @mbx_id: id of mailbox to write
210 *
211 *  returns SUCCESS if it successfully received a message acknowledgement
212 **/
213STATIC s32 e1000_poll_for_ack(struct e1000_hw *hw, u16 mbx_id)
214{
215	struct e1000_mbx_info *mbx = &hw->mbx;
216	int countdown = mbx->timeout;
217
218	DEBUGFUNC("e1000_poll_for_ack");
219
220	if (!countdown || !mbx->ops.check_for_ack)
221		goto out;
222
223	while (countdown && mbx->ops.check_for_ack(hw, mbx_id)) {
224		countdown--;
225		if (!countdown)
226			break;
227		usec_delay(mbx->usec_delay);
228	}
229
230	/* if we failed, all future posted messages fail until reset */
231	if (!countdown)
232		mbx->timeout = 0;
233out:
234	return countdown ? E1000_SUCCESS : -E1000_ERR_MBX;
235}
236
237/**
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
243 *
244 *  returns SUCCESS if it successfully received a message notification and
245 *  copied it into the receive buffer.
246 **/
247s32 e1000_read_posted_mbx(struct e1000_hw *hw, u32 *msg, u16 size, u16 mbx_id)
248{
249	struct e1000_mbx_info *mbx = &hw->mbx;
250	s32 ret_val = -E1000_ERR_MBX;
251
252	DEBUGFUNC("e1000_read_posted_mbx");
253
254	if (!mbx->ops.read)
255		goto out;
256
257	ret_val = e1000_poll_for_msg(hw, mbx_id);
258
259	/* if ack received read message, otherwise we timed out */
260	if (!ret_val)
261		ret_val = mbx->ops.read(hw, msg, size, mbx_id);
262out:
263	return ret_val;
264}
265
266/**
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
272 *
273 *  returns SUCCESS if it successfully copied message into the buffer and
274 *  received an ack to that message within delay * timeout period
275 **/
276s32 e1000_write_posted_mbx(struct e1000_hw *hw, u32 *msg, u16 size, u16 mbx_id)
277{
278	struct e1000_mbx_info *mbx = &hw->mbx;
279	s32 ret_val = -E1000_ERR_MBX;
280
281	DEBUGFUNC("e1000_write_posted_mbx");
282
283	/* exit if either we can't write or there isn't a defined timeout */
284	if (!mbx->ops.write || !mbx->timeout)
285		goto out;
286
287	/* send msg */
288	ret_val = mbx->ops.write(hw, msg, size, mbx_id);
289
290	/* if msg sent wait until we receive an ack */
291	if (!ret_val)
292		ret_val = e1000_poll_for_ack(hw, mbx_id);
293out:
294	return ret_val;
295}
296
297/**
298 *  e1000_init_mbx_ops_generic - Initialize mbx function pointers
299 *  @hw: pointer to the HW structure
300 *
301 *  Sets the function pointers to no-op functions
302 **/
303void e1000_init_mbx_ops_generic(struct e1000_hw *hw)
304{
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;
314}
315
316/**
317 *  e1000_read_v2p_mailbox - read v2p mailbox
318 *  @hw: pointer to the HW structure
319 *
320 *  This function is used to read the v2p mailbox without losing the read to
321 *  clear status bits.
322 **/
323STATIC u32 e1000_read_v2p_mailbox(struct e1000_hw *hw)
324{
325	u32 v2p_mailbox = E1000_READ_REG(hw, E1000_V2PMAILBOX(0));
326
327	v2p_mailbox |= hw->dev_spec.vf.v2p_mailbox;
328	hw->dev_spec.vf.v2p_mailbox |= v2p_mailbox & E1000_V2PMAILBOX_R2C_BITS;
329
330	return v2p_mailbox;
331}
332
333/**
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
337 *
338 *  This function is used to check for the read to clear bits within
339 *  the V2P mailbox.
340 **/
341STATIC s32 e1000_check_for_bit_vf(struct e1000_hw *hw, u32 mask)
342{
343	u32 v2p_mailbox = e1000_read_v2p_mailbox(hw);
344	s32 ret_val = -E1000_ERR_MBX;
345
346	if (v2p_mailbox & mask)
347		ret_val = E1000_SUCCESS;
348
349	hw->dev_spec.vf.v2p_mailbox &= ~mask;
350
351	return ret_val;
352}
353
354/**
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
358 *
359 *  returns SUCCESS if the PF has set the Status bit or else ERR_MBX
360 **/
361STATIC s32 e1000_check_for_msg_vf(struct e1000_hw *hw,
362				  u16 E1000_UNUSEDARG mbx_id)
363{
364	s32 ret_val = -E1000_ERR_MBX;
365
366	UNREFERENCED_1PARAMETER(mbx_id);
367	DEBUGFUNC("e1000_check_for_msg_vf");
368
369	if (!e1000_check_for_bit_vf(hw, E1000_V2PMAILBOX_PFSTS)) {
370		ret_val = E1000_SUCCESS;
371		hw->mbx.stats.reqs++;
372	}
373
374	return ret_val;
375}
376
377/**
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
381 *
382 *  returns SUCCESS if the PF has set the ACK bit or else ERR_MBX
383 **/
384STATIC s32 e1000_check_for_ack_vf(struct e1000_hw *hw,
385				  u16 E1000_UNUSEDARG mbx_id)
386{
387	s32 ret_val = -E1000_ERR_MBX;
388
389	UNREFERENCED_1PARAMETER(mbx_id);
390	DEBUGFUNC("e1000_check_for_ack_vf");
391
392	if (!e1000_check_for_bit_vf(hw, E1000_V2PMAILBOX_PFACK)) {
393		ret_val = E1000_SUCCESS;
394		hw->mbx.stats.acks++;
395	}
396
397	return ret_val;
398}
399
400/**
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
404 *
405 *  returns true if the PF has set the reset done bit or else false
406 **/
407STATIC s32 e1000_check_for_rst_vf(struct e1000_hw *hw,
408				  u16 E1000_UNUSEDARG mbx_id)
409{
410	s32 ret_val = -E1000_ERR_MBX;
411
412	UNREFERENCED_1PARAMETER(mbx_id);
413	DEBUGFUNC("e1000_check_for_rst_vf");
414
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++;
419	}
420
421	return ret_val;
422}
423
424/**
425 *  e1000_obtain_mbx_lock_vf - obtain mailbox lock
426 *  @hw: pointer to the HW structure
427 *
428 *  return SUCCESS if we obtained the mailbox lock
429 **/
430STATIC s32 e1000_obtain_mbx_lock_vf(struct e1000_hw *hw)
431{
432	s32 ret_val = -E1000_ERR_MBX;
433	int count = 10;
434
435	DEBUGFUNC("e1000_obtain_mbx_lock_vf");
436
437	do {
438		/* Take ownership of the buffer */
439		E1000_WRITE_REG(hw, E1000_V2PMAILBOX(0), E1000_V2PMAILBOX_VFU);
440
441		/* reserve mailbox for vf use */
442		if (e1000_read_v2p_mailbox(hw) & E1000_V2PMAILBOX_VFU) {
443			ret_val = E1000_SUCCESS;
444			break;
445		}
446		usec_delay(1000);
447	} while (count-- > 0);
448
449	return ret_val;
450}
451
452/**
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
458 *
459 *  returns SUCCESS if it successfully copied message into the buffer
460 **/
461STATIC s32 e1000_write_mbx_vf(struct e1000_hw *hw, u32 *msg, u16 size,
462			      u16 E1000_UNUSEDARG mbx_id)
463{
464	s32 ret_val;
465	u16 i;
466
467	UNREFERENCED_1PARAMETER(mbx_id);
468
469	DEBUGFUNC("e1000_write_mbx_vf");
470
471	/* lock the mailbox to prevent pf/vf race condition */
472	ret_val = e1000_obtain_mbx_lock_vf(hw);
473	if (ret_val)
474		goto out_no_write;
475
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);
479
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]);
483
484	/* update stats */
485	hw->mbx.stats.msgs_tx++;
486
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);
489
490out_no_write:
491	return ret_val;
492}
493
494/**
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
500 *
501 *  returns SUCCESS if it successfully read message from buffer
502 **/
503STATIC s32 e1000_read_mbx_vf(struct e1000_hw *hw, u32 *msg, u16 size,
504			     u16 E1000_UNUSEDARG mbx_id)
505{
506	s32 ret_val = E1000_SUCCESS;
507	u16 i;
508
509	DEBUGFUNC("e1000_read_mbx_vf");
510	UNREFERENCED_1PARAMETER(mbx_id);
511
512	/* lock the mailbox to prevent pf/vf race condition */
513	ret_val = e1000_obtain_mbx_lock_vf(hw);
514	if (ret_val)
515		goto out_no_read;
516
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);
520
521	/* Acknowledge receipt and release mailbox, then we're done */
522	E1000_WRITE_REG(hw, E1000_V2PMAILBOX(0), E1000_V2PMAILBOX_ACK);
523
524	/* update stats */
525	hw->mbx.stats.msgs_rx++;
526
527out_no_read:
528	return ret_val;
529}
530
531/**
532 *  e1000_init_mbx_params_vf - set initial values for vf mailbox
533 *  @hw: pointer to the HW structure
534 *
535 *  Initializes the hw->mbx struct to correct values for vf mailbox
536 */
537s32 e1000_init_mbx_params_vf(struct e1000_hw *hw)
538{
539	struct e1000_mbx_info *mbx = &hw->mbx;
540
541	/* start mailbox as timed out and let the reset_hw call set the timeout
542	 * value to begin communications */
543	mbx->timeout = 0;
544	mbx->usec_delay = E1000_VF_MBX_INIT_DELAY;
545
546	mbx->size = E1000_VFMAILBOX_SIZE;
547
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;
555
556	mbx->stats.msgs_tx = 0;
557	mbx->stats.msgs_rx = 0;
558	mbx->stats.reqs = 0;
559	mbx->stats.acks = 0;
560	mbx->stats.rsts = 0;
561
562	return E1000_SUCCESS;
563}
564
565STATIC s32 e1000_check_for_bit_pf(struct e1000_hw *hw, u32 mask)
566{
567	u32 mbvficr = E1000_READ_REG(hw, E1000_MBVFICR);
568	s32 ret_val = -E1000_ERR_MBX;
569
570	if (mbvficr & mask) {
571		ret_val = E1000_SUCCESS;
572		E1000_WRITE_REG(hw, E1000_MBVFICR, mask);
573	}
574
575	return ret_val;
576}
577
578/**
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
582 *
583 *  returns SUCCESS if the VF has set the Status bit or else ERR_MBX
584 **/
585STATIC s32 e1000_check_for_msg_pf(struct e1000_hw *hw, u16 vf_number)
586{
587	s32 ret_val = -E1000_ERR_MBX;
588
589	DEBUGFUNC("e1000_check_for_msg_pf");
590
591	if (!e1000_check_for_bit_pf(hw, E1000_MBVFICR_VFREQ_VF1 << vf_number)) {
592		ret_val = E1000_SUCCESS;
593		hw->mbx.stats.reqs++;
594	}
595
596	return ret_val;
597}
598
599/**
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
603 *
604 *  returns SUCCESS if the VF has set the Status bit or else ERR_MBX
605 **/
606STATIC s32 e1000_check_for_ack_pf(struct e1000_hw *hw, u16 vf_number)
607{
608	s32 ret_val = -E1000_ERR_MBX;
609
610	DEBUGFUNC("e1000_check_for_ack_pf");
611
612	if (!e1000_check_for_bit_pf(hw, E1000_MBVFICR_VFACK_VF1 << vf_number)) {
613		ret_val = E1000_SUCCESS;
614		hw->mbx.stats.acks++;
615	}
616
617	return ret_val;
618}
619
620/**
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
624 *
625 *  returns SUCCESS if the VF has set the Status bit or else ERR_MBX
626 **/
627STATIC s32 e1000_check_for_rst_pf(struct e1000_hw *hw, u16 vf_number)
628{
629	u32 vflre = E1000_READ_REG(hw, E1000_VFLRE);
630	s32 ret_val = -E1000_ERR_MBX;
631
632	DEBUGFUNC("e1000_check_for_rst_pf");
633
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++;
638	}
639
640	return ret_val;
641}
642
643/**
644 *  e1000_obtain_mbx_lock_pf - obtain mailbox lock
645 *  @hw: pointer to the HW structure
646 *  @vf_number: the VF index
647 *
648 *  return SUCCESS if we obtained the mailbox lock
649 **/
650STATIC s32 e1000_obtain_mbx_lock_pf(struct e1000_hw *hw, u16 vf_number)
651{
652	s32 ret_val = -E1000_ERR_MBX;
653	u32 p2v_mailbox;
654	int count = 10;
655
656	DEBUGFUNC("e1000_obtain_mbx_lock_pf");
657
658	do {
659		/* Take ownership of the buffer */
660		E1000_WRITE_REG(hw, E1000_P2VMAILBOX(vf_number),
661				E1000_P2VMAILBOX_PFU);
662
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;
667			break;
668		}
669		usec_delay(1000);
670	} while (count-- > 0);
671
672	return ret_val;
673
674}
675
676/**
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
682 *
683 *  returns SUCCESS if it successfully copied message into the buffer
684 **/
685STATIC s32 e1000_write_mbx_pf(struct e1000_hw *hw, u32 *msg, u16 size,
686			      u16 vf_number)
687{
688	s32 ret_val;
689	u16 i;
690
691	DEBUGFUNC("e1000_write_mbx_pf");
692
693	/* lock the mailbox to prevent pf/vf race condition */
694	ret_val = e1000_obtain_mbx_lock_pf(hw, vf_number);
695	if (ret_val)
696		goto out_no_write;
697
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);
701
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]);
705
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);
708
709	/* update stats */
710	hw->mbx.stats.msgs_tx++;
711
712out_no_write:
713	return ret_val;
714
715}
716
717/**
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
723 *
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.
727 **/
728STATIC s32 e1000_read_mbx_pf(struct e1000_hw *hw, u32 *msg, u16 size,
729			     u16 vf_number)
730{
731	s32 ret_val;
732	u16 i;
733
734	DEBUGFUNC("e1000_read_mbx_pf");
735
736	/* lock the mailbox to prevent pf/vf race condition */
737	ret_val = e1000_obtain_mbx_lock_pf(hw, vf_number);
738	if (ret_val)
739		goto out_no_read;
740
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);
744
745	/* Acknowledge the message and release buffer */
746	E1000_WRITE_REG(hw, E1000_P2VMAILBOX(vf_number), E1000_P2VMAILBOX_ACK);
747
748	/* update stats */
749	hw->mbx.stats.msgs_rx++;
750
751out_no_read:
752	return ret_val;
753}
754
755/**
756 *  e1000_init_mbx_params_pf - set initial values for pf mailbox
757 *  @hw: pointer to the HW structure
758 *
759 *  Initializes the hw->mbx struct to correct values for pf mailbox
760 */
761s32 e1000_init_mbx_params_pf(struct e1000_hw *hw)
762{
763	struct e1000_mbx_info *mbx = &hw->mbx;
764
765	switch (hw->mac.type) {
766	case e1000_82576:
767	case e1000_i350:
768	case e1000_i354:
769		mbx->timeout = 0;
770		mbx->usec_delay = 0;
771
772		mbx->size = E1000_VFMAILBOX_SIZE;
773
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;
781
782		mbx->stats.msgs_tx = 0;
783		mbx->stats.msgs_rx = 0;
784		mbx->stats.reqs = 0;
785		mbx->stats.acks = 0;
786		mbx->stats.rsts = 0;
787	default:
788		return E1000_SUCCESS;
789	}
790}
791
792