mbed official / mbed-src

mbed library sources

Dependents:   Encrypted my_mbed lklk CyaSSL_DTLS_Cellular ... more

Superseded

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

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

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

Import librarymbed

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

Last commit 20 Feb 2019 by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32F4/stm32f4xx_hal_cryp.c@581:39197bcd20f2, 2015-07-02 (annotated)

Committer:
mbed_official
Date:
Thu Jul 02 16:30:08 2015 +0100
Revision:
581:39197bcd20f2
Parent:
532:fe11edbda85c
Child:
613:bc40b8d2aec4
Synchronized with git revision ae2d3cdffe70184eb8736d94f76c45c93f4b7724



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



Make it possible to build the core mbed library with yotta

Who changed what in which revision?

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