[linux-block.git] / drivers / crypto / cavium / nitrox / nitrox_algs.c

// 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);
	void *fctx;

	/* get the first device */
	nctx->ndev = nitrox_get_first_device();
	if (!nctx->ndev)
		return -ENODEV;

	/* allocate nitrox crypto context */
	fctx = crypto_alloc_context(nctx->ndev);
	if (!fctx) {
		nitrox_put_device(nctx->ndev);
		return -ENOMEM;
	}
	nctx->u.ctx_handle = (uintptr_t)fctx;
	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 *)fctx);
	}
	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 void nitrox_skcipher_callback(struct skcipher_request *skreq,
				     int err)
{
	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;

	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);

	/* copy the iv */
	memcpy(creq->iv, skreq->iv, ivsize);
	creq->ivsize = ivsize;
	creq->src = skreq->src;
	creq->dst = skreq->dst;

	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);
}

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));
}

void nitrox_crypto_unregister(void)
{
	crypto_unregister_skciphers(nitrox_skciphers,
				    ARRAY_SIZE(nitrox_skciphers));
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
f2663872 SJ	2	#include <linux/crypto.h>
	3	#include <linux/kernel.h>
	4	#include <linux/module.h>
	5	#include <linux/printk.h>
	6
	7	#include <crypto/aes.h>
	8	#include <crypto/skcipher.h>
	9	#include <crypto/ctr.h>
	10	#include <crypto/des.h>
	11	#include <crypto/xts.h>
	12
	13	#include "nitrox_dev.h"
	14	#include "nitrox_common.h"
	15	#include "nitrox_req.h"
	16
	17	#define PRIO 4001
	18
	19	struct nitrox_cipher {
	20	const char *name;
	21	enum flexi_cipher value;
	22	};
	23
	24	/**
	25	* supported cipher list
	26	*/
	27	static const struct nitrox_cipher flexi_cipher_table[] = {
	28	{ "null", CIPHER_NULL },
	29	{ "cbc(des3_ede)", CIPHER_3DES_CBC },
	30	{ "ecb(des3_ede)", CIPHER_3DES_ECB },
	31	{ "cbc(aes)", CIPHER_AES_CBC },
	32	{ "ecb(aes)", CIPHER_AES_ECB },
	33	{ "cfb(aes)", CIPHER_AES_CFB },
	34	{ "rfc3686(ctr(aes))", CIPHER_AES_CTR },
	35	{ "xts(aes)", CIPHER_AES_XTS },
	36	{ "cts(cbc(aes))", CIPHER_AES_CBC_CTS },
	37	{ NULL, CIPHER_INVALID }
	38	};
	39
	40	static enum flexi_cipher flexi_cipher_type(const char *name)
	41	{
	42	const struct nitrox_cipher *cipher = flexi_cipher_table;
	43
	44	while (cipher->name) {
	45	if (!strcmp(cipher->name, name))
	46	break;
	47	cipher++;
	48	}
	49	return cipher->value;
	50	}
	51
	52	static int flexi_aes_keylen(int keylen)
	53	{
	54	int aes_keylen;
	55
	56	switch (keylen) {
	57	case AES_KEYSIZE_128:
	58	aes_keylen = 1;
	59	break;
	60	case AES_KEYSIZE_192:
	61	aes_keylen = 2;
	62	break;
	63	case AES_KEYSIZE_256:
	64	aes_keylen = 3;
	65	break;
66	default:
67	aes_keylen = -EINVAL;
68	break;
69	}
70	return aes_keylen;
71	}
72
73	static int nitrox_skcipher_init(struct crypto_skcipher *tfm)
74	{
75	struct nitrox_crypto_ctx *nctx = crypto_skcipher_ctx(tfm);
76	void *fctx;
77
78	/* get the first device */
79	nctx->ndev = nitrox_get_first_device();
80	if (!nctx->ndev)
81	return -ENODEV;
82
83	/* allocate nitrox crypto context */
84	fctx = crypto_alloc_context(nctx->ndev);
85	if (!fctx) {
86	nitrox_put_device(nctx->ndev);
87	return -ENOMEM;
88	}
89	nctx->u.ctx_handle = (uintptr_t)fctx;
90	crypto_skcipher_set_reqsize(tfm, crypto_skcipher_reqsize(tfm) +
91	sizeof(struct nitrox_kcrypt_request));
92	return 0;
93	}
94
95	static void nitrox_skcipher_exit(struct crypto_skcipher *tfm)
96	{
97	struct nitrox_crypto_ctx *nctx = crypto_skcipher_ctx(tfm);
98
99	/* free the nitrox crypto context */
100	if (nctx->u.ctx_handle) {
101	struct flexi_crypto_context *fctx = nctx->u.fctx;
102
103	memset(&fctx->crypto, 0, sizeof(struct crypto_keys));
104	memset(&fctx->auth, 0, sizeof(struct auth_keys));
105	crypto_free_context((void *)fctx);
106	}
107	nitrox_put_device(nctx->ndev);
108
109	nctx->u.ctx_handle = 0;
110	nctx->ndev = NULL;
111	}
112
113	static inline int nitrox_skcipher_setkey(struct crypto_skcipher *cipher,
114	int aes_keylen, const u8 *key,
115	unsigned int keylen)
116	{
117	struct crypto_tfm *tfm = crypto_skcipher_tfm(cipher);
118	struct nitrox_crypto_ctx *nctx = crypto_tfm_ctx(tfm);
119	struct flexi_crypto_context *fctx;
120	enum flexi_cipher cipher_type;
121	const char *name;
122
123	name = crypto_tfm_alg_name(tfm);
124	cipher_type = flexi_cipher_type(name);
125	if (unlikely(cipher_type == CIPHER_INVALID)) {
126	pr_err("unsupported cipher: %s\n", name);
127	return -EINVAL;
128	}
129
130	/* fill crypto context */
131	fctx = nctx->u.fctx;
132	fctx->flags = 0;
133	fctx->w0.cipher_type = cipher_type;
134	fctx->w0.aes_keylen = aes_keylen;
135	fctx->w0.iv_source = IV_FROM_DPTR;
136	fctx->flags = cpu_to_be64((u64 )&fctx->w0);
137	/* copy the key to context */
138	memcpy(fctx->crypto.u.key, key, keylen);
139
140	return 0;
141	}
142
143	static int nitrox_aes_setkey(struct crypto_skcipher cipher, const u8 key,
144	unsigned int keylen)
145	{
146	int aes_keylen;
147
148	aes_keylen = flexi_aes_keylen(keylen);
149	if (aes_keylen < 0) {
150	crypto_skcipher_set_flags(cipher, CRYPTO_TFM_RES_BAD_KEY_LEN);
151	return -EINVAL;
152	}
153	return nitrox_skcipher_setkey(cipher, aes_keylen, key, keylen);
154	}
155
156	static void nitrox_skcipher_callback(struct skcipher_request *skreq,
157	int err)
158	{
159	if (err) {
160	pr_err_ratelimited("request failed status 0x%0x\n", err);
161	err = -EINVAL;
162	}
163	skcipher_request_complete(skreq, err);
164	}
165
166	static int nitrox_skcipher_crypt(struct skcipher_request *skreq, bool enc)
167	{
168	struct crypto_skcipher *cipher = crypto_skcipher_reqtfm(skreq);
169	struct nitrox_crypto_ctx *nctx = crypto_skcipher_ctx(cipher);
170	struct nitrox_kcrypt_request *nkreq = skcipher_request_ctx(skreq);
171	int ivsize = crypto_skcipher_ivsize(cipher);
172	struct se_crypto_request *creq;
173
174	creq = &nkreq->creq;
175	creq->flags = skreq->base.flags;
176	creq->gfp = (skreq->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP) ?
177	GFP_KERNEL : GFP_ATOMIC;
178
179	/* fill the request */
180	creq->ctrl.value = 0;
181	creq->opcode = FLEXI_CRYPTO_ENCRYPT_HMAC;
182	creq->ctrl.s.arg = (enc ? ENCRYPT : DECRYPT);
183	/* param0: length of the data to be encrypted */
184	creq->gph.param0 = cpu_to_be16(skreq->cryptlen);
185	creq->gph.param1 = 0;
186	/* param2: encryption data offset */
187	creq->gph.param2 = cpu_to_be16(ivsize);
188	creq->gph.param3 = 0;
189
190	creq->ctx_handle = nctx->u.ctx_handle;
191	creq->ctrl.s.ctxl = sizeof(struct flexi_crypto_context);
192
193	/* copy the iv */
194	memcpy(creq->iv, skreq->iv, ivsize);
195	creq->ivsize = ivsize;
196	creq->src = skreq->src;
197	creq->dst = skreq->dst;
198
199	nkreq->nctx = nctx;
200	nkreq->skreq = skreq;
201
202	/* send the crypto request */
203	return nitrox_process_se_request(nctx->ndev, creq,
204	nitrox_skcipher_callback, skreq);
205	}
206
207	static int nitrox_aes_encrypt(struct skcipher_request *skreq)
208	{
209	return nitrox_skcipher_crypt(skreq, true);
210	}
211
212	static int nitrox_aes_decrypt(struct skcipher_request *skreq)
213	{
214	return nitrox_skcipher_crypt(skreq, false);
215	}
216
217	static int nitrox_3des_setkey(struct crypto_skcipher *cipher,
218	const u8 *key, unsigned int keylen)
219	{
220	if (keylen != DES3_EDE_KEY_SIZE) {
221	crypto_skcipher_set_flags(cipher, CRYPTO_TFM_RES_BAD_KEY_LEN);
222	return -EINVAL;
223	}
224
225	return nitrox_skcipher_setkey(cipher, 0, key, keylen);
226	}
227
228	static int nitrox_3des_encrypt(struct skcipher_request *skreq)
229	{
230	return nitrox_skcipher_crypt(skreq, true);
231	}
232
233	static int nitrox_3des_decrypt(struct skcipher_request *skreq)
234	{
235	return nitrox_skcipher_crypt(skreq, false);
236	}
237
238	static int nitrox_aes_xts_setkey(struct crypto_skcipher *cipher,
239	const u8 *key, unsigned int keylen)
240	{
241	struct crypto_tfm *tfm = crypto_skcipher_tfm(cipher);
242	struct nitrox_crypto_ctx *nctx = crypto_tfm_ctx(tfm);
243	struct flexi_crypto_context *fctx;
244	int aes_keylen, ret;
245
246	ret = xts_check_key(tfm, key, keylen);
247	if (ret)
248	return ret;
249
250	keylen /= 2;
251
252	aes_keylen = flexi_aes_keylen(keylen);
253	if (aes_keylen < 0) {
254	crypto_skcipher_set_flags(cipher, CRYPTO_TFM_RES_BAD_KEY_LEN);
255	return -EINVAL;
256	}
257
258	fctx = nctx->u.fctx;
259	/* copy KEY2 */
260	memcpy(fctx->auth.u.key2, (key + keylen), keylen);
261
262	return nitrox_skcipher_setkey(cipher, aes_keylen, key, keylen);
263	}
264
265	static int nitrox_aes_ctr_rfc3686_setkey(struct crypto_skcipher *cipher,
266	const u8 *key, unsigned int keylen)
267	{
268	struct crypto_tfm *tfm = crypto_skcipher_tfm(cipher);
269	struct nitrox_crypto_ctx *nctx = crypto_tfm_ctx(tfm);
270	struct flexi_crypto_context *fctx;
271	int aes_keylen;
272
273	if (keylen < CTR_RFC3686_NONCE_SIZE)
274	return -EINVAL;
275
276	fctx = nctx->u.fctx;
277
278	memcpy(fctx->crypto.iv, key + (keylen - CTR_RFC3686_NONCE_SIZE),
279	CTR_RFC3686_NONCE_SIZE);
280
281	keylen -= CTR_RFC3686_NONCE_SIZE;
282
283	aes_keylen = flexi_aes_keylen(keylen);
284	if (aes_keylen < 0) {
285	crypto_skcipher_set_flags(cipher, CRYPTO_TFM_RES_BAD_KEY_LEN);
286	return -EINVAL;
287	}
288	return nitrox_skcipher_setkey(cipher, aes_keylen, key, keylen);
289	}
290
291	static struct skcipher_alg nitrox_skciphers[] = { {
292	.base = {
293	.cra_name = "cbc(aes)",
294	.cra_driver_name = "n5_cbc(aes)",
295	.cra_priority = PRIO,
296	.cra_flags = CRYPTO_ALG_ASYNC,
297	.cra_blocksize = AES_BLOCK_SIZE,
298	.cra_ctxsize = sizeof(struct nitrox_crypto_ctx),
299	.cra_alignmask = 0,
300	.cra_module = THIS_MODULE,
301	},
302	.min_keysize = AES_MIN_KEY_SIZE,
303	.max_keysize = AES_MAX_KEY_SIZE,
304	.ivsize = AES_BLOCK_SIZE,
305	.setkey = nitrox_aes_setkey,
306	.encrypt = nitrox_aes_encrypt,
307	.decrypt = nitrox_aes_decrypt,
308	.init = nitrox_skcipher_init,
309	.exit = nitrox_skcipher_exit,
310	}, {
311	.base = {
312	.cra_name = "ecb(aes)",
313	.cra_driver_name = "n5_ecb(aes)",
314	.cra_priority = PRIO,
315	.cra_flags = CRYPTO_ALG_ASYNC,
316	.cra_blocksize = AES_BLOCK_SIZE,
317	.cra_ctxsize = sizeof(struct nitrox_crypto_ctx),
318	.cra_alignmask = 0,
319	.cra_module = THIS_MODULE,
320	},
321	.min_keysize = AES_MIN_KEY_SIZE,
322	.max_keysize = AES_MAX_KEY_SIZE,
323	.ivsize = AES_BLOCK_SIZE,
324	.setkey = nitrox_aes_setkey,
325	.encrypt = nitrox_aes_encrypt,
326	.decrypt = nitrox_aes_decrypt,
327	.init = nitrox_skcipher_init,
328	.exit = nitrox_skcipher_exit,
329	}, {
330	.base = {
331	.cra_name = "cfb(aes)",
332	.cra_driver_name = "n5_cfb(aes)",
333	.cra_priority = PRIO,
334	.cra_flags = CRYPTO_ALG_ASYNC,
335	.cra_blocksize = AES_BLOCK_SIZE,
336	.cra_ctxsize = sizeof(struct nitrox_crypto_ctx),
337	.cra_alignmask = 0,
338	.cra_module = THIS_MODULE,
339	},
340	.min_keysize = AES_MIN_KEY_SIZE,
341	.max_keysize = AES_MAX_KEY_SIZE,
342	.ivsize = AES_BLOCK_SIZE,
343	.setkey = nitrox_aes_setkey,
344	.encrypt = nitrox_aes_encrypt,
345	.decrypt = nitrox_aes_decrypt,
346	.init = nitrox_skcipher_init,
347	.exit = nitrox_skcipher_exit,
348	}, {
349	.base = {
350	.cra_name = "xts(aes)",
351	.cra_driver_name = "n5_xts(aes)",
352	.cra_priority = PRIO,
353	.cra_flags = CRYPTO_ALG_ASYNC,
354	.cra_blocksize = AES_BLOCK_SIZE,
355	.cra_ctxsize = sizeof(struct nitrox_crypto_ctx),
356	.cra_alignmask = 0,
357	.cra_module = THIS_MODULE,
358	},
359	.min_keysize = 2 * AES_MIN_KEY_SIZE,
360	.max_keysize = 2 * AES_MAX_KEY_SIZE,
361	.ivsize = AES_BLOCK_SIZE,
362	.setkey = nitrox_aes_xts_setkey,
363	.encrypt = nitrox_aes_encrypt,
364	.decrypt = nitrox_aes_decrypt,
365	.init = nitrox_skcipher_init,
366	.exit = nitrox_skcipher_exit,
367	}, {
368	.base = {
369	.cra_name = "rfc3686(ctr(aes))",
370	.cra_driver_name = "n5_rfc3686(ctr(aes))",
371	.cra_priority = PRIO,
372	.cra_flags = CRYPTO_ALG_ASYNC,
373	.cra_blocksize = 1,
374	.cra_ctxsize = sizeof(struct nitrox_crypto_ctx),
375	.cra_alignmask = 0,
376	.cra_module = THIS_MODULE,
377	},
378	.min_keysize = AES_MIN_KEY_SIZE + CTR_RFC3686_NONCE_SIZE,
379	.max_keysize = AES_MAX_KEY_SIZE + CTR_RFC3686_NONCE_SIZE,
380	.ivsize = CTR_RFC3686_IV_SIZE,
381	.init = nitrox_skcipher_init,
382	.exit = nitrox_skcipher_exit,
383	.setkey = nitrox_aes_ctr_rfc3686_setkey,
384	.encrypt = nitrox_aes_encrypt,
385	.decrypt = nitrox_aes_decrypt,
386	}, {
387	.base = {
388	.cra_name = "cts(cbc(aes))",
389	.cra_driver_name = "n5_cts(cbc(aes))",
390	.cra_priority = PRIO,
391	.cra_flags = CRYPTO_ALG_ASYNC,
392	.cra_blocksize = AES_BLOCK_SIZE,
393	.cra_ctxsize = sizeof(struct nitrox_crypto_ctx),
394	.cra_alignmask = 0,
395	.cra_type = &crypto_ablkcipher_type,
396	.cra_module = THIS_MODULE,
397	},
398	.min_keysize = AES_MIN_KEY_SIZE,
399	.max_keysize = AES_MAX_KEY_SIZE,
400	.ivsize = AES_BLOCK_SIZE,
401	.setkey = nitrox_aes_setkey,
402	.encrypt = nitrox_aes_encrypt,
403	.decrypt = nitrox_aes_decrypt,
404	.init = nitrox_skcipher_init,
405	.exit = nitrox_skcipher_exit,
406	}, {
407	.base = {
408	.cra_name = "cbc(des3_ede)",
409	.cra_driver_name = "n5_cbc(des3_ede)",
410	.cra_priority = PRIO,
411	.cra_flags = CRYPTO_ALG_ASYNC,
412	.cra_blocksize = DES3_EDE_BLOCK_SIZE,
413	.cra_ctxsize = sizeof(struct nitrox_crypto_ctx),
414	.cra_alignmask = 0,
415	.cra_module = THIS_MODULE,
416	},
417	.min_keysize = DES3_EDE_KEY_SIZE,
418	.max_keysize = DES3_EDE_KEY_SIZE,
419	.ivsize = DES3_EDE_BLOCK_SIZE,
420	.setkey = nitrox_3des_setkey,
421	.encrypt = nitrox_3des_encrypt,
422	.decrypt = nitrox_3des_decrypt,
423	.init = nitrox_skcipher_init,
424	.exit = nitrox_skcipher_exit,
425	}, {
426	.base = {
427	.cra_name = "ecb(des3_ede)",
428	.cra_driver_name = "n5_ecb(des3_ede)",
429	.cra_priority = PRIO,
430	.cra_flags = CRYPTO_ALG_ASYNC,
431	.cra_blocksize = DES3_EDE_BLOCK_SIZE,
432	.cra_ctxsize = sizeof(struct nitrox_crypto_ctx),
433	.cra_alignmask = 0,
434	.cra_module = THIS_MODULE,
435	},
436	.min_keysize = DES3_EDE_KEY_SIZE,
437	.max_keysize = DES3_EDE_KEY_SIZE,
438	.ivsize = DES3_EDE_BLOCK_SIZE,
439	.setkey = nitrox_3des_setkey,
440	.encrypt = nitrox_3des_encrypt,
441	.decrypt = nitrox_3des_decrypt,
442	.init = nitrox_skcipher_init,
443	.exit = nitrox_skcipher_exit,
444	}
445
446	};
447
448	int nitrox_crypto_register(void)
449	{
450	return crypto_register_skciphers(nitrox_skciphers,
451	ARRAY_SIZE(nitrox_skciphers));
452	}
453
454	void nitrox_crypto_unregister(void)
455	{
456	crypto_unregister_skciphers(nitrox_skciphers,
457	ARRAY_SIZE(nitrox_skciphers));
458	}