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