stm32l4xx_hal_rng.h

Go to the documentation of this file.

/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __STM32L4xx_HAL_RNG_H
#define __STM32L4xx_HAL_RNG_H

#ifdef __cplusplus
 extern "C" {
#endif

/* Includes ------------------------------------------------------------------*/
#include "stm32l4xx_hal_def.h"

/* Exported types ------------------------------------------------------------*/ 
#if defined(RNG_CR_CED)

typedef struct
{
  uint32_t                    ClockErrorDetection; 
}RNG_InitTypeDef;
#endif /* defined(RNG_CR_CED) */

typedef enum
{
  HAL_RNG_STATE_RESET     = 0x00,  
  HAL_RNG_STATE_READY     = 0x01,  
  HAL_RNG_STATE_BUSY      = 0x02,  
  HAL_RNG_STATE_TIMEOUT   = 0x03,  
  HAL_RNG_STATE_ERROR     = 0x04   
}HAL_RNG_StateTypeDef;

typedef struct __RNG_HandleTypeDef
{
  RNG_TypeDef                 *Instance;     
#if defined(RNG_CR_CED)
  RNG_InitTypeDef             Init;          
#endif /* defined(RNG_CR_CED) */

  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  
#if defined(RNG_CR_CED)

#define RNG_CED_ENABLE         ((uint32_t)0x00000000) 
#define RNG_CED_DISABLE        RNG_CR_CED             
#endif /* defined(RNG_CR_CED) */

#define  HAL_RNG_ERROR_NONE             ((uint32_t)0x00000000U)    
#if (USE_HAL_RNG_REGISTER_CALLBACKS == 1)
#define  HAL_RNG_ERROR_INVALID_CALLBACK ((uint32_t)0x00000001U)    
#endif /* USE_HAL_RNG_REGISTER_CALLBACKS */

/* 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 --------------------------------------------------------*/
/* Initialization and de-initialization 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 */

/* Peripheral Control functions  ************************************************/
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(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);
/* Peripheral State functions  **************************************************/
HAL_RNG_StateTypeDef HAL_RNG_GetState(RNG_HandleTypeDef *hrng);
uint32_t             HAL_RNG_GetError(RNG_HandleTypeDef *hrng);
/* Private types -------------------------------------------------------------*/
/* Private defines -----------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* Private constants ---------------------------------------------------------*/
/* Private macros ------------------------------------------------------------*/
#if defined(RNG_CR_CED)

#define IS_RNG_CED(__MODE__) (((__MODE__) == RNG_CED_ENABLE) || \
                              ((__MODE__) == RNG_CED_DISABLE))
#endif /* defined(RNG_CR_CED) */

/* Private functions prototypes ----------------------------------------------*/

#ifdef __cplusplus
}
#endif

#endif /* __STM32L4xx_HAL_RNG_H */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/