stm32f4xx_hal_cryp.h

Go to the documentation of this file.

 
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __STM32F4xx_HAL_CRYP_H
#define __STM32F4xx_HAL_CRYP_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
 
/* Includes ------------------------------------------------------------------*/
#include "stm32f4xx_hal_def.h"
 
#if defined (AES)  || defined (CRYP)
/* Exported types ------------------------------------------------------------*/
 
typedef struct
{
  uint32_t DataType;                   
  uint32_t KeySize;                    
  uint32_t *pKey;                      
  uint32_t *pInitVect;                 
  uint32_t Algorithm;                  
  uint32_t *Header;                    
  uint32_t HeaderSize;                
  uint32_t *B0;                       
  uint32_t DataWidthUnit;              
  uint32_t HeaderWidthUnit;            
  uint32_t KeyIVConfigSkip;            
} CRYP_ConfigTypeDef;
 
 
typedef enum
{
  HAL_CRYP_STATE_RESET             = 0x00U,  
  HAL_CRYP_STATE_READY             = 0x01U,  
  HAL_CRYP_STATE_BUSY              = 0x02U  
} HAL_CRYP_STATETypeDef;
 
 
typedef struct __CRYP_HandleTypeDef
{
#if defined (CRYP)
  CRYP_TypeDef                      *Instance;            
#else /* AES*/
  AES_TypeDef                       *Instance;            
#endif /* End AES or CRYP */
 
  CRYP_ConfigTypeDef                Init;             
  FunctionalState                   AutoKeyDerivation;   
  uint32_t                          *pCrypInBuffPtr;  
  uint32_t                          *pCrypOutBuffPtr; 
  __IO uint16_t                     CrypHeaderCount;   
  __IO uint16_t                     CrypInCount;      
  __IO uint16_t                     CrypOutCount;     
  uint16_t                          Size;           
  uint32_t                          Phase;            
  DMA_HandleTypeDef                 *hdmain;          
  DMA_HandleTypeDef                 *hdmaout;         
  HAL_LockTypeDef                   Lock;             
  __IO  HAL_CRYP_STATETypeDef       State;            
  __IO uint32_t                     ErrorCode;        
  uint32_t                          KeyIVConfig;      
  uint32_t                          SizesSum;         
#if (USE_HAL_CRYP_REGISTER_CALLBACKS == 1)
  void (*InCpltCallback)(struct __CRYP_HandleTypeDef *hcryp);      
  void (*OutCpltCallback)(struct __CRYP_HandleTypeDef *hcryp);     
  void (*ErrorCallback)(struct __CRYP_HandleTypeDef *hcryp);       
  void (* MspInitCallback)(struct __CRYP_HandleTypeDef *hcryp);    
  void (* MspDeInitCallback)(struct __CRYP_HandleTypeDef *hcryp);  
#endif /* (USE_HAL_CRYP_REGISTER_CALLBACKS) */
} CRYP_HandleTypeDef;
 
 
#if (USE_HAL_CRYP_REGISTER_CALLBACKS == 1)
typedef enum
{
  HAL_CRYP_INPUT_COMPLETE_CB_ID    = 0x01U,    
  HAL_CRYP_OUTPUT_COMPLETE_CB_ID   = 0x02U,    
  HAL_CRYP_ERROR_CB_ID             = 0x03U,    
  HAL_CRYP_MSPINIT_CB_ID        = 0x04U,    
  HAL_CRYP_MSPDEINIT_CB_ID      = 0x05U     
} HAL_CRYP_CallbackIDTypeDef;
typedef  void (*pCRYP_CallbackTypeDef)(CRYP_HandleTypeDef *hcryp);    
#endif /* USE_HAL_CRYP_REGISTER_CALLBACKS */
 
