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_NUCLEO_F401RE/stm32f4xx_hal_cryp.c@106:ced8cbb51063, 2014-02-26 (annotated)

Committer:
mbed_official
Date:
Wed Feb 26 09:45:12 2014 +0000
Revision:
106:ced8cbb51063
Parent:
87:085cde657901
Child:
226:b062af740e40
Synchronized with git revision 4222735eff5868389433f0e9271976b39c8115cd



Full URL: https://github.com/mbedmicro/mbed/commit/4222735eff5868389433f0e9271976b39c8115cd/



[NUCLEO_xxx] Update STM32CubeF4 driver V1.0.0 + update license

Who changed what in which revision?

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