source: trunk/firmware/Drivers/STM32G0xx_HAL_Driver/Inc/stm32g0xx_hal_rng.h

Last change on this file was 6, checked in by f.jahn, 8 months ago
File size: 12.3 KB
Line 
1/**
2 ******************************************************************************
3 * @file stm32g0xx_hal_rng.h
4 * @author MCD Application Team
5 * @brief Header file of RNG HAL module.
6 ******************************************************************************
7 * @attention
8 *
9 * <h2><center>&copy; Copyright (c) 2018 STMicroelectronics.
10 * All rights reserved.</center></h2>
11 *
12 * This software component is licensed by ST under BSD 3-Clause license,
13 * the "License"; You may not use this file except in compliance with the
14 * License. You may obtain a copy of the License at:
15 * opensource.org/licenses/BSD-3-Clause
16 *
17 ******************************************************************************
18 */
19
20/* Define to prevent recursive inclusion -------------------------------------*/
21#ifndef STM32G0xx_HAL_RNG_H
22#define STM32G0xx_HAL_RNG_H
23
24#ifdef __cplusplus
25extern "C" {
26#endif
27
28#if defined(STM32G081xx) || defined(STM32G041xx)
29/* Includes ------------------------------------------------------------------*/
30#include "stm32g0xx_hal_def.h"
31
32/** @addtogroup STM32G0xx_HAL_Driver
33 * @{
34 */
35
36/** @defgroup RNG RNG
37 * @brief RNG HAL module driver
38 * @{
39 */
40
41/* Exported types ------------------------------------------------------------*/
42
43/** @defgroup RNG_Exported_Types RNG Exported Types
44 * @{
45 */
46
47/** @defgroup RNG_Exported_Types_Group1 RNG Init Structure definition
48 * @{
49 */
50typedef struct
51{
52 uint32_t ClockErrorDetection; /*!< CED Clock error detection */
53} RNG_InitTypeDef;
54
55/**
56 * @}
57 */
58
59/** @defgroup RNG_Exported_Types_Group2 RNG State Structure definition
60 * @{
61 */
62typedef enum
63{
64 HAL_RNG_STATE_RESET = 0x00U, /*!< RNG not yet initialized or disabled */
65 HAL_RNG_STATE_READY = 0x01U, /*!< RNG initialized and ready for use */
66 HAL_RNG_STATE_BUSY = 0x02U, /*!< RNG internal process is ongoing */
67 HAL_RNG_STATE_TIMEOUT = 0x03U, /*!< RNG timeout state */
68 HAL_RNG_STATE_ERROR = 0x04U /*!< RNG error state */
69
70} HAL_RNG_StateTypeDef;
71
72/**
73 * @}
74 */
75
76/** @defgroup RNG_Exported_Types_Group3 RNG Handle Structure definition
77 * @{
78 */
79#if (USE_HAL_RNG_REGISTER_CALLBACKS == 1)
80typedef struct __RNG_HandleTypeDef
81#else
82typedef struct
83#endif
84{
85 RNG_TypeDef *Instance; /*!< Register base address */
86
87 RNG_InitTypeDef Init; /*!< RNG configuration parameters */
88
89 HAL_LockTypeDef Lock; /*!< RNG locking object */
90
91 __IO HAL_RNG_StateTypeDef State; /*!< RNG communication state */
92
93 __IO uint32_t ErrorCode; /*!< RNG Error code */
94
95 uint32_t RandomNumber; /*!< Last Generated RNG Data */
96
97#if (USE_HAL_RNG_REGISTER_CALLBACKS == 1)
98 void (* ReadyDataCallback)(struct __RNG_HandleTypeDef *hrng, uint32_t random32bit); /*!< RNG Data Ready Callback */
99 void (* ErrorCallback)(struct __RNG_HandleTypeDef *hrng); /*!< RNG Error Callback */
100
101 void (* MspInitCallback)(struct __RNG_HandleTypeDef *hrng); /*!< RNG Msp Init callback */
102 void (* MspDeInitCallback)(struct __RNG_HandleTypeDef *hrng); /*!< RNG Msp DeInit callback */
103#endif /* USE_HAL_RNG_REGISTER_CALLBACKS */
104
105} RNG_HandleTypeDef;
106
107#if (USE_HAL_RNG_REGISTER_CALLBACKS == 1)
108/**
109 * @brief HAL RNG Callback ID enumeration definition
110 */
111typedef enum
112{
113 HAL_RNG_ERROR_CB_ID = 0x00U, /*!< RNG Error Callback ID */
114
115 HAL_RNG_MSPINIT_CB_ID = 0x01U, /*!< RNG MspInit callback ID */
116 HAL_RNG_MSPDEINIT_CB_ID = 0x02U /*!< RNG MspDeInit callback ID */
117
118} HAL_RNG_CallbackIDTypeDef;
119
120/**
121 * @brief HAL RNG Callback pointer definition
122 */
123typedef void (*pRNG_CallbackTypeDef)(RNG_HandleTypeDef *hrng); /*!< pointer to a common RNG callback function */
124typedef void (*pRNG_ReadyDataCallbackTypeDef)(RNG_HandleTypeDef *hrng, uint32_t random32bit); /*!< pointer to an RNG Data Ready specific callback function */
125
126#endif /* USE_HAL_RNG_REGISTER_CALLBACKS */
127
128/**
129 * @}
130 */
131
132/**
133 * @}
134 */
135
136/* Exported constants --------------------------------------------------------*/
137/** @defgroup RNG_Exported_Constants RNG Exported Constants
138 * @{
139 */
140
141/** @defgroup RNG_Exported_Constants_Group1 RNG Interrupt definition
142 * @{
143 */
144#define RNG_IT_DRDY RNG_SR_DRDY /*!< Data Ready interrupt */
145#define RNG_IT_CEI RNG_SR_CEIS /*!< Clock error interrupt */
146#define RNG_IT_SEI RNG_SR_SEIS /*!< Seed error interrupt */
147/**
148 * @}
149 */
150
151/** @defgroup RNG_Exported_Constants_Group2 RNG Flag definition
152 * @{
153 */
154#define RNG_FLAG_DRDY RNG_SR_DRDY /*!< Data ready */
155#define RNG_FLAG_CECS RNG_SR_CECS /*!< Clock error current status */
156#define RNG_FLAG_SECS RNG_SR_SECS /*!< Seed error current status */
157/**
158 * @}
159 */
160
161/** @defgroup RNG_Exported_Constants_Group3 RNG Clock Error Detection
162 * @{
163 */
164#define RNG_CED_ENABLE 0x00000000U /*!< Clock error detection Enabled */
165#define RNG_CED_DISABLE RNG_CR_CED /*!< Clock error detection Disabled */
166/**
167 * @}
168 */
169
170/** @defgroup RNG_Error_Definition RNG Error Definition
171 * @{
172 */
173#define HAL_RNG_ERROR_NONE 0x00000000U /*!< No error */
174#if (USE_HAL_RNG_REGISTER_CALLBACKS == 1)
175#define HAL_RNG_ERROR_INVALID_CALLBACK 0x00000001U /*!< Invalid Callback error */
176#endif /* USE_HAL_RNG_REGISTER_CALLBACKS */
177#define HAL_RNG_ERROR_TIMEOUT 0x00000002U /*!< Timeout error */
178
179/**
180 * @}
181 */
182
183/**
184 * @}
185 */
186
187/* Exported macros -----------------------------------------------------------*/
188/** @defgroup RNG_Exported_Macros RNG Exported Macros
189 * @{
190 */
191
192/** @brief Reset RNG handle state
193 * @param __HANDLE__ RNG Handle
194 * @retval None
195 */
196#if (USE_HAL_RNG_REGISTER_CALLBACKS == 1)
197#define __HAL_RNG_RESET_HANDLE_STATE(__HANDLE__) do{ \
198 (__HANDLE__)->State = HAL_RNG_STATE_RESET; \
199 (__HANDLE__)->MspInitCallback = NULL; \
200 (__HANDLE__)->MspDeInitCallback = NULL; \
201 } while(0U)
202#else
203#define __HAL_RNG_RESET_HANDLE_STATE(__HANDLE__) ((__HANDLE__)->State = HAL_RNG_STATE_RESET)
204#endif /*USE_HAL_RNG_REGISTER_CALLBACKS */
205
206/**
207 * @brief Enables the RNG peripheral.
208 * @param __HANDLE__ RNG Handle
209 * @retval None
210 */
211#define __HAL_RNG_ENABLE(__HANDLE__) ((__HANDLE__)->Instance->CR |= RNG_CR_RNGEN)
212
213/**
214 * @brief Disables the RNG peripheral.
215 * @param __HANDLE__ RNG Handle
216 * @retval None
217 */
218#define __HAL_RNG_DISABLE(__HANDLE__) ((__HANDLE__)->Instance->CR &= ~RNG_CR_RNGEN)
219
220/**
221 * @brief Check the selected RNG flag status.
222 * @param __HANDLE__ RNG Handle
223 * @param __FLAG__ RNG flag
224 * This parameter can be one of the following values:
225 * @arg RNG_FLAG_DRDY: Data ready
226 * @arg RNG_FLAG_CECS: Clock error current status
227 * @arg RNG_FLAG_SECS: Seed error current status
228 * @retval The new state of __FLAG__ (SET or RESET).
229 */
230#define __HAL_RNG_GET_FLAG(__HANDLE__, __FLAG__) (((__HANDLE__)->Instance->SR & (__FLAG__)) == (__FLAG__))
231
232/**
233 * @brief Clears the selected RNG flag status.
234 * @param __HANDLE__ RNG handle
235 * @param __FLAG__ RNG flag to clear
236 * @note WARNING: This is a dummy macro for HAL code alignment,
237 * flags RNG_FLAG_DRDY, RNG_FLAG_CECS and RNG_FLAG_SECS are read-only.
238 * @retval None
239 */
240#define __HAL_RNG_CLEAR_FLAG(__HANDLE__, __FLAG__) /* dummy macro */
241
242/**
243 * @brief Enables the RNG interrupts.
244 * @param __HANDLE__ RNG Handle
245 * @retval None
246 */
247#define __HAL_RNG_ENABLE_IT(__HANDLE__) ((__HANDLE__)->Instance->CR |= RNG_CR_IE)
248
249/**
250 * @brief Disables the RNG interrupts.
251 * @param __HANDLE__ RNG Handle
252 * @retval None
253 */
254#define __HAL_RNG_DISABLE_IT(__HANDLE__) ((__HANDLE__)->Instance->CR &= ~RNG_CR_IE)
255
256/**
257 * @brief Checks whether the specified RNG interrupt has occurred or not.
258 * @param __HANDLE__ RNG Handle
259 * @param __INTERRUPT__ specifies the RNG interrupt status flag to check.
260 * This parameter can be one of the following values:
261 * @arg RNG_IT_DRDY: Data ready interrupt
262 * @arg RNG_IT_CEI: Clock error interrupt
263 * @arg RNG_IT_SEI: Seed error interrupt
264 * @retval The new state of __INTERRUPT__ (SET or RESET).
265 */
266#define __HAL_RNG_GET_IT(__HANDLE__, __INTERRUPT__) (((__HANDLE__)->Instance->SR & (__INTERRUPT__)) == (__INTERRUPT__))
267
268/**
269 * @brief Clear the RNG interrupt status flags.
270 * @param __HANDLE__ RNG Handle
271 * @param __INTERRUPT__ specifies the RNG interrupt status flag to clear.
272 * This parameter can be one of the following values:
273 * @arg RNG_IT_CEI: Clock error interrupt
274 * @arg RNG_IT_SEI: Seed error interrupt
275 * @note RNG_IT_DRDY flag is read-only, reading RNG_DR register automatically clears RNG_IT_DRDY.
276 * @retval None
277 */
278#define __HAL_RNG_CLEAR_IT(__HANDLE__, __INTERRUPT__) (((__HANDLE__)->Instance->SR) = ~(__INTERRUPT__))
279
280/**
281 * @}
282 */
283
284/* Exported functions --------------------------------------------------------*/
285/** @defgroup RNG_Exported_Functions RNG Exported Functions
286 * @{
287 */
288
289/** @defgroup RNG_Exported_Functions_Group1 Initialization and configuration functions
290 * @{
291 */
292HAL_StatusTypeDef HAL_RNG_Init(RNG_HandleTypeDef *hrng);
293HAL_StatusTypeDef HAL_RNG_DeInit(RNG_HandleTypeDef *hrng);
294void HAL_RNG_MspInit(RNG_HandleTypeDef *hrng);
295void HAL_RNG_MspDeInit(RNG_HandleTypeDef *hrng);
296
297/* Callbacks Register/UnRegister functions ***********************************/
298#if (USE_HAL_RNG_REGISTER_CALLBACKS == 1)
299HAL_StatusTypeDef HAL_RNG_RegisterCallback(RNG_HandleTypeDef *hrng, HAL_RNG_CallbackIDTypeDef CallbackID, pRNG_CallbackTypeDef pCallback);
300HAL_StatusTypeDef HAL_RNG_UnRegisterCallback(RNG_HandleTypeDef *hrng, HAL_RNG_CallbackIDTypeDef CallbackID);
301
302HAL_StatusTypeDef HAL_RNG_RegisterReadyDataCallback(RNG_HandleTypeDef *hrng, pRNG_ReadyDataCallbackTypeDef pCallback);
303HAL_StatusTypeDef HAL_RNG_UnRegisterReadyDataCallback(RNG_HandleTypeDef *hrng);
304#endif /* USE_HAL_RNG_REGISTER_CALLBACKS */
305
306/**
307 * @}
308 */
309
310/** @defgroup RNG_Exported_Functions_Group2 Peripheral Control functions
311 * @{
312 */
313HAL_StatusTypeDef HAL_RNG_GenerateRandomNumber(RNG_HandleTypeDef *hrng, uint32_t *random32bit);
314HAL_StatusTypeDef HAL_RNG_GenerateRandomNumber_IT(RNG_HandleTypeDef *hrng);
315uint32_t HAL_RNG_ReadLastRandomNumber(RNG_HandleTypeDef *hrng);
316
317void HAL_RNG_IRQHandler(RNG_HandleTypeDef *hrng);
318void HAL_RNG_ErrorCallback(RNG_HandleTypeDef *hrng);
319void HAL_RNG_ReadyDataCallback(RNG_HandleTypeDef *hrng, uint32_t random32bit);
320
321/**
322 * @}
323 */
324
325/** @defgroup RNG_Exported_Functions_Group3 Peripheral State functions
326 * @{
327 */
328HAL_RNG_StateTypeDef HAL_RNG_GetState(RNG_HandleTypeDef *hrng);
329uint32_t HAL_RNG_GetError(RNG_HandleTypeDef *hrng);
330/**
331 * @}
332 */
333
334/**
335 * @}
336 */
337
338/* Private macros ------------------------------------------------------------*/
339/** @defgroup RNG_Private_Macros RNG Private Macros
340 * @{
341 */
342#define IS_RNG_IT(IT) (((IT) == RNG_IT_CEI) || \
343 ((IT) == RNG_IT_SEI))
344
345#define IS_RNG_FLAG(FLAG) (((FLAG) == RNG_FLAG_DRDY) || \
346 ((FLAG) == RNG_FLAG_CECS) || \
347 ((FLAG) == RNG_FLAG_SECS))
348/**
349 * @brief Verify the RNG Clock Error Detection mode.
350 * @param __MODE__ RNG Clock Error Detection mode
351 * @retval SET (__MODE__ is valid) or RESET (__MODE__ is invalid)
352 */
353#define IS_RNG_CED(__MODE__) (((__MODE__) == RNG_CED_ENABLE) || \
354 ((__MODE__) == RNG_CED_DISABLE))
355/**
356 * @}
357 */
358
359/**
360 * @}
361 */
362
363/**
364 * @}
365 */
366
367#endif
368#ifdef __cplusplus
369}
370#endif
371
372#endif /* STM32G0xx_HAL_RNG_H */
373
374/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
Note: See TracBrowser for help on using the repository browser.