[mirror_ubuntu-bionic-kernel.git] / arch / x86 / crypto / serpent_avx_glue.c

/*
 * Glue Code for AVX assembler versions of Serpent Cipher
 *
 * Copyright (C) 2012 Johannes Goetzfried
 *     <Johannes.Goetzfried@informatik.stud.uni-erlangen.de>
 *
 * Copyright © 2011-2013 Jussi Kivilinna <jussi.kivilinna@iki.fi>
 *
 * 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.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
 * USA
 *
 */

#include <linux/module.h>
#include <linux/hardirq.h>
#include <linux/types.h>
#include <linux/crypto.h>
#include <linux/err.h>
#include <crypto/ablk_helper.h>
#include <crypto/algapi.h>
#include <crypto/serpent.h>
#include <crypto/cryptd.h>
#include <crypto/b128ops.h>
#include <crypto/ctr.h>
#include <crypto/lrw.h>
#include <crypto/xts.h>
#include <asm/xcr.h>
#include <asm/fpu/xstate.h>
#include <asm/crypto/serpent-avx.h>
#include <asm/crypto/glue_helper.h>

/* 8-way parallel cipher functions */
asmlinkage void serpent_ecb_enc_8way_avx(struct serpent_ctx *ctx, u8 *dst,
					 const u8 *src);
EXPORT_SYMBOL_GPL(serpent_ecb_enc_8way_avx);

asmlinkage void serpent_ecb_dec_8way_avx(struct serpent_ctx *ctx, u8 *dst,
					 const u8 *src);
EXPORT_SYMBOL_GPL(serpent_ecb_dec_8way_avx);

asmlinkage void serpent_cbc_dec_8way_avx(struct serpent_ctx *ctx, u8 *dst,
					 const u8 *src);
EXPORT_SYMBOL_GPL(serpent_cbc_dec_8way_avx);

asmlinkage void serpent_ctr_8way_avx(struct serpent_ctx *ctx, u8 *dst,
				     const u8 *src, le128 *iv);
EXPORT_SYMBOL_GPL(serpent_ctr_8way_avx);

asmlinkage void serpent_xts_enc_8way_avx(struct serpent_ctx *ctx, u8 *dst,
					 const u8 *src, le128 *iv);
EXPORT_SYMBOL_GPL(serpent_xts_enc_8way_avx);

asmlinkage void serpent_xts_dec_8way_avx(struct serpent_ctx *ctx, u8 *dst,
					 const u8 *src, le128 *iv);
EXPORT_SYMBOL_GPL(serpent_xts_dec_8way_avx);

void __serpent_crypt_ctr(void *ctx, u128 *dst, const u128 *src, le128 *iv)
{
	be128 ctrblk;

	le128_to_be128(&ctrblk, iv);
	le128_inc(iv);

	__serpent_encrypt(ctx, (u8 *)&ctrblk, (u8 *)&ctrblk);
	u128_xor(dst, src, (u128 *)&ctrblk);
}
EXPORT_SYMBOL_GPL(__serpent_crypt_ctr);

void serpent_xts_enc(void *ctx, u128 *dst, const u128 *src, le128 *iv)
{
	glue_xts_crypt_128bit_one(ctx, dst, src, iv,
				  GLUE_FUNC_CAST(__serpent_encrypt));
}
EXPORT_SYMBOL_GPL(serpent_xts_enc);

void serpent_xts_dec(void *ctx, u128 *dst, const u128 *src, le128 *iv)
{
	glue_xts_crypt_128bit_one(ctx, dst, src, iv,
				  GLUE_FUNC_CAST(__serpent_decrypt));
}
EXPORT_SYMBOL_GPL(serpent_xts_dec);


static const struct common_glue_ctx serpent_enc = {
	.num_funcs = 2,
	.fpu_blocks_limit = SERPENT_PARALLEL_BLOCKS,

	.funcs = { {
		.num_blocks = SERPENT_PARALLEL_BLOCKS,
		.fn_u = { .ecb = GLUE_FUNC_CAST(serpent_ecb_enc_8way_avx) }
	}, {
		.num_blocks = 1,
		.fn_u = { .ecb = GLUE_FUNC_CAST(__serpent_encrypt) }
	} }
};

static const struct common_glue_ctx serpent_ctr = {
	.num_funcs = 2,
	.fpu_blocks_limit = SERPENT_PARALLEL_BLOCKS,

	.funcs = { {
		.num_blocks = SERPENT_PARALLEL_BLOCKS,
		.fn_u = { .ctr = GLUE_CTR_FUNC_CAST(serpent_ctr_8way_avx) }
	}, {
		.num_blocks = 1,
		.fn_u = { .ctr = GLUE_CTR_FUNC_CAST(__serpent_crypt_ctr) }
	} }
};

static const struct common_glue_ctx serpent_enc_xts = {
	.num_funcs = 2,
	.fpu_blocks_limit = SERPENT_PARALLEL_BLOCKS,

	.funcs = { {
		.num_blocks = SERPENT_PARALLEL_BLOCKS,
		.fn_u = { .xts = GLUE_XTS_FUNC_CAST(serpent_xts_enc_8way_avx) }
	}, {
		.num_blocks = 1,
		.fn_u = { .xts = GLUE_XTS_FUNC_CAST(serpent_xts_enc) }
	} }
};

static const struct common_glue_ctx serpent_dec = {
	.num_funcs = 2,
	.fpu_blocks_limit = SERPENT_PARALLEL_BLOCKS,

	.funcs = { {
		.num_blocks = SERPENT_PARALLEL_BLOCKS,
		.fn_u = { .ecb = GLUE_FUNC_CAST(serpent_ecb_dec_8way_avx) }
	}, {
		.num_blocks = 1,
		.fn_u = { .ecb = GLUE_FUNC_CAST(__serpent_decrypt) }
	} }
};

static const struct common_glue_ctx serpent_dec_cbc = {
	.num_funcs = 2,
	.fpu_blocks_limit = SERPENT_PARALLEL_BLOCKS,

	.funcs = { {
		.num_blocks = SERPENT_PARALLEL_BLOCKS,
		.fn_u = { .cbc = GLUE_CBC_FUNC_CAST(serpent_cbc_dec_8way_avx) }
	}, {
		.num_blocks = 1,
		.fn_u = { .cbc = GLUE_CBC_FUNC_CAST(__serpent_decrypt) }
	} }
};

static const struct common_glue_ctx serpent_dec_xts = {
	.num_funcs = 2,
	.fpu_blocks_limit = SERPENT_PARALLEL_BLOCKS,

	.funcs = { {
		.num_blocks = SERPENT_PARALLEL_BLOCKS,
		.fn_u = { .xts = GLUE_XTS_FUNC_CAST(serpent_xts_dec_8way_avx) }
	}, {
		.num_blocks = 1,
		.fn_u = { .xts = GLUE_XTS_FUNC_CAST(serpent_xts_dec) }
	} }
};

static int ecb_encrypt(struct blkcipher_desc *desc, struct scatterlist *dst,
		       struct scatterlist *src, unsigned int nbytes)
{
	return glue_ecb_crypt_128bit(&serpent_enc, desc, dst, src, nbytes);
}

