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