1 /* 2 * Copyright (c) 2015, Linaro Limited 3 * 4 * This software is licensed under the terms of the GNU General Public 5 * License version 2, as published by the Free Software Foundation, and 6 * may be copied, distributed, and modified under those terms. 7 * 8 * This program is distributed in the hope that it will be useful, 9 * but WITHOUT ANY WARRANTY; without even the implied warranty of 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 11 * GNU General Public License for more details. 12 * 13 */ 14 15 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 16 17 #include <linux/arm-smccc.h> 18 #include <linux/errno.h> 19 #include <linux/io.h> 20 #include <linux/module.h> 21 #include <linux/of.h> 22 #include <linux/of_platform.h> 23 #include <linux/platform_device.h> 24 #include <linux/slab.h> 25 #include <linux/string.h> 26 #include <linux/tee_drv.h> 27 #include <linux/types.h> 28 #include <linux/uaccess.h> 29 #include "optee_private.h" 30 #include "optee_smc.h" 31 #include "shm_pool.h" 32 33 #define DRIVER_NAME "optee" 34 35 #define OPTEE_SHM_NUM_PRIV_PAGES CONFIG_OPTEE_SHM_NUM_PRIV_PAGES 36 37 /** 38 * optee_from_msg_param() - convert from OPTEE_MSG parameters to 39 * struct tee_param 40 * @params: subsystem internal parameter representation 41 * @num_params: number of elements in the parameter arrays 42 * @msg_params: OPTEE_MSG parameters 43 * Returns 0 on success or <0 on failure 44 */ 45 int optee_from_msg_param(struct tee_param *params, size_t num_params, 46 const struct optee_msg_param *msg_params) 47 { 48 int rc; 49 size_t n; 50 struct tee_shm *shm; 51 phys_addr_t pa; 52 53 for (n = 0; n < num_params; n++) { 54 struct tee_param *p = params + n; 55 const struct optee_msg_param *mp = msg_params + n; 56 u32 attr = mp->attr & OPTEE_MSG_ATTR_TYPE_MASK; 57 58 switch (attr) { 59 case OPTEE_MSG_ATTR_TYPE_NONE: 60 p->attr = TEE_IOCTL_PARAM_ATTR_TYPE_NONE; 61 memset(&p->u, 0, sizeof(p->u)); 62 break; 63 case OPTEE_MSG_ATTR_TYPE_VALUE_INPUT: 64 case OPTEE_MSG_ATTR_TYPE_VALUE_OUTPUT: 65 case OPTEE_MSG_ATTR_TYPE_VALUE_INOUT: 66 p->attr = TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INPUT + 67 attr - OPTEE_MSG_ATTR_TYPE_VALUE_INPUT; 68 p->u.value.a = mp->u.value.a; 69 p->u.value.b = mp->u.value.b; 70 p->u.value.c = mp->u.value.c; 71 break; 72 case OPTEE_MSG_ATTR_TYPE_TMEM_INPUT: 73 case OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT: 74 case OPTEE_MSG_ATTR_TYPE_TMEM_INOUT: 75 p->attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT + 76 attr - OPTEE_MSG_ATTR_TYPE_TMEM_INPUT; 77 p->u.memref.size = mp->u.tmem.size; 78 shm = (struct tee_shm *)(unsigned long) 79 mp->u.tmem.shm_ref; 80 if (!shm) { 81 p->u.memref.shm_offs = 0; 82 p->u.memref.shm = NULL; 83 break; 84 } 85 rc = tee_shm_get_pa(shm, 0, &pa); 86 if (rc) 87 return rc; 88 p->u.memref.shm_offs = mp->u.tmem.buf_ptr - pa; 89 p->u.memref.shm = shm; 90 91 /* Check that the memref is covered by the shm object */ 92 if (p->u.memref.size) { 93 size_t o = p->u.memref.shm_offs + 94 p->u.memref.size - 1; 95 96 rc = tee_shm_get_pa(shm, o, NULL); 97 if (rc) 98 return rc; 99 } 100 break; 101 case OPTEE_MSG_ATTR_TYPE_RMEM_INPUT: 102 case OPTEE_MSG_ATTR_TYPE_RMEM_OUTPUT: 103 case OPTEE_MSG_ATTR_TYPE_RMEM_INOUT: 104 p->attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT + 105 attr - OPTEE_MSG_ATTR_TYPE_RMEM_INPUT; 106 p->u.memref.size = mp->u.rmem.size; 107 shm = (struct tee_shm *)(unsigned long) 108 mp->u.rmem.shm_ref; 109 110 if (!shm) { 111 p->u.memref.shm_offs = 0; 112 p->u.memref.shm = NULL; 113 break; 114 } 115 p->u.memref.shm_offs = mp->u.rmem.offs; 116 p->u.memref.shm = shm; 117 118 break; 119 120 default: 121 return -EINVAL; 122 } 123 } 124 return 0; 125 } 126 127 static int to_msg_param_tmp_mem(struct optee_msg_param *mp, 128 const struct tee_param *p) 129 { 130 int rc; 131 phys_addr_t pa; 132 133 mp->attr = OPTEE_MSG_ATTR_TYPE_TMEM_INPUT + p->attr - 134 TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT; 135 136 mp->u.tmem.shm_ref = (unsigned long)p->u.memref.shm; 137 mp->u.tmem.size = p->u.memref.size; 138 139 if (!p->u.memref.shm) { 140 mp->u.tmem.buf_ptr = 0; 141 return 0; 142 } 143 144 rc = tee_shm_get_pa(p->u.memref.shm, p->u.memref.shm_offs, &pa); 145 if (rc) 146 return rc; 147 148 mp->u.tmem.buf_ptr = pa; 149 mp->attr |= OPTEE_MSG_ATTR_CACHE_PREDEFINED << 150 OPTEE_MSG_ATTR_CACHE_SHIFT; 151 152 return 0; 153 } 154 155 static int to_msg_param_reg_mem(struct optee_msg_param *mp, 156 const struct tee_param *p) 157 { 158 mp->attr = OPTEE_MSG_ATTR_TYPE_RMEM_INPUT + p->attr - 159 TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT; 160 161 mp->u.rmem.shm_ref = (unsigned long)p->u.memref.shm; 162 mp->u.rmem.size = p->u.memref.size; 163 mp->u.rmem.offs = p->u.memref.shm_offs; 164 return 0; 165 } 166 167 /** 168 * optee_to_msg_param() - convert from struct tee_params to OPTEE_MSG parameters 169 * @msg_params: OPTEE_MSG parameters 170 * @num_params: number of elements in the parameter arrays 171 * @params: subsystem itnernal parameter representation 172 * Returns 0 on success or <0 on failure 173 */ 174 int optee_to_msg_param(struct optee_msg_param *msg_params, size_t num_params, 175 const struct tee_param *params) 176 { 177 int rc; 178 size_t n; 179 180 for (n = 0; n < num_params; n++) { 181 const struct tee_param *p = params + n; 182 struct optee_msg_param *mp = msg_params + n; 183 184 switch (p->attr) { 185 case TEE_IOCTL_PARAM_ATTR_TYPE_NONE: 186 mp->attr = TEE_IOCTL_PARAM_ATTR_TYPE_NONE; 187 memset(&mp->u, 0, sizeof(mp->u)); 188 break; 189 case TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INPUT: 190 case TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_OUTPUT: 191 case TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INOUT: 192 mp->attr = OPTEE_MSG_ATTR_TYPE_VALUE_INPUT + p->attr - 193 TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INPUT; 194 mp->u.value.a = p->u.value.a; 195 mp->u.value.b = p->u.value.b; 196 mp->u.value.c = p->u.value.c; 197 break; 198 case TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT: 199 case TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_OUTPUT: 200 case TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INOUT: 201 if (tee_shm_is_registered(p->u.memref.shm)) 202 rc = to_msg_param_reg_mem(mp, p); 203 else 204 rc = to_msg_param_tmp_mem(mp, p); 205 if (rc) 206 return rc; 207 break; 208 default: 209 return -EINVAL; 210 } 211 } 212 return 0; 213 } 214 215 static void optee_get_version(struct tee_device *teedev, 216 struct tee_ioctl_version_data *vers) 217 { 218 struct tee_ioctl_version_data v = { 219 .impl_id = TEE_IMPL_ID_OPTEE, 220 .impl_caps = TEE_OPTEE_CAP_TZ, 221 .gen_caps = TEE_GEN_CAP_GP, 222 }; 223 struct optee *optee = tee_get_drvdata(teedev); 224 225 if (optee->sec_caps & OPTEE_SMC_SEC_CAP_DYNAMIC_SHM) 226 v.gen_caps |= TEE_GEN_CAP_REG_MEM; 227 *vers = v; 228 } 229 230 static int optee_open(struct tee_context *ctx) 231 { 232 struct optee_context_data *ctxdata; 233 struct tee_device *teedev = ctx->teedev; 234 struct optee *optee = tee_get_drvdata(teedev); 235 236 ctxdata = kzalloc(sizeof(*ctxdata), GFP_KERNEL); 237 if (!ctxdata) 238 return -ENOMEM; 239 240 if (teedev == optee->supp_teedev) { 241 bool busy = true; 242 243 mutex_lock(&optee->supp.mutex); 244 if (!optee->supp.ctx) { 245 busy = false; 246 optee->supp.ctx = ctx; 247 } 248 mutex_unlock(&optee->supp.mutex); 249 if (busy) { 250 kfree(ctxdata); 251 return -EBUSY; 252 } 253 } 254 255 mutex_init(&ctxdata->mutex); 256 INIT_LIST_HEAD(&ctxdata->sess_list); 257 258 ctx->data = ctxdata; 259 return 0; 260 } 261 262 static void optee_release(struct tee_context *ctx) 263 { 264 struct optee_context_data *ctxdata = ctx->data; 265 struct tee_device *teedev = ctx->teedev; 266 struct optee *optee = tee_get_drvdata(teedev); 267 struct tee_shm *shm; 268 struct optee_msg_arg *arg = NULL; 269 phys_addr_t parg; 270 struct optee_session *sess; 271 struct optee_session *sess_tmp; 272 273 if (!ctxdata) 274 return; 275 276 shm = tee_shm_alloc(ctx, sizeof(struct optee_msg_arg), TEE_SHM_MAPPED); 277 if (!IS_ERR(shm)) { 278 arg = tee_shm_get_va(shm, 0); 279 /* 280 * If va2pa fails for some reason, we can't call into 281 * secure world, only free the memory. Secure OS will leak 282 * sessions and finally refuse more sessions, but we will 283 * at least let normal world reclaim its memory. 284 */ 285 if (!IS_ERR(arg)) 286 if (tee_shm_va2pa(shm, arg, &parg)) 287 arg = NULL; /* prevent usage of parg below */ 288 } 289 290 list_for_each_entry_safe(sess, sess_tmp, &ctxdata->sess_list, 291 list_node) { 292 list_del(&sess->list_node); 293 if (!IS_ERR_OR_NULL(arg)) { 294 memset(arg, 0, sizeof(*arg)); 295 arg->cmd = OPTEE_MSG_CMD_CLOSE_SESSION; 296 arg->session = sess->session_id; 297 optee_do_call_with_arg(ctx, parg); 298 } 299 kfree(sess); 300 } 301 kfree(ctxdata); 302 303 if (!IS_ERR(shm)) 304 tee_shm_free(shm); 305 306 ctx->data = NULL; 307 308 if (teedev == optee->supp_teedev) 309 optee_supp_release(&optee->supp); 310 } 311 312 static const struct tee_driver_ops optee_ops = { 313 .get_version = optee_get_version, 314 .open = optee_open, 315 .release = optee_release, 316 .open_session = optee_open_session, 317 .close_session = optee_close_session, 318 .invoke_func = optee_invoke_func, 319 .cancel_req = optee_cancel_req, 320 .shm_register = optee_shm_register, 321 .shm_unregister = optee_shm_unregister, 322 }; 323 324 static const struct tee_desc optee_desc = { 325 .name = DRIVER_NAME "-clnt", 326 .ops = &optee_ops, 327 .owner = THIS_MODULE, 328 }; 329 330 static const struct tee_driver_ops optee_supp_ops = { 331 .get_version = optee_get_version, 332 .open = optee_open, 333 .release = optee_release, 334 .supp_recv = optee_supp_recv, 335 .supp_send = optee_supp_send, 336 .shm_register = optee_shm_register_supp, 337 .shm_unregister = optee_shm_unregister_supp, 338 }; 339 340 static const struct tee_desc optee_supp_desc = { 341 .name = DRIVER_NAME "-supp", 342 .ops = &optee_supp_ops, 343 .owner = THIS_MODULE, 344 .flags = TEE_DESC_PRIVILEGED, 345 }; 346 347 static bool optee_msg_api_uid_is_optee_api(optee_invoke_fn *invoke_fn) 348 { 349 struct arm_smccc_res res; 350 351 invoke_fn(OPTEE_SMC_CALLS_UID, 0, 0, 0, 0, 0, 0, 0, &res); 352 353 if (res.a0 == OPTEE_MSG_UID_0 && res.a1 == OPTEE_MSG_UID_1 && 354 res.a2 == OPTEE_MSG_UID_2 && res.a3 == OPTEE_MSG_UID_3) 355 return true; 356 return false; 357 } 358 359 static void optee_msg_get_os_revision(optee_invoke_fn *invoke_fn) 360 { 361 union { 362 struct arm_smccc_res smccc; 363 struct optee_smc_call_get_os_revision_result result; 364 } res = { 365 .result = { 366 .build_id = 0 367 } 368 }; 369 370 invoke_fn(OPTEE_SMC_CALL_GET_OS_REVISION, 0, 0, 0, 0, 0, 0, 0, 371 &res.smccc); 372 373 if (res.result.build_id) 374 pr_info("revision %lu.%lu (%08lx)", res.result.major, 375 res.result.minor, res.result.build_id); 376 else 377 pr_info("revision %lu.%lu", res.result.major, res.result.minor); 378 } 379 380 static bool optee_msg_api_revision_is_compatible(optee_invoke_fn *invoke_fn) 381 { 382 union { 383 struct arm_smccc_res smccc; 384 struct optee_smc_calls_revision_result result; 385 } res; 386 387 invoke_fn(OPTEE_SMC_CALLS_REVISION, 0, 0, 0, 0, 0, 0, 0, &res.smccc); 388 389 if (res.result.major == OPTEE_MSG_REVISION_MAJOR && 390 (int)res.result.minor >= OPTEE_MSG_REVISION_MINOR) 391 return true; 392 return false; 393 } 394 395 static bool optee_msg_exchange_capabilities(optee_invoke_fn *invoke_fn, 396 u32 *sec_caps) 397 { 398 union { 399 struct arm_smccc_res smccc; 400 struct optee_smc_exchange_capabilities_result result; 401 } res; 402 u32 a1 = 0; 403 404 /* 405 * TODO This isn't enough to tell if it's UP system (from kernel 406 * point of view) or not, is_smp() returns the the information 407 * needed, but can't be called directly from here. 408 */ 409 if (!IS_ENABLED(CONFIG_SMP) || nr_cpu_ids == 1) 410 a1 |= OPTEE_SMC_NSEC_CAP_UNIPROCESSOR; 411 412 invoke_fn(OPTEE_SMC_EXCHANGE_CAPABILITIES, a1, 0, 0, 0, 0, 0, 0, 413 &res.smccc); 414 415 if (res.result.status != OPTEE_SMC_RETURN_OK) 416 return false; 417 418 *sec_caps = res.result.capabilities; 419 return true; 420 } 421 422 static struct tee_shm_pool * 423 optee_config_shm_memremap(optee_invoke_fn *invoke_fn, void **memremaped_shm, 424 u32 sec_caps) 425 { 426 union { 427 struct arm_smccc_res smccc; 428 struct optee_smc_get_shm_config_result result; 429 } res; 430 unsigned long vaddr; 431 phys_addr_t paddr; 432 size_t size; 433 phys_addr_t begin; 434 phys_addr_t end; 435 void *va; 436 struct tee_shm_pool_mgr *priv_mgr; 437 struct tee_shm_pool_mgr *dmabuf_mgr; 438 void *rc; 439 440 invoke_fn(OPTEE_SMC_GET_SHM_CONFIG, 0, 0, 0, 0, 0, 0, 0, &res.smccc); 441 if (res.result.status != OPTEE_SMC_RETURN_OK) { 442 pr_info("shm service not available\n"); 443 return ERR_PTR(-ENOENT); 444 } 445 446 if (res.result.settings != OPTEE_SMC_SHM_CACHED) { 447 pr_err("only normal cached shared memory supported\n"); 448 return ERR_PTR(-EINVAL); 449 } 450 451 begin = roundup(res.result.start, PAGE_SIZE); 452 end = rounddown(res.result.start + res.result.size, PAGE_SIZE); 453 paddr = begin; 454 size = end - begin; 455 456 if (size < 2 * OPTEE_SHM_NUM_PRIV_PAGES * PAGE_SIZE) { 457 pr_err("too small shared memory area\n"); 458 return ERR_PTR(-EINVAL); 459 } 460 461 va = memremap(paddr, size, MEMREMAP_WB); 462 if (!va) { 463 pr_err("shared memory ioremap failed\n"); 464 return ERR_PTR(-EINVAL); 465 } 466 vaddr = (unsigned long)va; 467 468 /* 469 * If OP-TEE can work with unregistered SHM, we will use own pool 470 * for private shm 471 */ 472 if (sec_caps & OPTEE_SMC_SEC_CAP_DYNAMIC_SHM) { 473 rc = optee_shm_pool_alloc_pages(); 474 if (IS_ERR(rc)) 475 goto err_memunmap; 476 priv_mgr = rc; 477 } else { 478 const size_t sz = OPTEE_SHM_NUM_PRIV_PAGES * PAGE_SIZE; 479 480 rc = tee_shm_pool_mgr_alloc_res_mem(vaddr, paddr, sz, 481 3 /* 8 bytes aligned */); 482 if (IS_ERR(rc)) 483 goto err_memunmap; 484 priv_mgr = rc; 485 486 vaddr += sz; 487 paddr += sz; 488 size -= sz; 489 } 490 491 rc = tee_shm_pool_mgr_alloc_res_mem(vaddr, paddr, size, PAGE_SHIFT); 492 if (IS_ERR(rc)) 493 goto err_free_priv_mgr; 494 dmabuf_mgr = rc; 495 496 rc = tee_shm_pool_alloc(priv_mgr, dmabuf_mgr); 497 if (IS_ERR(rc)) 498 goto err_free_dmabuf_mgr; 499 500 *memremaped_shm = va; 501 502 return rc; 503 504 err_free_dmabuf_mgr: 505 tee_shm_pool_mgr_destroy(dmabuf_mgr); 506 err_free_priv_mgr: 507 tee_shm_pool_mgr_destroy(priv_mgr); 508 err_memunmap: 509 memunmap(va); 510 return rc; 511 } 512 513 /* Simple wrapper functions to be able to use a function pointer */ 514 static void optee_smccc_smc(unsigned long a0, unsigned long a1, 515 unsigned long a2, unsigned long a3, 516 unsigned long a4, unsigned long a5, 517 unsigned long a6, unsigned long a7, 518 struct arm_smccc_res *res) 519 { 520 arm_smccc_smc(a0, a1, a2, a3, a4, a5, a6, a7, res); 521 } 522 523 static void optee_smccc_hvc(unsigned long a0, unsigned long a1, 524 unsigned long a2, unsigned long a3, 525 unsigned long a4, unsigned long a5, 526 unsigned long a6, unsigned long a7, 527 struct arm_smccc_res *res) 528 { 529 arm_smccc_hvc(a0, a1, a2, a3, a4, a5, a6, a7, res); 530 } 531 532 static optee_invoke_fn *get_invoke_func(struct device_node *np) 533 { 534 const char *method; 535 536 pr_info("probing for conduit method from DT.\n"); 537 538 if (of_property_read_string(np, "method", &method)) { 539 pr_warn("missing \"method\" property\n"); 540 return ERR_PTR(-ENXIO); 541 } 542 543 if (!strcmp("hvc", method)) 544 return optee_smccc_hvc; 545 else if (!strcmp("smc", method)) 546 return optee_smccc_smc; 547 548 pr_warn("invalid \"method\" property: %s\n", method); 549 return ERR_PTR(-EINVAL); 550 } 551 552 static struct optee *optee_probe(struct device_node *np) 553 { 554 optee_invoke_fn *invoke_fn; 555 struct tee_shm_pool *pool; 556 struct optee *optee = NULL; 557 void *memremaped_shm = NULL; 558 struct tee_device *teedev; 559 u32 sec_caps; 560 int rc; 561 562 invoke_fn = get_invoke_func(np); 563 if (IS_ERR(invoke_fn)) 564 return (void *)invoke_fn; 565 566 if (!optee_msg_api_uid_is_optee_api(invoke_fn)) { 567 pr_warn("api uid mismatch\n"); 568 return ERR_PTR(-EINVAL); 569 } 570 571 optee_msg_get_os_revision(invoke_fn); 572 573 if (!optee_msg_api_revision_is_compatible(invoke_fn)) { 574 pr_warn("api revision mismatch\n"); 575 return ERR_PTR(-EINVAL); 576 } 577 578 if (!optee_msg_exchange_capabilities(invoke_fn, &sec_caps)) { 579 pr_warn("capabilities mismatch\n"); 580 return ERR_PTR(-EINVAL); 581 } 582 583 /* 584 * We have no other option for shared memory, if secure world 585 * doesn't have any reserved memory we can use we can't continue. 586 */ 587 if (!(sec_caps & OPTEE_SMC_SEC_CAP_HAVE_RESERVED_SHM)) 588 return ERR_PTR(-EINVAL); 589 590 pool = optee_config_shm_memremap(invoke_fn, &memremaped_shm, sec_caps); 591 if (IS_ERR(pool)) 592 return (void *)pool; 593 594 optee = kzalloc(sizeof(*optee), GFP_KERNEL); 595 if (!optee) { 596 rc = -ENOMEM; 597 goto err; 598 } 599 600 optee->invoke_fn = invoke_fn; 601 optee->sec_caps = sec_caps; 602 603 teedev = tee_device_alloc(&optee_desc, NULL, pool, optee); 604 if (IS_ERR(teedev)) { 605 rc = PTR_ERR(teedev); 606 goto err; 607 } 608 optee->teedev = teedev; 609 610 teedev = tee_device_alloc(&optee_supp_desc, NULL, pool, optee); 611 if (IS_ERR(teedev)) { 612 rc = PTR_ERR(teedev); 613 goto err; 614 } 615 optee->supp_teedev = teedev; 616 617 rc = tee_device_register(optee->teedev); 618 if (rc) 619 goto err; 620 621 rc = tee_device_register(optee->supp_teedev); 622 if (rc) 623 goto err; 624 625 mutex_init(&optee->call_queue.mutex); 626 INIT_LIST_HEAD(&optee->call_queue.waiters); 627 optee_wait_queue_init(&optee->wait_queue); 628 optee_supp_init(&optee->supp); 629 optee->memremaped_shm = memremaped_shm; 630 optee->pool = pool; 631 632 optee_enable_shm_cache(optee); 633 634 pr_info("initialized driver\n"); 635 return optee; 636 err: 637 if (optee) { 638 /* 639 * tee_device_unregister() is safe to call even if the 640 * devices hasn't been registered with 641 * tee_device_register() yet. 642 */ 643 tee_device_unregister(optee->supp_teedev); 644 tee_device_unregister(optee->teedev); 645 kfree(optee); 646 } 647 if (pool) 648 tee_shm_pool_free(pool); 649 if (memremaped_shm) 650 memunmap(memremaped_shm); 651 return ERR_PTR(rc); 652 } 653 654 static void optee_remove(struct optee *optee) 655 { 656 /* 657 * Ask OP-TEE to free all cached shared memory objects to decrease 658 * reference counters and also avoid wild pointers in secure world 659 * into the old shared memory range. 660 */ 661 optee_disable_shm_cache(optee); 662 663 /* 664 * The two devices has to be unregistered before we can free the 665 * other resources. 666 */ 667 tee_device_unregister(optee->supp_teedev); 668 tee_device_unregister(optee->teedev); 669 670 tee_shm_pool_free(optee->pool); 671 if (optee->memremaped_shm) 672 memunmap(optee->memremaped_shm); 673 optee_wait_queue_exit(&optee->wait_queue); 674 optee_supp_uninit(&optee->supp); 675 mutex_destroy(&optee->call_queue.mutex); 676 677 kfree(optee); 678 } 679 680 static const struct of_device_id optee_match[] = { 681 { .compatible = "linaro,optee-tz" }, 682 {}, 683 }; 684 685 static struct optee *optee_svc; 686 687 static int __init optee_driver_init(void) 688 { 689 struct device_node *fw_np; 690 struct device_node *np; 691 struct optee *optee; 692 693 /* Node is supposed to be below /firmware */ 694 fw_np = of_find_node_by_name(NULL, "firmware"); 695 if (!fw_np) 696 return -ENODEV; 697 698 np = of_find_matching_node(fw_np, optee_match); 699 if (!np || !of_device_is_available(np)) 700 return -ENODEV; 701 702 optee = optee_probe(np); 703 of_node_put(np); 704 705 if (IS_ERR(optee)) 706 return PTR_ERR(optee); 707 708 optee_svc = optee; 709 710 return 0; 711 } 712 module_init(optee_driver_init); 713 714 static void __exit optee_driver_exit(void) 715 { 716 struct optee *optee = optee_svc; 717 718 optee_svc = NULL; 719 if (optee) 720 optee_remove(optee); 721 } 722 module_exit(optee_driver_exit); 723 724 MODULE_AUTHOR("Linaro"); 725 MODULE_DESCRIPTION("OP-TEE driver"); 726 MODULE_SUPPORTED_DEVICE(""); 727 MODULE_VERSION("1.0"); 728 MODULE_LICENSE("GPL v2"); 729