[2/4] crypto: nx - convert AES-ECB to skcipher API

From: Eric Biggers <ebiggers@google.com>

Convert the PowerPC Nest (NX) implementation of AES-ECB from the
deprecated "blkcipher" API to the "skcipher" API.  This is needed in
order for the blkcipher API to be removed.

Signed-off-by: Eric Biggers <ebiggers@google.com>
---
 drivers/crypto/nx/nx-aes-ecb.c | 76 ++++++++++++++--------------------
 drivers/crypto/nx/nx.c         | 28 ++++++++++---
 drivers/crypto/nx/nx.h         |  5 ++-
 3 files changed, 58 insertions(+), 51 deletions(-)

On Sun, 13 Oct 2019 at 06:40, Eric Biggers <ebiggers@kernel.org> wrote:
>
> From: Eric Biggers <ebiggers@google.com>
>
> Convert the PowerPC Nest (NX) implementation of AES-ECB from the
> deprecated "blkcipher" API to the "skcipher" API.  This is needed in
> order for the blkcipher API to be removed.
>
> Signed-off-by: Eric Biggers <ebiggers@google.com>

Reviewed-by: Ard Biesheuvel <ard.biesheuvel@linaro.org>

> ---
>  drivers/crypto/nx/nx-aes-ecb.c | 76 ++++++++++++++--------------------
>  drivers/crypto/nx/nx.c         | 28 ++++++++++---
>  drivers/crypto/nx/nx.h         |  5 ++-
>  3 files changed, 58 insertions(+), 51 deletions(-)
>
> diff --git a/drivers/crypto/nx/nx-aes-ecb.c b/drivers/crypto/nx/nx-aes-ecb.c
> index 87183890d1ab..77e338dc33f1 100644
> --- a/drivers/crypto/nx/nx-aes-ecb.c
> +++ b/drivers/crypto/nx/nx-aes-ecb.c
> @@ -18,11 +18,11 @@
>  #include "nx.h"
>
>
> -static int ecb_aes_nx_set_key(struct crypto_tfm *tfm,
> -                             const u8          *in_key,
> -                             unsigned int       key_len)
> +static int ecb_aes_nx_set_key(struct crypto_skcipher *tfm,
> +                             const u8               *in_key,
> +                             unsigned int            key_len)
>  {
> -       struct nx_crypto_ctx *nx_ctx = crypto_tfm_ctx(tfm);
> +       struct nx_crypto_ctx *nx_ctx = crypto_skcipher_ctx(tfm);
>         struct nx_csbcpb *csbcpb = (struct nx_csbcpb *)nx_ctx->csbcpb;
>
>         nx_ctx_init(nx_ctx, HCOP_FC_AES);
> @@ -50,13 +50,11 @@ static int ecb_aes_nx_set_key(struct crypto_tfm *tfm,
>         return 0;
>  }
>
> -static int ecb_aes_nx_crypt(struct blkcipher_desc *desc,
> -                           struct scatterlist    *dst,
> -                           struct scatterlist    *src,
> -                           unsigned int           nbytes,
> -                           int                    enc)
> +static int ecb_aes_nx_crypt(struct skcipher_request *req,
> +                           int                      enc)
>  {
> -       struct nx_crypto_ctx *nx_ctx = crypto_blkcipher_ctx(desc->tfm);
> +       struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
> +       struct nx_crypto_ctx *nx_ctx = crypto_skcipher_ctx(tfm);
>         struct nx_csbcpb *csbcpb = nx_ctx->csbcpb;
>         unsigned long irq_flags;
>         unsigned int processed = 0, to_process;
> @@ -70,10 +68,10 @@ static int ecb_aes_nx_crypt(struct blkcipher_desc *desc,
>                 NX_CPB_FDM(csbcpb) &= ~NX_FDM_ENDE_ENCRYPT;
>
>         do {
> -               to_process = nbytes - processed;
> +               to_process = req->cryptlen - processed;
>
> -               rc = nx_build_sg_lists(nx_ctx, NULL, dst, src, &to_process,
> -                                      processed, NULL);
> +               rc = nx_build_sg_lists(nx_ctx, NULL, req->dst, req->src,
> +                                      &to_process, processed, NULL);
>                 if (rc)
>                         goto out;
>
> @@ -83,7 +81,7 @@ static int ecb_aes_nx_crypt(struct blkcipher_desc *desc,
>                 }
>
>                 rc = nx_hcall_sync(nx_ctx, &nx_ctx->op,
> -                                  desc->flags & CRYPTO_TFM_REQ_MAY_SLEEP);
> +                                  req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP);
>                 if (rc)
>                         goto out;
>
> @@ -92,46 +90,36 @@ static int ecb_aes_nx_crypt(struct blkcipher_desc *desc,
>                              &(nx_ctx->stats->aes_bytes));
>
>                 processed += to_process;
> -       } while (processed < nbytes);
> +       } while (processed < req->cryptlen);
>
>  out:
>         spin_unlock_irqrestore(&nx_ctx->lock, irq_flags);
>         return rc;
>  }
>
> -static int ecb_aes_nx_encrypt(struct blkcipher_desc *desc,
> -                             struct scatterlist    *dst,
> -                             struct scatterlist    *src,
> -                             unsigned int           nbytes)
> +static int ecb_aes_nx_encrypt(struct skcipher_request *req)
>  {
> -       return ecb_aes_nx_crypt(desc, dst, src, nbytes, 1);
> +       return ecb_aes_nx_crypt(req, 1);
>  }
>
> -static int ecb_aes_nx_decrypt(struct blkcipher_desc *desc,
> -                             struct scatterlist    *dst,
> -                             struct scatterlist    *src,
> -                             unsigned int           nbytes)
> +static int ecb_aes_nx_decrypt(struct skcipher_request *req)
>  {
> -       return ecb_aes_nx_crypt(desc, dst, src, nbytes, 0);
> +       return ecb_aes_nx_crypt(req, 0);
>  }
>
> -struct crypto_alg nx_ecb_aes_alg = {
> -       .cra_name        = "ecb(aes)",
> -       .cra_driver_name = "ecb-aes-nx",
> -       .cra_priority    = 300,
> -       .cra_flags       = CRYPTO_ALG_TYPE_BLKCIPHER,
> -       .cra_blocksize   = AES_BLOCK_SIZE,
> -       .cra_alignmask   = 0xf,
> -       .cra_ctxsize     = sizeof(struct nx_crypto_ctx),
> -       .cra_type        = &crypto_blkcipher_type,
> -       .cra_module      = THIS_MODULE,
> -       .cra_init        = nx_crypto_ctx_aes_ecb_init,
> -       .cra_exit        = nx_crypto_ctx_exit,
> -       .cra_blkcipher = {
> -               .min_keysize = AES_MIN_KEY_SIZE,
> -               .max_keysize = AES_MAX_KEY_SIZE,
> -               .setkey      = ecb_aes_nx_set_key,
> -               .encrypt     = ecb_aes_nx_encrypt,
> -               .decrypt     = ecb_aes_nx_decrypt,
> -       }
> +struct skcipher_alg nx_ecb_aes_alg = {
> +       .base.cra_name          = "ecb(aes)",
> +       .base.cra_driver_name   = "ecb-aes-nx",
> +       .base.cra_priority      = 300,
> +       .base.cra_blocksize     = AES_BLOCK_SIZE,
> +       .base.cra_alignmask     = 0xf,
> +       .base.cra_ctxsize       = sizeof(struct nx_crypto_ctx),
> +       .base.cra_module        = THIS_MODULE,
> +       .init                   = nx_crypto_ctx_aes_ecb_init,
> +       .exit                   = nx_crypto_ctx_skcipher_exit,
> +       .min_keysize            = AES_MIN_KEY_SIZE,
> +       .max_keysize            = AES_MAX_KEY_SIZE,
> +       .setkey                 = ecb_aes_nx_set_key,
> +       .encrypt                = ecb_aes_nx_encrypt,
> +       .decrypt                = ecb_aes_nx_decrypt,
>  };
> diff --git a/drivers/crypto/nx/nx.c b/drivers/crypto/nx/nx.c
> index 1202a00715ac..4b97081e7486 100644
> --- a/drivers/crypto/nx/nx.c
> +++ b/drivers/crypto/nx/nx.c
> @@ -517,6 +517,12 @@ static int nx_register_alg(struct crypto_alg *alg, u32 fc, u32 mode)
>                crypto_register_alg(alg) : 0;
>  }
>
> +static int nx_register_skcipher(struct skcipher_alg *alg, u32 fc, u32 mode)
> +{
> +       return nx_check_props(&nx_driver.viodev->dev, fc, mode) ?
> +              crypto_register_skcipher(alg) : 0;
> +}
> +
>  static int nx_register_aead(struct aead_alg *alg, u32 fc, u32 mode)
>  {
>         return nx_check_props(&nx_driver.viodev->dev, fc, mode) ?
> @@ -537,6 +543,12 @@ static void nx_unregister_alg(struct crypto_alg *alg, u32 fc, u32 mode)
>                 crypto_unregister_alg(alg);
>  }
>
> +static void nx_unregister_skcipher(struct skcipher_alg *alg, u32 fc, u32 mode)
> +{
> +       if (nx_check_props(NULL, fc, mode))
> +               crypto_unregister_skcipher(alg);
> +}
> +
>  static void nx_unregister_aead(struct aead_alg *alg, u32 fc, u32 mode)
>  {
>         if (nx_check_props(NULL, fc, mode))
> @@ -573,7 +585,7 @@ static int nx_register_algs(void)
>
>         nx_driver.of.status = NX_OKAY;
>
> -       rc = nx_register_alg(&nx_ecb_aes_alg, NX_FC_AES, NX_MODE_AES_ECB);
> +       rc = nx_register_skcipher(&nx_ecb_aes_alg, NX_FC_AES, NX_MODE_AES_ECB);
>         if (rc)
>                 goto out;
>
> @@ -637,7 +649,7 @@ static int nx_register_algs(void)
>  out_unreg_cbc:
>         nx_unregister_alg(&nx_cbc_aes_alg, NX_FC_AES, NX_MODE_AES_CBC);
>  out_unreg_ecb:
> -       nx_unregister_alg(&nx_ecb_aes_alg, NX_FC_AES, NX_MODE_AES_ECB);
> +       nx_unregister_skcipher(&nx_ecb_aes_alg, NX_FC_AES, NX_MODE_AES_ECB);
>  out:
>         return rc;
>  }
> @@ -716,9 +728,9 @@ int nx_crypto_ctx_aes_cbc_init(struct crypto_tfm *tfm)
>                                   NX_MODE_AES_CBC);
>  }
>
> -int nx_crypto_ctx_aes_ecb_init(struct crypto_tfm *tfm)
> +int nx_crypto_ctx_aes_ecb_init(struct crypto_skcipher *tfm)
>  {
> -       return nx_crypto_ctx_init(crypto_tfm_ctx(tfm), NX_FC_AES,
> +       return nx_crypto_ctx_init(crypto_skcipher_ctx(tfm), NX_FC_AES,
>                                   NX_MODE_AES_ECB);
>  }
>
> @@ -752,6 +764,11 @@ void nx_crypto_ctx_exit(struct crypto_tfm *tfm)
>         nx_ctx->out_sg = NULL;
>  }
>
> +void nx_crypto_ctx_skcipher_exit(struct crypto_skcipher *tfm)
> +{
> +       nx_crypto_ctx_exit(crypto_skcipher_ctx(tfm));
> +}
> +
>  void nx_crypto_ctx_aead_exit(struct crypto_aead *tfm)
>  {
>         struct nx_crypto_ctx *nx_ctx = crypto_aead_ctx(tfm);
> @@ -801,7 +818,8 @@ static int nx_remove(struct vio_dev *viodev)
>                 nx_unregister_alg(&nx_ctr3686_aes_alg,
>                                   NX_FC_AES, NX_MODE_AES_CTR);
>                 nx_unregister_alg(&nx_cbc_aes_alg, NX_FC_AES, NX_MODE_AES_CBC);
> -               nx_unregister_alg(&nx_ecb_aes_alg, NX_FC_AES, NX_MODE_AES_ECB);
> +               nx_unregister_skcipher(&nx_ecb_aes_alg, NX_FC_AES,
> +                                      NX_MODE_AES_ECB);
>         }
>
>         return 0;
> diff --git a/drivers/crypto/nx/nx.h b/drivers/crypto/nx/nx.h
> index 768ebae9731e..1a839ef21c4f 100644
> --- a/drivers/crypto/nx/nx.h
> +++ b/drivers/crypto/nx/nx.h
> @@ -147,9 +147,10 @@ int nx_crypto_ctx_aes_gcm_init(struct crypto_aead *tfm);
>  int nx_crypto_ctx_aes_xcbc_init(struct crypto_tfm *tfm);
>  int nx_crypto_ctx_aes_ctr_init(struct crypto_tfm *tfm);
>  int nx_crypto_ctx_aes_cbc_init(struct crypto_tfm *tfm);
> -int nx_crypto_ctx_aes_ecb_init(struct crypto_tfm *tfm);
> +int nx_crypto_ctx_aes_ecb_init(struct crypto_skcipher *tfm);
>  int nx_crypto_ctx_sha_init(struct crypto_tfm *tfm);
>  void nx_crypto_ctx_exit(struct crypto_tfm *tfm);
> +void nx_crypto_ctx_skcipher_exit(struct crypto_skcipher *tfm);
>  void nx_crypto_ctx_aead_exit(struct crypto_aead *tfm);
>  void nx_ctx_init(struct nx_crypto_ctx *nx_ctx, unsigned int function);
>  int nx_hcall_sync(struct nx_crypto_ctx *ctx, struct vio_pfo_op *op,
> @@ -176,7 +177,7 @@ void nx_debugfs_fini(struct nx_crypto_driver *);
>  #define NX_PAGE_NUM(x)         ((u64)(x) & 0xfffffffffffff000ULL)
>
>  extern struct crypto_alg nx_cbc_aes_alg;
> -extern struct crypto_alg nx_ecb_aes_alg;
> +extern struct skcipher_alg nx_ecb_aes_alg;
>  extern struct aead_alg nx_gcm_aes_alg;
>  extern struct aead_alg nx_gcm4106_aes_alg;
>  extern struct crypto_alg nx_ctr3686_aes_alg;
> --
> 2.23.0
>