Commit 0289e9be authored by Olivier Sobrie's avatar Olivier Sobrie Committed by Herbert Xu
Browse files

hwrng: ba431 - add support for BA431 hwrng 



Silex insight BA431 is an IP designed to generate random numbers that
can be integrated in various FPGA.
This driver adds support for it through the hwrng interface.

This driver is used in Silex Insight Viper OEM boards.

Signed-off-by: default avatarOlivier Sobrie <olivier.sobrie@silexinsight.com>
Signed-off-by: default avatarWaleed Ziad <waleed94ziad@gmail.com>
Acked-by: default avatarArnd Bergmann <arnd@arndb.de>
Signed-off-by: default avatarHerbert Xu <herbert@gondor.apana.org.au>
parent 50f362b2

drivers/char/hw_random/Kconfig

+12 −0
Original line number Diff line number Diff line
@@ -74,6 +74,18 @@ config HW_RANDOM_ATMEL 


	  If unsure, say Y.



config HW_RANDOM_BA431

	tristate "Silex Insight BA431 Random Number Generator support"

	default HW_RANDOM

	help

	  This driver provides kernel-side support for the Random Number

	  Generator hardware based on Silex Insight BA431 IP.



	  To compile this driver as a module, choose M here: the

	  module will be called ba431-rng.



	  If unsure, say Y.



config HW_RANDOM_BCM2835

	tristate "Broadcom BCM2835/BCM63xx Random Number Generator support"

	depends on ARCH_BCM2835 || ARCH_BCM_NSP || ARCH_BCM_5301X || \

drivers/char/hw_random/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -9,6 +9,7 @@ obj-$(CONFIG_HW_RANDOM_TIMERIOMEM) += timeriomem-rng.o 
obj-$(CONFIG_HW_RANDOM_INTEL) += intel-rng.o

obj-$(CONFIG_HW_RANDOM_AMD) += amd-rng.o

obj-$(CONFIG_HW_RANDOM_ATMEL) += atmel-rng.o

obj-$(CONFIG_HW_RANDOM_BA431) += ba431-rng.o

obj-$(CONFIG_HW_RANDOM_GEODE) += geode-rng.o

obj-$(CONFIG_HW_RANDOM_N2RNG) += n2-rng.o

n2-rng-y := n2-drv.o n2-asm.o

drivers/char/hw_random/ba431-rng.c

0 → 100644
+234 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

// Copyright (c) 2020 Silex Insight



#include <linux/delay.h>

#include <linux/hw_random.h>

#include <linux/io.h>

#include <linux/iopoll.h>

#include <linux/mod_devicetable.h>

#include <linux/module.h>

#include <linux/platform_device.h>

#include <linux/workqueue.h>



#define BA431_RESET_DELAY			1 /* usec */

#define BA431_RESET_READ_STATUS_TIMEOUT		1000 /* usec */

#define BA431_RESET_READ_STATUS_INTERVAL	10 /* usec */

#define BA431_READ_RETRY_INTERVAL		1 /* usec */



#define BA431_REG_CTRL				0x00

#define BA431_REG_FIFO_LEVEL			0x04

#define BA431_REG_STATUS			0x30

#define BA431_REG_FIFODATA			0x80



#define BA431_CTRL_ENABLE			BIT(0)

#define BA431_CTRL_SOFTRESET			BIT(8)



#define BA431_STATUS_STATE_MASK			(BIT(1) | BIT(2) | BIT(3))

#define BA431_STATUS_STATE_OFFSET		1



enum ba431_state {

	BA431_STATE_RESET,

	BA431_STATE_STARTUP,

	BA431_STATE_FIFOFULLON,

	BA431_STATE_FIFOFULLOFF,

	BA431_STATE_RUNNING,

	BA431_STATE_ERROR

};



struct ba431_trng {

	struct device *dev;

	void __iomem *base;

	struct hwrng rng;

	atomic_t reset_pending;

	struct work_struct reset_work;

};



static inline u32 ba431_trng_read_reg(struct ba431_trng *ba431, u32 reg)

{

	return ioread32(ba431->base + reg);

}



static inline void ba431_trng_write_reg(struct ba431_trng *ba431, u32 reg,

					u32 val)

{

	iowrite32(val, ba431->base + reg);

}



static inline enum ba431_state ba431_trng_get_state(struct ba431_trng *ba431)

{

	u32 status = ba431_trng_read_reg(ba431, BA431_REG_STATUS);



	return (status & BA431_STATUS_STATE_MASK) >> BA431_STATUS_STATE_OFFSET;

}



static int ba431_trng_is_in_error(struct ba431_trng *ba431)

{

	enum ba431_state state = ba431_trng_get_state(ba431);



	if ((state < BA431_STATE_STARTUP) ||

	    (state >= BA431_STATE_ERROR))

		return 1;



	return 0;

}



static int ba431_trng_reset(struct ba431_trng *ba431)

