char/hw_random/atmel-rng.c

0001 /*
0002  * Copyright (c) 2011 Peter Korsgaard <jacmet@sunsite.dk>
0003  *
0004  * This file is licensed under  the terms of the GNU General Public
0005  * License version 2. This program is licensed "as is" without any
0006  * warranty of any kind, whether express or implied.
0007  */
0008
0009 #include <linux/kernel.h>
0010 #include <linux/module.h>
0011 #include <linux/mod_devicetable.h>
0012 #include <linux/slab.h>
0013 #include <linux/err.h>
0014 #include <linux/clk.h>
0015 #include <linux/io.h>
0016 #include <linux/iopoll.h>
0017 #include <linux/hw_random.h>
0018 #include <linux/of_device.h>
0019 #include <linux/platform_device.h>
0020 #include <linux/pm_runtime.h>
0021
0022 #define TRNG_CR     0x00
0023 #define TRNG_MR     0x04
0024 #define TRNG_ISR    0x1c
0025 #define TRNG_ISR_DATRDY BIT(0)
0026 #define TRNG_ODATA  0x50
0027
0028 #define TRNG_KEY    0x524e4700 /* RNG */
0029
0030 #define TRNG_HALFR  BIT(0) /* generate RN every 168 cycles */
0031
0032 struct atmel_trng_data {
0033     bool has_half_rate;
0034 };
0035
0036 struct atmel_trng {
0037     struct clk *clk;
0038     void __iomem *base;
0039     struct hwrng rng;
0040     bool has_half_rate;
0041 };
0042
0043 static bool atmel_trng_wait_ready(struct atmel_trng *trng, bool wait)
0044 {
0045     int ready;
0046
0047     ready = readl(trng->base + TRNG_ISR) & TRNG_ISR_DATRDY;
0048     if (!ready && wait)
0049         readl_poll_timeout(trng->base + TRNG_ISR, ready,
0050                    ready & TRNG_ISR_DATRDY, 1000, 20000);
0051
0052     return !!ready;
0053 }
0054
0055 static int atmel_trng_read(struct hwrng *rng, void *buf, size_t max,
0056                bool wait)
0057 {
0058     struct atmel_trng *trng = container_of(rng, struct atmel_trng, rng);
0059     u32 *data = buf;
0060     int ret;
0061
0062     ret = pm_runtime_get_sync((struct device *)trng->rng.priv);
0063     if (ret < 0) {
0064         pm_runtime_put_sync((struct device *)trng->rng.priv);
0065         return ret;
0066     }
0067
0068     ret = atmel_trng_wait_ready(trng, wait);
0069     if (!ret)
0070         goto out;
0071
0072     *data = readl(trng->base + TRNG_ODATA);
0073     /*
0074      * ensure data ready is only set again AFTER the next data word is ready
0075      * in case it got set between checking ISR and reading ODATA, so we
0076      * don't risk re-reading the same word
0077      */
0078     readl(trng->base + TRNG_ISR);
0079     ret = 4;
0080
0081 out:
0082     pm_runtime_mark_last_busy((struct device *)trng->rng.priv);
0083     pm_runtime_put_sync_autosuspend((struct device *)trng->rng.priv);
0084     return ret;
0085 }
0086
0087 static int atmel_trng_init(struct atmel_trng *trng)
0088 {
0089     unsigned long rate;
0090     int ret;
0091
0092     ret = clk_prepare_enable(trng->clk);
0093     if (ret)
0094         return ret;
0095
0096     if (trng->has_half_rate) {
0097         rate = clk_get_rate(trng->clk);
0098
0099         /* if peripheral clk is above 100MHz, set HALFR */
0100         if (rate > 100000000)
0101             writel(TRNG_HALFR, trng->base + TRNG_MR);
0102     }
0103
0104     writel(TRNG_KEY | 1, trng->base + TRNG_CR);
0105
0106     return 0;
0107 }
0108
0109 static void atmel_trng_cleanup(struct atmel_trng *trng)
0110 {
0111     writel(TRNG_KEY, trng->base + TRNG_CR);
0112     clk_disable_unprepare(trng->clk);
0113 }
0114
0115 static int atmel_trng_probe(struct platform_device *pdev)
0116 {
0117     struct atmel_trng *trng;
0118     const struct atmel_trng_data *data;
0119     int ret;
0120
0121     trng = devm_kzalloc(&pdev->dev, sizeof(*trng), GFP_KERNEL);
0122     if (!trng)
0123         return -ENOMEM;
0124
0125     trng->base = devm_platform_ioremap_resource(pdev, 0);
0126     if (IS_ERR(trng->base))
0127         return PTR_ERR(trng->base);
0128
0129     trng->clk = devm_clk_get(&pdev->dev, NULL);
0130     if (IS_ERR(trng->clk))
0131         return PTR_ERR(trng->clk);
0132     data = of_device_get_match_data(&pdev->dev);
0133     if (!data)
0134         return -ENODEV;
0135
0136     trng->has_half_rate = data->has_half_rate;
0137     trng->rng.name = pdev->name;
0138     trng->rng.read = atmel_trng_read;
0139     trng->rng.priv = (unsigned long)&pdev->dev;
0140     platform_set_drvdata(pdev, trng);
0141
0142 #ifndef CONFIG_PM
0143     ret = atmel_trng_init(trng);
0144     if (ret)
0145         return ret;
0146 #endif
0147
0148     pm_runtime_set_autosuspend_delay(&pdev->dev, 100);
0149     pm_runtime_use_autosuspend(&pdev->dev);
0150     pm_runtime_enable(&pdev->dev);
0151
0152     ret = devm_hwrng_register(&pdev->dev, &trng->rng);
0153     if (ret) {
0154         pm_runtime_disable(&pdev->dev);
0155         pm_runtime_set_suspended(&pdev->dev);
0156 #ifndef CONFIG_PM
0157         atmel_trng_cleanup(trng);
0158 #endif
0159     }
0160
0161     return ret;
0162 }
0163
0164 static int atmel_trng_remove(struct platform_device *pdev)
0165 {
0166     struct atmel_trng *trng = platform_get_drvdata(pdev);
0167
0168     atmel_trng_cleanup(trng);
0169     pm_runtime_disable(&pdev->dev);
0170     pm_runtime_set_suspended(&pdev->dev);
0171
0172     return 0;
0173 }
0174
0175 static int __maybe_unused atmel_trng_runtime_suspend(struct device *dev)
0176 {
0177     struct atmel_trng *trng = dev_get_drvdata(dev);
0178
0179     atmel_trng_cleanup(trng);
0180
0181     return 0;
0182 }
0183
0184 static int __maybe_unused atmel_trng_runtime_resume(struct device *dev)
0185 {
0186     struct atmel_trng *trng = dev_get_drvdata(dev);
0187
0188     return atmel_trng_init(trng);
0189 }
0190
0191 static const struct dev_pm_ops __maybe_unused atmel_trng_pm_ops = {
0192     SET_RUNTIME_PM_OPS(atmel_trng_runtime_suspend,
0193                atmel_trng_runtime_resume, NULL)
0194     SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
0195                 pm_runtime_force_resume)
0196 };
0197
0198 static const struct atmel_trng_data at91sam9g45_config = {
0199     .has_half_rate = false,
0200 };
0201
0202 static const struct atmel_trng_data sam9x60_config = {
0203     .has_half_rate = true,
0204 };
0205
0206 static const struct of_device_id atmel_trng_dt_ids[] = {
0207     {
0208         .compatible = "atmel,at91sam9g45-trng",
0209         .data = &at91sam9g45_config,
0210     }, {
0211         .compatible = "microchip,sam9x60-trng",
0212         .data = &sam9x60_config,
0213     }, {
0214         /* sentinel */
0215     }
0216 };
0217 MODULE_DEVICE_TABLE(of, atmel_trng_dt_ids);
0218
0219 static struct platform_driver atmel_trng_driver = {
0220     .probe      = atmel_trng_probe,
0221     .remove     = atmel_trng_remove,
0222     .driver     = {
0223         .name   = "atmel-trng",
0224         .pm = pm_ptr(&atmel_trng_pm_ops),
0225         .of_match_table = atmel_trng_dt_ids,
0226     },
0227 };
0228
0229 module_platform_driver(atmel_trng_driver);
0230
0231 MODULE_LICENSE("GPL");
0232 MODULE_AUTHOR("Peter Korsgaard <jacmet@sunsite.dk>");
0233 MODULE_DESCRIPTION("Atmel true random number generator driver");