gabriel della-monica / mbed-src

mbed library sources

Fork of mbed-src by mbed official

targets/cmsis/TARGET_STM/TARGET_NUCLEO_L152RE/stm32l1xx_hal_cryp.c@354:e67efb2aab0e, 2014-10-16 (annotated)

Committer:
mbed_official
Date:
Thu Oct 16 15:00:10 2014 +0100
Revision:
354:e67efb2aab0e
Synchronized with git revision 36a8882a54cbf25645fa6e11af937c8b8048e184



Full URL: https://github.com/mbedmicro/mbed/commit/36a8882a54cbf25645fa6e11af937c8b8048e184/



Targets: NUCLEO_L152RE - Migration to STM32Cube driver (CMSIS and HAL)

Who changed what in which revision?

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