rt-thread/bsp/w60x/drivers/drv_crypto.c

/*
 * Copyright (c) 2019 Winner Microelectronics Co., Ltd.
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2019-05-17     tyx          1st version
 */

#include <rtthread.h>
#include <rtdevice.h>
#include <stdlib.h>
#include <string.h>
#include "drv_crypto.h"
#include "wm_crypto_hard.h"

// #define WM_HWCRYPTO_NOT_LOCK
// #define WM_HWCRYPTO_NOT_ALIGN_CHECK

extern u32 tls_crypto_crc_update_adv(u32 crc_val, CRYPTO_CRC_TYPE type, u8 mode, const unsigned char *in, u32 len);
extern int tls_crypto_des_encrypt_decrypt_adv(unsigned char *key, unsigned char *IV, const unsigned char *in, unsigned char *out, u32 len, CRYPTO_MODE cbc, CRYPTO_WAY dec);
extern int tls_crypto_3des_encrypt_decrypt_adv(unsigned char *key, unsigned char *IV, const unsigned char *in, unsigned char *out, u32 len, CRYPTO_MODE cbc, CRYPTO_WAY dec);
extern int tls_crypto_aes_encrypt_decrypt_adv(unsigned char *key, unsigned char *IV, const unsigned char *in, unsigned char *out, u32 len, CRYPTO_MODE cbc, CRYPTO_WAY dec);
extern int tls_crypto_rc4_adv(unsigned char *key, u32 keylen, const unsigned char *in, unsigned char *out, u32 len);

struct wm_hwcrypto_device
{
    struct rt_hwcrypto_device dev;
    struct rt_mutex mutex;
};

struct hash_ctx_des
{
    psDigestContext_t contex;
};

static rt_uint32_t _rng_rand(struct hwcrypto_rng *ctx)
{
    rt_uint32_t rand_num;
    struct wm_hwcrypto_device *_hwcrypto = (struct wm_hwcrypto_device *)ctx->parent.device;

#if !defined(WM_HWCRYPTO_NOT_LOCK)
    rt_mutex_take(&_hwcrypto->mutex, RT_WAITING_FOREVER);
#endif
    tls_crypto_random_init((u32)rt_tick_get(), CRYPTO_RNG_SWITCH_32);
    tls_crypto_random_bytes((unsigned char *)&rand_num, sizeof(rand_num));
    tls_crypto_random_stop();
#if !defined(WM_HWCRYPTO_NOT_LOCK)
    rt_mutex_release(&_hwcrypto->mutex);
#endif

    return rand_num;
}

static rt_uint32_t _crc_update(struct hwcrypto_crc *ctx, const rt_uint8_t *in, rt_size_t length)
{
    rt_uint32_t crc_result;
    CRYPTO_CRC_TYPE type;
    u8 mode = 0;
    struct wm_hwcrypto_device *_hwcrypto = (struct wm_hwcrypto_device *)ctx->parent.device;
    unsigned char align_flag = 0;

#if !defined(WM_HWCRYPTO_NOT_ALIGN_CHECK)
    if (((rt_uint32_t)in % 4) != 0)
    {
        void *temp;
        temp = rt_malloc(length);
        if (temp)
        {
            memcpy(temp, in, length);
            in = temp;
            align_flag = 1;
        }
        else
        {
            return 0;
        }
    }
#endif

    switch (ctx->crc_cfg.poly)
    {
    case 0x04C11DB7:
        type = CRYPTO_CRC_TYPE_32;
        break;
    case 0x00001021:
        type = CRYPTO_CRC_TYPE_16_CCITT;
        break;
    case 0x00008005:
        type = CRYPTO_CRC_TYPE_16_MODBUS;
        break;
    case 0x00000007:
    case 0x00000207:
        type = CRYPTO_CRC_TYPE_8;
        break;
    default:
        return 0;
    }

    mode |= ctx->crc_cfg.flags & CRC_FLAG_REFOUT ? OUTPUT_REFLECT : 0;
    mode |= ctx->crc_cfg.flags & CRC_FLAG_REFIN ? INPUT_REFLECT : 0;

#if !defined(WM_HWCRYPTO_NOT_LOCK)
    rt_mutex_take(&_hwcrypto->mutex, RT_WAITING_FOREVER);
#endif
    crc_result = tls_crypto_crc_update_adv(ctx->crc_cfg.last_val, type, mode, in, length);
#if !defined(WM_HWCRYPTO_NOT_LOCK)
    rt_mutex_release(&_hwcrypto->mutex);
#endif

#if !defined(WM_HWCRYPTO_NOT_ALIGN_CHECK)
    if (align_flag)
    {
        rt_free((rt_uint8_t *)in);
    }
#endif

    ctx->crc_cfg.last_val = crc_result;
    return crc_result ^ 0x00 ^ ctx->crc_cfg.xorout;
}

