Commit aebe5bd7 authored by Tudor Ambarus's avatar Tudor Ambarus Committed by Herbert Xu
Browse files

crypto: atmel-{aes,sha,tdes} - Group common alg type init in dedicated methods 



Move common alg type init to dedicated methods.

Signed-off-by: default avatarTudor Ambarus <tudor.ambarus@microchip.com>
Signed-off-by: default avatarHerbert Xu <herbert@gondor.apana.org.au>
parent 7db15aad

drivers/crypto/atmel-aes.c

+18 −64
Original line number Diff line number Diff line
@@ -1288,12 +1288,8 @@ static struct skcipher_alg aes_algs[] = { 
{

	.base.cra_name		= "ecb(aes)",

	.base.cra_driver_name	= "atmel-ecb-aes",

	.base.cra_priority	= ATMEL_AES_PRIORITY,

	.base.cra_flags		= CRYPTO_ALG_ASYNC,

	.base.cra_blocksize	= AES_BLOCK_SIZE,

	.base.cra_ctxsize	= sizeof(struct atmel_aes_ctx),

	.base.cra_alignmask	= 0xf,

	.base.cra_module	= THIS_MODULE,



	.init			= atmel_aes_init_tfm,

	.min_keysize		= AES_MIN_KEY_SIZE,
@@ -1305,12 +1301,8 @@ static struct skcipher_alg aes_algs[] = { 
{

	.base.cra_name		= "cbc(aes)",

	.base.cra_driver_name	= "atmel-cbc-aes",

	.base.cra_priority	= ATMEL_AES_PRIORITY,

	.base.cra_flags		= CRYPTO_ALG_ASYNC,

	.base.cra_blocksize	= AES_BLOCK_SIZE,

	.base.cra_ctxsize	= sizeof(struct atmel_aes_ctx),

	.base.cra_alignmask	= 0xf,

	.base.cra_module	= THIS_MODULE,



	.init			= atmel_aes_init_tfm,

	.min_keysize		= AES_MIN_KEY_SIZE,
@@ -1323,12 +1315,8 @@ static struct skcipher_alg aes_algs[] = { 
{

	.base.cra_name		= "ofb(aes)",

	.base.cra_driver_name	= "atmel-ofb-aes",

	.base.cra_priority	= ATMEL_AES_PRIORITY,

	.base.cra_flags		= CRYPTO_ALG_ASYNC,

	.base.cra_blocksize	= AES_BLOCK_SIZE,

	.base.cra_ctxsize	= sizeof(struct atmel_aes_ctx),

	.base.cra_alignmask	= 0xf,

	.base.cra_module	= THIS_MODULE,



	.init			= atmel_aes_init_tfm,

	.min_keysize		= AES_MIN_KEY_SIZE,
@@ -1341,12 +1329,8 @@ static struct skcipher_alg aes_algs[] = { 
{

	.base.cra_name		= "cfb(aes)",

	.base.cra_driver_name	= "atmel-cfb-aes",

	.base.cra_priority	= ATMEL_AES_PRIORITY,

	.base.cra_flags		= CRYPTO_ALG_ASYNC,

	.base.cra_blocksize	= AES_BLOCK_SIZE,

	.base.cra_ctxsize	= sizeof(struct atmel_aes_ctx),

	.base.cra_alignmask	= 0xf,

	.base.cra_module	= THIS_MODULE,



	.init			= atmel_aes_init_tfm,

	.min_keysize		= AES_MIN_KEY_SIZE,
@@ -1359,12 +1343,8 @@ static struct skcipher_alg aes_algs[] = { 
{

	.base.cra_name		= "cfb32(aes)",

	.base.cra_driver_name	= "atmel-cfb32-aes",

	.base.cra_priority	= ATMEL_AES_PRIORITY,

	.base.cra_flags		= CRYPTO_ALG_ASYNC,

	.base.cra_blocksize	= CFB32_BLOCK_SIZE,

	.base.cra_ctxsize	= sizeof(struct atmel_aes_ctx),

	.base.cra_alignmask	= 0xf,

	.base.cra_module	= THIS_MODULE,



	.init			= atmel_aes_init_tfm,

	.min_keysize		= AES_MIN_KEY_SIZE,
@@ -1377,12 +1357,8 @@ static struct skcipher_alg aes_algs[] = { 
{

	.base.cra_name		= "cfb16(aes)",

	.base.cra_driver_name	= "atmel-cfb16-aes",

	.base.cra_priority	= ATMEL_AES_PRIORITY,

	.base.cra_flags		= CRYPTO_ALG_ASYNC,

	.base.cra_blocksize	= CFB16_BLOCK_SIZE,

	.base.cra_ctxsize	= sizeof(struct atmel_aes_ctx),

	.base.cra_alignmask	= 0xf,

	.base.cra_module	= THIS_MODULE,



	.init			= atmel_aes_init_tfm,

	.min_keysize		= AES_MIN_KEY_SIZE,
@@ -1395,12 +1371,8 @@ static struct skcipher_alg aes_algs[] = { 
{

	.base.cra_name		= "cfb8(aes)",

	.base.cra_driver_name	= "atmel-cfb8-aes",

	.base.cra_priority	= ATMEL_AES_PRIORITY,

	.base.cra_flags		= CRYPTO_ALG_ASYNC,

	.base.cra_blocksize	= CFB8_BLOCK_SIZE,

	.base.cra_ctxsize	= sizeof(struct atmel_aes_ctx),

	.base.cra_alignmask	= 0xf,

	.base.cra_module	= THIS_MODULE,



	.init			= atmel_aes_init_tfm,

	.min_keysize		= AES_MIN_KEY_SIZE,
@@ -1413,12 +1385,8 @@ static struct skcipher_alg aes_algs[] = { 
{

	.base.cra_name		= "ctr(aes)",

	.base.cra_driver_name	= "atmel-ctr-aes",

	.base.cra_priority	= ATMEL_AES_PRIORITY,

	.base.cra_flags		= CRYPTO_ALG_ASYNC,

	.base.cra_blocksize	= 1,

	.base.cra_ctxsize	= sizeof(struct atmel_aes_ctr_ctx),

	.base.cra_alignmask	= 0xf,

	.base.cra_module	= THIS_MODULE,



	.init			= atmel_aes_ctr_init_tfm,

	.min_keysize		= AES_MIN_KEY_SIZE,
@@ -1433,12 +1401,8 @@ static struct skcipher_alg aes_algs[] = { 
static struct skcipher_alg aes_cfb64_alg = {

	.base.cra_name		= "cfb64(aes)",

	.base.cra_driver_name	= "atmel-cfb64-aes",

	.base.cra_priority	= ATMEL_AES_PRIORITY,

	.base.cra_flags		= CRYPTO_ALG_ASYNC,

	.base.cra_blocksize	= CFB64_BLOCK_SIZE,

	.base.cra_ctxsize	= sizeof(struct atmel_aes_ctx),

	.base.cra_alignmask	= 0xf,

	.base.cra_module	= THIS_MODULE,



	.init			= atmel_aes_init_tfm,

	.min_keysize		= AES_MIN_KEY_SIZE,
@@ -1824,12 +1788,8 @@ static struct aead_alg aes_gcm_alg = { 
	.base = {

		.cra_name		= "gcm(aes)",

		.cra_driver_name	= "atmel-gcm-aes",

		.cra_priority		= ATMEL_AES_PRIORITY,

		.cra_flags		= CRYPTO_ALG_ASYNC,

		.cra_blocksize		= 1,

		.cra_ctxsize		= sizeof(struct atmel_aes_gcm_ctx),

		.cra_alignmask		= 0xf,

		.cra_module		= THIS_MODULE,

	},

};
@@ -1946,12 +1906,8 @@ static int atmel_aes_xts_init_tfm(struct crypto_skcipher *tfm) 
static struct skcipher_alg aes_xts_alg = {

	.base.cra_name		= "xts(aes)",

	.base.cra_driver_name	= "atmel-xts-aes",

	.base.cra_priority	= ATMEL_AES_PRIORITY,

	.base.cra_flags		= CRYPTO_ALG_ASYNC,

	.base.cra_blocksize	= AES_BLOCK_SIZE,

	.base.cra_ctxsize	= sizeof(struct atmel_aes_xts_ctx),

	.base.cra_alignmask	= 0xf,

	.base.cra_module	= THIS_MODULE,



	.min_keysize		= 2 * AES_MIN_KEY_SIZE,

	.max_keysize		= 2 * AES_MAX_KEY_SIZE,
@@ -2251,12 +2207,8 @@ static struct aead_alg aes_authenc_algs[] = { 
	.base = {

		.cra_name		= "authenc(hmac(sha1),cbc(aes))",

		.cra_driver_name	= "atmel-authenc-hmac-sha1-cbc-aes",

		.cra_priority		= ATMEL_AES_PRIORITY,

		.cra_flags		= CRYPTO_ALG_ASYNC,

		.cra_blocksize		= AES_BLOCK_SIZE,

		.cra_ctxsize		= sizeof(struct atmel_aes_authenc_ctx),

		.cra_alignmask		= 0xf,

		.cra_module		= THIS_MODULE,

	},

},

{
@@ -2271,12 +2223,8 @@ static struct aead_alg aes_authenc_algs[] = { 
	.base = {

		.cra_name		= "authenc(hmac(sha224),cbc(aes))",

		.cra_driver_name	= "atmel-authenc-hmac-sha224-cbc-aes",

		.cra_priority		= ATMEL_AES_PRIORITY,

		.cra_flags		= CRYPTO_ALG_ASYNC,

		.cra_blocksize		= AES_BLOCK_SIZE,

		.cra_ctxsize		= sizeof(struct atmel_aes_authenc_ctx),

		.cra_alignmask		= 0xf,

		.cra_module		= THIS_MODULE,

	},

},

{
@@ -2291,12 +2239,8 @@ static struct aead_alg aes_authenc_algs[] = { 
	.base = {

		.cra_name		= "authenc(hmac(sha256),cbc(aes))",

		.cra_driver_name	= "atmel-authenc-hmac-sha256-cbc-aes",

		.cra_priority		= ATMEL_AES_PRIORITY,

		.cra_flags		= CRYPTO_ALG_ASYNC,

		.cra_blocksize		= AES_BLOCK_SIZE,

		.cra_ctxsize		= sizeof(struct atmel_aes_authenc_ctx),

		.cra_alignmask		= 0xf,

		.cra_module		= THIS_MODULE,

	},

},

{
@@ -2311,12 +2255,8 @@ static struct aead_alg aes_authenc_algs[] = { 
	.base = {

		.cra_name		= "authenc(hmac(sha384),cbc(aes))",

		.cra_driver_name	= "atmel-authenc-hmac-sha384-cbc-aes",

		.cra_priority		= ATMEL_AES_PRIORITY,

		.cra_flags		= CRYPTO_ALG_ASYNC,

		.cra_blocksize		= AES_BLOCK_SIZE,

		.cra_ctxsize		= sizeof(struct atmel_aes_authenc_ctx),

		.cra_alignmask		= 0xf,

		.cra_module		= THIS_MODULE,

	},

},

{
@@ -2331,12 +2271,8 @@ static struct aead_alg aes_authenc_algs[] = { 
	.base = {

		.cra_name		= "authenc(hmac(sha512),cbc(aes))",

		.cra_driver_name	= "atmel-authenc-hmac-sha512-cbc-aes",

		.cra_priority		= ATMEL_AES_PRIORITY,

		.cra_flags		= CRYPTO_ALG_ASYNC,

		.cra_blocksize		= AES_BLOCK_SIZE,

		.cra_ctxsize		= sizeof(struct atmel_aes_authenc_ctx),

		.cra_alignmask		= 0xf,

		.cra_module		= THIS_MODULE,

	},

},

};
@@ -2452,29 +2388,45 @@ static void atmel_aes_unregister_algs(struct atmel_aes_dev *dd) 
		crypto_unregister_skcipher(&aes_algs[i]);

}



static void atmel_aes_crypto_alg_init(struct crypto_alg *alg)

{

	alg->cra_flags = CRYPTO_ALG_ASYNC;

	alg->cra_alignmask = 0xf;

	alg->cra_priority = ATMEL_AES_PRIORITY;

	alg->cra_module = THIS_MODULE;

}



static int atmel_aes_register_algs(struct atmel_aes_dev *dd)

{

	int err, i, j;



	for (i = 0; i < ARRAY_SIZE(aes_algs); i++) {

		atmel_aes_crypto_alg_init(&aes_algs[i].base);



		err = crypto_register_skcipher(&aes_algs[i]);

		if (err)

			goto err_aes_algs;

	}



	if (dd->caps.has_cfb64) {

		atmel_aes_crypto_alg_init(&aes_cfb64_alg.base);



		err = crypto_register_skcipher(&aes_cfb64_alg);

		if (err)

			goto err_aes_cfb64_alg;

	}



	if (dd->caps.has_gcm) {

		atmel_aes_crypto_alg_init(&aes_gcm_alg.base);



		err = crypto_register_aead(&aes_gcm_alg);

		if (err)

			goto err_aes_gcm_alg;

	}



	if (dd->caps.has_xts) {

		atmel_aes_crypto_alg_init(&aes_xts_alg.base);



		err = crypto_register_skcipher(&aes_xts_alg);

		if (err)

			goto err_aes_xts_alg;
@@ -2483,6 +2435,8 @@ static int atmel_aes_register_algs(struct atmel_aes_dev *dd) 
#if IS_ENABLED(CONFIG_CRYPTO_DEV_ATMEL_AUTHENC)

	if (dd->caps.has_authenc) {

		for (i = 0; i < ARRAY_SIZE(aes_authenc_algs); i++) {

			atmel_aes_crypto_alg_init(&aes_authenc_algs[i].base);



			err = crypto_register_aead(&aes_authenc_algs[i]);

			if (err)

				goto err_aes_authenc_alg;

drivers/crypto/atmel-sha.c

+99 −225
Original line number Diff line number Diff line
@@ -1252,130 +1252,66 @@ static int atmel_sha_cra_init(struct crypto_tfm *tfm) 
	return 0;

}



static struct ahash_alg sha_1_256_algs[] = {

static void atmel_sha_alg_init(struct ahash_alg *alg)

{

	.init		= atmel_sha_init,

	.update		= atmel_sha_update,

	.final		= atmel_sha_final,

	.finup		= atmel_sha_finup,

	.digest		= atmel_sha_digest,

	.export		= atmel_sha_export,

	.import		= atmel_sha_import,

	.halg = {

		.digestsize	= SHA1_DIGEST_SIZE,

		.statesize	= sizeof(struct atmel_sha_reqctx),

		.base	= {

			.cra_name		= "sha1",

			.cra_driver_name	= "atmel-sha1",

			.cra_priority		= ATMEL_SHA_PRIORITY,

			.cra_flags		= CRYPTO_ALG_ASYNC,

			.cra_blocksize		= SHA1_BLOCK_SIZE,

			.cra_ctxsize		= sizeof(struct atmel_sha_ctx),

			.cra_alignmask		= 0,

			.cra_module		= THIS_MODULE,

			.cra_init		= atmel_sha_cra_init,

		}

	alg->halg.base.cra_priority = ATMEL_SHA_PRIORITY;

	alg->halg.base.cra_flags = CRYPTO_ALG_ASYNC;

	alg->halg.base.cra_ctxsize = sizeof(struct atmel_sha_ctx);

	alg->halg.base.cra_module = THIS_MODULE;

	alg->halg.base.cra_init = atmel_sha_cra_init;



	alg->halg.statesize = sizeof(struct atmel_sha_reqctx);



	alg->init = atmel_sha_init;

	alg->update = atmel_sha_update;

	alg->final = atmel_sha_final;

	alg->finup = atmel_sha_finup;

	alg->digest = atmel_sha_digest;

	alg->export = atmel_sha_export;

	alg->import = atmel_sha_import;

}



static struct ahash_alg sha_1_256_algs[] = {

{

	.halg.base.cra_name		= "sha1",

	.halg.base.cra_driver_name	= "atmel-sha1",

	.halg.base.cra_blocksize	= SHA1_BLOCK_SIZE,



	.halg.digestsize = SHA1_DIGEST_SIZE,

},

{

	.init		= atmel_sha_init,

	.update		= atmel_sha_update,

	.final		= atmel_sha_final,

	.finup		= atmel_sha_finup,

	.digest		= atmel_sha_digest,

	.export		= atmel_sha_export,

	.import		= atmel_sha_import,

	.halg = {

		.digestsize	= SHA256_DIGEST_SIZE,

		.statesize	= sizeof(struct atmel_sha_reqctx),

		.base	= {

			.cra_name		= "sha256",

			.cra_driver_name	= "atmel-sha256",

			.cra_priority		= ATMEL_SHA_PRIORITY,

			.cra_flags		= CRYPTO_ALG_ASYNC,

			.cra_blocksize		= SHA256_BLOCK_SIZE,

			.cra_ctxsize		= sizeof(struct atmel_sha_ctx),

			.cra_alignmask		= 0,

			.cra_module		= THIS_MODULE,

			.cra_init		= atmel_sha_cra_init,

		}

	}

	.halg.base.cra_name		= "sha256",

	.halg.base.cra_driver_name	= "atmel-sha256",

	.halg.base.cra_blocksize	= SHA256_BLOCK_SIZE,



	.halg.digestsize = SHA256_DIGEST_SIZE,

},

};



static struct ahash_alg sha_224_alg = {

	.init		= atmel_sha_init,

	.update		= atmel_sha_update,

	.final		= atmel_sha_final,

	.finup		= atmel_sha_finup,

	.digest		= atmel_sha_digest,

	.export		= atmel_sha_export,

	.import		= atmel_sha_import,

	.halg = {

		.digestsize	= SHA224_DIGEST_SIZE,

		.statesize	= sizeof(struct atmel_sha_reqctx),

		.base	= {

			.cra_name		= "sha224",

			.cra_driver_name	= "atmel-sha224",

			.cra_priority		= ATMEL_SHA_PRIORITY,

			.cra_flags		= CRYPTO_ALG_ASYNC,

			.cra_blocksize		= SHA224_BLOCK_SIZE,

			.cra_ctxsize		= sizeof(struct atmel_sha_ctx),

			.cra_alignmask		= 0,

			.cra_module		= THIS_MODULE,

			.cra_init		= atmel_sha_cra_init,

		}

	}

	.halg.base.cra_name		= "sha224",

	.halg.base.cra_driver_name	= "atmel-sha224",

	.halg.base.cra_blocksize	= SHA224_BLOCK_SIZE,



	.halg.digestsize = SHA224_DIGEST_SIZE,

};



static struct ahash_alg sha_384_512_algs[] = {

{

	.init		= atmel_sha_init,

	.update		= atmel_sha_update,

	.final		= atmel_sha_final,

	.finup		= atmel_sha_finup,

	.digest		= atmel_sha_digest,

	.export		= atmel_sha_export,

	.import		= atmel_sha_import,

	.halg = {

		.digestsize	= SHA384_DIGEST_SIZE,

		.statesize	= sizeof(struct atmel_sha_reqctx),

		.base	= {

			.cra_name		= "sha384",

			.cra_driver_name	= "atmel-sha384",

			.cra_priority		= ATMEL_SHA_PRIORITY,

			.cra_flags		= CRYPTO_ALG_ASYNC,

			.cra_blocksize		= SHA384_BLOCK_SIZE,

			.cra_ctxsize		= sizeof(struct atmel_sha_ctx),

			.cra_alignmask		= 0x3,

			.cra_module		= THIS_MODULE,

			.cra_init		= atmel_sha_cra_init,

		}

	}

	.halg.base.cra_name		= "sha384",

	.halg.base.cra_driver_name	= "atmel-sha384",

	.halg.base.cra_blocksize	= SHA384_BLOCK_SIZE,

	.halg.base.cra_alignmask	= 0x3,



	.halg.digestsize = SHA384_DIGEST_SIZE,

},

{

	.init		= atmel_sha_init,

	.update		= atmel_sha_update,

	.final		= atmel_sha_final,

	.finup		= atmel_sha_finup,

	.digest		= atmel_sha_digest,

	.export		= atmel_sha_export,

	.import		= atmel_sha_import,

	.halg = {

		.digestsize	= SHA512_DIGEST_SIZE,

		.statesize	= sizeof(struct atmel_sha_reqctx),

		.base	= {

			.cra_name		= "sha512",

			.cra_driver_name	= "atmel-sha512",

			.cra_priority		= ATMEL_SHA_PRIORITY,

			.cra_flags		= CRYPTO_ALG_ASYNC,

			.cra_blocksize		= SHA512_BLOCK_SIZE,

			.cra_ctxsize		= sizeof(struct atmel_sha_ctx),

			.cra_alignmask		= 0x3,

			.cra_module		= THIS_MODULE,

			.cra_init		= atmel_sha_cra_init,

		}

	}

	.halg.base.cra_name		= "sha512",

	.halg.base.cra_driver_name	= "atmel-sha512",

	.halg.base.cra_blocksize	= SHA512_BLOCK_SIZE,

	.halg.base.cra_alignmask	= 0x3,



	.halg.digestsize = SHA512_DIGEST_SIZE,

},

};
@@ -2084,131 +2020,61 @@ static void atmel_sha_hmac_cra_exit(struct crypto_tfm *tfm) 
	atmel_sha_hmac_key_release(&hmac->hkey);

}



static struct ahash_alg sha_hmac_algs[] = {

static void atmel_sha_hmac_alg_init(struct ahash_alg *alg)

{

	.init		= atmel_sha_hmac_init,

	.update		= atmel_sha_update,

	.final		= atmel_sha_final,

	.digest		= atmel_sha_hmac_digest,

	.setkey		= atmel_sha_hmac_setkey,

	.export		= atmel_sha_export,

	.import		= atmel_sha_import,

	.halg = {

		.digestsize	= SHA1_DIGEST_SIZE,

		.statesize	= sizeof(struct atmel_sha_reqctx),

		.base	= {

			.cra_name		= "hmac(sha1)",

			.cra_driver_name	= "atmel-hmac-sha1",

			.cra_priority		= ATMEL_SHA_PRIORITY,

			.cra_flags		= CRYPTO_ALG_ASYNC,

			.cra_blocksize		= SHA1_BLOCK_SIZE,

			.cra_ctxsize		= sizeof(struct atmel_sha_hmac_ctx),

			.cra_alignmask		= 0,

			.cra_module		= THIS_MODULE,

			.cra_init		= atmel_sha_hmac_cra_init,

			.cra_exit		= atmel_sha_hmac_cra_exit,

		}

	alg->halg.base.cra_priority = ATMEL_SHA_PRIORITY;

	alg->halg.base.cra_flags = CRYPTO_ALG_ASYNC;

	alg->halg.base.cra_ctxsize = sizeof(struct atmel_sha_hmac_ctx);

	alg->halg.base.cra_module = THIS_MODULE;

	alg->halg.base.cra_init	= atmel_sha_hmac_cra_init;

	alg->halg.base.cra_exit	= atmel_sha_hmac_cra_exit;



	alg->halg.statesize = sizeof(struct atmel_sha_reqctx);



	alg->init = atmel_sha_hmac_init;

	alg->update = atmel_sha_update;

	alg->final = atmel_sha_final;

	alg->digest = atmel_sha_hmac_digest;

	alg->setkey = atmel_sha_hmac_setkey;

	alg->export = atmel_sha_export;

	alg->import = atmel_sha_import;

}



static struct ahash_alg sha_hmac_algs[] = {

{

	.halg.base.cra_name		= "hmac(sha1)",

	.halg.base.cra_driver_name	= "atmel-hmac-sha1",

	.halg.base.cra_blocksize	= SHA1_BLOCK_SIZE,



	.halg.digestsize = SHA1_DIGEST_SIZE,

},

{

	.init		= atmel_sha_hmac_init,

	.update		= atmel_sha_update,

	.final		= atmel_sha_final,

	.digest		= atmel_sha_hmac_digest,

	.setkey		= atmel_sha_hmac_setkey,

	.export		= atmel_sha_export,

	.import		= atmel_sha_import,

	.halg = {

		.digestsize	= SHA224_DIGEST_SIZE,

		.statesize	= sizeof(struct atmel_sha_reqctx),

		.base	= {

			.cra_name		= "hmac(sha224)",

			.cra_driver_name	= "atmel-hmac-sha224",

			.cra_priority		= ATMEL_SHA_PRIORITY,

			.cra_flags		= CRYPTO_ALG_ASYNC,

			.cra_blocksize		= SHA224_BLOCK_SIZE,

			.cra_ctxsize		= sizeof(struct atmel_sha_hmac_ctx),

			.cra_alignmask		= 0,

			.cra_module		= THIS_MODULE,

			.cra_init		= atmel_sha_hmac_cra_init,

			.cra_exit		= atmel_sha_hmac_cra_exit,

		}

	}

	.halg.base.cra_name		= "hmac(sha224)",

	.halg.base.cra_driver_name	= "atmel-hmac-sha224",

	.halg.base.cra_blocksize	= SHA224_BLOCK_SIZE,



	.halg.digestsize = SHA224_DIGEST_SIZE,

},

{

	.init		= atmel_sha_hmac_init,

	.update		= atmel_sha_update,

	.final		= atmel_sha_final,

	.digest		= atmel_sha_hmac_digest,

	.setkey		= atmel_sha_hmac_setkey,

	.export		= atmel_sha_export,

	.import		= atmel_sha_import,

	.halg = {

		.digestsize	= SHA256_DIGEST_SIZE,

		.statesize	= sizeof(struct atmel_sha_reqctx),

		.base	= {

			.cra_name		= "hmac(sha256)",

			.cra_driver_name	= "atmel-hmac-sha256",

			.cra_priority		= ATMEL_SHA_PRIORITY,

			.cra_flags		= CRYPTO_ALG_ASYNC,

			.cra_blocksize		= SHA256_BLOCK_SIZE,

			.cra_ctxsize		= sizeof(struct atmel_sha_hmac_ctx),

			.cra_alignmask		= 0,

			.cra_module		= THIS_MODULE,

			.cra_init		= atmel_sha_hmac_cra_init,

			.cra_exit		= atmel_sha_hmac_cra_exit,

		}

	}

	.halg.base.cra_name		= "hmac(sha256)",

	.halg.base.cra_driver_name	= "atmel-hmac-sha256",

	.halg.base.cra_blocksize	= SHA256_BLOCK_SIZE,



	.halg.digestsize = SHA256_DIGEST_SIZE,

},

{

	.init		= atmel_sha_hmac_init,

	.update		= atmel_sha_update,

	.final		= atmel_sha_final,

	.digest		= atmel_sha_hmac_digest,

	.setkey		= atmel_sha_hmac_setkey,

	.export		= atmel_sha_export,

	.import		= atmel_sha_import,

	.halg = {

		.digestsize	= SHA384_DIGEST_SIZE,

		.statesize	= sizeof(struct atmel_sha_reqctx),

		.base	= {

			.cra_name		= "hmac(sha384)",

			.cra_driver_name	= "atmel-hmac-sha384",

			.cra_priority		= ATMEL_SHA_PRIORITY,

			.cra_flags		= CRYPTO_ALG_ASYNC,

			.cra_blocksize		= SHA384_BLOCK_SIZE,

			.cra_ctxsize		= sizeof(struct atmel_sha_hmac_ctx),

			.cra_alignmask		= 0,

			.cra_module		= THIS_MODULE,

			.cra_init		= atmel_sha_hmac_cra_init,

			.cra_exit		= atmel_sha_hmac_cra_exit,

		}

	}

	.halg.base.cra_name		= "hmac(sha384)",

	.halg.base.cra_driver_name	= "atmel-hmac-sha384",

	.halg.base.cra_blocksize	= SHA384_BLOCK_SIZE,



	.halg.digestsize = SHA384_DIGEST_SIZE,

},

{

	.init		= atmel_sha_hmac_init,

	.update		= atmel_sha_update,

	.final		= atmel_sha_final,

	.digest		= atmel_sha_hmac_digest,

	.setkey		= atmel_sha_hmac_setkey,

	.export		= atmel_sha_export,

	.import		= atmel_sha_import,

	.halg = {

		.digestsize	= SHA512_DIGEST_SIZE,

		.statesize	= sizeof(struct atmel_sha_reqctx),

		.base	= {

			.cra_name		= "hmac(sha512)",

			.cra_driver_name	= "atmel-hmac-sha512",

			.cra_priority		= ATMEL_SHA_PRIORITY,

			.cra_flags		= CRYPTO_ALG_ASYNC,

			.cra_blocksize		= SHA512_BLOCK_SIZE,

			.cra_ctxsize		= sizeof(struct atmel_sha_hmac_ctx),

			.cra_alignmask		= 0,

			.cra_module		= THIS_MODULE,

			.cra_init		= atmel_sha_hmac_cra_init,

			.cra_exit		= atmel_sha_hmac_cra_exit,

		}

	}

	.halg.base.cra_name		= "hmac(sha512)",

	.halg.base.cra_driver_name	= "atmel-hmac-sha512",

	.halg.base.cra_blocksize	= SHA512_BLOCK_SIZE,



	.halg.digestsize = SHA512_DIGEST_SIZE,

},

};
@@ -2561,12 +2427,16 @@ static int atmel_sha_register_algs(struct atmel_sha_dev *dd) 
	int err, i, j;



	for (i = 0; i < ARRAY_SIZE(sha_1_256_algs); i++) {

		atmel_sha_alg_init(&sha_1_256_algs[i]);



		err = crypto_register_ahash(&sha_1_256_algs[i]);

		if (err)

			goto err_sha_1_256_algs;

	}



	if (dd->caps.has_sha224) {

		atmel_sha_alg_init(&sha_224_alg);



		err = crypto_register_ahash(&sha_224_alg);

		if (err)

			goto err_sha_224_algs;
@@ -2574,6 +2444,8 @@ static int atmel_sha_register_algs(struct atmel_sha_dev *dd) 


	if (dd->caps.has_sha_384_512) {

		for (i = 0; i < ARRAY_SIZE(sha_384_512_algs); i++) {

			atmel_sha_alg_init(&sha_384_512_algs[i]);



			err = crypto_register_ahash(&sha_384_512_algs[i]);

			if (err)

				goto err_sha_384_512_algs;
@@ -2582,6 +2454,8 @@ static int atmel_sha_register_algs(struct atmel_sha_dev *dd) 


	if (dd->caps.has_hmac) {

		for (i = 0; i < ARRAY_SIZE(sha_hmac_algs); i++) {

			atmel_sha_hmac_alg_init(&sha_hmac_algs[i]);



			err = crypto_register_ahash(&sha_hmac_algs[i]);

			if (err)

				goto err_sha_hmac_algs;

drivers/crypto/atmel-tdes.c

+12 −50
Original line number Diff line number Diff line
@@ -912,18 +912,23 @@ static int atmel_tdes_init_tfm(struct crypto_skcipher *tfm) 
	return 0;

}



static void atmel_tdes_skcipher_alg_init(struct skcipher_alg *alg)

{

	alg->base.cra_priority = ATMEL_TDES_PRIORITY;

	alg->base.cra_flags = CRYPTO_ALG_ASYNC;

	alg->base.cra_ctxsize = sizeof(struct atmel_tdes_ctx),

	alg->base.cra_module = THIS_MODULE;



	alg->init = atmel_tdes_init_tfm;

}



static struct skcipher_alg tdes_algs[] = {

{

	.base.cra_name		= "ecb(des)",

	.base.cra_driver_name	= "atmel-ecb-des",

	.base.cra_priority	= ATMEL_TDES_PRIORITY,

	.base.cra_flags		= CRYPTO_ALG_ASYNC,

	.base.cra_blocksize	= DES_BLOCK_SIZE,

	.base.cra_ctxsize	= sizeof(struct atmel_tdes_ctx),

	.base.cra_alignmask	= 0x7,

	.base.cra_module	= THIS_MODULE,



	.init			= atmel_tdes_init_tfm,

	.min_keysize		= DES_KEY_SIZE,

	.max_keysize		= DES_KEY_SIZE,

	.setkey			= atmel_des_setkey,
@@ -933,14 +938,9 @@ static struct skcipher_alg tdes_algs[] = { 
{

	.base.cra_name		= "cbc(des)",

	.base.cra_driver_name	= "atmel-cbc-des",

	.base.cra_priority	= ATMEL_TDES_PRIORITY,

	.base.cra_flags		= CRYPTO_ALG_ASYNC,

	.base.cra_blocksize	= DES_BLOCK_SIZE,

	.base.cra_ctxsize	= sizeof(struct atmel_tdes_ctx),

	.base.cra_alignmask	= 0x7,

	.base.cra_module	= THIS_MODULE,



	.init			= atmel_tdes_init_tfm,

	.min_keysize		= DES_KEY_SIZE,

	.max_keysize		= DES_KEY_SIZE,

	.ivsize			= DES_BLOCK_SIZE,
@@ -951,14 +951,9 @@ static struct skcipher_alg tdes_algs[] = { 
{

	.base.cra_name		= "cfb(des)",

	.base.cra_driver_name	= "atmel-cfb-des",

	.base.cra_priority	= ATMEL_TDES_PRIORITY,

	.base.cra_flags		= CRYPTO_ALG_ASYNC,

	.base.cra_blocksize	= DES_BLOCK_SIZE,

	.base.cra_ctxsize	= sizeof(struct atmel_tdes_ctx),

	.base.cra_alignmask	= 0x7,

	.base.cra_module	= THIS_MODULE,



	.init			= atmel_tdes_init_tfm,

	.min_keysize		= DES_KEY_SIZE,

	.max_keysize		= DES_KEY_SIZE,

	.ivsize			= DES_BLOCK_SIZE,
@@ -969,14 +964,9 @@ static struct skcipher_alg tdes_algs[] = { 
{

	.base.cra_name		= "cfb8(des)",

	.base.cra_driver_name	= "atmel-cfb8-des",

	.base.cra_priority	= ATMEL_TDES_PRIORITY,

	.base.cra_flags		= CRYPTO_ALG_ASYNC,

	.base.cra_blocksize	= CFB8_BLOCK_SIZE,

	.base.cra_ctxsize	= sizeof(struct atmel_tdes_ctx),

	.base.cra_alignmask	= 0,

	.base.cra_module	= THIS_MODULE,



	.init			= atmel_tdes_init_tfm,

	.min_keysize		= DES_KEY_SIZE,

	.max_keysize		= DES_KEY_SIZE,

	.ivsize			= DES_BLOCK_SIZE,
@@ -987,14 +977,9 @@ static struct skcipher_alg tdes_algs[] = { 
{

	.base.cra_name		= "cfb16(des)",

	.base.cra_driver_name	= "atmel-cfb16-des",

	.base.cra_priority	= ATMEL_TDES_PRIORITY,

	.base.cra_flags		= CRYPTO_ALG_ASYNC,

	.base.cra_blocksize	= CFB16_BLOCK_SIZE,

	.base.cra_ctxsize	= sizeof(struct atmel_tdes_ctx),

	.base.cra_alignmask	= 0x1,

	.base.cra_module	= THIS_MODULE,



	.init			= atmel_tdes_init_tfm,

	.min_keysize		= DES_KEY_SIZE,

	.max_keysize		= DES_KEY_SIZE,

	.ivsize			= DES_BLOCK_SIZE,
@@ -1005,14 +990,9 @@ static struct skcipher_alg tdes_algs[] = { 
{

	.base.cra_name		= "cfb32(des)",

	.base.cra_driver_name	= "atmel-cfb32-des",

	.base.cra_priority	= ATMEL_TDES_PRIORITY,

	.base.cra_flags		= CRYPTO_ALG_ASYNC,

	.base.cra_blocksize	= CFB32_BLOCK_SIZE,

	.base.cra_ctxsize	= sizeof(struct atmel_tdes_ctx),

	.base.cra_alignmask	= 0x3,

	.base.cra_module	= THIS_MODULE,



	.init			= atmel_tdes_init_tfm,

	.min_keysize		= DES_KEY_SIZE,

	.max_keysize		= DES_KEY_SIZE,

	.ivsize			= DES_BLOCK_SIZE,
@@ -1023,14 +1003,9 @@ static struct skcipher_alg tdes_algs[] = { 
{

	.base.cra_name		= "ofb(des)",

	.base.cra_driver_name	= "atmel-ofb-des",

	.base.cra_priority	= ATMEL_TDES_PRIORITY,

	.base.cra_flags		= CRYPTO_ALG_ASYNC,

	.base.cra_blocksize	= DES_BLOCK_SIZE,

	.base.cra_ctxsize	= sizeof(struct atmel_tdes_ctx),

	.base.cra_alignmask	= 0x7,

	.base.cra_module	= THIS_MODULE,



	.init			= atmel_tdes_init_tfm,

	.min_keysize		= DES_KEY_SIZE,

	.max_keysize		= DES_KEY_SIZE,

	.ivsize			= DES_BLOCK_SIZE,
@@ -1041,14 +1016,9 @@ static struct skcipher_alg tdes_algs[] = { 
{

	.base.cra_name		= "ecb(des3_ede)",

	.base.cra_driver_name	= "atmel-ecb-tdes",

	.base.cra_priority	= ATMEL_TDES_PRIORITY,

	.base.cra_flags		= CRYPTO_ALG_ASYNC,

	.base.cra_blocksize	= DES_BLOCK_SIZE,

	.base.cra_ctxsize	= sizeof(struct atmel_tdes_ctx),

	.base.cra_alignmask	= 0x7,

	.base.cra_module	= THIS_MODULE,



	.init			= atmel_tdes_init_tfm,

	.min_keysize		= DES3_EDE_KEY_SIZE,

	.max_keysize		= DES3_EDE_KEY_SIZE,

	.setkey			= atmel_tdes_setkey,
@@ -1058,14 +1028,9 @@ static struct skcipher_alg tdes_algs[] = { 
{

	.base.cra_name		= "cbc(des3_ede)",

	.base.cra_driver_name	= "atmel-cbc-tdes",

	.base.cra_priority	= ATMEL_TDES_PRIORITY,

	.base.cra_flags		= CRYPTO_ALG_ASYNC,

	.base.cra_blocksize	= DES_BLOCK_SIZE,

	.base.cra_ctxsize	= sizeof(struct atmel_tdes_ctx),

	.base.cra_alignmask	= 0x7,

	.base.cra_module	= THIS_MODULE,



	.init			= atmel_tdes_init_tfm,

	.min_keysize		= DES3_EDE_KEY_SIZE,

	.max_keysize		= DES3_EDE_KEY_SIZE,

	.setkey			= atmel_tdes_setkey,
@@ -1076,14 +1041,9 @@ static struct skcipher_alg tdes_algs[] = { 
{

	.base.cra_name		= "ofb(des3_ede)",

	.base.cra_driver_name	= "atmel-ofb-tdes",

	.base.cra_priority	= ATMEL_TDES_PRIORITY,

	.base.cra_flags		= CRYPTO_ALG_ASYNC,

	.base.cra_blocksize	= DES_BLOCK_SIZE,

	.base.cra_ctxsize	= sizeof(struct atmel_tdes_ctx),

	.base.cra_alignmask	= 0x7,

	.base.cra_module	= THIS_MODULE,



	.init			= atmel_tdes_init_tfm,

	.min_keysize		= DES3_EDE_KEY_SIZE,

	.max_keysize		= DES3_EDE_KEY_SIZE,

	.setkey			= atmel_tdes_setkey,
@@ -1158,6 +1118,8 @@ static int atmel_tdes_register_algs(struct atmel_tdes_dev *dd) 
	int err, i, j;



	for (i = 0; i < ARRAY_SIZE(tdes_algs); i++) {

		atmel_tdes_skcipher_alg_init(&tdes_algs[i]);



		err = crypto_register_skcipher(&tdes_algs[i]);

		if (err)

			goto err_tdes_algs;