Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
torvalds
GitHub Repository: torvalds/linux
 Path: blob/master/arch/x86/crypto/camellia_aesni_avx_glue.c
26442 views
1
// SPDX-License-Identifier: GPL-2.0-or-later

2
/*

3
 * Glue Code for x86_64/AVX/AES-NI assembler optimized version of Camellia

4
 *

5
 * Copyright © 2012-2013 Jussi Kivilinna <[email protected]>

6
 */

7


8
#include <crypto/algapi.h>

9
#include <linux/crypto.h>

10
#include <linux/err.h>

11
#include <linux/export.h>

12
#include <linux/module.h>

13
#include <linux/types.h>

14


15
#include "camellia.h"

16
#include "ecb_cbc_helpers.h"

17


18
#define CAMELLIA_AESNI_PARALLEL_BLOCKS 16

19


20
/* 16-way parallel cipher functions (avx/aes-ni) */

21
asmlinkage void camellia_ecb_enc_16way(const void *ctx, u8 *dst, const u8 *src);

22
EXPORT_SYMBOL_GPL(camellia_ecb_enc_16way);

23


24
asmlinkage void camellia_ecb_dec_16way(const void *ctx, u8 *dst, const u8 *src);

25
EXPORT_SYMBOL_GPL(camellia_ecb_dec_16way);

26


27
asmlinkage void camellia_cbc_dec_16way(const void *ctx, u8 *dst, const u8 *src);

28
EXPORT_SYMBOL_GPL(camellia_cbc_dec_16way);

29


30
static int camellia_setkey(struct crypto_skcipher *tfm, const u8 *key,

31
			   unsigned int keylen)

32
{

33
	return __camellia_setkey(crypto_skcipher_ctx(tfm), key, keylen);

34
}

35


36
static int ecb_encrypt(struct skcipher_request *req)

37
{

38
	ECB_WALK_START(req, CAMELLIA_BLOCK_SIZE, CAMELLIA_AESNI_PARALLEL_BLOCKS);

39
	ECB_BLOCK(CAMELLIA_AESNI_PARALLEL_BLOCKS, camellia_ecb_enc_16way);

40
	ECB_BLOCK(2, camellia_enc_blk_2way);

41
	ECB_BLOCK(1, camellia_enc_blk);

42
	ECB_WALK_END();

43
}

44


45
static int ecb_decrypt(struct skcipher_request *req)

46
{

47
	ECB_WALK_START(req, CAMELLIA_BLOCK_SIZE, CAMELLIA_AESNI_PARALLEL_BLOCKS);

48
	ECB_BLOCK(CAMELLIA_AESNI_PARALLEL_BLOCKS, camellia_ecb_dec_16way);

49
	ECB_BLOCK(2, camellia_dec_blk_2way);

50
	ECB_BLOCK(1, camellia_dec_blk);

51
	ECB_WALK_END();

52
}

53


54
static int cbc_encrypt(struct skcipher_request *req)

55
{

56
	CBC_WALK_START(req, CAMELLIA_BLOCK_SIZE, -1);

57
	CBC_ENC_BLOCK(camellia_enc_blk);

58
	CBC_WALK_END();

59
}

60


61
static int cbc_decrypt(struct skcipher_request *req)

62
{

63
	CBC_WALK_START(req, CAMELLIA_BLOCK_SIZE, CAMELLIA_AESNI_PARALLEL_BLOCKS);

64
	CBC_DEC_BLOCK(CAMELLIA_AESNI_PARALLEL_BLOCKS, camellia_cbc_dec_16way);

65
	CBC_DEC_BLOCK(2, camellia_decrypt_cbc_2way);

66
	CBC_DEC_BLOCK(1, camellia_dec_blk);

67
	CBC_WALK_END();

68
}

69


70
static struct skcipher_alg camellia_algs[] = {

71
	{

72
		.base.cra_name		= "ecb(camellia)",

73
		.base.cra_driver_name	= "ecb-camellia-aesni",

74
		.base.cra_priority	= 400,

75
		.base.cra_blocksize	= CAMELLIA_BLOCK_SIZE,

76
		.base.cra_ctxsize	= sizeof(struct camellia_ctx),

77
		.base.cra_module	= THIS_MODULE,

78
		.min_keysize		= CAMELLIA_MIN_KEY_SIZE,

79
		.max_keysize		= CAMELLIA_MAX_KEY_SIZE,

80
		.setkey			= camellia_setkey,

81
		.encrypt		= ecb_encrypt,

82
		.decrypt		= ecb_decrypt,

83
	}, {

84
		.base.cra_name		= "cbc(camellia)",

85
		.base.cra_driver_name	= "cbc-camellia-aesni",

86
		.base.cra_priority	= 400,

87
		.base.cra_blocksize	= CAMELLIA_BLOCK_SIZE,

88
		.base.cra_ctxsize	= sizeof(struct camellia_ctx),

89
		.base.cra_module	= THIS_MODULE,

90
		.min_keysize		= CAMELLIA_MIN_KEY_SIZE,

91
		.max_keysize		= CAMELLIA_MAX_KEY_SIZE,

92
		.ivsize			= CAMELLIA_BLOCK_SIZE,

93
		.setkey			= camellia_setkey,

94
		.encrypt		= cbc_encrypt,

95
		.decrypt		= cbc_decrypt,

96
	}

97
};

98


99
static int __init camellia_aesni_init(void)

100
{

101
	const char *feature_name;

102


103
	if (!boot_cpu_has(X86_FEATURE_AVX) ||

104
	    !boot_cpu_has(X86_FEATURE_AES) ||

105
	    !boot_cpu_has(X86_FEATURE_OSXSAVE)) {

106
		pr_info("AVX or AES-NI instructions are not detected.\n");

107
		return -ENODEV;

108
	}

109


110
	if (!cpu_has_xfeatures(XFEATURE_MASK_SSE | XFEATURE_MASK_YMM,

111
				&feature_name)) {

112
		pr_info("CPU feature '%s' is not supported.\n", feature_name);

113
		return -ENODEV;

114
	}

115


116
	return crypto_register_skciphers(camellia_algs,

117
					 ARRAY_SIZE(camellia_algs));

118
}

119


120
static void __exit camellia_aesni_fini(void)

121
{

122
	crypto_unregister_skciphers(camellia_algs, ARRAY_SIZE(camellia_algs));

123
}

124


125
module_init(camellia_aesni_init);

126
module_exit(camellia_aesni_fini);

127


128
MODULE_LICENSE("GPL");

129
MODULE_DESCRIPTION("Camellia Cipher Algorithm, AES-NI/AVX optimized");

130
MODULE_ALIAS_CRYPTO("camellia");

131
MODULE_ALIAS_CRYPTO("camellia-asm");

132


133