1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * Copyright (c) 2010-2012 Broadcom. All rights reserved. |
4 | * Copyright (c) 2013 Lubomir Rintel |
5 | */ |
6 | |
7 | #include <linux/hw_random.h> |
8 | #include <linux/io.h> |
9 | #include <linux/kernel.h> |
10 | #include <linux/module.h> |
11 | #include <linux/of.h> |
12 | #include <linux/platform_device.h> |
13 | #include <linux/printk.h> |
14 | #include <linux/clk.h> |
15 | #include <linux/reset.h> |
16 | |
17 | #define RNG_CTRL 0x0 |
18 | #define RNG_STATUS 0x4 |
19 | #define RNG_DATA 0x8 |
20 | #define RNG_INT_MASK 0x10 |
21 | |
22 | /* enable rng */ |
23 | #define RNG_RBGEN 0x1 |
24 | |
25 | /* the initial numbers generated are "less random" so will be discarded */ |
26 | #define RNG_WARMUP_COUNT 0x40000 |
27 | |
28 | #define RNG_INT_OFF 0x1 |
29 | |
30 | struct bcm2835_rng_priv { |
31 | struct hwrng rng; |
32 | void __iomem *base; |
33 | bool mask_interrupts; |
34 | struct clk *clk; |
35 | struct reset_control *reset; |
36 | }; |
37 | |
38 | static inline struct bcm2835_rng_priv *to_rng_priv(struct hwrng *rng) |
39 | { |
40 | return container_of(rng, struct bcm2835_rng_priv, rng); |
41 | } |
42 | |
43 | static inline u32 rng_readl(struct bcm2835_rng_priv *priv, u32 offset) |
44 | { |
45 | /* MIPS chips strapped for BE will automagically configure the |
46 | * peripheral registers for CPU-native byte order. |
47 | */ |
48 | if (IS_ENABLED(CONFIG_MIPS) && IS_ENABLED(CONFIG_CPU_BIG_ENDIAN)) |
49 | return __raw_readl(addr: priv->base + offset); |
50 | else |
51 | return readl(addr: priv->base + offset); |
52 | } |
53 | |
54 | static inline void rng_writel(struct bcm2835_rng_priv *priv, u32 val, |
55 | u32 offset) |
56 | { |
57 | if (IS_ENABLED(CONFIG_MIPS) && IS_ENABLED(CONFIG_CPU_BIG_ENDIAN)) |
58 | __raw_writel(val, addr: priv->base + offset); |
59 | else |
60 | writel(val, addr: priv->base + offset); |
61 | } |
62 | |
63 | static int bcm2835_rng_read(struct hwrng *rng, void *buf, size_t max, |
64 | bool wait) |
65 | { |
66 | struct bcm2835_rng_priv *priv = to_rng_priv(rng); |
67 | u32 max_words = max / sizeof(u32); |
68 | u32 num_words, count; |
69 | |
70 | while ((rng_readl(priv, RNG_STATUS) >> 24) == 0) { |
71 | if (!wait) |
72 | return 0; |
73 | hwrng_yield(rng); |
74 | } |
75 | |
76 | num_words = rng_readl(priv, RNG_STATUS) >> 24; |
77 | if (num_words > max_words) |
78 | num_words = max_words; |
79 | |
80 | for (count = 0; count < num_words; count++) |
81 | ((u32 *)buf)[count] = rng_readl(priv, RNG_DATA); |
82 | |
83 | return num_words * sizeof(u32); |
84 | } |
85 | |
86 | static int bcm2835_rng_init(struct hwrng *rng) |
87 | { |
88 | struct bcm2835_rng_priv *priv = to_rng_priv(rng); |
89 | int ret = 0; |
90 | u32 val; |
91 | |
92 | ret = clk_prepare_enable(clk: priv->clk); |
93 | if (ret) |
94 | return ret; |
95 | |
96 | ret = reset_control_reset(rstc: priv->reset); |
97 | if (ret) |
98 | return ret; |
99 | |
100 | if (priv->mask_interrupts) { |
101 | /* mask the interrupt */ |
102 | val = rng_readl(priv, RNG_INT_MASK); |
103 | val |= RNG_INT_OFF; |
104 | rng_writel(priv, val, RNG_INT_MASK); |
105 | } |
106 | |
107 | /* set warm-up count & enable */ |
108 | rng_writel(priv, RNG_WARMUP_COUNT, RNG_STATUS); |
109 | rng_writel(priv, RNG_RBGEN, RNG_CTRL); |
110 | |
111 | return ret; |
112 | } |
113 | |
114 | static void bcm2835_rng_cleanup(struct hwrng *rng) |
115 | { |
116 | struct bcm2835_rng_priv *priv = to_rng_priv(rng); |
117 | |
118 | /* disable rng hardware */ |
119 | rng_writel(priv, val: 0, RNG_CTRL); |
120 | |
121 | clk_disable_unprepare(clk: priv->clk); |
122 | } |
123 | |
124 | struct bcm2835_rng_of_data { |
125 | bool mask_interrupts; |
126 | }; |
127 | |
128 | static const struct bcm2835_rng_of_data nsp_rng_of_data = { |
129 | .mask_interrupts = true, |
130 | }; |
131 | |
132 | static const struct of_device_id bcm2835_rng_of_match[] = { |
133 | { .compatible = "brcm,bcm2835-rng" }, |
134 | { .compatible = "brcm,bcm-nsp-rng" , .data = &nsp_rng_of_data }, |
135 | { .compatible = "brcm,bcm5301x-rng" , .data = &nsp_rng_of_data }, |
136 | { .compatible = "brcm,bcm6368-rng" }, |
137 | {}, |
138 | }; |
139 | |
140 | static int bcm2835_rng_probe(struct platform_device *pdev) |
141 | { |
142 | const struct bcm2835_rng_of_data *of_data; |
143 | struct device *dev = &pdev->dev; |
144 | const struct of_device_id *rng_id; |
145 | struct bcm2835_rng_priv *priv; |
146 | int err; |
147 | |
148 | priv = devm_kzalloc(dev, size: sizeof(*priv), GFP_KERNEL); |
149 | if (!priv) |
150 | return -ENOMEM; |
151 | |
152 | /* map peripheral */ |
153 | priv->base = devm_platform_ioremap_resource(pdev, index: 0); |
154 | if (IS_ERR(ptr: priv->base)) |
155 | return PTR_ERR(ptr: priv->base); |
156 | |
157 | /* Clock is optional on most platforms */ |
158 | priv->clk = devm_clk_get_optional(dev, NULL); |
159 | if (IS_ERR(ptr: priv->clk)) |
160 | return PTR_ERR(ptr: priv->clk); |
161 | |
162 | priv->reset = devm_reset_control_get_optional_exclusive(dev, NULL); |
163 | if (IS_ERR(ptr: priv->reset)) |
164 | return PTR_ERR(ptr: priv->reset); |
165 | |
166 | priv->rng.name = pdev->name; |
167 | priv->rng.init = bcm2835_rng_init; |
168 | priv->rng.read = bcm2835_rng_read; |
169 | priv->rng.cleanup = bcm2835_rng_cleanup; |
170 | |
171 | if (dev_of_node(dev)) { |
172 | rng_id = of_match_node(matches: bcm2835_rng_of_match, node: dev->of_node); |
173 | if (!rng_id) |
174 | return -EINVAL; |
175 | |
176 | /* Check for rng init function, execute it */ |
177 | of_data = rng_id->data; |
178 | if (of_data) |
179 | priv->mask_interrupts = of_data->mask_interrupts; |
180 | } |
181 | |
182 | /* register driver */ |
183 | err = devm_hwrng_register(dev, rng: &priv->rng); |
184 | if (err) |
185 | dev_err(dev, "hwrng registration failed\n" ); |
186 | else |
187 | dev_info(dev, "hwrng registered\n" ); |
188 | |
189 | return err; |
190 | } |
191 | |
192 | MODULE_DEVICE_TABLE(of, bcm2835_rng_of_match); |
193 | |
194 | static const struct platform_device_id bcm2835_rng_devtype[] = { |
195 | { .name = "bcm2835-rng" }, |
196 | { .name = "bcm63xx-rng" }, |
197 | { /* sentinel */ } |
198 | }; |
199 | MODULE_DEVICE_TABLE(platform, bcm2835_rng_devtype); |
200 | |
201 | static struct platform_driver bcm2835_rng_driver = { |
202 | .driver = { |
203 | .name = "bcm2835-rng" , |
204 | .of_match_table = bcm2835_rng_of_match, |
205 | }, |
206 | .probe = bcm2835_rng_probe, |
207 | .id_table = bcm2835_rng_devtype, |
208 | }; |
209 | module_platform_driver(bcm2835_rng_driver); |
210 | |
211 | MODULE_AUTHOR("Lubomir Rintel <lkundrak@v3.sk>" ); |
212 | MODULE_DESCRIPTION("BCM2835 Random Number Generator (RNG) driver" ); |
213 | MODULE_LICENSE("GPL v2" ); |
214 | |