drivers/tee/optee/core.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (c) 2018 Linaro Limited
   4  */
   5
   6 #include <common.h>
   7 #include <dm.h>
   8 #include <log.h>
   9 #include <tee.h>
  10 #include <linux/arm-smccc.h>
  11 #include <linux/err.h>
  12 #include <linux/io.h>
  13
  14 #include "optee_smc.h"
  15 #include "optee_msg.h"
  16 #include "optee_private.h"
  17
  18 #define PAGELIST_ENTRIES_PER_PAGE \
  19         ((OPTEE_MSG_NONCONTIG_PAGE_SIZE / sizeof(u64)) - 1)
  20
  21 typedef void (optee_invoke_fn)(unsigned long, unsigned long, unsigned long,
  22                                unsigned long, unsigned long, unsigned long,
  23                                unsigned long, unsigned long,
  24                                struct arm_smccc_res *);
  25
  26 struct optee_pdata {
  27         optee_invoke_fn *invoke_fn;
  28 };
  29
  30 struct rpc_param {
  31         u32     a0;
  32         u32     a1;
  33         u32     a2;
  34         u32     a3;
  35         u32     a4;
  36         u32     a5;
  37         u32     a6;
  38         u32     a7;
  39 };
  40
  41 /**
  42  * reg_pair_to_ptr() - Make a pointer of 2 32-bit values
  43  * @reg0:       High bits of the pointer
  44  * @reg1:       Low bits of the pointer
  45  *
  46  * Returns the combined result, note that if a pointer is 32-bit wide @reg0
  47  * will be discarded.
  48  */
  49 static void *reg_pair_to_ptr(u32 reg0, u32 reg1)
  50 {
  51         return (void *)(ulong)(((u64)reg0 << 32) | reg1);
  52 }
  53
  54 /**
  55  * reg_pair_from_64() - Split a 64-bit value into two 32-bit values
  56  * @reg0:       High bits of @val
  57  * @reg1:       Low bits of @val
  58  * @val:        The value to split
  59  */
  60 static void reg_pair_from_64(u32 *reg0, u32 *reg1, u64 val)
  61 {
  62         *reg0 = val >> 32;
  63         *reg1 = val;
  64 }
  65
  66 /**
  67  * optee_alloc_and_init_page_list() - Provide page list of memory buffer
  68  * @buf:                Start of buffer
  69  * @len:                Length of buffer
  70  * @phys_buf_ptr        Physical pointer with coded offset to page list
  71  *
  72  * Secure world doesn't share mapping with Normal world (U-Boot in this case)
  73  * so physical pointers are needed when sharing pointers.
  74  *
  75  * Returns a pointer page list on success or NULL on failure
  76  */
  77 void *optee_alloc_and_init_page_list(void *buf, ulong len, u64 *phys_buf_ptr)
  78 {
  79         const unsigned int page_size = OPTEE_MSG_NONCONTIG_PAGE_SIZE;
  80         const phys_addr_t page_mask = page_size - 1;
  81         u8 *buf_base;
  82         unsigned int page_offset;
  83         unsigned int num_pages;
  84         unsigned int list_size;
  85         unsigned int n;
  86         void *page_list;
  87         struct {
  88                 u64 pages_list[PAGELIST_ENTRIES_PER_PAGE];
  89                 u64 next_page_data;
  90         } *pages_data;
  91
  92         /*
  93          * A Memory buffer is described in chunks of 4k. The list of
  94          * physical addresses has to be represented by a physical pointer
  95          * too and a single list has to start at a 4k page and fit into
  96          * that page. In order to be able to describe large memory buffers
  97          * these 4k pages carrying physical addresses are linked together
  98          * in a list. See OPTEE_MSG_ATTR_NONCONTIG in
  99          * drivers/tee/optee/optee_msg.h for more information.
 100          */
 101
 102         page_offset = (ulong)buf & page_mask;
 103         num_pages = roundup(page_offset + len, page_size) / page_size;
 104         list_size = DIV_ROUND_UP(num_pages, PAGELIST_ENTRIES_PER_PAGE) *
 105                     page_size;
 106         page_list = memalign(page_size, list_size);
 107         if (!page_list)
 108                 return NULL;
 109
 110         pages_data = page_list;
 111         buf_base = (u8 *)rounddown((ulong)buf, page_size);
 112         n = 0;
 113         while (num_pages) {
 114                 pages_data->pages_list[n] = virt_to_phys(buf_base);
 115                 n++;
 116                 buf_base += page_size;
 117                 num_pages--;
 118
 119                 if (n == PAGELIST_ENTRIES_PER_PAGE) {
 120                         pages_data->next_page_data =
 121                                 virt_to_phys(pages_data + 1);
 122                         pages_data++;
 123                         n = 0;
 124                 }
 125         }
 126
 127         *phys_buf_ptr = virt_to_phys(page_list) | page_offset;
 128         return page_list;
 129 }
 130
 131 static void optee_get_version(struct udevice *dev,
 132                               struct tee_version_data *vers)
 133 {
 134         struct tee_version_data v = {
 135                 .gen_caps = TEE_GEN_CAP_GP | TEE_GEN_CAP_REG_MEM,
 136         };
 137
 138         *vers = v;
 139 }
 140
 141 static int get_msg_arg(struct udevice *dev, uint num_params,
 142                        struct tee_shm **shmp, struct optee_msg_arg **msg_arg)
 143 {
 144         int rc;
 145         struct optee_msg_arg *ma;
 146
 147         rc = __tee_shm_add(dev, OPTEE_MSG_NONCONTIG_PAGE_SIZE, NULL,
 148                            OPTEE_MSG_GET_ARG_SIZE(num_params), TEE_SHM_ALLOC,
 149                            shmp);
 150         if (rc)
 151                 return rc;
 152
 153         ma = (*shmp)->addr;
 154         memset(ma, 0, OPTEE_MSG_GET_ARG_SIZE(num_params));
 155         ma->num_params = num_params;
 156         *msg_arg = ma;
 157
 158         return 0;
 159 }
 160
 161 static int to_msg_param(struct optee_msg_param *msg_params, uint num_params,
 162                         const struct tee_param *params)
 163 {
 164         uint n;
 165
 166         for (n = 0; n < num_params; n++) {
 167                 const struct tee_param *p = params + n;
 168                 struct optee_msg_param *mp = msg_params + n;
 169
 170                 switch (p->attr) {
 171                 case TEE_PARAM_ATTR_TYPE_NONE:
 172                         mp->attr = OPTEE_MSG_ATTR_TYPE_NONE;
 173                         memset(&mp->u, 0, sizeof(mp->u));
 174                         break;
 175                 case TEE_PARAM_ATTR_TYPE_VALUE_INPUT:
 176                 case TEE_PARAM_ATTR_TYPE_VALUE_OUTPUT:
 177                 case TEE_PARAM_ATTR_TYPE_VALUE_INOUT:
 178                         mp->attr = OPTEE_MSG_ATTR_TYPE_VALUE_INPUT + p->attr -
 179                                    TEE_PARAM_ATTR_TYPE_VALUE_INPUT;
 180                         mp->u.value.a = p->u.value.a;
 181                         mp->u.value.b = p->u.value.b;
 182                         mp->u.value.c = p->u.value.c;
 183                         break;
 184                 case TEE_PARAM_ATTR_TYPE_MEMREF_INPUT:
 185                 case TEE_PARAM_ATTR_TYPE_MEMREF_OUTPUT:
 186                 case TEE_PARAM_ATTR_TYPE_MEMREF_INOUT:
 187                         mp->attr = OPTEE_MSG_ATTR_TYPE_RMEM_INPUT + p->attr -
 188                                    TEE_PARAM_ATTR_TYPE_MEMREF_INPUT;
 189                         mp->u.rmem.shm_ref = (ulong)p->u.memref.shm;
 190                         mp->u.rmem.size = p->u.memref.size;
 191                         mp->u.rmem.offs = p->u.memref.shm_offs;
 192                         break;
 193                 default:
 194                         return -EINVAL;
 195                 }
 196         }
 197         return 0;
 198 }
 199
 200 static int from_msg_param(struct tee_param *params, uint num_params,
 201                           const struct optee_msg_param *msg_params)
 202 {
 203         uint n;
 204         struct tee_shm *shm;
 205
 206         for (n = 0; n < num_params; n++) {
 207                 struct tee_param *p = params + n;
 208                 const struct optee_msg_param *mp = msg_params + n;
 209                 u32 attr = mp->attr & OPTEE_MSG_ATTR_TYPE_MASK;
 210
 211                 switch (attr) {
 212                 case OPTEE_MSG_ATTR_TYPE_NONE:
 213                         p->attr = TEE_PARAM_ATTR_TYPE_NONE;
 214                         memset(&p->u, 0, sizeof(p->u));
 215                         break;
 216                 case OPTEE_MSG_ATTR_TYPE_VALUE_INPUT:
 217                 case OPTEE_MSG_ATTR_TYPE_VALUE_OUTPUT:
 218                 case OPTEE_MSG_ATTR_TYPE_VALUE_INOUT:
 219                         p->attr = TEE_PARAM_ATTR_TYPE_VALUE_INPUT + attr -
 220                                   OPTEE_MSG_ATTR_TYPE_VALUE_INPUT;
 221                         p->u.value.a = mp->u.value.a;
 222                         p->u.value.b = mp->u.value.b;
 223                         p->u.value.c = mp->u.value.c;
 224                         break;
 225                 case OPTEE_MSG_ATTR_TYPE_RMEM_INPUT:
 226                 case OPTEE_MSG_ATTR_TYPE_RMEM_OUTPUT:
 227                 case OPTEE_MSG_ATTR_TYPE_RMEM_INOUT:
 228                         p->attr = TEE_PARAM_ATTR_TYPE_MEMREF_INPUT + attr -
 229                                   OPTEE_MSG_ATTR_TYPE_RMEM_INPUT;
 230                         p->u.memref.size = mp->u.rmem.size;
 231                         shm = (struct tee_shm *)(ulong)mp->u.rmem.shm_ref;
 232
 233                         if (!shm) {
 234                                 p->u.memref.shm_offs = 0;
 235                                 p->u.memref.shm = NULL;
 236                                 break;
 237                         }
 238                         p->u.memref.shm_offs = mp->u.rmem.offs;
 239                         p->u.memref.shm = shm;
 240                         break;
 241                 default:
 242                         return -EINVAL;
 243                 }
 244         }
 245         return 0;
 246 }
 247
 248 static void handle_rpc(struct udevice *dev, struct rpc_param *param,
 249                        void *page_list)
 250 {
 251         struct tee_shm *shm;
 252
 253         switch (OPTEE_SMC_RETURN_GET_RPC_FUNC(param->a0)) {
 254         case OPTEE_SMC_RPC_FUNC_ALLOC:
 255                 if (!__tee_shm_add(dev, OPTEE_MSG_NONCONTIG_PAGE_SIZE, NULL,
 256                                    param->a1, TEE_SHM_ALLOC | TEE_SHM_REGISTER,
 257                                    &shm)) {
 258                         reg_pair_from_64(&param->a1, &param->a2,
 259                                          virt_to_phys(shm->addr));
 260                         /* "cookie" */
 261                         reg_pair_from_64(&param->a4, &param->a5, (ulong)shm);
 262                 } else {
 263                         param->a1 = 0;
 264                         param->a2 = 0;
 265                         param->a4 = 0;
 266                         param->a5 = 0;
 267                 }
 268                 break;
 269         case OPTEE_SMC_RPC_FUNC_FREE:
 270                 shm = reg_pair_to_ptr(param->a1, param->a2);
 271                 tee_shm_free(shm);
 272                 break;
 273         case OPTEE_SMC_RPC_FUNC_FOREIGN_INTR:
 274                 break;
 275         case OPTEE_SMC_RPC_FUNC_CMD:
 276                 shm = reg_pair_to_ptr(param->a1, param->a2);
 277                 optee_suppl_cmd(dev, shm, page_list);
 278                 break;
 279         default:
 280                 break;
 281         }
 282
 283         param->a0 = OPTEE_SMC_CALL_RETURN_FROM_RPC;
 284 }
 285
 286 static u32 call_err_to_res(u32 call_err)
 287 {
 288         switch (call_err) {
 289         case OPTEE_SMC_RETURN_OK:
 290                 return TEE_SUCCESS;
 291         default:
 292                 return TEE_ERROR_BAD_PARAMETERS;
 293         }
 294 }
 295
 296 static u32 do_call_with_arg(struct udevice *dev, struct optee_msg_arg *arg)
 297 {
 298         struct optee_pdata *pdata = dev_get_platdata(dev);
 299         struct rpc_param param = { .a0 = OPTEE_SMC_CALL_WITH_ARG };
 300         void *page_list = NULL;
 301
 302         reg_pair_from_64(&param.a1, &param.a2, virt_to_phys(arg));
 303         while (true) {
 304                 struct arm_smccc_res res;
 305
 306                 pdata->invoke_fn(param.a0, param.a1, param.a2, param.a3,
 307                                  param.a4, param.a5, param.a6, param.a7, &res);
 308
 309                 free(page_list);
 310                 page_list = NULL;
 311
 312                 if (OPTEE_SMC_RETURN_IS_RPC(res.a0)) {
 313                         param.a0 = res.a0;
 314                         param.a1 = res.a1;
 315                         param.a2 = res.a2;
 316                         param.a3 = res.a3;
 317                         handle_rpc(dev, &param, &page_list);
 318                 } else {
 319                         /*
 320                          * In case we've accessed RPMB to serve an RPC
 321                          * request we need to restore the previously
 322                          * selected partition as the caller may expect it
 323                          * to remain unchanged.
 324                          */
 325                         optee_suppl_rpmb_release(dev);
 326                         return call_err_to_res(res.a0);
 327                 }
 328         }
 329 }
 330
 331 static int optee_close_session(struct udevice *dev, u32 session)
 332 {
 333         int rc;
 334         struct tee_shm *shm;
 335         struct optee_msg_arg *msg_arg;
 336
 337         rc = get_msg_arg(dev, 0, &shm, &msg_arg);
 338         if (rc)
 339                 return rc;
 340
 341         msg_arg->cmd = OPTEE_MSG_CMD_CLOSE_SESSION;
 342         msg_arg->session = session;
 343         do_call_with_arg(dev, msg_arg);
 344
 345         tee_shm_free(shm);
 346
 347         return 0;
 348 }
 349
 350 static int optee_open_session(struct udevice *dev,
 351                               struct tee_open_session_arg *arg,
 352                               uint num_params, struct tee_param *params)
 353 {
 354         int rc;
 355         struct tee_shm *shm;
 356         struct optee_msg_arg *msg_arg;
 357
 358         rc = get_msg_arg(dev, num_params + 2, &shm, &msg_arg);
 359         if (rc)
 360                 return rc;
 361
 362         msg_arg->cmd = OPTEE_MSG_CMD_OPEN_SESSION;
 363         /*
 364          * Initialize and add the meta parameters needed when opening a
 365          * session.
 366          */
 367         msg_arg->params[0].attr = OPTEE_MSG_ATTR_TYPE_VALUE_INPUT |
 368                                   OPTEE_MSG_ATTR_META;
 369         msg_arg->params[1].attr = OPTEE_MSG_ATTR_TYPE_VALUE_INPUT |
 370                                   OPTEE_MSG_ATTR_META;
 371         memcpy(&msg_arg->params[0].u.value, arg->uuid, sizeof(arg->uuid));
 372         memcpy(&msg_arg->params[1].u.value, arg->uuid, sizeof(arg->clnt_uuid));
 373         msg_arg->params[1].u.value.c = arg->clnt_login;
 374
 375         rc = to_msg_param(msg_arg->params + 2, num_params, params);
 376         if (rc)
 377                 goto out;
 378
 379         arg->ret = do_call_with_arg(dev, msg_arg);
 380         if (arg->ret) {
 381                 arg->ret_origin = TEE_ORIGIN_COMMS;
 382                 goto out;
 383         }
 384
 385         if (from_msg_param(params, num_params, msg_arg->params + 2)) {
 386                 arg->ret = TEE_ERROR_COMMUNICATION;
 387                 arg->ret_origin = TEE_ORIGIN_COMMS;
 388                 /* Close session again to avoid leakage */
 389                 optee_close_session(dev, msg_arg->session);
 390                 goto out;
 391         }
 392
 393         arg->session = msg_arg->session;
 394         arg->ret = msg_arg->ret;
 395         arg->ret_origin = msg_arg->ret_origin;
 396 out:
 397         tee_shm_free(shm);
 398
 399         return rc;
 400 }
 401
 402 static int optee_invoke_func(struct udevice *dev, struct tee_invoke_arg *arg,
 403                              uint num_params, struct tee_param *params)
 404 {
 405         struct tee_shm *shm;
 406         struct optee_msg_arg *msg_arg;
 407         int rc;
 408
 409         rc = get_msg_arg(dev, num_params, &shm, &msg_arg);
 410         if (rc)
 411                 return rc;
 412         msg_arg->cmd = OPTEE_MSG_CMD_INVOKE_COMMAND;
 413         msg_arg->func = arg->func;
 414         msg_arg->session = arg->session;
 415
 416         rc = to_msg_param(msg_arg->params, num_params, params);
 417         if (rc)
 418                 goto out;
 419
 420         arg->ret = do_call_with_arg(dev, msg_arg);
 421         if (arg->ret) {
 422                 arg->ret_origin = TEE_ORIGIN_COMMS;
 423                 goto out;
 424         }
 425
 426         if (from_msg_param(params, num_params, msg_arg->params)) {
 427                 arg->ret = TEE_ERROR_COMMUNICATION;
 428                 arg->ret_origin = TEE_ORIGIN_COMMS;
 429                 goto out;
 430         }
 431
 432         arg->ret = msg_arg->ret;
 433         arg->ret_origin = msg_arg->ret_origin;
 434 out:
 435         tee_shm_free(shm);
 436         return rc;
 437 }
 438
 439 static int optee_shm_register(struct udevice *dev, struct tee_shm *shm)
 440 {
 441         struct tee_shm *shm_arg;
 442         struct optee_msg_arg *msg_arg;
 443         void *pl;
 444         u64 ph_ptr;
 445         int rc;
 446
 447         rc = get_msg_arg(dev, 1, &shm_arg, &msg_arg);
 448         if (rc)
 449                 return rc;
 450
 451         pl = optee_alloc_and_init_page_list(shm->addr, shm->size, &ph_ptr);
 452         if (!pl) {
 453                 rc = -ENOMEM;
 454                 goto out;
 455         }
 456
 457         msg_arg->cmd = OPTEE_MSG_CMD_REGISTER_SHM;
 458         msg_arg->params->attr = OPTEE_MSG_ATTR_TYPE_TMEM_OUTPUT |
 459                                 OPTEE_MSG_ATTR_NONCONTIG;
 460         msg_arg->params->u.tmem.buf_ptr = ph_ptr;
 461         msg_arg->params->u.tmem.shm_ref = (ulong)shm;
 462         msg_arg->params->u.tmem.size = shm->size;
 463
 464         if (do_call_with_arg(dev, msg_arg) || msg_arg->ret)
 465                 rc = -EINVAL;
 466
 467         free(pl);
 468 out:
 469         tee_shm_free(shm_arg);
 470
 471         return rc;
 472 }
 473
 474 static int optee_shm_unregister(struct udevice *dev, struct tee_shm *shm)
 475 {
 476         struct tee_shm *shm_arg;
 477         struct optee_msg_arg *msg_arg;
 478         int rc;
 479
 480         rc = get_msg_arg(dev, 1, &shm_arg, &msg_arg);
 481         if (rc)
 482                 return rc;
 483
 484         msg_arg->cmd = OPTEE_MSG_CMD_UNREGISTER_SHM;
 485         msg_arg->params[0].attr = OPTEE_MSG_ATTR_TYPE_RMEM_INPUT;
 486         msg_arg->params[0].u.rmem.shm_ref = (ulong)shm;
 487
 488         if (do_call_with_arg(dev, msg_arg) || msg_arg->ret)
 489                 rc = -EINVAL;
 490         tee_shm_free(shm_arg);
 491
 492         return rc;
 493 }
 494
 495 static const struct tee_driver_ops optee_ops = {
 496         .get_version = optee_get_version,
 497         .open_session = optee_open_session,
 498         .close_session = optee_close_session,
 499         .invoke_func = optee_invoke_func,
 500         .shm_register = optee_shm_register,
 501         .shm_unregister = optee_shm_unregister,
 502 };
 503
 504 static bool is_optee_api(optee_invoke_fn *invoke_fn)
 505 {
 506         struct arm_smccc_res res;
 507
 508         invoke_fn(OPTEE_SMC_CALLS_UID, 0, 0, 0, 0, 0, 0, 0, &res);
 509
 510         return res.a0 == OPTEE_MSG_UID_0 && res.a1 == OPTEE_MSG_UID_1 &&
 511                res.a2 == OPTEE_MSG_UID_2 && res.a3 == OPTEE_MSG_UID_3;
 512 }
 513
 514 static void print_os_revision(optee_invoke_fn *invoke_fn)
 515 {
 516         union {
 517                 struct arm_smccc_res smccc;
 518                 struct optee_smc_call_get_os_revision_result result;
 519         } res = {
 520                 .result = {
 521                 .build_id = 0
 522                 }
 523         };
 524
 525         invoke_fn(OPTEE_SMC_CALL_GET_OS_REVISION, 0, 0, 0, 0, 0, 0, 0,
 526                   &res.smccc);
 527
 528         if (res.result.build_id)
 529                 debug("OP-TEE revision %lu.%lu (%08lx)\n", res.result.major,
 530                       res.result.minor, res.result.build_id);
 531         else
 532                 debug("OP-TEE revision %lu.%lu\n", res.result.major,
 533                       res.result.minor);
 534 }
 535
 536 static bool api_revision_is_compatible(optee_invoke_fn *invoke_fn)
 537 {
 538         union {
 539                 struct arm_smccc_res smccc;
 540                 struct optee_smc_calls_revision_result result;
 541         } res;
 542
 543         invoke_fn(OPTEE_SMC_CALLS_REVISION, 0, 0, 0, 0, 0, 0, 0, &res.smccc);
 544
 545         return res.result.major == OPTEE_MSG_REVISION_MAJOR &&
 546                (int)res.result.minor >= OPTEE_MSG_REVISION_MINOR;
 547 }
 548
 549 static bool exchange_capabilities(optee_invoke_fn *invoke_fn, u32 *sec_caps)
 550 {
 551         union {
 552                 struct arm_smccc_res smccc;
 553                 struct optee_smc_exchange_capabilities_result result;
 554         } res;
 555
 556         invoke_fn(OPTEE_SMC_EXCHANGE_CAPABILITIES,
 557                   OPTEE_SMC_NSEC_CAP_UNIPROCESSOR, 0, 0, 0, 0, 0, 0,
 558                   &res.smccc);
 559
 560         if (res.result.status != OPTEE_SMC_RETURN_OK)
 561                 return false;
 562
 563         *sec_caps = res.result.capabilities;
 564
 565         return true;
 566 }
 567
 568 /* Simple wrapper functions to be able to use a function pointer */
 569 static void optee_smccc_smc(unsigned long a0, unsigned long a1,
 570                             unsigned long a2, unsigned long a3,
 571                             unsigned long a4, unsigned long a5,
 572                             unsigned long a6, unsigned long a7,
 573                             struct arm_smccc_res *res)
 574 {
 575         arm_smccc_smc(a0, a1, a2, a3, a4, a5, a6, a7, res);
 576 }
 577
 578 static void optee_smccc_hvc(unsigned long a0, unsigned long a1,
 579                             unsigned long a2, unsigned long a3,
 580                             unsigned long a4, unsigned long a5,
 581                             unsigned long a6, unsigned long a7,
 582                             struct arm_smccc_res *res)
 583 {
 584         arm_smccc_hvc(a0, a1, a2, a3, a4, a5, a6, a7, res);
 585 }
 586
 587 static optee_invoke_fn *get_invoke_func(struct udevice *dev)
 588 {
 589         const char *method;
 590
 591         debug("optee: looking for conduit method in DT.\n");
 592         method = ofnode_get_property(dev->node, "method", NULL);
 593         if (!method) {
 594                 debug("optee: missing \"method\" property\n");
 595                 return ERR_PTR(-ENXIO);
 596         }
 597
 598         if (!strcmp("hvc", method))
 599                 return optee_smccc_hvc;
 600         else if (!strcmp("smc", method))
 601                 return optee_smccc_smc;
 602
 603         debug("optee: invalid \"method\" property: %s\n", method);
 604         return ERR_PTR(-EINVAL);
 605 }
 606
 607 static int optee_ofdata_to_platdata(struct udevice *dev)
 608 {
 609         struct optee_pdata *pdata = dev_get_platdata(dev);
 610
 611         pdata->invoke_fn = get_invoke_func(dev);
 612         if (IS_ERR(pdata->invoke_fn))
 613                 return PTR_ERR(pdata->invoke_fn);
 614
 615         return 0;
 616 }
 617
 618 static int optee_probe(struct udevice *dev)
 619 {
 620         struct optee_pdata *pdata = dev_get_platdata(dev);
 621         u32 sec_caps;
 622
 623         if (!is_optee_api(pdata->invoke_fn)) {
 624                 debug("%s: OP-TEE api uid mismatch\n", __func__);
 625                 return -ENOENT;
 626         }
 627
 628         print_os_revision(pdata->invoke_fn);
 629
 630         if (!api_revision_is_compatible(pdata->invoke_fn)) {
 631                 debug("%s: OP-TEE api revision mismatch\n", __func__);
 632                 return -ENOENT;
 633         }
 634
 635         /*
 636          * OP-TEE can use both shared memory via predefined pool or as
 637          * dynamic shared memory provided by normal world. To keep things
 638          * simple we're only using dynamic shared memory in this driver.
 639          */
 640         if (!exchange_capabilities(pdata->invoke_fn, &sec_caps) ||
 641             !(sec_caps & OPTEE_SMC_SEC_CAP_DYNAMIC_SHM)) {
 642                 debug("%s: OP-TEE capabilities mismatch\n", __func__);
 643                 return -ENOENT;
 644         }
 645
 646         return 0;
 647 }
 648
 649 static const struct udevice_id optee_match[] = {
 650         { .compatible = "linaro,optee-tz" },
 651         {},
 652 };
 653
 654 U_BOOT_DRIVER(optee) = {
 655         .name = "optee",
 656         .id = UCLASS_TEE,
 657         .of_match = optee_match,
 658         .ofdata_to_platdata = optee_ofdata_to_platdata,
 659         .probe = optee_probe,
 660         .ops = &optee_ops,
 661         .platdata_auto_alloc_size = sizeof(struct optee_pdata),
 662         .priv_auto_alloc_size = sizeof(struct optee_private),
 663 };