stm32f4xx_hal_rng.h

Go to the documentation of this file.

 
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef STM32F4xx_HAL_RNG_H
#define STM32F4xx_HAL_RNG_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* Includes ------------------------------------------------------------------*/
#include "stm32f4xx_hal_def.h"
 
#if defined (RNG)
 
/* Exported types ------------------------------------------------------------*/
 
typedef enum
{
  HAL_RNG_STATE_RESET     = 0x00U,  
  HAL_RNG_STATE_READY     = 0x01U,  
  HAL_RNG_STATE_BUSY      = 0x02U,  
  HAL_RNG_STATE_TIMEOUT   = 0x03U,  
  HAL_RNG_STATE_ERROR     = 0x04U   
} HAL_RNG_StateTypeDef;
 
#if (USE_HAL_RNG_REGISTER_CALLBACKS == 1)
typedef struct  __RNG_HandleTypeDef
#else
typedef struct
#endif /* USE_HAL_RNG_REGISTER_CALLBACKS */
{
  RNG_TypeDef                 *Instance;    
  HAL_LockTypeDef             Lock;         
  __IO HAL_RNG_StateTypeDef   State;        
  __IO  uint32_t              ErrorCode;    
  uint32_t                    RandomNumber; 
#if (USE_HAL_RNG_REGISTER_CALLBACKS == 1)
  void (* ReadyDataCallback)(struct __RNG_HandleTypeDef *hrng, uint32_t random32bit);  
  void (* ErrorCallback)(struct __RNG_HandleTypeDef *hrng);                            
  void (* MspInitCallback)(struct __RNG_HandleTypeDef *hrng);                          
  void (* MspDeInitCallback)(struct __RNG_HandleTypeDef *hrng);                        
#endif  /* USE_HAL_RNG_REGISTER_CALLBACKS */
 
} RNG_HandleTypeDef;
 
#if (USE_HAL_RNG_REGISTER_CALLBACKS == 1)
typedef enum
{
  HAL_RNG_ERROR_CB_ID                   = 0x00U,     
  HAL_RNG_MSPINIT_CB_ID                 = 0x01U,     
  HAL_RNG_MSPDEINIT_CB_ID               = 0x02U      
} HAL_RNG_CallbackIDTypeDef;
 
typedef  void (*pRNG_CallbackTypeDef)(RNG_HandleTypeDef *hrng);                                  
typedef  void (*pRNG_ReadyDataCallbackTypeDef)(RNG_HandleTypeDef *hrng, uint32_t random32bit);   
#endif /* USE_HAL_RNG_REGISTER_CALLBACKS */
 
/* Exported constants --------------------------------------------------------*/
#define RNG_IT_DRDY  RNG_SR_DRDY  
#define RNG_IT_CEI   RNG_SR_CEIS  
#define RNG_IT_SEI   RNG_SR_SEIS  
#define RNG_FLAG_DRDY   RNG_SR_DRDY  
#define RNG_FLAG_CECS   RNG_SR_CECS  
#define RNG_FLAG_SECS   RNG_SR_SECS  
#define  HAL_RNG_ERROR_NONE             0x00000000U    
#if (USE_HAL_RNG_REGISTER_CALLBACKS == 1)
#define  HAL_RNG_ERROR_INVALID_CALLBACK 0x00000001U    
#endif /* USE_HAL_RNG_REGISTER_CALLBACKS */
#define  HAL_RNG_ERROR_TIMEOUT          0x00000002U    
#define  HAL_RNG_ERROR_BUSY             0x00000004U    
#define  HAL_RNG_ERROR_SEED             0x00000008U    
#define  HAL_RNG_ERROR_CLOCK            0x00000010U    
/* Exported macros -----------------------------------------------------------*/
#if (USE_HAL_RNG_REGISTER_CALLBACKS == 1)
#define __HAL_RNG_RESET_HANDLE_STATE(__HANDLE__)  do{                                                   \
                                                       (__HANDLE__)->State = HAL_RNG_STATE_RESET;       \
                                                       (__HANDLE__)->MspInitCallback = NULL;            \
                                                       (__HANDLE__)->MspDeInitCallback = NULL;          \
                                                    } while(0U)
#else
#define __HAL_RNG_RESET_HANDLE_STATE(__HANDLE__) ((__HANDLE__)->State = HAL_RNG_STATE_RESET)
#endif /* USE_HAL_RNG_REGISTER_CALLBACKS */
 
#define __HAL_RNG_ENABLE(__HANDLE__) ((__HANDLE__)->Instance->CR |=  RNG_CR_RNGEN)
 
