mbed official / mbed-src

mbed library sources

Dependents:   Encrypted my_mbed lklk CyaSSL_DTLS_Cellular ... more

Superseded

This library was superseded by mbed-dev - https://os.mbed.com/users/mbed_official/code/mbed-dev/.

Development branch of the mbed library sources. This library is kept in synch with the latest changes from the mbed SDK and it is not guaranteed to work.

If you are looking for a stable and tested release, please import one of the official mbed library releases:

Import librarymbed

The official Mbed 2 C/C++ SDK provides the software platform and libraries to build your applications.

Last commit 20 Feb 2019 by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32L0/stm32l0xx_hal_cryp.c@579:53297373a894, 2015-07-01 (annotated)

Committer:
mbed_official
Date:
Wed Jul 01 09:45:11 2015 +0100
Revision:
579:53297373a894
Parent:
489:119543c9f674 
Synchronized with git revision d5b4d2ab9c47edb4dc5776e7177b0c2263459081



Full URL: https://github.com/mbedmicro/mbed/commit/d5b4d2ab9c47edb4dc5776e7177b0c2263459081/



Initial version of drivers for SAMR21

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbed_official 376:cb4d9db17537 1 /**
mbed_official 376:cb4d9db17537 2 ******************************************************************************
mbed_official 376:cb4d9db17537 3 * @file stm32l0xx_hal_cryp.c
mbed_official 376:cb4d9db17537 4 * @author MCD Application Team
mbed_official 489:119543c9f674 5 * @version V1.2.0
mbed_official 489:119543c9f674 6 * @date 06-February-2015
mbed_official 376:cb4d9db17537 7 * @brief CRYP HAL module driver.
mbed_official 376:cb4d9db17537 8 *
mbed_official 376:cb4d9db17537 9 * This file provides firmware functions to manage the following
mbed_official 376:cb4d9db17537 10 * functionalities of the Cryptography (CRYP) peripheral:
mbed_official 376:cb4d9db17537 11 * + Initialization and de-initialization functions
mbed_official 376:cb4d9db17537 12 * + Processing functions by algorithm using polling mode
mbed_official 376:cb4d9db17537 13 * + Processing functions by algorithm using interrupt mode
mbed_official 376:cb4d9db17537 14 * + Processing functions by algorithm using DMA mode
mbed_official 376:cb4d9db17537 15 * + Peripheral State functions
mbed_official 376:cb4d9db17537 16 *
mbed_official 376:cb4d9db17537 17 @verbatim
mbed_official 376:cb4d9db17537 18 ==============================================================================
mbed_official 376:cb4d9db17537 19 ##### How to use this driver #####
mbed_official 376:cb4d9db17537 20 ==============================================================================
mbed_official 376:cb4d9db17537 21 [..]
mbed_official 376:cb4d9db17537 22 The CRYP HAL driver can be used as follows:
mbed_official 376:cb4d9db17537 23
mbed_official 376:cb4d9db17537 24 (#)Initialize the CRYP low level resources by implementing the HAL_CRYP_MspInit():
mbed_official 489:119543c9f674 25 (##) Enable the CRYP interface clock using __HAL_RCC_AES_CLK_ENABLE()
mbed_official 489:119543c9f674 26 (##) In case of using interrupts (e.g. HAL_CRYP_AESECB_Encrypt_IT())
mbed_official 376:cb4d9db17537 27 (+) Configure the CRYP interrupt priority using HAL_NVIC_SetPriority()
mbed_official 376:cb4d9db17537 28 (+) Enable the CRYP IRQ handler using HAL_NVIC_EnableIRQ()
mbed_official 376:cb4d9db17537 29 (+) In CRYP IRQ handler, call HAL_CRYP_IRQHandler()
mbed_official 489:119543c9f674 30 (##) In case of using DMA to control data transfer (e.g. HAL_CRYP_AESECB_Encrypt_DMA())
mbed_official 376:cb4d9db17537 31 (+) Enable the DMA1 interface clock using
mbed_official 489:119543c9f674 32 (++) __HAL_RCC_DMA1_CLK_ENABLE()
mbed_official 376:cb4d9db17537 33 (+) Configure and enable two DMA Channels one for managing data transfer from
mbed_official 376:cb4d9db17537 34 memory to peripheral (input channel) and another channel for managing data
mbed_official 376:cb4d9db17537 35 transfer from peripheral to memory (output channel)
mbed_official 489:119543c9f674 36 (+) Associate the initialized DMA handle to the CRYP DMA handle
mbed_official 376:cb4d9db17537 37 using __HAL_LINKDMA()
mbed_official 376:cb4d9db17537 38 (+) Configure the priority and enable the NVIC for the transfer complete
mbed_official 376:cb4d9db17537 39 interrupt on the two DMA Streams. The output stream should have higher
mbed_official 376:cb4d9db17537 40 priority than the input stream.
mbed_official 376:cb4d9db17537 41 (++) HAL_NVIC_SetPriority()
mbed_official 376:cb4d9db17537 42 (++) HAL_NVIC_EnableIRQ()
mbed_official 376:cb4d9db17537 43
mbed_official 376:cb4d9db17537 44 (#)Initialize the CRYP HAL using HAL_CRYP_Init(). This function configures mainly:
mbed_official 376:cb4d9db17537 45 (##) The data type: 1-bit, 8-bit, 16-bit and 32-bit
mbed_official 376:cb4d9db17537 46 (##) The encryption/decryption key.
mbed_official 376:cb4d9db17537 47 (##) The initialization vector (counter). It is not used ECB mode.
mbed_official 376:cb4d9db17537 48
mbed_official 376:cb4d9db17537 49 (#)Three processing (encryption/decryption) functions are available:
mbed_official 376:cb4d9db17537 50 (##) Polling mode: encryption and decryption APIs are blocking functions
mbed_official 376:cb4d9db17537 51 i.e. they process the data and wait till the processing is finished
mbed_official 376:cb4d9db17537 52 e.g. HAL_CRYP_AESCBC_Encrypt()
mbed_official 376:cb4d9db17537 53 (##) Interrupt mode: encryption and decryption APIs are not blocking functions
mbed_official 376:cb4d9db17537 54 i.e. they process the data under interrupt
mbed_official 376:cb4d9db17537 55 e.g. HAL_CRYP_AESCBC_Encrypt_IT()
mbed_official 376:cb4d9db17537 56 (##) DMA mode: encryption and decryption APIs are not blocking functions
mbed_official 376:cb4d9db17537 57 i.e. the data transfer is ensured by DMA
mbed_official 376:cb4d9db17537 58 e.g. HAL_CRYP_AESCBC_Encrypt_DMA()
mbed_official 376:cb4d9db17537 59
mbed_official 489:119543c9f674 60 (#)When the processing function is called for the first time after HAL_CRYP_Init()
mbed_official 376:cb4d9db17537 61 the CRYP peripheral is initialized and processes the buffer in input.
mbed_official 376:cb4d9db17537 62 At second call, the processing function performs an append of the already
mbed_official 376:cb4d9db17537 63 processed buffer.
mbed_official 376:cb4d9db17537 64 When a new data block is to be processed, call HAL_CRYP_Init() then the
mbed_official 376:cb4d9db17537 65 processing function.
mbed_official 376:cb4d9db17537 66
mbed_official 489:119543c9f674 67 (#)Call HAL_CRYP_DeInit() to deinitialize the CRYP peripheral.
mbed_official 376:cb4d9db17537 68
mbed_official 376:cb4d9db17537 69 @endverbatim
mbed_official 376:cb4d9db17537 70 ******************************************************************************
mbed_official 376:cb4d9db17537 71 * @attention
mbed_official 376:cb4d9db17537 72 *
mbed_official 489:119543c9f674 73 * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
mbed_official 376:cb4d9db17537 74 *
mbed_official 376:cb4d9db17537 75 * Redistribution and use in source and binary forms, with or without modification,
mbed_official 376:cb4d9db17537 76 * are permitted provided that the following conditions are met:
mbed_official 376:cb4d9db17537 77 * 1. Redistributions of source code must retain the above copyright notice,
mbed_official 376:cb4d9db17537 78 * this list of conditions and the following disclaimer.
mbed_official 376:cb4d9db17537 79 * 2. Redistributions in binary form must reproduce the above copyright notice,
mbed_official 376:cb4d9db17537 80 * this list of conditions and the following disclaimer in the documentation
mbed_official 376:cb4d9db17537 81 * and/or other materials provided with the distribution.
mbed_official 376:cb4d9db17537 82 * 3. Neither the name of STMicroelectronics nor the names of its contributors
mbed_official 376:cb4d9db17537 83 * may be used to endorse or promote products derived from this software
mbed_official 376:cb4d9db17537 84 * without specific prior written permission.
mbed_official 376:cb4d9db17537 85 *
mbed_official 376:cb4d9db17537 86 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
mbed_official 376:cb4d9db17537 87 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
mbed_official 376:cb4d9db17537 88 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
mbed_official 376:cb4d9db17537 89 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
mbed_official 376:cb4d9db17537 90 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
mbed_official 376:cb4d9db17537 91 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
mbed_official 376:cb4d9db17537 92 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
mbed_official 376:cb4d9db17537 93 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
mbed_official 376:cb4d9db17537 94 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
mbed_official 376:cb4d9db17537 95 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
mbed_official 376:cb4d9db17537 96 *
mbed_official 376:cb4d9db17537 97 ******************************************************************************
mbed_official 376:cb4d9db17537 98 */
mbed_official 376:cb4d9db17537 99
mbed_official 489:119543c9f674 100 #if defined (STM32L041xx) || defined (STM32L061xx) || defined (STM32L062xx) || defined (STM32L063xx) || (STM32L081xx) || defined (STM32L082xx) || defined (STM32L083xx)
mbed_official 376:cb4d9db17537 101 /* Includes ------------------------------------------------------------------*/
mbed_official 376:cb4d9db17537 102 #include "stm32l0xx_hal.h"
mbed_official 376:cb4d9db17537 103
mbed_official 489:119543c9f674 104 #ifdef HAL_CRYP_MODULE_ENABLED
mbed_official 376:cb4d9db17537 105 /** @addtogroup STM32L0xx_HAL_Driver
mbed_official 376:cb4d9db17537 106 * @{
mbed_official 376:cb4d9db17537 107 */
mbed_official 376:cb4d9db17537 108
mbed_official 489:119543c9f674 109 /** @defgroup CRYP CRYP
mbed_official 376:cb4d9db17537 110 * @brief CRYP HAL module driver.
mbed_official 376:cb4d9db17537 111 * @{
mbed_official 376:cb4d9db17537 112 */
mbed_official 376:cb4d9db17537 113
mbed_official 376:cb4d9db17537 114
mbed_official 376:cb4d9db17537 115 /* Private typedef -----------------------------------------------------------*/
mbed_official 376:cb4d9db17537 116 /* Private define ------------------------------------------------------------*/
mbed_official 489:119543c9f674 117
mbed_official 489:119543c9f674 118 /** @defgroup CRYP_Private_Defines CRYP Private Defines
mbed_official 489:119543c9f674 119 * @{
mbed_official 489:119543c9f674 120 */
mbed_official 489:119543c9f674 121
mbed_official 376:cb4d9db17537 122 #define CRYP_ALGO_CHAIN_MASK (AES_CR_MODE | AES_CR_CHMOD)
mbed_official 489:119543c9f674 123
mbed_official 489:119543c9f674 124 /**
mbed_official 489:119543c9f674 125 * @}
mbed_official 489:119543c9f674 126 */
mbed_official 489:119543c9f674 127
mbed_official 376:cb4d9db17537 128 /* Private macro -------------------------------------------------------------*/
mbed_official 376:cb4d9db17537 129 /* Private variables ---------------------------------------------------------*/
mbed_official 376:cb4d9db17537 130 /* Private function prototypes -----------------------------------------------*/
mbed_official 376:cb4d9db17537 131
mbed_official 489:119543c9f674 132 /** @defgroup CRYP_Private_Functions CRYP Private Functions
mbed_official 376:cb4d9db17537 133 * @{
mbed_official 376:cb4d9db17537 134 */
mbed_official 376:cb4d9db17537 135
mbed_official 489:119543c9f674 136 static HAL_StatusTypeDef CRYP_EncryptDecrypt_IT(CRYP_HandleTypeDef *hcryp);
mbed_official 489:119543c9f674 137 static void CRYP_SetInitVector(CRYP_HandleTypeDef *hcryp, uint8_t *InitVector);
mbed_official 489:119543c9f674 138 static void CRYP_SetKey(CRYP_HandleTypeDef *hcryp, uint8_t *Key);
mbed_official 489:119543c9f674 139 static HAL_StatusTypeDef CRYP_ProcessData(CRYP_HandleTypeDef *hcryp, uint8_t* Input, uint16_t Ilength, uint8_t* Output, uint32_t Timeout);
mbed_official 489:119543c9f674 140 static void CRYP_DMAInCplt(DMA_HandleTypeDef *hdma);
mbed_official 489:119543c9f674 141 static void CRYP_DMAOutCplt(DMA_HandleTypeDef *hdma);
mbed_official 489:119543c9f674 142 static void CRYP_DMAError(DMA_HandleTypeDef *hdma);
mbed_official 489:119543c9f674 143 static void CRYP_SetDMAConfig(CRYP_HandleTypeDef *hcryp, uint32_t inputaddr, uint16_t Size, uint32_t outputaddr);
mbed_official 489:119543c9f674 144
mbed_official 489:119543c9f674 145 /**
mbed_official 489:119543c9f674 146 * @}
mbed_official 489:119543c9f674 147 */
mbed_official 489:119543c9f674 148
mbed_official 489:119543c9f674 149 /* Private functions ---------------------------------------------------------*/
mbed_official 489:119543c9f674 150
mbed_official 489:119543c9f674 151 /** @defgroup CRYP_Exported_Functions CRYP Exported Functions
mbed_official 489:119543c9f674 152 * @{
mbed_official 489:119543c9f674 153 */
mbed_official 489:119543c9f674 154
mbed_official 489:119543c9f674 155 /** @defgroup CRYP_Exported_Functions_Group1 Initialization and de-initialization functions
mbed_official 376:cb4d9db17537 156 * @brief Initialization and Configuration functions.
mbed_official 376:cb4d9db17537 157 *
mbed_official 376:cb4d9db17537 158 @verbatim
mbed_official 376:cb4d9db17537 159 ==============================================================================
mbed_official 376:cb4d9db17537 160 ##### Initialization and de-initialization functions #####
mbed_official 376:cb4d9db17537 161 ==============================================================================
mbed_official 376:cb4d9db17537 162 [..] This section provides functions allowing to:
mbed_official 376:cb4d9db17537 163 (+) Initialize the CRYP according to the specified parameters
mbed_official 376:cb4d9db17537 164 in the CRYP_InitTypeDef and creates the associated handle
mbed_official 376:cb4d9db17537 165 (+) DeInitialize the CRYP peripheral
mbed_official 376:cb4d9db17537 166 (+) Initialize the CRYP MSP
mbed_official 376:cb4d9db17537 167 (+) DeInitialize CRYP MSP
mbed_official 376:cb4d9db17537 168
mbed_official 376:cb4d9db17537 169 @endverbatim
mbed_official 376:cb4d9db17537 170 * @{
mbed_official 376:cb4d9db17537 171 */
mbed_official 376:cb4d9db17537 172
mbed_official 376:cb4d9db17537 173 /**
mbed_official 376:cb4d9db17537 174 * @brief Initializes the CRYP according to the specified
mbed_official 376:cb4d9db17537 175 * parameters in the CRYP_InitTypeDef and creates the associated handle.
mbed_official 376:cb4d9db17537 176 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 177 * the configuration information for CRYP module
mbed_official 376:cb4d9db17537 178 * @retval HAL status
mbed_official 376:cb4d9db17537 179 */
mbed_official 376:cb4d9db17537 180 HAL_StatusTypeDef HAL_CRYP_Init(CRYP_HandleTypeDef *hcryp)
mbed_official 489:119543c9f674 181 {
mbed_official 376:cb4d9db17537 182 /* Check the CRYP handle allocation */
mbed_official 489:119543c9f674 183 if(hcryp == NULL)
mbed_official 376:cb4d9db17537 184 {
mbed_official 376:cb4d9db17537 185 return HAL_ERROR;
mbed_official 376:cb4d9db17537 186 }
mbed_official 376:cb4d9db17537 187
mbed_official 376:cb4d9db17537 188 /* Check the parameters */
mbed_official 489:119543c9f674 189 assert_param(IS_AES_ALL_INSTANCE(hcryp->Instance));
mbed_official 376:cb4d9db17537 190 assert_param(IS_CRYP_DATATYPE(hcryp->Init.DataType));
mbed_official 376:cb4d9db17537 191
mbed_official 376:cb4d9db17537 192 if(hcryp->State == HAL_CRYP_STATE_RESET)
mbed_official 376:cb4d9db17537 193 {
mbed_official 489:119543c9f674 194 /* Allocate lock resource and initialize it */
mbed_official 489:119543c9f674 195 hcryp->Lock = HAL_UNLOCKED;
mbed_official 489:119543c9f674 196
mbed_official 376:cb4d9db17537 197 /* Init the low level hardware */
mbed_official 376:cb4d9db17537 198 HAL_CRYP_MspInit(hcryp);
mbed_official 376:cb4d9db17537 199 }
mbed_official 376:cb4d9db17537 200
mbed_official 489:119543c9f674 201 /* Check if AES already enabled */
mbed_official 489:119543c9f674 202 if (HAL_IS_BIT_CLR(hcryp->Instance->CR, AES_CR_EN))
mbed_official 489:119543c9f674 203 {
mbed_official 489:119543c9f674 204 /* Change the CRYP state */
mbed_official 489:119543c9f674 205 hcryp->State = HAL_CRYP_STATE_BUSY;
mbed_official 489:119543c9f674 206
mbed_official 489:119543c9f674 207 /* Set the data type*/
mbed_official 489:119543c9f674 208 MODIFY_REG(hcryp->Instance->CR, AES_CR_DATATYPE, hcryp->Init.DataType);
mbed_official 489:119543c9f674 209
mbed_official 489:119543c9f674 210 /* Reset CrypInCount and CrypOutCount */
mbed_official 489:119543c9f674 211 hcryp->CrypInCount = 0;
mbed_official 489:119543c9f674 212 hcryp->CrypOutCount = 0;
mbed_official 489:119543c9f674 213
mbed_official 489:119543c9f674 214 /* Change the CRYP state */
mbed_official 489:119543c9f674 215 hcryp->State = HAL_CRYP_STATE_READY;
mbed_official 489:119543c9f674 216
mbed_official 489:119543c9f674 217 /* Set the default CRYP phase */
mbed_official 489:119543c9f674 218 hcryp->Phase = HAL_CRYP_PHASE_READY;
mbed_official 489:119543c9f674 219
mbed_official 489:119543c9f674 220 /* Return function status */
mbed_official 489:119543c9f674 221 return HAL_OK;
mbed_official 489:119543c9f674 222 }
mbed_official 489:119543c9f674 223 else
mbed_official 489:119543c9f674 224 {
mbed_official 489:119543c9f674 225 /* The Datatype selection must be changed if the AES is disabled. Writing these bits while the AES is */
mbed_official 489:119543c9f674 226 /* enabled is forbidden to avoid unpredictable AES behavior.*/
mbed_official 489:119543c9f674 227
mbed_official 489:119543c9f674 228 /* Return function status */
mbed_official 489:119543c9f674 229 return HAL_ERROR;
mbed_official 489:119543c9f674 230 }
mbed_official 489:119543c9f674 231
mbed_official 376:cb4d9db17537 232 }
mbed_official 376:cb4d9db17537 233
mbed_official 376:cb4d9db17537 234 /**
mbed_official 376:cb4d9db17537 235 * @brief DeInitializes the CRYP peripheral.
mbed_official 376:cb4d9db17537 236 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 237 * the configuration information for CRYP module
mbed_official 376:cb4d9db17537 238 * @retval HAL status
mbed_official 376:cb4d9db17537 239 */
mbed_official 376:cb4d9db17537 240 HAL_StatusTypeDef HAL_CRYP_DeInit(CRYP_HandleTypeDef *hcryp)
mbed_official 376:cb4d9db17537 241 {
mbed_official 376:cb4d9db17537 242 /* Check the CRYP handle allocation */
mbed_official 489:119543c9f674 243 if(hcryp == NULL)
mbed_official 376:cb4d9db17537 244 {
mbed_official 376:cb4d9db17537 245 return HAL_ERROR;
mbed_official 376:cb4d9db17537 246 }
mbed_official 376:cb4d9db17537 247
mbed_official 376:cb4d9db17537 248 /* Change the CRYP state */
mbed_official 376:cb4d9db17537 249 hcryp->State = HAL_CRYP_STATE_BUSY;
mbed_official 376:cb4d9db17537 250
mbed_official 376:cb4d9db17537 251 /* Set the default CRYP phase */
mbed_official 376:cb4d9db17537 252 hcryp->Phase = HAL_CRYP_PHASE_READY;
mbed_official 376:cb4d9db17537 253
mbed_official 376:cb4d9db17537 254 /* Reset CrypInCount and CrypOutCount */
mbed_official 376:cb4d9db17537 255 hcryp->CrypInCount = 0;
mbed_official 376:cb4d9db17537 256 hcryp->CrypOutCount = 0;
mbed_official 376:cb4d9db17537 257
mbed_official 376:cb4d9db17537 258 /* Disable the CRYP Peripheral Clock */
mbed_official 489:119543c9f674 259 __HAL_CRYP_DISABLE(hcryp);
mbed_official 376:cb4d9db17537 260
mbed_official 376:cb4d9db17537 261 /* DeInit the low level hardware: CLOCK, NVIC.*/
mbed_official 376:cb4d9db17537 262 HAL_CRYP_MspDeInit(hcryp);
mbed_official 376:cb4d9db17537 263
mbed_official 376:cb4d9db17537 264 /* Change the CRYP state */
mbed_official 376:cb4d9db17537 265 hcryp->State = HAL_CRYP_STATE_RESET;
mbed_official 376:cb4d9db17537 266
mbed_official 376:cb4d9db17537 267 /* Release Lock */
mbed_official 376:cb4d9db17537 268 __HAL_UNLOCK(hcryp);
mbed_official 376:cb4d9db17537 269
mbed_official 376:cb4d9db17537 270 /* Return function status */
mbed_official 376:cb4d9db17537 271 return HAL_OK;
mbed_official 376:cb4d9db17537 272 }
mbed_official 376:cb4d9db17537 273
mbed_official 376:cb4d9db17537 274 /**
mbed_official 376:cb4d9db17537 275 * @brief Initializes the CRYP MSP.
mbed_official 376:cb4d9db17537 276 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 277 * the configuration information for CRYP module
mbed_official 376:cb4d9db17537 278 * @retval None
mbed_official 376:cb4d9db17537 279 */
mbed_official 376:cb4d9db17537 280 __weak void HAL_CRYP_MspInit(CRYP_HandleTypeDef *hcryp)
mbed_official 376:cb4d9db17537 281 {
mbed_official 489:119543c9f674 282 /* NOTE : This function should not be modified; when the callback is needed,
mbed_official 489:119543c9f674 283 the HAL_CRYP_MspInit can be implemented in the user file */
mbed_official 376:cb4d9db17537 284 }
mbed_official 376:cb4d9db17537 285
mbed_official 376:cb4d9db17537 286 /**
mbed_official 376:cb4d9db17537 287 * @brief DeInitializes CRYP MSP.
mbed_official 376:cb4d9db17537 288 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 289 * the configuration information for CRYP module
mbed_official 376:cb4d9db17537 290 * @retval None
mbed_official 376:cb4d9db17537 291 */
mbed_official 376:cb4d9db17537 292 __weak void HAL_CRYP_MspDeInit(CRYP_HandleTypeDef *hcryp)
mbed_official 376:cb4d9db17537 293 {
mbed_official 489:119543c9f674 294 /* NOTE : This function should not be modified; when the callback is needed,
mbed_official 489:119543c9f674 295 the HAL_CRYP_MspDeInit can be implemented in the user file */
mbed_official 376:cb4d9db17537 296 }
mbed_official 376:cb4d9db17537 297
mbed_official 376:cb4d9db17537 298 /**
mbed_official 376:cb4d9db17537 299 * @}
mbed_official 376:cb4d9db17537 300 */
mbed_official 376:cb4d9db17537 301
mbed_official 489:119543c9f674 302 /** @defgroup CRYP_Exported_Functions_Group2 AES processing functions
mbed_official 376:cb4d9db17537 303 * @brief processing functions.
mbed_official 376:cb4d9db17537 304 *
mbed_official 376:cb4d9db17537 305 @verbatim
mbed_official 376:cb4d9db17537 306 ==============================================================================
mbed_official 376:cb4d9db17537 307 ##### AES processing functions #####
mbed_official 376:cb4d9db17537 308 ==============================================================================
mbed_official 376:cb4d9db17537 309 [..] This section provides functions allowing to:
mbed_official 376:cb4d9db17537 310 (+) Encrypt plaintext using AES algorithm in different chaining modes
mbed_official 376:cb4d9db17537 311 (+) Decrypt cyphertext using AES algorithm in different chaining modes
mbed_official 376:cb4d9db17537 312 [..] Three processing functions are available:
mbed_official 376:cb4d9db17537 313 (+) Polling mode
mbed_official 376:cb4d9db17537 314 (+) Interrupt mode
mbed_official 376:cb4d9db17537 315 (+) DMA mode
mbed_official 376:cb4d9db17537 316
mbed_official 376:cb4d9db17537 317 @endverbatim
mbed_official 376:cb4d9db17537 318 * @{
mbed_official 376:cb4d9db17537 319 */
mbed_official 376:cb4d9db17537 320
mbed_official 376:cb4d9db17537 321 /**
mbed_official 376:cb4d9db17537 322 * @brief Initializes the CRYP peripheral in AES ECB encryption mode
mbed_official 376:cb4d9db17537 323 * then encrypt pPlainData. The cypher data are available in pCypherData
mbed_official 376:cb4d9db17537 324 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 325 * the configuration information for CRYP module
mbed_official 489:119543c9f674 326 * @param pPlainData: Pointer to the plaintext buffer (aligned on u32)
mbed_official 376:cb4d9db17537 327 * @param Size: Length of the plaintext buffer, must be a multiple of 16.
mbed_official 489:119543c9f674 328 * @param pCypherData: Pointer to the cyphertext buffer (aligned on u32)
mbed_official 376:cb4d9db17537 329 * @param Timeout: Specify Timeout value
mbed_official 376:cb4d9db17537 330 * @retval HAL status
mbed_official 376:cb4d9db17537 331 */
mbed_official 376:cb4d9db17537 332 HAL_StatusTypeDef HAL_CRYP_AESECB_Encrypt(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData, uint32_t Timeout)
mbed_official 376:cb4d9db17537 333 {
mbed_official 376:cb4d9db17537 334 /* Process Locked */
mbed_official 376:cb4d9db17537 335 __HAL_LOCK(hcryp);
mbed_official 489:119543c9f674 336
mbed_official 489:119543c9f674 337 /* Check that data aligned on u32 and Size multiple of 16*/
mbed_official 489:119543c9f674 338 if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
mbed_official 376:cb4d9db17537 339 {
mbed_official 489:119543c9f674 340 /* Process Locked */
mbed_official 489:119543c9f674 341 __HAL_UNLOCK(hcryp);
mbed_official 489:119543c9f674 342
mbed_official 489:119543c9f674 343 /* Return function status */
mbed_official 489:119543c9f674 344 return HAL_ERROR;
mbed_official 376:cb4d9db17537 345 }
mbed_official 376:cb4d9db17537 346
mbed_official 489:119543c9f674 347 /* Check if HAL_CRYP_Init has been called */
mbed_official 489:119543c9f674 348 if(hcryp->State != HAL_CRYP_STATE_RESET)
mbed_official 376:cb4d9db17537 349 {
mbed_official 489:119543c9f674 350 /* Change the CRYP state */
mbed_official 489:119543c9f674 351 hcryp->State = HAL_CRYP_STATE_BUSY;
mbed_official 489:119543c9f674 352
mbed_official 489:119543c9f674 353 /* Check if initialization phase has already been performed */
mbed_official 489:119543c9f674 354 if(hcryp->Phase == HAL_CRYP_PHASE_READY)
mbed_official 489:119543c9f674 355 {
mbed_official 489:119543c9f674 356 /* Set the key */
mbed_official 489:119543c9f674 357 CRYP_SetKey(hcryp, hcryp->Init.pKey);
mbed_official 489:119543c9f674 358
mbed_official 489:119543c9f674 359 /* Reset the CHMOD & MODE bits */
mbed_official 489:119543c9f674 360 CLEAR_BIT(hcryp->Instance->CR, CRYP_ALGO_CHAIN_MASK);
mbed_official 489:119543c9f674 361
mbed_official 489:119543c9f674 362 /* Set the CRYP peripheral in AES ECB mode */
mbed_official 489:119543c9f674 363 __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_ECB_ENCRYPT);
mbed_official 489:119543c9f674 364
mbed_official 489:119543c9f674 365 /* Enable CRYP */
mbed_official 489:119543c9f674 366 __HAL_CRYP_ENABLE(hcryp);
mbed_official 489:119543c9f674 367
mbed_official 489:119543c9f674 368 /* Set the phase */
mbed_official 489:119543c9f674 369 hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
mbed_official 489:119543c9f674 370 }
mbed_official 489:119543c9f674 371
mbed_official 489:119543c9f674 372 /* Write Plain Data and Get Cypher Data */
mbed_official 489:119543c9f674 373 if(CRYP_ProcessData(hcryp, pPlainData, Size, pCypherData, Timeout) != HAL_OK)
mbed_official 489:119543c9f674 374 {
mbed_official 489:119543c9f674 375 return HAL_TIMEOUT;
mbed_official 489:119543c9f674 376 }
mbed_official 489:119543c9f674 377
mbed_official 489:119543c9f674 378 /* Change the CRYP state */
mbed_official 489:119543c9f674 379 hcryp->State = HAL_CRYP_STATE_READY;
mbed_official 489:119543c9f674 380
mbed_official 489:119543c9f674 381 /* Process Unlocked */
mbed_official 489:119543c9f674 382 __HAL_UNLOCK(hcryp);
mbed_official 489:119543c9f674 383
mbed_official 489:119543c9f674 384 /* Return function status */
mbed_official 489:119543c9f674 385 return HAL_OK;
mbed_official 376:cb4d9db17537 386 }
mbed_official 489:119543c9f674 387 else
mbed_official 489:119543c9f674 388 {
mbed_official 489:119543c9f674 389 /* Process Locked */
mbed_official 489:119543c9f674 390 __HAL_UNLOCK(hcryp);
mbed_official 489:119543c9f674 391
mbed_official 489:119543c9f674 392 /* Return function status */
mbed_official 489:119543c9f674 393 return HAL_ERROR;
mbed_official 489:119543c9f674 394 }
mbed_official 376:cb4d9db17537 395 }
mbed_official 376:cb4d9db17537 396
mbed_official 376:cb4d9db17537 397 /**
mbed_official 376:cb4d9db17537 398 * @brief Initializes the CRYP peripheral in AES CBC encryption mode
mbed_official 376:cb4d9db17537 399 * then encrypt pPlainData. The cypher data are available in pCypherData
mbed_official 376:cb4d9db17537 400 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 401 * the configuration information for CRYP module
mbed_official 489:119543c9f674 402 * @param pPlainData: Pointer to the plaintext buffer (aligned on u32)
mbed_official 376:cb4d9db17537 403 * @param Size: Length of the plaintext buffer, must be a multiple of 16.
mbed_official 489:119543c9f674 404 * @param pCypherData: Pointer to the cyphertext buffer (aligned on u32)
mbed_official 376:cb4d9db17537 405 * @param Timeout: Specify Timeout value
mbed_official 376:cb4d9db17537 406 * @retval HAL status
mbed_official 376:cb4d9db17537 407 */
mbed_official 376:cb4d9db17537 408 HAL_StatusTypeDef HAL_CRYP_AESCBC_Encrypt(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData, uint32_t Timeout)
mbed_official 376:cb4d9db17537 409 {
mbed_official 376:cb4d9db17537 410 /* Process Locked */
mbed_official 376:cb4d9db17537 411 __HAL_LOCK(hcryp);
mbed_official 376:cb4d9db17537 412
mbed_official 489:119543c9f674 413 /* Check that data aligned on u32 */
mbed_official 489:119543c9f674 414 if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
mbed_official 376:cb4d9db17537 415 {
mbed_official 489:119543c9f674 416 /* Process Locked */
mbed_official 489:119543c9f674 417 __HAL_UNLOCK(hcryp);
mbed_official 489:119543c9f674 418
mbed_official 489:119543c9f674 419 /* Return function status */
mbed_official 489:119543c9f674 420 return HAL_ERROR;
mbed_official 376:cb4d9db17537 421 }
mbed_official 376:cb4d9db17537 422
mbed_official 489:119543c9f674 423 /* Check if HAL_CRYP_Init has been called */
mbed_official 489:119543c9f674 424 if(hcryp->State != HAL_CRYP_STATE_RESET)
mbed_official 489:119543c9f674 425 {
mbed_official 489:119543c9f674 426 /* Change the CRYP state */
mbed_official 489:119543c9f674 427 hcryp->State = HAL_CRYP_STATE_BUSY;
mbed_official 489:119543c9f674 428
mbed_official 489:119543c9f674 429 /* Check if initialization phase has already been performed */
mbed_official 489:119543c9f674 430 if(hcryp->Phase == HAL_CRYP_PHASE_READY)
mbed_official 489:119543c9f674 431 {
mbed_official 489:119543c9f674 432 /* Set the key */
mbed_official 489:119543c9f674 433 CRYP_SetKey(hcryp, hcryp->Init.pKey);
mbed_official 489:119543c9f674 434
mbed_official 489:119543c9f674 435 /* Reset the CHMOD & MODE bits */
mbed_official 489:119543c9f674 436 CLEAR_BIT(hcryp->Instance->CR, CRYP_ALGO_CHAIN_MASK);
mbed_official 489:119543c9f674 437
mbed_official 489:119543c9f674 438 /* Set the CRYP peripheral in AES CBC mode */
mbed_official 489:119543c9f674 439 __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CBC_ENCRYPT);
mbed_official 489:119543c9f674 440
mbed_official 489:119543c9f674 441 /* Set the Initialization Vector */
mbed_official 489:119543c9f674 442 CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect);
mbed_official 489:119543c9f674 443
mbed_official 489:119543c9f674 444 /* Enable CRYP */
mbed_official 489:119543c9f674 445 __HAL_CRYP_ENABLE(hcryp);
mbed_official 489:119543c9f674 446
mbed_official 489:119543c9f674 447 /* Set the phase */
mbed_official 489:119543c9f674 448 hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
mbed_official 489:119543c9f674 449 }
mbed_official 489:119543c9f674 450
mbed_official 376:cb4d9db17537 451 /* Write Plain Data and Get Cypher Data */
mbed_official 489:119543c9f674 452 if(CRYP_ProcessData(hcryp, pPlainData, Size, pCypherData, Timeout) != HAL_OK)
mbed_official 376:cb4d9db17537 453 {
mbed_official 376:cb4d9db17537 454 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 455 }
mbed_official 489:119543c9f674 456
mbed_official 489:119543c9f674 457 /* Change the CRYP state */
mbed_official 489:119543c9f674 458 hcryp->State = HAL_CRYP_STATE_READY;
mbed_official 489:119543c9f674 459
mbed_official 489:119543c9f674 460 /* Process Unlocked */
mbed_official 489:119543c9f674 461 __HAL_UNLOCK(hcryp);
mbed_official 489:119543c9f674 462
mbed_official 489:119543c9f674 463 /* Return function status */
mbed_official 489:119543c9f674 464 return HAL_OK;
mbed_official 489:119543c9f674 465 }
mbed_official 489:119543c9f674 466 else
mbed_official 489:119543c9f674 467 {
mbed_official 489:119543c9f674 468 /* Process Locked */
mbed_official 489:119543c9f674 469 __HAL_UNLOCK(hcryp);
mbed_official 489:119543c9f674 470
mbed_official 489:119543c9f674 471 /* Return function status */
mbed_official 489:119543c9f674 472 return HAL_ERROR;
mbed_official 489:119543c9f674 473 }
mbed_official 376:cb4d9db17537 474 }
mbed_official 376:cb4d9db17537 475
mbed_official 376:cb4d9db17537 476 /**
mbed_official 376:cb4d9db17537 477 * @brief Initializes the CRYP peripheral in AES CTR encryption mode
mbed_official 376:cb4d9db17537 478 * then encrypt pPlainData. The cypher data are available in pCypherData
mbed_official 376:cb4d9db17537 479 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 480 * the configuration information for CRYP module
mbed_official 489:119543c9f674 481 * @param pPlainData: Pointer to the plaintext buffer (aligned on u32)
mbed_official 376:cb4d9db17537 482 * @param Size: Length of the plaintext buffer, must be a multiple of 16.
mbed_official 489:119543c9f674 483 * @param pCypherData: Pointer to the cyphertext buffer (aligned on u32)
mbed_official 376:cb4d9db17537 484 * @param Timeout: Specify Timeout value
mbed_official 376:cb4d9db17537 485 * @retval HAL status
mbed_official 376:cb4d9db17537 486 */
mbed_official 376:cb4d9db17537 487 HAL_StatusTypeDef HAL_CRYP_AESCTR_Encrypt(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData, uint32_t Timeout)
mbed_official 376:cb4d9db17537 488 {
mbed_official 376:cb4d9db17537 489 /* Process Locked */
mbed_official 376:cb4d9db17537 490 __HAL_LOCK(hcryp);
mbed_official 376:cb4d9db17537 491
mbed_official 489:119543c9f674 492 /* Check that data aligned on u32 */
mbed_official 489:119543c9f674 493 if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
mbed_official 376:cb4d9db17537 494 {
mbed_official 489:119543c9f674 495 /* Process Locked */
mbed_official 489:119543c9f674 496 __HAL_UNLOCK(hcryp);
mbed_official 489:119543c9f674 497
mbed_official 489:119543c9f674 498 /* Return function status */
mbed_official 489:119543c9f674 499 return HAL_ERROR;
mbed_official 376:cb4d9db17537 500 }
mbed_official 376:cb4d9db17537 501
mbed_official 489:119543c9f674 502 /* Check if HAL_CRYP_Init has been called */
mbed_official 489:119543c9f674 503 if(hcryp->State != HAL_CRYP_STATE_RESET)
mbed_official 489:119543c9f674 504 {
mbed_official 489:119543c9f674 505 /* Change the CRYP state */
mbed_official 489:119543c9f674 506 hcryp->State = HAL_CRYP_STATE_BUSY;
mbed_official 489:119543c9f674 507
mbed_official 489:119543c9f674 508 /* Check if initialization phase has already been performed */
mbed_official 489:119543c9f674 509 if(hcryp->Phase == HAL_CRYP_PHASE_READY)
mbed_official 489:119543c9f674 510 {
mbed_official 489:119543c9f674 511 /* Set the key */
mbed_official 489:119543c9f674 512 CRYP_SetKey(hcryp, hcryp->Init.pKey);
mbed_official 489:119543c9f674 513
mbed_official 489:119543c9f674 514 /* Reset the CHMOD & MODE bits */
mbed_official 489:119543c9f674 515 CLEAR_BIT(hcryp->Instance->CR, CRYP_ALGO_CHAIN_MASK);
mbed_official 489:119543c9f674 516
mbed_official 489:119543c9f674 517 /* Set the CRYP peripheral in AES CTR mode */
mbed_official 489:119543c9f674 518 __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CTR_ENCRYPT);
mbed_official 489:119543c9f674 519
mbed_official 489:119543c9f674 520 /* Set the Initialization Vector */
mbed_official 489:119543c9f674 521 CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect);
mbed_official 489:119543c9f674 522
mbed_official 489:119543c9f674 523 /* Enable CRYP */
mbed_official 489:119543c9f674 524 __HAL_CRYP_ENABLE(hcryp);
mbed_official 489:119543c9f674 525
mbed_official 489:119543c9f674 526 /* Set the phase */
mbed_official 489:119543c9f674 527 hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
mbed_official 489:119543c9f674 528 }
mbed_official 489:119543c9f674 529
mbed_official 376:cb4d9db17537 530 /* Write Plain Data and Get Cypher Data */
mbed_official 376:cb4d9db17537 531 if(CRYP_ProcessData(hcryp, pPlainData, Size, pCypherData, Timeout) != HAL_OK)
mbed_official 376:cb4d9db17537 532 {
mbed_official 376:cb4d9db17537 533 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 534 }
mbed_official 489:119543c9f674 535
mbed_official 489:119543c9f674 536 /* Change the CRYP state */
mbed_official 489:119543c9f674 537 hcryp->State = HAL_CRYP_STATE_READY;
mbed_official 489:119543c9f674 538
mbed_official 489:119543c9f674 539 /* Process Unlocked */
mbed_official 489:119543c9f674 540 __HAL_UNLOCK(hcryp);
mbed_official 489:119543c9f674 541
mbed_official 489:119543c9f674 542 /* Return function status */
mbed_official 489:119543c9f674 543 return HAL_OK;
mbed_official 489:119543c9f674 544 }
mbed_official 489:119543c9f674 545 else
mbed_official 489:119543c9f674 546 {
mbed_official 489:119543c9f674 547 /* Release Lock */
mbed_official 489:119543c9f674 548 __HAL_UNLOCK(hcryp);
mbed_official 376:cb4d9db17537 549
mbed_official 489:119543c9f674 550 /* Return function status */
mbed_official 489:119543c9f674 551 return HAL_ERROR;
mbed_official 489:119543c9f674 552 }
mbed_official 376:cb4d9db17537 553 }
mbed_official 376:cb4d9db17537 554
mbed_official 376:cb4d9db17537 555 /**
mbed_official 376:cb4d9db17537 556 * @brief Initializes the CRYP peripheral in AES ECB decryption mode
mbed_official 376:cb4d9db17537 557 * then decrypted pCypherData. The cypher data are available in pPlainData
mbed_official 376:cb4d9db17537 558 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 559 * the configuration information for CRYP module
mbed_official 489:119543c9f674 560 * @param pCypherData: Pointer to the cyphertext buffer (aligned on u32)
mbed_official 376:cb4d9db17537 561 * @param Size: Length of the plaintext buffer, must be a multiple of 16.
mbed_official 489:119543c9f674 562 * @param pPlainData: Pointer to the plaintext buffer (aligned on u32)
mbed_official 376:cb4d9db17537 563 * @param Timeout: Specify Timeout value
mbed_official 376:cb4d9db17537 564 * @retval HAL status
mbed_official 376:cb4d9db17537 565 */
mbed_official 376:cb4d9db17537 566 HAL_StatusTypeDef HAL_CRYP_AESECB_Decrypt(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData, uint32_t Timeout)
mbed_official 376:cb4d9db17537 567 {
mbed_official 376:cb4d9db17537 568 /* Process Locked */
mbed_official 376:cb4d9db17537 569 __HAL_LOCK(hcryp);
mbed_official 376:cb4d9db17537 570
mbed_official 489:119543c9f674 571 /* Check that data aligned on u32 */
mbed_official 489:119543c9f674 572 if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
mbed_official 376:cb4d9db17537 573 {
mbed_official 489:119543c9f674 574 /* Process Locked */
mbed_official 489:119543c9f674 575 __HAL_UNLOCK(hcryp);
mbed_official 489:119543c9f674 576
mbed_official 489:119543c9f674 577 /* Return function status */
mbed_official 489:119543c9f674 578 return HAL_ERROR;
mbed_official 376:cb4d9db17537 579 }
mbed_official 376:cb4d9db17537 580
mbed_official 489:119543c9f674 581 /* Check if HAL_CRYP_Init has been called */
mbed_official 489:119543c9f674 582 if(hcryp->State != HAL_CRYP_STATE_RESET)
mbed_official 489:119543c9f674 583 {
mbed_official 489:119543c9f674 584 /* Change the CRYP state */
mbed_official 489:119543c9f674 585 hcryp->State = HAL_CRYP_STATE_BUSY;
mbed_official 489:119543c9f674 586
mbed_official 489:119543c9f674 587 /* Check if initialization phase has already been performed */
mbed_official 489:119543c9f674 588 if(hcryp->Phase == HAL_CRYP_PHASE_READY)
mbed_official 489:119543c9f674 589 {
mbed_official 489:119543c9f674 590 /* Set the key */
mbed_official 489:119543c9f674 591 CRYP_SetKey(hcryp, hcryp->Init.pKey);
mbed_official 489:119543c9f674 592
mbed_official 489:119543c9f674 593 /* Reset the CHMOD & MODE bits */
mbed_official 489:119543c9f674 594 CLEAR_BIT(hcryp->Instance->CR, CRYP_ALGO_CHAIN_MASK);
mbed_official 489:119543c9f674 595
mbed_official 489:119543c9f674 596 /* Set the CRYP peripheral in AES ECB decryption mode (with key derivation) */
mbed_official 489:119543c9f674 597 __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_ECB_KEYDERDECRYPT);
mbed_official 489:119543c9f674 598
mbed_official 489:119543c9f674 599 /* Enable CRYP */
mbed_official 489:119543c9f674 600 __HAL_CRYP_ENABLE(hcryp);
mbed_official 489:119543c9f674 601
mbed_official 489:119543c9f674 602 /* Set the phase */
mbed_official 489:119543c9f674 603 hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
mbed_official 489:119543c9f674 604 }
mbed_official 489:119543c9f674 605
mbed_official 489:119543c9f674 606 /* Write Cypher Data and Get Plain Data */
mbed_official 489:119543c9f674 607 if(CRYP_ProcessData(hcryp, pCypherData, Size, pPlainData, Timeout) != HAL_OK)
mbed_official 489:119543c9f674 608 {
mbed_official 489:119543c9f674 609 return HAL_TIMEOUT;
mbed_official 489:119543c9f674 610 }
mbed_official 489:119543c9f674 611
mbed_official 489:119543c9f674 612 /* Change the CRYP state */
mbed_official 489:119543c9f674 613 hcryp->State = HAL_CRYP_STATE_READY;
mbed_official 489:119543c9f674 614
mbed_official 489:119543c9f674 615 /* Process Unlocked */
mbed_official 489:119543c9f674 616 __HAL_UNLOCK(hcryp);
mbed_official 489:119543c9f674 617
mbed_official 489:119543c9f674 618 /* Return function status */
mbed_official 489:119543c9f674 619 return HAL_OK;
mbed_official 489:119543c9f674 620 }
mbed_official 489:119543c9f674 621 else
mbed_official 489:119543c9f674 622 {
mbed_official 489:119543c9f674 623 /* Release Lock */
mbed_official 489:119543c9f674 624 __HAL_UNLOCK(hcryp);
mbed_official 376:cb4d9db17537 625
mbed_official 489:119543c9f674 626 /* Return function status */
mbed_official 489:119543c9f674 627 return HAL_ERROR;
mbed_official 489:119543c9f674 628 }
mbed_official 376:cb4d9db17537 629 }
mbed_official 376:cb4d9db17537 630
mbed_official 376:cb4d9db17537 631 /**
mbed_official 376:cb4d9db17537 632 * @brief Initializes the CRYP peripheral in AES ECB decryption mode
mbed_official 376:cb4d9db17537 633 * then decrypted pCypherData. The cypher data are available in pPlainData
mbed_official 376:cb4d9db17537 634 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 635 * the configuration information for CRYP module
mbed_official 489:119543c9f674 636 * @param pCypherData: Pointer to the cyphertext buffer (aligned on u32)
mbed_official 376:cb4d9db17537 637 * @param Size: Length of the plaintext buffer, must be a multiple of 16.
mbed_official 489:119543c9f674 638 * @param pPlainData: Pointer to the plaintext buffer (aligned on u32)
mbed_official 376:cb4d9db17537 639 * @param Timeout: Specify Timeout value
mbed_official 376:cb4d9db17537 640 * @retval HAL status
mbed_official 376:cb4d9db17537 641 */
mbed_official 376:cb4d9db17537 642 HAL_StatusTypeDef HAL_CRYP_AESCBC_Decrypt(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData, uint32_t Timeout)
mbed_official 376:cb4d9db17537 643 {
mbed_official 376:cb4d9db17537 644 /* Process Locked */
mbed_official 376:cb4d9db17537 645 __HAL_LOCK(hcryp);
mbed_official 376:cb4d9db17537 646
mbed_official 489:119543c9f674 647 /* Check that data aligned on u32 */
mbed_official 489:119543c9f674 648 if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
mbed_official 376:cb4d9db17537 649 {
mbed_official 489:119543c9f674 650 /* Process Locked */
mbed_official 489:119543c9f674 651 __HAL_UNLOCK(hcryp);
mbed_official 489:119543c9f674 652
mbed_official 489:119543c9f674 653 /* Return function status */
mbed_official 489:119543c9f674 654 return HAL_ERROR;
mbed_official 376:cb4d9db17537 655 }
mbed_official 376:cb4d9db17537 656
mbed_official 489:119543c9f674 657 /* Check if HAL_CRYP_Init has been called */
mbed_official 489:119543c9f674 658 if(hcryp->State != HAL_CRYP_STATE_RESET)
mbed_official 376:cb4d9db17537 659 {
mbed_official 489:119543c9f674 660 /* Change the CRYP state */
mbed_official 489:119543c9f674 661 hcryp->State = HAL_CRYP_STATE_BUSY;
mbed_official 489:119543c9f674 662
mbed_official 489:119543c9f674 663 /* Check if initialization phase has already been performed */
mbed_official 489:119543c9f674 664 if(hcryp->Phase == HAL_CRYP_PHASE_READY)
mbed_official 489:119543c9f674 665 {
mbed_official 489:119543c9f674 666 /* Set the key */
mbed_official 489:119543c9f674 667 CRYP_SetKey(hcryp, hcryp->Init.pKey);
mbed_official 489:119543c9f674 668
mbed_official 489:119543c9f674 669 /* Reset the CHMOD & MODE bits */
mbed_official 489:119543c9f674 670 CLEAR_BIT(hcryp->Instance->CR, CRYP_ALGO_CHAIN_MASK);
mbed_official 489:119543c9f674 671
mbed_official 489:119543c9f674 672 /* Set the CRYP peripheral in AES CBC decryption mode (with key derivation) */
mbed_official 489:119543c9f674 673 __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CBC_KEYDERDECRYPT);
mbed_official 489:119543c9f674 674
mbed_official 489:119543c9f674 675 /* Set the Initialization Vector */
mbed_official 489:119543c9f674 676 CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect);
mbed_official 489:119543c9f674 677
mbed_official 489:119543c9f674 678 /* Enable CRYP */
mbed_official 489:119543c9f674 679 __HAL_CRYP_ENABLE(hcryp);
mbed_official 489:119543c9f674 680
mbed_official 489:119543c9f674 681 /* Set the phase */
mbed_official 489:119543c9f674 682 hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
mbed_official 489:119543c9f674 683 }
mbed_official 489:119543c9f674 684
mbed_official 489:119543c9f674 685 /* Write Cypher Data and Get Plain Data */
mbed_official 489:119543c9f674 686 if(CRYP_ProcessData(hcryp, pCypherData, Size, pPlainData, Timeout) != HAL_OK)
mbed_official 489:119543c9f674 687 {
mbed_official 489:119543c9f674 688 return HAL_TIMEOUT;
mbed_official 489:119543c9f674 689 }
mbed_official 489:119543c9f674 690
mbed_official 489:119543c9f674 691 /* Change the CRYP state */
mbed_official 489:119543c9f674 692 hcryp->State = HAL_CRYP_STATE_READY;
mbed_official 489:119543c9f674 693
mbed_official 489:119543c9f674 694 /* Process Unlocked */
mbed_official 489:119543c9f674 695 __HAL_UNLOCK(hcryp);
mbed_official 489:119543c9f674 696
mbed_official 489:119543c9f674 697 /* Return function status */
mbed_official 489:119543c9f674 698 return HAL_OK;
mbed_official 376:cb4d9db17537 699 }
mbed_official 489:119543c9f674 700 else
mbed_official 489:119543c9f674 701 {
mbed_official 489:119543c9f674 702 /* Release Lock */
mbed_official 489:119543c9f674 703 __HAL_UNLOCK(hcryp);
mbed_official 376:cb4d9db17537 704
mbed_official 489:119543c9f674 705 /* Return function status */
mbed_official 489:119543c9f674 706 return HAL_ERROR;
mbed_official 489:119543c9f674 707 }
mbed_official 376:cb4d9db17537 708 }
mbed_official 376:cb4d9db17537 709
mbed_official 376:cb4d9db17537 710 /**
mbed_official 376:cb4d9db17537 711 * @brief Initializes the CRYP peripheral in AES CTR decryption mode
mbed_official 376:cb4d9db17537 712 * then decrypted pCypherData. The cypher data are available in pPlainData
mbed_official 376:cb4d9db17537 713 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 714 * the configuration information for CRYP module
mbed_official 489:119543c9f674 715 * @param pCypherData: Pointer to the cyphertext buffer (aligned on u32)
mbed_official 376:cb4d9db17537 716 * @param Size: Length of the plaintext buffer, must be a multiple of 16.
mbed_official 489:119543c9f674 717 * @param pPlainData: Pointer to the plaintext buffer (aligned on u32)
mbed_official 376:cb4d9db17537 718 * @param Timeout: Specify Timeout value
mbed_official 376:cb4d9db17537 719 * @retval HAL status
mbed_official 376:cb4d9db17537 720 */
mbed_official 376:cb4d9db17537 721 HAL_StatusTypeDef HAL_CRYP_AESCTR_Decrypt(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData, uint32_t Timeout)
mbed_official 376:cb4d9db17537 722 {
mbed_official 376:cb4d9db17537 723 /* Process Locked */
mbed_official 376:cb4d9db17537 724 __HAL_LOCK(hcryp);
mbed_official 376:cb4d9db17537 725
mbed_official 489:119543c9f674 726 /* Check that data aligned on u32 */
mbed_official 489:119543c9f674 727 if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
mbed_official 489:119543c9f674 728 {
mbed_official 489:119543c9f674 729 /* Process Locked */
mbed_official 489:119543c9f674 730 __HAL_UNLOCK(hcryp);
mbed_official 489:119543c9f674 731
mbed_official 489:119543c9f674 732 /* Return function status */
mbed_official 489:119543c9f674 733 return HAL_ERROR;
mbed_official 489:119543c9f674 734 }
mbed_official 489:119543c9f674 735
mbed_official 376:cb4d9db17537 736 /* Check if initialization phase has already been performed */
mbed_official 489:119543c9f674 737 if ((hcryp->State != HAL_CRYP_STATE_RESET) && (hcryp->Phase == HAL_CRYP_PHASE_READY))
mbed_official 376:cb4d9db17537 738 {
mbed_official 376:cb4d9db17537 739 /* Change the CRYP state */
mbed_official 376:cb4d9db17537 740 hcryp->State = HAL_CRYP_STATE_BUSY;
mbed_official 376:cb4d9db17537 741
mbed_official 376:cb4d9db17537 742 /* Set the key */
mbed_official 376:cb4d9db17537 743 CRYP_SetKey(hcryp, hcryp->Init.pKey);
mbed_official 376:cb4d9db17537 744
mbed_official 489:119543c9f674 745 /* Reset the CHMOD & MODE bits */
mbed_official 489:119543c9f674 746 CLEAR_BIT(hcryp->Instance->CR, CRYP_ALGO_CHAIN_MASK);
mbed_official 376:cb4d9db17537 747
mbed_official 376:cb4d9db17537 748 /* Set the CRYP peripheral in AES CTR decryption mode */
mbed_official 489:119543c9f674 749 __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CTR_DECRYPT);
mbed_official 376:cb4d9db17537 750
mbed_official 376:cb4d9db17537 751 /* Set the Initialization Vector */
mbed_official 376:cb4d9db17537 752 CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect);
mbed_official 489:119543c9f674 753
mbed_official 376:cb4d9db17537 754 /* Enable CRYP */
mbed_official 489:119543c9f674 755 __HAL_CRYP_ENABLE(hcryp);
mbed_official 376:cb4d9db17537 756
mbed_official 376:cb4d9db17537 757 /* Set the phase */
mbed_official 376:cb4d9db17537 758 hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
mbed_official 376:cb4d9db17537 759 }
mbed_official 376:cb4d9db17537 760
mbed_official 489:119543c9f674 761 /* Write Cypher Data and Get Plain Data */
mbed_official 376:cb4d9db17537 762 if(CRYP_ProcessData(hcryp, pCypherData, Size, pPlainData, Timeout) != HAL_OK)
mbed_official 376:cb4d9db17537 763 {
mbed_official 376:cb4d9db17537 764 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 765 }
mbed_official 376:cb4d9db17537 766
mbed_official 376:cb4d9db17537 767 /* Change the CRYP state */
mbed_official 376:cb4d9db17537 768 hcryp->State = HAL_CRYP_STATE_READY;
mbed_official 376:cb4d9db17537 769
mbed_official 376:cb4d9db17537 770 /* Process Unlocked */
mbed_official 376:cb4d9db17537 771 __HAL_UNLOCK(hcryp);
mbed_official 376:cb4d9db17537 772
mbed_official 376:cb4d9db17537 773 /* Return function status */
mbed_official 376:cb4d9db17537 774 return HAL_OK;
mbed_official 376:cb4d9db17537 775 }
mbed_official 376:cb4d9db17537 776
mbed_official 376:cb4d9db17537 777 /**
mbed_official 376:cb4d9db17537 778 * @brief Initializes the CRYP peripheral in AES ECB encryption mode using Interrupt.
mbed_official 376:cb4d9db17537 779 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 780 * the configuration information for CRYP module
mbed_official 489:119543c9f674 781 * @param pPlainData: Pointer to the plaintext buffer (aligned on u32)
mbed_official 376:cb4d9db17537 782 * @param Size: Length of the plaintext buffer, must be a multiple of 16 bytes
mbed_official 489:119543c9f674 783 * @param pCypherData: Pointer to the cyphertext buffer (aligned on u32)
mbed_official 376:cb4d9db17537 784 * @retval HAL status
mbed_official 376:cb4d9db17537 785 */
mbed_official 376:cb4d9db17537 786 HAL_StatusTypeDef HAL_CRYP_AESECB_Encrypt_IT(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData)
mbed_official 376:cb4d9db17537 787 {
mbed_official 489:119543c9f674 788 uint32_t inputaddr = 0;
mbed_official 376:cb4d9db17537 789
mbed_official 489:119543c9f674 790 /* Check that data aligned on u32 */
mbed_official 489:119543c9f674 791 if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
mbed_official 489:119543c9f674 792 {
mbed_official 489:119543c9f674 793 /* Process Locked */
mbed_official 489:119543c9f674 794 __HAL_UNLOCK(hcryp);
mbed_official 489:119543c9f674 795
mbed_official 489:119543c9f674 796 /* Return function status */
mbed_official 489:119543c9f674 797 return HAL_ERROR;
mbed_official 489:119543c9f674 798 }
mbed_official 489:119543c9f674 799
mbed_official 489:119543c9f674 800 if ((hcryp->State != HAL_CRYP_STATE_RESET) && (hcryp->State == HAL_CRYP_STATE_READY))
mbed_official 376:cb4d9db17537 801 {
mbed_official 376:cb4d9db17537 802 /* Process Locked */
mbed_official 376:cb4d9db17537 803 __HAL_LOCK(hcryp);
mbed_official 376:cb4d9db17537 804
mbed_official 376:cb4d9db17537 805 /* Get the buffer addresses and sizes */
mbed_official 376:cb4d9db17537 806 hcryp->CrypInCount = Size;
mbed_official 376:cb4d9db17537 807 hcryp->pCrypInBuffPtr = pPlainData;
mbed_official 376:cb4d9db17537 808 hcryp->pCrypOutBuffPtr = pCypherData;
mbed_official 376:cb4d9db17537 809 hcryp->CrypOutCount = Size;
mbed_official 376:cb4d9db17537 810
mbed_official 376:cb4d9db17537 811 /* Change the CRYP state */
mbed_official 376:cb4d9db17537 812 hcryp->State = HAL_CRYP_STATE_BUSY;
mbed_official 376:cb4d9db17537 813
mbed_official 376:cb4d9db17537 814 /* Check if initialization phase has already been performed */
mbed_official 376:cb4d9db17537 815 if(hcryp->Phase == HAL_CRYP_PHASE_READY)
mbed_official 376:cb4d9db17537 816 {
mbed_official 376:cb4d9db17537 817 /* Set the key */
mbed_official 376:cb4d9db17537 818 CRYP_SetKey(hcryp, hcryp->Init.pKey);
mbed_official 376:cb4d9db17537 819
mbed_official 489:119543c9f674 820 /* Reset the CHMOD & MODE bits */
mbed_official 489:119543c9f674 821 CLEAR_BIT(hcryp->Instance->CR, CRYP_ALGO_CHAIN_MASK);
mbed_official 376:cb4d9db17537 822
mbed_official 376:cb4d9db17537 823 /* Set the CRYP peripheral in AES ECB mode */
mbed_official 489:119543c9f674 824 __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_ECB_ENCRYPT);
mbed_official 376:cb4d9db17537 825
mbed_official 376:cb4d9db17537 826 /* Set the phase */
mbed_official 376:cb4d9db17537 827 hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
mbed_official 376:cb4d9db17537 828 }
mbed_official 376:cb4d9db17537 829
mbed_official 376:cb4d9db17537 830 /* Enable Interrupts */
mbed_official 489:119543c9f674 831 __HAL_CRYP_ENABLE_IT(hcryp, CRYP_IT_CC);
mbed_official 376:cb4d9db17537 832
mbed_official 376:cb4d9db17537 833 /* Enable CRYP */
mbed_official 489:119543c9f674 834 __HAL_CRYP_ENABLE(hcryp);
mbed_official 376:cb4d9db17537 835
mbed_official 376:cb4d9db17537 836 /* Get the last input data adress */
mbed_official 376:cb4d9db17537 837 inputaddr = (uint32_t)hcryp->pCrypInBuffPtr;
mbed_official 376:cb4d9db17537 838
mbed_official 376:cb4d9db17537 839 /* Write the Input block in the Data Input register */
mbed_official 489:119543c9f674 840 hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
mbed_official 376:cb4d9db17537 841 inputaddr+=4;
mbed_official 489:119543c9f674 842 hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
mbed_official 376:cb4d9db17537 843 inputaddr+=4;
mbed_official 489:119543c9f674 844 hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
mbed_official 376:cb4d9db17537 845 inputaddr+=4;
mbed_official 489:119543c9f674 846 hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
mbed_official 376:cb4d9db17537 847 hcryp->pCrypInBuffPtr += 16;
mbed_official 376:cb4d9db17537 848 hcryp->CrypInCount -= 16;
mbed_official 376:cb4d9db17537 849
mbed_official 376:cb4d9db17537 850 /* Return function status */
mbed_official 376:cb4d9db17537 851 return HAL_OK;
mbed_official 376:cb4d9db17537 852 }
mbed_official 489:119543c9f674 853 else
mbed_official 376:cb4d9db17537 854 {
mbed_official 489:119543c9f674 855 /* Release Lock */
mbed_official 489:119543c9f674 856 __HAL_UNLOCK(hcryp);
mbed_official 489:119543c9f674 857
mbed_official 489:119543c9f674 858 /* Return function status */
mbed_official 489:119543c9f674 859 return HAL_ERROR;
mbed_official 376:cb4d9db17537 860 }
mbed_official 376:cb4d9db17537 861 }
mbed_official 376:cb4d9db17537 862
mbed_official 376:cb4d9db17537 863 /**
mbed_official 376:cb4d9db17537 864 * @brief Initializes the CRYP peripheral in AES CBC encryption mode using Interrupt.
mbed_official 376:cb4d9db17537 865 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 866 * the configuration information for CRYP module
mbed_official 489:119543c9f674 867 * @param pPlainData: Pointer to the plaintext buffer (aligned on u32)
mbed_official 376:cb4d9db17537 868 * @param Size: Length of the plaintext buffer, must be a multiple of 16 bytes
mbed_official 489:119543c9f674 869 * @param pCypherData: Pointer to the cyphertext buffer (aligned on u32)
mbed_official 376:cb4d9db17537 870 * @retval HAL status
mbed_official 376:cb4d9db17537 871 */
mbed_official 376:cb4d9db17537 872 HAL_StatusTypeDef HAL_CRYP_AESCBC_Encrypt_IT(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData)
mbed_official 376:cb4d9db17537 873 {
mbed_official 489:119543c9f674 874 uint32_t inputaddr = 0;
mbed_official 376:cb4d9db17537 875
mbed_official 489:119543c9f674 876 /* Check that data aligned on u32 */
mbed_official 489:119543c9f674 877 if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
mbed_official 489:119543c9f674 878 {
mbed_official 489:119543c9f674 879 /* Process Locked */
mbed_official 489:119543c9f674 880 __HAL_UNLOCK(hcryp);
mbed_official 489:119543c9f674 881
mbed_official 489:119543c9f674 882 /* Return function status */
mbed_official 489:119543c9f674 883 return HAL_ERROR;
mbed_official 489:119543c9f674 884 }
mbed_official 489:119543c9f674 885
mbed_official 489:119543c9f674 886 if ((hcryp->State != HAL_CRYP_STATE_RESET) && (hcryp->State == HAL_CRYP_STATE_READY))
mbed_official 376:cb4d9db17537 887 {
mbed_official 376:cb4d9db17537 888 /* Process Locked */
mbed_official 376:cb4d9db17537 889 __HAL_LOCK(hcryp);
mbed_official 376:cb4d9db17537 890
mbed_official 376:cb4d9db17537 891 /* Get the buffer addresses and sizes */
mbed_official 376:cb4d9db17537 892 hcryp->CrypInCount = Size;
mbed_official 376:cb4d9db17537 893 hcryp->pCrypInBuffPtr = pPlainData;
mbed_official 376:cb4d9db17537 894 hcryp->pCrypOutBuffPtr = pCypherData;
mbed_official 376:cb4d9db17537 895 hcryp->CrypOutCount = Size;
mbed_official 376:cb4d9db17537 896
mbed_official 376:cb4d9db17537 897 /* Change the CRYP state */
mbed_official 376:cb4d9db17537 898 hcryp->State = HAL_CRYP_STATE_BUSY;
mbed_official 376:cb4d9db17537 899
mbed_official 376:cb4d9db17537 900 /* Check if initialization phase has already been performed */
mbed_official 376:cb4d9db17537 901 if(hcryp->Phase == HAL_CRYP_PHASE_READY)
mbed_official 376:cb4d9db17537 902 {
mbed_official 376:cb4d9db17537 903 /* Set the key */
mbed_official 376:cb4d9db17537 904 CRYP_SetKey(hcryp, hcryp->Init.pKey);
mbed_official 376:cb4d9db17537 905
mbed_official 489:119543c9f674 906 /* Reset the CHMOD & MODE bits */
mbed_official 489:119543c9f674 907 CLEAR_BIT(hcryp->Instance->CR, CRYP_ALGO_CHAIN_MASK);
mbed_official 376:cb4d9db17537 908
mbed_official 376:cb4d9db17537 909 /* Set the CRYP peripheral in AES CBC mode */
mbed_official 489:119543c9f674 910 __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CBC_ENCRYPT);
mbed_official 376:cb4d9db17537 911
mbed_official 376:cb4d9db17537 912 /* Set the Initialization Vector */
mbed_official 376:cb4d9db17537 913 CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect);
mbed_official 376:cb4d9db17537 914
mbed_official 376:cb4d9db17537 915 /* Set the phase */
mbed_official 376:cb4d9db17537 916 hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
mbed_official 376:cb4d9db17537 917 }
mbed_official 376:cb4d9db17537 918
mbed_official 376:cb4d9db17537 919 /* Enable Interrupts */
mbed_official 489:119543c9f674 920 __HAL_CRYP_ENABLE_IT(hcryp, CRYP_IT_CC);
mbed_official 376:cb4d9db17537 921
mbed_official 376:cb4d9db17537 922 /* Enable CRYP */
mbed_official 489:119543c9f674 923 __HAL_CRYP_ENABLE(hcryp);
mbed_official 376:cb4d9db17537 924
mbed_official 376:cb4d9db17537 925 /* Get the last input data adress */
mbed_official 376:cb4d9db17537 926 inputaddr = (uint32_t)hcryp->pCrypInBuffPtr;
mbed_official 376:cb4d9db17537 927
mbed_official 376:cb4d9db17537 928 /* Write the Input block in the Data Input register */
mbed_official 489:119543c9f674 929 hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
mbed_official 376:cb4d9db17537 930 inputaddr+=4;
mbed_official 489:119543c9f674 931 hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
mbed_official 376:cb4d9db17537 932 inputaddr+=4;
mbed_official 489:119543c9f674 933 hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
mbed_official 376:cb4d9db17537 934 inputaddr+=4;
mbed_official 489:119543c9f674 935 hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
mbed_official 376:cb4d9db17537 936 hcryp->pCrypInBuffPtr += 16;
mbed_official 376:cb4d9db17537 937 hcryp->CrypInCount -= 16;
mbed_official 376:cb4d9db17537 938
mbed_official 376:cb4d9db17537 939 /* Return function status */
mbed_official 376:cb4d9db17537 940 return HAL_OK;
mbed_official 376:cb4d9db17537 941 }
mbed_official 489:119543c9f674 942 else
mbed_official 376:cb4d9db17537 943 {
mbed_official 489:119543c9f674 944 /* Release Lock */
mbed_official 489:119543c9f674 945 __HAL_UNLOCK(hcryp);
mbed_official 489:119543c9f674 946
mbed_official 489:119543c9f674 947 /* Return function status */
mbed_official 489:119543c9f674 948 return HAL_ERROR;
mbed_official 376:cb4d9db17537 949 }
mbed_official 376:cb4d9db17537 950 }
mbed_official 376:cb4d9db17537 951
mbed_official 376:cb4d9db17537 952 /**
mbed_official 376:cb4d9db17537 953 * @brief Initializes the CRYP peripheral in AES CTR encryption mode using Interrupt.
mbed_official 376:cb4d9db17537 954 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 955 * the configuration information for CRYP module
mbed_official 489:119543c9f674 956 * @param pPlainData: Pointer to the plaintext buffer (aligned on u32)
mbed_official 376:cb4d9db17537 957 * @param Size: Length of the plaintext buffer, must be a multiple of 16 bytes
mbed_official 489:119543c9f674 958 * @param pCypherData: Pointer to the cyphertext buffer (aligned on u32)
mbed_official 376:cb4d9db17537 959 * @retval HAL status
mbed_official 376:cb4d9db17537 960 */
mbed_official 376:cb4d9db17537 961 HAL_StatusTypeDef HAL_CRYP_AESCTR_Encrypt_IT(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData)
mbed_official 376:cb4d9db17537 962 {
mbed_official 489:119543c9f674 963 uint32_t inputaddr = 0;
mbed_official 376:cb4d9db17537 964
mbed_official 489:119543c9f674 965 /* Check that data aligned on u32 */
mbed_official 489:119543c9f674 966 if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
mbed_official 489:119543c9f674 967 {
mbed_official 489:119543c9f674 968 /* Process Locked */
mbed_official 489:119543c9f674 969 __HAL_UNLOCK(hcryp);
mbed_official 489:119543c9f674 970
mbed_official 489:119543c9f674 971 /* Return function status */
mbed_official 489:119543c9f674 972 return HAL_ERROR;
mbed_official 489:119543c9f674 973 }
mbed_official 489:119543c9f674 974
mbed_official 489:119543c9f674 975 if ((hcryp->State != HAL_CRYP_STATE_RESET) && (hcryp->State == HAL_CRYP_STATE_READY))
mbed_official 376:cb4d9db17537 976 {
mbed_official 376:cb4d9db17537 977 /* Process Locked */
mbed_official 376:cb4d9db17537 978 __HAL_LOCK(hcryp);
mbed_official 376:cb4d9db17537 979
mbed_official 376:cb4d9db17537 980 /* Get the buffer addresses and sizes */
mbed_official 376:cb4d9db17537 981 hcryp->CrypInCount = Size;
mbed_official 376:cb4d9db17537 982 hcryp->pCrypInBuffPtr = pPlainData;
mbed_official 376:cb4d9db17537 983 hcryp->pCrypOutBuffPtr = pCypherData;
mbed_official 376:cb4d9db17537 984 hcryp->CrypOutCount = Size;
mbed_official 376:cb4d9db17537 985
mbed_official 376:cb4d9db17537 986 /* Change the CRYP state */
mbed_official 376:cb4d9db17537 987 hcryp->State = HAL_CRYP_STATE_BUSY;
mbed_official 376:cb4d9db17537 988
mbed_official 376:cb4d9db17537 989 /* Check if initialization phase has already been performed */
mbed_official 376:cb4d9db17537 990 if(hcryp->Phase == HAL_CRYP_PHASE_READY)
mbed_official 376:cb4d9db17537 991 {
mbed_official 376:cb4d9db17537 992 /* Set the key */
mbed_official 376:cb4d9db17537 993 CRYP_SetKey(hcryp, hcryp->Init.pKey);
mbed_official 376:cb4d9db17537 994
mbed_official 489:119543c9f674 995 /* Reset the CHMOD & MODE bits */
mbed_official 489:119543c9f674 996 CLEAR_BIT(hcryp->Instance->CR, CRYP_ALGO_CHAIN_MASK);
mbed_official 376:cb4d9db17537 997
mbed_official 376:cb4d9db17537 998 /* Set the CRYP peripheral in AES CTR mode */
mbed_official 489:119543c9f674 999 __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CTR_ENCRYPT);
mbed_official 376:cb4d9db17537 1000
mbed_official 376:cb4d9db17537 1001 /* Set the Initialization Vector */
mbed_official 376:cb4d9db17537 1002 CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect);
mbed_official 376:cb4d9db17537 1003
mbed_official 376:cb4d9db17537 1004 /* Set the phase */
mbed_official 376:cb4d9db17537 1005 hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
mbed_official 376:cb4d9db17537 1006 }
mbed_official 376:cb4d9db17537 1007
mbed_official 376:cb4d9db17537 1008 /* Enable Interrupts */
mbed_official 489:119543c9f674 1009 __HAL_CRYP_ENABLE_IT(hcryp, CRYP_IT_CC);
mbed_official 376:cb4d9db17537 1010
mbed_official 376:cb4d9db17537 1011 /* Enable CRYP */
mbed_official 489:119543c9f674 1012 __HAL_CRYP_ENABLE(hcryp);
mbed_official 376:cb4d9db17537 1013
mbed_official 376:cb4d9db17537 1014 /* Get the last input data adress */
mbed_official 376:cb4d9db17537 1015 inputaddr = (uint32_t)hcryp->pCrypInBuffPtr;
mbed_official 376:cb4d9db17537 1016
mbed_official 376:cb4d9db17537 1017 /* Write the Input block in the Data Input register */
mbed_official 489:119543c9f674 1018 hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
mbed_official 376:cb4d9db17537 1019 inputaddr+=4;
mbed_official 489:119543c9f674 1020 hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
mbed_official 376:cb4d9db17537 1021 inputaddr+=4;
mbed_official 489:119543c9f674 1022 hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
mbed_official 376:cb4d9db17537 1023 inputaddr+=4;
mbed_official 489:119543c9f674 1024 hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
mbed_official 376:cb4d9db17537 1025 hcryp->pCrypInBuffPtr += 16;
mbed_official 376:cb4d9db17537 1026 hcryp->CrypInCount -= 16;
mbed_official 376:cb4d9db17537 1027
mbed_official 376:cb4d9db17537 1028 /* Return function status */
mbed_official 376:cb4d9db17537 1029 return HAL_OK;
mbed_official 376:cb4d9db17537 1030 }
mbed_official 489:119543c9f674 1031 else
mbed_official 376:cb4d9db17537 1032 {
mbed_official 489:119543c9f674 1033 /* Release Lock */
mbed_official 489:119543c9f674 1034 __HAL_UNLOCK(hcryp);
mbed_official 489:119543c9f674 1035
mbed_official 489:119543c9f674 1036 /* Return function status */
mbed_official 489:119543c9f674 1037 return HAL_ERROR;
mbed_official 376:cb4d9db17537 1038 }
mbed_official 376:cb4d9db17537 1039 }
mbed_official 376:cb4d9db17537 1040
mbed_official 376:cb4d9db17537 1041 /**
mbed_official 376:cb4d9db17537 1042 * @brief Initializes the CRYP peripheral in AES ECB decryption mode using Interrupt.
mbed_official 376:cb4d9db17537 1043 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1044 * the configuration information for CRYP module
mbed_official 489:119543c9f674 1045 * @param pCypherData: Pointer to the cyphertext buffer (aligned on u32)
mbed_official 376:cb4d9db17537 1046 * @param Size: Length of the plaintext buffer, must be a multiple of 16.
mbed_official 489:119543c9f674 1047 * @param pPlainData: Pointer to the plaintext buffer (aligned on u32)
mbed_official 376:cb4d9db17537 1048 * @retval HAL status
mbed_official 376:cb4d9db17537 1049 */
mbed_official 376:cb4d9db17537 1050 HAL_StatusTypeDef HAL_CRYP_AESECB_Decrypt_IT(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData)
mbed_official 376:cb4d9db17537 1051 {
mbed_official 489:119543c9f674 1052 uint32_t inputaddr = 0;
mbed_official 376:cb4d9db17537 1053
mbed_official 489:119543c9f674 1054 /* Check that data aligned on u32 */
mbed_official 489:119543c9f674 1055 if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
mbed_official 489:119543c9f674 1056 {
mbed_official 489:119543c9f674 1057 /* Process Locked */
mbed_official 489:119543c9f674 1058 __HAL_UNLOCK(hcryp);
mbed_official 489:119543c9f674 1059
mbed_official 489:119543c9f674 1060 /* Return function status */
mbed_official 489:119543c9f674 1061 return HAL_ERROR;
mbed_official 489:119543c9f674 1062 }
mbed_official 489:119543c9f674 1063
mbed_official 489:119543c9f674 1064 if ((hcryp->State != HAL_CRYP_STATE_RESET) && (hcryp->State == HAL_CRYP_STATE_READY))
mbed_official 376:cb4d9db17537 1065 {
mbed_official 376:cb4d9db17537 1066 /* Process Locked */
mbed_official 376:cb4d9db17537 1067 __HAL_LOCK(hcryp);
mbed_official 376:cb4d9db17537 1068
mbed_official 376:cb4d9db17537 1069 /* Get the buffer addresses and sizes */
mbed_official 376:cb4d9db17537 1070 hcryp->CrypInCount = Size;
mbed_official 376:cb4d9db17537 1071 hcryp->pCrypInBuffPtr = pCypherData;
mbed_official 376:cb4d9db17537 1072 hcryp->pCrypOutBuffPtr = pPlainData;
mbed_official 376:cb4d9db17537 1073 hcryp->CrypOutCount = Size;
mbed_official 376:cb4d9db17537 1074
mbed_official 376:cb4d9db17537 1075 /* Change the CRYP state */
mbed_official 376:cb4d9db17537 1076 hcryp->State = HAL_CRYP_STATE_BUSY;
mbed_official 376:cb4d9db17537 1077
mbed_official 489:119543c9f674 1078 /* Check if initialization phase has already been performed */
mbed_official 489:119543c9f674 1079 if(hcryp->Phase == HAL_CRYP_PHASE_READY)
mbed_official 489:119543c9f674 1080 {
mbed_official 489:119543c9f674 1081 /* Set the key */
mbed_official 489:119543c9f674 1082 CRYP_SetKey(hcryp, hcryp->Init.pKey);
mbed_official 489:119543c9f674 1083
mbed_official 489:119543c9f674 1084 /* Reset the CHMOD & MODE bits */
mbed_official 489:119543c9f674 1085 CLEAR_BIT(hcryp->Instance->CR, CRYP_ALGO_CHAIN_MASK);
mbed_official 489:119543c9f674 1086
mbed_official 489:119543c9f674 1087 /* Set the CRYP peripheral in AES ECB decryption mode (with key derivation) */
mbed_official 489:119543c9f674 1088 __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_ECB_KEYDERDECRYPT);
mbed_official 489:119543c9f674 1089
mbed_official 489:119543c9f674 1090 /* Set the phase */
mbed_official 489:119543c9f674 1091 hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
mbed_official 489:119543c9f674 1092 }
mbed_official 376:cb4d9db17537 1093
mbed_official 376:cb4d9db17537 1094 /* Enable Interrupts */
mbed_official 489:119543c9f674 1095 __HAL_CRYP_ENABLE_IT(hcryp, CRYP_IT_CC);
mbed_official 376:cb4d9db17537 1096
mbed_official 376:cb4d9db17537 1097 /* Enable CRYP */
mbed_official 489:119543c9f674 1098 __HAL_CRYP_ENABLE(hcryp);
mbed_official 376:cb4d9db17537 1099
mbed_official 376:cb4d9db17537 1100 /* Get the last input data adress */
mbed_official 376:cb4d9db17537 1101 inputaddr = (uint32_t)hcryp->pCrypInBuffPtr;
mbed_official 376:cb4d9db17537 1102
mbed_official 376:cb4d9db17537 1103 /* Write the Input block in the Data Input register */
mbed_official 489:119543c9f674 1104 hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
mbed_official 376:cb4d9db17537 1105 inputaddr+=4;
mbed_official 489:119543c9f674 1106 hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
mbed_official 376:cb4d9db17537 1107 inputaddr+=4;
mbed_official 489:119543c9f674 1108 hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
mbed_official 376:cb4d9db17537 1109 inputaddr+=4;
mbed_official 489:119543c9f674 1110 hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
mbed_official 376:cb4d9db17537 1111 hcryp->pCrypInBuffPtr += 16;
mbed_official 376:cb4d9db17537 1112 hcryp->CrypInCount -= 16;
mbed_official 376:cb4d9db17537 1113
mbed_official 376:cb4d9db17537 1114 /* Return function status */
mbed_official 376:cb4d9db17537 1115 return HAL_OK;
mbed_official 376:cb4d9db17537 1116 }
mbed_official 489:119543c9f674 1117 else
mbed_official 376:cb4d9db17537 1118 {
mbed_official 489:119543c9f674 1119 /* Release Lock */
mbed_official 489:119543c9f674 1120 __HAL_UNLOCK(hcryp);
mbed_official 489:119543c9f674 1121
mbed_official 489:119543c9f674 1122 /* Return function status */
mbed_official 489:119543c9f674 1123 return HAL_ERROR;
mbed_official 376:cb4d9db17537 1124 }
mbed_official 376:cb4d9db17537 1125 }
mbed_official 376:cb4d9db17537 1126
mbed_official 376:cb4d9db17537 1127 /**
mbed_official 376:cb4d9db17537 1128 * @brief Initializes the CRYP peripheral in AES CBC decryption mode using IT.
mbed_official 376:cb4d9db17537 1129 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1130 * the configuration information for CRYP module
mbed_official 489:119543c9f674 1131 * @param pCypherData: Pointer to the cyphertext buffer (aligned on u32)
mbed_official 376:cb4d9db17537 1132 * @param Size: Length of the plaintext buffer, must be a multiple of 16
mbed_official 489:119543c9f674 1133 * @param pPlainData: Pointer to the plaintext buffer (aligned on u32)
mbed_official 376:cb4d9db17537 1134 * @retval HAL status
mbed_official 376:cb4d9db17537 1135 */
mbed_official 376:cb4d9db17537 1136 HAL_StatusTypeDef HAL_CRYP_AESCBC_Decrypt_IT(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData)
mbed_official 376:cb4d9db17537 1137 {
mbed_official 489:119543c9f674 1138 uint32_t inputaddr = 0;
mbed_official 376:cb4d9db17537 1139
mbed_official 489:119543c9f674 1140 /* Check that data aligned on u32 */
mbed_official 489:119543c9f674 1141 if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
mbed_official 489:119543c9f674 1142 {
mbed_official 489:119543c9f674 1143 /* Process Locked */
mbed_official 489:119543c9f674 1144 __HAL_UNLOCK(hcryp);
mbed_official 489:119543c9f674 1145
mbed_official 489:119543c9f674 1146 /* Return function status */
mbed_official 489:119543c9f674 1147 return HAL_ERROR;
mbed_official 489:119543c9f674 1148 }
mbed_official 489:119543c9f674 1149
mbed_official 489:119543c9f674 1150 if ((hcryp->State != HAL_CRYP_STATE_RESET) && (hcryp->State == HAL_CRYP_STATE_READY))
mbed_official 376:cb4d9db17537 1151 {
mbed_official 376:cb4d9db17537 1152 /* Process Locked */
mbed_official 376:cb4d9db17537 1153 __HAL_LOCK(hcryp);
mbed_official 376:cb4d9db17537 1154
mbed_official 376:cb4d9db17537 1155 /* Get the buffer addresses and sizes */
mbed_official 376:cb4d9db17537 1156 hcryp->CrypInCount = Size;
mbed_official 376:cb4d9db17537 1157 hcryp->pCrypInBuffPtr = pCypherData;
mbed_official 376:cb4d9db17537 1158 hcryp->pCrypOutBuffPtr = pPlainData;
mbed_official 376:cb4d9db17537 1159 hcryp->CrypOutCount = Size;
mbed_official 376:cb4d9db17537 1160
mbed_official 376:cb4d9db17537 1161 /* Change the CRYP state */
mbed_official 376:cb4d9db17537 1162 hcryp->State = HAL_CRYP_STATE_BUSY;
mbed_official 376:cb4d9db17537 1163
mbed_official 489:119543c9f674 1164 /* Check if initialization phase has already been performed */
mbed_official 489:119543c9f674 1165 if(hcryp->Phase == HAL_CRYP_PHASE_READY)
mbed_official 489:119543c9f674 1166 {
mbed_official 489:119543c9f674 1167 /* Set the key */
mbed_official 489:119543c9f674 1168 CRYP_SetKey(hcryp, hcryp->Init.pKey);
mbed_official 489:119543c9f674 1169
mbed_official 489:119543c9f674 1170 /* Reset the CHMOD & MODE bits */
mbed_official 489:119543c9f674 1171 CLEAR_BIT(hcryp->Instance->CR, CRYP_ALGO_CHAIN_MASK);
mbed_official 489:119543c9f674 1172
mbed_official 489:119543c9f674 1173 /* Set the CRYP peripheral in AES CBC decryption mode (with key derivation) */
mbed_official 489:119543c9f674 1174 __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CBC_KEYDERDECRYPT);
mbed_official 489:119543c9f674 1175
mbed_official 489:119543c9f674 1176 /* Set the Initialization Vector */
mbed_official 489:119543c9f674 1177 CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect);
mbed_official 489:119543c9f674 1178
mbed_official 489:119543c9f674 1179 /* Set the phase */
mbed_official 489:119543c9f674 1180 hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
mbed_official 489:119543c9f674 1181 }
mbed_official 376:cb4d9db17537 1182
mbed_official 376:cb4d9db17537 1183 /* Enable Interrupts */
mbed_official 489:119543c9f674 1184 __HAL_CRYP_ENABLE_IT(hcryp, CRYP_IT_CC);
mbed_official 376:cb4d9db17537 1185
mbed_official 376:cb4d9db17537 1186 /* Enable CRYP */
mbed_official 489:119543c9f674 1187 __HAL_CRYP_ENABLE(hcryp);
mbed_official 376:cb4d9db17537 1188
mbed_official 376:cb4d9db17537 1189 /* Get the last input data adress */
mbed_official 376:cb4d9db17537 1190 inputaddr = (uint32_t)hcryp->pCrypInBuffPtr;
mbed_official 376:cb4d9db17537 1191
mbed_official 376:cb4d9db17537 1192 /* Write the Input block in the Data Input register */
mbed_official 489:119543c9f674 1193 hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
mbed_official 376:cb4d9db17537 1194 inputaddr+=4;
mbed_official 489:119543c9f674 1195 hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
mbed_official 376:cb4d9db17537 1196 inputaddr+=4;
mbed_official 489:119543c9f674 1197 hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
mbed_official 376:cb4d9db17537 1198 inputaddr+=4;
mbed_official 489:119543c9f674 1199 hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
mbed_official 376:cb4d9db17537 1200 hcryp->pCrypInBuffPtr += 16;
mbed_official 376:cb4d9db17537 1201 hcryp->CrypInCount -= 16;
mbed_official 376:cb4d9db17537 1202
mbed_official 376:cb4d9db17537 1203 /* Return function status */
mbed_official 376:cb4d9db17537 1204 return HAL_OK;
mbed_official 376:cb4d9db17537 1205 }
mbed_official 489:119543c9f674 1206 else
mbed_official 376:cb4d9db17537 1207 {
mbed_official 489:119543c9f674 1208 /* Release Lock */
mbed_official 489:119543c9f674 1209 __HAL_UNLOCK(hcryp);
mbed_official 489:119543c9f674 1210
mbed_official 489:119543c9f674 1211 /* Return function status */
mbed_official 489:119543c9f674 1212 return HAL_ERROR;
mbed_official 376:cb4d9db17537 1213 }
mbed_official 376:cb4d9db17537 1214 }
mbed_official 376:cb4d9db17537 1215
mbed_official 376:cb4d9db17537 1216 /**
mbed_official 376:cb4d9db17537 1217 * @brief Initializes the CRYP peripheral in AES CTR decryption mode using Interrupt.
mbed_official 376:cb4d9db17537 1218 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1219 * the configuration information for CRYP module
mbed_official 489:119543c9f674 1220 * @param pCypherData: Pointer to the cyphertext buffer (aligned on u32)
mbed_official 376:cb4d9db17537 1221 * @param Size: Length of the plaintext buffer, must be a multiple of 16
mbed_official 489:119543c9f674 1222 * @param pPlainData: Pointer to the plaintext buffer (aligned on u32)
mbed_official 376:cb4d9db17537 1223 * @retval HAL status
mbed_official 376:cb4d9db17537 1224 */
mbed_official 376:cb4d9db17537 1225 HAL_StatusTypeDef HAL_CRYP_AESCTR_Decrypt_IT(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData)
mbed_official 376:cb4d9db17537 1226 {
mbed_official 489:119543c9f674 1227 uint32_t inputaddr = 0;
mbed_official 376:cb4d9db17537 1228
mbed_official 489:119543c9f674 1229 /* Check that data aligned on u32 */
mbed_official 489:119543c9f674 1230 if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
mbed_official 489:119543c9f674 1231 {
mbed_official 489:119543c9f674 1232 /* Process Locked */
mbed_official 489:119543c9f674 1233 __HAL_UNLOCK(hcryp);
mbed_official 489:119543c9f674 1234
mbed_official 489:119543c9f674 1235 /* Return function status */
mbed_official 489:119543c9f674 1236 return HAL_ERROR;
mbed_official 489:119543c9f674 1237 }
mbed_official 489:119543c9f674 1238
mbed_official 489:119543c9f674 1239 if ((hcryp->State != HAL_CRYP_STATE_RESET) && (hcryp->State == HAL_CRYP_STATE_READY))
mbed_official 376:cb4d9db17537 1240 {
mbed_official 376:cb4d9db17537 1241 /* Process Locked */
mbed_official 376:cb4d9db17537 1242 __HAL_LOCK(hcryp);
mbed_official 376:cb4d9db17537 1243
mbed_official 376:cb4d9db17537 1244 /* Get the buffer addresses and sizes */
mbed_official 376:cb4d9db17537 1245 hcryp->CrypInCount = Size;
mbed_official 376:cb4d9db17537 1246 hcryp->pCrypInBuffPtr = pCypherData;
mbed_official 376:cb4d9db17537 1247 hcryp->pCrypOutBuffPtr = pPlainData;
mbed_official 376:cb4d9db17537 1248 hcryp->CrypOutCount = Size;
mbed_official 376:cb4d9db17537 1249
mbed_official 376:cb4d9db17537 1250 /* Change the CRYP state */
mbed_official 376:cb4d9db17537 1251 hcryp->State = HAL_CRYP_STATE_BUSY;
mbed_official 376:cb4d9db17537 1252
mbed_official 489:119543c9f674 1253 /* Check if initialization phase has already been performed */
mbed_official 489:119543c9f674 1254 if(hcryp->Phase == HAL_CRYP_PHASE_READY)
mbed_official 489:119543c9f674 1255 {
mbed_official 489:119543c9f674 1256 /* Set the key */
mbed_official 489:119543c9f674 1257 CRYP_SetKey(hcryp, hcryp->Init.pKey);
mbed_official 489:119543c9f674 1258
mbed_official 489:119543c9f674 1259 /* Reset the CHMOD & MODE bits */
mbed_official 489:119543c9f674 1260 CLEAR_BIT(hcryp->Instance->CR, CRYP_ALGO_CHAIN_MASK);
mbed_official 489:119543c9f674 1261
mbed_official 489:119543c9f674 1262 /* Set the CRYP peripheral in AES CTR decryption mode */
mbed_official 489:119543c9f674 1263 __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CTR_DECRYPT);
mbed_official 489:119543c9f674 1264
mbed_official 489:119543c9f674 1265 /* Set the Initialization Vector */
mbed_official 489:119543c9f674 1266 CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect);
mbed_official 489:119543c9f674 1267
mbed_official 489:119543c9f674 1268 /* Set the phase */
mbed_official 489:119543c9f674 1269 hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
mbed_official 489:119543c9f674 1270 }
mbed_official 376:cb4d9db17537 1271
mbed_official 376:cb4d9db17537 1272 /* Enable Interrupts */
mbed_official 489:119543c9f674 1273 __HAL_CRYP_ENABLE_IT(hcryp, CRYP_IT_CC);
mbed_official 376:cb4d9db17537 1274
mbed_official 376:cb4d9db17537 1275 /* Enable CRYP */
mbed_official 489:119543c9f674 1276 __HAL_CRYP_ENABLE(hcryp);
mbed_official 376:cb4d9db17537 1277
mbed_official 376:cb4d9db17537 1278 /* Get the last input data adress */
mbed_official 376:cb4d9db17537 1279 inputaddr = (uint32_t)hcryp->pCrypInBuffPtr;
mbed_official 376:cb4d9db17537 1280
mbed_official 376:cb4d9db17537 1281 /* Write the Input block in the Data Input register */
mbed_official 489:119543c9f674 1282 hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
mbed_official 376:cb4d9db17537 1283 inputaddr+=4;
mbed_official 489:119543c9f674 1284 hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
mbed_official 376:cb4d9db17537 1285 inputaddr+=4;
mbed_official 489:119543c9f674 1286 hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
mbed_official 376:cb4d9db17537 1287 inputaddr+=4;
mbed_official 489:119543c9f674 1288 hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
mbed_official 376:cb4d9db17537 1289 hcryp->pCrypInBuffPtr += 16;
mbed_official 376:cb4d9db17537 1290 hcryp->CrypInCount -= 16;
mbed_official 376:cb4d9db17537 1291
mbed_official 376:cb4d9db17537 1292 /* Return function status */
mbed_official 376:cb4d9db17537 1293 return HAL_OK;
mbed_official 376:cb4d9db17537 1294 }
mbed_official 489:119543c9f674 1295 else
mbed_official 376:cb4d9db17537 1296 {
mbed_official 489:119543c9f674 1297 /* Release Lock */
mbed_official 489:119543c9f674 1298 __HAL_UNLOCK(hcryp);
mbed_official 489:119543c9f674 1299
mbed_official 489:119543c9f674 1300 /* Return function status */
mbed_official 489:119543c9f674 1301 return HAL_ERROR;
mbed_official 376:cb4d9db17537 1302 }
mbed_official 376:cb4d9db17537 1303 }
mbed_official 376:cb4d9db17537 1304
mbed_official 376:cb4d9db17537 1305 /**
mbed_official 376:cb4d9db17537 1306 * @brief Initializes the CRYP peripheral in AES ECB encryption mode using DMA.
mbed_official 376:cb4d9db17537 1307 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1308 * the configuration information for CRYP module
mbed_official 489:119543c9f674 1309 * @param pPlainData: Pointer to the plaintext buffer (aligned on u32)
mbed_official 376:cb4d9db17537 1310 * @param Size: Length of the plaintext buffer, must be a multiple of 16 bytes
mbed_official 489:119543c9f674 1311 * @param pCypherData: Pointer to the cyphertext buffer (aligned on u32)
mbed_official 376:cb4d9db17537 1312 * @retval HAL status
mbed_official 376:cb4d9db17537 1313 */
mbed_official 376:cb4d9db17537 1314 HAL_StatusTypeDef HAL_CRYP_AESECB_Encrypt_DMA(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData)
mbed_official 376:cb4d9db17537 1315 {
mbed_official 489:119543c9f674 1316 uint32_t inputaddr = 0, outputaddr = 0;
mbed_official 376:cb4d9db17537 1317
mbed_official 489:119543c9f674 1318 /* Check that data aligned on u32 */
mbed_official 489:119543c9f674 1319 if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
mbed_official 489:119543c9f674 1320 {
mbed_official 489:119543c9f674 1321 /* Process Locked */
mbed_official 489:119543c9f674 1322 __HAL_UNLOCK(hcryp);
mbed_official 489:119543c9f674 1323
mbed_official 489:119543c9f674 1324 /* Return function status */
mbed_official 489:119543c9f674 1325 return HAL_ERROR;
mbed_official 489:119543c9f674 1326 }
mbed_official 489:119543c9f674 1327
mbed_official 489:119543c9f674 1328 /* Check if HAL_CRYP_Init has been called */
mbed_official 489:119543c9f674 1329 if ((hcryp->State != HAL_CRYP_STATE_RESET) && (hcryp->State == HAL_CRYP_STATE_READY))
mbed_official 376:cb4d9db17537 1330 {
mbed_official 376:cb4d9db17537 1331 /* Process Locked */
mbed_official 376:cb4d9db17537 1332 __HAL_LOCK(hcryp);
mbed_official 376:cb4d9db17537 1333
mbed_official 376:cb4d9db17537 1334 inputaddr = (uint32_t)pPlainData;
mbed_official 376:cb4d9db17537 1335 outputaddr = (uint32_t)pCypherData;
mbed_official 376:cb4d9db17537 1336
mbed_official 376:cb4d9db17537 1337 /* Change the CRYP state */
mbed_official 376:cb4d9db17537 1338 hcryp->State = HAL_CRYP_STATE_BUSY;
mbed_official 376:cb4d9db17537 1339
mbed_official 376:cb4d9db17537 1340 /* Check if initialization phase has already been performed */
mbed_official 376:cb4d9db17537 1341 if(hcryp->Phase == HAL_CRYP_PHASE_READY)
mbed_official 376:cb4d9db17537 1342 {
mbed_official 376:cb4d9db17537 1343 /* Set the key */
mbed_official 376:cb4d9db17537 1344 CRYP_SetKey(hcryp, hcryp->Init.pKey);
mbed_official 376:cb4d9db17537 1345
mbed_official 376:cb4d9db17537 1346 /* Set the CRYP peripheral in AES ECB mode */
mbed_official 489:119543c9f674 1347 __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_ECB_ENCRYPT);
mbed_official 489:119543c9f674 1348
mbed_official 489:119543c9f674 1349 /* Set the phase */
mbed_official 489:119543c9f674 1350 hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
mbed_official 376:cb4d9db17537 1351 }
mbed_official 376:cb4d9db17537 1352 /* Set the input and output addresses and start DMA transfer */
mbed_official 376:cb4d9db17537 1353 CRYP_SetDMAConfig(hcryp, inputaddr, Size, outputaddr);
mbed_official 376:cb4d9db17537 1354
mbed_official 376:cb4d9db17537 1355 /* Process Unlocked */
mbed_official 376:cb4d9db17537 1356 __HAL_UNLOCK(hcryp);
mbed_official 489:119543c9f674 1357
mbed_official 376:cb4d9db17537 1358 /* Return function status */
mbed_official 376:cb4d9db17537 1359 return HAL_OK;
mbed_official 376:cb4d9db17537 1360 }
mbed_official 376:cb4d9db17537 1361 else
mbed_official 489:119543c9f674 1362 {
mbed_official 489:119543c9f674 1363 /* Release Lock */
mbed_official 489:119543c9f674 1364 __HAL_UNLOCK(hcryp);
mbed_official 489:119543c9f674 1365
mbed_official 376:cb4d9db17537 1366 return HAL_ERROR;
mbed_official 376:cb4d9db17537 1367 }
mbed_official 376:cb4d9db17537 1368 }
mbed_official 376:cb4d9db17537 1369
mbed_official 376:cb4d9db17537 1370 /**
mbed_official 376:cb4d9db17537 1371 * @brief Initializes the CRYP peripheral in AES CBC encryption mode using DMA.
mbed_official 376:cb4d9db17537 1372 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1373 * the configuration information for CRYP module
mbed_official 489:119543c9f674 1374 * @param pPlainData: Pointer to the plaintext buffer (aligned on u32)
mbed_official 376:cb4d9db17537 1375 * @param Size: Length of the plaintext buffer, must be a multiple of 16.
mbed_official 489:119543c9f674 1376 * @param pCypherData: Pointer to the cyphertext buffer (aligned on u32)
mbed_official 376:cb4d9db17537 1377 * @retval HAL status
mbed_official 376:cb4d9db17537 1378 */
mbed_official 376:cb4d9db17537 1379 HAL_StatusTypeDef HAL_CRYP_AESCBC_Encrypt_DMA(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData)
mbed_official 376:cb4d9db17537 1380 {
mbed_official 489:119543c9f674 1381 uint32_t inputaddr = 0, outputaddr = 0;
mbed_official 376:cb4d9db17537 1382
mbed_official 489:119543c9f674 1383 /* Check that data aligned on u32 */
mbed_official 489:119543c9f674 1384 if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
mbed_official 489:119543c9f674 1385 {
mbed_official 489:119543c9f674 1386 /* Process Locked */
mbed_official 489:119543c9f674 1387 __HAL_UNLOCK(hcryp);
mbed_official 489:119543c9f674 1388
mbed_official 489:119543c9f674 1389 /* Return function status */
mbed_official 489:119543c9f674 1390 return HAL_ERROR;
mbed_official 489:119543c9f674 1391 }
mbed_official 489:119543c9f674 1392
mbed_official 489:119543c9f674 1393 /* Check if HAL_CRYP_Init has been called */
mbed_official 489:119543c9f674 1394 if ((hcryp->State != HAL_CRYP_STATE_RESET) && (hcryp->State == HAL_CRYP_STATE_READY))
mbed_official 376:cb4d9db17537 1395 {
mbed_official 376:cb4d9db17537 1396 /* Process Locked */
mbed_official 376:cb4d9db17537 1397 __HAL_LOCK(hcryp);
mbed_official 376:cb4d9db17537 1398
mbed_official 376:cb4d9db17537 1399 inputaddr = (uint32_t)pPlainData;
mbed_official 376:cb4d9db17537 1400 outputaddr = (uint32_t)pCypherData;
mbed_official 376:cb4d9db17537 1401
mbed_official 376:cb4d9db17537 1402 /* Change the CRYP state */
mbed_official 376:cb4d9db17537 1403 hcryp->State = HAL_CRYP_STATE_BUSY;
mbed_official 489:119543c9f674 1404
mbed_official 376:cb4d9db17537 1405 /* Check if initialization phase has already been performed */
mbed_official 376:cb4d9db17537 1406 if(hcryp->Phase == HAL_CRYP_PHASE_READY)
mbed_official 376:cb4d9db17537 1407 {
mbed_official 376:cb4d9db17537 1408 /* Set the key */
mbed_official 376:cb4d9db17537 1409 CRYP_SetKey(hcryp, hcryp->Init.pKey);
mbed_official 376:cb4d9db17537 1410
mbed_official 489:119543c9f674 1411 /* Set the CRYP peripheral in AES CBC mode */
mbed_official 489:119543c9f674 1412 __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CBC_ENCRYPT);
mbed_official 376:cb4d9db17537 1413
mbed_official 376:cb4d9db17537 1414 /* Set the Initialization Vector */
mbed_official 376:cb4d9db17537 1415 CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect);
mbed_official 489:119543c9f674 1416
mbed_official 489:119543c9f674 1417 /* Set the phase */
mbed_official 489:119543c9f674 1418 hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
mbed_official 489:119543c9f674 1419 }
mbed_official 489:119543c9f674 1420 /* Set the input and output addresses and start DMA transfer */
mbed_official 489:119543c9f674 1421 CRYP_SetDMAConfig(hcryp, inputaddr, Size, outputaddr);
mbed_official 489:119543c9f674 1422
mbed_official 489:119543c9f674 1423 /* Process Unlocked */
mbed_official 489:119543c9f674 1424 __HAL_UNLOCK(hcryp);
mbed_official 489:119543c9f674 1425
mbed_official 489:119543c9f674 1426 /* Return function status */
mbed_official 489:119543c9f674 1427 return HAL_OK;
mbed_official 376:cb4d9db17537 1428 }
mbed_official 376:cb4d9db17537 1429 else
mbed_official 376:cb4d9db17537 1430 {
mbed_official 489:119543c9f674 1431 /* Release Lock */
mbed_official 489:119543c9f674 1432 __HAL_UNLOCK(hcryp);
mbed_official 489:119543c9f674 1433
mbed_official 376:cb4d9db17537 1434 return HAL_ERROR;
mbed_official 376:cb4d9db17537 1435 }
mbed_official 376:cb4d9db17537 1436 }
mbed_official 376:cb4d9db17537 1437
mbed_official 376:cb4d9db17537 1438 /**
mbed_official 376:cb4d9db17537 1439 * @brief Initializes the CRYP peripheral in AES CTR encryption mode using DMA.
mbed_official 376:cb4d9db17537 1440 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1441 * the configuration information for CRYP module
mbed_official 489:119543c9f674 1442 * @param pPlainData: Pointer to the plaintext buffer (aligned on u32)
mbed_official 376:cb4d9db17537 1443 * @param Size: Length of the plaintext buffer, must be a multiple of 16.
mbed_official 489:119543c9f674 1444 * @param pCypherData: Pointer to the cyphertext buffer (aligned on u32)
mbed_official 376:cb4d9db17537 1445 * @retval HAL status
mbed_official 376:cb4d9db17537 1446 */
mbed_official 376:cb4d9db17537 1447 HAL_StatusTypeDef HAL_CRYP_AESCTR_Encrypt_DMA(CRYP_HandleTypeDef *hcryp, uint8_t *pPlainData, uint16_t Size, uint8_t *pCypherData)
mbed_official 376:cb4d9db17537 1448 {
mbed_official 489:119543c9f674 1449 uint32_t inputaddr = 0, outputaddr = 0;
mbed_official 376:cb4d9db17537 1450
mbed_official 489:119543c9f674 1451 /* Check that data aligned on u32 */
mbed_official 489:119543c9f674 1452 if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
mbed_official 489:119543c9f674 1453 {
mbed_official 489:119543c9f674 1454 /* Process Locked */
mbed_official 489:119543c9f674 1455 __HAL_UNLOCK(hcryp);
mbed_official 489:119543c9f674 1456
mbed_official 489:119543c9f674 1457 /* Return function status */
mbed_official 489:119543c9f674 1458 return HAL_ERROR;
mbed_official 489:119543c9f674 1459 }
mbed_official 489:119543c9f674 1460
mbed_official 489:119543c9f674 1461 /* Check if HAL_CRYP_Init has been called */
mbed_official 489:119543c9f674 1462 if ((hcryp->State != HAL_CRYP_STATE_RESET) && (hcryp->State == HAL_CRYP_STATE_READY))
mbed_official 376:cb4d9db17537 1463 {
mbed_official 376:cb4d9db17537 1464 /* Process Locked */
mbed_official 376:cb4d9db17537 1465 __HAL_LOCK(hcryp);
mbed_official 376:cb4d9db17537 1466
mbed_official 376:cb4d9db17537 1467 inputaddr = (uint32_t)pPlainData;
mbed_official 376:cb4d9db17537 1468 outputaddr = (uint32_t)pCypherData;
mbed_official 376:cb4d9db17537 1469
mbed_official 489:119543c9f674 1470 /* Change the CRYP state */
mbed_official 489:119543c9f674 1471 hcryp->State = HAL_CRYP_STATE_BUSY;
mbed_official 489:119543c9f674 1472
mbed_official 376:cb4d9db17537 1473 /* Check if initialization phase has already been performed */
mbed_official 376:cb4d9db17537 1474 if(hcryp->Phase == HAL_CRYP_PHASE_READY)
mbed_official 376:cb4d9db17537 1475 {
mbed_official 376:cb4d9db17537 1476 /* Set the key */
mbed_official 376:cb4d9db17537 1477 CRYP_SetKey(hcryp, hcryp->Init.pKey);
mbed_official 376:cb4d9db17537 1478
mbed_official 489:119543c9f674 1479 /* Set the CRYP peripheral in AES CTR mode */
mbed_official 489:119543c9f674 1480 __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CTR_ENCRYPT);
mbed_official 376:cb4d9db17537 1481
mbed_official 376:cb4d9db17537 1482 /* Set the Initialization Vector */
mbed_official 376:cb4d9db17537 1483 CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect);
mbed_official 489:119543c9f674 1484
mbed_official 489:119543c9f674 1485 /* Set the phase */
mbed_official 489:119543c9f674 1486 hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
mbed_official 376:cb4d9db17537 1487 }
mbed_official 376:cb4d9db17537 1488
mbed_official 376:cb4d9db17537 1489 /* Set the input and output addresses and start DMA transfer */
mbed_official 376:cb4d9db17537 1490 CRYP_SetDMAConfig(hcryp, inputaddr, Size, outputaddr);
mbed_official 376:cb4d9db17537 1491
mbed_official 376:cb4d9db17537 1492 /* Process Unlocked */
mbed_official 376:cb4d9db17537 1493 __HAL_UNLOCK(hcryp);
mbed_official 376:cb4d9db17537 1494
mbed_official 376:cb4d9db17537 1495 /* Return function status */
mbed_official 376:cb4d9db17537 1496 return HAL_OK;
mbed_official 376:cb4d9db17537 1497 }
mbed_official 376:cb4d9db17537 1498 else
mbed_official 376:cb4d9db17537 1499 {
mbed_official 489:119543c9f674 1500 /* Release Lock */
mbed_official 489:119543c9f674 1501 __HAL_UNLOCK(hcryp);
mbed_official 489:119543c9f674 1502
mbed_official 376:cb4d9db17537 1503 return HAL_ERROR;
mbed_official 376:cb4d9db17537 1504 }
mbed_official 376:cb4d9db17537 1505 }
mbed_official 376:cb4d9db17537 1506
mbed_official 376:cb4d9db17537 1507 /**
mbed_official 376:cb4d9db17537 1508 * @brief Initializes the CRYP peripheral in AES ECB decryption mode using DMA.
mbed_official 376:cb4d9db17537 1509 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1510 * the configuration information for CRYP module
mbed_official 489:119543c9f674 1511 * @param pCypherData: Pointer to the cyphertext buffer (aligned on u32)
mbed_official 376:cb4d9db17537 1512 * @param Size: Length of the plaintext buffer, must be a multiple of 16 bytes
mbed_official 489:119543c9f674 1513 * @param pPlainData: Pointer to the plaintext buffer (aligned on u32)
mbed_official 376:cb4d9db17537 1514 * @retval HAL status
mbed_official 376:cb4d9db17537 1515 */
mbed_official 376:cb4d9db17537 1516 HAL_StatusTypeDef HAL_CRYP_AESECB_Decrypt_DMA(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData)
mbed_official 376:cb4d9db17537 1517 {
mbed_official 489:119543c9f674 1518 uint32_t inputaddr = 0, outputaddr = 0;
mbed_official 376:cb4d9db17537 1519
mbed_official 489:119543c9f674 1520 /* Check that data aligned on u32 */
mbed_official 489:119543c9f674 1521 if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
mbed_official 376:cb4d9db17537 1522 {
mbed_official 376:cb4d9db17537 1523 /* Process Locked */
mbed_official 489:119543c9f674 1524 __HAL_UNLOCK(hcryp);
mbed_official 489:119543c9f674 1525
mbed_official 376:cb4d9db17537 1526 /* Return function status */
mbed_official 489:119543c9f674 1527 return HAL_ERROR;
mbed_official 376:cb4d9db17537 1528 }
mbed_official 376:cb4d9db17537 1529
mbed_official 489:119543c9f674 1530 /* Check if HAL_CRYP_Init has been called */
mbed_official 489:119543c9f674 1531 if ((hcryp->State != HAL_CRYP_STATE_RESET) && (hcryp->State == HAL_CRYP_STATE_READY))
mbed_official 376:cb4d9db17537 1532 {
mbed_official 376:cb4d9db17537 1533 /* Process Locked */
mbed_official 376:cb4d9db17537 1534 __HAL_LOCK(hcryp);
mbed_official 376:cb4d9db17537 1535
mbed_official 376:cb4d9db17537 1536 inputaddr = (uint32_t)pCypherData;
mbed_official 376:cb4d9db17537 1537 outputaddr = (uint32_t)pPlainData;
mbed_official 376:cb4d9db17537 1538
mbed_official 376:cb4d9db17537 1539 /* Change the CRYP state */
mbed_official 376:cb4d9db17537 1540 hcryp->State = HAL_CRYP_STATE_BUSY;
mbed_official 376:cb4d9db17537 1541
mbed_official 376:cb4d9db17537 1542 /* Check if initialization phase has already been performed */
mbed_official 376:cb4d9db17537 1543 if(hcryp->Phase == HAL_CRYP_PHASE_READY)
mbed_official 376:cb4d9db17537 1544 {
mbed_official 376:cb4d9db17537 1545 /* Set the key */
mbed_official 376:cb4d9db17537 1546 CRYP_SetKey(hcryp, hcryp->Init.pKey);
mbed_official 489:119543c9f674 1547
mbed_official 489:119543c9f674 1548 /* Reset the CHMOD & MODE bits */
mbed_official 489:119543c9f674 1549 CLEAR_BIT(hcryp->Instance->CR, CRYP_ALGO_CHAIN_MASK);
mbed_official 489:119543c9f674 1550
mbed_official 489:119543c9f674 1551 /* Set the CRYP peripheral in AES ECB decryption mode (with key derivation) */
mbed_official 489:119543c9f674 1552 __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_ECB_KEYDERDECRYPT);
mbed_official 489:119543c9f674 1553
mbed_official 376:cb4d9db17537 1554 /* Set the phase */
mbed_official 376:cb4d9db17537 1555 hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
mbed_official 376:cb4d9db17537 1556 }
mbed_official 376:cb4d9db17537 1557
mbed_official 376:cb4d9db17537 1558 /* Set the input and output addresses and start DMA transfer */
mbed_official 376:cb4d9db17537 1559 CRYP_SetDMAConfig(hcryp, inputaddr, Size, outputaddr);
mbed_official 376:cb4d9db17537 1560
mbed_official 376:cb4d9db17537 1561 /* Process Unlocked */
mbed_official 376:cb4d9db17537 1562 __HAL_UNLOCK(hcryp);
mbed_official 376:cb4d9db17537 1563
mbed_official 376:cb4d9db17537 1564 /* Return function status */
mbed_official 376:cb4d9db17537 1565 return HAL_OK;
mbed_official 376:cb4d9db17537 1566 }
mbed_official 376:cb4d9db17537 1567 else
mbed_official 376:cb4d9db17537 1568 {
mbed_official 489:119543c9f674 1569 /* Release Lock */
mbed_official 489:119543c9f674 1570 __HAL_UNLOCK(hcryp);
mbed_official 489:119543c9f674 1571
mbed_official 489:119543c9f674 1572 return HAL_ERROR;
mbed_official 489:119543c9f674 1573 }
mbed_official 489:119543c9f674 1574 }
mbed_official 489:119543c9f674 1575
mbed_official 489:119543c9f674 1576 /**
mbed_official 489:119543c9f674 1577 * @brief Initializes the CRYP peripheral in AES CBC encryption mode using DMA.
mbed_official 489:119543c9f674 1578 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 489:119543c9f674 1579 * the configuration information for CRYP module
mbed_official 489:119543c9f674 1580 * @param pCypherData: Pointer to the cyphertext buffer (aligned on u32)
mbed_official 489:119543c9f674 1581 * @param Size: Length of the plaintext buffer, must be a multiple of 16 bytes
mbed_official 489:119543c9f674 1582 * @param pPlainData: Pointer to the plaintext buffer (aligned on u32)
mbed_official 489:119543c9f674 1583 * @retval HAL status
mbed_official 489:119543c9f674 1584 */
mbed_official 489:119543c9f674 1585 HAL_StatusTypeDef HAL_CRYP_AESCBC_Decrypt_DMA(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData)
mbed_official 489:119543c9f674 1586 {
mbed_official 489:119543c9f674 1587 uint32_t inputaddr = 0, outputaddr = 0;
mbed_official 489:119543c9f674 1588
mbed_official 489:119543c9f674 1589 /* Check that data aligned on u32 */
mbed_official 489:119543c9f674 1590 if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
mbed_official 489:119543c9f674 1591 {
mbed_official 489:119543c9f674 1592 /* Process Locked */
mbed_official 489:119543c9f674 1593 __HAL_UNLOCK(hcryp);
mbed_official 489:119543c9f674 1594
mbed_official 489:119543c9f674 1595 /* Return function status */
mbed_official 489:119543c9f674 1596 return HAL_ERROR;
mbed_official 489:119543c9f674 1597 }
mbed_official 489:119543c9f674 1598
mbed_official 489:119543c9f674 1599 /* Check if HAL_CRYP_Init has been called */
mbed_official 489:119543c9f674 1600 if ((hcryp->State != HAL_CRYP_STATE_RESET) && (hcryp->State == HAL_CRYP_STATE_READY))
mbed_official 489:119543c9f674 1601 {
mbed_official 489:119543c9f674 1602 /* Process Locked */
mbed_official 489:119543c9f674 1603 __HAL_LOCK(hcryp);
mbed_official 489:119543c9f674 1604
mbed_official 489:119543c9f674 1605 inputaddr = (uint32_t)pCypherData;
mbed_official 489:119543c9f674 1606 outputaddr = (uint32_t)pPlainData;
mbed_official 489:119543c9f674 1607
mbed_official 489:119543c9f674 1608 /* Change the CRYP state */
mbed_official 489:119543c9f674 1609 hcryp->State = HAL_CRYP_STATE_BUSY;
mbed_official 489:119543c9f674 1610
mbed_official 489:119543c9f674 1611 /* Check if initialization phase has already been performed */
mbed_official 489:119543c9f674 1612 if(hcryp->Phase == HAL_CRYP_PHASE_READY)
mbed_official 489:119543c9f674 1613 {
mbed_official 489:119543c9f674 1614 /* Set the key */
mbed_official 489:119543c9f674 1615 CRYP_SetKey(hcryp, hcryp->Init.pKey);
mbed_official 489:119543c9f674 1616
mbed_official 489:119543c9f674 1617 /* Reset the CHMOD & MODE bits */
mbed_official 489:119543c9f674 1618 CLEAR_BIT(hcryp->Instance->CR, CRYP_ALGO_CHAIN_MASK);
mbed_official 489:119543c9f674 1619
mbed_official 489:119543c9f674 1620 /* Set the CRYP peripheral in AES CBC decryption mode (with key derivation) */
mbed_official 489:119543c9f674 1621 __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CBC_KEYDERDECRYPT);
mbed_official 489:119543c9f674 1622
mbed_official 489:119543c9f674 1623 /* Set the Initialization Vector */
mbed_official 489:119543c9f674 1624 CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect);
mbed_official 489:119543c9f674 1625
mbed_official 489:119543c9f674 1626 /* Set the phase */
mbed_official 489:119543c9f674 1627 hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
mbed_official 489:119543c9f674 1628 }
mbed_official 489:119543c9f674 1629
mbed_official 489:119543c9f674 1630 /* Set the input and output addresses and start DMA transfer */
mbed_official 489:119543c9f674 1631 CRYP_SetDMAConfig(hcryp, inputaddr, Size, outputaddr);
mbed_official 489:119543c9f674 1632
mbed_official 489:119543c9f674 1633 /* Process Unlocked */
mbed_official 489:119543c9f674 1634 __HAL_UNLOCK(hcryp);
mbed_official 489:119543c9f674 1635
mbed_official 489:119543c9f674 1636 /* Return function status */
mbed_official 489:119543c9f674 1637 return HAL_OK;
mbed_official 489:119543c9f674 1638 }
mbed_official 489:119543c9f674 1639 else
mbed_official 489:119543c9f674 1640 {
mbed_official 489:119543c9f674 1641 /* Release Lock */
mbed_official 489:119543c9f674 1642 __HAL_UNLOCK(hcryp);
mbed_official 489:119543c9f674 1643
mbed_official 376:cb4d9db17537 1644 return HAL_ERROR;
mbed_official 376:cb4d9db17537 1645 }
mbed_official 376:cb4d9db17537 1646 }
mbed_official 376:cb4d9db17537 1647
mbed_official 376:cb4d9db17537 1648 /**
mbed_official 376:cb4d9db17537 1649 * @brief Initializes the CRYP peripheral in AES CTR decryption mode using DMA.
mbed_official 376:cb4d9db17537 1650 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1651 * the configuration information for CRYP module
mbed_official 489:119543c9f674 1652 * @param pCypherData: Pointer to the cyphertext buffer (aligned on u32)
mbed_official 376:cb4d9db17537 1653 * @param Size: Length of the plaintext buffer, must be a multiple of 16
mbed_official 489:119543c9f674 1654 * @param pPlainData: Pointer to the plaintext buffer (aligned on u32)
mbed_official 376:cb4d9db17537 1655 * @retval HAL status
mbed_official 376:cb4d9db17537 1656 */
mbed_official 376:cb4d9db17537 1657 HAL_StatusTypeDef HAL_CRYP_AESCTR_Decrypt_DMA(CRYP_HandleTypeDef *hcryp, uint8_t *pCypherData, uint16_t Size, uint8_t *pPlainData)
mbed_official 376:cb4d9db17537 1658 {
mbed_official 489:119543c9f674 1659 uint32_t inputaddr = 0, outputaddr = 0;
mbed_official 376:cb4d9db17537 1660
mbed_official 489:119543c9f674 1661 /* Check that data aligned on u32 */
mbed_official 489:119543c9f674 1662 if((((uint32_t)pPlainData & (uint32_t)0x00000003) != 0) || (((uint32_t)pCypherData & (uint32_t)0x00000003) != 0) || ((Size & (uint16_t)0x000F) != 0))
mbed_official 489:119543c9f674 1663 {
mbed_official 489:119543c9f674 1664 /* Process Locked */
mbed_official 489:119543c9f674 1665 __HAL_UNLOCK(hcryp);
mbed_official 489:119543c9f674 1666
mbed_official 489:119543c9f674 1667 /* Return function status */
mbed_official 489:119543c9f674 1668 return HAL_ERROR;
mbed_official 489:119543c9f674 1669 }
mbed_official 489:119543c9f674 1670
mbed_official 489:119543c9f674 1671 /* Check if HAL_CRYP_Init has been called */
mbed_official 489:119543c9f674 1672 if ((hcryp->State != HAL_CRYP_STATE_RESET) && (hcryp->State == HAL_CRYP_STATE_READY))
mbed_official 376:cb4d9db17537 1673 {
mbed_official 376:cb4d9db17537 1674 /* Process Locked */
mbed_official 376:cb4d9db17537 1675 __HAL_LOCK(hcryp);
mbed_official 376:cb4d9db17537 1676
mbed_official 376:cb4d9db17537 1677 inputaddr = (uint32_t)pCypherData;
mbed_official 376:cb4d9db17537 1678 outputaddr = (uint32_t)pPlainData;
mbed_official 376:cb4d9db17537 1679
mbed_official 376:cb4d9db17537 1680 /* Change the CRYP state */
mbed_official 376:cb4d9db17537 1681 hcryp->State = HAL_CRYP_STATE_BUSY;
mbed_official 376:cb4d9db17537 1682
mbed_official 376:cb4d9db17537 1683 /* Check if initialization phase has already been performed */
mbed_official 376:cb4d9db17537 1684 if(hcryp->Phase == HAL_CRYP_PHASE_READY)
mbed_official 376:cb4d9db17537 1685 {
mbed_official 376:cb4d9db17537 1686 /* Set the key */
mbed_official 376:cb4d9db17537 1687 CRYP_SetKey(hcryp, hcryp->Init.pKey);
mbed_official 376:cb4d9db17537 1688
mbed_official 376:cb4d9db17537 1689 /* Set the CRYP peripheral in AES CTR mode */
mbed_official 489:119543c9f674 1690 __HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CTR_DECRYPT);
mbed_official 376:cb4d9db17537 1691
mbed_official 376:cb4d9db17537 1692 /* Set the Initialization Vector */
mbed_official 376:cb4d9db17537 1693 CRYP_SetInitVector(hcryp, hcryp->Init.pInitVect);
mbed_official 489:119543c9f674 1694
mbed_official 376:cb4d9db17537 1695 /* Set the phase */
mbed_official 376:cb4d9db17537 1696 hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
mbed_official 376:cb4d9db17537 1697 }
mbed_official 376:cb4d9db17537 1698
mbed_official 376:cb4d9db17537 1699 /* Set the input and output addresses and start DMA transfer */
mbed_official 376:cb4d9db17537 1700 CRYP_SetDMAConfig(hcryp, inputaddr, Size, outputaddr);
mbed_official 376:cb4d9db17537 1701
mbed_official 376:cb4d9db17537 1702 /* Process Unlocked */
mbed_official 376:cb4d9db17537 1703 __HAL_UNLOCK(hcryp);
mbed_official 376:cb4d9db17537 1704
mbed_official 376:cb4d9db17537 1705 /* Return function status */
mbed_official 376:cb4d9db17537 1706 return HAL_OK;
mbed_official 376:cb4d9db17537 1707 }
mbed_official 376:cb4d9db17537 1708 else
mbed_official 376:cb4d9db17537 1709 {
mbed_official 489:119543c9f674 1710 /* Release Lock */
mbed_official 489:119543c9f674 1711 __HAL_UNLOCK(hcryp);
mbed_official 489:119543c9f674 1712
mbed_official 376:cb4d9db17537 1713 return HAL_ERROR;
mbed_official 376:cb4d9db17537 1714 }
mbed_official 376:cb4d9db17537 1715 }
mbed_official 376:cb4d9db17537 1716
mbed_official 376:cb4d9db17537 1717 /**
mbed_official 376:cb4d9db17537 1718 * @}
mbed_official 376:cb4d9db17537 1719 */
mbed_official 376:cb4d9db17537 1720
mbed_official 489:119543c9f674 1721 /** @defgroup CRYP_Exported_Functions_Group3 DMA callback functions
mbed_official 376:cb4d9db17537 1722 * @brief DMA callback functions.
mbed_official 376:cb4d9db17537 1723 *
mbed_official 376:cb4d9db17537 1724 @verbatim
mbed_official 376:cb4d9db17537 1725 ==============================================================================
mbed_official 376:cb4d9db17537 1726 ##### DMA callback functions #####
mbed_official 376:cb4d9db17537 1727 ==============================================================================
mbed_official 376:cb4d9db17537 1728 [..] This section provides DMA callback functions:
mbed_official 376:cb4d9db17537 1729 (+) DMA Input data transfer complete
mbed_official 376:cb4d9db17537 1730 (+) DMA Output data transfer complete
mbed_official 376:cb4d9db17537 1731 (+) DMA error
mbed_official 376:cb4d9db17537 1732
mbed_official 376:cb4d9db17537 1733 @endverbatim
mbed_official 376:cb4d9db17537 1734 * @{
mbed_official 376:cb4d9db17537 1735 */
mbed_official 376:cb4d9db17537 1736
mbed_official 376:cb4d9db17537 1737 /**
mbed_official 489:119543c9f674 1738 * @brief CRYP error callback.
mbed_official 376:cb4d9db17537 1739 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1740 * the configuration information for CRYP module
mbed_official 376:cb4d9db17537 1741 * @retval None
mbed_official 376:cb4d9db17537 1742 */
mbed_official 376:cb4d9db17537 1743 __weak void HAL_CRYP_ErrorCallback(CRYP_HandleTypeDef *hcryp)
mbed_official 376:cb4d9db17537 1744 {
mbed_official 489:119543c9f674 1745 /* NOTE : This function should not be modified; when the callback is needed,
mbed_official 489:119543c9f674 1746 the HAL_CRYP_ErrorCallback can be implemented in the user file
mbed_official 376:cb4d9db17537 1747 */
mbed_official 376:cb4d9db17537 1748 }
mbed_official 376:cb4d9db17537 1749
mbed_official 376:cb4d9db17537 1750 /**
mbed_official 489:119543c9f674 1751 * @brief Input transfer completed callback.
mbed_official 376:cb4d9db17537 1752 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1753 * the configuration information for CRYP module
mbed_official 376:cb4d9db17537 1754 * @retval None
mbed_official 376:cb4d9db17537 1755 */
mbed_official 376:cb4d9db17537 1756 __weak void HAL_CRYP_InCpltCallback(CRYP_HandleTypeDef *hcryp)
mbed_official 376:cb4d9db17537 1757 {
mbed_official 489:119543c9f674 1758 /* NOTE : This function should not be modified; when the callback is needed,
mbed_official 489:119543c9f674 1759 the HAL_CRYP_InCpltCallback can be implemented in the user file
mbed_official 376:cb4d9db17537 1760 */
mbed_official 376:cb4d9db17537 1761 }
mbed_official 376:cb4d9db17537 1762
mbed_official 376:cb4d9db17537 1763 /**
mbed_official 489:119543c9f674 1764 * @brief Output transfer completed callback.
mbed_official 376:cb4d9db17537 1765 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1766 * the configuration information for CRYP module
mbed_official 376:cb4d9db17537 1767 * @retval None
mbed_official 376:cb4d9db17537 1768 */
mbed_official 376:cb4d9db17537 1769 __weak void HAL_CRYP_OutCpltCallback(CRYP_HandleTypeDef *hcryp)
mbed_official 376:cb4d9db17537 1770 {
mbed_official 489:119543c9f674 1771 /* NOTE : This function should not be modified; when the callback is needed,
mbed_official 489:119543c9f674 1772 the HAL_CRYP_OutCpltCallback can be implemented in the user file
mbed_official 376:cb4d9db17537 1773 */
mbed_official 376:cb4d9db17537 1774 }
mbed_official 376:cb4d9db17537 1775
mbed_official 376:cb4d9db17537 1776 /**
mbed_official 376:cb4d9db17537 1777 * @}
mbed_official 376:cb4d9db17537 1778 */
mbed_official 376:cb4d9db17537 1779
mbed_official 489:119543c9f674 1780 /** @defgroup CRYP_Exported_Functions_Group4 CRYP IRQ handler
mbed_official 376:cb4d9db17537 1781 * @brief CRYP IRQ handler.
mbed_official 376:cb4d9db17537 1782 *
mbed_official 376:cb4d9db17537 1783 @verbatim
mbed_official 376:cb4d9db17537 1784 ==============================================================================
mbed_official 376:cb4d9db17537 1785 ##### CRYP IRQ handler management #####
mbed_official 376:cb4d9db17537 1786 ==============================================================================
mbed_official 376:cb4d9db17537 1787 [..] This section provides CRYP IRQ handler function.
mbed_official 376:cb4d9db17537 1788
mbed_official 376:cb4d9db17537 1789 @endverbatim
mbed_official 376:cb4d9db17537 1790 * @{
mbed_official 376:cb4d9db17537 1791 */
mbed_official 376:cb4d9db17537 1792
mbed_official 376:cb4d9db17537 1793 /**
mbed_official 376:cb4d9db17537 1794 * @brief This function handles CRYP interrupt request.
mbed_official 376:cb4d9db17537 1795 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1796 * the configuration information for CRYP module
mbed_official 376:cb4d9db17537 1797 * @retval None
mbed_official 376:cb4d9db17537 1798 */
mbed_official 376:cb4d9db17537 1799 void HAL_CRYP_IRQHandler(CRYP_HandleTypeDef *hcryp)
mbed_official 376:cb4d9db17537 1800 {
mbed_official 489:119543c9f674 1801 /* Check if error occurred*/
mbed_official 489:119543c9f674 1802 if (__HAL_CRYP_GET_IT_SOURCE(hcryp, CRYP_IT_ERR) != RESET)
mbed_official 376:cb4d9db17537 1803 {
mbed_official 489:119543c9f674 1804 if (__HAL_CRYP_GET_FLAG(hcryp,CRYP_FLAG_RDERR) != RESET)
mbed_official 489:119543c9f674 1805 {
mbed_official 489:119543c9f674 1806 __HAL_CRYP_CLEAR_FLAG(hcryp, CRYP_CLEARFLAG_RDERR);
mbed_official 489:119543c9f674 1807 }
mbed_official 376:cb4d9db17537 1808
mbed_official 489:119543c9f674 1809 if (__HAL_CRYP_GET_FLAG(hcryp,CRYP_FLAG_WRERR) != RESET)
mbed_official 489:119543c9f674 1810 {
mbed_official 489:119543c9f674 1811 __HAL_CRYP_CLEAR_FLAG(hcryp, CRYP_CLEARFLAG_WRERR);
mbed_official 489:119543c9f674 1812 }
mbed_official 376:cb4d9db17537 1813
mbed_official 489:119543c9f674 1814 if (__HAL_CRYP_GET_FLAG(hcryp,CRYP_FLAG_CCF) != RESET)
mbed_official 489:119543c9f674 1815 {
mbed_official 489:119543c9f674 1816 __HAL_CRYP_CLEAR_FLAG(hcryp,CRYP_CLEARFLAG_CCF);
mbed_official 489:119543c9f674 1817 }
mbed_official 376:cb4d9db17537 1818
mbed_official 489:119543c9f674 1819 hcryp->State= HAL_CRYP_STATE_ERROR;
mbed_official 489:119543c9f674 1820 /* Disable Computation Complete Interrupt */
mbed_official 489:119543c9f674 1821 __HAL_CRYP_DISABLE_IT(hcryp,CRYP_IT_CC);
mbed_official 489:119543c9f674 1822 __HAL_CRYP_DISABLE_IT(hcryp,CRYP_IT_ERR);
mbed_official 489:119543c9f674 1823
mbed_official 489:119543c9f674 1824 HAL_CRYP_ErrorCallback(hcryp);
mbed_official 489:119543c9f674 1825
mbed_official 489:119543c9f674 1826 /* Process Unlocked */
mbed_official 489:119543c9f674 1827 __HAL_UNLOCK(hcryp);
mbed_official 376:cb4d9db17537 1828
mbed_official 489:119543c9f674 1829 return;
mbed_official 489:119543c9f674 1830 }
mbed_official 489:119543c9f674 1831
mbed_official 489:119543c9f674 1832 /* Check if computation complete interrupt was enabled*/
mbed_official 489:119543c9f674 1833 if (__HAL_CRYP_GET_IT_SOURCE(hcryp, CRYP_IT_CC) != RESET)
mbed_official 489:119543c9f674 1834 {
mbed_official 489:119543c9f674 1835 /* Clear CCF Flag */
mbed_official 489:119543c9f674 1836 __HAL_CRYP_CLEAR_FLAG(hcryp, CRYP_CLEARFLAG_CCF);
mbed_official 489:119543c9f674 1837
mbed_official 489:119543c9f674 1838 CRYP_EncryptDecrypt_IT(hcryp);
mbed_official 376:cb4d9db17537 1839 }
mbed_official 376:cb4d9db17537 1840 }
mbed_official 376:cb4d9db17537 1841
mbed_official 376:cb4d9db17537 1842 /**
mbed_official 376:cb4d9db17537 1843 * @}
mbed_official 376:cb4d9db17537 1844 */
mbed_official 376:cb4d9db17537 1845
mbed_official 489:119543c9f674 1846 /** @defgroup CRYP_Exported_Functions_Group5 Peripheral State functions
mbed_official 376:cb4d9db17537 1847 * @brief Peripheral State functions.
mbed_official 376:cb4d9db17537 1848 *
mbed_official 376:cb4d9db17537 1849 @verbatim
mbed_official 376:cb4d9db17537 1850 ==============================================================================
mbed_official 376:cb4d9db17537 1851 ##### Peripheral State functions #####
mbed_official 376:cb4d9db17537 1852 ==============================================================================
mbed_official 376:cb4d9db17537 1853 [..]
mbed_official 376:cb4d9db17537 1854 This subsection permits to get in run-time the status of the peripheral.
mbed_official 376:cb4d9db17537 1855
mbed_official 376:cb4d9db17537 1856 @endverbatim
mbed_official 376:cb4d9db17537 1857 * @{
mbed_official 376:cb4d9db17537 1858 */
mbed_official 376:cb4d9db17537 1859
mbed_official 376:cb4d9db17537 1860 /**
mbed_official 376:cb4d9db17537 1861 * @brief Returns the CRYP state.
mbed_official 376:cb4d9db17537 1862 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1863 * the configuration information for CRYP module
mbed_official 376:cb4d9db17537 1864 * @retval HAL state
mbed_official 376:cb4d9db17537 1865 */
mbed_official 376:cb4d9db17537 1866 HAL_CRYP_STATETypeDef HAL_CRYP_GetState(CRYP_HandleTypeDef *hcryp)
mbed_official 376:cb4d9db17537 1867 {
mbed_official 376:cb4d9db17537 1868 return hcryp->State;
mbed_official 376:cb4d9db17537 1869 }
mbed_official 376:cb4d9db17537 1870
mbed_official 376:cb4d9db17537 1871 /**
mbed_official 376:cb4d9db17537 1872 * @}
mbed_official 376:cb4d9db17537 1873 */
mbed_official 376:cb4d9db17537 1874
mbed_official 376:cb4d9db17537 1875 /**
mbed_official 489:119543c9f674 1876 * @}
mbed_official 489:119543c9f674 1877 */
mbed_official 489:119543c9f674 1878
mbed_official 489:119543c9f674 1879 /** @addtogroup CRYP_Private_Functions
mbed_official 489:119543c9f674 1880 * @{
mbed_official 489:119543c9f674 1881 */
mbed_official 489:119543c9f674 1882
mbed_official 489:119543c9f674 1883 /**
mbed_official 489:119543c9f674 1884 * @brief IT function called under interruption context to continue encryption or decryption
mbed_official 489:119543c9f674 1885 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 489:119543c9f674 1886 * the configuration information for CRYP module
mbed_official 489:119543c9f674 1887 * @retval HAL status
mbed_official 489:119543c9f674 1888 */
mbed_official 489:119543c9f674 1889 static HAL_StatusTypeDef CRYP_EncryptDecrypt_IT(CRYP_HandleTypeDef *hcryp)
mbed_official 489:119543c9f674 1890 {
mbed_official 489:119543c9f674 1891 uint32_t inputaddr = 0, outputaddr = 0;
mbed_official 489:119543c9f674 1892
mbed_official 489:119543c9f674 1893 /* Get the last Output data adress */
mbed_official 489:119543c9f674 1894 outputaddr = (uint32_t)hcryp->pCrypOutBuffPtr;
mbed_official 489:119543c9f674 1895
mbed_official 489:119543c9f674 1896 /* Read the Output block from the Output Register */
mbed_official 489:119543c9f674 1897 *(uint32_t*)(outputaddr) = hcryp->Instance->DOUTR;
mbed_official 489:119543c9f674 1898 outputaddr+=4;
mbed_official 489:119543c9f674 1899 *(uint32_t*)(outputaddr) = hcryp->Instance->DOUTR;
mbed_official 489:119543c9f674 1900 outputaddr+=4;
mbed_official 489:119543c9f674 1901 *(uint32_t*)(outputaddr) = hcryp->Instance->DOUTR;
mbed_official 489:119543c9f674 1902 outputaddr+=4;
mbed_official 489:119543c9f674 1903 *(uint32_t*)(outputaddr) = hcryp->Instance->DOUTR;
mbed_official 489:119543c9f674 1904
mbed_official 489:119543c9f674 1905 hcryp->pCrypOutBuffPtr += 16;
mbed_official 489:119543c9f674 1906 hcryp->CrypOutCount -= 16;
mbed_official 489:119543c9f674 1907
mbed_official 489:119543c9f674 1908 /* Check if all input text is encrypted or decrypted */
mbed_official 489:119543c9f674 1909 if(hcryp->CrypOutCount == 0)
mbed_official 489:119543c9f674 1910 {
mbed_official 489:119543c9f674 1911 /* Disable Computation Complete Interrupt */
mbed_official 489:119543c9f674 1912 __HAL_CRYP_DISABLE_IT(hcryp,CRYP_IT_CC);
mbed_official 489:119543c9f674 1913 __HAL_CRYP_DISABLE_IT(hcryp,CRYP_IT_ERR);
mbed_official 489:119543c9f674 1914
mbed_official 489:119543c9f674 1915 /* Process Unlocked */
mbed_official 489:119543c9f674 1916 __HAL_UNLOCK(hcryp);
mbed_official 489:119543c9f674 1917
mbed_official 489:119543c9f674 1918 /* Change the CRYP state */
mbed_official 489:119543c9f674 1919 hcryp->State = HAL_CRYP_STATE_READY;
mbed_official 489:119543c9f674 1920
mbed_official 489:119543c9f674 1921 /* Call computation complete callback */
mbed_official 489:119543c9f674 1922 HAL_CRYPEx_ComputationCpltCallback(hcryp);
mbed_official 489:119543c9f674 1923 }
mbed_official 489:119543c9f674 1924 else /* Process the rest of input text */
mbed_official 489:119543c9f674 1925 {
mbed_official 489:119543c9f674 1926 /* Get the last Intput data adress */
mbed_official 489:119543c9f674 1927 inputaddr = (uint32_t)hcryp->pCrypInBuffPtr;
mbed_official 489:119543c9f674 1928
mbed_official 489:119543c9f674 1929 /* Write the Input block in the Data Input register */
mbed_official 489:119543c9f674 1930 hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
mbed_official 489:119543c9f674 1931 inputaddr+=4;
mbed_official 489:119543c9f674 1932 hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
mbed_official 489:119543c9f674 1933 inputaddr+=4;
mbed_official 489:119543c9f674 1934 hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
mbed_official 489:119543c9f674 1935 inputaddr+=4;
mbed_official 489:119543c9f674 1936 hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
mbed_official 489:119543c9f674 1937 hcryp->pCrypInBuffPtr += 16;
mbed_official 489:119543c9f674 1938 hcryp->CrypInCount -= 16;
mbed_official 489:119543c9f674 1939 }
mbed_official 489:119543c9f674 1940 return HAL_OK;
mbed_official 489:119543c9f674 1941 }
mbed_official 489:119543c9f674 1942 /**
mbed_official 376:cb4d9db17537 1943 * @brief DMA CRYP Input Data process complete callback.
mbed_official 376:cb4d9db17537 1944 * @param hdma: DMA handle
mbed_official 376:cb4d9db17537 1945 * @retval None
mbed_official 376:cb4d9db17537 1946 */
mbed_official 376:cb4d9db17537 1947 static void CRYP_DMAInCplt(DMA_HandleTypeDef *hdma)
mbed_official 376:cb4d9db17537 1948 {
mbed_official 376:cb4d9db17537 1949 CRYP_HandleTypeDef* hcryp = (CRYP_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
mbed_official 376:cb4d9db17537 1950
mbed_official 376:cb4d9db17537 1951 /* Disable the DMA transfer for input request */
mbed_official 489:119543c9f674 1952 CLEAR_BIT(hcryp->Instance->CR, AES_CR_DMAINEN);
mbed_official 376:cb4d9db17537 1953
mbed_official 376:cb4d9db17537 1954 /* Call input data transfer complete callback */
mbed_official 376:cb4d9db17537 1955 HAL_CRYP_InCpltCallback(hcryp);
mbed_official 376:cb4d9db17537 1956 }
mbed_official 376:cb4d9db17537 1957
mbed_official 376:cb4d9db17537 1958 /**
mbed_official 376:cb4d9db17537 1959 * @brief DMA CRYP Output Data process complete callback.
mbed_official 376:cb4d9db17537 1960 * @param hdma: DMA handle
mbed_official 376:cb4d9db17537 1961 * @retval None
mbed_official 376:cb4d9db17537 1962 */
mbed_official 376:cb4d9db17537 1963 static void CRYP_DMAOutCplt(DMA_HandleTypeDef *hdma)
mbed_official 376:cb4d9db17537 1964 {
mbed_official 376:cb4d9db17537 1965 CRYP_HandleTypeDef* hcryp = (CRYP_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
mbed_official 376:cb4d9db17537 1966
mbed_official 489:119543c9f674 1967 /* Disable the DMA transfer for output request by resetting the DMAOUTEN bit
mbed_official 376:cb4d9db17537 1968 in the DMACR register */
mbed_official 489:119543c9f674 1969 CLEAR_BIT(hcryp->Instance->CR, AES_CR_DMAOUTEN);
mbed_official 489:119543c9f674 1970
mbed_official 489:119543c9f674 1971 /* Clear CCF Flag */
mbed_official 489:119543c9f674 1972 __HAL_CRYP_CLEAR_FLAG(hcryp, CRYP_CLEARFLAG_CCF);
mbed_official 489:119543c9f674 1973
mbed_official 376:cb4d9db17537 1974 /* Disable CRYP */
mbed_official 489:119543c9f674 1975 __HAL_CRYP_DISABLE(hcryp);
mbed_official 376:cb4d9db17537 1976
mbed_official 376:cb4d9db17537 1977 /* Change the CRYP state to ready */
mbed_official 376:cb4d9db17537 1978 hcryp->State = HAL_CRYP_STATE_READY;
mbed_official 376:cb4d9db17537 1979
mbed_official 376:cb4d9db17537 1980 /* Call output data transfer complete callback */
mbed_official 376:cb4d9db17537 1981 HAL_CRYP_OutCpltCallback(hcryp);
mbed_official 376:cb4d9db17537 1982 }
mbed_official 376:cb4d9db17537 1983
mbed_official 376:cb4d9db17537 1984 /**
mbed_official 376:cb4d9db17537 1985 * @brief DMA CRYP communication error callback.
mbed_official 376:cb4d9db17537 1986 * @param hdma: DMA handle
mbed_official 376:cb4d9db17537 1987 * @retval None
mbed_official 376:cb4d9db17537 1988 */
mbed_official 376:cb4d9db17537 1989 static void CRYP_DMAError(DMA_HandleTypeDef *hdma)
mbed_official 376:cb4d9db17537 1990 {
mbed_official 376:cb4d9db17537 1991 CRYP_HandleTypeDef* hcryp = (CRYP_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
mbed_official 489:119543c9f674 1992 hcryp->State= HAL_CRYP_STATE_ERROR;
mbed_official 376:cb4d9db17537 1993 HAL_CRYP_ErrorCallback(hcryp);
mbed_official 376:cb4d9db17537 1994 }
mbed_official 376:cb4d9db17537 1995
mbed_official 376:cb4d9db17537 1996 /**
mbed_official 376:cb4d9db17537 1997 * @brief Writes the Key in Key registers.
mbed_official 376:cb4d9db17537 1998 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1999 * the configuration information for CRYP module
mbed_official 376:cb4d9db17537 2000 * @param Key: Pointer to Key buffer
mbed_official 489:119543c9f674 2001 * @note Key must be written as little endian.
mbed_official 489:119543c9f674 2002 * If Key pointer points at address n,
mbed_official 489:119543c9f674 2003 * n[15:0] contains key[96:127],
mbed_official 489:119543c9f674 2004 * (n+4)[15:0] contains key[64:95],
mbed_official 489:119543c9f674 2005 * (n+8)[15:0] contains key[32:63] and
mbed_official 489:119543c9f674 2006 * (n+12)[15:0] contains key[0:31]
mbed_official 376:cb4d9db17537 2007 * @retval None
mbed_official 376:cb4d9db17537 2008 */
mbed_official 376:cb4d9db17537 2009 static void CRYP_SetKey(CRYP_HandleTypeDef *hcryp, uint8_t *Key)
mbed_official 489:119543c9f674 2010 {
mbed_official 376:cb4d9db17537 2011 uint32_t keyaddr = (uint32_t)Key;
mbed_official 376:cb4d9db17537 2012
mbed_official 489:119543c9f674 2013 hcryp->Instance->KEYR3 = __REV(*(uint32_t*)(keyaddr));
mbed_official 376:cb4d9db17537 2014 keyaddr+=4;
mbed_official 489:119543c9f674 2015 hcryp->Instance->KEYR2 = __REV(*(uint32_t*)(keyaddr));
mbed_official 376:cb4d9db17537 2016 keyaddr+=4;
mbed_official 489:119543c9f674 2017 hcryp->Instance->KEYR1 = __REV(*(uint32_t*)(keyaddr));
mbed_official 376:cb4d9db17537 2018 keyaddr+=4;
mbed_official 489:119543c9f674 2019 hcryp->Instance->KEYR0 = __REV(*(uint32_t*)(keyaddr));
mbed_official 376:cb4d9db17537 2020 }
mbed_official 376:cb4d9db17537 2021
mbed_official 376:cb4d9db17537 2022 /**
mbed_official 376:cb4d9db17537 2023 * @brief Writes the InitVector/InitCounter in IV registers.
mbed_official 376:cb4d9db17537 2024 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 2025 * the configuration information for CRYP module
mbed_official 376:cb4d9db17537 2026 * @param InitVector: Pointer to InitVector/InitCounter buffer
mbed_official 489:119543c9f674 2027 * @note Init Vector must be written as little endian.
mbed_official 489:119543c9f674 2028 * If Init Vector pointer points at address n,
mbed_official 489:119543c9f674 2029 * n[15:0] contains Vector[96:127],
mbed_official 489:119543c9f674 2030 * (n+4)[15:0] contains Vector[64:95],
mbed_official 489:119543c9f674 2031 * (n+8)[15:0] contains Vector[32:63] and
mbed_official 489:119543c9f674 2032 * (n+12)[15:0] contains Vector[0:31]
mbed_official 376:cb4d9db17537 2033 * @retval None
mbed_official 376:cb4d9db17537 2034 */
mbed_official 376:cb4d9db17537 2035 static void CRYP_SetInitVector(CRYP_HandleTypeDef *hcryp, uint8_t *InitVector)
mbed_official 376:cb4d9db17537 2036 {
mbed_official 376:cb4d9db17537 2037 uint32_t ivaddr = (uint32_t)InitVector;
mbed_official 376:cb4d9db17537 2038
mbed_official 489:119543c9f674 2039 hcryp->Instance->IVR3 = __REV(*(uint32_t*)(ivaddr));
mbed_official 376:cb4d9db17537 2040 ivaddr+=4;
mbed_official 489:119543c9f674 2041 hcryp->Instance->IVR2 = __REV(*(uint32_t*)(ivaddr));
mbed_official 376:cb4d9db17537 2042 ivaddr+=4;
mbed_official 489:119543c9f674 2043 hcryp->Instance->IVR1 = __REV(*(uint32_t*)(ivaddr));
mbed_official 376:cb4d9db17537 2044 ivaddr+=4;
mbed_official 489:119543c9f674 2045 hcryp->Instance->IVR0 = __REV(*(uint32_t*)(ivaddr));
mbed_official 376:cb4d9db17537 2046 }
mbed_official 376:cb4d9db17537 2047
mbed_official 376:cb4d9db17537 2048 /**
mbed_official 489:119543c9f674 2049 * @brief Process Data: Writes Input data in polling mode and reads the output data
mbed_official 376:cb4d9db17537 2050 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 2051 * the configuration information for CRYP module
mbed_official 376:cb4d9db17537 2052 * @param Input: Pointer to the Input buffer
mbed_official 376:cb4d9db17537 2053 * @param Ilength: Length of the Input buffer, must be a multiple of 16.
mbed_official 376:cb4d9db17537 2054 * @param Output: Pointer to the returned buffer
mbed_official 489:119543c9f674 2055 * @param Timeout: Specify Timeout value
mbed_official 376:cb4d9db17537 2056 * @retval None
mbed_official 376:cb4d9db17537 2057 */
mbed_official 376:cb4d9db17537 2058 static HAL_StatusTypeDef CRYP_ProcessData(CRYP_HandleTypeDef *hcryp, uint8_t* Input, uint16_t Ilength, uint8_t* Output, uint32_t Timeout)
mbed_official 376:cb4d9db17537 2059 {
mbed_official 376:cb4d9db17537 2060 uint32_t tickstart = 0;
mbed_official 376:cb4d9db17537 2061
mbed_official 489:119543c9f674 2062 uint32_t index = 0;
mbed_official 376:cb4d9db17537 2063 uint32_t inputaddr = (uint32_t)Input;
mbed_official 376:cb4d9db17537 2064 uint32_t outputaddr = (uint32_t)Output;
mbed_official 376:cb4d9db17537 2065
mbed_official 489:119543c9f674 2066 for(index=0; (index < Ilength); index += 16)
mbed_official 376:cb4d9db17537 2067 {
mbed_official 376:cb4d9db17537 2068 /* Write the Input block in the Data Input register */
mbed_official 489:119543c9f674 2069 hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
mbed_official 376:cb4d9db17537 2070 inputaddr+=4;
mbed_official 489:119543c9f674 2071 hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
mbed_official 376:cb4d9db17537 2072 inputaddr+=4;
mbed_official 489:119543c9f674 2073 hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
mbed_official 376:cb4d9db17537 2074 inputaddr+=4;
mbed_official 489:119543c9f674 2075 hcryp->Instance->DINR = *(uint32_t*)(inputaddr);
mbed_official 376:cb4d9db17537 2076 inputaddr+=4;
mbed_official 376:cb4d9db17537 2077
mbed_official 376:cb4d9db17537 2078 /* Get timeout */
mbed_official 376:cb4d9db17537 2079 tickstart = HAL_GetTick();
mbed_official 489:119543c9f674 2080
mbed_official 489:119543c9f674 2081 while(HAL_IS_BIT_CLR(hcryp->Instance->SR, AES_SR_CCF))
mbed_official 376:cb4d9db17537 2082 {
mbed_official 376:cb4d9db17537 2083 /* Check for the Timeout */
mbed_official 376:cb4d9db17537 2084 if(Timeout != HAL_MAX_DELAY)
mbed_official 376:cb4d9db17537 2085 {
mbed_official 376:cb4d9db17537 2086 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 376:cb4d9db17537 2087 {
mbed_official 376:cb4d9db17537 2088 /* Change state */
mbed_official 376:cb4d9db17537 2089 hcryp->State = HAL_CRYP_STATE_TIMEOUT;
mbed_official 376:cb4d9db17537 2090
mbed_official 376:cb4d9db17537 2091 /* Process Unlocked */
mbed_official 376:cb4d9db17537 2092 __HAL_UNLOCK(hcryp);
mbed_official 376:cb4d9db17537 2093
mbed_official 376:cb4d9db17537 2094 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 2095 }
mbed_official 376:cb4d9db17537 2096 }
mbed_official 376:cb4d9db17537 2097 }
mbed_official 376:cb4d9db17537 2098 /* Clear CCF Flag */
mbed_official 489:119543c9f674 2099 __HAL_CRYP_CLEAR_FLAG(hcryp, CRYP_CLEARFLAG_CCF);
mbed_official 376:cb4d9db17537 2100
mbed_official 376:cb4d9db17537 2101 /* Read the Output block from the Data Output Register */
mbed_official 489:119543c9f674 2102 *(uint32_t*)(outputaddr) = hcryp->Instance->DOUTR;
mbed_official 376:cb4d9db17537 2103 outputaddr+=4;
mbed_official 489:119543c9f674 2104 *(uint32_t*)(outputaddr) = hcryp->Instance->DOUTR;
mbed_official 376:cb4d9db17537 2105 outputaddr+=4;
mbed_official 489:119543c9f674 2106 *(uint32_t*)(outputaddr) = hcryp->Instance->DOUTR;
mbed_official 376:cb4d9db17537 2107 outputaddr+=4;
mbed_official 489:119543c9f674 2108 *(uint32_t*)(outputaddr) = hcryp->Instance->DOUTR;
mbed_official 376:cb4d9db17537 2109 outputaddr+=4;
mbed_official 376:cb4d9db17537 2110 }
mbed_official 376:cb4d9db17537 2111 /* Return function status */
mbed_official 376:cb4d9db17537 2112 return HAL_OK;
mbed_official 376:cb4d9db17537 2113 }
mbed_official 376:cb4d9db17537 2114
mbed_official 376:cb4d9db17537 2115 /**
mbed_official 376:cb4d9db17537 2116 * @brief Set the DMA configuration and start the DMA transfer
mbed_official 376:cb4d9db17537 2117 * @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 2118 * the configuration information for CRYP module
mbed_official 376:cb4d9db17537 2119 * @param inputaddr: address of the Input buffer
mbed_official 376:cb4d9db17537 2120 * @param Size: Size of the Input buffer, must be a multiple of 16.
mbed_official 376:cb4d9db17537 2121 * @param outputaddr: address of the Output buffer
mbed_official 376:cb4d9db17537 2122 * @retval None
mbed_official 376:cb4d9db17537 2123 */
mbed_official 376:cb4d9db17537 2124 static void CRYP_SetDMAConfig(CRYP_HandleTypeDef *hcryp, uint32_t inputaddr, uint16_t Size, uint32_t outputaddr)
mbed_official 376:cb4d9db17537 2125 {
mbed_official 376:cb4d9db17537 2126 /* Set the CRYP DMA transfer complete callback */
mbed_official 376:cb4d9db17537 2127 hcryp->hdmain->XferCpltCallback = CRYP_DMAInCplt;
mbed_official 376:cb4d9db17537 2128 /* Set the DMA error callback */
mbed_official 376:cb4d9db17537 2129 hcryp->hdmain->XferErrorCallback = CRYP_DMAError;
mbed_official 376:cb4d9db17537 2130
mbed_official 376:cb4d9db17537 2131 /* Set the CRYP DMA transfer complete callback */
mbed_official 376:cb4d9db17537 2132 hcryp->hdmaout->XferCpltCallback = CRYP_DMAOutCplt;
mbed_official 376:cb4d9db17537 2133 /* Set the DMA error callback */
mbed_official 376:cb4d9db17537 2134 hcryp->hdmaout->XferErrorCallback = CRYP_DMAError;
mbed_official 489:119543c9f674 2135
mbed_official 376:cb4d9db17537 2136 /* Enable the DMA In DMA Stream */
mbed_official 489:119543c9f674 2137 HAL_DMA_Start_IT(hcryp->hdmain, inputaddr, (uint32_t)&hcryp->Instance->DINR, Size/4);
mbed_official 489:119543c9f674 2138
mbed_official 376:cb4d9db17537 2139 /* Enable the DMA Out DMA Stream */
mbed_official 489:119543c9f674 2140 HAL_DMA_Start_IT(hcryp->hdmaout, (uint32_t)&hcryp->Instance->DOUTR, outputaddr, Size/4);
mbed_official 489:119543c9f674 2141
mbed_official 376:cb4d9db17537 2142 /* Enable In and Out DMA requests */
mbed_official 489:119543c9f674 2143 SET_BIT(hcryp->Instance->CR, (AES_CR_DMAINEN | AES_CR_DMAOUTEN));
mbed_official 489:119543c9f674 2144
mbed_official 376:cb4d9db17537 2145 /* Enable CRYP */
mbed_official 489:119543c9f674 2146 __HAL_CRYP_ENABLE(hcryp);
mbed_official 376:cb4d9db17537 2147 }
mbed_official 376:cb4d9db17537 2148
mbed_official 376:cb4d9db17537 2149 /**
mbed_official 376:cb4d9db17537 2150 * @}
mbed_official 376:cb4d9db17537 2151 */
mbed_official 376:cb4d9db17537 2152
mbed_official 376:cb4d9db17537 2153 /**
mbed_official 376:cb4d9db17537 2154 * @}
mbed_official 376:cb4d9db17537 2155 */
mbed_official 376:cb4d9db17537 2156
mbed_official 489:119543c9f674 2157 /**
mbed_official 489:119543c9f674 2158 * @}
mbed_official 489:119543c9f674 2159 */
mbed_official 489:119543c9f674 2160
mbed_official 489:119543c9f674 2161 #endif /* HAL_CRYP_MODULE_ENABLED */
mbed_official 489:119543c9f674 2162 #endif /* STM32L041xx || STM32L061xx || STM32L062xx || STM32L063xx || STM32L081xx || STM32L082xx || STM32L083xx */
mbed_official 376:cb4d9db17537 2163 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
mbed_official 489:119543c9f674 2164