libs/rt-thread
libs
/
rt-thread
4
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
rt-thread/bsp/allwinner/libraries/sunxi-hal/hal/source/ce/ce_common.c

985 lines
29 KiB
C
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* Copyright (c) 2019-2025 Allwinner Technology Co., Ltd. ALL rights reserved.
* Allwinner is a trademark of Allwinner Technology Co.,Ltd., registered in
* the the People's Republic of China and other countries.
* All Allwinner Technology Co.,Ltd. trademarks are used with permission.
* DISCLAIMER
* THIRD PARTY LICENCES MAY BE REQUIRED TO IMPLEMENT THE SOLUTION/PRODUCT.
* IF YOU NEED TO INTEGRATE THIRD PARTY’S TECHNOLOGY (SONY, DTS, DOLBY, AVS OR MPEGLA, ETC.)
* IN ALLWINNERS’SDK OR PRODUCTS, YOU SHALL BE SOLELY RESPONSIBLE TO OBTAIN
* ALL APPROPRIATELY REQUIRED THIRD PARTY LICENCES.
* ALLWINNER SHALL HAVE NO WARRANTY, INDEMNITY OR OTHER OBLIGATIONS WITH RESPECT TO MATTERS
* COVERED UNDER ANY REQUIRED THIRD PARTY LICENSE.
* YOU ARE SOLELY RESPONSIBLE FOR YOUR USAGE OF THIRD PARTY’S TECHNOLOGY.
* THIS SOFTWARE IS PROVIDED BY ALLWINNER"AS IS" AND TO THE MAXIMUM EXTENT
* PERMITTED BY LAW, ALLWINNER EXPRESSLY DISCLAIMS ALL WARRANTIES OF ANY KIND,
* WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING WITHOUT LIMITATION REGARDING
* THE TITLE, NON-INFRINGEMENT, ACCURACY, CONDITION, COMPLETENESS, PERFORMANCE
* OR MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
* IN NO EVENT SHALL ALLWINNER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS, OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <stdlib.h>
#include <string.h>
#include <interrupt.h>
#include <hal_cache.h>
#include <hal_mem.h>
#include <hal_osal.h>
#include <hal_sem.h>
#include <hal_timer.h>
#include <sunxi_hal_ce.h>
#include "ce_common.h"
#include "hal_ce.h"
#include "ce_reg.h"
#include "platform_ce.h"
//#define CE_NO_IRQ
#define CE_WAIT_TIME (50000)
#ifndef CE_NO_IRQ
static hal_sem_t ce_sem;
#endif
//static rt_wqueue_t ce_wqueue;
void ce_print_hex(char *_data, int _len, void *_addr)
{
int i, j;
char last[128] = {0};
CE_DBG("---------------- The valid len = %d ----------------\n",
_len);
for (i = 0; i < _len/8; i++) {
CE_DBG("%p: %02X %02X %02X %02X %02X %02X %02X %02X\n",
i*8 + _addr,
_data[i*8+0], _data[i*8+1], _data[i*8+2], _data[i*8+3],
_data[i*8+4], _data[i*8+5], _data[i*8+6], _data[i*8+7]);
}
for (j = 0; j < _len%8; j++) {
if (j == 0)
snprintf(last, 12, "%p:", i * 8 + _addr);
snprintf(last + 11 + j*3, 4, " %02X", _data[i*8 + j]);
if (j == _len % 8 - 1)
CE_DBG("%s\n", last);
}
CE_DBG("----------------------------------------------------\n");
}
void ce_print_task_info(ce_task_desc_t *task)
{
CE_DBG("-----------task_info------\n");
CE_DBG("task = 0x%lx\n", (uint32_t)task);
CE_DBG("task->comm_ctl = 0x%lx\n", task->comm_ctl);
CE_DBG("task->sym_ctl = 0x%lx\n", task->sym_ctl);
CE_DBG("task->asym_ctl = 0x%lx\n", task->asym_ctl);
CE_DBG("task->chan_id = 0x%lx\n", task->chan_id);
CE_DBG("task->ctr_addr = 0x%lx\n", task->ctr_addr);
CE_DBG("task->data_len = 0x%lx\n", task->data_len);
CE_DBG("task->iv_addr = 0x%lx\n", task->iv_addr);
CE_DBG("task->key_addr = 0x%lx\n", task->key_addr);
CE_DBG("task->src[0].addr = 0x%lx\n", task->src[0].addr);
CE_DBG("task->src[0].len = 0x%lx\n", task->src[0].len);
CE_DBG("task->dst[0].addr = 0x%lx\n", task->dst[0].addr);
CE_DBG("task->dst[0].len = 0x%lx\n", task->dst[0].len);
}
#ifndef CE_NO_IRQ
static hal_irqreturn_t ce_irq_handler(void *data)
{
int i;
int ret;
int pending = 0;
pending = hal_ce_pending_get();
for (i = 0; i < CE_FLOW_NUM; i++) {
if (pending & (CE_CHAN_PENDING << i)) {
CE_DBG("Chan %d completed. pending: %#x\n", i, pending);
hal_ce_pending_clear(i);
ret = hal_sem_post(ce_sem);
if (ret == 0) {
;
} else {
CE_ERR("hal_sem_post FAIL \n");
}
#if 0
rt_wqueue_wakeup(&ce_wqueue, NULL);
#endif
}
}
return HAL_IRQ_OK;
}
static int ce_irq_request(void)
{
#ifdef CONFIG_ARCH_SUN20IW2P1
uint32_t irqn = SUNXI_IRQ_CE_NS;
if (hal_request_irq(irqn, ce_irq_handler, "ce", NULL) < 0) {
CE_ERR("request irq error\n");
return -1;
}
hal_enable_irq(irqn);
#else
uint32_t irqn = SUNXI_IRQ_CE;
if (request_irq(irqn, ce_irq_handler, 0, "crypto", NULL) < 0) {
CE_ERR("Cannot request IRQ\n");
return -1;
}
enable_irq(irqn);
#endif
return 0;
}
#endif
int sunxi_ce_init(void)
{
int ret = 0;
hal_ce_clock_init();
#ifndef CE_NO_IRQ
ret = ce_irq_request();
if (ret < 0) {
return -1;
}
ce_sem = hal_sem_create(0);
if (ce_sem == NULL) {
CE_ERR("hal_sem_create fail\n");
return -1;
}
#endif
#if 0
rt_wqueue_init(&ce_wqueue);
#endif
return 0;
}
int sunxi_ce_uninit(void)
{
#ifndef CE_NO_IRQ
if (ce_sem)
hal_sem_delete(ce_sem);
#ifdef CONFIG_ARCH_SUN20IW2P1
hal_free_irq(SUNXI_IRQ_CE_NS);
#else
hal_free_irq(SUNXI_IRQ_CE);
#endif
#endif
return 0;
}
static void ce_task_desc_init(ce_task_desc_t *task, uint32_t flow)
{
memset((void *)task, 0x0, sizeof(ce_task_desc_t));
task->chan_id = flow;
hal_ce_task_enable(task);
}
static ce_task_desc_t *ce_aes_config(uint32_t dir, uint32_t type, uint32_t mode,
uint8_t *key_buf, uint32_t key_length)
{
ce_task_desc_t *task = NULL;
uint32_t flow = 1;
task = (ce_task_desc_t *)hal_malloc(sizeof(ce_task_desc_t));
if (task == NULL) {
CE_ERR("hal_malloc fail\n");
return NULL;
}
ce_task_desc_init(task, flow);
hal_ce_method_set(dir, type, task);
hal_ce_aes_mode_set(mode, task);
hal_ce_key_set(key_buf, key_length, task);
hal_dcache_clean((unsigned long)key_buf, key_length);
return task;
}
static uint32_t ce_aes_sw_padding(crypto_aes_req_ctx_t *ctx)
{
uint32_t blk_num = 0;
uint32_t padding_size = 0;
uint32_t last_blk_size = 0;
blk_num = ctx->src_length / AES_BLOCK_SIZE;
last_blk_size = ctx->src_length % AES_BLOCK_SIZE;
if (last_blk_size) {
padding_size = AES_BLOCK_SIZE - last_blk_size;
memcpy(ctx->padding, ctx->src_buffer + blk_num * AES_BLOCK_SIZE, last_blk_size);
memset(ctx->padding + last_blk_size, padding_size, padding_size);
ctx->padding_len = AES_BLOCK_SIZE;
} else {
ctx->padding_len = 0;
}
return blk_num * AES_BLOCK_SIZE;
}
static int ce_aes_start(crypto_aes_req_ctx_t *req_ctx)
{
int ret = 0;
ce_task_desc_t *task;
uint32_t src_len = 0;
uint32_t src_word_len = 0;
src_len = ce_aes_sw_padding(req_ctx);
src_word_len = src_len >> 2;
/*ce task config*/
task = ce_aes_config(req_ctx->dir, CE_METHOD_AES, req_ctx->mode, req_ctx->key, req_ctx->key_length);
if (task == NULL) {
CE_ERR("ce_aes_config fail\n");
return HAL_AES_INPUT_ERROR;
}
hal_ce_pending_clear(task->chan_id);
if (req_ctx->iv) {
hal_ce_iv_set(req_ctx->iv, AES_BLOCK_SIZE, task);
hal_dcache_clean((unsigned long)req_ctx->iv, AES_BLOCK_SIZE);
}
if (CE_AES_MODE_CTR == req_ctx->mode) {
hal_ce_cnt_set(req_ctx->iv_next, req_ctx->key_length, task);
hal_dcache_clean((unsigned long)req_ctx->iv_next, req_ctx->key_length);
} else if (CE_AES_MODE_CTS == req_ctx->mode) {
hal_ce_cts_last(task);
} else if (CE_AES_MODE_CFB == req_ctx->mode) {
hal_ce_cfb_bitwidth_set(req_ctx->bitwidth,task);
}
if ((task->sym_ctl & 0xF00) == (CE_AES_MODE_CTS << CE_SYM_CTL_OP_MODE_SHIFT))
task->data_len = src_len + req_ctx->padding_len;
else
hal_ce_data_len_set(src_len + req_ctx->padding_len, task);
if (src_len) {
task->src[0].addr = (uint32_t)__va_to_pa((unsigned long)req_ctx->src_buffer);
task->src[0].len = src_word_len;
if (req_ctx->padding_len) {
task->src[1].addr = (uint32_t)__va_to_pa((unsigned long)req_ctx->padding);
task->src[1].len = req_ctx->padding_len >> 2;
}
} else {
task->src[0].addr = (uint32_t)__va_to_pa((unsigned long)req_ctx->padding);
task->src[0].len = req_ctx->padding_len >> 2;
}
task->dst[0].addr = (uint32_t)__va_to_pa((unsigned long)req_ctx->dst_buffer);
task->dst[0].len = (src_len + req_ctx->padding_len) >> 2;
task->next = 0;
hal_dcache_clean((unsigned long)task, sizeof(ce_task_desc_t));
if (src_len) {
hal_dcache_clean((unsigned long)req_ctx->src_buffer, src_len);
}
if (req_ctx->padding_len) {
hal_dcache_clean((unsigned long)req_ctx->padding, req_ctx->padding_len);
}
hal_dcache_clean((unsigned long)req_ctx->dst_buffer, src_len + req_ctx->padding_len);
//ce_print_task_info(task);
hal_ce_set_task((unsigned long)task);
hal_ce_irq_enable(task->chan_id);
hal_ce_ctrl_start();
#ifdef CE_NO_IRQ
hal_ce_wait_finish(task->chan_id);
hal_ce_pending_clear(task->chan_id);
#else
#if 1
ret = hal_sem_timedwait(ce_sem, CE_WAIT_TIME);
if (ret != 0) {
CE_ERR("Timed out\n");
hal_free(task);
return HAL_AES_TIME_OUT;
}
#else
rt_wqueue_wait(&ce_wqueue, 0, RT_WAITING_FOREVER);
#endif
#endif
hal_dcache_invalidate((uint32_t)req_ctx->dst_buffer, src_len + req_ctx->padding_len);
hal_ce_irq_disable(task->chan_id);
if (hal_ce_get_erro() > 0) {
CE_ERR("error\n");
hal_ce_reg_printf();
hal_free(task);
return HAL_AES_CRYPTO_ERROR;
}
CE_DBG("do_aes_crypto sucess\n");
hal_free(task);
return HAL_AES_STATUS_OK;
}
static int ce_aes_check_ctx_vaild(crypto_aes_req_ctx_t *req_ctx)
{
if (req_ctx == NULL) {
CE_ERR("aes req_ctx is NULL\n");
return HAL_AES_INPUT_ERROR;
}
if ((req_ctx->src_buffer == NULL)
|| (req_ctx->dst_buffer == NULL)
|| (req_ctx->key == NULL)
|| ((req_ctx->mode != CE_AES_MODE_ECB) && (req_ctx->iv == NULL) )) {
CE_ERR("input is NULL\n");
return HAL_AES_INPUT_ERROR;
}
if ((req_ctx->key_length != AES_KEYSIZE_16)
&& (req_ctx->key_length != AES_KEYSIZE_24)
&& (req_ctx->key_length != AES_KEYSIZE_32)) {
CE_ERR("key length is %ld, invalid\n", req_ctx->key_length);
return HAL_AES_INPUT_ERROR;
}
if ((((u32)req_ctx->src_buffer & (CE_ALIGN_SIZE - 1)) != 0)
|| (((u32)req_ctx->dst_buffer & (CE_ALIGN_SIZE - 1)) != 0)
|| (((u32)req_ctx->key & (CE_ALIGN_SIZE - 1)) != 0)) {
CE_ERR("input buffer is not %d align\n", CE_ALIGN_SIZE);
return HAL_AES_INPUT_ERROR;
}
if (req_ctx->dir == CE_DIR_DECRYPT) {
if (((req_ctx->mode == CE_AES_MODE_ECB)
|| (req_ctx->mode == CE_AES_MODE_CBC)
|| (req_ctx->mode == CE_AES_MODE_CTS))
&& (req_ctx->src_length % AES_BLOCK_SIZE != 0)) {
CE_ERR("src_length: %d is not %d align\n",
req_ctx->src_length, AES_BLOCK_SIZE);
return HAL_AES_INPUT_ERROR;
}
if (req_ctx->src_length > req_ctx->dst_length) {
CE_ERR("src_length: %d should not bigger than dst_length: %d\n",
req_ctx->src_length, req_ctx->dst_length);
return HAL_AES_INPUT_ERROR;
}
} else if (req_ctx->dir == CE_DIR_ENCRYPT) {
if (req_ctx->dst_length < CE_ROUND_UP(req_ctx->src_length, AES_BLOCK_SIZE)) {
CE_ERR("dst_length: %d should not smaller than %d\n",
req_ctx->dst_length,
CE_ROUND_UP(req_ctx->src_length, AES_BLOCK_SIZE));
return HAL_AES_INPUT_ERROR;
}
} else {
CE_ERR("input crypt dir: %d is error.\n", req_ctx->dir);
return HAL_AES_INPUT_ERROR;
}
return HAL_AES_STATUS_OK;
}
int do_aes_crypto(crypto_aes_req_ctx_t *req_ctx)
{
uint32_t last_block_size = 0;
uint32_t block_num = 0;
uint32_t padding_size = 0;
uint32_t first_encypt_size = 0;
uint8_t data_block[AES_BLOCK_SIZE] = {0};
uint8_t *iv;
uint8_t *init_vector2;
ce_task_desc_t *task;
int ret;
ret = ce_aes_check_ctx_vaild(req_ctx);
if (ret) {
CE_ERR("ce_aes_check_ctx_vaild fail\n");
return ret;
}
ret = ce_aes_start(req_ctx);
if (ret < 0) {
CE_ERR("aes crypto fail\n");
return ret;
}
return ret;
}
static uint32_t ce_hash_endian4(uint32_t data)
{
uint32_t d1, d2, d3, d4;
d1 = (data & 0xff) << 24;
d2 = (data & 0xff00) << 8;
d3 = (data & 0xff0000) >> 8;
d4 = (data & 0xff000000) >> 24;
return (d1 | d2 | d3 | d4);
}
static uint32_t ce_hash_blk_size(int type)
{
if ((type == CE_METHOD_SHA384) || (type == CE_METHOD_SHA512))
return SHA512_BLOCK_SIZE;
return SHA1_BLOCK_SIZE;
}
static uint32_t ce_hash_sw_padding(crypto_hash_req_ctx_t *ctx)
{
uint32_t blk_size = ce_hash_blk_size(ctx->type);
uint32_t len_threshold = (blk_size == SHA512_BLOCK_SIZE) ? 112 : 56;
uint32_t n = ctx->src_length % blk_size;
uint8_t *p = ctx->padding;
uint32_t len_l = ctx->src_length << 3; /* total len, in bits. */
uint32_t len_h = ctx->src_length >> 29;
uint32_t big_endian = (ctx->type == CE_METHOD_MD5) ? 0 : 1;
memset(ctx->padding, 0, 256);
if (n) {
memcpy(ctx->padding, ctx->src_buffer + ctx->src_length - n, n);
}
CE_DBG("ctx->type = %d, n = %d, ctx->src_length = %d\n", ctx->type, n, ctx->src_length);
p[n] = 0x80;
n++;
if (n > len_threshold) { /* The pad data need two blocks. */
memset(p+n, 0, blk_size*2 - n);
p += blk_size*2 - 8;
} else {
memset(p+n, 0, blk_size - n);
p += blk_size - 8;
}
if (big_endian == 1) {
#if 0
/* The length should use bit64 in SHA384/512 case.
* The OpenSSL package is always small than 8K,
* so we use still bit32.
*/
if (blk_size == SHA512_BLOCK_SIZE) {
int len_hh = ctx->cnt >> 61;
*(int *)(p-4) = ce_hash_endian4(len_hh);
}
#endif
*(int *)p = ce_hash_endian4(len_h);
*(int *)(p+4) = ce_hash_endian4(len_l);
} else {
*(int *)p = len_l;
*(int *)(p+4) = len_h;
}
ctx->padding_len = (uint32_t)(p + 8 - ctx->padding);
CE_DBG("After padding %d: %02x %02x %02x %02x %02x %02x %02x %02x\n",
ctx->padding_len,
p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
return ctx->src_length - (ctx->src_length % blk_size);
}
static int ce_hash_start(crypto_hash_req_ctx_t *req_ctx)
{
int ret = 0;
int i = 0;
uint8_t chan_id = 1;
ce_task_desc_t *task = NULL;
uint32_t src_word_len = 0;
uint32_t src_length = ce_hash_sw_padding(req_ctx);
src_word_len = src_length >> 2;
task = (ce_task_desc_t *)hal_malloc(sizeof(ce_task_desc_t));
if (task == NULL) {
CE_ERR("hal_malloc fail\n");
return HAL_HASH_MALLOC_ERROR;
}
CE_DBG("task addr = 0x%lx\n", (uint32_t)task);
ce_task_desc_init(task, chan_id);
hal_ce_pending_clear(chan_id);
hal_ce_method_set(req_ctx->dir, req_ctx->type, task);
hal_ce_data_len_set(src_length + req_ctx->padding_len, task);
if (req_ctx->md_size) {
hal_ce_iv_set(req_ctx->md, req_ctx->md_size, task);
hal_dcache_clean((unsigned long)req_ctx->md, req_ctx->md_size);
hal_ce_iv_mode_set(CE_HASH_IV_INPUT, task);
}
if (src_word_len != 0) {
task->src[0].addr = (uint32_t)__va_to_pa((uint32_t)req_ctx->src_buffer);
task->src[0].len = src_word_len;
task->src[1].addr = (uint32_t)__va_to_pa((uint32_t)req_ctx->padding);
task->src[1].len = req_ctx->padding_len >> 2;
} else {
task->src[0].addr = (uint32_t)__va_to_pa((uint32_t)req_ctx->padding);
task->src[0].len = req_ctx->padding_len >> 2;
}
task->dst[0].addr = (uint32_t)__va_to_pa((uint32_t)req_ctx->dst_buffer);
task->dst[0].len = req_ctx->dst_length >> 2;
task->next = 0;
hal_dcache_clean((uint32_t)task, sizeof(ce_task_desc_t));
hal_dcache_clean((uint32_t)req_ctx->src_buffer, req_ctx->src_length);
hal_dcache_clean((uint32_t)req_ctx->padding, req_ctx->padding_len);
hal_dcache_clean((uint32_t)req_ctx->dst_buffer, req_ctx->dst_length);
//FlushCacheAll();
//ce_print_task_info(task);
hal_ce_set_task((uint32_t)task);
hal_ce_irq_enable(task->chan_id);
hal_ce_ctrl_start();
#ifdef CE_NO_IRQ
hal_ce_wait_finish(task->chan_id);
hal_ce_pending_clear(task->chan_id);
#else
ret = hal_sem_timedwait(ce_sem, CE_WAIT_TIME);
if (ret != 0) {
CE_ERR("Timed out\n");
ret = HAL_HASH_TIME_OUT;
goto fail;
}
#endif
hal_dcache_invalidate((uint32_t)req_ctx->dst_buffer, req_ctx->dst_length);
if (hal_ce_get_erro() > 0) {
hal_ce_reg_printf();
ret = HAL_HASH_CRYPTO_ERROR;
goto fail;
}
//ce_print_hex((char *)task->dst[0].addr, (task->dst[0].len * 4), (char *)task->dst[0].addr);
//hal_ce_reg_printf();
hal_ce_irq_disable(task->chan_id);
memcpy(req_ctx->md, req_ctx->dst_buffer, req_ctx->dst_length);
req_ctx->md_size = req_ctx->dst_length;
hal_free(task);
return HAL_HASH_STATUS_OK;
fail:
if (task) {
hal_free(task);
}
return ret;
}
static int ce_hash_check_ctx_valid(crypto_hash_req_ctx_t *req_ctx)
{
if (req_ctx == NULL) {
CE_ERR("sha req_ctx is NULL\n");
return HAL_HASH_INPUT_ERROR;
}
if ((((u32)req_ctx->dst_buffer & (CE_ALIGN_SIZE - 1)) != 0)
|| (((u32)req_ctx->src_buffer & (CE_ALIGN_SIZE - 1)) != 0)) {
CE_ERR("input buffer addr is not %d align\n", CE_ALIGN_SIZE);
return HAL_HASH_INPUT_ERROR;
}
if (req_ctx->type == CE_METHOD_MD5) {
if ((req_ctx->dst_length != MD5_DIGEST_SIZE)
|| ((req_ctx->md_size != 0)
&& (req_ctx->md_size != MD5_DIGEST_SIZE))) {
CE_ERR("output length is not %d\n", MD5_DIGEST_SIZE);
return HAL_HASH_INPUT_ERROR;
}
} else if (req_ctx->type == CE_METHOD_SHA1) {
if ((req_ctx->dst_length != SHA1_DIGEST_SIZE)
|| ((req_ctx->md_size != 0)
&& (req_ctx->md_size != SHA1_DIGEST_SIZE))) {
CE_ERR("output length is not %d\n", SHA1_DIGEST_SIZE);
return HAL_HASH_INPUT_ERROR;
}
} else if (req_ctx->type == CE_METHOD_SHA224) {
if ((req_ctx->dst_length != SHA256_DIGEST_SIZE)
|| ((req_ctx->md_size != 0)
&& (req_ctx->md_size != SHA256_DIGEST_SIZE))) {
CE_ERR("output length is not %d\n", SHA256_DIGEST_SIZE);
return HAL_HASH_INPUT_ERROR;
}
} else if (req_ctx->type == CE_METHOD_SHA256) {
if ((req_ctx->dst_length != SHA256_DIGEST_SIZE)
|| ((req_ctx->md_size != 0)
&& (req_ctx->md_size != SHA256_DIGEST_SIZE))) {
CE_ERR("output length is not %d\n", SHA256_DIGEST_SIZE);
return HAL_HASH_INPUT_ERROR;
}
} else if (req_ctx->type == CE_METHOD_SHA384) {
if ((req_ctx->dst_length != SHA512_DIGEST_SIZE)
|| ((req_ctx->md_size != 0)
&& (req_ctx->md_size != SHA512_DIGEST_SIZE))) {
CE_ERR("output length is not %d\n", SHA512_DIGEST_SIZE);
return HAL_HASH_INPUT_ERROR;
}
} else if (req_ctx->type == CE_METHOD_SHA512) {
if ((req_ctx->dst_length != SHA512_DIGEST_SIZE)
|| ((req_ctx->md_size != 0)
&& (req_ctx->md_size != SHA512_DIGEST_SIZE))) {
CE_ERR("output length is not %d\n", SHA512_DIGEST_SIZE);
return HAL_HASH_INPUT_ERROR;
}
} else {
CE_ERR("ce don't support hash mode: %d\n", req_ctx->type);
return HAL_HASH_INPUT_ERROR;
}
return HAL_HASH_STATUS_OK;
}
int do_hash_crypto(crypto_hash_req_ctx_t *req_ctx)
{
uint8_t *src_tmp = NULL;
uint32_t src_align_len = 0;
int ret = 0;
ret = ce_hash_check_ctx_valid(req_ctx);
if (ret < 0) {
CE_ERR("ce_hash_check_ctx_valid fail: %d\n", ret);
return ret;
}
ret = ce_hash_start(req_ctx);
if (ret < 0) {
CE_ERR("caclu hash erro num is %d\n", ret);
return HAL_HASH_CRYPTO_ERROR;
}
return HAL_HASH_STATUS_OK;
}
static void ce_rsa_sw_padding(uint8_t *dst_buf, uint8_t *src_buf, uint32_t data_len, uint32_t group_len)
{
int i = 0;
memset(dst_buf, 0, group_len);
for (i = group_len - data_len; i < group_len; i++) {
dst_buf[i] = src_buf[group_len - 1 - i];
}
}
static int ce_rsa_start(crypto_rsa_req_ctx_t *req_ctx)
{
int ret = 0;
uint8_t chan_id = 2;
uint8_t *p_src = NULL;
uint8_t *p_n = NULL;
uint8_t *p_d = NULL;
uint8_t *p_dst = NULL;
ce_task_desc_t *task = NULL;
uint32_t bitwidth_byte_len = 0;
uint32_t bitwidth_word_len = 0;
bitwidth_byte_len = req_ctx->bitwidth >> 3;
bitwidth_word_len = req_ctx->bitwidth >> 5;
p_src = hal_malloc(bitwidth_byte_len);
if (p_src == NULL) {
CE_ERR("rsa src hal_malloc fail\n");
ret = HAL_RSA_MALLOC_ERROR;
goto fail;
}
memset(p_src, 0x0, bitwidth_byte_len);
ce_rsa_sw_padding(p_src, req_ctx->src_buffer, req_ctx->src_length, bitwidth_byte_len);
p_n = hal_malloc(bitwidth_byte_len);
if (p_n == NULL) {
CE_ERR("rsa key n hal_malloc fail\n");
ret = HAL_RSA_MALLOC_ERROR;
goto fail;
}
memset(p_n, 0x0, bitwidth_byte_len);
ce_rsa_sw_padding(p_n, req_ctx->key_n, req_ctx->n_len, bitwidth_byte_len);
if (req_ctx->key_d) {
p_d = hal_malloc(bitwidth_byte_len);
if (p_d == NULL) {
CE_ERR("rsa key d hal_malloc fail\n");
ret = HAL_RSA_MALLOC_ERROR;
goto fail;
}
memset(p_d, 0x0, bitwidth_byte_len);
ce_rsa_sw_padding(p_d, req_ctx->key_d, req_ctx->d_len, bitwidth_byte_len);
req_ctx->key_d = p_d;
}
p_dst = hal_malloc(bitwidth_byte_len);
if (p_dst == NULL) {
CE_ERR("hal_malloc fail\n");
ret = HAL_RSA_MALLOC_ERROR;
goto fail;
}
memset(p_dst, 0x0, bitwidth_byte_len);
task = (ce_task_desc_t *)hal_malloc(sizeof(ce_task_desc_t));
if (task == NULL) {
CE_ERR("rt_malloc_align fail\n");
ret = HAL_RSA_MALLOC_ERROR;
goto fail;
}
CE_DBG("task addr = 0x%lx\n", (uint32_t)task);
ce_task_desc_init(task, chan_id);
hal_ce_pending_clear(chan_id);
hal_ce_method_set(req_ctx->dir, req_ctx->type, task);
hal_ce_rsa_width_set(req_ctx->bitwidth, task);
task->iv_addr = (uint32_t)__va_to_pa((uint32_t)p_n);
if (req_ctx->key_d)
task->key_addr = (uint32_t)__va_to_pa((uint32_t)p_d);
else
task->key_addr = (uint32_t)__va_to_pa((uint32_t)req_ctx->key_e);
hal_ce_data_len_set(bitwidth_byte_len, task);
task->src[0].addr = (uint32_t)__va_to_pa((uint32_t)p_src);
task->src[0].len = bitwidth_word_len;
task->dst[0].addr = (uint32_t)__va_to_pa((uint32_t)p_dst);
task->dst[0].len = bitwidth_word_len;
task->next = 0;
hal_dcache_clean((uint32_t)task, sizeof(ce_task_desc_t));
hal_dcache_clean((uint32_t)p_src, bitwidth_byte_len);
hal_dcache_clean((uint32_t)p_n, bitwidth_byte_len);
if (req_ctx->key_d)
hal_dcache_clean((uint32_t)p_d, bitwidth_byte_len);
else
hal_dcache_clean((uint32_t)req_ctx->key_e, bitwidth_byte_len);
hal_dcache_clean((uint32_t)p_dst, bitwidth_byte_len);
//FlushCacheAll();
/*ce_print_task_info(task);*/
hal_ce_set_task((uint32_t)task);
hal_ce_irq_enable(task->chan_id);
hal_ce_ctrl_start();
#ifdef CE_NO_IRQ
hal_ce_wait_finish(task->chan_id);
hal_ce_pending_clear(task->chan_id);
#else
ret = hal_sem_timedwait(ce_sem, CE_WAIT_TIME);
if (ret != 0) {
CE_ERR("Timed out\n");
ret = HAL_RSA_CRYPTO_ERROR;
goto fail;
}
#endif
hal_dcache_invalidate((uint32_t)p_dst, bitwidth_byte_len);
/*ce_reg_printf();*/
if (hal_ce_get_erro() > 0) {
hal_ce_reg_printf();
ret = HAL_RSA_CRYPTO_ERROR;
goto fail;
}
hal_ce_irq_disable(task->chan_id);
ce_rsa_sw_padding(req_ctx->dst_buffer, p_dst, req_ctx->dst_length, req_ctx->dst_length);
fail:
if (p_src)
hal_free(p_src);
if (p_n)
hal_free(p_n);
if (p_d)
hal_free(p_d);
if (p_dst)
hal_free(p_dst);
if (task)
hal_free(task);
return ret;
}
static int ce_rsa_check_ctx_valid(crypto_rsa_req_ctx_t *req_ctx)
{
if (req_ctx == NULL) {
CE_ERR("rsa req_ctx is NULL\n");
return HAL_RSA_INPUT_ERROR;
}
if ((((u32)req_ctx->key_n & (CE_ALIGN_SIZE - 1)) != 0)
|| (((u32)req_ctx->key_e & (CE_ALIGN_SIZE - 1)) != 0)
|| (((u32)req_ctx->key_d & (CE_ALIGN_SIZE - 1)) != 0)
|| (((u32)req_ctx->src_buffer & (CE_ALIGN_SIZE - 1)) != 0)
|| (((u32)req_ctx->dst_buffer & (CE_ALIGN_SIZE - 1)) != 0)) {
printf("rsa req_ctx buffer is not %d align\n", CE_ALIGN_SIZE);
return HAL_RSA_INPUT_ERROR;
}
if ((req_ctx->bitwidth == 512)
|| (req_ctx->bitwidth == 1024)
|| (req_ctx->bitwidth == 2048)) {
if ((req_ctx->n_len > req_ctx->bitwidth / 8)
|| (req_ctx->e_len > req_ctx->bitwidth / 8)
|| (req_ctx->d_len > req_ctx->bitwidth / 8)
|| (req_ctx->src_length > req_ctx->bitwidth / 8)
|| (req_ctx->dst_length > req_ctx->bitwidth / 8)) {
CE_ERR("rsa length should not bigger than %d\n", req_ctx->bitwidth / 8);
return HAL_RSA_INPUT_ERROR;
}
} else {
CE_ERR("invalid bitwidth: %d\n", req_ctx->bitwidth);
return HAL_RSA_INPUT_ERROR;
}
return HAL_RSA_STATUS_OK;
}
int do_rsa_crypto(crypto_rsa_req_ctx_t *req_ctx)
{
int ret = 0;
ret = ce_rsa_check_ctx_valid(req_ctx);
if (ret < 0) {
CE_ERR("ce_rsa_check_ctx_valid fail: %d\n", ret);
return ret;
}
ret = ce_rsa_start(req_ctx);
if (ret < 0) {
CE_ERR("calc rsa erro num is %d\n", ret);
return ret;
}
return HAL_RSA_STATUS_OK;
}
int do_rng_gen(crypto_rng_req_ctx_t *req_ctx)
{
int ret = 0;
uint8_t chan_id = 2;
uint32_t dst_len = 0;
uint8_t *dst_buf = NULL;
ce_task_desc_t *task = NULL;
if (req_ctx->mode == CE_METHOD_TRNG) {
dst_len = CE_ROUND_UP(req_ctx->rng_len, 32); /*align with 32 Bytes*/
} else if (req_ctx->mode == CE_METHOD_PRNG) {
dst_len = CE_ROUND_UP(req_ctx->rng_len, 20); /*align with 20 Bytes*/
} else {
CE_ERR("Error: do not support mode %d\n", req_ctx->mode);
ret = HAL_RNG_INPUT_ERROR;
goto fail;
}
if (dst_len > SS_RNG_MAX_LEN) {
CE_ERR("Error: The RNG length is too large: %d\n", dst_len);
ret = HAL_RNG_INPUT_ERROR;
goto fail;
}
dst_buf = (uint8_t *)hal_malloc(dst_len);
if (dst_buf == NULL) {
CE_ERR("hal_malloc dst_buf fail\n");
ret = HAL_RNG_MALLOC_ERROR;
goto fail;
}
task = (ce_task_desc_t *)hal_malloc(sizeof(ce_task_desc_t));
if (task == NULL) {
CE_ERR("hal_malloc task fail\n");
ret = HAL_RNG_MALLOC_ERROR;
goto fail;
}
CE_DBG("task addr = 0x%lx, rng_buf = 0x%lx, rng_len = %d\n", (uint32_t)task, req_ctx->rng_buf, req_ctx->rng_len);
ce_task_desc_init(task, chan_id);
hal_ce_pending_clear(chan_id);
hal_ce_method_set(0, req_ctx->mode, task);
hal_ce_data_len_set(dst_len, task);
if (req_ctx->mode == CE_METHOD_PRNG) {
/* must set the seed add in prng */
if (req_ctx->key && (req_ctx->key_len == 24)) {
hal_ce_key_set(req_ctx->key, req_ctx->key_len, task);
hal_dcache_clean((uint32_t)req_ctx->key, req_ctx->key_len);
} else {
CE_ERR("Error: RRNG must set seed, and the seed size must be 24!\n");
ret = HAL_RNG_INPUT_ERROR;
goto fail;
}
}
task->src[0].addr = 0;
task->src[0].len = 0;
task->dst[0].addr = (uint32_t)__va_to_pa((uint32_t)dst_buf);
task->dst[0].len = dst_len >> 2;
hal_dcache_clean((uint32_t)task, sizeof(ce_task_desc_t));
hal_dcache_clean((uint32_t)dst_buf, dst_len);
//ce_print_task_info(task);
hal_ce_set_task((uint32_t)task);
hal_ce_irq_enable(task->chan_id);
hal_ce_ctrl_start();
#ifdef CE_NO_IRQ
hal_ce_wait_finish(task->chan_id);
hal_ce_pending_clear(task->chan_id);
#else
ret = hal_sem_timedwait(ce_sem, CE_WAIT_TIME);
if (ret != 0) {
CE_ERR("Timed out\n");
ret = HAL_RNG_TIME_OUT;
goto fail;
}
#endif
hal_dcache_invalidate((uint32_t)dst_buf, dst_len);
if (req_ctx->mode == CE_METHOD_PRNG) {
hal_dcache_invalidate((uint32_t)req_ctx->key, req_ctx->key_len);
}
if (hal_ce_get_erro() > 0) {
hal_ce_reg_printf();
ret = HAL_RNG_CRYPTO_ERROR;
goto fail;
}
//ce_print_hex((char *)task->dst[0].addr, (task->dst[0].len * 4), (char *)task->dst[0].addr);
/*ce_reg_printf();*/
memcpy(req_ctx->rng_buf, dst_buf, req_ctx->rng_len);
hal_ce_irq_disable(task->chan_id);
hal_free(task);
hal_free(dst_buf);
return HAL_RNG_STATUS_OK;
fail:
if (task) {
hal_free(task);
}
if (dst_buf) {
hal_free(task);
}
return ret;
}
View Git Blame Copy Permalink