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/module.h>
 13#include <linux/rpmb.h>
 14#include <linux/slab.h>
 15#include <linux/string.h>
 16#include <linux/tee_core.h>
 17#include <linux/types.h>
 18#include "optee_private.h"
 19
 20struct blocking_notifier_head optee_rpmb_intf_added =
 21	BLOCKING_NOTIFIER_INIT(optee_rpmb_intf_added);
 22
 23static int rpmb_add_dev(struct device *dev)
 24{
 25	blocking_notifier_call_chain(&optee_rpmb_intf_added, 0,
 26				     to_rpmb_dev(dev));
 27
 28	return 0;
 29}
 30
 31static struct class_interface rpmb_class_intf = {
 32	.add_dev = rpmb_add_dev,
 33};
 34
 35void optee_bus_scan_rpmb(struct work_struct *work)
 36{
 37	struct optee *optee = container_of(work, struct optee,
 38					   rpmb_scan_bus_work);
 39	int ret;
 40
 41	if (!optee->rpmb_scan_bus_done) {
 42		ret = optee_enumerate_devices(PTA_CMD_GET_DEVICES_RPMB);
 43		optee->rpmb_scan_bus_done = !ret;
 44		if (ret && ret != -ENODEV)
 45			pr_info("Scanning for RPMB device: ret %d\n", ret);
 46	}
 47}
 48
 49int optee_rpmb_intf_rdev(struct notifier_block *intf, unsigned long action,
 50			 void *data)
 51{
 52	struct optee *optee = container_of(intf, struct optee, rpmb_intf);
 53
 54	schedule_work(&optee->rpmb_scan_bus_work);
 55
 56	return 0;
 57}
 58
 59int optee_set_dma_mask(struct optee *optee, u_int pa_width)
 60{
 61	u64 mask = DMA_BIT_MASK(min(64, pa_width));
 62
 63	return dma_coerce_mask_and_coherent(&optee->teedev->dev, mask);
 64}
 65
 66static void optee_bus_scan(struct work_struct *work)
 67{
 68	WARN_ON(optee_enumerate_devices(PTA_CMD_GET_DEVICES_SUPP));
 69}
 70
 71static ssize_t rpmb_routing_model_show(struct device *dev,
 72				       struct device_attribute *attr, char *buf)
 73{
 74	struct optee *optee = dev_get_drvdata(dev);
 75	const char *s;
 76
 77	if (optee->in_kernel_rpmb_routing)
 78		s = "kernel";
 79	else
 80		s = "user";
 81
 82	return sysfs_emit(buf, "%s\n", s);
 83}
 84static DEVICE_ATTR_RO(rpmb_routing_model);
 85
 86static struct attribute *optee_dev_attrs[] = {
 87	&dev_attr_rpmb_routing_model.attr,
 88	NULL
 89};
 90
 91ATTRIBUTE_GROUPS(optee_dev);
 92
 93void optee_set_dev_group(struct optee *optee)
 94{
 95	tee_device_set_dev_groups(optee->teedev, optee_dev_groups);
 96	tee_device_set_dev_groups(optee->supp_teedev, optee_dev_groups);
 97}
 98
 99int optee_open(struct tee_context *ctx, bool cap_memref_null)
