Commit c9613335 authored by Nagadheeraj Rottela's avatar Nagadheeraj Rottela Committed by Herbert Xu
Browse files

crypto: cavium/nitrox - Added AEAD cipher support 



Added support to offload AEAD ciphers to NITROX. Currently supported
AEAD cipher is 'gcm(aes)'.

Signed-off-by: default avatarNagadheeraj Rottela <rnagadheeraj@marvell.com>
Reviewed-by: default avatarSrikanth Jampala <jsrikanth@marvell.com>
Signed-off-by: default avatarHerbert Xu <herbert@gondor.apana.org.au>
parent 2326828e

drivers/crypto/cavium/nitrox/Makefile

+3 −1
Original line number Diff line number Diff line
@@ -7,7 +7,9 @@ n5pf-objs := nitrox_main.o \ 
	nitrox_hal.o \

	nitrox_reqmgr.o \

	nitrox_algs.o	\

	nitrox_mbx.o

	nitrox_mbx.o	\

	nitrox_skcipher.o \

	nitrox_aead.o



n5pf-$(CONFIG_PCI_IOV) += nitrox_sriov.o

n5pf-$(CONFIG_DEBUG_FS) += nitrox_debugfs.o

drivers/crypto/cavium/nitrox/nitrox_aead.c

0 → 100644
+364 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

#include <linux/kernel.h>

#include <linux/printk.h>

#include <linux/crypto.h>

#include <linux/rtnetlink.h>



#include <crypto/aead.h>

#include <crypto/authenc.h>

#include <crypto/des.h>

#include <crypto/sha.h>

#include <crypto/internal/aead.h>

#include <crypto/scatterwalk.h>

#include <crypto/gcm.h>



#include "nitrox_dev.h"

#include "nitrox_common.h"

#include "nitrox_req.h"



#define GCM_AES_SALT_SIZE	4



/**

 * struct nitrox_crypt_params - Params to set nitrox crypto request.

 * @cryptlen: Encryption/Decryption data length

 * @authlen: Assoc data length + Cryptlen

 * @srclen: Input buffer length

 * @dstlen: Output buffer length

 * @iv: IV data

 * @ivsize: IV data length

 * @ctrl_arg: Identifies the request type (ENCRYPT/DECRYPT)

 */

struct nitrox_crypt_params {

	unsigned int cryptlen;

	unsigned int authlen;

	unsigned int srclen;

	unsigned int dstlen;

	u8 *iv;

	int ivsize;

	u8 ctrl_arg;

};



union gph_p3 {

	struct {

#ifdef __BIG_ENDIAN_BITFIELD

		u16 iv_offset : 8;

		u16 auth_offset	: 8;

#else

		u16 auth_offset	: 8;

		u16 iv_offset : 8;

#endif

	};

	u16 param;

};



static int nitrox_aes_gcm_setkey(struct crypto_aead *aead, const u8 *key,

				 unsigned int keylen)

{

	int aes_keylen;

	struct nitrox_crypto_ctx *nctx = crypto_aead_ctx(aead);

	struct flexi_crypto_context *fctx;

	union fc_ctx_flags flags;



	aes_keylen = flexi_aes_keylen(keylen);

	if (aes_keylen < 0) {

		crypto_aead_set_flags(aead, CRYPTO_TFM_RES_BAD_KEY_LEN);

		return -EINVAL;

	}



	/* fill crypto context */

	fctx = nctx->u.fctx;

	flags.f = be64_to_cpu(fctx->flags.f);

	flags.w0.aes_keylen = aes_keylen;

	fctx->flags.f = cpu_to_be64(flags.f);



	/* copy enc key to context */

	memset(&fctx->crypto, 0, sizeof(fctx->crypto));

	memcpy(fctx->crypto.u.key, key, keylen);



	return 0;

}



static int nitrox_aead_setauthsize(struct crypto_aead *aead,

				   unsigned int authsize)

{

	struct nitrox_crypto_ctx *nctx = crypto_aead_ctx(aead);

	struct flexi_crypto_context *fctx = nctx->u.fctx;

	union fc_ctx_flags flags;



	flags.f = be64_to_cpu(fctx->flags.f);

	flags.w0.mac_len = authsize;

	fctx->flags.f = cpu_to_be64(flags.f);



	aead->authsize = authsize;



	return 0;

}



static int alloc_src_sglist(struct aead_request *areq, char *iv, int ivsize,

			    int buflen)

