1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (C) 2019-2021 Linaro Ltd.
4 */
5
6 #include <linux/io.h>
7 #include <linux/of.h>
8 #include <linux/of_address.h>
9 #include <linux/kernel.h>
10 #include <linux/module.h>
11 #include <linux/mutex.h>
12 #include <linux/slab.h>
13 #include <linux/tee_drv.h>
14 #include <linux/uuid.h>
15 #include <uapi/linux/tee.h>
16
17 #include "common.h"
18
19 #define SCMI_OPTEE_MAX_MSG_SIZE 128
20
21 enum scmi_optee_pta_cmd {
22 /*
23 * PTA_SCMI_CMD_CAPABILITIES - Get channel capabilities
24 *
25 * [out] value[0].a: Capability bit mask (enum pta_scmi_caps)
26 * [out] value[0].b: Extended capabilities or 0
27 */
28 PTA_SCMI_CMD_CAPABILITIES = 0,
29
30 /*
31 * PTA_SCMI_CMD_PROCESS_SMT_CHANNEL - Process SCMI message in SMT buffer
32 *
33 * [in] value[0].a: Channel handle
34 *
35 * Shared memory used for SCMI message/response exhange is expected
36 * already identified and bound to channel handle in both SCMI agent
37 * and SCMI server (OP-TEE) parts.
38 * The memory uses SMT header to carry SCMI meta-data (protocol ID and
39 * protocol message ID).
40 */
41 PTA_SCMI_CMD_PROCESS_SMT_CHANNEL = 1,
42
43 /*
44 * PTA_SCMI_CMD_PROCESS_SMT_CHANNEL_MESSAGE - Process SMT/SCMI message
45 *
46 * [in] value[0].a: Channel handle
47 * [in/out] memref[1]: Message/response buffer (SMT and SCMI payload)
48 *
49 * Shared memory used for SCMI message/response is a SMT buffer
50 * referenced by param[1]. It shall be 128 bytes large to fit response
51 * payload whatever message playload size.
52 * The memory uses SMT header to carry SCMI meta-data (protocol ID and
53 * protocol message ID).
54 */
55 PTA_SCMI_CMD_PROCESS_SMT_CHANNEL_MESSAGE = 2,
56
57 /*
58 * PTA_SCMI_CMD_GET_CHANNEL - Get channel handle
59 *
60 * SCMI shm information are 0 if agent expects to use OP-TEE regular SHM
61 *
62 * [in] value[0].a: Channel identifier
63 * [out] value[0].a: Returned channel handle
64 * [in] value[0].b: Requested capabilities mask (enum pta_scmi_caps)
65 */
66 PTA_SCMI_CMD_GET_CHANNEL = 3,
67
68 /*
69 * PTA_SCMI_CMD_PROCESS_MSG_CHANNEL - Process SCMI message in a MSG
70 * buffer pointed by memref parameters
71 *
72 * [in] value[0].a: Channel handle
73 * [in] memref[1]: Message buffer (MSG and SCMI payload)
74 * [out] memref[2]: Response buffer (MSG and SCMI payload)
75 *
76 * Shared memories used for SCMI message/response are MSG buffers
77 * referenced by param[1] and param[2]. MSG transport protocol
78 * uses a 32bit header to carry SCMI meta-data (protocol ID and
79 * protocol message ID) followed by the effective SCMI message
80 * payload.
81 */
82 PTA_SCMI_CMD_PROCESS_MSG_CHANNEL = 4,
83 };
84
85 /*
86 * OP-TEE SCMI service capabilities bit flags (32bit)
87 *
88 * PTA_SCMI_CAPS_SMT_HEADER
89 * When set, OP-TEE supports command using SMT header protocol (SCMI shmem) in
90 * shared memory buffers to carry SCMI protocol synchronisation information.
91 *
92 * PTA_SCMI_CAPS_MSG_HEADER
93 * When set, OP-TEE supports command using MSG header protocol in an OP-TEE
94 * shared memory to carry SCMI protocol synchronisation information and SCMI
95 * message payload.
96 */
97 #define PTA_SCMI_CAPS_NONE 0
98 #define PTA_SCMI_CAPS_SMT_HEADER BIT(0)
99 #define PTA_SCMI_CAPS_MSG_HEADER BIT(1)
100 #define PTA_SCMI_CAPS_MASK (PTA_SCMI_CAPS_SMT_HEADER | \
101 PTA_SCMI_CAPS_MSG_HEADER)
102
103 /**
104 * struct scmi_optee_channel - Description of an OP-TEE SCMI channel
105 *
106 * @channel_id: OP-TEE channel ID used for this transport
107 * @tee_session: TEE session identifier
108 * @caps: OP-TEE SCMI channel capabilities
109 * @rx_len: Response size
110 * @mu: Mutex protection on channel access
111 * @cinfo: SCMI channel information
112 * @shmem: Virtual base address of the shared memory
113 * @req: Shared memory protocol handle for SCMI request and synchronous response
114 * @tee_shm: TEE shared memory handle @req or NULL if using IOMEM shmem
115 * @link: Reference in agent's channel list
116 */
117 struct scmi_optee_channel {
118 u32 channel_id;
119 u32 tee_session;
120 u32 caps;
121 u32 rx_len;
122 struct mutex mu;
123 struct scmi_chan_info *cinfo;
124 union {
125 struct scmi_shared_mem __iomem *shmem;
126 struct scmi_msg_payld *msg;
127 } req;
128 struct tee_shm *tee_shm;
129 struct list_head link;
130 };
131
132 /**
133 * struct scmi_optee_agent - OP-TEE transport private data
134 *
135 * @dev: Device used for communication with TEE
136 * @tee_ctx: TEE context used for communication
137 * @caps: Supported channel capabilities
138 * @mu: Mutex for protection of @channel_list
139 * @channel_list: List of all created channels for the agent
140 */
141 struct scmi_optee_agent {
142 struct device *dev;
143 struct tee_context *tee_ctx;
144 u32 caps;
145 struct mutex mu;
146 struct list_head channel_list;
147 };
148
149 /* There can be only 1 SCMI service in OP-TEE we connect to */
150 static struct scmi_optee_agent *scmi_optee_private;
151
152 /* Forward reference to scmi_optee transport initialization */
153 static int scmi_optee_init(void);
154
155 /* Open a session toward SCMI OP-TEE service with REE_KERNEL identity */
open_session(struct scmi_optee_agent * agent,u32 * tee_session)156 static int open_session(struct scmi_optee_agent *agent, u32 *tee_session)
157 {
158 struct device *dev = agent->dev;
159 struct tee_client_device *scmi_pta = to_tee_client_device(dev);
160 struct tee_ioctl_open_session_arg arg = { };
161 int ret;
162
163 memcpy(arg.uuid, scmi_pta->id.uuid.b, TEE_IOCTL_UUID_LEN);
164 arg.clnt_login = TEE_IOCTL_LOGIN_REE_KERNEL;
165
166 ret = tee_client_open_session(agent->tee_ctx, &arg, NULL);
167 if (ret < 0 || arg.ret) {
168 dev_err(dev, "Can't open tee session: %d / %#x\n", ret, arg.ret);
169 return -EOPNOTSUPP;
170 }
171
172 *tee_session = arg.session;
173
174 return 0;
175 }
176
close_session(struct scmi_optee_agent * agent,u32 tee_session)177 static void close_session(struct scmi_optee_agent *agent, u32 tee_session)
178 {
179 tee_client_close_session(agent->tee_ctx, tee_session);
180 }
181
get_capabilities(struct scmi_optee_agent * agent)182 static int get_capabilities(struct scmi_optee_agent *agent)
183 {
184 struct tee_ioctl_invoke_arg arg = { };
185 struct tee_param param[1] = { };
186 u32 caps;
187 u32 tee_session;
188 int ret;
189
190 ret = open_session(agent, &tee_session);
191 if (ret)
192 return ret;
193
194 arg.func = PTA_SCMI_CMD_CAPABILITIES;
195 arg.session = tee_session;
196 arg.num_params = 1;
197
198 param[0].attr = TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_OUTPUT;
199
200 ret = tee_client_invoke_func(agent->tee_ctx, &arg, param);
201
202 close_session(agent, tee_session);
203
204 if (ret < 0 || arg.ret) {
205 dev_err(agent->dev, "Can't get capabilities: %d / %#x\n", ret, arg.ret);
206 return -EOPNOTSUPP;
207 }
208
209 caps = param[0].u.value.a;
210
211 if (!(caps & (PTA_SCMI_CAPS_SMT_HEADER | PTA_SCMI_CAPS_MSG_HEADER))) {
212 dev_err(agent->dev, "OP-TEE SCMI PTA doesn't support SMT and MSG\n");
213 return -EOPNOTSUPP;
214 }
215
216 agent->caps = caps;
217
218 return 0;
219 }
220
get_channel(struct scmi_optee_channel * channel)221 static int get_channel(struct scmi_optee_channel *channel)
222 {
223 struct device *dev = scmi_optee_private->dev;
224 struct tee_ioctl_invoke_arg arg = { };
225 struct tee_param param[1] = { };
226 unsigned int caps = 0;
227 int ret;
228
229 if (channel->tee_shm)
230 caps = PTA_SCMI_CAPS_MSG_HEADER;
231 else
232 caps = PTA_SCMI_CAPS_SMT_HEADER;
233
234 arg.func = PTA_SCMI_CMD_GET_CHANNEL;
235 arg.session = channel->tee_session;
236 arg.num_params = 1;
237
238 param[0].attr = TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INOUT;
239 param[0].u.value.a = channel->channel_id;
240 param[0].u.value.b = caps;
241
242 ret = tee_client_invoke_func(scmi_optee_private->tee_ctx, &arg, param);
243
244 if (ret || arg.ret) {
245 dev_err(dev, "Can't get channel with caps %#x: %d / %#x\n", caps, ret, arg.ret);
246 return -EOPNOTSUPP;
247 }
248
249 /* From now on use channel identifer provided by OP-TEE SCMI service */
250 channel->channel_id = param[0].u.value.a;
251 channel->caps = caps;
252
253 return 0;
254 }
255
invoke_process_smt_channel(struct scmi_optee_channel * channel)256 static int invoke_process_smt_channel(struct scmi_optee_channel *channel)
257 {
258 struct tee_ioctl_invoke_arg arg = {
259 .func = PTA_SCMI_CMD_PROCESS_SMT_CHANNEL,
260 .session = channel->tee_session,
261 .num_params = 1,
262 };
263 struct tee_param param[1] = { };
264 int ret;
265
266 param[0].attr = TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INPUT;
267 param[0].u.value.a = channel->channel_id;
268
269 ret = tee_client_invoke_func(scmi_optee_private->tee_ctx, &arg, param);
270 if (ret < 0 || arg.ret) {
271 dev_err(scmi_optee_private->dev, "Can't invoke channel %u: %d / %#x\n",
272 channel->channel_id, ret, arg.ret);
273 return -EIO;
274 }
275
276 return 0;
277 }
278
invoke_process_msg_channel(struct scmi_optee_channel * channel,size_t msg_size)279 static int invoke_process_msg_channel(struct scmi_optee_channel *channel, size_t msg_size)
280 {
281 struct tee_ioctl_invoke_arg arg = {
282 .func = PTA_SCMI_CMD_PROCESS_MSG_CHANNEL,
283 .session = channel->tee_session,
284 .num_params = 3,
285 };
286 struct tee_param param[3] = { };
287 int ret;
288
289 param[0].attr = TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INPUT;
290 param[0].u.value.a = channel->channel_id;
291
292 param[1].attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT;
293 param[1].u.memref.shm = channel->tee_shm;
294 param[1].u.memref.size = msg_size;
295
296 param[2].attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_OUTPUT;
297 param[2].u.memref.shm = channel->tee_shm;
298 param[2].u.memref.size = SCMI_OPTEE_MAX_MSG_SIZE;
299
300 ret = tee_client_invoke_func(scmi_optee_private->tee_ctx, &arg, param);
301 if (ret < 0 || arg.ret) {
302 dev_err(scmi_optee_private->dev, "Can't invoke channel %u: %d / %#x\n",
303 channel->channel_id, ret, arg.ret);
304 return -EIO;
305 }
306
307 /* Save response size */
308 channel->rx_len = param[2].u.memref.size;
309
310 return 0;
311 }
312
scmi_optee_link_supplier(struct device * dev)313 static int scmi_optee_link_supplier(struct device *dev)
314 {
315 if (!scmi_optee_private) {
316 if (scmi_optee_init())
317 dev_dbg(dev, "Optee bus not yet ready\n");
318
319 /* Wait for optee bus */
320 return -EPROBE_DEFER;
321 }
322
323 if (!device_link_add(dev, scmi_optee_private->dev, DL_FLAG_AUTOREMOVE_CONSUMER)) {
324 dev_err(dev, "Adding link to supplier optee device failed\n");
325 return -ECANCELED;
326 }
327
328 return 0;
329 }
330
scmi_optee_chan_available(struct device_node * of_node,int idx)331 static bool scmi_optee_chan_available(struct device_node *of_node, int idx)
332 {
333 u32 channel_id;
334
335 return !of_property_read_u32_index(of_node, "linaro,optee-channel-id",
336 idx, &channel_id);
337 }
338
scmi_optee_clear_channel(struct scmi_chan_info * cinfo)339 static void scmi_optee_clear_channel(struct scmi_chan_info *cinfo)
340 {
341 struct scmi_optee_channel *channel = cinfo->transport_info;
342
343 if (!channel->tee_shm)
344 shmem_clear_channel(channel->req.shmem);
345 }
346
setup_dynamic_shmem(struct device * dev,struct scmi_optee_channel * channel)347 static int setup_dynamic_shmem(struct device *dev, struct scmi_optee_channel *channel)
348 {
349 const size_t msg_size = SCMI_OPTEE_MAX_MSG_SIZE;
350 void *shbuf;
351
352 channel->tee_shm = tee_shm_alloc_kernel_buf(scmi_optee_private->tee_ctx, msg_size);
353 if (IS_ERR(channel->tee_shm)) {
354 dev_err(channel->cinfo->dev, "shmem allocation failed\n");
355 return -ENOMEM;
356 }
357
358 shbuf = tee_shm_get_va(channel->tee_shm, 0);
359 memset(shbuf, 0, msg_size);
360 channel->req.msg = shbuf;
361 channel->rx_len = msg_size;
362
363 return 0;
364 }
365
setup_static_shmem(struct device * dev,struct scmi_chan_info * cinfo,struct scmi_optee_channel * channel)366 static int setup_static_shmem(struct device *dev, struct scmi_chan_info *cinfo,
367 struct scmi_optee_channel *channel)
368 {
369 struct device_node *np;
370 resource_size_t size;
371 struct resource res;
372 int ret;
373
374 np = of_parse_phandle(cinfo->dev->of_node, "shmem", 0);
375 if (!of_device_is_compatible(np, "arm,scmi-shmem")) {
376 ret = -ENXIO;
377 goto out;
378 }
379
380 ret = of_address_to_resource(np, 0, &res);
381 if (ret) {
382 dev_err(dev, "Failed to get SCMI Tx shared memory\n");
383 goto out;
384 }
385
386 size = resource_size(&res);
387
388 channel->req.shmem = devm_ioremap(dev, res.start, size);
389 if (!channel->req.shmem) {
390 dev_err(dev, "Failed to ioremap SCMI Tx shared memory\n");
391 ret = -EADDRNOTAVAIL;
392 goto out;
393 }
394
395 ret = 0;
396
397 out:
398 of_node_put(np);
399
400 return ret;
401 }
402
setup_shmem(struct device * dev,struct scmi_chan_info * cinfo,struct scmi_optee_channel * channel)403 static int setup_shmem(struct device *dev, struct scmi_chan_info *cinfo,
404 struct scmi_optee_channel *channel)
405 {
406 if (of_property_present(cinfo->dev->of_node, "shmem"))
407 return setup_static_shmem(dev, cinfo, channel);
408 else
409 return setup_dynamic_shmem(dev, channel);
410 }
411
scmi_optee_chan_setup(struct scmi_chan_info * cinfo,struct device * dev,bool tx)412 static int scmi_optee_chan_setup(struct scmi_chan_info *cinfo, struct device *dev, bool tx)
413 {
414 struct scmi_optee_channel *channel;
415 uint32_t channel_id;
416 int ret;
417
418 if (!tx)
419 return -ENODEV;
420
421 channel = devm_kzalloc(dev, sizeof(*channel), GFP_KERNEL);
422 if (!channel)
423 return -ENOMEM;
424
425 ret = of_property_read_u32_index(cinfo->dev->of_node, "linaro,optee-channel-id",
426 0, &channel_id);
427 if (ret)
428 return ret;
429
430 cinfo->transport_info = channel;
431 channel->cinfo = cinfo;
432 channel->channel_id = channel_id;
433 mutex_init(&channel->mu);
434
435 ret = setup_shmem(dev, cinfo, channel);
436 if (ret)
437 return ret;
438
439 ret = open_session(scmi_optee_private, &channel->tee_session);
440 if (ret)
441 goto err_free_shm;
442
443 ret = get_channel(channel);
444 if (ret)
445 goto err_close_sess;
446
447 /* Enable polling */
448 cinfo->no_completion_irq = true;
449
450 mutex_lock(&scmi_optee_private->mu);
451 list_add(&channel->link, &scmi_optee_private->channel_list);
452 mutex_unlock(&scmi_optee_private->mu);
453
454 return 0;
455
456 err_close_sess:
457 close_session(scmi_optee_private, channel->tee_session);
458 err_free_shm:
459 if (channel->tee_shm)
460 tee_shm_free(channel->tee_shm);
461
462 return ret;
463 }
464
scmi_optee_chan_free(int id,void * p,void * data)465 static int scmi_optee_chan_free(int id, void *p, void *data)
466 {
467 struct scmi_chan_info *cinfo = p;
468 struct scmi_optee_channel *channel = cinfo->transport_info;
469
470 /*
471 * Different protocols might share the same chan info, so a previous
472 * call might have already freed the structure.
473 */
474 if (!channel)
475 return 0;
476
477 mutex_lock(&scmi_optee_private->mu);
478 list_del(&channel->link);
479 mutex_unlock(&scmi_optee_private->mu);
480
481 close_session(scmi_optee_private, channel->tee_session);
482
483 if (channel->tee_shm) {
484 tee_shm_free(channel->tee_shm);
485 channel->tee_shm = NULL;
486 }
487
488 cinfo->transport_info = NULL;
489 channel->cinfo = NULL;
490
491 return 0;
492 }
493
scmi_optee_send_message(struct scmi_chan_info * cinfo,struct scmi_xfer * xfer)494 static int scmi_optee_send_message(struct scmi_chan_info *cinfo,
495 struct scmi_xfer *xfer)
496 {
497 struct scmi_optee_channel *channel = cinfo->transport_info;
498 int ret;
499
500 mutex_lock(&channel->mu);
501
502 if (channel->tee_shm) {
503 msg_tx_prepare(channel->req.msg, xfer);
504 ret = invoke_process_msg_channel(channel, msg_command_size(xfer));
505 } else {
506 shmem_tx_prepare(channel->req.shmem, xfer, cinfo);
507 ret = invoke_process_smt_channel(channel);
508 }
509
510 if (ret)
511 mutex_unlock(&channel->mu);
512
513 return ret;
514 }
515
scmi_optee_fetch_response(struct scmi_chan_info * cinfo,struct scmi_xfer * xfer)516 static void scmi_optee_fetch_response(struct scmi_chan_info *cinfo,
517 struct scmi_xfer *xfer)
518 {
519 struct scmi_optee_channel *channel = cinfo->transport_info;
520
521 if (channel->tee_shm)
522 msg_fetch_response(channel->req.msg, channel->rx_len, xfer);
523 else
524 shmem_fetch_response(channel->req.shmem, xfer);
525 }
526
scmi_optee_mark_txdone(struct scmi_chan_info * cinfo,int ret,struct scmi_xfer * __unused)527 static void scmi_optee_mark_txdone(struct scmi_chan_info *cinfo, int ret,
528 struct scmi_xfer *__unused)
529 {
530 struct scmi_optee_channel *channel = cinfo->transport_info;
531
532 mutex_unlock(&channel->mu);
533 }
534
535 static struct scmi_transport_ops scmi_optee_ops = {
536 .link_supplier = scmi_optee_link_supplier,
537 .chan_available = scmi_optee_chan_available,
538 .chan_setup = scmi_optee_chan_setup,
539 .chan_free = scmi_optee_chan_free,
540 .send_message = scmi_optee_send_message,
541 .mark_txdone = scmi_optee_mark_txdone,
542 .fetch_response = scmi_optee_fetch_response,
543 .clear_channel = scmi_optee_clear_channel,
544 };
545
scmi_optee_ctx_match(struct tee_ioctl_version_data * ver,const void * data)546 static int scmi_optee_ctx_match(struct tee_ioctl_version_data *ver, const void *data)
547 {
548 return ver->impl_id == TEE_IMPL_ID_OPTEE;
549 }
550
scmi_optee_service_probe(struct device * dev)551 static int scmi_optee_service_probe(struct device *dev)
552 {
553 struct scmi_optee_agent *agent;
554 struct tee_context *tee_ctx;
555 int ret;
556
557 /* Only one SCMI OP-TEE device allowed */
558 if (scmi_optee_private) {
559 dev_err(dev, "An SCMI OP-TEE device was already initialized: only one allowed\n");
560 return -EBUSY;
561 }
562
563 tee_ctx = tee_client_open_context(NULL, scmi_optee_ctx_match, NULL, NULL);
564 if (IS_ERR(tee_ctx))
565 return -ENODEV;
566
567 agent = devm_kzalloc(dev, sizeof(*agent), GFP_KERNEL);
568 if (!agent) {
569 ret = -ENOMEM;
570 goto err;
571 }
572
573 agent->dev = dev;
574 agent->tee_ctx = tee_ctx;
575 INIT_LIST_HEAD(&agent->channel_list);
576 mutex_init(&agent->mu);
577
578 ret = get_capabilities(agent);
579 if (ret)
580 goto err;
581
582 /* Ensure agent resources are all visible before scmi_optee_private is */
583 smp_mb();
584 scmi_optee_private = agent;
585
586 return 0;
587
588 err:
589 tee_client_close_context(tee_ctx);
590
591 return ret;
592 }
593
scmi_optee_service_remove(struct device * dev)594 static int scmi_optee_service_remove(struct device *dev)
595 {
596 struct scmi_optee_agent *agent = scmi_optee_private;
597
598 if (!scmi_optee_private)
599 return -EINVAL;
600
601 if (!list_empty(&scmi_optee_private->channel_list))
602 return -EBUSY;
603
604 /* Ensure cleared reference is visible before resources are released */
605 smp_store_mb(scmi_optee_private, NULL);
606
607 tee_client_close_context(agent->tee_ctx);
608
609 return 0;
610 }
611
612 static const struct tee_client_device_id scmi_optee_service_id[] = {
613 {
614 UUID_INIT(0xa8cfe406, 0xd4f5, 0x4a2e,
615 0x9f, 0x8d, 0xa2, 0x5d, 0xc7, 0x54, 0xc0, 0x99)
616 },
617 { }
618 };
619
620 MODULE_DEVICE_TABLE(tee, scmi_optee_service_id);
621
622 static struct tee_client_driver scmi_optee_driver = {
623 .id_table = scmi_optee_service_id,
624 .driver = {
625 .name = "scmi-optee",
626 .bus = &tee_bus_type,
627 .probe = scmi_optee_service_probe,
628 .remove = scmi_optee_service_remove,
629 },
630 };
631
scmi_optee_init(void)632 static int scmi_optee_init(void)
633 {
634 return driver_register(&scmi_optee_driver.driver);
635 }
636
scmi_optee_exit(void)637 static void scmi_optee_exit(void)
638 {
639 if (scmi_optee_private)
640 driver_unregister(&scmi_optee_driver.driver);
641 }
642
643 const struct scmi_desc scmi_optee_desc = {
644 .transport_exit = scmi_optee_exit,
645 .ops = &scmi_optee_ops,
646 .max_rx_timeout_ms = 30,
647 .max_msg = 20,
648 .max_msg_size = SCMI_OPTEE_MAX_MSG_SIZE,
649 .sync_cmds_completed_on_ret = true,
650 };
651