qiurui
/
rv1126-uboot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

crypto: rockchip: modify crypto hash cache support for crypto v1&v2 

Change-Id: I6e0604bf02908269ab021714378b66ed712fdc06
Signed-off-by: Lin Jinhan <troy.lin@rock-chips.com>
This commit is contained in:
Lin Jinhan 2020-08-17 16:42:34 +08:00
parent 66d0591041
commit c48f1acf4a
6 changed files with 385 additions and 231 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
drivers/crypto/rockchip/Makefile
View File

@ -4,9 +4,9 @@
# Copyright (c) 2019 Fuzhou Rockchip Electronics Co., Ltd
#
obj-$(CONFIG_$(SPL_TPL_)ROCKCHIP_CRYPTO_V1) += crypto_v1.o
obj-$(CONFIG_$(SPL_TPL_)ROCKCHIP_CRYPTO_V2) += crypto_v2.o
obj-$(CONFIG_$(SPL_TPL_)ROCKCHIP_CRYPTO_V1) += crypto_v1.o crypto_hash_cache.o
obj-$(CONFIG_$(SPL_TPL_)ROCKCHIP_CRYPTO_V2) += crypto_v2.o crypto_hash_cache.o
ifeq ($(CONFIG_$(SPL_TPL_)ROCKCHIP_CRYPTO_V2)$(CONFIG_$(SPL_TPL_)ROCKCHIP_RSA), yy)
obj-y += crypto_v2_pka.o crypto_v2_util.o
endif
endif

193
drivers/crypto/rockchip/crypto_hash_cache.c Normal file
View File