/* Exported constants --------------------------------------------------------*/
#define HAL_CRYP_ERROR_NONE              0x00000000U  
#define HAL_CRYP_ERROR_WRITE             0x00000001U  
#define HAL_CRYP_ERROR_READ              0x00000002U  
#define HAL_CRYP_ERROR_DMA               0x00000004U  
#define HAL_CRYP_ERROR_BUSY              0x00000008U  
#define HAL_CRYP_ERROR_TIMEOUT           0x00000010U  
#define HAL_CRYP_ERROR_NOT_SUPPORTED     0x00000020U  
#define HAL_CRYP_ERROR_AUTH_TAG_SEQUENCE 0x00000040U  
#if (USE_HAL_CRYP_REGISTER_CALLBACKS == 1)
#define  HAL_CRYP_ERROR_INVALID_CALLBACK ((uint32_t)0x00000080U)    
#endif /* USE_HAL_CRYP_REGISTER_CALLBACKS */
#define CRYP_DATAWIDTHUNIT_WORD   0x00000000U  
#define CRYP_DATAWIDTHUNIT_BYTE   0x00000001U  
#define CRYP_HEADERWIDTHUNIT_WORD   0x00000000U  
#define CRYP_HEADERWIDTHUNIT_BYTE   0x00000001U  
#if defined(CRYP)
 
#define CRYP_DES_ECB     CRYP_CR_ALGOMODE_DES_ECB
#define CRYP_DES_CBC     CRYP_CR_ALGOMODE_DES_CBC
#define CRYP_TDES_ECB    CRYP_CR_ALGOMODE_TDES_ECB
#define CRYP_TDES_CBC    CRYP_CR_ALGOMODE_TDES_CBC
#define CRYP_AES_ECB     CRYP_CR_ALGOMODE_AES_ECB
#define CRYP_AES_CBC     CRYP_CR_ALGOMODE_AES_CBC
#define CRYP_AES_CTR     CRYP_CR_ALGOMODE_AES_CTR
#if defined (CRYP_CR_ALGOMODE_AES_GCM)
#define CRYP_AES_GCM     CRYP_CR_ALGOMODE_AES_GCM
#define CRYP_AES_CCM     CRYP_CR_ALGOMODE_AES_CCM
#endif /* GCM CCM defined*/
#else /* AES*/
#define CRYP_AES_ECB            0x00000000U                       
#define CRYP_AES_CBC            AES_CR_CHMOD_0                    
#define CRYP_AES_CTR            AES_CR_CHMOD_1                    
#define CRYP_AES_GCM_GMAC       (AES_CR_CHMOD_0 | AES_CR_CHMOD_1) 
#define CRYP_AES_CCM            AES_CR_CHMOD_2                    
#endif /* End AES or CRYP */
 
#if defined(CRYP)
#define CRYP_KEYSIZE_128B         0x00000000U
#define CRYP_KEYSIZE_192B         CRYP_CR_KEYSIZE_0
#define CRYP_KEYSIZE_256B         CRYP_CR_KEYSIZE_1
#else /* AES*/
#define CRYP_KEYSIZE_128B         0x00000000U          
#define CRYP_KEYSIZE_256B         AES_CR_KEYSIZE       
#endif /* End AES or CRYP */
#if defined(CRYP)
#define CRYP_DATATYPE_32B         0x00000000U
#define CRYP_DATATYPE_16B         CRYP_CR_DATATYPE_0
#define CRYP_DATATYPE_8B          CRYP_CR_DATATYPE_1
#define CRYP_DATATYPE_1B          CRYP_CR_DATATYPE
#else /* AES*/
#define CRYP_DATATYPE_32B         0x00000000U  
#define CRYP_DATATYPE_16B         AES_CR_DATATYPE_0       
#define CRYP_DATATYPE_8B          AES_CR_DATATYPE_1       
#define CRYP_DATATYPE_1B          AES_CR_DATATYPE         
#endif /* End AES or CRYP */
 
#if defined (CRYP)
#define CRYP_IT_INI       CRYP_IMSCR_INIM   
#define CRYP_IT_OUTI      CRYP_IMSCR_OUTIM  
#else /* AES*/
#define CRYP_IT_CCFIE     AES_CR_CCFIE 
#define CRYP_IT_ERRIE     AES_CR_ERRIE 
#define CRYP_IT_WRERR     AES_SR_WRERR  
#define CRYP_IT_RDERR     AES_SR_RDERR  
#define CRYP_IT_CCF       AES_SR_CCF    
#endif /* End AES or CRYP */
 
