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                                 .iv_size = {                            \
 236                                         .min = 12,                      \
 237                                         .max = 12,                      \
 238                                         .increment = 0                  \
 239                                 }                                       \
 240                         }, }                                            \
 241                 }, }                                                    \
 242         },                                                              \
 243         {       /* SNOW 3G (UIA2) */                                    \
 244                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 245                 {.sym = {                                               \
 246                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
 247                         {.auth = {                                      \
 248                                 .algo = RTE_CRYPTO_AUTH_SNOW3G_UIA2,    \
 249                                 .block_size = 16,                       \
 250                                 .key_size = {                           \
 251                                         .min = 16,                      \
 252                                         .max = 16,                      \
 253                                         .increment = 0                  \
 254                                 },                                      \
 255                                 .digest_size = {                        \
 256                                         .min = 4,                       \
 257                                         .max = 4,                       \
 258                                         .increment = 0                  \
 259                                 },                                      \
 260                                 .iv_size = {                            \
 261                                         .min = 16,                      \
 262                                         .max = 16,                      \
 263                                         .increment = 0                  \
 264                                 },                                      \
 265                                 .aad_size = { 0 }                       \
 266                         }, }                                            \
 267                 }, }                                                    \
 268         },                                                              \
 269         {       /* AES GCM (CIPHER) */                                  \
 270                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 271                 {.sym = {                                               \
 272                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 273                         {.cipher = {                                    \
 274                                 .algo = RTE_CRYPTO_CIPHER_AES_GCM,      \
 275                                 .block_size = 16,                       \
 276                                 .key_size = {                           \
 277                                         .min = 16,                      \
 278                                         .max = 32,                      \
 279                                         .increment = 8                  \
 280                                 },                                      \
 281                                 .iv_size = {                            \
 282                                         .min = 12,                      \
 283                                         .max = 12,                      \
 284                                         .increment = 0                  \
 285                                 }                                       \
 286                         }, }                                            \
 287                 }, }                                                    \
 288         },                                                              \
 289         {       /* AES CBC */                                           \
 290                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 291                 {.sym = {                                               \
 292                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 293                         {.cipher = {                                    \
 294                                 .algo = RTE_CRYPTO_CIPHER_AES_CBC,      \
 295                                 .block_size = 16,                       \
 296                                 .key_size = {                           \
 297                                         .min = 16,                      \
 298                                         .max = 32,                      \
 299                                         .increment = 8                  \
 300                                 },                                      \
 301                                 .iv_size = {                            \
 302                                         .min = 16,                      \
 303                                         .max = 16,                      \
 304                                         .increment = 0                  \
 305                                 }                                       \
 306                         }, }                                            \
 307                 }, }                                                    \
 308         },                                                              \
 309         {       /* AES DOCSIS BPI */                                    \
 310                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 311                 {.sym = {                                               \
 312                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 313                         {.cipher = {                                    \
 314                                 .algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI,\
 315                                 .block_size = 16,                       \
 316                                 .key_size = {                           \
 317                                         .min = 16,                      \
 318                                         .max = 16,                      \
 319                                         .increment = 0                  \
 320                                 },                                      \
 321                                 .iv_size = {                            \
 322                                         .min = 16,                      \
 323                                         .max = 16,                      \
 324                                         .increment = 0                  \
 325                                 }                                       \
 326                         }, }                                            \
 327                 }, }                                                    \
 328         },                                                              \
 329         {       /* SNOW 3G (UEA2) */                                    \
 330                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 331                 {.sym = {                                               \
 332                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 333                         {.cipher = {                                    \
 334                                 .algo = RTE_CRYPTO_CIPHER_SNOW3G_UEA2,  \
 335                                 .block_size = 16,                       \
 336                                 .key_size = {                           \
 337                                         .min = 16,                      \
 338                                         .max = 16,                      \
 339                                         .increment = 0                  \
 340                                 },                                      \
 341                                 .iv_size = {                            \
 342                                         .min = 16,                      \
 343                                         .max = 16,                      \
 344                                         .increment = 0                  \
 345                                 }                                       \
 346                         }, }                                            \
 347                 }, }                                                    \
 348         },                                                              \
 349         {       /* AES CTR */                                           \
 350                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 351                 {.sym = {                                               \
 352                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 353                         {.cipher = {                                    \
 354                                 .algo = RTE_CRYPTO_CIPHER_AES_CTR,      \
 355                                 .block_size = 16,                       \
 356                                 .key_size = {                           \
 357                                         .min = 16,                      \
 358                                         .max = 32,                      \
 359                                         .increment = 8                  \
 360                                 },                                      \
 361                                 .iv_size = {                            \
 362                                         .min = 16,                      \
 363                                         .max = 16,                      \
 364                                         .increment = 0                  \
 365                                 }                                       \
 366                         }, }                                            \
 367                 }, }                                                    \
 368         },                                                              \
 369         {       /* NULL (AUTH) */                                       \
 370                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 371                 {.sym = {                                               \
 372                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
 373                         {.auth = {                                      \
 374                                 .algo = RTE_CRYPTO_AUTH_NULL,           \
 375                                 .block_size = 1,                        \
 376                                 .key_size = {                           \
 377                                         .min = 0,                       \
 378                                         .max = 0,                       \
 379                                         .increment = 0                  \
 380                                 },                                      \
 381                                 .digest_size = {                        \
 382                                         .min = 0,                       \
 383                                         .max = 0,                       \
 384                                         .increment = 0                  \
 385                                 },                                      \
 386                                 .aad_size = { 0 },                      \
 387                                 .iv_size = { 0 }                        \
 388                         }, },                                           \
 389                 }, },                                                   \
 390         },                                                              \
 391         {       /* NULL (CIPHER) */                                     \
 392                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 393                 {.sym = {                                               \
 394                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 395                         {.cipher = {                                    \
 396                                 .algo = RTE_CRYPTO_CIPHER_NULL,         \
 397                                 .block_size = 1,                        \
 398                                 .key_size = {                           \
 399                                         .min = 0,                       \
 400                                         .max = 0,                       \
 401                                         .increment = 0                  \
 402                                 },                                      \
 403                                 .iv_size = {                            \
 404                                         .min = 0,                       \
 405                                         .max = 0,                       \
 406                                         .increment = 0                  \
 407                                 }                                       \
 408                         }, },                                           \
 409                 }, }                                                    \
 410         },                                                              \
 411         {       /* KASUMI (F8) */                                       \
 412                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 413                 {.sym = {                                               \
 414                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 415                         {.cipher = {                                    \
 416                                 .algo = RTE_CRYPTO_CIPHER_KASUMI_F8,    \
 417                                 .block_size = 8,                        \
 418                                 .key_size = {                           \
 419                                         .min = 16,                      \
 420                                         .max = 16,                      \
 421                                         .increment = 0                  \
 422                                 },                                      \
 423                                 .iv_size = {                            \
 424                                         .min = 8,                       \
 425                                         .max = 8,                       \
 426                                         .increment = 0                  \
 427                                 }                                       \
 428                         }, }                                            \
 429                 }, }                                                    \
 430         },                                                              \
 431         {       /* KASUMI (F9) */                                       \
 432                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 433                 {.sym = {                                               \
 434                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
 435                         {.auth = {                                      \
 436                                 .algo = RTE_CRYPTO_AUTH_KASUMI_F9,      \
 437                                 .block_size = 8,                        \
 438                                 .key_size = {                           \
 439                                         .min = 16,                      \
 440                                         .max = 16,                      \
 441                                         .increment = 0                  \
 442                                 },                                      \
 443                                 .digest_size = {                        \
 444                                         .min = 4,                       \
 445                                         .max = 4,                       \
 446                                         .increment = 0                  \
 447                                 },                                      \
 448                                 .iv_size = {                            \
 449                                         .min = 8,                       \
 450                                         .max = 8,                       \
 451                                         .increment = 0                  \
 452                                 },                                      \
 453                                 .aad_size = { 0 }                       \
 454                         }, }                                            \
 455                 }, }                                                    \
 456         },                                                              \
 457         {       /* 3DES CBC */                                          \
 458                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 459                 {.sym = {                                               \
 460                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 461                         {.cipher = {                                    \
 462                                 .algo = RTE_CRYPTO_CIPHER_3DES_CBC,     \
 463                                 .block_size = 8,                        \
 464                                 .key_size = {                           \
 465                                         .min = 16,                      \
 466                                         .max = 24,                      \
 467                                         .increment = 8                  \
 468                                 },                                      \
 469                                 .iv_size = {                            \
 470                                         .min = 8,                       \
 471                                         .max = 8,                       \
 472                                         .increment = 0                  \
 473                                 }                                       \
 474                         }, }                                            \
 475                 }, }                                                    \
 476         },                                                              \
 477         {       /* 3DES CTR */                                          \
 478                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 479                 {.sym = {                                               \
 480                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 481                         {.cipher = {                                    \
 482                                 .algo = RTE_CRYPTO_CIPHER_3DES_CTR,     \
 483                                 .block_size = 8,                        \
 484                                 .key_size = {                           \
 485                                         .min = 16,                      \
 486                                         .max = 24,                      \
 487                                         .increment = 8                  \
 488                                 },                                      \
 489                                 .iv_size = {                            \
 490                                         .min = 8,                       \
 491                                         .max = 8,                       \
 492                                         .increment = 0                  \
 493                                 }                                       \
 494                         }, }                                            \
 495                 }, }                                                    \
 496         },                                                              \
 497         {       /* DES CBC */                                           \
 498                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 499                 {.sym = {                                               \
 500                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 501                         {.cipher = {                                    \
 502                                 .algo = RTE_CRYPTO_CIPHER_DES_CBC,      \
 503                                 .block_size = 8,                        \
 504                                 .key_size = {                           \
 505                                         .min = 8,                       \
 506                                         .max = 8,                       \
 507                                         .increment = 0                  \
 508                                 },                                      \
 509                                 .iv_size = {                            \
 510                                         .min = 8,                       \
 511                                         .max = 8,                       \
 512                                         .increment = 0                  \
 513                                 }                                       \
 514                         }, }                                            \
 515                 }, }                                                    \
 516         },                                                              \
 517         {       /* DES DOCSISBPI */                                     \
 518                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 519                 {.sym = {                                               \
 520                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 521                         {.cipher = {                                    \
 522                                 .algo = RTE_CRYPTO_CIPHER_DES_DOCSISBPI,\
 523                                 .block_size = 8,                        \
 524                                 .key_size = {                           \
 525                                         .min = 8,                       \
 526                                         .max = 8,                       \
 527                                         .increment = 0                  \
 528                                 },                                      \
 529                                 .iv_size = {                            \
 530                                         .min = 8,                       \
 531                                         .max = 8,                       \
 532                                         .increment = 0                  \
 533                                 }                                       \
 534                         }, }                                            \
 535                 }, }                                                    \
 536         }
 537
 538 #define QAT_EXTRA_CPM17_SYM_CAPABILITIES                                \
 539         {       /* ZUC (EEA3) */                                        \
 540                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 541                 {.sym = {                                               \
 542                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 543                         {.cipher = {                                    \
 544                                 .algo = RTE_CRYPTO_CIPHER_ZUC_EEA3,     \
 545                                 .block_size = 16,                       \
 546                                 .key_size = {                           \
 547                                         .min = 16,                      \
 548                                         .max = 16,                      \
 549                                         .increment = 0                  \
 550                                 },                                      \
 551                                 .iv_size = {                            \
 552                                         .min = 16,                      \
 553                                         .max = 16,                      \
 554                                         .increment = 0                  \
 555                                 }                                       \
 556                         }, }                                            \
 557                 }, }                                                    \
 558         },                                                              \
 559         {       /* ZUC (EIA3) */                                        \
 560                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 561                 {.sym = {                                               \
 562                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
 563                         {.auth = {                                      \
 564                                 .algo = RTE_CRYPTO_AUTH_ZUC_EIA3,       \
 565                                 .block_size = 16,                       \
 566                                 .key_size = {                           \
 567                                         .min = 16,                      \
 568                                         .max = 16,                      \
 569                                         .increment = 0                  \
 570                                 },                                      \
 571                                 .digest_size = {                        \
 572                                         .min = 4,                       \
 573                                         .max = 4,                       \
 574                                         .increment = 0                  \
 575                                 },                                      \
 576                                 .iv_size = {                            \
 577                                         .min = 16,                      \
 578                                         .max = 16,                      \
 579                                         .increment = 0                  \
 580                                 },                                      \
 581                                 .aad_size = { 0 }                       \
 582                         }, }                                            \
 583                 }, }                                                    \
 584         }
 585
 586 #endif /* _QAT_CRYPTO_CAPABILITIES_H_ */