[deliverable/linux.git] / arch / s390 / crypto / aes_s390.c

/*
 * Cryptographic API.
 *
 * s390 implementation of the AES Cipher Algorithm.
 *
 * s390 Version:
 *   Copyright IBM Corp. 2005,2007
 *   Author(s): Jan Glauber (jang@de.ibm.com)
 *
 * Derived from "crypto/aes.c"
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 2 of the License, or (at your option)
 * any later version.
 *
 */

#include <crypto/algapi.h>
#include <linux/module.h>
#include <linux/init.h>
#include "crypt_s390.h"

#define AES_MIN_KEY_SIZE	16
#define AES_MAX_KEY_SIZE	32

/* data block size for all key lengths */
#define AES_BLOCK_SIZE		16

#define AES_KEYLEN_128		1
#define AES_KEYLEN_192		2
#define AES_KEYLEN_256		4

static char keylen_flag = 0;

struct s390_aes_ctx {
	u8 iv[AES_BLOCK_SIZE];
	u8 key[AES_MAX_KEY_SIZE];
	long enc;
	long dec;
	int key_len;
};

static int aes_set_key(struct crypto_tfm *tfm, const u8 *in_key,
		       unsigned int key_len)
{
	struct s390_aes_ctx *sctx = crypto_tfm_ctx(tfm);
	u32 *flags = &tfm->crt_flags;

	switch (key_len) {
	case 16:
		if (!(keylen_flag & AES_KEYLEN_128))
			goto fail;
		break;
	case 24:
		if (!(keylen_flag & AES_KEYLEN_192))
			goto fail;

		break;
	case 32:
		if (!(keylen_flag & AES_KEYLEN_256))
			goto fail;
		break;
	default:
		goto fail;
		break;
	}

	sctx->key_len = key_len;
	memcpy(sctx->key, in_key, key_len);
	return 0;
fail:
	*flags |= CRYPTO_TFM_RES_BAD_KEY_LEN;
	return -EINVAL;
}

static void aes_encrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
{
	const struct s390_aes_ctx *sctx = crypto_tfm_ctx(tfm);

	switch (sctx->key_len) {
	case 16:
		crypt_s390_km(KM_AES_128_ENCRYPT, &sctx->key, out, in,
			      AES_BLOCK_SIZE);
		break;
	case 24:
		crypt_s390_km(KM_AES_192_ENCRYPT, &sctx->key, out, in,
			      AES_BLOCK_SIZE);
		break;
	case 32:
		crypt_s390_km(KM_AES_256_ENCRYPT, &sctx->key, out, in,
			      AES_BLOCK_SIZE);
		break;
	}
}

static void aes_decrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
{
	const struct s390_aes_ctx *sctx = crypto_tfm_ctx(tfm);

	switch (sctx->key_len) {
	case 16:
		crypt_s390_km(KM_AES_128_DECRYPT, &sctx->key, out, in,
			      AES_BLOCK_SIZE);
		break;
	case 24:
		crypt_s390_km(KM_AES_192_DECRYPT, &sctx->key, out, in,
			      AES_BLOCK_SIZE);
		break;
	case 32:
		crypt_s390_km(KM_AES_256_DECRYPT, &sctx->key, out, in,
			      AES_BLOCK_SIZE);
		break;
	}
}


static struct crypto_alg aes_alg = {
	.cra_name		=	"aes",
	.cra_driver_name	=	"aes-s390",
	.cra_priority		=	CRYPT_S390_PRIORITY,
	.cra_flags		=	CRYPTO_ALG_TYPE_CIPHER,
	.cra_blocksize		=	AES_BLOCK_SIZE,
	.cra_ctxsize		=	sizeof(struct s390_aes_ctx),
	.cra_module		=	THIS_MODULE,
	.cra_list		=	LIST_HEAD_INIT(aes_alg.cra_list),
	.cra_u			=	{
		.cipher = {
			.cia_min_keysize	=	AES_MIN_KEY_SIZE,
			.cia_max_keysize	=	AES_MAX_KEY_SIZE,
			.cia_setkey		=	aes_set_key,
			.cia_encrypt		=	aes_encrypt,
			.cia_decrypt		=	aes_decrypt,
		}
	}
};

