// SPDX-License-Identifier: GPL-2.0 /* Copyright(c) 2013 - 2019 Intel Corporation. */ #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) { … } /** * 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) { … } /** * 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) { … } /** * 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) { … } /** * 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) { … } /** * 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) { … } /** * 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) { … } /** * 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) { … } /** * 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) { … } /** * 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) { … } /** * fm10k_mbx_tail_add - Determine new tail value with added offset * @mbx: pointer to mailbox * @offset: length to add to tail 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) { … } /** * fm10k_mbx_tail_sub - Determine new tail value with subtracted offset * @mbx: pointer to mailbox * @offset: length to add to tail 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) { … } /** * 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) { … } /** * 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) { … } /** * 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) { … } /** * 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) { … } /** * 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) { … } /** * 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) { … } /** * fm10k_mbx_write_copy - pulls data off of Tx FIFO and places it in mbmem * @hw: pointer to hardware structure * @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) { … } /** * 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) { … } /** * 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) { … } /** * 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) { … } /* pre-generated data for generating the CRC based on the poly 0xAC9A. */ static const u16 fm10k_crc_16b_table[256] = …; /** * 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) { … } /** * 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) { … } /** * 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) { … } /** * 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) { … } /** * 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) { … } /** * 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) { … } /** * 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) { … } /** * fm10k_mbx_dequeue_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) { … } /** * 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) { … } /** * 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) { … } /** * 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 message array to mbmem **/ static void fm10k_mbx_write(struct fm10k_hw *hw, struct fm10k_mbx_info *mbx) { … } /** * 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) { … } /** * 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) { … } /** * 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) { … } /** * fm10k_mbx_create_fake_disconnect_hdr - Generate a false disconnect mbox hdr * @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) { … } /** * fm10k_mbx_create_error_msg - Generate an 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) { … } /** * fm10k_mbx_validate_msg_hdr - Validate common fields in the message 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 type, invalid route, or a malformed message. **/ static s32 fm10k_mbx_validate_msg_hdr(struct fm10k_mbx_info *mbx) { … } /** * fm10k_mbx_create_reply - Generate reply based on state and remote head * @hw: pointer to hardware structure * @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) { … } /** * 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) { … } /** * fm10k_mbx_update_max_size - Update the max_size and drop any 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) { … } /** * 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) { … } /** * fm10k_mbx_process_connect - Process connect header * @hw: pointer to hardware structure * @mbx: pointer to mailbox * * 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) { … } /** * fm10k_mbx_process_data - Process data header * @hw: pointer to hardware structure * @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) { … } /** * fm10k_mbx_process_disconnect - Process disconnect header * @hw: pointer to hardware structure * @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) { … } /** * fm10k_mbx_process_error - Process error header * @hw: pointer to hardware structure * @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) { … } /** * 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) { … } /** * 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) { … } /** * 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) { … } /** * 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) { … } /** * 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) { … } /** * 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 and use that to 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) { … } /** * fm10k_sm_mbx_create_data_hdr - Generate a mailbox header for local FIFO * @mbx: pointer to mailbox * * This function returns a data mailbox header **/ static void fm10k_sm_mbx_create_data_hdr(struct fm10k_mbx_info *mbx) { … } /** * 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) { … } /** * 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) { … } /** * 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) { … } /** * 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) { … } /** * fm10k_sm_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) { … } /** * 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) { … } /** * fm10k_sm_mbx_create_error_msg - Process an error in FIFO header * @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) { … } /** * fm10k_sm_mbx_receive - Take message from Rx mailbox FIFO and put it in Rx * @hw: pointer to hardware structure * @mbx: pointer to mailbox * @tail: tail index of message * * 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) { … } /** * fm10k_sm_mbx_transmit - Take message from Tx and put it in Tx mailbox FIFO * @hw: pointer to hardware structure * @mbx: pointer to mailbox * @head: head index of message * * 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) { … } /** * fm10k_sm_mbx_create_reply - Generate reply based on state and remote head * @hw: pointer to hardware structure * @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) { … } /** * 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 s32 fm10k_sm_mbx_process_reset(struct fm10k_hw *hw, struct fm10k_mbx_info *mbx) { … } /** * 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) { … } /** * fm10k_sm_mbx_process - Process switch manager 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) { … } /** * 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 initializes the PF/SM mailbox for use. It will split the * buffer provided and use that to 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_sm_mbx_init(struct fm10k_hw __always_unused *hw, struct fm10k_mbx_info *mbx, const struct fm10k_msg_data *msg_data) { … }
Codebase Browser
linux