static rt_err_t _hash_update(struct hwcrypto_hash *ctx, const rt_uint8_t *in, rt_size_t length)
{
    rt_err_t err = RT_EOK;
    struct wm_hwcrypto_device *_hwcrypto = (struct wm_hwcrypto_device *)ctx->parent.device;
    unsigned char align_flag = 0;

#if !defined(WM_HWCRYPTO_NOT_ALIGN_CHECK)
    if (((rt_uint32_t)in % 4) != 0)
    {
        void *temp;
        temp = rt_malloc(length);
        if (temp)
        {
            memcpy(temp, in, length);
            in = temp;
            align_flag = 1;
        }
        else
        {
            return -RT_ENOMEM;
        }
    }
#endif

#if !defined(WM_HWCRYPTO_NOT_LOCK)
    rt_mutex_take(&_hwcrypto->mutex, RT_WAITING_FOREVER);
#endif
    switch (ctx->parent.type & HWCRYPTO_MAIN_TYPE_MASK)
    {
    case HWCRYPTO_TYPE_MD5:
        tls_crypto_md5_update(&((struct hash_ctx_des *)(ctx->parent.contex))->contex, in, length);
        break;
    case HWCRYPTO_TYPE_SHA1:
        tls_crypto_sha1_update(&((struct hash_ctx_des *)(ctx->parent.contex))->contex, in, length);
        break;
    default:
        err = -RT_ERROR;
        break;
    }
#if !defined(WM_HWCRYPTO_NOT_LOCK)
    rt_mutex_release(&_hwcrypto->mutex);
#endif

#if !defined(WM_HWCRYPTO_NOT_ALIGN_CHECK)
    if (align_flag)
    {
        rt_free((rt_uint8_t *)in);
    }
#endif

    return err;
}

static rt_err_t _hash_finish(struct hwcrypto_hash *ctx, rt_uint8_t *out, rt_size_t length)
{
    rt_err_t err = RT_EOK;
    struct wm_hwcrypto_device *_hwcrypto = (struct wm_hwcrypto_device *)ctx->parent.device;

#if !defined(WM_HWCRYPTO_NOT_LOCK)
    rt_mutex_take(&_hwcrypto->mutex, RT_WAITING_FOREVER);
#endif
    switch (ctx->parent.type & HWCRYPTO_MAIN_TYPE_MASK)
    {
    case HWCRYPTO_TYPE_MD5:
        tls_crypto_md5_final(&((struct hash_ctx_des *)(ctx->parent.contex))->contex, out);
        break;
    case HWCRYPTO_TYPE_SHA1:
        tls_crypto_sha1_final(&((struct hash_ctx_des *)(ctx->parent.contex))->contex, out);
        break;
    default:
        err = -RT_ERROR;
        break;
    }
#if !defined(WM_HWCRYPTO_NOT_LOCK)
    rt_mutex_release(&_hwcrypto->mutex);
#endif

    return err;
}

