drivers/crypto/qat/qat_crypto_capabilities.h

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright(c) 2017 Intel Corporation. All rights reserved.
   5  *   All rights reserved.
   6  *
   7  *   Redistribution and use in source and binary forms, with or without
   8  *   modification, are permitted provided that the following conditions
   9  *   are met:
  10  *
  11  *     * Redistributions of source code must retain the above copyright
  12  *       notice, this list of conditions and the following disclaimer.
  13  *     * Redistributions in binary form must reproduce the above copyright
  14  *       notice, this list of conditions and the following disclaimer in
  15  *       the documentation and/or other materials provided with the
  16  *       distribution.
  17  *     * Neither the name of Intel Corporation nor the names of its
  18  *       contributors may be used to endorse or promote products derived
  19  *       from this software without specific prior written permission.
  20  *
  21  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  24  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  25  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  26  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  27  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  31  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  */
  33
  34 #ifndef _QAT_CRYPTO_CAPABILITIES_H_
  35 #define _QAT_CRYPTO_CAPABILITIES_H_
  36
  37 #define QAT_BASE_CPM16_SYM_CAPABILITIES                                 \
  38         {       /* SHA1 HMAC */                                         \
  39                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
  40                 {.sym = {                                               \
  41                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
  42                         {.auth = {                                      \
  43                                 .algo = RTE_CRYPTO_AUTH_SHA1_HMAC,      \
  44                                 .block_size = 64,                       \
  45                                 .key_size = {                           \
  46                                         .min = 64,                      \
  47                                         .max = 64,                      \
  48                                         .increment = 0                  \
  49                                 },                                      \
  50                                 .digest_size = {                        \
  51                                         .min = 20,                      \
  52                                         .max = 20,                      \
  53                                         .increment = 0                  \
  54                                 },                                      \
  55                                 .aad_size = { 0 },                      \
  56                                 .iv_size = { 0 }                        \
  57                         }, }                                            \
  58                 }, }                                                    \
  59         },                                                              \
  60         {       /* SHA224 HMAC */                                       \
  61                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
  62                 {.sym = {                                               \
  63                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
  64                         {.auth = {                                      \
  65                                 .algo = RTE_CRYPTO_AUTH_SHA224_HMAC,    \
  66                                 .block_size = 64,                       \
  67                                 .key_size = {                           \
  68                                         .min = 64,                      \
  69                                         .max = 64,                      \
  70                                         .increment = 0                  \
  71                                 },                                      \
  72                                 .digest_size = {                        \
  73                                         .min = 28,                      \
  74                                         .max = 28,                      \
  75                                         .increment = 0                  \
  76                                 },                                      \
  77                                 .aad_size = { 0 },                      \
  78                                 .iv_size = { 0 }                        \
  79                         }, }                                            \
  80                 }, }                                                    \
  81         },                                                              \
  82         {       /* SHA256 HMAC */                                       \
  83                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
  84                 {.sym = {                                               \
  85                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
  86                         {.auth = {                                      \
  87                                 .algo = RTE_CRYPTO_AUTH_SHA256_HMAC,    \
  88                                 .block_size = 64,                       \
  89                                 .key_size = {                           \
  90                                         .min = 64,                      \
  91                                         .max = 64,                      \
  92                                         .increment = 0                  \
  93                                 },                                      \
  94                                 .digest_size = {                        \
  95                                         .min = 32,                      \
  96                                         .max = 32,                      \
  97                                         .increment = 0                  \
  98                                 },                                      \
  99                                 .aad_size = { 0 },                      \
 100                                 .iv_size = { 0 }                        \
 101                         }, }                                            \
 102                 }, }                                                    \
 103         },                                                              \
 104         {       /* SHA384 HMAC */                                       \
 105                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 106                 {.sym = {                                               \
 107                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
 108                         {.auth = {                                      \
 109                                 .algo = RTE_CRYPTO_AUTH_SHA384_HMAC,    \
 110                                 .block_size = 64,                       \
 111                                 .key_size = {                           \
 112                                         .min = 128,                     \
 113                                         .max = 128,                     \
 114                                         .increment = 0                  \
 115                                 },                                      \
 116                                 .digest_size = {                        \
 117                                         .min = 48,                      \
 118                                         .max = 48,                      \
 119                                         .increment = 0                  \
 120                                 },                                      \
 121                                 .aad_size = { 0 },                      \
 122                                 .iv_size = { 0 }                        \
 123                         }, }                                            \
 124                 }, }                                                    \
 125         },                                                              \
 126         {       /* SHA512 HMAC */                                       \
 127                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 128                 {.sym = {                                               \
 129                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
 130                         {.auth = {                                      \
 131                                 .algo = RTE_CRYPTO_AUTH_SHA512_HMAC,    \
 132                                 .block_size = 128,                      \
 133                                 .key_size = {                           \
 134                                         .min = 128,                     \
 135                                         .max = 128,                     \
 136                                         .increment = 0                  \
 137                                 },                                      \
 138                                 .digest_size = {                        \
 139                                         .min = 64,                      \
 140                                         .max = 64,                      \
 141                                         .increment = 0                  \
 142                                 },                                      \
 143                                 .aad_size = { 0 },                      \
 144                                 .iv_size = { 0 }                        \
 145                         }, }                                            \
 146                 }, }                                                    \
 147         },                                                              \
 148         {       /* MD5 HMAC */                                          \
 149                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 150                 {.sym = {                                               \
 151                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
 152                         {.auth = {                                      \
 153                                 .algo = RTE_CRYPTO_AUTH_MD5_HMAC,       \
 154                                 .block_size = 64,                       \
 155                                 .key_size = {                           \
 156                                         .min = 8,                       \
 157                                         .max = 64,                      \
 158                                         .increment = 8                  \
 159                                 },                                      \
 160                                 .digest_size = {                        \
 161                                         .min = 16,                      \
 162                                         .max = 16,                      \
 163                                         .increment = 0                  \
 164                                 },                                      \
 165                                 .aad_size = { 0 },                      \
 166                                 .iv_size = { 0 }                        \
 167                         }, }                                            \
 168                 }, }                                                    \
 169         },                                                              \
 170         {       /* AES XCBC MAC */                                      \
 171                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 172                 {.sym = {                                               \
 173                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
 174                         {.auth = {                                      \
 175                                 .algo = RTE_CRYPTO_AUTH_AES_XCBC_MAC,   \
 176                                 .block_size = 16,                       \
 177                                 .key_size = {                           \
 178                                         .min = 16,                      \
 179                                         .max = 16,                      \
 180                                         .increment = 0                  \
 181                                 },                                      \
 182                                 .digest_size = {                        \
 183                                         .min = 16,                      \
 184                                         .max = 16,                      \
 185                                         .increment = 0                  \
 186                                 },                                      \
 187                                 .aad_size = { 0 },                      \
 188                                 .iv_size = { 0 }                        \
 189                         }, }                                            \
 190                 }, }                                                    \
 191         },                                                              \
 192         {       /* AES GCM (AUTH) */                                    \
 193                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 194                 {.sym = {                                               \
 195                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
 196                         {.auth = {                                      \
 197                                 .algo = RTE_CRYPTO_AUTH_AES_GCM,        \
 198                                 .block_size = 16,                       \
 199                                 .key_size = {                           \
 200                                         .min = 16,                      \
 201                                         .max = 32,                      \
 202                                         .increment = 8                  \
 203                                 },                                      \
 204                                 .digest_size = {                        \
 205                                         .min = 8,                       \
 206                                         .max = 16,                      \
 207                                         .increment = 4                  \
 208                                 },                                      \
 209                                 .aad_size = {                           \
 210                                         .min = 0,                       \
 211                                         .max = 240,                     \
 212                                         .increment = 1                  \
 213                                 },                                      \
 214                                 .iv_size = { 0 }                        \
 215                         }, }                                            \
 216                 }, }                                                    \
 217         },                                                              \
 218         {       /* AES GMAC (AUTH) */                                   \
 219                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 220                 {.sym = {                                               \
 221                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
 222                         {.auth = {                                      \
 223                                 .algo = RTE_CRYPTO_AUTH_AES_GMAC,       \
 224                                 .block_size = 16,                       \
 225                                 .key_size = {                           \
 226                                         .min = 16,                      \
 227                                         .max = 32,                      \
 228                                         .increment = 8                  \
 229                                 },                                      \
 230                                 .digest_size = {                        \
 231                                         .min = 8,                       \
 232                                         .max = 16,                      \
 233                                         .increment = 4                  \
 234                                 },                                      \
 235                                 .aad_size = {                           \
 236                                         .min = 1,                       \
 237                                         .max = 65535,                   \
 238                                         .increment = 1                  \
 239                                 },                                      \
 240                                 .iv_size = { 0 }                        \
 241                         }, }                                            \
 242                 }, }                                                    \
 243         },                                                              \
 244         {       /* SNOW 3G (UIA2) */                                    \
 245                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 246                 {.sym = {                                               \
 247                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
 248                         {.auth = {                                      \
 249                                 .algo = RTE_CRYPTO_AUTH_SNOW3G_UIA2,    \
 250                                 .block_size = 16,                       \
 251                                 .key_size = {                           \
 252                                         .min = 16,                      \
 253                                         .max = 16,                      \
 254                                         .increment = 0                  \
 255                                 },                                      \
 256                                 .digest_size = {                        \
 257                                         .min = 4,                       \
 258                                         .max = 4,                       \
 259                                         .increment = 0                  \
 260                                 },                                      \
 261                                 .iv_size = {                            \
 262                                         .min = 16,                      \
 263                                         .max = 16,                      \
 264                                         .increment = 0                  \
 265                                 },                                      \
 266                                 .aad_size = { 0 }                       \
 267                         }, }                                            \
 268                 }, }                                                    \
 269         },                                                              \
 270         {       /* AES GCM (CIPHER) */                                  \
 271                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 272                 {.sym = {                                               \
 273                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 274                         {.cipher = {                                    \
 275                                 .algo = RTE_CRYPTO_CIPHER_AES_GCM,      \
 276                                 .block_size = 16,                       \
 277                                 .key_size = {                           \
 278                                         .min = 16,                      \
 279                                         .max = 32,                      \
 280                                         .increment = 8                  \
 281                                 },                                      \
 282                                 .iv_size = {                            \
 283                                         .min = 12,                      \
 284                                         .max = 12,                      \
 285                                         .increment = 0                  \
 286                                 }                                       \
 287                         }, }                                            \
 288                 }, }                                                    \
 289         },                                                              \
 290         {       /* AES CBC */                                           \
 291                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 292                 {.sym = {                                               \
 293                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 294                         {.cipher = {                                    \
 295                                 .algo = RTE_CRYPTO_CIPHER_AES_CBC,      \
 296                                 .block_size = 16,                       \
 297                                 .key_size = {                           \
 298                                         .min = 16,                      \
 299                                         .max = 32,                      \
 300                                         .increment = 8                  \
 301                                 },                                      \
 302                                 .iv_size = {                            \
 303                                         .min = 16,                      \
 304                                         .max = 16,                      \
 305                                         .increment = 0                  \
 306                                 }                                       \
 307                         }, }                                            \
 308                 }, }                                                    \
 309         },                                                              \
 310         {       /* AES DOCSIS BPI */                                    \
 311                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 312                 {.sym = {                                               \
 313                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 314                         {.cipher = {                                    \
 315                                 .algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI,\
 316                                 .block_size = 16,                       \
 317                                 .key_size = {                           \
 318                                         .min = 16,                      \
 319                                         .max = 16,                      \
 320                                         .increment = 0                  \
 321                                 },                                      \
 322                                 .iv_size = {                            \
 323                                         .min = 16,                      \
 324                                         .max = 16,                      \
 325                                         .increment = 0                  \
 326                                 }                                       \
 327                         }, }                                            \
 328                 }, }                                                    \
 329         },                                                              \
 330         {       /* SNOW 3G (UEA2) */                                    \
 331                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 332                 {.sym = {                                               \
 333                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 334                         {.cipher = {                                    \
 335                                 .algo = RTE_CRYPTO_CIPHER_SNOW3G_UEA2,  \
 336                                 .block_size = 16,                       \
 337                                 .key_size = {                           \
 338                                         .min = 16,                      \
 339                                         .max = 16,                      \
 340                                         .increment = 0                  \
 341                                 },                                      \
 342                                 .iv_size = {                            \
 343                                         .min = 16,                      \
 344                                         .max = 16,                      \
 345                                         .increment = 0                  \
 346                                 }                                       \
 347                         }, }                                            \
 348                 }, }                                                    \
 349         },                                                              \
 350         {       /* AES CTR */                                           \
 351                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 352                 {.sym = {                                               \
 353                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 354                         {.cipher = {                                    \
 355                                 .algo = RTE_CRYPTO_CIPHER_AES_CTR,      \
 356                                 .block_size = 16,                       \
 357                                 .key_size = {                           \
 358                                         .min = 16,                      \
 359                                         .max = 32,                      \
 360                                         .increment = 8                  \
 361                                 },                                      \
 362                                 .iv_size = {                            \
 363                                         .min = 16,                      \
 364                                         .max = 16,                      \
 365                                         .increment = 0                  \
 366                                 }                                       \
 367                         }, }                                            \
 368                 }, }                                                    \
 369         },                                                              \
 370         {       /* NULL (AUTH) */                                       \
 371                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 372                 {.sym = {                                               \
 373                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
 374                         {.auth = {                                      \
 375                                 .algo = RTE_CRYPTO_AUTH_NULL,           \
 376                                 .block_size = 1,                        \
 377                                 .key_size = {                           \
 378                                         .min = 0,                       \
 379                                         .max = 0,                       \
 380                                         .increment = 0                  \
 381                                 },                                      \
 382                                 .digest_size = {                        \
 383                                         .min = 0,                       \
 384                                         .max = 0,                       \
 385                                         .increment = 0                  \
 386                                 },                                      \
 387                                 .aad_size = { 0 },                      \
 388                                 .iv_size = { 0 }                        \
 389                         }, },                                           \
 390                 }, },                                                   \
 391         },                                                              \
 392         {       /* NULL (CIPHER) */                                     \
 393                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 394                 {.sym = {                                               \
 395                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 396                         {.cipher = {                                    \
 397                                 .algo = RTE_CRYPTO_CIPHER_NULL,         \
 398                                 .block_size = 1,                        \
 399                                 .key_size = {                           \
 400                                         .min = 0,                       \
 401                                         .max = 0,                       \
 402                                         .increment = 0                  \
 403                                 },                                      \
 404                                 .iv_size = {                            \
 405                                         .min = 0,                       \
 406                                         .max = 0,                       \
 407                                         .increment = 0                  \
 408                                 }                                       \
 409                         }, },                                           \
 410                 }, }                                                    \
 411         },                                                              \
 412         {       /* KASUMI (F8) */                                       \
 413                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 414                 {.sym = {                                               \
 415                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 416                         {.cipher = {                                    \
 417                                 .algo = RTE_CRYPTO_CIPHER_KASUMI_F8,    \
 418                                 .block_size = 8,                        \
 419                                 .key_size = {                           \
 420                                         .min = 16,                      \
 421                                         .max = 16,                      \
 422                                         .increment = 0                  \
 423                                 },                                      \
 424                                 .iv_size = {                            \
 425                                         .min = 8,                       \
 426                                         .max = 8,                       \
 427                                         .increment = 0                  \
 428                                 }                                       \
 429                         }, }                                            \
 430                 }, }                                                    \
 431         },                                                              \
 432         {       /* KASUMI (F9) */                                       \
 433                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 434                 {.sym = {                                               \
 435                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
 436                         {.auth = {                                      \
 437                                 .algo = RTE_CRYPTO_AUTH_KASUMI_F9,      \
 438                                 .block_size = 8,                        \
 439                                 .key_size = {                           \
 440                                         .min = 16,                      \
 441                                         .max = 16,                      \
 442                                         .increment = 0                  \
 443                                 },                                      \
 444                                 .digest_size = {                        \
 445                                         .min = 4,                       \
 446                                         .max = 4,                       \
 447                                         .increment = 0                  \
 448                                 },                                      \
 449                                 .iv_size = {                            \
 450                                         .min = 8,                       \
 451                                         .max = 8,                       \
 452                                         .increment = 0                  \
 453                                 },                                      \
 454                                 .aad_size = { 0 }                       \
 455                         }, }                                            \
 456                 }, }                                                    \
 457         },                                                              \
 458         {       /* 3DES CBC */                                          \
 459                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 460                 {.sym = {                                               \
 461                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 462                         {.cipher = {                                    \
 463                                 .algo = RTE_CRYPTO_CIPHER_3DES_CBC,     \
 464                                 .block_size = 8,                        \
 465                                 .key_size = {                           \
 466                                         .min = 16,                      \
 467                                         .max = 24,                      \
 468                                         .increment = 8                  \
 469                                 },                                      \
 470                                 .iv_size = {                            \
 471                                         .min = 8,                       \
 472                                         .max = 8,                       \
 473                                         .increment = 0                  \
 474                                 }                                       \
 475                         }, }                                            \
 476                 }, }                                                    \
 477         },                                                              \
 478         {       /* 3DES CTR */                                          \
 479                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 480                 {.sym = {                                               \
 481                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 482                         {.cipher = {                                    \
 483                                 .algo = RTE_CRYPTO_CIPHER_3DES_CTR,     \
 484                                 .block_size = 8,                        \
 485                                 .key_size = {                           \
 486                                         .min = 16,                      \
 487                                         .max = 24,                      \
 488                                         .increment = 8                  \
 489                                 },                                      \
 490                                 .iv_size = {                            \
 491                                         .min = 8,                       \
 492                                         .max = 8,                       \
 493                                         .increment = 0                  \
 494                                 }                                       \
 495                         }, }                                            \
 496                 }, }                                                    \
 497         },                                                              \
 498         {       /* DES CBC */                                           \
 499                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 500                 {.sym = {                                               \
 501                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 502                         {.cipher = {                                    \
 503                                 .algo = RTE_CRYPTO_CIPHER_DES_CBC,      \
 504                                 .block_size = 8,                        \
 505                                 .key_size = {                           \
 506                                         .min = 8,                       \
 507                                         .max = 8,                       \
 508                                         .increment = 0                  \
 509                                 },                                      \
 510                                 .iv_size = {                            \
 511                                         .min = 8,                       \
 512                                         .max = 8,                       \
 513                                         .increment = 0                  \
 514                                 }                                       \
 515                         }, }                                            \
 516                 }, }                                                    \
 517         },                                                              \
 518         {       /* DES DOCSISBPI */                                     \
 519                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 520                 {.sym = {                                               \
 521                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 522                         {.cipher = {                                    \
 523                                 .algo = RTE_CRYPTO_CIPHER_DES_DOCSISBPI,\
 524                                 .block_size = 8,                        \
 525                                 .key_size = {                           \
 526                                         .min = 8,                       \
 527                                         .max = 8,                       \
 528                                         .increment = 0                  \
 529                                 },                                      \
 530                                 .iv_size = {                            \
 531                                         .min = 8,                       \
 532                                         .max = 8,                       \
 533                                         .increment = 0                  \
 534                                 }                                       \
 535                         }, }                                            \
 536                 }, }                                                    \
 537         }
 538
 539 #define QAT_EXTRA_CPM17_SYM_CAPABILITIES                                \
 540         {       /* ZUC (EEA3) */                                        \
 541                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 542                 {.sym = {                                               \
 543                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 544                         {.cipher = {                                    \
 545                                 .algo = RTE_CRYPTO_CIPHER_ZUC_EEA3,     \
 546                                 .block_size = 16,                       \
 547                                 .key_size = {                           \
 548                                         .min = 16,                      \
 549                                         .max = 16,                      \
 550                                         .increment = 0                  \
 551                                 },                                      \
 552                                 .iv_size = {                            \
 553                                         .min = 16,                      \
 554                                         .max = 16,                      \
 555                                         .increment = 0                  \
 556                                 }                                       \
 557                         }, }                                            \
 558                 }, }                                                    \
 559         },                                                              \
 560         {       /* ZUC (EIA3) */                                        \
 561                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 562                 {.sym = {                                               \
 563                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
 564                         {.auth = {                                      \
 565                                 .algo = RTE_CRYPTO_AUTH_ZUC_EIA3,       \
 566                                 .block_size = 16,                       \
 567                                 .key_size = {                           \
 568                                         .min = 16,                      \
 569                                         .max = 16,                      \
 570                                         .increment = 0                  \
 571                                 },                                      \
 572                                 .digest_size = {                        \
 573                                         .min = 4,                       \
 574                                         .max = 4,                       \
 575                                         .increment = 0                  \
 576                                 },                                      \
 577                                 .iv_size = {                            \
 578                                         .min = 16,                      \
 579                                         .max = 16,                      \
 580                                         .increment = 0                  \
 581                                 },                                      \
 582                                 .aad_size = { 0 }                       \
 583                         }, }                                            \
 584                 }, }                                                    \
 585         }
 586
 587 #endif /* _QAT_CRYPTO_CAPABILITIES_H_ */