#if defined (CRYP)
/* Flags in the SR register */
#define CRYP_FLAG_IFEM    CRYP_SR_IFEM  
#define CRYP_FLAG_IFNF    CRYP_SR_IFNF  
#define CRYP_FLAG_OFNE    CRYP_SR_OFNE  
#define CRYP_FLAG_OFFU    CRYP_SR_OFFU  
#define CRYP_FLAG_BUSY    CRYP_SR_BUSY  
/* Flags in the RISR register */
#define CRYP_FLAG_OUTRIS  0x01000002U  
#define CRYP_FLAG_INRIS   0x01000001U  
#else /* AES*/
/* status flags */
#define CRYP_FLAG_BUSY    AES_SR_BUSY   
#define CRYP_FLAG_WRERR   AES_SR_WRERR  
#define CRYP_FLAG_RDERR   AES_SR_RDERR  
#define CRYP_FLAG_CCF     AES_SR_CCF    
/* clearing flags */
#define CRYP_CCF_CLEAR    AES_CR_CCFC   
#define CRYP_ERR_CLEAR    AES_CR_ERRC   
#endif /* End AES or CRYP  */
 
#define CRYP_KEYIVCONFIG_ALWAYS        0x00000000U            
#define CRYP_KEYIVCONFIG_ONCE          0x00000001U            
/* Exported macros -----------------------------------------------------------*/
#if (USE_HAL_CRYP_REGISTER_CALLBACKS == 1)
#define __HAL_CRYP_RESET_HANDLE_STATE(__HANDLE__) do{\
                                                      (__HANDLE__)->State = HAL_CRYP_STATE_RESET;\
                                                      (__HANDLE__)->MspInitCallback = NULL;\
                                                      (__HANDLE__)->MspDeInitCallback = NULL;\
                                                     }while(0)
#else
#define __HAL_CRYP_RESET_HANDLE_STATE(__HANDLE__) ( (__HANDLE__)->State = HAL_CRYP_STATE_RESET)
#endif /* USE_HAL_CRYP_REGISTER_CALLBACKS */
 
#if defined(CRYP)
#define __HAL_CRYP_ENABLE(__HANDLE__)  ((__HANDLE__)->Instance->CR |=  CRYP_CR_CRYPEN)
#define __HAL_CRYP_DISABLE(__HANDLE__) ((__HANDLE__)->Instance->CR &=  ~CRYP_CR_CRYPEN)
#else /* AES*/
#define __HAL_CRYP_ENABLE(__HANDLE__)  ((__HANDLE__)->Instance->CR |=  AES_CR_EN)
#define __HAL_CRYP_DISABLE(__HANDLE__) ((__HANDLE__)->Instance->CR &=  ~AES_CR_EN)
#endif /* End AES or CRYP  */
 
#define CRYP_FLAG_MASK  0x0000001FU
#if defined(CRYP)
#define __HAL_CRYP_GET_FLAG(__HANDLE__, __FLAG__) ((((uint8_t)((__FLAG__) >> 24)) == 0x01U)?((((__HANDLE__)->Instance->RISR) & ((__FLAG__) & CRYP_FLAG_MASK)) == ((__FLAG__) & CRYP_FLAG_MASK)): \
                                                   ((((__HANDLE__)->Instance->RISR) & ((__FLAG__) & CRYP_FLAG_MASK)) == ((__FLAG__) & CRYP_FLAG_MASK)))
#else /* AES*/
#define __HAL_CRYP_GET_FLAG(__HANDLE__, __FLAG__) (((__HANDLE__)->Instance->SR & (__FLAG__)) == (__FLAG__))
#endif /* End AES or CRYP */
 
#if defined(AES)
#define __HAL_CRYP_CLEAR_FLAG(__HANDLE__, __FLAG__) SET_BIT((__HANDLE__)->Instance->CR, (__FLAG__))
 
 
#define __HAL_CRYP_GET_IT_SOURCE(__HANDLE__, __INTERRUPT__) (((__HANDLE__)->Instance->CR\
                                                              & (__INTERRUPT__)) == (__INTERRUPT__))
 
#endif /* AES */
 
#if defined(CRYP)
#define __HAL_CRYP_GET_IT(__HANDLE__, __INTERRUPT__) (((__HANDLE__)->Instance->MISR\
                                                       & (__INTERRUPT__)) == (__INTERRUPT__))
