| /* |
| * Copyright (c) 2013-2022 Arm Limited. All rights reserved. |
| * |
| * 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 "Driver_USART.h" |
| |
| #include "RTE_Device.h" |
| #include "cmsis_driver_config.h" |
| |
| #ifndef ARG_UNUSED |
| #define ARG_UNUSED(arg) (void) arg |
| #endif |
| |
| /* Driver version */ |
| #define ARM_USART_DRV_VERSION ARM_DRIVER_VERSION_MAJOR_MINOR(2, 2) |
| |
| /* Driver Version */ |
| static const ARM_DRIVER_VERSION DriverVersion = { ARM_USART_API_VERSION, ARM_USART_DRV_VERSION }; |
| |
| /* Driver Capabilities */ |
| static const ARM_USART_CAPABILITIES DriverCapabilities = { |
| 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 available */ |
| 0, /* RTS Flow Control available */ |
| 0, /* CTS Flow Control available */ |
| 0, /* Transmit completed event: \ref ARM_USARTx_EVENT_TX_COMPLETE */ |
| 0, /* Signal receive character timeout event: \ref ARM_USARTx_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_USARTx_EVENT_CTS */ |
| 0, /* Signal DSR change event: \ref ARM_USARTx_EVENT_DSR */ |
| 0, /* Signal DCD change event: \ref ARM_USARTx_EVENT_DCD */ |
| 0, /* Signal RI change event: \ref ARM_USARTx_EVENT_RI */ |
| 0 /* Reserved */ |
| }; |
| |
| static ARM_DRIVER_VERSION ARM_USART_GetVersion(void) |
| { |
| return DriverVersion; |
| } |
| |
| static ARM_USART_CAPABILITIES ARM_USART_GetCapabilities(void) |
| { |
| return DriverCapabilities; |
| } |
| |
| typedef struct |
| { |
| struct uart_cmsdk_dev_t * dev; /* UART device structure */ |
| uint32_t tx_nbr_bytes; /* Number of bytes transferred */ |
| uint32_t rx_nbr_bytes; /* Number of bytes recevied */ |
| ARM_USART_SignalEvent_t cb_event; /* Callback function for events */ |
| } UARTx_Resources; |
| |
| static int32_t ARM_USARTx_Initialize(UARTx_Resources * uart_dev) |
| { |
| /* Initializes generic UART driver */ |
| uart_cmsdk_init(uart_dev->dev, PeripheralClock); |
| |
| return ARM_DRIVER_OK; |
| } |
| |
| static int32_t ARM_USARTx_PowerControl(UARTx_Resources * uart_dev, ARM_POWER_STATE state) |
| { |
| ARG_UNUSED(uart_dev); |
| |
| switch (state) |
| { |
| case ARM_POWER_OFF: |
| case ARM_POWER_LOW: |
| return ARM_DRIVER_ERROR_UNSUPPORTED; |
| case ARM_POWER_FULL: |
| /* Nothing to be done */ |
| return ARM_DRIVER_OK; |
| /* default: The default is not defined intentionally to force the |
| * compiler to check that all the enumeration values are |
| * covered in the switch.*/ |
| } |
| } |
| |
| static int32_t ARM_USARTx_Send(UARTx_Resources * uart_dev, const void * data, uint32_t num) |
| { |
| const uint8_t * p_data = (const uint8_t *) data; |
| |
| if ((data == NULL) || (num == 0U)) |
| { |
| /* Invalid parameters */ |
| return ARM_DRIVER_ERROR_PARAMETER; |
| } |
| |
| /* Resets previous TX counter */ |
| uart_dev->tx_nbr_bytes = 0; |
| |
| while (uart_dev->tx_nbr_bytes != num) |
| { |
| /* Waits until UART is ready to transmit */ |
| while (!uart_cmsdk_tx_ready(uart_dev->dev)) |
| { |
| }; |
| |
| /* As UART is ready to transmit at this point, the write function can |
| * not return any transmit error */ |
| (void) uart_cmsdk_write(uart_dev->dev, *p_data); |
| |
| uart_dev->tx_nbr_bytes++; |
| p_data++; |
| } |
| |
| if (uart_dev->cb_event != NULL) |
| { |
| uart_dev->cb_event(ARM_USART_EVENT_SEND_COMPLETE); |
| } |
| |
| /* Waits until character is transmitted */ |
| while (!uart_cmsdk_tx_ready(uart_dev->dev)) |
| { |
| }; |
| |
| return ARM_DRIVER_OK; |
| } |
| |
| static int32_t ARM_USARTx_Receive(UARTx_Resources * uart_dev, void * data, uint32_t num) |
| { |
| uint8_t * p_data = (uint8_t *) data; |
| |
| if ((data == NULL) || (num == 0U)) |
| { |
| // Invalid parameters |
| return ARM_DRIVER_ERROR_PARAMETER; |
| } |
| |
| /* Resets previous RX counter */ |
| uart_dev->rx_nbr_bytes = 0; |
| |
| while (uart_dev->rx_nbr_bytes != num) |
| { |
| /* Waits until one character is received */ |
| while (!uart_cmsdk_rx_ready(uart_dev->dev)) |
| { |
| }; |
| |
| /* As UART has received one byte, the read can not |
| * return any receive error at this point */ |
| (void) uart_cmsdk_read(uart_dev->dev, p_data); |
| |
| uart_dev->rx_nbr_bytes++; |
| p_data++; |
| } |
| |
| if (uart_dev->cb_event != NULL) |
| { |
| uart_dev->cb_event(ARM_USART_EVENT_RECEIVE_COMPLETE); |
| } |
| |
| return ARM_DRIVER_OK; |
| } |
| |
| static uint32_t ARM_USARTx_GetTxCount(UARTx_Resources * uart_dev) |
| { |
| return uart_dev->tx_nbr_bytes; |
| } |
| |
| static uint32_t ARM_USARTx_GetRxCount(UARTx_Resources * uart_dev) |
| { |
| return uart_dev->rx_nbr_bytes; |
| } |
| |
| static int32_t ARM_USARTx_Control(UARTx_Resources * uart_dev, uint32_t control, uint32_t arg) |
| { |
| switch (control & ARM_USART_CONTROL_Msk) |
| { |
| #ifdef UART_TX_RX_CONTROL_ENABLED |
| case ARM_USART_CONTROL_TX: |
| if (arg == 0) |
| { |
| uart_cmsdk_tx_disable(uart_dev->dev); |
| } |
| else if (arg == 1) |
| { |
| if (uart_cmsdk_tx_enable(uart_dev->dev) != UART_CMSDK_ERR_NONE) |
| { |
| return ARM_DRIVER_ERROR; |
| } |
| } |
| else |
| { |
| return ARM_DRIVER_ERROR_PARAMETER; |
| } |
| break; |
| case ARM_USART_CONTROL_RX: |
| if (arg == 0) |
| { |
| uart_cmsdk_rx_disable(uart_dev->dev); |
| } |
| else if (arg == 1) |
| { |
| if (uart_cmsdk_rx_enable(uart_dev->dev) != UART_CMSDK_ERR_NONE) |
| { |
| return ARM_DRIVER_ERROR; |
| } |
| } |
| else |
| { |
| return ARM_DRIVER_ERROR_PARAMETER; |
| } |
| break; |
| #endif |
| case ARM_USART_MODE_ASYNCHRONOUS: |
| if (uart_cmsdk_set_baudrate(uart_dev->dev, arg) != UART_CMSDK_ERR_NONE) |
| { |
| return ARM_USART_ERROR_BAUDRATE; |
| } |
| break; |
| /* Unsupported command */ |
| default: |
| return ARM_DRIVER_ERROR_UNSUPPORTED; |
| } |
| |
| /* UART Data bits */ |
| if (control & ARM_USART_DATA_BITS_Msk) |
| { |
| /* Data bit is not configurable */ |
| return ARM_DRIVER_ERROR_UNSUPPORTED; |
| } |
| |
| /* UART Parity */ |
| if (control & ARM_USART_PARITY_Msk) |
| { |
| /* Parity is not configurable */ |
| return ARM_USART_ERROR_PARITY; |
| } |
| |
| /* USART Stop bits */ |
| if (control & ARM_USART_STOP_BITS_Msk) |
| { |
| /* Stop bit is not configurable */ |
| return ARM_USART_ERROR_STOP_BITS; |
| } |
| |
| return ARM_DRIVER_OK; |
| } |
| |
| #if (RTE_USART0) |
| /* USART0 Driver wrapper functions */ |
| static UARTx_Resources USART0_DEV = { |
| .dev = &UART0_CMSDK_DEV, |
| .tx_nbr_bytes = 0, |
| .rx_nbr_bytes = 0, |
| .cb_event = NULL, |
| }; |
| |
| static int32_t ARM_USART0_Initialize(ARM_USART_SignalEvent_t cb_event) |
| { |
| USART0_DEV.cb_event = cb_event; |
| |
| return ARM_USARTx_Initialize(&USART0_DEV); |
| } |
| |
| static int32_t ARM_USART0_Uninitialize(void) |
| { |
| /* Nothing to be done */ |
| return ARM_DRIVER_OK; |
| } |
| |
| static int32_t ARM_USART0_PowerControl(ARM_POWER_STATE state) |
| { |
| return ARM_USARTx_PowerControl(&USART0_DEV, state); |
| } |
| |
| static int32_t ARM_USART0_Send(const void * data, uint32_t num) |
| { |
| return ARM_USARTx_Send(&USART0_DEV, data, num); |
| } |
| |
| static int32_t ARM_USART0_Receive(void * data, uint32_t num) |
| { |
| return ARM_USARTx_Receive(&USART0_DEV, data, num); |
| } |
| |
| static int32_t ARM_USART0_Transfer(const void * data_out, void * data_in, uint32_t num) |
| { |
| ARG_UNUSED(data_out); |
| ARG_UNUSED(data_in); |
| ARG_UNUSED(num); |
| |
| return ARM_DRIVER_ERROR_UNSUPPORTED; |
| } |
| |
| static uint32_t ARM_USART0_GetTxCount(void) |
| { |
| return ARM_USARTx_GetTxCount(&USART0_DEV); |
| } |
| |
| static uint32_t ARM_USART0_GetRxCount(void) |
| { |
| return ARM_USARTx_GetRxCount(&USART0_DEV); |
| } |
| static int32_t ARM_USART0_Control(uint32_t control, uint32_t arg) |
| { |
| return ARM_USARTx_Control(&USART0_DEV, control, arg); |
| } |
| |
| static ARM_USART_STATUS ARM_USART0_GetStatus(void) |
| { |
| ARM_USART_STATUS status = { 0, 0, 0, 0, 0, 0, 0, 0 }; |
| return status; |
| } |
| |
| static int32_t ARM_USART0_SetModemControl(ARM_USART_MODEM_CONTROL control) |
| { |
| ARG_UNUSED(control); |
| return ARM_DRIVER_ERROR_UNSUPPORTED; |
| } |
| |
| static ARM_USART_MODEM_STATUS ARM_USART0_GetModemStatus(void) |
| { |
| ARM_USART_MODEM_STATUS modem_status = { 0, 0, 0, 0, 0 }; |
| return modem_status; |
| } |
| |
| extern ARM_DRIVER_USART Driver_USART0; |
| ARM_DRIVER_USART Driver_USART0 = { ARM_USART_GetVersion, ARM_USART_GetCapabilities, ARM_USART0_Initialize, |
| ARM_USART0_Uninitialize, ARM_USART0_PowerControl, ARM_USART0_Send, |
| ARM_USART0_Receive, ARM_USART0_Transfer, ARM_USART0_GetTxCount, |
| ARM_USART0_GetRxCount, ARM_USART0_Control, ARM_USART0_GetStatus, |
| ARM_USART0_SetModemControl, ARM_USART0_GetModemStatus }; |
| #endif /* RTE_USART0 */ |
| |
| #if (RTE_USART1) |
| /* USART1 Driver wrapper functions */ |
| static UARTx_Resources USART1_DEV = { |
| .dev = &UART1_CMSDK_DEV, |
| .tx_nbr_bytes = 0, |
| .rx_nbr_bytes = 0, |
| .cb_event = NULL, |
| }; |
| |
| static int32_t ARM_USART1_Initialize(ARM_USART_SignalEvent_t cb_event) |
| { |
| USART1_DEV.cb_event = cb_event; |
| |
| return ARM_USARTx_Initialize(&USART1_DEV); |
| } |
| |
| static int32_t ARM_USART1_Uninitialize(void) |
| { |
| /* Nothing to be done */ |
| return ARM_DRIVER_OK; |
| } |
| |
| static int32_t ARM_USART1_PowerControl(ARM_POWER_STATE state) |
| { |
| return ARM_USARTx_PowerControl(&USART1_DEV, state); |
| } |
| |
| static int32_t ARM_USART1_Send(const void * data, uint32_t num) |
| { |
| return ARM_USARTx_Send(&USART1_DEV, data, num); |
| } |
| |
| static int32_t ARM_USART1_Receive(void * data, uint32_t num) |
| { |
| return ARM_USARTx_Receive(&USART1_DEV, data, num); |
| } |
| |
| static int32_t ARM_USART1_Transfer(const void * data_out, void * data_in, uint32_t num) |
| { |
| ARG_UNUSED(data_out); |
| ARG_UNUSED(data_in); |
| ARG_UNUSED(num); |
| |
| return ARM_DRIVER_ERROR_UNSUPPORTED; |
| } |
| |
| static uint32_t ARM_USART1_GetTxCount(void) |
| { |
| return ARM_USARTx_GetTxCount(&USART1_DEV); |
| } |
| |
| static uint32_t ARM_USART1_GetRxCount(void) |
| { |
| return ARM_USARTx_GetRxCount(&USART1_DEV); |
| } |
| static int32_t ARM_USART1_Control(uint32_t control, uint32_t arg) |
| { |
| return ARM_USARTx_Control(&USART1_DEV, control, arg); |
| } |
| |
| static ARM_USART_STATUS ARM_USART1_GetStatus(void) |
| { |
| ARM_USART_STATUS status = { 0, 0, 0, 0, 0, 0, 0, 0 }; |
| return status; |
| } |
| |
| static int32_t ARM_USART1_SetModemControl(ARM_USART_MODEM_CONTROL control) |
| { |
| ARG_UNUSED(control); |
| return ARM_DRIVER_ERROR_UNSUPPORTED; |
| } |
| |
| static ARM_USART_MODEM_STATUS ARM_USART1_GetModemStatus(void) |
| { |
| ARM_USART_MODEM_STATUS modem_status = { 0, 0, 0, 0, 0 }; |
| return modem_status; |
| } |
| |
| extern ARM_DRIVER_USART Driver_USART1; |
| ARM_DRIVER_USART Driver_USART1 = { ARM_USART_GetVersion, ARM_USART_GetCapabilities, ARM_USART1_Initialize, |
| ARM_USART1_Uninitialize, ARM_USART1_PowerControl, ARM_USART1_Send, |
| ARM_USART1_Receive, ARM_USART1_Transfer, ARM_USART1_GetTxCount, |
| ARM_USART1_GetRxCount, ARM_USART1_Control, ARM_USART1_GetStatus, |
| ARM_USART1_SetModemControl, ARM_USART1_GetModemStatus }; |
| #endif /* RTE_USART1 */ |
| |
| #if (RTE_USART2) |
| /* USART2 Driver wrapper functions */ |
| static UARTx_Resources USART2_DEV = { |
| .dev = &UART2_CMSDK_DEV, |
| .tx_nbr_bytes = 0, |
| .rx_nbr_bytes = 0, |
| .cb_event = NULL, |
| }; |
| |
| static int32_t ARM_USART2_Initialize(ARM_USART_SignalEvent_t cb_event) |
| { |
| USART2_DEV.cb_event = cb_event; |
| |
| return ARM_USARTx_Initialize(&USART2_DEV); |
| } |
| |
| static int32_t ARM_USART2_Uninitialize(void) |
| { |
| /* Nothing to be done */ |
| return ARM_DRIVER_OK; |
| } |
| |
| static int32_t ARM_USART2_PowerControl(ARM_POWER_STATE state) |
| { |
| return ARM_USARTx_PowerControl(&USART2_DEV, state); |
| } |
| |
| static int32_t ARM_USART2_Send(const void * data, uint32_t num) |
| { |
| return ARM_USARTx_Send(&USART2_DEV, data, num); |
| } |
| |
| static int32_t ARM_USART2_Receive(void * data, uint32_t num) |
| { |
| return ARM_USARTx_Receive(&USART2_DEV, data, num); |
| } |
| |
| static int32_t ARM_USART2_Transfer(const void * data_out, void * data_in, uint32_t num) |
| { |
| ARG_UNUSED(data_out); |
| ARG_UNUSED(data_in); |
| ARG_UNUSED(num); |
| |
| return ARM_DRIVER_ERROR_UNSUPPORTED; |
| } |
| |
| static uint32_t ARM_USART2_GetTxCount(void) |
| { |
| return ARM_USARTx_GetTxCount(&USART2_DEV); |
| } |
| |
| static uint32_t ARM_USART2_GetRxCount(void) |
| { |
| return ARM_USARTx_GetRxCount(&USART2_DEV); |
| } |
| static int32_t ARM_USART2_Control(uint32_t control, uint32_t arg) |
| { |
| return ARM_USARTx_Control(&USART2_DEV, control, arg); |
| } |
| |
| static ARM_USART_STATUS ARM_USART2_GetStatus(void) |
| { |
| ARM_USART_STATUS status = { 0, 0, 0, 0, 0, 0, 0, 0 }; |
| return status; |
| } |
| |
| static int32_t ARM_USART2_SetModemControl(ARM_USART_MODEM_CONTROL control) |
| { |
| ARG_UNUSED(control); |
| return ARM_DRIVER_ERROR_UNSUPPORTED; |
| } |
| |
| static ARM_USART_MODEM_STATUS ARM_USART2_GetModemStatus(void) |
| { |
| ARM_USART_MODEM_STATUS modem_status = { 0, 0, 0, 0, 0 }; |
| return modem_status; |
| } |
| |
| extern ARM_DRIVER_USART Driver_USART2; |
| ARM_DRIVER_USART Driver_USART2 = { ARM_USART_GetVersion, ARM_USART_GetCapabilities, ARM_USART2_Initialize, |
| ARM_USART2_Uninitialize, ARM_USART2_PowerControl, ARM_USART2_Send, |
| ARM_USART2_Receive, ARM_USART2_Transfer, ARM_USART2_GetTxCount, |
| ARM_USART2_GetRxCount, ARM_USART2_Control, ARM_USART2_GetStatus, |
| ARM_USART2_SetModemControl, ARM_USART2_GetModemStatus }; |
| #endif /* RTE_USART2 */ |
| |
| #if (RTE_USART3) |
| /* USART3 Driver wrapper functions */ |
| static UARTx_Resources USART3_DEV = { |
| .dev = &UART3_CMSDK_DEV, |
| .tx_nbr_bytes = 0, |
| .rx_nbr_bytes = 0, |
| .cb_event = NULL, |
| }; |
| |
| static int32_t ARM_USART3_Initialize(ARM_USART_SignalEvent_t cb_event) |
| { |
| USART3_DEV.cb_event = cb_event; |
| |
| return ARM_USARTx_Initialize(&USART3_DEV); |
| } |
| |
| static int32_t ARM_USART3_Uninitialize(void) |
| { |
| /* Nothing to be done */ |
| return ARM_DRIVER_OK; |
| } |
| |
| static int32_t ARM_USART3_PowerControl(ARM_POWER_STATE state) |
| { |
| return ARM_USARTx_PowerControl(&USART3_DEV, state); |
| } |
| |
| static int32_t ARM_USART3_Send(const void * data, uint32_t num) |
| { |
| return ARM_USARTx_Send(&USART3_DEV, data, num); |
| } |
| |
| static int32_t ARM_USART3_Receive(void * data, uint32_t num) |
| { |
| return ARM_USARTx_Receive(&USART3_DEV, data, num); |
| } |
| |
| static int32_t ARM_USART3_Transfer(const void * data_out, void * data_in, uint32_t num) |
| { |
| ARG_UNUSED(data_out); |
| ARG_UNUSED(data_in); |
| ARG_UNUSED(num); |
| |
| return ARM_DRIVER_ERROR_UNSUPPORTED; |
| } |
| |
| static uint32_t ARM_USART3_GetTxCount(void) |
| { |
| return ARM_USARTx_GetTxCount(&USART3_DEV); |
| } |
| |
| static uint32_t ARM_USART3_GetRxCount(void) |
| { |
| return ARM_USARTx_GetRxCount(&USART3_DEV); |
| } |
| static int32_t ARM_USART3_Control(uint32_t control, uint32_t arg) |
| { |
| return ARM_USARTx_Control(&USART3_DEV, control, arg); |
| } |
| |
| static ARM_USART_STATUS ARM_USART3_GetStatus(void) |
| { |
| ARM_USART_STATUS status = { 0, 0, 0, 0, 0, 0, 0, 0 }; |
| return status; |
| } |
| |
| static int32_t ARM_USART3_SetModemControl(ARM_USART_MODEM_CONTROL control) |
| { |
| ARG_UNUSED(control); |
| return ARM_DRIVER_ERROR_UNSUPPORTED; |
| } |
| |
| static ARM_USART_MODEM_STATUS ARM_USART3_GetModemStatus(void) |
| { |
| ARM_USART_MODEM_STATUS modem_status = { 0, 0, 0, 0, 0 }; |
| return modem_status; |
| } |
| |
| extern ARM_DRIVER_USART Driver_USART3; |
| ARM_DRIVER_USART Driver_USART3 = { ARM_USART_GetVersion, ARM_USART_GetCapabilities, ARM_USART3_Initialize, |
| ARM_USART3_Uninitialize, ARM_USART3_PowerControl, ARM_USART3_Send, |
| ARM_USART3_Receive, ARM_USART3_Transfer, ARM_USART3_GetTxCount, |
| ARM_USART3_GetRxCount, ARM_USART3_Control, ARM_USART3_GetStatus, |
| ARM_USART3_SetModemControl, ARM_USART3_GetModemStatus }; |
| #endif /* RTE_USART3 */ |
| |
| #if (RTE_USART4) |
| /* USART4 Driver wrapper functions */ |
| static UARTx_Resources USART4_DEV = { |
| .dev = &UART4_CMSDK_DEV, |
| .tx_nbr_bytes = 0, |
| .rx_nbr_bytes = 0, |
| .cb_event = NULL, |
| }; |
| |
| static int32_t ARM_USART4_Initialize(ARM_USART_SignalEvent_t cb_event) |
| { |
| USART4_DEV.cb_event = cb_event; |
| |
| return ARM_USARTx_Initialize(&USART4_DEV); |
| } |
| |
| static int32_t ARM_USART4_Uninitialize(void) |
| { |
| /* Nothing to be done */ |
| return ARM_DRIVER_OK; |
| } |
| |
| static int32_t ARM_USART4_PowerControl(ARM_POWER_STATE state) |
| { |
| return ARM_USARTx_PowerControl(&USART4_DEV, state); |
| } |
| |
| static int32_t ARM_USART4_Send(const void * data, uint32_t num) |
| { |
| return ARM_USARTx_Send(&USART4_DEV, data, num); |
| } |
| |
| static int32_t ARM_USART4_Receive(void * data, uint32_t num) |
| { |
| return ARM_USARTx_Receive(&USART4_DEV, data, num); |
| } |
| |
| static int32_t ARM_USART4_Transfer(const void * data_out, void * data_in, uint32_t num) |
| { |
| ARG_UNUSED(data_out); |
| ARG_UNUSED(data_in); |
| ARG_UNUSED(num); |
| |
| return ARM_DRIVER_ERROR_UNSUPPORTED; |
| } |
| |
| static uint32_t ARM_USART4_GetTxCount(void) |
| { |
| return ARM_USARTx_GetTxCount(&USART4_DEV); |
| } |
| |
| static uint32_t ARM_USART4_GetRxCount(void) |
| { |
| return ARM_USARTx_GetRxCount(&USART4_DEV); |
| } |
| static int32_t ARM_USART4_Control(uint32_t control, uint32_t arg) |
| { |
| return ARM_USARTx_Control(&USART4_DEV, control, arg); |
| } |
| |
| static ARM_USART_STATUS ARM_USART4_GetStatus(void) |
| { |
| ARM_USART_STATUS status = { 0, 0, 0, 0, 0, 0, 0, 0 }; |
| return status; |
| } |
| |
| static int32_t ARM_USART4_SetModemControl(ARM_USART_MODEM_CONTROL control) |
| { |
| ARG_UNUSED(control); |
| return ARM_DRIVER_ERROR_UNSUPPORTED; |
| } |
| |
| static ARM_USART_MODEM_STATUS ARM_USART4_GetModemStatus(void) |
| { |
| ARM_USART_MODEM_STATUS modem_status = { 0, 0, 0, 0, 0 }; |
| return modem_status; |
| } |
| |
| extern ARM_DRIVER_USART Driver_USART4; |
| ARM_DRIVER_USART Driver_USART4 = { ARM_USART_GetVersion, ARM_USART_GetCapabilities, ARM_USART4_Initialize, |
| ARM_USART4_Uninitialize, ARM_USART4_PowerControl, ARM_USART4_Send, |
| ARM_USART4_Receive, ARM_USART4_Transfer, ARM_USART4_GetTxCount, |
| ARM_USART4_GetRxCount, ARM_USART4_Control, ARM_USART4_GetStatus, |
| ARM_USART4_SetModemControl, ARM_USART4_GetModemStatus }; |
| #endif /* RTE_USART4 */ |