1// SPDX-License-Identifier: GPL-2.0-or-later
 2/*
 3 * Nomadik RNG support
 4 *  Copyright 2009 Alessandro Rubini
 
 
 
 
 
 5 */
 6
 7#include <linux/kernel.h>
 8#include <linux/module.h>
 9#include <linux/device.h>
10#include <linux/amba/bus.h>
11#include <linux/hw_random.h>
12#include <linux/io.h>
13#include <linux/clk.h>
14#include <linux/err.h>
15
 
 
16static int nmk_rng_read(struct hwrng *rng, void *data, size_t max, bool wait)
17{
18	void __iomem *base = (void __iomem *)rng->priv;
19
20	/*
21	 * The register is 32 bits and gives 16 random bits (low half).
22	 * A subsequent read will delay the core for 400ns, so we just read
23	 * once and accept the very unlikely very small delay, even if wait==0.
24	 */
25	*(u16 *)data = __raw_readl(base + 8) & 0xffff;
26	return 2;
27}
28
29/* we have at most one RNG per machine, granted */
30static struct hwrng nmk_rng = {
31	.name		= "nomadik",
32	.read		= nmk_rng_read,
33};
34
35static int nmk_rng_probe(struct amba_device *dev, const struct amba_id *id)
36{
37	struct clk *rng_clk;
38	void __iomem *base;
39	int ret;
40
41	rng_clk = devm_clk_get_enabled(&dev->dev, NULL);
42	if (IS_ERR(rng_clk))
43		return dev_err_probe(&dev->dev, PTR_ERR(rng_clk), "could not get rng clock\n");
 
 
 
 
 
44
45	ret = amba_request_regions(dev, dev->dev.init_name);
46	if (ret)
47		return ret;
48	ret = -ENOMEM;
49	base = devm_ioremap(&dev->dev, dev->res.start,
50			    resource_size(&dev->res));
51	if (!base)
52		goto out_release;
53	nmk_rng.priv = (unsigned long)base;
54	ret = devm_hwrng_register(&dev->dev, &nmk_rng);
55	if (ret)
56		goto out_release;
57	return 0;
58
59out_release:
60	amba_release_regions(dev);
 
 
61	return ret;
62}
63
64static void nmk_rng_remove(struct amba_device *dev)
65{
 
66	amba_release_regions(dev);
 
 
67}
68
69static const struct amba_id nmk_rng_ids[] = {
70	{
71		.id	= 0x000805e1,
72		.mask	= 0x000fffff, /* top bits are rev and cfg: accept all */
73	},
74	{0, 0},
75};
76
77MODULE_DEVICE_TABLE(amba, nmk_rng_ids);
78
79static struct amba_driver nmk_rng_driver = {
80	.drv = {
81		.owner = THIS_MODULE,
82		.name = "rng",
83		},
84	.probe = nmk_rng_probe,
85	.remove = nmk_rng_remove,
86	.id_table = nmk_rng_ids,
87};
88
89module_amba_driver(nmk_rng_driver);
90
91MODULE_DESCRIPTION("ST-Ericsson Nomadik Random Number Generator");
92MODULE_LICENSE("GPL");

 
  1/*
  2 * Nomadik RNG support
  3 *  Copyright 2009 Alessandro Rubini
  4 *
  5 *  This program is free software; you can redistribute it and/or modify
  6 *  it under the terms of the GNU General Public License as published by
  7 *  the Free Software Foundation; either version 2 of the License, or
  8 *  (at your option) any later version.
  9 */
 10
 11#include <linux/kernel.h>
 12#include <linux/module.h>
 13#include <linux/device.h>
 14#include <linux/amba/bus.h>
 15#include <linux/hw_random.h>
 16#include <linux/io.h>
 17#include <linux/clk.h>
 18#include <linux/err.h>
 19
 20static struct clk *rng_clk;
 21
 22static int nmk_rng_read(struct hwrng *rng, void *data, size_t max, bool wait)
 23{
 24	void __iomem *base = (void __iomem *)rng->priv;
 25
 26	/*
 27	 * The register is 32 bits and gives 16 random bits (low half).
 28	 * A subsequent read will delay the core for 400ns, so we just read
 29	 * once and accept the very unlikely very small delay, even if wait==0.
 30	 */
 31	*(u16 *)data = __raw_readl(base + 8) & 0xffff;
 32	return 2;
 33}
 34
 35/* we have at most one RNG per machine, granted */
 36static struct hwrng nmk_rng = {
 37	.name		= "nomadik",
 38	.read		= nmk_rng_read,
 39};
 40
 41static int nmk_rng_probe(struct amba_device *dev, const struct amba_id *id)
 42{
 
 43	void __iomem *base;
 44	int ret;
 45
 46	rng_clk = devm_clk_get(&dev->dev, NULL);
 47	if (IS_ERR(rng_clk)) {
 48		dev_err(&dev->dev, "could not get rng clock\n");
 49		ret = PTR_ERR(rng_clk);
 50		return ret;
 51	}
 52
 53	clk_prepare_enable(rng_clk);
 54
 55	ret = amba_request_regions(dev, dev->dev.init_name);
 56	if (ret)
 57		goto out_clk;
 58	ret = -ENOMEM;
 59	base = devm_ioremap(&dev->dev, dev->res.start,
 60			    resource_size(&dev->res));
 61	if (!base)
 62		goto out_release;
 63	nmk_rng.priv = (unsigned long)base;
 64	ret = hwrng_register(&nmk_rng);
 65	if (ret)
 66		goto out_release;
 67	return 0;
 68
 69out_release:
 70	amba_release_regions(dev);
 71out_clk:
 72	clk_disable(rng_clk);
 73	return ret;
 74}
 75
 76static int nmk_rng_remove(struct amba_device *dev)
 77{
 78	hwrng_unregister(&nmk_rng);
 79	amba_release_regions(dev);
 80	clk_disable(rng_clk);
 81	return 0;
 82}
 83
 84static struct amba_id nmk_rng_ids[] = {
 85	{
 86		.id	= 0x000805e1,
 87		.mask	= 0x000fffff, /* top bits are rev and cfg: accept all */
 88	},
 89	{0, 0},
 90};
 91
 92MODULE_DEVICE_TABLE(amba, nmk_rng_ids);
 93
 94static struct amba_driver nmk_rng_driver = {
 95	.drv = {
 96		.owner = THIS_MODULE,
 97		.name = "rng",
 98		},
 99	.probe = nmk_rng_probe,
100	.remove = nmk_rng_remove,
101	.id_table = nmk_rng_ids,
102};
103
104module_amba_driver(nmk_rng_driver);
105
 
106MODULE_LICENSE("GPL");