Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit c46ea13f authored by Krzysztof Kozlowski's avatar Krzysztof Kozlowski Committed by Herbert Xu
Browse files

crypto: exynos - Add new Exynos RNG driver 



Replace existing hw_ranndom/exynos-rng driver with a new, reworked one.
This is a driver for pseudo random number generator block which on
Exynos4 chipsets must be seeded with some value.  On newer Exynos5420
chipsets it might seed itself from true random number generator block
but this is not implemented yet.

New driver is a complete rework to use the crypto ALGAPI instead of
hw_random API.  Rationale for the change:
1. hw_random interface is for true RNG devices.
2. The old driver was seeding itself with jiffies which is not a
   reliable source for randomness.
3. Device generates five random 32-bit numbers in each pass but old
   driver was returning only one 32-bit number thus its performance was
   reduced.

Compatibility with DeviceTree bindings is preserved.

New driver does not use runtime power management but manually enables
and disables the clock when needed.  This is preferred approach because
using runtime PM just to toggle clock is huge overhead.

Another difference is reseeding itself with generated random data
periodically and during resuming from system suspend (previously driver
was re-seeding itself again with jiffies).

Signed-off-by: default avatarKrzysztof Kozlowski <krzk@kernel.org>
Reviewed-by: default avatarStephan Müller <smueller@chronox.de>
Reviewed-by: default avatarPrasannaKumar Muralidharan <prasannatsmkumar@gmail.com>
Reviewed-by: default avatarBartlomiej Zolnierkiewicz <b.zolnierkie@samsung.com>
Signed-off-by: default avatarHerbert Xu <herbert@gondor.apana.org.au>
parent ed067d4a

MAINTAINERS

+8 −0
Original line number Diff line number Diff line
@@ -10906,6 +10906,14 @@ L: alsa-devel@alsa-project.org (moderated for non-subscribers) 
S:	Supported

F:	sound/soc/samsung/



SAMSUNG EXYNOS PSEUDO RANDOM NUMBER GENERATOR (RNG) DRIVER

M:	Krzysztof Kozlowski <krzk@kernel.org>

L:	linux-crypto@vger.kernel.org

L:	linux-samsung-soc@vger.kernel.org

S:	Maintained

F:	drivers/crypto/exynos-rng.c

F:	Documentation/devicetree/bindings/rng/samsung,exynos-rng4.txt



SAMSUNG FRAMEBUFFER DRIVER

M:	Jingoo Han <jingoohan1@gmail.com>

L:	linux-fbdev@vger.kernel.org

drivers/char/hw_random/Kconfig

+0 −14
Original line number Diff line number Diff line
@@ -294,20 +294,6 @@ config HW_RANDOM_POWERNV 


	  If unsure, say Y.



config HW_RANDOM_EXYNOS

	tristate "EXYNOS HW random number generator support"

	depends on ARCH_EXYNOS || COMPILE_TEST

	depends on HAS_IOMEM

	default HW_RANDOM

	---help---

	  This driver provides kernel-side support for the Random Number

	  Generator hardware found on EXYNOS SOCs.



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

	  module will be called exynos-rng.



	  If unsure, say Y.



config HW_RANDOM_TPM

	tristate "TPM HW Random Number Generator support"

	depends on TCG_TPM

drivers/char/hw_random/Makefile

+0 −1
Original line number Diff line number Diff line
@@ -24,7 +24,6 @@ obj-$(CONFIG_HW_RANDOM_OCTEON) += octeon-rng.o 
obj-$(CONFIG_HW_RANDOM_NOMADIK) += nomadik-rng.o

obj-$(CONFIG_HW_RANDOM_PSERIES) += pseries-rng.o

obj-$(CONFIG_HW_RANDOM_POWERNV) += powernv-rng.o

obj-$(CONFIG_HW_RANDOM_EXYNOS)	+= exynos-rng.o

obj-$(CONFIG_HW_RANDOM_HISI)	+= hisi-rng.o

obj-$(CONFIG_HW_RANDOM_TPM) += tpm-rng.o

obj-$(CONFIG_HW_RANDOM_BCM2835) += bcm2835-rng.o

drivers/char/hw_random/exynos-rng.c