static int ecb_aes_set_key(struct crypto_tfm *tfm, const u8 *in_key,
			   unsigned int key_len)
{
	struct s390_aes_ctx *sctx = crypto_tfm_ctx(tfm);

	switch (key_len) {
	case 16:
		sctx->enc = KM_AES_128_ENCRYPT;
		sctx->dec = KM_AES_128_DECRYPT;
		break;
	case 24:
		sctx->enc = KM_AES_192_ENCRYPT;
		sctx->dec = KM_AES_192_DECRYPT;
		break;
	case 32:
		sctx->enc = KM_AES_256_ENCRYPT;
		sctx->dec = KM_AES_256_DECRYPT;
		break;
	}

	return aes_set_key(tfm, in_key, key_len);
}

static int ecb_aes_crypt(struct blkcipher_desc *desc, long func, void *param,
			 struct blkcipher_walk *walk)
{
	int ret = blkcipher_walk_virt(desc, walk);
	unsigned int nbytes;

	while ((nbytes = walk->nbytes)) {
		/* only use complete blocks */
		unsigned int n = nbytes & ~(AES_BLOCK_SIZE - 1);
		u8 *out = walk->dst.virt.addr;
		u8 *in = walk->src.virt.addr;

		ret = crypt_s390_km(func, param, out, in, n);
		BUG_ON((ret < 0) || (ret != n));

		nbytes &= AES_BLOCK_SIZE - 1;
		ret = blkcipher_walk_done(desc, walk, nbytes);
	}

	return ret;
}

static int ecb_aes_encrypt(struct blkcipher_desc *desc,
			   struct scatterlist *dst, struct scatterlist *src,
			   unsigned int nbytes)
{
	struct s390_aes_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
	struct blkcipher_walk walk;

	blkcipher_walk_init(&walk, dst, src, nbytes);
	return ecb_aes_crypt(desc, sctx->enc, sctx->key, &walk);
}

static int ecb_aes_decrypt(struct blkcipher_desc *desc,
			   struct scatterlist *dst, struct scatterlist *src,
			   unsigned int nbytes)
{
	struct s390_aes_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
	struct blkcipher_walk walk;

	blkcipher_walk_init(&walk, dst, src, nbytes);
	return ecb_aes_crypt(desc, sctx->dec, sctx->key, &walk);
}

static struct crypto_alg ecb_aes_alg = {
	.cra_name		=	"ecb(aes)",
	.cra_driver_name	=	"ecb-aes-s390",
	.cra_priority		=	CRYPT_S390_COMPOSITE_PRIORITY,
	.cra_flags		=	CRYPTO_ALG_TYPE_BLKCIPHER,
	.cra_blocksize		=	AES_BLOCK_SIZE,
	.cra_ctxsize		=	sizeof(struct s390_aes_ctx),
	.cra_type		=	&crypto_blkcipher_type,
	.cra_module		=	THIS_MODULE,
	.cra_list		=	LIST_HEAD_INIT(ecb_aes_alg.cra_list),
	.cra_u			=	{
		.blkcipher = {
			.min_keysize		=	AES_MIN_KEY_SIZE,
			.max_keysize		=	AES_MAX_KEY_SIZE,
			.setkey			=	ecb_aes_set_key,
			.encrypt		=	ecb_aes_encrypt,
			.decrypt		=	ecb_aes_decrypt,
		}
	}
};

static int cbc_aes_set_key(struct crypto_tfm *tfm, const u8 *in_key,
			   unsigned int key_len)
{
	struct s390_aes_ctx *sctx = crypto_tfm_ctx(tfm);

	switch (key_len) {
	case 16:
		sctx->enc = KMC_AES_128_ENCRYPT;
		sctx->dec = KMC_AES_128_DECRYPT;
		break;
	case 24:
		sctx->enc = KMC_AES_192_ENCRYPT;
		sctx->dec = KMC_AES_192_DECRYPT;
		break;
	case 32:
		sctx->enc = KMC_AES_256_ENCRYPT;
		sctx->dec = KMC_AES_256_DECRYPT;
		break;
	}

	return aes_set_key(tfm, in_key, key_len);
}

