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