1/* SPDX-License-Identifier: GPL-2.0-only */ 2/* 3 * Copyright (c) 2015-2021, Linaro Limited 4 */ 5 6#ifndef OPTEE_PRIVATE_H 7#define OPTEE_PRIVATE_H 8 9#include <linux/arm-smccc.h> 10#include <linux/rhashtable.h> 11#include <linux/semaphore.h> 12#include <linux/tee_drv.h> 13#include <linux/types.h> 14#include "optee_msg.h" 15 16#define DRIVER_NAME "optee" 17 18#define OPTEE_MAX_ARG_SIZE 1024 19 20/* Some Global Platform error codes used in this driver */ 21#define TEEC_SUCCESS 0x00000000 22#define TEEC_ERROR_BAD_PARAMETERS 0xFFFF0006 23#define TEEC_ERROR_NOT_SUPPORTED 0xFFFF000A 24#define TEEC_ERROR_COMMUNICATION 0xFFFF000E 25#define TEEC_ERROR_OUT_OF_MEMORY 0xFFFF000C 26#define TEEC_ERROR_BUSY 0xFFFF000D 27#define TEEC_ERROR_SHORT_BUFFER 0xFFFF0010 28 29#define TEEC_ORIGIN_COMMS 0x00000002 30 31/* 32 * This value should be larger than the number threads in secure world to 33 * meet the need from secure world. The number of threads in secure world 34 * are usually not even close to 255 so we should be safe for now. 35 */ 36#define OPTEE_DEFAULT_MAX_NOTIF_VALUE 255 37 38typedef void (optee_invoke_fn)(unsigned long, unsigned long, unsigned long, 39 unsigned long, unsigned long, unsigned long, 40 unsigned long, unsigned long, 41 struct arm_smccc_res *); 42 43struct optee_call_waiter { 44 struct list_head list_node; 45 struct completion c; 46}; 47 48struct optee_call_queue { 49 /* Serializes access to this struct */ 50 struct mutex mutex; 51 struct list_head waiters; 52}; 53 54struct optee_notif { 55 u_int max_key; 56 /* Serializes access to the elements below in this struct */ 57 spinlock_t lock; 58 struct list_head db; 59 u_long *bitmap; 60}; 61 62#define OPTEE_SHM_ARG_ALLOC_PRIV BIT(0) 63#define OPTEE_SHM_ARG_SHARED BIT(1) 64struct optee_shm_arg_entry; 65struct optee_shm_arg_cache { 66 u32 flags; 67 /* Serializes access to this struct */ 68 struct mutex mutex; 69 struct list_head shm_args; 70}; 71 72/** 73 * struct optee_supp - supplicant synchronization struct 74 * @ctx the context of current connected supplicant. 75 * if !NULL the supplicant device is available for use, 76 * else busy 77 * @mutex: held while accessing content of this struct 78 * @req_id: current request id if supplicant is doing synchronous 79 * communication, else -1 80 * @reqs: queued request not yet retrieved by supplicant 81 * @idr: IDR holding all requests currently being processed 82 * by supplicant 83 * @reqs_c: completion used by supplicant when waiting for a 84 * request to be queued. 85 */ 86struct optee_supp { 87 /* Serializes access to this struct */ 88 struct mutex mutex; 89 struct tee_context *ctx; 90 91 int req_id; 92 struct list_head reqs; 93 struct idr idr; 94 struct completion reqs_c; 95}; 96 97/* 98 * struct optee_pcpu - per cpu notif private struct passed to work functions 99 * @optee optee device reference 100 */ 101struct optee_pcpu { 102 struct optee *optee; 103}; 104 105/* 106 * struct optee_smc - optee smc communication struct 107 * @invoke_fn handler function to invoke secure monitor 108 * @memremaped_shm virtual address of memory in shared memory pool 109 * @sec_caps: secure world capabilities defined by 110 * OPTEE_SMC_SEC_CAP_* in optee_smc.h 111 * @notif_irq interrupt used as async notification by OP-TEE or 0 112 * @optee_pcpu per_cpu optee instance for per cpu work or NULL 113 * @notif_pcpu_wq workqueue for per cpu asynchronous notification or NULL 114 * @notif_pcpu_work work for per cpu asynchronous notification 115 * @notif_cpuhp_state CPU hotplug state assigned for pcpu interrupt management 116 */ 117struct optee_smc { 118 optee_invoke_fn *invoke_fn; 119 void *memremaped_shm; 120 u32 sec_caps; 121 unsigned int notif_irq; 122 struct optee_pcpu __percpu *optee_pcpu; 123 struct workqueue_struct *notif_pcpu_wq; 124 struct work_struct notif_pcpu_work; 125 unsigned int notif_cpuhp_state; 126}; 127 128/** 129 * struct optee_ffa_data - FFA communication struct 130 * @ffa_dev FFA device, contains the destination id, the id of 131 * OP-TEE in secure world 132 * @ffa_ops FFA operations 133 * @mutex Serializes access to @global_ids 134 * @global_ids FF-A shared memory global handle translation 135 */ 136struct optee_ffa { 137 struct ffa_device *ffa_dev; 138 /* Serializes access to @global_ids */ 139 struct mutex mutex; 140 struct rhashtable global_ids; 141}; 142 143struct optee; 144 145/** 146 * struct optee_ops - OP-TEE driver internal operations 147 * @do_call_with_arg: enters OP-TEE in secure world 148 * @to_msg_param: converts from struct tee_param to OPTEE_MSG parameters 149 * @from_msg_param: converts from OPTEE_MSG parameters to struct tee_param 150 * 151 * These OPs are only supposed to be used internally in the OP-TEE driver 152 * as a way of abstracting the different methogs of entering OP-TEE in 153 * secure world. 154 */ 155struct optee_ops { 156 int (*do_call_with_arg)(struct tee_context *ctx, 157 struct tee_shm *shm_arg, u_int offs); 158 int (*to_msg_param)(struct optee *optee, 159 struct optee_msg_param *msg_params, 160 size_t num_params, const struct tee_param *params); 161 int (*from_msg_param)(struct optee *optee, struct tee_param *params, 162 size_t num_params, 163 const struct optee_msg_param *msg_params); 164}; 165 166/** 167 * struct optee - main service struct 168 * @supp_teedev: supplicant device 169 * @teedev: client device 170 * @ops: internal callbacks for different ways to reach secure 171 * world 172 * @ctx: driver internal TEE context 173 * @smc: specific to SMC ABI 174 * @ffa: specific to FF-A ABI 175 * @call_queue: queue of threads waiting to call @invoke_fn 176 * @notif: notification synchronization struct 177 * @supp: supplicant synchronization struct for RPC to supplicant 178 * @pool: shared memory pool 179 * @rpc_param_count: If > 0 number of RPC parameters to make room for 180 * @scan_bus_done flag if device registation was already done. 181 * @scan_bus_wq workqueue to scan optee bus and register optee drivers 182 * @scan_bus_work workq to scan optee bus and register optee drivers 183 */ 184struct optee { 185 struct tee_device *supp_teedev; 186 struct tee_device *teedev; 187 const struct optee_ops *ops; 188 struct tee_context *ctx; 189 union { 190 struct optee_smc smc; 191 struct optee_ffa ffa; 192 }; 193 struct optee_shm_arg_cache shm_arg_cache; 194 struct optee_call_queue call_queue; 195 struct optee_notif notif; 196 struct optee_supp supp; 197 struct tee_shm_pool *pool; 198 unsigned int rpc_param_count; 199 bool scan_bus_done; 200 struct workqueue_struct *scan_bus_wq; 201 struct work_struct scan_bus_work; 202}; 203 204struct optee_session { 205 struct list_head list_node; 206 u32 session_id; 207}; 208 209struct optee_context_data { 210 /* Serializes access to this struct */ 211 struct mutex mutex; 212 struct list_head sess_list; 213}; 214 215struct optee_rpc_param { 216 u32 a0; 217 u32 a1; 218 u32 a2; 219 u32 a3; 220 u32 a4; 221 u32 a5; 222 u32 a6; 223 u32 a7; 224}; 225 226/* Holds context that is preserved during one STD call */ 227struct optee_call_ctx { 228 /* information about pages list used in last allocation */ 229 void *pages_list; 230 size_t num_entries; 231}; 232 233int optee_notif_init(struct optee *optee, u_int max_key); 234void optee_notif_uninit(struct optee *optee); 235int optee_notif_wait(struct optee *optee, u_int key); 236int optee_notif_send(struct optee *optee, u_int key); 237 238u32 optee_supp_thrd_req(struct tee_context *ctx, u32 func, size_t num_params, 239 struct tee_param *param); 240 241void optee_supp_init(struct optee_supp *supp); 242void optee_supp_uninit(struct optee_supp *supp); 243void optee_supp_release(struct optee_supp *supp); 244 245int optee_supp_recv(struct tee_context *ctx, u32 *func, u32 *num_params, 246 struct tee_param *param); 247int optee_supp_send(struct tee_context *ctx, u32 ret, u32 num_params, 248 struct tee_param *param); 249 250int optee_open_session(struct tee_context *ctx, 251 struct tee_ioctl_open_session_arg *arg, 252 struct tee_param *param); 253int optee_close_session_helper(struct tee_context *ctx, u32 session); 254int optee_close_session(struct tee_context *ctx, u32 session); 255int optee_invoke_func(struct tee_context *ctx, struct tee_ioctl_invoke_arg *arg, 256 struct tee_param *param); 257int optee_cancel_req(struct tee_context *ctx, u32 cancel_id, u32 session); 258 259#define PTA_CMD_GET_DEVICES 0x0 260#define PTA_CMD_GET_DEVICES_SUPP 0x1 261int optee_enumerate_devices(u32 func); 262void optee_unregister_devices(void); 263 264int optee_pool_op_alloc_helper(struct tee_shm_pool *pool, struct tee_shm *shm, 265 size_t size, size_t align, 266 int (*shm_register)(struct tee_context *ctx, 267 struct tee_shm *shm, 268 struct page **pages, 269 size_t num_pages, 270 unsigned long start)); 271void optee_pool_op_free_helper(struct tee_shm_pool *pool, struct tee_shm *shm, 272 int (*shm_unregister)(struct tee_context *ctx, 273 struct tee_shm *shm)); 274 275 276void optee_remove_common(struct optee *optee); 277int optee_open(struct tee_context *ctx, bool cap_memref_null); 278void optee_release(struct tee_context *ctx); 279void optee_release_supp(struct tee_context *ctx); 280 281static inline void optee_from_msg_param_value(struct tee_param *p, u32 attr, 282 const struct optee_msg_param *mp) 283{ 284 p->attr = TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INPUT + 285 attr - OPTEE_MSG_ATTR_TYPE_VALUE_INPUT; 286 p->u.value.a = mp->u.value.a; 287 p->u.value.b = mp->u.value.b; 288 p->u.value.c = mp->u.value.c; 289} 290 291static inline void optee_to_msg_param_value(struct optee_msg_param *mp, 292 const struct tee_param *p) 293{ 294 mp->attr = OPTEE_MSG_ATTR_TYPE_VALUE_INPUT + p->attr - 295 TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INPUT; 296 mp->u.value.a = p->u.value.a; 297 mp->u.value.b = p->u.value.b; 298 mp->u.value.c = p->u.value.c; 299} 300 301void optee_cq_wait_init(struct optee_call_queue *cq, 302 struct optee_call_waiter *w); 303void optee_cq_wait_for_completion(struct optee_call_queue *cq, 304 struct optee_call_waiter *w); 305void optee_cq_wait_final(struct optee_call_queue *cq, 306 struct optee_call_waiter *w); 307int optee_check_mem_type(unsigned long start, size_t num_pages); 308 309void optee_shm_arg_cache_init(struct optee *optee, u32 flags); 310void optee_shm_arg_cache_uninit(struct optee *optee); 311struct optee_msg_arg *optee_get_msg_arg(struct tee_context *ctx, 312 size_t num_params, 313 struct optee_shm_arg_entry **entry, 314 struct tee_shm **shm_ret, 315 u_int *offs); 316void optee_free_msg_arg(struct tee_context *ctx, 317 struct optee_shm_arg_entry *entry, u_int offs); 318size_t optee_msg_arg_size(size_t rpc_param_count); 319 320 321struct tee_shm *optee_rpc_cmd_alloc_suppl(struct tee_context *ctx, size_t sz); 322void optee_rpc_cmd_free_suppl(struct tee_context *ctx, struct tee_shm *shm); 323void optee_rpc_cmd(struct tee_context *ctx, struct optee *optee, 324 struct optee_msg_arg *arg); 325 326/* 327 * Small helpers 328 */ 329 330static inline void *reg_pair_to_ptr(u32 reg0, u32 reg1) 331{ 332 return (void *)(unsigned long)(((u64)reg0 << 32) | reg1); 333} 334 335static inline void reg_pair_from_64(u32 *reg0, u32 *reg1, u64 val) 336{ 337 *reg0 = val >> 32; 338 *reg1 = val; 339} 340 341/* Registration of the ABIs */ 342int optee_smc_abi_register(void); 343void optee_smc_abi_unregister(void); 344int optee_ffa_abi_register(void); 345void optee_ffa_abi_unregister(void); 346 347#endif /*OPTEE_PRIVATE_H*/ 348