[FOSS_TLK]security: tlk_driver: add daemon recovery support
[tegra/ote_partner/tlk_driver.git] / security / tlk_driver / ote_protocol.h
1 /*
2  * Copyright (c) 2013-2015 NVIDIA Corporation. All rights reserved.
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation; either version 2 of the License, or
7  * (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful, but WITHOUT
10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
12  * more details.
13  *
14  * You should have received a copy of the GNU General Public License along
15  * with this program; if not, write to the Free Software Foundation, Inc.,
16  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
17  */
18
19 #ifndef __OTE_PROTOCOL_H__
20 #define __OTE_PROTOCOL_H__
21
22 #include "ote_types.h"
23
24 #define TE_IOCTL_MAGIC_NUMBER ('t')
25 #define TE_IOCTL_OPEN_CLIENT_SESSION \
26         _IOWR(TE_IOCTL_MAGIC_NUMBER, 0x10, union te_cmd)
27 #define TE_IOCTL_CLOSE_CLIENT_SESSION \
28         _IOWR(TE_IOCTL_MAGIC_NUMBER, 0x11, union te_cmd)
29 #define TE_IOCTL_LAUNCH_OPERATION \
30         _IOWR(TE_IOCTL_MAGIC_NUMBER, 0x14, union te_cmd)
31
32 /* secure storage ioctl */
33 #define TE_IOCTL_SS_CMD \
34         _IOR(TE_IOCTL_MAGIC_NUMBER,  0x30, int)
35
36 #define TE_IOCTL_SS_CMD_GET_NEW_REQ     1
37 #define TE_IOCTL_SS_CMD_REQ_COMPLETE    2
38
39 #define TE_IOCTL_MIN_NR _IOC_NR(TE_IOCTL_OPEN_CLIENT_SESSION)
40 #define TE_IOCTL_MAX_NR _IOC_NR(TE_IOCTL_SS_CMD)
41
42 /* shared buffer is 2 pages: 1st are requests, 2nd are params */
43 #define TE_CMD_DESC_MAX (PAGE_SIZE / sizeof(struct te_request))
44 #define TE_PARAM_MAX    (PAGE_SIZE / sizeof(struct te_oper_param))
45
46 #define MAX_EXT_SMC_ARGS        12
47
48 extern struct mutex smc_lock;
49 extern struct tlk_device tlk_dev;
50 extern void tlk_fiq_glue_aarch64(void);
51
52 uint32_t send_smc(uint32_t arg0, uintptr_t arg1, uintptr_t arg2);
53 uint32_t _tlk_generic_smc(uint32_t arg0, uintptr_t arg1, uintptr_t arg2);
54 void tlk_irq_handler(void);
55
56 /* errors returned by secure world in reponse to SMC calls */
57 enum {
58         TE_ERROR_PREEMPT_BY_IRQ = 0xFFFFFFFD,
59         TE_ERROR_PREEMPT_BY_FS = 0xFFFFFFFE,
60 };
61
62 struct tlk_device {
63         struct te_request *req_addr;
64         dma_addr_t req_addr_phys;
65         struct te_oper_param *param_addr;
66         dma_addr_t param_addr_phys;
67
68         char *req_param_buf;
69
70         unsigned long *param_bitmap;
71
72         struct list_head used_cmd_list;
73         struct list_head free_cmd_list;
74 };
75
76 struct te_cmd_req_desc {
77         struct te_request *req_addr;
78         struct list_head list;
79 };
80
81 struct te_shmem_desc {
82         struct list_head list;
83         uint32_t type;
84         void *buffer;
85         size_t size;
86         struct page **pages;
87         unsigned int nr_pages;
88         bool is_locked;
89 };
90
91 /*
92  * Per-session data structure.
93  *
94  * Both temp (freed upon completion of the associated op) and persist
95  * (freed upon session close) memory references are tracked by this
96  * structure.
97  *
98  * Persistent memory references stay on an inactive list until the
99  * associated op completes.  If it completes successfully then the
100  * references are moved to the active list.
101  */
102 struct te_session {
103         struct list_head list;
104         uint32_t session_id;
105         struct list_head temp_shmem_list;
106         struct list_head inactive_persist_shmem_list;
107         struct list_head persist_shmem_list;
108 };
109
110 struct tlk_context {
111         struct tlk_device *dev;
112         struct list_head session_list;
113 };
114
115 enum {
116         /* Trusted Application Calls */
117         TE_SMC_OPEN_SESSION             = 0x70000001,
118         TE_SMC_CLOSE_SESSION            = 0x70000002,
119         TE_SMC_LAUNCH_OPERATION         = 0x70000003,
120         TE_SMC_TA_EVENT                 = 0x70000004,
121
122         /* Trusted OS (64-bit) calls */
123         TE_SMC_REGISTER_REQ_BUF         = 0x72000001,
124         TE_SMC_INIT_LOGGER              = 0x72000002,
125         TE_SMC_SS_REGISTER_HANDLER      = 0x72000003,
126         TE_SMC_RESTART                  = 0x72000100,
127
128         /* SIP (SOC specific) calls.  */
129         TE_SMC_PROGRAM_VPR              = 0x82000003,
130         TE_SMC_REGISTER_FIQ_GLUE        = 0x82000005,
131         TE_SMC_VRR_SET_BUF              = 0x82000011,
132         TE_SMC_VRR_SEC                  = 0x82000012,
133 };
134
135 enum {
136         TE_PARAM_TYPE_NONE              = 0x0,
137         TE_PARAM_TYPE_INT_RO            = 0x1,
138         TE_PARAM_TYPE_INT_RW            = 0x2,
139         TE_PARAM_TYPE_MEM_RO            = 0x3,
140         TE_PARAM_TYPE_MEM_RW            = 0x4,
141         TE_PARAM_TYPE_PERSIST_MEM_RO    = 0x100,
142         TE_PARAM_TYPE_PERSIST_MEM_RW    = 0x101,
143 };
144
145 struct te_oper_param {
146         uint32_t index;
147         uint32_t type;
148         union {
149                 struct {
150                         uint32_t val;
151                 } Int;
152                 struct {
153                         uint64_t base;
154                         uint32_t len;
155                 } Mem;
156         } u;
157         uint64_t next_ptr_user;
158 };
159
160 struct te_service_id {
161         uint32_t time_low;
162         uint16_t time_mid;
163         uint16_t time_hi_and_version;
164         uint8_t clock_seq_and_node[8];
165 };
166
167 struct te_operation {
168         uint32_t        command;
169         uint32_t        status;
170         uint64_t        list_head;
171         uint64_t        list_tail;
172         uint32_t        list_count;
173         uint32_t        interface_side;
174 };
175
176 /*
177  * OpenSession
178  */
179 struct te_opensession {
180         struct te_service_id    dest_uuid;
181         struct te_operation     operation;
182         uint64_t                answer;
183 };
184
185 /*
186  * CloseSession
187  */
188 struct te_closesession {
189         uint32_t        session_id;
190         uint64_t        answer;
191 };
192
193 /*
194  * LaunchOperation
195  */
196 struct te_launchop {
197         uint32_t                session_id;
198         struct te_operation     operation;
199         uint64_t                answer;
200 };
201
202 union te_cmd {
203         struct te_opensession   opensession;
204         struct te_closesession  closesession;
205         struct te_launchop      launchop;
206 };
207
208 struct te_request {
209         uint32_t                type;
210         uint32_t                session_id;
211         uint32_t                command_id;
212         uint64_t                params;
213         uint32_t                params_size;
214         uint32_t                dest_uuid[4];
215         uint32_t                result;
216         uint32_t                result_origin;
217 };
218
219 struct te_answer {
220         uint32_t        result;
221         uint32_t        session_id;
222         uint32_t        result_origin;
223 };
224
225 void te_open_session(struct te_opensession *cmd,
226         struct te_request *request,
227         struct tlk_context *context);
228
229 void te_close_session(struct te_closesession *cmd,
230         struct te_request *request,
231         struct tlk_context *context);
232
233 void te_launch_operation(struct te_launchop *cmd,
234         struct te_request *request,
235         struct tlk_context *context);
236
237 #define SS_OP_MAX_DATA_SIZE     0x1000
238 struct te_ss_op {
239         uint32_t        req_size;
240         uint8_t         data[SS_OP_MAX_DATA_SIZE];
241 };
242
243 enum ta_event_id {
244         TA_EVENT_RESTORE_KEYS = 0,
245
246         TA_EVENT_MASK = (1 << TA_EVENT_RESTORE_KEYS),
247 };
248
249 int te_handle_ss_ioctl(struct file *file, unsigned int ioctl_num,
250                 unsigned long ioctl_param);
251 void ote_print_logs(void);
252 int tlk_ss_op(void);
253 int ote_property_is_disabled(const char *str);
254
255 #endif