examples/platform/openiotsdk/tf-m/targets/an552/cmsis_drivers/Driver_USART.c - third_party/github/project-chip/connectedhomeip - Git at Google

 /*
  * 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 */
	/*
	* 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 */