Steven Wray / mbed-dev

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Fork of mbed-dev by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32F4/stm32f4xx_hal_cryp.c@148:e70627d019e9, 2016-09-28 (annotated)

Committer:
StevieWray
Date:
Wed Sep 28 08:45:18 2016 +0000
Revision:
148:e70627d019e9
Parent:
144:ef7eb2e8f9f7 
Fixed DAC output on STM32F3 boards to allow 3 outputs

Who changed what in which revision?

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