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