1 /**
2   ******************************************************************************
3   * @file    stm32h7rsxx_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) 2022 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 STM32H7RSxx_HAL_IRDA_EX_H
21 #define STM32H7RSxx_HAL_IRDA_EX_H
22 
23 #ifdef __cplusplus
24 extern "C" {
25 #endif
26 
27 /* Includes ------------------------------------------------------------------*/
28 #include "stm32h7rsxx_hal_def.h"
29 
30 /** @addtogroup STM32H7RSxx_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 /** @brief  Return clock source used for USART instance used for IRDA.
73   * @param  __HANDLE__ specifies the UART Handle.
74   * @param  __CLOCKSOURCE__ output variable.
75   * @retval USART clocking source, written in __CLOCKSOURCE__.
76   */
77 #define IRDA_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__)       \
78   do {                                                        \
79     if((__HANDLE__)->Instance == USART1)                      \
80     {                                                         \
81       switch(__HAL_RCC_GET_USART1_SOURCE())                   \
82       {                                                       \
83         case RCC_USART1CLKSOURCE_PCLK2:                       \
84           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK2;         \
85           break;                                              \
86         case RCC_USART1CLKSOURCE_PLL2Q:                       \
87           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PLL2Q;         \
88           break;                                              \
89         case RCC_USART1CLKSOURCE_PLL3Q:                       \
90           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PLL3Q;         \
91           break;                                              \
92         case RCC_USART1CLKSOURCE_HSI:                         \
93           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI;           \
94           break;                                              \
95         case RCC_USART1CLKSOURCE_CSI:                         \
96           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_CSI;           \
97           break;                                              \
98         case RCC_USART1CLKSOURCE_LSE:                         \
99           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE;           \
100           break;                                              \
101         default:                                              \
102           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED;     \
103           break;                                              \
104       }                                                       \
105     }                                                         \
106     else if(((__HANDLE__)->Instance == USART2) ||             \
107             ((__HANDLE__)->Instance == USART3) ||             \
108             ((__HANDLE__)->Instance == UART4) ||              \
109             ((__HANDLE__)->Instance == UART5) ||              \
110             ((__HANDLE__)->Instance == UART7) ||              \
111             ((__HANDLE__)->Instance == UART8))                \
112     {                                                         \
113       switch(__HAL_RCC_GET_USART234578_SOURCE())              \
114       {                                                       \
115         case RCC_USART234578CLKSOURCE_PCLK1:                  \
116           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1;         \
117           break;                                              \
118         case RCC_USART234578CLKSOURCE_PLL2Q:                  \
119           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PLL2Q;         \
120           break;                                              \
121         case RCC_USART234578CLKSOURCE_PLL3Q:                  \
122           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PLL3Q;         \
123           break;                                              \
124         case RCC_USART234578CLKSOURCE_HSI:                    \
125           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI;           \
126           break;                                              \
127         case RCC_USART234578CLKSOURCE_CSI:                    \
128           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_CSI;           \
129           break;                                              \
130         case RCC_USART234578CLKSOURCE_LSE:                    \
131           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE;           \
132           break;                                              \
133         default:                                              \
134           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED;     \
135           break;                                              \
136       }                                                       \
137     }                                                         \
138     else                                                      \
139     {                                                         \
140       (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED;         \
141     }                                                         \
142   } while(0U)
143 
144 /** @brief  Compute the mask to apply to retrieve the received data
145   *         according to the word length and to the parity bits activation.
146   * @param  __HANDLE__ specifies the IRDA Handle.
147   * @retval None, the mask to apply to the associated UART RDR register is stored in (__HANDLE__)->Mask field.
148   */
149 #define IRDA_MASK_COMPUTATION(__HANDLE__)                             \
150   do {                                                                \
151     if ((__HANDLE__)->Init.WordLength == IRDA_WORDLENGTH_9B)          \
152     {                                                                 \
153       if ((__HANDLE__)->Init.Parity == IRDA_PARITY_NONE)              \
154       {                                                               \
155         (__HANDLE__)->Mask = 0x01FFU ;                                \
156       }                                                               \
157       else                                                            \
158       {                                                               \
159         (__HANDLE__)->Mask = 0x00FFU ;                                \
160       }                                                               \
161     }                                                                 \
162     else if ((__HANDLE__)->Init.WordLength == IRDA_WORDLENGTH_8B)     \
163     {                                                                 \
164       if ((__HANDLE__)->Init.Parity == IRDA_PARITY_NONE)              \
165       {                                                               \
166         (__HANDLE__)->Mask = 0x00FFU ;                                \
167       }                                                               \
168       else                                                            \
169       {                                                               \
170         (__HANDLE__)->Mask = 0x007FU ;                                \
171       }                                                               \
172     }                                                                 \
173     else if ((__HANDLE__)->Init.WordLength == IRDA_WORDLENGTH_7B)     \
174     {                                                                 \
175       if ((__HANDLE__)->Init.Parity == IRDA_PARITY_NONE)              \
176       {                                                               \
177         (__HANDLE__)->Mask = 0x007FU ;                                \
178       }                                                               \
179       else                                                            \
180       {                                                               \
181         (__HANDLE__)->Mask = 0x003FU ;                                \
182       }                                                               \
183     }                                                                 \
184     else                                                              \
185     {                                                                 \
186       (__HANDLE__)->Mask = 0x0000U;                                   \
187     }                                                                 \
188   } while(0U)
189 
190 /** @brief Ensure that IRDA frame length is valid.
191   * @param __LENGTH__ IRDA frame length.
192   * @retval SET (__LENGTH__ is valid) or RESET (__LENGTH__ is invalid)
193   */
194 #define IS_IRDA_WORD_LENGTH(__LENGTH__) (((__LENGTH__) == IRDA_WORDLENGTH_7B) || \
195                                          ((__LENGTH__) == IRDA_WORDLENGTH_8B) || \
196                                          ((__LENGTH__) == IRDA_WORDLENGTH_9B))
197 /**
198   * @}
199   */
200 
201 /* Exported functions --------------------------------------------------------*/
202 
203 /**
204   * @}
205   */
206 
207 /**
208   * @}
209   */
210 
211 #ifdef __cplusplus
212 }
213 #endif
214 
215 #endif /* STM32H7RSxx_HAL_IRDA_EX_H */
216