drivers/crypto/bcm/spu2.c

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