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