static int ecb_decrypt(struct blkcipher_desc *desc, struct scatterlist *dst,
		       struct scatterlist *src, unsigned int nbytes)
{
	return glue_ecb_crypt_128bit(&serpent_dec, desc, dst, src, nbytes);
}

static int cbc_encrypt(struct blkcipher_desc *desc, struct scatterlist *dst,
		       struct scatterlist *src, unsigned int nbytes)
{
	return glue_cbc_encrypt_128bit(GLUE_FUNC_CAST(__serpent_encrypt), desc,
				     dst, src, nbytes);
}

static int cbc_decrypt(struct blkcipher_desc *desc, struct scatterlist *dst,
		       struct scatterlist *src, unsigned int nbytes)
{
	return glue_cbc_decrypt_128bit(&serpent_dec_cbc, desc, dst, src,
				       nbytes);
}

static int ctr_crypt(struct blkcipher_desc *desc, struct scatterlist *dst,
		     struct scatterlist *src, unsigned int nbytes)
{
	return glue_ctr_crypt_128bit(&serpent_ctr, desc, dst, src, nbytes);
}

static inline bool serpent_fpu_begin(bool fpu_enabled, unsigned int nbytes)
{
	return glue_fpu_begin(SERPENT_BLOCK_SIZE, SERPENT_PARALLEL_BLOCKS,
			      NULL, fpu_enabled, nbytes);
}

static inline void serpent_fpu_end(bool fpu_enabled)
{
	glue_fpu_end(fpu_enabled);
}

struct crypt_priv {
	struct serpent_ctx *ctx;
	bool fpu_enabled;
};

static void encrypt_callback(void *priv, u8 *srcdst, unsigned int nbytes)
{
	const unsigned int bsize = SERPENT_BLOCK_SIZE;
	struct crypt_priv *ctx = priv;
	int i;

	ctx->fpu_enabled = serpent_fpu_begin(ctx->fpu_enabled, nbytes);

	if (nbytes == bsize * SERPENT_PARALLEL_BLOCKS) {
		serpent_ecb_enc_8way_avx(ctx->ctx, srcdst, srcdst);
		return;
	}

	for (i = 0; i < nbytes / bsize; i++, srcdst += bsize)
		__serpent_encrypt(ctx->ctx, srcdst, srcdst);
}

static void decrypt_callback(void *priv, u8 *srcdst, unsigned int nbytes)
{
	const unsigned int bsize = SERPENT_BLOCK_SIZE;
	struct crypt_priv *ctx = priv;
	int i;

	ctx->fpu_enabled = serpent_fpu_begin(ctx->fpu_enabled, nbytes);

	if (nbytes == bsize * SERPENT_PARALLEL_BLOCKS) {
		serpent_ecb_dec_8way_avx(ctx->ctx, srcdst, srcdst);
		return;
	}

	for (i = 0; i < nbytes / bsize; i++, srcdst += bsize)
		__serpent_decrypt(ctx->ctx, srcdst, srcdst);
}

int lrw_serpent_setkey(struct crypto_tfm *tfm, const u8 *key,
		       unsigned int keylen)
{
	struct serpent_lrw_ctx *ctx = crypto_tfm_ctx(tfm);
	int err;

	err = __serpent_setkey(&ctx->serpent_ctx, key, keylen -
							SERPENT_BLOCK_SIZE);
	if (err)
		return err;

	return lrw_init_table(&ctx->lrw_table, key + keylen -
						SERPENT_BLOCK_SIZE);
}
EXPORT_SYMBOL_GPL(lrw_serpent_setkey);

static int lrw_encrypt(struct blkcipher_desc *desc, struct scatterlist *dst,
		       struct scatterlist *src, unsigned int nbytes)
{
	struct serpent_lrw_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
	be128 buf[SERPENT_PARALLEL_BLOCKS];
	struct crypt_priv crypt_ctx = {
		.ctx = &ctx->serpent_ctx,
		.fpu_enabled = false,
	};
	struct lrw_crypt_req req = {
		.tbuf = buf,
		.tbuflen = sizeof(buf),

		.table_ctx = &ctx->lrw_table,
		.crypt_ctx = &crypt_ctx,
		.crypt_fn = encrypt_callback,
	};
	int ret;

	desc->flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP;
	ret = lrw_crypt(desc, dst, src, nbytes, &req);
	serpent_fpu_end(crypt_ctx.fpu_enabled);

	return ret;
}

static int lrw_decrypt(struct blkcipher_desc *desc, struct scatterlist *dst,
		       struct scatterlist *src, unsigned int nbytes)
{
	struct serpent_lrw_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
	be128 buf[SERPENT_PARALLEL_BLOCKS];
	struct crypt_priv crypt_ctx = {
		.ctx = &ctx->serpent_ctx,
		.fpu_enabled = false,
	};
	struct lrw_crypt_req req = {
		.tbuf = buf,
		.tbuflen = sizeof(buf),

		.table_ctx = &ctx->lrw_table,
		.crypt_ctx = &crypt_ctx,
		.crypt_fn = decrypt_callback,
	};
	int ret;

	desc->flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP;
	ret = lrw_crypt(desc, dst, src, nbytes, &req);
	serpent_fpu_end(crypt_ctx.fpu_enabled);

	return ret;
}

void lrw_serpent_exit_tfm(struct crypto_tfm *tfm)
{
	struct serpent_lrw_ctx *ctx = crypto_tfm_ctx(tfm);

	lrw_free_table(&ctx->lrw_table);
}
EXPORT_SYMBOL_GPL(lrw_serpent_exit_tfm);

int xts_serpent_setkey(struct crypto_tfm *tfm, const u8 *key,
		       unsigned int keylen)
{
	struct serpent_xts_ctx *ctx = crypto_tfm_ctx(tfm);
	u32 *flags = &tfm->crt_flags;
	int err;

	/* key consists of keys of equal size concatenated, therefore
	 * the length must be even
	 */
	if (keylen % 2) {
		*flags |= CRYPTO_TFM_RES_BAD_KEY_LEN;
		return -EINVAL;
	}

	/* first half of xts-key is for crypt */
	err = __serpent_setkey(&ctx->crypt_ctx, key, keylen / 2);
	if (err)
		return err;

	/* second half of xts-key is for tweak */
	return __serpent_setkey(&ctx->tweak_ctx, key + keylen / 2, keylen / 2);
}
EXPORT_SYMBOL_GPL(xts_serpent_setkey);

static int xts_encrypt(struct blkcipher_desc *desc, struct scatterlist *dst,
		       struct scatterlist *src, unsigned int nbytes)
{
	struct serpent_xts_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);

	return glue_xts_crypt_128bit(&serpent_enc_xts, desc, dst, src, nbytes,
				     XTS_TWEAK_CAST(__serpent_encrypt),
				     &ctx->tweak_ctx, &ctx->crypt_ctx);
}

static int xts_decrypt(struct blkcipher_desc *desc, struct scatterlist *dst,
		       struct scatterlist *src, unsigned int nbytes)
{
	struct serpent_xts_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);

	return glue_xts_crypt_128bit(&serpent_dec_xts, desc, dst, src, nbytes,
				     XTS_TWEAK_CAST(__serpent_encrypt),
				     &ctx->tweak_ctx, &ctx->crypt_ctx);
}

static struct crypto_alg serpent_algs[10] = { {
	.cra_name		= "__ecb-serpent-avx",
	.cra_driver_name	= "__driver-ecb-serpent-avx",
	.cra_priority		= 0,
	.cra_flags		= CRYPTO_ALG_TYPE_BLKCIPHER |
				  CRYPTO_ALG_INTERNAL,
	.cra_blocksize		= SERPENT_BLOCK_SIZE,
	.cra_ctxsize		= sizeof(struct serpent_ctx),
	.cra_alignmask		= 0,
	.cra_type		= &crypto_blkcipher_type,
	.cra_module		= THIS_MODULE,
	.cra_u = {
		.blkcipher = {
			.min_keysize	= SERPENT_MIN_KEY_SIZE,
			.max_keysize	= SERPENT_MAX_KEY_SIZE,
			.setkey		= serpent_setkey,
			.encrypt	= ecb_encrypt,
			.decrypt	= ecb_decrypt,
		},
	},
}, {
	.cra_name		= "__cbc-serpent-avx",
	.cra_driver_name	= "__driver-cbc-serpent-avx",
	.cra_priority		= 0,
	.cra_flags		= CRYPTO_ALG_TYPE_BLKCIPHER |
				  CRYPTO_ALG_INTERNAL,
	.cra_blocksize		= SERPENT_BLOCK_SIZE,
	.cra_ctxsize		= sizeof(struct serpent_ctx),
	.cra_alignmask		= 0,
	.cra_type		= &crypto_blkcipher_type,
	.cra_module		= THIS_MODULE,
	.cra_u = {
		.blkcipher = {
			.min_keysize	= SERPENT_MIN_KEY_SIZE,
			.max_keysize	= SERPENT_MAX_KEY_SIZE,
			.setkey		= serpent_setkey,
			.encrypt	= cbc_encrypt,
			.decrypt	= cbc_decrypt,
		},
	},
}, {
	.cra_name		= "__ctr-serpent-avx",
	.cra_driver_name	= "__driver-ctr-serpent-avx",
	.cra_priority		= 0,
	.cra_flags		= CRYPTO_ALG_TYPE_BLKCIPHER |
				  CRYPTO_ALG_INTERNAL,
	.cra_blocksize		= 1,
	.cra_ctxsize		= sizeof(struct serpent_ctx),
	.cra_alignmask		= 0,
	.cra_type		= &crypto_blkcipher_type,
	.cra_module		= THIS_MODULE,
	.cra_u = {
		.blkcipher = {
			.min_keysize	= SERPENT_MIN_KEY_SIZE,
			.max_keysize	= SERPENT_MAX_KEY_SIZE,
			.ivsize		= SERPENT_BLOCK_SIZE,
			.setkey		= serpent_setkey,
			.encrypt	= ctr_crypt,
			.decrypt	= ctr_crypt,
		},
	},
}, {
	.cra_name		= "__lrw-serpent-avx",
	.cra_driver_name	= "__driver-lrw-serpent-avx",
	.cra_priority		= 0,
	.cra_flags		= CRYPTO_ALG_TYPE_BLKCIPHER |
				  CRYPTO_ALG_INTERNAL,
	.cra_blocksize		= SERPENT_BLOCK_SIZE,
	.cra_ctxsize		= sizeof(struct serpent_lrw_ctx),
	.cra_alignmask		= 0,
	.cra_type		= &crypto_blkcipher_type,
	.cra_module		= THIS_MODULE,
	.cra_exit		= lrw_serpent_exit_tfm,
	.cra_u = {
		.blkcipher = {
			.min_keysize	= SERPENT_MIN_KEY_SIZE +
					  SERPENT_BLOCK_SIZE,
			.max_keysize	= SERPENT_MAX_KEY_SIZE +
					  SERPENT_BLOCK_SIZE,
			.ivsize		= SERPENT_BLOCK_SIZE,
			.setkey		= lrw_serpent_setkey,
			.encrypt	= lrw_encrypt,
			.decrypt	= lrw_decrypt,
		},
	},
}, {
	.cra_name		= "__xts-serpent-avx",
	.cra_driver_name	= "__driver-xts-serpent-avx",
	.cra_priority		= 0,
	.cra_flags		= CRYPTO_ALG_TYPE_BLKCIPHER |
				  CRYPTO_ALG_INTERNAL,
	.cra_blocksize		= SERPENT_BLOCK_SIZE,
	.cra_ctxsize		= sizeof(struct serpent_xts_ctx),
	.cra_alignmask		= 0,
	.cra_type		= &crypto_blkcipher_type,
	.cra_module		= THIS_MODULE,
	.cra_u = {
		.blkcipher = {
			.min_keysize	= SERPENT_MIN_KEY_SIZE * 2,
			.max_keysize	= SERPENT_MAX_KEY_SIZE * 2,
			.ivsize		= SERPENT_BLOCK_SIZE,
			.setkey		= xts_serpent_setkey,
			.encrypt	= xts_encrypt,
			.decrypt	= xts_decrypt,
		},
	},
}, {
	.cra_name		= "ecb(serpent)",
	.cra_driver_name	= "ecb-serpent-avx",
	.cra_priority		= 500,
	.cra_flags		= CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
	.cra_blocksize		= SERPENT_BLOCK_SIZE,
	.cra_ctxsize		= sizeof(struct async_helper_ctx),
	.cra_alignmask		= 0,
	.cra_type		= &crypto_ablkcipher_type,
	.cra_module		= THIS_MODULE,
	.cra_init		= ablk_init,
	.cra_exit		= ablk_exit,
	.cra_u = {
		.ablkcipher = {
			.min_keysize	= SERPENT_MIN_KEY_SIZE,
			.max_keysize	= SERPENT_MAX_KEY_SIZE,
			.setkey		= ablk_set_key,
			.encrypt	= ablk_encrypt,
			.decrypt	= ablk_decrypt,
		},
	},
}, {
	.cra_name		= "cbc(serpent)",
	.cra_driver_name	= "cbc-serpent-avx",
	.cra_priority		= 500,
	.cra_flags		= CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
	.cra_blocksize		= SERPENT_BLOCK_SIZE,
	.cra_ctxsize		= sizeof(struct async_helper_ctx),
	.cra_alignmask		= 0,
	.cra_type		= &crypto_ablkcipher_type,
	.cra_module		= THIS_MODULE,
	.cra_init		= ablk_init,
	.cra_exit		= ablk_exit,
	.cra_u = {
		.ablkcipher = {
			.min_keysize	= SERPENT_MIN_KEY_SIZE,
			.max_keysize	= SERPENT_MAX_KEY_SIZE,
			.ivsize		= SERPENT_BLOCK_SIZE,
			.setkey		= ablk_set_key,
			.encrypt	= __ablk_encrypt,
			.decrypt	= ablk_decrypt,
		},
	},
}, {
	.cra_name		= "ctr(serpent)",
	.cra_driver_name	= "ctr-serpent-avx",
	.cra_priority		= 500,
	.cra_flags		= CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
	.cra_blocksize		= 1,
	.cra_ctxsize		= sizeof(struct async_helper_ctx),
	.cra_alignmask		= 0,
	.cra_type		= &crypto_ablkcipher_type,
	.cra_module		= THIS_MODULE,
	.cra_init		= ablk_init,
	.cra_exit		= ablk_exit,
	.cra_u = {
		.ablkcipher = {
			.min_keysize	= SERPENT_MIN_KEY_SIZE,
			.max_keysize	= SERPENT_MAX_KEY_SIZE,
			.ivsize		= SERPENT_BLOCK_SIZE,
			.setkey		= ablk_set_key,
			.encrypt	= ablk_encrypt,
			.decrypt	= ablk_encrypt,
			.geniv		= "chainiv",
		},
	},
}, {
	.cra_name		= "lrw(serpent)",
	.cra_driver_name	= "lrw-serpent-avx",
	.cra_priority		= 500,
	.cra_flags		= CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
	.cra_blocksize		= SERPENT_BLOCK_SIZE,
	.cra_ctxsize		= sizeof(struct async_helper_ctx),
	.cra_alignmask		= 0,
	.cra_type		= &crypto_ablkcipher_type,
	.cra_module		= THIS_MODULE,
	.cra_init		= ablk_init,
	.cra_exit		= ablk_exit,
	.cra_u = {
		.ablkcipher = {
			.min_keysize	= SERPENT_MIN_KEY_SIZE +
					  SERPENT_BLOCK_SIZE,
			.max_keysize	= SERPENT_MAX_KEY_SIZE +
					  SERPENT_BLOCK_SIZE,
			.ivsize		= SERPENT_BLOCK_SIZE,
			.setkey		= ablk_set_key,
			.encrypt	= ablk_encrypt,
			.decrypt	= ablk_decrypt,
		},
	},
}, {
	.cra_name		= "xts(serpent)",
	.cra_driver_name	= "xts-serpent-avx",
	.cra_priority		= 500,
	.cra_flags		= CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
	.cra_blocksize		= SERPENT_BLOCK_SIZE,
	.cra_ctxsize		= sizeof(struct async_helper_ctx),
	.cra_alignmask		= 0,
	.cra_type		= &crypto_ablkcipher_type,
	.cra_module		= THIS_MODULE,
	.cra_init		= ablk_init,
	.cra_exit		= ablk_exit,
	.cra_u = {
		.ablkcipher = {
			.min_keysize	= SERPENT_MIN_KEY_SIZE * 2,
			.max_keysize	= SERPENT_MAX_KEY_SIZE * 2,
			.ivsize		= SERPENT_BLOCK_SIZE,
			.setkey		= ablk_set_key,
			.encrypt	= ablk_encrypt,
			.decrypt	= ablk_decrypt,
		},
	},
} };