static int cbc_aes_crypt(struct blkcipher_desc *desc, long func, void *param,
			 struct blkcipher_walk *walk)
{
	int ret = blkcipher_walk_virt(desc, walk);
	unsigned int nbytes = walk->nbytes;

	if (!nbytes)
		goto out;

	memcpy(param, walk->iv, AES_BLOCK_SIZE);
	do {
		/* only use complete blocks */
		unsigned int n = nbytes & ~(AES_BLOCK_SIZE - 1);
		u8 *out = walk->dst.virt.addr;
		u8 *in = walk->src.virt.addr;

		ret = crypt_s390_kmc(func, param, out, in, n);
		BUG_ON((ret < 0) || (ret != n));

		nbytes &= AES_BLOCK_SIZE - 1;
		ret = blkcipher_walk_done(desc, walk, nbytes);
	} while ((nbytes = walk->nbytes));
	memcpy(walk->iv, param, AES_BLOCK_SIZE);

out:
	return ret;
}

static int cbc_aes_encrypt(struct blkcipher_desc *desc,
			   struct scatterlist *dst, struct scatterlist *src,
			   unsigned int nbytes)
{
	struct s390_aes_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
	struct blkcipher_walk walk;

	blkcipher_walk_init(&walk, dst, src, nbytes);
	return cbc_aes_crypt(desc, sctx->enc, sctx->iv, &walk);
}

static int cbc_aes_decrypt(struct blkcipher_desc *desc,
			   struct scatterlist *dst, struct scatterlist *src,
			   unsigned int nbytes)
{
	struct s390_aes_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
	struct blkcipher_walk walk;

	blkcipher_walk_init(&walk, dst, src, nbytes);
	return cbc_aes_crypt(desc, sctx->dec, sctx->iv, &walk);
}

static struct crypto_alg cbc_aes_alg = {
	.cra_name		=	"cbc(aes)",
	.cra_driver_name	=	"cbc-aes-s390",
	.cra_priority		=	CRYPT_S390_COMPOSITE_PRIORITY,
	.cra_flags		=	CRYPTO_ALG_TYPE_BLKCIPHER,
	.cra_blocksize		=	AES_BLOCK_SIZE,
	.cra_ctxsize		=	sizeof(struct s390_aes_ctx),
	.cra_type		=	&crypto_blkcipher_type,
	.cra_module		=	THIS_MODULE,
	.cra_list		=	LIST_HEAD_INIT(cbc_aes_alg.cra_list),
	.cra_u			=	{
		.blkcipher = {
			.min_keysize		=	AES_MIN_KEY_SIZE,
			.max_keysize		=	AES_MAX_KEY_SIZE,
			.ivsize			=	AES_BLOCK_SIZE,
			.setkey			=	cbc_aes_set_key,
			.encrypt		=	cbc_aes_encrypt,
			.decrypt		=	cbc_aes_decrypt,
		}
	}
};

static int __init aes_init(void)
{
	int ret;

	if (crypt_s390_func_available(KM_AES_128_ENCRYPT))
		keylen_flag |= AES_KEYLEN_128;
	if (crypt_s390_func_available(KM_AES_192_ENCRYPT))
		keylen_flag |= AES_KEYLEN_192;
	if (crypt_s390_func_available(KM_AES_256_ENCRYPT))
		keylen_flag |= AES_KEYLEN_256;

	if (!keylen_flag)
		return -EOPNOTSUPP;

	/* z9 109 and z9 BC/EC only support 128 bit key length */
	if (keylen_flag == AES_KEYLEN_128)
		printk(KERN_INFO
		       "aes_s390: hardware acceleration only available for"
		       "128 bit keys\n");

	ret = crypto_register_alg(&aes_alg);
	if (ret)
		goto aes_err;

	ret = crypto_register_alg(&ecb_aes_alg);
	if (ret)
		goto ecb_aes_err;

	ret = crypto_register_alg(&cbc_aes_alg);
	if (ret)
		goto cbc_aes_err;

out:
	return ret;

cbc_aes_err:
	crypto_unregister_alg(&ecb_aes_alg);
ecb_aes_err:
	crypto_unregister_alg(&aes_alg);
aes_err:
	goto out;
}

