1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright(c) 2009 - 2018 Intel Corporation. */
3 
4 #include <linux/bitfield.h>
5 #include "mbx.h"
6 
7 /**
8  *  e1000_poll_for_msg - Wait for message notification
9  *  @hw: pointer to the HW structure
10  *
11  *  returns SUCCESS if it successfully received a message notification
12  **/
13 static s32 e1000_poll_for_msg(struct e1000_hw *hw)
14 {
15 	struct e1000_mbx_info *mbx = &hw->mbx;
16 	int countdown = mbx->timeout;
17 
18 	if (!mbx->ops.check_for_msg)
19 		goto out;
20 
21 	while (countdown && mbx->ops.check_for_msg(hw)) {
22 		countdown--;
23 		udelay(mbx->usec_delay);
24 	}
25 
26 	/* if we failed, all future posted messages fail until reset */
27 	if (!countdown)
28 		mbx->timeout = 0;
29 out:
30 	return countdown ? E1000_SUCCESS : -E1000_ERR_MBX;
31 }
32 
33 /**
34  *  e1000_poll_for_ack - Wait for message acknowledgment
35  *  @hw: pointer to the HW structure
36  *
37  *  returns SUCCESS if it successfully received a message acknowledgment
38  **/
39 static s32 e1000_poll_for_ack(struct e1000_hw *hw)
40 {
41 	struct e1000_mbx_info *mbx = &hw->mbx;
42 	int countdown = mbx->timeout;
43 
44 	if (!mbx->ops.check_for_ack)
45 		goto out;
46 
47 	while (countdown && mbx->ops.check_for_ack(hw)) {
48 		countdown--;
49 		udelay(mbx->usec_delay);
50 	}
51 
52 	/* if we failed, all future posted messages fail until reset */
53 	if (!countdown)
54 		mbx->timeout = 0;
55 out:
56 	return countdown ? E1000_SUCCESS : -E1000_ERR_MBX;
57 }
58 
59 /**
60  *  e1000_read_posted_mbx - Wait for message notification and receive message
61  *  @hw: pointer to the HW structure
62  *  @msg: The message buffer
63  *  @size: Length of buffer
64  *
65  *  returns SUCCESS if it successfully received a message notification and
66  *  copied it into the receive buffer.
67  **/
68 static s32 e1000_read_posted_mbx(struct e1000_hw *hw, u32 *msg, u16 size)
69 {
70 	struct e1000_mbx_info *mbx = &hw->mbx;
71 	s32 ret_val = -E1000_ERR_MBX;
72 
73 	if (!mbx->ops.read)
74 		goto out;
75 
76 	ret_val = e1000_poll_for_msg(hw);
77 
78 	/* if ack received read message, otherwise we timed out */
79 	if (!ret_val)
80 		ret_val = mbx->ops.read(hw, msg, size);
81 out:
82 	return ret_val;
83 }
84 
85 /**
86  *  e1000_write_posted_mbx - Write a message to the mailbox, wait for ack
87  *  @hw: pointer to the HW structure
88  *  @msg: The message buffer
89  *  @size: Length of buffer
90  *
91  *  returns SUCCESS if it successfully copied message into the buffer and
92  *  received an ack to that message within delay * timeout period
93  **/
94 static s32 e1000_write_posted_mbx(struct e1000_hw *hw, u32 *msg, u16 size)
95 {
96 	struct e1000_mbx_info *mbx = &hw->mbx;
97 	s32 ret_val = -E1000_ERR_MBX;
98 
99 	/* exit if we either can't write or there isn't a defined timeout */
100 	if (!mbx->ops.write || !mbx->timeout)
101 		goto out;
102 
103 	/* send msg*/
104 	ret_val = mbx->ops.write(hw, msg, size);
105 
106 	/* if msg sent wait until we receive an ack */
107 	if (!ret_val)
108 		ret_val = e1000_poll_for_ack(hw);
109 out:
110 	return ret_val;
111 }
112 
113 /**
114  *  e1000_read_v2p_mailbox - read v2p mailbox
115  *  @hw: pointer to the HW structure
116  *
117  *  This function is used to read the v2p mailbox without losing the read to
118  *  clear status bits.
119  **/
120 static u32 e1000_read_v2p_mailbox(struct e1000_hw *hw)
121 {
122 	u32 v2p_mailbox = er32(V2PMAILBOX(0));
123 
124 	v2p_mailbox |= hw->dev_spec.vf.v2p_mailbox;
125 	hw->dev_spec.vf.v2p_mailbox |= v2p_mailbox & E1000_V2PMAILBOX_R2C_BITS;
126 
127 	return v2p_mailbox;
128 }
129 
130 /**
131  *  e1000_check_for_bit_vf - Determine if a status bit was set
132  *  @hw: pointer to the HW structure
133  *  @mask: bitmask for bits to be tested and cleared
134  *
135  *  This function is used to check for the read to clear bits within
136  *  the V2P mailbox.
137  **/
138 static s32 e1000_check_for_bit_vf(struct e1000_hw *hw, u32 mask)
139 {
140 	u32 v2p_mailbox = e1000_read_v2p_mailbox(hw);
141 	s32 ret_val = -E1000_ERR_MBX;
142 
143 	if (v2p_mailbox & mask)
144 		ret_val = E1000_SUCCESS;
145 
146 	hw->dev_spec.vf.v2p_mailbox &= ~mask;
147 
148 	return ret_val;
149 }
150 
151 /**
152  *  e1000_check_for_msg_vf - checks to see if the PF has sent mail
153  *  @hw: pointer to the HW structure
154  *
155  *  returns SUCCESS if the PF has set the Status bit or else ERR_MBX
156  **/
157 static s32 e1000_check_for_msg_vf(struct e1000_hw *hw)
158 {
159 	s32 ret_val = -E1000_ERR_MBX;
160 
161 	if (!e1000_check_for_bit_vf(hw, E1000_V2PMAILBOX_PFSTS)) {
162 		ret_val = E1000_SUCCESS;
163 		hw->mbx.stats.reqs++;
164 	}
165 
166 	return ret_val;
167 }
168 
169 /**
170  *  e1000_check_for_ack_vf - checks to see if the PF has ACK'd
171  *  @hw: pointer to the HW structure
172  *
173  *  returns SUCCESS if the PF has set the ACK bit or else ERR_MBX
174  **/
175 static s32 e1000_check_for_ack_vf(struct e1000_hw *hw)
176 {
177 	s32 ret_val = -E1000_ERR_MBX;
178 
179 	if (!e1000_check_for_bit_vf(hw, E1000_V2PMAILBOX_PFACK)) {
180 		ret_val = E1000_SUCCESS;
181 		hw->mbx.stats.acks++;
182 	}
183 
184 	return ret_val;
185 }
186 
187 /**
188  *  e1000_check_for_rst_vf - checks to see if the PF has reset
189  *  @hw: pointer to the HW structure
190  *
191  *  returns true if the PF has set the reset done bit or else false
192  **/
193 static s32 e1000_check_for_rst_vf(struct e1000_hw *hw)
194 {
195 	s32 ret_val = -E1000_ERR_MBX;
196 
197 	if (!e1000_check_for_bit_vf(hw, (E1000_V2PMAILBOX_RSTD |
198 					 E1000_V2PMAILBOX_RSTI))) {
199 		ret_val = E1000_SUCCESS;
200 		hw->mbx.stats.rsts++;
201 	}
202 
203 	return ret_val;
204 }
205 
206 /**
207  *  e1000_obtain_mbx_lock_vf - obtain mailbox lock
208  *  @hw: pointer to the HW structure
209  *
210  *  return SUCCESS if we obtained the mailbox lock
211  **/
212 static s32 e1000_obtain_mbx_lock_vf(struct e1000_hw *hw)
213 {
214 	s32 ret_val = -E1000_ERR_MBX;
215 	int count = 10;
216 
217 	do {
218 		/* Take ownership of the buffer */
219 		ew32(V2PMAILBOX(0), E1000_V2PMAILBOX_VFU);
220 
221 		/* reserve mailbox for VF use */
222 		if (e1000_read_v2p_mailbox(hw) & E1000_V2PMAILBOX_VFU) {
223 			ret_val = 0;
224 			break;
225 		}
226 		udelay(1000);
227 	} while (count-- > 0);
228 
229 	return ret_val;
230 }
231 
232 /**
233  *  e1000_write_mbx_vf - Write a message to the mailbox
234  *  @hw: pointer to the HW structure
235  *  @msg: The message buffer
236  *  @size: Length of buffer
237  *
238  *  returns SUCCESS if it successfully copied message into the buffer
239  **/
240 static s32 e1000_write_mbx_vf(struct e1000_hw *hw, u32 *msg, u16 size)
241 {
242 	s32 err;
243 	u16 i;
244 
245 	lockdep_assert_held(&hw->mbx_lock);
246 
247 	/* lock the mailbox to prevent pf/vf race condition */
248 	err = e1000_obtain_mbx_lock_vf(hw);
249 	if (err)
250 		goto out_no_write;
251 
252 	/* flush any ack or msg as we are going to overwrite mailbox */
253 	e1000_check_for_ack_vf(hw);
254 	e1000_check_for_msg_vf(hw);
255 
256 	/* copy the caller specified message to the mailbox memory buffer */
257 	for (i = 0; i < size; i++)
258 		array_ew32(VMBMEM(0), i, msg[i]);
259 
260 	/* update stats */
261 	hw->mbx.stats.msgs_tx++;
262 
263 	/* Drop VFU and interrupt the PF to tell it a message has been sent */
264 	ew32(V2PMAILBOX(0), E1000_V2PMAILBOX_REQ);
265 
266 out_no_write:
267 	return err;
268 }
269 
270 /**
271  *  e1000_read_mbx_vf - Reads a message from the inbox intended for VF
272  *  @hw: pointer to the HW structure
273  *  @msg: The message buffer
274  *  @size: Length of buffer
275  *
276  *  returns SUCCESS if it successfully read message from buffer
277  **/
278 static s32 e1000_read_mbx_vf(struct e1000_hw *hw, u32 *msg, u16 size)
279 {
280 	s32 err;
281 	u16 i;
282 
283 	lockdep_assert_held(&hw->mbx_lock);
284 
285 	/* lock the mailbox to prevent pf/vf race condition */
286 	err = e1000_obtain_mbx_lock_vf(hw);
287 	if (err)
288 		goto out_no_read;
289 
290 	/* copy the message from the mailbox memory buffer */
291 	for (i = 0; i < size; i++)
292 		msg[i] = array_er32(VMBMEM(0), i);
293 
294 	/* Acknowledge receipt and release mailbox, then we're done */
295 	ew32(V2PMAILBOX(0), E1000_V2PMAILBOX_ACK);
296 
297 	/* update stats */
298 	hw->mbx.stats.msgs_rx++;
299 
300 out_no_read:
301 	return err;
302 }
303 
304 /**
305  *  e1000_init_mbx_params_vf - set initial values for VF mailbox
306  *  @hw: pointer to the HW structure
307  *
308  *  Initializes the hw->mbx struct to correct values for VF mailbox
309  */
310 s32 e1000_init_mbx_params_vf(struct e1000_hw *hw)
311 {
312 	struct e1000_mbx_info *mbx = &hw->mbx;
313 
314 	/* start mailbox as timed out and let the reset_hw call set the timeout
315 	 * value to being communications
316 	 */
317 	mbx->timeout = 0;
318 	mbx->usec_delay = E1000_VF_MBX_INIT_DELAY;
319 
320 	mbx->size = E1000_VFMAILBOX_SIZE;
321 
322 	mbx->ops.read = e1000_read_mbx_vf;
323 	mbx->ops.write = e1000_write_mbx_vf;
324 	mbx->ops.read_posted = e1000_read_posted_mbx;
325 	mbx->ops.write_posted = e1000_write_posted_mbx;
326 	mbx->ops.check_for_msg = e1000_check_for_msg_vf;
327 	mbx->ops.check_for_ack = e1000_check_for_ack_vf;
328 	mbx->ops.check_for_rst = e1000_check_for_rst_vf;
329 
330 	mbx->stats.msgs_tx = 0;
331 	mbx->stats.msgs_rx = 0;
332 	mbx->stats.reqs = 0;
333 	mbx->stats.acks = 0;
334 	mbx->stats.rsts = 0;
335 
336 	return E1000_SUCCESS;
337 }
338