drivers/char/hw_random/mtk-rng.c

   1 /*
   2  * Driver for Mediatek Hardware Random Number Generator
   3  *
   4  * Copyright (C) 2017 Sean Wang <sean.wang@mediatek.com>
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License as
   8  * published by the Free Software Foundation; either version 2 of
   9  * the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14  * GNU General Public License for more details.
  15  */
  16 #define MTK_RNG_DEV KBUILD_MODNAME
  17
  18 #include <linux/clk.h>
  19 #include <linux/delay.h>
  20 #include <linux/err.h>
  21 #include <linux/hw_random.h>
  22 #include <linux/io.h>
  23 #include <linux/iopoll.h>
  24 #include <linux/kernel.h>
  25 #include <linux/module.h>
  26 #include <linux/of.h>
  27 #include <linux/platform_device.h>
  28 #include <linux/pm_runtime.h>
  29
  30 /* Runtime PM autosuspend timeout: */
  31 #define RNG_AUTOSUSPEND_TIMEOUT         100
  32
  33 #define USEC_POLL                       2
  34 #define TIMEOUT_POLL                    20
  35
  36 #define RNG_CTRL                        0x00
  37 #define RNG_EN                          BIT(0)
  38 #define RNG_READY                       BIT(31)
  39
  40 #define RNG_DATA                        0x08
  41
  42 #define to_mtk_rng(p)   container_of(p, struct mtk_rng, rng)
  43
  44 struct mtk_rng {
  45         void __iomem *base;
  46         struct clk *clk;
  47         struct hwrng rng;
  48 };
  49
  50 static int mtk_rng_init(struct hwrng *rng)
  51 {
  52         struct mtk_rng *priv = to_mtk_rng(rng);
  53         u32 val;
  54         int err;
  55
  56         err = clk_prepare_enable(priv->clk);
  57         if (err)
  58                 return err;
  59
  60         val = readl(priv->base + RNG_CTRL);
  61         val |= RNG_EN;
  62         writel(val, priv->base + RNG_CTRL);
  63
  64         return 0;
  65 }
  66
  67 static void mtk_rng_cleanup(struct hwrng *rng)
  68 {
  69         struct mtk_rng *priv = to_mtk_rng(rng);
  70         u32 val;
  71
  72         val = readl(priv->base + RNG_CTRL);
  73         val &= ~RNG_EN;
  74         writel(val, priv->base + RNG_CTRL);
  75
  76         clk_disable_unprepare(priv->clk);
  77 }
  78
  79 static bool mtk_rng_wait_ready(struct hwrng *rng, bool wait)
  80 {
  81         struct mtk_rng *priv = to_mtk_rng(rng);
  82         int ready;
  83
  84         ready = readl(priv->base + RNG_CTRL) & RNG_READY;
  85         if (!ready && wait)
  86                 readl_poll_timeout_atomic(priv->base + RNG_CTRL, ready,
  87                                           ready & RNG_READY, USEC_POLL,
  88                                           TIMEOUT_POLL);
  89         return !!ready;
  90 }
  91
  92 static int mtk_rng_read(struct hwrng *rng, void *buf, size_t max, bool wait)
  93 {
  94         struct mtk_rng *priv = to_mtk_rng(rng);
  95         int retval = 0;
  96
  97         pm_runtime_get_sync((struct device *)priv->rng.priv);
  98
  99         while (max >= sizeof(u32)) {
 100                 if (!mtk_rng_wait_ready(rng, wait))
 101                         break;
 102
 103                 *(u32 *)buf = readl(priv->base + RNG_DATA);
 104                 retval += sizeof(u32);
 105                 buf += sizeof(u32);
 106                 max -= sizeof(u32);
 107         }
 108
 109         pm_runtime_mark_last_busy((struct device *)priv->rng.priv);
 110         pm_runtime_put_sync_autosuspend((struct device *)priv->rng.priv);
 111
 112         return retval || !wait ? retval : -EIO;
 113 }
 114
 115 static int mtk_rng_probe(struct platform_device *pdev)
 116 {
 117         struct resource *res;
 118         int ret;
 119         struct mtk_rng *priv;
 120
 121         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 122         if (!res) {
 123                 dev_err(&pdev->dev, "no iomem resource\n");
 124                 return -ENXIO;
 125         }
 126
 127         priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
 128         if (!priv)
 129                 return -ENOMEM;
 130
 131         priv->rng.name = pdev->name;
 132 #ifndef CONFIG_PM
 133         priv->rng.init = mtk_rng_init;
 134         priv->rng.cleanup = mtk_rng_cleanup;
 135 #endif
 136         priv->rng.read = mtk_rng_read;
 137         priv->rng.priv = (unsigned long)&pdev->dev;
 138         priv->rng.quality = 900;
 139
 140         priv->clk = devm_clk_get(&pdev->dev, "rng");
 141         if (IS_ERR(priv->clk)) {
 142                 ret = PTR_ERR(priv->clk);
 143                 dev_err(&pdev->dev, "no clock for device: %d\n", ret);
 144                 return ret;
 145         }
 146
 147         priv->base = devm_ioremap_resource(&pdev->dev, res);
 148         if (IS_ERR(priv->base))
 149                 return PTR_ERR(priv->base);
 150
 151         ret = devm_hwrng_register(&pdev->dev, &priv->rng);
 152         if (ret) {
 153                 dev_err(&pdev->dev, "failed to register rng device: %d\n",
 154                         ret);
 155                 return ret;
 156         }
 157
 158         dev_set_drvdata(&pdev->dev, priv);
 159         pm_runtime_set_autosuspend_delay(&pdev->dev, RNG_AUTOSUSPEND_TIMEOUT);
 160         pm_runtime_use_autosuspend(&pdev->dev);
 161         pm_runtime_enable(&pdev->dev);
 162
 163         dev_info(&pdev->dev, "registered RNG driver\n");
 164
 165         return 0;
 166 }
 167
 168 #ifdef CONFIG_PM
 169 static int mtk_rng_runtime_suspend(struct device *dev)
 170 {
 171         struct mtk_rng *priv = dev_get_drvdata(dev);
 172
 173         mtk_rng_cleanup(&priv->rng);
 174
 175         return 0;
 176 }
 177
 178 static int mtk_rng_runtime_resume(struct device *dev)
 179 {
 180         struct mtk_rng *priv = dev_get_drvdata(dev);
 181
 182         return mtk_rng_init(&priv->rng);
 183 }
 184
 185 static const struct dev_pm_ops mtk_rng_pm_ops = {
 186         SET_RUNTIME_PM_OPS(mtk_rng_runtime_suspend,
 187                            mtk_rng_runtime_resume, NULL)
 188         SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
 189                                 pm_runtime_force_resume)
 190 };
 191
 192 #define MTK_RNG_PM_OPS (&mtk_rng_pm_ops)
 193 #else   /* CONFIG_PM */
 194 #define MTK_RNG_PM_OPS NULL
 195 #endif  /* CONFIG_PM */
 196
 197 static const struct of_device_id mtk_rng_match[] = {
 198         { .compatible = "mediatek,mt7623-rng" },
 199         {},
 200 };
 201 MODULE_DEVICE_TABLE(of, mtk_rng_match);
 202
 203 static struct platform_driver mtk_rng_driver = {
 204         .probe          = mtk_rng_probe,
 205         .driver = {
 206                 .name = MTK_RNG_DEV,
 207                 .pm = MTK_RNG_PM_OPS,
 208                 .of_match_table = mtk_rng_match,
 209         },
 210 };
 211
 212 module_platform_driver(mtk_rng_driver);
 213
 214 MODULE_DESCRIPTION("Mediatek Random Number Generator Driver");
 215 MODULE_AUTHOR("Sean Wang <sean.wang@mediatek.com>");
 216 MODULE_LICENSE("GPL");