static void __exit aes_fini(void)
{
	crypto_unregister_alg(&cbc_aes_alg);
	crypto_unregister_alg(&ecb_aes_alg);
	crypto_unregister_alg(&aes_alg);
}

module_init(aes_init);
module_exit(aes_fini);

MODULE_ALIAS("aes");

MODULE_DESCRIPTION("Rijndael (AES) Cipher Algorithm");
MODULE_LICENSE("GPL");
Commit	Line	Data
bf754ae8 JG	1	/*
	2	* Cryptographic API.
	3	*
	4	* s390 implementation of the AES Cipher Algorithm.
	5	*
	6	* s390 Version:
86aa9fc2	7	* Copyright IBM Corp. 2005,2007
bf754ae8 JG	8	* Author(s): Jan Glauber (jang@de.ibm.com)
	9	*
	10	* Derived from "crypto/aes.c"
	11	*
	12	* This program is free software; you can redistribute it and/or modify it
	13	* under the terms of the GNU General Public License as published by the Free
	14	* Software Foundation; either version 2 of the License, or (at your option)
	15	* any later version.
	16	*
	17	*/
	18
a9e62fad	19	#include <crypto/algapi.h>
bf754ae8 JG	20	#include <linux/module.h>
bf754ae8 JG	21	#include <linux/init.h>
bf754ae8 JG	22	#include "crypt_s390.h"
	23
	24	#define AES_MIN_KEY_SIZE 16
	25	#define AES_MAX_KEY_SIZE 32
	26
	27	/* data block size for all key lengths */
	28	#define AES_BLOCK_SIZE 16
	29
86aa9fc2 JG	30	#define AES_KEYLEN_128 1
	31	#define AES_KEYLEN_192 2
	32	#define AES_KEYLEN_256 4
	33
	34	static char keylen_flag = 0;
bf754ae8 JG	35
	36	struct s390_aes_ctx {
	37	u8 iv[AES_BLOCK_SIZE];
	38	u8 key[AES_MAX_KEY_SIZE];
a9e62fad HX	39	long enc;
a9e62fad HX	40	long dec;
bf754ae8 JG	41	int key_len;
	42	};
	43
6c2bb98b	44	static int aes_set_key(struct crypto_tfm tfm, const u8 in_key,
560c06ae	45	unsigned int key_len)
bf754ae8	46	{
6c2bb98b	47	struct s390_aes_ctx *sctx = crypto_tfm_ctx(tfm);
560c06ae	48	u32 *flags = &tfm->crt_flags;
bf754ae8 JG	49
	50	switch (key_len) {
	51	case 16:
86aa9fc2	52	if (!(keylen_flag & AES_KEYLEN_128))
bf754ae8 JG	53	goto fail;
	54	break;
	55	case 24:
86aa9fc2	56	if (!(keylen_flag & AES_KEYLEN_192))
bf754ae8 JG	57	goto fail;
	58
	59	break;
	60	case 32:
86aa9fc2	61	if (!(keylen_flag & AES_KEYLEN_256))
bf754ae8 JG	62	goto fail;
	63	break;
	64	default:
bf754ae8 JG	65	goto fail;
	66	break;
	67	}
	68
	69	sctx->key_len = key_len;
	70	memcpy(sctx->key, in_key, key_len);
	71	return 0;
	72	fail:
	73	*flags \|= CRYPTO_TFM_RES_BAD_KEY_LEN;
	74	return -EINVAL;
	75	}
	76
6c2bb98b	77	static void aes_encrypt(struct crypto_tfm tfm, u8 out, const u8 *in)
bf754ae8	78	{
6c2bb98b	79	const struct s390_aes_ctx *sctx = crypto_tfm_ctx(tfm);
bf754ae8 JG	80
	81	switch (sctx->key_len) {
	82	case 16:
	83	crypt_s390_km(KM_AES_128_ENCRYPT, &sctx->key, out, in,
	84	AES_BLOCK_SIZE);
	85	break;
	86	case 24:
	87	crypt_s390_km(KM_AES_192_ENCRYPT, &sctx->key, out, in,
	88	AES_BLOCK_SIZE);
	89	break;
	90	case 32:
	91	crypt_s390_km(KM_AES_256_ENCRYPT, &sctx->key, out, in,
	92	AES_BLOCK_SIZE);
	93	break;
	94	}
	95	}
	96
