Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-11-10 22:21:40 +00:00
Code Issues Packages Projects Releases Wiki Activity

crypto: aspeed - 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:54:57 +08:00
parent 4dd4d5e486
commit 304506f299
5 changed files with 202 additions and 105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
drivers/crypto/aspeed/aspeed-acry.c
View File

@ -2,25 +2,26 @@
/* /*
* Copyright 2021 Aspeed Technology Inc. * Copyright 2021 Aspeed Technology Inc.
*/ */
#include <crypto/akcipher.h>
#include <crypto/algapi.h>
#include <crypto/engine.h> #include <crypto/engine.h>
#include <crypto/internal/akcipher.h> #include <crypto/internal/akcipher.h>
#include <crypto/internal/rsa.h> #include <crypto/internal/rsa.h>
#include <crypto/scatterwalk.h> #include <crypto/scatterwalk.h>
#include <linux/clk.h> #include <linux/clk.h>
#include <linux/platform_device.h> #include <linux/count_zeros.h>
#include <linux/dma-mapping.h>
#include <linux/err.h>
#include <linux/interrupt.h>
#include <linux/kernel.h>
#include <linux/mfd/syscon.h>
#include <linux/module.h> #include <linux/module.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/of.h> #include <linux/of.h>
#include <linux/of_device.h> #include <linux/of_device.h>
#include <linux/mfd/syscon.h> #include <linux/of_address.h>
#include <linux/interrupt.h> #include <linux/of_irq.h>
#include <linux/count_zeros.h> #include <linux/platform_device.h>
#include <linux/err.h>
#include <linux/dma-mapping.h>
#include <linux/regmap.h> #include <linux/regmap.h>
#include <linux/slab.h>
#include <linux/string.h>
#ifdef CONFIG_CRYPTO_DEV_ASPEED_DEBUG #ifdef CONFIG_CRYPTO_DEV_ASPEED_DEBUG
#define ACRY_DBG(d, fmt, ...) \ #define ACRY_DBG(d, fmt, ...) \
@ -112,7 +113,6 @@ struct aspeed_acry_dev {
}; };
struct aspeed_acry_ctx { struct aspeed_acry_ctx {
struct crypto_engine_ctx enginectx;
struct aspeed_acry_dev *acry_dev; struct aspeed_acry_dev *acry_dev;
struct rsa_key key; struct rsa_key key;
@ -131,7 +131,7 @@ struct aspeed_acry_ctx {
struct aspeed_acry_alg { struct aspeed_acry_alg {
struct aspeed_acry_dev *acry_dev; struct aspeed_acry_dev *acry_dev;
struct akcipher_alg akcipher; struct akcipher_engine_alg akcipher;
}; };
enum aspeed_rsa_key_mode { enum aspeed_rsa_key_mode {
@ -577,7 +577,7 @@ static int aspeed_acry_rsa_init_tfm(struct crypto_akcipher *tfm)
const char *name = crypto_tfm_alg_name(&tfm->base); const char *name = crypto_tfm_alg_name(&tfm->base);
struct aspeed_acry_alg *acry_alg; struct aspeed_acry_alg *acry_alg;
acry_alg = container_of(alg, struct aspeed_acry_alg, akcipher); acry_alg = container_of(alg, struct aspeed_acry_alg, akcipher.base);
ctx->acry_dev = acry_alg->acry_dev; ctx->acry_dev = acry_alg->acry_dev;
@ -589,8 +589,6 @@ static int aspeed_acry_rsa_init_tfm(struct crypto_akcipher *tfm)
return PTR_ERR(ctx->fallback_tfm); return PTR_ERR(ctx->fallback_tfm);
} }
ctx->enginectx.op.do_one_request = aspeed_acry_do_request;
return 0; return 0;
} }
@ -603,7 +601,7 @@ static void aspeed_acry_rsa_exit_tfm(struct crypto_akcipher *tfm)
static struct aspeed_acry_alg aspeed_acry_akcipher_algs[] = { static struct aspeed_acry_alg aspeed_acry_akcipher_algs[] = {
{ {
.akcipher = { .akcipher.base = {
.encrypt = aspeed_acry_rsa_enc, .encrypt = aspeed_acry_rsa_enc,
.decrypt = aspeed_acry_rsa_dec, .decrypt = aspeed_acry_rsa_dec,
.sign = aspeed_acry_rsa_dec, .sign = aspeed_acry_rsa_dec,
@ -625,6 +623,9 @@ static struct aspeed_acry_alg aspeed_acry_akcipher_algs[] = {
.cra_ctxsize = sizeof(struct aspeed_acry_ctx), .cra_ctxsize = sizeof(struct aspeed_acry_ctx),
}, },
}, },
.akcipher.op = {
.do_one_request = aspeed_acry_do_request,
},
}, },
}; };
@ -634,10 +635,10 @@ static void aspeed_acry_register(struct aspeed_acry_dev *acry_dev)
for (i = 0; i < ARRAY_SIZE(aspeed_acry_akcipher_algs); i++) { for (i = 0; i < ARRAY_SIZE(aspeed_acry_akcipher_algs); i++) {
aspeed_acry_akcipher_algs[i].acry_dev = acry_dev; aspeed_acry_akcipher_algs[i].acry_dev = acry_dev;
rc = crypto_register_akcipher(&aspeed_acry_akcipher_algs[i].akcipher); rc = crypto_engine_register_akcipher(&aspeed_acry_akcipher_algs[i].akcipher);
if (rc) { if (rc) {
ACRY_DBG(acry_dev, "Failed to register %s\n", ACRY_DBG(acry_dev, "Failed to register %s\n",
aspeed_acry_akcipher_algs[i].akcipher.base.cra_name); aspeed_acry_akcipher_algs[i].akcipher.base.base.cra_name);
} }
} }
} }
@ -647,7 +648,7 @@ static void aspeed_acry_unregister(struct aspeed_acry_dev *acry_dev)
int i; int i;
for (i = 0; i < ARRAY_SIZE(aspeed_acry_akcipher_algs); i++) for (i = 0; i < ARRAY_SIZE(aspeed_acry_akcipher_algs); i++)
crypto_unregister_akcipher(&aspeed_acry_akcipher_algs[i].akcipher); crypto_engine_unregister_akcipher(&aspeed_acry_akcipher_algs[i].akcipher);
} }
/* ACRY interrupt service routine. */ /* ACRY interrupt service routine. */

