drivers/crypto/cnxk/cnxk_cryptodev_capabilities.c

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