stm32h7/include/stm32h7xx_hal_uart_ex.h

0001 /**
0002   ******************************************************************************
0003   * @file    stm32h7xx_hal_uart_ex.h
0004   * @author  MCD Application Team
0005   * @brief   Header file of UART HAL Extended module.
0006   ******************************************************************************
0007   * @attention
0008   *
0009   * Copyright (c) 2017 STMicroelectronics.
0010   * All rights reserved.
0011   *
0012   * This software is licensed under terms that can be found in the LICENSE file
0013   * in the root directory of this software component.
0014   * If no LICENSE file comes with this software, it is provided AS-IS.
0015   *
0016   ******************************************************************************
0017   */
0018
0019 /* Define to prevent recursive inclusion -------------------------------------*/
0020 #ifndef STM32H7xx_HAL_UART_EX_H
0021 #define STM32H7xx_HAL_UART_EX_H
0022
0023 #ifdef __cplusplus
0024 extern "C" {
0025 #endif
0026
0027 /* Includes ------------------------------------------------------------------*/
0028 #include "stm32h7xx_hal_def.h"
0029
0030 /** @addtogroup STM32H7xx_HAL_Driver
0031   * @{
0032   */
0033
0034 /** @addtogroup UARTEx
0035   * @{
0036   */
0037
0038 /* Exported types ------------------------------------------------------------*/
0039 /** @defgroup UARTEx_Exported_Types UARTEx Exported Types
0040   * @ingroup RTEMSBSPsARMSTM32H7
0041   * @{
0042   */
0043
0044 /**
0045   * @brief  UART wake up from stop mode parameters
0046   */
0047 typedef struct
0048 {
0049   uint32_t WakeUpEvent;        /*!< Specifies which event will activate the Wakeup from Stop mode flag (WUF).
0050                                     This parameter can be a value of @ref UART_WakeUp_from_Stop_Selection.
0051                                     If set to UART_WAKEUP_ON_ADDRESS, the two other fields below must
0052                                     be filled up. */
0053
0054   uint16_t AddressLength;      /*!< Specifies whether the address is 4 or 7-bit long.
0055                                     This parameter can be a value of @ref UARTEx_WakeUp_Address_Length.  */
0056
0057   uint8_t Address;             /*!< UART/USART node address (7-bit long max). */
0058 } UART_WakeUpTypeDef;
0059
0060 /**
0061   * @}
0062   */
0063
0064 /* Exported constants --------------------------------------------------------*/
0065 /** @defgroup UARTEx_Exported_Constants UARTEx Exported Constants
0066   * @ingroup RTEMSBSPsARMSTM32H7
0067   * @{
0068   */
0069
0070 /** @defgroup UARTEx_Word_Length UARTEx Word Length
0071   * @ingroup RTEMSBSPsARMSTM32H7
0072   * @{
0073   */
0074 #define UART_WORDLENGTH_7B          USART_CR1_M1   /*!< 7-bit long UART frame */
0075 #define UART_WORDLENGTH_8B          0x00000000U    /*!< 8-bit long UART frame */
0076 #define UART_WORDLENGTH_9B          USART_CR1_M0   /*!< 9-bit long UART frame */
0077 /**
0078   * @}
0079   */
0080
0081 /** @defgroup UARTEx_WakeUp_Address_Length UARTEx WakeUp Address Length
0082   * @ingroup RTEMSBSPsARMSTM32H7
0083   * @{
0084   */
0085 #define UART_ADDRESS_DETECT_4B      0x00000000U      /*!< 4-bit long wake-up address */
0086 #define UART_ADDRESS_DETECT_7B      USART_CR2_ADDM7  /*!< 7-bit long wake-up address */
0087 /**
0088   * @}
0089   */
0090
0091 /** @defgroup UARTEx_FIFO_mode UARTEx FIFO mode
0092   * @ingroup RTEMSBSPsARMSTM32H7
0093   * @brief    UART FIFO mode
0094   * @{
0095   */
0096 #define UART_FIFOMODE_DISABLE       0x00000000U       /*!< FIFO mode disable */
0097 #define UART_FIFOMODE_ENABLE        USART_CR1_FIFOEN  /*!< FIFO mode enable  */
0098 /**
0099   * @}
0100   */
0101
0102 /** @defgroup UARTEx_TXFIFO_threshold_level UARTEx TXFIFO threshold level
0103   * @ingroup RTEMSBSPsARMSTM32H7
0104   * @brief    UART TXFIFO threshold level
0105   * @{
0106   */
0107 #define UART_TXFIFO_THRESHOLD_1_8   0x00000000U                               /*!< TX FIFO reaches 1/8 of its depth */
0108 #define UART_TXFIFO_THRESHOLD_1_4   USART_CR3_TXFTCFG_0                       /*!< TX FIFO reaches 1/4 of its depth */
0109 #define UART_TXFIFO_THRESHOLD_1_2   USART_CR3_TXFTCFG_1                       /*!< TX FIFO reaches 1/2 of its depth */
0110 #define UART_TXFIFO_THRESHOLD_3_4   (USART_CR3_TXFTCFG_0|USART_CR3_TXFTCFG_1) /*!< TX FIFO reaches 3/4 of its depth */
0111 #define UART_TXFIFO_THRESHOLD_7_8   USART_CR3_TXFTCFG_2                       /*!< TX FIFO reaches 7/8 of its depth */
0112 #define UART_TXFIFO_THRESHOLD_8_8   (USART_CR3_TXFTCFG_2|USART_CR3_TXFTCFG_0) /*!< TX FIFO becomes empty            */
0113 /**
0114   * @}
0115   */
0116
0117 /** @defgroup UARTEx_RXFIFO_threshold_level UARTEx RXFIFO threshold level
0118   * @ingroup RTEMSBSPsARMSTM32H7
0119   * @brief    UART RXFIFO threshold level
0120   * @{
0121   */
0122 #define UART_RXFIFO_THRESHOLD_1_8   0x00000000U                               /*!< RX FIFO reaches 1/8 of its depth */
0123 #define UART_RXFIFO_THRESHOLD_1_4   USART_CR3_RXFTCFG_0                       /*!< RX FIFO reaches 1/4 of its depth */
0124 #define UART_RXFIFO_THRESHOLD_1_2   USART_CR3_RXFTCFG_1                       /*!< RX FIFO reaches 1/2 of its depth */
0125 #define UART_RXFIFO_THRESHOLD_3_4   (USART_CR3_RXFTCFG_0|USART_CR3_RXFTCFG_1) /*!< RX FIFO reaches 3/4 of its depth */
0126 #define UART_RXFIFO_THRESHOLD_7_8   USART_CR3_RXFTCFG_2                       /*!< RX FIFO reaches 7/8 of its depth */
0127 #define UART_RXFIFO_THRESHOLD_8_8   (USART_CR3_RXFTCFG_2|USART_CR3_RXFTCFG_0) /*!< RX FIFO becomes full             */
0128 /**
0129   * @}
0130   */
0131
0132 /**
0133   * @}
0134   */
0135
0136 /* Exported macros -----------------------------------------------------------*/
0137 /* Exported functions --------------------------------------------------------*/
0138 /** @addtogroup UARTEx_Exported_Functions
0139   * @{
0140   */
0141
0142 /** @addtogroup UARTEx_Exported_Functions_Group1
0143   * @{
0144   */
0145
0146 /* Initialization and de-initialization functions  ****************************/
0147 HAL_StatusTypeDef HAL_RS485Ex_Init(UART_HandleTypeDef *huart, uint32_t Polarity, uint32_t AssertionTime,
0148                                    uint32_t DeassertionTime);
0149
0150 /**
0151   * @}
0152   */
0153
0154 /** @addtogroup UARTEx_Exported_Functions_Group2
0155   * @{
0156   */
0157
0158 void HAL_UARTEx_WakeupCallback(UART_HandleTypeDef *huart);
0159
0160 void HAL_UARTEx_RxFifoFullCallback(UART_HandleTypeDef *huart);
0161 void HAL_UARTEx_TxFifoEmptyCallback(UART_HandleTypeDef *huart);
0162
0163 /**
0164   * @}
0165   */
0166
0167 /** @addtogroup UARTEx_Exported_Functions_Group3
0168   * @{
0169   */
0170
0171 /* Peripheral Control functions  **********************************************/
0172 HAL_StatusTypeDef HAL_UARTEx_StopModeWakeUpSourceConfig(UART_HandleTypeDef *huart, UART_WakeUpTypeDef WakeUpSelection);
0173 HAL_StatusTypeDef HAL_UARTEx_EnableStopMode(UART_HandleTypeDef *huart);
0174 HAL_StatusTypeDef HAL_UARTEx_DisableStopMode(UART_HandleTypeDef *huart);
0175
0176 HAL_StatusTypeDef HAL_MultiProcessorEx_AddressLength_Set(UART_HandleTypeDef *huart, uint32_t AddressLength);
0177
0178 HAL_StatusTypeDef HAL_UARTEx_EnableFifoMode(UART_HandleTypeDef *huart);
0179 HAL_StatusTypeDef HAL_UARTEx_DisableFifoMode(UART_HandleTypeDef *huart);
0180 HAL_StatusTypeDef HAL_UARTEx_SetTxFifoThreshold(UART_HandleTypeDef *huart, uint32_t Threshold);
0181 HAL_StatusTypeDef HAL_UARTEx_SetRxFifoThreshold(UART_HandleTypeDef *huart, uint32_t Threshold);
0182
0183 HAL_StatusTypeDef HAL_UARTEx_ReceiveToIdle(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint16_t *RxLen,
0184                                            uint32_t Timeout);
0185 HAL_StatusTypeDef HAL_UARTEx_ReceiveToIdle_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size);
0186 HAL_StatusTypeDef HAL_UARTEx_ReceiveToIdle_DMA(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size);
0187
0188 HAL_UART_RxEventTypeTypeDef HAL_UARTEx_GetRxEventType(const UART_HandleTypeDef *huart);
0189
0190
0191 /**
0192   * @}
0193   */
0194
0195 /**
0196   * @}
0197   */
0198
0199 /* Private macros ------------------------------------------------------------*/
0200 /** @defgroup UARTEx_Private_Macros UARTEx Private Macros
0201   * @ingroup RTEMSBSPsARMSTM32H7
0202   * @{
0203   */
0204
0205 /** @brief  Report the UART clock source.
0206   * @param  __HANDLE__ specifies the UART Handle.
0207   * @param  __CLOCKSOURCE__ output variable.
0208   * @retval UART clocking source, written in __CLOCKSOURCE__.
0209   */
0210 #if defined(UART9) && defined(USART10)
0211 #define UART_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__)       \
0212   do {                                                        \
0213     if((__HANDLE__)->Instance == USART1)                      \
0214     {                                                         \
0215       switch(__HAL_RCC_GET_USART1_SOURCE())                   \
0216       {                                                       \
0217         case RCC_USART1CLKSOURCE_D2PCLK2:                     \
0218           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK2;       \
0219           break;                                              \
0220         case RCC_USART1CLKSOURCE_PLL2:                        \
0221           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2;          \
0222           break;                                              \
0223         case RCC_USART1CLKSOURCE_PLL3:                        \
0224           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3;          \
0225           break;                                              \
0226         case RCC_USART1CLKSOURCE_HSI:                         \
0227           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \
0228           break;                                              \
0229         case RCC_USART1CLKSOURCE_CSI:                         \
0230           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI;           \
0231           break;                                              \
0232         case RCC_USART1CLKSOURCE_LSE:                         \
0233           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \
0234           break;                                              \
0235         default:                                              \
0236           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \
0237           break;                                              \
0238       }                                                       \
0239     }                                                         \
0240     else if((__HANDLE__)->Instance == USART2)                 \
0241     {                                                         \
0242       switch(__HAL_RCC_GET_USART2_SOURCE())                   \
0243       {                                                       \
0244         case RCC_USART2CLKSOURCE_D2PCLK1:                     \
0245           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK1;       \
0246           break;                                              \
0247         case RCC_USART2CLKSOURCE_PLL2:                        \
0248           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2;          \
0249           break;                                              \
0250         case RCC_USART2CLKSOURCE_PLL3:                        \
0251           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3;          \
0252           break;                                              \
0253         case RCC_USART2CLKSOURCE_HSI:                         \
0254           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \
0255           break;                                              \
0256         case RCC_USART2CLKSOURCE_CSI:                         \
0257           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI;           \
0258           break;                                              \
0259         case RCC_USART2CLKSOURCE_LSE:                         \
0260           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \
0261           break;                                              \
0262         default:                                              \
0263           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \
0264           break;                                              \
0265       }                                                       \
0266     }                                                         \
0267     else if((__HANDLE__)->Instance == USART3)                 \
0268     {                                                         \
0269       switch(__HAL_RCC_GET_USART3_SOURCE())                   \
0270       {                                                       \
0271         case RCC_USART3CLKSOURCE_D2PCLK1:                     \
0272           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK1;       \
0273           break;                                              \
0274         case RCC_USART3CLKSOURCE_PLL2:                        \
0275           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2;          \
0276           break;                                              \
0277         case RCC_USART3CLKSOURCE_PLL3:                        \
0278           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3;          \
0279           break;                                              \
0280         case RCC_USART3CLKSOURCE_HSI:                         \
0281           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \
0282           break;                                              \
0283         case RCC_USART3CLKSOURCE_CSI:                         \
0284           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI;           \
0285           break;                                              \
0286         case RCC_USART3CLKSOURCE_LSE:                         \
0287           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \
0288           break;                                              \
0289         default:                                              \
0290           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \
0291           break;                                              \
0292       }                                                       \
0293     }                                                         \
0294     else if((__HANDLE__)->Instance == UART4)                  \
0295     {                                                         \
0296       switch(__HAL_RCC_GET_UART4_SOURCE())                    \
0297       {                                                       \
0298         case RCC_UART4CLKSOURCE_D2PCLK1:                      \
0299           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK1;       \
0300           break;                                              \
0301         case RCC_UART4CLKSOURCE_PLL2:                         \
0302           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2;          \
0303           break;                                              \
0304         case RCC_UART4CLKSOURCE_PLL3:                         \
0305           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3;          \
0306           break;                                              \
0307         case RCC_UART4CLKSOURCE_HSI:                          \
0308           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \
0309           break;                                              \
0310         case RCC_UART4CLKSOURCE_CSI:                          \
0311           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI;           \
0312           break;                                              \
0313         case RCC_UART4CLKSOURCE_LSE:                          \
0314           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \
0315           break;                                              \
0316         default:                                              \
0317           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \
0318           break;                                              \
0319       }                                                       \
0320     }                                                         \
0321     else if ((__HANDLE__)->Instance == UART5)                 \
0322     {                                                         \
0323       switch(__HAL_RCC_GET_UART5_SOURCE())                    \
0324       {                                                       \
0325         case RCC_UART5CLKSOURCE_D2PCLK1:                      \
0326           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK1;       \
0327           break;                                              \
0328         case RCC_UART5CLKSOURCE_PLL2:                         \
0329           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2;          \
0330           break;                                              \
0331         case RCC_UART5CLKSOURCE_PLL3:                         \
0332           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3;          \
0333           break;                                              \
0334         case RCC_UART5CLKSOURCE_HSI:                          \
0335           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \
0336           break;                                              \
0337         case RCC_UART5CLKSOURCE_CSI:                          \
0338           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI;           \
0339           break;                                              \
0340         case RCC_UART5CLKSOURCE_LSE:                          \
0341           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \
0342           break;                                              \
0343         default:                                              \
0344           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \
0345           break;                                              \
0346       }                                                       \
0347     }                                                         \
0348     else if((__HANDLE__)->Instance == USART6)                 \
0349     {                                                         \
0350       switch(__HAL_RCC_GET_USART6_SOURCE())                   \
0351       {                                                       \
0352         case RCC_USART6CLKSOURCE_D2PCLK2:                     \
0353           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK2;       \
0354           break;                                              \
0355         case RCC_USART6CLKSOURCE_PLL2:                        \
0356           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2;          \
0357           break;                                              \
0358         case RCC_USART6CLKSOURCE_PLL3:                        \
0359           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3;          \
0360           break;                                              \
0361         case RCC_USART6CLKSOURCE_HSI:                         \
0362           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \
0363           break;                                              \
0364         case RCC_USART6CLKSOURCE_CSI:                         \
0365           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI;           \
0366           break;                                              \
0367         case RCC_USART6CLKSOURCE_LSE:                         \
0368           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \
0369           break;                                              \
0370         default:                                              \
0371           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \
0372           break;                                              \
0373       }                                                       \
0374     }                                                         \
0375     else if((__HANDLE__)->Instance == UART7)                  \
0376     {                                                         \
0377       switch(__HAL_RCC_GET_UART7_SOURCE())                    \
0378       {                                                       \
0379         case RCC_UART7CLKSOURCE_D2PCLK1:                      \
0380           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK1;       \
0381           break;                                              \
0382         case RCC_UART7CLKSOURCE_PLL2:                         \
0383           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2;          \
0384           break;                                              \
0385         case RCC_UART7CLKSOURCE_PLL3:                         \
0386           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3;          \
0387           break;                                              \
0388         case RCC_UART7CLKSOURCE_HSI:                          \
0389           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \
0390           break;                                              \
0391         case RCC_UART7CLKSOURCE_CSI:                          \
0392           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI;           \
0393           break;                                              \
0394         case RCC_UART7CLKSOURCE_LSE:                          \
0395           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \
0396           break;                                              \
0397         default:                                              \
0398           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \
0399           break;                                              \
0400       }                                                       \
0401     }                                                         \
0402     else if((__HANDLE__)->Instance == UART8)                  \
0403     {                                                         \
0404       switch(__HAL_RCC_GET_UART8_SOURCE())                    \
0405       {                                                       \
0406         case RCC_UART8CLKSOURCE_D2PCLK1:                      \
0407           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK1;       \
0408           break;                                              \
0409         case RCC_UART8CLKSOURCE_PLL2:                         \
0410           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2;          \
0411           break;                                              \
0412         case RCC_UART8CLKSOURCE_PLL3:                         \
0413           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3;          \
0414           break;                                              \
0415         case RCC_UART8CLKSOURCE_HSI:                          \
0416           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \
0417           break;                                              \
0418         case RCC_UART8CLKSOURCE_CSI:                          \
0419           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI;           \
0420           break;                                              \
0421         case RCC_UART8CLKSOURCE_LSE:                          \
0422           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \
0423           break;                                              \
0424         default:                                              \
0425           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \
0426           break;                                              \
0427       }                                                       \
0428     }                                                         \
0429     else if((__HANDLE__)->Instance == UART9)                  \
0430     {                                                         \
0431       switch(__HAL_RCC_GET_UART9_SOURCE())                    \
0432       {                                                       \
0433         case RCC_UART9CLKSOURCE_D2PCLK2:                      \
0434           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK2;       \
0435           break;                                              \
0436         case RCC_UART9CLKSOURCE_PLL2:                         \
0437           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2;          \
0438           break;                                              \
0439         case RCC_UART9CLKSOURCE_PLL3:                         \
0440           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3;          \
0441           break;                                              \
0442         case RCC_UART9CLKSOURCE_HSI:                          \
0443           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \
0444           break;                                              \
0445         case RCC_UART9CLKSOURCE_CSI:                          \
0446           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI;           \
0447           break;                                              \
0448         case RCC_UART9CLKSOURCE_LSE:                          \
0449           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \
0450           break;                                              \
0451         default:                                              \
0452           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \
0453           break;                                              \
0454       }                                                       \
0455     }                                                         \
0456     else if((__HANDLE__)->Instance == USART10)                \
0457     {                                                         \
0458       switch(__HAL_RCC_GET_USART10_SOURCE())                  \
0459       {                                                       \
0460         case RCC_USART10CLKSOURCE_D2PCLK2:                    \
0461           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK2;       \
0462           break;                                              \
0463         case RCC_USART10CLKSOURCE_PLL2:                       \
0464           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2;          \
0465           break;                                              \
0466         case RCC_USART10CLKSOURCE_PLL3:                       \
0467           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3;          \
0468           break;                                              \
0469         case RCC_USART10CLKSOURCE_HSI:                        \
0470           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \
0471           break;                                              \
0472         case RCC_USART10CLKSOURCE_CSI:                        \
0473           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI;           \
0474           break;                                              \
0475         case RCC_USART10CLKSOURCE_LSE:                        \
0476           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \
0477           break;                                              \
0478         default:                                              \
0479           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \
0480           break;                                              \
0481       }                                                       \
0482     }                                                         \
0483     else if((__HANDLE__)->Instance == LPUART1)                \
0484     {                                                         \
0485       switch(__HAL_RCC_GET_LPUART1_SOURCE())                  \
0486       {                                                       \
0487         case RCC_LPUART1CLKSOURCE_D3PCLK1:                    \
0488           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D3PCLK1;       \
0489           break;                                              \
0490         case RCC_LPUART1CLKSOURCE_PLL2:                       \
0491           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2;          \
0492           break;                                              \
0493         case RCC_LPUART1CLKSOURCE_PLL3:                       \
0494           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3;          \
0495           break;                                              \
0496         case RCC_LPUART1CLKSOURCE_HSI:                        \
0497           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \
0498           break;                                              \
0499         case RCC_LPUART1CLKSOURCE_CSI:                        \
0500           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI;           \
0501           break;                                              \
0502         case RCC_LPUART1CLKSOURCE_LSE:                        \
0503           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \
0504           break;                                              \
0505         default:                                              \
0506           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \
0507           break;                                              \
0508       }                                                       \
0509     }                                                         \
0510     else                                                      \
0511     {                                                         \
0512       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;         \
0513     }                                                         \
0514   } while(0U)
0515 #else
0516 #define UART_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__)       \
0517   do {                                                        \
0518     if((__HANDLE__)->Instance == USART1)                      \
0519     {                                                         \
0520       switch(__HAL_RCC_GET_USART1_SOURCE())                   \
0521       {                                                       \
0522         case RCC_USART1CLKSOURCE_D2PCLK2:                     \
0523           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK2;       \
0524           break;                                              \
0525         case RCC_USART1CLKSOURCE_PLL2:                        \
0526           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2;          \
0527           break;                                              \
0528         case RCC_USART1CLKSOURCE_PLL3:                        \
0529           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3;          \
0530           break;                                              \
0531         case RCC_USART1CLKSOURCE_HSI:                         \
0532           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \
0533           break;                                              \
0534         case RCC_USART1CLKSOURCE_CSI:                         \
0535           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI;           \
0536           break;                                              \
0537         case RCC_USART1CLKSOURCE_LSE:                         \
0538           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \
0539           break;                                              \
0540         default:                                              \
0541           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \
0542           break;                                              \
0543       }                                                       \
0544     }                                                         \
0545     else if((__HANDLE__)->Instance == USART2)                 \
0546     {                                                         \
0547       switch(__HAL_RCC_GET_USART2_SOURCE())                   \
0548       {                                                       \
0549         case RCC_USART2CLKSOURCE_D2PCLK1:                     \
0550           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK1;       \
0551           break;                                              \
0552         case RCC_USART2CLKSOURCE_PLL2:                        \
0553           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2;          \
0554           break;                                              \
0555         case RCC_USART2CLKSOURCE_PLL3:                        \
0556           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3;          \
0557           break;                                              \
0558         case RCC_USART2CLKSOURCE_HSI:                         \
0559           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \
0560           break;                                              \
0561         case RCC_USART2CLKSOURCE_CSI:                         \
0562           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI;           \
0563           break;                                              \
0564         case RCC_USART2CLKSOURCE_LSE:                         \
0565           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \
0566           break;                                              \
0567         default:                                              \
0568           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \
0569           break;                                              \
0570       }                                                       \
0571     }                                                         \
0572     else if((__HANDLE__)->Instance == USART3)                 \
0573     {                                                         \
0574       switch(__HAL_RCC_GET_USART3_SOURCE())                   \
0575       {                                                       \
0576         case RCC_USART3CLKSOURCE_D2PCLK1:                     \
0577           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK1;       \
0578           break;                                              \
0579         case RCC_USART3CLKSOURCE_PLL2:                        \
0580           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2;          \
0581           break;                                              \
0582         case RCC_USART3CLKSOURCE_PLL3:                        \
0583           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3;          \
0584           break;                                              \
0585         case RCC_USART3CLKSOURCE_HSI:                         \
0586           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \
0587           break;                                              \
0588         case RCC_USART3CLKSOURCE_CSI:                         \
0589           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI;           \
0590           break;                                              \
0591         case RCC_USART3CLKSOURCE_LSE:                         \
0592           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \
0593           break;                                              \
0594         default:                                              \
0595           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \
0596           break;                                              \
0597       }                                                       \
0598     }                                                         \
0599     else if((__HANDLE__)->Instance == UART4)                  \
0600     {                                                         \
0601       switch(__HAL_RCC_GET_UART4_SOURCE())                    \
0602       {                                                       \
0603         case RCC_UART4CLKSOURCE_D2PCLK1:                      \
0604           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK1;       \
0605           break;                                              \
0606         case RCC_UART4CLKSOURCE_PLL2:                         \
0607           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2;          \
0608           break;                                              \
0609         case RCC_UART4CLKSOURCE_PLL3:                         \
0610           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3;          \
0611           break;                                              \
0612         case RCC_UART4CLKSOURCE_HSI:                          \
0613           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \
0614           break;                                              \
0615         case RCC_UART4CLKSOURCE_CSI:                          \
0616           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI;           \
0617           break;                                              \
0618         case RCC_UART4CLKSOURCE_LSE:                          \
0619           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \
0620           break;                                              \
0621         default:                                              \
0622           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \
0623           break;                                              \
0624       }                                                       \
0625     }                                                         \
0626     else if ((__HANDLE__)->Instance == UART5)                 \
0627     {                                                         \
0628       switch(__HAL_RCC_GET_UART5_SOURCE())                    \
0629       {                                                       \
0630         case RCC_UART5CLKSOURCE_D2PCLK1:                      \
0631           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK1;       \
0632           break;                                              \
0633         case RCC_UART5CLKSOURCE_PLL2:                         \
0634           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2;          \
0635           break;                                              \
0636         case RCC_UART5CLKSOURCE_PLL3:                         \
0637           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3;          \
0638           break;                                              \
0639         case RCC_UART5CLKSOURCE_HSI:                          \
0640           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \
0641           break;                                              \
0642         case RCC_UART5CLKSOURCE_CSI:                          \
0643           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI;           \
0644           break;                                              \
0645         case RCC_UART5CLKSOURCE_LSE:                          \
0646           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \
0647           break;                                              \
0648         default:                                              \
0649           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \
0650           break;                                              \
0651       }                                                       \
0652     }                                                         \
0653     else if((__HANDLE__)->Instance == USART6)                 \
0654     {                                                         \
0655       switch(__HAL_RCC_GET_USART6_SOURCE())                   \
0656       {                                                       \
0657         case RCC_USART6CLKSOURCE_D2PCLK2:                     \
0658           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK2;       \
0659           break;                                              \
0660         case RCC_USART6CLKSOURCE_PLL2:                        \
0661           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2;          \
0662           break;                                              \
0663         case RCC_USART6CLKSOURCE_PLL3:                        \
0664           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3;          \
0665           break;                                              \
0666         case RCC_USART6CLKSOURCE_HSI:                         \
0667           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \
0668           break;                                              \
0669         case RCC_USART6CLKSOURCE_CSI:                         \
0670           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI;           \
0671           break;                                              \
0672         case RCC_USART6CLKSOURCE_LSE:                         \
0673           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \
0674           break;                                              \
0675         default:                                              \
0676           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \
0677           break;                                              \
0678       }                                                       \
0679     }                                                         \
0680     else if((__HANDLE__)->Instance == UART7)                  \
0681     {                                                         \
0682       switch(__HAL_RCC_GET_UART7_SOURCE())                    \
0683       {                                                       \
0684         case RCC_UART7CLKSOURCE_D2PCLK1:                      \
0685           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK1;       \
0686           break;                                              \
0687         case RCC_UART7CLKSOURCE_PLL2:                         \
0688           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2;          \
0689           break;                                              \
0690         case RCC_UART7CLKSOURCE_PLL3:                         \
0691           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3;          \
0692           break;                                              \
0693         case RCC_UART7CLKSOURCE_HSI:                          \
0694           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \
0695           break;                                              \
0696         case RCC_UART7CLKSOURCE_CSI:                          \
0697           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI;           \
0698           break;                                              \
0699         case RCC_UART7CLKSOURCE_LSE:                          \
0700           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \
0701           break;                                              \
0702         default:                                              \
0703           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \
0704           break;                                              \
0705       }                                                       \
0706     }                                                         \
0707     else if((__HANDLE__)->Instance == UART8)                  \
0708     {                                                         \
0709       switch(__HAL_RCC_GET_UART8_SOURCE())                    \
0710       {                                                       \
0711         case RCC_UART8CLKSOURCE_D2PCLK1:                      \
0712           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK1;       \
0713           break;                                              \
0714         case RCC_UART8CLKSOURCE_PLL2:                         \
0715           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2;          \
0716           break;                                              \
0717         case RCC_UART8CLKSOURCE_PLL3:                         \
0718           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3;          \
0719           break;                                              \
0720         case RCC_UART8CLKSOURCE_HSI:                          \
0721           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \
0722           break;                                              \
0723         case RCC_UART8CLKSOURCE_CSI:                          \
0724           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI;           \
0725           break;                                              \
0726         case RCC_UART8CLKSOURCE_LSE:                          \
0727           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \
0728           break;                                              \
0729         default:                                              \
0730           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \
0731           break;                                              \
0732       }                                                       \
0733     }                                                         \
0734     else if((__HANDLE__)->Instance == LPUART1)                \
0735     {                                                         \
0736       switch(__HAL_RCC_GET_LPUART1_SOURCE())                  \
0737       {                                                       \
0738         case RCC_LPUART1CLKSOURCE_D3PCLK1:                    \
0739           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D3PCLK1;       \
0740           break;                                              \
0741         case RCC_LPUART1CLKSOURCE_PLL2:                       \
0742           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2;          \
0743           break;                                              \
0744         case RCC_LPUART1CLKSOURCE_PLL3:                       \
0745           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3;          \
0746           break;                                              \
0747         case RCC_LPUART1CLKSOURCE_HSI:                        \
0748           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \
0749           break;                                              \
0750         case RCC_LPUART1CLKSOURCE_CSI:                        \
0751           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI;           \
0752           break;                                              \
0753         case RCC_LPUART1CLKSOURCE_LSE:                        \
0754           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \
0755           break;                                              \
0756         default:                                              \
0757           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \
0758           break;                                              \
0759       }                                                       \
0760     }                                                         \
0761     else                                                      \
0762     {                                                         \
0763       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;         \
0764     }                                                         \
0765   } while(0U)
0766 #endif  /* UART9 && USART10 */
0767
0768 /** @brief  Report the UART mask to apply to retrieve the received data
0769   *         according to the word length and to the parity bits activation.
0770   * @note   If PCE = 1, the parity bit is not included in the data extracted
0771   *         by the reception API().
0772   *         This masking operation is not carried out in the case of
0773   *         DMA transfers.
0774   * @param  __HANDLE__ specifies the UART Handle.
0775   * @retval None, the mask to apply to UART RDR register is stored in (__HANDLE__)->Mask field.
0776   */
0777 #define UART_MASK_COMPUTATION(__HANDLE__)                             \
0778   do {                                                                \
0779     if ((__HANDLE__)->Init.WordLength == UART_WORDLENGTH_9B)          \
0780     {                                                                 \
0781       if ((__HANDLE__)->Init.Parity == UART_PARITY_NONE)              \
0782       {                                                               \
0783         (__HANDLE__)->Mask = 0x01FFU ;                                \
0784       }                                                               \
0785       else                                                            \
0786       {                                                               \
0787         (__HANDLE__)->Mask = 0x00FFU ;                                \
0788       }                                                               \
0789     }                                                                 \
0790     else if ((__HANDLE__)->Init.WordLength == UART_WORDLENGTH_8B)     \
0791     {                                                                 \
0792       if ((__HANDLE__)->Init.Parity == UART_PARITY_NONE)              \
0793       {                                                               \
0794         (__HANDLE__)->Mask = 0x00FFU ;                                \
0795       }                                                               \
0796       else                                                            \
0797       {                                                               \
0798         (__HANDLE__)->Mask = 0x007FU ;                                \
0799       }                                                               \
0800     }                                                                 \
0801     else if ((__HANDLE__)->Init.WordLength == UART_WORDLENGTH_7B)     \
0802     {                                                                 \
0803       if ((__HANDLE__)->Init.Parity == UART_PARITY_NONE)              \
0804       {                                                               \
0805         (__HANDLE__)->Mask = 0x007FU ;                                \
0806       }                                                               \
0807       else                                                            \
0808       {                                                               \
0809         (__HANDLE__)->Mask = 0x003FU ;                                \
0810       }                                                               \
0811     }                                                                 \
0812     else                                                              \
0813     {                                                                 \
0814       (__HANDLE__)->Mask = 0x0000U;                                   \
0815     }                                                                 \
0816   } while(0U)
0817
0818 /**
0819   * @brief Ensure that UART frame length is valid.
0820   * @param __LENGTH__ UART frame length.
0821   * @retval SET (__LENGTH__ is valid) or RESET (__LENGTH__ is invalid)
0822   */
0823 #define IS_UART_WORD_LENGTH(__LENGTH__) (((__LENGTH__) == UART_WORDLENGTH_7B) || \
0824                                          ((__LENGTH__) == UART_WORDLENGTH_8B) || \
0825                                          ((__LENGTH__) == UART_WORDLENGTH_9B))
0826
0827 /**
0828   * @brief Ensure that UART wake-up address length is valid.
0829   * @param __ADDRESS__ UART wake-up address length.
0830   * @retval SET (__ADDRESS__ is valid) or RESET (__ADDRESS__ is invalid)
0831   */
0832 #define IS_UART_ADDRESSLENGTH_DETECT(__ADDRESS__) (((__ADDRESS__) == UART_ADDRESS_DETECT_4B) || \
0833                                                    ((__ADDRESS__) == UART_ADDRESS_DETECT_7B))
0834
0835 /**
0836   * @brief Ensure that UART TXFIFO threshold level is valid.
0837   * @param __THRESHOLD__ UART TXFIFO threshold level.
0838   * @retval SET (__THRESHOLD__ is valid) or RESET (__THRESHOLD__ is invalid)
0839   */
0840 #define IS_UART_TXFIFO_THRESHOLD(__THRESHOLD__) (((__THRESHOLD__) == UART_TXFIFO_THRESHOLD_1_8) || \
0841                                                  ((__THRESHOLD__) == UART_TXFIFO_THRESHOLD_1_4) || \
0842                                                  ((__THRESHOLD__) == UART_TXFIFO_THRESHOLD_1_2) || \
0843                                                  ((__THRESHOLD__) == UART_TXFIFO_THRESHOLD_3_4) || \
0844                                                  ((__THRESHOLD__) == UART_TXFIFO_THRESHOLD_7_8) || \
0845                                                  ((__THRESHOLD__) == UART_TXFIFO_THRESHOLD_8_8))
0846
0847 /**
0848   * @brief Ensure that UART RXFIFO threshold level is valid.
0849   * @param __THRESHOLD__ UART RXFIFO threshold level.
0850   * @retval SET (__THRESHOLD__ is valid) or RESET (__THRESHOLD__ is invalid)
0851   */
0852 #define IS_UART_RXFIFO_THRESHOLD(__THRESHOLD__) (((__THRESHOLD__) == UART_RXFIFO_THRESHOLD_1_8) || \
0853                                                  ((__THRESHOLD__) == UART_RXFIFO_THRESHOLD_1_4) || \
0854                                                  ((__THRESHOLD__) == UART_RXFIFO_THRESHOLD_1_2) || \
0855                                                  ((__THRESHOLD__) == UART_RXFIFO_THRESHOLD_3_4) || \
0856                                                  ((__THRESHOLD__) == UART_RXFIFO_THRESHOLD_7_8) || \
0857                                                  ((__THRESHOLD__) == UART_RXFIFO_THRESHOLD_8_8))
0858
0859 /**
0860   * @}
0861   */
0862
0863 /* Private functions ---------------------------------------------------------*/
0864
0865 /**
0866   * @}
0867   */
0868
0869 /**
0870   * @}
0871   */
0872
0873 #ifdef __cplusplus
0874 }
0875 #endif
0876
0877 #endif /* STM32H7xx_HAL_UART_EX_H */
0878