shinys000114/linux
1
0
Fork 0
mirror of https://github.com/hardkernel/linux.git synced 2026-06-08 11:50:43 +09:00
Code Issues Packages Projects Releases Wiki Activity

crypto: rockchip: optimize the coding style

Browse Source 
Rename some struct name and variable name been more clearly.

Change-Id: Icf5e6f9d1a7e3f4abfbe05b3fb0034651a120039
Signed-off-by: Lin Jinhan <troy.lin@rock-chips.com>
This commit is contained in:
Lin Jinhan
2021-04-23 17:51:44 +08:00
committed by Tao Huang
parent 2ab2181d46
commit a26979bf63
10 changed files with 749 additions and 772 deletions
Download Patch File Download Diff File Expand all files Collapse all files

350
drivers/crypto/rockchip/rk_crypto_core.c
View File

@@ -51,25 +51,25 @@
.default_pka_offset = 0x0480,\
}
static int rk_crypto_enable_clk(struct rk_crypto_info *dev)
static int rk_crypto_enable_clk(struct rk_crypto_dev *rk_dev)
{
int ret;
dev_dbg(dev->dev, "clk_bulk_prepare_enable.\n");
dev_dbg(rk_dev->dev, "clk_bulk_prepare_enable.\n");
ret = clk_bulk_prepare_enable(dev->clks_num,
dev->clk_bulks);
ret = clk_bulk_prepare_enable(rk_dev->clks_num,
rk_dev->clk_bulks);
if (ret < 0)
dev_err(dev->dev, "failed to enable clks %d\n", ret);
dev_err(rk_dev->dev, "failed to enable clks %d\n", ret);
return ret;
}
static void rk_crypto_disable_clk(struct rk_crypto_info *dev)
static void rk_crypto_disable_clk(struct rk_crypto_dev *rk_dev)
{
dev_dbg(dev->dev, "clk_bulk_disable_unprepare.\n");
dev_dbg(rk_dev->dev, "clk_bulk_disable_unprepare.\n");
clk_bulk_disable_unprepare(dev->clks_num, dev->clk_bulks);
clk_bulk_disable_unprepare(rk_dev->clks_num, rk_dev->clk_bulks);
}
static int check_alignment(struct scatterlist *sg_src,
@@ -89,190 +89,192 @@ static int check_alignment(struct scatterlist *sg_src,
return (align && (sg_src->length == sg_dst->length));
}
static int rk_load_data(struct rk_crypto_info *dev,
static int rk_load_data(struct rk_crypto_dev *rk_dev,
struct scatterlist *sg_src,
struct scatterlist *sg_dst)
{
int ret = -EINVAL;
unsigned int count;
struct device *dev = rk_dev->dev;
mutex_lock(&dev->mutex);
mutex_lock(&rk_dev->mutex);
dev->aligned = dev->aligned ?
check_alignment(sg_src, sg_dst, dev->align_size) :
dev->aligned;
if (dev->aligned) {
count = min_t(unsigned int, dev->left_bytes, sg_src->length);
dev->left_bytes -= count;
rk_dev->aligned = rk_dev->aligned ?
check_alignment(sg_src, sg_dst, rk_dev->align_size) :
rk_dev->aligned;
if (rk_dev->aligned) {
count = min_t(unsigned int, rk_dev->left_bytes, sg_src->length);
rk_dev->left_bytes -= count;
if (!dma_map_sg(dev->dev, sg_src, 1, DMA_TO_DEVICE)) {
dev_err(dev->dev, "[%s:%d] dma_map_sg(src) error\n",
if (!dma_map_sg(dev, sg_src, 1, DMA_TO_DEVICE)) {
dev_err(dev, "[%s:%d] dma_map_sg(src) error\n",
__func__, __LINE__);
ret = -EINVAL;
goto error;
}
dev->addr_in = sg_dma_address(sg_src);
rk_dev->addr_in = sg_dma_address(sg_src);
if (sg_dst) {
if (!dma_map_sg(dev->dev, sg_dst, 1, DMA_FROM_DEVICE)) {
dev_err(dev->dev,
if (!dma_map_sg(dev, sg_dst, 1, DMA_FROM_DEVICE)) {
dev_err(dev,
"[%s:%d] dma_map_sg(dst) error\n",
__func__, __LINE__);
dma_unmap_sg(dev->dev, sg_src, 1,
dma_unmap_sg(dev, sg_src, 1,
DMA_TO_DEVICE);
ret = -EINVAL;
goto error;
}
dev->addr_out = sg_dma_address(sg_dst);
rk_dev->addr_out = sg_dma_address(sg_dst);
}
} else {
count = (dev->left_bytes > PAGE_SIZE) ?
PAGE_SIZE : dev->left_bytes;
count = (rk_dev->left_bytes > PAGE_SIZE) ?
PAGE_SIZE : rk_dev->left_bytes;
if (!sg_pcopy_to_buffer(dev->first, dev->src_nents,
dev->addr_vir, count,
dev->total - dev->left_bytes)) {
dev_err(dev->dev, "[%s:%d] pcopy err\n",
if (!sg_pcopy_to_buffer(rk_dev->first, rk_dev->src_nents,
rk_dev->addr_vir, count,
rk_dev->total - rk_dev->left_bytes)) {
dev_err(dev, "[%s:%d] pcopy err\n",
__func__, __LINE__);
ret = -EINVAL;
goto error;
}
dev->left_bytes -= count;
sg_init_one(&dev->sg_tmp, dev->addr_vir, count);
if (!dma_map_sg(dev->dev, &dev->sg_tmp, 1, DMA_TO_DEVICE)) {
dev_err(dev->dev, "[%s:%d] dma_map_sg(sg_tmp) error\n",
rk_dev->left_bytes -= count;
sg_init_one(&rk_dev->sg_tmp, rk_dev->addr_vir, count);
if (!dma_map_sg(dev, &rk_dev->sg_tmp, 1, DMA_TO_DEVICE)) {
dev_err(dev, "[%s:%d] dma_map_sg(sg_tmp) error\n",
__func__, __LINE__);
ret = -ENOMEM;
goto error;
}
dev->addr_in = sg_dma_address(&dev->sg_tmp);
rk_dev->addr_in = sg_dma_address(&rk_dev->sg_tmp);
if (sg_dst) {
if (!dma_map_sg(dev->dev, &dev->sg_tmp, 1,
if (!dma_map_sg(dev, &rk_dev->sg_tmp, 1,
DMA_FROM_DEVICE)) {
dev_err(dev->dev,
dev_err(dev,
"[%s:%d] dma_map_sg(sg_tmp) error\n",
__func__, __LINE__);
dma_unmap_sg(dev->dev, &dev->sg_tmp, 1,
dma_unmap_sg(dev, &rk_dev->sg_tmp, 1,
DMA_TO_DEVICE);
ret = -ENOMEM;
goto error;
}
dev->addr_out = sg_dma_address(&dev->sg_tmp);
rk_dev->addr_out = sg_dma_address(&rk_dev->sg_tmp);
}
}
dev->count = count;
rk_dev->count = count;
return 0;
error:
mutex_unlock(&dev->mutex);
mutex_unlock(&rk_dev->mutex);
return ret;
}
static void rk_unload_data(struct rk_crypto_info *dev)
static void rk_unload_data(struct rk_crypto_dev *rk_dev)
{
struct scatterlist *sg_in, *sg_out;
sg_in = dev->aligned ? dev->sg_src : &dev->sg_tmp;
dma_unmap_sg(dev->dev, sg_in, 1, DMA_TO_DEVICE);
sg_in = rk_dev->aligned ? rk_dev->sg_src : &rk_dev->sg_tmp;
dma_unmap_sg(rk_dev->dev, sg_in, 1, DMA_TO_DEVICE);
if (dev->sg_dst) {
sg_out = dev->aligned ? dev->sg_dst : &dev->sg_tmp;
dma_unmap_sg(dev->dev, sg_out, 1, DMA_FROM_DEVICE);
if (rk_dev->sg_dst) {
sg_out = rk_dev->aligned ? rk_dev->sg_dst : &rk_dev->sg_tmp;
dma_unmap_sg(rk_dev->dev, sg_out, 1, DMA_FROM_DEVICE);
}
mutex_unlock(&dev->mutex);
mutex_unlock(&rk_dev->mutex);
}
static irqreturn_t rk_crypto_irq_handle(int irq, void *dev_id)
{
struct rk_crypto_info *dev = platform_get_drvdata(dev_id);
struct rk_crypto_dev *rk_dev = platform_get_drvdata(dev_id);
spin_lock(&dev->lock);
spin_lock(&rk_dev->lock);
if (dev->irq_handle)
dev->irq_handle(irq, dev_id);
if (rk_dev->irq_handle)
rk_dev->irq_handle(irq, dev_id);
tasklet_schedule(&dev->done_task);
tasklet_schedule(&rk_dev->done_task);
spin_unlock(&dev->lock);
spin_unlock(&rk_dev->lock);
return IRQ_HANDLED;
}
static int rk_crypto_enqueue(struct rk_crypto_info *dev,
static int rk_crypto_enqueue(struct rk_crypto_dev *rk_dev,
struct crypto_async_request *async_req)
{
unsigned long flags;
int ret;
spin_lock_irqsave(&dev->lock, flags);
ret = crypto_enqueue_request(&dev->queue, async_req);
if (dev->busy) {
spin_unlock_irqrestore(&dev->lock, flags);
spin_lock_irqsave(&rk_dev->lock, flags);
ret = crypto_enqueue_request(&rk_dev->queue, async_req);
if (rk_dev->busy) {
spin_unlock_irqrestore(&rk_dev->lock, flags);
return ret;
}
dev->busy = true;
spin_unlock_irqrestore(&dev->lock, flags);
tasklet_schedule(&dev->queue_task);
rk_dev->busy = true;
spin_unlock_irqrestore(&rk_dev->lock, flags);
tasklet_schedule(&rk_dev->queue_task);
return ret;
}
static void rk_crypto_queue_task_cb(unsigned long data)
{
struct rk_crypto_info *dev = (struct rk_crypto_info *)data;
struct rk_crypto_dev *rk_dev = (struct rk_crypto_dev *)data;
struct crypto_async_request *async_req, *backlog;
unsigned long flags;
int err = 0;
dev->err = 0;
spin_lock_irqsave(&dev->lock, flags);
backlog = crypto_get_backlog(&dev->queue);
async_req = crypto_dequeue_request(&dev->queue);
rk_dev->err = 0;
spin_lock_irqsave(&rk_dev->lock, flags);
backlog = crypto_get_backlog(&rk_dev->queue);
async_req = crypto_dequeue_request(&rk_dev->queue);
if (!async_req) {
dev->busy = false;
spin_unlock_irqrestore(&dev->lock, flags);
rk_dev->busy = false;
spin_unlock_irqrestore(&rk_dev->lock, flags);
return;
}
spin_unlock_irqrestore(&dev->lock, flags);
spin_unlock_irqrestore(&rk_dev->lock, flags);
if (backlog) {
backlog->complete(backlog, -EINPROGRESS);
backlog = NULL;
}
dev->async_req = async_req;
err = dev->start(dev);
rk_dev->async_req = async_req;
err = rk_dev->start(rk_dev);
if (err)
dev->complete(dev->async_req, err);
rk_dev->complete(rk_dev->async_req, err);
}
static void rk_crypto_done_task_cb(unsigned long data)
{
struct rk_crypto_info *dev = (struct rk_crypto_info *)data;
struct rk_crypto_dev *rk_dev = (struct rk_crypto_dev *)data;
if (dev->err) {
dev->complete(dev->async_req, dev->err);
if (rk_dev->err) {
rk_dev->complete(rk_dev->async_req, rk_dev->err);
return;
}
dev->err = dev->update(dev);
if (dev->err)
dev->complete(dev->async_req, dev->err);
rk_dev->err = rk_dev->update(rk_dev);
if (rk_dev->err)
rk_dev->complete(rk_dev->async_req, rk_dev->err);
}
static struct rk_crypto_tmp *rk_crypto_find_algs(struct rk_crypto_info *crypto_info, char *name)
static struct rk_crypto_algt *rk_crypto_find_algs(struct rk_crypto_dev *rk_dev,
char *name)
{
u32 i;
struct rk_crypto_tmp **algs;
struct rk_crypto_tmp *tmp_algs;
struct rk_crypto_algt **algs;
struct rk_crypto_algt *tmp_algs;
algs = crypto_info->soc_data->total_algs;
algs = rk_dev->soc_data->total_algs;
for (i = 0; i < crypto_info->soc_data->total_algs_num; i++, algs++) {
for (i = 0; i < rk_dev->soc_data->total_algs_num; i++, algs++) {
tmp_algs = *algs;
tmp_algs->dev = crypto_info;
tmp_algs->rk_dev = rk_dev;
if (strcmp(tmp_algs->name, name) == 0)
return tmp_algs;
@@ -281,20 +283,20 @@ static struct rk_crypto_tmp *rk_crypto_find_algs(struct rk_crypto_info *crypto_i
return NULL;
}
static int rk_crypto_register(struct rk_crypto_info *crypto_info)
static int rk_crypto_register(struct rk_crypto_dev *rk_dev)
{
unsigned int i, k;
char **algs_name;
struct rk_crypto_tmp *tmp_algs;
struct rk_crypto_algt *tmp_algs;
struct rk_crypto_soc_data *soc_data;
int err = 0;
soc_data = crypto_info->soc_data;
soc_data = rk_dev->soc_data;
algs_name = soc_data->valid_algs_name;
for (i = 0; i < soc_data->valid_algs_num; i++, algs_name++) {
tmp_algs = rk_crypto_find_algs(crypto_info, *algs_name);
tmp_algs = rk_crypto_find_algs(rk_dev, *algs_name);
if (!tmp_algs) {
CRYPTO_TRACE("%s not matched!!!\n", *algs_name);
continue;
@@ -302,7 +304,7 @@ static int rk_crypto_register(struct rk_crypto_info *crypto_info)
CRYPTO_TRACE("%s matched!!!\n", *algs_name);
tmp_algs->dev = crypto_info;
tmp_algs->rk_dev = rk_dev;
if (tmp_algs->type == ALG_TYPE_CIPHER) {
if (tmp_algs->algo == CIPHER_ALGO_AES &&
@@ -330,7 +332,7 @@ err_cipher_algs:
algs_name = soc_data->valid_algs_name;
for (k = 0; k < i; k++, algs_name++) {
tmp_algs = rk_crypto_find_algs(crypto_info, *algs_name);
tmp_algs = rk_crypto_find_algs(rk_dev, *algs_name);
if (tmp_algs->type == ALG_TYPE_CIPHER)
crypto_unregister_alg(&tmp_algs->alg.crypto);
else if (tmp_algs->type == ALG_TYPE_HASH || tmp_algs->type == ALG_TYPE_HMAC)
@@ -341,16 +343,16 @@ err_cipher_algs:
return err;
}
static void rk_crypto_unregister(struct rk_crypto_info *crypto_info)
static void rk_crypto_unregister(struct rk_crypto_dev *rk_dev)
{
unsigned int i;
char **algs_name;
struct rk_crypto_tmp *tmp_algs;
struct rk_crypto_algt *tmp_algs;
algs_name = crypto_info->soc_data->valid_algs_name;
algs_name = rk_dev->soc_data->valid_algs_name;
for (i = 0; i < crypto_info->soc_data->valid_algs_num; i++, algs_name++) {
tmp_algs = rk_crypto_find_algs(crypto_info, *algs_name);
for (i = 0; i < rk_dev->soc_data->valid_algs_num; i++, algs_name++) {
tmp_algs = rk_crypto_find_algs(rk_dev, *algs_name);
if (tmp_algs->type == ALG_TYPE_CIPHER)
crypto_unregister_alg(&tmp_algs->alg.crypto);
else if (tmp_algs->type == ALG_TYPE_HASH || tmp_algs->type == ALG_TYPE_HMAC)
@@ -360,33 +362,33 @@ static void rk_crypto_unregister(struct rk_crypto_info *crypto_info)
}
}
static void rk_crypto_request(struct rk_crypto_info *dev, const char *name)
static void rk_crypto_request(struct rk_crypto_dev *rk_dev, const char *name)
{
CRYPTO_TRACE("Crypto is requested by %s\n", name);
rk_crypto_enable_clk(dev);
rk_crypto_enable_clk(rk_dev);
}
static void rk_crypto_release(struct rk_crypto_info *dev, const char *name)
static void rk_crypto_release(struct rk_crypto_dev *rk_dev, const char *name)
{
CRYPTO_TRACE("Crypto is released by %s\n", name);
rk_crypto_disable_clk(dev);
rk_crypto_disable_clk(rk_dev);
}
static void rk_crypto_action(void *data)
{
struct rk_crypto_info *crypto_info = data;
struct rk_crypto_dev *rk_dev = data;
if (crypto_info->rst)
reset_control_assert(crypto_info->rst);
if (rk_dev->rst)
reset_control_assert(rk_dev->rst);
}
static const char * const crypto_v2_rsts[] = {
"crypto-rst",
};
static struct rk_crypto_tmp *crypto_v2_algs[] = {
static struct rk_crypto_algt *crypto_v2_algs[] = {
&rk_v2_ecb_sm4_alg, /* ecb(sm4) */
&rk_v2_cbc_sm4_alg, /* cbc(sm4) */
&rk_v2_xts_sm4_alg, /* xts(sm4) */
@@ -417,11 +419,11 @@ static struct rk_crypto_tmp *crypto_v2_algs[] = {
&rk_v2_ahash_md5, /* md5 */
&rk_v2_ahash_sm3, /* sm3 */
&rk_v2_ahash_hmac_sha1, /* hmac(sha1) */
&rk_v2_ahash_hmac_sha256, /* hmac(sha256) */
&rk_v2_ahash_hmac_sha512, /* hmac(sha512) */
&rk_v2_ahash_hmac_md5, /* hmac(md5) */
&rk_v2_ahash_hmac_sm3, /* hmac(sm3) */
&rk_v2_hmac_sha1, /* hmac(sha1) */
&rk_v2_hmac_sha256, /* hmac(sha256) */
&rk_v2_hmac_sha512, /* hmac(sha512) */
&rk_v2_hmac_md5, /* hmac(md5) */
&rk_v2_hmac_sm3, /* hmac(sm3) */
&rk_v2_asym_rsa, /* rsa */
};
@@ -466,7 +468,7 @@ static const char * const crypto_v1_rsts[] = {
"crypto-rst",
};
static struct rk_crypto_tmp *crypto_v1_algs[] = {
static struct rk_crypto_algt *crypto_v1_algs[] = {
&rk_v1_ecb_aes_alg, /* ecb(aes) */
&rk_v1_cbc_aes_alg, /* cbc(aes) */
@@ -520,117 +522,117 @@ static int rk_crypto_probe(struct platform_device *pdev)
struct resource *res;
struct device *dev = &pdev->dev;
struct device_node *np = pdev->dev.of_node;
struct rk_crypto_soc_data *soc_data;
const struct of_device_id *match;
struct rk_crypto_info *crypto_info;
struct rk_crypto_dev *rk_dev;
int err = 0;
crypto_info = devm_kzalloc(&pdev->dev,
sizeof(*crypto_info), GFP_KERNEL);
if (!crypto_info) {
rk_dev = devm_kzalloc(&pdev->dev,
sizeof(*rk_dev), GFP_KERNEL);
if (!rk_dev) {
err = -ENOMEM;
goto err_crypto;
}
match = of_match_node(crypto_of_id_table, np);
crypto_info->soc_data = (struct rk_crypto_soc_data *)match->data;
soc_data = (struct rk_crypto_soc_data *)match->data;
rk_dev->soc_data = soc_data;
if (crypto_info->soc_data->rsts[0]) {
crypto_info->rst =
devm_reset_control_get(dev,
crypto_info->soc_data->rsts[0]);
if (IS_ERR(crypto_info->rst)) {
err = PTR_ERR(crypto_info->rst);
if (soc_data->rsts[0]) {
rk_dev->rst =
devm_reset_control_get(dev, soc_data->rsts[0]);
if (IS_ERR(rk_dev->rst)) {
err = PTR_ERR(rk_dev->rst);
goto err_crypto;
}
reset_control_assert(crypto_info->rst);
reset_control_assert(rk_dev->rst);
usleep_range(10, 20);
reset_control_deassert(crypto_info->rst);
reset_control_deassert(rk_dev->rst);
}
err = devm_add_action_or_reset(dev, rk_crypto_action, crypto_info);
err = devm_add_action_or_reset(dev, rk_crypto_action, rk_dev);
if (err)
goto err_crypto;
spin_lock_init(&crypto_info->lock);
spin_lock_init(&rk_dev->lock);
/* get crypto base */
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
crypto_info->reg = devm_ioremap_resource(&pdev->dev, res);
if (IS_ERR(crypto_info->reg)) {
err = PTR_ERR(crypto_info->reg);
rk_dev->reg = devm_ioremap_resource(dev, res);
if (IS_ERR(rk_dev->reg)) {
err = PTR_ERR(rk_dev->reg);
goto err_crypto;
}
/* get pka base, if pka reg not set, pka reg = crypto + pka offset */
res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
crypto_info->pka_reg = devm_ioremap_resource(&pdev->dev, res);
if (IS_ERR(crypto_info->pka_reg))
crypto_info->pka_reg = crypto_info->reg + crypto_info->soc_data->default_pka_offset;
rk_dev->pka_reg = devm_ioremap_resource(dev, res);
if (IS_ERR(rk_dev->pka_reg))
rk_dev->pka_reg = rk_dev->reg + soc_data->default_pka_offset;
crypto_info->clks_num = devm_clk_bulk_get_all(&pdev->dev, &crypto_info->clk_bulks);
if (crypto_info->clks_num < 0) {
dev_err(&pdev->dev, "failed to get clks property\n");
rk_dev->clks_num = devm_clk_bulk_get_all(dev, &rk_dev->clk_bulks);
if (rk_dev->clks_num < 0) {
dev_err(dev, "failed to get clks property\n");
goto err_crypto;
}
crypto_info->irq = platform_get_irq(pdev, 0);
if (crypto_info->irq < 0) {
dev_warn(crypto_info->dev,
rk_dev->irq = platform_get_irq(pdev, 0);
if (rk_dev->irq < 0) {
dev_warn(dev,
"control Interrupt is not available.\n");
err = crypto_info->irq;
err = rk_dev->irq;
goto err_crypto;
}
err = devm_request_irq(&pdev->dev, crypto_info->irq,
err = devm_request_irq(dev, rk_dev->irq,
rk_crypto_irq_handle, IRQF_SHARED,
"rk-crypto", pdev);
if (err) {
dev_err(crypto_info->dev, "irq request failed.\n");
dev_err(dev, "irq request failed.\n");
goto err_crypto;
}
crypto_info->dev = &pdev->dev;
rk_dev->dev = dev;
crypto_info->hw_info =
devm_kzalloc(&pdev->dev,
crypto_info->soc_data->hw_info_size, GFP_KERNEL);
if (!crypto_info->hw_info) {
rk_dev->hw_info =
devm_kzalloc(dev, soc_data->hw_info_size, GFP_KERNEL);
if (!rk_dev->hw_info) {
err = -ENOMEM;
goto err_crypto;
}
err = crypto_info->soc_data->hw_init(&pdev->dev, crypto_info->hw_info);
err = soc_data->hw_init(dev, rk_dev->hw_info);
if (err) {
dev_err(crypto_info->dev, "hw_init failed.\n");
dev_err(dev, "hw_init failed.\n");
goto err_crypto;
}
crypto_info->addr_vir = (char *)__get_free_page(GFP_KERNEL);
if (!crypto_info->addr_vir) {
rk_dev->addr_vir = (char *)__get_free_page(GFP_KERNEL);
if (!rk_dev->addr_vir) {
err = -ENOMEM;
dev_err(crypto_info->dev, "__get_free_page failed.\n");
dev_err(dev, "__get_free_page failed.\n");
goto err_crypto;
}
platform_set_drvdata(pdev, crypto_info);
platform_set_drvdata(pdev, rk_dev);
tasklet_init(&crypto_info->queue_task,
rk_crypto_queue_task_cb, (unsigned long)crypto_info);
tasklet_init(&crypto_info->done_task,
rk_crypto_done_task_cb, (unsigned long)crypto_info);
crypto_init_queue(&crypto_info->queue, 50);
tasklet_init(&rk_dev->queue_task,
rk_crypto_queue_task_cb, (unsigned long)rk_dev);
tasklet_init(&rk_dev->done_task,
rk_crypto_done_task_cb, (unsigned long)rk_dev);
crypto_init_queue(&rk_dev->queue, 50);
mutex_init(&crypto_info->mutex);
mutex_init(&rk_dev->mutex);
crypto_info->request_crypto = rk_crypto_request;
crypto_info->release_crypto = rk_crypto_release;
crypto_info->load_data = rk_load_data;
crypto_info->unload_data = rk_unload_data;
crypto_info->enqueue = rk_crypto_enqueue;
crypto_info->busy = false;
rk_dev->request_crypto = rk_crypto_request;
rk_dev->release_crypto = rk_crypto_release;
rk_dev->load_data = rk_load_data;
rk_dev->unload_data = rk_unload_data;
rk_dev->enqueue = rk_crypto_enqueue;
rk_dev->busy = false;
err = rk_crypto_register(crypto_info);
err = rk_crypto_register(rk_dev);
if (err) {
dev_err(dev, "err in register alg");
goto err_register_alg;
@@ -640,27 +642,27 @@ static int rk_crypto_probe(struct platform_device *pdev)
return 0;
err_register_alg:
mutex_destroy(&crypto_info->mutex);
tasklet_kill(&crypto_info->queue_task);
tasklet_kill(&crypto_info->done_task);
mutex_destroy(&rk_dev->mutex);
tasklet_kill(&rk_dev->queue_task);
tasklet_kill(&rk_dev->done_task);
err_crypto:
return err;
}
static int rk_crypto_remove(struct platform_device *pdev)
{
struct rk_crypto_info *crypto_info = platform_get_drvdata(pdev);
struct rk_crypto_dev *rk_dev = platform_get_drvdata(pdev);
rk_crypto_unregister(crypto_info);
tasklet_kill(&crypto_info->done_task);
tasklet_kill(&crypto_info->queue_task);
rk_crypto_unregister(rk_dev);
tasklet_kill(&rk_dev->done_task);
tasklet_kill(&rk_dev->queue_task);
if (crypto_info->addr_vir)
free_page((unsigned long)crypto_info->addr_vir);
if (rk_dev->addr_vir)
free_page((unsigned long)rk_dev->addr_vir);
crypto_info->soc_data->hw_deinit(&pdev->dev, crypto_info->hw_info);
rk_dev->soc_data->hw_deinit(&pdev->dev, rk_dev->hw_info);
mutex_destroy(&crypto_info->mutex);
mutex_destroy(&rk_dev->mutex);
return 0;
}

49
drivers/crypto/rockchip/rk_crypto_core.h
View File

@@ -27,7 +27,7 @@
struct rk_crypto_soc_data {
char **valid_algs_name;
int valid_algs_num;
struct rk_crypto_tmp **total_algs;
struct rk_crypto_algt **total_algs;
int total_algs_num;
const char * const *rsts;
int rsts_num;
@@ -38,7 +38,7 @@ struct rk_crypto_soc_data {
void (*hw_deinit)(struct device *dev, void *hw_info);
};
struct rk_crypto_info {
struct rk_crypto_dev {
struct device *dev;
struct reset_control *rst;
void __iomem *reg;
@@ -47,49 +47,54 @@ struct rk_crypto_info {
struct crypto_queue queue;
struct tasklet_struct queue_task;
struct tasklet_struct done_task;
struct crypto_async_request *async_req;
int err;
void *hw_info;
struct rk_crypto_soc_data *soc_data;
int clks_num;
struct clk_bulk_data *clk_bulks;
/* device lock */
spinlock_t lock;
struct mutex mutex;
/* the public variable */
struct crypto_async_request *async_req;
void *addr_vir;
struct scatterlist *sg_src;
struct scatterlist *sg_dst;
struct scatterlist sg_tmp;
struct scatterlist *first;
struct rk_crypto_soc_data *soc_data;
int clks_num;
struct clk_bulk_data *clk_bulks;
unsigned int left_bytes;
void *addr_vir;
int aligned;
int align_size;
size_t src_nents;
size_t dst_nents;
unsigned int total;
unsigned int count;
unsigned int left_bytes;
dma_addr_t addr_in;
dma_addr_t addr_out;
int aligned;
int align_size;
bool busy;
void (*request_crypto)(struct rk_crypto_info *dev, const char *name);
void (*release_crypto)(struct rk_crypto_info *dev, const char *name);
int (*start)(struct rk_crypto_info *dev);
int (*update)(struct rk_crypto_info *dev);
void (*request_crypto)(struct rk_crypto_dev *rk_dev, const char *name);
void (*release_crypto)(struct rk_crypto_dev *rk_dev, const char *name);
int (*start)(struct rk_crypto_dev *rk_dev);
int (*update)(struct rk_crypto_dev *rk_dev);
void (*complete)(struct crypto_async_request *base, int err);
int (*irq_handle)(int irq, void *dev_id);
int (*load_data)(struct rk_crypto_info *dev,
int (*load_data)(struct rk_crypto_dev *rk_dev,
struct scatterlist *sg_src,
struct scatterlist *sg_dst);
void (*unload_data)(struct rk_crypto_info *dev);
int (*enqueue)(struct rk_crypto_info *dev,
void (*unload_data)(struct rk_crypto_dev *rk_dev);
int (*enqueue)(struct rk_crypto_dev *rk_dev,
struct crypto_async_request *async_req);
};
/* the private variable of hash */
struct rk_ahash_ctx {
struct rk_crypto_info *dev;
struct rk_crypto_dev *rk_dev;
u8 authkey[SHA512_BLOCK_SIZE];
/* for fallback */
@@ -104,7 +109,7 @@ struct rk_ahash_rctx {
/* the private variable of cipher */
struct rk_cipher_ctx {
struct rk_crypto_info *dev;
struct rk_crypto_dev *rk_dev;
unsigned char key[AES_MAX_KEY_SIZE * 2];
unsigned int keylen;
u32 mode;
@@ -119,7 +124,7 @@ struct rk_rsa_ctx {
struct rk_bignum *e;
struct rk_bignum *d;
struct rk_crypto_info *dev;
struct rk_crypto_dev *rk_dev;
};
enum alg_type {
@@ -129,8 +134,8 @@ enum alg_type {
ALG_TYPE_ASYM,
};
struct rk_crypto_tmp {
struct rk_crypto_info *dev;
struct rk_crypto_algt {
struct rk_crypto_dev *rk_dev;
union {
struct crypto_alg crypto;
struct ahash_alg hash;

18
drivers/crypto/rockchip/rk_crypto_v1.h
View File

@@ -11,18 +11,18 @@ struct rk_hw_crypto_v1_info {
int reserved;
};
extern struct rk_crypto_tmp rk_v1_ecb_aes_alg;
extern struct rk_crypto_tmp rk_v1_cbc_aes_alg;
extern struct rk_crypto_algt rk_v1_ecb_aes_alg;
extern struct rk_crypto_algt rk_v1_cbc_aes_alg;
extern struct rk_crypto_tmp rk_v1_ecb_des_alg;
extern struct rk_crypto_tmp rk_v1_cbc_des_alg;
extern struct rk_crypto_algt rk_v1_ecb_des_alg;
extern struct rk_crypto_algt rk_v1_cbc_des_alg;
extern struct rk_crypto_tmp rk_v1_ecb_des3_ede_alg;
extern struct rk_crypto_tmp rk_v1_cbc_des3_ede_alg;
extern struct rk_crypto_algt rk_v1_ecb_des3_ede_alg;
extern struct rk_crypto_algt rk_v1_cbc_des3_ede_alg;
extern struct rk_crypto_tmp rk_v1_ahash_sha1;
extern struct rk_crypto_tmp rk_v1_ahash_sha256;
extern struct rk_crypto_tmp rk_v1_ahash_md5;
extern struct rk_crypto_algt rk_v1_ahash_sha1;
extern struct rk_crypto_algt rk_v1_ahash_sha256;
extern struct rk_crypto_algt rk_v1_ahash_md5;
int rk_hw_crypto_v1_init(struct device *dev, void *hw_info);
void rk_hw_crypto_v1_deinit(struct device *dev, void *hw_info);

215
drivers/crypto/rockchip/rk_crypto_v1_ablkcipher.c
View File

@@ -16,15 +16,15 @@
static int rk_crypto_irq_handle(int irq, void *dev_id)
{
struct rk_crypto_info *dev = platform_get_drvdata(dev_id);
struct rk_crypto_dev *rk_dev = platform_get_drvdata(dev_id);
u32 interrupt_status;
interrupt_status = CRYPTO_READ(dev, RK_CRYPTO_INTSTS);
CRYPTO_WRITE(dev, RK_CRYPTO_INTSTS, interrupt_status);
interrupt_status = CRYPTO_READ(rk_dev, RK_CRYPTO_INTSTS);
CRYPTO_WRITE(rk_dev, RK_CRYPTO_INTSTS, interrupt_status);
if (interrupt_status & 0x0a) {
dev_warn(dev->dev, "DMA Error\n");
dev->err = -EFAULT;
dev_warn(rk_dev->dev, "DMA Error\n");
rk_dev->err = -EFAULT;
}
return 0;
@@ -36,13 +36,13 @@ static void rk_crypto_complete(struct crypto_async_request *base, int err)
base->complete(base, err);
}
static int rk_handle_req(struct rk_crypto_info *dev,
static int rk_handle_req(struct rk_crypto_dev *rk_dev,
struct ablkcipher_request *req)
{
if (!IS_ALIGNED(req->nbytes, dev->align_size))
if (!IS_ALIGNED(req->nbytes, rk_dev->align_size))
return -EINVAL;
else
return dev->enqueue(dev, &req->base);
return rk_dev->enqueue(rk_dev, &req->base);
}
static int rk_get_bc(u32 algo, u32 mode, u32 *bc_val)
@@ -85,10 +85,10 @@ static int rk_cipher_setkey(struct crypto_ablkcipher *cipher,
struct crypto_tfm *tfm = crypto_ablkcipher_tfm(cipher);
struct rk_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
struct crypto_alg *alg = tfm->__crt_alg;
struct rk_crypto_tmp *algt;
struct rk_crypto_algt *algt;
u32 tmp[DES_EXPKEY_WORDS];
algt = container_of(alg, struct rk_crypto_tmp, alg.crypto);
algt = container_of(alg, struct rk_crypto_algt, alg.crypto);
CRYPTO_MSG("algo = %x, mode = %x, key_len = %d\n",
algt->algo, algt->mode, keylen);
@@ -134,11 +134,11 @@ static int rk_cipher_encrypt(struct ablkcipher_request *req)
struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
struct rk_cipher_ctx *ctx = crypto_ablkcipher_ctx(tfm);
struct crypto_alg *alg = tfm->base.__crt_alg;
struct rk_crypto_info *dev = ctx->dev;
struct rk_crypto_tmp *algt;
struct rk_crypto_dev *rk_dev = ctx->rk_dev;
struct rk_crypto_algt *algt;
int ret;
algt = container_of(alg, struct rk_crypto_tmp, alg.crypto);
algt = container_of(alg, struct rk_crypto_algt, alg.crypto);
ret = rk_get_bc(algt->algo, algt->mode, &ctx->mode);
if (ret)
@@ -146,7 +146,7 @@ static int rk_cipher_encrypt(struct ablkcipher_request *req)
CRYPTO_MSG("ctx->mode = %x\n", ctx->mode);
return rk_handle_req(dev, req);
return rk_handle_req(rk_dev, req);
}
static int rk_cipher_decrypt(struct ablkcipher_request *req)
@@ -154,11 +154,11 @@ static int rk_cipher_decrypt(struct ablkcipher_request *req)
struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
struct rk_cipher_ctx *ctx = crypto_ablkcipher_ctx(tfm);
struct crypto_alg *alg = tfm->base.__crt_alg;
struct rk_crypto_info *dev = ctx->dev;
struct rk_crypto_tmp *algt;
struct rk_crypto_dev *rk_dev = ctx->rk_dev;
struct rk_crypto_algt *algt;
int ret;
algt = container_of(alg, struct rk_crypto_tmp, alg.crypto);
algt = container_of(alg, struct rk_crypto_algt, alg.crypto);
ret = rk_get_bc(algt->algo, algt->mode, &ctx->mode);
if (ret)
@@ -168,13 +168,13 @@ static int rk_cipher_decrypt(struct ablkcipher_request *req)
CRYPTO_MSG("ctx->mode = %x\n", ctx->mode);
return rk_handle_req(dev, req);
return rk_handle_req(rk_dev, req);
}
static void rk_ablk_hw_init(struct rk_crypto_info *dev)
static void rk_ablk_hw_init(struct rk_crypto_dev *rk_dev)
{
struct ablkcipher_request *req =
ablkcipher_request_cast(dev->async_req);
ablkcipher_request_cast(rk_dev->async_req);
struct crypto_ablkcipher *cipher = crypto_ablkcipher_reqtfm(req);
struct crypto_tfm *tfm = crypto_ablkcipher_tfm(cipher);
struct rk_cipher_ctx *ctx = crypto_ablkcipher_ctx(cipher);
@@ -184,16 +184,17 @@ static void rk_ablk_hw_init(struct rk_crypto_info *dev)
ivsize = crypto_ablkcipher_ivsize(cipher);
if (block == DES_BLOCK_SIZE) {
memcpy_toio(ctx->dev->reg + RK_CRYPTO_TDES_KEY1_0,
memcpy_toio(ctx->rk_dev->reg + RK_CRYPTO_TDES_KEY1_0,
ctx->key, ctx->keylen);
ctx->mode |= RK_CRYPTO_TDES_FIFO_MODE |
RK_CRYPTO_TDES_BYTESWAP_KEY |
RK_CRYPTO_TDES_BYTESWAP_IV;
CRYPTO_WRITE(dev, RK_CRYPTO_TDES_CTRL, ctx->mode);
memcpy_toio(dev->reg + RK_CRYPTO_TDES_IV_0, req->info, ivsize);
CRYPTO_WRITE(rk_dev, RK_CRYPTO_TDES_CTRL, ctx->mode);
memcpy_toio(rk_dev->reg + RK_CRYPTO_TDES_IV_0,
req->info, ivsize);
conf_reg = RK_CRYPTO_DESSEL;
} else {
memcpy_toio(ctx->dev->reg + RK_CRYPTO_AES_KEY_0,
memcpy_toio(ctx->rk_dev->reg + RK_CRYPTO_AES_KEY_0,
ctx->key, ctx->keylen);
ctx->mode |= RK_CRYPTO_AES_FIFO_MODE |
RK_CRYPTO_AES_KEY_CHANGE |
@@ -203,98 +204,99 @@ static void rk_ablk_hw_init(struct rk_crypto_info *dev)
ctx->mode |= RK_CRYPTO_AES_192BIT_key;
else if (ctx->keylen == AES_KEYSIZE_256)
ctx->mode |= RK_CRYPTO_AES_256BIT_key;
CRYPTO_WRITE(dev, RK_CRYPTO_AES_CTRL, ctx->mode);
memcpy_toio(dev->reg + RK_CRYPTO_AES_IV_0, req->info, ivsize);
CRYPTO_WRITE(rk_dev, RK_CRYPTO_AES_CTRL, ctx->mode);
memcpy_toio(rk_dev->reg + RK_CRYPTO_AES_IV_0,
req->info, ivsize);
}
conf_reg |= RK_CRYPTO_BYTESWAP_BTFIFO |
RK_CRYPTO_BYTESWAP_BRFIFO;
CRYPTO_WRITE(dev, RK_CRYPTO_CONF, conf_reg);
CRYPTO_WRITE(dev, RK_CRYPTO_INTENA,
CRYPTO_WRITE(rk_dev, RK_CRYPTO_CONF, conf_reg);
CRYPTO_WRITE(rk_dev, RK_CRYPTO_INTENA,
RK_CRYPTO_BCDMA_ERR_ENA | RK_CRYPTO_BCDMA_DONE_ENA);
}
static void crypto_dma_start(struct rk_crypto_info *dev)
static void crypto_dma_start(struct rk_crypto_dev *rk_dev)
{
CRYPTO_WRITE(dev, RK_CRYPTO_BRDMAS, dev->addr_in);
CRYPTO_WRITE(dev, RK_CRYPTO_BRDMAL, dev->count / 4);
CRYPTO_WRITE(dev, RK_CRYPTO_BTDMAS, dev->addr_out);
CRYPTO_WRITE(dev, RK_CRYPTO_CTRL, RK_CRYPTO_BLOCK_START |
CRYPTO_WRITE(rk_dev, RK_CRYPTO_BRDMAS, rk_dev->addr_in);
CRYPTO_WRITE(rk_dev, RK_CRYPTO_BRDMAL, rk_dev->count / 4);
CRYPTO_WRITE(rk_dev, RK_CRYPTO_BTDMAS, rk_dev->addr_out);
CRYPTO_WRITE(rk_dev, RK_CRYPTO_CTRL, RK_CRYPTO_BLOCK_START |
_SBF(RK_CRYPTO_BLOCK_START, 16));
}
static int rk_set_data_start(struct rk_crypto_info *dev)
static int rk_set_data_start(struct rk_crypto_dev *rk_dev)
{
int err;
struct ablkcipher_request *req =
ablkcipher_request_cast(dev->async_req);
ablkcipher_request_cast(rk_dev->async_req);
struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
struct rk_cipher_ctx *ctx = crypto_ablkcipher_ctx(tfm);
u32 ivsize = crypto_ablkcipher_ivsize(tfm);
u8 *src_last_blk = page_address(sg_page(dev->sg_src)) +
dev->sg_src->offset + dev->sg_src->length - ivsize;
u8 *src_last_blk = page_address(sg_page(rk_dev->sg_src)) +
rk_dev->sg_src->offset + rk_dev->sg_src->length - ivsize;
/* Store the iv that need to be updated in chain mode.
* And update the IV buffer to contain the next IV for decryption mode.
*/
if (ctx->mode & RK_CRYPTO_DEC) {
memcpy(ctx->iv, src_last_blk, ivsize);
sg_pcopy_to_buffer(dev->first, dev->src_nents, req->info,
ivsize, dev->total - ivsize);
sg_pcopy_to_buffer(rk_dev->first, rk_dev->src_nents, req->info,
ivsize, rk_dev->total - ivsize);
}
err = dev->load_data(dev, dev->sg_src, dev->sg_dst);
err = rk_dev->load_data(rk_dev, rk_dev->sg_src, rk_dev->sg_dst);
if (!err)
crypto_dma_start(dev);
crypto_dma_start(rk_dev);
return err;
}
static int rk_ablk_start(struct rk_crypto_info *dev)
static int rk_ablk_start(struct rk_crypto_dev *rk_dev)
{
struct ablkcipher_request *req =
ablkcipher_request_cast(dev->async_req);
ablkcipher_request_cast(rk_dev->async_req);
unsigned long flags;
int err = 0;
dev->left_bytes = req->nbytes;
dev->total = req->nbytes;
dev->sg_src = req->src;
dev->first = req->src;
dev->src_nents = sg_nents(req->src);
dev->sg_dst = req->dst;
dev->dst_nents = sg_nents(req->dst);
dev->aligned = 1;
rk_dev->left_bytes = req->nbytes;
rk_dev->total = req->nbytes;
rk_dev->sg_src = req->src;
rk_dev->first = req->src;
rk_dev->src_nents = sg_nents(req->src);
rk_dev->sg_dst = req->dst;
rk_dev->dst_nents = sg_nents(req->dst);
rk_dev->aligned = 1;
spin_lock_irqsave(&dev->lock, flags);
rk_ablk_hw_init(dev);
err = rk_set_data_start(dev);
spin_unlock_irqrestore(&dev->lock, flags);
spin_lock_irqsave(&rk_dev->lock, flags);
rk_ablk_hw_init(rk_dev);
err = rk_set_data_start(rk_dev);
spin_unlock_irqrestore(&rk_dev->lock, flags);
return err;
}
static void rk_iv_copyback(struct rk_crypto_info *dev)
static void rk_iv_copyback(struct rk_crypto_dev *rk_dev)
{
struct ablkcipher_request *req =
ablkcipher_request_cast(dev->async_req);
ablkcipher_request_cast(rk_dev->async_req);
struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
struct rk_cipher_ctx *ctx = crypto_ablkcipher_ctx(tfm);
u32 ivsize = crypto_ablkcipher_ivsize(tfm);
/* Update the IV buffer to contain the next IV for encryption mode. */
if (!(ctx->mode & RK_CRYPTO_DEC) && req->info) {
if (dev->aligned) {
memcpy(req->info, sg_virt(dev->sg_dst) +
dev->sg_dst->length - ivsize, ivsize);
if (rk_dev->aligned) {
memcpy(req->info, sg_virt(rk_dev->sg_dst) +
rk_dev->sg_dst->length - ivsize, ivsize);
} else {
memcpy(req->info, dev->addr_vir +
dev->count - ivsize, ivsize);
memcpy(req->info, rk_dev->addr_vir +
rk_dev->count - ivsize, ivsize);
}
}
}
static void rk_update_iv(struct rk_crypto_info *dev)
static void rk_update_iv(struct rk_crypto_dev *rk_dev)
{
struct ablkcipher_request *req =
ablkcipher_request_cast(dev->async_req);
ablkcipher_request_cast(rk_dev->async_req);
struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
struct rk_cipher_ctx *ctx = crypto_ablkcipher_ctx(tfm);
u32 ivsize = crypto_ablkcipher_ivsize(tfm);
@@ -303,54 +305,55 @@ static void rk_update_iv(struct rk_crypto_info *dev)
if (ctx->mode & RK_CRYPTO_DEC) {
new_iv = ctx->iv;
} else {
new_iv = page_address(sg_page(dev->sg_dst)) +
dev->sg_dst->offset + dev->sg_dst->length - ivsize;
new_iv = page_address(sg_page(rk_dev->sg_dst)) +
rk_dev->sg_dst->offset +
rk_dev->sg_dst->length - ivsize;
}
if (ivsize == DES_BLOCK_SIZE)
memcpy_toio(dev->reg + RK_CRYPTO_TDES_IV_0, new_iv, ivsize);
memcpy_toio(rk_dev->reg + RK_CRYPTO_TDES_IV_0, new_iv, ivsize);
else if (ivsize == AES_BLOCK_SIZE)
memcpy_toio(dev->reg + RK_CRYPTO_AES_IV_0, new_iv, ivsize);
memcpy_toio(rk_dev->reg + RK_CRYPTO_AES_IV_0, new_iv, ivsize);
}
/* return:
* true some err was occurred
* fault no err, continue
*/
static int rk_ablk_rx(struct rk_crypto_info *dev)
static int rk_ablk_rx(struct rk_crypto_dev *rk_dev)
{
int err = 0;
struct ablkcipher_request *req =
ablkcipher_request_cast(dev->async_req);
ablkcipher_request_cast(rk_dev->async_req);
dev->unload_data(dev);
if (!dev->aligned) {
if (!sg_pcopy_from_buffer(req->dst, dev->dst_nents,
dev->addr_vir, dev->count,
dev->total - dev->left_bytes -
dev->count)) {
rk_dev->unload_data(rk_dev);
if (!rk_dev->aligned) {
if (!sg_pcopy_from_buffer(req->dst, rk_dev->dst_nents,
rk_dev->addr_vir, rk_dev->count,
rk_dev->total - rk_dev->left_bytes -
rk_dev->count)) {
err = -EINVAL;
goto out_rx;
}
}
if (dev->left_bytes) {
rk_update_iv(dev);
if (dev->aligned) {
if (sg_is_last(dev->sg_src)) {
dev_err(dev->dev, "[%s:%d] Lack of data\n",
if (rk_dev->left_bytes) {
rk_update_iv(rk_dev);
if (rk_dev->aligned) {
if (sg_is_last(rk_dev->sg_src)) {
dev_err(rk_dev->dev, "[%s:%d] Lack of data\n",
__func__, __LINE__);
err = -ENOMEM;
goto out_rx;
}
dev->sg_src = sg_next(dev->sg_src);
dev->sg_dst = sg_next(dev->sg_dst);
rk_dev->sg_src = sg_next(rk_dev->sg_src);
rk_dev->sg_dst = sg_next(rk_dev->sg_dst);
}
err = rk_set_data_start(dev);
err = rk_set_data_start(rk_dev);
} else {
rk_iv_copyback(dev);
rk_iv_copyback(rk_dev);
/* here show the calculation is over without any err */
dev->complete(dev->async_req, 0);
tasklet_schedule(&dev->queue_task);
rk_dev->complete(rk_dev->async_req, 0);
tasklet_schedule(&rk_dev->queue_task);
}
out_rx:
return err;
@@ -360,24 +363,24 @@ static int rk_ablk_cra_init(struct crypto_tfm *tfm)
{
struct rk_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
struct crypto_alg *alg = tfm->__crt_alg;
struct rk_crypto_tmp *algt;
struct rk_crypto_info *info;
struct rk_crypto_algt *algt;
struct rk_crypto_dev *rk_dev;
algt = container_of(alg, struct rk_crypto_tmp, alg.crypto);
info = algt->dev;
algt = container_of(alg, struct rk_crypto_algt, alg.crypto);
rk_dev = algt->rk_dev;
if (!info->request_crypto)
if (!rk_dev->request_crypto)
return -EFAULT;
info->request_crypto(info, crypto_tfm_alg_name(tfm));
rk_dev->request_crypto(rk_dev, crypto_tfm_alg_name(tfm));
info->align_size = crypto_tfm_alg_alignmask(tfm) + 1;
info->start = rk_ablk_start;
info->update = rk_ablk_rx;
info->complete = rk_crypto_complete;
info->irq_handle = rk_crypto_irq_handle;
rk_dev->align_size = crypto_tfm_alg_alignmask(tfm) + 1;
rk_dev->start = rk_ablk_start;
rk_dev->update = rk_ablk_rx;
rk_dev->complete = rk_crypto_complete;
rk_dev->irq_handle = rk_crypto_irq_handle;
ctx->dev = info;
ctx->rk_dev = rk_dev;
return 0;
}
@@ -386,7 +389,7 @@ static void rk_ablk_cra_exit(struct crypto_tfm *tfm)
{
struct rk_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
ctx->dev->release_crypto(ctx->dev, crypto_tfm_alg_name(tfm));
ctx->rk_dev->release_crypto(ctx->rk_dev, crypto_tfm_alg_name(tfm));
}
int rk_hw_crypto_v1_init(struct device *dev, void *hw_info)
@@ -399,20 +402,20 @@ void rk_hw_crypto_v1_deinit(struct device *dev, void *hw_info)
}
struct rk_crypto_tmp rk_v1_ecb_aes_alg =
struct rk_crypto_algt rk_v1_ecb_aes_alg =
RK_CIPHER_ALGO_INIT(AES, ECB, ecb(aes), ecb-aes-rk);
struct rk_crypto_tmp rk_v1_cbc_aes_alg =
struct rk_crypto_algt rk_v1_cbc_aes_alg =
RK_CIPHER_ALGO_INIT(AES, CBC, cbc(aes), cbc-aes-rk);
struct rk_crypto_tmp rk_v1_ecb_des_alg =
struct rk_crypto_algt rk_v1_ecb_des_alg =
RK_CIPHER_ALGO_INIT(DES, ECB, ecb(des), ecb-des-rk);
struct rk_crypto_tmp rk_v1_cbc_des_alg =
struct rk_crypto_algt rk_v1_cbc_des_alg =
RK_CIPHER_ALGO_INIT(DES, CBC, cbc(des), cbc-des-rk);
struct rk_crypto_tmp rk_v1_ecb_des3_ede_alg =
struct rk_crypto_algt rk_v1_ecb_des3_ede_alg =
RK_CIPHER_ALGO_INIT(DES3_EDE, ECB, ecb(des3_ede), ecb-des3_ede-rk);
struct rk_crypto_tmp rk_v1_cbc_des3_ede_alg =
struct rk_crypto_algt rk_v1_cbc_des3_ede_alg =
RK_CIPHER_ALGO_INIT(DES3_EDE, CBC, cbc(des3_ede), cbc-des3_ede-rk);

135
drivers/crypto/rockchip/rk_crypto_v1_ahash.c
View File

@@ -19,15 +19,15 @@
static int rk_crypto_irq_handle(int irq, void *dev_id)
{
struct rk_crypto_info *dev = platform_get_drvdata(dev_id);
struct rk_crypto_dev *rk_dev = platform_get_drvdata(dev_id);
u32 interrupt_status;
interrupt_status = CRYPTO_READ(dev, RK_CRYPTO_INTSTS);
CRYPTO_WRITE(dev, RK_CRYPTO_INTSTS, interrupt_status);
interrupt_status = CRYPTO_READ(rk_dev, RK_CRYPTO_INTSTS);
CRYPTO_WRITE(rk_dev, RK_CRYPTO_INTSTS, interrupt_status);
if (interrupt_status & 0x0a) {
dev_warn(dev->dev, "DMA Error\n");
dev->err = -EFAULT;
dev_warn(rk_dev->dev, "DMA Error\n");
rk_dev->err = -EFAULT;
}
return 0;
@@ -61,37 +61,37 @@ static void rk_ahash_crypto_complete(struct crypto_async_request *base, int err)
base->complete(base, err);
}
static void rk_ahash_reg_init(struct rk_crypto_info *dev)
static void rk_ahash_reg_init(struct rk_crypto_dev *rk_dev)
{
struct ahash_request *req = ahash_request_cast(dev->async_req);
struct ahash_request *req = ahash_request_cast(rk_dev->async_req);
struct rk_ahash_rctx *rctx = ahash_request_ctx(req);
int reg_status = 0;
reg_status = CRYPTO_READ(dev, RK_CRYPTO_CTRL) |
reg_status = CRYPTO_READ(rk_dev, RK_CRYPTO_CTRL) |
RK_CRYPTO_HASH_FLUSH | _SBF(0xffff, 16);
CRYPTO_WRITE(dev, RK_CRYPTO_CTRL, reg_status);
CRYPTO_WRITE(rk_dev, RK_CRYPTO_CTRL, reg_status);
reg_status = CRYPTO_READ(dev, RK_CRYPTO_CTRL);
reg_status = CRYPTO_READ(rk_dev, RK_CRYPTO_CTRL);
reg_status &= (~RK_CRYPTO_HASH_FLUSH);
reg_status |= _SBF(0xffff, 16);
CRYPTO_WRITE(dev, RK_CRYPTO_CTRL, reg_status);
CRYPTO_WRITE(rk_dev, RK_CRYPTO_CTRL, reg_status);
memset_io(dev->reg + RK_CRYPTO_HASH_DOUT_0, 0, 32);
memset_io(rk_dev->reg + RK_CRYPTO_HASH_DOUT_0, 0, 32);
CRYPTO_WRITE(dev, RK_CRYPTO_INTENA, RK_CRYPTO_HRDMA_ERR_ENA |
CRYPTO_WRITE(rk_dev, RK_CRYPTO_INTENA, RK_CRYPTO_HRDMA_ERR_ENA |
RK_CRYPTO_HRDMA_DONE_ENA);
CRYPTO_WRITE(dev, RK_CRYPTO_INTSTS, RK_CRYPTO_HRDMA_ERR_INT |
CRYPTO_WRITE(rk_dev, RK_CRYPTO_INTSTS, RK_CRYPTO_HRDMA_ERR_INT |
RK_CRYPTO_HRDMA_DONE_INT);
CRYPTO_WRITE(dev, RK_CRYPTO_HASH_CTRL, rctx->mode |
CRYPTO_WRITE(rk_dev, RK_CRYPTO_HASH_CTRL, rctx->mode |
RK_CRYPTO_HASH_SWAP_DO);
CRYPTO_WRITE(dev, RK_CRYPTO_CONF, RK_CRYPTO_BYTESWAP_HRFIFO |
CRYPTO_WRITE(rk_dev, RK_CRYPTO_CONF, RK_CRYPTO_BYTESWAP_HRFIFO |
RK_CRYPTO_BYTESWAP_BRFIFO |
RK_CRYPTO_BYTESWAP_BTFIFO);
CRYPTO_WRITE(dev, RK_CRYPTO_HASH_MSG_LEN, dev->total);
CRYPTO_WRITE(rk_dev, RK_CRYPTO_HASH_MSG_LEN, rk_dev->total);
}
static int rk_ahash_init(struct ahash_request *req)
@@ -182,46 +182,47 @@ static int rk_ahash_export(struct ahash_request *req, void *out)
static int rk_ahash_digest(struct ahash_request *req)
{
struct rk_ahash_ctx *tctx = crypto_tfm_ctx(req->base.tfm);
struct rk_crypto_info *dev = tctx->dev;
struct rk_crypto_dev *rk_dev = tctx->rk_dev;
if (!req->nbytes)
return zero_message_process(req);
else
return dev->enqueue(dev, &req->base);
return rk_dev->enqueue(rk_dev, &req->base);
}
static void crypto_ahash_dma_start(struct rk_crypto_info *dev)
static void crypto_ahash_dma_start(struct rk_crypto_dev *rk_dev)
{
CRYPTO_WRITE(dev, RK_CRYPTO_HRDMAS, dev->addr_in);
CRYPTO_WRITE(dev, RK_CRYPTO_HRDMAL, (dev->count + 3) / 4);
CRYPTO_WRITE(dev, RK_CRYPTO_CTRL, RK_CRYPTO_HASH_START |
CRYPTO_WRITE(rk_dev, RK_CRYPTO_HRDMAS, rk_dev->addr_in);
CRYPTO_WRITE(rk_dev, RK_CRYPTO_HRDMAL, (rk_dev->count + 3) / 4);
CRYPTO_WRITE(rk_dev, RK_CRYPTO_CTRL, RK_CRYPTO_HASH_START |
(RK_CRYPTO_HASH_START << 16));
}
static int rk_ahash_set_data_start(struct rk_crypto_info *dev)
static int rk_ahash_set_data_start(struct rk_crypto_dev *rk_dev)
{
int err;
err = dev->load_data(dev, dev->sg_src, NULL);
err = rk_dev->load_data(rk_dev, rk_dev->sg_src, NULL);
if (!err)
crypto_ahash_dma_start(dev);
crypto_ahash_dma_start(rk_dev);
return err;
}
static int rk_ahash_start(struct rk_crypto_info *dev)
static int rk_ahash_start(struct rk_crypto_dev *rk_dev)
{
struct ahash_request *req = ahash_request_cast(dev->async_req);
struct ahash_request *req = ahash_request_cast(rk_dev->async_req);
struct crypto_ahash *tfm;
struct rk_ahash_rctx *rctx;
dev->total = req->nbytes;
dev->left_bytes = req->nbytes;
dev->aligned = 0;
dev->align_size = 4;
dev->sg_dst = NULL;
dev->sg_src = req->src;
dev->first = req->src;
dev->src_nents = sg_nents(req->src);
rk_dev->total = req->nbytes;
rk_dev->left_bytes = req->nbytes;
rk_dev->aligned = 0;
rk_dev->align_size = 4;
rk_dev->sg_dst = NULL;
rk_dev->sg_src = req->src;
rk_dev->first = req->src;
rk_dev->src_nents = sg_nents(req->src);
rctx = ahash_request_ctx(req);
rctx->mode = 0;
@@ -240,28 +241,28 @@ static int rk_ahash_start(struct rk_crypto_info *dev)
return -EINVAL;
}
rk_ahash_reg_init(dev);
return rk_ahash_set_data_start(dev);
rk_ahash_reg_init(rk_dev);
return rk_ahash_set_data_start(rk_dev);
}
static int rk_ahash_crypto_rx(struct rk_crypto_info *dev)
static int rk_ahash_crypto_rx(struct rk_crypto_dev *rk_dev)
{
int err = 0;
struct ahash_request *req = ahash_request_cast(dev->async_req);
struct ahash_request *req = ahash_request_cast(rk_dev->async_req);
struct crypto_ahash *tfm;
dev->unload_data(dev);
if (dev->left_bytes) {
if (dev->aligned) {
if (sg_is_last(dev->sg_src)) {
dev_warn(dev->dev, "[%s:%d], Lack of data\n",
rk_dev->unload_data(rk_dev);
if (rk_dev->left_bytes) {
if (rk_dev->aligned) {
if (sg_is_last(rk_dev->sg_src)) {
dev_warn(rk_dev->dev, "[%s:%d], Lack of data\n",
__func__, __LINE__);
err = -ENOMEM;
goto out_rx;
}
dev->sg_src = sg_next(dev->sg_src);
rk_dev->sg_src = sg_next(rk_dev->sg_src);
}
err = rk_ahash_set_data_start(dev);
err = rk_ahash_set_data_start(rk_dev);
} else {
/*
* it will take some time to process date after last dma
@@ -273,14 +274,14 @@ static int rk_ahash_crypto_rx(struct rk_crypto_info *dev)
* efficiency, and make it response quickly when dma
* complete.
*/
while (!CRYPTO_READ(dev, RK_CRYPTO_HASH_STS))
while (!CRYPTO_READ(rk_dev, RK_CRYPTO_HASH_STS))
udelay(10);
tfm = crypto_ahash_reqtfm(req);
memcpy_fromio(req->result, dev->reg + RK_CRYPTO_HASH_DOUT_0,
memcpy_fromio(req->result, rk_dev->reg + RK_CRYPTO_HASH_DOUT_0,
crypto_ahash_digestsize(tfm));
dev->complete(dev->async_req, 0);
tasklet_schedule(&dev->queue_task);
rk_dev->complete(rk_dev->async_req, 0);
tasklet_schedule(&rk_dev->queue_task);
}
out_rx:
@@ -290,31 +291,31 @@ out_rx:
static int rk_cra_hash_init(struct crypto_tfm *tfm)
{
struct rk_ahash_ctx *ctx = crypto_tfm_ctx(tfm);
struct rk_crypto_tmp *algt;
struct rk_crypto_algt *algt;
struct ahash_alg *alg = __crypto_ahash_alg(tfm->__crt_alg);
const char *alg_name = crypto_tfm_alg_name(tfm);
struct rk_crypto_info *info;
struct rk_crypto_dev *rk_dev;
algt = container_of(alg, struct rk_crypto_tmp, alg.hash);
info = algt->dev;
algt = container_of(alg, struct rk_crypto_algt, alg.hash);
rk_dev = algt->rk_dev;
if (!info->request_crypto)
if (!rk_dev->request_crypto)
return -EFAULT;
info->request_crypto(info, crypto_tfm_alg_name(tfm));
rk_dev->request_crypto(rk_dev, crypto_tfm_alg_name(tfm));
info->start = rk_ahash_start;
info->update = rk_ahash_crypto_rx;
info->complete = rk_ahash_crypto_complete;
info->irq_handle = rk_crypto_irq_handle;
rk_dev->start = rk_ahash_start;
rk_dev->update = rk_ahash_crypto_rx;
rk_dev->complete = rk_ahash_crypto_complete;
rk_dev->irq_handle = rk_crypto_irq_handle;
ctx->dev = info;
ctx->rk_dev = rk_dev;
/* for fallback */
ctx->fallback_tfm = crypto_alloc_ahash(alg_name, 0,
CRYPTO_ALG_NEED_FALLBACK);
if (IS_ERR(ctx->fallback_tfm)) {
dev_err(info->dev, "Could not load fallback driver.\n");
dev_err(rk_dev->dev, "Could not load fallback driver.\n");
return PTR_ERR(ctx->fallback_tfm);
}
crypto_ahash_set_reqsize(__crypto_ahash_cast(tfm),
@@ -333,10 +334,10 @@ static void rk_cra_hash_exit(struct crypto_tfm *tfm)
if (ctx->fallback_tfm)
crypto_free_ahash(ctx->fallback_tfm);
ctx->dev->release_crypto(ctx->dev, crypto_tfm_alg_name(tfm));
ctx->rk_dev->release_crypto(ctx->rk_dev, crypto_tfm_alg_name(tfm));
}
struct rk_crypto_tmp rk_v1_ahash_sha1 = RK_HASH_ALGO_INIT(SHA1, sha1);
struct rk_crypto_tmp rk_v1_ahash_sha256 = RK_HASH_ALGO_INIT(SHA256, sha256);
struct rk_crypto_tmp rk_v1_ahash_md5 = RK_HASH_ALGO_INIT(MD5, md5);
struct rk_crypto_algt rk_v1_ahash_sha1 = RK_HASH_ALGO_INIT(SHA1, sha1);
struct rk_crypto_algt rk_v1_ahash_sha256 = RK_HASH_ALGO_INIT(SHA256, sha256);
struct rk_crypto_algt rk_v1_ahash_md5 = RK_HASH_ALGO_INIT(MD5, md5);

62
drivers/crypto/rockchip/rk_crypto_v2.h
View File

@@ -23,43 +23,43 @@ struct rk_hw_crypto_v2_info {
dma_addr_t desc_dma;
};
extern struct rk_crypto_tmp rk_v2_ecb_sm4_alg;
extern struct rk_crypto_tmp rk_v2_cbc_sm4_alg;
extern struct rk_crypto_tmp rk_v2_xts_sm4_alg;
extern struct rk_crypto_tmp rk_v2_cfb_sm4_alg;
extern struct rk_crypto_tmp rk_v2_ofb_sm4_alg;
extern struct rk_crypto_tmp rk_v2_ctr_sm4_alg;
extern struct rk_crypto_algt rk_v2_ecb_sm4_alg;
extern struct rk_crypto_algt rk_v2_cbc_sm4_alg;
extern struct rk_crypto_algt rk_v2_xts_sm4_alg;
extern struct rk_crypto_algt rk_v2_cfb_sm4_alg;
extern struct rk_crypto_algt rk_v2_ofb_sm4_alg;
extern struct rk_crypto_algt rk_v2_ctr_sm4_alg;
extern struct rk_crypto_tmp rk_v2_ecb_aes_alg;
extern struct rk_crypto_tmp rk_v2_cbc_aes_alg;
extern struct rk_crypto_tmp rk_v2_xts_aes_alg;
extern struct rk_crypto_tmp rk_v2_cfb_aes_alg;
extern struct rk_crypto_tmp rk_v2_ofb_aes_alg;
extern struct rk_crypto_tmp rk_v2_ctr_aes_alg;
extern struct rk_crypto_algt rk_v2_ecb_aes_alg;
extern struct rk_crypto_algt rk_v2_cbc_aes_alg;
extern struct rk_crypto_algt rk_v2_xts_aes_alg;
extern struct rk_crypto_algt rk_v2_cfb_aes_alg;
extern struct rk_crypto_algt rk_v2_ofb_aes_alg;
extern struct rk_crypto_algt rk_v2_ctr_aes_alg;
extern struct rk_crypto_tmp rk_v2_ecb_des_alg;
extern struct rk_crypto_tmp rk_v2_cbc_des_alg;
extern struct rk_crypto_tmp rk_v2_cfb_des_alg;
extern struct rk_crypto_tmp rk_v2_ofb_des_alg;
extern struct rk_crypto_algt rk_v2_ecb_des_alg;
extern struct rk_crypto_algt rk_v2_cbc_des_alg;
extern struct rk_crypto_algt rk_v2_cfb_des_alg;
extern struct rk_crypto_algt rk_v2_ofb_des_alg;
extern struct rk_crypto_tmp rk_v2_ecb_des3_ede_alg;
extern struct rk_crypto_tmp rk_v2_cbc_des3_ede_alg;
extern struct rk_crypto_tmp rk_v2_cfb_des3_ede_alg;
extern struct rk_crypto_tmp rk_v2_ofb_des3_ede_alg;
extern struct rk_crypto_algt rk_v2_ecb_des3_ede_alg;
extern struct rk_crypto_algt rk_v2_cbc_des3_ede_alg;
extern struct rk_crypto_algt rk_v2_cfb_des3_ede_alg;
extern struct rk_crypto_algt rk_v2_ofb_des3_ede_alg;
extern struct rk_crypto_tmp rk_v2_ahash_sha1;
extern struct rk_crypto_tmp rk_v2_ahash_sha256;
extern struct rk_crypto_tmp rk_v2_ahash_sha512;
extern struct rk_crypto_tmp rk_v2_ahash_md5;
extern struct rk_crypto_tmp rk_v2_ahash_sm3;
extern struct rk_crypto_algt rk_v2_ahash_sha1;
extern struct rk_crypto_algt rk_v2_ahash_sha256;
extern struct rk_crypto_algt rk_v2_ahash_sha512;
extern struct rk_crypto_algt rk_v2_ahash_md5;
extern struct rk_crypto_algt rk_v2_ahash_sm3;
extern struct rk_crypto_tmp rk_v2_ahash_hmac_md5;
extern struct rk_crypto_tmp rk_v2_ahash_hmac_sha1;
extern struct rk_crypto_tmp rk_v2_ahash_hmac_sha256;
extern struct rk_crypto_tmp rk_v2_ahash_hmac_sha512;
extern struct rk_crypto_tmp rk_v2_ahash_hmac_sm3;
extern struct rk_crypto_algt rk_v2_hmac_md5;
extern struct rk_crypto_algt rk_v2_hmac_sha1;
extern struct rk_crypto_algt rk_v2_hmac_sha256;
extern struct rk_crypto_algt rk_v2_hmac_sha512;
extern struct rk_crypto_algt rk_v2_hmac_sm3;
extern struct rk_crypto_tmp rk_v2_asym_rsa;
extern struct rk_crypto_algt rk_v2_asym_rsa;
int rk_hw_crypto_v2_init(struct device *dev, void *hw_info);
void rk_hw_crypto_v2_deinit(struct device *dev, void *hw_info);

400
drivers/crypto/rockchip/rk_crypto_v2_ablkcipher.c
View File

@@ -36,61 +36,52 @@ static const u32 cipher_mode2bc[] = {
static int rk_crypto_irq_handle(int irq, void *dev_id)
{
struct rk_crypto_info *dev = platform_get_drvdata(dev_id);
struct rk_crypto_dev *rk_dev = platform_get_drvdata(dev_id);
u32 interrupt_status;
struct rk_hw_crypto_v2_info *hw_info =
(struct rk_hw_crypto_v2_info *)dev->hw_info;
(struct rk_hw_crypto_v2_info *)rk_dev->hw_info;
interrupt_status = CRYPTO_READ(dev, CRYPTO_DMA_INT_ST);
CRYPTO_WRITE(dev, CRYPTO_DMA_INT_ST, interrupt_status);
interrupt_status = CRYPTO_READ(rk_dev, CRYPTO_DMA_INT_ST);
CRYPTO_WRITE(rk_dev, CRYPTO_DMA_INT_ST, interrupt_status);
interrupt_status &= CRYPTO_LOCKSTEP_MASK;
if (interrupt_status != CRYPTO_DST_ITEM_DONE_INT_ST) {
dev_err(dev->dev, "DMA desc = %p\n", hw_info->desc);
dev_err(dev->dev, "DMA addr_in = %08x\n",
(u32)dev->addr_in);
dev_err(dev->dev, "DMA addr_out = %08x\n",
(u32)dev->addr_out);
dev_err(dev->dev, "DMA count = %08x\n", dev->count);
dev_err(dev->dev, "DMA desc_dma = %08x\n",
dev_err(rk_dev->dev, "DMA desc = %p\n", hw_info->desc);
dev_err(rk_dev->dev, "DMA addr_in = %08x\n",
(u32)rk_dev->addr_in);
dev_err(rk_dev->dev, "DMA addr_out = %08x\n",
(u32)rk_dev->addr_out);
dev_err(rk_dev->dev, "DMA count = %08x\n", rk_dev->count);
dev_err(rk_dev->dev, "DMA desc_dma = %08x\n",
(u32)hw_info->desc_dma);
dev_err(dev->dev, "DMA Error status = %08x\n",
dev_err(rk_dev->dev, "DMA Error status = %08x\n",
interrupt_status);
dev_err(dev->dev, "DMA CRYPTO_DMA_LLI_ADDR status = %08x\n",
CRYPTO_READ(dev, CRYPTO_DMA_LLI_ADDR));
dev_err(dev->dev, "DMA CRYPTO_DMA_ST status = %08x\n",
CRYPTO_READ(dev, CRYPTO_DMA_ST));
dev_err(dev->dev, "DMA CRYPTO_DMA_STATE status = %08x\n",
CRYPTO_READ(dev, CRYPTO_DMA_STATE));
dev_err(dev->dev, "DMA CRYPTO_DMA_LLI_RADDR status = %08x\n",
CRYPTO_READ(dev, CRYPTO_DMA_LLI_RADDR));
dev_err(dev->dev, "DMA CRYPTO_DMA_SRC_RADDR status = %08x\n",
CRYPTO_READ(dev, CRYPTO_DMA_SRC_RADDR));
dev_err(dev->dev, "DMA CRYPTO_DMA_DST_RADDR status = %08x\n",
CRYPTO_READ(dev, CRYPTO_DMA_DST_RADDR));
dev->err = -EFAULT;
dev_err(rk_dev->dev, "DMA CRYPTO_DMA_LLI_ADDR status = %08x\n",
CRYPTO_READ(rk_dev, CRYPTO_DMA_LLI_ADDR));
dev_err(rk_dev->dev, "DMA CRYPTO_DMA_ST status = %08x\n",
CRYPTO_READ(rk_dev, CRYPTO_DMA_ST));
dev_err(rk_dev->dev, "DMA CRYPTO_DMA_STATE status = %08x\n",
CRYPTO_READ(rk_dev, CRYPTO_DMA_STATE));
dev_err(rk_dev->dev, "DMA CRYPTO_DMA_LLI_RADDR status = %08x\n",
CRYPTO_READ(rk_dev, CRYPTO_DMA_LLI_RADDR));
dev_err(rk_dev->dev, "DMA CRYPTO_DMA_SRC_RADDR status = %08x\n",
CRYPTO_READ(rk_dev, CRYPTO_DMA_SRC_RADDR));
dev_err(rk_dev->dev, "DMA CRYPTO_DMA_DST_RADDR status = %08x\n",
CRYPTO_READ(rk_dev, CRYPTO_DMA_DST_RADDR));
rk_dev->err = -EFAULT;
}
return 0;
}
static u32 byte2word(const u8 *ch, u32 endian)
static inline u32 byte2word_be(const u8 *ch)
{
u32 w = 0;
/* 0: Big-Endian 1: Little-Endian */
if (endian == BIG_ENDIAN)
w = (*ch << 24) + (*(ch + 1) << 16) +
return (*ch << 24) + (*(ch + 1) << 16) +
(*(ch + 2) << 8) + *(ch + 3);
else if (endian == LITTLE_ENDIAN)
w = (*(ch + 3) << 24) + (*(ch + 2) << 16) +
(*(ch + 1) << 8) + *ch;
return w;
}
static void set_iv_reg(struct rk_crypto_info *dev, const u8 *iv, u32 iv_len)
static void set_iv_reg(struct rk_crypto_dev *rk_dev, const u8 *iv, u32 iv_len)
{
u32 i;
u8 tmp_buf[4];
@@ -102,64 +93,64 @@ static void set_iv_reg(struct rk_crypto_info *dev, const u8 *iv, u32 iv_len)
base_iv = CRYPTO_CH0_IV_0;
/* write iv data to reg */
for (i = 0; i < iv_len / 4; i++, base_iv += 4)
CRYPTO_WRITE(dev, base_iv, byte2word(iv + i * 4, BIG_ENDIAN));
CRYPTO_WRITE(rk_dev, base_iv, byte2word_be(iv + i * 4));
if (iv_len % 4) {
memset(tmp_buf, 0x00, sizeof(tmp_buf));
memcpy((u8 *)tmp_buf, iv + (iv_len / 4) * 4, iv_len % 4);
CRYPTO_WRITE(dev, base_iv, byte2word(tmp_buf, BIG_ENDIAN));
CRYPTO_WRITE(rk_dev, base_iv, byte2word_be(tmp_buf));
}
CRYPTO_WRITE(dev, CRYPTO_CH0_IV_LEN_0, iv_len);
CRYPTO_WRITE(rk_dev, CRYPTO_CH0_IV_LEN_0, iv_len);
}
static void write_key_reg(struct rk_crypto_info *dev, const u8 *key,
static void write_key_reg(struct rk_crypto_dev *rk_dev, const u8 *key,
u32 key_len)
{
u32 i;
u8 tmp_buf[4];
u32 chn_base_addr;
u32 base_addr;
chn_base_addr = CRYPTO_CH0_KEY_0;
base_addr = CRYPTO_CH0_KEY_0;
for (i = 0; i < key_len / 4; i++, chn_base_addr += 4)
CRYPTO_WRITE(dev, chn_base_addr,
byte2word(key + i * 4, BIG_ENDIAN));
for (i = 0; i < key_len / 4; i++, base_addr += 4)
CRYPTO_WRITE(rk_dev, base_addr,
byte2word_be(key + i * 4));
if (key_len % 4) {
memset(tmp_buf, 0x00, sizeof(tmp_buf));
memcpy((u8 *)tmp_buf, key + i * 4, key_len % 4);
CRYPTO_WRITE(dev, chn_base_addr,
byte2word(tmp_buf, BIG_ENDIAN));
CRYPTO_WRITE(rk_dev, base_addr,
byte2word_be(tmp_buf));
}
}
static void write_tkey_reg(struct rk_crypto_info *dev, const u8 *key,
static void write_tkey_reg(struct rk_crypto_dev *rk_dev, const u8 *key,
u32 key_len)
{
u32 i;
u8 tmp_buf[4];
u32 chn_base_addr;
u32 base_addr;
chn_base_addr = CRYPTO_CH4_KEY_0;
base_addr = CRYPTO_CH4_KEY_0;
for (i = 0; i < key_len / 4; i++, chn_base_addr += 4)
CRYPTO_WRITE(dev, chn_base_addr,
byte2word(key + i * 4, BIG_ENDIAN));
for (i = 0; i < key_len / 4; i++, base_addr += 4)
CRYPTO_WRITE(rk_dev, base_addr,
byte2word_be(key + i * 4));
if (key_len % 4) {
memset(tmp_buf, 0x00, sizeof(tmp_buf));
memcpy((u8 *)tmp_buf, key + i * 4, key_len % 4);
CRYPTO_WRITE(dev, chn_base_addr,
byte2word(tmp_buf, BIG_ENDIAN));
CRYPTO_WRITE(rk_dev, base_addr,
byte2word_be(tmp_buf));
}
}
static struct rk_crypto_tmp *rk_cipher_get_algt(struct crypto_ablkcipher *tfm)
static struct rk_crypto_algt *rk_cipher_get_algt(struct crypto_ablkcipher *tfm)
{
struct crypto_alg *alg = tfm->base.__crt_alg;
return container_of(alg, struct rk_crypto_tmp, alg.crypto);
return container_of(alg, struct rk_crypto_algt, alg.crypto);
}
static bool is_use_fallback(struct rk_cipher_ctx *ctx)
@@ -167,12 +158,12 @@ static bool is_use_fallback(struct rk_cipher_ctx *ctx)
return ctx->keylen == AES_KEYSIZE_192 && ctx->fallback_tfm;
}
static bool is_no_multi_blocksize(struct rk_crypto_info *dev)
static bool is_no_multi_blocksize(struct rk_crypto_dev *rk_dev)
{
struct ablkcipher_request *req =
ablkcipher_request_cast(dev->async_req);
ablkcipher_request_cast(rk_dev->async_req);
struct crypto_ablkcipher *cipher = crypto_ablkcipher_reqtfm(req);
struct rk_crypto_tmp *algt = rk_cipher_get_algt(cipher);
struct rk_crypto_algt *algt = rk_cipher_get_algt(cipher);
return (algt->mode == CIPHER_MODE_CFB ||
algt->mode == CIPHER_MODE_OFB ||
@@ -185,21 +176,21 @@ static void rk_crypto_complete(struct crypto_async_request *base, int err)
base->complete(base, err);
}
static int rk_handle_req(struct rk_crypto_info *dev,
static int rk_handle_req(struct rk_crypto_dev *rk_dev,
struct ablkcipher_request *req)
{
if (!IS_ALIGNED(req->nbytes, dev->align_size) &&
!is_no_multi_blocksize(dev))
if (!IS_ALIGNED(req->nbytes, rk_dev->align_size) &&
!is_no_multi_blocksize(rk_dev))
return -EINVAL;
else
return dev->enqueue(dev, &req->base);
return rk_dev->enqueue(rk_dev, &req->base);
}
static int rk_cipher_setkey(struct crypto_ablkcipher *cipher,
const u8 *key, unsigned int keylen)
{
struct crypto_tfm *tfm = crypto_ablkcipher_tfm(cipher);
struct rk_crypto_tmp *algt = rk_cipher_get_algt(cipher);
struct rk_crypto_algt *algt = rk_cipher_get_algt(cipher);
struct rk_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
u32 tmp[DES_EXPKEY_WORDS];
int ret = -EINVAL;
@@ -269,88 +260,84 @@ error:
return ret;
}
static int rk_cipher_encrypt(struct ablkcipher_request *req)
static int rk_cipher_fallback(struct ablkcipher_request *req,
struct rk_cipher_ctx *ctx,
bool encrypt)
{
int ret;
SKCIPHER_REQUEST_ON_STACK(subreq, ctx->fallback_tfm);
CRYPTO_MSG("use fallback tfm");
skcipher_request_set_tfm(subreq, ctx->fallback_tfm);
skcipher_request_set_callback(subreq, req->base.flags,
NULL, NULL);
skcipher_request_set_crypt(subreq, req->src, req->dst,
req->nbytes, req->info);
ret = encrypt ? crypto_skcipher_encrypt(subreq) :
crypto_skcipher_decrypt(subreq);
skcipher_request_zero(subreq);
return ret;
}
static int rk_cipher_crypt(struct ablkcipher_request *req, bool encrypt)
{
struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
struct rk_cipher_ctx *ctx = crypto_ablkcipher_ctx(tfm);
struct rk_crypto_tmp *algt = rk_cipher_get_algt(tfm);
struct rk_crypto_algt *algt = rk_cipher_get_algt(tfm);
int ret = -EINVAL;
CRYPTO_TRACE();
CRYPTO_TRACE("%s total = %u",
encrypt ? "encrypt" : "decrypt", req->nbytes);
if (is_use_fallback(ctx)) {
SKCIPHER_REQUEST_ON_STACK(subreq, ctx->fallback_tfm);
CRYPTO_MSG("use fallback tfm");
skcipher_request_set_tfm(subreq, ctx->fallback_tfm);
skcipher_request_set_callback(subreq, req->base.flags,
NULL, NULL);
skcipher_request_set_crypt(subreq, req->src, req->dst,
req->nbytes, req->info);
ret = crypto_skcipher_encrypt(subreq);
skcipher_request_zero(subreq);
ret = rk_cipher_fallback(req, ctx, encrypt);
} else {
ctx->mode = cipher_algo2bc[algt->algo] | cipher_mode2bc[algt->mode];
ctx->mode = cipher_algo2bc[algt->algo] |
cipher_mode2bc[algt->mode];
if (!encrypt)
ctx->mode |= CRYPTO_BC_DECRYPT;
CRYPTO_MSG("ctx->mode = %x\n", ctx->mode);
ret = rk_handle_req(ctx->dev, req);
ret = rk_handle_req(ctx->rk_dev, req);
}
return ret;
}
static int rk_cipher_encrypt(struct ablkcipher_request *req)
{
return rk_cipher_crypt(req, true);
}
static int rk_cipher_decrypt(struct ablkcipher_request *req)
{
struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
struct rk_cipher_ctx *ctx = crypto_ablkcipher_ctx(tfm);
struct rk_crypto_tmp *algt = rk_cipher_get_algt(tfm);
int ret = -EINVAL;
CRYPTO_TRACE();
if (is_use_fallback(ctx)) {
SKCIPHER_REQUEST_ON_STACK(subreq, ctx->fallback_tfm);
CRYPTO_MSG("use soft fallback tfm");
skcipher_request_set_tfm(subreq, ctx->fallback_tfm);
skcipher_request_set_callback(subreq, req->base.flags,
NULL, NULL);
skcipher_request_set_crypt(subreq, req->src, req->dst,
req->nbytes, req->info);
ret = crypto_skcipher_decrypt(subreq);
skcipher_request_zero(subreq);
} else {
ctx->mode = cipher_algo2bc[algt->algo] |
cipher_mode2bc[algt->mode] |
CRYPTO_BC_DECRYPT;
CRYPTO_MSG("ctx->mode = %x\n", ctx->mode);
ret = rk_handle_req(ctx->dev, req);
}
return ret;
return rk_cipher_crypt(req, false);
}
static void rk_ablk_hw_init(struct rk_crypto_info *dev)
static void rk_ablk_hw_init(struct rk_crypto_dev *rk_dev)
{
struct ablkcipher_request *req =
ablkcipher_request_cast(dev->async_req);
ablkcipher_request_cast(rk_dev->async_req);
struct crypto_ablkcipher *cipher = crypto_ablkcipher_reqtfm(req);
struct crypto_tfm *tfm = crypto_ablkcipher_tfm(cipher);
struct rk_cipher_ctx *ctx = crypto_ablkcipher_ctx(cipher);
u32 ivsize, block;
CRYPTO_WRITE(dev, CRYPTO_BC_CTL, 0x00010000);
CRYPTO_WRITE(rk_dev, CRYPTO_BC_CTL, 0x00010000);
block = crypto_tfm_alg_blocksize(tfm);
ivsize = crypto_ablkcipher_ivsize(cipher);
write_key_reg(ctx->dev, ctx->key, ctx->keylen);
write_key_reg(ctx->rk_dev, ctx->key, ctx->keylen);
if (MASK_BC_MODE(ctx->mode) == CRYPTO_BC_XTS)
write_tkey_reg(ctx->dev, ctx->key + ctx->keylen, ctx->keylen);
write_tkey_reg(ctx->rk_dev,
ctx->key + ctx->keylen, ctx->keylen);
if (MASK_BC_MODE(ctx->mode) != CRYPTO_BC_ECB)
set_iv_reg(dev, req->info, ivsize);
set_iv_reg(rk_dev, req->info, ivsize);
if (block != DES_BLOCK_SIZE) {
if (ctx->keylen == AES_KEYSIZE_128)
@@ -363,18 +350,18 @@ static void rk_ablk_hw_init(struct rk_crypto_info *dev)
ctx->mode |= CRYPTO_BC_ENABLE;
CRYPTO_WRITE(dev, CRYPTO_FIFO_CTL, 0x00030003);
CRYPTO_WRITE(rk_dev, CRYPTO_FIFO_CTL, 0x00030003);
CRYPTO_WRITE(dev, CRYPTO_DMA_INT_EN, 0x7f);
CRYPTO_WRITE(rk_dev, CRYPTO_DMA_INT_EN, 0x7f);
CRYPTO_WRITE(dev, CRYPTO_BC_CTL, ctx->mode | CRYPTO_WRITE_MASK_ALL);
CRYPTO_WRITE(rk_dev, CRYPTO_BC_CTL, ctx->mode | CRYPTO_WRITE_MASK_ALL);
}
static void crypto_dma_start(struct rk_crypto_info *dev)
static void crypto_dma_start(struct rk_crypto_dev *rk_dev)
{
struct rk_hw_crypto_v2_info *hw_info =
(struct rk_hw_crypto_v2_info *)dev->hw_info;
u32 calc_len = dev->count;
(struct rk_hw_crypto_v2_info *)rk_dev->hw_info;
u32 calc_len = rk_dev->count;
memset(hw_info->desc, 0x00, sizeof(*hw_info->desc));
@@ -382,60 +369,60 @@ static void crypto_dma_start(struct rk_crypto_info *dev)
* the data length is not aligned will use addr_vir to calculate,
* so crypto v2 could round up date date length to align_size
*/
if (is_no_multi_blocksize(dev))
calc_len = round_up(calc_len, dev->align_size);
if (is_no_multi_blocksize(rk_dev))
calc_len = round_up(calc_len, rk_dev->align_size);
hw_info->desc->src_addr = dev->addr_in;
hw_info->desc->src_len = calc_len;
hw_info->desc->dst_addr = dev->addr_out;
hw_info->desc->dst_len = calc_len;
hw_info->desc->next_addr = 0;
hw_info->desc->dma_ctrl = 0x00000201;
hw_info->desc->src_addr = rk_dev->addr_in;
hw_info->desc->src_len = calc_len;
hw_info->desc->dst_addr = rk_dev->addr_out;
hw_info->desc->dst_len = calc_len;
hw_info->desc->next_addr = 0;
hw_info->desc->dma_ctrl = 0x00000201;
hw_info->desc->user_define = 0x7;
dma_wmb();
CRYPTO_WRITE(dev, CRYPTO_DMA_LLI_ADDR, hw_info->desc_dma);
CRYPTO_WRITE(dev, CRYPTO_DMA_CTL, 0x00010001);/* start */
CRYPTO_WRITE(rk_dev, CRYPTO_DMA_LLI_ADDR, hw_info->desc_dma);
CRYPTO_WRITE(rk_dev, CRYPTO_DMA_CTL, 0x00010001);/* start */
}
static int rk_set_data_start(struct rk_crypto_info *dev)
static int rk_set_data_start(struct rk_crypto_dev *rk_dev)
{
int err;
err = dev->load_data(dev, dev->sg_src, dev->sg_dst);
err = rk_dev->load_data(rk_dev, rk_dev->sg_src, rk_dev->sg_dst);
if (!err)
crypto_dma_start(dev);
crypto_dma_start(rk_dev);
return err;
}
static int rk_ablk_start(struct rk_crypto_info *dev)
static int rk_ablk_start(struct rk_crypto_dev *rk_dev)
{
struct ablkcipher_request *req =
ablkcipher_request_cast(dev->async_req);
ablkcipher_request_cast(rk_dev->async_req);
unsigned long flags;
int err = 0;
dev->left_bytes = req->nbytes;
dev->total = req->nbytes;
dev->sg_src = req->src;
dev->first = req->src;
dev->src_nents = sg_nents(req->src);
dev->sg_dst = req->dst;
dev->dst_nents = sg_nents(req->dst);
dev->aligned = 1;
rk_dev->left_bytes = req->nbytes;
rk_dev->total = req->nbytes;
rk_dev->sg_src = req->src;
rk_dev->first = req->src;
rk_dev->src_nents = sg_nents(req->src);
rk_dev->sg_dst = req->dst;
rk_dev->dst_nents = sg_nents(req->dst);
rk_dev->aligned = 1;
spin_lock_irqsave(&dev->lock, flags);
rk_ablk_hw_init(dev);
err = rk_set_data_start(dev);
spin_unlock_irqrestore(&dev->lock, flags);
spin_lock_irqsave(&rk_dev->lock, flags);
rk_ablk_hw_init(rk_dev);
err = rk_set_data_start(rk_dev);
spin_unlock_irqrestore(&rk_dev->lock, flags);
return err;
}
static void rk_iv_copyback(struct rk_crypto_info *dev)
static void rk_iv_copyback(struct rk_crypto_dev *rk_dev)
{
struct ablkcipher_request *req =
ablkcipher_request_cast(dev->async_req);
ablkcipher_request_cast(rk_dev->async_req);
struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
struct rk_cipher_ctx *ctx = crypto_ablkcipher_ctx(tfm);
@@ -443,12 +430,12 @@ static void rk_iv_copyback(struct rk_crypto_info *dev)
/* Update the IV buffer to contain the next IV for encryption mode. */
if (!IS_BC_DECRYPT(ctx->mode) && req->info) {
if (dev->aligned) {
memcpy(req->info, sg_virt(dev->sg_dst) +
dev->count - ivsize, ivsize);
if (rk_dev->aligned) {
memcpy(req->info, sg_virt(rk_dev->sg_dst) +
rk_dev->count - ivsize, ivsize);
} else {
memcpy(req->info, dev->addr_vir +
dev->count - ivsize, ivsize);
memcpy(req->info, rk_dev->addr_vir +
rk_dev->count - ivsize, ivsize);
}
}
@@ -458,39 +445,39 @@ static void rk_iv_copyback(struct rk_crypto_info *dev)
* true some err was occurred
* fault no err, continue
*/
static int rk_ablk_rx(struct rk_crypto_info *dev)
static int rk_ablk_rx(struct rk_crypto_dev *rk_dev)
{
int err = 0;
struct ablkcipher_request *req =
ablkcipher_request_cast(dev->async_req);
ablkcipher_request_cast(rk_dev->async_req);
dev->unload_data(dev);
if (!dev->aligned) {
if (!sg_pcopy_from_buffer(req->dst, dev->dst_nents,
dev->addr_vir, dev->count,
dev->total - dev->left_bytes -
dev->count)) {
rk_dev->unload_data(rk_dev);
if (!rk_dev->aligned) {
if (!sg_pcopy_from_buffer(req->dst, rk_dev->dst_nents,
rk_dev->addr_vir, rk_dev->count,
rk_dev->total - rk_dev->left_bytes -
rk_dev->count)) {
err = -EINVAL;
goto out_rx;
}
}
if (dev->left_bytes) {
if (dev->aligned) {
if (sg_is_last(dev->sg_src)) {
dev_err(dev->dev, "[%s:%d] Lack of data\n",
if (rk_dev->left_bytes) {
if (rk_dev->aligned) {
if (sg_is_last(rk_dev->sg_src)) {
dev_err(rk_dev->dev, "[%s:%d] Lack of data\n",
__func__, __LINE__);
err = -ENOMEM;
goto out_rx;
}
dev->sg_src = sg_next(dev->sg_src);
dev->sg_dst = sg_next(dev->sg_dst);
rk_dev->sg_src = sg_next(rk_dev->sg_src);
rk_dev->sg_dst = sg_next(rk_dev->sg_dst);
}
err = rk_set_data_start(dev);
err = rk_set_data_start(rk_dev);
} else {
rk_iv_copyback(dev);
rk_iv_copyback(rk_dev);
/* here show the calculation is over without any err */
dev->complete(dev->async_req, 0);
tasklet_schedule(&dev->queue_task);
rk_dev->complete(rk_dev->async_req, 0);
tasklet_schedule(&rk_dev->queue_task);
}
out_rx:
return err;
@@ -498,25 +485,26 @@ out_rx:
static int rk_ablk_cra_init(struct crypto_tfm *tfm)
{
struct rk_crypto_tmp *algt = rk_cipher_get_algt(__crypto_ablkcipher_cast(tfm));
struct rk_crypto_algt *algt =
rk_cipher_get_algt(__crypto_ablkcipher_cast(tfm));
struct rk_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
const char *alg_name = crypto_tfm_alg_name(tfm);
struct rk_crypto_info *info = algt->dev;
struct rk_crypto_dev *rk_dev = algt->rk_dev;
CRYPTO_TRACE();
if (!info->request_crypto)
if (!rk_dev->request_crypto)
return -EFAULT;
info->request_crypto(info, alg_name);
rk_dev->request_crypto(rk_dev, alg_name);
info->align_size = crypto_tfm_alg_blocksize(tfm);
info->start = rk_ablk_start;
info->update = rk_ablk_rx;
info->complete = rk_crypto_complete;
info->irq_handle = rk_crypto_irq_handle;
rk_dev->align_size = crypto_tfm_alg_blocksize(tfm);
rk_dev->start = rk_ablk_start;
rk_dev->update = rk_ablk_rx;
rk_dev->complete = rk_crypto_complete;
rk_dev->irq_handle = rk_crypto_irq_handle;
ctx->dev = info;
ctx->rk_dev = rk_dev;
if (algt->alg.crypto.cra_flags & CRYPTO_ALG_NEED_FALLBACK) {
CRYPTO_MSG("alloc fallback tfm, name = %s", alg_name);
@@ -524,7 +512,7 @@ static int rk_ablk_cra_init(struct crypto_tfm *tfm)
CRYPTO_ALG_ASYNC |
CRYPTO_ALG_NEED_FALLBACK);
if (IS_ERR(ctx->fallback_tfm)) {
dev_err(info->dev, "Could not load fallback driver %s : %ld.\n",
dev_err(rk_dev->dev, "Could not load fallback driver %s : %ld.\n",
alg_name, PTR_ERR(ctx->fallback_tfm));
return PTR_ERR(ctx->fallback_tfm);
}
@@ -544,7 +532,7 @@ static void rk_ablk_cra_exit(struct crypto_tfm *tfm)
crypto_free_skcipher(ctx->fallback_tfm);
}
ctx->dev->release_crypto(ctx->dev, crypto_tfm_alg_name(tfm));
ctx->rk_dev->release_crypto(ctx->rk_dev, crypto_tfm_alg_name(tfm));
}
int rk_hw_crypto_v2_init(struct device *dev, void *hw_info)
@@ -576,63 +564,63 @@ void rk_hw_crypto_v2_deinit(struct device *dev, void *hw_info)
info->desc, info->desc_dma);
}
struct rk_crypto_tmp rk_v2_ecb_sm4_alg =
struct rk_crypto_algt rk_v2_ecb_sm4_alg =
RK_CIPHER_ALGO_INIT(SM4, ECB, ecb(sm4), ecb-sm4-rk);
struct rk_crypto_tmp rk_v2_cbc_sm4_alg =
struct rk_crypto_algt rk_v2_cbc_sm4_alg =
RK_CIPHER_ALGO_INIT(SM4, CBC, cbc(sm4), cbc-sm4-rk);
struct rk_crypto_tmp rk_v2_xts_sm4_alg =
struct rk_crypto_algt rk_v2_xts_sm4_alg =
RK_CIPHER_ALGO_XTS_INIT(SM4, xts(sm4), xts-sm4-rk);
struct rk_crypto_tmp rk_v2_cfb_sm4_alg =
struct rk_crypto_algt rk_v2_cfb_sm4_alg =
RK_CIPHER_ALGO_INIT(SM4, CFB, cfb(sm4), cfb-sm4-rk);
struct rk_crypto_tmp rk_v2_ofb_sm4_alg =
struct rk_crypto_algt rk_v2_ofb_sm4_alg =
RK_CIPHER_ALGO_INIT(SM4, OFB, ofb(sm4), ofb-sm4-rk);
struct rk_crypto_tmp rk_v2_ctr_sm4_alg =
struct rk_crypto_algt rk_v2_ctr_sm4_alg =
RK_CIPHER_ALGO_INIT(SM4, CTR, ctr(sm4), ctr-sm4-rk);
struct rk_crypto_tmp rk_v2_ecb_aes_alg =
struct rk_crypto_algt rk_v2_ecb_aes_alg =
RK_CIPHER_ALGO_INIT(AES, ECB, ecb(aes), ecb-aes-rk);
struct rk_crypto_tmp rk_v2_cbc_aes_alg =
struct rk_crypto_algt rk_v2_cbc_aes_alg =
RK_CIPHER_ALGO_INIT(AES, CBC, cbc(aes), cbc-aes-rk);
struct rk_crypto_tmp rk_v2_xts_aes_alg =
struct rk_crypto_algt rk_v2_xts_aes_alg =
RK_CIPHER_ALGO_XTS_INIT(AES, xts(aes), xts-aes-rk);
struct rk_crypto_tmp rk_v2_cfb_aes_alg =
struct rk_crypto_algt rk_v2_cfb_aes_alg =
RK_CIPHER_ALGO_INIT(AES, CFB, cfb(aes), cfb-aes-rk);
struct rk_crypto_tmp rk_v2_ofb_aes_alg =
struct rk_crypto_algt rk_v2_ofb_aes_alg =
RK_CIPHER_ALGO_INIT(AES, OFB, ofb(aes), ofb-aes-rk);
struct rk_crypto_tmp rk_v2_ctr_aes_alg =
struct rk_crypto_algt rk_v2_ctr_aes_alg =
RK_CIPHER_ALGO_INIT(AES, CTR, ctr(aes), ctr-aes-rk);
struct rk_crypto_tmp rk_v2_ecb_des_alg =
struct rk_crypto_algt rk_v2_ecb_des_alg =
RK_CIPHER_ALGO_INIT(DES, ECB, ecb(des), ecb-des-rk);
struct rk_crypto_tmp rk_v2_cbc_des_alg =
struct rk_crypto_algt rk_v2_cbc_des_alg =
RK_CIPHER_ALGO_INIT(DES, CBC, cbc(des), cbc-des-rk);
struct rk_crypto_tmp rk_v2_cfb_des_alg =
struct rk_crypto_algt rk_v2_cfb_des_alg =
RK_CIPHER_ALGO_INIT(DES, CFB, cfb(des), cfb-des-rk);
struct rk_crypto_tmp rk_v2_ofb_des_alg =
struct rk_crypto_algt rk_v2_ofb_des_alg =
RK_CIPHER_ALGO_INIT(DES, OFB, ofb(des), ofb-des-rk);
struct rk_crypto_tmp rk_v2_ecb_des3_ede_alg =
struct rk_crypto_algt rk_v2_ecb_des3_ede_alg =
RK_CIPHER_ALGO_INIT(DES3_EDE, ECB, ecb(des3_ede), ecb-des3_ede-rk);
struct rk_crypto_tmp rk_v2_cbc_des3_ede_alg =
struct rk_crypto_algt rk_v2_cbc_des3_ede_alg =
RK_CIPHER_ALGO_INIT(DES3_EDE, CBC, cbc(des3_ede), cbc-des3_ede-rk);
struct rk_crypto_tmp rk_v2_cfb_des3_ede_alg =
struct rk_crypto_algt rk_v2_cfb_des3_ede_alg =
RK_CIPHER_ALGO_INIT(DES3_EDE, CFB, cfb(des3_ede), cfb-des3_ede-rk);
struct rk_crypto_tmp rk_v2_ofb_des3_ede_alg =
struct rk_crypto_algt rk_v2_ofb_des3_ede_alg =
RK_CIPHER_ALGO_INIT(DES3_EDE, OFB, ofb(des3_ede), ofb-des3_ede-rk);

251
drivers/crypto/rockchip/rk_crypto_v2_ahash.c
View File

@@ -77,54 +77,32 @@ const char *hash_algo2name[] = {
[HASH_ALGO_SM3] = "sm3",
};
static void word2byte(u32 word, u8 *ch, u32 endian)
static inline void word2byte_be(u32 word, u8 *ch)
{
/* 0: Big-Endian 1: Little-Endian */
if (endian == BIG_ENDIAN) {
ch[0] = (word >> 24) & 0xff;
ch[1] = (word >> 16) & 0xff;
ch[2] = (word >> 8) & 0xff;
ch[3] = (word >> 0) & 0xff;
} else if (endian == LITTLE_ENDIAN) {
ch[0] = (word >> 0) & 0xff;
ch[1] = (word >> 8) & 0xff;
ch[2] = (word >> 16) & 0xff;
ch[3] = (word >> 24) & 0xff;
} else {
ch[0] = 0;
ch[1] = 0;
ch[2] = 0;
ch[3] = 0;
}
ch[0] = (word >> 24) & 0xff;
ch[1] = (word >> 16) & 0xff;
ch[2] = (word >> 8) & 0xff;
ch[3] = (word >> 0) & 0xff;
}
static u32 byte2word(const u8 *ch, u32 endian)
static inline u32 byte2word_be(const u8 *ch)
{
u32 w = 0;
/* 0: Big-Endian 1: Little-Endian */
if (endian == BIG_ENDIAN)
w = (*ch << 24) + (*(ch + 1) << 16) +
return (*ch << 24) + (*(ch + 1) << 16) +
(*(ch + 2) << 8) + *(ch + 3);
else if (endian == LITTLE_ENDIAN)
w = (*(ch + 3) << 24) + (*(ch + 2) << 16) +
(*(ch + 1) << 8) + *ch;
return w;
}
static struct rk_crypto_tmp *rk_ahash_get_algt(struct crypto_ahash *tfm)
static struct rk_crypto_algt *rk_ahash_get_algt(struct crypto_ahash *tfm)
{
struct ahash_alg *alg = __crypto_ahash_alg(tfm->base.__crt_alg);
return container_of(alg, struct rk_crypto_tmp, alg.hash);
return container_of(alg, struct rk_crypto_algt, alg.hash);
}
static int zero_message_process(struct ahash_request *req)
{
struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
int rk_digest_size = crypto_ahash_digestsize(tfm);
struct rk_crypto_tmp *algt = rk_ahash_get_algt(tfm);
struct rk_crypto_algt *algt = rk_ahash_get_algt(tfm);
switch (algt->algo) {
case HASH_ALGO_MD5:
@@ -151,40 +129,40 @@ static int zero_message_process(struct ahash_request *req)
static int rk_crypto_irq_handle(int irq, void *dev_id)
{
struct rk_crypto_info *dev = platform_get_drvdata(dev_id);
struct rk_crypto_dev *rk_dev = platform_get_drvdata(dev_id);
u32 interrupt_status;
struct rk_hw_crypto_v2_info *hw_info =
(struct rk_hw_crypto_v2_info *)dev->hw_info;
(struct rk_hw_crypto_v2_info *)rk_dev->hw_info;
interrupt_status = CRYPTO_READ(dev, CRYPTO_DMA_INT_ST);
CRYPTO_WRITE(dev, CRYPTO_DMA_INT_ST, interrupt_status);
interrupt_status = CRYPTO_READ(rk_dev, CRYPTO_DMA_INT_ST);
CRYPTO_WRITE(rk_dev, CRYPTO_DMA_INT_ST, interrupt_status);
interrupt_status &= CRYPTO_LOCKSTEP_MASK;
if (interrupt_status != CRYPTO_SRC_ITEM_DONE_INT_ST) {
dev_err(dev->dev, "DMA desc = %p\n", hw_info->desc);
dev_err(dev->dev, "DMA addr_in = %08x\n",
(u32)dev->addr_in);
dev_err(dev->dev, "DMA addr_out = %08x\n",
(u32)dev->addr_out);
dev_err(dev->dev, "DMA count = %08x\n", dev->count);
dev_err(dev->dev, "DMA desc_dma = %08x\n",
dev_err(rk_dev->dev, "DMA desc = %p\n", hw_info->desc);
dev_err(rk_dev->dev, "DMA addr_in = %08x\n",
(u32)rk_dev->addr_in);
dev_err(rk_dev->dev, "DMA addr_out = %08x\n",
(u32)rk_dev->addr_out);
dev_err(rk_dev->dev, "DMA count = %08x\n", rk_dev->count);
dev_err(rk_dev->dev, "DMA desc_dma = %08x\n",
(u32)hw_info->desc_dma);
dev_err(dev->dev, "DMA Error status = %08x\n",
dev_err(rk_dev->dev, "DMA Error status = %08x\n",
interrupt_status);
dev_err(dev->dev, "DMA CRYPTO_DMA_LLI_ADDR status = %08x\n",
CRYPTO_READ(dev, CRYPTO_DMA_LLI_ADDR));
dev_err(dev->dev, "DMA CRYPTO_DMA_ST status = %08x\n",
CRYPTO_READ(dev, CRYPTO_DMA_ST));
dev_err(dev->dev, "DMA CRYPTO_DMA_STATE status = %08x\n",
CRYPTO_READ(dev, CRYPTO_DMA_STATE));
dev_err(dev->dev, "DMA CRYPTO_DMA_LLI_RADDR status = %08x\n",
CRYPTO_READ(dev, CRYPTO_DMA_LLI_RADDR));
dev_err(dev->dev, "DMA CRYPTO_DMA_SRC_RADDR status = %08x\n",
CRYPTO_READ(dev, CRYPTO_DMA_SRC_RADDR));
dev_err(dev->dev, "DMA CRYPTO_DMA_DST_RADDR status = %08x\n",
CRYPTO_READ(dev, CRYPTO_DMA_DST_RADDR));
dev->err = -EFAULT;
dev_err(rk_dev->dev, "DMA CRYPTO_DMA_LLI_ADDR status = %08x\n",
CRYPTO_READ(rk_dev, CRYPTO_DMA_LLI_ADDR));
dev_err(rk_dev->dev, "DMA CRYPTO_DMA_ST status = %08x\n",
CRYPTO_READ(rk_dev, CRYPTO_DMA_ST));
dev_err(rk_dev->dev, "DMA CRYPTO_DMA_STATE status = %08x\n",
CRYPTO_READ(rk_dev, CRYPTO_DMA_STATE));
dev_err(rk_dev->dev, "DMA CRYPTO_DMA_LLI_RADDR status = %08x\n",
CRYPTO_READ(rk_dev, CRYPTO_DMA_LLI_RADDR));
dev_err(rk_dev->dev, "DMA CRYPTO_DMA_SRC_RADDR status = %08x\n",
CRYPTO_READ(rk_dev, CRYPTO_DMA_SRC_RADDR));
dev_err(rk_dev->dev, "DMA CRYPTO_DMA_DST_RADDR status = %08x\n",
CRYPTO_READ(rk_dev, CRYPTO_DMA_DST_RADDR));
rk_dev->err = -EFAULT;
}
return 0;
@@ -196,16 +174,16 @@ static void rk_ahash_crypto_complete(struct crypto_async_request *base, int err)
base->complete(base, err);
}
static inline void clear_hash_out_reg(struct rk_crypto_info *dev)
static inline void clear_hash_out_reg(struct rk_crypto_dev *rk_dev)
{
int i;
/*clear out register*/
for (i = 0; i < 16; i++)
CRYPTO_WRITE(dev, CRYPTO_HASH_DOUT_0 + 4 * i, 0);
CRYPTO_WRITE(rk_dev, CRYPTO_HASH_DOUT_0 + 4 * i, 0);
}
static void write_key_reg(struct rk_crypto_info *dev, const u8 *key,
static void write_key_reg(struct rk_crypto_dev *rk_dev, const u8 *key,
u32 key_len)
{
u32 i;
@@ -214,8 +192,8 @@ static void write_key_reg(struct rk_crypto_info *dev, const u8 *key,
chn_base_addr = CRYPTO_CH0_KEY_0;
for (i = 0; i < key_len / 4; i++, chn_base_addr += 4)
CRYPTO_WRITE(dev, chn_base_addr,
byte2word(key + i * 4, BIG_ENDIAN));
CRYPTO_WRITE(rk_dev, chn_base_addr,
byte2word_be(key + i * 4));
}
static int rk_ahash_init(struct ahash_request *req)
@@ -319,8 +297,8 @@ static int rk_ahash_digest(struct ahash_request *req)
{
struct rk_ahash_ctx *tctx = crypto_tfm_ctx(req->base.tfm);
struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
struct rk_crypto_tmp *algt = rk_ahash_get_algt(tfm);
struct rk_crypto_info *dev = tctx->dev;
struct rk_crypto_algt *algt = rk_ahash_get_algt(tfm);
struct rk_crypto_dev *rk_dev = tctx->rk_dev;
CRYPTO_TRACE("calc data %u bytes.", req->nbytes);
@@ -329,7 +307,7 @@ static int rk_ahash_digest(struct ahash_request *req)
crypto_ahash_digest(req) :
zero_message_process(req);
else
return dev->enqueue(dev, &req->base);
return rk_dev->enqueue(rk_dev, &req->base);
}
static int rk_ahash_calc_digest(const char *alg_name, const u8 *key, u32 keylen,
@@ -378,7 +356,7 @@ static int rk_ahash_hmac_setkey(struct crypto_ahash *tfm, const u8 *key,
{
unsigned int blocksize = crypto_tfm_alg_blocksize(crypto_ahash_tfm(tfm));
unsigned int digestsize = crypto_ahash_digestsize(tfm);
struct rk_crypto_tmp *algt = rk_ahash_get_algt(tfm);
struct rk_crypto_algt *algt = rk_ahash_get_algt(tfm);
struct rk_ahash_ctx *ctx = crypto_ahash_ctx(tfm);
const char *alg_name;
int ret;
@@ -420,95 +398,97 @@ exit:
return ret;
}
static void rk_ahash_dma_start(struct rk_crypto_info *dev)
static void rk_ahash_dma_start(struct rk_crypto_dev *rk_dev)
{
struct rk_hw_crypto_v2_info *hw_info =
(struct rk_hw_crypto_v2_info *)dev->hw_info;
(struct rk_hw_crypto_v2_info *)rk_dev->hw_info;
CRYPTO_TRACE();
memset(hw_info->desc, 0x00, sizeof(*hw_info->desc));
hw_info->desc->src_addr = dev->addr_in;
hw_info->desc->src_len = dev->count;
hw_info->desc->src_addr = rk_dev->addr_in;
hw_info->desc->src_len = rk_dev->count;
hw_info->desc->next_addr = 0;
hw_info->desc->dma_ctrl = 0x00000401;
hw_info->desc->user_define = 0x7;
dma_wmb();
CRYPTO_WRITE(dev, CRYPTO_DMA_LLI_ADDR, hw_info->desc_dma);
CRYPTO_WRITE(dev, CRYPTO_HASH_CTL,
CRYPTO_WRITE(rk_dev, CRYPTO_DMA_LLI_ADDR, hw_info->desc_dma);
CRYPTO_WRITE(rk_dev, CRYPTO_HASH_CTL,
(CRYPTO_HASH_ENABLE <<
CRYPTO_WRITE_MASK_SHIFT) |
CRYPTO_HASH_ENABLE);
CRYPTO_WRITE(dev, CRYPTO_DMA_CTL, 0x00010001);/* start */
CRYPTO_WRITE(rk_dev, CRYPTO_DMA_CTL, 0x00010001);/* start */
}
static int rk_ahash_set_data_start(struct rk_crypto_info *dev)
static int rk_ahash_set_data_start(struct rk_crypto_dev *rk_dev)
{
int err;
CRYPTO_TRACE();
err = dev->load_data(dev, dev->sg_src, dev->sg_dst);
err = rk_dev->load_data(rk_dev, rk_dev->sg_src, rk_dev->sg_dst);
if (!err)
rk_ahash_dma_start(dev);
rk_ahash_dma_start(rk_dev);
return err;
}
static int rk_ahash_start(struct rk_crypto_info *dev)
static int rk_ahash_start(struct rk_crypto_dev *rk_dev)
{
struct ahash_request *req = ahash_request_cast(dev->async_req);
struct ahash_request *req = ahash_request_cast(rk_dev->async_req);
struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
struct rk_crypto_tmp *algt = rk_ahash_get_algt(tfm);
struct rk_crypto_algt *algt = rk_ahash_get_algt(tfm);
struct rk_ahash_ctx *ctx = crypto_ahash_ctx(tfm);
u32 reg_ctrl = 0;
CRYPTO_TRACE();
dev->total = req->nbytes;
dev->left_bytes = req->nbytes;
dev->aligned = 0;
dev->align_size = 4;
dev->sg_dst = NULL;
dev->sg_src = req->src;
dev->first = req->src;
dev->src_nents = sg_nents(req->src);
rk_dev->total = req->nbytes;
rk_dev->left_bytes = req->nbytes;
rk_dev->aligned = 0;
rk_dev->align_size = 4;
rk_dev->sg_dst = NULL;
rk_dev->sg_src = req->src;
rk_dev->first = req->src;
rk_dev->src_nents = sg_nents(req->src);
if (algt->algo >= ARRAY_SIZE(hash_algo2bc))
goto exit;
reg_ctrl |= hash_algo2bc[algt->algo];
clear_hash_out_reg(dev);
clear_hash_out_reg(rk_dev);
reg_ctrl |= CRYPTO_HW_PAD_ENABLE;
if (IS_TYPE_HMAC(algt->type)) {
CRYPTO_TRACE("this is hmac");
reg_ctrl |= CRYPTO_HMAC_ENABLE;
write_key_reg(dev, ctx->authkey, sizeof(ctx->authkey));
write_key_reg(rk_dev, ctx->authkey, sizeof(ctx->authkey));
}
CRYPTO_WRITE(dev, CRYPTO_HASH_CTL, reg_ctrl | CRYPTO_WRITE_MASK_ALL);
CRYPTO_WRITE(rk_dev, CRYPTO_HASH_CTL, reg_ctrl | CRYPTO_WRITE_MASK_ALL);
CRYPTO_WRITE(dev, CRYPTO_FIFO_CTL, 0x00030003);
CRYPTO_WRITE(dev, CRYPTO_DMA_INT_EN, 0x7f);
CRYPTO_WRITE(rk_dev, CRYPTO_FIFO_CTL, 0x00030003);
CRYPTO_WRITE(rk_dev, CRYPTO_DMA_INT_EN, 0x7f);
return rk_ahash_set_data_start(dev);
return rk_ahash_set_data_start(rk_dev);
exit:
CRYPTO_WRITE(dev, CRYPTO_HASH_CTL, CRYPTO_WRITE_MASK_ALL | 0);
CRYPTO_WRITE(rk_dev, CRYPTO_HASH_CTL, CRYPTO_WRITE_MASK_ALL | 0);
return -1;
}
static int rk_ahash_get_result(struct rk_crypto_info *dev, uint8_t *data, uint32_t data_len)
static int rk_ahash_get_result(struct rk_crypto_dev *rk_dev,
uint8_t *data, uint32_t data_len)
{
int ret;
u32 i, offset;
u32 reg_ctrl = 0;
ret = readl_poll_timeout_atomic(dev->reg + CRYPTO_HASH_VALID, reg_ctrl,
ret = readl_poll_timeout_atomic(rk_dev->reg + CRYPTO_HASH_VALID,
reg_ctrl,
reg_ctrl & CRYPTO_HASH_IS_VALID,
RK_POLL_PERIOD_US,
RK_POLL_TIMEOUT_US);
@@ -517,43 +497,43 @@ static int rk_ahash_get_result(struct rk_crypto_info *dev, uint8_t *data, uint32
offset = CRYPTO_HASH_DOUT_0;
for (i = 0; i < data_len / 4; i++, offset += 4)
word2byte(CRYPTO_READ(dev, offset),
data + i * 4, BIG_ENDIAN);
word2byte_be(CRYPTO_READ(rk_dev, offset),
data + i * 4);
if (data_len % 4) {
uint8_t tmp_buf[4];
word2byte(CRYPTO_READ(dev, offset), tmp_buf, BIG_ENDIAN);
word2byte_be(CRYPTO_READ(rk_dev, offset), tmp_buf);
memcpy(data + i * 4, tmp_buf, data_len % 4);
}
CRYPTO_WRITE(dev, CRYPTO_HASH_VALID, CRYPTO_HASH_IS_VALID);
CRYPTO_WRITE(rk_dev, CRYPTO_HASH_VALID, CRYPTO_HASH_IS_VALID);
exit:
return ret;
}
static int rk_ahash_crypto_rx(struct rk_crypto_info *dev)
static int rk_ahash_crypto_rx(struct rk_crypto_dev *rk_dev)
{
int err = 0;
struct ahash_request *req = ahash_request_cast(dev->async_req);
struct ahash_request *req = ahash_request_cast(rk_dev->async_req);
struct crypto_ahash *tfm;
CRYPTO_TRACE();
dev->unload_data(dev);
CRYPTO_TRACE("left bytes = %u", dev->left_bytes);
if (dev->left_bytes) {
if (dev->aligned) {
if (sg_is_last(dev->sg_src)) {
dev_warn(dev->dev, "[%s:%d], Lack of data\n",
rk_dev->unload_data(rk_dev);
CRYPTO_TRACE("left bytes = %u", rk_dev->left_bytes);
if (rk_dev->left_bytes) {
if (rk_dev->aligned) {
if (sg_is_last(rk_dev->sg_src)) {
dev_warn(rk_dev->dev, "[%s:%d], Lack of data\n",
__func__, __LINE__);
err = -ENOMEM;
goto out_rx;
}
dev->sg_src = sg_next(dev->sg_src);
rk_dev->sg_src = sg_next(rk_dev->sg_src);
}
err = rk_ahash_set_data_start(dev);
err = rk_ahash_set_data_start(rk_dev);
} else {
/*
* it will take some time to process date after last dma
@@ -562,10 +542,11 @@ static int rk_ahash_crypto_rx(struct rk_crypto_info *dev)
tfm = crypto_ahash_reqtfm(req);
err = rk_ahash_get_result(dev, req->result, crypto_ahash_digestsize(tfm));
err = rk_ahash_get_result(rk_dev, req->result,
crypto_ahash_digestsize(tfm));
dev->complete(dev->async_req, err);
tasklet_schedule(&dev->queue_task);
rk_dev->complete(rk_dev->async_req, err);
tasklet_schedule(&rk_dev->queue_task);
}
out_rx:
@@ -575,31 +556,33 @@ out_rx:
static int rk_cra_hash_init(struct crypto_tfm *tfm)
{
struct rk_crypto_tmp *algt = rk_ahash_get_algt(__crypto_ahash_cast(tfm));
struct rk_crypto_algt *algt =
rk_ahash_get_algt(__crypto_ahash_cast(tfm));
const char *alg_name = crypto_tfm_alg_name(tfm);
struct rk_ahash_ctx *ctx = crypto_tfm_ctx(tfm);
struct rk_crypto_info *info = algt->dev;
struct rk_crypto_dev *rk_dev = algt->rk_dev;
CRYPTO_TRACE();
if (!info->request_crypto)
if (!rk_dev->request_crypto)
return -EFAULT;
info->request_crypto(info, alg_name);
info->start = rk_ahash_start;
info->update = rk_ahash_crypto_rx;
info->complete = rk_ahash_crypto_complete;
info->irq_handle = rk_crypto_irq_handle;
rk_dev->request_crypto(rk_dev, alg_name);
rk_dev->start = rk_ahash_start;
rk_dev->update = rk_ahash_crypto_rx;
rk_dev->complete = rk_ahash_crypto_complete;
rk_dev->irq_handle = rk_crypto_irq_handle;
memset(ctx, 0x00, sizeof(*ctx));
ctx->dev = info;
ctx->rk_dev = rk_dev;
/* for fallback */
ctx->fallback_tfm = crypto_alloc_ahash(alg_name, 0,
CRYPTO_ALG_NEED_FALLBACK);
if (IS_ERR(ctx->fallback_tfm)) {
dev_err(info->dev, "Could not load fallback driver.\n");
dev_err(rk_dev->dev, "Could not load fallback driver.\n");
return PTR_ERR(ctx->fallback_tfm);
}
@@ -621,18 +604,18 @@ static void rk_cra_hash_exit(struct crypto_tfm *tfm)
if (ctx->fallback_tfm)
crypto_free_ahash(ctx->fallback_tfm);
ctx->dev->release_crypto(ctx->dev, crypto_tfm_alg_name(tfm));
ctx->rk_dev->release_crypto(ctx->rk_dev, crypto_tfm_alg_name(tfm));
}
struct rk_crypto_tmp rk_v2_ahash_md5 = RK_HASH_ALGO_INIT(MD5, md5);
struct rk_crypto_tmp rk_v2_ahash_sha1 = RK_HASH_ALGO_INIT(SHA1, sha1);
struct rk_crypto_tmp rk_v2_ahash_sha256 = RK_HASH_ALGO_INIT(SHA256, sha256);
struct rk_crypto_tmp rk_v2_ahash_sha512 = RK_HASH_ALGO_INIT(SHA512, sha512);
struct rk_crypto_tmp rk_v2_ahash_sm3 = RK_HASH_ALGO_INIT(SM3, sm3);
struct rk_crypto_algt rk_v2_ahash_md5 = RK_HASH_ALGO_INIT(MD5, md5);
struct rk_crypto_algt rk_v2_ahash_sha1 = RK_HASH_ALGO_INIT(SHA1, sha1);
struct rk_crypto_algt rk_v2_ahash_sha256 = RK_HASH_ALGO_INIT(SHA256, sha256);
struct rk_crypto_algt rk_v2_ahash_sha512 = RK_HASH_ALGO_INIT(SHA512, sha512);
struct rk_crypto_algt rk_v2_ahash_sm3 = RK_HASH_ALGO_INIT(SM3, sm3);
struct rk_crypto_tmp rk_v2_ahash_hmac_md5 = RK_HMAC_ALGO_INIT(MD5, md5);
struct rk_crypto_tmp rk_v2_ahash_hmac_sha1 = RK_HMAC_ALGO_INIT(SHA1, sha1);
struct rk_crypto_tmp rk_v2_ahash_hmac_sha256 = RK_HMAC_ALGO_INIT(SHA256, sha256);
struct rk_crypto_tmp rk_v2_ahash_hmac_sha512 = RK_HMAC_ALGO_INIT(SHA512, sha512);
struct rk_crypto_tmp rk_v2_ahash_hmac_sm3 = RK_HMAC_ALGO_INIT(SM3, sm3);
struct rk_crypto_algt rk_v2_hmac_md5 = RK_HMAC_ALGO_INIT(MD5, md5);
struct rk_crypto_algt rk_v2_hmac_sha1 = RK_HMAC_ALGO_INIT(SHA1, sha1);
struct rk_crypto_algt rk_v2_hmac_sha256 = RK_HMAC_ALGO_INIT(SHA256, sha256);
struct rk_crypto_algt rk_v2_hmac_sha512 = RK_HMAC_ALGO_INIT(SHA512, sha512);
struct rk_crypto_algt rk_v2_hmac_sm3 = RK_HMAC_ALGO_INIT(SM3, sm3);

36
drivers/crypto/rockchip/rk_crypto_v2_akcipher.c
View File

@@ -162,7 +162,7 @@ static int rk_rsa_calc(struct akcipher_request *req, bool encypt)
goto exit;
if (!sg_copy_to_buffer(req->src, sg_nents(req->src), tmp_buf, req->src_len)) {
dev_err(ctx->dev->dev, "[%s:%d] sg copy err\n",
dev_err(ctx->rk_dev->dev, "[%s:%d] sg copy err\n",
__func__, __LINE__);
ret = -EINVAL;
goto exit;
@@ -190,7 +190,7 @@ static int rk_rsa_calc(struct akcipher_request *req, bool encypt)
CRYPTO_DUMPHEX("tmp_buf = ", tmp_buf, key_byte_size);
if (!sg_copy_from_buffer(req->dst, sg_nents(req->dst), tmp_buf, key_byte_size)) {
dev_err(ctx->dev->dev, "[%s:%d] sg copy err\n",
dev_err(ctx->rk_dev->dev, "[%s:%d] sg copy err\n",
__func__, __LINE__);
ret = -EINVAL;
goto exit;
@@ -222,14 +222,14 @@ static int rk_rsa_dec(struct akcipher_request *req)
return rk_rsa_calc(req, false);
}
static int rk_rsa_start(struct rk_crypto_info *dev)
static int rk_rsa_start(struct rk_crypto_dev *rk_dev)
{
CRYPTO_TRACE();
return -ENOSYS;
}
static int rk_rsa_crypto_rx(struct rk_crypto_info *dev)
static int rk_rsa_crypto_rx(struct rk_crypto_dev *rk_dev)
{
CRYPTO_TRACE();
@@ -246,27 +246,27 @@ static int rk_rsa_init_tfm(struct crypto_akcipher *tfm)
{
struct rk_rsa_ctx *ctx = akcipher_tfm_ctx(tfm);
struct akcipher_alg *alg = __crypto_akcipher_alg(tfm->base.__crt_alg);
struct rk_crypto_tmp *algt;
struct rk_crypto_info *info;
struct rk_crypto_algt *algt;
struct rk_crypto_dev *rk_dev;
CRYPTO_TRACE();
algt = container_of(alg, struct rk_crypto_tmp, alg.asym);
info = algt->dev;
algt = container_of(alg, struct rk_crypto_algt, alg.asym);
rk_dev = algt->rk_dev;
if (!info->request_crypto)
if (!rk_dev->request_crypto)
return -EFAULT;
info->request_crypto(info, "rsa");
rk_dev->request_crypto(rk_dev, "rsa");
info->align_size = crypto_tfm_alg_alignmask(&tfm->base) + 1;
info->start = rk_rsa_start;
info->update = rk_rsa_crypto_rx;
info->complete = rk_rsa_complete;
rk_dev->align_size = crypto_tfm_alg_alignmask(&tfm->base) + 1;
rk_dev->start = rk_rsa_start;
rk_dev->update = rk_rsa_crypto_rx;
rk_dev->complete = rk_rsa_complete;
ctx->dev = info;
ctx->rk_dev = rk_dev;
rk_pka_set_crypto_base(ctx->dev->pka_reg);
rk_pka_set_crypto_base(ctx->rk_dev->pka_reg);
return 0;
}
@@ -279,10 +279,10 @@ static void rk_rsa_exit_tfm(struct crypto_akcipher *tfm)
rk_rsa_clear_ctx(ctx);
ctx->dev->release_crypto(ctx->dev, "rsa");
ctx->rk_dev->release_crypto(ctx->rk_dev, "rsa");
}
struct rk_crypto_tmp rk_v2_asym_rsa = {
struct rk_crypto_algt rk_v2_asym_rsa = {
.name = "rsa",
.type = ALG_TYPE_ASYM,
.alg.asym = {

5
drivers/crypto/rockchip/rk_crypto_v2_reg.h
View File

@@ -319,10 +319,5 @@
#define CRYPTO_SRAM_BASE (0x01000 - CRYPTO_PKA_BASE_OFFSET)
#define CRYPTO_SRAM_SIZE 0x01000
enum endian_mode {
BIG_ENDIAN = 0,
LITTLE_ENDIAN
};
#endif