100{
101	struct optee_context_data *ctxdata;
102	struct tee_device *teedev = ctx->teedev;
103	struct optee *optee = tee_get_drvdata(teedev);
104
105	ctxdata = kzalloc(sizeof(*ctxdata), GFP_KERNEL);
106	if (!ctxdata)
107		return -ENOMEM;
108
109	if (teedev == optee->supp_teedev) {
110		bool busy = true;
111
112		mutex_lock(&optee->supp.mutex);
113		if (!optee->supp.ctx) {
114			busy = false;
115			optee->supp.ctx = ctx;
116		}
117		mutex_unlock(&optee->supp.mutex);
118		if (busy) {
119			kfree(ctxdata);
120			return -EBUSY;
121		}
122
123		if (!optee->scan_bus_done) {
124			INIT_WORK(&optee->scan_bus_work, optee_bus_scan);
125			schedule_work(&optee->scan_bus_work);
126			optee->scan_bus_done = true;
127		}
128	}
129	mutex_init(&ctxdata->mutex);
130	INIT_LIST_HEAD(&ctxdata->sess_list);
131
132	ctx->cap_memref_null = cap_memref_null;
133	ctx->data = ctxdata;
134	return 0;
135}
136
137static void optee_release_helper(struct tee_context *ctx,
138				 int (*close_session)(struct tee_context *ctx,
139						      u32 session,
140						      bool system_thread))
141{
142	struct optee_context_data *ctxdata = ctx->data;
143	struct optee_session *sess;
144	struct optee_session *sess_tmp;
145
146	if (!ctxdata)
147		return;
148
149	list_for_each_entry_safe(sess, sess_tmp, &ctxdata->sess_list,
150				 list_node) {
151		list_del(&sess->list_node);
152		close_session(ctx, sess->session_id, sess->use_sys_thread);
153		kfree(sess);
154	}
155	kfree(ctxdata);
156	ctx->data = NULL;
157}
158
159void optee_release(struct tee_context *ctx)
160{
161	optee_release_helper(ctx, optee_close_session_helper);
162}
163
164void optee_release_supp(struct tee_context *ctx)
165{
166	struct optee *optee = tee_get_drvdata(ctx->teedev);
167
168	optee_release_helper(ctx, optee_close_session_helper);
169
170	optee_supp_release(&optee->supp);
171}
172
173void optee_remove_common(struct optee *optee)
174{
175	blocking_notifier_chain_unregister(&optee_rpmb_intf_added,
176					   &optee->rpmb_intf);
177	cancel_work_sync(&optee->rpmb_scan_bus_work);
178	/* Unregister OP-TEE specific client devices on TEE bus */
179	optee_unregister_devices();
180
181	optee_notif_uninit(optee);
182	optee_shm_arg_cache_uninit(optee);
183	teedev_close_context(optee->ctx);
184	/*
185	 * The two devices have to be unregistered before we can free the
186	 * other resources.
187	 */
188	tee_device_unregister(optee->supp_teedev);
189	tee_device_unregister(optee->teedev);
190
191	tee_shm_pool_free(optee->pool);
192	optee_supp_uninit(&optee->supp);
193	mutex_destroy(&optee->call_queue.mutex);
194	rpmb_dev_put(optee->rpmb_dev);
195	mutex_destroy(&optee->rpmb_dev_mutex);
196}
197
198static int smc_abi_rc;
199static int ffa_abi_rc;
200static bool intf_is_regged;
201
202static int __init optee_core_init(void)
203{
204	int rc;
205
206	/*
207	 * The kernel may have crashed at the same time that all available
208	 * secure world threads were suspended and we cannot reschedule the
209	 * suspended threads without access to the crashed kernel's wait_queue.
210	 * Therefore, we cannot reliably initialize the OP-TEE driver in the
211	 * kdump kernel.
212	 */
213	if (is_kdump_kernel())
214		return -ENODEV;
215
216	if (IS_REACHABLE(CONFIG_RPMB)) {
217		rc = rpmb_interface_register(&rpmb_class_intf);
218		if (rc)
219			return rc;
220		intf_is_regged = true;
221	}
222
223	smc_abi_rc = optee_smc_abi_register();
224	ffa_abi_rc = optee_ffa_abi_register();
225
226	/* If both failed there's no point with this module */
227	if (smc_abi_rc && ffa_abi_rc) {
228		if (IS_REACHABLE(CONFIG_RPMB)) {
229			rpmb_interface_unregister(&rpmb_class_intf);
230			intf_is_regged = false;
231		}
232		return smc_abi_rc;
233	}
234
235	return 0;
236}
237module_init(optee_core_init);
238
239static void __exit optee_core_exit(void)
240{
241	if (IS_REACHABLE(CONFIG_RPMB) && intf_is_regged) {
242		rpmb_interface_unregister(&rpmb_class_intf);
243		intf_is_regged = false;
244	}
245
246	if (!smc_abi_rc)
247		optee_smc_abi_unregister();
248	if (!ffa_abi_rc)
249		optee_ffa_abi_unregister();
250}
251module_exit(optee_core_exit);
252
253MODULE_AUTHOR("Linaro");
254MODULE_DESCRIPTION("OP-TEE driver");
255MODULE_VERSION("1.0");
256MODULE_LICENSE("GPL v2");
257MODULE_ALIAS("platform:optee");