hal_aes.h

#ifndef HAL_AES_H
#define HAL_AES_H

#include <stdint.h>
#include <stdbool.h>
#include "in_mmap.h"

/*
 ****************************************************************************************
 * DEFINES
 ****************************************************************************************
 */

#define      AES_DATA_BLOCK_OFFSET_INDEX                    0x0400
#define      AES_CONTEXT_BLOCK_OFFSET_INDEX                 0x0800
#define      AES_CONTEXT_MEMORY_BLOCK0_INDEX                0x0000
#define      AES_CONTEXT_MEMORY_BLOCK1_INDEX                0x0020
#define      AES_CONTEXT_MEMORY_BLOCK2_INDEX                0x0030
#define      AES_CONTEXT_MEMORY_BLOCK3_INDEX                0x0040
#define      AES_CONTEXT_MEMORY_BLOCK4_INDEX                0x0050

#define      AES_DATA_BASE                                  AES_REG_BASE + AES_DATA_BLOCK_OFFSET_INDEX
#define      AES_CONTEXT_BASE                               AES_REG_BASE + AES_CONTEXT_BLOCK_OFFSET_INDEX
#define      AES_CONTEXT_MEMORY_BLOCK0_BASE                 AES_CONTEXT_BASE + AES_CONTEXT_MEMORY_BLOCK0_INDEX
#define      AES_CONTEXT_MEMORY_BLOCK1_BASE                 AES_CONTEXT_BASE + AES_CONTEXT_MEMORY_BLOCK1_INDEX
#define      AES_CONTEXT_MEMORY_BLOCK2_BASE                 AES_CONTEXT_BASE + AES_CONTEXT_MEMORY_BLOCK2_INDEX
#define      AES_CONTEXT_MEMORY_BLOCK3_BASE                 AES_CONTEXT_BASE + AES_CONTEXT_MEMORY_BLOCK3_INDEX
#define      AES_CONTEXT_MEMORY_BLOCK4_BASE                 AES_CONTEXT_BASE + AES_CONTEXT_MEMORY_BLOCK4_INDEX

#define      AES_MESSAGE_MEM_SIZE                           (256)  //maximum message memory size

typedef enum {
    AES_ERR_OK = 0,                 
    AES_ERR_NOT_INIT = 1,           
    AES_ERR_ALREADY_INIT = 2,       
    AES_ERR_DEV_BAD_STATE = 3,      
    AES_ERR_MAC_DOES_NOT_MATCH = 4, 
    AES_ERR_HW_MEM_USED_BY_ECC = 5, 
    AES_ERR_NOT_ENOUGH_BUF = 6,
    AES_ERR_INVALID_PARAM = 7,
} aes_crypto_status;

typedef enum {
    AES_CRYPTO_TYPE_ENCRYPT = 1, 
    AES_CRYPTO_TYPE_DECRYPT = 0  
} aes_crypto_type ;

typedef enum {
    AES_CRYPTO_MODE_ECB = 0,   
    AES_CRYPTO_MODE_CBC = 1,   
    AES_CRYPTO_MODE_CTR = 2,   
    AES_CRYPTO_MODE_CCM = 3,   
    AES_CRYPTO_MODE_CMAC = 4,  
    AES_CRYPTO_MODE_XCBC = 6,  
    AES_CRYPTO_MODE_F8 = 9     
} aes_crypto_mode ;

typedef enum {
    AES_KEY_SIZE_128 = 0,  
    AES_KEY_SIZE_192 = 1,  
    AES_KEY_SIZE_256 = 2   
} aes_key_size ;

typedef struct {
    aes_crypto_mode mode;      
    aes_key_size key_size;     
    const uint8_t *key;        
    union {
        uint8_t *salt;         
        uint8_t *key2;         
    } u1;

    union {
        uint8_t *ctr_blk;      
        uint8_t *key3;         
        uint8_t *iv;           
    } u2;

    const uint8_t *mac;        
    uint8_t mac_length;        
    uint16_t total_msg_length; 
} aes_cfg_t;

static __inline void aes_set_misc_ctrl_go(void)
{
    uint32_t reg = RD_WORD(AES_REG_MISC_CTRL);
    reg |= AES_REG_MISC_CTRL_GO;
    WR_WORD(AES_REG_MISC_CTRL, reg);
}

static __inline void aes_clr_misc_ctrl_go(void)
{
    uint32_t reg = RD_WORD(AES_REG_MISC_CTRL);
    reg &= ~AES_REG_MISC_CTRL_GO;
    WR_WORD(AES_REG_MISC_CTRL, reg);
}

