drivers/crypto/octeontx2/otx2_cryptodev_capabilities.c

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