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_hash_ex.c@613:bc40b8d2aec4, 2015-08-20 (annotated)

Committer:
mbed_official
Date:
Thu Aug 20 10:45:13 2015 +0100
Revision:
613:bc40b8d2aec4
Parent:
532:fe11edbda85c 
Synchronized with git revision 92ca8c7b60a283b6bb60eb65b183dac1599f0ade



Full URL: https://github.com/mbedmicro/mbed/commit/92ca8c7b60a283b6bb60eb65b183dac1599f0ade/



Nordic: update application start address in GCC linker script

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbed_official 235:685d5f11838f 1 /**
mbed_official 235:685d5f11838f 2 ******************************************************************************
mbed_official 235:685d5f11838f 3 * @file stm32f4xx_hal_hash_ex.c
mbed_official 235:685d5f11838f 4 * @author MCD Application Team
mbed_official 613:bc40b8d2aec4 5 * @version V1.3.2
mbed_official 613:bc40b8d2aec4 6 * @date 26-June-2015
mbed_official 235:685d5f11838f 7 * @brief HASH HAL Extension module driver.
mbed_official 235:685d5f11838f 8 * This file provides firmware functions to manage the following
mbed_official 235:685d5f11838f 9 * functionalities of HASH peripheral:
mbed_official 235:685d5f11838f 10 * + Extended HASH processing functions based on SHA224 Algorithm
mbed_official 235:685d5f11838f 11 * + Extended HASH processing functions based on SHA256 Algorithm
mbed_official 235:685d5f11838f 12 *
mbed_official 235:685d5f11838f 13 @verbatim
mbed_official 235:685d5f11838f 14 ==============================================================================
mbed_official 235:685d5f11838f 15 ##### How to use this driver #####
mbed_official 235:685d5f11838f 16 ==============================================================================
mbed_official 235:685d5f11838f 17 [..]
mbed_official 235:685d5f11838f 18 The HASH HAL driver can be used as follows:
mbed_official 235:685d5f11838f 19 (#)Initialize the HASH low level resources by implementing the HAL_HASH_MspInit():
mbed_official 532:fe11edbda85c 20 (##) Enable the HASH interface clock using __HAL_RCC_HASH_CLK_ENABLE()
mbed_official 235:685d5f11838f 21 (##) In case of using processing APIs based on interrupts (e.g. HAL_HMACEx_SHA224_Start())
mbed_official 235:685d5f11838f 22 (+++) Configure the HASH interrupt priority using HAL_NVIC_SetPriority()
mbed_official 235:685d5f11838f 23 (+++) Enable the HASH IRQ handler using HAL_NVIC_EnableIRQ()
mbed_official 235:685d5f11838f 24 (+++) In HASH IRQ handler, call HAL_HASH_IRQHandler()
mbed_official 235:685d5f11838f 25 (##) In case of using DMA to control data transfer (e.g. HAL_HMACEx_SH224_Start_DMA())
mbed_official 235:685d5f11838f 26 (+++) Enable the DMAx interface clock using __DMAx_CLK_ENABLE()
mbed_official 235:685d5f11838f 27 (+++) Configure and enable one DMA stream one for managing data transfer from
mbed_official 235:685d5f11838f 28 memory to peripheral (input stream). Managing data transfer from
mbed_official 235:685d5f11838f 29 peripheral to memory can be performed only using CPU
mbed_official 235:685d5f11838f 30 (+++) Associate the initialized DMA handle to the HASH DMA handle
mbed_official 235:685d5f11838f 31 using __HAL_LINKDMA()
mbed_official 235:685d5f11838f 32 (+++) Configure the priority and enable the NVIC for the transfer complete
mbed_official 235:685d5f11838f 33 interrupt on the DMA Stream: HAL_NVIC_SetPriority() and HAL_NVIC_EnableIRQ()
mbed_official 235:685d5f11838f 34 (#)Initialize the HASH HAL using HAL_HASH_Init(). This function configures mainly:
mbed_official 235:685d5f11838f 35 (##) The data type: 1-bit, 8-bit, 16-bit and 32-bit.
mbed_official 235:685d5f11838f 36 (##) For HMAC, the encryption key.
mbed_official 235:685d5f11838f 37 (##) For HMAC, the key size used for encryption.
mbed_official 235:685d5f11838f 38 (#)Three processing functions are available:
mbed_official 235:685d5f11838f 39 (##) Polling mode: processing APIs are blocking functions
mbed_official 235:685d5f11838f 40 i.e. they process the data and wait till the digest computation is finished
mbed_official 235:685d5f11838f 41 e.g. HAL_HASHEx_SHA224_Start()
mbed_official 235:685d5f11838f 42 (##) Interrupt mode: encryption and decryption APIs are not blocking functions
mbed_official 235:685d5f11838f 43 i.e. they process the data under interrupt
mbed_official 235:685d5f11838f 44 e.g. HAL_HASHEx_SHA224_Start_IT()
mbed_official 235:685d5f11838f 45 (##) DMA mode: processing APIs are not blocking functions and the CPU is
mbed_official 235:685d5f11838f 46 not used for data transfer i.e. the data transfer is ensured by DMA
mbed_official 235:685d5f11838f 47 e.g. HAL_HASHEx_SHA224_Start_DMA()
mbed_official 235:685d5f11838f 48 (#)When the processing function is called at first time after HAL_HASH_Init()
mbed_official 235:685d5f11838f 49 the HASH peripheral is initialized and processes the buffer in input.
mbed_official 235:685d5f11838f 50 After that, the digest computation is started.
mbed_official 235:685d5f11838f 51 When processing multi-buffer use the accumulate function to write the
mbed_official 235:685d5f11838f 52 data in the peripheral without starting the digest computation. In last
mbed_official 235:685d5f11838f 53 buffer use the start function to input the last buffer ans start the digest
mbed_official 235:685d5f11838f 54 computation.
mbed_official 235:685d5f11838f 55 (##) e.g. HAL_HASHEx_SHA224_Accumulate() : write 1st data buffer in the peripheral without starting the digest computation
mbed_official 235:685d5f11838f 56 (##) write (n-1)th data buffer in the peripheral without starting the digest computation
mbed_official 235:685d5f11838f 57 (##) HAL_HASHEx_SHA224_Start() : write (n)th data buffer in the peripheral and start the digest computation
mbed_official 235:685d5f11838f 58 (#)In HMAC mode, there is no Accumulate API. Only Start API is available.
mbed_official 235:685d5f11838f 59 (#)In case of using DMA, call the DMA start processing e.g. HAL_HASHEx_SHA224_Start_DMA().
mbed_official 235:685d5f11838f 60 After that, call the finish function in order to get the digest value
mbed_official 235:685d5f11838f 61 e.g. HAL_HASHEx_SHA224_Finish()
mbed_official 235:685d5f11838f 62 (#)Call HAL_HASH_DeInit() to deinitialize the HASH peripheral.
mbed_official 235:685d5f11838f 63
mbed_official 235:685d5f11838f 64 @endverbatim
mbed_official 235:685d5f11838f 65 ******************************************************************************
mbed_official 235:685d5f11838f 66 * @attention
mbed_official 235:685d5f11838f 67 *
mbed_official 532:fe11edbda85c 68 * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
mbed_official 235:685d5f11838f 69 *
mbed_official 235:685d5f11838f 70 * Redistribution and use in source and binary forms, with or without modification,
mbed_official 235:685d5f11838f 71 * are permitted provided that the following conditions are met:
mbed_official 235:685d5f11838f 72 * 1. Redistributions of source code must retain the above copyright notice,
mbed_official 235:685d5f11838f 73 * this list of conditions and the following disclaimer.
mbed_official 235:685d5f11838f 74 * 2. Redistributions in binary form must reproduce the above copyright notice,
mbed_official 235:685d5f11838f 75 * this list of conditions and the following disclaimer in the documentation
mbed_official 235:685d5f11838f 76 * and/or other materials provided with the distribution.
mbed_official 235:685d5f11838f 77 * 3. Neither the name of STMicroelectronics nor the names of its contributors
mbed_official 235:685d5f11838f 78 * may be used to endorse or promote products derived from this software
mbed_official 235:685d5f11838f 79 * without specific prior written permission.
mbed_official 235:685d5f11838f 80 *
mbed_official 235:685d5f11838f 81 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
mbed_official 235:685d5f11838f 82 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
mbed_official 235:685d5f11838f 83 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
mbed_official 235:685d5f11838f 84 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
mbed_official 235:685d5f11838f 85 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
mbed_official 235:685d5f11838f 86 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
mbed_official 235:685d5f11838f 87 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
mbed_official 235:685d5f11838f 88 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
mbed_official 235:685d5f11838f 89 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
mbed_official 235:685d5f11838f 90 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
mbed_official 235:685d5f11838f 91 *
mbed_official 235:685d5f11838f 92 ******************************************************************************
mbed_official 235:685d5f11838f 93 */
mbed_official 235:685d5f11838f 94
mbed_official 235:685d5f11838f 95 /* Includes ------------------------------------------------------------------*/
mbed_official 235:685d5f11838f 96 #include "stm32f4xx_hal.h"
mbed_official 235:685d5f11838f 97
mbed_official 235:685d5f11838f 98 /** @addtogroup STM32F4xx_HAL_Driver
mbed_official 235:685d5f11838f 99 * @{
mbed_official 235:685d5f11838f 100 */
mbed_official 235:685d5f11838f 101
mbed_official 532:fe11edbda85c 102 /** @defgroup HASHEx HASHEx
mbed_official 235:685d5f11838f 103 * @brief HASH Extension HAL module driver.
mbed_official 235:685d5f11838f 104 * @{
mbed_official 235:685d5f11838f 105 */
mbed_official 235:685d5f11838f 106
mbed_official 235:685d5f11838f 107 #ifdef HAL_HASH_MODULE_ENABLED
mbed_official 235:685d5f11838f 108
mbed_official 235:685d5f11838f 109 #if defined(STM32F437xx) || defined(STM32F439xx)
mbed_official 235:685d5f11838f 110
mbed_official 235:685d5f11838f 111 /* Private typedef -----------------------------------------------------------*/
mbed_official 235:685d5f11838f 112 /* Private define ------------------------------------------------------------*/
mbed_official 235:685d5f11838f 113 /* Private macro -------------------------------------------------------------*/
mbed_official 235:685d5f11838f 114 /* Private variables ---------------------------------------------------------*/
mbed_official 235:685d5f11838f 115 /* Private function prototypes -----------------------------------------------*/
mbed_official 532:fe11edbda85c 116 /** @addtogroup HASHEx_Private_Functions
mbed_official 532:fe11edbda85c 117 * @{
mbed_official 532:fe11edbda85c 118 */
mbed_official 235:685d5f11838f 119 static void HASHEx_DMAXferCplt(DMA_HandleTypeDef *hdma);
mbed_official 235:685d5f11838f 120 static void HASHEx_WriteData(uint8_t *pInBuffer, uint32_t Size);
mbed_official 235:685d5f11838f 121 static void HASHEx_GetDigest(uint8_t *pMsgDigest, uint8_t Size);
mbed_official 235:685d5f11838f 122 static void HASHEx_DMAError(DMA_HandleTypeDef *hdma);
mbed_official 235:685d5f11838f 123 /**
mbed_official 235:685d5f11838f 124 * @}
mbed_official 235:685d5f11838f 125 */
mbed_official 235:685d5f11838f 126
mbed_official 532:fe11edbda85c 127 /* Private functions ---------------------------------------------------------*/
mbed_official 235:685d5f11838f 128
mbed_official 532:fe11edbda85c 129 /** @addtogroup HASHEx_Private_Functions
mbed_official 235:685d5f11838f 130 * @{
mbed_official 235:685d5f11838f 131 */
mbed_official 235:685d5f11838f 132
mbed_official 235:685d5f11838f 133 /**
mbed_official 235:685d5f11838f 134 * @brief Writes the input buffer in data register.
mbed_official 235:685d5f11838f 135 * @param pInBuffer: Pointer to input buffer
mbed_official 235:685d5f11838f 136 * @param Size: The size of input buffer
mbed_official 235:685d5f11838f 137 * @retval None
mbed_official 235:685d5f11838f 138 */
mbed_official 235:685d5f11838f 139 static void HASHEx_WriteData(uint8_t *pInBuffer, uint32_t Size)
mbed_official 235:685d5f11838f 140 {
mbed_official 235:685d5f11838f 141 uint32_t buffercounter;
mbed_official 235:685d5f11838f 142 uint32_t inputaddr = (uint32_t) pInBuffer;
mbed_official 235:685d5f11838f 143
mbed_official 235:685d5f11838f 144 for(buffercounter = 0; buffercounter < Size; buffercounter+=4)
mbed_official 235:685d5f11838f 145 {
mbed_official 235:685d5f11838f 146 HASH->DIN = *(uint32_t*)inputaddr;
mbed_official 235:685d5f11838f 147 inputaddr+=4;
mbed_official 235:685d5f11838f 148 }
mbed_official 235:685d5f11838f 149 }
mbed_official 235:685d5f11838f 150
mbed_official 235:685d5f11838f 151 /**
mbed_official 235:685d5f11838f 152 * @brief Provides the message digest result.
mbed_official 235:685d5f11838f 153 * @param pMsgDigest: Pointer to the message digest
mbed_official 235:685d5f11838f 154 * @param Size: The size of the message digest in bytes
mbed_official 235:685d5f11838f 155 * @retval None
mbed_official 235:685d5f11838f 156 */
mbed_official 235:685d5f11838f 157 static void HASHEx_GetDigest(uint8_t *pMsgDigest, uint8_t Size)
mbed_official 235:685d5f11838f 158 {
mbed_official 235:685d5f11838f 159 uint32_t msgdigest = (uint32_t)pMsgDigest;
mbed_official 235:685d5f11838f 160
mbed_official 235:685d5f11838f 161 switch(Size)
mbed_official 235:685d5f11838f 162 {
mbed_official 235:685d5f11838f 163 case 16:
mbed_official 235:685d5f11838f 164 /* Read the message digest */
mbed_official 235:685d5f11838f 165 *(uint32_t*)(msgdigest) = __REV(HASH->HR[0]);
mbed_official 235:685d5f11838f 166 msgdigest+=4;
mbed_official 235:685d5f11838f 167 *(uint32_t*)(msgdigest) = __REV(HASH->HR[1]);
mbed_official 235:685d5f11838f 168 msgdigest+=4;
mbed_official 235:685d5f11838f 169 *(uint32_t*)(msgdigest) = __REV(HASH->HR[2]);
mbed_official 235:685d5f11838f 170 msgdigest+=4;
mbed_official 235:685d5f11838f 171 *(uint32_t*)(msgdigest) = __REV(HASH->HR[3]);
mbed_official 235:685d5f11838f 172 break;
mbed_official 235:685d5f11838f 173 case 20:
mbed_official 235:685d5f11838f 174 /* Read the message digest */
mbed_official 235:685d5f11838f 175 *(uint32_t*)(msgdigest) = __REV(HASH->HR[0]);
mbed_official 235:685d5f11838f 176 msgdigest+=4;
mbed_official 235:685d5f11838f 177 *(uint32_t*)(msgdigest) = __REV(HASH->HR[1]);
mbed_official 235:685d5f11838f 178 msgdigest+=4;
mbed_official 235:685d5f11838f 179 *(uint32_t*)(msgdigest) = __REV(HASH->HR[2]);
mbed_official 235:685d5f11838f 180 msgdigest+=4;
mbed_official 235:685d5f11838f 181 *(uint32_t*)(msgdigest) = __REV(HASH->HR[3]);
mbed_official 235:685d5f11838f 182 msgdigest+=4;
mbed_official 235:685d5f11838f 183 *(uint32_t*)(msgdigest) = __REV(HASH->HR[4]);
mbed_official 235:685d5f11838f 184 break;
mbed_official 235:685d5f11838f 185 case 28:
mbed_official 235:685d5f11838f 186 /* Read the message digest */
mbed_official 235:685d5f11838f 187 *(uint32_t*)(msgdigest) = __REV(HASH->HR[0]);
mbed_official 235:685d5f11838f 188 msgdigest+=4;
mbed_official 235:685d5f11838f 189 *(uint32_t*)(msgdigest) = __REV(HASH->HR[1]);
mbed_official 235:685d5f11838f 190 msgdigest+=4;
mbed_official 235:685d5f11838f 191 *(uint32_t*)(msgdigest) = __REV(HASH->HR[2]);
mbed_official 235:685d5f11838f 192 msgdigest+=4;
mbed_official 235:685d5f11838f 193 *(uint32_t*)(msgdigest) = __REV(HASH->HR[3]);
mbed_official 235:685d5f11838f 194 msgdigest+=4;
mbed_official 235:685d5f11838f 195 *(uint32_t*)(msgdigest) = __REV(HASH->HR[4]);
mbed_official 235:685d5f11838f 196 msgdigest+=4;
mbed_official 235:685d5f11838f 197 *(uint32_t*)(msgdigest) = __REV(HASH_DIGEST->HR[5]);
mbed_official 235:685d5f11838f 198 msgdigest+=4;
mbed_official 235:685d5f11838f 199 *(uint32_t*)(msgdigest) = __REV(HASH_DIGEST->HR[6]);
mbed_official 235:685d5f11838f 200 break;
mbed_official 235:685d5f11838f 201 case 32:
mbed_official 235:685d5f11838f 202 /* Read the message digest */
mbed_official 235:685d5f11838f 203 *(uint32_t*)(msgdigest) = __REV(HASH->HR[0]);
mbed_official 235:685d5f11838f 204 msgdigest+=4;
mbed_official 235:685d5f11838f 205 *(uint32_t*)(msgdigest) = __REV(HASH->HR[1]);
mbed_official 235:685d5f11838f 206 msgdigest+=4;
mbed_official 235:685d5f11838f 207 *(uint32_t*)(msgdigest) = __REV(HASH->HR[2]);
mbed_official 235:685d5f11838f 208 msgdigest+=4;
mbed_official 235:685d5f11838f 209 *(uint32_t*)(msgdigest) = __REV(HASH->HR[3]);
mbed_official 235:685d5f11838f 210 msgdigest+=4;
mbed_official 235:685d5f11838f 211 *(uint32_t*)(msgdigest) = __REV(HASH->HR[4]);
mbed_official 235:685d5f11838f 212 msgdigest+=4;
mbed_official 235:685d5f11838f 213 *(uint32_t*)(msgdigest) = __REV(HASH_DIGEST->HR[5]);
mbed_official 235:685d5f11838f 214 msgdigest+=4;
mbed_official 235:685d5f11838f 215 *(uint32_t*)(msgdigest) = __REV(HASH_DIGEST->HR[6]);
mbed_official 235:685d5f11838f 216 msgdigest+=4;
mbed_official 235:685d5f11838f 217 *(uint32_t*)(msgdigest) = __REV(HASH_DIGEST->HR[7]);
mbed_official 235:685d5f11838f 218 break;
mbed_official 235:685d5f11838f 219 default:
mbed_official 235:685d5f11838f 220 break;
mbed_official 235:685d5f11838f 221 }
mbed_official 235:685d5f11838f 222 }
mbed_official 235:685d5f11838f 223
mbed_official 235:685d5f11838f 224 /**
mbed_official 235:685d5f11838f 225 * @brief DMA HASH Input Data complete callback.
mbed_official 235:685d5f11838f 226 * @param hdma: DMA handle
mbed_official 235:685d5f11838f 227 * @retval None
mbed_official 235:685d5f11838f 228 */
mbed_official 235:685d5f11838f 229 static void HASHEx_DMAXferCplt(DMA_HandleTypeDef *hdma)
mbed_official 235:685d5f11838f 230 {
mbed_official 235:685d5f11838f 231 HASH_HandleTypeDef* hhash = ( HASH_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 235:685d5f11838f 232 uint32_t inputaddr = 0;
mbed_official 235:685d5f11838f 233 uint32_t buffersize = 0;
mbed_official 235:685d5f11838f 234
mbed_official 235:685d5f11838f 235 if((HASH->CR & HASH_CR_MODE) != HASH_CR_MODE)
mbed_official 235:685d5f11838f 236 {
mbed_official 235:685d5f11838f 237 /* Disable the DMA transfer */
mbed_official 235:685d5f11838f 238 HASH->CR &= (uint32_t)(~HASH_CR_DMAE);
mbed_official 235:685d5f11838f 239
mbed_official 235:685d5f11838f 240 /* Change HASH peripheral state */
mbed_official 235:685d5f11838f 241 hhash->State = HAL_HASH_STATE_READY;
mbed_official 235:685d5f11838f 242
mbed_official 235:685d5f11838f 243 /* Call Input data transfer complete callback */
mbed_official 235:685d5f11838f 244 HAL_HASH_InCpltCallback(hhash);
mbed_official 235:685d5f11838f 245 }
mbed_official 235:685d5f11838f 246 else
mbed_official 235:685d5f11838f 247 {
mbed_official 235:685d5f11838f 248 /* Increment Interrupt counter */
mbed_official 235:685d5f11838f 249 hhash->HashInCount++;
mbed_official 235:685d5f11838f 250 /* Disable the DMA transfer before starting the next transfer */
mbed_official 235:685d5f11838f 251 HASH->CR &= (uint32_t)(~HASH_CR_DMAE);
mbed_official 235:685d5f11838f 252
mbed_official 235:685d5f11838f 253 if(hhash->HashInCount <= 2)
mbed_official 235:685d5f11838f 254 {
mbed_official 235:685d5f11838f 255 /* In case HashInCount = 1, set the DMA to transfer data to HASH DIN register */
mbed_official 235:685d5f11838f 256 if(hhash->HashInCount == 1)
mbed_official 235:685d5f11838f 257 {
mbed_official 235:685d5f11838f 258 inputaddr = (uint32_t)hhash->pHashInBuffPtr;
mbed_official 235:685d5f11838f 259 buffersize = hhash->HashBuffSize;
mbed_official 235:685d5f11838f 260 }
mbed_official 235:685d5f11838f 261 /* In case HashInCount = 2, set the DMA to transfer key to HASH DIN register */
mbed_official 235:685d5f11838f 262 else if(hhash->HashInCount == 2)
mbed_official 235:685d5f11838f 263 {
mbed_official 235:685d5f11838f 264 inputaddr = (uint32_t)hhash->Init.pKey;
mbed_official 235:685d5f11838f 265 buffersize = hhash->Init.KeySize;
mbed_official 235:685d5f11838f 266 }
mbed_official 235:685d5f11838f 267 /* Configure the number of valid bits in last word of the message */
mbed_official 613:bc40b8d2aec4 268 MODIFY_REG(HASH->STR, HASH_STR_NBLW, 8 * (buffersize % 4));
mbed_official 235:685d5f11838f 269
mbed_official 235:685d5f11838f 270 /* Set the HASH DMA transfer complete */
mbed_official 235:685d5f11838f 271 hhash->hdmain->XferCpltCallback = HASHEx_DMAXferCplt;
mbed_official 235:685d5f11838f 272
mbed_official 235:685d5f11838f 273 /* Enable the DMA In DMA Stream */
mbed_official 235:685d5f11838f 274 HAL_DMA_Start_IT(hhash->hdmain, inputaddr, (uint32_t)&HASH->DIN, (buffersize%4 ? (buffersize+3)/4:buffersize/4));
mbed_official 235:685d5f11838f 275
mbed_official 235:685d5f11838f 276 /* Enable DMA requests */
mbed_official 235:685d5f11838f 277 HASH->CR |= (HASH_CR_DMAE);
mbed_official 235:685d5f11838f 278 }
mbed_official 235:685d5f11838f 279 else
mbed_official 235:685d5f11838f 280 {
mbed_official 235:685d5f11838f 281 /* Disable the DMA transfer */
mbed_official 235:685d5f11838f 282 HASH->CR &= (uint32_t)(~HASH_CR_DMAE);
mbed_official 235:685d5f11838f 283
mbed_official 235:685d5f11838f 284 /* Reset the InCount */
mbed_official 235:685d5f11838f 285 hhash->HashInCount = 0;
mbed_official 235:685d5f11838f 286
mbed_official 235:685d5f11838f 287 /* Change HASH peripheral state */
mbed_official 235:685d5f11838f 288 hhash->State = HAL_HASH_STATE_READY;
mbed_official 235:685d5f11838f 289
mbed_official 235:685d5f11838f 290 /* Call Input data transfer complete callback */
mbed_official 235:685d5f11838f 291 HAL_HASH_InCpltCallback(hhash);
mbed_official 235:685d5f11838f 292 }
mbed_official 235:685d5f11838f 293 }
mbed_official 235:685d5f11838f 294 }
mbed_official 235:685d5f11838f 295
mbed_official 235:685d5f11838f 296 /**
mbed_official 235:685d5f11838f 297 * @brief DMA HASH communication error callback.
mbed_official 235:685d5f11838f 298 * @param hdma: DMA handle
mbed_official 235:685d5f11838f 299 * @retval None
mbed_official 235:685d5f11838f 300 */
mbed_official 235:685d5f11838f 301 static void HASHEx_DMAError(DMA_HandleTypeDef *hdma)
mbed_official 235:685d5f11838f 302 {
mbed_official 235:685d5f11838f 303 HASH_HandleTypeDef* hhash = ( HASH_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 235:685d5f11838f 304 hhash->State= HAL_HASH_STATE_READY;
mbed_official 235:685d5f11838f 305 HAL_HASH_ErrorCallback(hhash);
mbed_official 235:685d5f11838f 306 }
mbed_official 235:685d5f11838f 307
mbed_official 532:fe11edbda85c 308 /**
mbed_official 532:fe11edbda85c 309 * @}
mbed_official 532:fe11edbda85c 310 */
mbed_official 532:fe11edbda85c 311
mbed_official 532:fe11edbda85c 312 /* Exported functions --------------------------------------------------------*/
mbed_official 532:fe11edbda85c 313 /** @addtogroup HASHEx_Exported_Functions
mbed_official 532:fe11edbda85c 314 * @{
mbed_official 532:fe11edbda85c 315 */
mbed_official 532:fe11edbda85c 316
mbed_official 532:fe11edbda85c 317 /** @defgroup HASHEx_Group1 HASH processing functions
mbed_official 532:fe11edbda85c 318 * @brief processing functions using polling mode
mbed_official 532:fe11edbda85c 319 *
mbed_official 532:fe11edbda85c 320 @verbatim
mbed_official 532:fe11edbda85c 321 ===============================================================================
mbed_official 532:fe11edbda85c 322 ##### HASH processing using polling mode functions #####
mbed_official 532:fe11edbda85c 323 ===============================================================================
mbed_official 532:fe11edbda85c 324 [..] This section provides functions allowing to calculate in polling mode
mbed_official 532:fe11edbda85c 325 the hash value using one of the following algorithms:
mbed_official 532:fe11edbda85c 326 (+) SHA224
mbed_official 532:fe11edbda85c 327 (+) SHA256
mbed_official 532:fe11edbda85c 328
mbed_official 532:fe11edbda85c 329 @endverbatim
mbed_official 532:fe11edbda85c 330 * @{
mbed_official 532:fe11edbda85c 331 */
mbed_official 532:fe11edbda85c 332
mbed_official 532:fe11edbda85c 333 /**
mbed_official 532:fe11edbda85c 334 * @brief Initializes the HASH peripheral in SHA224 mode
mbed_official 532:fe11edbda85c 335 * then processes pInBuffer. The digest is available in pOutBuffer
mbed_official 532:fe11edbda85c 336 * @param hhash: pointer to a HASH_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 337 * the configuration information for HASH module
mbed_official 532:fe11edbda85c 338 * @param pInBuffer: Pointer to the input buffer (buffer to be hashed).
mbed_official 532:fe11edbda85c 339 * @param Size: Length of the input buffer in bytes.
mbed_official 532:fe11edbda85c 340 * If the Size is not multiple of 64 bytes, the padding is managed by hardware.
mbed_official 532:fe11edbda85c 341 * @param pOutBuffer: Pointer to the computed digest. Its size must be 28 bytes.
mbed_official 532:fe11edbda85c 342 * @param Timeout: Specify Timeout value
mbed_official 532:fe11edbda85c 343 * @retval HAL status
mbed_official 532:fe11edbda85c 344 */
mbed_official 532:fe11edbda85c 345 HAL_StatusTypeDef HAL_HASHEx_SHA224_Start(HASH_HandleTypeDef *hhash, uint8_t *pInBuffer, uint32_t Size, uint8_t* pOutBuffer, uint32_t Timeout)
mbed_official 532:fe11edbda85c 346 {
mbed_official 532:fe11edbda85c 347 uint32_t tickstart = 0;
mbed_official 532:fe11edbda85c 348
mbed_official 532:fe11edbda85c 349 /* Process Locked */
mbed_official 532:fe11edbda85c 350 __HAL_LOCK(hhash);
mbed_official 532:fe11edbda85c 351
mbed_official 532:fe11edbda85c 352 /* Change the HASH state */
mbed_official 532:fe11edbda85c 353 hhash->State = HAL_HASH_STATE_BUSY;
mbed_official 532:fe11edbda85c 354
mbed_official 532:fe11edbda85c 355 /* Check if initialization phase has already been performed */
mbed_official 532:fe11edbda85c 356 if(hhash->Phase == HAL_HASH_PHASE_READY)
mbed_official 532:fe11edbda85c 357 {
mbed_official 532:fe11edbda85c 358 /* Select the SHA224 mode and reset the HASH processor core, so that the HASH will be ready to compute
mbed_official 532:fe11edbda85c 359 the message digest of a new message */
mbed_official 532:fe11edbda85c 360 HASH->CR |= HASH_ALGOSELECTION_SHA224 | HASH_CR_INIT;
mbed_official 532:fe11edbda85c 361 }
mbed_official 532:fe11edbda85c 362
mbed_official 532:fe11edbda85c 363 /* Set the phase */
mbed_official 532:fe11edbda85c 364 hhash->Phase = HAL_HASH_PHASE_PROCESS;
mbed_official 532:fe11edbda85c 365
mbed_official 532:fe11edbda85c 366 /* Configure the number of valid bits in last word of the message */
mbed_official 532:fe11edbda85c 367 __HAL_HASH_SET_NBVALIDBITS(Size);
mbed_official 532:fe11edbda85c 368
mbed_official 532:fe11edbda85c 369 /* Write input buffer in data register */
mbed_official 532:fe11edbda85c 370 HASHEx_WriteData(pInBuffer, Size);
mbed_official 532:fe11edbda85c 371
mbed_official 532:fe11edbda85c 372 /* Start the digest calculation */
mbed_official 532:fe11edbda85c 373 __HAL_HASH_START_DIGEST();
mbed_official 532:fe11edbda85c 374
mbed_official 532:fe11edbda85c 375 /* Get tick */
mbed_official 532:fe11edbda85c 376 tickstart = HAL_GetTick();
mbed_official 532:fe11edbda85c 377
mbed_official 532:fe11edbda85c 378 while((HASH->SR & HASH_FLAG_BUSY) == HASH_FLAG_BUSY)
mbed_official 532:fe11edbda85c 379 {
mbed_official 532:fe11edbda85c 380 /* Check for the Timeout */
mbed_official 532:fe11edbda85c 381 if(Timeout != HAL_MAX_DELAY)
mbed_official 532:fe11edbda85c 382 {
mbed_official 532:fe11edbda85c 383 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 532:fe11edbda85c 384 {
mbed_official 532:fe11edbda85c 385 /* Change state */
mbed_official 532:fe11edbda85c 386 hhash->State = HAL_HASH_STATE_TIMEOUT;
mbed_official 532:fe11edbda85c 387
mbed_official 532:fe11edbda85c 388 /* Process Unlocked */
mbed_official 532:fe11edbda85c 389 __HAL_UNLOCK(hhash);
mbed_official 532:fe11edbda85c 390
mbed_official 532:fe11edbda85c 391 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 392 }
mbed_official 532:fe11edbda85c 393 }
mbed_official 532:fe11edbda85c 394 }
mbed_official 532:fe11edbda85c 395
mbed_official 532:fe11edbda85c 396 /* Read the message digest */
mbed_official 532:fe11edbda85c 397 HASHEx_GetDigest(pOutBuffer, 28);
mbed_official 532:fe11edbda85c 398
mbed_official 532:fe11edbda85c 399 /* Change the HASH state */
mbed_official 532:fe11edbda85c 400 hhash->State = HAL_HASH_STATE_READY;
mbed_official 532:fe11edbda85c 401
mbed_official 532:fe11edbda85c 402 /* Process Unlocked */
mbed_official 532:fe11edbda85c 403 __HAL_UNLOCK(hhash);
mbed_official 532:fe11edbda85c 404
mbed_official 532:fe11edbda85c 405 /* Return function status */
mbed_official 532:fe11edbda85c 406 return HAL_OK;
mbed_official 532:fe11edbda85c 407 }
mbed_official 532:fe11edbda85c 408
mbed_official 532:fe11edbda85c 409 /**
mbed_official 532:fe11edbda85c 410 * @brief Initializes the HASH peripheral in SHA256 mode then processes pInBuffer.
mbed_official 532:fe11edbda85c 411 The digest is available in pOutBuffer.
mbed_official 532:fe11edbda85c 412 * @param hhash: pointer to a HASH_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 413 * the configuration information for HASH module
mbed_official 532:fe11edbda85c 414 * @param pInBuffer: Pointer to the input buffer (buffer to be hashed).
mbed_official 532:fe11edbda85c 415 * @param Size: Length of the input buffer in bytes.
mbed_official 532:fe11edbda85c 416 * If the Size is not multiple of 64 bytes, the padding is managed by hardware.
mbed_official 532:fe11edbda85c 417 * @param pOutBuffer: Pointer to the computed digest. Its size must be 32 bytes.
mbed_official 532:fe11edbda85c 418 * @param Timeout: Specify Timeout value
mbed_official 532:fe11edbda85c 419 * @retval HAL status
mbed_official 532:fe11edbda85c 420 */
mbed_official 532:fe11edbda85c 421 HAL_StatusTypeDef HAL_HASHEx_SHA256_Start(HASH_HandleTypeDef *hhash, uint8_t *pInBuffer, uint32_t Size, uint8_t* pOutBuffer, uint32_t Timeout)
mbed_official 532:fe11edbda85c 422 {
mbed_official 532:fe11edbda85c 423 uint32_t tickstart = 0;
mbed_official 532:fe11edbda85c 424
mbed_official 532:fe11edbda85c 425 /* Process Locked */
mbed_official 532:fe11edbda85c 426 __HAL_LOCK(hhash);
mbed_official 532:fe11edbda85c 427
mbed_official 532:fe11edbda85c 428 /* Change the HASH state */
mbed_official 532:fe11edbda85c 429 hhash->State = HAL_HASH_STATE_BUSY;
mbed_official 532:fe11edbda85c 430
mbed_official 532:fe11edbda85c 431 /* Check if initialization phase has already been performed */
mbed_official 532:fe11edbda85c 432 if(hhash->Phase == HAL_HASH_PHASE_READY)
mbed_official 532:fe11edbda85c 433 {
mbed_official 532:fe11edbda85c 434 /* Select the SHA256 mode and reset the HASH processor core, so that the HASH will be ready to compute
mbed_official 532:fe11edbda85c 435 the message digest of a new message */
mbed_official 532:fe11edbda85c 436 HASH->CR |= HASH_ALGOSELECTION_SHA256 | HASH_CR_INIT;
mbed_official 532:fe11edbda85c 437 }
mbed_official 532:fe11edbda85c 438
mbed_official 532:fe11edbda85c 439 /* Set the phase */
mbed_official 532:fe11edbda85c 440 hhash->Phase = HAL_HASH_PHASE_PROCESS;
mbed_official 532:fe11edbda85c 441
mbed_official 532:fe11edbda85c 442 /* Configure the number of valid bits in last word of the message */
mbed_official 532:fe11edbda85c 443 __HAL_HASH_SET_NBVALIDBITS(Size);
mbed_official 532:fe11edbda85c 444
mbed_official 532:fe11edbda85c 445 /* Write input buffer in data register */
mbed_official 532:fe11edbda85c 446 HASHEx_WriteData(pInBuffer, Size);
mbed_official 532:fe11edbda85c 447
mbed_official 532:fe11edbda85c 448 /* Start the digest calculation */
mbed_official 532:fe11edbda85c 449 __HAL_HASH_START_DIGEST();
mbed_official 532:fe11edbda85c 450
mbed_official 532:fe11edbda85c 451 /* Get tick */
mbed_official 532:fe11edbda85c 452 tickstart = HAL_GetTick();
mbed_official 532:fe11edbda85c 453
mbed_official 532:fe11edbda85c 454 while((HASH->SR & HASH_FLAG_BUSY) == HASH_FLAG_BUSY)
mbed_official 532:fe11edbda85c 455 {
mbed_official 532:fe11edbda85c 456 /* Check for the Timeout */
mbed_official 532:fe11edbda85c 457 if(Timeout != HAL_MAX_DELAY)
mbed_official 532:fe11edbda85c 458 {
mbed_official 532:fe11edbda85c 459 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 532:fe11edbda85c 460 {
mbed_official 532:fe11edbda85c 461 /* Change state */
mbed_official 532:fe11edbda85c 462 hhash->State = HAL_HASH_STATE_TIMEOUT;
mbed_official 532:fe11edbda85c 463
mbed_official 532:fe11edbda85c 464 /* Process Unlocked */
mbed_official 532:fe11edbda85c 465 __HAL_UNLOCK(hhash);
mbed_official 532:fe11edbda85c 466
mbed_official 532:fe11edbda85c 467 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 468 }
mbed_official 532:fe11edbda85c 469 }
mbed_official 532:fe11edbda85c 470 }
mbed_official 532:fe11edbda85c 471
mbed_official 532:fe11edbda85c 472 /* Read the message digest */
mbed_official 532:fe11edbda85c 473 HASHEx_GetDigest(pOutBuffer, 32);
mbed_official 532:fe11edbda85c 474
mbed_official 532:fe11edbda85c 475 /* Change the HASH state */
mbed_official 532:fe11edbda85c 476 hhash->State = HAL_HASH_STATE_READY;
mbed_official 532:fe11edbda85c 477
mbed_official 532:fe11edbda85c 478 /* Process Unlocked */
mbed_official 532:fe11edbda85c 479 __HAL_UNLOCK(hhash);
mbed_official 532:fe11edbda85c 480
mbed_official 532:fe11edbda85c 481 /* Return function status */
mbed_official 532:fe11edbda85c 482 return HAL_OK;
mbed_official 532:fe11edbda85c 483 }
mbed_official 532:fe11edbda85c 484
mbed_official 532:fe11edbda85c 485
mbed_official 532:fe11edbda85c 486 /**
mbed_official 532:fe11edbda85c 487 * @brief Initializes the HASH peripheral in SHA224 mode
mbed_official 532:fe11edbda85c 488 * then processes pInBuffer. The digest is available in pOutBuffer
mbed_official 532:fe11edbda85c 489 * @param hhash: pointer to a HASH_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 490 * the configuration information for HASH module
mbed_official 532:fe11edbda85c 491 * @param pInBuffer: Pointer to the input buffer (buffer to be hashed).
mbed_official 532:fe11edbda85c 492 * @param Size: Length of the input buffer in bytes.
mbed_official 532:fe11edbda85c 493 * If the Size is not multiple of 64 bytes, the padding is managed by hardware.
mbed_official 532:fe11edbda85c 494 * @retval HAL status
mbed_official 532:fe11edbda85c 495 */
mbed_official 532:fe11edbda85c 496 HAL_StatusTypeDef HAL_HASHEx_SHA224_Accumulate(HASH_HandleTypeDef *hhash, uint8_t *pInBuffer, uint32_t Size)
mbed_official 532:fe11edbda85c 497 {
mbed_official 532:fe11edbda85c 498 /* Process Locked */
mbed_official 532:fe11edbda85c 499 __HAL_LOCK(hhash);
mbed_official 532:fe11edbda85c 500
mbed_official 532:fe11edbda85c 501 /* Change the HASH state */
mbed_official 532:fe11edbda85c 502 hhash->State = HAL_HASH_STATE_BUSY;
mbed_official 532:fe11edbda85c 503
mbed_official 532:fe11edbda85c 504 /* Check if initialization phase has already been performed */
mbed_official 532:fe11edbda85c 505 if(hhash->Phase == HAL_HASH_PHASE_READY)
mbed_official 532:fe11edbda85c 506 {
mbed_official 532:fe11edbda85c 507 /* Select the SHA224 mode and reset the HASH processor core, so that the HASH will be ready to compute
mbed_official 532:fe11edbda85c 508 the message digest of a new message */
mbed_official 532:fe11edbda85c 509 HASH->CR |= HASH_ALGOSELECTION_SHA224 | HASH_CR_INIT;
mbed_official 532:fe11edbda85c 510 }
mbed_official 532:fe11edbda85c 511
mbed_official 532:fe11edbda85c 512 /* Set the phase */
mbed_official 532:fe11edbda85c 513 hhash->Phase = HAL_HASH_PHASE_PROCESS;
mbed_official 532:fe11edbda85c 514
mbed_official 532:fe11edbda85c 515 /* Configure the number of valid bits in last word of the message */
mbed_official 532:fe11edbda85c 516 __HAL_HASH_SET_NBVALIDBITS(Size);
mbed_official 532:fe11edbda85c 517
mbed_official 532:fe11edbda85c 518 /* Write input buffer in data register */
mbed_official 532:fe11edbda85c 519 HASHEx_WriteData(pInBuffer, Size);
mbed_official 532:fe11edbda85c 520
mbed_official 532:fe11edbda85c 521 /* Change the HASH state */
mbed_official 532:fe11edbda85c 522 hhash->State = HAL_HASH_STATE_READY;
mbed_official 532:fe11edbda85c 523
mbed_official 532:fe11edbda85c 524 /* Process Unlocked */
mbed_official 532:fe11edbda85c 525 __HAL_UNLOCK(hhash);
mbed_official 532:fe11edbda85c 526
mbed_official 532:fe11edbda85c 527 /* Return function status */
mbed_official 532:fe11edbda85c 528 return HAL_OK;
mbed_official 532:fe11edbda85c 529 }
mbed_official 532:fe11edbda85c 530
mbed_official 532:fe11edbda85c 531
mbed_official 532:fe11edbda85c 532 /**
mbed_official 532:fe11edbda85c 533 * @brief Initializes the HASH peripheral in SHA256 mode then processes pInBuffer.
mbed_official 532:fe11edbda85c 534 The digest is available in pOutBuffer.
mbed_official 532:fe11edbda85c 535 * @param hhash: pointer to a HASH_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 536 * the configuration information for HASH module
mbed_official 532:fe11edbda85c 537 * @param pInBuffer: Pointer to the input buffer (buffer to be hashed).
mbed_official 532:fe11edbda85c 538 * @param Size: Length of the input buffer in bytes.
mbed_official 532:fe11edbda85c 539 * If the Size is not multiple of 64 bytes, the padding is managed by hardware.
mbed_official 532:fe11edbda85c 540 * @retval HAL status
mbed_official 532:fe11edbda85c 541 */
mbed_official 532:fe11edbda85c 542 HAL_StatusTypeDef HAL_HASHEx_SHA256_Accumulate(HASH_HandleTypeDef *hhash, uint8_t *pInBuffer, uint32_t Size)
mbed_official 532:fe11edbda85c 543 {
mbed_official 532:fe11edbda85c 544 /* Process Locked */
mbed_official 532:fe11edbda85c 545 __HAL_LOCK(hhash);
mbed_official 532:fe11edbda85c 546
mbed_official 532:fe11edbda85c 547 /* Change the HASH state */
mbed_official 532:fe11edbda85c 548 hhash->State = HAL_HASH_STATE_BUSY;
mbed_official 532:fe11edbda85c 549
mbed_official 532:fe11edbda85c 550 /* Check if initialization phase has already been performed */
mbed_official 532:fe11edbda85c 551 if(hhash->Phase == HAL_HASH_PHASE_READY)
mbed_official 532:fe11edbda85c 552 {
mbed_official 532:fe11edbda85c 553 /* Select the SHA256 mode and reset the HASH processor core, so that the HASH will be ready to compute
mbed_official 532:fe11edbda85c 554 the message digest of a new message */
mbed_official 532:fe11edbda85c 555 HASH->CR |= HASH_ALGOSELECTION_SHA256 | HASH_CR_INIT;
mbed_official 532:fe11edbda85c 556 }
mbed_official 532:fe11edbda85c 557
mbed_official 532:fe11edbda85c 558 /* Set the phase */
mbed_official 532:fe11edbda85c 559 hhash->Phase = HAL_HASH_PHASE_PROCESS;
mbed_official 532:fe11edbda85c 560
mbed_official 532:fe11edbda85c 561 /* Configure the number of valid bits in last word of the message */
mbed_official 532:fe11edbda85c 562 __HAL_HASH_SET_NBVALIDBITS(Size);
mbed_official 532:fe11edbda85c 563
mbed_official 532:fe11edbda85c 564 /* Write input buffer in data register */
mbed_official 532:fe11edbda85c 565 HASHEx_WriteData(pInBuffer, Size);
mbed_official 532:fe11edbda85c 566
mbed_official 532:fe11edbda85c 567 /* Change the HASH state */
mbed_official 532:fe11edbda85c 568 hhash->State = HAL_HASH_STATE_READY;
mbed_official 532:fe11edbda85c 569
mbed_official 532:fe11edbda85c 570 /* Process Unlocked */
mbed_official 532:fe11edbda85c 571 __HAL_UNLOCK(hhash);
mbed_official 532:fe11edbda85c 572
mbed_official 532:fe11edbda85c 573 /* Return function status */
mbed_official 532:fe11edbda85c 574 return HAL_OK;
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 */
mbed_official 532:fe11edbda85c 581
mbed_official 532:fe11edbda85c 582 /** @defgroup HASHEx_Group2 HMAC processing functions using polling mode
mbed_official 532:fe11edbda85c 583 * @brief HMAC processing functions using polling mode .
mbed_official 532:fe11edbda85c 584 *
mbed_official 532:fe11edbda85c 585 @verbatim
mbed_official 532:fe11edbda85c 586 ===============================================================================
mbed_official 532:fe11edbda85c 587 ##### HMAC processing using polling mode functions #####
mbed_official 532:fe11edbda85c 588 ===============================================================================
mbed_official 532:fe11edbda85c 589 [..] This section provides functions allowing to calculate in polling mode
mbed_official 532:fe11edbda85c 590 the HMAC value using one of the following algorithms:
mbed_official 532:fe11edbda85c 591 (+) SHA224
mbed_official 532:fe11edbda85c 592 (+) SHA256
mbed_official 532:fe11edbda85c 593
mbed_official 532:fe11edbda85c 594 @endverbatim
mbed_official 532:fe11edbda85c 595 * @{
mbed_official 532:fe11edbda85c 596 */
mbed_official 532:fe11edbda85c 597
mbed_official 532:fe11edbda85c 598 /**
mbed_official 532:fe11edbda85c 599 * @brief Initializes the HASH peripheral in HMAC SHA224 mode
mbed_official 532:fe11edbda85c 600 * then processes pInBuffer. The digest is available in pOutBuffer.
mbed_official 532:fe11edbda85c 601 * @param hhash: pointer to a HASH_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 602 * the configuration information for HASH module
mbed_official 532:fe11edbda85c 603 * @param pInBuffer: Pointer to the input buffer (buffer to be hashed).
mbed_official 532:fe11edbda85c 604 * @param Size: Length of the input buffer in bytes.
mbed_official 532:fe11edbda85c 605 * If the Size is not multiple of 64 bytes, the padding is managed by hardware.
mbed_official 532:fe11edbda85c 606 * @param pOutBuffer: Pointer to the computed digest. Its size must be 20 bytes.
mbed_official 532:fe11edbda85c 607 * @param Timeout: Timeout value
mbed_official 532:fe11edbda85c 608 * @retval HAL status
mbed_official 532:fe11edbda85c 609 */
mbed_official 532:fe11edbda85c 610 HAL_StatusTypeDef HAL_HMACEx_SHA224_Start(HASH_HandleTypeDef *hhash, uint8_t *pInBuffer, uint32_t Size, uint8_t* pOutBuffer, uint32_t Timeout)
mbed_official 532:fe11edbda85c 611 {
mbed_official 532:fe11edbda85c 612 uint32_t tickstart = 0;
mbed_official 532:fe11edbda85c 613
mbed_official 532:fe11edbda85c 614 /* Process Locked */
mbed_official 532:fe11edbda85c 615 __HAL_LOCK(hhash);
mbed_official 532:fe11edbda85c 616
mbed_official 532:fe11edbda85c 617 /* Change the HASH state */
mbed_official 532:fe11edbda85c 618 hhash->State = HAL_HASH_STATE_BUSY;
mbed_official 532:fe11edbda85c 619
mbed_official 532:fe11edbda85c 620 /* Check if initialization phase has already been performed */
mbed_official 532:fe11edbda85c 621 if(hhash->Phase == HAL_HASH_PHASE_READY)
mbed_official 532:fe11edbda85c 622 {
mbed_official 532:fe11edbda85c 623 /* Check if key size is greater than 64 bytes */
mbed_official 532:fe11edbda85c 624 if(hhash->Init.KeySize > 64)
mbed_official 532:fe11edbda85c 625 {
mbed_official 532:fe11edbda85c 626 /* Select the HMAC SHA224 mode */
mbed_official 532:fe11edbda85c 627 HASH->CR |= (HASH_ALGOSELECTION_SHA224 | HASH_ALGOMODE_HMAC | HASH_HMAC_KEYTYPE_LONGKEY | HASH_CR_INIT);
mbed_official 532:fe11edbda85c 628 }
mbed_official 532:fe11edbda85c 629 else
mbed_official 532:fe11edbda85c 630 {
mbed_official 532:fe11edbda85c 631 /* Select the HMAC SHA224 mode */
mbed_official 532:fe11edbda85c 632 HASH->CR |= (HASH_ALGOSELECTION_SHA224 | HASH_ALGOMODE_HMAC | HASH_CR_INIT);
mbed_official 532:fe11edbda85c 633 }
mbed_official 532:fe11edbda85c 634 }
mbed_official 532:fe11edbda85c 635
mbed_official 532:fe11edbda85c 636 /* Set the phase */
mbed_official 532:fe11edbda85c 637 hhash->Phase = HAL_HASH_PHASE_PROCESS;
mbed_official 532:fe11edbda85c 638
mbed_official 532:fe11edbda85c 639 /************************** STEP 1 ******************************************/
mbed_official 532:fe11edbda85c 640 /* Configure the number of valid bits in last word of the message */
mbed_official 532:fe11edbda85c 641 __HAL_HASH_SET_NBVALIDBITS(hhash->Init.KeySize);
mbed_official 532:fe11edbda85c 642
mbed_official 532:fe11edbda85c 643 /* Write input buffer in data register */
mbed_official 532:fe11edbda85c 644 HASHEx_WriteData(hhash->Init.pKey, hhash->Init.KeySize);
mbed_official 532:fe11edbda85c 645
mbed_official 532:fe11edbda85c 646 /* Start the digest calculation */
mbed_official 532:fe11edbda85c 647 __HAL_HASH_START_DIGEST();
mbed_official 532:fe11edbda85c 648
mbed_official 532:fe11edbda85c 649 /* Get tick */
mbed_official 532:fe11edbda85c 650 tickstart = HAL_GetTick();
mbed_official 532:fe11edbda85c 651
mbed_official 532:fe11edbda85c 652 while((HASH->SR & HASH_FLAG_BUSY) == HASH_FLAG_BUSY)
mbed_official 532:fe11edbda85c 653 {
mbed_official 532:fe11edbda85c 654 /* Check for the Timeout */
mbed_official 532:fe11edbda85c 655 if(Timeout != HAL_MAX_DELAY)
mbed_official 532:fe11edbda85c 656 {
mbed_official 532:fe11edbda85c 657 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 532:fe11edbda85c 658 {
mbed_official 532:fe11edbda85c 659 /* Change state */
mbed_official 532:fe11edbda85c 660 hhash->State = HAL_HASH_STATE_TIMEOUT;
mbed_official 532:fe11edbda85c 661
mbed_official 532:fe11edbda85c 662 /* Process Unlocked */
mbed_official 532:fe11edbda85c 663 __HAL_UNLOCK(hhash);
mbed_official 532:fe11edbda85c 664
mbed_official 532:fe11edbda85c 665 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 666 }
mbed_official 532:fe11edbda85c 667 }
mbed_official 532:fe11edbda85c 668 }
mbed_official 532:fe11edbda85c 669 /************************** STEP 2 ******************************************/
mbed_official 532:fe11edbda85c 670 /* Configure the number of valid bits in last word of the message */
mbed_official 532:fe11edbda85c 671 __HAL_HASH_SET_NBVALIDBITS(Size);
mbed_official 532:fe11edbda85c 672
mbed_official 532:fe11edbda85c 673 /* Write input buffer in data register */
mbed_official 532:fe11edbda85c 674 HASHEx_WriteData(pInBuffer, Size);
mbed_official 532:fe11edbda85c 675
mbed_official 532:fe11edbda85c 676 /* Start the digest calculation */
mbed_official 532:fe11edbda85c 677 __HAL_HASH_START_DIGEST();
mbed_official 532:fe11edbda85c 678
mbed_official 532:fe11edbda85c 679 /* Get tick */
mbed_official 532:fe11edbda85c 680 tickstart = HAL_GetTick();
mbed_official 532:fe11edbda85c 681
mbed_official 532:fe11edbda85c 682 while((HASH->SR & HASH_FLAG_BUSY) == HASH_FLAG_BUSY)
mbed_official 532:fe11edbda85c 683 {
mbed_official 532:fe11edbda85c 684 /* Check for the Timeout */
mbed_official 532:fe11edbda85c 685 if(Timeout != HAL_MAX_DELAY)
mbed_official 532:fe11edbda85c 686 {
mbed_official 532:fe11edbda85c 687 if((HAL_GetTick() - tickstart ) > Timeout)
mbed_official 532:fe11edbda85c 688 {
mbed_official 532:fe11edbda85c 689 /* Change state */
mbed_official 532:fe11edbda85c 690 hhash->State = HAL_HASH_STATE_TIMEOUT;
mbed_official 532:fe11edbda85c 691
mbed_official 532:fe11edbda85c 692 /* Process Unlocked */
mbed_official 532:fe11edbda85c 693 __HAL_UNLOCK(hhash);
mbed_official 532:fe11edbda85c 694
mbed_official 532:fe11edbda85c 695 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 696 }
mbed_official 532:fe11edbda85c 697 }
mbed_official 532:fe11edbda85c 698 }
mbed_official 532:fe11edbda85c 699 /************************** STEP 3 ******************************************/
mbed_official 532:fe11edbda85c 700 /* Configure the number of valid bits in last word of the message */
mbed_official 532:fe11edbda85c 701 __HAL_HASH_SET_NBVALIDBITS(hhash->Init.KeySize);
mbed_official 532:fe11edbda85c 702
mbed_official 532:fe11edbda85c 703 /* Write input buffer in data register */
mbed_official 532:fe11edbda85c 704 HASHEx_WriteData(hhash->Init.pKey, hhash->Init.KeySize);
mbed_official 532:fe11edbda85c 705
mbed_official 532:fe11edbda85c 706 /* Start the digest calculation */
mbed_official 532:fe11edbda85c 707 __HAL_HASH_START_DIGEST();
mbed_official 532:fe11edbda85c 708
mbed_official 532:fe11edbda85c 709 /* Get tick */
mbed_official 532:fe11edbda85c 710 tickstart = HAL_GetTick();
mbed_official 532:fe11edbda85c 711
mbed_official 532:fe11edbda85c 712 while((HASH->SR & HASH_FLAG_BUSY) == HASH_FLAG_BUSY)
mbed_official 532:fe11edbda85c 713 {
mbed_official 532:fe11edbda85c 714 /* Check for the Timeout */
mbed_official 532:fe11edbda85c 715 if(Timeout != HAL_MAX_DELAY)
mbed_official 532:fe11edbda85c 716 {
mbed_official 532:fe11edbda85c 717 if((HAL_GetTick() - tickstart ) > Timeout)
mbed_official 532:fe11edbda85c 718 {
mbed_official 532:fe11edbda85c 719 /* Change state */
mbed_official 532:fe11edbda85c 720 hhash->State = HAL_HASH_STATE_TIMEOUT;
mbed_official 532:fe11edbda85c 721
mbed_official 532:fe11edbda85c 722 /* Process Unlocked */
mbed_official 532:fe11edbda85c 723 __HAL_UNLOCK(hhash);
mbed_official 532:fe11edbda85c 724
mbed_official 532:fe11edbda85c 725 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 726 }
mbed_official 532:fe11edbda85c 727 }
mbed_official 532:fe11edbda85c 728 }
mbed_official 532:fe11edbda85c 729 /* Read the message digest */
mbed_official 532:fe11edbda85c 730 HASHEx_GetDigest(pOutBuffer, 28);
mbed_official 532:fe11edbda85c 731
mbed_official 532:fe11edbda85c 732 /* Change the HASH state */
mbed_official 532:fe11edbda85c 733 hhash->State = HAL_HASH_STATE_READY;
mbed_official 532:fe11edbda85c 734
mbed_official 532:fe11edbda85c 735 /* Process Unlocked */
mbed_official 532:fe11edbda85c 736 __HAL_UNLOCK(hhash);
mbed_official 532:fe11edbda85c 737
mbed_official 532:fe11edbda85c 738 /* Return function status */
mbed_official 532:fe11edbda85c 739 return HAL_OK;
mbed_official 532:fe11edbda85c 740 }
mbed_official 532:fe11edbda85c 741
mbed_official 532:fe11edbda85c 742 /**
mbed_official 532:fe11edbda85c 743 * @brief Initializes the HASH peripheral in HMAC SHA256 mode
mbed_official 532:fe11edbda85c 744 * then processes pInBuffer. The digest is available in pOutBuffer
mbed_official 532:fe11edbda85c 745 * @param hhash: pointer to a HASH_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 746 * the configuration information for HASH module
mbed_official 532:fe11edbda85c 747 * @param pInBuffer: Pointer to the input buffer (buffer to be hashed).
mbed_official 532:fe11edbda85c 748 * @param Size: Length of the input buffer in bytes.
mbed_official 532:fe11edbda85c 749 * If the Size is not multiple of 64 bytes, the padding is managed by hardware.
mbed_official 532:fe11edbda85c 750 * @param pOutBuffer: Pointer to the computed digest. Its size must be 20 bytes.
mbed_official 532:fe11edbda85c 751 * @param Timeout: Timeout value
mbed_official 532:fe11edbda85c 752 * @retval HAL status
mbed_official 532:fe11edbda85c 753 */
mbed_official 532:fe11edbda85c 754 HAL_StatusTypeDef HAL_HMACEx_SHA256_Start(HASH_HandleTypeDef *hhash, uint8_t *pInBuffer, uint32_t Size, uint8_t* pOutBuffer, uint32_t Timeout)
mbed_official 532:fe11edbda85c 755 {
mbed_official 532:fe11edbda85c 756 uint32_t tickstart = 0;
mbed_official 532:fe11edbda85c 757
mbed_official 532:fe11edbda85c 758 /* Process Locked */
mbed_official 532:fe11edbda85c 759 __HAL_LOCK(hhash);
mbed_official 532:fe11edbda85c 760
mbed_official 532:fe11edbda85c 761 /* Change the HASH state */
mbed_official 532:fe11edbda85c 762 hhash->State = HAL_HASH_STATE_BUSY;
mbed_official 532:fe11edbda85c 763
mbed_official 532:fe11edbda85c 764 /* Check if initialization phase has already been performed */
mbed_official 532:fe11edbda85c 765 if(hhash->Phase == HAL_HASH_PHASE_READY)
mbed_official 532:fe11edbda85c 766 {
mbed_official 532:fe11edbda85c 767 /* Check if key size is greater than 64 bytes */
mbed_official 532:fe11edbda85c 768 if(hhash->Init.KeySize > 64)
mbed_official 532:fe11edbda85c 769 {
mbed_official 532:fe11edbda85c 770 /* Select the HMAC SHA256 mode */
mbed_official 532:fe11edbda85c 771 HASH->CR |= (HASH_ALGOSELECTION_SHA256 | HASH_ALGOMODE_HMAC | HASH_HMAC_KEYTYPE_LONGKEY);
mbed_official 532:fe11edbda85c 772 }
mbed_official 532:fe11edbda85c 773 else
mbed_official 532:fe11edbda85c 774 {
mbed_official 532:fe11edbda85c 775 /* Select the HMAC SHA256 mode */
mbed_official 532:fe11edbda85c 776 HASH->CR |= (HASH_ALGOSELECTION_SHA256 | HASH_ALGOMODE_HMAC);
mbed_official 532:fe11edbda85c 777 }
mbed_official 532:fe11edbda85c 778 /* Reset the HASH processor core, so that the HASH will be ready to compute
mbed_official 532:fe11edbda85c 779 the message digest of a new message */
mbed_official 532:fe11edbda85c 780 HASH->CR |= HASH_CR_INIT;
mbed_official 532:fe11edbda85c 781 }
mbed_official 532:fe11edbda85c 782
mbed_official 532:fe11edbda85c 783 /* Set the phase */
mbed_official 532:fe11edbda85c 784 hhash->Phase = HAL_HASH_PHASE_PROCESS;
mbed_official 532:fe11edbda85c 785
mbed_official 532:fe11edbda85c 786 /************************** STEP 1 ******************************************/
mbed_official 532:fe11edbda85c 787 /* Configure the number of valid bits in last word of the message */
mbed_official 532:fe11edbda85c 788 __HAL_HASH_SET_NBVALIDBITS(hhash->Init.KeySize);
mbed_official 532:fe11edbda85c 789
mbed_official 532:fe11edbda85c 790 /* Write input buffer in data register */
mbed_official 532:fe11edbda85c 791 HASHEx_WriteData(hhash->Init.pKey, hhash->Init.KeySize);
mbed_official 532:fe11edbda85c 792
mbed_official 532:fe11edbda85c 793 /* Start the digest calculation */
mbed_official 532:fe11edbda85c 794 __HAL_HASH_START_DIGEST();
mbed_official 532:fe11edbda85c 795
mbed_official 532:fe11edbda85c 796 /* Get tick */
mbed_official 532:fe11edbda85c 797 tickstart = HAL_GetTick();
mbed_official 532:fe11edbda85c 798
mbed_official 532:fe11edbda85c 799 while((HASH->SR & HASH_FLAG_BUSY) == HASH_FLAG_BUSY)
mbed_official 532:fe11edbda85c 800 {
mbed_official 532:fe11edbda85c 801 /* Check for the Timeout */
mbed_official 532:fe11edbda85c 802 if(Timeout != HAL_MAX_DELAY)
mbed_official 532:fe11edbda85c 803 {
mbed_official 532:fe11edbda85c 804 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 532:fe11edbda85c 805 {
mbed_official 532:fe11edbda85c 806 /* Change state */
mbed_official 532:fe11edbda85c 807 hhash->State = HAL_HASH_STATE_TIMEOUT;
mbed_official 532:fe11edbda85c 808
mbed_official 532:fe11edbda85c 809 /* Process Unlocked */
mbed_official 532:fe11edbda85c 810 __HAL_UNLOCK(hhash);
mbed_official 532:fe11edbda85c 811
mbed_official 532:fe11edbda85c 812 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 813 }
mbed_official 532:fe11edbda85c 814 }
mbed_official 532:fe11edbda85c 815 }
mbed_official 532:fe11edbda85c 816 /************************** STEP 2 ******************************************/
mbed_official 532:fe11edbda85c 817 /* Configure the number of valid bits in last word of the message */
mbed_official 532:fe11edbda85c 818 __HAL_HASH_SET_NBVALIDBITS(Size);
mbed_official 532:fe11edbda85c 819
mbed_official 532:fe11edbda85c 820 /* Write input buffer in data register */
mbed_official 532:fe11edbda85c 821 HASHEx_WriteData(pInBuffer, Size);
mbed_official 532:fe11edbda85c 822
mbed_official 532:fe11edbda85c 823 /* Start the digest calculation */
mbed_official 532:fe11edbda85c 824 __HAL_HASH_START_DIGEST();
mbed_official 532:fe11edbda85c 825
mbed_official 532:fe11edbda85c 826 /* Get tick */
mbed_official 532:fe11edbda85c 827 tickstart = HAL_GetTick();
mbed_official 532:fe11edbda85c 828
mbed_official 532:fe11edbda85c 829 while((HASH->SR & HASH_FLAG_BUSY) == HASH_FLAG_BUSY)
mbed_official 532:fe11edbda85c 830 {
mbed_official 532:fe11edbda85c 831 /* Check for the Timeout */
mbed_official 532:fe11edbda85c 832 if(Timeout != HAL_MAX_DELAY)
mbed_official 532:fe11edbda85c 833 {
mbed_official 532:fe11edbda85c 834 if((HAL_GetTick() - tickstart ) > Timeout)
mbed_official 532:fe11edbda85c 835 {
mbed_official 532:fe11edbda85c 836 /* Change state */
mbed_official 532:fe11edbda85c 837 hhash->State = HAL_HASH_STATE_TIMEOUT;
mbed_official 532:fe11edbda85c 838
mbed_official 532:fe11edbda85c 839 /* Process Unlocked */
mbed_official 532:fe11edbda85c 840 __HAL_UNLOCK(hhash);
mbed_official 532:fe11edbda85c 841
mbed_official 532:fe11edbda85c 842 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 843 }
mbed_official 532:fe11edbda85c 844 }
mbed_official 532:fe11edbda85c 845 }
mbed_official 532:fe11edbda85c 846 /************************** STEP 3 ******************************************/
mbed_official 532:fe11edbda85c 847 /* Configure the number of valid bits in last word of the message */
mbed_official 532:fe11edbda85c 848 __HAL_HASH_SET_NBVALIDBITS(hhash->Init.KeySize);
mbed_official 532:fe11edbda85c 849
mbed_official 532:fe11edbda85c 850 /* Write input buffer in data register */
mbed_official 532:fe11edbda85c 851 HASHEx_WriteData(hhash->Init.pKey, hhash->Init.KeySize);
mbed_official 532:fe11edbda85c 852
mbed_official 532:fe11edbda85c 853 /* Start the digest calculation */
mbed_official 532:fe11edbda85c 854 __HAL_HASH_START_DIGEST();
mbed_official 532:fe11edbda85c 855
mbed_official 532:fe11edbda85c 856 /* Get tick */
mbed_official 532:fe11edbda85c 857 tickstart = HAL_GetTick();
mbed_official 532:fe11edbda85c 858
mbed_official 532:fe11edbda85c 859 while((HASH->SR & HASH_FLAG_BUSY) == HASH_FLAG_BUSY)
mbed_official 532:fe11edbda85c 860 {
mbed_official 532:fe11edbda85c 861 /* Check for the Timeout */
mbed_official 532:fe11edbda85c 862 if(Timeout != HAL_MAX_DELAY)
mbed_official 532:fe11edbda85c 863 {
mbed_official 532:fe11edbda85c 864 if((HAL_GetTick() - tickstart ) > Timeout)
mbed_official 532:fe11edbda85c 865 {
mbed_official 532:fe11edbda85c 866 /* Change state */
mbed_official 532:fe11edbda85c 867 hhash->State = HAL_HASH_STATE_TIMEOUT;
mbed_official 532:fe11edbda85c 868
mbed_official 532:fe11edbda85c 869 /* Process Unlocked */
mbed_official 532:fe11edbda85c 870 __HAL_UNLOCK(hhash);
mbed_official 532:fe11edbda85c 871
mbed_official 532:fe11edbda85c 872 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 873 }
mbed_official 532:fe11edbda85c 874 }
mbed_official 532:fe11edbda85c 875 }
mbed_official 532:fe11edbda85c 876 /* Read the message digest */
mbed_official 532:fe11edbda85c 877 HASHEx_GetDigest(pOutBuffer, 32);
mbed_official 532:fe11edbda85c 878
mbed_official 532:fe11edbda85c 879 /* Change the HASH state */
mbed_official 532:fe11edbda85c 880 hhash->State = HAL_HASH_STATE_READY;
mbed_official 532:fe11edbda85c 881
mbed_official 532:fe11edbda85c 882 /* Process Unlocked */
mbed_official 532:fe11edbda85c 883 __HAL_UNLOCK(hhash);
mbed_official 532:fe11edbda85c 884
mbed_official 532:fe11edbda85c 885 /* Return function status */
mbed_official 532:fe11edbda85c 886 return HAL_OK;
mbed_official 532:fe11edbda85c 887 }
mbed_official 532:fe11edbda85c 888
mbed_official 532:fe11edbda85c 889 /**
mbed_official 532:fe11edbda85c 890 * @}
mbed_official 532:fe11edbda85c 891 */
mbed_official 532:fe11edbda85c 892
mbed_official 532:fe11edbda85c 893 /** @defgroup HASHEx_Group3 HASH processing functions using interrupt mode
mbed_official 532:fe11edbda85c 894 * @brief processing functions using interrupt mode.
mbed_official 532:fe11edbda85c 895 *
mbed_official 532:fe11edbda85c 896 @verbatim
mbed_official 532:fe11edbda85c 897 ===============================================================================
mbed_official 532:fe11edbda85c 898 ##### HASH processing using interrupt functions #####
mbed_official 532:fe11edbda85c 899 ===============================================================================
mbed_official 532:fe11edbda85c 900 [..] This section provides functions allowing to calculate in interrupt mode
mbed_official 532:fe11edbda85c 901 the hash value using one of the following algorithms:
mbed_official 532:fe11edbda85c 902 (+) SHA224
mbed_official 532:fe11edbda85c 903 (+) SHA256
mbed_official 532:fe11edbda85c 904
mbed_official 532:fe11edbda85c 905 @endverbatim
mbed_official 532:fe11edbda85c 906 * @{
mbed_official 532:fe11edbda85c 907 */
mbed_official 532:fe11edbda85c 908
mbed_official 532:fe11edbda85c 909 /**
mbed_official 532:fe11edbda85c 910 * @brief Initializes the HASH peripheral in SHA224 mode then processes pInBuffer.
mbed_official 532:fe11edbda85c 911 * The digest is available in pOutBuffer.
mbed_official 532:fe11edbda85c 912 * @param hhash: pointer to a HASH_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 913 * the configuration information for HASH module
mbed_official 532:fe11edbda85c 914 * @param pInBuffer: Pointer to the input buffer (buffer to be hashed).
mbed_official 532:fe11edbda85c 915 * @param Size: Length of the input buffer in bytes.
mbed_official 532:fe11edbda85c 916 * If the Size is not multiple of 64 bytes, the padding is managed by hardware.
mbed_official 532:fe11edbda85c 917 * @param pOutBuffer: Pointer to the computed digest. Its size must be 20 bytes.
mbed_official 532:fe11edbda85c 918 * @retval HAL status
mbed_official 532:fe11edbda85c 919 */
mbed_official 532:fe11edbda85c 920 HAL_StatusTypeDef HAL_HASHEx_SHA224_Start_IT(HASH_HandleTypeDef *hhash, uint8_t *pInBuffer, uint32_t Size, uint8_t* pOutBuffer)
mbed_official 532:fe11edbda85c 921 {
mbed_official 532:fe11edbda85c 922 uint32_t inputaddr;
mbed_official 532:fe11edbda85c 923 uint32_t buffercounter;
mbed_official 532:fe11edbda85c 924 uint32_t inputcounter;
mbed_official 532:fe11edbda85c 925
mbed_official 532:fe11edbda85c 926 /* Process Locked */
mbed_official 532:fe11edbda85c 927 __HAL_LOCK(hhash);
mbed_official 532:fe11edbda85c 928
mbed_official 532:fe11edbda85c 929 if(hhash->State == HAL_HASH_STATE_READY)
mbed_official 532:fe11edbda85c 930 {
mbed_official 532:fe11edbda85c 931 /* Change the HASH state */
mbed_official 532:fe11edbda85c 932 hhash->State = HAL_HASH_STATE_BUSY;
mbed_official 532:fe11edbda85c 933
mbed_official 532:fe11edbda85c 934 hhash->HashInCount = Size;
mbed_official 532:fe11edbda85c 935 hhash->pHashInBuffPtr = pInBuffer;
mbed_official 532:fe11edbda85c 936 hhash->pHashOutBuffPtr = pOutBuffer;
mbed_official 532:fe11edbda85c 937
mbed_official 532:fe11edbda85c 938 /* Check if initialization phase has already been performed */
mbed_official 532:fe11edbda85c 939 if(hhash->Phase == HAL_HASH_PHASE_READY)
mbed_official 532:fe11edbda85c 940 {
mbed_official 532:fe11edbda85c 941 /* Select the SHA224 mode */
mbed_official 532:fe11edbda85c 942 HASH->CR |= HASH_ALGOSELECTION_SHA224;
mbed_official 532:fe11edbda85c 943 /* Reset the HASH processor core, so that the HASH will be ready to compute
mbed_official 532:fe11edbda85c 944 the message digest of a new message */
mbed_official 532:fe11edbda85c 945 HASH->CR |= HASH_CR_INIT;
mbed_official 532:fe11edbda85c 946 }
mbed_official 532:fe11edbda85c 947
mbed_official 613:bc40b8d2aec4 948 /* Reset interrupt counter */
mbed_official 613:bc40b8d2aec4 949 hhash->HashITCounter = 0;
mbed_official 613:bc40b8d2aec4 950
mbed_official 532:fe11edbda85c 951 /* Set the phase */
mbed_official 532:fe11edbda85c 952 hhash->Phase = HAL_HASH_PHASE_PROCESS;
mbed_official 532:fe11edbda85c 953
mbed_official 532:fe11edbda85c 954 /* Process Unlocked */
mbed_official 532:fe11edbda85c 955 __HAL_UNLOCK(hhash);
mbed_official 532:fe11edbda85c 956
mbed_official 532:fe11edbda85c 957 /* Enable Interrupts */
mbed_official 532:fe11edbda85c 958 HASH->IMR = (HASH_IT_DINI | HASH_IT_DCI);
mbed_official 532:fe11edbda85c 959
mbed_official 532:fe11edbda85c 960 /* Return function status */
mbed_official 532:fe11edbda85c 961 return HAL_OK;
mbed_official 532:fe11edbda85c 962 }
mbed_official 532:fe11edbda85c 963 if(__HAL_HASH_GET_FLAG(HASH_FLAG_DCIS))
mbed_official 532:fe11edbda85c 964 {
mbed_official 532:fe11edbda85c 965 /* Read the message digest */
mbed_official 532:fe11edbda85c 966 HASHEx_GetDigest(hhash->pHashOutBuffPtr, 28);
mbed_official 532:fe11edbda85c 967 if(hhash->HashInCount == 0)
mbed_official 532:fe11edbda85c 968 {
mbed_official 532:fe11edbda85c 969 /* Disable Interrupts */
mbed_official 532:fe11edbda85c 970 HASH->IMR = 0;
mbed_official 532:fe11edbda85c 971 /* Change the HASH state */
mbed_official 532:fe11edbda85c 972 hhash->State = HAL_HASH_STATE_READY;
mbed_official 532:fe11edbda85c 973 /* Call digest computation complete callback */
mbed_official 532:fe11edbda85c 974 HAL_HASH_DgstCpltCallback(hhash);
mbed_official 613:bc40b8d2aec4 975
mbed_official 613:bc40b8d2aec4 976 /* Process Unlocked */
mbed_official 613:bc40b8d2aec4 977 __HAL_UNLOCK(hhash);
mbed_official 613:bc40b8d2aec4 978
mbed_official 613:bc40b8d2aec4 979 /* Return function status */
mbed_official 613:bc40b8d2aec4 980 return HAL_OK;
mbed_official 532:fe11edbda85c 981 }
mbed_official 532:fe11edbda85c 982 }
mbed_official 532:fe11edbda85c 983 if(__HAL_HASH_GET_FLAG(HASH_FLAG_DINIS))
mbed_official 532:fe11edbda85c 984 {
mbed_official 613:bc40b8d2aec4 985 if(hhash->HashInCount >= 68)
mbed_official 532:fe11edbda85c 986 {
mbed_official 532:fe11edbda85c 987 inputaddr = (uint32_t)hhash->pHashInBuffPtr;
mbed_official 532:fe11edbda85c 988 /* Write the Input block in the Data IN register */
mbed_official 532:fe11edbda85c 989 for(buffercounter = 0; buffercounter < 64; buffercounter+=4)
mbed_official 532:fe11edbda85c 990 {
mbed_official 532:fe11edbda85c 991 HASH->DIN = *(uint32_t*)inputaddr;
mbed_official 532:fe11edbda85c 992 inputaddr+=4;
mbed_official 532:fe11edbda85c 993 }
mbed_official 532:fe11edbda85c 994 if(hhash->HashITCounter == 0)
mbed_official 532:fe11edbda85c 995 {
mbed_official 532:fe11edbda85c 996 HASH->DIN = *(uint32_t*)inputaddr;
mbed_official 613:bc40b8d2aec4 997
mbed_official 532:fe11edbda85c 998 if(hhash->HashInCount >= 68)
mbed_official 532:fe11edbda85c 999 {
mbed_official 532:fe11edbda85c 1000 /* Decrement buffer counter */
mbed_official 532:fe11edbda85c 1001 hhash->HashInCount -= 68;
mbed_official 532:fe11edbda85c 1002 hhash->pHashInBuffPtr+= 68;
mbed_official 532:fe11edbda85c 1003 }
mbed_official 532:fe11edbda85c 1004 else
mbed_official 532:fe11edbda85c 1005 {
mbed_official 613:bc40b8d2aec4 1006 hhash->HashInCount = 0;
mbed_official 613:bc40b8d2aec4 1007 hhash->pHashInBuffPtr+= hhash->HashInCount;
mbed_official 532:fe11edbda85c 1008 }
mbed_official 613:bc40b8d2aec4 1009 /* Set Interrupt counter */
mbed_official 613:bc40b8d2aec4 1010 hhash->HashITCounter = 1;
mbed_official 532:fe11edbda85c 1011 }
mbed_official 532:fe11edbda85c 1012 else
mbed_official 532:fe11edbda85c 1013 {
mbed_official 532:fe11edbda85c 1014 /* Decrement buffer counter */
mbed_official 532:fe11edbda85c 1015 hhash->HashInCount -= 64;
mbed_official 532:fe11edbda85c 1016 hhash->pHashInBuffPtr+= 64;
mbed_official 532:fe11edbda85c 1017 }
mbed_official 532:fe11edbda85c 1018 }
mbed_official 532:fe11edbda85c 1019 else
mbed_official 532:fe11edbda85c 1020 {
mbed_official 532:fe11edbda85c 1021 /* Get the buffer address */
mbed_official 532:fe11edbda85c 1022 inputaddr = (uint32_t)hhash->pHashInBuffPtr;
mbed_official 532:fe11edbda85c 1023 /* Get the buffer counter */
mbed_official 532:fe11edbda85c 1024 inputcounter = hhash->HashInCount;
mbed_official 532:fe11edbda85c 1025 /* Disable Interrupts */
mbed_official 532:fe11edbda85c 1026 HASH->IMR &= ~(HASH_IT_DINI);
mbed_official 532:fe11edbda85c 1027 /* Configure the number of valid bits in last word of the message */
mbed_official 532:fe11edbda85c 1028 __HAL_HASH_SET_NBVALIDBITS(inputcounter);
mbed_official 532:fe11edbda85c 1029
mbed_official 532:fe11edbda85c 1030 if((inputcounter > 4) && (inputcounter%4))
mbed_official 532:fe11edbda85c 1031 {
mbed_official 532:fe11edbda85c 1032 inputcounter = (inputcounter+4-inputcounter%4);
mbed_official 532:fe11edbda85c 1033 }
mbed_official 613:bc40b8d2aec4 1034 else if ((inputcounter < 4) && (inputcounter != 0))
mbed_official 613:bc40b8d2aec4 1035 {
mbed_official 613:bc40b8d2aec4 1036 inputcounter = 4;
mbed_official 613:bc40b8d2aec4 1037 }
mbed_official 532:fe11edbda85c 1038 /* Write the Input block in the Data IN register */
mbed_official 532:fe11edbda85c 1039 for(buffercounter = 0; buffercounter < inputcounter/4; buffercounter++)
mbed_official 532:fe11edbda85c 1040 {
mbed_official 532:fe11edbda85c 1041 HASH->DIN = *(uint32_t*)inputaddr;
mbed_official 532:fe11edbda85c 1042 inputaddr+=4;
mbed_official 532:fe11edbda85c 1043 }
mbed_official 532:fe11edbda85c 1044 /* Start the digest calculation */
mbed_official 532:fe11edbda85c 1045 __HAL_HASH_START_DIGEST();
mbed_official 532:fe11edbda85c 1046 /* Reset buffer counter */
mbed_official 532:fe11edbda85c 1047 hhash->HashInCount = 0;
mbed_official 613:bc40b8d2aec4 1048
mbed_official 613:bc40b8d2aec4 1049 /* Call Input data transfer complete callback */
mbed_official 613:bc40b8d2aec4 1050 HAL_HASH_InCpltCallback(hhash);
mbed_official 532:fe11edbda85c 1051 }
mbed_official 532:fe11edbda85c 1052 }
mbed_official 532:fe11edbda85c 1053
mbed_official 532:fe11edbda85c 1054 /* Process Unlocked */
mbed_official 532:fe11edbda85c 1055 __HAL_UNLOCK(hhash);
mbed_official 532:fe11edbda85c 1056
mbed_official 532:fe11edbda85c 1057 /* Return function status */
mbed_official 532:fe11edbda85c 1058 return HAL_OK;
mbed_official 532:fe11edbda85c 1059 }
mbed_official 532:fe11edbda85c 1060
mbed_official 532:fe11edbda85c 1061
mbed_official 532:fe11edbda85c 1062 /**
mbed_official 532:fe11edbda85c 1063 * @brief Initializes the HASH peripheral in SHA256 mode then processes pInBuffer.
mbed_official 532:fe11edbda85c 1064 * The digest is available in pOutBuffer.
mbed_official 532:fe11edbda85c 1065 * @param hhash: pointer to a HASH_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 1066 * the configuration information for HASH module
mbed_official 532:fe11edbda85c 1067 * @param pInBuffer: Pointer to the input buffer (buffer to be hashed).
mbed_official 532:fe11edbda85c 1068 * @param Size: Length of the input buffer in bytes.
mbed_official 532:fe11edbda85c 1069 * If the Size is not multiple of 64 bytes, the padding is managed by hardware.
mbed_official 532:fe11edbda85c 1070 * @param pOutBuffer: Pointer to the computed digest. Its size must be 20 bytes.
mbed_official 532:fe11edbda85c 1071 * @retval HAL status
mbed_official 532:fe11edbda85c 1072 */
mbed_official 532:fe11edbda85c 1073 HAL_StatusTypeDef HAL_HASHEx_SHA256_Start_IT(HASH_HandleTypeDef *hhash, uint8_t *pInBuffer, uint32_t Size, uint8_t* pOutBuffer)
mbed_official 532:fe11edbda85c 1074 {
mbed_official 532:fe11edbda85c 1075 uint32_t inputaddr;
mbed_official 532:fe11edbda85c 1076 uint32_t buffercounter;
mbed_official 532:fe11edbda85c 1077 uint32_t inputcounter;
mbed_official 532:fe11edbda85c 1078
mbed_official 532:fe11edbda85c 1079 /* Process Locked */
mbed_official 532:fe11edbda85c 1080 __HAL_LOCK(hhash);
mbed_official 532:fe11edbda85c 1081
mbed_official 532:fe11edbda85c 1082 if(hhash->State == HAL_HASH_STATE_READY)
mbed_official 532:fe11edbda85c 1083 {
mbed_official 532:fe11edbda85c 1084 /* Change the HASH state */
mbed_official 532:fe11edbda85c 1085 hhash->State = HAL_HASH_STATE_BUSY;
mbed_official 532:fe11edbda85c 1086
mbed_official 532:fe11edbda85c 1087 hhash->HashInCount = Size;
mbed_official 532:fe11edbda85c 1088 hhash->pHashInBuffPtr = pInBuffer;
mbed_official 532:fe11edbda85c 1089 hhash->pHashOutBuffPtr = pOutBuffer;
mbed_official 532:fe11edbda85c 1090
mbed_official 532:fe11edbda85c 1091 /* Check if initialization phase has already been performed */
mbed_official 532:fe11edbda85c 1092 if(hhash->Phase == HAL_HASH_PHASE_READY)
mbed_official 532:fe11edbda85c 1093 {
mbed_official 532:fe11edbda85c 1094 /* Select the SHA256 mode */
mbed_official 532:fe11edbda85c 1095 HASH->CR |= HASH_ALGOSELECTION_SHA256;
mbed_official 532:fe11edbda85c 1096 /* Reset the HASH processor core, so that the HASH will be ready to compute
mbed_official 532:fe11edbda85c 1097 the message digest of a new message */
mbed_official 532:fe11edbda85c 1098 HASH->CR |= HASH_CR_INIT;
mbed_official 532:fe11edbda85c 1099 }
mbed_official 532:fe11edbda85c 1100
mbed_official 613:bc40b8d2aec4 1101 /* Reset interrupt counter */
mbed_official 613:bc40b8d2aec4 1102 hhash->HashITCounter = 0;
mbed_official 613:bc40b8d2aec4 1103
mbed_official 532:fe11edbda85c 1104 /* Set the phase */
mbed_official 532:fe11edbda85c 1105 hhash->Phase = HAL_HASH_PHASE_PROCESS;
mbed_official 532:fe11edbda85c 1106
mbed_official 532:fe11edbda85c 1107 /* Process Unlocked */
mbed_official 532:fe11edbda85c 1108 __HAL_UNLOCK(hhash);
mbed_official 532:fe11edbda85c 1109
mbed_official 532:fe11edbda85c 1110 /* Enable Interrupts */
mbed_official 532:fe11edbda85c 1111 HASH->IMR = (HASH_IT_DINI | HASH_IT_DCI);
mbed_official 532:fe11edbda85c 1112
mbed_official 532:fe11edbda85c 1113 /* Return function status */
mbed_official 532:fe11edbda85c 1114 return HAL_OK;
mbed_official 532:fe11edbda85c 1115 }
mbed_official 532:fe11edbda85c 1116 if(__HAL_HASH_GET_FLAG(HASH_FLAG_DCIS))
mbed_official 532:fe11edbda85c 1117 {
mbed_official 532:fe11edbda85c 1118 /* Read the message digest */
mbed_official 532:fe11edbda85c 1119 HASHEx_GetDigest(hhash->pHashOutBuffPtr, 32);
mbed_official 532:fe11edbda85c 1120 if(hhash->HashInCount == 0)
mbed_official 532:fe11edbda85c 1121 {
mbed_official 532:fe11edbda85c 1122 /* Disable Interrupts */
mbed_official 532:fe11edbda85c 1123 HASH->IMR = 0;
mbed_official 532:fe11edbda85c 1124 /* Change the HASH state */
mbed_official 532:fe11edbda85c 1125 hhash->State = HAL_HASH_STATE_READY;
mbed_official 532:fe11edbda85c 1126 /* Call digest computation complete callback */
mbed_official 532:fe11edbda85c 1127 HAL_HASH_DgstCpltCallback(hhash);
mbed_official 613:bc40b8d2aec4 1128
mbed_official 613:bc40b8d2aec4 1129 /* Process Unlocked */
mbed_official 613:bc40b8d2aec4 1130 __HAL_UNLOCK(hhash);
mbed_official 613:bc40b8d2aec4 1131
mbed_official 613:bc40b8d2aec4 1132 /* Return function status */
mbed_official 613:bc40b8d2aec4 1133 return HAL_OK;
mbed_official 532:fe11edbda85c 1134 }
mbed_official 532:fe11edbda85c 1135 }
mbed_official 532:fe11edbda85c 1136 if(__HAL_HASH_GET_FLAG(HASH_FLAG_DINIS))
mbed_official 532:fe11edbda85c 1137 {
mbed_official 613:bc40b8d2aec4 1138 if(hhash->HashInCount >= 68)
mbed_official 532:fe11edbda85c 1139 {
mbed_official 532:fe11edbda85c 1140 inputaddr = (uint32_t)hhash->pHashInBuffPtr;
mbed_official 532:fe11edbda85c 1141 /* Write the Input block in the Data IN register */
mbed_official 532:fe11edbda85c 1142 for(buffercounter = 0; buffercounter < 64; buffercounter+=4)
mbed_official 532:fe11edbda85c 1143 {
mbed_official 532:fe11edbda85c 1144 HASH->DIN = *(uint32_t*)inputaddr;
mbed_official 532:fe11edbda85c 1145 inputaddr+=4;
mbed_official 532:fe11edbda85c 1146 }
mbed_official 532:fe11edbda85c 1147 if(hhash->HashITCounter == 0)
mbed_official 532:fe11edbda85c 1148 {
mbed_official 532:fe11edbda85c 1149 HASH->DIN = *(uint32_t*)inputaddr;
mbed_official 613:bc40b8d2aec4 1150
mbed_official 532:fe11edbda85c 1151 if(hhash->HashInCount >= 68)
mbed_official 532:fe11edbda85c 1152 {
mbed_official 532:fe11edbda85c 1153 /* Decrement buffer counter */
mbed_official 532:fe11edbda85c 1154 hhash->HashInCount -= 68;
mbed_official 532:fe11edbda85c 1155 hhash->pHashInBuffPtr+= 68;
mbed_official 532:fe11edbda85c 1156 }
mbed_official 532:fe11edbda85c 1157 else
mbed_official 532:fe11edbda85c 1158 {
mbed_official 613:bc40b8d2aec4 1159 hhash->HashInCount = 0;
mbed_official 613:bc40b8d2aec4 1160 hhash->pHashInBuffPtr+= hhash->HashInCount;
mbed_official 532:fe11edbda85c 1161 }
mbed_official 613:bc40b8d2aec4 1162 /* Set Interrupt counter */
mbed_official 613:bc40b8d2aec4 1163 hhash->HashITCounter = 1;
mbed_official 532:fe11edbda85c 1164 }
mbed_official 532:fe11edbda85c 1165 else
mbed_official 532:fe11edbda85c 1166 {
mbed_official 532:fe11edbda85c 1167 /* Decrement buffer counter */
mbed_official 532:fe11edbda85c 1168 hhash->HashInCount -= 64;
mbed_official 532:fe11edbda85c 1169 hhash->pHashInBuffPtr+= 64;
mbed_official 532:fe11edbda85c 1170 }
mbed_official 532:fe11edbda85c 1171 }
mbed_official 532:fe11edbda85c 1172 else
mbed_official 532:fe11edbda85c 1173 {
mbed_official 532:fe11edbda85c 1174 /* Get the buffer address */
mbed_official 532:fe11edbda85c 1175 inputaddr = (uint32_t)hhash->pHashInBuffPtr;
mbed_official 532:fe11edbda85c 1176 /* Get the buffer counter */
mbed_official 532:fe11edbda85c 1177 inputcounter = hhash->HashInCount;
mbed_official 532:fe11edbda85c 1178 /* Disable Interrupts */
mbed_official 532:fe11edbda85c 1179 HASH->IMR &= ~(HASH_IT_DINI);
mbed_official 532:fe11edbda85c 1180 /* Configure the number of valid bits in last word of the message */
mbed_official 532:fe11edbda85c 1181 __HAL_HASH_SET_NBVALIDBITS(inputcounter);
mbed_official 532:fe11edbda85c 1182
mbed_official 532:fe11edbda85c 1183 if((inputcounter > 4) && (inputcounter%4))
mbed_official 532:fe11edbda85c 1184 {
mbed_official 532:fe11edbda85c 1185 inputcounter = (inputcounter+4-inputcounter%4);
mbed_official 532:fe11edbda85c 1186 }
mbed_official 613:bc40b8d2aec4 1187 else if ((inputcounter < 4) && (inputcounter != 0))
mbed_official 613:bc40b8d2aec4 1188 {
mbed_official 613:bc40b8d2aec4 1189 inputcounter = 4;
mbed_official 613:bc40b8d2aec4 1190 }
mbed_official 532:fe11edbda85c 1191 /* Write the Input block in the Data IN register */
mbed_official 532:fe11edbda85c 1192 for(buffercounter = 0; buffercounter < inputcounter/4; buffercounter++)
mbed_official 532:fe11edbda85c 1193 {
mbed_official 532:fe11edbda85c 1194 HASH->DIN = *(uint32_t*)inputaddr;
mbed_official 532:fe11edbda85c 1195 inputaddr+=4;
mbed_official 532:fe11edbda85c 1196 }
mbed_official 532:fe11edbda85c 1197 /* Start the digest calculation */
mbed_official 532:fe11edbda85c 1198 __HAL_HASH_START_DIGEST();
mbed_official 532:fe11edbda85c 1199 /* Reset buffer counter */
mbed_official 532:fe11edbda85c 1200 hhash->HashInCount = 0;
mbed_official 613:bc40b8d2aec4 1201
mbed_official 613:bc40b8d2aec4 1202 /* Call Input data transfer complete callback */
mbed_official 613:bc40b8d2aec4 1203 HAL_HASH_InCpltCallback(hhash);
mbed_official 532:fe11edbda85c 1204 }
mbed_official 532:fe11edbda85c 1205 }
mbed_official 532:fe11edbda85c 1206
mbed_official 532:fe11edbda85c 1207 /* Process Unlocked */
mbed_official 532:fe11edbda85c 1208 __HAL_UNLOCK(hhash);
mbed_official 532:fe11edbda85c 1209
mbed_official 532:fe11edbda85c 1210 /* Return function status */
mbed_official 532:fe11edbda85c 1211 return HAL_OK;
mbed_official 532:fe11edbda85c 1212 }
mbed_official 532:fe11edbda85c 1213
mbed_official 532:fe11edbda85c 1214 /**
mbed_official 532:fe11edbda85c 1215 * @brief This function handles HASH interrupt request.
mbed_official 532:fe11edbda85c 1216 * @param hhash: pointer to a HASH_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 1217 * the configuration information for HASH module
mbed_official 532:fe11edbda85c 1218 * @retval None
mbed_official 532:fe11edbda85c 1219 */
mbed_official 532:fe11edbda85c 1220 void HAL_HASHEx_IRQHandler(HASH_HandleTypeDef *hhash)
mbed_official 532:fe11edbda85c 1221 {
mbed_official 532:fe11edbda85c 1222 switch(HASH->CR & HASH_CR_ALGO)
mbed_official 532:fe11edbda85c 1223 {
mbed_official 532:fe11edbda85c 1224
mbed_official 532:fe11edbda85c 1225 case HASH_ALGOSELECTION_SHA224:
mbed_official 613:bc40b8d2aec4 1226 HAL_HASHEx_SHA224_Start_IT(hhash, NULL, 0, NULL);
mbed_official 532:fe11edbda85c 1227 break;
mbed_official 532:fe11edbda85c 1228
mbed_official 532:fe11edbda85c 1229 case HASH_ALGOSELECTION_SHA256:
mbed_official 613:bc40b8d2aec4 1230 HAL_HASHEx_SHA256_Start_IT(hhash, NULL, 0, NULL);
mbed_official 532:fe11edbda85c 1231 break;
mbed_official 532:fe11edbda85c 1232
mbed_official 532:fe11edbda85c 1233 default:
mbed_official 532:fe11edbda85c 1234 break;
mbed_official 532:fe11edbda85c 1235 }
mbed_official 532:fe11edbda85c 1236 }
mbed_official 532:fe11edbda85c 1237
mbed_official 532:fe11edbda85c 1238 /**
mbed_official 532:fe11edbda85c 1239 * @}
mbed_official 532:fe11edbda85c 1240 */
mbed_official 532:fe11edbda85c 1241
mbed_official 532:fe11edbda85c 1242 /** @defgroup HASHEx_Group4 HASH processing functions using DMA mode
mbed_official 532:fe11edbda85c 1243 * @brief processing functions using DMA mode.
mbed_official 532:fe11edbda85c 1244 *
mbed_official 532:fe11edbda85c 1245 @verbatim
mbed_official 532:fe11edbda85c 1246 ===============================================================================
mbed_official 532:fe11edbda85c 1247 ##### HASH processing using DMA functions #####
mbed_official 532:fe11edbda85c 1248 ===============================================================================
mbed_official 532:fe11edbda85c 1249 [..] This section provides functions allowing to calculate in DMA mode
mbed_official 532:fe11edbda85c 1250 the hash value using one of the following algorithms:
mbed_official 532:fe11edbda85c 1251 (+) SHA224
mbed_official 532:fe11edbda85c 1252 (+) SHA256
mbed_official 532:fe11edbda85c 1253
mbed_official 532:fe11edbda85c 1254 @endverbatim
mbed_official 532:fe11edbda85c 1255 * @{
mbed_official 532:fe11edbda85c 1256 */
mbed_official 532:fe11edbda85c 1257
mbed_official 532:fe11edbda85c 1258
mbed_official 532:fe11edbda85c 1259 /**
mbed_official 532:fe11edbda85c 1260 * @brief Initializes the HASH peripheral in SHA224 mode then enables DMA to
mbed_official 532:fe11edbda85c 1261 control data transfer. Use HAL_HASH_SHA224_Finish() to get the digest.
mbed_official 532:fe11edbda85c 1262 * @param hhash: pointer to a HASH_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 1263 * the configuration information for HASH module
mbed_official 532:fe11edbda85c 1264 * @param pInBuffer: Pointer to the input buffer (buffer to be hashed).
mbed_official 532:fe11edbda85c 1265 * @param Size: Length of the input buffer in bytes.
mbed_official 532:fe11edbda85c 1266 * If the Size is not multiple of 64 bytes, the padding is managed by hardware.
mbed_official 532:fe11edbda85c 1267 * @retval HAL status
mbed_official 532:fe11edbda85c 1268 */
mbed_official 532:fe11edbda85c 1269 HAL_StatusTypeDef HAL_HASHEx_SHA224_Start_DMA(HASH_HandleTypeDef *hhash, uint8_t *pInBuffer, uint32_t Size)
mbed_official 532:fe11edbda85c 1270 {
mbed_official 532:fe11edbda85c 1271 uint32_t inputaddr = (uint32_t)pInBuffer;
mbed_official 532:fe11edbda85c 1272
mbed_official 532:fe11edbda85c 1273 /* Process Locked */
mbed_official 532:fe11edbda85c 1274 __HAL_LOCK(hhash);
mbed_official 532:fe11edbda85c 1275
mbed_official 532:fe11edbda85c 1276 /* Change the HASH state */
mbed_official 532:fe11edbda85c 1277 hhash->State = HAL_HASH_STATE_BUSY;
mbed_official 532:fe11edbda85c 1278
mbed_official 532:fe11edbda85c 1279 /* Check if initialization phase has already been performed */
mbed_official 532:fe11edbda85c 1280 if(hhash->Phase == HAL_HASH_PHASE_READY)
mbed_official 532:fe11edbda85c 1281 {
mbed_official 532:fe11edbda85c 1282 /* Select the SHA224 mode and reset the HASH processor core, so that the HASH will be ready to compute
mbed_official 532:fe11edbda85c 1283 the message digest of a new message */
mbed_official 532:fe11edbda85c 1284 HASH->CR |= HASH_ALGOSELECTION_SHA224 | HASH_CR_INIT;
mbed_official 532:fe11edbda85c 1285 }
mbed_official 532:fe11edbda85c 1286
mbed_official 532:fe11edbda85c 1287 /* Configure the number of valid bits in last word of the message */
mbed_official 532:fe11edbda85c 1288 __HAL_HASH_SET_NBVALIDBITS(Size);
mbed_official 532:fe11edbda85c 1289
mbed_official 532:fe11edbda85c 1290 /* Set the phase */
mbed_official 532:fe11edbda85c 1291 hhash->Phase = HAL_HASH_PHASE_PROCESS;
mbed_official 532:fe11edbda85c 1292
mbed_official 532:fe11edbda85c 1293 /* Set the HASH DMA transfer complete callback */
mbed_official 532:fe11edbda85c 1294 hhash->hdmain->XferCpltCallback = HASHEx_DMAXferCplt;
mbed_official 532:fe11edbda85c 1295 /* Set the DMA error callback */
mbed_official 532:fe11edbda85c 1296 hhash->hdmain->XferErrorCallback = HASHEx_DMAError;
mbed_official 532:fe11edbda85c 1297
mbed_official 532:fe11edbda85c 1298 /* Enable the DMA In DMA Stream */
mbed_official 532:fe11edbda85c 1299 HAL_DMA_Start_IT(hhash->hdmain, inputaddr, (uint32_t)&HASH->DIN, (Size%4 ? (Size+3)/4:Size/4));
mbed_official 532:fe11edbda85c 1300
mbed_official 532:fe11edbda85c 1301 /* Enable DMA requests */
mbed_official 532:fe11edbda85c 1302 HASH->CR |= (HASH_CR_DMAE);
mbed_official 532:fe11edbda85c 1303
mbed_official 532:fe11edbda85c 1304 /* Process Unlocked */
mbed_official 532:fe11edbda85c 1305 __HAL_UNLOCK(hhash);
mbed_official 532:fe11edbda85c 1306
mbed_official 532:fe11edbda85c 1307 /* Return function status */
mbed_official 532:fe11edbda85c 1308 return HAL_OK;
mbed_official 532:fe11edbda85c 1309 }
mbed_official 532:fe11edbda85c 1310
mbed_official 532:fe11edbda85c 1311 /**
mbed_official 532:fe11edbda85c 1312 * @brief Returns the computed digest in SHA224
mbed_official 532:fe11edbda85c 1313 * @param hhash: pointer to a HASH_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 1314 * the configuration information for HASH module
mbed_official 532:fe11edbda85c 1315 * @param pOutBuffer: Pointer to the computed digest. Its size must be 28 bytes.
mbed_official 532:fe11edbda85c 1316 * @param Timeout: Timeout value
mbed_official 532:fe11edbda85c 1317 * @retval HAL status
mbed_official 532:fe11edbda85c 1318 */
mbed_official 532:fe11edbda85c 1319 HAL_StatusTypeDef HAL_HASHEx_SHA224_Finish(HASH_HandleTypeDef *hhash, uint8_t* pOutBuffer, uint32_t Timeout)
mbed_official 532:fe11edbda85c 1320 {
mbed_official 532:fe11edbda85c 1321 uint32_t tickstart = 0;
mbed_official 532:fe11edbda85c 1322
mbed_official 532:fe11edbda85c 1323 /* Process Locked */
mbed_official 532:fe11edbda85c 1324 __HAL_LOCK(hhash);
mbed_official 532:fe11edbda85c 1325
mbed_official 532:fe11edbda85c 1326 /* Change HASH peripheral state */
mbed_official 532:fe11edbda85c 1327 hhash->State = HAL_HASH_STATE_BUSY;
mbed_official 532:fe11edbda85c 1328
mbed_official 532:fe11edbda85c 1329 /* Get tick */
mbed_official 532:fe11edbda85c 1330 tickstart = HAL_GetTick();
mbed_official 532:fe11edbda85c 1331
mbed_official 532:fe11edbda85c 1332 while(HAL_IS_BIT_CLR(HASH->SR, HASH_FLAG_DCIS))
mbed_official 532:fe11edbda85c 1333 {
mbed_official 532:fe11edbda85c 1334 /* Check for the Timeout */
mbed_official 532:fe11edbda85c 1335 if(Timeout != HAL_MAX_DELAY)
mbed_official 532:fe11edbda85c 1336 {
mbed_official 532:fe11edbda85c 1337 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 532:fe11edbda85c 1338 {
mbed_official 532:fe11edbda85c 1339 /* Change state */
mbed_official 532:fe11edbda85c 1340 hhash->State = HAL_HASH_STATE_TIMEOUT;
mbed_official 532:fe11edbda85c 1341
mbed_official 532:fe11edbda85c 1342 /* Process Unlocked */
mbed_official 532:fe11edbda85c 1343 __HAL_UNLOCK(hhash);
mbed_official 532:fe11edbda85c 1344
mbed_official 532:fe11edbda85c 1345 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 1346 }
mbed_official 532:fe11edbda85c 1347 }
mbed_official 532:fe11edbda85c 1348 }
mbed_official 532:fe11edbda85c 1349
mbed_official 532:fe11edbda85c 1350 /* Read the message digest */
mbed_official 532:fe11edbda85c 1351 HASHEx_GetDigest(pOutBuffer, 28);
mbed_official 532:fe11edbda85c 1352
mbed_official 532:fe11edbda85c 1353 /* Change HASH peripheral state */
mbed_official 532:fe11edbda85c 1354 hhash->State = HAL_HASH_STATE_READY;
mbed_official 532:fe11edbda85c 1355
mbed_official 532:fe11edbda85c 1356 /* Process Unlocked */
mbed_official 532:fe11edbda85c 1357 __HAL_UNLOCK(hhash);
mbed_official 532:fe11edbda85c 1358
mbed_official 532:fe11edbda85c 1359 /* Return function status */
mbed_official 532:fe11edbda85c 1360 return HAL_OK;
mbed_official 532:fe11edbda85c 1361 }
mbed_official 532:fe11edbda85c 1362
mbed_official 532:fe11edbda85c 1363 /**
mbed_official 532:fe11edbda85c 1364 * @brief Initializes the HASH peripheral in SHA256 mode then enables DMA to
mbed_official 532:fe11edbda85c 1365 control data transfer. Use HAL_HASH_SHA256_Finish() to get the digest.
mbed_official 532:fe11edbda85c 1366 * @param hhash: pointer to a HASH_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 1367 * the configuration information for HASH module
mbed_official 532:fe11edbda85c 1368 * @param pInBuffer: Pointer to the input buffer (buffer to be hashed).
mbed_official 532:fe11edbda85c 1369 * @param Size: Length of the input buffer in bytes.
mbed_official 532:fe11edbda85c 1370 * If the Size is not multiple of 64 bytes, the padding is managed by hardware.
mbed_official 532:fe11edbda85c 1371 * @retval HAL status
mbed_official 532:fe11edbda85c 1372 */
mbed_official 532:fe11edbda85c 1373 HAL_StatusTypeDef HAL_HASHEx_SHA256_Start_DMA(HASH_HandleTypeDef *hhash, uint8_t *pInBuffer, uint32_t Size)
mbed_official 532:fe11edbda85c 1374 {
mbed_official 532:fe11edbda85c 1375 uint32_t inputaddr = (uint32_t)pInBuffer;
mbed_official 532:fe11edbda85c 1376
mbed_official 532:fe11edbda85c 1377 /* Process Locked */
mbed_official 532:fe11edbda85c 1378 __HAL_LOCK(hhash);
mbed_official 532:fe11edbda85c 1379
mbed_official 532:fe11edbda85c 1380 /* Change the HASH state */
mbed_official 532:fe11edbda85c 1381 hhash->State = HAL_HASH_STATE_BUSY;
mbed_official 532:fe11edbda85c 1382
mbed_official 532:fe11edbda85c 1383 /* Check if initialization phase has already been performed */
mbed_official 532:fe11edbda85c 1384 if(hhash->Phase == HAL_HASH_PHASE_READY)
mbed_official 532:fe11edbda85c 1385 {
mbed_official 532:fe11edbda85c 1386 /* Select the SHA256 mode and reset the HASH processor core, so that the HASH will be ready to compute
mbed_official 532:fe11edbda85c 1387 the message digest of a new message */
mbed_official 532:fe11edbda85c 1388 HASH->CR |= HASH_ALGOSELECTION_SHA256 | HASH_CR_INIT;
mbed_official 532:fe11edbda85c 1389 }
mbed_official 532:fe11edbda85c 1390
mbed_official 532:fe11edbda85c 1391 /* Configure the number of valid bits in last word of the message */
mbed_official 532:fe11edbda85c 1392 __HAL_HASH_SET_NBVALIDBITS(Size);
mbed_official 532:fe11edbda85c 1393
mbed_official 532:fe11edbda85c 1394 /* Set the phase */
mbed_official 532:fe11edbda85c 1395 hhash->Phase = HAL_HASH_PHASE_PROCESS;
mbed_official 532:fe11edbda85c 1396
mbed_official 532:fe11edbda85c 1397 /* Set the HASH DMA transfer complete callback */
mbed_official 532:fe11edbda85c 1398 hhash->hdmain->XferCpltCallback = HASHEx_DMAXferCplt;
mbed_official 532:fe11edbda85c 1399 /* Set the DMA error callback */
mbed_official 532:fe11edbda85c 1400 hhash->hdmain->XferErrorCallback = HASHEx_DMAError;
mbed_official 532:fe11edbda85c 1401
mbed_official 532:fe11edbda85c 1402 /* Enable the DMA In DMA Stream */
mbed_official 532:fe11edbda85c 1403 HAL_DMA_Start_IT(hhash->hdmain, inputaddr, (uint32_t)&HASH->DIN, (Size%4 ? (Size+3)/4:Size/4));
mbed_official 532:fe11edbda85c 1404
mbed_official 532:fe11edbda85c 1405 /* Enable DMA requests */
mbed_official 532:fe11edbda85c 1406 HASH->CR |= (HASH_CR_DMAE);
mbed_official 532:fe11edbda85c 1407
mbed_official 532:fe11edbda85c 1408 /* Process UnLock */
mbed_official 532:fe11edbda85c 1409 __HAL_UNLOCK(hhash);
mbed_official 532:fe11edbda85c 1410
mbed_official 532:fe11edbda85c 1411 /* Return function status */
mbed_official 532:fe11edbda85c 1412 return HAL_OK;
mbed_official 532:fe11edbda85c 1413 }
mbed_official 532:fe11edbda85c 1414
mbed_official 532:fe11edbda85c 1415 /**
mbed_official 532:fe11edbda85c 1416 * @brief Returns the computed digest in SHA256.
mbed_official 532:fe11edbda85c 1417 * @param hhash: pointer to a HASH_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 1418 * the configuration information for HASH module
mbed_official 532:fe11edbda85c 1419 * @param pOutBuffer: Pointer to the computed digest. Its size must be 32 bytes.
mbed_official 532:fe11edbda85c 1420 * @param Timeout: Timeout value
mbed_official 532:fe11edbda85c 1421 * @retval HAL status
mbed_official 532:fe11edbda85c 1422 */
mbed_official 532:fe11edbda85c 1423 HAL_StatusTypeDef HAL_HASHEx_SHA256_Finish(HASH_HandleTypeDef *hhash, uint8_t* pOutBuffer, uint32_t Timeout)
mbed_official 532:fe11edbda85c 1424 {
mbed_official 532:fe11edbda85c 1425 uint32_t tickstart = 0;
mbed_official 532:fe11edbda85c 1426
mbed_official 532:fe11edbda85c 1427 /* Process Locked */
mbed_official 532:fe11edbda85c 1428 __HAL_LOCK(hhash);
mbed_official 532:fe11edbda85c 1429
mbed_official 532:fe11edbda85c 1430 /* Change HASH peripheral state */
mbed_official 532:fe11edbda85c 1431 hhash->State = HAL_HASH_STATE_BUSY;
mbed_official 532:fe11edbda85c 1432
mbed_official 532:fe11edbda85c 1433 /* Get tick */
mbed_official 532:fe11edbda85c 1434 tickstart = HAL_GetTick();
mbed_official 532:fe11edbda85c 1435
mbed_official 532:fe11edbda85c 1436 while(HAL_IS_BIT_CLR(HASH->SR, HASH_FLAG_DCIS))
mbed_official 532:fe11edbda85c 1437 {
mbed_official 532:fe11edbda85c 1438 /* Check for the Timeout */
mbed_official 532:fe11edbda85c 1439 if(Timeout != HAL_MAX_DELAY)
mbed_official 532:fe11edbda85c 1440 {
mbed_official 532:fe11edbda85c 1441 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 532:fe11edbda85c 1442 {
mbed_official 532:fe11edbda85c 1443 /* Change state */
mbed_official 532:fe11edbda85c 1444 hhash->State = HAL_HASH_STATE_TIMEOUT;
mbed_official 532:fe11edbda85c 1445
mbed_official 532:fe11edbda85c 1446 /* Process Unlocked */
mbed_official 532:fe11edbda85c 1447 __HAL_UNLOCK(hhash);
mbed_official 532:fe11edbda85c 1448
mbed_official 532:fe11edbda85c 1449 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 1450 }
mbed_official 532:fe11edbda85c 1451 }
mbed_official 532:fe11edbda85c 1452 }
mbed_official 532:fe11edbda85c 1453
mbed_official 532:fe11edbda85c 1454 /* Read the message digest */
mbed_official 532:fe11edbda85c 1455 HASHEx_GetDigest(pOutBuffer, 32);
mbed_official 532:fe11edbda85c 1456
mbed_official 532:fe11edbda85c 1457 /* Change HASH peripheral state */
mbed_official 532:fe11edbda85c 1458 hhash->State = HAL_HASH_STATE_READY;
mbed_official 532:fe11edbda85c 1459
mbed_official 532:fe11edbda85c 1460 /* Process Unlocked */
mbed_official 532:fe11edbda85c 1461 __HAL_UNLOCK(hhash);
mbed_official 532:fe11edbda85c 1462
mbed_official 532:fe11edbda85c 1463 /* Return function status */
mbed_official 532:fe11edbda85c 1464 return HAL_OK;
mbed_official 532:fe11edbda85c 1465 }
mbed_official 532:fe11edbda85c 1466
mbed_official 532:fe11edbda85c 1467
mbed_official 532:fe11edbda85c 1468 /**
mbed_official 532:fe11edbda85c 1469 * @}
mbed_official 532:fe11edbda85c 1470 */
mbed_official 532:fe11edbda85c 1471 /** @defgroup HASHEx_Group5 HMAC processing functions using DMA mode
mbed_official 532:fe11edbda85c 1472 * @brief HMAC processing functions using DMA mode .
mbed_official 532:fe11edbda85c 1473 *
mbed_official 532:fe11edbda85c 1474 @verbatim
mbed_official 532:fe11edbda85c 1475 ===============================================================================
mbed_official 532:fe11edbda85c 1476 ##### HMAC processing using DMA functions #####
mbed_official 532:fe11edbda85c 1477 ===============================================================================
mbed_official 532:fe11edbda85c 1478 [..] This section provides functions allowing to calculate in DMA mode
mbed_official 532:fe11edbda85c 1479 the HMAC value using one of the following algorithms:
mbed_official 532:fe11edbda85c 1480 (+) SHA224
mbed_official 532:fe11edbda85c 1481 (+) SHA256
mbed_official 532:fe11edbda85c 1482
mbed_official 532:fe11edbda85c 1483 @endverbatim
mbed_official 532:fe11edbda85c 1484 * @{
mbed_official 532:fe11edbda85c 1485 */
mbed_official 532:fe11edbda85c 1486
mbed_official 532:fe11edbda85c 1487 /**
mbed_official 532:fe11edbda85c 1488 * @brief Initializes the HASH peripheral in HMAC SHA224 mode
mbed_official 532:fe11edbda85c 1489 * then enables DMA to control data transfer.
mbed_official 532:fe11edbda85c 1490 * @param hhash: pointer to a HASH_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 1491 * the configuration information for HASH module
mbed_official 532:fe11edbda85c 1492 * @param pInBuffer: Pointer to the input buffer (buffer to be hashed).
mbed_official 532:fe11edbda85c 1493 * @param Size: Length of the input buffer in bytes.
mbed_official 532:fe11edbda85c 1494 * If the Size is not multiple of 64 bytes, the padding is managed by hardware.
mbed_official 532:fe11edbda85c 1495 * @retval HAL status
mbed_official 532:fe11edbda85c 1496 */
mbed_official 532:fe11edbda85c 1497 HAL_StatusTypeDef HAL_HMACEx_SHA224_Start_DMA(HASH_HandleTypeDef *hhash, uint8_t *pInBuffer, uint32_t Size)
mbed_official 532:fe11edbda85c 1498 {
mbed_official 532:fe11edbda85c 1499 uint32_t inputaddr;
mbed_official 532:fe11edbda85c 1500
mbed_official 532:fe11edbda85c 1501 /* Process Locked */
mbed_official 532:fe11edbda85c 1502 __HAL_LOCK(hhash);
mbed_official 532:fe11edbda85c 1503
mbed_official 532:fe11edbda85c 1504 /* Change the HASH state */
mbed_official 532:fe11edbda85c 1505 hhash->State = HAL_HASH_STATE_BUSY;
mbed_official 532:fe11edbda85c 1506
mbed_official 532:fe11edbda85c 1507 /* Save buffer pointer and size in handle */
mbed_official 532:fe11edbda85c 1508 hhash->pHashInBuffPtr = pInBuffer;
mbed_official 532:fe11edbda85c 1509 hhash->HashBuffSize = Size;
mbed_official 532:fe11edbda85c 1510 hhash->HashInCount = 0;
mbed_official 532:fe11edbda85c 1511
mbed_official 532:fe11edbda85c 1512 /* Check if initialization phase has already been performed */
mbed_official 532:fe11edbda85c 1513 if(hhash->Phase == HAL_HASH_PHASE_READY)
mbed_official 532:fe11edbda85c 1514 {
mbed_official 532:fe11edbda85c 1515 /* Check if key size is greater than 64 bytes */
mbed_official 532:fe11edbda85c 1516 if(hhash->Init.KeySize > 64)
mbed_official 532:fe11edbda85c 1517 {
mbed_official 532:fe11edbda85c 1518 /* Select the HMAC SHA224 mode */
mbed_official 532:fe11edbda85c 1519 HASH->CR |= (HASH_ALGOSELECTION_SHA224 | HASH_ALGOMODE_HMAC | HASH_HMAC_KEYTYPE_LONGKEY | HASH_CR_INIT);
mbed_official 532:fe11edbda85c 1520 }
mbed_official 532:fe11edbda85c 1521 else
mbed_official 532:fe11edbda85c 1522 {
mbed_official 532:fe11edbda85c 1523 /* Select the HMAC SHA224 mode */
mbed_official 532:fe11edbda85c 1524 HASH->CR |= (HASH_ALGOSELECTION_SHA224 | HASH_ALGOMODE_HMAC | HASH_CR_INIT);
mbed_official 532:fe11edbda85c 1525 }
mbed_official 532:fe11edbda85c 1526 }
mbed_official 532:fe11edbda85c 1527
mbed_official 532:fe11edbda85c 1528 /* Set the phase */
mbed_official 532:fe11edbda85c 1529 hhash->Phase = HAL_HASH_PHASE_PROCESS;
mbed_official 532:fe11edbda85c 1530
mbed_official 532:fe11edbda85c 1531 /* Configure the number of valid bits in last word of the message */
mbed_official 532:fe11edbda85c 1532 __HAL_HASH_SET_NBVALIDBITS(hhash->Init.KeySize);
mbed_official 532:fe11edbda85c 1533
mbed_official 532:fe11edbda85c 1534 /* Get the key address */
mbed_official 532:fe11edbda85c 1535 inputaddr = (uint32_t)(hhash->Init.pKey);
mbed_official 532:fe11edbda85c 1536
mbed_official 532:fe11edbda85c 1537 /* Set the HASH DMA transfer complete callback */
mbed_official 532:fe11edbda85c 1538 hhash->hdmain->XferCpltCallback = HASHEx_DMAXferCplt;
mbed_official 532:fe11edbda85c 1539 /* Set the DMA error callback */
mbed_official 532:fe11edbda85c 1540 hhash->hdmain->XferErrorCallback = HASHEx_DMAError;
mbed_official 532:fe11edbda85c 1541
mbed_official 532:fe11edbda85c 1542 /* Enable the DMA In DMA Stream */
mbed_official 532:fe11edbda85c 1543 HAL_DMA_Start_IT(hhash->hdmain, inputaddr, (uint32_t)&HASH->DIN, (hhash->Init.KeySize%4 ? (hhash->Init.KeySize+3)/4:hhash->Init.KeySize/4));
mbed_official 532:fe11edbda85c 1544 /* Enable DMA requests */
mbed_official 532:fe11edbda85c 1545 HASH->CR |= (HASH_CR_DMAE);
mbed_official 532:fe11edbda85c 1546
mbed_official 532:fe11edbda85c 1547 /* Process Unlocked */
mbed_official 532:fe11edbda85c 1548 __HAL_UNLOCK(hhash);
mbed_official 532:fe11edbda85c 1549
mbed_official 532:fe11edbda85c 1550 /* Return function status */
mbed_official 532:fe11edbda85c 1551 return HAL_OK;
mbed_official 532:fe11edbda85c 1552 }
mbed_official 532:fe11edbda85c 1553
mbed_official 532:fe11edbda85c 1554 /**
mbed_official 532:fe11edbda85c 1555 * @brief Initializes the HASH peripheral in HMAC SHA256 mode
mbed_official 532:fe11edbda85c 1556 * then enables DMA to control data transfer.
mbed_official 532:fe11edbda85c 1557 * @param hhash: pointer to a HASH_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 1558 * the configuration information for HASH module
mbed_official 532:fe11edbda85c 1559 * @param pInBuffer: Pointer to the input buffer (buffer to be hashed).
mbed_official 532:fe11edbda85c 1560 * @param Size: Length of the input buffer in bytes.
mbed_official 532:fe11edbda85c 1561 * If the Size is not multiple of 64 bytes, the padding is managed by hardware.
mbed_official 532:fe11edbda85c 1562 * @retval HAL status
mbed_official 532:fe11edbda85c 1563 */
mbed_official 532:fe11edbda85c 1564 HAL_StatusTypeDef HAL_HMACEx_SHA256_Start_DMA(HASH_HandleTypeDef *hhash, uint8_t *pInBuffer, uint32_t Size)
mbed_official 532:fe11edbda85c 1565 {
mbed_official 532:fe11edbda85c 1566 uint32_t inputaddr;
mbed_official 532:fe11edbda85c 1567
mbed_official 532:fe11edbda85c 1568 /* Process Locked */
mbed_official 532:fe11edbda85c 1569 __HAL_LOCK(hhash);
mbed_official 532:fe11edbda85c 1570
mbed_official 532:fe11edbda85c 1571 /* Change the HASH state */
mbed_official 532:fe11edbda85c 1572 hhash->State = HAL_HASH_STATE_BUSY;
mbed_official 532:fe11edbda85c 1573
mbed_official 532:fe11edbda85c 1574 /* Save buffer pointer and size in handle */
mbed_official 532:fe11edbda85c 1575 hhash->pHashInBuffPtr = pInBuffer;
mbed_official 532:fe11edbda85c 1576 hhash->HashBuffSize = Size;
mbed_official 532:fe11edbda85c 1577 hhash->HashInCount = 0;
mbed_official 532:fe11edbda85c 1578
mbed_official 532:fe11edbda85c 1579 /* Check if initialization phase has already been performed */
mbed_official 532:fe11edbda85c 1580 if(hhash->Phase == HAL_HASH_PHASE_READY)
mbed_official 532:fe11edbda85c 1581 {
mbed_official 532:fe11edbda85c 1582 /* Check if key size is greater than 64 bytes */
mbed_official 532:fe11edbda85c 1583 if(hhash->Init.KeySize > 64)
mbed_official 532:fe11edbda85c 1584 {
mbed_official 532:fe11edbda85c 1585 /* Select the HMAC SHA256 mode */
mbed_official 532:fe11edbda85c 1586 HASH->CR |= (HASH_ALGOSELECTION_SHA256 | HASH_ALGOMODE_HMAC | HASH_HMAC_KEYTYPE_LONGKEY);
mbed_official 532:fe11edbda85c 1587 }
mbed_official 532:fe11edbda85c 1588 else
mbed_official 532:fe11edbda85c 1589 {
mbed_official 532:fe11edbda85c 1590 /* Select the HMAC SHA256 mode */
mbed_official 532:fe11edbda85c 1591 HASH->CR |= (HASH_ALGOSELECTION_SHA256 | HASH_ALGOMODE_HMAC);
mbed_official 532:fe11edbda85c 1592 }
mbed_official 532:fe11edbda85c 1593 /* Reset the HASH processor core, so that the HASH will be ready to compute
mbed_official 532:fe11edbda85c 1594 the message digest of a new message */
mbed_official 532:fe11edbda85c 1595 HASH->CR |= HASH_CR_INIT;
mbed_official 532:fe11edbda85c 1596 }
mbed_official 532:fe11edbda85c 1597
mbed_official 532:fe11edbda85c 1598 /* Set the phase */
mbed_official 532:fe11edbda85c 1599 hhash->Phase = HAL_HASH_PHASE_PROCESS;
mbed_official 532:fe11edbda85c 1600
mbed_official 532:fe11edbda85c 1601 /* Configure the number of valid bits in last word of the message */
mbed_official 532:fe11edbda85c 1602 __HAL_HASH_SET_NBVALIDBITS(hhash->Init.KeySize);
mbed_official 532:fe11edbda85c 1603
mbed_official 532:fe11edbda85c 1604 /* Get the key address */
mbed_official 532:fe11edbda85c 1605 inputaddr = (uint32_t)(hhash->Init.pKey);
mbed_official 532:fe11edbda85c 1606
mbed_official 532:fe11edbda85c 1607 /* Set the HASH DMA transfer complete callback */
mbed_official 532:fe11edbda85c 1608 hhash->hdmain->XferCpltCallback = HASHEx_DMAXferCplt;
mbed_official 532:fe11edbda85c 1609 /* Set the DMA error callback */
mbed_official 532:fe11edbda85c 1610 hhash->hdmain->XferErrorCallback = HASHEx_DMAError;
mbed_official 532:fe11edbda85c 1611
mbed_official 532:fe11edbda85c 1612 /* Enable the DMA In DMA Stream */
mbed_official 532:fe11edbda85c 1613 HAL_DMA_Start_IT(hhash->hdmain, inputaddr, (uint32_t)&HASH->DIN, (hhash->Init.KeySize%4 ? (hhash->Init.KeySize+3)/4:hhash->Init.KeySize/4));
mbed_official 532:fe11edbda85c 1614 /* Enable DMA requests */
mbed_official 532:fe11edbda85c 1615 HASH->CR |= (HASH_CR_DMAE);
mbed_official 532:fe11edbda85c 1616
mbed_official 532:fe11edbda85c 1617 /* Process Unlocked */
mbed_official 532:fe11edbda85c 1618 __HAL_UNLOCK(hhash);
mbed_official 532:fe11edbda85c 1619
mbed_official 532:fe11edbda85c 1620 /* Return function status */
mbed_official 532:fe11edbda85c 1621 return HAL_OK;
mbed_official 532:fe11edbda85c 1622 }
mbed_official 532:fe11edbda85c 1623
mbed_official 532:fe11edbda85c 1624 /**
mbed_official 532:fe11edbda85c 1625 * @}
mbed_official 532:fe11edbda85c 1626 */
mbed_official 235:685d5f11838f 1627
mbed_official 235:685d5f11838f 1628 /**
mbed_official 235:685d5f11838f 1629 * @}
mbed_official 235:685d5f11838f 1630 */
mbed_official 235:685d5f11838f 1631 #endif /* STM32F437xx || STM32F439xx */
mbed_official 235:685d5f11838f 1632
mbed_official 235:685d5f11838f 1633 #endif /* HAL_HASH_MODULE_ENABLED */
mbed_official 235:685d5f11838f 1634 /**
mbed_official 235:685d5f11838f 1635 * @}
mbed_official 235:685d5f11838f 1636 */
mbed_official 235:685d5f11838f 1637
mbed_official 235:685d5f11838f 1638 /**
mbed_official 235:685d5f11838f 1639 * @}
mbed_official 235:685d5f11838f 1640 */
mbed_official 235:685d5f11838f 1641
mbed_official 235:685d5f11838f 1642 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/