static __inline void aes_set_misc_ctrl(int mode, int key_size, uint8_t mac_length)
{
    uint32_t reg = RD_WORD(AES_REG_MISC_CTRL);

    reg &= ~(AES_REG_MISC_CTRL_MODE);
    reg |= ((mode & AES_REG_MISC_CTRL_MODE_MASK) << AES_REG_MISC_CTRL_MODE_SHIFT);

    reg &= ~(AES_REG_MISC_CTRL_KEY_SIZE);
    reg |= ((key_size & AES_REG_MISC_CTRL_KEY_SIZE_MASK) << AES_REG_MISC_CTRL_KEY_SIZE_SHIFT);

    reg &= ~(AES_REG_MISC_CTRL_MAC_LEN);
    if (mac_length == 16)
        mac_length = 0;
    reg |= ((mac_length & AES_REG_MISC_CTRL_MAC_LEN_MASK) << AES_REG_MISC_CTRL_MAC_LEN_SHIFT);

    WR_WORD(AES_REG_MISC_CTRL, reg);
}

static __inline void aes_set_misc_ctrl_type(aes_crypto_type type)
{
    uint32_t reg = RD_WORD(AES_REG_MISC_CTRL);
    if(type == AES_CRYPTO_TYPE_ENCRYPT)
        reg |= AES_REG_MISC_CTRL_ENCRYPT;
    else
        reg &= ~(AES_REG_MISC_CTRL_ENCRYPT);

    WR_WORD(AES_REG_MISC_CTRL, reg);
}

static __inline aes_crypto_type aes_get_misc_ctrl_type(void)
{
    uint32_t reg = ((RD_WORD(AES_REG_MISC_CTRL) & AES_REG_MISC_CTRL_ENCRYPT) >> 1);
    if(reg)
        return AES_CRYPTO_TYPE_ENCRYPT;
    else
        return AES_CRYPTO_TYPE_DECRYPT;
}

static __inline void aes_set_misc_ctrl_msg_begin(void)
{
    uint32_t reg = RD_WORD(AES_REG_MISC_CTRL);
    reg |= AES_REG_MISC_CTRL_MSG_BEGIN;
    WR_WORD(AES_REG_MISC_CTRL, reg);
}

static __inline void aes_clr_misc_ctrl_msg_begin(void)
{
    uint32_t reg = RD_WORD(AES_REG_MISC_CTRL);
    reg &= ~AES_REG_MISC_CTRL_MSG_BEGIN;
    WR_WORD(AES_REG_MISC_CTRL, reg);
}

static __inline void aes_set_misc_ctrl_msg_end(void)
{
    uint32_t reg = RD_WORD(AES_REG_MISC_CTRL);
    reg |= AES_REG_MISC_CTRL_MSG_END;
    WR_WORD(AES_REG_MISC_CTRL, reg);
}

static __inline void aes_clr_misc_ctrl_msg_end(void)
{
    uint32_t reg = RD_WORD(AES_REG_MISC_CTRL);
    reg &= ~AES_REG_MISC_CTRL_MSG_END;
    WR_WORD(AES_REG_MISC_CTRL, reg);
}

static __inline void aes_set_misc_ctrl_mode(aes_crypto_mode mode)
{
    uint32_t reg = RD_WORD(AES_REG_MISC_CTRL);
    uint8_t val = (uint8_t)mode;
    reg &= ~(AES_REG_MISC_CTRL_MODE);
    reg |= ((val & AES_REG_MISC_CTRL_MODE_MASK) << AES_REG_MISC_CTRL_MODE_SHIFT);
    WR_WORD(AES_REG_MISC_CTRL, reg);
}

static __inline aes_crypto_mode aes_get_misc_ctrl_mode(void)
{
    uint32_t reg = ((RD_WORD(AES_REG_MISC_CTRL) & AES_REG_MISC_CTRL_MODE) >> AES_REG_MISC_CTRL_MODE_SHIFT);
    if(reg == 0)
        return AES_CRYPTO_MODE_ECB;
    else if(reg == 1)
        return AES_CRYPTO_MODE_CBC;
    else if(reg == 2)
        return AES_CRYPTO_MODE_CTR;
    else if(reg == 3)
        return AES_CRYPTO_MODE_CCM;
    else if(reg == 4)
        return AES_CRYPTO_MODE_CMAC;
    else
        return AES_CRYPTO_MODE_F8;
}

static __inline void aes_set_misc_ctrl_mac_len(uint8_t length)
{
    uint32_t reg = RD_WORD(AES_REG_MISC_CTRL);
    reg &= ~(AES_REG_MISC_CTRL_MAC_LEN);
    reg |= ((length & AES_REG_MISC_CTRL_MAC_LEN_MASK) << AES_REG_MISC_CTRL_MAC_LEN_SHIFT);
    WR_WORD(AES_REG_MISC_CTRL, reg);
}

