releases/5.0.18/crypto-caam-qi2-generate-hash-keys-in-place.patch

   1 From 418cd20e4dcdca97e6f6d59e6336228dacf2e45d Mon Sep 17 00:00:00 2001
   2 From: =?UTF-8?q?Horia=20Geant=C4=83?= <horia.geanta@nxp.com>
   3 Date: Thu, 25 Apr 2019 17:52:23 +0300
   4 Subject: crypto: caam/qi2 - generate hash keys in-place
   5 MIME-Version: 1.0
   6 Content-Type: text/plain; charset=UTF-8
   7 Content-Transfer-Encoding: 8bit
   8
   9 From: Horia Geantă <horia.geanta@nxp.com>
  10
  11 commit 418cd20e4dcdca97e6f6d59e6336228dacf2e45d upstream.
  12
  13 Commit 307244452d3d ("crypto: caam - generate hash keys in-place")
  14 fixed ahash implementation in caam/jr driver such that user-provided key
  15 buffer is not DMA mapped, since it's not guaranteed to be DMAable.
  16
  17 Apply a similar fix for caam/qi2 driver.
  18
  19 Cc: <stable@vger.kernel.org> # v4.20+
  20 Fixes: 3f16f6c9d632 ("crypto: caam/qi2 - add support for ahash algorithms")
  21 Signed-off-by: Horia Geantă <horia.geanta@nxp.com>
  22 Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
  23 Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
  24
  25 ---
  26  drivers/crypto/caam/caamalg_qi2.c |   41 +++++++++++++-------------------------
  27  1 file changed, 15 insertions(+), 26 deletions(-)
  28
  29 --- a/drivers/crypto/caam/caamalg_qi2.c
  30 +++ b/drivers/crypto/caam/caamalg_qi2.c
  31 @@ -3021,13 +3021,13 @@ static void split_key_sh_done(void *cbk_
  32  }
  33
  34  /* Digest hash size if it is too large */
  35 -static int hash_digest_key(struct caam_hash_ctx *ctx, const u8 *key_in,
  36 -                          u32 *keylen, u8 *key_out, u32 digestsize)
  37 +static int hash_digest_key(struct caam_hash_ctx *ctx, u32 *keylen, u8 *key,
  38 +                          u32 digestsize)
  39  {
  40         struct caam_request *req_ctx;
  41         u32 *desc;
  42         struct split_key_sh_result result;
  43 -       dma_addr_t src_dma, dst_dma;
  44 +       dma_addr_t key_dma;
  45         struct caam_flc *flc;
  46         dma_addr_t flc_dma;
  47         int ret = -ENOMEM;
  48 @@ -3044,17 +3044,10 @@ static int hash_digest_key(struct caam_h
  49         if (!flc)
  50                 goto err_flc;
  51
  52 -       src_dma = dma_map_single(ctx->dev, (void *)key_in, *keylen,
  53 -                                DMA_TO_DEVICE);
  54 -       if (dma_mapping_error(ctx->dev, src_dma)) {
  55 -               dev_err(ctx->dev, "unable to map key input memory\n");
  56 -               goto err_src_dma;
  57 -       }
  58 -       dst_dma = dma_map_single(ctx->dev, (void *)key_out, digestsize,
  59 -                                DMA_FROM_DEVICE);
  60 -       if (dma_mapping_error(ctx->dev, dst_dma)) {
  61 -               dev_err(ctx->dev, "unable to map key output memory\n");
  62 -               goto err_dst_dma;
  63 +       key_dma = dma_map_single(ctx->dev, key, *keylen, DMA_BIDIRECTIONAL);
  64 +       if (dma_mapping_error(ctx->dev, key_dma)) {
  65 +               dev_err(ctx->dev, "unable to map key memory\n");
  66 +               goto err_key_dma;
  67         }
  68
  69         desc = flc->sh_desc;
  70 @@ -3079,14 +3072,14 @@ static int hash_digest_key(struct caam_h
  71
  72         dpaa2_fl_set_final(in_fle, true);
  73         dpaa2_fl_set_format(in_fle, dpaa2_fl_single);
  74 -       dpaa2_fl_set_addr(in_fle, src_dma);
  75 +       dpaa2_fl_set_addr(in_fle, key_dma);
  76         dpaa2_fl_set_len(in_fle, *keylen);
  77         dpaa2_fl_set_format(out_fle, dpaa2_fl_single);
  78 -       dpaa2_fl_set_addr(out_fle, dst_dma);
  79 +       dpaa2_fl_set_addr(out_fle, key_dma);
  80         dpaa2_fl_set_len(out_fle, digestsize);
  81
  82         print_hex_dump_debug("key_in@" __stringify(__LINE__)": ",
  83 -                            DUMP_PREFIX_ADDRESS, 16, 4, key_in, *keylen, 1);
  84 +                            DUMP_PREFIX_ADDRESS, 16, 4, key, *keylen, 1);
  85         print_hex_dump_debug("shdesc@" __stringify(__LINE__)": ",
  86                              DUMP_PREFIX_ADDRESS, 16, 4, desc, desc_bytes(desc),
  87                              1);
  88 @@ -3106,17 +3099,15 @@ static int hash_digest_key(struct caam_h
  89                 wait_for_completion(&result.completion);
  90                 ret = result.err;
  91                 print_hex_dump_debug("digested key@" __stringify(__LINE__)": ",
  92 -                                    DUMP_PREFIX_ADDRESS, 16, 4, key_in,
  93 +                                    DUMP_PREFIX_ADDRESS, 16, 4, key,
  94                                      digestsize, 1);
  95         }
  96
  97         dma_unmap_single(ctx->dev, flc_dma, sizeof(flc->flc) + desc_bytes(desc),
  98                          DMA_TO_DEVICE);
  99  err_flc_dma:
 100 -       dma_unmap_single(ctx->dev, dst_dma, digestsize, DMA_FROM_DEVICE);
 101 -err_dst_dma:
 102 -       dma_unmap_single(ctx->dev, src_dma, *keylen, DMA_TO_DEVICE);
 103 -err_src_dma:
 104 +       dma_unmap_single(ctx->dev, key_dma, *keylen, DMA_BIDIRECTIONAL);
 105 +err_key_dma:
 106         kfree(flc);
 107  err_flc:
 108         kfree(req_ctx);
 109 @@ -3138,12 +3129,10 @@ static int ahash_setkey(struct crypto_ah
 110         dev_dbg(ctx->dev, "keylen %d blocksize %d\n", keylen, blocksize);
 111
 112         if (keylen > blocksize) {
 113 -               hashed_key = kmalloc_array(digestsize, sizeof(*hashed_key),
 114 -                                          GFP_KERNEL | GFP_DMA);
 115 +               hashed_key = kmemdup(key, keylen, GFP_KERNEL | GFP_DMA);
 116                 if (!hashed_key)
 117                         return -ENOMEM;
 118 -               ret = hash_digest_key(ctx, key, &keylen, hashed_key,
 119 -                                     digestsize);
 120 +               ret = hash_digest_key(ctx, &keylen, hashed_key, digestsize);
 121                 if (ret)
 122                         goto bad_free_key;
 123                 key = hashed_key;