mbed official / mbed-src

mbed library sources

Dependents:   Encrypted my_mbed lklk CyaSSL_DTLS_Cellular ... more

Superseded

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

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

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

Import librarymbed

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

Last commit 20 Feb 2019 by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32L0/stm32l0xx_hal_cryp.c@387:643a59b3dbac, 2014-11-05 (annotated)

Committer:
mbed_official
Date:
Wed Nov 05 14:30:08 2014 +0000
Revision:
387:643a59b3dbac
Parent:
382:ee426a420dbb
Child:
489:119543c9f674
Synchronized with git revision cfeccf154f8f92c3ea9c0c881c577c154537aecc



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



Exporters: STM32L053R8 - IAR exporter

Who changed what in which revision?

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