/*================================================================================================== * Project : RTD AUTOSAR 4.4 * Platform : CORTEXM * Peripheral : FLEXIO * Dependencies : * * Autosar Version : 4.4.0 * Autosar Revision : ASR_REL_4_4_REV_0000 * Autosar Conf.Variant : * SW Version : 1.0.0 * Build Version : S32K1_RTD_1_0_0_HF01_D2109_ASR_REL_4_4_REV_0000_20210907 * * (c) Copyright 2020-2021 NXP Semiconductors * All Rights Reserved. * * NXP Confidential. This software is owned or controlled by NXP and may only be * used strictly in accordance with the applicable license terms. By expressly * accepting such terms or by downloading, installing, activating and/or otherwise * using the software, you are agreeing that you have read, and that you agree to * comply with and are bound by, such license terms. If you do not agree to be * bound by the applicable license terms, then you may not retain, install, * activate or otherwise use the software. ==================================================================================================*/ /** * @file * @internal * @addtogroup UART * @{ */ #ifdef __cplusplus extern "C" { #endif /*================================================================================================== * INCLUDE FILES * 1) system and project includes * 2) needed interfaces from external units * 3) internal and external interfaces from this unit ==================================================================================================*/ #include "Uart_Ipw.h" #include "Uart_Ipw_Cfg.h" #ifdef UART_IPW_LPUART_HW_USING #include "Lpuart_Uart_Ip.h" #endif #ifdef UART_IPW_FLEXIO_HW_USING #include "Flexio_Uart_Ip.h" #endif /*================================================================================================== * SOURCE FILE VERSION INFORMATION ==================================================================================================*/ #define UART_IPW_VENDOR_ID_C 43 #define UART_IPW_AR_RELEASE_MAJOR_VERSION_C 4 #define UART_IPW_AR_RELEASE_MINOR_VERSION_C 4 #define UART_IPW_AR_RELEASE_REVISION_VERSION_C 0 #define UART_IPW_SW_MAJOR_VERSION_C 1 #define UART_IPW_SW_MINOR_VERSION_C 0 #define UART_IPW_SW_PATCH_VERSION_C 0 /*================================================================================================== * FILE VERSION CHECKS ==================================================================================================*/ /*Checks against Uart_Ipw.h */ #if (UART_IPW_VENDOR_ID_C!= UART_IPW_VENDOR_ID) #error "Uart_Ipw.c and Uart_Ipw.h have different vendor ids" #endif #if ((UART_IPW_AR_RELEASE_MAJOR_VERSION_C != UART_IPW_AR_RELEASE_MAJOR_VERSION) || \ (UART_IPW_AR_RELEASE_MINOR_VERSION_C != UART_IPW_AR_RELEASE_MINOR_VERSION) || \ (UART_IPW_AR_RELEASE_REVISION_VERSION_C!= UART_IPW_AR_RELEASE_REVISION_VERSION)) #error "AUTOSAR Version Numbers of Uart_Ipw.c and Uart_Ipw.h are different" #endif #if ((UART_IPW_SW_MAJOR_VERSION_C!= UART_IPW_SW_MAJOR_VERSION) || \ (UART_IPW_SW_MINOR_VERSION_C!= UART_IPW_SW_MINOR_VERSION) || \ (UART_IPW_SW_PATCH_VERSION_C!= UART_IPW_SW_PATCH_VERSION) \ ) #error "Software Version Numbers of Uart_Ipw.c and Uart_Ipw.h are different" #endif /* Checks against Uart_Ipw_Cfg.h */ #if (UART_IPW_VENDOR_ID_C != UART_IPW_CFG_VENDOR_ID) #error "Uart_Ipw.c and Uart_Ipw_Cfg.h have different vendor ids" #endif #if ((UART_IPW_AR_RELEASE_MAJOR_VERSION_C != UART_IPW_CFG_AR_RELEASE_MAJOR_VERSION) || \ (UART_IPW_AR_RELEASE_MINOR_VERSION_C != UART_IPW_CFG_AR_RELEASE_MINOR_VERSION) || \ (UART_IPW_AR_RELEASE_REVISION_VERSION_C != UART_IPW_CFG_AR_RELEASE_REVISION_VERSION)) #error "AUTOSAR Version Numbers of Uart_Ipw.c and Uart_Ipw_Cfg.h are different" #endif #if ((UART_IPW_SW_MAJOR_VERSION_C != UART_IPW_CFG_SW_MAJOR_VERSION) || \ (UART_IPW_SW_MINOR_VERSION_C != UART_IPW_CFG_SW_MINOR_VERSION) || \ (UART_IPW_SW_PATCH_VERSION_C != UART_IPW_CFG_SW_PATCH_VERSION) \ ) #error "Software Version Numbers of Uart_Ipw.c and Uart_Ipw_Cfg.h are different" #endif #ifdef UART_IPW_LPUART_HW_USING /* Checks against Lpuart_Uart_Ip.h */ #if (UART_IPW_VENDOR_ID_C != LPUART_UART_IP_VENDOR_ID) #error "Uart_Ipw.c and Lpuart_Uart_Ip.h have different vendor ids" #endif #if ((UART_IPW_AR_RELEASE_MAJOR_VERSION_C != LPUART_UART_IP_AR_RELEASE_MAJOR_VERSION) || \ (UART_IPW_AR_RELEASE_MINOR_VERSION_C != LPUART_UART_IP_AR_RELEASE_MINOR_VERSION) || \ (UART_IPW_AR_RELEASE_REVISION_VERSION_C != LPUART_UART_IP_AR_RELEASE_REVISION_VERSION)) #error "AUTOSAR Version Numbers of Uart_Ipw.c and Lpuart_Uart_Ip.h are different" #endif #if ((UART_IPW_SW_MAJOR_VERSION_C != LPUART_UART_IP_SW_MAJOR_VERSION) || \ (UART_IPW_SW_MINOR_VERSION_C != LPUART_UART_IP_SW_MINOR_VERSION) || \ (UART_IPW_SW_PATCH_VERSION_C != LPUART_UART_IP_SW_PATCH_VERSION) \ ) #error "Software Version Numbers of Uart_Ipw.c and Lpuart_Uart_Ip.h are different" #endif #endif #ifdef UART_IPW_FLEXIO_HW_USING /* Checks against Flexio_Uart_Ip.h */ #if (UART_IPW_VENDOR_ID_C != FLEXIO_UART_IP_VENDOR_ID) #error "Uart_Ipw.c and Flexio_Uart_Ip.h have different vendor ids" #endif #if ((UART_IPW_AR_RELEASE_MAJOR_VERSION_C != FLEXIO_UART_IP_AR_RELEASE_MAJOR_VERSION) || \ (UART_IPW_AR_RELEASE_MINOR_VERSION_C != FLEXIO_UART_IP_AR_RELEASE_MINOR_VERSION) || \ (UART_IPW_AR_RELEASE_REVISION_VERSION_C != FLEXIO_UART_IP_AR_RELEASE_REVISION_VERSION)) #error "AUTOSAR Version Numbers of Uart_Ipw.c and Flexio_Uart_Ip.h are different" #endif #if ((UART_IPW_SW_MAJOR_VERSION_C != FLEXIO_UART_IP_SW_MAJOR_VERSION) || \ (UART_IPW_SW_MINOR_VERSION_C != FLEXIO_UART_IP_SW_MINOR_VERSION) || \ (UART_IPW_SW_PATCH_VERSION_C != FLEXIO_UART_IP_SW_PATCH_VERSION) \ ) #error "Software Version Numbers of Uart_Ipw.c and Flexio_Uart_Ip.h are different" #endif #endif /*================================================================================================== * LOCAL TYPEDEFS (STRUCTURES, UNIONS, ENUMS) ==================================================================================================*/ /*================================================================================================== * LOCAL MACROS ==================================================================================================*/ /*================================================================================================== * LOCAL CONSTANTS ==================================================================================================*/ /*================================================================================================== * LOCAL VARIABLES ==================================================================================================*/ /*================================================================================================== * GLOBAL CONSTANTS ==================================================================================================*/ #if (UART_CALLBACK_DECLARED == STD_ON) #define UART_START_SEC_VAR_INIT_8 #include "Uart_MemMap.h" static sint8 Uart_Ipw_s8HwMapping[UART_NUMBER_OF_INSTANCES] = UART_HW_CHANNELS_MAPPING_FOR_INIT; #define UART_STOP_SEC_VAR_INIT_8 #include "Uart_MemMap.h" #endif /* UART_CALLBACK_DECLARED == STD_ON */ #define UART_START_SEC_VAR_CLEARED_UNSPECIFIED #include "Uart_MemMap.h" const Uart_Ipw_HwConfigType *Uart_Ipw_apChnConfig[UART_CH_MAX_CONFIG]; #define UART_STOP_SEC_VAR_CLEARED_UNSPECIFIED #include "Uart_MemMap.h" /*================================================================================================== * GLOBAL VARIABLES ==================================================================================================*/ /*================================================================================================== * LOCAL FUNCTION PROTOTYPES ==================================================================================================*/ #define UART_START_SEC_CODE #include "Uart_MemMap.h" #ifdef UART_IPW_LPUART_HW_USING /* Convert Lpuart Status type to Standard status type */ static Uart_StatusType Uart_Ipw_LpuartConvertStatus(Lpuart_Uart_Ip_StatusType Status); /* Convert Uart Baudrate type to Ip Baudrate type */ static Lpuart_Uart_Ip_BaudrateType Uart_Ipw_LpuartConvertBaudrateType(Uart_BaudrateType Baudrate); #if (UART_CALLBACK_DECLARED == STD_ON) /* Convert HLD Uart Event type to Ip Event type */ static Uart_EventType Uart_Ipw_LpuartConvertEventType(Lpuart_Uart_Ip_EventType Event); #endif /* UART_CALLBACK_DECLARED == STD_ON */ #endif #ifdef UART_IPW_FLEXIO_HW_USING /* Convert Flexio Status type to Standard status type */ static Uart_StatusType Uart_Ipw_FlexioConvertStatus(Flexio_Uart_Ip_StatusType Status); /* Convert Uart Baudrate type to Ip Baudrate type */ static Flexio_Uart_Ip_BaudrateType Uart_Ipw_FlexioConvertBaudrateType(Uart_BaudrateType Baudrate); #if (UART_CALLBACK_DECLARED == STD_ON) /* Convert HLD Uart Event type to Ip Event type */ static Uart_EventType Uart_Ipw_FlexioConvertEventType(Flexio_Uart_Ip_EventType Event); #endif /* UART_CALLBACK_DECLARED == STD_ON */ #endif /*================================================================================================== * LOCAL FUNCTIONS ==================================================================================================*/ /*================================================================================================== * GLOBAL FUNCTIONS ==================================================================================================*/ /** * @internal * @brief Initialize an Uart channel. * @details This function calls a LLD function initializes all hardware registers needed to * start the Uart functionality on the selected channel. * * @param [in] Channel Uart channel to be initialized. * [in] Config Configuration pointer containing hardware specific settings. * * @return void. * */ void Uart_Ipw_Init(uint8 Channel, const Uart_Ipw_HwConfigType* Config) { uint8 HwUnit = Config->UartHwChannel; /* Save the mapping between hardware instance and logical channel */ /* Save the channel settings */ Uart_Ipw_apChnConfig[Channel] = Config; /* Call the LLD Initialization function */ if (LPUART_IP == Uart_Ipw_apChnConfig[Channel]->UartIpType) { #ifdef UART_IPW_LPUART_HW_USING #if (UART_CALLBACK_DECLARED == STD_ON) Uart_Ipw_s8HwMapping[HwUnit] = (sint8)Channel; #endif /* UART_CALLBACK_DECLARED == STD_ON */ Lpuart_Uart_Ip_Init(HwUnit, Config->UserConfig->LpuartUserConfig); #endif /* #ifdef UART_IPW_LPUART_HW_USING */ } #ifdef UART_IPW_FLEXIO_HW_USING else { #if (UART_CALLBACK_DECLARED == STD_ON) Uart_Ipw_s8HwMapping[UART_NUMBER_OF_INSTANCES - FLEXIO_UART_IP_NUMBER_OF_SHIFTER_AND_TIMER + HwUnit] = (sint8)Channel; #endif /* UART_CALLBACK_DECLARED == STD_ON */ Flexio_Uart_Ip_Init(HwUnit, Config->UserConfig->FlexioUartUserConfig); } #endif /* #ifdef UART_IPW_FLEXIO_HW_USING */ } /** * @internal * @brief De-initialize an Uart channel. * @details This function calls a LLD function de-initializes an Uart Hw instance and resets the current information regarding the current channel * * @param[in] Channel Uart channel to be de-initialized. * * @return void. * */ void Uart_Ipw_Deinit(uint8 Channel) { uint8 HwUnit = Uart_Ipw_apChnConfig[Channel]->UartHwChannel; if (LPUART_IP == Uart_Ipw_apChnConfig[Channel]->UartIpType) { #ifdef UART_IPW_LPUART_HW_USING #if (UART_CALLBACK_DECLARED == STD_ON) /* Remove the current hw to logic mapping */ Uart_Ipw_s8HwMapping[HwUnit] = -1; #endif /* UART_CALLBACK_DECLARED == STD_ON */ Lpuart_Uart_Ip_Deinit(HwUnit); #endif /* #ifdef UART_IPW_LPUART_HW_USING */ } #ifdef UART_IPW_FLEXIO_HW_USING else { #if (UART_CALLBACK_DECLARED == STD_ON) /* Remove the current hw to logic mapping */ Uart_Ipw_s8HwMapping[UART_NUMBER_OF_INSTANCES - FLEXIO_UART_IP_NUMBER_OF_SHIFTER_AND_TIMER + HwUnit] = -1; #endif /* UART_CALLBACK_DECLARED == STD_ON */ Flexio_Uart_Ip_Deinit(HwUnit); } #endif /* #ifdef UART_IPW_FLEXIO_HW_USING */ /* Remove refference to the current channel configuration */ Uart_Ipw_apChnConfig[Channel] = NULL_PTR; } /** * @internal * @brief Set a baudrate value for the current channel. * @details This function calls a LLD function which sets a baudrate value for a given channel, * * @param[in] Channel Uart channel where the baudrate shall be configured * @param[in] BaudRateValue The baudrate value to be configured. * @param[in] ClockFrequency The clock frequency set for the Uart module. * * @return E_OK: Baud rate successfully configured * E_NOT_OK: Baud rate wasn't successfully configured * */ Std_ReturnType Uart_Ipw_SetBaudrate(uint8 Channel, Uart_BaudrateType BaudRateValue, uint32 ClockFrequency) { Std_ReturnType TempStatus = (uint8)E_NOT_OK; uint8 HwUnit = Uart_Ipw_apChnConfig[Channel]->UartHwChannel; #ifdef UART_IPW_LPUART_HW_USING Lpuart_Uart_Ip_BaudrateType LpuartBaud = Uart_Ipw_LpuartConvertBaudrateType(BaudRateValue); #endif #ifdef UART_IPW_FLEXIO_HW_USING Flexio_Uart_Ip_BaudrateType FlexioBaud = Uart_Ipw_FlexioConvertBaudrateType(BaudRateValue); #endif if (LPUART_IP == Uart_Ipw_apChnConfig[Channel]->UartIpType) { #ifdef UART_IPW_LPUART_HW_USING if (LPUART_UART_IP_STATUS_SUCCESS == Lpuart_Uart_Ip_SetBaudRate(HwUnit, LpuartBaud, ClockFrequency)) { TempStatus = (uint8)E_OK; } #endif /* #ifdef UART_IPW_LPUART_HW_USING */ } #ifdef UART_IPW_FLEXIO_HW_USING else { if (FLEXIO_UART_IP_STATUS_SUCCESS == Flexio_Uart_Ip_SetBaudRate(HwUnit, FlexioBaud, ClockFrequency)) { TempStatus = (uint8)E_OK; } } #endif /* #ifdef UART_IPW_FLEXIO_HW_USING */ return TempStatus; } /** * @internal * @brief Retrieves the baudrate value configured for the current channel. * @details This function calls a LLD function returns the baudrate value configured for the given channel * via a pointer parameter provided by user. * * @param[in] Channel Uart channel where the baudrate shall be configured * @param[out] BaudrateValue The pointer which will contain the baudrate value. * * @return void * */ void Uart_Ipw_GetBaudrate(uint8 Channel, uint32 *BaudrateValue) { uint8 HwUnit = Uart_Ipw_apChnConfig[Channel]->UartHwChannel; if (LPUART_IP == Uart_Ipw_apChnConfig[Channel]->UartIpType) { #ifdef UART_IPW_LPUART_HW_USING Lpuart_Uart_Ip_GetBaudRate(HwUnit, BaudrateValue); #endif /* #ifdef UART_IPW_LPUART_HW_USING */ } #ifdef UART_IPW_FLEXIO_HW_USING else { Flexio_Uart_Ip_GetBaudRate(HwUnit, BaudrateValue); } #endif /* #ifdef UART_IPW_FLEXIO_HW_USING */ } /** * @internal * @brief Aborts an on-going transmission. * @details This function calls a LLD function which ends a transfer earlier. * * @param[in] Channel Uart channel where the transmission shall be ended. * * @return E_OK: The transfer ended successfully * E_NOT_OK: The transfer didn't end successfully * */ Std_ReturnType Uart_Ipw_AbortSendingData(uint8 Channel) { Std_ReturnType TempStatus = (uint8)E_NOT_OK; uint8 HwUnit = Uart_Ipw_apChnConfig[Channel]->UartHwChannel; if (LPUART_IP == Uart_Ipw_apChnConfig[Channel]->UartIpType) { #ifdef UART_IPW_LPUART_HW_USING if (LPUART_UART_IP_STATUS_SUCCESS == Lpuart_Uart_Ip_AbortSendingData(HwUnit)) { TempStatus = (uint8)E_OK; } #endif /* #ifdef UART_IPW_LPUART_HW_USING */ } #ifdef UART_IPW_FLEXIO_HW_USING else { if (FLEXIO_UART_IP_STATUS_SUCCESS == Flexio_Uart_Ip_AbortTransferData(HwUnit)) { TempStatus = (uint8)E_OK; } } #endif /* #ifdef UART_IPW_FLEXIO_HW_USING */ return TempStatus; } /** * @internal * @brief Aborts an on-going reception. * @details This function calls a LLD function which ends a reception earlier. * * @param[in] Channel Uart channel where the reception shall be ended. * * @return E_OK: The reception ended successfully * E_NOT_OK: The reception didn't end successfully * */ Std_ReturnType Uart_Ipw_AbortReceivingData(uint8 Channel) { Std_ReturnType TempStatus = (uint8)E_NOT_OK; uint8 HwUnit = Uart_Ipw_apChnConfig[Channel]->UartHwChannel; if (LPUART_IP == Uart_Ipw_apChnConfig[Channel]->UartIpType) { #ifdef UART_IPW_LPUART_HW_USING if (LPUART_UART_IP_STATUS_SUCCESS == Lpuart_Uart_Ip_AbortReceivingData(HwUnit)) { TempStatus = (uint8)E_OK; } #endif /* #ifdef UART_IPW_LPUART_HW_USING */ } #ifdef UART_IPW_FLEXIO_HW_USING else { if (FLEXIO_UART_IP_STATUS_SUCCESS == Flexio_Uart_Ip_AbortTransferData(HwUnit)) { TempStatus = (uint8)E_OK; } } #endif /* #ifdef UART_IPW_FLEXIO_HW_USING */ return TempStatus; } /** * @internal * @brief Sets a tx buffer. * @details This function calls a LLD function which sets a buffer for continuos transmission. * * @param[in] Channel Uart channel where to set the buffer. * * @return void */ void Uart_Ipw_SetTxBuffer(uint8 Channel, const uint8 *Buffer, uint32 BufferSize) { uint8 HwUnit = Uart_Ipw_apChnConfig[Channel]->UartHwChannel; if (LPUART_IP == Uart_Ipw_apChnConfig[Channel]->UartIpType) { #ifdef UART_IPW_LPUART_HW_USING (void)Lpuart_Uart_Ip_SetTxBuffer(HwUnit, Buffer, BufferSize); #endif /* #ifdef UART_IPW_LPUART_HW_USING */ } #ifdef UART_IPW_FLEXIO_HW_USING else { (void)Flexio_Uart_Ip_SetTxBuffer(HwUnit, Buffer, BufferSize); } #endif /* #ifdef UART_IPW_FLEXIO_HW_USING */ } /** * @brief Sets a rx buffer. * @details This function calls a LLD function which sets a buffer for continuos reception. * * @param[in] Channel Uart channel where to set the buffer. * * @return void */ void Uart_Ipw_SetRxBuffer(uint8 Channel, uint8 *Buffer, uint32 BufferSize) { uint8 HwUnit = Uart_Ipw_apChnConfig[Channel]->UartHwChannel; if (LPUART_IP == Uart_Ipw_apChnConfig[Channel]->UartIpType) { #ifdef UART_IPW_LPUART_HW_USING (void)Lpuart_Uart_Ip_SetRxBuffer(HwUnit, Buffer, BufferSize); #endif /* #ifdef UART_IPW_LPUART_HW_USING */ } #ifdef UART_IPW_FLEXIO_HW_USING else { (void)Flexio_Uart_Ip_SetRxBuffer(HwUnit, Buffer, BufferSize); } #endif /* #ifdef UART_IPW_FLEXIO_HW_USING */ } /** * @internal * @brief Sends a buffer synchronously. * @details This function calls a LLD function which sends BufferSize bytes using polling method. * * @param[in] Channel Uart channel used for transmission. * @param[in] Buffer Buffer to send. * @param[in] BufferSize The number of bytes to send. * @param[in] Timeout The timeout value in us. * * * @return E_OK: Tranmission ended successfully * UART_STATUS_TIMEOUT: Tranmission has timeout * E_NOT_OK Tranmission didn't end successfully */ Std_ReturnType Uart_Ipw_SyncSend(uint8 Channel, const uint8 *Buffer, uint32 BufferSize, uint32 Timeout) { Std_ReturnType TempStatus = (uint8)E_NOT_OK; uint8 HwUnit = Uart_Ipw_apChnConfig[Channel]->UartHwChannel; /* LPUART is used */ if (LPUART_IP == Uart_Ipw_apChnConfig[Channel]->UartIpType) { #ifdef UART_IPW_LPUART_HW_USING Lpuart_Uart_Ip_StatusType u32LpuartIpStatus; u32LpuartIpStatus = Lpuart_Uart_Ip_SyncSend(HwUnit, Buffer, BufferSize, Timeout); if (LPUART_UART_IP_STATUS_SUCCESS == u32LpuartIpStatus) { TempStatus = (uint8)E_OK; } else if (LPUART_UART_IP_STATUS_TIMEOUT == u32LpuartIpStatus) { TempStatus = (uint8)UART_STATUS_TIMEOUT; } else { TempStatus = (uint8)E_NOT_OK; } #endif /* #ifdef UART_IPW_LPUART_HW_USING */ } #ifdef UART_IPW_FLEXIO_HW_USING else { Flexio_Uart_Ip_StatusType u32FlexioIpStatus; u32FlexioIpStatus = Flexio_Uart_Ip_SyncSend(HwUnit, Buffer, BufferSize, Timeout); if (FLEXIO_UART_IP_STATUS_SUCCESS == u32FlexioIpStatus) { TempStatus = (uint8)E_OK; } else if (FLEXIO_UART_IP_STATUS_TIMEOUT == u32FlexioIpStatus) { TempStatus = (uint8)UART_STATUS_TIMEOUT; } else { TempStatus = (uint8)E_NOT_OK; } } #endif /* #ifdef UART_IPW_FLEXIO_HW_USING */ return TempStatus; } /** * @internal * @brief Receives a buffer synchronously. * @details This function calls a LLD function which receives BufferSize bytes using polling method. * * @param[in] Channel Uart channel used for reception. * @param[in] Buffer Buffer to receive. * @param[in] BufferSize The number of bytes to receive. * @param[in] Timeout The timeout value in us. * * * @return E_OK: Reception ended successfully * E_NOT_OK: Reception didn't end successfully * UART_STATUS_TIMEOUT: Reception has timeout */ Std_ReturnType Uart_Ipw_SyncReceive(uint8 Channel, uint8 *Buffer, uint32 BufferSize, uint32 Timeout) { Std_ReturnType TempStatus = (uint8)E_NOT_OK; uint8 HwUnit = Uart_Ipw_apChnConfig[Channel]->UartHwChannel; /* LPUART is used */ if (LPUART_IP == Uart_Ipw_apChnConfig[Channel]->UartIpType) { #ifdef UART_IPW_LPUART_HW_USING Lpuart_Uart_Ip_StatusType u32LpuartIpStatus; u32LpuartIpStatus = Lpuart_Uart_Ip_SyncReceive(HwUnit, Buffer, BufferSize, Timeout); if (LPUART_UART_IP_STATUS_SUCCESS == u32LpuartIpStatus) { TempStatus = (uint8)E_OK; } else if (LPUART_UART_IP_STATUS_TIMEOUT == u32LpuartIpStatus) { TempStatus = (uint8)UART_STATUS_TIMEOUT; } else { TempStatus = (uint8)E_NOT_OK; } #endif /* #ifdef UART_IPW_LPUART_HW_USING */ } #ifdef UART_IPW_FLEXIO_HW_USING else { Flexio_Uart_Ip_StatusType u32FlexioIpStatus; u32FlexioIpStatus = Flexio_Uart_Ip_SyncReceive(HwUnit, Buffer, BufferSize, Timeout); if (FLEXIO_UART_IP_STATUS_SUCCESS == u32FlexioIpStatus) { TempStatus = (uint8)E_OK; } else if (FLEXIO_UART_IP_STATUS_TIMEOUT == u32FlexioIpStatus) { TempStatus = (uint8)UART_STATUS_TIMEOUT; } else { TempStatus = (uint8)E_NOT_OK; } } #endif /* #ifdef UART_IPW_FLEXIO_HW_USING */ return TempStatus; } /** * @internal * @brief Receives a buffer asynchronously. * @details This function calls a LLD function which receives BufferSize bytes using an asynchornous method. * * @param[in] Channel Uart channel used for reception. * @param[in] Buffer Buffer to receive. * @param[in] BufferSize The number of bytes to receive. * * * @return E_OK: Reception started successfully E_NOT_OK: Reception didn't start successfully */ Std_ReturnType Uart_Ipw_AsyncReceive(uint8 Channel, uint8 *Buffer, uint32 BufferSize) { Std_ReturnType TempStatus = (uint8)E_NOT_OK; uint8 HwUnit = Uart_Ipw_apChnConfig[Channel]->UartHwChannel; /* LPUART is used */ if (LPUART_IP == Uart_Ipw_apChnConfig[Channel]->UartIpType) { #ifdef UART_IPW_LPUART_HW_USING if (LPUART_UART_IP_STATUS_SUCCESS == Lpuart_Uart_Ip_AsyncReceive(HwUnit, Buffer, BufferSize)) { TempStatus = (uint8)E_OK; } #endif /* #ifdef UART_IPW_LPUART_HW_USING */ } #ifdef UART_IPW_FLEXIO_HW_USING else { if (FLEXIO_UART_IP_STATUS_SUCCESS == Flexio_Uart_Ip_AsyncReceive(HwUnit, Buffer, BufferSize)) { TempStatus = (uint8)E_OK; } } #endif /* #ifdef UART_IPW_FLEXIO_HW_USING */ return TempStatus; } /** * @internal * @brief Sends a buffer asynchronously. * @details This function calls a LLD function which sends BufferSize bytes using an asynchornous method. * * @param[in] Channel Uart channel used for transmission. * @param[in] Buffer Buffer to send. * @param[in] BufferSize The number of bytes to send. * * * @return E_OK: Transmission started successfully E_NOT_OK: Transmission didn't start successfully */ Std_ReturnType Uart_Ipw_AsyncSend(uint8 Channel, const uint8 *Buffer, uint32 BufferSize) { Std_ReturnType TempStatus = (uint8)E_NOT_OK; uint8 HwUnit = Uart_Ipw_apChnConfig[Channel]->UartHwChannel; /* LPUART is used */ if (LPUART_IP == Uart_Ipw_apChnConfig[Channel]->UartIpType) { #ifdef UART_IPW_LPUART_HW_USING if (LPUART_UART_IP_STATUS_SUCCESS == Lpuart_Uart_Ip_AsyncSend(HwUnit, Buffer, BufferSize)) { TempStatus = (uint8)E_OK; } #endif /* #ifdef UART_IPW_LPUART_HW_USING */ } #ifdef UART_IPW_FLEXIO_HW_USING else { if (FLEXIO_UART_IP_STATUS_SUCCESS == Flexio_Uart_Ip_AsyncSend(HwUnit, Buffer, BufferSize)) { TempStatus = (uint8)E_OK; } } #endif /* #ifdef UART_IPW_FLEXIO_HW_USING */ return TempStatus; } /** * @internal * @brief Retrieves the status of the previous transfer. * @details This function calls a LLD function which retrieves the status of the previous transfer * and the number of the remaining bytes to send. * * @param[in] Channel Uart channel. * @param[out] BytesRemaining The pointer where to write the number of remaining bytes * * * @return UART_NO_ERR0R: The previous transfer ended successfully UART_STATUS_OPERATION_ONGOING The transfer is still on going UART_STATUS_ABORTED The previous transfer was aborted UART_STATUS_TIMEOUT The previous transfer was timeout */ Uart_StatusType Uart_Ipw_GetTransmitStatus(uint8 Channel, uint32 *BytesRemaining) { Uart_StatusType TempStatus = UART_STATUS_TIMEOUT; uint8 HwUnit = Uart_Ipw_apChnConfig[Channel]->UartHwChannel; if (LPUART_IP == Uart_Ipw_apChnConfig[Channel]->UartIpType) { #ifdef UART_IPW_LPUART_HW_USING Lpuart_Uart_Ip_StatusType u32LpuartIpStatus; u32LpuartIpStatus = Lpuart_Uart_Ip_GetTransmitStatus(HwUnit, BytesRemaining); TempStatus = Uart_Ipw_LpuartConvertStatus(u32LpuartIpStatus); #endif /* #ifdef UART_IPW_LPUART_HW_USING */ } #ifdef UART_IPW_FLEXIO_HW_USING else { Flexio_Uart_Ip_StatusType u32FlexioIpStatus; u32FlexioIpStatus = Flexio_Uart_Ip_GetStatus(HwUnit, BytesRemaining); TempStatus = Uart_Ipw_FlexioConvertStatus(u32FlexioIpStatus); } #endif /* #ifdef UART_IPW_FLEXIO_HW_USING */ return TempStatus; } /** * @internal * @brief Retrieves the status of the previous reception. * @details This function calls a LLD function which retrieves the status of the previous reception * and the number of the remaining bytes to receive. * * @param[in] Channel Uart channel. * @param[out] BytesRemaining The pointer where to write the number of remaining bytes * * * @return UART_NO_ERR0R: The previous transfer ended successfully UART_STATUS_OPERATION_ONGOING The reception is still on going UART_STATUS_ABORTED The previous reception was aborted UART_STATUS_FRAMING_ERROR Uart framing error UART_STATUS_RX_OVERRUN_ERROR Uart overrun error UART_STATUS_PARITY_ERROR Uart overrun error UART_STATUS_TIMEOUT Uart operation has timeout */ Uart_StatusType Uart_Ipw_GetReceiveStatus(uint8 Channel, uint32 *BytesRemaining) { Uart_StatusType TempStatus = UART_STATUS_TIMEOUT; uint8 HwUnit = Uart_Ipw_apChnConfig[Channel]->UartHwChannel; if (LPUART_IP == Uart_Ipw_apChnConfig[Channel]->UartIpType) { #ifdef UART_IPW_LPUART_HW_USING Lpuart_Uart_Ip_StatusType u32LpuartIpStatus; u32LpuartIpStatus = Lpuart_Uart_Ip_GetReceiveStatus(HwUnit, BytesRemaining); TempStatus = Uart_Ipw_LpuartConvertStatus(u32LpuartIpStatus); #endif /* #ifdef UART_IPW_LPUART_HW_USING */ } #ifdef UART_IPW_FLEXIO_HW_USING else { Flexio_Uart_Ip_StatusType u32FlexioIpStatus; u32FlexioIpStatus = Flexio_Uart_Ip_GetStatus(HwUnit, BytesRemaining); TempStatus = Uart_Ipw_FlexioConvertStatus(u32FlexioIpStatus); } #endif /* #ifdef UART_IPW_FLEXIO_HW_USING */ return TempStatus; } #ifdef UART_IPW_LPUART_HW_USING /** * @internal * @brief Convert Uart IP layer return status to standard return status. * @details This function receives Uart IP layer return status and convert to standard return status. * @param[in] Status Uart IP status * * * @return Standard status * This is not a public API as it is called from other driver functions. */ static Uart_StatusType Uart_Ipw_LpuartConvertStatus(Lpuart_Uart_Ip_StatusType Status) { Uart_StatusType TempStatus = UART_STATUS_TIMEOUT; switch (Status) { case LPUART_UART_IP_STATUS_SUCCESS: TempStatus = UART_STATUS_NO_ERROR; break; case LPUART_UART_IP_STATUS_BUSY: TempStatus = UART_STATUS_OPERATION_ONGOING; break; case LPUART_UART_IP_STATUS_ABORTED: TempStatus = UART_STATUS_ABORTED; break; case LPUART_UART_IP_STATUS_TIMEOUT: TempStatus = UART_STATUS_TIMEOUT; break; case LPUART_UART_IP_STATUS_FRAMING_ERROR: TempStatus = UART_STATUS_FRAMING_ERROR; break; case LPUART_UART_IP_STATUS_RX_OVERRUN: TempStatus = UART_STATUS_RX_OVERRUN_ERROR; break; case LPUART_UART_IP_STATUS_NOISE_ERROR: TempStatus = UART_STATUS_NOISE_ERROR; break; case LPUART_UART_IP_STATUS_PARITY_ERROR: TempStatus = UART_STATUS_PARITY_ERROR; break; default: TempStatus = UART_STATUS_DMA_ERROR; break; } return TempStatus; } /** * @internal * @brief Convert Uart HLD baudrate type to IP baudrate type. * @details This function receives HLD baudrate and convert to IP baudrate. * @param[in] Baudrate Uart HLD Baudrate * * * @return IP baudrate * This is not a public API as it is called from other driver functions. */ static Lpuart_Uart_Ip_BaudrateType Uart_Ipw_LpuartConvertBaudrateType(Uart_BaudrateType Baudrate) { Lpuart_Uart_Ip_BaudrateType TempBaud = LPUART_UART_BAUDRATE_1200; switch (Baudrate) { case UART_BAUDRATE_1200: TempBaud = LPUART_UART_BAUDRATE_1200; break; case UART_BAUDRATE_2400: TempBaud = LPUART_UART_BAUDRATE_2400; break; case UART_BAUDRATE_4800: TempBaud = LPUART_UART_BAUDRATE_4800; break; case UART_BAUDRATE_9600: TempBaud = LPUART_UART_BAUDRATE_9600; break; case UART_BAUDRATE_14400: TempBaud = LPUART_UART_BAUDRATE_14400; break; case UART_BAUDRATE_19200: TempBaud = LPUART_UART_BAUDRATE_19200; break; case UART_BAUDRATE_28800: TempBaud = LPUART_UART_BAUDRATE_28800; break; case UART_BAUDRATE_38400: TempBaud = LPUART_UART_BAUDRATE_38400; break; case UART_BAUDRATE_57600: TempBaud = LPUART_UART_BAUDRATE_57600; break; case UART_BAUDRATE_115200: TempBaud = LPUART_UART_BAUDRATE_115200; break; case UART_BAUDRATE_230400: TempBaud = LPUART_UART_BAUDRATE_230400; break; case UART_BAUDRATE_460800: TempBaud = LPUART_UART_BAUDRATE_460800; break; case UART_BAUDRATE_921600: TempBaud = LPUART_UART_BAUDRATE_921600; break; case UART_BAUDRATE_1843200: TempBaud = LPUART_UART_BAUDRATE_1843200; break; default: /* Nothing to do */ break; } return TempBaud; } #if (UART_CALLBACK_DECLARED == STD_ON) /** * @internal * @brief Convert Uart IP Event type to HLD Event type. * @details This function receives IP Event and convert to HLD Event. * @param[in] Event Uart IP Event * * * @return HLD Event * This is not a public API as it is called from other driver functions. */ static Uart_EventType Uart_Ipw_LpuartConvertEventType(Lpuart_Uart_Ip_EventType Event) { Uart_EventType TempEvent = UART_EVENT_ERROR; switch (Event) { case LPUART_UART_IP_EVENT_RX_FULL: TempEvent = UART_EVENT_RX_FULL; break; case LPUART_UART_IP_EVENT_TX_EMPTY: TempEvent = UART_EVENT_TX_EMPTY; break; case LPUART_UART_IP_EVENT_END_TRANSFER: TempEvent = UART_EVENT_END_TRANSFER; break; case LPUART_UART_IP_EVENT_ERROR: TempEvent = UART_EVENT_ERROR; break; case LPUART_UART_IP_EVENT_RECV_IDLE: //zhengchao TempEvent = UART_EVENT_IDLE; break; default: /* Nothing to do */ break; } return TempEvent; } #endif /* UART_CALLBACK_DECLARED == STD_ON */ #endif /* #ifdef UART_IPW_LPUART_HW_USING */ #ifdef UART_IPW_FLEXIO_HW_USING /** * @internal * @brief Convert Uart IP layer return status to standard return status. * @details This function receives Uart IP layer return status and convert to standard return status. * @param[in] Status Uart IP status * * * @return Standard status * This is not a public API as it is called from other driver functions. */ static Uart_StatusType Uart_Ipw_FlexioConvertStatus(Flexio_Uart_Ip_StatusType Status) { Uart_StatusType TempStatus = UART_STATUS_TIMEOUT; switch (Status) { case FLEXIO_UART_IP_STATUS_SUCCESS: TempStatus = UART_STATUS_NO_ERROR; break; case FLEXIO_UART_IP_STATUS_BUSY: TempStatus = UART_STATUS_OPERATION_ONGOING; break; case FLEXIO_UART_IP_STATUS_ABORTED: TempStatus = UART_STATUS_ABORTED; break; case FLEXIO_UART_IP_STATUS_TIMEOUT: TempStatus = UART_STATUS_TIMEOUT; break; case FLEXIO_UART_IP_STATUS_RX_OVERRUN: TempStatus = UART_STATUS_RX_OVERRUN_ERROR; break; default: TempStatus = UART_STATUS_DMA_ERROR; break; } return TempStatus; } /** * @internal * @brief Convert Uart HLD baudrate type to IP baudrate type. * @details This function receives HLD baudrate and convert to IP baudrate. * @param[in] Baudrate Uart HLD Baudrate * * * @return IP baudrate * This is not a public API as it is called from other driver functions. */ static Flexio_Uart_Ip_BaudrateType Uart_Ipw_FlexioConvertBaudrateType(Uart_BaudrateType Baudrate) { Flexio_Uart_Ip_BaudrateType TempBaud = FLEXIO_UART_BAUDRATE_1200; switch (Baudrate) { case UART_BAUDRATE_1200: TempBaud = FLEXIO_UART_BAUDRATE_1200; break; case UART_BAUDRATE_2400: TempBaud = FLEXIO_UART_BAUDRATE_2400; break; case UART_BAUDRATE_4800: TempBaud = FLEXIO_UART_BAUDRATE_4800; break; case UART_BAUDRATE_9600: TempBaud = FLEXIO_UART_BAUDRATE_9600; break; case UART_BAUDRATE_14400: TempBaud = FLEXIO_UART_BAUDRATE_14400; break; case UART_BAUDRATE_19200: TempBaud = FLEXIO_UART_BAUDRATE_19200; break; case UART_BAUDRATE_28800: TempBaud = FLEXIO_UART_BAUDRATE_28800; break; case UART_BAUDRATE_38400: TempBaud = FLEXIO_UART_BAUDRATE_38400; break; case UART_BAUDRATE_57600: TempBaud = FLEXIO_UART_BAUDRATE_57600; break; case UART_BAUDRATE_115200: TempBaud = FLEXIO_UART_BAUDRATE_115200; break; case UART_BAUDRATE_230400: TempBaud = FLEXIO_UART_BAUDRATE_230400; break; case UART_BAUDRATE_460800: TempBaud = FLEXIO_UART_BAUDRATE_460800; break; case UART_BAUDRATE_921600: TempBaud = FLEXIO_UART_BAUDRATE_921600; break; case UART_BAUDRATE_1843200: TempBaud = FLEXIO_UART_BAUDRATE_1843200; break; default: /* Nothing to do */ break; } return TempBaud; } #if (UART_CALLBACK_DECLARED == STD_ON) /** * @internal * @brief Convert Uart IP Event type to HLD Event type. * @details This function receives IP Event and convert to HLD Event. * @param[in] Event Uart IP Event * * * @return HLD Event * This is not a public API as it is called from other driver functions. */ static Uart_EventType Uart_Ipw_FlexioConvertEventType(Flexio_Uart_Ip_EventType Event) { Uart_EventType TempEvent = UART_EVENT_ERROR; switch (Event) { case FLEXIO_UART_IP_EVENT_RX_FULL: TempEvent = UART_EVENT_RX_FULL; break; case FLEXIO_UART_IP_EVENT_TX_EMPTY: TempEvent = UART_EVENT_TX_EMPTY; break; case FLEXIO_UART_IP_EVENT_END_TRANSFER: TempEvent = UART_EVENT_END_TRANSFER; break; case FLEXIO_UART_IP_EVENT_ERROR: TempEvent = UART_EVENT_ERROR; break; default: /* Nothing to do */ break; } return TempEvent; } #endif /* UART_CALLBACK_DECLARED == STD_ON */ #endif /* #ifdef UART_IPW_FLEXIO_HW_USING */ #if (UART_CALLBACK_DECLARED == STD_ON) #ifdef UART_IPW_LPUART_HW_USING /** * @internal * @internal * @brief Low level driver callback for Lpuart * @details This function is called by the low level driver in the ISR. * * * This is not a public API as it is called from other driver functions. */ void Uart_Ipw_LpuartCallback(const uint8 HwInstance, const Lpuart_Uart_Ip_EventType Event, void *UserData) { uint8 Channel = (uint8)Uart_Ipw_s8HwMapping[HwInstance]; Uart_EventType ConvertEvent = Uart_Ipw_LpuartConvertEventType(Event); (void)UserData; if (Uart_Ipw_apChnConfig[Channel]->Callback != NULL_PTR) { Uart_Ipw_apChnConfig[Channel]->Callback(Channel, ConvertEvent); } } #endif /* #ifdef UART_IPW_LPUART_HW_USING */ #ifdef UART_IPW_FLEXIO_HW_USING /** * @internal * @brief Low level driver Tx or Rx callback for Flexio * @details This function is called by the low level driver in the ISR. * * * This is not a public API as it is called from other driver functions. */ void Uart_Ipw_FlexioTransferCallback(const uint32 HwChannel, const Flexio_Uart_Ip_EventType Event, void *UserData) { uint8 Channel = (uint8)Uart_Ipw_s8HwMapping[UART_NUMBER_OF_INSTANCES - FLEXIO_UART_IP_NUMBER_OF_SHIFTER_AND_TIMER + HwChannel]; Uart_EventType ConvertEvent = Uart_Ipw_FlexioConvertEventType(Event); (void)UserData; if (Uart_Ipw_apChnConfig[Channel]->Callback != NULL_PTR) { Uart_Ipw_apChnConfig[Channel]->Callback(Channel, ConvertEvent); } } #endif /* #ifdef UART_IPW_FLEXIO_HW_USING */ #endif /* UART_CALLBACK_DECLARED == STD_ON */ #define UART_STOP_SEC_CODE #include "Uart_MemMap.h" #ifdef __cplusplus } /** @} */ #endif