[linux-2.6-block.git] / drivers / crypto / caam / caamprng.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Driver to expose SEC4 PRNG via crypto RNG API
 *
 * Copyright 2022 NXP
 *
 */

#include <linux/completion.h>
#include <crypto/internal/rng.h>
#include <linux/dma-mapping.h>
#include <linux/kernel.h>
#include "compat.h"
#include "regs.h"
#include "intern.h"
#include "desc_constr.h"
#include "jr.h"
#include "error.h"

/*
 * Length of used descriptors, see caam_init_desc()
 */
#define CAAM_PRNG_MAX_DESC_LEN (CAAM_CMD_SZ +				\
			    CAAM_CMD_SZ +				\
			    CAAM_CMD_SZ + CAAM_PTR_SZ_MAX)

/* prng per-device context */
struct caam_prng_ctx {
	int err;
	struct completion done;
};

struct caam_prng_alg {
	struct rng_alg rng;
	bool registered;
};

static void caam_prng_done(struct device *jrdev, u32 *desc, u32 err,
			  void *context)
{
	struct caam_prng_ctx *jctx = context;

	jctx->err = err ? caam_jr_strstatus(jrdev, err) : 0;

	complete(&jctx->done);
}

static u32 *caam_init_reseed_desc(u32 *desc)
{
	init_job_desc(desc, 0);	/* + 1 cmd_sz */
	/* Generate random bytes: + 1 cmd_sz */
	append_operation(desc, OP_TYPE_CLASS1_ALG | OP_ALG_ALGSEL_RNG |
			OP_ALG_AS_FINALIZE);

	print_hex_dump_debug("prng reseed desc@: ", DUMP_PREFIX_ADDRESS,
			     16, 4, desc, desc_bytes(desc), 1);

	return desc;
}

static u32 *caam_init_prng_desc(u32 *desc, dma_addr_t dst_dma, u32 len)
{
	init_job_desc(desc, 0);	/* + 1 cmd_sz */
	/* Generate random bytes: + 1 cmd_sz */
	append_operation(desc, OP_ALG_ALGSEL_RNG | OP_TYPE_CLASS1_ALG);
	/* Store bytes: + 1 cmd_sz + caam_ptr_sz  */
	append_fifo_store(desc, dst_dma,
			  len, FIFOST_TYPE_RNGSTORE);

	print_hex_dump_debug("prng job desc@: ", DUMP_PREFIX_ADDRESS,
			     16, 4, desc, desc_bytes(desc), 1);

	return desc;
}

static int caam_prng_generate(struct crypto_rng *tfm,
			     const u8 *src, unsigned int slen,
			     u8 *dst, unsigned int dlen)
{
	unsigned int aligned_dlen = ALIGN(dlen, dma_get_cache_alignment());
	struct caam_prng_ctx ctx;
	struct device *jrdev;
	dma_addr_t dst_dma;
	u32 *desc;
	u8 *buf;
	int ret;

	if (aligned_dlen < dlen)
		return -EOVERFLOW;

	buf = kzalloc(aligned_dlen, GFP_KERNEL);
	if (!buf)
		return -ENOMEM;

	jrdev = caam_jr_alloc();
	ret = PTR_ERR_OR_ZERO(jrdev);
	if (ret) {
		pr_err("Job Ring Device allocation failed\n");
		kfree(buf);
		return ret;
	}

	desc = kzalloc(CAAM_PRNG_MAX_DESC_LEN, GFP_KERNEL);
	if (!desc) {
		ret = -ENOMEM;
		goto out1;
	}

	dst_dma = dma_map_single(jrdev, buf, dlen, DMA_FROM_DEVICE);
	if (dma_mapping_error(jrdev, dst_dma)) {
		dev_err(jrdev, "Failed to map destination buffer memory\n");
		ret = -ENOMEM;
		goto out;
	}

	init_completion(&ctx.done);
	ret = caam_jr_enqueue(jrdev,
			      caam_init_prng_desc(desc, dst_dma, dlen),
			      caam_prng_done, &ctx);

	if (ret == -EINPROGRESS) {
		wait_for_completion(&ctx.done);
		ret = ctx.err;
	}

	dma_unmap_single(jrdev, dst_dma, dlen, DMA_FROM_DEVICE);

	if (!ret)
		memcpy(dst, buf, dlen);
out:
	kfree(desc);
out1:
	caam_jr_free(jrdev);
	kfree(buf);
	return ret;
}

