drivers/tee/optee/core.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (c) 2015-2021, Linaro Limited
   4  * Copyright (c) 2016, EPAM Systems
   5  */
   6
   7 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
   8
   9 #include <linux/crash_dump.h>
  10 #include <linux/errno.h>
  11 #include <linux/io.h>
  12 #include <linux/mm.h>
  13 #include <linux/module.h>
  14 #include <linux/slab.h>
  15 #include <linux/string.h>
  16 #include <linux/tee_drv.h>
  17 #include <linux/types.h>
  18 #include "optee_private.h"
  19
  20 int optee_pool_op_alloc_helper(struct tee_shm_pool *pool, struct tee_shm *shm,
  21                                size_t size, size_t align,
  22                                int (*shm_register)(struct tee_context *ctx,
  23                                                    struct tee_shm *shm,
  24                                                    struct page **pages,
  25                                                    size_t num_pages,
  26                                                    unsigned long start))
  27 {
  28         size_t nr_pages = roundup(size, PAGE_SIZE) / PAGE_SIZE;
  29         struct page **pages;
  30         unsigned int i;
  31         int rc = 0;
  32
  33         /*
  34          * Ignore alignment since this is already going to be page aligned
  35          * and there's no need for any larger alignment.
  36          */
  37         shm->kaddr = alloc_pages_exact(nr_pages * PAGE_SIZE,
  38                                        GFP_KERNEL | __GFP_ZERO);
  39         if (!shm->kaddr)
  40                 return -ENOMEM;
  41
  42         shm->paddr = virt_to_phys(shm->kaddr);
  43         shm->size = nr_pages * PAGE_SIZE;
  44
  45         pages = kcalloc(nr_pages, sizeof(*pages), GFP_KERNEL);
  46         if (!pages) {
  47                 rc = -ENOMEM;
  48                 goto err;
  49         }
  50
  51         for (i = 0; i < nr_pages; i++)
  52                 pages[i] = virt_to_page((u8 *)shm->kaddr + i * PAGE_SIZE);
  53
  54         shm->pages = pages;
  55         shm->num_pages = nr_pages;
  56
  57         if (shm_register) {
  58                 rc = shm_register(shm->ctx, shm, pages, nr_pages,
  59                                   (unsigned long)shm->kaddr);
  60                 if (rc)
  61                         goto err;
  62         }
  63
  64         return 0;
  65 err:
  66         free_pages_exact(shm->kaddr, shm->size);
  67         shm->kaddr = NULL;
  68         return rc;
  69 }
  70
  71 void optee_pool_op_free_helper(struct tee_shm_pool *pool, struct tee_shm *shm,
  72                                int (*shm_unregister)(struct tee_context *ctx,
  73                                                      struct tee_shm *shm))
  74 {
  75         if (shm_unregister)
  76                 shm_unregister(shm->ctx, shm);
  77         free_pages_exact(shm->kaddr, shm->size);
  78         shm->kaddr = NULL;
  79         kfree(shm->pages);
  80         shm->pages = NULL;
  81 }
  82
  83 static void optee_bus_scan(struct work_struct *work)
  84 {
  85         WARN_ON(optee_enumerate_devices(PTA_CMD_GET_DEVICES_SUPP));
  86 }
  87
  88 int optee_open(struct tee_context *ctx, bool cap_memref_null)
  89 {
  90         struct optee_context_data *ctxdata;
  91         struct tee_device *teedev = ctx->teedev;
  92         struct optee *optee = tee_get_drvdata(teedev);
  93
  94         ctxdata = kzalloc(sizeof(*ctxdata), GFP_KERNEL);
  95         if (!ctxdata)
  96                 return -ENOMEM;
  97
  98         if (teedev == optee->supp_teedev) {
  99                 bool busy = true;
 100
 101                 mutex_lock(&optee->supp.mutex);
 102                 if (!optee->supp.ctx) {
 103                         busy = false;
 104                         optee->supp.ctx = ctx;
 105                 }
 106                 mutex_unlock(&optee->supp.mutex);
 107                 if (busy) {
 108                         kfree(ctxdata);
 109                         return -EBUSY;
 110                 }
 111
 112                 if (!optee->scan_bus_done) {
 113                         INIT_WORK(&optee->scan_bus_work, optee_bus_scan);
 114                         schedule_work(&optee->scan_bus_work);
 115                         optee->scan_bus_done = true;
 116                 }
 117         }
 118         mutex_init(&ctxdata->mutex);
 119         INIT_LIST_HEAD(&ctxdata->sess_list);
 120
 121         ctx->cap_memref_null = cap_memref_null;
 122         ctx->data = ctxdata;
 123         return 0;
 124 }
 125
 126 static void optee_release_helper(struct tee_context *ctx,
 127                                  int (*close_session)(struct tee_context *ctx,
 128                                                       u32 session,
 129                                                       bool system_thread))
 130 {
 131         struct optee_context_data *ctxdata = ctx->data;
 132         struct optee_session *sess;
 133         struct optee_session *sess_tmp;
 134
 135         if (!ctxdata)
 136                 return;
 137
 138         list_for_each_entry_safe(sess, sess_tmp, &ctxdata->sess_list,
 139                                  list_node) {
 140                 list_del(&sess->list_node);
 141                 close_session(ctx, sess->session_id, sess->use_sys_thread);
 142                 kfree(sess);
 143         }
 144         kfree(ctxdata);
 145         ctx->data = NULL;
 146 }
 147
 148 void optee_release(struct tee_context *ctx)
 149 {
 150         optee_release_helper(ctx, optee_close_session_helper);
 151 }
 152
 153 void optee_release_supp(struct tee_context *ctx)
 154 {
 155         struct optee *optee = tee_get_drvdata(ctx->teedev);
 156
 157         optee_release_helper(ctx, optee_close_session_helper);
 158
 159         optee_supp_release(&optee->supp);
 160 }
 161
 162 void optee_remove_common(struct optee *optee)
 163 {
 164         /* Unregister OP-TEE specific client devices on TEE bus */
 165         optee_unregister_devices();
 166
 167         optee_notif_uninit(optee);
 168         optee_shm_arg_cache_uninit(optee);
 169         teedev_close_context(optee->ctx);
 170         /*
 171          * The two devices have to be unregistered before we can free the
 172          * other resources.
 173          */
 174         tee_device_unregister(optee->supp_teedev);
 175         tee_device_unregister(optee->teedev);
 176
 177         tee_shm_pool_free(optee->pool);
 178         optee_supp_uninit(&optee->supp);
 179         mutex_destroy(&optee->call_queue.mutex);
 180 }
 181
 182 static int smc_abi_rc;
 183 static int ffa_abi_rc;
 184
 185 static int __init optee_core_init(void)
 186 {
 187         /*
 188          * The kernel may have crashed at the same time that all available
 189          * secure world threads were suspended and we cannot reschedule the
 190          * suspended threads without access to the crashed kernel's wait_queue.
 191          * Therefore, we cannot reliably initialize the OP-TEE driver in the
 192          * kdump kernel.
 193          */
 194         if (is_kdump_kernel())
 195                 return -ENODEV;
 196
 197         smc_abi_rc = optee_smc_abi_register();
 198         ffa_abi_rc = optee_ffa_abi_register();
 199
 200         /* If both failed there's no point with this module */
 201         if (smc_abi_rc && ffa_abi_rc)
 202                 return smc_abi_rc;
 203         return 0;
 204 }
 205 module_init(optee_core_init);
 206
 207 static void __exit optee_core_exit(void)
 208 {
 209         if (!smc_abi_rc)
 210                 optee_smc_abi_unregister();
 211         if (!ffa_abi_rc)
 212                 optee_ffa_abi_unregister();
 213 }
 214 module_exit(optee_core_exit);
 215
 216 MODULE_AUTHOR("Linaro");
 217 MODULE_DESCRIPTION("OP-TEE driver");
 218 MODULE_VERSION("1.0");
 219 MODULE_LICENSE("GPL v2");
 220 MODULE_ALIAS("platform:optee");