static rt_err_t _des_crypt(struct hwcrypto_symmetric *symmetric_ctx, struct hwcrypto_symmetric_info *symmetric_info)
{
    CRYPTO_WAY mode;
    CRYPTO_MODE cbc;
    struct wm_hwcrypto_device *_hwcrypto = (struct wm_hwcrypto_device *)symmetric_ctx->parent.device;
    unsigned char *in, *out, align_flag = 0;

    if ((symmetric_ctx->key_bitlen >> 3) != 8
            || (symmetric_info->length % 8) != 0)
    {
        return -RT_EINVAL;
    }

    in = (unsigned char *)symmetric_info->in;
    out = (unsigned char *)symmetric_info->out;

#if !defined(WM_HWCRYPTO_NOT_ALIGN_CHECK)
    if (((rt_uint32_t)in % 4) != 0 || ((rt_uint32_t)out % 4) != 0)
    {
        in = rt_malloc(symmetric_info->length);
        if (in)
        {
            memcpy(in, symmetric_info->in, symmetric_info->length);
            out = in;
            align_flag = 1;
        }
        else
        {
            return -RT_ENOMEM;
        }
    }
#endif

    mode = symmetric_info->mode == HWCRYPTO_MODE_ENCRYPT ? CRYPTO_WAY_ENCRYPT : CRYPTO_WAY_DECRYPT;

    switch (symmetric_ctx->parent.type & (HWCRYPTO_MAIN_TYPE_MASK | HWCRYPTO_SUB_TYPE_MASK))
    {
    case HWCRYPTO_TYPE_DES_ECB:
        cbc = CRYPTO_MODE_ECB;
        break;
    case HWCRYPTO_TYPE_DES_CBC:
        cbc = CRYPTO_MODE_CBC;
        break;
    default :
        return -RT_ERROR;
    }

#if !defined(WM_HWCRYPTO_NOT_LOCK)
    rt_mutex_take(&_hwcrypto->mutex, RT_WAITING_FOREVER);
#endif
    tls_crypto_des_encrypt_decrypt_adv(symmetric_ctx->key, symmetric_ctx->iv,
                                       symmetric_info->in, symmetric_info->out,
                                       symmetric_info->length, cbc, mode);
#if !defined(WM_HWCRYPTO_NOT_LOCK)
    rt_mutex_release(&_hwcrypto->mutex);
#endif

#if !defined(WM_HWCRYPTO_NOT_ALIGN_CHECK)
    if (align_flag)
    {
        memcpy(symmetric_info->out, out, symmetric_info->length);
        rt_free(in);
    }
#endif

    return RT_EOK;
}

