mbed-modifed - Modified version of the mbed library for use with…

Flotsam » Code » mbed-modifed

Flotsam / mbed-modifed

Modified version of the mbed library for use with the Nucleo boards.

Dependents: EEPROMWrite Full-Project

Fork of mbed-src by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32F4/stm32f4xx_hal_cryp.c@613:bc40b8d2aec4, 2015-08-20 (annotated)

Committer:: mbed_official
Date:: Thu Aug 20 10:45:13 2015 +0100
Revision:: 613:bc40b8d2aec4
Parent:: 532:fe11edbda85c

Synchronized with git revision 92ca8c7b60a283b6bb60eb65b183dac1599f0ade

Full URL: https://github.com/mbedmicro/mbed/commit/92ca8c7b60a283b6bb60eb65b183dac1599f0ade/

Nordic: update application start address in GCC linker script

Who changed what in which revision?

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

Repository toolbox

Export to desktop IDE

Repository details

Type:	Library
Created:	02 Nov 2015
Imports:	14
Forks:	0
Commits:	637
Dependents:	2
Dependencies:	0
Followers:	5

targets/cmsis/TARGET_STM/TARGET_STM32F4/stm32f4xx_hal_cryp.c@613:bc40b8d2aec4, 2015-08-20 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning