1
2
3
4
5
6#include <linux/delay.h>
7#include <linux/of.h>
8#include <linux/hw_random.h>
9#include <linux/kernel.h>
10#include <linux/module.h>
11#include <linux/slab.h>
12#include <linux/tee_drv.h>
13#include <linux/uuid.h>
14
15#define DRIVER_NAME "optee-rng"
16
17#define TEE_ERROR_HEALTH_TEST_FAIL 0x00000001
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33#define TA_CMD_GET_ENTROPY 0x0
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48#define TA_CMD_GET_RNG_INFO 0x1
49
50#define MAX_ENTROPY_REQ_SZ (4 * 1024)
51
52
53
54
55
56
57
58
59
60
61struct optee_rng_private {
62 struct device *dev;
63 struct tee_context *ctx;
64 u32 session_id;
65 u32 data_rate;
66 struct tee_shm *entropy_shm_pool;
67 struct hwrng optee_rng;
68};
69
70#define to_optee_rng_private(r) \
71 container_of(r, struct optee_rng_private, optee_rng)
72
73static size_t get_optee_rng_data(struct optee_rng_private *pvt_data,
74 void *buf, size_t req_size)
75{
76 int ret = 0;
77 u8 *rng_data = NULL;
78 size_t rng_size = 0;
79 struct tee_ioctl_invoke_arg inv_arg;
80 struct tee_param param[4];
81
82 memset(&inv_arg, 0, sizeof(inv_arg));
83 memset(¶m, 0, sizeof(param));
84
85
86 inv_arg.func = TA_CMD_GET_ENTROPY;
87 inv_arg.session = pvt_data->session_id;
88 inv_arg.num_params = 4;
89
90
91 param[0].attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INOUT;
92 param[0].u.memref.shm = pvt_data->entropy_shm_pool;
93 param[0].u.memref.size = req_size;
94 param[0].u.memref.shm_offs = 0;
95
96 ret = tee_client_invoke_func(pvt_data->ctx, &inv_arg, param);
97 if ((ret < 0) || (inv_arg.ret != 0)) {
98 dev_err(pvt_data->dev, "TA_CMD_GET_ENTROPY invoke err: %x\n",
99 inv_arg.ret);
100 return 0;
101 }
102
103 rng_data = tee_shm_get_va(pvt_data->entropy_shm_pool, 0);
104 if (IS_ERR(rng_data)) {
105 dev_err(pvt_data->dev, "tee_shm_get_va failed\n");
106 return 0;
107 }
108
109 rng_size = param[0].u.memref.size;
110 memcpy(buf, rng_data, rng_size);
111
112 return rng_size;
113}
114
115static int optee_rng_read(struct hwrng *rng, void *buf, size_t max, bool wait)
116{
117 struct optee_rng_private *pvt_data = to_optee_rng_private(rng);
118 size_t read = 0, rng_size = 0;
119 int timeout = 1;
120 u8 *data = buf;
121
122 if (max > MAX_ENTROPY_REQ_SZ)
123 max = MAX_ENTROPY_REQ_SZ;
124
125 while (read < max) {
126 rng_size = get_optee_rng_data(pvt_data, data, (max - read));
127
128 data += rng_size;
129 read += rng_size;
130
131 if (wait && pvt_data->data_rate) {
132 if ((timeout-- == 0) || (read == max))
133 return read;
134 msleep((1000 * (max - read)) / pvt_data->data_rate);
135 } else {
136 return read;
137 }
138 }
139
140 return read;
141}
142
143static int optee_rng_init(struct hwrng *rng)
144{
145 struct optee_rng_private *pvt_data = to_optee_rng_private(rng);
146 struct tee_shm *entropy_shm_pool = NULL;
147
148 entropy_shm_pool = tee_shm_alloc(pvt_data->ctx, MAX_ENTROPY_REQ_SZ,
149 TEE_SHM_MAPPED | TEE_SHM_DMA_BUF);
150 if (IS_ERR(entropy_shm_pool)) {
151 dev_err(pvt_data->dev, "tee_shm_alloc failed\n");
152 return PTR_ERR(entropy_shm_pool);
153 }
154
155 pvt_data->entropy_shm_pool = entropy_shm_pool;
156
157 return 0;
158}
159
160static void optee_rng_cleanup(struct hwrng *rng)
161{
162 struct optee_rng_private *pvt_data = to_optee_rng_private(rng);
163
164 tee_shm_free(pvt_data->entropy_shm_pool);
165}
166
167static struct optee_rng_private pvt_data = {
168 .optee_rng = {
169 .name = DRIVER_NAME,
170 .init = optee_rng_init,
171 .cleanup = optee_rng_cleanup,
172 .read = optee_rng_read,
173 }
174};
175
176static int get_optee_rng_info(struct device *dev)
177{
178 int ret = 0;
179 struct tee_ioctl_invoke_arg inv_arg;
180 struct tee_param param[4];
181
182 memset(&inv_arg, 0, sizeof(inv_arg));
183 memset(¶m, 0, sizeof(param));
184
185
186 inv_arg.func = TA_CMD_GET_RNG_INFO;
187 inv_arg.session = pvt_data.session_id;
188 inv_arg.num_params = 4;
189
190
191 param[0].attr = TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_OUTPUT;
192
193 ret = tee_client_invoke_func(pvt_data.ctx, &inv_arg, param);
194 if ((ret < 0) || (inv_arg.ret != 0)) {
195 dev_err(dev, "TA_CMD_GET_RNG_INFO invoke err: %x\n",
196 inv_arg.ret);
197 return -EINVAL;
198 }
199
200 pvt_data.data_rate = param[0].u.value.a;
201 pvt_data.optee_rng.quality = param[0].u.value.b;
202
203 return 0;
204}
205
206static int optee_ctx_match(struct tee_ioctl_version_data *ver, const void *data)
207{
208 if (ver->impl_id == TEE_IMPL_ID_OPTEE)
209 return 1;
210 else
211 return 0;
212}
213
214static int optee_rng_probe(struct device *dev)
215{
216 struct tee_client_device *rng_device = to_tee_client_device(dev);
217 int ret = 0, err = -ENODEV;
218 struct tee_ioctl_open_session_arg sess_arg;
219
220 memset(&sess_arg, 0, sizeof(sess_arg));
221
222
223 pvt_data.ctx = tee_client_open_context(NULL, optee_ctx_match, NULL,
224 NULL);
225 if (IS_ERR(pvt_data.ctx))
226 return -ENODEV;
227
228
229 export_uuid(sess_arg.uuid, &rng_device->id.uuid);
230 sess_arg.clnt_login = TEE_IOCTL_LOGIN_PUBLIC;
231 sess_arg.num_params = 0;
232
233 ret = tee_client_open_session(pvt_data.ctx, &sess_arg, NULL);
234 if ((ret < 0) || (sess_arg.ret != 0)) {
235 dev_err(dev, "tee_client_open_session failed, err: %x\n",
236 sess_arg.ret);
237 err = -EINVAL;
238 goto out_ctx;
239 }
240 pvt_data.session_id = sess_arg.session;
241
242 err = get_optee_rng_info(dev);
243 if (err)
244 goto out_sess;
245
246 err = devm_hwrng_register(dev, &pvt_data.optee_rng);
247 if (err) {
248 dev_err(dev, "hwrng registration failed (%d)\n", err);
249 goto out_sess;
250 }
251
252 pvt_data.dev = dev;
253
254 return 0;
255
256out_sess:
257 tee_client_close_session(pvt_data.ctx, pvt_data.session_id);
258out_ctx:
259 tee_client_close_context(pvt_data.ctx);
260
261 return err;
262}
263
264static int optee_rng_remove(struct device *dev)
265{
266 tee_client_close_session(pvt_data.ctx, pvt_data.session_id);
267 tee_client_close_context(pvt_data.ctx);
268
269 return 0;
270}
271
272static const struct tee_client_device_id optee_rng_id_table[] = {
273 {UUID_INIT(0xab7a617c, 0xb8e7, 0x4d8f,
274 0x83, 0x01, 0xd0, 0x9b, 0x61, 0x03, 0x6b, 0x64)},
275 {}
276};
277
278MODULE_DEVICE_TABLE(tee, optee_rng_id_table);
279
280static struct tee_client_driver optee_rng_driver = {
281 .id_table = optee_rng_id_table,
282 .driver = {
283 .name = DRIVER_NAME,
284 .bus = &tee_bus_type,
285 .probe = optee_rng_probe,
286 .remove = optee_rng_remove,
287 },
288};
289
290static int __init optee_rng_mod_init(void)
291{
292 return driver_register(&optee_rng_driver.driver);
293}
294
295static void __exit optee_rng_mod_exit(void)
296{
297 driver_unregister(&optee_rng_driver.driver);
298}
299
300module_init(optee_rng_mod_init);
301module_exit(optee_rng_mod_exit);
302
303MODULE_LICENSE("GPL v2");
304MODULE_AUTHOR("Sumit Garg <sumit.garg@linaro.org>");
305MODULE_DESCRIPTION("OP-TEE based random number generator driver");
306