static int __init serpent_init(void)
{
	u64 xcr0;

	if (!cpu_has_avx || !cpu_has_osxsave) {
		printk(KERN_INFO "AVX instructions are not detected.\n");
		return -ENODEV;
	}

	xcr0 = xgetbv(XCR_XFEATURE_ENABLED_MASK);
	if ((xcr0 & (XSTATE_SSE | XSTATE_YMM)) != (XSTATE_SSE | XSTATE_YMM)) {
		printk(KERN_INFO "AVX detected but unusable.\n");
		return -ENODEV;
	}

	return crypto_register_algs(serpent_algs, ARRAY_SIZE(serpent_algs));
}

static void __exit serpent_exit(void)
{
	crypto_unregister_algs(serpent_algs, ARRAY_SIZE(serpent_algs));
}

module_init(serpent_init);
module_exit(serpent_exit);

MODULE_DESCRIPTION("Serpent Cipher Algorithm, AVX optimized");
MODULE_LICENSE("GPL");
MODULE_ALIAS_CRYPTO("serpent");
Commit	Line	Data
7efe4076 JG	1	/*
	2	* Glue Code for AVX assembler versions of Serpent Cipher
	3	*
	4	* Copyright (C) 2012 Johannes Goetzfried
	5	* <Johannes.Goetzfried@informatik.stud.uni-erlangen.de>
	6	*
a05248ed	7	* Copyright © 2011-2013 Jussi Kivilinna <jussi.kivilinna@iki.fi>
7efe4076 JG	8	*
	9	* This program is free software; you can redistribute it and/or modify
	10	* it under the terms of the GNU General Public License as published by
	11	* the Free Software Foundation; either version 2 of the License, or
	12	* (at your option) any later version.
	13	*
	14	* This program is distributed in the hope that it will be useful,
	15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	* GNU General Public License for more details.
	18	*
	19	* You should have received a copy of the GNU General Public License
	20	* along with this program; if not, write to the Free Software
	21	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
	22	* USA
	23	*
	24	*/
	25
	26	#include <linux/module.h>
	27	#include <linux/hardirq.h>
	28	#include <linux/types.h>
	29	#include <linux/crypto.h>
	30	#include <linux/err.h>
801201aa	31	#include <crypto/ablk_helper.h>
7efe4076 JG	32	#include <crypto/algapi.h>
	33	#include <crypto/serpent.h>
	34	#include <crypto/cryptd.h>
	35	#include <crypto/b128ops.h>
	36	#include <crypto/ctr.h>
	37	#include <crypto/lrw.h>
	38	#include <crypto/xts.h>
7efe4076	39	#include <asm/xcr.h>
669ebabb	40	#include <asm/fpu/xstate.h>
d4af0e9d	41	#include <asm/crypto/serpent-avx.h>
1d0debbd	42	#include <asm/crypto/glue_helper.h>
7efe4076	43
56d76c96 JK	44	/* 8-way parallel cipher functions */
	45	asmlinkage void serpent_ecb_enc_8way_avx(struct serpent_ctx ctx, u8 dst,
	46	const u8 *src);
	47	EXPORT_SYMBOL_GPL(serpent_ecb_enc_8way_avx);
	48
	49	asmlinkage void serpent_ecb_dec_8way_avx(struct serpent_ctx ctx, u8 dst,
	50	const u8 *src);
	51	EXPORT_SYMBOL_GPL(serpent_ecb_dec_8way_avx);
	52
	53	asmlinkage void serpent_cbc_dec_8way_avx(struct serpent_ctx ctx, u8 dst,
	54	const u8 *src);
	55	EXPORT_SYMBOL_GPL(serpent_cbc_dec_8way_avx);
	56
	57	asmlinkage void serpent_ctr_8way_avx(struct serpent_ctx ctx, u8 dst,
	58	const u8 src, le128 iv);
	59	EXPORT_SYMBOL_GPL(serpent_ctr_8way_avx);
	60
	61	asmlinkage void serpent_xts_enc_8way_avx(struct serpent_ctx ctx, u8 dst,
	62	const u8 src, le128 iv);
	63	EXPORT_SYMBOL_GPL(serpent_xts_enc_8way_avx);
	64
	65	asmlinkage void serpent_xts_dec_8way_avx(struct serpent_ctx ctx, u8 dst,
	66	const u8 src, le128 iv);
	67	EXPORT_SYMBOL_GPL(serpent_xts_dec_8way_avx);
	68
	69	void __serpent_crypt_ctr(void ctx, u128 dst, const u128 src, le128 iv)
7efe4076	70	{
1d0debbd	71	be128 ctrblk;
7efe4076	72
58990986 JK	73	le128_to_be128(&ctrblk, iv);
58990986 JK	74	le128_inc(iv);
7efe4076	75
1d0debbd JK	76	__serpent_encrypt(ctx, (u8 )&ctrblk, (u8 )&ctrblk);
1d0debbd JK	77	u128_xor(dst, src, (u128 *)&ctrblk);
7efe4076	78	}
56d76c96	79	EXPORT_SYMBOL_GPL(__serpent_crypt_ctr);
7efe4076	80
56d76c96	81	void serpent_xts_enc(void ctx, u128 dst, const u128 src, le128 iv)
a05248ed JK	82	{
	83	glue_xts_crypt_128bit_one(ctx, dst, src, iv,
	84	GLUE_FUNC_CAST(__serpent_encrypt));
	85	}
56d76c96	86	EXPORT_SYMBOL_GPL(serpent_xts_enc);
a05248ed	87
56d76c96	88	void serpent_xts_dec(void ctx, u128 dst, const u128 src, le128 iv)
a05248ed JK	89	{
	90	glue_xts_crypt_128bit_one(ctx, dst, src, iv,
	91	GLUE_FUNC_CAST(__serpent_decrypt));
	92	}
56d76c96 JK	93	EXPORT_SYMBOL_GPL(serpent_xts_dec);
56d76c96 JK	94
a05248ed	95
1d0debbd JK	96	static const struct common_glue_ctx serpent_enc = {
	97	.num_funcs = 2,
	98	.fpu_blocks_limit = SERPENT_PARALLEL_BLOCKS,
7efe4076	99
1d0debbd JK	100	.funcs = { {
1d0debbd JK	101	.num_blocks = SERPENT_PARALLEL_BLOCKS,
facd416f	102	.fn_u = { .ecb = GLUE_FUNC_CAST(serpent_ecb_enc_8way_avx) }
1d0debbd JK	103	}, {
	104	.num_blocks = 1,
	105	.fn_u = { .ecb = GLUE_FUNC_CAST(__serpent_encrypt) }
	106	} }
	107	};
7efe4076	108
1d0debbd JK	109	static const struct common_glue_ctx serpent_ctr = {
	110	.num_funcs = 2,
	111	.fpu_blocks_limit = SERPENT_PARALLEL_BLOCKS,
	112
	113	.funcs = { {
	114	.num_blocks = SERPENT_PARALLEL_BLOCKS,
facd416f	115	.fn_u = { .ctr = GLUE_CTR_FUNC_CAST(serpent_ctr_8way_avx) }
1d0debbd JK	116	}, {
1d0debbd JK	117	.num_blocks = 1,
56d76c96	118	.fn_u = { .ctr = GLUE_CTR_FUNC_CAST(__serpent_crypt_ctr) }
1d0debbd JK	119	} }
1d0debbd JK	120	};
7efe4076	121
a05248ed JK	122	static const struct common_glue_ctx serpent_enc_xts = {
	123	.num_funcs = 2,
	124	.fpu_blocks_limit = SERPENT_PARALLEL_BLOCKS,
	125
	126	.funcs = { {
	127	.num_blocks = SERPENT_PARALLEL_BLOCKS,
	128	.fn_u = { .xts = GLUE_XTS_FUNC_CAST(serpent_xts_enc_8way_avx) }
	129	}, {
	130	.num_blocks = 1,
	131	.fn_u = { .xts = GLUE_XTS_FUNC_CAST(serpent_xts_enc) }
	132	} }
	133	};
	134
1d0debbd JK	135	static const struct common_glue_ctx serpent_dec = {
	136	.num_funcs = 2,
	137	.fpu_blocks_limit = SERPENT_PARALLEL_BLOCKS,
	138
	139	.funcs = { {
	140	.num_blocks = SERPENT_PARALLEL_BLOCKS,
facd416f	141	.fn_u = { .ecb = GLUE_FUNC_CAST(serpent_ecb_dec_8way_avx) }
1d0debbd JK	142	}, {
	143	.num_blocks = 1,
	144	.fn_u = { .ecb = GLUE_FUNC_CAST(__serpent_decrypt) }
	145	} }
	146	};
7efe4076	147
1d0debbd JK	148	static const struct common_glue_ctx serpent_dec_cbc = {
	149	.num_funcs = 2,
	150	.fpu_blocks_limit = SERPENT_PARALLEL_BLOCKS,
	151
	152	.funcs = { {
	153	.num_blocks = SERPENT_PARALLEL_BLOCKS,
facd416f	154	.fn_u = { .cbc = GLUE_CBC_FUNC_CAST(serpent_cbc_dec_8way_avx) }
1d0debbd JK	155	}, {
	156	.num_blocks = 1,
	157	.fn_u = { .cbc = GLUE_CBC_FUNC_CAST(__serpent_decrypt) }
	158	} }
	159	};
7efe4076	160
a05248ed JK	161	static const struct common_glue_ctx serpent_dec_xts = {
	162	.num_funcs = 2,
	163	.fpu_blocks_limit = SERPENT_PARALLEL_BLOCKS,
	164
	165	.funcs = { {
	166	.num_blocks = SERPENT_PARALLEL_BLOCKS,
	167	.fn_u = { .xts = GLUE_XTS_FUNC_CAST(serpent_xts_dec_8way_avx) }
	168	}, {
	169	.num_blocks = 1,
	170	.fn_u = { .xts = GLUE_XTS_FUNC_CAST(serpent_xts_dec) }
	171	} }
	172	};
	173