{

	struct nitrox_kcrypt_request *nkreq = aead_request_ctx(areq);

	int nents = sg_nents_for_len(areq->src, buflen) + 1;

	int ret;



	if (nents < 0)

		return nents;



	/* Allocate buffer to hold IV and input scatterlist array */

	ret = alloc_src_req_buf(nkreq, nents, ivsize);

	if (ret)

		return ret;



	nitrox_creq_copy_iv(nkreq->src, iv, ivsize);

	nitrox_creq_set_src_sg(nkreq, nents, ivsize, areq->src, buflen);



	return 0;

}



static int alloc_dst_sglist(struct aead_request *areq, int ivsize, int buflen)

{

	struct nitrox_kcrypt_request *nkreq = aead_request_ctx(areq);

	int nents = sg_nents_for_len(areq->dst, buflen) + 3;

	int ret;



	if (nents < 0)

		return nents;



	/* Allocate buffer to hold ORH, COMPLETION and output scatterlist

	 * array

	 */

	ret = alloc_dst_req_buf(nkreq, nents);

	if (ret)

		return ret;



	nitrox_creq_set_orh(nkreq);

	nitrox_creq_set_comp(nkreq);

	nitrox_creq_set_dst_sg(nkreq, nents, ivsize, areq->dst, buflen);



	return 0;

}



static void free_src_sglist(struct aead_request *areq)

{

	struct nitrox_kcrypt_request *nkreq = aead_request_ctx(areq);



	kfree(nkreq->src);

}



static void free_dst_sglist(struct aead_request *areq)

{

	struct nitrox_kcrypt_request *nkreq = aead_request_ctx(areq);



	kfree(nkreq->dst);

}



static int nitrox_set_creq(struct aead_request *areq,

			   struct nitrox_crypt_params *params)

{

	struct nitrox_kcrypt_request *nkreq = aead_request_ctx(areq);

	struct se_crypto_request *creq = &nkreq->creq;

	struct crypto_aead *aead = crypto_aead_reqtfm(areq);

	union gph_p3 param3;

	struct nitrox_crypto_ctx *nctx = crypto_aead_ctx(aead);

	int ret;



	creq->flags = areq->base.flags;

	creq->gfp = (areq->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP) ?

		GFP_KERNEL : GFP_ATOMIC;



	creq->ctrl.value = 0;

	creq->opcode = FLEXI_CRYPTO_ENCRYPT_HMAC;

	creq->ctrl.s.arg = params->ctrl_arg;



	creq->gph.param0 = cpu_to_be16(params->cryptlen);

	creq->gph.param1 = cpu_to_be16(params->authlen);

	creq->gph.param2 = cpu_to_be16(params->ivsize + areq->assoclen);

	param3.iv_offset = 0;

	param3.auth_offset = params->ivsize;

	creq->gph.param3 = cpu_to_be16(param3.param);



	creq->ctx_handle = nctx->u.ctx_handle;

	creq->ctrl.s.ctxl = sizeof(struct flexi_crypto_context);



	ret = alloc_src_sglist(areq, params->iv, params->ivsize,

			       params->srclen);

	if (ret)

		return ret;



	ret = alloc_dst_sglist(areq, params->ivsize, params->dstlen);

	if (ret) {

		free_src_sglist(areq);

		return ret;

	}



	return 0;

}



static void nitrox_aead_callback(void *arg, int err)

{

	struct aead_request *areq = arg;



	free_src_sglist(areq);

	free_dst_sglist(areq);

	if (err) {

		pr_err_ratelimited("request failed status 0x%0x\n", err);

		err = -EINVAL;

	}



	areq->base.complete(&areq->base, err);

}



static int nitrox_aes_gcm_enc(struct aead_request *areq)

{

	struct crypto_aead *aead = crypto_aead_reqtfm(areq);

	struct nitrox_crypto_ctx *nctx = crypto_aead_ctx(aead);

	struct nitrox_kcrypt_request *nkreq = aead_request_ctx(areq);

	struct se_crypto_request *creq = &nkreq->creq;

	struct flexi_crypto_context *fctx = nctx->u.fctx;

	struct nitrox_crypt_params params;

	int ret;



	memcpy(fctx->crypto.iv, areq->iv, GCM_AES_SALT_SIZE);



	memset(&params, 0, sizeof(params));

	params.cryptlen = areq->cryptlen;

	params.authlen = areq->assoclen + params.cryptlen;

	params.srclen = params.authlen;

	params.dstlen = params.srclen + aead->authsize;

	params.iv = &areq->iv[GCM_AES_SALT_SIZE];

	params.ivsize = GCM_AES_IV_SIZE - GCM_AES_SALT_SIZE;

	params.ctrl_arg = ENCRYPT;

	ret = nitrox_set_creq(areq, &params);

	if (ret)

		return ret;



	/* send the crypto request */

	return nitrox_process_se_request(nctx->ndev, creq, nitrox_aead_callback,

					 areq);

}



