projects/linux·blob master · refs

280 lines · 6.5 KiB

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
66int optee_get_revision(struct tee_device *teedev, char *buf, size_t len)
67{
68 struct optee *optee = tee_get_drvdata(teedev);
69 u64 build_id;
70
71 if (!optee)
72 return -ENODEV;
73 if (!buf || !len)
74 return -EINVAL;
75
76 build_id = optee->revision.os_build_id;
77 if (build_id)
78 scnprintf(buf, len, "%u.%u (%016llx)",
79 optee->revision.os_major,
80 optee->revision.os_minor,
81 (unsigned long long)build_id);
82 else
83 scnprintf(buf, len, "%u.%u", optee->revision.os_major,
84 optee->revision.os_minor);
85
86 return 0;
87}
88
89static void optee_bus_scan(struct work_struct *work)
90{
91 WARN_ON(optee_enumerate_devices(PTA_CMD_GET_DEVICES_SUPP));
92}
93
94static ssize_t rpmb_routing_model_show(struct device *dev,
95 struct device_attribute *attr, char *buf)
96{
97 struct optee *optee = dev_get_drvdata(dev);
98 const char *s;
99
100 if (optee->in_kernel_rpmb_routing)
101 s = "kernel";
102 else
103 s = "user";
104
105 return sysfs_emit(buf, "%s\n", s);
106}
107static DEVICE_ATTR_RO(rpmb_routing_model);
108
109static struct attribute *optee_dev_attrs[] = {
110 &dev_attr_rpmb_routing_model.attr,
111 NULL
112};
113
114ATTRIBUTE_GROUPS(optee_dev);
115
116void optee_set_dev_group(struct optee *optee)
117{
118 tee_device_set_dev_groups(optee->teedev, optee_dev_groups);
119 tee_device_set_dev_groups(optee->supp_teedev, optee_dev_groups);
120}
121
122int optee_open(struct tee_context *ctx, bool cap_memref_null)
123{
124 struct optee_context_data *ctxdata;
125 struct tee_device *teedev = ctx->teedev;
126 struct optee *optee = tee_get_drvdata(teedev);
127
128 ctxdata = kzalloc_obj(*ctxdata);
129 if (!ctxdata)
130 return -ENOMEM;
131
132 if (teedev == optee->supp_teedev) {
133 bool busy = true;
134
135 mutex_lock(&optee->supp.mutex);
136 if (!optee->supp.ctx) {
137 busy = false;
138 optee->supp.ctx = ctx;
139 }
140 mutex_unlock(&optee->supp.mutex);
141 if (busy) {
142 kfree(ctxdata);
143 return -EBUSY;
144 }
145
146 if (!optee->scan_bus_done) {
147 INIT_WORK(&optee->scan_bus_work, optee_bus_scan);
148 schedule_work(&optee->scan_bus_work);
149 optee->scan_bus_done = true;
150 }
151 }
152 mutex_init(&ctxdata->mutex);
153 INIT_LIST_HEAD(&ctxdata->sess_list);
154
155 ctx->cap_memref_null = cap_memref_null;
156 ctx->data = ctxdata;
157 return 0;
158}
159
160static void optee_release_helper(struct tee_context *ctx,
161 int (*close_session)(struct tee_context *ctx,
162 u32 session,
163 bool system_thread))
164{
165 struct optee_context_data *ctxdata = ctx->data;
166 struct optee_session *sess;
167 struct optee_session *sess_tmp;
168
169 if (!ctxdata)
170 return;
171
172 list_for_each_entry_safe(sess, sess_tmp, &ctxdata->sess_list,
173 list_node) {
174 list_del(&sess->list_node);
175 close_session(ctx, sess->session_id, sess->use_sys_thread);
176 kfree(sess);
177 }
178 kfree(ctxdata);
179 ctx->data = NULL;
180}
181
182void optee_release(struct tee_context *ctx)
183{
184 optee_release_helper(ctx, optee_close_session_helper);
185}
186
187void optee_release_supp(struct tee_context *ctx)
188{
189 struct optee *optee = tee_get_drvdata(ctx->teedev);
190
191 optee_release_helper(ctx, optee_close_session_helper);
192
193 optee_supp_release(&optee->supp);
194}
195
196void optee_remove_common(struct optee *optee)
197{
198 blocking_notifier_chain_unregister(&optee_rpmb_intf_added,
199 &optee->rpmb_intf);
200 cancel_work_sync(&optee->rpmb_scan_bus_work);
201 /* Unregister OP-TEE specific client devices on TEE bus */
202 optee_unregister_devices();
203
204 optee_notif_uninit(optee);
205 optee_shm_arg_cache_uninit(optee);
206 teedev_close_context(optee->ctx);
207 /*
208 * The two devices have to be unregistered before we can free the
209 * other resources.
210 */
211 tee_device_unregister(optee->supp_teedev);
212 tee_device_unregister(optee->teedev);
213
214 tee_shm_pool_free(optee->pool);
215 optee_supp_uninit(&optee->supp);
216 mutex_destroy(&optee->call_queue.mutex);
217 rpmb_dev_put(optee->rpmb_dev);
218 mutex_destroy(&optee->rpmb_dev_mutex);
219}
220
221static int smc_abi_rc;
222static int ffa_abi_rc;
223static bool intf_is_regged;
224
225static int __init optee_core_init(void)
226{
227 int rc;
228
229 /*
230 * The kernel may have crashed at the same time that all available
231 * secure world threads were suspended and we cannot reschedule the
232 * suspended threads without access to the crashed kernel's wait_queue.
233 * Therefore, we cannot reliably initialize the OP-TEE driver in the
234 * kdump kernel.
235 */
236 if (is_kdump_kernel())
237 return -ENODEV;
238
239 if (IS_REACHABLE(CONFIG_RPMB)) {
240 rc = rpmb_interface_register(&rpmb_class_intf);
241 if (rc)
242 return rc;
243 intf_is_regged = true;
244 }
245
246 smc_abi_rc = optee_smc_abi_register();
247 ffa_abi_rc = optee_ffa_abi_register();
248
249 /* If both failed there's no point with this module */
250 if (smc_abi_rc && ffa_abi_rc) {
251 if (IS_REACHABLE(CONFIG_RPMB)) {
252 rpmb_interface_unregister(&rpmb_class_intf);
253 intf_is_regged = false;
254 }
255 return smc_abi_rc;
256 }
257
258 return 0;
259}
260module_init(optee_core_init);
261
262static void __exit optee_core_exit(void)
263{
264 if (IS_REACHABLE(CONFIG_RPMB) && intf_is_regged) {
265 rpmb_interface_unregister(&rpmb_class_intf);
266 intf_is_regged = false;
267 }
268
269 if (!smc_abi_rc)
270 optee_smc_abi_unregister();
271 if (!ffa_abi_rc)
272 optee_ffa_abi_unregister();
273}
274module_exit(optee_core_exit);
275
276MODULE_AUTHOR("Linaro");
277MODULE_DESCRIPTION("OP-TEE driver");
278MODULE_VERSION("1.0");
279MODULE_LICENSE("GPL v2");
280MODULE_ALIAS("platform:optee");