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 120 #define SEP_QUEUE_LENGTH 2 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 273 union key_t { 274 struct sep_des_key des; 275 u32 aes[SEP_AES_MAX_KEY_SIZE_WORDS]; 276 }; 277 278 /* Context structures for crypto API */ 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; 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; 304 int i_own_sep; /* Do I have custody of the sep? */ 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; 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; 327 enum hash_stage current_hash_stage; 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; 344 unsigned long end_time; 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; 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); 360