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

Move common alg type init to dedicated methods.

Signed-off-by: Tudor Ambarus <tudor.ambarus@microchip.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>

diff --git a/drivers/crypto/atmel-aes.c b/drivers/crypto/atmel-aes.c
index 173a30b..47b20df 100644 (file)
--- a/drivers/crypto/atmel-aes.c
+++ b/drivers/crypto/atmel-aes.c
@@ -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;

diff --git a/drivers/crypto/atmel-sha.c b/drivers/crypto/atmel-sha.c
index bef968a..ebf5001 100644 (file)
--- a/drivers/crypto/atmel-sha.c
+++ b/drivers/crypto/atmel-sha.c
@@ -1252,130 +1252,66 @@ static int atmel_sha_cra_init(struct crypto_tfm *tfm)
        return 0;
 }
 
+static void atmel_sha_alg_init(struct ahash_alg *alg)
+{
+       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[] = {
 {
-       .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,
-               }
-       }
+       .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 void atmel_sha_hmac_alg_init(struct ahash_alg *alg)
+{
+       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[] = {
 {
-       .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,
-               }
-       }
+       .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;

diff --git a/drivers/crypto/atmel-tdes.c b/drivers/crypto/atmel-tdes.c
index b1b8df5..12268b5 100644 (file)
--- a/drivers/crypto/atmel-tdes.c
+++ b/drivers/crypto/atmel-tdes.c
@@ -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;