static void caam_prng_exit(struct crypto_tfm *tfm) {}

static int caam_prng_init(struct crypto_tfm *tfm)
{
	return 0;
}

static int caam_prng_seed(struct crypto_rng *tfm,
			 const u8 *seed, unsigned int slen)
{
	struct caam_prng_ctx ctx;
	struct device *jrdev;
	u32 *desc;
	int ret;

	if (slen) {
		pr_err("Seed length should be zero\n");
		return -EINVAL;
	}

	jrdev = caam_jr_alloc();
	ret = PTR_ERR_OR_ZERO(jrdev);
	if (ret) {
		pr_err("Job Ring Device allocation failed\n");
		return ret;
	}

	desc = kzalloc(CAAM_PRNG_MAX_DESC_LEN, GFP_KERNEL);
	if (!desc) {
		caam_jr_free(jrdev);
		return -ENOMEM;
	}

	init_completion(&ctx.done);
	ret = caam_jr_enqueue(jrdev,
			      caam_init_reseed_desc(desc),
			      caam_prng_done, &ctx);

	if (ret == -EINPROGRESS) {
		wait_for_completion(&ctx.done);
		ret = ctx.err;
	}

	kfree(desc);
	caam_jr_free(jrdev);
	return ret;
}

static struct caam_prng_alg caam_prng_alg = {
	.rng = {
		.generate = caam_prng_generate,
		.seed = caam_prng_seed,
		.seedsize = 0,
		.base = {
			.cra_name = "stdrng",
			.cra_driver_name = "prng-caam",
			.cra_priority = 500,
			.cra_ctxsize = sizeof(struct caam_prng_ctx),
			.cra_module = THIS_MODULE,
			.cra_init = caam_prng_init,
			.cra_exit = caam_prng_exit,
		},
	}
};

void caam_prng_unregister(void *data)
{
	if (caam_prng_alg.registered)
		crypto_unregister_rng(&caam_prng_alg.rng);
}

int caam_prng_register(struct device *ctrldev)
{
	struct caam_drv_private *priv = dev_get_drvdata(ctrldev);
	u32 rng_inst;
	int ret = 0;

	/* Check for available RNG blocks before registration */
	if (priv->era < 10)
		rng_inst = (rd_reg32(&priv->jr[0]->perfmon.cha_num_ls) &
			    CHA_ID_LS_RNG_MASK) >> CHA_ID_LS_RNG_SHIFT;
	else
		rng_inst = rd_reg32(&priv->jr[0]->vreg.rng) & CHA_VER_NUM_MASK;

	if (!rng_inst) {
		dev_dbg(ctrldev, "RNG block is not available... skipping registering algorithm\n");
		return ret;
	}

	ret = crypto_register_rng(&caam_prng_alg.rng);
	if (ret) {
		dev_err(ctrldev,
			"couldn't register rng crypto alg: %d\n",
			ret);
		return ret;
	}

	caam_prng_alg.registered = true;

	dev_info(ctrldev,
		 "rng crypto API alg registered %s\n", caam_prng_alg.rng.base.cra_driver_name);

	return 0;
}
Commit	Line	Data
0aa6ac77 MA	1	// SPDX-License-Identifier: GPL-2.0+
	2	/*
	3	* Driver to expose SEC4 PRNG via crypto RNG API
	4	*
	5	* Copyright 2022 NXP
	6	*
	7	*/
	8
	9	#include <linux/completion.h>
	10	#include <crypto/internal/rng.h>