static int nitrox_aes_gcm_dec(struct aead_request *areq)

{

	struct crypto_aead *aead = crypto_aead_reqtfm(areq);

	struct nitrox_crypto_ctx *nctx = crypto_aead_ctx(aead);

	struct nitrox_kcrypt_request *nkreq = aead_request_ctx(areq);

	struct se_crypto_request *creq = &nkreq->creq;

	struct flexi_crypto_context *fctx = nctx->u.fctx;

	struct nitrox_crypt_params params;

	int ret;



	memcpy(fctx->crypto.iv, areq->iv, GCM_AES_SALT_SIZE);



	memset(&params, 0, sizeof(params));

	params.cryptlen = areq->cryptlen - aead->authsize;

	params.authlen = areq->assoclen + params.cryptlen;

	params.srclen = areq->cryptlen + areq->assoclen;

	params.dstlen = params.srclen - aead->authsize;

	params.iv = &areq->iv[GCM_AES_SALT_SIZE];

	params.ivsize = GCM_AES_IV_SIZE - GCM_AES_SALT_SIZE;

	params.ctrl_arg = DECRYPT;

	ret = nitrox_set_creq(areq, &params);

	if (ret)

		return ret;



	/* send the crypto request */

	return nitrox_process_se_request(nctx->ndev, creq, nitrox_aead_callback,

					 areq);

}



static int nitrox_aead_init(struct crypto_aead *aead)

{

	struct nitrox_crypto_ctx *nctx = crypto_aead_ctx(aead);

	struct crypto_ctx_hdr *chdr;



	/* get the first device */

	nctx->ndev = nitrox_get_first_device();

	if (!nctx->ndev)

		return -ENODEV;



	/* allocate nitrox crypto context */

	chdr = crypto_alloc_context(nctx->ndev);

	if (!chdr) {

		nitrox_put_device(nctx->ndev);

		return -ENOMEM;

	}

	nctx->chdr = chdr;

	nctx->u.ctx_handle = (uintptr_t)((u8 *)chdr->vaddr +

					 sizeof(struct ctx_hdr));

	nctx->u.fctx->flags.f = 0;



	return 0;

}



static int nitrox_aes_gcm_init(struct crypto_aead *aead)

{

	int ret;

	struct nitrox_crypto_ctx *nctx = crypto_aead_ctx(aead);

	union fc_ctx_flags *flags;



	ret = nitrox_aead_init(aead);

	if (ret)

		return ret;



	flags = &nctx->u.fctx->flags;

	flags->w0.cipher_type = CIPHER_AES_GCM;

	flags->w0.hash_type = AUTH_NULL;

	flags->w0.iv_source = IV_FROM_DPTR;

	/* ask microcode to calculate ipad/opad */

	flags->w0.auth_input_type = 1;

	flags->f = be64_to_cpu(flags->f);



	crypto_aead_set_reqsize(aead, sizeof(struct aead_request) +

				sizeof(struct nitrox_kcrypt_request));



	return 0;

}



static void nitrox_aead_exit(struct crypto_aead *aead)

{

	struct nitrox_crypto_ctx *nctx = crypto_aead_ctx(aead);



	/* free the nitrox crypto context */

	if (nctx->u.ctx_handle) {

		struct flexi_crypto_context *fctx = nctx->u.fctx;



		memzero_explicit(&fctx->crypto, sizeof(struct crypto_keys));

		memzero_explicit(&fctx->auth, sizeof(struct auth_keys));

		crypto_free_context((void *)nctx->chdr);

	}

	nitrox_put_device(nctx->ndev);



	nctx->u.ctx_handle = 0;

	nctx->ndev = NULL;

}



static struct aead_alg nitrox_aeads[] = { {

	.base = {

		.cra_name = "gcm(aes)",

		.cra_driver_name = "n5_aes_gcm",

		.cra_priority = PRIO,

		.cra_flags = CRYPTO_ALG_ASYNC,

		.cra_blocksize = AES_BLOCK_SIZE,

		.cra_ctxsize = sizeof(struct nitrox_crypto_ctx),

		.cra_alignmask = 0,

		.cra_module = THIS_MODULE,

	},

	.setkey = nitrox_aes_gcm_setkey,

	.setauthsize = nitrox_aead_setauthsize,

	.encrypt = nitrox_aes_gcm_enc,

	.decrypt = nitrox_aes_gcm_dec,

	.init = nitrox_aes_gcm_init,

	.exit = nitrox_aead_exit,

	.ivsize = GCM_AES_IV_SIZE,

	.maxauthsize = AES_BLOCK_SIZE,

} };



int nitrox_register_aeads(void)

{

	return crypto_register_aeads(nitrox_aeads, ARRAY_SIZE(nitrox_aeads));

}



void nitrox_unregister_aeads(void)

{

	crypto_unregister_aeads(nitrox_aeads, ARRAY_SIZE(nitrox_aeads));

}

drivers/crypto/cavium/nitrox/nitrox_algs.c

+11 −548
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

#include <linux/crypto.h>

#include <linux/kernel.h>

#include <linux/module.h>

#include <linux/printk.h>



#include <crypto/aes.h>

#include <crypto/skcipher.h>

#include <crypto/ctr.h>

#include <crypto/des.h>

#include <crypto/xts.h>



#include "nitrox_dev.h"

#include "nitrox_common.h"

#include "nitrox_req.h"



#define PRIO 4001



struct nitrox_cipher {

	const char *name;

	enum flexi_cipher value;

};



/**

 * supported cipher list

 */

static const struct nitrox_cipher flexi_cipher_table[] = {

	{ "null",		CIPHER_NULL },

	{ "cbc(des3_ede)",	CIPHER_3DES_CBC },

	{ "ecb(des3_ede)",	CIPHER_3DES_ECB },

	{ "cbc(aes)",		CIPHER_AES_CBC },

	{ "ecb(aes)",		CIPHER_AES_ECB },

	{ "cfb(aes)",		CIPHER_AES_CFB },

	{ "rfc3686(ctr(aes))",	CIPHER_AES_CTR },

	{ "xts(aes)",		CIPHER_AES_XTS },

	{ "cts(cbc(aes))",	CIPHER_AES_CBC_CTS },

	{ NULL,			CIPHER_INVALID }

};



static enum flexi_cipher flexi_cipher_type(const char *name)

{

	const struct nitrox_cipher *cipher = flexi_cipher_table;



	while (cipher->name) {

		if (!strcmp(cipher->name, name))

			break;

		cipher++;

	}

	return cipher->value;

}



static int flexi_aes_keylen(int keylen)

{

	int aes_keylen;



	switch (keylen) {

	case AES_KEYSIZE_128:

		aes_keylen = 1;

		break;

	case AES_KEYSIZE_192:

		aes_keylen = 2;

		break;

	case AES_KEYSIZE_256:

		aes_keylen = 3;

		break;

	default:

		aes_keylen = -EINVAL;

		break;

	}

	return aes_keylen;

}



static int nitrox_skcipher_init(struct crypto_skcipher *tfm)

{

	struct nitrox_crypto_ctx *nctx = crypto_skcipher_ctx(tfm);

	struct crypto_ctx_hdr *chdr;



	/* get the first device */

	nctx->ndev = nitrox_get_first_device();

	if (!nctx->ndev)

		return -ENODEV;



	/* allocate nitrox crypto context */

	chdr = crypto_alloc_context(nctx->ndev);

	if (!chdr) {

		nitrox_put_device(nctx->ndev);

		return -ENOMEM;

	}

	nctx->chdr = chdr;

	nctx->u.ctx_handle = (uintptr_t)((u8 *)chdr->vaddr +

					 sizeof(struct ctx_hdr));

	crypto_skcipher_set_reqsize(tfm, crypto_skcipher_reqsize(tfm) +

				    sizeof(struct nitrox_kcrypt_request));

	return 0;

}



static void nitrox_skcipher_exit(struct crypto_skcipher *tfm)

{

	struct nitrox_crypto_ctx *nctx = crypto_skcipher_ctx(tfm);



	/* free the nitrox crypto context */

	if (nctx->u.ctx_handle) {

		struct flexi_crypto_context *fctx = nctx->u.fctx;



		memset(&fctx->crypto, 0, sizeof(struct crypto_keys));

		memset(&fctx->auth, 0, sizeof(struct auth_keys));

		crypto_free_context((void *)nctx->chdr);

	}

	nitrox_put_device(nctx->ndev);



	nctx->u.ctx_handle = 0;

	nctx->ndev = NULL;

}



static inline int nitrox_skcipher_setkey(struct crypto_skcipher *cipher,

					 int aes_keylen, const u8 *key,

					 unsigned int keylen)

{

	struct crypto_tfm *tfm = crypto_skcipher_tfm(cipher);

	struct nitrox_crypto_ctx *nctx = crypto_tfm_ctx(tfm);

	struct flexi_crypto_context *fctx;

	enum flexi_cipher cipher_type;

	const char *name;



	name = crypto_tfm_alg_name(tfm);

	cipher_type = flexi_cipher_type(name);

	if (unlikely(cipher_type == CIPHER_INVALID)) {

		pr_err("unsupported cipher: %s\n", name);

		return -EINVAL;

	}



	/* fill crypto context */

	fctx = nctx->u.fctx;

	fctx->flags = 0;

	fctx->w0.cipher_type = cipher_type;

	fctx->w0.aes_keylen = aes_keylen;

	fctx->w0.iv_source = IV_FROM_DPTR;

	fctx->flags = cpu_to_be64(*(u64 *)&fctx->w0);

	/* copy the key to context */

	memcpy(fctx->crypto.u.key, key, keylen);



	return 0;

}



static int nitrox_aes_setkey(struct crypto_skcipher *cipher, const u8 *key,

			     unsigned int keylen)

{

	int aes_keylen;



	aes_keylen = flexi_aes_keylen(keylen);

	if (aes_keylen < 0) {

		crypto_skcipher_set_flags(cipher, CRYPTO_TFM_RES_BAD_KEY_LEN);

		return -EINVAL;

	}

	return nitrox_skcipher_setkey(cipher, aes_keylen, key, keylen);

}



static int alloc_src_sglist(struct skcipher_request *skreq, int ivsize)

{

	struct nitrox_kcrypt_request *nkreq = skcipher_request_ctx(skreq);

	int nents = sg_nents(skreq->src) + 1;

	struct se_crypto_request *creq = &nkreq->creq;

	char *iv;

	struct scatterlist *sg;



	/* Allocate buffer to hold IV and input scatterlist array */

	nkreq->src = alloc_req_buf(nents, ivsize, creq->gfp);

	if (!nkreq->src)

		return -ENOMEM;



	/* copy iv */

	iv = nkreq->src;

	memcpy(iv, skreq->iv, ivsize);



	sg = (struct scatterlist *)(iv + ivsize);

	creq->src = sg;

	sg_init_table(sg, nents);



	/* Input format:

	 * +----+----------------+

	 * | IV | SRC sg entries |

	 * +----+----------------+

	 */



	/* IV */

	sg = create_single_sg(sg, iv, ivsize);

	/* SRC entries */

	create_multi_sg(sg, skreq->src);



	return 0;

}



static int alloc_dst_sglist(struct skcipher_request *skreq, int ivsize)

{

	struct nitrox_kcrypt_request *nkreq = skcipher_request_ctx(skreq);

	int nents = sg_nents(skreq->dst) + 3;

	int extralen = ORH_HLEN + COMP_HLEN;

	struct se_crypto_request *creq = &nkreq->creq;

	struct scatterlist *sg;

	char *iv = nkreq->src;



	/* Allocate buffer to hold ORH, COMPLETION and output scatterlist

	 * array

	 */

	nkreq->dst = alloc_req_buf(nents, extralen, creq->gfp);

	if (!nkreq->dst)

		return -ENOMEM;



	creq->orh = (u64 *)(nkreq->dst);

	set_orh_value(creq->orh);



	creq->comp = (u64 *)(nkreq->dst + ORH_HLEN);

	set_comp_value(creq->comp);



	sg = (struct scatterlist *)(nkreq->dst + ORH_HLEN + COMP_HLEN);

	creq->dst = sg;

	sg_init_table(sg, nents);



	/* Output format:

	 * +-----+----+----------------+-----------------+

	 * | ORH | IV | DST sg entries | COMPLETION Bytes|

	 * +-----+----+----------------+-----------------+

	 */



	/* ORH */

	sg = create_single_sg(sg, creq->orh, ORH_HLEN);

	/* IV */

	sg = create_single_sg(sg, iv, ivsize);

	/* DST entries */

	sg = create_multi_sg(sg, skreq->dst);

	/* COMPLETION Bytes */

	create_single_sg(sg, creq->comp, COMP_HLEN);



	return 0;

}



static void free_src_sglist(struct skcipher_request *skreq)

{

	struct nitrox_kcrypt_request *nkreq = skcipher_request_ctx(skreq);



	kfree(nkreq->src);

}



static void free_dst_sglist(struct skcipher_request *skreq)

int nitrox_crypto_register(void)