#define __HAL_RNG_DISABLE(__HANDLE__) ((__HANDLE__)->Instance->CR &= ~RNG_CR_RNGEN)
 
#define __HAL_RNG_GET_FLAG(__HANDLE__, __FLAG__) (((__HANDLE__)->Instance->SR & (__FLAG__)) == (__FLAG__))
 
#define __HAL_RNG_CLEAR_FLAG(__HANDLE__, __FLAG__)                      /* dummy  macro */
 
#define __HAL_RNG_ENABLE_IT(__HANDLE__) ((__HANDLE__)->Instance->CR |=  RNG_CR_IE)
 
#define __HAL_RNG_DISABLE_IT(__HANDLE__) ((__HANDLE__)->Instance->CR &= ~RNG_CR_IE)
 
#define __HAL_RNG_GET_IT(__HANDLE__, __INTERRUPT__) (((__HANDLE__)->Instance->SR & (__INTERRUPT__)) == (__INTERRUPT__))
 
#define __HAL_RNG_CLEAR_IT(__HANDLE__, __INTERRUPT__) (((__HANDLE__)->Instance->SR) = ~(__INTERRUPT__))
 
/* Exported functions --------------------------------------------------------*/
HAL_StatusTypeDef HAL_RNG_Init(RNG_HandleTypeDef *hrng);
HAL_StatusTypeDef HAL_RNG_DeInit(RNG_HandleTypeDef *hrng);
void HAL_RNG_MspInit(RNG_HandleTypeDef *hrng);
void HAL_RNG_MspDeInit(RNG_HandleTypeDef *hrng);
 
/* Callbacks Register/UnRegister functions  ***********************************/
#if (USE_HAL_RNG_REGISTER_CALLBACKS == 1)
HAL_StatusTypeDef HAL_RNG_RegisterCallback(RNG_HandleTypeDef *hrng, HAL_RNG_CallbackIDTypeDef CallbackID,
                                           pRNG_CallbackTypeDef pCallback);
HAL_StatusTypeDef HAL_RNG_UnRegisterCallback(RNG_HandleTypeDef *hrng, HAL_RNG_CallbackIDTypeDef CallbackID);
 
HAL_StatusTypeDef HAL_RNG_RegisterReadyDataCallback(RNG_HandleTypeDef *hrng, pRNG_ReadyDataCallbackTypeDef pCallback);
HAL_StatusTypeDef HAL_RNG_UnRegisterReadyDataCallback(RNG_HandleTypeDef *hrng);
#endif /* USE_HAL_RNG_REGISTER_CALLBACKS */
 
uint32_t HAL_RNG_GetRandomNumber(RNG_HandleTypeDef
                                 *hrng);    /* Obsolete, use HAL_RNG_GenerateRandomNumber() instead    */
uint32_t HAL_RNG_GetRandomNumber_IT(RNG_HandleTypeDef
                                    *hrng); /* Obsolete, use HAL_RNG_GenerateRandomNumber_IT() instead */
HAL_StatusTypeDef HAL_RNG_GenerateRandomNumber(RNG_HandleTypeDef *hrng, uint32_t *random32bit);
HAL_StatusTypeDef HAL_RNG_GenerateRandomNumber_IT(RNG_HandleTypeDef *hrng);
uint32_t HAL_RNG_ReadLastRandomNumber(const RNG_HandleTypeDef *hrng);
 
void HAL_RNG_IRQHandler(RNG_HandleTypeDef *hrng);
void HAL_RNG_ErrorCallback(RNG_HandleTypeDef *hrng);
void HAL_RNG_ReadyDataCallback(RNG_HandleTypeDef *hrng, uint32_t random32bit);
 
HAL_RNG_StateTypeDef HAL_RNG_GetState(const RNG_HandleTypeDef *hrng);
uint32_t             HAL_RNG_GetError(const RNG_HandleTypeDef *hrng);
/* Private macros ------------------------------------------------------------*/
#define IS_RNG_IT(IT) (((IT) == RNG_IT_CEI) || \
                       ((IT) == RNG_IT_SEI))
 
#define IS_RNG_FLAG(FLAG) (((FLAG) == RNG_FLAG_DRDY) || \
                           ((FLAG) == RNG_FLAG_CECS) || \
                           ((FLAG) == RNG_FLAG_SECS))
 
#endif /* RNG */
 
#ifdef __cplusplus
}
#endif
 
 
#endif /* STM32F4xx_HAL_RNG_H */