mbed-dev - added prescaler for 16 bit pwm in LPC1347 target

Users » JojoS » Code » mbed-dev

added prescaler for 16 bit pwm in LPC1347 target

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

Committer:: <>
Date:: Fri Sep 02 15:07:44 2016 +0100
Revision:: 144:ef7eb2e8f9f7
Parent:: 83:a036322b8637

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

Repository toolbox

Export to desktop IDE

Repository details

Type:	Library
Created:	10 Sep 2016
Imports:	1
Forks:	0
Commits:	148
Dependents:	0
Dependencies:	0
Followers:	1

targets/cmsis/TARGET_STM/TARGET_STM32F7/stm32f7xx_hal_cryp.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