1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Copyright (c) 2015, Daniel Thompson
4  */
5 
6 #include <linux/clk.h>
7 #include <linux/delay.h>
8 #include <linux/hw_random.h>
9 #include <linux/io.h>
10 #include <linux/iopoll.h>
11 #include <linux/kernel.h>
12 #include <linux/module.h>
13 #include <linux/of_address.h>
14 #include <linux/of_platform.h>
15 #include <linux/pm_runtime.h>
16 #include <linux/reset.h>
17 #include <linux/slab.h>
18 
19 #define RNG_CR 0x00
20 #define RNG_CR_RNGEN BIT(2)
21 #define RNG_CR_CED BIT(5)
22 
23 #define RNG_SR 0x04
24 #define RNG_SR_SEIS BIT(6)
25 #define RNG_SR_CEIS BIT(5)
26 #define RNG_SR_DRDY BIT(0)
27 
28 #define RNG_DR 0x08
29 
30 struct stm32_rng_private {
31 	struct hwrng rng;
32 	void __iomem *base;
33 	struct clk *clk;
34 	struct reset_control *rst;
35 	bool ced;
36 };
37 
38 static int stm32_rng_read(struct hwrng *rng, void *data, size_t max, bool wait)
39 {
40 	struct stm32_rng_private *priv =
41 	    container_of(rng, struct stm32_rng_private, rng);
42 	u32 sr;
43 	int retval = 0;
44 
45 	pm_runtime_get_sync((struct device *) priv->rng.priv);
46 
47 	while (max > sizeof(u32)) {
48 		sr = readl_relaxed(priv->base + RNG_SR);
49 		/* Manage timeout which is based on timer and take */
50 		/* care of initial delay time when enabling rng	*/
51 		if (!sr && wait) {
52 			retval = readl_relaxed_poll_timeout_atomic(priv->base
53 								   + RNG_SR,
54 								   sr, sr,
55 								   10, 50000);
56 			if (retval)
57 				dev_err((struct device *)priv->rng.priv,
58 					"%s: timeout %x!\n", __func__, sr);
59 		}
60 
61 		/* If error detected or data not ready... */
62 		if (sr != RNG_SR_DRDY) {
63 			if (WARN_ONCE(sr & (RNG_SR_SEIS | RNG_SR_CEIS),
64 					"bad RNG status - %x\n", sr))
65 				writel_relaxed(0, priv->base + RNG_SR);
66 			break;
67 		}
68 
69 		*(u32 *)data = readl_relaxed(priv->base + RNG_DR);
70 
71 		retval += sizeof(u32);
72 		data += sizeof(u32);
73 		max -= sizeof(u32);
74 	}
75 
76 	pm_runtime_mark_last_busy((struct device *) priv->rng.priv);
77 	pm_runtime_put_sync_autosuspend((struct device *) priv->rng.priv);
78 
79 	return retval || !wait ? retval : -EIO;
80 }
81 
82 static int stm32_rng_init(struct hwrng *rng)
83 {
84 	struct stm32_rng_private *priv =
85 	    container_of(rng, struct stm32_rng_private, rng);
86 	int err;
87 
88 	err = clk_prepare_enable(priv->clk);
89 	if (err)
90 		return err;
91 
92 	if (priv->ced)
93 		writel_relaxed(RNG_CR_RNGEN, priv->base + RNG_CR);
94 	else
95 		writel_relaxed(RNG_CR_RNGEN | RNG_CR_CED,
96 			       priv->base + RNG_CR);
97 
98 	/* clear error indicators */
99 	writel_relaxed(0, priv->base + RNG_SR);
100 
101 	return 0;
102 }
103 
104 static void stm32_rng_cleanup(struct hwrng *rng)
105 {
106 	struct stm32_rng_private *priv =
107 	    container_of(rng, struct stm32_rng_private, rng);
108 
109 	writel_relaxed(0, priv->base + RNG_CR);
110 	clk_disable_unprepare(priv->clk);
111 }
112 
113 static int stm32_rng_probe(struct platform_device *ofdev)
114 {
115 	struct device *dev = &ofdev->dev;
116 	struct device_node *np = ofdev->dev.of_node;
117 	struct stm32_rng_private *priv;
118 	struct resource res;
119 	int err;
120 
121 	priv = devm_kzalloc(dev, sizeof(struct stm32_rng_private), GFP_KERNEL);
122 	if (!priv)
123 		return -ENOMEM;
124 
125 	err = of_address_to_resource(np, 0, &res);
126 	if (err)
127 		return err;
128 
129 	priv->base = devm_ioremap_resource(dev, &res);
130 	if (IS_ERR(priv->base))
131 		return PTR_ERR(priv->base);
132 
133 	priv->clk = devm_clk_get(&ofdev->dev, NULL);
134 	if (IS_ERR(priv->clk))
135 		return PTR_ERR(priv->clk);
136 
137 	priv->rst = devm_reset_control_get(&ofdev->dev, NULL);
138 	if (!IS_ERR(priv->rst)) {
139 		reset_control_assert(priv->rst);
140 		udelay(2);
141 		reset_control_deassert(priv->rst);
142 	}
143 
144 	priv->ced = of_property_read_bool(np, "clock-error-detect");
145 
146 	dev_set_drvdata(dev, priv);
147 
148 	priv->rng.name = dev_driver_string(dev),
149 #ifndef CONFIG_PM
150 	priv->rng.init = stm32_rng_init,
151 	priv->rng.cleanup = stm32_rng_cleanup,
152 #endif
153 	priv->rng.read = stm32_rng_read,
154 	priv->rng.priv = (unsigned long) dev;
155 	priv->rng.quality = 900;
156 
157 	pm_runtime_set_autosuspend_delay(dev, 100);
158 	pm_runtime_use_autosuspend(dev);
159 	pm_runtime_enable(dev);
160 
161 	return devm_hwrng_register(dev, &priv->rng);
162 }
163 
164 static int stm32_rng_remove(struct platform_device *ofdev)
165 {
166 	pm_runtime_disable(&ofdev->dev);
167 
168 	return 0;
169 }
170 
171 #ifdef CONFIG_PM
172 static int stm32_rng_runtime_suspend(struct device *dev)
173 {
174 	struct stm32_rng_private *priv = dev_get_drvdata(dev);
175 
176 	stm32_rng_cleanup(&priv->rng);
177 
178 	return 0;
179 }
180 
181 static int stm32_rng_runtime_resume(struct device *dev)
182 {
183 	struct stm32_rng_private *priv = dev_get_drvdata(dev);
184 
185 	return stm32_rng_init(&priv->rng);
186 }
187 #endif
188 
189 static const struct dev_pm_ops stm32_rng_pm_ops = {
190 	SET_RUNTIME_PM_OPS(stm32_rng_runtime_suspend,
191 			   stm32_rng_runtime_resume, NULL)
192 	SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
193 				pm_runtime_force_resume)
194 };
195 
196 
197 static const struct of_device_id stm32_rng_match[] = {
198 	{
199 		.compatible = "st,stm32-rng",
200 	},
201 	{},
202 };
203 MODULE_DEVICE_TABLE(of, stm32_rng_match);
204 
205 static struct platform_driver stm32_rng_driver = {
206 	.driver = {
207 		.name = "stm32-rng",
208 		.pm = &stm32_rng_pm_ops,
209 		.of_match_table = stm32_rng_match,
210 	},
211 	.probe = stm32_rng_probe,
212 	.remove = stm32_rng_remove,
213 };
214 
215 module_platform_driver(stm32_rng_driver);
216 
217 MODULE_LICENSE("GPL");
218 MODULE_AUTHOR("Daniel Thompson <daniel.thompson@linaro.org>");
219 MODULE_DESCRIPTION("STMicroelectronics STM32 RNG device driver");
220