1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (C) 2019-2021 Linaro Ltd.
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>
19 #define SCMI_OPTEE_MAX_MSG_SIZE 128
21 enum scmi_optee_pta_cmd {
23 * PTA_SCMI_CMD_CAPABILITIES - Get channel capabilities
25 * [out] value[0].a: Capability bit mask (enum pta_scmi_caps)
26 * [out] value[0].b: Extended capabilities or 0
28 PTA_SCMI_CMD_CAPABILITIES = 0,
31 * PTA_SCMI_CMD_PROCESS_SMT_CHANNEL - Process SCMI message in SMT buffer
33 * [in] value[0].a: Channel handle
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).
41 PTA_SCMI_CMD_PROCESS_SMT_CHANNEL = 1,
44 * PTA_SCMI_CMD_PROCESS_SMT_CHANNEL_MESSAGE - Process SMT/SCMI message
46 * [in] value[0].a: Channel handle
47 * [in/out] memref[1]: Message/response buffer (SMT and SCMI payload)
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).
55 PTA_SCMI_CMD_PROCESS_SMT_CHANNEL_MESSAGE = 2,
58 * PTA_SCMI_CMD_GET_CHANNEL - Get channel handle
60 * SCMI shm information are 0 if agent expects to use OP-TEE regular SHM
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)
66 PTA_SCMI_CMD_GET_CHANNEL = 3,
69 * PTA_SCMI_CMD_PROCESS_MSG_CHANNEL - Process SCMI message in a MSG
70 * buffer pointed by memref parameters
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)
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
82 PTA_SCMI_CMD_PROCESS_MSG_CHANNEL = 4,
86 * OP-TEE SCMI service capabilities bit flags (32bit)
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.
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
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)
104 * struct scmi_optee_channel - Description of an OP-TEE SCMI channel
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 * @mu: Mutex protection on channel access
110 * @cinfo: SCMI channel information
111 * @shmem: Virtual base address of the shared memory
112 * @req: Shared memory protocol handle for SCMI request and synchronous response
113 * @tee_shm: TEE shared memory handle @req or NULL if using IOMEM shmem
114 * @link: Reference in agent's channel list
116 struct scmi_optee_channel {
122 struct scmi_chan_info *cinfo;
124 struct scmi_shared_mem __iomem *shmem;
125 struct scmi_msg_payld *msg;
127 struct tee_shm *tee_shm;
128 struct list_head link;
132 * struct scmi_optee_agent - OP-TEE transport private data
134 * @dev: Device used for communication with TEE
135 * @tee_ctx: TEE context used for communication
136 * @caps: Supported channel capabilities
137 * @mu: Mutex for protection of @channel_list
138 * @channel_list: List of all created channels for the agent
140 struct scmi_optee_agent {
142 struct tee_context *tee_ctx;
145 struct list_head channel_list;
148 /* There can be only 1 SCMI service in OP-TEE we connect to */
149 static struct scmi_optee_agent *scmi_optee_private;
151 /* Forward reference to scmi_optee transport initialization */
152 static int scmi_optee_init(void);
154 /* Open a session toward SCMI OP-TEE service with REE_KERNEL identity */
155 static int open_session(struct scmi_optee_agent *agent, u32 *tee_session)
157 struct device *dev = agent->dev;
158 struct tee_client_device *scmi_pta = to_tee_client_device(dev);
159 struct tee_ioctl_open_session_arg arg = { };
162 memcpy(arg.uuid, scmi_pta->id.uuid.b, TEE_IOCTL_UUID_LEN);
163 arg.clnt_login = TEE_IOCTL_LOGIN_REE_KERNEL;
165 ret = tee_client_open_session(agent->tee_ctx, &arg, NULL);
166 if (ret < 0 || arg.ret) {
167 dev_err(dev, "Can't open tee session: %d / %#x\n", ret, arg.ret);
171 *tee_session = arg.session;
176 static void close_session(struct scmi_optee_agent *agent, u32 tee_session)
178 tee_client_close_session(agent->tee_ctx, tee_session);
181 static int get_capabilities(struct scmi_optee_agent *agent)
183 struct tee_ioctl_invoke_arg arg = { };
184 struct tee_param param[1] = { };
189 ret = open_session(agent, &tee_session);
193 arg.func = PTA_SCMI_CMD_CAPABILITIES;
194 arg.session = tee_session;
197 param[0].attr = TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_OUTPUT;
199 ret = tee_client_invoke_func(agent->tee_ctx, &arg, param);
201 close_session(agent, tee_session);
203 if (ret < 0 || arg.ret) {
204 dev_err(agent->dev, "Can't get capabilities: %d / %#x\n", ret, arg.ret);
208 caps = param[0].u.value.a;
210 if (!(caps & (PTA_SCMI_CAPS_SMT_HEADER | PTA_SCMI_CAPS_MSG_HEADER))) {
211 dev_err(agent->dev, "OP-TEE SCMI PTA doesn't support SMT and MSG\n");
220 static int get_channel(struct scmi_optee_channel *channel)
222 struct device *dev = scmi_optee_private->dev;
223 struct tee_ioctl_invoke_arg arg = { };
224 struct tee_param param[1] = { };
225 unsigned int caps = 0;
228 if (channel->tee_shm)
229 caps = PTA_SCMI_CAPS_MSG_HEADER;
231 caps = PTA_SCMI_CAPS_SMT_HEADER;
233 arg.func = PTA_SCMI_CMD_GET_CHANNEL;
234 arg.session = channel->tee_session;
237 param[0].attr = TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INOUT;
238 param[0].u.value.a = channel->channel_id;
239 param[0].u.value.b = caps;
241 ret = tee_client_invoke_func(scmi_optee_private->tee_ctx, &arg, param);
243 if (ret || arg.ret) {
244 dev_err(dev, "Can't get channel with caps %#x: %d / %#x\n", caps, ret, arg.ret);
248 /* From now on use channel identifer provided by OP-TEE SCMI service */
249 channel->channel_id = param[0].u.value.a;
250 channel->caps = caps;
255 static int invoke_process_smt_channel(struct scmi_optee_channel *channel)
257 struct tee_ioctl_invoke_arg arg = {
258 .func = PTA_SCMI_CMD_PROCESS_SMT_CHANNEL,
259 .session = channel->tee_session,
262 struct tee_param param[1] = { };
265 param[0].attr = TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INPUT;
266 param[0].u.value.a = channel->channel_id;
268 ret = tee_client_invoke_func(scmi_optee_private->tee_ctx, &arg, param);
269 if (ret < 0 || arg.ret) {
270 dev_err(scmi_optee_private->dev, "Can't invoke channel %u: %d / %#x\n",
271 channel->channel_id, ret, arg.ret);
278 static int invoke_process_msg_channel(struct scmi_optee_channel *channel, size_t msg_size)
280 struct tee_ioctl_invoke_arg arg = {
281 .func = PTA_SCMI_CMD_PROCESS_MSG_CHANNEL,
282 .session = channel->tee_session,
285 struct tee_param param[3] = { };
288 param[0].attr = TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INPUT;
289 param[0].u.value.a = channel->channel_id;
291 param[1].attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT;
292 param[1].u.memref.shm = channel->tee_shm;
293 param[1].u.memref.size = msg_size;
295 param[2].attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_OUTPUT;
296 param[2].u.memref.shm = channel->tee_shm;
297 param[2].u.memref.size = SCMI_OPTEE_MAX_MSG_SIZE;
299 ret = tee_client_invoke_func(scmi_optee_private->tee_ctx, &arg, param);
300 if (ret < 0 || arg.ret) {
301 dev_err(scmi_optee_private->dev, "Can't invoke channel %u: %d / %#x\n",
302 channel->channel_id, ret, arg.ret);
306 /* Save response size */
307 channel->rx_len = param[2].u.memref.size;
312 static int scmi_optee_link_supplier(struct device *dev)
314 if (!scmi_optee_private) {
315 if (scmi_optee_init())
316 dev_dbg(dev, "Optee bus not yet ready\n");
318 /* Wait for optee bus */
319 return -EPROBE_DEFER;
322 if (!device_link_add(dev, scmi_optee_private->dev, DL_FLAG_AUTOREMOVE_CONSUMER)) {
323 dev_err(dev, "Adding link to supplier optee device failed\n");
330 static bool scmi_optee_chan_available(struct device *dev, int idx)
334 return !of_property_read_u32_index(dev->of_node, "linaro,optee-channel-id",
338 static void scmi_optee_clear_channel(struct scmi_chan_info *cinfo)
340 struct scmi_optee_channel *channel = cinfo->transport_info;
342 if (!channel->tee_shm)
343 shmem_clear_channel(channel->req.shmem);
346 static int setup_dynamic_shmem(struct device *dev, struct scmi_optee_channel *channel)
348 const size_t msg_size = SCMI_OPTEE_MAX_MSG_SIZE;
351 channel->tee_shm = tee_shm_alloc_kernel_buf(scmi_optee_private->tee_ctx, msg_size);
352 if (IS_ERR(channel->tee_shm)) {
353 dev_err(channel->cinfo->dev, "shmem allocation failed\n");
357 shbuf = tee_shm_get_va(channel->tee_shm, 0);
358 memset(shbuf, 0, msg_size);
359 channel->req.msg = shbuf;
360 channel->rx_len = msg_size;
365 static int setup_static_shmem(struct device *dev, struct scmi_chan_info *cinfo,
366 struct scmi_optee_channel *channel)
368 struct device_node *np;
369 resource_size_t size;
373 np = of_parse_phandle(cinfo->dev->of_node, "shmem", 0);
374 if (!of_device_is_compatible(np, "arm,scmi-shmem")) {
379 ret = of_address_to_resource(np, 0, &res);
381 dev_err(dev, "Failed to get SCMI Tx shared memory\n");
385 size = resource_size(&res);
387 channel->req.shmem = devm_ioremap(dev, res.start, size);
388 if (!channel->req.shmem) {
389 dev_err(dev, "Failed to ioremap SCMI Tx shared memory\n");
390 ret = -EADDRNOTAVAIL;
402 static int setup_shmem(struct device *dev, struct scmi_chan_info *cinfo,
403 struct scmi_optee_channel *channel)
405 if (of_find_property(cinfo->dev->of_node, "shmem", NULL))
406 return setup_static_shmem(dev, cinfo, channel);
408 return setup_dynamic_shmem(dev, channel);
411 static int scmi_optee_chan_setup(struct scmi_chan_info *cinfo, struct device *dev, bool tx)
413 struct scmi_optee_channel *channel;
420 channel = devm_kzalloc(dev, sizeof(*channel), GFP_KERNEL);
424 ret = of_property_read_u32_index(cinfo->dev->of_node, "linaro,optee-channel-id",
429 cinfo->transport_info = channel;
430 channel->cinfo = cinfo;
431 channel->channel_id = channel_id;
432 mutex_init(&channel->mu);
434 ret = setup_shmem(dev, cinfo, channel);
438 ret = open_session(scmi_optee_private, &channel->tee_session);
442 ret = get_channel(channel);
447 cinfo->no_completion_irq = true;
449 mutex_lock(&scmi_optee_private->mu);
450 list_add(&channel->link, &scmi_optee_private->channel_list);
451 mutex_unlock(&scmi_optee_private->mu);
456 close_session(scmi_optee_private, channel->tee_session);
458 if (channel->tee_shm)
459 tee_shm_free(channel->tee_shm);
464 static int scmi_optee_chan_free(int id, void *p, void *data)
466 struct scmi_chan_info *cinfo = p;
467 struct scmi_optee_channel *channel = cinfo->transport_info;
469 mutex_lock(&scmi_optee_private->mu);
470 list_del(&channel->link);
471 mutex_unlock(&scmi_optee_private->mu);
473 close_session(scmi_optee_private, channel->tee_session);
475 if (channel->tee_shm) {
476 tee_shm_free(channel->tee_shm);
477 channel->tee_shm = NULL;
480 cinfo->transport_info = NULL;
481 channel->cinfo = NULL;
483 scmi_free_channel(cinfo, data, id);
488 static int scmi_optee_send_message(struct scmi_chan_info *cinfo,
489 struct scmi_xfer *xfer)
491 struct scmi_optee_channel *channel = cinfo->transport_info;
494 mutex_lock(&channel->mu);
496 if (channel->tee_shm) {
497 msg_tx_prepare(channel->req.msg, xfer);
498 ret = invoke_process_msg_channel(channel, msg_command_size(xfer));
500 shmem_tx_prepare(channel->req.shmem, xfer);
501 ret = invoke_process_smt_channel(channel);
505 mutex_unlock(&channel->mu);
510 static void scmi_optee_fetch_response(struct scmi_chan_info *cinfo,
511 struct scmi_xfer *xfer)
513 struct scmi_optee_channel *channel = cinfo->transport_info;
515 if (channel->tee_shm)
516 msg_fetch_response(channel->req.msg, channel->rx_len, xfer);
518 shmem_fetch_response(channel->req.shmem, xfer);
521 static void scmi_optee_mark_txdone(struct scmi_chan_info *cinfo, int ret,
522 struct scmi_xfer *__unused)
524 struct scmi_optee_channel *channel = cinfo->transport_info;
526 mutex_unlock(&channel->mu);
529 static struct scmi_transport_ops scmi_optee_ops = {
530 .link_supplier = scmi_optee_link_supplier,
531 .chan_available = scmi_optee_chan_available,
532 .chan_setup = scmi_optee_chan_setup,
533 .chan_free = scmi_optee_chan_free,
534 .send_message = scmi_optee_send_message,
535 .mark_txdone = scmi_optee_mark_txdone,
536 .fetch_response = scmi_optee_fetch_response,
537 .clear_channel = scmi_optee_clear_channel,
540 static int scmi_optee_ctx_match(struct tee_ioctl_version_data *ver, const void *data)
542 return ver->impl_id == TEE_IMPL_ID_OPTEE;
545 static int scmi_optee_service_probe(struct device *dev)
547 struct scmi_optee_agent *agent;
548 struct tee_context *tee_ctx;
551 /* Only one SCMI OP-TEE device allowed */
552 if (scmi_optee_private) {
553 dev_err(dev, "An SCMI OP-TEE device was already initialized: only one allowed\n");
557 tee_ctx = tee_client_open_context(NULL, scmi_optee_ctx_match, NULL, NULL);
561 agent = devm_kzalloc(dev, sizeof(*agent), GFP_KERNEL);
568 agent->tee_ctx = tee_ctx;
569 INIT_LIST_HEAD(&agent->channel_list);
570 mutex_init(&agent->mu);
572 ret = get_capabilities(agent);
576 /* Ensure agent resources are all visible before scmi_optee_private is */
578 scmi_optee_private = agent;
583 tee_client_close_context(tee_ctx);
588 static int scmi_optee_service_remove(struct device *dev)
590 struct scmi_optee_agent *agent = scmi_optee_private;
592 if (!scmi_optee_private)
595 if (!list_empty(&scmi_optee_private->channel_list))
598 /* Ensure cleared reference is visible before resources are released */
599 smp_store_mb(scmi_optee_private, NULL);
601 tee_client_close_context(agent->tee_ctx);
606 static const struct tee_client_device_id scmi_optee_service_id[] = {
608 UUID_INIT(0xa8cfe406, 0xd4f5, 0x4a2e,
609 0x9f, 0x8d, 0xa2, 0x5d, 0xc7, 0x54, 0xc0, 0x99)
614 MODULE_DEVICE_TABLE(tee, scmi_optee_service_id);
616 static struct tee_client_driver scmi_optee_driver = {
617 .id_table = scmi_optee_service_id,
619 .name = "scmi-optee",
620 .bus = &tee_bus_type,
621 .probe = scmi_optee_service_probe,
622 .remove = scmi_optee_service_remove,
626 static int scmi_optee_init(void)
628 return driver_register(&scmi_optee_driver.driver);
631 static void scmi_optee_exit(void)
633 if (scmi_optee_private)
634 driver_unregister(&scmi_optee_driver.driver);
637 const struct scmi_desc scmi_optee_desc = {
638 .transport_exit = scmi_optee_exit,
639 .ops = &scmi_optee_ops,
640 .max_rx_timeout_ms = 30,
642 .max_msg_size = SCMI_OPTEE_MAX_MSG_SIZE,
643 .sync_cmds_completed_on_ret = true,