mbed-dev | Mbed

Users » ptpaterson » Code » mbed-dev

targets/cmsis/TARGET_STM/TARGET_STM32F4/stm32f4xx_hal_cryp_ex.c@144:ef7eb2e8f9f7, 2016-09-02 (annotated)

Committer:: <>
Date:: Fri Sep 02 15:07:44 2016 +0100
Revision:: 144:ef7eb2e8f9f7
Parent:: 19:112740acecfa

This updates the lib to the mbed lib v125

Who changed what in which revision?

User	Revision	Line number	New contents of line
<>	144:ef7eb2e8f9f7	1	/**
<>	144:ef7eb2e8f9f7	2	******************************************************************************
<>	144:ef7eb2e8f9f7	3	* @file stm32f4xx_hal_cryp_ex.c
<>	144:ef7eb2e8f9f7	4	* @author MCD Application Team
<>	144:ef7eb2e8f9f7	5	* @version V1.5.0
<>	144:ef7eb2e8f9f7	6	* @date 06-May-2016
<>	144:ef7eb2e8f9f7	7	* @brief Extended CRYP HAL module driver
<>	144:ef7eb2e8f9f7	8	* This file provides firmware functions to manage the following
<>	144:ef7eb2e8f9f7	9	* functionalities of CRYP extension peripheral:
<>	144:ef7eb2e8f9f7	10	* + Extended AES processing functions
<>	144:ef7eb2e8f9f7	11	*
<>	144:ef7eb2e8f9f7	12	@verbatim
<>	144:ef7eb2e8f9f7	13	==============================================================================
<>	144:ef7eb2e8f9f7	14	##### How to use this driver #####
<>	144:ef7eb2e8f9f7	15	==============================================================================
<>	144:ef7eb2e8f9f7	16	[..]
<>	144:ef7eb2e8f9f7	17	The CRYP Extension HAL driver can be used as follows:
<>	144:ef7eb2e8f9f7	18	(#)Initialize the CRYP low level resources by implementing the HAL_CRYP_MspInit():
<>	144:ef7eb2e8f9f7	19	(##) Enable the CRYP interface clock using __HAL_RCC_CRYP_CLK_ENABLE()
<>	144:ef7eb2e8f9f7	20	(##) In case of using interrupts (e.g. HAL_CRYPEx_AESGCM_Encrypt_IT())
<>	144:ef7eb2e8f9f7	21	(+++) Configure the CRYP interrupt priority using HAL_NVIC_SetPriority()
<>	144:ef7eb2e8f9f7	22	(+++) Enable the CRYP IRQ handler using HAL_NVIC_EnableIRQ()
<>	144:ef7eb2e8f9f7	23	(+++) In CRYP IRQ handler, call HAL_CRYP_IRQHandler()
<>	144:ef7eb2e8f9f7	24	(##) In case of using DMA to control data transfer (e.g. HAL_AES_ECB_Encrypt_DMA())
<>	144:ef7eb2e8f9f7	25	(+++) Enable the DMAx interface clock using __DMAx_CLK_ENABLE()
<>	144:ef7eb2e8f9f7	26	(+++) Configure and enable two DMA streams one for managing data transfer from
<>	144:ef7eb2e8f9f7	27	memory to peripheral (input stream) and another stream for managing data
<>	144:ef7eb2e8f9f7	28	transfer from peripheral to memory (output stream)
<>	144:ef7eb2e8f9f7	29	(+++) Associate the initialized DMA handle to the CRYP DMA handle
<>	144:ef7eb2e8f9f7	30	using __HAL_LINKDMA()
<>	144:ef7eb2e8f9f7	31	(+++) Configure the priority and enable the NVIC for the transfer complete
<>	144:ef7eb2e8f9f7	32	interrupt on the two DMA Streams. The output stream should have higher
<>	144:ef7eb2e8f9f7	33	priority than the input stream HAL_NVIC_SetPriority() and HAL_NVIC_EnableIRQ()
<>	144:ef7eb2e8f9f7	34	(#)Initialize the CRYP HAL using HAL_CRYP_Init(). This function configures mainly:
<>	144:ef7eb2e8f9f7	35	(##) The data type: 1-bit, 8-bit, 16-bit and 32-bit
<>	144:ef7eb2e8f9f7	36	(##) The key size: 128, 192 and 256. This parameter is relevant only for AES
<>	144:ef7eb2e8f9f7	37	(##) The encryption/decryption key. Its size depends on the algorithm
<>	144:ef7eb2e8f9f7	38	used for encryption/decryption
<>	144:ef7eb2e8f9f7	39	(##) The initialization vector (counter). It is not used ECB mode.
<>	144:ef7eb2e8f9f7	40	(#)Three processing (encryption/decryption) functions are available:
<>	144:ef7eb2e8f9f7	41	(##) Polling mode: encryption and decryption APIs are blocking functions
<>	144:ef7eb2e8f9f7	42	i.e. they process the data and wait till the processing is finished
<>	144:ef7eb2e8f9f7	43	e.g. HAL_CRYPEx_AESGCM_Encrypt()
<>	144:ef7eb2e8f9f7	44	(##) Interrupt mode: encryption and decryption APIs are not blocking functions
<>	144:ef7eb2e8f9f7	45	i.e. they process the data under interrupt
<>	144:ef7eb2e8f9f7	46	e.g. HAL_CRYPEx_AESGCM_Encrypt_IT()
<>	144:ef7eb2e8f9f7	47	(##) DMA mode: encryption and decryption APIs are not blocking functions
<>	144:ef7eb2e8f9f7	48	i.e. the data transfer is ensured by DMA
<>	144:ef7eb2e8f9f7	49	e.g. HAL_CRYPEx_AESGCM_Encrypt_DMA()
<>	144:ef7eb2e8f9f7	50	(#)When the processing function is called at first time after HAL_CRYP_Init()
<>	144:ef7eb2e8f9f7	51	the CRYP peripheral is initialized and processes the buffer in input.
<>	144:ef7eb2e8f9f7	52	At second call, the processing function performs an append of the already
<>	144:ef7eb2e8f9f7	53	processed buffer.
<>	144:ef7eb2e8f9f7	54	When a new data block is to be processed, call HAL_CRYP_Init() then the
<>	144:ef7eb2e8f9f7	55	processing function.
<>	144:ef7eb2e8f9f7	56	(#)In AES-GCM and AES-CCM modes are an authenticated encryption algorithms
<>	144:ef7eb2e8f9f7	57	which provide authentication messages.
<>	144:ef7eb2e8f9f7	58	HAL_AES_GCM_Finish() and HAL_AES_CCM_Finish() are used to provide those
<>	144:ef7eb2e8f9f7	59	authentication messages.
<>	144:ef7eb2e8f9f7	60	Call those functions after the processing ones (polling, interrupt or DMA).
<>	144:ef7eb2e8f9f7	61	e.g. in AES-CCM mode call HAL_CRYPEx_AESCCM_Encrypt() to encrypt the plain data
<>	144:ef7eb2e8f9f7	62	then call HAL_CRYPEx_AESCCM_Finish() to get the authentication message
<>	144:ef7eb2e8f9f7	63	-@- For CCM Encrypt/Decrypt API's, only DataType = 8-bit is supported by this version.
<>	144:ef7eb2e8f9f7	64	-@- The HAL_CRYPEx_AESGCM_xxxx() implementation is limited to 32bits inputs data length
<>	144:ef7eb2e8f9f7	65	(Plain/Cyphertext, Header) compared with GCM standards specifications (800-38D).
<>	144:ef7eb2e8f9f7	66	(#)Call HAL_CRYP_DeInit() to deinitialize the CRYP peripheral.
<>	144:ef7eb2e8f9f7	67
<>	144:ef7eb2e8f9f7	68	@endverbatim
<>	144:ef7eb2e8f9f7	69	******************************************************************************
<>	144:ef7eb2e8f9f7	70	* @attention
<>	144:ef7eb2e8f9f7	71	*
<>	144:ef7eb2e8f9f7	72	* <h2><center>© COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
<>	144:ef7eb2e8f9f7	73	*
<>	144:ef7eb2e8f9f7	74	* Redistribution and use in source and binary forms, with or without modification,
<>	144:ef7eb2e8f9f7	75	* are permitted provided that the following conditions are met:
<>	144:ef7eb2e8f9f7	76	* 1. Redistributions of source code must retain the above copyright notice,
<>	144:ef7eb2e8f9f7	77	* this list of conditions and the following disclaimer.
<>	144:ef7eb2e8f9f7	78	* 2. Redistributions in binary form must reproduce the above copyright notice,
<>	144:ef7eb2e8f9f7	79	* this list of conditions and the following disclaimer in the documentation
<>	144:ef7eb2e8f9f7	80	* and/or other materials provided with the distribution.
<>	144:ef7eb2e8f9f7	81	* 3. Neither the name of STMicroelectronics nor the names of its contributors
<>	144:ef7eb2e8f9f7	82	* may be used to endorse or promote products derived from this software
<>	144:ef7eb2e8f9f7	83	* without specific prior written permission.
<>	144:ef7eb2e8f9f7	84	*
<>	144:ef7eb2e8f9f7	85	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
<>	144:ef7eb2e8f9f7	86	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
<>	144:ef7eb2e8f9f7	87	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
<>	144:ef7eb2e8f9f7	88	* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
<>	144:ef7eb2e8f9f7	89	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
<>	144:ef7eb2e8f9f7	90	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
<>	144:ef7eb2e8f9f7	91	* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
<>	144:ef7eb2e8f9f7	92	* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
<>	144:ef7eb2e8f9f7	93	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
<>	144:ef7eb2e8f9f7	94	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
<>	144:ef7eb2e8f9f7	95	*
<>	144:ef7eb2e8f9f7	96	******************************************************************************
<>	144:ef7eb2e8f9f7	97	*/
<>	144:ef7eb2e8f9f7	98
<>	144:ef7eb2e8f9f7	99	/* Includes ------------------------------------------------------------------*/
<>	144:ef7eb2e8f9f7	100	#include "stm32f4xx_hal.h"
<>	144:ef7eb2e8f9f7	101
<>	144:ef7eb2e8f9f7	102	/** @addtogroup STM32F4xx_HAL_Driver
<>	144:ef7eb2e8f9f7	103	* @{
<>	144:ef7eb2e8f9f7	104	*/
<>	144:ef7eb2e8f9f7	105
<>	144:ef7eb2e8f9f7	106	/** @defgroup CRYPEx CRYPEx
<>	144:ef7eb2e8f9f7	107	* @brief CRYP Extension HAL module driver.
<>	144:ef7eb2e8f9f7	108	* @{
<>	144:ef7eb2e8f9f7	109	*/
<>	144:ef7eb2e8f9f7	110
<>	144:ef7eb2e8f9f7	111	#ifdef HAL_CRYP_MODULE_ENABLED
<>	144:ef7eb2e8f9f7	112
<>	144:ef7eb2e8f9f7	113	#if defined(STM32F437xx) \|\| defined(STM32F439xx) \|\| defined(STM32F479xx)
<>	144:ef7eb2e8f9f7	114
<>	144:ef7eb2e8f9f7	115	/* Private typedef -----------------------------------------------------------*/
<>	144:ef7eb2e8f9f7	116	/* Private define ------------------------------------------------------------*/
<>	144:ef7eb2e8f9f7	117	/** @addtogroup CRYPEx_Private_define
<>	144:ef7eb2e8f9f7	118	* @{
<>	144:ef7eb2e8f9f7	119	*/
<>	144:ef7eb2e8f9f7	120	#define CRYPEx_TIMEOUT_VALUE 1U
<>	144:ef7eb2e8f9f7	121	/**
<>	144:ef7eb2e8f9f7	122	* @}
<>	144:ef7eb2e8f9f7	123	*/
<>	144:ef7eb2e8f9f7	124
<>	144:ef7eb2e8f9f7	125	/* Private macro -------------------------------------------------------------*/
<>	144:ef7eb2e8f9f7	126	/* Private variables ---------------------------------------------------------*/
<>	144:ef7eb2e8f9f7	127	/* Private function prototypes -----------------------------------------------*/
<>	144:ef7eb2e8f9f7	128	/** @defgroup CRYPEx_Private_Functions_prototypes CRYP Private Functions Prototypes
<>	144:ef7eb2e8f9f7	129	* @{
<>	144:ef7eb2e8f9f7	130	*/
<>	144:ef7eb2e8f9f7	131	static void CRYPEx_GCMCCM_SetInitVector(CRYP_HandleTypeDef hcryp, uint8_t InitVector);
<>	144:ef7eb2e8f9f7	132	static void CRYPEx_GCMCCM_SetKey(CRYP_HandleTypeDef hcryp, uint8_t Key, uint32_t KeySize);
<>	144:ef7eb2e8f9f7	133	static HAL_StatusTypeDef CRYPEx_GCMCCM_ProcessData(CRYP_HandleTypeDef hcryp, uint8_t Input, uint16_t Ilength, uint8_t *Output, uint32_t Timeout);
<>	144:ef7eb2e8f9f7	134	static HAL_StatusTypeDef CRYPEx_GCMCCM_SetHeaderPhase(CRYP_HandleTypeDef hcryp, uint8_t Input, uint16_t Ilength, uint32_t Timeout);
<>	144:ef7eb2e8f9f7	135	static void CRYPEx_GCMCCM_DMAInCplt(DMA_HandleTypeDef *hdma);
<>	144:ef7eb2e8f9f7	136	static void CRYPEx_GCMCCM_DMAOutCplt(DMA_HandleTypeDef *hdma);
<>	144:ef7eb2e8f9f7	137	static void CRYPEx_GCMCCM_DMAError(DMA_HandleTypeDef *hdma);
<>	144:ef7eb2e8f9f7	138	static void CRYPEx_GCMCCM_SetDMAConfig(CRYP_HandleTypeDef *hcryp, uint32_t inputaddr, uint16_t Size, uint32_t outputaddr);
<>	144:ef7eb2e8f9f7	139	/**
<>	144:ef7eb2e8f9f7	140	* @}
<>	144:ef7eb2e8f9f7	141	*/
<>	144:ef7eb2e8f9f7	142
<>	144:ef7eb2e8f9f7	143	/* Private functions ---------------------------------------------------------*/
<>	144:ef7eb2e8f9f7	144	/** @addtogroup CRYPEx_Private_Functions
<>	144:ef7eb2e8f9f7	145	* @{
<>	144:ef7eb2e8f9f7	146	*/
<>	144:ef7eb2e8f9f7	147
<>	144:ef7eb2e8f9f7	148	/**
<>	144:ef7eb2e8f9f7	149	* @brief DMA CRYP Input Data process complete callback.
<>	144:ef7eb2e8f9f7	150	* @param hdma: DMA handle
<>	144:ef7eb2e8f9f7	151	* @retval None
<>	144:ef7eb2e8f9f7	152	*/
<>	144:ef7eb2e8f9f7	153	static void CRYPEx_GCMCCM_DMAInCplt(DMA_HandleTypeDef *hdma)
<>	144:ef7eb2e8f9f7	154	{
<>	144:ef7eb2e8f9f7	155	CRYP_HandleTypeDef* hcryp = ( CRYP_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
<>	144:ef7eb2e8f9f7	156
<>	144:ef7eb2e8f9f7	157	/* Disable the DMA transfer for input Fifo request by resetting the DIEN bit
<>	144:ef7eb2e8f9f7	158	in the DMACR register */
<>	144:ef7eb2e8f9f7	159	hcryp->Instance->DMACR &= (uint32_t)(~CRYP_DMACR_DIEN);
<>	144:ef7eb2e8f9f7	160
<>	144:ef7eb2e8f9f7	161	/* Call input data transfer complete callback */
<>	144:ef7eb2e8f9f7	162	HAL_CRYP_InCpltCallback(hcryp);
<>	144:ef7eb2e8f9f7	163	}
<>	144:ef7eb2e8f9f7	164
<>	144:ef7eb2e8f9f7	165	/**
<>	144:ef7eb2e8f9f7	166	* @brief DMA CRYP Output Data process complete callback.
<>	144:ef7eb2e8f9f7	167	* @param hdma: DMA handle
<>	144:ef7eb2e8f9f7	168	* @retval None
<>	144:ef7eb2e8f9f7	169	*/
<>	144:ef7eb2e8f9f7	170	static void CRYPEx_GCMCCM_DMAOutCplt(DMA_HandleTypeDef *hdma)
<>	144:ef7eb2e8f9f7	171	{
<>	144:ef7eb2e8f9f7	172	CRYP_HandleTypeDef* hcryp = ( CRYP_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
<>	144:ef7eb2e8f9f7	173
<>	144:ef7eb2e8f9f7	174	/* Disable the DMA transfer for output Fifo request by resetting the DOEN bit
<>	144:ef7eb2e8f9f7	175	in the DMACR register */
<>	144:ef7eb2e8f9f7	176	hcryp->Instance->DMACR &= (uint32_t)(~CRYP_DMACR_DOEN);
<>	144:ef7eb2e8f9f7	177
<>	144:ef7eb2e8f9f7	178	/* Enable the CRYP peripheral */
<>	144:ef7eb2e8f9f7	179	__HAL_CRYP_DISABLE(hcryp);
<>	144:ef7eb2e8f9f7	180
<>	144:ef7eb2e8f9f7	181	/* Change the CRYP peripheral state */
<>	144:ef7eb2e8f9f7	182	hcryp->State = HAL_CRYP_STATE_READY;
<>	144:ef7eb2e8f9f7	183
<>	144:ef7eb2e8f9f7	184	/* Call output data transfer complete callback */
<>	144:ef7eb2e8f9f7	185	HAL_CRYP_OutCpltCallback(hcryp);
<>	144:ef7eb2e8f9f7	186	}
<>	144:ef7eb2e8f9f7	187
<>	144:ef7eb2e8f9f7	188	/**
<>	144:ef7eb2e8f9f7	189	* @brief DMA CRYP communication error callback.
<>	144:ef7eb2e8f9f7	190	* @param hdma: DMA handle
<>	144:ef7eb2e8f9f7	191	* @retval None
<>	144:ef7eb2e8f9f7	192	*/
<>	144:ef7eb2e8f9f7	193	static void CRYPEx_GCMCCM_DMAError(DMA_HandleTypeDef *hdma)
<>	144:ef7eb2e8f9f7	194	{
<>	144:ef7eb2e8f9f7	195	CRYP_HandleTypeDef* hcryp = ( CRYP_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
<>	144:ef7eb2e8f9f7	196	hcryp->State= HAL_CRYP_STATE_READY;
<>	144:ef7eb2e8f9f7	197	HAL_CRYP_ErrorCallback(hcryp);
<>	144:ef7eb2e8f9f7	198	}
<>	144:ef7eb2e8f9f7	199
<>	144:ef7eb2e8f9f7	200	/**
<>	144:ef7eb2e8f9f7	201	* @brief Writes the Key in Key registers.
<>	144:ef7eb2e8f9f7	202	* @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	203	* the configuration information for CRYP module
<>	144:ef7eb2e8f9f7	204	* @param Key: Pointer to Key buffer
<>	144:ef7eb2e8f9f7	205	* @param KeySize: Size of Key
<>	144:ef7eb2e8f9f7	206	* @retval None
<>	144:ef7eb2e8f9f7	207	*/
<>	144:ef7eb2e8f9f7	208	static void CRYPEx_GCMCCM_SetKey(CRYP_HandleTypeDef hcryp, uint8_t Key, uint32_t KeySize)
<>	144:ef7eb2e8f9f7	209	{
<>	144:ef7eb2e8f9f7	210	uint32_t keyaddr = (uint32_t)Key;
<>	144:ef7eb2e8f9f7	211
<>	144:ef7eb2e8f9f7	212	switch(KeySize)
<>	144:ef7eb2e8f9f7	213	{
<>	144:ef7eb2e8f9f7	214	case CRYP_KEYSIZE_256B:
<>	144:ef7eb2e8f9f7	215	/* Key Initialisation */
<>	144:ef7eb2e8f9f7	216	hcryp->Instance->K0LR = __REV((uint32_t)(keyaddr));
<>	144:ef7eb2e8f9f7	217	keyaddr+=4U;
<>	144:ef7eb2e8f9f7	218	hcryp->Instance->K0RR = __REV((uint32_t)(keyaddr));
<>	144:ef7eb2e8f9f7	219	keyaddr+=4U;
<>	144:ef7eb2e8f9f7	220	hcryp->Instance->K1LR = __REV((uint32_t)(keyaddr));
<>	144:ef7eb2e8f9f7	221	keyaddr+=4U;
<>	144:ef7eb2e8f9f7	222	hcryp->Instance->K1RR = __REV((uint32_t)(keyaddr));
<>	144:ef7eb2e8f9f7	223	keyaddr+=4U;
<>	144:ef7eb2e8f9f7	224	hcryp->Instance->K2LR = __REV((uint32_t)(keyaddr));
<>	144:ef7eb2e8f9f7	225	keyaddr+=4U;
<>	144:ef7eb2e8f9f7	226	hcryp->Instance->K2RR = __REV((uint32_t)(keyaddr));
<>	144:ef7eb2e8f9f7	227	keyaddr+=4U;
<>	144:ef7eb2e8f9f7	228	hcryp->Instance->K3LR = __REV((uint32_t)(keyaddr));
<>	144:ef7eb2e8f9f7	229	keyaddr+=4U;
<>	144:ef7eb2e8f9f7	230	hcryp->Instance->K3RR = __REV((uint32_t)(keyaddr));
<>	144:ef7eb2e8f9f7	231	break;
<>	144:ef7eb2e8f9f7	232	case CRYP_KEYSIZE_192B:
<>	144:ef7eb2e8f9f7	233	hcryp->Instance->K1LR = __REV((uint32_t)(keyaddr));
<>	144:ef7eb2e8f9f7	234	keyaddr+=4U;
<>	144:ef7eb2e8f9f7	235	hcryp->Instance->K1RR = __REV((uint32_t)(keyaddr));
<>	144:ef7eb2e8f9f7	236	keyaddr+=4U;
<>	144:ef7eb2e8f9f7	237	hcryp->Instance->K2LR = __REV((uint32_t)(keyaddr));
<>	144:ef7eb2e8f9f7	238	keyaddr+=4U;
<>	144:ef7eb2e8f9f7	239	hcryp->Instance->K2RR = __REV((uint32_t)(keyaddr));
<>	144:ef7eb2e8f9f7	240	keyaddr+=4U;
<>	144:ef7eb2e8f9f7	241	hcryp->Instance->K3LR = __REV((uint32_t)(keyaddr));
<>	144:ef7eb2e8f9f7	242	keyaddr+=4U;
<>	144:ef7eb2e8f9f7	243	hcryp->Instance->K3RR = __REV((uint32_t)(keyaddr));
<>	144:ef7eb2e8f9f7	244	break;
<>	144:ef7eb2e8f9f7	245	case CRYP_KEYSIZE_128B:
<>	144:ef7eb2e8f9f7	246	hcryp->Instance->K2LR = __REV((uint32_t)(keyaddr));
<>	144:ef7eb2e8f9f7	247	keyaddr+=4U;
<>	144:ef7eb2e8f9f7	248	hcryp->Instance->K2RR = __REV((uint32_t)(keyaddr));
<>	144:ef7eb2e8f9f7	249	keyaddr+=4U;
<>	144:ef7eb2e8f9f7	250	hcryp->Instance->K3LR = __REV((uint32_t)(keyaddr));
<>	144:ef7eb2e8f9f7	251	keyaddr+=4U;
<>	144:ef7eb2e8f9f7	252	hcryp->Instance->K3RR = __REV((uint32_t)(keyaddr));
<>	144:ef7eb2e8f9f7	253	break;
<>	144:ef7eb2e8f9f7	254	default:
<>	144:ef7eb2e8f9f7	255	break;
<>	144:ef7eb2e8f9f7	256	}
<>	144:ef7eb2e8f9f7	257	}
<>	144:ef7eb2e8f9f7	258
<>	144:ef7eb2e8f9f7	259	/**
<>	144:ef7eb2e8f9f7	260	* @brief Writes the InitVector/InitCounter in IV registers.
<>	144:ef7eb2e8f9f7	261	* @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	262	* the configuration information for CRYP module
<>	144:ef7eb2e8f9f7	263	* @param InitVector: Pointer to InitVector/InitCounter buffer
<>	144:ef7eb2e8f9f7	264	* @retval None
<>	144:ef7eb2e8f9f7	265	*/
<>	144:ef7eb2e8f9f7	266	static void CRYPEx_GCMCCM_SetInitVector(CRYP_HandleTypeDef hcryp, uint8_t InitVector)
<>	144:ef7eb2e8f9f7	267	{
<>	144:ef7eb2e8f9f7	268	uint32_t ivaddr = (uint32_t)InitVector;
<>	144:ef7eb2e8f9f7	269
<>	144:ef7eb2e8f9f7	270	hcryp->Instance->IV0LR = __REV((uint32_t)(ivaddr));
<>	144:ef7eb2e8f9f7	271	ivaddr+=4U;
<>	144:ef7eb2e8f9f7	272	hcryp->Instance->IV0RR = __REV((uint32_t)(ivaddr));
<>	144:ef7eb2e8f9f7	273	ivaddr+=4U;
<>	144:ef7eb2e8f9f7	274	hcryp->Instance->IV1LR = __REV((uint32_t)(ivaddr));
<>	144:ef7eb2e8f9f7	275	ivaddr+=4U;
<>	144:ef7eb2e8f9f7	276	hcryp->Instance->IV1RR = __REV((uint32_t)(ivaddr));
<>	144:ef7eb2e8f9f7	277	}
<>	144:ef7eb2e8f9f7	278
<>	144:ef7eb2e8f9f7	279	/**
<>	144:ef7eb2e8f9f7	280	* @brief Process Data: Writes Input data in polling mode and read the Output data.
<>	144:ef7eb2e8f9f7	281	* @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	282	* the configuration information for CRYP module
<>	144:ef7eb2e8f9f7	283	* @param Input: Pointer to the Input buffer.
<>	144:ef7eb2e8f9f7	284	* @param Ilength: Length of the Input buffer, must be a multiple of 16
<>	144:ef7eb2e8f9f7	285	* @param Output: Pointer to the returned buffer
<>	144:ef7eb2e8f9f7	286	* @param Timeout: Timeout value
<>	144:ef7eb2e8f9f7	287	* @retval None
<>	144:ef7eb2e8f9f7	288	*/
<>	144:ef7eb2e8f9f7	289	static HAL_StatusTypeDef CRYPEx_GCMCCM_ProcessData(CRYP_HandleTypeDef hcryp, uint8_t Input, uint16_t Ilength, uint8_t *Output, uint32_t Timeout)
<>	144:ef7eb2e8f9f7	290	{
<>	144:ef7eb2e8f9f7	291	uint32_t tickstart = 0U;
<>	144:ef7eb2e8f9f7	292	uint32_t i = 0U;
<>	144:ef7eb2e8f9f7	293	uint32_t inputaddr = (uint32_t)Input;
<>	144:ef7eb2e8f9f7	294	uint32_t outputaddr = (uint32_t)Output;
<>	144:ef7eb2e8f9f7	295
<>	144:ef7eb2e8f9f7	296	for(i=0U; (i < Ilength); i+=16U)
<>	144:ef7eb2e8f9f7	297	{
<>	144:ef7eb2e8f9f7	298	/* Write the Input block in the IN FIFO */
<>	144:ef7eb2e8f9f7	299	hcryp->Instance->DR = (uint32_t)(inputaddr);
<>	144:ef7eb2e8f9f7	300	inputaddr+=4U;
<>	144:ef7eb2e8f9f7	301	hcryp->Instance->DR = (uint32_t)(inputaddr);
<>	144:ef7eb2e8f9f7	302	inputaddr+=4U;
<>	144:ef7eb2e8f9f7	303	hcryp->Instance->DR = (uint32_t)(inputaddr);
<>	144:ef7eb2e8f9f7	304	inputaddr+=4U;
<>	144:ef7eb2e8f9f7	305	hcryp->Instance->DR = (uint32_t)(inputaddr);
<>	144:ef7eb2e8f9f7	306	inputaddr+=4U;
<>	144:ef7eb2e8f9f7	307
<>	144:ef7eb2e8f9f7	308	/* Get tick */
<>	144:ef7eb2e8f9f7	309	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	310
<>	144:ef7eb2e8f9f7	311	while(HAL_IS_BIT_CLR(hcryp->Instance->SR, CRYP_FLAG_OFNE))
<>	144:ef7eb2e8f9f7	312	{
<>	144:ef7eb2e8f9f7	313	/* Check for the Timeout */
<>	144:ef7eb2e8f9f7	314	if(Timeout != HAL_MAX_DELAY)
<>	144:ef7eb2e8f9f7	315	{
<>	144:ef7eb2e8f9f7	316	if((HAL_GetTick() - tickstart ) > CRYPEx_TIMEOUT_VALUE)
<>	144:ef7eb2e8f9f7	317	{
<>	144:ef7eb2e8f9f7	318	/* Change state */
<>	144:ef7eb2e8f9f7	319	hcryp->State = HAL_CRYP_STATE_TIMEOUT;
<>	144:ef7eb2e8f9f7	320
<>	144:ef7eb2e8f9f7	321	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	322	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	323
<>	144:ef7eb2e8f9f7	324	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	325	}
<>	144:ef7eb2e8f9f7	326	}
<>	144:ef7eb2e8f9f7	327	}
<>	144:ef7eb2e8f9f7	328	/* Read the Output block from the OUT FIFO */
<>	144:ef7eb2e8f9f7	329	(uint32_t)(outputaddr) = hcryp->Instance->DOUT;
<>	144:ef7eb2e8f9f7	330	outputaddr+=4U;
<>	144:ef7eb2e8f9f7	331	(uint32_t)(outputaddr) = hcryp->Instance->DOUT;
<>	144:ef7eb2e8f9f7	332	outputaddr+=4U;
<>	144:ef7eb2e8f9f7	333	(uint32_t)(outputaddr) = hcryp->Instance->DOUT;
<>	144:ef7eb2e8f9f7	334	outputaddr+=4U;
<>	144:ef7eb2e8f9f7	335	(uint32_t)(outputaddr) = hcryp->Instance->DOUT;
<>	144:ef7eb2e8f9f7	336	outputaddr+=4U;
<>	144:ef7eb2e8f9f7	337	}
<>	144:ef7eb2e8f9f7	338	/* Return function status */
<>	144:ef7eb2e8f9f7	339	return HAL_OK;
<>	144:ef7eb2e8f9f7	340	}
<>	144:ef7eb2e8f9f7	341
<>	144:ef7eb2e8f9f7	342	/**
<>	144:ef7eb2e8f9f7	343	* @brief Sets the header phase
<>	144:ef7eb2e8f9f7	344	* @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	345	* the configuration information for CRYP module
<>	144:ef7eb2e8f9f7	346	* @param Input: Pointer to the Input buffer.
<>	144:ef7eb2e8f9f7	347	* @param Ilength: Length of the Input buffer, must be a multiple of 16
<>	144:ef7eb2e8f9f7	348	* @param Timeout: Timeout value
<>	144:ef7eb2e8f9f7	349	* @retval None
<>	144:ef7eb2e8f9f7	350	*/
<>	144:ef7eb2e8f9f7	351	static HAL_StatusTypeDef CRYPEx_GCMCCM_SetHeaderPhase(CRYP_HandleTypeDef hcryp, uint8_t Input, uint16_t Ilength, uint32_t Timeout)
<>	144:ef7eb2e8f9f7	352	{
<>	144:ef7eb2e8f9f7	353	uint32_t tickstart = 0U;
<>	144:ef7eb2e8f9f7	354	uint32_t loopcounter = 0U;
<>	144:ef7eb2e8f9f7	355	uint32_t headeraddr = (uint32_t)Input;
<>	144:ef7eb2e8f9f7	356
<>	144:ef7eb2e8f9f7	357	/*************************** Header phase *******************************/
<>	144:ef7eb2e8f9f7	358	if(hcryp->Init.HeaderSize != 0U)
<>	144:ef7eb2e8f9f7	359	{
<>	144:ef7eb2e8f9f7	360	/* Select header phase */
<>	144:ef7eb2e8f9f7	361	__HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_HEADER);
<>	144:ef7eb2e8f9f7	362	/* Enable the CRYP peripheral */
<>	144:ef7eb2e8f9f7	363	__HAL_CRYP_ENABLE(hcryp);
<>	144:ef7eb2e8f9f7	364
<>	144:ef7eb2e8f9f7	365	for(loopcounter = 0U; (loopcounter < hcryp->Init.HeaderSize); loopcounter+=16U)
<>	144:ef7eb2e8f9f7	366	{
<>	144:ef7eb2e8f9f7	367	/* Get tick */
<>	144:ef7eb2e8f9f7	368	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	369
<>	144:ef7eb2e8f9f7	370	while(HAL_IS_BIT_CLR(hcryp->Instance->SR, CRYP_FLAG_IFEM))
<>	144:ef7eb2e8f9f7	371	{
<>	144:ef7eb2e8f9f7	372	/* Check for the Timeout */
<>	144:ef7eb2e8f9f7	373	if(Timeout != HAL_MAX_DELAY)
<>	144:ef7eb2e8f9f7	374	{
<>	144:ef7eb2e8f9f7	375	if((Timeout == 0U)\|\|((HAL_GetTick() - tickstart ) > Timeout))
<>	144:ef7eb2e8f9f7	376	{
<>	144:ef7eb2e8f9f7	377	/* Change state */
<>	144:ef7eb2e8f9f7	378	hcryp->State = HAL_CRYP_STATE_TIMEOUT;
<>	144:ef7eb2e8f9f7	379
<>	144:ef7eb2e8f9f7	380	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	381	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	382
<>	144:ef7eb2e8f9f7	383	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	384	}
<>	144:ef7eb2e8f9f7	385	}
<>	144:ef7eb2e8f9f7	386	}
<>	144:ef7eb2e8f9f7	387	/* Write the Input block in the IN FIFO */
<>	144:ef7eb2e8f9f7	388	hcryp->Instance->DR = (uint32_t)(headeraddr);
<>	144:ef7eb2e8f9f7	389	headeraddr+=4U;
<>	144:ef7eb2e8f9f7	390	hcryp->Instance->DR = (uint32_t)(headeraddr);
<>	144:ef7eb2e8f9f7	391	headeraddr+=4U;
<>	144:ef7eb2e8f9f7	392	hcryp->Instance->DR = (uint32_t)(headeraddr);
<>	144:ef7eb2e8f9f7	393	headeraddr+=4U;
<>	144:ef7eb2e8f9f7	394	hcryp->Instance->DR = (uint32_t)(headeraddr);
<>	144:ef7eb2e8f9f7	395	headeraddr+=4U;
<>	144:ef7eb2e8f9f7	396	}
<>	144:ef7eb2e8f9f7	397
<>	144:ef7eb2e8f9f7	398	/* Wait until the complete message has been processed */
<>	144:ef7eb2e8f9f7	399
<>	144:ef7eb2e8f9f7	400	/* Get tick */
<>	144:ef7eb2e8f9f7	401	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	402
<>	144:ef7eb2e8f9f7	403	while((hcryp->Instance->SR & CRYP_FLAG_BUSY) == CRYP_FLAG_BUSY)
<>	144:ef7eb2e8f9f7	404	{
<>	144:ef7eb2e8f9f7	405	/* Check for the Timeout */
<>	144:ef7eb2e8f9f7	406	if(Timeout != HAL_MAX_DELAY)
<>	144:ef7eb2e8f9f7	407	{
<>	144:ef7eb2e8f9f7	408	if((Timeout == 0U)\|\|((HAL_GetTick() - tickstart ) > Timeout))
<>	144:ef7eb2e8f9f7	409	{
<>	144:ef7eb2e8f9f7	410	/* Change state */
<>	144:ef7eb2e8f9f7	411	hcryp->State = HAL_CRYP_STATE_TIMEOUT;
<>	144:ef7eb2e8f9f7	412
<>	144:ef7eb2e8f9f7	413	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	414	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	415
<>	144:ef7eb2e8f9f7	416	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	417	}
<>	144:ef7eb2e8f9f7	418	}
<>	144:ef7eb2e8f9f7	419	}
<>	144:ef7eb2e8f9f7	420	}
<>	144:ef7eb2e8f9f7	421	/* Return function status */
<>	144:ef7eb2e8f9f7	422	return HAL_OK;
<>	144:ef7eb2e8f9f7	423	}
<>	144:ef7eb2e8f9f7	424
<>	144:ef7eb2e8f9f7	425	/**
<>	144:ef7eb2e8f9f7	426	* @brief Sets the DMA configuration and start the DMA transfer.
<>	144:ef7eb2e8f9f7	427	* @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	428	* the configuration information for CRYP module
<>	144:ef7eb2e8f9f7	429	* @param inputaddr: Address of the Input buffer
<>	144:ef7eb2e8f9f7	430	* @param Size: Size of the Input buffer, must be a multiple of 16
<>	144:ef7eb2e8f9f7	431	* @param outputaddr: Address of the Output buffer
<>	144:ef7eb2e8f9f7	432	* @retval None
<>	144:ef7eb2e8f9f7	433	*/
<>	144:ef7eb2e8f9f7	434	static void CRYPEx_GCMCCM_SetDMAConfig(CRYP_HandleTypeDef *hcryp, uint32_t inputaddr, uint16_t Size, uint32_t outputaddr)
<>	144:ef7eb2e8f9f7	435	{
<>	144:ef7eb2e8f9f7	436	/* Set the CRYP DMA transfer complete callback */
<>	144:ef7eb2e8f9f7	437	hcryp->hdmain->XferCpltCallback = CRYPEx_GCMCCM_DMAInCplt;
<>	144:ef7eb2e8f9f7	438	/* Set the DMA error callback */
<>	144:ef7eb2e8f9f7	439	hcryp->hdmain->XferErrorCallback = CRYPEx_GCMCCM_DMAError;
<>	144:ef7eb2e8f9f7	440
<>	144:ef7eb2e8f9f7	441	/* Set the CRYP DMA transfer complete callback */
<>	144:ef7eb2e8f9f7	442	hcryp->hdmaout->XferCpltCallback = CRYPEx_GCMCCM_DMAOutCplt;
<>	144:ef7eb2e8f9f7	443	/* Set the DMA error callback */
<>	144:ef7eb2e8f9f7	444	hcryp->hdmaout->XferErrorCallback = CRYPEx_GCMCCM_DMAError;
<>	144:ef7eb2e8f9f7	445
<>	144:ef7eb2e8f9f7	446	/* Enable the CRYP peripheral */
<>	144:ef7eb2e8f9f7	447	__HAL_CRYP_ENABLE(hcryp);
<>	144:ef7eb2e8f9f7	448
<>	144:ef7eb2e8f9f7	449	/* Enable the DMA In DMA Stream */
<>	144:ef7eb2e8f9f7	450	HAL_DMA_Start_IT(hcryp->hdmain, inputaddr, (uint32_t)&hcryp->Instance->DR, Size/4U);
<>	144:ef7eb2e8f9f7	451
<>	144:ef7eb2e8f9f7	452	/* Enable In DMA request */
<>	144:ef7eb2e8f9f7	453	hcryp->Instance->DMACR = CRYP_DMACR_DIEN;
<>	144:ef7eb2e8f9f7	454
<>	144:ef7eb2e8f9f7	455	/* Enable the DMA Out DMA Stream */
<>	144:ef7eb2e8f9f7	456	HAL_DMA_Start_IT(hcryp->hdmaout, (uint32_t)&hcryp->Instance->DOUT, outputaddr, Size/4U);
<>	144:ef7eb2e8f9f7	457
<>	144:ef7eb2e8f9f7	458	/* Enable Out DMA request */
<>	144:ef7eb2e8f9f7	459	hcryp->Instance->DMACR \|= CRYP_DMACR_DOEN;
<>	144:ef7eb2e8f9f7	460	}
<>	144:ef7eb2e8f9f7	461
<>	144:ef7eb2e8f9f7	462	/**
<>	144:ef7eb2e8f9f7	463	* @}
<>	144:ef7eb2e8f9f7	464	*/
<>	144:ef7eb2e8f9f7	465
<>	144:ef7eb2e8f9f7	466	/* Exported functions---------------------------------------------------------*/
<>	144:ef7eb2e8f9f7	467	/** @addtogroup CRYPEx_Exported_Functions
<>	144:ef7eb2e8f9f7	468	* @{
<>	144:ef7eb2e8f9f7	469	*/
<>	144:ef7eb2e8f9f7	470
<>	144:ef7eb2e8f9f7	471	/** @defgroup CRYPEx_Exported_Functions_Group1 Extended AES processing functions
<>	144:ef7eb2e8f9f7	472	* @brief Extended processing functions.
<>	144:ef7eb2e8f9f7	473	*
<>	144:ef7eb2e8f9f7	474	@verbatim
<>	144:ef7eb2e8f9f7	475	==============================================================================
<>	144:ef7eb2e8f9f7	476	##### Extended AES processing functions #####
<>	144:ef7eb2e8f9f7	477	==============================================================================
<>	144:ef7eb2e8f9f7	478	[..] This section provides functions allowing to:
<>	144:ef7eb2e8f9f7	479	(+) Encrypt plaintext using AES-128/192/256 using GCM and CCM chaining modes
<>	144:ef7eb2e8f9f7	480	(+) Decrypt cyphertext using AES-128/192/256 using GCM and CCM chaining modes
<>	144:ef7eb2e8f9f7	481	(+) Finish the processing. This function is available only for GCM and CCM
<>	144:ef7eb2e8f9f7	482	[..] Three processing methods are available:
<>	144:ef7eb2e8f9f7	483	(+) Polling mode
<>	144:ef7eb2e8f9f7	484	(+) Interrupt mode
<>	144:ef7eb2e8f9f7	485	(+) DMA mode
<>	144:ef7eb2e8f9f7	486
<>	144:ef7eb2e8f9f7	487	@endverbatim
<>	144:ef7eb2e8f9f7	488	* @{
<>	144:ef7eb2e8f9f7	489	*/
<>	144:ef7eb2e8f9f7	490
<>	144:ef7eb2e8f9f7	491
<>	144:ef7eb2e8f9f7	492	/**
<>	144:ef7eb2e8f9f7	493	* @brief Initializes the CRYP peripheral in AES CCM encryption mode then
<>	144:ef7eb2e8f9f7	494	* encrypt pPlainData. The cypher data are available in pCypherData.
<>	144:ef7eb2e8f9f7	495	* @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	496	* the configuration information for CRYP module
<>	144:ef7eb2e8f9f7	497	* @param pPlainData: Pointer to the plaintext buffer
<>	144:ef7eb2e8f9f7	498	* @param Size: Length of the plaintext buffer, must be a multiple of 16
<>	144:ef7eb2e8f9f7	499	* @param pCypherData: Pointer to the cyphertext buffer
<>	144:ef7eb2e8f9f7	500	* @param Timeout: Timeout duration
<>	144:ef7eb2e8f9f7	501	* @retval HAL status
<>	144:ef7eb2e8f9f7	502	*/
<>	144:ef7eb2e8f9f7	503	HAL_StatusTypeDef HAL_CRYPEx_AESCCM_Encrypt(CRYP_HandleTypeDef hcryp, uint8_t pPlainData, uint16_t Size, uint8_t *pCypherData, uint32_t Timeout)
<>	144:ef7eb2e8f9f7	504	{
<>	144:ef7eb2e8f9f7	505	uint32_t tickstart = 0U;
<>	144:ef7eb2e8f9f7	506	uint32_t headersize = hcryp->Init.HeaderSize;
<>	144:ef7eb2e8f9f7	507	uint32_t headeraddr = (uint32_t)hcryp->Init.Header;
<>	144:ef7eb2e8f9f7	508	uint32_t loopcounter = 0U;
<>	144:ef7eb2e8f9f7	509	uint32_t bufferidx = 0U;
<>	144:ef7eb2e8f9f7	510	uint8_t blockb0[16U] = {0U};/* Block B0 */
<>	144:ef7eb2e8f9f7	511	uint8_t ctr[16U] = {0U}; /* Counter */
<>	144:ef7eb2e8f9f7	512	uint32_t b0addr = (uint32_t)blockb0;
<>	144:ef7eb2e8f9f7	513
<>	144:ef7eb2e8f9f7	514	/* Process Locked */
<>	144:ef7eb2e8f9f7	515	__HAL_LOCK(hcryp);
<>	144:ef7eb2e8f9f7	516
<>	144:ef7eb2e8f9f7	517	/* Change the CRYP peripheral state */
<>	144:ef7eb2e8f9f7	518	hcryp->State = HAL_CRYP_STATE_BUSY;
<>	144:ef7eb2e8f9f7	519
<>	144:ef7eb2e8f9f7	520	/* Check if initialization phase has already been performed */
<>	144:ef7eb2e8f9f7	521	if(hcryp->Phase == HAL_CRYP_PHASE_READY)
<>	144:ef7eb2e8f9f7	522	{
<>	144:ef7eb2e8f9f7	523	/********************** Formatting the header block *******************/
<>	144:ef7eb2e8f9f7	524	if(headersize != 0U)
<>	144:ef7eb2e8f9f7	525	{
<>	144:ef7eb2e8f9f7	526	/* Check that the associated data (or header) length is lower than 2^16 - 2^8 = 65536 - 256 = 65280 */
<>	144:ef7eb2e8f9f7	527	if(headersize < 65280U)
<>	144:ef7eb2e8f9f7	528	{
<>	144:ef7eb2e8f9f7	529	hcryp->Init.pScratch[bufferidx++] = (uint8_t) ((headersize >> 8U) & 0xFFU);
<>	144:ef7eb2e8f9f7	530	hcryp->Init.pScratch[bufferidx++] = (uint8_t) ((headersize) & 0xFFU);
<>	144:ef7eb2e8f9f7	531	headersize += 2U;
<>	144:ef7eb2e8f9f7	532	}
<>	144:ef7eb2e8f9f7	533	else
<>	144:ef7eb2e8f9f7	534	{
<>	144:ef7eb2e8f9f7	535	/* Header is encoded as 0xff \|\| 0xfe \|\| [headersize]32, i.e., six octets */
<>	144:ef7eb2e8f9f7	536	hcryp->Init.pScratch[bufferidx++] = 0xFFU;
<>	144:ef7eb2e8f9f7	537	hcryp->Init.pScratch[bufferidx++] = 0xFEU;
<>	144:ef7eb2e8f9f7	538	hcryp->Init.pScratch[bufferidx++] = headersize & 0xff000000U;
<>	144:ef7eb2e8f9f7	539	hcryp->Init.pScratch[bufferidx++] = headersize & 0x00ff0000U;
<>	144:ef7eb2e8f9f7	540	hcryp->Init.pScratch[bufferidx++] = headersize & 0x0000ff00U;
<>	144:ef7eb2e8f9f7	541	hcryp->Init.pScratch[bufferidx++] = headersize & 0x000000ffU;
<>	144:ef7eb2e8f9f7	542	headersize += 6U;
<>	144:ef7eb2e8f9f7	543	}
<>	144:ef7eb2e8f9f7	544	/* Copy the header buffer in internal buffer "hcryp->Init.pScratch" */
<>	144:ef7eb2e8f9f7	545	for(loopcounter = 0U; loopcounter < headersize; loopcounter++)
<>	144:ef7eb2e8f9f7	546	{
<>	144:ef7eb2e8f9f7	547	hcryp->Init.pScratch[bufferidx++] = hcryp->Init.Header[loopcounter];
<>	144:ef7eb2e8f9f7	548	}
<>	144:ef7eb2e8f9f7	549	/* Check if the header size is modulo 16 */
<>	144:ef7eb2e8f9f7	550	if ((headersize % 16U) != 0U)
<>	144:ef7eb2e8f9f7	551	{
<>	144:ef7eb2e8f9f7	552	/* Padd the header buffer with 0s till the hcryp->Init.pScratch length is modulo 16 */
<>	144:ef7eb2e8f9f7	553	for(loopcounter = headersize; loopcounter <= ((headersize/16U) + 1U) * 16U; loopcounter++)
<>	144:ef7eb2e8f9f7	554	{
<>	144:ef7eb2e8f9f7	555	hcryp->Init.pScratch[loopcounter] = 0U;
<>	144:ef7eb2e8f9f7	556	}
<>	144:ef7eb2e8f9f7	557	/* Set the header size to modulo 16 */
<>	144:ef7eb2e8f9f7	558	headersize = ((headersize/16U) + 1U) * 16U;
<>	144:ef7eb2e8f9f7	559	}
<>	144:ef7eb2e8f9f7	560	/* Set the pointer headeraddr to hcryp->Init.pScratch */
<>	144:ef7eb2e8f9f7	561	headeraddr = (uint32_t)hcryp->Init.pScratch;
<>	144:ef7eb2e8f9f7	562	}
<>	144:ef7eb2e8f9f7	563	/********************* Formatting the block B0 ************************/
<>	144:ef7eb2e8f9f7	564	if(headersize != 0U)
<>	144:ef7eb2e8f9f7	565	{
<>	144:ef7eb2e8f9f7	566	blockb0[0U] = 0x40U;
<>	144:ef7eb2e8f9f7	567	}
<>	144:ef7eb2e8f9f7	568	/* Flags byte */
<>	144:ef7eb2e8f9f7	569	/* blockb0[0] \|= 0u \| (((( (uint8_t) hcryp->Init.TagSize - 2) / 2) & 0x07 ) << 3 ) \| ( ( (uint8_t) (15 - hcryp->Init.IVSize) - 1) & 0x07U) */
<>	144:ef7eb2e8f9f7	570	blockb0[0U] \|= (uint8_t)((uint8_t)((uint8_t)(((uint8_t)(hcryp->Init.TagSize - (uint8_t)(2U))) >> 1U) & (uint8_t)0x07U) << 3U);
<>	144:ef7eb2e8f9f7	571	blockb0[0U] \|= (uint8_t)((uint8_t)((uint8_t)((uint8_t)(15U) - hcryp->Init.IVSize) - (uint8_t)1U) & (uint8_t)0x07U);
<>	144:ef7eb2e8f9f7	572
<>	144:ef7eb2e8f9f7	573	for (loopcounter = 0U; loopcounter < hcryp->Init.IVSize; loopcounter++)
<>	144:ef7eb2e8f9f7	574	{
<>	144:ef7eb2e8f9f7	575	blockb0[loopcounter+1U] = hcryp->Init.pInitVect[loopcounter];
<>	144:ef7eb2e8f9f7	576	}
<>	144:ef7eb2e8f9f7	577	for ( ; loopcounter < 13U; loopcounter++)
<>	144:ef7eb2e8f9f7	578	{
<>	144:ef7eb2e8f9f7	579	blockb0[loopcounter+1U] = 0U;
<>	144:ef7eb2e8f9f7	580	}
<>	144:ef7eb2e8f9f7	581
<>	144:ef7eb2e8f9f7	582	blockb0[14U] = (Size >> 8U);
<>	144:ef7eb2e8f9f7	583	blockb0[15U] = (Size & 0xFFU);
<>	144:ef7eb2e8f9f7	584
<>	144:ef7eb2e8f9f7	585	/*********************** Formatting the initial counter ***************/
<>	144:ef7eb2e8f9f7	586	/* Byte 0:
<>	144:ef7eb2e8f9f7	587	Bits 7 and 6 are reserved and shall be set to 0
<>	144:ef7eb2e8f9f7	588	Bits 3, 4, and 5 shall also be set to 0, to ensure that all the counter blocks
<>	144:ef7eb2e8f9f7	589	are distinct from B0
<>	144:ef7eb2e8f9f7	590	Bits 0, 1, and 2 contain the same encoding of q as in B0
<>	144:ef7eb2e8f9f7	591	*/
<>	144:ef7eb2e8f9f7	592	ctr[0U] = blockb0[0U] & 0x07U;
<>	144:ef7eb2e8f9f7	593	/* byte 1 to NonceSize is the IV (Nonce) */
<>	144:ef7eb2e8f9f7	594	for(loopcounter = 1U; loopcounter < hcryp->Init.IVSize + 1U; loopcounter++)
<>	144:ef7eb2e8f9f7	595	{
<>	144:ef7eb2e8f9f7	596	ctr[loopcounter] = blockb0[loopcounter];
<>	144:ef7eb2e8f9f7	597	}
<>	144:ef7eb2e8f9f7	598	/* Set the LSB to 1 */
<>	144:ef7eb2e8f9f7	599	ctr[15U] \|= 0x01U;
<>	144:ef7eb2e8f9f7	600
<>	144:ef7eb2e8f9f7	601	/* Set the key */
<>	144:ef7eb2e8f9f7	602	CRYPEx_GCMCCM_SetKey(hcryp, hcryp->Init.pKey, hcryp->Init.KeySize);
<>	144:ef7eb2e8f9f7	603
<>	144:ef7eb2e8f9f7	604	/* Set the CRYP peripheral in AES CCM mode */
<>	144:ef7eb2e8f9f7	605	__HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CCM_ENCRYPT);
<>	144:ef7eb2e8f9f7	606
<>	144:ef7eb2e8f9f7	607	/* Set the Initialization Vector */
<>	144:ef7eb2e8f9f7	608	CRYPEx_GCMCCM_SetInitVector(hcryp, ctr);
<>	144:ef7eb2e8f9f7	609
<>	144:ef7eb2e8f9f7	610	/* Select init phase */
<>	144:ef7eb2e8f9f7	611	__HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_INIT);
<>	144:ef7eb2e8f9f7	612
<>	144:ef7eb2e8f9f7	613	b0addr = (uint32_t)blockb0;
<>	144:ef7eb2e8f9f7	614	/* Write the blockb0 block in the IN FIFO */
<>	144:ef7eb2e8f9f7	615	hcryp->Instance->DR = (uint32_t)(b0addr);
<>	144:ef7eb2e8f9f7	616	b0addr+=4U;
<>	144:ef7eb2e8f9f7	617	hcryp->Instance->DR = (uint32_t)(b0addr);
<>	144:ef7eb2e8f9f7	618	b0addr+=4U;
<>	144:ef7eb2e8f9f7	619	hcryp->Instance->DR = (uint32_t)(b0addr);
<>	144:ef7eb2e8f9f7	620	b0addr+=4U;
<>	144:ef7eb2e8f9f7	621	hcryp->Instance->DR = (uint32_t)(b0addr);
<>	144:ef7eb2e8f9f7	622
<>	144:ef7eb2e8f9f7	623	/* Enable the CRYP peripheral */
<>	144:ef7eb2e8f9f7	624	__HAL_CRYP_ENABLE(hcryp);
<>	144:ef7eb2e8f9f7	625
<>	144:ef7eb2e8f9f7	626	/* Get tick */
<>	144:ef7eb2e8f9f7	627	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	628
<>	144:ef7eb2e8f9f7	629	while((CRYP->CR & CRYP_CR_CRYPEN) == CRYP_CR_CRYPEN)
<>	144:ef7eb2e8f9f7	630	{
<>	144:ef7eb2e8f9f7	631	/* Check for the Timeout */
<>	144:ef7eb2e8f9f7	632	if(Timeout != HAL_MAX_DELAY)
<>	144:ef7eb2e8f9f7	633	{
<>	144:ef7eb2e8f9f7	634	if((Timeout == 0U)\|\|((HAL_GetTick() - tickstart ) > Timeout))
<>	144:ef7eb2e8f9f7	635	{
<>	144:ef7eb2e8f9f7	636	/* Change state */
<>	144:ef7eb2e8f9f7	637	hcryp->State = HAL_CRYP_STATE_TIMEOUT;
<>	144:ef7eb2e8f9f7	638
<>	144:ef7eb2e8f9f7	639	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	640	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	641
<>	144:ef7eb2e8f9f7	642	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	643	}
<>	144:ef7eb2e8f9f7	644	}
<>	144:ef7eb2e8f9f7	645	}
<>	144:ef7eb2e8f9f7	646	/*************************** Header phase *****************************/
<>	144:ef7eb2e8f9f7	647	if(headersize != 0U)
<>	144:ef7eb2e8f9f7	648	{
<>	144:ef7eb2e8f9f7	649	/* Select header phase */
<>	144:ef7eb2e8f9f7	650	__HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_HEADER);
<>	144:ef7eb2e8f9f7	651
<>	144:ef7eb2e8f9f7	652	/* Enable the CRYP peripheral */
<>	144:ef7eb2e8f9f7	653	__HAL_CRYP_ENABLE(hcryp);
<>	144:ef7eb2e8f9f7	654
<>	144:ef7eb2e8f9f7	655	for(loopcounter = 0U; (loopcounter < headersize); loopcounter+=16U)
<>	144:ef7eb2e8f9f7	656	{
<>	144:ef7eb2e8f9f7	657	/* Get tick */
<>	144:ef7eb2e8f9f7	658	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	659
<>	144:ef7eb2e8f9f7	660	while(HAL_IS_BIT_CLR(hcryp->Instance->SR, CRYP_FLAG_IFEM))
<>	144:ef7eb2e8f9f7	661	{
<>	144:ef7eb2e8f9f7	662	{
<>	144:ef7eb2e8f9f7	663	/* Check for the Timeout */
<>	144:ef7eb2e8f9f7	664	if(Timeout != HAL_MAX_DELAY)
<>	144:ef7eb2e8f9f7	665	{
<>	144:ef7eb2e8f9f7	666	if((Timeout == 0U)\|\|((HAL_GetTick() - tickstart ) > Timeout))
<>	144:ef7eb2e8f9f7	667	{
<>	144:ef7eb2e8f9f7	668	/* Change state */
<>	144:ef7eb2e8f9f7	669	hcryp->State = HAL_CRYP_STATE_TIMEOUT;
<>	144:ef7eb2e8f9f7	670
<>	144:ef7eb2e8f9f7	671	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	672	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	673
<>	144:ef7eb2e8f9f7	674	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	675	}
<>	144:ef7eb2e8f9f7	676	}
<>	144:ef7eb2e8f9f7	677	}
<>	144:ef7eb2e8f9f7	678	}
<>	144:ef7eb2e8f9f7	679	/* Write the header block in the IN FIFO */
<>	144:ef7eb2e8f9f7	680	hcryp->Instance->DR = (uint32_t)(headeraddr);
<>	144:ef7eb2e8f9f7	681	headeraddr+=4U;
<>	144:ef7eb2e8f9f7	682	hcryp->Instance->DR = (uint32_t)(headeraddr);
<>	144:ef7eb2e8f9f7	683	headeraddr+=4U;
<>	144:ef7eb2e8f9f7	684	hcryp->Instance->DR = (uint32_t)(headeraddr);
<>	144:ef7eb2e8f9f7	685	headeraddr+=4U;
<>	144:ef7eb2e8f9f7	686	hcryp->Instance->DR = (uint32_t)(headeraddr);
<>	144:ef7eb2e8f9f7	687	headeraddr+=4U;
<>	144:ef7eb2e8f9f7	688	}
<>	144:ef7eb2e8f9f7	689
<>	144:ef7eb2e8f9f7	690	/* Get tick */
<>	144:ef7eb2e8f9f7	691	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	692
<>	144:ef7eb2e8f9f7	693	while((hcryp->Instance->SR & CRYP_FLAG_BUSY) == CRYP_FLAG_BUSY)
<>	144:ef7eb2e8f9f7	694	{
<>	144:ef7eb2e8f9f7	695	/* Check for the Timeout */
<>	144:ef7eb2e8f9f7	696	if(Timeout != HAL_MAX_DELAY)
<>	144:ef7eb2e8f9f7	697	{
<>	144:ef7eb2e8f9f7	698	if((Timeout == 0U)\|\|((HAL_GetTick() - tickstart ) > Timeout))
<>	144:ef7eb2e8f9f7	699	{
<>	144:ef7eb2e8f9f7	700	/* Change state */
<>	144:ef7eb2e8f9f7	701	hcryp->State = HAL_CRYP_STATE_TIMEOUT;
<>	144:ef7eb2e8f9f7	702
<>	144:ef7eb2e8f9f7	703	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	704	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	705
<>	144:ef7eb2e8f9f7	706	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	707	}
<>	144:ef7eb2e8f9f7	708	}
<>	144:ef7eb2e8f9f7	709	}
<>	144:ef7eb2e8f9f7	710	}
<>	144:ef7eb2e8f9f7	711	/* Save formatted counter into the scratch buffer pScratch */
<>	144:ef7eb2e8f9f7	712	for(loopcounter = 0U; (loopcounter < 16U); loopcounter++)
<>	144:ef7eb2e8f9f7	713	{
<>	144:ef7eb2e8f9f7	714	hcryp->Init.pScratch[loopcounter] = ctr[loopcounter];
<>	144:ef7eb2e8f9f7	715	}
<>	144:ef7eb2e8f9f7	716	/* Reset bit 0 */
<>	144:ef7eb2e8f9f7	717	hcryp->Init.pScratch[15U] &= 0xFEU;
<>	144:ef7eb2e8f9f7	718
<>	144:ef7eb2e8f9f7	719	/* Select payload phase once the header phase is performed */
<>	144:ef7eb2e8f9f7	720	__HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_PAYLOAD);
<>	144:ef7eb2e8f9f7	721
<>	144:ef7eb2e8f9f7	722	/* Flush FIFO */
<>	144:ef7eb2e8f9f7	723	__HAL_CRYP_FIFO_FLUSH(hcryp);
<>	144:ef7eb2e8f9f7	724
<>	144:ef7eb2e8f9f7	725	/* Enable the CRYP peripheral */
<>	144:ef7eb2e8f9f7	726	__HAL_CRYP_ENABLE(hcryp);
<>	144:ef7eb2e8f9f7	727
<>	144:ef7eb2e8f9f7	728	/* Set the phase */
<>	144:ef7eb2e8f9f7	729	hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
<>	144:ef7eb2e8f9f7	730	}
<>	144:ef7eb2e8f9f7	731
<>	144:ef7eb2e8f9f7	732	/* Write Plain Data and Get Cypher Data */
<>	144:ef7eb2e8f9f7	733	if(CRYPEx_GCMCCM_ProcessData(hcryp,pPlainData, Size, pCypherData, Timeout) != HAL_OK)
<>	144:ef7eb2e8f9f7	734	{
<>	144:ef7eb2e8f9f7	735	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	736	}
<>	144:ef7eb2e8f9f7	737
<>	144:ef7eb2e8f9f7	738	/* Change the CRYP peripheral state */
<>	144:ef7eb2e8f9f7	739	hcryp->State = HAL_CRYP_STATE_READY;
<>	144:ef7eb2e8f9f7	740
<>	144:ef7eb2e8f9f7	741	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	742	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	743
<>	144:ef7eb2e8f9f7	744	/* Return function status */
<>	144:ef7eb2e8f9f7	745	return HAL_OK;
<>	144:ef7eb2e8f9f7	746	}
<>	144:ef7eb2e8f9f7	747
<>	144:ef7eb2e8f9f7	748	/**
<>	144:ef7eb2e8f9f7	749	* @brief Initializes the CRYP peripheral in AES GCM encryption mode then
<>	144:ef7eb2e8f9f7	750	* encrypt pPlainData. The cypher data are available in pCypherData.
<>	144:ef7eb2e8f9f7	751	* @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	752	* the configuration information for CRYP module
<>	144:ef7eb2e8f9f7	753	* @param pPlainData: Pointer to the plaintext buffer
<>	144:ef7eb2e8f9f7	754	* @param Size: Length of the plaintext buffer, must be a multiple of 16
<>	144:ef7eb2e8f9f7	755	* @param pCypherData: Pointer to the cyphertext buffer
<>	144:ef7eb2e8f9f7	756	* @param Timeout: Timeout duration
<>	144:ef7eb2e8f9f7	757	* @retval HAL status
<>	144:ef7eb2e8f9f7	758	*/
<>	144:ef7eb2e8f9f7	759	HAL_StatusTypeDef HAL_CRYPEx_AESGCM_Encrypt(CRYP_HandleTypeDef hcryp, uint8_t pPlainData, uint16_t Size, uint8_t *pCypherData, uint32_t Timeout)
<>	144:ef7eb2e8f9f7	760	{
<>	144:ef7eb2e8f9f7	761	uint32_t tickstart = 0U;
<>	144:ef7eb2e8f9f7	762
<>	144:ef7eb2e8f9f7	763	/* Process Locked */
<>	144:ef7eb2e8f9f7	764	__HAL_LOCK(hcryp);
<>	144:ef7eb2e8f9f7	765
<>	144:ef7eb2e8f9f7	766	/* Change the CRYP peripheral state */
<>	144:ef7eb2e8f9f7	767	hcryp->State = HAL_CRYP_STATE_BUSY;
<>	144:ef7eb2e8f9f7	768
<>	144:ef7eb2e8f9f7	769	/* Check if initialization phase has already been performed */
<>	144:ef7eb2e8f9f7	770	if(hcryp->Phase == HAL_CRYP_PHASE_READY)
<>	144:ef7eb2e8f9f7	771	{
<>	144:ef7eb2e8f9f7	772	/* Set the key */
<>	144:ef7eb2e8f9f7	773	CRYPEx_GCMCCM_SetKey(hcryp, hcryp->Init.pKey, hcryp->Init.KeySize);
<>	144:ef7eb2e8f9f7	774
<>	144:ef7eb2e8f9f7	775	/* Set the CRYP peripheral in AES GCM mode */
<>	144:ef7eb2e8f9f7	776	__HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_GCM_ENCRYPT);
<>	144:ef7eb2e8f9f7	777
<>	144:ef7eb2e8f9f7	778	/* Set the Initialization Vector */
<>	144:ef7eb2e8f9f7	779	CRYPEx_GCMCCM_SetInitVector(hcryp, hcryp->Init.pInitVect);
<>	144:ef7eb2e8f9f7	780
<>	144:ef7eb2e8f9f7	781	/* Flush FIFO */
<>	144:ef7eb2e8f9f7	782	__HAL_CRYP_FIFO_FLUSH(hcryp);
<>	144:ef7eb2e8f9f7	783
<>	144:ef7eb2e8f9f7	784	/* Enable the CRYP peripheral */
<>	144:ef7eb2e8f9f7	785	__HAL_CRYP_ENABLE(hcryp);
<>	144:ef7eb2e8f9f7	786
<>	144:ef7eb2e8f9f7	787	/* Get tick */
<>	144:ef7eb2e8f9f7	788	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	789
<>	144:ef7eb2e8f9f7	790	while((CRYP->CR & CRYP_CR_CRYPEN) == CRYP_CR_CRYPEN)
<>	144:ef7eb2e8f9f7	791	{
<>	144:ef7eb2e8f9f7	792	/* Check for the Timeout */
<>	144:ef7eb2e8f9f7	793	if(Timeout != HAL_MAX_DELAY)
<>	144:ef7eb2e8f9f7	794	{
<>	144:ef7eb2e8f9f7	795	if((Timeout == 0U)\|\|((HAL_GetTick() - tickstart ) > Timeout))
<>	144:ef7eb2e8f9f7	796	{
<>	144:ef7eb2e8f9f7	797	/* Change state */
<>	144:ef7eb2e8f9f7	798	hcryp->State = HAL_CRYP_STATE_TIMEOUT;
<>	144:ef7eb2e8f9f7	799
<>	144:ef7eb2e8f9f7	800	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	801	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	802
<>	144:ef7eb2e8f9f7	803	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	804	}
<>	144:ef7eb2e8f9f7	805	}
<>	144:ef7eb2e8f9f7	806	}
<>	144:ef7eb2e8f9f7	807
<>	144:ef7eb2e8f9f7	808	/* Set the header phase */
<>	144:ef7eb2e8f9f7	809	if(CRYPEx_GCMCCM_SetHeaderPhase(hcryp, hcryp->Init.Header, hcryp->Init.HeaderSize, Timeout) != HAL_OK)
<>	144:ef7eb2e8f9f7	810	{
<>	144:ef7eb2e8f9f7	811	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	812	}
<>	144:ef7eb2e8f9f7	813
<>	144:ef7eb2e8f9f7	814	/* Disable the CRYP peripheral */
<>	144:ef7eb2e8f9f7	815	__HAL_CRYP_DISABLE(hcryp);
<>	144:ef7eb2e8f9f7	816
<>	144:ef7eb2e8f9f7	817	/* Select payload phase once the header phase is performed */
<>	144:ef7eb2e8f9f7	818	__HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_PAYLOAD);
<>	144:ef7eb2e8f9f7	819
<>	144:ef7eb2e8f9f7	820	/* Flush FIFO */
<>	144:ef7eb2e8f9f7	821	__HAL_CRYP_FIFO_FLUSH(hcryp);
<>	144:ef7eb2e8f9f7	822
<>	144:ef7eb2e8f9f7	823	/* Enable the CRYP peripheral */
<>	144:ef7eb2e8f9f7	824	__HAL_CRYP_ENABLE(hcryp);
<>	144:ef7eb2e8f9f7	825
<>	144:ef7eb2e8f9f7	826	/* Set the phase */
<>	144:ef7eb2e8f9f7	827	hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
<>	144:ef7eb2e8f9f7	828	}
<>	144:ef7eb2e8f9f7	829
<>	144:ef7eb2e8f9f7	830	/* Write Plain Data and Get Cypher Data */
<>	144:ef7eb2e8f9f7	831	if(CRYPEx_GCMCCM_ProcessData(hcryp, pPlainData, Size, pCypherData, Timeout) != HAL_OK)
<>	144:ef7eb2e8f9f7	832	{
<>	144:ef7eb2e8f9f7	833	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	834	}
<>	144:ef7eb2e8f9f7	835
<>	144:ef7eb2e8f9f7	836	/* Change the CRYP peripheral state */
<>	144:ef7eb2e8f9f7	837	hcryp->State = HAL_CRYP_STATE_READY;
<>	144:ef7eb2e8f9f7	838
<>	144:ef7eb2e8f9f7	839	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	840	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	841
<>	144:ef7eb2e8f9f7	842	/* Return function status */
<>	144:ef7eb2e8f9f7	843	return HAL_OK;
<>	144:ef7eb2e8f9f7	844	}
<>	144:ef7eb2e8f9f7	845
<>	144:ef7eb2e8f9f7	846	/**
<>	144:ef7eb2e8f9f7	847	* @brief Initializes the CRYP peripheral in AES GCM decryption mode then
<>	144:ef7eb2e8f9f7	848	* decrypted pCypherData. The cypher data are available in pPlainData.
<>	144:ef7eb2e8f9f7	849	* @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	850	* the configuration information for CRYP module
<>	144:ef7eb2e8f9f7	851	* @param pCypherData: Pointer to the cyphertext buffer
<>	144:ef7eb2e8f9f7	852	* @param Size: Length of the cyphertext buffer, must be a multiple of 16
<>	144:ef7eb2e8f9f7	853	* @param pPlainData: Pointer to the plaintext buffer
<>	144:ef7eb2e8f9f7	854	* @param Timeout: Timeout duration
<>	144:ef7eb2e8f9f7	855	* @retval HAL status
<>	144:ef7eb2e8f9f7	856	*/
<>	144:ef7eb2e8f9f7	857	HAL_StatusTypeDef HAL_CRYPEx_AESGCM_Decrypt(CRYP_HandleTypeDef hcryp, uint8_t pCypherData, uint16_t Size, uint8_t *pPlainData, uint32_t Timeout)
<>	144:ef7eb2e8f9f7	858	{
<>	144:ef7eb2e8f9f7	859	uint32_t tickstart = 0U;
<>	144:ef7eb2e8f9f7	860
<>	144:ef7eb2e8f9f7	861	/* Process Locked */
<>	144:ef7eb2e8f9f7	862	__HAL_LOCK(hcryp);
<>	144:ef7eb2e8f9f7	863
<>	144:ef7eb2e8f9f7	864	/* Change the CRYP peripheral state */
<>	144:ef7eb2e8f9f7	865	hcryp->State = HAL_CRYP_STATE_BUSY;
<>	144:ef7eb2e8f9f7	866
<>	144:ef7eb2e8f9f7	867	/* Check if initialization phase has already been performed */
<>	144:ef7eb2e8f9f7	868	if(hcryp->Phase == HAL_CRYP_PHASE_READY)
<>	144:ef7eb2e8f9f7	869	{
<>	144:ef7eb2e8f9f7	870	/* Set the key */
<>	144:ef7eb2e8f9f7	871	CRYPEx_GCMCCM_SetKey(hcryp, hcryp->Init.pKey, hcryp->Init.KeySize);
<>	144:ef7eb2e8f9f7	872
<>	144:ef7eb2e8f9f7	873	/* Set the CRYP peripheral in AES GCM decryption mode */
<>	144:ef7eb2e8f9f7	874	__HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_GCM_DECRYPT);
<>	144:ef7eb2e8f9f7	875
<>	144:ef7eb2e8f9f7	876	/* Set the Initialization Vector */
<>	144:ef7eb2e8f9f7	877	CRYPEx_GCMCCM_SetInitVector(hcryp, hcryp->Init.pInitVect);
<>	144:ef7eb2e8f9f7	878
<>	144:ef7eb2e8f9f7	879	/* Flush FIFO */
<>	144:ef7eb2e8f9f7	880	__HAL_CRYP_FIFO_FLUSH(hcryp);
<>	144:ef7eb2e8f9f7	881
<>	144:ef7eb2e8f9f7	882	/* Enable the CRYP peripheral */
<>	144:ef7eb2e8f9f7	883	__HAL_CRYP_ENABLE(hcryp);
<>	144:ef7eb2e8f9f7	884
<>	144:ef7eb2e8f9f7	885	/* Get tick */
<>	144:ef7eb2e8f9f7	886	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	887
<>	144:ef7eb2e8f9f7	888	while((CRYP->CR & CRYP_CR_CRYPEN) == CRYP_CR_CRYPEN)
<>	144:ef7eb2e8f9f7	889	{
<>	144:ef7eb2e8f9f7	890	/* Check for the Timeout */
<>	144:ef7eb2e8f9f7	891	if(Timeout != HAL_MAX_DELAY)
<>	144:ef7eb2e8f9f7	892	{
<>	144:ef7eb2e8f9f7	893	if((Timeout == 0U)\|\|((HAL_GetTick() - tickstart ) > Timeout))
<>	144:ef7eb2e8f9f7	894	{
<>	144:ef7eb2e8f9f7	895	/* Change state */
<>	144:ef7eb2e8f9f7	896	hcryp->State = HAL_CRYP_STATE_TIMEOUT;
<>	144:ef7eb2e8f9f7	897
<>	144:ef7eb2e8f9f7	898	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	899	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	900
<>	144:ef7eb2e8f9f7	901	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	902	}
<>	144:ef7eb2e8f9f7	903	}
<>	144:ef7eb2e8f9f7	904	}
<>	144:ef7eb2e8f9f7	905
<>	144:ef7eb2e8f9f7	906	/* Set the header phase */
<>	144:ef7eb2e8f9f7	907	if(CRYPEx_GCMCCM_SetHeaderPhase(hcryp, hcryp->Init.Header, hcryp->Init.HeaderSize, Timeout) != HAL_OK)
<>	144:ef7eb2e8f9f7	908	{
<>	144:ef7eb2e8f9f7	909	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	910	}
<>	144:ef7eb2e8f9f7	911	/* Disable the CRYP peripheral */
<>	144:ef7eb2e8f9f7	912	__HAL_CRYP_DISABLE(hcryp);
<>	144:ef7eb2e8f9f7	913
<>	144:ef7eb2e8f9f7	914	/* Select payload phase once the header phase is performed */
<>	144:ef7eb2e8f9f7	915	__HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_PAYLOAD);
<>	144:ef7eb2e8f9f7	916
<>	144:ef7eb2e8f9f7	917	/* Enable the CRYP peripheral */
<>	144:ef7eb2e8f9f7	918	__HAL_CRYP_ENABLE(hcryp);
<>	144:ef7eb2e8f9f7	919
<>	144:ef7eb2e8f9f7	920	/* Set the phase */
<>	144:ef7eb2e8f9f7	921	hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
<>	144:ef7eb2e8f9f7	922	}
<>	144:ef7eb2e8f9f7	923
<>	144:ef7eb2e8f9f7	924	/* Write Plain Data and Get Cypher Data */
<>	144:ef7eb2e8f9f7	925	if(CRYPEx_GCMCCM_ProcessData(hcryp, pCypherData, Size, pPlainData, Timeout) != HAL_OK)
<>	144:ef7eb2e8f9f7	926	{
<>	144:ef7eb2e8f9f7	927	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	928	}
<>	144:ef7eb2e8f9f7	929
<>	144:ef7eb2e8f9f7	930	/* Change the CRYP peripheral state */
<>	144:ef7eb2e8f9f7	931	hcryp->State = HAL_CRYP_STATE_READY;
<>	144:ef7eb2e8f9f7	932
<>	144:ef7eb2e8f9f7	933	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	934	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	935
<>	144:ef7eb2e8f9f7	936	/* Return function status */
<>	144:ef7eb2e8f9f7	937	return HAL_OK;
<>	144:ef7eb2e8f9f7	938	}
<>	144:ef7eb2e8f9f7	939
<>	144:ef7eb2e8f9f7	940	/**
<>	144:ef7eb2e8f9f7	941	* @brief Computes the authentication TAG.
<>	144:ef7eb2e8f9f7	942	* @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	943	* the configuration information for CRYP module
<>	144:ef7eb2e8f9f7	944	* @param Size: Total length of the plain/cyphertext buffer
<>	144:ef7eb2e8f9f7	945	* @param AuthTag: Pointer to the authentication buffer
<>	144:ef7eb2e8f9f7	946	* @param Timeout: Timeout duration
<>	144:ef7eb2e8f9f7	947	* @retval HAL status
<>	144:ef7eb2e8f9f7	948	*/
<>	144:ef7eb2e8f9f7	949	HAL_StatusTypeDef HAL_CRYPEx_AESGCM_Finish(CRYP_HandleTypeDef hcryp, uint32_t Size, uint8_t AuthTag, uint32_t Timeout)
<>	144:ef7eb2e8f9f7	950	{
<>	144:ef7eb2e8f9f7	951	uint32_t tickstart = 0U;
<>	144:ef7eb2e8f9f7	952	uint64_t headerlength = hcryp->Init.HeaderSize * 8U; /* Header length in bits */
<>	144:ef7eb2e8f9f7	953	uint64_t inputlength = Size * 8U; /* input length in bits */
<>	144:ef7eb2e8f9f7	954	uint32_t tagaddr = (uint32_t)AuthTag;
<>	144:ef7eb2e8f9f7	955
<>	144:ef7eb2e8f9f7	956	/* Process Locked */
<>	144:ef7eb2e8f9f7	957	__HAL_LOCK(hcryp);
<>	144:ef7eb2e8f9f7	958
<>	144:ef7eb2e8f9f7	959	/* Change the CRYP peripheral state */
<>	144:ef7eb2e8f9f7	960	hcryp->State = HAL_CRYP_STATE_BUSY;
<>	144:ef7eb2e8f9f7	961
<>	144:ef7eb2e8f9f7	962	/* Check if initialization phase has already been performed */
<>	144:ef7eb2e8f9f7	963	if(hcryp->Phase == HAL_CRYP_PHASE_PROCESS)
<>	144:ef7eb2e8f9f7	964	{
<>	144:ef7eb2e8f9f7	965	/* Change the CRYP phase */
<>	144:ef7eb2e8f9f7	966	hcryp->Phase = HAL_CRYP_PHASE_FINAL;
<>	144:ef7eb2e8f9f7	967
<>	144:ef7eb2e8f9f7	968	/* Disable CRYP to start the final phase */
<>	144:ef7eb2e8f9f7	969	__HAL_CRYP_DISABLE(hcryp);
<>	144:ef7eb2e8f9f7	970
<>	144:ef7eb2e8f9f7	971	/* Select final phase */
<>	144:ef7eb2e8f9f7	972	__HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_FINAL);
<>	144:ef7eb2e8f9f7	973
<>	144:ef7eb2e8f9f7	974	/* Enable the CRYP peripheral */
<>	144:ef7eb2e8f9f7	975	__HAL_CRYP_ENABLE(hcryp);
<>	144:ef7eb2e8f9f7	976
<>	144:ef7eb2e8f9f7	977	/* Write the number of bits in header (64 bits) followed by the number of bits
<>	144:ef7eb2e8f9f7	978	in the payload */
<>	144:ef7eb2e8f9f7	979	if(hcryp->Init.DataType == CRYP_DATATYPE_1B)
<>	144:ef7eb2e8f9f7	980	{
<>	144:ef7eb2e8f9f7	981	hcryp->Instance->DR = __RBIT(headerlength >> 32U);
<>	144:ef7eb2e8f9f7	982	hcryp->Instance->DR = __RBIT(headerlength);
<>	144:ef7eb2e8f9f7	983	hcryp->Instance->DR = __RBIT(inputlength >> 32U);
<>	144:ef7eb2e8f9f7	984	hcryp->Instance->DR = __RBIT(inputlength);
<>	144:ef7eb2e8f9f7	985	}
<>	144:ef7eb2e8f9f7	986	else if(hcryp->Init.DataType == CRYP_DATATYPE_8B)
<>	144:ef7eb2e8f9f7	987	{
<>	144:ef7eb2e8f9f7	988	hcryp->Instance->DR = __REV(headerlength >> 32U);
<>	144:ef7eb2e8f9f7	989	hcryp->Instance->DR = __REV(headerlength);
<>	144:ef7eb2e8f9f7	990	hcryp->Instance->DR = __REV(inputlength >> 32U);
<>	144:ef7eb2e8f9f7	991	hcryp->Instance->DR = __REV(inputlength);
<>	144:ef7eb2e8f9f7	992	}
<>	144:ef7eb2e8f9f7	993	else if(hcryp->Init.DataType == CRYP_DATATYPE_16B)
<>	144:ef7eb2e8f9f7	994	{
<>	144:ef7eb2e8f9f7	995	hcryp->Instance->DR = __ROR((uint32_t)(headerlength >> 32U), 16U);
<>	144:ef7eb2e8f9f7	996	hcryp->Instance->DR = __ROR((uint32_t)headerlength, 16U);
<>	144:ef7eb2e8f9f7	997	hcryp->Instance->DR = __ROR((uint32_t)(inputlength >> 32U), 16U);
<>	144:ef7eb2e8f9f7	998	hcryp->Instance->DR = __ROR((uint32_t)inputlength, 16U);
<>	144:ef7eb2e8f9f7	999	}
<>	144:ef7eb2e8f9f7	1000	else if(hcryp->Init.DataType == CRYP_DATATYPE_32B)
<>	144:ef7eb2e8f9f7	1001	{
<>	144:ef7eb2e8f9f7	1002	hcryp->Instance->DR = (uint32_t)(headerlength >> 32U);
<>	144:ef7eb2e8f9f7	1003	hcryp->Instance->DR = (uint32_t)(headerlength);
<>	144:ef7eb2e8f9f7	1004	hcryp->Instance->DR = (uint32_t)(inputlength >> 32U);
<>	144:ef7eb2e8f9f7	1005	hcryp->Instance->DR = (uint32_t)(inputlength);
<>	144:ef7eb2e8f9f7	1006	}
<>	144:ef7eb2e8f9f7	1007	/* Get tick */
<>	144:ef7eb2e8f9f7	1008	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	1009
<>	144:ef7eb2e8f9f7	1010	while(HAL_IS_BIT_CLR(hcryp->Instance->SR, CRYP_FLAG_OFNE))
<>	144:ef7eb2e8f9f7	1011	{
<>	144:ef7eb2e8f9f7	1012	/* Check for the Timeout */
<>	144:ef7eb2e8f9f7	1013	if(Timeout != HAL_MAX_DELAY)
<>	144:ef7eb2e8f9f7	1014	{
<>	144:ef7eb2e8f9f7	1015	if((Timeout == 0U)\|\|((HAL_GetTick() - tickstart ) > Timeout))
<>	144:ef7eb2e8f9f7	1016	{
<>	144:ef7eb2e8f9f7	1017	/* Change state */
<>	144:ef7eb2e8f9f7	1018	hcryp->State = HAL_CRYP_STATE_TIMEOUT;
<>	144:ef7eb2e8f9f7	1019
<>	144:ef7eb2e8f9f7	1020	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	1021	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	1022
<>	144:ef7eb2e8f9f7	1023	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	1024	}
<>	144:ef7eb2e8f9f7	1025	}
<>	144:ef7eb2e8f9f7	1026	}
<>	144:ef7eb2e8f9f7	1027
<>	144:ef7eb2e8f9f7	1028	/* Read the Auth TAG in the IN FIFO */
<>	144:ef7eb2e8f9f7	1029	(uint32_t)(tagaddr) = hcryp->Instance->DOUT;
<>	144:ef7eb2e8f9f7	1030	tagaddr+=4U;
<>	144:ef7eb2e8f9f7	1031	(uint32_t)(tagaddr) = hcryp->Instance->DOUT;
<>	144:ef7eb2e8f9f7	1032	tagaddr+=4U;
<>	144:ef7eb2e8f9f7	1033	(uint32_t)(tagaddr) = hcryp->Instance->DOUT;
<>	144:ef7eb2e8f9f7	1034	tagaddr+=4U;
<>	144:ef7eb2e8f9f7	1035	(uint32_t)(tagaddr) = hcryp->Instance->DOUT;
<>	144:ef7eb2e8f9f7	1036	}
<>	144:ef7eb2e8f9f7	1037
<>	144:ef7eb2e8f9f7	1038	/* Change the CRYP peripheral state */
<>	144:ef7eb2e8f9f7	1039	hcryp->State = HAL_CRYP_STATE_READY;
<>	144:ef7eb2e8f9f7	1040
<>	144:ef7eb2e8f9f7	1041	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	1042	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	1043
<>	144:ef7eb2e8f9f7	1044	/* Return function status */
<>	144:ef7eb2e8f9f7	1045	return HAL_OK;
<>	144:ef7eb2e8f9f7	1046	}
<>	144:ef7eb2e8f9f7	1047
<>	144:ef7eb2e8f9f7	1048	/**
<>	144:ef7eb2e8f9f7	1049	* @brief Computes the authentication TAG for AES CCM mode.
<>	144:ef7eb2e8f9f7	1050	* @note This API is called after HAL_AES_CCM_Encrypt()/HAL_AES_CCM_Decrypt()
<>	144:ef7eb2e8f9f7	1051	* @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	1052	* the configuration information for CRYP module
<>	144:ef7eb2e8f9f7	1053	* @param AuthTag: Pointer to the authentication buffer
<>	144:ef7eb2e8f9f7	1054	* @param Timeout: Timeout duration
<>	144:ef7eb2e8f9f7	1055	* @retval HAL status
<>	144:ef7eb2e8f9f7	1056	*/
<>	144:ef7eb2e8f9f7	1057	HAL_StatusTypeDef HAL_CRYPEx_AESCCM_Finish(CRYP_HandleTypeDef hcryp, uint8_t AuthTag, uint32_t Timeout)
<>	144:ef7eb2e8f9f7	1058	{
<>	144:ef7eb2e8f9f7	1059	uint32_t tickstart = 0U;
<>	144:ef7eb2e8f9f7	1060	uint32_t tagaddr = (uint32_t)AuthTag;
<>	144:ef7eb2e8f9f7	1061	uint32_t ctraddr = (uint32_t)hcryp->Init.pScratch;
<>	144:ef7eb2e8f9f7	1062	uint32_t temptag[4U] = {0U}; /* Temporary TAG (MAC) */
<>	144:ef7eb2e8f9f7	1063	uint32_t loopcounter;
<>	144:ef7eb2e8f9f7	1064
<>	144:ef7eb2e8f9f7	1065	/* Process Locked */
<>	144:ef7eb2e8f9f7	1066	__HAL_LOCK(hcryp);
<>	144:ef7eb2e8f9f7	1067
<>	144:ef7eb2e8f9f7	1068	/* Change the CRYP peripheral state */
<>	144:ef7eb2e8f9f7	1069	hcryp->State = HAL_CRYP_STATE_BUSY;
<>	144:ef7eb2e8f9f7	1070
<>	144:ef7eb2e8f9f7	1071	/* Check if initialization phase has already been performed */
<>	144:ef7eb2e8f9f7	1072	if(hcryp->Phase == HAL_CRYP_PHASE_PROCESS)
<>	144:ef7eb2e8f9f7	1073	{
<>	144:ef7eb2e8f9f7	1074	/* Change the CRYP phase */
<>	144:ef7eb2e8f9f7	1075	hcryp->Phase = HAL_CRYP_PHASE_FINAL;
<>	144:ef7eb2e8f9f7	1076
<>	144:ef7eb2e8f9f7	1077	/* Disable CRYP to start the final phase */
<>	144:ef7eb2e8f9f7	1078	__HAL_CRYP_DISABLE(hcryp);
<>	144:ef7eb2e8f9f7	1079
<>	144:ef7eb2e8f9f7	1080	/* Select final phase */
<>	144:ef7eb2e8f9f7	1081	__HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_FINAL);
<>	144:ef7eb2e8f9f7	1082
<>	144:ef7eb2e8f9f7	1083	/* Enable the CRYP peripheral */
<>	144:ef7eb2e8f9f7	1084	__HAL_CRYP_ENABLE(hcryp);
<>	144:ef7eb2e8f9f7	1085
<>	144:ef7eb2e8f9f7	1086	/* Write the counter block in the IN FIFO */
<>	144:ef7eb2e8f9f7	1087	hcryp->Instance->DR = (uint32_t)ctraddr;
<>	144:ef7eb2e8f9f7	1088	ctraddr+=4U;
<>	144:ef7eb2e8f9f7	1089	hcryp->Instance->DR = (uint32_t)ctraddr;
<>	144:ef7eb2e8f9f7	1090	ctraddr+=4U;
<>	144:ef7eb2e8f9f7	1091	hcryp->Instance->DR = (uint32_t)ctraddr;
<>	144:ef7eb2e8f9f7	1092	ctraddr+=4U;
<>	144:ef7eb2e8f9f7	1093	hcryp->Instance->DR = (uint32_t)ctraddr;
<>	144:ef7eb2e8f9f7	1094
<>	144:ef7eb2e8f9f7	1095	/* Get tick */
<>	144:ef7eb2e8f9f7	1096	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	1097
<>	144:ef7eb2e8f9f7	1098	while(HAL_IS_BIT_CLR(hcryp->Instance->SR, CRYP_FLAG_OFNE))
<>	144:ef7eb2e8f9f7	1099	{
<>	144:ef7eb2e8f9f7	1100	/* Check for the Timeout */
<>	144:ef7eb2e8f9f7	1101	if(Timeout != HAL_MAX_DELAY)
<>	144:ef7eb2e8f9f7	1102	{
<>	144:ef7eb2e8f9f7	1103	if((Timeout == 0U)\|\|((HAL_GetTick() - tickstart ) > Timeout))
<>	144:ef7eb2e8f9f7	1104	{
<>	144:ef7eb2e8f9f7	1105	/* Change state */
<>	144:ef7eb2e8f9f7	1106	hcryp->State = HAL_CRYP_STATE_TIMEOUT;
<>	144:ef7eb2e8f9f7	1107
<>	144:ef7eb2e8f9f7	1108	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	1109	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	1110
<>	144:ef7eb2e8f9f7	1111	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	1112	}
<>	144:ef7eb2e8f9f7	1113	}
<>	144:ef7eb2e8f9f7	1114	}
<>	144:ef7eb2e8f9f7	1115
<>	144:ef7eb2e8f9f7	1116	/* Read the Auth TAG in the IN FIFO */
<>	144:ef7eb2e8f9f7	1117	temptag[0U] = hcryp->Instance->DOUT;
<>	144:ef7eb2e8f9f7	1118	temptag[1U] = hcryp->Instance->DOUT;
<>	144:ef7eb2e8f9f7	1119	temptag[2U] = hcryp->Instance->DOUT;
<>	144:ef7eb2e8f9f7	1120	temptag[3U] = hcryp->Instance->DOUT;
<>	144:ef7eb2e8f9f7	1121	}
<>	144:ef7eb2e8f9f7	1122
<>	144:ef7eb2e8f9f7	1123	/* Copy temporary authentication TAG in user TAG buffer */
<>	144:ef7eb2e8f9f7	1124	for(loopcounter = 0U; loopcounter < hcryp->Init.TagSize ; loopcounter++)
<>	144:ef7eb2e8f9f7	1125	{
<>	144:ef7eb2e8f9f7	1126	/* Set the authentication TAG buffer */
<>	144:ef7eb2e8f9f7	1127	((uint8_t)tagaddr+loopcounter) = ((uint8_t)temptag+loopcounter);
<>	144:ef7eb2e8f9f7	1128	}
<>	144:ef7eb2e8f9f7	1129
<>	144:ef7eb2e8f9f7	1130	/* Change the CRYP peripheral state */
<>	144:ef7eb2e8f9f7	1131	hcryp->State = HAL_CRYP_STATE_READY;
<>	144:ef7eb2e8f9f7	1132
<>	144:ef7eb2e8f9f7	1133	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	1134	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	1135
<>	144:ef7eb2e8f9f7	1136	/* Return function status */
<>	144:ef7eb2e8f9f7	1137	return HAL_OK;
<>	144:ef7eb2e8f9f7	1138	}
<>	144:ef7eb2e8f9f7	1139
<>	144:ef7eb2e8f9f7	1140	/**
<>	144:ef7eb2e8f9f7	1141	* @brief Initializes the CRYP peripheral in AES CCM decryption mode then
<>	144:ef7eb2e8f9f7	1142	* decrypted pCypherData. The cypher data are available in pPlainData.
<>	144:ef7eb2e8f9f7	1143	* @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	1144	* the configuration information for CRYP module
<>	144:ef7eb2e8f9f7	1145	* @param pPlainData: Pointer to the plaintext buffer
<>	144:ef7eb2e8f9f7	1146	* @param Size: Length of the plaintext buffer, must be a multiple of 16
<>	144:ef7eb2e8f9f7	1147	* @param pCypherData: Pointer to the cyphertext buffer
<>	144:ef7eb2e8f9f7	1148	* @param Timeout: Timeout duration
<>	144:ef7eb2e8f9f7	1149	* @retval HAL status
<>	144:ef7eb2e8f9f7	1150	*/
<>	144:ef7eb2e8f9f7	1151	HAL_StatusTypeDef HAL_CRYPEx_AESCCM_Decrypt(CRYP_HandleTypeDef hcryp, uint8_t pCypherData, uint16_t Size, uint8_t *pPlainData, uint32_t Timeout)
<>	144:ef7eb2e8f9f7	1152	{
<>	144:ef7eb2e8f9f7	1153	uint32_t tickstart = 0U;
<>	144:ef7eb2e8f9f7	1154	uint32_t headersize = hcryp->Init.HeaderSize;
<>	144:ef7eb2e8f9f7	1155	uint32_t headeraddr = (uint32_t)hcryp->Init.Header;
<>	144:ef7eb2e8f9f7	1156	uint32_t loopcounter = 0U;
<>	144:ef7eb2e8f9f7	1157	uint32_t bufferidx = 0U;
<>	144:ef7eb2e8f9f7	1158	uint8_t blockb0[16U] = {0U};/* Block B0 */
<>	144:ef7eb2e8f9f7	1159	uint8_t ctr[16U] = {0U}; /* Counter */
<>	144:ef7eb2e8f9f7	1160	uint32_t b0addr = (uint32_t)blockb0;
<>	144:ef7eb2e8f9f7	1161
<>	144:ef7eb2e8f9f7	1162	/* Process Locked */
<>	144:ef7eb2e8f9f7	1163	__HAL_LOCK(hcryp);
<>	144:ef7eb2e8f9f7	1164
<>	144:ef7eb2e8f9f7	1165	/* Change the CRYP peripheral state */
<>	144:ef7eb2e8f9f7	1166	hcryp->State = HAL_CRYP_STATE_BUSY;
<>	144:ef7eb2e8f9f7	1167
<>	144:ef7eb2e8f9f7	1168	/* Check if initialization phase has already been performed */
<>	144:ef7eb2e8f9f7	1169	if(hcryp->Phase == HAL_CRYP_PHASE_READY)
<>	144:ef7eb2e8f9f7	1170	{
<>	144:ef7eb2e8f9f7	1171	/********************** Formatting the header block *******************/
<>	144:ef7eb2e8f9f7	1172	if(headersize != 0U)
<>	144:ef7eb2e8f9f7	1173	{
<>	144:ef7eb2e8f9f7	1174	/* Check that the associated data (or header) length is lower than 2^16 - 2^8 = 65536 - 256 = 65280 */
<>	144:ef7eb2e8f9f7	1175	if(headersize < 65280U)
<>	144:ef7eb2e8f9f7	1176	{
<>	144:ef7eb2e8f9f7	1177	hcryp->Init.pScratch[bufferidx++] = (uint8_t) ((headersize >> 8U) & 0xFFU);
<>	144:ef7eb2e8f9f7	1178	hcryp->Init.pScratch[bufferidx++] = (uint8_t) ((headersize) & 0xFFU);
<>	144:ef7eb2e8f9f7	1179	headersize += 2U;
<>	144:ef7eb2e8f9f7	1180	}
<>	144:ef7eb2e8f9f7	1181	else
<>	144:ef7eb2e8f9f7	1182	{
<>	144:ef7eb2e8f9f7	1183	/* Header is encoded as 0xff \|\| 0xfe \|\| [headersize]32, i.e., six octets */
<>	144:ef7eb2e8f9f7	1184	hcryp->Init.pScratch[bufferidx++] = 0xFFU;
<>	144:ef7eb2e8f9f7	1185	hcryp->Init.pScratch[bufferidx++] = 0xFEU;
<>	144:ef7eb2e8f9f7	1186	hcryp->Init.pScratch[bufferidx++] = headersize & 0xff000000U;
<>	144:ef7eb2e8f9f7	1187	hcryp->Init.pScratch[bufferidx++] = headersize & 0x00ff0000U;
<>	144:ef7eb2e8f9f7	1188	hcryp->Init.pScratch[bufferidx++] = headersize & 0x0000ff00U;
<>	144:ef7eb2e8f9f7	1189	hcryp->Init.pScratch[bufferidx++] = headersize & 0x000000ffU;
<>	144:ef7eb2e8f9f7	1190	headersize += 6U;
<>	144:ef7eb2e8f9f7	1191	}
<>	144:ef7eb2e8f9f7	1192	/* Copy the header buffer in internal buffer "hcryp->Init.pScratch" */
<>	144:ef7eb2e8f9f7	1193	for(loopcounter = 0U; loopcounter < headersize; loopcounter++)
<>	144:ef7eb2e8f9f7	1194	{
<>	144:ef7eb2e8f9f7	1195	hcryp->Init.pScratch[bufferidx++] = hcryp->Init.Header[loopcounter];
<>	144:ef7eb2e8f9f7	1196	}
<>	144:ef7eb2e8f9f7	1197	/* Check if the header size is modulo 16 */
<>	144:ef7eb2e8f9f7	1198	if ((headersize % 16U) != 0U)
<>	144:ef7eb2e8f9f7	1199	{
<>	144:ef7eb2e8f9f7	1200	/* Padd the header buffer with 0s till the hcryp->Init.pScratch length is modulo 16 */
<>	144:ef7eb2e8f9f7	1201	for(loopcounter = headersize; loopcounter <= ((headersize/16U) + 1U) * 16U; loopcounter++)
<>	144:ef7eb2e8f9f7	1202	{
<>	144:ef7eb2e8f9f7	1203	hcryp->Init.pScratch[loopcounter] = 0U;
<>	144:ef7eb2e8f9f7	1204	}
<>	144:ef7eb2e8f9f7	1205	/* Set the header size to modulo 16 */
<>	144:ef7eb2e8f9f7	1206	headersize = ((headersize/16U) + 1U) * 16U;
<>	144:ef7eb2e8f9f7	1207	}
<>	144:ef7eb2e8f9f7	1208	/* Set the pointer headeraddr to hcryp->Init.pScratch */
<>	144:ef7eb2e8f9f7	1209	headeraddr = (uint32_t)hcryp->Init.pScratch;
<>	144:ef7eb2e8f9f7	1210	}
<>	144:ef7eb2e8f9f7	1211	/********************* Formatting the block B0 ************************/
<>	144:ef7eb2e8f9f7	1212	if(headersize != 0U)
<>	144:ef7eb2e8f9f7	1213	{
<>	144:ef7eb2e8f9f7	1214	blockb0[0U] = 0x40U;
<>	144:ef7eb2e8f9f7	1215	}
<>	144:ef7eb2e8f9f7	1216	/* Flags byte */
<>	144:ef7eb2e8f9f7	1217	/* blockb0[0] \|= 0u \| (((( (uint8_t) hcryp->Init.TagSize - 2) / 2) & 0x07 ) << 3 ) \| ( ( (uint8_t) (15 - hcryp->Init.IVSize) - 1) & 0x07U) */
<>	144:ef7eb2e8f9f7	1218	blockb0[0U] \|= (uint8_t)((uint8_t)((uint8_t)(((uint8_t)(hcryp->Init.TagSize - (uint8_t)(2U))) >> 1U) & (uint8_t)0x07U) << 3U);
<>	144:ef7eb2e8f9f7	1219	blockb0[0U] \|= (uint8_t)((uint8_t)((uint8_t)((uint8_t)(15U) - hcryp->Init.IVSize) - (uint8_t)1U) & (uint8_t)0x07U);
<>	144:ef7eb2e8f9f7	1220
<>	144:ef7eb2e8f9f7	1221	for (loopcounter = 0U; loopcounter < hcryp->Init.IVSize; loopcounter++)
<>	144:ef7eb2e8f9f7	1222	{
<>	144:ef7eb2e8f9f7	1223	blockb0[loopcounter+1U] = hcryp->Init.pInitVect[loopcounter];
<>	144:ef7eb2e8f9f7	1224	}
<>	144:ef7eb2e8f9f7	1225	for ( ; loopcounter < 13U; loopcounter++)
<>	144:ef7eb2e8f9f7	1226	{
<>	144:ef7eb2e8f9f7	1227	blockb0[loopcounter+1U] = 0U;
<>	144:ef7eb2e8f9f7	1228	}
<>	144:ef7eb2e8f9f7	1229
<>	144:ef7eb2e8f9f7	1230	blockb0[14U] = (Size >> 8U);
<>	144:ef7eb2e8f9f7	1231	blockb0[15U] = (Size & 0xFFU);
<>	144:ef7eb2e8f9f7	1232
<>	144:ef7eb2e8f9f7	1233	/*********************** Formatting the initial counter ***************/
<>	144:ef7eb2e8f9f7	1234	/* Byte 0:
<>	144:ef7eb2e8f9f7	1235	Bits 7 and 6 are reserved and shall be set to 0
<>	144:ef7eb2e8f9f7	1236	Bits 3, 4, and 5 shall also be set to 0, to ensure that all the counter
<>	144:ef7eb2e8f9f7	1237	blocks are distinct from B0
<>	144:ef7eb2e8f9f7	1238	Bits 0, 1, and 2 contain the same encoding of q as in B0
<>	144:ef7eb2e8f9f7	1239	*/
<>	144:ef7eb2e8f9f7	1240	ctr[0U] = blockb0[0U] & 0x07U;
<>	144:ef7eb2e8f9f7	1241	/* byte 1 to NonceSize is the IV (Nonce) */
<>	144:ef7eb2e8f9f7	1242	for(loopcounter = 1U; loopcounter < hcryp->Init.IVSize + 1U; loopcounter++)
<>	144:ef7eb2e8f9f7	1243	{
<>	144:ef7eb2e8f9f7	1244	ctr[loopcounter] = blockb0[loopcounter];
<>	144:ef7eb2e8f9f7	1245	}
<>	144:ef7eb2e8f9f7	1246	/* Set the LSB to 1 */
<>	144:ef7eb2e8f9f7	1247	ctr[15U] \|= 0x01U;
<>	144:ef7eb2e8f9f7	1248
<>	144:ef7eb2e8f9f7	1249	/* Set the key */
<>	144:ef7eb2e8f9f7	1250	CRYPEx_GCMCCM_SetKey(hcryp, hcryp->Init.pKey, hcryp->Init.KeySize);
<>	144:ef7eb2e8f9f7	1251
<>	144:ef7eb2e8f9f7	1252	/* Set the CRYP peripheral in AES CCM mode */
<>	144:ef7eb2e8f9f7	1253	__HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CCM_DECRYPT);
<>	144:ef7eb2e8f9f7	1254
<>	144:ef7eb2e8f9f7	1255	/* Set the Initialization Vector */
<>	144:ef7eb2e8f9f7	1256	CRYPEx_GCMCCM_SetInitVector(hcryp, ctr);
<>	144:ef7eb2e8f9f7	1257
<>	144:ef7eb2e8f9f7	1258	/* Select init phase */
<>	144:ef7eb2e8f9f7	1259	__HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_INIT);
<>	144:ef7eb2e8f9f7	1260
<>	144:ef7eb2e8f9f7	1261	b0addr = (uint32_t)blockb0;
<>	144:ef7eb2e8f9f7	1262	/* Write the blockb0 block in the IN FIFO */
<>	144:ef7eb2e8f9f7	1263	hcryp->Instance->DR = (uint32_t)(b0addr);
<>	144:ef7eb2e8f9f7	1264	b0addr+=4U;
<>	144:ef7eb2e8f9f7	1265	hcryp->Instance->DR = (uint32_t)(b0addr);
<>	144:ef7eb2e8f9f7	1266	b0addr+=4U;
<>	144:ef7eb2e8f9f7	1267	hcryp->Instance->DR = (uint32_t)(b0addr);
<>	144:ef7eb2e8f9f7	1268	b0addr+=4U;
<>	144:ef7eb2e8f9f7	1269	hcryp->Instance->DR = (uint32_t)(b0addr);
<>	144:ef7eb2e8f9f7	1270
<>	144:ef7eb2e8f9f7	1271	/* Enable the CRYP peripheral */
<>	144:ef7eb2e8f9f7	1272	__HAL_CRYP_ENABLE(hcryp);
<>	144:ef7eb2e8f9f7	1273
<>	144:ef7eb2e8f9f7	1274	/* Get tick */
<>	144:ef7eb2e8f9f7	1275	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	1276
<>	144:ef7eb2e8f9f7	1277	while((CRYP->CR & CRYP_CR_CRYPEN) == CRYP_CR_CRYPEN)
<>	144:ef7eb2e8f9f7	1278	{
<>	144:ef7eb2e8f9f7	1279	/* Check for the Timeout */
<>	144:ef7eb2e8f9f7	1280	if(Timeout != HAL_MAX_DELAY)
<>	144:ef7eb2e8f9f7	1281	{
<>	144:ef7eb2e8f9f7	1282	if((Timeout == 0U)\|\|((HAL_GetTick() - tickstart ) > Timeout))
<>	144:ef7eb2e8f9f7	1283	{
<>	144:ef7eb2e8f9f7	1284	/* Change state */
<>	144:ef7eb2e8f9f7	1285	hcryp->State = HAL_CRYP_STATE_TIMEOUT;
<>	144:ef7eb2e8f9f7	1286
<>	144:ef7eb2e8f9f7	1287	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	1288	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	1289
<>	144:ef7eb2e8f9f7	1290	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	1291	}
<>	144:ef7eb2e8f9f7	1292	}
<>	144:ef7eb2e8f9f7	1293	}
<>	144:ef7eb2e8f9f7	1294	/*************************** Header phase *****************************/
<>	144:ef7eb2e8f9f7	1295	if(headersize != 0U)
<>	144:ef7eb2e8f9f7	1296	{
<>	144:ef7eb2e8f9f7	1297	/* Select header phase */
<>	144:ef7eb2e8f9f7	1298	__HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_HEADER);
<>	144:ef7eb2e8f9f7	1299
<>	144:ef7eb2e8f9f7	1300	/* Enable Crypto processor */
<>	144:ef7eb2e8f9f7	1301	__HAL_CRYP_ENABLE(hcryp);
<>	144:ef7eb2e8f9f7	1302
<>	144:ef7eb2e8f9f7	1303	for(loopcounter = 0U; (loopcounter < headersize); loopcounter+=16U)
<>	144:ef7eb2e8f9f7	1304	{
<>	144:ef7eb2e8f9f7	1305	/* Get tick */
<>	144:ef7eb2e8f9f7	1306	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	1307
<>	144:ef7eb2e8f9f7	1308	while(HAL_IS_BIT_CLR(hcryp->Instance->SR, CRYP_FLAG_IFEM))
<>	144:ef7eb2e8f9f7	1309	{
<>	144:ef7eb2e8f9f7	1310	/* Check for the Timeout */
<>	144:ef7eb2e8f9f7	1311	if(Timeout != HAL_MAX_DELAY)
<>	144:ef7eb2e8f9f7	1312	{
<>	144:ef7eb2e8f9f7	1313	if((Timeout == 0U)\|\|((HAL_GetTick() - tickstart ) > Timeout))
<>	144:ef7eb2e8f9f7	1314	{
<>	144:ef7eb2e8f9f7	1315	/* Change state */
<>	144:ef7eb2e8f9f7	1316	hcryp->State = HAL_CRYP_STATE_TIMEOUT;
<>	144:ef7eb2e8f9f7	1317
<>	144:ef7eb2e8f9f7	1318	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	1319	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	1320
<>	144:ef7eb2e8f9f7	1321	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	1322	}
<>	144:ef7eb2e8f9f7	1323	}
<>	144:ef7eb2e8f9f7	1324	}
<>	144:ef7eb2e8f9f7	1325	/* Write the header block in the IN FIFO */
<>	144:ef7eb2e8f9f7	1326	hcryp->Instance->DR = (uint32_t)(headeraddr);
<>	144:ef7eb2e8f9f7	1327	headeraddr+=4U;
<>	144:ef7eb2e8f9f7	1328	hcryp->Instance->DR = (uint32_t)(headeraddr);
<>	144:ef7eb2e8f9f7	1329	headeraddr+=4U;
<>	144:ef7eb2e8f9f7	1330	hcryp->Instance->DR = (uint32_t)(headeraddr);
<>	144:ef7eb2e8f9f7	1331	headeraddr+=4U;
<>	144:ef7eb2e8f9f7	1332	hcryp->Instance->DR = (uint32_t)(headeraddr);
<>	144:ef7eb2e8f9f7	1333	headeraddr+=4U;
<>	144:ef7eb2e8f9f7	1334	}
<>	144:ef7eb2e8f9f7	1335
<>	144:ef7eb2e8f9f7	1336	/* Get tick */
<>	144:ef7eb2e8f9f7	1337	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	1338
<>	144:ef7eb2e8f9f7	1339	while((hcryp->Instance->SR & CRYP_FLAG_BUSY) == CRYP_FLAG_BUSY)
<>	144:ef7eb2e8f9f7	1340	{
<>	144:ef7eb2e8f9f7	1341	/* Check for the Timeout */
<>	144:ef7eb2e8f9f7	1342	if(Timeout != HAL_MAX_DELAY)
<>	144:ef7eb2e8f9f7	1343	{
<>	144:ef7eb2e8f9f7	1344	if((Timeout == 0U)\|\|((HAL_GetTick() - tickstart ) > Timeout))
<>	144:ef7eb2e8f9f7	1345	{
<>	144:ef7eb2e8f9f7	1346	/* Change state */
<>	144:ef7eb2e8f9f7	1347	hcryp->State = HAL_CRYP_STATE_TIMEOUT;
<>	144:ef7eb2e8f9f7	1348
<>	144:ef7eb2e8f9f7	1349	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	1350	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	1351
<>	144:ef7eb2e8f9f7	1352	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	1353	}
<>	144:ef7eb2e8f9f7	1354	}
<>	144:ef7eb2e8f9f7	1355	}
<>	144:ef7eb2e8f9f7	1356	}
<>	144:ef7eb2e8f9f7	1357	/* Save formatted counter into the scratch buffer pScratch */
<>	144:ef7eb2e8f9f7	1358	for(loopcounter = 0U; (loopcounter < 16U); loopcounter++)
<>	144:ef7eb2e8f9f7	1359	{
<>	144:ef7eb2e8f9f7	1360	hcryp->Init.pScratch[loopcounter] = ctr[loopcounter];
<>	144:ef7eb2e8f9f7	1361	}
<>	144:ef7eb2e8f9f7	1362	/* Reset bit 0 */
<>	144:ef7eb2e8f9f7	1363	hcryp->Init.pScratch[15U] &= 0xFEU;
<>	144:ef7eb2e8f9f7	1364	/* Select payload phase once the header phase is performed */
<>	144:ef7eb2e8f9f7	1365	__HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_PAYLOAD);
<>	144:ef7eb2e8f9f7	1366
<>	144:ef7eb2e8f9f7	1367	/* Flush FIFO */
<>	144:ef7eb2e8f9f7	1368	__HAL_CRYP_FIFO_FLUSH(hcryp);
<>	144:ef7eb2e8f9f7	1369
<>	144:ef7eb2e8f9f7	1370	/* Enable the CRYP peripheral */
<>	144:ef7eb2e8f9f7	1371	__HAL_CRYP_ENABLE(hcryp);
<>	144:ef7eb2e8f9f7	1372
<>	144:ef7eb2e8f9f7	1373	/* Set the phase */
<>	144:ef7eb2e8f9f7	1374	hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
<>	144:ef7eb2e8f9f7	1375	}
<>	144:ef7eb2e8f9f7	1376
<>	144:ef7eb2e8f9f7	1377	/* Write Plain Data and Get Cypher Data */
<>	144:ef7eb2e8f9f7	1378	if(CRYPEx_GCMCCM_ProcessData(hcryp, pCypherData, Size, pPlainData, Timeout) != HAL_OK)
<>	144:ef7eb2e8f9f7	1379	{
<>	144:ef7eb2e8f9f7	1380	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	1381	}
<>	144:ef7eb2e8f9f7	1382
<>	144:ef7eb2e8f9f7	1383	/* Change the CRYP peripheral state */
<>	144:ef7eb2e8f9f7	1384	hcryp->State = HAL_CRYP_STATE_READY;
<>	144:ef7eb2e8f9f7	1385
<>	144:ef7eb2e8f9f7	1386	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	1387	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	1388
<>	144:ef7eb2e8f9f7	1389	/* Return function status */
<>	144:ef7eb2e8f9f7	1390	return HAL_OK;
<>	144:ef7eb2e8f9f7	1391	}
<>	144:ef7eb2e8f9f7	1392
<>	144:ef7eb2e8f9f7	1393	/**
<>	144:ef7eb2e8f9f7	1394	* @brief Initializes the CRYP peripheral in AES GCM encryption mode using IT.
<>	144:ef7eb2e8f9f7	1395	* @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	1396	* the configuration information for CRYP module
<>	144:ef7eb2e8f9f7	1397	* @param pPlainData: Pointer to the plaintext buffer
<>	144:ef7eb2e8f9f7	1398	* @param Size: Length of the plaintext buffer, must be a multiple of 16
<>	144:ef7eb2e8f9f7	1399	* @param pCypherData: Pointer to the cyphertext buffer
<>	144:ef7eb2e8f9f7	1400	* @retval HAL status
<>	144:ef7eb2e8f9f7	1401	*/
<>	144:ef7eb2e8f9f7	1402	HAL_StatusTypeDef HAL_CRYPEx_AESGCM_Encrypt_IT(CRYP_HandleTypeDef hcryp, uint8_t pPlainData, uint16_t Size, uint8_t *pCypherData)
<>	144:ef7eb2e8f9f7	1403	{
<>	144:ef7eb2e8f9f7	1404	uint32_t tickstart = 0U;
<>	144:ef7eb2e8f9f7	1405	uint32_t inputaddr;
<>	144:ef7eb2e8f9f7	1406	uint32_t outputaddr;
<>	144:ef7eb2e8f9f7	1407
<>	144:ef7eb2e8f9f7	1408	if(hcryp->State == HAL_CRYP_STATE_READY)
<>	144:ef7eb2e8f9f7	1409	{
<>	144:ef7eb2e8f9f7	1410	/* Process Locked */
<>	144:ef7eb2e8f9f7	1411	__HAL_LOCK(hcryp);
<>	144:ef7eb2e8f9f7	1412
<>	144:ef7eb2e8f9f7	1413	/* Get the buffer addresses and sizes */
<>	144:ef7eb2e8f9f7	1414	hcryp->CrypInCount = Size;
<>	144:ef7eb2e8f9f7	1415	hcryp->pCrypInBuffPtr = pPlainData;
<>	144:ef7eb2e8f9f7	1416	hcryp->pCrypOutBuffPtr = pCypherData;
<>	144:ef7eb2e8f9f7	1417	hcryp->CrypOutCount = Size;
<>	144:ef7eb2e8f9f7	1418
<>	144:ef7eb2e8f9f7	1419	/* Change the CRYP peripheral state */
<>	144:ef7eb2e8f9f7	1420	hcryp->State = HAL_CRYP_STATE_BUSY;
<>	144:ef7eb2e8f9f7	1421
<>	144:ef7eb2e8f9f7	1422	/* Check if initialization phase has already been performed */
<>	144:ef7eb2e8f9f7	1423	if(hcryp->Phase == HAL_CRYP_PHASE_READY)
<>	144:ef7eb2e8f9f7	1424	{
<>	144:ef7eb2e8f9f7	1425	/* Set the key */
<>	144:ef7eb2e8f9f7	1426	CRYPEx_GCMCCM_SetKey(hcryp, hcryp->Init.pKey, hcryp->Init.KeySize);
<>	144:ef7eb2e8f9f7	1427
<>	144:ef7eb2e8f9f7	1428	/* Set the CRYP peripheral in AES GCM mode */
<>	144:ef7eb2e8f9f7	1429	__HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_GCM_ENCRYPT);
<>	144:ef7eb2e8f9f7	1430
<>	144:ef7eb2e8f9f7	1431	/* Set the Initialization Vector */
<>	144:ef7eb2e8f9f7	1432	CRYPEx_GCMCCM_SetInitVector(hcryp, hcryp->Init.pInitVect);
<>	144:ef7eb2e8f9f7	1433
<>	144:ef7eb2e8f9f7	1434	/* Flush FIFO */
<>	144:ef7eb2e8f9f7	1435	__HAL_CRYP_FIFO_FLUSH(hcryp);
<>	144:ef7eb2e8f9f7	1436
<>	144:ef7eb2e8f9f7	1437	/* Enable CRYP to start the init phase */
<>	144:ef7eb2e8f9f7	1438	__HAL_CRYP_ENABLE(hcryp);
<>	144:ef7eb2e8f9f7	1439
<>	144:ef7eb2e8f9f7	1440	/* Get tick */
<>	144:ef7eb2e8f9f7	1441	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	1442
<>	144:ef7eb2e8f9f7	1443	while((CRYP->CR & CRYP_CR_CRYPEN) == CRYP_CR_CRYPEN)
<>	144:ef7eb2e8f9f7	1444	{
<>	144:ef7eb2e8f9f7	1445	/* Check for the Timeout */
<>	144:ef7eb2e8f9f7	1446
<>	144:ef7eb2e8f9f7	1447	if((HAL_GetTick() - tickstart ) > CRYPEx_TIMEOUT_VALUE)
<>	144:ef7eb2e8f9f7	1448	{
<>	144:ef7eb2e8f9f7	1449	/* Change state */
<>	144:ef7eb2e8f9f7	1450	hcryp->State = HAL_CRYP_STATE_TIMEOUT;
<>	144:ef7eb2e8f9f7	1451
<>	144:ef7eb2e8f9f7	1452	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	1453	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	1454
<>	144:ef7eb2e8f9f7	1455	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	1456
<>	144:ef7eb2e8f9f7	1457	}
<>	144:ef7eb2e8f9f7	1458	}
<>	144:ef7eb2e8f9f7	1459
<>	144:ef7eb2e8f9f7	1460	/* Set the header phase */
<>	144:ef7eb2e8f9f7	1461	if(CRYPEx_GCMCCM_SetHeaderPhase(hcryp, hcryp->Init.Header, hcryp->Init.HeaderSize, 1U) != HAL_OK)
<>	144:ef7eb2e8f9f7	1462	{
<>	144:ef7eb2e8f9f7	1463	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	1464	}
<>	144:ef7eb2e8f9f7	1465	/* Disable the CRYP peripheral */
<>	144:ef7eb2e8f9f7	1466	__HAL_CRYP_DISABLE(hcryp);
<>	144:ef7eb2e8f9f7	1467
<>	144:ef7eb2e8f9f7	1468	/* Select payload phase once the header phase is performed */
<>	144:ef7eb2e8f9f7	1469	__HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_PAYLOAD);
<>	144:ef7eb2e8f9f7	1470
<>	144:ef7eb2e8f9f7	1471	/* Flush FIFO */
<>	144:ef7eb2e8f9f7	1472	__HAL_CRYP_FIFO_FLUSH(hcryp);
<>	144:ef7eb2e8f9f7	1473
<>	144:ef7eb2e8f9f7	1474	/* Set the phase */
<>	144:ef7eb2e8f9f7	1475	hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
<>	144:ef7eb2e8f9f7	1476	}
<>	144:ef7eb2e8f9f7	1477
<>	144:ef7eb2e8f9f7	1478	if(Size != 0U)
<>	144:ef7eb2e8f9f7	1479	{
<>	144:ef7eb2e8f9f7	1480	/* Enable Interrupts */
<>	144:ef7eb2e8f9f7	1481	__HAL_CRYP_ENABLE_IT(hcryp, CRYP_IT_INI \| CRYP_IT_OUTI);
<>	144:ef7eb2e8f9f7	1482	/* Enable the CRYP peripheral */
<>	144:ef7eb2e8f9f7	1483	__HAL_CRYP_ENABLE(hcryp);
<>	144:ef7eb2e8f9f7	1484	}
<>	144:ef7eb2e8f9f7	1485	else
<>	144:ef7eb2e8f9f7	1486	{
<>	144:ef7eb2e8f9f7	1487	/* Process Locked */
<>	144:ef7eb2e8f9f7	1488	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	1489	/* Change the CRYP state and phase */
<>	144:ef7eb2e8f9f7	1490	hcryp->State = HAL_CRYP_STATE_READY;
<>	144:ef7eb2e8f9f7	1491	}
<>	144:ef7eb2e8f9f7	1492	/* Return function status */
<>	144:ef7eb2e8f9f7	1493	return HAL_OK;
<>	144:ef7eb2e8f9f7	1494	}
<>	144:ef7eb2e8f9f7	1495	else if (__HAL_CRYP_GET_IT(hcryp, CRYP_IT_INI))
<>	144:ef7eb2e8f9f7	1496	{
<>	144:ef7eb2e8f9f7	1497	inputaddr = (uint32_t)hcryp->pCrypInBuffPtr;
<>	144:ef7eb2e8f9f7	1498	/* Write the Input block in the IN FIFO */
<>	144:ef7eb2e8f9f7	1499	hcryp->Instance->DR = (uint32_t)(inputaddr);
<>	144:ef7eb2e8f9f7	1500	inputaddr+=4U;
<>	144:ef7eb2e8f9f7	1501	hcryp->Instance->DR = (uint32_t)(inputaddr);
<>	144:ef7eb2e8f9f7	1502	inputaddr+=4U;
<>	144:ef7eb2e8f9f7	1503	hcryp->Instance->DR = (uint32_t)(inputaddr);
<>	144:ef7eb2e8f9f7	1504	inputaddr+=4U;
<>	144:ef7eb2e8f9f7	1505	hcryp->Instance->DR = (uint32_t)(inputaddr);
<>	144:ef7eb2e8f9f7	1506	hcryp->pCrypInBuffPtr += 16U;
<>	144:ef7eb2e8f9f7	1507	hcryp->CrypInCount -= 16U;
<>	144:ef7eb2e8f9f7	1508	if(hcryp->CrypInCount == 0U)
<>	144:ef7eb2e8f9f7	1509	{
<>	144:ef7eb2e8f9f7	1510	__HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_INI);
<>	144:ef7eb2e8f9f7	1511	/* Call the Input data transfer complete callback */
<>	144:ef7eb2e8f9f7	1512	HAL_CRYP_InCpltCallback(hcryp);
<>	144:ef7eb2e8f9f7	1513	}
<>	144:ef7eb2e8f9f7	1514	}
<>	144:ef7eb2e8f9f7	1515	else if (__HAL_CRYP_GET_IT(hcryp, CRYP_IT_OUTI))
<>	144:ef7eb2e8f9f7	1516	{
<>	144:ef7eb2e8f9f7	1517	outputaddr = (uint32_t)hcryp->pCrypOutBuffPtr;
<>	144:ef7eb2e8f9f7	1518	/* Read the Output block from the Output FIFO */
<>	144:ef7eb2e8f9f7	1519	(uint32_t)(outputaddr) = hcryp->Instance->DOUT;
<>	144:ef7eb2e8f9f7	1520	outputaddr+=4U;
<>	144:ef7eb2e8f9f7	1521	(uint32_t)(outputaddr) = hcryp->Instance->DOUT;
<>	144:ef7eb2e8f9f7	1522	outputaddr+=4U;
<>	144:ef7eb2e8f9f7	1523	(uint32_t)(outputaddr) = hcryp->Instance->DOUT;
<>	144:ef7eb2e8f9f7	1524	outputaddr+=4U;
<>	144:ef7eb2e8f9f7	1525	(uint32_t)(outputaddr) = hcryp->Instance->DOUT;
<>	144:ef7eb2e8f9f7	1526	hcryp->pCrypOutBuffPtr += 16U;
<>	144:ef7eb2e8f9f7	1527	hcryp->CrypOutCount -= 16U;
<>	144:ef7eb2e8f9f7	1528	if(hcryp->CrypOutCount == 0U)
<>	144:ef7eb2e8f9f7	1529	{
<>	144:ef7eb2e8f9f7	1530	__HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_OUTI);
<>	144:ef7eb2e8f9f7	1531	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	1532	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	1533	/* Change the CRYP peripheral state */
<>	144:ef7eb2e8f9f7	1534	hcryp->State = HAL_CRYP_STATE_READY;
<>	144:ef7eb2e8f9f7	1535	/* Call Input transfer complete callback */
<>	144:ef7eb2e8f9f7	1536	HAL_CRYP_OutCpltCallback(hcryp);
<>	144:ef7eb2e8f9f7	1537	}
<>	144:ef7eb2e8f9f7	1538	}
<>	144:ef7eb2e8f9f7	1539
<>	144:ef7eb2e8f9f7	1540	/* Return function status */
<>	144:ef7eb2e8f9f7	1541	return HAL_OK;
<>	144:ef7eb2e8f9f7	1542	}
<>	144:ef7eb2e8f9f7	1543
<>	144:ef7eb2e8f9f7	1544	/**
<>	144:ef7eb2e8f9f7	1545	* @brief Initializes the CRYP peripheral in AES CCM encryption mode using interrupt.
<>	144:ef7eb2e8f9f7	1546	* @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	1547	* the configuration information for CRYP module
<>	144:ef7eb2e8f9f7	1548	* @param pPlainData: Pointer to the plaintext buffer
<>	144:ef7eb2e8f9f7	1549	* @param Size: Length of the plaintext buffer, must be a multiple of 16
<>	144:ef7eb2e8f9f7	1550	* @param pCypherData: Pointer to the cyphertext buffer
<>	144:ef7eb2e8f9f7	1551	* @retval HAL status
<>	144:ef7eb2e8f9f7	1552	*/
<>	144:ef7eb2e8f9f7	1553	HAL_StatusTypeDef HAL_CRYPEx_AESCCM_Encrypt_IT(CRYP_HandleTypeDef hcryp, uint8_t pPlainData, uint16_t Size, uint8_t *pCypherData)
<>	144:ef7eb2e8f9f7	1554	{
<>	144:ef7eb2e8f9f7	1555	uint32_t tickstart = 0U;
<>	144:ef7eb2e8f9f7	1556	uint32_t inputaddr;
<>	144:ef7eb2e8f9f7	1557	uint32_t outputaddr;
<>	144:ef7eb2e8f9f7	1558
<>	144:ef7eb2e8f9f7	1559	uint32_t headersize = hcryp->Init.HeaderSize;
<>	144:ef7eb2e8f9f7	1560	uint32_t headeraddr = (uint32_t)hcryp->Init.Header;
<>	144:ef7eb2e8f9f7	1561	uint32_t loopcounter = 0U;
<>	144:ef7eb2e8f9f7	1562	uint32_t bufferidx = 0U;
<>	144:ef7eb2e8f9f7	1563	uint8_t blockb0[16U] = {0U};/* Block B0 */
<>	144:ef7eb2e8f9f7	1564	uint8_t ctr[16U] = {0U}; /* Counter */
<>	144:ef7eb2e8f9f7	1565	uint32_t b0addr = (uint32_t)blockb0;
<>	144:ef7eb2e8f9f7	1566
<>	144:ef7eb2e8f9f7	1567	if(hcryp->State == HAL_CRYP_STATE_READY)
<>	144:ef7eb2e8f9f7	1568	{
<>	144:ef7eb2e8f9f7	1569	/* Process Locked */
<>	144:ef7eb2e8f9f7	1570	__HAL_LOCK(hcryp);
<>	144:ef7eb2e8f9f7	1571
<>	144:ef7eb2e8f9f7	1572	hcryp->CrypInCount = Size;
<>	144:ef7eb2e8f9f7	1573	hcryp->pCrypInBuffPtr = pPlainData;
<>	144:ef7eb2e8f9f7	1574	hcryp->pCrypOutBuffPtr = pCypherData;
<>	144:ef7eb2e8f9f7	1575	hcryp->CrypOutCount = Size;
<>	144:ef7eb2e8f9f7	1576
<>	144:ef7eb2e8f9f7	1577	/* Change the CRYP peripheral state */
<>	144:ef7eb2e8f9f7	1578	hcryp->State = HAL_CRYP_STATE_BUSY;
<>	144:ef7eb2e8f9f7	1579
<>	144:ef7eb2e8f9f7	1580	/* Check if initialization phase has already been performed */
<>	144:ef7eb2e8f9f7	1581	if(hcryp->Phase == HAL_CRYP_PHASE_READY)
<>	144:ef7eb2e8f9f7	1582	{
<>	144:ef7eb2e8f9f7	1583	/********************** Formatting the header block *****************/
<>	144:ef7eb2e8f9f7	1584	if(headersize != 0U)
<>	144:ef7eb2e8f9f7	1585	{
<>	144:ef7eb2e8f9f7	1586	/* Check that the associated data (or header) length is lower than 2^16 - 2^8 = 65536 - 256 = 65280 */
<>	144:ef7eb2e8f9f7	1587	if(headersize < 65280U)
<>	144:ef7eb2e8f9f7	1588	{
<>	144:ef7eb2e8f9f7	1589	hcryp->Init.pScratch[bufferidx++] = (uint8_t) ((headersize >> 8U) & 0xFFU);
<>	144:ef7eb2e8f9f7	1590	hcryp->Init.pScratch[bufferidx++] = (uint8_t) ((headersize) & 0xFFU);
<>	144:ef7eb2e8f9f7	1591	headersize += 2U;
<>	144:ef7eb2e8f9f7	1592	}
<>	144:ef7eb2e8f9f7	1593	else
<>	144:ef7eb2e8f9f7	1594	{
<>	144:ef7eb2e8f9f7	1595	/* Header is encoded as 0xff \|\| 0xfe \|\| [headersize]32, i.e., six octets */
<>	144:ef7eb2e8f9f7	1596	hcryp->Init.pScratch[bufferidx++] = 0xFFU;
<>	144:ef7eb2e8f9f7	1597	hcryp->Init.pScratch[bufferidx++] = 0xFEU;
<>	144:ef7eb2e8f9f7	1598	hcryp->Init.pScratch[bufferidx++] = headersize & 0xff000000U;
<>	144:ef7eb2e8f9f7	1599	hcryp->Init.pScratch[bufferidx++] = headersize & 0x00ff0000U;
<>	144:ef7eb2e8f9f7	1600	hcryp->Init.pScratch[bufferidx++] = headersize & 0x0000ff00U;
<>	144:ef7eb2e8f9f7	1601	hcryp->Init.pScratch[bufferidx++] = headersize & 0x000000ffU;
<>	144:ef7eb2e8f9f7	1602	headersize += 6U;
<>	144:ef7eb2e8f9f7	1603	}
<>	144:ef7eb2e8f9f7	1604	/* Copy the header buffer in internal buffer "hcryp->Init.pScratch" */
<>	144:ef7eb2e8f9f7	1605	for(loopcounter = 0U; loopcounter < headersize; loopcounter++)
<>	144:ef7eb2e8f9f7	1606	{
<>	144:ef7eb2e8f9f7	1607	hcryp->Init.pScratch[bufferidx++] = hcryp->Init.Header[loopcounter];
<>	144:ef7eb2e8f9f7	1608	}
<>	144:ef7eb2e8f9f7	1609	/* Check if the header size is modulo 16 */
<>	144:ef7eb2e8f9f7	1610	if ((headersize % 16U) != 0U)
<>	144:ef7eb2e8f9f7	1611	{
<>	144:ef7eb2e8f9f7	1612	/* Padd the header buffer with 0s till the hcryp->Init.pScratch length is modulo 16 */
<>	144:ef7eb2e8f9f7	1613	for(loopcounter = headersize; loopcounter <= ((headersize/16U) + 1U) * 16U; loopcounter++)
<>	144:ef7eb2e8f9f7	1614	{
<>	144:ef7eb2e8f9f7	1615	hcryp->Init.pScratch[loopcounter] = 0U;
<>	144:ef7eb2e8f9f7	1616	}
<>	144:ef7eb2e8f9f7	1617	/* Set the header size to modulo 16 */
<>	144:ef7eb2e8f9f7	1618	headersize = ((headersize/16U) + 1U) * 16U;
<>	144:ef7eb2e8f9f7	1619	}
<>	144:ef7eb2e8f9f7	1620	/* Set the pointer headeraddr to hcryp->Init.pScratch */
<>	144:ef7eb2e8f9f7	1621	headeraddr = (uint32_t)hcryp->Init.pScratch;
<>	144:ef7eb2e8f9f7	1622	}
<>	144:ef7eb2e8f9f7	1623	/********************* Formatting the block B0 **********************/
<>	144:ef7eb2e8f9f7	1624	if(headersize != 0U)
<>	144:ef7eb2e8f9f7	1625	{
<>	144:ef7eb2e8f9f7	1626	blockb0[0U] = 0x40U;
<>	144:ef7eb2e8f9f7	1627	}
<>	144:ef7eb2e8f9f7	1628	/* Flags byte */
<>	144:ef7eb2e8f9f7	1629	/* blockb0[0] \|= 0u \| (((( (uint8_t) hcryp->Init.TagSize - 2) / 2) & 0x07 ) << 3 ) \| ( ( (uint8_t) (15 - hcryp->Init.IVSize) - 1) & 0x07U) */
<>	144:ef7eb2e8f9f7	1630	blockb0[0U] \|= (uint8_t)((uint8_t)((uint8_t)(((uint8_t)(hcryp->Init.TagSize - (uint8_t)(2U))) >> 1U) & (uint8_t)0x07U) << 3U);
<>	144:ef7eb2e8f9f7	1631	blockb0[0U] \|= (uint8_t)((uint8_t)((uint8_t)((uint8_t)(15U) - hcryp->Init.IVSize) - (uint8_t)1U) & (uint8_t)0x07U);
<>	144:ef7eb2e8f9f7	1632
<>	144:ef7eb2e8f9f7	1633	for (loopcounter = 0U; loopcounter < hcryp->Init.IVSize; loopcounter++)
<>	144:ef7eb2e8f9f7	1634	{
<>	144:ef7eb2e8f9f7	1635	blockb0[loopcounter+1U] = hcryp->Init.pInitVect[loopcounter];
<>	144:ef7eb2e8f9f7	1636	}
<>	144:ef7eb2e8f9f7	1637	for ( ; loopcounter < 13U; loopcounter++)
<>	144:ef7eb2e8f9f7	1638	{
<>	144:ef7eb2e8f9f7	1639	blockb0[loopcounter+1U] = 0U;
<>	144:ef7eb2e8f9f7	1640	}
<>	144:ef7eb2e8f9f7	1641
<>	144:ef7eb2e8f9f7	1642	blockb0[14U] = (Size >> 8U);
<>	144:ef7eb2e8f9f7	1643	blockb0[15U] = (Size & 0xFFU);
<>	144:ef7eb2e8f9f7	1644
<>	144:ef7eb2e8f9f7	1645	/*********************** Formatting the initial counter *************/
<>	144:ef7eb2e8f9f7	1646	/* Byte 0:
<>	144:ef7eb2e8f9f7	1647	Bits 7 and 6 are reserved and shall be set to 0
<>	144:ef7eb2e8f9f7	1648	Bits 3, 4, and 5 shall also be set to 0, to ensure that all the counter
<>	144:ef7eb2e8f9f7	1649	blocks are distinct from B0
<>	144:ef7eb2e8f9f7	1650	Bits 0, 1, and 2 contain the same encoding of q as in B0
<>	144:ef7eb2e8f9f7	1651	*/
<>	144:ef7eb2e8f9f7	1652	ctr[0U] = blockb0[0U] & 0x07U;
<>	144:ef7eb2e8f9f7	1653	/* byte 1 to NonceSize is the IV (Nonce) */
<>	144:ef7eb2e8f9f7	1654	for(loopcounter = 1; loopcounter < hcryp->Init.IVSize + 1U; loopcounter++)
<>	144:ef7eb2e8f9f7	1655	{
<>	144:ef7eb2e8f9f7	1656	ctr[loopcounter] = blockb0[loopcounter];
<>	144:ef7eb2e8f9f7	1657	}
<>	144:ef7eb2e8f9f7	1658	/* Set the LSB to 1 */
<>	144:ef7eb2e8f9f7	1659	ctr[15U] \|= 0x01U;
<>	144:ef7eb2e8f9f7	1660
<>	144:ef7eb2e8f9f7	1661	/* Set the key */
<>	144:ef7eb2e8f9f7	1662	CRYPEx_GCMCCM_SetKey(hcryp, hcryp->Init.pKey, hcryp->Init.KeySize);
<>	144:ef7eb2e8f9f7	1663
<>	144:ef7eb2e8f9f7	1664	/* Set the CRYP peripheral in AES CCM mode */
<>	144:ef7eb2e8f9f7	1665	__HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CCM_ENCRYPT);
<>	144:ef7eb2e8f9f7	1666
<>	144:ef7eb2e8f9f7	1667	/* Set the Initialization Vector */
<>	144:ef7eb2e8f9f7	1668	CRYPEx_GCMCCM_SetInitVector(hcryp, ctr);
<>	144:ef7eb2e8f9f7	1669
<>	144:ef7eb2e8f9f7	1670	/* Select init phase */
<>	144:ef7eb2e8f9f7	1671	__HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_INIT);
<>	144:ef7eb2e8f9f7	1672
<>	144:ef7eb2e8f9f7	1673	b0addr = (uint32_t)blockb0;
<>	144:ef7eb2e8f9f7	1674	/* Write the blockb0 block in the IN FIFO */
<>	144:ef7eb2e8f9f7	1675	hcryp->Instance->DR = (uint32_t)(b0addr);
<>	144:ef7eb2e8f9f7	1676	b0addr+=4U;
<>	144:ef7eb2e8f9f7	1677	hcryp->Instance->DR = (uint32_t)(b0addr);
<>	144:ef7eb2e8f9f7	1678	b0addr+=4U;
<>	144:ef7eb2e8f9f7	1679	hcryp->Instance->DR = (uint32_t)(b0addr);
<>	144:ef7eb2e8f9f7	1680	b0addr+=4U;
<>	144:ef7eb2e8f9f7	1681	hcryp->Instance->DR = (uint32_t)(b0addr);
<>	144:ef7eb2e8f9f7	1682
<>	144:ef7eb2e8f9f7	1683	/* Enable the CRYP peripheral */
<>	144:ef7eb2e8f9f7	1684	__HAL_CRYP_ENABLE(hcryp);
<>	144:ef7eb2e8f9f7	1685
<>	144:ef7eb2e8f9f7	1686	/* Get tick */
<>	144:ef7eb2e8f9f7	1687	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	1688
<>	144:ef7eb2e8f9f7	1689	while((CRYP->CR & CRYP_CR_CRYPEN) == CRYP_CR_CRYPEN)
<>	144:ef7eb2e8f9f7	1690	{
<>	144:ef7eb2e8f9f7	1691	/* Check for the Timeout */
<>	144:ef7eb2e8f9f7	1692	if((HAL_GetTick() - tickstart ) > CRYPEx_TIMEOUT_VALUE)
<>	144:ef7eb2e8f9f7	1693	{
<>	144:ef7eb2e8f9f7	1694	/* Change state */
<>	144:ef7eb2e8f9f7	1695	hcryp->State = HAL_CRYP_STATE_TIMEOUT;
<>	144:ef7eb2e8f9f7	1696
<>	144:ef7eb2e8f9f7	1697	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	1698	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	1699
<>	144:ef7eb2e8f9f7	1700	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	1701	}
<>	144:ef7eb2e8f9f7	1702	}
<>	144:ef7eb2e8f9f7	1703	/*************************** Header phase ***************************/
<>	144:ef7eb2e8f9f7	1704	if(headersize != 0U)
<>	144:ef7eb2e8f9f7	1705	{
<>	144:ef7eb2e8f9f7	1706	/* Select header phase */
<>	144:ef7eb2e8f9f7	1707	__HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_HEADER);
<>	144:ef7eb2e8f9f7	1708
<>	144:ef7eb2e8f9f7	1709	/* Enable Crypto processor */
<>	144:ef7eb2e8f9f7	1710	__HAL_CRYP_ENABLE(hcryp);
<>	144:ef7eb2e8f9f7	1711
<>	144:ef7eb2e8f9f7	1712	for(loopcounter = 0U; (loopcounter < headersize); loopcounter+=16U)
<>	144:ef7eb2e8f9f7	1713	{
<>	144:ef7eb2e8f9f7	1714	/* Get tick */
<>	144:ef7eb2e8f9f7	1715	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	1716
<>	144:ef7eb2e8f9f7	1717	while(HAL_IS_BIT_CLR(hcryp->Instance->SR, CRYP_FLAG_IFEM))
<>	144:ef7eb2e8f9f7	1718	{
<>	144:ef7eb2e8f9f7	1719	/* Check for the Timeout */
<>	144:ef7eb2e8f9f7	1720	if((HAL_GetTick() - tickstart ) > CRYPEx_TIMEOUT_VALUE)
<>	144:ef7eb2e8f9f7	1721	{
<>	144:ef7eb2e8f9f7	1722	/* Change state */
<>	144:ef7eb2e8f9f7	1723	hcryp->State = HAL_CRYP_STATE_TIMEOUT;
<>	144:ef7eb2e8f9f7	1724
<>	144:ef7eb2e8f9f7	1725	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	1726	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	1727
<>	144:ef7eb2e8f9f7	1728	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	1729	}
<>	144:ef7eb2e8f9f7	1730	}
<>	144:ef7eb2e8f9f7	1731	/* Write the header block in the IN FIFO */
<>	144:ef7eb2e8f9f7	1732	hcryp->Instance->DR = (uint32_t)(headeraddr);
<>	144:ef7eb2e8f9f7	1733	headeraddr+=4U;
<>	144:ef7eb2e8f9f7	1734	hcryp->Instance->DR = (uint32_t)(headeraddr);
<>	144:ef7eb2e8f9f7	1735	headeraddr+=4U;
<>	144:ef7eb2e8f9f7	1736	hcryp->Instance->DR = (uint32_t)(headeraddr);
<>	144:ef7eb2e8f9f7	1737	headeraddr+=4U;
<>	144:ef7eb2e8f9f7	1738	hcryp->Instance->DR = (uint32_t)(headeraddr);
<>	144:ef7eb2e8f9f7	1739	headeraddr+=4U;
<>	144:ef7eb2e8f9f7	1740	}
<>	144:ef7eb2e8f9f7	1741
<>	144:ef7eb2e8f9f7	1742	/* Get tick */
<>	144:ef7eb2e8f9f7	1743	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	1744
<>	144:ef7eb2e8f9f7	1745	while((hcryp->Instance->SR & CRYP_FLAG_BUSY) == CRYP_FLAG_BUSY)
<>	144:ef7eb2e8f9f7	1746	{
<>	144:ef7eb2e8f9f7	1747	/* Check for the Timeout */
<>	144:ef7eb2e8f9f7	1748	if((HAL_GetTick() - tickstart ) > CRYPEx_TIMEOUT_VALUE)
<>	144:ef7eb2e8f9f7	1749	{
<>	144:ef7eb2e8f9f7	1750	/* Change state */
<>	144:ef7eb2e8f9f7	1751	hcryp->State = HAL_CRYP_STATE_TIMEOUT;
<>	144:ef7eb2e8f9f7	1752
<>	144:ef7eb2e8f9f7	1753	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	1754	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	1755
<>	144:ef7eb2e8f9f7	1756	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	1757	}
<>	144:ef7eb2e8f9f7	1758	}
<>	144:ef7eb2e8f9f7	1759	}
<>	144:ef7eb2e8f9f7	1760	/* Save formatted counter into the scratch buffer pScratch */
<>	144:ef7eb2e8f9f7	1761	for(loopcounter = 0U; (loopcounter < 16U); loopcounter++)
<>	144:ef7eb2e8f9f7	1762	{
<>	144:ef7eb2e8f9f7	1763	hcryp->Init.pScratch[loopcounter] = ctr[loopcounter];
<>	144:ef7eb2e8f9f7	1764	}
<>	144:ef7eb2e8f9f7	1765	/* Reset bit 0 */
<>	144:ef7eb2e8f9f7	1766	hcryp->Init.pScratch[15U] &= 0xFEU;
<>	144:ef7eb2e8f9f7	1767
<>	144:ef7eb2e8f9f7	1768	/* Select payload phase once the header phase is performed */
<>	144:ef7eb2e8f9f7	1769	__HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_PAYLOAD);
<>	144:ef7eb2e8f9f7	1770
<>	144:ef7eb2e8f9f7	1771	/* Flush FIFO */
<>	144:ef7eb2e8f9f7	1772	__HAL_CRYP_FIFO_FLUSH(hcryp);
<>	144:ef7eb2e8f9f7	1773
<>	144:ef7eb2e8f9f7	1774	/* Set the phase */
<>	144:ef7eb2e8f9f7	1775	hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
<>	144:ef7eb2e8f9f7	1776	}
<>	144:ef7eb2e8f9f7	1777
<>	144:ef7eb2e8f9f7	1778	if(Size != 0U)
<>	144:ef7eb2e8f9f7	1779	{
<>	144:ef7eb2e8f9f7	1780	/* Enable Interrupts */
<>	144:ef7eb2e8f9f7	1781	__HAL_CRYP_ENABLE_IT(hcryp, CRYP_IT_INI \| CRYP_IT_OUTI);
<>	144:ef7eb2e8f9f7	1782	/* Enable the CRYP peripheral */
<>	144:ef7eb2e8f9f7	1783	__HAL_CRYP_ENABLE(hcryp);
<>	144:ef7eb2e8f9f7	1784	}
<>	144:ef7eb2e8f9f7	1785	else
<>	144:ef7eb2e8f9f7	1786	{
<>	144:ef7eb2e8f9f7	1787	/* Change the CRYP state and phase */
<>	144:ef7eb2e8f9f7	1788	hcryp->State = HAL_CRYP_STATE_READY;
<>	144:ef7eb2e8f9f7	1789	}
<>	144:ef7eb2e8f9f7	1790
<>	144:ef7eb2e8f9f7	1791	/* Return function status */
<>	144:ef7eb2e8f9f7	1792	return HAL_OK;
<>	144:ef7eb2e8f9f7	1793	}
<>	144:ef7eb2e8f9f7	1794	else if (__HAL_CRYP_GET_IT(hcryp, CRYP_IT_INI))
<>	144:ef7eb2e8f9f7	1795	{
<>	144:ef7eb2e8f9f7	1796	inputaddr = (uint32_t)hcryp->pCrypInBuffPtr;
<>	144:ef7eb2e8f9f7	1797	/* Write the Input block in the IN FIFO */
<>	144:ef7eb2e8f9f7	1798	hcryp->Instance->DR = (uint32_t)(inputaddr);
<>	144:ef7eb2e8f9f7	1799	inputaddr+=4U;
<>	144:ef7eb2e8f9f7	1800	hcryp->Instance->DR = (uint32_t)(inputaddr);
<>	144:ef7eb2e8f9f7	1801	inputaddr+=4U;
<>	144:ef7eb2e8f9f7	1802	hcryp->Instance->DR = (uint32_t)(inputaddr);
<>	144:ef7eb2e8f9f7	1803	inputaddr+=4U;
<>	144:ef7eb2e8f9f7	1804	hcryp->Instance->DR = (uint32_t)(inputaddr);
<>	144:ef7eb2e8f9f7	1805	hcryp->pCrypInBuffPtr += 16U;
<>	144:ef7eb2e8f9f7	1806	hcryp->CrypInCount -= 16U;
<>	144:ef7eb2e8f9f7	1807	if(hcryp->CrypInCount == 0U)
<>	144:ef7eb2e8f9f7	1808	{
<>	144:ef7eb2e8f9f7	1809	__HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_INI);
<>	144:ef7eb2e8f9f7	1810	/* Call Input transfer complete callback */
<>	144:ef7eb2e8f9f7	1811	HAL_CRYP_InCpltCallback(hcryp);
<>	144:ef7eb2e8f9f7	1812	}
<>	144:ef7eb2e8f9f7	1813	}
<>	144:ef7eb2e8f9f7	1814	else if (__HAL_CRYP_GET_IT(hcryp, CRYP_IT_OUTI))
<>	144:ef7eb2e8f9f7	1815	{
<>	144:ef7eb2e8f9f7	1816	outputaddr = (uint32_t)hcryp->pCrypOutBuffPtr;
<>	144:ef7eb2e8f9f7	1817	/* Read the Output block from the Output FIFO */
<>	144:ef7eb2e8f9f7	1818	(uint32_t)(outputaddr) = hcryp->Instance->DOUT;
<>	144:ef7eb2e8f9f7	1819	outputaddr+=4U;
<>	144:ef7eb2e8f9f7	1820	(uint32_t)(outputaddr) = hcryp->Instance->DOUT;
<>	144:ef7eb2e8f9f7	1821	outputaddr+=4U;
<>	144:ef7eb2e8f9f7	1822	(uint32_t)(outputaddr) = hcryp->Instance->DOUT;
<>	144:ef7eb2e8f9f7	1823	outputaddr+=4U;
<>	144:ef7eb2e8f9f7	1824	(uint32_t)(outputaddr) = hcryp->Instance->DOUT;
<>	144:ef7eb2e8f9f7	1825	hcryp->pCrypOutBuffPtr += 16U;
<>	144:ef7eb2e8f9f7	1826	hcryp->CrypOutCount -= 16U;
<>	144:ef7eb2e8f9f7	1827	if(hcryp->CrypOutCount == 0U)
<>	144:ef7eb2e8f9f7	1828	{
<>	144:ef7eb2e8f9f7	1829	__HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_OUTI);
<>	144:ef7eb2e8f9f7	1830	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	1831	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	1832	/* Change the CRYP peripheral state */
<>	144:ef7eb2e8f9f7	1833	hcryp->State = HAL_CRYP_STATE_READY;
<>	144:ef7eb2e8f9f7	1834	/* Call Input transfer complete callback */
<>	144:ef7eb2e8f9f7	1835	HAL_CRYP_OutCpltCallback(hcryp);
<>	144:ef7eb2e8f9f7	1836	}
<>	144:ef7eb2e8f9f7	1837	}
<>	144:ef7eb2e8f9f7	1838
<>	144:ef7eb2e8f9f7	1839	/* Return function status */
<>	144:ef7eb2e8f9f7	1840	return HAL_OK;
<>	144:ef7eb2e8f9f7	1841	}
<>	144:ef7eb2e8f9f7	1842
<>	144:ef7eb2e8f9f7	1843	/**
<>	144:ef7eb2e8f9f7	1844	* @brief Initializes the CRYP peripheral in AES GCM decryption mode using IT.
<>	144:ef7eb2e8f9f7	1845	* @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	1846	* the configuration information for CRYP module
<>	144:ef7eb2e8f9f7	1847	* @param pCypherData: Pointer to the cyphertext buffer
<>	144:ef7eb2e8f9f7	1848	* @param Size: Length of the cyphertext buffer, must be a multiple of 16
<>	144:ef7eb2e8f9f7	1849	* @param pPlainData: Pointer to the plaintext buffer
<>	144:ef7eb2e8f9f7	1850	* @retval HAL status
<>	144:ef7eb2e8f9f7	1851	*/
<>	144:ef7eb2e8f9f7	1852	HAL_StatusTypeDef HAL_CRYPEx_AESGCM_Decrypt_IT(CRYP_HandleTypeDef hcryp, uint8_t pCypherData, uint16_t Size, uint8_t *pPlainData)
<>	144:ef7eb2e8f9f7	1853	{
<>	144:ef7eb2e8f9f7	1854	uint32_t tickstart = 0U;
<>	144:ef7eb2e8f9f7	1855	uint32_t inputaddr;
<>	144:ef7eb2e8f9f7	1856	uint32_t outputaddr;
<>	144:ef7eb2e8f9f7	1857
<>	144:ef7eb2e8f9f7	1858	if(hcryp->State == HAL_CRYP_STATE_READY)
<>	144:ef7eb2e8f9f7	1859	{
<>	144:ef7eb2e8f9f7	1860	/* Process Locked */
<>	144:ef7eb2e8f9f7	1861	__HAL_LOCK(hcryp);
<>	144:ef7eb2e8f9f7	1862
<>	144:ef7eb2e8f9f7	1863	/* Get the buffer addresses and sizes */
<>	144:ef7eb2e8f9f7	1864	hcryp->CrypInCount = Size;
<>	144:ef7eb2e8f9f7	1865	hcryp->pCrypInBuffPtr = pCypherData;
<>	144:ef7eb2e8f9f7	1866	hcryp->pCrypOutBuffPtr = pPlainData;
<>	144:ef7eb2e8f9f7	1867	hcryp->CrypOutCount = Size;
<>	144:ef7eb2e8f9f7	1868
<>	144:ef7eb2e8f9f7	1869	/* Change the CRYP peripheral state */
<>	144:ef7eb2e8f9f7	1870	hcryp->State = HAL_CRYP_STATE_BUSY;
<>	144:ef7eb2e8f9f7	1871
<>	144:ef7eb2e8f9f7	1872	/* Check if initialization phase has already been performed */
<>	144:ef7eb2e8f9f7	1873	if(hcryp->Phase == HAL_CRYP_PHASE_READY)
<>	144:ef7eb2e8f9f7	1874	{
<>	144:ef7eb2e8f9f7	1875	/* Set the key */
<>	144:ef7eb2e8f9f7	1876	CRYPEx_GCMCCM_SetKey(hcryp, hcryp->Init.pKey, hcryp->Init.KeySize);
<>	144:ef7eb2e8f9f7	1877
<>	144:ef7eb2e8f9f7	1878	/* Set the CRYP peripheral in AES GCM decryption mode */
<>	144:ef7eb2e8f9f7	1879	__HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_GCM_DECRYPT);
<>	144:ef7eb2e8f9f7	1880
<>	144:ef7eb2e8f9f7	1881	/* Set the Initialization Vector */
<>	144:ef7eb2e8f9f7	1882	CRYPEx_GCMCCM_SetInitVector(hcryp, hcryp->Init.pInitVect);
<>	144:ef7eb2e8f9f7	1883
<>	144:ef7eb2e8f9f7	1884	/* Flush FIFO */
<>	144:ef7eb2e8f9f7	1885	__HAL_CRYP_FIFO_FLUSH(hcryp);
<>	144:ef7eb2e8f9f7	1886
<>	144:ef7eb2e8f9f7	1887	/* Enable CRYP to start the init phase */
<>	144:ef7eb2e8f9f7	1888	__HAL_CRYP_ENABLE(hcryp);
<>	144:ef7eb2e8f9f7	1889
<>	144:ef7eb2e8f9f7	1890	/* Get tick */
<>	144:ef7eb2e8f9f7	1891	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	1892
<>	144:ef7eb2e8f9f7	1893	while((CRYP->CR & CRYP_CR_CRYPEN) == CRYP_CR_CRYPEN)
<>	144:ef7eb2e8f9f7	1894	{
<>	144:ef7eb2e8f9f7	1895	/* Check for the Timeout */
<>	144:ef7eb2e8f9f7	1896	if((HAL_GetTick() - tickstart ) > CRYPEx_TIMEOUT_VALUE)
<>	144:ef7eb2e8f9f7	1897	{
<>	144:ef7eb2e8f9f7	1898	/* Change state */
<>	144:ef7eb2e8f9f7	1899	hcryp->State = HAL_CRYP_STATE_TIMEOUT;
<>	144:ef7eb2e8f9f7	1900
<>	144:ef7eb2e8f9f7	1901	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	1902	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	1903
<>	144:ef7eb2e8f9f7	1904	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	1905	}
<>	144:ef7eb2e8f9f7	1906	}
<>	144:ef7eb2e8f9f7	1907
<>	144:ef7eb2e8f9f7	1908	/* Set the header phase */
<>	144:ef7eb2e8f9f7	1909	if(CRYPEx_GCMCCM_SetHeaderPhase(hcryp, hcryp->Init.Header, hcryp->Init.HeaderSize, 1U) != HAL_OK)
<>	144:ef7eb2e8f9f7	1910	{
<>	144:ef7eb2e8f9f7	1911	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	1912	}
<>	144:ef7eb2e8f9f7	1913	/* Disable the CRYP peripheral */
<>	144:ef7eb2e8f9f7	1914	__HAL_CRYP_DISABLE(hcryp);
<>	144:ef7eb2e8f9f7	1915
<>	144:ef7eb2e8f9f7	1916	/* Select payload phase once the header phase is performed */
<>	144:ef7eb2e8f9f7	1917	__HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_PAYLOAD);
<>	144:ef7eb2e8f9f7	1918
<>	144:ef7eb2e8f9f7	1919	/* Set the phase */
<>	144:ef7eb2e8f9f7	1920	hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
<>	144:ef7eb2e8f9f7	1921	}
<>	144:ef7eb2e8f9f7	1922
<>	144:ef7eb2e8f9f7	1923	if(Size != 0U)
<>	144:ef7eb2e8f9f7	1924	{
<>	144:ef7eb2e8f9f7	1925	/* Enable Interrupts */
<>	144:ef7eb2e8f9f7	1926	__HAL_CRYP_ENABLE_IT(hcryp, CRYP_IT_INI \| CRYP_IT_OUTI);
<>	144:ef7eb2e8f9f7	1927	/* Enable the CRYP peripheral */
<>	144:ef7eb2e8f9f7	1928	__HAL_CRYP_ENABLE(hcryp);
<>	144:ef7eb2e8f9f7	1929	}
<>	144:ef7eb2e8f9f7	1930	else
<>	144:ef7eb2e8f9f7	1931	{
<>	144:ef7eb2e8f9f7	1932	/* Process Locked */
<>	144:ef7eb2e8f9f7	1933	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	1934	/* Change the CRYP state and phase */
<>	144:ef7eb2e8f9f7	1935	hcryp->State = HAL_CRYP_STATE_READY;
<>	144:ef7eb2e8f9f7	1936	}
<>	144:ef7eb2e8f9f7	1937
<>	144:ef7eb2e8f9f7	1938	/* Return function status */
<>	144:ef7eb2e8f9f7	1939	return HAL_OK;
<>	144:ef7eb2e8f9f7	1940	}
<>	144:ef7eb2e8f9f7	1941	else if (__HAL_CRYP_GET_IT(hcryp, CRYP_IT_INI))
<>	144:ef7eb2e8f9f7	1942	{
<>	144:ef7eb2e8f9f7	1943	inputaddr = (uint32_t)hcryp->pCrypInBuffPtr;
<>	144:ef7eb2e8f9f7	1944	/* Write the Input block in the IN FIFO */
<>	144:ef7eb2e8f9f7	1945	hcryp->Instance->DR = (uint32_t)(inputaddr);
<>	144:ef7eb2e8f9f7	1946	inputaddr+=4U;
<>	144:ef7eb2e8f9f7	1947	hcryp->Instance->DR = (uint32_t)(inputaddr);
<>	144:ef7eb2e8f9f7	1948	inputaddr+=4U;
<>	144:ef7eb2e8f9f7	1949	hcryp->Instance->DR = (uint32_t)(inputaddr);
<>	144:ef7eb2e8f9f7	1950	inputaddr+=4U;
<>	144:ef7eb2e8f9f7	1951	hcryp->Instance->DR = (uint32_t)(inputaddr);
<>	144:ef7eb2e8f9f7	1952	hcryp->pCrypInBuffPtr += 16U;
<>	144:ef7eb2e8f9f7	1953	hcryp->CrypInCount -= 16U;
<>	144:ef7eb2e8f9f7	1954	if(hcryp->CrypInCount == 0U)
<>	144:ef7eb2e8f9f7	1955	{
<>	144:ef7eb2e8f9f7	1956	__HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_INI);
<>	144:ef7eb2e8f9f7	1957	/* Call the Input data transfer complete callback */
<>	144:ef7eb2e8f9f7	1958	HAL_CRYP_InCpltCallback(hcryp);
<>	144:ef7eb2e8f9f7	1959	}
<>	144:ef7eb2e8f9f7	1960	}
<>	144:ef7eb2e8f9f7	1961	else if (__HAL_CRYP_GET_IT(hcryp, CRYP_IT_OUTI))
<>	144:ef7eb2e8f9f7	1962	{
<>	144:ef7eb2e8f9f7	1963	outputaddr = (uint32_t)hcryp->pCrypOutBuffPtr;
<>	144:ef7eb2e8f9f7	1964	/* Read the Output block from the Output FIFO */
<>	144:ef7eb2e8f9f7	1965	(uint32_t)(outputaddr) = hcryp->Instance->DOUT;
<>	144:ef7eb2e8f9f7	1966	outputaddr+=4U;
<>	144:ef7eb2e8f9f7	1967	(uint32_t)(outputaddr) = hcryp->Instance->DOUT;
<>	144:ef7eb2e8f9f7	1968	outputaddr+=4U;
<>	144:ef7eb2e8f9f7	1969	(uint32_t)(outputaddr) = hcryp->Instance->DOUT;
<>	144:ef7eb2e8f9f7	1970	outputaddr+=4U;
<>	144:ef7eb2e8f9f7	1971	(uint32_t)(outputaddr) = hcryp->Instance->DOUT;
<>	144:ef7eb2e8f9f7	1972	hcryp->pCrypOutBuffPtr += 16U;
<>	144:ef7eb2e8f9f7	1973	hcryp->CrypOutCount -= 16U;
<>	144:ef7eb2e8f9f7	1974	if(hcryp->CrypOutCount == 0U)
<>	144:ef7eb2e8f9f7	1975	{
<>	144:ef7eb2e8f9f7	1976	__HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_OUTI);
<>	144:ef7eb2e8f9f7	1977	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	1978	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	1979	/* Change the CRYP peripheral state */
<>	144:ef7eb2e8f9f7	1980	hcryp->State = HAL_CRYP_STATE_READY;
<>	144:ef7eb2e8f9f7	1981	/* Call Input transfer complete callback */
<>	144:ef7eb2e8f9f7	1982	HAL_CRYP_OutCpltCallback(hcryp);
<>	144:ef7eb2e8f9f7	1983	}
<>	144:ef7eb2e8f9f7	1984	}
<>	144:ef7eb2e8f9f7	1985
<>	144:ef7eb2e8f9f7	1986	/* Return function status */
<>	144:ef7eb2e8f9f7	1987	return HAL_OK;
<>	144:ef7eb2e8f9f7	1988	}
<>	144:ef7eb2e8f9f7	1989
<>	144:ef7eb2e8f9f7	1990	/**
<>	144:ef7eb2e8f9f7	1991	* @brief Initializes the CRYP peripheral in AES CCM decryption mode using interrupt
<>	144:ef7eb2e8f9f7	1992	* then decrypted pCypherData. The cypher data are available in pPlainData.
<>	144:ef7eb2e8f9f7	1993	* @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	1994	* the configuration information for CRYP module
<>	144:ef7eb2e8f9f7	1995	* @param pCypherData: Pointer to the cyphertext buffer
<>	144:ef7eb2e8f9f7	1996	* @param Size: Length of the plaintext buffer, must be a multiple of 16
<>	144:ef7eb2e8f9f7	1997	* @param pPlainData: Pointer to the plaintext buffer
<>	144:ef7eb2e8f9f7	1998	* @retval HAL status
<>	144:ef7eb2e8f9f7	1999	*/
<>	144:ef7eb2e8f9f7	2000	HAL_StatusTypeDef HAL_CRYPEx_AESCCM_Decrypt_IT(CRYP_HandleTypeDef hcryp, uint8_t pCypherData, uint16_t Size, uint8_t *pPlainData)
<>	144:ef7eb2e8f9f7	2001	{
<>	144:ef7eb2e8f9f7	2002	uint32_t inputaddr;
<>	144:ef7eb2e8f9f7	2003	uint32_t outputaddr;
<>	144:ef7eb2e8f9f7	2004	uint32_t tickstart = 0U;
<>	144:ef7eb2e8f9f7	2005	uint32_t headersize = hcryp->Init.HeaderSize;
<>	144:ef7eb2e8f9f7	2006	uint32_t headeraddr = (uint32_t)hcryp->Init.Header;
<>	144:ef7eb2e8f9f7	2007	uint32_t loopcounter = 0U;
<>	144:ef7eb2e8f9f7	2008	uint32_t bufferidx = 0U;
<>	144:ef7eb2e8f9f7	2009	uint8_t blockb0[16U] = {0U};/* Block B0 */
<>	144:ef7eb2e8f9f7	2010	uint8_t ctr[16U] = {0U}; /* Counter */
<>	144:ef7eb2e8f9f7	2011	uint32_t b0addr = (uint32_t)blockb0;
<>	144:ef7eb2e8f9f7	2012
<>	144:ef7eb2e8f9f7	2013	if(hcryp->State == HAL_CRYP_STATE_READY)
<>	144:ef7eb2e8f9f7	2014	{
<>	144:ef7eb2e8f9f7	2015	/* Process Locked */
<>	144:ef7eb2e8f9f7	2016	__HAL_LOCK(hcryp);
<>	144:ef7eb2e8f9f7	2017
<>	144:ef7eb2e8f9f7	2018	hcryp->CrypInCount = Size;
<>	144:ef7eb2e8f9f7	2019	hcryp->pCrypInBuffPtr = pCypherData;
<>	144:ef7eb2e8f9f7	2020	hcryp->pCrypOutBuffPtr = pPlainData;
<>	144:ef7eb2e8f9f7	2021	hcryp->CrypOutCount = Size;
<>	144:ef7eb2e8f9f7	2022
<>	144:ef7eb2e8f9f7	2023	/* Change the CRYP peripheral state */
<>	144:ef7eb2e8f9f7	2024	hcryp->State = HAL_CRYP_STATE_BUSY;
<>	144:ef7eb2e8f9f7	2025
<>	144:ef7eb2e8f9f7	2026	/* Check if initialization phase has already been performed */
<>	144:ef7eb2e8f9f7	2027	if(hcryp->Phase == HAL_CRYP_PHASE_READY)
<>	144:ef7eb2e8f9f7	2028	{
<>	144:ef7eb2e8f9f7	2029	/********************** Formatting the header block *****************/
<>	144:ef7eb2e8f9f7	2030	if(headersize != 0U)
<>	144:ef7eb2e8f9f7	2031	{
<>	144:ef7eb2e8f9f7	2032	/* Check that the associated data (or header) length is lower than 2^16 - 2^8 = 65536 - 256 = 65280 */
<>	144:ef7eb2e8f9f7	2033	if(headersize < 65280U)
<>	144:ef7eb2e8f9f7	2034	{
<>	144:ef7eb2e8f9f7	2035	hcryp->Init.pScratch[bufferidx++] = (uint8_t) ((headersize >> 8U) & 0xFFU);
<>	144:ef7eb2e8f9f7	2036	hcryp->Init.pScratch[bufferidx++] = (uint8_t) ((headersize) & 0xFFU);
<>	144:ef7eb2e8f9f7	2037	headersize += 2U;
<>	144:ef7eb2e8f9f7	2038	}
<>	144:ef7eb2e8f9f7	2039	else
<>	144:ef7eb2e8f9f7	2040	{
<>	144:ef7eb2e8f9f7	2041	/* Header is encoded as 0xff \|\| 0xfe \|\| [headersize]32, i.e., six octets */
<>	144:ef7eb2e8f9f7	2042	hcryp->Init.pScratch[bufferidx++] = 0xFFU;
<>	144:ef7eb2e8f9f7	2043	hcryp->Init.pScratch[bufferidx++] = 0xFEU;
<>	144:ef7eb2e8f9f7	2044	hcryp->Init.pScratch[bufferidx++] = headersize & 0xff000000U;
<>	144:ef7eb2e8f9f7	2045	hcryp->Init.pScratch[bufferidx++] = headersize & 0x00ff0000U;
<>	144:ef7eb2e8f9f7	2046	hcryp->Init.pScratch[bufferidx++] = headersize & 0x0000ff00U;
<>	144:ef7eb2e8f9f7	2047	hcryp->Init.pScratch[bufferidx++] = headersize & 0x000000ffU;
<>	144:ef7eb2e8f9f7	2048	headersize += 6U;
<>	144:ef7eb2e8f9f7	2049	}
<>	144:ef7eb2e8f9f7	2050	/* Copy the header buffer in internal buffer "hcryp->Init.pScratch" */
<>	144:ef7eb2e8f9f7	2051	for(loopcounter = 0U; loopcounter < headersize; loopcounter++)
<>	144:ef7eb2e8f9f7	2052	{
<>	144:ef7eb2e8f9f7	2053	hcryp->Init.pScratch[bufferidx++] = hcryp->Init.Header[loopcounter];
<>	144:ef7eb2e8f9f7	2054	}
<>	144:ef7eb2e8f9f7	2055	/* Check if the header size is modulo 16 */
<>	144:ef7eb2e8f9f7	2056	if ((headersize % 16U) != 0U)
<>	144:ef7eb2e8f9f7	2057	{
<>	144:ef7eb2e8f9f7	2058	/* Padd the header buffer with 0s till the hcryp->Init.pScratch length is modulo 16 */
<>	144:ef7eb2e8f9f7	2059	for(loopcounter = headersize; loopcounter <= ((headersize/16U) + 1U) * 16U; loopcounter++)
<>	144:ef7eb2e8f9f7	2060	{
<>	144:ef7eb2e8f9f7	2061	hcryp->Init.pScratch[loopcounter] = 0U;
<>	144:ef7eb2e8f9f7	2062	}
<>	144:ef7eb2e8f9f7	2063	/* Set the header size to modulo 16 */
<>	144:ef7eb2e8f9f7	2064	headersize = ((headersize/16U) + 1U) * 16U;
<>	144:ef7eb2e8f9f7	2065	}
<>	144:ef7eb2e8f9f7	2066	/* Set the pointer headeraddr to hcryp->Init.pScratch */
<>	144:ef7eb2e8f9f7	2067	headeraddr = (uint32_t)hcryp->Init.pScratch;
<>	144:ef7eb2e8f9f7	2068	}
<>	144:ef7eb2e8f9f7	2069	/********************* Formatting the block B0 **********************/
<>	144:ef7eb2e8f9f7	2070	if(headersize != 0U)
<>	144:ef7eb2e8f9f7	2071	{
<>	144:ef7eb2e8f9f7	2072	blockb0[0U] = 0x40U;
<>	144:ef7eb2e8f9f7	2073	}
<>	144:ef7eb2e8f9f7	2074	/* Flags byte */
<>	144:ef7eb2e8f9f7	2075	/* blockb0[0] \|= 0u \| (((( (uint8_t) hcryp->Init.TagSize - 2) / 2) & 0x07 ) << 3 ) \| ( ( (uint8_t) (15 - hcryp->Init.IVSize) - 1) & 0x07U) */
<>	144:ef7eb2e8f9f7	2076	blockb0[0U] \|= (uint8_t)((uint8_t)((uint8_t)(((uint8_t)(hcryp->Init.TagSize - (uint8_t)(2U))) >> 1U) & (uint8_t)0x07U) << 3U);
<>	144:ef7eb2e8f9f7	2077	blockb0[0U] \|= (uint8_t)((uint8_t)((uint8_t)((uint8_t)(15U) - hcryp->Init.IVSize) - (uint8_t)1U) & (uint8_t)0x07U);
<>	144:ef7eb2e8f9f7	2078
<>	144:ef7eb2e8f9f7	2079	for (loopcounter = 0U; loopcounter < hcryp->Init.IVSize; loopcounter++)
<>	144:ef7eb2e8f9f7	2080	{
<>	144:ef7eb2e8f9f7	2081	blockb0[loopcounter+1U] = hcryp->Init.pInitVect[loopcounter];
<>	144:ef7eb2e8f9f7	2082	}
<>	144:ef7eb2e8f9f7	2083	for ( ; loopcounter < 13U; loopcounter++)
<>	144:ef7eb2e8f9f7	2084	{
<>	144:ef7eb2e8f9f7	2085	blockb0[loopcounter+1U] = 0U;
<>	144:ef7eb2e8f9f7	2086	}
<>	144:ef7eb2e8f9f7	2087
<>	144:ef7eb2e8f9f7	2088	blockb0[14U] = (Size >> 8U);
<>	144:ef7eb2e8f9f7	2089	blockb0[15U] = (Size & 0xFFU);
<>	144:ef7eb2e8f9f7	2090
<>	144:ef7eb2e8f9f7	2091	/*********************** Formatting the initial counter *************/
<>	144:ef7eb2e8f9f7	2092	/* Byte 0:
<>	144:ef7eb2e8f9f7	2093	Bits 7 and 6 are reserved and shall be set to 0
<>	144:ef7eb2e8f9f7	2094	Bits 3, 4, and 5 shall also be set to 0, to ensure that all the counter
<>	144:ef7eb2e8f9f7	2095	blocks are distinct from B0
<>	144:ef7eb2e8f9f7	2096	Bits 0, 1, and 2 contain the same encoding of q as in B0
<>	144:ef7eb2e8f9f7	2097	*/
<>	144:ef7eb2e8f9f7	2098	ctr[0U] = blockb0[0U] & 0x07U;
<>	144:ef7eb2e8f9f7	2099	/* byte 1 to NonceSize is the IV (Nonce) */
<>	144:ef7eb2e8f9f7	2100	for(loopcounter = 1U; loopcounter < hcryp->Init.IVSize + 1U; loopcounter++)
<>	144:ef7eb2e8f9f7	2101	{
<>	144:ef7eb2e8f9f7	2102	ctr[loopcounter] = blockb0[loopcounter];
<>	144:ef7eb2e8f9f7	2103	}
<>	144:ef7eb2e8f9f7	2104	/* Set the LSB to 1 */
<>	144:ef7eb2e8f9f7	2105	ctr[15U] \|= 0x01U;
<>	144:ef7eb2e8f9f7	2106
<>	144:ef7eb2e8f9f7	2107	/* Set the key */
<>	144:ef7eb2e8f9f7	2108	CRYPEx_GCMCCM_SetKey(hcryp, hcryp->Init.pKey, hcryp->Init.KeySize);
<>	144:ef7eb2e8f9f7	2109
<>	144:ef7eb2e8f9f7	2110	/* Set the CRYP peripheral in AES CCM mode */
<>	144:ef7eb2e8f9f7	2111	__HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CCM_DECRYPT);
<>	144:ef7eb2e8f9f7	2112
<>	144:ef7eb2e8f9f7	2113	/* Set the Initialization Vector */
<>	144:ef7eb2e8f9f7	2114	CRYPEx_GCMCCM_SetInitVector(hcryp, ctr);
<>	144:ef7eb2e8f9f7	2115
<>	144:ef7eb2e8f9f7	2116	/* Select init phase */
<>	144:ef7eb2e8f9f7	2117	__HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_INIT);
<>	144:ef7eb2e8f9f7	2118
<>	144:ef7eb2e8f9f7	2119	b0addr = (uint32_t)blockb0;
<>	144:ef7eb2e8f9f7	2120	/* Write the blockb0 block in the IN FIFO */
<>	144:ef7eb2e8f9f7	2121	hcryp->Instance->DR = (uint32_t)(b0addr);
<>	144:ef7eb2e8f9f7	2122	b0addr+=4U;
<>	144:ef7eb2e8f9f7	2123	hcryp->Instance->DR = (uint32_t)(b0addr);
<>	144:ef7eb2e8f9f7	2124	b0addr+=4U;
<>	144:ef7eb2e8f9f7	2125	hcryp->Instance->DR = (uint32_t)(b0addr);
<>	144:ef7eb2e8f9f7	2126	b0addr+=4U;
<>	144:ef7eb2e8f9f7	2127	hcryp->Instance->DR = (uint32_t)(b0addr);
<>	144:ef7eb2e8f9f7	2128
<>	144:ef7eb2e8f9f7	2129	/* Enable the CRYP peripheral */
<>	144:ef7eb2e8f9f7	2130	__HAL_CRYP_ENABLE(hcryp);
<>	144:ef7eb2e8f9f7	2131
<>	144:ef7eb2e8f9f7	2132	/* Get tick */
<>	144:ef7eb2e8f9f7	2133	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	2134
<>	144:ef7eb2e8f9f7	2135	while((CRYP->CR & CRYP_CR_CRYPEN) == CRYP_CR_CRYPEN)
<>	144:ef7eb2e8f9f7	2136	{
<>	144:ef7eb2e8f9f7	2137	/* Check for the Timeout */
<>	144:ef7eb2e8f9f7	2138	if((HAL_GetTick() - tickstart ) > CRYPEx_TIMEOUT_VALUE)
<>	144:ef7eb2e8f9f7	2139	{
<>	144:ef7eb2e8f9f7	2140	/* Change state */
<>	144:ef7eb2e8f9f7	2141	hcryp->State = HAL_CRYP_STATE_TIMEOUT;
<>	144:ef7eb2e8f9f7	2142
<>	144:ef7eb2e8f9f7	2143	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	2144	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	2145
<>	144:ef7eb2e8f9f7	2146	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	2147	}
<>	144:ef7eb2e8f9f7	2148	}
<>	144:ef7eb2e8f9f7	2149	/*************************** Header phase ***************************/
<>	144:ef7eb2e8f9f7	2150	if(headersize != 0U)
<>	144:ef7eb2e8f9f7	2151	{
<>	144:ef7eb2e8f9f7	2152	/* Select header phase */
<>	144:ef7eb2e8f9f7	2153	__HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_HEADER);
<>	144:ef7eb2e8f9f7	2154
<>	144:ef7eb2e8f9f7	2155	/* Enable Crypto processor */
<>	144:ef7eb2e8f9f7	2156	__HAL_CRYP_ENABLE(hcryp);
<>	144:ef7eb2e8f9f7	2157
<>	144:ef7eb2e8f9f7	2158	for(loopcounter = 0U; (loopcounter < headersize); loopcounter+=16U)
<>	144:ef7eb2e8f9f7	2159	{
<>	144:ef7eb2e8f9f7	2160	/* Get tick */
<>	144:ef7eb2e8f9f7	2161	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	2162
<>	144:ef7eb2e8f9f7	2163	while(HAL_IS_BIT_CLR(hcryp->Instance->SR, CRYP_FLAG_IFEM))
<>	144:ef7eb2e8f9f7	2164	{
<>	144:ef7eb2e8f9f7	2165	/* Check for the Timeout */
<>	144:ef7eb2e8f9f7	2166	if((HAL_GetTick() - tickstart ) > CRYPEx_TIMEOUT_VALUE)
<>	144:ef7eb2e8f9f7	2167	{
<>	144:ef7eb2e8f9f7	2168	/* Change state */
<>	144:ef7eb2e8f9f7	2169	hcryp->State = HAL_CRYP_STATE_TIMEOUT;
<>	144:ef7eb2e8f9f7	2170
<>	144:ef7eb2e8f9f7	2171	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	2172	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	2173
<>	144:ef7eb2e8f9f7	2174	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	2175	}
<>	144:ef7eb2e8f9f7	2176	}
<>	144:ef7eb2e8f9f7	2177	/* Write the header block in the IN FIFO */
<>	144:ef7eb2e8f9f7	2178	hcryp->Instance->DR = (uint32_t)(headeraddr);
<>	144:ef7eb2e8f9f7	2179	headeraddr+=4U;
<>	144:ef7eb2e8f9f7	2180	hcryp->Instance->DR = (uint32_t)(headeraddr);
<>	144:ef7eb2e8f9f7	2181	headeraddr+=4U;
<>	144:ef7eb2e8f9f7	2182	hcryp->Instance->DR = (uint32_t)(headeraddr);
<>	144:ef7eb2e8f9f7	2183	headeraddr+=4U;
<>	144:ef7eb2e8f9f7	2184	hcryp->Instance->DR = (uint32_t)(headeraddr);
<>	144:ef7eb2e8f9f7	2185	headeraddr+=4U;
<>	144:ef7eb2e8f9f7	2186	}
<>	144:ef7eb2e8f9f7	2187
<>	144:ef7eb2e8f9f7	2188	/* Get tick */
<>	144:ef7eb2e8f9f7	2189	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	2190
<>	144:ef7eb2e8f9f7	2191	while((hcryp->Instance->SR & CRYP_FLAG_BUSY) == CRYP_FLAG_BUSY)
<>	144:ef7eb2e8f9f7	2192	{
<>	144:ef7eb2e8f9f7	2193	/* Check for the Timeout */
<>	144:ef7eb2e8f9f7	2194	if((HAL_GetTick() - tickstart ) > CRYPEx_TIMEOUT_VALUE)
<>	144:ef7eb2e8f9f7	2195	{
<>	144:ef7eb2e8f9f7	2196	/* Change state */
<>	144:ef7eb2e8f9f7	2197	hcryp->State = HAL_CRYP_STATE_TIMEOUT;
<>	144:ef7eb2e8f9f7	2198
<>	144:ef7eb2e8f9f7	2199	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	2200	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	2201
<>	144:ef7eb2e8f9f7	2202	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	2203	}
<>	144:ef7eb2e8f9f7	2204	}
<>	144:ef7eb2e8f9f7	2205	}
<>	144:ef7eb2e8f9f7	2206	/* Save formatted counter into the scratch buffer pScratch */
<>	144:ef7eb2e8f9f7	2207	for(loopcounter = 0U; (loopcounter < 16U); loopcounter++)
<>	144:ef7eb2e8f9f7	2208	{
<>	144:ef7eb2e8f9f7	2209	hcryp->Init.pScratch[loopcounter] = ctr[loopcounter];
<>	144:ef7eb2e8f9f7	2210	}
<>	144:ef7eb2e8f9f7	2211	/* Reset bit 0 */
<>	144:ef7eb2e8f9f7	2212	hcryp->Init.pScratch[15U] &= 0xFEU;
<>	144:ef7eb2e8f9f7	2213	/* Select payload phase once the header phase is performed */
<>	144:ef7eb2e8f9f7	2214	__HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_PAYLOAD);
<>	144:ef7eb2e8f9f7	2215
<>	144:ef7eb2e8f9f7	2216	/* Flush FIFO */
<>	144:ef7eb2e8f9f7	2217	__HAL_CRYP_FIFO_FLUSH(hcryp);
<>	144:ef7eb2e8f9f7	2218
<>	144:ef7eb2e8f9f7	2219	/* Set the phase */
<>	144:ef7eb2e8f9f7	2220	hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
<>	144:ef7eb2e8f9f7	2221	}
<>	144:ef7eb2e8f9f7	2222
<>	144:ef7eb2e8f9f7	2223	/* Enable Interrupts */
<>	144:ef7eb2e8f9f7	2224	__HAL_CRYP_ENABLE_IT(hcryp, CRYP_IT_INI \| CRYP_IT_OUTI);
<>	144:ef7eb2e8f9f7	2225
<>	144:ef7eb2e8f9f7	2226	/* Enable the CRYP peripheral */
<>	144:ef7eb2e8f9f7	2227	__HAL_CRYP_ENABLE(hcryp);
<>	144:ef7eb2e8f9f7	2228
<>	144:ef7eb2e8f9f7	2229	/* Return function status */
<>	144:ef7eb2e8f9f7	2230	return HAL_OK;
<>	144:ef7eb2e8f9f7	2231	}
<>	144:ef7eb2e8f9f7	2232	else if (__HAL_CRYP_GET_IT(hcryp, CRYP_IT_INI))
<>	144:ef7eb2e8f9f7	2233	{
<>	144:ef7eb2e8f9f7	2234	inputaddr = (uint32_t)hcryp->pCrypInBuffPtr;
<>	144:ef7eb2e8f9f7	2235	/* Write the Input block in the IN FIFO */
<>	144:ef7eb2e8f9f7	2236	hcryp->Instance->DR = (uint32_t)(inputaddr);
<>	144:ef7eb2e8f9f7	2237	inputaddr+=4U;
<>	144:ef7eb2e8f9f7	2238	hcryp->Instance->DR = (uint32_t)(inputaddr);
<>	144:ef7eb2e8f9f7	2239	inputaddr+=4U;
<>	144:ef7eb2e8f9f7	2240	hcryp->Instance->DR = (uint32_t)(inputaddr);
<>	144:ef7eb2e8f9f7	2241	inputaddr+=4U;
<>	144:ef7eb2e8f9f7	2242	hcryp->Instance->DR = (uint32_t)(inputaddr);
<>	144:ef7eb2e8f9f7	2243	hcryp->pCrypInBuffPtr += 16U;
<>	144:ef7eb2e8f9f7	2244	hcryp->CrypInCount -= 16U;
<>	144:ef7eb2e8f9f7	2245	if(hcryp->CrypInCount == 0U)
<>	144:ef7eb2e8f9f7	2246	{
<>	144:ef7eb2e8f9f7	2247	__HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_INI);
<>	144:ef7eb2e8f9f7	2248	/* Call the Input data transfer complete callback */
<>	144:ef7eb2e8f9f7	2249	HAL_CRYP_InCpltCallback(hcryp);
<>	144:ef7eb2e8f9f7	2250	}
<>	144:ef7eb2e8f9f7	2251	}
<>	144:ef7eb2e8f9f7	2252	else if (__HAL_CRYP_GET_IT(hcryp, CRYP_IT_OUTI))
<>	144:ef7eb2e8f9f7	2253	{
<>	144:ef7eb2e8f9f7	2254	outputaddr = (uint32_t)hcryp->pCrypOutBuffPtr;
<>	144:ef7eb2e8f9f7	2255	/* Read the Output block from the Output FIFO */
<>	144:ef7eb2e8f9f7	2256	(uint32_t)(outputaddr) = hcryp->Instance->DOUT;
<>	144:ef7eb2e8f9f7	2257	outputaddr+=4U;
<>	144:ef7eb2e8f9f7	2258	(uint32_t)(outputaddr) = hcryp->Instance->DOUT;
<>	144:ef7eb2e8f9f7	2259	outputaddr+=4U;
<>	144:ef7eb2e8f9f7	2260	(uint32_t)(outputaddr) = hcryp->Instance->DOUT;
<>	144:ef7eb2e8f9f7	2261	outputaddr+=4U;
<>	144:ef7eb2e8f9f7	2262	(uint32_t)(outputaddr) = hcryp->Instance->DOUT;
<>	144:ef7eb2e8f9f7	2263	hcryp->pCrypOutBuffPtr += 16U;
<>	144:ef7eb2e8f9f7	2264	hcryp->CrypOutCount -= 16U;
<>	144:ef7eb2e8f9f7	2265	if(hcryp->CrypOutCount == 0U)
<>	144:ef7eb2e8f9f7	2266	{
<>	144:ef7eb2e8f9f7	2267	__HAL_CRYP_DISABLE_IT(hcryp, CRYP_IT_OUTI);
<>	144:ef7eb2e8f9f7	2268	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	2269	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	2270	/* Change the CRYP peripheral state */
<>	144:ef7eb2e8f9f7	2271	hcryp->State = HAL_CRYP_STATE_READY;
<>	144:ef7eb2e8f9f7	2272	/* Call Input transfer complete callback */
<>	144:ef7eb2e8f9f7	2273	HAL_CRYP_OutCpltCallback(hcryp);
<>	144:ef7eb2e8f9f7	2274	}
<>	144:ef7eb2e8f9f7	2275	}
<>	144:ef7eb2e8f9f7	2276
<>	144:ef7eb2e8f9f7	2277	/* Return function status */
<>	144:ef7eb2e8f9f7	2278	return HAL_OK;
<>	144:ef7eb2e8f9f7	2279	}
<>	144:ef7eb2e8f9f7	2280
<>	144:ef7eb2e8f9f7	2281	/**
<>	144:ef7eb2e8f9f7	2282	* @brief Initializes the CRYP peripheral in AES GCM encryption mode using DMA.
<>	144:ef7eb2e8f9f7	2283	* @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	2284	* the configuration information for CRYP module
<>	144:ef7eb2e8f9f7	2285	* @param pPlainData: Pointer to the plaintext buffer
<>	144:ef7eb2e8f9f7	2286	* @param Size: Length of the plaintext buffer, must be a multiple of 16
<>	144:ef7eb2e8f9f7	2287	* @param pCypherData: Pointer to the cyphertext buffer
<>	144:ef7eb2e8f9f7	2288	* @retval HAL status
<>	144:ef7eb2e8f9f7	2289	*/
<>	144:ef7eb2e8f9f7	2290	HAL_StatusTypeDef HAL_CRYPEx_AESGCM_Encrypt_DMA(CRYP_HandleTypeDef hcryp, uint8_t pPlainData, uint16_t Size, uint8_t *pCypherData)
<>	144:ef7eb2e8f9f7	2291	{
<>	144:ef7eb2e8f9f7	2292	uint32_t tickstart = 0U;
<>	144:ef7eb2e8f9f7	2293	uint32_t inputaddr;
<>	144:ef7eb2e8f9f7	2294	uint32_t outputaddr;
<>	144:ef7eb2e8f9f7	2295
<>	144:ef7eb2e8f9f7	2296	if((hcryp->State == HAL_CRYP_STATE_READY) \|\| (hcryp->Phase == HAL_CRYP_PHASE_PROCESS))
<>	144:ef7eb2e8f9f7	2297	{
<>	144:ef7eb2e8f9f7	2298	/* Process Locked */
<>	144:ef7eb2e8f9f7	2299	__HAL_LOCK(hcryp);
<>	144:ef7eb2e8f9f7	2300
<>	144:ef7eb2e8f9f7	2301	inputaddr = (uint32_t)pPlainData;
<>	144:ef7eb2e8f9f7	2302	outputaddr = (uint32_t)pCypherData;
<>	144:ef7eb2e8f9f7	2303
<>	144:ef7eb2e8f9f7	2304	/* Change the CRYP peripheral state */
<>	144:ef7eb2e8f9f7	2305	hcryp->State = HAL_CRYP_STATE_BUSY;
<>	144:ef7eb2e8f9f7	2306
<>	144:ef7eb2e8f9f7	2307	/* Check if initialization phase has already been performed */
<>	144:ef7eb2e8f9f7	2308	if(hcryp->Phase == HAL_CRYP_PHASE_READY)
<>	144:ef7eb2e8f9f7	2309	{
<>	144:ef7eb2e8f9f7	2310	/* Set the key */
<>	144:ef7eb2e8f9f7	2311	CRYPEx_GCMCCM_SetKey(hcryp, hcryp->Init.pKey, hcryp->Init.KeySize);
<>	144:ef7eb2e8f9f7	2312
<>	144:ef7eb2e8f9f7	2313	/* Set the CRYP peripheral in AES GCM mode */
<>	144:ef7eb2e8f9f7	2314	__HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_GCM_ENCRYPT);
<>	144:ef7eb2e8f9f7	2315
<>	144:ef7eb2e8f9f7	2316	/* Set the Initialization Vector */
<>	144:ef7eb2e8f9f7	2317	CRYPEx_GCMCCM_SetInitVector(hcryp, hcryp->Init.pInitVect);
<>	144:ef7eb2e8f9f7	2318
<>	144:ef7eb2e8f9f7	2319	/* Flush FIFO */
<>	144:ef7eb2e8f9f7	2320	__HAL_CRYP_FIFO_FLUSH(hcryp);
<>	144:ef7eb2e8f9f7	2321
<>	144:ef7eb2e8f9f7	2322	/* Enable CRYP to start the init phase */
<>	144:ef7eb2e8f9f7	2323	__HAL_CRYP_ENABLE(hcryp);
<>	144:ef7eb2e8f9f7	2324
<>	144:ef7eb2e8f9f7	2325	/* Get tick */
<>	144:ef7eb2e8f9f7	2326	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	2327
<>	144:ef7eb2e8f9f7	2328	while((CRYP->CR & CRYP_CR_CRYPEN) == CRYP_CR_CRYPEN)
<>	144:ef7eb2e8f9f7	2329	{
<>	144:ef7eb2e8f9f7	2330	/* Check for the Timeout */
<>	144:ef7eb2e8f9f7	2331	if((HAL_GetTick() - tickstart ) > CRYPEx_TIMEOUT_VALUE)
<>	144:ef7eb2e8f9f7	2332	{
<>	144:ef7eb2e8f9f7	2333	/* Change state */
<>	144:ef7eb2e8f9f7	2334	hcryp->State = HAL_CRYP_STATE_TIMEOUT;
<>	144:ef7eb2e8f9f7	2335
<>	144:ef7eb2e8f9f7	2336	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	2337	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	2338
<>	144:ef7eb2e8f9f7	2339	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	2340	}
<>	144:ef7eb2e8f9f7	2341	}
<>	144:ef7eb2e8f9f7	2342	/* Flush FIFO */
<>	144:ef7eb2e8f9f7	2343	__HAL_CRYP_FIFO_FLUSH(hcryp);
<>	144:ef7eb2e8f9f7	2344
<>	144:ef7eb2e8f9f7	2345	/* Set the header phase */
<>	144:ef7eb2e8f9f7	2346	if(CRYPEx_GCMCCM_SetHeaderPhase(hcryp, hcryp->Init.Header, hcryp->Init.HeaderSize, 1U) != HAL_OK)
<>	144:ef7eb2e8f9f7	2347	{
<>	144:ef7eb2e8f9f7	2348	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	2349	}
<>	144:ef7eb2e8f9f7	2350	/* Disable the CRYP peripheral */
<>	144:ef7eb2e8f9f7	2351	__HAL_CRYP_DISABLE(hcryp);
<>	144:ef7eb2e8f9f7	2352
<>	144:ef7eb2e8f9f7	2353	/* Select payload phase once the header phase is performed */
<>	144:ef7eb2e8f9f7	2354	__HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_PAYLOAD);
<>	144:ef7eb2e8f9f7	2355
<>	144:ef7eb2e8f9f7	2356	/* Flush FIFO */
<>	144:ef7eb2e8f9f7	2357	__HAL_CRYP_FIFO_FLUSH(hcryp);
<>	144:ef7eb2e8f9f7	2358
<>	144:ef7eb2e8f9f7	2359	/* Set the phase */
<>	144:ef7eb2e8f9f7	2360	hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
<>	144:ef7eb2e8f9f7	2361	}
<>	144:ef7eb2e8f9f7	2362
<>	144:ef7eb2e8f9f7	2363	/* Set the input and output addresses and start DMA transfer */
<>	144:ef7eb2e8f9f7	2364	CRYPEx_GCMCCM_SetDMAConfig(hcryp, inputaddr, Size, outputaddr);
<>	144:ef7eb2e8f9f7	2365
<>	144:ef7eb2e8f9f7	2366	/* Unlock process */
<>	144:ef7eb2e8f9f7	2367	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	2368
<>	144:ef7eb2e8f9f7	2369	/* Return function status */
<>	144:ef7eb2e8f9f7	2370	return HAL_OK;
<>	144:ef7eb2e8f9f7	2371	}
<>	144:ef7eb2e8f9f7	2372	else
<>	144:ef7eb2e8f9f7	2373	{
<>	144:ef7eb2e8f9f7	2374	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	2375	}
<>	144:ef7eb2e8f9f7	2376	}
<>	144:ef7eb2e8f9f7	2377
<>	144:ef7eb2e8f9f7	2378	/**
<>	144:ef7eb2e8f9f7	2379	* @brief Initializes the CRYP peripheral in AES CCM encryption mode using interrupt.
<>	144:ef7eb2e8f9f7	2380	* @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	2381	* the configuration information for CRYP module
<>	144:ef7eb2e8f9f7	2382	* @param pPlainData: Pointer to the plaintext buffer
<>	144:ef7eb2e8f9f7	2383	* @param Size: Length of the plaintext buffer, must be a multiple of 16
<>	144:ef7eb2e8f9f7	2384	* @param pCypherData: Pointer to the cyphertext buffer
<>	144:ef7eb2e8f9f7	2385	* @retval HAL status
<>	144:ef7eb2e8f9f7	2386	*/
<>	144:ef7eb2e8f9f7	2387	HAL_StatusTypeDef HAL_CRYPEx_AESCCM_Encrypt_DMA(CRYP_HandleTypeDef hcryp, uint8_t pPlainData, uint16_t Size, uint8_t *pCypherData)
<>	144:ef7eb2e8f9f7	2388	{
<>	144:ef7eb2e8f9f7	2389	uint32_t tickstart = 0U;
<>	144:ef7eb2e8f9f7	2390	uint32_t inputaddr;
<>	144:ef7eb2e8f9f7	2391	uint32_t outputaddr;
<>	144:ef7eb2e8f9f7	2392	uint32_t headersize;
<>	144:ef7eb2e8f9f7	2393	uint32_t headeraddr;
<>	144:ef7eb2e8f9f7	2394	uint32_t loopcounter = 0U;
<>	144:ef7eb2e8f9f7	2395	uint32_t bufferidx = 0U;
<>	144:ef7eb2e8f9f7	2396	uint8_t blockb0[16U] = {0U};/* Block B0 */
<>	144:ef7eb2e8f9f7	2397	uint8_t ctr[16U] = {0U}; /* Counter */
<>	144:ef7eb2e8f9f7	2398	uint32_t b0addr = (uint32_t)blockb0;
<>	144:ef7eb2e8f9f7	2399
<>	144:ef7eb2e8f9f7	2400	if((hcryp->State == HAL_CRYP_STATE_READY) \|\| (hcryp->Phase == HAL_CRYP_PHASE_PROCESS))
<>	144:ef7eb2e8f9f7	2401	{
<>	144:ef7eb2e8f9f7	2402	/* Process Locked */
<>	144:ef7eb2e8f9f7	2403	__HAL_LOCK(hcryp);
<>	144:ef7eb2e8f9f7	2404
<>	144:ef7eb2e8f9f7	2405	inputaddr = (uint32_t)pPlainData;
<>	144:ef7eb2e8f9f7	2406	outputaddr = (uint32_t)pCypherData;
<>	144:ef7eb2e8f9f7	2407
<>	144:ef7eb2e8f9f7	2408	headersize = hcryp->Init.HeaderSize;
<>	144:ef7eb2e8f9f7	2409	headeraddr = (uint32_t)hcryp->Init.Header;
<>	144:ef7eb2e8f9f7	2410
<>	144:ef7eb2e8f9f7	2411	hcryp->CrypInCount = Size;
<>	144:ef7eb2e8f9f7	2412	hcryp->pCrypInBuffPtr = pPlainData;
<>	144:ef7eb2e8f9f7	2413	hcryp->pCrypOutBuffPtr = pCypherData;
<>	144:ef7eb2e8f9f7	2414	hcryp->CrypOutCount = Size;
<>	144:ef7eb2e8f9f7	2415
<>	144:ef7eb2e8f9f7	2416	/* Change the CRYP peripheral state */
<>	144:ef7eb2e8f9f7	2417	hcryp->State = HAL_CRYP_STATE_BUSY;
<>	144:ef7eb2e8f9f7	2418
<>	144:ef7eb2e8f9f7	2419	/* Check if initialization phase has already been performed */
<>	144:ef7eb2e8f9f7	2420	if(hcryp->Phase == HAL_CRYP_PHASE_READY)
<>	144:ef7eb2e8f9f7	2421	{
<>	144:ef7eb2e8f9f7	2422	/********************** Formatting the header block *****************/
<>	144:ef7eb2e8f9f7	2423	if(headersize != 0U)
<>	144:ef7eb2e8f9f7	2424	{
<>	144:ef7eb2e8f9f7	2425	/* Check that the associated data (or header) length is lower than 2^16 - 2^8 = 65536 - 256 = 65280 */
<>	144:ef7eb2e8f9f7	2426	if(headersize < 65280U)
<>	144:ef7eb2e8f9f7	2427	{
<>	144:ef7eb2e8f9f7	2428	hcryp->Init.pScratch[bufferidx++] = (uint8_t) ((headersize >> 8U) & 0xFFU);
<>	144:ef7eb2e8f9f7	2429	hcryp->Init.pScratch[bufferidx++] = (uint8_t) ((headersize) & 0xFFU);
<>	144:ef7eb2e8f9f7	2430	headersize += 2U;
<>	144:ef7eb2e8f9f7	2431	}
<>	144:ef7eb2e8f9f7	2432	else
<>	144:ef7eb2e8f9f7	2433	{
<>	144:ef7eb2e8f9f7	2434	/* Header is encoded as 0xff \|\| 0xfe \|\| [headersize]32, i.e., six octets */
<>	144:ef7eb2e8f9f7	2435	hcryp->Init.pScratch[bufferidx++] = 0xFFU;
<>	144:ef7eb2e8f9f7	2436	hcryp->Init.pScratch[bufferidx++] = 0xFEU;
<>	144:ef7eb2e8f9f7	2437	hcryp->Init.pScratch[bufferidx++] = headersize & 0xff000000U;
<>	144:ef7eb2e8f9f7	2438	hcryp->Init.pScratch[bufferidx++] = headersize & 0x00ff0000U;
<>	144:ef7eb2e8f9f7	2439	hcryp->Init.pScratch[bufferidx++] = headersize & 0x0000ff00U;
<>	144:ef7eb2e8f9f7	2440	hcryp->Init.pScratch[bufferidx++] = headersize & 0x000000ffU;
<>	144:ef7eb2e8f9f7	2441	headersize += 6U;
<>	144:ef7eb2e8f9f7	2442	}
<>	144:ef7eb2e8f9f7	2443	/* Copy the header buffer in internal buffer "hcryp->Init.pScratch" */
<>	144:ef7eb2e8f9f7	2444	for(loopcounter = 0U; loopcounter < headersize; loopcounter++)
<>	144:ef7eb2e8f9f7	2445	{
<>	144:ef7eb2e8f9f7	2446	hcryp->Init.pScratch[bufferidx++] = hcryp->Init.Header[loopcounter];
<>	144:ef7eb2e8f9f7	2447	}
<>	144:ef7eb2e8f9f7	2448	/* Check if the header size is modulo 16 */
<>	144:ef7eb2e8f9f7	2449	if ((headersize % 16U) != 0U)
<>	144:ef7eb2e8f9f7	2450	{
<>	144:ef7eb2e8f9f7	2451	/* Padd the header buffer with 0s till the hcryp->Init.pScratch length is modulo 16 */
<>	144:ef7eb2e8f9f7	2452	for(loopcounter = headersize; loopcounter <= ((headersize/16U) + 1U) * 16U; loopcounter++)
<>	144:ef7eb2e8f9f7	2453	{
<>	144:ef7eb2e8f9f7	2454	hcryp->Init.pScratch[loopcounter] = 0U;
<>	144:ef7eb2e8f9f7	2455	}
<>	144:ef7eb2e8f9f7	2456	/* Set the header size to modulo 16 */
<>	144:ef7eb2e8f9f7	2457	headersize = ((headersize/16U) + 1U) * 16U;
<>	144:ef7eb2e8f9f7	2458	}
<>	144:ef7eb2e8f9f7	2459	/* Set the pointer headeraddr to hcryp->Init.pScratch */
<>	144:ef7eb2e8f9f7	2460	headeraddr = (uint32_t)hcryp->Init.pScratch;
<>	144:ef7eb2e8f9f7	2461	}
<>	144:ef7eb2e8f9f7	2462	/********************* Formatting the block B0 **********************/
<>	144:ef7eb2e8f9f7	2463	if(headersize != 0U)
<>	144:ef7eb2e8f9f7	2464	{
<>	144:ef7eb2e8f9f7	2465	blockb0[0U] = 0x40U;
<>	144:ef7eb2e8f9f7	2466	}
<>	144:ef7eb2e8f9f7	2467	/* Flags byte */
<>	144:ef7eb2e8f9f7	2468	/* blockb0[0] \|= 0u \| (((( (uint8_t) hcryp->Init.TagSize - 2) / 2) & 0x07 ) << 3 ) \| ( ( (uint8_t) (15 - hcryp->Init.IVSize) - 1) & 0x07U) */
<>	144:ef7eb2e8f9f7	2469	blockb0[0U] \|= (uint8_t)((uint8_t)((uint8_t)(((uint8_t)(hcryp->Init.TagSize - (uint8_t)(2U))) >> 1U) & (uint8_t)0x07U) << 3U);
<>	144:ef7eb2e8f9f7	2470	blockb0[0U] \|= (uint8_t)((uint8_t)((uint8_t)((uint8_t)(15U) - hcryp->Init.IVSize) - (uint8_t)1U) & (uint8_t)0x07U);
<>	144:ef7eb2e8f9f7	2471
<>	144:ef7eb2e8f9f7	2472	for (loopcounter = 0U; loopcounter < hcryp->Init.IVSize; loopcounter++)
<>	144:ef7eb2e8f9f7	2473	{
<>	144:ef7eb2e8f9f7	2474	blockb0[loopcounter+1U] = hcryp->Init.pInitVect[loopcounter];
<>	144:ef7eb2e8f9f7	2475	}
<>	144:ef7eb2e8f9f7	2476	for ( ; loopcounter < 13U; loopcounter++)
<>	144:ef7eb2e8f9f7	2477	{
<>	144:ef7eb2e8f9f7	2478	blockb0[loopcounter+1U] = 0U;
<>	144:ef7eb2e8f9f7	2479	}
<>	144:ef7eb2e8f9f7	2480
<>	144:ef7eb2e8f9f7	2481	blockb0[14U] = (Size >> 8U);
<>	144:ef7eb2e8f9f7	2482	blockb0[15U] = (Size & 0xFFU);
<>	144:ef7eb2e8f9f7	2483
<>	144:ef7eb2e8f9f7	2484	/*********************** Formatting the initial counter *************/
<>	144:ef7eb2e8f9f7	2485	/* Byte 0:
<>	144:ef7eb2e8f9f7	2486	Bits 7 and 6 are reserved and shall be set to 0
<>	144:ef7eb2e8f9f7	2487	Bits 3, 4, and 5 shall also be set to 0, to ensure that all the counter
<>	144:ef7eb2e8f9f7	2488	blocks are distinct from B0
<>	144:ef7eb2e8f9f7	2489	Bits 0, 1, and 2 contain the same encoding of q as in B0
<>	144:ef7eb2e8f9f7	2490	*/
<>	144:ef7eb2e8f9f7	2491	ctr[0U] = blockb0[0U] & 0x07U;
<>	144:ef7eb2e8f9f7	2492	/* byte 1 to NonceSize is the IV (Nonce) */
<>	144:ef7eb2e8f9f7	2493	for(loopcounter = 1U; loopcounter < hcryp->Init.IVSize + 1U; loopcounter++)
<>	144:ef7eb2e8f9f7	2494	{
<>	144:ef7eb2e8f9f7	2495	ctr[loopcounter] = blockb0[loopcounter];
<>	144:ef7eb2e8f9f7	2496	}
<>	144:ef7eb2e8f9f7	2497	/* Set the LSB to 1 */
<>	144:ef7eb2e8f9f7	2498	ctr[15U] \|= 0x01U;
<>	144:ef7eb2e8f9f7	2499
<>	144:ef7eb2e8f9f7	2500	/* Set the key */
<>	144:ef7eb2e8f9f7	2501	CRYPEx_GCMCCM_SetKey(hcryp, hcryp->Init.pKey, hcryp->Init.KeySize);
<>	144:ef7eb2e8f9f7	2502
<>	144:ef7eb2e8f9f7	2503	/* Set the CRYP peripheral in AES CCM mode */
<>	144:ef7eb2e8f9f7	2504	__HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CCM_ENCRYPT);
<>	144:ef7eb2e8f9f7	2505
<>	144:ef7eb2e8f9f7	2506	/* Set the Initialization Vector */
<>	144:ef7eb2e8f9f7	2507	CRYPEx_GCMCCM_SetInitVector(hcryp, ctr);
<>	144:ef7eb2e8f9f7	2508
<>	144:ef7eb2e8f9f7	2509	/* Select init phase */
<>	144:ef7eb2e8f9f7	2510	__HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_INIT);
<>	144:ef7eb2e8f9f7	2511
<>	144:ef7eb2e8f9f7	2512	b0addr = (uint32_t)blockb0;
<>	144:ef7eb2e8f9f7	2513	/* Write the blockb0 block in the IN FIFO */
<>	144:ef7eb2e8f9f7	2514	hcryp->Instance->DR = (uint32_t)(b0addr);
<>	144:ef7eb2e8f9f7	2515	b0addr+=4U;
<>	144:ef7eb2e8f9f7	2516	hcryp->Instance->DR = (uint32_t)(b0addr);
<>	144:ef7eb2e8f9f7	2517	b0addr+=4U;
<>	144:ef7eb2e8f9f7	2518	hcryp->Instance->DR = (uint32_t)(b0addr);
<>	144:ef7eb2e8f9f7	2519	b0addr+=4U;
<>	144:ef7eb2e8f9f7	2520	hcryp->Instance->DR = (uint32_t)(b0addr);
<>	144:ef7eb2e8f9f7	2521
<>	144:ef7eb2e8f9f7	2522	/* Enable the CRYP peripheral */
<>	144:ef7eb2e8f9f7	2523	__HAL_CRYP_ENABLE(hcryp);
<>	144:ef7eb2e8f9f7	2524
<>	144:ef7eb2e8f9f7	2525	/* Get tick */
<>	144:ef7eb2e8f9f7	2526	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	2527
<>	144:ef7eb2e8f9f7	2528	while((CRYP->CR & CRYP_CR_CRYPEN) == CRYP_CR_CRYPEN)
<>	144:ef7eb2e8f9f7	2529	{
<>	144:ef7eb2e8f9f7	2530	/* Check for the Timeout */
<>	144:ef7eb2e8f9f7	2531	if((HAL_GetTick() - tickstart ) > CRYPEx_TIMEOUT_VALUE)
<>	144:ef7eb2e8f9f7	2532	{
<>	144:ef7eb2e8f9f7	2533	/* Change state */
<>	144:ef7eb2e8f9f7	2534	hcryp->State = HAL_CRYP_STATE_TIMEOUT;
<>	144:ef7eb2e8f9f7	2535
<>	144:ef7eb2e8f9f7	2536	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	2537	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	2538
<>	144:ef7eb2e8f9f7	2539	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	2540	}
<>	144:ef7eb2e8f9f7	2541	}
<>	144:ef7eb2e8f9f7	2542	/*************************** Header phase ***************************/
<>	144:ef7eb2e8f9f7	2543	if(headersize != 0U)
<>	144:ef7eb2e8f9f7	2544	{
<>	144:ef7eb2e8f9f7	2545	/* Select header phase */
<>	144:ef7eb2e8f9f7	2546	__HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_HEADER);
<>	144:ef7eb2e8f9f7	2547
<>	144:ef7eb2e8f9f7	2548	/* Enable Crypto processor */
<>	144:ef7eb2e8f9f7	2549	__HAL_CRYP_ENABLE(hcryp);
<>	144:ef7eb2e8f9f7	2550
<>	144:ef7eb2e8f9f7	2551	for(loopcounter = 0U; (loopcounter < headersize); loopcounter+=16U)
<>	144:ef7eb2e8f9f7	2552	{
<>	144:ef7eb2e8f9f7	2553	/* Get tick */
<>	144:ef7eb2e8f9f7	2554	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	2555
<>	144:ef7eb2e8f9f7	2556	while(HAL_IS_BIT_CLR(hcryp->Instance->SR, CRYP_FLAG_IFEM))
<>	144:ef7eb2e8f9f7	2557	{
<>	144:ef7eb2e8f9f7	2558	/* Check for the Timeout */
<>	144:ef7eb2e8f9f7	2559	if((HAL_GetTick() - tickstart ) > CRYPEx_TIMEOUT_VALUE)
<>	144:ef7eb2e8f9f7	2560	{
<>	144:ef7eb2e8f9f7	2561	/* Change state */
<>	144:ef7eb2e8f9f7	2562	hcryp->State = HAL_CRYP_STATE_TIMEOUT;
<>	144:ef7eb2e8f9f7	2563
<>	144:ef7eb2e8f9f7	2564	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	2565	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	2566
<>	144:ef7eb2e8f9f7	2567	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	2568	}
<>	144:ef7eb2e8f9f7	2569	}
<>	144:ef7eb2e8f9f7	2570	/* Write the header block in the IN FIFO */
<>	144:ef7eb2e8f9f7	2571	hcryp->Instance->DR = (uint32_t)(headeraddr);
<>	144:ef7eb2e8f9f7	2572	headeraddr+=4U;
<>	144:ef7eb2e8f9f7	2573	hcryp->Instance->DR = (uint32_t)(headeraddr);
<>	144:ef7eb2e8f9f7	2574	headeraddr+=4U;
<>	144:ef7eb2e8f9f7	2575	hcryp->Instance->DR = (uint32_t)(headeraddr);
<>	144:ef7eb2e8f9f7	2576	headeraddr+=4U;
<>	144:ef7eb2e8f9f7	2577	hcryp->Instance->DR = (uint32_t)(headeraddr);
<>	144:ef7eb2e8f9f7	2578	headeraddr+=4U;
<>	144:ef7eb2e8f9f7	2579	}
<>	144:ef7eb2e8f9f7	2580
<>	144:ef7eb2e8f9f7	2581	/* Get tick */
<>	144:ef7eb2e8f9f7	2582	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	2583
<>	144:ef7eb2e8f9f7	2584	while((hcryp->Instance->SR & CRYP_FLAG_BUSY) == CRYP_FLAG_BUSY)
<>	144:ef7eb2e8f9f7	2585	{
<>	144:ef7eb2e8f9f7	2586	/* Check for the Timeout */
<>	144:ef7eb2e8f9f7	2587	if((HAL_GetTick() - tickstart ) > CRYPEx_TIMEOUT_VALUE)
<>	144:ef7eb2e8f9f7	2588	{
<>	144:ef7eb2e8f9f7	2589	/* Change state */
<>	144:ef7eb2e8f9f7	2590	hcryp->State = HAL_CRYP_STATE_TIMEOUT;
<>	144:ef7eb2e8f9f7	2591
<>	144:ef7eb2e8f9f7	2592	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	2593	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	2594
<>	144:ef7eb2e8f9f7	2595	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	2596	}
<>	144:ef7eb2e8f9f7	2597	}
<>	144:ef7eb2e8f9f7	2598	}
<>	144:ef7eb2e8f9f7	2599	/* Save formatted counter into the scratch buffer pScratch */
<>	144:ef7eb2e8f9f7	2600	for(loopcounter = 0U; (loopcounter < 16U); loopcounter++)
<>	144:ef7eb2e8f9f7	2601	{
<>	144:ef7eb2e8f9f7	2602	hcryp->Init.pScratch[loopcounter] = ctr[loopcounter];
<>	144:ef7eb2e8f9f7	2603	}
<>	144:ef7eb2e8f9f7	2604	/* Reset bit 0 */
<>	144:ef7eb2e8f9f7	2605	hcryp->Init.pScratch[15U] &= 0xFEU;
<>	144:ef7eb2e8f9f7	2606
<>	144:ef7eb2e8f9f7	2607	/* Select payload phase once the header phase is performed */
<>	144:ef7eb2e8f9f7	2608	__HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_PAYLOAD);
<>	144:ef7eb2e8f9f7	2609
<>	144:ef7eb2e8f9f7	2610	/* Flush FIFO */
<>	144:ef7eb2e8f9f7	2611	__HAL_CRYP_FIFO_FLUSH(hcryp);
<>	144:ef7eb2e8f9f7	2612
<>	144:ef7eb2e8f9f7	2613	/* Set the phase */
<>	144:ef7eb2e8f9f7	2614	hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
<>	144:ef7eb2e8f9f7	2615	}
<>	144:ef7eb2e8f9f7	2616
<>	144:ef7eb2e8f9f7	2617	/* Set the input and output addresses and start DMA transfer */
<>	144:ef7eb2e8f9f7	2618	CRYPEx_GCMCCM_SetDMAConfig(hcryp, inputaddr, Size, outputaddr);
<>	144:ef7eb2e8f9f7	2619
<>	144:ef7eb2e8f9f7	2620	/* Unlock process */
<>	144:ef7eb2e8f9f7	2621	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	2622
<>	144:ef7eb2e8f9f7	2623	/* Return function status */
<>	144:ef7eb2e8f9f7	2624	return HAL_OK;
<>	144:ef7eb2e8f9f7	2625	}
<>	144:ef7eb2e8f9f7	2626	else
<>	144:ef7eb2e8f9f7	2627	{
<>	144:ef7eb2e8f9f7	2628	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	2629	}
<>	144:ef7eb2e8f9f7	2630	}
<>	144:ef7eb2e8f9f7	2631
<>	144:ef7eb2e8f9f7	2632	/**
<>	144:ef7eb2e8f9f7	2633	* @brief Initializes the CRYP peripheral in AES GCM decryption mode using DMA.
<>	144:ef7eb2e8f9f7	2634	* @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	2635	* the configuration information for CRYP module
<>	144:ef7eb2e8f9f7	2636	* @param pCypherData: Pointer to the cyphertext buffer.
<>	144:ef7eb2e8f9f7	2637	* @param Size: Length of the cyphertext buffer, must be a multiple of 16
<>	144:ef7eb2e8f9f7	2638	* @param pPlainData: Pointer to the plaintext buffer
<>	144:ef7eb2e8f9f7	2639	* @retval HAL status
<>	144:ef7eb2e8f9f7	2640	*/
<>	144:ef7eb2e8f9f7	2641	HAL_StatusTypeDef HAL_CRYPEx_AESGCM_Decrypt_DMA(CRYP_HandleTypeDef hcryp, uint8_t pCypherData, uint16_t Size, uint8_t *pPlainData)
<>	144:ef7eb2e8f9f7	2642	{
<>	144:ef7eb2e8f9f7	2643	uint32_t tickstart = 0U;
<>	144:ef7eb2e8f9f7	2644	uint32_t inputaddr;
<>	144:ef7eb2e8f9f7	2645	uint32_t outputaddr;
<>	144:ef7eb2e8f9f7	2646
<>	144:ef7eb2e8f9f7	2647	if((hcryp->State == HAL_CRYP_STATE_READY) \|\| (hcryp->Phase == HAL_CRYP_PHASE_PROCESS))
<>	144:ef7eb2e8f9f7	2648	{
<>	144:ef7eb2e8f9f7	2649	/* Process Locked */
<>	144:ef7eb2e8f9f7	2650	__HAL_LOCK(hcryp);
<>	144:ef7eb2e8f9f7	2651
<>	144:ef7eb2e8f9f7	2652	inputaddr = (uint32_t)pCypherData;
<>	144:ef7eb2e8f9f7	2653	outputaddr = (uint32_t)pPlainData;
<>	144:ef7eb2e8f9f7	2654
<>	144:ef7eb2e8f9f7	2655	/* Change the CRYP peripheral state */
<>	144:ef7eb2e8f9f7	2656	hcryp->State = HAL_CRYP_STATE_BUSY;
<>	144:ef7eb2e8f9f7	2657
<>	144:ef7eb2e8f9f7	2658	/* Check if initialization phase has already been performed */
<>	144:ef7eb2e8f9f7	2659	if(hcryp->Phase == HAL_CRYP_PHASE_READY)
<>	144:ef7eb2e8f9f7	2660	{
<>	144:ef7eb2e8f9f7	2661	/* Set the key */
<>	144:ef7eb2e8f9f7	2662	CRYPEx_GCMCCM_SetKey(hcryp, hcryp->Init.pKey, hcryp->Init.KeySize);
<>	144:ef7eb2e8f9f7	2663
<>	144:ef7eb2e8f9f7	2664	/* Set the CRYP peripheral in AES GCM decryption mode */
<>	144:ef7eb2e8f9f7	2665	__HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_GCM_DECRYPT);
<>	144:ef7eb2e8f9f7	2666
<>	144:ef7eb2e8f9f7	2667	/* Set the Initialization Vector */
<>	144:ef7eb2e8f9f7	2668	CRYPEx_GCMCCM_SetInitVector(hcryp, hcryp->Init.pInitVect);
<>	144:ef7eb2e8f9f7	2669
<>	144:ef7eb2e8f9f7	2670	/* Enable CRYP to start the init phase */
<>	144:ef7eb2e8f9f7	2671	__HAL_CRYP_ENABLE(hcryp);
<>	144:ef7eb2e8f9f7	2672
<>	144:ef7eb2e8f9f7	2673	/* Get tick */
<>	144:ef7eb2e8f9f7	2674	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	2675
<>	144:ef7eb2e8f9f7	2676	while((CRYP->CR & CRYP_CR_CRYPEN) == CRYP_CR_CRYPEN)
<>	144:ef7eb2e8f9f7	2677	{
<>	144:ef7eb2e8f9f7	2678	/* Check for the Timeout */
<>	144:ef7eb2e8f9f7	2679	if((HAL_GetTick() - tickstart ) > CRYPEx_TIMEOUT_VALUE)
<>	144:ef7eb2e8f9f7	2680	{
<>	144:ef7eb2e8f9f7	2681	/* Change state */
<>	144:ef7eb2e8f9f7	2682	hcryp->State = HAL_CRYP_STATE_TIMEOUT;
<>	144:ef7eb2e8f9f7	2683
<>	144:ef7eb2e8f9f7	2684	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	2685	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	2686
<>	144:ef7eb2e8f9f7	2687	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	2688	}
<>	144:ef7eb2e8f9f7	2689	}
<>	144:ef7eb2e8f9f7	2690
<>	144:ef7eb2e8f9f7	2691	/* Set the header phase */
<>	144:ef7eb2e8f9f7	2692	if(CRYPEx_GCMCCM_SetHeaderPhase(hcryp, hcryp->Init.Header, hcryp->Init.HeaderSize, 1U) != HAL_OK)
<>	144:ef7eb2e8f9f7	2693	{
<>	144:ef7eb2e8f9f7	2694	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	2695	}
<>	144:ef7eb2e8f9f7	2696	/* Disable the CRYP peripheral */
<>	144:ef7eb2e8f9f7	2697	__HAL_CRYP_DISABLE(hcryp);
<>	144:ef7eb2e8f9f7	2698
<>	144:ef7eb2e8f9f7	2699	/* Select payload phase once the header phase is performed */
<>	144:ef7eb2e8f9f7	2700	__HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_PAYLOAD);
<>	144:ef7eb2e8f9f7	2701
<>	144:ef7eb2e8f9f7	2702	/* Set the phase */
<>	144:ef7eb2e8f9f7	2703	hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
<>	144:ef7eb2e8f9f7	2704	}
<>	144:ef7eb2e8f9f7	2705
<>	144:ef7eb2e8f9f7	2706	/* Set the input and output addresses and start DMA transfer */
<>	144:ef7eb2e8f9f7	2707	CRYPEx_GCMCCM_SetDMAConfig(hcryp, inputaddr, Size, outputaddr);
<>	144:ef7eb2e8f9f7	2708
<>	144:ef7eb2e8f9f7	2709	/* Unlock process */
<>	144:ef7eb2e8f9f7	2710	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	2711
<>	144:ef7eb2e8f9f7	2712	/* Return function status */
<>	144:ef7eb2e8f9f7	2713	return HAL_OK;
<>	144:ef7eb2e8f9f7	2714	}
<>	144:ef7eb2e8f9f7	2715	else
<>	144:ef7eb2e8f9f7	2716	{
<>	144:ef7eb2e8f9f7	2717	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	2718	}
<>	144:ef7eb2e8f9f7	2719	}
<>	144:ef7eb2e8f9f7	2720
<>	144:ef7eb2e8f9f7	2721	/**
<>	144:ef7eb2e8f9f7	2722	* @brief Initializes the CRYP peripheral in AES CCM decryption mode using DMA
<>	144:ef7eb2e8f9f7	2723	* then decrypted pCypherData. The cypher data are available in pPlainData.
<>	144:ef7eb2e8f9f7	2724	* @param hcryp: pointer to a CRYP_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	2725	* the configuration information for CRYP module
<>	144:ef7eb2e8f9f7	2726	* @param pCypherData: Pointer to the cyphertext buffer
<>	144:ef7eb2e8f9f7	2727	* @param Size: Length of the plaintext buffer, must be a multiple of 16
<>	144:ef7eb2e8f9f7	2728	* @param pPlainData: Pointer to the plaintext buffer
<>	144:ef7eb2e8f9f7	2729	* @retval HAL status
<>	144:ef7eb2e8f9f7	2730	*/
<>	144:ef7eb2e8f9f7	2731	HAL_StatusTypeDef HAL_CRYPEx_AESCCM_Decrypt_DMA(CRYP_HandleTypeDef hcryp, uint8_t pCypherData, uint16_t Size, uint8_t *pPlainData)
<>	144:ef7eb2e8f9f7	2732	{
<>	144:ef7eb2e8f9f7	2733	uint32_t tickstart = 0U;
<>	144:ef7eb2e8f9f7	2734	uint32_t inputaddr;
<>	144:ef7eb2e8f9f7	2735	uint32_t outputaddr;
<>	144:ef7eb2e8f9f7	2736	uint32_t headersize;
<>	144:ef7eb2e8f9f7	2737	uint32_t headeraddr;
<>	144:ef7eb2e8f9f7	2738	uint32_t loopcounter = 0U;
<>	144:ef7eb2e8f9f7	2739	uint32_t bufferidx = 0U;
<>	144:ef7eb2e8f9f7	2740	uint8_t blockb0[16U] = {0U};/* Block B0 */
<>	144:ef7eb2e8f9f7	2741	uint8_t ctr[16U] = {0U}; /* Counter */
<>	144:ef7eb2e8f9f7	2742	uint32_t b0addr = (uint32_t)blockb0;
<>	144:ef7eb2e8f9f7	2743
<>	144:ef7eb2e8f9f7	2744	if((hcryp->State == HAL_CRYP_STATE_READY) \|\| (hcryp->Phase == HAL_CRYP_PHASE_PROCESS))
<>	144:ef7eb2e8f9f7	2745	{
<>	144:ef7eb2e8f9f7	2746	/* Process Locked */
<>	144:ef7eb2e8f9f7	2747	__HAL_LOCK(hcryp);
<>	144:ef7eb2e8f9f7	2748
<>	144:ef7eb2e8f9f7	2749	inputaddr = (uint32_t)pCypherData;
<>	144:ef7eb2e8f9f7	2750	outputaddr = (uint32_t)pPlainData;
<>	144:ef7eb2e8f9f7	2751
<>	144:ef7eb2e8f9f7	2752	headersize = hcryp->Init.HeaderSize;
<>	144:ef7eb2e8f9f7	2753	headeraddr = (uint32_t)hcryp->Init.Header;
<>	144:ef7eb2e8f9f7	2754
<>	144:ef7eb2e8f9f7	2755	hcryp->CrypInCount = Size;
<>	144:ef7eb2e8f9f7	2756	hcryp->pCrypInBuffPtr = pCypherData;
<>	144:ef7eb2e8f9f7	2757	hcryp->pCrypOutBuffPtr = pPlainData;
<>	144:ef7eb2e8f9f7	2758	hcryp->CrypOutCount = Size;
<>	144:ef7eb2e8f9f7	2759
<>	144:ef7eb2e8f9f7	2760	/* Change the CRYP peripheral state */
<>	144:ef7eb2e8f9f7	2761	hcryp->State = HAL_CRYP_STATE_BUSY;
<>	144:ef7eb2e8f9f7	2762
<>	144:ef7eb2e8f9f7	2763	/* Check if initialization phase has already been performed */
<>	144:ef7eb2e8f9f7	2764	if(hcryp->Phase == HAL_CRYP_PHASE_READY)
<>	144:ef7eb2e8f9f7	2765	{
<>	144:ef7eb2e8f9f7	2766	/********************** Formatting the header block *****************/
<>	144:ef7eb2e8f9f7	2767	if(headersize != 0U)
<>	144:ef7eb2e8f9f7	2768	{
<>	144:ef7eb2e8f9f7	2769	/* Check that the associated data (or header) length is lower than 2^16 - 2^8 = 65536 - 256 = 65280 */
<>	144:ef7eb2e8f9f7	2770	if(headersize < 65280U)
<>	144:ef7eb2e8f9f7	2771	{
<>	144:ef7eb2e8f9f7	2772	hcryp->Init.pScratch[bufferidx++] = (uint8_t) ((headersize >> 8U) & 0xFFU);
<>	144:ef7eb2e8f9f7	2773	hcryp->Init.pScratch[bufferidx++] = (uint8_t) ((headersize) & 0xFFU);
<>	144:ef7eb2e8f9f7	2774	headersize += 2U;
<>	144:ef7eb2e8f9f7	2775	}
<>	144:ef7eb2e8f9f7	2776	else
<>	144:ef7eb2e8f9f7	2777	{
<>	144:ef7eb2e8f9f7	2778	/* Header is encoded as 0xff \|\| 0xfe \|\| [headersize]32, i.e., six octets */
<>	144:ef7eb2e8f9f7	2779	hcryp->Init.pScratch[bufferidx++] = 0xFFU;
<>	144:ef7eb2e8f9f7	2780	hcryp->Init.pScratch[bufferidx++] = 0xFEU;
<>	144:ef7eb2e8f9f7	2781	hcryp->Init.pScratch[bufferidx++] = headersize & 0xff000000U;
<>	144:ef7eb2e8f9f7	2782	hcryp->Init.pScratch[bufferidx++] = headersize & 0x00ff0000U;
<>	144:ef7eb2e8f9f7	2783	hcryp->Init.pScratch[bufferidx++] = headersize & 0x0000ff00U;
<>	144:ef7eb2e8f9f7	2784	hcryp->Init.pScratch[bufferidx++] = headersize & 0x000000ffU;
<>	144:ef7eb2e8f9f7	2785	headersize += 6U;
<>	144:ef7eb2e8f9f7	2786	}
<>	144:ef7eb2e8f9f7	2787	/* Copy the header buffer in internal buffer "hcryp->Init.pScratch" */
<>	144:ef7eb2e8f9f7	2788	for(loopcounter = 0U; loopcounter < headersize; loopcounter++)
<>	144:ef7eb2e8f9f7	2789	{
<>	144:ef7eb2e8f9f7	2790	hcryp->Init.pScratch[bufferidx++] = hcryp->Init.Header[loopcounter];
<>	144:ef7eb2e8f9f7	2791	}
<>	144:ef7eb2e8f9f7	2792	/* Check if the header size is modulo 16 */
<>	144:ef7eb2e8f9f7	2793	if ((headersize % 16U) != 0U)
<>	144:ef7eb2e8f9f7	2794	{
<>	144:ef7eb2e8f9f7	2795	/* Padd the header buffer with 0s till the hcryp->Init.pScratch length is modulo 16 */
<>	144:ef7eb2e8f9f7	2796	for(loopcounter = headersize; loopcounter <= ((headersize/16U) + 1U) * 16U; loopcounter++)
<>	144:ef7eb2e8f9f7	2797	{
<>	144:ef7eb2e8f9f7	2798	hcryp->Init.pScratch[loopcounter] = 0U;
<>	144:ef7eb2e8f9f7	2799	}
<>	144:ef7eb2e8f9f7	2800	/* Set the header size to modulo 16 */
<>	144:ef7eb2e8f9f7	2801	headersize = ((headersize/16U) + 1U) * 16U;
<>	144:ef7eb2e8f9f7	2802	}
<>	144:ef7eb2e8f9f7	2803	/* Set the pointer headeraddr to hcryp->Init.pScratch */
<>	144:ef7eb2e8f9f7	2804	headeraddr = (uint32_t)hcryp->Init.pScratch;
<>	144:ef7eb2e8f9f7	2805	}
<>	144:ef7eb2e8f9f7	2806	/********************* Formatting the block B0 **********************/
<>	144:ef7eb2e8f9f7	2807	if(headersize != 0U)
<>	144:ef7eb2e8f9f7	2808	{
<>	144:ef7eb2e8f9f7	2809	blockb0[0U] = 0x40U;
<>	144:ef7eb2e8f9f7	2810	}
<>	144:ef7eb2e8f9f7	2811	/* Flags byte */
<>	144:ef7eb2e8f9f7	2812	/* blockb0[0] \|= 0u \| (((( (uint8_t) hcryp->Init.TagSize - 2) / 2) & 0x07 ) << 3 ) \| ( ( (uint8_t) (15 - hcryp->Init.IVSize) - 1) & 0x07U) */
<>	144:ef7eb2e8f9f7	2813	blockb0[0U] \|= (uint8_t)((uint8_t)((uint8_t)(((uint8_t)(hcryp->Init.TagSize - (uint8_t)(2U))) >> 1U) & (uint8_t)0x07U) << 3U);
<>	144:ef7eb2e8f9f7	2814	blockb0[0U] \|= (uint8_t)((uint8_t)((uint8_t)((uint8_t)(15U) - hcryp->Init.IVSize) - (uint8_t)1U) & (uint8_t)0x07U);
<>	144:ef7eb2e8f9f7	2815
<>	144:ef7eb2e8f9f7	2816	for (loopcounter = 0U; loopcounter < hcryp->Init.IVSize; loopcounter++)
<>	144:ef7eb2e8f9f7	2817	{
<>	144:ef7eb2e8f9f7	2818	blockb0[loopcounter+1U] = hcryp->Init.pInitVect[loopcounter];
<>	144:ef7eb2e8f9f7	2819	}
<>	144:ef7eb2e8f9f7	2820	for ( ; loopcounter < 13U; loopcounter++)
<>	144:ef7eb2e8f9f7	2821	{
<>	144:ef7eb2e8f9f7	2822	blockb0[loopcounter+1U] = 0U;
<>	144:ef7eb2e8f9f7	2823	}
<>	144:ef7eb2e8f9f7	2824
<>	144:ef7eb2e8f9f7	2825	blockb0[14U] = (Size >> 8U);
<>	144:ef7eb2e8f9f7	2826	blockb0[15U] = (Size & 0xFFU);
<>	144:ef7eb2e8f9f7	2827
<>	144:ef7eb2e8f9f7	2828	/*********************** Formatting the initial counter *************/
<>	144:ef7eb2e8f9f7	2829	/* Byte 0:
<>	144:ef7eb2e8f9f7	2830	Bits 7 and 6 are reserved and shall be set to 0
<>	144:ef7eb2e8f9f7	2831	Bits 3, 4, and 5 shall also be set to 0, to ensure that all the counter
<>	144:ef7eb2e8f9f7	2832	blocks are distinct from B0
<>	144:ef7eb2e8f9f7	2833	Bits 0, 1, and 2 contain the same encoding of q as in B0
<>	144:ef7eb2e8f9f7	2834	*/
<>	144:ef7eb2e8f9f7	2835	ctr[0U] = blockb0[0U] & 0x07U;
<>	144:ef7eb2e8f9f7	2836	/* byte 1 to NonceSize is the IV (Nonce) */
<>	144:ef7eb2e8f9f7	2837	for(loopcounter = 1U; loopcounter < hcryp->Init.IVSize + 1U; loopcounter++)
<>	144:ef7eb2e8f9f7	2838	{
<>	144:ef7eb2e8f9f7	2839	ctr[loopcounter] = blockb0[loopcounter];
<>	144:ef7eb2e8f9f7	2840	}
<>	144:ef7eb2e8f9f7	2841	/* Set the LSB to 1 */
<>	144:ef7eb2e8f9f7	2842	ctr[15U] \|= 0x01U;
<>	144:ef7eb2e8f9f7	2843
<>	144:ef7eb2e8f9f7	2844	/* Set the key */
<>	144:ef7eb2e8f9f7	2845	CRYPEx_GCMCCM_SetKey(hcryp, hcryp->Init.pKey, hcryp->Init.KeySize);
<>	144:ef7eb2e8f9f7	2846
<>	144:ef7eb2e8f9f7	2847	/* Set the CRYP peripheral in AES CCM mode */
<>	144:ef7eb2e8f9f7	2848	__HAL_CRYP_SET_MODE(hcryp, CRYP_CR_ALGOMODE_AES_CCM_DECRYPT);
<>	144:ef7eb2e8f9f7	2849
<>	144:ef7eb2e8f9f7	2850	/* Set the Initialization Vector */
<>	144:ef7eb2e8f9f7	2851	CRYPEx_GCMCCM_SetInitVector(hcryp, ctr);
<>	144:ef7eb2e8f9f7	2852
<>	144:ef7eb2e8f9f7	2853	/* Select init phase */
<>	144:ef7eb2e8f9f7	2854	__HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_INIT);
<>	144:ef7eb2e8f9f7	2855
<>	144:ef7eb2e8f9f7	2856	b0addr = (uint32_t)blockb0;
<>	144:ef7eb2e8f9f7	2857	/* Write the blockb0 block in the IN FIFO */
<>	144:ef7eb2e8f9f7	2858	hcryp->Instance->DR = (uint32_t)(b0addr);
<>	144:ef7eb2e8f9f7	2859	b0addr+=4U;
<>	144:ef7eb2e8f9f7	2860	hcryp->Instance->DR = (uint32_t)(b0addr);
<>	144:ef7eb2e8f9f7	2861	b0addr+=4U;
<>	144:ef7eb2e8f9f7	2862	hcryp->Instance->DR = (uint32_t)(b0addr);
<>	144:ef7eb2e8f9f7	2863	b0addr+=4U;
<>	144:ef7eb2e8f9f7	2864	hcryp->Instance->DR = (uint32_t)(b0addr);
<>	144:ef7eb2e8f9f7	2865
<>	144:ef7eb2e8f9f7	2866	/* Enable the CRYP peripheral */
<>	144:ef7eb2e8f9f7	2867	__HAL_CRYP_ENABLE(hcryp);
<>	144:ef7eb2e8f9f7	2868
<>	144:ef7eb2e8f9f7	2869	/* Get tick */
<>	144:ef7eb2e8f9f7	2870	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	2871
<>	144:ef7eb2e8f9f7	2872	while((CRYP->CR & CRYP_CR_CRYPEN) == CRYP_CR_CRYPEN)
<>	144:ef7eb2e8f9f7	2873	{
<>	144:ef7eb2e8f9f7	2874	/* Check for the Timeout */
<>	144:ef7eb2e8f9f7	2875
<>	144:ef7eb2e8f9f7	2876	if((HAL_GetTick() - tickstart ) > CRYPEx_TIMEOUT_VALUE)
<>	144:ef7eb2e8f9f7	2877	{
<>	144:ef7eb2e8f9f7	2878	/* Change state */
<>	144:ef7eb2e8f9f7	2879	hcryp->State = HAL_CRYP_STATE_TIMEOUT;
<>	144:ef7eb2e8f9f7	2880
<>	144:ef7eb2e8f9f7	2881	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	2882	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	2883
<>	144:ef7eb2e8f9f7	2884	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	2885
<>	144:ef7eb2e8f9f7	2886	}
<>	144:ef7eb2e8f9f7	2887	}
<>	144:ef7eb2e8f9f7	2888	/*************************** Header phase ***************************/
<>	144:ef7eb2e8f9f7	2889	if(headersize != 0U)
<>	144:ef7eb2e8f9f7	2890	{
<>	144:ef7eb2e8f9f7	2891	/* Select header phase */
<>	144:ef7eb2e8f9f7	2892	__HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_HEADER);
<>	144:ef7eb2e8f9f7	2893
<>	144:ef7eb2e8f9f7	2894	/* Enable Crypto processor */
<>	144:ef7eb2e8f9f7	2895	__HAL_CRYP_ENABLE(hcryp);
<>	144:ef7eb2e8f9f7	2896
<>	144:ef7eb2e8f9f7	2897	for(loopcounter = 0U; (loopcounter < headersize); loopcounter+=16U)
<>	144:ef7eb2e8f9f7	2898	{
<>	144:ef7eb2e8f9f7	2899	/* Get tick */
<>	144:ef7eb2e8f9f7	2900	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	2901
<>	144:ef7eb2e8f9f7	2902	while(HAL_IS_BIT_CLR(hcryp->Instance->SR, CRYP_FLAG_IFEM))
<>	144:ef7eb2e8f9f7	2903	{
<>	144:ef7eb2e8f9f7	2904	/* Check for the Timeout */
<>	144:ef7eb2e8f9f7	2905	if((HAL_GetTick() - tickstart ) > CRYPEx_TIMEOUT_VALUE)
<>	144:ef7eb2e8f9f7	2906	{
<>	144:ef7eb2e8f9f7	2907	/* Change state */
<>	144:ef7eb2e8f9f7	2908	hcryp->State = HAL_CRYP_STATE_TIMEOUT;
<>	144:ef7eb2e8f9f7	2909
<>	144:ef7eb2e8f9f7	2910	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	2911	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	2912
<>	144:ef7eb2e8f9f7	2913	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	2914	}
<>	144:ef7eb2e8f9f7	2915	}
<>	144:ef7eb2e8f9f7	2916	/* Write the header block in the IN FIFO */
<>	144:ef7eb2e8f9f7	2917	hcryp->Instance->DR = (uint32_t)(headeraddr);
<>	144:ef7eb2e8f9f7	2918	headeraddr+=4U;
<>	144:ef7eb2e8f9f7	2919	hcryp->Instance->DR = (uint32_t)(headeraddr);
<>	144:ef7eb2e8f9f7	2920	headeraddr+=4U;
<>	144:ef7eb2e8f9f7	2921	hcryp->Instance->DR = (uint32_t)(headeraddr);
<>	144:ef7eb2e8f9f7	2922	headeraddr+=4U;
<>	144:ef7eb2e8f9f7	2923	hcryp->Instance->DR = (uint32_t)(headeraddr);
<>	144:ef7eb2e8f9f7	2924	headeraddr+=4U;
<>	144:ef7eb2e8f9f7	2925	}
<>	144:ef7eb2e8f9f7	2926
<>	144:ef7eb2e8f9f7	2927	/* Get tick */
<>	144:ef7eb2e8f9f7	2928	tickstart = HAL_GetTick();
<>	144:ef7eb2e8f9f7	2929
<>	144:ef7eb2e8f9f7	2930	while((hcryp->Instance->SR & CRYP_FLAG_BUSY) == CRYP_FLAG_BUSY)
<>	144:ef7eb2e8f9f7	2931	{
<>	144:ef7eb2e8f9f7	2932	/* Check for the Timeout */
<>	144:ef7eb2e8f9f7	2933	if((HAL_GetTick() - tickstart ) > CRYPEx_TIMEOUT_VALUE)
<>	144:ef7eb2e8f9f7	2934	{
<>	144:ef7eb2e8f9f7	2935	/* Change state */
<>	144:ef7eb2e8f9f7	2936	hcryp->State = HAL_CRYP_STATE_TIMEOUT;
<>	144:ef7eb2e8f9f7	2937
<>	144:ef7eb2e8f9f7	2938	/* Process Unlocked */
<>	144:ef7eb2e8f9f7	2939	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	2940
<>	144:ef7eb2e8f9f7	2941	return HAL_TIMEOUT;
<>	144:ef7eb2e8f9f7	2942	}
<>	144:ef7eb2e8f9f7	2943	}
<>	144:ef7eb2e8f9f7	2944	}
<>	144:ef7eb2e8f9f7	2945	/* Save formatted counter into the scratch buffer pScratch */
<>	144:ef7eb2e8f9f7	2946	for(loopcounter = 0U; (loopcounter < 16U); loopcounter++)
<>	144:ef7eb2e8f9f7	2947	{
<>	144:ef7eb2e8f9f7	2948	hcryp->Init.pScratch[loopcounter] = ctr[loopcounter];
<>	144:ef7eb2e8f9f7	2949	}
<>	144:ef7eb2e8f9f7	2950	/* Reset bit 0 */
<>	144:ef7eb2e8f9f7	2951	hcryp->Init.pScratch[15U] &= 0xFEU;
<>	144:ef7eb2e8f9f7	2952	/* Select payload phase once the header phase is performed */
<>	144:ef7eb2e8f9f7	2953	__HAL_CRYP_SET_PHASE(hcryp, CRYP_PHASE_PAYLOAD);
<>	144:ef7eb2e8f9f7	2954
<>	144:ef7eb2e8f9f7	2955	/* Flush FIFO */
<>	144:ef7eb2e8f9f7	2956	__HAL_CRYP_FIFO_FLUSH(hcryp);
<>	144:ef7eb2e8f9f7	2957
<>	144:ef7eb2e8f9f7	2958	/* Set the phase */
<>	144:ef7eb2e8f9f7	2959	hcryp->Phase = HAL_CRYP_PHASE_PROCESS;
<>	144:ef7eb2e8f9f7	2960	}
<>	144:ef7eb2e8f9f7	2961	/* Set the input and output addresses and start DMA transfer */
<>	144:ef7eb2e8f9f7	2962	CRYPEx_GCMCCM_SetDMAConfig(hcryp, inputaddr, Size, outputaddr);
<>	144:ef7eb2e8f9f7	2963
<>	144:ef7eb2e8f9f7	2964	/* Unlock process */
<>	144:ef7eb2e8f9f7	2965	__HAL_UNLOCK(hcryp);
<>	144:ef7eb2e8f9f7	2966
<>	144:ef7eb2e8f9f7	2967	/* Return function status */
<>	144:ef7eb2e8f9f7	2968	return HAL_OK;
<>	144:ef7eb2e8f9f7	2969	}
<>	144:ef7eb2e8f9f7	2970	else
<>	144:ef7eb2e8f9f7	2971	{
<>	144:ef7eb2e8f9f7	2972	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	2973	}
<>	144:ef7eb2e8f9f7	2974	}
<>	144:ef7eb2e8f9f7	2975
<>	144:ef7eb2e8f9f7	2976	/**
<>	144:ef7eb2e8f9f7	2977	* @}
<>	144:ef7eb2e8f9f7	2978	*/
<>	144:ef7eb2e8f9f7	2979
<>	144:ef7eb2e8f9f7	2980	/** @defgroup CRYPEx_Exported_Functions_Group2 CRYPEx IRQ handler management
<>	144:ef7eb2e8f9f7	2981	* @brief CRYPEx IRQ handler.
<>	144:ef7eb2e8f9f7	2982	*
<>	144:ef7eb2e8f9f7	2983	@verbatim
<>	144:ef7eb2e8f9f7	2984	==============================================================================
<>	144:ef7eb2e8f9f7	2985	##### CRYPEx IRQ handler management #####
<>	144:ef7eb2e8f9f7	2986	==============================================================================
<>	144:ef7eb2e8f9f7	2987	[..] This section provides CRYPEx IRQ handler function.
<>	144:ef7eb2e8f9f7	2988
<>	144:ef7eb2e8f9f7	2989	@endverbatim
<>	144:ef7eb2e8f9f7	2990	* @{
<>	144:ef7eb2e8f9f7	2991	*/
<>	144:ef7eb2e8f9f7	2992
<>	144:ef7eb2e8f9f7	2993	/**
<>	144:ef7eb2e8f9f7	2994	* @brief This function handles CRYPEx interrupt request.
<>	144:ef7eb2e8f9f7	2995	* @param hcryp: pointer to a CRYPEx_HandleTypeDef structure that contains
<>	144:ef7eb2e8f9f7	2996	* the configuration information for CRYP module
<>	144:ef7eb2e8f9f7	2997	* @retval None
<>	144:ef7eb2e8f9f7	2998	*/
<>	144:ef7eb2e8f9f7	2999
<>	144:ef7eb2e8f9f7	3000	void HAL_CRYPEx_GCMCCM_IRQHandler(CRYP_HandleTypeDef *hcryp)
<>	144:ef7eb2e8f9f7	3001	{
<>	144:ef7eb2e8f9f7	3002	switch(CRYP->CR & CRYP_CR_ALGOMODE_DIRECTION)
<>	144:ef7eb2e8f9f7	3003	{
<>	144:ef7eb2e8f9f7	3004	case CRYP_CR_ALGOMODE_AES_GCM_ENCRYPT:
<>	144:ef7eb2e8f9f7	3005	HAL_CRYPEx_AESGCM_Encrypt_IT(hcryp, NULL, 0U, NULL);
<>	144:ef7eb2e8f9f7	3006	break;
<>	144:ef7eb2e8f9f7	3007
<>	144:ef7eb2e8f9f7	3008	case CRYP_CR_ALGOMODE_AES_GCM_DECRYPT:
<>	144:ef7eb2e8f9f7	3009	HAL_CRYPEx_AESGCM_Decrypt_IT(hcryp, NULL, 0U, NULL);
<>	144:ef7eb2e8f9f7	3010	break;
<>	144:ef7eb2e8f9f7	3011
<>	144:ef7eb2e8f9f7	3012	case CRYP_CR_ALGOMODE_AES_CCM_ENCRYPT:
<>	144:ef7eb2e8f9f7	3013	HAL_CRYPEx_AESCCM_Encrypt_IT(hcryp, NULL, 0U, NULL);
<>	144:ef7eb2e8f9f7	3014	break;
<>	144:ef7eb2e8f9f7	3015
<>	144:ef7eb2e8f9f7	3016	case CRYP_CR_ALGOMODE_AES_CCM_DECRYPT:
<>	144:ef7eb2e8f9f7	3017	HAL_CRYPEx_AESCCM_Decrypt_IT(hcryp, NULL, 0U, NULL);
<>	144:ef7eb2e8f9f7	3018	break;
<>	144:ef7eb2e8f9f7	3019
<>	144:ef7eb2e8f9f7	3020	default:
<>	144:ef7eb2e8f9f7	3021	break;
<>	144:ef7eb2e8f9f7	3022	}
<>	144:ef7eb2e8f9f7	3023	}
<>	144:ef7eb2e8f9f7	3024
<>	144:ef7eb2e8f9f7	3025	/**
<>	144:ef7eb2e8f9f7	3026	* @}
<>	144:ef7eb2e8f9f7	3027	*/
<>	144:ef7eb2e8f9f7	3028
<>	144:ef7eb2e8f9f7	3029	/**
<>	144:ef7eb2e8f9f7	3030	* @}
<>	144:ef7eb2e8f9f7	3031	*/
<>	144:ef7eb2e8f9f7	3032	#endif /* STM32F437xx \|\| STM32F439xx \|\| STM32F479xx */
<>	144:ef7eb2e8f9f7	3033
<>	144:ef7eb2e8f9f7	3034	#endif /* HAL_CRYP_MODULE_ENABLED */
<>	144:ef7eb2e8f9f7	3035	/**
<>	144:ef7eb2e8f9f7	3036	* @}
<>	144:ef7eb2e8f9f7	3037	*/
<>	144:ef7eb2e8f9f7	3038
<>	144:ef7eb2e8f9f7	3039	/**
<>	144:ef7eb2e8f9f7	3040	* @}
<>	144:ef7eb2e8f9f7	3041	*/
<>	144:ef7eb2e8f9f7	3042
<>	144:ef7eb2e8f9f7	3043	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/

Repository toolbox

Repository details

Type:	Library
Created:	03 Nov 2016
Imports:	2
Forks:	0
Commits:	151
Dependents:	0
Dependencies:	0
Followers:	1

Important changes to repositories hosted on mbed.com

targets/cmsis/TARGET_STM/TARGET_STM32F4/stm32f4xx_hal_cryp_ex.c@144:ef7eb2e8f9f7, 2016-09-02 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Important changes to repositories hosted on mbed.com

targets/cmsis/TARGET_STM/TARGET_STM32F4/stm32f4xx_hal_cryp_ex.c@144:ef7eb2e8f9f7, 2016-09-02 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning