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