static __inline uint8_t aes_get_misc_ctrl_mac_len(void)
{
    uint8_t len = ((RD_WORD(AES_REG_MISC_CTRL) & AES_REG_MISC_CTRL_MAC_LEN) >> AES_REG_MISC_CTRL_MAC_LEN_SHIFT);
    if(len == 0)
        return 16;
    else
        return len;
}

static __inline void aes_set_misc_ctrl_key_size(aes_key_size size)
{
    uint32_t reg = RD_WORD(AES_REG_MISC_CTRL);
    uint8_t val;
    if(size == AES_KEY_SIZE_128)
        val = 0;
    else if(size == AES_KEY_SIZE_192)
        val = 1;
    else if(size == AES_KEY_SIZE_256)
        val = 2;
    reg &= ~(AES_REG_MISC_CTRL_KEY_SIZE);
    reg |= ((val & AES_REG_MISC_CTRL_KEY_SIZE_MASK) << AES_REG_MISC_CTRL_KEY_SIZE_SHIFT);
    WR_WORD(AES_REG_MISC_CTRL, reg);
}

static __inline aes_key_size aes_get_misc_ctrl_key_size(void)
{
    uint32_t reg = ((RD_WORD(AES_REG_MISC_CTRL) & AES_REG_MISC_CTRL_KEY_SIZE) >> AES_REG_MISC_CTRL_KEY_SIZE_SHIFT);
    if(reg == 0)
        return AES_KEY_SIZE_128;
    else if(reg == 1)
        return AES_KEY_SIZE_192;
    else
        return AES_KEY_SIZE_256;
}

static __inline void aes_set_misc_ctrl_str_ctx(void)
{
    uint32_t reg = RD_WORD(AES_REG_MISC_CTRL);
    reg |= AES_REG_MISC_CTRL_STR_CTX;
    WR_WORD(AES_REG_MISC_CTRL, reg);
}

static __inline void aes_clr_misc_ctrl_str_ctx(void)
{
    uint32_t reg = RD_WORD(AES_REG_MISC_CTRL);
    reg &= ~AES_REG_MISC_CTRL_STR_CTX;
    WR_WORD(AES_REG_MISC_CTRL, reg);
}

static __inline void aes_set_misc_ctrl_ret_ctx(void)
{
    uint32_t reg = RD_WORD(AES_REG_MISC_CTRL);
    reg |= AES_REG_MISC_CTRL_RET_CTX;
    WR_WORD(AES_REG_MISC_CTRL, reg);
}

static __inline void aes_clr_misc_ctrl_ret_ctx(void)
{
    uint32_t reg = RD_WORD(AES_REG_MISC_CTRL);
    reg &= ~AES_REG_MISC_CTRL_RET_CTX;
    WR_WORD(AES_REG_MISC_CTRL, reg);
}

#define AES_CTX_INDEX                                               0x0000000F

#define AES_BLOCK_INDEX                                             0x00000003

#define AES_AAD_LENGTH                                              0x0000007F

static __inline void aes_set_aad_length(uint32_t length)
{
    uint32_t reg = RD_WORD(AES_REG_AAD_LENGTH);
    reg &= ~(AES_REG_AAD_LENGTH_LENGTH);
    reg |= (length & AES_REG_AAD_LENGTH_LENGTH_MASK);
    WR_WORD(AES_REG_AAD_LENGTH, reg);
}

static __inline uint32_t aes_get_aad_length(void)
{
    return (RD_WORD(AES_REG_AAD_LENGTH) & AES_REG_AAD_LENGTH_LENGTH_MASK);
}

#define AES_NUM_BYTES                                               0x0000007F

static __inline void aes_set_num_bytes(uint32_t num)
{
    uint32_t reg = RD_WORD(AES_REG_NUM_BYTES);
    reg &= ~(AES_REG_NUM_BYTES_NUM_BYTES);
    reg |= (num & AES_REG_NUM_BYTES_NUM_BYTES_MASK);
    WR_WORD(AES_REG_NUM_BYTES, reg);
}

static __inline uint32_t aes_get_num_bytes(void)
{
    return (RD_WORD(AES_REG_NUM_BYTES) & AES_REG_NUM_BYTES_NUM_BYTES_MASK);
}

#define AES_NUM_TOTAL_BYTES                                         0x0000FFFF

static __inline void aes_set_num_total_bytes(uint32_t num)
{
    uint32_t reg = RD_WORD(AES_REG_NUM_TOTAL_BYTES);
    reg &= ~(AES_REG_NUM_TOTAL_BYTES_NUM_TOTAL_BYTES);
    reg |= (num & AES_REG_NUM_TOTAL_BYTES_NUM_TOTAL_BYTES_MASK);
    WR_WORD(AES_REG_NUM_TOTAL_BYTES, reg);
}

static __inline uint32_t aes_get_num_total_bytes(void)
{
    return (RD_WORD(AES_REG_NUM_TOTAL_BYTES) & AES_REG_NUM_TOTAL_BYTES_NUM_TOTAL_BYTES_MASK);
}

