drivers/common/dpaax/caamflib/desc/algo.h

   1 /* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
   2  *
   3  * Copyright 2008-2016 Freescale Semiconductor Inc.
   4  * Copyright 2016,2019 NXP
   5  *
   6  */
   7
   8 #ifndef __DESC_ALGO_H__
   9 #define __DESC_ALGO_H__
  10
  11 #include "rta.h"
  12 #include "common.h"
  13
  14 /**
  15  * DOC: Algorithms - Shared Descriptor Constructors
  16  *
  17  * Shared descriptors for algorithms (i.e. not for protocols).
  18  */
  19
  20 /**
  21  * cnstr_shdsc_zuce - ZUC Enc (EEA2) as a shared descriptor
  22  * @descbuf: pointer to descriptor-under-construction buffer
  23  * @ps: if 36/40bit addressing is desired, this parameter must be true
  24  * @swap: must be true when core endianness doesn't match SEC endianness
  25  * @cipherdata: pointer to block cipher transform definitions
  26  * @dir: Cipher direction (DIR_ENC/DIR_DEC)
  27  *
  28  * Return: size of descriptor written in words or negative number on error
  29  */
  30 static inline int
  31 cnstr_shdsc_zuce(uint32_t *descbuf, bool ps, bool swap,
  32                     struct alginfo *cipherdata, uint8_t dir)
  33 {
  34         struct program prg;
  35         struct program *p = &prg;
  36
  37         PROGRAM_CNTXT_INIT(p, descbuf, 0);
  38         if (swap)
  39                 PROGRAM_SET_BSWAP(p);
  40
  41         if (ps)
  42                 PROGRAM_SET_36BIT_ADDR(p);
  43         SHR_HDR(p, SHR_ALWAYS, 1, 0);
  44
  45         KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
  46             cipherdata->keylen, INLINE_KEY(cipherdata));
  47
  48         SEQLOAD(p, CONTEXT1, 0, 16, 0);
  49
  50         MATHB(p, SEQINSZ, SUB, MATH2, VSEQINSZ, 4, 0);
  51         MATHB(p, SEQINSZ, SUB, MATH2, VSEQOUTSZ, 4, 0);
  52         ALG_OPERATION(p, OP_ALG_ALGSEL_ZUCE, OP_ALG_AAI_F8,
  53                       OP_ALG_AS_INITFINAL, 0, dir);
  54         SEQFIFOLOAD(p, MSG1, 0, VLF | LAST1);
  55         SEQFIFOSTORE(p, MSG, 0, 0, VLF);
  56
  57         return PROGRAM_FINALIZE(p);
  58 }
  59
  60 /**
  61  * cnstr_shdsc_zuca - ZUC Auth (EIA2) as a shared descriptor
  62  * @descbuf: pointer to descriptor-under-construction buffer
  63  * @ps: if 36/40bit addressing is desired, this parameter must be true
  64  * @swap: must be true when core endianness doesn't match SEC endianness
  65  * @authdata: pointer to authentication transform definitions
  66  * @chk_icv: Whether to compare and verify ICV (true/false)
  67  * @authlen: size of digest
  68  *
  69  * The IV prepended before hmac payload must be 8 bytes consisting
  70  * of COUNT||BEAERER||DIR. The COUNT is of 32-bits, bearer is of 5 bits and
  71  * direction is of 1 bit - totalling to 38 bits.
  72  *
  73  * Return: size of descriptor written in words or negative number on error
  74  */
  75 static inline int
  76 cnstr_shdsc_zuca(uint32_t *descbuf, bool ps, bool swap,
  77                  struct alginfo *authdata, uint8_t chk_icv,
  78                  uint32_t authlen)
  79 {
  80         struct program prg;
  81         struct program *p = &prg;
  82         int dir = chk_icv ? DIR_DEC : DIR_ENC;
  83
  84         PROGRAM_CNTXT_INIT(p, descbuf, 0);
  85         if (swap)
  86                 PROGRAM_SET_BSWAP(p);
  87
  88         if (ps)
  89                 PROGRAM_SET_36BIT_ADDR(p);
  90         SHR_HDR(p, SHR_ALWAYS, 1, 0);
  91
  92         KEY(p, KEY2, authdata->key_enc_flags, authdata->key,
  93             authdata->keylen, INLINE_KEY(authdata));
  94
  95         SEQLOAD(p, CONTEXT2, 0, 8, 0);
  96
  97         if (chk_icv == ICV_CHECK_ENABLE)
  98                 MATHB(p, SEQINSZ, SUB, authlen, VSEQINSZ, 4, IMMED2);
  99         else
 100                 MATHB(p, SEQINSZ, SUB, ZERO, VSEQINSZ, 4, 0);
 101
 102         ALG_OPERATION(p, OP_ALG_ALGSEL_ZUCA, OP_ALG_AAI_F9,
 103                       OP_ALG_AS_INITFINAL, chk_icv, dir);
 104
 105         SEQFIFOLOAD(p, MSG2, 0, VLF | CLASS2 | LAST2);
 106
 107         if (chk_icv == ICV_CHECK_ENABLE)
 108                 SEQFIFOLOAD(p, ICV2, authlen, LAST2);
 109         else
 110                 /* Save lower half of MAC out into a 32-bit sequence */
 111                 SEQSTORE(p, CONTEXT2, 0, authlen, 0);
 112
 113         return PROGRAM_FINALIZE(p);
 114 }
 115
 116
 117 /**
 118  * cnstr_shdsc_snow_f8 - SNOW/f8 (UEA2) as a shared descriptor
 119  * @descbuf: pointer to descriptor-under-construction buffer
 120  * @ps: if 36/40bit addressing is desired, this parameter must be true
 121  * @swap: must be true when core endianness doesn't match SEC endianness
 122  * @cipherdata: pointer to block cipher transform definitions
 123  * @dir: Cipher direction (DIR_ENC/DIR_DEC)
 124  *
 125  * Return: size of descriptor written in words or negative number on error
 126  */
 127 static inline int
 128 cnstr_shdsc_snow_f8(uint32_t *descbuf, bool ps, bool swap,
 129                     struct alginfo *cipherdata, uint8_t dir)
 130 {
 131         struct program prg;
 132         struct program *p = &prg;
 133
 134         PROGRAM_CNTXT_INIT(p, descbuf, 0);
 135         if (swap)
 136                 PROGRAM_SET_BSWAP(p);
 137
 138         if (ps)
 139                 PROGRAM_SET_36BIT_ADDR(p);
 140         SHR_HDR(p, SHR_ALWAYS, 1, 0);
 141
 142         KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
 143             cipherdata->keylen, INLINE_KEY(cipherdata));
 144
 145         SEQLOAD(p, CONTEXT1, 0, 16, 0);
 146
 147         MATHB(p, SEQINSZ, SUB, MATH2, VSEQINSZ, 4, 0);
 148         MATHB(p, SEQINSZ, SUB, MATH2, VSEQOUTSZ, 4, 0);
 149         ALG_OPERATION(p, OP_ALG_ALGSEL_SNOW_F8, OP_ALG_AAI_F8,
 150                       OP_ALG_AS_INITFINAL, 0, dir);
 151         SEQFIFOLOAD(p, MSG1, 0, VLF | LAST1);
 152         SEQFIFOSTORE(p, MSG, 0, 0, VLF);
 153
 154         return PROGRAM_FINALIZE(p);
 155 }
 156
 157 /**
 158  * conv_to_zuc_eia_iv - ZUCA IV 16-byte to 8-byte convert
 159  * function for 3G.
 160  * @iv: 16 bytes of original IV data.
 161  *
 162  * From the original IV, we extract 32-bits of COUNT,
 163  * 5-bits of bearer and 1-bit of direction.
 164  * Refer to CAAM refman for ZUCA IV format. Then these values are
 165  * appended as COUNT||BEARER||DIR continuously to make a 38-bit block.
 166  * This 38-bit block is copied left justified into 8-byte array used as
 167  * converted IV.
 168  *
 169  * Return: 8-bytes of IV data as understood by SEC HW
 170  */
 171
 172 static inline uint8_t *conv_to_zuc_eia_iv(uint8_t *iv)
 173 {
 174         uint8_t dir = (iv[14] & 0x80) ? 4 : 0;
 175
 176         iv[12] = iv[4] | dir;
 177         iv[13] = 0;
 178         iv[14] = 0;
 179         iv[15] = 0;
 180
 181         iv[8] = iv[0];
 182         iv[9] = iv[1];
 183         iv[10] = iv[2];
 184         iv[11] = iv[3];
 185
 186         return (iv + 8);
 187 }
 188
 189 /**
 190  * conv_to_snow_f9_iv - SNOW/f9 (UIA2) IV 16 byte to 12 byte convert
 191  * function for 3G.
 192  * @iv: 16 byte original IV data
 193  *
 194  * Return: 12 byte IV data as understood by SEC HW
 195  */
 196
 197 static inline uint8_t *conv_to_snow_f9_iv(uint8_t *iv)
 198 {
 199         uint8_t temp = (iv[8] == iv[0]) ? 0 : 4;
 200
 201         iv[12] = iv[4];
 202         iv[13] = iv[5];
 203         iv[14] = iv[6];
 204         iv[15] = iv[7];
 205
 206         iv[8] = temp;
 207         iv[9] = 0x00;
 208         iv[10] = 0x00;
 209         iv[11] = 0x00;
 210
 211         iv[4] = iv[0];
 212         iv[5] = iv[1];
 213         iv[6] = iv[2];
 214         iv[7] = iv[3];
 215
 216         return (iv + 4);
 217 }
 218
 219 /**
 220  * cnstr_shdsc_snow_f9 - SNOW/f9 (UIA2) as a shared descriptor
 221  * @descbuf: pointer to descriptor-under-construction buffer
 222  * @ps: if 36/40bit addressing is desired, this parameter must be true
 223  * @swap: must be true when core endianness doesn't match SEC endianness
 224  * @authdata: pointer to authentication transform definitions
 225  * @chk_icv: check or generate ICV value
 226  * @authlen: size of digest
 227  *
 228  * Return: size of descriptor written in words or negative number on error
 229  */
 230 static inline int
 231 cnstr_shdsc_snow_f9(uint32_t *descbuf, bool ps, bool swap,
 232                     struct alginfo *authdata, uint8_t chk_icv,
 233                     uint32_t authlen)
 234 {
 235         struct program prg;
 236         struct program *p = &prg;
 237         int dir = chk_icv ? DIR_DEC : DIR_ENC;
 238
 239         PROGRAM_CNTXT_INIT(p, descbuf, 0);
 240         if (swap)
 241                 PROGRAM_SET_BSWAP(p);
 242
 243         if (ps)
 244                 PROGRAM_SET_36BIT_ADDR(p);
 245
 246         SHR_HDR(p, SHR_ALWAYS, 1, 0);
 247
 248         KEY(p, KEY2, authdata->key_enc_flags, authdata->key,
 249             authdata->keylen, INLINE_KEY(authdata));
 250
 251         SEQLOAD(p, CONTEXT2, 0, 12, 0);
 252
 253         if (chk_icv == ICV_CHECK_ENABLE)
 254                 MATHB(p, SEQINSZ, SUB, authlen, VSEQINSZ, 4, IMMED2);
 255         else
 256                 MATHB(p, SEQINSZ, SUB, ZERO, VSEQINSZ, 4, 0);
 257
 258         ALG_OPERATION(p, OP_ALG_ALGSEL_SNOW_F9, OP_ALG_AAI_F9,
 259                       OP_ALG_AS_INITFINAL, chk_icv, dir);
 260
 261         SEQFIFOLOAD(p, MSG2, 0, VLF | CLASS2 | LAST2);
 262
 263         if (chk_icv == ICV_CHECK_ENABLE)
 264                 SEQFIFOLOAD(p, ICV2, authlen, LAST2);
 265         else
 266                 /* Save lower half of MAC out into a 32-bit sequence */
 267                 SEQSTORE(p, CONTEXT2, 0, authlen, 0);
 268
 269         return PROGRAM_FINALIZE(p);
 270 }
 271
 272 /**
 273  * cnstr_shdsc_blkcipher - block cipher transformation
 274  * @descbuf: pointer to descriptor-under-construction buffer
 275  * @ps: if 36/40bit addressing is desired, this parameter must be true
 276  * @swap: must be true when core endianness doesn't match SEC endianness
 277  * @share: sharing type of shared descriptor
 278  * @cipherdata: pointer to block cipher transform definitions
 279  *              Valid algorithm values one of OP_ALG_ALGSEL_* {DES, 3DES, AES}
 280  *              Valid modes for:
 281  *                  AES: OP_ALG_AAI_* {CBC, CTR}
 282  *                  DES, 3DES: OP_ALG_AAI_CBC
 283  * @iv: IV data; if NULL, "ivlen" bytes from the input frame will be read as IV
 284  * @ivlen: IV length
 285  * @dir: DIR_ENC/DIR_DEC
 286  *
 287  * Return: size of descriptor written in words or negative number on error
 288  */
 289 static inline int
 290 cnstr_shdsc_blkcipher(uint32_t *descbuf, bool ps, bool swap,
 291                       enum rta_share_type share,
 292                       struct alginfo *cipherdata,
 293                       uint32_t ivlen, uint8_t dir)
 294 {
 295         struct program prg;
 296         struct program *p = &prg;
 297         uint32_t iv_off = 0, counter;
 298         const bool need_dk = (dir == DIR_DEC) &&
 299                              (cipherdata->algtype == OP_ALG_ALGSEL_AES) &&
 300                              (cipherdata->algmode == OP_ALG_AAI_CBC);
 301         LABEL(keyjmp);
 302         LABEL(skipdk);
 303         REFERENCE(pkeyjmp);
 304         REFERENCE(pskipdk);
 305
 306         PROGRAM_CNTXT_INIT(p, descbuf, 0);
 307         if (swap)
 308                 PROGRAM_SET_BSWAP(p);
 309         if (ps)
 310                 PROGRAM_SET_36BIT_ADDR(p);
 311         SHR_HDR(p, share, 1, SC);
 312
 313         pkeyjmp = JUMP(p, keyjmp, LOCAL_JUMP, ALL_TRUE, SHRD);
 314         /* Insert Key */
 315         KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
 316             cipherdata->keylen, INLINE_KEY(cipherdata));
 317
 318         if (need_dk) {
 319                 ALG_OPERATION(p, cipherdata->algtype, cipherdata->algmode,
 320                               OP_ALG_AS_INITFINAL, ICV_CHECK_DISABLE, dir);
 321
 322                 pskipdk = JUMP(p, skipdk, LOCAL_JUMP, ALL_TRUE, 0);
 323         }
 324         SET_LABEL(p, keyjmp);
 325
 326         if (need_dk) {
 327                 ALG_OPERATION(p, OP_ALG_ALGSEL_AES, cipherdata->algmode |
 328                               OP_ALG_AAI_DK, OP_ALG_AS_INITFINAL,
 329                               ICV_CHECK_DISABLE, dir);
 330                 SET_LABEL(p, skipdk);
 331         } else {
 332                 ALG_OPERATION(p, cipherdata->algtype, cipherdata->algmode,
 333                               OP_ALG_AS_INITFINAL, ICV_CHECK_DISABLE, dir);
 334         }
 335
 336         if (cipherdata->algmode == OP_ALG_AAI_CTR)
 337                 iv_off = 16;
 338
 339         /* IV is present first before the actual message */
 340         SEQLOAD(p, CONTEXT1, iv_off, ivlen, 0);
 341
 342         /* If IV len is less than 16 bytes, set 'counter' as 1 */
 343         if (cipherdata->algmode == OP_ALG_AAI_CTR && ivlen < 16) {
 344                 counter = 1;
 345                 if (!swap)
 346                         counter = swab32(1);
 347
 348                 LOAD(p, counter, CONTEXT1, (iv_off + ivlen), 16 - ivlen, IMMED);
 349         }
 350
 351         MATHB(p, SEQINSZ, SUB, MATH2, VSEQINSZ, 4, 0);
 352         MATHB(p, SEQINSZ, SUB, MATH2, VSEQOUTSZ, 4, 0);
 353
 354         /* Insert sequence load/store with VLF */
 355         SEQFIFOLOAD(p, MSG1, 0, VLF | LAST1);
 356         SEQFIFOSTORE(p, MSG, 0, 0, VLF);
 357
 358         PATCH_JUMP(p, pkeyjmp, keyjmp);
 359         if (need_dk)
 360                 PATCH_JUMP(p, pskipdk, skipdk);
 361
 362         return PROGRAM_FINALIZE(p);
 363 }
 364
 365 /**
 366  * cnstr_shdsc_hmac - HMAC shared
 367  * @descbuf: pointer to descriptor-under-construction buffer
 368  * @ps: if 36/40bit addressing is desired, this parameter must be true
 369  * @swap: must be true when core endianness doesn't match SEC endianness
 370  * @share: sharing type of shared descriptor
 371  * @authdata: pointer to authentication transform definitions;
 372  *            message digest algorithm: OP_ALG_ALGSEL_MD5/ SHA1-512.
 373  * @do_icv: 0 if ICV checking is not desired, any other value if ICV checking
 374  *          is needed for all the packets processed by this shared descriptor
 375  * @trunc_len: Length of the truncated ICV to be written in the output buffer, 0
 376  *             if no truncation is needed
 377  *
 378  * Note: There's no support for keys longer than the block size of the
 379  * underlying hash function, according to the selected algorithm.
 380  *
 381  * Return: size of descriptor written in words or negative number on error
 382  */
 383 static inline int
 384 cnstr_shdsc_hmac(uint32_t *descbuf, bool ps, bool swap,
 385                  enum rta_share_type share,
 386                  struct alginfo *authdata, uint8_t do_icv,
 387                  uint8_t trunc_len)
 388 {
 389         struct program prg;
 390         struct program *p = &prg;
 391         uint8_t storelen, opicv, dir;
 392         LABEL(keyjmp);
 393         LABEL(jmpprecomp);
 394         REFERENCE(pkeyjmp);
 395         REFERENCE(pjmpprecomp);
 396
 397         /* Compute fixed-size store based on alg selection */
 398         switch (authdata->algtype) {
 399         case OP_ALG_ALGSEL_MD5:
 400                 storelen = 16;
 401                 break;
 402         case OP_ALG_ALGSEL_SHA1:
 403                 storelen = 20;
 404                 break;
 405         case OP_ALG_ALGSEL_SHA224:
 406                 storelen = 28;
 407                 break;
 408         case OP_ALG_ALGSEL_SHA256:
 409                 storelen = 32;
 410                 break;
 411         case OP_ALG_ALGSEL_SHA384:
 412                 storelen = 48;
 413                 break;
 414         case OP_ALG_ALGSEL_SHA512:
 415                 storelen = 64;
 416                 break;
 417         default:
 418                 return -EINVAL;
 419         }
 420
 421         trunc_len = trunc_len && (trunc_len < storelen) ? trunc_len : storelen;
 422
 423         opicv = do_icv ? ICV_CHECK_ENABLE : ICV_CHECK_DISABLE;
 424         dir = do_icv ? DIR_DEC : DIR_ENC;
 425
 426         PROGRAM_CNTXT_INIT(p, descbuf, 0);
 427         if (swap)
 428                 PROGRAM_SET_BSWAP(p);
 429         if (ps)
 430                 PROGRAM_SET_36BIT_ADDR(p);
 431         SHR_HDR(p, share, 1, SC);
 432
 433         pkeyjmp = JUMP(p, keyjmp, LOCAL_JUMP, ALL_TRUE, SHRD);
 434         KEY(p, KEY2, authdata->key_enc_flags, authdata->key, authdata->keylen,
 435             INLINE_KEY(authdata));
 436
 437         /* Do operation */
 438         ALG_OPERATION(p, authdata->algtype, OP_ALG_AAI_HMAC,
 439                       OP_ALG_AS_INITFINAL, opicv, dir);
 440
 441         pjmpprecomp = JUMP(p, jmpprecomp, LOCAL_JUMP, ALL_TRUE, 0);
 442         SET_LABEL(p, keyjmp);
 443
 444         ALG_OPERATION(p, authdata->algtype, OP_ALG_AAI_HMAC_PRECOMP,
 445                       OP_ALG_AS_INITFINAL, opicv, dir);
 446
 447         SET_LABEL(p, jmpprecomp);
 448
 449         /* compute sequences */
 450         if (opicv == ICV_CHECK_ENABLE)
 451                 MATHB(p, SEQINSZ, SUB, trunc_len, VSEQINSZ, 4, IMMED2);
 452         else
 453                 MATHB(p, SEQINSZ, SUB, MATH2, VSEQINSZ, 4, 0);
 454
 455         /* Do load (variable length) */
 456         SEQFIFOLOAD(p, MSG2, 0, VLF | LAST2);
 457
 458         if (opicv == ICV_CHECK_ENABLE)
 459                 SEQFIFOLOAD(p, ICV2, trunc_len, LAST2);
 460         else
 461                 SEQSTORE(p, CONTEXT2, 0, trunc_len, 0);
 462
 463         PATCH_JUMP(p, pkeyjmp, keyjmp);
 464         PATCH_JUMP(p, pjmpprecomp, jmpprecomp);
 465
 466         return PROGRAM_FINALIZE(p);
 467 }
 468
 469 /**
 470  * cnstr_shdsc_kasumi_f8 - KASUMI F8 (Confidentiality) as a shared descriptor
 471  *                         (ETSI "Document 1: f8 and f9 specification")
 472  * @descbuf: pointer to descriptor-under-construction buffer
 473  * @ps: if 36/40bit addressing is desired, this parameter must be true
 474  * @swap: must be true when core endianness doesn't match SEC endianness
 475  * @cipherdata: pointer to block cipher transform definitions
 476  * @dir: cipher direction (DIR_ENC/DIR_DEC)
 477  * @count: count value (32 bits)
 478  * @bearer: bearer ID (5 bits)
 479  * @direction: direction (1 bit)
 480  *
 481  * Return: size of descriptor written in words or negative number on error
 482  */
 483 static inline int
 484 cnstr_shdsc_kasumi_f8(uint32_t *descbuf, bool ps, bool swap,
 485                       struct alginfo *cipherdata, uint8_t dir)
 486 {
 487         struct program prg;
 488         struct program *p = &prg;
 489
 490         PROGRAM_CNTXT_INIT(p, descbuf, 0);
 491         if (swap)
 492                 PROGRAM_SET_BSWAP(p);
 493         if (ps)
 494                 PROGRAM_SET_36BIT_ADDR(p);
 495         SHR_HDR(p, SHR_ALWAYS, 1, 0);
 496
 497         KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
 498             cipherdata->keylen, INLINE_KEY(cipherdata));
 499         SEQLOAD(p, CONTEXT1, 0, 8, 0);
 500         MATHB(p, SEQINSZ, SUB, MATH2, VSEQINSZ, 4, 0);
 501         MATHB(p, SEQINSZ, SUB, MATH2, VSEQOUTSZ, 4, 0);
 502         ALG_OPERATION(p, OP_ALG_ALGSEL_KASUMI, OP_ALG_AAI_F8,
 503                       OP_ALG_AS_INITFINAL, 0, dir);
 504         SEQFIFOLOAD(p, MSG1, 0, VLF | LAST1);
 505         SEQFIFOSTORE(p, MSG, 0, 0, VLF);
 506
 507         return PROGRAM_FINALIZE(p);
 508 }
 509
 510 /**
 511  * cnstr_shdsc_kasumi_f9 -  KASUMI F9 (Integrity) as a shared descriptor
 512  *                          (ETSI "Document 1: f8 and f9 specification")
 513  * @descbuf: pointer to descriptor-under-construction buffer
 514  * @ps: if 36/40bit addressing is desired, this parameter must be true
 515  * @swap: must be true when core endianness doesn't match SEC endianness
 516  * @authdata: pointer to authentication transform definitions
 517  * @chk_icv: check or generate ICV value
 518  * @authlen: size of digest
 519  *
 520  * Return: size of descriptor written in words or negative number on error
 521  */
 522 static inline int
 523 cnstr_shdsc_kasumi_f9(uint32_t *descbuf, bool ps, bool swap,
 524                     struct alginfo *authdata, uint8_t chk_icv,
 525                     uint32_t authlen)
 526 {
 527         struct program prg;
 528         struct program *p = &prg;
 529         int dir = chk_icv ? DIR_DEC : DIR_ENC;
 530
 531         PROGRAM_CNTXT_INIT(p, descbuf, 0);
 532         if (swap)
 533                 PROGRAM_SET_BSWAP(p);
 534
 535         if (ps)
 536                 PROGRAM_SET_36BIT_ADDR(p);
 537
 538         SHR_HDR(p, SHR_ALWAYS, 1, 0);
 539
 540         KEY(p, KEY2, authdata->key_enc_flags, authdata->key,
 541             authdata->keylen, INLINE_KEY(authdata));
 542
 543         SEQLOAD(p, CONTEXT2, 0, 12, 0);
 544
 545         if (chk_icv == ICV_CHECK_ENABLE)
 546                 MATHB(p, SEQINSZ, SUB, authlen, VSEQINSZ, 4, IMMED2);
 547         else
 548                 MATHB(p, SEQINSZ, SUB, ZERO, VSEQINSZ, 4, 0);
 549
 550         ALG_OPERATION(p, OP_ALG_ALGSEL_KASUMI, OP_ALG_AAI_F9,
 551                       OP_ALG_AS_INITFINAL, chk_icv, dir);
 552
 553         SEQFIFOLOAD(p, MSG2, 0, VLF | CLASS2 | LAST2);
 554
 555         if (chk_icv == ICV_CHECK_ENABLE)
 556                 SEQFIFOLOAD(p, ICV2, authlen, LAST2);
 557         else
 558                 /* Save lower half of MAC out into a 32-bit sequence */
 559                 SEQSTORE(p, CONTEXT2, 0, authlen, 0);
 560
 561         return PROGRAM_FINALIZE(p);
 562 }
 563
 564 /**
 565  * cnstr_shdsc_crc - CRC32 Accelerator (IEEE 802 CRC32 protocol mode)
 566  * @descbuf: pointer to descriptor-under-construction buffer
 567  * @swap: must be true when core endianness doesn't match SEC endianness
 568  *
 569  * Return: size of descriptor written in words or negative number on error
 570  */
 571 static inline int
 572 cnstr_shdsc_crc(uint32_t *descbuf, bool swap)
 573 {
 574         struct program prg;
 575         struct program *p = &prg;
 576
 577         PROGRAM_CNTXT_INIT(p, descbuf, 0);
 578         if (swap)
 579                 PROGRAM_SET_BSWAP(p);
 580
 581         SHR_HDR(p, SHR_ALWAYS, 1, 0);
 582
 583         MATHB(p, SEQINSZ, SUB, MATH2, VSEQINSZ, 4, 0);
 584         ALG_OPERATION(p, OP_ALG_ALGSEL_CRC,
 585                       OP_ALG_AAI_802 | OP_ALG_AAI_DOC,
 586                       OP_ALG_AS_FINALIZE, 0, DIR_ENC);
 587         SEQFIFOLOAD(p, MSG2, 0, VLF | LAST2);
 588         SEQSTORE(p, CONTEXT2, 0, 4, 0);
 589
 590         return PROGRAM_FINALIZE(p);
 591 }
 592
 593 /**
 594  * cnstr_shdsc_gcm_encap - AES-GCM encap as a shared descriptor
 595  * @descbuf: pointer to descriptor-under-construction buffer
 596  * @ps: if 36/40bit addressing is desired, this parameter must be true
 597  * @swap: must be true when core endianness doesn't match SEC endianness
 598  * @share: sharing type of shared descriptor
 599  * @cipherdata: pointer to block cipher transform definitions
 600  *              Valid algorithm values - OP_ALG_ALGSEL_AES ANDed with
 601  *              OP_ALG_AAI_GCM.
 602  * @ivlen: Initialization vector length
 603  * @icvsize: integrity check value (ICV) size (truncated or full)
 604  *
 605  * Return: size of descriptor written in words or negative number on error
 606  */
 607 static inline int
 608 cnstr_shdsc_gcm_encap(uint32_t *descbuf, bool ps, bool swap,
 609                       enum rta_share_type share,
 610                       struct alginfo *cipherdata,
 611                       uint32_t ivlen, uint32_t icvsize)
 612 {
 613         struct program prg;
 614         struct program *p = &prg;
 615
 616         LABEL(keyjmp);
 617         LABEL(zeroassocjump2);
 618         LABEL(zeroassocjump1);
 619         LABEL(zeropayloadjump);
 620         REFERENCE(pkeyjmp);
 621         REFERENCE(pzeroassocjump2);
 622         REFERENCE(pzeroassocjump1);
 623         REFERENCE(pzeropayloadjump);
 624
 625         PROGRAM_CNTXT_INIT(p, descbuf, 0);
 626
 627         if (swap)
 628                 PROGRAM_SET_BSWAP(p);
 629         if (ps)
 630                 PROGRAM_SET_36BIT_ADDR(p);
 631
 632         SHR_HDR(p, share, 1, SC);
 633
 634         pkeyjmp = JUMP(p, keyjmp, LOCAL_JUMP, ALL_TRUE, SELF | SHRD);
 635         /* Insert Key */
 636         KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
 637             cipherdata->keylen, INLINE_KEY(cipherdata));
 638
 639         SET_LABEL(p, keyjmp);
 640
 641         /* class 1 operation */
 642         ALG_OPERATION(p, cipherdata->algtype, cipherdata->algmode,
 643                       OP_ALG_AS_INITFINAL, ICV_CHECK_DISABLE, DIR_ENC);
 644
 645         MATHB(p, DPOVRD, AND, 0x7fffffff, MATH3, 4, IMMED2);
 646
 647         /* if assoclen + cryptlen is ZERO, skip to ICV write */
 648         MATHB(p, SEQINSZ, SUB, ivlen, VSEQOUTSZ, 4, IMMED2);
 649         pzeroassocjump2 = JUMP(p, zeroassocjump2, LOCAL_JUMP, ALL_TRUE, MATH_Z);
 650
 651         SEQFIFOLOAD(p, IV1, ivlen, FLUSH1);
 652
 653         /* if assoclen is ZERO, skip reading the assoc data */
 654         MATHB(p, ZERO, ADD, MATH3, VSEQINSZ, 4, 0);
 655         pzeroassocjump1 = JUMP(p, zeroassocjump1, LOCAL_JUMP, ALL_TRUE, MATH_Z);
 656
 657         /* cryptlen = seqinlen - assoclen */
 658         MATHB(p, SEQINSZ, SUB, MATH3, VSEQOUTSZ, 4, 0);
 659
 660         /* if cryptlen is ZERO jump to zero-payload commands */
 661         pzeropayloadjump = JUMP(p, zeropayloadjump, LOCAL_JUMP, ALL_TRUE,
 662                                 MATH_Z);
 663
 664         /* read assoc data */
 665         SEQFIFOLOAD(p, AAD1, 0, CLASS1 | VLF | FLUSH1);
 666         SET_LABEL(p, zeroassocjump1);
 667
 668         MATHB(p, SEQINSZ, SUB, MATH0, VSEQINSZ, 4, 0);
 669
 670         /* write encrypted data */
 671         SEQFIFOSTORE(p, MSG, 0, 0, VLF);
 672
 673         /* read payload data */
 674         SEQFIFOLOAD(p, MSG1, 0, CLASS1 | VLF | LAST1);
 675
 676         /* jump the zero-payload commands */
 677         JUMP(p, 4, LOCAL_JUMP, ALL_TRUE, 0);
 678
 679         /* zero-payload commands */
 680         SET_LABEL(p, zeropayloadjump);
 681
 682         /* read assoc data */
 683         SEQFIFOLOAD(p, AAD1, 0, CLASS1 | VLF | LAST1);
 684
 685         JUMP(p, 2, LOCAL_JUMP, ALL_TRUE, 0);
 686
 687         /* There is no input data */
 688         SET_LABEL(p, zeroassocjump2);
 689
 690         SEQFIFOLOAD(p, IV1, ivlen, FLUSH1 | LAST1);
 691
 692         /* write ICV */
 693         SEQSTORE(p, CONTEXT1, 0, icvsize, 0);
 694
 695         PATCH_JUMP(p, pkeyjmp, keyjmp);
 696         PATCH_JUMP(p, pzeroassocjump2, zeroassocjump2);
 697         PATCH_JUMP(p, pzeroassocjump1, zeroassocjump1);
 698         PATCH_JUMP(p, pzeropayloadjump, zeropayloadjump);
 699
 700         return PROGRAM_FINALIZE(p);
 701 }
 702
 703 /**
 704  * cnstr_shdsc_gcm_decap - AES-GCM decap as a shared descriptor
 705  * @descbuf: pointer to descriptor-under-construction buffer
 706  * @ps: if 36/40bit addressing is desired, this parameter must be true
 707  * @swap: must be true when core endianness doesn't match SEC endianness
 708  * @share: sharing type of shared descriptor
 709  * @cipherdata: pointer to block cipher transform definitions
 710  *              Valid algorithm values - OP_ALG_ALGSEL_AES ANDed with
 711  *              OP_ALG_AAI_GCM.
 712  * @icvsize: integrity check value (ICV) size (truncated or full)
 713  *
 714  * Return: size of descriptor written in words or negative number on error
 715  */
 716 static inline int
 717 cnstr_shdsc_gcm_decap(uint32_t *descbuf, bool ps, bool swap,
 718                       enum rta_share_type share,
 719                       struct alginfo *cipherdata,
 720                       uint32_t ivlen, uint32_t icvsize)
 721 {
 722         struct program prg;
 723         struct program *p = &prg;
 724
 725         LABEL(keyjmp);
 726         LABEL(zeroassocjump1);
 727         LABEL(zeropayloadjump);
 728         REFERENCE(pkeyjmp);
 729         REFERENCE(pzeroassocjump1);
 730         REFERENCE(pzeropayloadjump);
 731
 732         PROGRAM_CNTXT_INIT(p, descbuf, 0);
 733
 734         if (swap)
 735                 PROGRAM_SET_BSWAP(p);
 736         if (ps)
 737                 PROGRAM_SET_36BIT_ADDR(p);
 738
 739         SHR_HDR(p, share, 1, SC);
 740
 741         pkeyjmp = JUMP(p, keyjmp, LOCAL_JUMP, ALL_TRUE, SELF | SHRD);
 742         /* Insert Key */
 743         KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
 744             cipherdata->keylen, INLINE_KEY(cipherdata));
 745
 746         SET_LABEL(p, keyjmp);
 747
 748         /* class 1 operation */
 749         ALG_OPERATION(p, cipherdata->algtype, cipherdata->algmode,
 750                       OP_ALG_AS_INITFINAL, ICV_CHECK_ENABLE, DIR_DEC);
 751
 752         MATHB(p, DPOVRD, AND, 0x7fffffff, MATH3, 4, IMMED2);
 753         SEQFIFOLOAD(p, IV1, ivlen, FLUSH1);
 754
 755         /* if assoclen is ZERO, skip reading the assoc data */
 756         MATHB(p, ZERO, ADD, MATH3, VSEQINSZ, 4, 0);
 757         pzeroassocjump1 = JUMP(p, zeroassocjump1, LOCAL_JUMP, ALL_TRUE, MATH_Z);
 758
 759         /* read assoc data */
 760         SEQFIFOLOAD(p, AAD1, 0, CLASS1 | VLF | FLUSH1);
 761
 762         SET_LABEL(p, zeroassocjump1);
 763
 764         /* cryptlen = seqoutlen - assoclen */
 765         MATHB(p, SEQOUTSZ, SUB, MATH0, VSEQINSZ, 4, 0);
 766
 767         /* jump to zero-payload command if cryptlen is zero */
 768         pzeropayloadjump = JUMP(p, zeropayloadjump, LOCAL_JUMP, ALL_TRUE,
 769                                 MATH_Z);
 770
 771         MATHB(p, SEQOUTSZ, SUB, MATH0, VSEQOUTSZ, 4, 0);
 772
 773         /* store encrypted data */
 774         SEQFIFOSTORE(p, MSG, 0, 0, VLF);
 775
 776         /* read payload data */
 777         SEQFIFOLOAD(p, MSG1, 0, CLASS1 | VLF | FLUSH1);
 778
 779         /* zero-payload command */
 780         SET_LABEL(p, zeropayloadjump);
 781
 782         /* read ICV */
 783         SEQFIFOLOAD(p, ICV1, icvsize, CLASS1 | LAST1);
 784
 785         PATCH_JUMP(p, pkeyjmp, keyjmp);
 786         PATCH_JUMP(p, pzeroassocjump1, zeroassocjump1);
 787         PATCH_JUMP(p, pzeropayloadjump, zeropayloadjump);
 788
 789         return PROGRAM_FINALIZE(p);
 790 }
 791
 792 #endif /* __DESC_ALGO_H__ */