diff --git a/drivers/crypto/rockchip/rk_crypto_core.c b/drivers/crypto/rockchip/rk_crypto_core.c
index 9bf7b65acdee..07a2256edb97 100644
--- a/drivers/crypto/rockchip/rk_crypto_core.c
+++ b/drivers/crypto/rockchip/rk_crypto_core.c
@@ -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;
 }
diff --git a/drivers/crypto/rockchip/rk_crypto_core.h b/drivers/crypto/rockchip/rk_crypto_core.h
index 8b81fc4364a6..d04c1f8f39bd 100644
--- a/drivers/crypto/rockchip/rk_crypto_core.h
+++ b/drivers/crypto/rockchip/rk_crypto_core.h
@@ -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;
diff --git a/drivers/crypto/rockchip/rk_crypto_v1.h b/drivers/crypto/rockchip/rk_crypto_v1.h
index 348257428009..d02ad537871a 100644
--- a/drivers/crypto/rockchip/rk_crypto_v1.h
+++ b/drivers/crypto/rockchip/rk_crypto_v1.h
@@ -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);
diff --git a/drivers/crypto/rockchip/rk_crypto_v1_ablkcipher.c b/drivers/crypto/rockchip/rk_crypto_v1_ablkcipher.c
index 69ad820ffe48..3a1376b1e455 100644
--- a/drivers/crypto/rockchip/rk_crypto_v1_ablkcipher.c
+++ b/drivers/crypto/rockchip/rk_crypto_v1_ablkcipher.c
@@ -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);
diff --git a/drivers/crypto/rockchip/rk_crypto_v1_ahash.c b/drivers/crypto/rockchip/rk_crypto_v1_ahash.c
index 0bc93fde535c..853036791aa1 100644
--- a/drivers/crypto/rockchip/rk_crypto_v1_ahash.c
+++ b/drivers/crypto/rockchip/rk_crypto_v1_ahash.c
@@ -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);
 
diff --git a/drivers/crypto/rockchip/rk_crypto_v2.h b/drivers/crypto/rockchip/rk_crypto_v2.h
index 76253ea34728..a166fc6effdf 100644
--- a/drivers/crypto/rockchip/rk_crypto_v2.h
+++ b/drivers/crypto/rockchip/rk_crypto_v2.h
@@ -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);
diff --git a/drivers/crypto/rockchip/rk_crypto_v2_ablkcipher.c b/drivers/crypto/rockchip/rk_crypto_v2_ablkcipher.c
index 87b09a539f21..d47260c79b5d 100644
--- a/drivers/crypto/rockchip/rk_crypto_v2_ablkcipher.c
+++ b/drivers/crypto/rockchip/rk_crypto_v2_ablkcipher.c
@@ -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);
 
diff --git a/drivers/crypto/rockchip/rk_crypto_v2_ahash.c b/drivers/crypto/rockchip/rk_crypto_v2_ahash.c
index 71ba22dc8c03..d3b04f1f1909 100644
--- a/drivers/crypto/rockchip/rk_crypto_v2_ahash.c
+++ b/drivers/crypto/rockchip/rk_crypto_v2_ahash.c
@@ -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);
 
diff --git a/drivers/crypto/rockchip/rk_crypto_v2_akcipher.c b/drivers/crypto/rockchip/rk_crypto_v2_akcipher.c
index 4daf1e94b158..2781c963fd0b 100644
--- a/drivers/crypto/rockchip/rk_crypto_v2_akcipher.c
+++ b/drivers/crypto/rockchip/rk_crypto_v2_akcipher.c
@@ -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 = {
diff --git a/drivers/crypto/rockchip/rk_crypto_v2_reg.h b/drivers/crypto/rockchip/rk_crypto_v2_reg.h
index 69330dd967bd..c2a0ef10e85e 100644
--- a/drivers/crypto/rockchip/rk_crypto_v2_reg.h
+++ b/drivers/crypto/rockchip/rk_crypto_v2_reg.h
@@ -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