6c2bb98b	97	static void aes_decrypt(struct crypto_tfm tfm, u8 out, const u8 *in)
bf754ae8	98	{
6c2bb98b	99	const struct s390_aes_ctx *sctx = crypto_tfm_ctx(tfm);
bf754ae8 JG	100
	101	switch (sctx->key_len) {
	102	case 16:
	103	crypt_s390_km(KM_AES_128_DECRYPT, &sctx->key, out, in,
	104	AES_BLOCK_SIZE);
	105	break;
	106	case 24:
	107	crypt_s390_km(KM_AES_192_DECRYPT, &sctx->key, out, in,
	108	AES_BLOCK_SIZE);
	109	break;
	110	case 32:
	111	crypt_s390_km(KM_AES_256_DECRYPT, &sctx->key, out, in,
	112	AES_BLOCK_SIZE);
	113	break;
	114	}
	115	}
	116
bf754ae8 JG	117
	118	static struct crypto_alg aes_alg = {
	119	.cra_name = "aes",
65b75c36 HX	120	.cra_driver_name = "aes-s390",
65b75c36 HX	121	.cra_priority = CRYPT_S390_PRIORITY,
bf754ae8 JG	122	.cra_flags = CRYPTO_ALG_TYPE_CIPHER,
	123	.cra_blocksize = AES_BLOCK_SIZE,
	124	.cra_ctxsize = sizeof(struct s390_aes_ctx),
	125	.cra_module = THIS_MODULE,
	126	.cra_list = LIST_HEAD_INIT(aes_alg.cra_list),
	127	.cra_u = {
	128	.cipher = {
	129	.cia_min_keysize = AES_MIN_KEY_SIZE,
	130	.cia_max_keysize = AES_MAX_KEY_SIZE,
	131	.cia_setkey = aes_set_key,
	132	.cia_encrypt = aes_encrypt,
	133	.cia_decrypt = aes_decrypt,
bf754ae8 JG	134	}
	135	}
	136	};
	137
