mbed-dev - mbed library sources. Supersedes mbed-src.

Users » mbed_official » Code » mbed-dev

mbed library sources. Supersedes mbed-src.

Dependents: Nucleo_Hello_Encoder BLE_iBeaconScan AM1805_DEMO DISCO-F429ZI_ExportTemplate1 ... more

targets/TARGET_STM/TARGET_STM32F2/device/stm32f2xx_hal_cryp.c@189:f392fc9709a3, 2019-02-20 (annotated)

Committer:: AnnaBridge
Date:: Wed Feb 20 22:31:08 2019 +0000
Revision:: 189:f392fc9709a3
Parent:: 167:e84263d55307

mbed library release version 165

Who changed what in which revision?

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