#define AES_TAG_MSG_ADDR                                            0x0000003F

#define AES_AAD_LEN_TOTAL                                           0x0000FFFF

static __inline void aes_set_aad_length_total(uint32_t length)
{
    uint32_t reg = RD_WORD(AES_REG_AAD_LEN_TOTAL);
    reg &= ~(AES_REG_AAD_LEN_TOTAL_LEN);
    reg |= (length & AES_REG_AAD_LEN_TOTAL_LEN_MASK);
    WR_WORD(AES_REG_AAD_LEN_TOTAL, reg);
}

static __inline uint32_t aes_get_aad_length_total(void)
{
    return (RD_WORD(AES_REG_AAD_LEN_TOTAL) & AES_REG_AAD_LEN_TOTAL_LEN_MASK);
}


#define HASH_REG_OFFSET_INTR                                            0x00000800UL
#define HASH_REG_OFFSET_INTR_EN                                         0x00000040UL
#define HASH_REG_OFFSET_INTR_CLR                                        0x00000080UL
#define HASH_REG_OFFSET_INTR_STATUS                                     0x00000100UL

#define AES_REG_CRYPTO_STATUS                           (AES_REG_BASE + 0x20)
#define AES_REG_CRYPTO_STATUS_INTR_EN                   0x001
#define AES_REG_CRYPTO_STATUS_INTR_CLR                  0x002
#define AES_REG_CRYPTO_STATUS_INTR_STATUS               0x004
#define AES_REG_CRYPTO_STATUS_INTR_STATUS_SHIFT         (2)
#define AES_REG_CRYPTO_STATUS_STATUS                    0x100
#define AES_REG_CRYPTO_STATUS_STATUS_SHIFT              (8)
#define AES_REG_CRYPTO_STATUS_MAC_VER                   0x200
#define AES_REG_CRYPTO_STATUS_MAC_VER_SHIFT             (9)

static __inline void aes_intr_unmask() {
    uint32_t reg = RD_WORD(AES_REG_CRYPTO_STATUS);
    reg |= (AES_REG_CRYPTO_STATUS_INTR_EN);
    WR_WORD(AES_REG_CRYPTO_STATUS, reg);
}

static __inline void aes_intr_mask() {
    uint32_t reg = RD_WORD(AES_REG_CRYPTO_STATUS);
    reg &= ~(AES_REG_CRYPTO_STATUS_INTR_EN);
    WR_WORD(AES_REG_CRYPTO_STATUS, reg);
}

static __inline void aes_intr_clr() {
    uint32_t reg = RD_WORD(AES_REG_CRYPTO_STATUS);
    reg |= (AES_REG_CRYPTO_STATUS_INTR_CLR);
    WR_WORD(AES_REG_CRYPTO_STATUS, reg);
}

static __inline uint8_t aes_get_crypto_status_intr_status() {
    return ((RD_WORD(AES_REG_CRYPTO_STATUS) & AES_REG_CRYPTO_STATUS_INTR_STATUS) >> AES_REG_CRYPTO_STATUS_INTR_STATUS_SHIFT);
}

static __inline uint8_t aes_get_crypto_status_status() {
    return ((RD_WORD(AES_REG_CRYPTO_STATUS) & AES_REG_CRYPTO_STATUS_STATUS) >> AES_REG_CRYPTO_STATUS_STATUS_SHIFT);
}

static __inline uint8_t aes_get_crypto_status_mac_ver() {
    return ((RD_WORD(AES_REG_CRYPTO_STATUS) & AES_REG_CRYPTO_STATUS_MAC_VER) >> AES_REG_CRYPTO_STATUS_MAC_VER_SHIFT);
}

static __inline void aes_mem_en(int en)
{
    if (en)
        WR_WORD(GLOBAL_REG_AES_ECC_MEM_SEL, GLOBAL_REG_AES_ECC_MEM_SEL_CTL_AES_ECC_MEM_SEL);
    else
        WR_WORD(GLOBAL_REG_AES_ECC_MEM_SEL, GLOBAL_REG_AES_ECC_MEM_SEL_DEFAULT);

}

int hal_aes_open(void);

int hal_aes_close(void);

int hal_aes_is_open(void);

int hal_aes_config(aes_cfg_t *cfg);

void hal_aes_set_aad_length(uint32_t length);

int hal_aes_encrypt(const uint8_t *input, uint32_t length, uint8_t *output, bool end);

void hal_aes_get_encrypt_mac(uint8_t *mac, uint32_t buf_sz);

void hal_aes_get_iv(uint8_t iv[16]);

int hal_aes_decrypt(const uint8_t *input, uint32_t length, uint8_t *output, bool end);

#endif