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 /* 70 * OP-TEE SCMI service capabilities bit flags (32bit) 71 * 72 * PTA_SCMI_CAPS_SMT_HEADER 73 * When set, OP-TEE supports command using SMT header protocol (SCMI shmem) in 74 * shared memory buffers to carry SCMI protocol synchronisation information. 75 */ 76 #define PTA_SCMI_CAPS_NONE 0 77 #define PTA_SCMI_CAPS_SMT_HEADER BIT(0) 78 79 /** 80 * struct scmi_optee_channel - Description of an OP-TEE SCMI channel 81 * 82 * @channel_id: OP-TEE channel ID used for this transport 83 * @tee_session: TEE session identifier 84 * @caps: OP-TEE SCMI channel capabilities 85 * @mu: Mutex protection on channel access 86 * @cinfo: SCMI channel information 87 * @shmem: Virtual base address of the shared memory 88 * @tee_shm: Reference to TEE shared memory or NULL if using static shmem 89 * @link: Reference in agent's channel list 90 */ 91 struct scmi_optee_channel { 92 u32 channel_id; 93 u32 tee_session; 94 u32 caps; 95 struct mutex mu; 96 struct scmi_chan_info *cinfo; 97 struct scmi_shared_mem __iomem *shmem; 98 struct tee_shm *tee_shm; 99 struct list_head link; 100 }; 101 102 /** 103 * struct scmi_optee_agent - OP-TEE transport private data 104 * 105 * @dev: Device used for communication with TEE 106 * @tee_ctx: TEE context used for communication 107 * @caps: Supported channel capabilities 108 * @mu: Mutex for protection of @channel_list 109 * @channel_list: List of all created channels for the agent 110 */ 111 struct scmi_optee_agent { 112 struct device *dev; 113 struct tee_context *tee_ctx; 114 u32 caps; 115 struct mutex mu; 116 struct list_head channel_list; 117 }; 118 119 /* There can be only 1 SCMI service in OP-TEE we connect to */ 120 static struct scmi_optee_agent *scmi_optee_private; 121 122 /* Forward reference to scmi_optee transport initialization */ 123 static int scmi_optee_init(void); 124 125 /* Open a session toward SCMI OP-TEE service with REE_KERNEL identity */ 126 static int open_session(struct scmi_optee_agent *agent, u32 *tee_session) 127 { 128 struct device *dev = agent->dev; 129 struct tee_client_device *scmi_pta = to_tee_client_device(dev); 130 struct tee_ioctl_open_session_arg arg = { }; 131 int ret; 132 133 memcpy(arg.uuid, scmi_pta->id.uuid.b, TEE_IOCTL_UUID_LEN); 134 arg.clnt_login = TEE_IOCTL_LOGIN_REE_KERNEL; 135 136 ret = tee_client_open_session(agent->tee_ctx, &arg, NULL); 137 if (ret < 0 || arg.ret) { 138 dev_err(dev, "Can't open tee session: %d / %#x\n", ret, arg.ret); 139 return -EOPNOTSUPP; 140 } 141 142 *tee_session = arg.session; 143 144 return 0; 145 } 146 147 static void close_session(struct scmi_optee_agent *agent, u32 tee_session) 148 { 149 tee_client_close_session(agent->tee_ctx, tee_session); 150 } 151 152 static int get_capabilities(struct scmi_optee_agent *agent) 153 { 154 struct tee_ioctl_invoke_arg arg = { }; 155 struct tee_param param[1] = { }; 156 u32 caps; 157 u32 tee_session; 158 int ret; 159 160 ret = open_session(agent, &tee_session); 161 if (ret) 162 return ret; 163 164 arg.func = PTA_SCMI_CMD_CAPABILITIES; 165 arg.session = tee_session; 166 arg.num_params = 1; 167 168 param[0].attr = TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_OUTPUT; 169 170 ret = tee_client_invoke_func(agent->tee_ctx, &arg, param); 171 172 close_session(agent, tee_session); 173 174 if (ret < 0 || arg.ret) { 175 dev_err(agent->dev, "Can't get capabilities: %d / %#x\n", ret, arg.ret); 176 return -EOPNOTSUPP; 177 } 178 179 caps = param[0].u.value.a; 180 181 if (!(caps & PTA_SCMI_CAPS_SMT_HEADER)) { 182 dev_err(agent->dev, "OP-TEE SCMI PTA doesn't support SMT\n"); 183 return -EOPNOTSUPP; 184 } 185 186 agent->caps = caps; 187 188 return 0; 189 } 190 191 static int get_channel(struct scmi_optee_channel *channel) 192 { 193 struct device *dev = scmi_optee_private->dev; 194 struct tee_ioctl_invoke_arg arg = { }; 195 struct tee_param param[1] = { }; 196 unsigned int caps = PTA_SCMI_CAPS_SMT_HEADER; 197 int ret; 198 199 arg.func = PTA_SCMI_CMD_GET_CHANNEL; 200 arg.session = channel->tee_session; 201 arg.num_params = 1; 202 203 param[0].attr = TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INOUT; 204 param[0].u.value.a = channel->channel_id; 205 param[0].u.value.b = caps; 206 207 ret = tee_client_invoke_func(scmi_optee_private->tee_ctx, &arg, param); 208 209 if (ret || arg.ret) { 210 dev_err(dev, "Can't get channel with caps %#x: %d / %#x\n", caps, ret, arg.ret); 211 return -EOPNOTSUPP; 212 } 213 214 /* From now on use channel identifer provided by OP-TEE SCMI service */ 215 channel->channel_id = param[0].u.value.a; 216 channel->caps = caps; 217 218 return 0; 219 } 220 221 static int invoke_process_smt_channel(struct scmi_optee_channel *channel) 222 { 223 struct tee_ioctl_invoke_arg arg = { }; 224 struct tee_param param[2] = { }; 225 int ret; 226 227 arg.session = channel->tee_session; 228 param[0].attr = TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INPUT; 229 param[0].u.value.a = channel->channel_id; 230 231 if (channel->tee_shm) { 232 param[1].attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INOUT; 233 param[1].u.memref.shm = channel->tee_shm; 234 param[1].u.memref.size = SCMI_OPTEE_MAX_MSG_SIZE; 235 arg.num_params = 2; 236 arg.func = PTA_SCMI_CMD_PROCESS_SMT_CHANNEL_MESSAGE; 237 } else { 238 arg.num_params = 1; 239 arg.func = PTA_SCMI_CMD_PROCESS_SMT_CHANNEL; 240 } 241 242 ret = tee_client_invoke_func(scmi_optee_private->tee_ctx, &arg, param); 243 if (ret < 0 || arg.ret) { 244 dev_err(scmi_optee_private->dev, "Can't invoke channel %u: %d / %#x\n", 245 channel->channel_id, ret, arg.ret); 246 return -EIO; 247 } 248 249 return 0; 250 } 251 252 static int scmi_optee_link_supplier(struct device *dev) 253 { 254 if (!scmi_optee_private) { 255 if (scmi_optee_init()) 256 dev_dbg(dev, "Optee bus not yet ready\n"); 257 258 /* Wait for optee bus */ 259 return -EPROBE_DEFER; 260 } 261 262 if (!device_link_add(dev, scmi_optee_private->dev, DL_FLAG_AUTOREMOVE_CONSUMER)) { 263 dev_err(dev, "Adding link to supplier optee device failed\n"); 264 return -ECANCELED; 265 } 266 267 return 0; 268 } 269 270 static bool scmi_optee_chan_available(struct device *dev, int idx) 271 { 272 u32 channel_id; 273 274 return !of_property_read_u32_index(dev->of_node, "linaro,optee-channel-id", 275 idx, &channel_id); 276 } 277 278 static void scmi_optee_clear_channel(struct scmi_chan_info *cinfo) 279 { 280 struct scmi_optee_channel *channel = cinfo->transport_info; 281 282 shmem_clear_channel(channel->shmem); 283 } 284 285 static int setup_static_shmem(struct device *dev, struct scmi_chan_info *cinfo, 286 struct scmi_optee_channel *channel) 287 { 288 struct device_node *np; 289 resource_size_t size; 290 struct resource res; 291 int ret; 292 293 np = of_parse_phandle(cinfo->dev->of_node, "shmem", 0); 294 if (!of_device_is_compatible(np, "arm,scmi-shmem")) { 295 ret = -ENXIO; 296 goto out; 297 } 298 299 ret = of_address_to_resource(np, 0, &res); 300 if (ret) { 301 dev_err(dev, "Failed to get SCMI Tx shared memory\n"); 302 goto out; 303 } 304 305 size = resource_size(&res); 306 307 channel->shmem = devm_ioremap(dev, res.start, size); 308 if (!channel->shmem) { 309 dev_err(dev, "Failed to ioremap SCMI Tx shared memory\n"); 310 ret = -EADDRNOTAVAIL; 311 goto out; 312 } 313 314 ret = 0; 315 316 out: 317 of_node_put(np); 318 319 return ret; 320 } 321 322 static int setup_shmem(struct device *dev, struct scmi_chan_info *cinfo, 323 struct scmi_optee_channel *channel) 324 { 325 if (of_find_property(cinfo->dev->of_node, "shmem", NULL)) 326 return setup_static_shmem(dev, cinfo, channel); 327 else 328 return -ENOMEM; 329 } 330 331 static int scmi_optee_chan_setup(struct scmi_chan_info *cinfo, struct device *dev, bool tx) 332 { 333 struct scmi_optee_channel *channel; 334 uint32_t channel_id; 335 int ret; 336 337 if (!tx) 338 return -ENODEV; 339 340 channel = devm_kzalloc(dev, sizeof(*channel), GFP_KERNEL); 341 if (!channel) 342 return -ENOMEM; 343 344 ret = of_property_read_u32_index(cinfo->dev->of_node, "linaro,optee-channel-id", 345 0, &channel_id); 346 if (ret) 347 return ret; 348 349 cinfo->transport_info = channel; 350 channel->cinfo = cinfo; 351 channel->channel_id = channel_id; 352 mutex_init(&channel->mu); 353 354 ret = setup_shmem(dev, cinfo, channel); 355 if (ret) 356 return ret; 357 358 ret = open_session(scmi_optee_private, &channel->tee_session); 359 if (ret) 360 goto err_free_shm; 361 362 ret = get_channel(channel); 363 if (ret) 364 goto err_close_sess; 365 366 /* Enable polling */ 367 cinfo->no_completion_irq = true; 368 369 mutex_lock(&scmi_optee_private->mu); 370 list_add(&channel->link, &scmi_optee_private->channel_list); 371 mutex_unlock(&scmi_optee_private->mu); 372 373 return 0; 374 375 err_close_sess: 376 close_session(scmi_optee_private, channel->tee_session); 377 err_free_shm: 378 if (channel->tee_shm) 379 tee_shm_free(channel->tee_shm); 380 381 return ret; 382 } 383 384 static int scmi_optee_chan_free(int id, void *p, void *data) 385 { 386 struct scmi_chan_info *cinfo = p; 387 struct scmi_optee_channel *channel = cinfo->transport_info; 388 389 mutex_lock(&scmi_optee_private->mu); 390 list_del(&channel->link); 391 mutex_unlock(&scmi_optee_private->mu); 392 393 close_session(scmi_optee_private, channel->tee_session); 394 395 if (channel->tee_shm) { 396 tee_shm_free(channel->tee_shm); 397 channel->tee_shm = NULL; 398 } 399 400 cinfo->transport_info = NULL; 401 channel->cinfo = NULL; 402 403 scmi_free_channel(cinfo, data, id); 404 405 return 0; 406 } 407 408 static struct scmi_shared_mem *get_channel_shm(struct scmi_optee_channel *chan, 409 struct scmi_xfer *xfer) 410 { 411 if (!chan) 412 return NULL; 413 414 return chan->shmem; 415 } 416 417 418 static int scmi_optee_send_message(struct scmi_chan_info *cinfo, 419 struct scmi_xfer *xfer) 420 { 421 struct scmi_optee_channel *channel = cinfo->transport_info; 422 struct scmi_shared_mem *shmem = get_channel_shm(channel, xfer); 423 int ret; 424 425 mutex_lock(&channel->mu); 426 shmem_tx_prepare(shmem, xfer); 427 428 ret = invoke_process_smt_channel(channel); 429 if (ret) 430 mutex_unlock(&channel->mu); 431 432 return ret; 433 } 434 435 static void scmi_optee_fetch_response(struct scmi_chan_info *cinfo, 436 struct scmi_xfer *xfer) 437 { 438 struct scmi_optee_channel *channel = cinfo->transport_info; 439 struct scmi_shared_mem *shmem = get_channel_shm(channel, xfer); 440 441 shmem_fetch_response(shmem, xfer); 442 } 443 444 static void scmi_optee_mark_txdone(struct scmi_chan_info *cinfo, int ret, 445 struct scmi_xfer *__unused) 446 { 447 struct scmi_optee_channel *channel = cinfo->transport_info; 448 449 mutex_unlock(&channel->mu); 450 } 451 452 static struct scmi_transport_ops scmi_optee_ops = { 453 .link_supplier = scmi_optee_link_supplier, 454 .chan_available = scmi_optee_chan_available, 455 .chan_setup = scmi_optee_chan_setup, 456 .chan_free = scmi_optee_chan_free, 457 .send_message = scmi_optee_send_message, 458 .mark_txdone = scmi_optee_mark_txdone, 459 .fetch_response = scmi_optee_fetch_response, 460 .clear_channel = scmi_optee_clear_channel, 461 }; 462 463 static int scmi_optee_ctx_match(struct tee_ioctl_version_data *ver, const void *data) 464 { 465 return ver->impl_id == TEE_IMPL_ID_OPTEE; 466 } 467 468 static int scmi_optee_service_probe(struct device *dev) 469 { 470 struct scmi_optee_agent *agent; 471 struct tee_context *tee_ctx; 472 int ret; 473 474 /* Only one SCMI OP-TEE device allowed */ 475 if (scmi_optee_private) { 476 dev_err(dev, "An SCMI OP-TEE device was already initialized: only one allowed\n"); 477 return -EBUSY; 478 } 479 480 tee_ctx = tee_client_open_context(NULL, scmi_optee_ctx_match, NULL, NULL); 481 if (IS_ERR(tee_ctx)) 482 return -ENODEV; 483 484 agent = devm_kzalloc(dev, sizeof(*agent), GFP_KERNEL); 485 if (!agent) { 486 ret = -ENOMEM; 487 goto err; 488 } 489 490 agent->dev = dev; 491 agent->tee_ctx = tee_ctx; 492 INIT_LIST_HEAD(&agent->channel_list); 493 mutex_init(&agent->mu); 494 495 ret = get_capabilities(agent); 496 if (ret) 497 goto err; 498 499 /* Ensure agent resources are all visible before scmi_optee_private is */ 500 smp_mb(); 501 scmi_optee_private = agent; 502 503 return 0; 504 505 err: 506 tee_client_close_context(tee_ctx); 507 508 return ret; 509 } 510 511 static int scmi_optee_service_remove(struct device *dev) 512 { 513 struct scmi_optee_agent *agent = scmi_optee_private; 514 515 if (!scmi_optee_private) 516 return -EINVAL; 517 518 if (!list_empty(&scmi_optee_private->channel_list)) 519 return -EBUSY; 520 521 /* Ensure cleared reference is visible before resources are released */ 522 smp_store_mb(scmi_optee_private, NULL); 523 524 tee_client_close_context(agent->tee_ctx); 525 526 return 0; 527 } 528 529 static const struct tee_client_device_id scmi_optee_service_id[] = { 530 { 531 UUID_INIT(0xa8cfe406, 0xd4f5, 0x4a2e, 532 0x9f, 0x8d, 0xa2, 0x5d, 0xc7, 0x54, 0xc0, 0x99) 533 }, 534 { } 535 }; 536 537 MODULE_DEVICE_TABLE(tee, scmi_optee_service_id); 538 539 static struct tee_client_driver scmi_optee_driver = { 540 .id_table = scmi_optee_service_id, 541 .driver = { 542 .name = "scmi-optee", 543 .bus = &tee_bus_type, 544 .probe = scmi_optee_service_probe, 545 .remove = scmi_optee_service_remove, 546 }, 547 }; 548 549 static int scmi_optee_init(void) 550 { 551 return driver_register(&scmi_optee_driver.driver); 552 } 553 554 static void scmi_optee_exit(void) 555 { 556 if (scmi_optee_private) 557 driver_unregister(&scmi_optee_driver.driver); 558 } 559 560 const struct scmi_desc scmi_optee_desc = { 561 .transport_exit = scmi_optee_exit, 562 .ops = &scmi_optee_ops, 563 .max_rx_timeout_ms = 30, 564 .max_msg = 20, 565 .max_msg_size = SCMI_OPTEE_MAX_MSG_SIZE, 566 .sync_cmds_completed_on_ret = true, 567 }; 568