[PATCH v4 07/19] crypto: talitos/skcipher - Move into separate file
Paul Louvel <[email protected]>
| Newsgroups | org.kernel.vger.linux-crypto,org.kernel.vger.linux-kernel |
|---|---|
| Message-ID | <[email protected]> |
Move the skcipher algorithm implementations from talitos.c into a dedicated talitos-skcipher.c file. Reviewed-by: Christophe Leroy (CS GROUP) <[email protected]> Signed-off-by: Paul Louvel <[email protected]> --- drivers/crypto/talitos/Makefile | 2 +- drivers/crypto/talitos/talitos-skcipher.c | 399 ++++++++++++++++++++++++++++++ drivers/crypto/talitos/talitos.c | 377 +--------------------------- drivers/crypto/talitos/talitos.h | 1 + 4 files changed, 411 insertions(+), 368 deletions(-) diff --git a/drivers/crypto/talitos/Makefile b/drivers/crypto/talitos/Makefile index 40d37f9364ef..d4f19f2f6375 100644 --- a/drivers/crypto/talitos/Makefile +++ b/drivers/crypto/talitos/Makefile @@ -1,3 +1,3 @@ obj-$(CONFIG_CRYPTO_DEV_TALITOS) += talitos.o -talitos-y := talitos.o talitos-rng.o talitos-hash.o +talitos-y := talitos.o talitos-rng.o talitos-hash.o talitos-skcipher.o diff --git a/drivers/crypto/talitos/talitos-skcipher.c b/drivers/crypto/talitos/talitos-skcipher.c new file mode 100644 index 000000000000..f80373610aa4 --- /dev/null +++ b/drivers/crypto/talitos/talitos-skcipher.c @@ -0,0 +1,399 @@ +// SPDX-License-Identifier: GPL-2.0-or-later + +/* + * Freescale SEC (talitos) skcipher implementation + * + * Copyright (c) 2006-2011 Freescale Semiconductor, Inc. + */ + +#include <crypto/internal/des.h> +#include <crypto/internal/skcipher.h> + +#include "talitos.h" + +static void common_nonsnoop_unmap(struct device *dev, + struct talitos_edesc *edesc, + struct skcipher_request *areq) +{ + unmap_single_talitos_ptr(dev, &edesc->desc.ptr[5], DMA_FROM_DEVICE); + + talitos_sg_unmap(dev, edesc, areq->src, areq->dst, areq->cryptlen, 0); + unmap_single_talitos_ptr(dev, &edesc->desc.ptr[1], DMA_TO_DEVICE); + + if (edesc->dma_len) + dma_unmap_single(dev, edesc->dma_link_tbl, edesc->dma_len, + DMA_BIDIRECTIONAL); +} + +static void skcipher_done(struct device *dev, + struct talitos_desc *desc, void *context, + int err) +{ + struct skcipher_request *areq = context; + struct crypto_skcipher *cipher = crypto_skcipher_reqtfm(areq); + struct talitos_ctx *ctx = crypto_skcipher_ctx(cipher); + unsigned int ivsize = crypto_skcipher_ivsize(cipher); + struct talitos_edesc *edesc; + + edesc = container_of(desc, struct talitos_edesc, desc); + + common_nonsnoop_unmap(dev, edesc, areq); + memcpy(areq->iv, ctx->iv, ivsize); + + kfree(edesc); + + skcipher_request_complete(areq, err); +} + +static int common_nonsnoop(struct talitos_edesc *edesc, + struct skcipher_request *areq, + void (*callback) (struct device *dev, + struct talitos_desc *desc, + void *context, int error)) +{ + struct crypto_skcipher *cipher = crypto_skcipher_reqtfm(areq); + struct talitos_ctx *ctx = crypto_skcipher_ctx(cipher); + struct device *dev = ctx->dev; + struct talitos_desc *desc = &edesc->desc; + unsigned int cryptlen = areq->cryptlen; + unsigned int ivsize = crypto_skcipher_ivsize(cipher); + int sg_count, ret; + bool sync_needed = false; + struct talitos_private *priv = dev_get_drvdata(dev); + bool is_sec1 = has_ftr_sec1(priv); + bool is_ctr = (desc->hdr & DESC_HDR_SEL0_MASK) == DESC_HDR_SEL0_AESU && + (desc->hdr & DESC_HDR_MODE0_AESU_MASK) == DESC_HDR_MODE0_AESU_CTR; + + /* first DWORD empty */ + + /* cipher iv */ + to_talitos_ptr(&desc->ptr[1], edesc->iv_dma, ivsize, is_sec1); + + /* cipher key */ + to_talitos_ptr(&desc->ptr[2], ctx->dma_key, ctx->keylen, is_sec1); + + sg_count = edesc->src_nents ?: 1; + if (is_sec1 && sg_count > 1) + sg_copy_to_buffer(areq->src, sg_count, edesc->buf, + cryptlen); + else + sg_count = dma_map_sg(dev, areq->src, sg_count, + (areq->src == areq->dst) ? + DMA_BIDIRECTIONAL : DMA_TO_DEVICE); + /* + * cipher in + */ + sg_count = talitos_sg_map_ext(dev, areq->src, cryptlen, edesc, &desc->ptr[3], + sg_count, 0, 0, 0, false, is_ctr ? 16 : 1); + if (sg_count > 1) + sync_needed = true; + + /* cipher out */ + if (areq->src != areq->dst) { + sg_count = edesc->dst_nents ? : 1; + if (!is_sec1 || sg_count == 1) + dma_map_sg(dev, areq->dst, sg_count, DMA_FROM_DEVICE); + } + + ret = talitos_sg_map(dev, areq->dst, cryptlen, edesc, &desc->ptr[4], + sg_count, 0, (edesc->src_nents + 1)); + if (ret > 1) + sync_needed = true; + + /* iv out */ + map_single_talitos_ptr(dev, &desc->ptr[5], ivsize, ctx->iv, + DMA_FROM_DEVICE); + + /* last DWORD empty */ + + if (sync_needed) + dma_sync_single_for_device(dev, edesc->dma_link_tbl, + edesc->dma_len, DMA_BIDIRECTIONAL); + + ret = talitos_submit(dev, ctx->ch, desc, callback, areq); + if (ret != -EINPROGRESS) { + common_nonsnoop_unmap(dev, edesc, areq); + kfree(edesc); + } + return ret; +} + +static int skcipher_setkey(struct crypto_skcipher *cipher, + const u8 *key, unsigned int keylen) +{ + struct talitos_ctx *ctx = crypto_skcipher_ctx(cipher); + struct device *dev = ctx->dev; + + if (ctx->keylen) + dma_unmap_single(dev, ctx->dma_key, ctx->keylen, DMA_TO_DEVICE); + + memcpy(&ctx->key, key, keylen); + ctx->keylen = keylen; + + ctx->dma_key = dma_map_single(dev, ctx->key, keylen, DMA_TO_DEVICE); + + return 0; +} + +static int skcipher_des_setkey(struct crypto_skcipher *cipher, + const u8 *key, unsigned int keylen) +{ + return verify_skcipher_des_key(cipher, key) ?: + skcipher_setkey(cipher, key, keylen); +} + +static int skcipher_des3_setkey(struct crypto_skcipher *cipher, + const u8 *key, unsigned int keylen) +{ + return verify_skcipher_des3_key(cipher, key) ?: + skcipher_setkey(cipher, key, keylen); +} + +static int skcipher_aes_setkey(struct crypto_skcipher *cipher, + const u8 *key, unsigned int keylen) +{ + if (keylen == AES_KEYSIZE_128 || keylen == AES_KEYSIZE_192 || + keylen == AES_KEYSIZE_256) + return skcipher_setkey(cipher, key, keylen); + + return -EINVAL; +} + +static struct talitos_edesc *skcipher_edesc_alloc(struct skcipher_request * + areq, bool encrypt) +{ + struct crypto_skcipher *cipher = crypto_skcipher_reqtfm(areq); + struct talitos_ctx *ctx = crypto_skcipher_ctx(cipher); + unsigned int ivsize = crypto_skcipher_ivsize(cipher); + + return talitos_edesc_alloc(ctx->dev, areq->src, areq->dst, + areq->iv, 0, areq->cryptlen, 0, ivsize, 0, + areq->base.flags, encrypt); +} + +static int skcipher_encrypt(struct skcipher_request *areq) +{ + struct crypto_skcipher *cipher = crypto_skcipher_reqtfm(areq); + struct talitos_ctx *ctx = crypto_skcipher_ctx(cipher); + struct talitos_edesc *edesc; + unsigned int blocksize = + crypto_tfm_alg_blocksize(crypto_skcipher_tfm(cipher)); + + if (!areq->cryptlen) + return 0; + + if (areq->cryptlen % blocksize) + return -EINVAL; + + /* allocate extended descriptor */ + edesc = skcipher_edesc_alloc(areq, true); + if (IS_ERR(edesc)) + return PTR_ERR(edesc); + + /* set encrypt */ + edesc->desc.hdr = ctx->desc_hdr_template | DESC_HDR_MODE0_ENCRYPT; + + return common_nonsnoop(edesc, areq, skcipher_done); +} + +static int skcipher_decrypt(struct skcipher_request *areq) +{ + struct crypto_skcipher *cipher = crypto_skcipher_reqtfm(areq); + struct talitos_ctx *ctx = crypto_skcipher_ctx(cipher); + struct talitos_edesc *edesc; + unsigned int blocksize = + crypto_tfm_alg_blocksize(crypto_skcipher_tfm(cipher)); + + if (!areq->cryptlen) + return 0; + + if (areq->cryptlen % blocksize) + return -EINVAL; + + /* allocate extended descriptor */ + edesc = skcipher_edesc_alloc(areq, false); + if (IS_ERR(edesc)) + return PTR_ERR(edesc); + + edesc->desc.hdr = ctx->desc_hdr_template | DESC_HDR_DIR_INBOUND; + + return common_nonsnoop(edesc, areq, skcipher_done); +} + +static int talitos_cra_init_skcipher(struct crypto_skcipher *tfm) +{ + struct skcipher_alg *alg = crypto_skcipher_alg(tfm); + struct talitos_crypto_alg *talitos_alg; + struct talitos_ctx *ctx = crypto_skcipher_ctx(tfm); + + talitos_alg = container_of(alg, struct talitos_crypto_alg, + algt.alg.skcipher); + + return talitos_init_common(ctx, talitos_alg); +} + +static struct talitos_alg_template skcipher_driver_algs[] = { + { .type = CRYPTO_ALG_TYPE_SKCIPHER, + .alg.skcipher = { + .base.cra_name = "ecb(aes)", + .base.cra_driver_name = "ecb-aes-talitos", + .base.cra_blocksize = AES_BLOCK_SIZE, + .base.cra_flags = CRYPTO_ALG_ASYNC | + CRYPTO_ALG_ALLOCATES_MEMORY, + .min_keysize = AES_MIN_KEY_SIZE, + .max_keysize = AES_MAX_KEY_SIZE, + .setkey = skcipher_aes_setkey, + }, + .desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU | + DESC_HDR_SEL0_AESU, + }, + { .type = CRYPTO_ALG_TYPE_SKCIPHER, + .alg.skcipher = { + .base.cra_name = "cbc(aes)", + .base.cra_driver_name = "cbc-aes-talitos", + .base.cra_blocksize = AES_BLOCK_SIZE, + .base.cra_flags = CRYPTO_ALG_ASYNC | + CRYPTO_ALG_ALLOCATES_MEMORY, + .min_keysize = AES_MIN_KEY_SIZE, + .max_keysize = AES_MAX_KEY_SIZE, + .ivsize = AES_BLOCK_SIZE, + .setkey = skcipher_aes_setkey, + }, + .desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU | + DESC_HDR_SEL0_AESU | + DESC_HDR_MODE0_AESU_CBC, + }, + { .type = CRYPTO_ALG_TYPE_SKCIPHER, + .alg.skcipher = { + .base.cra_name = "ctr(aes)", + .base.cra_driver_name = "ctr-aes-talitos", + .base.cra_blocksize = 1, + .base.cra_flags = CRYPTO_ALG_ASYNC | + CRYPTO_ALG_ALLOCATES_MEMORY, + .min_keysize = AES_MIN_KEY_SIZE, + .max_keysize = AES_MAX_KEY_SIZE, + .ivsize = AES_BLOCK_SIZE, + .setkey = skcipher_aes_setkey, + }, + .desc_hdr_template = DESC_HDR_TYPE_AESU_CTR_NONSNOOP | + DESC_HDR_SEL0_AESU | + DESC_HDR_MODE0_AESU_CTR, + }, + { .type = CRYPTO_ALG_TYPE_SKCIPHER, + .alg.skcipher = { + .base.cra_name = "ctr(aes)", + .base.cra_driver_name = "ctr-aes-talitos", + .base.cra_blocksize = 1, + .base.cra_flags = CRYPTO_ALG_ASYNC | + CRYPTO_ALG_ALLOCATES_MEMORY, + .min_keysize = AES_MIN_KEY_SIZE, + .max_keysize = AES_MAX_KEY_SIZE, + .ivsize = AES_BLOCK_SIZE, + .setkey = skcipher_aes_setkey, + }, + .desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU | + DESC_HDR_SEL0_AESU | + DESC_HDR_MODE0_AESU_CTR, + }, + { .type = CRYPTO_ALG_TYPE_SKCIPHER, + .alg.skcipher = { + .base.cra_name = "ecb(des)", + .base.cra_driver_name = "ecb-des-talitos", + .base.cra_blocksize = DES_BLOCK_SIZE, + .base.cra_flags = CRYPTO_ALG_ASYNC | + CRYPTO_ALG_ALLOCATES_MEMORY, + .min_keysize = DES_KEY_SIZE, + .max_keysize = DES_KEY_SIZE, + .setkey = skcipher_des_setkey, + }, + .desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU | + DESC_HDR_SEL0_DEU, + }, + { .type = CRYPTO_ALG_TYPE_SKCIPHER, + .alg.skcipher = { + .base.cra_name = "cbc(des)", + .base.cra_driver_name = "cbc-des-talitos", + .base.cra_blocksize = DES_BLOCK_SIZE, + .base.cra_flags = CRYPTO_ALG_ASYNC | + CRYPTO_ALG_ALLOCATES_MEMORY, + .min_keysize = DES_KEY_SIZE, + .max_keysize = DES_KEY_SIZE, + .ivsize = DES_BLOCK_SIZE, + .setkey = skcipher_des_setkey, + }, + .desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU | + DESC_HDR_SEL0_DEU | + DESC_HDR_MODE0_DEU_CBC, + }, + { .type = CRYPTO_ALG_TYPE_SKCIPHER, + .alg.skcipher = { + .base.cra_name = "ecb(des3_ede)", + .base.cra_driver_name = "ecb-3des-talitos", + .base.cra_blocksize = DES3_EDE_BLOCK_SIZE, + .base.cra_flags = CRYPTO_ALG_ASYNC | + CRYPTO_ALG_ALLOCATES_MEMORY, + .min_keysize = DES3_EDE_KEY_SIZE, + .max_keysize = DES3_EDE_KEY_SIZE, + .setkey = skcipher_des3_setkey, + }, + .desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU | + DESC_HDR_SEL0_DEU | + DESC_HDR_MODE0_DEU_3DES, + }, + { .type = CRYPTO_ALG_TYPE_SKCIPHER, + .alg.skcipher = { + .base.cra_name = "cbc(des3_ede)", + .base.cra_driver_name = "cbc-3des-talitos", + .base.cra_blocksize = DES3_EDE_BLOCK_SIZE, + .base.cra_flags = CRYPTO_ALG_ASYNC | + CRYPTO_ALG_ALLOCATES_MEMORY, + .min_keysize = DES3_EDE_KEY_SIZE, + .max_keysize = DES3_EDE_KEY_SIZE, + .ivsize = DES3_EDE_BLOCK_SIZE, + .setkey = skcipher_des3_setkey, + }, + .desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU | + DESC_HDR_SEL0_DEU | + DESC_HDR_MODE0_DEU_CBC | + DESC_HDR_MODE0_DEU_3DES, + }, +}; + +int talitos_register_skcipher(struct device *dev) +{ + struct talitos_private *priv = dev_get_drvdata(dev); + struct skcipher_alg *skcipher_alg; + struct crypto_alg *alg; + size_t i; + int ret; + + for (i = 0; i < ARRAY_SIZE(skcipher_driver_algs); i++) { + if (!talitos_hw_supports( + dev, skcipher_driver_algs[i].desc_hdr_template)) + continue; + + skcipher_alg = &skcipher_driver_algs[i].alg.skcipher; + alg = &skcipher_alg->base; + + alg->cra_exit = talitos_cra_exit; + if (has_ftr_sec1(priv)) + alg->cra_alignmask = 3; + + skcipher_alg->init = talitos_cra_init_skcipher; + skcipher_alg->setkey = skcipher_alg->setkey ?: skcipher_setkey; + skcipher_alg->encrypt = skcipher_encrypt; + skcipher_alg->decrypt = skcipher_decrypt; + + if (!strcmp(alg->cra_name, "ctr(aes)") && !has_ftr_sec1(priv) && + DESC_TYPE(skcipher_driver_algs[i].desc_hdr_template) != + DESC_TYPE(DESC_HDR_TYPE_AESU_CTR_NONSNOOP)) { + continue; + } + + ret = talitos_register_common(dev, &skcipher_driver_algs[i]); + if (ret) + return ret; + } + + return 0; +} diff --git a/drivers/crypto/talitos/talitos.c b/drivers/crypto/talitos/talitos.c index 2d5688b1c81e..4b77253e04fa 100644 --- a/drivers/crypto/talitos/talitos.c +++ b/drivers/crypto/talitos/talitos.c @@ -1337,215 +1337,6 @@ static int aead_decrypt(struct aead_request *req) return ipsec_esp(edesc, req, false, ipsec_esp_decrypt_swauth_done); } -static int skcipher_setkey(struct crypto_skcipher *cipher, - const u8 *key, unsigned int keylen) -{ - struct talitos_ctx *ctx = crypto_skcipher_ctx(cipher); - struct device *dev = ctx->dev; - - if (ctx->keylen) - dma_unmap_single(dev, ctx->dma_key, ctx->keylen, DMA_TO_DEVICE); - - memcpy(&ctx->key, key, keylen); - ctx->keylen = keylen; - - ctx->dma_key = dma_map_single(dev, ctx->key, keylen, DMA_TO_DEVICE); - - return 0; -} - -static int skcipher_des_setkey(struct crypto_skcipher *cipher, - const u8 *key, unsigned int keylen) -{ - return verify_skcipher_des_key(cipher, key) ?: - skcipher_setkey(cipher, key, keylen); -} - -static int skcipher_des3_setkey(struct crypto_skcipher *cipher, - const u8 *key, unsigned int keylen) -{ - return verify_skcipher_des3_key(cipher, key) ?: - skcipher_setkey(cipher, key, keylen); -} - -static int skcipher_aes_setkey(struct crypto_skcipher *cipher, - const u8 *key, unsigned int keylen) -{ - if (keylen == AES_KEYSIZE_128 || keylen == AES_KEYSIZE_192 || - keylen == AES_KEYSIZE_256) - return skcipher_setkey(cipher, key, keylen); - - return -EINVAL; -} - -static void common_nonsnoop_unmap(struct device *dev, - struct talitos_edesc *edesc, - struct skcipher_request *areq) -{ - unmap_single_talitos_ptr(dev, &edesc->desc.ptr[5], DMA_FROM_DEVICE); - - talitos_sg_unmap(dev, edesc, areq->src, areq->dst, areq->cryptlen, 0); - unmap_single_talitos_ptr(dev, &edesc->desc.ptr[1], DMA_TO_DEVICE); - - if (edesc->dma_len) - dma_unmap_single(dev, edesc->dma_link_tbl, edesc->dma_len, - DMA_BIDIRECTIONAL); -} - -static void skcipher_done(struct device *dev, - struct talitos_desc *desc, void *context, - int err) -{ - struct skcipher_request *areq = context; - struct crypto_skcipher *cipher = crypto_skcipher_reqtfm(areq); - struct talitos_ctx *ctx = crypto_skcipher_ctx(cipher); - unsigned int ivsize = crypto_skcipher_ivsize(cipher); - struct talitos_edesc *edesc; - - edesc = container_of(desc, struct talitos_edesc, desc); - - common_nonsnoop_unmap(dev, edesc, areq); - memcpy(areq->iv, ctx->iv, ivsize); - - kfree(edesc); - - skcipher_request_complete(areq, err); -} - -static int common_nonsnoop(struct talitos_edesc *edesc, - struct skcipher_request *areq, - void (*callback) (struct device *dev, - struct talitos_desc *desc, - void *context, int error)) -{ - struct crypto_skcipher *cipher = crypto_skcipher_reqtfm(areq); - struct talitos_ctx *ctx = crypto_skcipher_ctx(cipher); - struct device *dev = ctx->dev; - struct talitos_desc *desc = &edesc->desc; - unsigned int cryptlen = areq->cryptlen; - unsigned int ivsize = crypto_skcipher_ivsize(cipher); - int sg_count, ret; - bool sync_needed = false; - struct talitos_private *priv = dev_get_drvdata(dev); - bool is_sec1 = has_ftr_sec1(priv); - bool is_ctr = (desc->hdr & DESC_HDR_SEL0_MASK) == DESC_HDR_SEL0_AESU && - (desc->hdr & DESC_HDR_MODE0_AESU_MASK) == DESC_HDR_MODE0_AESU_CTR; - - /* first DWORD empty */ - - /* cipher iv */ - to_talitos_ptr(&desc->ptr[1], edesc->iv_dma, ivsize, is_sec1); - - /* cipher key */ - to_talitos_ptr(&desc->ptr[2], ctx->dma_key, ctx->keylen, is_sec1); - - sg_count = edesc->src_nents ?: 1; - if (is_sec1 && sg_count > 1) - sg_copy_to_buffer(areq->src, sg_count, edesc->buf, - cryptlen); - else - sg_count = dma_map_sg(dev, areq->src, sg_count, - (areq->src == areq->dst) ? - DMA_BIDIRECTIONAL : DMA_TO_DEVICE); - /* - * cipher in - */ - sg_count = talitos_sg_map_ext(dev, areq->src, cryptlen, edesc, &desc->ptr[3], - sg_count, 0, 0, 0, false, is_ctr ? 16 : 1); - if (sg_count > 1) - sync_needed = true; - - /* cipher out */ - if (areq->src != areq->dst) { - sg_count = edesc->dst_nents ? : 1; - if (!is_sec1 || sg_count == 1) - dma_map_sg(dev, areq->dst, sg_count, DMA_FROM_DEVICE); - } - - ret = talitos_sg_map(dev, areq->dst, cryptlen, edesc, &desc->ptr[4], - sg_count, 0, (edesc->src_nents + 1)); - if (ret > 1) - sync_needed = true; - - /* iv out */ - map_single_talitos_ptr(dev, &desc->ptr[5], ivsize, ctx->iv, - DMA_FROM_DEVICE); - - /* last DWORD empty */ - - if (sync_needed) - dma_sync_single_for_device(dev, edesc->dma_link_tbl, - edesc->dma_len, DMA_BIDIRECTIONAL); - - ret = talitos_submit(dev, ctx->ch, desc, callback, areq); - if (ret != -EINPROGRESS) { - common_nonsnoop_unmap(dev, edesc, areq); - kfree(edesc); - } - return ret; -} - -static struct talitos_edesc *skcipher_edesc_alloc(struct skcipher_request * - areq, bool encrypt) -{ - struct crypto_skcipher *cipher = crypto_skcipher_reqtfm(areq); - struct talitos_ctx *ctx = crypto_skcipher_ctx(cipher); - unsigned int ivsize = crypto_skcipher_ivsize(cipher); - - return talitos_edesc_alloc(ctx->dev, areq->src, areq->dst, - areq->iv, 0, areq->cryptlen, 0, ivsize, 0, - areq->base.flags, encrypt); -} - -static int skcipher_encrypt(struct skcipher_request *areq) -{ - struct crypto_skcipher *cipher = crypto_skcipher_reqtfm(areq); - struct talitos_ctx *ctx = crypto_skcipher_ctx(cipher); - struct talitos_edesc *edesc; - unsigned int blocksize = - crypto_tfm_alg_blocksize(crypto_skcipher_tfm(cipher)); - - if (!areq->cryptlen) - return 0; - - if (areq->cryptlen % blocksize) - return -EINVAL; - - /* allocate extended descriptor */ - edesc = skcipher_edesc_alloc(areq, true); - if (IS_ERR(edesc)) - return PTR_ERR(edesc); - - /* set encrypt */ - edesc->desc.hdr = ctx->desc_hdr_template | DESC_HDR_MODE0_ENCRYPT; - - return common_nonsnoop(edesc, areq, skcipher_done); -} - -static int skcipher_decrypt(struct skcipher_request *areq) -{ - struct crypto_skcipher *cipher = crypto_skcipher_reqtfm(areq); - struct talitos_ctx *ctx = crypto_skcipher_ctx(cipher); - struct talitos_edesc *edesc; - unsigned int blocksize = - crypto_tfm_alg_blocksize(crypto_skcipher_tfm(cipher)); - - if (!areq->cryptlen) - return 0; - - if (areq->cryptlen % blocksize) - return -EINVAL; - - /* allocate extended descriptor */ - edesc = skcipher_edesc_alloc(areq, false); - if (IS_ERR(edesc)) - return PTR_ERR(edesc); - - edesc->desc.hdr = ctx->desc_hdr_template | DESC_HDR_DIR_INBOUND; - - return common_nonsnoop(edesc, areq, skcipher_done); -} - static struct talitos_alg_template driver_algs[] = { /* AEAD algorithms. These use a single-pass ipsec_esp descriptor */ { .type = CRYPTO_ALG_TYPE_AEAD, @@ -2004,131 +1795,6 @@ static struct talitos_alg_template driver_algs[] = { DESC_HDR_MODE1_MDEU_PAD | DESC_HDR_MODE1_MDEU_MD5_HMAC, }, - /* SKCIPHER algorithms. */ - { .type = CRYPTO_ALG_TYPE_SKCIPHER, - .alg.skcipher = { - .base.cra_name = "ecb(aes)", - .base.cra_driver_name = "ecb-aes-talitos", - .base.cra_blocksize = AES_BLOCK_SIZE, - .base.cra_flags = CRYPTO_ALG_ASYNC | - CRYPTO_ALG_ALLOCATES_MEMORY, - .min_keysize = AES_MIN_KEY_SIZE, - .max_keysize = AES_MAX_KEY_SIZE, - .setkey = skcipher_aes_setkey, - }, - .desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU | - DESC_HDR_SEL0_AESU, - }, - { .type = CRYPTO_ALG_TYPE_SKCIPHER, - .alg.skcipher = { - .base.cra_name = "cbc(aes)", - .base.cra_driver_name = "cbc-aes-talitos", - .base.cra_blocksize = AES_BLOCK_SIZE, - .base.cra_flags = CRYPTO_ALG_ASYNC | - CRYPTO_ALG_ALLOCATES_MEMORY, - .min_keysize = AES_MIN_KEY_SIZE, - .max_keysize = AES_MAX_KEY_SIZE, - .ivsize = AES_BLOCK_SIZE, - .setkey = skcipher_aes_setkey, - }, - .desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU | - DESC_HDR_SEL0_AESU | - DESC_HDR_MODE0_AESU_CBC, - }, - { .type = CRYPTO_ALG_TYPE_SKCIPHER, - .alg.skcipher = { - .base.cra_name = "ctr(aes)", - .base.cra_driver_name = "ctr-aes-talitos", - .base.cra_blocksize = 1, - .base.cra_flags = CRYPTO_ALG_ASYNC | - CRYPTO_ALG_ALLOCATES_MEMORY, - .min_keysize = AES_MIN_KEY_SIZE, - .max_keysize = AES_MAX_KEY_SIZE, - .ivsize = AES_BLOCK_SIZE, - .setkey = skcipher_aes_setkey, - }, - .desc_hdr_template = DESC_HDR_TYPE_AESU_CTR_NONSNOOP | - DESC_HDR_SEL0_AESU | - DESC_HDR_MODE0_AESU_CTR, - }, - { .type = CRYPTO_ALG_TYPE_SKCIPHER, - .alg.skcipher = { - .base.cra_name = "ctr(aes)", - .base.cra_driver_name = "ctr-aes-talitos", - .base.cra_blocksize = 1, - .base.cra_flags = CRYPTO_ALG_ASYNC | - CRYPTO_ALG_ALLOCATES_MEMORY, - .min_keysize = AES_MIN_KEY_SIZE, - .max_keysize = AES_MAX_KEY_SIZE, - .ivsize = AES_BLOCK_SIZE, - .setkey = skcipher_aes_setkey, - }, - .desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU | - DESC_HDR_SEL0_AESU | - DESC_HDR_MODE0_AESU_CTR, - }, - { .type = CRYPTO_ALG_TYPE_SKCIPHER, - .alg.skcipher = { - .base.cra_name = "ecb(des)", - .base.cra_driver_name = "ecb-des-talitos", - .base.cra_blocksize = DES_BLOCK_SIZE, - .base.cra_flags = CRYPTO_ALG_ASYNC | - CRYPTO_ALG_ALLOCATES_MEMORY, - .min_keysize = DES_KEY_SIZE, - .max_keysize = DES_KEY_SIZE, - .setkey = skcipher_des_setkey, - }, - .desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU | - DESC_HDR_SEL0_DEU, - }, - { .type = CRYPTO_ALG_TYPE_SKCIPHER, - .alg.skcipher = { - .base.cra_name = "cbc(des)", - .base.cra_driver_name = "cbc-des-talitos", - .base.cra_blocksize = DES_BLOCK_SIZE, - .base.cra_flags = CRYPTO_ALG_ASYNC | - CRYPTO_ALG_ALLOCATES_MEMORY, - .min_keysize = DES_KEY_SIZE, - .max_keysize = DES_KEY_SIZE, - .ivsize = DES_BLOCK_SIZE, - .setkey = skcipher_des_setkey, - }, - .desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU | - DESC_HDR_SEL0_DEU | - DESC_HDR_MODE0_DEU_CBC, - }, - { .type = CRYPTO_ALG_TYPE_SKCIPHER, - .alg.skcipher = { - .base.cra_name = "ecb(des3_ede)", - .base.cra_driver_name = "ecb-3des-talitos", - .base.cra_blocksize = DES3_EDE_BLOCK_SIZE, - .base.cra_flags = CRYPTO_ALG_ASYNC | - CRYPTO_ALG_ALLOCATES_MEMORY, - .min_keysize = DES3_EDE_KEY_SIZE, - .max_keysize = DES3_EDE_KEY_SIZE, - .setkey = skcipher_des3_setkey, - }, - .desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU | - DESC_HDR_SEL0_DEU | - DESC_HDR_MODE0_DEU_3DES, - }, - { .type = CRYPTO_ALG_TYPE_SKCIPHER, - .alg.skcipher = { - .base.cra_name = "cbc(des3_ede)", - .base.cra_driver_name = "cbc-3des-talitos", - .base.cra_blocksize = DES3_EDE_BLOCK_SIZE, - .base.cra_flags = CRYPTO_ALG_ASYNC | - CRYPTO_ALG_ALLOCATES_MEMORY, - .min_keysize = DES3_EDE_KEY_SIZE, - .max_keysize = DES3_EDE_KEY_SIZE, - .ivsize = DES3_EDE_BLOCK_SIZE, - .setkey = skcipher_des3_setkey, - }, - .desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU | - DESC_HDR_SEL0_DEU | - DESC_HDR_MODE0_DEU_CBC | - DESC_HDR_MODE0_DEU_3DES, - }, }; int talitos_init_common(struct talitos_ctx *ctx, @@ -2165,18 +1831,6 @@ static int talitos_cra_init_aead(struct crypto_aead *tfm) return talitos_init_common(ctx, talitos_alg); } -static int talitos_cra_init_skcipher(struct crypto_skcipher *tfm) -{ - struct skcipher_alg *alg = crypto_skcipher_alg(tfm); - struct talitos_crypto_alg *talitos_alg; - struct talitos_ctx *ctx = crypto_skcipher_ctx(tfm); - - talitos_alg = container_of(alg, struct talitos_crypto_alg, - algt.alg.skcipher); - - return talitos_init_common(ctx, talitos_alg); -} - void talitos_cra_exit(struct crypto_tfm *tfm) { struct talitos_ctx *ctx = crypto_tfm_ctx(tfm); @@ -2281,6 +1935,12 @@ int talitos_register_common(struct device *dev, t_alg->algt.type); ret = crypto_register_ahash(&t_alg->algt.alg.hash); break; + case CRYPTO_ALG_TYPE_SKCIPHER: + alg = &t_alg->algt.alg.skcipher.base; + talitos_alg_set_common(priv, alg, t_alg->algt.priority, + t_alg->algt.type); + ret = crypto_register_skcipher(&t_alg->algt.alg.skcipher); + break; default: dev_err(dev, "unknown algorithm type %d\n", t_alg->algt.type); devm_kfree(dev, t_alg); @@ -2317,21 +1977,6 @@ static struct talitos_crypto_alg *talitos_alg_alloc(struct device *dev, t_alg->algt = *template; switch (t_alg->algt.type) { - case CRYPTO_ALG_TYPE_SKCIPHER: - alg = &t_alg->algt.alg.skcipher.base; - alg->cra_exit = talitos_cra_exit; - t_alg->algt.alg.skcipher.init = talitos_cra_init_skcipher; - t_alg->algt.alg.skcipher.setkey = - t_alg->algt.alg.skcipher.setkey ?: skcipher_setkey; - t_alg->algt.alg.skcipher.encrypt = skcipher_encrypt; - t_alg->algt.alg.skcipher.decrypt = skcipher_decrypt; - if (!strcmp(alg->cra_name, "ctr(aes)") && !has_ftr_sec1(priv) && - DESC_TYPE(t_alg->algt.desc_hdr_template) != - DESC_TYPE(DESC_HDR_TYPE_AESU_CTR_NONSNOOP)) { - devm_kfree(dev, t_alg); - return ERR_PTR(-ENOTSUPP); - } - break; case CRYPTO_ALG_TYPE_AEAD: alg = &t_alg->algt.alg.aead.base; alg->cra_exit = talitos_cra_exit; @@ -2578,6 +2223,10 @@ static int talitos_probe(struct platform_device *ofdev) if (err) goto err_out; + err = talitos_register_skcipher(dev); + if (err) + goto err_out; + /* register crypto algorithms the device supports */ for (i = 0; i < ARRAY_SIZE(driver_algs); i++) { if (talitos_hw_supports(dev, @@ -2594,12 +2243,6 @@ static int talitos_probe(struct platform_device *ofdev) } switch (t_alg->algt.type) { - case CRYPTO_ALG_TYPE_SKCIPHER: - err = crypto_register_skcipher( - &t_alg->algt.alg.skcipher); - alg = &t_alg->algt.alg.skcipher.base; - break; - case CRYPTO_ALG_TYPE_AEAD: err = crypto_register_aead( &t_alg->algt.alg.aead); diff --git a/drivers/crypto/talitos/talitos.h b/drivers/crypto/talitos/talitos.h index e59c85e3196c..4a803ad6349d 100644 --- a/drivers/crypto/talitos/talitos.h +++ b/drivers/crypto/talitos/talitos.h @@ -610,3 +610,4 @@ void talitos_unregister_rng(struct device *dev); /* Hash */ int talitos_register_hash(struct device *dev); +int talitos_register_skcipher(struct device *dev); -- 2.55.0