a9e62fad HX	138	static int ecb_aes_set_key(struct crypto_tfm tfm, const u8 in_key,
	139	unsigned int key_len)
	140	{
	141	struct s390_aes_ctx *sctx = crypto_tfm_ctx(tfm);
	142
	143	switch (key_len) {
	144	case 16:
	145	sctx->enc = KM_AES_128_ENCRYPT;
	146	sctx->dec = KM_AES_128_DECRYPT;
	147	break;
	148	case 24:
	149	sctx->enc = KM_AES_192_ENCRYPT;
	150	sctx->dec = KM_AES_192_DECRYPT;
	151	break;
	152	case 32:
	153	sctx->enc = KM_AES_256_ENCRYPT;
	154	sctx->dec = KM_AES_256_DECRYPT;
	155	break;
	156	}
	157
	158	return aes_set_key(tfm, in_key, key_len);
	159	}
	160
	161	static int ecb_aes_crypt(struct blkcipher_desc desc, long func, void param,
	162	struct blkcipher_walk *walk)
	163	{
	164	int ret = blkcipher_walk_virt(desc, walk);
	165	unsigned int nbytes;
	166
	167	while ((nbytes = walk->nbytes)) {
	168	/* only use complete blocks */
	169	unsigned int n = nbytes & ~(AES_BLOCK_SIZE - 1);
	170	u8 *out = walk->dst.virt.addr;
	171	u8 *in = walk->src.virt.addr;
	172
	173	ret = crypt_s390_km(func, param, out, in, n);
	174	BUG_ON((ret < 0) \|\| (ret != n));
	175
	176	nbytes &= AES_BLOCK_SIZE - 1;
	177	ret = blkcipher_walk_done(desc, walk, nbytes);
	178	}
	179
	180	return ret;
	181	}
	182
	183	static int ecb_aes_encrypt(struct blkcipher_desc *desc,
	184	struct scatterlist dst, struct scatterlist src,
	185	unsigned int nbytes)
	186	{
	187	struct s390_aes_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
	188	struct blkcipher_walk walk;
	189
	190	blkcipher_walk_init(&walk, dst, src, nbytes);
	191	return ecb_aes_crypt(desc, sctx->enc, sctx->key, &walk);
	192	}
	193
	194	static int ecb_aes_decrypt(struct blkcipher_desc *desc,
	195	struct scatterlist dst, struct scatterlist src,
	196	unsigned int nbytes)
	197	{
	198	struct s390_aes_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
	199	struct blkcipher_walk walk;
	200
	201	blkcipher_walk_init(&walk, dst, src, nbytes);
202	return ecb_aes_crypt(desc, sctx->dec, sctx->key, &walk);
203	}
204
205	static struct crypto_alg ecb_aes_alg = {
206	.cra_name = "ecb(aes)",
207	.cra_driver_name = "ecb-aes-s390",
208	.cra_priority = CRYPT_S390_COMPOSITE_PRIORITY,
209	.cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER,
210	.cra_blocksize = AES_BLOCK_SIZE,
211	.cra_ctxsize = sizeof(struct s390_aes_ctx),
212	.cra_type = &crypto_blkcipher_type,
213	.cra_module = THIS_MODULE,
214	.cra_list = LIST_HEAD_INIT(ecb_aes_alg.cra_list),
215	.cra_u = {
216	.blkcipher = {
217	.min_keysize = AES_MIN_KEY_SIZE,
218	.max_keysize = AES_MAX_KEY_SIZE,
219	.setkey = ecb_aes_set_key,
220	.encrypt = ecb_aes_encrypt,
221	.decrypt = ecb_aes_decrypt,
222	}
223	}
224	};
225
226	static int cbc_aes_set_key(struct crypto_tfm tfm, const u8 in_key,
227	unsigned int key_len)
228	{
229	struct s390_aes_ctx *sctx = crypto_tfm_ctx(tfm);
230
231	switch (key_len) {
232	case 16:
233	sctx->enc = KMC_AES_128_ENCRYPT;
234	sctx->dec = KMC_AES_128_DECRYPT;
235	break;
236	case 24:
237	sctx->enc = KMC_AES_192_ENCRYPT;
238	sctx->dec = KMC_AES_192_DECRYPT;
239	break;
240	case 32:
241	sctx->enc = KMC_AES_256_ENCRYPT;
242	sctx->dec = KMC_AES_256_DECRYPT;
243	break;
244	}
245
246	return aes_set_key(tfm, in_key, key_len);
247	}
248
249	static int cbc_aes_crypt(struct blkcipher_desc desc, long func, void param,
250	struct blkcipher_walk *walk)
251	{
252	int ret = blkcipher_walk_virt(desc, walk);
253	unsigned int nbytes = walk->nbytes;
254
255	if (!nbytes)
256	goto out;
257
258	memcpy(param, walk->iv, AES_BLOCK_SIZE);
259	do {
260	/* only use complete blocks */
261	unsigned int n = nbytes & ~(AES_BLOCK_SIZE - 1);
262	u8 *out = walk->dst.virt.addr;
263	u8 *in = walk->src.virt.addr;
264
265	ret = crypt_s390_kmc(func, param, out, in, n);
266	BUG_ON((ret < 0) \|\| (ret != n));
267
268	nbytes &= AES_BLOCK_SIZE - 1;
269	ret = blkcipher_walk_done(desc, walk, nbytes);
270	} while ((nbytes = walk->nbytes));
271	memcpy(walk->iv, param, AES_BLOCK_SIZE);
272
273	out:
274	return ret;
275	}
276
277	static int cbc_aes_encrypt(struct blkcipher_desc *desc,
278	struct scatterlist dst, struct scatterlist src,
279	unsigned int nbytes)
280	{
281	struct s390_aes_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
282	struct blkcipher_walk walk;
283
284	blkcipher_walk_init(&walk, dst, src, nbytes);
285	return cbc_aes_crypt(desc, sctx->enc, sctx->iv, &walk);
286	}
287
288	static int cbc_aes_decrypt(struct blkcipher_desc *desc,
289	struct scatterlist dst, struct scatterlist src,
290	unsigned int nbytes)
291	{
292	struct s390_aes_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
293	struct blkcipher_walk walk;
294
295	blkcipher_walk_init(&walk, dst, src, nbytes);
296	return cbc_aes_crypt(desc, sctx->dec, sctx->iv, &walk);
297	}
298
299	static struct crypto_alg cbc_aes_alg = {
300	.cra_name = "cbc(aes)",
301	.cra_driver_name = "cbc-aes-s390",
302	.cra_priority = CRYPT_S390_COMPOSITE_PRIORITY,
303	.cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER,
304	.cra_blocksize = AES_BLOCK_SIZE,
305	.cra_ctxsize = sizeof(struct s390_aes_ctx),
306	.cra_type = &crypto_blkcipher_type,
307	.cra_module = THIS_MODULE,
308	.cra_list = LIST_HEAD_INIT(cbc_aes_alg.cra_list),
309	.cra_u = {
310	.blkcipher = {
311	.min_keysize = AES_MIN_KEY_SIZE,
312	.max_keysize = AES_MAX_KEY_SIZE,
313	.ivsize = AES_BLOCK_SIZE,
314	.setkey = cbc_aes_set_key,
315	.encrypt = cbc_aes_encrypt,
316	.decrypt = cbc_aes_decrypt,
317	}
318	}
319	};
320
bf754ae8 JG	321	static int __init aes_init(void)
	322	{
	323	int ret;
	324
	325	if (crypt_s390_func_available(KM_AES_128_ENCRYPT))
86aa9fc2	326	keylen_flag \|= AES_KEYLEN_128;
bf754ae8	327	if (crypt_s390_func_available(KM_AES_192_ENCRYPT))
86aa9fc2	328	keylen_flag \|= AES_KEYLEN_192;
bf754ae8	329	if (crypt_s390_func_available(KM_AES_256_ENCRYPT))
86aa9fc2 JG	330	keylen_flag \|= AES_KEYLEN_256;
	331
	332	if (!keylen_flag)
	333	return -EOPNOTSUPP;
bf754ae8	334
86aa9fc2 JG	335	/* z9 109 and z9 BC/EC only support 128 bit key length */
	336	if (keylen_flag == AES_KEYLEN_128)
	337	printk(KERN_INFO
	338	"aes_s390: hardware acceleration only available for"
	339	"128 bit keys\n");
bf754ae8 JG	340
bf754ae8 JG	341	ret = crypto_register_alg(&aes_alg);
86aa9fc2	342	if (ret)
a9e62fad	343	goto aes_err;
a9e62fad HX	344
a9e62fad HX	345	ret = crypto_register_alg(&ecb_aes_alg);
86aa9fc2	346	if (ret)
a9e62fad	347	goto ecb_aes_err;
a9e62fad HX	348
a9e62fad HX	349	ret = crypto_register_alg(&cbc_aes_alg);
86aa9fc2	350	if (ret)
a9e62fad	351	goto cbc_aes_err;
a9e62fad HX	352
a9e62fad HX	353	out:
bf754ae8	354	return ret;
a9e62fad HX	355
	356	cbc_aes_err:
	357	crypto_unregister_alg(&ecb_aes_alg);
	358	ecb_aes_err:
	359	crypto_unregister_alg(&aes_alg);
	360	aes_err:
	361	goto out;
bf754ae8 JG	362	}
	363
	364	static void __exit aes_fini(void)
	365	{
a9e62fad HX	366	crypto_unregister_alg(&cbc_aes_alg);
a9e62fad HX	367	crypto_unregister_alg(&ecb_aes_alg);
bf754ae8 JG	368	crypto_unregister_alg(&aes_alg);
	369	}
	370
	371	module_init(aes_init);
	372	module_exit(aes_fini);
	373
	374	MODULE_ALIAS("aes");
	375
	376	MODULE_DESCRIPTION("Rijndael (AES) Cipher Algorithm");
	377	MODULE_LICENSE("GPL");
	378