crypto: nx - convert AES-ECB to skcipher API (bfd9efdd) · Commits · 戴 / test

drivers/crypto/nx/nx-aes-ecb.c

+32 −44

Original line number	Diff line number	Diff line
		@@ -18,11 +18,11 @@
		#include "nx.h"


		static int ecb_aes_nx_set_key(struct crypto_tfm *tfm,
		static int ecb_aes_nx_set_key(struct crypto_skcipher *tfm,
		const u8 *in_key,
		unsigned int key_len)
		{
		struct nx_crypto_ctx *nx_ctx = crypto_tfm_ctx(tfm);
		struct nx_crypto_ctx *nx_ctx = crypto_skcipher_ctx(tfm);
		struct nx_csbcpb csbcpb = (struct nx_csbcpb )nx_ctx->csbcpb;

		nx_ctx_init(nx_ctx, HCOP_FC_AES);
		@@ -50,13 +50,11 @@ static int ecb_aes_nx_set_key(struct crypto_tfm *tfm,
		return 0;
		}

		static int ecb_aes_nx_crypt(struct blkcipher_desc *desc,
		struct scatterlist *dst,
		struct scatterlist *src,
		unsigned int nbytes,
		static int ecb_aes_nx_crypt(struct skcipher_request *req,
		int enc)
		{
		struct nx_crypto_ctx *nx_ctx = crypto_blkcipher_ctx(desc->tfm);
		struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
		struct nx_crypto_ctx *nx_ctx = crypto_skcipher_ctx(tfm);
		struct nx_csbcpb *csbcpb = nx_ctx->csbcpb;
		unsigned long irq_flags;
		unsigned int processed = 0, to_process;
		@@ -70,10 +68,10 @@ static int ecb_aes_nx_crypt(struct blkcipher_desc *desc,
		NX_CPB_FDM(csbcpb) &= ~NX_FDM_ENDE_ENCRYPT;

		do {
		to_process = nbytes - processed;
		to_process = req->cryptlen - processed;

		rc = nx_build_sg_lists(nx_ctx, NULL, dst, src, &to_process,
		processed, NULL);
		rc = nx_build_sg_lists(nx_ctx, NULL, req->dst, req->src,
		&to_process, processed, NULL);
		if (rc)
		goto out;

		@@ -83,7 +81,7 @@ static int ecb_aes_nx_crypt(struct blkcipher_desc *desc,
		}

		rc = nx_hcall_sync(nx_ctx, &nx_ctx->op,
		desc->flags & CRYPTO_TFM_REQ_MAY_SLEEP);
		req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP);
		if (rc)
		goto out;

		@@ -92,46 +90,36 @@ static int ecb_aes_nx_crypt(struct blkcipher_desc *desc,
		&(nx_ctx->stats->aes_bytes));

		processed += to_process;
		} while (processed < nbytes);
		} while (processed < req->cryptlen);

		out:
		spin_unlock_irqrestore(&nx_ctx->lock, irq_flags);
		return rc;
		}

		static int ecb_aes_nx_encrypt(struct blkcipher_desc *desc,
		struct scatterlist *dst,
		struct scatterlist *src,
		unsigned int nbytes)
		static int ecb_aes_nx_encrypt(struct skcipher_request *req)
		{
		return ecb_aes_nx_crypt(desc, dst, src, nbytes, 1);
		return ecb_aes_nx_crypt(req, 1);
		}

		static int ecb_aes_nx_decrypt(struct blkcipher_desc *desc,
		struct scatterlist *dst,
		struct scatterlist *src,
		unsigned int nbytes)
		static int ecb_aes_nx_decrypt(struct skcipher_request *req)
		{
		return ecb_aes_nx_crypt(desc, dst, src, nbytes, 0);
		return ecb_aes_nx_crypt(req, 0);
		}

		struct crypto_alg nx_ecb_aes_alg = {
		.cra_name = "ecb(aes)",
		.cra_driver_name = "ecb-aes-nx",
		.cra_priority = 300,
		.cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER,
		.cra_blocksize = AES_BLOCK_SIZE,
		.cra_alignmask = 0xf,
		.cra_ctxsize = sizeof(struct nx_crypto_ctx),
		.cra_type = &crypto_blkcipher_type,
		.cra_module = THIS_MODULE,
		.cra_init = nx_crypto_ctx_aes_ecb_init,
		.cra_exit = nx_crypto_ctx_exit,
		.cra_blkcipher = {
		struct skcipher_alg nx_ecb_aes_alg = {
		.base.cra_name = "ecb(aes)",
		.base.cra_driver_name = "ecb-aes-nx",
		.base.cra_priority = 300,
		.base.cra_blocksize = AES_BLOCK_SIZE,
		.base.cra_alignmask = 0xf,
		.base.cra_ctxsize = sizeof(struct nx_crypto_ctx),
		.base.cra_module = THIS_MODULE,
		.init = nx_crypto_ctx_aes_ecb_init,
		.exit = nx_crypto_ctx_skcipher_exit,
		.min_keysize = AES_MIN_KEY_SIZE,
		.max_keysize = AES_MAX_KEY_SIZE,
		.setkey = ecb_aes_nx_set_key,
		.encrypt = ecb_aes_nx_encrypt,
		.decrypt = ecb_aes_nx_decrypt,
		}
		};

drivers/crypto/nx/nx.c

+23 −5

Original line number	Diff line number	Diff line
		@@ -517,6 +517,12 @@ static int nx_register_alg(struct crypto_alg *alg, u32 fc, u32 mode)
		crypto_register_alg(alg) : 0;
		}

		static int nx_register_skcipher(struct skcipher_alg *alg, u32 fc, u32 mode)
		{
		return nx_check_props(&nx_driver.viodev->dev, fc, mode) ?
		crypto_register_skcipher(alg) : 0;
		}

		static int nx_register_aead(struct aead_alg *alg, u32 fc, u32 mode)
		{
		return nx_check_props(&nx_driver.viodev->dev, fc, mode) ?
		@@ -537,6 +543,12 @@ static void nx_unregister_alg(struct crypto_alg *alg, u32 fc, u32 mode)
		crypto_unregister_alg(alg);
		}

		static void nx_unregister_skcipher(struct skcipher_alg *alg, u32 fc, u32 mode)
		{
		if (nx_check_props(NULL, fc, mode))
		crypto_unregister_skcipher(alg);
		}

		static void nx_unregister_aead(struct aead_alg *alg, u32 fc, u32 mode)
		{
		if (nx_check_props(NULL, fc, mode))
		@@ -573,7 +585,7 @@ static int nx_register_algs(void)

		nx_driver.of.status = NX_OKAY;

		rc = nx_register_alg(&nx_ecb_aes_alg, NX_FC_AES, NX_MODE_AES_ECB);
		rc = nx_register_skcipher(&nx_ecb_aes_alg, NX_FC_AES, NX_MODE_AES_ECB);
		if (rc)
		goto out;

		@@ -637,7 +649,7 @@ out_unreg_ctr3686:
		out_unreg_cbc:
		nx_unregister_alg(&nx_cbc_aes_alg, NX_FC_AES, NX_MODE_AES_CBC);
		out_unreg_ecb:
		nx_unregister_alg(&nx_ecb_aes_alg, NX_FC_AES, NX_MODE_AES_ECB);
		nx_unregister_skcipher(&nx_ecb_aes_alg, NX_FC_AES, NX_MODE_AES_ECB);
		out:
		return rc;
		}
		@@ -716,9 +728,9 @@ int nx_crypto_ctx_aes_cbc_init(struct crypto_tfm *tfm)
		NX_MODE_AES_CBC);
		}

		int nx_crypto_ctx_aes_ecb_init(struct crypto_tfm *tfm)
		int nx_crypto_ctx_aes_ecb_init(struct crypto_skcipher *tfm)
		{
		return nx_crypto_ctx_init(crypto_tfm_ctx(tfm), NX_FC_AES,
		return nx_crypto_ctx_init(crypto_skcipher_ctx(tfm), NX_FC_AES,
		NX_MODE_AES_ECB);
		}

		@@ -752,6 +764,11 @@ void nx_crypto_ctx_exit(struct crypto_tfm *tfm)
		nx_ctx->out_sg = NULL;
		}

		void nx_crypto_ctx_skcipher_exit(struct crypto_skcipher *tfm)
		{
		nx_crypto_ctx_exit(crypto_skcipher_ctx(tfm));
		}

		void nx_crypto_ctx_aead_exit(struct crypto_aead *tfm)
		{
		struct nx_crypto_ctx *nx_ctx = crypto_aead_ctx(tfm);
		@@ -801,7 +818,8 @@ static int nx_remove(struct vio_dev *viodev)
		nx_unregister_alg(&nx_ctr3686_aes_alg,
		NX_FC_AES, NX_MODE_AES_CTR);
		nx_unregister_alg(&nx_cbc_aes_alg, NX_FC_AES, NX_MODE_AES_CBC);
		nx_unregister_alg(&nx_ecb_aes_alg, NX_FC_AES, NX_MODE_AES_ECB);
		nx_unregister_skcipher(&nx_ecb_aes_alg, NX_FC_AES,
		NX_MODE_AES_ECB);
		}

		return 0;

