1 /* 2 * Copyright 2016 Broadcom 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, version 2, as 6 * published by the Free Software Foundation (the "GPL"). 7 * 8 * This program is distributed in the hope that it will be useful, but 9 * WITHOUT ANY WARRANTY; without even the implied warranty of 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 11 * General Public License version 2 (GPLv2) for more details. 12 * 13 * You should have received a copy of the GNU General Public License 14 * version 2 (GPLv2) along with this source code. 15 */ 16 17 /* 18 * This file works with the SPU2 version of the SPU. SPU2 has different message 19 * formats than the previous version of the SPU. All SPU message format 20 * differences should be hidden in the spux.c,h files. 21 */ 22 23 #include <linux/kernel.h> 24 #include <linux/string.h> 25 26 #include "util.h" 27 #include "spu.h" 28 #include "spu2.h" 29 30 #define SPU2_TX_STATUS_LEN 0 /* SPU2 has no STATUS in input packet */ 31 32 /* 33 * Controlled by pkt_stat_cnt field in CRYPTO_SS_SPU0_CORE_SPU2_CONTROL0 34 * register. Defaults to 2. 35 */ 36 #define SPU2_RX_STATUS_LEN 2 37 38 enum spu2_proto_sel { 39 SPU2_PROTO_RESV = 0, 40 SPU2_MACSEC_SECTAG8_ECB = 1, 41 SPU2_MACSEC_SECTAG8_SCB = 2, 42 SPU2_MACSEC_SECTAG16 = 3, 43 SPU2_MACSEC_SECTAG16_8_XPN = 4, 44 SPU2_IPSEC = 5, 45 SPU2_IPSEC_ESN = 6, 46 SPU2_TLS_CIPHER = 7, 47 SPU2_TLS_AEAD = 8, 48 SPU2_DTLS_CIPHER = 9, 49 SPU2_DTLS_AEAD = 10 50 }; 51 52 char *spu2_cipher_type_names[] = { "None", "AES128", "AES192", "AES256", 53 "DES", "3DES" 54 }; 55 56 char *spu2_cipher_mode_names[] = { "ECB", "CBC", "CTR", "CFB", "OFB", "XTS", 57 "CCM", "GCM" 58 }; 59 60 char *spu2_hash_type_names[] = { "None", "AES128", "AES192", "AES256", 61 "Reserved", "Reserved", "MD5", "SHA1", "SHA224", "SHA256", "SHA384", 62 "SHA512", "SHA512/224", "SHA512/256", "SHA3-224", "SHA3-256", 63 "SHA3-384", "SHA3-512" 64 }; 65 66 char *spu2_hash_mode_names[] = { "CMAC", "CBC-MAC", "XCBC-MAC", "HMAC", 67 "Rabin", "CCM", "GCM", "Reserved" 68 }; 69 70 static char *spu2_ciph_type_name(enum spu2_cipher_type cipher_type) 71 { 72 if (cipher_type >= SPU2_CIPHER_TYPE_LAST) 73 return "Reserved"; 74 return spu2_cipher_type_names[cipher_type]; 75 } 76 77 static char *spu2_ciph_mode_name(enum spu2_cipher_mode cipher_mode) 78 { 79 if (cipher_mode >= SPU2_CIPHER_MODE_LAST) 80 return "Reserved"; 81 return spu2_cipher_mode_names[cipher_mode]; 82 } 83 84 static char *spu2_hash_type_name(enum spu2_hash_type hash_type) 85 { 86 if (hash_type >= SPU2_HASH_TYPE_LAST) 87 return "Reserved"; 88 return spu2_hash_type_names[hash_type]; 89 } 90 91 static char *spu2_hash_mode_name(enum spu2_hash_mode hash_mode) 92 { 93 if (hash_mode >= SPU2_HASH_MODE_LAST) 94 return "Reserved"; 95 return spu2_hash_mode_names[hash_mode]; 96 } 97 98 /* 99 * Convert from a software cipher mode value to the corresponding value 100 * for SPU2. 101 */ 102 static int spu2_cipher_mode_xlate(enum spu_cipher_mode cipher_mode, 103 enum spu2_cipher_mode *spu2_mode) 104 { 105 switch (cipher_mode) { 106 case CIPHER_MODE_ECB: 107 *spu2_mode = SPU2_CIPHER_MODE_ECB; 108 break; 109 case CIPHER_MODE_CBC: 110 *spu2_mode = SPU2_CIPHER_MODE_CBC; 111 break; 112 case CIPHER_MODE_OFB: 113 *spu2_mode = SPU2_CIPHER_MODE_OFB; 114 break; 115 case CIPHER_MODE_CFB: 116 *spu2_mode = SPU2_CIPHER_MODE_CFB; 117 break; 118 case CIPHER_MODE_CTR: 119 *spu2_mode = SPU2_CIPHER_MODE_CTR; 120 break; 121 case CIPHER_MODE_CCM: 122 *spu2_mode = SPU2_CIPHER_MODE_CCM; 123 break; 124 case CIPHER_MODE_GCM: 125 *spu2_mode = SPU2_CIPHER_MODE_GCM; 126 break; 127 case CIPHER_MODE_XTS: 128 *spu2_mode = SPU2_CIPHER_MODE_XTS; 129 break; 130 default: 131 return -EINVAL; 132 } 133 return 0; 134 } 135 136 /** 137 * spu2_cipher_xlate() - Convert a cipher {alg/mode/type} triple to a SPU2 138 * cipher type and mode. 139 * @cipher_alg: [in] cipher algorithm value from software enumeration 140 * @cipher_mode: [in] cipher mode value from software enumeration 141 * @cipher_type: [in] cipher type value from software enumeration 142 * @spu2_type: [out] cipher type value used by spu2 hardware 143 * @spu2_mode: [out] cipher mode value used by spu2 hardware 144 * 145 * Return: 0 if successful 146 */ 147 static int spu2_cipher_xlate(enum spu_cipher_alg cipher_alg, 148 enum spu_cipher_mode cipher_mode, 149 enum spu_cipher_type cipher_type, 150 enum spu2_cipher_type *spu2_type, 151 enum spu2_cipher_mode *spu2_mode) 152 { 153 int err; 154 155 err = spu2_cipher_mode_xlate(cipher_mode, spu2_mode); 156 if (err) { 157 flow_log("Invalid cipher mode %d\n", cipher_mode); 158 return err; 159 } 160 161 switch (cipher_alg) { 162 case CIPHER_ALG_NONE: 163 *spu2_type = SPU2_CIPHER_TYPE_NONE; 164 break; 165 case CIPHER_ALG_RC4: 166 /* SPU2 does not support RC4 */ 167 err = -EINVAL; 168 *spu2_type = SPU2_CIPHER_TYPE_NONE; 169 break; 170 case CIPHER_ALG_DES: 171 *spu2_type = SPU2_CIPHER_TYPE_DES; 172 break; 173 case CIPHER_ALG_3DES: 174 *spu2_type = SPU2_CIPHER_TYPE_3DES; 175 break; 176 case CIPHER_ALG_AES: 177 switch (cipher_type) { 178 case CIPHER_TYPE_AES128: 179 *spu2_type = SPU2_CIPHER_TYPE_AES128; 180 break; 181 case CIPHER_TYPE_AES192: 182 *spu2_type = SPU2_CIPHER_TYPE_AES192; 183 break; 184 case CIPHER_TYPE_AES256: 185 *spu2_type = SPU2_CIPHER_TYPE_AES256; 186 break; 187 default: 188 err = -EINVAL; 189 } 190 break; 191 case CIPHER_ALG_LAST: 192 default: 193 err = -EINVAL; 194 break; 195 } 196 197 if (err) 198 flow_log("Invalid cipher alg %d or type %d\n", 199 cipher_alg, cipher_type); 200 return err; 201 } 202 203 /* 204 * Convert from a software hash mode value to the corresponding value 205 * for SPU2. Note that HASH_MODE_NONE and HASH_MODE_XCBC have the same value. 206 */ 207 static int spu2_hash_mode_xlate(enum hash_mode hash_mode, 208 enum spu2_hash_mode *spu2_mode) 209 { 210 switch (hash_mode) { 211 case HASH_MODE_XCBC: 212 *spu2_mode = SPU2_HASH_MODE_XCBC_MAC; 213 break; 214 case HASH_MODE_CMAC: 215 *spu2_mode = SPU2_HASH_MODE_CMAC; 216 break; 217 case HASH_MODE_HMAC: 218 *spu2_mode = SPU2_HASH_MODE_HMAC; 219 break; 220 case HASH_MODE_CCM: 221 *spu2_mode = SPU2_HASH_MODE_CCM; 222 break; 223 case HASH_MODE_GCM: 224 *spu2_mode = SPU2_HASH_MODE_GCM; 225 break; 226 default: 227 return -EINVAL; 228 } 229 return 0; 230 } 231 232 /** 233 * spu2_hash_xlate() - Convert a hash {alg/mode/type} triple to a SPU2 hash type 234 * and mode. 235 * @hash_alg: [in] hash algorithm value from software enumeration 236 * @hash_mode: [in] hash mode value from software enumeration 237 * @hash_type: [in] hash type value from software enumeration 238 * @ciph_type: [in] cipher type value from software enumeration 239 * @spu2_type: [out] hash type value used by SPU2 hardware 240 * @spu2_mode: [out] hash mode value used by SPU2 hardware 241 * 242 * Return: 0 if successful 243 */ 244 static int 245 spu2_hash_xlate(enum hash_alg hash_alg, enum hash_mode hash_mode, 246 enum hash_type hash_type, enum spu_cipher_type ciph_type, 247 enum spu2_hash_type *spu2_type, enum spu2_hash_mode *spu2_mode) 248 { 249 int err; 250 251 err = spu2_hash_mode_xlate(hash_mode, spu2_mode); 252 if (err) { 253 flow_log("Invalid hash mode %d\n", hash_mode); 254 return err; 255 } 256 257 switch (hash_alg) { 258 case HASH_ALG_NONE: 259 *spu2_type = SPU2_HASH_TYPE_NONE; 260 break; 261 case HASH_ALG_MD5: 262 *spu2_type = SPU2_HASH_TYPE_MD5; 263 break; 264 case HASH_ALG_SHA1: 265 *spu2_type = SPU2_HASH_TYPE_SHA1; 266 break; 267 case HASH_ALG_SHA224: 268 *spu2_type = SPU2_HASH_TYPE_SHA224; 269 break; 270 case HASH_ALG_SHA256: 271 *spu2_type = SPU2_HASH_TYPE_SHA256; 272 break; 273 case HASH_ALG_SHA384: 274 *spu2_type = SPU2_HASH_TYPE_SHA384; 275 break; 276 case HASH_ALG_SHA512: 277 *spu2_type = SPU2_HASH_TYPE_SHA512; 278 break; 279 case HASH_ALG_AES: 280 switch (ciph_type) { 281 case CIPHER_TYPE_AES128: 282 *spu2_type = SPU2_HASH_TYPE_AES128; 283 break; 284 case CIPHER_TYPE_AES192: 285 *spu2_type = SPU2_HASH_TYPE_AES192; 286 break; 287 case CIPHER_TYPE_AES256: 288 *spu2_type = SPU2_HASH_TYPE_AES256; 289 break; 290 default: 291 err = -EINVAL; 292 } 293 break; 294 case HASH_ALG_SHA3_224: 295 *spu2_type = SPU2_HASH_TYPE_SHA3_224; 296 break; 297 case HASH_ALG_SHA3_256: 298 *spu2_type = SPU2_HASH_TYPE_SHA3_256; 299 break; 300 case HASH_ALG_SHA3_384: 301 *spu2_type = SPU2_HASH_TYPE_SHA3_384; 302 break; 303 case HASH_ALG_SHA3_512: 304 *spu2_type = SPU2_HASH_TYPE_SHA3_512; 305 break; 306 case HASH_ALG_LAST: 307 default: 308 err = -EINVAL; 309 break; 310 } 311 312 if (err) 313 flow_log("Invalid hash alg %d or type %d\n", 314 hash_alg, hash_type); 315 return err; 316 } 317 318 /* Dump FMD ctrl0. The ctrl0 input is in host byte order */ 319 static void spu2_dump_fmd_ctrl0(u64 ctrl0) 320 { 321 enum spu2_cipher_type ciph_type; 322 enum spu2_cipher_mode ciph_mode; 323 enum spu2_hash_type hash_type; 324 enum spu2_hash_mode hash_mode; 325 char *ciph_name; 326 char *ciph_mode_name; 327 char *hash_name; 328 char *hash_mode_name; 329 u8 cfb; 330 u8 proto; 331 332 packet_log(" FMD CTRL0 %#16llx\n", ctrl0); 333 if (ctrl0 & SPU2_CIPH_ENCRYPT_EN) 334 packet_log(" encrypt\n"); 335 else 336 packet_log(" decrypt\n"); 337 338 ciph_type = (ctrl0 & SPU2_CIPH_TYPE) >> SPU2_CIPH_TYPE_SHIFT; 339 ciph_name = spu2_ciph_type_name(ciph_type); 340 packet_log(" Cipher type: %s\n", ciph_name); 341 342 if (ciph_type != SPU2_CIPHER_TYPE_NONE) { 343 ciph_mode = (ctrl0 & SPU2_CIPH_MODE) >> SPU2_CIPH_MODE_SHIFT; 344 ciph_mode_name = spu2_ciph_mode_name(ciph_mode); 345 packet_log(" Cipher mode: %s\n", ciph_mode_name); 346 } 347 348 cfb = (ctrl0 & SPU2_CFB_MASK) >> SPU2_CFB_MASK_SHIFT; 349 packet_log(" CFB %#x\n", cfb); 350 351 proto = (ctrl0 & SPU2_PROTO_SEL) >> SPU2_PROTO_SEL_SHIFT; 352 packet_log(" protocol %#x\n", proto); 353 354 if (ctrl0 & SPU2_HASH_FIRST) 355 packet_log(" hash first\n"); 356 else 357 packet_log(" cipher first\n"); 358 359 if (ctrl0 & SPU2_CHK_TAG) 360 packet_log(" check tag\n"); 361 362 hash_type = (ctrl0 & SPU2_HASH_TYPE) >> SPU2_HASH_TYPE_SHIFT; 363 hash_name = spu2_hash_type_name(hash_type); 364 packet_log(" Hash type: %s\n", hash_name); 365 366 if (hash_type != SPU2_HASH_TYPE_NONE) { 367 hash_mode = (ctrl0 & SPU2_HASH_MODE) >> SPU2_HASH_MODE_SHIFT; 368 hash_mode_name = spu2_hash_mode_name(hash_mode); 369 packet_log(" Hash mode: %s\n", hash_mode_name); 370 } 371 372 if (ctrl0 & SPU2_CIPH_PAD_EN) { 373 packet_log(" Cipher pad: %#2llx\n", 374 (ctrl0 & SPU2_CIPH_PAD) >> SPU2_CIPH_PAD_SHIFT); 375 } 376 } 377 378 /* Dump FMD ctrl1. The ctrl1 input is in host byte order */ 379 static void spu2_dump_fmd_ctrl1(u64 ctrl1) 380 { 381 u8 hash_key_len; 382 u8 ciph_key_len; 383 u8 ret_iv_len; 384 u8 iv_offset; 385 u8 iv_len; 386 u8 hash_tag_len; 387 u8 ret_md; 388 389 packet_log(" FMD CTRL1 %#16llx\n", ctrl1); 390 if (ctrl1 & SPU2_TAG_LOC) 391 packet_log(" Tag after payload\n"); 392 393 packet_log(" Msg includes "); 394 if (ctrl1 & SPU2_HAS_FR_DATA) 395 packet_log("FD "); 396 if (ctrl1 & SPU2_HAS_AAD1) 397 packet_log("AAD1 "); 398 if (ctrl1 & SPU2_HAS_NAAD) 399 packet_log("NAAD "); 400 if (ctrl1 & SPU2_HAS_AAD2) 401 packet_log("AAD2 "); 402 if (ctrl1 & SPU2_HAS_ESN) 403 packet_log("ESN "); 404 packet_log("\n"); 405 406 hash_key_len = (ctrl1 & SPU2_HASH_KEY_LEN) >> SPU2_HASH_KEY_LEN_SHIFT; 407 packet_log(" Hash key len %u\n", hash_key_len); 408 409 ciph_key_len = (ctrl1 & SPU2_CIPH_KEY_LEN) >> SPU2_CIPH_KEY_LEN_SHIFT; 410 packet_log(" Cipher key len %u\n", ciph_key_len); 411 412 if (ctrl1 & SPU2_GENIV) 413 packet_log(" Generate IV\n"); 414 415 if (ctrl1 & SPU2_HASH_IV) 416 packet_log(" IV included in hash\n"); 417 418 if (ctrl1 & SPU2_RET_IV) 419 packet_log(" Return IV in output before payload\n"); 420 421 ret_iv_len = (ctrl1 & SPU2_RET_IV_LEN) >> SPU2_RET_IV_LEN_SHIFT; 422 packet_log(" Length of returned IV %u bytes\n", 423 ret_iv_len ? ret_iv_len : 16); 424 425 iv_offset = (ctrl1 & SPU2_IV_OFFSET) >> SPU2_IV_OFFSET_SHIFT; 426 packet_log(" IV offset %u\n", iv_offset); 427 428 iv_len = (ctrl1 & SPU2_IV_LEN) >> SPU2_IV_LEN_SHIFT; 429 packet_log(" Input IV len %u bytes\n", iv_len); 430 431 hash_tag_len = (ctrl1 & SPU2_HASH_TAG_LEN) >> SPU2_HASH_TAG_LEN_SHIFT; 432 packet_log(" Hash tag length %u bytes\n", hash_tag_len); 433 434 packet_log(" Return "); 435 ret_md = (ctrl1 & SPU2_RETURN_MD) >> SPU2_RETURN_MD_SHIFT; 436 if (ret_md) 437 packet_log("FMD "); 438 if (ret_md == SPU2_RET_FMD_OMD) 439 packet_log("OMD "); 440 else if (ret_md == SPU2_RET_FMD_OMD_IV) 441 packet_log("OMD IV "); 442 if (ctrl1 & SPU2_RETURN_FD) 443 packet_log("FD "); 444 if (ctrl1 & SPU2_RETURN_AAD1) 445 packet_log("AAD1 "); 446 if (ctrl1 & SPU2_RETURN_NAAD) 447 packet_log("NAAD "); 448 if (ctrl1 & SPU2_RETURN_AAD2) 449 packet_log("AAD2 "); 450 if (ctrl1 & SPU2_RETURN_PAY) 451 packet_log("Payload"); 452 packet_log("\n"); 453 } 454 455 /* Dump FMD ctrl2. The ctrl2 input is in host byte order */ 456 static void spu2_dump_fmd_ctrl2(u64 ctrl2) 457 { 458 packet_log(" FMD CTRL2 %#16llx\n", ctrl2); 459 460 packet_log(" AAD1 offset %llu length %llu bytes\n", 461 ctrl2 & SPU2_AAD1_OFFSET, 462 (ctrl2 & SPU2_AAD1_LEN) >> SPU2_AAD1_LEN_SHIFT); 463 packet_log(" AAD2 offset %llu\n", 464 (ctrl2 & SPU2_AAD2_OFFSET) >> SPU2_AAD2_OFFSET_SHIFT); 465 packet_log(" Payload offset %llu\n", 466 (ctrl2 & SPU2_PL_OFFSET) >> SPU2_PL_OFFSET_SHIFT); 467 } 468 469 /* Dump FMD ctrl3. The ctrl3 input is in host byte order */ 470 static void spu2_dump_fmd_ctrl3(u64 ctrl3) 471 { 472 packet_log(" FMD CTRL3 %#16llx\n", ctrl3); 473 474 packet_log(" Payload length %llu bytes\n", ctrl3 & SPU2_PL_LEN); 475 packet_log(" TLS length %llu bytes\n", 476 (ctrl3 & SPU2_TLS_LEN) >> SPU2_TLS_LEN_SHIFT); 477 } 478 479 static void spu2_dump_fmd(struct SPU2_FMD *fmd) 480 { 481 spu2_dump_fmd_ctrl0(le64_to_cpu(fmd->ctrl0)); 482 spu2_dump_fmd_ctrl1(le64_to_cpu(fmd->ctrl1)); 483 spu2_dump_fmd_ctrl2(le64_to_cpu(fmd->ctrl2)); 484 spu2_dump_fmd_ctrl3(le64_to_cpu(fmd->ctrl3)); 485 } 486 487 static void spu2_dump_omd(u8 *omd, u16 hash_key_len, u16 ciph_key_len, 488 u16 hash_iv_len, u16 ciph_iv_len) 489 { 490 u8 *ptr = omd; 491 492 packet_log(" OMD:\n"); 493 494 if (hash_key_len) { 495 packet_log(" Hash Key Length %u bytes\n", hash_key_len); 496 packet_dump(" KEY: ", ptr, hash_key_len); 497 ptr += hash_key_len; 498 } 499 500 if (ciph_key_len) { 501 packet_log(" Cipher Key Length %u bytes\n", ciph_key_len); 502 packet_dump(" KEY: ", ptr, ciph_key_len); 503 ptr += ciph_key_len; 504 } 505 506 if (hash_iv_len) { 507 packet_log(" Hash IV Length %u bytes\n", hash_iv_len); 508 packet_dump(" hash IV: ", ptr, hash_iv_len); 509 ptr += ciph_key_len; 510 } 511 512 if (ciph_iv_len) { 513 packet_log(" Cipher IV Length %u bytes\n", ciph_iv_len); 514 packet_dump(" cipher IV: ", ptr, ciph_iv_len); 515 } 516 } 517 518 /* Dump a SPU2 header for debug */ 519 void spu2_dump_msg_hdr(u8 *buf, unsigned int buf_len) 520 { 521 struct SPU2_FMD *fmd = (struct SPU2_FMD *)buf; 522 u8 *omd; 523 u64 ctrl1; 524 u16 hash_key_len; 525 u16 ciph_key_len; 526 u16 hash_iv_len; 527 u16 ciph_iv_len; 528 u16 omd_len; 529 530 packet_log("\n"); 531 packet_log("SPU2 message header %p len: %u\n", buf, buf_len); 532 533 spu2_dump_fmd(fmd); 534 omd = (u8 *)(fmd + 1); 535 536 ctrl1 = le64_to_cpu(fmd->ctrl1); 537 hash_key_len = (ctrl1 & SPU2_HASH_KEY_LEN) >> SPU2_HASH_KEY_LEN_SHIFT; 538 ciph_key_len = (ctrl1 & SPU2_CIPH_KEY_LEN) >> SPU2_CIPH_KEY_LEN_SHIFT; 539 hash_iv_len = 0; 540 ciph_iv_len = (ctrl1 & SPU2_IV_LEN) >> SPU2_IV_LEN_SHIFT; 541 spu2_dump_omd(omd, hash_key_len, ciph_key_len, hash_iv_len, 542 ciph_iv_len); 543 544 /* Double check sanity */ 545 omd_len = hash_key_len + ciph_key_len + hash_iv_len + ciph_iv_len; 546 if (FMD_SIZE + omd_len != buf_len) { 547 packet_log 548 (" Packet parsed incorrectly. buf_len %u, sum of MD %zu\n", 549 buf_len, FMD_SIZE + omd_len); 550 } 551 packet_log("\n"); 552 } 553 554 /** 555 * spu2_fmd_init() - At setkey time, initialize the fixed meta data for 556 * subsequent ablkcipher requests for this context. 557 * @spu2_cipher_type: Cipher algorithm 558 * @spu2_mode: Cipher mode 559 * @cipher_key_len: Length of cipher key, in bytes 560 * @cipher_iv_len: Length of cipher initialization vector, in bytes 561 * 562 * Return: 0 (success) 563 */ 564 static int spu2_fmd_init(struct SPU2_FMD *fmd, 565 enum spu2_cipher_type spu2_type, 566 enum spu2_cipher_mode spu2_mode, 567 u32 cipher_key_len, u32 cipher_iv_len) 568 { 569 u64 ctrl0; 570 u64 ctrl1; 571 u64 ctrl2; 572 u64 ctrl3; 573 u32 aad1_offset; 574 u32 aad2_offset; 575 u16 aad1_len = 0; 576 u64 payload_offset; 577 578 ctrl0 = (spu2_type << SPU2_CIPH_TYPE_SHIFT) | 579 (spu2_mode << SPU2_CIPH_MODE_SHIFT); 580 581 ctrl1 = (cipher_key_len << SPU2_CIPH_KEY_LEN_SHIFT) | 582 ((u64)cipher_iv_len << SPU2_IV_LEN_SHIFT) | 583 ((u64)SPU2_RET_FMD_ONLY << SPU2_RETURN_MD_SHIFT) | SPU2_RETURN_PAY; 584 585 /* 586 * AAD1 offset is from start of FD. FD length is always 0 for this 587 * driver. So AAD1_offset is always 0. 588 */ 589 aad1_offset = 0; 590 aad2_offset = aad1_offset; 591 payload_offset = 0; 592 ctrl2 = aad1_offset | 593 (aad1_len << SPU2_AAD1_LEN_SHIFT) | 594 (aad2_offset << SPU2_AAD2_OFFSET_SHIFT) | 595 (payload_offset << SPU2_PL_OFFSET_SHIFT); 596 597 ctrl3 = 0; 598 599 fmd->ctrl0 = cpu_to_le64(ctrl0); 600 fmd->ctrl1 = cpu_to_le64(ctrl1); 601 fmd->ctrl2 = cpu_to_le64(ctrl2); 602 fmd->ctrl3 = cpu_to_le64(ctrl3); 603 604 return 0; 605 } 606 607 /** 608 * spu2_fmd_ctrl0_write() - Write ctrl0 field in fixed metadata (FMD) field of 609 * SPU request packet. 610 * @fmd: Start of FMD field to be written 611 * @is_inbound: true if decrypting. false if encrypting. 612 * @authFirst: true if alg authenticates before encrypting 613 * @protocol: protocol selector 614 * @cipher_type: cipher algorithm 615 * @cipher_mode: cipher mode 616 * @auth_type: authentication type 617 * @auth_mode: authentication mode 618 */ 619 static void spu2_fmd_ctrl0_write(struct SPU2_FMD *fmd, 620 bool is_inbound, bool auth_first, 621 enum spu2_proto_sel protocol, 622 enum spu2_cipher_type cipher_type, 623 enum spu2_cipher_mode cipher_mode, 624 enum spu2_hash_type auth_type, 625 enum spu2_hash_mode auth_mode) 626 { 627 u64 ctrl0 = 0; 628 629 if ((cipher_type != SPU2_CIPHER_TYPE_NONE) && !is_inbound) 630 ctrl0 |= SPU2_CIPH_ENCRYPT_EN; 631 632 ctrl0 |= ((u64)cipher_type << SPU2_CIPH_TYPE_SHIFT) | 633 ((u64)cipher_mode << SPU2_CIPH_MODE_SHIFT); 634 635 if (protocol) 636 ctrl0 |= (u64)protocol << SPU2_PROTO_SEL_SHIFT; 637 638 if (auth_first) 639 ctrl0 |= SPU2_HASH_FIRST; 640 641 if (is_inbound && (auth_type != SPU2_HASH_TYPE_NONE)) 642 ctrl0 |= SPU2_CHK_TAG; 643 644 ctrl0 |= (((u64)auth_type << SPU2_HASH_TYPE_SHIFT) | 645 ((u64)auth_mode << SPU2_HASH_MODE_SHIFT)); 646 647 fmd->ctrl0 = cpu_to_le64(ctrl0); 648 } 649 650 /** 651 * spu2_fmd_ctrl1_write() - Write ctrl1 field in fixed metadata (FMD) field of 652 * SPU request packet. 653 * @fmd: Start of FMD field to be written 654 * @assoc_size: Length of additional associated data, in bytes 655 * @auth_key_len: Length of authentication key, in bytes 656 * @cipher_key_len: Length of cipher key, in bytes 657 * @gen_iv: If true, hw generates IV and returns in response 658 * @hash_iv: IV participates in hash. Used for IPSEC and TLS. 659 * @return_iv: Return IV in output packet before payload 660 * @ret_iv_len: Length of IV returned from SPU, in bytes 661 * @ret_iv_offset: Offset into full IV of start of returned IV 662 * @cipher_iv_len: Length of input cipher IV, in bytes 663 * @digest_size: Length of digest (aka, hash tag or ICV), in bytes 664 * @return_payload: Return payload in SPU response 665 * @return_md : return metadata in SPU response 666 * 667 * Packet can have AAD2 w/o AAD1. For algorithms currently supported, 668 * associated data goes in AAD2. 669 */ 670 static void spu2_fmd_ctrl1_write(struct SPU2_FMD *fmd, bool is_inbound, 671 u64 assoc_size, 672 u64 auth_key_len, u64 cipher_key_len, 673 bool gen_iv, bool hash_iv, bool return_iv, 674 u64 ret_iv_len, u64 ret_iv_offset, 675 u64 cipher_iv_len, u64 digest_size, 676 bool return_payload, bool return_md) 677 { 678 u64 ctrl1 = 0; 679 680 if (is_inbound && digest_size) 681 ctrl1 |= SPU2_TAG_LOC; 682 683 if (assoc_size) { 684 ctrl1 |= SPU2_HAS_AAD2; 685 ctrl1 |= SPU2_RETURN_AAD2; /* need aad2 for gcm aes esp */ 686 } 687 688 if (auth_key_len) 689 ctrl1 |= ((auth_key_len << SPU2_HASH_KEY_LEN_SHIFT) & 690 SPU2_HASH_KEY_LEN); 691 692 if (cipher_key_len) 693 ctrl1 |= ((cipher_key_len << SPU2_CIPH_KEY_LEN_SHIFT) & 694 SPU2_CIPH_KEY_LEN); 695 696 if (gen_iv) 697 ctrl1 |= SPU2_GENIV; 698 699 if (hash_iv) 700 ctrl1 |= SPU2_HASH_IV; 701 702 if (return_iv) { 703 ctrl1 |= SPU2_RET_IV; 704 ctrl1 |= ret_iv_len << SPU2_RET_IV_LEN_SHIFT; 705 ctrl1 |= ret_iv_offset << SPU2_IV_OFFSET_SHIFT; 706 } 707 708 ctrl1 |= ((cipher_iv_len << SPU2_IV_LEN_SHIFT) & SPU2_IV_LEN); 709 710 if (digest_size) 711 ctrl1 |= ((digest_size << SPU2_HASH_TAG_LEN_SHIFT) & 712 SPU2_HASH_TAG_LEN); 713 714 /* Let's ask for the output pkt to include FMD, but don't need to 715 * get keys and IVs back in OMD. 716 */ 717 if (return_md) 718 ctrl1 |= ((u64)SPU2_RET_FMD_ONLY << SPU2_RETURN_MD_SHIFT); 719 else 720 ctrl1 |= ((u64)SPU2_RET_NO_MD << SPU2_RETURN_MD_SHIFT); 721 722 /* Crypto API does not get assoc data back. So no need for AAD2. */ 723 724 if (return_payload) 725 ctrl1 |= SPU2_RETURN_PAY; 726 727 fmd->ctrl1 = cpu_to_le64(ctrl1); 728 } 729 730 /** 731 * spu2_fmd_ctrl2_write() - Set the ctrl2 field in the fixed metadata field of 732 * SPU2 header. 733 * @fmd: Start of FMD field to be written 734 * @cipher_offset: Number of bytes from Start of Packet (end of FD field) where 735 * data to be encrypted or decrypted begins 736 * @auth_key_len: Length of authentication key, in bytes 737 * @auth_iv_len: Length of authentication initialization vector, in bytes 738 * @cipher_key_len: Length of cipher key, in bytes 739 * @cipher_iv_len: Length of cipher IV, in bytes 740 */ 741 static void spu2_fmd_ctrl2_write(struct SPU2_FMD *fmd, u64 cipher_offset, 742 u64 auth_key_len, u64 auth_iv_len, 743 u64 cipher_key_len, u64 cipher_iv_len) 744 { 745 u64 ctrl2; 746 u64 aad1_offset; 747 u64 aad2_offset; 748 u16 aad1_len = 0; 749 u64 payload_offset; 750 751 /* AAD1 offset is from start of FD. FD length always 0. */ 752 aad1_offset = 0; 753 754 aad2_offset = aad1_offset; 755 payload_offset = cipher_offset; 756 ctrl2 = aad1_offset | 757 (aad1_len << SPU2_AAD1_LEN_SHIFT) | 758 (aad2_offset << SPU2_AAD2_OFFSET_SHIFT) | 759 (payload_offset << SPU2_PL_OFFSET_SHIFT); 760 761 fmd->ctrl2 = cpu_to_le64(ctrl2); 762 } 763 764 /** 765 * spu2_fmd_ctrl3_write() - Set the ctrl3 field in FMD 766 * @fmd: Fixed meta data. First field in SPU2 msg header. 767 * @payload_len: Length of payload, in bytes 768 */ 769 static void spu2_fmd_ctrl3_write(struct SPU2_FMD *fmd, u64 payload_len) 770 { 771 u64 ctrl3; 772 773 ctrl3 = payload_len & SPU2_PL_LEN; 774 775 fmd->ctrl3 = cpu_to_le64(ctrl3); 776 } 777 778 /** 779 * spu2_ctx_max_payload() - Determine the maximum length of the payload for a 780 * SPU message for a given cipher and hash alg context. 781 * @cipher_alg: The cipher algorithm 782 * @cipher_mode: The cipher mode 783 * @blocksize: The size of a block of data for this algo 784 * 785 * For SPU2, the hardware generally ignores the PayloadLen field in ctrl3 of 786 * FMD and just keeps computing until it receives a DMA descriptor with the EOF 787 * flag set. So we consider the max payload to be infinite. AES CCM is an 788 * exception. 789 * 790 * Return: Max payload length in bytes 791 */ 792 u32 spu2_ctx_max_payload(enum spu_cipher_alg cipher_alg, 793 enum spu_cipher_mode cipher_mode, 794 unsigned int blocksize) 795 { 796 if ((cipher_alg == CIPHER_ALG_AES) && 797 (cipher_mode == CIPHER_MODE_CCM)) { 798 u32 excess = SPU2_MAX_PAYLOAD % blocksize; 799 800 return SPU2_MAX_PAYLOAD - excess; 801 } else { 802 return SPU_MAX_PAYLOAD_INF; 803 } 804 } 805 806 /** 807 * spu_payload_length() - Given a SPU2 message header, extract the payload 808 * length. 809 * @spu_hdr: Start of SPU message header (FMD) 810 * 811 * Return: payload length, in bytes 812 */ 813 u32 spu2_payload_length(u8 *spu_hdr) 814 { 815 struct SPU2_FMD *fmd = (struct SPU2_FMD *)spu_hdr; 816 u32 pl_len; 817 u64 ctrl3; 818 819 ctrl3 = le64_to_cpu(fmd->ctrl3); 820 pl_len = ctrl3 & SPU2_PL_LEN; 821 822 return pl_len; 823 } 824 825 /** 826 * spu_response_hdr_len() - Determine the expected length of a SPU response 827 * header. 828 * @auth_key_len: Length of authentication key, in bytes 829 * @enc_key_len: Length of encryption key, in bytes 830 * 831 * For SPU2, includes just FMD. OMD is never requested. 832 * 833 * Return: Length of FMD, in bytes 834 */ 835 u16 spu2_response_hdr_len(u16 auth_key_len, u16 enc_key_len, bool is_hash) 836 { 837 return FMD_SIZE; 838 } 839 840 /** 841 * spu_hash_pad_len() - Calculate the length of hash padding required to extend 842 * data to a full block size. 843 * @hash_alg: hash algorithm 844 * @hash_mode: hash mode 845 * @chunksize: length of data, in bytes 846 * @hash_block_size: size of a hash block, in bytes 847 * 848 * SPU2 hardware does all hash padding 849 * 850 * Return: length of hash pad in bytes 851 */ 852 u16 spu2_hash_pad_len(enum hash_alg hash_alg, enum hash_mode hash_mode, 853 u32 chunksize, u16 hash_block_size) 854 { 855 return 0; 856 } 857 858 /** 859 * spu2_gcm_ccm_padlen() - Determine the length of GCM/CCM padding for either 860 * the AAD field or the data. 861 * 862 * Return: 0. Unlike SPU-M, SPU2 hardware does any GCM/CCM padding required. 863 */ 864 u32 spu2_gcm_ccm_pad_len(enum spu_cipher_mode cipher_mode, 865 unsigned int data_size) 866 { 867 return 0; 868 } 869 870 /** 871 * spu_assoc_resp_len() - Determine the size of the AAD2 buffer needed to catch 872 * associated data in a SPU2 output packet. 873 * @cipher_mode: cipher mode 874 * @assoc_len: length of additional associated data, in bytes 875 * @iv_len: length of initialization vector, in bytes 876 * @is_encrypt: true if encrypting. false if decrypt. 877 * 878 * Return: Length of buffer to catch associated data in response 879 */ 880 u32 spu2_assoc_resp_len(enum spu_cipher_mode cipher_mode, 881 unsigned int assoc_len, unsigned int iv_len, 882 bool is_encrypt) 883 { 884 u32 resp_len = assoc_len; 885 886 if (is_encrypt) 887 /* gcm aes esp has to write 8-byte IV in response */ 888 resp_len += iv_len; 889 return resp_len; 890 } 891 892 /* 893 * spu_aead_ivlen() - Calculate the length of the AEAD IV to be included 894 * in a SPU request after the AAD and before the payload. 895 * @cipher_mode: cipher mode 896 * @iv_ctr_len: initialization vector length in bytes 897 * 898 * For SPU2, AEAD IV is included in OMD and does not need to be repeated 899 * prior to the payload. 900 * 901 * Return: Length of AEAD IV in bytes 902 */ 903 u8 spu2_aead_ivlen(enum spu_cipher_mode cipher_mode, u16 iv_len) 904 { 905 return 0; 906 } 907 908 /** 909 * spu2_hash_type() - Determine the type of hash operation. 910 * @src_sent: The number of bytes in the current request that have already 911 * been sent to the SPU to be hashed. 912 * 913 * SPU2 always does a FULL hash operation 914 */ 915 enum hash_type spu2_hash_type(u32 src_sent) 916 { 917 return HASH_TYPE_FULL; 918 } 919 920 /** 921 * spu2_digest_size() - Determine the size of a hash digest to expect the SPU to 922 * return. 923 * alg_digest_size: Number of bytes in the final digest for the given algo 924 * alg: The hash algorithm 925 * htype: Type of hash operation (init, update, full, etc) 926 * 927 */ 928 u32 spu2_digest_size(u32 alg_digest_size, enum hash_alg alg, 929 enum hash_type htype) 930 { 931 return alg_digest_size; 932 } 933 934 /** 935 * spu_create_request() - Build a SPU2 request message header, includint FMD and 936 * OMD. 937 * @spu_hdr: Start of buffer where SPU request header is to be written 938 * @req_opts: SPU request message options 939 * @cipher_parms: Parameters related to cipher algorithm 940 * @hash_parms: Parameters related to hash algorithm 941 * @aead_parms: Parameters related to AEAD operation 942 * @data_size: Length of data to be encrypted or authenticated. If AEAD, does 943 * not include length of AAD. 944 * 945 * Construct the message starting at spu_hdr. Caller should allocate this buffer 946 * in DMA-able memory at least SPU_HEADER_ALLOC_LEN bytes long. 947 * 948 * Return: the length of the SPU header in bytes. 0 if an error occurs. 949 */ 950 u32 spu2_create_request(u8 *spu_hdr, 951 struct spu_request_opts *req_opts, 952 struct spu_cipher_parms *cipher_parms, 953 struct spu_hash_parms *hash_parms, 954 struct spu_aead_parms *aead_parms, 955 unsigned int data_size) 956 { 957 struct SPU2_FMD *fmd; 958 u8 *ptr; 959 unsigned int buf_len; 960 int err; 961 enum spu2_cipher_type spu2_ciph_type = SPU2_CIPHER_TYPE_NONE; 962 enum spu2_cipher_mode spu2_ciph_mode; 963 enum spu2_hash_type spu2_auth_type = SPU2_HASH_TYPE_NONE; 964 enum spu2_hash_mode spu2_auth_mode; 965 bool return_md = true; 966 enum spu2_proto_sel proto = SPU2_PROTO_RESV; 967 968 /* size of the payload */ 969 unsigned int payload_len = 970 hash_parms->prebuf_len + data_size + hash_parms->pad_len - 971 ((req_opts->is_aead && req_opts->is_inbound) ? 972 hash_parms->digestsize : 0); 973 974 /* offset of prebuf or data from start of AAD2 */ 975 unsigned int cipher_offset = aead_parms->assoc_size + 976 aead_parms->aad_pad_len + aead_parms->iv_len; 977 978 #ifdef DEBUG 979 /* total size of the data following OMD (without STAT word padding) */ 980 unsigned int real_db_size = spu_real_db_size(aead_parms->assoc_size, 981 aead_parms->iv_len, 982 hash_parms->prebuf_len, 983 data_size, 984 aead_parms->aad_pad_len, 985 aead_parms->data_pad_len, 986 hash_parms->pad_len); 987 #endif 988 unsigned int assoc_size = aead_parms->assoc_size; 989 990 if (req_opts->is_aead && 991 (cipher_parms->alg == CIPHER_ALG_AES) && 992 (cipher_parms->mode == CIPHER_MODE_GCM)) 993 /* 994 * On SPU 2, aes gcm cipher first on encrypt, auth first on 995 * decrypt 996 */ 997 req_opts->auth_first = req_opts->is_inbound; 998 999 /* and do opposite for ccm (auth 1st on encrypt) */ 1000 if (req_opts->is_aead && 1001 (cipher_parms->alg == CIPHER_ALG_AES) && 1002 (cipher_parms->mode == CIPHER_MODE_CCM)) 1003 req_opts->auth_first = !req_opts->is_inbound; 1004 1005 flow_log("%s()\n", __func__); 1006 flow_log(" in:%u authFirst:%u\n", 1007 req_opts->is_inbound, req_opts->auth_first); 1008 flow_log(" cipher alg:%u mode:%u type %u\n", cipher_parms->alg, 1009 cipher_parms->mode, cipher_parms->type); 1010 flow_log(" is_esp: %s\n", req_opts->is_esp ? "yes" : "no"); 1011 flow_log(" key: %d\n", cipher_parms->key_len); 1012 flow_dump(" key: ", cipher_parms->key_buf, cipher_parms->key_len); 1013 flow_log(" iv: %d\n", cipher_parms->iv_len); 1014 flow_dump(" iv: ", cipher_parms->iv_buf, cipher_parms->iv_len); 1015 flow_log(" auth alg:%u mode:%u type %u\n", 1016 hash_parms->alg, hash_parms->mode, hash_parms->type); 1017 flow_log(" digestsize: %u\n", hash_parms->digestsize); 1018 flow_log(" authkey: %d\n", hash_parms->key_len); 1019 flow_dump(" authkey: ", hash_parms->key_buf, hash_parms->key_len); 1020 flow_log(" assoc_size:%u\n", assoc_size); 1021 flow_log(" prebuf_len:%u\n", hash_parms->prebuf_len); 1022 flow_log(" data_size:%u\n", data_size); 1023 flow_log(" hash_pad_len:%u\n", hash_parms->pad_len); 1024 flow_log(" real_db_size:%u\n", real_db_size); 1025 flow_log(" cipher_offset:%u payload_len:%u\n", 1026 cipher_offset, payload_len); 1027 flow_log(" aead_iv: %u\n", aead_parms->iv_len); 1028 1029 /* Convert to spu2 values for cipher alg, hash alg */ 1030 err = spu2_cipher_xlate(cipher_parms->alg, cipher_parms->mode, 1031 cipher_parms->type, 1032 &spu2_ciph_type, &spu2_ciph_mode); 1033 1034 /* If we are doing GCM hashing only - either via rfc4543 transform 1035 * or because we happen to do GCM with AAD only and no payload - we 1036 * need to configure hardware to use hash key rather than cipher key 1037 * and put data into payload. This is because unlike SPU-M, running 1038 * GCM cipher with 0 size payload is not permitted. 1039 */ 1040 if ((req_opts->is_rfc4543) || 1041 ((spu2_ciph_mode == SPU2_CIPHER_MODE_GCM) && 1042 (payload_len == 0))) { 1043 /* Use hashing (only) and set up hash key */ 1044 spu2_ciph_type = SPU2_CIPHER_TYPE_NONE; 1045 hash_parms->key_len = cipher_parms->key_len; 1046 memcpy(hash_parms->key_buf, cipher_parms->key_buf, 1047 cipher_parms->key_len); 1048 cipher_parms->key_len = 0; 1049 1050 if (req_opts->is_rfc4543) 1051 payload_len += assoc_size; 1052 else 1053 payload_len = assoc_size; 1054 cipher_offset = 0; 1055 assoc_size = 0; 1056 } 1057 1058 if (err) 1059 return 0; 1060 1061 flow_log("spu2 cipher type %s, cipher mode %s\n", 1062 spu2_ciph_type_name(spu2_ciph_type), 1063 spu2_ciph_mode_name(spu2_ciph_mode)); 1064 1065 err = spu2_hash_xlate(hash_parms->alg, hash_parms->mode, 1066 hash_parms->type, 1067 cipher_parms->type, 1068 &spu2_auth_type, &spu2_auth_mode); 1069 if (err) 1070 return 0; 1071 1072 flow_log("spu2 hash type %s, hash mode %s\n", 1073 spu2_hash_type_name(spu2_auth_type), 1074 spu2_hash_mode_name(spu2_auth_mode)); 1075 1076 fmd = (struct SPU2_FMD *)spu_hdr; 1077 1078 spu2_fmd_ctrl0_write(fmd, req_opts->is_inbound, req_opts->auth_first, 1079 proto, spu2_ciph_type, spu2_ciph_mode, 1080 spu2_auth_type, spu2_auth_mode); 1081 1082 spu2_fmd_ctrl1_write(fmd, req_opts->is_inbound, assoc_size, 1083 hash_parms->key_len, cipher_parms->key_len, 1084 false, false, 1085 aead_parms->return_iv, aead_parms->ret_iv_len, 1086 aead_parms->ret_iv_off, 1087 cipher_parms->iv_len, hash_parms->digestsize, 1088 !req_opts->bd_suppress, return_md); 1089 1090 spu2_fmd_ctrl2_write(fmd, cipher_offset, hash_parms->key_len, 0, 1091 cipher_parms->key_len, cipher_parms->iv_len); 1092 1093 spu2_fmd_ctrl3_write(fmd, payload_len); 1094 1095 ptr = (u8 *)(fmd + 1); 1096 buf_len = sizeof(struct SPU2_FMD); 1097 1098 /* Write OMD */ 1099 if (hash_parms->key_len) { 1100 memcpy(ptr, hash_parms->key_buf, hash_parms->key_len); 1101 ptr += hash_parms->key_len; 1102 buf_len += hash_parms->key_len; 1103 } 1104 if (cipher_parms->key_len) { 1105 memcpy(ptr, cipher_parms->key_buf, cipher_parms->key_len); 1106 ptr += cipher_parms->key_len; 1107 buf_len += cipher_parms->key_len; 1108 } 1109 if (cipher_parms->iv_len) { 1110 memcpy(ptr, cipher_parms->iv_buf, cipher_parms->iv_len); 1111 ptr += cipher_parms->iv_len; 1112 buf_len += cipher_parms->iv_len; 1113 } 1114 1115 packet_dump(" SPU request header: ", spu_hdr, buf_len); 1116 1117 return buf_len; 1118 } 1119 1120 /** 1121 * spu_cipher_req_init() - Build an ablkcipher SPU2 request message header, 1122 * including FMD and OMD. 1123 * @spu_hdr: Location of start of SPU request (FMD field) 1124 * @cipher_parms: Parameters describing cipher request 1125 * 1126 * Called at setkey time to initialize a msg header that can be reused for all 1127 * subsequent ablkcipher requests. Construct the message starting at spu_hdr. 1128 * Caller should allocate this buffer in DMA-able memory at least 1129 * SPU_HEADER_ALLOC_LEN bytes long. 1130 * 1131 * Return: the total length of the SPU header (FMD and OMD) in bytes. 0 if an 1132 * error occurs. 1133 */ 1134 u16 spu2_cipher_req_init(u8 *spu_hdr, struct spu_cipher_parms *cipher_parms) 1135 { 1136 struct SPU2_FMD *fmd; 1137 u8 *omd; 1138 enum spu2_cipher_type spu2_type = SPU2_CIPHER_TYPE_NONE; 1139 enum spu2_cipher_mode spu2_mode; 1140 int err; 1141 1142 flow_log("%s()\n", __func__); 1143 flow_log(" cipher alg:%u mode:%u type %u\n", cipher_parms->alg, 1144 cipher_parms->mode, cipher_parms->type); 1145 flow_log(" cipher_iv_len: %u\n", cipher_parms->iv_len); 1146 flow_log(" key: %d\n", cipher_parms->key_len); 1147 flow_dump(" key: ", cipher_parms->key_buf, cipher_parms->key_len); 1148 1149 /* Convert to spu2 values */ 1150 err = spu2_cipher_xlate(cipher_parms->alg, cipher_parms->mode, 1151 cipher_parms->type, &spu2_type, &spu2_mode); 1152 if (err) 1153 return 0; 1154 1155 flow_log("spu2 cipher type %s, cipher mode %s\n", 1156 spu2_ciph_type_name(spu2_type), 1157 spu2_ciph_mode_name(spu2_mode)); 1158 1159 /* Construct the FMD header */ 1160 fmd = (struct SPU2_FMD *)spu_hdr; 1161 err = spu2_fmd_init(fmd, spu2_type, spu2_mode, cipher_parms->key_len, 1162 cipher_parms->iv_len); 1163 if (err) 1164 return 0; 1165 1166 /* Write cipher key to OMD */ 1167 omd = (u8 *)(fmd + 1); 1168 if (cipher_parms->key_buf && cipher_parms->key_len) 1169 memcpy(omd, cipher_parms->key_buf, cipher_parms->key_len); 1170 1171 packet_dump(" SPU request header: ", spu_hdr, 1172 FMD_SIZE + cipher_parms->key_len + cipher_parms->iv_len); 1173 1174 return FMD_SIZE + cipher_parms->key_len + cipher_parms->iv_len; 1175 } 1176 1177 /** 1178 * spu_cipher_req_finish() - Finish building a SPU request message header for a 1179 * block cipher request. 1180 * @spu_hdr: Start of the request message header (MH field) 1181 * @spu_req_hdr_len: Length in bytes of the SPU request header 1182 * @isInbound: 0 encrypt, 1 decrypt 1183 * @cipher_parms: Parameters describing cipher operation to be performed 1184 * @update_key: If true, rewrite the cipher key in SCTX 1185 * @data_size: Length of the data in the BD field 1186 * 1187 * Assumes much of the header was already filled in at setkey() time in 1188 * spu_cipher_req_init(). 1189 * spu_cipher_req_init() fills in the encryption key. For RC4, when submitting a 1190 * request for a non-first chunk, we use the 260-byte SUPDT field from the 1191 * previous response as the key. update_key is true for this case. Unused in all 1192 * other cases. 1193 */ 1194 void spu2_cipher_req_finish(u8 *spu_hdr, 1195 u16 spu_req_hdr_len, 1196 unsigned int is_inbound, 1197 struct spu_cipher_parms *cipher_parms, 1198 bool update_key, 1199 unsigned int data_size) 1200 { 1201 struct SPU2_FMD *fmd; 1202 u8 *omd; /* start of optional metadata */ 1203 u64 ctrl0; 1204 u64 ctrl3; 1205 1206 flow_log("%s()\n", __func__); 1207 flow_log(" in: %u\n", is_inbound); 1208 flow_log(" cipher alg: %u, cipher_type: %u\n", cipher_parms->alg, 1209 cipher_parms->type); 1210 if (update_key) { 1211 flow_log(" cipher key len: %u\n", cipher_parms->key_len); 1212 flow_dump(" key: ", cipher_parms->key_buf, 1213 cipher_parms->key_len); 1214 } 1215 flow_log(" iv len: %d\n", cipher_parms->iv_len); 1216 flow_dump(" iv: ", cipher_parms->iv_buf, cipher_parms->iv_len); 1217 flow_log(" data_size: %u\n", data_size); 1218 1219 fmd = (struct SPU2_FMD *)spu_hdr; 1220 omd = (u8 *)(fmd + 1); 1221 1222 /* 1223 * FMD ctrl0 was initialized at setkey time. update it to indicate 1224 * whether we are encrypting or decrypting. 1225 */ 1226 ctrl0 = le64_to_cpu(fmd->ctrl0); 1227 if (is_inbound) 1228 ctrl0 &= ~SPU2_CIPH_ENCRYPT_EN; /* decrypt */ 1229 else 1230 ctrl0 |= SPU2_CIPH_ENCRYPT_EN; /* encrypt */ 1231 fmd->ctrl0 = cpu_to_le64(ctrl0); 1232 1233 if (cipher_parms->alg && cipher_parms->iv_buf && cipher_parms->iv_len) { 1234 /* cipher iv provided so put it in here */ 1235 memcpy(omd + cipher_parms->key_len, cipher_parms->iv_buf, 1236 cipher_parms->iv_len); 1237 } 1238 1239 ctrl3 = le64_to_cpu(fmd->ctrl3); 1240 data_size &= SPU2_PL_LEN; 1241 ctrl3 |= data_size; 1242 fmd->ctrl3 = cpu_to_le64(ctrl3); 1243 1244 packet_dump(" SPU request header: ", spu_hdr, spu_req_hdr_len); 1245 } 1246 1247 /** 1248 * spu_request_pad() - Create pad bytes at the end of the data. 1249 * @pad_start: Start of buffer where pad bytes are to be written 1250 * @gcm_padding: Length of GCM padding, in bytes 1251 * @hash_pad_len: Number of bytes of padding extend data to full block 1252 * @auth_alg: Authentication algorithm 1253 * @auth_mode: Authentication mode 1254 * @total_sent: Length inserted at end of hash pad 1255 * @status_padding: Number of bytes of padding to align STATUS word 1256 * 1257 * There may be three forms of pad: 1258 * 1. GCM pad - for GCM mode ciphers, pad to 16-byte alignment 1259 * 2. hash pad - pad to a block length, with 0x80 data terminator and 1260 * size at the end 1261 * 3. STAT pad - to ensure the STAT field is 4-byte aligned 1262 */ 1263 void spu2_request_pad(u8 *pad_start, u32 gcm_padding, u32 hash_pad_len, 1264 enum hash_alg auth_alg, enum hash_mode auth_mode, 1265 unsigned int total_sent, u32 status_padding) 1266 { 1267 u8 *ptr = pad_start; 1268 1269 /* fix data alignent for GCM */ 1270 if (gcm_padding > 0) { 1271 flow_log(" GCM: padding to 16 byte alignment: %u bytes\n", 1272 gcm_padding); 1273 memset(ptr, 0, gcm_padding); 1274 ptr += gcm_padding; 1275 } 1276 1277 if (hash_pad_len > 0) { 1278 /* clear the padding section */ 1279 memset(ptr, 0, hash_pad_len); 1280 1281 /* terminate the data */ 1282 *ptr = 0x80; 1283 ptr += (hash_pad_len - sizeof(u64)); 1284 1285 /* add the size at the end as required per alg */ 1286 if (auth_alg == HASH_ALG_MD5) 1287 *(u64 *)ptr = cpu_to_le64((u64)total_sent * 8); 1288 else /* SHA1, SHA2-224, SHA2-256 */ 1289 *(u64 *)ptr = cpu_to_be64((u64)total_sent * 8); 1290 ptr += sizeof(u64); 1291 } 1292 1293 /* pad to a 4byte alignment for STAT */ 1294 if (status_padding > 0) { 1295 flow_log(" STAT: padding to 4 byte alignment: %u bytes\n", 1296 status_padding); 1297 1298 memset(ptr, 0, status_padding); 1299 ptr += status_padding; 1300 } 1301 } 1302 1303 /** 1304 * spu2_xts_tweak_in_payload() - Indicate that SPU2 does NOT place the XTS 1305 * tweak field in the packet payload (it uses IV instead) 1306 * 1307 * Return: 0 1308 */ 1309 u8 spu2_xts_tweak_in_payload(void) 1310 { 1311 return 0; 1312 } 1313 1314 /** 1315 * spu2_tx_status_len() - Return the length of the STATUS field in a SPU 1316 * response message. 1317 * 1318 * Return: Length of STATUS field in bytes. 1319 */ 1320 u8 spu2_tx_status_len(void) 1321 { 1322 return SPU2_TX_STATUS_LEN; 1323 } 1324 1325 /** 1326 * spu2_rx_status_len() - Return the length of the STATUS field in a SPU 1327 * response message. 1328 * 1329 * Return: Length of STATUS field in bytes. 1330 */ 1331 u8 spu2_rx_status_len(void) 1332 { 1333 return SPU2_RX_STATUS_LEN; 1334 } 1335 1336 /** 1337 * spu_status_process() - Process the status from a SPU response message. 1338 * @statp: start of STATUS word 1339 * 1340 * Return: 0 - if status is good and response should be processed 1341 * !0 - status indicates an error and response is invalid 1342 */ 1343 int spu2_status_process(u8 *statp) 1344 { 1345 /* SPU2 status is 2 bytes by default - SPU_RX_STATUS_LEN */ 1346 u16 status = le16_to_cpu(*(__le16 *)statp); 1347 1348 if (status == 0) 1349 return 0; 1350 1351 flow_log("rx status is %#x\n", status); 1352 if (status == SPU2_INVALID_ICV) 1353 return SPU_INVALID_ICV; 1354 1355 return -EBADMSG; 1356 } 1357 1358 /** 1359 * spu2_ccm_update_iv() - Update the IV as per the requirements for CCM mode. 1360 * 1361 * @digestsize: Digest size of this request 1362 * @cipher_parms: (pointer to) cipher parmaeters, includes IV buf & IV len 1363 * @assoclen: Length of AAD data 1364 * @chunksize: length of input data to be sent in this req 1365 * @is_encrypt: true if this is an output/encrypt operation 1366 * @is_esp: true if this is an ESP / RFC4309 operation 1367 * 1368 */ 1369 void spu2_ccm_update_iv(unsigned int digestsize, 1370 struct spu_cipher_parms *cipher_parms, 1371 unsigned int assoclen, unsigned int chunksize, 1372 bool is_encrypt, bool is_esp) 1373 { 1374 int L; /* size of length field, in bytes */ 1375 1376 /* 1377 * In RFC4309 mode, L is fixed at 4 bytes; otherwise, IV from 1378 * testmgr contains (L-1) in bottom 3 bits of first byte, 1379 * per RFC 3610. 1380 */ 1381 if (is_esp) 1382 L = CCM_ESP_L_VALUE; 1383 else 1384 L = ((cipher_parms->iv_buf[0] & CCM_B0_L_PRIME) >> 1385 CCM_B0_L_PRIME_SHIFT) + 1; 1386 1387 /* SPU2 doesn't want these length bytes nor the first byte... */ 1388 cipher_parms->iv_len -= (1 + L); 1389 memmove(cipher_parms->iv_buf, &cipher_parms->iv_buf[1], 1390 cipher_parms->iv_len); 1391 } 1392 1393 /** 1394 * spu2_wordalign_padlen() - SPU2 does not require padding. 1395 * @data_size: length of data field in bytes 1396 * 1397 * Return: length of status field padding, in bytes (always 0 on SPU2) 1398 */ 1399 u32 spu2_wordalign_padlen(u32 data_size) 1400 { 1401 return 0; 1402 } 1403