root/drivers/tee/optee/call.c

DEFINITIONS

1. optee_cq_wait_init
2. optee_cq_wait_for_completion
3. optee_cq_complete_one
4. optee_cq_wait_final
5. find_session
6. optee_do_call_with_arg
7. get_msg_arg
8. optee_open_session
9. optee_close_session
10. optee_invoke_func
11. optee_cancel_req
12. optee_enable_shm_cache
13. optee_disable_shm_cache
14. optee_fill_pages_list
15. get_pages_list_size
16. optee_allocate_pages_list
17. optee_free_pages_list
18. is_normal_memory
19. __check_mem_type
20. check_mem_type
21. optee_shm_register
22. optee_shm_unregister
23. optee_shm_register_supp
24. optee_shm_unregister_supp

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (c) 2015, Linaro Limited
   4  */
   5 #include <linux/arm-smccc.h>
   6 #include <linux/device.h>
   7 #include <linux/err.h>
   8 #include <linux/errno.h>
   9 #include <linux/mm.h>
  10 #include <linux/slab.h>
  11 #include <linux/tee_drv.h>
  12 #include <linux/types.h>
  13 #include <linux/uaccess.h>
  14 #include "optee_private.h"
  15 #include "optee_smc.h"
  16 
  17 struct optee_call_waiter {
  18         struct list_head list_node;
  19         struct completion c;
  20 };
  21 
  22 static void optee_cq_wait_init(struct optee_call_queue *cq,
  23                                struct optee_call_waiter *w)
  24 {
  25         /*
  26          * We're preparing to make a call to secure world. In case we can't
  27          * allocate a thread in secure world we'll end up waiting in
  28          * optee_cq_wait_for_completion().
  29          *
  30          * Normally if there's no contention in secure world the call will
  31          * complete and we can cleanup directly with optee_cq_wait_final().
  32          */
  33         mutex_lock(&cq->mutex);
  34 
  35         /*
  36          * We add ourselves to the queue, but we don't wait. This
  37          * guarantees that we don't lose a completion if secure world
  38          * returns busy and another thread just exited and try to complete
  39          * someone.
  40          */
  41         init_completion(&w->c);
  42         list_add_tail(&w->list_node, &cq->waiters);
  43 
  44         mutex_unlock(&cq->mutex);
  45 }
  46 
  47 static void optee_cq_wait_for_completion(struct optee_call_queue *cq,
  48                                          struct optee_call_waiter *w)
  49 {
  50         wait_for_completion(&w->c);
  51 
  52         mutex_lock(&cq->mutex);
  53 
  54         /* Move to end of list to get out of the way for other waiters */
  55         list_del(&w->list_node);
  56         reinit_completion(&w->c);
  57         list_add_tail(&w->list_node, &cq->waiters);
  58 
  59         mutex_unlock(&cq->mutex);
  60 }
  61 
  62 static void optee_cq_complete_one(struct optee_call_queue *cq)
  63 {
  64         struct optee_call_waiter *w;
  65 
  66         list_for_each_entry(w, &cq->waiters, list_node) {
  67                 if (!completion_done(&w->c)) {
  68                         complete(&w->c);
  69                         break;
  70                 }
  71         }
  72 }
  73 
  74 static void optee_cq_wait_final(struct optee_call_queue *cq,
  75                                 struct optee_call_waiter *w)
  76 {
  77         /*
  78          * We're done with the call to secure world. The thread in secure
  79          * world that was used for this call is now available for some
  80          * other task to use.
  81          */
  82         mutex_lock(&cq->mutex);
  83 
  84         /* Get out of the list */
  85         list_del(&w->list_node);
  86 
  87         /* Wake up one eventual waiting task */
  88         optee_cq_complete_one(cq);
  89 
  90         /*
  91          * If we're completed we've got a completion from another task that
  92          * was just done with its call to secure world. Since yet another
  93          * thread now is available in secure world wake up another eventual
  94          * waiting task.
  95          */
  96         if (completion_done(&w->c))
  97                 optee_cq_complete_one(cq);
  98 
  99         mutex_unlock(&cq->mutex);
 100 }
 101 
 102 /* Requires the filpstate mutex to be held */
 103 static struct optee_session *find_session(struct optee_context_data *ctxdata,
 104                                           u32 session_id)
 105 {
 106         struct optee_session *sess;
 107 
 108         list_for_each_entry(sess, &ctxdata->sess_list, list_node)
 109                 if (sess->session_id == session_id)
 110                         return sess;
 111 
 112         return NULL;
 113 }
 114 
 115 /**
 116  * optee_do_call_with_arg() - Do an SMC to OP-TEE in secure world
 117  * @ctx:        calling context
 118  * @parg:       physical address of message to pass to secure world
 119  *
 120  * Does and SMC to OP-TEE in secure world and handles eventual resulting
 121  * Remote Procedure Calls (RPC) from OP-TEE.
 122  *
 123  * Returns return code from secure world, 0 is OK
 124  */
 125 u32 optee_do_call_with_arg(struct tee_context *ctx, phys_addr_t parg)
 126 {
 127         struct optee *optee = tee_get_drvdata(ctx->teedev);
 128         struct optee_call_waiter w;
 129         struct optee_rpc_param param = { };
 130         struct optee_call_ctx call_ctx = { };
 131         u32 ret;
 132 
 133         param.a0 = OPTEE_SMC_CALL_WITH_ARG;
 134         reg_pair_from_64(&param.a1, &param.a2, parg);
 135         /* Initialize waiter */
 136         optee_cq_wait_init(&optee->call_queue, &w);
 137         while (true) {
 138                 struct arm_smccc_res res;
 139 
 140                 optee->invoke_fn(param.a0, param.a1, param.a2, param.a3,
 141                                  param.a4, param.a5, param.a6, param.a7,
 142                                  &res);
 143 
 144                 if (res.a0 == OPTEE_SMC_RETURN_ETHREAD_LIMIT) {
 145                         /*
 146                          * Out of threads in secure world, wait for a thread
 147                          * become available.
 148                          */
 149                         optee_cq_wait_for_completion(&optee->call_queue, &w);
 150                 } else if (OPTEE_SMC_RETURN_IS_RPC(res.a0)) {
 151                         might_sleep();
 152                         param.a0 = res.a0;
 153                         param.a1 = res.a1;
 154                         param.a2 = res.a2;
 155                         param.a3 = res.a3;
 156                         optee_handle_rpc(ctx, &param, &call_ctx);
 157                 } else {
 158                         ret = res.a0;
 159                         break;
 160                 }
 161         }
 162 
 163         optee_rpc_finalize_call(&call_ctx);
 164         /*
 165          * We're done with our thread in secure world, if there's any
 166          * thread waiters wake up one.
 167          */
 168         optee_cq_wait_final(&optee->call_queue, &w);
 169 
 170         return ret;
 171 }
 172 
 173 static struct tee_shm *get_msg_arg(struct tee_context *ctx, size_t num_params,
 174                                    struct optee_msg_arg **msg_arg,
 175                                    phys_addr_t *msg_parg)
 176 {
 177         int rc;
 178         struct tee_shm *shm;
 179         struct optee_msg_arg *ma;
 180 
 181         shm = tee_shm_alloc(ctx, OPTEE_MSG_GET_ARG_SIZE(num_params),
 182                             TEE_SHM_MAPPED);
 183         if (IS_ERR(shm))
 184                 return shm;
 185 
 186         ma = tee_shm_get_va(shm, 0);
 187         if (IS_ERR(ma)) {
 188                 rc = PTR_ERR(ma);
 189                 goto out;
 190         }
 191 
 192         rc = tee_shm_get_pa(shm, 0, msg_parg);
 193         if (rc)
 194                 goto out;
 195 
 196         memset(ma, 0, OPTEE_MSG_GET_ARG_SIZE(num_params));
 197         ma->num_params = num_params;
 198         *msg_arg = ma;
 199 out:
 200         if (rc) {
 201                 tee_shm_free(shm);
 202                 return ERR_PTR(rc);
 203         }
 204 
 205         return shm;
 206 }
 207 
 208 int optee_open_session(struct tee_context *ctx,
 209                        struct tee_ioctl_open_session_arg *arg,
 210                        struct tee_param *param)
 211 {
 212         struct optee_context_data *ctxdata = ctx->data;
 213         int rc;
 214         struct tee_shm *shm;
 215         struct optee_msg_arg *msg_arg;
 216         phys_addr_t msg_parg;
 217         struct optee_session *sess = NULL;
 218 
 219         /* +2 for the meta parameters added below */
 220         shm = get_msg_arg(ctx, arg->num_params + 2, &msg_arg, &msg_parg);
 221         if (IS_ERR(shm))
 222                 return PTR_ERR(shm);
 223 
 224         msg_arg->cmd = OPTEE_MSG_CMD_OPEN_SESSION;
 225         msg_arg->cancel_id = arg->cancel_id;
 226 
 227         /*
 228          * Initialize and add the meta parameters needed when opening a
 229          * session.
 230          */
 231         msg_arg->params[0].attr = OPTEE_MSG_ATTR_TYPE_VALUE_INPUT |
 232                                   OPTEE_MSG_ATTR_META;
 233         msg_arg->params[1].attr = OPTEE_MSG_ATTR_TYPE_VALUE_INPUT |
 234                                   OPTEE_MSG_ATTR_META;
 235         memcpy(&msg_arg->params[0].u.value, arg->uuid, sizeof(arg->uuid));
 236         memcpy(&msg_arg->params[1].u.value, arg->uuid, sizeof(arg->clnt_uuid));
 237         msg_arg->params[1].u.value.c = arg->clnt_login;
 238 
 239         rc = optee_to_msg_param(msg_arg->params + 2, arg->num_params, param);
 240         if (rc)
 241                 goto out;
 242 
 243         sess = kzalloc(sizeof(*sess), GFP_KERNEL);
 244         if (!sess) {
 245                 rc = -ENOMEM;
 246                 goto out;
 247         }
 248 
 249         if (optee_do_call_with_arg(ctx, msg_parg)) {
 250                 msg_arg->ret = TEEC_ERROR_COMMUNICATION;
 251                 msg_arg->ret_origin = TEEC_ORIGIN_COMMS;
 252         }
 253 
 254         if (msg_arg->ret == TEEC_SUCCESS) {
 255                 /* A new session has been created, add it to the list. */
 256                 sess->session_id = msg_arg->session;
 257                 mutex_lock(&ctxdata->mutex);
 258                 list_add(&sess->list_node, &ctxdata->sess_list);
 259                 mutex_unlock(&ctxdata->mutex);
 260         } else {
 261                 kfree(sess);
 262         }
 263 
 264         if (optee_from_msg_param(param, arg->num_params, msg_arg->params + 2)) {
 265                 arg->ret = TEEC_ERROR_COMMUNICATION;
 266                 arg->ret_origin = TEEC_ORIGIN_COMMS;
 267                 /* Close session again to avoid leakage */
 268                 optee_close_session(ctx, msg_arg->session);
 269         } else {
 270                 arg->session = msg_arg->session;
 271                 arg->ret = msg_arg->ret;
 272                 arg->ret_origin = msg_arg->ret_origin;
 273         }
 274 out:
 275         tee_shm_free(shm);
 276 
 277         return rc;
 278 }
 279 
 280 int optee_close_session(struct tee_context *ctx, u32 session)
 281 {
 282         struct optee_context_data *ctxdata = ctx->data;
 283         struct tee_shm *shm;
 284         struct optee_msg_arg *msg_arg;
 285         phys_addr_t msg_parg;
 286         struct optee_session *sess;
 287 
 288         /* Check that the session is valid and remove it from the list */
 289         mutex_lock(&ctxdata->mutex);
 290         sess = find_session(ctxdata, session);
 291         if (sess)
 292                 list_del(&sess->list_node);
 293         mutex_unlock(&ctxdata->mutex);
 294         if (!sess)
 295                 return -EINVAL;
 296         kfree(sess);
 297 
 298         shm = get_msg_arg(ctx, 0, &msg_arg, &msg_parg);
 299         if (IS_ERR(shm))
 300                 return PTR_ERR(shm);
 301 
 302         msg_arg->cmd = OPTEE_MSG_CMD_CLOSE_SESSION;
 303         msg_arg->session = session;
 304         optee_do_call_with_arg(ctx, msg_parg);
 305 
 306         tee_shm_free(shm);
 307         return 0;
 308 }
 309 
 310 int optee_invoke_func(struct tee_context *ctx, struct tee_ioctl_invoke_arg *arg,
 311                       struct tee_param *param)
 312 {
 313         struct optee_context_data *ctxdata = ctx->data;
 314         struct tee_shm *shm;
 315         struct optee_msg_arg *msg_arg;
 316         phys_addr_t msg_parg;
 317         struct optee_session *sess;
 318         int rc;
 319 
 320         /* Check that the session is valid */
 321         mutex_lock(&ctxdata->mutex);
 322         sess = find_session(ctxdata, arg->session);
 323         mutex_unlock(&ctxdata->mutex);
 324         if (!sess)
 325                 return -EINVAL;
 326 
 327         shm = get_msg_arg(ctx, arg->num_params, &msg_arg, &msg_parg);
 328         if (IS_ERR(shm))
 329                 return PTR_ERR(shm);
 330         msg_arg->cmd = OPTEE_MSG_CMD_INVOKE_COMMAND;
 331         msg_arg->func = arg->func;
 332         msg_arg->session = arg->session;
 333         msg_arg->cancel_id = arg->cancel_id;
 334 
 335         rc = optee_to_msg_param(msg_arg->params, arg->num_params, param);
 336         if (rc)
 337                 goto out;
 338 
 339         if (optee_do_call_with_arg(ctx, msg_parg)) {
 340                 msg_arg->ret = TEEC_ERROR_COMMUNICATION;
 341                 msg_arg->ret_origin = TEEC_ORIGIN_COMMS;
 342         }
 343 
 344         if (optee_from_msg_param(param, arg->num_params, msg_arg->params)) {
 345                 msg_arg->ret = TEEC_ERROR_COMMUNICATION;
 346                 msg_arg->ret_origin = TEEC_ORIGIN_COMMS;
 347         }
 348 
 349         arg->ret = msg_arg->ret;
 350         arg->ret_origin = msg_arg->ret_origin;
 351 out:
 352         tee_shm_free(shm);
 353         return rc;
 354 }
 355 
 356 int optee_cancel_req(struct tee_context *ctx, u32 cancel_id, u32 session)
 357 {
 358         struct optee_context_data *ctxdata = ctx->data;
 359         struct tee_shm *shm;
 360         struct optee_msg_arg *msg_arg;
 361         phys_addr_t msg_parg;
 362         struct optee_session *sess;
 363 
 364         /* Check that the session is valid */
 365         mutex_lock(&ctxdata->mutex);
 366         sess = find_session(ctxdata, session);
 367         mutex_unlock(&ctxdata->mutex);
 368         if (!sess)
 369                 return -EINVAL;
 370 
 371         shm = get_msg_arg(ctx, 0, &msg_arg, &msg_parg);
 372         if (IS_ERR(shm))
 373                 return PTR_ERR(shm);
 374 
 375         msg_arg->cmd = OPTEE_MSG_CMD_CANCEL;
 376         msg_arg->session = session;
 377         msg_arg->cancel_id = cancel_id;
 378         optee_do_call_with_arg(ctx, msg_parg);
 379 
 380         tee_shm_free(shm);
 381         return 0;
 382 }
 383 
 384 /**
 385  * optee_enable_shm_cache() - Enables caching of some shared memory allocation
 386  *                            in OP-TEE
 387  * @optee:      main service struct
 388  */
 389 void optee_enable_shm_cache(struct optee *optee)
 390 {
 391         struct optee_call_waiter w;
 392 
 393         /* We need to retry until secure world isn't busy. */
 394         optee_cq_wait_init(&optee->call_queue, &w);
 395         while (true) {
 396                 struct arm_smccc_res res;
 397 
 398                 optee->invoke_fn(OPTEE_SMC_ENABLE_SHM_CACHE, 0, 0, 0, 0, 0, 0,
 399                                  0, &res);
 400                 if (res.a0 == OPTEE_SMC_RETURN_OK)
 401                         break;
 402                 optee_cq_wait_for_completion(&optee->call_queue, &w);
 403         }
 404         optee_cq_wait_final(&optee->call_queue, &w);
 405 }
 406 
 407 /**
 408  * optee_disable_shm_cache() - Disables caching of some shared memory allocation
 409  *                            in OP-TEE
 410  * @optee:      main service struct
 411  */
 412 void optee_disable_shm_cache(struct optee *optee)
 413 {
 414         struct optee_call_waiter w;
 415 
 416         /* We need to retry until secure world isn't busy. */
 417         optee_cq_wait_init(&optee->call_queue, &w);
 418         while (true) {
 419                 union {
 420                         struct arm_smccc_res smccc;
 421                         struct optee_smc_disable_shm_cache_result result;
 422                 } res;
 423 
 424                 optee->invoke_fn(OPTEE_SMC_DISABLE_SHM_CACHE, 0, 0, 0, 0, 0, 0,
 425                                  0, &res.smccc);
 426                 if (res.result.status == OPTEE_SMC_RETURN_ENOTAVAIL)
 427                         break; /* All shm's freed */
 428                 if (res.result.status == OPTEE_SMC_RETURN_OK) {
 429                         struct tee_shm *shm;
 430 
 431                         shm = reg_pair_to_ptr(res.result.shm_upper32,
 432                                               res.result.shm_lower32);
 433                         tee_shm_free(shm);
 434                 } else {
 435                         optee_cq_wait_for_completion(&optee->call_queue, &w);
 436                 }
 437         }
 438         optee_cq_wait_final(&optee->call_queue, &w);
 439 }
 440 
 441 #define PAGELIST_ENTRIES_PER_PAGE                               \
 442         ((OPTEE_MSG_NONCONTIG_PAGE_SIZE / sizeof(u64)) - 1)
 443 
 444 /**
 445  * optee_fill_pages_list() - write list of user pages to given shared
 446  * buffer.
 447  *
 448  * @dst: page-aligned buffer where list of pages will be stored
 449  * @pages: array of pages that represents shared buffer
 450  * @num_pages: number of entries in @pages
 451  * @page_offset: offset of user buffer from page start
 452  *
 453  * @dst should be big enough to hold list of user page addresses and
 454  *      links to the next pages of buffer
 455  */
 456 void optee_fill_pages_list(u64 *dst, struct page **pages, int num_pages,
 457                            size_t page_offset)
 458 {
 459         int n = 0;
 460         phys_addr_t optee_page;
 461         /*
 462          * Refer to OPTEE_MSG_ATTR_NONCONTIG description in optee_msg.h
 463          * for details.
 464          */
 465         struct {
 466                 u64 pages_list[PAGELIST_ENTRIES_PER_PAGE];
 467                 u64 next_page_data;
 468         } *pages_data;
 469 
 470         /*
 471          * Currently OP-TEE uses 4k page size and it does not looks
 472          * like this will change in the future.  On other hand, there are
 473          * no know ARM architectures with page size < 4k.
 474          * Thus the next built assert looks redundant. But the following
 475          * code heavily relies on this assumption, so it is better be
 476          * safe than sorry.
 477          */
 478         BUILD_BUG_ON(PAGE_SIZE < OPTEE_MSG_NONCONTIG_PAGE_SIZE);
 479 
 480         pages_data = (void *)dst;
 481         /*
 482          * If linux page is bigger than 4k, and user buffer offset is
 483          * larger than 4k/8k/12k/etc this will skip first 4k pages,
 484          * because they bear no value data for OP-TEE.
 485          */
 486         optee_page = page_to_phys(*pages) +
 487                 round_down(page_offset, OPTEE_MSG_NONCONTIG_PAGE_SIZE);
 488 
 489         while (true) {
 490                 pages_data->pages_list[n++] = optee_page;
 491 
 492                 if (n == PAGELIST_ENTRIES_PER_PAGE) {
 493                         pages_data->next_page_data =
 494                                 virt_to_phys(pages_data + 1);
 495                         pages_data++;
 496                         n = 0;
 497                 }
 498 
 499                 optee_page += OPTEE_MSG_NONCONTIG_PAGE_SIZE;
 500                 if (!(optee_page & ~PAGE_MASK)) {
 501                         if (!--num_pages)
 502                                 break;
 503                         pages++;
 504                         optee_page = page_to_phys(*pages);
 505                 }
 506         }
 507 }
 508 
 509 /*
 510  * The final entry in each pagelist page is a pointer to the next
 511  * pagelist page.
 512  */
 513 static size_t get_pages_list_size(size_t num_entries)
 514 {
 515         int pages = DIV_ROUND_UP(num_entries, PAGELIST_ENTRIES_PER_PAGE);
 516 
 517         return pages * OPTEE_MSG_NONCONTIG_PAGE_SIZE;
 518 }
 519 
 520 u64 *optee_allocate_pages_list(size_t num_entries)
 521 {
 522         return alloc_pages_exact(get_pages_list_size(num_entries), GFP_KERNEL);
 523 }
 524 
 525 void optee_free_pages_list(void *list, size_t num_entries)
 526 {
 527         free_pages_exact(list, get_pages_list_size(num_entries));
 528 }
 529 
 530 static bool is_normal_memory(pgprot_t p)
 531 {
 532 #if defined(CONFIG_ARM)
 533         return (pgprot_val(p) & L_PTE_MT_MASK) == L_PTE_MT_WRITEALLOC;
 534 #elif defined(CONFIG_ARM64)
 535         return (pgprot_val(p) & PTE_ATTRINDX_MASK) == PTE_ATTRINDX(MT_NORMAL);
 536 #else
 537 #error "Unuspported architecture"
 538 #endif
 539 }
 540 
 541 static int __check_mem_type(struct vm_area_struct *vma, unsigned long end)
 542 {
 543         while (vma && is_normal_memory(vma->vm_page_prot)) {
 544                 if (vma->vm_end >= end)
 545                         return 0;
 546                 vma = vma->vm_next;
 547         }
 548 
 549         return -EINVAL;
 550 }
 551 
 552 static int check_mem_type(unsigned long start, size_t num_pages)
 553 {
 554         struct mm_struct *mm = current->mm;
 555         int rc;
 556 
 557         /*
 558          * Allow kernel address to register with OP-TEE as kernel
 559          * pages are configured as normal memory only.
 560          */
 561         if (virt_addr_valid(start))
 562                 return 0;
 563 
 564         down_read(&mm->mmap_sem);
 565         rc = __check_mem_type(find_vma(mm, start),
 566                               start + num_pages * PAGE_SIZE);
 567         up_read(&mm->mmap_sem);
 568 
 569         return rc;
 570 }
 571 
 572 int optee_shm_register(struct tee_context *ctx, struct tee_shm *shm,
 573                        struct page **pages, size_t num_pages,
 574                        unsigned long start)
 575 {
 576         struct tee_shm *shm_arg = NULL;
 577         struct optee_msg_arg *msg_arg;
 578         u64 *pages_list;
 579         phys_addr_t msg_parg;
 580         int rc;
 581 
 582         if (!num_pages)
 583                 return -EINVAL;
 584 
 585         rc = check_mem_type(start, num_pages);
 586         if (rc)
 587                 return rc;
 588 
 589         pages_list = optee_allocate_pages_list(num_pages);
 590         if (!pages_list)
 591                 return -ENOMEM;
 592 
 593         shm_arg = get_msg_arg(ctx, 1, &msg_arg, &msg_parg);
 594         if (IS_ERR(shm_arg)) {
 595                 rc = PTR_ERR(shm_arg);
 596                 goto out;
 597         }
 598 
 599         optee_fill_pages_list(pages_list, pages, num_pages,
 600                               tee_shm_get_page_offset(shm));
 601 
 602         msg_arg->cmd = OPTEE_MSG_CMD_REGISTER_SHM;
 603         msg_arg->params->attr = OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT |
 604                                 OPTEE_MSG_ATTR_NONCONTIG;
 605         msg_arg->params->u.tmem.shm_ref = (unsigned long)shm;
 606         msg_arg->params->u.tmem.size = tee_shm_get_size(shm);
 607         /*
 608          * In the least bits of msg_arg->params->u.tmem.buf_ptr we
 609          * store buffer offset from 4k page, as described in OP-TEE ABI.
 610          */
 611         msg_arg->params->u.tmem.buf_ptr = virt_to_phys(pages_list) |
 612           (tee_shm_get_page_offset(shm) & (OPTEE_MSG_NONCONTIG_PAGE_SIZE - 1));
 613 
 614         if (optee_do_call_with_arg(ctx, msg_parg) ||
 615             msg_arg->ret != TEEC_SUCCESS)
 616                 rc = -EINVAL;
 617 
 618         tee_shm_free(shm_arg);
 619 out:
 620         optee_free_pages_list(pages_list, num_pages);
 621         return rc;
 622 }
 623 
 624 int optee_shm_unregister(struct tee_context *ctx, struct tee_shm *shm)
 625 {
 626         struct tee_shm *shm_arg;
 627         struct optee_msg_arg *msg_arg;
 628         phys_addr_t msg_parg;
 629         int rc = 0;
 630 
 631         shm_arg = get_msg_arg(ctx, 1, &msg_arg, &msg_parg);
 632         if (IS_ERR(shm_arg))
 633                 return PTR_ERR(shm_arg);
 634 
 635         msg_arg->cmd = OPTEE_MSG_CMD_UNREGISTER_SHM;
 636 
 637         msg_arg->params[0].attr = OPTEE_MSG_ATTR_TYPE_RMEM_INPUT;
 638         msg_arg->params[0].u.rmem.shm_ref = (unsigned long)shm;
 639 
 640         if (optee_do_call_with_arg(ctx, msg_parg) ||
 641             msg_arg->ret != TEEC_SUCCESS)
 642                 rc = -EINVAL;
 643         tee_shm_free(shm_arg);
 644         return rc;
 645 }
 646 
 647 int optee_shm_register_supp(struct tee_context *ctx, struct tee_shm *shm,
 648                             struct page **pages, size_t num_pages,
 649                             unsigned long start)
 650 {
 651         /*
 652          * We don't want to register supplicant memory in OP-TEE.
 653          * Instead information about it will be passed in RPC code.
 654          */
 655         return check_mem_type(start, num_pages);
 656 }
 657 
 658 int optee_shm_unregister_supp(struct tee_context *ctx, struct tee_shm *shm)
 659 {
 660         return 0;
 661 }