hpm_sdp_drv.h

Go to the documentation of this file.

/*
 * Copyright (c) 2021-2024 HPMicro
 *
 * SPDX-License-Identifier: BSD-3-Clause
 *
 */
 
#ifndef HPM_SDP_DRV_H
#define HPM_SDP_DRV_H
 
#include "hpm_common.h"
#include "hpm_sdp_regs.h"
#include "hpm_soc_feature.h"
 
/***********************************************************************************************************************
 * Definitions
 **********************************************************************************************************************/
typedef enum {
    sdp_aes_keybits_128 = 0,                    
    sdp_aes_keybits_256 = 1,                    
#if defined(SDP_HAS_SM4_SUPPORT) && (SDP_HAS_SM4_SUPPORT == 1)
    sdp_sm4_keybits_128 = sdp_aes_keybits_128, /* SM4 Key bits */
#endif
} sdp_crypto_key_bits_t;
 
typedef sdp_crypto_key_bits_t sdp_aes_key_bits_t;
 
typedef sdp_crypto_key_bits_t sdp_sm4_key_bits_t;
 
typedef enum {
    sdp_aes_op_encrypt,                         
    sdp_aes_op_decrypt,                         
#if defined(SDP_HAS_SM4_SUPPORT) && (SDP_HAS_SM4_SUPPORT == 1)
    sdp_sm4_op_encrypt = sdp_aes_op_encrypt,    
    sdp_sm4_op_decrypt = sdp_aes_op_decrypt,    
#endif
} sdp_crypto_op_t;
 
typedef sdp_crypto_op_t sdp_aes_op_t;
 
#if defined(SDP_HAS_SM4_SUPPORT) && (SDP_HAS_SM4_SUPPORT == 1)
 
typedef sdp_crypto_op_t sdp_sm4_op_t;
 
#endif
 
typedef enum {
    sdp_crypto_alg_aes = 0, 
#if defined(SDP_HAS_SM4_SUPPORT) && (SDP_HAS_SM4_SUPPORT == 1)
    sdp_crypto_alg_sm4 = 1, 
#endif
} sdp_crypto_alg_t;
 
typedef enum {
    sdp_crypto_mode_ecb = 0,    
    sdp_crypto_mode_cbc = 1,    
} sdp_crypto_mode_t;
 
typedef enum {
    sdp_swap_mode_none = 0,             
    sdp_swap_mode_bytes_in_word = 1,    
    sdp_swap_mode_word_swap = 2,        
    sdp_swap_mode_switch_endian = 3,    
} sdp_data_swap_mode_t;
 
typedef enum {
    sdp_calc_hash_for_input = 0,        
    sdp_calc_hash_for_output = 1,       
} sdp_calc_hash_mode_t;
 
 
typedef enum {
    sdp_hash_alg_sha1 = 0,                  
    sdp_hash_alg_crc32 = 1,                 
    sdp_hash_alg_sha256 = 2,                
#if defined(SDP_HAS_SM3_SUPPORT) && (SDP_HAS_SM3_SUPPORT == 1)
    sdp_hash_alg_sm3 = 8,                   
    sdp_hash_alg_max = sdp_hash_alg_sm3,
#else
    sdp_hash_alg_max = sdp_hash_alg_sha256,
#endif
} sdp_hash_alg_t;
 
#define HASH_BLOCK_SIZE (64U)               
#define AES_BLOCK_SIZE (16U)                
#define AES_128_KEY_SIZE (0x10U)            
#define AES_256_KEY_SIZE (0x20U)            
#define SM4_BLOCK_SIZE (AES_BLOCK_SIZE)     
#define SM4_KEY_SIZE (AES_128_KEY_SIZE)     
#define SDP_PKT_CTRL_DERSEMA_MASK (1U << 2)
#define SDP_PKT_CTRL_CHAIN_MASK (1U << 3)
#define SDP_PKT_CTRL_HASHINIT_MASK (1U << 4)
#define SDP_PKT_CTRL_HASHFINISH_MASK (1U << 5)
#define SDP_PKT_CTRL_CIPHIV_MASK (1U << 6)
 
