drivers/crypto/allwinner/sun8i-ss/sun8i-ss-prng.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * sun8i-ss-prng.c - hardware cryptographic offloader for
   4  * Allwinner A80/A83T SoC
   5  *
   6  * Copyright (C) 2015-2020 Corentin Labbe <clabbe@baylibre.com>
   7  *
   8  * This file handle the PRNG found in the SS
   9  *
  10  * You could find a link for the datasheet in Documentation/arm/sunxi.rst
  11  */
  12 #include "sun8i-ss.h"
  13 #include <linux/dma-mapping.h>
  14 #include <linux/pm_runtime.h>
  15 #include <crypto/internal/rng.h>
  16
  17 int sun8i_ss_prng_seed(struct crypto_rng *tfm, const u8 *seed,
  18                        unsigned int slen)
  19 {
  20         struct sun8i_ss_rng_tfm_ctx *ctx = crypto_rng_ctx(tfm);
  21
  22         if (ctx->seed && ctx->slen != slen) {
  23                 memzero_explicit(ctx->seed, ctx->slen);
  24                 kfree(ctx->seed);
  25                 ctx->slen = 0;
  26                 ctx->seed = NULL;
  27         }
  28         if (!ctx->seed)
  29                 ctx->seed = kmalloc(slen, GFP_KERNEL | GFP_DMA);
  30         if (!ctx->seed)
  31                 return -ENOMEM;
  32
  33         memcpy(ctx->seed, seed, slen);
  34         ctx->slen = slen;
  35
  36         return 0;
  37 }
  38
  39 int sun8i_ss_prng_init(struct crypto_tfm *tfm)
  40 {
  41         struct sun8i_ss_rng_tfm_ctx *ctx = crypto_tfm_ctx(tfm);
  42
  43         memset(ctx, 0, sizeof(struct sun8i_ss_rng_tfm_ctx));
  44         return 0;
  45 }
  46
  47 void sun8i_ss_prng_exit(struct crypto_tfm *tfm)
  48 {
  49         struct sun8i_ss_rng_tfm_ctx *ctx = crypto_tfm_ctx(tfm);
  50
  51         memzero_explicit(ctx->seed, ctx->slen);
  52         kfree(ctx->seed);
  53         ctx->seed = NULL;
  54         ctx->slen = 0;
  55 }
  56
  57 int sun8i_ss_prng_generate(struct crypto_rng *tfm, const u8 *src,
  58                            unsigned int slen, u8 *dst, unsigned int dlen)
  59 {
  60         struct sun8i_ss_rng_tfm_ctx *ctx = crypto_rng_ctx(tfm);
  61         struct rng_alg *alg = crypto_rng_alg(tfm);
  62         struct sun8i_ss_alg_template *algt;
  63         struct sun8i_ss_dev *ss;
  64         dma_addr_t dma_iv, dma_dst;
  65         unsigned int todo;
  66         int err = 0;
  67         int flow;
  68         void *d;
  69         u32 v;
  70
  71         algt = container_of(alg, struct sun8i_ss_alg_template, alg.rng);
  72         ss = algt->ss;
  73
  74         if (ctx->slen == 0) {
  75                 dev_err(ss->dev, "The PRNG is not seeded\n");
  76                 return -EINVAL;
  77         }
  78
  79         /* The SS does not give an updated seed, so we need to get a new one.
  80          * So we will ask for an extra PRNG_SEED_SIZE data.
  81          * We want dlen + seedsize rounded up to a multiple of PRNG_DATA_SIZE
  82          */
  83         todo = dlen + PRNG_SEED_SIZE + PRNG_DATA_SIZE;
  84         todo -= todo % PRNG_DATA_SIZE;
  85
  86         d = kzalloc(todo, GFP_KERNEL | GFP_DMA);
  87         if (!d)
  88                 return -ENOMEM;
  89
  90         flow = sun8i_ss_get_engine_number(ss);
  91
  92 #ifdef CONFIG_CRYPTO_DEV_SUN8I_SS_DEBUG
  93         algt->stat_req++;
  94         algt->stat_bytes += todo;
  95 #endif
  96
  97         v = SS_ALG_PRNG | SS_PRNG_CONTINUE | SS_START;
  98         if (flow)
  99                 v |= SS_FLOW1;
 100         else
 101                 v |= SS_FLOW0;
 102
 103         dma_iv = dma_map_single(ss->dev, ctx->seed, ctx->slen, DMA_TO_DEVICE);
 104         if (dma_mapping_error(ss->dev, dma_iv)) {
 105                 dev_err(ss->dev, "Cannot DMA MAP IV\n");
 106                 err = -EFAULT;
 107                 goto err_free;
 108         }
 109
 110         dma_dst = dma_map_single(ss->dev, d, todo, DMA_FROM_DEVICE);
 111         if (dma_mapping_error(ss->dev, dma_dst)) {
 112                 dev_err(ss->dev, "Cannot DMA MAP DST\n");
 113                 err = -EFAULT;
 114                 goto err_iv;
 115         }
 116
 117         err = pm_runtime_get_sync(ss->dev);
 118         if (err < 0) {
 119                 pm_runtime_put_noidle(ss->dev);
 120                 goto err_pm;
 121         }
 122         err = 0;
 123
 124         mutex_lock(&ss->mlock);
 125         writel(dma_iv, ss->base + SS_IV_ADR_REG);
 126         /* the PRNG act badly (failing rngtest) without SS_KEY_ADR_REG set */
 127         writel(dma_iv, ss->base + SS_KEY_ADR_REG);
 128         writel(dma_dst, ss->base + SS_DST_ADR_REG);
 129         writel(todo / 4, ss->base + SS_LEN_ADR_REG);
 130
 131         reinit_completion(&ss->flows[flow].complete);
 132         ss->flows[flow].status = 0;
 133         /* Be sure all data is written before enabling the task */
 134         wmb();
 135
 136         writel(v, ss->base + SS_CTL_REG);
 137
 138         wait_for_completion_interruptible_timeout(&ss->flows[flow].complete,
 139                                                   msecs_to_jiffies(todo));
 140         if (ss->flows[flow].status == 0) {
 141                 dev_err(ss->dev, "DMA timeout for PRNG (size=%u)\n", todo);
 142                 err = -EFAULT;
 143         }
 144         /* Since cipher and hash use the linux/cryptoengine and that we have
 145          * a cryptoengine per flow, we are sure that they will issue only one
 146          * request per flow.
 147          * Since the cryptoengine wait for completion before submitting a new
 148          * one, the mlock could be left just after the final writel.
 149          * But cryptoengine cannot handle crypto_rng, so we need to be sure
 150          * nothing will use our flow.
 151          * The easiest way is to grab mlock until the hardware end our requests.
 152          * We could have used a per flow lock, but this would increase
 153          * complexity.
 154          * The drawback is that no request could be handled for the other flow.
 155          */
 156         mutex_unlock(&ss->mlock);
 157
 158         pm_runtime_put(ss->dev);
 159
 160 err_pm:
 161         dma_unmap_single(ss->dev, dma_dst, todo, DMA_FROM_DEVICE);
 162 err_iv:
 163         dma_unmap_single(ss->dev, dma_iv, ctx->slen, DMA_TO_DEVICE);
 164
 165         if (!err) {
 166                 memcpy(dst, d, dlen);
 167                 /* Update seed */
 168                 memcpy(ctx->seed, d + dlen, ctx->slen);
 169         }
 170         memzero_explicit(d, todo);
 171 err_free:
 172         kfree(d);
 173
 174         return err;
 175 }