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_GEN1_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 = 1,                       \
  47                                         .max = 64,                      \
  48                                         .increment = 1                  \
  49                                 },                                      \
  50                                 .digest_size = {                        \
  51                                         .min = 20,                      \
  52                                         .max = 20,                      \
  53                                         .increment = 0                  \
  54                                 },                                      \
  55                                 .iv_size = { 0 }                        \
  56                         }, }                                            \
  57                 }, }                                                    \
  58         },                                                              \
  59         {       /* SHA224 HMAC */                                       \
  60                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
  61                 {.sym = {                                               \
  62                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
  63                         {.auth = {                                      \
  64                                 .algo = RTE_CRYPTO_AUTH_SHA224_HMAC,    \
  65                                 .block_size = 64,                       \
  66                                 .key_size = {                           \
  67                                         .min = 1,                       \
  68                                         .max = 64,                      \
  69                                         .increment = 1                  \
  70                                 },                                      \
  71                                 .digest_size = {                        \
  72                                         .min = 28,                      \
  73                                         .max = 28,                      \
  74                                         .increment = 0                  \
  75                                 },                                      \
  76                                 .iv_size = { 0 }                        \
  77                         }, }                                            \
  78                 }, }                                                    \
  79         },                                                              \
  80         {       /* SHA256 HMAC */                                       \
  81                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
  82                 {.sym = {                                               \
  83                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
  84                         {.auth = {                                      \
  85                                 .algo = RTE_CRYPTO_AUTH_SHA256_HMAC,    \
  86                                 .block_size = 64,                       \
  87                                 .key_size = {                           \
  88                                         .min = 1,                       \
  89                                         .max = 64,                      \
  90                                         .increment = 1                  \
  91                                 },                                      \
  92                                 .digest_size = {                        \
  93                                         .min = 32,                      \
  94                                         .max = 32,                      \
  95                                         .increment = 0                  \
  96                                 },                                      \
  97                                 .iv_size = { 0 }                        \
  98                         }, }                                            \
  99                 }, }                                                    \
 100         },                                                              \
 101         {       /* SHA384 HMAC */                                       \
 102                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 103                 {.sym = {                                               \
 104                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
 105                         {.auth = {                                      \
 106                                 .algo = RTE_CRYPTO_AUTH_SHA384_HMAC,    \
 107                                 .block_size = 128,                      \
 108                                 .key_size = {                           \
 109                                         .min = 1,                       \
 110                                         .max = 128,                     \
 111                                         .increment = 1                  \
 112                                 },                                      \
 113                                 .digest_size = {                        \
 114                                         .min = 48,                      \
 115                                         .max = 48,                      \
 116                                         .increment = 0                  \
 117                                 },                                      \
 118                                 .iv_size = { 0 }                        \
 119                         }, }                                            \
 120                 }, }                                                    \
 121         },                                                              \
 122         {       /* SHA512 HMAC */                                       \
 123                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 124                 {.sym = {                                               \
 125                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
 126                         {.auth = {                                      \
 127                                 .algo = RTE_CRYPTO_AUTH_SHA512_HMAC,    \
 128                                 .block_size = 128,                      \
 129                                 .key_size = {                           \
 130                                         .min = 1,                       \
 131                                         .max = 128,                     \
 132                                         .increment = 1                  \
 133                                 },                                      \
 134                                 .digest_size = {                        \
 135                                         .min = 64,                      \
 136                                         .max = 64,                      \
 137                                         .increment = 0                  \
 138                                 },                                      \
 139                                 .iv_size = { 0 }                        \
 140                         }, }                                            \
 141                 }, }                                                    \
 142         },                                                              \
 143         {       /* MD5 HMAC */                                          \
 144                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 145                 {.sym = {                                               \
 146                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
 147                         {.auth = {                                      \
 148                                 .algo = RTE_CRYPTO_AUTH_MD5_HMAC,       \
 149                                 .block_size = 64,                       \
 150                                 .key_size = {                           \
 151                                         .min = 1,                       \
 152                                         .max = 64,                      \
 153                                         .increment = 1                  \
 154                                 },                                      \
 155                                 .digest_size = {                        \
 156                                         .min = 16,                      \
 157                                         .max = 16,                      \
 158                                         .increment = 0                  \
 159                                 },                                      \
 160                                 .iv_size = { 0 }                        \
 161                         }, }                                            \
 162                 }, }                                                    \
 163         },                                                              \
 164         {       /* AES XCBC MAC */                                      \
 165                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 166                 {.sym = {                                               \
 167                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
 168                         {.auth = {                                      \
 169                                 .algo = RTE_CRYPTO_AUTH_AES_XCBC_MAC,   \
 170                                 .block_size = 16,                       \
 171                                 .key_size = {                           \
 172                                         .min = 16,                      \
 173                                         .max = 16,                      \
 174                                         .increment = 0                  \
 175                                 },                                      \
 176                                 .digest_size = {                        \
 177                                         .min = 16,                      \
 178                                         .max = 16,                      \
 179                                         .increment = 0                  \
 180                                 },                                      \
 181                                 .aad_size = { 0 },                      \
 182                                 .iv_size = { 0 }                        \
 183                         }, }                                            \
 184                 }, }                                                    \
 185         },                                                              \
 186         {       /* AES CCM */                                           \
 187                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 188                 {.sym = {                                               \
 189                         .xform_type = RTE_CRYPTO_SYM_XFORM_AEAD,        \
 190                         {.aead = {                                      \
 191                                 .algo = RTE_CRYPTO_AEAD_AES_CCM,        \
 192                                 .block_size = 16,                       \
 193                                 .key_size = {                           \
 194                                         .min = 16,                      \
 195                                         .max = 16,                      \
 196                                         .increment = 0                  \
 197                                 },                                      \
 198                                 .digest_size = {                        \
 199                                         .min = 4,                       \
 200                                         .max = 16,                      \
 201                                         .increment = 2                  \
 202                                 },                                      \
 203                                 .aad_size = {                           \
 204                                         .min = 0,                       \
 205                                         .max = 224,                     \
 206                                         .increment = 1                  \
 207                                 },                                      \
 208                                 .iv_size = {                            \
 209                                         .min = 7,                       \
 210                                         .max = 13,                      \
 211                                         .increment = 1                  \
 212                                 },                                      \
 213                         }, }                                            \
 214                 }, }                                                    \
 215         },                                                              \
 216         {       /* AES GCM */                                           \
 217                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 218                 {.sym = {                                               \
 219                         .xform_type = RTE_CRYPTO_SYM_XFORM_AEAD,        \
 220                         {.aead = {                                      \
 221                                 .algo = RTE_CRYPTO_AEAD_AES_GCM,        \
 222                                 .block_size = 16,                       \
 223                                 .key_size = {                           \
 224                                         .min = 16,                      \
 225                                         .max = 32,                      \
 226                                         .increment = 8                  \
 227                                 },                                      \
 228                                 .digest_size = {                        \
 229                                         .min = 8,                       \
 230                                         .max = 16,                      \
 231                                         .increment = 4                  \
 232                                 },                                      \
 233                                 .aad_size = {                           \
 234                                         .min = 0,                       \
 235                                         .max = 240,                     \
 236                                         .increment = 1                  \
 237                                 },                                      \
 238                                 .iv_size = {                            \
 239                                         .min = 12,                      \
 240                                         .max = 12,                      \
 241                                         .increment = 0                  \
 242                                 },                                      \
 243                         }, }                                            \
 244                 }, }                                                    \
 245         },                                                              \
 246         {       /* AES GMAC (AUTH) */                                   \
 247                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 248                 {.sym = {                                               \
 249                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
 250                         {.auth = {                                      \
 251                                 .algo = RTE_CRYPTO_AUTH_AES_GMAC,       \
 252                                 .block_size = 16,                       \
 253                                 .key_size = {                           \
 254                                         .min = 16,                      \
 255                                         .max = 32,                      \
 256                                         .increment = 8                  \
 257                                 },                                      \
 258                                 .digest_size = {                        \
 259                                         .min = 8,                       \
 260                                         .max = 16,                      \
 261                                         .increment = 4                  \
 262                                 },                                      \
 263                                 .iv_size = {                            \
 264                                         .min = 12,                      \
 265                                         .max = 12,                      \
 266                                         .increment = 0                  \
 267                                 }                                       \
 268                         }, }                                            \
 269                 }, }                                                    \
 270         },                                                              \
 271         {       /* SNOW 3G (UIA2) */                                    \
 272                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 273                 {.sym = {                                               \
 274                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
 275                         {.auth = {                                      \
 276                                 .algo = RTE_CRYPTO_AUTH_SNOW3G_UIA2,    \
 277                                 .block_size = 16,                       \
 278                                 .key_size = {                           \
 279                                         .min = 16,                      \
 280                                         .max = 16,                      \
 281                                         .increment = 0                  \
 282                                 },                                      \
 283                                 .digest_size = {                        \
 284                                         .min = 4,                       \
 285                                         .max = 4,                       \
 286                                         .increment = 0                  \
 287                                 },                                      \
 288                                 .iv_size = {                            \
 289                                         .min = 16,                      \
 290                                         .max = 16,                      \
 291                                         .increment = 0                  \
 292                                 }                                       \
 293                         }, }                                            \
 294                 }, }                                                    \
 295         },                                                              \
 296         {       /* AES CBC */                                           \
 297                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 298                 {.sym = {                                               \
 299                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 300                         {.cipher = {                                    \
 301                                 .algo = RTE_CRYPTO_CIPHER_AES_CBC,      \
 302                                 .block_size = 16,                       \
 303                                 .key_size = {                           \
 304                                         .min = 16,                      \
 305                                         .max = 32,                      \
 306                                         .increment = 8                  \
 307                                 },                                      \
 308                                 .iv_size = {                            \
 309                                         .min = 16,                      \
 310                                         .max = 16,                      \
 311                                         .increment = 0                  \
 312                                 }                                       \
 313                         }, }                                            \
 314                 }, }                                                    \
 315         },                                                              \
 316         {       /* AES DOCSIS BPI */                                    \
 317                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 318                 {.sym = {                                               \
 319                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 320                         {.cipher = {                                    \
 321                                 .algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI,\
 322                                 .block_size = 16,                       \
 323                                 .key_size = {                           \
 324                                         .min = 16,                      \
 325                                         .max = 16,                      \
 326                                         .increment = 0                  \
 327                                 },                                      \
 328                                 .iv_size = {                            \
 329                                         .min = 16,                      \
 330                                         .max = 16,                      \
 331                                         .increment = 0                  \
 332                                 }                                       \
 333                         }, }                                            \
 334                 }, }                                                    \
 335         },                                                              \
 336         {       /* SNOW 3G (UEA2) */                                    \
 337                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 338                 {.sym = {                                               \
 339                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 340                         {.cipher = {                                    \
 341                                 .algo = RTE_CRYPTO_CIPHER_SNOW3G_UEA2,  \
 342                                 .block_size = 16,                       \
 343                                 .key_size = {                           \
 344                                         .min = 16,                      \
 345                                         .max = 16,                      \
 346                                         .increment = 0                  \
 347                                 },                                      \
 348                                 .iv_size = {                            \
 349                                         .min = 16,                      \
 350                                         .max = 16,                      \
 351                                         .increment = 0                  \
 352                                 }                                       \
 353                         }, }                                            \
 354                 }, }                                                    \
 355         },                                                              \
 356         {       /* AES CTR */                                           \
 357                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 358                 {.sym = {                                               \
 359                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 360                         {.cipher = {                                    \
 361                                 .algo = RTE_CRYPTO_CIPHER_AES_CTR,      \
 362                                 .block_size = 16,                       \
 363                                 .key_size = {                           \
 364                                         .min = 16,                      \
 365                                         .max = 32,                      \
 366                                         .increment = 8                  \
 367                                 },                                      \
 368                                 .iv_size = {                            \
 369                                         .min = 16,                      \
 370                                         .max = 16,                      \
 371                                         .increment = 0                  \
 372                                 }                                       \
 373                         }, }                                            \
 374                 }, }                                                    \
 375         },                                                              \
 376         {       /* NULL (AUTH) */                                       \
 377                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 378                 {.sym = {                                               \
 379                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
 380                         {.auth = {                                      \
 381                                 .algo = RTE_CRYPTO_AUTH_NULL,           \
 382                                 .block_size = 1,                        \
 383                                 .key_size = {                           \
 384                                         .min = 0,                       \
 385                                         .max = 0,                       \
 386                                         .increment = 0                  \
 387                                 },                                      \
 388                                 .digest_size = {                        \
 389                                         .min = 0,                       \
 390                                         .max = 0,                       \
 391                                         .increment = 0                  \
 392                                 },                                      \
 393                                 .iv_size = { 0 }                        \
 394                         }, },                                           \
 395                 }, },                                                   \
 396         },                                                              \
 397         {       /* NULL (CIPHER) */                                     \
 398                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 399                 {.sym = {                                               \
 400                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 401                         {.cipher = {                                    \
 402                                 .algo = RTE_CRYPTO_CIPHER_NULL,         \
 403                                 .block_size = 1,                        \
 404                                 .key_size = {                           \
 405                                         .min = 0,                       \
 406                                         .max = 0,                       \
 407                                         .increment = 0                  \
 408                                 },                                      \
 409                                 .iv_size = {                            \
 410                                         .min = 0,                       \
 411                                         .max = 0,                       \
 412                                         .increment = 0                  \
 413                                 }                                       \
 414                         }, },                                           \
 415                 }, }                                                    \
 416         },                                                              \
 417         {       /* KASUMI (F8) */                                       \
 418                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 419                 {.sym = {                                               \
 420                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 421                         {.cipher = {                                    \
 422                                 .algo = RTE_CRYPTO_CIPHER_KASUMI_F8,    \
 423                                 .block_size = 8,                        \
 424                                 .key_size = {                           \
 425                                         .min = 16,                      \
 426                                         .max = 16,                      \
 427                                         .increment = 0                  \
 428                                 },                                      \
 429                                 .iv_size = {                            \
 430                                         .min = 8,                       \
 431                                         .max = 8,                       \
 432                                         .increment = 0                  \
 433                                 }                                       \
 434                         }, }                                            \
 435                 }, }                                                    \
 436         },                                                              \
 437         {       /* KASUMI (F9) */                                       \
 438                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 439                 {.sym = {                                               \
 440                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
 441                         {.auth = {                                      \
 442                                 .algo = RTE_CRYPTO_AUTH_KASUMI_F9,      \
 443                                 .block_size = 8,                        \
 444                                 .key_size = {                           \
 445                                         .min = 16,                      \
 446                                         .max = 16,                      \
 447                                         .increment = 0                  \
 448                                 },                                      \
 449                                 .digest_size = {                        \
 450                                         .min = 4,                       \
 451                                         .max = 4,                       \
 452                                         .increment = 0                  \
 453                                 },                                      \
 454                                 .iv_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_GEN2_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                         }, }                                            \
 583                 }, }                                                    \
 584         }
 585
 586 #endif /* _QAT_CRYPTO_CAPABILITIES_H_ */