1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (C) 2018-2019 Linaro Ltd.
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 * TA_CMD_GET_ENTROPY - Get Entropy from RNG
21 *
22 * param[0] (inout memref) - Entropy buffer memory reference
23 * param[1] unused
24 * param[2] unused
25 * param[3] unused
26 *
27 * Result:
28 * TEE_SUCCESS - Invoke command success
29 * TEE_ERROR_BAD_PARAMETERS - Incorrect input param
30 * TEE_ERROR_NOT_SUPPORTED - Requested entropy size greater than size of pool
31 * TEE_ERROR_HEALTH_TEST_FAIL - Continuous health testing failed
32 */
33 #define TA_CMD_GET_ENTROPY 0x0
34
35 /*
36 * TA_CMD_GET_RNG_INFO - Get RNG information
37 *
38 * param[0] (out value) - value.a: RNG data-rate in bytes per second
39 * value.b: Quality/Entropy per 1024 bit of data
40 * param[1] unused
41 * param[2] unused
42 * param[3] unused
43 *
44 * Result:
45 * TEE_SUCCESS - Invoke command success
46 * TEE_ERROR_BAD_PARAMETERS - Incorrect input param
47 */
48 #define TA_CMD_GET_RNG_INFO 0x1
49
50 #define MAX_ENTROPY_REQ_SZ (4 * 1024)
51
52 /**
53 * struct optee_rng_private - OP-TEE Random Number Generator private data
54 * @dev: OP-TEE based RNG device.
55 * @ctx: OP-TEE context handler.
56 * @session_id: RNG TA session identifier.
57 * @data_rate: RNG data rate.
58 * @entropy_shm_pool: Memory pool shared with RNG device.
59 * @optee_rng: OP-TEE RNG driver structure.
60 */
61 struct 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
get_optee_rng_data(struct optee_rng_private * pvt_data,void * buf,size_t req_size)73 static 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 /* Invoke TA_CMD_GET_ENTROPY function of Trusted App */
86 inv_arg.func = TA_CMD_GET_ENTROPY;
87 inv_arg.session = pvt_data->session_id;
88 inv_arg.num_params = 4;
89
90 /* Fill invoke cmd params */
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
optee_rng_read(struct hwrng * rng,void * buf,size_t max,bool wait)115 static 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;
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
optee_rng_init(struct hwrng * rng)143 static 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_kernel_buf(pvt_data->ctx,
149 MAX_ENTROPY_REQ_SZ);
150 if (IS_ERR(entropy_shm_pool)) {
151 dev_err(pvt_data->dev, "tee_shm_alloc_kernel_buf 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
optee_rng_cleanup(struct hwrng * rng)160 static 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
167 static 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
get_optee_rng_info(struct device * dev)176 static 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 /* Invoke TA_CMD_GET_RNG_INFO function of Trusted App */
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 /* Fill invoke cmd params */
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
optee_ctx_match(struct tee_ioctl_version_data * ver,const void * data)206 static 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
optee_rng_probe(struct device * dev)214 static 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 /* Open context with TEE driver */
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 /* Open session with hwrng Trusted App */
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
256 out_sess:
257 tee_client_close_session(pvt_data.ctx, pvt_data.session_id);
258 out_ctx:
259 tee_client_close_context(pvt_data.ctx);
260
261 return err;
262 }
263
optee_rng_remove(struct device * dev)264 static 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
272 static 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
278 MODULE_DEVICE_TABLE(tee, optee_rng_id_table);
279
280 static 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
optee_rng_mod_init(void)290 static int __init optee_rng_mod_init(void)
291 {
292 return driver_register(&optee_rng_driver.driver);
293 }
294
optee_rng_mod_exit(void)295 static void __exit optee_rng_mod_exit(void)
296 {
297 driver_unregister(&optee_rng_driver.driver);
298 }
299
300 module_init(optee_rng_mod_init);
301 module_exit(optee_rng_mod_exit);
302
303 MODULE_LICENSE("GPL v2");
304 MODULE_AUTHOR("Sumit Garg <sumit.garg@linaro.org>");
305 MODULE_DESCRIPTION("OP-TEE based random number generator driver");
306
