hpm_sdp_drv.h

Go to the documentation of this file.

/*
 * Copyright (c) 2021-2023 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, 
#if defined(SDP_HAS_SM4_SUPPORT) && (SDP_HAS_SM4_SUPPORT == 1)
    sdp_crypto_alg_sm4, 
#endif
} sdp_crypto_alg_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),      
};
 
#ifdef __cplusplus
extern "C"
{
#endif
 
 
/***********************************************************************************************************************
 * Prototypes
 **********************************************************************************************************************/
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);
 
#ifdef __cplusplus
}
#endif
 
#endif /* HPM_SDP_DRV_H */