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
20int 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;
65err:
66	free_pages_exact(shm->kaddr, shm->size);
67	shm->kaddr = NULL;
68	return rc;
69}
70
71void 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
83static void optee_bus_scan(struct work_struct *work)
84{
85	WARN_ON(optee_enumerate_devices(PTA_CMD_GET_DEVICES_SUPP));
86}
87
88int 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
126static 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
148void optee_release(struct tee_context *ctx)
149{
150	optee_release_helper(ctx, optee_close_session_helper);
151}
152
153void 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
162void 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
182static int smc_abi_rc;
183static int ffa_abi_rc;
184
185static 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}
205module_init(optee_core_init);
206
207static 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}
214module_exit(optee_core_exit);
215
216MODULE_AUTHOR("Linaro");
217MODULE_DESCRIPTION("OP-TEE driver");
218MODULE_VERSION("1.0");
219MODULE_LICENSE("GPL v2");
220MODULE_ALIAS("platform:optee");
221