{

	int ret;



	/* Disable interrupts, random generation and enable the softreset */

	ba431_trng_write_reg(ba431, BA431_REG_CTRL, BA431_CTRL_SOFTRESET);

	udelay(BA431_RESET_DELAY);

	ba431_trng_write_reg(ba431, BA431_REG_CTRL, BA431_CTRL_ENABLE);



	/* Wait until the state changed */

	if (readx_poll_timeout(ba431_trng_is_in_error, ba431, ret, !ret,

			       BA431_RESET_READ_STATUS_INTERVAL,

			       BA431_RESET_READ_STATUS_TIMEOUT)) {

		dev_err(ba431->dev, "reset failed (state: %d)\n",

			ba431_trng_get_state(ba431));

		return -ETIMEDOUT;

	}



	dev_info(ba431->dev, "reset done\n");



	return 0;

}



static void ba431_trng_reset_work(struct work_struct *work)

{

	struct ba431_trng *ba431 = container_of(work, struct ba431_trng,

						reset_work);

	ba431_trng_reset(ba431);

	atomic_set(&ba431->reset_pending, 0);

}



static void ba431_trng_schedule_reset(struct ba431_trng *ba431)

{

	if (atomic_cmpxchg(&ba431->reset_pending, 0, 1))

		return;



	schedule_work(&ba431->reset_work);

}



static int ba431_trng_read(struct hwrng *rng, void *buf, size_t max, bool wait)

{

	struct ba431_trng *ba431 = container_of(rng, struct ba431_trng, rng);

	u32 *data = buf;

	unsigned int level, i;

	int n = 0;



	while (max > 0) {

		level = ba431_trng_read_reg(ba431, BA431_REG_FIFO_LEVEL);

		if (!level) {

			if (ba431_trng_is_in_error(ba431)) {

				ba431_trng_schedule_reset(ba431);

				break;

			}



			if (!wait)

				break;



			udelay(BA431_READ_RETRY_INTERVAL);

			continue;

		}



		i = level;

		do {

			data[n++] = ba431_trng_read_reg(ba431,

							BA431_REG_FIFODATA);

			max -= sizeof(*data);

		} while (--i && (max > 0));



		if (ba431_trng_is_in_error(ba431)) {

			n -= (level - i);

			ba431_trng_schedule_reset(ba431);

			break;

		}

	}



	n *= sizeof(data);

	return (n || !wait) ? n : -EIO;

}



static void ba431_trng_cleanup(struct hwrng *rng)

{

	struct ba431_trng *ba431 = container_of(rng, struct ba431_trng, rng);



	ba431_trng_write_reg(ba431, BA431_REG_CTRL, 0);

	cancel_work_sync(&ba431->reset_work);

}



static int ba431_trng_init(struct hwrng *rng)

{

	struct ba431_trng *ba431 = container_of(rng, struct ba431_trng, rng);



	return ba431_trng_reset(ba431);

}



static int ba431_trng_probe(struct platform_device *pdev)

{

	struct ba431_trng *ba431;

	struct resource *res;

	int ret;



	ba431 = devm_kzalloc(&pdev->dev, sizeof(*ba431), GFP_KERNEL);

	if (!ba431)

		return -ENOMEM;



	ba431->dev = &pdev->dev;



	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);

	ba431->base = devm_ioremap_resource(&pdev->dev, res);

	if (IS_ERR(ba431->base))

		return PTR_ERR(ba431->base);



	atomic_set(&ba431->reset_pending, 0);

	INIT_WORK(&ba431->reset_work, ba431_trng_reset_work);

	ba431->rng.name = pdev->name;

	ba431->rng.init = ba431_trng_init;

	ba431->rng.cleanup = ba431_trng_cleanup;

	ba431->rng.read = ba431_trng_read;



	platform_set_drvdata(pdev, ba431);



	ret = hwrng_register(&ba431->rng);

	if (ret) {

		dev_err(&pdev->dev, "BA431 registration failed (%d)\n", ret);

		return ret;

	}



	dev_info(&pdev->dev, "BA431 TRNG registered\n");



	return 0;

}



static int ba431_trng_remove(struct platform_device *pdev)

{

	struct ba431_trng *ba431 = platform_get_drvdata(pdev);



	hwrng_unregister(&ba431->rng);



	return 0;

}



static const struct of_device_id ba431_trng_dt_ids[] = {

	{ .compatible = "silex-insight,ba431-rng", .data = NULL },

	{ /* sentinel */ }

};

MODULE_DEVICE_TABLE(of, ba431_trng_dt_ids);



static struct platform_driver ba431_trng_driver = {

	.driver = {

		.name = "ba431-rng",

		.of_match_table = ba431_trng_dt_ids,

	},

	.probe = ba431_trng_probe,

	.remove = ba431_trng_remove,

};



module_platform_driver(ba431_trng_driver);



MODULE_AUTHOR("Olivier Sobrie <olivier@sobrie.be>");

MODULE_DESCRIPTION("TRNG driver for Silex Insight BA431");

MODULE_LICENSE("GPL");

CRA Git | Maintained and supported by SUSTech CRA and CCSE