1 /* Intel Ethernet Switch Host Interface Driver
2 * Copyright(c) 2013 - 2015 Intel Corporation.
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.
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
13 * The full GNU General Public License is included in this distribution in
14 * the file called "COPYING".
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
21 #include "fm10k_common.h"
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
29 static void fm10k_fifo_init(struct fm10k_mbx_fifo *fifo, u32 *buffer, u16 size)
31 fifo->buffer = buffer;
38 * fm10k_fifo_used - Retrieve used space in FIFO
39 * @fifo: pointer to FIFO
41 * This function returns the number of DWORDs used in the FIFO
43 static u16 fm10k_fifo_used(struct fm10k_mbx_fifo *fifo)
45 return fifo->tail - fifo->head;
49 * fm10k_fifo_unused - Retrieve unused space in FIFO
50 * @fifo: pointer to FIFO
52 * This function returns the number of unused DWORDs in the FIFO
54 static u16 fm10k_fifo_unused(struct fm10k_mbx_fifo *fifo)
56 return fifo->size + fifo->head - fifo->tail;
60 * fm10k_fifo_empty - Test to verify if fifo is empty
61 * @fifo: pointer to FIFO
63 * This function returns true if the FIFO is empty, else false
65 static bool fm10k_fifo_empty(struct fm10k_mbx_fifo *fifo)
67 return fifo->head == fifo->tail;
71 * fm10k_fifo_head_offset - returns indices of head with given offset
72 * @fifo: pointer to FIFO
73 * @offset: offset to add to head
75 * This function returns the indices into the fifo based on head + offset
77 static u16 fm10k_fifo_head_offset(struct fm10k_mbx_fifo *fifo, u16 offset)
79 return (fifo->head + offset) & (fifo->size - 1);
83 * fm10k_fifo_tail_offset - returns indices of tail with given offset
84 * @fifo: pointer to FIFO
85 * @offset: offset to add to tail
87 * This function returns the indices into the fifo based on tail + offset
89 static u16 fm10k_fifo_tail_offset(struct fm10k_mbx_fifo *fifo, u16 offset)
91 return (fifo->tail + offset) & (fifo->size - 1);
95 * fm10k_fifo_head_len - Retrieve length of first message in FIFO
96 * @fifo: pointer to FIFO
98 * This function returns the size of the first message in the FIFO
100 static u16 fm10k_fifo_head_len(struct fm10k_mbx_fifo *fifo)
102 u32 *head = fifo->buffer + fm10k_fifo_head_offset(fifo, 0);
104 /* verify there is at least 1 DWORD in the fifo so *head is valid */
105 if (fm10k_fifo_empty(fifo))
108 /* retieve the message length */
109 return FM10K_TLV_DWORD_LEN(*head);
113 * fm10k_fifo_head_drop - Drop the first message in FIFO
114 * @fifo: pointer to FIFO
116 * This function returns the size of the message dropped from the FIFO
118 static u16 fm10k_fifo_head_drop(struct fm10k_mbx_fifo *fifo)
120 u16 len = fm10k_fifo_head_len(fifo);
122 /* update head so it is at the start of next frame */
129 * fm10k_fifo_drop_all - Drop all messages in FIFO
130 * @fifo: pointer to FIFO
132 * This function resets the head pointer to drop all messages in the FIFO,
133 * and ensure the FIFO is empty.
135 static void fm10k_fifo_drop_all(struct fm10k_mbx_fifo *fifo)
137 fifo->head = fifo->tail;
141 * fm10k_mbx_index_len - Convert a head/tail index into a length value
142 * @mbx: pointer to mailbox
146 * This function takes the head and tail index and determines the length
147 * of the data indicated by this pair.
149 static u16 fm10k_mbx_index_len(struct fm10k_mbx_info *mbx, u16 head, u16 tail)
151 u16 len = tail - head;
153 /* we wrapped so subtract 2, one for index 0, one for all 1s index */
157 return len & ((mbx->mbmem_len << 1) - 1);
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
165 * This function takes the local tail index and recomputes it for
166 * a given length added as an offset.
168 static u16 fm10k_mbx_tail_add(struct fm10k_mbx_info *mbx, u16 offset)
170 u16 tail = (mbx->tail + offset + 1) & ((mbx->mbmem_len << 1) - 1);
172 /* add/sub 1 because we cannot have offset 0 or all 1s */
173 return (tail > mbx->tail) ? --tail : ++tail;
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
181 * This function takes the local tail index and recomputes it for
182 * a given length added as an offset.
184 static u16 fm10k_mbx_tail_sub(struct fm10k_mbx_info *mbx, u16 offset)
186 u16 tail = (mbx->tail - offset - 1) & ((mbx->mbmem_len << 1) - 1);
188 /* sub/add 1 because we cannot have offset 0 or all 1s */
189 return (tail < mbx->tail) ? ++tail : --tail;
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
197 * This function takes the local head index and recomputes it for
198 * a given length added as an offset.
200 static u16 fm10k_mbx_head_add(struct fm10k_mbx_info *mbx, u16 offset)
202 u16 head = (mbx->head + offset + 1) & ((mbx->mbmem_len << 1) - 1);
204 /* add/sub 1 because we cannot have offset 0 or all 1s */
205 return (head > mbx->head) ? --head : ++head;
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
213 * This function takes the local head index and recomputes it for
214 * a given length added as an offset.
216 static u16 fm10k_mbx_head_sub(struct fm10k_mbx_info *mbx, u16 offset)
218 u16 head = (mbx->head - offset - 1) & ((mbx->mbmem_len << 1) - 1);
220 /* sub/add 1 because we cannot have offset 0 or all 1s */
221 return (head < mbx->head) ? ++head : --head;
225 * fm10k_mbx_pushed_tail_len - Retrieve the length of message being pushed
226 * @mbx: pointer to mailbox
228 * This function will return the length of the message currently being
229 * pushed onto the tail of the Rx queue.
231 static u16 fm10k_mbx_pushed_tail_len(struct fm10k_mbx_info *mbx)
233 u32 *tail = mbx->rx.buffer + fm10k_fifo_tail_offset(&mbx->rx, 0);
235 /* pushed tail is only valid if pushed is set */
239 return FM10K_TLV_DWORD_LEN(*tail);
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
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.
253 static void fm10k_fifo_write_copy(struct fm10k_mbx_fifo *fifo,
254 const u32 *msg, u16 tail_offset, u16 len)
256 u16 end = fm10k_fifo_tail_offset(fifo, tail_offset);
257 u32 *tail = fifo->buffer + end;
259 /* track when we should cross the end of the FIFO */
260 end = fifo->size - end;
262 /* copy end of message before start of message */
264 memcpy(fifo->buffer, msg + end, (len - end) << 2);
268 /* Copy remaining message into Tx FIFO */
269 memcpy(tail, msg, end << 2);
273 * fm10k_fifo_enqueue - Enqueues the message to the tail of the FIFO
274 * @fifo: pointer to FIFO
275 * @msg: message array to read
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.
281 static s32 fm10k_fifo_enqueue(struct fm10k_mbx_fifo *fifo, const u32 *msg)
283 u16 len = FM10K_TLV_DWORD_LEN(*msg);
285 /* verify parameters */
286 if (len > fifo->size)
287 return FM10K_MBX_ERR_SIZE;
289 /* verify there is room for the message */
290 if (len > fm10k_fifo_unused(fifo))
291 return FM10K_MBX_ERR_NO_SPACE;
293 /* Copy message into FIFO */
294 fm10k_fifo_write_copy(fifo, msg, 0, len);
296 /* memory barrier to guarantee FIFO is written before tail update */
299 /* Update Tx FIFO tail */
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
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.
313 static u16 fm10k_mbx_validate_msg_size(struct fm10k_mbx_info *mbx, u16 len)
315 struct fm10k_mbx_fifo *fifo = &mbx->rx;
316 u16 total_len = 0, msg_len;
319 /* length should include previous amounts pushed */
322 /* offset in message is based off of current message size */
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);
329 /* message extends out of pushed section, but fits in FIFO */
330 if ((len < total_len) && (msg_len <= mbx->max_size))
333 /* return length of invalid section */
334 return (len < total_len) ? len : (len - total_len);
338 * fm10k_mbx_write_copy - pulls data off of Tx FIFO and places it in mbmem
339 * @mbx: pointer to mailbox
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.
345 static void fm10k_mbx_write_copy(struct fm10k_hw *hw,
346 struct fm10k_mbx_info *mbx)
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;
356 /* determine data length and mbmem tail index */
357 mask = mbx->mbmem_len - 1;
359 tail = fm10k_mbx_tail_sub(mbx, len);
363 /* determine offset in the ring */
364 end = fm10k_fifo_head_offset(fifo, mbx->pulled);
367 /* memory barrier to guarantee data is ready to be read */
370 /* Copy message from Tx FIFO */
371 for (end = fifo->size - end; len; head = fifo->buffer) {
373 /* adjust tail to match offset for FIFO */
378 /* write message to hardware FIFO */
379 fm10k_write_reg(hw, mbmem + tail++, *(head++));
380 } while (--len && --end);
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
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.
395 static void fm10k_mbx_pull_head(struct fm10k_hw *hw,
396 struct fm10k_mbx_info *mbx, u16 head)
398 u16 mbmem_len, len, ack = fm10k_mbx_index_len(mbx, head, mbx->tail);
399 struct fm10k_mbx_fifo *fifo = &mbx->tx;
401 /* update number of bytes pulled and update bytes in transit */
402 mbx->pulled += mbx->tail_len - ack;
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;
410 /* update tail and record number of bytes in transit */
411 mbx->tail = fm10k_mbx_tail_add(mbx, len - ack);
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);
420 mbx->tx_dwords += len;
423 /* Copy message out from the Tx FIFO */
424 fm10k_mbx_write_copy(hw, mbx);
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
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.
436 static void fm10k_mbx_read_copy(struct fm10k_hw *hw,
437 struct fm10k_mbx_info *mbx)
439 struct fm10k_mbx_fifo *fifo = &mbx->rx;
440 u32 mbmem = mbx->mbmem_reg ^ mbx->mbmem_len;
441 u32 *tail = fifo->buffer;
444 /* determine data length and mbmem head index */
446 head = fm10k_mbx_head_sub(mbx, len);
447 if (head >= mbx->mbmem_len)
450 /* determine offset in the ring */
451 end = fm10k_fifo_tail_offset(fifo, mbx->pushed);
454 /* Copy message into Rx FIFO */
455 for (end = fifo->size - end; len; tail = fifo->buffer) {
457 /* adjust head to match offset for FIFO */
458 head &= mbx->mbmem_len - 1;
462 /* read message from hardware FIFO */
463 *(tail++) = fm10k_read_reg(hw, mbmem + head++);
464 } while (--len && --end);
467 /* memory barrier to guarantee FIFO is written before tail update */
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
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.
482 static s32 fm10k_mbx_push_tail(struct fm10k_hw *hw,
483 struct fm10k_mbx_info *mbx,
486 struct fm10k_mbx_fifo *fifo = &mbx->rx;
487 u16 len, seq = fm10k_mbx_index_len(mbx, mbx->head, tail);
489 /* determine length of data to push */
490 len = fm10k_fifo_unused(fifo) - mbx->pushed;
494 /* update head and record bytes received */
495 mbx->head = fm10k_mbx_head_add(mbx, len);
498 /* nothing to do if there is no data */
502 /* Copy msg into Rx FIFO */
503 fm10k_mbx_read_copy(hw, mbx);
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;
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)) {
519 mbx->rx_dwords += len;
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 };
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
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.
571 static u16 fm10k_crc_16b(const u32 *data, u16 seed, u16 len)
577 result = (result >> 8) ^ fm10k_crc_16b_table[result & 0xFF];
578 result = (result >> 8) ^ fm10k_crc_16b_table[result & 0xFF];
583 result = (result >> 8) ^ fm10k_crc_16b_table[result & 0xFF];
584 result = (result >> 8) ^ fm10k_crc_16b_table[result & 0xFF];
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
597 * This function generates a CRC for some region of the FIFO
599 static u16 fm10k_fifo_crc(struct fm10k_mbx_fifo *fifo, u16 offset,
602 u32 *data = fifo->buffer + offset;
604 /* track when we should cross the end of the FIFO */
605 offset = fifo->size - offset;
607 /* if we are in 2 blocks process the end of the FIFO first */
609 seed = fm10k_crc_16b(data, seed, offset * 2);
614 /* process any remaining bits */
615 return fm10k_crc_16b(data, seed, len * 2);
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
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
628 static void fm10k_mbx_update_local_crc(struct fm10k_mbx_info *mbx, u16 head)
630 u16 len = mbx->tail_len - fm10k_mbx_index_len(mbx, head, mbx->tail);
632 /* determine the offset for the start of the region to be pulled */
633 head = fm10k_fifo_head_offset(&mbx->tx, mbx->pulled);
635 /* update local CRC to include all of the pulled data */
636 mbx->local = fm10k_fifo_crc(&mbx->tx, head, len, mbx->local);
640 * fm10k_mbx_verify_remote_crc - Verify the CRC is correct for current data
641 * @mbx: pointer to mailbox
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
649 static s32 fm10k_mbx_verify_remote_crc(struct fm10k_mbx_info *mbx)
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;
656 /* update the remote CRC if new data has been received */
658 mbx->remote = fm10k_fifo_crc(fifo, offset, len, mbx->remote);
660 /* process the full header as we have to validate the CRC */
661 crc = fm10k_crc_16b(&mbx->mbx_hdr, mbx->remote, 1);
663 /* notify other end if we have a problem */
664 return crc ? FM10K_MBX_ERR_CRC : 0;
668 * fm10k_mbx_rx_ready - Indicates that a message is ready in the Rx FIFO
669 * @mbx: pointer to mailbox
671 * This function returns true if there is a message in the Rx FIFO to dequeue.
673 static bool fm10k_mbx_rx_ready(struct fm10k_mbx_info *mbx)
675 u16 msg_size = fm10k_fifo_head_len(&mbx->rx);
677 return msg_size && (fm10k_fifo_used(&mbx->rx) >= msg_size);
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
685 * This function returns true if the mailbox is in a state ready to transmit.
687 static bool fm10k_mbx_tx_ready(struct fm10k_mbx_info *mbx, u16 len)
689 u16 fifo_unused = fm10k_fifo_unused(&mbx->tx);
691 return (mbx->state == FM10K_STATE_OPEN) && (fifo_unused >= len);
695 * fm10k_mbx_tx_complete - Indicates that the Tx FIFO has been emptied
696 * @mbx: pointer to mailbox
698 * This function returns true if the Tx FIFO is empty.
700 static bool fm10k_mbx_tx_complete(struct fm10k_mbx_info *mbx)
702 return fm10k_fifo_empty(&mbx->tx);
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
710 * This function dequeues messages and hands them off to the tlv parser.
711 * It will return the number of messages processed when called.
713 static u16 fm10k_mbx_dequeue_rx(struct fm10k_hw *hw,
714 struct fm10k_mbx_info *mbx)
716 struct fm10k_mbx_fifo *fifo = &mbx->rx;
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,
727 fm10k_fifo_head_drop(fifo);
730 /* shift remaining bytes back to start of FIFO */
731 memmove(fifo->buffer, fifo->buffer + fifo->tail, mbx->pushed << 2);
733 /* shift head and tail based on the memory we moved */
734 fifo->tail -= fifo->head;
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
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.
750 static s32 fm10k_mbx_enqueue_tx(struct fm10k_hw *hw,
751 struct fm10k_mbx_info *mbx, const u32 *msg)
753 u32 countdown = mbx->timeout;
756 switch (mbx->state) {
757 case FM10K_STATE_CLOSED:
758 case FM10K_STATE_DISCONNECT:
759 return FM10K_MBX_ERR_NO_MBX;
764 /* enqueue the message on the Tx FIFO */
765 err = fm10k_fifo_enqueue(&mbx->tx, msg);
767 /* if it failed give the FIFO a chance to drain */
768 while (err && countdown) {
771 mbx->ops.process(hw, mbx);
772 err = fm10k_fifo_enqueue(&mbx->tx, msg);
775 /* if we failed treat the error */
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
786 mbx->ops.process(hw, mbx);
792 * fm10k_mbx_read - Copies the mbmem to local message buffer
793 * @hw: pointer to hardware structure
794 * @mbx: pointer to mailbox
796 * This function copies the message from the mbmem to the message array
798 static s32 fm10k_mbx_read(struct fm10k_hw *hw, struct fm10k_mbx_info *mbx)
800 /* only allow one reader in here at a time */
802 return FM10K_MBX_ERR_BUSY;
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;
808 /* write back interrupt bits to clear */
809 fm10k_write_reg(hw, mbx->mbx_reg,
810 FM10K_MBX_REQ_INTERRUPT | FM10K_MBX_ACK_INTERRUPT);
812 /* read remote header */
813 mbx->mbx_hdr = fm10k_read_reg(hw, mbx->mbmem_reg ^ mbx->mbmem_len);
819 * fm10k_mbx_write - Copies the local message buffer to mbmem
820 * @hw: pointer to hardware structure
821 * @mbx: pointer to mailbox
823 * This function copies the message from the the message array to mbmem
825 static void fm10k_mbx_write(struct fm10k_hw *hw, struct fm10k_mbx_info *mbx)
827 u32 mbmem = mbx->mbmem_reg;
829 /* write new msg header to notify recipient of change */
830 fm10k_write_reg(hw, mbmem, mbx->mbx_hdr);
832 /* write mailbox to send interrupt */
834 fm10k_write_reg(hw, mbx->mbx_reg, mbx->mbx_lock);
836 /* we no longer are using the header so free it */
842 * fm10k_mbx_create_connect_hdr - Generate a connect mailbox header
843 * @mbx: pointer to mailbox
845 * This function returns a connection mailbox header
847 static void fm10k_mbx_create_connect_hdr(struct fm10k_mbx_info *mbx)
849 mbx->mbx_lock |= FM10K_MBX_REQ;
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);
857 * fm10k_mbx_create_data_hdr - Generate a data mailbox header
858 * @mbx: pointer to mailbox
860 * This function returns a data mailbox header
862 static void fm10k_mbx_create_data_hdr(struct fm10k_mbx_info *mbx)
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;
871 mbx->mbx_lock |= FM10K_MBX_REQ;
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);
878 /* load header to memory to be written */
879 mbx->mbx_hdr = hdr | FM10K_MSG_HDR_FIELD_SET(crc, CRC);
883 * fm10k_mbx_create_disconnect_hdr - Generate a disconnect mailbox header
884 * @mbx: pointer to mailbox
886 * This function returns a disconnect mailbox header
888 static void fm10k_mbx_create_disconnect_hdr(struct fm10k_mbx_info *mbx)
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);
895 mbx->mbx_lock |= FM10K_MBX_ACK;
897 /* load header to memory to be written */
898 mbx->mbx_hdr = hdr | FM10K_MSG_HDR_FIELD_SET(crc, CRC);
902 * fm10k_mbx_create_error_msg - Generate a error message
903 * @mbx: pointer to mailbox
904 * @err: local error encountered
906 * This function will interpret the error provided by err, and based on
907 * that it may shift the message by 1 DWORD and then place an error header
908 * at the start of the message.
910 static void fm10k_mbx_create_error_msg(struct fm10k_mbx_info *mbx, s32 err)
912 /* only generate an error message for these types */
914 case FM10K_MBX_ERR_TAIL:
915 case FM10K_MBX_ERR_HEAD:
916 case FM10K_MBX_ERR_TYPE:
917 case FM10K_MBX_ERR_SIZE:
918 case FM10K_MBX_ERR_RSVD0:
919 case FM10K_MBX_ERR_CRC:
925 mbx->mbx_lock |= FM10K_MBX_REQ;
927 mbx->mbx_hdr = FM10K_MSG_HDR_FIELD_SET(FM10K_MSG_ERROR, TYPE) |
928 FM10K_MSG_HDR_FIELD_SET(err, ERR_NO) |
929 FM10K_MSG_HDR_FIELD_SET(mbx->head, HEAD);
933 * fm10k_mbx_validate_msg_hdr - Validate common fields in the message header
934 * @mbx: pointer to mailbox
935 * @msg: message array to read
937 * This function will parse up the fields in the mailbox header and return
938 * an error if the header contains any of a number of invalid configurations
939 * including unrecognized type, invalid route, or a malformed message.
941 static s32 fm10k_mbx_validate_msg_hdr(struct fm10k_mbx_info *mbx)
943 u16 type, rsvd0, head, tail, size;
944 const u32 *hdr = &mbx->mbx_hdr;
946 type = FM10K_MSG_HDR_FIELD_GET(*hdr, TYPE);
947 rsvd0 = FM10K_MSG_HDR_FIELD_GET(*hdr, RSVD0);
948 tail = FM10K_MSG_HDR_FIELD_GET(*hdr, TAIL);
949 head = FM10K_MSG_HDR_FIELD_GET(*hdr, HEAD);
950 size = FM10K_MSG_HDR_FIELD_GET(*hdr, CONNECT_SIZE);
953 return FM10K_MBX_ERR_RSVD0;
956 case FM10K_MSG_DISCONNECT:
957 /* validate that all data has been received */
958 if (tail != mbx->head)
959 return FM10K_MBX_ERR_TAIL;
963 /* validate that head is moving correctly */
964 if (!head || (head == FM10K_MSG_HDR_MASK(HEAD)))
965 return FM10K_MBX_ERR_HEAD;
966 if (fm10k_mbx_index_len(mbx, head, mbx->tail) > mbx->tail_len)
967 return FM10K_MBX_ERR_HEAD;
969 /* validate that tail is moving correctly */
970 if (!tail || (tail == FM10K_MSG_HDR_MASK(TAIL)))
971 return FM10K_MBX_ERR_TAIL;
972 if (fm10k_mbx_index_len(mbx, mbx->head, tail) < mbx->mbmem_len)
975 return FM10K_MBX_ERR_TAIL;
976 case FM10K_MSG_CONNECT:
977 /* validate size is in range and is power of 2 mask */
978 if ((size < FM10K_VFMBX_MSG_MTU) || (size & (size + 1)))
979 return FM10K_MBX_ERR_SIZE;
982 case FM10K_MSG_ERROR:
983 if (!head || (head == FM10K_MSG_HDR_MASK(HEAD)))
984 return FM10K_MBX_ERR_HEAD;
985 /* neither create nor error include a tail offset */
987 return FM10K_MBX_ERR_TAIL;
991 return FM10K_MBX_ERR_TYPE;
998 * fm10k_mbx_create_reply - Generate reply based on state and remote head
999 * @mbx: pointer to mailbox
1000 * @head: acknowledgement number
1002 * This function will generate an outgoing message based on the current
1003 * mailbox state and the remote fifo head. It will return the length
1004 * of the outgoing message excluding header on success, and a negative value
1007 static s32 fm10k_mbx_create_reply(struct fm10k_hw *hw,
1008 struct fm10k_mbx_info *mbx, u16 head)
1010 switch (mbx->state) {
1011 case FM10K_STATE_OPEN:
1012 case FM10K_STATE_DISCONNECT:
1013 /* update our checksum for the outgoing data */
1014 fm10k_mbx_update_local_crc(mbx, head);
1016 /* as long as other end recognizes us keep sending data */
1017 fm10k_mbx_pull_head(hw, mbx, head);
1019 /* generate new header based on data */
1020 if (mbx->tail_len || (mbx->state == FM10K_STATE_OPEN))
1021 fm10k_mbx_create_data_hdr(mbx);
1023 fm10k_mbx_create_disconnect_hdr(mbx);
1025 case FM10K_STATE_CONNECT:
1026 /* send disconnect even if we aren't connected */
1027 fm10k_mbx_create_connect_hdr(mbx);
1029 case FM10K_STATE_CLOSED:
1030 /* generate new header based on data */
1031 fm10k_mbx_create_disconnect_hdr(mbx);
1040 * fm10k_mbx_reset_work- Reset internal pointers for any pending work
1041 * @mbx: pointer to mailbox
1043 * This function will reset all internal pointers so any work in progress
1044 * is dropped. This call should occur every time we transition from the
1045 * open state to the connect state.
1047 static void fm10k_mbx_reset_work(struct fm10k_mbx_info *mbx)
1049 /* reset our outgoing max size back to Rx limits */
1050 mbx->max_size = mbx->rx.size - 1;
1052 /* just do a quick resysnc to start of message */
1062 * fm10k_mbx_update_max_size - Update the max_size and drop any large messages
1063 * @mbx: pointer to mailbox
1064 * @size: new value for max_size
1066 * This function updates the max_size value and drops any outgoing messages
1067 * at the head of the Tx FIFO if they are larger than max_size. It does not
1068 * drop all messages, as this is too difficult to parse and remove them from
1069 * the FIFO. Instead, rely on the checking to ensure that messages larger
1070 * than max_size aren't pushed into the memory buffer.
1072 static void fm10k_mbx_update_max_size(struct fm10k_mbx_info *mbx, u16 size)
1076 mbx->max_size = size;
1078 /* flush any oversized messages from the queue */
1079 for (len = fm10k_fifo_head_len(&mbx->tx);
1081 len = fm10k_fifo_head_len(&mbx->tx)) {
1082 fm10k_fifo_head_drop(&mbx->tx);
1088 * fm10k_mbx_connect_reset - Reset following request for reset
1089 * @mbx: pointer to mailbox
1091 * This function resets the mailbox to either a disconnected state
1092 * or a connect state depending on the current mailbox state
1094 static void fm10k_mbx_connect_reset(struct fm10k_mbx_info *mbx)
1096 /* just do a quick resysnc to start of frame */
1097 fm10k_mbx_reset_work(mbx);
1099 /* reset CRC seeds */
1100 mbx->local = FM10K_MBX_CRC_SEED;
1101 mbx->remote = FM10K_MBX_CRC_SEED;
1103 /* we cannot exit connect until the size is good */
1104 if (mbx->state == FM10K_STATE_OPEN)
1105 mbx->state = FM10K_STATE_CONNECT;
1107 mbx->state = FM10K_STATE_CLOSED;
1111 * fm10k_mbx_process_connect - Process connect header
1112 * @mbx: pointer to mailbox
1113 * @msg: message array to process
1115 * This function will read an incoming connect header and reply with the
1116 * appropriate message. It will return a value indicating the number of
1117 * data DWORDs on success, or will return a negative value on failure.
1119 static s32 fm10k_mbx_process_connect(struct fm10k_hw *hw,
1120 struct fm10k_mbx_info *mbx)
1122 const enum fm10k_mbx_state state = mbx->state;
1123 const u32 *hdr = &mbx->mbx_hdr;
1126 /* we will need to pull all of the fields for verification */
1127 size = FM10K_MSG_HDR_FIELD_GET(*hdr, CONNECT_SIZE);
1128 head = FM10K_MSG_HDR_FIELD_GET(*hdr, HEAD);
1131 case FM10K_STATE_DISCONNECT:
1132 case FM10K_STATE_OPEN:
1133 /* reset any in-progress work */
1134 fm10k_mbx_connect_reset(mbx);
1136 case FM10K_STATE_CONNECT:
1137 /* we cannot exit connect until the size is good */
1138 if (size > mbx->rx.size) {
1139 mbx->max_size = mbx->rx.size - 1;
1141 /* record the remote system requesting connection */
1142 mbx->state = FM10K_STATE_OPEN;
1144 fm10k_mbx_update_max_size(mbx, size);
1151 /* align our tail index to remote head index */
1154 return fm10k_mbx_create_reply(hw, mbx, head);
1158 * fm10k_mbx_process_data - Process data header
1159 * @mbx: pointer to mailbox
1161 * This function will read an incoming data header and reply with the
1162 * appropriate message. It will return a value indicating the number of
1163 * data DWORDs on success, or will return a negative value on failure.
1165 static s32 fm10k_mbx_process_data(struct fm10k_hw *hw,
1166 struct fm10k_mbx_info *mbx)
1168 const u32 *hdr = &mbx->mbx_hdr;
1172 /* we will need to pull all of the fields for verification */
1173 head = FM10K_MSG_HDR_FIELD_GET(*hdr, HEAD);
1174 tail = FM10K_MSG_HDR_FIELD_GET(*hdr, TAIL);
1176 /* if we are in connect just update our data and go */
1177 if (mbx->state == FM10K_STATE_CONNECT) {
1179 mbx->state = FM10K_STATE_OPEN;
1182 /* abort on message size errors */
1183 err = fm10k_mbx_push_tail(hw, mbx, tail);
1187 /* verify the checksum on the incoming data */
1188 err = fm10k_mbx_verify_remote_crc(mbx);
1192 /* process messages if we have received any */
1193 fm10k_mbx_dequeue_rx(hw, mbx);
1195 return fm10k_mbx_create_reply(hw, mbx, head);
1199 * fm10k_mbx_process_disconnect - Process disconnect header
1200 * @mbx: pointer to mailbox
1202 * This function will read an incoming disconnect header and reply with the
1203 * appropriate message. It will return a value indicating the number of
1204 * data DWORDs on success, or will return a negative value on failure.
1206 static s32 fm10k_mbx_process_disconnect(struct fm10k_hw *hw,
1207 struct fm10k_mbx_info *mbx)
1209 const enum fm10k_mbx_state state = mbx->state;
1210 const u32 *hdr = &mbx->mbx_hdr;
1214 /* we will need to pull the header field for verification */
1215 head = FM10K_MSG_HDR_FIELD_GET(*hdr, HEAD);
1217 /* We should not be receiving disconnect if Rx is incomplete */
1219 return FM10K_MBX_ERR_TAIL;
1221 /* we have already verified mbx->head == tail so we know this is 0 */
1224 /* verify the checksum on the incoming header is correct */
1225 err = fm10k_mbx_verify_remote_crc(mbx);
1230 case FM10K_STATE_DISCONNECT:
1231 case FM10K_STATE_OPEN:
1232 /* state doesn't change if we still have work to do */
1233 if (!fm10k_mbx_tx_complete(mbx))
1236 /* verify the head indicates we completed all transmits */
1237 if (head != mbx->tail)
1238 return FM10K_MBX_ERR_HEAD;
1240 /* reset any in-progress work */
1241 fm10k_mbx_connect_reset(mbx);
1247 return fm10k_mbx_create_reply(hw, mbx, head);
1251 * fm10k_mbx_process_error - Process error header
1252 * @mbx: pointer to mailbox
1254 * This function will read an incoming error header and reply with the
1255 * appropriate message. It will return a value indicating the number of
1256 * data DWORDs on success, or will return a negative value on failure.
1258 static s32 fm10k_mbx_process_error(struct fm10k_hw *hw,
1259 struct fm10k_mbx_info *mbx)
1261 const u32 *hdr = &mbx->mbx_hdr;
1265 /* we will need to pull all of the fields for verification */
1266 head = FM10K_MSG_HDR_FIELD_GET(*hdr, HEAD);
1268 /* we only have lower 10 bits of error number so add upper bits */
1269 err_no = FM10K_MSG_HDR_FIELD_GET(*hdr, ERR_NO);
1270 err_no |= ~FM10K_MSG_HDR_MASK(ERR_NO);
1272 switch (mbx->state) {
1273 case FM10K_STATE_OPEN:
1274 case FM10K_STATE_DISCONNECT:
1275 /* flush any uncompleted work */
1276 fm10k_mbx_reset_work(mbx);
1278 /* reset CRC seeds */
1279 mbx->local = FM10K_MBX_CRC_SEED;
1280 mbx->remote = FM10K_MBX_CRC_SEED;
1282 /* reset tail index and size to prepare for reconnect */
1285 /* if open then reset max_size and go back to connect */
1286 if (mbx->state == FM10K_STATE_OPEN) {
1287 mbx->state = FM10K_STATE_CONNECT;
1291 /* send a connect message to get data flowing again */
1292 fm10k_mbx_create_connect_hdr(mbx);
1298 return fm10k_mbx_create_reply(hw, mbx, mbx->tail);
1302 * fm10k_mbx_process - Process mailbox interrupt
1303 * @hw: pointer to hardware structure
1304 * @mbx: pointer to mailbox
1306 * This function will process incoming mailbox events and generate mailbox
1307 * replies. It will return a value indicating the number of DWORDs
1308 * transmitted excluding header on success or a negative value on error.
1310 static s32 fm10k_mbx_process(struct fm10k_hw *hw,
1311 struct fm10k_mbx_info *mbx)
1315 /* we do not read mailbox if closed */
1316 if (mbx->state == FM10K_STATE_CLOSED)
1319 /* copy data from mailbox */
1320 err = fm10k_mbx_read(hw, mbx);
1324 /* validate type, source, and destination */
1325 err = fm10k_mbx_validate_msg_hdr(mbx);
1329 switch (FM10K_MSG_HDR_FIELD_GET(mbx->mbx_hdr, TYPE)) {
1330 case FM10K_MSG_CONNECT:
1331 err = fm10k_mbx_process_connect(hw, mbx);
1333 case FM10K_MSG_DATA:
1334 err = fm10k_mbx_process_data(hw, mbx);
1336 case FM10K_MSG_DISCONNECT:
1337 err = fm10k_mbx_process_disconnect(hw, mbx);
1339 case FM10K_MSG_ERROR:
1340 err = fm10k_mbx_process_error(hw, mbx);
1343 err = FM10K_MBX_ERR_TYPE;
1348 /* notify partner of errors on our end */
1350 fm10k_mbx_create_error_msg(mbx, err);
1352 /* copy data from mailbox */
1353 fm10k_mbx_write(hw, mbx);
1359 * fm10k_mbx_disconnect - Shutdown mailbox connection
1360 * @hw: pointer to hardware structure
1361 * @mbx: pointer to mailbox
1363 * This function will shut down the mailbox. It places the mailbox first
1364 * in the disconnect state, it then allows up to a predefined timeout for
1365 * the mailbox to transition to close on its own. If this does not occur
1366 * then the mailbox will be forced into the closed state.
1368 * Any mailbox transactions not completed before calling this function
1369 * are not guaranteed to complete and may be dropped.
1371 static void fm10k_mbx_disconnect(struct fm10k_hw *hw,
1372 struct fm10k_mbx_info *mbx)
1374 int timeout = mbx->timeout ? FM10K_MBX_DISCONNECT_TIMEOUT : 0;
1376 /* Place mbx in ready to disconnect state */
1377 mbx->state = FM10K_STATE_DISCONNECT;
1379 /* trigger interrupt to start shutdown process */
1380 fm10k_write_reg(hw, mbx->mbx_reg, FM10K_MBX_REQ |
1381 FM10K_MBX_INTERRUPT_DISABLE);
1383 udelay(FM10K_MBX_POLL_DELAY);
1384 mbx->ops.process(hw, mbx);
1385 timeout -= FM10K_MBX_POLL_DELAY;
1386 } while ((timeout > 0) && (mbx->state != FM10K_STATE_CLOSED));
1388 /* in case we didn't close, just force the mailbox into shutdown and
1389 * drop all left over messages in the FIFO.
1391 fm10k_mbx_connect_reset(mbx);
1392 fm10k_fifo_drop_all(&mbx->tx);
1394 fm10k_write_reg(hw, mbx->mbmem_reg, 0);
1398 * fm10k_mbx_connect - Start mailbox connection
1399 * @hw: pointer to hardware structure
1400 * @mbx: pointer to mailbox
1402 * This function will initiate a mailbox connection. It will populate the
1403 * mailbox with a broadcast connect message and then initialize the lock.
1404 * This is safe since the connect message is a single DWORD so the mailbox
1405 * transaction is guaranteed to be atomic.
1407 * This function will return an error if the mailbox has not been initiated
1408 * or is currently in use.
1410 static s32 fm10k_mbx_connect(struct fm10k_hw *hw, struct fm10k_mbx_info *mbx)
1412 /* we cannot connect an uninitialized mailbox */
1413 if (!mbx->rx.buffer)
1414 return FM10K_MBX_ERR_NO_SPACE;
1416 /* we cannot connect an already connected mailbox */
1417 if (mbx->state != FM10K_STATE_CLOSED)
1418 return FM10K_MBX_ERR_BUSY;
1420 /* mailbox timeout can now become active */
1421 mbx->timeout = FM10K_MBX_INIT_TIMEOUT;
1423 /* Place mbx in ready to connect state */
1424 mbx->state = FM10K_STATE_CONNECT;
1426 /* initialize header of remote mailbox */
1427 fm10k_mbx_create_disconnect_hdr(mbx);
1428 fm10k_write_reg(hw, mbx->mbmem_reg ^ mbx->mbmem_len, mbx->mbx_hdr);
1430 /* enable interrupt and notify other party of new message */
1431 mbx->mbx_lock = FM10K_MBX_REQ_INTERRUPT | FM10K_MBX_ACK_INTERRUPT |
1432 FM10K_MBX_INTERRUPT_ENABLE;
1434 /* generate and load connect header into mailbox */
1435 fm10k_mbx_create_connect_hdr(mbx);
1436 fm10k_mbx_write(hw, mbx);
1442 * fm10k_mbx_validate_handlers - Validate layout of message parsing data
1443 * @msg_data: handlers for mailbox events
1445 * This function validates the layout of the message parsing data. This
1446 * should be mostly static, but it is important to catch any errors that
1447 * are made when constructing the parsers.
1449 static s32 fm10k_mbx_validate_handlers(const struct fm10k_msg_data *msg_data)
1451 const struct fm10k_tlv_attr *attr;
1454 /* Allow NULL mailboxes that transmit but don't receive */
1458 while (msg_data->id != FM10K_TLV_ERROR) {
1459 /* all messages should have a function handler */
1460 if (!msg_data->func)
1461 return FM10K_ERR_PARAM;
1463 /* parser is optional */
1464 attr = msg_data->attr;
1466 while (attr->id != FM10K_TLV_ERROR) {
1469 /* ID should always be increasing */
1471 return FM10K_ERR_PARAM;
1472 /* ID should fit in results array */
1473 if (id >= FM10K_TLV_RESULTS_MAX)
1474 return FM10K_ERR_PARAM;
1477 /* verify terminator is in the list */
1478 if (attr->id != FM10K_TLV_ERROR)
1479 return FM10K_ERR_PARAM;
1484 /* ID should always be increasing */
1485 if (id >= msg_data->id)
1486 return FM10K_ERR_PARAM;
1489 /* verify terminator is in the list */
1490 if ((msg_data->id != FM10K_TLV_ERROR) || !msg_data->func)
1491 return FM10K_ERR_PARAM;
1497 * fm10k_mbx_register_handlers - Register a set of handler ops for mailbox
1498 * @mbx: pointer to mailbox
1499 * @msg_data: handlers for mailbox events
1501 * This function associates a set of message handling ops with a mailbox.
1503 static s32 fm10k_mbx_register_handlers(struct fm10k_mbx_info *mbx,
1504 const struct fm10k_msg_data *msg_data)
1506 /* validate layout of handlers before assigning them */
1507 if (fm10k_mbx_validate_handlers(msg_data))
1508 return FM10K_ERR_PARAM;
1510 /* initialize the message handlers */
1511 mbx->msg_data = msg_data;
1517 * fm10k_pfvf_mbx_init - Initialize mailbox memory for PF/VF mailbox
1518 * @hw: pointer to hardware structure
1519 * @mbx: pointer to mailbox
1520 * @msg_data: handlers for mailbox events
1521 * @id: ID reference for PF as it supports up to 64 PF/VF mailboxes
1523 * This function initializes the mailbox for use. It will split the
1524 * buffer provided an use that th populate both the Tx and Rx FIFO by
1525 * evenly splitting it. In order to allow for easy masking of head/tail
1526 * the value reported in size must be a power of 2 and is reported in
1527 * DWORDs, not bytes. Any invalid values will cause the mailbox to return
1530 s32 fm10k_pfvf_mbx_init(struct fm10k_hw *hw, struct fm10k_mbx_info *mbx,
1531 const struct fm10k_msg_data *msg_data, u8 id)
1533 /* initialize registers */
1534 switch (hw->mac.type) {
1536 mbx->mbx_reg = FM10K_VFMBX;
1537 mbx->mbmem_reg = FM10K_VFMBMEM(FM10K_VFMBMEM_VF_XOR);
1540 /* there are only 64 VF <-> PF mailboxes */
1542 mbx->mbx_reg = FM10K_MBX(id);
1543 mbx->mbmem_reg = FM10K_MBMEM_VF(id, 0);
1548 return FM10K_MBX_ERR_NO_MBX;
1551 /* start out in closed state */
1552 mbx->state = FM10K_STATE_CLOSED;
1554 /* validate layout of handlers before assigning them */
1555 if (fm10k_mbx_validate_handlers(msg_data))
1556 return FM10K_ERR_PARAM;
1558 /* initialize the message handlers */
1559 mbx->msg_data = msg_data;
1561 /* start mailbox as timed out and let the reset_hw call
1562 * set the timeout value to begin communications
1565 mbx->udelay = FM10K_MBX_INIT_DELAY;
1567 /* initialize tail and head */
1571 /* initialize CRC seeds */
1572 mbx->local = FM10K_MBX_CRC_SEED;
1573 mbx->remote = FM10K_MBX_CRC_SEED;
1575 /* Split buffer for use by Tx/Rx FIFOs */
1576 mbx->max_size = FM10K_MBX_MSG_MAX_SIZE;
1577 mbx->mbmem_len = FM10K_VFMBMEM_VF_XOR;
1579 /* initialize the FIFOs, sizes are in 4 byte increments */
1580 fm10k_fifo_init(&mbx->tx, mbx->buffer, FM10K_MBX_TX_BUFFER_SIZE);
1581 fm10k_fifo_init(&mbx->rx, &mbx->buffer[FM10K_MBX_TX_BUFFER_SIZE],
1582 FM10K_MBX_RX_BUFFER_SIZE);
1584 /* initialize function pointers */
1585 mbx->ops.connect = fm10k_mbx_connect;
1586 mbx->ops.disconnect = fm10k_mbx_disconnect;
1587 mbx->ops.rx_ready = fm10k_mbx_rx_ready;
1588 mbx->ops.tx_ready = fm10k_mbx_tx_ready;
1589 mbx->ops.tx_complete = fm10k_mbx_tx_complete;
1590 mbx->ops.enqueue_tx = fm10k_mbx_enqueue_tx;
1591 mbx->ops.process = fm10k_mbx_process;
1592 mbx->ops.register_handlers = fm10k_mbx_register_handlers;
1598 * fm10k_sm_mbx_create_data_hdr - Generate a mailbox header for local FIFO
1599 * @mbx: pointer to mailbox
1601 * This function returns a connection mailbox header
1603 static void fm10k_sm_mbx_create_data_hdr(struct fm10k_mbx_info *mbx)
1606 mbx->mbx_lock |= FM10K_MBX_REQ;
1608 mbx->mbx_hdr = FM10K_MSG_HDR_FIELD_SET(mbx->tail, SM_TAIL) |
1609 FM10K_MSG_HDR_FIELD_SET(mbx->remote, SM_VER) |
1610 FM10K_MSG_HDR_FIELD_SET(mbx->head, SM_HEAD);
1614 * fm10k_sm_mbx_create_connect_hdr - Generate a mailbox header for local FIFO
1615 * @mbx: pointer to mailbox
1616 * @err: error flags to report if any
1618 * This function returns a connection mailbox header
1620 static void fm10k_sm_mbx_create_connect_hdr(struct fm10k_mbx_info *mbx, u8 err)
1623 mbx->mbx_lock |= FM10K_MBX_REQ;
1625 mbx->mbx_hdr = FM10K_MSG_HDR_FIELD_SET(mbx->tail, SM_TAIL) |
1626 FM10K_MSG_HDR_FIELD_SET(mbx->remote, SM_VER) |
1627 FM10K_MSG_HDR_FIELD_SET(mbx->head, SM_HEAD) |
1628 FM10K_MSG_HDR_FIELD_SET(err, SM_ERR);
1632 * fm10k_sm_mbx_connect_reset - Reset following request for reset
1633 * @mbx: pointer to mailbox
1635 * This function resets the mailbox to a just connected state
1637 static void fm10k_sm_mbx_connect_reset(struct fm10k_mbx_info *mbx)
1639 /* flush any uncompleted work */
1640 fm10k_mbx_reset_work(mbx);
1642 /* set local version to max and remote version to 0 */
1643 mbx->local = FM10K_SM_MBX_VERSION;
1646 /* initialize tail and head */
1650 /* reset state back to connect */
1651 mbx->state = FM10K_STATE_CONNECT;
1655 * fm10k_sm_mbx_connect - Start switch manager mailbox connection
1656 * @hw: pointer to hardware structure
1657 * @mbx: pointer to mailbox
1659 * This function will initiate a mailbox connection with the switch
1660 * manager. To do this it will first disconnect the mailbox, and then
1661 * reconnect it in order to complete a reset of the mailbox.
1663 * This function will return an error if the mailbox has not been initiated
1664 * or is currently in use.
1666 static s32 fm10k_sm_mbx_connect(struct fm10k_hw *hw, struct fm10k_mbx_info *mbx)
1668 /* we cannot connect an uninitialized mailbox */
1669 if (!mbx->rx.buffer)
1670 return FM10K_MBX_ERR_NO_SPACE;
1672 /* we cannot connect an already connected mailbox */
1673 if (mbx->state != FM10K_STATE_CLOSED)
1674 return FM10K_MBX_ERR_BUSY;
1676 /* mailbox timeout can now become active */
1677 mbx->timeout = FM10K_MBX_INIT_TIMEOUT;
1679 /* Place mbx in ready to connect state */
1680 mbx->state = FM10K_STATE_CONNECT;
1681 mbx->max_size = FM10K_MBX_MSG_MAX_SIZE;
1683 /* reset interface back to connect */
1684 fm10k_sm_mbx_connect_reset(mbx);
1686 /* enable interrupt and notify other party of new message */
1687 mbx->mbx_lock = FM10K_MBX_REQ_INTERRUPT | FM10K_MBX_ACK_INTERRUPT |
1688 FM10K_MBX_INTERRUPT_ENABLE;
1690 /* generate and load connect header into mailbox */
1691 fm10k_sm_mbx_create_connect_hdr(mbx, 0);
1692 fm10k_mbx_write(hw, mbx);
1694 /* enable interrupt and notify other party of new message */
1700 * fm10k_sm_mbx_disconnect - Shutdown mailbox connection
1701 * @hw: pointer to hardware structure
1702 * @mbx: pointer to mailbox
1704 * This function will shut down the mailbox. It places the mailbox first
1705 * in the disconnect state, it then allows up to a predefined timeout for
1706 * the mailbox to transition to close on its own. If this does not occur
1707 * then the mailbox will be forced into the closed state.
1709 * Any mailbox transactions not completed before calling this function
1710 * are not guaranteed to complete and may be dropped.
1712 static void fm10k_sm_mbx_disconnect(struct fm10k_hw *hw,
1713 struct fm10k_mbx_info *mbx)
1715 int timeout = mbx->timeout ? FM10K_MBX_DISCONNECT_TIMEOUT : 0;
1717 /* Place mbx in ready to disconnect state */
1718 mbx->state = FM10K_STATE_DISCONNECT;
1720 /* trigger interrupt to start shutdown process */
1721 fm10k_write_reg(hw, mbx->mbx_reg, FM10K_MBX_REQ |
1722 FM10K_MBX_INTERRUPT_DISABLE);
1724 udelay(FM10K_MBX_POLL_DELAY);
1725 mbx->ops.process(hw, mbx);
1726 timeout -= FM10K_MBX_POLL_DELAY;
1727 } while ((timeout > 0) && (mbx->state != FM10K_STATE_CLOSED));
1729 /* in case we didn't close just force the mailbox into shutdown */
1730 mbx->state = FM10K_STATE_CLOSED;
1732 fm10k_mbx_reset_work(mbx);
1733 fm10k_mbx_update_max_size(mbx, 0);
1735 fm10k_write_reg(hw, mbx->mbmem_reg, 0);
1739 * fm10k_mbx_validate_fifo_hdr - Validate fields in the remote FIFO header
1740 * @mbx: pointer to mailbox
1742 * This function will parse up the fields in the mailbox header and return
1743 * an error if the header contains any of a number of invalid configurations
1744 * including unrecognized offsets or version numbers.
1746 static s32 fm10k_sm_mbx_validate_fifo_hdr(struct fm10k_mbx_info *mbx)
1748 const u32 *hdr = &mbx->mbx_hdr;
1749 u16 tail, head, ver;
1751 tail = FM10K_MSG_HDR_FIELD_GET(*hdr, SM_TAIL);
1752 ver = FM10K_MSG_HDR_FIELD_GET(*hdr, SM_VER);
1753 head = FM10K_MSG_HDR_FIELD_GET(*hdr, SM_HEAD);
1758 case FM10K_SM_MBX_VERSION:
1759 if (!head || head > FM10K_SM_MBX_FIFO_LEN)
1760 return FM10K_MBX_ERR_HEAD;
1761 if (!tail || tail > FM10K_SM_MBX_FIFO_LEN)
1762 return FM10K_MBX_ERR_TAIL;
1763 if (mbx->tail < head)
1764 head += mbx->mbmem_len - 1;
1765 if (tail < mbx->head)
1766 tail += mbx->mbmem_len - 1;
1767 if (fm10k_mbx_index_len(mbx, head, mbx->tail) > mbx->tail_len)
1768 return FM10K_MBX_ERR_HEAD;
1769 if (fm10k_mbx_index_len(mbx, mbx->head, tail) < mbx->mbmem_len)
1771 return FM10K_MBX_ERR_TAIL;
1773 return FM10K_MBX_ERR_SRC;
1780 * fm10k_sm_mbx_process_error - Process header with error flag set
1781 * @mbx: pointer to mailbox
1783 * This function is meant to respond to a request where the error flag
1784 * is set. As a result we will terminate a connection if one is present
1785 * and fall back into the reset state with a connection header of version
1788 static void fm10k_sm_mbx_process_error(struct fm10k_mbx_info *mbx)
1790 const enum fm10k_mbx_state state = mbx->state;
1793 case FM10K_STATE_DISCONNECT:
1794 /* if there is an error just disconnect */
1797 case FM10K_STATE_OPEN:
1798 /* flush any uncompleted work */
1799 fm10k_sm_mbx_connect_reset(mbx);
1801 case FM10K_STATE_CONNECT:
1802 /* try connnecting at lower version */
1804 while (mbx->local > 1)
1813 fm10k_sm_mbx_create_connect_hdr(mbx, 0);
1817 * fm10k_sm_mbx_create_error_message - Process an error in FIFO hdr
1818 * @mbx: pointer to mailbox
1819 * @err: local error encountered
1821 * This function will interpret the error provided by err, and based on
1822 * that it may set the error bit in the local message header
1824 static void fm10k_sm_mbx_create_error_msg(struct fm10k_mbx_info *mbx, s32 err)
1826 /* only generate an error message for these types */
1828 case FM10K_MBX_ERR_TAIL:
1829 case FM10K_MBX_ERR_HEAD:
1830 case FM10K_MBX_ERR_SRC:
1831 case FM10K_MBX_ERR_SIZE:
1832 case FM10K_MBX_ERR_RSVD0:
1838 /* process it as though we received an error, and send error reply */
1839 fm10k_sm_mbx_process_error(mbx);
1840 fm10k_sm_mbx_create_connect_hdr(mbx, 1);
1844 * fm10k_sm_mbx_receive - Take message from Rx mailbox FIFO and put it in Rx
1845 * @hw: pointer to hardware structure
1846 * @mbx: pointer to mailbox
1848 * This function will dequeue one message from the Rx switch manager mailbox
1849 * FIFO and place it in the Rx mailbox FIFO for processing by software.
1851 static s32 fm10k_sm_mbx_receive(struct fm10k_hw *hw,
1852 struct fm10k_mbx_info *mbx,
1855 /* reduce length by 1 to convert to a mask */
1856 u16 mbmem_len = mbx->mbmem_len - 1;
1859 /* push tail in front of head */
1860 if (tail < mbx->head)
1863 /* copy data to the Rx FIFO */
1864 err = fm10k_mbx_push_tail(hw, mbx, tail);
1868 /* process messages if we have received any */
1869 fm10k_mbx_dequeue_rx(hw, mbx);
1871 /* guarantee head aligns with the end of the last message */
1872 mbx->head = fm10k_mbx_head_sub(mbx, mbx->pushed);
1875 /* clear any extra bits left over since index adds 1 extra bit */
1876 if (mbx->head > mbmem_len)
1877 mbx->head -= mbmem_len;
1883 * fm10k_sm_mbx_transmit - Take message from Tx and put it in Tx mailbox FIFO
1884 * @hw: pointer to hardware structure
1885 * @mbx: pointer to mailbox
1887 * This function will dequeue one message from the Tx mailbox FIFO and place
1888 * it in the Tx switch manager mailbox FIFO for processing by hardware.
1890 static void fm10k_sm_mbx_transmit(struct fm10k_hw *hw,
1891 struct fm10k_mbx_info *mbx, u16 head)
1893 struct fm10k_mbx_fifo *fifo = &mbx->tx;
1894 /* reduce length by 1 to convert to a mask */
1895 u16 mbmem_len = mbx->mbmem_len - 1;
1896 u16 tail_len, len = 0;
1899 /* push head behind tail */
1900 if (mbx->tail < head)
1903 fm10k_mbx_pull_head(hw, mbx, head);
1905 /* determine msg aligned offset for end of buffer */
1907 msg = fifo->buffer + fm10k_fifo_head_offset(fifo, len);
1909 len += FM10K_TLV_DWORD_LEN(*msg);
1910 } while ((len <= mbx->tail_len) && (len < mbmem_len));
1912 /* guarantee we stop on a message boundary */
1913 if (mbx->tail_len > tail_len) {
1914 mbx->tail = fm10k_mbx_tail_sub(mbx, mbx->tail_len - tail_len);
1915 mbx->tail_len = tail_len;
1918 /* clear any extra bits left over since index adds 1 extra bit */
1919 if (mbx->tail > mbmem_len)
1920 mbx->tail -= mbmem_len;
1924 * fm10k_sm_mbx_create_reply - Generate reply based on state and remote head
1925 * @mbx: pointer to mailbox
1926 * @head: acknowledgement number
1928 * This function will generate an outgoing message based on the current
1929 * mailbox state and the remote fifo head. It will return the length
1930 * of the outgoing message excluding header on success, and a negative value
1933 static void fm10k_sm_mbx_create_reply(struct fm10k_hw *hw,
1934 struct fm10k_mbx_info *mbx, u16 head)
1936 switch (mbx->state) {
1937 case FM10K_STATE_OPEN:
1938 case FM10K_STATE_DISCONNECT:
1939 /* flush out Tx data */
1940 fm10k_sm_mbx_transmit(hw, mbx, head);
1942 /* generate new header based on data */
1943 if (mbx->tail_len || (mbx->state == FM10K_STATE_OPEN)) {
1944 fm10k_sm_mbx_create_data_hdr(mbx);
1947 fm10k_sm_mbx_create_connect_hdr(mbx, 0);
1950 case FM10K_STATE_CONNECT:
1951 case FM10K_STATE_CLOSED:
1952 fm10k_sm_mbx_create_connect_hdr(mbx, 0);
1960 * fm10k_sm_mbx_process_reset - Process header with version == 0 (RESET)
1961 * @hw: pointer to hardware structure
1962 * @mbx: pointer to mailbox
1964 * This function is meant to respond to a request where the version data
1965 * is set to 0. As such we will either terminate the connection or go
1966 * into the connect state in order to re-establish the connection. This
1967 * function can also be used to respond to an error as the connection
1968 * resetting would also be a means of dealing with errors.
1970 static void fm10k_sm_mbx_process_reset(struct fm10k_hw *hw,
1971 struct fm10k_mbx_info *mbx)
1973 const enum fm10k_mbx_state state = mbx->state;
1976 case FM10K_STATE_DISCONNECT:
1977 /* drop remote connections and disconnect */
1978 mbx->state = FM10K_STATE_CLOSED;
1982 case FM10K_STATE_OPEN:
1983 /* flush any incomplete work */
1984 fm10k_sm_mbx_connect_reset(mbx);
1986 case FM10K_STATE_CONNECT:
1987 /* Update remote value to match local value */
1988 mbx->remote = mbx->local;
1993 fm10k_sm_mbx_create_reply(hw, mbx, mbx->tail);
1997 * fm10k_sm_mbx_process_version_1 - Process header with version == 1
1998 * @hw: pointer to hardware structure
1999 * @mbx: pointer to mailbox
2001 * This function is meant to process messages received when the remote
2002 * mailbox is active.
2004 static s32 fm10k_sm_mbx_process_version_1(struct fm10k_hw *hw,
2005 struct fm10k_mbx_info *mbx)
2007 const u32 *hdr = &mbx->mbx_hdr;
2011 /* pull all fields needed for verification */
2012 tail = FM10K_MSG_HDR_FIELD_GET(*hdr, SM_TAIL);
2013 head = FM10K_MSG_HDR_FIELD_GET(*hdr, SM_HEAD);
2015 /* if we are in connect and wanting version 1 then start up and go */
2016 if (mbx->state == FM10K_STATE_CONNECT) {
2019 if (mbx->remote != 1)
2020 return FM10K_MBX_ERR_SRC;
2022 mbx->state = FM10K_STATE_OPEN;
2026 /* abort on message size errors */
2027 len = fm10k_sm_mbx_receive(hw, mbx, tail);
2031 /* continue until we have flushed the Rx FIFO */
2035 fm10k_sm_mbx_create_reply(hw, mbx, head);
2041 * fm10k_sm_mbx_process - Process mailbox switch mailbox interrupt
2042 * @hw: pointer to hardware structure
2043 * @mbx: pointer to mailbox
2045 * This function will process incoming mailbox events and generate mailbox
2046 * replies. It will return a value indicating the number of DWORDs
2047 * transmitted excluding header on success or a negative value on error.
2049 static s32 fm10k_sm_mbx_process(struct fm10k_hw *hw,
2050 struct fm10k_mbx_info *mbx)
2054 /* we do not read mailbox if closed */
2055 if (mbx->state == FM10K_STATE_CLOSED)
2058 /* retrieve data from switch manager */
2059 err = fm10k_mbx_read(hw, mbx);
2063 err = fm10k_sm_mbx_validate_fifo_hdr(mbx);
2067 if (FM10K_MSG_HDR_FIELD_GET(mbx->mbx_hdr, SM_ERR)) {
2068 fm10k_sm_mbx_process_error(mbx);
2072 switch (FM10K_MSG_HDR_FIELD_GET(mbx->mbx_hdr, SM_VER)) {
2074 fm10k_sm_mbx_process_reset(hw, mbx);
2076 case FM10K_SM_MBX_VERSION:
2077 err = fm10k_sm_mbx_process_version_1(hw, mbx);
2083 fm10k_sm_mbx_create_error_msg(mbx, err);
2085 /* report data to switch manager */
2086 fm10k_mbx_write(hw, mbx);
2092 * fm10k_sm_mbx_init - Initialize mailbox memory for PF/SM mailbox
2093 * @hw: pointer to hardware structure
2094 * @mbx: pointer to mailbox
2095 * @msg_data: handlers for mailbox events
2097 * This function for now is used to stub out the PF/SM mailbox
2099 s32 fm10k_sm_mbx_init(struct fm10k_hw *hw, struct fm10k_mbx_info *mbx,
2100 const struct fm10k_msg_data *msg_data)
2102 mbx->mbx_reg = FM10K_GMBX;
2103 mbx->mbmem_reg = FM10K_MBMEM_PF(0);
2104 /* start out in closed state */
2105 mbx->state = FM10K_STATE_CLOSED;
2107 /* validate layout of handlers before assigning them */
2108 if (fm10k_mbx_validate_handlers(msg_data))
2109 return FM10K_ERR_PARAM;
2111 /* initialize the message handlers */
2112 mbx->msg_data = msg_data;
2114 /* start mailbox as timed out and let the reset_hw call
2115 * set the timeout value to begin communications
2118 mbx->udelay = FM10K_MBX_INIT_DELAY;
2120 /* Split buffer for use by Tx/Rx FIFOs */
2121 mbx->max_size = FM10K_MBX_MSG_MAX_SIZE;
2122 mbx->mbmem_len = FM10K_MBMEM_PF_XOR;
2124 /* initialize the FIFOs, sizes are in 4 byte increments */
2125 fm10k_fifo_init(&mbx->tx, mbx->buffer, FM10K_MBX_TX_BUFFER_SIZE);
2126 fm10k_fifo_init(&mbx->rx, &mbx->buffer[FM10K_MBX_TX_BUFFER_SIZE],
2127 FM10K_MBX_RX_BUFFER_SIZE);
2129 /* initialize function pointers */
2130 mbx->ops.connect = fm10k_sm_mbx_connect;
2131 mbx->ops.disconnect = fm10k_sm_mbx_disconnect;
2132 mbx->ops.rx_ready = fm10k_mbx_rx_ready;
2133 mbx->ops.tx_ready = fm10k_mbx_tx_ready;
2134 mbx->ops.tx_complete = fm10k_mbx_tx_complete;
2135 mbx->ops.enqueue_tx = fm10k_mbx_enqueue_tx;
2136 mbx->ops.process = fm10k_sm_mbx_process;
2137 mbx->ops.register_handlers = fm10k_mbx_register_handlers;