#else /* AES*/
#define __HAL_CRYP_GET_IT(__HANDLE__, __INTERRUPT__) (((__HANDLE__)->Instance->SR & (__INTERRUPT__)) == (__INTERRUPT__))
#endif /* End AES or CRYP */
 
#if defined(CRYP)
#define __HAL_CRYP_ENABLE_IT(__HANDLE__, __INTERRUPT__) (((__HANDLE__)->Instance->IMSCR) |= (__INTERRUPT__))
#else /* AES*/
#define __HAL_CRYP_ENABLE_IT(__HANDLE__, __INTERRUPT__) (((__HANDLE__)->Instance->CR) |= (__INTERRUPT__))
#endif /* End AES or CRYP */
 
#if defined(CRYP)
#define __HAL_CRYP_DISABLE_IT(__HANDLE__, __INTERRUPT__) (((__HANDLE__)->Instance->IMSCR) &= ~(__INTERRUPT__))
#else /* AES*/
#define __HAL_CRYP_DISABLE_IT(__HANDLE__, __INTERRUPT__) (((__HANDLE__)->Instance->CR) &= ~(__INTERRUPT__))
#endif /* End AES or CRYP */
 
#if defined (CRYP_CR_ALGOMODE_AES_GCM)|| defined (AES)
/* Include CRYP HAL Extended module */
#include "stm32f4xx_hal_cryp_ex.h"
#endif /* AES or GCM CCM defined*/
/* Exported functions --------------------------------------------------------*/
HAL_StatusTypeDef HAL_CRYP_Init(CRYP_HandleTypeDef *hcryp);
HAL_StatusTypeDef HAL_CRYP_DeInit(CRYP_HandleTypeDef *hcryp);
void HAL_CRYP_MspInit(CRYP_HandleTypeDef *hcryp);
void HAL_CRYP_MspDeInit(CRYP_HandleTypeDef *hcryp);
HAL_StatusTypeDef HAL_CRYP_SetConfig(CRYP_HandleTypeDef *hcryp, CRYP_ConfigTypeDef *pConf);
HAL_StatusTypeDef HAL_CRYP_GetConfig(CRYP_HandleTypeDef *hcryp, CRYP_ConfigTypeDef *pConf);
#if (USE_HAL_CRYP_REGISTER_CALLBACKS == 1)
HAL_StatusTypeDef HAL_CRYP_RegisterCallback(CRYP_HandleTypeDef *hcryp, HAL_CRYP_CallbackIDTypeDef CallbackID,
                                            pCRYP_CallbackTypeDef pCallback);
HAL_StatusTypeDef HAL_CRYP_UnRegisterCallback(CRYP_HandleTypeDef *hcryp, HAL_CRYP_CallbackIDTypeDef CallbackID);
#endif /* USE_HAL_CRYP_REGISTER_CALLBACKS */
/* encryption/decryption ***********************************/
HAL_StatusTypeDef HAL_CRYP_Encrypt(CRYP_HandleTypeDef *hcryp, uint32_t *Input, uint16_t Size, uint32_t *Output,
                                   uint32_t Timeout);
HAL_StatusTypeDef HAL_CRYP_Decrypt(CRYP_HandleTypeDef *hcryp, uint32_t *Input, uint16_t Size, uint32_t *Output,
                                   uint32_t Timeout);
HAL_StatusTypeDef HAL_CRYP_Encrypt_IT(CRYP_HandleTypeDef *hcryp, uint32_t *Input, uint16_t Size, uint32_t *Output);
HAL_StatusTypeDef HAL_CRYP_Decrypt_IT(CRYP_HandleTypeDef *hcryp, uint32_t *Input, uint16_t Size, uint32_t *Output);
HAL_StatusTypeDef HAL_CRYP_Encrypt_DMA(CRYP_HandleTypeDef *hcryp, uint32_t *Input, uint16_t Size, uint32_t *Output);
HAL_StatusTypeDef HAL_CRYP_Decrypt_DMA(CRYP_HandleTypeDef *hcryp, uint32_t *Input, uint16_t Size, uint32_t *Output);
 
