lib/main/STM32H7/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_rng.c

   1 /**
   2   ******************************************************************************
   3   * @file    stm32h7xx_hal_rng.c
   4   * @author  MCD Application Team
   5   * @brief   RNG HAL module driver.
   6   *          This file provides firmware functions to manage the following
   7   *          functionalities of the Random Number Generator (RNG) peripheral:
   8   *           + Initialization and configuration functions
   9   *           + Peripheral Control functions
  10   *           + Peripheral State functions
  11   *
  12   @verbatim
  13   ==============================================================================
  14                      ##### How to use this driver #####
  15   ==============================================================================
  16   [..]
  17       The RNG HAL driver can be used as follows:
  18
  19       (#) Enable the RNG controller clock using __HAL_RCC_RNG_CLK_ENABLE() macro
  20           in HAL_RNG_MspInit().
  21       (#) Activate the RNG peripheral using HAL_RNG_Init() function.
  22       (#) Wait until the 32 bit Random Number Generator contains a valid
  23           random data using (polling/interrupt) mode.
  24       (#) Get the 32 bit random number using HAL_RNG_GenerateRandomNumber() function.
  25
  26     ##### Callback registration #####
  27     ==================================
  28
  29     [..]
  30     The compilation define USE_HAL_RNG_REGISTER_CALLBACKS when set to 1
  31     allows the user to configure dynamically the driver callbacks.
  32
  33     [..]
  34     Use Function @ref HAL_RNG_RegisterCallback() to register a user callback.
  35     Function @ref HAL_RNG_RegisterCallback() allows to register following callbacks:
  36     (+) ErrorCallback             : RNG Error Callback.
  37     (+) MspInitCallback           : RNG MspInit.
  38     (+) MspDeInitCallback         : RNG MspDeInit.
  39     This function takes as parameters the HAL peripheral handle, the Callback ID
  40     and a pointer to the user callback function.
  41
  42     [..]
  43     Use function @ref HAL_RNG_UnRegisterCallback() to reset a callback to the default
  44     weak (surcharged) function.
  45     @ref HAL_RNG_UnRegisterCallback() takes as parameters the HAL peripheral handle,
  46     and the Callback ID.
  47     This function allows to reset following callbacks:
  48     (+) ErrorCallback             : RNG Error Callback.
  49     (+) MspInitCallback           : RNG MspInit.
  50     (+) MspDeInitCallback         : RNG MspDeInit.
  51
  52     [..]
  53     For specific callback ReadyDataCallback, use dedicated register callbacks:
  54     respectively @ref HAL_RNG_RegisterReadyDataCallback() , @ref HAL_RNG_UnRegisterReadyDataCallback().
  55
  56     [..]
  57     By default, after the @ref HAL_RNG_Init() and when the state is HAL_RNG_STATE_RESET
  58     all callbacks are set to the corresponding weak (surcharged) functions:
  59     example @ref HAL_RNG_ErrorCallback().
  60     Exception done for MspInit and MspDeInit functions that are respectively
  61     reset to the legacy weak (surcharged) functions in the @ref HAL_RNG_Init()
  62     and @ref HAL_RNG_DeInit() only when these callbacks are null (not registered beforehand).
  63     If not, MspInit or MspDeInit are not null, the @ref HAL_RNG_Init() and @ref HAL_RNG_DeInit()
  64     keep and use the user MspInit/MspDeInit callbacks (registered beforehand).
  65
  66     [..]
  67     Callbacks can be registered/unregistered in HAL_RNG_STATE_READY state only.
  68     Exception done MspInit/MspDeInit that can be registered/unregistered
  69     in HAL_RNG_STATE_READY or HAL_RNG_STATE_RESET state, thus registered (user)
  70     MspInit/DeInit callbacks can be used during the Init/DeInit.
  71     In that case first register the MspInit/MspDeInit user callbacks
  72     using @ref HAL_RNG_RegisterCallback() before calling @ref HAL_RNG_DeInit()
  73     or @ref HAL_RNG_Init() function.
  74
  75     [..]
  76     When The compilation define USE_HAL_RNG_REGISTER_CALLBACKS is set to 0 or
  77     not defined, the callback registration feature is not available
  78     and weak (surcharged) callbacks are used.
  79
  80   @endverbatim
  81   ******************************************************************************
  82   * @attention
  83   *
  84   * <h2><center>&copy; Copyright (c) 2017 STMicroelectronics.
  85   * All rights reserved.</center></h2>
  86   *
  87   * This software component is licensed by ST under BSD 3-Clause license,
  88   * the "License"; You may not use this file except in compliance with the
  89   * License. You may obtain a copy of the License at:
  90   *                        opensource.org/licenses/BSD-3-Clause
  91   *
  92   ******************************************************************************
  93   */
  94
  95 /* Includes ------------------------------------------------------------------*/
  96 #include "stm32h7xx_hal.h"
  97
  98 /** @addtogroup STM32H7xx_HAL_Driver
  99   * @{
 100   */
 101
 102 #if defined (RNG)
 103
 104 /** @addtogroup RNG
 105   * @brief RNG HAL module driver.
 106   * @{
 107   */
 108
 109 #ifdef HAL_RNG_MODULE_ENABLED
 110
 111 /* Private types -------------------------------------------------------------*/
 112 /* Private defines -----------------------------------------------------------*/
 113 /** @defgroup RNG_Private_Defines RNG Private Defines
 114   * @{
 115   */
 116 /*  Health test control register information to use in CCM algorithm */
 117 #define RNG_HTCFG_1   0x17590ABCU /*!< magic number */
 118 #if defined(RNG_VER_3_1) || defined(RNG_VER_3_0)
 119 #define RNG_HTCFG     0x000CAA74U /*!< for best latency and To be compliant with NIST */
 120 #else /*RNG_VER_3_2*/
 121 #define RNG_HTCFG     0x00007274U /*!< for best latency and To be compliant with NIST */
 122 #endif
 123 /**
 124   * @}
 125   */
 126 /* Private variables ---------------------------------------------------------*/
 127 /* Private constants ---------------------------------------------------------*/
 128 /** @defgroup RNG_Private_Constants RNG Private Constants
 129   * @{
 130   */
 131 #define RNG_TIMEOUT_VALUE     2U
 132 /**
 133   * @}
 134   */
 135 /* Private macros ------------------------------------------------------------*/
 136 /* Private functions prototypes ----------------------------------------------*/
 137 /* Private functions ---------------------------------------------------------*/
 138 /* Exported functions --------------------------------------------------------*/
 139
 140 /** @addtogroup RNG_Exported_Functions
 141   * @{
 142   */
 143
 144 /** @addtogroup RNG_Exported_Functions_Group1
 145  *  @brief   Initialization and configuration functions
 146  *
 147 @verbatim
 148  ===============================================================================
 149           ##### Initialization and configuration functions #####
 150  ===============================================================================
 151     [..]  This section provides functions allowing to:
 152       (+) Initialize the RNG according to the specified parameters
 153           in the RNG_InitTypeDef and create the associated handle
 154       (+) DeInitialize the RNG peripheral
 155       (+) Initialize the RNG MSP
 156       (+) DeInitialize RNG MSP
 157
 158 @endverbatim
 159   * @{
 160   */
 161
 162 /**
 163   * @brief  Initializes the RNG peripheral and creates the associated handle.
 164   * @param  hrng pointer to a RNG_HandleTypeDef structure that contains
 165   *                the configuration information for RNG.
 166   * @retval HAL status
 167   */
 168 HAL_StatusTypeDef HAL_RNG_Init(RNG_HandleTypeDef *hrng)
 169 {
 170   uint32_t tickstart;
 171   /* Check the RNG handle allocation */
 172   if (hrng == NULL)
 173   {
 174     return HAL_ERROR;
 175   }
 176   /* Check the parameters */
 177   assert_param(IS_RNG_ALL_INSTANCE(hrng->Instance));
 178   assert_param(IS_RNG_CED(hrng->Init.ClockErrorDetection));
 179
 180 #if (USE_HAL_RNG_REGISTER_CALLBACKS == 1)
 181   if (hrng->State == HAL_RNG_STATE_RESET)
 182   {
 183     /* Allocate lock resource and initialize it */
 184     hrng->Lock = HAL_UNLOCKED;
 185
 186     hrng->ReadyDataCallback  = HAL_RNG_ReadyDataCallback;  /* Legacy weak ReadyDataCallback  */
 187     hrng->ErrorCallback      = HAL_RNG_ErrorCallback;      /* Legacy weak ErrorCallback      */
 188
 189     if (hrng->MspInitCallback == NULL)
 190     {
 191       hrng->MspInitCallback = HAL_RNG_MspInit; /* Legacy weak MspInit  */
 192     }
 193
 194     /* Init the low level hardware */
 195     hrng->MspInitCallback(hrng);
 196   }
 197 #else
 198   if (hrng->State == HAL_RNG_STATE_RESET)
 199   {
 200     /* Allocate lock resource and initialize it */
 201     hrng->Lock = HAL_UNLOCKED;
 202
 203     /* Init the low level hardware */
 204     HAL_RNG_MspInit(hrng);
 205   }
 206 #endif /* USE_HAL_RNG_REGISTER_CALLBACKS */
 207
 208   /* Change RNG peripheral state */
 209   hrng->State = HAL_RNG_STATE_BUSY;
 210
 211 #if defined(RNG_CR_CONDRST)
 212   /* Disable RNG */
 213   __HAL_RNG_DISABLE(hrng);
 214
 215   /* Clock Error Detection Configuration when CONDRT bit is set to 1 */
 216   MODIFY_REG(hrng->Instance->CR, RNG_CR_CED | RNG_CR_CONDRST, hrng->Init.ClockErrorDetection | RNG_CR_CONDRST);
 217
 218 #if defined(RNG_VER_3_2) || defined(RNG_VER_3_1) || defined(RNG_VER_3_0)
 219   /*!< magic number must be written immediately before to RNG_HTCRG */
 220   WRITE_REG(hrng->Instance->HTCR, RNG_HTCFG_1);
 221   /* for best latency and to be compliant with NIST */
 222   WRITE_REG(hrng->Instance->HTCR, RNG_HTCFG);
 223 #endif
 224
 225   /* Writing bits CONDRST=0*/
 226   CLEAR_BIT(hrng->Instance->CR, RNG_CR_CONDRST);
 227
 228   /* Get tick */
 229   tickstart = HAL_GetTick();
 230
 231   /* Wait for conditioning reset process to be completed */
 232   while (HAL_IS_BIT_SET(hrng->Instance->CR, RNG_CR_CONDRST))
 233   {
 234     if ((HAL_GetTick() - tickstart) > RNG_TIMEOUT_VALUE)
 235     {
 236       hrng->State = HAL_RNG_STATE_READY;
 237       hrng->ErrorCode = HAL_RNG_ERROR_TIMEOUT;
 238       return HAL_ERROR;
 239     }
 240   }
 241 #else
 242   /* Clock Error Detection Configuration */
 243   MODIFY_REG(hrng->Instance->CR, RNG_CR_CED, hrng->Init.ClockErrorDetection);
 244 #endif /* end of RNG_CR_CONDRST */
 245
 246   /* Enable the RNG Peripheral */
 247   __HAL_RNG_ENABLE(hrng);
 248
 249   /* verify that no seed error */
 250   if (__HAL_RNG_GET_IT(hrng, RNG_IT_SEI) != RESET)
 251   {
 252     hrng->State = HAL_RNG_STATE_ERROR;
 253     return HAL_ERROR;
 254   }
 255   /* Get tick */
 256   tickstart = HAL_GetTick();
 257   /* Check if data register contains valid random data */
 258   while (__HAL_RNG_GET_FLAG(hrng, RNG_FLAG_SECS) != RESET)
 259   {
 260     if ((HAL_GetTick() - tickstart) > RNG_TIMEOUT_VALUE)
 261     {
 262       hrng->State = HAL_RNG_STATE_ERROR;
 263       hrng->ErrorCode = HAL_RNG_ERROR_TIMEOUT;
 264       return HAL_ERROR;
 265     }
 266   }
 267
 268   /* Initialize the RNG state */
 269   hrng->State = HAL_RNG_STATE_READY;
 270
 271   /* Initialise the error code */
 272   hrng->ErrorCode = HAL_RNG_ERROR_NONE;
 273
 274   /* Return function status */
 275   return HAL_OK;
 276 }
 277
 278 /**
 279   * @brief  DeInitializes the RNG peripheral.
 280   * @param  hrng pointer to a RNG_HandleTypeDef structure that contains
 281   *                the configuration information for RNG.
 282   * @retval HAL status
 283   */
 284 HAL_StatusTypeDef HAL_RNG_DeInit(RNG_HandleTypeDef *hrng)
 285 {
 286 #if defined(RNG_CR_CONDRST)
 287   uint32_t tickstart;
 288
 289 #endif /* RNG_CR_CONDRST */
 290   /* Check the RNG handle allocation */
 291   if (hrng == NULL)
 292   {
 293     return HAL_ERROR;
 294   }
 295
 296 #if defined(RNG_CR_CONDRST)
 297   /* Clear Clock Error Detection bit when CONDRT bit is set to 1 */
 298   MODIFY_REG(hrng->Instance->CR, RNG_CR_CED | RNG_CR_CONDRST, RNG_CED_ENABLE | RNG_CR_CONDRST);
 299
 300   /* Writing bits CONDRST=0*/
 301   CLEAR_BIT(hrng->Instance->CR, RNG_CR_CONDRST);
 302
 303   /* Get tick */
 304   tickstart = HAL_GetTick();
 305
 306   /* Wait for conditioning reset process to be completed */
 307   while (HAL_IS_BIT_SET(hrng->Instance->CR, RNG_CR_CONDRST))
 308   {
 309     if ((HAL_GetTick() - tickstart) > RNG_TIMEOUT_VALUE)
 310     {
 311       hrng->State = HAL_RNG_STATE_READY;
 312       hrng->ErrorCode = HAL_RNG_ERROR_TIMEOUT;
 313       /* Process Unlocked */
 314       __HAL_UNLOCK(hrng);
 315       return HAL_ERROR;
 316     }
 317   }
 318
 319 #else
 320   /* Clear Clock Error Detection bit */
 321   CLEAR_BIT(hrng->Instance->CR, RNG_CR_CED);
 322 #endif /* RNG_CR_CONDRST */
 323   /* Disable the RNG Peripheral */
 324   CLEAR_BIT(hrng->Instance->CR, RNG_CR_IE | RNG_CR_RNGEN);
 325
 326   /* Clear RNG interrupt status flags */
 327   CLEAR_BIT(hrng->Instance->SR, RNG_SR_CEIS | RNG_SR_SEIS);
 328
 329 #if (USE_HAL_RNG_REGISTER_CALLBACKS == 1)
 330   if (hrng->MspDeInitCallback == NULL)
 331   {
 332     hrng->MspDeInitCallback = HAL_RNG_MspDeInit; /* Legacy weak MspDeInit  */
 333   }
 334
 335   /* DeInit the low level hardware */
 336   hrng->MspDeInitCallback(hrng);
 337 #else
 338   /* DeInit the low level hardware */
 339   HAL_RNG_MspDeInit(hrng);
 340 #endif /* USE_HAL_RNG_REGISTER_CALLBACKS */
 341
 342   /* Update the RNG state */
 343   hrng->State = HAL_RNG_STATE_RESET;
 344
 345   /* Initialise the error code */
 346   hrng->ErrorCode = HAL_RNG_ERROR_NONE;
 347
 348   /* Release Lock */
 349   __HAL_UNLOCK(hrng);
 350
 351   /* Return the function status */
 352   return HAL_OK;
 353 }
 354
 355 /**
 356   * @brief  Initializes the RNG MSP.
 357   * @param  hrng pointer to a RNG_HandleTypeDef structure that contains
 358   *                the configuration information for RNG.
 359   * @retval None
 360   */
 361 __weak void HAL_RNG_MspInit(RNG_HandleTypeDef *hrng)
 362 {
 363   /* Prevent unused argument(s) compilation warning */
 364   UNUSED(hrng);
 365   /* NOTE : This function should not be modified. When the callback is needed,
 366             function HAL_RNG_MspInit must be implemented in the user file.
 367    */
 368 }
 369
 370 /**
 371   * @brief  DeInitializes the RNG MSP.
 372   * @param  hrng pointer to a RNG_HandleTypeDef structure that contains
 373   *                the configuration information for RNG.
 374   * @retval None
 375   */
 376 __weak void HAL_RNG_MspDeInit(RNG_HandleTypeDef *hrng)
 377 {
 378   /* Prevent unused argument(s) compilation warning */
 379   UNUSED(hrng);
 380   /* NOTE : This function should not be modified. When the callback is needed,
 381             function HAL_RNG_MspDeInit must be implemented in the user file.
 382    */
 383 }
 384
 385 #if (USE_HAL_RNG_REGISTER_CALLBACKS == 1)
 386 /**
 387   * @brief  Register a User RNG Callback
 388   *         To be used instead of the weak predefined callback
 389   * @param  hrng RNG handle
 390   * @param  CallbackID ID of the callback to be registered
 391   *         This parameter can be one of the following values:
 392   *          @arg @ref HAL_RNG_ERROR_CB_ID Error callback ID
 393   *          @arg @ref HAL_RNG_MSPINIT_CB_ID MspInit callback ID
 394   *          @arg @ref HAL_RNG_MSPDEINIT_CB_ID MspDeInit callback ID
 395   * @param  pCallback pointer to the Callback function
 396   * @retval HAL status
 397   */
 398 HAL_StatusTypeDef HAL_RNG_RegisterCallback(RNG_HandleTypeDef *hrng, HAL_RNG_CallbackIDTypeDef CallbackID, pRNG_CallbackTypeDef pCallback)
 399 {
 400   HAL_StatusTypeDef status = HAL_OK;
 401
 402   if (pCallback == NULL)
 403   {
 404     /* Update the error code */
 405     hrng->ErrorCode = HAL_RNG_ERROR_INVALID_CALLBACK;
 406     return HAL_ERROR;
 407   }
 408   /* Process locked */
 409   __HAL_LOCK(hrng);
 410
 411   if (HAL_RNG_STATE_READY == hrng->State)
 412   {
 413     switch (CallbackID)
 414     {
 415       case HAL_RNG_ERROR_CB_ID :
 416         hrng->ErrorCallback = pCallback;
 417         break;
 418
 419       case HAL_RNG_MSPINIT_CB_ID :
 420         hrng->MspInitCallback = pCallback;
 421         break;
 422
 423       case HAL_RNG_MSPDEINIT_CB_ID :
 424         hrng->MspDeInitCallback = pCallback;
 425         break;
 426
 427       default :
 428         /* Update the error code */
 429         hrng->ErrorCode = HAL_RNG_ERROR_INVALID_CALLBACK;
 430         /* Return error status */
 431         status =  HAL_ERROR;
 432         break;
 433     }
 434   }
 435   else if (HAL_RNG_STATE_RESET == hrng->State)
 436   {
 437     switch (CallbackID)
 438     {
 439       case HAL_RNG_MSPINIT_CB_ID :
 440         hrng->MspInitCallback = pCallback;
 441         break;
 442
 443       case HAL_RNG_MSPDEINIT_CB_ID :
 444         hrng->MspDeInitCallback = pCallback;
 445         break;
 446
 447       default :
 448         /* Update the error code */
 449         hrng->ErrorCode = HAL_RNG_ERROR_INVALID_CALLBACK;
 450         /* Return error status */
 451         status =  HAL_ERROR;
 452         break;
 453     }
 454   }
 455   else
 456   {
 457     /* Update the error code */
 458     hrng->ErrorCode = HAL_RNG_ERROR_INVALID_CALLBACK;
 459     /* Return error status */
 460     status =  HAL_ERROR;
 461   }
 462
 463   /* Release Lock */
 464   __HAL_UNLOCK(hrng);
 465   return status;
 466 }
 467
 468 /**
 469   * @brief  Unregister an RNG Callback
 470   *         RNG callabck is redirected to the weak predefined callback
 471   * @param  hrng RNG handle
 472   * @param  CallbackID ID of the callback to be unregistered
 473   *         This parameter can be one of the following values:
 474   *          @arg @ref HAL_RNG_ERROR_CB_ID Error callback ID
 475   *          @arg @ref HAL_RNG_MSPINIT_CB_ID MspInit callback ID
 476   *          @arg @ref HAL_RNG_MSPDEINIT_CB_ID MspDeInit callback ID
 477   * @retval HAL status
 478   */
 479 HAL_StatusTypeDef HAL_RNG_UnRegisterCallback(RNG_HandleTypeDef *hrng, HAL_RNG_CallbackIDTypeDef CallbackID)
 480 {
 481   HAL_StatusTypeDef status = HAL_OK;
 482
 483   /* Process locked */
 484   __HAL_LOCK(hrng);
 485
 486   if (HAL_RNG_STATE_READY == hrng->State)
 487   {
 488     switch (CallbackID)
 489     {
 490       case HAL_RNG_ERROR_CB_ID :
 491         hrng->ErrorCallback = HAL_RNG_ErrorCallback;          /* Legacy weak ErrorCallback  */
 492         break;
 493
 494       case HAL_RNG_MSPINIT_CB_ID :
 495         hrng->MspInitCallback = HAL_RNG_MspInit;              /* Legacy weak MspInit  */
 496         break;
 497
 498       case HAL_RNG_MSPDEINIT_CB_ID :
 499         hrng->MspDeInitCallback = HAL_RNG_MspDeInit;          /* Legacy weak MspDeInit  */
 500         break;
 501
 502       default :
 503         /* Update the error code */
 504         hrng->ErrorCode = HAL_RNG_ERROR_INVALID_CALLBACK;
 505         /* Return error status */
 506         status =  HAL_ERROR;
 507         break;
 508     }
 509   }
 510   else if (HAL_RNG_STATE_RESET == hrng->State)
 511   {
 512     switch (CallbackID)
 513     {
 514       case HAL_RNG_MSPINIT_CB_ID :
 515         hrng->MspInitCallback = HAL_RNG_MspInit;              /* Legacy weak MspInit  */
 516         break;
 517
 518       case HAL_RNG_MSPDEINIT_CB_ID :
 519         hrng->MspDeInitCallback = HAL_RNG_MspDeInit;          /* Legacy weak MspInit  */
 520         break;
 521
 522       default :
 523         /* Update the error code */
 524         hrng->ErrorCode = HAL_RNG_ERROR_INVALID_CALLBACK;
 525         /* Return error status */
 526         status =  HAL_ERROR;
 527         break;
 528     }
 529   }
 530   else
 531   {
 532     /* Update the error code */
 533     hrng->ErrorCode = HAL_RNG_ERROR_INVALID_CALLBACK;
 534     /* Return error status */
 535     status =  HAL_ERROR;
 536   }
 537
 538   /* Release Lock */
 539   __HAL_UNLOCK(hrng);
 540   return status;
 541 }
 542
 543 /**
 544   * @brief  Register Data Ready RNG Callback
 545   *         To be used instead of the weak HAL_RNG_ReadyDataCallback() predefined callback
 546   * @param  hrng RNG handle
 547   * @param  pCallback pointer to the Data Ready Callback function
 548   * @retval HAL status
 549   */
 550 HAL_StatusTypeDef HAL_RNG_RegisterReadyDataCallback(RNG_HandleTypeDef *hrng, pRNG_ReadyDataCallbackTypeDef pCallback)
 551 {
 552   HAL_StatusTypeDef status = HAL_OK;
 553
 554   if (pCallback == NULL)
 555   {
 556     /* Update the error code */
 557     hrng->ErrorCode = HAL_RNG_ERROR_INVALID_CALLBACK;
 558     return HAL_ERROR;
 559   }
 560   /* Process locked */
 561   __HAL_LOCK(hrng);
 562
 563   if (HAL_RNG_STATE_READY == hrng->State)
 564   {
 565     hrng->ReadyDataCallback = pCallback;
 566   }
 567   else
 568   {
 569     /* Update the error code */
 570     hrng->ErrorCode = HAL_RNG_ERROR_INVALID_CALLBACK;
 571     /* Return error status */
 572     status =  HAL_ERROR;
 573   }
 574
 575   /* Release Lock */
 576   __HAL_UNLOCK(hrng);
 577   return status;
 578 }
 579
 580 /**
 581   * @brief  UnRegister the Data Ready RNG Callback
 582   *         Data Ready RNG Callback is redirected to the weak HAL_RNG_ReadyDataCallback() predefined callback
 583   * @param  hrng RNG handle
 584   * @retval HAL status
 585   */
 586 HAL_StatusTypeDef HAL_RNG_UnRegisterReadyDataCallback(RNG_HandleTypeDef *hrng)
 587 {
 588   HAL_StatusTypeDef status = HAL_OK;
 589
 590   /* Process locked */
 591   __HAL_LOCK(hrng);
 592
 593   if (HAL_RNG_STATE_READY == hrng->State)
 594   {
 595     hrng->ReadyDataCallback = HAL_RNG_ReadyDataCallback; /* Legacy weak ReadyDataCallback  */
 596   }
 597   else
 598   {
 599     /* Update the error code */
 600     hrng->ErrorCode = HAL_RNG_ERROR_INVALID_CALLBACK;
 601     /* Return error status */
 602     status =  HAL_ERROR;
 603   }
 604
 605   /* Release Lock */
 606   __HAL_UNLOCK(hrng);
 607   return status;
 608 }
 609
 610 #endif /* USE_HAL_RNG_REGISTER_CALLBACKS */
 611
 612 /**
 613   * @}
 614   */
 615
 616 /** @addtogroup RNG_Exported_Functions_Group2
 617  *  @brief   Peripheral Control functions
 618  *
 619 @verbatim
 620  ===============================================================================
 621                       ##### Peripheral Control functions #####
 622  ===============================================================================
 623     [..]  This section provides functions allowing to:
 624       (+) Get the 32 bit Random number
 625       (+) Get the 32 bit Random number with interrupt enabled
 626       (+) Handle RNG interrupt request
 627
 628 @endverbatim
 629   * @{
 630   */
 631
 632 /**
 633   * @brief  Generates a 32-bit random number.
 634   * @note   This function checks value of RNG_FLAG_DRDY flag to know if valid
 635   *         random number is available in the DR register (RNG_FLAG_DRDY flag set
 636   *         whenever a random number is available through the RNG_DR register).
 637   *         After transitioning from 0 to 1 (random number available),
 638   *         RNG_FLAG_DRDY flag remains high until output buffer becomes empty after reading
 639   *         four words from the RNG_DR register, i.e. further function calls
 640   *         will immediately return a new u32 random number (additional words are
 641   *         available and can be read by the application, till RNG_FLAG_DRDY flag remains high).
 642   * @note   When no more random number data is available in DR register, RNG_FLAG_DRDY
 643   *         flag is automatically cleared.
 644   * @param  hrng pointer to a RNG_HandleTypeDef structure that contains
 645   *                the configuration information for RNG.
 646   * @param  random32bit pointer to generated random number variable if successful.
 647   * @retval HAL status
 648   */
 649
 650 HAL_StatusTypeDef HAL_RNG_GenerateRandomNumber(RNG_HandleTypeDef *hrng, uint32_t *random32bit)
 651 {
 652   uint32_t tickstart;
 653   HAL_StatusTypeDef status = HAL_OK;
 654
 655   /* Process Locked */
 656   __HAL_LOCK(hrng);
 657
 658   /* Check RNG peripheral state */
 659   if (hrng->State == HAL_RNG_STATE_READY)
 660   {
 661     /* Change RNG peripheral state */
 662     hrng->State = HAL_RNG_STATE_BUSY;
 663
 664     /* Get tick */
 665     tickstart = HAL_GetTick();
 666
 667     /* Check if data register contains valid random data */
 668     while (__HAL_RNG_GET_FLAG(hrng, RNG_FLAG_DRDY) == RESET)
 669     {
 670       if ((HAL_GetTick() - tickstart) > RNG_TIMEOUT_VALUE)
 671       {
 672         hrng->State = HAL_RNG_STATE_READY;
 673         hrng->ErrorCode = HAL_RNG_ERROR_TIMEOUT;
 674         /* Process Unlocked */
 675         __HAL_UNLOCK(hrng);
 676         return HAL_ERROR;
 677       }
 678     }
 679
 680     /* Get a 32bit Random number */
 681     hrng->RandomNumber = hrng->Instance->DR;
 682     *random32bit = hrng->RandomNumber;
 683
 684     hrng->State = HAL_RNG_STATE_READY;
 685   }
 686   else
 687   {
 688     hrng->ErrorCode = HAL_RNG_ERROR_BUSY;
 689     status = HAL_ERROR;
 690   }
 691
 692   /* Process Unlocked */
 693   __HAL_UNLOCK(hrng);
 694
 695   return status;
 696 }
 697
 698 /**
 699   * @brief  Generates a 32-bit random number in interrupt mode.
 700   * @param  hrng pointer to a RNG_HandleTypeDef structure that contains
 701   *                the configuration information for RNG.
 702   * @retval HAL status
 703   */
 704 HAL_StatusTypeDef HAL_RNG_GenerateRandomNumber_IT(RNG_HandleTypeDef *hrng)
 705 {
 706   HAL_StatusTypeDef status = HAL_OK;
 707
 708   /* Process Locked */
 709   __HAL_LOCK(hrng);
 710
 711   /* Check RNG peripheral state */
 712   if (hrng->State == HAL_RNG_STATE_READY)
 713   {
 714     /* Change RNG peripheral state */
 715     hrng->State = HAL_RNG_STATE_BUSY;
 716
 717     /* Enable the RNG Interrupts: Data Ready, Clock error, Seed error */
 718     __HAL_RNG_ENABLE_IT(hrng);
 719   }
 720   else
 721   {
 722     /* Process Unlocked */
 723     __HAL_UNLOCK(hrng);
 724
 725     hrng->ErrorCode = HAL_RNG_ERROR_BUSY;
 726     status = HAL_ERROR;
 727   }
 728
 729   return status;
 730 }
 731
 732 /**
 733   * @brief  Handles RNG interrupt request.
 734   * @note   In the case of a clock error, the RNG is no more able to generate
 735   *         random numbers because the PLL48CLK clock is not correct. User has
 736   *         to check that the clock controller is correctly configured to provide
 737   *         the RNG clock and clear the CEIS bit using __HAL_RNG_CLEAR_IT().
 738   *         The clock error has no impact on the previously generated
 739   *         random numbers, and the RNG_DR register contents can be used.
 740   * @note   In the case of a seed error, the generation of random numbers is
 741   *         interrupted as long as the SECS bit is '1'. If a number is
 742   *         available in the RNG_DR register, it must not be used because it may
 743   *         not have enough entropy. In this case, it is recommended to clear the
 744   *         SEIS bit using __HAL_RNG_CLEAR_IT(), then disable and enable
 745   *         the RNG peripheral to reinitialize and restart the RNG.
 746   * @note   User-written HAL_RNG_ErrorCallback() API is called once whether SEIS
 747   *         or CEIS are set.
 748   * @param  hrng pointer to a RNG_HandleTypeDef structure that contains
 749   *                the configuration information for RNG.
 750   * @retval None
 751
 752   */
 753 void HAL_RNG_IRQHandler(RNG_HandleTypeDef *hrng)
 754 {
 755   uint32_t rngclockerror = 0U;
 756
 757   /* RNG clock error interrupt occurred */
 758   if (__HAL_RNG_GET_IT(hrng, RNG_IT_CEI) != RESET)
 759   {
 760     /* Update the error code */
 761     hrng->ErrorCode = HAL_RNG_ERROR_CLOCK;
 762     rngclockerror = 1U;
 763   }
 764   else if (__HAL_RNG_GET_IT(hrng, RNG_IT_SEI) != RESET)
 765   {
 766     /* Update the error code */
 767     hrng->ErrorCode = HAL_RNG_ERROR_SEED;
 768     rngclockerror = 1U;
 769   }
 770   else
 771   {
 772     /* Nothing to do */
 773   }
 774
 775   if (rngclockerror == 1U)
 776   {
 777     /* Change RNG peripheral state */
 778     hrng->State = HAL_RNG_STATE_ERROR;
 779
 780 #if (USE_HAL_RNG_REGISTER_CALLBACKS == 1)
 781     /* Call registered Error callback */
 782     hrng->ErrorCallback(hrng);
 783 #else
 784     /* Call legacy weak Error callback */
 785     HAL_RNG_ErrorCallback(hrng);
 786 #endif /* USE_HAL_RNG_REGISTER_CALLBACKS */
 787
 788     /* Clear the clock error flag */
 789     __HAL_RNG_CLEAR_IT(hrng, RNG_IT_CEI | RNG_IT_SEI);
 790   }
 791
 792   /* Check RNG data ready interrupt occurred */
 793   if (__HAL_RNG_GET_IT(hrng, RNG_IT_DRDY) != RESET)
 794   {
 795     /* Generate random number once, so disable the IT */
 796     __HAL_RNG_DISABLE_IT(hrng);
 797
 798     /* Get the 32bit Random number (DRDY flag automatically cleared) */
 799     hrng->RandomNumber = hrng->Instance->DR;
 800
 801     if (hrng->State != HAL_RNG_STATE_ERROR)
 802     {
 803       /* Change RNG peripheral state */
 804       hrng->State = HAL_RNG_STATE_READY;
 805       /* Process Unlocked */
 806       __HAL_UNLOCK(hrng);
 807
 808 #if (USE_HAL_RNG_REGISTER_CALLBACKS == 1)
 809       /* Call registered Data Ready callback */
 810       hrng->ReadyDataCallback(hrng, hrng->RandomNumber);
 811 #else
 812       /* Call legacy weak Data Ready callback */
 813       HAL_RNG_ReadyDataCallback(hrng, hrng->RandomNumber);
 814 #endif /* USE_HAL_RNG_REGISTER_CALLBACKS */
 815     }
 816   }
 817 }
 818
 819 /**
 820   * @brief  Read latest generated random number.
 821   * @param  hrng pointer to a RNG_HandleTypeDef structure that contains
 822   *                the configuration information for RNG.
 823   * @retval random value
 824   */
 825 uint32_t HAL_RNG_ReadLastRandomNumber(RNG_HandleTypeDef *hrng)
 826 {
 827   return (hrng->RandomNumber);
 828 }
 829
 830 /**
 831   * @brief  Data Ready callback in non-blocking mode.
 832   * @note   When RNG_FLAG_DRDY flag value is set, first random number has been read
 833   *         from DR register in IRQ Handler and is provided as callback parameter.
 834   *         Depending on valid data available in the conditioning output buffer,
 835   *         additional words can be read by the application from DR register till
 836   *         DRDY bit remains high.
 837   * @param  hrng pointer to a RNG_HandleTypeDef structure that contains
 838   *                the configuration information for RNG.
 839   * @param  random32bit generated random number.
 840   * @retval None
 841   */
 842 __weak void HAL_RNG_ReadyDataCallback(RNG_HandleTypeDef *hrng, uint32_t random32bit)
 843 {
 844   /* Prevent unused argument(s) compilation warning */
 845   UNUSED(hrng);
 846   UNUSED(random32bit);
 847   /* NOTE : This function should not be modified. When the callback is needed,
 848             function HAL_RNG_ReadyDataCallback must be implemented in the user file.
 849    */
 850 }
 851
 852 /**
 853   * @brief  RNG error callbacks.
 854   * @param  hrng pointer to a RNG_HandleTypeDef structure that contains
 855   *                the configuration information for RNG.
 856   * @retval None
 857   */
 858 __weak void HAL_RNG_ErrorCallback(RNG_HandleTypeDef *hrng)
 859 {
 860   /* Prevent unused argument(s) compilation warning */
 861   UNUSED(hrng);
 862   /* NOTE : This function should not be modified. When the callback is needed,
 863             function HAL_RNG_ErrorCallback must be implemented in the user file.
 864    */
 865 }
 866 /**
 867   * @}
 868   */
 869
 870
 871 /** @addtogroup RNG_Exported_Functions_Group3
 872  *  @brief   Peripheral State functions
 873  *
 874 @verbatim
 875  ===============================================================================
 876                       ##### Peripheral State functions #####
 877  ===============================================================================
 878     [..]
 879     This subsection permits to get in run-time the status of the peripheral
 880     and the data flow.
 881
 882 @endverbatim
 883   * @{
 884   */
 885
 886 /**
 887   * @brief  Returns the RNG state.
 888   * @param  hrng pointer to a RNG_HandleTypeDef structure that contains
 889   *                the configuration information for RNG.
 890   * @retval HAL state
 891   */
 892 HAL_RNG_StateTypeDef HAL_RNG_GetState(RNG_HandleTypeDef *hrng)
 893 {
 894   return hrng->State;
 895 }
 896
 897 /**
 898   * @brief  Return the RNG handle error code.
 899   * @param  hrng: pointer to a RNG_HandleTypeDef structure.
 900   * @retval RNG Error Code
 901 */
 902 uint32_t HAL_RNG_GetError(RNG_HandleTypeDef *hrng)
 903 {
 904   /* Return RNG Error Code */
 905   return hrng->ErrorCode;
 906 }
 907 /**
 908   * @}
 909   */
 910
 911 /**
 912   * @}
 913   */
 914
 915
 916 #endif /* HAL_RNG_MODULE_ENABLED */
 917 /**
 918   * @}
 919   */
 920
 921 #endif /* RNG */
 922
 923 /**
 924   * @}
 925   */
 926
 927 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/