132
drivers/crypto/aspeed/aspeed-hace-crypto.c
View File

@ -4,6 +4,17 @@
*/ */
#include "aspeed-hace.h" #include "aspeed-hace.h"
#include <crypto/des.h>
#include <crypto/engine.h>
#include <crypto/internal/des.h>
#include <crypto/internal/skcipher.h>
#include <linux/dma-mapping.h>
#include <linux/err.h>
#include <linux/io.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/scatterlist.h>
#include <linux/string.h>
#ifdef CONFIG_CRYPTO_DEV_ASPEED_HACE_CRYPTO_DEBUG #ifdef CONFIG_CRYPTO_DEV_ASPEED_HACE_CRYPTO_DEBUG
#define CIPHER_DBG(h, fmt, ...) \ #define CIPHER_DBG(h, fmt, ...) \
@ -696,7 +707,7 @@ static int aspeed_crypto_cra_init(struct crypto_skcipher *tfm)
struct aspeed_hace_alg *crypto_alg; struct aspeed_hace_alg *crypto_alg;
crypto_alg = container_of(alg, struct aspeed_hace_alg, alg.skcipher); crypto_alg = container_of(alg, struct aspeed_hace_alg, alg.skcipher.base);
ctx->hace_dev = crypto_alg->hace_dev; ctx->hace_dev = crypto_alg->hace_dev;
ctx->start = aspeed_hace_skcipher_trigger; ctx->start = aspeed_hace_skcipher_trigger;
@ -713,8 +724,6 @@ static int aspeed_crypto_cra_init(struct crypto_skcipher *tfm)
crypto_skcipher_set_reqsize(tfm, sizeof(struct aspeed_cipher_reqctx) + crypto_skcipher_set_reqsize(tfm, sizeof(struct aspeed_cipher_reqctx) +
crypto_skcipher_reqsize(ctx->fallback_tfm)); crypto_skcipher_reqsize(ctx->fallback_tfm));
ctx->enginectx.op.do_one_request = aspeed_crypto_do_request;
return 0; return 0;
} }
@ -729,7 +738,7 @@ static void aspeed_crypto_cra_exit(struct crypto_skcipher *tfm)
static struct aspeed_hace_alg aspeed_crypto_algs[] = { static struct aspeed_hace_alg aspeed_crypto_algs[] = {
{ {
.alg.skcipher = { .alg.skcipher.base = {
.min_keysize = AES_MIN_KEY_SIZE, .min_keysize = AES_MIN_KEY_SIZE,
.max_keysize = AES_MAX_KEY_SIZE, .max_keysize = AES_MAX_KEY_SIZE,
.setkey = aspeed_aes_setkey, .setkey = aspeed_aes_setkey,
@ -749,10 +758,13 @@ static struct aspeed_hace_alg aspeed_crypto_algs[] = {
.cra_alignmask = 0x0f, .cra_alignmask = 0x0f,
.cra_module = THIS_MODULE, .cra_module = THIS_MODULE,
} }
} },
.alg.skcipher.op = {
.do_one_request = aspeed_crypto_do_request,
},
}, },
{ {
.alg.skcipher = { .alg.skcipher.base = {
.ivsize = AES_BLOCK_SIZE, .ivsize = AES_BLOCK_SIZE,
.min_keysize = AES_MIN_KEY_SIZE, .min_keysize = AES_MIN_KEY_SIZE,
.max_keysize = AES_MAX_KEY_SIZE, .max_keysize = AES_MAX_KEY_SIZE,
@ -773,10 +785,13 @@ static struct aspeed_hace_alg aspeed_crypto_algs[] = {
.cra_alignmask = 0x0f, .cra_alignmask = 0x0f,
.cra_module = THIS_MODULE, .cra_module = THIS_MODULE,
} }
} },
.alg.skcipher.op = {
.do_one_request = aspeed_crypto_do_request,
},
}, },
{ {
.alg.skcipher = { .alg.skcipher.base = {
.ivsize = AES_BLOCK_SIZE, .ivsize = AES_BLOCK_SIZE,
.min_keysize = AES_MIN_KEY_SIZE, .min_keysize = AES_MIN_KEY_SIZE,
.max_keysize = AES_MAX_KEY_SIZE, .max_keysize = AES_MAX_KEY_SIZE,
@ -797,10 +812,13 @@ static struct aspeed_hace_alg aspeed_crypto_algs[] = {
.cra_alignmask = 0x0f, .cra_alignmask = 0x0f,
.cra_module = THIS_MODULE, .cra_module = THIS_MODULE,
} }
} },
.alg.skcipher.op = {
.do_one_request = aspeed_crypto_do_request,
},
}, },
{ {
.alg.skcipher = { .alg.skcipher.base = {
.ivsize = AES_BLOCK_SIZE, .ivsize = AES_BLOCK_SIZE,
.min_keysize = AES_MIN_KEY_SIZE, .min_keysize = AES_MIN_KEY_SIZE,
.max_keysize = AES_MAX_KEY_SIZE, .max_keysize = AES_MAX_KEY_SIZE,
@ -821,10 +839,13 @@ static struct aspeed_hace_alg aspeed_crypto_algs[] = {
.cra_alignmask = 0x0f, .cra_alignmask = 0x0f,
.cra_module = THIS_MODULE, .cra_module = THIS_MODULE,
} }
} },
.alg.skcipher.op = {
.do_one_request = aspeed_crypto_do_request,
},
}, },
{ {
.alg.skcipher = { .alg.skcipher.base = {
.min_keysize = DES_KEY_SIZE, .min_keysize = DES_KEY_SIZE,
.max_keysize = DES_KEY_SIZE, .max_keysize = DES_KEY_SIZE,
.setkey = aspeed_des_setkey, .setkey = aspeed_des_setkey,
@ -844,10 +865,13 @@ static struct aspeed_hace_alg aspeed_crypto_algs[] = {
.cra_alignmask = 0x0f, .cra_alignmask = 0x0f,
.cra_module = THIS_MODULE, .cra_module = THIS_MODULE,
} }
} },
.alg.skcipher.op = {
.do_one_request = aspeed_crypto_do_request,
},
}, },
{ {
.alg.skcipher = { .alg.skcipher.base = {
.ivsize = DES_BLOCK_SIZE, .ivsize = DES_BLOCK_SIZE,
.min_keysize = DES_KEY_SIZE, .min_keysize = DES_KEY_SIZE,
.max_keysize = DES_KEY_SIZE, .max_keysize = DES_KEY_SIZE,
@ -868,10 +892,13 @@ static struct aspeed_hace_alg aspeed_crypto_algs[] = {
.cra_alignmask = 0x0f, .cra_alignmask = 0x0f,
.cra_module = THIS_MODULE, .cra_module = THIS_MODULE,
} }
} },
.alg.skcipher.op = {
.do_one_request = aspeed_crypto_do_request,
},
}, },
{ {
.alg.skcipher = { .alg.skcipher.base = {
.ivsize = DES_BLOCK_SIZE, .ivsize = DES_BLOCK_SIZE,
.min_keysize = DES_KEY_SIZE, .min_keysize = DES_KEY_SIZE,
.max_keysize = DES_KEY_SIZE, .max_keysize = DES_KEY_SIZE,
@ -892,10 +919,13 @@ static struct aspeed_hace_alg aspeed_crypto_algs[] = {
.cra_alignmask = 0x0f, .cra_alignmask = 0x0f,
.cra_module = THIS_MODULE, .cra_module = THIS_MODULE,
} }
} },
.alg.skcipher.op = {
.do_one_request = aspeed_crypto_do_request,
},
}, },
{ {
.alg.skcipher = { .alg.skcipher.base = {
.ivsize = DES_BLOCK_SIZE, .ivsize = DES_BLOCK_SIZE,
.min_keysize = DES_KEY_SIZE, .min_keysize = DES_KEY_SIZE,
.max_keysize = DES_KEY_SIZE, .max_keysize = DES_KEY_SIZE,
@ -916,10 +946,13 @@ static struct aspeed_hace_alg aspeed_crypto_algs[] = {
.cra_alignmask = 0x0f, .cra_alignmask = 0x0f,
.cra_module = THIS_MODULE, .cra_module = THIS_MODULE,
} }
} },
.alg.skcipher.op = {
.do_one_request = aspeed_crypto_do_request,
},
}, },
{ {
.alg.skcipher = { .alg.skcipher.base = {
.min_keysize = DES3_EDE_KEY_SIZE, .min_keysize = DES3_EDE_KEY_SIZE,
.max_keysize = DES3_EDE_KEY_SIZE, .max_keysize = DES3_EDE_KEY_SIZE,
.setkey = aspeed_des_setkey, .setkey = aspeed_des_setkey,
@ -939,10 +972,13 @@ static struct aspeed_hace_alg aspeed_crypto_algs[] = {
.cra_alignmask = 0x0f, .cra_alignmask = 0x0f,
.cra_module = THIS_MODULE, .cra_module = THIS_MODULE,
} }
} },
.alg.skcipher.op = {
.do_one_request = aspeed_crypto_do_request,
},
}, },
{ {
.alg.skcipher = { .alg.skcipher.base = {
.ivsize = DES_BLOCK_SIZE, .ivsize = DES_BLOCK_SIZE,
.min_keysize = DES3_EDE_KEY_SIZE, .min_keysize = DES3_EDE_KEY_SIZE,
.max_keysize = DES3_EDE_KEY_SIZE, .max_keysize = DES3_EDE_KEY_SIZE,
@ -963,10 +999,13 @@ static struct aspeed_hace_alg aspeed_crypto_algs[] = {
.cra_alignmask = 0x0f, .cra_alignmask = 0x0f,
.cra_module = THIS_MODULE, .cra_module = THIS_MODULE,
} }
} },
.alg.skcipher.op = {
.do_one_request = aspeed_crypto_do_request,
},
}, },
{ {
.alg.skcipher = { .alg.skcipher.base = {
.ivsize = DES_BLOCK_SIZE, .ivsize = DES_BLOCK_SIZE,
.min_keysize = DES3_EDE_KEY_SIZE, .min_keysize = DES3_EDE_KEY_SIZE,
.max_keysize = DES3_EDE_KEY_SIZE, .max_keysize = DES3_EDE_KEY_SIZE,
@ -987,10 +1026,13 @@ static struct aspeed_hace_alg aspeed_crypto_algs[] = {
.cra_alignmask = 0x0f, .cra_alignmask = 0x0f,
.cra_module = THIS_MODULE, .cra_module = THIS_MODULE,
} }
} },
.alg.skcipher.op = {
.do_one_request = aspeed_crypto_do_request,
},
}, },
{ {
.alg.skcipher = { .alg.skcipher.base = {
.ivsize = DES_BLOCK_SIZE, .ivsize = DES_BLOCK_SIZE,
.min_keysize = DES3_EDE_KEY_SIZE, .min_keysize = DES3_EDE_KEY_SIZE,
.max_keysize = DES3_EDE_KEY_SIZE, .max_keysize = DES3_EDE_KEY_SIZE,
@ -1011,13 +1053,16 @@ static struct aspeed_hace_alg aspeed_crypto_algs[] = {
.cra_alignmask = 0x0f, .cra_alignmask = 0x0f,
.cra_module = THIS_MODULE, .cra_module = THIS_MODULE,
} }
} },
.alg.skcipher.op = {
.do_one_request = aspeed_crypto_do_request,
},
}, },
}; };
static struct aspeed_hace_alg aspeed_crypto_algs_g6[] = { static struct aspeed_hace_alg aspeed_crypto_algs_g6[] = {
{ {
.alg.skcipher = { .alg.skcipher.base = {
.ivsize = AES_BLOCK_SIZE, .ivsize = AES_BLOCK_SIZE,
.min_keysize = AES_MIN_KEY_SIZE, .min_keysize = AES_MIN_KEY_SIZE,
.max_keysize = AES_MAX_KEY_SIZE, .max_keysize = AES_MAX_KEY_SIZE,
@ -1037,10 +1082,13 @@ static struct aspeed_hace_alg aspeed_crypto_algs_g6[] = {
.cra_alignmask = 0x0f, .cra_alignmask = 0x0f,
.cra_module = THIS_MODULE, .cra_module = THIS_MODULE,
} }
} },
.alg.skcipher.op = {
.do_one_request = aspeed_crypto_do_request,
},
}, },
{ {
.alg.skcipher = { .alg.skcipher.base = {
.ivsize = DES_BLOCK_SIZE, .ivsize = DES_BLOCK_SIZE,
.min_keysize = DES_KEY_SIZE, .min_keysize = DES_KEY_SIZE,
.max_keysize = DES_KEY_SIZE, .max_keysize = DES_KEY_SIZE,
@ -1060,10 +1108,13 @@ static struct aspeed_hace_alg aspeed_crypto_algs_g6[] = {
.cra_alignmask = 0x0f, .cra_alignmask = 0x0f,
.cra_module = THIS_MODULE, .cra_module = THIS_MODULE,
} }
} },
.alg.skcipher.op = {
.do_one_request = aspeed_crypto_do_request,
},
}, },
{ {
.alg.skcipher = { .alg.skcipher.base = {
.ivsize = DES_BLOCK_SIZE, .ivsize = DES_BLOCK_SIZE,
.min_keysize = DES3_EDE_KEY_SIZE, .min_keysize = DES3_EDE_KEY_SIZE,
.max_keysize = DES3_EDE_KEY_SIZE, .max_keysize = DES3_EDE_KEY_SIZE,
@ -1083,7 +1134,10 @@ static struct aspeed_hace_alg aspeed_crypto_algs_g6[] = {
.cra_alignmask = 0x0f, .cra_alignmask = 0x0f,
.cra_module = THIS_MODULE, .cra_module = THIS_MODULE,
} }
} },
.alg.skcipher.op = {
.do_one_request = aspeed_crypto_do_request,
},
}, },
}; };
@ -1093,13 +1147,13 @@ void aspeed_unregister_hace_crypto_algs(struct aspeed_hace_dev *hace_dev)
int i; int i;
for (i = 0; i < ARRAY_SIZE(aspeed_crypto_algs); i++) for (i = 0; i < ARRAY_SIZE(aspeed_crypto_algs); i++)
crypto_unregister_skcipher(&aspeed_crypto_algs[i].alg.skcipher); crypto_engine_unregister_skcipher(&aspeed_crypto_algs[i].alg.skcipher);
if (hace_dev->version != AST2600_VERSION) if (hace_dev->version != AST2600_VERSION)
return; return;
for (i = 0; i < ARRAY_SIZE(aspeed_crypto_algs_g6); i++) for (i = 0; i < ARRAY_SIZE(aspeed_crypto_algs_g6); i++)
crypto_unregister_skcipher(&aspeed_crypto_algs_g6[i].alg.skcipher); crypto_engine_unregister_skcipher(&aspeed_crypto_algs_g6[i].alg.skcipher);
} }
void aspeed_register_hace_crypto_algs(struct aspeed_hace_dev *hace_dev) void aspeed_register_hace_crypto_algs(struct aspeed_hace_dev *hace_dev)
@ -1110,10 +1164,10 @@ void aspeed_register_hace_crypto_algs(struct aspeed_hace_dev *hace_dev)
for (i = 0; i < ARRAY_SIZE(aspeed_crypto_algs); i++) { for (i = 0; i < ARRAY_SIZE(aspeed_crypto_algs); i++) {
aspeed_crypto_algs[i].hace_dev = hace_dev; aspeed_crypto_algs[i].hace_dev = hace_dev;
rc = crypto_register_skcipher(&aspeed_crypto_algs[i].alg.skcipher); rc = crypto_engine_register_skcipher(&aspeed_crypto_algs[i].alg.skcipher);
if (rc) { if (rc) {
CIPHER_DBG(hace_dev, "Failed to register %s\n", CIPHER_DBG(hace_dev, "Failed to register %s\n",
aspeed_crypto_algs[i].alg.skcipher.base.cra_name); aspeed_crypto_algs[i].alg.skcipher.base.base.cra_name);
} }
} }
@ -1122,10 +1176,10 @@ void aspeed_register_hace_crypto_algs(struct aspeed_hace_dev *hace_dev)
for (i = 0; i < ARRAY_SIZE(aspeed_crypto_algs_g6); i++) { for (i = 0; i < ARRAY_SIZE(aspeed_crypto_algs_g6); i++) {
aspeed_crypto_algs_g6[i].hace_dev = hace_dev; aspeed_crypto_algs_g6[i].hace_dev = hace_dev;
rc = crypto_register_skcipher(&aspeed_crypto_algs_g6[i].alg.skcipher); rc = crypto_engine_register_skcipher(&aspeed_crypto_algs_g6[i].alg.skcipher);
if (rc) { if (rc) {
CIPHER_DBG(hace_dev, "Failed to register %s\n", CIPHER_DBG(hace_dev, "Failed to register %s\n",
aspeed_crypto_algs_g6[i].alg.skcipher.base.cra_name); aspeed_crypto_algs_g6[i].alg.skcipher.base.base.cra_name);
} }
} }
} }