@ -0,0 +1,193 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2020 Rockchip Electronics Co., Ltd
*/
#include <common.h>
#include <clk.h>
#include <crypto.h>
#include <rockchip/crypto_hash_cache.h>
static int hash_cache_calc(struct crypto_hash_cache *hash_cache, const u8 *data,
u32 data_len, u8 is_last)
{
crypto_hash_calc direct_calc = hash_cache->direct_calc;
int ret = 0;
if (!hash_cache->cache) {
hash_cache->cache = (u8 *)memalign(CONFIG_SYS_CACHELINE_SIZE,
HASH_CACHE_SIZE);
if (!hash_cache->cache)
goto error;
hash_cache->cache_size = 0;
}
while (1) {
u32 tmp_len = 0;
if (hash_cache->cache_size + data_len <= HASH_CACHE_SIZE) {
/* copy to cache */
debug("%s, %d: copy to cache %u\n",
__func__, __LINE__, data_len);
memcpy(hash_cache->cache + hash_cache->cache_size, data,
data_len);
hash_cache->cache_size += data_len;
/* if last one calc cache immediately */
if (is_last) {
debug("%s, %d: last one calc cache %u\n",
__func__, __LINE__,
hash_cache->cache_size);
ret = direct_calc(hash_cache->user_data,
hash_cache->cache,
hash_cache->cache_size,
&hash_cache->is_started,
is_last);
if (ret)
goto error;
}
break;
}
/* 1. make cache be full */
/* 2. calc cache */
tmp_len = HASH_CACHE_SIZE - hash_cache->cache_size;
debug("%s, %d: make cache be full %u\n",
__func__, __LINE__, tmp_len);
memcpy(hash_cache->cache + hash_cache->cache_size,
data, tmp_len);
ret = direct_calc(hash_cache->user_data, hash_cache->cache,
HASH_CACHE_SIZE, &hash_cache->is_started, 0);
if (ret)
goto error;
data += tmp_len;
data_len -= tmp_len;
hash_cache->cache_size = 0;
}
return ret;
error:
return -EINVAL;
}
void crypto_flush_cacheline(ulong addr, ulong size)
{
ulong alignment = CONFIG_SYS_CACHELINE_SIZE;
ulong aligned_input, aligned_len;
/* Must flush dcache before crypto DMA fetch data region */
aligned_input = round_down(addr, alignment);
aligned_len = round_up(size + (addr - aligned_input), alignment);
flush_cache(aligned_input, aligned_len);
}
struct crypto_hash_cache *crypto_hash_cache_alloc(crypto_hash_calc direct_calc,
void *user_data, u32 total,
u32 data_align, u32 len_align)
{
struct crypto_hash_cache *hash_cache = NULL;
if (!direct_calc)
return NULL;
hash_cache = malloc(sizeof(struct crypto_hash_cache));
if (!hash_cache)
return NULL;
memset(hash_cache, 0x00, sizeof(*hash_cache));
hash_cache->direct_calc = direct_calc;
hash_cache->user_data = user_data;
hash_cache->data_align = data_align;
hash_cache->len_align = len_align;
hash_cache->left_len = total;
return hash_cache;
}
void crypto_hash_cache_free(struct crypto_hash_cache *hash_cache)
{
if (!hash_cache)
return;
if (hash_cache->cache)
free(hash_cache->cache);
free(hash_cache);
}
int crypto_hash_update_with_cache(struct crypto_hash_cache *hash_cache,
const u8 *data, u32 data_len)
{
crypto_hash_calc direct_calc = hash_cache->direct_calc;
const u8 *direct_data = NULL, *cache_data = NULL;
u32 direct_data_len = 0, cache_data_len = 0;
u8 is_last = 0;
int ret = 0;
if (hash_cache->left_len < data_len)
goto error;
is_last = hash_cache->left_len == data_len ? 1 : 0;
if (!hash_cache->use_cache &&
IS_ALIGNED((ulong)data, hash_cache->data_align)) {
direct_data = data;
if (IS_ALIGNED(data_len, hash_cache->len_align) || is_last) {
/* calc all directly */
debug("%s, %d: calc all directly\n",
__func__, __LINE__);
direct_data_len = data_len;
} else {
/* calc some directly calc some in cache */
debug("%s, %d: calc some directly calc some in cache\n",
__func__, __LINE__);
direct_data_len = round_down((ulong)data_len,
hash_cache->len_align);
cache_data = direct_data + direct_data_len;
cache_data_len = data_len % hash_cache->len_align;
hash_cache->use_cache = 1;
}
} else {
/* calc all in cache */
debug("%s, %d: calc all in cache\n", __func__, __LINE__);
cache_data = data;
cache_data_len = data_len;
hash_cache->use_cache = 1;
}
if (direct_data_len) {
debug("%s, %d: calc direct data %u\n",
__func__, __LINE__, direct_data_len);
ret = direct_calc(hash_cache->user_data,
direct_data, direct_data_len,
&hash_cache->is_started, is_last);
if (ret)
goto error;
hash_cache->left_len -= direct_data_len;
}
if (cache_data_len) {
debug("%s, %d: calc cache data %u\n",
__func__, __LINE__, cache_data_len);
ret = hash_cache_calc(hash_cache, cache_data,
cache_data_len, is_last);
if (ret)
goto error;
hash_cache->left_len -= cache_data_len;
}
return 0;
error:
if (hash_cache->cache) {
free(hash_cache->cache);
hash_cache->cache = NULL;
}
return -EINVAL;
}

105
drivers/crypto/rockchip/crypto_v1.c
View File

