Google Git
Sign in
coral / mcuxpresso_sdk / 20602c8dd7e6c22a33e76e7325f487e6858506c3 / . / devices / MIMX8MQ6 / cmsis_drivers / fsl_uart_cmsis.c
blob: 000c35daaf8727c14595622f92f534049a58eb61 [file] [log] [blame]
/*
* Copyright (c) 2013-2016 ARM Limited. All rights reserved.
* Copyright (c) 2016, Freescale Semiconductor, Inc. Not a Contribution.
* Copyright 2016-2017 NXP. Not a Contribution.
*
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the License); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an AS IS BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "fsl_uart_cmsis.h"
/* Component ID definition, used by tools. */
#ifndef FSL_COMPONENT_ID
#define FSL_COMPONENT_ID "platform.drivers.iuart_cmsis"
#endif
#if ((RTE_USART1 && defined(UART1)) || (RTE_USART2 && defined(UART2)) || (RTE_USART3 && defined(UART3)) || \
(RTE_USART4 && defined(UART4)))
#define ARM_UART_DRV_VERSION ARM_DRIVER_VERSION_MAJOR_MINOR(2, 0)
/*
* ARMCC does not support split the data section automatically, so the driver
* needs to split the data to separate sections explicitly, to reduce codesize.
*/
#if defined(__CC_ARM) || defined(__ARMCC_VERSION)
#define ARMCC_SECTION(section_name) __attribute__((section(section_name)))
#endif
typedef const struct _cmsis_uart_resource
{
UART_Type *base; /*!< UART peripheral base address. */
uint32_t (*GetFreq)(void); /*!< Function to get the clock frequency. */
} cmsis_uart_resource_t;
typedef struct _cmsis_uart_non_blocking_driver_state
{
cmsis_uart_resource_t *resource; /*!< Basic UART resource. */
uart_handle_t *handle; /*!< Interupt transfer handle. */
ARM_USART_SignalEvent_t cb_event; /*!< Callback function. */
uint8_t flags; /*!< Control and state flags. */
} cmsis_uart_non_blocking_driver_state_t;
#if (defined(FSL_FEATURE_SOC_SDMA_COUNT) && FSL_FEATURE_SOC_SDMA_COUNT)
typedef struct _cmsis_uart_sdma_resource
{
SDMAARM_Type *txSdmaBase; /*!< SDMA peripheral base address for TX. */
uint32_t txSdmaChannel; /*!< SDMA channel for UART TX. */
uint32_t txSdmaRequest; /*!< TX SDMA request source. */
uint32_t txSdmaPriority; /*!< TX SDMA channel priority. */
SDMAARM_Type *rxSdmaBase; /*!< SDMA peripheral base address for RX. */
uint32_t rxSdmaChannel; /*!< SDMA channel for UART RX. */
uint32_t rxSdmaRequest; /*!< RX SDMA request source. */
uint32_t rxSdmaPriority; /*!< RX SDMA channel priority. */
} cmsis_uart_sdma_resource_t;
typedef struct _cmsis_uart_sdma_driver_state
{
cmsis_uart_resource_t *resource; /*!< UART basic resource. */
cmsis_uart_sdma_resource_t *sdmaResource; /*!< UART SDMA resource. */
uart_sdma_handle_t *handle; /*!< UART SDMA transfer handle. */
sdma_handle_t *rxHandle; /*!< SDMA RX handle. */
sdma_handle_t *txHandle; /*!< SDMA TX handle. */
ARM_USART_SignalEvent_t cb_event; /*!< Callback function. */
uint8_t flags; /*!< Control and state flags. */
} cmsis_uart_sdma_driver_state_t;
#endif
enum _uart_transfer_states
{
kUART_TxIdle, /*!< TX idle. */
kUART_TxBusy, /*!< TX busy. */
kUART_RxIdle, /*!< RX idle. */
kUART_RxBusy /*!< RX busy. */
};
/* Driver Version */
static const ARM_DRIVER_VERSION s_uartDriverVersion = {ARM_USART_API_VERSION, ARM_UART_DRV_VERSION};
static const ARM_USART_CAPABILITIES s_uartDriverCapabilities = {
1, /* supports UART (Asynchronous) mode */
0, /* supports Synchronous Master mode */
0, /* supports Synchronous Slave mode */
0, /* supports UART Single-wire mode */
0, /* supports UART IrDA mode */
0, /* supports UART Smart Card mode */
0, /* Smart Card Clock generator */
0, /* RTS Flow Control available */
0, /* CTS Flow Control available */
0, /* Transmit completed event: \ref ARM_USART_EVENT_TX_COMPLETE */
0, /* Signal receive character timeout event: \ref ARM_USART_EVENT_RX_TIMEOUT */
0, /* RTS Line: 0=not available, 1=available */
0, /* CTS Line: 0=not available, 1=available */
0, /* DTR Line: 0=not available, 1=available */
0, /* DSR Line: 0=not available, 1=available */
0, /* DCD Line: 0=not available, 1=available */
0, /* RI Line: 0=not available, 1=available */
0, /* Signal CTS change event: \ref ARM_USART_EVENT_CTS */
0, /* Signal DSR change event: \ref ARM_USART_EVENT_DSR */
0, /* Signal DCD change event: \ref ARM_USART_EVENT_DCD */
0, /* Signal RI change event: \ref ARM_USART_EVENT_RI */
};
/*
* Common control function used by UART_NonBlockingControl/UART_DmaControl
*/
static int32_t UART_CommonControl(uint32_t control,
uint32_t arg,
cmsis_uart_resource_t *resource,
uint8_t *isConfigured)
{
uart_config_t config;
UART_GetDefaultConfig(&config);
switch (control & ARM_USART_CONTROL_Msk)
{
case ARM_USART_MODE_ASYNCHRONOUS:
/* USART Baudrate */
config.baudRate_Bps = arg;
break;
/* TX/RX IO is controlled in application layer. */
case ARM_USART_CONTROL_TX:
if (arg)
{
UART_EnableTx(resource->base, true);
}
else
{
UART_EnableTx(resource->base, false);
}
return ARM_DRIVER_OK;
case ARM_USART_CONTROL_RX:
if (arg)
{
UART_EnableRx(resource->base, true);
}
else
{
UART_EnableRx(resource->base, false);
}
return ARM_DRIVER_OK;
default:
return ARM_DRIVER_ERROR_UNSUPPORTED;
}
switch (control & ARM_USART_DATA_BITS_Msk)
{
case ARM_USART_DATA_BITS_7:
config.dataBitsCount = kUART_SevenDataBits;
break;
case ARM_USART_DATA_BITS_8:
config.dataBitsCount = kUART_EightDataBits;
break;
default:
return ARM_USART_ERROR_DATA_BITS;
}
switch (control & ARM_USART_PARITY_Msk)
{
case ARM_USART_PARITY_NONE:
config.parityMode = kUART_ParityDisabled;
break;
case ARM_USART_PARITY_EVEN:
config.parityMode = kUART_ParityEven;
break;
case ARM_USART_PARITY_ODD:
config.parityMode = kUART_ParityOdd;
break;
default:
return ARM_USART_ERROR_PARITY;
}
switch (control & ARM_USART_STOP_BITS_Msk)
{
case ARM_USART_STOP_BITS_1:
/* The GetDefaultConfig has already set for this case. */
break;
case ARM_USART_STOP_BITS_2:
config.stopBitCount = kUART_TwoStopBit;
break;
default:
return ARM_USART_ERROR_STOP_BITS;
}
/* If UART is already configured, deinit it first. */
if ((*isConfigured) & USART_FLAG_CONFIGURED)
{
UART_Deinit(resource->base);
*isConfigured &= ~USART_FLAG_CONFIGURED;
}
config.enableTx = true;
config.enableRx = true;
if (kStatus_UART_BaudrateNotSupport == UART_Init(resource->base, &config, resource->GetFreq()))
{
return ARM_USART_ERROR_BAUDRATE;
}
*isConfigured |= USART_FLAG_CONFIGURED;
return ARM_DRIVER_OK;
}
static ARM_DRIVER_VERSION UARTx_GetVersion(void)
{
return s_uartDriverVersion;
}
static ARM_USART_CAPABILITIES UARTx_GetCapabilities(void)
{
return s_uartDriverCapabilities;
}
static int32_t UARTx_SetModemControl(ARM_USART_MODEM_CONTROL control)
{
return ARM_DRIVER_ERROR_UNSUPPORTED;
}
static ARM_USART_MODEM_STATUS UARTx_GetModemStatus(void)
{
ARM_USART_MODEM_STATUS modem_status;
modem_status.cts = 0U;
modem_status.dsr = 0U;
modem_status.ri = 0U;
modem_status.dcd = 0U;
modem_status.reserved = 0U;
return modem_status;
}
#endif
#if ((RTE_USART1_DMA_EN && defined(UART1)) || (RTE_USART2_DMA_EN && defined(UART2)) || \
(RTE_USART3_DMA_EN && defined(UART3)) || (RTE_USART4_DMA_EN && defined(UART4)) || \
(RTE_USART5_DMA_EN && defined(UART5)))
void KSDK_UART_SdmaCallback(UART_Type *base, uart_sdma_handle_t *handle, status_t status, void *userData)
{
uint32_t event = 0U;
if (kStatus_UART_TxIdle == status)
{
event = ARM_USART_EVENT_SEND_COMPLETE;
}
else if (kStatus_UART_RxIdle == status)
{
event = ARM_USART_EVENT_RECEIVE_COMPLETE;
}
/* User data is actually CMSIS driver callback. */
if ((0U != event) && (userData))
{
((ARM_USART_SignalEvent_t)userData)(event);
}
}
static int32_t UART_SdmaInitialize(ARM_USART_SignalEvent_t cb_event, cmsis_uart_sdma_driver_state_t *uart)
{
if (!(uart->flags & USART_FLAG_INIT))
{
uart->cb_event = cb_event;
uart->flags = USART_FLAG_INIT;
}
return ARM_DRIVER_OK;
}
static int32_t UART_SdmaUninitialize(cmsis_uart_sdma_driver_state_t *uart)
{
uart->flags = USART_FLAG_UNINIT;
return ARM_DRIVER_OK;
}
static int32_t UART_SdmaPowerControl(ARM_POWER_STATE state,
cmsis_uart_sdma_driver_state_t *uart,
sdma_context_data_t *rxContext,
sdma_context_data_t *txContext)
{
status_t status;
uart_config_t config;
switch (state)
{
case ARM_POWER_OFF:
if (uart->flags & USART_FLAG_POWER)
{
UART_Deinit(uart->resource->base);
uart->flags = USART_FLAG_INIT;
}
break;
case ARM_POWER_LOW:
return ARM_DRIVER_ERROR_UNSUPPORTED;
case ARM_POWER_FULL:
/* Must be initialized first. */
if (uart->flags == USART_FLAG_UNINIT)
{
return ARM_DRIVER_ERROR;
}
if (uart->flags & USART_FLAG_POWER)
{
/* Driver already powered */
break;
}
UART_GetDefaultConfig(&config);
config.enableTx = true;
config.enableRx = true;
/* Set up DMA setting. */
SDMA_CreateHandle(uart->txHandle, uart->sdmaResource->txSdmaBase, uart->sdmaResource->txSdmaChannel,
txContext);
SDMA_CreateHandle(uart->rxHandle, uart->sdmaResource->rxSdmaBase, uart->sdmaResource->rxSdmaChannel,
rxContext);
SDMA_SetChannelPriority(uart->sdmaResource->txSdmaBase, uart->sdmaResource->txSdmaChannel,
uart->sdmaResource->txSdmaPriority);
SDMA_SetChannelPriority(uart->sdmaResource->rxSdmaBase, uart->sdmaResource->rxSdmaChannel,
uart->sdmaResource->rxSdmaPriority);
/* Setup the UART. */
status = UART_Init(uart->resource->base, &config, uart->resource->GetFreq());
if (kStatus_Success != status)
{
return kStatus_Fail;
}
/* Create UART SDMA handle. */
UART_TransferCreateHandleSDMA(uart->resource->base, uart->handle, KSDK_UART_SdmaCallback,
(void *)uart->cb_event, uart->txHandle, uart->rxHandle,
uart->sdmaResource->txSdmaRequest, uart->sdmaResource->rxSdmaRequest);
uart->flags |= (USART_FLAG_POWER | USART_FLAG_CONFIGURED);
break;
default:
return ARM_DRIVER_ERROR_UNSUPPORTED;
}
return ARM_DRIVER_OK;
}
static int32_t UART_SdmaSend(const void *data, uint32_t num, cmsis_uart_sdma_driver_state_t *uart)
{
int32_t ret;
status_t status;
uart_transfer_t xfer;
xfer.data = (uint8_t *)data;
xfer.dataSize = num;
status = UART_SendSDMA(uart->resource->base, uart->handle, &xfer);
switch (status)
{
case kStatus_Success:
ret = ARM_DRIVER_OK;
break;
case kStatus_InvalidArgument:
ret = ARM_DRIVER_ERROR_PARAMETER;
break;
case kStatus_UART_RxBusy:
ret = ARM_DRIVER_ERROR_BUSY;
break;
default:
ret = ARM_DRIVER_ERROR;
break;
}
return ret;
}
static int32_t UART_SdmaReceive(void *data, uint32_t num, cmsis_uart_sdma_driver_state_t *uart)
{
int32_t ret;
status_t status;
uart_transfer_t xfer;
xfer.data = data;
xfer.dataSize = num;
status = UART_ReceiveSDMA(uart->resource->base, uart->handle, &xfer);
switch (status)
{
case kStatus_Success:
ret = ARM_DRIVER_OK;
break;
case kStatus_InvalidArgument:
ret = ARM_DRIVER_ERROR_PARAMETER;
break;
case kStatus_UART_TxBusy:
ret = ARM_DRIVER_ERROR_BUSY;
break;
default:
ret = ARM_DRIVER_ERROR;
break;
}
return ret;
}
static int32_t UART_SdmaTransfer(const void *data_out,
void *data_in,
uint32_t num,
cmsis_uart_sdma_driver_state_t *uart)
{
/* Only in synchronous mode */
return ARM_DRIVER_ERROR;
}
static uint32_t UART_SdmaGetTxCount(cmsis_uart_sdma_driver_state_t *uart)
{
/* Not supported by current driver. */
return 0;
}
static uint32_t UART_SdmaGetRxCount(cmsis_uart_sdma_driver_state_t *uart)
{
/* Not supported by current driver. */
return 0;
}
static int32_t UART_SdmaControl(uint32_t control, uint32_t arg, cmsis_uart_sdma_driver_state_t *uart)
{
/* Must be power on. */
if (!(uart->flags & USART_FLAG_POWER))
{
return ARM_DRIVER_ERROR;
}
/* Does not support these features. */
if (control & (ARM_USART_FLOW_CONTROL_Msk | ARM_USART_CPOL_Msk | ARM_USART_CPHA_Msk))
{
return ARM_DRIVER_ERROR_UNSUPPORTED;
}
switch (control & ARM_USART_CONTROL_Msk)
{
/* Abort Send */
case ARM_USART_ABORT_SEND:
UART_TransferAbortSendSDMA(uart->resource->base, uart->handle);
return ARM_DRIVER_OK;
/* Abort receive */
case ARM_USART_ABORT_RECEIVE:
UART_TransferAbortReceiveSDMA(uart->resource->base, uart->handle);
return ARM_DRIVER_OK;
default:
break;
}
return UART_CommonControl(control, arg, uart->resource, &uart->flags);
}
static ARM_USART_STATUS UART_SdmaGetStatus(cmsis_uart_sdma_driver_state_t *uart)
{
ARM_USART_STATUS stat;
stat.tx_busy = ((kUART_TxBusy == uart->handle->txState) ? (1U) : (0U));
stat.rx_busy = ((kUART_RxBusy == uart->handle->rxState) ? (1U) : (0U));
stat.tx_underflow = 0U;
stat.rx_overflow = UART_GetStatusFlag(uart->resource->base, kUART_RxOverrunFlag);
stat.rx_break = UART_GetStatusFlag(uart->resource->base, kUART_BreakDetectFlag);
stat.rx_framing_error = UART_GetStatusFlag(uart->resource->base, kUART_FrameErrorFlag);
stat.rx_parity_error = UART_GetStatusFlag(uart->resource->base, kUART_ParityErrorFlag);
stat.reserved = 0U;
return stat;
}
#endif
#if (((RTE_USART1 && !RTE_USART1_DMA_EN) && defined(UART1)) || \
((RTE_USART2 && !RTE_USART2_DMA_EN) && defined(UART2)) || \
((RTE_USART3 && !RTE_USART3_DMA_EN) && defined(UART3)) || ((RTE_USART4 && !RTE_USART4_DMA_EN) && defined(UART4)))
void KSDK_UART_NonBlockingCallback(UART_Type *base, uart_handle_t *handle, status_t status, void *userData)
{
uint32_t event = 0U;
if (kStatus_UART_TxIdle == status)
{
event = ARM_USART_EVENT_SEND_COMPLETE;
}
if (kStatus_UART_RxIdle == status)
{
event = ARM_USART_EVENT_RECEIVE_COMPLETE;
}
if (kStatus_UART_RxHardwareOverrun == status)
{
event = ARM_USART_EVENT_RX_OVERFLOW;
}
/* User data is actually CMSIS driver callback. */
if ((0U != event) && (userData))
{
((ARM_USART_SignalEvent_t)userData)(event);
}
}
static int32_t UART_NonBlockingInitialize(ARM_USART_SignalEvent_t cb_event,
cmsis_uart_non_blocking_driver_state_t *uart)
{
if (!(uart->flags & USART_FLAG_INIT))
{
uart->cb_event = cb_event;
uart->flags = USART_FLAG_INIT;
}
return ARM_DRIVER_OK;
}
static int32_t UART_NonBlockingUninitialize(cmsis_uart_non_blocking_driver_state_t *uart)
{
uart->flags = USART_FLAG_UNINIT;
return ARM_DRIVER_OK;
}
static int32_t UART_NonBlockingPowerControl(ARM_POWER_STATE state, cmsis_uart_non_blocking_driver_state_t *uart)
{
status_t status;
uart_config_t config;
switch (state)
{
case ARM_POWER_OFF:
if (uart->flags & USART_FLAG_POWER)
{
UART_Deinit(uart->resource->base);
uart->flags = USART_FLAG_INIT;
}
break;
case ARM_POWER_LOW:
return ARM_DRIVER_ERROR_UNSUPPORTED;
case ARM_POWER_FULL:
/* Must be initialized first. */
if (uart->flags == USART_FLAG_UNINIT)
{
return ARM_DRIVER_ERROR;
}
if (uart->flags & USART_FLAG_POWER)
{
/* Driver already powered */
break;
}
UART_GetDefaultConfig(&config);
config.enableTx = true;
config.enableRx = true;
status = UART_Init(uart->resource->base, &config, uart->resource->GetFreq());
if (kStatus_Success != status)
{
return kStatus_Fail;
}
UART_TransferCreateHandle(uart->resource->base, uart->handle, KSDK_UART_NonBlockingCallback,
(void *)uart->cb_event);
uart->flags |= (USART_FLAG_POWER | USART_FLAG_CONFIGURED);
break;
default:
return ARM_DRIVER_ERROR_UNSUPPORTED;
}
return ARM_DRIVER_OK;
}
static int32_t UART_NonBlockingSend(const void *data, uint32_t num, cmsis_uart_non_blocking_driver_state_t *uart)
{
int32_t ret;
status_t status;
uart_transfer_t xfer;
xfer.data = (uint8_t *)data;
xfer.dataSize = num;
status = UART_TransferSendNonBlocking(uart->resource->base, uart->handle, &xfer);
switch (status)
{
case kStatus_Success:
ret = ARM_DRIVER_OK;
break;
case kStatus_InvalidArgument:
ret = ARM_DRIVER_ERROR_PARAMETER;
break;
case kStatus_UART_RxBusy:
ret = ARM_DRIVER_ERROR_BUSY;
break;
default:
ret = ARM_DRIVER_ERROR;
break;
}
return ret;
}
static int32_t UART_NonBlockingReceive(void *data, uint32_t num, cmsis_uart_non_blocking_driver_state_t *uart)
{
int32_t ret;
status_t status;
uart_transfer_t xfer;
xfer.data = data;
xfer.dataSize = num;
status = UART_TransferReceiveNonBlocking(uart->resource->base, uart->handle, &xfer, NULL);
switch (status)
{
case kStatus_Success:
ret = ARM_DRIVER_OK;
break;
case kStatus_InvalidArgument:
ret = ARM_DRIVER_ERROR_PARAMETER;
break;
case kStatus_UART_TxBusy:
ret = ARM_DRIVER_ERROR_BUSY;
break;
default:
ret = ARM_DRIVER_ERROR;
break;
}
return ret;
}
static int32_t UART_NonBlockingTransfer(const void *data_out,
void *data_in,
uint32_t num,
cmsis_uart_non_blocking_driver_state_t *uart)
{
/* Only in synchronous mode */
return ARM_DRIVER_ERROR;
}
static uint32_t UART_NonBlockingGetTxCount(cmsis_uart_non_blocking_driver_state_t *uart)
{
uint32_t cnt;
/* If TX not in progress, then the TX count is txDataSizeAll saved in handle. */
if (kStatus_NoTransferInProgress == UART_TransferGetSendCount(uart->resource->base, uart->handle, &cnt))
{
cnt = uart->handle->txDataSizeAll;
}
return cnt;
}
static uint32_t UART_NonBlockingGetRxCount(cmsis_uart_non_blocking_driver_state_t *uart)
{
uint32_t cnt;
if (kStatus_NoTransferInProgress == UART_TransferGetReceiveCount(uart->resource->base, uart->handle, &cnt))
{
cnt = uart->handle->rxDataSizeAll;
}
return cnt;
}
static int32_t UART_NonBlockingControl(uint32_t control, uint32_t arg, cmsis_uart_non_blocking_driver_state_t *uart)
{
/* Must be power on. */
if (!(uart->flags & USART_FLAG_POWER))
{
return ARM_DRIVER_ERROR;
}
/* Does not support these features. */
if (control & (ARM_USART_FLOW_CONTROL_Msk | ARM_USART_CPOL_Msk | ARM_USART_CPHA_Msk))
{
return ARM_DRIVER_ERROR_UNSUPPORTED;
}
switch (control & ARM_USART_CONTROL_Msk)
{
/* Abort Send */
case ARM_USART_ABORT_SEND:
UART_TransferAbortSend(uart->resource->base, uart->handle);
return ARM_DRIVER_OK;
/* Abort receive */
case ARM_USART_ABORT_RECEIVE:
UART_TransferAbortReceive(uart->resource->base, uart->handle);
return ARM_DRIVER_OK;
default:
break;
}
return UART_CommonControl(control, arg, uart->resource, &uart->flags);
}
static ARM_USART_STATUS UART_NonBlockingGetStatus(cmsis_uart_non_blocking_driver_state_t *uart)
{
ARM_USART_STATUS stat;
stat.tx_busy = ((kUART_TxBusy == uart->handle->txState) ? (1U) : (0U));
stat.rx_busy = ((kUART_RxBusy == uart->handle->rxState) ? (1U) : (0U));
stat.tx_underflow = 0U;
stat.rx_overflow = UART_GetStatusFlag(uart->resource->base, kUART_RxOverrunFlag);
stat.rx_break = UART_GetStatusFlag(uart->resource->base, kUART_BreakDetectFlag);
stat.rx_framing_error = UART_GetStatusFlag(uart->resource->base, kUART_FrameErrorFlag);
stat.rx_parity_error = UART_GetStatusFlag(uart->resource->base, kUART_ParityErrorFlag);
stat.reserved = 0U;
return stat;
}
#endif
#if defined(UART1) && RTE_USART1
/* User needs to provide the implementation for UART1_GetFreq/InitPins/DeinitPins
* in the application for enabling according instance.
*/
extern uint32_t UART1_GetFreq(void);
extern void UART1_InitPins(void);
extern void UART1_DeinitPins(void);
cmsis_uart_resource_t UART1_Resource = {UART1, UART1_GetFreq};
#if RTE_USART1_DMA_EN
cmsis_uart_sdma_resource_t UART1_SdmaResource = {
RTE_USART1_SDMA_TX_DMA_BASE, RTE_USART1_SDMA_TX_CH, RTE_USART1_SDMA_TX_REQUEST, RTE_USART1_SDMA_TX_PRIORITY,
RTE_USART1_SDMA_RX_DMA_BASE, RTE_USART1_SDMA_RX_CH, RTE_USART1_SDMA_RX_REQUEST, RTE_USART1_SDMA_RX_PRIORITY,
};
AT_NONCACHEABLE_SECTION_ALIGN(uart_sdma_handle_t UART1_SdmaHandle, 4);
AT_NONCACHEABLE_SECTION_ALIGN(sdma_handle_t UART1_SdmaTxHandle, 4);
AT_NONCACHEABLE_SECTION_ALIGN(sdma_handle_t UART1_SdmaRxHandle, 4);
AT_NONCACHEABLE_SECTION_ALIGN(sdma_context_data_t UART1_SdmaTxContext, 4);
AT_NONCACHEABLE_SECTION_ALIGN(sdma_context_data_t UART1_SdmaRxContext, 4);
#if defined(__CC_ARM) || defined(__ARMCC_VERSION)
ARMCC_SECTION("uart1_sdma_driver_state")
cmsis_uart_sdma_driver_state_t UART1_SdmaDriverState = {
#else
cmsis_uart_sdma_driver_state_t UART1_SdmaDriverState = {
#endif
&UART1_Resource, &UART1_SdmaResource, &UART1_SdmaHandle, &UART1_SdmaRxHandle, &UART1_SdmaTxHandle,
};
static int32_t UART1_SdmaInitialize(ARM_USART_SignalEvent_t cb_event)
{
UART1_InitPins();
return UART_SdmaInitialize(cb_event, &UART1_SdmaDriverState);
}
static int32_t UART1_SdmaUninitialize(void)
{
UART1_DeinitPins();
return UART_SdmaUninitialize(&UART1_SdmaDriverState);
}
static int32_t UART1_SdmaPowerControl(ARM_POWER_STATE state)
{
return UART_SdmaPowerControl(state, &UART1_SdmaDriverState, &UART1_SdmaRxContext, &UART1_SdmaTxContext);
}
static int32_t UART1_SdmaSend(const void *data, uint32_t num)
{
return UART_SdmaSend(data, num, &UART1_SdmaDriverState);
}
static int32_t UART1_SdmaReceive(void *data, uint32_t num)
{
return UART_SdmaReceive(data, num, &UART1_SdmaDriverState);
}
static int32_t UART1_SdmaTransfer(const void *data_out, void *data_in, uint32_t num)
{
return UART_SdmaTransfer(data_out, data_in, num, &UART1_SdmaDriverState);
}
static uint32_t UART1_SdmaGetTxCount(void)
{
return UART_SdmaGetTxCount(&UART1_SdmaDriverState);
}
static uint32_t UART1_SdmaGetRxCount(void)
{
return UART_SdmaGetRxCount(&UART1_SdmaDriverState);
}
static int32_t UART1_SdmaControl(uint32_t control, uint32_t arg)
{
return UART_SdmaControl(control, arg, &UART1_SdmaDriverState);
}
static ARM_USART_STATUS UART1_SdmaGetStatus(void)
{
return UART_SdmaGetStatus(&UART1_SdmaDriverState);
}
#else
uart_handle_t UART1_Handle;
#if defined(USART1_RX_BUFFER_ENABLE) && (USART1_RX_BUFFER_ENABLE == 1)
static uint8_t uart1_rxRingBuffer[USART_RX_BUFFER_LEN];
#endif
#if defined(__CC_ARM) || defined(__ARMCC_VERSION)
ARMCC_SECTION("uart1_non_blocking_driver_state")
cmsis_uart_non_blocking_driver_state_t UART1_NonBlockingDriverState = {
#else
cmsis_uart_non_blocking_driver_state_t UART1_NonBlockingDriverState = {
#endif
&UART1_Resource,
&UART1_Handle,
};
static int32_t UART1_NonBlockingInitialize(ARM_USART_SignalEvent_t cb_event)
{
UART1_InitPins();
return UART_NonBlockingInitialize(cb_event, &UART1_NonBlockingDriverState);
}
static int32_t UART1_NonBlockingUninitialize(void)
{
UART1_DeinitPins();
return UART_NonBlockingUninitialize(&UART1_NonBlockingDriverState);
}
static int32_t UART1_NonBlockingPowerControl(ARM_POWER_STATE state)
{
uint32_t result;
result = UART_NonBlockingPowerControl(state, &UART1_NonBlockingDriverState);
#if defined(USART1_RX_BUFFER_ENABLE) && (USART1_RX_BUFFER_ENABLE == 1)
if ((state == ARM_POWER_FULL) && (UART1_NonBlockingDriverState.handle->rxRingBuffer == NULL))
{
UART_TransferStartRingBuffer(UART1_NonBlockingDriverState.resource->base, UART1_NonBlockingDriverState.handle,
uart1_rxRingBuffer, USART_RX_BUFFER_LEN);
}
#endif
return result;
}
static int32_t UART1_NonBlockingSend(const void *data, uint32_t num)
{
return UART_NonBlockingSend(data, num, &UART1_NonBlockingDriverState);
}
static int32_t UART1_NonBlockingReceive(void *data, uint32_t num)
{
return UART_NonBlockingReceive(data, num, &UART1_NonBlockingDriverState);
}
static int32_t UART1_NonBlockingTransfer(const void *data_out, void *data_in, uint32_t num)
{
return UART_NonBlockingTransfer(data_out, data_in, num, &UART1_NonBlockingDriverState);
}
static uint32_t UART1_NonBlockingGetTxCount(void)
{
return UART_NonBlockingGetTxCount(&UART1_NonBlockingDriverState);
}
static uint32_t UART1_NonBlockingGetRxCount(void)
{
return UART_NonBlockingGetRxCount(&UART1_NonBlockingDriverState);
}
static int32_t UART1_NonBlockingControl(uint32_t control, uint32_t arg)
{
int32_t result;
result = UART_NonBlockingControl(control, arg, &UART1_NonBlockingDriverState);
if (ARM_DRIVER_OK != result)
{
return result;
}
/* Enable the receive interrupts if ring buffer is used */
if (UART1_NonBlockingDriverState.handle->rxRingBuffer != NULL)
{
UART_EnableInterrupts(UART1_NonBlockingDriverState.resource->base,
(kUART_RxReadyEnable | kUART_AgingTimerEnable | kUART_RxOverrunEnable |
kUART_ParityErrorEnable | kUART_FrameErrorEnable));
}
return ARM_DRIVER_OK;
}
static ARM_USART_STATUS UART1_NonBlockingGetStatus(void)
{
return UART_NonBlockingGetStatus(&UART1_NonBlockingDriverState);
}
#endif
ARM_DRIVER_USART Driver_USART1 = {
UARTx_GetVersion, UARTx_GetCapabilities,
#if RTE_USART1_DMA_EN
UART1_SdmaInitialize, UART1_SdmaUninitialize, UART1_SdmaPowerControl, UART1_SdmaSend, UART1_SdmaReceive,
UART1_SdmaTransfer, UART1_SdmaGetTxCount, UART1_SdmaGetRxCount, UART1_SdmaControl, UART1_SdmaGetStatus,
#else
UART1_NonBlockingInitialize,
UART1_NonBlockingUninitialize,
UART1_NonBlockingPowerControl,
UART1_NonBlockingSend,
UART1_NonBlockingReceive,
UART1_NonBlockingTransfer,
UART1_NonBlockingGetTxCount,
UART1_NonBlockingGetRxCount,
UART1_NonBlockingControl,
UART1_NonBlockingGetStatus,
#endif
UARTx_SetModemControl, UARTx_GetModemStatus};
#endif /* UART1 */
#if defined(UART2) && RTE_USART2
/* User needs to provide the implementation for UART2_GetFreq/InitPins/DeinitPins
* in the application for enabling according instance.
*/
extern uint32_t UART2_GetFreq(void);
extern void UART2_InitPins(void);
extern void UART2_DeinitPins(void);
cmsis_uart_resource_t UART2_Resource = {UART2, UART2_GetFreq};
#if RTE_USART2_DMA_EN
cmsis_uart_sdma_resource_t UART2_SdmaResource = {
RTE_USART2_SDMA_TX_DMA_BASE, RTE_USART2_SDMA_TX_CH, RTE_USART2_SDMA_TX_REQUEST, RTE_USART2_SDMA_TX_PRIORITY,
RTE_USART2_SDMA_RX_DMA_BASE, RTE_USART2_SDMA_RX_CH, RTE_USART2_SDMA_RX_REQUEST, RTE_USART2_SDMA_RX_PRIORITY,
};
AT_NONCACHEABLE_SECTION_ALIGN(uart_sdma_handle_t UART2_SdmaHandle, 4);
AT_NONCACHEABLE_SECTION_ALIGN(sdma_handle_t UART2_SdmaTxHandle, 4);
AT_NONCACHEABLE_SECTION_ALIGN(sdma_handle_t UART2_SdmaRxHandle, 4);
AT_NONCACHEABLE_SECTION_ALIGN(sdma_context_data_t UART2_SdmaTxContext, 4);
AT_NONCACHEABLE_SECTION_ALIGN(sdma_context_data_t UART2_SdmaRxContext, 4);
#if defined(__CC_ARM) || defined(__ARMCC_VERSION)
ARMCC_SECTION("uart2_sdma_driver_state")
cmsis_uart_sdma_driver_state_t UART2_SdmaDriverState = {
#else
cmsis_uart_sdma_driver_state_t UART2_SdmaDriverState = {
#endif
&UART2_Resource, &UART2_SdmaResource, &UART2_SdmaHandle, &UART2_SdmaRxHandle, &UART2_SdmaTxHandle,
};
static int32_t UART2_SdmaInitialize(ARM_USART_SignalEvent_t cb_event)
{
UART2_InitPins();
return UART_SdmaInitialize(cb_event, &UART2_SdmaDriverState);
}
static int32_t UART2_SdmaUninitialize(void)
{
UART2_DeinitPins();
return UART_SdmaUninitialize(&UART2_SdmaDriverState);
}
static int32_t UART2_SdmaPowerControl(ARM_POWER_STATE state)
{
return UART_SdmaPowerControl(state, &UART2_SdmaDriverState, &UART2_SdmaRxContext, &UART2_SdmaTxContext);
}
static int32_t UART2_SdmaSend(const void *data, uint32_t num)
{
return UART_SdmaSend(data, num, &UART2_SdmaDriverState);
}
static int32_t UART2_SdmaReceive(void *data, uint32_t num)
{
return UART_SdmaReceive(data, num, &UART2_SdmaDriverState);
}
static int32_t UART2_SdmaTransfer(const void *data_out, void *data_in, uint32_t num)
{
return UART_SdmaTransfer(data_out, data_in, num, &UART2_SdmaDriverState);
}
static uint32_t UART2_SdmaGetTxCount(void)
{
return UART_SdmaGetTxCount(&UART2_SdmaDriverState);
}
static uint32_t UART2_SdmaGetRxCount(void)
{
return UART_SdmaGetRxCount(&UART2_SdmaDriverState);
}
static int32_t UART2_SdmaControl(uint32_t control, uint32_t arg)
{
return UART_SdmaControl(control, arg, &UART2_SdmaDriverState);
}
static ARM_USART_STATUS UART2_SdmaGetStatus(void)
{
return UART_SdmaGetStatus(&UART2_SdmaDriverState);
}
#else
uart_handle_t UART2_Handle;
#if defined(USART2_RX_BUFFER_ENABLE) && (USART2_RX_BUFFER_ENABLE == 1)
static uint8_t uart2_rxRingBuffer[USART_RX_BUFFER_LEN];
#endif
#if defined(__CC_ARM) || defined(__ARMCC_VERSION)
ARMCC_SECTION("uart2_non_blocking_driver_state")
cmsis_uart_non_blocking_driver_state_t UART2_NonBlockingDriverState = {
#else
cmsis_uart_non_blocking_driver_state_t UART2_NonBlockingDriverState = {
#endif
&UART2_Resource,
&UART2_Handle,
};
static int32_t UART2_NonBlockingInitialize(ARM_USART_SignalEvent_t cb_event)
{
UART2_InitPins();
return UART_NonBlockingInitialize(cb_event, &UART2_NonBlockingDriverState);
}
static int32_t UART2_NonBlockingUninitialize(void)
{
UART2_DeinitPins();
return UART_NonBlockingUninitialize(&UART2_NonBlockingDriverState);
}
static int32_t UART2_NonBlockingPowerControl(ARM_POWER_STATE state)
{
uint32_t result;
result = UART_NonBlockingPowerControl(state, &UART2_NonBlockingDriverState);
#if defined(USART2_RX_BUFFER_ENABLE) && (USART2_RX_BUFFER_ENABLE == 1)
if ((state == ARM_POWER_FULL) && (UART2_NonBlockingDriverState.handle->rxRingBuffer == NULL))
{
UART_TransferStartRingBuffer(UART2_NonBlockingDriverState.resource->base, UART2_NonBlockingDriverState.handle,
uart2_rxRingBuffer, USART_RX_BUFFER_LEN);
}
#endif
return result;
}
static int32_t UART2_NonBlockingSend(const void *data, uint32_t num)
{
return UART_NonBlockingSend(data, num, &UART2_NonBlockingDriverState);
}
static int32_t UART2_NonBlockingReceive(void *data, uint32_t num)
{
return UART_NonBlockingReceive(data, num, &UART2_NonBlockingDriverState);
}
static int32_t UART2_NonBlockingTransfer(const void *data_out, void *data_in, uint32_t num)
{
return UART_NonBlockingTransfer(data_out, data_in, num, &UART2_NonBlockingDriverState);
}
static uint32_t UART2_NonBlockingGetTxCount(void)
{
return UART_NonBlockingGetTxCount(&UART2_NonBlockingDriverState);
}
static uint32_t UART2_NonBlockingGetRxCount(void)
{
return UART_NonBlockingGetRxCount(&UART2_NonBlockingDriverState);
}
static int32_t UART2_NonBlockingControl(uint32_t control, uint32_t arg)
{
int32_t result;
result = UART_NonBlockingControl(control, arg, &UART2_NonBlockingDriverState);
if (ARM_DRIVER_OK != result)
{
return result;
}
/* Enable the receive interrupts if ring buffer is used */
if (UART2_NonBlockingDriverState.handle->rxRingBuffer != NULL)
{
UART_EnableInterrupts(UART2_NonBlockingDriverState.resource->base,
(kUART_RxReadyEnable | kUART_AgingTimerEnable | kUART_RxOverrunEnable |
kUART_ParityErrorEnable | kUART_FrameErrorEnable));
}
return ARM_DRIVER_OK;
}
static ARM_USART_STATUS UART2_NonBlockingGetStatus(void)
{
return UART_NonBlockingGetStatus(&UART2_NonBlockingDriverState);
}
#endif
ARM_DRIVER_USART Driver_USART2 = {
UARTx_GetVersion, UARTx_GetCapabilities,
#if RTE_USART2_DMA_EN
UART2_SdmaInitialize, UART2_SdmaUninitialize, UART2_SdmaPowerControl, UART2_SdmaSend, UART2_SdmaReceive,
UART2_SdmaTransfer, UART2_SdmaGetTxCount, UART2_SdmaGetRxCount, UART2_SdmaControl, UART2_SdmaGetStatus,
#else
UART2_NonBlockingInitialize,
UART2_NonBlockingUninitialize,
UART2_NonBlockingPowerControl,
UART2_NonBlockingSend,
UART2_NonBlockingReceive,
UART2_NonBlockingTransfer,
UART2_NonBlockingGetTxCount,
UART2_NonBlockingGetRxCount,
UART2_NonBlockingControl,
UART2_NonBlockingGetStatus,
#endif
UARTx_SetModemControl, UARTx_GetModemStatus};
#endif /* UART2 */
#if defined(UART3) && RTE_USART3
/* User needs to provide the implementation for UART3_GetFreq/InitPins/DeinitPins
* in the application for enabling according instance.
*/
extern uint32_t UART3_GetFreq(void);
extern void UART3_InitPins(void);
extern void UART3_DeinitPins(void);
cmsis_uart_resource_t UART3_Resource = {UART3, UART3_GetFreq};
#if RTE_USART3_DMA_EN
cmsis_uart_sdma_resource_t UART3_SdmaResource = {
RTE_USART3_SDMA_TX_DMA_BASE, RTE_USART3_SDMA_TX_CH, RTE_USART3_SDMA_TX_REQUEST, RTE_USART3_SDMA_TX_PRIORITY,
RTE_USART3_SDMA_RX_DMA_BASE, RTE_USART3_SDMA_RX_CH, RTE_USART3_SDMA_RX_REQUEST, RTE_USART3_SDMA_RX_PRIORITY,
};
AT_NONCACHEABLE_SECTION_ALIGN(uart_sdma_handle_t UART3_SdmaHandle, 4);
AT_NONCACHEABLE_SECTION_ALIGN(sdma_handle_t UART3_SdmaTxHandle, 4);
AT_NONCACHEABLE_SECTION_ALIGN(sdma_handle_t UART3_SdmaRxHandle, 4);
AT_NONCACHEABLE_SECTION_ALIGN(sdma_context_data_t UART3_SdmaTxContext, 4);
AT_NONCACHEABLE_SECTION_ALIGN(sdma_context_data_t UART3_SdmaRxContext, 4);
#if defined(__CC_ARM) || defined(__ARMCC_VERSION)
ARMCC_SECTION("uart3_sdma_driver_state")
cmsis_uart_sdma_driver_state_t UART3_SdmaDriverState = {
#else
cmsis_uart_sdma_driver_state_t UART3_SdmaDriverState = {
#endif
&UART3_Resource, &UART3_SdmaResource, &UART3_SdmaHandle, &UART3_SdmaRxHandle, &UART3_SdmaTxHandle,
};
static int32_t UART3_SdmaInitialize(ARM_USART_SignalEvent_t cb_event)
{
UART3_InitPins();
return UART_SdmaInitialize(cb_event, &UART3_SdmaDriverState);
}
static int32_t UART3_SdmaUninitialize(void)
{
UART3_DeinitPins();
return UART_SdmaUninitialize(&UART3_SdmaDriverState);
}
static int32_t UART3_SdmaPowerControl(ARM_POWER_STATE state)
{
return UART_SdmaPowerControl(state, &UART3_SdmaDriverState, &UART3_SdmaRxContext, &UART3_SdmaTxContext);
}
static int32_t UART3_SdmaSend(const void *data, uint32_t num)
{
return UART_SdmaSend(data, num, &UART3_SdmaDriverState);
}
static int32_t UART3_SdmaReceive(void *data, uint32_t num)
{
return UART_SdmaReceive(data, num, &UART3_SdmaDriverState);
}
static int32_t UART3_SdmaTransfer(const void *data_out, void *data_in, uint32_t num)
{
return UART_SdmaTransfer(data_out, data_in, num, &UART3_SdmaDriverState);
}
static uint32_t UART3_SdmaGetTxCount(void)
{
return UART_SdmaGetTxCount(&UART3_SdmaDriverState);
}
static uint32_t UART3_SdmaGetRxCount(void)
{
return UART_SdmaGetRxCount(&UART3_SdmaDriverState);
}
static int32_t UART3_SdmaControl(uint32_t control, uint32_t arg)
{
return UART_SdmaControl(control, arg, &UART3_SdmaDriverState);
}
static ARM_USART_STATUS UART3_SdmaGetStatus(void)
{
return UART_SdmaGetStatus(&UART3_SdmaDriverState);
}
#else
uart_handle_t UART3_Handle;
#if defined(USART3_RX_BUFFER_ENABLE) && (USART3_RX_BUFFER_ENABLE == 1)
static uint8_t uart3_rxRingBuffer[USART_RX_BUFFER_LEN];
#endif
#if defined(__CC_ARM) || defined(__ARMCC_VERSION)
ARMCC_SECTION("uart3_non_blocking_driver_state")
cmsis_uart_non_blocking_driver_state_t UART3_NonBlockingDriverState = {
#else
cmsis_uart_non_blocking_driver_state_t UART3_NonBlockingDriverState = {
#endif
&UART3_Resource,
&UART3_Handle,
};
static int32_t UART3_NonBlockingInitialize(ARM_USART_SignalEvent_t cb_event)
{
UART3_InitPins();
return UART_NonBlockingInitialize(cb_event, &UART3_NonBlockingDriverState);
}
static int32_t UART3_NonBlockingUninitialize(void)
{
UART3_DeinitPins();
return UART_NonBlockingUninitialize(&UART3_NonBlockingDriverState);
}
static int32_t UART3_NonBlockingPowerControl(ARM_POWER_STATE state)
{
uint32_t result;
result = UART_NonBlockingPowerControl(state, &UART3_NonBlockingDriverState);
#if defined(USART3_RX_BUFFER_ENABLE) && (USART3_RX_BUFFER_ENABLE == 1)
if ((state == ARM_POWER_FULL) && (UART3_NonBlockingDriverState.handle->rxRingBuffer == NULL))
{
UART_TransferStartRingBuffer(UART3_NonBlockingDriverState.resource->base, UART3_NonBlockingDriverState.handle,
uart3_rxRingBuffer, USART_RX_BUFFER_LEN);
}
#endif
return result;
}
static int32_t UART3_NonBlockingSend(const void *data, uint32_t num)
{
return UART_NonBlockingSend(data, num, &UART3_NonBlockingDriverState);
}
static int32_t UART3_NonBlockingReceive(void *data, uint32_t num)
{
return UART_NonBlockingReceive(data, num, &UART3_NonBlockingDriverState);
}
static int32_t UART3_NonBlockingTransfer(const void *data_out, void *data_in, uint32_t num)
{
return UART_NonBlockingTransfer(data_out, data_in, num, &UART3_NonBlockingDriverState);
}
static uint32_t UART3_NonBlockingGetTxCount(void)
{
return UART_NonBlockingGetTxCount(&UART3_NonBlockingDriverState);
}
static uint32_t UART3_NonBlockingGetRxCount(void)
{
return UART_NonBlockingGetRxCount(&UART3_NonBlockingDriverState);
}
static int32_t UART3_NonBlockingControl(uint32_t control, uint32_t arg)
{
int32_t result;
result = UART_NonBlockingControl(control, arg, &UART3_NonBlockingDriverState);
if (ARM_DRIVER_OK != result)
{
return result;
}
/* Enable the receive interrupts if ring buffer is used */
if (UART3_NonBlockingDriverState.handle->rxRingBuffer != NULL)
{
UART_EnableInterrupts(UART3_NonBlockingDriverState.resource->base,
(kUART_RxReadyEnable | kUART_AgingTimerEnable | kUART_RxOverrunEnable |
kUART_ParityErrorEnable | kUART_FrameErrorEnable));
}
return ARM_DRIVER_OK;
}
static ARM_USART_STATUS UART3_NonBlockingGetStatus(void)
{
return UART_NonBlockingGetStatus(&UART3_NonBlockingDriverState);
}
#endif
ARM_DRIVER_USART Driver_USART3 = {
UARTx_GetVersion, UARTx_GetCapabilities,
#if RTE_USART3_DMA_EN
UART3_SdmaInitialize, UART3_SdmaUninitialize, UART3_SdmaPowerControl, UART3_SdmaSend, UART3_SdmaReceive,
UART3_SdmaTransfer, UART3_SdmaGetTxCount, UART3_SdmaGetRxCount, UART3_SdmaControl, UART3_SdmaGetStatus,
#else
UART3_NonBlockingInitialize,
UART3_NonBlockingUninitialize,
UART3_NonBlockingPowerControl,
UART3_NonBlockingSend,
UART3_NonBlockingReceive,
UART3_NonBlockingTransfer,
UART3_NonBlockingGetTxCount,
UART3_NonBlockingGetRxCount,
UART3_NonBlockingControl,
UART3_NonBlockingGetStatus,
#endif
UARTx_SetModemControl, UARTx_GetModemStatus};
#endif /* UART3 */
#if defined(UART4) && RTE_USART4
/* User needs to provide the implementation for UART4_GetFreq/InitPins/DeinitPins
* in the application for enabling according instance.
*/
extern uint32_t UART4_GetFreq(void);
extern void UART4_InitPins(void);
extern void UART4_DeinitPins(void);
cmsis_uart_resource_t UART4_Resource = {UART4, UART4_GetFreq};
#if RTE_USART4_DMA_EN
cmsis_uart_sdma_resource_t UART4_SdmaResource = {
RTE_USART4_SDMA_TX_DMA_BASE, RTE_USART4_SDMA_TX_CH, RTE_USART4_SDMA_TX_REQUEST, RTE_USART4_SDMA_TX_PRIORITY,
RTE_USART4_SDMA_RX_DMA_BASE, RTE_USART4_SDMA_RX_CH, RTE_USART4_SDMA_RX_REQUEST, RTE_USART4_SDMA_RX_PRIORITY,
};
AT_NONCACHEABLE_SECTION_ALIGN(uart_sdma_handle_t UART4_SdmaHandle, 4);
AT_NONCACHEABLE_SECTION_ALIGN(sdma_handle_t UART4_SdmaTxHandle, 4);
AT_NONCACHEABLE_SECTION_ALIGN(sdma_handle_t UART4_SdmaRxHandle, 4);
AT_NONCACHEABLE_SECTION_ALIGN(sdma_context_data_t UART4_SdmaTxContext, 4);
AT_NONCACHEABLE_SECTION_ALIGN(sdma_context_data_t UART4_SdmaRxContext, 4);
#if defined(__CC_ARM) || defined(__ARMCC_VERSION)
ARMCC_SECTION("uart4_sdma_driver_state")
cmsis_uart_sdma_driver_state_t UART4_SdmaDriverState = {
#else
cmsis_uart_sdma_driver_state_t UART4_SdmaDriverState = {
#endif
&UART4_Resource, &UART4_SdmaResource, &UART4_SdmaHandle, &UART4_SdmaRxHandle, &UART4_SdmaTxHandle,
};
static int32_t UART4_SdmaInitialize(ARM_USART_SignalEvent_t cb_event)
{
UART4_InitPins();
return UART_SdmaInitialize(cb_event, &UART4_SdmaDriverState);
}
static int32_t UART4_SdmaUninitialize(void)
{
UART4_DeinitPins();
return UART_SdmaUninitialize(&UART4_SdmaDriverState);
}
static int32_t UART4_SdmaPowerControl(ARM_POWER_STATE state)
{
return UART_SdmaPowerControl(state, &UART4_SdmaDriverState, &UART4_SdmaRxContext, &UART4_SdmaTxContext);
}
static int32_t UART4_SdmaSend(const void *data, uint32_t num)
{
return UART_SdmaSend(data, num, &UART4_SdmaDriverState);
}
static int32_t UART4_SdmaReceive(void *data, uint32_t num)
{
return UART_SdmaReceive(data, num, &UART4_SdmaDriverState);
}
static int32_t UART4_SdmaTransfer(const void *data_out, void *data_in, uint32_t num)
{
return UART_SdmaTransfer(data_out, data_in, num, &UART4_SdmaDriverState);
}
static uint32_t UART4_SdmaGetTxCount(void)
{
return UART_SdmaGetTxCount(&UART4_SdmaDriverState);
}
static uint32_t UART4_SdmaGetRxCount(void)
{
return UART_SdmaGetRxCount(&UART4_SdmaDriverState);
}
static int32_t UART4_SdmaControl(uint32_t control, uint32_t arg)
{
return UART_SdmaControl(control, arg, &UART4_SdmaDriverState);
}
static ARM_USART_STATUS UART4_SdmaGetStatus(void)
{
return UART_SdmaGetStatus(&UART4_SdmaDriverState);
}
#else
uart_handle_t UART4_Handle;
#if defined(USART4_RX_BUFFER_ENABLE) && (USART4_RX_BUFFER_ENABLE == 1)
static uint8_t uart4_rxRingBuffer[USART_RX_BUFFER_LEN];
#endif
#if defined(__CC_ARM) || defined(__ARMCC_VERSION)
ARMCC_SECTION("uart4_non_blocking_driver_state")
cmsis_uart_non_blocking_driver_state_t UART4_NonBlockingDriverState = {
#else
cmsis_uart_non_blocking_driver_state_t UART4_NonBlockingDriverState = {
#endif
&UART4_Resource,
&UART4_Handle,
};
static int32_t UART4_NonBlockingInitialize(ARM_USART_SignalEvent_t cb_event)
{
UART4_InitPins();
return UART_NonBlockingInitialize(cb_event, &UART4_NonBlockingDriverState);
}
static int32_t UART4_NonBlockingUninitialize(void)
{
UART4_DeinitPins();
return UART_NonBlockingUninitialize(&UART4_NonBlockingDriverState);
}
static int32_t UART4_NonBlockingPowerControl(ARM_POWER_STATE state)
{
uint32_t result;
result = UART_NonBlockingPowerControl(state, &UART4_NonBlockingDriverState);
#if defined(USART4_RX_BUFFER_ENABLE) && (USART4_RX_BUFFER_ENABLE == 1)
if ((state == ARM_POWER_FULL) && (UART4_NonBlockingDriverState.handle->rxRingBuffer == NULL))
{
UART_TransferStartRingBuffer(UART4_NonBlockingDriverState.resource->base, UART4_NonBlockingDriverState.handle,
uart4_rxRingBuffer, USART_RX_BUFFER_LEN);
}
#endif
return result;
}
static int32_t UART4_NonBlockingSend(const void *data, uint32_t num)
{
return UART_NonBlockingSend(data, num, &UART4_NonBlockingDriverState);
}
static int32_t UART4_NonBlockingReceive(void *data, uint32_t num)
{
return UART_NonBlockingReceive(data, num, &UART4_NonBlockingDriverState);
}
static int32_t UART4_NonBlockingTransfer(const void *data_out, void *data_in, uint32_t num)
{
return UART_NonBlockingTransfer(data_out, data_in, num, &UART4_NonBlockingDriverState);
}
static uint32_t UART4_NonBlockingGetTxCount(void)
{
return UART_NonBlockingGetTxCount(&UART4_NonBlockingDriverState);
}
static uint32_t UART4_NonBlockingGetRxCount(void)
{
return UART_NonBlockingGetRxCount(&UART4_NonBlockingDriverState);
}
static int32_t UART4_NonBlockingControl(uint32_t control, uint32_t arg)
{
int32_t result;
result = UART_NonBlockingControl(control, arg, &UART4_NonBlockingDriverState);
if (ARM_DRIVER_OK != result)
{
return result;
}
/* Enable the receive interrupts if ring buffer is used */
if (UART4_NonBlockingDriverState.handle->rxRingBuffer != NULL)
{
UART_EnableInterrupts(UART4_NonBlockingDriverState.resource->base,
(kUART_RxReadyEnable | kUART_AgingTimerEnable | kUART_RxOverrunEnable |
kUART_ParityErrorEnable | kUART_FrameErrorEnable));
}
return ARM_DRIVER_OK;
}
static ARM_USART_STATUS UART4_NonBlockingGetStatus(void)
{
return UART_NonBlockingGetStatus(&UART4_NonBlockingDriverState);
}
#endif
ARM_DRIVER_USART Driver_USART4 = {
UARTx_GetVersion, UARTx_GetCapabilities,
#if RTE_USART4_DMA_EN
UART4_SdmaInitialize, UART4_SdmaUninitialize, UART4_SdmaPowerControl, UART4_SdmaSend, UART4_SdmaReceive,
UART4_SdmaTransfer, UART4_SdmaGetTxCount, UART4_SdmaGetRxCount, UART4_SdmaControl, UART4_SdmaGetStatus,
#else
UART4_NonBlockingInitialize,
UART4_NonBlockingUninitialize,
UART4_NonBlockingPowerControl,
UART4_NonBlockingSend,
UART4_NonBlockingReceive,
UART4_NonBlockingTransfer,
UART4_NonBlockingGetTxCount,
UART4_NonBlockingGetRxCount,
UART4_NonBlockingControl,
UART4_NonBlockingGetStatus,
#endif
UARTx_SetModemControl, UARTx_GetModemStatus};
#endif /* UART4 */