git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_M7_M4_AMP_STM32H745I_Discovery_IAR/ST_code/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_uart_ex.h

   1 /**\r
   2   ******************************************************************************\r
   3   * @file    stm32h7xx_hal_uart_ex.h\r
   4   * @author  MCD Application Team\r
   5   * @brief   Header file of UART HAL Extended module.\r
   6   ******************************************************************************\r
   7   * @attention\r
   8   *\r
   9   * <h2><center>&copy; Copyright (c) 2017 STMicroelectronics.\r
  10   * All rights reserved.</center></h2>\r
  11   *\r
  12   * This software component is licensed by ST under BSD 3-Clause license,\r
  13   * the "License"; You may not use this file except in compliance with the\r
  14   * License. You may obtain a copy of the License at:\r
  15   *                        opensource.org/licenses/BSD-3-Clause\r
  16   *\r
  17   ******************************************************************************\r
  18   */\r
  19 \r
  20 /* Define to prevent recursive inclusion -------------------------------------*/\r
  21 #ifndef STM32H7xx_HAL_UART_EX_H\r
  22 #define STM32H7xx_HAL_UART_EX_H\r
  23 \r
  24 #ifdef __cplusplus\r
  25 extern "C" {\r
  26 #endif\r
  27 \r
  28 /* Includes ------------------------------------------------------------------*/\r
  29 #include "stm32h7xx_hal_def.h"\r
  30 \r
  31 /** @addtogroup STM32H7xx_HAL_Driver\r
  32   * @{\r
  33   */\r
  34 \r
  35 /** @addtogroup UARTEx\r
  36   * @{\r
  37   */\r
  38 \r
  39 /* Exported types ------------------------------------------------------------*/\r
  40 /** @defgroup UARTEx_Exported_Types UARTEx Exported Types\r
  41   * @{\r
  42   */\r
  43 \r
  44 /**\r
  45   * @brief  UART wake up from stop mode parameters\r
  46   */\r
  47 typedef struct\r
  48 {\r
  49   uint32_t WakeUpEvent;        /*!< Specifies which event will activate the Wakeup from Stop mode flag (WUF).\r
  50                                     This parameter can be a value of @ref UART_WakeUp_from_Stop_Selection.\r
  51                                     If set to UART_WAKEUP_ON_ADDRESS, the two other fields below must\r
  52                                     be filled up. */\r
  53 \r
  54   uint16_t AddressLength;      /*!< Specifies whether the address is 4 or 7-bit long.\r
  55                                     This parameter can be a value of @ref UARTEx_WakeUp_Address_Length.  */\r
  56 \r
  57   uint8_t Address;             /*!< UART/USART node address (7-bit long max). */\r
  58 } UART_WakeUpTypeDef;\r
  59 \r
  60 /**\r
  61   * @}\r
  62   */\r
  63 \r
  64 /* Exported constants --------------------------------------------------------*/\r
  65 /** @defgroup UARTEx_Exported_Constants UARTEx Exported Constants\r
  66   * @{\r
  67   */\r
  68 \r
  69 /** @defgroup UARTEx_Word_Length UARTEx Word Length\r
  70   * @{\r
  71   */\r
  72 #define UART_WORDLENGTH_7B                  USART_CR1_M1   /*!< 7-bit long UART frame */\r
  73 #define UART_WORDLENGTH_8B                  0x00000000U    /*!< 8-bit long UART frame */\r
  74 #define UART_WORDLENGTH_9B                  USART_CR1_M0   /*!< 9-bit long UART frame */\r
  75 /**\r
  76   * @}\r
  77   */\r
  78 \r
  79 /** @defgroup UARTEx_WakeUp_Address_Length UARTEx WakeUp Address Length\r
  80   * @{\r
  81   */\r
  82 #define UART_ADDRESS_DETECT_4B              0x00000000U      /*!< 4-bit long wake-up address */\r
  83 #define UART_ADDRESS_DETECT_7B              USART_CR2_ADDM7  /*!< 7-bit long wake-up address */\r
  84 /**\r
  85   * @}\r
  86   */\r
  87 \r
  88 /** @defgroup UARTEx_FIFO_mode UARTEx FIFO mode\r
  89   * @brief    UART FIFO mode\r
  90   * @{\r
  91   */\r
  92 #define UART_FIFOMODE_DISABLE        0x00000000U       /*!< FIFO mode disable */\r
  93 #define UART_FIFOMODE_ENABLE         USART_CR1_FIFOEN  /*!< FIFO mode enable  */\r
  94 /**\r
  95   * @}\r
  96   */\r
  97 \r
  98 /** @defgroup UARTEx_TXFIFO_threshold_level UARTEx TXFIFO threshold level\r
  99   * @brief    UART TXFIFO threshold level\r
 100   * @{\r
 101   */\r
 102 #define UART_TXFIFO_THRESHOLD_1_8   0x00000000U                               /*!< TXFIFO reaches 1/8 of its depth */\r
 103 #define UART_TXFIFO_THRESHOLD_1_4   USART_CR3_TXFTCFG_0                       /*!< TXFIFO reaches 1/4 of its depth */\r
 104 #define UART_TXFIFO_THRESHOLD_1_2   USART_CR3_TXFTCFG_1                       /*!< TXFIFO reaches 1/2 of its depth */\r
 105 #define UART_TXFIFO_THRESHOLD_3_4   (USART_CR3_TXFTCFG_0|USART_CR3_TXFTCFG_1) /*!< TXFIFO reaches 3/4 of its depth */\r
 106 #define UART_TXFIFO_THRESHOLD_7_8   USART_CR3_TXFTCFG_2                       /*!< TXFIFO reaches 7/8 of its depth */\r
 107 #define UART_TXFIFO_THRESHOLD_8_8   (USART_CR3_TXFTCFG_2|USART_CR3_TXFTCFG_0) /*!< TXFIFO becomes empty            */\r
 108 /**\r
 109   * @}\r
 110   */\r
 111 \r
 112 /** @defgroup UARTEx_RXFIFO_threshold_level UARTEx RXFIFO threshold level\r
 113   * @brief    UART RXFIFO threshold level\r
 114   * @{\r
 115   */\r
 116 #define UART_RXFIFO_THRESHOLD_1_8   0x00000000U                               /*!< RXFIFO FIFO reaches 1/8 of its depth */\r
 117 #define UART_RXFIFO_THRESHOLD_1_4   USART_CR3_RXFTCFG_0                       /*!< RXFIFO FIFO reaches 1/4 of its depth */\r
 118 #define UART_RXFIFO_THRESHOLD_1_2   USART_CR3_RXFTCFG_1                       /*!< RXFIFO FIFO reaches 1/2 of its depth */\r
 119 #define UART_RXFIFO_THRESHOLD_3_4   (USART_CR3_RXFTCFG_0|USART_CR3_RXFTCFG_1) /*!< RXFIFO FIFO reaches 3/4 of its depth */\r
 120 #define UART_RXFIFO_THRESHOLD_7_8   USART_CR3_RXFTCFG_2                       /*!< RXFIFO FIFO reaches 7/8 of its depth */\r
 121 #define UART_RXFIFO_THRESHOLD_8_8   (USART_CR3_RXFTCFG_2|USART_CR3_RXFTCFG_0) /*!< RXFIFO FIFO becomes full             */\r
 122 /**\r
 123   * @}\r
 124   */\r
 125 \r
 126 /**\r
 127   * @}\r
 128   */\r
 129 \r
 130 /* Exported macros -----------------------------------------------------------*/\r
 131 /* Exported functions --------------------------------------------------------*/\r
 132 /** @addtogroup UARTEx_Exported_Functions\r
 133   * @{\r
 134   */\r
 135 \r
 136 /** @addtogroup UARTEx_Exported_Functions_Group1\r
 137   * @{\r
 138   */\r
 139 \r
 140 /* Initialization and de-initialization functions  ****************************/\r
 141 HAL_StatusTypeDef HAL_RS485Ex_Init(UART_HandleTypeDef *huart, uint32_t Polarity, uint32_t AssertionTime, uint32_t DeassertionTime);\r
 142 \r
 143 /**\r
 144   * @}\r
 145   */\r
 146 \r
 147 /** @addtogroup UARTEx_Exported_Functions_Group2\r
 148   * @{\r
 149   */\r
 150 \r
 151 void HAL_UARTEx_WakeupCallback(UART_HandleTypeDef *huart);\r
 152 \r
 153 void HAL_UARTEx_RxFifoFullCallback(UART_HandleTypeDef *huart);\r
 154 void HAL_UARTEx_TxFifoEmptyCallback(UART_HandleTypeDef *huart);\r
 155 \r
 156 /**\r
 157   * @}\r
 158   */\r
 159 \r
 160 /** @addtogroup UARTEx_Exported_Functions_Group3\r
 161   * @{\r
 162   */\r
 163 \r
 164 /* Peripheral Control functions  **********************************************/\r
 165 HAL_StatusTypeDef HAL_UARTEx_StopModeWakeUpSourceConfig(UART_HandleTypeDef *huart, UART_WakeUpTypeDef WakeUpSelection);\r
 166 HAL_StatusTypeDef HAL_UARTEx_EnableStopMode(UART_HandleTypeDef *huart);\r
 167 HAL_StatusTypeDef HAL_UARTEx_DisableStopMode(UART_HandleTypeDef *huart);\r
 168 HAL_StatusTypeDef HAL_MultiProcessorEx_AddressLength_Set(UART_HandleTypeDef *huart, uint32_t AddressLength);\r
 169 HAL_StatusTypeDef HAL_UARTEx_EnableFifoMode(UART_HandleTypeDef *huart);\r
 170 HAL_StatusTypeDef HAL_UARTEx_DisableFifoMode(UART_HandleTypeDef *huart);\r
 171 HAL_StatusTypeDef HAL_UARTEx_SetTxFifoThreshold(UART_HandleTypeDef *huart, uint32_t Threshold);\r
 172 HAL_StatusTypeDef HAL_UARTEx_SetRxFifoThreshold(UART_HandleTypeDef *huart, uint32_t Threshold);\r
 173 \r
 174 /**\r
 175   * @}\r
 176   */\r
 177 \r
 178 /**\r
 179   * @}\r
 180   */\r
 181 \r
 182 /* Private macros ------------------------------------------------------------*/\r
 183 /** @defgroup UARTEx_Private_Macros UARTEx Private Macros\r
 184   * @{\r
 185   */\r
 186 \r
 187 /** @brief  Report the UART clock source.\r
 188   * @param  __HANDLE__ specifies the UART Handle.\r
 189   * @param  __CLOCKSOURCE__ output variable.\r
 190   * @retval UART clocking source, written in __CLOCKSOURCE__.\r
 191   */\r
 192 #define UART_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__)       \\r
 193   do {                                                        \\r
 194     if((__HANDLE__)->Instance == USART1)                      \\r
 195     {                                                         \\r
 196       switch(__HAL_RCC_GET_USART1_SOURCE())                   \\r
 197       {                                                       \\r
 198         case RCC_USART1CLKSOURCE_D2PCLK2:                     \\r
 199           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK2;       \\r
 200           break;                                              \\r
 201         case RCC_USART1CLKSOURCE_PLL2:                        \\r
 202           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2;          \\r
 203           break;                                              \\r
 204         case RCC_USART1CLKSOURCE_PLL3:                        \\r
 205           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3;          \\r
 206           break;                                              \\r
 207         case RCC_USART1CLKSOURCE_HSI:                         \\r
 208           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \\r
 209           break;                                              \\r
 210         case RCC_USART1CLKSOURCE_CSI:                         \\r
 211           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI;           \\r
 212           break;                                              \\r
 213         case RCC_USART1CLKSOURCE_LSE:                         \\r
 214           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \\r
 215           break;                                              \\r
 216         default:                                              \\r
 217           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \\r
 218           break;                                              \\r
 219       }                                                       \\r
 220     }                                                         \\r
 221     else if((__HANDLE__)->Instance == USART2)                 \\r
 222     {                                                         \\r
 223       switch(__HAL_RCC_GET_USART2_SOURCE())                   \\r
 224       {                                                       \\r
 225         case RCC_USART2CLKSOURCE_D2PCLK1:                     \\r
 226           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK1;       \\r
 227           break;                                              \\r
 228         case RCC_USART2CLKSOURCE_PLL2:                        \\r
 229           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2;          \\r
 230           break;                                              \\r
 231         case RCC_USART2CLKSOURCE_PLL3:                        \\r
 232           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3;          \\r
 233           break;                                              \\r
 234         case RCC_USART2CLKSOURCE_HSI:                         \\r
 235           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \\r
 236           break;                                              \\r
 237         case RCC_USART2CLKSOURCE_CSI:                         \\r
 238           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI;           \\r
 239           break;                                              \\r
 240         case RCC_USART2CLKSOURCE_LSE:                         \\r
 241           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \\r
 242           break;                                              \\r
 243         default:                                              \\r
 244           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \\r
 245           break;                                              \\r
 246       }                                                       \\r
 247     }                                                         \\r
 248     else if((__HANDLE__)->Instance == USART3)                 \\r
 249     {                                                         \\r
 250       switch(__HAL_RCC_GET_USART3_SOURCE())                   \\r
 251       {                                                       \\r
 252         case RCC_USART3CLKSOURCE_D2PCLK1:                     \\r
 253           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK1;       \\r
 254           break;                                              \\r
 255         case RCC_USART3CLKSOURCE_PLL2:                        \\r
 256           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2;          \\r
 257           break;                                              \\r
 258         case RCC_USART3CLKSOURCE_PLL3:                        \\r
 259           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3;          \\r
 260           break;                                              \\r
 261         case RCC_USART3CLKSOURCE_HSI:                         \\r
 262           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \\r
 263           break;                                              \\r
 264         case RCC_USART3CLKSOURCE_CSI:                         \\r
 265           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI;           \\r
 266           break;                                              \\r
 267         case RCC_USART3CLKSOURCE_LSE:                         \\r
 268           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \\r
 269           break;                                              \\r
 270         default:                                              \\r
 271           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \\r
 272           break;                                              \\r
 273       }                                                       \\r
 274     }                                                         \\r
 275     else if((__HANDLE__)->Instance == UART4)                  \\r
 276     {                                                         \\r
 277       switch(__HAL_RCC_GET_UART4_SOURCE())                    \\r
 278       {                                                       \\r
 279         case RCC_UART4CLKSOURCE_D2PCLK1:                      \\r
 280           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK1;       \\r
 281           break;                                              \\r
 282         case RCC_UART4CLKSOURCE_PLL2:                         \\r
 283           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2;          \\r
 284           break;                                              \\r
 285         case RCC_UART4CLKSOURCE_PLL3:                         \\r
 286           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3;          \\r
 287           break;                                              \\r
 288         case RCC_UART4CLKSOURCE_HSI:                          \\r
 289           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \\r
 290           break;                                              \\r
 291         case RCC_UART4CLKSOURCE_CSI:                          \\r
 292           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI;           \\r
 293           break;                                              \\r
 294         case RCC_UART4CLKSOURCE_LSE:                          \\r
 295           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \\r
 296           break;                                              \\r
 297         default:                                              \\r
 298           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \\r
 299           break;                                              \\r
 300       }                                                       \\r
 301     }                                                         \\r
 302     else if ((__HANDLE__)->Instance == UART5)                 \\r
 303     {                                                         \\r
 304       switch(__HAL_RCC_GET_UART5_SOURCE())                    \\r
 305       {                                                       \\r
 306         case RCC_UART5CLKSOURCE_D2PCLK1:                      \\r
 307           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK1;       \\r
 308           break;                                              \\r
 309         case RCC_UART5CLKSOURCE_PLL2:                         \\r
 310           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2;          \\r
 311           break;                                              \\r
 312         case RCC_UART5CLKSOURCE_PLL3:                         \\r
 313           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3;          \\r
 314           break;                                              \\r
 315         case RCC_UART5CLKSOURCE_HSI:                          \\r
 316           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \\r
 317           break;                                              \\r
 318         case RCC_UART5CLKSOURCE_CSI:                          \\r
 319           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI;           \\r
 320           break;                                              \\r
 321         case RCC_UART5CLKSOURCE_LSE:                          \\r
 322           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \\r
 323           break;                                              \\r
 324         default:                                              \\r
 325           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \\r
 326           break;                                              \\r
 327       }                                                       \\r
 328     }                                                         \\r
 329     else if((__HANDLE__)->Instance == USART6)                 \\r
 330     {                                                         \\r
 331       switch(__HAL_RCC_GET_USART6_SOURCE())                   \\r
 332       {                                                       \\r
 333         case RCC_USART6CLKSOURCE_D2PCLK2:                     \\r
 334           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK2;       \\r
 335           break;                                              \\r
 336         case RCC_USART6CLKSOURCE_PLL2:                        \\r
 337           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2;          \\r
 338           break;                                              \\r
 339         case RCC_USART6CLKSOURCE_PLL3:                        \\r
 340           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3;          \\r
 341           break;                                              \\r
 342         case RCC_USART6CLKSOURCE_HSI:                         \\r
 343           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \\r
 344           break;                                              \\r
 345         case RCC_USART6CLKSOURCE_CSI:                         \\r
 346           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI;           \\r
 347           break;                                              \\r
 348         case RCC_USART6CLKSOURCE_LSE:                         \\r
 349           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \\r
 350           break;                                              \\r
 351         default:                                              \\r
 352           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \\r
 353           break;                                              \\r
 354       }                                                       \\r
 355     }                                                         \\r
 356     else if((__HANDLE__)->Instance == UART7)                  \\r
 357     {                                                         \\r
 358       switch(__HAL_RCC_GET_UART7_SOURCE())                    \\r
 359       {                                                       \\r
 360         case RCC_UART7CLKSOURCE_D2PCLK1:                      \\r
 361           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK1;       \\r
 362           break;                                              \\r
 363         case RCC_UART7CLKSOURCE_PLL2:                         \\r
 364           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2;          \\r
 365           break;                                              \\r
 366         case RCC_UART7CLKSOURCE_PLL3:                         \\r
 367           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3;          \\r
 368           break;                                              \\r
 369         case RCC_UART7CLKSOURCE_HSI:                          \\r
 370           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \\r
 371           break;                                              \\r
 372         case RCC_UART7CLKSOURCE_CSI:                          \\r
 373           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI;           \\r
 374           break;                                              \\r
 375         case RCC_UART7CLKSOURCE_LSE:                          \\r
 376           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \\r
 377           break;                                              \\r
 378         default:                                              \\r
 379           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \\r
 380           break;                                              \\r
 381       }                                                       \\r
 382     }                                                         \\r
 383     else if((__HANDLE__)->Instance == UART8)                  \\r
 384     {                                                         \\r
 385       switch(__HAL_RCC_GET_UART8_SOURCE())                    \\r
 386       {                                                       \\r
 387         case RCC_UART8CLKSOURCE_D2PCLK1:                      \\r
 388           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK1;       \\r
 389           break;                                              \\r
 390         case RCC_UART8CLKSOURCE_PLL2:                         \\r
 391           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2;          \\r
 392           break;                                              \\r
 393         case RCC_UART8CLKSOURCE_PLL3:                         \\r
 394           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3;          \\r
 395           break;                                              \\r
 396         case RCC_UART8CLKSOURCE_HSI:                          \\r
 397           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \\r
 398           break;                                              \\r
 399         case RCC_UART8CLKSOURCE_CSI:                          \\r
 400           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI;           \\r
 401           break;                                              \\r
 402         case RCC_UART8CLKSOURCE_LSE:                          \\r
 403           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \\r
 404           break;                                              \\r
 405         default:                                              \\r
 406           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \\r
 407           break;                                              \\r
 408       }                                                       \\r
 409     }                                                         \\r
 410     else if((__HANDLE__)->Instance == LPUART1)                \\r
 411     {                                                         \\r
 412       switch(__HAL_RCC_GET_LPUART1_SOURCE())                  \\r
 413       {                                                       \\r
 414         case RCC_LPUART1CLKSOURCE_D3PCLK1:                    \\r
 415           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D3PCLK1;       \\r
 416           break;                                              \\r
 417         case RCC_LPUART1CLKSOURCE_PLL2:                       \\r
 418           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2;          \\r
 419           break;                                              \\r
 420         case RCC_LPUART1CLKSOURCE_PLL3:                       \\r
 421           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3;          \\r
 422           break;                                              \\r
 423         case RCC_LPUART1CLKSOURCE_HSI:                        \\r
 424           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \\r
 425           break;                                              \\r
 426         case RCC_LPUART1CLKSOURCE_CSI:                        \\r
 427           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI;           \\r
 428           break;                                              \\r
 429         case RCC_LPUART1CLKSOURCE_LSE:                        \\r
 430           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \\r
 431           break;                                              \\r
 432         default:                                              \\r
 433           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \\r
 434           break;                                              \\r
 435       }                                                       \\r
 436     }                                                         \\r
 437     else                                                      \\r
 438     {                                                         \\r
 439       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;         \\r
 440     }                                                         \\r
 441   } while(0U)\r
 442 \r
 443 /** @brief  Report the UART mask to apply to retrieve the received data\r
 444   *         according to the word length and to the parity bits activation.\r
 445   * @note   If PCE = 1, the parity bit is not included in the data extracted\r
 446   *         by the reception API().\r
 447   *         This masking operation is not carried out in the case of\r
 448   *         DMA transfers.\r
 449   * @param  __HANDLE__ specifies the UART Handle.\r
 450   * @retval None, the mask to apply to UART RDR register is stored in (__HANDLE__)->Mask field.\r
 451   */\r
 452 #define UART_MASK_COMPUTATION(__HANDLE__)                             \\r
 453   do {                                                                \\r
 454   if ((__HANDLE__)->Init.WordLength == UART_WORDLENGTH_9B)            \\r
 455   {                                                                   \\r
 456      if ((__HANDLE__)->Init.Parity == UART_PARITY_NONE)               \\r
 457      {                                                                \\r
 458         (__HANDLE__)->Mask = 0x01FFU ;                                \\r
 459      }                                                                \\r
 460      else                                                             \\r
 461      {                                                                \\r
 462         (__HANDLE__)->Mask = 0x00FFU ;                                \\r
 463      }                                                                \\r
 464   }                                                                   \\r
 465   else if ((__HANDLE__)->Init.WordLength == UART_WORDLENGTH_8B)       \\r
 466   {                                                                   \\r
 467      if ((__HANDLE__)->Init.Parity == UART_PARITY_NONE)               \\r
 468      {                                                                \\r
 469         (__HANDLE__)->Mask = 0x00FFU ;                                \\r
 470      }                                                                \\r
 471      else                                                             \\r
 472      {                                                                \\r
 473         (__HANDLE__)->Mask = 0x007FU ;                                \\r
 474      }                                                                \\r
 475   }                                                                   \\r
 476   else if ((__HANDLE__)->Init.WordLength == UART_WORDLENGTH_7B)       \\r
 477   {                                                                   \\r
 478      if ((__HANDLE__)->Init.Parity == UART_PARITY_NONE)               \\r
 479      {                                                                \\r
 480         (__HANDLE__)->Mask = 0x007FU ;                                \\r
 481      }                                                                \\r
 482      else                                                             \\r
 483      {                                                                \\r
 484         (__HANDLE__)->Mask = 0x003FU ;                                \\r
 485      }                                                                \\r
 486   }                                                                   \\r
 487   else                                                                \\r
 488   {                                                                   \\r
 489     (__HANDLE__)->Mask = 0x0000U;                                     \\r
 490   }                                                                   \\r
 491 } while(0U)\r
 492 \r
 493 /**\r
 494   * @brief Ensure that UART frame length is valid.\r
 495   * @param __LENGTH__ UART frame length.\r
 496   * @retval SET (__LENGTH__ is valid) or RESET (__LENGTH__ is invalid)\r
 497   */\r
 498 #define IS_UART_WORD_LENGTH(__LENGTH__) (((__LENGTH__) == UART_WORDLENGTH_7B) || \\r
 499                                          ((__LENGTH__) == UART_WORDLENGTH_8B) || \\r
 500                                          ((__LENGTH__) == UART_WORDLENGTH_9B))\r
 501 \r
 502 /**\r
 503   * @brief Ensure that UART wake-up address length is valid.\r
 504   * @param __ADDRESS__ UART wake-up address length.\r
 505   * @retval SET (__ADDRESS__ is valid) or RESET (__ADDRESS__ is invalid)\r
 506   */\r
 507 #define IS_UART_ADDRESSLENGTH_DETECT(__ADDRESS__) (((__ADDRESS__) == UART_ADDRESS_DETECT_4B) || \\r
 508                                                    ((__ADDRESS__) == UART_ADDRESS_DETECT_7B))\r
 509 \r
 510 /**\r
 511   * @brief Ensure that UART TXFIFO threshold level is valid.\r
 512   * @param __THRESHOLD__ UART TXFIFO threshold level.\r
 513   * @retval SET (__THRESHOLD__ is valid) or RESET (__THRESHOLD__ is invalid)\r
 514   */\r
 515 #define IS_UART_TXFIFO_THRESHOLD(__THRESHOLD__) (((__THRESHOLD__) == UART_TXFIFO_THRESHOLD_1_8) || \\r
 516                                                  ((__THRESHOLD__) == UART_TXFIFO_THRESHOLD_1_4) || \\r
 517                                                  ((__THRESHOLD__) == UART_TXFIFO_THRESHOLD_1_2) || \\r
 518                                                  ((__THRESHOLD__) == UART_TXFIFO_THRESHOLD_3_4) || \\r
 519                                                  ((__THRESHOLD__) == UART_TXFIFO_THRESHOLD_7_8) || \\r
 520                                                  ((__THRESHOLD__) == UART_TXFIFO_THRESHOLD_8_8))\r
 521 \r
 522 /**\r
 523   * @brief Ensure that UART RXFIFO threshold level is valid.\r
 524   * @param __THRESHOLD__ UART RXFIFO threshold level.\r
 525   * @retval SET (__THRESHOLD__ is valid) or RESET (__THRESHOLD__ is invalid)\r
 526   */\r
 527 #define IS_UART_RXFIFO_THRESHOLD(__THRESHOLD__) (((__THRESHOLD__) == UART_RXFIFO_THRESHOLD_1_8) || \\r
 528                                                  ((__THRESHOLD__) == UART_RXFIFO_THRESHOLD_1_4) || \\r
 529                                                  ((__THRESHOLD__) == UART_RXFIFO_THRESHOLD_1_2) || \\r
 530                                                  ((__THRESHOLD__) == UART_RXFIFO_THRESHOLD_3_4) || \\r
 531                                                  ((__THRESHOLD__) == UART_RXFIFO_THRESHOLD_7_8) || \\r
 532                                                  ((__THRESHOLD__) == UART_RXFIFO_THRESHOLD_8_8))\r
 533 \r
 534 /**\r
 535   * @}\r
 536   */\r
 537 \r
 538 /* Private functions ---------------------------------------------------------*/\r
 539 \r
 540 /**\r
 541   * @}\r
 542   */\r
 543 \r
 544 /**\r
 545   * @}\r
 546   */\r
 547 \r
 548 #ifdef __cplusplus\r
 549 }\r
 550 #endif\r
 551 \r
 552 #endif /* STM32H7xx_HAL_UART_EX_H */\r
 553 \r
 554 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/\r