Embedded_SDK
/
MCUXpresso_MIMXRT1052xxxxB
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
MCUXpresso_MIMXRT1052xxxxB/components/serial_manager/fsl_component_serial_port_s...

573 lines
21 KiB
C
Raw Permalink Blame History

/*
* 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);
}
#else /* SERIAL_MANAGER_NON_BLOCKING_MODE */
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;
mastetTransfer.txData = buffer;
mastetTransfer.rxData = NULL;
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);
serialSpiMasterHandle = (serial_spi_master_state_t *)serialHandle;
masterReceiver.txData = NULL;
masterReceiver.rxData = buffer;
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
Reference in New Issue View Git Blame Copy Permalink