/* Interrupt Handler functions  **********************************************/
void HAL_CRYP_IRQHandler(CRYP_HandleTypeDef *hcryp);
HAL_CRYP_STATETypeDef HAL_CRYP_GetState(CRYP_HandleTypeDef *hcryp);
void HAL_CRYP_InCpltCallback(CRYP_HandleTypeDef *hcryp);
void HAL_CRYP_OutCpltCallback(CRYP_HandleTypeDef *hcryp);
void HAL_CRYP_ErrorCallback(CRYP_HandleTypeDef *hcryp);
uint32_t HAL_CRYP_GetError(CRYP_HandleTypeDef *hcryp);
 
/* Private macros --------------------------------------------------------*/
#if defined(CRYP)
#if defined (CRYP_CR_ALGOMODE_AES_GCM)
#define IS_CRYP_ALGORITHM(ALGORITHM) (((ALGORITHM) == CRYP_DES_ECB)   || \
                                      ((ALGORITHM)  == CRYP_DES_CBC)   || \
                                      ((ALGORITHM)  == CRYP_TDES_ECB)  || \
                                      ((ALGORITHM)  == CRYP_TDES_CBC)  || \
                                      ((ALGORITHM)  == CRYP_AES_ECB)   || \
                                      ((ALGORITHM)  == CRYP_AES_CBC)   || \
                                      ((ALGORITHM)  == CRYP_AES_CTR)   || \
                                      ((ALGORITHM)  == CRYP_AES_GCM)   || \
                                      ((ALGORITHM)  == CRYP_AES_CCM))
#else /*NO GCM CCM */
#define IS_CRYP_ALGORITHM(ALGORITHM) (((ALGORITHM) == CRYP_DES_ECB)   || \
                                      ((ALGORITHM)  == CRYP_DES_CBC)   || \
                                      ((ALGORITHM)  == CRYP_TDES_ECB)  || \
                                      ((ALGORITHM)  == CRYP_TDES_CBC)  || \
                                      ((ALGORITHM)  == CRYP_AES_ECB)   || \
                                      ((ALGORITHM)  == CRYP_AES_CBC)   || \
                                      ((ALGORITHM)  == CRYP_AES_CTR))
#endif /* GCM CCM defined*/
#define IS_CRYP_KEYSIZE(KEYSIZE)(((KEYSIZE) == CRYP_KEYSIZE_128B)   || \
                                 ((KEYSIZE) == CRYP_KEYSIZE_192B)   || \
                                 ((KEYSIZE) == CRYP_KEYSIZE_256B))
#else /* AES*/
#define IS_CRYP_ALGORITHM(ALGORITHM) (((ALGORITHM) == CRYP_AES_ECB)   || \
                                      ((ALGORITHM)  == CRYP_AES_CBC)   || \
                                      ((ALGORITHM)  == CRYP_AES_CTR)  || \
                                      ((ALGORITHM)  == CRYP_AES_GCM_GMAC)|| \
                                      ((ALGORITHM)  == CRYP_AES_CCM))
 
 
#define IS_CRYP_KEYSIZE(KEYSIZE)(((KEYSIZE) == CRYP_KEYSIZE_128B)   || \
                                 ((KEYSIZE) == CRYP_KEYSIZE_256B))
#endif /* End AES or CRYP */
 
#define IS_CRYP_DATATYPE(DATATYPE)(((DATATYPE) == CRYP_DATATYPE_32B)   || \
                                   ((DATATYPE) == CRYP_DATATYPE_16B) || \
                                   ((DATATYPE) == CRYP_DATATYPE_8B) || \
                                   ((DATATYPE) == CRYP_DATATYPE_1B))
 
#define IS_CRYP_INIT(CONFIG)(((CONFIG) == CRYP_KEYIVCONFIG_ALWAYS) || \
                             ((CONFIG) == CRYP_KEYIVCONFIG_ONCE))
/* Private constants ---------------------------------------------------------*/
/* Private defines -----------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* Private functions prototypes ----------------------------------------------*/
/* Private functions ---------------------------------------------------------*/
#endif /* TinyAES or CRYP*/
 
#ifdef __cplusplus
}
#endif
 
#endif /* __STM32F4xx_HAL_CRYP_H */