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@147:ba84b7dc41a7, 2016-09-10 (annotated)

Committer:: JojoS
Date:: Sat Sep 10 15:32:04 2016 +0000
Revision:: 147:ba84b7dc41a7
Parent:: 144:ef7eb2e8f9f7

added prescaler for 16 bit timers (solution as in LPC11xx), default prescaler 31 for max 28 ms period time

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@147:ba84b7dc41a7, 2016-09-10 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning