WebSVN – DashDisplay – Diff – /branches/Dashboard_L152_v2/Drivers/STM32L1xx_HAL_Driver/Src/stm32l1xx_hal_cryp.c

 /**
   ******************************************************************************
   * @file    stm32l1xx_hal_cryp.c
   * @author  MCD Application Team
   * @brief   CRYP HAL module driver.
   *
   *          This file provides firmware functions to manage the following
   *          functionalities of the Cryptography (CRYP) peripheral:
   *           + Initialization and de-initialization functions
   *           + Processing functions by algorithm using polling mode
   *           + Processing functions by algorithm using interrupt mode
   *           + Processing functions by algorithm using DMA mode
   *           + Peripheral State functions
   *
   @verbatim
   ==============================================================================
                      ##### How to use this driver #####
   ==============================================================================
     [..]
       The CRYP HAL driver can be used as follows:
       (#)Initialize the CRYP low level resources by implementing the HAL_CRYP_MspInit():
          (##) Enable the CRYP interface clock using __HAL_RCC_CRYP_CLK_ENABLE()
          (##) In case of using interrupts (e.g. HAL_CRYP_AESECB_Encrypt_IT())
              (+) Configure the CRYP interrupt priority using HAL_NVIC_SetPriority()
              (+) Enable the CRYP IRQ handler using HAL_NVIC_EnableIRQ()
              (+) In CRYP IRQ handler, call HAL_CRYP_IRQHandler()
          (##) In case of using DMA to control data transfer (e.g. HAL_CRYP_AESECB_Encrypt_DMA())
              (+) Enable the DMA2 interface clock using
                  (++) __HAL_RCC_DMA2_CLK_ENABLE()
              (+) Configure and enable two DMA Channels one for managing data transfer from
                  memory to peripheral (input channel) and another channel for managing data
                  transfer from peripheral to memory (output channel)
              (+) Associate the initialized DMA handle to the CRYP DMA handle
                  using  __HAL_LINKDMA()
              (+) Configure the priority and enable the NVIC for the transfer complete
                  interrupt on the two DMA Streams. The output stream should have higher
                  priority than the input stream.
                  (++) HAL_NVIC_SetPriority()
                  (++) HAL_NVIC_EnableIRQ()
       (#)Initialize the CRYP HAL using HAL_CRYP_Init(). This function configures mainly:
          (##) The data type: 1-bit, 8-bit, 16-bit and 32-bit
          (##) The encryption/decryption key.
          (##) The initialization vector (counter). It is not used ECB mode.
       (#)Three processing (encryption/decryption) functions are available:
          (##) Polling mode: encryption and decryption APIs are blocking functions
               i.e. they process the data and wait till the processing is finished
               e.g. HAL_CRYP_AESCBC_Encrypt()
          (##) Interrupt mode: encryption and decryption APIs are not blocking functions
               i.e. they process the data under interrupt
               e.g. HAL_CRYP_AESCBC_Encrypt_IT()
          (##) DMA mode: encryption and decryption APIs are not blocking functions
               i.e. the data transfer is ensured by DMA
               e.g. HAL_CRYP_AESCBC_Encrypt_DMA()
       (#)When the processing function is called for the first time after HAL_CRYP_Init()
          the CRYP peripheral is initialized and processes the buffer in input.
          At second call, the processing function performs an append of the already
          processed buffer.
          When a new data block is to be processed, call HAL_CRYP_Init() then the
          processing function.
       (#)Call HAL_CRYP_DeInit() to deinitialize the CRYP peripheral.
   @endverbatim
   ******************************************************************************
   * @attention
   *
-  * <h2><center>&copy; Copyright (c) 2017 STMicroelectronics.
+  * Copyright (c) 2017 STMicroelectronics.
-  * All rights reserved.</center></h2>
+  * All rights reserved.
   *
-  * This software component is licensed by ST under BSD 3-Clause license,
+  * This software is licensed under terms that can be found in the LICENSE file
-  * the "License"; You may not use this file except in compliance with the
+  * in the root directory of this software component.
-  * License. You may obtain a copy of the License at:
+  * If no LICENSE file comes with this software, it is provided AS-IS.
-  *                        opensource.org/licenses/BSD-3-Clause
+  *
-  *
+  ******************************************************************************
-  ******************************************************************************
+  */
-  */
+/* Includes ------------------------------------------------------------------*/
-/* Includes ------------------------------------------------------------------*/
+#include "stm32l1xx_hal.h"
-#include "stm32l1xx_hal.h"
+#ifdef HAL_CRYP_MODULE_ENABLED
-#ifdef HAL_CRYP_MODULE_ENABLED
+/** @addtogroup STM32L1xx_HAL_Driver
-/** @addtogroup STM32L1xx_HAL_Driver
+  * @{
-  * @{
+  */
-  */
+/** @defgroup CRYP CRYP
-/** @defgroup CRYP CRYP
+  * @brief CRYP HAL module driver.
-  * @brief CRYP HAL module driver.
+  * @{
-  * @{
+  */
-  */
+#if defined(STM32L162xC) || defined(STM32L162xCA) || defined(STM32L162xD) || defined(STM32L162xE) || defined(STM32L162xDX)
-#if defined(STM32L162xC) || defined(STM32L162xCA) || defined(STM32L162xD) || defined(STM32L162xE) || defined(STM32L162xDX)
+/* Private typedef -----------------------------------------------------------*/
-/* Private typedef -----------------------------------------------------------*/
+/* Private define ------------------------------------------------------------*/
-/* Private define ------------------------------------------------------------*/
+/** @defgroup CRYP_Private_Defines CRYP Private Defines
-/** @defgroup CRYP_Private_Defines CRYP Private Defines
+  * @{
-  * @{
+  */
-  */
+#define  CRYP_ALGO_CHAIN_MASK         (AES_CR_MODE | AES_CR_CHMOD)
-#define  CRYP_ALGO_CHAIN_MASK         (AES_CR_MODE | AES_CR_CHMOD)
+/**
-/**
+  * @}
-  * @}
+  */
-  */
+/* Private macro -------------------------------------------------------------*/
-/* Private macro -------------------------------------------------------------*/
+/* Private variables ---------------------------------------------------------*/
-/* Private variables ---------------------------------------------------------*/
+/* Private function prototypes -----------------------------------------------*/
-/* Private function prototypes -----------------------------------------------*/
+/** @defgroup CRYP_Private_Functions CRYP Private Functions
-/** @defgroup CRYP_Private_Functions CRYP Private Functions
+  * @{
-  * @{
+  */
-  */
+static HAL_StatusTypeDef  CRYP_EncryptDecrypt_IT(CRYP_HandleTypeDef *hcryp);
-static HAL_StatusTypeDef  CRYP_EncryptDecrypt_IT(CRYP_HandleTypeDef *hcryp);
+static void               CRYP_SetInitVector(CRYP_HandleTypeDef *hcryp, uint8_t *InitVector);
-static void               CRYP_SetInitVector(CRYP_HandleTypeDef *hcryp, uint8_t *InitVector);
+static void               CRYP_SetKey(CRYP_HandleTypeDef *hcryp, uint8_t *Key);
-static void               CRYP_SetKey(CRYP_HandleTypeDef *hcryp, uint8_t *Key);
+static HAL_StatusTypeDef  CRYP_ProcessData(CRYP_HandleTypeDef *hcryp, uint8_t* Input, uint16_t Ilength, uint8_t* Output, uint32_t Timeout);
-static HAL_StatusTypeDef  CRYP_ProcessData(CRYP_HandleTypeDef *hcryp, uint8_t* Input, uint16_t Ilength, uint8_t* Output, uint32_t Timeout);
+static void               CRYP_DMAInCplt(DMA_HandleTypeDef *hdma);
-static void               CRYP_DMAInCplt(DMA_HandleTypeDef *hdma);
+static void               CRYP_DMAOutCplt(DMA_HandleTypeDef *hdma);
-static void               CRYP_DMAOutCplt(DMA_HandleTypeDef *hdma);
+static void               CRYP_DMAError(DMA_HandleTypeDef *hdma);
-static void               CRYP_DMAError(DMA_HandleTypeDef *hdma);
+static void               CRYP_SetDMAConfig(CRYP_HandleTypeDef *hcryp, uint32_t inputaddr, uint16_t Size, uint32_t outputaddr);
-static void               CRYP_SetDMAConfig(CRYP_HandleTypeDef *hcryp, uint32_t inputaddr, uint16_t Size, uint32_t outputaddr);
+/**
-/**
+  * @}
-  * @}
+  */
-  */
+/* Private functions ---------------------------------------------------------*/
-/* Private functions ---------------------------------------------------------*/
+/** @defgroup CRYP_Exported_Functions CRYP Exported Functions
-/** @defgroup CRYP_Exported_Functions CRYP Exported Functions
+  * @{
-  * @{
+  */
-  */
+/** @defgroup CRYP_Exported_Functions_Group1 Initialization and de-initialization functions
-/** @defgroup CRYP_Exported_Functions_Group1 Initialization and de-initialization functions
+ *  @brief    Initialization and Configuration functions.
- *  @brief    Initialization and Configuration functions.
+ *
- *
+@verbatim
-@verbatim
+  ==============================================================================
-  ==============================================================================
+              ##### Initialization and de-initialization functions #####
-              ##### Initialization and de-initialization functions #####
+  ==============================================================================
-  ==============================================================================
+    [..]  This section provides functions allowing to:
-    [..]  This section provides functions allowing to:
+      (+) Initialize the CRYP according to the specified parameters
-      (+) Initialize the CRYP according to the specified parameters
+          in the CRYP_InitTypeDef and creates the associated handle
-          in the CRYP_InitTypeDef and creates the associated handle
+      (+) DeInitialize the CRYP peripheral
-      (+) DeInitialize the CRYP peripheral
+      (+) Initialize the CRYP MSP
-      (+) Initialize the CRYP MSP
+      (+) DeInitialize CRYP MSP
-      (+) DeInitialize CRYP MSP
+@endverbatim
-@endverbatim
+  * @{
-  * @{
+  */
-  */
+/**
-/**
+  * @brief  Initializes the CRYP according to the specified
-  * @brief  Initializes the CRYP according to the specified
+  *         parameters in the CRYP_InitTypeDef and creates the associated handle.
-  *         parameters in the CRYP_InitTypeDef and creates the associated handle.
+  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
-  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
+  *         the configuration information for CRYP module
-  *         the configuration information for CRYP module
+  * @retval HAL status
-  * @retval HAL status
+  */
-  */
+HAL_StatusTypeDef HAL_CRYP_Init(CRYP_HandleTypeDef *hcryp)
-HAL_StatusTypeDef HAL_CRYP_Init(CRYP_HandleTypeDef *hcryp)
+{
-{
+  /* Check the CRYP handle allocation */
-  /* Check the CRYP handle allocation */
+  if(hcryp == NULL)
-  if(hcryp == NULL)
+  {
-  {
+    return HAL_ERROR;
-    return HAL_ERROR;
+  }
-  }
+  /* Check the parameters */
-  /* Check the parameters */
+  assert_param(IS_AES_ALL_INSTANCE(hcryp->Instance));
-  assert_param(IS_AES_ALL_INSTANCE(hcryp->Instance));
+  assert_param(IS_CRYP_DATATYPE(hcryp->Init.DataType));
-  assert_param(IS_CRYP_DATATYPE(hcryp->Init.DataType));
+  if(hcryp->State == HAL_CRYP_STATE_RESET)
-  if(hcryp->State == HAL_CRYP_STATE_RESET)
+  {
-  {
+    /* Allocate lock resource and initialize it */
-    /* Allocate lock resource and initialize it */
+    hcryp->Lock = HAL_UNLOCKED;
-    hcryp->Lock = HAL_UNLOCKED;
+    /* Init the low level hardware */
-    /* Init the low level hardware */
+    HAL_CRYP_MspInit(hcryp);
-    HAL_CRYP_MspInit(hcryp);
+  }
-  }
+  /* Check if AES already enabled */
-  /* Check if AES already enabled */
+  if (HAL_IS_BIT_CLR(hcryp->Instance->CR, AES_CR_EN))
-  if (HAL_IS_BIT_CLR(hcryp->Instance->CR, AES_CR_EN))
+  {
-  {
+    /* Change the CRYP state */
-    /* Change the CRYP state */
+    hcryp->State = HAL_CRYP_STATE_BUSY;
-    hcryp->State = HAL_CRYP_STATE_BUSY;
+    /* Set the data type*/
-    /* Set the data type*/
+    MODIFY_REG(hcryp->Instance->CR, AES_CR_DATATYPE, hcryp->Init.DataType);
-    MODIFY_REG(hcryp->Instance->CR, AES_CR_DATATYPE, hcryp->Init.DataType);
+    /* Reset CrypInCount and CrypOutCount */
-    /* Reset CrypInCount and CrypOutCount */
+    hcryp->CrypInCount = 0;
-    hcryp->CrypInCount = 0;
+    hcryp->CrypOutCount = 0;
-    hcryp->CrypOutCount = 0;
+    /* Change the CRYP state */
-    /* Change the CRYP state */
+    hcryp->State = HAL_CRYP_STATE_READY;
-    hcryp->State = HAL_CRYP_STATE_READY;
+    /* Set the default CRYP phase */
-    /* Set the default CRYP phase */
+    hcryp->Phase = HAL_CRYP_PHASE_READY;
-    hcryp->Phase = HAL_CRYP_PHASE_READY;
+    /* Return function status */
-    /* Return function status */
+    return HAL_OK;
-    return HAL_OK;
+  }
-  }
+  else
-  else
+  {
-  {
+    /* The Datatype selection must be changed if the AES is disabled. Writing these bits while the AES is */
-    /* The Datatype selection must be changed if the AES is disabled. Writing these bits while the AES is */
+    /* enabled is forbidden to avoid unpredictable AES behavior.*/
-    /* enabled is forbidden to avoid unpredictable AES behavior.*/
+    /* Return function status */
-    /* Return function status */
+    return HAL_ERROR;
-    return HAL_ERROR;
+  }
-  }
+}
-}
+/**
-/**
+  * @brief  DeInitializes the CRYP peripheral.
-  * @brief  DeInitializes the CRYP peripheral.
+  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
-  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
+  *         the configuration information for CRYP module
-  *         the configuration information for CRYP module
+  * @retval HAL status
-  * @retval HAL status
+  */
-  */
+HAL_StatusTypeDef HAL_CRYP_DeInit(CRYP_HandleTypeDef *hcryp)
-HAL_StatusTypeDef HAL_CRYP_DeInit(CRYP_HandleTypeDef *hcryp)
+{
-{
+  /* Check the CRYP handle allocation */
-  /* Check the CRYP handle allocation */
+  if(hcryp == NULL)
-  if(hcryp == NULL)
+  {
-  {
+    return HAL_ERROR;
-    return HAL_ERROR;
+  }
-  }
+  /* Change the CRYP state */
-  /* Change the CRYP state */
+  hcryp->State = HAL_CRYP_STATE_BUSY;
-  hcryp->State = HAL_CRYP_STATE_BUSY;
+  /* Set the default CRYP phase */
-  /* Set the default CRYP phase */
+  hcryp->Phase = HAL_CRYP_PHASE_READY;
-  hcryp->Phase = HAL_CRYP_PHASE_READY;
+  /* Reset CrypInCount and CrypOutCount */
-  /* Reset CrypInCount and CrypOutCount */
+  hcryp->CrypInCount = 0;
-  hcryp->CrypInCount = 0;
+  hcryp->CrypOutCount = 0;
-  hcryp->CrypOutCount = 0;
+  /* Disable the CRYP Peripheral Clock */
-  /* Disable the CRYP Peripheral Clock */
+  __HAL_CRYP_DISABLE(hcryp);
-  __HAL_CRYP_DISABLE(hcryp);
+  /* DeInit the low level hardware: CLOCK, NVIC.*/
-  /* DeInit the low level hardware: CLOCK, NVIC.*/
+  HAL_CRYP_MspDeInit(hcryp);
-  HAL_CRYP_MspDeInit(hcryp);
+  /* Change the CRYP state */
-  /* Change the CRYP state */
+  hcryp->State = HAL_CRYP_STATE_RESET;
-  hcryp->State = HAL_CRYP_STATE_RESET;
+  /* Release Lock */
-  /* Release Lock */
+  __HAL_UNLOCK(hcryp);
-  __HAL_UNLOCK(hcryp);
+  /* Return function status */
-  /* Return function status */
+  return HAL_OK;
-  return HAL_OK;
+}
-}
+/**
-/**
+  * @brief  Initializes the CRYP MSP.
-  * @brief  Initializes the CRYP MSP.
+  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
-  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
+  *         the configuration information for CRYP module
-  *         the configuration information for CRYP module
+  * @retval None
-  * @retval None
+  */
-  */
+__weak void HAL_CRYP_MspInit(CRYP_HandleTypeDef *hcryp)
-__weak void HAL_CRYP_MspInit(CRYP_HandleTypeDef *hcryp)
+{
-{
+  /* Prevent unused argument(s) compilation warning */
-  /* Prevent unused argument(s) compilation warning */
+  UNUSED(hcryp);
-  UNUSED(hcryp);
+  /* NOTE : This function should not be modified; when the callback is needed,
-  /* NOTE : This function should not be modified; when the callback is needed,
+            the HAL_CRYP_MspInit can be implemented in the user file */
-            the HAL_CRYP_MspInit can be implemented in the user file */
+}
-}
+/**
-/**
+  * @brief  DeInitializes CRYP MSP.
-  * @brief  DeInitializes CRYP MSP.
+  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
-  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
+  *         the configuration information for CRYP module
-  *         the configuration information for CRYP module
+  * @retval None
-  * @retval None
+  */
-  */
+__weak void HAL_CRYP_MspDeInit(CRYP_HandleTypeDef *hcryp)
-__weak void HAL_CRYP_MspDeInit(CRYP_HandleTypeDef *hcryp)
+{
-{
+  /* Prevent unused argument(s) compilation warning */
-  /* Prevent unused argument(s) compilation warning */
+  UNUSED(hcryp);
-  UNUSED(hcryp);
+  /* NOTE : This function should not be modified; when the callback is needed,
-  /* NOTE : This function should not be modified; when the callback is needed,
+            the HAL_CRYP_MspDeInit can be implemented in the user file */
-            the HAL_CRYP_MspDeInit can be implemented in the user file */
+}
-}
+/**
-/**
+  * @}
-  * @}
+  */
-  */
+/** @defgroup CRYP_Exported_Functions_Group2 AES processing functions
-/** @defgroup CRYP_Exported_Functions_Group2 AES processing functions
+ *  @brief   processing functions.
- *  @brief   processing functions.
+ *
- *
+@verbatim
-@verbatim
+  ==============================================================================
-  ==============================================================================
+                      ##### AES processing functions #####
-                      ##### AES processing functions #####
+  ==============================================================================
-  ==============================================================================
+    [..]  This section provides functions allowing to:
-    [..]  This section provides functions allowing to:
+      (+) Encrypt plaintext using AES algorithm in different chaining modes
-      (+) Encrypt plaintext using AES algorithm in different chaining modes
+      (+) Decrypt cyphertext using AES algorithm in different chaining modes
-      (+) Decrypt cyphertext using AES algorithm in different chaining modes
+    [..]  Three processing functions are available:
-    [..]  Three processing functions are available:
+      (+) Polling mode
-      (+) Polling mode
+      (+) Interrupt mode
-      (+) Interrupt mode
+      (+) DMA mode
-      (+) DMA mode
+@endverbatim
-@endverbatim
+  * @{
-  * @{
+  */
-  */
+/**
-/**
+  * @brief  Initializes the CRYP peripheral in AES ECB encryption mode
-  * @brief  Initializes the CRYP peripheral in AES ECB encryption mode
+  *         then encrypt pPlainData. The cypher data are available in pCypherData
-  *         then encrypt pPlainData. The cypher data are available in pCypherData
+  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
-  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
+  *         the configuration information for CRYP module
-  *         the configuration information for CRYP module
+  * @param  pPlainData Pointer to the plaintext buffer (aligned on u32)
-  * @param  pPlainData Pointer to the plaintext buffer (aligned on u32)
+  * @param  Size Length of the plaintext buffer, must be a multiple of 16.
-  * @param  Size Length of the plaintext buffer, must be a multiple of 16.
+  * @param  pCypherData Pointer to the cyphertext buffer (aligned on u32)
-  * @param  pCypherData Pointer to the cyphertext buffer (aligned on u32)
+  * @param  Timeout Specify Timeout value
-  * @param  Timeout Specify Timeout value
+  * @retval HAL status
-  * @retval HAL status
+  */
-  */
+HAL_StatusTypeDef HAL_CRYP_AESECB_Encrypt(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData, uint32_t Timeout)
-HAL_StatusTypeDef HAL_CRYP_AESECB_Encrypt(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData, uint32_t Timeout)
+{
-{
+  /* Process Locked */
-  /* Process Locked */
+  __HAL_LOCK(hcryp);
-  __HAL_LOCK(hcryp);
+  /* Check that data aligned on u32 and Size multiple of 16*/
-  /* Check that data aligned on u32 and Size multiple of 16*/
+  if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
-  if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
+  {
-  {
+    /* Process Locked */
-    /* Process Locked */
+    __HAL_UNLOCK(hcryp);
-    __HAL_UNLOCK(hcryp);
+    /* Return function status */
-    /* Return function status */
+    return HAL_ERROR;
-    return HAL_ERROR;
+  }
-  }
+  /* Check if HAL_CRYP_Init has been called */
-  /* Check if HAL_CRYP_Init has been called */
+  if(hcryp->State != HAL_CRYP_STATE_RESET)
-  if(hcryp->State != HAL_CRYP_STATE_RESET)
+  {
-  {
+    /* Change the CRYP state */
-    /* Change the CRYP state */
+    hcryp->State = HAL_CRYP_STATE_BUSY;
-    hcryp->State = HAL_CRYP_STATE_BUSY;
+    /* Check if initialization phase has already been performed */
-    /* Check if initialization phase has already been performed */
+    if(hcryp->Phase == HAL_CRYP_PHASE_READY)
-    if(hcryp->Phase == HAL_CRYP_PHASE_READY)
+    {
-    {
+      /* Set the key */
-      /* Set the key */
+      CRYP_SetKey(hcryp, hcryp->Init.pKey);
-      CRYP_SetKey(hcryp, hcryp->Init.pKey);
+      /* Reset the CHMOD & MODE bits */
-      /* Reset the CHMOD & MODE bits */
+      CLEAR_BIT(hcryp->Instance->CR, CRYP_ALGO_CHAIN_MASK);
-      CLEAR_BIT(hcryp->Instance->CR, CRYP_ALGO_CHAIN_MASK);
+      /* Set the CRYP peripheral in AES ECB mode */
-      /* Set the CRYP peripheral in AES ECB mode */
+      __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_ECB_ENCRYPT);
-      __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_ECB_ENCRYPT);
+      /* Enable CRYP */
-      /* Enable CRYP */
+      __HAL_CRYP_ENABLE(hcryp);
-      __HAL_CRYP_ENABLE(hcryp);
+      /* Set the phase */
-      /* Set the phase */
+      hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
-      hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
+    }
-    }
+    /* Write Plain Data and Get Cypher Data */
-    /* Write Plain Data and Get Cypher Data */
+    if(CRYP_ProcessData(hcryp, pPlainData, Size, pCypherData, Timeout) != HAL_OK)
-    if(CRYP_ProcessData(hcryp, pPlainData, Size, pCypherData, Timeout) != HAL_OK)
+    {
-    {
+      return HAL_TIMEOUT;
-      return HAL_TIMEOUT;
+    }
-    }
+    /* Change the CRYP state */
-    /* Change the CRYP state */
+    hcryp->State = HAL_CRYP_STATE_READY;
-    hcryp->State = HAL_CRYP_STATE_READY;
+    /* Process Unlocked */
-    /* Process Unlocked */
+    __HAL_UNLOCK(hcryp);
-    __HAL_UNLOCK(hcryp);
+    /* Return function status */
-    /* Return function status */
+    return HAL_OK;
-    return HAL_OK;
+  }
-  }
+  else
-  else
+  {
-  {
+    /* Process Locked */
-    /* Process Locked */
+    __HAL_UNLOCK(hcryp);
-    __HAL_UNLOCK(hcryp);
+    /* Return function status */
-    /* Return function status */
+    return HAL_ERROR;
-    return HAL_ERROR;
+  }
-  }
+}
-}
+/**
-/**
+  * @brief  Initializes the CRYP peripheral in AES CBC encryption mode
-  * @brief  Initializes the CRYP peripheral in AES CBC encryption mode
+  *         then encrypt pPlainData. The cypher data are available in pCypherData
-  *         then encrypt pPlainData. The cypher data are available in pCypherData
+  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
-  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
+  *         the configuration information for CRYP module
-  *         the configuration information for CRYP module
+  * @param  pPlainData Pointer to the plaintext buffer (aligned on u32)
-  * @param  pPlainData Pointer to the plaintext buffer (aligned on u32)
+  * @param  Size Length of the plaintext buffer, must be a multiple of 16.
-  * @param  Size Length of the plaintext buffer, must be a multiple of 16.
+  * @param  pCypherData Pointer to the cyphertext buffer (aligned on u32)
-  * @param  pCypherData Pointer to the cyphertext buffer (aligned on u32)
+  * @param  Timeout Specify Timeout value
-  * @param  Timeout Specify Timeout value
+  * @retval HAL status
-  * @retval HAL status
+  */
-  */
+HAL_StatusTypeDef HAL_CRYP_AESCBC_Encrypt(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData, uint32_t Timeout)
-HAL_StatusTypeDef HAL_CRYP_AESCBC_Encrypt(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData, uint32_t Timeout)
+{
-{
+  /* Process Locked */
-  /* Process Locked */
+  __HAL_LOCK(hcryp);
-  __HAL_LOCK(hcryp);
+  /* Check that data aligned on u32 */
-  /* Check that data aligned on u32 */
+  if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
-  if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
+  {
-  {
+    /* Process Locked */
-    /* Process Locked */
+    __HAL_UNLOCK(hcryp);
-    __HAL_UNLOCK(hcryp);
+    /* Return function status */
-    /* Return function status */
+    return HAL_ERROR;
-    return HAL_ERROR;
+  }
-  }
+  /* Check if HAL_CRYP_Init has been called */
-  /* Check if HAL_CRYP_Init has been called */
+  if(hcryp->State != HAL_CRYP_STATE_RESET)
-  if(hcryp->State != HAL_CRYP_STATE_RESET)
+  {
-  {
+    /* Change the CRYP state */
-    /* Change the CRYP state */
+    hcryp->State = HAL_CRYP_STATE_BUSY;
-    hcryp->State = HAL_CRYP_STATE_BUSY;
+    /* Check if initialization phase has already been performed */
-    /* Check if initialization phase has already been performed */
+    if(hcryp->Phase == HAL_CRYP_PHASE_READY)
-    if(hcryp->Phase == HAL_CRYP_PHASE_READY)
+    {
-    {
+      /* Set the key */
-      /* Set the key */
+      CRYP_SetKey(hcryp, hcryp->Init.pKey);
-      CRYP_SetKey(hcryp, hcryp->Init.pKey);
+      /* Reset the CHMOD & MODE bits */
-      /* Reset the CHMOD & MODE bits */
+      CLEAR_BIT(hcryp->Instance->CR, CRYP_ALGO_CHAIN_MASK);
-      CLEAR_BIT(hcryp->Instance->CR, CRYP_ALGO_CHAIN_MASK);
+      /* Set the CRYP peripheral in AES CBC mode */
-      /* Set the CRYP peripheral in AES CBC mode */
+      __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CBC_ENCRYPT);
-      __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CBC_ENCRYPT);
+      /* Set the Initialization Vector */
-      /* Set the Initialization Vector */
+      CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect);
-      CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect);
+      /* Enable CRYP */
-      /* Enable CRYP */
+      __HAL_CRYP_ENABLE(hcryp);
-      __HAL_CRYP_ENABLE(hcryp);
+      /* Set the phase */
-      /* Set the phase */
+      hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
-      hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
+    }
-    }
+    /* Write Plain Data and Get Cypher Data */
-    /* Write Plain Data and Get Cypher Data */
+    if(CRYP_ProcessData(hcryp, pPlainData, Size, pCypherData, Timeout) != HAL_OK)
-    if(CRYP_ProcessData(hcryp, pPlainData, Size, pCypherData, Timeout) != HAL_OK)
+    {
-    {
+      return HAL_TIMEOUT;
-      return HAL_TIMEOUT;
+    }
-    }
+    /* Change the CRYP state */
-    /* Change the CRYP state */
+    hcryp->State = HAL_CRYP_STATE_READY;
-    hcryp->State = HAL_CRYP_STATE_READY;
+    /* Process Unlocked */
-    /* Process Unlocked */
+    __HAL_UNLOCK(hcryp);
-    __HAL_UNLOCK(hcryp);
+    /* Return function status */
-    /* Return function status */
+    return HAL_OK;
-    return HAL_OK;
+  }
-  }
+  else
-  else
+  {
-  {
+    /* Process Locked */
-    /* Process Locked */
+    __HAL_UNLOCK(hcryp);
-    __HAL_UNLOCK(hcryp);
+    /* Return function status */
-    /* Return function status */
+    return HAL_ERROR;
-    return HAL_ERROR;
+  }
-  }
+}
-}
+/**
-/**
+  * @brief  Initializes the CRYP peripheral in AES CTR encryption mode
-  * @brief  Initializes the CRYP peripheral in AES CTR encryption mode
+  *         then encrypt pPlainData. The cypher data are available in pCypherData
-  *         then encrypt pPlainData. The cypher data are available in pCypherData
+  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
-  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
+  *         the configuration information for CRYP module
-  *         the configuration information for CRYP module
+  * @param  pPlainData Pointer to the plaintext buffer (aligned on u32)
-  * @param  pPlainData Pointer to the plaintext buffer (aligned on u32)
+  * @param  Size Length of the plaintext buffer, must be a multiple of 16.
-  * @param  Size Length of the plaintext buffer, must be a multiple of 16.
+  * @param  pCypherData Pointer to the cyphertext buffer (aligned on u32)
-  * @param  pCypherData Pointer to the cyphertext buffer (aligned on u32)
+  * @param  Timeout Specify Timeout value
-  * @param  Timeout Specify Timeout value
+  * @retval HAL status
-  * @retval HAL status
+  */
-  */
+HAL_StatusTypeDef HAL_CRYP_AESCTR_Encrypt(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData, uint32_t Timeout)
-HAL_StatusTypeDef HAL_CRYP_AESCTR_Encrypt(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData, uint32_t Timeout)
+{
-{
+  /* Process Locked */
-  /* Process Locked */
+  __HAL_LOCK(hcryp);
-  __HAL_LOCK(hcryp);
+  /* Check that data aligned on u32 */
-  /* Check that data aligned on u32 */
+  if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
-  if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
+  {
-  {
+    /* Process Locked */
-    /* Process Locked */
+    __HAL_UNLOCK(hcryp);
-    __HAL_UNLOCK(hcryp);
+    /* Return function status */
-    /* Return function status */
+    return HAL_ERROR;
-    return HAL_ERROR;
+  }
-  }
+  /* Check if HAL_CRYP_Init has been called */
-  /* Check if HAL_CRYP_Init has been called */
+  if(hcryp->State != HAL_CRYP_STATE_RESET)
-  if(hcryp->State != HAL_CRYP_STATE_RESET)
+  {
-  {
+    /* Change the CRYP state */
-    /* Change the CRYP state */
+    hcryp->State = HAL_CRYP_STATE_BUSY;
-    hcryp->State = HAL_CRYP_STATE_BUSY;
+    /* Check if initialization phase has already been performed */
-    /* Check if initialization phase has already been performed */
+    if(hcryp->Phase == HAL_CRYP_PHASE_READY)
-    if(hcryp->Phase == HAL_CRYP_PHASE_READY)
+    {
-    {
+      /* Set the key */
-      /* Set the key */
+      CRYP_SetKey(hcryp, hcryp->Init.pKey);
-      CRYP_SetKey(hcryp, hcryp->Init.pKey);
+      /* Reset the CHMOD & MODE bits */
-      /* Reset the CHMOD & MODE bits */
+      CLEAR_BIT(hcryp->Instance->CR, CRYP_ALGO_CHAIN_MASK);
-      CLEAR_BIT(hcryp->Instance->CR, CRYP_ALGO_CHAIN_MASK);
+      /* Set the CRYP peripheral in AES CTR mode */
-      /* Set the CRYP peripheral in AES CTR mode */
+      __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CTR_ENCRYPT);
-      __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CTR_ENCRYPT);
+      /* Set the Initialization Vector */
-      /* Set the Initialization Vector */
+      CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect);
-      CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect);
+      /* Enable CRYP */
-      /* Enable CRYP */
+      __HAL_CRYP_ENABLE(hcryp);
-      __HAL_CRYP_ENABLE(hcryp);
+      /* Set the phase */
-      /* Set the phase */
+      hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
-      hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
+    }
-    }
+    /* Write Plain Data and Get Cypher Data */
-    /* Write Plain Data and Get Cypher Data */
+    if(CRYP_ProcessData(hcryp, pPlainData, Size, pCypherData, Timeout) != HAL_OK)
-    if(CRYP_ProcessData(hcryp, pPlainData, Size, pCypherData, Timeout) != HAL_OK)
+    {
-    {
+      return HAL_TIMEOUT;
-      return HAL_TIMEOUT;
+    }
-    }
+    /* Change the CRYP state */
-    /* Change the CRYP state */
+    hcryp->State = HAL_CRYP_STATE_READY;
-    hcryp->State = HAL_CRYP_STATE_READY;
+    /* Process Unlocked */
-    /* Process Unlocked */
+    __HAL_UNLOCK(hcryp);
-    __HAL_UNLOCK(hcryp);
+    /* Return function status */
-    /* Return function status */
+    return HAL_OK;
-    return HAL_OK;
+  }
-  }
+  else
-  else
+  {
-  {
+    /* Release Lock */
-    /* Release Lock */
+    __HAL_UNLOCK(hcryp);
-    __HAL_UNLOCK(hcryp);
+    /* Return function status */
-    /* Return function status */
+    return HAL_ERROR;
-    return HAL_ERROR;
+  }
-  }
+}
-}
+/**
-/**
+  * @brief  Initializes the CRYP peripheral in AES ECB decryption mode
-  * @brief  Initializes the CRYP peripheral in AES ECB decryption mode
+  *         then decrypted pCypherData. The cypher data are available in pPlainData
-  *         then decrypted pCypherData. The cypher data are available in pPlainData
+  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
-  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
+  *         the configuration information for CRYP module
-  *         the configuration information for CRYP module
+  * @param  pCypherData Pointer to the cyphertext buffer (aligned on u32)
-  * @param  pCypherData Pointer to the cyphertext buffer (aligned on u32)
+  * @param  Size Length of the plaintext buffer, must be a multiple of 16.
-  * @param  Size Length of the plaintext buffer, must be a multiple of 16.
+  * @param  pPlainData Pointer to the plaintext buffer (aligned on u32)
-  * @param  pPlainData Pointer to the plaintext buffer (aligned on u32)
+  * @param  Timeout Specify Timeout value
-  * @param  Timeout Specify Timeout value
+  * @retval HAL status
-  * @retval HAL status
+  */
-  */
+HAL_StatusTypeDef HAL_CRYP_AESECB_Decrypt(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData, uint32_t Timeout)
-HAL_StatusTypeDef HAL_CRYP_AESECB_Decrypt(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData, uint32_t Timeout)
+{
-{
+  /* Process Locked */
-  /* Process Locked */
+  __HAL_LOCK(hcryp);
-  __HAL_LOCK(hcryp);
+  /* Check that data aligned on u32 */
-  /* Check that data aligned on u32 */
+  if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
-  if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
+  {
-  {
+    /* Process Locked */
-    /* Process Locked */
+    __HAL_UNLOCK(hcryp);
-    __HAL_UNLOCK(hcryp);
+    /* Return function status */
-    /* Return function status */
+    return HAL_ERROR;
-    return HAL_ERROR;
+  }
-  }
+  /* Check if HAL_CRYP_Init has been called */
-  /* Check if HAL_CRYP_Init has been called */
+  if(hcryp->State != HAL_CRYP_STATE_RESET)
-  if(hcryp->State != HAL_CRYP_STATE_RESET)
+  {
-  {
+    /* Change the CRYP state */
-    /* Change the CRYP state */
+    hcryp->State = HAL_CRYP_STATE_BUSY;
-    hcryp->State = HAL_CRYP_STATE_BUSY;
+    /* Check if initialization phase has already been performed */
-    /* Check if initialization phase has already been performed */
+    if(hcryp->Phase == HAL_CRYP_PHASE_READY)
-    if(hcryp->Phase == HAL_CRYP_PHASE_READY)
+    {
-    {
+      /* Set the key */
-      /* Set the key */
+      CRYP_SetKey(hcryp, hcryp->Init.pKey);
-      CRYP_SetKey(hcryp, hcryp->Init.pKey);
+      /* Reset the CHMOD & MODE bits */
-      /* Reset the CHMOD & MODE bits */
+      CLEAR_BIT(hcryp->Instance->CR, CRYP_ALGO_CHAIN_MASK);
-      CLEAR_BIT(hcryp->Instance->CR, CRYP_ALGO_CHAIN_MASK);
+      /* Set the CRYP peripheral in AES ECB decryption mode (with key derivation) */
-      /* Set the CRYP peripheral in AES ECB decryption mode (with key derivation) */
+      __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_ECB_KEYDERDECRYPT);
-      __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_ECB_KEYDERDECRYPT);
+      /* Enable CRYP */
-      /* Enable CRYP */
+      __HAL_CRYP_ENABLE(hcryp);
-      __HAL_CRYP_ENABLE(hcryp);
+      /* Set the phase */
-      /* Set the phase */
+      hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
-      hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
+    }
-    }
+    /* Write Cypher Data and Get Plain Data */
-    /* Write Cypher Data and Get Plain Data */
+    if(CRYP_ProcessData(hcryp, pCypherData, Size, pPlainData, Timeout) != HAL_OK)
-    if(CRYP_ProcessData(hcryp, pCypherData, Size, pPlainData, Timeout) != HAL_OK)
+    {
-    {
+      return HAL_TIMEOUT;
-      return HAL_TIMEOUT;
+    }
-    }
+    /* Change the CRYP state */
-    /* Change the CRYP state */
+    hcryp->State = HAL_CRYP_STATE_READY;
-    hcryp->State = HAL_CRYP_STATE_READY;
+    /* Process Unlocked */
-    /* Process Unlocked */
+    __HAL_UNLOCK(hcryp);
-    __HAL_UNLOCK(hcryp);
+    /* Return function status */
-    /* Return function status */
+    return HAL_OK;
-    return HAL_OK;
+  }
-  }
+  else
-  else
+  {
-  {
+    /* Release Lock */
-    /* Release Lock */
+    __HAL_UNLOCK(hcryp);
-    __HAL_UNLOCK(hcryp);
+    /* Return function status */
-    /* Return function status */
+    return HAL_ERROR;
-    return HAL_ERROR;
+  }
-  }
+}
-}
+/**
-/**
+  * @brief  Initializes the CRYP peripheral in AES ECB decryption mode
-  * @brief  Initializes the CRYP peripheral in AES ECB decryption mode
+  *         then decrypted pCypherData. The cypher data are available in pPlainData
-  *         then decrypted pCypherData. The cypher data are available in pPlainData
+  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
-  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
+  *         the configuration information for CRYP module
-  *         the configuration information for CRYP module
+  * @param  pCypherData Pointer to the cyphertext buffer (aligned on u32)
-  * @param  pCypherData Pointer to the cyphertext buffer (aligned on u32)
+  * @param  Size Length of the plaintext buffer, must be a multiple of 16.
-  * @param  Size Length of the plaintext buffer, must be a multiple of 16.
+  * @param  pPlainData Pointer to the plaintext buffer (aligned on u32)
-  * @param  pPlainData Pointer to the plaintext buffer (aligned on u32)
+  * @param  Timeout Specify Timeout value
-  * @param  Timeout Specify Timeout value
+  * @retval HAL status
-  * @retval HAL status
+  */
-  */
+HAL_StatusTypeDef HAL_CRYP_AESCBC_Decrypt(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData, uint32_t Timeout)
-HAL_StatusTypeDef HAL_CRYP_AESCBC_Decrypt(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData, uint32_t Timeout)
+{
-{
+  /* Process Locked */
-  /* Process Locked */
+  __HAL_LOCK(hcryp);
-  __HAL_LOCK(hcryp);
+  /* Check that data aligned on u32 */
-  /* Check that data aligned on u32 */
+  if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
-  if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
+  {
-  {
+    /* Process Locked */
-    /* Process Locked */
+    __HAL_UNLOCK(hcryp);
-    __HAL_UNLOCK(hcryp);
+    /* Return function status */
-    /* Return function status */
+    return HAL_ERROR;
-    return HAL_ERROR;
+  }
-  }
+  /* Check if HAL_CRYP_Init has been called */
-  /* Check if HAL_CRYP_Init has been called */
+  if(hcryp->State != HAL_CRYP_STATE_RESET)
-  if(hcryp->State != HAL_CRYP_STATE_RESET)
+  {
-  {
+    /* Change the CRYP state */
-    /* Change the CRYP state */
+    hcryp->State = HAL_CRYP_STATE_BUSY;
-    hcryp->State = HAL_CRYP_STATE_BUSY;
+    /* Check if initialization phase has already been performed */
-    /* Check if initialization phase has already been performed */
+    if(hcryp->Phase == HAL_CRYP_PHASE_READY)
-    if(hcryp->Phase == HAL_CRYP_PHASE_READY)
+    {
-    {
+      /* Set the key */
-      /* Set the key */
+      CRYP_SetKey(hcryp, hcryp->Init.pKey);
-      CRYP_SetKey(hcryp, hcryp->Init.pKey);
+      /* Reset the CHMOD & MODE bits */
-      /* Reset the CHMOD & MODE bits */
+      CLEAR_BIT(hcryp->Instance->CR, CRYP_ALGO_CHAIN_MASK);
-      CLEAR_BIT(hcryp->Instance->CR, CRYP_ALGO_CHAIN_MASK);
+      /* Set the CRYP peripheral in AES CBC decryption mode (with key derivation) */
-      /* Set the CRYP peripheral in AES CBC decryption mode (with key derivation) */
+      __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CBC_KEYDERDECRYPT);
-      __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CBC_KEYDERDECRYPT);
+      /* Set the Initialization Vector */
-      /* Set the Initialization Vector */
+      CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect);
-      CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect);
+      /* Enable CRYP */
-      /* Enable CRYP */
+      __HAL_CRYP_ENABLE(hcryp);
-      __HAL_CRYP_ENABLE(hcryp);
+      /* Set the phase */
-      /* Set the phase */
+      hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
-      hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
+    }
-    }
+    /* Write Cypher Data and Get Plain Data */
-    /* Write Cypher Data and Get Plain Data */
+    if(CRYP_ProcessData(hcryp, pCypherData, Size, pPlainData, Timeout) != HAL_OK)
-    if(CRYP_ProcessData(hcryp, pCypherData, Size, pPlainData, Timeout) != HAL_OK)
+    {
-    {
+      return HAL_TIMEOUT;
-      return HAL_TIMEOUT;
+    }
-    }
+    /* Change the CRYP state */
-    /* Change the CRYP state */
+    hcryp->State = HAL_CRYP_STATE_READY;
-    hcryp->State = HAL_CRYP_STATE_READY;
+    /* Process Unlocked */
-    /* Process Unlocked */
+    __HAL_UNLOCK(hcryp);
-    __HAL_UNLOCK(hcryp);
+    /* Return function status */
-    /* Return function status */
+    return HAL_OK;
-    return HAL_OK;
+  }
-  }
+  else
-  else
+  {
-  {
+    /* Release Lock */
-    /* Release Lock */
+    __HAL_UNLOCK(hcryp);
-    __HAL_UNLOCK(hcryp);
+    /* Return function status */
-    /* Return function status */
+    return HAL_ERROR;
-    return HAL_ERROR;
+  }
-  }
+}
-}
+/**
-/**
+  * @brief  Initializes the CRYP peripheral in AES CTR decryption mode
-  * @brief  Initializes the CRYP peripheral in AES CTR decryption mode
+  *         then decrypted pCypherData. The cypher data are available in pPlainData
-  *         then decrypted pCypherData. The cypher data are available in pPlainData
+  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
-  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
+  *         the configuration information for CRYP module
-  *         the configuration information for CRYP module
+  * @param  pCypherData Pointer to the cyphertext buffer (aligned on u32)
-  * @param  pCypherData Pointer to the cyphertext buffer (aligned on u32)
+  * @param  Size Length of the plaintext buffer, must be a multiple of 16.
-  * @param  Size Length of the plaintext buffer, must be a multiple of 16.
+  * @param  pPlainData Pointer to the plaintext buffer (aligned on u32)
-  * @param  pPlainData Pointer to the plaintext buffer (aligned on u32)
+  * @param  Timeout Specify Timeout value
-  * @param  Timeout Specify Timeout value
+  * @retval HAL status
-  * @retval HAL status
+  */
-  */
+HAL_StatusTypeDef HAL_CRYP_AESCTR_Decrypt(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData, uint32_t Timeout)
-HAL_StatusTypeDef HAL_CRYP_AESCTR_Decrypt(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData, uint32_t Timeout)
+{
-{
+  /* Process Locked */
-  /* Process Locked */
+  __HAL_LOCK(hcryp);
-  __HAL_LOCK(hcryp);
+  /* Check that data aligned on u32 */
-  /* Check that data aligned on u32 */
+  if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
-  if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
+  {
-  {
+    /* Process Locked */
-    /* Process Locked */
+    __HAL_UNLOCK(hcryp);
-    __HAL_UNLOCK(hcryp);
+    /* Return function status */
-    /* Return function status */
+    return HAL_ERROR;
-    return HAL_ERROR;
+  }
-  }
+  /* Check if initialization phase has already been performed */
-  /* Check if initialization phase has already been performed */
+  if ((hcryp->State != HAL_CRYP_STATE_RESET) && (hcryp->Phase == HAL_CRYP_PHASE_READY))
-  if ((hcryp->State != HAL_CRYP_STATE_RESET) && (hcryp->Phase == HAL_CRYP_PHASE_READY))
+  {
-  {
+    /* Change the CRYP state */
-    /* Change the CRYP state */
+    hcryp->State = HAL_CRYP_STATE_BUSY;
-    hcryp->State = HAL_CRYP_STATE_BUSY;
+    /* Set the key */
-    /* Set the key */
+    CRYP_SetKey(hcryp, hcryp->Init.pKey);
-    CRYP_SetKey(hcryp, hcryp->Init.pKey);
+    /* Reset the CHMOD & MODE bits */
-    /* Reset the CHMOD & MODE bits */
+    CLEAR_BIT(hcryp->Instance->CR, CRYP_ALGO_CHAIN_MASK);
-    CLEAR_BIT(hcryp->Instance->CR, CRYP_ALGO_CHAIN_MASK);
+    /* Set the CRYP peripheral in AES CTR decryption mode */
-    /* Set the CRYP peripheral in AES CTR decryption mode */
+    __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CTR_DECRYPT);
-    __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CTR_DECRYPT);
+    /* Set the Initialization Vector */
-    /* Set the Initialization Vector */
+    CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect);
-    CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect);
+    /* Enable CRYP */
-    /* Enable CRYP */
+    __HAL_CRYP_ENABLE(hcryp);
-    __HAL_CRYP_ENABLE(hcryp);
+    /* Set the phase */
-    /* Set the phase */
+    hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
-    hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
+  }
-  }
+  /* Write Cypher Data and Get Plain Data */
-  /* Write Cypher Data and Get Plain Data */
+  if(CRYP_ProcessData(hcryp, pCypherData, Size, pPlainData, Timeout) != HAL_OK)
-  if(CRYP_ProcessData(hcryp, pCypherData, Size, pPlainData, Timeout) != HAL_OK)
+  {
-  {
+    return HAL_TIMEOUT;
-    return HAL_TIMEOUT;
+  }
-  }
+  /* Change the CRYP state */
-  /* Change the CRYP state */
+  hcryp->State = HAL_CRYP_STATE_READY;
-  hcryp->State = HAL_CRYP_STATE_READY;
+  /* Process Unlocked */
-  /* Process Unlocked */
+  __HAL_UNLOCK(hcryp);
-  __HAL_UNLOCK(hcryp);
+  /* Return function status */
-  /* Return function status */
+  return HAL_OK;
-  return HAL_OK;
+}
-}
+/**
-/**
+  * @brief  Initializes the CRYP peripheral in AES ECB encryption mode using Interrupt.
-  * @brief  Initializes the CRYP peripheral in AES ECB encryption mode using Interrupt.
+  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
-  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
+  *         the configuration information for CRYP module
-  *         the configuration information for CRYP module
+  * @param  pPlainData Pointer to the plaintext buffer (aligned on u32)
-  * @param  pPlainData Pointer to the plaintext buffer (aligned on u32)
+  * @param  Size Length of the plaintext buffer, must be a multiple of 16 bytes
-  * @param  Size Length of the plaintext buffer, must be a multiple of 16 bytes
+  * @param  pCypherData Pointer to the cyphertext buffer (aligned on u32)
-  * @param  pCypherData Pointer to the cyphertext buffer (aligned on u32)
+  * @retval HAL status
-  * @retval HAL status
+  */
-  */
+HAL_StatusTypeDef HAL_CRYP_AESECB_Encrypt_IT(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData)
-HAL_StatusTypeDef HAL_CRYP_AESECB_Encrypt_IT(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData)
+{
-{
+  uint32_t inputaddr = 0;
-  uint32_t inputaddr = 0;
+  /* Check that data aligned on u32 */
-  /* Check that data aligned on u32 */
+  if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
-  if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
+  {
-  {
+    /* Process Locked */
-    /* Process Locked */
+    __HAL_UNLOCK(hcryp);
-    __HAL_UNLOCK(hcryp);
+    /* Return function status */
-    /* Return function status */
+    return HAL_ERROR;
-    return HAL_ERROR;
+  }
-  }
+  if ((hcryp->State != HAL_CRYP_STATE_RESET) && (hcryp->State == HAL_CRYP_STATE_READY))
-  if ((hcryp->State != HAL_CRYP_STATE_RESET) && (hcryp->State == HAL_CRYP_STATE_READY))
+  {
-  {
+    /* Process Locked */
-    /* Process Locked */
+    __HAL_LOCK(hcryp);
-    __HAL_LOCK(hcryp);
+    /* Get the buffer addresses and sizes */
-    /* Get the buffer addresses and sizes */
+    hcryp->CrypInCount = Size;
-    hcryp->CrypInCount = Size;
+    hcryp->pCrypInBuffPtr = pPlainData;
-    hcryp->pCrypInBuffPtr = pPlainData;
+    hcryp->pCrypOutBuffPtr = pCypherData;
-    hcryp->pCrypOutBuffPtr = pCypherData;
+    hcryp->CrypOutCount = Size;
-    hcryp->CrypOutCount = Size;
+    /* Change the CRYP state */
-    /* Change the CRYP state */
+    hcryp->State = HAL_CRYP_STATE_BUSY;
-    hcryp->State = HAL_CRYP_STATE_BUSY;
+    /* Check if initialization phase has already been performed */
-    /* Check if initialization phase has already been performed */
+    if(hcryp->Phase == HAL_CRYP_PHASE_READY)
-    if(hcryp->Phase == HAL_CRYP_PHASE_READY)
+    {
-    {
+      /* Set the key */
-      /* Set the key */
+      CRYP_SetKey(hcryp, hcryp->Init.pKey);
-      CRYP_SetKey(hcryp, hcryp->Init.pKey);
+      /* Reset the CHMOD & MODE bits */
-      /* Reset the CHMOD & MODE bits */
+      CLEAR_BIT(hcryp->Instance->CR, CRYP_ALGO_CHAIN_MASK);
-      CLEAR_BIT(hcryp->Instance->CR, CRYP_ALGO_CHAIN_MASK);
+      /* Set the CRYP peripheral in AES ECB mode */
-      /* Set the CRYP peripheral in AES ECB mode */
+      __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_ECB_ENCRYPT);
-      __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_ECB_ENCRYPT);
+      /* Set the phase */
-      /* Set the phase */
+      hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
-      hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
+    }
-    }
+    /* Enable Interrupts */
-    /* Enable Interrupts */
+    __HAL_CRYP_ENABLE_IT(hcryp, CRYP_IT_CC);
-    __HAL_CRYP_ENABLE_IT(hcryp, CRYP_IT_CC);
+    /* Enable CRYP */
-    /* Enable CRYP */
+    __HAL_CRYP_ENABLE(hcryp);
-    __HAL_CRYP_ENABLE(hcryp);
+    /* Get the last input data address */
-    /* Get the last input data adress */
+    inputaddr = (uint32_t)hcryp->pCrypInBuffPtr;
-    inputaddr = (uint32_t)hcryp->pCrypInBuffPtr;
+    /* Increment the pointer before writing the input block in the IN FIFO to make sure that
-    /* Write the Input block in the Data Input register */
+       when Computation Completed IRQ fires, the hcryp->CrypInCount has always a consistent value
-    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
+       and it is ready for the next operation. */
-    inputaddr+=4;
+    hcryp->pCrypInBuffPtr += 16U;
-    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
+    hcryp->CrypInCount -= 16U;
-    inputaddr+=4;
-    hcryp->Instance->DINR  = *(uint32_t*)(inputaddr);
+    /* Write the Input block in the Data Input register */
-    inputaddr+=4;
+    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
-    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
+    inputaddr+=4;
-    hcryp->pCrypInBuffPtr += 16;
+    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
-    hcryp->CrypInCount -= 16;
+    inputaddr+=4;
+    hcryp->Instance->DINR  = *(uint32_t*)(inputaddr);
-    /* Return function status */
+    inputaddr+=4;
-    return HAL_OK;
+    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
-  }
-  else
+    /* Return function status */
-  {
+    return HAL_OK;
-    /* Release Lock */
+  }
-    __HAL_UNLOCK(hcryp);
+  else
+  {
-    /* Return function status */
+    /* Release Lock */
-    return HAL_ERROR;
+    __HAL_UNLOCK(hcryp);
-  }
-}
+    /* Return function status */
+    return HAL_ERROR;
-/**
+  }
-  * @brief  Initializes the CRYP peripheral in AES CBC encryption mode using Interrupt.
+}
-  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
-  *         the configuration information for CRYP module
+/**
-  * @param  pPlainData Pointer to the plaintext buffer (aligned on u32)
+  * @brief  Initializes the CRYP peripheral in AES CBC encryption mode using Interrupt.
-  * @param  Size Length of the plaintext buffer, must be a multiple of 16 bytes
+  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
-  * @param  pCypherData Pointer to the cyphertext buffer (aligned on u32)
+  *         the configuration information for CRYP module
-  * @retval HAL status
+  * @param  pPlainData Pointer to the plaintext buffer (aligned on u32)
-  */
+  * @param  Size Length of the plaintext buffer, must be a multiple of 16 bytes
-HAL_StatusTypeDef HAL_CRYP_AESCBC_Encrypt_IT(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData)
+  * @param  pCypherData Pointer to the cyphertext buffer (aligned on u32)
-{
+  * @retval HAL status
-  uint32_t inputaddr = 0;
+  */
+HAL_StatusTypeDef HAL_CRYP_AESCBC_Encrypt_IT(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData)
-  /* Check that data aligned on u32 */
+{
-  if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
+  uint32_t inputaddr = 0;
-  {
-    /* Process Locked */
+  /* Check that data aligned on u32 */
-    __HAL_UNLOCK(hcryp);
+  if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
+  {
-    /* Return function status */
+    /* Process Locked */
-    return HAL_ERROR;
+    __HAL_UNLOCK(hcryp);
-  }
+    /* Return function status */
-  if ((hcryp->State != HAL_CRYP_STATE_RESET) && (hcryp->State == HAL_CRYP_STATE_READY))
+    return HAL_ERROR;
-  {
+  }
-    /* Process Locked */
-    __HAL_LOCK(hcryp);
+  if ((hcryp->State != HAL_CRYP_STATE_RESET) && (hcryp->State == HAL_CRYP_STATE_READY))
+  {
-    /* Get the buffer addresses and sizes */
+    /* Process Locked */
-    hcryp->CrypInCount = Size;
+    __HAL_LOCK(hcryp);
-    hcryp->pCrypInBuffPtr = pPlainData;
-    hcryp->pCrypOutBuffPtr = pCypherData;
+    /* Get the buffer addresses and sizes */
-    hcryp->CrypOutCount = Size;
+    hcryp->CrypInCount = Size;
+    hcryp->pCrypInBuffPtr = pPlainData;
-    /* Change the CRYP state */
+    hcryp->pCrypOutBuffPtr = pCypherData;
-    hcryp->State = HAL_CRYP_STATE_BUSY;
+    hcryp->CrypOutCount = Size;
-    /* Check if initialization phase has already been performed */
+    /* Change the CRYP state */
-    if(hcryp->Phase == HAL_CRYP_PHASE_READY)
+    hcryp->State = HAL_CRYP_STATE_BUSY;
-    {
-      /* Set the key */
+    /* Check if initialization phase has already been performed */
-      CRYP_SetKey(hcryp, hcryp->Init.pKey);
+    if(hcryp->Phase == HAL_CRYP_PHASE_READY)
+    {
-      /* Reset the CHMOD & MODE bits */
+      /* Set the key */
-      CLEAR_BIT(hcryp->Instance->CR, CRYP_ALGO_CHAIN_MASK);
+      CRYP_SetKey(hcryp, hcryp->Init.pKey);
-      /* Set the CRYP peripheral in AES CBC mode */
+      /* Reset the CHMOD & MODE bits */
-      __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CBC_ENCRYPT);
+      CLEAR_BIT(hcryp->Instance->CR, CRYP_ALGO_CHAIN_MASK);
-      /* Set the Initialization Vector */
+      /* Set the CRYP peripheral in AES CBC mode */
-      CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect);
+      __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CBC_ENCRYPT);
-      /* Set the phase */
+      /* Set the Initialization Vector */
-      hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
+      CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect);
-    }
+      /* Set the phase */
-    /* Enable Interrupts */
+      hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
-    __HAL_CRYP_ENABLE_IT(hcryp, CRYP_IT_CC);
+    }
-    /* Enable CRYP */
+    /* Enable Interrupts */
-    __HAL_CRYP_ENABLE(hcryp);
+    __HAL_CRYP_ENABLE_IT(hcryp, CRYP_IT_CC);
-    /* Get the last input data adress */
+    /* Enable CRYP */
-    inputaddr = (uint32_t)hcryp->pCrypInBuffPtr;
+    __HAL_CRYP_ENABLE(hcryp);
-    /* Write the Input block in the Data Input register */
+    /* Get the last input data address */
-    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
+    inputaddr = (uint32_t)hcryp->pCrypInBuffPtr;
-    inputaddr+=4;
-    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
+    /* Increment the pointer before writing the input block in the IN FIFO to make sure that
-    inputaddr+=4;
+       when Computation Completed IRQ fires, the hcryp->CrypInCount has always a consistent value
-    hcryp->Instance->DINR  = *(uint32_t*)(inputaddr);
+       and it is ready for the next operation. */
-    inputaddr+=4;
+    hcryp->pCrypInBuffPtr += 16U;
-    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
+    hcryp->CrypInCount -= 16U;
-    hcryp->pCrypInBuffPtr += 16;
-    hcryp->CrypInCount -= 16;
+    /* Write the Input block in the Data Input register */
+    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
-    /* Return function status */
+    inputaddr+=4;
-    return HAL_OK;
+    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
-  }
+    inputaddr+=4;
-  else
+    hcryp->Instance->DINR  = *(uint32_t*)(inputaddr);
-  {
+    inputaddr+=4;
-    /* Release Lock */
+    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
-    __HAL_UNLOCK(hcryp);
+    /* Return function status */
-    /* Return function status */
+    return HAL_OK;
-    return HAL_ERROR;
+  }
-  }
+  else
-}
+  {
+    /* Release Lock */
-/**
+    __HAL_UNLOCK(hcryp);
-  * @brief  Initializes the CRYP peripheral in AES CTR encryption mode using Interrupt.
-  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
+    /* Return function status */
-  *         the configuration information for CRYP module
+    return HAL_ERROR;
-  * @param  pPlainData Pointer to the plaintext buffer (aligned on u32)
+  }
-  * @param  Size Length of the plaintext buffer, must be a multiple of 16 bytes
+}
-  * @param  pCypherData Pointer to the cyphertext buffer (aligned on u32)
-  * @retval HAL status
+/**
-  */
+  * @brief  Initializes the CRYP peripheral in AES CTR encryption mode using Interrupt.
-HAL_StatusTypeDef HAL_CRYP_AESCTR_Encrypt_IT(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData)
+  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
-{
+  *         the configuration information for CRYP module
-  uint32_t inputaddr = 0;
+  * @param  pPlainData Pointer to the plaintext buffer (aligned on u32)
+  * @param  Size Length of the plaintext buffer, must be a multiple of 16 bytes
-  /* Check that data aligned on u32 */
+  * @param  pCypherData Pointer to the cyphertext buffer (aligned on u32)
-  if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
+  * @retval HAL status
-  {
+  */
-    /* Process Locked */
+HAL_StatusTypeDef HAL_CRYP_AESCTR_Encrypt_IT(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData)
-    __HAL_UNLOCK(hcryp);
+{
+  uint32_t inputaddr = 0;
-    /* Return function status */
-    return HAL_ERROR;
+  /* Check that data aligned on u32 */
-  }
+  if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
+  {
-  if ((hcryp->State != HAL_CRYP_STATE_RESET) && (hcryp->State == HAL_CRYP_STATE_READY))
+    /* Process Locked */
-  {
+    __HAL_UNLOCK(hcryp);
-    /* Process Locked */
-    __HAL_LOCK(hcryp);
+    /* Return function status */
+    return HAL_ERROR;
-    /* Get the buffer addresses and sizes */
+  }
-    hcryp->CrypInCount = Size;
-    hcryp->pCrypInBuffPtr = pPlainData;
+  if ((hcryp->State != HAL_CRYP_STATE_RESET) && (hcryp->State == HAL_CRYP_STATE_READY))
-    hcryp->pCrypOutBuffPtr = pCypherData;
+  {
-    hcryp->CrypOutCount = Size;
+    /* Process Locked */
+    __HAL_LOCK(hcryp);
-    /* Change the CRYP state */
-    hcryp->State = HAL_CRYP_STATE_BUSY;
+    /* Get the buffer addresses and sizes */
+    hcryp->CrypInCount = Size;
-    /* Check if initialization phase has already been performed */
+    hcryp->pCrypInBuffPtr = pPlainData;
-    if(hcryp->Phase == HAL_CRYP_PHASE_READY)
+    hcryp->pCrypOutBuffPtr = pCypherData;
-    {
+    hcryp->CrypOutCount = Size;
-      /* Set the key */
-      CRYP_SetKey(hcryp, hcryp->Init.pKey);
+    /* Change the CRYP state */
+    hcryp->State = HAL_CRYP_STATE_BUSY;
-      /* Reset the CHMOD & MODE bits */
-      CLEAR_BIT(hcryp->Instance->CR, CRYP_ALGO_CHAIN_MASK);
+    /* Check if initialization phase has already been performed */
+    if(hcryp->Phase == HAL_CRYP_PHASE_READY)
-      /* Set the CRYP peripheral in AES CTR mode */
+    {
-      __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CTR_ENCRYPT);
+      /* Set the key */
+      CRYP_SetKey(hcryp, hcryp->Init.pKey);
-      /* Set the Initialization Vector */
-      CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect);
+      /* Reset the CHMOD & MODE bits */
+      CLEAR_BIT(hcryp->Instance->CR, CRYP_ALGO_CHAIN_MASK);
-      /* Set the phase */
-      hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
+      /* Set the CRYP peripheral in AES CTR mode */
-    }
+      __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CTR_ENCRYPT);
-    /* Enable Interrupts */
+      /* Set the Initialization Vector */
-    __HAL_CRYP_ENABLE_IT(hcryp, CRYP_IT_CC);
+      CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect);
-    /* Enable CRYP */
+      /* Set the phase */
-    __HAL_CRYP_ENABLE(hcryp);
+      hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
+    }
-    /* Get the last input data adress */
-    inputaddr = (uint32_t)hcryp->pCrypInBuffPtr;
+    /* Enable Interrupts */
+    __HAL_CRYP_ENABLE_IT(hcryp, CRYP_IT_CC);
-    /* Write the Input block in the Data Input register */
-    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
+    /* Enable CRYP */
-    inputaddr+=4;
+    __HAL_CRYP_ENABLE(hcryp);
-    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
-    inputaddr+=4;
+    /* Get the last input data address */
-    hcryp->Instance->DINR  = *(uint32_t*)(inputaddr);
+    inputaddr = (uint32_t)hcryp->pCrypInBuffPtr;
-    inputaddr+=4;
-    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
+    /* Increment the pointer before writing the input block in the IN FIFO to make sure that
-    hcryp->pCrypInBuffPtr += 16;
+       when Computation Completed IRQ fires, the hcryp->CrypInCount has always a consistent value
-    hcryp->CrypInCount -= 16;
+       and it is ready for the next operation. */
+    hcryp->pCrypInBuffPtr += 16U;
-    /* Return function status */
+    hcryp->CrypInCount -= 16U;
-    return HAL_OK;
-  }
+    /* Write the Input block in the Data Input register */
-  else
+    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
-  {
+    inputaddr+=4;
-    /* Release Lock */
+    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
-    __HAL_UNLOCK(hcryp);
+    inputaddr+=4;
+    hcryp->Instance->DINR  = *(uint32_t*)(inputaddr);
-    /* Return function status */
+    inputaddr+=4;
-    return HAL_ERROR;
+    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
-  }
-}
+    /* Return function status */
+    return HAL_OK;
-/**
+  }
-  * @brief  Initializes the CRYP peripheral in AES ECB decryption mode using Interrupt.
+  else
-  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
+  {
-  *         the configuration information for CRYP module
+    /* Release Lock */
-  * @param  pCypherData Pointer to the cyphertext buffer (aligned on u32)
+    __HAL_UNLOCK(hcryp);
-  * @param  Size Length of the plaintext buffer, must be a multiple of 16.
-  * @param  pPlainData Pointer to the plaintext buffer (aligned on u32)
+    /* Return function status */
-  * @retval HAL status
+    return HAL_ERROR;
-  */
+  }
-HAL_StatusTypeDef HAL_CRYP_AESECB_Decrypt_IT(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData)
+}
-{
-  uint32_t inputaddr = 0;
+/**
+  * @brief  Initializes the CRYP peripheral in AES ECB decryption mode using Interrupt.
-  /* Check that data aligned on u32 */
+  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
-  if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
+  *         the configuration information for CRYP module
-  {
+  * @param  pCypherData Pointer to the cyphertext buffer (aligned on u32)
-    /* Process Locked */
+  * @param  Size Length of the plaintext buffer, must be a multiple of 16.
-    __HAL_UNLOCK(hcryp);
+  * @param  pPlainData Pointer to the plaintext buffer (aligned on u32)
+  * @retval HAL status
-    /* Return function status */
+  */
-    return HAL_ERROR;
+HAL_StatusTypeDef HAL_CRYP_AESECB_Decrypt_IT(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData)
-  }
+{
+  uint32_t inputaddr = 0;
-  if ((hcryp->State != HAL_CRYP_STATE_RESET) && (hcryp->State == HAL_CRYP_STATE_READY))
-  {
+  /* Check that data aligned on u32 */
-    /* Process Locked */
+  if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
-    __HAL_LOCK(hcryp);
+  {
+    /* Process Locked */
-    /* Get the buffer addresses and sizes */
+    __HAL_UNLOCK(hcryp);
-    hcryp->CrypInCount = Size;
-    hcryp->pCrypInBuffPtr = pCypherData;
+    /* Return function status */
-    hcryp->pCrypOutBuffPtr = pPlainData;
+    return HAL_ERROR;
-    hcryp->CrypOutCount = Size;
+  }
-    /* Change the CRYP state */
+  if ((hcryp->State != HAL_CRYP_STATE_RESET) && (hcryp->State == HAL_CRYP_STATE_READY))
-    hcryp->State = HAL_CRYP_STATE_BUSY;
+  {
+    /* Process Locked */
-    /* Check if initialization phase has already been performed */
+    __HAL_LOCK(hcryp);
-    if(hcryp->Phase == HAL_CRYP_PHASE_READY)
-    {
+    /* Get the buffer addresses and sizes */
-      /* Set the key */
+    hcryp->CrypInCount = Size;
-      CRYP_SetKey(hcryp, hcryp->Init.pKey);
+    hcryp->pCrypInBuffPtr = pCypherData;
+    hcryp->pCrypOutBuffPtr = pPlainData;
-      /* Reset the CHMOD & MODE bits */
+    hcryp->CrypOutCount = Size;
-      CLEAR_BIT(hcryp->Instance->CR, CRYP_ALGO_CHAIN_MASK);
+    /* Change the CRYP state */
-      /* Set the CRYP peripheral in AES ECB decryption mode (with key derivation) */
+    hcryp->State = HAL_CRYP_STATE_BUSY;
-      __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_ECB_KEYDERDECRYPT);
+    /* Check if initialization phase has already been performed */
-      /* Set the phase */
+    if(hcryp->Phase == HAL_CRYP_PHASE_READY)
-      hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
+    {
-    }
+      /* Set the key */
+      CRYP_SetKey(hcryp, hcryp->Init.pKey);
-    /* Enable Interrupts */
-    __HAL_CRYP_ENABLE_IT(hcryp, CRYP_IT_CC);
+      /* Reset the CHMOD & MODE bits */
+      CLEAR_BIT(hcryp->Instance->CR, CRYP_ALGO_CHAIN_MASK);
-    /* Enable CRYP */
-    __HAL_CRYP_ENABLE(hcryp);
+      /* Set the CRYP peripheral in AES ECB decryption mode (with key derivation) */
+      __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_ECB_KEYDERDECRYPT);
-    /* Get the last input data adress */
-    inputaddr = (uint32_t)hcryp->pCrypInBuffPtr;
+      /* Set the phase */
+      hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
-    /* Write the Input block in the Data Input register */
+    }
-    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
-    inputaddr+=4;
+    /* Enable Interrupts */
-    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
+    __HAL_CRYP_ENABLE_IT(hcryp, CRYP_IT_CC);
-    inputaddr+=4;
-    hcryp->Instance->DINR  = *(uint32_t*)(inputaddr);
+    /* Enable CRYP */
-    inputaddr+=4;
+    __HAL_CRYP_ENABLE(hcryp);
-    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
-    hcryp->pCrypInBuffPtr += 16;
+    /* Get the last input data address */
-    hcryp->CrypInCount -= 16;
+    inputaddr = (uint32_t)hcryp->pCrypInBuffPtr;
-    /* Return function status */
+    /* Increment the pointer before writing the input block in the IN FIFO to make sure that
-    return HAL_OK;
+       when Computation Completed IRQ fires, the hcryp->CrypInCount has always a consistent value
-  }
+       and it is ready for the next operation. */
-  else
+    hcryp->pCrypInBuffPtr += 16U;
-  {
+    hcryp->CrypInCount -= 16U;
-    /* Release Lock */
-    __HAL_UNLOCK(hcryp);
+    /* Write the Input block in the Data Input register */
+    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
-    /* Return function status */
+    inputaddr+=4;
-    return HAL_ERROR;
+    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
-  }
+    inputaddr+=4;
-}
+    hcryp->Instance->DINR  = *(uint32_t*)(inputaddr);
+    inputaddr+=4;
-/**
+    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
-  * @brief  Initializes the CRYP peripheral in AES CBC decryption mode using IT.
-  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
+    /* Return function status */
-  *         the configuration information for CRYP module
+    return HAL_OK;
-  * @param  pCypherData Pointer to the cyphertext buffer (aligned on u32)
+  }
-  * @param  Size Length of the plaintext buffer, must be a multiple of 16
+  else
-  * @param  pPlainData Pointer to the plaintext buffer (aligned on u32)
+  {
-  * @retval HAL status
+    /* Release Lock */
-  */
+    __HAL_UNLOCK(hcryp);
-HAL_StatusTypeDef HAL_CRYP_AESCBC_Decrypt_IT(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData)
-{
+    /* Return function status */
-  uint32_t inputaddr = 0;
+    return HAL_ERROR;
+  }
-  /* Check that data aligned on u32 */
+}
-  if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
-  {
+/**
-    /* Process Locked */
+  * @brief  Initializes the CRYP peripheral in AES CBC decryption mode using IT.
-    __HAL_UNLOCK(hcryp);
+  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
+  *         the configuration information for CRYP module
-    /* Return function status */
+  * @param  pCypherData Pointer to the cyphertext buffer (aligned on u32)
-    return HAL_ERROR;
+  * @param  Size Length of the plaintext buffer, must be a multiple of 16
-  }
+  * @param  pPlainData Pointer to the plaintext buffer (aligned on u32)
+  * @retval HAL status
-  if ((hcryp->State != HAL_CRYP_STATE_RESET) && (hcryp->State == HAL_CRYP_STATE_READY))
+  */
-  {
+HAL_StatusTypeDef HAL_CRYP_AESCBC_Decrypt_IT(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData)
-    /* Process Locked */
+{
-    __HAL_LOCK(hcryp);
+  uint32_t inputaddr = 0;
-    /* Get the buffer addresses and sizes */
+  /* Check that data aligned on u32 */
-    hcryp->CrypInCount = Size;
+  if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
-    hcryp->pCrypInBuffPtr = pCypherData;
+  {
-    hcryp->pCrypOutBuffPtr = pPlainData;
+    /* Process Locked */
-    hcryp->CrypOutCount = Size;
+    __HAL_UNLOCK(hcryp);
-    /* Change the CRYP state */
+    /* Return function status */
-    hcryp->State = HAL_CRYP_STATE_BUSY;
+    return HAL_ERROR;
+  }
-    /* Check if initialization phase has already been performed */
-    if(hcryp->Phase == HAL_CRYP_PHASE_READY)
+  if ((hcryp->State != HAL_CRYP_STATE_RESET) && (hcryp->State == HAL_CRYP_STATE_READY))
-    {
+  {
-      /* Set the key */
+    /* Process Locked */
-      CRYP_SetKey(hcryp, hcryp->Init.pKey);
+    __HAL_LOCK(hcryp);
-      /* Reset the CHMOD & MODE bits */
+    /* Get the buffer addresses and sizes */
-      CLEAR_BIT(hcryp->Instance->CR, CRYP_ALGO_CHAIN_MASK);
+    hcryp->CrypInCount = Size;
+    hcryp->pCrypInBuffPtr = pCypherData;
-      /* Set the CRYP peripheral in AES CBC decryption mode (with key derivation) */
+    hcryp->pCrypOutBuffPtr = pPlainData;
-      __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CBC_KEYDERDECRYPT);
+    hcryp->CrypOutCount = Size;
-      /* Set the Initialization Vector */
+    /* Change the CRYP state */
-      CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect);
+    hcryp->State = HAL_CRYP_STATE_BUSY;
-      /* Set the phase */
+    /* Check if initialization phase has already been performed */
-      hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
+    if(hcryp->Phase == HAL_CRYP_PHASE_READY)
-    }
+    {
+      /* Set the key */
-    /* Enable Interrupts */
+      CRYP_SetKey(hcryp, hcryp->Init.pKey);
-    __HAL_CRYP_ENABLE_IT(hcryp, CRYP_IT_CC);
+      /* Reset the CHMOD & MODE bits */
-    /* Enable CRYP */
+      CLEAR_BIT(hcryp->Instance->CR, CRYP_ALGO_CHAIN_MASK);
-    __HAL_CRYP_ENABLE(hcryp);
+      /* Set the CRYP peripheral in AES CBC decryption mode (with key derivation) */
-    /* Get the last input data adress */
+      __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CBC_KEYDERDECRYPT);
-    inputaddr = (uint32_t)hcryp->pCrypInBuffPtr;
+      /* Set the Initialization Vector */
-    /* Write the Input block in the Data Input register */
+      CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect);
-    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
-    inputaddr+=4;
+      /* Set the phase */
-    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
+      hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
-    inputaddr+=4;
+    }
-    hcryp->Instance->DINR  = *(uint32_t*)(inputaddr);
-    inputaddr+=4;
+    /* Enable Interrupts */
-    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
+    __HAL_CRYP_ENABLE_IT(hcryp, CRYP_IT_CC);
-    hcryp->pCrypInBuffPtr += 16;
-    hcryp->CrypInCount -= 16;
+    /* Enable CRYP */
+    __HAL_CRYP_ENABLE(hcryp);
-    /* Return function status */
-    return HAL_OK;
+    /* Get the last input data address */
-  }
+    inputaddr = (uint32_t)hcryp->pCrypInBuffPtr;
-  else
-  {
+    /* Increment the pointer before writing the input block in the IN FIFO to make sure that
-    /* Release Lock */
+       when Computation Completed IRQ fires, the hcryp->CrypInCount has always a consistent value
-    __HAL_UNLOCK(hcryp);
+       and it is ready for the next operation. */
+    hcryp->pCrypInBuffPtr += 16U;
-    /* Return function status */
+    hcryp->CrypInCount -= 16U;
-    return HAL_ERROR;
-  }
+    /* Write the Input block in the Data Input register */
-}
+    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
+    inputaddr+=4;
-/**
+    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
-  * @brief  Initializes the CRYP peripheral in AES CTR decryption mode using Interrupt.
+    inputaddr+=4;
-  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
+    hcryp->Instance->DINR  = *(uint32_t*)(inputaddr);
-  *         the configuration information for CRYP module
+    inputaddr+=4;
-  * @param  pCypherData Pointer to the cyphertext buffer (aligned on u32)
+    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
-  * @param  Size Length of the plaintext buffer, must be a multiple of 16
-  * @param  pPlainData Pointer to the plaintext buffer (aligned on u32)
+    /* Return function status */
-  * @retval HAL status
+    return HAL_OK;
-  */
+  }
-HAL_StatusTypeDef HAL_CRYP_AESCTR_Decrypt_IT(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData)
+  else
-{
+  {
-  uint32_t inputaddr = 0;
+    /* Release Lock */
+    __HAL_UNLOCK(hcryp);
-  /* Check that data aligned on u32 */
-  if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
+    /* Return function status */
-  {
+    return HAL_ERROR;
-    /* Process Locked */
+  }
-    __HAL_UNLOCK(hcryp);
+}
-    /* Return function status */
+/**
-    return HAL_ERROR;
+  * @brief  Initializes the CRYP peripheral in AES CTR decryption mode using Interrupt.
-  }
+  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
+  *         the configuration information for CRYP module
-  if ((hcryp->State != HAL_CRYP_STATE_RESET) && (hcryp->State == HAL_CRYP_STATE_READY))
+  * @param  pCypherData Pointer to the cyphertext buffer (aligned on u32)
-  {
+  * @param  Size Length of the plaintext buffer, must be a multiple of 16
-    /* Process Locked */
+  * @param  pPlainData Pointer to the plaintext buffer (aligned on u32)
-    __HAL_LOCK(hcryp);
+  * @retval HAL status
+  */
-    /* Get the buffer addresses and sizes */
+HAL_StatusTypeDef HAL_CRYP_AESCTR_Decrypt_IT(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData)
-    hcryp->CrypInCount = Size;
+{
-    hcryp->pCrypInBuffPtr = pCypherData;
+  uint32_t inputaddr = 0;
-    hcryp->pCrypOutBuffPtr = pPlainData;
-    hcryp->CrypOutCount = Size;
+  /* Check that data aligned on u32 */
+  if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
-    /* Change the CRYP state */
+  {
-    hcryp->State = HAL_CRYP_STATE_BUSY;
+    /* Process Locked */
+    __HAL_UNLOCK(hcryp);
-    /* Check if initialization phase has already been performed */
-    if(hcryp->Phase == HAL_CRYP_PHASE_READY)
+    /* Return function status */
-    {
+    return HAL_ERROR;
-      /* Set the key */
+  }
-      CRYP_SetKey(hcryp, hcryp->Init.pKey);
+  if ((hcryp->State != HAL_CRYP_STATE_RESET) && (hcryp->State == HAL_CRYP_STATE_READY))
-      /* Reset the CHMOD & MODE bits */
+  {
-      CLEAR_BIT(hcryp->Instance->CR, CRYP_ALGO_CHAIN_MASK);
+    /* Process Locked */
+    __HAL_LOCK(hcryp);
-      /* Set the CRYP peripheral in AES CTR decryption mode */
-      __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CTR_DECRYPT);
+    /* Get the buffer addresses and sizes */
+    hcryp->CrypInCount = Size;
-      /* Set the Initialization Vector */
+    hcryp->pCrypInBuffPtr = pCypherData;
-      CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect);
+    hcryp->pCrypOutBuffPtr = pPlainData;
+    hcryp->CrypOutCount = Size;
-      /* Set the phase */
-      hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
+    /* Change the CRYP state */
-    }
+    hcryp->State = HAL_CRYP_STATE_BUSY;
-    /* Enable Interrupts */
+    /* Check if initialization phase has already been performed */
-    __HAL_CRYP_ENABLE_IT(hcryp, CRYP_IT_CC);
+    if(hcryp->Phase == HAL_CRYP_PHASE_READY)
+    {
-    /* Enable CRYP */
+      /* Set the key */
-    __HAL_CRYP_ENABLE(hcryp);
+      CRYP_SetKey(hcryp, hcryp->Init.pKey);
-    /* Get the last input data adress */
+      /* Reset the CHMOD & MODE bits */
-    inputaddr = (uint32_t)hcryp->pCrypInBuffPtr;
+      CLEAR_BIT(hcryp->Instance->CR, CRYP_ALGO_CHAIN_MASK);
-    /* Write the Input block in the Data Input register */
+      /* Set the CRYP peripheral in AES CTR decryption mode */
-    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
+      __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CTR_DECRYPT);
-    inputaddr+=4;
-    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
+      /* Set the Initialization Vector */
-    inputaddr+=4;
+      CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect);
-    hcryp->Instance->DINR  = *(uint32_t*)(inputaddr);
-    inputaddr+=4;
+      /* Set the phase */
-    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
+      hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
-    hcryp->pCrypInBuffPtr += 16;
+    }
-    hcryp->CrypInCount -= 16;
+    /* Enable Interrupts */
-    /* Return function status */
+    __HAL_CRYP_ENABLE_IT(hcryp, CRYP_IT_CC);
-    return HAL_OK;
-  }
+    /* Enable CRYP */
-  else
+    __HAL_CRYP_ENABLE(hcryp);
-  {
-    /* Release Lock */
+    /* Get the last input data address */
-    __HAL_UNLOCK(hcryp);
+    inputaddr = (uint32_t)hcryp->pCrypInBuffPtr;
-    /* Return function status */
+    /* Increment the pointer before writing the input block in the IN FIFO to make sure that
-    return HAL_ERROR;
+       when Computation Completed IRQ fires, the hcryp->CrypInCount has always a consistent value
-  }
+       and it is ready for the next operation. */
-}
+    hcryp->pCrypInBuffPtr += 16U;
+    hcryp->CrypInCount -= 16U;
-/**
-  * @brief  Initializes the CRYP peripheral in AES ECB encryption mode using DMA.
+    /* Write the Input block in the Data Input register */
-  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
+    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
-  *         the configuration information for CRYP module
+    inputaddr+=4;
-  * @param  pPlainData Pointer to the plaintext buffer (aligned on u32)
+    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
-  * @param  Size Length of the plaintext buffer, must be a multiple of 16 bytes
+    inputaddr+=4;
-  * @param  pCypherData Pointer to the cyphertext buffer (aligned on u32)
+    hcryp->Instance->DINR  = *(uint32_t*)(inputaddr);
-  * @retval HAL status
+    inputaddr+=4;
-  */
+    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
-HAL_StatusTypeDef HAL_CRYP_AESECB_Encrypt_DMA(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData)
-{
+    /* Return function status */
-  uint32_t inputaddr = 0, outputaddr = 0;
+    return HAL_OK;
+  }
-  /* Check that data aligned on u32 */
+  else
-  if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
+  {
-  {
+    /* Release Lock */
-    /* Process Locked */
+    __HAL_UNLOCK(hcryp);
-    __HAL_UNLOCK(hcryp);
+    /* Return function status */
-    /* Return function status */
+    return HAL_ERROR;
-    return HAL_ERROR;
+  }
-  }
+}
-  /* Check if HAL_CRYP_Init has been called */
+/**
-  if ((hcryp->State != HAL_CRYP_STATE_RESET) && (hcryp->State == HAL_CRYP_STATE_READY))
+  * @brief  Initializes the CRYP peripheral in AES ECB encryption mode using DMA.
-  {
+  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
-    /* Process Locked */
+  *         the configuration information for CRYP module
-    __HAL_LOCK(hcryp);
+  * @param  pPlainData Pointer to the plaintext buffer (aligned on u32)
+  * @param  Size Length of the plaintext buffer, must be a multiple of 16 bytes
-    inputaddr  = (uint32_t)pPlainData;
+  * @param  pCypherData Pointer to the cyphertext buffer (aligned on u32)
-    outputaddr = (uint32_t)pCypherData;
+  * @retval HAL status
+  */
-    /* Change the CRYP state */
+HAL_StatusTypeDef HAL_CRYP_AESECB_Encrypt_DMA(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData)
-    hcryp->State = HAL_CRYP_STATE_BUSY;
+{
+  uint32_t inputaddr = 0, outputaddr = 0;
-    /* Check if initialization phase has already been performed */
-    if(hcryp->Phase == HAL_CRYP_PHASE_READY)
+  /* Check that data aligned on u32 */
-    {
+  if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
-      /* Set the key */
+  {
-      CRYP_SetKey(hcryp, hcryp->Init.pKey);
+    /* Process Locked */
+    __HAL_UNLOCK(hcryp);
-      /* Set the CRYP peripheral in AES ECB mode */
-      __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_ECB_ENCRYPT);
+    /* Return function status */
+    return HAL_ERROR;
-      /* Set the phase */
+  }
-      hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
-    }
+  /* Check if HAL_CRYP_Init has been called */
-    /* Set the input and output addresses and start DMA transfer */
+  if ((hcryp->State != HAL_CRYP_STATE_RESET) && (hcryp->State == HAL_CRYP_STATE_READY))
-    CRYP_SetDMAConfig(hcryp, inputaddr, Size, outputaddr);
+  {
+    /* Process Locked */
-    /* Process Unlocked */
+    __HAL_LOCK(hcryp);
-    __HAL_UNLOCK(hcryp);
+    inputaddr  = (uint32_t)pPlainData;
-    /* Return function status */
+    outputaddr = (uint32_t)pCypherData;
-    return HAL_OK;
-  }
+    /* Change the CRYP state */
-  else
+    hcryp->State = HAL_CRYP_STATE_BUSY;
-  {
-    /* Release Lock */
+    /* Check if initialization phase has already been performed */
-    __HAL_UNLOCK(hcryp);
+    if(hcryp->Phase == HAL_CRYP_PHASE_READY)
+    {
-    return HAL_ERROR;
+      /* Set the key */
-  }
+      CRYP_SetKey(hcryp, hcryp->Init.pKey);
-}
+      /* Set the CRYP peripheral in AES ECB mode */
-/**
+      __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_ECB_ENCRYPT);
-  * @brief  Initializes the CRYP peripheral in AES CBC encryption mode using DMA.
-  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
+      /* Set the phase */
-  *         the configuration information for CRYP module
+      hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
-  * @param  pPlainData Pointer to the plaintext buffer (aligned on u32)
+    }
-  * @param  Size Length of the plaintext buffer, must be a multiple of 16.
+    /* Set the input and output addresses and start DMA transfer */
-  * @param  pCypherData Pointer to the cyphertext buffer (aligned on u32)
+    CRYP_SetDMAConfig(hcryp, inputaddr, Size, outputaddr);
-  * @retval HAL status
-  */
+    /* Process Unlocked */
-HAL_StatusTypeDef HAL_CRYP_AESCBC_Encrypt_DMA(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData)
+    __HAL_UNLOCK(hcryp);
-{
-  uint32_t inputaddr = 0, outputaddr = 0;
+    /* Return function status */
+    return HAL_OK;
-  /* Check that data aligned on u32 */
+  }
-  if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
+  else
   {
-    /* Process Locked */
+    /* Release Lock */
     __HAL_UNLOCK(hcryp);
-    /* Return function status */
+    return HAL_ERROR;
-    return HAL_ERROR;
+  }
-  }
+}
-  /* Check if HAL_CRYP_Init has been called */
+/**
-  if ((hcryp->State != HAL_CRYP_STATE_RESET) && (hcryp->State == HAL_CRYP_STATE_READY))
+  * @brief  Initializes the CRYP peripheral in AES CBC encryption mode using DMA.
-  {
+  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
-    /* Process Locked */
+  *         the configuration information for CRYP module
-    __HAL_LOCK(hcryp);
+  * @param  pPlainData Pointer to the plaintext buffer (aligned on u32)
+  * @param  Size Length of the plaintext buffer, must be a multiple of 16.
-    inputaddr  = (uint32_t)pPlainData;
+  * @param  pCypherData Pointer to the cyphertext buffer (aligned on u32)
-    outputaddr = (uint32_t)pCypherData;
+  * @retval HAL status
+  */
-    /* Change the CRYP state */
+HAL_StatusTypeDef HAL_CRYP_AESCBC_Encrypt_DMA(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData)
-    hcryp->State = HAL_CRYP_STATE_BUSY;
+{
+  uint32_t inputaddr = 0, outputaddr = 0;
-    /* Check if initialization phase has already been performed */
-    if(hcryp->Phase == HAL_CRYP_PHASE_READY)
+  /* Check that data aligned on u32 */
-    {
+  if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
-      /* Set the key */
+  {
-      CRYP_SetKey(hcryp, hcryp->Init.pKey);
+    /* Process Locked */
+    __HAL_UNLOCK(hcryp);
-      /* Set the CRYP peripheral in AES CBC mode */
-      __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CBC_ENCRYPT);
+    /* Return function status */
+    return HAL_ERROR;
-      /* Set the Initialization Vector */
+  }
-      CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect);
+  /* Check if HAL_CRYP_Init has been called */
-      /* Set the phase */
+  if ((hcryp->State != HAL_CRYP_STATE_RESET) && (hcryp->State == HAL_CRYP_STATE_READY))
-      hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
+  {
-    }
+    /* Process Locked */
-    /* Set the input and output addresses and start DMA transfer */
+    __HAL_LOCK(hcryp);
-    CRYP_SetDMAConfig(hcryp, inputaddr, Size, outputaddr);
+    inputaddr  = (uint32_t)pPlainData;
-    /* Process Unlocked */
+    outputaddr = (uint32_t)pCypherData;
-    __HAL_UNLOCK(hcryp);
+    /* Change the CRYP state */
-    /* Return function status */
+    hcryp->State = HAL_CRYP_STATE_BUSY;
-    return HAL_OK;
-  }
+    /* Check if initialization phase has already been performed */
-  else
+    if(hcryp->Phase == HAL_CRYP_PHASE_READY)
-  {
+    {
-    /* Release Lock */
+      /* Set the key */
-    __HAL_UNLOCK(hcryp);
+      CRYP_SetKey(hcryp, hcryp->Init.pKey);
-    return HAL_ERROR;
+      /* Set the CRYP peripheral in AES CBC mode */
-  }
+      __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CBC_ENCRYPT);
-}
+      /* Set the Initialization Vector */
-/**
+      CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect);
-  * @brief  Initializes the CRYP peripheral in AES CTR encryption mode using DMA.
-  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
+      /* Set the phase */
-  *         the configuration information for CRYP module
+      hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
-  * @param  pPlainData Pointer to the plaintext buffer (aligned on u32)
+    }
-  * @param  Size Length of the plaintext buffer, must be a multiple of 16.
+    /* Set the input and output addresses and start DMA transfer */
-  * @param  pCypherData Pointer to the cyphertext buffer (aligned on u32)
+    CRYP_SetDMAConfig(hcryp, inputaddr, Size, outputaddr);
-  * @retval HAL status
-  */
+    /* Process Unlocked */
-HAL_StatusTypeDef HAL_CRYP_AESCTR_Encrypt_DMA(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData)
+    __HAL_UNLOCK(hcryp);
-{
-  uint32_t inputaddr = 0, outputaddr = 0;
+    /* Return function status */
+    return HAL_OK;
-  /* Check that data aligned on u32 */
+  }
-  if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
+  else
   {
-    /* Process Locked */
+    /* Release Lock */
     __HAL_UNLOCK(hcryp);
-    /* Return function status */
+    return HAL_ERROR;
-    return HAL_ERROR;
+  }
-  }
+}
-  /* Check if HAL_CRYP_Init has been called */
+/**
-  if ((hcryp->State != HAL_CRYP_STATE_RESET) && (hcryp->State == HAL_CRYP_STATE_READY))
+  * @brief  Initializes the CRYP peripheral in AES CTR encryption mode using DMA.
-  {
+  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
-    /* Process Locked */
+  *         the configuration information for CRYP module
-    __HAL_LOCK(hcryp);
+  * @param  pPlainData Pointer to the plaintext buffer (aligned on u32)
+  * @param  Size Length of the plaintext buffer, must be a multiple of 16.
-    inputaddr  = (uint32_t)pPlainData;
+  * @param  pCypherData Pointer to the cyphertext buffer (aligned on u32)
-    outputaddr = (uint32_t)pCypherData;
+  * @retval HAL status
+  */
-    /* Change the CRYP state */
+HAL_StatusTypeDef HAL_CRYP_AESCTR_Encrypt_DMA(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData)
-    hcryp->State = HAL_CRYP_STATE_BUSY;
+{
+  uint32_t inputaddr = 0, outputaddr = 0;
-    /* Check if initialization phase has already been performed */
-    if(hcryp->Phase == HAL_CRYP_PHASE_READY)
+  /* Check that data aligned on u32 */
-    {
+  if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
-      /* Set the key */
+  {
-      CRYP_SetKey(hcryp, hcryp->Init.pKey);
+    /* Process Locked */
+    __HAL_UNLOCK(hcryp);
-      /* Set the CRYP peripheral in AES CTR mode */
-      __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CTR_ENCRYPT);
+    /* Return function status */
+    return HAL_ERROR;
-      /* Set the Initialization Vector */
+  }
-      CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect);
+  /* Check if HAL_CRYP_Init has been called */
-      /* Set the phase */
+  if ((hcryp->State != HAL_CRYP_STATE_RESET) && (hcryp->State == HAL_CRYP_STATE_READY))
-      hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
+  {
-    }
+    /* Process Locked */
+    __HAL_LOCK(hcryp);
-    /* Set the input and output addresses and start DMA transfer */
-    CRYP_SetDMAConfig(hcryp, inputaddr, Size, outputaddr);
+    inputaddr  = (uint32_t)pPlainData;
+    outputaddr = (uint32_t)pCypherData;
-    /* Process Unlocked */
-    __HAL_UNLOCK(hcryp);
+    /* Change the CRYP state */
+    hcryp->State = HAL_CRYP_STATE_BUSY;
-    /* Return function status */
-    return HAL_OK;
+    /* Check if initialization phase has already been performed */
-  }
+    if(hcryp->Phase == HAL_CRYP_PHASE_READY)
-  else
+    {
-  {
+      /* Set the key */
-    /* Release Lock */
+      CRYP_SetKey(hcryp, hcryp->Init.pKey);
-    __HAL_UNLOCK(hcryp);
+      /* Set the CRYP peripheral in AES CTR mode */
-    return HAL_ERROR;
+      __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CTR_ENCRYPT);
-  }
-}
+      /* Set the Initialization Vector */
+      CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect);
-/**
-  * @brief  Initializes the CRYP peripheral in AES ECB decryption mode using DMA.
+      /* Set the phase */
-  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
+      hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
-  *         the configuration information for CRYP module
+    }
-  * @param  pCypherData Pointer to the cyphertext buffer (aligned on u32)
-  * @param  Size Length of the plaintext buffer, must be a multiple of 16 bytes
+    /* Set the input and output addresses and start DMA transfer */
-  * @param  pPlainData Pointer to the plaintext buffer (aligned on u32)
+    CRYP_SetDMAConfig(hcryp, inputaddr, Size, outputaddr);
-  * @retval HAL status
-  */
+    /* Process Unlocked */
-HAL_StatusTypeDef HAL_CRYP_AESECB_Decrypt_DMA(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData)
+    __HAL_UNLOCK(hcryp);
-{
-  uint32_t inputaddr = 0, outputaddr = 0;
+    /* Return function status */
+    return HAL_OK;
-  /* Check that data aligned on u32 */
+  }
-  if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
+  else
   {
-    /* Process Locked */
+    /* Release Lock */
     __HAL_UNLOCK(hcryp);
-    /* Return function status */
+    return HAL_ERROR;
-    return HAL_ERROR;
+  }
-  }
+}
-  /* Check if HAL_CRYP_Init has been called */
+/**
-  if ((hcryp->State != HAL_CRYP_STATE_RESET) && (hcryp->State == HAL_CRYP_STATE_READY))
+  * @brief  Initializes the CRYP peripheral in AES ECB decryption mode using DMA.
-  {
+  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
-    /* Process Locked */
+  *         the configuration information for CRYP module
-    __HAL_LOCK(hcryp);
+  * @param  pCypherData Pointer to the cyphertext buffer (aligned on u32)
+  * @param  Size Length of the plaintext buffer, must be a multiple of 16 bytes
-    inputaddr  = (uint32_t)pCypherData;
+  * @param  pPlainData Pointer to the plaintext buffer (aligned on u32)
-    outputaddr = (uint32_t)pPlainData;
+  * @retval HAL status
+  */
-    /* Change the CRYP state */
+HAL_StatusTypeDef HAL_CRYP_AESECB_Decrypt_DMA(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData)
-    hcryp->State = HAL_CRYP_STATE_BUSY;
+{
+  uint32_t inputaddr = 0, outputaddr = 0;
-    /* Check if initialization phase has already been performed */
-    if(hcryp->Phase == HAL_CRYP_PHASE_READY)
+  /* Check that data aligned on u32 */
-    {
+  if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
-      /* Set the key */
+  {
-      CRYP_SetKey(hcryp, hcryp->Init.pKey);
+    /* Process Locked */
+    __HAL_UNLOCK(hcryp);
-      /* Reset the CHMOD & MODE bits */
-      CLEAR_BIT(hcryp->Instance->CR, CRYP_ALGO_CHAIN_MASK);
+    /* Return function status */
+    return HAL_ERROR;
-      /* Set the CRYP peripheral in AES ECB decryption mode (with key derivation) */
+  }
-      __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_ECB_KEYDERDECRYPT);
+  /* Check if HAL_CRYP_Init has been called */
-      /* Set the phase */
+  if ((hcryp->State != HAL_CRYP_STATE_RESET) && (hcryp->State == HAL_CRYP_STATE_READY))
-      hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
+  {
-    }
+    /* Process Locked */
+    __HAL_LOCK(hcryp);
-    /* Set the input and output addresses and start DMA transfer */
-    CRYP_SetDMAConfig(hcryp, inputaddr, Size, outputaddr);
+    inputaddr  = (uint32_t)pCypherData;
+    outputaddr = (uint32_t)pPlainData;
-    /* Process Unlocked */
-    __HAL_UNLOCK(hcryp);
+    /* Change the CRYP state */
+    hcryp->State = HAL_CRYP_STATE_BUSY;
-    /* Return function status */
-    return HAL_OK;
+    /* Check if initialization phase has already been performed */
-  }
+    if(hcryp->Phase == HAL_CRYP_PHASE_READY)
-  else
+    {
-  {
+      /* Set the key */
-    /* Release Lock */
+      CRYP_SetKey(hcryp, hcryp->Init.pKey);
-    __HAL_UNLOCK(hcryp);
+      /* Reset the CHMOD & MODE bits */
-    return HAL_ERROR;
+      CLEAR_BIT(hcryp->Instance->CR, CRYP_ALGO_CHAIN_MASK);
-  }
-}
+      /* Set the CRYP peripheral in AES ECB decryption mode (with key derivation) */
+      __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_ECB_KEYDERDECRYPT);
-/**
-  * @brief  Initializes the CRYP peripheral in AES CBC encryption mode using DMA.
+      /* Set the phase */
-  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
+      hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
-  *         the configuration information for CRYP module
+    }
-  * @param  pCypherData Pointer to the cyphertext buffer (aligned on u32)
-  * @param  Size Length of the plaintext buffer, must be a multiple of 16 bytes
+    /* Set the input and output addresses and start DMA transfer */
-  * @param  pPlainData Pointer to the plaintext buffer (aligned on u32)
+    CRYP_SetDMAConfig(hcryp, inputaddr, Size, outputaddr);
-  * @retval HAL status
-  */
+    /* Process Unlocked */
-HAL_StatusTypeDef HAL_CRYP_AESCBC_Decrypt_DMA(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData)
+    __HAL_UNLOCK(hcryp);
-{
-  uint32_t inputaddr = 0, outputaddr = 0;
+    /* Return function status */
+    return HAL_OK;
-  /* Check that data aligned on u32 */
+  }
-  if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
+  else
   {
-    /* Process Locked */
+    /* Release Lock */
     __HAL_UNLOCK(hcryp);
-    /* Return function status */
+    return HAL_ERROR;
-    return HAL_ERROR;
+  }
-  }
+}
-  /* Check if HAL_CRYP_Init has been called */
+/**
-  if ((hcryp->State != HAL_CRYP_STATE_RESET) && (hcryp->State == HAL_CRYP_STATE_READY))
+  * @brief  Initializes the CRYP peripheral in AES CBC encryption mode using DMA.
-  {
+  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
-    /* Process Locked */
+  *         the configuration information for CRYP module
-    __HAL_LOCK(hcryp);
+  * @param  pCypherData Pointer to the cyphertext buffer (aligned on u32)
+  * @param  Size Length of the plaintext buffer, must be a multiple of 16 bytes
-    inputaddr  = (uint32_t)pCypherData;
+  * @param  pPlainData Pointer to the plaintext buffer (aligned on u32)
-    outputaddr = (uint32_t)pPlainData;
+  * @retval HAL status
+  */
-    /* Change the CRYP state */
+HAL_StatusTypeDef HAL_CRYP_AESCBC_Decrypt_DMA(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData)
-    hcryp->State = HAL_CRYP_STATE_BUSY;
+{
+  uint32_t inputaddr = 0, outputaddr = 0;
-    /* Check if initialization phase has already been performed */
-    if(hcryp->Phase == HAL_CRYP_PHASE_READY)
+  /* Check that data aligned on u32 */
-    {
+  if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
-      /* Set the key */
+  {
-      CRYP_SetKey(hcryp, hcryp->Init.pKey);
+    /* Process Locked */
+    __HAL_UNLOCK(hcryp);
-      /* Reset the CHMOD & MODE bits */
-      CLEAR_BIT(hcryp->Instance->CR, CRYP_ALGO_CHAIN_MASK);
+    /* Return function status */
+    return HAL_ERROR;
-      /* Set the CRYP peripheral in AES CBC decryption mode (with key derivation) */
+  }
-      __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CBC_KEYDERDECRYPT);
+  /* Check if HAL_CRYP_Init has been called */
-      /* Set the Initialization Vector */
+  if ((hcryp->State != HAL_CRYP_STATE_RESET) && (hcryp->State == HAL_CRYP_STATE_READY))
-      CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect);
+  {
+    /* Process Locked */
-      /* Set the phase */
+    __HAL_LOCK(hcryp);
-      hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
-    }
+    inputaddr  = (uint32_t)pCypherData;
+    outputaddr = (uint32_t)pPlainData;
-    /* Set the input and output addresses and start DMA transfer */
-    CRYP_SetDMAConfig(hcryp, inputaddr, Size, outputaddr);
+    /* Change the CRYP state */
+    hcryp->State = HAL_CRYP_STATE_BUSY;
-    /* Process Unlocked */
-    __HAL_UNLOCK(hcryp);
+    /* Check if initialization phase has already been performed */
+    if(hcryp->Phase == HAL_CRYP_PHASE_READY)
-    /* Return function status */
+    {
-    return HAL_OK;
+      /* Set the key */
-  }
+      CRYP_SetKey(hcryp, hcryp->Init.pKey);
-  else
-  {
+      /* Reset the CHMOD & MODE bits */
-    /* Release Lock */
+      CLEAR_BIT(hcryp->Instance->CR, CRYP_ALGO_CHAIN_MASK);
-    __HAL_UNLOCK(hcryp);
+      /* Set the CRYP peripheral in AES CBC decryption mode (with key derivation) */
-    return HAL_ERROR;
+      __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CBC_KEYDERDECRYPT);
-  }
-}
+      /* Set the Initialization Vector */
+      CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect);
-/**
-  * @brief  Initializes the CRYP peripheral in AES CTR decryption mode using DMA.
+      /* Set the phase */
-  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
+      hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
-  *         the configuration information for CRYP module
+    }
-  * @param  pCypherData Pointer to the cyphertext buffer (aligned on u32)
-  * @param  Size Length of the plaintext buffer, must be a multiple of 16
+    /* Set the input and output addresses and start DMA transfer */
-  * @param  pPlainData Pointer to the plaintext buffer (aligned on u32)
+    CRYP_SetDMAConfig(hcryp, inputaddr, Size, outputaddr);
-  * @retval HAL status
-  */
+    /* Process Unlocked */
-HAL_StatusTypeDef HAL_CRYP_AESCTR_Decrypt_DMA(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData)
+    __HAL_UNLOCK(hcryp);
-{
-  uint32_t inputaddr = 0, outputaddr = 0;
+    /* Return function status */
+    return HAL_OK;
-  /* Check that data aligned on u32 */
+  }
-  if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
+  else
   {
-    /* Process Locked */
+    /* Release Lock */
     __HAL_UNLOCK(hcryp);
-    /* Return function status */
+    return HAL_ERROR;
-    return HAL_ERROR;
+  }
-  }
+}
-  /* Check if HAL_CRYP_Init has been called */
+/**
-  if ((hcryp->State != HAL_CRYP_STATE_RESET) && (hcryp->State == HAL_CRYP_STATE_READY))
+  * @brief  Initializes the CRYP peripheral in AES CTR decryption mode using DMA.
-  {
+  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
-    /* Process Locked */
+  *         the configuration information for CRYP module
-    __HAL_LOCK(hcryp);
+  * @param  pCypherData Pointer to the cyphertext buffer (aligned on u32)
+  * @param  Size Length of the plaintext buffer, must be a multiple of 16
-    inputaddr  = (uint32_t)pCypherData;
+  * @param  pPlainData Pointer to the plaintext buffer (aligned on u32)
-    outputaddr = (uint32_t)pPlainData;
+  * @retval HAL status
+  */
-    /* Change the CRYP state */
+HAL_StatusTypeDef HAL_CRYP_AESCTR_Decrypt_DMA(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData)
-    hcryp->State = HAL_CRYP_STATE_BUSY;
+{
+  uint32_t inputaddr = 0, outputaddr = 0;
-    /* Check if initialization phase has already been performed */
-    if(hcryp->Phase == HAL_CRYP_PHASE_READY)
+  /* Check that data aligned on u32 */
-    {
+  if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
-      /* Set the key */
+  {
-      CRYP_SetKey(hcryp, hcryp->Init.pKey);
+    /* Process Locked */
+    __HAL_UNLOCK(hcryp);
-      /* Set the CRYP peripheral in AES CTR mode */
-      __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CTR_DECRYPT);
+    /* Return function status */
+    return HAL_ERROR;
-      /* Set the Initialization Vector */
+  }
-      CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect);
+  /* Check if HAL_CRYP_Init has been called */
-      /* Set the phase */
+  if ((hcryp->State != HAL_CRYP_STATE_RESET) && (hcryp->State == HAL_CRYP_STATE_READY))
-      hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
+  {
-    }
+    /* Process Locked */
+    __HAL_LOCK(hcryp);
-    /* Set the input and output addresses and start DMA transfer */
-    CRYP_SetDMAConfig(hcryp, inputaddr, Size, outputaddr);
+    inputaddr  = (uint32_t)pCypherData;
+    outputaddr = (uint32_t)pPlainData;
-    /* Process Unlocked */
-    __HAL_UNLOCK(hcryp);
+    /* Change the CRYP state */
+    hcryp->State = HAL_CRYP_STATE_BUSY;
-    /* Return function status */
-    return HAL_OK;
+    /* Check if initialization phase has already been performed */
-  }
+    if(hcryp->Phase == HAL_CRYP_PHASE_READY)
-  else
+    {
-  {
+      /* Set the key */
-    /* Release Lock */
+      CRYP_SetKey(hcryp, hcryp->Init.pKey);
-    __HAL_UNLOCK(hcryp);
+      /* Set the CRYP peripheral in AES CTR mode */
-    return HAL_ERROR;
+      __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CTR_DECRYPT);
-  }
-}
+      /* Set the Initialization Vector */
+      CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect);
-/**
-  * @}
+      /* Set the phase */
-  */
+      hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
+    }
-/** @defgroup CRYP_Exported_Functions_Group3 DMA callback functions
- *  @brief   DMA callback functions.
+    /* Set the input and output addresses and start DMA transfer */
- *
+    CRYP_SetDMAConfig(hcryp, inputaddr, Size, outputaddr);
-@verbatim
-  ==============================================================================
+    /* Process Unlocked */
-                      ##### DMA callback functions  #####
+    __HAL_UNLOCK(hcryp);
-  ==============================================================================
-    [..]  This section provides DMA callback functions:
+    /* Return function status */
-      (+) DMA Input data transfer complete
+    return HAL_OK;
-      (+) DMA Output data transfer complete
+  }
-      (+) DMA error
+  else
+  {
-@endverbatim
+    /* Release Lock */
-  * @{
+    __HAL_UNLOCK(hcryp);
-  */
+    return HAL_ERROR;
-/**
+  }
-  * @brief  CRYP error callback.
+}
-  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
-  *         the configuration information for CRYP module
+/**
-  * @retval None
+  * @}
   */
- __weak void HAL_CRYP_ErrorCallback(CRYP_HandleTypeDef *hcryp)
-{
+/** @defgroup CRYP_Exported_Functions_Group3 DMA callback functions
-  /* Prevent unused argument(s) compilation warning */
+ *  @brief   DMA callback functions.
-  UNUSED(hcryp);
+ *
+@verbatim
-  /* NOTE : This function should not be modified; when the callback is needed,
+  ==============================================================================
-            the HAL_CRYP_ErrorCallback can be implemented in the user file
+                      ##### DMA callback functions  #####
-   */
+  ==============================================================================
-}
+    [..]  This section provides DMA callback functions:
+      (+) DMA Input data transfer complete
-/**
+      (+) DMA Output data transfer complete
-  * @brief  Input transfer completed callback.
+      (+) DMA error
-  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
-  *         the configuration information for CRYP module
+@endverbatim
-  * @retval None
+  * @{
   */
-__weak void HAL_CRYP_InCpltCallback(CRYP_HandleTypeDef *hcryp)
-{
+/**
-  /* Prevent unused argument(s) compilation warning */
+  * @brief  CRYP error callback.
-  UNUSED(hcryp);
+  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
+  *         the configuration information for CRYP module
-  /* NOTE : This function should not be modified; when the callback is needed,
+  * @retval None
-            the HAL_CRYP_InCpltCallback can be implemented in the user file
+  */
-   */
+ __weak void HAL_CRYP_ErrorCallback(CRYP_HandleTypeDef *hcryp)
-}
+{
+  /* Prevent unused argument(s) compilation warning */
-/**
+  UNUSED(hcryp);
-  * @brief  Output transfer completed callback.
-  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
+  /* NOTE : This function should not be modified; when the callback is needed,
-  *         the configuration information for CRYP module
+            the HAL_CRYP_ErrorCallback can be implemented in the user file
-  * @retval None
+   */
-  */
+}
-__weak void HAL_CRYP_OutCpltCallback(CRYP_HandleTypeDef *hcryp)
-{
+/**
-  /* Prevent unused argument(s) compilation warning */
+  * @brief  Input transfer completed callback.
-  UNUSED(hcryp);
+  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
+  *         the configuration information for CRYP module
-  /* NOTE : This function should not be modified; when the callback is needed,
+  * @retval None
-            the HAL_CRYP_OutCpltCallback can be implemented in the user file
+  */
-   */
+__weak void HAL_CRYP_InCpltCallback(CRYP_HandleTypeDef *hcryp)
-}
+{
+  /* Prevent unused argument(s) compilation warning */
-/**
+  UNUSED(hcryp);
-  * @}
-  */
+  /* NOTE : This function should not be modified; when the callback is needed,
+            the HAL_CRYP_InCpltCallback can be implemented in the user file
-/** @defgroup CRYP_Exported_Functions_Group4 CRYP IRQ handler
+   */
- *  @brief   CRYP IRQ handler.
+}
- *
-@verbatim
+/**
-  ==============================================================================
+  * @brief  Output transfer completed callback.
-                ##### CRYP IRQ handler management #####
+  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
-  ==============================================================================
+  *         the configuration information for CRYP module
-[..]  This section provides CRYP IRQ handler function.
+  * @retval None
+  */
-@endverbatim
+__weak void HAL_CRYP_OutCpltCallback(CRYP_HandleTypeDef *hcryp)
-  * @{
+{
-  */
+  /* Prevent unused argument(s) compilation warning */
+  UNUSED(hcryp);
-/**
-  * @brief  This function handles CRYP interrupt request.
+  /* NOTE : This function should not be modified; when the callback is needed,
-  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
+            the HAL_CRYP_OutCpltCallback can be implemented in the user file
-  *         the configuration information for CRYP module
+   */
-  * @retval None
+}
-  */
-void HAL_CRYP_IRQHandler(CRYP_HandleTypeDef *hcryp)
+/**
-{
+  * @}
-  /* Check if error occurred*/
+  */
-  if (__HAL_CRYP_GET_IT_SOURCE(hcryp, CRYP_IT_ERR) != RESET)
-  {
+/** @defgroup CRYP_Exported_Functions_Group4 CRYP IRQ handler
-    if (__HAL_CRYP_GET_FLAG(hcryp,CRYP_FLAG_RDERR) != RESET)
+ *  @brief   CRYP IRQ handler.
-    {
+ *
-      __HAL_CRYP_CLEAR_FLAG(hcryp, CRYP_CLEARFLAG_RDERR);
+@verbatim
-    }
+  ==============================================================================
+                ##### CRYP IRQ handler management #####
-    if (__HAL_CRYP_GET_FLAG(hcryp,CRYP_FLAG_WRERR) != RESET)
+  ==============================================================================
-    {
+[..]  This section provides CRYP IRQ handler function.
-      __HAL_CRYP_CLEAR_FLAG(hcryp, CRYP_CLEARFLAG_WRERR);
-    }
+@endverbatim
+  * @{
-    if (__HAL_CRYP_GET_FLAG(hcryp, CRYP_FLAG_CCF) != RESET)
+  */
-    {
-      __HAL_CRYP_CLEAR_FLAG(hcryp, CRYP_CLEARFLAG_CCF);
+/**
-    }
+  * @brief  This function handles CRYP interrupt request.
+  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
-    hcryp->State= HAL_CRYP_STATE_ERROR;
+  *         the configuration information for CRYP module
-    /* Disable Computation Complete Interrupt */
+  * @retval None
-    __HAL_CRYP_DISABLE_IT(hcryp,CRYP_IT_CC);
+  */
-    __HAL_CRYP_DISABLE_IT(hcryp,CRYP_IT_ERR);
+void HAL_CRYP_IRQHandler(CRYP_HandleTypeDef *hcryp)
+{
-    HAL_CRYP_ErrorCallback(hcryp);
+  /* Check if error occurred*/
+  if (__HAL_CRYP_GET_IT_SOURCE(hcryp, CRYP_IT_ERR) != RESET)
-    /* Process Unlocked */
+  {
-    __HAL_UNLOCK(hcryp);
+    if (__HAL_CRYP_GET_FLAG(hcryp,CRYP_FLAG_RDERR) != RESET)
+    {
-    return;
+      __HAL_CRYP_CLEAR_FLAG(hcryp, CRYP_CLEARFLAG_RDERR);
-  }
+    }
-  /* Check if computation complete interrupt was enabled*/
+    if (__HAL_CRYP_GET_FLAG(hcryp,CRYP_FLAG_WRERR) != RESET)
-  if (__HAL_CRYP_GET_IT_SOURCE(hcryp, CRYP_IT_CC) != RESET)
+    {
-  {
+      __HAL_CRYP_CLEAR_FLAG(hcryp, CRYP_CLEARFLAG_WRERR);
-    /* Clear CCF Flag */
+    }
-    __HAL_CRYP_CLEAR_FLAG(hcryp, CRYP_CLEARFLAG_CCF);
+    if (__HAL_CRYP_GET_FLAG(hcryp, CRYP_FLAG_CCF) != RESET)
-    CRYP_EncryptDecrypt_IT(hcryp);
+    {
-  }
+      __HAL_CRYP_CLEAR_FLAG(hcryp, CRYP_CLEARFLAG_CCF);
-}
+    }
-/**
+    hcryp->State= HAL_CRYP_STATE_ERROR;
-  * @}
+    /* Disable Computation Complete Interrupt */
-  */
+    __HAL_CRYP_DISABLE_IT(hcryp,CRYP_IT_CC);
+    __HAL_CRYP_DISABLE_IT(hcryp,CRYP_IT_ERR);
-/** @defgroup CRYP_Exported_Functions_Group5 Peripheral State functions
- *  @brief   Peripheral State functions.
+    HAL_CRYP_ErrorCallback(hcryp);
- *
-@verbatim
+    /* Process Unlocked */
-  ==============================================================================
+    __HAL_UNLOCK(hcryp);
-                      ##### Peripheral State functions #####
-  ==============================================================================
+    return;
-    [..]
+  }
-    This subsection permits to get in run-time the status of the peripheral.
+  /* Check if computation complete interrupt was enabled*/
-@endverbatim
+  if (__HAL_CRYP_GET_IT_SOURCE(hcryp, CRYP_IT_CC) != RESET)
-  * @{
+  {
-  */
+    /* Clear CCF Flag */
+    __HAL_CRYP_CLEAR_FLAG(hcryp, CRYP_CLEARFLAG_CCF);
-/**
-  * @brief  Returns the CRYP state.
+    CRYP_EncryptDecrypt_IT(hcryp);
-  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
+  }
-  *         the configuration information for CRYP module
+}
-  * @retval HAL state
-  */
+/**
-HAL_CRYP_STATETypeDef HAL_CRYP_GetState(CRYP_HandleTypeDef *hcryp)
+  * @}
-{
+  */
-  return hcryp->State;
-}
+/** @defgroup CRYP_Exported_Functions_Group5 Peripheral State functions
+ *  @brief   Peripheral State functions.
-/**
+ *
-  * @}
+@verbatim
-  */
+  ==============================================================================
+                      ##### Peripheral State functions #####
-/**
+  ==============================================================================
-  * @}
+    [..]
-  */
+    This subsection permits to get in run-time the status of the peripheral.
-/** @addtogroup CRYP_Private_Functions
+@endverbatim
   * @{
   */
 /**
-  * @brief  IT function called under interruption context to continue encryption or decryption
+  * @brief  Returns the CRYP state.
   * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
   *         the configuration information for CRYP module
-  * @retval HAL status
+  * @retval HAL state
   */
-static HAL_StatusTypeDef CRYP_EncryptDecrypt_IT(CRYP_HandleTypeDef *hcryp)
+HAL_CRYP_STATETypeDef HAL_CRYP_GetState(CRYP_HandleTypeDef *hcryp)
 {
-  uint32_t inputaddr = 0, outputaddr = 0;
+  return hcryp->State;
+}
-  /* Get the last Output data adress */
-  outputaddr = (uint32_t)hcryp->pCrypOutBuffPtr;
+/**
+  * @}
-  /* Read the Output block from the Output Register */
+  */
-  *(uint32_t*)(outputaddr) = hcryp->Instance->DOUTR;
-  outputaddr+=4;
+/**
-  *(uint32_t*)(outputaddr) = hcryp->Instance->DOUTR;
+  * @}
-  outputaddr+=4;
+  */
-  *(uint32_t*)(outputaddr) = hcryp->Instance->DOUTR;
-  outputaddr+=4;
+/** @addtogroup CRYP_Private_Functions
-  *(uint32_t*)(outputaddr) = hcryp->Instance->DOUTR;
+  * @{
+  */
-  hcryp->pCrypOutBuffPtr += 16;
-  hcryp->CrypOutCount -= 16;
+/**
+  * @brief  IT function called under interruption context to continue encryption or decryption
-  /* Check if all input text is encrypted or decrypted */
+  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
-  if(hcryp->CrypOutCount == 0)
+  *         the configuration information for CRYP module
-  {
+  * @retval HAL status
-    /* Disable Computation Complete Interrupt */
+  */
-    __HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_CC);
+static HAL_StatusTypeDef CRYP_EncryptDecrypt_IT(CRYP_HandleTypeDef *hcryp)
-    __HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_ERR);
+{
+  uint32_t inputaddr = 0, outputaddr = 0;
-    /* Process Unlocked */
-    __HAL_UNLOCK(hcryp);
+  /* Get the last Output data address */
+  outputaddr = (uint32_t)hcryp->pCrypOutBuffPtr;
-    /* Change the CRYP state */
-    hcryp->State = HAL_CRYP_STATE_READY;
+  /* Read the Output block from the Output Register */
+  *(uint32_t*)(outputaddr) = hcryp->Instance->DOUTR;
-    /* Call computation complete callback */
+  outputaddr+=4;
-    HAL_CRYPEx_ComputationCpltCallback(hcryp);
+  *(uint32_t*)(outputaddr) = hcryp->Instance->DOUTR;
-  }
+  outputaddr+=4;
-  else /* Process the rest of input text */
+  *(uint32_t*)(outputaddr) = hcryp->Instance->DOUTR;
-  {
+  outputaddr+=4;
-    /* Get the last Intput data adress */
+  *(uint32_t*)(outputaddr) = hcryp->Instance->DOUTR;
-    inputaddr = (uint32_t)hcryp->pCrypInBuffPtr;
+  hcryp->pCrypOutBuffPtr += 16;
-    /* Write the Input block in the Data Input register */
+  hcryp->CrypOutCount -= 16;
-    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
-    inputaddr+=4;
+  /* Check if all input text is encrypted or decrypted */
-    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
+  if(hcryp->CrypOutCount == 0)
-    inputaddr+=4;
+  {
-    hcryp->Instance->DINR  = *(uint32_t*)(inputaddr);
+    /* Disable Computation Complete Interrupt */
-    inputaddr+=4;
+    __HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_CC);
-    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
+    __HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_ERR);
-    hcryp->pCrypInBuffPtr += 16;
-    hcryp->CrypInCount -= 16;
+    /* Process Unlocked */
-  }
+    __HAL_UNLOCK(hcryp);
-  return HAL_OK;
-}
+    /* Change the CRYP state */
-/**
+    hcryp->State = HAL_CRYP_STATE_READY;
-  * @brief  DMA CRYP Input Data process complete callback.
-  * @param  hdma DMA handle
+    /* Call computation complete callback */
-  * @retval None
+    HAL_CRYPEx_ComputationCpltCallback(hcryp);
-  */
+  }
-static void CRYP_DMAInCplt(DMA_HandleTypeDef *hdma)
+  else /* Process the rest of input text */
-{
+  {
-  CRYP_HandleTypeDef* hcryp = (CRYP_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
+    /* Get the last Input data address */
+    inputaddr = (uint32_t)hcryp->pCrypInBuffPtr;
-  /* Disable the DMA transfer for input request  */
-  CLEAR_BIT(hcryp->Instance->CR, AES_CR_DMAINEN);
+    /* Increment the pointer before writing the input block in the IN FIFO to make sure that
+       when Computation Completed IRQ fires, the hcryp->CrypInCount has always a consistent value
-  /* Call input data transfer complete callback */
+       and it is ready for the next operation. */
-  HAL_CRYP_InCpltCallback(hcryp);
+    hcryp->pCrypInBuffPtr += 16U;
-}
+    hcryp->CrypInCount -= 16U;
-/**
+    /* Write the Input block in the Data Input register */
-  * @brief  DMA CRYP Output Data process complete callback.
+    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
-  * @param  hdma DMA handle
+    inputaddr+=4;
-  * @retval None
+    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
-  */
+    inputaddr+=4;
-static void CRYP_DMAOutCplt(DMA_HandleTypeDef *hdma)
+    hcryp->Instance->DINR  = *(uint32_t*)(inputaddr);
-{
+    inputaddr+=4;
-  CRYP_HandleTypeDef* hcryp = (CRYP_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
+    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
+  }
-  /* Disable the DMA transfer for output request by resetting the DMAOUTEN bit
+  return HAL_OK;
-     in the DMACR register */
+}
-  CLEAR_BIT(hcryp->Instance->CR, AES_CR_DMAOUTEN);
+/**
+  * @brief  DMA CRYP Input Data process complete callback.
-  /* Clear CCF Flag */
+  * @param  hdma DMA handle
-  __HAL_CRYP_CLEAR_FLAG(hcryp, CRYP_CLEARFLAG_CCF);
+  * @retval None
+  */
-  /* Disable CRYP */
+static void CRYP_DMAInCplt(DMA_HandleTypeDef *hdma)
-  __HAL_CRYP_DISABLE(hcryp);
+{
+  CRYP_HandleTypeDef* hcryp = (CRYP_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
-  /* Change the CRYP state to ready */
-  hcryp->State = HAL_CRYP_STATE_READY;
+  /* Disable the DMA transfer for input request  */
+  CLEAR_BIT(hcryp->Instance->CR, AES_CR_DMAINEN);
-  /* Call output data transfer complete callback */
-  HAL_CRYP_OutCpltCallback(hcryp);
+  /* Call input data transfer complete callback */
-}
+  HAL_CRYP_InCpltCallback(hcryp);
+}
-/**
-  * @brief  DMA CRYP communication error callback.
+/**
-  * @param  hdma DMA handle
+  * @brief  DMA CRYP Output Data process complete callback.
-  * @retval None
+  * @param  hdma DMA handle
-  */
+  * @retval None
-static void CRYP_DMAError(DMA_HandleTypeDef *hdma)
+  */
-{
+static void CRYP_DMAOutCplt(DMA_HandleTypeDef *hdma)
-  CRYP_HandleTypeDef* hcryp = (CRYP_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
+{
-  hcryp->State= HAL_CRYP_STATE_ERROR;
+  CRYP_HandleTypeDef* hcryp = (CRYP_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
-  HAL_CRYP_ErrorCallback(hcryp);
-}
+  /* Disable the DMA transfer for output request by resetting the DMAOUTEN bit
+     in the DMACR register */
-/**
+  CLEAR_BIT(hcryp->Instance->CR, AES_CR_DMAOUTEN);
-  * @brief  Writes the Key in Key registers.
-  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
+  /* Clear CCF Flag */
-  *         the configuration information for CRYP module
+  __HAL_CRYP_CLEAR_FLAG(hcryp, CRYP_CLEARFLAG_CCF);
-  * @param  Key Pointer to Key buffer
-  * @note Key must be written as little endian.
+  /* Disable CRYP */
-  *         If Key pointer points at address n,
+  __HAL_CRYP_DISABLE(hcryp);
-  *         n[15:0] contains key[96:127],
-  *         (n+4)[15:0] contains key[64:95],
+  /* Change the CRYP state to ready */
-  *         (n+8)[15:0] contains key[32:63] and
+  hcryp->State = HAL_CRYP_STATE_READY;
-  *         (n+12)[15:0] contains key[0:31]
-  * @retval None
+  /* Call output data transfer complete callback */
-  */
+  HAL_CRYP_OutCpltCallback(hcryp);
-static void CRYP_SetKey(CRYP_HandleTypeDef *hcryp, uint8_t *Key)
+}
-{
-  uint32_t keyaddr = (uint32_t)Key;
+/**
+  * @brief  DMA CRYP communication error callback.
-  hcryp->Instance->KEYR3 = __REV(*(uint32_t*)(keyaddr));
+  * @param  hdma DMA handle
-  keyaddr+=4;
+  * @retval None
-  hcryp->Instance->KEYR2 = __REV(*(uint32_t*)(keyaddr));
+  */
-  keyaddr+=4;
+static void CRYP_DMAError(DMA_HandleTypeDef *hdma)
-  hcryp->Instance->KEYR1 = __REV(*(uint32_t*)(keyaddr));
+{
-  keyaddr+=4;
+  CRYP_HandleTypeDef* hcryp = (CRYP_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
-  hcryp->Instance->KEYR0 = __REV(*(uint32_t*)(keyaddr));
+  hcryp->State= HAL_CRYP_STATE_ERROR;
-}
+  HAL_CRYP_ErrorCallback(hcryp);
+}
-/**
-  * @brief  Writes the InitVector/InitCounter in IV registers.
+/**
-  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
+  * @brief  Writes the Key in Key registers.
-  *         the configuration information for CRYP module
+  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
-  * @param  InitVector Pointer to InitVector/InitCounter buffer
+  *         the configuration information for CRYP module
-  * @note Init Vector must be written as little endian.
+  * @param  Key Pointer to Key buffer
-  *         If Init Vector pointer points at address n,
+  * @note Key must be written as little endian.
-  *         n[15:0] contains Vector[96:127],
+  *         If Key pointer points at address n,
-  *         (n+4)[15:0] contains Vector[64:95],
+  *         n[15:0] contains key[96:127],
-  *         (n+8)[15:0] contains Vector[32:63] and
+  *         (n+4)[15:0] contains key[64:95],
-  *         (n+12)[15:0] contains Vector[0:31]
+  *         (n+8)[15:0] contains key[32:63] and
-  * @retval None
+  *         (n+12)[15:0] contains key[0:31]
-  */
+  * @retval None
-static void CRYP_SetInitVector(CRYP_HandleTypeDef *hcryp, uint8_t *InitVector)
+  */
-{
+static void CRYP_SetKey(CRYP_HandleTypeDef *hcryp, uint8_t *Key)
-  uint32_t ivaddr = (uint32_t)InitVector;
+{
+  uint32_t keyaddr = (uint32_t)Key;
-  hcryp->Instance->IVR3 = __REV(*(uint32_t*)(ivaddr));
-  ivaddr+=4;
+  hcryp->Instance->KEYR3 = __REV(*(uint32_t*)(keyaddr));
-  hcryp->Instance->IVR2 = __REV(*(uint32_t*)(ivaddr));
+  keyaddr+=4;
-  ivaddr+=4;
+  hcryp->Instance->KEYR2 = __REV(*(uint32_t*)(keyaddr));
-  hcryp->Instance->IVR1 = __REV(*(uint32_t*)(ivaddr));
+  keyaddr+=4;
-  ivaddr+=4;
+  hcryp->Instance->KEYR1 = __REV(*(uint32_t*)(keyaddr));
-  hcryp->Instance->IVR0 = __REV(*(uint32_t*)(ivaddr));
+  keyaddr+=4;
-}
+  hcryp->Instance->KEYR0 = __REV(*(uint32_t*)(keyaddr));
+}
-/**
-  * @brief  Process Data: Writes Input data in polling mode and reads the output data
+/**
-  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
+  * @brief  Writes the InitVector/InitCounter in IV registers.
-  *         the configuration information for CRYP module
+  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
-  * @param  Input Pointer to the Input buffer
+  *         the configuration information for CRYP module
-  * @param  Ilength Length of the Input buffer, must be a multiple of 16.
+  * @param  InitVector Pointer to InitVector/InitCounter buffer
-  * @param  Output Pointer to the returned buffer
+  * @note Init Vector must be written as little endian.
-  * @param  Timeout Specify Timeout value
+  *         If Init Vector pointer points at address n,
-  * @retval None
+  *         n[15:0] contains Vector[96:127],
-  */
+  *         (n+4)[15:0] contains Vector[64:95],
-static HAL_StatusTypeDef CRYP_ProcessData(CRYP_HandleTypeDef *hcryp, uint8_t* Input, uint16_t Ilength, uint8_t* Output, uint32_t Timeout)
+  *         (n+8)[15:0] contains Vector[32:63] and
-{
+  *         (n+12)[15:0] contains Vector[0:31]
-  uint32_t tickstart = 0;
+  * @retval None
+  */
-  uint32_t index = 0;
+static void CRYP_SetInitVector(CRYP_HandleTypeDef *hcryp, uint8_t *InitVector)
-  uint32_t inputaddr  = (uint32_t)Input;
+{
-  uint32_t outputaddr = (uint32_t)Output;
+  uint32_t ivaddr = (uint32_t)InitVector;
-  for(index=0; (index < Ilength); index += 16)
+  hcryp->Instance->IVR3 = __REV(*(uint32_t*)(ivaddr));
-  {
+  ivaddr+=4;
-    /* Write the Input block in the Data Input register */
+  hcryp->Instance->IVR2 = __REV(*(uint32_t*)(ivaddr));
-    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
+  ivaddr+=4;
-    inputaddr+=4;
+  hcryp->Instance->IVR1 = __REV(*(uint32_t*)(ivaddr));
-    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
+  ivaddr+=4;
-    inputaddr+=4;
+  hcryp->Instance->IVR0 = __REV(*(uint32_t*)(ivaddr));
-    hcryp->Instance->DINR  = *(uint32_t*)(inputaddr);
+}
-    inputaddr+=4;
-    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
+/**
-    inputaddr+=4;
+  * @brief  Process Data: Writes Input data in polling mode and reads the output data
+  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
-    /* Get timeout */
+  *         the configuration information for CRYP module
-    tickstart = HAL_GetTick();
+  * @param  Input Pointer to the Input buffer
+  * @param  Ilength Length of the Input buffer, must be a multiple of 16.
-    while(HAL_IS_BIT_CLR(hcryp->Instance->SR, AES_SR_CCF))
+  * @param  Output Pointer to the returned buffer
-    {
+  * @param  Timeout Specify Timeout value
-      /* Check for the Timeout */
+  * @retval None
-      if(Timeout != HAL_MAX_DELAY)
+  */
-      {
+static HAL_StatusTypeDef CRYP_ProcessData(CRYP_HandleTypeDef *hcryp, uint8_t* Input, uint16_t Ilength, uint8_t* Output, uint32_t Timeout)
-        if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
+{
-        {
+  uint32_t tickstart = 0;
-          /* Change state */
-          hcryp->State = HAL_CRYP_STATE_TIMEOUT;
+  uint32_t index = 0;
+  uint32_t inputaddr  = (uint32_t)Input;
-          /* Process Unlocked */
+  uint32_t outputaddr = (uint32_t)Output;
-          __HAL_UNLOCK(hcryp);
+  for(index=0; (index < Ilength); index += 16)
-          return HAL_TIMEOUT;
+  {
-        }
+    /* Write the Input block in the Data Input register */
-      }
+    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
-    }
+    inputaddr+=4;
-    /* Clear CCF Flag */
+    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
-    __HAL_CRYP_CLEAR_FLAG(hcryp, CRYP_CLEARFLAG_CCF);
+    inputaddr+=4;
+    hcryp->Instance->DINR  = *(uint32_t*)(inputaddr);
-    /* Read the Output block from the Data Output Register */
+    inputaddr+=4;
-    *(uint32_t*)(outputaddr) = hcryp->Instance->DOUTR;
+    hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
-    outputaddr+=4;
+    inputaddr+=4;
-    *(uint32_t*)(outputaddr) = hcryp->Instance->DOUTR;
-    outputaddr+=4;
+    /* Get timeout */
-    *(uint32_t*)(outputaddr) = hcryp->Instance->DOUTR;
+    tickstart = HAL_GetTick();
-    outputaddr+=4;
-    *(uint32_t*)(outputaddr) = hcryp->Instance->DOUTR;
+    while(HAL_IS_BIT_CLR(hcryp->Instance->SR, AES_SR_CCF))
-    outputaddr+=4;
+    {
-  }
+      /* Check for the Timeout */
-  /* Return function status */
+      if(Timeout != HAL_MAX_DELAY)
-  return HAL_OK;
+      {
-}
+        if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
+        {
-/**
+          /* Change state */
-  * @brief  Set the DMA configuration and start the DMA transfer
+          hcryp->State = HAL_CRYP_STATE_TIMEOUT;
-  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
-  *         the configuration information for CRYP module
+          /* Process Unlocked */
-  * @param  inputaddr address of the Input buffer
+          __HAL_UNLOCK(hcryp);
-  * @param  Size Size of the Input buffer, must be a multiple of 16.
-  * @param  outputaddr address of the Output buffer
+          return HAL_TIMEOUT;
-  * @retval None
+        }
-  */
+      }
-static void CRYP_SetDMAConfig(CRYP_HandleTypeDef *hcryp, uint32_t inputaddr, uint16_t Size, uint32_t outputaddr)
+    }
-{
+    /* Clear CCF Flag */
-  /* Set the CRYP DMA transfer complete callback */
+    __HAL_CRYP_CLEAR_FLAG(hcryp, CRYP_CLEARFLAG_CCF);
-  hcryp->hdmain->XferCpltCallback = CRYP_DMAInCplt;
-  /* Set the DMA error callback */
+    /* Read the Output block from the Data Output Register */
-  hcryp->hdmain->XferErrorCallback = CRYP_DMAError;
+    *(uint32_t*)(outputaddr) = hcryp->Instance->DOUTR;
+    outputaddr+=4;
-  /* Set the CRYP DMA transfer complete callback */
+    *(uint32_t*)(outputaddr) = hcryp->Instance->DOUTR;
-  hcryp->hdmaout->XferCpltCallback = CRYP_DMAOutCplt;
+    outputaddr+=4;
-  /* Set the DMA error callback */
+    *(uint32_t*)(outputaddr) = hcryp->Instance->DOUTR;
-  hcryp->hdmaout->XferErrorCallback = CRYP_DMAError;
+    outputaddr+=4;
+    *(uint32_t*)(outputaddr) = hcryp->Instance->DOUTR;
-  /* Enable the DMA In DMA Stream */
+    outputaddr+=4;
-  HAL_DMA_Start_IT(hcryp->hdmain, inputaddr, (uint32_t)&hcryp->Instance->DINR, Size/4);
+  }
+  /* Return function status */
-  /* Enable the DMA Out DMA Stream */
+  return HAL_OK;
-  HAL_DMA_Start_IT(hcryp->hdmaout, (uint32_t)&hcryp->Instance->DOUTR, outputaddr, Size/4);
+}
-  /* Enable In and Out DMA requests */
+/**
-  SET_BIT(hcryp->Instance->CR, (AES_CR_DMAINEN | AES_CR_DMAOUTEN));
+  * @brief  Set the DMA configuration and start the DMA transfer
+  * @param  hcryp pointer to a CRYP_HandleTypeDef structure that contains
-  /* Enable CRYP */
+  *         the configuration information for CRYP module
-  __HAL_CRYP_ENABLE(hcryp);
+  * @param  inputaddr address of the Input buffer
-}
+  * @param  Size Size of the Input buffer, must be a multiple of 16.
+  * @param  outputaddr address of the Output buffer
-/**
+  * @retval None
-  * @}
+  */
-  */
+static void CRYP_SetDMAConfig(CRYP_HandleTypeDef *hcryp, uint32_t inputaddr, uint16_t Size, uint32_t outputaddr)
+{
-#endif /* STM32L162xC || STM32L162xCA || STM32L162xD || STM32L162xE || STM32L162xDX*/
+  /* Set the CRYP DMA transfer complete callback */
+  hcryp->hdmain->XferCpltCallback = CRYP_DMAInCplt;
-/**
+  /* Set the DMA error callback */
-  * @}
+  hcryp->hdmain->XferErrorCallback = CRYP_DMAError;
-  */
+  /* Set the CRYP DMA transfer complete callback */
-/**
+  hcryp->hdmaout->XferCpltCallback = CRYP_DMAOutCplt;
-  * @}
+  /* Set the DMA error callback */
-  */
+  hcryp->hdmaout->XferErrorCallback = CRYP_DMAError;
-#endif /* HAL_CRYP_MODULE_ENABLED */
+  /* Enable the DMA In DMA Stream */
+  HAL_DMA_Start_IT(hcryp->hdmain, inputaddr, (uint32_t)&hcryp->Instance->DINR, Size/4);
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
+  /* Enable the DMA Out DMA Stream */
+  HAL_DMA_Start_IT(hcryp->hdmaout, (uint32_t)&hcryp->Instance->DOUTR, outputaddr, Size/4);
+  /* Enable In and Out DMA requests */
+  SET_BIT(hcryp->Instance->CR, (AES_CR_DMAINEN | AES_CR_DMAOUTEN));
+  /* Enable CRYP */
+  __HAL_CRYP_ENABLE(hcryp);
+}
+/**
+  * @}
+  */
+#endif /* STM32L162xC || STM32L162xCA || STM32L162xD || STM32L162xE || STM32L162xDX*/
+/**
+  * @}
+  */
+/**
+  * @}
+  */
+#endif /* HAL_CRYP_MODULE_ENABLED */

Subversion Repositories DashDisplay

(root)/branches/Dashboard_L152_v2/Drivers/STM32L1xx_HAL_Driver/Src/stm32l1xx_hal_cryp.c – Rev 56 → 77