drivers/crypto/qat/qat_sym_capabilities.h

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2017-2018 Intel Corporation
   3  */
   4
   5 #ifndef _QAT_SYM_CAPABILITIES_H_
   6 #define _QAT_SYM_CAPABILITIES_H_
   7
   8 #define QAT_BASE_GEN1_SYM_CAPABILITIES                                  \
   9         {       /* SHA1 HMAC */                                         \
  10                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
  11                 {.sym = {                                               \
  12                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
  13                         {.auth = {                                      \
  14                                 .algo = RTE_CRYPTO_AUTH_SHA1_HMAC,      \
  15                                 .block_size = 64,                       \
  16                                 .key_size = {                           \
  17                                         .min = 1,                       \
  18                                         .max = 64,                      \
  19                                         .increment = 1                  \
  20                                 },                                      \
  21                                 .digest_size = {                        \
  22                                         .min = 1,                       \
  23                                         .max = 20,                      \
  24                                         .increment = 1                  \
  25                                 },                                      \
  26                                 .iv_size = { 0 }                        \
  27                         }, }                                            \
  28                 }, }                                                    \
  29         },                                                              \
  30         {       /* SHA224 HMAC */                                       \
  31                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
  32                 {.sym = {                                               \
  33                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
  34                         {.auth = {                                      \
  35                                 .algo = RTE_CRYPTO_AUTH_SHA224_HMAC,    \
  36                                 .block_size = 64,                       \
  37                                 .key_size = {                           \
  38                                         .min = 1,                       \
  39                                         .max = 64,                      \
  40                                         .increment = 1                  \
  41                                 },                                      \
  42                                 .digest_size = {                        \
  43                                         .min = 1,                       \
  44                                         .max = 28,                      \
  45                                         .increment = 1                  \
  46                                 },                                      \
  47                                 .iv_size = { 0 }                        \
  48                         }, }                                            \
  49                 }, }                                                    \
  50         },                                                              \
  51         {       /* SHA256 HMAC */                                       \
  52                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
  53                 {.sym = {                                               \
  54                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
  55                         {.auth = {                                      \
  56                                 .algo = RTE_CRYPTO_AUTH_SHA256_HMAC,    \
  57                                 .block_size = 64,                       \
  58                                 .key_size = {                           \
  59                                         .min = 1,                       \
  60                                         .max = 64,                      \
  61                                         .increment = 1                  \
  62                                 },                                      \
  63                                 .digest_size = {                        \
  64                                         .min = 1,                       \
  65                                         .max = 32,                      \
  66                                         .increment = 1                  \
  67                                 },                                      \
  68                                 .iv_size = { 0 }                        \
  69                         }, }                                            \
  70                 }, }                                                    \
  71         },                                                              \
  72         {       /* SHA384 HMAC */                                       \
  73                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
  74                 {.sym = {                                               \
  75                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
  76                         {.auth = {                                      \
  77                                 .algo = RTE_CRYPTO_AUTH_SHA384_HMAC,    \
  78                                 .block_size = 128,                      \
  79                                 .key_size = {                           \
  80                                         .min = 1,                       \
  81                                         .max = 128,                     \
  82                                         .increment = 1                  \
  83                                 },                                      \
  84                                 .digest_size = {                        \
  85                                         .min = 1,                       \
  86                                         .max = 48,                      \
  87                                         .increment = 1                  \
  88                                 },                                      \
  89                                 .iv_size = { 0 }                        \
  90                         }, }                                            \
  91                 }, }                                                    \
  92         },                                                              \
  93         {       /* SHA512 HMAC */                                       \
  94                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
  95                 {.sym = {                                               \
  96                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
  97                         {.auth = {                                      \
  98                                 .algo = RTE_CRYPTO_AUTH_SHA512_HMAC,    \
  99                                 .block_size = 128,                      \
 100                                 .key_size = {                           \
 101                                         .min = 1,                       \
 102                                         .max = 128,                     \
 103                                         .increment = 1                  \
 104                                 },                                      \
 105                                 .digest_size = {                        \
 106                                         .min = 1,                       \
 107                                         .max = 64,                      \
 108                                         .increment = 1                  \
 109                                 },                                      \
 110                                 .iv_size = { 0 }                        \
 111                         }, }                                            \
 112                 }, }                                                    \
 113         },                                                              \
 114         {       /* MD5 HMAC */                                          \
 115                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 116                 {.sym = {                                               \
 117                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
 118                         {.auth = {                                      \
 119                                 .algo = RTE_CRYPTO_AUTH_MD5_HMAC,       \
 120                                 .block_size = 64,                       \
 121                                 .key_size = {                           \
 122                                         .min = 1,                       \
 123                                         .max = 64,                      \
 124                                         .increment = 1                  \
 125                                 },                                      \
 126                                 .digest_size = {                        \
 127                                         .min = 1,                       \
 128                                         .max = 16,                      \
 129                                         .increment = 1                  \
 130                                 },                                      \
 131                                 .iv_size = { 0 }                        \
 132                         }, }                                            \
 133                 }, }                                                    \
 134         },                                                              \
 135         {       /* AES XCBC MAC */                                      \
 136                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 137                 {.sym = {                                               \
 138                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
 139                         {.auth = {                                      \
 140                                 .algo = RTE_CRYPTO_AUTH_AES_XCBC_MAC,   \
 141                                 .block_size = 16,                       \
 142                                 .key_size = {                           \
 143                                         .min = 16,                      \
 144                                         .max = 16,                      \
 145                                         .increment = 0                  \
 146                                 },                                      \
 147                                 .digest_size = {                        \
 148                                         .min = 16,                      \
 149                                         .max = 16,                      \
 150                                         .increment = 0                  \
 151                                 },                                      \
 152                                 .aad_size = { 0 },                      \
 153                                 .iv_size = { 0 }                        \
 154                         }, }                                            \
 155                 }, }                                                    \
 156         },                                                              \
 157         {       /* AES CMAC */                                          \
 158                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 159                 {.sym = {                                               \
 160                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
 161                         {.auth = {                                      \
 162                                 .algo = RTE_CRYPTO_AUTH_AES_CMAC,       \
 163                                 .block_size = 16,                       \
 164                                 .key_size = {                           \
 165                                         .min = 16,                      \
 166                                         .max = 16,                      \
 167                                         .increment = 0                  \
 168                                 },                                      \
 169                                 .digest_size = {                        \
 170                                         .min = 12,                      \
 171                                         .max = 16,                      \
 172                                         .increment = 4                  \
 173                                 }                                       \
 174                         }, }                                            \
 175                 }, }                                                    \
 176         },                                                              \
 177         {       /* AES CCM */                                           \
 178                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 179                 {.sym = {                                               \
 180                         .xform_type = RTE_CRYPTO_SYM_XFORM_AEAD,        \
 181                         {.aead = {                                      \
 182                                 .algo = RTE_CRYPTO_AEAD_AES_CCM,        \
 183                                 .block_size = 16,                       \
 184                                 .key_size = {                           \
 185                                         .min = 16,                      \
 186                                         .max = 16,                      \
 187                                         .increment = 0                  \
 188                                 },                                      \
 189                                 .digest_size = {                        \
 190                                         .min = 4,                       \
 191                                         .max = 16,                      \
 192                                         .increment = 2                  \
 193                                 },                                      \
 194                                 .aad_size = {                           \
 195                                         .min = 0,                       \
 196                                         .max = 224,                     \
 197                                         .increment = 1                  \
 198                                 },                                      \
 199                                 .iv_size = {                            \
 200                                         .min = 7,                       \
 201                                         .max = 13,                      \
 202                                         .increment = 1                  \
 203                                 },                                      \
 204                         }, }                                            \
 205                 }, }                                                    \
 206         },                                                              \
 207         {       /* AES GCM */                                           \
 208                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 209                 {.sym = {                                               \
 210                         .xform_type = RTE_CRYPTO_SYM_XFORM_AEAD,        \
 211                         {.aead = {                                      \
 212                                 .algo = RTE_CRYPTO_AEAD_AES_GCM,        \
 213                                 .block_size = 16,                       \
 214                                 .key_size = {                           \
 215                                         .min = 16,                      \
 216                                         .max = 32,                      \
 217                                         .increment = 8                  \
 218                                 },                                      \
 219                                 .digest_size = {                        \
 220                                         .min = 8,                       \
 221                                         .max = 16,                      \
 222                                         .increment = 4                  \
 223                                 },                                      \
 224                                 .aad_size = {                           \
 225                                         .min = 0,                       \
 226                                         .max = 240,                     \
 227                                         .increment = 1                  \
 228                                 },                                      \
 229                                 .iv_size = {                            \
 230                                         .min = 12,                      \
 231                                         .max = 12,                      \
 232                                         .increment = 0                  \
 233                                 },                                      \
 234                         }, }                                            \
 235                 }, }                                                    \
 236         },                                                              \
 237         {       /* AES GMAC (AUTH) */                                   \
 238                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 239                 {.sym = {                                               \
 240                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
 241                         {.auth = {                                      \
 242                                 .algo = RTE_CRYPTO_AUTH_AES_GMAC,       \
 243                                 .block_size = 16,                       \
 244                                 .key_size = {                           \
 245                                         .min = 16,                      \
 246                                         .max = 32,                      \
 247                                         .increment = 8                  \
 248                                 },                                      \
 249                                 .digest_size = {                        \
 250                                         .min = 8,                       \
 251                                         .max = 16,                      \
 252                                         .increment = 4                  \
 253                                 },                                      \
 254                                 .iv_size = {                            \
 255                                         .min = 12,                      \
 256                                         .max = 12,                      \
 257                                         .increment = 0                  \
 258                                 }                                       \
 259                         }, }                                            \
 260                 }, }                                                    \
 261         },                                                              \
 262         {       /* SNOW 3G (UIA2) */                                    \
 263                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 264                 {.sym = {                                               \
 265                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
 266                         {.auth = {                                      \
 267                                 .algo = RTE_CRYPTO_AUTH_SNOW3G_UIA2,    \
 268                                 .block_size = 16,                       \
 269                                 .key_size = {                           \
 270                                         .min = 16,                      \
 271                                         .max = 16,                      \
 272                                         .increment = 0                  \
 273                                 },                                      \
 274                                 .digest_size = {                        \
 275                                         .min = 4,                       \
 276                                         .max = 4,                       \
 277                                         .increment = 0                  \
 278                                 },                                      \
 279                                 .iv_size = {                            \
 280                                         .min = 16,                      \
 281                                         .max = 16,                      \
 282                                         .increment = 0                  \
 283                                 }                                       \
 284                         }, }                                            \
 285                 }, }                                                    \
 286         },                                                              \
 287         {       /* AES CBC */                                           \
 288                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 289                 {.sym = {                                               \
 290                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 291                         {.cipher = {                                    \
 292                                 .algo = RTE_CRYPTO_CIPHER_AES_CBC,      \
 293                                 .block_size = 16,                       \
 294                                 .key_size = {                           \
 295                                         .min = 16,                      \
 296                                         .max = 32,                      \
 297                                         .increment = 8                  \
 298                                 },                                      \
 299                                 .iv_size = {                            \
 300                                         .min = 16,                      \
 301                                         .max = 16,                      \
 302                                         .increment = 0                  \
 303                                 }                                       \
 304                         }, }                                            \
 305                 }, }                                                    \
 306         },                                                              \
 307         {       /* AES DOCSIS BPI */                                    \
 308                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 309                 {.sym = {                                               \
 310                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 311                         {.cipher = {                                    \
 312                                 .algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI,\
 313                                 .block_size = 16,                       \
 314                                 .key_size = {                           \
 315                                         .min = 16,                      \
 316                                         .max = 16,                      \
 317                                         .increment = 0                  \
 318                                 },                                      \
 319                                 .iv_size = {                            \
 320                                         .min = 16,                      \
 321                                         .max = 16,                      \
 322                                         .increment = 0                  \
 323                                 }                                       \
 324                         }, }                                            \
 325                 }, }                                                    \
 326         },                                                              \
 327         {       /* SNOW 3G (UEA2) */                                    \
 328                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 329                 {.sym = {                                               \
 330                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 331                         {.cipher = {                                    \
 332                                 .algo = RTE_CRYPTO_CIPHER_SNOW3G_UEA2,  \
 333                                 .block_size = 16,                       \
 334                                 .key_size = {                           \
 335                                         .min = 16,                      \
 336                                         .max = 16,                      \
 337                                         .increment = 0                  \
 338                                 },                                      \
 339                                 .iv_size = {                            \
 340                                         .min = 16,                      \
 341                                         .max = 16,                      \
 342                                         .increment = 0                  \
 343                                 }                                       \
 344                         }, }                                            \
 345                 }, }                                                    \
 346         },                                                              \
 347         {       /* AES CTR */                                           \
 348                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 349                 {.sym = {                                               \
 350                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 351                         {.cipher = {                                    \
 352                                 .algo = RTE_CRYPTO_CIPHER_AES_CTR,      \
 353                                 .block_size = 16,                       \
 354                                 .key_size = {                           \
 355                                         .min = 16,                      \
 356                                         .max = 32,                      \
 357                                         .increment = 8                  \
 358                                 },                                      \
 359                                 .iv_size = {                            \
 360                                         .min = 16,                      \
 361                                         .max = 16,                      \
 362                                         .increment = 0                  \
 363                                 }                                       \
 364                         }, }                                            \
 365                 }, }                                                    \
 366         },                                                              \
 367         {       /* NULL (AUTH) */                                       \
 368                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 369                 {.sym = {                                               \
 370                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
 371                         {.auth = {                                      \
 372                                 .algo = RTE_CRYPTO_AUTH_NULL,           \
 373                                 .block_size = 1,                        \
 374                                 .key_size = {                           \
 375                                         .min = 0,                       \
 376                                         .max = 0,                       \
 377                                         .increment = 0                  \
 378                                 },                                      \
 379                                 .digest_size = {                        \
 380                                         .min = 0,                       \
 381                                         .max = 0,                       \
 382                                         .increment = 0                  \
 383                                 },                                      \
 384                                 .iv_size = { 0 }                        \
 385                         }, },                                           \
 386                 }, },                                                   \
 387         },                                                              \
 388         {       /* NULL (CIPHER) */                                     \
 389                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 390                 {.sym = {                                               \
 391                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 392                         {.cipher = {                                    \
 393                                 .algo = RTE_CRYPTO_CIPHER_NULL,         \
 394                                 .block_size = 1,                        \
 395                                 .key_size = {                           \
 396                                         .min = 0,                       \
 397                                         .max = 0,                       \
 398                                         .increment = 0                  \
 399                                 },                                      \
 400                                 .iv_size = {                            \
 401                                         .min = 0,                       \
 402                                         .max = 0,                       \
 403                                         .increment = 0                  \
 404                                 }                                       \
 405                         }, },                                           \
 406                 }, }                                                    \
 407         },                                                              \
 408         {       /* KASUMI (F8) */                                       \
 409                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 410                 {.sym = {                                               \
 411                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 412                         {.cipher = {                                    \
 413                                 .algo = RTE_CRYPTO_CIPHER_KASUMI_F8,    \
 414                                 .block_size = 8,                        \
 415                                 .key_size = {                           \
 416                                         .min = 16,                      \
 417                                         .max = 16,                      \
 418                                         .increment = 0                  \
 419                                 },                                      \
 420                                 .iv_size = {                            \
 421                                         .min = 8,                       \
 422                                         .max = 8,                       \
 423                                         .increment = 0                  \
 424                                 }                                       \
 425                         }, }                                            \
 426                 }, }                                                    \
 427         },                                                              \
 428         {       /* KASUMI (F9) */                                       \
 429                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 430                 {.sym = {                                               \
 431                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
 432                         {.auth = {                                      \
 433                                 .algo = RTE_CRYPTO_AUTH_KASUMI_F9,      \
 434                                 .block_size = 8,                        \
 435                                 .key_size = {                           \
 436                                         .min = 16,                      \
 437                                         .max = 16,                      \
 438                                         .increment = 0                  \
 439                                 },                                      \
 440                                 .digest_size = {                        \
 441                                         .min = 4,                       \
 442                                         .max = 4,                       \
 443                                         .increment = 0                  \
 444                                 },                                      \
 445                                 .iv_size = { 0 }                        \
 446                         }, }                                            \
 447                 }, }                                                    \
 448         },                                                              \
 449         {       /* 3DES CBC */                                          \
 450                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 451                 {.sym = {                                               \
 452                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 453                         {.cipher = {                                    \
 454                                 .algo = RTE_CRYPTO_CIPHER_3DES_CBC,     \
 455                                 .block_size = 8,                        \
 456                                 .key_size = {                           \
 457                                         .min = 8,                       \
 458                                         .max = 24,                      \
 459                                         .increment = 8                  \
 460                                 },                                      \
 461                                 .iv_size = {                            \
 462                                         .min = 8,                       \
 463                                         .max = 8,                       \
 464                                         .increment = 0                  \
 465                                 }                                       \
 466                         }, }                                            \
 467                 }, }                                                    \
 468         },                                                              \
 469         {       /* 3DES CTR */                                          \
 470                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 471                 {.sym = {                                               \
 472                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 473                         {.cipher = {                                    \
 474                                 .algo = RTE_CRYPTO_CIPHER_3DES_CTR,     \
 475                                 .block_size = 8,                        \
 476                                 .key_size = {                           \
 477                                         .min = 16,                      \
 478                                         .max = 24,                      \
 479                                         .increment = 8                  \
 480                                 },                                      \
 481                                 .iv_size = {                            \
 482                                         .min = 8,                       \
 483                                         .max = 8,                       \
 484                                         .increment = 0                  \
 485                                 }                                       \
 486                         }, }                                            \
 487                 }, }                                                    \
 488         },                                                              \
 489         {       /* DES CBC */                                           \
 490                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 491                 {.sym = {                                               \
 492                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 493                         {.cipher = {                                    \
 494                                 .algo = RTE_CRYPTO_CIPHER_DES_CBC,      \
 495                                 .block_size = 8,                        \
 496                                 .key_size = {                           \
 497                                         .min = 8,                       \
 498                                         .max = 8,                       \
 499                                         .increment = 0                  \
 500                                 },                                      \
 501                                 .iv_size = {                            \
 502                                         .min = 8,                       \
 503                                         .max = 8,                       \
 504                                         .increment = 0                  \
 505                                 }                                       \
 506                         }, }                                            \
 507                 }, }                                                    \
 508         },                                                              \
 509         {       /* DES DOCSISBPI */                                     \
 510                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 511                 {.sym = {                                               \
 512                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 513                         {.cipher = {                                    \
 514                                 .algo = RTE_CRYPTO_CIPHER_DES_DOCSISBPI,\
 515                                 .block_size = 8,                        \
 516                                 .key_size = {                           \
 517                                         .min = 8,                       \
 518                                         .max = 8,                       \
 519                                         .increment = 0                  \
 520                                 },                                      \
 521                                 .iv_size = {                            \
 522                                         .min = 8,                       \
 523                                         .max = 8,                       \
 524                                         .increment = 0                  \
 525                                 }                                       \
 526                         }, }                                            \
 527                 }, }                                                    \
 528         }
 529
 530 #define QAT_EXTRA_GEN2_SYM_CAPABILITIES                                 \
 531         {       /* ZUC (EEA3) */                                        \
 532                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 533                 {.sym = {                                               \
 534                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
 535                         {.cipher = {                                    \
 536                                 .algo = RTE_CRYPTO_CIPHER_ZUC_EEA3,     \
 537                                 .block_size = 16,                       \
 538                                 .key_size = {                           \
 539                                         .min = 16,                      \
 540                                         .max = 16,                      \
 541                                         .increment = 0                  \
 542                                 },                                      \
 543                                 .iv_size = {                            \
 544                                         .min = 16,                      \
 545                                         .max = 16,                      \
 546                                         .increment = 0                  \
 547                                 }                                       \
 548                         }, }                                            \
 549                 }, }                                                    \
 550         },                                                              \
 551         {       /* ZUC (EIA3) */                                        \
 552                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
 553                 {.sym = {                                               \
 554                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
 555                         {.auth = {                                      \
 556                                 .algo = RTE_CRYPTO_AUTH_ZUC_EIA3,       \
 557                                 .block_size = 16,                       \
 558                                 .key_size = {                           \
 559                                         .min = 16,                      \
 560                                         .max = 16,                      \
 561                                         .increment = 0                  \
 562                                 },                                      \
 563                                 .digest_size = {                        \
 564                                         .min = 4,                       \
 565                                         .max = 4,                       \
 566                                         .increment = 0                  \
 567                                 },                                      \
 568                                 .iv_size = {                            \
 569                                         .min = 16,                      \
 570                                         .max = 16,                      \
 571                                         .increment = 0                  \
 572                                 }                                       \
 573                         }, }                                            \
 574                 }, }                                                    \
 575         }
 576
 577 #endif /* _QAT_SYM_CAPABILITIES_H_ */