97
drivers/crypto/aspeed/aspeed-hace-hash.c
View File

@ -4,6 +4,17 @@
*/ */
#include "aspeed-hace.h" #include "aspeed-hace.h"
#include <crypto/engine.h>
#include <crypto/hmac.h>
#include <crypto/internal/hash.h>
#include <crypto/scatterwalk.h>
#include <crypto/sha1.h>
#include <crypto/sha2.h>
#include <linux/dma-mapping.h>
#include <linux/err.h>
#include <linux/io.h>
#include <linux/kernel.h>
#include <linux/string.h>
#ifdef CONFIG_CRYPTO_DEV_ASPEED_DEBUG #ifdef CONFIG_CRYPTO_DEV_ASPEED_DEBUG
#define AHASH_DBG(h, fmt, ...) \ #define AHASH_DBG(h, fmt, ...) \
@ -858,7 +869,7 @@ static int aspeed_sham_cra_init(struct crypto_tfm *tfm)
struct aspeed_sham_ctx *tctx = crypto_tfm_ctx(tfm); struct aspeed_sham_ctx *tctx = crypto_tfm_ctx(tfm);
struct aspeed_hace_alg *ast_alg; struct aspeed_hace_alg *ast_alg;
ast_alg = container_of(alg, struct aspeed_hace_alg, alg.ahash); ast_alg = container_of(alg, struct aspeed_hace_alg, alg.ahash.base);
tctx->hace_dev = ast_alg->hace_dev; tctx->hace_dev = ast_alg->hace_dev;
tctx->flags = 0; tctx->flags = 0;
@ -880,8 +891,6 @@ static int aspeed_sham_cra_init(struct crypto_tfm *tfm)
} }
} }
tctx->enginectx.op.do_one_request = aspeed_ahash_do_one;
return 0; return 0;
} }
@ -919,7 +928,7 @@ static int aspeed_sham_import(struct ahash_request *req, const void *in)
static struct aspeed_hace_alg aspeed_ahash_algs[] = { static struct aspeed_hace_alg aspeed_ahash_algs[] = {
{ {
.alg.ahash = { .alg.ahash.base = {
.init = aspeed_sham_init, .init = aspeed_sham_init,
.update = aspeed_sham_update, .update = aspeed_sham_update,
.final = aspeed_sham_final, .final = aspeed_sham_final,
@ -946,9 +955,12 @@ static struct aspeed_hace_alg aspeed_ahash_algs[] = {
} }
} }
}, },
.alg.ahash.op = {
.do_one_request = aspeed_ahash_do_one,
},
}, },
{ {
.alg.ahash = { .alg.ahash.base = {
.init = aspeed_sham_init, .init = aspeed_sham_init,
.update = aspeed_sham_update, .update = aspeed_sham_update,
.final = aspeed_sham_final, .final = aspeed_sham_final,
@ -975,9 +987,12 @@ static struct aspeed_hace_alg aspeed_ahash_algs[] = {
} }
} }
}, },
.alg.ahash.op = {
.do_one_request = aspeed_ahash_do_one,
},
}, },
{ {
.alg.ahash = { .alg.ahash.base = {
.init = aspeed_sham_init, .init = aspeed_sham_init,
.update = aspeed_sham_update, .update = aspeed_sham_update,
.final = aspeed_sham_final, .final = aspeed_sham_final,
@ -1004,10 +1019,13 @@ static struct aspeed_hace_alg aspeed_ahash_algs[] = {
} }
} }
}, },
.alg.ahash.op = {
.do_one_request = aspeed_ahash_do_one,
},
}, },
{ {
.alg_base = "sha1", .alg_base = "sha1",
.alg.ahash = { .alg.ahash.base = {
.init = aspeed_sham_init, .init = aspeed_sham_init,
.update = aspeed_sham_update, .update = aspeed_sham_update,
.final = aspeed_sham_final, .final = aspeed_sham_final,
@ -1036,10 +1054,13 @@ static struct aspeed_hace_alg aspeed_ahash_algs[] = {
} }
} }
}, },
.alg.ahash.op = {
.do_one_request = aspeed_ahash_do_one,
},
}, },
{ {
.alg_base = "sha224", .alg_base = "sha224",
.alg.ahash = { .alg.ahash.base = {
.init = aspeed_sham_init, .init = aspeed_sham_init,
.update = aspeed_sham_update, .update = aspeed_sham_update,
.final = aspeed_sham_final, .final = aspeed_sham_final,
@ -1068,10 +1089,13 @@ static struct aspeed_hace_alg aspeed_ahash_algs[] = {
} }
} }
}, },
.alg.ahash.op = {
.do_one_request = aspeed_ahash_do_one,
},
}, },
{ {
.alg_base = "sha256", .alg_base = "sha256",
.alg.ahash = { .alg.ahash.base = {
.init = aspeed_sham_init, .init = aspeed_sham_init,
.update = aspeed_sham_update, .update = aspeed_sham_update,
.final = aspeed_sham_final, .final = aspeed_sham_final,
@ -1100,12 +1124,15 @@ static struct aspeed_hace_alg aspeed_ahash_algs[] = {
} }
} }
}, },
.alg.ahash.op = {
.do_one_request = aspeed_ahash_do_one,
},
}, },
}; };
static struct aspeed_hace_alg aspeed_ahash_algs_g6[] = { static struct aspeed_hace_alg aspeed_ahash_algs_g6[] = {
{ {
.alg.ahash = { .alg.ahash.base = {
.init = aspeed_sham_init, .init = aspeed_sham_init,
.update = aspeed_sham_update, .update = aspeed_sham_update,
.final = aspeed_sham_final, .final = aspeed_sham_final,
@ -1132,9 +1159,12 @@ static struct aspeed_hace_alg aspeed_ahash_algs_g6[] = {
} }
} }
}, },
.alg.ahash.op = {
.do_one_request = aspeed_ahash_do_one,
},
}, },
{ {
.alg.ahash = { .alg.ahash.base = {
.init = aspeed_sham_init, .init = aspeed_sham_init,
.update = aspeed_sham_update, .update = aspeed_sham_update,
.final = aspeed_sham_final, .final = aspeed_sham_final,
@ -1161,9 +1191,12 @@ static struct aspeed_hace_alg aspeed_ahash_algs_g6[] = {
} }
} }
}, },
.alg.ahash.op = {
.do_one_request = aspeed_ahash_do_one,
},
}, },
{ {
.alg.ahash = { .alg.ahash.base = {
.init = aspeed_sha512s_init, .init = aspeed_sha512s_init,
.update = aspeed_sham_update, .update = aspeed_sham_update,
.final = aspeed_sham_final, .final = aspeed_sham_final,
@ -1190,9 +1223,12 @@ static struct aspeed_hace_alg aspeed_ahash_algs_g6[] = {
} }
} }
}, },
.alg.ahash.op = {
.do_one_request = aspeed_ahash_do_one,
},
}, },
{ {
.alg.ahash = { .alg.ahash.base = {
.init = aspeed_sha512s_init, .init = aspeed_sha512s_init,
.update = aspeed_sham_update, .update = aspeed_sham_update,
.final = aspeed_sham_final, .final = aspeed_sham_final,
@ -1219,10 +1255,13 @@ static struct aspeed_hace_alg aspeed_ahash_algs_g6[] = {
} }
} }
}, },
.alg.ahash.op = {
.do_one_request = aspeed_ahash_do_one,
},
}, },
{ {
.alg_base = "sha384", .alg_base = "sha384",
.alg.ahash = { .alg.ahash.base = {
.init = aspeed_sham_init, .init = aspeed_sham_init,
.update = aspeed_sham_update, .update = aspeed_sham_update,
.final = aspeed_sham_final, .final = aspeed_sham_final,
@ -1251,10 +1290,13 @@ static struct aspeed_hace_alg aspeed_ahash_algs_g6[] = {
} }
} }
}, },
.alg.ahash.op = {
.do_one_request = aspeed_ahash_do_one,
},
}, },
{ {
.alg_base = "sha512", .alg_base = "sha512",
.alg.ahash = { .alg.ahash.base = {
.init = aspeed_sham_init, .init = aspeed_sham_init,
.update = aspeed_sham_update, .update = aspeed_sham_update,
.final = aspeed_sham_final, .final = aspeed_sham_final,
@ -1283,10 +1325,13 @@ static struct aspeed_hace_alg aspeed_ahash_algs_g6[] = {
} }
} }
}, },
.alg.ahash.op = {
.do_one_request = aspeed_ahash_do_one,
},
}, },
{ {
.alg_base = "sha512_224", .alg_base = "sha512_224",
.alg.ahash = { .alg.ahash.base = {
.init = aspeed_sha512s_init, .init = aspeed_sha512s_init,
.update = aspeed_sham_update, .update = aspeed_sham_update,
.final = aspeed_sham_final, .final = aspeed_sham_final,
@ -1315,10 +1360,13 @@ static struct aspeed_hace_alg aspeed_ahash_algs_g6[] = {
} }
} }
}, },
.alg.ahash.op = {
.do_one_request = aspeed_ahash_do_one,
},
}, },
{ {
.alg_base = "sha512_256", .alg_base = "sha512_256",
.alg.ahash = { .alg.ahash.base = {
.init = aspeed_sha512s_init, .init = aspeed_sha512s_init,
.update = aspeed_sham_update, .update = aspeed_sham_update,
.final = aspeed_sham_final, .final = aspeed_sham_final,
@ -1347,6 +1395,9 @@ static struct aspeed_hace_alg aspeed_ahash_algs_g6[] = {
} }
} }
}, },
.alg.ahash.op = {
.do_one_request = aspeed_ahash_do_one,
},
}, },
}; };
@ -1355,13 +1406,13 @@ void aspeed_unregister_hace_hash_algs(struct aspeed_hace_dev *hace_dev)
int i; int i;
for (i = 0; i < ARRAY_SIZE(aspeed_ahash_algs); i++) for (i = 0; i < ARRAY_SIZE(aspeed_ahash_algs); i++)
crypto_unregister_ahash(&aspeed_ahash_algs[i].alg.ahash); crypto_engine_unregister_ahash(&aspeed_ahash_algs[i].alg.ahash);
if (hace_dev->version != AST2600_VERSION) if (hace_dev->version != AST2600_VERSION)
return; return;
for (i = 0; i < ARRAY_SIZE(aspeed_ahash_algs_g6); i++) for (i = 0; i < ARRAY_SIZE(aspeed_ahash_algs_g6); i++)
crypto_unregister_ahash(&aspeed_ahash_algs_g6[i].alg.ahash); crypto_engine_unregister_ahash(&aspeed_ahash_algs_g6[i].alg.ahash);
} }
void aspeed_register_hace_hash_algs(struct aspeed_hace_dev *hace_dev) void aspeed_register_hace_hash_algs(struct aspeed_hace_dev *hace_dev)
@ -1372,10 +1423,10 @@ void aspeed_register_hace_hash_algs(struct aspeed_hace_dev *hace_dev)
for (i = 0; i < ARRAY_SIZE(aspeed_ahash_algs); i++) { for (i = 0; i < ARRAY_SIZE(aspeed_ahash_algs); i++) {
aspeed_ahash_algs[i].hace_dev = hace_dev; aspeed_ahash_algs[i].hace_dev = hace_dev;
rc = crypto_register_ahash(&aspeed_ahash_algs[i].alg.ahash); rc = crypto_engine_register_ahash(&aspeed_ahash_algs[i].alg.ahash);
if (rc) { if (rc) {
AHASH_DBG(hace_dev, "Failed to register %s\n", AHASH_DBG(hace_dev, "Failed to register %s\n",
aspeed_ahash_algs[i].alg.ahash.halg.base.cra_name); aspeed_ahash_algs[i].alg.ahash.base.halg.base.cra_name);
} }
} }
@ -1384,10 +1435,10 @@ void aspeed_register_hace_hash_algs(struct aspeed_hace_dev *hace_dev)
for (i = 0; i < ARRAY_SIZE(aspeed_ahash_algs_g6); i++) { for (i = 0; i < ARRAY_SIZE(aspeed_ahash_algs_g6); i++) {
aspeed_ahash_algs_g6[i].hace_dev = hace_dev; aspeed_ahash_algs_g6[i].hace_dev = hace_dev;
rc = crypto_register_ahash(&aspeed_ahash_algs_g6[i].alg.ahash); rc = crypto_engine_register_ahash(&aspeed_ahash_algs_g6[i].alg.ahash);
if (rc) { if (rc) {
AHASH_DBG(hace_dev, "Failed to register %s\n", AHASH_DBG(hace_dev, "Failed to register %s\n",
aspeed_ahash_algs_g6[i].alg.ahash.halg.base.cra_name); aspeed_ahash_algs_g6[i].alg.ahash.base.halg.base.cra_name);
} }
} }
} }

