mirrors/linux-stable
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git synced 2024-09-30 22:26:55 +00:00
Code Issues Releases Wiki Activity

crypto: jh7110 - Use new crypto_engine_op interface

Browse source 
Use the new crypto_engine_op interface where the callback is stored
in the algorithm object.

Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
This commit is contained in:
Herbert Xu 2023-08-13 14:55:12 +08:00
parent 1a15d26c31
commit 982213e473
4 changed files with 251 additions and 204 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

162
drivers/crypto/starfive/jh7110-aes.c
View file

@ -5,12 +5,17 @@
* Copyright (c) 2022 StarFive Technology
*/
#include <linux/iopoll.h>
#include <crypto/engine.h>
#include <crypto/gcm.h>
#include <crypto/scatterwalk.h>
#include <crypto/internal/aead.h>
#include <crypto/internal/skcipher.h>
#include <crypto/scatterwalk.h>
#include "jh7110-cryp.h"
#include <linux/err.h>
#include <linux/iopoll.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/string.h>
#define STARFIVE_AES_REGS_OFFSET 0x100
#define STARFIVE_AES_AESDIO0R (STARFIVE_AES_REGS_OFFSET + 0x0)
@ -554,8 +559,6 @@ static int starfive_aes_init_tfm(struct crypto_skcipher *tfm)
crypto_skcipher_set_reqsize(tfm, sizeof(struct starfive_cryp_request_ctx) +
sizeof(struct skcipher_request));
ctx->enginectx.op.do_one_request = starfive_aes_do_one_req;
return 0;
}
@ -638,8 +641,6 @@ static int starfive_aes_aead_init_tfm(struct crypto_aead *tfm)
crypto_aead_set_reqsize(tfm, sizeof(struct starfive_cryp_ctx) +
sizeof(struct aead_request));
ctx->enginectx.op.do_one_request = starfive_aes_aead_do_one_req;
return 0;
}
@ -844,15 +845,15 @@ static int starfive_aes_ccm_decrypt(struct aead_request *req)
return starfive_aes_aead_crypt(req, STARFIVE_AES_MODE_CCM);
}
static struct skcipher_alg skcipher_algs[] = {
static struct skcipher_engine_alg skcipher_algs[] = {
{
.init = starfive_aes_init_tfm,
.setkey = starfive_aes_setkey,
.encrypt = starfive_aes_ecb_encrypt,
.decrypt = starfive_aes_ecb_decrypt,
.min_keysize = AES_MIN_KEY_SIZE,
.max_keysize = AES_MAX_KEY_SIZE,
.base = {
.base.init = starfive_aes_init_tfm,
.base.setkey = starfive_aes_setkey,
.base.encrypt = starfive_aes_ecb_encrypt,
.base.decrypt = starfive_aes_ecb_decrypt,
.base.min_keysize = AES_MIN_KEY_SIZE,
.base.max_keysize = AES_MAX_KEY_SIZE,
.base.base = {
.cra_name = "ecb(aes)",
.cra_driver_name = "starfive-ecb-aes",
.cra_priority = 200,
@ -862,15 +863,18 @@ static struct skcipher_alg skcipher_algs[] = {
.cra_alignmask = 0xf,
.cra_module = THIS_MODULE,
},
.op = {
.do_one_request = starfive_aes_do_one_req,
},
}, {
.init = starfive_aes_init_tfm,
.setkey = starfive_aes_setkey,
.encrypt = starfive_aes_cbc_encrypt,
.decrypt = starfive_aes_cbc_decrypt,
.min_keysize = AES_MIN_KEY_SIZE,
.max_keysize = AES_MAX_KEY_SIZE,
.ivsize = AES_BLOCK_SIZE,
.base = {
.base.init = starfive_aes_init_tfm,
.base.setkey = starfive_aes_setkey,
.base.encrypt = starfive_aes_cbc_encrypt,
.base.decrypt = starfive_aes_cbc_decrypt,
.base.min_keysize = AES_MIN_KEY_SIZE,
.base.max_keysize = AES_MAX_KEY_SIZE,
.base.ivsize = AES_BLOCK_SIZE,
.base.base = {
.cra_name = "cbc(aes)",
.cra_driver_name = "starfive-cbc-aes",
.cra_priority = 200,
@ -880,15 +884,18 @@ static struct skcipher_alg skcipher_algs[] = {
.cra_alignmask = 0xf,
.cra_module = THIS_MODULE,
},
.op = {
.do_one_request = starfive_aes_do_one_req,
},
}, {
.init = starfive_aes_init_tfm,
.setkey = starfive_aes_setkey,
.encrypt = starfive_aes_ctr_encrypt,
.decrypt = starfive_aes_ctr_decrypt,
.min_keysize = AES_MIN_KEY_SIZE,
.max_keysize = AES_MAX_KEY_SIZE,
.ivsize = AES_BLOCK_SIZE,
.base = {
.base.init = starfive_aes_init_tfm,
.base.setkey = starfive_aes_setkey,
.base.encrypt = starfive_aes_ctr_encrypt,
.base.decrypt = starfive_aes_ctr_decrypt,
.base.min_keysize = AES_MIN_KEY_SIZE,
.base.max_keysize = AES_MAX_KEY_SIZE,
.base.ivsize = AES_BLOCK_SIZE,
.base.base = {
.cra_name = "ctr(aes)",
.cra_driver_name = "starfive-ctr-aes",
.cra_priority = 200,
@ -898,15 +905,18 @@ static struct skcipher_alg skcipher_algs[] = {
.cra_alignmask = 0xf,
.cra_module = THIS_MODULE,
},
.op = {
.do_one_request = starfive_aes_do_one_req,
},
}, {
.init = starfive_aes_init_tfm,
.setkey = starfive_aes_setkey,
.encrypt = starfive_aes_cfb_encrypt,
.decrypt = starfive_aes_cfb_decrypt,
.min_keysize = AES_MIN_KEY_SIZE,
.max_keysize = AES_MAX_KEY_SIZE,
.ivsize = AES_BLOCK_SIZE,
.base = {
.base.init = starfive_aes_init_tfm,
.base.setkey = starfive_aes_setkey,
.base.encrypt = starfive_aes_cfb_encrypt,
.base.decrypt = starfive_aes_cfb_decrypt,
.base.min_keysize = AES_MIN_KEY_SIZE,
.base.max_keysize = AES_MAX_KEY_SIZE,
.base.ivsize = AES_BLOCK_SIZE,
.base.base = {
.cra_name = "cfb(aes)",
.cra_driver_name = "starfive-cfb-aes",
.cra_priority = 200,
@ -916,15 +926,18 @@ static struct skcipher_alg skcipher_algs[] = {
.cra_alignmask = 0xf,
.cra_module = THIS_MODULE,
},
.op = {
.do_one_request = starfive_aes_do_one_req,
},
}, {
.init = starfive_aes_init_tfm,
.setkey = starfive_aes_setkey,
.encrypt = starfive_aes_ofb_encrypt,
.decrypt = starfive_aes_ofb_decrypt,
.min_keysize = AES_MIN_KEY_SIZE,
.max_keysize = AES_MAX_KEY_SIZE,
.ivsize = AES_BLOCK_SIZE,
.base = {
.base.init = starfive_aes_init_tfm,
.base.setkey = starfive_aes_setkey,
.base.encrypt = starfive_aes_ofb_encrypt,
.base.decrypt = starfive_aes_ofb_decrypt,
.base.min_keysize = AES_MIN_KEY_SIZE,
.base.max_keysize = AES_MAX_KEY_SIZE,
.base.ivsize = AES_BLOCK_SIZE,
.base.base = {
.cra_name = "ofb(aes)",
.cra_driver_name = "starfive-ofb-aes",
.cra_priority = 200,
@ -934,20 +947,23 @@ static struct skcipher_alg skcipher_algs[] = {
.cra_alignmask = 0xf,
.cra_module = THIS_MODULE,
},
.op = {
.do_one_request = starfive_aes_do_one_req,
},
},
};
static struct aead_alg aead_algs[] = {
static struct aead_engine_alg aead_algs[] = {
{
.setkey = starfive_aes_aead_setkey,
.setauthsize = starfive_aes_gcm_setauthsize,
.encrypt = starfive_aes_gcm_encrypt,
.decrypt = starfive_aes_gcm_decrypt,
.init = starfive_aes_aead_init_tfm,
.exit = starfive_aes_aead_exit_tfm,
.ivsize = GCM_AES_IV_SIZE,
.maxauthsize = AES_BLOCK_SIZE,
.base = {
.base.setkey = starfive_aes_aead_setkey,
.base.setauthsize = starfive_aes_gcm_setauthsize,
.base.encrypt = starfive_aes_gcm_encrypt,
.base.decrypt = starfive_aes_gcm_decrypt,
.base.init = starfive_aes_aead_init_tfm,
.base.exit = starfive_aes_aead_exit_tfm,
.base.ivsize = GCM_AES_IV_SIZE,
.base.maxauthsize = AES_BLOCK_SIZE,
.base.base = {
.cra_name = "gcm(aes)",
.cra_driver_name = "starfive-gcm-aes",
.cra_priority = 200,
@ -957,16 +973,19 @@ static struct aead_alg aead_algs[] = {
.cra_alignmask = 0xf,
.cra_module = THIS_MODULE,
},
.op = {
.do_one_request = starfive_aes_aead_do_one_req,
},
}, {
.setkey = starfive_aes_aead_setkey,
.setauthsize = starfive_aes_ccm_setauthsize,
.encrypt = starfive_aes_ccm_encrypt,
.decrypt = starfive_aes_ccm_decrypt,
.init = starfive_aes_aead_init_tfm,
.exit = starfive_aes_aead_exit_tfm,
.ivsize = AES_BLOCK_SIZE,
.maxauthsize = AES_BLOCK_SIZE,
.base = {
.base.setkey = starfive_aes_aead_setkey,
.base.setauthsize = starfive_aes_ccm_setauthsize,
.base.encrypt = starfive_aes_ccm_encrypt,
.base.decrypt = starfive_aes_ccm_decrypt,
.base.init = starfive_aes_aead_init_tfm,
.base.exit = starfive_aes_aead_exit_tfm,
.base.ivsize = AES_BLOCK_SIZE,
.base.maxauthsize = AES_BLOCK_SIZE,
.base.base = {
.cra_name = "ccm(aes)",
.cra_driver_name = "starfive-ccm-aes",
.cra_priority = 200,
@ -977,6 +996,9 @@ static struct aead_alg aead_algs[] = {
.cra_alignmask = 0xf,
.cra_module = THIS_MODULE,
},
.op = {
.do_one_request = starfive_aes_aead_do_one_req,
},
},
};
@ -984,19 +1006,19 @@ int starfive_aes_register_algs(void)
{
int ret;
ret = crypto_register_skciphers(skcipher_algs, ARRAY_SIZE(skcipher_algs));
ret = crypto_engine_register_skciphers(skcipher_algs, ARRAY_SIZE(skcipher_algs));
if (ret)
return ret;
ret = crypto_register_aeads(aead_algs, ARRAY_SIZE(aead_algs));
ret = crypto_engine_register_aeads(aead_algs, ARRAY_SIZE(aead_algs));
if (ret)
crypto_unregister_skciphers(skcipher_algs, ARRAY_SIZE(skcipher_algs));
crypto_engine_unregister_skciphers(skcipher_algs, ARRAY_SIZE(skcipher_algs));
return ret;
}
void starfive_aes_unregister_algs(void)
{
crypto_unregister_aeads(aead_algs, ARRAY_SIZE(aead_algs));
crypto_unregister_skciphers(skcipher_algs, ARRAY_SIZE(skcipher_algs));
crypto_engine_unregister_aeads(aead_algs, ARRAY_SIZE(aead_algs));
crypto_engine_unregister_skciphers(skcipher_algs, ARRAY_SIZE(skcipher_algs));
}

9
drivers/crypto/starfive/jh7110-cryp.c
View file

@ -7,17 +7,20 @@
*
*/
#include <crypto/engine.h>
#include "jh7110-cryp.h"
#include <linux/clk.h>
#include <linux/delay.h>
#include <linux/completion.h>
#include <linux/err.h>
#include <linux/interrupt.h>
#include <linux/iopoll.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/of_device.h>
#include <linux/platform_device.h>
#include <linux/pm_runtime.h>
#include <linux/reset.h>
#include "jh7110-cryp.h"
#include <linux/spinlock.h>
#define DRIVER_NAME "jh7110-crypto"

2
drivers/crypto/starfive/jh7110-cryp.h
View file

@ -3,7 +3,6 @@
#define __STARFIVE_STR_H__
#include <crypto/aes.h>
#include <crypto/engine.h>
#include <crypto/hash.h>
#include <crypto/scatterwalk.h>
#include <crypto/sha2.h>
@ -151,7 +150,6 @@ union starfive_alg_cr {
};
struct starfive_cryp_ctx {
struct crypto_engine_ctx enginectx;
struct starfive_cryp_dev *cryp;
struct starfive_cryp_request_ctx *rctx;

282
drivers/crypto/starfive/jh7110-hash.c
View file

@ -6,11 +6,14 @@
*
*/
#include <crypto/engine.h>
#include <crypto/internal/hash.h>
#include <crypto/scatterwalk.h>
#include "jh7110-cryp.h"
#include <linux/amba/pl080.h>
#include <linux/clk.h>
#include <linux/crypto.h>
#include <linux/dma-direct.h>
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/iopoll.h>
#include <linux/kernel.h>
#include <linux/module.h>
@ -18,13 +21,6 @@
#include <linux/platform_device.h>
#include <linux/pm_runtime.h>
#include <linux/reset.h>
#include <linux/amba/pl080.h>
#include <crypto/hash.h>
#include <crypto/scatterwalk.h>
#include <crypto/internal/hash.h>
#include "jh7110-cryp.h"
#define STARFIVE_HASH_REGS_OFFSET 0x300
#define STARFIVE_HASH_SHACSR (STARFIVE_HASH_REGS_OFFSET + 0x0)
@ -433,8 +429,6 @@ static int starfive_hash_init_tfm(struct crypto_ahash *hash,
ctx->keylen = 0;
ctx->hash_mode = mode;
ctx->enginectx.op.do_one_request = starfive_hash_one_request;
return 0;
}
@ -612,18 +606,18 @@ static int starfive_hmac_sm3_init_tfm(struct crypto_ahash *hash)
STARFIVE_HASH_SM3);
}
static struct ahash_alg algs_sha2_sm3[] = {
static struct ahash_engine_alg algs_sha2_sm3[] = {
{
.init = starfive_hash_init,
.update = starfive_hash_update,
.final = starfive_hash_final,
.finup = starfive_hash_finup,
.digest = starfive_hash_digest,
.export = starfive_hash_export,
.import = starfive_hash_import,
.init_tfm = starfive_sha224_init_tfm,
.exit_tfm = starfive_hash_exit_tfm,
.halg = {
.base.init = starfive_hash_init,
.base.update = starfive_hash_update,
.base.final = starfive_hash_final,
.base.finup = starfive_hash_finup,
.base.digest = starfive_hash_digest,
.base.export = starfive_hash_export,
.base.import = starfive_hash_import,
.base.init_tfm = starfive_sha224_init_tfm,
.base.exit_tfm = starfive_hash_exit_tfm,
.base.halg = {
.digestsize = SHA224_DIGEST_SIZE,
.statesize = sizeof(struct sha256_state),
.base = {
@ -638,19 +632,22 @@ static struct ahash_alg algs_sha2_sm3[] = {
.cra_alignmask = 3,
.cra_module = THIS_MODULE,
}
}
},
.op = {
.do_one_request = starfive_hash_one_request,
},
}, {
.init = starfive_hash_init,
.update = starfive_hash_update,
.final = starfive_hash_final,
.finup = starfive_hash_finup,
.digest = starfive_hash_digest,
.export = starfive_hash_export,
.import = starfive_hash_import,
.init_tfm = starfive_hmac_sha224_init_tfm,
.exit_tfm = starfive_hash_exit_tfm,
.setkey = starfive_hash_setkey,
.halg = {
.base.init = starfive_hash_init,
.base.update = starfive_hash_update,
.base.final = starfive_hash_final,
.base.finup = starfive_hash_finup,
.base.digest = starfive_hash_digest,
.base.export = starfive_hash_export,
.base.import = starfive_hash_import,
.base.init_tfm = starfive_hmac_sha224_init_tfm,
.base.exit_tfm = starfive_hash_exit_tfm,
.base.setkey = starfive_hash_setkey,
.base.halg = {
.digestsize = SHA224_DIGEST_SIZE,
.statesize = sizeof(struct sha256_state),
.base = {
@ -665,18 +662,21 @@ static struct ahash_alg algs_sha2_sm3[] = {
.cra_alignmask = 3,
.cra_module = THIS_MODULE,
}
}
},
.op = {
.do_one_request = starfive_hash_one_request,
},
}, {
.init = starfive_hash_init,
.update = starfive_hash_update,
.final = starfive_hash_final,
.finup = starfive_hash_finup,
.digest = starfive_hash_digest,
.export = starfive_hash_export,
.import = starfive_hash_import,
.init_tfm = starfive_sha256_init_tfm,
.exit_tfm = starfive_hash_exit_tfm,
.halg = {
.base.init = starfive_hash_init,
.base.update = starfive_hash_update,
.base.final = starfive_hash_final,
.base.finup = starfive_hash_finup,
.base.digest = starfive_hash_digest,
.base.export = starfive_hash_export,
.base.import = starfive_hash_import,
.base.init_tfm = starfive_sha256_init_tfm,
.base.exit_tfm = starfive_hash_exit_tfm,
.base.halg = {
.digestsize = SHA256_DIGEST_SIZE,
.statesize = sizeof(struct sha256_state),
.base = {
@ -691,19 +691,22 @@ static struct ahash_alg algs_sha2_sm3[] = {
.cra_alignmask = 3,
.cra_module = THIS_MODULE,
}
}
},
.op = {
.do_one_request = starfive_hash_one_request,
},
}, {
.init = starfive_hash_init,
.update = starfive_hash_update,
.final = starfive_hash_final,
.finup = starfive_hash_finup,
.digest = starfive_hash_digest,
.export = starfive_hash_export,
.import = starfive_hash_import,
.init_tfm = starfive_hmac_sha256_init_tfm,
.exit_tfm = starfive_hash_exit_tfm,
.setkey = starfive_hash_setkey,
.halg = {
.base.init = starfive_hash_init,
.base.update = starfive_hash_update,
.base.final = starfive_hash_final,
.base.finup = starfive_hash_finup,
.base.digest = starfive_hash_digest,
.base.export = starfive_hash_export,
.base.import = starfive_hash_import,
.base.init_tfm = starfive_hmac_sha256_init_tfm,
.base.exit_tfm = starfive_hash_exit_tfm,
.base.setkey = starfive_hash_setkey,
.base.halg = {
.digestsize = SHA256_DIGEST_SIZE,
.statesize = sizeof(struct sha256_state),
.base = {
@ -718,18 +721,21 @@ static struct ahash_alg algs_sha2_sm3[] = {
.cra_alignmask = 3,
.cra_module = THIS_MODULE,
}
}
},
.op = {
.do_one_request = starfive_hash_one_request,
},
}, {
.init = starfive_hash_init,
.update = starfive_hash_update,
.final = starfive_hash_final,
.finup = starfive_hash_finup,
.digest = starfive_hash_digest,
.export = starfive_hash_export,
.import = starfive_hash_import,
.init_tfm = starfive_sha384_init_tfm,
.exit_tfm = starfive_hash_exit_tfm,
.halg = {
.base.init = starfive_hash_init,
.base.update = starfive_hash_update,
.base.final = starfive_hash_final,
.base.finup = starfive_hash_finup,
.base.digest = starfive_hash_digest,
.base.export = starfive_hash_export,
.base.import = starfive_hash_import,
.base.init_tfm = starfive_sha384_init_tfm,
.base.exit_tfm = starfive_hash_exit_tfm,
.base.halg = {
.digestsize = SHA384_DIGEST_SIZE,
.statesize = sizeof(struct sha512_state),
.base = {
@ -744,19 +750,22 @@ static struct ahash_alg algs_sha2_sm3[] = {
.cra_alignmask = 3,
.cra_module = THIS_MODULE,
}
}
},
.op = {
.do_one_request = starfive_hash_one_request,
},
}, {
.init = starfive_hash_init,
.update = starfive_hash_update,
.final = starfive_hash_final,
.finup = starfive_hash_finup,
.digest = starfive_hash_digest,
.export = starfive_hash_export,
.import = starfive_hash_import,
.init_tfm = starfive_hmac_sha384_init_tfm,
.exit_tfm = starfive_hash_exit_tfm,
.setkey = starfive_hash_setkey,
.halg = {
.base.init = starfive_hash_init,
.base.update = starfive_hash_update,
.base.final = starfive_hash_final,
.base.finup = starfive_hash_finup,
.base.digest = starfive_hash_digest,
.base.export = starfive_hash_export,
.base.import = starfive_hash_import,
.base.init_tfm = starfive_hmac_sha384_init_tfm,
.base.exit_tfm = starfive_hash_exit_tfm,
.base.setkey = starfive_hash_setkey,
.base.halg = {
.digestsize = SHA384_DIGEST_SIZE,
.statesize = sizeof(struct sha512_state),
.base = {
@ -771,18 +780,21 @@ static struct ahash_alg algs_sha2_sm3[] = {
.cra_alignmask = 3,
.cra_module = THIS_MODULE,
}
}
},
.op = {
.do_one_request = starfive_hash_one_request,
},
}, {
.init = starfive_hash_init,
.update = starfive_hash_update,
.final = starfive_hash_final,
.finup = starfive_hash_finup,
.digest = starfive_hash_digest,
.export = starfive_hash_export,
.import = starfive_hash_import,
.init_tfm = starfive_sha512_init_tfm,
.exit_tfm = starfive_hash_exit_tfm,
.halg = {
.base.init = starfive_hash_init,
.base.update = starfive_hash_update,
.base.final = starfive_hash_final,
.base.finup = starfive_hash_finup,
.base.digest = starfive_hash_digest,
.base.export = starfive_hash_export,
.base.import = starfive_hash_import,
.base.init_tfm = starfive_sha512_init_tfm,
.base.exit_tfm = starfive_hash_exit_tfm,
.base.halg = {
.digestsize = SHA512_DIGEST_SIZE,
.statesize = sizeof(struct sha512_state),
.base = {
@ -797,19 +809,22 @@ static struct ahash_alg algs_sha2_sm3[] = {
.cra_alignmask = 3,
.cra_module = THIS_MODULE,
}
}
},
.op = {
.do_one_request = starfive_hash_one_request,
},
}, {
.init = starfive_hash_init,
.update = starfive_hash_update,
.final = starfive_hash_final,
.finup = starfive_hash_finup,
.digest = starfive_hash_digest,
.export = starfive_hash_export,
.import = starfive_hash_import,
.init_tfm = starfive_hmac_sha512_init_tfm,
.exit_tfm = starfive_hash_exit_tfm,
.setkey = starfive_hash_setkey,
.halg = {
.base.init = starfive_hash_init,
.base.update = starfive_hash_update,
.base.final = starfive_hash_final,
.base.finup = starfive_hash_finup,
.base.digest = starfive_hash_digest,
.base.export = starfive_hash_export,
.base.import = starfive_hash_import,
.base.init_tfm = starfive_hmac_sha512_init_tfm,
.base.exit_tfm = starfive_hash_exit_tfm,
.base.setkey = starfive_hash_setkey,
.base.halg = {
.digestsize = SHA512_DIGEST_SIZE,
.statesize = sizeof(struct sha512_state),
.base = {
@ -824,18 +839,21 @@ static struct ahash_alg algs_sha2_sm3[] = {
.cra_alignmask = 3,
.cra_module = THIS_MODULE,
}
}
},
.op = {
.do_one_request = starfive_hash_one_request,
},
}, {
.init = starfive_hash_init,
.update = starfive_hash_update,
.final = starfive_hash_final,
.finup = starfive_hash_finup,
.digest = starfive_hash_digest,
.export = starfive_hash_export,
.import = starfive_hash_import,
.init_tfm = starfive_sm3_init_tfm,
.exit_tfm = starfive_hash_exit_tfm,
.halg = {
.base.init = starfive_hash_init,
.base.update = starfive_hash_update,
.base.final = starfive_hash_final,
.base.finup = starfive_hash_finup,
.base.digest = starfive_hash_digest,
.base.export = starfive_hash_export,
.base.import = starfive_hash_import,
.base.init_tfm = starfive_sm3_init_tfm,
.base.exit_tfm = starfive_hash_exit_tfm,
.base.halg = {
.digestsize = SM3_DIGEST_SIZE,
.statesize = sizeof(struct sm3_state),
.base = {
@ -850,19 +868,22 @@ static struct ahash_alg algs_sha2_sm3[] = {
.cra_alignmask = 3,
.cra_module = THIS_MODULE,
}
}
},
.op = {
.do_one_request = starfive_hash_one_request,
},
}, {
.init = starfive_hash_init,
.update = starfive_hash_update,
.final = starfive_hash_final,
.finup = starfive_hash_finup,
.digest = starfive_hash_digest,
.export = starfive_hash_export,
.import = starfive_hash_import,
.init_tfm = starfive_hmac_sm3_init_tfm,
.exit_tfm = starfive_hash_exit_tfm,
.setkey = starfive_hash_setkey,
.halg = {
.base.init = starfive_hash_init,
.base.update = starfive_hash_update,
.base.final = starfive_hash_final,
.base.finup = starfive_hash_finup,
.base.digest = starfive_hash_digest,
.base.export = starfive_hash_export,
.base.import = starfive_hash_import,
.base.init_tfm = starfive_hmac_sm3_init_tfm,
.base.exit_tfm = starfive_hash_exit_tfm,
.base.setkey = starfive_hash_setkey,
.base.halg = {
.digestsize = SM3_DIGEST_SIZE,
.statesize = sizeof(struct sm3_state),
.base = {
@ -877,16 +898,19 @@ static struct ahash_alg algs_sha2_sm3[] = {
.cra_alignmask = 3,
.cra_module = THIS_MODULE,
}
}
},
.op = {
.do_one_request = starfive_hash_one_request,
},
},
};
int starfive_hash_register_algs(void)
{
return crypto_register_ahashes(algs_sha2_sm3, ARRAY_SIZE(algs_sha2_sm3));
return crypto_engine_register_ahashes(algs_sha2_sm3, ARRAY_SIZE(algs_sha2_sm3));
}
void starfive_hash_unregister_algs(void)
{
crypto_unregister_ahashes(algs_sha2_sm3, ARRAY_SIZE(algs_sha2_sm3));
crypto_engine_unregister_ahashes(algs_sha2_sm3, ARRAY_SIZE(algs_sha2_sm3));
}