Commit | Line | Data |
---|---|---|
ff3d9c3c MA |
1 | /* |
2 | * | |
3 | * sep_crypto.h - Crypto interface structures | |
4 | * | |
5 | * Copyright(c) 2009-2011 Intel Corporation. All rights reserved. | |
6 | * Contributions(c) 2009-2010 Discretix. All rights reserved. | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or modify it | |
9 | * under the terms of the GNU General Public License as published by the Free | |
10 | * Software Foundation; version 2 of the License. | |
11 | * | |
12 | * This program is distributed in the hope that it will be useful, but WITHOUT | |
13 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
14 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | |
15 | * more details. | |
16 | * | |
17 | * You should have received a copy of the GNU General Public License along with | |
18 | * this program; if not, write to the Free Software Foundation, Inc., 59 | |
19 | * Temple Place - Suite 330, Boston, MA 02111-1307, USA. | |
20 | * | |
21 | * CONTACTS: | |
22 | * | |
23 | * Mark Allyn mark.a.allyn@intel.com | |
24 | * Jayant Mangalampalli jayant.mangalampalli@intel.com | |
25 | * | |
26 | * CHANGES: | |
27 | * | |
28 | * 2009.06.26 Initial publish | |
29 | * 2011.02.22 Enable Kernel Crypto | |
30 | * | |
31 | */ | |
32 | ||
33 | /* Constants for SEP (from vendor) */ | |
34 | #define SEP_START_MSG_TOKEN 0x02558808 | |
35 | ||
36 | #define SEP_DES_IV_SIZE_WORDS 2 | |
37 | #define SEP_DES_IV_SIZE_BYTES (SEP_DES_IV_SIZE_WORDS * \ | |
38 | sizeof(u32)) | |
39 | #define SEP_DES_KEY_SIZE_WORDS 2 | |
40 | #define SEP_DES_KEY_SIZE_BYTES (SEP_DES_KEY_SIZE_WORDS * \ | |
41 | sizeof(u32)) | |
42 | #define SEP_DES_BLOCK_SIZE 8 | |
43 | #define SEP_DES_DUMMY_SIZE 16 | |
44 | ||
45 | #define SEP_DES_INIT_OPCODE 0x10 | |
46 | #define SEP_DES_BLOCK_OPCODE 0x11 | |
47 | ||
48 | #define SEP_AES_BLOCK_SIZE_WORDS 4 | |
49 | #define SEP_AES_BLOCK_SIZE_BYTES \ | |
50 | (SEP_AES_BLOCK_SIZE_WORDS * sizeof(u32)) | |
51 | ||
52 | #define SEP_AES_DUMMY_BLOCK_SIZE 16 | |
53 | #define SEP_AES_IV_SIZE_WORDS SEP_AES_BLOCK_SIZE_WORDS | |
54 | #define SEP_AES_IV_SIZE_BYTES \ | |
55 | (SEP_AES_IV_SIZE_WORDS * sizeof(u32)) | |
56 | ||
57 | #define SEP_AES_KEY_128_SIZE 16 | |
58 | #define SEP_AES_KEY_192_SIZE 24 | |
59 | #define SEP_AES_KEY_256_SIZE 32 | |
60 | #define SEP_AES_KEY_512_SIZE 64 | |
61 | #define SEP_AES_MAX_KEY_SIZE_WORDS 16 | |
62 | #define SEP_AES_MAX_KEY_SIZE_BYTES \ | |
63 | (SEP_AES_MAX_KEY_SIZE_WORDS * sizeof(u32)) | |
64 | ||
65 | #define SEP_AES_WRAP_MIN_SIZE 8 | |
66 | #define SEP_AES_WRAP_MAX_SIZE 0x10000000 | |
67 | ||
68 | #define SEP_AES_WRAP_BLOCK_SIZE_WORDS 2 | |
69 | #define SEP_AES_WRAP_BLOCK_SIZE_BYTES \ | |
70 | (SEP_AES_WRAP_BLOCK_SIZE_WORDS * sizeof(u32)) | |
71 | ||
72 | #define SEP_AES_SECRET_RKEK1 0x1 | |
73 | #define SEP_AES_SECRET_RKEK2 0x2 | |
74 | ||
75 | #define SEP_AES_INIT_OPCODE 0x2 | |
76 | #define SEP_AES_BLOCK_OPCODE 0x3 | |
77 | #define SEP_AES_FINISH_OPCODE 0x4 | |
78 | #define SEP_AES_WRAP_OPCODE 0x6 | |
79 | #define SEP_AES_UNWRAP_OPCODE 0x7 | |
80 | #define SEP_AES_XTS_FINISH_OPCODE 0x8 | |
81 | ||
82 | #define SEP_HASH_RESULT_SIZE_WORDS 16 | |
83 | #define SEP_MD5_DIGEST_SIZE_WORDS 4 | |
84 | #define SEP_MD5_DIGEST_SIZE_BYTES \ | |
85 | (SEP_MD5_DIGEST_SIZE_WORDS * sizeof(u32)) | |
86 | #define SEP_SHA1_DIGEST_SIZE_WORDS 5 | |
87 | #define SEP_SHA1_DIGEST_SIZE_BYTES \ | |
88 | (SEP_SHA1_DIGEST_SIZE_WORDS * sizeof(u32)) | |
89 | #define SEP_SHA224_DIGEST_SIZE_WORDS 7 | |
90 | #define SEP_SHA224_DIGEST_SIZE_BYTES \ | |
91 | (SEP_SHA224_DIGEST_SIZE_WORDS * sizeof(u32)) | |
92 | #define SEP_SHA256_DIGEST_SIZE_WORDS 8 | |
93 | #define SEP_SHA256_DIGEST_SIZE_BYTES \ | |
94 | (SEP_SHA256_DIGEST_SIZE_WORDS * sizeof(u32)) | |
95 | #define SEP_SHA384_DIGEST_SIZE_WORDS 12 | |
96 | #define SEP_SHA384_DIGEST_SIZE_BYTES \ | |
97 | (SEP_SHA384_DIGEST_SIZE_WORDS * sizeof(u32)) | |
98 | #define SEP_SHA512_DIGEST_SIZE_WORDS 16 | |
99 | #define SEP_SHA512_DIGEST_SIZE_BYTES \ | |
100 | (SEP_SHA512_DIGEST_SIZE_WORDS * sizeof(u32)) | |
101 | #define SEP_HASH_BLOCK_SIZE_WORDS 16 | |
102 | #define SEP_HASH_BLOCK_SIZE_BYTES \ | |
103 | (SEP_HASH_BLOCK_SIZE_WORDS * sizeof(u32)) | |
104 | #define SEP_SHA2_BLOCK_SIZE_WORDS 32 | |
105 | #define SEP_SHA2_BLOCK_SIZE_BYTES \ | |
106 | (SEP_SHA2_BLOCK_SIZE_WORDS * sizeof(u32)) | |
107 | ||
108 | #define SEP_HASH_INIT_OPCODE 0x20 | |
109 | #define SEP_HASH_UPDATE_OPCODE 0x21 | |
110 | #define SEP_HASH_FINISH_OPCODE 0x22 | |
111 | #define SEP_HASH_SINGLE_OPCODE 0x23 | |
112 | ||
113 | #define SEP_HOST_ERROR 0x0b000000 | |
114 | #define SEP_OK 0x0 | |
115 | #define SEP_INVALID_START (SEP_HOST_ERROR + 0x3) | |
116 | #define SEP_WRONG_OPCODE (SEP_HOST_ERROR + 0x1) | |
117 | ||
118 | #define SEP_TRANSACTION_WAIT_TIME 5 | |
119 | ||
9196dc11 | 120 | #define SEP_QUEUE_LENGTH 2 |
ff3d9c3c MA |
121 | /* Macros */ |
122 | #ifndef __LITTLE_ENDIAN | |
123 | #define CHG_ENDIAN(val) \ | |
124 | (((val) >> 24) | \ | |
125 | (((val) & 0x00FF0000) >> 8) | \ | |
126 | (((val) & 0x0000FF00) << 8) | \ | |
127 | (((val) & 0x000000FF) << 24)) | |
128 | #else | |
129 | #define CHG_ENDIAN(val) val | |
130 | #endif | |
131 | /* Enums for SEP (from vendor) */ | |
132 | enum des_numkey { | |
133 | DES_KEY_1 = 1, | |
134 | DES_KEY_2 = 2, | |
135 | DES_KEY_3 = 3, | |
136 | SEP_NUMKEY_OPTIONS, | |
137 | SEP_NUMKEY_LAST = 0x7fffffff, | |
138 | }; | |
139 | ||
140 | enum des_enc_mode { | |
141 | SEP_DES_ENCRYPT = 0, | |
142 | SEP_DES_DECRYPT = 1, | |
143 | SEP_DES_ENC_OPTIONS, | |
144 | SEP_DES_ENC_LAST = 0x7fffffff, | |
145 | }; | |
146 | ||
147 | enum des_op_mode { | |
148 | SEP_DES_ECB = 0, | |
149 | SEP_DES_CBC = 1, | |
150 | SEP_OP_OPTIONS, | |
151 | SEP_OP_LAST = 0x7fffffff, | |
152 | }; | |
153 | ||
154 | enum aes_keysize { | |
155 | AES_128 = 0, | |
156 | AES_192 = 1, | |
157 | AES_256 = 2, | |
158 | AES_512 = 3, | |
159 | AES_SIZE_OPTIONS, | |
160 | AEA_SIZE_LAST = 0x7FFFFFFF, | |
161 | }; | |
162 | ||
163 | enum aes_enc_mode { | |
164 | SEP_AES_ENCRYPT = 0, | |
165 | SEP_AES_DECRYPT = 1, | |
166 | SEP_AES_ENC_OPTIONS, | |
167 | SEP_AES_ENC_LAST = 0x7FFFFFFF, | |
168 | }; | |
169 | ||
170 | enum aes_op_mode { | |
171 | SEP_AES_ECB = 0, | |
172 | SEP_AES_CBC = 1, | |
173 | SEP_AES_MAC = 2, | |
174 | SEP_AES_CTR = 3, | |
175 | SEP_AES_XCBC = 4, | |
176 | SEP_AES_CMAC = 5, | |
177 | SEP_AES_XTS = 6, | |
178 | SEP_AES_OP_OPTIONS, | |
179 | SEP_AES_OP_LAST = 0x7FFFFFFF, | |
180 | }; | |
181 | ||
182 | enum hash_op_mode { | |
183 | SEP_HASH_SHA1 = 0, | |
184 | SEP_HASH_SHA224 = 1, | |
185 | SEP_HASH_SHA256 = 2, | |
186 | SEP_HASH_SHA384 = 3, | |
187 | SEP_HASH_SHA512 = 4, | |
188 | SEP_HASH_MD5 = 5, | |
189 | SEP_HASH_OPTIONS, | |
190 | SEP_HASH_LAST_MODE = 0x7FFFFFFF, | |
191 | }; | |
192 | ||
193 | /* Structures for SEP (from vendor) */ | |
194 | struct sep_des_internal_key { | |
195 | u32 key1[SEP_DES_KEY_SIZE_WORDS]; | |
196 | u32 key2[SEP_DES_KEY_SIZE_WORDS]; | |
197 | u32 key3[SEP_DES_KEY_SIZE_WORDS]; | |
198 | }; | |
199 | ||
200 | struct sep_des_internal_context { | |
201 | u32 iv_context[SEP_DES_IV_SIZE_WORDS]; | |
202 | struct sep_des_internal_key context_key; | |
203 | enum des_numkey nbr_keys; | |
204 | enum des_enc_mode encryption; | |
205 | enum des_op_mode operation; | |
206 | u8 dummy_block[SEP_DES_DUMMY_SIZE]; | |
207 | }; | |
208 | ||
209 | struct sep_des_private_context { | |
210 | u32 valid_tag; | |
211 | u32 iv; | |
212 | u8 ctx_buf[sizeof(struct sep_des_internal_context)]; | |
213 | }; | |
214 | ||
215 | /* This is the structure passed to SEP via msg area */ | |
216 | struct sep_des_key { | |
217 | u32 key1[SEP_DES_KEY_SIZE_WORDS]; | |
218 | u32 key2[SEP_DES_KEY_SIZE_WORDS]; | |
219 | u32 key3[SEP_DES_KEY_SIZE_WORDS]; | |
220 | u32 pad[SEP_DES_KEY_SIZE_WORDS]; | |
221 | }; | |
222 | ||
223 | struct sep_aes_internal_context { | |
224 | u32 aes_ctx_iv[SEP_AES_IV_SIZE_WORDS]; | |
225 | u32 aes_ctx_key[SEP_AES_MAX_KEY_SIZE_WORDS / 2]; | |
226 | enum aes_keysize keysize; | |
227 | enum aes_enc_mode encmode; | |
228 | enum aes_op_mode opmode; | |
229 | u8 secret_key; | |
230 | u32 no_add_blocks; | |
231 | u32 last_block_size; | |
232 | u32 last_block[SEP_AES_BLOCK_SIZE_WORDS]; | |
233 | u32 prev_iv[SEP_AES_BLOCK_SIZE_WORDS]; | |
234 | u32 remaining_size; | |
235 | union { | |
236 | struct { | |
237 | u32 dkey1[SEP_AES_BLOCK_SIZE_WORDS]; | |
238 | u32 dkey2[SEP_AES_BLOCK_SIZE_WORDS]; | |
239 | u32 dkey3[SEP_AES_BLOCK_SIZE_WORDS]; | |
240 | } cmac_data; | |
241 | struct { | |
242 | u32 xts_key[SEP_AES_MAX_KEY_SIZE_WORDS / 2]; | |
243 | u32 temp1[SEP_AES_BLOCK_SIZE_WORDS]; | |
244 | u32 temp2[SEP_AES_BLOCK_SIZE_WORDS]; | |
245 | } xtx_data; | |
246 | } s_data; | |
247 | u8 dummy_block[SEP_AES_DUMMY_BLOCK_SIZE]; | |
248 | }; | |
249 | ||
250 | struct sep_aes_private_context { | |
251 | u32 valid_tag; | |
252 | u32 aes_iv; | |
253 | u32 op_mode; | |
254 | u8 cbuff[sizeof(struct sep_aes_internal_context)]; | |
255 | }; | |
256 | ||
257 | struct sep_hash_internal_context { | |
258 | u32 hash_result[SEP_HASH_RESULT_SIZE_WORDS]; | |
259 | enum hash_op_mode hash_opmode; | |
260 | u32 previous_data[SEP_SHA2_BLOCK_SIZE_WORDS]; | |
261 | u16 prev_update_bytes; | |
262 | u32 total_proc_128bit[4]; | |
263 | u16 op_mode_block_size; | |
264 | u8 dummy_aes_block[SEP_AES_DUMMY_BLOCK_SIZE]; | |
265 | }; | |
266 | ||
267 | struct sep_hash_private_context { | |
268 | u32 valid_tag; | |
269 | u32 iv; | |
270 | u8 internal_context[sizeof(struct sep_hash_internal_context)]; | |
271 | }; | |
272 | ||
9196dc11 MA |
273 | union key_t { |
274 | struct sep_des_key des; | |
275 | u32 aes[SEP_AES_MAX_KEY_SIZE_WORDS]; | |
276 | }; | |
277 | ||
ff3d9c3c | 278 | /* Context structures for crypto API */ |
9196dc11 MA |
279 | /** |
280 | * Structure for this current task context | |
281 | * This same structure is used for both hash | |
282 | * and crypt in order to reduce duplicate code | |
283 | * for stuff that is done for both hash operations | |
284 | * and crypto operations. We cannot trust that the | |
285 | * system context is not pulled out from under | |
286 | * us during operation to operation, so all | |
287 | * critical stuff such as data pointers must | |
288 | * be in in a context that is exclusive for this | |
289 | * particular task at hand. | |
290 | */ | |
291 | struct this_task_ctx { | |
292 | struct sep_device *sep_used; | |
ff3d9c3c MA |
293 | u32 done; |
294 | unsigned char iv[100]; | |
295 | enum des_enc_mode des_encmode; | |
296 | enum des_op_mode des_opmode; | |
297 | enum aes_enc_mode aes_encmode; | |
298 | enum aes_op_mode aes_opmode; | |
299 | u32 init_opcode; | |
300 | u32 block_opcode; | |
301 | size_t data_length; | |
302 | size_t ivlen; | |
303 | struct ablkcipher_walk walk; | |
ff3d9c3c | 304 | int i_own_sep; /* Do I have custody of the sep? */ |
ff3d9c3c MA |
305 | struct sep_call_status call_status; |
306 | struct build_dcb_struct_kernel dcb_input_data; | |
307 | struct sep_dma_context *dma_ctx; | |
308 | void *dmatables_region; | |
309 | size_t nbytes; | |
310 | struct sep_dcblock *dcb_region; | |
311 | struct sep_queue_info *queue_elem; | |
312 | int msg_len_words; | |
313 | unsigned char msg[SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES]; | |
314 | void *msgptr; | |
315 | struct scatterlist *src_sg; | |
316 | struct scatterlist *dst_sg; | |
317 | struct scatterlist *src_sg_hold; | |
318 | struct scatterlist *dst_sg_hold; | |
319 | struct ahash_request *current_hash_req; | |
320 | struct ablkcipher_request *current_cypher_req; | |
321 | enum type_of_request current_request; | |
9196dc11 MA |
322 | int digest_size_words; |
323 | int digest_size_bytes; | |
324 | int block_size_words; | |
325 | int block_size_bytes; | |
326 | enum hash_op_mode hash_opmode; | |
ff3d9c3c | 327 | enum hash_stage current_hash_stage; |
9196dc11 MA |
328 | /** |
329 | * Not that this is a pointer. The are_we_done_yet variable is | |
330 | * allocated by the task function. This way, even if the kernel | |
331 | * crypto infrastructure has grabbed the task structure out from | |
332 | * under us, the task function can still see this variable. | |
333 | */ | |
334 | int *are_we_done_yet; | |
335 | unsigned long end_time; | |
336 | }; | |
337 | ||
338 | struct sep_system_ctx { | |
339 | union key_t key; | |
340 | size_t keylen; | |
341 | int key_sent; | |
342 | enum des_numkey des_nbr_keys; | |
343 | enum aes_keysize aes_key_size; | |
ff3d9c3c | 344 | unsigned long end_time; |
9196dc11 MA |
345 | struct sep_des_private_context des_private_ctx; |
346 | struct sep_aes_private_context aes_private_ctx; | |
347 | struct sep_hash_private_context hash_private_ctx; | |
ff3d9c3c MA |
348 | }; |
349 | ||
350 | /* work queue structures */ | |
351 | struct sep_work_struct { | |
352 | struct work_struct work; | |
353 | void (*callback)(void *); | |
354 | void *data; | |
355 | }; | |
356 | ||
357 | /* Functions */ | |
358 | int sep_crypto_setup(void); | |
359 | void sep_crypto_takedown(void); |