199354d7 HX	11	#include <linux/dma-mapping.h>
199354d7 HX	12	#include <linux/kernel.h>
0aa6ac77 MA	13	#include "compat.h"
	14	#include "regs.h"
	15	#include "intern.h"
	16	#include "desc_constr.h"
	17	#include "jr.h"
	18	#include "error.h"
	19
	20	/*
	21	* Length of used descriptors, see caam_init_desc()
	22	*/
	23	#define CAAM_PRNG_MAX_DESC_LEN (CAAM_CMD_SZ + \
	24	CAAM_CMD_SZ + \
	25	CAAM_CMD_SZ + CAAM_PTR_SZ_MAX)
	26
	27	/* prng per-device context */
	28	struct caam_prng_ctx {
	29	int err;
	30	struct completion done;
	31	};
	32
	33	struct caam_prng_alg {
	34	struct rng_alg rng;
	35	bool registered;
	36	};
	37
	38	static void caam_prng_done(struct device jrdev, u32 desc, u32 err,
	39	void *context)
	40	{
	41	struct caam_prng_ctx *jctx = context;
	42
	43	jctx->err = err ? caam_jr_strstatus(jrdev, err) : 0;
	44
	45	complete(&jctx->done);
	46	}
	47
	48	static u32 caam_init_reseed_desc(u32 desc)
	49	{
	50	init_job_desc(desc, 0); /* + 1 cmd_sz */
	51	/* Generate random bytes: + 1 cmd_sz */
	52	append_operation(desc, OP_TYPE_CLASS1_ALG \| OP_ALG_ALGSEL_RNG \|
	53	OP_ALG_AS_FINALIZE);
	54
	55	print_hex_dump_debug("prng reseed desc@: ", DUMP_PREFIX_ADDRESS,
	56	16, 4, desc, desc_bytes(desc), 1);
	57
	58	return desc;
	59	}
	60
	61	static u32 caam_init_prng_desc(u32 desc, dma_addr_t dst_dma, u32 len)
	62	{
	63	init_job_desc(desc, 0); /* + 1 cmd_sz */
	64	/* Generate random bytes: + 1 cmd_sz */
	65	append_operation(desc, OP_ALG_ALGSEL_RNG \| OP_TYPE_CLASS1_ALG);
	66	/* Store bytes: + 1 cmd_sz + caam_ptr_sz */
	67	append_fifo_store(desc, dst_dma,
	68	len, FIFOST_TYPE_RNGSTORE);
	69
	70	print_hex_dump_debug("prng job desc@: ", DUMP_PREFIX_ADDRESS,
	71	16, 4, desc, desc_bytes(desc), 1);
	72
	73	return desc;
	74	}
	75
	76	static int caam_prng_generate(struct crypto_rng *tfm,
77	const u8 *src, unsigned int slen,
78	u8 *dst, unsigned int dlen)
79	{
199354d7	80	unsigned int aligned_dlen = ALIGN(dlen, dma_get_cache_alignment());
0aa6ac77 MA	81	struct caam_prng_ctx ctx;
	82	struct device *jrdev;
	83	dma_addr_t dst_dma;
	84	u32 *desc;
	85	u8 *buf;
	86	int ret;
	87
199354d7 HX	88	if (aligned_dlen < dlen)
	89	return -EOVERFLOW;
	90
	91	buf = kzalloc(aligned_dlen, GFP_KERNEL);
0aa6ac77 MA	92	if (!buf)
	93	return -ENOMEM;
	94
	95	jrdev = caam_jr_alloc();
	96	ret = PTR_ERR_OR_ZERO(jrdev);
	97	if (ret) {
	98	pr_err("Job Ring Device allocation failed\n");
	99	kfree(buf);
	100	return ret;
	101	}
	102
199354d7	103	desc = kzalloc(CAAM_PRNG_MAX_DESC_LEN, GFP_KERNEL);
0aa6ac77 MA	104	if (!desc) {
	105	ret = -ENOMEM;
	106	goto out1;
	107	}
	108
	109	dst_dma = dma_map_single(jrdev, buf, dlen, DMA_FROM_DEVICE);
	110	if (dma_mapping_error(jrdev, dst_dma)) {
	111	dev_err(jrdev, "Failed to map destination buffer memory\n");
	112	ret = -ENOMEM;
	113	goto out;
	114	}
	115
	116	init_completion(&ctx.done);
	117	ret = caam_jr_enqueue(jrdev,
	118	caam_init_prng_desc(desc, dst_dma, dlen),
	119	caam_prng_done, &ctx);
	120
	121	if (ret == -EINPROGRESS) {
	122	wait_for_completion(&ctx.done);
	123	ret = ctx.err;
	124	}
	125
	126	dma_unmap_single(jrdev, dst_dma, dlen, DMA_FROM_DEVICE);
	127
	128	if (!ret)
	129	memcpy(dst, buf, dlen);
	130	out:
	131	kfree(desc);
	132	out1:
	133	caam_jr_free(jrdev);
	134	kfree(buf);
	135	return ret;
	136	}
	137
	138	static void caam_prng_exit(struct crypto_tfm *tfm) {}
	139
	140	static int caam_prng_init(struct crypto_tfm *tfm)
	141	{
	142	return 0;
	143	}
	144
	145	static int caam_prng_seed(struct crypto_rng *tfm,
	146	const u8 *seed, unsigned int slen)
	147	{
	148	struct caam_prng_ctx ctx;
	149	struct device *jrdev;
	150	u32 *desc;
	151	int ret;
	152
	153	if (slen) {
	154	pr_err("Seed length should be zero\n");
	155	return -EINVAL;
	156	}
	157
	158	jrdev = caam_jr_alloc();
	159	ret = PTR_ERR_OR_ZERO(jrdev);
	160	if (ret) {
	161	pr_err("Job Ring Device allocation failed\n");
	162	return ret;
	163	}
	164
199354d7	165	desc = kzalloc(CAAM_PRNG_MAX_DESC_LEN, GFP_KERNEL);
0aa6ac77 MA	166	if (!desc) {
	167	caam_jr_free(jrdev);
	168	return -ENOMEM;
	169	}
	170
	171	init_completion(&ctx.done);
	172	ret = caam_jr_enqueue(jrdev,
	173	caam_init_reseed_desc(desc),
	174	caam_prng_done, &ctx);
	175
	176	if (ret == -EINPROGRESS) {
	177	wait_for_completion(&ctx.done);
	178	ret = ctx.err;
	179	}
	180
	181	kfree(desc);
	182	caam_jr_free(jrdev);
	183	return ret;
	184	}
	185
	186	static struct caam_prng_alg caam_prng_alg = {
	187	.rng = {
	188	.generate = caam_prng_generate,
	189	.seed = caam_prng_seed,
	190	.seedsize = 0,
	191	.base = {
	192	.cra_name = "stdrng",
	193	.cra_driver_name = "prng-caam",
	194	.cra_priority = 500,
	195	.cra_ctxsize = sizeof(struct caam_prng_ctx),
	196	.cra_module = THIS_MODULE,
	197	.cra_init = caam_prng_init,
	198	.cra_exit = caam_prng_exit,
	199	},
	200	}
	201	};
	202
	203	void caam_prng_unregister(void *data)
	204	{
	205	if (caam_prng_alg.registered)
	206	crypto_unregister_rng(&caam_prng_alg.rng);
	207	}
	208
	209	int caam_prng_register(struct device *ctrldev)
	210	{
	211	struct caam_drv_private *priv = dev_get_drvdata(ctrldev);
	212	u32 rng_inst;
	213	int ret = 0;
	214
	215	/* Check for available RNG blocks before registration */
	216	if (priv->era < 10)
	217	rng_inst = (rd_reg32(&priv->jr[0]->perfmon.cha_num_ls) &
	218	CHA_ID_LS_RNG_MASK) >> CHA_ID_LS_RNG_SHIFT;
	219	else
	220	rng_inst = rd_reg32(&priv->jr[0]->vreg.rng) & CHA_VER_NUM_MASK;
	221
	222	if (!rng_inst) {
	223	dev_dbg(ctrldev, "RNG block is not available... skipping registering algorithm\n");
	224	return ret;
	225	}
	226
	227	ret = crypto_register_rng(&caam_prng_alg.rng);
	228	if (ret) {
	229	dev_err(ctrldev,
230	"couldn't register rng crypto alg: %d\n",
231	ret);
232	return ret;
233	}
234
235	caam_prng_alg.registered = true;
236
237	dev_info(ctrldev,
238	"rng crypto API alg registered %s\n", caam_prng_alg.rng.base.cra_driver_name);
239
240	return 0;
241	}