deleted100644 → 0
+0 −231
Original line number Diff line number Diff line 
/*

 * exynos-rng.c - Random Number Generator driver for the exynos

 *

 * Copyright (C) 2012 Samsung Electronics

 * Jonghwa Lee <jonghwa3.lee@samsung.com>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation;

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 */



#include <linux/hw_random.h>

#include <linux/kernel.h>

#include <linux/module.h>

#include <linux/io.h>

#include <linux/platform_device.h>

#include <linux/clk.h>

#include <linux/pm_runtime.h>

#include <linux/err.h>



#define EXYNOS_PRNG_STATUS_OFFSET	0x10

#define EXYNOS_PRNG_SEED_OFFSET		0x140

#define EXYNOS_PRNG_OUT1_OFFSET		0x160

#define SEED_SETTING_DONE		BIT(1)

#define PRNG_START			0x18

#define PRNG_DONE			BIT(5)

#define EXYNOS_AUTOSUSPEND_DELAY	100



struct exynos_rng {

	struct device *dev;

	struct hwrng rng;

	void __iomem *mem;

	struct clk *clk;

};



static u32 exynos_rng_readl(struct exynos_rng *rng, u32 offset)

{

	return	readl_relaxed(rng->mem + offset);

}



static void exynos_rng_writel(struct exynos_rng *rng, u32 val, u32 offset)

{

	writel_relaxed(val, rng->mem + offset);

}



static int exynos_rng_configure(struct exynos_rng *exynos_rng)

{

	int i;

	int ret = 0;



	for (i = 0 ; i < 5 ; i++)

		exynos_rng_writel(exynos_rng, jiffies,

				EXYNOS_PRNG_SEED_OFFSET + 4*i);



	if (!(exynos_rng_readl(exynos_rng, EXYNOS_PRNG_STATUS_OFFSET)

						 & SEED_SETTING_DONE))

		ret = -EIO;



	return ret;

}



static int exynos_init(struct hwrng *rng)

{

	struct exynos_rng *exynos_rng = container_of(rng,

						struct exynos_rng, rng);

	int ret = 0;



	pm_runtime_get_sync(exynos_rng->dev);

	ret = exynos_rng_configure(exynos_rng);

	pm_runtime_mark_last_busy(exynos_rng->dev);

	pm_runtime_put_autosuspend(exynos_rng->dev);



	return ret;

}



static int exynos_read(struct hwrng *rng, void *buf,

					size_t max, bool wait)

{

	struct exynos_rng *exynos_rng = container_of(rng,

						struct exynos_rng, rng);

	u32 *data = buf;

	int retry = 100;

	int ret = 4;



	pm_runtime_get_sync(exynos_rng->dev);



	exynos_rng_writel(exynos_rng, PRNG_START, 0);



	while (!(exynos_rng_readl(exynos_rng,

			EXYNOS_PRNG_STATUS_OFFSET) & PRNG_DONE) && --retry)

		cpu_relax();

	if (!retry) {

		ret = -ETIMEDOUT;

		goto out;

	}



	exynos_rng_writel(exynos_rng, PRNG_DONE, EXYNOS_PRNG_STATUS_OFFSET);



	*data = exynos_rng_readl(exynos_rng, EXYNOS_PRNG_OUT1_OFFSET);



out:

	pm_runtime_mark_last_busy(exynos_rng->dev);

	pm_runtime_put_sync_autosuspend(exynos_rng->dev);



	return ret;

}



static int exynos_rng_probe(struct platform_device *pdev)

