git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_M7_STM32F7_STM32756G-EVAL_IAR_Keil/ST_Library/stm32f7xx_hal_cryp.c

   1 /**\r
   2   ******************************************************************************\r
   3   * @file    stm32f7xx_hal_cryp.c\r
   4   * @author  MCD Application Team\r
   5   * @version V1.0.0RC1\r
   6   * @date    24-March-2015\r
   7   * @brief   CRYP HAL module driver.\r
   8   *          This file provides firmware functions to manage the following \r
   9   *          functionalities of the Cryptography (CRYP) peripheral:\r
  10   *           + Initialization and de-initialization functions\r
  11   *           + AES processing functions\r
  12   *           + DES processing functions\r
  13   *           + TDES processing functions\r
  14   *           + DMA callback functions\r
  15   *           + CRYP IRQ handler management\r
  16   *           + Peripheral State functions\r
  17   *\r
  18   @verbatim\r
  19   ==============================================================================\r
  20                      ##### How to use this driver #####\r
  21   ==============================================================================\r
  22     [..]\r
  23       The CRYP HAL driver can be used as follows:\r
  24 \r
  25       (#)Initialize the CRYP low level resources by implementing the HAL_CRYP_MspInit():\r
  26          (##) Enable the CRYP interface clock using __HAL_RCC_CRYP_CLK_ENABLE()\r
  27          (##) In case of using interrupts (e.g. HAL_CRYP_AESECB_Encrypt_IT())\r
  28              (+++) Configure the CRYP interrupt priority using HAL_NVIC_SetPriority()\r
  29              (+++) Enable the CRYP IRQ handler using HAL_NVIC_EnableIRQ()\r
  30              (+++) In CRYP IRQ handler, call HAL_CRYP_IRQHandler()\r
  31          (##) In case of using DMA to control data transfer (e.g. HAL_CRYP_AESECB_Encrypt_DMA())\r
  32              (+++) Enable the DMAx interface clock using __DMAx_CLK_ENABLE()\r
  33              (+++) Configure and enable two DMA streams one for managing data transfer from\r
  34                  memory to peripheral (input stream) and another stream for managing data\r
  35                  transfer from peripheral to memory (output stream)\r
  36              (+++) Associate the initialized DMA handle to the CRYP DMA handle\r
  37                  using  __HAL_LINKDMA()\r
  38              (+++) Configure the priority and enable the NVIC for the transfer complete\r
  39                  interrupt on the two DMA Streams. The output stream should have higher\r
  40                  priority than the input stream HAL_NVIC_SetPriority() and HAL_NVIC_EnableIRQ()\r
  41     \r
  42       (#)Initialize the CRYP HAL using HAL_CRYP_Init(). This function configures mainly:\r
  43          (##) The data type: 1-bit, 8-bit, 16-bit and 32-bit\r
  44          (##) The key size: 128, 192 and 256. This parameter is relevant only for AES\r
  45          (##) The encryption/decryption key. It's size depends on the algorithm\r
  46               used for encryption/decryption\r
  47          (##) The initialization vector (counter). It is not used ECB mode.\r
  48     \r
  49       (#)Three processing (encryption/decryption) functions are available:\r
  50          (##) Polling mode: encryption and decryption APIs are blocking functions\r
  51               i.e. they process the data and wait till the processing is finished,\r
  52               e.g. HAL_CRYP_AESCBC_Encrypt()\r
  53          (##) Interrupt mode: encryption and decryption APIs are not blocking functions\r
  54               i.e. they process the data under interrupt,\r
  55               e.g. HAL_CRYP_AESCBC_Encrypt_IT()\r
  56          (##) DMA mode: encryption and decryption APIs are not blocking functions\r
  57               i.e. the data transfer is ensured by DMA,\r
  58               e.g. HAL_CRYP_AESCBC_Encrypt_DMA()\r
  59     \r
  60       (#)When the processing function is called at first time after HAL_CRYP_Init()\r
  61          the CRYP peripheral is initialized and processes the buffer in input.\r
  62          At second call, the processing function performs an append of the already\r
  63          processed buffer.\r
  64          When a new data block is to be processed, call HAL_CRYP_Init() then the\r
  65          processing function.\r
  66     \r
  67        (#)Call HAL_CRYP_DeInit() to deinitialize the CRYP peripheral.\r
  68 \r
  69   @endverbatim\r
  70   ******************************************************************************\r
  71   * @attention\r
  72   *\r
  73   * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>\r
  74   *\r
  75   * Redistribution and use in source and binary forms, with or without modification,\r
  76   * are permitted provided that the following conditions are met:\r
  77   *   1. Redistributions of source code must retain the above copyright notice,\r
  78   *      this list of conditions and the following disclaimer.\r
  79   *   2. Redistributions in binary form must reproduce the above copyright notice,\r
  80   *      this list of conditions and the following disclaimer in the documentation\r
  81   *      and/or other materials provided with the distribution.\r
  82   *   3. Neither the name of STMicroelectronics nor the names of its contributors\r
  83   *      may be used to endorse or promote products derived from this software\r
  84   *      without specific prior written permission.\r
  85   *\r
  86   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"\r
  87   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
  88   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\r
  89   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\r
  90   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\r
  91   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\r
  92   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\r
  93   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\r
  94   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\r
  95   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
  96   *\r
  97   ******************************************************************************\r
  98   */ \r
  99 \r
 100 /* Includes ------------------------------------------------------------------*/\r
 101 #include "stm32f7xx_hal.h"\r
 102 \r
 103 /** @addtogroup STM32F7xx_HAL_Driver\r
 104   * @{\r
 105   */\r
 106 \r
 107 /** @defgroup CRYP CRYP\r
 108   * @brief CRYP HAL module driver.\r
 109   * @{\r
 110   */\r
 111 \r
 112 #ifdef HAL_CRYP_MODULE_ENABLED\r
 113 \r
 114 #if defined(STM32F756xx)\r
 115 \r
 116 /* Private typedef -----------------------------------------------------------*/\r
 117 /* Private define ------------------------------------------------------------*/\r
 118 /** @addtogroup CRYP_Private_define\r
 119   * @{\r
 120   */\r
 121 #define CRYP_TIMEOUT_VALUE  1\r
 122 /**\r
 123   * @}\r
 124   */ \r
 125   \r
 126 /* Private macro -------------------------------------------------------------*/\r
 127 /* Private variables ---------------------------------------------------------*/\r
 128 /* Private function prototypes -----------------------------------------------*/\r
 129 /** @addtogroup CRYP_Private_Functions_prototypes\r
 130   * @{\r
 131   */  \r
 132 static void CRYP_SetInitVector(CRYP_HandleTypeDef *hcryp, uint8_t *InitVector, uint32_t IVSize);\r
 133 static void CRYP_SetKey(CRYP_HandleTypeDef *hcryp, uint8_t *Key, uint32_t KeySize);\r
 134 static HAL_StatusTypeDef CRYP_ProcessData(CRYP_HandleTypeDef *hcryp, uint8_t* Input, uint16_t Ilength, uint8_t* Output, uint32_t Timeout);\r
 135 static HAL_StatusTypeDef CRYP_ProcessData2Words(CRYP_HandleTypeDef *hcryp, uint8_t* Input, uint16_t Ilength, uint8_t* Output, uint32_t Timeout);\r
 136 static void CRYP_DMAInCplt(DMA_HandleTypeDef *hdma);\r
 137 static void CRYP_DMAOutCplt(DMA_HandleTypeDef *hdma);\r
 138 static void CRYP_DMAError(DMA_HandleTypeDef *hdma);\r
 139 static void CRYP_SetDMAConfig(CRYP_HandleTypeDef *hcryp, uint32_t inputaddr, uint16_t Size, uint32_t outputaddr);\r
 140 static void CRYP_SetTDESECBMode(CRYP_HandleTypeDef *hcryp, uint32_t Direction);\r
 141 static void CRYP_SetTDESCBCMode(CRYP_HandleTypeDef *hcryp, uint32_t Direction);\r
 142 static void CRYP_SetDESECBMode(CRYP_HandleTypeDef *hcryp, uint32_t Direction);\r
 143 static void CRYP_SetDESCBCMode(CRYP_HandleTypeDef *hcryp, uint32_t Direction);\r
 144 /**\r
 145   * @}\r
 146   */ \r
 147 /* Private functions ---------------------------------------------------------*/\r
 148 \r
 149 /** @addtogroup CRYP_Private_Functions\r
 150   * @{\r
 151   */\r
 152 \r
 153 /**\r
 154   * @brief  DMA CRYP Input Data process complete callback.\r
 155   * @param  hdma: DMA handle\r
 156   * @retval None\r
 157   */\r
 158 static void CRYP_DMAInCplt(DMA_HandleTypeDef *hdma)  \r
 159 {\r
 160   CRYP_HandleTypeDef* hcryp = (CRYP_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;\r
 161   \r
 162   /* Disable the DMA transfer for input FIFO request by resetting the DIEN bit\r
 163      in the DMACR register */\r
 164   hcryp->Instance->DMACR &= (uint32_t)(~CRYP_DMACR_DIEN);\r
 165   \r
 166   /* Call input data transfer complete callback */\r
 167   HAL_CRYP_InCpltCallback(hcryp);\r
 168 }\r
 169 \r
 170 /**\r
 171   * @brief  DMA CRYP Output Data process complete callback.\r
 172   * @param  hdma: DMA handle\r
 173   * @retval None\r
 174   */\r
 175 static void CRYP_DMAOutCplt(DMA_HandleTypeDef *hdma)\r
 176 {\r
 177   CRYP_HandleTypeDef* hcryp = (CRYP_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;\r
 178   \r
 179   /* Disable the DMA transfer for output FIFO request by resetting the DOEN bit\r
 180      in the DMACR register */\r
 181   hcryp->Instance->DMACR &= (uint32_t)(~CRYP_DMACR_DOEN);\r
 182   \r
 183   /* Disable CRYP */\r
 184   __HAL_CRYP_DISABLE(hcryp);\r
 185   \r
 186   /* Change the CRYP state to ready */\r
 187   hcryp->State = HAL_CRYP_STATE_READY;\r
 188   \r
 189   /* Call output data transfer complete callback */\r
 190   HAL_CRYP_OutCpltCallback(hcryp);\r
 191 }\r
 192 \r
 193 /**\r
 194   * @brief  DMA CRYP communication error callback. \r
 195   * @param  hdma: DMA handle\r
 196   * @retval None\r
 197   */\r
 198 static void CRYP_DMAError(DMA_HandleTypeDef *hdma)\r
 199 {\r
 200   CRYP_HandleTypeDef* hcryp = (CRYP_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;\r
 201   hcryp->State= HAL_CRYP_STATE_READY;\r
 202   HAL_CRYP_ErrorCallback(hcryp);\r
 203 }\r
 204 \r
 205 /**\r
 206   * @brief  Writes the Key in Key registers. \r
 207   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
 208   *         the configuration information for CRYP module\r
 209   * @param  Key: Pointer to Key buffer\r
 210   * @param  KeySize: Size of Key\r
 211   * @retval None\r
 212   */\r
 213 static void CRYP_SetKey(CRYP_HandleTypeDef *hcryp, uint8_t *Key, uint32_t KeySize)\r
 214 {\r
 215   uint32_t keyaddr = (uint32_t)Key;\r
 216   \r
 217   switch(KeySize)\r
 218   {\r
 219   case CRYP_KEYSIZE_256B:\r
 220     /* Key Initialisation */\r
 221     hcryp->Instance->K0LR = __REV(*(uint32_t*)(keyaddr));\r
 222     keyaddr+=4;\r
 223     hcryp->Instance->K0RR = __REV(*(uint32_t*)(keyaddr));\r
 224     keyaddr+=4;\r
 225     hcryp->Instance->K1LR = __REV(*(uint32_t*)(keyaddr));\r
 226     keyaddr+=4;\r
 227     hcryp->Instance->K1RR = __REV(*(uint32_t*)(keyaddr));\r
 228     keyaddr+=4;\r
 229     hcryp->Instance->K2LR = __REV(*(uint32_t*)(keyaddr));\r
 230     keyaddr+=4;\r
 231     hcryp->Instance->K2RR = __REV(*(uint32_t*)(keyaddr));\r
 232     keyaddr+=4;\r
 233     hcryp->Instance->K3LR = __REV(*(uint32_t*)(keyaddr));\r
 234     keyaddr+=4;\r
 235     hcryp->Instance->K3RR = __REV(*(uint32_t*)(keyaddr));\r
 236     break;\r
 237   case CRYP_KEYSIZE_192B:\r
 238     hcryp->Instance->K1LR = __REV(*(uint32_t*)(keyaddr));\r
 239     keyaddr+=4;\r
 240     hcryp->Instance->K1RR = __REV(*(uint32_t*)(keyaddr));\r
 241     keyaddr+=4;\r
 242     hcryp->Instance->K2LR = __REV(*(uint32_t*)(keyaddr));\r
 243     keyaddr+=4;\r
 244     hcryp->Instance->K2RR = __REV(*(uint32_t*)(keyaddr));\r
 245     keyaddr+=4;\r
 246     hcryp->Instance->K3LR = __REV(*(uint32_t*)(keyaddr));\r
 247     keyaddr+=4;\r
 248     hcryp->Instance->K3RR = __REV(*(uint32_t*)(keyaddr));\r
 249     break;\r
 250   case CRYP_KEYSIZE_128B:       \r
 251     hcryp->Instance->K2LR = __REV(*(uint32_t*)(keyaddr));\r
 252     keyaddr+=4;\r
 253     hcryp->Instance->K2RR = __REV(*(uint32_t*)(keyaddr));\r
 254     keyaddr+=4;\r
 255     hcryp->Instance->K3LR = __REV(*(uint32_t*)(keyaddr));\r
 256     keyaddr+=4;\r
 257     hcryp->Instance->K3RR = __REV(*(uint32_t*)(keyaddr));\r
 258     break;\r
 259   default:\r
 260     break;\r
 261   }\r
 262 }\r
 263 \r
 264 /**\r
 265   * @brief  Writes the InitVector/InitCounter in IV registers. \r
 266   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
 267   *         the configuration information for CRYP module\r
 268   * @param  InitVector: Pointer to InitVector/InitCounter buffer\r
 269   * @param  IVSize: Size of the InitVector/InitCounter\r
 270   * @retval None\r
 271   */\r
 272 static void CRYP_SetInitVector(CRYP_HandleTypeDef *hcryp, uint8_t *InitVector, uint32_t IVSize)\r
 273 {\r
 274   uint32_t ivaddr = (uint32_t)InitVector;\r
 275   \r
 276   switch(IVSize)\r
 277   {\r
 278   case CRYP_KEYSIZE_128B:\r
 279     hcryp->Instance->IV0LR = __REV(*(uint32_t*)(ivaddr));\r
 280     ivaddr+=4;\r
 281     hcryp->Instance->IV0RR = __REV(*(uint32_t*)(ivaddr));\r
 282     ivaddr+=4;\r
 283     hcryp->Instance->IV1LR = __REV(*(uint32_t*)(ivaddr));\r
 284     ivaddr+=4;\r
 285     hcryp->Instance->IV1RR = __REV(*(uint32_t*)(ivaddr));\r
 286     break;\r
 287     /* Whatever key size 192 or 256, Init vector is written in IV0LR and IV0RR */\r
 288   case CRYP_KEYSIZE_192B:\r
 289     hcryp->Instance->IV0LR = __REV(*(uint32_t*)(ivaddr));\r
 290     ivaddr+=4;\r
 291     hcryp->Instance->IV0RR = __REV(*(uint32_t*)(ivaddr));\r
 292     break;\r
 293   case CRYP_KEYSIZE_256B:\r
 294     hcryp->Instance->IV0LR = __REV(*(uint32_t*)(ivaddr));\r
 295     ivaddr+=4;\r
 296     hcryp->Instance->IV0RR = __REV(*(uint32_t*)(ivaddr));\r
 297     break;\r
 298   default:\r
 299     break;\r
 300   }\r
 301 }\r
 302 \r
 303 /**\r
 304   * @brief  Process Data: Writes Input data in polling mode and read the output data\r
 305   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
 306   *         the configuration information for CRYP module\r
 307   * @param  Input: Pointer to the Input buffer\r
 308   * @param  Ilength: Length of the Input buffer, must be a multiple of 16.\r
 309   * @param  Output: Pointer to the returned buffer\r
 310   * @param  Timeout: Timeout value\r
 311   * @retval None\r
 312   */\r
 313 static HAL_StatusTypeDef CRYP_ProcessData(CRYP_HandleTypeDef *hcryp, uint8_t* Input, uint16_t Ilength, uint8_t* Output, uint32_t Timeout)\r
 314 {\r
 315   uint32_t tickstart = 0;\r
 316   \r
 317   uint32_t i = 0;\r
 318   uint32_t inputaddr  = (uint32_t)Input;\r
 319   uint32_t outputaddr = (uint32_t)Output;\r
 320   \r
 321   for(i=0; (i < Ilength); i+=16)\r
 322   {\r
 323     /* Write the Input block in the IN FIFO */\r
 324     hcryp->Instance->DR = *(uint32_t*)(inputaddr);\r
 325     inputaddr+=4;\r
 326     hcryp->Instance->DR = *(uint32_t*)(inputaddr);\r
 327     inputaddr+=4;\r
 328     hcryp->Instance->DR  = *(uint32_t*)(inputaddr);\r
 329     inputaddr+=4;\r
 330     hcryp->Instance->DR = *(uint32_t*)(inputaddr);\r
 331     inputaddr+=4;\r
 332     \r
 333     /* Get tick */\r
 334     tickstart = HAL_GetTick();\r
 335 \r
 336     while(HAL_IS_BIT_CLR(hcryp->Instance->SR, CRYP_FLAG_OFNE))\r
 337     {    \r
 338       /* Check for the Timeout */\r
 339       if(Timeout != HAL_MAX_DELAY)\r
 340       {\r
 341         if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))\r
 342         {\r
 343           /* Change state */\r
 344           hcryp->State = HAL_CRYP_STATE_TIMEOUT;\r
 345           \r
 346           /* Process Unlocked */\r
 347           __HAL_UNLOCK(hcryp);\r
 348         \r
 349           return HAL_TIMEOUT;\r
 350         }\r
 351       }\r
 352     }\r
 353     /* Read the Output block from the Output FIFO */\r
 354     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
 355     outputaddr+=4;\r
 356     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
 357     outputaddr+=4;\r
 358     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
 359     outputaddr+=4;\r
 360     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
 361     outputaddr+=4;\r
 362   }\r
 363   /* Return function status */\r
 364   return HAL_OK;\r
 365 }\r
 366 \r
 367 /**\r
 368   * @brief  Process Data: Write Input data in polling mode. \r
 369   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
 370   *         the configuration information for CRYP module\r
 371   * @param  Input: Pointer to the Input buffer\r
 372   * @param  Ilength: Length of the Input buffer, must be a multiple of 8\r
 373   * @param  Output: Pointer to the returned buffer\r
 374   * @param  Timeout: Specify Timeout value  \r
 375   * @retval None\r
 376   */\r
 377 static HAL_StatusTypeDef CRYP_ProcessData2Words(CRYP_HandleTypeDef *hcryp, uint8_t* Input, uint16_t Ilength, uint8_t* Output, uint32_t Timeout)\r
 378 {\r
 379   uint32_t tickstart = 0;   \r
 380   \r
 381   uint32_t i = 0;\r
 382   uint32_t inputaddr  = (uint32_t)Input;\r
 383   uint32_t outputaddr = (uint32_t)Output;\r
 384   \r
 385   for(i=0; (i < Ilength); i+=8)\r
 386   {\r
 387     /* Write the Input block in the IN FIFO */\r
 388     hcryp->Instance->DR  = *(uint32_t*)(inputaddr);\r
 389     inputaddr+=4;\r
 390     hcryp->Instance->DR = *(uint32_t*)(inputaddr);\r
 391     inputaddr+=4;\r
 392     \r
 393     /* Get tick */\r
 394     tickstart = HAL_GetTick();\r
 395     \r
 396     while(HAL_IS_BIT_CLR(hcryp->Instance->SR, CRYP_FLAG_OFNE))\r
 397     {\r
 398       /* Check for the Timeout */\r
 399       if(Timeout != HAL_MAX_DELAY)\r
 400       {\r
 401         if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))\r
 402         {\r
 403           /* Change state */\r
 404           hcryp->State = HAL_CRYP_STATE_TIMEOUT;\r
 405           \r
 406           /* Process Unlocked */          \r
 407           __HAL_UNLOCK(hcryp);\r
 408           \r
 409           return HAL_TIMEOUT;\r
 410         }\r
 411       }\r
 412     }\r
 413     /* Read the Output block from the Output FIFO */\r
 414     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
 415     outputaddr+=4;\r
 416     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
 417     outputaddr+=4;\r
 418   }\r
 419   /* Return function status */\r
 420   return HAL_OK;\r
 421 }\r
 422 \r
 423 /**\r
 424   * @brief  Set the DMA configuration and start the DMA transfer\r
 425   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
 426   *         the configuration information for CRYP module\r
 427   * @param  inputaddr: address of the Input buffer\r
 428   * @param  Size: Size of the Input buffer, must be a multiple of 16.\r
 429   * @param  outputaddr: address of the Output buffer\r
 430   * @retval None\r
 431   */\r
 432 static void CRYP_SetDMAConfig(CRYP_HandleTypeDef *hcryp, uint32_t inputaddr, uint16_t Size, uint32_t outputaddr)\r
 433 {\r
 434   /* Set the CRYP DMA transfer complete callback */\r
 435   hcryp->hdmain->XferCpltCallback = CRYP_DMAInCplt;\r
 436   /* Set the DMA error callback */\r
 437   hcryp->hdmain->XferErrorCallback = CRYP_DMAError;\r
 438   \r
 439   /* Set the CRYP DMA transfer complete callback */\r
 440   hcryp->hdmaout->XferCpltCallback = CRYP_DMAOutCplt;\r
 441   /* Set the DMA error callback */\r
 442   hcryp->hdmaout->XferErrorCallback = CRYP_DMAError;\r
 443   \r
 444   /* Enable CRYP */\r
 445   __HAL_CRYP_ENABLE(hcryp);\r
 446   \r
 447   /* Enable the DMA In DMA Stream */\r
 448   HAL_DMA_Start_IT(hcryp->hdmain, inputaddr, (uint32_t)&hcryp->Instance->DR, Size/4);\r
 449 \r
 450   /* Enable In DMA request */\r
 451   hcryp->Instance->DMACR = (CRYP_DMACR_DIEN);\r
 452   \r
 453   /* Enable the DMA Out DMA Stream */\r
 454   HAL_DMA_Start_IT(hcryp->hdmaout, (uint32_t)&hcryp->Instance->DOUT, outputaddr, Size/4);\r
 455   \r
 456   /* Enable Out DMA request */\r
 457   hcryp->Instance->DMACR |= CRYP_DMACR_DOEN;\r
 458  \r
 459 }\r
 460 \r
 461 /**\r
 462   * @brief  Sets the CRYP peripheral in DES ECB mode.\r
 463   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
 464   *         the configuration information for CRYP module\r
 465   * @param  Direction: Encryption or decryption\r
 466   * @retval None\r
 467   */\r
 468 static void CRYP_SetDESECBMode(CRYP_HandleTypeDef *hcryp, uint32_t Direction)\r
 469 {\r
 470   /* Check if initialization phase has already been performed */\r
 471   if(hcryp->Phase == HAL_CRYP_PHASE_READY)\r
 472   {\r
 473     /* Set the CRYP peripheral in AES ECB mode */\r
 474     __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_DES_ECB | Direction);\r
 475     \r
 476     /* Set the key */\r
 477     hcryp->Instance->K1LR = __REV(*(uint32_t*)(hcryp->Init.pKey));\r
 478     hcryp->Instance->K1RR = __REV(*(uint32_t*)(hcryp->Init.pKey+4));\r
 479     \r
 480     /* Flush FIFO */\r
 481     __HAL_CRYP_FIFO_FLUSH(hcryp);\r
 482     \r
 483     /* Set the phase */\r
 484     hcryp->Phase = HAL_CRYP_PHASE_PROCESS;\r
 485   }\r
 486 }\r
 487 \r
 488 /**\r
 489   * @brief  Sets the CRYP peripheral in DES CBC mode.\r
 490   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
 491   *         the configuration information for CRYP module\r
 492   * @param  Direction: Encryption or decryption\r
 493   * @retval None\r
 494   */\r
 495 static void CRYP_SetDESCBCMode(CRYP_HandleTypeDef *hcryp, uint32_t Direction)\r
 496 {\r
 497   /* Check if initialization phase has already been performed */\r
 498   if(hcryp->Phase == HAL_CRYP_PHASE_READY)\r
 499   {\r
 500     /* Set the CRYP peripheral in AES ECB mode */\r
 501     __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_DES_CBC | Direction);\r
 502     \r
 503     /* Set the key */\r
 504     hcryp->Instance->K1LR = __REV(*(uint32_t*)(hcryp->Init.pKey));\r
 505     hcryp->Instance->K1RR = __REV(*(uint32_t*)(hcryp->Init.pKey+4));\r
 506     \r
 507     /* Set the Initialization Vector */\r
 508     CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect, CRYP_KEYSIZE_256B);\r
 509     \r
 510     /* Flush FIFO */\r
 511     __HAL_CRYP_FIFO_FLUSH(hcryp);\r
 512     \r
 513     /* Set the phase */\r
 514     hcryp->Phase = HAL_CRYP_PHASE_PROCESS;\r
 515   }\r
 516 }\r
 517 \r
 518 /**\r
 519   * @brief  Sets the CRYP peripheral in TDES ECB mode.\r
 520   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
 521   *         the configuration information for CRYP module\r
 522   * @param  Direction: Encryption or decryption\r
 523   * @retval None\r
 524   */\r
 525 static void CRYP_SetTDESECBMode(CRYP_HandleTypeDef *hcryp, uint32_t Direction)\r
 526 {\r
 527   /* Check if initialization phase has already been performed */\r
 528   if(hcryp->Phase == HAL_CRYP_PHASE_READY)\r
 529   {\r
 530     /* Set the CRYP peripheral in AES ECB mode */\r
 531     __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_TDES_ECB | Direction);\r
 532     \r
 533     /* Set the key */\r
 534     CRYP_SetKey(hcryp, hcryp->Init.pKey, CRYP_KEYSIZE_192B);\r
 535     \r
 536     /* Flush FIFO */\r
 537     __HAL_CRYP_FIFO_FLUSH(hcryp);\r
 538     \r
 539     /* Set the phase */\r
 540     hcryp->Phase = HAL_CRYP_PHASE_PROCESS;\r
 541   }\r
 542 }\r
 543 \r
 544 /**\r
 545   * @brief  Sets the CRYP peripheral in TDES CBC mode\r
 546   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
 547   *         the configuration information for CRYP module\r
 548   * @param  Direction: Encryption or decryption\r
 549   * @retval None\r
 550   */\r
 551 static void CRYP_SetTDESCBCMode(CRYP_HandleTypeDef *hcryp, uint32_t Direction)\r
 552 {\r
 553   /* Check if initialization phase has already been performed */\r
 554   if(hcryp->Phase == HAL_CRYP_PHASE_READY)\r
 555   {\r
 556     /* Set the CRYP peripheral in AES CBC mode */\r
 557     __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_TDES_CBC | Direction);\r
 558     \r
 559     /* Set the key */\r
 560     CRYP_SetKey(hcryp, hcryp->Init.pKey, CRYP_KEYSIZE_192B);\r
 561     \r
 562     /* Set the Initialization Vector */\r
 563     CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect, CRYP_KEYSIZE_256B);\r
 564     \r
 565     /* Flush FIFO */\r
 566     __HAL_CRYP_FIFO_FLUSH(hcryp);\r
 567     \r
 568     /* Set the phase */\r
 569     hcryp->Phase = HAL_CRYP_PHASE_PROCESS;\r
 570   }\r
 571 }\r
 572 \r
 573 /**\r
 574   * @}\r
 575   */ \r
 576   \r
 577  /* Exported functions --------------------------------------------------------*/\r
 578 /** @addtogroup CRYP_Exported_Functions\r
 579   * @{\r
 580   */ \r
 581   \r
 582 /** @defgroup CRYP_Exported_Functions_Group1 Initialization and de-initialization functions \r
 583  *  @brief    Initialization and Configuration functions. \r
 584  *\r
 585 @verbatim    \r
 586   ==============================================================================\r
 587               ##### Initialization and de-initialization functions #####\r
 588   ==============================================================================\r
 589     [..]  This section provides functions allowing to:\r
 590       (+) Initialize the CRYP according to the specified parameters \r
 591           in the CRYP_InitTypeDef and creates the associated handle\r
 592       (+) DeInitialize the CRYP peripheral\r
 593       (+) Initialize the CRYP MSP\r
 594       (+) DeInitialize CRYP MSP \r
 595  \r
 596 @endverbatim\r
 597   * @{\r
 598   */\r
 599 \r
 600 /**\r
 601   * @brief  Initializes the CRYP according to the specified\r
 602   *         parameters in the CRYP_InitTypeDef and creates the associated handle.\r
 603   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
 604   *         the configuration information for CRYP module\r
 605   * @retval HAL status\r
 606   */\r
 607 HAL_StatusTypeDef HAL_CRYP_Init(CRYP_HandleTypeDef *hcryp)\r
 608 { \r
 609   /* Check the CRYP handle allocation */\r
 610   if(hcryp == NULL)\r
 611   {\r
 612     return HAL_ERROR;\r
 613   }\r
 614 \r
 615   /* Check the parameters */\r
 616   assert_param(IS_CRYP_KEYSIZE(hcryp->Init.KeySize));\r
 617   assert_param(IS_CRYP_DATATYPE(hcryp->Init.DataType));\r
 618     \r
 619   if(hcryp->State == HAL_CRYP_STATE_RESET)\r
 620   {\r
 621     /* Allocate lock resource and initialize it */\r
 622     hcryp->Lock = HAL_UNLOCKED;\r
 623     /* Init the low level hardware */\r
 624     HAL_CRYP_MspInit(hcryp);\r
 625   }\r
 626   \r
 627   /* Change the CRYP state */\r
 628   hcryp->State = HAL_CRYP_STATE_BUSY;\r
 629   \r
 630   /* Set the key size and data type*/\r
 631   CRYP->CR = (uint32_t) (hcryp->Init.KeySize | hcryp->Init.DataType);\r
 632   \r
 633   /* Reset CrypInCount and CrypOutCount */\r
 634   hcryp->CrypInCount = 0;\r
 635   hcryp->CrypOutCount = 0;\r
 636   \r
 637   /* Change the CRYP state */\r
 638   hcryp->State = HAL_CRYP_STATE_READY;\r
 639   \r
 640   /* Set the default CRYP phase */\r
 641   hcryp->Phase = HAL_CRYP_PHASE_READY;\r
 642   \r
 643   /* Return function status */\r
 644   return HAL_OK;\r
 645 }\r
 646 \r
 647 /**\r
 648   * @brief  DeInitializes the CRYP peripheral. \r
 649   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
 650   *         the configuration information for CRYP module\r
 651   * @retval HAL status\r
 652   */\r
 653 HAL_StatusTypeDef HAL_CRYP_DeInit(CRYP_HandleTypeDef *hcryp)\r
 654 {\r
 655   /* Check the CRYP handle allocation */\r
 656   if(hcryp == NULL)\r
 657   {\r
 658     return HAL_ERROR;\r
 659   }\r
 660   \r
 661   /* Change the CRYP state */\r
 662   hcryp->State = HAL_CRYP_STATE_BUSY;\r
 663   \r
 664   /* Set the default CRYP phase */\r
 665   hcryp->Phase = HAL_CRYP_PHASE_READY;\r
 666   \r
 667   /* Reset CrypInCount and CrypOutCount */\r
 668   hcryp->CrypInCount = 0;\r
 669   hcryp->CrypOutCount = 0;\r
 670   \r
 671   /* Disable the CRYP Peripheral Clock */\r
 672   __HAL_CRYP_DISABLE(hcryp);\r
 673   \r
 674   /* DeInit the low level hardware: CLOCK, NVIC.*/\r
 675   HAL_CRYP_MspDeInit(hcryp);\r
 676   \r
 677   /* Change the CRYP state */\r
 678   hcryp->State = HAL_CRYP_STATE_RESET;\r
 679 \r
 680   /* Release Lock */\r
 681   __HAL_UNLOCK(hcryp);\r
 682 \r
 683   /* Return function status */\r
 684   return HAL_OK;\r
 685 }\r
 686 \r
 687 /**\r
 688   * @brief  Initializes the CRYP MSP.\r
 689   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
 690   *         the configuration information for CRYP module\r
 691   * @retval None\r
 692   */\r
 693 __weak void HAL_CRYP_MspInit(CRYP_HandleTypeDef *hcryp)\r
 694 {\r
 695   /* NOTE : This function Should not be modified, when the callback is needed,\r
 696             the HAL_CRYP_MspInit could be implemented in the user file\r
 697    */\r
 698 }\r
 699 \r
 700 /**\r
 701   * @brief  DeInitializes CRYP MSP.\r
 702   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
 703   *         the configuration information for CRYP module\r
 704   * @retval None\r
 705   */\r
 706 __weak void HAL_CRYP_MspDeInit(CRYP_HandleTypeDef *hcryp)\r
 707 {\r
 708   /* NOTE : This function Should not be modified, when the callback is needed,\r
 709             the HAL_CRYP_MspDeInit could be implemented in the user file\r
 710    */\r
 711 }\r
 712 \r
 713 /**\r
 714   * @}\r
 715   */\r
 716 \r
 717 /** @defgroup CRYP_Exported_Functions_Group2 AES processing functions \r
 718  *  @brief   processing functions. \r
 719  *\r
 720 @verbatim   \r
 721   ==============================================================================\r
 722                       ##### AES processing functions #####\r
 723   ==============================================================================  \r
 724     [..]  This section provides functions allowing to:\r
 725       (+) Encrypt plaintext using AES-128/192/256 using chaining modes\r
 726       (+) Decrypt cyphertext using AES-128/192/256 using chaining modes\r
 727     [..]  Three processing functions are available:\r
 728       (+) Polling mode\r
 729       (+) Interrupt mode\r
 730       (+) DMA mode\r
 731 \r
 732 @endverbatim\r
 733   * @{\r
 734   */\r
 735 \r
 736 /**\r
 737   * @brief  Initializes the CRYP peripheral in AES ECB encryption mode\r
 738   *         then encrypt pPlainData. The cypher data are available in pCypherData\r
 739   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
 740   *         the configuration information for CRYP module\r
 741   * @param  pPlainData: Pointer to the plaintext buffer\r
 742   * @param  Size: Length of the plaintext buffer, must be a multiple of 16.\r
 743   * @param  pCypherData: Pointer to the cyphertext buffer\r
 744   * @param  Timeout: Specify Timeout value \r
 745   * @retval HAL status\r
 746   */\r
 747 HAL_StatusTypeDef HAL_CRYP_AESECB_Encrypt(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData, uint32_t Timeout)\r
 748 {\r
 749   /* Process Locked */\r
 750   __HAL_LOCK(hcryp);\r
 751   \r
 752   /* Change the CRYP state */\r
 753   hcryp->State = HAL_CRYP_STATE_BUSY;\r
 754   \r
 755   /* Check if initialization phase has already been performed */\r
 756   if(hcryp->Phase == HAL_CRYP_PHASE_READY)\r
 757   {\r
 758     /* Set the key */\r
 759     CRYP_SetKey(hcryp, hcryp->Init.pKey, hcryp->Init.KeySize);\r
 760     \r
 761     /* Set the CRYP peripheral in AES ECB mode */\r
 762     __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_ECB);\r
 763     \r
 764     /* Flush FIFO */\r
 765     __HAL_CRYP_FIFO_FLUSH(hcryp);\r
 766     \r
 767     /* Enable CRYP */\r
 768     __HAL_CRYP_ENABLE(hcryp);\r
 769     \r
 770     /* Set the phase */\r
 771     hcryp->Phase = HAL_CRYP_PHASE_PROCESS;\r
 772   }\r
 773   \r
 774     /* Write Plain Data and Get Cypher Data */\r
 775     if(CRYP_ProcessData(hcryp, pPlainData, Size, pCypherData, Timeout) != HAL_OK)\r
 776     {\r
 777       return HAL_TIMEOUT;\r
 778     }\r
 779   \r
 780   /* Change the CRYP state */\r
 781   hcryp->State = HAL_CRYP_STATE_READY;\r
 782   \r
 783   /* Process Unlocked */\r
 784   __HAL_UNLOCK(hcryp);\r
 785   \r
 786   /* Return function status */\r
 787   return HAL_OK;\r
 788 }\r
 789 \r
 790 /**\r
 791   * @brief  Initializes the CRYP peripheral in AES CBC encryption mode\r
 792   *         then encrypt pPlainData. The cypher data are available in pCypherData\r
 793   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
 794   *         the configuration information for CRYP module\r
 795   * @param  pPlainData: Pointer to the plaintext buffer\r
 796   * @param  Size: Length of the plaintext buffer, must be a multiple of 16.\r
 797   * @param  pCypherData: Pointer to the cyphertext buffer\r
 798   * @param  Timeout: Specify Timeout value  \r
 799   * @retval HAL status\r
 800   */\r
 801 HAL_StatusTypeDef HAL_CRYP_AESCBC_Encrypt(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData, uint32_t Timeout)\r
 802 {\r
 803   /* Process Locked */\r
 804   __HAL_LOCK(hcryp);\r
 805   \r
 806   /* Change the CRYP state */\r
 807   hcryp->State = HAL_CRYP_STATE_BUSY;\r
 808   \r
 809   /* Check if initialization phase has already been performed */\r
 810   if(hcryp->Phase == HAL_CRYP_PHASE_READY)\r
 811   {\r
 812     /* Set the key */\r
 813     CRYP_SetKey(hcryp, hcryp->Init.pKey, hcryp->Init.KeySize);\r
 814     \r
 815     /* Set the CRYP peripheral in AES ECB mode */\r
 816     __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CBC);\r
 817     \r
 818     /* Set the Initialization Vector */\r
 819     CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect, CRYP_KEYSIZE_128B);\r
 820     \r
 821     /* Flush FIFO */\r
 822     __HAL_CRYP_FIFO_FLUSH(hcryp);\r
 823     \r
 824     /* Enable CRYP */\r
 825     __HAL_CRYP_ENABLE(hcryp);\r
 826     \r
 827     /* Set the phase */\r
 828     hcryp->Phase = HAL_CRYP_PHASE_PROCESS;\r
 829   }\r
 830   \r
 831     /* Write Plain Data and Get Cypher Data */\r
 832     if(CRYP_ProcessData(hcryp,pPlainData, Size, pCypherData, Timeout) != HAL_OK)\r
 833     {\r
 834       return HAL_TIMEOUT;\r
 835     }\r
 836   \r
 837   /* Change the CRYP state */\r
 838   hcryp->State = HAL_CRYP_STATE_READY;\r
 839   \r
 840   /* Process Unlocked */\r
 841   __HAL_UNLOCK(hcryp);\r
 842   \r
 843   /* Return function status */\r
 844   return HAL_OK;\r
 845 }\r
 846 \r
 847 /**\r
 848   * @brief  Initializes the CRYP peripheral in AES CTR encryption mode\r
 849   *         then encrypt pPlainData. The cypher data are available in pCypherData\r
 850   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
 851   *         the configuration information for CRYP module\r
 852   * @param  pPlainData: Pointer to the plaintext buffer\r
 853   * @param  Size: Length of the plaintext buffer, must be a multiple of 16.\r
 854   * @param  pCypherData: Pointer to the cyphertext buffer\r
 855   * @param  Timeout: Specify Timeout value  \r
 856   * @retval HAL status\r
 857   */\r
 858 HAL_StatusTypeDef HAL_CRYP_AESCTR_Encrypt(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData, uint32_t Timeout)\r
 859 {  \r
 860   /* Process Locked */\r
 861   __HAL_LOCK(hcryp);\r
 862   \r
 863   /* Change the CRYP state */\r
 864   hcryp->State = HAL_CRYP_STATE_BUSY;\r
 865   \r
 866   /* Check if initialization phase has already been performed */\r
 867   if(hcryp->Phase == HAL_CRYP_PHASE_READY)\r
 868   {\r
 869     /* Set the key */\r
 870     CRYP_SetKey(hcryp, hcryp->Init.pKey, hcryp->Init.KeySize);\r
 871     \r
 872     /* Set the CRYP peripheral in AES ECB mode */\r
 873     __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CTR);\r
 874     \r
 875     /* Set the Initialization Vector */\r
 876     CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect, CRYP_KEYSIZE_128B);\r
 877     \r
 878     /* Flush FIFO */\r
 879     __HAL_CRYP_FIFO_FLUSH(hcryp);\r
 880     \r
 881     /* Enable CRYP */\r
 882     __HAL_CRYP_ENABLE(hcryp);\r
 883     \r
 884     /* Set the phase */\r
 885     hcryp->Phase = HAL_CRYP_PHASE_PROCESS;\r
 886   }\r
 887   \r
 888     /* Write Plain Data and Get Cypher Data */\r
 889     if(CRYP_ProcessData(hcryp, pPlainData, Size, pCypherData, Timeout) != HAL_OK)\r
 890     {\r
 891       return HAL_TIMEOUT;\r
 892     }\r
 893   \r
 894   /* Change the CRYP state */\r
 895   hcryp->State = HAL_CRYP_STATE_READY;\r
 896   \r
 897   /* Process Unlocked */\r
 898   __HAL_UNLOCK(hcryp);\r
 899   \r
 900   /* Return function status */\r
 901   return HAL_OK;\r
 902 }\r
 903 \r
 904 \r
 905 \r
 906 /**\r
 907   * @brief  Initializes the CRYP peripheral in AES ECB decryption mode\r
 908   *         then decrypted pCypherData. The cypher data are available in pPlainData\r
 909   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
 910   *         the configuration information for CRYP module\r
 911   * @param  pCypherData: Pointer to the cyphertext buffer\r
 912   * @param  Size: Length of the plaintext buffer, must be a multiple of 16.\r
 913   * @param  pPlainData: Pointer to the plaintext buffer\r
 914   * @param  Timeout: Specify Timeout value  \r
 915   * @retval HAL status\r
 916   */\r
 917 HAL_StatusTypeDef HAL_CRYP_AESECB_Decrypt(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData, uint32_t Timeout)\r
 918 {\r
 919    uint32_t tickstart = 0;\r
 920   \r
 921   /* Process Locked */\r
 922   __HAL_LOCK(hcryp);\r
 923   \r
 924   /* Change the CRYP state */\r
 925   hcryp->State = HAL_CRYP_STATE_BUSY;\r
 926   \r
 927   /* Check if initialization phase has already been performed */\r
 928   if(hcryp->Phase == HAL_CRYP_PHASE_READY)\r
 929   {\r
 930     /* Set the key */\r
 931     CRYP_SetKey(hcryp, hcryp->Init.pKey, hcryp->Init.KeySize);\r
 932     \r
 933     /* Set the CRYP peripheral in AES Key mode */\r
 934     __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_KEY | CRYP_CR_ALGODIR);\r
 935     \r
 936     /* Enable CRYP */\r
 937     __HAL_CRYP_ENABLE(hcryp);\r
 938     \r
 939     /* Get tick */ \r
 940     tickstart = HAL_GetTick();\r
 941 \r
 942     while(HAL_IS_BIT_SET(hcryp->Instance->SR, CRYP_FLAG_BUSY))\r
 943     {\r
 944       /* Check for the Timeout */\r
 945       if(Timeout != HAL_MAX_DELAY)\r
 946       {\r
 947         if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))\r
 948         {\r
 949           /* Change state */\r
 950           hcryp->State = HAL_CRYP_STATE_TIMEOUT;\r
 951           \r
 952           /* Process Unlocked */          \r
 953           __HAL_UNLOCK(hcryp);\r
 954         \r
 955           return HAL_TIMEOUT;\r
 956         }\r
 957       }\r
 958     }\r
 959     \r
 960     /* Disable CRYP */\r
 961     __HAL_CRYP_DISABLE(hcryp);\r
 962     \r
 963     /* Reset the ALGOMODE bits*/\r
 964     CRYP->CR &= (uint32_t)(~CRYP_CR_ALGOMODE);\r
 965     \r
 966     /* Set the CRYP peripheral in AES ECB decryption mode */\r
 967     __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_ECB | CRYP_CR_ALGODIR);\r
 968     /* Flush FIFO */\r
 969     __HAL_CRYP_FIFO_FLUSH(hcryp);\r
 970     \r
 971     /* Enable CRYP */\r
 972     __HAL_CRYP_ENABLE(hcryp);\r
 973     \r
 974     /* Set the phase */\r
 975     hcryp->Phase = HAL_CRYP_PHASE_PROCESS;\r
 976   }\r
 977     \r
 978     /* Write Plain Data and Get Cypher Data */\r
 979     if(CRYP_ProcessData(hcryp, pCypherData, Size, pPlainData, Timeout) != HAL_OK)\r
 980     {\r
 981       return HAL_TIMEOUT;\r
 982     }\r
 983   \r
 984   /* Change the CRYP state */\r
 985   hcryp->State = HAL_CRYP_STATE_READY;\r
 986   \r
 987   /* Process Unlocked */\r
 988   __HAL_UNLOCK(hcryp);\r
 989   \r
 990   /* Return function status */\r
 991   return HAL_OK;\r
 992 }\r
 993 \r
 994 /**\r
 995   * @brief  Initializes the CRYP peripheral in AES ECB decryption mode\r
 996   *         then decrypted pCypherData. The cypher data are available in pPlainData\r
 997   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
 998   *         the configuration information for CRYP module\r
 999   * @param  pCypherData: Pointer to the cyphertext buffer\r
1000   * @param  Size: Length of the plaintext buffer, must be a multiple of 16.\r
1001   * @param  pPlainData: Pointer to the plaintext buffer\r
1002   * @param  Timeout: Specify Timeout value  \r
1003   * @retval HAL status\r
1004   */\r
1005 HAL_StatusTypeDef HAL_CRYP_AESCBC_Decrypt(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData, uint32_t Timeout)\r
1006 {\r
1007   uint32_t tickstart = 0;\r
1008   \r
1009   /* Process Locked */\r
1010   __HAL_LOCK(hcryp);\r
1011   \r
1012   /* Change the CRYP state */\r
1013   hcryp->State = HAL_CRYP_STATE_BUSY;\r
1014   \r
1015   /* Check if initialization phase has already been performed */\r
1016   if(hcryp->Phase == HAL_CRYP_PHASE_READY)\r
1017   {\r
1018     /* Set the key */\r
1019     CRYP_SetKey(hcryp, hcryp->Init.pKey, hcryp->Init.KeySize);\r
1020     \r
1021     /* Set the CRYP peripheral in AES Key mode */\r
1022     __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_KEY | CRYP_CR_ALGODIR);\r
1023     \r
1024     /* Enable CRYP */\r
1025     __HAL_CRYP_ENABLE(hcryp);\r
1026     \r
1027     /* Get tick */ \r
1028     tickstart = HAL_GetTick();\r
1029 \r
1030     while(HAL_IS_BIT_SET(hcryp->Instance->SR, CRYP_FLAG_BUSY))\r
1031     {\r
1032       /* Check for the Timeout */\r
1033       if(Timeout != HAL_MAX_DELAY)\r
1034       {\r
1035         if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))\r
1036         {\r
1037           /* Change state */\r
1038           hcryp->State = HAL_CRYP_STATE_TIMEOUT;\r
1039           \r
1040           /* Process Unlocked */\r
1041           __HAL_UNLOCK(hcryp);\r
1042           \r
1043           return HAL_TIMEOUT;\r
1044         }\r
1045       }\r
1046     }\r
1047     \r
1048     /* Reset the ALGOMODE bits*/\r
1049     CRYP->CR &= (uint32_t)(~CRYP_CR_ALGOMODE);\r
1050     \r
1051     /* Set the CRYP peripheral in AES CBC decryption mode */\r
1052     __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CBC | CRYP_CR_ALGODIR);\r
1053     \r
1054     /* Set the Initialization Vector */\r
1055     CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect, CRYP_KEYSIZE_128B);\r
1056     \r
1057     /* Flush FIFO */\r
1058     __HAL_CRYP_FIFO_FLUSH(hcryp);\r
1059     \r
1060     /* Enable CRYP */\r
1061     __HAL_CRYP_ENABLE(hcryp);\r
1062     \r
1063     /* Set the phase */\r
1064     hcryp->Phase = HAL_CRYP_PHASE_PROCESS;\r
1065   }\r
1066   \r
1067     /* Write Plain Data and Get Cypher Data */\r
1068     if(CRYP_ProcessData(hcryp, pCypherData, Size, pPlainData, Timeout) != HAL_OK)\r
1069     {\r
1070       return HAL_TIMEOUT;\r
1071     }\r
1072   \r
1073   /* Change the CRYP state */\r
1074   hcryp->State = HAL_CRYP_STATE_READY;\r
1075   \r
1076   /* Process Unlocked */\r
1077   __HAL_UNLOCK(hcryp);\r
1078   \r
1079   /* Return function status */\r
1080   return HAL_OK;\r
1081 }\r
1082 \r
1083 /**\r
1084   * @brief  Initializes the CRYP peripheral in AES CTR decryption mode\r
1085   *         then decrypted pCypherData. The cypher data are available in pPlainData\r
1086   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
1087   *         the configuration information for CRYP module\r
1088   * @param  pCypherData: Pointer to the cyphertext buffer\r
1089   * @param  Size: Length of the plaintext buffer, must be a multiple of 16.\r
1090   * @param  pPlainData: Pointer to the plaintext buffer\r
1091   * @param  Timeout: Specify Timeout value  \r
1092   * @retval HAL status\r
1093   */\r
1094 HAL_StatusTypeDef HAL_CRYP_AESCTR_Decrypt(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData, uint32_t Timeout)\r
1095 {  \r
1096   /* Process Locked */\r
1097   __HAL_LOCK(hcryp);\r
1098   \r
1099   /* Check if initialization phase has already been performed */\r
1100   if(hcryp->Phase == HAL_CRYP_PHASE_READY)\r
1101   {\r
1102     /* Change the CRYP state */\r
1103     hcryp->State = HAL_CRYP_STATE_BUSY;\r
1104     \r
1105     /* Set the key */\r
1106     CRYP_SetKey(hcryp, hcryp->Init.pKey, hcryp->Init.KeySize);\r
1107     \r
1108     /* Set the CRYP peripheral in AES CTR mode */\r
1109     __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CTR | CRYP_CR_ALGODIR);\r
1110     \r
1111     /* Set the Initialization Vector */\r
1112     CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect, CRYP_KEYSIZE_128B);\r
1113     \r
1114     /* Flush FIFO */\r
1115     __HAL_CRYP_FIFO_FLUSH(hcryp);\r
1116     \r
1117     /* Enable CRYP */\r
1118     __HAL_CRYP_ENABLE(hcryp);\r
1119     \r
1120     /* Set the phase */\r
1121     hcryp->Phase = HAL_CRYP_PHASE_PROCESS;\r
1122   }\r
1123   \r
1124     /* Write Plain Data and Get Cypher Data */\r
1125     if(CRYP_ProcessData(hcryp, pCypherData, Size, pPlainData, Timeout) != HAL_OK)\r
1126     {\r
1127       return HAL_TIMEOUT;\r
1128     }\r
1129   \r
1130   /* Change the CRYP state */\r
1131   hcryp->State = HAL_CRYP_STATE_READY;\r
1132   \r
1133   /* Process Unlocked */\r
1134   __HAL_UNLOCK(hcryp);\r
1135   \r
1136   /* Return function status */\r
1137   return HAL_OK;\r
1138 }\r
1139 \r
1140 /**\r
1141   * @brief  Initializes the CRYP peripheral in AES ECB encryption mode using Interrupt.\r
1142   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
1143   *         the configuration information for CRYP module\r
1144   * @param  pPlainData: Pointer to the plaintext buffer\r
1145   * @param  Size: Length of the plaintext buffer, must be a multiple of 16 bytes\r
1146   * @param  pCypherData: Pointer to the cyphertext buffer\r
1147   * @retval HAL status\r
1148   */\r
1149 HAL_StatusTypeDef HAL_CRYP_AESECB_Encrypt_IT(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData)\r
1150 {\r
1151   uint32_t inputaddr;\r
1152   uint32_t outputaddr;\r
1153   \r
1154   if(hcryp->State == HAL_CRYP_STATE_READY)\r
1155   {\r
1156     /* Process Locked */\r
1157     __HAL_LOCK(hcryp);\r
1158     \r
1159     hcryp->CrypInCount = Size;\r
1160     hcryp->pCrypInBuffPtr = pPlainData;\r
1161     hcryp->pCrypOutBuffPtr = pCypherData;\r
1162     hcryp->CrypOutCount = Size;\r
1163     \r
1164     /* Change the CRYP state */\r
1165     hcryp->State = HAL_CRYP_STATE_BUSY;\r
1166     \r
1167     /* Check if initialization phase has already been performed */\r
1168     if(hcryp->Phase == HAL_CRYP_PHASE_READY)\r
1169     {\r
1170       /* Set the key */\r
1171       CRYP_SetKey(hcryp, hcryp->Init.pKey, hcryp->Init.KeySize);\r
1172       \r
1173       /* Set the CRYP peripheral in AES ECB mode */\r
1174       __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_ECB);\r
1175       \r
1176       /* Flush FIFO */\r
1177       __HAL_CRYP_FIFO_FLUSH(hcryp);\r
1178       \r
1179      /* Set the phase */\r
1180      hcryp->Phase = HAL_CRYP_PHASE_PROCESS;\r
1181     }\r
1182     \r
1183     /* Enable Interrupts */\r
1184     __HAL_CRYP_ENABLE_IT(hcryp, CRYP_IT_INI | CRYP_IT_OUTI);\r
1185     \r
1186     /* Enable CRYP */\r
1187     __HAL_CRYP_ENABLE(hcryp);\r
1188     \r
1189     /* Return function status */\r
1190     return HAL_OK;\r
1191   }\r
1192   else if(__HAL_CRYP_GET_IT(hcryp, CRYP_IT_INI))\r
1193   {\r
1194     inputaddr = (uint32_t)hcryp->pCrypInBuffPtr;\r
1195     /* Write the Input block in the IN FIFO */\r
1196     hcryp->Instance->DR = *(uint32_t*)(inputaddr);\r
1197     inputaddr+=4;\r
1198     hcryp->Instance->DR = *(uint32_t*)(inputaddr);\r
1199     inputaddr+=4;\r
1200     hcryp->Instance->DR  = *(uint32_t*)(inputaddr);\r
1201     inputaddr+=4;\r
1202     hcryp->Instance->DR = *(uint32_t*)(inputaddr);\r
1203     hcryp->pCrypInBuffPtr += 16;\r
1204     hcryp->CrypInCount -= 16;\r
1205     if(hcryp->CrypInCount == 0)\r
1206     {\r
1207       __HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_INI);\r
1208       /* Call the Input data transfer complete callback */\r
1209       HAL_CRYP_InCpltCallback(hcryp);\r
1210     }\r
1211   }\r
1212   else if(__HAL_CRYP_GET_IT(hcryp, CRYP_IT_OUTI))\r
1213   {\r
1214     outputaddr = (uint32_t)hcryp->pCrypOutBuffPtr;\r
1215     /* Read the Output block from the Output FIFO */\r
1216     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
1217     outputaddr+=4;\r
1218     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
1219     outputaddr+=4;\r
1220     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
1221     outputaddr+=4;\r
1222     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
1223     hcryp->pCrypOutBuffPtr += 16;\r
1224     hcryp->CrypOutCount -= 16;\r
1225     if(hcryp->CrypOutCount == 0)\r
1226     {\r
1227       __HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_OUTI);\r
1228       /* Process Locked */\r
1229       __HAL_UNLOCK(hcryp);\r
1230       /* Change the CRYP state */\r
1231       hcryp->State = HAL_CRYP_STATE_READY;\r
1232       /* Call Input transfer complete callback */\r
1233       HAL_CRYP_OutCpltCallback(hcryp);\r
1234     }\r
1235   }\r
1236   \r
1237   /* Return function status */\r
1238   return HAL_OK;\r
1239 }\r
1240 \r
1241 /**\r
1242   * @brief  Initializes the CRYP peripheral in AES CBC encryption mode using Interrupt.\r
1243   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
1244   *         the configuration information for CRYP module\r
1245   * @param  pPlainData: Pointer to the plaintext buffer\r
1246   * @param  Size: Length of the plaintext buffer, must be a multiple of 16 bytes\r
1247   * @param  pCypherData: Pointer to the cyphertext buffer\r
1248   * @retval HAL status\r
1249   */\r
1250 HAL_StatusTypeDef HAL_CRYP_AESCBC_Encrypt_IT(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData)\r
1251 {\r
1252   uint32_t inputaddr;\r
1253   uint32_t outputaddr;\r
1254   \r
1255   if(hcryp->State == HAL_CRYP_STATE_READY)\r
1256   {\r
1257     /* Process Locked */\r
1258     __HAL_LOCK(hcryp);\r
1259     \r
1260     hcryp->CrypInCount = Size;\r
1261     hcryp->pCrypInBuffPtr = pPlainData;\r
1262     hcryp->pCrypOutBuffPtr = pCypherData;\r
1263     hcryp->CrypOutCount = Size;\r
1264     \r
1265     /* Change the CRYP state */\r
1266     hcryp->State = HAL_CRYP_STATE_BUSY;\r
1267     \r
1268     /* Check if initialization phase has already been performed */\r
1269     if(hcryp->Phase == HAL_CRYP_PHASE_READY)\r
1270     {      \r
1271       /* Set the key */\r
1272       CRYP_SetKey(hcryp, hcryp->Init.pKey, hcryp->Init.KeySize);\r
1273       \r
1274       /* Set the CRYP peripheral in AES CBC mode */\r
1275       __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CBC);\r
1276       \r
1277       /* Set the Initialization Vector */\r
1278       CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect, CRYP_KEYSIZE_128B);\r
1279       \r
1280       /* Flush FIFO */\r
1281       __HAL_CRYP_FIFO_FLUSH(hcryp);\r
1282       \r
1283      /* Set the phase */\r
1284      hcryp->Phase = HAL_CRYP_PHASE_PROCESS;\r
1285     }\r
1286     /* Enable Interrupts */\r
1287     __HAL_CRYP_ENABLE_IT(hcryp, CRYP_IT_INI | CRYP_IT_OUTI);\r
1288     \r
1289     /* Enable CRYP */\r
1290     __HAL_CRYP_ENABLE(hcryp);\r
1291     \r
1292     /* Return function status */\r
1293     return HAL_OK;\r
1294   }\r
1295   else if(__HAL_CRYP_GET_IT(hcryp, CRYP_IT_INI))\r
1296   {\r
1297     inputaddr = (uint32_t)hcryp->pCrypInBuffPtr;\r
1298     /* Write the Input block in the IN FIFO */\r
1299     hcryp->Instance->DR = *(uint32_t*)(inputaddr);\r
1300     inputaddr+=4;\r
1301     hcryp->Instance->DR = *(uint32_t*)(inputaddr);\r
1302     inputaddr+=4;\r
1303     hcryp->Instance->DR  = *(uint32_t*)(inputaddr);\r
1304     inputaddr+=4;\r
1305     hcryp->Instance->DR = *(uint32_t*)(inputaddr);\r
1306     hcryp->pCrypInBuffPtr += 16;\r
1307     hcryp->CrypInCount -= 16;\r
1308     if(hcryp->CrypInCount == 0)\r
1309     {\r
1310       __HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_INI);\r
1311       /* Call the Input data transfer complete callback */\r
1312       HAL_CRYP_InCpltCallback(hcryp);\r
1313     }\r
1314   }\r
1315   else if(__HAL_CRYP_GET_IT(hcryp, CRYP_IT_OUTI))\r
1316   {\r
1317     outputaddr = (uint32_t)hcryp->pCrypOutBuffPtr;\r
1318     /* Read the Output block from the Output FIFO */\r
1319     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
1320     outputaddr+=4;\r
1321     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
1322     outputaddr+=4;\r
1323     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
1324     outputaddr+=4;\r
1325     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
1326     hcryp->pCrypOutBuffPtr += 16;\r
1327     hcryp->CrypOutCount -= 16;\r
1328     if(hcryp->CrypOutCount == 0)\r
1329     {\r
1330       __HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_OUTI);\r
1331       /* Process Locked */\r
1332       __HAL_UNLOCK(hcryp);\r
1333       /* Change the CRYP state */\r
1334       hcryp->State = HAL_CRYP_STATE_READY;\r
1335       /* Call Input transfer complete callback */\r
1336       HAL_CRYP_OutCpltCallback(hcryp);\r
1337     }\r
1338   }\r
1339   \r
1340   /* Return function status */\r
1341   return HAL_OK;\r
1342 }\r
1343 \r
1344 /**\r
1345   * @brief  Initializes the CRYP peripheral in AES CTR encryption mode using Interrupt.\r
1346   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
1347   *         the configuration information for CRYP module\r
1348   * @param  pPlainData: Pointer to the plaintext buffer\r
1349   * @param  Size: Length of the plaintext buffer, must be a multiple of 16 bytes\r
1350   * @param  pCypherData: Pointer to the cyphertext buffer\r
1351   * @retval HAL status\r
1352   */\r
1353 HAL_StatusTypeDef HAL_CRYP_AESCTR_Encrypt_IT(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData)\r
1354 {\r
1355   uint32_t inputaddr;\r
1356   uint32_t outputaddr;\r
1357   \r
1358   if(hcryp->State == HAL_CRYP_STATE_READY)\r
1359   {\r
1360     /* Process Locked */\r
1361     __HAL_LOCK(hcryp);\r
1362     \r
1363     hcryp->CrypInCount = Size;\r
1364     hcryp->pCrypInBuffPtr = pPlainData;\r
1365     hcryp->pCrypOutBuffPtr = pCypherData;\r
1366     hcryp->CrypOutCount = Size;\r
1367     \r
1368     /* Change the CRYP state */\r
1369     hcryp->State = HAL_CRYP_STATE_BUSY;\r
1370     \r
1371     /* Check if initialization phase has already been performed */\r
1372     if(hcryp->Phase == HAL_CRYP_PHASE_READY)\r
1373     {\r
1374       /* Set the key */\r
1375       CRYP_SetKey(hcryp, hcryp->Init.pKey, hcryp->Init.KeySize);\r
1376       \r
1377       /* Set the CRYP peripheral in AES CTR mode */\r
1378       __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CTR);\r
1379       \r
1380       /* Set the Initialization Vector */\r
1381       CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect, CRYP_KEYSIZE_128B);\r
1382       \r
1383       /* Flush FIFO */\r
1384       __HAL_CRYP_FIFO_FLUSH(hcryp);\r
1385       \r
1386      /* Set the phase */\r
1387      hcryp->Phase = HAL_CRYP_PHASE_PROCESS;\r
1388     }\r
1389     /* Enable Interrupts */\r
1390     __HAL_CRYP_ENABLE_IT(hcryp, CRYP_IT_INI | CRYP_IT_OUTI);\r
1391     \r
1392     /* Enable CRYP */\r
1393     __HAL_CRYP_ENABLE(hcryp);\r
1394     \r
1395     /* Return function status */\r
1396     return HAL_OK;\r
1397   }\r
1398   else if(__HAL_CRYP_GET_IT(hcryp, CRYP_IT_INI))\r
1399   {\r
1400     inputaddr = (uint32_t)hcryp->pCrypInBuffPtr;\r
1401     /* Write the Input block in the IN FIFO */\r
1402     hcryp->Instance->DR = *(uint32_t*)(inputaddr);\r
1403     inputaddr+=4;\r
1404     hcryp->Instance->DR = *(uint32_t*)(inputaddr);\r
1405     inputaddr+=4;\r
1406     hcryp->Instance->DR  = *(uint32_t*)(inputaddr);\r
1407     inputaddr+=4;\r
1408     hcryp->Instance->DR = *(uint32_t*)(inputaddr);\r
1409     hcryp->pCrypInBuffPtr += 16;\r
1410     hcryp->CrypInCount -= 16;\r
1411     if(hcryp->CrypInCount == 0)\r
1412     {\r
1413       __HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_INI);\r
1414       /* Call the Input data transfer complete callback */\r
1415       HAL_CRYP_InCpltCallback(hcryp);\r
1416     }\r
1417   }\r
1418   else if(__HAL_CRYP_GET_IT(hcryp, CRYP_IT_OUTI))\r
1419   {\r
1420     outputaddr = (uint32_t)hcryp->pCrypOutBuffPtr;\r
1421     /* Read the Output block from the Output FIFO */\r
1422     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
1423     outputaddr+=4;\r
1424     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
1425     outputaddr+=4;\r
1426     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
1427     outputaddr+=4;\r
1428     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
1429     hcryp->pCrypOutBuffPtr += 16;\r
1430     hcryp->CrypOutCount -= 16;\r
1431     if(hcryp->CrypOutCount == 0)\r
1432     {\r
1433       __HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_OUTI);\r
1434       /* Process Unlocked */\r
1435       __HAL_UNLOCK(hcryp);\r
1436       /* Change the CRYP state */\r
1437       hcryp->State = HAL_CRYP_STATE_READY;\r
1438       /* Call Input transfer complete callback */\r
1439       HAL_CRYP_OutCpltCallback(hcryp);\r
1440     }\r
1441   }\r
1442   \r
1443   /* Return function status */\r
1444   return HAL_OK;\r
1445 }\r
1446 \r
1447 \r
1448 /**\r
1449   * @brief  Initializes the CRYP peripheral in AES ECB decryption mode using Interrupt.\r
1450   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
1451   *         the configuration information for CRYP module\r
1452   * @param  pCypherData: Pointer to the cyphertext buffer\r
1453   * @param  Size: Length of the plaintext buffer, must be a multiple of 16.\r
1454   * @param  pPlainData: Pointer to the plaintext buffer\r
1455   * @retval HAL status\r
1456   */\r
1457 HAL_StatusTypeDef HAL_CRYP_AESECB_Decrypt_IT(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData)\r
1458 {\r
1459   uint32_t tickstart = 0;\r
1460 \r
1461   uint32_t inputaddr;\r
1462   uint32_t outputaddr;\r
1463   \r
1464   if(hcryp->State == HAL_CRYP_STATE_READY)\r
1465   {\r
1466     /* Process Locked */\r
1467     __HAL_LOCK(hcryp);\r
1468     \r
1469     hcryp->CrypInCount = Size;\r
1470     hcryp->pCrypInBuffPtr = pCypherData;\r
1471     hcryp->pCrypOutBuffPtr = pPlainData;\r
1472     hcryp->CrypOutCount = Size;\r
1473     \r
1474     /* Change the CRYP state */\r
1475     hcryp->State = HAL_CRYP_STATE_BUSY;\r
1476     \r
1477   /* Check if initialization phase has already been performed */\r
1478   if(hcryp->Phase == HAL_CRYP_PHASE_READY)\r
1479   {\r
1480     /* Set the key */\r
1481     CRYP_SetKey(hcryp, hcryp->Init.pKey, hcryp->Init.KeySize);\r
1482     \r
1483     /* Set the CRYP peripheral in AES Key mode */\r
1484     __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_KEY | CRYP_CR_ALGODIR);\r
1485     /* Enable CRYP */\r
1486     __HAL_CRYP_ENABLE(hcryp);\r
1487     \r
1488     /* Get tick */ \r
1489     tickstart = HAL_GetTick();\r
1490 \r
1491     while(HAL_IS_BIT_SET(hcryp->Instance->SR, CRYP_FLAG_BUSY))\r
1492     {\r
1493       /* Check for the Timeout */\r
1494       if((HAL_GetTick() - tickstart ) > CRYP_TIMEOUT_VALUE)\r
1495       {\r
1496         /* Change state */\r
1497         hcryp->State = HAL_CRYP_STATE_TIMEOUT;\r
1498         \r
1499         /* Process Unlocked */\r
1500         __HAL_UNLOCK(hcryp);\r
1501         \r
1502         return HAL_TIMEOUT;\r
1503       }\r
1504     }\r
1505     \r
1506     /* Reset the ALGOMODE bits*/\r
1507     CRYP->CR &= (uint32_t)(~CRYP_CR_ALGOMODE);\r
1508     \r
1509     /* Set the CRYP peripheral in AES ECB decryption mode */\r
1510     __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_ECB | CRYP_CR_ALGODIR);\r
1511     \r
1512     /* Flush FIFO */\r
1513     __HAL_CRYP_FIFO_FLUSH(hcryp);\r
1514     \r
1515      /* Set the phase */\r
1516      hcryp->Phase = HAL_CRYP_PHASE_PROCESS;\r
1517   }\r
1518      \r
1519     /* Enable Interrupts */\r
1520     __HAL_CRYP_ENABLE_IT(hcryp, CRYP_IT_INI | CRYP_IT_OUTI);\r
1521     \r
1522     /* Enable CRYP */\r
1523     __HAL_CRYP_ENABLE(hcryp);\r
1524     \r
1525     /* Return function status */\r
1526     return HAL_OK;\r
1527   }\r
1528   else if(__HAL_CRYP_GET_IT(hcryp, CRYP_IT_INI))\r
1529   {\r
1530     inputaddr = (uint32_t)hcryp->pCrypInBuffPtr;\r
1531     /* Write the Input block in the IN FIFO */\r
1532     hcryp->Instance->DR = *(uint32_t*)(inputaddr);\r
1533     inputaddr+=4;\r
1534     hcryp->Instance->DR = *(uint32_t*)(inputaddr);\r
1535     inputaddr+=4;\r
1536     hcryp->Instance->DR  = *(uint32_t*)(inputaddr);\r
1537     inputaddr+=4;\r
1538     hcryp->Instance->DR = *(uint32_t*)(inputaddr);\r
1539     hcryp->pCrypInBuffPtr += 16;\r
1540     hcryp->CrypInCount -= 16;\r
1541     if(hcryp->CrypInCount == 0)\r
1542     {\r
1543       __HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_INI);\r
1544       /* Call the Input data transfer complete callback */\r
1545       HAL_CRYP_InCpltCallback(hcryp);\r
1546     }\r
1547   }\r
1548   else if(__HAL_CRYP_GET_IT(hcryp, CRYP_IT_OUTI))\r
1549   {\r
1550     outputaddr = (uint32_t)hcryp->pCrypOutBuffPtr;\r
1551     /* Read the Output block from the Output FIFO */\r
1552     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
1553     outputaddr+=4;\r
1554     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
1555     outputaddr+=4;\r
1556     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
1557     outputaddr+=4;\r
1558     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
1559     hcryp->pCrypOutBuffPtr += 16;\r
1560     hcryp->CrypOutCount -= 16;\r
1561     if(hcryp->CrypOutCount == 0)\r
1562     {\r
1563       __HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_OUTI);\r
1564       /* Process Unlocked */\r
1565       __HAL_UNLOCK(hcryp);\r
1566       /* Change the CRYP state */\r
1567       hcryp->State = HAL_CRYP_STATE_READY;\r
1568       /* Call Input transfer complete callback */\r
1569       HAL_CRYP_OutCpltCallback(hcryp);\r
1570     }\r
1571   }\r
1572   \r
1573   /* Return function status */\r
1574   return HAL_OK;\r
1575 }\r
1576 \r
1577 /**\r
1578   * @brief  Initializes the CRYP peripheral in AES CBC decryption mode using IT.\r
1579   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
1580   *         the configuration information for CRYP module\r
1581   * @param  pCypherData: Pointer to the cyphertext buffer\r
1582   * @param  Size: Length of the plaintext buffer, must be a multiple of 16\r
1583   * @param  pPlainData: Pointer to the plaintext buffer\r
1584   * @retval HAL status\r
1585   */\r
1586 HAL_StatusTypeDef HAL_CRYP_AESCBC_Decrypt_IT(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData)\r
1587 {\r
1588 \r
1589   uint32_t tickstart = 0;   \r
1590   uint32_t inputaddr;\r
1591   uint32_t outputaddr;\r
1592   \r
1593   if(hcryp->State == HAL_CRYP_STATE_READY)\r
1594   {\r
1595     /* Process Locked */\r
1596     __HAL_LOCK(hcryp);\r
1597     \r
1598     /* Get the buffer addresses and sizes */    \r
1599     hcryp->CrypInCount = Size;\r
1600     hcryp->pCrypInBuffPtr = pCypherData;\r
1601     hcryp->pCrypOutBuffPtr = pPlainData;\r
1602     hcryp->CrypOutCount = Size;\r
1603     \r
1604     /* Change the CRYP state */\r
1605     hcryp->State = HAL_CRYP_STATE_BUSY;\r
1606     \r
1607     /* Check if initialization phase has already been performed */\r
1608     if(hcryp->Phase == HAL_CRYP_PHASE_READY)\r
1609     {\r
1610       /* Set the key */\r
1611       CRYP_SetKey(hcryp, hcryp->Init.pKey, hcryp->Init.KeySize);\r
1612       \r
1613       /* Set the CRYP peripheral in AES Key mode */\r
1614       __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_KEY | CRYP_CR_ALGODIR);\r
1615       \r
1616       /* Enable CRYP */\r
1617       __HAL_CRYP_ENABLE(hcryp);\r
1618       \r
1619     /* Get tick */\r
1620     tickstart = HAL_GetTick();\r
1621 \r
1622     while(HAL_IS_BIT_SET(hcryp->Instance->SR, CRYP_FLAG_BUSY))\r
1623     {\r
1624       /* Check for the Timeout */\r
1625       if((HAL_GetTick() - tickstart ) > CRYP_TIMEOUT_VALUE)\r
1626       {\r
1627         /* Change state */\r
1628         hcryp->State = HAL_CRYP_STATE_TIMEOUT;\r
1629         \r
1630         /* Process Unlocked */\r
1631         __HAL_UNLOCK(hcryp);\r
1632         \r
1633         return HAL_TIMEOUT;\r
1634       }\r
1635     }\r
1636     \r
1637       /* Reset the ALGOMODE bits*/\r
1638       CRYP->CR &= (uint32_t)(~CRYP_CR_ALGOMODE);\r
1639     \r
1640       /* Set the CRYP peripheral in AES CBC decryption mode */\r
1641       __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CBC | CRYP_CR_ALGODIR);\r
1642     \r
1643       /* Set the Initialization Vector */\r
1644       CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect, CRYP_KEYSIZE_128B);\r
1645     \r
1646       /* Flush FIFO */\r
1647       __HAL_CRYP_FIFO_FLUSH(hcryp);\r
1648     \r
1649       /* Enable CRYP */\r
1650       __HAL_CRYP_ENABLE(hcryp);\r
1651       \r
1652       /* Set the phase */\r
1653       hcryp->Phase = HAL_CRYP_PHASE_PROCESS;\r
1654     }\r
1655     \r
1656     /* Enable Interrupts */\r
1657     __HAL_CRYP_ENABLE_IT(hcryp, CRYP_IT_INI | CRYP_IT_OUTI);\r
1658     \r
1659     /* Enable CRYP */\r
1660     __HAL_CRYP_ENABLE(hcryp);\r
1661     \r
1662     /* Return function status */\r
1663     return HAL_OK;\r
1664   }\r
1665   else if(__HAL_CRYP_GET_IT(hcryp, CRYP_IT_INI))\r
1666   {\r
1667     inputaddr = (uint32_t)hcryp->pCrypInBuffPtr;\r
1668     /* Write the Input block in the IN FIFO */\r
1669     hcryp->Instance->DR = *(uint32_t*)(inputaddr);\r
1670     inputaddr+=4;\r
1671     hcryp->Instance->DR = *(uint32_t*)(inputaddr);\r
1672     inputaddr+=4;\r
1673     hcryp->Instance->DR  = *(uint32_t*)(inputaddr);\r
1674     inputaddr+=4;\r
1675     hcryp->Instance->DR = *(uint32_t*)(inputaddr);\r
1676     hcryp->pCrypInBuffPtr += 16;\r
1677     hcryp->CrypInCount -= 16;\r
1678     if(hcryp->CrypInCount == 0)\r
1679     {\r
1680       __HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_INI);\r
1681       /* Call the Input data transfer complete callback */\r
1682       HAL_CRYP_InCpltCallback(hcryp);\r
1683     }\r
1684   }\r
1685   else if(__HAL_CRYP_GET_IT(hcryp, CRYP_IT_OUTI))\r
1686   {\r
1687     outputaddr = (uint32_t)hcryp->pCrypOutBuffPtr;\r
1688     /* Read the Output block from the Output FIFO */\r
1689     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
1690     outputaddr+=4;\r
1691     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
1692     outputaddr+=4;\r
1693     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
1694     outputaddr+=4;\r
1695     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
1696     hcryp->pCrypOutBuffPtr += 16;\r
1697     hcryp->CrypOutCount -= 16;\r
1698     if(hcryp->CrypOutCount == 0)\r
1699     {\r
1700       __HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_OUTI);\r
1701       /* Process Unlocked */\r
1702       __HAL_UNLOCK(hcryp);\r
1703       /* Change the CRYP state */\r
1704       hcryp->State = HAL_CRYP_STATE_READY;\r
1705       /* Call Input transfer complete callback */\r
1706       HAL_CRYP_OutCpltCallback(hcryp);\r
1707     }\r
1708   }\r
1709   \r
1710   /* Return function status */\r
1711   return HAL_OK;\r
1712 }\r
1713 \r
1714 /**\r
1715   * @brief  Initializes the CRYP peripheral in AES CTR decryption mode using Interrupt.\r
1716   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
1717   *         the configuration information for CRYP module\r
1718   * @param  pCypherData: Pointer to the cyphertext buffer\r
1719   * @param  Size: Length of the plaintext buffer, must be a multiple of 16\r
1720   * @param  pPlainData: Pointer to the plaintext buffer\r
1721   * @retval HAL status\r
1722   */\r
1723 HAL_StatusTypeDef HAL_CRYP_AESCTR_Decrypt_IT(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData)\r
1724 {\r
1725   uint32_t inputaddr;\r
1726   uint32_t outputaddr;\r
1727   \r
1728   if(hcryp->State == HAL_CRYP_STATE_READY)\r
1729   {\r
1730     /* Process Locked */\r
1731     __HAL_LOCK(hcryp);\r
1732     \r
1733     /* Get the buffer addresses and sizes */    \r
1734     hcryp->CrypInCount = Size;\r
1735     hcryp->pCrypInBuffPtr = pCypherData;\r
1736     hcryp->pCrypOutBuffPtr = pPlainData;\r
1737     hcryp->CrypOutCount = Size;\r
1738     \r
1739     /* Change the CRYP state */\r
1740     hcryp->State = HAL_CRYP_STATE_BUSY;\r
1741     \r
1742     /* Check if initialization phase has already been performed */\r
1743     if(hcryp->Phase == HAL_CRYP_PHASE_READY)\r
1744     {\r
1745       /* Set the key */\r
1746       CRYP_SetKey(hcryp, hcryp->Init.pKey, hcryp->Init.KeySize);\r
1747       \r
1748       /* Set the CRYP peripheral in AES CTR mode */\r
1749       __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CTR | CRYP_CR_ALGODIR);\r
1750       \r
1751       /* Set the Initialization Vector */\r
1752       CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect, CRYP_KEYSIZE_128B);\r
1753       \r
1754       /* Flush FIFO */\r
1755       __HAL_CRYP_FIFO_FLUSH(hcryp);\r
1756       \r
1757       /* Set the phase */\r
1758       hcryp->Phase = HAL_CRYP_PHASE_PROCESS;\r
1759     }\r
1760     \r
1761     /* Enable Interrupts */\r
1762     __HAL_CRYP_ENABLE_IT(hcryp, CRYP_IT_INI | CRYP_IT_OUTI);\r
1763     \r
1764     /* Enable CRYP */\r
1765     __HAL_CRYP_ENABLE(hcryp);\r
1766     \r
1767     /* Return function status */\r
1768     return HAL_OK;\r
1769   }\r
1770   else if(__HAL_CRYP_GET_IT(hcryp, CRYP_IT_INI))\r
1771   {\r
1772     inputaddr = (uint32_t)hcryp->pCrypInBuffPtr;\r
1773     /* Write the Input block in the IN FIFO */\r
1774     hcryp->Instance->DR = *(uint32_t*)(inputaddr);\r
1775     inputaddr+=4;\r
1776     hcryp->Instance->DR = *(uint32_t*)(inputaddr);\r
1777     inputaddr+=4;\r
1778     hcryp->Instance->DR  = *(uint32_t*)(inputaddr);\r
1779     inputaddr+=4;\r
1780     hcryp->Instance->DR = *(uint32_t*)(inputaddr);\r
1781     hcryp->pCrypInBuffPtr += 16;\r
1782     hcryp->CrypInCount -= 16;\r
1783     if(hcryp->CrypInCount == 0)\r
1784     {\r
1785       __HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_INI);\r
1786       /* Call the Input data transfer complete callback */\r
1787       HAL_CRYP_InCpltCallback(hcryp);\r
1788     }\r
1789   }\r
1790   else if(__HAL_CRYP_GET_IT(hcryp, CRYP_IT_OUTI))\r
1791   {\r
1792     outputaddr = (uint32_t)hcryp->pCrypOutBuffPtr;\r
1793     /* Read the Output block from the Output FIFO */\r
1794     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
1795     outputaddr+=4;\r
1796     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
1797     outputaddr+=4;\r
1798     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
1799     outputaddr+=4;\r
1800     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
1801     hcryp->pCrypOutBuffPtr += 16;\r
1802     hcryp->CrypOutCount -= 16;\r
1803     if(hcryp->CrypOutCount == 0)\r
1804     {\r
1805       __HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_OUTI);\r
1806       /* Process Unlocked */\r
1807       __HAL_UNLOCK(hcryp);\r
1808       /* Change the CRYP state */\r
1809       hcryp->State = HAL_CRYP_STATE_READY;\r
1810       /* Call Input transfer complete callback */\r
1811       HAL_CRYP_OutCpltCallback(hcryp);\r
1812     }\r
1813   }\r
1814   \r
1815   /* Return function status */\r
1816   return HAL_OK;\r
1817 }\r
1818 \r
1819 /**\r
1820   * @brief  Initializes the CRYP peripheral in AES ECB encryption mode using DMA.\r
1821   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
1822   *         the configuration information for CRYP module\r
1823   * @param  pPlainData: Pointer to the plaintext buffer\r
1824   * @param  Size: Length of the plaintext buffer, must be a multiple of 16 bytes\r
1825   * @param  pCypherData: Pointer to the cyphertext buffer\r
1826   * @retval HAL status\r
1827   */\r
1828 HAL_StatusTypeDef HAL_CRYP_AESECB_Encrypt_DMA(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData)\r
1829 {\r
1830   uint32_t inputaddr;\r
1831   uint32_t outputaddr;\r
1832   \r
1833   if((hcryp->State == HAL_CRYP_STATE_READY) || (hcryp->Phase == HAL_CRYP_PHASE_PROCESS))\r
1834   {\r
1835     /* Process Locked */\r
1836     __HAL_LOCK(hcryp);\r
1837     \r
1838     inputaddr  = (uint32_t)pPlainData;\r
1839     outputaddr = (uint32_t)pCypherData;\r
1840     \r
1841     /* Change the CRYP state */\r
1842     hcryp->State = HAL_CRYP_STATE_BUSY;\r
1843     \r
1844     /* Check if initialization phase has already been performed */\r
1845     if(hcryp->Phase == HAL_CRYP_PHASE_READY)\r
1846     {\r
1847       /* Set the key */\r
1848       CRYP_SetKey(hcryp, hcryp->Init.pKey, hcryp->Init.KeySize);\r
1849       \r
1850       /* Set the CRYP peripheral in AES ECB mode */\r
1851       __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_ECB);\r
1852       \r
1853       /* Flush FIFO */\r
1854       __HAL_CRYP_FIFO_FLUSH(hcryp);\r
1855       \r
1856      /* Set the phase */\r
1857      hcryp->Phase = HAL_CRYP_PHASE_PROCESS;\r
1858     }\r
1859     /* Set the input and output addresses and start DMA transfer */ \r
1860     CRYP_SetDMAConfig(hcryp, inputaddr, Size, outputaddr);\r
1861     \r
1862     /* Process Unlocked */\r
1863     __HAL_UNLOCK(hcryp);\r
1864      \r
1865     /* Return function status */\r
1866     return HAL_OK;\r
1867   }\r
1868   else\r
1869   {\r
1870     return HAL_ERROR;   \r
1871   }\r
1872 }\r
1873 \r
1874 /**\r
1875   * @brief  Initializes the CRYP peripheral in AES CBC encryption mode using DMA.\r
1876   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
1877   *         the configuration information for CRYP module\r
1878   * @param  pPlainData: Pointer to the plaintext buffer\r
1879   * @param  Size: Length of the plaintext buffer, must be a multiple of 16.\r
1880   * @param  pCypherData: Pointer to the cyphertext buffer\r
1881   * @retval HAL status\r
1882   */\r
1883 HAL_StatusTypeDef HAL_CRYP_AESCBC_Encrypt_DMA(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData)\r
1884 {\r
1885   uint32_t inputaddr;\r
1886   uint32_t outputaddr;\r
1887   \r
1888   if((hcryp->State == HAL_CRYP_STATE_READY) || (hcryp->Phase == HAL_CRYP_PHASE_PROCESS))\r
1889   {\r
1890     /* Process Locked */\r
1891     __HAL_LOCK(hcryp);\r
1892     \r
1893     inputaddr  = (uint32_t)pPlainData;\r
1894     outputaddr = (uint32_t)pCypherData;\r
1895     \r
1896     /* Change the CRYP state */\r
1897     hcryp->State = HAL_CRYP_STATE_BUSY;\r
1898   \r
1899     /* Check if initialization phase has already been performed */\r
1900     if(hcryp->Phase == HAL_CRYP_PHASE_READY)\r
1901     {\r
1902       /* Set the key */\r
1903       CRYP_SetKey(hcryp, hcryp->Init.pKey, hcryp->Init.KeySize);\r
1904       \r
1905       /* Set the CRYP peripheral in AES ECB mode */\r
1906       __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CBC);\r
1907       \r
1908       /* Set the Initialization Vector */\r
1909       CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect, CRYP_KEYSIZE_128B);\r
1910       \r
1911       /* Flush FIFO */\r
1912       __HAL_CRYP_FIFO_FLUSH(hcryp);\r
1913       \r
1914        /* Set the phase */\r
1915        hcryp->Phase = HAL_CRYP_PHASE_PROCESS;\r
1916      }\r
1917      /* Set the input and output addresses and start DMA transfer */ \r
1918      CRYP_SetDMAConfig(hcryp, inputaddr, Size, outputaddr);\r
1919      \r
1920      /* Process Unlocked */\r
1921      __HAL_UNLOCK(hcryp);\r
1922      \r
1923      /* Return function status */\r
1924      return HAL_OK;\r
1925   }\r
1926   else\r
1927   {\r
1928     return HAL_ERROR;   \r
1929   }\r
1930 }\r
1931 \r
1932 /**\r
1933   * @brief  Initializes the CRYP peripheral in AES CTR encryption mode using DMA.\r
1934   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
1935   *         the configuration information for CRYP module\r
1936   * @param  pPlainData: Pointer to the plaintext buffer\r
1937   * @param  Size: Length of the plaintext buffer, must be a multiple of 16.\r
1938   * @param  pCypherData: Pointer to the cyphertext buffer\r
1939   * @retval HAL status\r
1940   */\r
1941 HAL_StatusTypeDef HAL_CRYP_AESCTR_Encrypt_DMA(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData)\r
1942 {\r
1943   uint32_t inputaddr;\r
1944   uint32_t outputaddr;\r
1945   \r
1946   if((hcryp->State == HAL_CRYP_STATE_READY) || (hcryp->Phase == HAL_CRYP_PHASE_PROCESS))\r
1947   {\r
1948     /* Process Locked */\r
1949     __HAL_LOCK(hcryp);\r
1950     \r
1951     inputaddr  = (uint32_t)pPlainData;\r
1952     outputaddr = (uint32_t)pCypherData;\r
1953     \r
1954   /* Change the CRYP state */\r
1955   hcryp->State = HAL_CRYP_STATE_BUSY;\r
1956   \r
1957     /* Check if initialization phase has already been performed */\r
1958     if(hcryp->Phase == HAL_CRYP_PHASE_READY)\r
1959     {\r
1960       /* Set the key */\r
1961       CRYP_SetKey(hcryp, hcryp->Init.pKey, hcryp->Init.KeySize);\r
1962       \r
1963       /* Set the CRYP peripheral in AES ECB mode */\r
1964       __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CTR);\r
1965       \r
1966       /* Set the Initialization Vector */\r
1967       CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect, CRYP_KEYSIZE_128B);\r
1968       \r
1969       /* Flush FIFO */\r
1970       __HAL_CRYP_FIFO_FLUSH(hcryp);\r
1971       \r
1972        /* Set the phase */\r
1973        hcryp->Phase = HAL_CRYP_PHASE_PROCESS;\r
1974     }\r
1975     \r
1976     /* Set the input and output addresses and start DMA transfer */ \r
1977     CRYP_SetDMAConfig(hcryp, inputaddr, Size, outputaddr);\r
1978     \r
1979     /* Process Unlocked */\r
1980     __HAL_UNLOCK(hcryp);\r
1981     \r
1982     /* Return function status */\r
1983     return HAL_OK;\r
1984   }\r
1985   else\r
1986   {\r
1987     return HAL_ERROR;   \r
1988   }\r
1989 }\r
1990 \r
1991 /**\r
1992   * @brief  Initializes the CRYP peripheral in AES ECB decryption mode using DMA.\r
1993   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
1994   *         the configuration information for CRYP module\r
1995   * @param  pCypherData: Pointer to the cyphertext buffer\r
1996   * @param  Size: Length of the plaintext buffer, must be a multiple of 16 bytes\r
1997   * @param  pPlainData: Pointer to the plaintext buffer\r
1998   * @retval HAL status\r
1999   */\r
2000 HAL_StatusTypeDef HAL_CRYP_AESECB_Decrypt_DMA(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData)\r
2001 {\r
2002   uint32_t tickstart = 0;   \r
2003   uint32_t inputaddr;\r
2004   uint32_t outputaddr;\r
2005   \r
2006   if((hcryp->State == HAL_CRYP_STATE_READY) || (hcryp->Phase == HAL_CRYP_PHASE_PROCESS))\r
2007   {\r
2008     /* Process Locked */\r
2009     __HAL_LOCK(hcryp);\r
2010     \r
2011     inputaddr  = (uint32_t)pCypherData;\r
2012     outputaddr = (uint32_t)pPlainData;\r
2013     \r
2014     /* Change the CRYP state */\r
2015     hcryp->State = HAL_CRYP_STATE_BUSY;\r
2016     \r
2017     /* Check if initialization phase has already been performed */\r
2018     if(hcryp->Phase == HAL_CRYP_PHASE_READY)\r
2019     {\r
2020     /* Set the key */\r
2021     CRYP_SetKey(hcryp, hcryp->Init.pKey, hcryp->Init.KeySize);\r
2022     \r
2023     /* Set the CRYP peripheral in AES Key mode */\r
2024     __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_KEY | CRYP_CR_ALGODIR);\r
2025     \r
2026     /* Enable CRYP */\r
2027     __HAL_CRYP_ENABLE(hcryp);\r
2028     \r
2029     /* Get tick */\r
2030     tickstart = HAL_GetTick();\r
2031     \r
2032     while(HAL_IS_BIT_SET(hcryp->Instance->SR, CRYP_FLAG_BUSY))\r
2033     {\r
2034       /* Check for the Timeout */\r
2035       if((HAL_GetTick() - tickstart ) > CRYP_TIMEOUT_VALUE)\r
2036       {\r
2037         /* Change state */\r
2038         hcryp->State = HAL_CRYP_STATE_TIMEOUT;\r
2039         \r
2040         /* Process Unlocked */\r
2041         __HAL_UNLOCK(hcryp);\r
2042         \r
2043         return HAL_TIMEOUT;\r
2044       }\r
2045     }\r
2046     \r
2047     /* Reset the ALGOMODE bits*/\r
2048     CRYP->CR &= (uint32_t)(~CRYP_CR_ALGOMODE);\r
2049     \r
2050     /* Set the CRYP peripheral in AES ECB decryption mode */\r
2051     __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_ECB | CRYP_CR_ALGODIR);\r
2052     \r
2053     /* Flush FIFO */\r
2054     __HAL_CRYP_FIFO_FLUSH(hcryp);\r
2055     \r
2056      /* Set the phase */\r
2057      hcryp->Phase = HAL_CRYP_PHASE_PROCESS;\r
2058     }\r
2059      \r
2060     /* Set the input and output addresses and start DMA transfer */ \r
2061     CRYP_SetDMAConfig(hcryp, inputaddr, Size, outputaddr);\r
2062     \r
2063      /* Process Unlocked */\r
2064      __HAL_UNLOCK(hcryp);\r
2065     \r
2066     /* Return function status */\r
2067     return HAL_OK;\r
2068   }\r
2069   else\r
2070   {\r
2071     return HAL_ERROR;   \r
2072   }\r
2073 }\r
2074 \r
2075 /**\r
2076   * @brief  Initializes the CRYP peripheral in AES CBC encryption mode using DMA.\r
2077   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
2078   *         the configuration information for CRYP module\r
2079   * @param  pCypherData: Pointer to the cyphertext buffer\r
2080   * @param  Size: Length of the plaintext buffer, must be a multiple of 16 bytes\r
2081   * @param  pPlainData: Pointer to the plaintext buffer\r
2082   * @retval HAL status\r
2083   */\r
2084 HAL_StatusTypeDef HAL_CRYP_AESCBC_Decrypt_DMA(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData)\r
2085 {\r
2086   uint32_t tickstart = 0;   \r
2087   uint32_t inputaddr;\r
2088   uint32_t outputaddr;\r
2089   \r
2090   if((hcryp->State == HAL_CRYP_STATE_READY) || (hcryp->Phase == HAL_CRYP_PHASE_PROCESS))\r
2091   {\r
2092     /* Process Locked */\r
2093     __HAL_LOCK(hcryp);\r
2094     \r
2095     inputaddr  = (uint32_t)pCypherData;\r
2096     outputaddr = (uint32_t)pPlainData;\r
2097     \r
2098     /* Change the CRYP state */\r
2099     hcryp->State = HAL_CRYP_STATE_BUSY;\r
2100     \r
2101     /* Check if initialization phase has already been performed */\r
2102     if(hcryp->Phase == HAL_CRYP_PHASE_READY)\r
2103     {\r
2104       /* Set the key */\r
2105       CRYP_SetKey(hcryp, hcryp->Init.pKey, hcryp->Init.KeySize);\r
2106       \r
2107       /* Set the CRYP peripheral in AES Key mode */\r
2108       __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_KEY | CRYP_CR_ALGODIR);\r
2109       \r
2110       /* Enable CRYP */\r
2111       __HAL_CRYP_ENABLE(hcryp);\r
2112       \r
2113       /* Get tick */\r
2114       tickstart = HAL_GetTick();\r
2115 \r
2116       while(HAL_IS_BIT_SET(hcryp->Instance->SR, CRYP_FLAG_BUSY))\r
2117       {\r
2118         /* Check for the Timeout */\r
2119         if((HAL_GetTick() - tickstart ) > CRYP_TIMEOUT_VALUE)\r
2120         {\r
2121           /* Change state */\r
2122           hcryp->State = HAL_CRYP_STATE_TIMEOUT;\r
2123           \r
2124           /* Process Unlocked */\r
2125           __HAL_UNLOCK(hcryp);\r
2126           \r
2127           return HAL_TIMEOUT;\r
2128         }\r
2129       }\r
2130       \r
2131       /* Reset the ALGOMODE bits*/\r
2132       CRYP->CR &= (uint32_t)(~CRYP_CR_ALGOMODE);\r
2133       \r
2134       /* Set the CRYP peripheral in AES CBC decryption mode */\r
2135       __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CBC | CRYP_CR_ALGODIR);\r
2136       \r
2137       /* Set the Initialization Vector */\r
2138       CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect, CRYP_KEYSIZE_128B);\r
2139       \r
2140       /* Flush FIFO */\r
2141       __HAL_CRYP_FIFO_FLUSH(hcryp);\r
2142       \r
2143       /* Set the phase */\r
2144       hcryp->Phase = HAL_CRYP_PHASE_PROCESS;\r
2145     }\r
2146     \r
2147     /* Set the input and output addresses and start DMA transfer */ \r
2148     CRYP_SetDMAConfig(hcryp, inputaddr, Size, outputaddr);\r
2149     \r
2150     /* Process Unlocked */\r
2151     __HAL_UNLOCK(hcryp);\r
2152     \r
2153     /* Return function status */\r
2154     return HAL_OK;\r
2155   }\r
2156   else\r
2157   {\r
2158     return HAL_ERROR;   \r
2159   }\r
2160 }\r
2161 \r
2162 /**\r
2163   * @brief  Initializes the CRYP peripheral in AES CTR decryption mode using DMA.\r
2164   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
2165   *         the configuration information for CRYP module\r
2166   * @param  pCypherData: Pointer to the cyphertext buffer\r
2167   * @param  Size: Length of the plaintext buffer, must be a multiple of 16\r
2168   * @param  pPlainData: Pointer to the plaintext buffer\r
2169   * @retval HAL status\r
2170   */\r
2171 HAL_StatusTypeDef HAL_CRYP_AESCTR_Decrypt_DMA(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData)\r
2172 {  \r
2173   uint32_t inputaddr;\r
2174   uint32_t outputaddr;\r
2175   \r
2176   if((hcryp->State == HAL_CRYP_STATE_READY) || (hcryp->Phase == HAL_CRYP_PHASE_PROCESS))\r
2177   {\r
2178     /* Process Locked */\r
2179     __HAL_LOCK(hcryp);\r
2180     \r
2181     inputaddr  = (uint32_t)pCypherData;\r
2182     outputaddr = (uint32_t)pPlainData;\r
2183     \r
2184     /* Change the CRYP state */\r
2185     hcryp->State = HAL_CRYP_STATE_BUSY;\r
2186     \r
2187     /* Check if initialization phase has already been performed */\r
2188     if(hcryp->Phase == HAL_CRYP_PHASE_READY)\r
2189     {\r
2190       /* Set the key */\r
2191       CRYP_SetKey(hcryp, hcryp->Init.pKey, hcryp->Init.KeySize);\r
2192       \r
2193       /* Set the CRYP peripheral in AES CTR mode */\r
2194       __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CTR | CRYP_CR_ALGODIR);\r
2195       \r
2196       /* Set the Initialization Vector */\r
2197       CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect, CRYP_KEYSIZE_128B);\r
2198       \r
2199       /* Flush FIFO */\r
2200       __HAL_CRYP_FIFO_FLUSH(hcryp);\r
2201       \r
2202       /* Set the phase */\r
2203       hcryp->Phase = HAL_CRYP_PHASE_PROCESS;\r
2204     }\r
2205     \r
2206     /* Set the input and output addresses and start DMA transfer */ \r
2207     CRYP_SetDMAConfig(hcryp, inputaddr, Size, outputaddr);\r
2208     \r
2209     /* Process Unlocked */\r
2210     __HAL_UNLOCK(hcryp);\r
2211     \r
2212     /* Return function status */\r
2213     return HAL_OK;\r
2214   }\r
2215   else\r
2216   {\r
2217     return HAL_ERROR;   \r
2218   }\r
2219 }\r
2220 \r
2221 \r
2222 /**\r
2223   * @}\r
2224   */\r
2225   \r
2226 /** @defgroup CRYP_Exported_Functions_Group3 DES processing functions \r
2227  *  @brief   processing functions. \r
2228  *\r
2229 @verbatim   \r
2230   ==============================================================================\r
2231                       ##### DES processing functions #####\r
2232   ==============================================================================  \r
2233     [..]  This section provides functions allowing to:\r
2234       (+) Encrypt plaintext using DES using ECB or CBC chaining modes\r
2235       (+) Decrypt cyphertext using ECB or CBC chaining modes\r
2236     [..]  Three processing functions are available:\r
2237       (+) Polling mode\r
2238       (+) Interrupt mode\r
2239       (+) DMA mode\r
2240 \r
2241 @endverbatim\r
2242   * @{\r
2243   */\r
2244 \r
2245 /**\r
2246   * @brief  Initializes the CRYP peripheral in DES ECB encryption mode.\r
2247   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
2248   *         the configuration information for CRYP module\r
2249   * @param  pPlainData: Pointer to the plaintext buffer\r
2250   * @param  Size: Length of the plaintext buffer, must be a multiple of 8\r
2251   * @param  pCypherData: Pointer to the cyphertext buffer\r
2252   * @param  Timeout: Specify Timeout value  \r
2253   * @retval HAL status\r
2254   */\r
2255 HAL_StatusTypeDef HAL_CRYP_DESECB_Encrypt(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData, uint32_t Timeout)\r
2256 {\r
2257   /* Process Locked */\r
2258   __HAL_LOCK(hcryp);\r
2259   \r
2260   /* Change the CRYP state */\r
2261   hcryp->State = HAL_CRYP_STATE_BUSY;\r
2262   \r
2263   /* Set CRYP peripheral in DES ECB encryption mode */\r
2264   CRYP_SetDESECBMode(hcryp, 0);\r
2265   \r
2266   /* Enable CRYP */\r
2267   __HAL_CRYP_ENABLE(hcryp);\r
2268   \r
2269   /* Write Plain Data and Get Cypher Data */\r
2270   if(CRYP_ProcessData2Words(hcryp, pPlainData, Size, pCypherData, Timeout) != HAL_OK)\r
2271   {\r
2272     return HAL_TIMEOUT;\r
2273   }\r
2274   \r
2275   /* Change the CRYP state */\r
2276   hcryp->State = HAL_CRYP_STATE_READY;\r
2277   \r
2278   /* Process Unlocked */\r
2279   __HAL_UNLOCK(hcryp);\r
2280   \r
2281   /* Return function status */\r
2282   return HAL_OK;\r
2283 }\r
2284 \r
2285 /**\r
2286   * @brief  Initializes the CRYP peripheral in DES ECB decryption mode.\r
2287   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
2288   *         the configuration information for CRYP module\r
2289   * @param  pPlainData: Pointer to the plaintext buffer\r
2290   * @param  Size: Length of the plaintext buffer, must be a multiple of 8\r
2291   * @param  pCypherData: Pointer to the cyphertext buffer\r
2292   * @param  Timeout: Specify Timeout value  \r
2293   * @retval HAL status\r
2294   */\r
2295 HAL_StatusTypeDef HAL_CRYP_DESECB_Decrypt(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData, uint32_t Timeout)\r
2296 {\r
2297   /* Process Locked */\r
2298   __HAL_LOCK(hcryp);\r
2299   \r
2300   /* Change the CRYP state */\r
2301   hcryp->State = HAL_CRYP_STATE_BUSY;\r
2302   \r
2303   /* Set CRYP peripheral in DES ECB decryption mode */\r
2304   CRYP_SetDESECBMode(hcryp, CRYP_CR_ALGODIR);\r
2305   \r
2306   /* Enable CRYP */\r
2307   __HAL_CRYP_ENABLE(hcryp);\r
2308   \r
2309   /* Write Plain Data and Get Cypher Data */\r
2310   if(CRYP_ProcessData2Words(hcryp, pPlainData, Size, pCypherData, Timeout) != HAL_OK)\r
2311   {\r
2312     return HAL_TIMEOUT;\r
2313   }\r
2314   \r
2315   /* Change the CRYP state */\r
2316   hcryp->State = HAL_CRYP_STATE_READY;\r
2317   \r
2318   /* Process Unlocked */\r
2319   __HAL_UNLOCK(hcryp);\r
2320   \r
2321   /* Return function status */\r
2322   return HAL_OK;\r
2323 }\r
2324 \r
2325 /**\r
2326   * @brief  Initializes the CRYP peripheral in DES CBC encryption mode.\r
2327   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
2328   *         the configuration information for CRYP module\r
2329   * @param  pPlainData: Pointer to the plaintext buffer\r
2330   * @param  Size: Length of the plaintext buffer, must be a multiple of 8\r
2331   * @param  pCypherData: Pointer to the cyphertext buffer\r
2332   * @param  Timeout: Specify Timeout value  \r
2333   * @retval HAL status\r
2334   */\r
2335 HAL_StatusTypeDef HAL_CRYP_DESCBC_Encrypt(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData, uint32_t Timeout)\r
2336 {\r
2337   /* Process Locked */\r
2338   __HAL_LOCK(hcryp);\r
2339   \r
2340   /* Change the CRYP state */\r
2341   hcryp->State = HAL_CRYP_STATE_BUSY;\r
2342   \r
2343   /* Set CRYP peripheral in DES CBC encryption mode */\r
2344   CRYP_SetDESCBCMode(hcryp, 0);\r
2345   \r
2346   /* Enable CRYP */\r
2347   __HAL_CRYP_ENABLE(hcryp);\r
2348   \r
2349   /* Write Plain Data and Get Cypher Data */\r
2350   if(CRYP_ProcessData2Words(hcryp, pPlainData, Size, pCypherData, Timeout) != HAL_OK)\r
2351   {\r
2352     return HAL_TIMEOUT;\r
2353   }\r
2354   \r
2355   /* Change the CRYP state */\r
2356   hcryp->State = HAL_CRYP_STATE_READY;\r
2357   \r
2358   /* Process Unlocked */\r
2359   __HAL_UNLOCK(hcryp);\r
2360   \r
2361   /* Return function status */\r
2362   return HAL_OK;\r
2363 }\r
2364 \r
2365 /**\r
2366   * @brief  Initializes the CRYP peripheral in DES ECB decryption mode.\r
2367   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
2368   *         the configuration information for CRYP module\r
2369   * @param  pPlainData: Pointer to the plaintext buffer\r
2370   * @param  Size: Length of the plaintext buffer, must be a multiple of 8\r
2371   * @param  pCypherData: Pointer to the cyphertext buffer\r
2372   * @param  Timeout: Specify Timeout value  \r
2373   * @retval HAL status\r
2374   */\r
2375 HAL_StatusTypeDef HAL_CRYP_DESCBC_Decrypt(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData, uint32_t Timeout)\r
2376 {\r
2377   /* Process Locked */\r
2378   __HAL_LOCK(hcryp);\r
2379   \r
2380   /* Change the CRYP state */\r
2381   hcryp->State = HAL_CRYP_STATE_BUSY;\r
2382   \r
2383   /* Set CRYP peripheral in DES CBC decryption mode */\r
2384   CRYP_SetDESCBCMode(hcryp, CRYP_CR_ALGODIR);\r
2385   \r
2386   /* Enable CRYP */\r
2387   __HAL_CRYP_ENABLE(hcryp);\r
2388   \r
2389   /* Write Plain Data and Get Cypher Data */\r
2390   if(CRYP_ProcessData2Words(hcryp, pPlainData, Size, pCypherData, Timeout) != HAL_OK)\r
2391   {\r
2392     return HAL_TIMEOUT;\r
2393   }\r
2394   \r
2395   /* Change the CRYP state */\r
2396   hcryp->State = HAL_CRYP_STATE_READY;\r
2397   \r
2398   /* Process Unlocked */\r
2399   __HAL_UNLOCK(hcryp);\r
2400   \r
2401   /* Return function status */\r
2402   return HAL_OK;\r
2403 }\r
2404 \r
2405 /**\r
2406   * @brief  Initializes the CRYP peripheral in DES ECB encryption mode using IT.\r
2407   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
2408   *         the configuration information for CRYP module\r
2409   * @param  pPlainData: Pointer to the plaintext buffer\r
2410   * @param  Size: Length of the plaintext buffer, must be a multiple of 8\r
2411   * @param  pCypherData: Pointer to the cyphertext buffer\r
2412   * @retval HAL status\r
2413   */\r
2414 HAL_StatusTypeDef HAL_CRYP_DESECB_Encrypt_IT(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData)\r
2415 {\r
2416   uint32_t inputaddr;\r
2417   uint32_t outputaddr;\r
2418   \r
2419   if(hcryp->State == HAL_CRYP_STATE_READY)\r
2420   {\r
2421     /* Process Locked */\r
2422     __HAL_LOCK(hcryp);\r
2423     \r
2424     hcryp->CrypInCount = Size;\r
2425     hcryp->pCrypInBuffPtr = pPlainData;\r
2426     hcryp->pCrypOutBuffPtr = pCypherData;\r
2427     hcryp->CrypOutCount = Size;\r
2428     \r
2429     /* Change the CRYP state */\r
2430     hcryp->State = HAL_CRYP_STATE_BUSY;\r
2431     \r
2432     /* Set CRYP peripheral in DES ECB encryption mode */\r
2433     CRYP_SetDESECBMode(hcryp, 0);\r
2434     \r
2435     /* Enable Interrupts */\r
2436     __HAL_CRYP_ENABLE_IT(hcryp, CRYP_IT_INI | CRYP_IT_OUTI);\r
2437     \r
2438     /* Enable CRYP */\r
2439     __HAL_CRYP_ENABLE(hcryp);\r
2440     \r
2441     /* Return function status */\r
2442     return HAL_OK;\r
2443   }\r
2444   else if(__HAL_CRYP_GET_IT(hcryp, CRYP_IT_INI))\r
2445   {\r
2446     inputaddr = (uint32_t)hcryp->pCrypInBuffPtr;\r
2447     /* Write the Input block in the IN FIFO */\r
2448     hcryp->Instance->DR = *(uint32_t*)(inputaddr);\r
2449     inputaddr+=4;\r
2450     hcryp->Instance->DR = *(uint32_t*)(inputaddr);\r
2451     \r
2452     hcryp->pCrypInBuffPtr += 8;\r
2453     hcryp->CrypInCount -= 8;\r
2454     if(hcryp->CrypInCount == 0)\r
2455     {\r
2456       __HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_INI);\r
2457       /* Call the Input data transfer complete callback */\r
2458       HAL_CRYP_InCpltCallback(hcryp);\r
2459     }\r
2460   }\r
2461   else if(__HAL_CRYP_GET_IT(hcryp, CRYP_IT_OUTI))\r
2462   {\r
2463     outputaddr = (uint32_t)hcryp->pCrypOutBuffPtr;\r
2464     /* Read the Output block from the Output FIFO */\r
2465     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
2466     outputaddr+=4;\r
2467     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
2468     \r
2469     hcryp->pCrypOutBuffPtr += 8;\r
2470     hcryp->CrypOutCount -= 8;\r
2471     if(hcryp->CrypOutCount == 0)\r
2472     {\r
2473       /* Disable IT */\r
2474       __HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_OUTI);\r
2475       /* Disable CRYP */\r
2476       __HAL_CRYP_DISABLE(hcryp);\r
2477       /* Process Unlocked */\r
2478       __HAL_UNLOCK(hcryp);\r
2479       /* Change the CRYP state */\r
2480       hcryp->State = HAL_CRYP_STATE_READY;\r
2481       /* Call Input transfer complete callback */\r
2482       HAL_CRYP_OutCpltCallback(hcryp);\r
2483     }\r
2484   }\r
2485   \r
2486   /* Return function status */\r
2487   return HAL_OK;\r
2488 }\r
2489 \r
2490 /**\r
2491   * @brief  Initializes the CRYP peripheral in DES CBC encryption mode using interrupt.\r
2492   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
2493   *         the configuration information for CRYP module\r
2494   * @param  pPlainData: Pointer to the plaintext buffer\r
2495   * @param  Size: Length of the plaintext buffer, must be a multiple of 8\r
2496   * @param  pCypherData: Pointer to the cyphertext buffer\r
2497   * @retval HAL status\r
2498   */\r
2499 HAL_StatusTypeDef HAL_CRYP_DESCBC_Encrypt_IT(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData)\r
2500 {\r
2501   uint32_t inputaddr;\r
2502   uint32_t outputaddr;\r
2503   \r
2504   if(hcryp->State == HAL_CRYP_STATE_READY)\r
2505   {\r
2506     /* Process Locked */\r
2507     __HAL_LOCK(hcryp);\r
2508     \r
2509     hcryp->CrypInCount = Size;\r
2510     hcryp->pCrypInBuffPtr = pPlainData;\r
2511     hcryp->pCrypOutBuffPtr = pCypherData;\r
2512     hcryp->CrypOutCount = Size;\r
2513     \r
2514     /* Change the CRYP state */\r
2515     hcryp->State = HAL_CRYP_STATE_BUSY;\r
2516     \r
2517     /* Set CRYP peripheral in DES CBC encryption mode */\r
2518     CRYP_SetDESCBCMode(hcryp, 0);\r
2519     \r
2520     /* Enable Interrupts */\r
2521     __HAL_CRYP_ENABLE_IT(hcryp, CRYP_IT_INI | CRYP_IT_OUTI);\r
2522     \r
2523     /* Enable CRYP */\r
2524     __HAL_CRYP_ENABLE(hcryp);\r
2525     \r
2526     /* Return function status */\r
2527     return HAL_OK;\r
2528   }\r
2529   \r
2530   else if(__HAL_CRYP_GET_IT(hcryp, CRYP_IT_INI))\r
2531   {\r
2532     inputaddr = (uint32_t)hcryp->pCrypInBuffPtr;\r
2533     /* Write the Input block in the IN FIFO */\r
2534     hcryp->Instance->DR = *(uint32_t*)(inputaddr);\r
2535     inputaddr+=4;\r
2536     hcryp->Instance->DR = *(uint32_t*)(inputaddr);\r
2537 \r
2538     hcryp->pCrypInBuffPtr += 8;\r
2539     hcryp->CrypInCount -= 8;\r
2540     if(hcryp->CrypInCount == 0)\r
2541     {\r
2542       __HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_INI);\r
2543       /* Call the Input data transfer complete callback */\r
2544       HAL_CRYP_InCpltCallback(hcryp);\r
2545     }\r
2546   }\r
2547   else if(__HAL_CRYP_GET_IT(hcryp, CRYP_IT_OUTI))\r
2548   {\r
2549     outputaddr = (uint32_t)hcryp->pCrypOutBuffPtr;\r
2550     /* Read the Output block from the Output FIFO */\r
2551     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
2552     outputaddr+=4;\r
2553     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
2554 \r
2555     hcryp->pCrypOutBuffPtr += 8;\r
2556     hcryp->CrypOutCount -= 8;\r
2557     if(hcryp->CrypOutCount == 0)\r
2558     {\r
2559       /* Disable IT */\r
2560       __HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_OUTI);\r
2561       /* Disable CRYP */\r
2562       __HAL_CRYP_DISABLE(hcryp);\r
2563       /* Process Unlocked */\r
2564       __HAL_UNLOCK(hcryp);\r
2565       /* Change the CRYP state */\r
2566       hcryp->State = HAL_CRYP_STATE_READY;\r
2567       /* Call Input transfer complete callback */\r
2568       HAL_CRYP_OutCpltCallback(hcryp);\r
2569     }\r
2570   }\r
2571   \r
2572   /* Return function status */\r
2573   return HAL_OK;\r
2574 }\r
2575 \r
2576 /**\r
2577   * @brief  Initializes the CRYP peripheral in DES ECB decryption mode using IT.\r
2578   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
2579   *         the configuration information for CRYP module\r
2580   * @param  pPlainData: Pointer to the plaintext buffer\r
2581   * @param  Size: Length of the plaintext buffer, must be a multiple of 8\r
2582   * @param  pCypherData: Pointer to the cyphertext buffer\r
2583   * @retval HAL status\r
2584   */\r
2585 HAL_StatusTypeDef HAL_CRYP_DESECB_Decrypt_IT(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData)\r
2586 {\r
2587   uint32_t inputaddr;\r
2588   uint32_t outputaddr;\r
2589   \r
2590   if(hcryp->State == HAL_CRYP_STATE_READY)\r
2591   {\r
2592     /* Process Locked */\r
2593     __HAL_LOCK(hcryp);\r
2594     \r
2595     hcryp->CrypInCount = Size;\r
2596     hcryp->pCrypInBuffPtr = pCypherData;\r
2597     hcryp->pCrypOutBuffPtr = pPlainData;\r
2598     hcryp->CrypOutCount = Size;\r
2599     \r
2600     /* Change the CRYP state */\r
2601     hcryp->State = HAL_CRYP_STATE_BUSY;\r
2602     \r
2603     /* Set CRYP peripheral in DES ECB decryption mode */\r
2604     CRYP_SetDESECBMode(hcryp, CRYP_CR_ALGODIR);\r
2605     \r
2606     /* Enable Interrupts */\r
2607     __HAL_CRYP_ENABLE_IT(hcryp, CRYP_IT_INI | CRYP_IT_OUTI);\r
2608     \r
2609     /* Enable CRYP */\r
2610     __HAL_CRYP_ENABLE(hcryp);\r
2611     \r
2612     /* Return function status */\r
2613     return HAL_OK;\r
2614   }\r
2615   else if(__HAL_CRYP_GET_IT(hcryp, CRYP_IT_INI))\r
2616   {\r
2617     inputaddr = (uint32_t)hcryp->pCrypInBuffPtr;\r
2618     /* Write the Input block in the IN FIFO */\r
2619     hcryp->Instance->DR = *(uint32_t*)(inputaddr);\r
2620     inputaddr+=4;\r
2621     hcryp->Instance->DR = *(uint32_t*)(inputaddr);\r
2622     \r
2623     hcryp->pCrypInBuffPtr += 8;\r
2624     hcryp->CrypInCount -= 8;\r
2625     if(hcryp->CrypInCount == 0)\r
2626     {\r
2627       __HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_INI);\r
2628       /* Call the Input data transfer complete callback */\r
2629       HAL_CRYP_InCpltCallback(hcryp);\r
2630     }\r
2631   }\r
2632   else if(__HAL_CRYP_GET_IT(hcryp, CRYP_IT_OUTI))\r
2633   {\r
2634     outputaddr = (uint32_t)hcryp->pCrypOutBuffPtr;\r
2635     /* Read the Output block from the Output FIFO */\r
2636     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
2637     outputaddr+=4;\r
2638     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
2639 \r
2640     hcryp->pCrypOutBuffPtr += 8;\r
2641     hcryp->CrypOutCount -= 8;\r
2642     if(hcryp->CrypOutCount == 0)\r
2643     {\r
2644       /* Disable IT */\r
2645       __HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_OUTI);\r
2646       /* Disable CRYP */\r
2647       __HAL_CRYP_DISABLE(hcryp);\r
2648       /* Process Unlocked */\r
2649       __HAL_UNLOCK(hcryp);\r
2650       /* Change the CRYP state */\r
2651       hcryp->State = HAL_CRYP_STATE_READY;\r
2652       /* Call Input transfer complete callback */\r
2653       HAL_CRYP_OutCpltCallback(hcryp);\r
2654     }\r
2655   }\r
2656   \r
2657   /* Return function status */\r
2658   return HAL_OK;\r
2659 }\r
2660 \r
2661 /**\r
2662   * @brief  Initializes the CRYP peripheral in DES ECB decryption mode using interrupt.\r
2663   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
2664   *         the configuration information for CRYP module\r
2665   * @param  pPlainData: Pointer to the plaintext buffer\r
2666   * @param  Size: Length of the plaintext buffer, must be a multiple of 8\r
2667   * @param  pCypherData: Pointer to the cyphertext buffer\r
2668   * @retval HAL status\r
2669   */\r
2670 HAL_StatusTypeDef HAL_CRYP_DESCBC_Decrypt_IT(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData)\r
2671 {\r
2672   uint32_t inputaddr;\r
2673   uint32_t outputaddr;\r
2674   \r
2675   if(hcryp->State == HAL_CRYP_STATE_READY)\r
2676   {\r
2677     /* Process Locked */\r
2678     __HAL_LOCK(hcryp);\r
2679     \r
2680     hcryp->CrypInCount = Size;\r
2681     hcryp->pCrypInBuffPtr = pCypherData;\r
2682     hcryp->pCrypOutBuffPtr = pPlainData;\r
2683     hcryp->CrypOutCount = Size;\r
2684     \r
2685     /* Change the CRYP state */\r
2686     hcryp->State = HAL_CRYP_STATE_BUSY;\r
2687     \r
2688     /* Set CRYP peripheral in DES CBC decryption mode */\r
2689     CRYP_SetDESCBCMode(hcryp, CRYP_CR_ALGODIR);\r
2690     \r
2691     /* Enable Interrupts */\r
2692     __HAL_CRYP_ENABLE_IT(hcryp, CRYP_IT_INI | CRYP_IT_OUTI);\r
2693     \r
2694     /* Enable CRYP */\r
2695     __HAL_CRYP_ENABLE(hcryp);\r
2696     \r
2697     /* Return function status */\r
2698     return HAL_OK;\r
2699   }\r
2700   else if(__HAL_CRYP_GET_IT(hcryp, CRYP_IT_INI))\r
2701   {\r
2702     inputaddr = (uint32_t)hcryp->pCrypInBuffPtr;\r
2703     /* Write the Input block in the IN FIFO */\r
2704     hcryp->Instance->DR = *(uint32_t*)(inputaddr);\r
2705     inputaddr+=4;\r
2706     hcryp->Instance->DR = *(uint32_t*)(inputaddr);\r
2707 \r
2708     hcryp->pCrypInBuffPtr += 8;\r
2709     hcryp->CrypInCount -= 8;\r
2710     if(hcryp->CrypInCount == 0)\r
2711     {\r
2712       __HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_INI);\r
2713       /* Call the Input data transfer complete callback */\r
2714       HAL_CRYP_InCpltCallback(hcryp);\r
2715     }\r
2716   }\r
2717   else if(__HAL_CRYP_GET_IT(hcryp, CRYP_IT_OUTI))\r
2718   {\r
2719     outputaddr = (uint32_t)hcryp->pCrypOutBuffPtr;\r
2720     /* Read the Output block from the Output FIFO */\r
2721     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
2722     outputaddr+=4;\r
2723     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
2724 \r
2725     hcryp->pCrypOutBuffPtr += 8;\r
2726     hcryp->CrypOutCount -= 8;\r
2727     if(hcryp->CrypOutCount == 0)\r
2728     {\r
2729       /* Disable IT */\r
2730       __HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_OUTI);\r
2731       /* Disable CRYP */\r
2732       __HAL_CRYP_DISABLE(hcryp);\r
2733       /* Process Unlocked */\r
2734       __HAL_UNLOCK(hcryp);\r
2735       /* Change the CRYP state */\r
2736       hcryp->State = HAL_CRYP_STATE_READY;\r
2737       /* Call Input transfer complete callback */\r
2738       HAL_CRYP_OutCpltCallback(hcryp);\r
2739     }\r
2740   }\r
2741   \r
2742   /* Return function status */\r
2743   return HAL_OK;\r
2744 }\r
2745 \r
2746 /**\r
2747   * @brief  Initializes the CRYP peripheral in DES ECB encryption mode using DMA.\r
2748   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
2749   *         the configuration information for CRYP module\r
2750   * @param  pPlainData: Pointer to the plaintext buffer\r
2751   * @param  Size: Length of the plaintext buffer, must be a multiple of 8\r
2752   * @param  pCypherData: Pointer to the cyphertext buffer\r
2753   * @retval HAL status\r
2754   */\r
2755 HAL_StatusTypeDef HAL_CRYP_DESECB_Encrypt_DMA(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData)\r
2756 {\r
2757   uint32_t inputaddr;\r
2758   uint32_t outputaddr;\r
2759   \r
2760   if((hcryp->State == HAL_CRYP_STATE_READY) || (hcryp->Phase == HAL_CRYP_PHASE_PROCESS))\r
2761   {\r
2762     /* Process Locked */\r
2763     __HAL_LOCK(hcryp);\r
2764     \r
2765     inputaddr  = (uint32_t)pPlainData;\r
2766     outputaddr = (uint32_t)pCypherData;\r
2767     \r
2768     /* Change the CRYP state */\r
2769     hcryp->State = HAL_CRYP_STATE_BUSY;\r
2770     \r
2771     /* Set CRYP peripheral in DES ECB encryption mode */\r
2772     CRYP_SetDESECBMode(hcryp, 0);\r
2773     \r
2774     /* Set the input and output addresses and start DMA transfer */ \r
2775     CRYP_SetDMAConfig(hcryp, inputaddr, Size, outputaddr);\r
2776     \r
2777     /* Process Unlocked */\r
2778     __HAL_UNLOCK(hcryp);\r
2779     \r
2780     /* Return function status */\r
2781     return HAL_OK;\r
2782   }\r
2783   else\r
2784   {\r
2785     return HAL_ERROR;   \r
2786   }\r
2787 }\r
2788 \r
2789 /**\r
2790   * @brief  Initializes the CRYP peripheral in DES CBC encryption mode using DMA.\r
2791   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
2792   *         the configuration information for CRYP module\r
2793   * @param  pPlainData: Pointer to the plaintext buffer\r
2794   * @param  Size: Length of the plaintext buffer, must be a multiple of 8\r
2795   * @param  pCypherData: Pointer to the cyphertext buffer\r
2796   * @retval HAL status\r
2797   */\r
2798 HAL_StatusTypeDef HAL_CRYP_DESCBC_Encrypt_DMA(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData)\r
2799 {\r
2800   uint32_t inputaddr;\r
2801   uint32_t outputaddr;\r
2802   \r
2803   if((hcryp->State == HAL_CRYP_STATE_READY) || (hcryp->Phase == HAL_CRYP_PHASE_PROCESS))\r
2804   {\r
2805     /* Process Locked */\r
2806     __HAL_LOCK(hcryp);\r
2807     \r
2808     inputaddr  = (uint32_t)pPlainData;\r
2809     outputaddr = (uint32_t)pCypherData;\r
2810     \r
2811     /* Change the CRYP state */\r
2812     hcryp->State = HAL_CRYP_STATE_BUSY;\r
2813     \r
2814     /* Set CRYP peripheral in DES CBC encryption mode */\r
2815     CRYP_SetDESCBCMode(hcryp, 0);\r
2816     \r
2817     /* Set the input and output addresses and start DMA transfer */ \r
2818     CRYP_SetDMAConfig(hcryp, inputaddr, Size, outputaddr);\r
2819     \r
2820     /* Process Unlocked */\r
2821     __HAL_UNLOCK(hcryp);\r
2822     \r
2823     /* Return function status */\r
2824     return HAL_OK;\r
2825   }\r
2826   else\r
2827   {\r
2828     return HAL_ERROR;   \r
2829   }\r
2830 }\r
2831 \r
2832 /**\r
2833   * @brief  Initializes the CRYP peripheral in DES ECB decryption mode using DMA.\r
2834   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
2835   *         the configuration information for CRYP module\r
2836   * @param  pPlainData: Pointer to the plaintext buffer\r
2837   * @param  Size: Length of the plaintext buffer, must be a multiple of 8\r
2838   * @param  pCypherData: Pointer to the cyphertext buffer\r
2839   * @retval HAL status\r
2840   */\r
2841 HAL_StatusTypeDef HAL_CRYP_DESECB_Decrypt_DMA(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData)\r
2842 {\r
2843   uint32_t inputaddr;\r
2844   uint32_t outputaddr;\r
2845   \r
2846   if((hcryp->State == HAL_CRYP_STATE_READY) || (hcryp->Phase == HAL_CRYP_PHASE_PROCESS))\r
2847   {\r
2848     /* Process Locked */\r
2849     __HAL_LOCK(hcryp);\r
2850     \r
2851     inputaddr  = (uint32_t)pCypherData;\r
2852     outputaddr = (uint32_t)pPlainData;\r
2853     \r
2854     /* Change the CRYP state */\r
2855     hcryp->State = HAL_CRYP_STATE_BUSY;\r
2856     \r
2857     /* Set CRYP peripheral in DES ECB decryption mode */\r
2858     CRYP_SetDESECBMode(hcryp, CRYP_CR_ALGODIR);\r
2859     \r
2860     /* Set the input and output addresses and start DMA transfer */ \r
2861     CRYP_SetDMAConfig(hcryp, inputaddr, Size, outputaddr);\r
2862     \r
2863     /* Process Unlocked */\r
2864     __HAL_UNLOCK(hcryp);\r
2865     \r
2866     /* Return function status */\r
2867     return HAL_OK;\r
2868   }\r
2869   else\r
2870   {\r
2871     return HAL_ERROR;   \r
2872   }\r
2873 }\r
2874 \r
2875 /**\r
2876   * @brief  Initializes the CRYP peripheral in DES ECB decryption mode using DMA.\r
2877   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
2878   *         the configuration information for CRYP module\r
2879   * @param  pPlainData: Pointer to the plaintext buffer\r
2880   * @param  Size: Length of the plaintext buffer, must be a multiple of 8\r
2881   * @param  pCypherData: Pointer to the cyphertext buffer\r
2882   * @retval HAL status\r
2883   */\r
2884 HAL_StatusTypeDef HAL_CRYP_DESCBC_Decrypt_DMA(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData)\r
2885 {\r
2886   uint32_t inputaddr;\r
2887   uint32_t outputaddr;\r
2888   \r
2889   if((hcryp->State == HAL_CRYP_STATE_READY) || (hcryp->Phase == HAL_CRYP_PHASE_PROCESS))\r
2890   {\r
2891     /* Process Locked */\r
2892     __HAL_LOCK(hcryp);\r
2893     \r
2894     inputaddr  = (uint32_t)pCypherData;\r
2895     outputaddr = (uint32_t)pPlainData;\r
2896     \r
2897     /* Change the CRYP state */\r
2898     hcryp->State = HAL_CRYP_STATE_BUSY;\r
2899     \r
2900     /* Set CRYP peripheral in DES CBC decryption mode */\r
2901     CRYP_SetDESCBCMode(hcryp, CRYP_CR_ALGODIR);\r
2902     \r
2903     /* Set the input and output addresses and start DMA transfer */ \r
2904     CRYP_SetDMAConfig(hcryp, inputaddr, Size, outputaddr);\r
2905     \r
2906     /* Process Unlocked */\r
2907     __HAL_UNLOCK(hcryp);\r
2908     \r
2909     /* Return function status */\r
2910     return HAL_OK;\r
2911   }\r
2912   else\r
2913   {\r
2914     return HAL_ERROR;   \r
2915   }\r
2916 }\r
2917 \r
2918 /**\r
2919   * @}\r
2920   */\r
2921 \r
2922 /** @defgroup CRYP_Exported_Functions_Group4 TDES processing functions \r
2923  *  @brief   processing functions. \r
2924  *\r
2925 @verbatim   \r
2926   ==============================================================================\r
2927                       ##### TDES processing functions #####\r
2928   ==============================================================================  \r
2929     [..]  This section provides functions allowing to:\r
2930       (+) Encrypt plaintext using TDES based on ECB or CBC chaining modes\r
2931       (+) Decrypt cyphertext using TDES based on ECB or CBC chaining modes\r
2932     [..]  Three processing functions are available:\r
2933       (+) Polling mode\r
2934       (+) Interrupt mode\r
2935       (+) DMA mode\r
2936 \r
2937 @endverbatim\r
2938   * @{\r
2939   */\r
2940 \r
2941 /**\r
2942   * @brief  Initializes the CRYP peripheral in TDES ECB encryption mode\r
2943   *         then encrypt pPlainData. The cypher data are available in pCypherData\r
2944   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
2945   *         the configuration information for CRYP module\r
2946   * @param  pPlainData: Pointer to the plaintext buffer\r
2947   * @param  Size: Length of the plaintext buffer, must be a multiple of 8\r
2948   * @param  pCypherData: Pointer to the cyphertext buffer\r
2949   * @param  Timeout: Specify Timeout value  \r
2950   * @retval HAL status\r
2951   */\r
2952 HAL_StatusTypeDef HAL_CRYP_TDESECB_Encrypt(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData, uint32_t Timeout)\r
2953 {\r
2954   /* Process Locked */\r
2955   __HAL_LOCK(hcryp);\r
2956   \r
2957   /* Change the CRYP state */\r
2958   hcryp->State = HAL_CRYP_STATE_BUSY;\r
2959   \r
2960   /* Set CRYP peripheral in TDES ECB encryption mode */\r
2961   CRYP_SetTDESECBMode(hcryp, 0);\r
2962   \r
2963   /* Enable CRYP */\r
2964   __HAL_CRYP_ENABLE(hcryp);\r
2965   \r
2966   /* Write Plain Data and Get Cypher Data */\r
2967   if(CRYP_ProcessData2Words(hcryp, pPlainData, Size, pCypherData, Timeout) != HAL_OK)\r
2968   {\r
2969     return HAL_TIMEOUT;\r
2970   }\r
2971   \r
2972   /* Change the CRYP state */\r
2973   hcryp->State = HAL_CRYP_STATE_READY;\r
2974   \r
2975   /* Process Unlocked */\r
2976   __HAL_UNLOCK(hcryp);\r
2977   \r
2978   /* Return function status */\r
2979   return HAL_OK;\r
2980 }\r
2981 \r
2982 /**\r
2983   * @brief  Initializes the CRYP peripheral in TDES ECB decryption mode\r
2984   *         then decrypted pCypherData. The cypher data are available in pPlainData\r
2985   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
2986   *         the configuration information for CRYP module\r
2987   * @param  pPlainData: Pointer to the plaintext buffer\r
2988   * @param  Size: Length of the plaintext buffer, must be a multiple of 8\r
2989   * @param  pCypherData: Pointer to the cyphertext buffer\r
2990   * @param  Timeout: Specify Timeout value  \r
2991   * @retval HAL status\r
2992   */\r
2993 HAL_StatusTypeDef HAL_CRYP_TDESECB_Decrypt(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData, uint32_t Timeout)\r
2994 {  \r
2995   /* Process Locked */\r
2996   __HAL_LOCK(hcryp);\r
2997   \r
2998   /* Change the CRYP state */\r
2999   hcryp->State = HAL_CRYP_STATE_BUSY;\r
3000   \r
3001   /* Set CRYP peripheral in TDES ECB decryption mode */\r
3002   CRYP_SetTDESECBMode(hcryp, CRYP_CR_ALGODIR);\r
3003   \r
3004   /* Enable CRYP */\r
3005   __HAL_CRYP_ENABLE(hcryp);\r
3006   \r
3007   /* Write Cypher Data and Get Plain Data */\r
3008   if(CRYP_ProcessData2Words(hcryp, pCypherData, Size, pPlainData, Timeout) != HAL_OK)\r
3009   {\r
3010     return HAL_TIMEOUT;\r
3011   }\r
3012   \r
3013   /* Change the CRYP state */\r
3014   hcryp->State = HAL_CRYP_STATE_READY;\r
3015   \r
3016   /* Process Unlocked */\r
3017   __HAL_UNLOCK(hcryp);\r
3018   \r
3019   /* Return function status */\r
3020   return HAL_OK;\r
3021 }\r
3022 \r
3023 /**\r
3024   * @brief  Initializes the CRYP peripheral in TDES CBC encryption mode\r
3025   *         then encrypt pPlainData. The cypher data are available in pCypherData\r
3026   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
3027   *         the configuration information for CRYP module\r
3028   * @param  pPlainData: Pointer to the plaintext buffer\r
3029   * @param  Size: Length of the plaintext buffer, must be a multiple of 8\r
3030   * @param  pCypherData: Pointer to the cyphertext buffer\r
3031   * @param  Timeout: Specify Timeout value  \r
3032   * @retval HAL status\r
3033   */\r
3034 HAL_StatusTypeDef HAL_CRYP_TDESCBC_Encrypt(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData, uint32_t Timeout)\r
3035 {\r
3036   /* Process Locked */\r
3037   __HAL_LOCK(hcryp);\r
3038   \r
3039   /* Change the CRYP state */\r
3040   hcryp->State = HAL_CRYP_STATE_BUSY;\r
3041   \r
3042   /* Set CRYP peripheral in TDES CBC encryption mode */\r
3043   CRYP_SetTDESCBCMode(hcryp, 0);\r
3044   \r
3045   /* Enable CRYP */\r
3046   __HAL_CRYP_ENABLE(hcryp);\r
3047   \r
3048   /* Write Plain Data and Get Cypher Data */\r
3049   if(CRYP_ProcessData2Words(hcryp, pPlainData, Size, pCypherData, Timeout) != HAL_OK)\r
3050   {\r
3051     return HAL_TIMEOUT;\r
3052   }\r
3053   \r
3054   /* Change the CRYP state */\r
3055   hcryp->State = HAL_CRYP_STATE_READY;\r
3056   \r
3057   /* Process Unlocked */\r
3058   __HAL_UNLOCK(hcryp);\r
3059   \r
3060   /* Return function status */\r
3061   return HAL_OK;\r
3062 }\r
3063 \r
3064 /**\r
3065   * @brief  Initializes the CRYP peripheral in TDES CBC decryption mode\r
3066   *         then decrypted pCypherData. The cypher data are available in pPlainData\r
3067   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
3068   *         the configuration information for CRYP module\r
3069   * @param  pCypherData: Pointer to the cyphertext buffer\r
3070   * @param  Size: Length of the plaintext buffer, must be a multiple of 8\r
3071   * @param  pPlainData: Pointer to the plaintext buffer\r
3072   * @param  Timeout: Specify Timeout value  \r
3073   * @retval HAL status\r
3074   */\r
3075 HAL_StatusTypeDef HAL_CRYP_TDESCBC_Decrypt(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData, uint32_t Timeout)\r
3076 {\r
3077   /* Process Locked */\r
3078   __HAL_LOCK(hcryp);\r
3079   \r
3080   /* Change the CRYP state */\r
3081   hcryp->State = HAL_CRYP_STATE_BUSY;\r
3082   \r
3083   /* Set CRYP peripheral in TDES CBC decryption mode */\r
3084   CRYP_SetTDESCBCMode(hcryp, CRYP_CR_ALGODIR);\r
3085   \r
3086   /* Enable CRYP */\r
3087   __HAL_CRYP_ENABLE(hcryp);\r
3088   \r
3089   /* Write Cypher Data and Get Plain Data */\r
3090   if(CRYP_ProcessData2Words(hcryp, pCypherData, Size, pPlainData, Timeout) != HAL_OK)\r
3091   {\r
3092     return HAL_TIMEOUT;\r
3093   }\r
3094   \r
3095   /* Change the CRYP state */\r
3096   hcryp->State = HAL_CRYP_STATE_READY;\r
3097   \r
3098   /* Process Unlocked */\r
3099   __HAL_UNLOCK(hcryp);\r
3100   \r
3101   /* Return function status */\r
3102   return HAL_OK;\r
3103 }\r
3104 \r
3105 /**\r
3106   * @brief  Initializes the CRYP peripheral in TDES ECB encryption mode using interrupt.\r
3107   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
3108   *         the configuration information for CRYP module\r
3109   * @param  pPlainData: Pointer to the plaintext buffer\r
3110   * @param  Size: Length of the plaintext buffer, must be a multiple of 8\r
3111   * @param  pCypherData: Pointer to the cyphertext buffer\r
3112   * @retval HAL status\r
3113   */\r
3114 HAL_StatusTypeDef HAL_CRYP_TDESECB_Encrypt_IT(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData)\r
3115 {\r
3116   uint32_t inputaddr;\r
3117   uint32_t outputaddr;\r
3118   \r
3119   if(hcryp->State == HAL_CRYP_STATE_READY)\r
3120   {\r
3121     /* Process Locked */\r
3122     __HAL_LOCK(hcryp);\r
3123     \r
3124     hcryp->CrypInCount = Size;\r
3125     hcryp->pCrypInBuffPtr = pPlainData;\r
3126     hcryp->pCrypOutBuffPtr = pCypherData;\r
3127     hcryp->CrypOutCount = Size;\r
3128     \r
3129     /* Change the CRYP state */\r
3130     hcryp->State = HAL_CRYP_STATE_BUSY;\r
3131     \r
3132     /* Set CRYP peripheral in TDES ECB encryption mode */\r
3133     CRYP_SetTDESECBMode(hcryp, 0);\r
3134     \r
3135     /* Enable Interrupts */\r
3136     __HAL_CRYP_ENABLE_IT(hcryp, CRYP_IT_INI | CRYP_IT_OUTI);\r
3137     \r
3138     /* Enable CRYP */\r
3139     __HAL_CRYP_ENABLE(hcryp);\r
3140     \r
3141     /* Return function status */\r
3142     return HAL_OK;\r
3143   }\r
3144   else if(__HAL_CRYP_GET_IT(hcryp, CRYP_IT_INI))\r
3145   {\r
3146     inputaddr = (uint32_t)hcryp->pCrypInBuffPtr;\r
3147     /* Write the Input block in the IN FIFO */\r
3148     hcryp->Instance->DR = *(uint32_t*)(inputaddr);\r
3149     inputaddr+=4;\r
3150     hcryp->Instance->DR = *(uint32_t*)(inputaddr);\r
3151 \r
3152     hcryp->pCrypInBuffPtr += 8;\r
3153     hcryp->CrypInCount -= 8;\r
3154     if(hcryp->CrypInCount == 0)\r
3155     {\r
3156       __HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_INI);\r
3157       /* Call the Input data transfer complete callback */\r
3158       HAL_CRYP_InCpltCallback(hcryp);\r
3159     }\r
3160   }\r
3161   else if(__HAL_CRYP_GET_IT(hcryp, CRYP_IT_OUTI))\r
3162   {\r
3163     outputaddr = (uint32_t)hcryp->pCrypOutBuffPtr;\r
3164     /* Read the Output block from the Output FIFO */\r
3165     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
3166     outputaddr+=4;\r
3167     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
3168 \r
3169     hcryp->pCrypOutBuffPtr += 8;\r
3170     hcryp->CrypOutCount -= 8;\r
3171     if(hcryp->CrypOutCount == 0)\r
3172     {\r
3173       /* Disable IT */\r
3174       __HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_OUTI);\r
3175       /* Disable CRYP */\r
3176       __HAL_CRYP_DISABLE(hcryp);\r
3177       /* Process Unlocked */\r
3178       __HAL_UNLOCK(hcryp);\r
3179       /* Change the CRYP state */\r
3180       hcryp->State = HAL_CRYP_STATE_READY;\r
3181       /* Call the Output data transfer complete callback */\r
3182       HAL_CRYP_OutCpltCallback(hcryp);\r
3183     }\r
3184   }\r
3185   \r
3186   /* Return function status */\r
3187   return HAL_OK;\r
3188 }\r
3189 \r
3190 /**\r
3191   * @brief  Initializes the CRYP peripheral in TDES CBC encryption mode.\r
3192   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
3193   *         the configuration information for CRYP module\r
3194   * @param  pPlainData: Pointer to the plaintext buffer\r
3195   * @param  Size: Length of the plaintext buffer, must be a multiple of 8\r
3196   * @param  pCypherData: Pointer to the cyphertext buffer\r
3197   * @retval HAL status\r
3198   */\r
3199 HAL_StatusTypeDef HAL_CRYP_TDESCBC_Encrypt_IT(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData)\r
3200 {\r
3201   uint32_t inputaddr;\r
3202   uint32_t outputaddr;\r
3203   \r
3204   if(hcryp->State == HAL_CRYP_STATE_READY)\r
3205   {\r
3206     /* Process Locked */\r
3207     __HAL_LOCK(hcryp);\r
3208     \r
3209     hcryp->CrypInCount = Size;\r
3210     hcryp->pCrypInBuffPtr = pPlainData;\r
3211     hcryp->pCrypOutBuffPtr = pCypherData;\r
3212     hcryp->CrypOutCount = Size;\r
3213     \r
3214     /* Change the CRYP state */\r
3215     hcryp->State = HAL_CRYP_STATE_BUSY;\r
3216     \r
3217     /* Set CRYP peripheral in TDES CBC encryption mode */\r
3218     CRYP_SetTDESCBCMode(hcryp, 0);\r
3219     \r
3220     /* Enable Interrupts */\r
3221     __HAL_CRYP_ENABLE_IT(hcryp, CRYP_IT_INI | CRYP_IT_OUTI);\r
3222     \r
3223     /* Enable CRYP */\r
3224     __HAL_CRYP_ENABLE(hcryp);\r
3225     \r
3226     /* Return function status */\r
3227     return HAL_OK;\r
3228   }\r
3229   else if(__HAL_CRYP_GET_IT(hcryp, CRYP_IT_INI))\r
3230   {\r
3231     inputaddr = (uint32_t)hcryp->pCrypInBuffPtr;\r
3232     /* Write the Input block in the IN FIFO */\r
3233     hcryp->Instance->DR = *(uint32_t*)(inputaddr);\r
3234     inputaddr+=4;\r
3235     hcryp->Instance->DR = *(uint32_t*)(inputaddr);\r
3236 \r
3237     hcryp->pCrypInBuffPtr += 8;\r
3238     hcryp->CrypInCount -= 8;\r
3239     if(hcryp->CrypInCount == 0)\r
3240     {\r
3241       __HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_INI);\r
3242       /* Call the Input data transfer complete callback */\r
3243       HAL_CRYP_InCpltCallback(hcryp);\r
3244     }\r
3245   }\r
3246   else if(__HAL_CRYP_GET_IT(hcryp, CRYP_IT_OUTI))\r
3247   {\r
3248     outputaddr = (uint32_t)hcryp->pCrypOutBuffPtr;\r
3249     /* Read the Output block from the Output FIFO */\r
3250     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
3251     outputaddr+=4;\r
3252     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
3253         \r
3254     hcryp->pCrypOutBuffPtr += 8;\r
3255     hcryp->CrypOutCount -= 8;\r
3256     if(hcryp->CrypOutCount == 0)\r
3257     {\r
3258       __HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_OUTI);\r
3259       /* Disable CRYP */\r
3260       __HAL_CRYP_DISABLE(hcryp);\r
3261       /* Process Unlocked */\r
3262       __HAL_UNLOCK(hcryp);\r
3263       /* Change the CRYP state */\r
3264       hcryp->State = HAL_CRYP_STATE_READY;\r
3265       /* Call Input transfer complete callback */\r
3266       HAL_CRYP_OutCpltCallback(hcryp);\r
3267     }\r
3268   }\r
3269   \r
3270   /* Return function status */\r
3271   return HAL_OK;\r
3272 }\r
3273 \r
3274 /**\r
3275   * @brief  Initializes the CRYP peripheral in TDES ECB decryption mode.\r
3276   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
3277   *         the configuration information for CRYP module\r
3278   * @param  pPlainData: Pointer to the plaintext buffer\r
3279   * @param  Size: Length of the plaintext buffer, must be a multiple of 8\r
3280   * @param  pCypherData: Pointer to the cyphertext buffer\r
3281   * @retval HAL status\r
3282   */\r
3283 HAL_StatusTypeDef HAL_CRYP_TDESECB_Decrypt_IT(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData)\r
3284 {\r
3285   uint32_t inputaddr;\r
3286   uint32_t outputaddr;\r
3287   \r
3288   if(hcryp->State == HAL_CRYP_STATE_READY)\r
3289   {\r
3290     /* Process Locked */\r
3291     __HAL_LOCK(hcryp);\r
3292     \r
3293     hcryp->CrypInCount = Size;\r
3294     hcryp->pCrypInBuffPtr = pCypherData;\r
3295     hcryp->pCrypOutBuffPtr = pPlainData;\r
3296     hcryp->CrypOutCount = Size;\r
3297     \r
3298     /* Change the CRYP state */\r
3299     hcryp->State = HAL_CRYP_STATE_BUSY;\r
3300     \r
3301     /* Set CRYP peripheral in TDES ECB decryption mode */\r
3302     CRYP_SetTDESECBMode(hcryp, CRYP_CR_ALGODIR);\r
3303     \r
3304     /* Enable Interrupts */\r
3305     __HAL_CRYP_ENABLE_IT(hcryp, CRYP_IT_INI | CRYP_IT_OUTI);\r
3306     \r
3307     /* Enable CRYP */\r
3308     __HAL_CRYP_ENABLE(hcryp);\r
3309     \r
3310     /* Return function status */\r
3311     return HAL_OK;\r
3312   }\r
3313   else if(__HAL_CRYP_GET_IT(hcryp, CRYP_IT_INI))\r
3314   {\r
3315     inputaddr = (uint32_t)hcryp->pCrypInBuffPtr;\r
3316     /* Write the Input block in the IN FIFO */\r
3317     hcryp->Instance->DR = *(uint32_t*)(inputaddr);\r
3318     inputaddr+=4;\r
3319     hcryp->Instance->DR = *(uint32_t*)(inputaddr);\r
3320 \r
3321     hcryp->pCrypInBuffPtr += 8;\r
3322     hcryp->CrypInCount -= 8;\r
3323     if(hcryp->CrypInCount == 0)\r
3324     {\r
3325       __HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_INI);\r
3326       /* Call the Input data transfer complete callback */\r
3327       HAL_CRYP_InCpltCallback(hcryp);\r
3328     }\r
3329   }\r
3330   else if(__HAL_CRYP_GET_IT(hcryp, CRYP_IT_OUTI))\r
3331   {\r
3332     outputaddr = (uint32_t)hcryp->pCrypOutBuffPtr;\r
3333     /* Read the Output block from the Output FIFO */\r
3334     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
3335     outputaddr+=4;\r
3336     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
3337 \r
3338     hcryp->pCrypOutBuffPtr += 8;\r
3339     hcryp->CrypOutCount -= 8;\r
3340     if(hcryp->CrypOutCount == 0)\r
3341     {\r
3342       __HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_OUTI);\r
3343       /* Disable CRYP */\r
3344       __HAL_CRYP_DISABLE(hcryp);\r
3345       /* Process Unlocked */\r
3346       __HAL_UNLOCK(hcryp);\r
3347       /* Change the CRYP state */\r
3348       hcryp->State = HAL_CRYP_STATE_READY;\r
3349       /* Call Input transfer complete callback */\r
3350       HAL_CRYP_OutCpltCallback(hcryp);\r
3351     }\r
3352   }\r
3353   \r
3354   /* Return function status */\r
3355   return HAL_OK;\r
3356 } \r
3357 \r
3358 /**\r
3359   * @brief  Initializes the CRYP peripheral in TDES CBC decryption mode.\r
3360   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
3361   *         the configuration information for CRYP module\r
3362   * @param  pCypherData: Pointer to the cyphertext buffer\r
3363   * @param  Size: Length of the plaintext buffer, must be a multiple of 8\r
3364   * @param  pPlainData: Pointer to the plaintext buffer\r
3365   * @retval HAL status\r
3366   */\r
3367 HAL_StatusTypeDef HAL_CRYP_TDESCBC_Decrypt_IT(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData)\r
3368 {\r
3369   uint32_t inputaddr;\r
3370   uint32_t outputaddr;\r
3371   \r
3372   if(hcryp->State == HAL_CRYP_STATE_READY)\r
3373   {\r
3374     /* Process Locked */\r
3375     __HAL_LOCK(hcryp);\r
3376     \r
3377     hcryp->CrypInCount = Size;\r
3378     hcryp->pCrypInBuffPtr = pCypherData;\r
3379     hcryp->pCrypOutBuffPtr = pPlainData;\r
3380     hcryp->CrypOutCount = Size;\r
3381     \r
3382     /* Change the CRYP state */\r
3383     hcryp->State = HAL_CRYP_STATE_BUSY;\r
3384     \r
3385     /* Set CRYP peripheral in TDES CBC decryption mode */\r
3386     CRYP_SetTDESCBCMode(hcryp, CRYP_CR_ALGODIR);\r
3387     \r
3388     /* Enable Interrupts */\r
3389     __HAL_CRYP_ENABLE_IT(hcryp, CRYP_IT_INI | CRYP_IT_OUTI);\r
3390     \r
3391     /* Enable CRYP */\r
3392     __HAL_CRYP_ENABLE(hcryp);\r
3393     \r
3394     /* Return function status */\r
3395     return HAL_OK;\r
3396   }\r
3397   else if(__HAL_CRYP_GET_IT(hcryp, CRYP_IT_INI))\r
3398   {\r
3399     inputaddr = (uint32_t)hcryp->pCrypInBuffPtr;\r
3400     /* Write the Input block in the IN FIFO */\r
3401     hcryp->Instance->DR = *(uint32_t*)(inputaddr);\r
3402     inputaddr+=4;\r
3403     hcryp->Instance->DR = *(uint32_t*)(inputaddr);\r
3404 \r
3405     hcryp->pCrypInBuffPtr += 8;\r
3406     hcryp->CrypInCount -= 8;\r
3407     if(hcryp->CrypInCount == 0)\r
3408     {\r
3409       __HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_INI);\r
3410       /* Call the Input data transfer complete callback */\r
3411       HAL_CRYP_InCpltCallback(hcryp);\r
3412     }\r
3413   }\r
3414   else if(__HAL_CRYP_GET_IT(hcryp, CRYP_IT_OUTI))\r
3415   {\r
3416     outputaddr = (uint32_t)hcryp->pCrypOutBuffPtr;\r
3417     /* Read the Output block from the Output FIFO */\r
3418     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
3419     outputaddr+=4;\r
3420     *(uint32_t*)(outputaddr) = hcryp->Instance->DOUT;\r
3421 \r
3422     hcryp->pCrypOutBuffPtr += 8;\r
3423     hcryp->CrypOutCount -= 8;\r
3424     if(hcryp->CrypOutCount == 0)\r
3425     {\r
3426       __HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_OUTI);\r
3427       /* Disable CRYP */\r
3428       __HAL_CRYP_DISABLE(hcryp);\r
3429       /* Process Unlocked */\r
3430       __HAL_UNLOCK(hcryp);\r
3431       /* Change the CRYP state */\r
3432       hcryp->State = HAL_CRYP_STATE_READY;\r
3433       /* Call Input transfer complete callback */\r
3434       HAL_CRYP_OutCpltCallback(hcryp);\r
3435     }\r
3436   }\r
3437   \r
3438   /* Return function status */\r
3439   return HAL_OK;\r
3440 }\r
3441 \r
3442 /**\r
3443   * @brief  Initializes the CRYP peripheral in TDES ECB encryption mode using DMA.\r
3444   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
3445   *         the configuration information for CRYP module\r
3446   * @param  pPlainData: Pointer to the plaintext buffer\r
3447   * @param  Size: Length of the plaintext buffer, must be a multiple of 8\r
3448   * @param  pCypherData: Pointer to the cyphertext buffer\r
3449   * @retval HAL status\r
3450   */\r
3451 HAL_StatusTypeDef HAL_CRYP_TDESECB_Encrypt_DMA(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData)\r
3452 {\r
3453   uint32_t inputaddr;\r
3454   uint32_t outputaddr;\r
3455   \r
3456   if((hcryp->State == HAL_CRYP_STATE_READY) || (hcryp->Phase == HAL_CRYP_PHASE_PROCESS))\r
3457   {\r
3458     /* Process Locked */\r
3459     __HAL_LOCK(hcryp);\r
3460     \r
3461     inputaddr  = (uint32_t)pPlainData;\r
3462     outputaddr = (uint32_t)pCypherData;\r
3463     \r
3464     /* Change the CRYP state */\r
3465     hcryp->State = HAL_CRYP_STATE_BUSY;\r
3466     \r
3467     /* Set CRYP peripheral in TDES ECB encryption mode */\r
3468     CRYP_SetTDESECBMode(hcryp, 0);\r
3469     \r
3470     /* Set the input and output addresses and start DMA transfer */ \r
3471     CRYP_SetDMAConfig(hcryp, inputaddr, Size, outputaddr);\r
3472     \r
3473     /* Process Unlocked */\r
3474     __HAL_UNLOCK(hcryp);\r
3475     \r
3476     /* Return function status */\r
3477     return HAL_OK;\r
3478   }\r
3479   else\r
3480   {\r
3481     return HAL_ERROR;   \r
3482   }\r
3483 }\r
3484 \r
3485 /**\r
3486   * @brief  Initializes the CRYP peripheral in TDES CBC encryption mode using DMA.\r
3487   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
3488   *         the configuration information for CRYP module\r
3489   * @param  pPlainData: Pointer to the plaintext buffer\r
3490   * @param  Size: Length of the plaintext buffer, must be a multiple of 8\r
3491   * @param  pCypherData: Pointer to the cyphertext buffer\r
3492   * @retval HAL status\r
3493   */\r
3494 HAL_StatusTypeDef HAL_CRYP_TDESCBC_Encrypt_DMA(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData)\r
3495 {\r
3496   uint32_t inputaddr;\r
3497   uint32_t outputaddr;\r
3498   \r
3499   if((hcryp->State == HAL_CRYP_STATE_READY) || (hcryp->Phase == HAL_CRYP_PHASE_PROCESS))\r
3500   {\r
3501     /* Process Locked */\r
3502     __HAL_LOCK(hcryp);\r
3503     \r
3504     inputaddr  = (uint32_t)pPlainData;\r
3505     outputaddr = (uint32_t)pCypherData;\r
3506     \r
3507     /* Change the CRYP state */\r
3508     hcryp->State = HAL_CRYP_STATE_BUSY;\r
3509     \r
3510     /* Set CRYP peripheral in TDES CBC encryption mode */\r
3511     CRYP_SetTDESCBCMode(hcryp, 0);\r
3512     \r
3513     /* Set the input and output addresses and start DMA transfer */ \r
3514     CRYP_SetDMAConfig(hcryp, inputaddr, Size, outputaddr);\r
3515     \r
3516     /* Process Unlocked */\r
3517     __HAL_UNLOCK(hcryp);\r
3518     \r
3519     /* Return function status */\r
3520     return HAL_OK;\r
3521   }\r
3522   else\r
3523   {\r
3524     return HAL_ERROR;   \r
3525   }\r
3526 }\r
3527 \r
3528 /**\r
3529   * @brief  Initializes the CRYP peripheral in TDES ECB decryption mode using DMA.\r
3530   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
3531   *         the configuration information for CRYP module\r
3532   * @param  pPlainData: Pointer to the plaintext buffer\r
3533   * @param  Size: Length of the plaintext buffer, must be a multiple of 8\r
3534   * @param  pCypherData: Pointer to the cyphertext buffer\r
3535   * @retval HAL status\r
3536   */\r
3537 HAL_StatusTypeDef HAL_CRYP_TDESECB_Decrypt_DMA(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData)\r
3538 {\r
3539   uint32_t inputaddr;\r
3540   uint32_t outputaddr;\r
3541   \r
3542   if((hcryp->State == HAL_CRYP_STATE_READY) || (hcryp->Phase == HAL_CRYP_PHASE_PROCESS))\r
3543   {\r
3544     /* Process Locked */\r
3545     __HAL_LOCK(hcryp);\r
3546     \r
3547     inputaddr  = (uint32_t)pCypherData;\r
3548     outputaddr = (uint32_t)pPlainData;\r
3549     \r
3550     /* Change the CRYP state */\r
3551     hcryp->State = HAL_CRYP_STATE_BUSY;\r
3552     \r
3553     /* Set CRYP peripheral in TDES ECB decryption mode */\r
3554     CRYP_SetTDESECBMode(hcryp, CRYP_CR_ALGODIR);\r
3555     \r
3556     /* Set the input and output addresses and start DMA transfer */ \r
3557     CRYP_SetDMAConfig(hcryp, inputaddr, Size, outputaddr);\r
3558     \r
3559     /* Process Unlocked */\r
3560     __HAL_UNLOCK(hcryp);\r
3561     \r
3562     /* Return function status */\r
3563     return HAL_OK;\r
3564   }\r
3565   else\r
3566   {\r
3567     return HAL_ERROR;   \r
3568   }\r
3569 }\r
3570 \r
3571 /**\r
3572   * @brief  Initializes the CRYP peripheral in TDES CBC decryption mode using DMA.\r
3573   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
3574   *         the configuration information for CRYP module\r
3575   * @param  pCypherData: Pointer to the cyphertext buffer\r
3576   * @param  Size: Length of the plaintext buffer, must be a multiple of 8\r
3577   * @param  pPlainData: Pointer to the plaintext buffer\r
3578   * @retval HAL status\r
3579   */\r
3580 HAL_StatusTypeDef HAL_CRYP_TDESCBC_Decrypt_DMA(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData)\r
3581 {\r
3582   uint32_t inputaddr;\r
3583   uint32_t outputaddr;\r
3584   \r
3585   if((hcryp->State == HAL_CRYP_STATE_READY) || (hcryp->Phase == HAL_CRYP_PHASE_PROCESS))\r
3586   {\r
3587     /* Process Locked */\r
3588     __HAL_LOCK(hcryp);\r
3589     \r
3590     inputaddr  = (uint32_t)pCypherData;\r
3591     outputaddr = (uint32_t)pPlainData;\r
3592     \r
3593     /* Change the CRYP state */\r
3594     hcryp->State = HAL_CRYP_STATE_BUSY;\r
3595     \r
3596     /* Set CRYP peripheral in TDES CBC decryption mode */\r
3597     CRYP_SetTDESCBCMode(hcryp, CRYP_CR_ALGODIR);\r
3598     \r
3599     /* Set the input and output addresses and start DMA transfer */ \r
3600     CRYP_SetDMAConfig(hcryp, inputaddr, Size, outputaddr);\r
3601     \r
3602     /* Process Unlocked */\r
3603     __HAL_UNLOCK(hcryp);\r
3604     \r
3605     /* Return function status */\r
3606     return HAL_OK;\r
3607   }\r
3608   else\r
3609   {\r
3610     return HAL_ERROR;   \r
3611   }\r
3612 }\r
3613 \r
3614 /**\r
3615   * @}\r
3616   */\r
3617 \r
3618 /** @defgroup CRYP_Exported_Functions_Group5 DMA callback functions \r
3619  *  @brief   DMA callback functions. \r
3620  *\r
3621 @verbatim   \r
3622   ==============================================================================\r
3623                       ##### DMA callback functions  #####\r
3624   ==============================================================================  \r
3625     [..]  This section provides DMA callback functions:\r
3626       (+) DMA Input data transfer complete\r
3627       (+) DMA Output data transfer complete\r
3628       (+) DMA error\r
3629 \r
3630 @endverbatim\r
3631   * @{\r
3632   */\r
3633 \r
3634 /**\r
3635   * @brief  Input FIFO transfer completed callbacks.\r
3636   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
3637   *         the configuration information for CRYP module\r
3638   * @retval None\r
3639   */\r
3640 __weak void HAL_CRYP_InCpltCallback(CRYP_HandleTypeDef *hcryp)\r
3641 {\r
3642   /* NOTE : This function Should not be modified, when the callback is needed,\r
3643             the HAL_CRYP_InCpltCallback could be implemented in the user file\r
3644    */ \r
3645 }\r
3646 \r
3647 /**\r
3648   * @brief  Output FIFO transfer completed callbacks.\r
3649   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
3650   *         the configuration information for CRYP module\r
3651   * @retval None\r
3652   */\r
3653 __weak void HAL_CRYP_OutCpltCallback(CRYP_HandleTypeDef *hcryp)\r
3654 {\r
3655   /* NOTE : This function Should not be modified, when the callback is needed,\r
3656             the HAL_CRYP_OutCpltCallback could be implemented in the user file\r
3657    */\r
3658 }\r
3659 \r
3660 /**\r
3661   * @brief  CRYP error callbacks.\r
3662   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
3663   *         the configuration information for CRYP module\r
3664   * @retval None\r
3665   */\r
3666  __weak void HAL_CRYP_ErrorCallback(CRYP_HandleTypeDef *hcryp)\r
3667 {\r
3668   /* NOTE : This function Should not be modified, when the callback is needed,\r
3669             the HAL_CRYP_ErrorCallback could be implemented in the user file\r
3670    */ \r
3671 }\r
3672 \r
3673 /**\r
3674   * @}\r
3675   */\r
3676 \r
3677 /** @defgroup CRYP_Exported_Functions_Group6 CRYP IRQ handler management  \r
3678  *  @brief   CRYP IRQ handler.\r
3679  *\r
3680 @verbatim   \r
3681   ==============================================================================\r
3682                 ##### CRYP IRQ handler management #####\r
3683   ==============================================================================  \r
3684 [..]  This section provides CRYP IRQ handler function.\r
3685 \r
3686 @endverbatim\r
3687   * @{\r
3688   */\r
3689 \r
3690 /**\r
3691   * @brief  This function handles CRYP interrupt request.\r
3692   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
3693   *         the configuration information for CRYP module\r
3694   * @retval None\r
3695   */\r
3696 void HAL_CRYP_IRQHandler(CRYP_HandleTypeDef *hcryp)\r
3697 {\r
3698   switch(CRYP->CR & CRYP_CR_ALGOMODE_DIRECTION)\r
3699   {\r
3700   case CRYP_CR_ALGOMODE_TDES_ECB_ENCRYPT:\r
3701     HAL_CRYP_TDESECB_Encrypt_IT(hcryp, NULL, 0, NULL);\r
3702     break;\r
3703     \r
3704   case CRYP_CR_ALGOMODE_TDES_ECB_DECRYPT:\r
3705     HAL_CRYP_TDESECB_Decrypt_IT(hcryp, NULL, 0, NULL);\r
3706     break;\r
3707     \r
3708   case CRYP_CR_ALGOMODE_TDES_CBC_ENCRYPT:\r
3709     HAL_CRYP_TDESCBC_Encrypt_IT(hcryp, NULL, 0, NULL);\r
3710     break;\r
3711     \r
3712   case CRYP_CR_ALGOMODE_TDES_CBC_DECRYPT:\r
3713     HAL_CRYP_TDESCBC_Decrypt_IT(hcryp, NULL, 0, NULL);\r
3714     break;\r
3715     \r
3716   case CRYP_CR_ALGOMODE_DES_ECB_ENCRYPT:\r
3717     HAL_CRYP_DESECB_Encrypt_IT(hcryp, NULL, 0, NULL);\r
3718     break;\r
3719     \r
3720   case CRYP_CR_ALGOMODE_DES_ECB_DECRYPT:\r
3721     HAL_CRYP_DESECB_Decrypt_IT(hcryp, NULL, 0, NULL);\r
3722     break;\r
3723     \r
3724   case CRYP_CR_ALGOMODE_DES_CBC_ENCRYPT:\r
3725     HAL_CRYP_DESCBC_Encrypt_IT(hcryp, NULL, 0, NULL);\r
3726     break;\r
3727     \r
3728   case CRYP_CR_ALGOMODE_DES_CBC_DECRYPT:\r
3729     HAL_CRYP_DESCBC_Decrypt_IT(hcryp, NULL, 0, NULL);\r
3730     break;\r
3731     \r
3732   case CRYP_CR_ALGOMODE_AES_ECB_ENCRYPT:\r
3733     HAL_CRYP_AESECB_Encrypt_IT(hcryp, NULL, 0, NULL);\r
3734     break;\r
3735     \r
3736   case CRYP_CR_ALGOMODE_AES_ECB_DECRYPT:\r
3737     HAL_CRYP_AESECB_Decrypt_IT(hcryp, NULL, 0, NULL);\r
3738     break;\r
3739     \r
3740   case CRYP_CR_ALGOMODE_AES_CBC_ENCRYPT:\r
3741     HAL_CRYP_AESCBC_Encrypt_IT(hcryp, NULL, 0, NULL);\r
3742     break;\r
3743     \r
3744   case CRYP_CR_ALGOMODE_AES_CBC_DECRYPT:\r
3745     HAL_CRYP_AESCBC_Decrypt_IT(hcryp, NULL, 0, NULL);\r
3746     break;\r
3747     \r
3748   case CRYP_CR_ALGOMODE_AES_CTR_ENCRYPT:\r
3749     HAL_CRYP_AESCTR_Encrypt_IT(hcryp, NULL, 0, NULL);       \r
3750     break;\r
3751     \r
3752   case CRYP_CR_ALGOMODE_AES_CTR_DECRYPT:\r
3753     HAL_CRYP_AESCTR_Decrypt_IT(hcryp, NULL, 0, NULL);        \r
3754     break;\r
3755     \r
3756   default:\r
3757     break;\r
3758   }\r
3759 }\r
3760 \r
3761 /**\r
3762   * @}\r
3763   */\r
3764 \r
3765 /** @defgroup CRYP_Exported_Functions_Group7 Peripheral State functions \r
3766  *  @brief   Peripheral State functions. \r
3767  *\r
3768 @verbatim   \r
3769   ==============================================================================\r
3770                       ##### Peripheral State functions #####\r
3771   ==============================================================================  \r
3772     [..]\r
3773     This subsection permits to get in run-time the status of the peripheral.\r
3774 \r
3775 @endverbatim\r
3776   * @{\r
3777   */\r
3778 \r
3779 /**\r
3780   * @brief  Returns the CRYP state.\r
3781   * @param  hcryp: pointer to a CRYP_HandleTypeDef structure that contains\r
3782   *         the configuration information for CRYP module\r
3783   * @retval HAL state\r
3784   */\r
3785 HAL_CRYP_STATETypeDef HAL_CRYP_GetState(CRYP_HandleTypeDef *hcryp)\r
3786 {\r
3787   return hcryp->State;\r
3788 }\r
3789 \r
3790 /**\r
3791   * @}\r
3792   */\r
3793 \r
3794 /**\r
3795   * @}\r
3796   */\r
3797 \r
3798 #endif /* STM32F756xx */\r
3799 \r
3800 #endif /* HAL_CRYP_MODULE_ENABLED */\r
3801 /**\r
3802   * @}\r
3803   */\r
3804 \r
3805 /**\r
3806   * @}\r
3807   */\r
3808 \r
3809 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/\r