LCOV - code coverage report
Current view: top level - drivers/event/cnxk - cnxk_eventdev_adptr.c (source / functions) Hit Total Coverage
Test: Code coverage Lines: 0 382 0.0 %
Date: 2024-04-01 19:00:53 Functions: 0 26 0.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 192 0.0 %

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  * Copyright(C) 2021 Marvell.
       3                 :            :  */
       4                 :            : 
       5                 :            : #include "cnxk_cryptodev_ops.h"
       6                 :            : #include "cnxk_ethdev.h"
       7                 :            : #include "cnxk_eventdev.h"
       8                 :            : #include "cnxk_dmadev.h"
       9                 :            : 
      10                 :            : void
      11                 :          0 : cnxk_sso_updt_xae_cnt(struct cnxk_sso_evdev *dev, void *data,
      12                 :            :                       uint32_t event_type)
      13                 :            : {
      14                 :            :         int i;
      15                 :            : 
      16   [ #  #  #  # ]:          0 :         switch (event_type) {
      17                 :            :         case RTE_EVENT_TYPE_ETHDEV: {
      18                 :            :                 struct cnxk_eth_rxq_sp *rxq = data;
      19                 :            :                 uint64_t *old_ptr;
      20                 :            : 
      21         [ #  # ]:          0 :                 for (i = 0; i < dev->rx_adptr_pool_cnt; i++) {
      22         [ #  # ]:          0 :                         if ((uint64_t)rxq->qconf.mp == dev->rx_adptr_pools[i])
      23                 :            :                                 return;
      24                 :            :                 }
      25                 :            : 
      26                 :          0 :                 dev->rx_adptr_pool_cnt++;
      27                 :          0 :                 old_ptr = dev->rx_adptr_pools;
      28                 :          0 :                 dev->rx_adptr_pools = rte_realloc(
      29                 :            :                         dev->rx_adptr_pools,
      30                 :          0 :                         sizeof(uint64_t) * dev->rx_adptr_pool_cnt, 0);
      31         [ #  # ]:          0 :                 if (dev->rx_adptr_pools == NULL) {
      32                 :          0 :                         dev->adptr_xae_cnt += rxq->qconf.mp->size;
      33                 :          0 :                         dev->rx_adptr_pools = old_ptr;
      34                 :          0 :                         dev->rx_adptr_pool_cnt--;
      35                 :          0 :                         return;
      36                 :            :                 }
      37                 :          0 :                 dev->rx_adptr_pools[dev->rx_adptr_pool_cnt - 1] =
      38                 :          0 :                         (uint64_t)rxq->qconf.mp;
      39                 :            : 
      40                 :          0 :                 dev->adptr_xae_cnt += rxq->qconf.mp->size;
      41                 :          0 :                 break;
      42                 :            :         }
      43                 :            :         case RTE_EVENT_TYPE_ETHDEV_VECTOR: {
      44                 :            :                 struct rte_mempool *mp = data;
      45                 :            :                 uint64_t *old_ptr;
      46                 :            : 
      47         [ #  # ]:          0 :                 for (i = 0; i < dev->vec_pool_cnt; i++) {
      48         [ #  # ]:          0 :                         if ((uint64_t)mp == dev->vec_pools[i])
      49                 :            :                                 return;
      50                 :            :                 }
      51                 :            : 
      52                 :          0 :                 dev->vec_pool_cnt++;
      53                 :          0 :                 old_ptr = dev->vec_pools;
      54                 :          0 :                 dev->vec_pools =
      55                 :          0 :                         rte_realloc(dev->vec_pools,
      56                 :          0 :                                     sizeof(uint64_t) * dev->vec_pool_cnt, 0);
      57         [ #  # ]:          0 :                 if (dev->vec_pools == NULL) {
      58                 :          0 :                         dev->adptr_xae_cnt += mp->size;
      59                 :          0 :                         dev->vec_pools = old_ptr;
      60                 :          0 :                         dev->vec_pool_cnt--;
      61                 :          0 :                         return;
      62                 :            :                 }
      63                 :          0 :                 dev->vec_pools[dev->vec_pool_cnt - 1] = (uint64_t)mp;
      64                 :            : 
      65                 :          0 :                 dev->adptr_xae_cnt += mp->size;
      66                 :          0 :                 break;
      67                 :            :         }
      68                 :            :         case RTE_EVENT_TYPE_TIMER: {
      69                 :            :                 struct cnxk_tim_ring *timr = data;
      70                 :            :                 uint16_t *old_ring_ptr;
      71                 :            :                 uint64_t *old_sz_ptr;
      72                 :            : 
      73         [ #  # ]:          0 :                 for (i = 0; i < dev->tim_adptr_ring_cnt; i++) {
      74         [ #  # ]:          0 :                         if (timr->ring_id != dev->timer_adptr_rings[i])
      75                 :            :                                 continue;
      76         [ #  # ]:          0 :                         if (timr->nb_timers == dev->timer_adptr_sz[i])
      77                 :            :                                 return;
      78                 :          0 :                         dev->adptr_xae_cnt -= dev->timer_adptr_sz[i];
      79                 :          0 :                         dev->adptr_xae_cnt += timr->nb_timers;
      80                 :          0 :                         dev->timer_adptr_sz[i] = timr->nb_timers;
      81                 :            : 
      82                 :          0 :                         return;
      83                 :            :                 }
      84                 :            : 
      85                 :          0 :                 dev->tim_adptr_ring_cnt++;
      86                 :          0 :                 old_ring_ptr = dev->timer_adptr_rings;
      87                 :          0 :                 old_sz_ptr = dev->timer_adptr_sz;
      88                 :            : 
      89                 :          0 :                 dev->timer_adptr_rings = rte_realloc(
      90                 :            :                         dev->timer_adptr_rings,
      91                 :          0 :                         sizeof(uint16_t) * dev->tim_adptr_ring_cnt, 0);
      92         [ #  # ]:          0 :                 if (dev->timer_adptr_rings == NULL) {
      93                 :          0 :                         dev->adptr_xae_cnt += timr->nb_timers;
      94                 :          0 :                         dev->timer_adptr_rings = old_ring_ptr;
      95                 :          0 :                         dev->tim_adptr_ring_cnt--;
      96                 :          0 :                         return;
      97                 :            :                 }
      98                 :            : 
      99                 :          0 :                 dev->timer_adptr_sz = rte_realloc(
     100                 :          0 :                         dev->timer_adptr_sz,
     101                 :          0 :                         sizeof(uint64_t) * dev->tim_adptr_ring_cnt, 0);
     102                 :            : 
     103         [ #  # ]:          0 :                 if (dev->timer_adptr_sz == NULL) {
     104                 :          0 :                         dev->adptr_xae_cnt += timr->nb_timers;
     105                 :          0 :                         dev->timer_adptr_sz = old_sz_ptr;
     106                 :          0 :                         dev->tim_adptr_ring_cnt--;
     107                 :          0 :                         return;
     108                 :            :                 }
     109                 :            : 
     110                 :          0 :                 dev->timer_adptr_rings[dev->tim_adptr_ring_cnt - 1] =
     111                 :          0 :                         timr->ring_id;
     112                 :          0 :                 dev->timer_adptr_sz[dev->tim_adptr_ring_cnt - 1] =
     113                 :          0 :                         timr->nb_timers;
     114                 :            : 
     115                 :          0 :                 dev->adptr_xae_cnt += timr->nb_timers;
     116                 :          0 :                 break;
     117                 :            :         }
     118                 :            :         default:
     119                 :            :                 break;
     120                 :            :         }
     121                 :            : }
     122                 :            : 
     123                 :            : static int
     124                 :          0 : cnxk_sso_rxq_enable(struct cnxk_eth_dev *cnxk_eth_dev, uint16_t rq_id,
     125                 :            :                     uint16_t port_id, const struct rte_event *ev,
     126                 :            :                     uint8_t custom_flowid)
     127                 :            : {
     128                 :          0 :         struct roc_nix *nix = &cnxk_eth_dev->nix;
     129                 :            :         struct roc_nix_rq *rq;
     130                 :            :         uint16_t wqe_skip;
     131                 :            :         int rc;
     132                 :            : 
     133                 :          0 :         rq = &cnxk_eth_dev->rqs[rq_id];
     134                 :          0 :         rq->sso_ena = 1;
     135                 :          0 :         rq->tt = ev->sched_type;
     136                 :          0 :         rq->hwgrp = ev->queue_id;
     137                 :          0 :         rq->flow_tag_width = 20;
     138                 :            :         wqe_skip = RTE_ALIGN_CEIL(sizeof(struct rte_mbuf), ROC_CACHE_LINE_SZ);
     139                 :            :         wqe_skip = wqe_skip / ROC_CACHE_LINE_SZ;
     140                 :          0 :         rq->wqe_skip = wqe_skip;
     141                 :          0 :         rq->tag_mask = (port_id & 0xF) << 20;
     142                 :          0 :         rq->tag_mask |= (((port_id >> 4) & 0xF) | (RTE_EVENT_TYPE_ETHDEV << 4))
     143                 :          0 :                         << 24;
     144                 :            : 
     145         [ #  # ]:          0 :         if (custom_flowid) {
     146                 :          0 :                 rq->flow_tag_width = 0;
     147                 :          0 :                 rq->tag_mask |= ev->flow_id;
     148                 :            :         }
     149                 :            : 
     150                 :          0 :         rc = roc_nix_rq_modify(&cnxk_eth_dev->nix, rq, 0);
     151         [ #  # ]:          0 :         if (rc)
     152                 :            :                 return rc;
     153                 :            : 
     154   [ #  #  #  # ]:          0 :         if (rq_id == 0 && roc_nix_inl_inb_is_enabled(nix)) {
     155                 :            :                 uint32_t sec_tag_const;
     156                 :            : 
     157                 :            :                 /* IPSec tag const is 8-bit left shifted value of tag_mask
     158                 :            :                  * as it applies to bit 32:8 of tag only.
     159                 :            :                  */
     160                 :          0 :                 sec_tag_const = rq->tag_mask >> 8;
     161                 :          0 :                 rc = roc_nix_inl_inb_tag_update(nix, sec_tag_const,
     162                 :          0 :                                                 ev->sched_type);
     163         [ #  # ]:          0 :                 if (rc)
     164                 :          0 :                         plt_err("Failed to set tag conf for ipsec, rc=%d", rc);
     165                 :            :         }
     166                 :            : 
     167                 :            :         return rc;
     168                 :            : }
     169                 :            : 
     170                 :            : static int
     171                 :            : cnxk_sso_rxq_disable(struct cnxk_eth_dev *cnxk_eth_dev, uint16_t rq_id)
     172                 :            : {
     173                 :            :         struct roc_nix_rq *rq;
     174                 :            : 
     175                 :          0 :         rq = &cnxk_eth_dev->rqs[rq_id];
     176                 :          0 :         rq->sso_ena = 0;
     177                 :          0 :         rq->flow_tag_width = 32;
     178                 :          0 :         rq->tag_mask = 0;
     179                 :            : 
     180                 :          0 :         return roc_nix_rq_modify(&cnxk_eth_dev->nix, rq, 0);
     181                 :            : }
     182                 :            : 
     183                 :            : static int
     184                 :          0 : cnxk_sso_rx_adapter_vwqe_enable(struct cnxk_eth_dev *cnxk_eth_dev,
     185                 :            :                                 uint16_t port_id, uint16_t rq_id, uint16_t sz,
     186                 :            :                                 uint64_t tmo_ns, struct rte_mempool *vmp)
     187                 :            : {
     188                 :            :         struct roc_nix_rq *rq;
     189                 :            : 
     190                 :          0 :         rq = &cnxk_eth_dev->rqs[rq_id];
     191                 :            : 
     192         [ #  # ]:          0 :         if (!rq->sso_ena)
     193                 :            :                 return -EINVAL;
     194         [ #  # ]:          0 :         if (rq->flow_tag_width == 0)
     195                 :            :                 return -EINVAL;
     196                 :            : 
     197                 :          0 :         rq->vwqe_ena = 1;
     198                 :          0 :         rq->vwqe_first_skip = 0;
     199                 :          0 :         rq->vwqe_aura_handle = vmp->pool_id;
     200         [ #  # ]:          0 :         rq->vwqe_max_sz_exp = rte_log2_u32(sz);
     201                 :          0 :         rq->vwqe_wait_tmo =
     202                 :          0 :                 tmo_ns /
     203                 :          0 :                 ((roc_nix_get_vwqe_interval(&cnxk_eth_dev->nix) + 1) * 100);
     204                 :          0 :         rq->tag_mask = (port_id & 0xF) << 20;
     205                 :          0 :         rq->tag_mask |=
     206                 :            :                 (((port_id >> 4) & 0xF) | (RTE_EVENT_TYPE_ETHDEV_VECTOR << 4))
     207                 :          0 :                 << 24;
     208                 :            : 
     209                 :          0 :         return roc_nix_rq_modify(&cnxk_eth_dev->nix, rq, 0);
     210                 :            : }
     211                 :            : 
     212                 :            : static void
     213                 :            : cnxk_sso_tstamp_cfg(uint16_t port_id, struct cnxk_eth_dev *cnxk_eth_dev,
     214                 :            :                     struct cnxk_sso_evdev *dev)
     215                 :            : {
     216                 :          0 :         if (cnxk_eth_dev->rx_offloads & RTE_ETH_RX_OFFLOAD_TIMESTAMP)
     217                 :          0 :                 dev->tstamp[port_id] = &cnxk_eth_dev->tstamp;
     218                 :            : }
     219                 :            : 
     220                 :            : int
     221                 :          0 : cnxk_sso_rx_adapter_queue_add(
     222                 :            :         const struct rte_eventdev *event_dev, const struct rte_eth_dev *eth_dev,
     223                 :            :         int32_t rx_queue_id,
     224                 :            :         const struct rte_event_eth_rx_adapter_queue_conf *queue_conf)
     225                 :            : {
     226         [ #  # ]:          0 :         struct cnxk_eth_dev *cnxk_eth_dev = eth_dev->data->dev_private;
     227                 :            :         struct cnxk_sso_evdev *dev = cnxk_sso_pmd_priv(event_dev);
     228                 :          0 :         uint16_t port = eth_dev->data->port_id;
     229                 :            :         struct cnxk_eth_rxq_sp *rxq_sp;
     230                 :            :         int i, rc = 0;
     231                 :            : 
     232         [ #  # ]:          0 :         if (rx_queue_id < 0) {
     233         [ #  # ]:          0 :                 for (i = 0; i < eth_dev->data->nb_rx_queues; i++)
     234                 :          0 :                         rc |= cnxk_sso_rx_adapter_queue_add(event_dev, eth_dev,
     235                 :            :                                                             i, queue_conf);
     236                 :            :         } else {
     237                 :          0 :                 rxq_sp = cnxk_eth_rxq_to_sp(
     238                 :          0 :                         eth_dev->data->rx_queues[rx_queue_id]);
     239                 :          0 :                 cnxk_sso_updt_xae_cnt(dev, rxq_sp, RTE_EVENT_TYPE_ETHDEV);
     240                 :          0 :                 rc = cnxk_sso_xae_reconfigure(
     241                 :            :                         (struct rte_eventdev *)(uintptr_t)event_dev);
     242                 :          0 :                 rc |= cnxk_sso_rxq_enable(
     243                 :            :                         cnxk_eth_dev, (uint16_t)rx_queue_id, port,
     244                 :            :                         &queue_conf->ev,
     245                 :          0 :                         !!(queue_conf->rx_queue_flags &
     246                 :            :                            RTE_EVENT_ETH_RX_ADAPTER_QUEUE_FLOW_ID_VALID));
     247         [ #  # ]:          0 :                 if (queue_conf->rx_queue_flags &
     248                 :            :                     RTE_EVENT_ETH_RX_ADAPTER_QUEUE_EVENT_VECTOR) {
     249                 :          0 :                         cnxk_sso_updt_xae_cnt(dev, queue_conf->vector_mp,
     250                 :            :                                               RTE_EVENT_TYPE_ETHDEV_VECTOR);
     251                 :          0 :                         rc |= cnxk_sso_xae_reconfigure(
     252                 :            :                                 (struct rte_eventdev *)(uintptr_t)event_dev);
     253                 :          0 :                         rc |= cnxk_sso_rx_adapter_vwqe_enable(
     254                 :            :                                 cnxk_eth_dev, port, rx_queue_id,
     255                 :          0 :                                 queue_conf->vector_sz,
     256                 :          0 :                                 queue_conf->vector_timeout_ns,
     257                 :          0 :                                 queue_conf->vector_mp);
     258                 :            : 
     259         [ #  # ]:          0 :                         if (cnxk_eth_dev->vec_drop_re_dis)
     260                 :          0 :                                 rc |= roc_nix_rx_drop_re_set(&cnxk_eth_dev->nix,
     261                 :            :                                                              false);
     262                 :            :                 }
     263                 :            : 
     264                 :            :                 /* Propagate force bp devarg */
     265                 :          0 :                 cnxk_eth_dev->nix.force_rx_aura_bp = dev->force_ena_bp;
     266         [ #  # ]:          0 :                 cnxk_sso_tstamp_cfg(eth_dev->data->port_id, cnxk_eth_dev, dev);
     267                 :          0 :                 cnxk_eth_dev->nb_rxq_sso++;
     268                 :            :         }
     269                 :            : 
     270         [ #  # ]:          0 :         if (rc < 0) {
     271                 :          0 :                 plt_err("Failed to configure Rx adapter port=%d, q=%d", port,
     272                 :            :                         queue_conf->ev.queue_id);
     273                 :          0 :                 return rc;
     274                 :            :         }
     275                 :            : 
     276                 :          0 :         dev->rx_offloads |= cnxk_eth_dev->rx_offload_flags;
     277                 :          0 :         return 0;
     278                 :            : }
     279                 :            : 
     280                 :            : int
     281                 :          0 : cnxk_sso_rx_adapter_queue_del(const struct rte_eventdev *event_dev,
     282                 :            :                               const struct rte_eth_dev *eth_dev,
     283                 :            :                               int32_t rx_queue_id)
     284                 :            : {
     285                 :          0 :         struct cnxk_eth_dev *cnxk_eth_dev = eth_dev->data->dev_private;
     286                 :            :         int i, rc = 0;
     287                 :            : 
     288                 :            :         RTE_SET_USED(event_dev);
     289         [ #  # ]:          0 :         if (rx_queue_id < 0) {
     290         [ #  # ]:          0 :                 for (i = 0; i < eth_dev->data->nb_rx_queues; i++)
     291                 :          0 :                         cnxk_sso_rx_adapter_queue_del(event_dev, eth_dev, i);
     292                 :            :         } else {
     293                 :          0 :                 rc = cnxk_sso_rxq_disable(cnxk_eth_dev, (uint16_t)rx_queue_id);
     294                 :          0 :                 cnxk_eth_dev->nb_rxq_sso--;
     295                 :            : 
     296                 :            :                 /* Enable drop_re if it was disabled earlier */
     297   [ #  #  #  # ]:          0 :                 if (cnxk_eth_dev->vec_drop_re_dis && !cnxk_eth_dev->nb_rxq_sso)
     298                 :          0 :                         rc |= roc_nix_rx_drop_re_set(&cnxk_eth_dev->nix, true);
     299                 :            :         }
     300                 :            : 
     301         [ #  # ]:          0 :         if (rc < 0)
     302                 :          0 :                 plt_err("Failed to clear Rx adapter config port=%d, q=%d",
     303                 :            :                         eth_dev->data->port_id, rx_queue_id);
     304                 :          0 :         return rc;
     305                 :            : }
     306                 :            : 
     307                 :            : int
     308                 :          0 : cnxk_sso_rx_adapter_start(const struct rte_eventdev *event_dev,
     309                 :            :                           const struct rte_eth_dev *eth_dev)
     310                 :            : {
     311                 :          0 :         struct cnxk_eth_dev *cnxk_eth_dev = eth_dev->data->dev_private;
     312                 :            :         struct cnxk_sso_evdev *dev = cnxk_sso_pmd_priv(event_dev);
     313                 :          0 :         dev->rx_offloads |= cnxk_eth_dev->rx_offload_flags;
     314                 :          0 :         return 0;
     315                 :            : }
     316                 :            : 
     317                 :            : int
     318                 :          0 : cnxk_sso_rx_adapter_stop(const struct rte_eventdev *event_dev,
     319                 :            :                          const struct rte_eth_dev *eth_dev)
     320                 :            : {
     321                 :            :         RTE_SET_USED(eth_dev);
     322                 :            :         struct cnxk_sso_evdev *dev = cnxk_sso_pmd_priv(event_dev);
     323                 :          0 :         dev->rx_offloads = 0;
     324                 :          0 :         return 0;
     325                 :            : }
     326                 :            : 
     327                 :            : static int
     328                 :          0 : cnxk_sso_sqb_aura_limit_edit(struct roc_nix_sq *sq, uint16_t nb_sqb_bufs)
     329                 :            : {
     330                 :            :         int rc;
     331                 :            : 
     332         [ #  # ]:          0 :         if (sq->aura_sqb_bufs != nb_sqb_bufs) {
     333                 :          0 :                 rc = roc_npa_aura_limit_modify(
     334                 :            :                         sq->aura_handle,
     335                 :          0 :                         RTE_MIN(nb_sqb_bufs, sq->aura_sqb_bufs));
     336         [ #  # ]:          0 :                 if (rc < 0)
     337                 :            :                         return rc;
     338                 :            : 
     339                 :          0 :                 sq->nb_sqb_bufs = RTE_MIN(nb_sqb_bufs, sq->aura_sqb_bufs) -
     340                 :          0 :                                   sq->roc_nix->sqb_slack;
     341                 :            :         }
     342                 :            :         return 0;
     343                 :            : }
     344                 :            : 
     345                 :            : static void
     346                 :          0 : cnxk_sso_tx_queue_data_init(struct cnxk_sso_evdev *dev, uint64_t *txq_data,
     347                 :            :                             uint16_t eth_port_id, uint16_t tx_queue_id)
     348                 :            : {
     349                 :            :         uint64_t offset = 0;
     350                 :            :         int i;
     351                 :            : 
     352                 :          0 :         dev->max_queue_id[0] = RTE_MAX(dev->max_queue_id[0], eth_port_id);
     353         [ #  # ]:          0 :         for (i = 1; i < eth_port_id; i++) {
     354                 :          0 :                 offset += (dev->max_queue_id[i - 1] + 1);
     355                 :          0 :                 txq_data[i] |= offset << 48;
     356                 :            :         }
     357                 :          0 :         dev->max_port_id = RTE_MAX(dev->max_port_id, eth_port_id);
     358                 :          0 :         dev->max_queue_id[eth_port_id] =
     359                 :          0 :                 RTE_MAX(dev->max_queue_id[eth_port_id], tx_queue_id);
     360                 :          0 : }
     361                 :            : 
     362                 :            : static void
     363                 :          0 : cnxk_sso_tx_queue_data_cpy(struct cnxk_sso_evdev *dev, uint64_t *txq_data,
     364                 :            :                            uint64_t *otxq_data, uint16_t eth_port_id)
     365                 :            : {
     366                 :            :         uint64_t offset = 0;
     367                 :            :         int i, j;
     368                 :            : 
     369         [ #  # ]:          0 :         for (i = 1; i < eth_port_id; i++) {
     370                 :          0 :                 offset += (dev->max_queue_id[i - 1] + 1);
     371                 :          0 :                 txq_data[i] |= offset << 48;
     372                 :          0 :                 for (j = 0;
     373   [ #  #  #  # ]:          0 :                      (i < dev->max_port_id) && (j < dev->max_queue_id[i] + 1);
     374                 :          0 :                      j++)
     375                 :          0 :                         txq_data[offset + j] =
     376                 :          0 :                                 otxq_data[(otxq_data[i] >> 48) + j];
     377                 :            :         }
     378                 :          0 : }
     379                 :            : 
     380                 :            : static void
     381                 :          0 : cnxk_sso_tx_queue_data_cpy_max(struct cnxk_sso_evdev *dev, uint64_t *txq_data,
     382                 :            :                                uint64_t *otxq_data, uint16_t eth_port_id,
     383                 :            :                                uint16_t max_port_id, uint16_t max_queue_id)
     384                 :            : {
     385                 :            :         uint64_t offset = 0;
     386                 :            :         int i, j;
     387                 :            : 
     388         [ #  # ]:          0 :         for (i = 1; i < max_port_id + 1; i++) {
     389                 :          0 :                 offset += (dev->max_queue_id[i - 1] + 1);
     390                 :          0 :                 txq_data[i] |= offset << 48;
     391         [ #  # ]:          0 :                 for (j = 0; j < dev->max_queue_id[i] + 1; j++) {
     392   [ #  #  #  # ]:          0 :                         if (i == eth_port_id && j > max_queue_id)
     393                 :          0 :                                 continue;
     394                 :          0 :                         txq_data[offset + j] =
     395                 :          0 :                                 otxq_data[(otxq_data[i] >> 48) + j];
     396                 :            :                 }
     397                 :            :         }
     398                 :          0 : }
     399                 :            : 
     400                 :            : static void
     401                 :          0 : cnxk_sso_tx_queue_data_rewrite(struct cnxk_sso_evdev *dev, uint64_t *txq_data,
     402                 :            :                                uint16_t eth_port_id, uint16_t tx_queue_id,
     403                 :            :                                uint64_t *otxq_data, uint16_t max_port_id,
     404                 :            :                                uint16_t max_queue_id)
     405                 :            : {
     406                 :            :         int i;
     407                 :            : 
     408         [ #  # ]:          0 :         for (i = 0; i < dev->max_queue_id[0] + 1; i++)
     409                 :          0 :                 txq_data[i] |= (otxq_data[i] & ~((BIT_ULL(16) - 1) << 48));
     410                 :            : 
     411         [ #  # ]:          0 :         if (eth_port_id > max_port_id) {
     412                 :          0 :                 dev->max_queue_id[0] =
     413                 :          0 :                         RTE_MAX(dev->max_queue_id[0], eth_port_id);
     414                 :          0 :                 dev->max_port_id = RTE_MAX(dev->max_port_id, eth_port_id);
     415                 :            : 
     416                 :          0 :                 cnxk_sso_tx_queue_data_cpy(dev, txq_data, otxq_data,
     417                 :            :                                            eth_port_id);
     418                 :          0 :                 dev->max_queue_id[eth_port_id] =
     419                 :          0 :                         RTE_MAX(dev->max_queue_id[eth_port_id], tx_queue_id);
     420         [ #  # ]:          0 :         } else if (tx_queue_id > max_queue_id) {
     421                 :          0 :                 dev->max_queue_id[eth_port_id] =
     422                 :          0 :                         RTE_MAX(dev->max_queue_id[eth_port_id], tx_queue_id);
     423                 :          0 :                 dev->max_port_id = RTE_MAX(max_port_id, eth_port_id);
     424                 :          0 :                 cnxk_sso_tx_queue_data_cpy_max(dev, txq_data, otxq_data,
     425                 :            :                                                eth_port_id, max_port_id,
     426                 :            :                                                max_queue_id);
     427                 :            :         }
     428                 :          0 : }
     429                 :            : 
     430                 :            : static void
     431                 :          0 : cnxk_sso_tx_queue_data_sz(struct cnxk_sso_evdev *dev, uint16_t eth_port_id,
     432                 :            :                           uint16_t tx_queue_id, uint16_t max_port_id,
     433                 :            :                           uint16_t max_queue_id, uint64_t *r, size_t *sz)
     434                 :            : {
     435                 :            :         uint64_t row = 0;
     436                 :            :         size_t size = 0;
     437                 :            :         int i;
     438                 :            : 
     439         [ #  # ]:          0 :         if (dev->tx_adptr_data == NULL) {
     440                 :          0 :                 size = (eth_port_id + 1);
     441                 :          0 :                 size += (eth_port_id + tx_queue_id);
     442                 :          0 :                 row = 2 * eth_port_id;
     443                 :          0 :                 *r = row;
     444                 :          0 :                 *sz = size;
     445                 :          0 :                 return;
     446                 :            :         }
     447                 :            : 
     448         [ #  # ]:          0 :         if (eth_port_id > max_port_id) {
     449                 :          0 :                 size = (RTE_MAX(eth_port_id, dev->max_queue_id[0]) + 1);
     450         [ #  # ]:          0 :                 for (i = 1; i < eth_port_id; i++)
     451                 :          0 :                         size += (dev->max_queue_id[i] + 1);
     452                 :            :                 row = size;
     453                 :          0 :                 size += (tx_queue_id + 1);
     454         [ #  # ]:          0 :         } else if (tx_queue_id > max_queue_id) {
     455                 :            :                 size = !eth_port_id ?
     456         [ #  # ]:          0 :                                tx_queue_id + 1 :
     457                 :          0 :                                      RTE_MAX(max_port_id, dev->max_queue_id[0]) + 1;
     458         [ #  # ]:          0 :                 for (i = 1; i < max_port_id + 1; i++) {
     459         [ #  # ]:          0 :                         if (i == eth_port_id) {
     460                 :            :                                 row = size;
     461                 :          0 :                                 size += tx_queue_id + 1;
     462                 :            :                         } else {
     463                 :          0 :                                 size += dev->max_queue_id[i] + 1;
     464                 :            :                         }
     465                 :            :                 }
     466                 :            :         }
     467                 :          0 :         *r = row;
     468                 :          0 :         *sz = size;
     469                 :            : }
     470                 :            : 
     471                 :            : static int
     472         [ #  # ]:          0 : cnxk_sso_updt_tx_queue_data(const struct rte_eventdev *event_dev,
     473                 :            :                             uint16_t eth_port_id, uint16_t tx_queue_id,
     474                 :            :                             void *txq)
     475                 :            : {
     476                 :            :         struct cnxk_sso_evdev *dev = cnxk_sso_pmd_priv(event_dev);
     477                 :          0 :         uint16_t max_queue_id = dev->max_queue_id[eth_port_id];
     478                 :          0 :         uint16_t max_port_id = dev->max_port_id;
     479                 :            :         uint64_t *txq_data = NULL;
     480                 :          0 :         uint64_t row = 0;
     481                 :          0 :         size_t size = 0;
     482                 :            : 
     483         [ #  # ]:          0 :         if (((uint64_t)txq) & 0xFFFF000000000000)
     484                 :            :                 return -EINVAL;
     485                 :            : 
     486                 :          0 :         cnxk_sso_tx_queue_data_sz(dev, eth_port_id, tx_queue_id, max_port_id,
     487                 :            :                                   max_queue_id, &row, &size);
     488                 :            : 
     489                 :          0 :         size *= sizeof(uint64_t);
     490                 :            : 
     491         [ #  # ]:          0 :         if (size) {
     492                 :          0 :                 uint64_t *otxq_data = dev->tx_adptr_data;
     493                 :            : 
     494                 :          0 :                 txq_data = malloc(size);
     495         [ #  # ]:          0 :                 if (txq_data == NULL)
     496                 :            :                         return -ENOMEM;
     497                 :            :                 memset(txq_data, 0, size);
     498                 :          0 :                 txq_data[eth_port_id] = ((uint64_t)row) << 48;
     499                 :          0 :                 txq_data[row + tx_queue_id] = (uint64_t)txq;
     500                 :            : 
     501         [ #  # ]:          0 :                 if (otxq_data != NULL)
     502                 :          0 :                         cnxk_sso_tx_queue_data_rewrite(
     503                 :            :                                 dev, txq_data, eth_port_id, tx_queue_id,
     504                 :            :                                 otxq_data, max_port_id, max_queue_id);
     505                 :            :                 else
     506                 :          0 :                         cnxk_sso_tx_queue_data_init(dev, txq_data, eth_port_id,
     507                 :            :                                                     tx_queue_id);
     508                 :          0 :                 dev->tx_adptr_data_sz = size;
     509                 :          0 :                 free(otxq_data);
     510                 :          0 :                 dev->tx_adptr_data = txq_data;
     511                 :            :         } else {
     512                 :          0 :                 txq_data = dev->tx_adptr_data;
     513                 :          0 :                 row = txq_data[eth_port_id] >> 48;
     514                 :          0 :                 txq_data[row + tx_queue_id] &= ~(BIT_ULL(48) - 1);
     515                 :          0 :                 txq_data[row + tx_queue_id] |= (uint64_t)txq;
     516                 :            :         }
     517                 :            : 
     518                 :            :         return 0;
     519                 :            : }
     520                 :            : 
     521                 :            : int
     522                 :          0 : cnxk_sso_tx_adapter_queue_add(const struct rte_eventdev *event_dev,
     523                 :            :                               const struct rte_eth_dev *eth_dev,
     524                 :            :                               int32_t tx_queue_id)
     525                 :            : {
     526                 :          0 :         struct cnxk_eth_dev *cnxk_eth_dev = eth_dev->data->dev_private;
     527                 :            :         struct roc_nix_sq *sq;
     528                 :            :         int i, ret = 0;
     529                 :            :         void *txq;
     530                 :            : 
     531         [ #  # ]:          0 :         if (tx_queue_id < 0) {
     532         [ #  # ]:          0 :                 for (i = 0; i < eth_dev->data->nb_tx_queues; i++)
     533                 :          0 :                         ret |= cnxk_sso_tx_adapter_queue_add(event_dev, eth_dev,
     534                 :            :                                                              i);
     535                 :            :         } else {
     536                 :          0 :                 txq = eth_dev->data->tx_queues[tx_queue_id];
     537                 :          0 :                 sq = &cnxk_eth_dev->sqs[tx_queue_id];
     538                 :          0 :                 cnxk_sso_sqb_aura_limit_edit(sq, sq->aura_sqb_bufs);
     539                 :          0 :                 ret = cnxk_sso_updt_tx_queue_data(
     540                 :          0 :                         event_dev, eth_dev->data->port_id, tx_queue_id, txq);
     541         [ #  # ]:          0 :                 if (ret < 0)
     542                 :            :                         return ret;
     543                 :            :         }
     544                 :            : 
     545         [ #  # ]:          0 :         if (ret < 0) {
     546                 :          0 :                 plt_err("Failed to configure Tx adapter port=%d, q=%d",
     547                 :            :                         eth_dev->data->port_id, tx_queue_id);
     548                 :          0 :                 return ret;
     549                 :            :         }
     550                 :            : 
     551                 :            :         return 0;
     552                 :            : }
     553                 :            : 
     554                 :            : int
     555                 :          0 : cnxk_sso_tx_adapter_queue_del(const struct rte_eventdev *event_dev,
     556                 :            :                               const struct rte_eth_dev *eth_dev,
     557                 :            :                               int32_t tx_queue_id)
     558                 :            : {
     559                 :          0 :         struct cnxk_eth_dev *cnxk_eth_dev = eth_dev->data->dev_private;
     560                 :            :         struct roc_nix_sq *sq;
     561                 :            :         int i, ret = 0;
     562                 :            : 
     563                 :            :         RTE_SET_USED(event_dev);
     564         [ #  # ]:          0 :         if (tx_queue_id < 0) {
     565         [ #  # ]:          0 :                 for (i = 0; i < eth_dev->data->nb_tx_queues; i++)
     566                 :          0 :                         ret |= cnxk_sso_tx_adapter_queue_del(event_dev, eth_dev,
     567                 :            :                                                              i);
     568                 :            :         } else {
     569                 :          0 :                 sq = &cnxk_eth_dev->sqs[tx_queue_id];
     570                 :          0 :                 cnxk_sso_sqb_aura_limit_edit(sq, sq->aura_sqb_bufs);
     571                 :          0 :                 ret = cnxk_sso_updt_tx_queue_data(
     572                 :          0 :                         event_dev, eth_dev->data->port_id, tx_queue_id, NULL);
     573         [ #  # ]:          0 :                 if (ret < 0)
     574                 :            :                         return ret;
     575                 :            :         }
     576                 :            : 
     577         [ #  # ]:          0 :         if (ret < 0) {
     578                 :          0 :                 plt_err("Failed to clear Tx adapter config port=%d, q=%d",
     579                 :            :                         eth_dev->data->port_id, tx_queue_id);
     580                 :          0 :                 return ret;
     581                 :            :         }
     582                 :            : 
     583                 :            :         return 0;
     584                 :            : }
     585                 :            : 
     586                 :            : int
     587                 :          0 : cnxk_sso_tx_adapter_start(uint8_t id, const struct rte_eventdev *event_dev)
     588                 :            : {
     589                 :            :         struct cnxk_sso_evdev *dev = cnxk_sso_pmd_priv(event_dev);
     590                 :            : 
     591                 :          0 :         dev->tx_adptr_active_mask |= (1 << id);
     592                 :            : 
     593                 :          0 :         return 0;
     594                 :            : }
     595                 :            : 
     596                 :            : int
     597                 :          0 : cnxk_sso_tx_adapter_stop(uint8_t id, const struct rte_eventdev *event_dev)
     598                 :            : {
     599                 :            :         struct cnxk_sso_evdev *dev = cnxk_sso_pmd_priv(event_dev);
     600                 :            : 
     601                 :          0 :         dev->tx_adptr_active_mask &= ~(1 << id);
     602                 :            : 
     603                 :          0 :         return 0;
     604                 :            : }
     605                 :            : 
     606                 :            : int
     607         [ #  # ]:          0 : cnxk_sso_tx_adapter_free(uint8_t id __rte_unused,
     608                 :            :                          const struct rte_eventdev *event_dev)
     609                 :            : {
     610                 :            :         struct cnxk_sso_evdev *dev = cnxk_sso_pmd_priv(event_dev);
     611                 :            : 
     612   [ #  #  #  # ]:          0 :         if (dev->tx_adptr_data_sz && dev->tx_adptr_active_mask == 0) {
     613                 :          0 :                 dev->tx_adptr_data_sz = 0;
     614                 :          0 :                 free(dev->tx_adptr_data);
     615                 :          0 :                 dev->tx_adptr_data = NULL;
     616                 :            :         }
     617                 :            : 
     618                 :          0 :         return 0;
     619                 :            : }
     620                 :            : 
     621                 :            : static int
     622         [ #  # ]:          0 : crypto_adapter_qp_setup(const struct rte_cryptodev *cdev, struct cnxk_cpt_qp *qp,
     623                 :            :                         const struct rte_event_crypto_adapter_queue_conf *conf)
     624                 :            : {
     625                 :            :         char name[RTE_MEMPOOL_NAMESIZE];
     626                 :            :         uint32_t cache_size, nb_req;
     627                 :            :         unsigned int req_size;
     628                 :            :         uint32_t nb_desc_min;
     629                 :            : 
     630                 :            :         /*
     631                 :            :          * Update CPT FC threshold. Decrement by hardware burst size to allow
     632                 :            :          * simultaneous enqueue from all available cores.
     633                 :            :          */
     634         [ #  # ]:          0 :         if (roc_model_is_cn10k())
     635                 :          0 :                 nb_desc_min = rte_lcore_count() * 32;
     636                 :            :         else
     637                 :          0 :                 nb_desc_min = rte_lcore_count() * 2;
     638                 :            : 
     639         [ #  # ]:          0 :         if (qp->lmtline.fc_thresh < nb_desc_min) {
     640                 :          0 :                 plt_err("CPT queue depth not sufficient to allow enqueueing from %d cores",
     641                 :            :                         rte_lcore_count());
     642                 :          0 :                 return -ENOSPC;
     643                 :            :         }
     644                 :            : 
     645                 :          0 :         qp->lmtline.fc_thresh -= nb_desc_min;
     646                 :            : 
     647         [ #  # ]:          0 :         snprintf(name, RTE_MEMPOOL_NAMESIZE, "cnxk_ca_req_%u:%u", cdev->data->dev_id, qp->lf.lf_id);
     648                 :            :         req_size = sizeof(struct cpt_inflight_req);
     649         [ #  # ]:          0 :         cache_size = RTE_MIN(RTE_MEMPOOL_CACHE_MAX_SIZE, qp->lf.nb_desc / 1.5);
     650                 :          0 :         nb_req = RTE_MAX(qp->lf.nb_desc, cache_size * rte_lcore_count());
     651                 :          0 :         qp->ca.req_mp = rte_mempool_create(name, nb_req, req_size, cache_size, 0, NULL, NULL, NULL,
     652                 :          0 :                                            NULL, rte_socket_id(), 0);
     653         [ #  # ]:          0 :         if (qp->ca.req_mp == NULL)
     654                 :            :                 return -ENOMEM;
     655                 :            : 
     656         [ #  # ]:          0 :         if (conf != NULL) {
     657                 :          0 :                 qp->ca.vector_sz = conf->vector_sz;
     658                 :          0 :                 qp->ca.vector_mp = conf->vector_mp;
     659                 :            :         }
     660                 :          0 :         qp->ca.enabled = true;
     661                 :            : 
     662                 :          0 :         return 0;
     663                 :            : }
     664                 :            : 
     665                 :            : int
     666         [ #  # ]:          0 : cnxk_crypto_adapter_qp_add(const struct rte_eventdev *event_dev, const struct rte_cryptodev *cdev,
     667                 :            :                            int32_t queue_pair_id,
     668                 :            :                            const struct rte_event_crypto_adapter_queue_conf *conf)
     669                 :            : {
     670                 :            :         struct cnxk_sso_evdev *sso_evdev = cnxk_sso_pmd_priv(event_dev);
     671                 :            :         uint32_t adptr_xae_cnt = 0;
     672                 :            :         struct cnxk_cpt_qp *qp;
     673                 :            :         int ret;
     674                 :            : 
     675         [ #  # ]:          0 :         if (queue_pair_id == -1) {
     676                 :            :                 uint16_t qp_id;
     677                 :            : 
     678         [ #  # ]:          0 :                 for (qp_id = 0; qp_id < cdev->data->nb_queue_pairs; qp_id++) {
     679                 :          0 :                         qp = cdev->data->queue_pairs[qp_id];
     680                 :          0 :                         ret = crypto_adapter_qp_setup(cdev, qp, conf);
     681         [ #  # ]:          0 :                         if (ret) {
     682                 :          0 :                                 cnxk_crypto_adapter_qp_del(cdev, -1);
     683                 :          0 :                                 return ret;
     684                 :            :                         }
     685                 :          0 :                         adptr_xae_cnt += qp->ca.req_mp->size;
     686                 :            :                 }
     687                 :            :         } else {
     688                 :          0 :                 qp = cdev->data->queue_pairs[queue_pair_id];
     689                 :          0 :                 ret = crypto_adapter_qp_setup(cdev, qp, conf);
     690         [ #  # ]:          0 :                 if (ret)
     691                 :            :                         return ret;
     692                 :          0 :                 adptr_xae_cnt = qp->ca.req_mp->size;
     693                 :            :         }
     694                 :            : 
     695                 :            :         /* Update crypto adapter XAE count */
     696                 :          0 :         sso_evdev->adptr_xae_cnt += adptr_xae_cnt;
     697                 :          0 :         cnxk_sso_xae_reconfigure((struct rte_eventdev *)(uintptr_t)event_dev);
     698                 :            : 
     699                 :          0 :         return 0;
     700                 :            : }
     701                 :            : 
     702                 :            : static int
     703                 :          0 : crypto_adapter_qp_free(struct cnxk_cpt_qp *qp)
     704                 :            : {
     705                 :            :         int ret;
     706                 :            : 
     707                 :          0 :         rte_mempool_free(qp->ca.req_mp);
     708                 :          0 :         qp->ca.enabled = false;
     709                 :            : 
     710                 :          0 :         ret = roc_cpt_lmtline_init(qp->lf.roc_cpt, &qp->lmtline, qp->lf.lf_id);
     711         [ #  # ]:          0 :         if (ret < 0) {
     712                 :          0 :                 plt_err("Could not reset lmtline for queue pair %d", qp->lf.lf_id);
     713                 :          0 :                 return ret;
     714                 :            :         }
     715                 :            : 
     716                 :            :         return 0;
     717                 :            : }
     718                 :            : 
     719                 :            : int
     720                 :          0 : cnxk_crypto_adapter_qp_del(const struct rte_cryptodev *cdev,
     721                 :            :                            int32_t queue_pair_id)
     722                 :            : {
     723                 :            :         struct cnxk_cpt_qp *qp;
     724                 :            : 
     725         [ #  # ]:          0 :         if (queue_pair_id == -1) {
     726                 :            :                 uint16_t qp_id;
     727                 :            : 
     728         [ #  # ]:          0 :                 for (qp_id = 0; qp_id < cdev->data->nb_queue_pairs; qp_id++) {
     729                 :          0 :                         qp = cdev->data->queue_pairs[qp_id];
     730         [ #  # ]:          0 :                         if (qp->ca.enabled)
     731                 :          0 :                                 crypto_adapter_qp_free(qp);
     732                 :            :                 }
     733                 :            :         } else {
     734                 :          0 :                 qp = cdev->data->queue_pairs[queue_pair_id];
     735         [ #  # ]:          0 :                 if (qp->ca.enabled)
     736                 :          0 :                         crypto_adapter_qp_free(qp);
     737                 :            :         }
     738                 :            : 
     739                 :          0 :         return 0;
     740                 :            : }
     741                 :            : 
     742                 :            : static int
     743                 :          0 : dma_adapter_vchan_setup(const int16_t dma_dev_id, struct cnxk_dpi_conf *vchan,
     744                 :            :                         uint16_t vchan_id)
     745                 :            : {
     746                 :            :         char name[RTE_MEMPOOL_NAMESIZE];
     747                 :            :         uint32_t cache_size, nb_req;
     748                 :            :         unsigned int req_size;
     749                 :            : 
     750                 :          0 :         snprintf(name, RTE_MEMPOOL_NAMESIZE, "cnxk_dma_req_%u:%u", dma_dev_id, vchan_id);
     751                 :            :         req_size = sizeof(struct cnxk_dpi_compl_s);
     752                 :            : 
     753                 :          0 :         nb_req = vchan->c_desc.max_cnt;
     754                 :            :         cache_size = 16;
     755                 :          0 :         nb_req += (cache_size * rte_lcore_count());
     756                 :            : 
     757                 :          0 :         vchan->adapter_info.req_mp = rte_mempool_create(name, nb_req, req_size, cache_size, 0,
     758                 :          0 :                                                         NULL, NULL, NULL, NULL, rte_socket_id(), 0);
     759         [ #  # ]:          0 :         if (vchan->adapter_info.req_mp == NULL)
     760                 :            :                 return -ENOMEM;
     761                 :            : 
     762                 :          0 :         vchan->adapter_info.enabled = true;
     763                 :            : 
     764                 :          0 :         return 0;
     765                 :            : }
     766                 :            : 
     767                 :            : int
     768         [ #  # ]:          0 : cnxk_dma_adapter_vchan_add(const struct rte_eventdev *event_dev,
     769                 :            :                            const int16_t dma_dev_id, uint16_t vchan_id)
     770                 :            : {
     771                 :            :         struct cnxk_sso_evdev *sso_evdev = cnxk_sso_pmd_priv(event_dev);
     772                 :            :         uint32_t adptr_xae_cnt = 0;
     773                 :            :         struct cnxk_dpi_vf_s *dpivf;
     774                 :            :         struct cnxk_dpi_conf *vchan;
     775                 :            :         int ret;
     776                 :            : 
     777                 :          0 :         dpivf = rte_dma_fp_objs[dma_dev_id].dev_private;
     778         [ #  # ]:          0 :         if ((int16_t)vchan_id == -1) {
     779                 :            :                 uint16_t vchan_id;
     780                 :            : 
     781         [ #  # ]:          0 :                 for (vchan_id = 0; vchan_id < dpivf->num_vchans; vchan_id++) {
     782                 :          0 :                         vchan = &dpivf->conf[vchan_id];
     783                 :          0 :                         ret = dma_adapter_vchan_setup(dma_dev_id, vchan, vchan_id);
     784         [ #  # ]:          0 :                         if (ret) {
     785                 :          0 :                                 cnxk_dma_adapter_vchan_del(dma_dev_id, -1);
     786                 :          0 :                                 return ret;
     787                 :            :                         }
     788                 :          0 :                         adptr_xae_cnt += vchan->adapter_info.req_mp->size;
     789                 :            :                 }
     790                 :            :         } else {
     791                 :          0 :                 vchan = &dpivf->conf[vchan_id];
     792                 :          0 :                 ret = dma_adapter_vchan_setup(dma_dev_id, vchan, vchan_id);
     793         [ #  # ]:          0 :                 if (ret)
     794                 :            :                         return ret;
     795                 :          0 :                 adptr_xae_cnt = vchan->adapter_info.req_mp->size;
     796                 :            :         }
     797                 :            : 
     798                 :            :         /* Update dma adapter XAE count */
     799                 :          0 :         sso_evdev->adptr_xae_cnt += adptr_xae_cnt;
     800                 :          0 :         cnxk_sso_xae_reconfigure((struct rte_eventdev *)(uintptr_t)event_dev);
     801                 :            : 
     802                 :          0 :         return 0;
     803                 :            : }
     804                 :            : 
     805                 :            : static int
     806                 :            : dma_adapter_vchan_free(struct cnxk_dpi_conf *vchan)
     807                 :            : {
     808                 :          0 :         rte_mempool_free(vchan->adapter_info.req_mp);
     809                 :          0 :         vchan->adapter_info.enabled = false;
     810                 :            : 
     811                 :          0 :         return 0;
     812                 :            : }
     813                 :            : 
     814                 :            : int
     815                 :          0 : cnxk_dma_adapter_vchan_del(const int16_t dma_dev_id, uint16_t vchan_id)
     816                 :            : {
     817                 :            :         struct cnxk_dpi_vf_s *dpivf;
     818                 :            :         struct cnxk_dpi_conf *vchan;
     819                 :            : 
     820                 :          0 :         dpivf = rte_dma_fp_objs[dma_dev_id].dev_private;
     821         [ #  # ]:          0 :         if ((int16_t)vchan_id == -1) {
     822                 :            :                 uint16_t vchan_id;
     823                 :            : 
     824         [ #  # ]:          0 :                 for (vchan_id = 0; vchan_id < dpivf->num_vchans; vchan_id++) {
     825                 :          0 :                         vchan = &dpivf->conf[vchan_id];
     826         [ #  # ]:          0 :                         if (vchan->adapter_info.enabled)
     827                 :            :                                 dma_adapter_vchan_free(vchan);
     828                 :            :                 }
     829                 :            :         } else {
     830                 :          0 :                 vchan = &dpivf->conf[vchan_id];
     831         [ #  # ]:          0 :                 if (vchan->adapter_info.enabled)
     832                 :            :                         dma_adapter_vchan_free(vchan);
     833                 :            :         }
     834                 :            : 
     835                 :          0 :         return 0;
     836                 :            : }

Generated by: LCOV version 1.14