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

   1 /**
   2   ******************************************************************************
   3   * @file    stm32h7xx_hal_otfdec.c
   4   * @author  MCD Application Team
   5   * @brief   OTFDEC HAL module driver.
   6   *          This file provides firmware functions to manage the following
   7   *          functionalities of the On-The-Fly Decryption (OTFDEC) peripheral:
   8   *           + Initialization and de-initialization functions
   9   *           + Region setting/enable functions
  10   *           + Peripheral State functions
  11   *
  12   @verbatim
  13   ==============================================================================
  14                      ##### How to use this driver #####
  15   ==============================================================================
  16  [..]
  17     The OTFDEC HAL driver can be used as follows:
  18
  19     (#) Declare an OTFDEC_HandleTypeDef handle structure (eg. OTFDEC_HandleTypeDef hotfdec).
  20
  21     (#) Initialize the OTFDEC low level resources by implementing the HAL_OTFDEC_MspInit() API:
  22         (++) Enable the OTFDEC interface clock.
  23         (++) NVIC configuration if interrupts are used
  24             (+++) Configure the OTFDEC interrupt priority.
  25             (+++) Enable the NVIC OTFDEC IRQ handle.
  26
  27     (#) Initialize the OTFDEC peripheral by calling the HAL_OTFDEC_Init() API.
  28
  29     (#) For each region,
  30
  31         (++) Configure the region deciphering mode by calling the HAL_OTFDEC_RegionSetMode() API.
  32
  33         (++) Write the region Key by calling the HAL_OTFDEC_RegionSetKey() API. If desired,
  34         read the key CRC by calling HAL_OTFDEC_RegionGetKeyCRC() API and compare the
  35         result with the theoretically expected CRC.
  36
  37         (++) Initialize the OTFDEC region config structure with the Nonce, protected
  38         region start and end addresses and firmware version, and wrap-up the region
  39         configuration by calling HAL_OTFDEC_RegionConfig() API.
  40
  41     (#) At this point, the OTFDEC region configuration is done and the deciphering
  42         is enabled. The region can be deciphered on the fly after having made sure
  43         the OctoSPI is configured in memory-mapped mode.
  44
  45     [..]
  46     (@) Warning: the OTFDEC deciphering is based on a different endianness compared
  47         to the AES-CTR as implemented in the AES peripheral. E.g., if the OTFEC
  48         resorts to the Key (B0, B1, B2, B3) where Bi are 32-bit longwords and B0
  49         is the Least Significant Word, the AES has to be configured with the Key
  50         (B3, B2, B1, B0) to report the same result (with the same swapping applied
  51         to the Initialization Vector).
  52
  53     [..]
  54
  55     *** Callback registration ***
  56     =============================================
  57     [..]
  58
  59      The compilation flag USE_HAL_OTFDEC_REGISTER_CALLBACKS, when set to 1,
  60      allows the user to configure dynamically the driver callbacks.
  61      Use Functions @ref HAL_OTFDEC_RegisterCallback()
  62      to register an interrupt callback.
  63     [..]
  64
  65      Function @ref HAL_OTFDEC_RegisterCallback() allows to register following callbacks:
  66        (+) ErrorCallback                  : OTFDEC error callback
  67        (+) MspInitCallback                : OTFDEC Msp Init callback
  68        (+) MspDeInitCallback              : OTFDEC Msp DeInit callback
  69      This function takes as parameters the HAL peripheral handle, the Callback ID
  70      and a pointer to the user callback function.
  71     [..]
  72
  73      Use function @ref HAL_OTFDEC_UnRegisterCallback to reset a callback to the default
  74      weak function.
  75     [..]
  76
  77      @ref HAL_OTFDEC_UnRegisterCallback takes as parameters the HAL peripheral handle,
  78      and the Callback ID.
  79      This function allows to reset following callbacks:
  80        (+) ErrorCallback                  : OTFDEC error callback
  81        (+) MspInitCallback                : OTFDEC Msp Init callback
  82        (+) MspDeInitCallback              : OTFDEC Msp DeInit callback
  83      [..]
  84
  85      By default, after the @ref HAL_OTFDEC_Init() and when the state is @ref HAL_OTFDEC_STATE_RESET
  86      all callbacks are set to the corresponding weak functions:
  87      example @ref HAL_OTFDEC_ErrorCallback().
  88      Exception done for MspInit and MspDeInit functions that are
  89      reset to the legacy weak functions in the @ref HAL_OTFDEC_Init()/ @ref HAL_OTFDEC_DeInit() only when
  90      these callbacks are null (not registered beforehand).
  91     [..]
  92
  93      If MspInit or MspDeInit are not null, the @ref HAL_OTFDEC_Init()/ @ref HAL_OTFDEC_DeInit()
  94      keep and use the user MspInit/MspDeInit callbacks (registered beforehand) whatever the state.
  95      [..]
  96
  97      Callbacks can be registered/unregistered in @ref HAL_OTFDEC_STATE_READY state only.
  98      Exception done MspInit/MspDeInit functions that can be registered/unregistered
  99      in @ref HAL_OTFDEC_STATE_READY or @ref HAL_OTFDEC_STATE_RESET state,
 100      thus registered (user) MspInit/DeInit callbacks can be used during the Init/DeInit.
 101     [..]
 102
 103      Then, the user first registers the MspInit/MspDeInit user callbacks
 104      using @ref HAL_OTFDEC_RegisterCallback() before calling @ref HAL_OTFDEC_DeInit()
 105      or @ref HAL_OTFDEC_Init() function.
 106      [..]
 107
 108      When the compilation flag USE_HAL_OTFDEC_REGISTER_CALLBACKS is set to 0 or
 109      not defined, the callback registration feature is not available and all callbacks
 110      are set to the corresponding weak functions.
 111
 112   @endverbatim
 113   ******************************************************************************
 114   * @attention
 115   *
 116   * <h2><center>&copy; Copyright (c) 2018 STMicroelectronics.
 117   * All rights reserved.</center></h2>
 118   *
 119   * This software component is licensed by ST under BSD 3-Clause license,
 120   * the "License"; You may not use this file except in compliance with the
 121   * License. You may obtain a copy of the License at:
 122   *                        opensource.org/licenses/BSD-3-Clause
 123   *
 124   ******************************************************************************
 125   */
 126
 127 /* Includes ------------------------------------------------------------------*/
 128 #include "stm32h7xx_hal.h"
 129
 130 /** @addtogroup STM32H7xx_HAL_Driver
 131   * @{
 132   */
 133
 134 /** @defgroup OTFDEC OTFDEC
 135   * @brief OTFDEC HAL module driver.
 136   * @{
 137   */
 138
 139
 140 #ifdef HAL_OTFDEC_MODULE_ENABLED
 141
 142 #if defined(OTFDEC1)
 143
 144 /* Private typedef -----------------------------------------------------------*/
 145 /* Private define ------------------------------------------------------------*/
 146 /* Private macro -------------------------------------------------------------*/
 147 /* Private variables ---------------------------------------------------------*/
 148 /* Private function prototypes -----------------------------------------------*/
 149 /* Private functions ---------------------------------------------------------*/
 150
 151
 152
 153  /* Exported functions --------------------------------------------------------*/
 154 /** @addtogroup OTFDEC_Exported_Functions
 155   * @{
 156   */
 157
 158 /** @defgroup OTFDEC_Exported_Functions_Group1 Initialization and de-initialization functions
 159  *  @brief    Initialization and Configuration functions.
 160  *
 161 @verbatim
 162   ==============================================================================
 163               ##### Initialization and de-initialization functions #####
 164   ==============================================================================
 165
 166 @endverbatim
 167   * @{
 168   */
 169
 170 /**
 171   * @brief  Initialize the OTFDEC peripheral and create the associated handle.
 172   * @param  hotfdec pointer to an OTFDEC_HandleTypeDef structure that contains
 173   *         the configuration information for OTFDEC module
 174   * @retval HAL status
 175   */
 176 HAL_StatusTypeDef HAL_OTFDEC_Init(OTFDEC_HandleTypeDef *hotfdec)
 177 {
 178   /* Check the OTFDEC handle allocation */
 179   if(hotfdec == NULL)
 180   {
 181     return HAL_ERROR;
 182   }
 183
 184   /* Check the parameters */
 185   assert_param(IS_OTFDEC_ALL_INSTANCE(hotfdec->Instance));
 186
 187   if(hotfdec->State == HAL_OTFDEC_STATE_RESET)
 188   {
 189     /* Allocate lock resource and initialize it */
 190     __HAL_UNLOCK(hotfdec);
 191
 192 #if (USE_HAL_OTFDEC_REGISTER_CALLBACKS == 1)
 193     /* Init the OTFDEC Callback settings */
 194     hotfdec->ErrorCallback = HAL_OTFDEC_ErrorCallback; /* Legacy weak callback */
 195
 196     if (hotfdec->MspInitCallback == NULL)
 197     {
 198       hotfdec->MspInitCallback = HAL_OTFDEC_MspInit; /* Legacy weak MspInit */
 199     }
 200
 201     /* Init the low level hardware */
 202     hotfdec->MspInitCallback(hotfdec);
 203 #else
 204     /* Init the low level hardware */
 205     HAL_OTFDEC_MspInit(hotfdec);
 206 #endif /* USE_HAL_OTFDEC_REGISTER_CALLBACKS */
 207   }
 208
 209   /* Change the OTFDEC state */
 210   hotfdec->State = HAL_OTFDEC_STATE_READY;
 211
 212   /* Return function status */
 213   return HAL_OK;
 214 }
 215
 216 /**
 217   * @brief  DeInitialize the OTFDEC peripheral.
 218   * @param  hotfdec pointer to an OTFDEC_HandleTypeDef structure that contains
 219   *         the configuration information for OTFDEC module
 220   * @retval HAL status
 221   */
 222 HAL_StatusTypeDef HAL_OTFDEC_DeInit(OTFDEC_HandleTypeDef *hotfdec)
 223 {
 224   /* Check the OTFDEC handle allocation */
 225   if(hotfdec == NULL)
 226   {
 227     return HAL_ERROR;
 228   }
 229
 230   /* Check the parameters */
 231   assert_param(IS_OTFDEC_ALL_INSTANCE(hotfdec->Instance));
 232
 233   /* Change the OTFDEC state */
 234   hotfdec->State = HAL_OTFDEC_STATE_BUSY;
 235
 236 #if (USE_HAL_OTFDEC_REGISTER_CALLBACKS == 1)
 237   if (hotfdec->MspDeInitCallback == NULL)
 238   {
 239     hotfdec->MspDeInitCallback = HAL_OTFDEC_MspDeInit; /* Legacy weak MspDeInit */
 240   }
 241
 242   /* DeInit the low level hardware: CLOCK, NVIC */
 243   hotfdec->MspDeInitCallback(hotfdec);
 244 #else
 245   /* DeInit the low level hardware: CLOCK, NVIC */
 246   HAL_OTFDEC_MspDeInit(hotfdec);
 247 #endif /* USE_HAL_OTFDEC_REGISTER_CALLBACKS */
 248
 249   /* Change the OTFDEC state */
 250   hotfdec->State = HAL_OTFDEC_STATE_RESET;
 251
 252   /* Reset OTFDEC error status */
 253   hotfdec->ErrorCode = HAL_OTFDEC_ERROR_NONE;
 254
 255   /* Release Lock */
 256   __HAL_UNLOCK(hotfdec);
 257
 258   /* Return function status */
 259   return HAL_OK;
 260 }
 261
 262 /**
 263   * @brief  Initialize the OTFDEC MSP.
 264   * @param  hotfdec pointer to an OTFDEC_HandleTypeDef structure that contains
 265   *         the configuration information for OTFDEC module
 266   * @retval None
 267   */
 268 __weak void HAL_OTFDEC_MspInit(OTFDEC_HandleTypeDef *hotfdec)
 269 {
 270   /* Prevent unused argument(s) compilation warning */
 271   UNUSED(hotfdec);
 272
 273   /* NOTE : This function should not be modified; when the callback is needed,
 274             the HAL_OTFDEC_MspInit can be implemented in the user file.
 275    */
 276 }
 277
 278 /**
 279   * @brief  DeInitialize OTFDEC MSP.
 280   * @param  hotfdec pointer to an OTFDEC_HandleTypeDef structure that contains
 281   *         the configuration information for OTFDEC module
 282   * @retval None
 283   */
 284 __weak void HAL_OTFDEC_MspDeInit(OTFDEC_HandleTypeDef *hotfdec)
 285 {
 286   /* Prevent unused argument(s) compilation warning */
 287   UNUSED(hotfdec);
 288
 289   /* NOTE : This function should not be modified; when the callback is needed,
 290             the HAL_OTFDEC_MspDeInit can be implemented in the user file.
 291    */
 292 }
 293
 294 #if (USE_HAL_OTFDEC_REGISTER_CALLBACKS == 1)
 295 /**
 296   * @brief  Register a User OTFDEC Callback
 297   *         To be used instead of the weak predefined callback
 298   * @param  hotfdec pointer to an OTFDEC_HandleTypeDef structure that contains
 299   *         the configuration information for OTFDEC module
 300   * @param  CallbackID ID of the callback to be registered
 301   *         This parameter can be one of the following values:
 302   *          @arg @ref HAL_OTFDEC_ERROR_CB_ID           OTFDEC error callback ID
 303   *          @arg @ref HAL_OTFDEC_MSPINIT_CB_ID         MspInit callback ID
 304   *          @arg @ref HAL_OTFDEC_MSPDEINIT_CB_ID       MspDeInit callback ID
 305   * @param  pCallback pointer to the Callback function
 306   * @retval HAL status
 307   */
 308 HAL_StatusTypeDef HAL_OTFDEC_RegisterCallback(OTFDEC_HandleTypeDef *hotfdec, HAL_OTFDEC_CallbackIDTypeDef CallbackID, pOTFDEC_CallbackTypeDef pCallback)
 309 {
 310   HAL_StatusTypeDef status = HAL_OK;
 311
 312   if (pCallback == NULL)
 313   {
 314     /* Update the error code */
 315     hotfdec->ErrorCode |= HAL_OTFDEC_ERROR_INVALID_CALLBACK;
 316
 317     return HAL_ERROR;
 318   }
 319
 320   if (hotfdec->State == HAL_OTFDEC_STATE_READY)
 321   {
 322     switch (CallbackID)
 323     {
 324       case HAL_OTFDEC_ERROR_CB_ID :
 325         hotfdec->ErrorCallback = pCallback;
 326         break;
 327
 328       case HAL_OTFDEC_MSPINIT_CB_ID :
 329         hotfdec->MspInitCallback = pCallback;
 330         break;
 331
 332       case HAL_OTFDEC_MSPDEINIT_CB_ID :
 333         hotfdec->MspDeInitCallback = pCallback;
 334         break;
 335
 336       default :
 337         /* Update the error code */
 338         hotfdec->ErrorCode |= HAL_OTFDEC_ERROR_INVALID_CALLBACK;
 339
 340         /* Return error status */
 341         status = HAL_ERROR;
 342         break;
 343     }
 344   }
 345   else if (HAL_OTFDEC_STATE_RESET == hotfdec->State)
 346   {
 347     switch (CallbackID)
 348     {
 349       case HAL_OTFDEC_MSPINIT_CB_ID :
 350         hotfdec->MspInitCallback = pCallback;
 351         break;
 352
 353       case HAL_OTFDEC_MSPDEINIT_CB_ID :
 354         hotfdec->MspDeInitCallback = pCallback;
 355         break;
 356
 357       default :
 358         /* Update the error code */
 359         hotfdec->ErrorCode |= HAL_OTFDEC_ERROR_INVALID_CALLBACK;
 360
 361         /* Return error status */
 362         status = HAL_ERROR;
 363         break;
 364     }
 365   }
 366   else
 367   {
 368     /* Update the error code */
 369     hotfdec->ErrorCode |= HAL_OTFDEC_ERROR_INVALID_CALLBACK;
 370
 371     /* Return error status */
 372     status =  HAL_ERROR;
 373   }
 374
 375   return status;
 376 }
 377
 378 /**
 379   * @brief  Unregister a OTFDEC Callback
 380   *         OTFDEC callback is redirected to the weak predefined callback
 381   * @param  hotfdec pointer to an OTFDEC_HandleTypeDef structure that contains
 382   *         the configuration information for OTFDEC module
 383   * @param  CallbackID ID of the callback to be registered
 384   *         This parameter can be one of the following values:
 385   *          @arg @ref HAL_OTFDEC_ERROR_CB_ID           OTFDEC error callback ID
 386   *          @arg @ref HAL_OTFDEC_MSPINIT_CB_ID         MspInit callback ID
 387   *          @arg @ref HAL_OTFDEC_MSPDEINIT_CB_ID       MspDeInit callback ID
 388   * @retval HAL status
 389   */
 390 HAL_StatusTypeDef HAL_OTFDEC_UnRegisterCallback(OTFDEC_HandleTypeDef *hotfdec, HAL_OTFDEC_CallbackIDTypeDef CallbackID)
 391 {
 392   HAL_StatusTypeDef status = HAL_OK;
 393
 394   if (hotfdec->State == HAL_OTFDEC_STATE_READY)
 395   {
 396     switch (CallbackID)
 397     {
 398       case HAL_OTFDEC_ERROR_CB_ID :
 399         hotfdec->ErrorCallback = HAL_OTFDEC_ErrorCallback;
 400         break;
 401
 402       case HAL_OTFDEC_MSPINIT_CB_ID :
 403         hotfdec->MspInitCallback = HAL_OTFDEC_MspInit; /* Legacy weak MspInit */
 404         break;
 405
 406       case HAL_OTFDEC_MSPDEINIT_CB_ID :
 407         hotfdec->MspDeInitCallback = HAL_OTFDEC_MspDeInit; /* Legacy weak MspDeInit */
 408         break;
 409
 410       default :
 411         /* Update the error code */
 412         hotfdec->ErrorCode |= HAL_OTFDEC_ERROR_INVALID_CALLBACK;
 413
 414         /* Return error status */
 415         status =  HAL_ERROR;
 416         break;
 417     }
 418   }
 419   else if (HAL_OTFDEC_STATE_RESET == hotfdec->State)
 420   {
 421     switch (CallbackID)
 422     {
 423       case HAL_OTFDEC_MSPINIT_CB_ID :
 424         hotfdec->MspInitCallback = HAL_OTFDEC_MspInit; /* Legacy weak MspInit */
 425         break;
 426
 427       case HAL_OTFDEC_MSPDEINIT_CB_ID :
 428         hotfdec->MspDeInitCallback = HAL_OTFDEC_MspDeInit; /* Legacy weak MspDeInit */
 429         break;
 430
 431       default :
 432         /* Update the error code */
 433         hotfdec->ErrorCode |= HAL_OTFDEC_ERROR_INVALID_CALLBACK;
 434
 435         /* Return error status */
 436         status =  HAL_ERROR;
 437         break;
 438     }
 439   }
 440   else
 441   {
 442     /* Update the error code */
 443     hotfdec->ErrorCode |= HAL_OTFDEC_ERROR_INVALID_CALLBACK;
 444
 445     /* Return error status */
 446     status =  HAL_ERROR;
 447   }
 448
 449   return status;
 450 }
 451
 452 #endif /* USE_HAL_OTFDEC_REGISTER_CALLBACKS */
 453
 454 /**
 455   * @}
 456   */
 457
 458 /** @defgroup OTFDEC_Exported_Functions_Group2  OTFDEC IRQ handler management
 459  *  @brief   OTFDEC IRQ handler.
 460  *
 461 @verbatim
 462   ==============================================================================
 463                 ##### OTFDEC IRQ handler management #####
 464   ==============================================================================
 465 [..]  This section provides OTFDEC IRQ handler function.
 466
 467 @endverbatim
 468   * @{
 469   */
 470
 471 /**
 472   * @brief  Handle OTFDEC interrupt request.
 473   * @param  hotfdec pointer to an OTFDEC_HandleTypeDef structure that contains
 474   *         the configuration information for OTFDEC module
 475   * @retval None
 476   */
 477 void HAL_OTFDEC_IRQHandler(OTFDEC_HandleTypeDef *hotfdec)
 478 {
 479   uint32_t isr_reg;
 480
 481   isr_reg = READ_REG(hotfdec->Instance->ISR);
 482   if ((isr_reg & OTFDEC_ISR_SEIF) == OTFDEC_ISR_SEIF)
 483   {
 484     SET_BIT( hotfdec->Instance->ICR, OTFDEC_ICR_SEIF );
 485     hotfdec->ErrorCode |= HAL_OTFDEC_SECURITY_ERROR;
 486   }
 487   if ((isr_reg & OTFDEC_ISR_XONEIF) == OTFDEC_ISR_XONEIF)
 488   {
 489     SET_BIT( hotfdec->Instance->ICR, OTFDEC_ICR_XONEIF );
 490     hotfdec->ErrorCode |= HAL_OTFDEC_EXECUTE_ERROR;
 491   }
 492   if ((isr_reg & OTFDEC_ISR_KEIF) == OTFDEC_ISR_KEIF)
 493   {
 494     SET_BIT( hotfdec->Instance->ICR, OTFDEC_ICR_KEIF );
 495     hotfdec->ErrorCode |= HAL_OTFDEC_KEY_ERROR;
 496   }
 497
 498 #if (USE_HAL_OTFDEC_REGISTER_CALLBACKS == 1)
 499   hotfdec->ErrorCallback(hotfdec);
 500 #else
 501   HAL_OTFDEC_ErrorCallback(hotfdec);
 502 #endif /* USE_HAL_OTFDEC_REGISTER_CALLBACKS */
 503 }
 504
 505 /**
 506   * @brief OTFDEC error callback.
 507   * @param  hotfdec pointer to an OTFDEC_HandleTypeDef structure that contains
 508   *         the configuration information for OTFDEC module
 509   * @retval None
 510   */
 511 __weak void HAL_OTFDEC_ErrorCallback(OTFDEC_HandleTypeDef *hotfdec)
 512 {
 513   /* Prevent unused argument(s) compilation warning */
 514   UNUSED(hotfdec);
 515
 516   /* NOTE : This function should not be modified; when the callback is needed,
 517             the HAL_OTFDEC_ErrorCallback can be implemented in the user file.
 518    */
 519 }
 520
 521 /**
 522   * @}
 523   */
 524
 525
 526
 527
 528 /** @defgroup OTFDEC_Exported_Functions_Group3 Peripheral Control functions
 529  *  @brief   Peripheral control functions.
 530  *
 531 @verbatim
 532   ==============================================================================
 533                       ##### Peripheral Control functions #####
 534   ==============================================================================
 535     [..]
 536     This subsection permits to configure the OTFDEC peripheral
 537
 538 @endverbatim
 539   * @{
 540   */
 541
 542 /**
 543   * @brief  Lock region keys.
 544   * @note   Writes to this region KEYRx registers are ignored until next OTFDEC reset.
 545   * @param  hotfdec pointer to an OTFDEC_HandleTypeDef structure that contains
 546   *         the configuration information for OTFDEC module
 547   * @param  RegionIndex index of region the keys of which are locked
 548   * @retval HAL state
 549   */
 550 HAL_StatusTypeDef HAL_OTFDEC_RegionKeyLock(OTFDEC_HandleTypeDef *hotfdec, uint32_t RegionIndex)
 551 {
 552   OTFDEC_Region_TypeDef * region;
 553   uint32_t address;
 554
 555   /* Check the parameters */
 556   assert_param(IS_OTFDEC_ALL_INSTANCE(hotfdec->Instance));
 557   assert_param(IS_OTFDEC_REGIONINDEX(RegionIndex));
 558
 559   /* Take Lock */
 560   __HAL_LOCK(hotfdec);
 561
 562   address =   (uint32_t)(hotfdec->Instance) + 0x20U + (0x30U * RegionIndex);
 563   region = (OTFDEC_Region_TypeDef *)address;
 564
 565   SET_BIT( region->REG_CONFIGR, OTFDEC_REG_CONFIGR_KEYLOCK );
 566
 567   /* Release Lock */
 568   __HAL_UNLOCK(hotfdec);
 569
 570   /* Status is okay */
 571   return HAL_OK;
 572 }
 573
 574 /**
 575   * @brief  Set region keys.
 576   * @param  hotfdec pointer to an OTFDEC_HandleTypeDef structure that contains
 577   *         the configuration information for OTFDEC module
 578   * @param  RegionIndex index of region the keys of which are set
 579   * @param  pKey pointer at set of keys
 580   * @note   The API reads the key CRC computed by the peripheral and compares it with that
 581   *         theoretically expected. An error is reported if they are different.
 582   * @retval HAL state
 583   */
 584 HAL_StatusTypeDef HAL_OTFDEC_RegionSetKey(OTFDEC_HandleTypeDef *hotfdec, uint32_t RegionIndex, uint32_t *pKey)
 585 {
 586   OTFDEC_Region_TypeDef * region;
 587   uint32_t address;
 588
 589   /* Check the parameters */
 590   assert_param(IS_OTFDEC_ALL_INSTANCE(hotfdec->Instance));
 591   assert_param(IS_OTFDEC_REGIONINDEX(RegionIndex));
 592
 593   if (pKey == NULL)
 594   {
 595     return HAL_ERROR;
 596   }
 597   else
 598   {
 599     /* Take Lock */
 600     __HAL_LOCK(hotfdec);
 601
 602     address =   (uint32_t)(hotfdec->Instance) + 0x20U + (0x30U * RegionIndex);
 603     region = (OTFDEC_Region_TypeDef *)address;
 604
 605     /* Set Key */
 606     WRITE_REG( region->REG_KEYR0, pKey[0]);
 607
 608     __DSB();
 609     __ISB();
 610
 611     WRITE_REG( region->REG_KEYR1, pKey[1]);
 612
 613     __DSB();
 614     __ISB();
 615
 616     WRITE_REG( region->REG_KEYR2, pKey[2]);
 617
 618     __DSB();
 619     __ISB();
 620
 621     WRITE_REG( region->REG_KEYR3, pKey[3]);
 622
 623     /* Compute theoretically expected CRC and compare it with that reported by the peripheral */
 624     if (HAL_OTFDEC_KeyCRCComputation(pKey) != HAL_OTFDEC_RegionGetKeyCRC(hotfdec, RegionIndex))
 625     {
 626       /* Release Lock */
 627       __HAL_UNLOCK(hotfdec);
 628
 629       /* Status is okay */
 630       return HAL_ERROR;
 631     }
 632
 633     /* Release Lock */
 634     __HAL_UNLOCK(hotfdec);
 635
 636     /* Status is okay */
 637     return HAL_OK;
 638   }
 639 }
 640
 641 /**
 642   * @brief  Set region mode.
 643   * @param  hotfdec pointer to an OTFDEC_HandleTypeDef structure that contains
 644   *         the configuration information for OTFDEC module
 645   * @param  RegionIndex index of region the mode of which is set
 646   * @param  mode This parameter can be only:
 647   *           @arg @ref OTFDEC_REG_MODE_INSTRUCTION_ACCESSES_ONLY             Only instruction accesses are decrypted
 648   *           @arg @ref OTFDEC_REG_MODE_DATA_ACCESSES_ONLY                    Only data accesses are decrypted
 649   *           @arg @ref OTFDEC_REG_MODE_INSTRUCTION_OR_DATA_ACCESSES          All read accesses are decrypted (instruction or data)
 650   *           @arg @ref OTFDEC_REG_MODE_INSTRUCTION_ACCESSES_ONLY_WITH_CIPHER Only instruction accesses are decrypted with proprietary cipher activated
 651   * @retval HAL state
 652   */
 653 HAL_StatusTypeDef HAL_OTFDEC_RegionSetMode(OTFDEC_HandleTypeDef *hotfdec, uint32_t RegionIndex, uint32_t mode)
 654 {
 655   OTFDEC_Region_TypeDef * region;
 656   uint32_t address;
 657
 658   /* Check the parameters */
 659   assert_param(IS_OTFDEC_ALL_INSTANCE(hotfdec->Instance));
 660   assert_param(IS_OTFDEC_REGIONINDEX(RegionIndex));
 661   assert_param(IS_OTFDEC_REGION_OPERATING_MODE(mode));
 662
 663   /* Take Lock */
 664   __HAL_LOCK(hotfdec);
 665
 666   address =   (uint32_t)(hotfdec->Instance) + 0x20U + (0x30U * RegionIndex);
 667   region = (OTFDEC_Region_TypeDef *)address;
 668
 669   /* Set mode */
 670   MODIFY_REG(region->REG_CONFIGR, OTFDEC_REG_CONFIGR_MODE, mode);
 671
 672   /* Release Lock */
 673   __HAL_UNLOCK(hotfdec);
 674
 675   /* Status is okay */
 676   return HAL_OK;
 677 }
 678
 679 /**
 680   * @brief  Set region configuration.
 681   * @note  Region deciphering is enabled at the end of this function
 682   * @param  hotfdec pointer to an OTFDEC_HandleTypeDef structure that contains
 683   *         the configuration information for OTFDEC module
 684   * @param  RegionIndex index of region that is configured
 685   * @param  Config pointer on structure containing the region configuration parameters
 686   * @param  lock configuration lock enable or disable parameter
 687   *         This parameter can be one of the following values:
 688   *          @arg @ref OTFDEC_REG_CONFIGR_LOCK_DISABLE      OTFDEC region configuration is not locked
 689   *          @arg @ref OTFDEC_REG_CONFIGR_LOCK_ENABLE       OTFDEC region configuration is locked
 690   * @retval HAL state
 691   */
 692 HAL_StatusTypeDef HAL_OTFDEC_RegionConfig(OTFDEC_HandleTypeDef *hotfdec, uint32_t RegionIndex, OTFDEC_RegionConfigTypeDef *Config, uint32_t lock)
 693 {
 694   OTFDEC_Region_TypeDef * region;
 695   uint32_t address;
 696
 697   /* Check the parameters */
 698   assert_param(IS_OTFDEC_ALL_INSTANCE(hotfdec->Instance));
 699   assert_param(IS_OTFDEC_REGIONINDEX(RegionIndex));
 700   assert_param(IS_OTFDEC_REGION_CONFIG_LOCK(lock));
 701
 702   if (Config == NULL)
 703   {
 704     return HAL_ERROR;
 705   }
 706   else
 707   {
 708
 709     /* Take Lock */
 710     __HAL_LOCK(hotfdec);
 711
 712     address =   (uint32_t)(hotfdec->Instance) + 0x20U + (0x30U * RegionIndex);
 713     region = (OTFDEC_Region_TypeDef *)address;
 714
 715     /* Set Nonce */
 716     WRITE_REG( region->REG_NONCER0, Config->Nonce[0]);
 717
 718     WRITE_REG( region->REG_NONCER1, Config->Nonce[1]);
 719
 720     /* Write region protected area start and end addresses */
 721     WRITE_REG( region->REG_START_ADDR, Config->StartAddress);
 722
 723     WRITE_REG( region->REG_END_ADDR, Config->EndAddress);
 724
 725     /* Write Version */
 726     MODIFY_REG( region->REG_CONFIGR, OTFDEC_REG_CONFIGR_VERSION, (uint32_t)(Config->Version) << OTFDEC_REG_CONFIGR_VERSION_Pos );
 727
 728     /* Enable region deciphering or enciphering (depending of OTFDEC_CR ENC bit setting) */
 729     SET_BIT( region->REG_CONFIGR, OTFDEC_REG_CONFIGR_REG_ENABLE);
 730
 731     /* Lock the region configuration according to lock parameter value */
 732     if (lock == OTFDEC_REG_CONFIGR_LOCK_ENABLE)
 733     {
 734       SET_BIT( region->REG_CONFIGR, OTFDEC_REG_CONFIGR_LOCK_ENABLE);
 735     }
 736
 737     /* Release Lock */
 738     __HAL_UNLOCK(hotfdec);
 739
 740     /* Status is okay */
 741     return HAL_OK;
 742   }
 743 }
 744
 745
 746 /**
 747   * @brief  Compute Key CRC
 748   * @param  pKey pointer at set of keys
 749   * @retval CRC value
 750   */
 751 uint32_t HAL_OTFDEC_KeyCRCComputation(uint32_t *pKey)
 752 {
 753   uint8_t crc7_poly = 0x7;
 754   uint32_t key_strobe[4] = {0xAA55AA55U, 0x3U, 0x18U, 0xC0U};
 755   uint8_t  i;
 756   uint8_t crc = 0;
 757   uint32_t  j, keyval, k;
 758   uint32_t * temp = pKey;
 759
 760   for (j = 0U; j < 4U; j++)
 761   {
 762     keyval = *temp;
 763     temp++;
 764     if (j == 0U)
 765     {
 766       keyval ^= key_strobe[0];
 767     }
 768     else
 769     {
 770       keyval ^= (key_strobe[j] << 24) | ((uint32_t)crc << 16) | (key_strobe[j] << 8) | crc;
 771     }
 772
 773     crc = 0;
 774     for (i = 0; i < (uint8_t)32; i++)
 775     {
 776       k = ((((uint32_t)crc >> 7) ^ ((keyval >> ((uint8_t)31-i))&((uint8_t)0xF)))) & 1U;
 777       crc <<= 1;
 778       if (k != 0U)
 779       {
 780         crc ^= crc7_poly;
 781        }
 782     }
 783
 784     crc^=(uint8_t)0x55;
 785   }
 786
 787   return (uint32_t) crc;
 788 }
 789
 790
 791 /**
 792   * @brief  Enable region deciphering.
 793   * @param  hotfdec pointer to an OTFDEC_HandleTypeDef structure that contains
 794   *         the configuration information for OTFDEC module
 795   * @param  RegionIndex index of region the deciphering is enabled
 796   * @note   An error is reported when the configuration is locked.
 797   * @retval HAL state
 798   */
 799 HAL_StatusTypeDef HAL_OTFDEC_RegionEnable(OTFDEC_HandleTypeDef *hotfdec, uint32_t RegionIndex)
 800 {
 801   OTFDEC_Region_TypeDef * region;
 802   uint32_t address;
 803
 804   /* Check the parameters */
 805   assert_param(IS_OTFDEC_ALL_INSTANCE(hotfdec->Instance));
 806   assert_param(IS_OTFDEC_REGIONINDEX(RegionIndex));
 807
 808   /* Take Lock */
 809   __HAL_LOCK(hotfdec);
 810
 811   address =   (uint32_t)(hotfdec->Instance) + 0x20U + (0x30U * RegionIndex);
 812   region = (OTFDEC_Region_TypeDef *)address;
 813
 814   if (READ_BIT( region->REG_CONFIGR, OTFDEC_REG_CONFIGR_LOCK_ENABLE) == OTFDEC_REG_CONFIGR_LOCK_ENABLE)
 815   {
 816     /* Configuration is locked, REG_EN bit can't be modified */
 817     __HAL_UNLOCK(hotfdec);
 818
 819      return HAL_ERROR;
 820   }
 821
 822   /* Enable region processing */
 823   SET_BIT( region->REG_CONFIGR, OTFDEC_REG_CONFIGR_REG_ENABLE);
 824
 825   /* Release Lock */
 826   __HAL_UNLOCK(hotfdec);
 827
 828   /* Status is okay */
 829   return HAL_OK;
 830 }
 831
 832 /**
 833   * @brief  Disable region deciphering.
 834   * @param  hotfdec pointer to an OTFDEC_HandleTypeDef structure that contains
 835   *         the configuration information for OTFDEC module
 836   * @param  RegionIndex index of region the deciphering is disabled
 837   * @note   An error is reported when the configuration is locked.
 838   * @retval HAL state
 839   */
 840 HAL_StatusTypeDef HAL_OTFDEC_RegionDisable(OTFDEC_HandleTypeDef *hotfdec, uint32_t RegionIndex)
 841 {
 842   OTFDEC_Region_TypeDef * region;
 843   uint32_t address;
 844
 845   /* Check the parameters */
 846   assert_param(IS_OTFDEC_ALL_INSTANCE(hotfdec->Instance));
 847   assert_param(IS_OTFDEC_REGIONINDEX(RegionIndex));
 848
 849   /* Take Lock */
 850   __HAL_LOCK(hotfdec);
 851
 852   address =   (uint32_t)(hotfdec->Instance) + 0x20U + (0x30U * RegionIndex);
 853   region = (OTFDEC_Region_TypeDef *)address;
 854
 855   if (READ_BIT( region->REG_CONFIGR, OTFDEC_REG_CONFIGR_LOCK_ENABLE) == OTFDEC_REG_CONFIGR_LOCK_ENABLE)
 856   {
 857     /* Configuration is locked, REG_EN bit can't be modified */
 858     __HAL_UNLOCK(hotfdec);
 859
 860      return HAL_ERROR;
 861   }
 862
 863   /* Disable region processing */
 864   CLEAR_BIT( region->REG_CONFIGR, OTFDEC_REG_CONFIGR_REG_ENABLE);
 865
 866   /* Release Lock */
 867   __HAL_UNLOCK(hotfdec);
 868
 869   /* Status is okay */
 870   return HAL_OK;
 871 }
 872
 873 /**
 874   * @}
 875   */
 876
 877 /** @defgroup OTFDEC_Exported_Functions_Group4 Peripheral State and Status functions
 878  *  @brief   Peripheral State functions.
 879  *
 880 @verbatim
 881   ==============================================================================
 882                       ##### Peripheral State functions #####
 883   ==============================================================================
 884     [..]
 885     This subsection permits to get in run-time the status of the peripheral.
 886
 887 @endverbatim
 888   * @{
 889   */
 890
 891 /**
 892   * @brief  Return the OTFDEC state.
 893   * @param  hotfdec pointer to an OTFDEC_HandleTypeDef structure that contains
 894   *         the configuration information for OTFDEC module
 895   * @retval HAL state
 896   */
 897 HAL_OTFDEC_StateTypeDef HAL_OTFDEC_GetState(OTFDEC_HandleTypeDef *hotfdec)
 898 {
 899   return hotfdec->State;
 900 }
 901
 902
 903 /**
 904   * @brief  Return region keys CRC.
 905   * @param  hotfdec pointer to an OTFDEC_HandleTypeDef structure that contains
 906   *         the configuration information for OTFDEC module
 907   * @param  RegionIndex index of region the keys CRC of which is read
 908   * @retval Key CRC
 909   */
 910 uint32_t HAL_OTFDEC_RegionGetKeyCRC(OTFDEC_HandleTypeDef *hotfdec, uint32_t RegionIndex)
 911 {
 912   OTFDEC_Region_TypeDef * region;
 913   uint32_t address;
 914   uint32_t keycrc;
 915
 916   /* Check the parameters */
 917   assert_param(IS_OTFDEC_ALL_INSTANCE(hotfdec->Instance));
 918   assert_param(IS_OTFDEC_REGIONINDEX(RegionIndex));
 919
 920   address =   (uint32_t)(hotfdec->Instance) + 0x20U + (0x30U * RegionIndex);
 921   region = (OTFDEC_Region_TypeDef *)address;
 922
 923   keycrc = (READ_REG( region->REG_CONFIGR )) & OTFDEC_REG_CONFIGR_KEYCRC;
 924
 925   keycrc >>= OTFDEC_REG_CONFIGR_KEYCRC_Pos;
 926
 927   return keycrc;
 928 }
 929
 930 /**
 931   * @brief  Return region configuration parameters.
 932   * @param  hotfdec pointer to an OTFDEC_HandleTypeDef structure that contains
 933   *         the configuration information for OTFDEC module
 934   * @param  RegionIndex index of region the configuration of which is read
 935   * @param  Config pointer on structure that will be filled up with the region configuration parameters
 936   * @retval HAL state
 937   */
 938 HAL_StatusTypeDef HAL_OTFDEC_RegionGetConfig(OTFDEC_HandleTypeDef *hotfdec, uint32_t RegionIndex, OTFDEC_RegionConfigTypeDef *Config)
 939 {
 940   OTFDEC_Region_TypeDef * region;
 941   uint32_t address;
 942
 943   /* Check the parameters */
 944   assert_param(IS_OTFDEC_ALL_INSTANCE(hotfdec->Instance));
 945   assert_param(IS_OTFDEC_REGIONINDEX(RegionIndex));
 946
 947   if (Config == NULL)
 948   {
 949     return HAL_ERROR;
 950   }
 951   else
 952   {
 953     /* Take Lock */
 954     __HAL_LOCK(hotfdec);
 955
 956     address =   (uint32_t)(hotfdec->Instance) + 0x20U + (0x30U * RegionIndex);
 957     region = (OTFDEC_Region_TypeDef *)address;
 958
 959     /* Read Nonce */
 960     Config->Nonce[0] = READ_REG(region->REG_NONCER0);
 961     Config->Nonce[1] = READ_REG(region->REG_NONCER1);
 962
 963     /* Read Addresses */
 964     Config->StartAddress = READ_REG(region->REG_START_ADDR);
 965     Config->EndAddress = READ_REG(region->REG_END_ADDR);
 966
 967     /* Read Version */
 968     Config->Version = (uint16_t)(READ_REG(region->REG_CONFIGR) & OTFDEC_REG_CONFIGR_VERSION) >> OTFDEC_REG_CONFIGR_VERSION_Pos;
 969
 970     /* Release Lock */
 971     __HAL_UNLOCK(hotfdec);
 972
 973     /* Status is okay */
 974     return HAL_OK;
 975   }
 976 }
 977
 978
 979 /**
 980   * @}
 981   */
 982
 983 /**
 984   * @}
 985   */
 986
 987 #endif /* OTFDEC1 */
 988
 989 #endif /* HAL_OTFDEC_MODULE_ENABLED */
 990
 991
 992 /**
 993   * @}
 994   */
 995
 996 /**
 997   * @}
 998   */