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