{

	struct exynos_rng *exynos_rng;

	struct resource *res;

	int ret;



	exynos_rng = devm_kzalloc(&pdev->dev, sizeof(struct exynos_rng),

					GFP_KERNEL);

	if (!exynos_rng)

		return -ENOMEM;



	exynos_rng->dev = &pdev->dev;

	exynos_rng->rng.name = "exynos";

	exynos_rng->rng.init =	exynos_init;

	exynos_rng->rng.read = exynos_read;

	exynos_rng->clk = devm_clk_get(&pdev->dev, "secss");

	if (IS_ERR(exynos_rng->clk)) {

		dev_err(&pdev->dev, "Couldn't get clock.\n");

		return -ENOENT;

	}



	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);

	exynos_rng->mem = devm_ioremap_resource(&pdev->dev, res);

	if (IS_ERR(exynos_rng->mem))

		return PTR_ERR(exynos_rng->mem);



	platform_set_drvdata(pdev, exynos_rng);



	pm_runtime_set_autosuspend_delay(&pdev->dev, EXYNOS_AUTOSUSPEND_DELAY);

	pm_runtime_use_autosuspend(&pdev->dev);

	pm_runtime_enable(&pdev->dev);



	ret = devm_hwrng_register(&pdev->dev, &exynos_rng->rng);

	if (ret) {

		pm_runtime_dont_use_autosuspend(&pdev->dev);

		pm_runtime_disable(&pdev->dev);

	}



	return ret;

}



static int exynos_rng_remove(struct platform_device *pdev)

{

	pm_runtime_dont_use_autosuspend(&pdev->dev);

	pm_runtime_disable(&pdev->dev);



	return 0;

}



static int __maybe_unused exynos_rng_runtime_suspend(struct device *dev)

{

	struct platform_device *pdev = to_platform_device(dev);

	struct exynos_rng *exynos_rng = platform_get_drvdata(pdev);



	clk_disable_unprepare(exynos_rng->clk);



	return 0;

}



static int __maybe_unused exynos_rng_runtime_resume(struct device *dev)

{

	struct platform_device *pdev = to_platform_device(dev);

	struct exynos_rng *exynos_rng = platform_get_drvdata(pdev);



	return clk_prepare_enable(exynos_rng->clk);

}



static int __maybe_unused exynos_rng_suspend(struct device *dev)

{

	return pm_runtime_force_suspend(dev);

}



static int __maybe_unused exynos_rng_resume(struct device *dev)

{

	struct platform_device *pdev = to_platform_device(dev);

	struct exynos_rng *exynos_rng = platform_get_drvdata(pdev);

	int ret;



	ret = pm_runtime_force_resume(dev);

	if (ret)

		return ret;



	return exynos_rng_configure(exynos_rng);

}



static const struct dev_pm_ops exynos_rng_pm_ops = {

	SET_SYSTEM_SLEEP_PM_OPS(exynos_rng_suspend, exynos_rng_resume)

	SET_RUNTIME_PM_OPS(exynos_rng_runtime_suspend,

			   exynos_rng_runtime_resume, NULL)

};



static const struct of_device_id exynos_rng_dt_match[] = {

	{

		.compatible = "samsung,exynos4-rng",

	},

	{ },

};

MODULE_DEVICE_TABLE(of, exynos_rng_dt_match);



static struct platform_driver exynos_rng_driver = {

	.driver		= {

		.name	= "exynos-rng",

		.pm	= &exynos_rng_pm_ops,

		.of_match_table = exynos_rng_dt_match,

	},

	.probe		= exynos_rng_probe,

	.remove		= exynos_rng_remove,

};



module_platform_driver(exynos_rng_driver);



MODULE_DESCRIPTION("EXYNOS 4 H/W Random Number Generator driver");

MODULE_AUTHOR("Jonghwa Lee <jonghwa3.lee@samsung.com>");

MODULE_LICENSE("GPL");

drivers/crypto/Kconfig

+15 −0
Original line number Diff line number Diff line
@@ -388,6 +388,21 @@ config CRYPTO_DEV_MXC_SCC 
	  This option enables support for the Security Controller (SCC)

	  found in Freescale i.MX25 chips.



config CRYPTO_DEV_EXYNOS_RNG

	tristate "EXYNOS HW pseudo random number generator support"

	depends on ARCH_EXYNOS || COMPILE_TEST

	depends on HAS_IOMEM

	select CRYPTO_RNG

	---help---

	  This driver provides kernel-side support through the

	  cryptographic API for the pseudo random number generator hardware

	  found on Exynos SoCs.



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

	  module will be called exynos-rng.



	  If unsure, say Y.



config CRYPTO_DEV_S5P

	tristate "Support for Samsung S5PV210/Exynos crypto accelerator"

	depends on ARCH_S5PV210 || ARCH_EXYNOS || COMPILE_TEST