static rt_err_t _des3_crypt(struct hwcrypto_symmetric *symmetric_ctx, struct hwcrypto_symmetric_info *symmetric_info)
{
    CRYPTO_WAY mode;
    CRYPTO_MODE cbc;
    struct wm_hwcrypto_device *_hwcrypto = (struct wm_hwcrypto_device *)symmetric_ctx->parent.device;
    unsigned char *in, *out, align_flag = 0;

    if ((symmetric_ctx->key_bitlen >> 3) != 24
            || (symmetric_info->length % 8) != 0)
    {
        return -RT_EINVAL;
    }

    in = (unsigned char *)symmetric_info->in;
    out = (unsigned char *)symmetric_info->out;

#if !defined(WM_HWCRYPTO_NOT_ALIGN_CHECK)
    if (((rt_uint32_t)in % 4) != 0 || ((rt_uint32_t)out % 4) != 0)
    {
        in = rt_malloc(symmetric_info->length);
        if (in)
        {
            memcpy(in, symmetric_info->in, symmetric_info->length);
            out = in;
            align_flag = 1;
        }
        else
        {
            return -RT_ENOMEM;
        }
    }
#endif

    mode = symmetric_info->mode == HWCRYPTO_MODE_ENCRYPT ? CRYPTO_WAY_ENCRYPT : CRYPTO_WAY_DECRYPT;

    switch (symmetric_ctx->parent.type & (HWCRYPTO_MAIN_TYPE_MASK | HWCRYPTO_SUB_TYPE_MASK))
    {
    case HWCRYPTO_TYPE_3DES_ECB:
        cbc = CRYPTO_MODE_ECB;
        break;
    case HWCRYPTO_TYPE_3DES_CBC:
        cbc = CRYPTO_MODE_CBC;
        break;
    default :
        return -RT_ERROR;
    }

#if !defined(WM_HWCRYPTO_NOT_LOCK)
    rt_mutex_take(&_hwcrypto->mutex, RT_WAITING_FOREVER);
#endif
    tls_crypto_3des_encrypt_decrypt_adv(symmetric_ctx->key, symmetric_ctx->iv,
                                        symmetric_info->in, symmetric_info->out,
                                        symmetric_info->length, cbc, mode);
#if !defined(WM_HWCRYPTO_NOT_LOCK)
    rt_mutex_release(&_hwcrypto->mutex);
#endif

#if !defined(WM_HWCRYPTO_NOT_ALIGN_CHECK)
    if (align_flag)
    {
        memcpy(symmetric_info->out, out, symmetric_info->length);
        rt_free(in);
    }
#endif

    return RT_EOK;
}

static rt_err_t _rc4_crypt(struct hwcrypto_symmetric *symmetric_ctx, struct hwcrypto_symmetric_info *symmetric_info)
{
    struct wm_hwcrypto_device *_hwcrypto = (struct wm_hwcrypto_device *)symmetric_ctx->parent.device;
    unsigned char *in, *out, align_flag = 0;

    if ((symmetric_ctx->key_bitlen >> 3) != 16)
    {
        return -RT_EINVAL;
    }

    in = (unsigned char *)symmetric_info->in;
    out = (unsigned char *)symmetric_info->out;

#if !defined(WM_HWCRYPTO_NOT_ALIGN_CHECK)
    if (((rt_uint32_t)in % 4) != 0 || ((rt_uint32_t)out % 4) != 0)
    {
        in = rt_malloc(symmetric_info->length);
        if (in)
        {
            memcpy(in, symmetric_info->in, symmetric_info->length);
            out = in;
            align_flag = 1;
        }
        else
        {
            return -RT_ENOMEM;
        }
    }
#endif

#if !defined(WM_HWCRYPTO_NOT_LOCK)
    rt_mutex_take(&_hwcrypto->mutex, RT_WAITING_FOREVER);
#endif
    tls_crypto_rc4_adv(symmetric_ctx->key, symmetric_ctx->key_bitlen >> 3,
                       (unsigned char *)symmetric_info->in,
                       symmetric_info->out,
                       symmetric_info->length);
#if !defined(WM_HWCRYPTO_NOT_LOCK)
    rt_mutex_release(&_hwcrypto->mutex);
#endif

#if !defined(WM_HWCRYPTO_NOT_ALIGN_CHECK)
    if (align_flag)
    {
        memcpy(symmetric_info->out, out, symmetric_info->length);
        rt_free(in);
    }
#endif

    return RT_EOK;
}

static rt_err_t _aes_crypt(struct hwcrypto_symmetric *symmetric_ctx, struct hwcrypto_symmetric_info *symmetric_info)
{
    CRYPTO_WAY mode;
    CRYPTO_MODE cbc;
    struct wm_hwcrypto_device *_hwcrypto = (struct wm_hwcrypto_device *)symmetric_ctx->parent.device;
    unsigned char *in, *out, align_flag = 0;

    if ((symmetric_ctx->key_bitlen >> 3) != 16
            || (symmetric_info->length % 16) != 0)
    {
        return -RT_EINVAL;
    }

    in = (unsigned char *)symmetric_info->in;
    out = (unsigned char *)symmetric_info->out;

#if !defined(WM_HWCRYPTO_NOT_ALIGN_CHECK)
    if (((rt_uint32_t)in % 4) != 0 || ((rt_uint32_t)out % 4) != 0)
    {
        in = rt_malloc(symmetric_info->length);
        if (in)
        {
            memcpy(in, symmetric_info->in, symmetric_info->length);
            out = in;
            align_flag = 1;
        }
        else
        {
            return -RT_ENOMEM;
        }
    }
#endif

    mode = symmetric_info->mode == HWCRYPTO_MODE_ENCRYPT ? CRYPTO_WAY_ENCRYPT : CRYPTO_WAY_DECRYPT;

    switch (symmetric_ctx->parent.type & (HWCRYPTO_MAIN_TYPE_MASK | HWCRYPTO_SUB_TYPE_MASK))
    {
    case HWCRYPTO_TYPE_AES_ECB:
        cbc = CRYPTO_MODE_ECB;
        break;
    case HWCRYPTO_TYPE_AES_CBC:
        cbc = CRYPTO_MODE_CBC;
        break;
    case HWCRYPTO_TYPE_AES_CTR:
        cbc = CRYPTO_MODE_CTR;
        break;
    default :
        return -RT_ERROR;
    }

#if !defined(WM_HWCRYPTO_NOT_LOCK)
    rt_mutex_take(&_hwcrypto->mutex, RT_WAITING_FOREVER);
#endif
    tls_crypto_aes_encrypt_decrypt_adv(symmetric_ctx->key, symmetric_ctx->iv,
                                       in, out, symmetric_info->length, cbc, mode);
#if !defined(WM_HWCRYPTO_NOT_LOCK)
    rt_mutex_release(&_hwcrypto->mutex);
#endif

#if !defined(WM_HWCRYPTO_NOT_ALIGN_CHECK)
    if (align_flag)
    {
        memcpy(symmetric_info->out, out, symmetric_info->length);
        rt_free(in);
    }
#endif

    return RT_EOK;
}

/**< a = b ^ c (mod d) */
static rt_err_t _bignum_exptmod(struct hwcrypto_bignum *bignum_ctx,
                    struct hw_bignum_mpi *x,
                    const struct hw_bignum_mpi *a,
                    const struct hw_bignum_mpi *b,
                    const struct hw_bignum_mpi *c)
{
	pstm_int pa, pb, pm, pres;
    u32 * buff_a = NULL;
	u32 * buff_b = NULL;
	u32 * buff_m = NULL;
	int err = -1;
    void *buff;
    int buff_len;

    pstm_init(NULL, &pres);

    buff_a = tls_mem_alloc(a->total);
	if(buff_a == NULL)
		goto out;
	buff_b = tls_mem_alloc(b->total);
	if(buff_b == NULL)
		goto out;
	buff_m = tls_mem_alloc(c->total);
	if(buff_m == NULL)
		goto out;

    memset(buff_a, 0, a->total);
    memset(buff_b, 0, b->total);
    memset(buff_m, 0, c->total);

    memcpy(buff_a, a->p, a->total);
    memcpy(buff_b, b->p, b->total);
    memcpy(buff_m, c->p, c->total);

    pstm_reverse((unsigned char *)buff_a, a->total);
	pstm_reverse((unsigned char *)buff_b, b->total);
	pstm_reverse((unsigned char *)buff_m, c->total);

//    *((volatile unsigned int *)0x40000710) = *((volatile unsigned int *)0x40000710) | (0x1 << 28);

	if ((err = pstm_init_for_read_unsigned_bin(NULL, &pa, a->total)) != PS_SUCCESS){
		goto out;
	}
	if ((err = pstm_read_unsigned_bin(&pa, (unsigned char *)buff_a, a->total)) != PS_SUCCESS) {
		goto out;
	}
	if ((err = pstm_init_for_read_unsigned_bin(NULL, &pb, b->total)) != PS_SUCCESS){
		goto out;
	}
	if ((err = pstm_read_unsigned_bin(&pb, (unsigned char *)buff_b, b->total)) != PS_SUCCESS) {
		goto out;
	}
	if ((err = pstm_init_for_read_unsigned_bin(NULL, &pm, c->total)) != PS_SUCCESS){
		goto out;
	}
	if ((err = pstm_read_unsigned_bin(&pm, (unsigned char *)buff_m, c->total)) != PS_SUCCESS) {
		goto out;
	}

    tls_crypto_exptmod(&pa, &pb, &pm, &pres);
    buff_len = pstm_unsigned_bin_size(&pres);
    buff = rt_malloc(buff_len);
    pstm_to_unsigned_bin_nr(NULL, &pres, buff);
    x->sign = pres.sign;
    x->p = buff;
    x->total = buff_len;

out:
    if(buff_a)
		tls_mem_free(buff_a);
	if(buff_b)
		tls_mem_free(buff_b);
	if(buff_m)
		tls_mem_free(buff_m);

	pstm_clear(&pa);
	pstm_clear(&pb);
	pstm_clear(&pm);
	pstm_clear(&pres);

    if (a->sign < 0)
    {
        rt_kprintf("a->sign < 0\n");
    }

    return err == PS_SUCCESS ? RT_EOK : -RT_ERROR;
}

static const struct hwcrypto_symmetric_ops aes_ops =
{
    .crypt = _aes_crypt,
};

static const struct hwcrypto_symmetric_ops rc4_ops =
{
    .crypt = _rc4_crypt,
};

static const struct hwcrypto_symmetric_ops des_ops =
{
    .crypt = _des_crypt,
};

static const struct hwcrypto_symmetric_ops des3_ops =
{
    .crypt = _des3_crypt,
};

static const struct hwcrypto_hash_ops hash_ops =
{
    .update = _hash_update,
    .finish = _hash_finish,
};

static const struct hwcrypto_rng_ops rng_ops =
{
    .update = _rng_rand,
};

static const struct hwcrypto_crc_ops crc_ops =
{
    .update = _crc_update,
};

static const struct hwcrypto_bignum_ops bignum_ops = 
{
    .add = RT_NULL,
    .sub = RT_NULL,
    .mul = RT_NULL,
    .mulmod = RT_NULL,
    .exptmod = _bignum_exptmod,
};

static rt_err_t _crypto_create(struct rt_hwcrypto_ctx *ctx)
{
    rt_err_t res = RT_EOK;
    void *contex;

    switch (ctx->type & HWCRYPTO_MAIN_TYPE_MASK)
    {
    case HWCRYPTO_TYPE_AES :
        ctx->contex = RT_NULL;
        ((struct hwcrypto_symmetric *)ctx)->ops = &aes_ops;
        break;
    case HWCRYPTO_TYPE_RC4 :
        ctx->contex = RT_NULL;
        ((struct hwcrypto_symmetric *)ctx)->ops = &rc4_ops;
        break;
    case HWCRYPTO_TYPE_MD5:
    case HWCRYPTO_TYPE_SHA1:
        contex = rt_malloc(sizeof(struct hash_ctx_des));
        if (contex == RT_NULL)
        {
            return -RT_ENOMEM;
        }
        memset(contex, 0, sizeof(struct hash_ctx_des));
        ctx->contex = contex;
        ((struct hwcrypto_hash *)ctx)->ops = &hash_ops;
        if ((ctx->type & HWCRYPTO_MAIN_TYPE_MASK) == HWCRYPTO_TYPE_MD5)
        {
            tls_crypto_md5_init(&((struct hash_ctx_des *)contex)->contex);
        }
        else
        {
            tls_crypto_sha1_init(&((struct hash_ctx_des *)contex)->contex);
        }
        break;
    case HWCRYPTO_TYPE_DES:
        ctx->contex = RT_NULL;
        ((struct hwcrypto_symmetric *)ctx)->ops = &des_ops;
        break;
    case HWCRYPTO_TYPE_3DES:
        ctx->contex = RT_NULL;
        ((struct hwcrypto_symmetric *)ctx)->ops = &des3_ops;
        break;
    case HWCRYPTO_TYPE_RNG:
        ctx->contex = RT_NULL;
        ((struct hwcrypto_rng *)ctx)->ops = &rng_ops;
        ctx->contex = RT_NULL;
        break;
    case HWCRYPTO_TYPE_CRC:
        ctx->contex = RT_NULL;
        ((struct hwcrypto_crc *)ctx)->ops = &crc_ops;
        break;
    case HWCRYPTO_TYPE_BIGNUM:
        ((struct hwcrypto_bignum *)ctx)->ops = &bignum_ops;
        break;
    default:
        res = -RT_ERROR;
        break;
    }

    return res;
}

static void _crypto_destroy(struct rt_hwcrypto_ctx *ctx)
{
    rt_free(ctx->contex);
}

static rt_err_t _crypto_clone(struct rt_hwcrypto_ctx *des, const struct rt_hwcrypto_ctx *src)
{
    rt_err_t res = RT_EOK;

    switch (src->type & HWCRYPTO_MAIN_TYPE_MASK)
    {
    case HWCRYPTO_TYPE_AES:
    case HWCRYPTO_TYPE_RC4:
    case HWCRYPTO_TYPE_RNG:
    case HWCRYPTO_TYPE_CRC:
    case HWCRYPTO_TYPE_BIGNUM:
        break;
    case HWCRYPTO_TYPE_MD5:
    case HWCRYPTO_TYPE_SHA1:
        if (des->contex && src->contex)
        {
            rt_memcpy(des->contex, src->contex, sizeof(struct hash_ctx_des));
        }
        break;
    default:
        res = -RT_ERROR;
        break;
    }

    return res;
}

static void _crypto_reset(struct rt_hwcrypto_ctx *ctx)
{
    switch (ctx->type & HWCRYPTO_MAIN_TYPE_MASK)
    {
    case HWCRYPTO_TYPE_AES:
    case HWCRYPTO_TYPE_RC4:
    case HWCRYPTO_TYPE_RNG:
    case HWCRYPTO_TYPE_CRC:
        break;
    case HWCRYPTO_TYPE_MD5:
        tls_crypto_md5_init(&((struct hash_ctx_des *)(ctx->contex))->contex);
        break;
    case HWCRYPTO_TYPE_SHA1:
        tls_crypto_sha1_init(&((struct hash_ctx_des *)(ctx->contex))->contex);
        break;
    default:
        break;
    }
}

static const struct rt_hwcrypto_ops _ops =
{
    .create = _crypto_create,
    .destroy = _crypto_destroy,
    .copy = _crypto_clone,
    .reset = _crypto_reset,
};

extern u8 *wpa_supplicant_get_mac(void);

int wm_hw_crypto_device_init(void)
{
    static struct wm_hwcrypto_device _crypto_dev;

    _crypto_dev.dev.ops = &_ops;
    _crypto_dev.dev.id = 0;
    rt_memcpy(&_crypto_dev.dev.id, wpa_supplicant_get_mac(), 
        sizeof(_crypto_dev.dev.id) > 6 ?
        6 : sizeof(_crypto_dev.dev.id));
    _crypto_dev.dev.user_data = &_crypto_dev;

    if (rt_hwcrypto_register(&_crypto_dev.dev,
                             RT_HWCRYPTO_DEFAULT_NAME) != RT_EOK)
    {
        return -1;
    }
    rt_mutex_init(&_crypto_dev.mutex, RT_HWCRYPTO_DEFAULT_NAME, RT_IPC_FLAG_FIFO);
    return 0;
}
INIT_DEVICE_EXPORT(wm_hw_crypto_device_init);