[deliverable/linux.git] / arch / arm64 / crypto / sha2-ce-glue.c

/*
 * sha2-ce-glue.c - SHA-224/SHA-256 using ARMv8 Crypto Extensions
 *
 * Copyright (C) 2014 Linaro Ltd <ard.biesheuvel@linaro.org>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <asm/neon.h>
#include <asm/unaligned.h>
#include <crypto/internal/hash.h>
#include <crypto/sha.h>
#include <crypto/sha256_base.h>
#include <linux/cpufeature.h>
#include <linux/crypto.h>
#include <linux/module.h>

#define ASM_EXPORT(sym, val) \
	asm(".globl " #sym "; .set " #sym ", %0" :: "I"(val));

MODULE_DESCRIPTION("SHA-224/SHA-256 secure hash using ARMv8 Crypto Extensions");
MODULE_AUTHOR("Ard Biesheuvel <ard.biesheuvel@linaro.org>");
MODULE_LICENSE("GPL v2");

struct sha256_ce_state {
	struct sha256_state	sst;
	u32			finalize;
};

asmlinkage void sha2_ce_transform(struct sha256_ce_state *sst, u8 const *src,
				  int blocks);

static int sha256_ce_update(struct shash_desc *desc, const u8 *data,
			    unsigned int len)
{
	struct sha256_ce_state *sctx = shash_desc_ctx(desc);

	sctx->finalize = 0;
	kernel_neon_begin_partial(28);
	sha256_base_do_update(desc, data, len,
			      (sha256_block_fn *)sha2_ce_transform);
	kernel_neon_end();

	return 0;
}

static int sha256_ce_finup(struct shash_desc *desc, const u8 *data,
			   unsigned int len, u8 *out)
{
	struct sha256_ce_state *sctx = shash_desc_ctx(desc);
	bool finalize = !sctx->sst.count && !(len % SHA256_BLOCK_SIZE);

	ASM_EXPORT(sha256_ce_offsetof_count,
		   offsetof(struct sha256_ce_state, sst.count));
	ASM_EXPORT(sha256_ce_offsetof_finalize,
		   offsetof(struct sha256_ce_state, finalize));

	/*
	 * Allow the asm code to perform the finalization if there is no
	 * partial data and the input is a round multiple of the block size.
	 */
	sctx->finalize = finalize;

	kernel_neon_begin_partial(28);
	sha256_base_do_update(desc, data, len,
			      (sha256_block_fn *)sha2_ce_transform);
	if (!finalize)
		sha256_base_do_finalize(desc,
					(sha256_block_fn *)sha2_ce_transform);
	kernel_neon_end();
	return sha256_base_finish(desc, out);
}

static int sha256_ce_final(struct shash_desc *desc, u8 *out)
{
	struct sha256_ce_state *sctx = shash_desc_ctx(desc);

	sctx->finalize = 0;
	kernel_neon_begin_partial(28);
	sha256_base_do_finalize(desc, (sha256_block_fn *)sha2_ce_transform);
	kernel_neon_end();
	return sha256_base_finish(desc, out);
}

static struct shash_alg algs[] = { {
	.init			= sha224_base_init,
	.update			= sha256_ce_update,
	.final			= sha256_ce_final,
	.finup			= sha256_ce_finup,
	.descsize		= sizeof(struct sha256_ce_state),
	.digestsize		= SHA224_DIGEST_SIZE,
	.base			= {
		.cra_name		= "sha224",
		.cra_driver_name	= "sha224-ce",
		.cra_priority		= 200,
		.cra_flags		= CRYPTO_ALG_TYPE_SHASH,
		.cra_blocksize		= SHA256_BLOCK_SIZE,
		.cra_module		= THIS_MODULE,
	}
}, {
	.init			= sha256_base_init,
	.update			= sha256_ce_update,
	.final			= sha256_ce_final,
	.finup			= sha256_ce_finup,
	.descsize		= sizeof(struct sha256_ce_state),
	.digestsize		= SHA256_DIGEST_SIZE,
	.base			= {
		.cra_name		= "sha256",
		.cra_driver_name	= "sha256-ce",
		.cra_priority		= 200,
		.cra_flags		= CRYPTO_ALG_TYPE_SHASH,
		.cra_blocksize		= SHA256_BLOCK_SIZE,
		.cra_module		= THIS_MODULE,
	}
} };

static int __init sha2_ce_mod_init(void)
{
	return crypto_register_shashes(algs, ARRAY_SIZE(algs));
}

static void __exit sha2_ce_mod_fini(void)
{
	crypto_unregister_shashes(algs, ARRAY_SIZE(algs));
}

module_cpu_feature_match(SHA2, sha2_ce_mod_init);
module_exit(sha2_ce_mod_fini);
Commit	Line	Data
6ba6c74d AB	1	/*
	2	* sha2-ce-glue.c - SHA-224/SHA-256 using ARMv8 Crypto Extensions
	3	*
	4	* Copyright (C) 2014 Linaro Ltd <ard.biesheuvel@linaro.org>
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License version 2 as
	8	* published by the Free Software Foundation.
	9	*/
	10
	11	#include <asm/neon.h>
	12	#include <asm/unaligned.h>
	13	#include <crypto/internal/hash.h>
	14	#include <crypto/sha.h>
03802f6a	15	#include <crypto/sha256_base.h>
6ba6c74d AB	16	#include <linux/cpufeature.h>
	17	#include <linux/crypto.h>
	18	#include <linux/module.h>
	19
