LCOV - code coverage report
Current view: top level - drivers/crypto/dpaa_sec - dpaa_sec_raw_dp.c (source / functions) Hit Total Coverage
Test: Code coverage Lines: 0 476 0.0 %
Date: 2024-01-22 16:13:49 Functions: 0 15 0.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 168 0.0 %

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  * Copyright 2021-2022 NXP
       3                 :            :  */
       4                 :            : 
       5                 :            : #include <rte_byteorder.h>
       6                 :            : #include <rte_common.h>
       7                 :            : #include <cryptodev_pmd.h>
       8                 :            : #include <rte_crypto.h>
       9                 :            : #include <rte_cryptodev.h>
      10                 :            : #include <rte_security_driver.h>
      11                 :            : 
      12                 :            : /* RTA header files */
      13                 :            : #include <desc/algo.h>
      14                 :            : #include <desc/ipsec.h>
      15                 :            : 
      16                 :            : #include <bus_dpaa_driver.h>
      17                 :            : #include <dpaa_sec.h>
      18                 :            : #include <dpaa_sec_log.h>
      19                 :            : 
      20                 :            : struct dpaa_sec_raw_dp_ctx {
      21                 :            :         dpaa_sec_session *session;
      22                 :            :         uint32_t tail;
      23                 :            :         uint32_t head;
      24                 :            :         uint16_t cached_enqueue;
      25                 :            :         uint16_t cached_dequeue;
      26                 :            : };
      27                 :            : 
      28                 :            : static inline int
      29                 :            : is_encode(dpaa_sec_session *ses)
      30                 :            : {
      31                 :          0 :         return ses->dir == DIR_ENC;
      32                 :            : }
      33                 :            : 
      34                 :            : static inline int is_decode(dpaa_sec_session *ses)
      35                 :            : {
      36                 :          0 :         return ses->dir == DIR_DEC;
      37                 :            : }
      38                 :            : 
      39                 :            : static __rte_always_inline int
      40                 :          0 : dpaa_sec_raw_enqueue_done(void *qp_data, uint8_t *drv_ctx, uint32_t n)
      41                 :            : {
      42                 :            :         RTE_SET_USED(qp_data);
      43                 :            :         RTE_SET_USED(drv_ctx);
      44                 :            :         RTE_SET_USED(n);
      45                 :            : 
      46                 :          0 :         return 0;
      47                 :            : }
      48                 :            : 
      49                 :            : static __rte_always_inline int
      50                 :          0 : dpaa_sec_raw_dequeue_done(void *qp_data, uint8_t *drv_ctx, uint32_t n)
      51                 :            : {
      52                 :            :         RTE_SET_USED(qp_data);
      53                 :            :         RTE_SET_USED(drv_ctx);
      54                 :            :         RTE_SET_USED(n);
      55                 :            : 
      56                 :          0 :         return 0;
      57                 :            : }
      58                 :            : 
      59                 :            : static inline struct dpaa_sec_op_ctx *
      60         [ #  # ]:          0 : dpaa_sec_alloc_raw_ctx(dpaa_sec_session *ses, int sg_count)
      61                 :            : {
      62                 :            :         struct dpaa_sec_op_ctx *ctx;
      63                 :            :         int i, retval;
      64                 :            : 
      65                 :          0 :         retval = rte_mempool_get(
      66         [ #  # ]:          0 :                         ses->qp[rte_lcore_id() % MAX_DPAA_CORES]->ctx_pool,
      67                 :            :                         (void **)(&ctx));
      68   [ #  #  #  # ]:          0 :         if (!ctx || retval) {
      69                 :          0 :                 DPAA_SEC_DP_WARN("Alloc sec descriptor failed!");
      70                 :          0 :                 return NULL;
      71                 :            :         }
      72                 :            :         /*
      73                 :            :          * Clear SG memory. There are 16 SG entries of 16 Bytes each.
      74                 :            :          * one call to dcbz_64() clear 64 bytes, hence calling it 4 times
      75                 :            :          * to clear all the SG entries. dpaa_sec_alloc_ctx() is called for
      76                 :            :          * each packet, memset is costlier than dcbz_64().
      77                 :            :          */
      78                 :            :         for (i = 0; i < sg_count && i < MAX_JOB_SG_ENTRIES; i += 4)
      79                 :            :                 dcbz_64(&ctx->job.sg[i]);
      80                 :            : 
      81                 :          0 :         ctx->ctx_pool = ses->qp[rte_lcore_id() % MAX_DPAA_CORES]->ctx_pool;
      82                 :          0 :         ctx->vtop_offset = (size_t) ctx - rte_mempool_virt2iova(ctx);
      83                 :            : 
      84                 :          0 :         return ctx;
      85                 :            : }
      86                 :            : 
      87                 :            : static struct dpaa_sec_job *
      88                 :          0 : build_dpaa_raw_dp_auth_fd(uint8_t *drv_ctx,
      89                 :            :                         struct rte_crypto_sgl *sgl,
      90                 :            :                         struct rte_crypto_sgl *dest_sgl,
      91                 :            :                         struct rte_crypto_va_iova_ptr *iv,
      92                 :            :                         struct rte_crypto_va_iova_ptr *digest,
      93                 :            :                         struct rte_crypto_va_iova_ptr *auth_iv,
      94                 :            :                         union rte_crypto_sym_ofs ofs,
      95                 :            :                         void *userdata,
      96                 :            :                         struct qm_fd *fd)
      97                 :            : {
      98                 :            :         RTE_SET_USED(dest_sgl);
      99                 :            :         RTE_SET_USED(iv);
     100                 :            :         RTE_SET_USED(auth_iv);
     101                 :            :         RTE_SET_USED(fd);
     102                 :            : 
     103                 :          0 :         dpaa_sec_session *ses =
     104                 :            :                 ((struct dpaa_sec_raw_dp_ctx *)drv_ctx)->session;
     105                 :            :         struct dpaa_sec_job *cf;
     106                 :            :         struct dpaa_sec_op_ctx *ctx;
     107                 :            :         struct qm_sg_entry *sg, *out_sg, *in_sg;
     108                 :            :         phys_addr_t start_addr;
     109                 :            :         uint8_t *old_digest, extra_segs;
     110                 :            :         int data_len, data_offset, total_len = 0;
     111                 :            :         unsigned int i;
     112                 :            : 
     113         [ #  # ]:          0 :         for (i = 0; i < sgl->num; i++)
     114                 :          0 :                 total_len += sgl->vec[i].len;
     115                 :            : 
     116                 :          0 :         data_len = total_len - ofs.ofs.auth.head - ofs.ofs.auth.tail;
     117                 :            :         data_offset =  ofs.ofs.auth.head;
     118                 :            : 
     119                 :            :         /* Support only length in bits for SNOW3G and ZUC */
     120                 :            : 
     121         [ #  # ]:          0 :         if (is_decode(ses))
     122                 :            :                 extra_segs = 3;
     123                 :            :         else
     124                 :            :                 extra_segs = 2;
     125                 :            : 
     126         [ #  # ]:          0 :         if (sgl->num > MAX_SG_ENTRIES) {
     127                 :          0 :                 DPAA_SEC_DP_ERR("Auth: Max sec segs supported is %d",
     128                 :            :                                 MAX_SG_ENTRIES);
     129                 :          0 :                 return NULL;
     130                 :            :         }
     131                 :          0 :         ctx = dpaa_sec_alloc_raw_ctx(ses, sgl->num * 2 + extra_segs);
     132         [ #  # ]:          0 :         if (!ctx)
     133                 :            :                 return NULL;
     134                 :            : 
     135                 :          0 :         cf = &ctx->job;
     136                 :          0 :         ctx->userdata = (void *)userdata;
     137                 :          0 :         old_digest = ctx->digest;
     138                 :            : 
     139                 :            :         /* output */
     140                 :          0 :         out_sg = &cf->sg[0];
     141                 :          0 :         qm_sg_entry_set64(out_sg, digest->iova);
     142                 :          0 :         out_sg->length = ses->digest_length;
     143                 :          0 :         cpu_to_hw_sg(out_sg);
     144                 :            : 
     145                 :            :         /* input */
     146                 :          0 :         in_sg = &cf->sg[1];
     147                 :            :         /* need to extend the input to a compound frame */
     148                 :          0 :         in_sg->extension = 1;
     149                 :          0 :         in_sg->final = 1;
     150                 :          0 :         in_sg->length = data_len;
     151                 :          0 :         qm_sg_entry_set64(in_sg, rte_dpaa_mem_vtop(&cf->sg[2]));
     152                 :            : 
     153                 :            :         /* 1st seg */
     154                 :          0 :         sg = in_sg + 1;
     155                 :            : 
     156         [ #  # ]:          0 :         if (ses->iv.length) {
     157                 :            :                 uint8_t *iv_ptr;
     158                 :            : 
     159                 :          0 :                 iv_ptr = rte_crypto_op_ctod_offset(userdata, uint8_t *,
     160                 :            :                                                    ses->iv.offset);
     161                 :            : 
     162         [ #  # ]:          0 :                 if (ses->auth_alg == RTE_CRYPTO_AUTH_SNOW3G_UIA2) {
     163                 :            :                         iv_ptr = conv_to_snow_f9_iv(iv_ptr);
     164                 :          0 :                         sg->length = 12;
     165         [ #  # ]:          0 :                 } else if (ses->auth_alg == RTE_CRYPTO_AUTH_ZUC_EIA3) {
     166                 :            :                         iv_ptr = conv_to_zuc_eia_iv(iv_ptr);
     167                 :          0 :                         sg->length = 8;
     168                 :            :                 } else {
     169                 :          0 :                         sg->length = ses->iv.length;
     170                 :            :                 }
     171                 :          0 :                 qm_sg_entry_set64(sg, rte_dpaa_mem_vtop(iv_ptr));
     172                 :          0 :                 in_sg->length += sg->length;
     173                 :          0 :                 cpu_to_hw_sg(sg);
     174                 :          0 :                 sg++;
     175                 :            :         }
     176                 :            : 
     177                 :          0 :         qm_sg_entry_set64(sg, sgl->vec[0].iova);
     178                 :          0 :         sg->offset = data_offset;
     179                 :            : 
     180         [ #  # ]:          0 :         if (data_len <= (int)(sgl->vec[0].len - data_offset)) {
     181                 :          0 :                 sg->length = data_len;
     182                 :            :         } else {
     183                 :          0 :                 sg->length = sgl->vec[0].len - data_offset;
     184                 :            : 
     185                 :            :                 /* remaining i/p segs */
     186         [ #  # ]:          0 :                 for (i = 1; i < sgl->num; i++) {
     187                 :          0 :                         cpu_to_hw_sg(sg);
     188                 :          0 :                         sg++;
     189                 :          0 :                         qm_sg_entry_set64(sg, sgl->vec[i].iova);
     190         [ #  # ]:          0 :                         if (data_len > (int)sgl->vec[i].len)
     191                 :          0 :                                 sg->length = sgl->vec[0].len;
     192                 :            :                         else
     193                 :          0 :                                 sg->length = data_len;
     194                 :            : 
     195                 :          0 :                         data_len = data_len - sg->length;
     196         [ #  # ]:          0 :                         if (data_len < 1)
     197                 :            :                                 break;
     198                 :            :                 }
     199                 :            :         }
     200                 :            : 
     201         [ #  # ]:          0 :         if (is_decode(ses)) {
     202                 :            :                 /* Digest verification case */
     203                 :          0 :                 cpu_to_hw_sg(sg);
     204                 :          0 :                 sg++;
     205                 :          0 :                 rte_memcpy(old_digest, digest->va,
     206         [ #  # ]:          0 :                                 ses->digest_length);
     207                 :            :                 start_addr = rte_dpaa_mem_vtop(old_digest);
     208                 :          0 :                 qm_sg_entry_set64(sg, start_addr);
     209                 :          0 :                 sg->length = ses->digest_length;
     210                 :          0 :                 in_sg->length += ses->digest_length;
     211                 :            :         }
     212                 :          0 :         sg->final = 1;
     213                 :          0 :         cpu_to_hw_sg(sg);
     214                 :          0 :         cpu_to_hw_sg(in_sg);
     215                 :            : 
     216                 :          0 :         return cf;
     217                 :            : }
     218                 :            : 
     219                 :            : static inline struct dpaa_sec_job *
     220                 :          0 : build_raw_cipher_auth_gcm_sg(uint8_t *drv_ctx,
     221                 :            :                         struct rte_crypto_sgl *sgl,
     222                 :            :                         struct rte_crypto_sgl *dest_sgl,
     223                 :            :                         struct rte_crypto_va_iova_ptr *iv,
     224                 :            :                         struct rte_crypto_va_iova_ptr *digest,
     225                 :            :                         struct rte_crypto_va_iova_ptr *auth_iv,
     226                 :            :                         union rte_crypto_sym_ofs ofs,
     227                 :            :                         void *userdata,
     228                 :            :                         struct qm_fd *fd)
     229                 :            : {
     230                 :          0 :         dpaa_sec_session *ses =
     231                 :            :                 ((struct dpaa_sec_raw_dp_ctx *)drv_ctx)->session;
     232                 :            :         struct dpaa_sec_job *cf;
     233                 :            :         struct dpaa_sec_op_ctx *ctx;
     234                 :            :         struct qm_sg_entry *sg, *out_sg, *in_sg;
     235                 :            :         uint8_t extra_req_segs;
     236                 :          0 :         uint8_t *IV_ptr = iv->va;
     237                 :            :         int data_len = 0, aead_len = 0;
     238                 :            :         unsigned int i;
     239                 :            : 
     240         [ #  # ]:          0 :         for (i = 0; i < sgl->num; i++)
     241                 :          0 :                 data_len += sgl->vec[i].len;
     242                 :            : 
     243                 :            :         extra_req_segs = 4;
     244                 :          0 :         aead_len = data_len - ofs.ofs.cipher.head - ofs.ofs.cipher.tail;
     245                 :            : 
     246         [ #  # ]:          0 :         if (ses->auth_only_len)
     247                 :            :                 extra_req_segs++;
     248                 :            : 
     249         [ #  # ]:          0 :         if (sgl->num > MAX_SG_ENTRIES) {
     250                 :          0 :                 DPAA_SEC_DP_ERR("AEAD: Max sec segs supported is %d",
     251                 :            :                                 MAX_SG_ENTRIES);
     252                 :          0 :                 return NULL;
     253                 :            :         }
     254                 :            : 
     255                 :          0 :         ctx = dpaa_sec_alloc_raw_ctx(ses,  sgl->num * 2 + extra_req_segs);
     256         [ #  # ]:          0 :         if (!ctx)
     257                 :            :                 return NULL;
     258                 :            : 
     259                 :          0 :         cf = &ctx->job;
     260                 :          0 :         ctx->userdata = (void *)userdata;
     261                 :            : 
     262                 :          0 :         rte_prefetch0(cf->sg);
     263                 :            : 
     264                 :            :         /* output */
     265                 :            :         out_sg = &cf->sg[0];
     266                 :          0 :         out_sg->extension = 1;
     267         [ #  # ]:          0 :         if (is_encode(ses))
     268                 :          0 :                 out_sg->length = aead_len + ses->digest_length;
     269                 :            :         else
     270                 :          0 :                 out_sg->length = aead_len;
     271                 :            : 
     272                 :            :         /* output sg entries */
     273                 :          0 :         sg = &cf->sg[2];
     274                 :          0 :         qm_sg_entry_set64(out_sg, rte_dpaa_mem_vtop(sg));
     275                 :          0 :         cpu_to_hw_sg(out_sg);
     276                 :            : 
     277         [ #  # ]:          0 :         if (dest_sgl) {
     278                 :            :                 /* 1st seg */
     279                 :          0 :                 qm_sg_entry_set64(sg, dest_sgl->vec[0].iova);
     280                 :          0 :                 sg->length = dest_sgl->vec[0].len - ofs.ofs.cipher.head;
     281                 :          0 :                 sg->offset = ofs.ofs.cipher.head;
     282                 :            : 
     283                 :            :                 /* Successive segs */
     284         [ #  # ]:          0 :                 for (i = 1; i < dest_sgl->num; i++) {
     285                 :          0 :                         cpu_to_hw_sg(sg);
     286                 :          0 :                         sg++;
     287                 :          0 :                         qm_sg_entry_set64(sg, dest_sgl->vec[i].iova);
     288                 :          0 :                         sg->length = dest_sgl->vec[i].len;
     289                 :            :                 }
     290                 :            :         } else {
     291                 :            :                 /* 1st seg */
     292                 :          0 :                 qm_sg_entry_set64(sg, sgl->vec[0].iova);
     293                 :          0 :                 sg->length = sgl->vec[0].len - ofs.ofs.cipher.head;
     294                 :          0 :                 sg->offset = ofs.ofs.cipher.head;
     295                 :            : 
     296                 :            :                 /* Successive segs */
     297         [ #  # ]:          0 :                 for (i = 1; i < sgl->num; i++) {
     298                 :          0 :                         cpu_to_hw_sg(sg);
     299                 :          0 :                         sg++;
     300                 :          0 :                         qm_sg_entry_set64(sg, sgl->vec[i].iova);
     301                 :          0 :                         sg->length = sgl->vec[i].len;
     302                 :            :                 }
     303                 :            : 
     304                 :            :         }
     305                 :            : 
     306         [ #  # ]:          0 :         if (is_encode(ses)) {
     307                 :          0 :                 cpu_to_hw_sg(sg);
     308                 :            :                 /* set auth output */
     309                 :          0 :                 sg++;
     310                 :          0 :                 qm_sg_entry_set64(sg, digest->iova);
     311                 :          0 :                 sg->length = ses->digest_length;
     312                 :            :         }
     313                 :          0 :         sg->final = 1;
     314                 :          0 :         cpu_to_hw_sg(sg);
     315                 :            : 
     316                 :            :         /* input */
     317                 :          0 :         in_sg = &cf->sg[1];
     318                 :          0 :         in_sg->extension = 1;
     319                 :          0 :         in_sg->final = 1;
     320         [ #  # ]:          0 :         if (is_encode(ses))
     321                 :          0 :                 in_sg->length = ses->iv.length + aead_len
     322                 :          0 :                                                 + ses->auth_only_len;
     323                 :            :         else
     324                 :          0 :                 in_sg->length = ses->iv.length + aead_len
     325                 :          0 :                                 + ses->auth_only_len + ses->digest_length;
     326                 :            : 
     327                 :            :         /* input sg entries */
     328                 :          0 :         sg++;
     329                 :          0 :         qm_sg_entry_set64(in_sg, rte_dpaa_mem_vtop(sg));
     330                 :          0 :         cpu_to_hw_sg(in_sg);
     331                 :            : 
     332                 :            :         /* 1st seg IV */
     333                 :          0 :         qm_sg_entry_set64(sg, rte_dpaa_mem_vtop(IV_ptr));
     334                 :          0 :         sg->length = ses->iv.length;
     335                 :          0 :         cpu_to_hw_sg(sg);
     336                 :            : 
     337                 :            :         /* 2 seg auth only */
     338         [ #  # ]:          0 :         if (ses->auth_only_len) {
     339                 :          0 :                 sg++;
     340                 :          0 :                 qm_sg_entry_set64(sg, auth_iv->iova);
     341                 :          0 :                 sg->length = ses->auth_only_len;
     342                 :          0 :                 cpu_to_hw_sg(sg);
     343                 :            :         }
     344                 :            : 
     345                 :            :         /* 3rd seg */
     346                 :          0 :         sg++;
     347                 :          0 :         qm_sg_entry_set64(sg, sgl->vec[0].iova);
     348                 :          0 :         sg->length = sgl->vec[0].len - ofs.ofs.cipher.head;
     349                 :          0 :         sg->offset = ofs.ofs.cipher.head;
     350                 :            : 
     351                 :            :         /* Successive segs */
     352         [ #  # ]:          0 :         for (i = 1; i < sgl->num; i++) {
     353                 :          0 :                 cpu_to_hw_sg(sg);
     354                 :          0 :                 sg++;
     355                 :          0 :                 qm_sg_entry_set64(sg, sgl->vec[i].iova);
     356                 :          0 :                 sg->length =  sgl->vec[i].len;
     357                 :            :         }
     358                 :            : 
     359         [ #  # ]:          0 :         if (is_decode(ses)) {
     360                 :          0 :                 cpu_to_hw_sg(sg);
     361                 :          0 :                 sg++;
     362                 :          0 :                 memcpy(ctx->digest, digest->va,
     363                 :          0 :                         ses->digest_length);
     364                 :          0 :                 qm_sg_entry_set64(sg, rte_dpaa_mem_vtop(ctx->digest));
     365                 :          0 :                 sg->length = ses->digest_length;
     366                 :            :         }
     367                 :          0 :         sg->final = 1;
     368                 :          0 :         cpu_to_hw_sg(sg);
     369                 :            : 
     370         [ #  # ]:          0 :         if (ses->auth_only_len)
     371                 :          0 :                 fd->cmd = 0x80000000 | ses->auth_only_len;
     372                 :            : 
     373                 :            :         return cf;
     374                 :            : }
     375                 :            : 
     376                 :            : static inline struct dpaa_sec_job *
     377                 :          0 : build_dpaa_raw_dp_chain_fd(uint8_t *drv_ctx,
     378                 :            :                         struct rte_crypto_sgl *sgl,
     379                 :            :                         struct rte_crypto_sgl *dest_sgl,
     380                 :            :                         struct rte_crypto_va_iova_ptr *iv,
     381                 :            :                         struct rte_crypto_va_iova_ptr *digest,
     382                 :            :                         struct rte_crypto_va_iova_ptr *auth_iv,
     383                 :            :                         union rte_crypto_sym_ofs ofs,
     384                 :            :                         void *userdata,
     385                 :            :                         struct qm_fd *fd)
     386                 :            : {
     387                 :            :         RTE_SET_USED(auth_iv);
     388                 :            : 
     389                 :          0 :         dpaa_sec_session *ses =
     390                 :            :                 ((struct dpaa_sec_raw_dp_ctx *)drv_ctx)->session;
     391                 :            :         struct dpaa_sec_job *cf;
     392                 :            :         struct dpaa_sec_op_ctx *ctx;
     393                 :            :         struct qm_sg_entry *sg, *out_sg, *in_sg;
     394                 :          0 :         uint8_t *IV_ptr = iv->va;
     395                 :            :         unsigned int i;
     396                 :          0 :         uint16_t auth_hdr_len = ofs.ofs.cipher.head -
     397                 :            :                                 ofs.ofs.auth.head;
     398                 :            :         uint16_t auth_tail_len;
     399                 :            :         uint32_t auth_only_len;
     400                 :            :         int data_len = 0, auth_len = 0, cipher_len = 0;
     401                 :            : 
     402         [ #  # ]:          0 :         for (i = 0; i < sgl->num; i++)
     403                 :          0 :                 data_len += sgl->vec[i].len;
     404                 :            : 
     405                 :          0 :         cipher_len = data_len - ofs.ofs.cipher.head - ofs.ofs.cipher.tail;
     406                 :          0 :         auth_len = data_len - ofs.ofs.auth.head - ofs.ofs.auth.tail;
     407                 :          0 :         auth_tail_len = auth_len - cipher_len - auth_hdr_len;
     408                 :          0 :         auth_only_len = (auth_tail_len << 16) | auth_hdr_len;
     409                 :            : 
     410         [ #  # ]:          0 :         if (sgl->num > MAX_SG_ENTRIES) {
     411                 :          0 :                 DPAA_SEC_DP_ERR("Cipher-Auth: Max sec segs supported is %d",
     412                 :            :                                 MAX_SG_ENTRIES);
     413                 :          0 :                 return NULL;
     414                 :            :         }
     415                 :            : 
     416                 :          0 :         ctx = dpaa_sec_alloc_raw_ctx(ses, sgl->num * 2 + 4);
     417         [ #  # ]:          0 :         if (!ctx)
     418                 :            :                 return NULL;
     419                 :            : 
     420                 :          0 :         cf = &ctx->job;
     421                 :          0 :         ctx->userdata = (void *)userdata;
     422                 :            : 
     423                 :          0 :         rte_prefetch0(cf->sg);
     424                 :            : 
     425                 :            :         /* output */
     426                 :            :         out_sg = &cf->sg[0];
     427                 :          0 :         out_sg->extension = 1;
     428         [ #  # ]:          0 :         if (is_encode(ses))
     429                 :          0 :                 out_sg->length = cipher_len + ses->digest_length;
     430                 :            :         else
     431                 :          0 :                 out_sg->length = cipher_len;
     432                 :            : 
     433                 :            :         /* output sg entries */
     434                 :          0 :         sg = &cf->sg[2];
     435                 :          0 :         qm_sg_entry_set64(out_sg, rte_dpaa_mem_vtop(sg));
     436                 :          0 :         cpu_to_hw_sg(out_sg);
     437                 :            : 
     438                 :            :         /* 1st seg */
     439         [ #  # ]:          0 :         if (dest_sgl) {
     440                 :          0 :                 qm_sg_entry_set64(sg, dest_sgl->vec[0].iova);
     441                 :          0 :                 sg->length = dest_sgl->vec[0].len - ofs.ofs.cipher.head;
     442                 :          0 :                 sg->offset = ofs.ofs.cipher.head;
     443                 :            : 
     444                 :            :                 /* Successive segs */
     445         [ #  # ]:          0 :                 for (i = 1; i < dest_sgl->num; i++) {
     446                 :          0 :                         cpu_to_hw_sg(sg);
     447                 :          0 :                         sg++;
     448                 :          0 :                         qm_sg_entry_set64(sg, dest_sgl->vec[i].iova);
     449                 :          0 :                         sg->length = dest_sgl->vec[i].len;
     450                 :            :                 }
     451                 :          0 :                 sg->length -= ofs.ofs.cipher.tail;
     452                 :            :         } else {
     453                 :          0 :                 qm_sg_entry_set64(sg, sgl->vec[0].iova);
     454                 :          0 :                 sg->length = sgl->vec[0].len - ofs.ofs.cipher.head;
     455                 :          0 :                 sg->offset = ofs.ofs.cipher.head;
     456                 :            : 
     457                 :            :                 /* Successive segs */
     458         [ #  # ]:          0 :                 for (i = 1; i < sgl->num; i++) {
     459                 :          0 :                         cpu_to_hw_sg(sg);
     460                 :          0 :                         sg++;
     461                 :          0 :                         qm_sg_entry_set64(sg, sgl->vec[i].iova);
     462                 :          0 :                         sg->length = sgl->vec[i].len;
     463                 :            :                 }
     464                 :          0 :                 sg->length -= ofs.ofs.cipher.tail;
     465                 :            :         }
     466                 :            : 
     467         [ #  # ]:          0 :         if (is_encode(ses)) {
     468                 :          0 :                 cpu_to_hw_sg(sg);
     469                 :            :                 /* set auth output */
     470                 :          0 :                 sg++;
     471                 :          0 :                 qm_sg_entry_set64(sg, digest->iova);
     472                 :          0 :                 sg->length = ses->digest_length;
     473                 :            :         }
     474                 :          0 :         sg->final = 1;
     475                 :          0 :         cpu_to_hw_sg(sg);
     476                 :            : 
     477                 :            :         /* input */
     478                 :          0 :         in_sg = &cf->sg[1];
     479                 :          0 :         in_sg->extension = 1;
     480                 :          0 :         in_sg->final = 1;
     481         [ #  # ]:          0 :         if (is_encode(ses))
     482                 :          0 :                 in_sg->length = ses->iv.length + auth_len;
     483                 :            :         else
     484                 :          0 :                 in_sg->length = ses->iv.length + auth_len
     485                 :          0 :                                                 + ses->digest_length;
     486                 :            : 
     487                 :            :         /* input sg entries */
     488                 :          0 :         sg++;
     489                 :          0 :         qm_sg_entry_set64(in_sg, rte_dpaa_mem_vtop(sg));
     490                 :          0 :         cpu_to_hw_sg(in_sg);
     491                 :            : 
     492                 :            :         /* 1st seg IV */
     493                 :          0 :         qm_sg_entry_set64(sg, rte_dpaa_mem_vtop(IV_ptr));
     494                 :          0 :         sg->length = ses->iv.length;
     495                 :          0 :         cpu_to_hw_sg(sg);
     496                 :            : 
     497                 :            :         /* 2 seg */
     498                 :          0 :         sg++;
     499                 :          0 :         qm_sg_entry_set64(sg, sgl->vec[0].iova);
     500                 :          0 :         sg->length = sgl->vec[0].len - ofs.ofs.auth.head;
     501                 :          0 :         sg->offset = ofs.ofs.auth.head;
     502                 :            : 
     503                 :            :         /* Successive segs */
     504         [ #  # ]:          0 :         for (i = 1; i < sgl->num; i++) {
     505                 :          0 :                 cpu_to_hw_sg(sg);
     506                 :          0 :                 sg++;
     507                 :          0 :                 qm_sg_entry_set64(sg, sgl->vec[i].iova);
     508                 :          0 :                 sg->length = sgl->vec[i].len;
     509                 :            :         }
     510                 :            : 
     511         [ #  # ]:          0 :         if (is_decode(ses)) {
     512                 :          0 :                 cpu_to_hw_sg(sg);
     513                 :          0 :                 sg++;
     514                 :          0 :                 memcpy(ctx->digest, digest->va,
     515                 :          0 :                         ses->digest_length);
     516                 :          0 :                 qm_sg_entry_set64(sg, rte_dpaa_mem_vtop(ctx->digest));
     517                 :          0 :                 sg->length = ses->digest_length;
     518                 :            :         }
     519                 :          0 :         sg->final = 1;
     520                 :          0 :         cpu_to_hw_sg(sg);
     521                 :            : 
     522         [ #  # ]:          0 :         if (auth_only_len)
     523                 :          0 :                 fd->cmd = 0x80000000 | auth_only_len;
     524                 :            : 
     525                 :            :         return cf;
     526                 :            : }
     527                 :            : 
     528                 :            : static struct dpaa_sec_job *
     529                 :          0 : build_dpaa_raw_dp_cipher_fd(uint8_t *drv_ctx,
     530                 :            :                         struct rte_crypto_sgl *sgl,
     531                 :            :                         struct rte_crypto_sgl *dest_sgl,
     532                 :            :                         struct rte_crypto_va_iova_ptr *iv,
     533                 :            :                         struct rte_crypto_va_iova_ptr *digest,
     534                 :            :                         struct rte_crypto_va_iova_ptr *auth_iv,
     535                 :            :                         union rte_crypto_sym_ofs ofs,
     536                 :            :                         void *userdata,
     537                 :            :                         struct qm_fd *fd)
     538                 :            : {
     539                 :            :         RTE_SET_USED(digest);
     540                 :            :         RTE_SET_USED(auth_iv);
     541                 :            :         RTE_SET_USED(fd);
     542                 :            : 
     543                 :          0 :         dpaa_sec_session *ses =
     544                 :            :                 ((struct dpaa_sec_raw_dp_ctx *)drv_ctx)->session;
     545                 :            :         struct dpaa_sec_job *cf;
     546                 :            :         struct dpaa_sec_op_ctx *ctx;
     547                 :            :         struct qm_sg_entry *sg, *out_sg, *in_sg;
     548                 :            :         unsigned int i;
     549                 :          0 :         uint8_t *IV_ptr = iv->va;
     550                 :            :         int data_len, total_len = 0, data_offset;
     551                 :            : 
     552         [ #  # ]:          0 :         for (i = 0; i < sgl->num; i++)
     553                 :          0 :                 total_len += sgl->vec[i].len;
     554                 :            : 
     555                 :          0 :         data_len = total_len - ofs.ofs.cipher.head - ofs.ofs.cipher.tail;
     556                 :            :         data_offset = ofs.ofs.cipher.head;
     557                 :            : 
     558                 :            :         /* Support lengths in bits only for SNOW3G and ZUC */
     559         [ #  # ]:          0 :         if (sgl->num > MAX_SG_ENTRIES) {
     560                 :          0 :                 DPAA_SEC_DP_ERR("Cipher: Max sec segs supported is %d",
     561                 :            :                                 MAX_SG_ENTRIES);
     562                 :          0 :                 return NULL;
     563                 :            :         }
     564                 :            : 
     565                 :          0 :         ctx = dpaa_sec_alloc_raw_ctx(ses, sgl->num * 2 + 3);
     566         [ #  # ]:          0 :         if (!ctx)
     567                 :            :                 return NULL;
     568                 :            : 
     569                 :          0 :         cf = &ctx->job;
     570                 :          0 :         ctx->userdata = (void *)userdata;
     571                 :            : 
     572                 :            :         /* output */
     573                 :          0 :         out_sg = &cf->sg[0];
     574                 :          0 :         out_sg->extension = 1;
     575                 :          0 :         out_sg->length = data_len;
     576                 :          0 :         qm_sg_entry_set64(out_sg, rte_dpaa_mem_vtop(&cf->sg[2]));
     577                 :          0 :         cpu_to_hw_sg(out_sg);
     578                 :            : 
     579         [ #  # ]:          0 :         if (dest_sgl) {
     580                 :            :                 /* 1st seg */
     581                 :            :                 sg = &cf->sg[2];
     582                 :          0 :                 qm_sg_entry_set64(sg, dest_sgl->vec[0].iova);
     583                 :          0 :                 sg->length = dest_sgl->vec[0].len - data_offset;
     584                 :          0 :                 sg->offset = data_offset;
     585                 :            : 
     586                 :            :                 /* Successive segs */
     587         [ #  # ]:          0 :                 for (i = 1; i < dest_sgl->num; i++) {
     588                 :          0 :                         cpu_to_hw_sg(sg);
     589                 :          0 :                         sg++;
     590                 :          0 :                         qm_sg_entry_set64(sg, dest_sgl->vec[i].iova);
     591                 :          0 :                         sg->length = dest_sgl->vec[i].len;
     592                 :            :                 }
     593                 :            :         } else {
     594                 :            :                 /* 1st seg */
     595                 :            :                 sg = &cf->sg[2];
     596                 :          0 :                 qm_sg_entry_set64(sg, sgl->vec[0].iova);
     597                 :          0 :                 sg->length = sgl->vec[0].len - data_offset;
     598                 :          0 :                 sg->offset = data_offset;
     599                 :            : 
     600                 :            :                 /* Successive segs */
     601         [ #  # ]:          0 :                 for (i = 1; i < sgl->num; i++) {
     602                 :          0 :                         cpu_to_hw_sg(sg);
     603                 :          0 :                         sg++;
     604                 :          0 :                         qm_sg_entry_set64(sg, sgl->vec[i].iova);
     605                 :          0 :                         sg->length = sgl->vec[i].len;
     606                 :            :                 }
     607                 :            : 
     608                 :            :         }
     609                 :          0 :         sg->final = 1;
     610                 :          0 :         cpu_to_hw_sg(sg);
     611                 :            : 
     612                 :            :         /* input */
     613                 :          0 :         in_sg = &cf->sg[1];
     614                 :          0 :         in_sg->extension = 1;
     615                 :          0 :         in_sg->final = 1;
     616                 :          0 :         in_sg->length = data_len + ses->iv.length;
     617                 :            : 
     618                 :          0 :         sg++;
     619                 :          0 :         qm_sg_entry_set64(in_sg, rte_dpaa_mem_vtop(sg));
     620                 :          0 :         cpu_to_hw_sg(in_sg);
     621                 :            : 
     622                 :            :         /* IV */
     623                 :          0 :         qm_sg_entry_set64(sg, rte_dpaa_mem_vtop(IV_ptr));
     624                 :          0 :         sg->length = ses->iv.length;
     625                 :          0 :         cpu_to_hw_sg(sg);
     626                 :            : 
     627                 :            :         /* 1st seg */
     628                 :          0 :         sg++;
     629                 :          0 :         qm_sg_entry_set64(sg, sgl->vec[0].iova);
     630                 :          0 :         sg->length = sgl->vec[0].len - data_offset;
     631                 :          0 :         sg->offset = data_offset;
     632                 :            : 
     633                 :            :         /* Successive segs */
     634         [ #  # ]:          0 :         for (i = 1; i < sgl->num; i++) {
     635                 :          0 :                 cpu_to_hw_sg(sg);
     636                 :          0 :                 sg++;
     637                 :          0 :                 qm_sg_entry_set64(sg, sgl->vec[i].iova);
     638                 :          0 :                 sg->length = sgl->vec[i].len;
     639                 :            :         }
     640                 :          0 :         sg->final = 1;
     641                 :          0 :         cpu_to_hw_sg(sg);
     642                 :            : 
     643                 :          0 :         return cf;
     644                 :            : }
     645                 :            : 
     646                 :            : static inline struct dpaa_sec_job *
     647                 :          0 : build_dpaa_raw_proto_sg(uint8_t *drv_ctx,
     648                 :            :                         struct rte_crypto_sgl *sgl,
     649                 :            :                         struct rte_crypto_sgl *dest_sgl,
     650                 :            :                         struct rte_crypto_va_iova_ptr *iv,
     651                 :            :                         struct rte_crypto_va_iova_ptr *digest,
     652                 :            :                         struct rte_crypto_va_iova_ptr *auth_iv,
     653                 :            :                         union rte_crypto_sym_ofs ofs,
     654                 :            :                         void *userdata,
     655                 :            :                         struct qm_fd *fd)
     656                 :            : {
     657                 :            :         RTE_SET_USED(iv);
     658                 :            :         RTE_SET_USED(digest);
     659                 :            :         RTE_SET_USED(auth_iv);
     660                 :            :         RTE_SET_USED(ofs);
     661                 :            : 
     662                 :          0 :         dpaa_sec_session *ses =
     663                 :            :                 ((struct dpaa_sec_raw_dp_ctx *)drv_ctx)->session;
     664                 :            :         struct dpaa_sec_job *cf;
     665                 :            :         struct dpaa_sec_op_ctx *ctx;
     666                 :            :         struct qm_sg_entry *sg, *out_sg, *in_sg;
     667                 :            :         uint32_t in_len = 0, out_len = 0;
     668                 :            :         unsigned int i;
     669                 :            : 
     670         [ #  # ]:          0 :         if (sgl->num > MAX_SG_ENTRIES) {
     671                 :          0 :                 DPAA_SEC_DP_ERR("Proto: Max sec segs supported is %d",
     672                 :            :                                 MAX_SG_ENTRIES);
     673                 :          0 :                 return NULL;
     674                 :            :         }
     675                 :            : 
     676                 :          0 :         ctx = dpaa_sec_alloc_raw_ctx(ses, sgl->num * 2 + 4);
     677         [ #  # ]:          0 :         if (!ctx)
     678                 :            :                 return NULL;
     679                 :          0 :         cf = &ctx->job;
     680                 :          0 :         ctx->userdata = (void *)userdata;
     681                 :            :         /* output */
     682                 :          0 :         out_sg = &cf->sg[0];
     683                 :          0 :         out_sg->extension = 1;
     684                 :          0 :         qm_sg_entry_set64(out_sg, rte_dpaa_mem_vtop(&cf->sg[2]));
     685                 :            : 
     686         [ #  # ]:          0 :         if (dest_sgl) {
     687                 :            :                 /* 1st seg */
     688                 :            :                 sg = &cf->sg[2];
     689                 :          0 :                 qm_sg_entry_set64(sg, dest_sgl->vec[0].iova);
     690                 :          0 :                 sg->offset = 0;
     691                 :          0 :                 sg->length = dest_sgl->vec[0].len;
     692                 :          0 :                 out_len += sg->length;
     693                 :            : 
     694         [ #  # ]:          0 :                 for (i = 1; i < dest_sgl->num; i++) {
     695                 :            :                 /* Successive segs */
     696                 :          0 :                         cpu_to_hw_sg(sg);
     697                 :          0 :                         sg++;
     698                 :          0 :                         qm_sg_entry_set64(sg, dest_sgl->vec[i].iova);
     699                 :          0 :                         sg->offset = 0;
     700                 :          0 :                         sg->length = dest_sgl->vec[i].len;
     701                 :          0 :                         out_len += sg->length;
     702                 :            :                 }
     703                 :          0 :                 sg->length = dest_sgl->vec[i - 1].tot_len;
     704                 :            :         } else {
     705                 :            :                 /* 1st seg */
     706                 :            :                 sg = &cf->sg[2];
     707                 :          0 :                 qm_sg_entry_set64(sg, sgl->vec[0].iova);
     708                 :          0 :                 sg->offset = 0;
     709                 :          0 :                 sg->length = sgl->vec[0].len;
     710                 :          0 :                 out_len += sg->length;
     711                 :            : 
     712         [ #  # ]:          0 :                 for (i = 1; i < sgl->num; i++) {
     713                 :            :                 /* Successive segs */
     714                 :          0 :                         cpu_to_hw_sg(sg);
     715                 :          0 :                         sg++;
     716                 :          0 :                         qm_sg_entry_set64(sg, sgl->vec[i].iova);
     717                 :          0 :                         sg->offset = 0;
     718                 :          0 :                         sg->length = sgl->vec[i].len;
     719                 :          0 :                         out_len += sg->length;
     720                 :            :                 }
     721                 :          0 :                 sg->length = sgl->vec[i - 1].tot_len;
     722                 :            : 
     723                 :            :         }
     724                 :          0 :         out_len += sg->length;
     725                 :          0 :         sg->final = 1;
     726                 :          0 :         cpu_to_hw_sg(sg);
     727                 :            : 
     728                 :          0 :         out_sg->length = out_len;
     729                 :          0 :         cpu_to_hw_sg(out_sg);
     730                 :            : 
     731                 :            :         /* input */
     732                 :          0 :         in_sg = &cf->sg[1];
     733                 :          0 :         in_sg->extension = 1;
     734                 :          0 :         in_sg->final = 1;
     735                 :          0 :         in_len = sgl->vec[0].len;
     736                 :            : 
     737                 :          0 :         sg++;
     738                 :          0 :         qm_sg_entry_set64(in_sg, rte_dpaa_mem_vtop(sg));
     739                 :            : 
     740                 :            :         /* 1st seg */
     741                 :          0 :         qm_sg_entry_set64(sg, sgl->vec[0].iova);
     742                 :          0 :         sg->length = sgl->vec[0].len;
     743                 :          0 :         sg->offset = 0;
     744                 :            : 
     745                 :            :         /* Successive segs */
     746         [ #  # ]:          0 :         for (i = 1; i < sgl->num; i++) {
     747                 :          0 :                 cpu_to_hw_sg(sg);
     748                 :          0 :                 sg++;
     749                 :          0 :                 qm_sg_entry_set64(sg, sgl->vec[i].iova);
     750                 :          0 :                 sg->length = sgl->vec[i].len;
     751                 :          0 :                 sg->offset = 0;
     752                 :          0 :                 in_len += sg->length;
     753                 :            :         }
     754                 :          0 :         sg->final = 1;
     755                 :          0 :         cpu_to_hw_sg(sg);
     756                 :            : 
     757                 :          0 :         in_sg->length = in_len;
     758                 :          0 :         cpu_to_hw_sg(in_sg);
     759                 :            : 
     760   [ #  #  #  # ]:          0 :         if ((ses->ctxt == DPAA_SEC_PDCP) && ses->pdcp.hfn_ovd) {
     761                 :          0 :                 fd->cmd = 0x80000000 |
     762                 :          0 :                         *((uint32_t *)((uint8_t *)userdata +
     763                 :          0 :                         ses->pdcp.hfn_ovd_offset));
     764                 :            :                 DPAA_SEC_DP_DEBUG("Per packet HFN: %x, ovd:%u\n",
     765                 :            :                         *((uint32_t *)((uint8_t *)userdata +
     766                 :            :                         ses->pdcp.hfn_ovd_offset)),
     767                 :            :                         ses->pdcp.hfn_ovd);
     768                 :            :         }
     769                 :            : 
     770                 :            :         return cf;
     771                 :            : }
     772                 :            : 
     773                 :            : static uint32_t
     774                 :          0 : dpaa_sec_raw_enqueue_burst(void *qp_data, uint8_t *drv_ctx,
     775                 :            :         struct rte_crypto_sym_vec *vec, union rte_crypto_sym_ofs ofs,
     776                 :            :         void *user_data[], int *status)
     777                 :            : {
     778                 :            :         /* Function to transmit the frames to given device and queuepair */
     779                 :            :         uint32_t loop;
     780                 :            :         struct dpaa_sec_qp *dpaa_qp = (struct dpaa_sec_qp *)qp_data;
     781                 :            :         uint16_t num_tx = 0;
     782                 :            :         struct qm_fd fds[DPAA_SEC_BURST], *fd;
     783                 :            :         uint32_t frames_to_send;
     784                 :            :         struct dpaa_sec_job *cf;
     785                 :          0 :         dpaa_sec_session *ses =
     786                 :            :                         ((struct dpaa_sec_raw_dp_ctx *)drv_ctx)->session;
     787                 :          0 :         uint32_t flags[DPAA_SEC_BURST] = {0};
     788                 :            :         struct qman_fq *inq[DPAA_SEC_BURST];
     789                 :            : 
     790         [ #  # ]:          0 :         if (unlikely(!DPAA_PER_LCORE_PORTAL)) {
     791         [ #  # ]:          0 :                 if (rte_dpaa_portal_init((void *)0)) {
     792                 :          0 :                         DPAA_SEC_ERR("Failure in affining portal");
     793                 :          0 :                         return 0;
     794                 :            :                 }
     795                 :            :         }
     796                 :            : 
     797         [ #  # ]:          0 :         while (vec->num) {
     798                 :          0 :                 frames_to_send = (vec->num > DPAA_SEC_BURST) ?
     799                 :            :                                 DPAA_SEC_BURST : vec->num;
     800         [ #  # ]:          0 :                 for (loop = 0; loop < frames_to_send; loop++) {
     801         [ #  # ]:          0 :                         if (unlikely(!ses->qp[rte_lcore_id() % MAX_DPAA_CORES])) {
     802         [ #  # ]:          0 :                                 if (dpaa_sec_attach_sess_q(dpaa_qp, ses)) {
     803                 :            :                                         frames_to_send = loop;
     804                 :          0 :                                         goto send_pkts;
     805                 :            :                                 }
     806         [ #  # ]:          0 :                         } else if (unlikely(ses->qp[rte_lcore_id() %
     807                 :            :                                                 MAX_DPAA_CORES] != dpaa_qp)) {
     808                 :          0 :                                 DPAA_SEC_DP_ERR("Old:sess->qp = %p"
     809                 :            :                                         " New qp = %p\n",
     810                 :            :                                         ses->qp[rte_lcore_id() %
     811                 :            :                                         MAX_DPAA_CORES], dpaa_qp);
     812                 :            :                                 frames_to_send = loop;
     813                 :          0 :                                 goto send_pkts;
     814                 :            :                         }
     815                 :            : 
     816                 :            :                         /*Clear the unused FD fields before sending*/
     817                 :          0 :                         fd = &fds[loop];
     818                 :            :                         memset(fd, 0, sizeof(struct qm_fd));
     819                 :          0 :                         cf = ses->build_raw_dp_fd(drv_ctx,
     820                 :          0 :                                                 &vec->src_sgl[loop],
     821                 :          0 :                                                 &vec->dest_sgl[loop],
     822                 :          0 :                                                 &vec->iv[loop],
     823                 :          0 :                                                 &vec->digest[loop],
     824                 :          0 :                                                 &vec->auth_iv[loop],
     825                 :            :                                                 ofs,
     826                 :          0 :                                                 user_data[loop],
     827                 :            :                                                 fd);
     828         [ #  # ]:          0 :                         if (!cf) {
     829                 :          0 :                                 DPAA_SEC_ERR("error: Improper packet contents"
     830                 :            :                                         " for crypto operation");
     831                 :          0 :                                 goto skip_tx;
     832                 :            :                         }
     833                 :          0 :                         inq[loop] = ses->inq[rte_lcore_id() % MAX_DPAA_CORES];
     834                 :          0 :                         qm_fd_addr_set64(fd, rte_dpaa_mem_vtop(cf->sg));
     835                 :          0 :                         fd->_format1 = qm_fd_compound;
     836                 :          0 :                         fd->length29 = 2 * sizeof(struct qm_sg_entry);
     837                 :            : 
     838                 :          0 :                         status[loop] = 1;
     839                 :            :                 }
     840                 :          0 : send_pkts:
     841                 :            :                 loop = 0;
     842         [ #  # ]:          0 :                 while (loop < frames_to_send) {
     843                 :          0 :                         loop += qman_enqueue_multi_fq(&inq[loop], &fds[loop],
     844                 :          0 :                                         &flags[loop], frames_to_send - loop);
     845                 :            :                 }
     846                 :          0 :                 vec->num -= frames_to_send;
     847                 :          0 :                 num_tx += frames_to_send;
     848                 :            :         }
     849                 :            : 
     850                 :          0 : skip_tx:
     851                 :          0 :         dpaa_qp->tx_pkts += num_tx;
     852                 :          0 :         dpaa_qp->tx_errs += vec->num - num_tx;
     853                 :            : 
     854                 :          0 :         return num_tx;
     855                 :            : }
     856                 :            : 
     857                 :            : static int
     858                 :          0 : dpaa_sec_deq_raw(struct dpaa_sec_qp *qp, void **out_user_data,
     859                 :            :                 uint8_t is_user_data_array,
     860                 :            :                 rte_cryptodev_raw_post_dequeue_t post_dequeue,
     861                 :            :                 int nb_ops)
     862                 :            : {
     863                 :            :         struct qman_fq *fq;
     864                 :            :         unsigned int pkts = 0;
     865                 :            :         int num_rx_bufs, ret;
     866                 :            :         struct qm_dqrr_entry *dq;
     867                 :            :         uint32_t vdqcr_flags = 0;
     868                 :            :         uint8_t is_success = 0;
     869                 :            : 
     870                 :          0 :         fq = &qp->outq;
     871                 :            :         /*
     872                 :            :          * Until request for four buffers, we provide exact number of buffers.
     873                 :            :          * Otherwise we do not set the QM_VDQCR_EXACT flag.
     874                 :            :          * Not setting QM_VDQCR_EXACT flag can provide two more buffers than
     875                 :            :          * requested, so we request two less in this case.
     876                 :            :          */
     877         [ #  # ]:          0 :         if (nb_ops < 4) {
     878                 :            :                 vdqcr_flags = QM_VDQCR_EXACT;
     879                 :            :                 num_rx_bufs = nb_ops;
     880                 :            :         } else {
     881                 :          0 :                 num_rx_bufs = nb_ops > DPAA_MAX_DEQUEUE_NUM_FRAMES ?
     882                 :          0 :                         (DPAA_MAX_DEQUEUE_NUM_FRAMES - 2) : (nb_ops - 2);
     883                 :            :         }
     884                 :          0 :         ret = qman_set_vdq(fq, num_rx_bufs, vdqcr_flags);
     885         [ #  # ]:          0 :         if (ret)
     886                 :            :                 return 0;
     887                 :            : 
     888                 :            :         do {
     889                 :            :                 const struct qm_fd *fd;
     890                 :            :                 struct dpaa_sec_job *job;
     891                 :            :                 struct dpaa_sec_op_ctx *ctx;
     892                 :            : 
     893                 :          0 :                 dq = qman_dequeue(fq);
     894         [ #  # ]:          0 :                 if (!dq)
     895                 :          0 :                         continue;
     896                 :            : 
     897                 :            :                 fd = &dq->fd;
     898                 :            :                 /* sg is embedded in an op ctx,
     899                 :            :                  * sg[0] is for output
     900                 :            :                  * sg[1] for input
     901                 :            :                  */
     902                 :          0 :                 job = rte_dpaa_mem_ptov(qm_fd_addr_get64(fd));
     903                 :            : 
     904                 :            :                 ctx = container_of(job, struct dpaa_sec_op_ctx, job);
     905                 :          0 :                 ctx->fd_status = fd->status;
     906         [ #  # ]:          0 :                 if (is_user_data_array)
     907                 :          0 :                         out_user_data[pkts] = ctx->userdata;
     908                 :            :                 else
     909                 :          0 :                         out_user_data[0] = ctx->userdata;
     910                 :            : 
     911         [ #  # ]:          0 :                 if (!ctx->fd_status) {
     912                 :            :                         is_success = true;
     913                 :            :                 } else {
     914                 :            :                         is_success = false;
     915                 :          0 :                         DPAA_SEC_DP_WARN("SEC return err:0x%x", ctx->fd_status);
     916                 :            :                 }
     917                 :          0 :                 post_dequeue(ctx->op, pkts, is_success);
     918                 :          0 :                 pkts++;
     919                 :            : 
     920                 :            :                 /* report op status to sym->op and then free the ctx memory */
     921         [ #  # ]:          0 :                 rte_mempool_put(ctx->ctx_pool, (void *)ctx);
     922                 :            : 
     923                 :          0 :                 qman_dqrr_consume(fq, dq);
     924         [ #  # ]:          0 :         } while (fq->flags & QMAN_FQ_STATE_VDQCR);
     925                 :            : 
     926                 :          0 :         return pkts;
     927                 :            : }
     928                 :            : 
     929                 :            : 
     930                 :            : static __rte_always_inline uint32_t
     931                 :          0 : dpaa_sec_raw_dequeue_burst(void *qp_data, uint8_t *drv_ctx,
     932                 :            :         rte_cryptodev_raw_get_dequeue_count_t get_dequeue_count,
     933                 :            :         uint32_t max_nb_to_dequeue,
     934                 :            :         rte_cryptodev_raw_post_dequeue_t post_dequeue,
     935                 :            :         void **out_user_data, uint8_t is_user_data_array,
     936                 :            :         uint32_t *n_success, int *dequeue_status)
     937                 :            : {
     938                 :            :         RTE_SET_USED(drv_ctx);
     939                 :            :         RTE_SET_USED(get_dequeue_count);
     940                 :            :         uint16_t num_rx;
     941                 :            :         struct dpaa_sec_qp *dpaa_qp = (struct dpaa_sec_qp *)qp_data;
     942                 :            :         uint32_t nb_ops = max_nb_to_dequeue;
     943                 :            : 
     944         [ #  # ]:          0 :         if (unlikely(!DPAA_PER_LCORE_PORTAL)) {
     945         [ #  # ]:          0 :                 if (rte_dpaa_portal_init((void *)0)) {
     946                 :          0 :                         DPAA_SEC_ERR("Failure in affining portal");
     947                 :          0 :                         return 0;
     948                 :            :                 }
     949                 :            :         }
     950                 :            : 
     951                 :          0 :         num_rx = dpaa_sec_deq_raw(dpaa_qp, out_user_data,
     952                 :            :                         is_user_data_array, post_dequeue, nb_ops);
     953                 :            : 
     954                 :          0 :         dpaa_qp->rx_pkts += num_rx;
     955                 :          0 :         *dequeue_status = 1;
     956                 :          0 :         *n_success = num_rx;
     957                 :            : 
     958                 :            :         DPAA_SEC_DP_DEBUG("SEC Received %d Packets\n", num_rx);
     959                 :            : 
     960                 :          0 :         return num_rx;
     961                 :            : }
     962                 :            : 
     963                 :            : static __rte_always_inline int
     964                 :          0 : dpaa_sec_raw_enqueue(void *qp_data, uint8_t *drv_ctx,
     965                 :            :         struct rte_crypto_vec *data_vec,
     966                 :            :         uint16_t n_data_vecs, union rte_crypto_sym_ofs ofs,
     967                 :            :         struct rte_crypto_va_iova_ptr *iv,
     968                 :            :         struct rte_crypto_va_iova_ptr *digest,
     969                 :            :         struct rte_crypto_va_iova_ptr *aad_or_auth_iv,
     970                 :            :         void *user_data)
     971                 :            : {
     972                 :            :         RTE_SET_USED(qp_data);
     973                 :            :         RTE_SET_USED(drv_ctx);
     974                 :            :         RTE_SET_USED(data_vec);
     975                 :            :         RTE_SET_USED(n_data_vecs);
     976                 :            :         RTE_SET_USED(ofs);
     977                 :            :         RTE_SET_USED(iv);
     978                 :            :         RTE_SET_USED(digest);
     979                 :            :         RTE_SET_USED(aad_or_auth_iv);
     980                 :            :         RTE_SET_USED(user_data);
     981                 :            : 
     982                 :          0 :         return 0;
     983                 :            : }
     984                 :            : 
     985                 :            : static __rte_always_inline void *
     986                 :          0 : dpaa_sec_raw_dequeue(void *qp_data, uint8_t *drv_ctx, int *dequeue_status,
     987                 :            :         enum rte_crypto_op_status *op_status)
     988                 :            : {
     989                 :            :         RTE_SET_USED(qp_data);
     990                 :            :         RTE_SET_USED(drv_ctx);
     991                 :            :         RTE_SET_USED(dequeue_status);
     992                 :            :         RTE_SET_USED(op_status);
     993                 :            : 
     994                 :          0 :         return NULL;
     995                 :            : }
     996                 :            : 
     997                 :            : int
     998                 :          0 : dpaa_sec_configure_raw_dp_ctx(struct rte_cryptodev *dev, uint16_t qp_id,
     999                 :            :         struct rte_crypto_raw_dp_ctx *raw_dp_ctx,
    1000                 :            :         enum rte_crypto_op_sess_type sess_type,
    1001                 :            :         union rte_cryptodev_session_ctx session_ctx, uint8_t is_update)
    1002                 :            : {
    1003                 :            :         dpaa_sec_session *sess;
    1004                 :            :         struct dpaa_sec_raw_dp_ctx *dp_ctx;
    1005                 :            :         RTE_SET_USED(qp_id);
    1006                 :            : 
    1007         [ #  # ]:          0 :         if (!is_update) {
    1008                 :            :                 memset(raw_dp_ctx, 0, sizeof(*raw_dp_ctx));
    1009                 :          0 :                 raw_dp_ctx->qp_data = dev->data->queue_pairs[qp_id];
    1010                 :            :         }
    1011                 :            : 
    1012         [ #  # ]:          0 :         if (sess_type == RTE_CRYPTO_OP_SECURITY_SESSION)
    1013                 :          0 :                 sess = SECURITY_GET_SESS_PRIV(session_ctx.sec_sess);
    1014         [ #  # ]:          0 :         else if (sess_type == RTE_CRYPTO_OP_WITH_SESSION)
    1015                 :          0 :                 sess = (dpaa_sec_session *)
    1016                 :            :                         CRYPTODEV_GET_SYM_SESS_PRIV(session_ctx.crypto_sess);
    1017                 :            :         else
    1018                 :            :                 return -ENOTSUP;
    1019                 :          0 :         raw_dp_ctx->dequeue_burst = dpaa_sec_raw_dequeue_burst;
    1020                 :          0 :         raw_dp_ctx->dequeue = dpaa_sec_raw_dequeue;
    1021                 :          0 :         raw_dp_ctx->dequeue_done = dpaa_sec_raw_dequeue_done;
    1022                 :          0 :         raw_dp_ctx->enqueue_burst = dpaa_sec_raw_enqueue_burst;
    1023                 :          0 :         raw_dp_ctx->enqueue = dpaa_sec_raw_enqueue;
    1024                 :          0 :         raw_dp_ctx->enqueue_done = dpaa_sec_raw_enqueue_done;
    1025                 :            : 
    1026         [ #  # ]:          0 :         if (sess->ctxt == DPAA_SEC_CIPHER)
    1027                 :          0 :                 sess->build_raw_dp_fd = build_dpaa_raw_dp_cipher_fd;
    1028         [ #  # ]:          0 :         else if (sess->ctxt == DPAA_SEC_AUTH)
    1029                 :          0 :                 sess->build_raw_dp_fd = build_dpaa_raw_dp_auth_fd;
    1030         [ #  # ]:          0 :         else if (sess->ctxt == DPAA_SEC_CIPHER_HASH)
    1031                 :          0 :                 sess->build_raw_dp_fd = build_dpaa_raw_dp_chain_fd;
    1032         [ #  # ]:          0 :         else if (sess->ctxt == DPAA_SEC_AEAD)
    1033                 :          0 :                 sess->build_raw_dp_fd = build_raw_cipher_auth_gcm_sg;
    1034         [ #  # ]:          0 :         else if (sess->ctxt == DPAA_SEC_IPSEC ||
    1035                 :            :                         sess->ctxt == DPAA_SEC_PDCP)
    1036                 :          0 :                 sess->build_raw_dp_fd = build_dpaa_raw_proto_sg;
    1037                 :            :         else
    1038                 :            :                 return -ENOTSUP;
    1039                 :            :         dp_ctx = (struct dpaa_sec_raw_dp_ctx *)raw_dp_ctx->drv_ctx_data;
    1040                 :          0 :         dp_ctx->session = sess;
    1041                 :            : 
    1042                 :          0 :         return 0;
    1043                 :            : }
    1044                 :            : 
    1045                 :            : int
    1046                 :          0 : dpaa_sec_get_dp_ctx_size(__rte_unused struct rte_cryptodev *dev)
    1047                 :            : {
    1048                 :          0 :         return sizeof(struct dpaa_sec_raw_dp_ctx);
    1049                 :            : }

Generated by: LCOV version 1.14