drivers/crypto/octeontx2/otx2_cryptodev_capabilities.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright (C) 2019 Marvell International Ltd.
   3  */
   4
   5 #include <rte_cryptodev.h>
   6
   7 #include "otx2_cryptodev_capabilities.h"
   8 #include "otx2_mbox.h"
   9
  10 #define CPT_EGRP_GET(hw_caps, name, egrp) do {  \
  11         if ((hw_caps[CPT_ENG_TYPE_SE].name) &&  \
  12             (hw_caps[CPT_ENG_TYPE_IE].name))    \
  13                 *egrp = OTX2_CPT_EGRP_SE_IE;    \
  14         else if (hw_caps[CPT_ENG_TYPE_SE].name) \
  15                 *egrp = OTX2_CPT_EGRP_SE;       \
  16         else if (hw_caps[CPT_ENG_TYPE_AE].name) \
  17                 *egrp = OTX2_CPT_EGRP_AE;       \
  18         else                                    \
  19                 *egrp = OTX2_CPT_EGRP_MAX;      \
  20 } while (0)
  21
  22 #define CPT_CAPS_ADD(hw_caps, name) do {                                \
  23         enum otx2_cpt_egrp egrp;                                        \
  24         CPT_EGRP_GET(hw_caps, name, &egrp);                             \
  25         if (egrp < OTX2_CPT_EGRP_MAX)                                   \
  26                 cpt_caps_add(caps_##name, RTE_DIM(caps_##name));        \
  27 } while (0)
  28
  29 #define OTX2_CPT_MAX_CAPS 34
  30
  31 static struct rte_cryptodev_capabilities otx2_cpt_caps[OTX2_CPT_MAX_CAPS];
  32
  33 static const struct rte_cryptodev_capabilities caps_mul[] = {
  34         {       /* RSA */
  35                 .op = RTE_CRYPTO_OP_TYPE_ASYMMETRIC,
  36                 {.asym = {
  37                         .xform_capa = {
  38                                 .xform_type = RTE_CRYPTO_ASYM_XFORM_RSA,
  39                                 .op_types = ((1 << RTE_CRYPTO_ASYM_OP_SIGN) |
  40                                         (1 << RTE_CRYPTO_ASYM_OP_VERIFY) |
  41                                         (1 << RTE_CRYPTO_ASYM_OP_ENCRYPT) |
  42                                         (1 << RTE_CRYPTO_ASYM_OP_DECRYPT)),
  43                                 {.modlen = {
  44                                         .min = 17,
  45                                         .max = 1024,
  46                                         .increment = 1
  47                                 }, }
  48                         }
  49                 }, }
  50         },
  51         {       /* MOD_EXP */
  52                 .op = RTE_CRYPTO_OP_TYPE_ASYMMETRIC,
  53                 {.asym = {
  54                         .xform_capa = {
  55                                 .xform_type = RTE_CRYPTO_ASYM_XFORM_MODEX,
  56                                 .op_types = 0,
  57                                 {.modlen = {
  58                                         .min = 17,
  59                                         .max = 1024,
  60                                         .increment = 1
  61                                 }, }
  62                         }
  63                 }, }
  64         },
  65         {       /* ECDSA */
  66                 .op = RTE_CRYPTO_OP_TYPE_ASYMMETRIC,
  67                 {.asym = {
  68                         .xform_capa = {
  69                                 .xform_type = RTE_CRYPTO_ASYM_XFORM_ECDSA,
  70                                 .op_types = ((1 << RTE_CRYPTO_ASYM_OP_SIGN) |
  71                                         (1 << RTE_CRYPTO_ASYM_OP_VERIFY)),
  72                                 }
  73                         },
  74                 }
  75         },
  76         {       /* ECPM */
  77                 .op = RTE_CRYPTO_OP_TYPE_ASYMMETRIC,
  78                 {.asym = {
  79                         .xform_capa = {
  80                                 .xform_type = RTE_CRYPTO_ASYM_XFORM_ECPM,
  81                                 .op_types = 0
  82                                 }
  83                         },
  84                 }
  85         },
  86 };
  87
  88 static const struct rte_cryptodev_capabilities caps_sha1_sha2[] = {
  89         {       /* SHA1 */
  90                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
  91                 {.sym = {
  92                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
  93                         {.auth = {
  94                                 .algo = RTE_CRYPTO_AUTH_SHA1,
  95                                 .block_size = 64,
  96                                 .key_size = {
  97                                         .min = 0,
  98                                         .max = 0,
  99                                         .increment = 0
 100                                 },
 101                                 .digest_size = {
 102                                         .min = 20,
 103                                         .max = 20,
 104                                         .increment = 0
 105                                 },
 106                         }, }
 107                 }, }
 108         },
 109         {       /* SHA1 HMAC */
 110                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 111                 {.sym = {
 112                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 113                         {.auth = {
 114                                 .algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
 115                                 .block_size = 64,
 116                                 .key_size = {
 117                                         .min = 1,
 118                                         .max = 1024,
 119                                         .increment = 1
 120                                 },
 121                                 .digest_size = {
 122                                         .min = 12,
 123                                         .max = 20,
 124                                         .increment = 8
 125                                 },
 126                         }, }
 127                 }, }
 128         },
 129         {       /* SHA224 */
 130                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 131                 {.sym = {
 132                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 133                         {.auth = {
 134                                 .algo = RTE_CRYPTO_AUTH_SHA224,
 135                                 .block_size = 64,
 136                                         .key_size = {
 137                                         .min = 0,
 138                                         .max = 0,
 139                                         .increment = 0
 140                                 },
 141                                 .digest_size = {
 142                                         .min = 28,
 143                                         .max = 28,
 144                                         .increment = 0
 145                                 },
 146                         }, }
 147                 }, }
 148         },
 149         {       /* SHA224 HMAC */
 150                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 151                 {.sym = {
 152                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 153                         {.auth = {
 154                                 .algo = RTE_CRYPTO_AUTH_SHA224_HMAC,
 155                                 .block_size = 64,
 156                                         .key_size = {
 157                                         .min = 1,
 158                                         .max = 1024,
 159                                         .increment = 1
 160                                 },
 161                                 .digest_size = {
 162                                         .min = 28,
 163                                         .max = 28,
 164                                         .increment = 0
 165                                 },
 166                         }, }
 167                 }, }
 168         },
 169         {       /* SHA256 */
 170                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 171                 {.sym = {
 172                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 173                         {.auth = {
 174                                 .algo = RTE_CRYPTO_AUTH_SHA256,
 175                                 .block_size = 64,
 176                                 .key_size = {
 177                                         .min = 0,
 178                                         .max = 0,
 179                                         .increment = 0
 180                                 },
 181                                 .digest_size = {
 182                                         .min = 32,
 183                                         .max = 32,
 184                                         .increment = 0
 185                                 },
 186                         }, }
 187                 }, }
 188         },
 189         {       /* SHA256 HMAC */
 190                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 191                 {.sym = {
 192                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 193                         {.auth = {
 194                                 .algo = RTE_CRYPTO_AUTH_SHA256_HMAC,
 195                                 .block_size = 64,
 196                                 .key_size = {
 197                                         .min = 1,
 198                                         .max = 1024,
 199                                         .increment = 1
 200                                 },
 201                                 .digest_size = {
 202                                         .min = 16,
 203                                         .max = 32,
 204                                         .increment = 16
 205                                 },
 206                         }, }
 207                 }, }
 208         },
 209         {       /* SHA384 */
 210                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 211                 {.sym = {
 212                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 213                         {.auth = {
 214                                 .algo = RTE_CRYPTO_AUTH_SHA384,
 215                                 .block_size = 64,
 216                                 .key_size = {
 217                                         .min = 0,
 218                                         .max = 0,
 219                                         .increment = 0
 220                                 },
 221                                 .digest_size = {
 222                                         .min = 48,
 223                                         .max = 48,
 224                                         .increment = 0
 225                                         },
 226                         }, }
 227                 }, }
 228         },
 229         {       /* SHA384 HMAC */
 230                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 231                 {.sym = {
 232                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 233                         {.auth = {
 234                                 .algo = RTE_CRYPTO_AUTH_SHA384_HMAC,
 235                                 .block_size = 64,
 236                                 .key_size = {
 237                                         .min = 1,
 238                                         .max = 1024,
 239                                         .increment = 1
 240                                 },
 241                                 .digest_size = {
 242                                         .min = 24,
 243                                         .max = 48,
 244                                         .increment = 24
 245                                         },
 246                         }, }
 247                 }, }
 248         },
 249         {       /* SHA512 */
 250                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 251                 {.sym = {
 252                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 253                         {.auth = {
 254                                 .algo = RTE_CRYPTO_AUTH_SHA512,
 255                                 .block_size = 128,
 256                                 .key_size = {
 257                                         .min = 0,
 258                                         .max = 0,
 259                                         .increment = 0
 260                                 },
 261                                 .digest_size = {
 262                                         .min = 64,
 263                                         .max = 64,
 264                                         .increment = 0
 265                                 },
 266                         }, }
 267                 }, }
 268         },
 269         {       /* SHA512 HMAC */
 270                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 271                 {.sym = {
 272                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 273                         {.auth = {
 274                                 .algo = RTE_CRYPTO_AUTH_SHA512_HMAC,
 275                                 .block_size = 128,
 276                                 .key_size = {
 277                                         .min = 1,
 278                                         .max = 1024,
 279                                         .increment = 1
 280                                 },
 281                                 .digest_size = {
 282                                         .min = 32,
 283                                         .max = 64,
 284                                         .increment = 32
 285                                 },
 286                         }, }
 287                 }, }
 288         },
 289         {       /* MD5 */
 290                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 291                 {.sym = {
 292                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 293                         {.auth = {
 294                                 .algo = RTE_CRYPTO_AUTH_MD5,
 295                                 .block_size = 64,
 296                                 .key_size = {
 297                                         .min = 0,
 298                                         .max = 0,
 299                                         .increment = 0
 300                                 },
 301                                 .digest_size = {
 302                                         .min = 16,
 303                                         .max = 16,
 304                                         .increment = 0
 305                                 },
 306                         }, }
 307                 }, }
 308         },
 309         {       /* MD5 HMAC */
 310                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 311                 {.sym = {
 312                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 313                         {.auth = {
 314                                 .algo = RTE_CRYPTO_AUTH_MD5_HMAC,
 315                                 .block_size = 64,
 316                                 .key_size = {
 317                                         .min = 8,
 318                                         .max = 64,
 319                                         .increment = 8
 320                                 },
 321                                 .digest_size = {
 322                                         .min = 12,
 323                                         .max = 16,
 324                                         .increment = 4
 325                                 },
 326                         }, }
 327                 }, }
 328         },
 329 };
 330
 331 static const struct rte_cryptodev_capabilities caps_zuc_snow3g[] = {
 332         {       /* SNOW 3G (UEA2) */
 333                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 334                 {.sym = {
 335                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 336                         {.cipher = {
 337                                 .algo = RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
 338                                 .block_size = 16,
 339                                 .key_size = {
 340                                         .min = 16,
 341                                         .max = 16,
 342                                         .increment = 0
 343                                 },
 344                                 .iv_size = {
 345                                         .min = 16,
 346                                         .max = 16,
 347                                         .increment = 0
 348                                 }
 349                         }, }
 350                 }, }
 351         },
 352         {       /* ZUC (EEA3) */
 353                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 354                 {.sym = {
 355                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 356                         {.cipher = {
 357                                 .algo = RTE_CRYPTO_CIPHER_ZUC_EEA3,
 358                                 .block_size = 16,
 359                                 .key_size = {
 360                                         .min = 16,
 361                                         .max = 16,
 362                                         .increment = 0
 363                                 },
 364                                 .iv_size = {
 365                                         .min = 16,
 366                                         .max = 16,
 367                                         .increment = 0
 368                                 }
 369                         }, }
 370                 }, }
 371         },
 372         {       /* SNOW 3G (UIA2) */
 373                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 374                 {.sym = {
 375                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 376                         {.auth = {
 377                                 .algo = RTE_CRYPTO_AUTH_SNOW3G_UIA2,
 378                                 .block_size = 16,
 379                                 .key_size = {
 380                                         .min = 16,
 381                                         .max = 16,
 382                                         .increment = 0
 383                                 },
 384                                 .digest_size = {
 385                                         .min = 4,
 386                                         .max = 4,
 387                                         .increment = 0
 388                                 },
 389                                 .iv_size = {
 390                                         .min = 16,
 391                                         .max = 16,
 392                                         .increment = 0
 393                                 }
 394                         }, }
 395                 }, }
 396         },
 397         {       /* ZUC (EIA3) */
 398                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 399                 {.sym = {
 400                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 401                         {.auth = {
 402                                 .algo = RTE_CRYPTO_AUTH_ZUC_EIA3,
 403                                 .block_size = 16,
 404                                 .key_size = {
 405                                         .min = 16,
 406                                         .max = 16,
 407                                         .increment = 0
 408                                 },
 409                                 .digest_size = {
 410                                         .min = 4,
 411                                         .max = 4,
 412                                         .increment = 0
 413                                 },
 414                                 .iv_size = {
 415                                         .min = 16,
 416                                         .max = 16,
 417                                         .increment = 0
 418                                 }
 419                         }, }
 420                 }, }
 421         },
 422 };
 423
 424 static const struct rte_cryptodev_capabilities caps_aes[] = {
 425         {       /* AES GMAC (AUTH) */
 426                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 427                 {.sym = {
 428                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 429                         {.auth = {
 430                                 .algo = RTE_CRYPTO_AUTH_AES_GMAC,
 431                                 .block_size = 16,
 432                                 .key_size = {
 433                                         .min = 16,
 434                                         .max = 32,
 435                                         .increment = 8
 436                                 },
 437                                 .digest_size = {
 438                                         .min = 8,
 439                                         .max = 16,
 440                                         .increment = 4
 441                                 },
 442                                 .iv_size = {
 443                                         .min = 12,
 444                                         .max = 12,
 445                                         .increment = 0
 446                                 }
 447                         }, }
 448                 }, }
 449         },
 450         {       /* AES CBC */
 451                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 452                 {.sym = {
 453                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 454                         {.cipher = {
 455                                 .algo = RTE_CRYPTO_CIPHER_AES_CBC,
 456                                 .block_size = 16,
 457                                 .key_size = {
 458                                         .min = 16,
 459                                         .max = 32,
 460                                         .increment = 8
 461                                 },
 462                                 .iv_size = {
 463                                         .min = 16,
 464                                         .max = 16,
 465                                         .increment = 0
 466                                 }
 467                         }, }
 468                 }, }
 469         },
 470         {       /* AES CTR */
 471                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 472                 {.sym = {
 473                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 474                         {.cipher = {
 475                                 .algo = RTE_CRYPTO_CIPHER_AES_CTR,
 476                                 .block_size = 16,
 477                                 .key_size = {
 478                                         .min = 16,
 479                                         .max = 32,
 480                                         .increment = 8
 481                                 },
 482                                 .iv_size = {
 483                                         .min = 12,
 484                                         .max = 16,
 485                                         .increment = 4
 486                                 }
 487                         }, }
 488                 }, }
 489         },
 490         {       /* AES XTS */
 491                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 492                 {.sym = {
 493                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 494                         {.cipher = {
 495                                 .algo = RTE_CRYPTO_CIPHER_AES_XTS,
 496                                 .block_size = 16,
 497                                 .key_size = {
 498                                         .min = 32,
 499                                         .max = 64,
 500                                         .increment = 0
 501                                 },
 502                                 .iv_size = {
 503                                         .min = 16,
 504                                         .max = 16,
 505                                         .increment = 0
 506                                 }
 507                         }, }
 508                 }, }
 509         },
 510         {       /* AES GCM */
 511                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 512                 {.sym = {
 513                         .xform_type = RTE_CRYPTO_SYM_XFORM_AEAD,
 514                         {.aead = {
 515                                 .algo = RTE_CRYPTO_AEAD_AES_GCM,
 516                                 .block_size = 16,
 517                                 .key_size = {
 518                                         .min = 16,
 519                                         .max = 32,
 520                                         .increment = 8
 521                                 },
 522                                 .digest_size = {
 523                                         .min = 4,
 524                                         .max = 16,
 525                                         .increment = 1
 526                                 },
 527                                 .aad_size = {
 528                                         .min = 0,
 529                                         .max = 1024,
 530                                         .increment = 1
 531                                 },
 532                                 .iv_size = {
 533                                         .min = 12,
 534                                         .max = 12,
 535                                         .increment = 0
 536                                 }
 537                         }, }
 538                 }, }
 539         },
 540 };
 541
 542 static const struct rte_cryptodev_capabilities caps_kasumi[] = {
 543         {       /* KASUMI (F8) */
 544                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 545                 {.sym = {
 546                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 547                         {.cipher = {
 548                                 .algo = RTE_CRYPTO_CIPHER_KASUMI_F8,
 549                                 .block_size = 8,
 550                                 .key_size = {
 551                                         .min = 16,
 552                                         .max = 16,
 553                                         .increment = 0
 554                                 },
 555                                 .iv_size = {
 556                                         .min = 8,
 557                                         .max = 8,
 558                                         .increment = 0
 559                                 }
 560                         }, }
 561                 }, }
 562         },
 563         {       /* KASUMI (F9) */
 564                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 565                 {.sym = {
 566                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 567                         {.auth = {
 568                                 .algo = RTE_CRYPTO_AUTH_KASUMI_F9,
 569                                 .block_size = 8,
 570                                 .key_size = {
 571                                         .min = 16,
 572                                         .max = 16,
 573                                         .increment = 0
 574                                 },
 575                                 .digest_size = {
 576                                         .min = 4,
 577                                         .max = 4,
 578                                         .increment = 0
 579                                 },
 580                         }, }
 581                 }, }
 582         },
 583 };
 584
 585 static const struct rte_cryptodev_capabilities caps_des[] = {
 586         {       /* 3DES CBC */
 587                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 588                 {.sym = {
 589                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 590                         {.cipher = {
 591                                 .algo = RTE_CRYPTO_CIPHER_3DES_CBC,
 592                                 .block_size = 8,
 593                                 .key_size = {
 594                                         .min = 24,
 595                                         .max = 24,
 596                                         .increment = 0
 597                                 },
 598                                 .iv_size = {
 599                                         .min = 8,
 600                                         .max = 16,
 601                                         .increment = 8
 602                                 }
 603                         }, }
 604                 }, }
 605         },
 606         {       /* 3DES ECB */
 607                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 608                 {.sym = {
 609                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 610                         {.cipher = {
 611                                 .algo = RTE_CRYPTO_CIPHER_3DES_ECB,
 612                                 .block_size = 8,
 613                                 .key_size = {
 614                                         .min = 24,
 615                                         .max = 24,
 616                                         .increment = 0
 617                                 },
 618                                 .iv_size = {
 619                                         .min = 0,
 620                                         .max = 0,
 621                                         .increment = 0
 622                                 }
 623                         }, }
 624                 }, }
 625         },
 626         {       /* DES CBC */
 627                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 628                 {.sym = {
 629                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 630                         {.cipher = {
 631                                 .algo = RTE_CRYPTO_CIPHER_DES_CBC,
 632                                 .block_size = 8,
 633                                 .key_size = {
 634                                         .min = 8,
 635                                         .max = 8,
 636                                         .increment = 0
 637                                 },
 638                                 .iv_size = {
 639                                         .min = 8,
 640                                         .max = 8,
 641                                         .increment = 0
 642                                 }
 643                         }, }
 644                 }, }
 645         },
 646 };
 647
 648 static const struct rte_cryptodev_capabilities caps_null[] = {
 649         {       /* NULL (AUTH) */
 650                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 651                 {.sym = {
 652                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 653                         {.auth = {
 654                                 .algo = RTE_CRYPTO_AUTH_NULL,
 655                                 .block_size = 1,
 656                                 .key_size = {
 657                                         .min = 0,
 658                                         .max = 0,
 659                                         .increment = 0
 660                                 },
 661                                 .digest_size = {
 662                                         .min = 0,
 663                                         .max = 0,
 664                                         .increment = 0
 665                                 },
 666                         }, },
 667                 }, },
 668         },
 669         {       /* NULL (CIPHER) */
 670                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 671                 {.sym = {
 672                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 673                         {.cipher = {
 674                                 .algo = RTE_CRYPTO_CIPHER_NULL,
 675                                 .block_size = 1,
 676                                 .key_size = {
 677                                         .min = 0,
 678                                         .max = 0,
 679                                         .increment = 0
 680                                 },
 681                                 .iv_size = {
 682                                         .min = 0,
 683                                         .max = 0,
 684                                         .increment = 0
 685                                 }
 686                         }, },
 687                 }, }
 688         },
 689 };
 690
 691 static const struct rte_cryptodev_capabilities caps_end[] = {
 692         RTE_CRYPTODEV_END_OF_CAPABILITIES_LIST()
 693 };
 694
 695 static void
 696 cpt_caps_add(const struct rte_cryptodev_capabilities *caps, int nb_caps)
 697 {
 698         static int cur_pos;
 699
 700         if (cur_pos + nb_caps > OTX2_CPT_MAX_CAPS)
 701                 return;
 702
 703         memcpy(&otx2_cpt_caps[cur_pos], caps, nb_caps * sizeof(caps[0]));
 704         cur_pos += nb_caps;
 705 }
 706
 707 const struct rte_cryptodev_capabilities *
 708 otx2_cpt_capabilities_get(union cpt_eng_caps *hw_caps)
 709 {
 710
 711         CPT_CAPS_ADD(hw_caps, mul);
 712         CPT_CAPS_ADD(hw_caps, sha1_sha2);
 713         CPT_CAPS_ADD(hw_caps, zuc_snow3g);
 714         CPT_CAPS_ADD(hw_caps, aes);
 715         CPT_CAPS_ADD(hw_caps, kasumi);
 716         CPT_CAPS_ADD(hw_caps, des);
 717
 718         cpt_caps_add(caps_null, RTE_DIM(caps_null));
 719         cpt_caps_add(caps_end, RTE_DIM(caps_end));
 720
 721         return otx2_cpt_caps;
 722 }