{

	struct nitrox_kcrypt_request *nkreq = skcipher_request_ctx(skreq);

	int err;



	kfree(nkreq->dst);

}

	err = nitrox_register_skciphers();

	if (err)

		return err;



static void nitrox_skcipher_callback(struct skcipher_request *skreq,

				     int err)

{

	free_src_sglist(skreq);

	free_dst_sglist(skreq);

	err = nitrox_register_aeads();

	if (err) {

		pr_err_ratelimited("request failed status 0x%0x\n", err);

		err = -EINVAL;

	}



	skcipher_request_complete(skreq, err);

}



static int nitrox_skcipher_crypt(struct skcipher_request *skreq, bool enc)

{

	struct crypto_skcipher *cipher = crypto_skcipher_reqtfm(skreq);

	struct nitrox_crypto_ctx *nctx = crypto_skcipher_ctx(cipher);

	struct nitrox_kcrypt_request *nkreq = skcipher_request_ctx(skreq);

	int ivsize = crypto_skcipher_ivsize(cipher);

	struct se_crypto_request *creq;

	int ret;



	creq = &nkreq->creq;

	creq->flags = skreq->base.flags;

	creq->gfp = (skreq->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP) ?

		     GFP_KERNEL : GFP_ATOMIC;



	/* fill the request */

	creq->ctrl.value = 0;

	creq->opcode = FLEXI_CRYPTO_ENCRYPT_HMAC;

	creq->ctrl.s.arg = (enc ? ENCRYPT : DECRYPT);

	/* param0: length of the data to be encrypted */

	creq->gph.param0 = cpu_to_be16(skreq->cryptlen);

	creq->gph.param1 = 0;

	/* param2: encryption data offset */

	creq->gph.param2 = cpu_to_be16(ivsize);

	creq->gph.param3 = 0;



	creq->ctx_handle = nctx->u.ctx_handle;

	creq->ctrl.s.ctxl = sizeof(struct flexi_crypto_context);



	ret = alloc_src_sglist(skreq, ivsize);

	if (ret)

		return ret;



	ret = alloc_dst_sglist(skreq, ivsize);

	if (ret) {

		free_src_sglist(skreq);

		return ret;

	}



	nkreq->nctx = nctx;

	nkreq->skreq = skreq;



	/* send the crypto request */

	return nitrox_process_se_request(nctx->ndev, creq,

					 nitrox_skcipher_callback, skreq);

}



static int nitrox_aes_encrypt(struct skcipher_request *skreq)

{

	return nitrox_skcipher_crypt(skreq, true);

}



static int nitrox_aes_decrypt(struct skcipher_request *skreq)

{

	return nitrox_skcipher_crypt(skreq, false);

}



static int nitrox_3des_setkey(struct crypto_skcipher *cipher,

			      const u8 *key, unsigned int keylen)

{

	if (keylen != DES3_EDE_KEY_SIZE) {

		crypto_skcipher_set_flags(cipher, CRYPTO_TFM_RES_BAD_KEY_LEN);

		return -EINVAL;

	}



	return nitrox_skcipher_setkey(cipher, 0, key, keylen);

}



static int nitrox_3des_encrypt(struct skcipher_request *skreq)

{

	return nitrox_skcipher_crypt(skreq, true);

}



static int nitrox_3des_decrypt(struct skcipher_request *skreq)

{

	return nitrox_skcipher_crypt(skreq, false);

}



static int nitrox_aes_xts_setkey(struct crypto_skcipher *cipher,

				 const u8 *key, unsigned int keylen)

{

	struct crypto_tfm *tfm = crypto_skcipher_tfm(cipher);

	struct nitrox_crypto_ctx *nctx = crypto_tfm_ctx(tfm);

	struct flexi_crypto_context *fctx;

	int aes_keylen, ret;



	ret = xts_check_key(tfm, key, keylen);

	if (ret)

		return ret;



	keylen /= 2;



	aes_keylen = flexi_aes_keylen(keylen);

	if (aes_keylen < 0) {

		crypto_skcipher_set_flags(cipher, CRYPTO_TFM_RES_BAD_KEY_LEN);

		return -EINVAL;

	}



	fctx = nctx->u.fctx;

	/* copy KEY2 */

	memcpy(fctx->auth.u.key2, (key + keylen), keylen);



	return nitrox_skcipher_setkey(cipher, aes_keylen, key, keylen);

		nitrox_unregister_skciphers();

		return err;

	}



static int nitrox_aes_ctr_rfc3686_setkey(struct crypto_skcipher *cipher,

					 const u8 *key, unsigned int keylen)