typedef struct _sdp_packet_struct {
    struct _sdp_packet_struct *next_cmd;
    union {
        struct {
            uint32_t RESERVED0: 1;
            uint32_t PKTINT: 1;     
            uint32_t DCRSEMA: 1;    
            uint32_t CHAIN: 1;      
            uint32_t HASHINIT: 1;   
            uint32_t HASHFINISH: 1; 
            uint32_t CIPHIV: 1;     
            uint32_t RESERVED1: 17;
            uint32_t PKTTAG: 8; 
        };
        uint32_t PKT_CTRL; 
    } pkt_ctrl;
    uint32_t src_addr; 
    uint32_t dst_addr; 
    uint32_t buf_size; 
    uint32_t reserved[3];
} sdp_pkt_struct_t;
 
typedef struct {
    uint8_t key_idx;  
    uint8_t key_bits; 
    uint16_t crypto_algo;
    sdp_pkt_struct_t sdp_pkt;                         
    uint32_t buf0[AES_BLOCK_SIZE / sizeof(uint32_t)]; 
    uint32_t buf1[AES_BLOCK_SIZE / sizeof(uint32_t)]; 
    uint32_t buf2[AES_BLOCK_SIZE / sizeof(uint32_t)]; 
    uint32_t buf3[AES_BLOCK_SIZE / sizeof(uint32_t)]; 
} sdp_crypto_ctx_t;
 
typedef sdp_crypto_ctx_t sdp_aes_ctx_t;
 
#if defined(SDP_HAS_SM4_SUPPORT) && (SDP_HAS_SM4_SUPPORT == 1)
typedef sdp_crypto_ctx_t sdp_sm4_ctx_t;
#endif
 
typedef struct {
    sdp_pkt_struct_t sdp_pkt; 
} sdp_dma_ctx_t;
 
typedef struct {
    sdp_pkt_struct_t sdp_pkt; 
    uint32_t internal[64];    
} sdp_hash_ctx_t;
 
enum {
    status_sdp_no_crypto_support = MAKE_STATUS(status_group_sdp, 0), 
    status_sdp_no_hash_support = MAKE_STATUS(status_group_sdp, 1),   
    status_sdp_invalid_key_src = MAKE_STATUS(status_group_sdp, 2),   
    status_sdp_error_packet = MAKE_STATUS(status_group_sdp, 3),      
    status_sdp_aes_busy = MAKE_STATUS(status_group_sdp, 4),          
    status_sdp_hash_busy = MAKE_STATUS(status_group_sdp, 5),         
    status_sdp_error_setup = MAKE_STATUS(status_group_sdp, 6),       
    status_sdp_error_src = MAKE_STATUS(status_group_sdp, 7),         
    status_sdp_error_dst = MAKE_STATUS(status_group_sdp, 8),         
    status_sdp_error_hash = MAKE_STATUS(status_group_sdp, 9),        
    status_sdp_error_chain = MAKE_STATUS(status_group_sdp, 10),      
    status_sdp_error_invalid_mac = MAKE_STATUS(status_group_sdp, 11),
    status_sdp_invalid_alg = MAKE_STATUS(status_group_sdp, 12),      
};
 
typedef enum {
    sdp_op_invalid = 0,
    sdp_op_cipher_only = SDP_SDPCR_CIPHEN_MASK,
    sdp_op_hash_only = SDP_SDPCR_HASHEN_MASK,
    sdp_op_memcpy_only = SDP_SDPCR_MCPEN_MASK,
    sdp_op_memfill_only = SDP_SDPCR_CONFEN_MASK,
    sdp_op_cipher_hash = SDP_SDPCR_CIPHEN_MASK | SDP_SDPCR_HASHEN_MASK,
    sdp_op_copy_hash = SDP_SDPCR_MCPEN_MASK | SDP_SDPCR_HASHEN_MASK,
} sdp_operation_t;
 