1d0debbd	174	static int ecb_encrypt(struct blkcipher_desc desc, struct scatterlist dst,
7efe4076 JG	175	struct scatterlist *src, unsigned int nbytes)
7efe4076 JG	176	{
1d0debbd	177	return glue_ecb_crypt_128bit(&serpent_enc, desc, dst, src, nbytes);
7efe4076 JG	178	}
7efe4076 JG	179
1d0debbd JK	180	static int ecb_decrypt(struct blkcipher_desc desc, struct scatterlist dst,
1d0debbd JK	181	struct scatterlist *src, unsigned int nbytes)
7efe4076	182	{
1d0debbd	183	return glue_ecb_crypt_128bit(&serpent_dec, desc, dst, src, nbytes);
7efe4076 JG	184	}
7efe4076 JG	185
1d0debbd JK	186	static int cbc_encrypt(struct blkcipher_desc desc, struct scatterlist dst,
1d0debbd JK	187	struct scatterlist *src, unsigned int nbytes)
7efe4076	188	{
1d0debbd JK	189	return glue_cbc_encrypt_128bit(GLUE_FUNC_CAST(__serpent_encrypt), desc,
1d0debbd JK	190	dst, src, nbytes);
7efe4076 JG	191	}
7efe4076 JG	192
1d0debbd JK	193	static int cbc_decrypt(struct blkcipher_desc desc, struct scatterlist dst,
1d0debbd JK	194	struct scatterlist *src, unsigned int nbytes)
7efe4076	195	{
1d0debbd JK	196	return glue_cbc_decrypt_128bit(&serpent_dec_cbc, desc, dst, src,
1d0debbd JK	197	nbytes);
7efe4076 JG	198	}
7efe4076 JG	199
1d0debbd JK	200	static int ctr_crypt(struct blkcipher_desc desc, struct scatterlist dst,
1d0debbd JK	201	struct scatterlist *src, unsigned int nbytes)
7efe4076	202	{
1d0debbd	203	return glue_ctr_crypt_128bit(&serpent_ctr, desc, dst, src, nbytes);
7efe4076 JG	204	}
7efe4076 JG	205
1d0debbd	206	static inline bool serpent_fpu_begin(bool fpu_enabled, unsigned int nbytes)
7efe4076	207	{
1d0debbd JK	208	return glue_fpu_begin(SERPENT_BLOCK_SIZE, SERPENT_PARALLEL_BLOCKS,
1d0debbd JK	209	NULL, fpu_enabled, nbytes);
7efe4076 JG	210	}
7efe4076 JG	211
1d0debbd	212	static inline void serpent_fpu_end(bool fpu_enabled)
7efe4076	213	{
1d0debbd	214	glue_fpu_end(fpu_enabled);
7efe4076 JG	215	}
	216
	217	struct crypt_priv {
	218	struct serpent_ctx *ctx;
	219	bool fpu_enabled;
	220	};
	221
	222	static void encrypt_callback(void priv, u8 srcdst, unsigned int nbytes)
	223	{
	224	const unsigned int bsize = SERPENT_BLOCK_SIZE;
	225	struct crypt_priv *ctx = priv;
	226	int i;
	227
	228	ctx->fpu_enabled = serpent_fpu_begin(ctx->fpu_enabled, nbytes);
	229
	230	if (nbytes == bsize * SERPENT_PARALLEL_BLOCKS) {
facd416f	231	serpent_ecb_enc_8way_avx(ctx->ctx, srcdst, srcdst);
7efe4076 JG	232	return;
	233	}
	234
	235	for (i = 0; i < nbytes / bsize; i++, srcdst += bsize)
	236	__serpent_encrypt(ctx->ctx, srcdst, srcdst);
	237	}
	238
	239	static void decrypt_callback(void priv, u8 srcdst, unsigned int nbytes)
	240	{
	241	const unsigned int bsize = SERPENT_BLOCK_SIZE;
	242	struct crypt_priv *ctx = priv;
	243	int i;
	244
	245	ctx->fpu_enabled = serpent_fpu_begin(ctx->fpu_enabled, nbytes);
	246
	247	if (nbytes == bsize * SERPENT_PARALLEL_BLOCKS) {
facd416f	248	serpent_ecb_dec_8way_avx(ctx->ctx, srcdst, srcdst);
7efe4076 JG	249	return;
	250	}
	251
	252	for (i = 0; i < nbytes / bsize; i++, srcdst += bsize)
	253	__serpent_decrypt(ctx->ctx, srcdst, srcdst);
	254	}
	255
56d76c96 JK	256	int lrw_serpent_setkey(struct crypto_tfm tfm, const u8 key,
56d76c96 JK	257	unsigned int keylen)
7efe4076 JG	258	{
	259	struct serpent_lrw_ctx *ctx = crypto_tfm_ctx(tfm);
	260	int err;
	261
	262	err = __serpent_setkey(&ctx->serpent_ctx, key, keylen -
	263	SERPENT_BLOCK_SIZE);
	264	if (err)
	265	return err;
	266
	267	return lrw_init_table(&ctx->lrw_table, key + keylen -
	268	SERPENT_BLOCK_SIZE);
	269	}
56d76c96	270	EXPORT_SYMBOL_GPL(lrw_serpent_setkey);
7efe4076 JG	271
	272	static int lrw_encrypt(struct blkcipher_desc desc, struct scatterlist dst,
	273	struct scatterlist *src, unsigned int nbytes)
	274	{
	275	struct serpent_lrw_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
	276	be128 buf[SERPENT_PARALLEL_BLOCKS];
	277	struct crypt_priv crypt_ctx = {
	278	.ctx = &ctx->serpent_ctx,
	279	.fpu_enabled = false,
	280	};
	281	struct lrw_crypt_req req = {
	282	.tbuf = buf,
	283	.tbuflen = sizeof(buf),
	284
	285	.table_ctx = &ctx->lrw_table,
	286	.crypt_ctx = &crypt_ctx,
	287	.crypt_fn = encrypt_callback,
	288	};
	289	int ret;
	290
	291	desc->flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP;
	292	ret = lrw_crypt(desc, dst, src, nbytes, &req);
	293	serpent_fpu_end(crypt_ctx.fpu_enabled);
	294
	295	return ret;
	296	}
	297
	298	static int lrw_decrypt(struct blkcipher_desc desc, struct scatterlist dst,
	299	struct scatterlist *src, unsigned int nbytes)
	300	{
	301	struct serpent_lrw_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
	302	be128 buf[SERPENT_PARALLEL_BLOCKS];
	303	struct crypt_priv crypt_ctx = {
	304	.ctx = &ctx->serpent_ctx,
	305	.fpu_enabled = false,
	306	};
	307	struct lrw_crypt_req req = {
	308	.tbuf = buf,
	309	.tbuflen = sizeof(buf),
	310
	311	.table_ctx = &ctx->lrw_table,
	312	.crypt_ctx = &crypt_ctx,
	313	.crypt_fn = decrypt_callback,
	314	};
	315	int ret;
	316
	317	desc->flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP;
	318	ret = lrw_crypt(desc, dst, src, nbytes, &req);
	319	serpent_fpu_end(crypt_ctx.fpu_enabled);
	320
	321	return ret;
	322	}
	323
56d76c96	324	void lrw_serpent_exit_tfm(struct crypto_tfm *tfm)
7efe4076 JG	325	{
	326	struct serpent_lrw_ctx *ctx = crypto_tfm_ctx(tfm);
	327
	328	lrw_free_table(&ctx->lrw_table);
	329	}
