shao ziyang / mbed-src-kl05

mbed library sources

Dependents:   frdm_kl05z_gpio_test

Fork of mbed-src by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32F407VG/stm32f4xx_hal_cryp.c@323:9e901b0a5aa1, 2014-09-13 (annotated)

Committer:
shaoziyang
Date:
Sat Sep 13 14:25:46 2014 +0000
Revision:
323:9e901b0a5aa1
Parent:
296:ec1b66a3d094 
test with CLOCK_SETUP = 0

Who changed what in which revision?

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