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         {       /* AES CMAC */
 572                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 573                 {.sym = {
 574                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 575                         {.auth = {
 576                                 .algo = RTE_CRYPTO_AUTH_AES_CMAC,
 577                                 .block_size = 16,
 578                                 .key_size = {
 579                                         .min = 16,
 580                                         .max = 32,
 581                                         .increment = 8
 582                                 },
 583                                 .digest_size = {
 584                                         .min = 4,
 585                                         .max = 4,
 586                                         .increment = 0
 587                                 },
 588                         }, }
 589                 }, }
 590         },
 591 };
 592
 593 static const struct rte_cryptodev_capabilities caps_kasumi[] = {
 594         {       /* KASUMI (F8) */
 595                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 596                 {.sym = {
 597                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 598                         {.cipher = {
 599                                 .algo = RTE_CRYPTO_CIPHER_KASUMI_F8,
 600                                 .block_size = 8,
 601                                 .key_size = {
 602                                         .min = 16,
 603                                         .max = 16,
 604                                         .increment = 0
 605                                 },
 606                                 .iv_size = {
 607                                         .min = 8,
 608                                         .max = 8,
 609                                         .increment = 0
 610                                 }
 611                         }, }
 612                 }, }
 613         },
 614         {       /* KASUMI (F9) */
 615                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 616                 {.sym = {
 617                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 618                         {.auth = {
 619                                 .algo = RTE_CRYPTO_AUTH_KASUMI_F9,
 620                                 .block_size = 8,
 621                                 .key_size = {
 622                                         .min = 16,
 623                                         .max = 16,
 624                                         .increment = 0
 625                                 },
 626                                 .digest_size = {
 627                                         .min = 4,
 628                                         .max = 4,
 629                                         .increment = 0
 630                                 },
 631                         }, }
 632                 }, }
 633         },
 634 };
 635
 636 static const struct rte_cryptodev_capabilities caps_des[] = {
 637         {       /* 3DES CBC */
 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_CBC,
 643                                 .block_size = 8,
 644                                 .key_size = {
 645                                         .min = 24,
 646                                         .max = 24,
 647                                         .increment = 0
 648                                 },
 649                                 .iv_size = {
 650                                         .min = 8,
 651                                         .max = 16,
 652                                         .increment = 8
 653                                 }
 654                         }, }
 655                 }, }
 656         },
 657         {       /* 3DES ECB */
 658                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 659                 {.sym = {
 660                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 661                         {.cipher = {
 662                                 .algo = RTE_CRYPTO_CIPHER_3DES_ECB,
 663                                 .block_size = 8,
 664                                 .key_size = {
 665                                         .min = 24,
 666                                         .max = 24,
 667                                         .increment = 0
 668                                 },
 669                                 .iv_size = {
 670                                         .min = 0,
 671                                         .max = 0,
 672                                         .increment = 0
 673                                 }
 674                         }, }
 675                 }, }
 676         },
 677         {       /* DES CBC */
 678                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 679                 {.sym = {
 680                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 681                         {.cipher = {
 682                                 .algo = RTE_CRYPTO_CIPHER_DES_CBC,
 683                                 .block_size = 8,
 684                                 .key_size = {
 685                                         .min = 8,
 686                                         .max = 8,
 687                                         .increment = 0
 688                                 },
 689                                 .iv_size = {
 690                                         .min = 8,
 691                                         .max = 8,
 692                                         .increment = 0
 693                                 }
 694                         }, }
 695                 }, }
 696         },
 697 };
 698
 699 static const struct rte_cryptodev_capabilities caps_null[] = {
 700         {       /* NULL (AUTH) */
 701                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 702                 {.sym = {
 703                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 704                         {.auth = {
 705                                 .algo = RTE_CRYPTO_AUTH_NULL,
 706                                 .block_size = 1,
 707                                 .key_size = {
 708                                         .min = 0,
 709                                         .max = 0,
 710                                         .increment = 0
 711                                 },
 712                                 .digest_size = {
 713                                         .min = 0,
 714                                         .max = 0,
 715                                         .increment = 0
 716                                 },
 717                         }, },
 718                 }, },
 719         },
 720         {       /* NULL (CIPHER) */
 721                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 722                 {.sym = {
 723                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 724                         {.cipher = {
 725                                 .algo = RTE_CRYPTO_CIPHER_NULL,
 726                                 .block_size = 1,
 727                                 .key_size = {
 728                                         .min = 0,
 729                                         .max = 0,
 730                                         .increment = 0
 731                                 },
 732                                 .iv_size = {
 733                                         .min = 0,
 734                                         .max = 0,
 735                                         .increment = 0
 736                                 }
 737                         }, },
 738                 }, }
 739         },
 740 };
 741
 742 static const struct rte_cryptodev_capabilities caps_end[] = {
 743         RTE_CRYPTODEV_END_OF_CAPABILITIES_LIST()
 744 };
 745
 746 static const struct rte_cryptodev_capabilities sec_caps_aes[] = {
 747         {       /* AES GCM */
 748                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 749                 {.sym = {
 750                         .xform_type = RTE_CRYPTO_SYM_XFORM_AEAD,
 751                         {.aead = {
 752                                 .algo = RTE_CRYPTO_AEAD_AES_GCM,
 753                                 .block_size = 16,
 754                                 .key_size = {
 755                                         .min = 16,
 756                                         .max = 32,
 757                                         .increment = 8
 758                                 },
 759                                 .digest_size = {
 760                                         .min = 16,
 761                                         .max = 16,
 762                                         .increment = 0
 763                                 },
 764                                 .aad_size = {
 765                                         .min = 8,
 766                                         .max = 12,
 767                                         .increment = 4
 768                                 },
 769                                 .iv_size = {
 770                                         .min = 12,
 771                                         .max = 12,
 772                                         .increment = 0
 773                                 }
 774                         }, }
 775                 }, }
 776         },
 777         {       /* AES CTR */
 778                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 779                 {.sym = {
 780                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 781                         {.cipher = {
 782                                 .algo = RTE_CRYPTO_CIPHER_AES_CTR,
 783                                 .block_size = 16,
 784                                 .key_size = {
 785                                         .min = 16,
 786                                         .max = 32,
 787                                         .increment = 8
 788                                 },
 789                                 .iv_size = {
 790                                         .min = 12,
 791                                         .max = 16,
 792                                         .increment = 4
 793                                 }
 794                         }, }
 795                 }, }
 796         },
 797         {       /* AES CBC */
 798                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 799                 {.sym = {
 800                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 801                         {.cipher = {
 802                                 .algo = RTE_CRYPTO_CIPHER_AES_CBC,
 803                                 .block_size = 16,
 804                                 .key_size = {
 805                                         .min = 16,
 806                                         .max = 32,
 807                                         .increment = 8
 808                                 },
 809                                 .iv_size = {
 810                                         .min = 16,
 811                                         .max = 16,
 812                                         .increment = 0
 813                                 }
 814                         }, }
 815                 }, }
 816         },
 817         {       /* AES-XCBC */
 818                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 819                 { .sym = {
 820                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 821                         {.auth = {
 822                                 .algo = RTE_CRYPTO_AUTH_AES_XCBC_MAC,
 823                                 .block_size = 16,
 824                                 .key_size = {
 825                                         .min = 16,
 826                                         .max = 16,
 827                                         .increment = 0
 828                                 },
 829                                 .digest_size = {
 830                                         .min = 12,
 831                                         .max = 12,
 832                                         .increment = 0,
 833                                 },
 834                         }, }
 835                 }, }
 836         },
 837 };
 838
 839 static const struct rte_cryptodev_capabilities sec_caps_sha1_sha2[] = {
 840         {       /* SHA1 HMAC */
 841                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 842                 {.sym = {
 843                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 844                         {.auth = {
 845                                 .algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
 846                                 .block_size = 64,
 847                                 .key_size = {
 848                                         .min = 20,
 849                                         .max = 64,
 850                                         .increment = 1
 851                                 },
 852                                 .digest_size = {
 853                                         .min = 12,
 854                                         .max = 12,
 855                                         .increment = 0
 856                                 },
 857                         }, }
 858                 }, }
 859         },
 860         {       /* SHA256 HMAC */
 861                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 862                 {.sym = {
 863                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 864                         {.auth = {
 865                                 .algo = RTE_CRYPTO_AUTH_SHA256_HMAC,
 866                                 .block_size = 64,
 867                                 .key_size = {
 868                                         .min = 1,
 869                                         .max = 1024,
 870                                         .increment = 1
 871                                 },
 872                                 .digest_size = {
 873                                         .min = 16,
 874                                         .max = 16,
 875                                         .increment = 0
 876                                 },
 877                         }, }
 878                 }, }
 879         },
 880         {       /* SHA384 HMAC */
 881                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 882                 {.sym = {
 883                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 884                         {.auth = {
 885                                 .algo = RTE_CRYPTO_AUTH_SHA384_HMAC,
 886                                 .block_size = 64,
 887                                 .key_size = {
 888                                         .min = 48,
 889                                         .max = 48,
 890                                         .increment = 0
 891                                 },
 892                                 .digest_size = {
 893                                         .min = 24,
 894                                         .max = 24,
 895                                         .increment = 0
 896                                         },
 897                         }, }
 898                 }, }
 899         },
 900         {       /* SHA512 HMAC */
 901                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 902                 {.sym = {
 903                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 904                         {.auth = {
 905                                 .algo = RTE_CRYPTO_AUTH_SHA512_HMAC,
 906                                 .block_size = 128,
 907                                 .key_size = {
 908                                         .min = 64,
 909                                         .max = 64,
 910                                         .increment = 0
 911                                 },
 912                                 .digest_size = {
 913                                         .min = 32,
 914                                         .max = 32,
 915                                         .increment = 0
 916                                 },
 917                         }, }
 918                 }, }
 919         },
 920 };
 921
 922 static const struct rte_cryptodev_capabilities sec_caps_null[] = {
 923         {       /* NULL (CIPHER) */
 924                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 925                 {.sym = {
 926                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 927                         {.cipher = {
 928                                 .algo = RTE_CRYPTO_CIPHER_NULL,
 929                                 .block_size = 1,
 930                                 .key_size = {
 931                                         .min = 0,
 932                                         .max = 0,
 933                                         .increment = 0
 934                                 },
 935                                 .iv_size = {
 936                                         .min = 0,
 937                                         .max = 0,
 938                                         .increment = 0
 939                                 }
 940                         }, },
 941                 }, }
 942         },
 943 };
 944
 945 static const struct rte_security_capability sec_caps_templ[] = {
 946         {       /* IPsec Lookaside Protocol ESP Tunnel Ingress */
 947                 .action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
 948                 .protocol = RTE_SECURITY_PROTOCOL_IPSEC,
 949                 .ipsec = {
 950                         .proto = RTE_SECURITY_IPSEC_SA_PROTO_ESP,
 951                         .mode = RTE_SECURITY_IPSEC_SA_MODE_TUNNEL,
 952                         .direction = RTE_SECURITY_IPSEC_SA_DIR_INGRESS,
 953                         .options = { 0 },
 954                 },
 955                 .crypto_capabilities = NULL,
 956         },
 957         {       /* IPsec Lookaside Protocol ESP Tunnel Egress */
 958                 .action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
 959                 .protocol = RTE_SECURITY_PROTOCOL_IPSEC,
 960                 .ipsec = {
 961                         .proto = RTE_SECURITY_IPSEC_SA_PROTO_ESP,
 962                         .mode = RTE_SECURITY_IPSEC_SA_MODE_TUNNEL,
 963                         .direction = RTE_SECURITY_IPSEC_SA_DIR_EGRESS,
 964                         .options = { 0 },
 965                 },
 966                 .crypto_capabilities = NULL,
 967         },
 968         {       /* IPsec Lookaside Protocol ESP Transport Ingress */
 969                 .action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
 970                 .protocol = RTE_SECURITY_PROTOCOL_IPSEC,
 971                 .ipsec = {
 972                         .proto = RTE_SECURITY_IPSEC_SA_PROTO_ESP,
 973                         .mode = RTE_SECURITY_IPSEC_SA_MODE_TRANSPORT,
 974                         .direction = RTE_SECURITY_IPSEC_SA_DIR_INGRESS,
 975                         .options = { 0 },
 976                 },
 977                 .crypto_capabilities = NULL,
 978         },
 979         {       /* IPsec Lookaside Protocol ESP Transport Egress */
 980                 .action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
 981                 .protocol = RTE_SECURITY_PROTOCOL_IPSEC,
 982                 .ipsec = {
 983                         .proto = RTE_SECURITY_IPSEC_SA_PROTO_ESP,
 984                         .mode = RTE_SECURITY_IPSEC_SA_MODE_TRANSPORT,
 985                         .direction = RTE_SECURITY_IPSEC_SA_DIR_EGRESS,
 986                         .options = { 0 },
 987                 },
 988                 .crypto_capabilities = NULL,
 989         },
 990         {
 991                 .action = RTE_SECURITY_ACTION_TYPE_NONE
 992         }
 993 };
 994
 995 static void
 996 cpt_caps_add(struct rte_cryptodev_capabilities cnxk_caps[], int *cur_pos,
 997              const struct rte_cryptodev_capabilities *caps, int nb_caps)
 998 {
 999         if (*cur_pos + nb_caps > CNXK_CPT_MAX_CAPS)
1000                 return;
1001
1002         memcpy(&cnxk_caps[*cur_pos], caps, nb_caps * sizeof(caps[0]));
1003         *cur_pos += nb_caps;
1004 }
1005
1006 static void
1007 cn10k_crypto_caps_update(struct rte_cryptodev_capabilities cnxk_caps[])
1008 {
1009
1010         struct rte_cryptodev_capabilities *caps;
1011         int i = 0;
1012
1013         while ((caps = &cnxk_caps[i++])->op != RTE_CRYPTO_OP_TYPE_UNDEFINED) {
1014                 if ((caps->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC) &&
1015                     (caps->sym.xform_type == RTE_CRYPTO_SYM_XFORM_CIPHER) &&
1016                     (caps->sym.cipher.algo == RTE_CRYPTO_CIPHER_ZUC_EEA3)) {
1017
1018                         caps->sym.cipher.key_size.max = 32;
1019                         caps->sym.cipher.key_size.increment = 16;
1020                         caps->sym.cipher.iv_size.max = 25;
1021                         caps->sym.cipher.iv_size.increment = 1;
1022                 }
1023
1024                 if ((caps->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC) &&
1025                     (caps->sym.xform_type == RTE_CRYPTO_SYM_XFORM_AUTH) &&
1026                     (caps->sym.auth.algo == RTE_CRYPTO_AUTH_ZUC_EIA3)) {
1027
1028                         caps->sym.auth.key_size.max = 32;
1029                         caps->sym.auth.key_size.increment = 16;
1030                         caps->sym.auth.digest_size.max = 16;
1031                         caps->sym.auth.digest_size.increment = 4;
1032                         caps->sym.auth.iv_size.max = 25;
1033                         caps->sym.auth.iv_size.increment = 1;
1034                 }
1035         }
1036 }
1037
1038 static void
1039 crypto_caps_populate(struct rte_cryptodev_capabilities cnxk_caps[],
1040                      union cpt_eng_caps *hw_caps)
1041 {
1042         int cur_pos = 0;
1043
1044         CPT_CAPS_ADD(cnxk_caps, &cur_pos, hw_caps, mul);
1045         CPT_CAPS_ADD(cnxk_caps, &cur_pos, hw_caps, sha1_sha2);
1046         CPT_CAPS_ADD(cnxk_caps, &cur_pos, hw_caps, chacha20);
1047         CPT_CAPS_ADD(cnxk_caps, &cur_pos, hw_caps, zuc_snow3g);
1048         CPT_CAPS_ADD(cnxk_caps, &cur_pos, hw_caps, aes);
1049         CPT_CAPS_ADD(cnxk_caps, &cur_pos, hw_caps, kasumi);
1050         CPT_CAPS_ADD(cnxk_caps, &cur_pos, hw_caps, des);
1051
1052         cpt_caps_add(cnxk_caps, &cur_pos, caps_null, RTE_DIM(caps_null));
1053         cpt_caps_add(cnxk_caps, &cur_pos, caps_end, RTE_DIM(caps_end));
1054
1055         if (roc_model_is_cn10k())
1056                 cn10k_crypto_caps_update(cnxk_caps);
1057 }
1058
1059 const struct rte_cryptodev_capabilities *
1060 cnxk_crypto_capabilities_get(struct cnxk_cpt_vf *vf)
1061 {
1062         return vf->crypto_caps;
1063 }
1064
1065 static void
1066 sec_caps_add(struct rte_cryptodev_capabilities cnxk_caps[], int *cur_pos,
1067              const struct rte_cryptodev_capabilities *caps, int nb_caps)
1068 {
1069         if (*cur_pos + nb_caps > CNXK_SEC_CRYPTO_MAX_CAPS) {
1070                 rte_panic("Could not add sec crypto caps");
1071                 return;
1072         }
1073
1074         memcpy(&cnxk_caps[*cur_pos], caps, nb_caps * sizeof(caps[0]));
1075         *cur_pos += nb_caps;
1076 }
1077
1078 static void
1079 cn10k_sec_crypto_caps_update(struct rte_cryptodev_capabilities cnxk_caps[],
1080                              int *cur_pos)
1081 {
1082         const struct rte_cryptodev_capabilities *cap;
1083         unsigned int i;
1084
1085         if ((CNXK_SEC_CRYPTO_MAX_CAPS - *cur_pos) < 1) {
1086                 rte_panic("Could not add sec crypto caps");
1087                 return;
1088         }
1089
1090         /* NULL auth */
1091         for (i = 0; i < RTE_DIM(caps_null); i++) {
1092                 cap = &caps_null[i];
1093                 if (cap->sym.xform_type == RTE_CRYPTO_SYM_XFORM_AUTH &&
1094                     cap->sym.auth.algo == RTE_CRYPTO_AUTH_NULL) {
1095                         cnxk_caps[*cur_pos] = caps_null[i];
1096                         *cur_pos += 1;
1097                 }
1098         }
1099 }
1100
1101 static void
1102 cn9k_sec_crypto_caps_update(struct rte_cryptodev_capabilities cnxk_caps[])
1103 {
1104
1105         struct rte_cryptodev_capabilities *caps;
1106         int i = 0;
1107
1108         while ((caps = &cnxk_caps[i++])->op != RTE_CRYPTO_OP_TYPE_UNDEFINED) {
1109                 if ((caps->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC) &&
1110                     (caps->sym.xform_type == RTE_CRYPTO_SYM_XFORM_AUTH) &&
1111                     (caps->sym.auth.algo == RTE_CRYPTO_AUTH_SHA256_HMAC)) {
1112                         caps->sym.auth.key_size.min = 32;
1113                         caps->sym.auth.key_size.max = 64;
1114                         caps->sym.auth.key_size.increment = 1;
1115
1116                         break;
1117                 }
1118         }
1119 }
1120
1121 static void
1122 sec_crypto_caps_populate(struct rte_cryptodev_capabilities cnxk_caps[],
1123                          union cpt_eng_caps *hw_caps)
1124 {
1125         int cur_pos = 0;
1126
1127         SEC_CAPS_ADD(cnxk_caps, &cur_pos, hw_caps, aes);
1128         SEC_CAPS_ADD(cnxk_caps, &cur_pos, hw_caps, sha1_sha2);
1129
1130         if (roc_model_is_cn10k())
1131                 cn10k_sec_crypto_caps_update(cnxk_caps, &cur_pos);
1132         else
1133                 cn9k_sec_crypto_caps_update(cnxk_caps);
1134
1135         sec_caps_add(cnxk_caps, &cur_pos, sec_caps_null,
1136                      RTE_DIM(sec_caps_null));
1137         sec_caps_add(cnxk_caps, &cur_pos, caps_end, RTE_DIM(caps_end));
1138 }
1139
1140 static void
1141 cnxk_sec_caps_update(struct rte_security_capability *sec_cap)
1142 {
1143         sec_cap->ipsec.options.udp_encap = 1;
1144         sec_cap->ipsec.options.copy_df = 1;
1145 }
1146
1147 static void
1148 cn10k_sec_caps_update(struct rte_security_capability *sec_cap)
1149 {
1150         if (sec_cap->ipsec.direction == RTE_SECURITY_IPSEC_SA_DIR_EGRESS) {
1151 #ifdef LA_IPSEC_DEBUG
1152                 sec_cap->ipsec.options.iv_gen_disable = 1;
1153 #endif
1154         } else {
1155                 sec_cap->ipsec.options.udp_ports_verify = 1;
1156                 if (sec_cap->ipsec.mode == RTE_SECURITY_IPSEC_SA_MODE_TUNNEL)
1157                         sec_cap->ipsec.options.tunnel_hdr_verify =
1158                                 RTE_SECURITY_IPSEC_TUNNEL_VERIFY_SRC_DST_ADDR;
1159         }
1160         sec_cap->ipsec.options.ip_csum_enable = 1;
1161         sec_cap->ipsec.options.l4_csum_enable = 1;
1162         sec_cap->ipsec.options.stats = 1;
1163 }
1164
1165 static void
1166 cn9k_sec_caps_update(struct rte_security_capability *sec_cap)
1167 {
1168         if (sec_cap->ipsec.direction == RTE_SECURITY_IPSEC_SA_DIR_EGRESS) {
1169                 sec_cap->ipsec.options.iv_gen_disable = 1;
1170         }
1171 }
1172
1173 void
1174 cnxk_cpt_caps_populate(struct cnxk_cpt_vf *vf)
1175 {
1176         unsigned long i;
1177
1178         crypto_caps_populate(vf->crypto_caps, vf->cpt.hw_caps);
1179         sec_crypto_caps_populate(vf->sec_crypto_caps, vf->cpt.hw_caps);
1180
1181         PLT_STATIC_ASSERT(RTE_DIM(sec_caps_templ) <= RTE_DIM(vf->sec_caps));
1182         memcpy(vf->sec_caps, sec_caps_templ, sizeof(sec_caps_templ));
1183
1184         for (i = 0; i < RTE_DIM(sec_caps_templ) - 1; i++) {
1185                 vf->sec_caps[i].crypto_capabilities = vf->sec_crypto_caps;
1186
1187                 cnxk_sec_caps_update(&vf->sec_caps[i]);
1188
1189                 if (roc_model_is_cn10k())
1190                         cn10k_sec_caps_update(&vf->sec_caps[i]);
1191
1192                 if (roc_model_is_cn9k())
1193                         cn9k_sec_caps_update(&vf->sec_caps[i]);
1194
1195         }
1196 }
1197
1198 const struct rte_security_capability *
1199 cnxk_crypto_sec_capabilities_get(void *device)
1200 {
1201         struct rte_cryptodev *dev = device;
1202         struct cnxk_cpt_vf *vf;
1203
1204         vf = dev->data->dev_private;
1205         return vf->sec_caps;
1206 }