{

	struct crypto_tfm *tfm = crypto_skcipher_tfm(cipher);

	struct nitrox_crypto_ctx *nctx = crypto_tfm_ctx(tfm);

	struct flexi_crypto_context *fctx;

	int aes_keylen;



	if (keylen < CTR_RFC3686_NONCE_SIZE)

		return -EINVAL;



	fctx = nctx->u.fctx;



	memcpy(fctx->crypto.iv, key + (keylen - CTR_RFC3686_NONCE_SIZE),

	       CTR_RFC3686_NONCE_SIZE);



	keylen -= CTR_RFC3686_NONCE_SIZE;



	aes_keylen = flexi_aes_keylen(keylen);

	if (aes_keylen < 0) {

		crypto_skcipher_set_flags(cipher, CRYPTO_TFM_RES_BAD_KEY_LEN);

		return -EINVAL;

	}

	return nitrox_skcipher_setkey(cipher, aes_keylen, key, keylen);

}



static struct skcipher_alg nitrox_skciphers[] = { {

	.base = {

		.cra_name = "cbc(aes)",

		.cra_driver_name = "n5_cbc(aes)",

		.cra_priority = PRIO,

		.cra_flags = CRYPTO_ALG_ASYNC,

		.cra_blocksize = AES_BLOCK_SIZE,

		.cra_ctxsize = sizeof(struct nitrox_crypto_ctx),

		.cra_alignmask = 0,

		.cra_module = THIS_MODULE,

	},

	.min_keysize = AES_MIN_KEY_SIZE,

	.max_keysize = AES_MAX_KEY_SIZE,

	.ivsize = AES_BLOCK_SIZE,

	.setkey = nitrox_aes_setkey,

	.encrypt = nitrox_aes_encrypt,

	.decrypt = nitrox_aes_decrypt,

	.init = nitrox_skcipher_init,

