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@369:2e96f1b71984, 2014-10-27 (annotated)

Committer:
mbed_official
Date:
Mon Oct 27 09:45:07 2014 +0000
Revision:
369:2e96f1b71984
Parent:
226:b062af740e40 
Synchronized with git revision 2d1f64de28cfb25c0e602532e3ce5ad1d9accbed



Full URL: https://github.com/mbedmicro/mbed/commit/2d1f64de28cfb25c0e602532e3ce5ad1d9accbed/



CMSIS: NUCLEO_F401RE - Update STM32Cube driver

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