56d76c96	330	EXPORT_SYMBOL_GPL(lrw_serpent_exit_tfm);
7efe4076	331
56d76c96 JK	332	int xts_serpent_setkey(struct crypto_tfm tfm, const u8 key,
56d76c96 JK	333	unsigned int keylen)
7efe4076 JG	334	{
	335	struct serpent_xts_ctx *ctx = crypto_tfm_ctx(tfm);
	336	u32 *flags = &tfm->crt_flags;
	337	int err;
	338
	339	/* key consists of keys of equal size concatenated, therefore
	340	* the length must be even
	341	*/
	342	if (keylen % 2) {
	343	*flags \|= CRYPTO_TFM_RES_BAD_KEY_LEN;
	344	return -EINVAL;
	345	}
	346
	347	/* first half of xts-key is for crypt */
	348	err = __serpent_setkey(&ctx->crypt_ctx, key, keylen / 2);
	349	if (err)
	350	return err;
	351
	352	/* second half of xts-key is for tweak */
	353	return __serpent_setkey(&ctx->tweak_ctx, key + keylen / 2, keylen / 2);
	354	}
56d76c96	355	EXPORT_SYMBOL_GPL(xts_serpent_setkey);
7efe4076 JG	356
	357	static int xts_encrypt(struct blkcipher_desc desc, struct scatterlist dst,
	358	struct scatterlist *src, unsigned int nbytes)
	359	{
	360	struct serpent_xts_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
7efe4076	361
a05248ed JK	362	return glue_xts_crypt_128bit(&serpent_enc_xts, desc, dst, src, nbytes,
	363	XTS_TWEAK_CAST(__serpent_encrypt),
	364	&ctx->tweak_ctx, &ctx->crypt_ctx);
7efe4076 JG	365	}
	366
	367	static int xts_decrypt(struct blkcipher_desc desc, struct scatterlist dst,
	368	struct scatterlist *src, unsigned int nbytes)
	369	{
	370	struct serpent_xts_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
7efe4076	371
a05248ed JK	372	return glue_xts_crypt_128bit(&serpent_dec_xts, desc, dst, src, nbytes,
	373	XTS_TWEAK_CAST(__serpent_encrypt),
	374	&ctx->tweak_ctx, &ctx->crypt_ctx);
7efe4076 JG	375	}
7efe4076 JG	376
7efe4076 JG	377	static struct crypto_alg serpent_algs[10] = { {
	378	.cra_name = "__ecb-serpent-avx",
	379	.cra_driver_name = "__driver-ecb-serpent-avx",
	380	.cra_priority = 0,
65aed539 SM	381	.cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER \|
65aed539 SM	382	CRYPTO_ALG_INTERNAL,
7efe4076 JG	383	.cra_blocksize = SERPENT_BLOCK_SIZE,
	384	.cra_ctxsize = sizeof(struct serpent_ctx),
	385	.cra_alignmask = 0,
	386	.cra_type = &crypto_blkcipher_type,
	387	.cra_module = THIS_MODULE,
7efe4076 JG	388	.cra_u = {
	389	.blkcipher = {
	390	.min_keysize = SERPENT_MIN_KEY_SIZE,
	391	.max_keysize = SERPENT_MAX_KEY_SIZE,
	392	.setkey = serpent_setkey,
	393	.encrypt = ecb_encrypt,
	394	.decrypt = ecb_decrypt,
	395	},
	396	},
	397	}, {
	398	.cra_name = "__cbc-serpent-avx",
	399	.cra_driver_name = "__driver-cbc-serpent-avx",
	400	.cra_priority = 0,
65aed539 SM	401	.cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER \|
65aed539 SM	402	CRYPTO_ALG_INTERNAL,
7efe4076 JG	403	.cra_blocksize = SERPENT_BLOCK_SIZE,
	404	.cra_ctxsize = sizeof(struct serpent_ctx),
	405	.cra_alignmask = 0,
	406	.cra_type = &crypto_blkcipher_type,
	407	.cra_module = THIS_MODULE,
7efe4076 JG	408	.cra_u = {
	409	.blkcipher = {
	410	.min_keysize = SERPENT_MIN_KEY_SIZE,
	411	.max_keysize = SERPENT_MAX_KEY_SIZE,
	412	.setkey = serpent_setkey,
	413	.encrypt = cbc_encrypt,
	414	.decrypt = cbc_decrypt,
	415	},
	416	},
	417	}, {
	418	.cra_name = "__ctr-serpent-avx",
	419	.cra_driver_name = "__driver-ctr-serpent-avx",
	420	.cra_priority = 0,
65aed539 SM	421	.cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER \|
65aed539 SM	422	CRYPTO_ALG_INTERNAL,
7efe4076 JG	423	.cra_blocksize = 1,
	424	.cra_ctxsize = sizeof(struct serpent_ctx),
	425	.cra_alignmask = 0,
	426	.cra_type = &crypto_blkcipher_type,
	427	.cra_module = THIS_MODULE,
7efe4076 JG	428	.cra_u = {
	429	.blkcipher = {
	430	.min_keysize = SERPENT_MIN_KEY_SIZE,
	431	.max_keysize = SERPENT_MAX_KEY_SIZE,
	432	.ivsize = SERPENT_BLOCK_SIZE,
	433	.setkey = serpent_setkey,
	434	.encrypt = ctr_crypt,
	435	.decrypt = ctr_crypt,
	436	},
	437	},
	438	}, {
	439	.cra_name = "__lrw-serpent-avx",
	440	.cra_driver_name = "__driver-lrw-serpent-avx",
	441	.cra_priority = 0,
65aed539 SM	442	.cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER \|
65aed539 SM	443	CRYPTO_ALG_INTERNAL,
7efe4076 JG	444	.cra_blocksize = SERPENT_BLOCK_SIZE,
	445	.cra_ctxsize = sizeof(struct serpent_lrw_ctx),
	446	.cra_alignmask = 0,
	447	.cra_type = &crypto_blkcipher_type,
	448	.cra_module = THIS_MODULE,
56d76c96	449	.cra_exit = lrw_serpent_exit_tfm,
7efe4076 JG	450	.cra_u = {
	451	.blkcipher = {
	452	.min_keysize = SERPENT_MIN_KEY_SIZE +
	453	SERPENT_BLOCK_SIZE,
	454	.max_keysize = SERPENT_MAX_KEY_SIZE +
	455	SERPENT_BLOCK_SIZE,
	456	.ivsize = SERPENT_BLOCK_SIZE,
	457	.setkey = lrw_serpent_setkey,
	458	.encrypt = lrw_encrypt,
	459	.decrypt = lrw_decrypt,
	460	},
	461	},
	462	}, {
	463	.cra_name = "__xts-serpent-avx",
	464	.cra_driver_name = "__driver-xts-serpent-avx",
	465	.cra_priority = 0,
65aed539 SM	466	.cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER \|
65aed539 SM	467	CRYPTO_ALG_INTERNAL,
7efe4076 JG	468	.cra_blocksize = SERPENT_BLOCK_SIZE,
	469	.cra_ctxsize = sizeof(struct serpent_xts_ctx),
	470	.cra_alignmask = 0,
	471	.cra_type = &crypto_blkcipher_type,
	472	.cra_module = THIS_MODULE,
7efe4076 JG	473	.cra_u = {
	474	.blkcipher = {
	475	.min_keysize = SERPENT_MIN_KEY_SIZE * 2,
	476	.max_keysize = SERPENT_MAX_KEY_SIZE * 2,
	477	.ivsize = SERPENT_BLOCK_SIZE,
	478	.setkey = xts_serpent_setkey,
	479	.encrypt = xts_encrypt,
	480	.decrypt = xts_decrypt,
	481	},
	482	},
	483	}, {
	484	.cra_name = "ecb(serpent)",
	485	.cra_driver_name = "ecb-serpent-avx",
	486	.cra_priority = 500,
	487	.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER \| CRYPTO_ALG_ASYNC,
	488	.cra_blocksize = SERPENT_BLOCK_SIZE,
ffaf9156	489	.cra_ctxsize = sizeof(struct async_helper_ctx),
7efe4076 JG	490	.cra_alignmask = 0,
	491	.cra_type = &crypto_ablkcipher_type,
	492	.cra_module = THIS_MODULE,
7efe4076 JG	493	.cra_init = ablk_init,
	494	.cra_exit = ablk_exit,
	495	.cra_u = {
	496	.ablkcipher = {
	497	.min_keysize = SERPENT_MIN_KEY_SIZE,
	498	.max_keysize = SERPENT_MAX_KEY_SIZE,
	499	.setkey = ablk_set_key,
	500	.encrypt = ablk_encrypt,
	501	.decrypt = ablk_decrypt,
	502	},
	503	},
	504	}, {
	505	.cra_name = "cbc(serpent)",
	506	.cra_driver_name = "cbc-serpent-avx",
	507	.cra_priority = 500,
	508	.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER \| CRYPTO_ALG_ASYNC,
	509	.cra_blocksize = SERPENT_BLOCK_SIZE,
ffaf9156	510	.cra_ctxsize = sizeof(struct async_helper_ctx),
7efe4076 JG	511	.cra_alignmask = 0,
	512	.cra_type = &crypto_ablkcipher_type,
	513	.cra_module = THIS_MODULE,
7efe4076 JG	514	.cra_init = ablk_init,
	515	.cra_exit = ablk_exit,
	516	.cra_u = {
	517	.ablkcipher = {
	518	.min_keysize = SERPENT_MIN_KEY_SIZE,
	519	.max_keysize = SERPENT_MAX_KEY_SIZE,
	520	.ivsize = SERPENT_BLOCK_SIZE,
	521	.setkey = ablk_set_key,
	522	.encrypt = __ablk_encrypt,
	523	.decrypt = ablk_decrypt,
	524	},
	525	},
	526	}, {
	527	.cra_name = "ctr(serpent)",
	528	.cra_driver_name = "ctr-serpent-avx",
	529	.cra_priority = 500,
	530	.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER \| CRYPTO_ALG_ASYNC,
	531	.cra_blocksize = 1,
ffaf9156	532	.cra_ctxsize = sizeof(struct async_helper_ctx),
7efe4076 JG	533	.cra_alignmask = 0,
	534	.cra_type = &crypto_ablkcipher_type,
	535	.cra_module = THIS_MODULE,
7efe4076 JG	536	.cra_init = ablk_init,
	537	.cra_exit = ablk_exit,
	538	.cra_u = {
	539	.ablkcipher = {
	540	.min_keysize = SERPENT_MIN_KEY_SIZE,
	541	.max_keysize = SERPENT_MAX_KEY_SIZE,
	542	.ivsize = SERPENT_BLOCK_SIZE,
	543	.setkey = ablk_set_key,
	544	.encrypt = ablk_encrypt,
	545	.decrypt = ablk_encrypt,
	546	.geniv = "chainiv",
	547	},
	548	},
	549	}, {
	550	.cra_name = "lrw(serpent)",
	551	.cra_driver_name = "lrw-serpent-avx",
	552	.cra_priority = 500,
	553	.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER \| CRYPTO_ALG_ASYNC,
	554	.cra_blocksize = SERPENT_BLOCK_SIZE,
ffaf9156	555	.cra_ctxsize = sizeof(struct async_helper_ctx),
7efe4076 JG	556	.cra_alignmask = 0,
	557	.cra_type = &crypto_ablkcipher_type,
	558	.cra_module = THIS_MODULE,
7efe4076 JG	559	.cra_init = ablk_init,
	560	.cra_exit = ablk_exit,
	561	.cra_u = {
	562	.ablkcipher = {
	563	.min_keysize = SERPENT_MIN_KEY_SIZE +
	564	SERPENT_BLOCK_SIZE,
	565	.max_keysize = SERPENT_MAX_KEY_SIZE +
	566	SERPENT_BLOCK_SIZE,
	567	.ivsize = SERPENT_BLOCK_SIZE,
	568	.setkey = ablk_set_key,
	569	.encrypt = ablk_encrypt,
	570	.decrypt = ablk_decrypt,
	571	},
	572	},
	573	}, {
	574	.cra_name = "xts(serpent)",
	575	.cra_driver_name = "xts-serpent-avx",
	576	.cra_priority = 500,
	577	.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER \| CRYPTO_ALG_ASYNC,
	578	.cra_blocksize = SERPENT_BLOCK_SIZE,
ffaf9156	579	.cra_ctxsize = sizeof(struct async_helper_ctx),
7efe4076 JG	580	.cra_alignmask = 0,
	581	.cra_type = &crypto_ablkcipher_type,
	582	.cra_module = THIS_MODULE,
7efe4076 JG	583	.cra_init = ablk_init,
	584	.cra_exit = ablk_exit,
	585	.cra_u = {
	586	.ablkcipher = {
	587	.min_keysize = SERPENT_MIN_KEY_SIZE * 2,
	588	.max_keysize = SERPENT_MAX_KEY_SIZE * 2,
	589	.ivsize = SERPENT_BLOCK_SIZE,
	590	.setkey = ablk_set_key,
	591	.encrypt = ablk_encrypt,
	592	.decrypt = ablk_decrypt,
	593	},
	594	},
	595	} };
	596
	597	static int __init serpent_init(void)
	598	{
	599	u64 xcr0;
	600
	601	if (!cpu_has_avx \|\| !cpu_has_osxsave) {
	602	printk(KERN_INFO "AVX instructions are not detected.\n");
	603	return -ENODEV;
	604	}
	605
	606	xcr0 = xgetbv(XCR_XFEATURE_ENABLED_MASK);
	607	if ((xcr0 & (XSTATE_SSE \| XSTATE_YMM)) != (XSTATE_SSE \| XSTATE_YMM)) {
	608	printk(KERN_INFO "AVX detected but unusable.\n");
	609	return -ENODEV;
	610	}
	611
	612	return crypto_register_algs(serpent_algs, ARRAY_SIZE(serpent_algs));
	613	}
	614
	615	static void __exit serpent_exit(void)
	616	{
	617	crypto_unregister_algs(serpent_algs, ARRAY_SIZE(serpent_algs));
	618	}
	619
	620	module_init(serpent_init);
	621	module_exit(serpent_exit);
	622
	623	MODULE_DESCRIPTION("Serpent Cipher Algorithm, AVX optimized");
	624	MODULE_LICENSE("GPL");
5d26a105	625	MODULE_ALIAS_CRYPTO("serpent");