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                         }, }                                            \
  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 = 64,                      \
  68                                         .max = 64,                      \
  69                                         .increment = 0                  \
  70                                 },                                      \
  71                                 .digest_size = {                        \
  72                                         .min = 28,                      \
  73                                         .max = 28,                      \
  74                                         .increment = 0                  \
  75                                 },                                      \
  76                                 .aad_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 = 64,                      \
  89                                         .max = 64,                      \
  90                                         .increment = 0                  \
  91                                 },                                      \
  92                                 .digest_size = {                        \
  93                                         .min = 32,                      \
  94                                         .max = 32,                      \
  95                                         .increment = 0                  \
  96                                 },                                      \
  97                                 .aad_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 = 64,                       \
 108                                 .key_size = {                           \
 109                                         .min = 128,                     \
 110                                         .max = 128,                     \
 111                                         .increment = 0                  \
 112                                 },                                      \
 113                                 .digest_size = {                        \
 114                                         .min = 48,                      \
 115                                         .max = 48,                      \
 116                                         .increment = 0                  \
 117                                         },                              \
 118                                 .aad_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 = 128,                     \
 131                                         .max = 128,                     \
 132                                         .increment = 0                  \
 133                                 },                                      \
 134                                 .digest_size = {                        \
 135                                         .min = 64,                      \
 136                                         .max = 64,                      \
 137                                         .increment = 0                  \
 138                                 },                                      \
 139                                 .aad_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 = 8,                       \
 152                                         .max = 64,                      \
 153                                         .increment = 8                  \
 154                                 },                                      \
 155                                 .digest_size = {                        \
 156                                         .min = 16,                      \
 157                                         .max = 16,                      \
 158                                         .increment = 0                  \
 159                                 },                                      \
 160                                 .aad_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                         }, }                                            \
 183                 }, }                                                    \
 184         },                                                              \
 185         {       /* AES GCM (AUTH) */                                    \
 186                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 187                 {.sym = {                                               \
 188                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
 189                         {.auth = {                                      \
 190                                 .algo = RTE_CRYPTO_AUTH_AES_GCM,        \
 191                                 .block_size = 16,                       \
 192                                 .key_size = {                           \
 193                                         .min = 16,                      \
 194                                         .max = 32,                      \
 195                                         .increment = 8                  \
 196                                 },                                      \
 197                                 .digest_size = {                        \
 198                                         .min = 8,                       \
 199                                         .max = 16,                      \
 200                                         .increment = 4                  \
 201                                 },                                      \
 202                                 .aad_size = {                           \
 203                                         .min = 0,                       \
 204                                         .max = 240,                     \
 205                                         .increment = 1                  \
 206                                 }                                       \
 207                         }, }                                            \
 208                 }, }                                                    \
 209         },                                                              \
 210         {       /* AES GMAC (AUTH) */                                   \
 211                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 212                 {.sym = {                                               \
 213                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
 214                         {.auth = {                                      \
 215                                 .algo = RTE_CRYPTO_AUTH_AES_GMAC,       \
 216                                 .block_size = 16,                       \
 217                                 .key_size = {                           \
 218                                         .min = 16,                      \
 219                                         .max = 32,                      \
 220                                         .increment = 8                  \
 221                                 },                                      \
 222                                 .digest_size = {                        \
 223                                         .min = 8,                       \
 224                                         .max = 16,                      \
 225                                         .increment = 4                  \
 226                                 },                                      \
 227                                 .aad_size = {                           \
 228                                         .min = 1,                       \
 229                                         .max = 65535,                   \
 230                                         .increment = 1                  \
 231                                 }                                       \
 232                         }, }                                            \
 233                 }, }                                                    \
 234         },                                                              \
 235         {       /* SNOW 3G (UIA2) */                                    \
 236                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 237                 {.sym = {                                               \
 238                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
 239                         {.auth = {                                      \
 240                                 .algo = RTE_CRYPTO_AUTH_SNOW3G_UIA2,    \
 241                                 .block_size = 16,                       \
 242                                 .key_size = {                           \
 243                                         .min = 16,                      \
 244                                         .max = 16,                      \
 245                                         .increment = 0                  \
 246                                 },                                      \
 247                                 .digest_size = {                        \
 248                                         .min = 4,                       \
 249                                         .max = 4,                       \
 250                                         .increment = 0                  \
 251                                 },                                      \
 252                                 .aad_size = {                           \
 253                                         .min = 16,                      \
 254                                         .max = 16,                      \
 255                                         .increment = 0                  \
 256                                 }                                       \
 257                         }, }                                            \
 258                 }, }                                                    \
 259         },                                                              \
 260         {       /* AES GCM (CIPHER) */                                  \
 261                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 262                 {.sym = {                                               \
 263                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 264                         {.cipher = {                                    \
 265                                 .algo = RTE_CRYPTO_CIPHER_AES_GCM,      \
 266                                 .block_size = 16,                       \
 267                                 .key_size = {                           \
 268                                         .min = 16,                      \
 269                                         .max = 32,                      \
 270                                         .increment = 8                  \
 271                                 },                                      \
 272                                 .iv_size = {                            \
 273                                         .min = 12,                      \
 274                                         .max = 12,                      \
 275                                         .increment = 0                  \
 276                                 }                                       \
 277                         }, }                                            \
 278                 }, }                                                    \
 279         },                                                              \
 280         {       /* AES CBC */                                           \
 281                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 282                 {.sym = {                                               \
 283                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 284                         {.cipher = {                                    \
 285                                 .algo = RTE_CRYPTO_CIPHER_AES_CBC,      \
 286                                 .block_size = 16,                       \
 287                                 .key_size = {                           \
 288                                         .min = 16,                      \
 289                                         .max = 32,                      \
 290                                         .increment = 8                  \
 291                                 },                                      \
 292                                 .iv_size = {                            \
 293                                         .min = 16,                      \
 294                                         .max = 16,                      \
 295                                         .increment = 0                  \
 296                                 }                                       \
 297                         }, }                                            \
 298                 }, }                                                    \
 299         },                                                              \
 300         {       /* AES DOCSIS BPI */                                    \
 301                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 302                 {.sym = {                                               \
 303                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 304                         {.cipher = {                                    \
 305                                 .algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI,\
 306                                 .block_size = 16,                       \
 307                                 .key_size = {                           \
 308                                         .min = 16,                      \
 309                                         .max = 16,                      \
 310                                         .increment = 0                  \
 311                                 },                                      \
 312                                 .iv_size = {                            \
 313                                         .min = 16,                      \
 314                                         .max = 16,                      \
 315                                         .increment = 0                  \
 316                                 }                                       \
 317                         }, }                                            \
 318                 }, }                                                    \
 319         },                                                              \
 320         {       /* SNOW 3G (UEA2) */                                    \
 321                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 322                 {.sym = {                                               \
 323                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 324                         {.cipher = {                                    \
 325                                 .algo = RTE_CRYPTO_CIPHER_SNOW3G_UEA2,  \
 326                                 .block_size = 16,                       \
 327                                 .key_size = {                           \
 328                                         .min = 16,                      \
 329                                         .max = 16,                      \
 330                                         .increment = 0                  \
 331                                 },                                      \
 332                                 .iv_size = {                            \
 333                                         .min = 16,                      \
 334                                         .max = 16,                      \
 335                                         .increment = 0                  \
 336                                 }                                       \
 337                         }, }                                            \
 338                 }, }                                                    \
 339         },                                                              \
 340         {       /* AES CTR */                                           \
 341                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 342                 {.sym = {                                               \
 343                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 344                         {.cipher = {                                    \
 345                                 .algo = RTE_CRYPTO_CIPHER_AES_CTR,      \
 346                                 .block_size = 16,                       \
 347                                 .key_size = {                           \
 348                                         .min = 16,                      \
 349                                         .max = 32,                      \
 350                                         .increment = 8                  \
 351                                 },                                      \
 352                                 .iv_size = {                            \
 353                                         .min = 16,                      \
 354                                         .max = 16,                      \
 355                                         .increment = 0                  \
 356                                 }                                       \
 357                         }, }                                            \
 358                 }, }                                                    \
 359         },                                                              \
 360         {       /* NULL (AUTH) */                                       \
 361                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 362                 {.sym = {                                               \
 363                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
 364                         {.auth = {                                      \
 365                                 .algo = RTE_CRYPTO_AUTH_NULL,           \
 366                                 .block_size = 1,                        \
 367                                 .key_size = {                           \
 368                                         .min = 0,                       \
 369                                         .max = 0,                       \
 370                                         .increment = 0                  \
 371                                 },                                      \
 372                                 .digest_size = {                        \
 373                                         .min = 0,                       \
 374                                         .max = 0,                       \
 375                                         .increment = 0                  \
 376                                 },                                      \
 377                                 .aad_size = { 0 }                       \
 378                         }, },                                           \
 379                 }, },                                                   \
 380         },                                                              \
 381         {       /* NULL (CIPHER) */                                     \
 382                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 383                 {.sym = {                                               \
 384                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 385                         {.cipher = {                                    \
 386                                 .algo = RTE_CRYPTO_CIPHER_NULL,         \
 387                                 .block_size = 1,                        \
 388                                 .key_size = {                           \
 389                                         .min = 0,                       \
 390                                         .max = 0,                       \
 391                                         .increment = 0                  \
 392                                 },                                      \
 393                                 .iv_size = {                            \
 394                                         .min = 0,                       \
 395                                         .max = 0,                       \
 396                                         .increment = 0                  \
 397                                 }                                       \
 398                         }, },                                           \
 399                 }, }                                                    \
 400         },                                                              \
 401         {       /* KASUMI (F8) */                                       \
 402                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 403                 {.sym = {                                               \
 404                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 405                         {.cipher = {                                    \
 406                                 .algo = RTE_CRYPTO_CIPHER_KASUMI_F8,    \
 407                                 .block_size = 8,                        \
 408                                 .key_size = {                           \
 409                                         .min = 16,                      \
 410                                         .max = 16,                      \
 411                                         .increment = 0                  \
 412                                 },                                      \
 413                                 .iv_size = {                            \
 414                                         .min = 8,                       \
 415                                         .max = 8,                       \
 416                                         .increment = 0                  \
 417                                 }                                       \
 418                         }, }                                            \
 419                 }, }                                                    \
 420         },                                                              \
 421         {       /* KASUMI (F9) */                                       \
 422                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 423                 {.sym = {                                               \
 424                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
 425                         {.auth = {                                      \
 426                                 .algo = RTE_CRYPTO_AUTH_KASUMI_F9,      \
 427                                 .block_size = 8,                        \
 428                                 .key_size = {                           \
 429                                         .min = 16,                      \
 430                                         .max = 16,                      \
 431                                         .increment = 0                  \
 432                                 },                                      \
 433                                 .digest_size = {                        \
 434                                         .min = 4,                       \
 435                                         .max = 4,                       \
 436                                         .increment = 0                  \
 437                                 },                                      \
 438                                 .aad_size = {                           \
 439                                         .min = 8,                       \
 440                                         .max = 8,                       \
 441                                         .increment = 0                  \
 442                                 }                                       \
 443                         }, }                                            \
 444                 }, }                                                    \
 445         },                                                              \
 446         {       /* 3DES CBC */                                          \
 447                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 448                 {.sym = {                                               \
 449                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 450                         {.cipher = {                                    \
 451                                 .algo = RTE_CRYPTO_CIPHER_3DES_CBC,     \
 452                                 .block_size = 8,                        \
 453                                 .key_size = {                           \
 454                                         .min = 16,                      \
 455                                         .max = 24,                      \
 456                                         .increment = 8                  \
 457                                 },                                      \
 458                                 .iv_size = {                            \
 459                                         .min = 8,                       \
 460                                         .max = 8,                       \
 461                                         .increment = 0                  \
 462                                 }                                       \
 463                         }, }                                            \
 464                 }, }                                                    \
 465         },                                                              \
 466         {       /* 3DES CTR */                                          \
 467                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 468                 {.sym = {                                               \
 469                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 470                         {.cipher = {                                    \
 471                                 .algo = RTE_CRYPTO_CIPHER_3DES_CTR,     \
 472                                 .block_size = 8,                        \
 473                                 .key_size = {                           \
 474                                         .min = 16,                      \
 475                                         .max = 24,                      \
 476                                         .increment = 8                  \
 477                                 },                                      \
 478                                 .iv_size = {                            \
 479                                         .min = 8,                       \
 480                                         .max = 8,                       \
 481                                         .increment = 0                  \
 482                                 }                                       \
 483                         }, }                                            \
 484                 }, }                                                    \
 485         },                                                              \
 486         {       /* DES CBC */                                           \
 487                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 488                 {.sym = {                                               \
 489                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 490                         {.cipher = {                                    \
 491                                 .algo = RTE_CRYPTO_CIPHER_DES_CBC,      \
 492                                 .block_size = 8,                        \
 493                                 .key_size = {                           \
 494                                         .min = 8,                       \
 495                                         .max = 8,                       \
 496                                         .increment = 0                  \
 497                                 },                                      \
 498                                 .iv_size = {                            \
 499                                         .min = 8,                       \
 500                                         .max = 8,                       \
 501                                         .increment = 0                  \
 502                                 }                                       \
 503                         }, }                                            \
 504                 }, }                                                    \
 505         },                                                              \
 506         {       /* DES DOCSISBPI */                                     \
 507                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 508                 {.sym = {                                               \
 509                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 510                         {.cipher = {                                    \
 511                                 .algo = RTE_CRYPTO_CIPHER_DES_DOCSISBPI,\
 512                                 .block_size = 8,                        \
 513                                 .key_size = {                           \
 514                                         .min = 8,                       \
 515                                         .max = 8,                       \
 516                                         .increment = 0                  \
 517                                 },                                      \
 518                                 .iv_size = {                            \
 519                                         .min = 8,                       \
 520                                         .max = 8,                       \
 521                                         .increment = 0                  \
 522                                 }                                       \
 523                         }, }                                            \
 524                 }, }                                                    \
 525         }
 526
 527 #define QAT_EXTRA_CPM17_SYM_CAPABILITIES                                \
 528         {       /* ZUC (EEA3) */                                        \
 529                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 530                 {.sym = {                                               \
 531                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 532                         {.cipher = {                                    \
 533                                 .algo = RTE_CRYPTO_CIPHER_ZUC_EEA3,     \
 534                                 .block_size = 16,                       \
 535                                 .key_size = {                           \
 536                                         .min = 16,                      \
 537                                         .max = 16,                      \
 538                                         .increment = 0                  \
 539                                 },                                      \
 540                                 .iv_size = {                            \
 541                                         .min = 16,                      \
 542                                         .max = 16,                      \
 543                                         .increment = 0                  \
 544                                 }                                       \
 545                         }, }                                            \
 546                 }, }                                                    \
 547         },                                                              \
 548         {       /* ZUC (EIA3) */                                        \
 549                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 550                 {.sym = {                                               \
 551                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
 552                         {.auth = {                                      \
 553                                 .algo = RTE_CRYPTO_AUTH_ZUC_EIA3,       \
 554                                 .block_size = 16,                       \
 555                                 .key_size = {                           \
 556                                         .min = 16,                      \
 557                                         .max = 16,                      \
 558                                         .increment = 0                  \
 559                                 },                                      \
 560                                 .digest_size = {                        \
 561                                         .min = 4,                       \
 562                                         .max = 4,                       \
 563                                         .increment = 0                  \
 564                                 },                                      \
 565                                 .aad_size = {                           \
 566                                         .min = 16,                      \
 567                                         .max = 16,                      \
 568                                         .increment = 0                  \
 569                                 }                                       \
 570                         }, }                                            \
 571                 }, }                                                    \
 572         }
 573
 574 #endif /* _QAT_CRYPTO_CAPABILITIES_H_ */