]>
Commit | Line | Data |
---|---|---|
9c3c133b AC |
1 | /* |
2 | * drivers/char/hw_random/timeriomem-rng.c | |
3 | * | |
4 | * Copyright (C) 2009 Alexander Clouter <alex@digriz.org.uk> | |
5 | * | |
6 | * Derived from drivers/char/hw_random/omap-rng.c | |
7 | * Copyright 2005 (c) MontaVista Software, Inc. | |
8 | * Author: Deepak Saxena <dsaxena@plexity.net> | |
9 | * | |
10 | * This program is free software; you can redistribute it and/or modify | |
11 | * it under the terms of the GNU General Public License version 2 as | |
12 | * published by the Free Software Foundation. | |
13 | * | |
14 | * Overview: | |
15 | * This driver is useful for platforms that have an IO range that provides | |
16 | * periodic random data from a single IO memory address. All the platform | |
17 | * has to do is provide the address and 'wait time' that new data becomes | |
18 | * available. | |
19 | * | |
20 | * TODO: add support for reading sizes other than 32bits and masking | |
21 | */ | |
22 | ||
23 | #include <linux/module.h> | |
24 | #include <linux/kernel.h> | |
25 | #include <linux/platform_device.h> | |
b149a30d | 26 | #include <linux/of.h> |
9c3c133b AC |
27 | #include <linux/hw_random.h> |
28 | #include <linux/io.h> | |
1907da78 | 29 | #include <linux/slab.h> |
9c3c133b AC |
30 | #include <linux/timeriomem-rng.h> |
31 | #include <linux/jiffies.h> | |
32 | #include <linux/sched.h> | |
33 | #include <linux/timer.h> | |
34 | #include <linux/completion.h> | |
35 | ||
1907da78 AC |
36 | struct timeriomem_rng_private_data { |
37 | void __iomem *io_base; | |
38 | unsigned int expires; | |
39 | unsigned int period; | |
40 | unsigned int present:1; | |
9c3c133b | 41 | |
1907da78 AC |
42 | struct timer_list timer; |
43 | struct completion completion; | |
44 | ||
45 | struct hwrng timeriomem_rng_ops; | |
46 | }; | |
47 | ||
48 | #define to_rng_priv(rng) \ | |
49 | ((struct timeriomem_rng_private_data *)rng->priv) | |
9c3c133b AC |
50 | |
51 | /* | |
52 | * have data return 1, however return 0 if we have nothing | |
53 | */ | |
54 | static int timeriomem_rng_data_present(struct hwrng *rng, int wait) | |
55 | { | |
1907da78 | 56 | struct timeriomem_rng_private_data *priv = to_rng_priv(rng); |
9c3c133b | 57 | |
1907da78 AC |
58 | if (!wait || priv->present) |
59 | return priv->present; | |
9c3c133b | 60 | |
1907da78 | 61 | wait_for_completion(&priv->completion); |
9c3c133b AC |
62 | |
63 | return 1; | |
64 | } | |
65 | ||
66 | static int timeriomem_rng_data_read(struct hwrng *rng, u32 *data) | |
67 | { | |
1907da78 | 68 | struct timeriomem_rng_private_data *priv = to_rng_priv(rng); |
9c3c133b AC |
69 | unsigned long cur; |
70 | s32 delay; | |
71 | ||
1907da78 | 72 | *data = readl(priv->io_base); |
9c3c133b | 73 | |
1907da78 | 74 | cur = jiffies; |
9c3c133b | 75 | |
1907da78 AC |
76 | delay = cur - priv->expires; |
77 | delay = priv->period - (delay % priv->period); | |
9c3c133b | 78 | |
1907da78 AC |
79 | priv->expires = cur + delay; |
80 | priv->present = 0; | |
9c3c133b | 81 | |
16735d02 | 82 | reinit_completion(&priv->completion); |
1907da78 | 83 | mod_timer(&priv->timer, priv->expires); |
9c3c133b AC |
84 | |
85 | return 4; | |
86 | } | |
87 | ||
1907da78 | 88 | static void timeriomem_rng_trigger(unsigned long data) |
9c3c133b | 89 | { |
1907da78 AC |
90 | struct timeriomem_rng_private_data *priv |
91 | = (struct timeriomem_rng_private_data *)data; | |
9c3c133b | 92 | |
1907da78 AC |
93 | priv->present = 1; |
94 | complete(&priv->completion); | |
95 | } | |
9c3c133b | 96 | |
bcd2982a | 97 | static int timeriomem_rng_probe(struct platform_device *pdev) |
9c3c133b | 98 | { |
1907da78 AC |
99 | struct timeriomem_rng_data *pdata = pdev->dev.platform_data; |
100 | struct timeriomem_rng_private_data *priv; | |
08ced854 | 101 | struct resource *res; |
1907da78 AC |
102 | int err = 0; |
103 | int period; | |
9c3c133b | 104 | |
b149a30d | 105 | if (!pdev->dev.of_node && !pdata) { |
1907da78 AC |
106 | dev_err(&pdev->dev, "timeriomem_rng_data is missing\n"); |
107 | return -EINVAL; | |
108 | } | |
3341323b | 109 | |
1907da78 | 110 | res = platform_get_resource(pdev, IORESOURCE_MEM, 0); |
3341323b | 111 | if (!res) |
1907da78 | 112 | return -ENXIO; |
3341323b | 113 | |
1907da78 AC |
114 | if (res->start % 4 != 0 || resource_size(res) != 4) { |
115 | dev_err(&pdev->dev, | |
116 | "address must be four bytes wide and aligned\n"); | |
117 | return -EINVAL; | |
118 | } | |
9c3c133b | 119 | |
1907da78 AC |
120 | /* Allocate memory for the device structure (and zero it) */ |
121 | priv = kzalloc(sizeof(struct timeriomem_rng_private_data), GFP_KERNEL); | |
122 | if (!priv) { | |
123 | dev_err(&pdev->dev, "failed to allocate device structure.\n"); | |
124 | return -ENOMEM; | |
125 | } | |
126 | ||
127 | platform_set_drvdata(pdev, priv); | |
3341323b | 128 | |
b149a30d AC |
129 | if (pdev->dev.of_node) { |
130 | int i; | |
131 | ||
132 | if (!of_property_read_u32(pdev->dev.of_node, | |
133 | "period", &i)) | |
134 | period = i; | |
135 | else { | |
136 | dev_err(&pdev->dev, "missing period\n"); | |
137 | err = -EINVAL; | |
138 | goto out_free; | |
139 | } | |
140 | } else | |
141 | period = pdata->period; | |
9c3c133b | 142 | |
1907da78 AC |
143 | priv->period = usecs_to_jiffies(period); |
144 | if (priv->period < 1) { | |
145 | dev_err(&pdev->dev, "period is less than one jiffy\n"); | |
146 | err = -EINVAL; | |
147 | goto out_free; | |
9c3c133b | 148 | } |
9c3c133b | 149 | |
1907da78 AC |
150 | priv->expires = jiffies; |
151 | priv->present = 1; | |
152 | ||
153 | init_completion(&priv->completion); | |
154 | complete(&priv->completion); | |
155 | ||
156 | setup_timer(&priv->timer, timeriomem_rng_trigger, (unsigned long)priv); | |
157 | ||
158 | priv->timeriomem_rng_ops.name = dev_name(&pdev->dev); | |
159 | priv->timeriomem_rng_ops.data_present = timeriomem_rng_data_present; | |
160 | priv->timeriomem_rng_ops.data_read = timeriomem_rng_data_read; | |
161 | priv->timeriomem_rng_ops.priv = (unsigned long)priv; | |
162 | ||
163 | if (!request_mem_region(res->start, resource_size(res), | |
164 | dev_name(&pdev->dev))) { | |
165 | dev_err(&pdev->dev, "request_mem_region failed\n"); | |
166 | err = -EBUSY; | |
167 | goto out_timer; | |
168 | } | |
169 | ||
170 | priv->io_base = ioremap(res->start, resource_size(res)); | |
171 | if (priv->io_base == NULL) { | |
172 | dev_err(&pdev->dev, "ioremap failed\n"); | |
173 | err = -EIO; | |
174 | goto out_release_io; | |
175 | } | |
176 | ||
177 | err = hwrng_register(&priv->timeriomem_rng_ops); | |
178 | if (err) { | |
179 | dev_err(&pdev->dev, "problem registering\n"); | |
180 | goto out; | |
181 | } | |
9c3c133b AC |
182 | |
183 | dev_info(&pdev->dev, "32bits from 0x%p @ %dus\n", | |
1907da78 | 184 | priv->io_base, period); |
9c3c133b AC |
185 | |
186 | return 0; | |
3341323b | 187 | |
1907da78 AC |
188 | out: |
189 | iounmap(priv->io_base); | |
190 | out_release_io: | |
191 | release_mem_region(res->start, resource_size(res)); | |
192 | out_timer: | |
193 | del_timer_sync(&priv->timer); | |
194 | out_free: | |
1907da78 AC |
195 | kfree(priv); |
196 | return err; | |
9c3c133b AC |
197 | } |
198 | ||
39af33fc | 199 | static int timeriomem_rng_remove(struct platform_device *pdev) |
9c3c133b | 200 | { |
1907da78 AC |
201 | struct timeriomem_rng_private_data *priv = platform_get_drvdata(pdev); |
202 | struct resource *res; | |
203 | ||
204 | res = platform_get_resource(pdev, IORESOURCE_MEM, 0); | |
205 | ||
206 | hwrng_unregister(&priv->timeriomem_rng_ops); | |
9c3c133b | 207 | |
1907da78 AC |
208 | del_timer_sync(&priv->timer); |
209 | iounmap(priv->io_base); | |
210 | release_mem_region(res->start, resource_size(res)); | |
1907da78 | 211 | kfree(priv); |
3341323b | 212 | |
9c3c133b AC |
213 | return 0; |
214 | } | |
215 | ||
b149a30d AC |
216 | static const struct of_device_id timeriomem_rng_match[] = { |
217 | { .compatible = "timeriomem_rng" }, | |
218 | {}, | |
219 | }; | |
220 | MODULE_DEVICE_TABLE(of, timeriomem_rng_match); | |
221 | ||
9c3c133b AC |
222 | static struct platform_driver timeriomem_rng_driver = { |
223 | .driver = { | |
224 | .name = "timeriomem_rng", | |
225 | .owner = THIS_MODULE, | |
b149a30d | 226 | .of_match_table = timeriomem_rng_match, |
9c3c133b AC |
227 | }, |
228 | .probe = timeriomem_rng_probe, | |
bcd2982a | 229 | .remove = timeriomem_rng_remove, |
9c3c133b AC |
230 | }; |
231 | ||
b21cb324 | 232 | module_platform_driver(timeriomem_rng_driver); |
9c3c133b AC |
233 | |
234 | MODULE_LICENSE("GPL"); | |
235 | MODULE_AUTHOR("Alexander Clouter <alex@digriz.org.uk>"); | |
236 | MODULE_DESCRIPTION("Timer IOMEM H/W RNG driver"); |