Skip to content

L
linux
Commit 47ece481 authored by Ard Biesheuvel's avatar Ard Biesheuvel Committed by Herbert Xu
Browse files
Options

crypto: stm32 - switch to skcipher API 

Commit 7a7ffe65 ("crypto: skcipher - Add top-level skcipher interface")
dated 20 august 2015 introduced the new skcipher API which is supposed to
replace both blkcipher and ablkcipher. While all consumers of the API have
been converted long ago, some producers of the ablkcipher remain, forcing
us to keep the ablkcipher support routines alive, along with the matching
code to expose [a]blkciphers via the skcipher API.

So switch this driver to the skcipher API, allowing us to finally drop the
ablkcipher code in the near future.

Cc: Maxime Coquelin <mcoquelin.stm32@gmail.com>
Cc: Alexandre Torgue <alexandre.torgue@st.com>
Signed-off-by: default avatarArd Biesheuvel <ardb@kernel.org>
Signed-off-by: default avatarHerbert Xu <herbert@gondor.apana.org.au>
parent 8bf08715
Show whitespace changes
Inline Side-by-side
Showing with 159 additions and 179 deletions
drivers/crypto/stm32/stm32-cryp.c
View file @ 47ece481
...@@ -19,6 +19,7 @@ ...@@ -19,6 +19,7 @@
#include <crypto/engine.h> #include <crypto/engine.h>
#include <crypto/scatterwalk.h> #include <crypto/scatterwalk.h>
#include <crypto/internal/aead.h> #include <crypto/internal/aead.h>
#include <crypto/internal/skcipher.h>
#define DRIVER_NAME "stm32-cryp" #define DRIVER_NAME "stm32-cryp"
...@@ -137,7 +138,7 @@ struct stm32_cryp { ...@@ -137,7 +138,7 @@ struct stm32_cryp {
struct crypto_engine *engine; struct crypto_engine *engine;
struct ablkcipher_request *req; struct skcipher_request *req;
struct aead_request *areq; struct aead_request *areq;
size_t authsize; size_t authsize;
...@@ -395,8 +396,8 @@ static void stm32_cryp_hw_write_iv(struct stm32_cryp *cryp, u32 *iv) ...@@ -395,8 +396,8 @@ static void stm32_cryp_hw_write_iv(struct stm32_cryp *cryp, u32 *iv)
static void stm32_cryp_get_iv(struct stm32_cryp *cryp) static void stm32_cryp_get_iv(struct stm32_cryp *cryp)
{ {
struct ablkcipher_request *req = cryp->req; struct skcipher_request *req = cryp->req;
u32 *tmp = req->info; u32 *tmp = (void *)req->iv;
if (!tmp) if (!tmp)
return; return;
...@@ -616,7 +617,7 @@ static int stm32_cryp_hw_init(struct stm32_cryp *cryp) ...@@ -616,7 +617,7 @@ static int stm32_cryp_hw_init(struct stm32_cryp *cryp)
case CR_TDES_CBC: case CR_TDES_CBC:
case CR_AES_CBC: case CR_AES_CBC:
case CR_AES_CTR: case CR_AES_CTR:
stm32_cryp_hw_write_iv(cryp, (u32 *)cryp->req->info); stm32_cryp_hw_write_iv(cryp, (u32 *)cryp->req->iv);
break; break;
default: default:
...@@ -667,7 +668,7 @@ static void stm32_cryp_finish_req(struct stm32_cryp *cryp, int err) ...@@ -667,7 +668,7 @@ static void stm32_cryp_finish_req(struct stm32_cryp *cryp, int err)
if (is_gcm(cryp) || is_ccm(cryp)) if (is_gcm(cryp) || is_ccm(cryp))
crypto_finalize_aead_request(cryp->engine, cryp->areq, err); crypto_finalize_aead_request(cryp->engine, cryp->areq, err);
else else
crypto_finalize_ablkcipher_request(cryp->engine, cryp->req, crypto_finalize_skcipher_request(cryp->engine, cryp->req,
err); err);
memset(cryp->ctx->key, 0, cryp->ctx->keylen); memset(cryp->ctx->key, 0, cryp->ctx->keylen);
...@@ -685,11 +686,11 @@ static int stm32_cryp_cipher_one_req(struct crypto_engine *engine, void *areq); ...@@ -685,11 +686,11 @@ static int stm32_cryp_cipher_one_req(struct crypto_engine *engine, void *areq);
static int stm32_cryp_prepare_cipher_req(struct crypto_engine *engine, static int stm32_cryp_prepare_cipher_req(struct crypto_engine *engine,
void *areq); void *areq);
static int stm32_cryp_cra_init(struct crypto_tfm *tfm) static int stm32_cryp_init_tfm(struct crypto_skcipher *tfm)
{ {
struct stm32_cryp_ctx *ctx = crypto_tfm_ctx(tfm); struct stm32_cryp_ctx *ctx = crypto_skcipher_ctx(tfm);
tfm->crt_ablkcipher.reqsize = sizeof(struct stm32_cryp_reqctx); crypto_skcipher_set_reqsize(tfm, sizeof(struct stm32_cryp_reqctx));
ctx->enginectx.op.do_one_request = stm32_cryp_cipher_one_req; ctx->enginectx.op.do_one_request = stm32_cryp_cipher_one_req;
ctx->enginectx.op.prepare_request = stm32_cryp_prepare_cipher_req; ctx->enginectx.op.prepare_request = stm32_cryp_prepare_cipher_req;
...@@ -714,11 +715,11 @@ static int stm32_cryp_aes_aead_init(struct crypto_aead *tfm) ...@@ -714,11 +715,11 @@ static int stm32_cryp_aes_aead_init(struct crypto_aead *tfm)
return 0; return 0;
} }
static int stm32_cryp_crypt(struct ablkcipher_request *req, unsigned long mode) static int stm32_cryp_crypt(struct skcipher_request *req, unsigned long mode)
{ {
struct stm32_cryp_ctx *ctx = crypto_ablkcipher_ctx( struct stm32_cryp_ctx *ctx = crypto_skcipher_ctx(
crypto_ablkcipher_reqtfm(req)); crypto_skcipher_reqtfm(req));
struct stm32_cryp_reqctx *rctx = ablkcipher_request_ctx(req); struct stm32_cryp_reqctx *rctx = skcipher_request_ctx(req);
struct stm32_cryp *cryp = stm32_cryp_find_dev(ctx); struct stm32_cryp *cryp = stm32_cryp_find_dev(ctx);
if (!cryp) if (!cryp)
...@@ -726,7 +727,7 @@ static int stm32_cryp_crypt(struct ablkcipher_request *req, unsigned long mode) ...@@ -726,7 +727,7 @@ static int stm32_cryp_crypt(struct ablkcipher_request *req, unsigned long mode)
rctx->mode = mode; rctx->mode = mode;
return crypto_transfer_ablkcipher_request_to_engine(cryp->engine, req); return crypto_transfer_skcipher_request_to_engine(cryp->engine, req);
} }
static int stm32_cryp_aead_crypt(struct aead_request *req, unsigned long mode) static int stm32_cryp_aead_crypt(struct aead_request *req, unsigned long mode)
...@@ -743,10 +744,10 @@ static int stm32_cryp_aead_crypt(struct aead_request *req, unsigned long mode) ...@@ -743,10 +744,10 @@ static int stm32_cryp_aead_crypt(struct aead_request *req, unsigned long mode)
return crypto_transfer_aead_request_to_engine(cryp->engine, req); return crypto_transfer_aead_request_to_engine(cryp->engine, req);
} }
static int stm32_cryp_setkey(struct crypto_ablkcipher *tfm, const u8 *key, static int stm32_cryp_setkey(struct crypto_skcipher *tfm, const u8 *key,
unsigned int keylen) unsigned int keylen)
{ {
struct stm32_cryp_ctx *ctx = crypto_ablkcipher_ctx(tfm); struct stm32_cryp_ctx *ctx = crypto_skcipher_ctx(tfm);
memcpy(ctx->key, key, keylen); memcpy(ctx->key, key, keylen);
ctx->keylen = keylen; ctx->keylen = keylen;
...@@ -754,7 +755,7 @@ static int stm32_cryp_setkey(struct crypto_ablkcipher *tfm, const u8 *key, ...@@ -754,7 +755,7 @@ static int stm32_cryp_setkey(struct crypto_ablkcipher *tfm, const u8 *key,
return 0; return 0;
} }
static int stm32_cryp_aes_setkey(struct crypto_ablkcipher *tfm, const u8 *key, static int stm32_cryp_aes_setkey(struct crypto_skcipher *tfm, const u8 *key,
unsigned int keylen) unsigned int keylen)
{ {
if (keylen != AES_KEYSIZE_128 && keylen != AES_KEYSIZE_192 && if (keylen != AES_KEYSIZE_128 && keylen != AES_KEYSIZE_192 &&
...@@ -764,17 +765,17 @@ static int stm32_cryp_aes_setkey(struct crypto_ablkcipher *tfm, const u8 *key, ...@@ -764,17 +765,17 @@ static int stm32_cryp_aes_setkey(struct crypto_ablkcipher *tfm, const u8 *key,
return stm32_cryp_setkey(tfm, key, keylen); return stm32_cryp_setkey(tfm, key, keylen);
} }
static int stm32_cryp_des_setkey(struct crypto_ablkcipher *tfm, const u8 *key, static int stm32_cryp_des_setkey(struct crypto_skcipher *tfm, const u8 *key,
unsigned int keylen) unsigned int keylen)
{ {
return verify_ablkcipher_des_key(tfm, key) ?: return verify_skcipher_des_key(tfm, key) ?:
stm32_cryp_setkey(tfm, key, keylen); stm32_cryp_setkey(tfm, key, keylen);
} }
static int stm32_cryp_tdes_setkey(struct crypto_ablkcipher *tfm, const u8 *key, static int stm32_cryp_tdes_setkey(struct crypto_skcipher *tfm, const u8 *key,
unsigned int keylen) unsigned int keylen)
{ {
return verify_ablkcipher_des3_key(tfm, key) ?: return verify_skcipher_des3_key(tfm, key) ?:
stm32_cryp_setkey(tfm, key, keylen); stm32_cryp_setkey(tfm, key, keylen);
} }
...@@ -818,32 +819,32 @@ static int stm32_cryp_aes_ccm_setauthsize(struct crypto_aead *tfm, ...@@ -818,32 +819,32 @@ static int stm32_cryp_aes_ccm_setauthsize(struct crypto_aead *tfm,
return 0; return 0;
} }
static int stm32_cryp_aes_ecb_encrypt(struct ablkcipher_request *req) static int stm32_cryp_aes_ecb_encrypt(struct skcipher_request *req)
{ {
return stm32_cryp_crypt(req, FLG_AES | FLG_ECB | FLG_ENCRYPT); return stm32_cryp_crypt(req, FLG_AES | FLG_ECB | FLG_ENCRYPT);
} }
static int stm32_cryp_aes_ecb_decrypt(struct ablkcipher_request *req) static int stm32_cryp_aes_ecb_decrypt(struct skcipher_request *req)
{ {
return stm32_cryp_crypt(req, FLG_AES | FLG_ECB); return stm32_cryp_crypt(req, FLG_AES | FLG_ECB);
} }
static int stm32_cryp_aes_cbc_encrypt(struct ablkcipher_request *req) static int stm32_cryp_aes_cbc_encrypt(struct skcipher_request *req)
{ {
return stm32_cryp_crypt(req, FLG_AES | FLG_CBC | FLG_ENCRYPT); return stm32_cryp_crypt(req, FLG_AES | FLG_CBC | FLG_ENCRYPT);
} }
static int stm32_cryp_aes_cbc_decrypt(struct ablkcipher_request *req) static int stm32_cryp_aes_cbc_decrypt(struct skcipher_request *req)
{ {
return stm32_cryp_crypt(req, FLG_AES | FLG_CBC); return stm32_cryp_crypt(req, FLG_AES | FLG_CBC);
} }
static int stm32_cryp_aes_ctr_encrypt(struct ablkcipher_request *req) static int stm32_cryp_aes_ctr_encrypt(struct skcipher_request *req)
{ {
return stm32_cryp_crypt(req, FLG_AES | FLG_CTR | FLG_ENCRYPT); return stm32_cryp_crypt(req, FLG_AES | FLG_CTR | FLG_ENCRYPT);
} }
static int stm32_cryp_aes_ctr_decrypt(struct ablkcipher_request *req) static int stm32_cryp_aes_ctr_decrypt(struct skcipher_request *req)
{ {
return stm32_cryp_crypt(req, FLG_AES | FLG_CTR); return stm32_cryp_crypt(req, FLG_AES | FLG_CTR);
} }
...@@ -868,47 +869,47 @@ static int stm32_cryp_aes_ccm_decrypt(struct aead_request *req) ...@@ -868,47 +869,47 @@ static int stm32_cryp_aes_ccm_decrypt(struct aead_request *req)
return stm32_cryp_aead_crypt(req, FLG_AES | FLG_CCM); return stm32_cryp_aead_crypt(req, FLG_AES | FLG_CCM);
} }
static int stm32_cryp_des_ecb_encrypt(struct ablkcipher_request *req) static int stm32_cryp_des_ecb_encrypt(struct skcipher_request *req)
{ {
return stm32_cryp_crypt(req, FLG_DES | FLG_ECB | FLG_ENCRYPT); return stm32_cryp_crypt(req, FLG_DES | FLG_ECB | FLG_ENCRYPT);
} }
static int stm32_cryp_des_ecb_decrypt(struct ablkcipher_request *req) static int stm32_cryp_des_ecb_decrypt(struct skcipher_request *req)
{ {
return stm32_cryp_crypt(req, FLG_DES | FLG_ECB); return stm32_cryp_crypt(req, FLG_DES | FLG_ECB);
} }
static int stm32_cryp_des_cbc_encrypt(struct ablkcipher_request *req) static int stm32_cryp_des_cbc_encrypt(struct skcipher_request *req)
{ {
return stm32_cryp_crypt(req, FLG_DES | FLG_CBC | FLG_ENCRYPT); return stm32_cryp_crypt(req, FLG_DES | FLG_CBC | FLG_ENCRYPT);
} }
static int stm32_cryp_des_cbc_decrypt(struct ablkcipher_request *req) static int stm32_cryp_des_cbc_decrypt(struct skcipher_request *req)
{ {
return stm32_cryp_crypt(req, FLG_DES | FLG_CBC); return stm32_cryp_crypt(req, FLG_DES | FLG_CBC);
} }
static int stm32_cryp_tdes_ecb_encrypt(struct ablkcipher_request *req) static int stm32_cryp_tdes_ecb_encrypt(struct skcipher_request *req)
{ {
return stm32_cryp_crypt(req, FLG_TDES | FLG_ECB | FLG_ENCRYPT); return stm32_cryp_crypt(req, FLG_TDES | FLG_ECB | FLG_ENCRYPT);
} }
static int stm32_cryp_tdes_ecb_decrypt(struct ablkcipher_request *req) static int stm32_cryp_tdes_ecb_decrypt(struct skcipher_request *req)
{ {
return stm32_cryp_crypt(req, FLG_TDES | FLG_ECB); return stm32_cryp_crypt(req, FLG_TDES | FLG_ECB);
} }
static int stm32_cryp_tdes_cbc_encrypt(struct ablkcipher_request *req) static int stm32_cryp_tdes_cbc_encrypt(struct skcipher_request *req)
{ {
return stm32_cryp_crypt(req, FLG_TDES | FLG_CBC | FLG_ENCRYPT); return stm32_cryp_crypt(req, FLG_TDES | FLG_CBC | FLG_ENCRYPT);
} }
static int stm32_cryp_tdes_cbc_decrypt(struct ablkcipher_request *req) static int stm32_cryp_tdes_cbc_decrypt(struct skcipher_request *req)
{ {
return stm32_cryp_crypt(req, FLG_TDES | FLG_CBC); return stm32_cryp_crypt(req, FLG_TDES | FLG_CBC);
} }
static int stm32_cryp_prepare_req(struct ablkcipher_request *req, static int stm32_cryp_prepare_req(struct skcipher_request *req,
struct aead_request *areq) struct aead_request *areq)
{ {
struct stm32_cryp_ctx *ctx; struct stm32_cryp_ctx *ctx;
...@@ -919,7 +920,7 @@ static int stm32_cryp_prepare_req(struct ablkcipher_request *req, ...@@ -919,7 +920,7 @@ static int stm32_cryp_prepare_req(struct ablkcipher_request *req,
if (!req && !areq) if (!req && !areq)
return -EINVAL; return -EINVAL;
ctx = req ? crypto_ablkcipher_ctx(crypto_ablkcipher_reqtfm(req)) : ctx = req ? crypto_skcipher_ctx(crypto_skcipher_reqtfm(req)) :
crypto_aead_ctx(crypto_aead_reqtfm(areq)); crypto_aead_ctx(crypto_aead_reqtfm(areq));
cryp = ctx->cryp; cryp = ctx->cryp;
...@@ -927,7 +928,7 @@ static int stm32_cryp_prepare_req(struct ablkcipher_request *req, ...@@ -927,7 +928,7 @@ static int stm32_cryp_prepare_req(struct ablkcipher_request *req,
if (!cryp) if (!cryp)
return -ENODEV; return -ENODEV;
rctx = req ? ablkcipher_request_ctx(req) : aead_request_ctx(areq); rctx = req ? skcipher_request_ctx(req) : aead_request_ctx(areq);
rctx->mode &= FLG_MODE_MASK; rctx->mode &= FLG_MODE_MASK;
ctx->cryp = cryp; ctx->cryp = cryp;
...@@ -939,7 +940,7 @@ static int stm32_cryp_prepare_req(struct ablkcipher_request *req, ...@@ -939,7 +940,7 @@ static int stm32_cryp_prepare_req(struct ablkcipher_request *req,
if (req) { if (req) {
cryp->req = req; cryp->req = req;
cryp->areq = NULL; cryp->areq = NULL;
cryp->total_in = req->nbytes; cryp->total_in = req->cryptlen;
cryp->total_out = cryp->total_in; cryp->total_out = cryp->total_in;
} else { } else {
/* /*
...@@ -1016,8 +1017,8 @@ static int stm32_cryp_prepare_req(struct ablkcipher_request *req, ...@@ -1016,8 +1017,8 @@ static int stm32_cryp_prepare_req(struct ablkcipher_request *req,
static int stm32_cryp_prepare_cipher_req(struct crypto_engine *engine, static int stm32_cryp_prepare_cipher_req(struct crypto_engine *engine,
void *areq) void *areq)
{ {
struct ablkcipher_request *req = container_of(areq, struct skcipher_request *req = container_of(areq,
struct ablkcipher_request, struct skcipher_request,
base); base);
return stm32_cryp_prepare_req(req, NULL); return stm32_cryp_prepare_req(req, NULL);
...@@ -1025,11 +1026,11 @@ static int stm32_cryp_prepare_cipher_req(struct crypto_engine *engine, ...@@ -1025,11 +1026,11 @@ static int stm32_cryp_prepare_cipher_req(struct crypto_engine *engine,
static int stm32_cryp_cipher_one_req(struct crypto_engine *engine, void *areq) static int stm32_cryp_cipher_one_req(struct crypto_engine *engine, void *areq)
{ {
struct ablkcipher_request *req = container_of(areq, struct skcipher_request *req = container_of(areq,
struct ablkcipher_request, struct skcipher_request,
base); base);
struct stm32_cryp_ctx *ctx = crypto_ablkcipher_ctx( struct stm32_cryp_ctx *ctx = crypto_skcipher_ctx(
crypto_ablkcipher_reqtfm(req)); crypto_skcipher_reqtfm(req));
struct stm32_cryp *cryp = ctx->cryp; struct stm32_cryp *cryp = ctx->cryp;
if (!cryp) if (!cryp)
...@@ -1724,150 +1725,129 @@ static irqreturn_t stm32_cryp_irq(int irq, void *arg) ...@@ -1724,150 +1725,129 @@ static irqreturn_t stm32_cryp_irq(int irq, void *arg)
return IRQ_WAKE_THREAD; return IRQ_WAKE_THREAD;
} }
static struct crypto_alg crypto_algs[] = { static struct skcipher_alg crypto_algs[] = {
{ {
.cra_name = "ecb(aes)", .base.cra_name = "ecb(aes)",
.cra_driver_name = "stm32-ecb-aes", .base.cra_driver_name = "stm32-ecb-aes",
.cra_priority = 200, .base.cra_priority = 200,
.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | .base.cra_flags = CRYPTO_ALG_ASYNC,
CRYPTO_ALG_ASYNC, .base.cra_blocksize = AES_BLOCK_SIZE,
.cra_blocksize = AES_BLOCK_SIZE, .base.cra_ctxsize = sizeof(struct stm32_cryp_ctx),
.cra_ctxsize = sizeof(struct stm32_cryp_ctx), .base.cra_alignmask = 0xf,
.cra_alignmask = 0xf, .base.cra_module = THIS_MODULE,
.cra_type = &crypto_ablkcipher_type,
.cra_module = THIS_MODULE, .init = stm32_cryp_init_tfm,
.cra_init = stm32_cryp_cra_init,
.cra_ablkcipher = {
.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 = stm32_cryp_aes_setkey, .setkey = stm32_cryp_aes_setkey,
.encrypt = stm32_cryp_aes_ecb_encrypt, .encrypt = stm32_cryp_aes_ecb_encrypt,
.decrypt = stm32_cryp_aes_ecb_decrypt, .decrypt = stm32_cryp_aes_ecb_decrypt,
}
}, },
{ {
.cra_name = "cbc(aes)", .base.cra_name = "cbc(aes)",
.cra_driver_name = "stm32-cbc-aes", .base.cra_driver_name = "stm32-cbc-aes",
.cra_priority = 200, .base.cra_priority = 200,
.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | .base.cra_flags = CRYPTO_ALG_ASYNC,
CRYPTO_ALG_ASYNC, .base.cra_blocksize = AES_BLOCK_SIZE,
.cra_blocksize = AES_BLOCK_SIZE, .base.cra_ctxsize = sizeof(struct stm32_cryp_ctx),
.cra_ctxsize = sizeof(struct stm32_cryp_ctx), .base.cra_alignmask = 0xf,
.cra_alignmask = 0xf, .base.cra_module = THIS_MODULE,
.cra_type = &crypto_ablkcipher_type,
.cra_module = THIS_MODULE, .init = stm32_cryp_init_tfm,
.cra_init = stm32_cryp_cra_init,
.cra_ablkcipher = {
.min_keysize = AES_MIN_KEY_SIZE, .min_keysize = AES_MIN_KEY_SIZE,
.max_keysize = AES_MAX_KEY_SIZE, .max_keysize = AES_MAX_KEY_SIZE,
.ivsize = AES_BLOCK_SIZE, .ivsize = AES_BLOCK_SIZE,
.setkey = stm32_cryp_aes_setkey, .setkey = stm32_cryp_aes_setkey,
.encrypt = stm32_cryp_aes_cbc_encrypt, .encrypt = stm32_cryp_aes_cbc_encrypt,
.decrypt = stm32_cryp_aes_cbc_decrypt, .decrypt = stm32_cryp_aes_cbc_decrypt,
}
}, },
{ {
.cra_name = "ctr(aes)", .base.cra_name = "ctr(aes)",
.cra_driver_name = "stm32-ctr-aes", .base.cra_driver_name = "stm32-ctr-aes",
.cra_priority = 200, .base.cra_priority = 200,
.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | .base.cra_flags = CRYPTO_ALG_ASYNC,
CRYPTO_ALG_ASYNC, .base.cra_blocksize = 1,
.cra_blocksize = 1, .base.cra_ctxsize = sizeof(struct stm32_cryp_ctx),
.cra_ctxsize = sizeof(struct stm32_cryp_ctx), .base.cra_alignmask = 0xf,
.cra_alignmask = 0xf, .base.cra_module = THIS_MODULE,
.cra_type = &crypto_ablkcipher_type,
.cra_module = THIS_MODULE, .init = stm32_cryp_init_tfm,
.cra_init = stm32_cryp_cra_init,
.cra_ablkcipher = {
.min_keysize = AES_MIN_KEY_SIZE, .min_keysize = AES_MIN_KEY_SIZE,
.max_keysize = AES_MAX_KEY_SIZE, .max_keysize = AES_MAX_KEY_SIZE,
.ivsize = AES_BLOCK_SIZE, .ivsize = AES_BLOCK_SIZE,
.setkey = stm32_cryp_aes_setkey, .setkey = stm32_cryp_aes_setkey,
.encrypt = stm32_cryp_aes_ctr_encrypt, .encrypt = stm32_cryp_aes_ctr_encrypt,
.decrypt = stm32_cryp_aes_ctr_decrypt, .decrypt = stm32_cryp_aes_ctr_decrypt,
}
}, },
{ {
.cra_name = "ecb(des)", .base.cra_name = "ecb(des)",
.cra_driver_name = "stm32-ecb-des", .base.cra_driver_name = "stm32-ecb-des",
.cra_priority = 200, .base.cra_priority = 200,
.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | .base.cra_flags = CRYPTO_ALG_ASYNC,
CRYPTO_ALG_ASYNC, .base.cra_blocksize = DES_BLOCK_SIZE,
.cra_blocksize = DES_BLOCK_SIZE, .base.cra_ctxsize = sizeof(struct stm32_cryp_ctx),
.cra_ctxsize = sizeof(struct stm32_cryp_ctx), .base.cra_alignmask = 0xf,
.cra_alignmask = 0xf, .base.cra_module = THIS_MODULE,
.cra_type = &crypto_ablkcipher_type,
.cra_module = THIS_MODULE, .init = stm32_cryp_init_tfm,
.cra_init = stm32_cryp_cra_init,
.cra_ablkcipher = {
.min_keysize = DES_BLOCK_SIZE, .min_keysize = DES_BLOCK_SIZE,
.max_keysize = DES_BLOCK_SIZE, .max_keysize = DES_BLOCK_SIZE,
.setkey = stm32_cryp_des_setkey, .setkey = stm32_cryp_des_setkey,
.encrypt = stm32_cryp_des_ecb_encrypt, .encrypt = stm32_cryp_des_ecb_encrypt,
.decrypt = stm32_cryp_des_ecb_decrypt, .decrypt = stm32_cryp_des_ecb_decrypt,
}
}, },
{ {
.cra_name = "cbc(des)", .base.cra_name = "cbc(des)",
.cra_driver_name = "stm32-cbc-des", .base.cra_driver_name = "stm32-cbc-des",
.cra_priority = 200, .base.cra_priority = 200,
.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | .base.cra_flags = CRYPTO_ALG_ASYNC,
CRYPTO_ALG_ASYNC, .base.cra_blocksize = DES_BLOCK_SIZE,
.cra_blocksize = DES_BLOCK_SIZE, .base.cra_ctxsize = sizeof(struct stm32_cryp_ctx),
.cra_ctxsize = sizeof(struct stm32_cryp_ctx), .base.cra_alignmask = 0xf,
.cra_alignmask = 0xf, .base.cra_module = THIS_MODULE,
.cra_type = &crypto_ablkcipher_type,
.cra_module = THIS_MODULE, .init = stm32_cryp_init_tfm,
.cra_init = stm32_cryp_cra_init,
.cra_ablkcipher = {
.min_keysize = DES_BLOCK_SIZE, .min_keysize = DES_BLOCK_SIZE,
.max_keysize = DES_BLOCK_SIZE, .max_keysize = DES_BLOCK_SIZE,
.ivsize = DES_BLOCK_SIZE, .ivsize = DES_BLOCK_SIZE,
.setkey = stm32_cryp_des_setkey, .setkey = stm32_cryp_des_setkey,
.encrypt = stm32_cryp_des_cbc_encrypt, .encrypt = stm32_cryp_des_cbc_encrypt,
.decrypt = stm32_cryp_des_cbc_decrypt, .decrypt = stm32_cryp_des_cbc_decrypt,
}
}, },
{ {
.cra_name = "ecb(des3_ede)", .base.cra_name = "ecb(des3_ede)",
.cra_driver_name = "stm32-ecb-des3", .base.cra_driver_name = "stm32-ecb-des3",
.cra_priority = 200, .base.cra_priority = 200,
.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | .base.cra_flags = CRYPTO_ALG_ASYNC,
CRYPTO_ALG_ASYNC, .base.cra_blocksize = DES_BLOCK_SIZE,
.cra_blocksize = DES_BLOCK_SIZE, .base.cra_ctxsize = sizeof(struct stm32_cryp_ctx),
.cra_ctxsize = sizeof(struct stm32_cryp_ctx), .base.cra_alignmask = 0xf,
.cra_alignmask = 0xf, .base.cra_module = THIS_MODULE,
.cra_type = &crypto_ablkcipher_type,
.cra_module = THIS_MODULE, .init = stm32_cryp_init_tfm,
.cra_init = stm32_cryp_cra_init,
.cra_ablkcipher = {
.min_keysize = 3 * DES_BLOCK_SIZE, .min_keysize = 3 * DES_BLOCK_SIZE,
.max_keysize = 3 * DES_BLOCK_SIZE, .max_keysize = 3 * DES_BLOCK_SIZE,
.setkey = stm32_cryp_tdes_setkey, .setkey = stm32_cryp_tdes_setkey,
.encrypt = stm32_cryp_tdes_ecb_encrypt, .encrypt = stm32_cryp_tdes_ecb_encrypt,
.decrypt = stm32_cryp_tdes_ecb_decrypt, .decrypt = stm32_cryp_tdes_ecb_decrypt,
}
}, },
{ {
.cra_name = "cbc(des3_ede)", .base.cra_name = "cbc(des3_ede)",
.cra_driver_name = "stm32-cbc-des3", .base.cra_driver_name = "stm32-cbc-des3",
.cra_priority = 200, .base.cra_priority = 200,
.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | .base.cra_flags = CRYPTO_ALG_ASYNC,
CRYPTO_ALG_ASYNC, .base.cra_blocksize = DES_BLOCK_SIZE,
.cra_blocksize = DES_BLOCK_SIZE, .base.cra_ctxsize = sizeof(struct stm32_cryp_ctx),
.cra_ctxsize = sizeof(struct stm32_cryp_ctx), .base.cra_alignmask = 0xf,
.cra_alignmask = 0xf, .base.cra_module = THIS_MODULE,
.cra_type = &crypto_ablkcipher_type,
.cra_module = THIS_MODULE, .init = stm32_cryp_init_tfm,
.cra_init = stm32_cryp_cra_init,
.cra_ablkcipher = {
.min_keysize = 3 * DES_BLOCK_SIZE, .min_keysize = 3 * DES_BLOCK_SIZE,
.max_keysize = 3 * DES_BLOCK_SIZE, .max_keysize = 3 * DES_BLOCK_SIZE,
.ivsize = DES_BLOCK_SIZE, .ivsize = DES_BLOCK_SIZE,
.setkey = stm32_cryp_tdes_setkey, .setkey = stm32_cryp_tdes_setkey,
.encrypt = stm32_cryp_tdes_cbc_encrypt, .encrypt = stm32_cryp_tdes_cbc_encrypt,
.decrypt = stm32_cryp_tdes_cbc_decrypt, .decrypt = stm32_cryp_tdes_cbc_decrypt,
}
}, },
}; };
...@@ -2010,7 +1990,7 @@ static int stm32_cryp_probe(struct platform_device *pdev) ...@@ -2010,7 +1990,7 @@ static int stm32_cryp_probe(struct platform_device *pdev)
goto err_engine2; goto err_engine2;
} }
ret = crypto_register_algs(crypto_algs, ARRAY_SIZE(crypto_algs)); ret = crypto_register_skciphers(crypto_algs, ARRAY_SIZE(crypto_algs));
if (ret) { if (ret) {
dev_err(dev, "Could not register algs\n"); dev_err(dev, "Could not register algs\n");
goto err_algs; goto err_algs;
...@@ -2027,7 +2007,7 @@ static int stm32_cryp_probe(struct platform_device *pdev) ...@@ -2027,7 +2007,7 @@ static int stm32_cryp_probe(struct platform_device *pdev)
return 0; return 0;
err_aead_algs: err_aead_algs:
crypto_unregister_algs(crypto_algs, ARRAY_SIZE(crypto_algs)); crypto_unregister_skciphers(crypto_algs, ARRAY_SIZE(crypto_algs));
err_algs: err_algs:
err_engine2: err_engine2:
crypto_engine_exit(cryp->engine); crypto_engine_exit(cryp->engine);
...@@ -2059,7 +2039,7 @@ static int stm32_cryp_remove(struct platform_device *pdev) ...@@ -2059,7 +2039,7 @@ static int stm32_cryp_remove(struct platform_device *pdev)
return ret; return ret;
crypto_unregister_aeads(aead_algs, ARRAY_SIZE(aead_algs)); crypto_unregister_aeads(aead_algs, ARRAY_SIZE(aead_algs));
crypto_unregister_algs(crypto_algs, ARRAY_SIZE(crypto_algs)); crypto_unregister_skciphers(crypto_algs, ARRAY_SIZE(crypto_algs));
crypto_engine_exit(cryp->engine); crypto_engine_exit(cryp->engine);
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7