9
drivers/crypto/aspeed/aspeed-hace.c
View File

@ -3,7 +3,14 @@
* Copyright (c) 2021 Aspeed Technology Inc. * Copyright (c) 2021 Aspeed Technology Inc.
*/ */
#include "aspeed-hace.h"
#include <crypto/engine.h>
#include <linux/clk.h> #include <linux/clk.h>
#include <linux/dma-mapping.h>
#include <linux/err.h>
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/kernel.h>
#include <linux/module.h> #include <linux/module.h>
#include <linux/of_address.h> #include <linux/of_address.h>
#include <linux/of_device.h> #include <linux/of_device.h>
@ -11,8 +18,6 @@
#include <linux/of.h> #include <linux/of.h>
#include <linux/platform_device.h> #include <linux/platform_device.h>
#include "aspeed-hace.h"
#ifdef CONFIG_CRYPTO_DEV_ASPEED_DEBUG #ifdef CONFIG_CRYPTO_DEV_ASPEED_DEBUG
#define HACE_DBG(d, fmt, ...) \ #define HACE_DBG(d, fmt, ...) \
dev_info((d)->dev, "%s() " fmt, __func__, ##__VA_ARGS__) dev_info((d)->dev, "%s() " fmt, __func__, ##__VA_ARGS__)

30
drivers/crypto/aspeed/aspeed-hace.h
View File

@ -2,25 +2,14 @@
#ifndef __ASPEED_HACE_H__ #ifndef __ASPEED_HACE_H__
#define __ASPEED_HACE_H__ #define __ASPEED_HACE_H__
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/err.h>
#include <linux/fips.h>
#include <linux/dma-mapping.h>
#include <crypto/aes.h> #include <crypto/aes.h>
#include <crypto/des.h>
#include <crypto/scatterwalk.h>
#include <crypto/internal/aead.h>
#include <crypto/internal/akcipher.h>
#include <crypto/internal/des.h>
#include <crypto/internal/hash.h>
#include <crypto/internal/kpp.h>
#include <crypto/internal/skcipher.h>
#include <crypto/algapi.h>
#include <crypto/engine.h> #include <crypto/engine.h>
#include <crypto/hmac.h> #include <crypto/hash.h>
#include <crypto/sha1.h>
#include <crypto/sha2.h> #include <crypto/sha2.h>
#include <linux/bits.h>
#include <linux/compiler_attributes.h>
#include <linux/interrupt.h>
#include <linux/types.h>
/***************************** /*****************************
* * * *
@ -144,6 +133,7 @@
HACE_CMD_OFB | HACE_CMD_CTR) HACE_CMD_OFB | HACE_CMD_CTR)
struct aspeed_hace_dev; struct aspeed_hace_dev;
struct scatterlist;
typedef int (*aspeed_hace_fn_t)(struct aspeed_hace_dev *); typedef int (*aspeed_hace_fn_t)(struct aspeed_hace_dev *);
@ -178,8 +168,6 @@ struct aspeed_sha_hmac_ctx {
}; };
struct aspeed_sham_ctx { struct aspeed_sham_ctx {
struct crypto_engine_ctx enginectx;
struct aspeed_hace_dev *hace_dev; struct aspeed_hace_dev *hace_dev;
unsigned long flags; /* hmac flag */ unsigned long flags; /* hmac flag */
@ -235,8 +223,6 @@ struct aspeed_engine_crypto {
}; };
struct aspeed_cipher_ctx { struct aspeed_cipher_ctx {
struct crypto_engine_ctx enginectx;
struct aspeed_hace_dev *hace_dev; struct aspeed_hace_dev *hace_dev;
int key_len; int key_len;
u8 key[AES_MAX_KEYLENGTH]; u8 key[AES_MAX_KEYLENGTH];
@ -275,8 +261,8 @@ struct aspeed_hace_alg {
const char *alg_base; const char *alg_base;
union { union {
struct skcipher_alg skcipher; struct skcipher_engine_alg skcipher;
struct ahash_alg ahash; struct ahash_engine_alg ahash;
} alg; } alg;
}; };