hwrng: mtk - Add driver for hardware random generator on MT7623 SoC

This patch adds support for hardware random generator on MT7623 SoC
and should also work on other similar Mediatek SoCs. Currently,
the driver is already tested successfully with rng-tools.

Signed-off-by: Sean Wang <sean.wang@mediatek.com>
Reviewed-by: PrasannaKumar Muralidharan <prasannatsmkumar@gmail.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>

diff --git a/drivers/char/hw_random/Kconfig b/drivers/char/hw_random/Kconfig
index bdae802e7154c4d7b57ea0bb747ef54bd664f908..fd34121934e53305aa0f03cd0fc65982070fa488 100644 (file)
--- a/drivers/char/hw_random/Kconfig
+++ b/drivers/char/hw_random/Kconfig
@@ -409,6 +409,20 @@ config HW_RANDOM_CAVIUM
 
          If unsure, say Y.
 
+config HW_RANDOM_MTK
+       tristate "Mediatek Random Number Generator support"
+       depends on HW_RANDOM
+       depends on ARCH_MEDIATEK || COMPILE_TEST
+       default y
+       ---help---
+         This driver provides kernel-side support for the Random Number
+         Generator hardware found on Mediatek SoCs.
+
+         To compile this driver as a module, choose M here. the
+         module will be called mtk-rng.
+
+         If unsure, say Y.
+
 endif # HW_RANDOM
 
 config UML_RANDOM

diff --git a/drivers/char/hw_random/Makefile b/drivers/char/hw_random/Makefile
index 6f1eecc2045cf6a371b766f5aa927e2ebaffdac9..de6ea808bd3cac55ac59db296b16e86ef45331ad 100644 (file)
--- a/drivers/char/hw_random/Makefile
+++ b/drivers/char/hw_random/Makefile
@@ -35,3 +35,4 @@ obj-$(CONFIG_HW_RANDOM_STM32) += stm32-rng.o
 obj-$(CONFIG_HW_RANDOM_PIC32) += pic32-rng.o
 obj-$(CONFIG_HW_RANDOM_MESON) += meson-rng.o
 obj-$(CONFIG_HW_RANDOM_CAVIUM) += cavium-rng.o cavium-rng-vf.o
+obj-$(CONFIG_HW_RANDOM_MTK)    += mtk-rng.o

diff --git a/drivers/char/hw_random/mtk-rng.c b/drivers/char/hw_random/mtk-rng.c
new file mode 100644 (file)
index 0000000..df8eb54
--- /dev/null
+++ b/drivers/char/hw_random/mtk-rng.c
@@ -0,0 +1,168 @@
+/*
+ * Driver for Mediatek Hardware Random Number Generator
+ *
+ * Copyright (C) 2017 Sean Wang <sean.wang@mediatek.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; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * 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.
+ */
+#define MTK_RNG_DEV KBUILD_MODNAME
+
+#include <linux/clk.h>
+#include <linux/delay.h>
+#include <linux/err.h>
+#include <linux/hw_random.h>
+#include <linux/io.h>
+#include <linux/iopoll.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/platform_device.h>
+
+#define USEC_POLL                      2
+#define TIMEOUT_POLL                   20
+
+#define RNG_CTRL                       0x00
+#define RNG_EN                         BIT(0)
+#define RNG_READY                      BIT(31)
+
+#define RNG_DATA                       0x08
+
+#define to_mtk_rng(p)  container_of(p, struct mtk_rng, rng)
+
+struct mtk_rng {
+       void __iomem *base;
+       struct clk *clk;
+       struct hwrng rng;
+};
+
+static int mtk_rng_init(struct hwrng *rng)
+{
+       struct mtk_rng *priv = to_mtk_rng(rng);
+       u32 val;
+       int err;
+
+       err = clk_prepare_enable(priv->clk);
+       if (err)
+               return err;
+
+       val = readl(priv->base + RNG_CTRL);
+       val |= RNG_EN;
+       writel(val, priv->base + RNG_CTRL);
+
+       return 0;
+}
+
+static void mtk_rng_cleanup(struct hwrng *rng)
+{
+       struct mtk_rng *priv = to_mtk_rng(rng);
+       u32 val;
+
+       val = readl(priv->base + RNG_CTRL);
+       val &= ~RNG_EN;
+       writel(val, priv->base + RNG_CTRL);
+
+       clk_disable_unprepare(priv->clk);
+}
+
+static bool mtk_rng_wait_ready(struct hwrng *rng, bool wait)
+{
+       struct mtk_rng *priv = to_mtk_rng(rng);
+       int ready;
+
+       ready = readl(priv->base + RNG_CTRL) & RNG_READY;
+       if (!ready && wait)
+               readl_poll_timeout_atomic(priv->base + RNG_CTRL, ready,
+                                         ready & RNG_READY, USEC_POLL,
+                                         TIMEOUT_POLL);
+       return !!ready;
+}
+
+static int mtk_rng_read(struct hwrng *rng, void *buf, size_t max, bool wait)
+{
+       struct mtk_rng *priv = to_mtk_rng(rng);
+       int retval = 0;
+
+       while (max >= sizeof(u32)) {
+               if (!mtk_rng_wait_ready(rng, wait))
+                       break;
+
+               *(u32 *)buf = readl(priv->base + RNG_DATA);
+               retval += sizeof(u32);
+               buf += sizeof(u32);
+               max -= sizeof(u32);
+       }
+
+       return retval || !wait ? retval : -EIO;
+}
+
+static int mtk_rng_probe(struct platform_device *pdev)
+{
+       struct resource *res;
+       int ret;
+       struct mtk_rng *priv;
+
+       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+       if (!res) {
+               dev_err(&pdev->dev, "no iomem resource\n");
+               return -ENXIO;
+       }
+
+       priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
+       if (!priv)
+               return -ENOMEM;
+
+       priv->rng.name = pdev->name;
+       priv->rng.init = mtk_rng_init;
+       priv->rng.cleanup = mtk_rng_cleanup;
+       priv->rng.read = mtk_rng_read;
+
+       priv->clk = devm_clk_get(&pdev->dev, "rng");
+       if (IS_ERR(priv->clk)) {
+               ret = PTR_ERR(priv->clk);
+               dev_err(&pdev->dev, "no clock for device: %d\n", ret);
+               return ret;
+       }
+
+       priv->base = devm_ioremap_resource(&pdev->dev, res);
+       if (IS_ERR(priv->base))
+               return PTR_ERR(priv->base);
+
+       ret = devm_hwrng_register(&pdev->dev, &priv->rng);
+       if (ret) {
+               dev_err(&pdev->dev, "failed to register rng device: %d\n",
+                       ret);
+               return ret;
+       }
+
+       dev_info(&pdev->dev, "registered RNG driver\n");
+
+       return 0;
+}
+
+static const struct of_device_id mtk_rng_match[] = {
+       { .compatible = "mediatek,mt7623-rng" },
+       {},
+};
+MODULE_DEVICE_TABLE(of, mtk_rng_match);
+
+static struct platform_driver mtk_rng_driver = {
+       .probe          = mtk_rng_probe,
+       .driver = {
+               .name = MTK_RNG_DEV,
+               .of_match_table = mtk_rng_match,
+       },
+};
+
+module_platform_driver(mtk_rng_driver);
+
+MODULE_DESCRIPTION("Mediatek Random Number Generator Driver");
+MODULE_AUTHOR("Sean Wang <sean.wang@mediatek.com>");
+MODULE_LICENSE("GPL");