tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
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 <linux/workqueue.h>
19#include "optee_private.h"
20
21int optee_pool_op_alloc_helper(struct tee_shm_pool_mgr *poolm,
22 struct tee_shm *shm, size_t size,
23 int (*shm_register)(struct tee_context *ctx,
24 struct tee_shm *shm,
25 struct page **pages,
26 size_t num_pages,
27 unsigned long start))
28{
29 unsigned int order = get_order(size);
30 struct page *page;
31 int rc = 0;
32
33 page = alloc_pages(GFP_KERNEL | __GFP_ZERO, order);
34 if (!page)
35 return -ENOMEM;
36
37 shm->kaddr = page_address(page);
38 shm->paddr = page_to_phys(page);
39 shm->size = PAGE_SIZE << order;
40
41 if (shm_register) {
42 unsigned int nr_pages = 1 << order, i;
43 struct page **pages;
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] = page;
53 page++;
54 }
55
56 shm->flags |= TEE_SHM_REGISTER;
57 rc = shm_register(shm->ctx, shm, pages, nr_pages,
58 (unsigned long)shm->kaddr);
59 kfree(pages);
60 if (rc)
61 goto err;
62 }
63
64 return 0;
65
66err:
67 __free_pages(page, order);
68 return rc;
69}
70
71static void optee_bus_scan(struct work_struct *work)
72{
73 WARN_ON(optee_enumerate_devices(PTA_CMD_GET_DEVICES_SUPP));
74}
75
76int optee_open(struct tee_context *ctx, bool cap_memref_null)
77{
78 struct optee_context_data *ctxdata;
79 struct tee_device *teedev = ctx->teedev;
80 struct optee *optee = tee_get_drvdata(teedev);
81
82 ctxdata = kzalloc(sizeof(*ctxdata), GFP_KERNEL);
83 if (!ctxdata)
84 return -ENOMEM;
85
86 if (teedev == optee->supp_teedev) {
87 bool busy = true;
88
89 mutex_lock(&optee->supp.mutex);
90 if (!optee->supp.ctx) {
91 busy = false;
92 optee->supp.ctx = ctx;
93 }
94 mutex_unlock(&optee->supp.mutex);
95 if (busy) {
96 kfree(ctxdata);
97 return -EBUSY;
98 }
99
100 if (!optee->scan_bus_done) {
101 INIT_WORK(&optee->scan_bus_work, optee_bus_scan);
102 optee->scan_bus_wq = create_workqueue("optee_bus_scan");
103 if (!optee->scan_bus_wq) {
104 kfree(ctxdata);
105 return -ECHILD;
106 }
107 queue_work(optee->scan_bus_wq, &optee->scan_bus_work);
108 optee->scan_bus_done = true;
109 }
110 }
111 mutex_init(&ctxdata->mutex);
112 INIT_LIST_HEAD(&ctxdata->sess_list);
113
114 ctx->cap_memref_null = cap_memref_null;
115 ctx->data = ctxdata;
116 return 0;
117}
118
119static void optee_release_helper(struct tee_context *ctx,
120 int (*close_session)(struct tee_context *ctx,
121 u32 session))
122{
123 struct optee_context_data *ctxdata = ctx->data;
124 struct optee_session *sess;
125 struct optee_session *sess_tmp;
126
127 if (!ctxdata)
128 return;
129
130 list_for_each_entry_safe(sess, sess_tmp, &ctxdata->sess_list,
131 list_node) {
132 list_del(&sess->list_node);
133 close_session(ctx, sess->session_id);
134 kfree(sess);
135 }
136 kfree(ctxdata);
137 ctx->data = NULL;
138}
139
140void optee_release(struct tee_context *ctx)
141{
142 optee_release_helper(ctx, optee_close_session_helper);
143}
144
145void optee_release_supp(struct tee_context *ctx)
146{
147 struct optee *optee = tee_get_drvdata(ctx->teedev);
148
149 optee_release_helper(ctx, optee_close_session_helper);
150 if (optee->scan_bus_wq) {
151 destroy_workqueue(optee->scan_bus_wq);
152 optee->scan_bus_wq = NULL;
153 }
154 optee_supp_release(&optee->supp);
155}
156
157void optee_remove_common(struct optee *optee)
158{
159 /* Unregister OP-TEE specific client devices on TEE bus */
160 optee_unregister_devices();
161
162 /*
163 * The two devices have to be unregistered before we can free the
164 * other resources.
165 */
166 tee_device_unregister(optee->supp_teedev);
167 tee_device_unregister(optee->teedev);
168
169 tee_shm_pool_free(optee->pool);
170 optee_wait_queue_exit(&optee->wait_queue);
171 optee_supp_uninit(&optee->supp);
172 mutex_destroy(&optee->call_queue.mutex);
173}
174
175static int smc_abi_rc;
176static int ffa_abi_rc;
177
178static int optee_core_init(void)
179{
180 /*
181 * The kernel may have crashed at the same time that all available
182 * secure world threads were suspended and we cannot reschedule the
183 * suspended threads without access to the crashed kernel's wait_queue.
184 * Therefore, we cannot reliably initialize the OP-TEE driver in the
185 * kdump kernel.
186 */
187 if (is_kdump_kernel())
188 return -ENODEV;
189
190 smc_abi_rc = optee_smc_abi_register();
191 ffa_abi_rc = optee_ffa_abi_register();
192
193 /* If both failed there's no point with this module */
194 if (smc_abi_rc && ffa_abi_rc)
195 return smc_abi_rc;
196 return 0;
197}
198module_init(optee_core_init);
199
200static void optee_core_exit(void)
201{
202 if (!smc_abi_rc)
203 optee_smc_abi_unregister();
204 if (!ffa_abi_rc)
205 optee_ffa_abi_unregister();
206}
207module_exit(optee_core_exit);
208
209MODULE_AUTHOR("Linaro");
210MODULE_DESCRIPTION("OP-TEE driver");
211MODULE_VERSION("1.0");
212MODULE_LICENSE("GPL v2");
213MODULE_ALIAS("platform:optee");