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@532:fe11edbda85c, 2015-04-30 (annotated)

Committer:
mbed_official
Date:
Thu Apr 30 13:45:11 2015 +0100
Revision:
532:fe11edbda85c
Parent:
441:d2c15dda23c1
Child:
613:bc40b8d2aec4
Synchronized with git revision 8c95d60d0a0c337e8161211fd1eded577e79e00b



Full URL: https://github.com/mbedmicro/mbed/commit/8c95d60d0a0c337e8161211fd1eded577e79e00b/



Stm32cubef4 update

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 532:fe11edbda85c 5 * @version V1.3.0
mbed_official 532:fe11edbda85c 6 * @date 09-March-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 235:685d5f11838f 268 HASH->STR |= 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->HashITCounter == 0)
mbed_official 532:fe11edbda85c 930 {
mbed_official 532:fe11edbda85c 931 hhash->HashITCounter = 1;
mbed_official 532:fe11edbda85c 932 }
mbed_official 532:fe11edbda85c 933 else
mbed_official 532:fe11edbda85c 934 {
mbed_official 532:fe11edbda85c 935 hhash->HashITCounter = 0;
mbed_official 532:fe11edbda85c 936 }
mbed_official 532:fe11edbda85c 937 if(hhash->State == HAL_HASH_STATE_READY)
mbed_official 532:fe11edbda85c 938 {
mbed_official 532:fe11edbda85c 939 /* Change the HASH state */
mbed_official 532:fe11edbda85c 940 hhash->State = HAL_HASH_STATE_BUSY;
mbed_official 532:fe11edbda85c 941
mbed_official 532:fe11edbda85c 942 hhash->HashInCount = Size;
mbed_official 532:fe11edbda85c 943 hhash->pHashInBuffPtr = pInBuffer;
mbed_official 532:fe11edbda85c 944 hhash->pHashOutBuffPtr = pOutBuffer;
mbed_official 532:fe11edbda85c 945
mbed_official 532:fe11edbda85c 946 /* Check if initialization phase has already been performed */
mbed_official 532:fe11edbda85c 947 if(hhash->Phase == HAL_HASH_PHASE_READY)
mbed_official 532:fe11edbda85c 948 {
mbed_official 532:fe11edbda85c 949 /* Select the SHA224 mode */
mbed_official 532:fe11edbda85c 950 HASH->CR |= HASH_ALGOSELECTION_SHA224;
mbed_official 532:fe11edbda85c 951 /* Reset the HASH processor core, so that the HASH will be ready to compute
mbed_official 532:fe11edbda85c 952 the message digest of a new message */
mbed_official 532:fe11edbda85c 953 HASH->CR |= HASH_CR_INIT;
mbed_official 532:fe11edbda85c 954 }
mbed_official 532:fe11edbda85c 955
mbed_official 532:fe11edbda85c 956 /* Set the phase */
mbed_official 532:fe11edbda85c 957 hhash->Phase = HAL_HASH_PHASE_PROCESS;
mbed_official 532:fe11edbda85c 958
mbed_official 532:fe11edbda85c 959 /* Process Unlocked */
mbed_official 532:fe11edbda85c 960 __HAL_UNLOCK(hhash);
mbed_official 532:fe11edbda85c 961
mbed_official 532:fe11edbda85c 962 /* Enable Interrupts */
mbed_official 532:fe11edbda85c 963 HASH->IMR = (HASH_IT_DINI | HASH_IT_DCI);
mbed_official 532:fe11edbda85c 964
mbed_official 532:fe11edbda85c 965 /* Return function status */
mbed_official 532:fe11edbda85c 966 return HAL_OK;
mbed_official 532:fe11edbda85c 967 }
mbed_official 532:fe11edbda85c 968 if(__HAL_HASH_GET_FLAG(HASH_FLAG_DCIS))
mbed_official 532:fe11edbda85c 969 {
mbed_official 532:fe11edbda85c 970 /* Read the message digest */
mbed_official 532:fe11edbda85c 971 HASHEx_GetDigest(hhash->pHashOutBuffPtr, 28);
mbed_official 532:fe11edbda85c 972 if(hhash->HashInCount == 0)
mbed_official 532:fe11edbda85c 973 {
mbed_official 532:fe11edbda85c 974 /* Disable Interrupts */
mbed_official 532:fe11edbda85c 975 HASH->IMR = 0;
mbed_official 532:fe11edbda85c 976 /* Change the HASH state */
mbed_official 532:fe11edbda85c 977 hhash->State = HAL_HASH_STATE_READY;
mbed_official 532:fe11edbda85c 978 /* Call digest computation complete callback */
mbed_official 532:fe11edbda85c 979 HAL_HASH_DgstCpltCallback(hhash);
mbed_official 532:fe11edbda85c 980 }
mbed_official 532:fe11edbda85c 981 }
mbed_official 532:fe11edbda85c 982 if(__HAL_HASH_GET_FLAG(HASH_FLAG_DINIS))
mbed_official 532:fe11edbda85c 983 {
mbed_official 532:fe11edbda85c 984 if(hhash->HashInCount > 64)
mbed_official 532:fe11edbda85c 985 {
mbed_official 532:fe11edbda85c 986 inputaddr = (uint32_t)hhash->pHashInBuffPtr;
mbed_official 532:fe11edbda85c 987 /* Write the Input block in the Data IN register */
mbed_official 532:fe11edbda85c 988 for(buffercounter = 0; buffercounter < 64; buffercounter+=4)
mbed_official 532:fe11edbda85c 989 {
mbed_official 532:fe11edbda85c 990 HASH->DIN = *(uint32_t*)inputaddr;
mbed_official 532:fe11edbda85c 991 inputaddr+=4;
mbed_official 532:fe11edbda85c 992 }
mbed_official 532:fe11edbda85c 993 if(hhash->HashITCounter == 0)
mbed_official 532:fe11edbda85c 994 {
mbed_official 532:fe11edbda85c 995 HASH->DIN = *(uint32_t*)inputaddr;
mbed_official 532:fe11edbda85c 996 if(hhash->HashInCount >= 68)
mbed_official 532:fe11edbda85c 997 {
mbed_official 532:fe11edbda85c 998 /* Decrement buffer counter */
mbed_official 532:fe11edbda85c 999 hhash->HashInCount -= 68;
mbed_official 532:fe11edbda85c 1000 hhash->pHashInBuffPtr+= 68;
mbed_official 532:fe11edbda85c 1001 }
mbed_official 532:fe11edbda85c 1002 else
mbed_official 532:fe11edbda85c 1003 {
mbed_official 532:fe11edbda85c 1004 hhash->HashInCount -= 64;
mbed_official 532:fe11edbda85c 1005 }
mbed_official 532:fe11edbda85c 1006 }
mbed_official 532:fe11edbda85c 1007 else
mbed_official 532:fe11edbda85c 1008 {
mbed_official 532:fe11edbda85c 1009 /* Decrement buffer counter */
mbed_official 532:fe11edbda85c 1010 hhash->HashInCount -= 64;
mbed_official 532:fe11edbda85c 1011 hhash->pHashInBuffPtr+= 64;
mbed_official 532:fe11edbda85c 1012 }
mbed_official 532:fe11edbda85c 1013 }
mbed_official 532:fe11edbda85c 1014 else
mbed_official 532:fe11edbda85c 1015 {
mbed_official 532:fe11edbda85c 1016 /* Get the buffer address */
mbed_official 532:fe11edbda85c 1017 inputaddr = (uint32_t)hhash->pHashInBuffPtr;
mbed_official 532:fe11edbda85c 1018 /* Get the buffer counter */
mbed_official 532:fe11edbda85c 1019 inputcounter = hhash->HashInCount;
mbed_official 532:fe11edbda85c 1020 /* Disable Interrupts */
mbed_official 532:fe11edbda85c 1021 HASH->IMR &= ~(HASH_IT_DINI);
mbed_official 532:fe11edbda85c 1022 /* Configure the number of valid bits in last word of the message */
mbed_official 532:fe11edbda85c 1023 __HAL_HASH_SET_NBVALIDBITS(inputcounter);
mbed_official 532:fe11edbda85c 1024
mbed_official 532:fe11edbda85c 1025 if((inputcounter > 4) && (inputcounter%4))
mbed_official 532:fe11edbda85c 1026 {
mbed_official 532:fe11edbda85c 1027 inputcounter = (inputcounter+4-inputcounter%4);
mbed_official 532:fe11edbda85c 1028 }
mbed_official 532:fe11edbda85c 1029
mbed_official 532:fe11edbda85c 1030 /* Write the Input block in the Data IN register */
mbed_official 532:fe11edbda85c 1031 for(buffercounter = 0; buffercounter < inputcounter/4; buffercounter++)
mbed_official 532:fe11edbda85c 1032 {
mbed_official 532:fe11edbda85c 1033 HASH->DIN = *(uint32_t*)inputaddr;
mbed_official 532:fe11edbda85c 1034 inputaddr+=4;
mbed_official 532:fe11edbda85c 1035 }
mbed_official 532:fe11edbda85c 1036 /* Start the digest calculation */
mbed_official 532:fe11edbda85c 1037 __HAL_HASH_START_DIGEST();
mbed_official 532:fe11edbda85c 1038 /* Reset buffer counter */
mbed_official 532:fe11edbda85c 1039 hhash->HashInCount = 0;
mbed_official 532:fe11edbda85c 1040 }
mbed_official 532:fe11edbda85c 1041 /* Call Input data transfer complete callback */
mbed_official 532:fe11edbda85c 1042 HAL_HASH_InCpltCallback(hhash);
mbed_official 532:fe11edbda85c 1043 }
mbed_official 532:fe11edbda85c 1044
mbed_official 532:fe11edbda85c 1045 /* Process Unlocked */
mbed_official 532:fe11edbda85c 1046 __HAL_UNLOCK(hhash);
mbed_official 532:fe11edbda85c 1047
mbed_official 532:fe11edbda85c 1048 /* Return function status */
mbed_official 532:fe11edbda85c 1049 return HAL_OK;
mbed_official 532:fe11edbda85c 1050 }
mbed_official 532:fe11edbda85c 1051
mbed_official 532:fe11edbda85c 1052
mbed_official 532:fe11edbda85c 1053 /**
mbed_official 532:fe11edbda85c 1054 * @brief Initializes the HASH peripheral in SHA256 mode then processes pInBuffer.
mbed_official 532:fe11edbda85c 1055 * The digest is available in pOutBuffer.
mbed_official 532:fe11edbda85c 1056 * @param hhash: pointer to a HASH_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 1057 * the configuration information for HASH module
mbed_official 532:fe11edbda85c 1058 * @param pInBuffer: Pointer to the input buffer (buffer to be hashed).
mbed_official 532:fe11edbda85c 1059 * @param Size: Length of the input buffer in bytes.
mbed_official 532:fe11edbda85c 1060 * If the Size is not multiple of 64 bytes, the padding is managed by hardware.
mbed_official 532:fe11edbda85c 1061 * @param pOutBuffer: Pointer to the computed digest. Its size must be 20 bytes.
mbed_official 532:fe11edbda85c 1062 * @retval HAL status
mbed_official 532:fe11edbda85c 1063 */
mbed_official 532:fe11edbda85c 1064 HAL_StatusTypeDef HAL_HASHEx_SHA256_Start_IT(HASH_HandleTypeDef *hhash, uint8_t *pInBuffer, uint32_t Size, uint8_t* pOutBuffer)
mbed_official 532:fe11edbda85c 1065 {
mbed_official 532:fe11edbda85c 1066 uint32_t inputaddr;
mbed_official 532:fe11edbda85c 1067 uint32_t buffercounter;
mbed_official 532:fe11edbda85c 1068 uint32_t inputcounter;
mbed_official 532:fe11edbda85c 1069
mbed_official 532:fe11edbda85c 1070 /* Process Locked */
mbed_official 532:fe11edbda85c 1071 __HAL_LOCK(hhash);
mbed_official 532:fe11edbda85c 1072
mbed_official 532:fe11edbda85c 1073 if(hhash->HashITCounter == 0)
mbed_official 532:fe11edbda85c 1074 {
mbed_official 532:fe11edbda85c 1075 hhash->HashITCounter = 1;
mbed_official 532:fe11edbda85c 1076 }
mbed_official 532:fe11edbda85c 1077 else
mbed_official 532:fe11edbda85c 1078 {
mbed_official 532:fe11edbda85c 1079 hhash->HashITCounter = 0;
mbed_official 532:fe11edbda85c 1080 }
mbed_official 532:fe11edbda85c 1081 if(hhash->State == HAL_HASH_STATE_READY)
mbed_official 532:fe11edbda85c 1082 {
mbed_official 532:fe11edbda85c 1083 /* Change the HASH state */
mbed_official 532:fe11edbda85c 1084 hhash->State = HAL_HASH_STATE_BUSY;
mbed_official 532:fe11edbda85c 1085
mbed_official 532:fe11edbda85c 1086 hhash->HashInCount = Size;
mbed_official 532:fe11edbda85c 1087 hhash->pHashInBuffPtr = pInBuffer;
mbed_official 532:fe11edbda85c 1088 hhash->pHashOutBuffPtr = pOutBuffer;
mbed_official 532:fe11edbda85c 1089
mbed_official 532:fe11edbda85c 1090 /* Check if initialization phase has already been performed */
mbed_official 532:fe11edbda85c 1091 if(hhash->Phase == HAL_HASH_PHASE_READY)
mbed_official 532:fe11edbda85c 1092 {
mbed_official 532:fe11edbda85c 1093 /* Select the SHA256 mode */
mbed_official 532:fe11edbda85c 1094 HASH->CR |= HASH_ALGOSELECTION_SHA256;
mbed_official 532:fe11edbda85c 1095 /* Reset the HASH processor core, so that the HASH will be ready to compute
mbed_official 532:fe11edbda85c 1096 the message digest of a new message */
mbed_official 532:fe11edbda85c 1097 HASH->CR |= HASH_CR_INIT;
mbed_official 532:fe11edbda85c 1098 }
mbed_official 532:fe11edbda85c 1099
mbed_official 532:fe11edbda85c 1100 /* Set the phase */
mbed_official 532:fe11edbda85c 1101 hhash->Phase = HAL_HASH_PHASE_PROCESS;
mbed_official 532:fe11edbda85c 1102
mbed_official 532:fe11edbda85c 1103 /* Process Unlocked */
mbed_official 532:fe11edbda85c 1104 __HAL_UNLOCK(hhash);
mbed_official 532:fe11edbda85c 1105
mbed_official 532:fe11edbda85c 1106 /* Enable Interrupts */
mbed_official 532:fe11edbda85c 1107 HASH->IMR = (HASH_IT_DINI | HASH_IT_DCI);
mbed_official 532:fe11edbda85c 1108
mbed_official 532:fe11edbda85c 1109 /* Return function status */
mbed_official 532:fe11edbda85c 1110 return HAL_OK;
mbed_official 532:fe11edbda85c 1111 }
mbed_official 532:fe11edbda85c 1112 if(__HAL_HASH_GET_FLAG(HASH_FLAG_DCIS))
mbed_official 532:fe11edbda85c 1113 {
mbed_official 532:fe11edbda85c 1114 /* Read the message digest */
mbed_official 532:fe11edbda85c 1115 HASHEx_GetDigest(hhash->pHashOutBuffPtr, 32);
mbed_official 532:fe11edbda85c 1116 if(hhash->HashInCount == 0)
mbed_official 532:fe11edbda85c 1117 {
mbed_official 532:fe11edbda85c 1118 /* Disable Interrupts */
mbed_official 532:fe11edbda85c 1119 HASH->IMR = 0;
mbed_official 532:fe11edbda85c 1120 /* Change the HASH state */
mbed_official 532:fe11edbda85c 1121 hhash->State = HAL_HASH_STATE_READY;
mbed_official 532:fe11edbda85c 1122 /* Call digest computation complete callback */
mbed_official 532:fe11edbda85c 1123 HAL_HASH_DgstCpltCallback(hhash);
mbed_official 532:fe11edbda85c 1124 }
mbed_official 532:fe11edbda85c 1125 }
mbed_official 532:fe11edbda85c 1126 if(__HAL_HASH_GET_FLAG(HASH_FLAG_DINIS))
mbed_official 532:fe11edbda85c 1127 {
mbed_official 532:fe11edbda85c 1128 if(hhash->HashInCount > 64)
mbed_official 532:fe11edbda85c 1129 {
mbed_official 532:fe11edbda85c 1130 inputaddr = (uint32_t)hhash->pHashInBuffPtr;
mbed_official 532:fe11edbda85c 1131 /* Write the Input block in the Data IN register */
mbed_official 532:fe11edbda85c 1132 for(buffercounter = 0; buffercounter < 64; buffercounter+=4)
mbed_official 532:fe11edbda85c 1133 {
mbed_official 532:fe11edbda85c 1134 HASH->DIN = *(uint32_t*)inputaddr;
mbed_official 532:fe11edbda85c 1135 inputaddr+=4;
mbed_official 532:fe11edbda85c 1136 }
mbed_official 532:fe11edbda85c 1137 if(hhash->HashITCounter == 0)
mbed_official 532:fe11edbda85c 1138 {
mbed_official 532:fe11edbda85c 1139 HASH->DIN = *(uint32_t*)inputaddr;
mbed_official 532:fe11edbda85c 1140
mbed_official 532:fe11edbda85c 1141 if(hhash->HashInCount >= 68)
mbed_official 532:fe11edbda85c 1142 {
mbed_official 532:fe11edbda85c 1143 /* Decrement buffer counter */
mbed_official 532:fe11edbda85c 1144 hhash->HashInCount -= 68;
mbed_official 532:fe11edbda85c 1145 hhash->pHashInBuffPtr+= 68;
mbed_official 532:fe11edbda85c 1146 }
mbed_official 532:fe11edbda85c 1147 else
mbed_official 532:fe11edbda85c 1148 {
mbed_official 532:fe11edbda85c 1149 hhash->HashInCount -= 64;
mbed_official 532:fe11edbda85c 1150 }
mbed_official 532:fe11edbda85c 1151 }
mbed_official 532:fe11edbda85c 1152 else
mbed_official 532:fe11edbda85c 1153 {
mbed_official 532:fe11edbda85c 1154 /* Decrement buffer counter */
mbed_official 532:fe11edbda85c 1155 hhash->HashInCount -= 64;
mbed_official 532:fe11edbda85c 1156 hhash->pHashInBuffPtr+= 64;
mbed_official 532:fe11edbda85c 1157 }
mbed_official 532:fe11edbda85c 1158 }
mbed_official 532:fe11edbda85c 1159 else
mbed_official 532:fe11edbda85c 1160 {
mbed_official 532:fe11edbda85c 1161 /* Get the buffer address */
mbed_official 532:fe11edbda85c 1162 inputaddr = (uint32_t)hhash->pHashInBuffPtr;
mbed_official 532:fe11edbda85c 1163 /* Get the buffer counter */
mbed_official 532:fe11edbda85c 1164 inputcounter = hhash->HashInCount;
mbed_official 532:fe11edbda85c 1165 /* Disable Interrupts */
mbed_official 532:fe11edbda85c 1166 HASH->IMR &= ~(HASH_IT_DINI);
mbed_official 532:fe11edbda85c 1167 /* Configure the number of valid bits in last word of the message */
mbed_official 532:fe11edbda85c 1168 __HAL_HASH_SET_NBVALIDBITS(inputcounter);
mbed_official 532:fe11edbda85c 1169
mbed_official 532:fe11edbda85c 1170 if((inputcounter > 4) && (inputcounter%4))
mbed_official 532:fe11edbda85c 1171 {
mbed_official 532:fe11edbda85c 1172 inputcounter = (inputcounter+4-inputcounter%4);
mbed_official 532:fe11edbda85c 1173 }
mbed_official 532:fe11edbda85c 1174
mbed_official 532:fe11edbda85c 1175 /* Write the Input block in the Data IN register */
mbed_official 532:fe11edbda85c 1176 for(buffercounter = 0; buffercounter < inputcounter/4; buffercounter++)
mbed_official 532:fe11edbda85c 1177 {
mbed_official 532:fe11edbda85c 1178 HASH->DIN = *(uint32_t*)inputaddr;
mbed_official 532:fe11edbda85c 1179 inputaddr+=4;
mbed_official 532:fe11edbda85c 1180 }
mbed_official 532:fe11edbda85c 1181 /* Start the digest calculation */
mbed_official 532:fe11edbda85c 1182 __HAL_HASH_START_DIGEST();
mbed_official 532:fe11edbda85c 1183 /* Reset buffer counter */
mbed_official 532:fe11edbda85c 1184 hhash->HashInCount = 0;
mbed_official 532:fe11edbda85c 1185 }
mbed_official 532:fe11edbda85c 1186 /* Call Input data transfer complete callback */
mbed_official 532:fe11edbda85c 1187 HAL_HASH_InCpltCallback(hhash);
mbed_official 532:fe11edbda85c 1188 }
mbed_official 532:fe11edbda85c 1189
mbed_official 532:fe11edbda85c 1190 /* Process Unlocked */
mbed_official 532:fe11edbda85c 1191 __HAL_UNLOCK(hhash);
mbed_official 532:fe11edbda85c 1192
mbed_official 532:fe11edbda85c 1193 /* Return function status */
mbed_official 532:fe11edbda85c 1194 return HAL_OK;
mbed_official 532:fe11edbda85c 1195 }
mbed_official 532:fe11edbda85c 1196
mbed_official 532:fe11edbda85c 1197 /**
mbed_official 532:fe11edbda85c 1198 * @brief This function handles HASH interrupt request.
mbed_official 532:fe11edbda85c 1199 * @param hhash: pointer to a HASH_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 1200 * the configuration information for HASH module
mbed_official 532:fe11edbda85c 1201 * @retval None
mbed_official 532:fe11edbda85c 1202 */
mbed_official 532:fe11edbda85c 1203 void HAL_HASHEx_IRQHandler(HASH_HandleTypeDef *hhash)
mbed_official 532:fe11edbda85c 1204 {
mbed_official 532:fe11edbda85c 1205 switch(HASH->CR & HASH_CR_ALGO)
mbed_official 532:fe11edbda85c 1206 {
mbed_official 532:fe11edbda85c 1207
mbed_official 532:fe11edbda85c 1208 case HASH_ALGOSELECTION_SHA224:
mbed_official 532:fe11edbda85c 1209 HAL_HASHEx_SHA224_Start_IT(hhash, HAL_NULL, 0, HAL_NULL);
mbed_official 532:fe11edbda85c 1210 break;
mbed_official 532:fe11edbda85c 1211
mbed_official 532:fe11edbda85c 1212 case HASH_ALGOSELECTION_SHA256:
mbed_official 532:fe11edbda85c 1213 HAL_HASHEx_SHA256_Start_IT(hhash, HAL_NULL, 0, HAL_NULL);
mbed_official 532:fe11edbda85c 1214 break;
mbed_official 532:fe11edbda85c 1215
mbed_official 532:fe11edbda85c 1216 default:
mbed_official 532:fe11edbda85c 1217 break;
mbed_official 532:fe11edbda85c 1218 }
mbed_official 532:fe11edbda85c 1219 }
mbed_official 532:fe11edbda85c 1220
mbed_official 532:fe11edbda85c 1221 /**
mbed_official 532:fe11edbda85c 1222 * @}
mbed_official 532:fe11edbda85c 1223 */
mbed_official 532:fe11edbda85c 1224
mbed_official 532:fe11edbda85c 1225 /** @defgroup HASHEx_Group4 HASH processing functions using DMA mode
mbed_official 532:fe11edbda85c 1226 * @brief processing functions using DMA mode.
mbed_official 532:fe11edbda85c 1227 *
mbed_official 532:fe11edbda85c 1228 @verbatim
mbed_official 532:fe11edbda85c 1229 ===============================================================================
mbed_official 532:fe11edbda85c 1230 ##### HASH processing using DMA functions #####
mbed_official 532:fe11edbda85c 1231 ===============================================================================
mbed_official 532:fe11edbda85c 1232 [..] This section provides functions allowing to calculate in DMA mode
mbed_official 532:fe11edbda85c 1233 the hash value using one of the following algorithms:
mbed_official 532:fe11edbda85c 1234 (+) SHA224
mbed_official 532:fe11edbda85c 1235 (+) SHA256
mbed_official 532:fe11edbda85c 1236
mbed_official 532:fe11edbda85c 1237 @endverbatim
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 /**
mbed_official 532:fe11edbda85c 1243 * @brief Initializes the HASH peripheral in SHA224 mode then enables DMA to
mbed_official 532:fe11edbda85c 1244 control data transfer. Use HAL_HASH_SHA224_Finish() to get the digest.
mbed_official 532:fe11edbda85c 1245 * @param hhash: pointer to a HASH_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 1246 * the configuration information for HASH module
mbed_official 532:fe11edbda85c 1247 * @param pInBuffer: Pointer to the input buffer (buffer to be hashed).
mbed_official 532:fe11edbda85c 1248 * @param Size: Length of the input buffer in bytes.
mbed_official 532:fe11edbda85c 1249 * If the Size is not multiple of 64 bytes, the padding is managed by hardware.
mbed_official 532:fe11edbda85c 1250 * @retval HAL status
mbed_official 532:fe11edbda85c 1251 */
mbed_official 532:fe11edbda85c 1252 HAL_StatusTypeDef HAL_HASHEx_SHA224_Start_DMA(HASH_HandleTypeDef *hhash, uint8_t *pInBuffer, uint32_t Size)
mbed_official 532:fe11edbda85c 1253 {
mbed_official 532:fe11edbda85c 1254 uint32_t inputaddr = (uint32_t)pInBuffer;
mbed_official 532:fe11edbda85c 1255
mbed_official 532:fe11edbda85c 1256 /* Process Locked */
mbed_official 532:fe11edbda85c 1257 __HAL_LOCK(hhash);
mbed_official 532:fe11edbda85c 1258
mbed_official 532:fe11edbda85c 1259 /* Change the HASH state */
mbed_official 532:fe11edbda85c 1260 hhash->State = HAL_HASH_STATE_BUSY;
mbed_official 532:fe11edbda85c 1261
mbed_official 532:fe11edbda85c 1262 /* Check if initialization phase has already been performed */
mbed_official 532:fe11edbda85c 1263 if(hhash->Phase == HAL_HASH_PHASE_READY)
mbed_official 532:fe11edbda85c 1264 {
mbed_official 532:fe11edbda85c 1265 /* Select the SHA224 mode and reset the HASH processor core, so that the HASH will be ready to compute
mbed_official 532:fe11edbda85c 1266 the message digest of a new message */
mbed_official 532:fe11edbda85c 1267 HASH->CR |= HASH_ALGOSELECTION_SHA224 | HASH_CR_INIT;
mbed_official 532:fe11edbda85c 1268 }
mbed_official 532:fe11edbda85c 1269
mbed_official 532:fe11edbda85c 1270 /* Configure the number of valid bits in last word of the message */
mbed_official 532:fe11edbda85c 1271 __HAL_HASH_SET_NBVALIDBITS(Size);
mbed_official 532:fe11edbda85c 1272
mbed_official 532:fe11edbda85c 1273 /* Set the phase */
mbed_official 532:fe11edbda85c 1274 hhash->Phase = HAL_HASH_PHASE_PROCESS;
mbed_official 532:fe11edbda85c 1275
mbed_official 532:fe11edbda85c 1276 /* Set the HASH DMA transfer complete callback */
mbed_official 532:fe11edbda85c 1277 hhash->hdmain->XferCpltCallback = HASHEx_DMAXferCplt;
mbed_official 532:fe11edbda85c 1278 /* Set the DMA error callback */
mbed_official 532:fe11edbda85c 1279 hhash->hdmain->XferErrorCallback = HASHEx_DMAError;
mbed_official 532:fe11edbda85c 1280
mbed_official 532:fe11edbda85c 1281 /* Enable the DMA In DMA Stream */
mbed_official 532:fe11edbda85c 1282 HAL_DMA_Start_IT(hhash->hdmain, inputaddr, (uint32_t)&HASH->DIN, (Size%4 ? (Size+3)/4:Size/4));
mbed_official 532:fe11edbda85c 1283
mbed_official 532:fe11edbda85c 1284 /* Enable DMA requests */
mbed_official 532:fe11edbda85c 1285 HASH->CR |= (HASH_CR_DMAE);
mbed_official 532:fe11edbda85c 1286
mbed_official 532:fe11edbda85c 1287 /* Process Unlocked */
mbed_official 532:fe11edbda85c 1288 __HAL_UNLOCK(hhash);
mbed_official 532:fe11edbda85c 1289
mbed_official 532:fe11edbda85c 1290 /* Return function status */
mbed_official 532:fe11edbda85c 1291 return HAL_OK;
mbed_official 532:fe11edbda85c 1292 }
mbed_official 532:fe11edbda85c 1293
mbed_official 532:fe11edbda85c 1294 /**
mbed_official 532:fe11edbda85c 1295 * @brief Returns the computed digest in SHA224
mbed_official 532:fe11edbda85c 1296 * @param hhash: pointer to a HASH_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 1297 * the configuration information for HASH module
mbed_official 532:fe11edbda85c 1298 * @param pOutBuffer: Pointer to the computed digest. Its size must be 28 bytes.
mbed_official 532:fe11edbda85c 1299 * @param Timeout: Timeout value
mbed_official 532:fe11edbda85c 1300 * @retval HAL status
mbed_official 532:fe11edbda85c 1301 */
mbed_official 532:fe11edbda85c 1302 HAL_StatusTypeDef HAL_HASHEx_SHA224_Finish(HASH_HandleTypeDef *hhash, uint8_t* pOutBuffer, uint32_t Timeout)
mbed_official 532:fe11edbda85c 1303 {
mbed_official 532:fe11edbda85c 1304 uint32_t tickstart = 0;
mbed_official 532:fe11edbda85c 1305
mbed_official 532:fe11edbda85c 1306 /* Process Locked */
mbed_official 532:fe11edbda85c 1307 __HAL_LOCK(hhash);
mbed_official 532:fe11edbda85c 1308
mbed_official 532:fe11edbda85c 1309 /* Change HASH peripheral state */
mbed_official 532:fe11edbda85c 1310 hhash->State = HAL_HASH_STATE_BUSY;
mbed_official 532:fe11edbda85c 1311
mbed_official 532:fe11edbda85c 1312 /* Get tick */
mbed_official 532:fe11edbda85c 1313 tickstart = HAL_GetTick();
mbed_official 532:fe11edbda85c 1314
mbed_official 532:fe11edbda85c 1315 while(HAL_IS_BIT_CLR(HASH->SR, HASH_FLAG_DCIS))
mbed_official 532:fe11edbda85c 1316 {
mbed_official 532:fe11edbda85c 1317 /* Check for the Timeout */
mbed_official 532:fe11edbda85c 1318 if(Timeout != HAL_MAX_DELAY)
mbed_official 532:fe11edbda85c 1319 {
mbed_official 532:fe11edbda85c 1320 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 532:fe11edbda85c 1321 {
mbed_official 532:fe11edbda85c 1322 /* Change state */
mbed_official 532:fe11edbda85c 1323 hhash->State = HAL_HASH_STATE_TIMEOUT;
mbed_official 532:fe11edbda85c 1324
mbed_official 532:fe11edbda85c 1325 /* Process Unlocked */
mbed_official 532:fe11edbda85c 1326 __HAL_UNLOCK(hhash);
mbed_official 532:fe11edbda85c 1327
mbed_official 532:fe11edbda85c 1328 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 1329 }
mbed_official 532:fe11edbda85c 1330 }
mbed_official 532:fe11edbda85c 1331 }
mbed_official 532:fe11edbda85c 1332
mbed_official 532:fe11edbda85c 1333 /* Read the message digest */
mbed_official 532:fe11edbda85c 1334 HASHEx_GetDigest(pOutBuffer, 28);
mbed_official 532:fe11edbda85c 1335
mbed_official 532:fe11edbda85c 1336 /* Change HASH peripheral state */
mbed_official 532:fe11edbda85c 1337 hhash->State = HAL_HASH_STATE_READY;
mbed_official 532:fe11edbda85c 1338
mbed_official 532:fe11edbda85c 1339 /* Process Unlocked */
mbed_official 532:fe11edbda85c 1340 __HAL_UNLOCK(hhash);
mbed_official 532:fe11edbda85c 1341
mbed_official 532:fe11edbda85c 1342 /* Return function status */
mbed_official 532:fe11edbda85c 1343 return HAL_OK;
mbed_official 532:fe11edbda85c 1344 }
mbed_official 532:fe11edbda85c 1345
mbed_official 532:fe11edbda85c 1346 /**
mbed_official 532:fe11edbda85c 1347 * @brief Initializes the HASH peripheral in SHA256 mode then enables DMA to
mbed_official 532:fe11edbda85c 1348 control data transfer. Use HAL_HASH_SHA256_Finish() to get the digest.
mbed_official 532:fe11edbda85c 1349 * @param hhash: pointer to a HASH_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 1350 * the configuration information for HASH module
mbed_official 532:fe11edbda85c 1351 * @param pInBuffer: Pointer to the input buffer (buffer to be hashed).
mbed_official 532:fe11edbda85c 1352 * @param Size: Length of the input buffer in bytes.
mbed_official 532:fe11edbda85c 1353 * If the Size is not multiple of 64 bytes, the padding is managed by hardware.
mbed_official 532:fe11edbda85c 1354 * @retval HAL status
mbed_official 532:fe11edbda85c 1355 */
mbed_official 532:fe11edbda85c 1356 HAL_StatusTypeDef HAL_HASHEx_SHA256_Start_DMA(HASH_HandleTypeDef *hhash, uint8_t *pInBuffer, uint32_t Size)
mbed_official 532:fe11edbda85c 1357 {
mbed_official 532:fe11edbda85c 1358 uint32_t inputaddr = (uint32_t)pInBuffer;
mbed_official 532:fe11edbda85c 1359
mbed_official 532:fe11edbda85c 1360 /* Process Locked */
mbed_official 532:fe11edbda85c 1361 __HAL_LOCK(hhash);
mbed_official 532:fe11edbda85c 1362
mbed_official 532:fe11edbda85c 1363 /* Change the HASH state */
mbed_official 532:fe11edbda85c 1364 hhash->State = HAL_HASH_STATE_BUSY;
mbed_official 532:fe11edbda85c 1365
mbed_official 532:fe11edbda85c 1366 /* Check if initialization phase has already been performed */
mbed_official 532:fe11edbda85c 1367 if(hhash->Phase == HAL_HASH_PHASE_READY)
mbed_official 532:fe11edbda85c 1368 {
mbed_official 532:fe11edbda85c 1369 /* Select the SHA256 mode and reset the HASH processor core, so that the HASH will be ready to compute
mbed_official 532:fe11edbda85c 1370 the message digest of a new message */
mbed_official 532:fe11edbda85c 1371 HASH->CR |= HASH_ALGOSELECTION_SHA256 | HASH_CR_INIT;
mbed_official 532:fe11edbda85c 1372 }
mbed_official 532:fe11edbda85c 1373
mbed_official 532:fe11edbda85c 1374 /* Configure the number of valid bits in last word of the message */
mbed_official 532:fe11edbda85c 1375 __HAL_HASH_SET_NBVALIDBITS(Size);
mbed_official 532:fe11edbda85c 1376
mbed_official 532:fe11edbda85c 1377 /* Set the phase */
mbed_official 532:fe11edbda85c 1378 hhash->Phase = HAL_HASH_PHASE_PROCESS;
mbed_official 532:fe11edbda85c 1379
mbed_official 532:fe11edbda85c 1380 /* Set the HASH DMA transfer complete callback */
mbed_official 532:fe11edbda85c 1381 hhash->hdmain->XferCpltCallback = HASHEx_DMAXferCplt;
mbed_official 532:fe11edbda85c 1382 /* Set the DMA error callback */
mbed_official 532:fe11edbda85c 1383 hhash->hdmain->XferErrorCallback = HASHEx_DMAError;
mbed_official 532:fe11edbda85c 1384
mbed_official 532:fe11edbda85c 1385 /* Enable the DMA In DMA Stream */
mbed_official 532:fe11edbda85c 1386 HAL_DMA_Start_IT(hhash->hdmain, inputaddr, (uint32_t)&HASH->DIN, (Size%4 ? (Size+3)/4:Size/4));
mbed_official 532:fe11edbda85c 1387
mbed_official 532:fe11edbda85c 1388 /* Enable DMA requests */
mbed_official 532:fe11edbda85c 1389 HASH->CR |= (HASH_CR_DMAE);
mbed_official 532:fe11edbda85c 1390
mbed_official 532:fe11edbda85c 1391 /* Process UnLock */
mbed_official 532:fe11edbda85c 1392 __HAL_UNLOCK(hhash);
mbed_official 532:fe11edbda85c 1393
mbed_official 532:fe11edbda85c 1394 /* Return function status */
mbed_official 532:fe11edbda85c 1395 return HAL_OK;
mbed_official 532:fe11edbda85c 1396 }
mbed_official 532:fe11edbda85c 1397
mbed_official 532:fe11edbda85c 1398 /**
mbed_official 532:fe11edbda85c 1399 * @brief Returns the computed digest in SHA256.
mbed_official 532:fe11edbda85c 1400 * @param hhash: pointer to a HASH_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 1401 * the configuration information for HASH module
mbed_official 532:fe11edbda85c 1402 * @param pOutBuffer: Pointer to the computed digest. Its size must be 32 bytes.
mbed_official 532:fe11edbda85c 1403 * @param Timeout: Timeout value
mbed_official 532:fe11edbda85c 1404 * @retval HAL status
mbed_official 532:fe11edbda85c 1405 */
mbed_official 532:fe11edbda85c 1406 HAL_StatusTypeDef HAL_HASHEx_SHA256_Finish(HASH_HandleTypeDef *hhash, uint8_t* pOutBuffer, uint32_t Timeout)
mbed_official 532:fe11edbda85c 1407 {
mbed_official 532:fe11edbda85c 1408 uint32_t tickstart = 0;
mbed_official 532:fe11edbda85c 1409
mbed_official 532:fe11edbda85c 1410 /* Process Locked */
mbed_official 532:fe11edbda85c 1411 __HAL_LOCK(hhash);
mbed_official 532:fe11edbda85c 1412
mbed_official 532:fe11edbda85c 1413 /* Change HASH peripheral state */
mbed_official 532:fe11edbda85c 1414 hhash->State = HAL_HASH_STATE_BUSY;
mbed_official 532:fe11edbda85c 1415
mbed_official 532:fe11edbda85c 1416 /* Get tick */
mbed_official 532:fe11edbda85c 1417 tickstart = HAL_GetTick();
mbed_official 532:fe11edbda85c 1418
mbed_official 532:fe11edbda85c 1419 while(HAL_IS_BIT_CLR(HASH->SR, HASH_FLAG_DCIS))
mbed_official 532:fe11edbda85c 1420 {
mbed_official 532:fe11edbda85c 1421 /* Check for the Timeout */
mbed_official 532:fe11edbda85c 1422 if(Timeout != HAL_MAX_DELAY)
mbed_official 532:fe11edbda85c 1423 {
mbed_official 532:fe11edbda85c 1424 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 532:fe11edbda85c 1425 {
mbed_official 532:fe11edbda85c 1426 /* Change state */
mbed_official 532:fe11edbda85c 1427 hhash->State = HAL_HASH_STATE_TIMEOUT;
mbed_official 532:fe11edbda85c 1428
mbed_official 532:fe11edbda85c 1429 /* Process Unlocked */
mbed_official 532:fe11edbda85c 1430 __HAL_UNLOCK(hhash);
mbed_official 532:fe11edbda85c 1431
mbed_official 532:fe11edbda85c 1432 return HAL_TIMEOUT;
mbed_official 532:fe11edbda85c 1433 }
mbed_official 532:fe11edbda85c 1434 }
mbed_official 532:fe11edbda85c 1435 }
mbed_official 532:fe11edbda85c 1436
mbed_official 532:fe11edbda85c 1437 /* Read the message digest */
mbed_official 532:fe11edbda85c 1438 HASHEx_GetDigest(pOutBuffer, 32);
mbed_official 532:fe11edbda85c 1439
mbed_official 532:fe11edbda85c 1440 /* Change HASH peripheral state */
mbed_official 532:fe11edbda85c 1441 hhash->State = HAL_HASH_STATE_READY;
mbed_official 532:fe11edbda85c 1442
mbed_official 532:fe11edbda85c 1443 /* Process Unlocked */
mbed_official 532:fe11edbda85c 1444 __HAL_UNLOCK(hhash);
mbed_official 532:fe11edbda85c 1445
mbed_official 532:fe11edbda85c 1446 /* Return function status */
mbed_official 532:fe11edbda85c 1447 return HAL_OK;
mbed_official 532:fe11edbda85c 1448 }
mbed_official 532:fe11edbda85c 1449
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 /** @defgroup HASHEx_Group5 HMAC processing functions using DMA mode
mbed_official 532:fe11edbda85c 1455 * @brief HMAC processing functions using DMA mode .
mbed_official 532:fe11edbda85c 1456 *
mbed_official 532:fe11edbda85c 1457 @verbatim
mbed_official 532:fe11edbda85c 1458 ===============================================================================
mbed_official 532:fe11edbda85c 1459 ##### HMAC processing using DMA functions #####
mbed_official 532:fe11edbda85c 1460 ===============================================================================
mbed_official 532:fe11edbda85c 1461 [..] This section provides functions allowing to calculate in DMA mode
mbed_official 532:fe11edbda85c 1462 the HMAC value using one of the following algorithms:
mbed_official 532:fe11edbda85c 1463 (+) SHA224
mbed_official 532:fe11edbda85c 1464 (+) SHA256
mbed_official 532:fe11edbda85c 1465
mbed_official 532:fe11edbda85c 1466 @endverbatim
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 * @brief Initializes the HASH peripheral in HMAC SHA224 mode
mbed_official 532:fe11edbda85c 1472 * then enables DMA to control data transfer.
mbed_official 532:fe11edbda85c 1473 * @param hhash: pointer to a HASH_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 1474 * the configuration information for HASH module
mbed_official 532:fe11edbda85c 1475 * @param pInBuffer: Pointer to the input buffer (buffer to be hashed).
mbed_official 532:fe11edbda85c 1476 * @param Size: Length of the input buffer in bytes.
mbed_official 532:fe11edbda85c 1477 * If the Size is not multiple of 64 bytes, the padding is managed by hardware.
mbed_official 532:fe11edbda85c 1478 * @retval HAL status
mbed_official 532:fe11edbda85c 1479 */
mbed_official 532:fe11edbda85c 1480 HAL_StatusTypeDef HAL_HMACEx_SHA224_Start_DMA(HASH_HandleTypeDef *hhash, uint8_t *pInBuffer, uint32_t Size)
mbed_official 532:fe11edbda85c 1481 {
mbed_official 532:fe11edbda85c 1482 uint32_t inputaddr;
mbed_official 532:fe11edbda85c 1483
mbed_official 532:fe11edbda85c 1484 /* Process Locked */
mbed_official 532:fe11edbda85c 1485 __HAL_LOCK(hhash);
mbed_official 532:fe11edbda85c 1486
mbed_official 532:fe11edbda85c 1487 /* Change the HASH state */
mbed_official 532:fe11edbda85c 1488 hhash->State = HAL_HASH_STATE_BUSY;
mbed_official 532:fe11edbda85c 1489
mbed_official 532:fe11edbda85c 1490 /* Save buffer pointer and size in handle */
mbed_official 532:fe11edbda85c 1491 hhash->pHashInBuffPtr = pInBuffer;
mbed_official 532:fe11edbda85c 1492 hhash->HashBuffSize = Size;
mbed_official 532:fe11edbda85c 1493 hhash->HashInCount = 0;
mbed_official 532:fe11edbda85c 1494
mbed_official 532:fe11edbda85c 1495 /* Check if initialization phase has already been performed */
mbed_official 532:fe11edbda85c 1496 if(hhash->Phase == HAL_HASH_PHASE_READY)
mbed_official 532:fe11edbda85c 1497 {
mbed_official 532:fe11edbda85c 1498 /* Check if key size is greater than 64 bytes */
mbed_official 532:fe11edbda85c 1499 if(hhash->Init.KeySize > 64)
mbed_official 532:fe11edbda85c 1500 {
mbed_official 532:fe11edbda85c 1501 /* Select the HMAC SHA224 mode */
mbed_official 532:fe11edbda85c 1502 HASH->CR |= (HASH_ALGOSELECTION_SHA224 | HASH_ALGOMODE_HMAC | HASH_HMAC_KEYTYPE_LONGKEY | HASH_CR_INIT);
mbed_official 532:fe11edbda85c 1503 }
mbed_official 532:fe11edbda85c 1504 else
mbed_official 532:fe11edbda85c 1505 {
mbed_official 532:fe11edbda85c 1506 /* Select the HMAC SHA224 mode */
mbed_official 532:fe11edbda85c 1507 HASH->CR |= (HASH_ALGOSELECTION_SHA224 | HASH_ALGOMODE_HMAC | HASH_CR_INIT);
mbed_official 532:fe11edbda85c 1508 }
mbed_official 532:fe11edbda85c 1509 }
mbed_official 532:fe11edbda85c 1510
mbed_official 532:fe11edbda85c 1511 /* Set the phase */
mbed_official 532:fe11edbda85c 1512 hhash->Phase = HAL_HASH_PHASE_PROCESS;
mbed_official 532:fe11edbda85c 1513
mbed_official 532:fe11edbda85c 1514 /* Configure the number of valid bits in last word of the message */
mbed_official 532:fe11edbda85c 1515 __HAL_HASH_SET_NBVALIDBITS(hhash->Init.KeySize);
mbed_official 532:fe11edbda85c 1516
mbed_official 532:fe11edbda85c 1517 /* Get the key address */
mbed_official 532:fe11edbda85c 1518 inputaddr = (uint32_t)(hhash->Init.pKey);
mbed_official 532:fe11edbda85c 1519
mbed_official 532:fe11edbda85c 1520 /* Set the HASH DMA transfer complete callback */
mbed_official 532:fe11edbda85c 1521 hhash->hdmain->XferCpltCallback = HASHEx_DMAXferCplt;
mbed_official 532:fe11edbda85c 1522 /* Set the DMA error callback */
mbed_official 532:fe11edbda85c 1523 hhash->hdmain->XferErrorCallback = HASHEx_DMAError;
mbed_official 532:fe11edbda85c 1524
mbed_official 532:fe11edbda85c 1525 /* Enable the DMA In DMA Stream */
mbed_official 532:fe11edbda85c 1526 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 1527 /* Enable DMA requests */
mbed_official 532:fe11edbda85c 1528 HASH->CR |= (HASH_CR_DMAE);
mbed_official 532:fe11edbda85c 1529
mbed_official 532:fe11edbda85c 1530 /* Process Unlocked */
mbed_official 532:fe11edbda85c 1531 __HAL_UNLOCK(hhash);
mbed_official 532:fe11edbda85c 1532
mbed_official 532:fe11edbda85c 1533 /* Return function status */
mbed_official 532:fe11edbda85c 1534 return HAL_OK;
mbed_official 532:fe11edbda85c 1535 }
mbed_official 532:fe11edbda85c 1536
mbed_official 532:fe11edbda85c 1537 /**
mbed_official 532:fe11edbda85c 1538 * @brief Initializes the HASH peripheral in HMAC SHA256 mode
mbed_official 532:fe11edbda85c 1539 * then enables DMA to control data transfer.
mbed_official 532:fe11edbda85c 1540 * @param hhash: pointer to a HASH_HandleTypeDef structure that contains
mbed_official 532:fe11edbda85c 1541 * the configuration information for HASH module
mbed_official 532:fe11edbda85c 1542 * @param pInBuffer: Pointer to the input buffer (buffer to be hashed).
mbed_official 532:fe11edbda85c 1543 * @param Size: Length of the input buffer in bytes.
mbed_official 532:fe11edbda85c 1544 * If the Size is not multiple of 64 bytes, the padding is managed by hardware.
mbed_official 532:fe11edbda85c 1545 * @retval HAL status
mbed_official 532:fe11edbda85c 1546 */
mbed_official 532:fe11edbda85c 1547 HAL_StatusTypeDef HAL_HMACEx_SHA256_Start_DMA(HASH_HandleTypeDef *hhash, uint8_t *pInBuffer, uint32_t Size)
mbed_official 532:fe11edbda85c 1548 {
mbed_official 532:fe11edbda85c 1549 uint32_t inputaddr;
mbed_official 532:fe11edbda85c 1550
mbed_official 532:fe11edbda85c 1551 /* Process Locked */
mbed_official 532:fe11edbda85c 1552 __HAL_LOCK(hhash);
mbed_official 532:fe11edbda85c 1553
mbed_official 532:fe11edbda85c 1554 /* Change the HASH state */
mbed_official 532:fe11edbda85c 1555 hhash->State = HAL_HASH_STATE_BUSY;
mbed_official 532:fe11edbda85c 1556
mbed_official 532:fe11edbda85c 1557 /* Save buffer pointer and size in handle */
mbed_official 532:fe11edbda85c 1558 hhash->pHashInBuffPtr = pInBuffer;
mbed_official 532:fe11edbda85c 1559 hhash->HashBuffSize = Size;
mbed_official 532:fe11edbda85c 1560 hhash->HashInCount = 0;
mbed_official 532:fe11edbda85c 1561
mbed_official 532:fe11edbda85c 1562 /* Check if initialization phase has already been performed */
mbed_official 532:fe11edbda85c 1563 if(hhash->Phase == HAL_HASH_PHASE_READY)
mbed_official 532:fe11edbda85c 1564 {
mbed_official 532:fe11edbda85c 1565 /* Check if key size is greater than 64 bytes */
mbed_official 532:fe11edbda85c 1566 if(hhash->Init.KeySize > 64)
mbed_official 532:fe11edbda85c 1567 {
mbed_official 532:fe11edbda85c 1568 /* Select the HMAC SHA256 mode */
mbed_official 532:fe11edbda85c 1569 HASH->CR |= (HASH_ALGOSELECTION_SHA256 | HASH_ALGOMODE_HMAC | HASH_HMAC_KEYTYPE_LONGKEY);
mbed_official 532:fe11edbda85c 1570 }
mbed_official 532:fe11edbda85c 1571 else
mbed_official 532:fe11edbda85c 1572 {
mbed_official 532:fe11edbda85c 1573 /* Select the HMAC SHA256 mode */
mbed_official 532:fe11edbda85c 1574 HASH->CR |= (HASH_ALGOSELECTION_SHA256 | HASH_ALGOMODE_HMAC);
mbed_official 532:fe11edbda85c 1575 }
mbed_official 532:fe11edbda85c 1576 /* Reset the HASH processor core, so that the HASH will be ready to compute
mbed_official 532:fe11edbda85c 1577 the message digest of a new message */
mbed_official 532:fe11edbda85c 1578 HASH->CR |= HASH_CR_INIT;
mbed_official 532:fe11edbda85c 1579 }
mbed_official 532:fe11edbda85c 1580
mbed_official 532:fe11edbda85c 1581 /* Set the phase */
mbed_official 532:fe11edbda85c 1582 hhash->Phase = HAL_HASH_PHASE_PROCESS;
mbed_official 532:fe11edbda85c 1583
mbed_official 532:fe11edbda85c 1584 /* Configure the number of valid bits in last word of the message */
mbed_official 532:fe11edbda85c 1585 __HAL_HASH_SET_NBVALIDBITS(hhash->Init.KeySize);
mbed_official 532:fe11edbda85c 1586
mbed_official 532:fe11edbda85c 1587 /* Get the key address */
mbed_official 532:fe11edbda85c 1588 inputaddr = (uint32_t)(hhash->Init.pKey);
mbed_official 532:fe11edbda85c 1589
mbed_official 532:fe11edbda85c 1590 /* Set the HASH DMA transfer complete callback */
mbed_official 532:fe11edbda85c 1591 hhash->hdmain->XferCpltCallback = HASHEx_DMAXferCplt;
mbed_official 532:fe11edbda85c 1592 /* Set the DMA error callback */
mbed_official 532:fe11edbda85c 1593 hhash->hdmain->XferErrorCallback = HASHEx_DMAError;
mbed_official 532:fe11edbda85c 1594
mbed_official 532:fe11edbda85c 1595 /* Enable the DMA In DMA Stream */
mbed_official 532:fe11edbda85c 1596 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 1597 /* Enable DMA requests */
mbed_official 532:fe11edbda85c 1598 HASH->CR |= (HASH_CR_DMAE);
mbed_official 532:fe11edbda85c 1599
mbed_official 532:fe11edbda85c 1600 /* Process Unlocked */
mbed_official 532:fe11edbda85c 1601 __HAL_UNLOCK(hhash);
mbed_official 532:fe11edbda85c 1602
mbed_official 532:fe11edbda85c 1603 /* Return function status */
mbed_official 532:fe11edbda85c 1604 return HAL_OK;
mbed_official 532:fe11edbda85c 1605 }
mbed_official 532:fe11edbda85c 1606
mbed_official 532:fe11edbda85c 1607 /**
mbed_official 532:fe11edbda85c 1608 * @}
mbed_official 532:fe11edbda85c 1609 */
mbed_official 235:685d5f11838f 1610
mbed_official 235:685d5f11838f 1611 /**
mbed_official 235:685d5f11838f 1612 * @}
mbed_official 235:685d5f11838f 1613 */
mbed_official 235:685d5f11838f 1614 #endif /* STM32F437xx || STM32F439xx */
mbed_official 235:685d5f11838f 1615
mbed_official 235:685d5f11838f 1616 #endif /* HAL_HASH_MODULE_ENABLED */
mbed_official 235:685d5f11838f 1617 /**
mbed_official 235:685d5f11838f 1618 * @}
mbed_official 235:685d5f11838f 1619 */
mbed_official 235:685d5f11838f 1620
mbed_official 235:685d5f11838f 1621 /**
mbed_official 235:685d5f11838f 1622 * @}
mbed_official 235:685d5f11838f 1623 */
mbed_official 235:685d5f11838f 1624
mbed_official 235:685d5f11838f 1625 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/