1	// SPDX-License-Identifier: GPL-2.0
2	/* Copyright(c) 2013 - 2019 Intel Corporation. */
3
4	#include "fm10k_common.h"
5
6	/**
7	* fm10k_fifo_init - Initialize a message FIFO
8	* @fifo: pointer to FIFO
9	* @buffer: pointer to memory to be used to store FIFO
10	* @size: maximum message size to store in FIFO, must be 2^n - 1
11	**/
12	static void fm10k_fifo_init(struct fm10k_mbx_fifo *fifo, u32 *buffer, u16 size)
13	{
14	fifo->buffer = buffer;
15	fifo->size = size;
16	fifo->head = 0;
17	fifo->tail = 0;
18	}
19
20	/**
21	* fm10k_fifo_used - Retrieve used space in FIFO
22	* @fifo: pointer to FIFO
23	*
24	* This function returns the number of DWORDs used in the FIFO
25	**/
26	static u16 fm10k_fifo_used(struct fm10k_mbx_fifo *fifo)
27	{
28	return fifo->tail - fifo->head;
29	}
30
31	/**
32	* fm10k_fifo_unused - Retrieve unused space in FIFO
33	* @fifo: pointer to FIFO
34	*
35	* This function returns the number of unused DWORDs in the FIFO
36	**/
37	static u16 fm10k_fifo_unused(struct fm10k_mbx_fifo *fifo)
38	{
39	return fifo->size + fifo->head - fifo->tail;
40	}
41
42	/**
43	* fm10k_fifo_empty - Test to verify if FIFO is empty
44	* @fifo: pointer to FIFO
45	*
46	* This function returns true if the FIFO is empty, else false
47	**/
48	static bool fm10k_fifo_empty(struct fm10k_mbx_fifo *fifo)
49	{
50	return fifo->head == fifo->tail;
51	}
52
53	/**
54	* fm10k_fifo_head_offset - returns indices of head with given offset
55	* @fifo: pointer to FIFO
56	* @offset: offset to add to head
57	*
58	* This function returns the indices into the FIFO based on head + offset
59	**/
60	static u16 fm10k_fifo_head_offset(struct fm10k_mbx_fifo *fifo, u16 offset)
61	{
62	return (fifo->head + offset) & (fifo->size - 1);
63	}
64
65	/**
66	* fm10k_fifo_tail_offset - returns indices of tail with given offset
67	* @fifo: pointer to FIFO
68	* @offset: offset to add to tail
69	*
70	* This function returns the indices into the FIFO based on tail + offset
71	**/
72	static u16 fm10k_fifo_tail_offset(struct fm10k_mbx_fifo *fifo, u16 offset)
73	{
74	return (fifo->tail + offset) & (fifo->size - 1);
75	}
76
77	/**
78	* fm10k_fifo_head_len - Retrieve length of first message in FIFO
79	* @fifo: pointer to FIFO
80	*
81	* This function returns the size of the first message in the FIFO
82	**/
83	static u16 fm10k_fifo_head_len(struct fm10k_mbx_fifo *fifo)
84	{
85	u32 *head = fifo->buffer + fm10k_fifo_head_offset(fifo, offset: 0);
86
87	/* verify there is at least 1 DWORD in the fifo so *head is valid */
88	if (fm10k_fifo_empty(fifo))
89	return 0;
90
91	/* retieve the message length */
92	return FM10K_TLV_DWORD_LEN(*head);
93	}
94
95	/**
96	* fm10k_fifo_head_drop - Drop the first message in FIFO
97	* @fifo: pointer to FIFO
98	*
99	* This function returns the size of the message dropped from the FIFO
100	**/
101	static u16 fm10k_fifo_head_drop(struct fm10k_mbx_fifo *fifo)
102	{
103	u16 len = fm10k_fifo_head_len(fifo);
104
105	/* update head so it is at the start of next frame */
106	fifo->head += len;
107
108	return len;
109	}
110
111	/**
112	* fm10k_fifo_drop_all - Drop all messages in FIFO
113	* @fifo: pointer to FIFO
114	*
115	* This function resets the head pointer to drop all messages in the FIFO and
116	* ensure the FIFO is empty.
117	**/
118	static void fm10k_fifo_drop_all(struct fm10k_mbx_fifo *fifo)
119	{
120	fifo->head = fifo->tail;
121	}
122
123	/**
124	* fm10k_mbx_index_len - Convert a head/tail index into a length value
125	* @mbx: pointer to mailbox
126	* @head: head index
127	* @tail: head index
128	*
129	* This function takes the head and tail index and determines the length
130	* of the data indicated by this pair.
131	**/
132	static u16 fm10k_mbx_index_len(struct fm10k_mbx_info *mbx, u16 head, u16 tail)
133	{
134	u16 len = tail - head;
135
136	/* we wrapped so subtract 2, one for index 0, one for all 1s index */
137	if (len > tail)
138	len -= 2;
139
140	return len & ((mbx->mbmem_len << 1) - 1);
141	}
142
143	/**
144	* fm10k_mbx_tail_add - Determine new tail value with added offset
145	* @mbx: pointer to mailbox
146	* @offset: length to add to tail offset
147	*
148	* This function takes the local tail index and recomputes it for
149	* a given length added as an offset.
150	**/
151	static u16 fm10k_mbx_tail_add(struct fm10k_mbx_info *mbx, u16 offset)
152	{
153	u16 tail = (mbx->tail + offset + 1) & ((mbx->mbmem_len << 1) - 1);
154
155	/* add/sub 1 because we cannot have offset 0 or all 1s */
156	return (tail > mbx->tail) ? --tail : ++tail;
157	}
158
159	/**
160	* fm10k_mbx_tail_sub - Determine new tail value with subtracted offset
161	* @mbx: pointer to mailbox
162	* @offset: length to add to tail offset
163	*
164	* This function takes the local tail index and recomputes it for
165	* a given length added as an offset.
166	**/
167	static u16 fm10k_mbx_tail_sub(struct fm10k_mbx_info *mbx, u16 offset)
168	{
169	u16 tail = (mbx->tail - offset - 1) & ((mbx->mbmem_len << 1) - 1);
170
171	/* sub/add 1 because we cannot have offset 0 or all 1s */
172	return (tail < mbx->tail) ? ++tail : --tail;
173	}
174
175	/**
176	* fm10k_mbx_head_add - Determine new head value with added offset
177	* @mbx: pointer to mailbox
178	* @offset: length to add to head offset
179	*
180	* This function takes the local head index and recomputes it for
181	* a given length added as an offset.
182	**/
183	static u16 fm10k_mbx_head_add(struct fm10k_mbx_info *mbx, u16 offset)
184	{
185	u16 head = (mbx->head + offset + 1) & ((mbx->mbmem_len << 1) - 1);
186
187	/* add/sub 1 because we cannot have offset 0 or all 1s */
188	return (head > mbx->head) ? --head : ++head;
189	}
190
191	/**
192	* fm10k_mbx_head_sub - Determine new head value with subtracted offset
193	* @mbx: pointer to mailbox
194	* @offset: length to add to head offset
195	*
196	* This function takes the local head index and recomputes it for
197	* a given length added as an offset.
198	**/
199	static u16 fm10k_mbx_head_sub(struct fm10k_mbx_info *mbx, u16 offset)
200	{
201	u16 head = (mbx->head - offset - 1) & ((mbx->mbmem_len << 1) - 1);
202
203	/* sub/add 1 because we cannot have offset 0 or all 1s */
204	return (head < mbx->head) ? ++head : --head;
205	}
206
207	/**
208	* fm10k_mbx_pushed_tail_len - Retrieve the length of message being pushed
209	* @mbx: pointer to mailbox
210	*
211	* This function will return the length of the message currently being
212	* pushed onto the tail of the Rx queue.
213	**/
214	static u16 fm10k_mbx_pushed_tail_len(struct fm10k_mbx_info *mbx)
215	{
216	u32 *tail = mbx->rx.buffer + fm10k_fifo_tail_offset(fifo: &mbx->rx, offset: 0);
217
218	/* pushed tail is only valid if pushed is set */
219	if (!mbx->pushed)
220	return 0;
221
222	return FM10K_TLV_DWORD_LEN(*tail);
223	}
224
225	/**
226	* fm10k_fifo_write_copy - pulls data off of msg and places it in FIFO
227	* @fifo: pointer to FIFO
228	* @msg: message array to populate
229	* @tail_offset: additional offset to add to tail pointer
230	* @len: length of FIFO to copy into message header
231	*
232	* This function will take a message and copy it into a section of the
233	* FIFO. In order to get something into a location other than just
234	* the tail you can use tail_offset to adjust the pointer.
235	**/
236	static void fm10k_fifo_write_copy(struct fm10k_mbx_fifo *fifo,
237	const u32 *msg, u16 tail_offset, u16 len)
238	{
239	u16 end = fm10k_fifo_tail_offset(fifo, offset: tail_offset);
240	u32 *tail = fifo->buffer + end;
241
242	/* track when we should cross the end of the FIFO */
243	end = fifo->size - end;
244
245	/* copy end of message before start of message */
246	if (end < len)
247	memcpy(fifo->buffer, msg + end, (len - end) << 2);
248	else
249	end = len;
250
251	/* Copy remaining message into Tx FIFO */
252	memcpy(tail, msg, end << 2);
253	}
254
255	/**
256	* fm10k_fifo_enqueue - Enqueues the message to the tail of the FIFO
257	* @fifo: pointer to FIFO
258	* @msg: message array to read
259	*
260	* This function enqueues a message up to the size specified by the length
261	* contained in the first DWORD of the message and will place at the tail
262	* of the FIFO. It will return 0 on success, or a negative value on error.
263	**/
264	static s32 fm10k_fifo_enqueue(struct fm10k_mbx_fifo *fifo, const u32 *msg)
265	{
266	u16 len = FM10K_TLV_DWORD_LEN(*msg);
267
268	/* verify parameters */
269	if (len > fifo->size)
270	return FM10K_MBX_ERR_SIZE;
271
272	/* verify there is room for the message */
273	if (len > fm10k_fifo_unused(fifo))
274	return FM10K_MBX_ERR_NO_SPACE;
275
276	/* Copy message into FIFO */
277	fm10k_fifo_write_copy(fifo, msg, tail_offset: 0, len);
278
279	/* memory barrier to guarantee FIFO is written before tail update */
280	wmb();
281
282	/* Update Tx FIFO tail */
283	fifo->tail += len;
284
285	return 0;
286	}
287
288	/**
289	* fm10k_mbx_validate_msg_size - Validate incoming message based on size
290	* @mbx: pointer to mailbox
291	* @len: length of data pushed onto buffer
292	*
293	* This function analyzes the frame and will return a non-zero value when
294	* the start of a message larger than the mailbox is detected.
295	**/
296	static u16 fm10k_mbx_validate_msg_size(struct fm10k_mbx_info *mbx, u16 len)
297	{
298	struct fm10k_mbx_fifo *fifo = &mbx->rx;
299	u16 total_len = 0, msg_len;
300
301	/* length should include previous amounts pushed */
302	len += mbx->pushed;
303
304	/* offset in message is based off of current message size */
305	do {
306	u32 *msg;
307
308	msg = fifo->buffer + fm10k_fifo_tail_offset(fifo, offset: total_len);
309	msg_len = FM10K_TLV_DWORD_LEN(*msg);
310	total_len += msg_len;
311	} while (total_len < len);
312
313	/* message extends out of pushed section, but fits in FIFO */
314	if ((len < total_len) && (msg_len <= mbx->max_size))
315	return 0;
316
317	/* return length of invalid section */
318	return (len < total_len) ? len : (len - total_len);
319	}
320
321	/**
322	* fm10k_mbx_write_copy - pulls data off of Tx FIFO and places it in mbmem
323	* @hw: pointer to hardware structure
324	* @mbx: pointer to mailbox
325	*
326	* This function will take a section of the Tx FIFO and copy it into the
327	* mailbox memory. The offset in mbmem is based on the lower bits of the
328	* tail and len determines the length to copy.
329	**/
330	static void fm10k_mbx_write_copy(struct fm10k_hw *hw,
331	struct fm10k_mbx_info *mbx)
332	{
333	struct fm10k_mbx_fifo *fifo = &mbx->tx;
334	u32 mbmem = mbx->mbmem_reg;
335	u32 *head = fifo->buffer;
336	u16 end, len, tail, mask;
337
338	if (!mbx->tail_len)
339	return;
340
341	/* determine data length and mbmem tail index */
342	mask = mbx->mbmem_len - 1;
343	len = mbx->tail_len;
344	tail = fm10k_mbx_tail_sub(mbx, offset: len);
345	if (tail > mask)
346	tail++;
347
348	/* determine offset in the ring */
349	end = fm10k_fifo_head_offset(fifo, offset: mbx->pulled);
350	head += end;
351
352	/* memory barrier to guarantee data is ready to be read */
353	rmb();
354
355	/* Copy message from Tx FIFO */
356	for (end = fifo->size - end; len; head = fifo->buffer) {
357	do {
358	/* adjust tail to match offset for FIFO */
359	tail &= mask;
360	if (!tail)
361	tail++;
362
363	mbx->tx_mbmem_pulled++;
364
365	/* write message to hardware FIFO */
366	fm10k_write_reg(hw, mbmem + tail++, *(head++));
367	} while (--len && --end);
368	}
369	}
370
371	/**
372	* fm10k_mbx_pull_head - Pulls data off of head of Tx FIFO
373	* @hw: pointer to hardware structure
374	* @mbx: pointer to mailbox
375	* @head: acknowledgement number last received
376	*
377	* This function will push the tail index forward based on the remote
378	* head index. It will then pull up to mbmem_len DWORDs off of the
379	* head of the FIFO and will place it in the MBMEM registers
380	* associated with the mailbox.
381	**/
382	static void fm10k_mbx_pull_head(struct fm10k_hw *hw,
383	struct fm10k_mbx_info *mbx, u16 head)
384	{
385	u16 mbmem_len, len, ack = fm10k_mbx_index_len(mbx, head, tail: mbx->tail);
386	struct fm10k_mbx_fifo *fifo = &mbx->tx;
387
388	/* update number of bytes pulled and update bytes in transit */
389	mbx->pulled += mbx->tail_len - ack;
390
391	/* determine length of data to pull, reserve space for mbmem header */
392	mbmem_len = mbx->mbmem_len - 1;
393	len = fm10k_fifo_used(fifo) - mbx->pulled;
394	if (len > mbmem_len)
395	len = mbmem_len;
396
397	/* update tail and record number of bytes in transit */
398	mbx->tail = fm10k_mbx_tail_add(mbx, offset: len - ack);
399	mbx->tail_len = len;
400
401	/* drop pulled messages from the FIFO */
402	for (len = fm10k_fifo_head_len(fifo);
403	len && (mbx->pulled >= len);
404	len = fm10k_fifo_head_len(fifo)) {
405	mbx->pulled -= fm10k_fifo_head_drop(fifo);
406	mbx->tx_messages++;
407	mbx->tx_dwords += len;
408	}
409
410	/* Copy message out from the Tx FIFO */
411	fm10k_mbx_write_copy(hw, mbx);
412	}
413
414	/**
415	* fm10k_mbx_read_copy - pulls data off of mbmem and places it in Rx FIFO
416	* @hw: pointer to hardware structure
417	* @mbx: pointer to mailbox
418	*
419	* This function will take a section of the mailbox memory and copy it
420	* into the Rx FIFO. The offset is based on the lower bits of the
421	* head and len determines the length to copy.
422	**/
423	static void fm10k_mbx_read_copy(struct fm10k_hw *hw,
424	struct fm10k_mbx_info *mbx)
425	{
426	struct fm10k_mbx_fifo *fifo = &mbx->rx;
427	u32 mbmem = mbx->mbmem_reg ^ mbx->mbmem_len;
428	u32 *tail = fifo->buffer;
429	u16 end, len, head;
430
431	/* determine data length and mbmem head index */
432	len = mbx->head_len;
433	head = fm10k_mbx_head_sub(mbx, offset: len);
434	if (head >= mbx->mbmem_len)
435	head++;
436
437	/* determine offset in the ring */
438	end = fm10k_fifo_tail_offset(fifo, offset: mbx->pushed);
439	tail += end;
440
441	/* Copy message into Rx FIFO */
442	for (end = fifo->size - end; len; tail = fifo->buffer) {
443	do {
444	/* adjust head to match offset for FIFO */
445	head &= mbx->mbmem_len - 1;
446	if (!head)
447	head++;
448
449	mbx->rx_mbmem_pushed++;
450
451	/* read message from hardware FIFO */
452	*(tail++) = fm10k_read_reg(hw, reg: mbmem + head++);
453	} while (--len && --end);
454	}
455
456	/* memory barrier to guarantee FIFO is written before tail update */
457	wmb();
458	}
459
460	/**
461	* fm10k_mbx_push_tail - Pushes up to 15 DWORDs on to tail of FIFO
462	* @hw: pointer to hardware structure
463	* @mbx: pointer to mailbox
464	* @tail: tail index of message
465	*
466	* This function will first validate the tail index and size for the
467	* incoming message. It then updates the acknowledgment number and
468	* copies the data into the FIFO. It will return the number of messages
469	* dequeued on success and a negative value on error.
470	**/
471	static s32 fm10k_mbx_push_tail(struct fm10k_hw *hw,
472	struct fm10k_mbx_info *mbx,
473	u16 tail)
474	{
475	struct fm10k_mbx_fifo *fifo = &mbx->rx;
476	u16 len, seq = fm10k_mbx_index_len(mbx, head: mbx->head, tail);
477
478	/* determine length of data to push */
479	len = fm10k_fifo_unused(fifo) - mbx->pushed;
480	if (len > seq)
481	len = seq;
482
483	/* update head and record bytes received */
484	mbx->head = fm10k_mbx_head_add(mbx, offset: len);
485	mbx->head_len = len;
486
487	/* nothing to do if there is no data */
488	if (!len)
489	return 0;
490
491	/* Copy msg into Rx FIFO */
492	fm10k_mbx_read_copy(hw, mbx);
493
494	/* determine if there are any invalid lengths in message */
495	if (fm10k_mbx_validate_msg_size(mbx, len))
496	return FM10K_MBX_ERR_SIZE;
497
498	/* Update pushed */
499	mbx->pushed += len;
500
501	/* flush any completed messages */
502	for (len = fm10k_mbx_pushed_tail_len(mbx);
503	len && (mbx->pushed >= len);
504	len = fm10k_mbx_pushed_tail_len(mbx)) {
505	fifo->tail += len;
506	mbx->pushed -= len;
507	mbx->rx_messages++;
508	mbx->rx_dwords += len;
509	}
510
511	return 0;
512	}
513
514	/* pre-generated data for generating the CRC based on the poly 0xAC9A. */
515	static const u16 fm10k_crc_16b_table[256] = {
516	0x0000, 0x7956, 0xF2AC, 0x8BFA, 0xBC6D, 0xC53B, 0x4EC1, 0x3797,
517	0x21EF, 0x58B9, 0xD343, 0xAA15, 0x9D82, 0xE4D4, 0x6F2E, 0x1678,
518	0x43DE, 0x3A88, 0xB172, 0xC824, 0xFFB3, 0x86E5, 0x0D1F, 0x7449,
519	0x6231, 0x1B67, 0x909D, 0xE9CB, 0xDE5C, 0xA70A, 0x2CF0, 0x55A6,
520	0x87BC, 0xFEEA, 0x7510, 0x0C46, 0x3BD1, 0x4287, 0xC97D, 0xB02B,
521	0xA653, 0xDF05, 0x54FF, 0x2DA9, 0x1A3E, 0x6368, 0xE892, 0x91C4,
522	0xC462, 0xBD34, 0x36CE, 0x4F98, 0x780F, 0x0159, 0x8AA3, 0xF3F5,
523	0xE58D, 0x9CDB, 0x1721, 0x6E77, 0x59E0, 0x20B6, 0xAB4C, 0xD21A,
524	0x564D, 0x2F1B, 0xA4E1, 0xDDB7, 0xEA20, 0x9376, 0x188C, 0x61DA,
525	0x77A2, 0x0EF4, 0x850E, 0xFC58, 0xCBCF, 0xB299, 0x3963, 0x4035,
526	0x1593, 0x6CC5, 0xE73F, 0x9E69, 0xA9FE, 0xD0A8, 0x5B52, 0x2204,
527	0x347C, 0x4D2A, 0xC6D0, 0xBF86, 0x8811, 0xF147, 0x7ABD, 0x03EB,
528	0xD1F1, 0xA8A7, 0x235D, 0x5A0B, 0x6D9C, 0x14CA, 0x9F30, 0xE666,
529	0xF01E, 0x8948, 0x02B2, 0x7BE4, 0x4C73, 0x3525, 0xBEDF, 0xC789,
530	0x922F, 0xEB79, 0x6083, 0x19D5, 0x2E42, 0x5714, 0xDCEE, 0xA5B8,
531	0xB3C0, 0xCA96, 0x416C, 0x383A, 0x0FAD, 0x76FB, 0xFD01, 0x8457,
532	0xAC9A, 0xD5CC, 0x5E36, 0x2760, 0x10F7, 0x69A1, 0xE25B, 0x9B0D,
533	0x8D75, 0xF423, 0x7FD9, 0x068F, 0x3118, 0x484E, 0xC3B4, 0xBAE2,
534	0xEF44, 0x9612, 0x1DE8, 0x64BE, 0x5329, 0x2A7F, 0xA185, 0xD8D3,
535	0xCEAB, 0xB7FD, 0x3C07, 0x4551, 0x72C6, 0x0B90, 0x806A, 0xF93C,
536	0x2B26, 0x5270, 0xD98A, 0xA0DC, 0x974B, 0xEE1D, 0x65E7, 0x1CB1,
537	0x0AC9, 0x739F, 0xF865, 0x8133, 0xB6A4, 0xCFF2, 0x4408, 0x3D5E,
538	0x68F8, 0x11AE, 0x9A54, 0xE302, 0xD495, 0xADC3, 0x2639, 0x5F6F,
539	0x4917, 0x3041, 0xBBBB, 0xC2ED, 0xF57A, 0x8C2C, 0x07D6, 0x7E80,
540	0xFAD7, 0x8381, 0x087B, 0x712D, 0x46BA, 0x3FEC, 0xB416, 0xCD40,
541	0xDB38, 0xA26E, 0x2994, 0x50C2, 0x6755, 0x1E03, 0x95F9, 0xECAF,
542	0xB909, 0xC05F, 0x4BA5, 0x32F3, 0x0564, 0x7C32, 0xF7C8, 0x8E9E,
543	0x98E6, 0xE1B0, 0x6A4A, 0x131C, 0x248B, 0x5DDD, 0xD627, 0xAF71,
544	0x7D6B, 0x043D, 0x8FC7, 0xF691, 0xC106, 0xB850, 0x33AA, 0x4AFC,
545	0x5C84, 0x25D2, 0xAE28, 0xD77E, 0xE0E9, 0x99BF, 0x1245, 0x6B13,
546	0x3EB5, 0x47E3, 0xCC19, 0xB54F, 0x82D8, 0xFB8E, 0x7074, 0x0922,
547	0x1F5A, 0x660C, 0xEDF6, 0x94A0, 0xA337, 0xDA61, 0x519B, 0x28CD };
548
549	/**
550	* fm10k_crc_16b - Generate a 16 bit CRC for a region of 16 bit data
551	* @data: pointer to data to process
552	* @seed: seed value for CRC
553	* @len: length measured in 16 bits words
554	*
555	* This function will generate a CRC based on the polynomial 0xAC9A and
556	* whatever value is stored in the seed variable. Note that this
557	* value inverts the local seed and the result in order to capture all
558	* leading and trailing zeros.
559	*/
560	static u16 fm10k_crc_16b(const u32 *data, u16 seed, u16 len)
561	{
562	u32 result = seed;
563
564	while (len--) {
565	result ^= *(data++);
566	result = (result >> 8) ^ fm10k_crc_16b_table[result & 0xFF];
567	result = (result >> 8) ^ fm10k_crc_16b_table[result & 0xFF];
568
569	if (!(len--))
570	break;
571
572	result = (result >> 8) ^ fm10k_crc_16b_table[result & 0xFF];
573	result = (result >> 8) ^ fm10k_crc_16b_table[result & 0xFF];
574	}
575
576	return (u16)result;
577	}
578
579	/**
580	* fm10k_fifo_crc - generate a CRC based off of FIFO data
581	* @fifo: pointer to FIFO
582	* @offset: offset point for start of FIFO
583	* @len: number of DWORDS words to process
584	* @seed: seed value for CRC
585	*
586	* This function generates a CRC for some region of the FIFO
587	**/
588	static u16 fm10k_fifo_crc(struct fm10k_mbx_fifo *fifo, u16 offset,
589	u16 len, u16 seed)
590	{
591	u32 *data = fifo->buffer + offset;
592
593	/* track when we should cross the end of the FIFO */
594	offset = fifo->size - offset;
595
596	/* if we are in 2 blocks process the end of the FIFO first */
597	if (offset < len) {
598	seed = fm10k_crc_16b(data, seed, len: offset * 2);
599	data = fifo->buffer;
600	len -= offset;
601	}
602
603	/* process any remaining bits */
604	return fm10k_crc_16b(data, seed, len: len * 2);
605	}
606
607	/**
608	* fm10k_mbx_update_local_crc - Update the local CRC for outgoing data
609	* @mbx: pointer to mailbox
610	* @head: head index provided by remote mailbox
611	*
612	* This function will generate the CRC for all data from the end of the
613	* last head update to the current one. It uses the result of the
614	* previous CRC as the seed for this update. The result is stored in
615	* mbx->local.
616	**/
617	static void fm10k_mbx_update_local_crc(struct fm10k_mbx_info *mbx, u16 head)
618	{
619	u16 len = mbx->tail_len - fm10k_mbx_index_len(mbx, head, tail: mbx->tail);
620
621	/* determine the offset for the start of the region to be pulled */
622	head = fm10k_fifo_head_offset(fifo: &mbx->tx, offset: mbx->pulled);
623
624	/* update local CRC to include all of the pulled data */
625	mbx->local = fm10k_fifo_crc(fifo: &mbx->tx, offset: head, len, seed: mbx->local);
626	}
627
628	/**
629	* fm10k_mbx_verify_remote_crc - Verify the CRC is correct for current data
630	* @mbx: pointer to mailbox
631	*
632	* This function will take all data that has been provided from the remote
633	* end and generate a CRC for it. This is stored in mbx->remote. The
634	* CRC for the header is then computed and if the result is non-zero this
635	* is an error and we signal an error dropping all data and resetting the
636	* connection.
637	*/
638	static s32 fm10k_mbx_verify_remote_crc(struct fm10k_mbx_info *mbx)
639	{
640	struct fm10k_mbx_fifo *fifo = &mbx->rx;
641	u16 len = mbx->head_len;
642	u16 offset = fm10k_fifo_tail_offset(fifo, offset: mbx->pushed) - len;
643	u16 crc;
644
645	/* update the remote CRC if new data has been received */
646	if (len)
647	mbx->remote = fm10k_fifo_crc(fifo, offset, len, seed: mbx->remote);
648
649	/* process the full header as we have to validate the CRC */
650	crc = fm10k_crc_16b(data: &mbx->mbx_hdr, seed: mbx->remote, len: 1);
651
652	/* notify other end if we have a problem */
653	return crc ? FM10K_MBX_ERR_CRC : 0;
654	}
655
656	/**
657	* fm10k_mbx_rx_ready - Indicates that a message is ready in the Rx FIFO
658	* @mbx: pointer to mailbox
659	*
660	* This function returns true if there is a message in the Rx FIFO to dequeue.
661	**/
662	static bool fm10k_mbx_rx_ready(struct fm10k_mbx_info *mbx)
663	{
664	u16 msg_size = fm10k_fifo_head_len(fifo: &mbx->rx);
665
666	return msg_size && (fm10k_fifo_used(fifo: &mbx->rx) >= msg_size);
667	}
668
669	/**
670	* fm10k_mbx_tx_ready - Indicates that the mailbox is in state ready for Tx
671	* @mbx: pointer to mailbox
672	* @len: verify free space is >= this value
673	*
674	* This function returns true if the mailbox is in a state ready to transmit.
675	**/
676	static bool fm10k_mbx_tx_ready(struct fm10k_mbx_info *mbx, u16 len)
677	{
678	u16 fifo_unused = fm10k_fifo_unused(fifo: &mbx->tx);
679
680	return (mbx->state == FM10K_STATE_OPEN) && (fifo_unused >= len);
681	}
682
683	/**
684	* fm10k_mbx_tx_complete - Indicates that the Tx FIFO has been emptied
685	* @mbx: pointer to mailbox
686	*
687	* This function returns true if the Tx FIFO is empty.
688	**/
689	static bool fm10k_mbx_tx_complete(struct fm10k_mbx_info *mbx)
690	{
691	return fm10k_fifo_empty(fifo: &mbx->tx);
692	}
693
694	/**
695	* fm10k_mbx_dequeue_rx - Dequeues the message from the head in the Rx FIFO
696	* @hw: pointer to hardware structure
697	* @mbx: pointer to mailbox
698	*
699	* This function dequeues messages and hands them off to the TLV parser.
700	* It will return the number of messages processed when called.
701	**/
702	static u16 fm10k_mbx_dequeue_rx(struct fm10k_hw *hw,
703	struct fm10k_mbx_info *mbx)
704	{
705	struct fm10k_mbx_fifo *fifo = &mbx->rx;
706	s32 err;
707	u16 cnt;
708
709	/* parse Rx messages out of the Rx FIFO to empty it */
710	for (cnt = 0; !fm10k_fifo_empty(fifo); cnt++) {
711	err = fm10k_tlv_msg_parse(hw, fifo->buffer + fifo->head,
712	mbx, mbx->msg_data);
713	if (err < 0)
714	mbx->rx_parse_err++;
715
716	fm10k_fifo_head_drop(fifo);
717	}
718
719	/* shift remaining bytes back to start of FIFO */
720	memmove(fifo->buffer, fifo->buffer + fifo->tail, mbx->pushed << 2);
721
722	/* shift head and tail based on the memory we moved */
723	fifo->tail -= fifo->head;
724	fifo->head = 0;
725
726	return cnt;
727	}
728
729	/**
730	* fm10k_mbx_enqueue_tx - Enqueues the message to the tail of the Tx FIFO
731	* @hw: pointer to hardware structure
732	* @mbx: pointer to mailbox
733	* @msg: message array to read
734	*
735	* This function enqueues a message up to the size specified by the length
736	* contained in the first DWORD of the message and will place at the tail
737	* of the FIFO. It will return 0 on success, or a negative value on error.
738	**/
739	static s32 fm10k_mbx_enqueue_tx(struct fm10k_hw *hw,
740	struct fm10k_mbx_info *mbx, const u32 *msg)
741	{
742	u32 countdown = mbx->timeout;
743	s32 err;
744
745	switch (mbx->state) {
746	case FM10K_STATE_CLOSED:
747	case FM10K_STATE_DISCONNECT:
748	return FM10K_MBX_ERR_NO_MBX;
749	default:
750	break;
751	}
752
753	/* enqueue the message on the Tx FIFO */
754	err = fm10k_fifo_enqueue(fifo: &mbx->tx, msg);
755
756	/* if it failed give the FIFO a chance to drain */
757	while (err && countdown) {
758	countdown--;
759	udelay(mbx->udelay);
760	mbx->ops.process(hw, mbx);
761	err = fm10k_fifo_enqueue(fifo: &mbx->tx, msg);
762	}
763
764	/* if we failed treat the error */
765	if (err) {
766	mbx->timeout = 0;
767	mbx->tx_busy++;
768	}
769
770	/* begin processing message, ignore errors as this is just meant
771	* to start the mailbox flow so we are not concerned if there
772	* is a bad error, or the mailbox is already busy with a request
773	*/
774	if (!mbx->tail_len)
775	mbx->ops.process(hw, mbx);
776
777	return 0;
778	}
779
780	/**
781	* fm10k_mbx_read - Copies the mbmem to local message buffer
782	* @hw: pointer to hardware structure
783	* @mbx: pointer to mailbox
784	*
785	* This function copies the message from the mbmem to the message array
786	**/
787	static s32 fm10k_mbx_read(struct fm10k_hw *hw, struct fm10k_mbx_info *mbx)
788	{
789	/* only allow one reader in here at a time */
790	if (mbx->mbx_hdr)
791	return FM10K_MBX_ERR_BUSY;
792
793	/* read to capture initial interrupt bits */
794	if (fm10k_read_reg(hw, reg: mbx->mbx_reg) & FM10K_MBX_REQ_INTERRUPT)
795	mbx->mbx_lock = FM10K_MBX_ACK;
796
797	/* write back interrupt bits to clear */
798	fm10k_write_reg(hw, mbx->mbx_reg,
799	FM10K_MBX_REQ_INTERRUPT | FM10K_MBX_ACK_INTERRUPT);
800
801	/* read remote header */
802	mbx->mbx_hdr = fm10k_read_reg(hw, reg: mbx->mbmem_reg ^ mbx->mbmem_len);
803
804	return 0;
805	}
806
807	/**
808	* fm10k_mbx_write - Copies the local message buffer to mbmem
809	* @hw: pointer to hardware structure
810	* @mbx: pointer to mailbox
811	*
812	* This function copies the message from the message array to mbmem
813	**/
814	static void fm10k_mbx_write(struct fm10k_hw *hw, struct fm10k_mbx_info *mbx)
815	{
816	u32 mbmem = mbx->mbmem_reg;
817
818	/* write new msg header to notify recipient of change */
819	fm10k_write_reg(hw, mbmem, mbx->mbx_hdr);
820
821	/* write mailbox to send interrupt */
822	if (mbx->mbx_lock)
823	fm10k_write_reg(hw, mbx->mbx_reg, mbx->mbx_lock);
824
825	/* we no longer are using the header so free it */
826	mbx->mbx_hdr = 0;
827	mbx->mbx_lock = 0;
828	}
829
830	/**
831	* fm10k_mbx_create_connect_hdr - Generate a connect mailbox header
832	* @mbx: pointer to mailbox
833	*
834	* This function returns a connection mailbox header
835	**/
836	static void fm10k_mbx_create_connect_hdr(struct fm10k_mbx_info *mbx)
837	{
838	mbx->mbx_lock |= FM10K_MBX_REQ;
839
840	mbx->mbx_hdr = FM10K_MSG_HDR_FIELD_SET(FM10K_MSG_CONNECT, TYPE) |
841	FM10K_MSG_HDR_FIELD_SET(mbx->head, HEAD) |
842	FM10K_MSG_HDR_FIELD_SET(mbx->rx.size - 1, CONNECT_SIZE);
843	}
844
845	/**
846	* fm10k_mbx_create_data_hdr - Generate a data mailbox header
847	* @mbx: pointer to mailbox
848	*
849	* This function returns a data mailbox header
850	**/
851	static void fm10k_mbx_create_data_hdr(struct fm10k_mbx_info *mbx)
852	{
853	u32 hdr = FM10K_MSG_HDR_FIELD_SET(FM10K_MSG_DATA, TYPE) |
854	FM10K_MSG_HDR_FIELD_SET(mbx->tail, TAIL) |
855	FM10K_MSG_HDR_FIELD_SET(mbx->head, HEAD);
856	struct fm10k_mbx_fifo *fifo = &mbx->tx;
857	u16 crc;
858
859	if (mbx->tail_len)
860	mbx->mbx_lock |= FM10K_MBX_REQ;
861
862	/* generate CRC for data in flight and header */
863	crc = fm10k_fifo_crc(fifo, offset: fm10k_fifo_head_offset(fifo, offset: mbx->pulled),
864	len: mbx->tail_len, seed: mbx->local);
865	crc = fm10k_crc_16b(data: &hdr, seed: crc, len: 1);
866
867	/* load header to memory to be written */
868	mbx->mbx_hdr = hdr | FM10K_MSG_HDR_FIELD_SET(crc, CRC);
869	}
870
871	/**
872	* fm10k_mbx_create_disconnect_hdr - Generate a disconnect mailbox header
873	* @mbx: pointer to mailbox
874	*
875	* This function returns a disconnect mailbox header
876	**/
877	static void fm10k_mbx_create_disconnect_hdr(struct fm10k_mbx_info *mbx)
878	{
879	u32 hdr = FM10K_MSG_HDR_FIELD_SET(FM10K_MSG_DISCONNECT, TYPE) |
880	FM10K_MSG_HDR_FIELD_SET(mbx->tail, TAIL) |
881	FM10K_MSG_HDR_FIELD_SET(mbx->head, HEAD);
882	u16 crc = fm10k_crc_16b(data: &hdr, seed: mbx->local, len: 1);
883
884	mbx->mbx_lock |= FM10K_MBX_ACK;
885
886	/* load header to memory to be written */
887	mbx->mbx_hdr = hdr | FM10K_MSG_HDR_FIELD_SET(crc, CRC);
888	}
889
890	/**
891	* fm10k_mbx_create_fake_disconnect_hdr - Generate a false disconnect mbox hdr
892	* @mbx: pointer to mailbox
893	*
894	* This function creates a fake disconnect header for loading into remote
895	* mailbox header. The primary purpose is to prevent errors on immediate
896	* start up after mbx->connect.
897	**/
898	static void fm10k_mbx_create_fake_disconnect_hdr(struct fm10k_mbx_info *mbx)
899	{
900	u32 hdr = FM10K_MSG_HDR_FIELD_SET(FM10K_MSG_DISCONNECT, TYPE) |
901	FM10K_MSG_HDR_FIELD_SET(mbx->head, TAIL) |
902	FM10K_MSG_HDR_FIELD_SET(mbx->tail, HEAD);
903	u16 crc = fm10k_crc_16b(data: &hdr, seed: mbx->local, len: 1);
904
905	mbx->mbx_lock |= FM10K_MBX_ACK;
906
907	/* load header to memory to be written */
908	mbx->mbx_hdr = hdr | FM10K_MSG_HDR_FIELD_SET(crc, CRC);
909	}
910
911	/**
912	* fm10k_mbx_create_error_msg - Generate an error message
913	* @mbx: pointer to mailbox
914	* @err: local error encountered
915	*
916	* This function will interpret the error provided by err, and based on
917	* that it may shift the message by 1 DWORD and then place an error header
918	* at the start of the message.
919	**/
920	static void fm10k_mbx_create_error_msg(struct fm10k_mbx_info *mbx, s32 err)
921	{
922	/* only generate an error message for these types */
923	switch (err) {
924	case FM10K_MBX_ERR_TAIL:
925	case FM10K_MBX_ERR_HEAD:
926	case FM10K_MBX_ERR_TYPE:
927	case FM10K_MBX_ERR_SIZE:
928	case FM10K_MBX_ERR_RSVD0:
929	case FM10K_MBX_ERR_CRC:
930	break;
931	default:
932	return;
933	}
934
935	mbx->mbx_lock |= FM10K_MBX_REQ;
936
937	mbx->mbx_hdr = FM10K_MSG_HDR_FIELD_SET(FM10K_MSG_ERROR, TYPE) |
938	FM10K_MSG_HDR_FIELD_SET(err, ERR_NO) |
939	FM10K_MSG_HDR_FIELD_SET(mbx->head, HEAD);
940	}
941
942	/**
943	* fm10k_mbx_validate_msg_hdr - Validate common fields in the message header
944	* @mbx: pointer to mailbox
945	*
946	* This function will parse up the fields in the mailbox header and return
947	* an error if the header contains any of a number of invalid configurations
948	* including unrecognized type, invalid route, or a malformed message.
949	**/
950	static s32 fm10k_mbx_validate_msg_hdr(struct fm10k_mbx_info *mbx)
951	{
952	u16 type, rsvd0, head, tail, size;
953	const u32 *hdr = &mbx->mbx_hdr;
954
955	type = FM10K_MSG_HDR_FIELD_GET(*hdr, TYPE);
956	rsvd0 = FM10K_MSG_HDR_FIELD_GET(*hdr, RSVD0);
957	tail = FM10K_MSG_HDR_FIELD_GET(*hdr, TAIL);
958	head = FM10K_MSG_HDR_FIELD_GET(*hdr, HEAD);
959	size = FM10K_MSG_HDR_FIELD_GET(*hdr, CONNECT_SIZE);
960
961	if (rsvd0)
962	return FM10K_MBX_ERR_RSVD0;
963
964	switch (type) {
965	case FM10K_MSG_DISCONNECT:
966	/* validate that all data has been received */
967	if (tail != mbx->head)
968	return FM10K_MBX_ERR_TAIL;
969
970	fallthrough;
971	case FM10K_MSG_DATA:
972	/* validate that head is moving correctly */
973	if (!head || (head == FM10K_MSG_HDR_MASK(HEAD)))
974	return FM10K_MBX_ERR_HEAD;
975	if (fm10k_mbx_index_len(mbx, head, tail: mbx->tail) > mbx->tail_len)
976	return FM10K_MBX_ERR_HEAD;
977
978	/* validate that tail is moving correctly */
979	if (!tail || (tail == FM10K_MSG_HDR_MASK(TAIL)))
980	return FM10K_MBX_ERR_TAIL;
981	if (fm10k_mbx_index_len(mbx, head: mbx->head, tail) < mbx->mbmem_len)
982	break;
983
984	return FM10K_MBX_ERR_TAIL;
985	case FM10K_MSG_CONNECT:
986	/* validate size is in range and is power of 2 mask */
987	if ((size < FM10K_VFMBX_MSG_MTU) || (size & (size + 1)))
988	return FM10K_MBX_ERR_SIZE;
989
990	fallthrough;
991	case FM10K_MSG_ERROR:
992	if (!head || (head == FM10K_MSG_HDR_MASK(HEAD)))
993	return FM10K_MBX_ERR_HEAD;
994	/* neither create nor error include a tail offset */
995	if (tail)
996	return FM10K_MBX_ERR_TAIL;
997
998	break;
999	default:
1000	return FM10K_MBX_ERR_TYPE;
1001	}
1002
1003	return 0;
1004	}
1005
1006	/**
1007	* fm10k_mbx_create_reply - Generate reply based on state and remote head
1008	* @hw: pointer to hardware structure
1009	* @mbx: pointer to mailbox
1010	* @head: acknowledgement number
1011	*
1012	* This function will generate an outgoing message based on the current
1013	* mailbox state and the remote FIFO head. It will return the length
1014	* of the outgoing message excluding header on success, and a negative value
1015	* on error.
1016	**/
1017	static s32 fm10k_mbx_create_reply(struct fm10k_hw *hw,
1018	struct fm10k_mbx_info *mbx, u16 head)
1019	{
1020	switch (mbx->state) {
1021	case FM10K_STATE_OPEN:
1022	case FM10K_STATE_DISCONNECT:
1023	/* update our checksum for the outgoing data */
1024	fm10k_mbx_update_local_crc(mbx, head);
1025
1026	/* as long as other end recognizes us keep sending data */
1027	fm10k_mbx_pull_head(hw, mbx, head);
1028
1029	/* generate new header based on data */
1030	if (mbx->tail_len || (mbx->state == FM10K_STATE_OPEN))
1031	fm10k_mbx_create_data_hdr(mbx);
1032	else
1033	fm10k_mbx_create_disconnect_hdr(mbx);
1034	break;
1035	case FM10K_STATE_CONNECT:
1036	/* send disconnect even if we aren't connected */
1037	fm10k_mbx_create_connect_hdr(mbx);
1038	break;
1039	case FM10K_STATE_CLOSED:
1040	/* generate new header based on data */
1041	fm10k_mbx_create_disconnect_hdr(mbx);
1042	break;
1043	default:
1044	break;
1045	}
1046
1047	return 0;
1048	}
1049
1050	/**
1051	* fm10k_mbx_reset_work- Reset internal pointers for any pending work
1052	* @mbx: pointer to mailbox
1053	*
1054	* This function will reset all internal pointers so any work in progress
1055	* is dropped. This call should occur every time we transition from the
1056	* open state to the connect state.
1057	**/
1058	static void fm10k_mbx_reset_work(struct fm10k_mbx_info *mbx)
1059	{
1060	u16 len, head, ack;
1061
1062	/* reset our outgoing max size back to Rx limits */
1063	mbx->max_size = mbx->rx.size - 1;
1064
1065	/* update mbx->pulled to account for tail_len and ack */
1066	head = FM10K_MSG_HDR_FIELD_GET(mbx->mbx_hdr, HEAD);
1067	ack = fm10k_mbx_index_len(mbx, head, tail: mbx->tail);
1068	mbx->pulled += mbx->tail_len - ack;
1069
1070	/* now drop any messages which have started or finished transmitting */
1071	while (fm10k_fifo_head_len(fifo: &mbx->tx) && mbx->pulled) {
1072	len = fm10k_fifo_head_drop(fifo: &mbx->tx);
1073	mbx->tx_dropped++;
1074	if (mbx->pulled >= len)
1075	mbx->pulled -= len;
1076	else
1077	mbx->pulled = 0;
1078	}
1079
1080	/* just do a quick resysnc to start of message */
1081	mbx->pushed = 0;
1082	mbx->pulled = 0;
1083	mbx->tail_len = 0;
1084	mbx->head_len = 0;
1085	mbx->rx.tail = 0;
1086	mbx->rx.head = 0;
1087	}
1088
1089	/**
1090	* fm10k_mbx_update_max_size - Update the max_size and drop any large messages
1091	* @mbx: pointer to mailbox
1092	* @size: new value for max_size
1093	*
1094	* This function updates the max_size value and drops any outgoing messages
1095	* at the head of the Tx FIFO if they are larger than max_size. It does not
1096	* drop all messages, as this is too difficult to parse and remove them from
1097	* the FIFO. Instead, rely on the checking to ensure that messages larger
1098	* than max_size aren't pushed into the memory buffer.
1099	**/
1100	static void fm10k_mbx_update_max_size(struct fm10k_mbx_info *mbx, u16 size)
1101	{
1102	u16 len;
1103
1104	mbx->max_size = size;
1105
1106	/* flush any oversized messages from the queue */
1107	for (len = fm10k_fifo_head_len(fifo: &mbx->tx);
1108	len > size;
1109	len = fm10k_fifo_head_len(fifo: &mbx->tx)) {
1110	fm10k_fifo_head_drop(fifo: &mbx->tx);
1111	mbx->tx_dropped++;
1112	}
1113	}
1114
1115	/**
1116	* fm10k_mbx_connect_reset - Reset following request for reset
1117	* @mbx: pointer to mailbox
1118	*
1119	* This function resets the mailbox to either a disconnected state
1120	* or a connect state depending on the current mailbox state
1121	**/
1122	static void fm10k_mbx_connect_reset(struct fm10k_mbx_info *mbx)
1123	{
1124	/* just do a quick resysnc to start of frame */
1125	fm10k_mbx_reset_work(mbx);
1126
1127	/* reset CRC seeds */
1128	mbx->local = FM10K_MBX_CRC_SEED;
1129	mbx->remote = FM10K_MBX_CRC_SEED;
1130
1131	/* we cannot exit connect until the size is good */
1132	if (mbx->state == FM10K_STATE_OPEN)
1133	mbx->state = FM10K_STATE_CONNECT;
1134	else
1135	mbx->state = FM10K_STATE_CLOSED;
1136	}
1137
1138	/**
1139	* fm10k_mbx_process_connect - Process connect header
1140	* @hw: pointer to hardware structure
1141	* @mbx: pointer to mailbox
1142	*
1143	* This function will read an incoming connect header and reply with the
1144	* appropriate message. It will return a value indicating the number of
1145	* data DWORDs on success, or will return a negative value on failure.
1146	**/
1147	static s32 fm10k_mbx_process_connect(struct fm10k_hw *hw,
1148	struct fm10k_mbx_info *mbx)
1149	{
1150	const enum fm10k_mbx_state state = mbx->state;
1151	const u32 *hdr = &mbx->mbx_hdr;
1152	u16 size, head;
1153
1154	/* we will need to pull all of the fields for verification */
1155	size = FM10K_MSG_HDR_FIELD_GET(*hdr, CONNECT_SIZE);
1156	head = FM10K_MSG_HDR_FIELD_GET(*hdr, HEAD);
1157
1158	switch (state) {
1159	case FM10K_STATE_DISCONNECT:
1160	case FM10K_STATE_OPEN:
1161	/* reset any in-progress work */
1162	fm10k_mbx_connect_reset(mbx);
1163	break;
1164	case FM10K_STATE_CONNECT:
1165	/* we cannot exit connect until the size is good */
1166	if (size > mbx->rx.size) {
1167	mbx->max_size = mbx->rx.size - 1;
1168	} else {
1169	/* record the remote system requesting connection */
1170	mbx->state = FM10K_STATE_OPEN;
1171
1172	fm10k_mbx_update_max_size(mbx, size);
1173	}
1174	break;
1175	default:
1176	break;
1177	}
1178
1179	/* align our tail index to remote head index */
1180	mbx->tail = head;
1181
1182	return fm10k_mbx_create_reply(hw, mbx, head);
1183	}
1184
1185	/**
1186	* fm10k_mbx_process_data - Process data header
1187	* @hw: pointer to hardware structure
1188	* @mbx: pointer to mailbox
1189	*
1190	* This function will read an incoming data header and reply with the
1191	* appropriate message. It will return a value indicating the number of
1192	* data DWORDs on success, or will return a negative value on failure.
1193	**/
1194	static s32 fm10k_mbx_process_data(struct fm10k_hw *hw,
1195	struct fm10k_mbx_info *mbx)
1196	{
1197	const u32 *hdr = &mbx->mbx_hdr;
1198	u16 head, tail;
1199	s32 err;
1200
1201	/* we will need to pull all of the fields for verification */
1202	head = FM10K_MSG_HDR_FIELD_GET(*hdr, HEAD);
1203	tail = FM10K_MSG_HDR_FIELD_GET(*hdr, TAIL);
1204
1205	/* if we are in connect just update our data and go */
1206	if (mbx->state == FM10K_STATE_CONNECT) {
1207	mbx->tail = head;
1208	mbx->state = FM10K_STATE_OPEN;
1209	}
1210
1211	/* abort on message size errors */
1212	err = fm10k_mbx_push_tail(hw, mbx, tail);
1213	if (err < 0)
1214	return err;
1215
1216	/* verify the checksum on the incoming data */
1217	err = fm10k_mbx_verify_remote_crc(mbx);
1218	if (err)
1219	return err;
1220
1221	/* process messages if we have received any */
1222	fm10k_mbx_dequeue_rx(hw, mbx);
1223
1224	return fm10k_mbx_create_reply(hw, mbx, head);
1225	}
1226
1227	/**
1228	* fm10k_mbx_process_disconnect - Process disconnect header
1229	* @hw: pointer to hardware structure
1230	* @mbx: pointer to mailbox
1231	*
1232	* This function will read an incoming disconnect header and reply with the
1233	* appropriate message. It will return a value indicating the number of
1234	* data DWORDs on success, or will return a negative value on failure.
1235	**/
1236	static s32 fm10k_mbx_process_disconnect(struct fm10k_hw *hw,
1237	struct fm10k_mbx_info *mbx)
1238	{
1239	const enum fm10k_mbx_state state = mbx->state;
1240	const u32 *hdr = &mbx->mbx_hdr;
1241	u16 head;
1242	s32 err;
1243
1244	/* we will need to pull the header field for verification */
1245	head = FM10K_MSG_HDR_FIELD_GET(*hdr, HEAD);
1246
1247	/* We should not be receiving disconnect if Rx is incomplete */
1248	if (mbx->pushed)
1249	return FM10K_MBX_ERR_TAIL;
1250
1251	/* we have already verified mbx->head == tail so we know this is 0 */
1252	mbx->head_len = 0;
1253
1254	/* verify the checksum on the incoming header is correct */
1255	err = fm10k_mbx_verify_remote_crc(mbx);
1256	if (err)
1257	return err;
1258
1259	switch (state) {
1260	case FM10K_STATE_DISCONNECT:
1261	case FM10K_STATE_OPEN:
1262	/* state doesn't change if we still have work to do */
1263	if (!fm10k_mbx_tx_complete(mbx))
1264	break;
1265
1266	/* verify the head indicates we completed all transmits */
1267	if (head != mbx->tail)
1268	return FM10K_MBX_ERR_HEAD;
1269
1270	/* reset any in-progress work */
1271	fm10k_mbx_connect_reset(mbx);
1272	break;
1273	default:
1274	break;
1275	}
1276
1277	return fm10k_mbx_create_reply(hw, mbx, head);
1278	}
1279
1280	/**
1281	* fm10k_mbx_process_error - Process error header
1282	* @hw: pointer to hardware structure
1283	* @mbx: pointer to mailbox
1284	*
1285	* This function will read an incoming error header and reply with the
1286	* appropriate message. It will return a value indicating the number of
1287	* data DWORDs on success, or will return a negative value on failure.
1288	**/
1289	static s32 fm10k_mbx_process_error(struct fm10k_hw *hw,
1290	struct fm10k_mbx_info *mbx)
1291	{
1292	const u32 *hdr = &mbx->mbx_hdr;
1293	u16 head;
1294
1295	/* we will need to pull all of the fields for verification */
1296	head = FM10K_MSG_HDR_FIELD_GET(*hdr, HEAD);
1297
1298	switch (mbx->state) {
1299	case FM10K_STATE_OPEN:
1300	case FM10K_STATE_DISCONNECT:
1301	/* flush any uncompleted work */
1302	fm10k_mbx_reset_work(mbx);
1303
1304	/* reset CRC seeds */
1305	mbx->local = FM10K_MBX_CRC_SEED;
1306	mbx->remote = FM10K_MBX_CRC_SEED;
1307
1308	/* reset tail index and size to prepare for reconnect */
1309	mbx->tail = head;
1310
1311	/* if open then reset max_size and go back to connect */
1312	if (mbx->state == FM10K_STATE_OPEN) {
1313	mbx->state = FM10K_STATE_CONNECT;
1314	break;
1315	}
1316
1317	/* send a connect message to get data flowing again */
1318	fm10k_mbx_create_connect_hdr(mbx);
1319	return 0;
1320	default:
1321	break;
1322	}
1323
1324	return fm10k_mbx_create_reply(hw, mbx, head: mbx->tail);
1325	}
1326
1327	/**
1328	* fm10k_mbx_process - Process mailbox interrupt
1329	* @hw: pointer to hardware structure
1330	* @mbx: pointer to mailbox
1331	*
1332	* This function will process incoming mailbox events and generate mailbox
1333	* replies. It will return a value indicating the number of DWORDs
1334	* transmitted excluding header on success or a negative value on error.
1335	**/
1336	static s32 fm10k_mbx_process(struct fm10k_hw *hw,
1337	struct fm10k_mbx_info *mbx)
1338	{
1339	s32 err;
1340
1341	/* we do not read mailbox if closed */
1342	if (mbx->state == FM10K_STATE_CLOSED)
1343	return 0;
1344
1345	/* copy data from mailbox */
1346	err = fm10k_mbx_read(hw, mbx);
1347	if (err)
1348	return err;
1349
1350	/* validate type, source, and destination */
1351	err = fm10k_mbx_validate_msg_hdr(mbx);
1352	if (err < 0)
1353	goto msg_err;
1354
1355	switch (FM10K_MSG_HDR_FIELD_GET(mbx->mbx_hdr, TYPE)) {
1356	case FM10K_MSG_CONNECT:
1357	err = fm10k_mbx_process_connect(hw, mbx);
1358	break;
1359	case FM10K_MSG_DATA:
1360	err = fm10k_mbx_process_data(hw, mbx);
1361	break;
1362	case FM10K_MSG_DISCONNECT:
1363	err = fm10k_mbx_process_disconnect(hw, mbx);
1364	break;
1365	case FM10K_MSG_ERROR:
1366	err = fm10k_mbx_process_error(hw, mbx);
1367	break;
1368	default:
1369	err = FM10K_MBX_ERR_TYPE;
1370	break;
1371	}
1372
1373	msg_err:
1374	/* notify partner of errors on our end */
1375	if (err < 0)
1376	fm10k_mbx_create_error_msg(mbx, err);
1377
1378	/* copy data from mailbox */
1379	fm10k_mbx_write(hw, mbx);
1380
1381	return err;
1382	}
1383
1384	/**
1385	* fm10k_mbx_disconnect - Shutdown mailbox connection
1386	* @hw: pointer to hardware structure
1387	* @mbx: pointer to mailbox
1388	*
1389	* This function will shut down the mailbox. It places the mailbox first
1390	* in the disconnect state, it then allows up to a predefined timeout for
1391	* the mailbox to transition to close on its own. If this does not occur
1392	* then the mailbox will be forced into the closed state.
1393	*
1394	* Any mailbox transactions not completed before calling this function
1395	* are not guaranteed to complete and may be dropped.
1396	**/
1397	static void fm10k_mbx_disconnect(struct fm10k_hw *hw,
1398	struct fm10k_mbx_info *mbx)
1399	{
1400	int timeout = mbx->timeout ? FM10K_MBX_DISCONNECT_TIMEOUT : 0;
1401
1402	/* Place mbx in ready to disconnect state */
1403	mbx->state = FM10K_STATE_DISCONNECT;
1404
1405	/* trigger interrupt to start shutdown process */
1406	fm10k_write_reg(hw, mbx->mbx_reg, FM10K_MBX_REQ |
1407	FM10K_MBX_INTERRUPT_DISABLE);
1408	do {
1409	udelay(FM10K_MBX_POLL_DELAY);
1410	mbx->ops.process(hw, mbx);
1411	timeout -= FM10K_MBX_POLL_DELAY;
1412	} while ((timeout > 0) && (mbx->state != FM10K_STATE_CLOSED));
1413
1414	/* in case we didn't close, just force the mailbox into shutdown and
1415	* drop all left over messages in the FIFO.
1416	*/
1417	fm10k_mbx_connect_reset(mbx);
1418	fm10k_fifo_drop_all(fifo: &mbx->tx);
1419
1420	fm10k_write_reg(hw, mbx->mbmem_reg, 0);
1421	}
1422
1423	/**
1424	* fm10k_mbx_connect - Start mailbox connection
1425	* @hw: pointer to hardware structure
1426	* @mbx: pointer to mailbox
1427	*
1428	* This function will initiate a mailbox connection. It will populate the
1429	* mailbox with a broadcast connect message and then initialize the lock.
1430	* This is safe since the connect message is a single DWORD so the mailbox
1431	* transaction is guaranteed to be atomic.
1432	*
1433	* This function will return an error if the mailbox has not been initiated
1434	* or is currently in use.
1435	**/
1436	static s32 fm10k_mbx_connect(struct fm10k_hw *hw, struct fm10k_mbx_info *mbx)
1437	{
1438	/* we cannot connect an uninitialized mailbox */
1439	if (!mbx->rx.buffer)
1440	return FM10K_MBX_ERR_NO_SPACE;
1441
1442	/* we cannot connect an already connected mailbox */
1443	if (mbx->state != FM10K_STATE_CLOSED)
1444	return FM10K_MBX_ERR_BUSY;
1445
1446	/* mailbox timeout can now become active */
1447	mbx->timeout = FM10K_MBX_INIT_TIMEOUT;
1448
1449	/* Place mbx in ready to connect state */
1450	mbx->state = FM10K_STATE_CONNECT;
1451
1452	fm10k_mbx_reset_work(mbx);
1453
1454	/* initialize header of remote mailbox */
1455	fm10k_mbx_create_fake_disconnect_hdr(mbx);
1456	fm10k_write_reg(hw, mbx->mbmem_reg ^ mbx->mbmem_len, mbx->mbx_hdr);
1457
1458	/* enable interrupt and notify other party of new message */
1459	mbx->mbx_lock = FM10K_MBX_REQ_INTERRUPT | FM10K_MBX_ACK_INTERRUPT |
1460	FM10K_MBX_INTERRUPT_ENABLE;
1461
1462	/* generate and load connect header into mailbox */
1463	fm10k_mbx_create_connect_hdr(mbx);
1464	fm10k_mbx_write(hw, mbx);
1465
1466	return 0;
1467	}
1468
1469	/**
1470	* fm10k_mbx_validate_handlers - Validate layout of message parsing data
1471	* @msg_data: handlers for mailbox events
1472	*
1473	* This function validates the layout of the message parsing data. This
1474	* should be mostly static, but it is important to catch any errors that
1475	* are made when constructing the parsers.
1476	**/
1477	static s32 fm10k_mbx_validate_handlers(const struct fm10k_msg_data *msg_data)
1478	{
1479	const struct fm10k_tlv_attr *attr;
1480	unsigned int id;
1481
1482	/* Allow NULL mailboxes that transmit but don't receive */
1483	if (!msg_data)
1484	return 0;
1485
1486	while (msg_data->id != FM10K_TLV_ERROR) {
1487	/* all messages should have a function handler */
1488	if (!msg_data->func)
1489	return FM10K_ERR_PARAM;
1490
1491	/* parser is optional */
1492	attr = msg_data->attr;
1493	if (attr) {
1494	while (attr->id != FM10K_TLV_ERROR) {
1495	id = attr->id;
1496	attr++;
1497	/* ID should always be increasing */
1498	if (id >= attr->id)
1499	return FM10K_ERR_PARAM;
1500	/* ID should fit in results array */
1501	if (id >= FM10K_TLV_RESULTS_MAX)
1502	return FM10K_ERR_PARAM;
1503	}
1504
1505	/* verify terminator is in the list */
1506	if (attr->id != FM10K_TLV_ERROR)
1507	return FM10K_ERR_PARAM;
1508	}
1509
1510	id = msg_data->id;
1511	msg_data++;
1512	/* ID should always be increasing */
1513	if (id >= msg_data->id)
1514	return FM10K_ERR_PARAM;
1515	}
1516
1517	/* verify terminator is in the list */
1518	if ((msg_data->id != FM10K_TLV_ERROR) || !msg_data->func)
1519	return FM10K_ERR_PARAM;
1520
1521	return 0;
1522	}
1523
1524	/**
1525	* fm10k_mbx_register_handlers - Register a set of handler ops for mailbox
1526	* @mbx: pointer to mailbox
1527	* @msg_data: handlers for mailbox events
1528	*
1529	* This function associates a set of message handling ops with a mailbox.
1530	**/
1531	static s32 fm10k_mbx_register_handlers(struct fm10k_mbx_info *mbx,
1532	const struct fm10k_msg_data *msg_data)
1533	{
1534	/* validate layout of handlers before assigning them */
1535	if (fm10k_mbx_validate_handlers(msg_data))
1536	return FM10K_ERR_PARAM;
1537
1538	/* initialize the message handlers */
1539	mbx->msg_data = msg_data;
1540
1541	return 0;
1542	}
1543
1544	/**
1545	* fm10k_pfvf_mbx_init - Initialize mailbox memory for PF/VF mailbox
1546	* @hw: pointer to hardware structure
1547	* @mbx: pointer to mailbox
1548	* @msg_data: handlers for mailbox events
1549	* @id: ID reference for PF as it supports up to 64 PF/VF mailboxes
1550	*
1551	* This function initializes the mailbox for use. It will split the
1552	* buffer provided and use that to populate both the Tx and Rx FIFO by
1553	* evenly splitting it. In order to allow for easy masking of head/tail
1554	* the value reported in size must be a power of 2 and is reported in
1555	* DWORDs, not bytes. Any invalid values will cause the mailbox to return
1556	* error.
1557	**/
1558	s32 fm10k_pfvf_mbx_init(struct fm10k_hw *hw, struct fm10k_mbx_info *mbx,
1559	const struct fm10k_msg_data *msg_data, u8 id)
1560	{
1561	/* initialize registers */
1562	switch (hw->mac.type) {
1563	case fm10k_mac_vf:
1564	mbx->mbx_reg = FM10K_VFMBX;
1565	mbx->mbmem_reg = FM10K_VFMBMEM(FM10K_VFMBMEM_VF_XOR);
1566	break;
1567	case fm10k_mac_pf:
1568	/* there are only 64 VF <-> PF mailboxes */
1569	if (id < 64) {
1570	mbx->mbx_reg = FM10K_MBX(id);
1571	mbx->mbmem_reg = FM10K_MBMEM_VF(id, 0);
1572	break;
1573	}
1574	fallthrough;
1575	default:
1576	return FM10K_MBX_ERR_NO_MBX;
1577	}
1578
1579	/* start out in closed state */
1580	mbx->state = FM10K_STATE_CLOSED;
1581
1582	/* validate layout of handlers before assigning them */
1583	if (fm10k_mbx_validate_handlers(msg_data))
1584	return FM10K_ERR_PARAM;
1585
1586	/* initialize the message handlers */
1587	mbx->msg_data = msg_data;
1588
1589	/* start mailbox as timed out and let the reset_hw call
1590	* set the timeout value to begin communications
1591	*/
1592	mbx->timeout = 0;
1593	mbx->udelay = FM10K_MBX_INIT_DELAY;
1594
1595	/* initialize tail and head */
1596	mbx->tail = 1;
1597	mbx->head = 1;
1598
1599	/* initialize CRC seeds */
1600	mbx->local = FM10K_MBX_CRC_SEED;
1601	mbx->remote = FM10K_MBX_CRC_SEED;
1602
1603	/* Split buffer for use by Tx/Rx FIFOs */
1604	mbx->max_size = FM10K_MBX_MSG_MAX_SIZE;
1605	mbx->mbmem_len = FM10K_VFMBMEM_VF_XOR;
1606
1607	/* initialize the FIFOs, sizes are in 4 byte increments */
1608	fm10k_fifo_init(fifo: &mbx->tx, buffer: mbx->buffer, FM10K_MBX_TX_BUFFER_SIZE);
1609	fm10k_fifo_init(fifo: &mbx->rx, buffer: &mbx->buffer[FM10K_MBX_TX_BUFFER_SIZE],
1610	FM10K_MBX_RX_BUFFER_SIZE);
1611
1612	/* initialize function pointers */
1613	mbx->ops.connect = fm10k_mbx_connect;
1614	mbx->ops.disconnect = fm10k_mbx_disconnect;
1615	mbx->ops.rx_ready = fm10k_mbx_rx_ready;
1616	mbx->ops.tx_ready = fm10k_mbx_tx_ready;
1617	mbx->ops.tx_complete = fm10k_mbx_tx_complete;
1618	mbx->ops.enqueue_tx = fm10k_mbx_enqueue_tx;
1619	mbx->ops.process = fm10k_mbx_process;
1620	mbx->ops.register_handlers = fm10k_mbx_register_handlers;
1621
1622	return 0;
1623	}
1624
1625	/**
1626	* fm10k_sm_mbx_create_data_hdr - Generate a mailbox header for local FIFO
1627	* @mbx: pointer to mailbox
1628	*
1629	* This function returns a data mailbox header
1630	**/
1631	static void fm10k_sm_mbx_create_data_hdr(struct fm10k_mbx_info *mbx)
1632	{
1633	if (mbx->tail_len)
1634	mbx->mbx_lock |= FM10K_MBX_REQ;
1635
1636	mbx->mbx_hdr = FM10K_MSG_HDR_FIELD_SET(mbx->tail, SM_TAIL) |
1637	FM10K_MSG_HDR_FIELD_SET(mbx->remote, SM_VER) |
1638	FM10K_MSG_HDR_FIELD_SET(mbx->head, SM_HEAD);
1639	}
1640
1641	/**
1642	* fm10k_sm_mbx_create_connect_hdr - Generate a mailbox header for local FIFO
1643	* @mbx: pointer to mailbox
1644	* @err: error flags to report if any
1645	*
1646	* This function returns a connection mailbox header
1647	**/
1648	static void fm10k_sm_mbx_create_connect_hdr(struct fm10k_mbx_info *mbx, u8 err)
1649	{
1650	if (mbx->local)
1651	mbx->mbx_lock |= FM10K_MBX_REQ;
1652
1653	mbx->mbx_hdr = FM10K_MSG_HDR_FIELD_SET(mbx->tail, SM_TAIL) |
1654	FM10K_MSG_HDR_FIELD_SET(mbx->remote, SM_VER) |
1655	FM10K_MSG_HDR_FIELD_SET(mbx->head, SM_HEAD) |
1656	FM10K_MSG_HDR_FIELD_SET(err, SM_ERR);
1657	}
1658
1659	/**
1660	* fm10k_sm_mbx_connect_reset - Reset following request for reset
1661	* @mbx: pointer to mailbox
1662	*
1663	* This function resets the mailbox to a just connected state
1664	**/
1665	static void fm10k_sm_mbx_connect_reset(struct fm10k_mbx_info *mbx)
1666	{
1667	/* flush any uncompleted work */
1668	fm10k_mbx_reset_work(mbx);
1669
1670	/* set local version to max and remote version to 0 */
1671	mbx->local = FM10K_SM_MBX_VERSION;
1672	mbx->remote = 0;
1673
1674	/* initialize tail and head */
1675	mbx->tail = 1;
1676	mbx->head = 1;
1677
1678	/* reset state back to connect */
1679	mbx->state = FM10K_STATE_CONNECT;
1680	}
1681
1682	/**
1683	* fm10k_sm_mbx_connect - Start switch manager mailbox connection
1684	* @hw: pointer to hardware structure
1685	* @mbx: pointer to mailbox
1686	*
1687	* This function will initiate a mailbox connection with the switch
1688	* manager. To do this it will first disconnect the mailbox, and then
1689	* reconnect it in order to complete a reset of the mailbox.
1690	*
1691	* This function will return an error if the mailbox has not been initiated
1692	* or is currently in use.
1693	**/
1694	static s32 fm10k_sm_mbx_connect(struct fm10k_hw *hw, struct fm10k_mbx_info *mbx)
1695	{
1696	/* we cannot connect an uninitialized mailbox */
1697	if (!mbx->rx.buffer)
1698	return FM10K_MBX_ERR_NO_SPACE;
1699
1700	/* we cannot connect an already connected mailbox */
1701	if (mbx->state != FM10K_STATE_CLOSED)
1702	return FM10K_MBX_ERR_BUSY;
1703
1704	/* mailbox timeout can now become active */
1705	mbx->timeout = FM10K_MBX_INIT_TIMEOUT;
1706
1707	/* Place mbx in ready to connect state */
1708	mbx->state = FM10K_STATE_CONNECT;
1709	mbx->max_size = FM10K_MBX_MSG_MAX_SIZE;
1710
1711	/* reset interface back to connect */
1712	fm10k_sm_mbx_connect_reset(mbx);
1713
1714	/* enable interrupt and notify other party of new message */
1715	mbx->mbx_lock = FM10K_MBX_REQ_INTERRUPT | FM10K_MBX_ACK_INTERRUPT |
1716	FM10K_MBX_INTERRUPT_ENABLE;
1717
1718	/* generate and load connect header into mailbox */
1719	fm10k_sm_mbx_create_connect_hdr(mbx, err: 0);
1720	fm10k_mbx_write(hw, mbx);
1721
1722	return 0;
1723	}
1724
1725	/**
1726	* fm10k_sm_mbx_disconnect - Shutdown mailbox connection
1727	* @hw: pointer to hardware structure
1728	* @mbx: pointer to mailbox
1729	*
1730	* This function will shut down the mailbox. It places the mailbox first
1731	* in the disconnect state, it then allows up to a predefined timeout for
1732	* the mailbox to transition to close on its own. If this does not occur
1733	* then the mailbox will be forced into the closed state.
1734	*
1735	* Any mailbox transactions not completed before calling this function
1736	* are not guaranteed to complete and may be dropped.
1737	**/
1738	static void fm10k_sm_mbx_disconnect(struct fm10k_hw *hw,
1739	struct fm10k_mbx_info *mbx)
1740	{
1741	int timeout = mbx->timeout ? FM10K_MBX_DISCONNECT_TIMEOUT : 0;
1742
1743	/* Place mbx in ready to disconnect state */
1744	mbx->state = FM10K_STATE_DISCONNECT;
1745
1746	/* trigger interrupt to start shutdown process */
1747	fm10k_write_reg(hw, mbx->mbx_reg, FM10K_MBX_REQ |
1748	FM10K_MBX_INTERRUPT_DISABLE);
1749	do {
1750	udelay(FM10K_MBX_POLL_DELAY);
1751	mbx->ops.process(hw, mbx);
1752	timeout -= FM10K_MBX_POLL_DELAY;
1753	} while ((timeout > 0) && (mbx->state != FM10K_STATE_CLOSED));
1754
1755	/* in case we didn't close just force the mailbox into shutdown */
1756	mbx->state = FM10K_STATE_CLOSED;
1757	mbx->remote = 0;
1758	fm10k_mbx_reset_work(mbx);
1759	fm10k_fifo_drop_all(fifo: &mbx->tx);
1760
1761	fm10k_write_reg(hw, mbx->mbmem_reg, 0);
1762	}
1763
1764	/**
1765	* fm10k_sm_mbx_validate_fifo_hdr - Validate fields in the remote FIFO header
1766	* @mbx: pointer to mailbox
1767	*
1768	* This function will parse up the fields in the mailbox header and return
1769	* an error if the header contains any of a number of invalid configurations
1770	* including unrecognized offsets or version numbers.
1771	**/
1772	static s32 fm10k_sm_mbx_validate_fifo_hdr(struct fm10k_mbx_info *mbx)
1773	{
1774	const u32 *hdr = &mbx->mbx_hdr;
1775	u16 tail, head, ver;
1776
1777	tail = FM10K_MSG_HDR_FIELD_GET(*hdr, SM_TAIL);
1778	ver = FM10K_MSG_HDR_FIELD_GET(*hdr, SM_VER);
1779	head = FM10K_MSG_HDR_FIELD_GET(*hdr, SM_HEAD);
1780
1781	switch (ver) {
1782	case 0:
1783	break;
1784	case FM10K_SM_MBX_VERSION:
1785	if (!head || head > FM10K_SM_MBX_FIFO_LEN)
1786	return FM10K_MBX_ERR_HEAD;
1787	if (!tail || tail > FM10K_SM_MBX_FIFO_LEN)
1788	return FM10K_MBX_ERR_TAIL;
1789	if (mbx->tail < head)
1790	head += mbx->mbmem_len - 1;
1791	if (tail < mbx->head)
1792	tail += mbx->mbmem_len - 1;
1793	if (fm10k_mbx_index_len(mbx, head, tail: mbx->tail) > mbx->tail_len)
1794	return FM10K_MBX_ERR_HEAD;
1795	if (fm10k_mbx_index_len(mbx, head: mbx->head, tail) < mbx->mbmem_len)
1796	break;
1797	return FM10K_MBX_ERR_TAIL;
1798	default:
1799	return FM10K_MBX_ERR_SRC;
1800	}
1801
1802	return 0;
1803	}
1804
1805	/**
1806	* fm10k_sm_mbx_process_error - Process header with error flag set
1807	* @mbx: pointer to mailbox
1808	*
1809	* This function is meant to respond to a request where the error flag
1810	* is set. As a result we will terminate a connection if one is present
1811	* and fall back into the reset state with a connection header of version
1812	* 0 (RESET).
1813	**/
1814	static void fm10k_sm_mbx_process_error(struct fm10k_mbx_info *mbx)
1815	{
1816	const enum fm10k_mbx_state state = mbx->state;
1817
1818	switch (state) {
1819	case FM10K_STATE_DISCONNECT:
1820	/* if there is an error just disconnect */
1821	mbx->remote = 0;
1822	break;
1823	case FM10K_STATE_OPEN:
1824	/* flush any uncompleted work */
1825	fm10k_sm_mbx_connect_reset(mbx);
1826	break;
1827	case FM10K_STATE_CONNECT:
1828	/* try connecting at lower version */
1829	if (mbx->remote) {
1830	while (mbx->local > 1)
1831	mbx->local--;
1832	mbx->remote = 0;
1833	}
1834	break;
1835	default:
1836	break;
1837	}
1838
1839	fm10k_sm_mbx_create_connect_hdr(mbx, err: 0);
1840	}
1841
1842	/**
1843	* fm10k_sm_mbx_create_error_msg - Process an error in FIFO header
1844	* @mbx: pointer to mailbox
1845	* @err: local error encountered
1846	*
1847	* This function will interpret the error provided by err, and based on
1848	* that it may set the error bit in the local message header
1849	**/
1850	static void fm10k_sm_mbx_create_error_msg(struct fm10k_mbx_info *mbx, s32 err)
1851	{
1852	/* only generate an error message for these types */
1853	switch (err) {
1854	case FM10K_MBX_ERR_TAIL:
1855	case FM10K_MBX_ERR_HEAD:
1856	case FM10K_MBX_ERR_SRC:
1857	case FM10K_MBX_ERR_SIZE:
1858	case FM10K_MBX_ERR_RSVD0:
1859	break;
1860	default:
1861	return;
1862	}
1863
1864	/* process it as though we received an error, and send error reply */
1865	fm10k_sm_mbx_process_error(mbx);
1866	fm10k_sm_mbx_create_connect_hdr(mbx, err: 1);
1867	}
1868
1869	/**
1870	* fm10k_sm_mbx_receive - Take message from Rx mailbox FIFO and put it in Rx
1871	* @hw: pointer to hardware structure
1872	* @mbx: pointer to mailbox
1873	* @tail: tail index of message
1874	*
1875	* This function will dequeue one message from the Rx switch manager mailbox
1876	* FIFO and place it in the Rx mailbox FIFO for processing by software.
1877	**/
1878	static s32 fm10k_sm_mbx_receive(struct fm10k_hw *hw,
1879	struct fm10k_mbx_info *mbx,
1880	u16 tail)
1881	{
1882	/* reduce length by 1 to convert to a mask */
1883	u16 mbmem_len = mbx->mbmem_len - 1;
1884	s32 err;
1885
1886	/* push tail in front of head */
1887	if (tail < mbx->head)
1888	tail += mbmem_len;
1889
1890	/* copy data to the Rx FIFO */
1891	err = fm10k_mbx_push_tail(hw, mbx, tail);
1892	if (err < 0)
1893	return err;
1894
1895	/* process messages if we have received any */
1896	fm10k_mbx_dequeue_rx(hw, mbx);
1897
1898	/* guarantee head aligns with the end of the last message */
1899	mbx->head = fm10k_mbx_head_sub(mbx, offset: mbx->pushed);
1900	mbx->pushed = 0;
1901
1902	/* clear any extra bits left over since index adds 1 extra bit */
1903	if (mbx->head > mbmem_len)
1904	mbx->head -= mbmem_len;
1905
1906	return err;
1907	}
1908
1909	/**
1910	* fm10k_sm_mbx_transmit - Take message from Tx and put it in Tx mailbox FIFO
1911	* @hw: pointer to hardware structure
1912	* @mbx: pointer to mailbox
1913	* @head: head index of message
1914	*
1915	* This function will dequeue one message from the Tx mailbox FIFO and place
1916	* it in the Tx switch manager mailbox FIFO for processing by hardware.
1917	**/
1918	static void fm10k_sm_mbx_transmit(struct fm10k_hw *hw,
1919	struct fm10k_mbx_info *mbx, u16 head)
1920	{
1921	struct fm10k_mbx_fifo *fifo = &mbx->tx;
1922	/* reduce length by 1 to convert to a mask */
1923	u16 mbmem_len = mbx->mbmem_len - 1;
1924	u16 tail_len, len = 0;
1925
1926	/* push head behind tail */
1927	if (mbx->tail < head)
1928	head += mbmem_len;
1929
1930	fm10k_mbx_pull_head(hw, mbx, head);
1931
1932	/* determine msg aligned offset for end of buffer */
1933	do {
1934	u32 *msg;
1935
1936	msg = fifo->buffer + fm10k_fifo_head_offset(fifo, offset: len);
1937	tail_len = len;
1938	len += FM10K_TLV_DWORD_LEN(*msg);
1939	} while ((len <= mbx->tail_len) && (len < mbmem_len));
1940
1941	/* guarantee we stop on a message boundary */
1942	if (mbx->tail_len > tail_len) {
1943	mbx->tail = fm10k_mbx_tail_sub(mbx, offset: mbx->tail_len - tail_len);
1944	mbx->tail_len = tail_len;
1945	}
1946
1947	/* clear any extra bits left over since index adds 1 extra bit */
1948	if (mbx->tail > mbmem_len)
1949	mbx->tail -= mbmem_len;
1950	}
1951
1952	/**
1953	* fm10k_sm_mbx_create_reply - Generate reply based on state and remote head
1954	* @hw: pointer to hardware structure
1955	* @mbx: pointer to mailbox
1956	* @head: acknowledgement number
1957	*
1958	* This function will generate an outgoing message based on the current
1959	* mailbox state and the remote FIFO head. It will return the length
1960	* of the outgoing message excluding header on success, and a negative value
1961	* on error.
1962	**/
1963	static void fm10k_sm_mbx_create_reply(struct fm10k_hw *hw,
1964	struct fm10k_mbx_info *mbx, u16 head)
1965	{
1966	switch (mbx->state) {
1967	case FM10K_STATE_OPEN:
1968	case FM10K_STATE_DISCONNECT:
1969	/* flush out Tx data */
1970	fm10k_sm_mbx_transmit(hw, mbx, head);
1971
1972	/* generate new header based on data */
1973	if (mbx->tail_len || (mbx->state == FM10K_STATE_OPEN)) {
1974	fm10k_sm_mbx_create_data_hdr(mbx);
1975	} else {
1976	mbx->remote = 0;
1977	fm10k_sm_mbx_create_connect_hdr(mbx, err: 0);
1978	}
1979	break;
1980	case FM10K_STATE_CONNECT:
1981	case FM10K_STATE_CLOSED:
1982	fm10k_sm_mbx_create_connect_hdr(mbx, err: 0);
1983	break;
1984	default:
1985	break;
1986	}
1987	}
1988
1989	/**
1990	* fm10k_sm_mbx_process_reset - Process header with version == 0 (RESET)
1991	* @hw: pointer to hardware structure
1992	* @mbx: pointer to mailbox
1993	*
1994	* This function is meant to respond to a request where the version data
1995	* is set to 0. As such we will either terminate the connection or go
1996	* into the connect state in order to re-establish the connection. This
1997	* function can also be used to respond to an error as the connection
1998	* resetting would also be a means of dealing with errors.
1999	**/
2000	static s32 fm10k_sm_mbx_process_reset(struct fm10k_hw *hw,
2001	struct fm10k_mbx_info *mbx)
2002	{
2003	s32 err = 0;
2004	const enum fm10k_mbx_state state = mbx->state;
2005
2006	switch (state) {
2007	case FM10K_STATE_DISCONNECT:
2008	/* drop remote connections and disconnect */
2009	mbx->state = FM10K_STATE_CLOSED;
2010	mbx->remote = 0;
2011	mbx->local = 0;
2012	break;
2013	case FM10K_STATE_OPEN:
2014	/* flush any incomplete work */
2015	fm10k_sm_mbx_connect_reset(mbx);
2016	err = FM10K_ERR_RESET_REQUESTED;
2017	break;
2018	case FM10K_STATE_CONNECT:
2019	/* Update remote value to match local value */
2020	mbx->remote = mbx->local;
2021	break;
2022	default:
2023	break;
2024	}
2025
2026	fm10k_sm_mbx_create_reply(hw, mbx, head: mbx->tail);
2027
2028	return err;
2029	}
2030
2031	/**
2032	* fm10k_sm_mbx_process_version_1 - Process header with version == 1
2033	* @hw: pointer to hardware structure
2034	* @mbx: pointer to mailbox
2035	*
2036	* This function is meant to process messages received when the remote
2037	* mailbox is active.
2038	**/
2039	static s32 fm10k_sm_mbx_process_version_1(struct fm10k_hw *hw,
2040	struct fm10k_mbx_info *mbx)
2041	{
2042	const u32 *hdr = &mbx->mbx_hdr;
2043	u16 head, tail;
2044	s32 len;
2045
2046	/* pull all fields needed for verification */
2047	tail = FM10K_MSG_HDR_FIELD_GET(*hdr, SM_TAIL);
2048	head = FM10K_MSG_HDR_FIELD_GET(*hdr, SM_HEAD);
2049
2050	/* if we are in connect and wanting version 1 then start up and go */
2051	if (mbx->state == FM10K_STATE_CONNECT) {
2052	if (!mbx->remote)
2053	goto send_reply;
2054	if (mbx->remote != 1)
2055	return FM10K_MBX_ERR_SRC;
2056
2057	mbx->state = FM10K_STATE_OPEN;
2058	}
2059
2060	do {
2061	/* abort on message size errors */
2062	len = fm10k_sm_mbx_receive(hw, mbx, tail);
2063	if (len < 0)
2064	return len;
2065
2066	/* continue until we have flushed the Rx FIFO */
2067	} while (len);
2068
2069	send_reply:
2070	fm10k_sm_mbx_create_reply(hw, mbx, head);
2071
2072	return 0;
2073	}
2074
2075	/**
2076	* fm10k_sm_mbx_process - Process switch manager mailbox interrupt
2077	* @hw: pointer to hardware structure
2078	* @mbx: pointer to mailbox
2079	*
2080	* This function will process incoming mailbox events and generate mailbox
2081	* replies. It will return a value indicating the number of DWORDs
2082	* transmitted excluding header on success or a negative value on error.
2083	**/
2084	static s32 fm10k_sm_mbx_process(struct fm10k_hw *hw,
2085	struct fm10k_mbx_info *mbx)
2086	{
2087	s32 err;
2088
2089	/* we do not read mailbox if closed */
2090	if (mbx->state == FM10K_STATE_CLOSED)
2091	return 0;
2092
2093	/* retrieve data from switch manager */
2094	err = fm10k_mbx_read(hw, mbx);
2095	if (err)
2096	return err;
2097
2098	err = fm10k_sm_mbx_validate_fifo_hdr(mbx);
2099	if (err < 0)
2100	goto fifo_err;
2101
2102	if (FM10K_MSG_HDR_FIELD_GET(mbx->mbx_hdr, SM_ERR)) {
2103	fm10k_sm_mbx_process_error(mbx);
2104	goto fifo_err;
2105	}
2106
2107	switch (FM10K_MSG_HDR_FIELD_GET(mbx->mbx_hdr, SM_VER)) {
2108	case 0:
2109	err = fm10k_sm_mbx_process_reset(hw, mbx);
2110	break;
2111	case FM10K_SM_MBX_VERSION:
2112	err = fm10k_sm_mbx_process_version_1(hw, mbx);
2113	break;
2114	}
2115
2116	fifo_err:
2117	if (err < 0)
2118	fm10k_sm_mbx_create_error_msg(mbx, err);
2119
2120	/* report data to switch manager */
2121	fm10k_mbx_write(hw, mbx);
2122
2123	return err;
2124	}
2125
2126	/**
2127	* fm10k_sm_mbx_init - Initialize mailbox memory for PF/SM mailbox
2128	* @hw: pointer to hardware structure
2129	* @mbx: pointer to mailbox
2130	* @msg_data: handlers for mailbox events
2131	*
2132	* This function initializes the PF/SM mailbox for use. It will split the
2133	* buffer provided and use that to populate both the Tx and Rx FIFO by
2134	* evenly splitting it. In order to allow for easy masking of head/tail
2135	* the value reported in size must be a power of 2 and is reported in
2136	* DWORDs, not bytes. Any invalid values will cause the mailbox to return
2137	* error.
2138	**/
2139	s32 fm10k_sm_mbx_init(struct fm10k_hw __always_unused *hw,
2140	struct fm10k_mbx_info *mbx,
2141	const struct fm10k_msg_data *msg_data)
2142	{
2143	mbx->mbx_reg = FM10K_GMBX;
2144	mbx->mbmem_reg = FM10K_MBMEM_PF(0);
2145
2146	/* start out in closed state */
2147	mbx->state = FM10K_STATE_CLOSED;
2148
2149	/* validate layout of handlers before assigning them */
2150	if (fm10k_mbx_validate_handlers(msg_data))
2151	return FM10K_ERR_PARAM;
2152
2153	/* initialize the message handlers */
2154	mbx->msg_data = msg_data;
2155
2156	/* start mailbox as timed out and let the reset_hw call
2157	* set the timeout value to begin communications
2158	*/
2159	mbx->timeout = 0;
2160	mbx->udelay = FM10K_MBX_INIT_DELAY;
2161
2162	/* Split buffer for use by Tx/Rx FIFOs */
2163	mbx->max_size = FM10K_MBX_MSG_MAX_SIZE;
2164	mbx->mbmem_len = FM10K_MBMEM_PF_XOR;
2165
2166	/* initialize the FIFOs, sizes are in 4 byte increments */
2167	fm10k_fifo_init(fifo: &mbx->tx, buffer: mbx->buffer, FM10K_MBX_TX_BUFFER_SIZE);
2168	fm10k_fifo_init(fifo: &mbx->rx, buffer: &mbx->buffer[FM10K_MBX_TX_BUFFER_SIZE],
2169	FM10K_MBX_RX_BUFFER_SIZE);
2170
2171	/* initialize function pointers */
2172	mbx->ops.connect = fm10k_sm_mbx_connect;
2173	mbx->ops.disconnect = fm10k_sm_mbx_disconnect;
2174	mbx->ops.rx_ready = fm10k_mbx_rx_ready;
2175	mbx->ops.tx_ready = fm10k_mbx_tx_ready;
2176	mbx->ops.tx_complete = fm10k_mbx_tx_complete;
2177	mbx->ops.enqueue_tx = fm10k_mbx_enqueue_tx;
2178	mbx->ops.process = fm10k_sm_mbx_process;
2179	mbx->ops.register_handlers = fm10k_mbx_register_handlers;
2180
2181	return 0;
2182	}
2183