@ -7,14 +7,23 @@
#include <clk.h>
#include <crypto.h>
#include <dm.h>
#include <rockchip/crypto_hash_cache.h>
#include <rockchip/crypto_v1.h>
#include <asm/io.h>
#include <asm/arch/hardware.h>
#include <asm/arch/clock.h>
#define CRYPTO_V1_DEFAULT_RATE 100000000
/* crypto timeout 500ms, must support more than 32M data per times*/
#define HASH_UPDATE_LIMIT (32 * 1024 * 1024)
#define RK_CRYPTO_TIME_OUT 500000
#define LLI_ADDR_ALIGIN_SIZE 8
#define DATA_ADDR_ALIGIN_SIZE 8
#define DATA_LEN_ALIGIN_SIZE 64
struct rockchip_crypto_priv {
struct crypto_hash_cache *hash_cache;
struct rk_crypto_reg *reg;
struct clk clk;
sha_context *ctx;
@ -34,6 +43,36 @@ static u32 rockchip_crypto_capability(struct udevice *dev)
CRYPTO_RSA2048;
}
static int rk_hash_direct_calc(void *hw_data, const u8 *data,
u32 data_len, u8 *started_flag, u8 is_last)
{
struct rockchip_crypto_priv *priv = hw_data;
struct rk_crypto_reg *reg = priv->reg;
if (!data_len)
return -EINVAL;
/* Must flush dcache before crypto DMA fetch data region */
crypto_flush_cacheline((ulong)data, data_len);
/* Hash Done Interrupt */
writel(HASH_DONE_INT, &reg->crypto_intsts);
/* Set data base and length */
writel((u32)(ulong)data, &reg->crypto_hrdmas);
writel((data_len + 3) >> 2, &reg->crypto_hrdmal);
/* Write 1 to start. When finishes, the core will clear it */
rk_setreg(&reg->crypto_ctrl, HASH_START);
/* Wait last complete */
do {} while (readl(&reg->crypto_ctrl) & HASH_START);
priv->length += data_len;
return 0;
}
static int rockchip_crypto_sha_init(struct udevice *dev, sha_context *ctx)
{
struct rockchip_crypto_priv *priv = dev_get_priv(dev);
@ -48,6 +87,13 @@ static int rockchip_crypto_sha_init(struct udevice *dev, sha_context *ctx)
return -EINVAL;
}
priv->hash_cache = crypto_hash_cache_alloc(rk_hash_direct_calc,
priv, ctx->length,
DATA_ADDR_ALIGIN_SIZE,
DATA_LEN_ALIGIN_SIZE);
if (!priv->hash_cache)
return -EFAULT;
priv->ctx = ctx;
priv->length = 0;
writel(ctx->length, &reg->crypto_hash_msg_len);
@ -97,40 +143,32 @@ static int rockchip_crypto_sha_update(struct udevice *dev,
u32 *input, u32 len)
{
struct rockchip_crypto_priv *priv = dev_get_priv(dev);
struct rk_crypto_reg *reg = priv->reg;
ulong aligned_input, aligned_len;
int ret = -EINVAL, i;
u8 *p;
if (!len)
return -EINVAL;
if (!input || !len)
goto exit;
priv->length += len;
if ((priv->length != priv->ctx->length) && !IS_ALIGNED(len, 4)) {
printf("Crypto-v1: require update data length 4-byte "
"aligned(0x%08lx - 0x%08lx)\n",
(ulong)input, (ulong)input + len);
return -EINVAL;
p = (u8 *)input;
for (i = 0; i < len / HASH_UPDATE_LIMIT; i++, p += HASH_UPDATE_LIMIT) {
ret = crypto_hash_update_with_cache(priv->hash_cache, p,
HASH_UPDATE_LIMIT);
if (ret)
goto exit;
}
/* Must flush dcache before crypto DMA fetch data region */
aligned_input = round_down((ulong)input, CONFIG_SYS_CACHELINE_SIZE);
aligned_len = round_up(len + ((ulong)input - aligned_input),
CONFIG_SYS_CACHELINE_SIZE);
flush_cache(aligned_input, aligned_len);
if (len % HASH_UPDATE_LIMIT)
ret = crypto_hash_update_with_cache(priv->hash_cache, p,
len % HASH_UPDATE_LIMIT);
/* Wait last complete */
do {} while (readl(&reg->crypto_ctrl) & HASH_START);
exit:
if (ret) {
crypto_hash_cache_free(priv->hash_cache);
priv->hash_cache = NULL;
}
/* Hash Done Interrupt */
writel(HASH_DONE_INT, &reg->crypto_intsts);
/* Set data base and length */
writel((u32)(ulong)input, &reg->crypto_hrdmas);
writel((len + 3) >> 2, &reg->crypto_hrdmal);
/* Write 1 to start. When finishes, the core will clear it */
rk_setreg(&reg->crypto_ctrl, HASH_START);
return 0;
return ret;
}
static int rockchip_crypto_sha_final(struct udevice *dev,
@ -139,13 +177,15 @@ static int rockchip_crypto_sha_final(struct udevice *dev,
struct rockchip_crypto_priv *priv = dev_get_priv(dev);
struct rk_crypto_reg *reg = priv->reg;
u32 *buf = (u32 *)output;
int ret = 0;
u32 nbits;
int i;
if (priv->length != ctx->length) {
printf("Crypto-v1: data total length(0x%08x) != init length(0x%08x)!\n",
printf("total length(0x%08x) != init length(0x%08x)!\n",
priv->length, ctx->length);
return -EIO;
ret = -EIO;
goto exit;
}
/* Wait last complete */
@ -159,7 +199,10 @@ static int rockchip_crypto_sha_final(struct udevice *dev,
for (i = 0; i < BITS2WORD(nbits); i++)
buf[i] = readl(&reg->crypto_hash_dout[i]);
return 0;
exit:
crypto_hash_cache_free(priv->hash_cache);
priv->hash_cache = NULL;
return ret;
}
#if CONFIG_IS_ENABLED(ROCKCHIP_RSA)

234
drivers/crypto/rockchip/crypto_v2.c
View File

@ -10,9 +10,44 @@
#include <asm/io.h>
#include <asm/arch/hardware.h>
#include <asm/arch/clock.h>
#include <rockchip/crypto_hash_cache.h>
#include <rockchip/crypto_v2.h>
#include <rockchip/crypto_v2_pka.h>
#define RK_HASH_CTX_MAGIC 0x1A1A1A1A
#define CRYPTO_TRNG_MAX 32
enum endian_mode {
BIG_ENDIAN = 0,
LITTLE_ENDIAN
};
enum clk_type {
CLK = 0,
HCLK
};
struct crypto_lli_desc {
u32 src_addr;
u32 src_len;
u32 dst_addr;
u32 dst_len;
u32 user_define;
u32 reserve;
u32 dma_ctrl;
u32 next_addr;
};
struct rk_hash_ctx {
struct crypto_lli_desc data_lli; /* lli desc */
struct crypto_hash_cache *hash_cache;
u32 magic; /* to check ctx */
u32 algo; /* hash algo */
u8 digest_size; /* hash out length */
u8 reserved[3];
};
struct rockchip_crypto_priv {
fdt_addr_t reg;
struct clk clk;
@ -73,16 +108,6 @@ static void word2byte(u32 word, u8 *ch, u32 endian)
}
}
static void rk_flush_cache_align(ulong addr, ulong size, ulong alignment)
{
ulong aligned_input, aligned_len;
/* Must flush dcache before crypto DMA fetch data region */
aligned_input = round_down(addr, alignment);
aligned_len = round_up(size + (addr - aligned_input), alignment);
flush_cache(aligned_input, aligned_len);
}
static inline void clear_hash_out_reg(void)
{
int i;
@ -117,13 +142,12 @@ static void hw_hash_clean_ctx(struct rk_hash_ctx *ctx)
assert(ctx);
assert(ctx->magic == RK_HASH_CTX_MAGIC);
if (ctx->cache)
free(ctx->cache);
crypto_hash_cache_free(ctx->hash_cache);
memset(ctx, 0x00, sizeof(*ctx));
}
int rk_hash_init(void *hw_ctx, u32 algo, u32 length)
static int rk_hash_init(void *hw_ctx, u32 algo)
{
struct rk_hash_ctx *tmp_ctx = (struct rk_hash_ctx *)hw_ctx;
u32 reg_ctrl = 0;
@ -132,8 +156,6 @@ int rk_hash_init(void *hw_ctx, u32 algo, u32 length)
if (!tmp_ctx)
return -EINVAL;
memset(tmp_ctx, 0x00, sizeof(*tmp_ctx));
reg_ctrl = CRYPTO_SW_CC_RESET;
crypto_write(reg_ctrl | (reg_ctrl << CRYPTO_WRITE_MASK_SHIFT),
CRYPTO_RST_CTL);
@ -182,7 +204,6 @@ int rk_hash_init(void *hw_ctx, u32 algo, u32 length)
crypto_write(CRYPTO_SRC_ITEM_INT_EN, CRYPTO_DMA_INT_EN);
tmp_ctx->magic = RK_HASH_CTX_MAGIC;
tmp_ctx->left_len = length;
return 0;
exit:
@ -192,9 +213,12 @@ exit:
return ret;
}
static int rk_hash_direct_calc(struct crypto_lli_desc *lli, const u8 *data,
static int rk_hash_direct_calc(void *hw_data, const u8 *data,
u32 data_len, u8 *started_flag, u8 is_last)
{
struct rockchip_crypto_priv *priv = hw_data;
struct rk_hash_ctx *hash_ctx = priv->hw_ctx;
struct crypto_lli_desc *lli = &hash_ctx->data_lli;
int ret = -EINVAL;
u32 tmp = 0;
@ -230,9 +254,8 @@ static int rk_hash_direct_calc(struct crypto_lli_desc *lli, const u8 *data,
}
/* flush cache */
rk_flush_cache_align((ulong)lli, sizeof(*lli),
CONFIG_SYS_CACHELINE_SIZE);
rk_flush_cache_align((ulong)data, data_len, CONFIG_SYS_CACHELINE_SIZE);
crypto_flush_cacheline((ulong)lli, sizeof(*lli));
crypto_flush_cacheline((ulong)data, data_len);
/* start calculate */
crypto_write(tmp << CRYPTO_WRITE_MASK_SHIFT | tmp,
@ -253,153 +276,32 @@ static int rk_hash_direct_calc(struct crypto_lli_desc *lli, const u8 *data,
goto exit;
}
priv->length += data_len;
exit:
return ret;
}
static int rk_hash_cache_calc(struct rk_hash_ctx *tmp_ctx, const u8 *data,
u32 data_len, u8 is_last)
{
u32 left_len;
int ret = 0;
if (!tmp_ctx->cache) {
tmp_ctx->cache = (u8 *)memalign(DATA_ADDR_ALIGIN_SIZE,
HASH_CACHE_SIZE);
if (!tmp_ctx->cache)
goto error;
tmp_ctx->cache_size = 0;
}
left_len = tmp_ctx->left_len;
while (1) {
u32 tmp_len = 0;
if (tmp_ctx->cache_size + data_len <= HASH_CACHE_SIZE) {
/* copy to cache */
debug("%s, %d: copy to cache %u\n",
__func__, __LINE__, data_len);
memcpy(tmp_ctx->cache + tmp_ctx->cache_size, data,
data_len);
tmp_ctx->cache_size += data_len;
/* if last one calc cache immediately */
if (is_last) {
debug("%s, %d: last one calc cache %u\n",
__func__, __LINE__, tmp_ctx->cache_size);
ret = rk_hash_direct_calc(&tmp_ctx->data_lli,
tmp_ctx->cache,
tmp_ctx->cache_size,
&tmp_ctx->is_started,
is_last);
if (ret)
goto error;
}
left_len -= data_len;
break;
}
/* 1. make cache be full */
/* 2. calc cache */
tmp_len = HASH_CACHE_SIZE - tmp_ctx->cache_size;
debug("%s, %d: make cache be full %u\n",
__func__, __LINE__, tmp_len);
memcpy(tmp_ctx->cache + tmp_ctx->cache_size, data, tmp_len);
ret = rk_hash_direct_calc(&tmp_ctx->data_lli,
tmp_ctx->cache,
HASH_CACHE_SIZE,
&tmp_ctx->is_started,
0);
if (ret)
goto error;
data += tmp_len;
data_len -= tmp_len;
left_len -= tmp_len;
tmp_ctx->cache_size = 0;
}
return ret;
error:
return -EINVAL;
}
int rk_hash_update(void *ctx, const u8 *data, u32 data_len)
{
struct rk_hash_ctx *tmp_ctx = (struct rk_hash_ctx *)ctx;
const u8 *direct_data = NULL, *cache_data = NULL;
u32 direct_data_len = 0, cache_data_len = 0;
int ret = 0;
u8 is_last = 0;
int ret = -EINVAL;
debug("\n");
if (!tmp_ctx || !data)
goto error;
goto exit;
if (tmp_ctx->digest_size == 0 || tmp_ctx->magic != RK_HASH_CTX_MAGIC)
goto error;
goto exit;
if (tmp_ctx->left_len < data_len)
goto error;
ret = crypto_hash_update_with_cache(tmp_ctx->hash_cache,
data, data_len);
is_last = tmp_ctx->left_len == data_len ? 1 : 0;
if (!tmp_ctx->use_cache &&
IS_ALIGNED((ulong)data, DATA_ADDR_ALIGIN_SIZE)) {
direct_data = data;
if (IS_ALIGNED(data_len, DATA_LEN_ALIGIN_SIZE) || is_last) {
/* calc all directly */
debug("%s, %d: calc all directly\n",
__func__, __LINE__);
direct_data_len = data_len;
} else {
/* calc some directly calc some in cache */
debug("%s, %d: calc some directly calc some in cache\n",
__func__, __LINE__);
direct_data_len = round_down((ulong)data_len,
DATA_LEN_ALIGIN_SIZE);
cache_data = direct_data + direct_data_len;
cache_data_len = data_len % DATA_LEN_ALIGIN_SIZE;
tmp_ctx->use_cache = 1;
}
} else {
/* calc all in cache */
debug("%s, %d: calc all in cache\n", __func__, __LINE__);
cache_data = data;
cache_data_len = data_len;
tmp_ctx->use_cache = 1;
}
if (direct_data_len) {
debug("%s, %d: calc direct data %u\n",
__func__, __LINE__, direct_data_len);
ret = rk_hash_direct_calc(&tmp_ctx->data_lli, direct_data,
direct_data_len,
&tmp_ctx->is_started, is_last);
if (ret)
goto error;
tmp_ctx->left_len -= direct_data_len;
}
if (cache_data_len) {
debug("%s, %d: calc cache data %u\n",
__func__, __LINE__, cache_data_len);
ret = rk_hash_cache_calc(tmp_ctx, cache_data,
cache_data_len, is_last);
if (ret)
goto error;
tmp_ctx->left_len -= cache_data_len;
}
exit:
/* free lli list */
if (ret)
hw_hash_clean_ctx(tmp_ctx);
return ret;
error:
/* free lli list */
hw_hash_clean_ctx(tmp_ctx);
return -EINVAL;
}
int rk_hash_final(void *ctx, u8 *digest, size_t len)
@ -439,8 +341,6 @@ int rk_hash_final(void *ctx, u8 *digest, size_t len)
crypto_write(CRYPTO_WRITE_MASK_ALL | 0, CRYPTO_HASH_CTL);
exit:
/* free lli list */
hw_hash_clean_ctx(tmp_ctx);
return ret;
}
@ -500,13 +400,23 @@ static u32 rockchip_crypto_capability(struct udevice *dev)
static int rockchip_crypto_sha_init(struct udevice *dev, sha_context *ctx)
{
struct rockchip_crypto_priv *priv = dev_get_priv(dev);
struct rk_hash_ctx *hash_ctx = priv->hw_ctx;
if (!ctx)
return -EINVAL;
memset(priv->hw_ctx, 0x00, sizeof(struct rk_hash_ctx));
memset(hash_ctx, 0x00, sizeof(*hash_ctx));
return rk_hash_init(priv->hw_ctx, ctx->algo, ctx->length);
priv->length = 0;
hash_ctx->hash_cache = crypto_hash_cache_alloc(rk_hash_direct_calc,
priv, ctx->length,
DATA_ADDR_ALIGIN_SIZE,
DATA_LEN_ALIGIN_SIZE);
if (!hash_ctx->hash_cache)
return -EFAULT;
return rk_hash_init(hash_ctx, ctx->algo);
}
static int rockchip_crypto_sha_update(struct udevice *dev,
@ -539,10 +449,22 @@ static int rockchip_crypto_sha_final(struct udevice *dev,
{
struct rockchip_crypto_priv *priv = dev_get_priv(dev);
u32 nbits;
int ret;
nbits = crypto_algo_nbits(ctx->algo);
return rk_hash_final(priv->hw_ctx, (u8 *)output, BITS2BYTE(nbits));
if (priv->length != ctx->length) {
printf("total length(0x%08x) != init length(0x%08x)!\n",
priv->length, ctx->length);
ret = -EIO;
goto exit;
}
ret = rk_hash_final(priv->hw_ctx, (u8 *)output, BITS2BYTE(nbits));
exit:
hw_hash_clean_ctx(priv->hw_ctx);
return ret;
}
#if CONFIG_IS_ENABLED(ROCKCHIP_RSA)

37
include/rockchip/crypto_hash_cache.h Normal file
View File

@ -0,0 +1,37 @@
/* SPDX-License-Identifier: GPL-2.0+ */
/*
* (C) Copyright 2020 Rockchip Electronics Co., Ltd
*/
#ifndef _CRYPTO_HASH_CACHE_H_
#define _CRYPTO_HASH_CACHE_H_
#define HASH_CACHE_SIZE 8192
#define CIPHER_CACHE_SIZE 8192
typedef int (*crypto_hash_calc)(void *hw_data, const u8 *data, u32 data_len,
u8 *started_flag, u8 is_last);
struct crypto_hash_cache {
crypto_hash_calc direct_calc; /* hardware hash callback*/
void *user_data;
void *cache; /* virt addr for hash src data*/
u32 cache_size; /* data in cached size */
u32 data_align;
u32 len_align;
u32 left_len; /* left data to calc */
u8 is_started; /* start or restart */
u8 use_cache; /* is use cache or not*/
u8 reserved[2];
};
struct crypto_hash_cache *crypto_hash_cache_alloc(crypto_hash_calc direct_calc,
void *user_data, u32 total,
u32 data_align,
u32 len_align);
void crypto_hash_cache_free(struct crypto_hash_cache *hash_cache);
int crypto_hash_update_with_cache(struct crypto_hash_cache *hash_cache,
const u8 *data, u32 data_len);
void crypto_flush_cacheline(ulong addr, ulong size);
#endif

41
include/rockchip/crypto_v2.h
View File

@ -44,9 +44,6 @@ enum rk_hash_algo {
#define RK_MODE_ENCRYPT 0
#define RK_MODE_DECRYPT 1
#define HASH_CACHE_SIZE 8192
#define CIPHER_CACHE_SIZE 8192
#define _SBF(s, v) ((v) << (s))
#define _BIT(b) _SBF(b, 1)
@ -556,44 +553,6 @@ enum rk_hash_algo {
#define LLI_USER_PRIVACY_KEY _BIT(7)
#define LLI_USER_ROOT_KEY _BIT(8)
#define CRYPTO_TRNG_MAX 32
enum endian_mode {
BIG_ENDIAN = 0,
LITTLE_ENDIAN
};
enum clk_type {
CLK = 0,
HCLK
};
struct crypto_lli_desc {
u32 src_addr;
u32 src_len;
u32 dst_addr;
u32 dst_len;
u32 user_define;
u32 reserve;
u32 dma_ctrl;
u32 next_addr;
};
struct rk_hash_ctx {
struct crypto_lli_desc data_lli;/* lli desc */
void *cache; /* virt addr for hash src data*/
u32 cache_size; /* data in cached size */
u32 left_len; /* left data to calc */
u32 magic; /* to check ctx */
u32 algo; /* hash algo */
u8 digest_size; /* hash out length */
u8 is_started; /* choose use start or restart */
u8 use_cache; /* is use cache or not*/
u8 reserved;
};
#define RK_HASH_CTX_MAGIC 0x1A1A1A1A
extern fdt_addr_t crypto_base;
static inline u32 crypto_read(u32 offset)