1 /** 2 ****************************************************************************** 3 * @file stm32h5xx_hal_irda_ex.h 4 * @author MCD Application Team 5 * @brief Header file of IRDA HAL Extended module. 6 ****************************************************************************** 7 * @attention 8 * 9 * Copyright (c) 2023 STMicroelectronics. 10 * All rights reserved. 11 * 12 * This software is licensed under terms that can be found in the LICENSE file 13 * in the root directory of this software component. 14 * If no LICENSE file comes with this software, it is provided AS-IS. 15 * 16 ****************************************************************************** 17 */ 18 19 /* Define to prevent recursive inclusion -------------------------------------*/ 20 #ifndef STM32H5xx_HAL_IRDA_EX_H 21 #define STM32H5xx_HAL_IRDA_EX_H 22 23 #ifdef __cplusplus 24 extern "C" { 25 #endif 26 27 /* Includes ------------------------------------------------------------------*/ 28 #include "stm32h5xx_hal_def.h" 29 30 /** @addtogroup STM32H5xx_HAL_Driver 31 * @{ 32 */ 33 34 /** @defgroup IRDAEx IRDAEx 35 * @brief IRDA Extended HAL module driver 36 * @{ 37 */ 38 39 /* Exported types ------------------------------------------------------------*/ 40 /* Exported constants --------------------------------------------------------*/ 41 /** @defgroup IRDAEx_Extended_Exported_Constants IRDAEx Extended Exported Constants 42 * @{ 43 */ 44 45 /** @defgroup IRDAEx_Word_Length IRDAEx Word Length 46 * @{ 47 */ 48 #define IRDA_WORDLENGTH_7B USART_CR1_M1 /*!< 7-bit long frame */ 49 #define IRDA_WORDLENGTH_8B 0x00000000U /*!< 8-bit long frame */ 50 #define IRDA_WORDLENGTH_9B USART_CR1_M0 /*!< 9-bit long frame */ 51 /** 52 * @} 53 */ 54 55 /** 56 * @} 57 */ 58 59 /* Exported macros -----------------------------------------------------------*/ 60 61 /* Private macros ------------------------------------------------------------*/ 62 63 /** @defgroup IRDAEx_Private_Macros IRDAEx Private Macros 64 * @{ 65 */ 66 67 /** @brief Report the IRDA clock source. 68 * @param __HANDLE__ specifies the IRDA Handle. 69 * @param __CLOCKSOURCE__ output variable. 70 * @retval IRDA clocking source, written in __CLOCKSOURCE__. 71 */ 72 #if (defined(STM32H573xx) || defined(STM32H563xx) || defined(STM32H562xx)) 73 #define IRDA_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__) \ 74 do { \ 75 if((__HANDLE__)->Instance == USART1) \ 76 { \ 77 switch(__HAL_RCC_GET_USART1_SOURCE()) \ 78 { \ 79 case RCC_USART1CLKSOURCE_PCLK2: \ 80 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK2; \ 81 break; \ 82 case RCC_USART1CLKSOURCE_HSI: \ 83 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 84 break; \ 85 case RCC_USART1CLKSOURCE_CSI: \ 86 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_CSI; \ 87 break; \ 88 case RCC_USART1CLKSOURCE_LSE: \ 89 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 90 break; \ 91 case RCC_USART1CLKSOURCE_PLL2Q: \ 92 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PLL2Q; \ 93 break; \ 94 case RCC_USART1CLKSOURCE_PLL3Q: \ 95 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PLL3Q; \ 96 break; \ 97 default: \ 98 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 99 break; \ 100 } \ 101 } \ 102 else if((__HANDLE__)->Instance == USART2) \ 103 { \ 104 switch(__HAL_RCC_GET_USART2_SOURCE()) \ 105 { \ 106 case RCC_USART2CLKSOURCE_PCLK1: \ 107 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1; \ 108 break; \ 109 case RCC_USART2CLKSOURCE_HSI: \ 110 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 111 break; \ 112 case RCC_USART2CLKSOURCE_CSI: \ 113 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_CSI; \ 114 break; \ 115 case RCC_USART2CLKSOURCE_LSE: \ 116 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 117 break; \ 118 case RCC_USART2CLKSOURCE_PLL2Q: \ 119 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PLL2Q; \ 120 break; \ 121 case RCC_USART2CLKSOURCE_PLL3Q: \ 122 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PLL3Q; \ 123 break; \ 124 default: \ 125 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 126 break; \ 127 } \ 128 } \ 129 else if((__HANDLE__)->Instance == USART3) \ 130 { \ 131 switch(__HAL_RCC_GET_USART3_SOURCE()) \ 132 { \ 133 case RCC_USART3CLKSOURCE_PCLK1: \ 134 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1; \ 135 break; \ 136 case RCC_USART3CLKSOURCE_HSI: \ 137 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 138 break; \ 139 case RCC_USART3CLKSOURCE_CSI: \ 140 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_CSI; \ 141 break; \ 142 case RCC_USART3CLKSOURCE_LSE: \ 143 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 144 break; \ 145 case RCC_USART3CLKSOURCE_PLL2Q: \ 146 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PLL2Q; \ 147 break; \ 148 case RCC_USART3CLKSOURCE_PLL3Q: \ 149 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PLL3Q; \ 150 break; \ 151 default: \ 152 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 153 break; \ 154 } \ 155 } \ 156 else if((__HANDLE__)->Instance == UART4) \ 157 { \ 158 switch(__HAL_RCC_GET_UART4_SOURCE()) \ 159 { \ 160 case RCC_UART4CLKSOURCE_PCLK1: \ 161 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1; \ 162 break; \ 163 case RCC_UART4CLKSOURCE_HSI: \ 164 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 165 break; \ 166 case RCC_UART4CLKSOURCE_CSI: \ 167 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_CSI; \ 168 break; \ 169 case RCC_UART4CLKSOURCE_LSE: \ 170 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 171 break; \ 172 case RCC_UART4CLKSOURCE_PLL2Q: \ 173 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PLL2Q; \ 174 break; \ 175 case RCC_UART4CLKSOURCE_PLL3Q: \ 176 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PLL3Q; \ 177 break; \ 178 default: \ 179 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 180 break; \ 181 } \ 182 } \ 183 else if((__HANDLE__)->Instance == UART5) \ 184 { \ 185 switch(__HAL_RCC_GET_UART5_SOURCE()) \ 186 { \ 187 case RCC_UART5CLKSOURCE_PCLK1: \ 188 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1; \ 189 break; \ 190 case RCC_UART5CLKSOURCE_HSI: \ 191 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 192 break; \ 193 case RCC_UART5CLKSOURCE_CSI: \ 194 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_CSI; \ 195 break; \ 196 case RCC_UART5CLKSOURCE_LSE: \ 197 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 198 break; \ 199 case RCC_UART5CLKSOURCE_PLL2Q: \ 200 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PLL2Q; \ 201 break; \ 202 case RCC_UART5CLKSOURCE_PLL3Q: \ 203 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PLL3Q; \ 204 break; \ 205 default: \ 206 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 207 break; \ 208 } \ 209 } \ 210 else if((__HANDLE__)->Instance == USART6) \ 211 { \ 212 switch(__HAL_RCC_GET_USART6_SOURCE()) \ 213 { \ 214 case RCC_USART6CLKSOURCE_PCLK1: \ 215 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1; \ 216 break; \ 217 case RCC_USART6CLKSOURCE_HSI: \ 218 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 219 break; \ 220 case RCC_USART6CLKSOURCE_CSI: \ 221 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_CSI; \ 222 break; \ 223 case RCC_USART6CLKSOURCE_LSE: \ 224 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 225 break; \ 226 case RCC_USART6CLKSOURCE_PLL2Q: \ 227 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PLL2Q; \ 228 break; \ 229 case RCC_USART6CLKSOURCE_PLL3Q: \ 230 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PLL3Q; \ 231 break; \ 232 default: \ 233 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 234 break; \ 235 } \ 236 } \ 237 else if((__HANDLE__)->Instance == UART7) \ 238 { \ 239 switch(__HAL_RCC_GET_UART7_SOURCE()) \ 240 { \ 241 case RCC_UART7CLKSOURCE_PCLK1: \ 242 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1; \ 243 break; \ 244 case RCC_UART7CLKSOURCE_HSI: \ 245 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 246 break; \ 247 case RCC_UART7CLKSOURCE_CSI: \ 248 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_CSI; \ 249 break; \ 250 case RCC_UART7CLKSOURCE_LSE: \ 251 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 252 break; \ 253 case RCC_UART7CLKSOURCE_PLL2Q: \ 254 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PLL2Q; \ 255 break; \ 256 case RCC_UART7CLKSOURCE_PLL3Q: \ 257 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PLL3Q; \ 258 break; \ 259 default: \ 260 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 261 break; \ 262 } \ 263 } \ 264 else if((__HANDLE__)->Instance == UART8) \ 265 { \ 266 switch(__HAL_RCC_GET_UART8_SOURCE()) \ 267 { \ 268 case RCC_UART8CLKSOURCE_PCLK1: \ 269 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1; \ 270 break; \ 271 case RCC_UART8CLKSOURCE_HSI: \ 272 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 273 break; \ 274 case RCC_UART8CLKSOURCE_CSI: \ 275 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_CSI; \ 276 break; \ 277 case RCC_UART8CLKSOURCE_LSE: \ 278 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 279 break; \ 280 case RCC_UART8CLKSOURCE_PLL2Q: \ 281 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PLL2Q; \ 282 break; \ 283 case RCC_UART8CLKSOURCE_PLL3Q: \ 284 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PLL3Q; \ 285 break; \ 286 default: \ 287 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 288 break; \ 289 } \ 290 } \ 291 else if((__HANDLE__)->Instance == UART9) \ 292 { \ 293 switch(__HAL_RCC_GET_UART9_SOURCE()) \ 294 { \ 295 case RCC_UART9CLKSOURCE_PCLK1: \ 296 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1; \ 297 break; \ 298 case RCC_UART9CLKSOURCE_HSI: \ 299 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 300 break; \ 301 case RCC_UART9CLKSOURCE_CSI: \ 302 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_CSI; \ 303 break; \ 304 case RCC_UART9CLKSOURCE_LSE: \ 305 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 306 break; \ 307 case RCC_UART9CLKSOURCE_PLL2Q: \ 308 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PLL2Q; \ 309 break; \ 310 case RCC_UART9CLKSOURCE_PLL3Q: \ 311 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PLL3Q; \ 312 break; \ 313 default: \ 314 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 315 break; \ 316 } \ 317 } \ 318 else if((__HANDLE__)->Instance == USART10) \ 319 { \ 320 switch(__HAL_RCC_GET_USART10_SOURCE()) \ 321 { \ 322 case RCC_USART10CLKSOURCE_PCLK1: \ 323 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1; \ 324 break; \ 325 case RCC_USART10CLKSOURCE_HSI: \ 326 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 327 break; \ 328 case RCC_USART10CLKSOURCE_CSI: \ 329 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_CSI; \ 330 break; \ 331 case RCC_USART10CLKSOURCE_LSE: \ 332 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 333 break; \ 334 case RCC_USART10CLKSOURCE_PLL2Q: \ 335 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PLL2Q; \ 336 break; \ 337 case RCC_USART10CLKSOURCE_PLL3Q: \ 338 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PLL3Q; \ 339 break; \ 340 default: \ 341 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 342 break; \ 343 } \ 344 } \ 345 else if((__HANDLE__)->Instance == USART11) \ 346 { \ 347 switch(__HAL_RCC_GET_USART11_SOURCE()) \ 348 { \ 349 case RCC_USART11CLKSOURCE_PCLK1: \ 350 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1; \ 351 break; \ 352 case RCC_USART11CLKSOURCE_HSI: \ 353 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 354 break; \ 355 case RCC_USART11CLKSOURCE_CSI: \ 356 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_CSI; \ 357 break; \ 358 case RCC_USART11CLKSOURCE_LSE: \ 359 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 360 break; \ 361 case RCC_USART11CLKSOURCE_PLL2Q: \ 362 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PLL2Q; \ 363 break; \ 364 case RCC_USART11CLKSOURCE_PLL3Q: \ 365 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PLL3Q; \ 366 break; \ 367 default: \ 368 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 369 break; \ 370 } \ 371 } \ 372 else if((__HANDLE__)->Instance == UART12) \ 373 { \ 374 switch(__HAL_RCC_GET_UART12_SOURCE()) \ 375 { \ 376 case RCC_UART12CLKSOURCE_PCLK1: \ 377 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1; \ 378 break; \ 379 case RCC_UART12CLKSOURCE_HSI: \ 380 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 381 break; \ 382 case RCC_UART12CLKSOURCE_CSI: \ 383 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_CSI; \ 384 break; \ 385 case RCC_UART12CLKSOURCE_LSE: \ 386 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 387 break; \ 388 case RCC_UART12CLKSOURCE_PLL2Q: \ 389 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PLL2Q; \ 390 break; \ 391 case RCC_UART12CLKSOURCE_PLL3Q: \ 392 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PLL3Q; \ 393 break; \ 394 default: \ 395 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 396 break; \ 397 } \ 398 } \ 399 else \ 400 { \ 401 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 402 } \ 403 } while(0U) 404 #elif (defined(STM32H523xx) || defined(STM32H533xx)) 405 #define IRDA_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__) \ 406 do { \ 407 if((__HANDLE__)->Instance == USART1) \ 408 { \ 409 switch(__HAL_RCC_GET_USART1_SOURCE()) \ 410 { \ 411 case RCC_USART1CLKSOURCE_PCLK2: \ 412 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK2; \ 413 break; \ 414 case RCC_USART1CLKSOURCE_CSI: \ 415 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_CSI; \ 416 break; \ 417 case RCC_USART1CLKSOURCE_HSI: \ 418 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 419 break; \ 420 case RCC_USART1CLKSOURCE_LSE: \ 421 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 422 break; \ 423 case RCC_USART1CLKSOURCE_PLL2Q: \ 424 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PLL2Q; \ 425 break; \ 426 case RCC_USART1CLKSOURCE_PLL3Q: \ 427 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PLL3Q; \ 428 break; \ 429 default: \ 430 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 431 break; \ 432 } \ 433 } \ 434 else if((__HANDLE__)->Instance == USART2) \ 435 { \ 436 switch(__HAL_RCC_GET_USART2_SOURCE()) \ 437 { \ 438 case RCC_USART2CLKSOURCE_PCLK1: \ 439 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1; \ 440 break; \ 441 case RCC_USART2CLKSOURCE_CSI: \ 442 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_CSI; \ 443 break; \ 444 case RCC_USART2CLKSOURCE_HSI: \ 445 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 446 break; \ 447 case RCC_USART2CLKSOURCE_LSE: \ 448 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 449 break; \ 450 case RCC_USART2CLKSOURCE_PLL2Q: \ 451 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PLL2Q; \ 452 break; \ 453 case RCC_USART2CLKSOURCE_PLL3Q: \ 454 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PLL3Q; \ 455 break; \ 456 default: \ 457 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 458 break; \ 459 } \ 460 } \ 461 else if((__HANDLE__)->Instance == USART3) \ 462 { \ 463 switch(__HAL_RCC_GET_USART3_SOURCE()) \ 464 { \ 465 case RCC_USART3CLKSOURCE_PCLK1: \ 466 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1; \ 467 break; \ 468 case RCC_USART3CLKSOURCE_CSI: \ 469 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_CSI; \ 470 break; \ 471 case RCC_USART3CLKSOURCE_HSI: \ 472 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 473 break; \ 474 case RCC_USART3CLKSOURCE_LSE: \ 475 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 476 break; \ 477 case RCC_USART3CLKSOURCE_PLL2Q: \ 478 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PLL2Q; \ 479 break; \ 480 case RCC_USART3CLKSOURCE_PLL3Q: \ 481 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PLL3Q; \ 482 break; \ 483 default: \ 484 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 485 break; \ 486 } \ 487 } \ 488 else if((__HANDLE__)->Instance == UART4) \ 489 { \ 490 switch(__HAL_RCC_GET_UART4_SOURCE()) \ 491 { \ 492 case RCC_UART4CLKSOURCE_PCLK1: \ 493 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1; \ 494 break; \ 495 case RCC_UART4CLKSOURCE_HSI: \ 496 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 497 break; \ 498 case RCC_UART4CLKSOURCE_CSI: \ 499 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_CSI; \ 500 break; \ 501 case RCC_UART4CLKSOURCE_LSE: \ 502 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 503 break; \ 504 case RCC_UART4CLKSOURCE_PLL2Q: \ 505 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PLL2Q; \ 506 break; \ 507 case RCC_UART4CLKSOURCE_PLL3Q: \ 508 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PLL3Q; \ 509 break; \ 510 default: \ 511 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 512 break; \ 513 } \ 514 } \ 515 else if((__HANDLE__)->Instance == UART5) \ 516 { \ 517 switch(__HAL_RCC_GET_UART5_SOURCE()) \ 518 { \ 519 case RCC_UART5CLKSOURCE_PCLK1: \ 520 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1; \ 521 break; \ 522 case RCC_UART5CLKSOURCE_HSI: \ 523 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 524 break; \ 525 case RCC_UART5CLKSOURCE_CSI: \ 526 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_CSI; \ 527 break; \ 528 case RCC_UART5CLKSOURCE_LSE: \ 529 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 530 break; \ 531 case RCC_UART5CLKSOURCE_PLL2Q: \ 532 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PLL2Q; \ 533 break; \ 534 case RCC_UART5CLKSOURCE_PLL3Q: \ 535 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PLL3Q; \ 536 break; \ 537 default: \ 538 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 539 break; \ 540 } \ 541 } \ 542 else if((__HANDLE__)->Instance == USART6) \ 543 { \ 544 switch(__HAL_RCC_GET_USART6_SOURCE()) \ 545 { \ 546 case RCC_USART6CLKSOURCE_PCLK1: \ 547 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1; \ 548 break; \ 549 case RCC_USART6CLKSOURCE_CSI: \ 550 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_CSI; \ 551 break; \ 552 case RCC_USART6CLKSOURCE_HSI: \ 553 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 554 break; \ 555 case RCC_USART6CLKSOURCE_LSE: \ 556 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 557 break; \ 558 case RCC_USART6CLKSOURCE_PLL2Q: \ 559 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PLL2Q; \ 560 break; \ 561 case RCC_USART6CLKSOURCE_PLL3Q: \ 562 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PLL3Q; \ 563 break; \ 564 default: \ 565 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 566 break; \ 567 } \ 568 } \ 569 else \ 570 { \ 571 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 572 } \ 573 } while(0U) 574 #else 575 #define IRDA_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__) \ 576 do { \ 577 if((__HANDLE__)->Instance == USART1) \ 578 { \ 579 switch(__HAL_RCC_GET_USART1_SOURCE()) \ 580 { \ 581 case RCC_USART1CLKSOURCE_PCLK2: \ 582 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK2; \ 583 break; \ 584 case RCC_USART1CLKSOURCE_HSI: \ 585 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 586 break; \ 587 case RCC_USART1CLKSOURCE_CSI: \ 588 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_CSI; \ 589 break; \ 590 case RCC_USART1CLKSOURCE_LSE: \ 591 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 592 break; \ 593 case RCC_USART1CLKSOURCE_PLL2Q: \ 594 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PLL2Q; \ 595 break; \ 596 default: \ 597 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 598 break; \ 599 } \ 600 } \ 601 else if((__HANDLE__)->Instance == USART2) \ 602 { \ 603 switch(__HAL_RCC_GET_USART2_SOURCE()) \ 604 { \ 605 case RCC_USART2CLKSOURCE_PCLK1: \ 606 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1; \ 607 break; \ 608 case RCC_USART2CLKSOURCE_HSI: \ 609 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 610 break; \ 611 case RCC_USART2CLKSOURCE_CSI: \ 612 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_CSI; \ 613 break; \ 614 case RCC_USART2CLKSOURCE_LSE: \ 615 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 616 break; \ 617 case RCC_USART2CLKSOURCE_PLL2Q: \ 618 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PLL2Q; \ 619 break; \ 620 default: \ 621 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 622 break; \ 623 } \ 624 } \ 625 else if((__HANDLE__)->Instance == USART3) \ 626 { \ 627 switch(__HAL_RCC_GET_USART3_SOURCE()) \ 628 { \ 629 case RCC_USART3CLKSOURCE_PCLK1: \ 630 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1; \ 631 break; \ 632 case RCC_USART3CLKSOURCE_HSI: \ 633 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 634 break; \ 635 case RCC_USART3CLKSOURCE_CSI: \ 636 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_CSI; \ 637 break; \ 638 case RCC_USART3CLKSOURCE_LSE: \ 639 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 640 break; \ 641 case RCC_USART3CLKSOURCE_PLL2Q: \ 642 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PLL2Q; \ 643 break; \ 644 default: \ 645 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 646 break; \ 647 } \ 648 } \ 649 else \ 650 { \ 651 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 652 } \ 653 } while(0U) 654 655 #endif /* (defined(STM32H573xx) || defined(STM32H563xx) || defined(STM32H562xx) */ 656 657 /** @brief Compute the mask to apply to retrieve the received data 658 * according to the word length and to the parity bits activation. 659 * @param __HANDLE__ specifies the IRDA Handle. 660 * @retval None, the mask to apply to the associated UART RDR register is stored in (__HANDLE__)->Mask field. 661 */ 662 #define IRDA_MASK_COMPUTATION(__HANDLE__) \ 663 do { \ 664 if ((__HANDLE__)->Init.WordLength == IRDA_WORDLENGTH_9B) \ 665 { \ 666 if ((__HANDLE__)->Init.Parity == IRDA_PARITY_NONE) \ 667 { \ 668 (__HANDLE__)->Mask = 0x01FFU ; \ 669 } \ 670 else \ 671 { \ 672 (__HANDLE__)->Mask = 0x00FFU ; \ 673 } \ 674 } \ 675 else if ((__HANDLE__)->Init.WordLength == IRDA_WORDLENGTH_8B) \ 676 { \ 677 if ((__HANDLE__)->Init.Parity == IRDA_PARITY_NONE) \ 678 { \ 679 (__HANDLE__)->Mask = 0x00FFU ; \ 680 } \ 681 else \ 682 { \ 683 (__HANDLE__)->Mask = 0x007FU ; \ 684 } \ 685 } \ 686 else if ((__HANDLE__)->Init.WordLength == IRDA_WORDLENGTH_7B) \ 687 { \ 688 if ((__HANDLE__)->Init.Parity == IRDA_PARITY_NONE) \ 689 { \ 690 (__HANDLE__)->Mask = 0x007FU ; \ 691 } \ 692 else \ 693 { \ 694 (__HANDLE__)->Mask = 0x003FU ; \ 695 } \ 696 } \ 697 else \ 698 { \ 699 (__HANDLE__)->Mask = 0x0000U; \ 700 } \ 701 } while(0U) 702 703 /** @brief Ensure that IRDA frame length is valid. 704 * @param __LENGTH__ IRDA frame length. 705 * @retval SET (__LENGTH__ is valid) or RESET (__LENGTH__ is invalid) 706 */ 707 #define IS_IRDA_WORD_LENGTH(__LENGTH__) (((__LENGTH__) == IRDA_WORDLENGTH_7B) || \ 708 ((__LENGTH__) == IRDA_WORDLENGTH_8B) || \ 709 ((__LENGTH__) == IRDA_WORDLENGTH_9B)) 710 /** 711 * @} 712 */ 713 714 /* Exported functions --------------------------------------------------------*/ 715 716 /** 717 * @} 718 */ 719 720 /** 721 * @} 722 */ 723 724 #ifdef __cplusplus 725 } 726 #endif 727 728 #endif /* STM32H5xx_HAL_IRDA_EX_H */ 729