	.exit = nitrox_skcipher_exit,

}, {

	.base = {

		.cra_name = "ecb(aes)",

		.cra_driver_name = "n5_ecb(aes)",

		.cra_priority = PRIO,

		.cra_flags = CRYPTO_ALG_ASYNC,

		.cra_blocksize = AES_BLOCK_SIZE,

		.cra_ctxsize = sizeof(struct nitrox_crypto_ctx),

		.cra_alignmask = 0,

		.cra_module = THIS_MODULE,

	},

	.min_keysize = AES_MIN_KEY_SIZE,

	.max_keysize = AES_MAX_KEY_SIZE,

	.ivsize = AES_BLOCK_SIZE,

	.setkey = nitrox_aes_setkey,

	.encrypt = nitrox_aes_encrypt,

	.decrypt = nitrox_aes_decrypt,

	.init = nitrox_skcipher_init,

	.exit = nitrox_skcipher_exit,

}, {

	.base = {

		.cra_name = "cfb(aes)",

		.cra_driver_name = "n5_cfb(aes)",

		.cra_priority = PRIO,

		.cra_flags = CRYPTO_ALG_ASYNC,

		.cra_blocksize = AES_BLOCK_SIZE,

		.cra_ctxsize = sizeof(struct nitrox_crypto_ctx),

		.cra_alignmask = 0,

		.cra_module = THIS_MODULE,

	},

	.min_keysize = AES_MIN_KEY_SIZE,

	.max_keysize = AES_MAX_KEY_SIZE,

	.ivsize = AES_BLOCK_SIZE,

	.setkey = nitrox_aes_setkey,

	.encrypt = nitrox_aes_encrypt,

	.decrypt = nitrox_aes_decrypt,

	.init = nitrox_skcipher_init,

	.exit = nitrox_skcipher_exit,

}, {

	.base = {

		.cra_name = "xts(aes)",

		.cra_driver_name = "n5_xts(aes)",

		.cra_priority = PRIO,

		.cra_flags = CRYPTO_ALG_ASYNC,

		.cra_blocksize = AES_BLOCK_SIZE,

		.cra_ctxsize = sizeof(struct nitrox_crypto_ctx),

		.cra_alignmask = 0,

		.cra_module = THIS_MODULE,

	},

	.min_keysize = 2 * AES_MIN_KEY_SIZE,

	.max_keysize = 2 * AES_MAX_KEY_SIZE,

	.ivsize = AES_BLOCK_SIZE,

	.setkey = nitrox_aes_xts_setkey,

	.encrypt = nitrox_aes_encrypt,

	.decrypt = nitrox_aes_decrypt,

	.init = nitrox_skcipher_init,

	.exit = nitrox_skcipher_exit,

}, {

	.base = {

		.cra_name = "rfc3686(ctr(aes))",

		.cra_driver_name = "n5_rfc3686(ctr(aes))",

		.cra_priority = PRIO,

		.cra_flags = CRYPTO_ALG_ASYNC,

		.cra_blocksize = 1,

		.cra_ctxsize = sizeof(struct nitrox_crypto_ctx),

		.cra_alignmask = 0,

		.cra_module = THIS_MODULE,

	},

	.min_keysize = AES_MIN_KEY_SIZE + CTR_RFC3686_NONCE_SIZE,

	.max_keysize = AES_MAX_KEY_SIZE + CTR_RFC3686_NONCE_SIZE,

	.ivsize = CTR_RFC3686_IV_SIZE,

	.init = nitrox_skcipher_init,

	.exit = nitrox_skcipher_exit,

	.setkey = nitrox_aes_ctr_rfc3686_setkey,

	.encrypt = nitrox_aes_encrypt,

	.decrypt = nitrox_aes_decrypt,

}, {

	.base = {

		.cra_name = "cts(cbc(aes))",

		.cra_driver_name = "n5_cts(cbc(aes))",

		.cra_priority = PRIO,

		.cra_flags = CRYPTO_ALG_ASYNC,

		.cra_blocksize = AES_BLOCK_SIZE,

		.cra_ctxsize = sizeof(struct nitrox_crypto_ctx),

		.cra_alignmask = 0,

		.cra_type = &crypto_ablkcipher_type,

		.cra_module = THIS_MODULE,

	},

	.min_keysize = AES_MIN_KEY_SIZE,

	.max_keysize = AES_MAX_KEY_SIZE,

	.ivsize = AES_BLOCK_SIZE,

	.setkey = nitrox_aes_setkey,

	.encrypt = nitrox_aes_encrypt,

	.decrypt = nitrox_aes_decrypt,

	.init = nitrox_skcipher_init,

	.exit = nitrox_skcipher_exit,

}, {

	.base = {

		.cra_name = "cbc(des3_ede)",

		.cra_driver_name = "n5_cbc(des3_ede)",

		.cra_priority = PRIO,

		.cra_flags = CRYPTO_ALG_ASYNC,

		.cra_blocksize = DES3_EDE_BLOCK_SIZE,

		.cra_ctxsize = sizeof(struct nitrox_crypto_ctx),

		.cra_alignmask = 0,

		.cra_module = THIS_MODULE,

	},

	.min_keysize = DES3_EDE_KEY_SIZE,

	.max_keysize = DES3_EDE_KEY_SIZE,

	.ivsize = DES3_EDE_BLOCK_SIZE,

	.setkey = nitrox_3des_setkey,

	.encrypt = nitrox_3des_encrypt,

	.decrypt = nitrox_3des_decrypt,

	.init = nitrox_skcipher_init,

	.exit = nitrox_skcipher_exit,

}, {

	.base = {

		.cra_name = "ecb(des3_ede)",

		.cra_driver_name = "n5_ecb(des3_ede)",

		.cra_priority = PRIO,

		.cra_flags = CRYPTO_ALG_ASYNC,

		.cra_blocksize = DES3_EDE_BLOCK_SIZE,

		.cra_ctxsize = sizeof(struct nitrox_crypto_ctx),

		.cra_alignmask = 0,

		.cra_module = THIS_MODULE,

	},

	.min_keysize = DES3_EDE_KEY_SIZE,

	.max_keysize = DES3_EDE_KEY_SIZE,

	.ivsize = DES3_EDE_BLOCK_SIZE,

	.setkey = nitrox_3des_setkey,

	.encrypt = nitrox_3des_encrypt,

	.decrypt = nitrox_3des_decrypt,

	.init = nitrox_skcipher_init,

	.exit = nitrox_skcipher_exit,

}



};



int nitrox_crypto_register(void)

{

	return crypto_register_skciphers(nitrox_skciphers,

					 ARRAY_SIZE(nitrox_skciphers));

	return 0;

}



void nitrox_crypto_unregister(void)

{

	crypto_unregister_skciphers(nitrox_skciphers,

				    ARRAY_SIZE(nitrox_skciphers));

	nitrox_unregister_aeads();

	nitrox_unregister_skciphers();

}

drivers/crypto/cavium/nitrox/nitrox_common.h

+5 −1

File changed.

Preview size limit exceeded, changes collapsed.

drivers/crypto/cavium/nitrox/nitrox_req.h

+201 −38

File changed.

Preview size limit exceeded, changes collapsed.