blob: bd5418543537e2e164da29b537580c58db4df0f5 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
|
// SPDX-License-Identifier: BSD-2-Clause
/*
* Copyright (c) 2015, Linaro Limited
* Copyright (c) 2014, STMicroelectronics International N.V.
*/
#include <tee/entry_fast.h>
#include <optee_msg.h>
#include <sm/optee_smc.h>
#include <kernel/generic_boot.h>
#include <kernel/tee_l2cc_mutex.h>
#include <kernel/misc.h>
#include <mm/core_mmu.h>
static void tee_entry_get_shm_config(struct thread_smc_args *args)
{
args->a0 = OPTEE_SMC_RETURN_OK;
args->a1 = default_nsec_shm_paddr;
args->a2 = default_nsec_shm_size;
/* Should this be TEESMC cache attributes instead? */
args->a3 = core_mmu_is_shm_cached();
}
static void tee_entry_fastcall_l2cc_mutex(struct thread_smc_args *args)
{
TEE_Result ret;
#ifdef ARM32
paddr_t pa = 0;
switch (args->a1) {
case OPTEE_SMC_L2CC_MUTEX_GET_ADDR:
ret = tee_get_l2cc_mutex(&pa);
reg_pair_from_64(pa, &args->a2, &args->a3);
break;
case OPTEE_SMC_L2CC_MUTEX_SET_ADDR:
pa = reg_pair_to_64(args->a2, args->a3);
ret = tee_set_l2cc_mutex(&pa);
break;
case OPTEE_SMC_L2CC_MUTEX_ENABLE:
ret = tee_enable_l2cc_mutex();
break;
case OPTEE_SMC_L2CC_MUTEX_DISABLE:
ret = tee_disable_l2cc_mutex();
break;
default:
args->a0 = OPTEE_SMC_RETURN_EBADCMD;
return;
}
#else
ret = TEE_ERROR_NOT_SUPPORTED;
#endif
if (ret == TEE_ERROR_NOT_SUPPORTED)
args->a0 = OPTEE_SMC_RETURN_UNKNOWN_FUNCTION;
else if (ret)
args->a0 = OPTEE_SMC_RETURN_EBADADDR;
else
args->a0 = OPTEE_SMC_RETURN_OK;
}
static void tee_entry_exchange_capabilities(struct thread_smc_args *args)
{
bool dyn_shm_en = false;
/*
* Currently we ignore OPTEE_SMC_NSEC_CAP_UNIPROCESSOR.
*
* The memory mapping of shared memory is defined as normal
* shared memory for SMP systems and normal memory for UP
* systems. Currently we map all memory as shared in secure
* world.
*
* When translation tables are created with shared bit cleared for
* uniprocessor systems we'll need to check
* OPTEE_SMC_NSEC_CAP_UNIPROCESSOR.
*/
if (args->a1 & ~OPTEE_SMC_NSEC_CAP_UNIPROCESSOR) {
/* Unknown capability. */
args->a0 = OPTEE_SMC_RETURN_ENOTAVAIL;
return;
}
args->a0 = OPTEE_SMC_RETURN_OK;
args->a1 = OPTEE_SMC_SEC_CAP_HAVE_RESERVED_SHM;
#if defined(CFG_DYN_SHM_CAP)
dyn_shm_en = core_mmu_nsec_ddr_is_defined();
if (dyn_shm_en)
args->a1 |= OPTEE_SMC_SEC_CAP_DYNAMIC_SHM;
#endif
IMSG("Dynamic shared memory is %sabled", dyn_shm_en ? "en" : "dis");
}
static void tee_entry_disable_shm_cache(struct thread_smc_args *args)
{
uint64_t cookie;
if (!thread_disable_prealloc_rpc_cache(&cookie)) {
args->a0 = OPTEE_SMC_RETURN_EBUSY;
return;
}
if (!cookie) {
args->a0 = OPTEE_SMC_RETURN_ENOTAVAIL;
return;
}
args->a0 = OPTEE_SMC_RETURN_OK;
args->a1 = cookie >> 32;
args->a2 = cookie;
}
static void tee_entry_enable_shm_cache(struct thread_smc_args *args)
{
if (thread_enable_prealloc_rpc_cache())
args->a0 = OPTEE_SMC_RETURN_OK;
else
args->a0 = OPTEE_SMC_RETURN_EBUSY;
}
static void tee_entry_boot_secondary(struct thread_smc_args *args)
{
#if defined(CFG_BOOT_SECONDARY_REQUEST)
if (!generic_boot_core_release(args->a1, (paddr_t)(args->a3)))
args->a0 = OPTEE_SMC_RETURN_OK;
else
args->a0 = OPTEE_SMC_RETURN_EBADCMD;
#else
args->a0 = OPTEE_SMC_RETURN_ENOTAVAIL;
#endif
}
void tee_entry_fast(struct thread_smc_args *args)
{
switch (args->a0) {
/* Generic functions */
case OPTEE_SMC_CALLS_COUNT:
tee_entry_get_api_call_count(args);
break;
case OPTEE_SMC_CALLS_UID:
tee_entry_get_api_uuid(args);
break;
case OPTEE_SMC_CALLS_REVISION:
tee_entry_get_api_revision(args);
break;
case OPTEE_SMC_CALL_GET_OS_UUID:
tee_entry_get_os_uuid(args);
break;
case OPTEE_SMC_CALL_GET_OS_REVISION:
tee_entry_get_os_revision(args);
break;
/* OP-TEE specific SMC functions */
case OPTEE_SMC_GET_SHM_CONFIG:
tee_entry_get_shm_config(args);
break;
case OPTEE_SMC_L2CC_MUTEX:
tee_entry_fastcall_l2cc_mutex(args);
break;
case OPTEE_SMC_EXCHANGE_CAPABILITIES:
tee_entry_exchange_capabilities(args);
break;
case OPTEE_SMC_DISABLE_SHM_CACHE:
tee_entry_disable_shm_cache(args);
break;
case OPTEE_SMC_ENABLE_SHM_CACHE:
tee_entry_enable_shm_cache(args);
break;
case OPTEE_SMC_BOOT_SECONDARY:
tee_entry_boot_secondary(args);
break;
default:
args->a0 = OPTEE_SMC_RETURN_UNKNOWN_FUNCTION;
break;
}
}
size_t tee_entry_generic_get_api_call_count(void)
{
/*
* All the different calls handled in this file. If the specific
* target has additional calls it will call this function and
* add the number of calls the target has added.
*/
return 11;
}
void __weak tee_entry_get_api_call_count(struct thread_smc_args *args)
{
args->a0 = tee_entry_generic_get_api_call_count();
}
void __weak tee_entry_get_api_uuid(struct thread_smc_args *args)
{
args->a0 = OPTEE_MSG_UID_0;
args->a1 = OPTEE_MSG_UID_1;
args->a2 = OPTEE_MSG_UID_2;
args->a3 = OPTEE_MSG_UID_3;
}
void __weak tee_entry_get_api_revision(struct thread_smc_args *args)
{
args->a0 = OPTEE_MSG_REVISION_MAJOR;
args->a1 = OPTEE_MSG_REVISION_MINOR;
}
void __weak tee_entry_get_os_uuid(struct thread_smc_args *args)
{
args->a0 = OPTEE_MSG_OS_OPTEE_UUID_0;
args->a1 = OPTEE_MSG_OS_OPTEE_UUID_1;
args->a2 = OPTEE_MSG_OS_OPTEE_UUID_2;
args->a3 = OPTEE_MSG_OS_OPTEE_UUID_3;
}
void __weak tee_entry_get_os_revision(struct thread_smc_args *args)
{
args->a0 = CFG_OPTEE_REVISION_MAJOR;
args->a1 = CFG_OPTEE_REVISION_MINOR;
args->a2 = TEE_IMPL_GIT_SHA1;
}
|
