crypto: sun8i-ce - Use new crypto_engine_op interface (07e34cd3) · Commits · EulixOS / Software / Kernel

drivers/crypto/allwinner/sun8i-ce/sun8i-ce-cipher.c

+14 −11

Original line number	Original line	Diff line number	Diff line
	@@ -29,7 +29,7 @@ static int sun8i_ce_cipher_need_fallback(struct skcipher_request *areq)
	struct sun8i_ce_alg_template *algt;		struct sun8i_ce_alg_template *algt;
	unsigned int todo, len;		unsigned int todo, len;

	algt = container_of(alg, struct sun8i_ce_alg_template, alg.skcipher);		algt = container_of(alg, struct sun8i_ce_alg_template, alg.skcipher.base);

	if (sg_nents_for_len(areq->src, areq->cryptlen) > MAX_SG \|\|		if (sg_nents_for_len(areq->src, areq->cryptlen) > MAX_SG \|\|
	sg_nents_for_len(areq->dst, areq->cryptlen) > MAX_SG) {		sg_nents_for_len(areq->dst, areq->cryptlen) > MAX_SG) {
	@@ -92,13 +92,18 @@ static int sun8i_ce_cipher_fallback(struct skcipher_request *areq)
	struct sun8i_cipher_tfm_ctx *op = crypto_skcipher_ctx(tfm);		struct sun8i_cipher_tfm_ctx *op = crypto_skcipher_ctx(tfm);
	struct sun8i_cipher_req_ctx *rctx = skcipher_request_ctx(areq);		struct sun8i_cipher_req_ctx *rctx = skcipher_request_ctx(areq);
	int err;		int err;
	#ifdef CONFIG_CRYPTO_DEV_SUN8I_CE_DEBUG
			if (IS_ENABLED(CONFIG_CRYPTO_DEV_SUN8I_CE_DEBUG)) {
	struct skcipher_alg *alg = crypto_skcipher_alg(tfm);		struct skcipher_alg *alg = crypto_skcipher_alg(tfm);
	struct sun8i_ce_alg_template *algt;		struct sun8i_ce_alg_template *algt __maybe_unused;

			algt = container_of(alg, struct sun8i_ce_alg_template,
			alg.skcipher.base);

	algt = container_of(alg, struct sun8i_ce_alg_template, alg.skcipher);		#ifdef CONFIG_CRYPTO_DEV_SUN8I_CE_DEBUG
	algt->stat_fb++;		algt->stat_fb++;
	#endif		#endif
			}

	skcipher_request_set_tfm(&rctx->fallback_req, op->fallback_tfm);		skcipher_request_set_tfm(&rctx->fallback_req, op->fallback_tfm);
	skcipher_request_set_callback(&rctx->fallback_req, areq->base.flags,		skcipher_request_set_callback(&rctx->fallback_req, areq->base.flags,
	@@ -133,7 +138,7 @@ static int sun8i_ce_cipher_prepare(struct crypto_engine engine, void async_req
	int ns = sg_nents_for_len(areq->src, areq->cryptlen);		int ns = sg_nents_for_len(areq->src, areq->cryptlen);
	int nd = sg_nents_for_len(areq->dst, areq->cryptlen);		int nd = sg_nents_for_len(areq->dst, areq->cryptlen);

	algt = container_of(alg, struct sun8i_ce_alg_template, alg.skcipher);		algt = container_of(alg, struct sun8i_ce_alg_template, alg.skcipher.base);

	dev_dbg(ce->dev, "%s %s %u %x IV(%p %u) key=%u\n", __func__,		dev_dbg(ce->dev, "%s %s %u %x IV(%p %u) key=%u\n", __func__,
	crypto_tfm_alg_name(areq->base.tfm),		crypto_tfm_alg_name(areq->base.tfm),
	@@ -355,7 +360,7 @@ static void sun8i_ce_cipher_unprepare(struct crypto_engine *engine,
	dma_unmap_single(ce->dev, rctx->addr_key, op->keylen, DMA_TO_DEVICE);		dma_unmap_single(ce->dev, rctx->addr_key, op->keylen, DMA_TO_DEVICE);
	}		}

	static int sun8i_ce_cipher_do_one(struct crypto_engine engine, void areq)		int sun8i_ce_cipher_do_one(struct crypto_engine engine, void areq)
	{		{
	int err = sun8i_ce_cipher_prepare(engine, areq);		int err = sun8i_ce_cipher_prepare(engine, areq);

	@@ -416,7 +421,7 @@ int sun8i_ce_cipher_init(struct crypto_tfm *tfm)

	memset(op, 0, sizeof(struct sun8i_cipher_tfm_ctx));		memset(op, 0, sizeof(struct sun8i_cipher_tfm_ctx));

	algt = container_of(alg, struct sun8i_ce_alg_template, alg.skcipher);		algt = container_of(alg, struct sun8i_ce_alg_template, alg.skcipher.base);
	op->ce = algt->ce;		op->ce = algt->ce;

	op->fallback_tfm = crypto_alloc_skcipher(name, 0, CRYPTO_ALG_NEED_FALLBACK);		op->fallback_tfm = crypto_alloc_skcipher(name, 0, CRYPTO_ALG_NEED_FALLBACK);
	@@ -433,8 +438,6 @@ int sun8i_ce_cipher_init(struct crypto_tfm *tfm)
	crypto_tfm_alg_driver_name(crypto_skcipher_tfm(op->fallback_tfm)),		crypto_tfm_alg_driver_name(crypto_skcipher_tfm(op->fallback_tfm)),
	CRYPTO_MAX_ALG_NAME);		CRYPTO_MAX_ALG_NAME);

	op->enginectx.op.do_one_request = sun8i_ce_cipher_do_one;

	err = pm_runtime_get_sync(op->ce->dev);		err = pm_runtime_get_sync(op->ce->dev);
	if (err < 0)		if (err < 0)
	goto error_pm;		goto error_pm;

drivers/crypto/allwinner/sun8i-ce/sun8i-ce-core.c

+109 −62

Original line number	Original line	Diff line number	Diff line
	@@ -9,21 +9,25 @@
	*		*
	* You could find a link for the datasheet in Documentation/arch/arm/sunxi.rst		* You could find a link for the datasheet in Documentation/arch/arm/sunxi.rst
	*/		*/

			#include <crypto/engine.h>
			#include <crypto/internal/hash.h>
			#include <crypto/internal/rng.h>
			#include <crypto/internal/skcipher.h>
	#include <linux/clk.h>		#include <linux/clk.h>
	#include <linux/crypto.h>
	#include <linux/delay.h>		#include <linux/delay.h>
	#include <linux/dma-mapping.h>		#include <linux/dma-mapping.h>
			#include <linux/err.h>
	#include <linux/interrupt.h>		#include <linux/interrupt.h>
	#include <linux/io.h>		#include <linux/io.h>
	#include <linux/irq.h>		#include <linux/irq.h>
			#include <linux/kernel.h>
	#include <linux/module.h>		#include <linux/module.h>
	#include <linux/of.h>		#include <linux/of.h>
	#include <linux/of_device.h>		#include <linux/of_device.h>
	#include <linux/platform_device.h>		#include <linux/platform_device.h>
	#include <linux/pm_runtime.h>		#include <linux/pm_runtime.h>
	#include <linux/reset.h>		#include <linux/reset.h>
	#include <crypto/internal/rng.h>
	#include <crypto/internal/skcipher.h>

	#include "sun8i-ce.h"		#include "sun8i-ce.h"

	@@ -277,7 +281,7 @@ static struct sun8i_ce_alg_template ce_algs[] = {
	.type = CRYPTO_ALG_TYPE_SKCIPHER,		.type = CRYPTO_ALG_TYPE_SKCIPHER,
	.ce_algo_id = CE_ID_CIPHER_AES,		.ce_algo_id = CE_ID_CIPHER_AES,
	.ce_blockmode = CE_ID_OP_CBC,		.ce_blockmode = CE_ID_OP_CBC,
	.alg.skcipher = {		.alg.skcipher.base = {
	.base = {		.base = {
	.cra_name = "cbc(aes)",		.cra_name = "cbc(aes)",
	.cra_driver_name = "cbc-aes-sun8i-ce",		.cra_driver_name = "cbc-aes-sun8i-ce",
	@@ -298,13 +302,16 @@ static struct sun8i_ce_alg_template ce_algs[] = {
	.setkey = sun8i_ce_aes_setkey,		.setkey = sun8i_ce_aes_setkey,
	.encrypt = sun8i_ce_skencrypt,		.encrypt = sun8i_ce_skencrypt,
	.decrypt = sun8i_ce_skdecrypt,		.decrypt = sun8i_ce_skdecrypt,
	}		},
			.alg.skcipher.op = {
			.do_one_request = sun8i_ce_cipher_do_one,
			},
	},		},
	{		{
	.type = CRYPTO_ALG_TYPE_SKCIPHER,		.type = CRYPTO_ALG_TYPE_SKCIPHER,
	.ce_algo_id = CE_ID_CIPHER_AES,		.ce_algo_id = CE_ID_CIPHER_AES,
	.ce_blockmode = CE_ID_OP_ECB,		.ce_blockmode = CE_ID_OP_ECB,
	.alg.skcipher = {		.alg.skcipher.base = {
	.base = {		.base = {
	.cra_name = "ecb(aes)",		.cra_name = "ecb(aes)",
	.cra_driver_name = "ecb-aes-sun8i-ce",		.cra_driver_name = "ecb-aes-sun8i-ce",
	@@ -324,13 +331,16 @@ static struct sun8i_ce_alg_template ce_algs[] = {
	.setkey = sun8i_ce_aes_setkey,		.setkey = sun8i_ce_aes_setkey,
	.encrypt = sun8i_ce_skencrypt,		.encrypt = sun8i_ce_skencrypt,
	.decrypt = sun8i_ce_skdecrypt,		.decrypt = sun8i_ce_skdecrypt,
	}		},
			.alg.skcipher.op = {
			.do_one_request = sun8i_ce_cipher_do_one,
			},
	},		},
	{		{
	.type = CRYPTO_ALG_TYPE_SKCIPHER,		.type = CRYPTO_ALG_TYPE_SKCIPHER,
	.ce_algo_id = CE_ID_CIPHER_DES3,		.ce_algo_id = CE_ID_CIPHER_DES3,
	.ce_blockmode = CE_ID_OP_CBC,		.ce_blockmode = CE_ID_OP_CBC,
	.alg.skcipher = {		.alg.skcipher.base = {
	.base = {		.base = {
	.cra_name = "cbc(des3_ede)",		.cra_name = "cbc(des3_ede)",
	.cra_driver_name = "cbc-des3-sun8i-ce",		.cra_driver_name = "cbc-des3-sun8i-ce",
	@@ -351,13 +361,16 @@ static struct sun8i_ce_alg_template ce_algs[] = {
	.setkey = sun8i_ce_des3_setkey,		.setkey = sun8i_ce_des3_setkey,
	.encrypt = sun8i_ce_skencrypt,		.encrypt = sun8i_ce_skencrypt,
	.decrypt = sun8i_ce_skdecrypt,		.decrypt = sun8i_ce_skdecrypt,
	}		},
			.alg.skcipher.op = {
			.do_one_request = sun8i_ce_cipher_do_one,
			},
	},		},
	{		{
	.type = CRYPTO_ALG_TYPE_SKCIPHER,		.type = CRYPTO_ALG_TYPE_SKCIPHER,
	.ce_algo_id = CE_ID_CIPHER_DES3,		.ce_algo_id = CE_ID_CIPHER_DES3,
	.ce_blockmode = CE_ID_OP_ECB,		.ce_blockmode = CE_ID_OP_ECB,
	.alg.skcipher = {		.alg.skcipher.base = {
	.base = {		.base = {
	.cra_name = "ecb(des3_ede)",		.cra_name = "ecb(des3_ede)",
	.cra_driver_name = "ecb-des3-sun8i-ce",		.cra_driver_name = "ecb-des3-sun8i-ce",
	@@ -377,12 +390,15 @@ static struct sun8i_ce_alg_template ce_algs[] = {
	.setkey = sun8i_ce_des3_setkey,		.setkey = sun8i_ce_des3_setkey,
	.encrypt = sun8i_ce_skencrypt,		.encrypt = sun8i_ce_skencrypt,
	.decrypt = sun8i_ce_skdecrypt,		.decrypt = sun8i_ce_skdecrypt,
	}		},
			.alg.skcipher.op = {
			.do_one_request = sun8i_ce_cipher_do_one,
			},
	},		},
	#ifdef CONFIG_CRYPTO_DEV_SUN8I_CE_HASH		#ifdef CONFIG_CRYPTO_DEV_SUN8I_CE_HASH
	{ .type = CRYPTO_ALG_TYPE_AHASH,		{ .type = CRYPTO_ALG_TYPE_AHASH,
	.ce_algo_id = CE_ID_HASH_MD5,		.ce_algo_id = CE_ID_HASH_MD5,
	.alg.hash = {		.alg.hash.base = {
	.init = sun8i_ce_hash_init,		.init = sun8i_ce_hash_init,
	.update = sun8i_ce_hash_update,		.update = sun8i_ce_hash_update,
	.final = sun8i_ce_hash_final,		.final = sun8i_ce_hash_final,
	@@ -390,6 +406,8 @@ static struct sun8i_ce_alg_template ce_algs[] = {
	.digest = sun8i_ce_hash_digest,		.digest = sun8i_ce_hash_digest,
	.export = sun8i_ce_hash_export,		.export = sun8i_ce_hash_export,
	.import = sun8i_ce_hash_import,		.import = sun8i_ce_hash_import,
			.init_tfm = sun8i_ce_hash_init_tfm,
			.exit_tfm = sun8i_ce_hash_exit_tfm,
	.halg = {		.halg = {
	.digestsize = MD5_DIGEST_SIZE,		.digestsize = MD5_DIGEST_SIZE,
	.statesize = sizeof(struct md5_state),		.statesize = sizeof(struct md5_state),
	@@ -404,15 +422,17 @@ static struct sun8i_ce_alg_template ce_algs[] = {
	.cra_blocksize = MD5_HMAC_BLOCK_SIZE,		.cra_blocksize = MD5_HMAC_BLOCK_SIZE,
	.cra_ctxsize = sizeof(struct sun8i_ce_hash_tfm_ctx),		.cra_ctxsize = sizeof(struct sun8i_ce_hash_tfm_ctx),
	.cra_module = THIS_MODULE,		.cra_module = THIS_MODULE,
	.cra_init = sun8i_ce_hash_crainit,
	.cra_exit = sun8i_ce_hash_craexit,
	}
	}		}
	}		}
	},		},
			.alg.hash.op = {
			.do_one_request = sun8i_ce_hash_run,
			},

			},
	{ .type = CRYPTO_ALG_TYPE_AHASH,		{ .type = CRYPTO_ALG_TYPE_AHASH,
	.ce_algo_id = CE_ID_HASH_SHA1,		.ce_algo_id = CE_ID_HASH_SHA1,
	.alg.hash = {		.alg.hash.base = {
	.init = sun8i_ce_hash_init,		.init = sun8i_ce_hash_init,
	.update = sun8i_ce_hash_update,		.update = sun8i_ce_hash_update,
	.final = sun8i_ce_hash_final,		.final = sun8i_ce_hash_final,
	@@ -420,6 +440,8 @@ static struct sun8i_ce_alg_template ce_algs[] = {
	.digest = sun8i_ce_hash_digest,		.digest = sun8i_ce_hash_digest,
	.export = sun8i_ce_hash_export,		.export = sun8i_ce_hash_export,
	.import = sun8i_ce_hash_import,		.import = sun8i_ce_hash_import,
			.init_tfm = sun8i_ce_hash_init_tfm,
			.exit_tfm = sun8i_ce_hash_exit_tfm,
	.halg = {		.halg = {
	.digestsize = SHA1_DIGEST_SIZE,		.digestsize = SHA1_DIGEST_SIZE,
	.statesize = sizeof(struct sha1_state),		.statesize = sizeof(struct sha1_state),
	@@ -434,15 +456,16 @@ static struct sun8i_ce_alg_template ce_algs[] = {
	.cra_blocksize = SHA1_BLOCK_SIZE,		.cra_blocksize = SHA1_BLOCK_SIZE,
	.cra_ctxsize = sizeof(struct sun8i_ce_hash_tfm_ctx),		.cra_ctxsize = sizeof(struct sun8i_ce_hash_tfm_ctx),
	.cra_module = THIS_MODULE,		.cra_module = THIS_MODULE,
	.cra_init = sun8i_ce_hash_crainit,
	.cra_exit = sun8i_ce_hash_craexit,
	}
	}		}
	}		}
	},		},
			.alg.hash.op = {
			.do_one_request = sun8i_ce_hash_run,
			},
			},
	{ .type = CRYPTO_ALG_TYPE_AHASH,		{ .type = CRYPTO_ALG_TYPE_AHASH,
	.ce_algo_id = CE_ID_HASH_SHA224,		.ce_algo_id = CE_ID_HASH_SHA224,
	.alg.hash = {		.alg.hash.base = {
	.init = sun8i_ce_hash_init,		.init = sun8i_ce_hash_init,
	.update = sun8i_ce_hash_update,		.update = sun8i_ce_hash_update,
	.final = sun8i_ce_hash_final,		.final = sun8i_ce_hash_final,
	@@ -450,6 +473,8 @@ static struct sun8i_ce_alg_template ce_algs[] = {
	.digest = sun8i_ce_hash_digest,		.digest = sun8i_ce_hash_digest,
	.export = sun8i_ce_hash_export,		.export = sun8i_ce_hash_export,
	.import = sun8i_ce_hash_import,		.import = sun8i_ce_hash_import,
			.init_tfm = sun8i_ce_hash_init_tfm,
			.exit_tfm = sun8i_ce_hash_exit_tfm,
	.halg = {		.halg = {
	.digestsize = SHA224_DIGEST_SIZE,		.digestsize = SHA224_DIGEST_SIZE,
	.statesize = sizeof(struct sha256_state),		.statesize = sizeof(struct sha256_state),
	@@ -464,15 +489,16 @@ static struct sun8i_ce_alg_template ce_algs[] = {
	.cra_blocksize = SHA224_BLOCK_SIZE,		.cra_blocksize = SHA224_BLOCK_SIZE,
	.cra_ctxsize = sizeof(struct sun8i_ce_hash_tfm_ctx),		.cra_ctxsize = sizeof(struct sun8i_ce_hash_tfm_ctx),
	.cra_module = THIS_MODULE,		.cra_module = THIS_MODULE,
	.cra_init = sun8i_ce_hash_crainit,
	.cra_exit = sun8i_ce_hash_craexit,
	}
	}		}
	}		}
	},		},
			.alg.hash.op = {
			.do_one_request = sun8i_ce_hash_run,
			},
			},
	{ .type = CRYPTO_ALG_TYPE_AHASH,		{ .type = CRYPTO_ALG_TYPE_AHASH,
	.ce_algo_id = CE_ID_HASH_SHA256,		.ce_algo_id = CE_ID_HASH_SHA256,
	.alg.hash = {		.alg.hash.base = {
	.init = sun8i_ce_hash_init,		.init = sun8i_ce_hash_init,
	.update = sun8i_ce_hash_update,		.update = sun8i_ce_hash_update,
	.final = sun8i_ce_hash_final,		.final = sun8i_ce_hash_final,
	@@ -480,6 +506,8 @@ static struct sun8i_ce_alg_template ce_algs[] = {
	.digest = sun8i_ce_hash_digest,		.digest = sun8i_ce_hash_digest,
	.export = sun8i_ce_hash_export,		.export = sun8i_ce_hash_export,
	.import = sun8i_ce_hash_import,		.import = sun8i_ce_hash_import,
			.init_tfm = sun8i_ce_hash_init_tfm,
			.exit_tfm = sun8i_ce_hash_exit_tfm,
	.halg = {		.halg = {
	.digestsize = SHA256_DIGEST_SIZE,		.digestsize = SHA256_DIGEST_SIZE,
	.statesize = sizeof(struct sha256_state),		.statesize = sizeof(struct sha256_state),
	@@ -494,15 +522,16 @@ static struct sun8i_ce_alg_template ce_algs[] = {
	.cra_blocksize = SHA256_BLOCK_SIZE,		.cra_blocksize = SHA256_BLOCK_SIZE,
	.cra_ctxsize = sizeof(struct sun8i_ce_hash_tfm_ctx),		.cra_ctxsize = sizeof(struct sun8i_ce_hash_tfm_ctx),
	.cra_module = THIS_MODULE,		.cra_module = THIS_MODULE,
	.cra_init = sun8i_ce_hash_crainit,
	.cra_exit = sun8i_ce_hash_craexit,
	}
	}		}
	}		}
	},		},
			.alg.hash.op = {
			.do_one_request = sun8i_ce_hash_run,
			},
			},
	{ .type = CRYPTO_ALG_TYPE_AHASH,		{ .type = CRYPTO_ALG_TYPE_AHASH,
	.ce_algo_id = CE_ID_HASH_SHA384,		.ce_algo_id = CE_ID_HASH_SHA384,
	.alg.hash = {		.alg.hash.base = {
	.init = sun8i_ce_hash_init,		.init = sun8i_ce_hash_init,
	.update = sun8i_ce_hash_update,		.update = sun8i_ce_hash_update,
	.final = sun8i_ce_hash_final,		.final = sun8i_ce_hash_final,
	@@ -510,6 +539,8 @@ static struct sun8i_ce_alg_template ce_algs[] = {
	.digest = sun8i_ce_hash_digest,		.digest = sun8i_ce_hash_digest,
	.export = sun8i_ce_hash_export,		.export = sun8i_ce_hash_export,
	.import = sun8i_ce_hash_import,		.import = sun8i_ce_hash_import,
			.init_tfm = sun8i_ce_hash_init_tfm,
			.exit_tfm = sun8i_ce_hash_exit_tfm,
	.halg = {		.halg = {
	.digestsize = SHA384_DIGEST_SIZE,		.digestsize = SHA384_DIGEST_SIZE,
	.statesize = sizeof(struct sha512_state),		.statesize = sizeof(struct sha512_state),
	@@ -524,15 +555,16 @@ static struct sun8i_ce_alg_template ce_algs[] = {
	.cra_blocksize = SHA384_BLOCK_SIZE,		.cra_blocksize = SHA384_BLOCK_SIZE,
	.cra_ctxsize = sizeof(struct sun8i_ce_hash_tfm_ctx),		.cra_ctxsize = sizeof(struct sun8i_ce_hash_tfm_ctx),
	.cra_module = THIS_MODULE,		.cra_module = THIS_MODULE,
	.cra_init = sun8i_ce_hash_crainit,
	.cra_exit = sun8i_ce_hash_craexit,
	}
	}		}
	}		}
	},		},
			.alg.hash.op = {
			.do_one_request = sun8i_ce_hash_run,
			},
			},
	{ .type = CRYPTO_ALG_TYPE_AHASH,		{ .type = CRYPTO_ALG_TYPE_AHASH,
	.ce_algo_id = CE_ID_HASH_SHA512,		.ce_algo_id = CE_ID_HASH_SHA512,
	.alg.hash = {		.alg.hash.base = {
	.init = sun8i_ce_hash_init,		.init = sun8i_ce_hash_init,
	.update = sun8i_ce_hash_update,		.update = sun8i_ce_hash_update,
	.final = sun8i_ce_hash_final,		.final = sun8i_ce_hash_final,
	@@ -540,6 +572,8 @@ static struct sun8i_ce_alg_template ce_algs[] = {
	.digest = sun8i_ce_hash_digest,		.digest = sun8i_ce_hash_digest,
	.export = sun8i_ce_hash_export,		.export = sun8i_ce_hash_export,
	.import = sun8i_ce_hash_import,		.import = sun8i_ce_hash_import,
			.init_tfm = sun8i_ce_hash_init_tfm,
			.exit_tfm = sun8i_ce_hash_exit_tfm,
	.halg = {		.halg = {
	.digestsize = SHA512_DIGEST_SIZE,		.digestsize = SHA512_DIGEST_SIZE,
	.statesize = sizeof(struct sha512_state),		.statesize = sizeof(struct sha512_state),
	@@ -554,12 +588,13 @@ static struct sun8i_ce_alg_template ce_algs[] = {
	.cra_blocksize = SHA512_BLOCK_SIZE,		.cra_blocksize = SHA512_BLOCK_SIZE,
	.cra_ctxsize = sizeof(struct sun8i_ce_hash_tfm_ctx),		.cra_ctxsize = sizeof(struct sun8i_ce_hash_tfm_ctx),
	.cra_module = THIS_MODULE,		.cra_module = THIS_MODULE,
	.cra_init = sun8i_ce_hash_crainit,
	.cra_exit = sun8i_ce_hash_craexit,
	}
	}		}
	}		}
	},		},
			.alg.hash.op = {
			.do_one_request = sun8i_ce_hash_run,
			},
			},
	#endif		#endif
	#ifdef CONFIG_CRYPTO_DEV_SUN8I_CE_PRNG		#ifdef CONFIG_CRYPTO_DEV_SUN8I_CE_PRNG
	{		{
	@@ -582,14 +617,18 @@ static struct sun8i_ce_alg_template ce_algs[] = {
	#endif		#endif
	};		};

	#ifdef CONFIG_CRYPTO_DEV_SUN8I_CE_DEBUG
	static int sun8i_ce_debugfs_show(struct seq_file seq, void v)		static int sun8i_ce_debugfs_show(struct seq_file seq, void v)
	{		{
	struct sun8i_ce_dev *ce = seq->private;		struct sun8i_ce_dev *ce __maybe_unused = seq->private;
	unsigned int i;		unsigned int i;

	for (i = 0; i < MAXFLOW; i++)		for (i = 0; i < MAXFLOW; i++)
	seq_printf(seq, "Channel %d: nreq %lu\n", i, ce->chanlist[i].stat_req);		seq_printf(seq, "Channel %d: nreq %lu\n", i,
			#ifdef CONFIG_CRYPTO_DEV_SUN8I_CE_DEBUG
			ce->chanlist[i].stat_req);
			#else
			0ul);
			#endif

	for (i = 0; i < ARRAY_SIZE(ce_algs); i++) {		for (i = 0; i < ARRAY_SIZE(ce_algs); i++) {
	if (!ce_algs[i].ce)		if (!ce_algs[i].ce)
	@@ -597,8 +636,8 @@ static int sun8i_ce_debugfs_show(struct seq_file seq, void v)
	switch (ce_algs[i].type) {		switch (ce_algs[i].type) {
	case CRYPTO_ALG_TYPE_SKCIPHER:		case CRYPTO_ALG_TYPE_SKCIPHER:
	seq_printf(seq, "%s %s reqs=%lu fallback=%lu\n",		seq_printf(seq, "%s %s reqs=%lu fallback=%lu\n",
	ce_algs[i].alg.skcipher.base.cra_driver_name,		ce_algs[i].alg.skcipher.base.base.cra_driver_name,
	ce_algs[i].alg.skcipher.base.cra_name,		ce_algs[i].alg.skcipher.base.base.cra_name,
	ce_algs[i].stat_req, ce_algs[i].stat_fb);		ce_algs[i].stat_req, ce_algs[i].stat_fb);
	seq_printf(seq, "\tLast fallback is: %s\n",		seq_printf(seq, "\tLast fallback is: %s\n",
	ce_algs[i].fbname);		ce_algs[i].fbname);
	@@ -621,8 +660,8 @@ static int sun8i_ce_debugfs_show(struct seq_file seq, void v)
	break;		break;
	case CRYPTO_ALG_TYPE_AHASH:		case CRYPTO_ALG_TYPE_AHASH:
	seq_printf(seq, "%s %s reqs=%lu fallback=%lu\n",		seq_printf(seq, "%s %s reqs=%lu fallback=%lu\n",
	ce_algs[i].alg.hash.halg.base.cra_driver_name,		ce_algs[i].alg.hash.base.halg.base.cra_driver_name,
	ce_algs[i].alg.hash.halg.base.cra_name,		ce_algs[i].alg.hash.base.halg.base.cra_name,
	ce_algs[i].stat_req, ce_algs[i].stat_fb);		ce_algs[i].stat_req, ce_algs[i].stat_fb);
	seq_printf(seq, "\tLast fallback is: %s\n",		seq_printf(seq, "\tLast fallback is: %s\n",
	ce_algs[i].fbname);		ce_algs[i].fbname);
	@@ -643,7 +682,8 @@ static int sun8i_ce_debugfs_show(struct seq_file seq, void v)
	break;		break;
	}		}
	}		}
	#ifdef CONFIG_CRYPTO_DEV_SUN8I_CE_TRNG		#if defined(CONFIG_CRYPTO_DEV_SUN8I_CE_TRNG) && \
			defined(CONFIG_CRYPTO_DEV_SUN8I_CE_DEBUG)
	seq_printf(seq, "HWRNG %lu %lu\n",		seq_printf(seq, "HWRNG %lu %lu\n",
	ce->hwrng_stat_req, ce->hwrng_stat_bytes);		ce->hwrng_stat_req, ce->hwrng_stat_bytes);
	#endif		#endif
	@@ -651,7 +691,6 @@ static int sun8i_ce_debugfs_show(struct seq_file seq, void v)
	}		}

	DEFINE_SHOW_ATTRIBUTE(sun8i_ce_debugfs);		DEFINE_SHOW_ATTRIBUTE(sun8i_ce_debugfs);
	#endif

	static void sun8i_ce_free_chanlist(struct sun8i_ce_dev *ce, int i)		static void sun8i_ce_free_chanlist(struct sun8i_ce_dev *ce, int i)
	{		{
	@@ -839,7 +878,7 @@ static int sun8i_ce_register_algs(struct sun8i_ce_dev *ce)
	if (ce_method == CE_ID_NOTSUPP) {		if (ce_method == CE_ID_NOTSUPP) {
	dev_dbg(ce->dev,		dev_dbg(ce->dev,
	"DEBUG: Algo of %s not supported\n",		"DEBUG: Algo of %s not supported\n",
	ce_algs[i].alg.skcipher.base.cra_name);		ce_algs[i].alg.skcipher.base.base.cra_name);
	ce_algs[i].ce = NULL;		ce_algs[i].ce = NULL;
	break;		break;
	}		}
	@@ -847,16 +886,16 @@ static int sun8i_ce_register_algs(struct sun8i_ce_dev *ce)
	ce_method = ce->variant->op_mode[id];		ce_method = ce->variant->op_mode[id];
	if (ce_method == CE_ID_NOTSUPP) {		if (ce_method == CE_ID_NOTSUPP) {
	dev_dbg(ce->dev, "DEBUG: Blockmode of %s not supported\n",		dev_dbg(ce->dev, "DEBUG: Blockmode of %s not supported\n",
	ce_algs[i].alg.skcipher.base.cra_name);		ce_algs[i].alg.skcipher.base.base.cra_name);
	ce_algs[i].ce = NULL;		ce_algs[i].ce = NULL;
	break;		break;
	}		}
	dev_info(ce->dev, "Register %s\n",		dev_info(ce->dev, "Register %s\n",
	ce_algs[i].alg.skcipher.base.cra_name);		ce_algs[i].alg.skcipher.base.base.cra_name);
	err = crypto_register_skcipher(&ce_algs[i].alg.skcipher);		err = crypto_engine_register_skcipher(&ce_algs[i].alg.skcipher);
	if (err) {		if (err) {
	dev_err(ce->dev, "ERROR: Fail to register %s\n",		dev_err(ce->dev, "ERROR: Fail to register %s\n",
	ce_algs[i].alg.skcipher.base.cra_name);		ce_algs[i].alg.skcipher.base.base.cra_name);
	ce_algs[i].ce = NULL;		ce_algs[i].ce = NULL;
	return err;		return err;
	}		}
	@@ -867,16 +906,16 @@ static int sun8i_ce_register_algs(struct sun8i_ce_dev *ce)
	if (ce_method == CE_ID_NOTSUPP) {		if (ce_method == CE_ID_NOTSUPP) {
	dev_info(ce->dev,		dev_info(ce->dev,
	"DEBUG: Algo of %s not supported\n",		"DEBUG: Algo of %s not supported\n",
	ce_algs[i].alg.hash.halg.base.cra_name);		ce_algs[i].alg.hash.base.halg.base.cra_name);
	ce_algs[i].ce = NULL;		ce_algs[i].ce = NULL;
	break;		break;
	}		}
	dev_info(ce->dev, "Register %s\n",		dev_info(ce->dev, "Register %s\n",
	ce_algs[i].alg.hash.halg.base.cra_name);		ce_algs[i].alg.hash.base.halg.base.cra_name);
	err = crypto_register_ahash(&ce_algs[i].alg.hash);		err = crypto_engine_register_ahash(&ce_algs[i].alg.hash);
	if (err) {		if (err) {
	dev_err(ce->dev, "ERROR: Fail to register %s\n",		dev_err(ce->dev, "ERROR: Fail to register %s\n",
	ce_algs[i].alg.hash.halg.base.cra_name);		ce_algs[i].alg.hash.base.halg.base.cra_name);
	ce_algs[i].ce = NULL;		ce_algs[i].ce = NULL;
	return err;		return err;
	}		}
	@@ -916,13 +955,13 @@ static void sun8i_ce_unregister_algs(struct sun8i_ce_dev *ce)
	switch (ce_algs[i].type) {		switch (ce_algs[i].type) {
	case CRYPTO_ALG_TYPE_SKCIPHER:		case CRYPTO_ALG_TYPE_SKCIPHER:
	dev_info(ce->dev, "Unregister %d %s\n", i,		dev_info(ce->dev, "Unregister %d %s\n", i,
	ce_algs[i].alg.skcipher.base.cra_name);		ce_algs[i].alg.skcipher.base.base.cra_name);
	crypto_unregister_skcipher(&ce_algs[i].alg.skcipher);		crypto_engine_unregister_skcipher(&ce_algs[i].alg.skcipher);
	break;		break;
	case CRYPTO_ALG_TYPE_AHASH:		case CRYPTO_ALG_TYPE_AHASH:
	dev_info(ce->dev, "Unregister %d %s\n", i,		dev_info(ce->dev, "Unregister %d %s\n", i,
	ce_algs[i].alg.hash.halg.base.cra_name);		ce_algs[i].alg.hash.base.halg.base.cra_name);
	crypto_unregister_ahash(&ce_algs[i].alg.hash);		crypto_engine_unregister_ahash(&ce_algs[i].alg.hash);
	break;		break;
	case CRYPTO_ALG_TYPE_RNG:		case CRYPTO_ALG_TYPE_RNG:
	dev_info(ce->dev, "Unregister %d %s\n", i,		dev_info(ce->dev, "Unregister %d %s\n", i,
	@@ -1007,13 +1046,21 @@ static int sun8i_ce_probe(struct platform_device *pdev)

	pm_runtime_put_sync(ce->dev);		pm_runtime_put_sync(ce->dev);

	#ifdef CONFIG_CRYPTO_DEV_SUN8I_CE_DEBUG		if (IS_ENABLED(CONFIG_CRYPTO_DEV_SUN8I_CE_DEBUG)) {
			struct dentry *dbgfs_dir __maybe_unused;
			struct dentry *dbgfs_stats __maybe_unused;

	/* Ignore error of debugfs */		/* Ignore error of debugfs */
	ce->dbgfs_dir = debugfs_create_dir("sun8i-ce", NULL);		dbgfs_dir = debugfs_create_dir("sun8i-ce", NULL);
	ce->dbgfs_stats = debugfs_create_file("stats", 0444,		dbgfs_stats = debugfs_create_file("stats", 0444,
	ce->dbgfs_dir, ce,		dbgfs_dir, ce,
	&sun8i_ce_debugfs_fops);		&sun8i_ce_debugfs_fops);

			#ifdef CONFIG_CRYPTO_DEV_SUN8I_CE_DEBUG
			ce->dbgfs_dir = dbgfs_dir;
			ce->dbgfs_stats = dbgfs_stats;
	#endif		#endif
			}

	return 0;		return 0;
	error_alg:		error_alg:

drivers/crypto/allwinner/sun8i-ce/sun8i-ce-hash.c

+52 −44

Original line number	Original line	Diff line number	Diff line
	@@ -9,46 +9,46 @@
	*		*
	* You could find the datasheet in Documentation/arch/arm/sunxi.rst		* You could find the datasheet in Documentation/arch/arm/sunxi.rst
	*/		*/

			#include <crypto/internal/hash.h>
			#include <crypto/md5.h>
			#include <crypto/sha1.h>
			#include <crypto/sha2.h>
	#include <linux/bottom_half.h>		#include <linux/bottom_half.h>
	#include <linux/dma-mapping.h>		#include <linux/dma-mapping.h>
			#include <linux/kernel.h>
	#include <linux/pm_runtime.h>		#include <linux/pm_runtime.h>
	#include <linux/scatterlist.h>		#include <linux/scatterlist.h>
	#include <crypto/internal/hash.h>		#include <linux/slab.h>
	#include <crypto/sha1.h>		#include <linux/string.h>
	#include <crypto/sha2.h>
	#include <crypto/md5.h>
	#include "sun8i-ce.h"		#include "sun8i-ce.h"

	int sun8i_ce_hash_crainit(struct crypto_tfm *tfm)		int sun8i_ce_hash_init_tfm(struct crypto_ahash *tfm)
	{		{
	struct sun8i_ce_hash_tfm_ctx *op = crypto_tfm_ctx(tfm);		struct sun8i_ce_hash_tfm_ctx *op = crypto_ahash_ctx(tfm);
	struct ahash_alg *alg = __crypto_ahash_alg(tfm->__crt_alg);		struct ahash_alg *alg = crypto_ahash_alg(tfm);
	struct sun8i_ce_alg_template *algt;		struct sun8i_ce_alg_template *algt;
	int err;		int err;

	memset(op, 0, sizeof(struct sun8i_ce_hash_tfm_ctx));		algt = container_of(alg, struct sun8i_ce_alg_template, alg.hash.base);

	algt = container_of(alg, struct sun8i_ce_alg_template, alg.hash);
	op->ce = algt->ce;		op->ce = algt->ce;

	op->enginectx.op.do_one_request = sun8i_ce_hash_run;

	/* FALLBACK */		/* FALLBACK */
	op->fallback_tfm = crypto_alloc_ahash(crypto_tfm_alg_name(tfm), 0,		op->fallback_tfm = crypto_alloc_ahash(crypto_ahash_alg_name(tfm), 0,
	CRYPTO_ALG_NEED_FALLBACK);		CRYPTO_ALG_NEED_FALLBACK);
	if (IS_ERR(op->fallback_tfm)) {		if (IS_ERR(op->fallback_tfm)) {
	dev_err(algt->ce->dev, "Fallback driver could no be loaded\n");		dev_err(algt->ce->dev, "Fallback driver could no be loaded\n");
	return PTR_ERR(op->fallback_tfm);		return PTR_ERR(op->fallback_tfm);
	}		}

	if (algt->alg.hash.halg.statesize < crypto_ahash_statesize(op->fallback_tfm))		crypto_ahash_set_statesize(tfm,
	algt->alg.hash.halg.statesize = crypto_ahash_statesize(op->fallback_tfm);		crypto_ahash_statesize(op->fallback_tfm));

	crypto_ahash_set_reqsize(__crypto_ahash_cast(tfm),		crypto_ahash_set_reqsize(tfm,
	sizeof(struct sun8i_ce_hash_reqctx) +		sizeof(struct sun8i_ce_hash_reqctx) +
	crypto_ahash_reqsize(op->fallback_tfm));		crypto_ahash_reqsize(op->fallback_tfm));

	memcpy(algt->fbname, crypto_tfm_alg_driver_name(&op->fallback_tfm->base),		memcpy(algt->fbname, crypto_ahash_driver_name(op->fallback_tfm),
	CRYPTO_MAX_ALG_NAME);		CRYPTO_MAX_ALG_NAME);

	err = pm_runtime_get_sync(op->ce->dev);		err = pm_runtime_get_sync(op->ce->dev);
	@@ -61,9 +61,9 @@ int sun8i_ce_hash_crainit(struct crypto_tfm *tfm)
	return err;		return err;
	}		}

	void sun8i_ce_hash_craexit(struct crypto_tfm *tfm)		void sun8i_ce_hash_exit_tfm(struct crypto_ahash *tfm)
	{		{
	struct sun8i_ce_hash_tfm_ctx *tfmctx = crypto_tfm_ctx(tfm);		struct sun8i_ce_hash_tfm_ctx *tfmctx = crypto_ahash_ctx(tfm);

	crypto_free_ahash(tfmctx->fallback_tfm);		crypto_free_ahash(tfmctx->fallback_tfm);
	pm_runtime_put_sync_suspend(tfmctx->ce->dev);		pm_runtime_put_sync_suspend(tfmctx->ce->dev);
	@@ -112,20 +112,22 @@ int sun8i_ce_hash_final(struct ahash_request *areq)
	struct sun8i_ce_hash_reqctx *rctx = ahash_request_ctx(areq);		struct sun8i_ce_hash_reqctx *rctx = ahash_request_ctx(areq);
	struct crypto_ahash *tfm = crypto_ahash_reqtfm(areq);		struct crypto_ahash *tfm = crypto_ahash_reqtfm(areq);
	struct sun8i_ce_hash_tfm_ctx *tfmctx = crypto_ahash_ctx(tfm);		struct sun8i_ce_hash_tfm_ctx *tfmctx = crypto_ahash_ctx(tfm);
	#ifdef CONFIG_CRYPTO_DEV_SUN8I_CE_DEBUG
	struct ahash_alg *alg = __crypto_ahash_alg(tfm->base.__crt_alg);
	struct sun8i_ce_alg_template *algt;
	#endif

	ahash_request_set_tfm(&rctx->fallback_req, tfmctx->fallback_tfm);		ahash_request_set_tfm(&rctx->fallback_req, tfmctx->fallback_tfm);
	rctx->fallback_req.base.flags = areq->base.flags &		rctx->fallback_req.base.flags = areq->base.flags &
	CRYPTO_TFM_REQ_MAY_SLEEP;		CRYPTO_TFM_REQ_MAY_SLEEP;
	rctx->fallback_req.result = areq->result;		rctx->fallback_req.result = areq->result;

			if (IS_ENABLED(CONFIG_CRYPTO_DEV_SUN8I_CE_DEBUG)) {
			struct sun8i_ce_alg_template *algt __maybe_unused;
			struct ahash_alg *alg = crypto_ahash_alg(tfm);

			algt = container_of(alg, struct sun8i_ce_alg_template,
			alg.hash.base);
	#ifdef CONFIG_CRYPTO_DEV_SUN8I_CE_DEBUG		#ifdef CONFIG_CRYPTO_DEV_SUN8I_CE_DEBUG
	algt = container_of(alg, struct sun8i_ce_alg_template, alg.hash);
	algt->stat_fb++;		algt->stat_fb++;
	#endif		#endif
			}

	return crypto_ahash_final(&rctx->fallback_req);		return crypto_ahash_final(&rctx->fallback_req);
	}		}
	@@ -150,10 +152,6 @@ int sun8i_ce_hash_finup(struct ahash_request *areq)
	struct sun8i_ce_hash_reqctx *rctx = ahash_request_ctx(areq);		struct sun8i_ce_hash_reqctx *rctx = ahash_request_ctx(areq);
	struct crypto_ahash *tfm = crypto_ahash_reqtfm(areq);		struct crypto_ahash *tfm = crypto_ahash_reqtfm(areq);
	struct sun8i_ce_hash_tfm_ctx *tfmctx = crypto_ahash_ctx(tfm);		struct sun8i_ce_hash_tfm_ctx *tfmctx = crypto_ahash_ctx(tfm);
	#ifdef CONFIG_CRYPTO_DEV_SUN8I_CE_DEBUG
	struct ahash_alg *alg = __crypto_ahash_alg(tfm->base.__crt_alg);
	struct sun8i_ce_alg_template *algt;
	#endif

	ahash_request_set_tfm(&rctx->fallback_req, tfmctx->fallback_tfm);		ahash_request_set_tfm(&rctx->fallback_req, tfmctx->fallback_tfm);
	rctx->fallback_req.base.flags = areq->base.flags &		rctx->fallback_req.base.flags = areq->base.flags &
	@@ -162,10 +160,17 @@ int sun8i_ce_hash_finup(struct ahash_request *areq)
	rctx->fallback_req.nbytes = areq->nbytes;		rctx->fallback_req.nbytes = areq->nbytes;
	rctx->fallback_req.src = areq->src;		rctx->fallback_req.src = areq->src;
	rctx->fallback_req.result = areq->result;		rctx->fallback_req.result = areq->result;

			if (IS_ENABLED(CONFIG_CRYPTO_DEV_SUN8I_CE_DEBUG)) {
			struct sun8i_ce_alg_template *algt __maybe_unused;
			struct ahash_alg *alg = crypto_ahash_alg(tfm);

			algt = container_of(alg, struct sun8i_ce_alg_template,
			alg.hash.base);
	#ifdef CONFIG_CRYPTO_DEV_SUN8I_CE_DEBUG		#ifdef CONFIG_CRYPTO_DEV_SUN8I_CE_DEBUG
	algt = container_of(alg, struct sun8i_ce_alg_template, alg.hash);
	algt->stat_fb++;		algt->stat_fb++;
	#endif		#endif
			}

	return crypto_ahash_finup(&rctx->fallback_req);		return crypto_ahash_finup(&rctx->fallback_req);
	}		}
	@@ -175,10 +180,6 @@ static int sun8i_ce_hash_digest_fb(struct ahash_request *areq)
	struct sun8i_ce_hash_reqctx *rctx = ahash_request_ctx(areq);		struct sun8i_ce_hash_reqctx *rctx = ahash_request_ctx(areq);
	struct crypto_ahash *tfm = crypto_ahash_reqtfm(areq);		struct crypto_ahash *tfm = crypto_ahash_reqtfm(areq);
	struct sun8i_ce_hash_tfm_ctx *tfmctx = crypto_ahash_ctx(tfm);		struct sun8i_ce_hash_tfm_ctx *tfmctx = crypto_ahash_ctx(tfm);
	#ifdef CONFIG_CRYPTO_DEV_SUN8I_CE_DEBUG
	struct ahash_alg *alg = __crypto_ahash_alg(tfm->base.__crt_alg);
	struct sun8i_ce_alg_template *algt;
	#endif

	ahash_request_set_tfm(&rctx->fallback_req, tfmctx->fallback_tfm);		ahash_request_set_tfm(&rctx->fallback_req, tfmctx->fallback_tfm);
	rctx->fallback_req.base.flags = areq->base.flags &		rctx->fallback_req.base.flags = areq->base.flags &
	@@ -187,10 +188,17 @@ static int sun8i_ce_hash_digest_fb(struct ahash_request *areq)
	rctx->fallback_req.nbytes = areq->nbytes;		rctx->fallback_req.nbytes = areq->nbytes;
	rctx->fallback_req.src = areq->src;		rctx->fallback_req.src = areq->src;
	rctx->fallback_req.result = areq->result;		rctx->fallback_req.result = areq->result;

			if (IS_ENABLED(CONFIG_CRYPTO_DEV_SUN8I_CE_DEBUG)) {
			struct sun8i_ce_alg_template *algt __maybe_unused;
			struct ahash_alg *alg = crypto_ahash_alg(tfm);

			algt = container_of(alg, struct sun8i_ce_alg_template,
			alg.hash.base);
	#ifdef CONFIG_CRYPTO_DEV_SUN8I_CE_DEBUG		#ifdef CONFIG_CRYPTO_DEV_SUN8I_CE_DEBUG
	algt = container_of(alg, struct sun8i_ce_alg_template, alg.hash);
	algt->stat_fb++;		algt->stat_fb++;
	#endif		#endif
			}

	return crypto_ahash_digest(&rctx->fallback_req);		return crypto_ahash_digest(&rctx->fallback_req);
	}		}
	@@ -202,7 +210,7 @@ static bool sun8i_ce_hash_need_fallback(struct ahash_request *areq)
	struct sun8i_ce_alg_template *algt;		struct sun8i_ce_alg_template *algt;
	struct scatterlist *sg;		struct scatterlist *sg;

	algt = container_of(alg, struct sun8i_ce_alg_template, alg.hash);		algt = container_of(alg, struct sun8i_ce_alg_template, alg.hash.base);

	if (areq->nbytes == 0) {		if (areq->nbytes == 0) {
	algt->stat_fb_len0++;		algt->stat_fb_len0++;
	@@ -251,7 +259,7 @@ int sun8i_ce_hash_digest(struct ahash_request *areq)
	return sun8i_ce_hash_digest_fb(areq);		return sun8i_ce_hash_digest_fb(areq);
	}		}

	algt = container_of(alg, struct sun8i_ce_alg_template, alg.hash);		algt = container_of(alg, struct sun8i_ce_alg_template, alg.hash.base);
	ce = algt->ce;		ce = algt->ce;

	e = sun8i_ce_get_engine_number(ce);		e = sun8i_ce_get_engine_number(ce);
	@@ -343,11 +351,11 @@ int sun8i_ce_hash_run(struct crypto_engine engine, void breq)
	dma_addr_t addr_res, addr_pad;		dma_addr_t addr_res, addr_pad;
	int ns = sg_nents_for_len(areq->src, areq->nbytes);		int ns = sg_nents_for_len(areq->src, areq->nbytes);

	algt = container_of(alg, struct sun8i_ce_alg_template, alg.hash);		algt = container_of(alg, struct sun8i_ce_alg_template, alg.hash.base);
	ce = algt->ce;		ce = algt->ce;

	bs = algt->alg.hash.halg.base.cra_blocksize;		bs = algt->alg.hash.base.halg.base.cra_blocksize;
	digestsize = algt->alg.hash.halg.digestsize;		digestsize = algt->alg.hash.base.halg.digestsize;
	if (digestsize == SHA224_DIGEST_SIZE)		if (digestsize == SHA224_DIGEST_SIZE)
	digestsize = SHA256_DIGEST_SIZE;		digestsize = SHA256_DIGEST_SIZE;
	if (digestsize == SHA384_DIGEST_SIZE)		if (digestsize == SHA384_DIGEST_SIZE)
	@@ -452,14 +460,14 @@ int sun8i_ce_hash_run(struct crypto_engine engine, void breq)

	chan->timeout = areq->nbytes;		chan->timeout = areq->nbytes;

	err = sun8i_ce_run_task(ce, flow, crypto_tfm_alg_name(areq->base.tfm));		err = sun8i_ce_run_task(ce, flow, crypto_ahash_alg_name(tfm));

	dma_unmap_single(ce->dev, addr_pad, j * 4, DMA_TO_DEVICE);		dma_unmap_single(ce->dev, addr_pad, j * 4, DMA_TO_DEVICE);
	dma_unmap_sg(ce->dev, areq->src, ns, DMA_TO_DEVICE);		dma_unmap_sg(ce->dev, areq->src, ns, DMA_TO_DEVICE);
	dma_unmap_single(ce->dev, addr_res, digestsize, DMA_FROM_DEVICE);		dma_unmap_single(ce->dev, addr_res, digestsize, DMA_FROM_DEVICE);


	memcpy(areq->result, result, algt->alg.hash.halg.digestsize);		memcpy(areq->result, result, algt->alg.hash.base.halg.digestsize);
	theend:		theend:
	kfree(buf);		kfree(buf);
	kfree(result);		kfree(result);

drivers/crypto/allwinner/sun8i-ce/sun8i-ce.h

+5 −8

Original line number	Original line	Diff line number	Diff line
	@@ -265,14 +265,12 @@ struct sun8i_cipher_req_ctx {

	/*		/*
	* struct sun8i_cipher_tfm_ctx - context for a skcipher TFM		* struct sun8i_cipher_tfm_ctx - context for a skcipher TFM
	* @enginectx: crypto_engine used by this TFM
	* @key: pointer to key data		* @key: pointer to key data
	* @keylen: len of the key		* @keylen: len of the key
	* @ce: pointer to the private data of driver handling this TFM		* @ce: pointer to the private data of driver handling this TFM
	* @fallback_tfm: pointer to the fallback TFM		* @fallback_tfm: pointer to the fallback TFM
	*/		*/
	struct sun8i_cipher_tfm_ctx {		struct sun8i_cipher_tfm_ctx {
	struct crypto_engine_ctx enginectx;
	u32 *key;		u32 *key;
	u32 keylen;		u32 keylen;
	struct sun8i_ce_dev *ce;		struct sun8i_ce_dev *ce;
	@@ -281,12 +279,10 @@ struct sun8i_cipher_tfm_ctx {

	/*		/*
	* struct sun8i_ce_hash_tfm_ctx - context for an ahash TFM		* struct sun8i_ce_hash_tfm_ctx - context for an ahash TFM
	* @enginectx: crypto_engine used by this TFM
	* @ce: pointer to the private data of driver handling this TFM		* @ce: pointer to the private data of driver handling this TFM
	* @fallback_tfm: pointer to the fallback TFM		* @fallback_tfm: pointer to the fallback TFM
	*/		*/
	struct sun8i_ce_hash_tfm_ctx {		struct sun8i_ce_hash_tfm_ctx {
	struct crypto_engine_ctx enginectx;
	struct sun8i_ce_dev *ce;		struct sun8i_ce_dev *ce;
	struct crypto_ahash *fallback_tfm;		struct crypto_ahash *fallback_tfm;
	};		};
	@@ -329,8 +325,8 @@ struct sun8i_ce_alg_template {
	u32 ce_blockmode;		u32 ce_blockmode;
	struct sun8i_ce_dev *ce;		struct sun8i_ce_dev *ce;
	union {		union {
	struct skcipher_alg skcipher;		struct skcipher_engine_alg skcipher;
	struct ahash_alg hash;		struct ahash_engine_alg hash;
	struct rng_alg rng;		struct rng_alg rng;
	} alg;		} alg;
	unsigned long stat_req;		unsigned long stat_req;
	@@ -353,6 +349,7 @@ int sun8i_ce_des3_setkey(struct crypto_skcipher tfm, const u8 key,
	unsigned int keylen);		unsigned int keylen);
	int sun8i_ce_cipher_init(struct crypto_tfm *tfm);		int sun8i_ce_cipher_init(struct crypto_tfm *tfm);
	void sun8i_ce_cipher_exit(struct crypto_tfm *tfm);		void sun8i_ce_cipher_exit(struct crypto_tfm *tfm);
			int sun8i_ce_cipher_do_one(struct crypto_engine engine, void areq);
	int sun8i_ce_skdecrypt(struct skcipher_request *areq);		int sun8i_ce_skdecrypt(struct skcipher_request *areq);
	int sun8i_ce_skencrypt(struct skcipher_request *areq);		int sun8i_ce_skencrypt(struct skcipher_request *areq);

	@@ -360,8 +357,8 @@ int sun8i_ce_get_engine_number(struct sun8i_ce_dev *ce);

	int sun8i_ce_run_task(struct sun8i_ce_dev ce, int flow, const char name);		int sun8i_ce_run_task(struct sun8i_ce_dev ce, int flow, const char name);

	int sun8i_ce_hash_crainit(struct crypto_tfm *tfm);		int sun8i_ce_hash_init_tfm(struct crypto_ahash *tfm);
	void sun8i_ce_hash_craexit(struct crypto_tfm *tfm);		void sun8i_ce_hash_exit_tfm(struct crypto_ahash *tfm);
	int sun8i_ce_hash_init(struct ahash_request *areq);		int sun8i_ce_hash_init(struct ahash_request *areq);
	int sun8i_ce_hash_export(struct ahash_request areq, void out);		int sun8i_ce_hash_export(struct ahash_request areq, void out);
	int sun8i_ce_hash_import(struct ahash_request areq, const void in);		int sun8i_ce_hash_import(struct ahash_request areq, const void in);