03802f6a AB	20	#define ASM_EXPORT(sym, val) \
	21	asm(".globl " #sym "; .set " #sym ", %0" :: "I"(val));
	22
6ba6c74d AB	23	MODULE_DESCRIPTION("SHA-224/SHA-256 secure hash using ARMv8 Crypto Extensions");
	24	MODULE_AUTHOR("Ard Biesheuvel <ard.biesheuvel@linaro.org>");
	25	MODULE_LICENSE("GPL v2");
	26
03802f6a AB	27	struct sha256_ce_state {
	28	struct sha256_state sst;
	29	u32 finalize;
	30	};
6ba6c74d	31
03802f6a AB	32	asmlinkage void sha2_ce_transform(struct sha256_ce_state sst, u8 const src,
03802f6a AB	33	int blocks);
6ba6c74d	34
03802f6a AB	35	static int sha256_ce_update(struct shash_desc desc, const u8 data,
03802f6a AB	36	unsigned int len)
6ba6c74d	37	{
03802f6a	38	struct sha256_ce_state *sctx = shash_desc_ctx(desc);
6ba6c74d	39
03802f6a AB	40	sctx->finalize = 0;
	41	kernel_neon_begin_partial(28);
	42	sha256_base_do_update(desc, data, len,
	43	(sha256_block_fn *)sha2_ce_transform);
	44	kernel_neon_end();
6ba6c74d	45
6ba6c74d AB	46	return 0;
	47	}
	48
03802f6a AB	49	static int sha256_ce_finup(struct shash_desc desc, const u8 data,
03802f6a AB	50	unsigned int len, u8 *out)
6ba6c74d	51	{
03802f6a AB	52	struct sha256_ce_state *sctx = shash_desc_ctx(desc);
03802f6a AB	53	bool finalize = !sctx->sst.count && !(len % SHA256_BLOCK_SIZE);
6ba6c74d	54
03802f6a AB	55	ASM_EXPORT(sha256_ce_offsetof_count,
	56	offsetof(struct sha256_ce_state, sst.count));
	57	ASM_EXPORT(sha256_ce_offsetof_finalize,
	58	offsetof(struct sha256_ce_state, finalize));
6ba6c74d AB	59
6ba6c74d AB	60	/*
03802f6a AB	61	* Allow the asm code to perform the finalization if there is no
03802f6a AB	62	* partial data and the input is a round multiple of the block size.
6ba6c74d	63	*/
03802f6a	64	sctx->finalize = finalize;
6ba6c74d AB	65
6ba6c74d AB	66	kernel_neon_begin_partial(28);
03802f6a AB	67	sha256_base_do_update(desc, data, len,
	68	(sha256_block_fn *)sha2_ce_transform);
	69	if (!finalize)
	70	sha256_base_do_finalize(desc,
	71	(sha256_block_fn *)sha2_ce_transform);
6ba6c74d	72	kernel_neon_end();
03802f6a	73	return sha256_base_finish(desc, out);
6ba6c74d AB	74	}
6ba6c74d AB	75
03802f6a	76	static int sha256_ce_final(struct shash_desc desc, u8 out)
6ba6c74d	77	{
ec59a65d AB	78	struct sha256_ce_state *sctx = shash_desc_ctx(desc);
	79
	80	sctx->finalize = 0;
03802f6a AB	81	kernel_neon_begin_partial(28);
	82	sha256_base_do_finalize(desc, (sha256_block_fn *)sha2_ce_transform);
	83	kernel_neon_end();
	84	return sha256_base_finish(desc, out);
6ba6c74d AB	85	}
	86
	87	static struct shash_alg algs[] = { {
03802f6a AB	88	.init = sha224_base_init,
	89	.update = sha256_ce_update,
	90	.final = sha256_ce_final,
	91	.finup = sha256_ce_finup,
	92	.descsize = sizeof(struct sha256_ce_state),
6ba6c74d	93	.digestsize = SHA224_DIGEST_SIZE,
6ba6c74d AB	94	.base = {
	95	.cra_name = "sha224",
	96	.cra_driver_name = "sha224-ce",
	97	.cra_priority = 200,
	98	.cra_flags = CRYPTO_ALG_TYPE_SHASH,
	99	.cra_blocksize = SHA256_BLOCK_SIZE,
	100	.cra_module = THIS_MODULE,
	101	}
	102	}, {
03802f6a AB	103	.init = sha256_base_init,
	104	.update = sha256_ce_update,
	105	.final = sha256_ce_final,
	106	.finup = sha256_ce_finup,
	107	.descsize = sizeof(struct sha256_ce_state),
6ba6c74d	108	.digestsize = SHA256_DIGEST_SIZE,
6ba6c74d AB	109	.base = {
	110	.cra_name = "sha256",
	111	.cra_driver_name = "sha256-ce",
	112	.cra_priority = 200,
	113	.cra_flags = CRYPTO_ALG_TYPE_SHASH,
	114	.cra_blocksize = SHA256_BLOCK_SIZE,
	115	.cra_module = THIS_MODULE,
	116	}
	117	} };
	118
	119	static int __init sha2_ce_mod_init(void)
	120	{
	121	return crypto_register_shashes(algs, ARRAY_SIZE(algs));
	122	}
	123
	124	static void __exit sha2_ce_mod_fini(void)
	125	{
	126	crypto_unregister_shashes(algs, ARRAY_SIZE(algs));
	127	}
	128
	129	module_cpu_feature_match(SHA2, sha2_ce_mod_init);
	130	module_exit(sha2_ce_mod_fini);