diff options
Diffstat (limited to 'src/dpdk22/drivers/net/fm10k/base/fm10k_mbx.c')
| -rw-r--r-- | src/dpdk22/drivers/net/fm10k/base/fm10k_mbx.c | 2239 |
1 files changed, 0 insertions, 2239 deletions
diff --git a/src/dpdk22/drivers/net/fm10k/base/fm10k_mbx.c b/src/dpdk22/drivers/net/fm10k/base/fm10k_mbx.c deleted file mode 100644 index 3c9ab3a5..00000000 --- a/src/dpdk22/drivers/net/fm10k/base/fm10k_mbx.c +++ /dev/null @@ -1,2239 +0,0 @@ -/******************************************************************************* - -Copyright (c) 2013 - 2015, Intel Corporation -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - - 1. Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - - 2. Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in the - documentation and/or other materials provided with the distribution. - - 3. Neither the name of the Intel Corporation nor the names of its - contributors may be used to endorse or promote products derived from - this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE -ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE -LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR -CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF -SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS -INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN -CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) -ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE -POSSIBILITY OF SUCH DAMAGE. - -***************************************************************************/ - -#include "fm10k_common.h" - -/** - * fm10k_fifo_init - Initialize a message FIFO - * @fifo: pointer to FIFO - * @buffer: pointer to memory to be used to store FIFO - * @size: maximum message size to store in FIFO, must be 2^n - 1 - **/ -STATIC void fm10k_fifo_init(struct fm10k_mbx_fifo *fifo, u32 *buffer, u16 size) -{ - fifo->buffer = buffer; - fifo->size = size; - fifo->head = 0; - fifo->tail = 0; -} - -/** - * fm10k_fifo_used - Retrieve used space in FIFO - * @fifo: pointer to FIFO - * - * This function returns the number of DWORDs used in the FIFO - **/ -STATIC u16 fm10k_fifo_used(struct fm10k_mbx_fifo *fifo) -{ - return fifo->tail - fifo->head; -} - -/** - * fm10k_fifo_unused - Retrieve unused space in FIFO - * @fifo: pointer to FIFO - * - * This function returns the number of unused DWORDs in the FIFO - **/ -STATIC u16 fm10k_fifo_unused(struct fm10k_mbx_fifo *fifo) -{ - return fifo->size + fifo->head - fifo->tail; -} - -/** - * fm10k_fifo_empty - Test to verify if fifo is empty - * @fifo: pointer to FIFO - * - * This function returns true if the FIFO is empty, else false - **/ -STATIC bool fm10k_fifo_empty(struct fm10k_mbx_fifo *fifo) -{ - return fifo->head == fifo->tail; -} - -/** - * fm10k_fifo_head_offset - returns indices of head with given offset - * @fifo: pointer to FIFO - * @offset: offset to add to head - * - * This function returns the indices into the fifo based on head + offset - **/ -STATIC u16 fm10k_fifo_head_offset(struct fm10k_mbx_fifo *fifo, u16 offset) -{ - return (fifo->head + offset) & (fifo->size - 1); -} - -/** - * fm10k_fifo_tail_offset - returns indices of tail with given offset - * @fifo: pointer to FIFO - * @offset: offset to add to tail - * - * This function returns the indices into the fifo based on tail + offset - **/ -STATIC u16 fm10k_fifo_tail_offset(struct fm10k_mbx_fifo *fifo, u16 offset) -{ - return (fifo->tail + offset) & (fifo->size - 1); -} - -/** - * fm10k_fifo_head_len - Retrieve length of first message in FIFO - * @fifo: pointer to FIFO - * - * This function returns the size of the first message in the FIFO - **/ -STATIC u16 fm10k_fifo_head_len(struct fm10k_mbx_fifo *fifo) -{ - u32 *head = fifo->buffer + fm10k_fifo_head_offset(fifo, 0); - - /* verify there is at least 1 DWORD in the fifo so *head is valid */ - if (fm10k_fifo_empty(fifo)) - return 0; - - /* retieve the message length */ - return FM10K_TLV_DWORD_LEN(*head); -} - -/** - * fm10k_fifo_head_drop - Drop the first message in FIFO - * @fifo: pointer to FIFO - * - * This function returns the size of the message dropped from the FIFO - **/ -STATIC u16 fm10k_fifo_head_drop(struct fm10k_mbx_fifo *fifo) -{ - u16 len = fm10k_fifo_head_len(fifo); - - /* update head so it is at the start of next frame */ - fifo->head += len; - - return len; -} - -/** - * fm10k_fifo_drop_all - Drop all messages in FIFO - * @fifo: pointer to FIFO - * - * This function resets the head pointer to drop all messages in the FIFO and - * ensure the FIFO is empty. - **/ -STATIC void fm10k_fifo_drop_all(struct fm10k_mbx_fifo *fifo) -{ - fifo->head = fifo->tail; -} - -/** - * fm10k_mbx_index_len - Convert a head/tail index into a length value - * @mbx: pointer to mailbox - * @head: head index - * @tail: head index - * - * This function takes the head and tail index and determines the length - * of the data indicated by this pair. - **/ -STATIC u16 fm10k_mbx_index_len(struct fm10k_mbx_info *mbx, u16 head, u16 tail) -{ - u16 len = tail - head; - - /* we wrapped so subtract 2, one for index 0, one for all 1s index */ - if (len > tail) - len -= 2; - - return len & ((mbx->mbmem_len << 1) - 1); -} - -/** - * fm10k_mbx_tail_add - Determine new tail value with added offset - * @mbx: pointer to mailbox - * @offset: length to add to head offset - * - * This function takes the local tail index and recomputes it for - * a given length added as an offset. - **/ -STATIC u16 fm10k_mbx_tail_add(struct fm10k_mbx_info *mbx, u16 offset) -{ - u16 tail = (mbx->tail + offset + 1) & ((mbx->mbmem_len << 1) - 1); - - /* add/sub 1 because we cannot have offset 0 or all 1s */ - return (tail > mbx->tail) ? --tail : ++tail; -} - -/** - * fm10k_mbx_tail_sub - Determine new tail value with subtracted offset - * @mbx: pointer to mailbox - * @offset: length to add to head offset - * - * This function takes the local tail index and recomputes it for - * a given length added as an offset. - **/ -STATIC u16 fm10k_mbx_tail_sub(struct fm10k_mbx_info *mbx, u16 offset) -{ - u16 tail = (mbx->tail - offset - 1) & ((mbx->mbmem_len << 1) - 1); - - /* sub/add 1 because we cannot have offset 0 or all 1s */ - return (tail < mbx->tail) ? ++tail : --tail; -} - -/** - * fm10k_mbx_head_add - Determine new head value with added offset - * @mbx: pointer to mailbox - * @offset: length to add to head offset - * - * This function takes the local head index and recomputes it for - * a given length added as an offset. - **/ -STATIC u16 fm10k_mbx_head_add(struct fm10k_mbx_info *mbx, u16 offset) -{ - u16 head = (mbx->head + offset + 1) & ((mbx->mbmem_len << 1) - 1); - - /* add/sub 1 because we cannot have offset 0 or all 1s */ - return (head > mbx->head) ? --head : ++head; -} - -/** - * fm10k_mbx_head_sub - Determine new head value with subtracted offset - * @mbx: pointer to mailbox - * @offset: length to add to head offset - * - * This function takes the local head index and recomputes it for - * a given length added as an offset. - **/ -STATIC u16 fm10k_mbx_head_sub(struct fm10k_mbx_info *mbx, u16 offset) -{ - u16 head = (mbx->head - offset - 1) & ((mbx->mbmem_len << 1) - 1); - - /* sub/add 1 because we cannot have offset 0 or all 1s */ - return (head < mbx->head) ? ++head : --head; -} - -/** - * fm10k_mbx_pushed_tail_len - Retrieve the length of message being pushed - * @mbx: pointer to mailbox - * - * This function will return the length of the message currently being - * pushed onto the tail of the Rx queue. - **/ -STATIC u16 fm10k_mbx_pushed_tail_len(struct fm10k_mbx_info *mbx) -{ - u32 *tail = mbx->rx.buffer + fm10k_fifo_tail_offset(&mbx->rx, 0); - - /* pushed tail is only valid if pushed is set */ - if (!mbx->pushed) - return 0; - - return FM10K_TLV_DWORD_LEN(*tail); -} - -/** - * fm10k_fifo_write_copy - pulls data off of msg and places it in fifo - * @fifo: pointer to FIFO - * @msg: message array to populate - * @tail_offset: additional offset to add to tail pointer - * @len: length of FIFO to copy into message header - * - * This function will take a message and copy it into a section of the - * FIFO. In order to get something into a location other than just - * the tail you can use tail_offset to adjust the pointer. - **/ -STATIC void fm10k_fifo_write_copy(struct fm10k_mbx_fifo *fifo, - const u32 *msg, u16 tail_offset, u16 len) -{ - u16 end = fm10k_fifo_tail_offset(fifo, tail_offset); - u32 *tail = fifo->buffer + end; - - /* track when we should cross the end of the FIFO */ - end = fifo->size - end; - - /* copy end of message before start of message */ - if (end < len) - memcpy(fifo->buffer, msg + end, (len - end) << 2); - else - end = len; - - /* Copy remaining message into Tx FIFO */ - memcpy(tail, msg, end << 2); -} - -/** - * fm10k_fifo_enqueue - Enqueues the message to the tail of the FIFO - * @fifo: pointer to FIFO - * @msg: message array to read - * - * This function enqueues a message up to the size specified by the length - * contained in the first DWORD of the message and will place at the tail - * of the FIFO. It will return 0 on success, or a negative value on error. - **/ -STATIC s32 fm10k_fifo_enqueue(struct fm10k_mbx_fifo *fifo, const u32 *msg) -{ - u16 len = FM10K_TLV_DWORD_LEN(*msg); - - DEBUGFUNC("fm10k_fifo_enqueue"); - - /* verify parameters */ - if (len > fifo->size) - return FM10K_MBX_ERR_SIZE; - - /* verify there is room for the message */ - if (len > fm10k_fifo_unused(fifo)) - return FM10K_MBX_ERR_NO_SPACE; - - /* Copy message into FIFO */ - fm10k_fifo_write_copy(fifo, msg, 0, len); - - /* memory barrier to guarantee FIFO is written before tail update */ - FM10K_WMB(); - - /* Update Tx FIFO tail */ - fifo->tail += len; - - return FM10K_SUCCESS; -} - -/** - * fm10k_mbx_validate_msg_size - Validate incoming message based on size - * @mbx: pointer to mailbox - * @len: length of data pushed onto buffer - * - * This function analyzes the frame and will return a non-zero value when - * the start of a message larger than the mailbox is detected. - **/ -STATIC u16 fm10k_mbx_validate_msg_size(struct fm10k_mbx_info *mbx, u16 len) -{ - struct fm10k_mbx_fifo *fifo = &mbx->rx; - u16 total_len = 0, msg_len; - u32 *msg; - - DEBUGFUNC("fm10k_mbx_validate_msg"); - - /* length should include previous amounts pushed */ - len += mbx->pushed; - - /* offset in message is based off of current message size */ - do { - msg = fifo->buffer + fm10k_fifo_tail_offset(fifo, total_len); - msg_len = FM10K_TLV_DWORD_LEN(*msg); - total_len += msg_len; - } while (total_len < len); - - /* message extends out of pushed section, but fits in FIFO */ - if ((len < total_len) && (msg_len <= mbx->max_size)) - return 0; - - /* return length of invalid section */ - return (len < total_len) ? len : (len - total_len); -} - -/** - * fm10k_mbx_write_copy - pulls data off of Tx FIFO and places it in mbmem - * @mbx: pointer to mailbox - * - * This function will take a section of the Tx FIFO and copy it into the - * mailbox memory. The offset in mbmem is based on the lower bits of the - * tail and len determines the length to copy. - **/ -STATIC void fm10k_mbx_write_copy(struct fm10k_hw *hw, - struct fm10k_mbx_info *mbx) -{ - struct fm10k_mbx_fifo *fifo = &mbx->tx; - u32 mbmem = mbx->mbmem_reg; - u32 *head = fifo->buffer; - u16 end, len, tail, mask; - - DEBUGFUNC("fm10k_mbx_write_copy"); - - if (!mbx->tail_len) - return; - - /* determine data length and mbmem tail index */ - mask = mbx->mbmem_len - 1; - len = mbx->tail_len; - tail = fm10k_mbx_tail_sub(mbx, len); - if (tail > mask) - tail++; - - /* determine offset in the ring */ - end = fm10k_fifo_head_offset(fifo, mbx->pulled); - head += end; - - /* memory barrier to guarantee data is ready to be read */ - FM10K_RMB(); - - /* Copy message from Tx FIFO */ - for (end = fifo->size - end; len; head = fifo->buffer) { - do { - /* adjust tail to match offset for FIFO */ - tail &= mask; - if (!tail) - tail++; - - mbx->tx_mbmem_pulled++; - - /* write message to hardware FIFO */ - FM10K_WRITE_MBX(hw, mbmem + tail++, *(head++)); - } while (--len && --end); - } -} - -/** - * fm10k_mbx_pull_head - Pulls data off of head of Tx FIFO - * @hw: pointer to hardware structure - * @mbx: pointer to mailbox - * @head: acknowledgement number last received - * - * This function will push the tail index forward based on the remote - * head index. It will then pull up to mbmem_len DWORDs off of the - * head of the FIFO and will place it in the MBMEM registers - * associated with the mailbox. - **/ -STATIC void fm10k_mbx_pull_head(struct fm10k_hw *hw, - struct fm10k_mbx_info *mbx, u16 head) -{ - u16 mbmem_len, len, ack = fm10k_mbx_index_len(mbx, head, mbx->tail); - struct fm10k_mbx_fifo *fifo = &mbx->tx; - - /* update number of bytes pulled and update bytes in transit */ - mbx->pulled += mbx->tail_len - ack; - - /* determine length of data to pull, reserve space for mbmem header */ - mbmem_len = mbx->mbmem_len - 1; - len = fm10k_fifo_used(fifo) - mbx->pulled; - if (len > mbmem_len) - len = mbmem_len; - - /* update tail and record number of bytes in transit */ - mbx->tail = fm10k_mbx_tail_add(mbx, len - ack); - mbx->tail_len = len; - - /* drop pulled messages from the FIFO */ - for (len = fm10k_fifo_head_len(fifo); - len && (mbx->pulled >= len); - len = fm10k_fifo_head_len(fifo)) { - mbx->pulled -= fm10k_fifo_head_drop(fifo); - mbx->tx_messages++; - mbx->tx_dwords += len; - } - - /* Copy message out from the Tx FIFO */ - fm10k_mbx_write_copy(hw, mbx); -} - -/** - * fm10k_mbx_read_copy - pulls data off of mbmem and places it in Rx FIFO - * @hw: pointer to hardware structure - * @mbx: pointer to mailbox - * - * This function will take a section of the mailbox memory and copy it - * into the Rx FIFO. The offset is based on the lower bits of the - * head and len determines the length to copy. - **/ -STATIC void fm10k_mbx_read_copy(struct fm10k_hw *hw, - struct fm10k_mbx_info *mbx) -{ - struct fm10k_mbx_fifo *fifo = &mbx->rx; - u32 mbmem = mbx->mbmem_reg ^ mbx->mbmem_len; - u32 *tail = fifo->buffer; - u16 end, len, head; - - DEBUGFUNC("fm10k_mbx_read_copy"); - - /* determine data length and mbmem head index */ - len = mbx->head_len; - head = fm10k_mbx_head_sub(mbx, len); - if (head >= mbx->mbmem_len) - head++; - - /* determine offset in the ring */ - end = fm10k_fifo_tail_offset(fifo, mbx->pushed); - tail += end; - - /* Copy message into Rx FIFO */ - for (end = fifo->size - end; len; tail = fifo->buffer) { - do { - /* adjust head to match offset for FIFO */ - head &= mbx->mbmem_len - 1; - if (!head) - head++; - - mbx->rx_mbmem_pushed++; - - /* read message from hardware FIFO */ - *(tail++) = FM10K_READ_MBX(hw, mbmem + head++); - } while (--len && --end); - } - - /* memory barrier to guarantee FIFO is written before tail update */ - FM10K_WMB(); -} - -/** - * fm10k_mbx_push_tail - Pushes up to 15 DWORDs on to tail of FIFO - * @hw: pointer to hardware structure - * @mbx: pointer to mailbox - * @tail: tail index of message - * - * This function will first validate the tail index and size for the - * incoming message. It then updates the acknowledgment number and - * copies the data into the FIFO. It will return the number of messages - * dequeued on success and a negative value on error. - **/ -STATIC s32 fm10k_mbx_push_tail(struct fm10k_hw *hw, - struct fm10k_mbx_info *mbx, - u16 tail) -{ - struct fm10k_mbx_fifo *fifo = &mbx->rx; - u16 len, seq = fm10k_mbx_index_len(mbx, mbx->head, tail); - - DEBUGFUNC("fm10k_mbx_push_tail"); - - /* determine length of data to push */ - len = fm10k_fifo_unused(fifo) - mbx->pushed; - if (len > seq) - len = seq; - - /* update head and record bytes received */ - mbx->head = fm10k_mbx_head_add(mbx, len); - mbx->head_len = len; - - /* nothing to do if there is no data */ - if (!len) - return FM10K_SUCCESS; - - /* Copy msg into Rx FIFO */ - fm10k_mbx_read_copy(hw, mbx); - - /* determine if there are any invalid lengths in message */ - if (fm10k_mbx_validate_msg_size(mbx, len)) - return FM10K_MBX_ERR_SIZE; - - /* Update pushed */ - mbx->pushed += len; - - /* flush any completed messages */ - for (len = fm10k_mbx_pushed_tail_len(mbx); - len && (mbx->pushed >= len); - len = fm10k_mbx_pushed_tail_len(mbx)) { - fifo->tail += len; - mbx->pushed -= len; - mbx->rx_messages++; - mbx->rx_dwords += len; - } - - return FM10K_SUCCESS; -} - -/* pre-generated data for generating the CRC based on the poly 0xAC9A. */ -static const u16 fm10k_crc_16b_table[256] = { - 0x0000, 0x7956, 0xF2AC, 0x8BFA, 0xBC6D, 0xC53B, 0x4EC1, 0x3797, - 0x21EF, 0x58B9, 0xD343, 0xAA15, 0x9D82, 0xE4D4, 0x6F2E, 0x1678, - 0x43DE, 0x3A88, 0xB172, 0xC824, 0xFFB3, 0x86E5, 0x0D1F, 0x7449, - 0x6231, 0x1B67, 0x909D, 0xE9CB, 0xDE5C, 0xA70A, 0x2CF0, 0x55A6, - 0x87BC, 0xFEEA, 0x7510, 0x0C46, 0x3BD1, 0x4287, 0xC97D, 0xB02B, - 0xA653, 0xDF05, 0x54FF, 0x2DA9, 0x1A3E, 0x6368, 0xE892, 0x91C4, - 0xC462, 0xBD34, 0x36CE, 0x4F98, 0x780F, 0x0159, 0x8AA3, 0xF3F5, - 0xE58D, 0x9CDB, 0x1721, 0x6E77, 0x59E0, 0x20B6, 0xAB4C, 0xD21A, - 0x564D, 0x2F1B, 0xA4E1, 0xDDB7, 0xEA20, 0x9376, 0x188C, 0x61DA, - 0x77A2, 0x0EF4, 0x850E, 0xFC58, 0xCBCF, 0xB299, 0x3963, 0x4035, - 0x1593, 0x6CC5, 0xE73F, 0x9E69, 0xA9FE, 0xD0A8, 0x5B52, 0x2204, - 0x347C, 0x4D2A, 0xC6D0, 0xBF86, 0x8811, 0xF147, 0x7ABD, 0x03EB, - 0xD1F1, 0xA8A7, 0x235D, 0x5A0B, 0x6D9C, 0x14CA, 0x9F30, 0xE666, - 0xF01E, 0x8948, 0x02B2, 0x7BE4, 0x4C73, 0x3525, 0xBEDF, 0xC789, - 0x922F, 0xEB79, 0x6083, 0x19D5, 0x2E42, 0x5714, 0xDCEE, 0xA5B8, - 0xB3C0, 0xCA96, 0x416C, 0x383A, 0x0FAD, 0x76FB, 0xFD01, 0x8457, - 0xAC9A, 0xD5CC, 0x5E36, 0x2760, 0x10F7, 0x69A1, 0xE25B, 0x9B0D, - 0x8D75, 0xF423, 0x7FD9, 0x068F, 0x3118, 0x484E, 0xC3B4, 0xBAE2, - 0xEF44, 0x9612, 0x1DE8, 0x64BE, 0x5329, 0x2A7F, 0xA185, 0xD8D3, - 0xCEAB, 0xB7FD, 0x3C07, 0x4551, 0x72C6, 0x0B90, 0x806A, 0xF93C, - 0x2B26, 0x5270, 0xD98A, 0xA0DC, 0x974B, 0xEE1D, 0x65E7, 0x1CB1, - 0x0AC9, 0x739F, 0xF865, 0x8133, 0xB6A4, 0xCFF2, 0x4408, 0x3D5E, - 0x68F8, 0x11AE, 0x9A54, 0xE302, 0xD495, 0xADC3, 0x2639, 0x5F6F, - 0x4917, 0x3041, 0xBBBB, 0xC2ED, 0xF57A, 0x8C2C, 0x07D6, 0x7E80, - 0xFAD7, 0x8381, 0x087B, 0x712D, 0x46BA, 0x3FEC, 0xB416, 0xCD40, - 0xDB38, 0xA26E, 0x2994, 0x50C2, 0x6755, 0x1E03, 0x95F9, 0xECAF, - 0xB909, 0xC05F, 0x4BA5, 0x32F3, 0x0564, 0x7C32, 0xF7C8, 0x8E9E, - 0x98E6, 0xE1B0, 0x6A4A, 0x131C, 0x248B, 0x5DDD, 0xD627, 0xAF71, - 0x7D6B, 0x043D, 0x8FC7, 0xF691, 0xC106, 0xB850, 0x33AA, 0x4AFC, - 0x5C84, 0x25D2, 0xAE28, 0xD77E, 0xE0E9, 0x99BF, 0x1245, 0x6B13, - 0x3EB5, 0x47E3, 0xCC19, 0xB54F, 0x82D8, 0xFB8E, 0x7074, 0x0922, - 0x1F5A, 0x660C, 0xEDF6, 0x94A0, 0xA337, 0xDA61, 0x519B, 0x28CD }; - -/** - * fm10k_crc_16b - Generate a 16 bit CRC for a region of 16 bit data - * @data: pointer to data to process - * @seed: seed value for CRC - * @len: length measured in 16 bits words - * - * This function will generate a CRC based on the polynomial 0xAC9A and - * whatever value is stored in the seed variable. Note that this - * value inverts the local seed and the result in order to capture all - * leading and trailing zeros. - */ -STATIC u16 fm10k_crc_16b(const u32 *data, u16 seed, u16 len) -{ - u32 result = seed; - - while (len--) { - result ^= *(data++); - result = (result >> 8) ^ fm10k_crc_16b_table[result & 0xFF]; - result = (result >> 8) ^ fm10k_crc_16b_table[result & 0xFF]; - - if (!(len--)) - break; - - result = (result >> 8) ^ fm10k_crc_16b_table[result & 0xFF]; - result = (result >> 8) ^ fm10k_crc_16b_table[result & 0xFF]; - } - - return (u16)result; -} - -/** - * fm10k_fifo_crc - generate a CRC based off of FIFO data - * @fifo: pointer to FIFO - * @offset: offset point for start of FIFO - * @len: number of DWORDS words to process - * @seed: seed value for CRC - * - * This function generates a CRC for some region of the FIFO - **/ -STATIC u16 fm10k_fifo_crc(struct fm10k_mbx_fifo *fifo, u16 offset, - u16 len, u16 seed) -{ - u32 *data = fifo->buffer + offset; - - /* track when we should cross the end of the FIFO */ - offset = fifo->size - offset; - - /* if we are in 2 blocks process the end of the FIFO first */ - if (offset < len) { - seed = fm10k_crc_16b(data, seed, offset * 2); - data = fifo->buffer; - len -= offset; - } - - /* process any remaining bits */ - return fm10k_crc_16b(data, seed, len * 2); -} - -/** - * fm10k_mbx_update_local_crc - Update the local CRC for outgoing data - * @mbx: pointer to mailbox - * @head: head index provided by remote mailbox - * - * This function will generate the CRC for all data from the end of the - * last head update to the current one. It uses the result of the - * previous CRC as the seed for this update. The result is stored in - * mbx->local. - **/ -STATIC void fm10k_mbx_update_local_crc(struct fm10k_mbx_info *mbx, u16 head) -{ - u16 len = mbx->tail_len - fm10k_mbx_index_len(mbx, head, mbx->tail); - - /* determine the offset for the start of the region to be pulled */ - head = fm10k_fifo_head_offset(&mbx->tx, mbx->pulled); - - /* update local CRC to include all of the pulled data */ - mbx->local = fm10k_fifo_crc(&mbx->tx, head, len, mbx->local); -} - -/** - * fm10k_mbx_verify_remote_crc - Verify the CRC is correct for current data - * @mbx: pointer to mailbox - * - * This function will take all data that has been provided from the remote - * end and generate a CRC for it. This is stored in mbx->remote. The - * CRC for the header is then computed and if the result is non-zero this - * is an error and we signal an error dropping all data and resetting the - * connection. - */ -STATIC s32 fm10k_mbx_verify_remote_crc(struct fm10k_mbx_info *mbx) -{ - struct fm10k_mbx_fifo *fifo = &mbx->rx; - u16 len = mbx->head_len; - u16 offset = fm10k_fifo_tail_offset(fifo, mbx->pushed) - len; - u16 crc; - - /* update the remote CRC if new data has been received */ - if (len) - mbx->remote = fm10k_fifo_crc(fifo, offset, len, mbx->remote); - - /* process the full header as we have to validate the CRC */ - crc = fm10k_crc_16b(&mbx->mbx_hdr, mbx->remote, 1); - - /* notify other end if we have a problem */ - return crc ? FM10K_MBX_ERR_CRC : FM10K_SUCCESS; -} - -/** - * fm10k_mbx_rx_ready - Indicates that a message is ready in the Rx FIFO - * @mbx: pointer to mailbox - * - * This function returns true if there is a message in the Rx FIFO to dequeue. - **/ -STATIC bool fm10k_mbx_rx_ready(struct fm10k_mbx_info *mbx) -{ - u16 msg_size = fm10k_fifo_head_len(&mbx->rx); - - return msg_size && (fm10k_fifo_used(&mbx->rx) >= msg_size); -} - -/** - * fm10k_mbx_tx_ready - Indicates that the mailbox is in state ready for Tx - * @mbx: pointer to mailbox - * @len: verify free space is >= this value - * - * This function returns true if the mailbox is in a state ready to transmit. - **/ -STATIC bool fm10k_mbx_tx_ready(struct fm10k_mbx_info *mbx, u16 len) -{ - u16 fifo_unused = fm10k_fifo_unused(&mbx->tx); - - return (mbx->state == FM10K_STATE_OPEN) && (fifo_unused >= len); -} - -/** - * fm10k_mbx_tx_complete - Indicates that the Tx FIFO has been emptied - * @mbx: pointer to mailbox - * - * This function returns true if the Tx FIFO is empty. - **/ -STATIC bool fm10k_mbx_tx_complete(struct fm10k_mbx_info *mbx) -{ - return fm10k_fifo_empty(&mbx->tx); -} - -/** - * fm10k_mbx_deqeueue_rx - Dequeues the message from the head in the Rx FIFO - * @hw: pointer to hardware structure - * @mbx: pointer to mailbox - * - * This function dequeues messages and hands them off to the tlv parser. - * It will return the number of messages processed when called. - **/ -STATIC u16 fm10k_mbx_dequeue_rx(struct fm10k_hw *hw, - struct fm10k_mbx_info *mbx) -{ - struct fm10k_mbx_fifo *fifo = &mbx->rx; - s32 err; - u16 cnt; - - /* parse Rx messages out of the Rx FIFO to empty it */ - for (cnt = 0; !fm10k_fifo_empty(fifo); cnt++) { - err = fm10k_tlv_msg_parse(hw, fifo->buffer + fifo->head, - mbx, mbx->msg_data); - if (err < 0) - mbx->rx_parse_err++; - - fm10k_fifo_head_drop(fifo); - } - - /* shift remaining bytes back to start of FIFO */ - memmove(fifo->buffer, fifo->buffer + fifo->tail, mbx->pushed << 2); - - /* shift head and tail based on the memory we moved */ - fifo->tail -= fifo->head; - fifo->head = 0; - - return cnt; -} - -/** - * fm10k_mbx_enqueue_tx - Enqueues the message to the tail of the Tx FIFO - * @hw: pointer to hardware structure - * @mbx: pointer to mailbox - * @msg: message array to read - * - * This function enqueues a message up to the size specified by the length - * contained in the first DWORD of the message and will place at the tail - * of the FIFO. It will return 0 on success, or a negative value on error. - **/ -STATIC s32 fm10k_mbx_enqueue_tx(struct fm10k_hw *hw, - struct fm10k_mbx_info *mbx, const u32 *msg) -{ - u32 countdown = mbx->timeout; - s32 err; - - switch (mbx->state) { - case FM10K_STATE_CLOSED: - case FM10K_STATE_DISCONNECT: - return FM10K_MBX_ERR_NO_MBX; - default: - break; - } - - /* enqueue the message on the Tx FIFO */ - err = fm10k_fifo_enqueue(&mbx->tx, msg); - - /* if it failed give the FIFO a chance to drain */ - while (err && countdown) { - countdown--; - usec_delay(mbx->usec_delay); - mbx->ops.process(hw, mbx); - err = fm10k_fifo_enqueue(&mbx->tx, msg); - } - - /* if we failed treat the error */ - if (err) { - mbx->timeout = 0; - mbx->tx_busy++; - } - - /* begin processing message, ignore errors as this is just meant - * to start the mailbox flow so we are not concerned if there - * is a bad error, or the mailbox is already busy with a request - */ - if (!mbx->tail_len) - mbx->ops.process(hw, mbx); - - return FM10K_SUCCESS; -} - -/** - * fm10k_mbx_read - Copies the mbmem to local message buffer - * @hw: pointer to hardware structure - * @mbx: pointer to mailbox - * - * This function copies the message from the mbmem to the message array - **/ -STATIC s32 fm10k_mbx_read(struct fm10k_hw *hw, struct fm10k_mbx_info *mbx) -{ - DEBUGFUNC("fm10k_mbx_read"); - - /* only allow one reader in here at a time */ - if (mbx->mbx_hdr) - return FM10K_MBX_ERR_BUSY; - - /* read to capture initial interrupt bits */ - if (FM10K_READ_MBX(hw, mbx->mbx_reg) & FM10K_MBX_REQ_INTERRUPT) - mbx->mbx_lock = FM10K_MBX_ACK; - - /* write back interrupt bits to clear */ - FM10K_WRITE_MBX(hw, mbx->mbx_reg, - FM10K_MBX_REQ_INTERRUPT | FM10K_MBX_ACK_INTERRUPT); - - /* read remote header */ - mbx->mbx_hdr = FM10K_READ_MBX(hw, mbx->mbmem_reg ^ mbx->mbmem_len); - - return FM10K_SUCCESS; -} - -/** - * fm10k_mbx_write - Copies the local message buffer to mbmem - * @hw: pointer to hardware structure - * @mbx: pointer to mailbox - * - * This function copies the message from the the message array to mbmem - **/ -STATIC void fm10k_mbx_write(struct fm10k_hw *hw, struct fm10k_mbx_info *mbx) -{ - u32 mbmem = mbx->mbmem_reg; - - DEBUGFUNC("fm10k_mbx_write"); - - /* write new msg header to notify recipient of change */ - FM10K_WRITE_MBX(hw, mbmem, mbx->mbx_hdr); - - /* write mailbox to send interrupt */ - if (mbx->mbx_lock) - FM10K_WRITE_MBX(hw, mbx->mbx_reg, mbx->mbx_lock); - - /* we no longer are using the header so free it */ - mbx->mbx_hdr = 0; - mbx->mbx_lock = 0; -} - -/** - * fm10k_mbx_create_connect_hdr - Generate a connect mailbox header - * @mbx: pointer to mailbox - * - * This function returns a connection mailbox header - **/ -STATIC void fm10k_mbx_create_connect_hdr(struct fm10k_mbx_info *mbx) -{ - mbx->mbx_lock |= FM10K_MBX_REQ; - - mbx->mbx_hdr = FM10K_MSG_HDR_FIELD_SET(FM10K_MSG_CONNECT, TYPE) | - FM10K_MSG_HDR_FIELD_SET(mbx->head, HEAD) | - FM10K_MSG_HDR_FIELD_SET(mbx->rx.size - 1, CONNECT_SIZE); -} - -/** - * fm10k_mbx_create_data_hdr - Generate a data mailbox header - * @mbx: pointer to mailbox - * - * This function returns a data mailbox header - **/ -STATIC void fm10k_mbx_create_data_hdr(struct fm10k_mbx_info *mbx) -{ - u32 hdr = FM10K_MSG_HDR_FIELD_SET(FM10K_MSG_DATA, TYPE) | - FM10K_MSG_HDR_FIELD_SET(mbx->tail, TAIL) | - FM10K_MSG_HDR_FIELD_SET(mbx->head, HEAD); - struct fm10k_mbx_fifo *fifo = &mbx->tx; - u16 crc; - - if (mbx->tail_len) - mbx->mbx_lock |= FM10K_MBX_REQ; - - /* generate CRC for data in flight and header */ - crc = fm10k_fifo_crc(fifo, fm10k_fifo_head_offset(fifo, mbx->pulled), - mbx->tail_len, mbx->local); - crc = fm10k_crc_16b(&hdr, crc, 1); - - /* load header to memory to be written */ - mbx->mbx_hdr = hdr | FM10K_MSG_HDR_FIELD_SET(crc, CRC); -} - -/** - * fm10k_mbx_create_disconnect_hdr - Generate a disconnect mailbox header - * @mbx: pointer to mailbox - * - * This function returns a disconnect mailbox header - **/ -STATIC void fm10k_mbx_create_disconnect_hdr(struct fm10k_mbx_info *mbx) -{ - u32 hdr = FM10K_MSG_HDR_FIELD_SET(FM10K_MSG_DISCONNECT, TYPE) | - FM10K_MSG_HDR_FIELD_SET(mbx->tail, TAIL) | - FM10K_MSG_HDR_FIELD_SET(mbx->head, HEAD); - u16 crc = fm10k_crc_16b(&hdr, mbx->local, 1); - - mbx->mbx_lock |= FM10K_MBX_ACK; - - /* load header to memory to be written */ - mbx->mbx_hdr = hdr | FM10K_MSG_HDR_FIELD_SET(crc, CRC); -} - -/** - * fm10k_mbx_create_fake_disconnect_hdr - Generate a false disconnect mailbox header - * @mbx: pointer to mailbox - * - * This function creates a fake disconnect header for loading into remote - * mailbox header. The primary purpose is to prevent errors on immediate - * start up after mbx->connect. - **/ -STATIC void fm10k_mbx_create_fake_disconnect_hdr(struct fm10k_mbx_info *mbx) -{ - u32 hdr = FM10K_MSG_HDR_FIELD_SET(FM10K_MSG_DISCONNECT, TYPE) | - FM10K_MSG_HDR_FIELD_SET(mbx->head, TAIL) | - FM10K_MSG_HDR_FIELD_SET(mbx->tail, HEAD); - u16 crc = fm10k_crc_16b(&hdr, mbx->local, 1); - - mbx->mbx_lock |= FM10K_MBX_ACK; - - /* load header to memory to be written */ - mbx->mbx_hdr = hdr | FM10K_MSG_HDR_FIELD_SET(crc, CRC); -} - -/** - * fm10k_mbx_create_error_msg - Generate a error message - * @mbx: pointer to mailbox - * @err: local error encountered - * - * This function will interpret the error provided by err, and based on - * that it may shift the message by 1 DWORD and then place an error header - * at the start of the message. - **/ -STATIC void fm10k_mbx_create_error_msg(struct fm10k_mbx_info *mbx, s32 err) -{ - /* only generate an error message for these types */ - switch (err) { - case FM10K_MBX_ERR_TAIL: - case FM10K_MBX_ERR_HEAD: - case FM10K_MBX_ERR_TYPE: - case FM10K_MBX_ERR_SIZE: - case FM10K_MBX_ERR_RSVD0: - case FM10K_MBX_ERR_CRC: - break; - default: - return; - } - - mbx->mbx_lock |= FM10K_MBX_REQ; - - mbx->mbx_hdr = FM10K_MSG_HDR_FIELD_SET(FM10K_MSG_ERROR, TYPE) | - FM10K_MSG_HDR_FIELD_SET(err, ERR_NO) | - FM10K_MSG_HDR_FIELD_SET(mbx->head, HEAD); -} - -/** - * fm10k_mbx_validate_msg_hdr - Validate common fields in the message header - * @mbx: pointer to mailbox - * @msg: message array to read - * - * This function will parse up the fields in the mailbox header and return - * an error if the header contains any of a number of invalid configurations - * including unrecognized type, invalid route, or a malformed message. - **/ -STATIC s32 fm10k_mbx_validate_msg_hdr(struct fm10k_mbx_info *mbx) -{ - u16 type, rsvd0, head, tail, size; - const u32 *hdr = &mbx->mbx_hdr; - - DEBUGFUNC("fm10k_mbx_validate_msg_hdr"); - - type = FM10K_MSG_HDR_FIELD_GET(*hdr, TYPE); - rsvd0 = FM10K_MSG_HDR_FIELD_GET(*hdr, RSVD0); - tail = FM10K_MSG_HDR_FIELD_GET(*hdr, TAIL); - head = FM10K_MSG_HDR_FIELD_GET(*hdr, HEAD); - size = FM10K_MSG_HDR_FIELD_GET(*hdr, CONNECT_SIZE); - - if (rsvd0) - return FM10K_MBX_ERR_RSVD0; - - switch (type) { - case FM10K_MSG_DISCONNECT: - /* validate that all data has been received */ - if (tail != mbx->head) - return FM10K_MBX_ERR_TAIL; - - /* fall through */ - case FM10K_MSG_DATA: - /* validate that head is moving correctly */ - if (!head || (head == FM10K_MSG_HDR_MASK(HEAD))) - return FM10K_MBX_ERR_HEAD; - if (fm10k_mbx_index_len(mbx, head, mbx->tail) > mbx->tail_len) - return FM10K_MBX_ERR_HEAD; - - /* validate that tail is moving correctly */ - if (!tail || (tail == FM10K_MSG_HDR_MASK(TAIL))) - return FM10K_MBX_ERR_TAIL; - if (fm10k_mbx_index_len(mbx, mbx->head, tail) < mbx->mbmem_len) - break; - - return FM10K_MBX_ERR_TAIL; - case FM10K_MSG_CONNECT: - /* validate size is in range and is power of 2 mask */ - if ((size < FM10K_VFMBX_MSG_MTU) || (size & (size + 1))) - return FM10K_MBX_ERR_SIZE; - - /* fall through */ - case FM10K_MSG_ERROR: - if (!head || (head == FM10K_MSG_HDR_MASK(HEAD))) - return FM10K_MBX_ERR_HEAD; - /* neither create nor error include a tail offset */ - if (tail) - return FM10K_MBX_ERR_TAIL; - - break; - default: - return FM10K_MBX_ERR_TYPE; - } - - return FM10K_SUCCESS; -} - -/** - * fm10k_mbx_create_reply - Generate reply based on state and remote head - * @mbx: pointer to mailbox - * @head: acknowledgement number - * - * This function will generate an outgoing message based on the current - * mailbox state and the remote fifo head. It will return the length - * of the outgoing message excluding header on success, and a negative value - * on error. - **/ -STATIC s32 fm10k_mbx_create_reply(struct fm10k_hw *hw, - struct fm10k_mbx_info *mbx, u16 head) -{ - switch (mbx->state) { - case FM10K_STATE_OPEN: - case FM10K_STATE_DISCONNECT: - /* update our checksum for the outgoing data */ - fm10k_mbx_update_local_crc(mbx, head); - - /* as long as other end recognizes us keep sending data */ - fm10k_mbx_pull_head(hw, mbx, head); - - /* generate new header based on data */ - if (mbx->tail_len || (mbx->state == FM10K_STATE_OPEN)) - fm10k_mbx_create_data_hdr(mbx); - else - fm10k_mbx_create_disconnect_hdr(mbx); - break; - case FM10K_STATE_CONNECT: - /* send disconnect even if we aren't connected */ - fm10k_mbx_create_connect_hdr(mbx); - break; - case FM10K_STATE_CLOSED: - /* generate new header based on data */ - fm10k_mbx_create_disconnect_hdr(mbx); - default: - break; - } - - return FM10K_SUCCESS; -} - -/** - * fm10k_mbx_reset_work- Reset internal pointers for any pending work - * @mbx: pointer to mailbox - * - * This function will reset all internal pointers so any work in progress - * is dropped. This call should occur every time we transition from the - * open state to the connect state. - **/ -STATIC void fm10k_mbx_reset_work(struct fm10k_mbx_info *mbx) -{ - u16 len, head, ack; - - /* reset our outgoing max size back to Rx limits */ - mbx->max_size = mbx->rx.size - 1; - - /* update mbx->pulled to account for tail_len and ack */ - head = FM10K_MSG_HDR_FIELD_GET(mbx->mbx_hdr, HEAD); - ack = fm10k_mbx_index_len(mbx, head, mbx->tail); - mbx->pulled += mbx->tail_len - ack; - - /* now drop any messages which have started or finished transmitting */ - while (fm10k_fifo_head_len(&mbx->tx) && mbx->pulled) { - len = fm10k_fifo_head_drop(&mbx->tx); - mbx->tx_dropped++; - if (mbx->pulled >= len) - mbx->pulled -= len; - else - mbx->pulled = 0; - } - - /* just do a quick resysnc to start of message */ - mbx->pushed = 0; - mbx->pulled = 0; - mbx->tail_len = 0; - mbx->head_len = 0; - mbx->rx.tail = 0; - mbx->rx.head = 0; -} - -/** - * fm10k_mbx_update_max_size - Update the max_size and drop large messages - * @mbx: pointer to mailbox - * @size: new value for max_size - * - * This function updates the max_size value and drops any outgoing messages - * at the head of the Tx FIFO if they are larger than max_size. It does not - * drop all messages, as this is too difficult to parse and remove them from - * the FIFO. Instead, rely on the checking to ensure that messages larger - * than max_size aren't pushed into the memory buffer. - **/ -STATIC void fm10k_mbx_update_max_size(struct fm10k_mbx_info *mbx, u16 size) -{ - u16 len; - - DEBUGFUNC("fm10k_mbx_update_max_size_hdr"); - - mbx->max_size = size; - - /* flush any oversized messages from the queue */ - for (len = fm10k_fifo_head_len(&mbx->tx); - len > size; - len = fm10k_fifo_head_len(&mbx->tx)) { - fm10k_fifo_head_drop(&mbx->tx); - mbx->tx_dropped++; - } -} - -/** - * fm10k_mbx_connect_reset - Reset following request for reset - * @mbx: pointer to mailbox - * - * This function resets the mailbox to either a disconnected state - * or a connect state depending on the current mailbox state - **/ -STATIC void fm10k_mbx_connect_reset(struct fm10k_mbx_info *mbx) -{ - /* just do a quick resysnc to start of frame */ - fm10k_mbx_reset_work(mbx); - - /* reset CRC seeds */ - mbx->local = FM10K_MBX_CRC_SEED; - mbx->remote = FM10K_MBX_CRC_SEED; - - /* we cannot exit connect until the size is good */ - if (mbx->state == FM10K_STATE_OPEN) - mbx->state = FM10K_STATE_CONNECT; - else - mbx->state = FM10K_STATE_CLOSED; -} - -/** - * fm10k_mbx_process_connect - Process connect header - * @mbx: pointer to mailbox - * @msg: message array to process - * - * This function will read an incoming connect header and reply with the - * appropriate message. It will return a value indicating the number of - * data DWORDs on success, or will return a negative value on failure. - **/ -STATIC s32 fm10k_mbx_process_connect(struct fm10k_hw *hw, - struct fm10k_mbx_info *mbx) -{ - const enum fm10k_mbx_state state = mbx->state; - const u32 *hdr = &mbx->mbx_hdr; - u16 size, head; - - /* we will need to pull all of the fields for verification */ - size = FM10K_MSG_HDR_FIELD_GET(*hdr, CONNECT_SIZE); - head = FM10K_MSG_HDR_FIELD_GET(*hdr, HEAD); - - switch (state) { - case FM10K_STATE_DISCONNECT: - case FM10K_STATE_OPEN: - /* reset any in-progress work */ - fm10k_mbx_connect_reset(mbx); - break; - case FM10K_STATE_CONNECT: - /* we cannot exit connect until the size is good */ - if (size > mbx->rx.size) { - mbx->max_size = mbx->rx.size - 1; - } else { - /* record the remote system requesting connection */ - mbx->state = FM10K_STATE_OPEN; - - fm10k_mbx_update_max_size(mbx, size); - } - break; - default: - break; - } - - /* align our tail index to remote head index */ - mbx->tail = head; - - return fm10k_mbx_create_reply(hw, mbx, head); -} - -/** - * fm10k_mbx_process_data - Process data header - * @mbx: pointer to mailbox - * - * This function will read an incoming data header and reply with the - * appropriate message. It will return a value indicating the number of - * data DWORDs on success, or will return a negative value on failure. - **/ -STATIC s32 fm10k_mbx_process_data(struct fm10k_hw *hw, - struct fm10k_mbx_info *mbx) -{ - const u32 *hdr = &mbx->mbx_hdr; - u16 head, tail; - s32 err; - - DEBUGFUNC("fm10k_mbx_process_data"); - - /* we will need to pull all of the fields for verification */ - head = FM10K_MSG_HDR_FIELD_GET(*hdr, HEAD); - tail = FM10K_MSG_HDR_FIELD_GET(*hdr, TAIL); - - /* if we are in connect just update our data and go */ - if (mbx->state == FM10K_STATE_CONNECT) { - mbx->tail = head; - mbx->state = FM10K_STATE_OPEN; - } - - /* abort on message size errors */ - err = fm10k_mbx_push_tail(hw, mbx, tail); - if (err < 0) - return err; - - /* verify the checksum on the incoming data */ - err = fm10k_mbx_verify_remote_crc(mbx); - if (err) - return err; - - /* process messages if we have received any */ - fm10k_mbx_dequeue_rx(hw, mbx); - - return fm10k_mbx_create_reply(hw, mbx, head); -} - -/** - * fm10k_mbx_process_disconnect - Process disconnect header - * @mbx: pointer to mailbox - * - * This function will read an incoming disconnect header and reply with the - * appropriate message. It will return a value indicating the number of - * data DWORDs on success, or will return a negative value on failure. - **/ -STATIC s32 fm10k_mbx_process_disconnect(struct fm10k_hw *hw, - struct fm10k_mbx_info *mbx) -{ - const enum fm10k_mbx_state state = mbx->state; - const u32 *hdr = &mbx->mbx_hdr; - u16 head; - s32 err; - - /* we will need to pull the header field for verification */ - head = FM10K_MSG_HDR_FIELD_GET(*hdr, HEAD); - - /* We should not be receiving disconnect if Rx is incomplete */ - if (mbx->pushed) - return FM10K_MBX_ERR_TAIL; - - /* we have already verified mbx->head == tail so we know this is 0 */ - mbx->head_len = 0; - - /* verify the checksum on the incoming header is correct */ - err = fm10k_mbx_verify_remote_crc(mbx); - if (err) - return err; - - switch (state) { - case FM10K_STATE_DISCONNECT: - case FM10K_STATE_OPEN: - /* state doesn't change if we still have work to do */ - if (!fm10k_mbx_tx_complete(mbx)) - break; - - /* verify the head indicates we completed all transmits */ - if (head != mbx->tail) - return FM10K_MBX_ERR_HEAD; - - /* reset any in-progress work */ - fm10k_mbx_connect_reset(mbx); - break; - default: - break; - } - - return fm10k_mbx_create_reply(hw, mbx, head); -} - -/** - * fm10k_mbx_process_error - Process error header - * @mbx: pointer to mailbox - * - * This function will read an incoming error header and reply with the - * appropriate message. It will return a value indicating the number of - * data DWORDs on success, or will return a negative value on failure. - **/ -STATIC s32 fm10k_mbx_process_error(struct fm10k_hw *hw, - struct fm10k_mbx_info *mbx) -{ - const u32 *hdr = &mbx->mbx_hdr; - u16 head; - - /* we will need to pull all of the fields for verification */ - head = FM10K_MSG_HDR_FIELD_GET(*hdr, HEAD); - - switch (mbx->state) { - case FM10K_STATE_OPEN: - case FM10K_STATE_DISCONNECT: - /* flush any uncompleted work */ - fm10k_mbx_reset_work(mbx); - - /* reset CRC seeds */ - mbx->local = FM10K_MBX_CRC_SEED; - mbx->remote = FM10K_MBX_CRC_SEED; - - /* reset tail index and size to prepare for reconnect */ - mbx->tail = head; - - /* if open then reset max_size and go back to connect */ - if (mbx->state == FM10K_STATE_OPEN) { - mbx->state = FM10K_STATE_CONNECT; - break; - } - - /* send a connect message to get data flowing again */ - fm10k_mbx_create_connect_hdr(mbx); - return FM10K_SUCCESS; - default: - break; - } - - return fm10k_mbx_create_reply(hw, mbx, mbx->tail); -} - -/** - * fm10k_mbx_process - Process mailbox interrupt - * @hw: pointer to hardware structure - * @mbx: pointer to mailbox - * - * This function will process incoming mailbox events and generate mailbox - * replies. It will return a value indicating the number of DWORDs - * transmitted excluding header on success or a negative value on error. - **/ -STATIC s32 fm10k_mbx_process(struct fm10k_hw *hw, - struct fm10k_mbx_info *mbx) -{ - s32 err; - - DEBUGFUNC("fm10k_mbx_process"); - - /* we do not read mailbox if closed */ - if (mbx->state == FM10K_STATE_CLOSED) - return FM10K_SUCCESS; - - /* copy data from mailbox */ - err = fm10k_mbx_read(hw, mbx); - if (err) - return err; - - /* validate type, source, and destination */ - err = fm10k_mbx_validate_msg_hdr(mbx); - if (err < 0) - goto msg_err; - - switch (FM10K_MSG_HDR_FIELD_GET(mbx->mbx_hdr, TYPE)) { - case FM10K_MSG_CONNECT: - err = fm10k_mbx_process_connect(hw, mbx); - break; - case FM10K_MSG_DATA: - err = fm10k_mbx_process_data(hw, mbx); - break; - case FM10K_MSG_DISCONNECT: - err = fm10k_mbx_process_disconnect(hw, mbx); - break; - case FM10K_MSG_ERROR: - err = fm10k_mbx_process_error(hw, mbx); - break; - default: - err = FM10K_MBX_ERR_TYPE; - break; - } - -msg_err: - /* notify partner of errors on our end */ - if (err < 0) - fm10k_mbx_create_error_msg(mbx, err); - - /* copy data from mailbox */ - fm10k_mbx_write(hw, mbx); - - return err; -} - -/** - * fm10k_mbx_disconnect - Shutdown mailbox connection - * @hw: pointer to hardware structure - * @mbx: pointer to mailbox - * - * This function will shut down the mailbox. It places the mailbox first - * in the disconnect state, it then allows up to a predefined timeout for - * the mailbox to transition to close on its own. If this does not occur - * then the mailbox will be forced into the closed state. - * - * Any mailbox transactions not completed before calling this function - * are not guaranteed to complete and may be dropped. - **/ -STATIC void fm10k_mbx_disconnect(struct fm10k_hw *hw, - struct fm10k_mbx_info *mbx) -{ - int timeout = mbx->timeout ? FM10K_MBX_DISCONNECT_TIMEOUT : 0; - - DEBUGFUNC("fm10k_mbx_disconnect"); - - /* Place mbx in ready to disconnect state */ - mbx->state = FM10K_STATE_DISCONNECT; - - /* trigger interrupt to start shutdown process */ - FM10K_WRITE_MBX(hw, mbx->mbx_reg, FM10K_MBX_REQ | - FM10K_MBX_INTERRUPT_DISABLE); - do { - usec_delay(FM10K_MBX_POLL_DELAY); - mbx->ops.process(hw, mbx); - timeout -= FM10K_MBX_POLL_DELAY; - } while ((timeout > 0) && (mbx->state != FM10K_STATE_CLOSED)); - - /* in case we didn't close, just force the mailbox into shutdown and - * drop all left over messages in the FIFO. - */ - fm10k_mbx_connect_reset(mbx); - fm10k_fifo_drop_all(&mbx->tx); - - FM10K_WRITE_MBX(hw, mbx->mbmem_reg, 0); -} - -/** - * fm10k_mbx_connect - Start mailbox connection - * @hw: pointer to hardware structure - * @mbx: pointer to mailbox - * - * This function will initiate a mailbox connection. It will populate the - * mailbox with a broadcast connect message and then initialize the lock. - * This is safe since the connect message is a single DWORD so the mailbox - * transaction is guaranteed to be atomic. - * - * This function will return an error if the mailbox has not been initiated - * or is currently in use. - **/ -STATIC s32 fm10k_mbx_connect(struct fm10k_hw *hw, struct fm10k_mbx_info *mbx) -{ - DEBUGFUNC("fm10k_mbx_connect"); - - /* we cannot connect an uninitialized mailbox */ - if (!mbx->rx.buffer) - return FM10K_MBX_ERR_NO_SPACE; - - /* we cannot connect an already connected mailbox */ - if (mbx->state != FM10K_STATE_CLOSED) - return FM10K_MBX_ERR_BUSY; - - /* mailbox timeout can now become active */ - mbx->timeout = FM10K_MBX_INIT_TIMEOUT; - - /* Place mbx in ready to connect state */ - mbx->state = FM10K_STATE_CONNECT; - - fm10k_mbx_reset_work(mbx); - - fm10k_mbx_create_fake_disconnect_hdr(mbx); - FM10K_WRITE_MBX(hw, mbx->mbmem_reg ^ mbx->mbmem_len, mbx->mbx_hdr); - - /* enable interrupt and notify other party of new message */ - mbx->mbx_lock = FM10K_MBX_REQ_INTERRUPT | FM10K_MBX_ACK_INTERRUPT | - FM10K_MBX_INTERRUPT_ENABLE; - - /* generate and load connect header into mailbox */ - fm10k_mbx_create_connect_hdr(mbx); - fm10k_mbx_write(hw, mbx); - - return FM10K_SUCCESS; -} - -/** - * fm10k_mbx_validate_handlers - Validate layout of message parsing data - * @msg_data: handlers for mailbox events - * - * This function validates the layout of the message parsing data. This - * should be mostly static, but it is important to catch any errors that - * are made when constructing the parsers. - **/ -STATIC s32 fm10k_mbx_validate_handlers(const struct fm10k_msg_data *msg_data) -{ - const struct fm10k_tlv_attr *attr; - unsigned int id; - - DEBUGFUNC("fm10k_mbx_validate_handlers"); - - /* Allow NULL mailboxes that transmit but don't receive */ - if (!msg_data) - return FM10K_SUCCESS; - - while (msg_data->id != FM10K_TLV_ERROR) { - /* all messages should have a function handler */ - if (!msg_data->func) - return FM10K_ERR_PARAM; - - /* parser is optional */ - attr = msg_data->attr; - if (attr) { - while (attr->id != FM10K_TLV_ERROR) { - id = attr->id; - attr++; - /* ID should always be increasing */ - if (id >= attr->id) - return FM10K_ERR_PARAM; - /* ID should fit in results array */ - if (id >= FM10K_TLV_RESULTS_MAX) - return FM10K_ERR_PARAM; - } - - /* verify terminator is in the list */ - if (attr->id != FM10K_TLV_ERROR) - return FM10K_ERR_PARAM; - } - - id = msg_data->id; - msg_data++; - /* ID should always be increasing */ - if (id >= msg_data->id) - return FM10K_ERR_PARAM; - } - - /* verify terminator is in the list */ - if ((msg_data->id != FM10K_TLV_ERROR) || !msg_data->func) - return FM10K_ERR_PARAM; - - return FM10K_SUCCESS; -} - -/** - * fm10k_mbx_register_handlers - Register a set of handler ops for mailbox - * @mbx: pointer to mailbox - * @msg_data: handlers for mailbox events - * - * This function associates a set of message handling ops with a mailbox. - **/ -STATIC s32 fm10k_mbx_register_handlers(struct fm10k_mbx_info *mbx, - const struct fm10k_msg_data *msg_data) -{ - DEBUGFUNC("fm10k_mbx_register_handlers"); - - /* validate layout of handlers before assigning them */ - if (fm10k_mbx_validate_handlers(msg_data)) - return FM10K_ERR_PARAM; - - /* initialize the message handlers */ - mbx->msg_data = msg_data; - - return FM10K_SUCCESS; -} - -/** - * fm10k_pfvf_mbx_init - Initialize mailbox memory for PF/VF mailbox - * @hw: pointer to hardware structure - * @mbx: pointer to mailbox - * @msg_data: handlers for mailbox events - * @id: ID reference for PF as it supports up to 64 PF/VF mailboxes - * - * This function initializes the mailbox for use. It will split the - * buffer provided an use that th populate both the Tx and Rx FIFO by - * evenly splitting it. In order to allow for easy masking of head/tail - * the value reported in size must be a power of 2 and is reported in - * DWORDs, not bytes. Any invalid values will cause the mailbox to return - * error. - **/ -s32 fm10k_pfvf_mbx_init(struct fm10k_hw *hw, struct fm10k_mbx_info *mbx, - const struct fm10k_msg_data *msg_data, u8 id) -{ - DEBUGFUNC("fm10k_pfvf_mbx_init"); - - /* initialize registers */ - switch (hw->mac.type) { - case fm10k_mac_vf: - mbx->mbx_reg = FM10K_VFMBX; - mbx->mbmem_reg = FM10K_VFMBMEM(FM10K_VFMBMEM_VF_XOR); - break; - case fm10k_mac_pf: - /* there are only 64 VF <-> PF mailboxes */ - if (id < 64) { - mbx->mbx_reg = FM10K_MBX(id); - mbx->mbmem_reg = FM10K_MBMEM_VF(id, 0); - break; - } - /* fallthough */ - default: - return FM10K_MBX_ERR_NO_MBX; - } - - /* start out in closed state */ - mbx->state = FM10K_STATE_CLOSED; - - /* validate layout of handlers before assigning them */ - if (fm10k_mbx_validate_handlers(msg_data)) - return FM10K_ERR_PARAM; - - /* initialize the message handlers */ - mbx->msg_data = msg_data; - - /* start mailbox as timed out and let the reset_hw call - * set the timeout value to begin communications - */ - mbx->timeout = 0; - mbx->usec_delay = FM10K_MBX_INIT_DELAY; - - /* initialize tail and head */ - mbx->tail = 1; - mbx->head = 1; - - /* initialize CRC seeds */ - mbx->local = FM10K_MBX_CRC_SEED; - mbx->remote = FM10K_MBX_CRC_SEED; - - /* Split buffer for use by Tx/Rx FIFOs */ - mbx->max_size = FM10K_MBX_MSG_MAX_SIZE; - mbx->mbmem_len = FM10K_VFMBMEM_VF_XOR; - - /* initialize the FIFOs, sizes are in 4 byte increments */ - fm10k_fifo_init(&mbx->tx, mbx->buffer, FM10K_MBX_TX_BUFFER_SIZE); - fm10k_fifo_init(&mbx->rx, &mbx->buffer[FM10K_MBX_TX_BUFFER_SIZE], - FM10K_MBX_RX_BUFFER_SIZE); - - /* initialize function pointers */ - mbx->ops.connect = fm10k_mbx_connect; - mbx->ops.disconnect = fm10k_mbx_disconnect; - mbx->ops.rx_ready = fm10k_mbx_rx_ready; - mbx->ops.tx_ready = fm10k_mbx_tx_ready; - mbx->ops.tx_complete = fm10k_mbx_tx_complete; - mbx->ops.enqueue_tx = fm10k_mbx_enqueue_tx; - mbx->ops.process = fm10k_mbx_process; - mbx->ops.register_handlers = fm10k_mbx_register_handlers; - - return FM10K_SUCCESS; -} - -/** - * fm10k_sm_mbx_create_data_hdr - Generate a mailbox header for local FIFO - * @mbx: pointer to mailbox - * - * This function returns a connection mailbox header - **/ -STATIC void fm10k_sm_mbx_create_data_hdr(struct fm10k_mbx_info *mbx) -{ - if (mbx->tail_len) - mbx->mbx_lock |= FM10K_MBX_REQ; - - mbx->mbx_hdr = FM10K_MSG_HDR_FIELD_SET(mbx->tail, SM_TAIL) | - FM10K_MSG_HDR_FIELD_SET(mbx->remote, SM_VER) | - FM10K_MSG_HDR_FIELD_SET(mbx->head, SM_HEAD); -} - -/** - * fm10k_sm_mbx_create_connect_hdr - Generate a mailbox header for local FIFO - * @mbx: pointer to mailbox - * @err: error flags to report if any - * - * This function returns a connection mailbox header - **/ -STATIC void fm10k_sm_mbx_create_connect_hdr(struct fm10k_mbx_info *mbx, u8 err) -{ - if (mbx->local) - mbx->mbx_lock |= FM10K_MBX_REQ; - - mbx->mbx_hdr = FM10K_MSG_HDR_FIELD_SET(mbx->tail, SM_TAIL) | - FM10K_MSG_HDR_FIELD_SET(mbx->remote, SM_VER) | - FM10K_MSG_HDR_FIELD_SET(mbx->head, SM_HEAD) | - FM10K_MSG_HDR_FIELD_SET(err, SM_ERR); -} - -/** - * fm10k_sm_mbx_connect_reset - Reset following request for reset - * @mbx: pointer to mailbox - * - * This function resets the mailbox to a just connected state - **/ -STATIC void fm10k_sm_mbx_connect_reset(struct fm10k_mbx_info *mbx) -{ - /* flush any uncompleted work */ - fm10k_mbx_reset_work(mbx); - - /* set local version to max and remote version to 0 */ - mbx->local = FM10K_SM_MBX_VERSION; - mbx->remote = 0; - - /* initialize tail and head */ - mbx->tail = 1; - mbx->head = 1; - - /* reset state back to connect */ - mbx->state = FM10K_STATE_CONNECT; -} - -/** - * fm10k_sm_mbx_connect - Start switch manager mailbox connection - * @hw: pointer to hardware structure - * @mbx: pointer to mailbox - * - * This function will initiate a mailbox connection with the switch - * manager. To do this it will first disconnect the mailbox, and then - * reconnect it in order to complete a reset of the mailbox. - * - * This function will return an error if the mailbox has not been initiated - * or is currently in use. - **/ -STATIC s32 fm10k_sm_mbx_connect(struct fm10k_hw *hw, struct fm10k_mbx_info *mbx) -{ - DEBUGFUNC("fm10k_mbx_connect"); - - /* we cannot connect an uninitialized mailbox */ - if (!mbx->rx.buffer) - return FM10K_MBX_ERR_NO_SPACE; - - /* we cannot connect an already connected mailbox */ - if (mbx->state != FM10K_STATE_CLOSED) - return FM10K_MBX_ERR_BUSY; - - /* mailbox timeout can now become active */ - mbx->timeout = FM10K_MBX_INIT_TIMEOUT; - - /* Place mbx in ready to connect state */ - mbx->state = FM10K_STATE_CONNECT; - mbx->max_size = FM10K_MBX_MSG_MAX_SIZE; - - /* reset interface back to connect */ - fm10k_sm_mbx_connect_reset(mbx); - - /* enable interrupt and notify other party of new message */ - mbx->mbx_lock = FM10K_MBX_REQ_INTERRUPT | FM10K_MBX_ACK_INTERRUPT | - FM10K_MBX_INTERRUPT_ENABLE; - - /* generate and load connect header into mailbox */ - fm10k_sm_mbx_create_connect_hdr(mbx, 0); - fm10k_mbx_write(hw, mbx); - - /* enable interrupt and notify other party of new message */ - - return FM10K_SUCCESS; -} - -/** - * fm10k_sm_mbx_disconnect - Shutdown mailbox connection - * @hw: pointer to hardware structure - * @mbx: pointer to mailbox - * - * This function will shut down the mailbox. It places the mailbox first - * in the disconnect state, it then allows up to a predefined timeout for - * the mailbox to transition to close on its own. If this does not occur - * then the mailbox will be forced into the closed state. - * - * Any mailbox transactions not completed before calling this function - * are not guaranteed to complete and may be dropped. - **/ -STATIC void fm10k_sm_mbx_disconnect(struct fm10k_hw *hw, - struct fm10k_mbx_info *mbx) -{ - int timeout = mbx->timeout ? FM10K_MBX_DISCONNECT_TIMEOUT : 0; - - DEBUGFUNC("fm10k_sm_mbx_disconnect"); - - /* Place mbx in ready to disconnect state */ - mbx->state = FM10K_STATE_DISCONNECT; - - /* trigger interrupt to start shutdown process */ - FM10K_WRITE_REG(hw, mbx->mbx_reg, FM10K_MBX_REQ | - FM10K_MBX_INTERRUPT_DISABLE); - do { - usec_delay(FM10K_MBX_POLL_DELAY); - mbx->ops.process(hw, mbx); - timeout -= FM10K_MBX_POLL_DELAY; - } while ((timeout > 0) && (mbx->state != FM10K_STATE_CLOSED)); - - /* in case we didn't close just force the mailbox into shutdown */ - mbx->state = FM10K_STATE_CLOSED; - mbx->remote = 0; - fm10k_mbx_reset_work(mbx); - fm10k_fifo_drop_all(&mbx->tx); - - FM10K_WRITE_REG(hw, mbx->mbmem_reg, 0); -} - -/** - * fm10k_mbx_validate_fifo_hdr - Validate fields in the remote FIFO header - * @mbx: pointer to mailbox - * - * This function will parse up the fields in the mailbox header and return - * an error if the header contains any of a number of invalid configurations - * including unrecognized offsets or version numbers. - **/ -STATIC s32 fm10k_sm_mbx_validate_fifo_hdr(struct fm10k_mbx_info *mbx) -{ - const u32 *hdr = &mbx->mbx_hdr; - u16 tail, head, ver; - - DEBUGFUNC("fm10k_mbx_validate_msg_hdr"); - - tail = FM10K_MSG_HDR_FIELD_GET(*hdr, SM_TAIL); - ver = FM10K_MSG_HDR_FIELD_GET(*hdr, SM_VER); - head = FM10K_MSG_HDR_FIELD_GET(*hdr, SM_HEAD); - - switch (ver) { - case 0: - break; - case FM10K_SM_MBX_VERSION: - if (!head || head > FM10K_SM_MBX_FIFO_LEN) - return FM10K_MBX_ERR_HEAD; - if (!tail || tail > FM10K_SM_MBX_FIFO_LEN) - return FM10K_MBX_ERR_TAIL; - if (mbx->tail < head) - head += mbx->mbmem_len - 1; - if (tail < mbx->head) - tail += mbx->mbmem_len - 1; - if (fm10k_mbx_index_len(mbx, head, mbx->tail) > mbx->tail_len) - return FM10K_MBX_ERR_HEAD; - if (fm10k_mbx_index_len(mbx, mbx->head, tail) < mbx->mbmem_len) - break; - return FM10K_MBX_ERR_TAIL; - default: - return FM10K_MBX_ERR_SRC; - } - - return FM10K_SUCCESS; -} - -/** - * fm10k_sm_mbx_process_error - Process header with error flag set - * @mbx: pointer to mailbox - * - * This function is meant to respond to a request where the error flag - * is set. As a result we will terminate a connection if one is present - * and fall back into the reset state with a connection header of version - * 0 (RESET). - **/ -STATIC void fm10k_sm_mbx_process_error(struct fm10k_mbx_info *mbx) -{ - const enum fm10k_mbx_state state = mbx->state; - - switch (state) { - case FM10K_STATE_DISCONNECT: - /* if there is an error just disconnect */ - mbx->remote = 0; - break; - case FM10K_STATE_OPEN: - /* flush any uncompleted work */ - fm10k_sm_mbx_connect_reset(mbx); - break; - case FM10K_STATE_CONNECT: - /* try connnecting at lower version */ - if (mbx->remote) { - while (mbx->local > 1) - mbx->local--; - mbx->remote = 0; - } - break; - default: - break; - } - - fm10k_sm_mbx_create_connect_hdr(mbx, 0); -} - -/** - * fm10k_sm_mbx_create_error_message - Process an error in FIFO hdr - * @mbx: pointer to mailbox - * @err: local error encountered - * - * This function will interpret the error provided by err, and based on - * that it may set the error bit in the local message header - **/ -STATIC void fm10k_sm_mbx_create_error_msg(struct fm10k_mbx_info *mbx, s32 err) -{ - /* only generate an error message for these types */ - switch (err) { - case FM10K_MBX_ERR_TAIL: - case FM10K_MBX_ERR_HEAD: - case FM10K_MBX_ERR_SRC: - case FM10K_MBX_ERR_SIZE: - case FM10K_MBX_ERR_RSVD0: - break; - default: - return; - } - - /* process it as though we received an error, and send error reply */ - fm10k_sm_mbx_process_error(mbx); - fm10k_sm_mbx_create_connect_hdr(mbx, 1); -} - -/** - * fm10k_sm_mbx_receive - Take message from Rx mailbox FIFO and put it in Rx - * @hw: pointer to hardware structure - * @mbx: pointer to mailbox - * - * This function will dequeue one message from the Rx switch manager mailbox - * FIFO and place it in the Rx mailbox FIFO for processing by software. - **/ -STATIC s32 fm10k_sm_mbx_receive(struct fm10k_hw *hw, - struct fm10k_mbx_info *mbx, - u16 tail) -{ - /* reduce length by 1 to convert to a mask */ - u16 mbmem_len = mbx->mbmem_len - 1; - s32 err; - - DEBUGFUNC("fm10k_sm_mbx_receive"); - - /* push tail in front of head */ - if (tail < mbx->head) - tail += mbmem_len; - - /* copy data to the Rx FIFO */ - err = fm10k_mbx_push_tail(hw, mbx, tail); - if (err < 0) - return err; - - /* process messages if we have received any */ - fm10k_mbx_dequeue_rx(hw, mbx); - - /* guarantee head aligns with the end of the last message */ - mbx->head = fm10k_mbx_head_sub(mbx, mbx->pushed); - mbx->pushed = 0; - - /* clear any extra bits left over since index adds 1 extra bit */ - if (mbx->head > mbmem_len) - mbx->head -= mbmem_len; - - return err; -} - -/** - * fm10k_sm_mbx_transmit - Take message from Tx and put it in Tx mailbox FIFO - * @hw: pointer to hardware structure - * @mbx: pointer to mailbox - * - * This function will dequeue one message from the Tx mailbox FIFO and place - * it in the Tx switch manager mailbox FIFO for processing by hardware. - **/ -STATIC void fm10k_sm_mbx_transmit(struct fm10k_hw *hw, - struct fm10k_mbx_info *mbx, u16 head) -{ - struct fm10k_mbx_fifo *fifo = &mbx->tx; - /* reduce length by 1 to convert to a mask */ - u16 mbmem_len = mbx->mbmem_len - 1; - u16 tail_len, len = 0; - u32 *msg; - - DEBUGFUNC("fm10k_sm_mbx_transmit"); - - /* push head behind tail */ - if (mbx->tail < head) - head += mbmem_len; - - fm10k_mbx_pull_head(hw, mbx, head); - - /* determine msg aligned offset for end of buffer */ - do { - msg = fifo->buffer + fm10k_fifo_head_offset(fifo, len); - tail_len = len; - len += FM10K_TLV_DWORD_LEN(*msg); - } while ((len <= mbx->tail_len) && (len < mbmem_len)); - - /* guarantee we stop on a message boundary */ - if (mbx->tail_len > tail_len) { - mbx->tail = fm10k_mbx_tail_sub(mbx, mbx->tail_len - tail_len); - mbx->tail_len = tail_len; - } - - /* clear any extra bits left over since index adds 1 extra bit */ - if (mbx->tail > mbmem_len) - mbx->tail -= mbmem_len; -} - -/** - * fm10k_sm_mbx_create_reply - Generate reply based on state and remote head - * @mbx: pointer to mailbox - * @head: acknowledgement number - * - * This function will generate an outgoing message based on the current - * mailbox state and the remote fifo head. It will return the length - * of the outgoing message excluding header on success, and a negative value - * on error. - **/ -STATIC void fm10k_sm_mbx_create_reply(struct fm10k_hw *hw, - struct fm10k_mbx_info *mbx, u16 head) -{ - switch (mbx->state) { - case FM10K_STATE_OPEN: - case FM10K_STATE_DISCONNECT: - /* flush out Tx data */ - fm10k_sm_mbx_transmit(hw, mbx, head); - - /* generate new header based on data */ - if (mbx->tail_len || (mbx->state == FM10K_STATE_OPEN)) { - fm10k_sm_mbx_create_data_hdr(mbx); - } else { - mbx->remote = 0; - fm10k_sm_mbx_create_connect_hdr(mbx, 0); - } - break; - case FM10K_STATE_CONNECT: - case FM10K_STATE_CLOSED: - fm10k_sm_mbx_create_connect_hdr(mbx, 0); - break; - default: - break; - } -} - -/** - * fm10k_sm_mbx_process_reset - Process header with version == 0 (RESET) - * @hw: pointer to hardware structure - * @mbx: pointer to mailbox - * - * This function is meant to respond to a request where the version data - * is set to 0. As such we will either terminate the connection or go - * into the connect state in order to re-establish the connection. This - * function can also be used to respond to an error as the connection - * resetting would also be a means of dealing with errors. - **/ -STATIC void fm10k_sm_mbx_process_reset(struct fm10k_hw *hw, - struct fm10k_mbx_info *mbx) -{ - const enum fm10k_mbx_state state = mbx->state; - - switch (state) { - case FM10K_STATE_DISCONNECT: - /* drop remote connections and disconnect */ - mbx->state = FM10K_STATE_CLOSED; - mbx->remote = 0; - mbx->local = 0; - break; - case FM10K_STATE_OPEN: - /* flush any incomplete work */ - fm10k_sm_mbx_connect_reset(mbx); - break; - case FM10K_STATE_CONNECT: - /* Update remote value to match local value */ - mbx->remote = mbx->local; - default: - break; - } - - fm10k_sm_mbx_create_reply(hw, mbx, mbx->tail); -} - -/** - * fm10k_sm_mbx_process_version_1 - Process header with version == 1 - * @hw: pointer to hardware structure - * @mbx: pointer to mailbox - * - * This function is meant to process messages received when the remote - * mailbox is active. - **/ -STATIC s32 fm10k_sm_mbx_process_version_1(struct fm10k_hw *hw, - struct fm10k_mbx_info *mbx) -{ - const u32 *hdr = &mbx->mbx_hdr; - u16 head, tail; - s32 len; - - /* pull all fields needed for verification */ - tail = FM10K_MSG_HDR_FIELD_GET(*hdr, SM_TAIL); - head = FM10K_MSG_HDR_FIELD_GET(*hdr, SM_HEAD); - - /* if we are in connect and wanting version 1 then start up and go */ - if (mbx->state == FM10K_STATE_CONNECT) { - if (!mbx->remote) - goto send_reply; - if (mbx->remote != 1) - return FM10K_MBX_ERR_SRC; - - mbx->state = FM10K_STATE_OPEN; - } - - do { - /* abort on message size errors */ - len = fm10k_sm_mbx_receive(hw, mbx, tail); - if (len < 0) - return len; - - /* continue until we have flushed the Rx FIFO */ - } while (len); - -send_reply: - fm10k_sm_mbx_create_reply(hw, mbx, head); - - return FM10K_SUCCESS; -} - -/** - * fm10k_sm_mbx_process - Process mailbox switch mailbox interrupt - * @hw: pointer to hardware structure - * @mbx: pointer to mailbox - * - * This function will process incoming mailbox events and generate mailbox - * replies. It will return a value indicating the number of DWORDs - * transmitted excluding header on success or a negative value on error. - **/ -STATIC s32 fm10k_sm_mbx_process(struct fm10k_hw *hw, - struct fm10k_mbx_info *mbx) -{ - s32 err; - - DEBUGFUNC("fm10k_sm_mbx_process"); - - /* we do not read mailbox if closed */ - if (mbx->state == FM10K_STATE_CLOSED) - return FM10K_SUCCESS; - - /* retrieve data from switch manager */ - err = fm10k_mbx_read(hw, mbx); - if (err) - return err; - - err = fm10k_sm_mbx_validate_fifo_hdr(mbx); - if (err < 0) - goto fifo_err; - - if (FM10K_MSG_HDR_FIELD_GET(mbx->mbx_hdr, SM_ERR)) { - fm10k_sm_mbx_process_error(mbx); - goto fifo_err; - } - - switch (FM10K_MSG_HDR_FIELD_GET(mbx->mbx_hdr, SM_VER)) { - case 0: - fm10k_sm_mbx_process_reset(hw, mbx); - break; - case FM10K_SM_MBX_VERSION: - err = fm10k_sm_mbx_process_version_1(hw, mbx); - break; - } - -fifo_err: - if (err < 0) - fm10k_sm_mbx_create_error_msg(mbx, err); - - /* report data to switch manager */ - fm10k_mbx_write(hw, mbx); - - return err; -} - -/** - * fm10k_sm_mbx_init - Initialize mailbox memory for PF/SM mailbox - * @hw: pointer to hardware structure - * @mbx: pointer to mailbox - * @msg_data: handlers for mailbox events - * - * This function for now is used to stub out the PF/SM mailbox - **/ -s32 fm10k_sm_mbx_init(struct fm10k_hw *hw, struct fm10k_mbx_info *mbx, - const struct fm10k_msg_data *msg_data) -{ - DEBUGFUNC("fm10k_sm_mbx_init"); - UNREFERENCED_1PARAMETER(hw); - - mbx->mbx_reg = FM10K_GMBX; - mbx->mbmem_reg = FM10K_MBMEM_PF(0); - - /* start out in closed state */ - mbx->state = FM10K_STATE_CLOSED; - - /* validate layout of handlers before assigning them */ - if (fm10k_mbx_validate_handlers(msg_data)) - return FM10K_ERR_PARAM; - - /* initialize the message handlers */ - mbx->msg_data = msg_data; - - /* start mailbox as timed out and let the reset_hw call - * set the timeout value to begin communications - */ - mbx->timeout = 0; - mbx->usec_delay = FM10K_MBX_INIT_DELAY; - - /* Split buffer for use by Tx/Rx FIFOs */ - mbx->max_size = FM10K_MBX_MSG_MAX_SIZE; - mbx->mbmem_len = FM10K_MBMEM_PF_XOR; - - /* initialize the FIFOs, sizes are in 4 byte increments */ - fm10k_fifo_init(&mbx->tx, mbx->buffer, FM10K_MBX_TX_BUFFER_SIZE); - fm10k_fifo_init(&mbx->rx, &mbx->buffer[FM10K_MBX_TX_BUFFER_SIZE], - FM10K_MBX_RX_BUFFER_SIZE); - - /* initialize function pointers */ - mbx->ops.connect = fm10k_sm_mbx_connect; - mbx->ops.disconnect = fm10k_sm_mbx_disconnect; - mbx->ops.rx_ready = fm10k_mbx_rx_ready; - mbx->ops.tx_ready = fm10k_mbx_tx_ready; - mbx->ops.tx_complete = fm10k_mbx_tx_complete; - mbx->ops.enqueue_tx = fm10k_mbx_enqueue_tx; - mbx->ops.process = fm10k_sm_mbx_process; - mbx->ops.register_handlers = fm10k_mbx_register_handlers; - - return FM10K_SUCCESS; -} |