typedef struct {
    sdp_operation_t op;                     
    sdp_data_swap_mode_t input_swap_mode;   
    sdp_data_swap_mode_t output_swap_mode;  
    struct {
        sdp_hash_alg_t hash_alg;            
        bool hash_check;                    
    };
    struct {
        sdp_crypto_alg_t crypto_alg;        
        sdp_crypto_mode_t crypto_mode;      
        uint16_t key_bits;                  
        uint8_t key_index;                  
        sdp_crypto_op_t crypto_op;          
        sdp_data_swap_mode_t key_swap_mode; 
        sdp_calc_hash_mode_t hash_mode;     
    };
} sdp_action_t;
 
 
#ifdef __cplusplus
extern "C"
{
#endif
 
 
/***********************************************************************************************************************
 * Prototypes
 **********************************************************************************************************************/
static inline void sdp_enable_interrupt(SDP_Type *base)
{
    base->SDPCR |= SDP_SDPCR_INTEN_MASK;
}
 
static inline void sdp_disable_interrupt(SDP_Type *base)
{
    base->SDPCR &= ~SDP_SDPCR_INTEN_MASK;
}
 
static inline void sdp_set_key_index(SDP_Type *base, uint32_t key_index)
{
    base->KEYADDR = SDP_KEYADDR_INDEX_SET(key_index);
}
 
static inline void sdp_write_key(SDP_Type *base, uint32_t key_index, uint32_t key_bits, const uint32_t *crypto_key)
{
    if (key_bits == 256) {
        uint32_t actual_key_index = key_index * 2;
        for (uint32_t i = 0; i < 2; i++) {
            sdp_set_key_index(base, actual_key_index++);
            for (uint32_t j = 0; j < 4; j++) {
                base->KEYDAT = *crypto_key++;
            }
        }
    } else {
        sdp_set_key_index(base, key_index);
        for (uint32_t j = 0; j < 4; j++) {
            base->KEYDAT = *crypto_key++;
        }
    }
}
 
static inline void sdp_write_hash_digest(SDP_Type *base, const uint32_t *digest, uint32_t num_words)
{
    for (uint32_t i = 0; i < num_words; i++) {
        base->HASWRD[i] = *digest++;
    }
}
 
static inline void sdp_get_hash_digest(SDP_Type *base, uint32_t *digest, uint32_t num_words)
{
    for (uint32_t i = 0; i < num_words; i++) {
        *digest++ = base->HASWRD[i];
    }
}
 
static inline void sdp_write_cipher_iv(SDP_Type *base, const uint32_t *iv)
{
    for (uint32_t i = 0; i < 4; i++) {
        base->CIPHIV[i] = *iv++;
    }
}
 
static inline void sdp_clear_status(SDP_Type *base, uint32_t mask)
{
    base->STA = mask;
}
 
static inline uint32_t sdp_get_status(SDP_Type *base)
{
    return base->STA;
}
 
hpm_stat_t sdp_init(SDP_Type *base);
 
hpm_stat_t sdp_deinit(SDP_Type *base);
 
hpm_stat_t sdp_aes_set_key(SDP_Type *base,
                           sdp_aes_ctx_t *aes_ctx,
                           const uint8_t *key,
                           sdp_aes_key_bits_t key_bits,
                           uint32_t key_idx);
 
#if defined(SDP_HAS_SM4_SUPPORT) && (SDP_HAS_SM4_SUPPORT == 1)
 
hpm_stat_t sdp_sm4_set_key(SDP_Type *base,
                           sdp_sm4_ctx_t *sm4_ctx,
                           const uint8_t *key,
                           sdp_sm4_key_bits_t key_bits,
                           uint32_t key_idx);
 
#endif
 
hpm_stat_t sdp_aes_crypt_ecb(SDP_Type *base,
                             sdp_aes_ctx_t *aes_ctx,
                             sdp_aes_op_t op,
                             uint32_t len,
                             const uint8_t *in,
                             uint8_t *out);
 
#if defined(SDP_HAS_SM4_SUPPORT) && (SDP_HAS_SM4_SUPPORT == 1)
#define sdp_sm4_crypt_ecb sdp_aes_crypt_ecb
#endif
 
hpm_stat_t sdp_aes_crypt_cbc(SDP_Type *base,
                             sdp_aes_ctx_t *aes_ctx,
                             sdp_aes_op_t op,
                             uint32_t length,
                             const uint8_t iv[16],
                             const uint8_t *input,
                             uint8_t *output);
 
#if defined(SDP_HAS_SM4_SUPPORT) && (SDP_HAS_SM4_SUPPORT == 1)
#define sdp_sm4_crypt_cbc sdp_aes_crypt_cbc
#endif
 
hpm_stat_t sdp_aes_crypt_ctr(SDP_Type *base,
                             sdp_aes_ctx_t *aes_ctx,
                             uint8_t *nonce_counter,
                             uint8_t *input,
                             uint8_t *output,
                             uint32_t length);
 
#if defined(SDP_HAS_SM4_SUPPORT) && (SDP_HAS_SM4_SUPPORT == 1)
#define sdp_sm4_crypt_ctr sdp_aes_crypt_ctr
#endif
 
hpm_stat_t sdp_aes_ccm_generate_encrypt(SDP_Type *base,
                                        sdp_aes_ctx_t *aes_ctx,
                                        uint32_t input_len,
                                        const uint8_t *iv,
                                        uint32_t iv_len,
                                        const uint8_t *aad,
                                        uint32_t aad_len,
                                        const uint8_t *input,
                                        uint8_t *output,
                                        uint8_t *tag,
                                        uint32_t tag_len);
 
#if defined(SDP_HAS_SM4_SUPPORT) && (SDP_HAS_SM4_SUPPORT == 1)
#define sdp_sm4_ccm_generate_encrypt sdp_aes_ccm_generate_encrypt
#endif
 
hpm_stat_t sdp_aes_ccm_decrypt_verify(SDP_Type *base,
                                      sdp_aes_ctx_t *aes_ctx,
                                      uint32_t input_len,
                                      const uint8_t *iv,
                                      uint32_t iv_len,
                                      const uint8_t *aad,
                                      uint32_t aad_len,
                                      const uint8_t *input,
                                      uint8_t *output,
                                      const uint8_t *tag,
                                      uint32_t tag_len);
 
#if defined(SDP_HAS_SM4_SUPPORT) && (SDP_HAS_SM4_SUPPORT == 1)
#define sdp_sm4_ccm_decrypt_verify sdp_aes_ccm_decrypt_verify
#endif
 
hpm_stat_t sdp_memcpy(SDP_Type *base, sdp_dma_ctx_t *sdp_ctx, void *dst, const void *src, uint32_t length);
 
hpm_stat_t sdp_memset(SDP_Type *base, sdp_dma_ctx_t *sdp_ctx, void *dst, uint8_t pattern, uint32_t length);
 
hpm_stat_t sdp_hash_init(SDP_Type *base, sdp_hash_ctx_t *hash_ctx, sdp_hash_alg_t alg);
 
hpm_stat_t sdp_hash_update(SDP_Type *base, sdp_hash_ctx_t *hash_ctx, const uint8_t *data, uint32_t length);
 
hpm_stat_t sdp_hash_finish(SDP_Type *base, sdp_hash_ctx_t *hash_ctx, uint8_t *digest);
 
hpm_stat_t sdp_wait_done(SDP_Type *base);
 
 
hpm_stat_t sdp_trigger_action(SDP_Type *base, const sdp_action_t *action, const sdp_pkt_struct_t *cmd_pkt);
 
#ifdef __cplusplus
}
#endif
 
#endif /* HPM_SDP_DRV_H */