drivers/crypto/dpaa2_sec/dpaa2_sec_priv.h

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  *
   3  *   Copyright (c) 2016 Freescale Semiconductor, Inc. All rights reserved.
   4  *   Copyright 2016,2020-2021 NXP
   5  *
   6  */
   7
   8 #ifndef _DPAA2_SEC_PMD_PRIVATE_H_
   9 #define _DPAA2_SEC_PMD_PRIVATE_H_
  10
  11 #ifdef RTE_LIB_SECURITY
  12 #include <rte_security_driver.h>
  13 #endif
  14
  15 #define CRYPTODEV_NAME_DPAA2_SEC_PMD    crypto_dpaa2_sec
  16 /**< NXP DPAA2 - SEC PMD device name */
  17
  18 extern uint8_t cryptodev_driver_id;
  19
  20 /* FLE_POOL_NUM_BUFS is set as per the ipsec-secgw application */
  21 #define FLE_POOL_NUM_BUFS       32000
  22 #define FLE_POOL_BUF_SIZE       256
  23 #define FLE_POOL_CACHE_SIZE     512
  24 #define FLE_SG_MEM_SIZE(num)    (FLE_POOL_BUF_SIZE + ((num) * 32))
  25 #define SEC_FLC_DHR_OUTBOUND    -114
  26 #define SEC_FLC_DHR_INBOUND     0
  27
  28 #define MAX_QUEUES              64
  29 #define MAX_DESC_SIZE           64
  30 /** private data structure for each DPAA2_SEC device */
  31 struct dpaa2_sec_dev_private {
  32         void *mc_portal; /**< MC Portal for configuring this device */
  33         void *hw; /**< Hardware handle for this device.Used by NADK framework */
  34         struct rte_mempool *fle_pool; /* per device memory pool for FLE */
  35         int32_t hw_id; /**< An unique ID of this device instance */
  36         int32_t vfio_fd; /**< File descriptor received via VFIO */
  37         uint16_t token; /**< Token required by DPxxx objects */
  38         unsigned int max_nb_queue_pairs;
  39         /**< Max number of queue pairs supported by device */
  40 };
  41
  42 struct dpaa2_sec_qp {
  43         struct dpaa2_queue rx_vq;
  44         struct dpaa2_queue tx_vq;
  45 };
  46
  47 enum shr_desc_type {
  48         DESC_UPDATE,
  49         DESC_FINAL,
  50         DESC_INITFINAL,
  51 };
  52
  53 #define DIR_ENC                 1
  54 #define DIR_DEC                 0
  55
  56 #define DPAA2_IPv6_DEFAULT_VTC_FLOW     0x60000000
  57
  58 #define DPAA2_SET_FLC_EWS(flc)  (flc->word1_bits23_16 |= 0x1)
  59 #define DPAA2_SET_FLC_RSC(flc)  (flc->word1_bits31_24 |= 0x1)
  60 #define DPAA2_SET_FLC_REUSE_BS(flc) (flc->mode_bits |= 0x8000)
  61 #define DPAA2_SET_FLC_REUSE_FF(flc) (flc->mode_bits |= 0x2000)
  62
  63 /* SEC Flow Context Descriptor */
  64 struct sec_flow_context {
  65         /* word 0 */
  66         uint16_t word0_sdid;            /* 11-0  SDID */
  67         uint16_t word0_res;             /* 31-12 reserved */
  68
  69         /* word 1 */
  70         uint8_t word1_sdl;              /* 5-0 SDL */
  71                                         /* 7-6 reserved */
  72
  73         uint8_t word1_bits_15_8;        /* 11-8 CRID */
  74                                         /* 14-12 reserved */
  75                                         /* 15 CRJD */
  76
  77         uint8_t word1_bits23_16;        /* 16  EWS */
  78                                         /* 17 DAC */
  79                                         /* 18,19,20 ? */
  80                                         /* 23-21 reserved */
  81
  82         uint8_t word1_bits31_24;        /* 24 RSC */
  83                                         /* 25 RBMT */
  84                                         /* 31-26 reserved */
  85
  86         /* word 2  RFLC[31-0] */
  87         uint32_t word2_rflc_31_0;
  88
  89         /* word 3  RFLC[63-32] */
  90         uint32_t word3_rflc_63_32;
  91
  92         /* word 4 */
  93         uint16_t word4_iicid;           /* 15-0  IICID */
  94         uint16_t word4_oicid;           /* 31-16 OICID */
  95
  96         /* word 5 */
  97         uint32_t word5_ofqid:24;                /* 23-0 OFQID */
  98         uint32_t word5_31_24:8;
  99                                         /* 24 OSC */
 100                                         /* 25 OBMT */
 101                                         /* 29-26 reserved */
 102                                         /* 31-30 ICR */
 103
 104         /* word 6 */
 105         uint32_t word6_oflc_31_0;
 106
 107         /* word 7 */
 108         uint32_t word7_oflc_63_32;
 109
 110         /* Word 8-15 storage profiles */
 111         uint16_t dl;                    /**<  DataLength(correction) */
 112         uint16_t reserved;              /**< reserved */
 113         uint16_t dhr;                   /**< DataHeadRoom(correction) */
 114         uint16_t mode_bits;             /**< mode bits */
 115         uint16_t bpv0;                  /**< buffer pool0 valid */
 116         uint16_t bpid0;                 /**< Bypass Memory Translation */
 117         uint16_t bpv1;                  /**< buffer pool1 valid */
 118         uint16_t bpid1;                 /**< Bypass Memory Translation */
 119         uint64_t word_12_15[2];         /**< word 12-15 are reserved */
 120 };
 121
 122 struct sec_flc_desc {
 123         struct sec_flow_context flc;
 124         uint32_t desc[MAX_DESC_SIZE];
 125 };
 126
 127 struct ctxt_priv {
 128         struct rte_mempool *fle_pool; /* per device memory pool for FLE */
 129         struct sec_flc_desc flc_desc[0];
 130 };
 131
 132 enum dpaa2_sec_op_type {
 133         DPAA2_SEC_NONE,  /*!< No Cipher operations*/
 134         DPAA2_SEC_CIPHER,/*!< CIPHER operations */
 135         DPAA2_SEC_AUTH,  /*!< Authentication Operations */
 136         DPAA2_SEC_AEAD,  /*!< AEAD (AES-GCM/CCM) type operations */
 137         DPAA2_SEC_CIPHER_HASH,  /*!< Authenticated Encryption with
 138                                  * associated data
 139                                  */
 140         DPAA2_SEC_HASH_CIPHER,  /*!< Encryption with Authenticated
 141                                  * associated data
 142                                  */
 143         DPAA2_SEC_IPSEC, /*!< IPSEC protocol operations*/
 144         DPAA2_SEC_PDCP,  /*!< PDCP protocol operations*/
 145         DPAA2_SEC_PKC,   /*!< Public Key Cryptographic Operations */
 146         DPAA2_SEC_MAX
 147 };
 148
 149 struct dpaa2_sec_aead_ctxt {
 150         uint16_t auth_only_len; /*!< Length of data for Auth only */
 151         uint8_t auth_cipher_text;       /**< Authenticate/cipher ordering */
 152 };
 153
 154 #ifdef RTE_LIB_SECURITY
 155 /*
 156  * The structure is to be filled by user for PDCP Protocol
 157  */
 158 struct dpaa2_pdcp_ctxt {
 159         enum rte_security_pdcp_domain domain; /*!< Data/Control mode*/
 160         int8_t bearer;  /*!< PDCP bearer ID */
 161         int8_t pkt_dir;/*!< PDCP Frame Direction 0:UL 1:DL*/
 162         int8_t hfn_ovd;/*!< Overwrite HFN per packet*/
 163         uint8_t sn_size;        /*!< Sequence number size, 5/7/12/15/18 */
 164         uint32_t hfn_ovd_offset;/*!< offset from rte_crypto_op at which
 165                                  * per packet hfn is stored
 166                                  */
 167         uint32_t hfn;   /*!< Hyper Frame Number */
 168         uint32_t hfn_threshold; /*!< HFN Threashold for key renegotiation */
 169 };
 170 #endif
 171
 172 typedef int (*dpaa2_sec_build_fd_t)(
 173         void *qp, uint8_t *drv_ctx, struct rte_crypto_vec *data_vec,
 174         uint16_t n_data_vecs, union rte_crypto_sym_ofs ofs,
 175         struct rte_crypto_va_iova_ptr *iv,
 176         struct rte_crypto_va_iova_ptr *digest,
 177         struct rte_crypto_va_iova_ptr *aad_or_auth_iv,
 178         void *user_data);
 179
 180 typedef int (*dpaa2_sec_build_raw_dp_fd_t)(uint8_t *drv_ctx,
 181                        struct rte_crypto_sgl *sgl,
 182                        struct rte_crypto_sgl *dest_sgl,
 183                        struct rte_crypto_va_iova_ptr *iv,
 184                        struct rte_crypto_va_iova_ptr *digest,
 185                        struct rte_crypto_va_iova_ptr *auth_iv,
 186                        union rte_crypto_sym_ofs ofs,
 187                        void *userdata,
 188                        struct qbman_fd *fd);
 189
 190 typedef struct dpaa2_sec_session_entry {
 191         void *ctxt;
 192         uint8_t ctxt_type;
 193         uint8_t dir;         /*!< Operation Direction */
 194         enum rte_crypto_cipher_algorithm cipher_alg; /*!< Cipher Algorithm*/
 195         enum rte_crypto_auth_algorithm auth_alg; /*!< Authentication Algorithm*/
 196         enum rte_crypto_aead_algorithm aead_alg; /*!< AEAD Algorithm*/
 197         dpaa2_sec_build_fd_t build_fd;
 198         dpaa2_sec_build_raw_dp_fd_t build_raw_dp_fd;
 199         union {
 200                 struct {
 201                         uint8_t *data;  /**< pointer to key data */
 202                         size_t length;  /**< key length in bytes */
 203                 } aead_key;
 204                 struct {
 205                         struct {
 206                                 uint8_t *data;  /**< pointer to key data */
 207                                 size_t length;  /**< key length in bytes */
 208                         } cipher_key;
 209                         struct {
 210                                 uint8_t *data;  /**< pointer to key data */
 211                                 size_t length;  /**< key length in bytes */
 212                         } auth_key;
 213                 };
 214         };
 215         union {
 216                 struct {
 217                         struct {
 218                                 uint16_t length; /**< IV length in bytes */
 219                                 uint16_t offset; /**< IV offset in bytes */
 220                         } iv;
 221                         uint16_t digest_length;
 222                         uint8_t status;
 223                         union {
 224                                 struct dpaa2_sec_aead_ctxt aead_ctxt;
 225                         } ext_params;
 226                 };
 227 #ifdef RTE_LIB_SECURITY
 228                 struct dpaa2_pdcp_ctxt pdcp;
 229 #endif
 230         };
 231 } dpaa2_sec_session;
 232
 233 static const struct rte_cryptodev_capabilities dpaa2_sec_capabilities[] = {
 234         /* Symmetric capabilities */
 235         {       /* MD5 */
 236                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 237                 {.sym = {
 238                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 239                         {.auth = {
 240                                 .algo = RTE_CRYPTO_AUTH_MD5,
 241                                 .block_size = 64,
 242                                 .key_size = {
 243                                         .min = 0,
 244                                         .max = 0,
 245                                         .increment = 0
 246                                 },
 247                                 .digest_size = {
 248                                         .min = 16,
 249                                         .max = 16,
 250                                         .increment = 0
 251                                 },
 252                                 .iv_size = { 0 }
 253                         }, }
 254                 }, }
 255         },
 256         {       /* MD5 HMAC */
 257                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 258                 {.sym = {
 259                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 260                         {.auth = {
 261                                 .algo = RTE_CRYPTO_AUTH_MD5_HMAC,
 262                                 .block_size = 64,
 263                                 .key_size = {
 264                                         .min = 1,
 265                                         .max = 64,
 266                                         .increment = 1
 267                                 },
 268                                 .digest_size = {
 269                                         .min = 1,
 270                                         .max = 16,
 271                                         .increment = 1
 272                                 },
 273                                 .iv_size = { 0 }
 274                         }, }
 275                 }, }
 276         },
 277         {       /* SHA1 */
 278                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 279                 {.sym = {
 280                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 281                         {.auth = {
 282                                 .algo = RTE_CRYPTO_AUTH_SHA1,
 283                                 .block_size = 64,
 284                                 .key_size = {
 285                                         .min = 0,
 286                                         .max = 0,
 287                                         .increment = 0
 288                                 },
 289                                 .digest_size = {
 290                                         .min = 20,
 291                                         .max = 20,
 292                                         .increment = 0
 293                                 },
 294                                 .iv_size = { 0 }
 295                         }, }
 296                 }, }
 297         },
 298         {       /* SHA1 HMAC */
 299                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 300                 {.sym = {
 301                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 302                         {.auth = {
 303                                 .algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
 304                                 .block_size = 64,
 305                                 .key_size = {
 306                                         .min = 1,
 307                                         .max = 64,
 308                                         .increment = 1
 309                                 },
 310                                 .digest_size = {
 311                                         .min = 1,
 312                                         .max = 20,
 313                                         .increment = 1
 314                                 },
 315                                 .iv_size = { 0 }
 316                         }, }
 317                 }, }
 318         },
 319         {       /* SHA224 */
 320                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 321                 {.sym = {
 322                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 323                         {.auth = {
 324                                 .algo = RTE_CRYPTO_AUTH_SHA224,
 325                                 .block_size = 64,
 326                                         .key_size = {
 327                                         .min = 0,
 328                                         .max = 0,
 329                                         .increment = 0
 330                                 },
 331                                 .digest_size = {
 332                                         .min = 28,
 333                                         .max = 28,
 334                                         .increment = 0
 335                                 },
 336                                 .iv_size = { 0 }
 337                         }, }
 338                 }, }
 339         },
 340         {       /* SHA224 HMAC */
 341                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 342                 {.sym = {
 343                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 344                         {.auth = {
 345                                 .algo = RTE_CRYPTO_AUTH_SHA224_HMAC,
 346                                 .block_size = 64,
 347                                 .key_size = {
 348                                         .min = 1,
 349                                         .max = 64,
 350                                         .increment = 1
 351                                 },
 352                                 .digest_size = {
 353                                         .min = 1,
 354                                         .max = 28,
 355                                         .increment = 1
 356                                 },
 357                                 .iv_size = { 0 }
 358                         }, }
 359                 }, }
 360         },
 361         {       /* SHA256 */
 362                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 363                 {.sym = {
 364                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 365                         {.auth = {
 366                                 .algo = RTE_CRYPTO_AUTH_SHA256,
 367                                 .block_size = 64,
 368                                 .key_size = {
 369                                         .min = 0,
 370                                         .max = 0,
 371                                         .increment = 0
 372                                 },
 373                                 .digest_size = {
 374                                         .min = 32,
 375                                         .max = 32,
 376                                         .increment = 0
 377                                 },
 378                                 .iv_size = { 0 }
 379                         }, }
 380                 }, }
 381         },
 382         {       /* SHA256 HMAC */
 383                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 384                 {.sym = {
 385                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 386                         {.auth = {
 387                                 .algo = RTE_CRYPTO_AUTH_SHA256_HMAC,
 388                                 .block_size = 64,
 389                                 .key_size = {
 390                                         .min = 1,
 391                                         .max = 64,
 392                                         .increment = 1
 393                                 },
 394                                 .digest_size = {
 395                                         .min = 1,
 396                                         .max = 32,
 397                                         .increment = 1
 398                                 },
 399                                 .iv_size = { 0 }
 400                         }, }
 401                 }, }
 402         },
 403         {       /* SHA384 */
 404                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 405                 {.sym = {
 406                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 407                         {.auth = {
 408                                 .algo = RTE_CRYPTO_AUTH_SHA384,
 409                                 .block_size = 64,
 410                                 .key_size = {
 411                                         .min = 0,
 412                                         .max = 0,
 413                                         .increment = 0
 414                                 },
 415                                 .digest_size = {
 416                                         .min = 48,
 417                                         .max = 48,
 418                                         .increment = 0
 419                                         },
 420                                 .iv_size = { 0 }
 421                         }, }
 422                 }, }
 423         },
 424         {       /* SHA384 HMAC */
 425                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 426                 {.sym = {
 427                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 428                         {.auth = {
 429                                 .algo = RTE_CRYPTO_AUTH_SHA384_HMAC,
 430                                 .block_size = 128,
 431                                 .key_size = {
 432                                         .min = 1,
 433                                         .max = 128,
 434                                         .increment = 1
 435                                 },
 436                                 .digest_size = {
 437                                         .min = 1,
 438                                         .max = 48,
 439                                         .increment = 1
 440                                 },
 441                                 .iv_size = { 0 }
 442                         }, }
 443                 }, }
 444         },
 445         {       /* SHA512 */
 446                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 447                 {.sym = {
 448                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 449                         {.auth = {
 450                                 .algo = RTE_CRYPTO_AUTH_SHA512,
 451                                 .block_size = 128,
 452                                 .key_size = {
 453                                         .min = 0,
 454                                         .max = 0,
 455                                         .increment = 0
 456                                 },
 457                                 .digest_size = {
 458                                         .min = 64,
 459                                         .max = 64,
 460                                         .increment = 0
 461                                 },
 462                                 .iv_size = { 0 }
 463                         }, }
 464                 }, }
 465         },
 466         {       /* SHA512 HMAC */
 467                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 468                 {.sym = {
 469                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 470                         {.auth = {
 471                                 .algo = RTE_CRYPTO_AUTH_SHA512_HMAC,
 472                                 .block_size = 128,
 473                                 .key_size = {
 474                                         .min = 1,
 475                                         .max = 128,
 476                                         .increment = 1
 477                                 },
 478                                 .digest_size = {
 479                                         .min = 1,
 480                                         .max = 64,
 481                                         .increment = 1
 482                                 },
 483                                 .iv_size = { 0 }
 484                         }, }
 485                 }, }
 486         },
 487         {       /* AES GCM */
 488                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 489                 {.sym = {
 490                         .xform_type = RTE_CRYPTO_SYM_XFORM_AEAD,
 491                         {.aead = {
 492                                 .algo = RTE_CRYPTO_AEAD_AES_GCM,
 493                                 .block_size = 16,
 494                                 .key_size = {
 495                                         .min = 16,
 496                                         .max = 32,
 497                                         .increment = 8
 498                                 },
 499                                 .digest_size = {
 500                                         .min = 8,
 501                                         .max = 16,
 502                                         .increment = 4
 503                                 },
 504                                 .aad_size = {
 505                                         .min = 0,
 506                                         .max = 240,
 507                                         .increment = 1
 508                                 },
 509                                 .iv_size = {
 510                                         .min = 12,
 511                                         .max = 12,
 512                                         .increment = 0
 513                                 },
 514                         }, }
 515                 }, }
 516         },
 517         {       /* AES XCBC HMAC */
 518                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 519                 {.sym = {
 520                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 521                         {.auth = {
 522                                 .algo = RTE_CRYPTO_AUTH_AES_XCBC_MAC,
 523                                 .block_size = 16,
 524                                 .key_size = {
 525                                         .min = 1,
 526                                         .max = 16,
 527                                         .increment = 1
 528                                 },
 529                                 .digest_size = {
 530                                         .min = 12,
 531                                         .max = 16,
 532                                         .increment = 4
 533                                 },
 534                                 .aad_size = { 0 },
 535                                 .iv_size = { 0 }
 536                         }, }
 537                 }, }
 538         },
 539         {       /* AES CMAC */
 540                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 541                 {.sym = {
 542                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 543                         {.auth = {
 544                                 .algo = RTE_CRYPTO_AUTH_AES_CMAC,
 545                                 .block_size = 16,
 546                                 .key_size = {
 547                                         .min = 1,
 548                                         .max = 16,
 549                                         .increment = 1
 550                                 },
 551                                 .digest_size = {
 552                                         .min = 4,
 553                                         .max = 16,
 554                                         .increment = 4
 555                                 },
 556                                 .aad_size = { 0 }
 557                         }, }
 558                 }, }
 559         },
 560         {       /* AES CBC */
 561                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 562                 {.sym = {
 563                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 564                         {.cipher = {
 565                                 .algo = RTE_CRYPTO_CIPHER_AES_CBC,
 566                                 .block_size = 16,
 567                                 .key_size = {
 568                                         .min = 16,
 569                                         .max = 32,
 570                                         .increment = 8
 571                                 },
 572                                 .iv_size = {
 573                                         .min = 16,
 574                                         .max = 16,
 575                                         .increment = 0
 576                                 }
 577                         }, }
 578                 }, }
 579         },
 580         {       /* AES CTR */
 581                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 582                 {.sym = {
 583                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 584                         {.cipher = {
 585                                 .algo = RTE_CRYPTO_CIPHER_AES_CTR,
 586                                 .block_size = 16,
 587                                 .key_size = {
 588                                         .min = 16,
 589                                         .max = 32,
 590                                         .increment = 8
 591                                 },
 592                                 .iv_size = {
 593                                         .min = 16,
 594                                         .max = 16,
 595                                         .increment = 0
 596                                 },
 597                         }, }
 598                 }, }
 599         },
 600         {       /* DES CBC */
 601                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 602                 {.sym = {
 603                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 604                         {.cipher = {
 605                                 .algo = RTE_CRYPTO_CIPHER_DES_CBC,
 606                                 .block_size = 8,
 607                                 .key_size = {
 608                                         .min = 8,
 609                                         .max = 8,
 610                                         .increment = 0
 611                                 },
 612                                 .iv_size = {
 613                                         .min = 8,
 614                                         .max = 8,
 615                                         .increment = 0
 616                                 }
 617                         }, }
 618                 }, }
 619         },
 620         {       /* 3DES CBC */
 621                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 622                 {.sym = {
 623                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 624                         {.cipher = {
 625                                 .algo = RTE_CRYPTO_CIPHER_3DES_CBC,
 626                                 .block_size = 8,
 627                                 .key_size = {
 628                                         .min = 16,
 629                                         .max = 24,
 630                                         .increment = 8
 631                                 },
 632                                 .iv_size = {
 633                                         .min = 8,
 634                                         .max = 8,
 635                                         .increment = 0
 636                                 }
 637                         }, }
 638                 }, }
 639         },
 640         {       /* SNOW 3G (UIA2) */
 641                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 642                 {.sym = {
 643                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 644                         {.auth = {
 645                                 .algo = RTE_CRYPTO_AUTH_SNOW3G_UIA2,
 646                                 .block_size = 16,
 647                                 .key_size = {
 648                                         .min = 16,
 649                                         .max = 16,
 650                                         .increment = 0
 651                                 },
 652                                 .digest_size = {
 653                                         .min = 4,
 654                                         .max = 4,
 655                                         .increment = 0
 656                                 },
 657                                 .iv_size = {
 658                                         .min = 16,
 659                                         .max = 16,
 660                                         .increment = 0
 661                                 }
 662                         }, }
 663                 }, }
 664         },
 665         {       /* SNOW 3G (UEA2) */
 666                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 667                 {.sym = {
 668                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 669                         {.cipher = {
 670                                 .algo = RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
 671                                 .block_size = 16,
 672                                 .key_size = {
 673                                         .min = 16,
 674                                         .max = 16,
 675                                         .increment = 0
 676                                 },
 677                                 .iv_size = {
 678                                         .min = 16,
 679                                         .max = 16,
 680                                         .increment = 0
 681                                 }
 682                         }, }
 683                 }, }
 684         },
 685         {       /* ZUC (EEA3) */
 686                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 687                 {.sym = {
 688                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 689                         {.cipher = {
 690                                 .algo = RTE_CRYPTO_CIPHER_ZUC_EEA3,
 691                                 .block_size = 16,
 692                                 .key_size = {
 693                                         .min = 16,
 694                                         .max = 16,
 695                                         .increment = 0
 696                                 },
 697                                 .iv_size = {
 698                                         .min = 16,
 699                                         .max = 16,
 700                                         .increment = 0
 701                                 }
 702                         }, }
 703                 }, }
 704         },
 705         {       /* ZUC (EIA3) */
 706                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 707                 {.sym = {
 708                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 709                         {.auth = {
 710                                 .algo = RTE_CRYPTO_AUTH_ZUC_EIA3,
 711                                 .block_size = 16,
 712                                 .key_size = {
 713                                         .min = 16,
 714                                         .max = 16,
 715                                         .increment = 0
 716                                 },
 717                                 .digest_size = {
 718                                         .min = 4,
 719                                         .max = 4,
 720                                         .increment = 0
 721                                 },
 722                                 .iv_size = {
 723                                         .min = 16,
 724                                         .max = 16,
 725                                         .increment = 0
 726                                 }
 727                         }, }
 728                 }, }
 729         },
 730         RTE_CRYPTODEV_END_OF_CAPABILITIES_LIST()
 731 };
 732
 733 #ifdef RTE_LIB_SECURITY
 734
 735 static const struct rte_cryptodev_capabilities dpaa2_pdcp_capabilities[] = {
 736         {       /* SNOW 3G (UIA2) */
 737                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 738                 {.sym = {
 739                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 740                         {.auth = {
 741                                 .algo = RTE_CRYPTO_AUTH_SNOW3G_UIA2,
 742                                 .block_size = 16,
 743                                 .key_size = {
 744                                         .min = 16,
 745                                         .max = 16,
 746                                         .increment = 0
 747                                 },
 748                                 .digest_size = {
 749                                         .min = 4,
 750                                         .max = 4,
 751                                         .increment = 0
 752                                 },
 753                                 .iv_size = {
 754                                         .min = 16,
 755                                         .max = 16,
 756                                         .increment = 0
 757                                 }
 758                         }, }
 759                 }, }
 760         },
 761         {       /* SNOW 3G (UEA2) */
 762                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 763                 {.sym = {
 764                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 765                         {.cipher = {
 766                                 .algo = RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
 767                                 .block_size = 16,
 768                                 .key_size = {
 769                                         .min = 16,
 770                                         .max = 16,
 771                                         .increment = 0
 772                                 },
 773                                 .iv_size = {
 774                                         .min = 16,
 775                                         .max = 16,
 776                                         .increment = 0
 777                                 }
 778                         }, }
 779                 }, }
 780         },
 781         {       /* AES CTR */
 782                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 783                 {.sym = {
 784                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 785                         {.cipher = {
 786                                 .algo = RTE_CRYPTO_CIPHER_AES_CTR,
 787                                 .block_size = 16,
 788                                 .key_size = {
 789                                         .min = 16,
 790                                         .max = 32,
 791                                         .increment = 8
 792                                 },
 793                                 .iv_size = {
 794                                         .min = 16,
 795                                         .max = 16,
 796                                         .increment = 0
 797                                 }
 798                         }, }
 799                 }, }
 800         },
 801         {       /* NULL (AUTH) */
 802                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 803                 {.sym = {
 804                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 805                         {.auth = {
 806                                 .algo = RTE_CRYPTO_AUTH_NULL,
 807                                 .block_size = 1,
 808                                 .key_size = {
 809                                         .min = 0,
 810                                         .max = 0,
 811                                         .increment = 0
 812                                 },
 813                                 .digest_size = {
 814                                         .min = 0,
 815                                         .max = 0,
 816                                         .increment = 0
 817                                 },
 818                                 .iv_size = { 0 }
 819                         }, },
 820                 }, },
 821         },
 822         {       /* NULL (CIPHER) */
 823                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 824                 {.sym = {
 825                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 826                         {.cipher = {
 827                                 .algo = RTE_CRYPTO_CIPHER_NULL,
 828                                 .block_size = 1,
 829                                 .key_size = {
 830                                         .min = 0,
 831                                         .max = 0,
 832                                         .increment = 0
 833                                 },
 834                                 .iv_size = {
 835                                         .min = 0,
 836                                         .max = 0,
 837                                         .increment = 0
 838                                 }
 839                         }, },
 840                 }, }
 841         },
 842         {       /* ZUC (EEA3) */
 843                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 844                 {.sym = {
 845                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
 846                         {.cipher = {
 847                                 .algo = RTE_CRYPTO_CIPHER_ZUC_EEA3,
 848                                 .block_size = 16,
 849                                 .key_size = {
 850                                         .min = 16,
 851                                         .max = 16,
 852                                         .increment = 0
 853                                 },
 854                                 .iv_size = {
 855                                         .min = 16,
 856                                         .max = 16,
 857                                         .increment = 0
 858                                 }
 859                         }, }
 860                 }, }
 861         },
 862         {       /* ZUC (EIA3) */
 863                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 864                 {.sym = {
 865                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
 866                         {.auth = {
 867                                 .algo = RTE_CRYPTO_AUTH_ZUC_EIA3,
 868                                 .block_size = 16,
 869                                 .key_size = {
 870                                         .min = 16,
 871                                         .max = 16,
 872                                         .increment = 0
 873                                 },
 874                                 .digest_size = {
 875                                         .min = 4,
 876                                         .max = 4,
 877                                         .increment = 0
 878                                 },
 879                                 .iv_size = {
 880                                         .min = 16,
 881                                         .max = 16,
 882                                         .increment = 0
 883                                 }
 884                         }, }
 885                 }, }
 886         },
 887
 888         RTE_CRYPTODEV_END_OF_CAPABILITIES_LIST()
 889 };
 890
 891 static const struct rte_security_capability dpaa2_sec_security_cap[] = {
 892         { /* IPsec Lookaside Protocol offload ESP Transport Egress */
 893                 .action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
 894                 .protocol = RTE_SECURITY_PROTOCOL_IPSEC,
 895                 .ipsec = {
 896                         .proto = RTE_SECURITY_IPSEC_SA_PROTO_ESP,
 897                         .mode = RTE_SECURITY_IPSEC_SA_MODE_TUNNEL,
 898                         .direction = RTE_SECURITY_IPSEC_SA_DIR_EGRESS,
 899                         .options = { 0 },
 900                         .replay_win_sz_max = 128
 901                 },
 902                 .crypto_capabilities = dpaa2_sec_capabilities
 903         },
 904         { /* IPsec Lookaside Protocol offload ESP Tunnel Ingress */
 905                 .action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
 906                 .protocol = RTE_SECURITY_PROTOCOL_IPSEC,
 907                 .ipsec = {
 908                         .proto = RTE_SECURITY_IPSEC_SA_PROTO_ESP,
 909                         .mode = RTE_SECURITY_IPSEC_SA_MODE_TUNNEL,
 910                         .direction = RTE_SECURITY_IPSEC_SA_DIR_INGRESS,
 911                         .options = { 0 },
 912                         .replay_win_sz_max = 128
 913                 },
 914                 .crypto_capabilities = dpaa2_sec_capabilities
 915         },
 916         { /* PDCP Lookaside Protocol offload Data */
 917                 .action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
 918                 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
 919                 .pdcp = {
 920                         .domain = RTE_SECURITY_PDCP_MODE_DATA,
 921                         .capa_flags = 0
 922                 },
 923                 .crypto_capabilities = dpaa2_pdcp_capabilities
 924         },
 925         { /* PDCP Lookaside Protocol offload Control */
 926                 .action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
 927                 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
 928                 .pdcp = {
 929                         .domain = RTE_SECURITY_PDCP_MODE_CONTROL,
 930                         .capa_flags = 0
 931                 },
 932                 .crypto_capabilities = dpaa2_pdcp_capabilities
 933         },
 934         { /* PDCP Lookaside Protocol offload Short MAC */
 935                 .action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
 936                 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
 937                 .pdcp = {
 938                         .domain = RTE_SECURITY_PDCP_MODE_SHORT_MAC,
 939                         .capa_flags = 0
 940                 },
 941                 .crypto_capabilities = dpaa2_pdcp_capabilities
 942         },
 943         {
 944                 .action = RTE_SECURITY_ACTION_TYPE_NONE
 945         }
 946 };
 947 #endif
 948 /**
 949  * Checksum
 950  *
 951  * @param buffer calculate chksum for buffer
 952  * @param len    buffer length
 953  *
 954  * @return checksum value in host cpu order
 955  */
 956 static inline uint16_t
 957 calc_chksum(void *buffer, int len)
 958 {
 959         uint16_t *buf = (uint16_t *)buffer;
 960         uint32_t sum = 0;
 961         uint16_t result;
 962
 963         for (sum = 0; len > 1; len -= 2)
 964                 sum += *buf++;
 965
 966         if (len == 1)
 967                 sum += *(unsigned char *)buf;
 968
 969         sum = (sum >> 16) + (sum & 0xFFFF);
 970         sum += (sum >> 16);
 971         result = ~sum;
 972
 973         return  result;
 974 }
 975
 976 int
 977 dpaa2_sec_configure_raw_dp_ctx(struct rte_cryptodev *dev, uint16_t qp_id,
 978         struct rte_crypto_raw_dp_ctx *raw_dp_ctx,
 979         enum rte_crypto_op_sess_type sess_type,
 980         union rte_cryptodev_session_ctx session_ctx, uint8_t is_update);
 981
 982 int
 983 dpaa2_sec_get_dp_ctx_size(struct rte_cryptodev *dev);
 984
 985
 986 #endif /* _DPAA2_SEC_PMD_PRIVATE_H_ */