2022-08-23 15:00:33 +00:00
|
|
|
/*
|
|
|
|
* Copyright 2021 NXP
|
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* SPDX-License-Identifier: BSD-3-Clause
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "fsl_component_serial_manager.h"
|
|
|
|
#include "fsl_component_serial_port_internal.h"
|
|
|
|
|
|
|
|
#if (defined(SERIAL_PORT_TYPE_SPI) && (SERIAL_PORT_TYPE_SPI > 0U))
|
|
|
|
#include "fsl_adapter_spi.h"
|
|
|
|
#include "fsl_component_serial_port_spi.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*******************************************************************************
|
|
|
|
* Definitions
|
|
|
|
******************************************************************************/
|
|
|
|
#ifndef NDEBUG
|
|
|
|
#if (defined(DEBUG_CONSOLE_ASSERT_DISABLE) && (DEBUG_CONSOLE_ASSERT_DISABLE > 0U))
|
|
|
|
#undef assert
|
|
|
|
#define assert(n)
|
|
|
|
#else
|
|
|
|
/* MISRA C-2012 Rule 17.2 */
|
|
|
|
#undef assert
|
|
|
|
#define assert(n) \
|
|
|
|
while (!(n)) \
|
|
|
|
{ \
|
|
|
|
; \
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#define SERIAL_PORT_SPI_RECEIVE_DATA_LENGTH 1U
|
|
|
|
#define SERIAL_MANAGER_BLOCK_OFFSET (12U)
|
|
|
|
|
|
|
|
typedef struct _serial_spi_master_send_state
|
|
|
|
{
|
|
|
|
uint8_t *buffer;
|
|
|
|
uint32_t length;
|
|
|
|
serial_manager_callback_t callback;
|
|
|
|
void *callbackParam;
|
|
|
|
} serial_spi_master_send_state_t;
|
|
|
|
|
|
|
|
typedef struct _serial_spi_master_recv_state
|
|
|
|
{
|
|
|
|
uint8_t *buffer;
|
|
|
|
uint32_t length;
|
|
|
|
serial_manager_callback_t callback;
|
|
|
|
void *callbackParam;
|
|
|
|
} serial_spi_master_recv_state_t;
|
|
|
|
|
|
|
|
typedef struct _serial_spi_master_state
|
|
|
|
{
|
|
|
|
HAL_SPI_MASTER_HANDLE_DEFINE(spiMasterHandleBuffer);
|
|
|
|
uint32_t configFlags;
|
|
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
|
|
serial_spi_master_send_state_t tx;
|
|
|
|
serial_spi_master_recv_state_t rx;
|
|
|
|
#endif
|
|
|
|
} serial_spi_master_state_t;
|
|
|
|
|
|
|
|
typedef struct _serial_spi_slave_send_state
|
|
|
|
{
|
|
|
|
uint8_t *buffer;
|
|
|
|
uint32_t length;
|
|
|
|
serial_manager_callback_t callback;
|
|
|
|
void *callbackParam;
|
|
|
|
} serial_spi_slave_send_state_t;
|
|
|
|
|
|
|
|
typedef struct _serial_spi_slave_recv_state
|
|
|
|
{
|
|
|
|
uint8_t *buffer;
|
|
|
|
uint32_t length;
|
|
|
|
serial_manager_callback_t callback;
|
|
|
|
void *callbackParam;
|
|
|
|
} serial_spi_slave_recv_state_t;
|
|
|
|
|
|
|
|
typedef struct _serial_spi_slave_state
|
|
|
|
{
|
|
|
|
HAL_SPI_SLAVE_HANDLE_DEFINE(spiSlaveHandleBuffer);
|
|
|
|
uint32_t configFlags;
|
|
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
|
|
serial_spi_slave_send_state_t tx;
|
|
|
|
serial_spi_slave_recv_state_t rx;
|
|
|
|
#endif
|
|
|
|
} serial_spi_slave_state_t;
|
|
|
|
|
|
|
|
/*******************************************************************************
|
|
|
|
* Prototypes
|
|
|
|
******************************************************************************/
|
|
|
|
|
|
|
|
/*******************************************************************************
|
|
|
|
* Code
|
|
|
|
******************************************************************************/
|
|
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
|
|
void Serial_SpiMasterTxCallback(hal_spi_master_handle_t handle, hal_spi_status_t status, void *callbackParam)
|
|
|
|
{
|
|
|
|
serial_spi_master_state_t *serialSpiMasterHandle;
|
|
|
|
serial_manager_callback_message_t msg;
|
|
|
|
|
|
|
|
if (NULL != callbackParam)
|
|
|
|
{
|
|
|
|
serialSpiMasterHandle = (serial_spi_master_state_t *)callbackParam;
|
|
|
|
if (NULL != serialSpiMasterHandle->tx.callback)
|
|
|
|
{
|
|
|
|
serial_manager_status_t serialManagerStatus = kStatus_SerialManager_Success;
|
|
|
|
msg.buffer = serialSpiMasterHandle->tx.buffer;
|
|
|
|
msg.length = serialSpiMasterHandle->tx.length;
|
|
|
|
if (NULL != serialSpiMasterHandle->tx.callback)
|
|
|
|
{
|
|
|
|
serialSpiMasterHandle->tx.callback(serialSpiMasterHandle->tx.callbackParam, &msg, serialManagerStatus);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Serial_SpiMasterRxCallback(hal_spi_master_handle_t handle, hal_spi_status_t status, void *callbackParam)
|
|
|
|
{
|
|
|
|
serial_spi_master_state_t *serialSpiMasterHandle;
|
|
|
|
serial_manager_callback_message_t msg;
|
|
|
|
|
|
|
|
if (NULL != callbackParam)
|
|
|
|
{
|
|
|
|
serialSpiMasterHandle = (serial_spi_master_state_t *)callbackParam;
|
|
|
|
serial_manager_status_t serialManagerStatus = kStatus_SerialManager_Success;
|
|
|
|
msg.buffer = serialSpiMasterHandle->rx.buffer;
|
|
|
|
msg.length = serialSpiMasterHandle->rx.length;
|
|
|
|
if (NULL != serialSpiMasterHandle->rx.callback)
|
|
|
|
{
|
|
|
|
serialSpiMasterHandle->rx.callback(serialSpiMasterHandle->rx.callbackParam, &msg, serialManagerStatus);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Serial_SpiSlaveTxCallback(hal_spi_slave_handle_t handle, hal_spi_status_t status, void *callbackParam)
|
|
|
|
{
|
|
|
|
serial_spi_slave_state_t *serialSpiSlaveHandle;
|
|
|
|
serial_manager_callback_message_t msg;
|
|
|
|
|
|
|
|
if (NULL != callbackParam)
|
|
|
|
{
|
|
|
|
serialSpiSlaveHandle = (serial_spi_slave_state_t *)callbackParam;
|
|
|
|
serial_manager_status_t serialManagerStatus = kStatus_SerialManager_Success;
|
|
|
|
msg.buffer = serialSpiSlaveHandle->tx.buffer;
|
|
|
|
msg.length = serialSpiSlaveHandle->tx.length;
|
|
|
|
if (NULL != serialSpiSlaveHandle->tx.callback)
|
|
|
|
{
|
|
|
|
serialSpiSlaveHandle->tx.callback(serialSpiSlaveHandle->tx.callbackParam, &msg, serialManagerStatus);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Serial_SpiSlaveRxCallback(hal_spi_slave_handle_t handle, hal_spi_status_t status, void *callbackParam)
|
|
|
|
{
|
|
|
|
serial_spi_slave_state_t *serialSpiSlaveHandle;
|
|
|
|
serial_manager_callback_message_t msg;
|
|
|
|
if (NULL != callbackParam)
|
|
|
|
{
|
|
|
|
serialSpiSlaveHandle = (serial_spi_slave_state_t *)callbackParam;
|
|
|
|
serial_manager_status_t serialManagerStatus = kStatus_SerialManager_Success;
|
|
|
|
msg.buffer = serialSpiSlaveHandle->rx.buffer;
|
|
|
|
msg.length = serialSpiSlaveHandle->rx.length;
|
|
|
|
if (NULL != serialSpiSlaveHandle->rx.callback)
|
|
|
|
{
|
|
|
|
serialSpiSlaveHandle->rx.callback(serialSpiSlaveHandle->rx.callbackParam, &msg, serialManagerStatus);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif /* SERIAL_MANAGER_NON_BLOCKING_MODE */
|
|
|
|
serial_manager_status_t Serial_SpiMasterInit(serial_handle_t serialHandle, void *serialConfig)
|
|
|
|
{
|
|
|
|
serial_spi_master_state_t *serialSpiMasterHandle;
|
|
|
|
serial_spi_master_config_t *serialSpiMasterConfig;
|
|
|
|
#if (defined(HAL_SPI_MASTER_DMA_ENABLE) && (HAL_SPI_MASTER_DMA_ENABLE > 0U))
|
|
|
|
hal_spi_dma_config_t *spi_dma_config;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
assert(serialHandle);
|
|
|
|
assert(serialConfig);
|
|
|
|
#if (defined(HAL_SPI_MASTER_DMA_ENABLE) && (HAL_SPI_MASTER_DMA_ENABLE > 0U))
|
|
|
|
assert((SERIAL_PORT_SPI_MASTER_HANDLE_SIZE - HAL_SPI_MASTER_DMA_HANDLE_SIZE) >= sizeof(serial_spi_master_state_t));
|
|
|
|
#else
|
|
|
|
assert(SERIAL_PORT_SPI_MASTER_HANDLE_SIZE >= sizeof(serial_spi_master_state_t));
|
|
|
|
#endif
|
|
|
|
serialSpiMasterHandle = (serial_spi_master_state_t *)serialHandle;
|
|
|
|
serialSpiMasterConfig = (serial_spi_master_config_t *)serialConfig;
|
|
|
|
|
|
|
|
if (kStatus_HAL_SpiSuccess !=
|
|
|
|
HAL_SpiMasterInit((hal_spi_master_handle_t)serialSpiMasterHandle->spiMasterHandleBuffer,
|
|
|
|
(const hal_spi_master_config_t *)serialSpiMasterConfig))
|
|
|
|
{
|
|
|
|
return kStatus_SerialManager_Error;
|
|
|
|
}
|
|
|
|
serialSpiMasterHandle->configFlags = serialSpiMasterConfig->configFlags;
|
|
|
|
#if (defined(HAL_SPI_MASTER_DMA_ENABLE) && (HAL_SPI_MASTER_DMA_ENABLE > 0U))
|
|
|
|
if (serialSpiMasterConfig->enableDMA == 1)
|
|
|
|
{
|
|
|
|
spi_dma_config = (hal_spi_dma_config_t *)serialSpiMasterConfig->dmaConfig;
|
|
|
|
HAL_SpiMasterDMAInit((hal_spi_master_handle_t)serialSpiMasterHandle->spiMasterHandleBuffer,
|
|
|
|
(uint8_t *)serialSpiMasterHandle->spiMasterHandleBuffer +
|
|
|
|
(SERIAL_PORT_SPI_MASTER_HANDLE_SIZE - HAL_SPI_MASTER_DMA_HANDLE_SIZE),
|
|
|
|
spi_dma_config);
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
|
|
#endif /* SERIAL_MANAGER_NON_BLOCKING_MODE */
|
|
|
|
|
|
|
|
return kStatus_SerialManager_Success;
|
|
|
|
}
|
|
|
|
|
|
|
|
serial_manager_status_t Serial_SpiMasterDeinit(serial_handle_t serialHandle)
|
|
|
|
{
|
|
|
|
serial_spi_master_state_t *serialSpiMasterHandle;
|
|
|
|
|
|
|
|
assert(serialHandle);
|
|
|
|
|
|
|
|
serialSpiMasterHandle = (serial_spi_master_state_t *)serialHandle;
|
|
|
|
|
|
|
|
(void)HAL_SpiMasterDeinit((hal_spi_master_handle_t)serialSpiMasterHandle->spiMasterHandleBuffer);
|
|
|
|
|
|
|
|
return kStatus_SerialManager_Success;
|
|
|
|
}
|
|
|
|
|
|
|
|
serial_manager_status_t Serial_SpiSlaveInit(serial_handle_t serialHandle, void *serialConfig)
|
|
|
|
{
|
|
|
|
serial_spi_slave_state_t *serialSpiSlaveHandle;
|
|
|
|
serial_spi_slave_config_t *serialSpiSlaveConfig;
|
|
|
|
#if (defined(HAL_SPI_SLAVE_DMA_ENABLE) && (HAL_SPI_SLAVE_DMA_ENABLE > 0U))
|
|
|
|
hal_spi_dma_config_t *spi_dma_config;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
assert(serialHandle);
|
|
|
|
assert(serialConfig);
|
|
|
|
|
|
|
|
#if (defined(HAL_SPI_SLAVE_DMA_ENABLE) && (HAL_SPI_SLAVE_DMA_ENABLE > 0U))
|
|
|
|
assert((SERIAL_PORT_SPI_SLAVE_HANDLE_SIZE - HAL_SPI_SLAVE_DMA_HANDLE_SIZE) >= sizeof(serial_spi_slave_state_t));
|
|
|
|
#else
|
|
|
|
assert(SERIAL_PORT_SPI_SLAVE_HANDLE_SIZE >= sizeof(serial_spi_slave_state_t));
|
|
|
|
#endif
|
|
|
|
|
|
|
|
serialSpiSlaveHandle = (serial_spi_slave_state_t *)serialHandle;
|
|
|
|
serialSpiSlaveConfig = (serial_spi_slave_config_t *)serialConfig;
|
|
|
|
|
|
|
|
if (kStatus_HAL_SpiSuccess != HAL_SpiSlaveInit((hal_spi_slave_handle_t)serialSpiSlaveHandle->spiSlaveHandleBuffer,
|
|
|
|
(hal_spi_slave_config_t *)serialSpiSlaveConfig))
|
|
|
|
{
|
|
|
|
return kStatus_SerialManager_Error;
|
|
|
|
}
|
|
|
|
serialSpiSlaveHandle->configFlags = serialSpiSlaveConfig->configFlags;
|
|
|
|
#if (defined(HAL_SPI_SLAVE_DMA_ENABLE) && (HAL_SPI_SLAVE_DMA_ENABLE > 0U))
|
|
|
|
if (serialSpiSlaveConfig->enableDMA == 1)
|
|
|
|
{
|
|
|
|
spi_dma_config = (hal_spi_dma_config_t *)serialSpiSlaveConfig->dmaConfig;
|
|
|
|
HAL_SpiSlaveDMAInit((hal_spi_slave_handle_t)serialSpiSlaveHandle->spiSlaveHandleBuffer,
|
|
|
|
(uint8_t *)serialSpiSlaveHandle->spiSlaveHandleBuffer +
|
|
|
|
(SERIAL_PORT_SPI_SLAVE_HANDLE_SIZE - HAL_SPI_SLAVE_DMA_HANDLE_SIZE),
|
|
|
|
spi_dma_config);
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
|
|
#endif /* SERIAL_MANAGER_NON_BLOCKING_MODE */
|
|
|
|
|
|
|
|
return kStatus_SerialManager_Success;
|
|
|
|
}
|
|
|
|
|
|
|
|
serial_manager_status_t Serial_SpiSlaveDeinit(serial_handle_t serialHandle)
|
|
|
|
{
|
|
|
|
serial_spi_slave_state_t *serialSpiSlaveHandle;
|
|
|
|
|
|
|
|
assert(serialHandle);
|
|
|
|
|
|
|
|
serialSpiSlaveHandle = (serial_spi_slave_state_t *)serialHandle;
|
|
|
|
|
|
|
|
(void)HAL_SpiSlaveDeinit((hal_spi_slave_handle_t)serialSpiSlaveHandle->spiSlaveHandleBuffer);
|
|
|
|
|
|
|
|
return kStatus_SerialManager_Success;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
|
|
|
|
|
|
serial_manager_status_t Serial_SpiMasterWrite(serial_handle_t serialHandle, uint8_t *buffer, uint32_t length)
|
|
|
|
{
|
|
|
|
serial_spi_master_state_t *serialSpiMasterHandle;
|
|
|
|
hal_spi_transfer_t mastetTransfer;
|
|
|
|
|
|
|
|
assert(serialHandle);
|
|
|
|
assert(buffer);
|
|
|
|
assert(length);
|
|
|
|
serialSpiMasterHandle = (serial_spi_master_state_t *)serialHandle;
|
|
|
|
serialSpiMasterHandle->tx.buffer = buffer;
|
|
|
|
serialSpiMasterHandle->tx.length = (size_t)length;
|
|
|
|
|
|
|
|
if (kStatus_HAL_SpiSuccess !=
|
|
|
|
HAL_SpiMasterTransferInstallCallback((hal_spi_master_handle_t)serialSpiMasterHandle->spiMasterHandleBuffer,
|
|
|
|
Serial_SpiMasterTxCallback, serialHandle))
|
|
|
|
{
|
|
|
|
return kStatus_SerialManager_Error;
|
|
|
|
}
|
|
|
|
serialSpiMasterHandle = (serial_spi_master_state_t *)serialHandle;
|
|
|
|
mastetTransfer.txData = buffer;
|
|
|
|
mastetTransfer.rxData = NULL;
|
|
|
|
mastetTransfer.dataSize = (size_t)length;
|
|
|
|
mastetTransfer.flags = serialSpiMasterHandle->configFlags;
|
|
|
|
|
|
|
|
return (serial_manager_status_t)HAL_SpiMasterTransferNonBlocking(
|
|
|
|
((hal_spi_master_handle_t)&serialSpiMasterHandle->spiMasterHandleBuffer[0]), &mastetTransfer);
|
|
|
|
}
|
|
|
|
|
|
|
|
serial_manager_status_t Serial_SpiSlaveWrite(serial_handle_t serialHandle, uint8_t *buffer, uint32_t length)
|
|
|
|
{
|
|
|
|
serial_spi_slave_state_t *serialSpiSlaveHandle;
|
|
|
|
hal_spi_transfer_t slaveTransfer;
|
|
|
|
assert(serialHandle);
|
|
|
|
assert(buffer);
|
|
|
|
assert(length);
|
|
|
|
|
|
|
|
serialSpiSlaveHandle = (serial_spi_slave_state_t *)serialHandle;
|
|
|
|
serialSpiSlaveHandle->tx.buffer = buffer;
|
|
|
|
serialSpiSlaveHandle->tx.length = (size_t)length;
|
|
|
|
|
|
|
|
if (kStatus_HAL_SpiSuccess !=
|
|
|
|
HAL_SpiSlaveTransferInstallCallback((hal_spi_slave_handle_t)serialSpiSlaveHandle->spiSlaveHandleBuffer,
|
|
|
|
Serial_SpiSlaveTxCallback, serialHandle))
|
|
|
|
{
|
|
|
|
return kStatus_SerialManager_Error;
|
|
|
|
}
|
|
|
|
slaveTransfer.txData = buffer;
|
|
|
|
slaveTransfer.rxData = NULL;
|
|
|
|
slaveTransfer.dataSize = (size_t)length;
|
|
|
|
slaveTransfer.flags = serialSpiSlaveHandle->configFlags;
|
|
|
|
return (serial_manager_status_t)HAL_SpiSlaveTransferNonBlocking(
|
|
|
|
((hal_spi_slave_handle_t)&serialSpiSlaveHandle->spiSlaveHandleBuffer[0]), &slaveTransfer);
|
|
|
|
}
|
|
|
|
|
|
|
|
// read Serial_SpiMasterRead
|
|
|
|
serial_manager_status_t Serial_SpiMasterRead(serial_handle_t serialHandle, uint8_t *buffer, uint32_t length)
|
|
|
|
{
|
|
|
|
serial_spi_master_state_t *serialSpiMasterHandle;
|
|
|
|
hal_spi_transfer_t masterReceiver;
|
|
|
|
|
|
|
|
assert(serialHandle);
|
|
|
|
assert(buffer);
|
|
|
|
assert(length);
|
|
|
|
|
|
|
|
serialSpiMasterHandle = (serial_spi_master_state_t *)serialHandle;
|
|
|
|
|
|
|
|
serialSpiMasterHandle->rx.buffer = buffer;
|
|
|
|
serialSpiMasterHandle->rx.length = (size_t)length;
|
|
|
|
if (kStatus_HAL_SpiSuccess !=
|
|
|
|
HAL_SpiMasterTransferInstallCallback((hal_spi_master_handle_t)serialSpiMasterHandle->spiMasterHandleBuffer,
|
|
|
|
Serial_SpiMasterRxCallback, serialHandle))
|
|
|
|
{
|
|
|
|
return kStatus_SerialManager_Error;
|
|
|
|
}
|
|
|
|
|
|
|
|
masterReceiver.txData = NULL;
|
|
|
|
masterReceiver.rxData = buffer;
|
|
|
|
masterReceiver.dataSize = (size_t)length;
|
|
|
|
masterReceiver.flags = serialSpiMasterHandle->configFlags;
|
|
|
|
return (serial_manager_status_t)HAL_SpiMasterTransferNonBlocking(
|
|
|
|
((hal_spi_master_handle_t)&serialSpiMasterHandle->spiMasterHandleBuffer[0]), &masterReceiver);
|
|
|
|
}
|
|
|
|
|
|
|
|
serial_manager_status_t Serial_SpiSlaveRead(serial_handle_t serialHandle, uint8_t *buffer, uint32_t length)
|
|
|
|
{
|
|
|
|
serial_spi_slave_state_t *serialSpiSlaveHandle;
|
|
|
|
hal_spi_transfer_t slaveReceiver;
|
|
|
|
|
|
|
|
assert(serialHandle);
|
|
|
|
assert(buffer);
|
|
|
|
assert(length);
|
|
|
|
|
|
|
|
serialSpiSlaveHandle = (serial_spi_slave_state_t *)serialHandle;
|
|
|
|
serialSpiSlaveHandle->rx.buffer = buffer;
|
|
|
|
serialSpiSlaveHandle->rx.length = (size_t)length;
|
|
|
|
|
|
|
|
if (kStatus_HAL_SpiSuccess !=
|
|
|
|
HAL_SpiSlaveTransferInstallCallback((hal_spi_slave_handle_t)serialSpiSlaveHandle->spiSlaveHandleBuffer,
|
|
|
|
Serial_SpiSlaveRxCallback, serialHandle))
|
|
|
|
{
|
|
|
|
return kStatus_SerialManager_Error;
|
|
|
|
}
|
|
|
|
slaveReceiver.txData = NULL;
|
|
|
|
slaveReceiver.rxData = buffer;
|
|
|
|
slaveReceiver.dataSize = (size_t)length;
|
|
|
|
slaveReceiver.flags = serialSpiSlaveHandle->configFlags;
|
|
|
|
return (serial_manager_status_t)HAL_SpiSlaveTransferNonBlocking(
|
|
|
|
((hal_spi_slave_handle_t)&serialSpiSlaveHandle->spiSlaveHandleBuffer[0]), &slaveReceiver);
|
|
|
|
}
|
|
|
|
|
2022-12-02 11:44:05 +00:00
|
|
|
#else /* SERIAL_MANAGER_NON_BLOCKING_MODE */
|
2022-08-23 15:00:33 +00:00
|
|
|
serial_manager_status_t Serial_SpiMasterWrite(serial_handle_t serialHandle, uint8_t *buffer, uint32_t length)
|
|
|
|
{
|
|
|
|
serial_spi_master_state_t *serialSpiMasterHandle;
|
|
|
|
hal_spi_transfer_t mastetTransfer;
|
|
|
|
|
|
|
|
assert(serialHandle);
|
|
|
|
assert(buffer);
|
|
|
|
assert(length);
|
|
|
|
|
|
|
|
serialSpiMasterHandle = (serial_spi_master_state_t *)serialHandle;
|
|
|
|
|
2024-03-15 14:23:36 +00:00
|
|
|
mastetTransfer.txData = buffer;
|
|
|
|
mastetTransfer.rxData = NULL;
|
2022-08-23 15:00:33 +00:00
|
|
|
mastetTransfer.dataSize = (size_t)length;
|
|
|
|
return (serial_manager_status_t)HAL_SpiMasterTransferBlocking(
|
|
|
|
((hal_spi_master_handle_t)&serialSpiMasterHandle->spiMasterHandleBuffer[0]), &mastetTransfer);
|
|
|
|
}
|
|
|
|
|
|
|
|
serial_manager_status_t Serial_SpiMasterRead(serial_handle_t serialHandle, uint8_t *buffer, uint32_t length)
|
|
|
|
{
|
|
|
|
serial_spi_master_state_t *serialSpiMasterHandle;
|
|
|
|
hal_spi_transfer_t masterReceiver;
|
|
|
|
|
|
|
|
assert(serialHandle);
|
|
|
|
assert(buffer);
|
|
|
|
assert(length);
|
|
|
|
|
2024-03-15 14:23:36 +00:00
|
|
|
serialSpiMasterHandle = (serial_spi_master_state_t *)serialHandle;
|
|
|
|
masterReceiver.txData = NULL;
|
|
|
|
masterReceiver.rxData = buffer;
|
2022-08-23 15:00:33 +00:00
|
|
|
masterReceiver.dataSize = (size_t)length;
|
|
|
|
return (serial_manager_status_t)HAL_SpiMasterTransferBlocking(
|
|
|
|
((hal_spi_master_handle_t)&serialSpiMasterHandle->spiMasterHandleBuffer[0]), &masterReceiver);
|
|
|
|
}
|
|
|
|
#if 0
|
|
|
|
serial_manager_status_t Serial_SpiSlaveWrite(serial_handle_t serialHandle, uint8_t *buffer, uint32_t length)
|
|
|
|
{
|
|
|
|
serial_spi_master_state_t *serialSpiSlaveHandle;
|
|
|
|
hal_spi_transfer_t slaveTransfer;
|
|
|
|
|
|
|
|
assert(serialHandle);
|
|
|
|
assert(buffer);
|
|
|
|
assert(length);
|
|
|
|
|
|
|
|
serialSpiSlaveHandle = (serial_spi_master_state_t *)serialHandle;
|
|
|
|
|
|
|
|
slaveTransfer.txData = buffer;
|
|
|
|
slaveTransfer.rxData = NULL;
|
|
|
|
slaveTransfer.dataSize = (size_t)length;
|
|
|
|
return (serial_manager_status_t)HAL_SpiSlaveTransferBlocking(
|
|
|
|
((hal_spi_master_handle_t)&serialSpiSlaveHandle->spiSlaveHandleBuffer[0]), &slaveTransfer);
|
|
|
|
}
|
|
|
|
|
|
|
|
serial_manager_status_t Serial_SpiSlaveRead(serial_handle_t serialHandle, uint8_t *buffer, uint32_t length)
|
|
|
|
{
|
|
|
|
serial_spi_master_state_t *serialSpiSlaveHandle;
|
|
|
|
hal_spi_transfer_t slaveReceiver;
|
|
|
|
|
|
|
|
assert(serialHandle);
|
|
|
|
assert(buffer);
|
|
|
|
assert(length);
|
|
|
|
|
|
|
|
serialSpiSlaveHandle = (serial_spi_master_state_t *)serialHandle;
|
|
|
|
slaveReceiver.txData = NULL;
|
|
|
|
slaveReceiver.rxData = buffer;
|
|
|
|
slaveReceiver.dataSize = (size_t)length;
|
|
|
|
return (serial_manager_status_t)HAL_SpiSlaveTransferBlocking(
|
|
|
|
((hal_spi_master_handle_t)&serialSpiSlaveHandle->spiSlaveHandleBuffer[0]), &slaveReceiver);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
|
|
|
|
|
|
serial_manager_status_t Serial_SpiMasterInstallTxCallback(serial_handle_t serialHandle,
|
|
|
|
serial_manager_callback_t callback,
|
|
|
|
void *callbackParam)
|
|
|
|
{
|
|
|
|
serial_spi_master_state_t *serialSpiMasterHandle;
|
|
|
|
|
|
|
|
assert(serialHandle);
|
|
|
|
|
|
|
|
serialSpiMasterHandle = (serial_spi_master_state_t *)serialHandle;
|
|
|
|
|
|
|
|
serialSpiMasterHandle->tx.callback = callback;
|
|
|
|
serialSpiMasterHandle->tx.callbackParam = callbackParam;
|
|
|
|
|
|
|
|
return kStatus_SerialManager_Success;
|
|
|
|
}
|
|
|
|
|
|
|
|
serial_manager_status_t Serial_SpiMasterInstallRxCallback(serial_handle_t serialHandle,
|
|
|
|
serial_manager_callback_t callback,
|
|
|
|
void *callbackParam)
|
|
|
|
{
|
|
|
|
serial_spi_master_state_t *serialSpiMasterHandle;
|
|
|
|
|
|
|
|
assert(serialHandle);
|
|
|
|
|
|
|
|
serialSpiMasterHandle = (serial_spi_master_state_t *)serialHandle;
|
|
|
|
|
|
|
|
serialSpiMasterHandle->rx.callback = callback;
|
|
|
|
serialSpiMasterHandle->rx.callbackParam = callbackParam;
|
|
|
|
|
|
|
|
return kStatus_SerialManager_Success;
|
|
|
|
}
|
|
|
|
|
|
|
|
serial_manager_status_t Serial_SpiSlaveInstallTxCallback(serial_handle_t serialHandle,
|
|
|
|
serial_manager_callback_t callback,
|
|
|
|
void *callbackParam)
|
|
|
|
{
|
|
|
|
serial_spi_slave_state_t *serialSpiSlaveHandle;
|
|
|
|
|
|
|
|
assert(serialHandle);
|
|
|
|
|
|
|
|
serialSpiSlaveHandle = (serial_spi_slave_state_t *)serialHandle;
|
|
|
|
|
|
|
|
serialSpiSlaveHandle->tx.callback = callback;
|
|
|
|
serialSpiSlaveHandle->tx.callbackParam = callbackParam;
|
|
|
|
|
|
|
|
return kStatus_SerialManager_Success;
|
|
|
|
}
|
|
|
|
|
|
|
|
serial_manager_status_t Serial_SpiSlaveInstallRxCallback(serial_handle_t serialHandle,
|
|
|
|
serial_manager_callback_t callback,
|
|
|
|
void *callbackParam)
|
|
|
|
{
|
|
|
|
serial_spi_slave_state_t *serialSpiSlaveHandle;
|
|
|
|
|
|
|
|
assert(serialHandle);
|
|
|
|
|
|
|
|
serialSpiSlaveHandle = (serial_spi_slave_state_t *)serialHandle;
|
|
|
|
|
|
|
|
serialSpiSlaveHandle->rx.callback = callback;
|
|
|
|
serialSpiSlaveHandle->rx.callbackParam = callbackParam;
|
|
|
|
|
|
|
|
return kStatus_SerialManager_Success;
|
|
|
|
}
|
|
|
|
|
|
|
|
serial_manager_status_t Serial_SpiMasterCancelWrite(serial_handle_t serialHandle)
|
|
|
|
{
|
|
|
|
serial_spi_master_state_t *serialSpiMaster;
|
|
|
|
|
|
|
|
assert(serialHandle);
|
|
|
|
|
|
|
|
serialSpiMaster = (serial_spi_master_state_t *)serialHandle;
|
|
|
|
|
|
|
|
if (kStatus_HAL_SpiSuccess !=
|
|
|
|
HAL_SpiMasterTransferAbort((hal_spi_master_handle_t)serialSpiMaster->spiMasterHandleBuffer))
|
|
|
|
|
|
|
|
{
|
|
|
|
return kStatus_SerialManager_Error;
|
|
|
|
}
|
|
|
|
|
|
|
|
return kStatus_SerialManager_Success;
|
|
|
|
}
|
|
|
|
|
|
|
|
serial_manager_status_t Serial_SpiSlaveCancelWrite(serial_handle_t serialHandle)
|
|
|
|
{
|
|
|
|
serial_spi_slave_state_t *serialSpiSlave;
|
|
|
|
|
|
|
|
assert(serialHandle);
|
|
|
|
|
|
|
|
serialSpiSlave = (serial_spi_slave_state_t *)serialHandle;
|
|
|
|
|
|
|
|
if (kStatus_HAL_SpiSuccess !=
|
|
|
|
HAL_SpiSlaveTransferAbort((hal_spi_slave_handle_t)serialSpiSlave->spiSlaveHandleBuffer))
|
|
|
|
|
|
|
|
{
|
|
|
|
return kStatus_SerialManager_Error;
|
|
|
|
}
|
|
|
|
|
|
|
|
return kStatus_SerialManager_Success;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|