drivers/crypto/nx/nx.h

+3 −2

Original line number	Diff line number	Diff line
		@@ -147,9 +147,10 @@ int nx_crypto_ctx_aes_gcm_init(struct crypto_aead *tfm);
		int nx_crypto_ctx_aes_xcbc_init(struct crypto_tfm *tfm);
		int nx_crypto_ctx_aes_ctr_init(struct crypto_tfm *tfm);
		int nx_crypto_ctx_aes_cbc_init(struct crypto_tfm *tfm);
		int nx_crypto_ctx_aes_ecb_init(struct crypto_tfm *tfm);
		int nx_crypto_ctx_aes_ecb_init(struct crypto_skcipher *tfm);
		int nx_crypto_ctx_sha_init(struct crypto_tfm *tfm);
		void nx_crypto_ctx_exit(struct crypto_tfm *tfm);
		void nx_crypto_ctx_skcipher_exit(struct crypto_skcipher *tfm);
		void nx_crypto_ctx_aead_exit(struct crypto_aead *tfm);
		void nx_ctx_init(struct nx_crypto_ctx *nx_ctx, unsigned int function);
		int nx_hcall_sync(struct nx_crypto_ctx ctx, struct vio_pfo_op op,
		@@ -176,7 +177,7 @@ void nx_debugfs_fini(struct nx_crypto_driver *);
		#define NX_PAGE_NUM(x) ((u64)(x) & 0xfffffffffffff000ULL)

		extern struct crypto_alg nx_cbc_aes_alg;
		extern struct crypto_alg nx_ecb_aes_alg;
		extern struct skcipher_alg nx_ecb_aes_alg;
		extern struct aead_alg nx_gcm_aes_alg;
		extern struct aead_alg nx_gcm4106_aes_alg;
		extern struct crypto_alg nx_ctr3686_aes_alg;

Admin message