drivers/crypto/cnxk/cnxk_cryptodev_capabilities.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(C) 2021 Marvell.
   3  */
   4
   5 #include <cryptodev_pmd.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_mul[] = {
  32         {       /* RSA */
  33                 .op = RTE_CRYPTO_OP_TYPE_ASYMMETRIC,
  34                 {.asym = {
  35                         .xform_capa = {
  36                                 .xform_type = RTE_CRYPTO_ASYM_XFORM_RSA,
  37                                 .op_types = ((1 << RTE_CRYPTO_ASYM_OP_SIGN) |
  38                                         (1 << RTE_CRYPTO_ASYM_OP_VERIFY) |
  39                                         (1 << RTE_CRYPTO_ASYM_OP_ENCRYPT) |
  40                                         (1 << RTE_CRYPTO_ASYM_OP_DECRYPT)),
  41                                 {.modlen = {
  42                                         .min = 17,
  43                                         .max = 1024,
  44                                         .increment = 1
  45                                 }, }
  46                         }
  47                 }, }
  48         },
  49         {       /* MOD_EXP */
  50                 .op = RTE_CRYPTO_OP_TYPE_ASYMMETRIC,
  51                 {.asym = {
  52                         .xform_capa = {
  53                                 .xform_type = RTE_CRYPTO_ASYM_XFORM_MODEX,
  54                                 .op_types = 0,
  55                                 {.modlen = {
  56                                         .min = 17,
  57                                         .max = 1024,
  58                                         .increment = 1
  59                                 }, }
  60                         }
  61                 }, }
  62         },
  63         {       /* ECDSA */
  64                 .op = RTE_CRYPTO_OP_TYPE_ASYMMETRIC,
  65                 {.asym = {
  66                         .xform_capa = {
  67                                 .xform_type = RTE_CRYPTO_ASYM_XFORM_ECDSA,
  68                                 .op_types = ((1 << RTE_CRYPTO_ASYM_OP_SIGN) |
  69                                         (1 << RTE_CRYPTO_ASYM_OP_VERIFY)),
  70                                 }
  71                         },
  72                 }
  73         },
  74         {       /* ECPM */
  75                 .op = RTE_CRYPTO_OP_TYPE_ASYMMETRIC,
  76                 {.asym = {
  77                         .xform_capa = {
  78                                 .xform_type = RTE_CRYPTO_ASYM_XFORM_ECPM,
  79                                 .op_types = 0
  80                                 }
  81                         },
  82                 }
  83         },
  84 };
  85
  86 static const struct rte_cryptodev_capabilities caps_sha1_sha2[] = {
  87         {       /* SHA1 */
  88                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
  89                 {.sym = {
  90                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
  91                         {.auth = {
  92                                 .algo = RTE_CRYPTO_AUTH_SHA1,
  93                                 .block_size = 64,
  94                                 .key_size = {
  95                                         .min = 0,
  96                                         .max = 0,
  97                                         .increment = 0
  98                                 },
  99                                 .digest_size = {
 100                                         .min = 20,
 101                                         .max = 20,
 102                                         .increment = 0
 103                                 },
 104                         }, }
 105                 }, }
 106         },
 107         {       /* SHA1 HMAC */
 108                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 109                 {.sym = {
 110                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 111                         {.auth = {
 112                                 .algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
 113                                 .block_size = 64,
 114                                 .key_size = {
 115                                         .min = 1,
 116                                         .max = 1024,
 117                                         .increment = 1
 118                                 },
 119                                 .digest_size = {
 120                                         .min = 12,
 121                                         .max = 20,
 122                                         .increment = 8
 123                                 },
 124                         }, }
 125                 }, }
 126         },
 127         {       /* SHA224 */
 128                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 129                 {.sym = {
 130                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 131                         {.auth = {
 132                                 .algo = RTE_CRYPTO_AUTH_SHA224,
 133                                 .block_size = 64,
 134                                         .key_size = {
 135                                         .min = 0,
 136                                         .max = 0,
 137                                         .increment = 0
 138                                 },
 139                                 .digest_size = {
 140                                         .min = 28,
 141                                         .max = 28,
 142                                         .increment = 0
 143                                 },
 144                         }, }
 145                 }, }
 146         },
 147         {       /* SHA224 HMAC */
 148                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 149                 {.sym = {
 150                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 151                         {.auth = {
 152                                 .algo = RTE_CRYPTO_AUTH_SHA224_HMAC,
 153                                 .block_size = 64,
 154                                         .key_size = {
 155                                         .min = 1,
 156                                         .max = 1024,
 157                                         .increment = 1
 158                                 },
 159                                 .digest_size = {
 160                                         .min = 28,
 161                                         .max = 28,
 162                                         .increment = 0
 163                                 },
 164                         }, }
 165                 }, }
 166         },
 167         {       /* SHA256 */
 168                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 169                 {.sym = {
 170                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 171                         {.auth = {
 172                                 .algo = RTE_CRYPTO_AUTH_SHA256,
 173                                 .block_size = 64,
 174                                 .key_size = {
 175                                         .min = 0,
 176                                         .max = 0,
 177                                         .increment = 0
 178                                 },
 179                                 .digest_size = {
 180                                         .min = 32,
 181                                         .max = 32,
 182                                         .increment = 0
 183                                 },
 184                         }, }
 185                 }, }
 186         },
 187         {       /* SHA256 HMAC */
 188                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 189                 {.sym = {
 190                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 191                         {.auth = {
 192                                 .algo = RTE_CRYPTO_AUTH_SHA256_HMAC,
 193                                 .block_size = 64,
 194                                 .key_size = {
 195                                         .min = 1,
 196                                         .max = 1024,
 197                                         .increment = 1
 198                                 },
 199                                 .digest_size = {
 200                                         .min = 16,
 201                                         .max = 32,
 202                                         .increment = 16
 203                                 },
 204                         }, }
 205                 }, }
 206         },
 207         {       /* SHA384 */
 208                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 209                 {.sym = {
 210                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 211                         {.auth = {
 212                                 .algo = RTE_CRYPTO_AUTH_SHA384,
 213                                 .block_size = 64,
 214                                 .key_size = {
 215                                         .min = 0,
 216                                         .max = 0,
 217                                         .increment = 0
 218                                 },
 219                                 .digest_size = {
 220                                         .min = 48,
 221                                         .max = 48,
 222                                         .increment = 0
 223                                         },
 224                         }, }
 225                 }, }
 226         },
 227         {       /* SHA384 HMAC */
 228                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 229                 {.sym = {
 230                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 231                         {.auth = {
 232                                 .algo = RTE_CRYPTO_AUTH_SHA384_HMAC,
 233                                 .block_size = 64,
 234                                 .key_size = {
 235                                         .min = 1,
 236                                         .max = 1024,
 237                                         .increment = 1
 238                                 },
 239                                 .digest_size = {
 240                                         .min = 24,
 241                                         .max = 48,
 242                                         .increment = 24
 243                                         },
 244                         }, }
 245                 }, }
 246         },
 247         {       /* SHA512 */
 248                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 249                 {.sym = {
 250                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 251                         {.auth = {
 252                                 .algo = RTE_CRYPTO_AUTH_SHA512,
 253                                 .block_size = 128,
 254                                 .key_size = {
 255                                         .min = 0,
 256                                         .max = 0,
 257                                         .increment = 0
 258                                 },
 259                                 .digest_size = {
 260                                         .min = 64,
 261                                         .max = 64,
 262                                         .increment = 0
 263                                 },
 264                         }, }
 265                 }, }
 266         },
 267         {       /* SHA512 HMAC */
 268                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 269                 {.sym = {
 270                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 271                         {.auth = {
 272                                 .algo = RTE_CRYPTO_AUTH_SHA512_HMAC,
 273                                 .block_size = 128,
 274                                 .key_size = {
 275                                         .min = 1,
 276                                         .max = 1024,
 277                                         .increment = 1
 278                                 },
 279                                 .digest_size = {
 280                                         .min = 32,
 281                                         .max = 64,
 282                                         .increment = 32
 283                                 },
 284                         }, }
 285                 }, }
 286         },
 287         {       /* MD5 */
 288                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 289                 {.sym = {
 290                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 291                         {.auth = {
 292                                 .algo = RTE_CRYPTO_AUTH_MD5,
 293                                 .block_size = 64,
 294                                 .key_size = {
 295                                         .min = 0,
 296                                         .max = 0,
 297                                         .increment = 0
 298                                 },
 299                                 .digest_size = {
 300                                         .min = 16,
 301                                         .max = 16,
 302                                         .increment = 0
 303                                 },
 304                         }, }
 305                 }, }
 306         },
 307         {       /* MD5 HMAC */
 308                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 309                 {.sym = {
 310                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 311                         {.auth = {
 312                                 .algo = RTE_CRYPTO_AUTH_MD5_HMAC,
 313                                 .block_size = 64,
 314                                 .key_size = {
 315                                         .min = 8,
 316                                         .max = 64,
 317                                         .increment = 8
 318                                 },
 319                                 .digest_size = {
 320                                         .min = 12,
 321                                         .max = 16,
 322                                         .increment = 4
 323                                 },
 324                         }, }
 325                 }, }
 326         },
 327 };
 328
 329 static const struct rte_cryptodev_capabilities caps_chacha20[] = {
 330         {       /* Chacha20-Poly1305 */
 331                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 332                 {.sym = {
 333                         .xform_type = RTE_CRYPTO_SYM_XFORM_AEAD,
 334                         {.aead = {
 335                                 .algo = RTE_CRYPTO_AEAD_CHACHA20_POLY1305,
 336                                 .block_size = 64,
 337                                 .key_size = {
 338                                         .min = 32,
 339                                         .max = 32,
 340                                         .increment = 0
 341                                 },
 342                                 .digest_size = {
 343                                         .min = 16,
 344                                         .max = 16,
 345                                         .increment = 0
 346                                 },
 347                                 .aad_size = {
 348                                         .min = 0,
 349                                         .max = 1024,
 350                                         .increment = 1
 351                                 },
 352                                 .iv_size = {
 353                                         .min = 12,
 354                                         .max = 12,
 355                                         .increment = 0
 356                                 },
 357                         }, }
 358                 }, }
 359         }
 360 };
 361
 362 static const struct rte_cryptodev_capabilities caps_zuc_snow3g[] = {
 363         {       /* SNOW 3G (UEA2) */
 364                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 365                 {.sym = {
 366                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 367                         {.cipher = {
 368                                 .algo = RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
 369                                 .block_size = 16,
 370                                 .key_size = {
 371                                         .min = 16,
 372                                         .max = 16,
 373                                         .increment = 0
 374                                 },
 375                                 .iv_size = {
 376                                         .min = 16,
 377                                         .max = 16,
 378                                         .increment = 0
 379                                 }
 380                         }, }
 381                 }, }
 382         },
 383         {       /* ZUC (EEA3) */
 384                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 385                 {.sym = {
 386                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 387                         {.cipher = {
 388                                 .algo = RTE_CRYPTO_CIPHER_ZUC_EEA3,
 389                                 .block_size = 16,
 390                                 .key_size = {
 391                                         .min = 16,
 392                                         .max = 16,
 393                                         .increment = 0
 394                                 },
 395                                 .iv_size = {
 396                                         .min = 16,
 397                                         .max = 16,
 398                                         .increment = 0
 399                                 }
 400                         }, }
 401                 }, }
 402         },
 403         {       /* SNOW 3G (UIA2) */
 404                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 405                 {.sym = {
 406                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 407                         {.auth = {
 408                                 .algo = RTE_CRYPTO_AUTH_SNOW3G_UIA2,
 409                                 .block_size = 16,
 410                                 .key_size = {
 411                                         .min = 16,
 412                                         .max = 16,
 413                                         .increment = 0
 414                                 },
 415                                 .digest_size = {
 416                                         .min = 4,
 417                                         .max = 4,
 418                                         .increment = 0
 419                                 },
 420                                 .iv_size = {
 421                                         .min = 16,
 422                                         .max = 16,
 423                                         .increment = 0
 424                                 }
 425                         }, }
 426                 }, }
 427         },
 428         {       /* ZUC (EIA3) */
 429                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 430                 {.sym = {
 431                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 432                         {.auth = {
 433                                 .algo = RTE_CRYPTO_AUTH_ZUC_EIA3,
 434                                 .block_size = 16,
 435                                 .key_size = {
 436                                         .min = 16,
 437                                         .max = 16,
 438                                         .increment = 0
 439                                 },
 440                                 .digest_size = {
 441                                         .min = 4,
 442                                         .max = 4,
 443                                         .increment = 0
 444                                 },
 445                                 .iv_size = {
 446                                         .min = 16,
 447                                         .max = 16,
 448                                         .increment = 0
 449                                 }
 450                         }, }
 451                 }, }
 452         },
 453 };
 454
 455 static const struct rte_cryptodev_capabilities caps_aes[] = {
 456         {       /* AES GMAC (AUTH) */
 457                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 458                 {.sym = {
 459                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 460                         {.auth = {
 461                                 .algo = RTE_CRYPTO_AUTH_AES_GMAC,
 462                                 .block_size = 16,
 463                                 .key_size = {
 464                                         .min = 16,
 465                                         .max = 32,
 466                                         .increment = 8
 467                                 },
 468                                 .digest_size = {
 469                                         .min = 8,
 470                                         .max = 16,
 471                                         .increment = 4
 472                                 },
 473                                 .iv_size = {
 474                                         .min = 12,
 475                                         .max = 12,
 476                                         .increment = 0
 477                                 }
 478                         }, }
 479                 }, }
 480         },
 481         {       /* AES CBC */
 482                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 483                 {.sym = {
 484                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 485                         {.cipher = {
 486                                 .algo = RTE_CRYPTO_CIPHER_AES_CBC,
 487                                 .block_size = 16,
 488                                 .key_size = {
 489                                         .min = 16,
 490                                         .max = 32,
 491                                         .increment = 8
 492                                 },
 493                                 .iv_size = {
 494                                         .min = 16,
 495                                         .max = 16,
 496                                         .increment = 0
 497                                 }
 498                         }, }
 499                 }, }
 500         },
 501         {       /* AES CTR */
 502                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 503                 {.sym = {
 504                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 505                         {.cipher = {
 506                                 .algo = RTE_CRYPTO_CIPHER_AES_CTR,
 507                                 .block_size = 16,
 508                                 .key_size = {
 509                                         .min = 16,
 510                                         .max = 32,
 511                                         .increment = 8
 512                                 },
 513                                 .iv_size = {
 514                                         .min = 12,
 515                                         .max = 16,
 516                                         .increment = 4
 517                                 }
 518                         }, }
 519                 }, }
 520         },
 521         {       /* AES XTS */
 522                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 523                 {.sym = {
 524                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 525                         {.cipher = {
 526                                 .algo = RTE_CRYPTO_CIPHER_AES_XTS,
 527                                 .block_size = 16,
 528                                 .key_size = {
 529                                         .min = 32,
 530                                         .max = 64,
 531                                         .increment = 32
 532                                 },
 533                                 .iv_size = {
 534                                         .min = 16,
 535                                         .max = 16,
 536                                         .increment = 0
 537                                 }
 538                         }, }
 539                 }, }
 540         },
 541         {       /* AES GCM */
 542                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 543                 {.sym = {
 544                         .xform_type = RTE_CRYPTO_SYM_XFORM_AEAD,
 545                         {.aead = {
 546                                 .algo = RTE_CRYPTO_AEAD_AES_GCM,
 547                                 .block_size = 16,
 548                                 .key_size = {
 549                                         .min = 16,
 550                                         .max = 32,
 551                                         .increment = 8
 552                                 },
 553                                 .digest_size = {
 554                                         .min = 4,
 555                                         .max = 16,
 556                                         .increment = 1
 557                                 },
 558                                 .aad_size = {
 559                                         .min = 0,
 560                                         .max = 1024,
 561                                         .increment = 1
 562                                 },
 563                                 .iv_size = {
 564                                         .min = 12,
 565                                         .max = 12,
 566                                         .increment = 0
 567                                 }
 568                         }, }
 569                 }, }
 570         },
 571 };
 572
 573 static const struct rte_cryptodev_capabilities caps_kasumi[] = {
 574         {       /* KASUMI (F8) */
 575                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 576                 {.sym = {
 577                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 578                         {.cipher = {
 579                                 .algo = RTE_CRYPTO_CIPHER_KASUMI_F8,
 580                                 .block_size = 8,
 581                                 .key_size = {
 582                                         .min = 16,
 583                                         .max = 16,
 584                                         .increment = 0
 585                                 },
 586                                 .iv_size = {
 587                                         .min = 8,
 588                                         .max = 8,
 589                                         .increment = 0
 590                                 }
 591                         }, }
 592                 }, }
 593         },
 594         {       /* KASUMI (F9) */
 595                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 596                 {.sym = {
 597                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 598                         {.auth = {
 599                                 .algo = RTE_CRYPTO_AUTH_KASUMI_F9,
 600                                 .block_size = 8,
 601                                 .key_size = {
 602                                         .min = 16,
 603                                         .max = 16,
 604                                         .increment = 0
 605                                 },
 606                                 .digest_size = {
 607                                         .min = 4,
 608                                         .max = 4,
 609                                         .increment = 0
 610                                 },
 611                         }, }
 612                 }, }
 613         },
 614 };
 615
 616 static const struct rte_cryptodev_capabilities caps_des[] = {
 617         {       /* 3DES CBC */
 618                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 619                 {.sym = {
 620                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 621                         {.cipher = {
 622                                 .algo = RTE_CRYPTO_CIPHER_3DES_CBC,
 623                                 .block_size = 8,
 624                                 .key_size = {
 625                                         .min = 24,
 626                                         .max = 24,
 627                                         .increment = 0
 628                                 },
 629                                 .iv_size = {
 630                                         .min = 8,
 631                                         .max = 16,
 632                                         .increment = 8
 633                                 }
 634                         }, }
 635                 }, }
 636         },
 637         {       /* 3DES ECB */
 638                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 639                 {.sym = {
 640                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 641                         {.cipher = {
 642                                 .algo = RTE_CRYPTO_CIPHER_3DES_ECB,
 643                                 .block_size = 8,
 644                                 .key_size = {
 645                                         .min = 24,
 646                                         .max = 24,
 647                                         .increment = 0
 648                                 },
 649                                 .iv_size = {
 650                                         .min = 0,
 651                                         .max = 0,
 652                                         .increment = 0
 653                                 }
 654                         }, }
 655                 }, }
 656         },
 657         {       /* DES CBC */
 658                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 659                 {.sym = {
 660                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 661                         {.cipher = {
 662                                 .algo = RTE_CRYPTO_CIPHER_DES_CBC,
 663                                 .block_size = 8,
 664                                 .key_size = {
 665                                         .min = 8,
 666                                         .max = 8,
 667                                         .increment = 0
 668                                 },
 669                                 .iv_size = {
 670                                         .min = 8,
 671                                         .max = 8,
 672                                         .increment = 0
 673                                 }
 674                         }, }
 675                 }, }
 676         },
 677 };
 678
 679 static const struct rte_cryptodev_capabilities caps_null[] = {
 680         {       /* NULL (AUTH) */
 681                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 682                 {.sym = {
 683                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 684                         {.auth = {
 685                                 .algo = RTE_CRYPTO_AUTH_NULL,
 686                                 .block_size = 1,
 687                                 .key_size = {
 688                                         .min = 0,
 689                                         .max = 0,
 690                                         .increment = 0
 691                                 },
 692                                 .digest_size = {
 693                                         .min = 0,
 694                                         .max = 0,
 695                                         .increment = 0
 696                                 },
 697                         }, },
 698                 }, },
 699         },
 700         {       /* NULL (CIPHER) */
 701                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 702                 {.sym = {
 703                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 704                         {.cipher = {
 705                                 .algo = RTE_CRYPTO_CIPHER_NULL,
 706                                 .block_size = 1,
 707                                 .key_size = {
 708                                         .min = 0,
 709                                         .max = 0,
 710                                         .increment = 0
 711                                 },
 712                                 .iv_size = {
 713                                         .min = 0,
 714                                         .max = 0,
 715                                         .increment = 0
 716                                 }
 717                         }, },
 718                 }, }
 719         },
 720 };
 721
 722 static const struct rte_cryptodev_capabilities caps_end[] = {
 723         RTE_CRYPTODEV_END_OF_CAPABILITIES_LIST()
 724 };
 725
 726 static const struct rte_cryptodev_capabilities sec_caps_aes[] = {
 727         {       /* AES GCM */
 728                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 729                 {.sym = {
 730                         .xform_type = RTE_CRYPTO_SYM_XFORM_AEAD,
 731                         {.aead = {
 732                                 .algo = RTE_CRYPTO_AEAD_AES_GCM,
 733                                 .block_size = 16,
 734                                 .key_size = {
 735                                         .min = 16,
 736                                         .max = 32,
 737                                         .increment = 8
 738                                 },
 739                                 .digest_size = {
 740                                         .min = 16,
 741                                         .max = 16,
 742                                         .increment = 0
 743                                 },
 744                                 .aad_size = {
 745                                         .min = 8,
 746                                         .max = 12,
 747                                         .increment = 4
 748                                 },
 749                                 .iv_size = {
 750                                         .min = 12,
 751                                         .max = 12,
 752                                         .increment = 0
 753                                 }
 754                         }, }
 755                 }, }
 756         },
 757         {       /* AES CBC */
 758                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 759                 {.sym = {
 760                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 761                         {.cipher = {
 762                                 .algo = RTE_CRYPTO_CIPHER_AES_CBC,
 763                                 .block_size = 16,
 764                                 .key_size = {
 765                                         .min = 16,
 766                                         .max = 32,
 767                                         .increment = 8
 768                                 },
 769                                 .iv_size = {
 770                                         .min = 16,
 771                                         .max = 16,
 772                                         .increment = 0
 773                                 }
 774                         }, }
 775                 }, }
 776         },
 777 };
 778
 779 static const struct rte_cryptodev_capabilities sec_caps_sha1_sha2[] = {
 780         {       /* SHA1 HMAC */
 781                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 782                 {.sym = {
 783                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 784                         {.auth = {
 785                                 .algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
 786                                 .block_size = 64,
 787                                 .key_size = {
 788                                         .min = 20,
 789                                         .max = 64,
 790                                         .increment = 1
 791                                 },
 792                                 .digest_size = {
 793                                         .min = 12,
 794                                         .max = 12,
 795                                         .increment = 0
 796                                 },
 797                         }, }
 798                 }, }
 799         },
 800         {       /* SHA256 HMAC */
 801                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 802                 {.sym = {
 803                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 804                         {.auth = {
 805                                 .algo = RTE_CRYPTO_AUTH_SHA256_HMAC,
 806                                 .block_size = 64,
 807                                 .key_size = {
 808                                         .min = 1,
 809                                         .max = 1024,
 810                                         .increment = 1
 811                                 },
 812                                 .digest_size = {
 813                                         .min = 16,
 814                                         .max = 16,
 815                                         .increment = 0
 816                                 },
 817                         }, }
 818                 }, }
 819         },
 820 };
 821
 822 static const struct rte_security_capability sec_caps_templ[] = {
 823         {       /* IPsec Lookaside Protocol ESP Tunnel Ingress */
 824                 .action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
 825                 .protocol = RTE_SECURITY_PROTOCOL_IPSEC,
 826                 .ipsec = {
 827                         .proto = RTE_SECURITY_IPSEC_SA_PROTO_ESP,
 828                         .mode = RTE_SECURITY_IPSEC_SA_MODE_TUNNEL,
 829                         .direction = RTE_SECURITY_IPSEC_SA_DIR_INGRESS,
 830                         .options = { 0 },
 831                 },
 832                 .crypto_capabilities = NULL,
 833         },
 834         {       /* IPsec Lookaside Protocol ESP Tunnel Egress */
 835                 .action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
 836                 .protocol = RTE_SECURITY_PROTOCOL_IPSEC,
 837                 .ipsec = {
 838                         .proto = RTE_SECURITY_IPSEC_SA_PROTO_ESP,
 839                         .mode = RTE_SECURITY_IPSEC_SA_MODE_TUNNEL,
 840                         .direction = RTE_SECURITY_IPSEC_SA_DIR_EGRESS,
 841                         .options = { 0 },
 842                 },
 843                 .crypto_capabilities = NULL,
 844         },
 845         {       /* IPsec Lookaside Protocol ESP Transport Ingress */
 846                 .action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
 847                 .protocol = RTE_SECURITY_PROTOCOL_IPSEC,
 848                 .ipsec = {
 849                         .proto = RTE_SECURITY_IPSEC_SA_PROTO_ESP,
 850                         .mode = RTE_SECURITY_IPSEC_SA_MODE_TRANSPORT,
 851                         .direction = RTE_SECURITY_IPSEC_SA_DIR_INGRESS,
 852                         .options = { 0 },
 853                 },
 854                 .crypto_capabilities = NULL,
 855         },
 856         {       /* IPsec Lookaside Protocol ESP Transport Egress */
 857                 .action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
 858                 .protocol = RTE_SECURITY_PROTOCOL_IPSEC,
 859                 .ipsec = {
 860                         .proto = RTE_SECURITY_IPSEC_SA_PROTO_ESP,
 861                         .mode = RTE_SECURITY_IPSEC_SA_MODE_TRANSPORT,
 862                         .direction = RTE_SECURITY_IPSEC_SA_DIR_EGRESS,
 863                         .options = { 0 },
 864                 },
 865                 .crypto_capabilities = NULL,
 866         },
 867         {
 868                 .action = RTE_SECURITY_ACTION_TYPE_NONE
 869         }
 870 };
 871
 872 static void
 873 cpt_caps_add(struct rte_cryptodev_capabilities cnxk_caps[], int *cur_pos,
 874              const struct rte_cryptodev_capabilities *caps, int nb_caps)
 875 {
 876         if (*cur_pos + nb_caps > CNXK_CPT_MAX_CAPS)
 877                 return;
 878
 879         memcpy(&cnxk_caps[*cur_pos], caps, nb_caps * sizeof(caps[0]));
 880         *cur_pos += nb_caps;
 881 }
 882
 883 static void
 884 cn10k_crypto_caps_update(struct rte_cryptodev_capabilities cnxk_caps[])
 885 {
 886
 887         struct rte_cryptodev_capabilities *caps;
 888         int i = 0;
 889
 890         while ((caps = &cnxk_caps[i++])->op != RTE_CRYPTO_OP_TYPE_UNDEFINED) {
 891                 if ((caps->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC) &&
 892                     (caps->sym.xform_type == RTE_CRYPTO_SYM_XFORM_CIPHER) &&
 893                     (caps->sym.cipher.algo == RTE_CRYPTO_CIPHER_ZUC_EEA3)) {
 894
 895                         caps->sym.cipher.key_size.max = 32;
 896                         caps->sym.cipher.key_size.increment = 16;
 897                         caps->sym.cipher.iv_size.max = 25;
 898                         caps->sym.cipher.iv_size.increment = 1;
 899                 }
 900
 901                 if ((caps->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC) &&
 902                     (caps->sym.xform_type == RTE_CRYPTO_SYM_XFORM_AUTH) &&
 903                     (caps->sym.auth.algo == RTE_CRYPTO_AUTH_ZUC_EIA3)) {
 904
 905                         caps->sym.auth.key_size.max = 32;
 906                         caps->sym.auth.key_size.increment = 16;
 907                         caps->sym.auth.digest_size.max = 16;
 908                         caps->sym.auth.digest_size.increment = 4;
 909                         caps->sym.auth.iv_size.max = 25;
 910                         caps->sym.auth.iv_size.increment = 1;
 911                 }
 912         }
 913 }
 914
 915 static void
 916 crypto_caps_populate(struct rte_cryptodev_capabilities cnxk_caps[],
 917                      union cpt_eng_caps *hw_caps)
 918 {
 919         int cur_pos = 0;
 920
 921         CPT_CAPS_ADD(cnxk_caps, &cur_pos, hw_caps, mul);
 922         CPT_CAPS_ADD(cnxk_caps, &cur_pos, hw_caps, sha1_sha2);
 923         CPT_CAPS_ADD(cnxk_caps, &cur_pos, hw_caps, chacha20);
 924         CPT_CAPS_ADD(cnxk_caps, &cur_pos, hw_caps, zuc_snow3g);
 925         CPT_CAPS_ADD(cnxk_caps, &cur_pos, hw_caps, aes);
 926         CPT_CAPS_ADD(cnxk_caps, &cur_pos, hw_caps, kasumi);
 927         CPT_CAPS_ADD(cnxk_caps, &cur_pos, hw_caps, des);
 928
 929         cpt_caps_add(cnxk_caps, &cur_pos, caps_null, RTE_DIM(caps_null));
 930         cpt_caps_add(cnxk_caps, &cur_pos, caps_end, RTE_DIM(caps_end));
 931
 932         if (roc_model_is_cn10k())
 933                 cn10k_crypto_caps_update(cnxk_caps);
 934 }
 935
 936 const struct rte_cryptodev_capabilities *
 937 cnxk_crypto_capabilities_get(struct cnxk_cpt_vf *vf)
 938 {
 939         return vf->crypto_caps;
 940 }
 941
 942 static void
 943 sec_caps_add(struct rte_cryptodev_capabilities cnxk_caps[], int *cur_pos,
 944              const struct rte_cryptodev_capabilities *caps, int nb_caps)
 945 {
 946         if (*cur_pos + nb_caps > CNXK_SEC_CRYPTO_MAX_CAPS) {
 947                 rte_panic("Could not add sec crypto caps");
 948                 return;
 949         }
 950
 951         memcpy(&cnxk_caps[*cur_pos], caps, nb_caps * sizeof(caps[0]));
 952         *cur_pos += nb_caps;
 953 }
 954
 955 static void
 956 cn10k_sec_crypto_caps_update(struct rte_cryptodev_capabilities cnxk_caps[],
 957                              int *cur_pos)
 958 {
 959         const struct rte_cryptodev_capabilities *cap;
 960         unsigned int i;
 961
 962         if ((CNXK_SEC_CRYPTO_MAX_CAPS - *cur_pos) < 1) {
 963                 rte_panic("Could not add sec crypto caps");
 964                 return;
 965         }
 966
 967         /* NULL auth */
 968         for (i = 0; i < RTE_DIM(caps_null); i++) {
 969                 cap = &caps_null[i];
 970                 if (cap->sym.xform_type == RTE_CRYPTO_SYM_XFORM_AUTH &&
 971                     cap->sym.auth.algo == RTE_CRYPTO_AUTH_NULL) {
 972                         cnxk_caps[*cur_pos] = caps_null[i];
 973                         *cur_pos += 1;
 974                 }
 975         }
 976 }
 977
 978 static void
 979 cn9k_sec_crypto_caps_update(struct rte_cryptodev_capabilities cnxk_caps[])
 980 {
 981
 982         struct rte_cryptodev_capabilities *caps;
 983         int i = 0;
 984
 985         while ((caps = &cnxk_caps[i++])->op != RTE_CRYPTO_OP_TYPE_UNDEFINED) {
 986                 if ((caps->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC) &&
 987                     (caps->sym.xform_type == RTE_CRYPTO_SYM_XFORM_AUTH) &&
 988                     (caps->sym.auth.algo == RTE_CRYPTO_AUTH_SHA256_HMAC)) {
 989                         caps->sym.auth.key_size.min = 32;
 990                         caps->sym.auth.key_size.max = 64;
 991                         caps->sym.auth.key_size.increment = 1;
 992
 993                         break;
 994                 }
 995         }
 996 }
 997
 998 static void
 999 sec_crypto_caps_populate(struct rte_cryptodev_capabilities cnxk_caps[],
1000                          union cpt_eng_caps *hw_caps)
1001 {
1002         int cur_pos = 0;
1003
1004         SEC_CAPS_ADD(cnxk_caps, &cur_pos, hw_caps, aes);
1005         SEC_CAPS_ADD(cnxk_caps, &cur_pos, hw_caps, sha1_sha2);
1006
1007         if (roc_model_is_cn10k())
1008                 cn10k_sec_crypto_caps_update(cnxk_caps, &cur_pos);
1009         else
1010                 cn9k_sec_crypto_caps_update(cnxk_caps);
1011
1012         sec_caps_add(cnxk_caps, &cur_pos, caps_end, RTE_DIM(caps_end));
1013 }
1014
1015 static void
1016 cnxk_sec_caps_update(struct rte_security_capability *sec_cap)
1017 {
1018         sec_cap->ipsec.options.udp_encap = 1;
1019 }
1020
1021 static void
1022 cn10k_sec_caps_update(struct rte_security_capability *sec_cap)
1023 {
1024         if (sec_cap->ipsec.direction == RTE_SECURITY_IPSEC_SA_DIR_EGRESS) {
1025 #ifdef LA_IPSEC_DEBUG
1026                 sec_cap->ipsec.options.iv_gen_disable = 1;
1027 #endif
1028         } else {
1029                 sec_cap->ipsec.options.udp_ports_verify = 1;
1030                 if (sec_cap->ipsec.mode == RTE_SECURITY_IPSEC_SA_MODE_TUNNEL)
1031                         sec_cap->ipsec.options.tunnel_hdr_verify =
1032                                 RTE_SECURITY_IPSEC_TUNNEL_VERIFY_SRC_DST_ADDR;
1033         }
1034         sec_cap->ipsec.options.ip_csum_enable = 1;
1035         sec_cap->ipsec.options.l4_csum_enable = 1;
1036 }
1037
1038 static void
1039 cn9k_sec_caps_update(struct rte_security_capability *sec_cap)
1040 {
1041         if (sec_cap->ipsec.direction == RTE_SECURITY_IPSEC_SA_DIR_EGRESS) {
1042                 sec_cap->ipsec.options.iv_gen_disable = 1;
1043         }
1044 }
1045
1046 void
1047 cnxk_cpt_caps_populate(struct cnxk_cpt_vf *vf)
1048 {
1049         unsigned long i;
1050
1051         crypto_caps_populate(vf->crypto_caps, vf->cpt.hw_caps);
1052         sec_crypto_caps_populate(vf->sec_crypto_caps, vf->cpt.hw_caps);
1053
1054         PLT_STATIC_ASSERT(RTE_DIM(sec_caps_templ) <= RTE_DIM(vf->sec_caps));
1055         memcpy(vf->sec_caps, sec_caps_templ, sizeof(sec_caps_templ));
1056
1057         for (i = 0; i < RTE_DIM(sec_caps_templ) - 1; i++) {
1058                 vf->sec_caps[i].crypto_capabilities = vf->sec_crypto_caps;
1059
1060                 cnxk_sec_caps_update(&vf->sec_caps[i]);
1061
1062                 if (roc_model_is_cn10k())
1063                         cn10k_sec_caps_update(&vf->sec_caps[i]);
1064
1065                 if (roc_model_is_cn9k())
1066                         cn9k_sec_caps_update(&vf->sec_caps[i]);
1067
1068         }
1069 }
1070
1071 const struct rte_security_capability *
1072 cnxk_crypto_sec_capabilities_get(void *device)
1073 {
1074         struct rte_cryptodev *dev = device;
1075         struct cnxk_cpt_vf *vf;
1076
1077         vf = dev->data->dev_private;
1078         return vf->sec_caps;
1079 }