LCOV - code coverage report
Current view: top level - lib/dmadev - rte_dmadev.c (source / functions) Hit Total Coverage
Test: Code coverage Lines: 118 455 25.9 %
Date: 2024-04-01 19:00:53 Functions: 15 42 35.7 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 50 364 13.7 %

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  * Copyright(c) 2021 HiSilicon Limited
       3                 :            :  * Copyright(c) 2021 Intel Corporation
       4                 :            :  */
       5                 :            : 
       6                 :            : #include <ctype.h>
       7                 :            : #include <inttypes.h>
       8                 :            : #include <stdlib.h>
       9                 :            : 
      10                 :            : #include <rte_eal.h>
      11                 :            : #include <rte_lcore.h>
      12                 :            : #include <rte_log.h>
      13                 :            : #include <rte_malloc.h>
      14                 :            : #include <rte_memzone.h>
      15                 :            : #include <rte_string_fns.h>
      16                 :            : #include <rte_telemetry.h>
      17                 :            : 
      18                 :            : #include "rte_dmadev.h"
      19                 :            : #include "rte_dmadev_pmd.h"
      20                 :            : #include "rte_dmadev_trace.h"
      21                 :            : 
      22                 :            : static int16_t dma_devices_max;
      23                 :            : 
      24                 :            : struct rte_dma_fp_object *rte_dma_fp_objs;
      25                 :            : static struct rte_dma_dev *rte_dma_devices;
      26                 :            : static struct {
      27                 :            :         /* Hold the dev_max information of the primary process. This field is
      28                 :            :          * set by the primary process and is read by the secondary process.
      29                 :            :          */
      30                 :            :         int16_t dev_max;
      31                 :            :         struct rte_dma_dev_data data[0];
      32                 :            : } *dma_devices_shared_data;
      33                 :            : 
      34         [ -  + ]:        238 : RTE_LOG_REGISTER_DEFAULT(rte_dma_logtype, INFO);
      35                 :            : #define RTE_LOGTYPE_DMADEV rte_dma_logtype
      36                 :            : 
      37                 :            : #define RTE_DMA_LOG(level, ...) \
      38                 :            :         RTE_LOG_LINE(level, DMADEV, "" __VA_ARGS__)
      39                 :            : 
      40                 :            : int
      41                 :          0 : rte_dma_dev_max(size_t dev_max)
      42                 :            : {
      43                 :            :         /* This function may be called before rte_eal_init(), so no rte library
      44                 :            :          * function can be called in this function.
      45                 :            :          */
      46         [ #  # ]:          0 :         if (dev_max == 0 || dev_max > INT16_MAX)
      47                 :            :                 return -EINVAL;
      48                 :            : 
      49         [ #  # ]:          0 :         if (dma_devices_max > 0)
      50                 :            :                 return -EINVAL;
      51                 :            : 
      52                 :          0 :         dma_devices_max = dev_max;
      53                 :            : 
      54                 :          0 :         return 0;
      55                 :            : }
      56                 :            : 
      57                 :            : int16_t
      58                 :          0 : rte_dma_next_dev(int16_t start_dev_id)
      59                 :            : {
      60                 :            :         int16_t dev_id = start_dev_id;
      61   [ #  #  #  # ]:          0 :         while (dev_id < dma_devices_max && rte_dma_devices[dev_id].state == RTE_DMA_DEV_UNUSED)
      62                 :          0 :                 dev_id++;
      63                 :            : 
      64         [ #  # ]:          0 :         if (dev_id < dma_devices_max)
      65                 :          0 :                 return dev_id;
      66                 :            : 
      67                 :            :         return -1;
      68                 :            : }
      69                 :            : 
      70                 :            : static int
      71                 :          2 : dma_check_name(const char *name)
      72                 :            : {
      73                 :            :         size_t name_len;
      74                 :            : 
      75         [ -  + ]:          2 :         if (name == NULL) {
      76                 :          0 :                 RTE_DMA_LOG(ERR, "Name can't be NULL");
      77                 :          0 :                 return -EINVAL;
      78                 :            :         }
      79                 :            : 
      80                 :          2 :         name_len = strnlen(name, RTE_DEV_NAME_MAX_LEN);
      81         [ -  + ]:          2 :         if (name_len == 0) {
      82                 :          0 :                 RTE_DMA_LOG(ERR, "Zero length DMA device name");
      83                 :          0 :                 return -EINVAL;
      84                 :            :         }
      85         [ -  + ]:          2 :         if (name_len >= RTE_DEV_NAME_MAX_LEN) {
      86                 :          0 :                 RTE_DMA_LOG(ERR, "DMA device name is too long");
      87                 :          0 :                 return -EINVAL;
      88                 :            :         }
      89                 :            : 
      90                 :            :         return 0;
      91                 :            : }
      92                 :            : 
      93                 :            : static int16_t
      94                 :            : dma_find_free_id(void)
      95                 :            : {
      96                 :            :         int16_t i;
      97                 :            : 
      98   [ +  -  +  - ]:          1 :         if (rte_dma_devices == NULL || dma_devices_shared_data == NULL)
      99                 :            :                 return -1;
     100                 :            : 
     101         [ +  - ]:          1 :         for (i = 0; i < dma_devices_max; i++) {
     102         [ -  + ]:          1 :                 if (dma_devices_shared_data->data[i].dev_name[0] == '\0')
     103                 :            :                         return i;
     104                 :            :         }
     105                 :            : 
     106                 :            :         return -1;
     107                 :            : }
     108                 :            : 
     109                 :            : static struct rte_dma_dev*
     110                 :          2 : dma_find_by_name(const char *name)
     111                 :            : {
     112                 :            :         int16_t i;
     113                 :            : 
     114         [ +  - ]:          2 :         if (rte_dma_devices == NULL)
     115                 :            :                 return NULL;
     116                 :            : 
     117         [ +  + ]:         66 :         for (i = 0; i < dma_devices_max; i++) {
     118         [ +  + ]:         65 :                 if ((rte_dma_devices[i].state != RTE_DMA_DEV_UNUSED) &&
     119         [ +  - ]:          1 :                     (!strcmp(name, rte_dma_devices[i].data->dev_name)))
     120                 :          1 :                         return &rte_dma_devices[i];
     121                 :            :         }
     122                 :            : 
     123                 :            :         return NULL;
     124                 :            : }
     125                 :            : 
     126                 :            : static void dma_fp_object_dummy(struct rte_dma_fp_object *obj);
     127                 :            : 
     128                 :            : static int
     129                 :          1 : dma_fp_data_prepare(void)
     130                 :            : {
     131                 :            :         size_t size;
     132                 :            :         void *ptr;
     133                 :            :         int i;
     134                 :            : 
     135         [ +  - ]:          1 :         if (rte_dma_fp_objs != NULL)
     136                 :            :                 return 0;
     137                 :            : 
     138                 :            :         /* Fast-path object must align cacheline, but the return value of malloc
     139                 :            :          * may not be aligned to the cache line. Therefore, extra memory is
     140                 :            :          * applied for realignment.
     141                 :            :          * note: We do not call posix_memalign/aligned_alloc because it is
     142                 :            :          * version dependent on libc.
     143                 :            :          */
     144                 :          1 :         size = dma_devices_max * sizeof(struct rte_dma_fp_object) +
     145                 :            :                 RTE_CACHE_LINE_SIZE;
     146                 :          1 :         ptr = malloc(size);
     147         [ +  - ]:          1 :         if (ptr == NULL)
     148                 :            :                 return -ENOMEM;
     149                 :            :         memset(ptr, 0, size);
     150                 :            : 
     151                 :          1 :         rte_dma_fp_objs = RTE_PTR_ALIGN(ptr, RTE_CACHE_LINE_SIZE);
     152         [ +  + ]:         65 :         for (i = 0; i < dma_devices_max; i++)
     153                 :         64 :                 dma_fp_object_dummy(&rte_dma_fp_objs[i]);
     154                 :            : 
     155                 :            :         return 0;
     156                 :            : }
     157                 :            : 
     158                 :            : static int
     159                 :          1 : dma_dev_data_prepare(void)
     160                 :            : {
     161                 :            :         size_t size;
     162                 :            : 
     163         [ +  - ]:          1 :         if (rte_dma_devices != NULL)
     164                 :            :                 return 0;
     165                 :            : 
     166                 :          1 :         size = dma_devices_max * sizeof(struct rte_dma_dev);
     167                 :          1 :         rte_dma_devices = malloc(size);
     168         [ +  - ]:          1 :         if (rte_dma_devices == NULL)
     169                 :            :                 return -ENOMEM;
     170                 :            :         memset(rte_dma_devices, 0, size);
     171                 :            : 
     172                 :          1 :         return 0;
     173                 :            : }
     174                 :            : 
     175                 :            : static int
     176                 :          1 : dma_shared_data_prepare(void)
     177                 :            : {
     178                 :            :         const char *mz_name = "rte_dma_dev_data";
     179                 :            :         const struct rte_memzone *mz;
     180                 :            :         size_t size;
     181                 :            : 
     182         [ +  - ]:          1 :         if (dma_devices_shared_data != NULL)
     183                 :            :                 return 0;
     184                 :            : 
     185                 :          1 :         size = sizeof(*dma_devices_shared_data) +
     186                 :          1 :                 sizeof(struct rte_dma_dev_data) * dma_devices_max;
     187                 :            : 
     188         [ +  - ]:          1 :         if (rte_eal_process_type() == RTE_PROC_PRIMARY)
     189                 :          1 :                 mz = rte_memzone_reserve(mz_name, size, rte_socket_id(), 0);
     190                 :            :         else
     191                 :          0 :                 mz = rte_memzone_lookup(mz_name);
     192         [ +  - ]:          1 :         if (mz == NULL)
     193                 :            :                 return -ENOMEM;
     194                 :            : 
     195                 :          1 :         dma_devices_shared_data = mz->addr;
     196         [ +  - ]:          1 :         if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
     197                 :          1 :                 memset(dma_devices_shared_data, 0, size);
     198                 :          1 :                 dma_devices_shared_data->dev_max = dma_devices_max;
     199                 :            :         } else {
     200                 :          0 :                 dma_devices_max = dma_devices_shared_data->dev_max;
     201                 :            :         }
     202                 :            : 
     203                 :            :         return 0;
     204                 :            : }
     205                 :            : 
     206                 :            : static int
     207                 :          1 : dma_data_prepare(void)
     208                 :            : {
     209                 :            :         int ret;
     210                 :            : 
     211         [ +  - ]:          1 :         if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
     212         [ +  - ]:          1 :                 if (dma_devices_max == 0)
     213                 :          1 :                         dma_devices_max = RTE_DMADEV_DEFAULT_MAX;
     214                 :          1 :                 ret = dma_fp_data_prepare();
     215         [ +  - ]:          1 :                 if (ret)
     216                 :            :                         return ret;
     217                 :          1 :                 ret = dma_dev_data_prepare();
     218         [ +  - ]:          1 :                 if (ret)
     219                 :            :                         return ret;
     220                 :          1 :                 ret = dma_shared_data_prepare();
     221         [ -  + ]:          1 :                 if (ret)
     222                 :          0 :                         return ret;
     223                 :            :         } else {
     224                 :          0 :                 ret = dma_shared_data_prepare();
     225         [ #  # ]:          0 :                 if (ret)
     226                 :            :                         return ret;
     227                 :          0 :                 ret = dma_fp_data_prepare();
     228         [ #  # ]:          0 :                 if (ret)
     229                 :            :                         return ret;
     230                 :          0 :                 ret = dma_dev_data_prepare();
     231         [ #  # ]:          0 :                 if (ret)
     232                 :          0 :                         return ret;
     233                 :            :         }
     234                 :            : 
     235                 :            :         return 0;
     236                 :            : }
     237                 :            : 
     238                 :            : static struct rte_dma_dev *
     239                 :          1 : dma_allocate_primary(const char *name, int numa_node, size_t private_data_size)
     240                 :            : {
     241                 :            :         struct rte_dma_dev *dev;
     242                 :            :         void *dev_private;
     243                 :            :         int16_t dev_id;
     244                 :            :         int ret;
     245                 :            : 
     246                 :          1 :         ret = dma_data_prepare();
     247         [ -  + ]:          1 :         if (ret < 0) {
     248                 :          0 :                 RTE_DMA_LOG(ERR, "Cannot initialize dmadevs data");
     249                 :          0 :                 return NULL;
     250                 :            :         }
     251                 :            : 
     252                 :          1 :         dev = dma_find_by_name(name);
     253         [ -  + ]:          1 :         if (dev != NULL) {
     254                 :          0 :                 RTE_DMA_LOG(ERR, "DMA device already allocated");
     255                 :          0 :                 return NULL;
     256                 :            :         }
     257                 :            : 
     258                 :          1 :         dev_private = rte_zmalloc_socket(name, private_data_size,
     259                 :            :                                          RTE_CACHE_LINE_SIZE, numa_node);
     260         [ -  + ]:          1 :         if (dev_private == NULL) {
     261                 :          0 :                 RTE_DMA_LOG(ERR, "Cannot allocate private data");
     262                 :          0 :                 return NULL;
     263                 :            :         }
     264                 :            : 
     265                 :            :         dev_id = dma_find_free_id();
     266         [ -  + ]:          1 :         if (dev_id < 0) {
     267                 :          0 :                 RTE_DMA_LOG(ERR, "Reached maximum number of DMA devices");
     268                 :          0 :                 rte_free(dev_private);
     269                 :          0 :                 return NULL;
     270                 :            :         }
     271                 :            : 
     272                 :          1 :         dev = &rte_dma_devices[dev_id];
     273                 :          1 :         dev->data = &dma_devices_shared_data->data[dev_id];
     274                 :          1 :         rte_strscpy(dev->data->dev_name, name, sizeof(dev->data->dev_name));
     275                 :          1 :         dev->data->dev_id = dev_id;
     276                 :          1 :         dev->data->numa_node = numa_node;
     277                 :          1 :         dev->data->dev_private = dev_private;
     278                 :            : 
     279                 :          1 :         return dev;
     280                 :            : }
     281                 :            : 
     282                 :            : static struct rte_dma_dev *
     283                 :          0 : dma_attach_secondary(const char *name)
     284                 :            : {
     285                 :            :         struct rte_dma_dev *dev;
     286                 :            :         int16_t i;
     287                 :            :         int ret;
     288                 :            : 
     289                 :          0 :         ret = dma_data_prepare();
     290         [ #  # ]:          0 :         if (ret < 0) {
     291                 :          0 :                 RTE_DMA_LOG(ERR, "Cannot initialize dmadevs data");
     292                 :          0 :                 return NULL;
     293                 :            :         }
     294                 :            : 
     295         [ #  # ]:          0 :         for (i = 0; i < dma_devices_max; i++) {
     296         [ #  # ]:          0 :                 if (!strcmp(dma_devices_shared_data->data[i].dev_name, name))
     297                 :            :                         break;
     298                 :            :         }
     299         [ #  # ]:          0 :         if (i == dma_devices_max) {
     300                 :          0 :                 RTE_DMA_LOG(ERR,
     301                 :            :                         "Device %s is not driven by the primary process",
     302                 :            :                         name);
     303                 :          0 :                 return NULL;
     304                 :            :         }
     305                 :            : 
     306                 :          0 :         dev = &rte_dma_devices[i];
     307                 :          0 :         dev->data = &dma_devices_shared_data->data[i];
     308                 :            : 
     309                 :          0 :         return dev;
     310                 :            : }
     311                 :            : 
     312                 :            : static struct rte_dma_dev *
     313                 :          1 : dma_allocate(const char *name, int numa_node, size_t private_data_size)
     314                 :            : {
     315                 :            :         struct rte_dma_dev *dev;
     316                 :            : 
     317         [ +  - ]:          1 :         if (rte_eal_process_type() == RTE_PROC_PRIMARY)
     318                 :          1 :                 dev = dma_allocate_primary(name, numa_node, private_data_size);
     319                 :            :         else
     320                 :          0 :                 dev = dma_attach_secondary(name);
     321                 :            : 
     322         [ +  - ]:          1 :         if (dev) {
     323                 :          1 :                 dev->fp_obj = &rte_dma_fp_objs[dev->data->dev_id];
     324                 :            :                 dma_fp_object_dummy(dev->fp_obj);
     325                 :            :         }
     326                 :            : 
     327                 :          1 :         return dev;
     328                 :            : }
     329                 :            : 
     330                 :            : static void
     331                 :          1 : dma_release(struct rte_dma_dev *dev)
     332                 :            : {
     333         [ +  - ]:          1 :         if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
     334                 :          1 :                 rte_free(dev->data->dev_private);
     335                 :          1 :                 memset(dev->data, 0, sizeof(struct rte_dma_dev_data));
     336                 :            :         }
     337                 :            : 
     338                 :          1 :         dma_fp_object_dummy(dev->fp_obj);
     339                 :            :         memset(dev, 0, sizeof(struct rte_dma_dev));
     340                 :          1 : }
     341                 :            : 
     342                 :            : struct rte_dma_dev *
     343                 :          1 : rte_dma_pmd_allocate(const char *name, int numa_node, size_t private_data_size)
     344                 :            : {
     345                 :            :         struct rte_dma_dev *dev;
     346                 :            : 
     347   [ +  -  +  - ]:          1 :         if (dma_check_name(name) != 0 || private_data_size == 0)
     348                 :            :                 return NULL;
     349                 :            : 
     350                 :          1 :         dev = dma_allocate(name, numa_node, private_data_size);
     351         [ +  - ]:          1 :         if (dev == NULL)
     352                 :            :                 return NULL;
     353                 :            : 
     354                 :          1 :         dev->state = RTE_DMA_DEV_REGISTERED;
     355                 :            : 
     356                 :          1 :         return dev;
     357                 :            : }
     358                 :            : 
     359                 :            : int
     360                 :          1 : rte_dma_pmd_release(const char *name)
     361                 :            : {
     362                 :            :         struct rte_dma_dev *dev;
     363                 :            : 
     364         [ +  - ]:          1 :         if (dma_check_name(name) != 0)
     365                 :            :                 return -EINVAL;
     366                 :            : 
     367                 :          1 :         dev = dma_find_by_name(name);
     368         [ +  - ]:          1 :         if (dev == NULL)
     369                 :            :                 return -EINVAL;
     370                 :            : 
     371         [ +  - ]:          1 :         if (dev->state == RTE_DMA_DEV_READY)
     372                 :          1 :                 return rte_dma_close(dev->data->dev_id);
     373                 :            : 
     374                 :          0 :         dma_release(dev);
     375                 :          0 :         return 0;
     376                 :            : }
     377                 :            : 
     378                 :            : int
     379                 :          0 : rte_dma_get_dev_id_by_name(const char *name)
     380                 :            : {
     381                 :            :         struct rte_dma_dev *dev;
     382                 :            : 
     383         [ #  # ]:          0 :         if (dma_check_name(name) != 0)
     384                 :            :                 return -EINVAL;
     385                 :            : 
     386                 :          0 :         dev = dma_find_by_name(name);
     387         [ #  # ]:          0 :         if (dev == NULL)
     388                 :            :                 return -EINVAL;
     389                 :            : 
     390                 :          0 :         return dev->data->dev_id;
     391                 :            : }
     392                 :            : 
     393                 :            : bool
     394                 :          1 : rte_dma_is_valid(int16_t dev_id)
     395                 :            : {
     396         [ +  - ]:          1 :         return (dev_id >= 0) && (dev_id < dma_devices_max) &&
     397   [ +  -  +  - ]:          2 :                 rte_dma_devices != NULL &&
     398         [ -  + ]:          1 :                 rte_dma_devices[dev_id].state != RTE_DMA_DEV_UNUSED;
     399                 :            : }
     400                 :            : 
     401                 :            : struct rte_dma_dev *
     402                 :          0 : rte_dma_pmd_get_dev_by_id(int16_t dev_id)
     403                 :            : {
     404         [ #  # ]:          0 :         if (!rte_dma_is_valid(dev_id))
     405                 :            :                 return NULL;
     406                 :            : 
     407                 :          0 :         return &rte_dma_devices[dev_id];
     408                 :            : }
     409                 :            : 
     410                 :            : uint16_t
     411                 :          0 : rte_dma_count_avail(void)
     412                 :            : {
     413                 :            :         uint16_t count = 0;
     414                 :            :         uint16_t i;
     415                 :            : 
     416         [ #  # ]:          0 :         if (rte_dma_devices == NULL)
     417                 :            :                 return count;
     418                 :            : 
     419         [ #  # ]:          0 :         for (i = 0; i < dma_devices_max; i++) {
     420         [ #  # ]:          0 :                 if (rte_dma_devices[i].state != RTE_DMA_DEV_UNUSED)
     421                 :          0 :                         count++;
     422                 :            :         }
     423                 :            : 
     424                 :            :         return count;
     425                 :            : }
     426                 :            : 
     427                 :            : int
     428                 :          0 : rte_dma_info_get(int16_t dev_id, struct rte_dma_info *dev_info)
     429                 :            : {
     430                 :          0 :         const struct rte_dma_dev *dev = &rte_dma_devices[dev_id];
     431                 :            :         int ret;
     432                 :            : 
     433   [ #  #  #  # ]:          0 :         if (!rte_dma_is_valid(dev_id) || dev_info == NULL)
     434                 :            :                 return -EINVAL;
     435                 :            : 
     436         [ #  # ]:          0 :         if (*dev->dev_ops->dev_info_get == NULL)
     437                 :            :                 return -ENOTSUP;
     438                 :            :         memset(dev_info, 0, sizeof(struct rte_dma_info));
     439                 :          0 :         ret = (*dev->dev_ops->dev_info_get)(dev, dev_info,
     440                 :            :                                             sizeof(struct rte_dma_info));
     441         [ #  # ]:          0 :         if (ret != 0)
     442                 :            :                 return ret;
     443                 :            : 
     444                 :          0 :         dev_info->dev_name = dev->data->dev_name;
     445                 :          0 :         dev_info->numa_node = dev->device->numa_node;
     446         [ #  # ]:          0 :         dev_info->nb_vchans = dev->data->dev_conf.nb_vchans;
     447                 :            : 
     448                 :          0 :         rte_dma_trace_info_get(dev_id, dev_info);
     449                 :            : 
     450                 :          0 :         return 0;
     451                 :            : }
     452                 :            : 
     453                 :            : int
     454                 :          0 : rte_dma_configure(int16_t dev_id, const struct rte_dma_conf *dev_conf)
     455                 :            : {
     456                 :          0 :         struct rte_dma_dev *dev = &rte_dma_devices[dev_id];
     457                 :            :         struct rte_dma_info dev_info;
     458                 :            :         int ret;
     459                 :            : 
     460   [ #  #  #  # ]:          0 :         if (!rte_dma_is_valid(dev_id) || dev_conf == NULL)
     461                 :            :                 return -EINVAL;
     462                 :            : 
     463         [ #  # ]:          0 :         if (dev->data->dev_started != 0) {
     464                 :          0 :                 RTE_DMA_LOG(ERR,
     465                 :            :                         "Device %d must be stopped to allow configuration",
     466                 :            :                         dev_id);
     467                 :          0 :                 return -EBUSY;
     468                 :            :         }
     469                 :            : 
     470                 :          0 :         ret = rte_dma_info_get(dev_id, &dev_info);
     471         [ #  # ]:          0 :         if (ret != 0) {
     472                 :          0 :                 RTE_DMA_LOG(ERR, "Device %d get device info fail", dev_id);
     473                 :          0 :                 return -EINVAL;
     474                 :            :         }
     475         [ #  # ]:          0 :         if (dev_conf->nb_vchans == 0) {
     476                 :          0 :                 RTE_DMA_LOG(ERR,
     477                 :            :                         "Device %d configure zero vchans", dev_id);
     478                 :          0 :                 return -EINVAL;
     479                 :            :         }
     480         [ #  # ]:          0 :         if (dev_conf->nb_vchans > dev_info.max_vchans) {
     481                 :          0 :                 RTE_DMA_LOG(ERR,
     482                 :            :                         "Device %d configure too many vchans", dev_id);
     483                 :          0 :                 return -EINVAL;
     484                 :            :         }
     485         [ #  # ]:          0 :         if (dev_conf->enable_silent &&
     486         [ #  # ]:          0 :             !(dev_info.dev_capa & RTE_DMA_CAPA_SILENT)) {
     487                 :          0 :                 RTE_DMA_LOG(ERR, "Device %d don't support silent", dev_id);
     488                 :          0 :                 return -EINVAL;
     489                 :            :         }
     490                 :            : 
     491         [ #  # ]:          0 :         if (*dev->dev_ops->dev_configure == NULL)
     492                 :            :                 return -ENOTSUP;
     493                 :          0 :         ret = (*dev->dev_ops->dev_configure)(dev, dev_conf,
     494                 :            :                                              sizeof(struct rte_dma_conf));
     495         [ #  # ]:          0 :         if (ret == 0)
     496                 :          0 :                 memcpy(&dev->data->dev_conf, dev_conf,
     497                 :            :                        sizeof(struct rte_dma_conf));
     498                 :            : 
     499                 :          0 :         rte_dma_trace_configure(dev_id, dev_conf, ret);
     500                 :            : 
     501                 :          0 :         return ret;
     502                 :            : }
     503                 :            : 
     504                 :            : int
     505                 :          0 : rte_dma_start(int16_t dev_id)
     506                 :            : {
     507                 :          0 :         struct rte_dma_dev *dev = &rte_dma_devices[dev_id];
     508                 :            :         int ret;
     509                 :            : 
     510         [ #  # ]:          0 :         if (!rte_dma_is_valid(dev_id))
     511                 :            :                 return -EINVAL;
     512                 :            : 
     513         [ #  # ]:          0 :         if (dev->data->dev_conf.nb_vchans == 0) {
     514                 :          0 :                 RTE_DMA_LOG(ERR, "Device %d must be configured first", dev_id);
     515                 :          0 :                 return -EINVAL;
     516                 :            :         }
     517                 :            : 
     518         [ #  # ]:          0 :         if (dev->data->dev_started != 0) {
     519                 :          0 :                 RTE_DMA_LOG(WARNING, "Device %d already started", dev_id);
     520                 :          0 :                 return 0;
     521                 :            :         }
     522                 :            : 
     523         [ #  # ]:          0 :         if (dev->dev_ops->dev_start == NULL)
     524                 :          0 :                 goto mark_started;
     525                 :            : 
     526                 :          0 :         ret = (*dev->dev_ops->dev_start)(dev);
     527                 :          0 :         rte_dma_trace_start(dev_id, ret);
     528         [ #  # ]:          0 :         if (ret != 0)
     529                 :            :                 return ret;
     530                 :            : 
     531                 :          0 : mark_started:
     532                 :          0 :         dev->data->dev_started = 1;
     533                 :          0 :         return 0;
     534                 :            : }
     535                 :            : 
     536                 :            : int
     537                 :          0 : rte_dma_stop(int16_t dev_id)
     538                 :            : {
     539                 :          0 :         struct rte_dma_dev *dev = &rte_dma_devices[dev_id];
     540                 :            :         int ret;
     541                 :            : 
     542         [ #  # ]:          0 :         if (!rte_dma_is_valid(dev_id))
     543                 :            :                 return -EINVAL;
     544                 :            : 
     545         [ #  # ]:          0 :         if (dev->data->dev_started == 0) {
     546                 :          0 :                 RTE_DMA_LOG(WARNING, "Device %d already stopped", dev_id);
     547                 :          0 :                 return 0;
     548                 :            :         }
     549                 :            : 
     550         [ #  # ]:          0 :         if (dev->dev_ops->dev_stop == NULL)
     551                 :          0 :                 goto mark_stopped;
     552                 :            : 
     553                 :          0 :         ret = (*dev->dev_ops->dev_stop)(dev);
     554                 :          0 :         rte_dma_trace_stop(dev_id, ret);
     555         [ #  # ]:          0 :         if (ret != 0)
     556                 :            :                 return ret;
     557                 :            : 
     558                 :          0 : mark_stopped:
     559                 :          0 :         dev->data->dev_started = 0;
     560                 :          0 :         return 0;
     561                 :            : }
     562                 :            : 
     563                 :            : int
     564                 :          1 : rte_dma_close(int16_t dev_id)
     565                 :            : {
     566                 :          1 :         struct rte_dma_dev *dev = &rte_dma_devices[dev_id];
     567                 :            :         int ret;
     568                 :            : 
     569         [ +  - ]:          1 :         if (!rte_dma_is_valid(dev_id))
     570                 :            :                 return -EINVAL;
     571                 :            : 
     572                 :            :         /* Device must be stopped before it can be closed */
     573         [ -  + ]:          1 :         if (dev->data->dev_started == 1) {
     574                 :          0 :                 RTE_DMA_LOG(ERR,
     575                 :            :                         "Device %d must be stopped before closing", dev_id);
     576                 :          0 :                 return -EBUSY;
     577                 :            :         }
     578                 :            : 
     579         [ +  - ]:          1 :         if (*dev->dev_ops->dev_close == NULL)
     580                 :            :                 return -ENOTSUP;
     581                 :          1 :         ret = (*dev->dev_ops->dev_close)(dev);
     582         [ +  - ]:          1 :         if (ret == 0)
     583                 :          1 :                 dma_release(dev);
     584                 :            : 
     585                 :          1 :         rte_dma_trace_close(dev_id, ret);
     586                 :            : 
     587                 :          1 :         return ret;
     588                 :            : }
     589                 :            : 
     590                 :            : int
     591                 :          0 : rte_dma_vchan_setup(int16_t dev_id, uint16_t vchan,
     592                 :            :                     const struct rte_dma_vchan_conf *conf)
     593                 :            : {
     594                 :          0 :         struct rte_dma_dev *dev = &rte_dma_devices[dev_id];
     595                 :            :         struct rte_dma_info dev_info;
     596                 :            :         bool src_is_dev, dst_is_dev;
     597                 :            :         int ret;
     598                 :            : 
     599   [ #  #  #  # ]:          0 :         if (!rte_dma_is_valid(dev_id) || conf == NULL)
     600                 :            :                 return -EINVAL;
     601                 :            : 
     602         [ #  # ]:          0 :         if (dev->data->dev_started != 0) {
     603                 :          0 :                 RTE_DMA_LOG(ERR,
     604                 :            :                         "Device %d must be stopped to allow configuration",
     605                 :            :                         dev_id);
     606                 :          0 :                 return -EBUSY;
     607                 :            :         }
     608                 :            : 
     609                 :          0 :         ret = rte_dma_info_get(dev_id, &dev_info);
     610         [ #  # ]:          0 :         if (ret != 0) {
     611                 :          0 :                 RTE_DMA_LOG(ERR, "Device %d get device info fail", dev_id);
     612                 :          0 :                 return -EINVAL;
     613                 :            :         }
     614         [ #  # ]:          0 :         if (dev->data->dev_conf.nb_vchans == 0) {
     615                 :          0 :                 RTE_DMA_LOG(ERR, "Device %d must be configured first", dev_id);
     616                 :          0 :                 return -EINVAL;
     617                 :            :         }
     618         [ #  # ]:          0 :         if (vchan >= dev_info.nb_vchans) {
     619                 :          0 :                 RTE_DMA_LOG(ERR, "Device %d vchan out range!", dev_id);
     620                 :          0 :                 return -EINVAL;
     621                 :            :         }
     622         [ #  # ]:          0 :         if (conf->direction != RTE_DMA_DIR_MEM_TO_MEM &&
     623                 :            :             conf->direction != RTE_DMA_DIR_MEM_TO_DEV &&
     624                 :            :             conf->direction != RTE_DMA_DIR_DEV_TO_MEM &&
     625                 :            :             conf->direction != RTE_DMA_DIR_DEV_TO_DEV) {
     626                 :          0 :                 RTE_DMA_LOG(ERR, "Device %d direction invalid!", dev_id);
     627                 :          0 :                 return -EINVAL;
     628                 :            :         }
     629         [ #  # ]:          0 :         if (conf->direction == RTE_DMA_DIR_MEM_TO_MEM &&
     630         [ #  # ]:          0 :             !(dev_info.dev_capa & RTE_DMA_CAPA_MEM_TO_MEM)) {
     631                 :          0 :                 RTE_DMA_LOG(ERR,
     632                 :            :                         "Device %d don't support mem2mem transfer", dev_id);
     633                 :          0 :                 return -EINVAL;
     634                 :            :         }
     635         [ #  # ]:          0 :         if (conf->direction == RTE_DMA_DIR_MEM_TO_DEV &&
     636         [ #  # ]:          0 :             !(dev_info.dev_capa & RTE_DMA_CAPA_MEM_TO_DEV)) {
     637                 :          0 :                 RTE_DMA_LOG(ERR,
     638                 :            :                         "Device %d don't support mem2dev transfer", dev_id);
     639                 :          0 :                 return -EINVAL;
     640                 :            :         }
     641         [ #  # ]:          0 :         if (conf->direction == RTE_DMA_DIR_DEV_TO_MEM &&
     642         [ #  # ]:          0 :             !(dev_info.dev_capa & RTE_DMA_CAPA_DEV_TO_MEM)) {
     643                 :          0 :                 RTE_DMA_LOG(ERR,
     644                 :            :                         "Device %d don't support dev2mem transfer", dev_id);
     645                 :          0 :                 return -EINVAL;
     646                 :            :         }
     647         [ #  # ]:          0 :         if (conf->direction == RTE_DMA_DIR_DEV_TO_DEV &&
     648         [ #  # ]:          0 :             !(dev_info.dev_capa & RTE_DMA_CAPA_DEV_TO_DEV)) {
     649                 :          0 :                 RTE_DMA_LOG(ERR,
     650                 :            :                         "Device %d don't support dev2dev transfer", dev_id);
     651                 :          0 :                 return -EINVAL;
     652                 :            :         }
     653         [ #  # ]:          0 :         if (conf->nb_desc < dev_info.min_desc ||
     654         [ #  # ]:          0 :             conf->nb_desc > dev_info.max_desc) {
     655                 :          0 :                 RTE_DMA_LOG(ERR,
     656                 :            :                         "Device %d number of descriptors invalid", dev_id);
     657                 :          0 :                 return -EINVAL;
     658                 :            :         }
     659                 :          0 :         src_is_dev = conf->direction == RTE_DMA_DIR_DEV_TO_MEM ||
     660                 :            :                      conf->direction == RTE_DMA_DIR_DEV_TO_DEV;
     661   [ #  #  #  #  :          0 :         if ((conf->src_port.port_type == RTE_DMA_PORT_NONE && src_is_dev) ||
                   #  # ]
     662         [ #  # ]:          0 :             (conf->src_port.port_type != RTE_DMA_PORT_NONE && !src_is_dev)) {
     663                 :          0 :                 RTE_DMA_LOG(ERR, "Device %d source port type invalid", dev_id);
     664                 :          0 :                 return -EINVAL;
     665                 :            :         }
     666                 :          0 :         dst_is_dev = conf->direction == RTE_DMA_DIR_MEM_TO_DEV ||
     667                 :            :                      conf->direction == RTE_DMA_DIR_DEV_TO_DEV;
     668   [ #  #  #  #  :          0 :         if ((conf->dst_port.port_type == RTE_DMA_PORT_NONE && dst_is_dev) ||
                   #  # ]
     669         [ #  # ]:          0 :             (conf->dst_port.port_type != RTE_DMA_PORT_NONE && !dst_is_dev)) {
     670                 :          0 :                 RTE_DMA_LOG(ERR,
     671                 :            :                         "Device %d destination port type invalid", dev_id);
     672                 :          0 :                 return -EINVAL;
     673                 :            :         }
     674                 :            : 
     675         [ #  # ]:          0 :         if (*dev->dev_ops->vchan_setup == NULL)
     676                 :            :                 return -ENOTSUP;
     677                 :          0 :         ret = (*dev->dev_ops->vchan_setup)(dev, vchan, conf,
     678                 :            :                                         sizeof(struct rte_dma_vchan_conf));
     679                 :          0 :         rte_dma_trace_vchan_setup(dev_id, vchan, conf, ret);
     680                 :            : 
     681                 :          0 :         return ret;
     682                 :            : }
     683                 :            : 
     684                 :            : int
     685                 :          0 : rte_dma_stats_get(int16_t dev_id, uint16_t vchan, struct rte_dma_stats *stats)
     686                 :            : {
     687                 :          0 :         const struct rte_dma_dev *dev = &rte_dma_devices[dev_id];
     688                 :            : 
     689   [ #  #  #  # ]:          0 :         if (!rte_dma_is_valid(dev_id) || stats == NULL)
     690                 :            :                 return -EINVAL;
     691                 :            : 
     692   [ #  #  #  # ]:          0 :         if (vchan >= dev->data->dev_conf.nb_vchans &&
     693                 :            :             vchan != RTE_DMA_ALL_VCHAN) {
     694                 :          0 :                 RTE_DMA_LOG(ERR,
     695                 :            :                         "Device %d vchan %u out of range", dev_id, vchan);
     696                 :          0 :                 return -EINVAL;
     697                 :            :         }
     698                 :            : 
     699         [ #  # ]:          0 :         if (*dev->dev_ops->stats_get == NULL)
     700                 :            :                 return -ENOTSUP;
     701                 :            :         memset(stats, 0, sizeof(struct rte_dma_stats));
     702                 :          0 :         return (*dev->dev_ops->stats_get)(dev, vchan, stats,
     703                 :            :                                           sizeof(struct rte_dma_stats));
     704                 :            : }
     705                 :            : 
     706                 :            : int
     707                 :          0 : rte_dma_stats_reset(int16_t dev_id, uint16_t vchan)
     708                 :            : {
     709                 :          0 :         struct rte_dma_dev *dev = &rte_dma_devices[dev_id];
     710                 :            :         int ret;
     711                 :            : 
     712         [ #  # ]:          0 :         if (!rte_dma_is_valid(dev_id))
     713                 :            :                 return -EINVAL;
     714                 :            : 
     715   [ #  #  #  # ]:          0 :         if (vchan >= dev->data->dev_conf.nb_vchans &&
     716                 :            :             vchan != RTE_DMA_ALL_VCHAN) {
     717                 :          0 :                 RTE_DMA_LOG(ERR,
     718                 :            :                         "Device %d vchan %u out of range", dev_id, vchan);
     719                 :          0 :                 return -EINVAL;
     720                 :            :         }
     721                 :            : 
     722         [ #  # ]:          0 :         if (*dev->dev_ops->stats_reset == NULL)
     723                 :            :                 return -ENOTSUP;
     724                 :          0 :         ret = (*dev->dev_ops->stats_reset)(dev, vchan);
     725                 :          0 :         rte_dma_trace_stats_reset(dev_id, vchan, ret);
     726                 :            : 
     727                 :          0 :         return ret;
     728                 :            : }
     729                 :            : 
     730                 :            : int
     731                 :          0 : rte_dma_vchan_status(int16_t dev_id, uint16_t vchan, enum rte_dma_vchan_status *status)
     732                 :            : {
     733                 :          0 :         struct rte_dma_dev *dev = &rte_dma_devices[dev_id];
     734                 :            : 
     735         [ #  # ]:          0 :         if (!rte_dma_is_valid(dev_id))
     736                 :            :                 return -EINVAL;
     737                 :            : 
     738         [ #  # ]:          0 :         if (vchan >= dev->data->dev_conf.nb_vchans) {
     739                 :          0 :                 RTE_DMA_LOG(ERR, "Device %u vchan %u out of range", dev_id, vchan);
     740                 :          0 :                 return -EINVAL;
     741                 :            :         }
     742                 :            : 
     743         [ #  # ]:          0 :         if (*dev->dev_ops->vchan_status == NULL)
     744                 :            :                 return -ENOTSUP;
     745                 :          0 :         return (*dev->dev_ops->vchan_status)(dev, vchan, status);
     746                 :            : }
     747                 :            : 
     748                 :            : static const char *
     749                 :            : dma_capability_name(uint64_t capability)
     750                 :            : {
     751                 :            :         static const struct {
     752                 :            :                 uint64_t capability;
     753                 :            :                 const char *name;
     754                 :            :         } capa_names[] = {
     755                 :            :                 { RTE_DMA_CAPA_MEM_TO_MEM,  "mem2mem" },
     756                 :            :                 { RTE_DMA_CAPA_MEM_TO_DEV,  "mem2dev" },
     757                 :            :                 { RTE_DMA_CAPA_DEV_TO_MEM,  "dev2mem" },
     758                 :            :                 { RTE_DMA_CAPA_DEV_TO_DEV,  "dev2dev" },
     759                 :            :                 { RTE_DMA_CAPA_SVA,         "sva"     },
     760                 :            :                 { RTE_DMA_CAPA_SILENT,      "silent"  },
     761                 :            :                 { RTE_DMA_CAPA_HANDLES_ERRORS, "handles_errors" },
     762                 :            :                 { RTE_DMA_CAPA_M2D_AUTO_FREE,  "m2d_auto_free"  },
     763                 :            :                 { RTE_DMA_CAPA_OPS_COPY,    "copy"    },
     764                 :            :                 { RTE_DMA_CAPA_OPS_COPY_SG, "copy_sg" },
     765                 :            :                 { RTE_DMA_CAPA_OPS_FILL,    "fill"    },
     766                 :            :         };
     767                 :            : 
     768                 :            :         const char *name = "unknown";
     769                 :            :         uint32_t i;
     770                 :            : 
     771   [ #  #  #  #  :          0 :         for (i = 0; i < RTE_DIM(capa_names); i++) {
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                #  #  # ]
     772   [ #  #  #  #  :          0 :                 if (capability == capa_names[i].capability) {
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                #  #  # ]
     773                 :          0 :                         name = capa_names[i].name;
     774                 :          0 :                         break;
     775                 :            :                 }
     776                 :            :         }
     777                 :            : 
     778                 :            :         return name;
     779                 :            : }
     780                 :            : 
     781                 :            : static void
     782                 :          0 : dma_dump_capability(FILE *f, uint64_t dev_capa)
     783                 :            : {
     784                 :            :         uint64_t capa;
     785                 :            : 
     786                 :            :         (void)fprintf(f, "  dev_capa: 0x%" PRIx64 " -", dev_capa);
     787         [ #  # ]:          0 :         while (dev_capa > 0) {
     788                 :          0 :                 capa = 1ull << rte_ctz64(dev_capa);
     789                 :            :                 (void)fprintf(f, " %s", dma_capability_name(capa));
     790                 :          0 :                 dev_capa &= ~capa;
     791                 :            :         }
     792                 :            :         (void)fprintf(f, "\n");
     793                 :          0 : }
     794                 :            : 
     795                 :            : int
     796                 :          0 : rte_dma_dump(int16_t dev_id, FILE *f)
     797                 :            : {
     798                 :          0 :         const struct rte_dma_dev *dev = &rte_dma_devices[dev_id];
     799                 :            :         struct rte_dma_info dev_info;
     800                 :            :         int ret;
     801                 :            : 
     802   [ #  #  #  # ]:          0 :         if (!rte_dma_is_valid(dev_id) || f == NULL)
     803                 :            :                 return -EINVAL;
     804                 :            : 
     805                 :          0 :         ret = rte_dma_info_get(dev_id, &dev_info);
     806         [ #  # ]:          0 :         if (ret != 0) {
     807                 :          0 :                 RTE_DMA_LOG(ERR, "Device %d get device info fail", dev_id);
     808                 :          0 :                 return -EINVAL;
     809                 :            :         }
     810                 :            : 
     811                 :          0 :         (void)fprintf(f, "DMA Dev %d, '%s' [%s]\n",
     812                 :          0 :                 dev->data->dev_id,
     813                 :          0 :                 dev->data->dev_name,
     814         [ #  # ]:          0 :                 dev->data->dev_started ? "started" : "stopped");
     815                 :          0 :         dma_dump_capability(f, dev_info.dev_capa);
     816                 :          0 :         (void)fprintf(f, "  max_vchans_supported: %u\n", dev_info.max_vchans);
     817                 :          0 :         (void)fprintf(f, "  nb_vchans_configured: %u\n", dev_info.nb_vchans);
     818                 :          0 :         (void)fprintf(f, "  silent_mode: %s\n",
     819         [ #  # ]:          0 :                 dev->data->dev_conf.enable_silent ? "on" : "off");
     820                 :            : 
     821         [ #  # ]:          0 :         if (dev->dev_ops->dev_dump != NULL)
     822                 :          0 :                 ret = (*dev->dev_ops->dev_dump)(dev, f);
     823                 :          0 :         rte_dma_trace_dump(dev_id, f, ret);
     824                 :            : 
     825                 :          0 :         return ret;
     826                 :            : }
     827                 :            : 
     828                 :            : static int
     829                 :          0 : dummy_copy(__rte_unused void *dev_private, __rte_unused uint16_t vchan,
     830                 :            :            __rte_unused rte_iova_t src, __rte_unused rte_iova_t dst,
     831                 :            :            __rte_unused uint32_t length, __rte_unused uint64_t flags)
     832                 :            : {
     833                 :          0 :         RTE_DMA_LOG(ERR, "copy is not configured or not supported.");
     834                 :          0 :         return -EINVAL;
     835                 :            : }
     836                 :            : 
     837                 :            : static int
     838                 :          0 : dummy_copy_sg(__rte_unused void *dev_private, __rte_unused uint16_t vchan,
     839                 :            :               __rte_unused const struct rte_dma_sge *src,
     840                 :            :               __rte_unused const struct rte_dma_sge *dst,
     841                 :            :               __rte_unused uint16_t nb_src, __rte_unused uint16_t nb_dst,
     842                 :            :               __rte_unused uint64_t flags)
     843                 :            : {
     844                 :          0 :         RTE_DMA_LOG(ERR, "copy_sg is not configured or not supported.");
     845                 :          0 :         return -EINVAL;
     846                 :            : }
     847                 :            : 
     848                 :            : static int
     849                 :          0 : dummy_fill(__rte_unused void *dev_private, __rte_unused uint16_t vchan,
     850                 :            :            __rte_unused uint64_t pattern, __rte_unused rte_iova_t dst,
     851                 :            :            __rte_unused uint32_t length, __rte_unused uint64_t flags)
     852                 :            : {
     853                 :          0 :         RTE_DMA_LOG(ERR, "fill is not configured or not supported.");
     854                 :          0 :         return -EINVAL;
     855                 :            : }
     856                 :            : 
     857                 :            : static int
     858                 :          0 : dummy_submit(__rte_unused void *dev_private, __rte_unused uint16_t vchan)
     859                 :            : {
     860                 :          0 :         RTE_DMA_LOG(ERR, "submit is not configured or not supported.");
     861                 :          0 :         return -EINVAL;
     862                 :            : }
     863                 :            : 
     864                 :            : static uint16_t
     865                 :          0 : dummy_completed(__rte_unused void *dev_private, __rte_unused uint16_t vchan,
     866                 :            :                 __rte_unused const uint16_t nb_cpls,
     867                 :            :                 __rte_unused uint16_t *last_idx, __rte_unused bool *has_error)
     868                 :            : {
     869                 :          0 :         RTE_DMA_LOG(ERR, "completed is not configured or not supported.");
     870                 :          0 :         return 0;
     871                 :            : }
     872                 :            : 
     873                 :            : static uint16_t
     874                 :          0 : dummy_completed_status(__rte_unused void *dev_private,
     875                 :            :                        __rte_unused uint16_t vchan,
     876                 :            :                        __rte_unused const uint16_t nb_cpls,
     877                 :            :                        __rte_unused uint16_t *last_idx,
     878                 :            :                        __rte_unused enum rte_dma_status_code *status)
     879                 :            : {
     880                 :          0 :         RTE_DMA_LOG(ERR,
     881                 :            :                     "completed_status is not configured or not supported.");
     882                 :          0 :         return 0;
     883                 :            : }
     884                 :            : 
     885                 :            : static uint16_t
     886                 :          0 : dummy_burst_capacity(__rte_unused const void *dev_private,
     887                 :            :                      __rte_unused uint16_t vchan)
     888                 :            : {
     889                 :          0 :         RTE_DMA_LOG(ERR, "burst_capacity is not configured or not supported.");
     890                 :          0 :         return 0;
     891                 :            : }
     892                 :            : 
     893                 :            : static void
     894                 :            : dma_fp_object_dummy(struct rte_dma_fp_object *obj)
     895                 :            : {
     896                 :         66 :         obj->dev_private      = NULL;
     897                 :         66 :         obj->copy             = dummy_copy;
     898                 :         66 :         obj->copy_sg          = dummy_copy_sg;
     899                 :         66 :         obj->fill             = dummy_fill;
     900                 :         66 :         obj->submit           = dummy_submit;
     901                 :         66 :         obj->completed        = dummy_completed;
     902                 :         66 :         obj->completed_status = dummy_completed_status;
     903                 :         64 :         obj->burst_capacity   = dummy_burst_capacity;
     904                 :          1 : }
     905                 :            : 
     906                 :            : static int
     907                 :          0 : dmadev_handle_dev_list(const char *cmd __rte_unused,
     908                 :            :                 const char *params __rte_unused,
     909                 :            :                 struct rte_tel_data *d)
     910                 :            : {
     911                 :            :         int dev_id;
     912                 :            : 
     913                 :          0 :         rte_tel_data_start_array(d, RTE_TEL_INT_VAL);
     914         [ #  # ]:          0 :         for (dev_id = 0; dev_id < dma_devices_max; dev_id++)
     915         [ #  # ]:          0 :                 if (rte_dma_is_valid(dev_id))
     916                 :          0 :                         rte_tel_data_add_array_int(d, dev_id);
     917                 :            : 
     918                 :          0 :         return 0;
     919                 :            : }
     920                 :            : 
     921                 :            : #define ADD_CAPA(td, dc, c) rte_tel_data_add_dict_int(td, dma_capability_name(c), !!(dc & c))
     922                 :            : 
     923                 :            : static int
     924                 :          0 : dmadev_handle_dev_info(const char *cmd __rte_unused,
     925                 :            :                 const char *params, struct rte_tel_data *d)
     926                 :            : {
     927                 :            :         struct rte_dma_info dma_info;
     928                 :            :         struct rte_tel_data *dma_caps;
     929                 :            :         int dev_id, ret;
     930                 :            :         uint64_t dev_capa;
     931                 :            :         char *end_param;
     932                 :            : 
     933   [ #  #  #  #  :          0 :         if (params == NULL || strlen(params) == 0 || !isdigit(*params))
                   #  # ]
     934                 :            :                 return -EINVAL;
     935                 :            : 
     936                 :          0 :         dev_id = strtoul(params, &end_param, 0);
     937         [ #  # ]:          0 :         if (*end_param != '\0')
     938                 :          0 :                 RTE_DMA_LOG(WARNING, "Extra parameters passed to dmadev telemetry command, ignoring");
     939                 :            : 
     940                 :            :         /* Function info_get validates dev_id so we don't need to. */
     941                 :          0 :         ret = rte_dma_info_get(dev_id, &dma_info);
     942         [ #  # ]:          0 :         if (ret < 0)
     943                 :            :                 return -EINVAL;
     944                 :          0 :         dev_capa = dma_info.dev_capa;
     945                 :            : 
     946                 :          0 :         rte_tel_data_start_dict(d);
     947                 :          0 :         rte_tel_data_add_dict_string(d, "name", dma_info.dev_name);
     948                 :          0 :         rte_tel_data_add_dict_int(d, "nb_vchans", dma_info.nb_vchans);
     949                 :          0 :         rte_tel_data_add_dict_int(d, "numa_node", dma_info.numa_node);
     950                 :          0 :         rte_tel_data_add_dict_int(d, "max_vchans", dma_info.max_vchans);
     951                 :          0 :         rte_tel_data_add_dict_int(d, "max_desc", dma_info.max_desc);
     952                 :          0 :         rte_tel_data_add_dict_int(d, "min_desc", dma_info.min_desc);
     953                 :          0 :         rte_tel_data_add_dict_int(d, "max_sges", dma_info.max_sges);
     954                 :            : 
     955                 :          0 :         dma_caps = rte_tel_data_alloc();
     956         [ #  # ]:          0 :         if (!dma_caps)
     957                 :            :                 return -ENOMEM;
     958                 :            : 
     959                 :          0 :         rte_tel_data_start_dict(dma_caps);
     960                 :          0 :         ADD_CAPA(dma_caps, dev_capa, RTE_DMA_CAPA_MEM_TO_MEM);
     961                 :          0 :         ADD_CAPA(dma_caps, dev_capa, RTE_DMA_CAPA_MEM_TO_DEV);
     962                 :          0 :         ADD_CAPA(dma_caps, dev_capa, RTE_DMA_CAPA_DEV_TO_MEM);
     963                 :          0 :         ADD_CAPA(dma_caps, dev_capa, RTE_DMA_CAPA_DEV_TO_DEV);
     964                 :          0 :         ADD_CAPA(dma_caps, dev_capa, RTE_DMA_CAPA_SVA);
     965                 :          0 :         ADD_CAPA(dma_caps, dev_capa, RTE_DMA_CAPA_SILENT);
     966                 :          0 :         ADD_CAPA(dma_caps, dev_capa, RTE_DMA_CAPA_HANDLES_ERRORS);
     967                 :          0 :         ADD_CAPA(dma_caps, dev_capa, RTE_DMA_CAPA_M2D_AUTO_FREE);
     968                 :          0 :         ADD_CAPA(dma_caps, dev_capa, RTE_DMA_CAPA_OPS_COPY);
     969                 :          0 :         ADD_CAPA(dma_caps, dev_capa, RTE_DMA_CAPA_OPS_COPY_SG);
     970                 :          0 :         ADD_CAPA(dma_caps, dev_capa, RTE_DMA_CAPA_OPS_FILL);
     971                 :          0 :         rte_tel_data_add_dict_container(d, "capabilities", dma_caps, 0);
     972                 :            : 
     973                 :          0 :         return 0;
     974                 :            : }
     975                 :            : 
     976                 :            : #define ADD_DICT_STAT(s) rte_tel_data_add_dict_uint(d, #s, dma_stats.s)
     977                 :            : 
     978                 :            : static int
     979                 :          0 : dmadev_handle_dev_stats(const char *cmd __rte_unused,
     980                 :            :                 const char *params,
     981                 :            :                 struct rte_tel_data *d)
     982                 :            : {
     983                 :            :         struct rte_dma_info dma_info;
     984                 :            :         struct rte_dma_stats dma_stats;
     985                 :            :         int dev_id, ret, vchan_id;
     986                 :            :         char *end_param;
     987                 :            :         const char *vchan_param;
     988                 :            : 
     989   [ #  #  #  #  :          0 :         if (params == NULL || strlen(params) == 0 || !isdigit(*params))
                   #  # ]
     990                 :            :                 return -EINVAL;
     991                 :            : 
     992                 :          0 :         dev_id = strtoul(params, &end_param, 0);
     993                 :            : 
     994                 :            :         /* Function info_get validates dev_id so we don't need to. */
     995                 :          0 :         ret = rte_dma_info_get(dev_id, &dma_info);
     996         [ #  # ]:          0 :         if (ret < 0)
     997                 :            :                 return -EINVAL;
     998                 :            : 
     999                 :            :         /* If the device has one vchan the user does not need to supply the
    1000                 :            :          * vchan id and only the device id is needed, no extra parameters.
    1001                 :            :          */
    1002   [ #  #  #  # ]:          0 :         if (dma_info.nb_vchans == 1 && *end_param == '\0')
    1003                 :            :                 vchan_id = 0;
    1004                 :            :         else {
    1005                 :          0 :                 vchan_param = strtok(end_param, ",");
    1006   [ #  #  #  #  :          0 :                 if (!vchan_param || strlen(vchan_param) == 0 || !isdigit(*vchan_param))
                   #  # ]
    1007                 :            :                         return -EINVAL;
    1008                 :            : 
    1009                 :          0 :                 vchan_id = strtoul(vchan_param, &end_param, 0);
    1010                 :            :         }
    1011         [ #  # ]:          0 :         if (*end_param != '\0')
    1012                 :          0 :                 RTE_DMA_LOG(WARNING, "Extra parameters passed to dmadev telemetry command, ignoring");
    1013                 :            : 
    1014                 :          0 :         ret = rte_dma_stats_get(dev_id, vchan_id, &dma_stats);
    1015         [ #  # ]:          0 :         if (ret < 0)
    1016                 :            :                 return -EINVAL;
    1017                 :            : 
    1018                 :          0 :         rte_tel_data_start_dict(d);
    1019                 :          0 :         ADD_DICT_STAT(submitted);
    1020                 :          0 :         ADD_DICT_STAT(completed);
    1021                 :          0 :         ADD_DICT_STAT(errors);
    1022                 :            : 
    1023                 :          0 :         return 0;
    1024                 :            : }
    1025                 :            : 
    1026                 :            : #ifndef RTE_EXEC_ENV_WINDOWS
    1027                 :            : static int
    1028                 :          0 : dmadev_handle_dev_dump(const char *cmd __rte_unused,
    1029                 :            :                 const char *params,
    1030                 :            :                 struct rte_tel_data *d)
    1031                 :            : {
    1032                 :            :         char *buf, *end_param;
    1033                 :            :         int dev_id, ret;
    1034                 :            :         FILE *f;
    1035                 :            : 
    1036   [ #  #  #  #  :          0 :         if (params == NULL || strlen(params) == 0 || !isdigit(*params))
                   #  # ]
    1037                 :            :                 return -EINVAL;
    1038                 :            : 
    1039                 :          0 :         dev_id = strtoul(params, &end_param, 0);
    1040         [ #  # ]:          0 :         if (*end_param != '\0')
    1041                 :          0 :                 RTE_DMA_LOG(WARNING, "Extra parameters passed to dmadev telemetry command, ignoring");
    1042                 :            : 
    1043                 :          0 :         buf = calloc(RTE_TEL_MAX_SINGLE_STRING_LEN, sizeof(char));
    1044         [ #  # ]:          0 :         if (buf == NULL)
    1045                 :            :                 return -ENOMEM;
    1046                 :            : 
    1047                 :          0 :         f = fmemopen(buf, RTE_TEL_MAX_SINGLE_STRING_LEN - 1, "w+");
    1048         [ #  # ]:          0 :         if (f == NULL) {
    1049                 :          0 :                 free(buf);
    1050                 :          0 :                 return -EINVAL;
    1051                 :            :         }
    1052                 :            : 
    1053                 :          0 :         ret = rte_dma_dump(dev_id, f);
    1054                 :          0 :         fclose(f);
    1055         [ #  # ]:          0 :         if (ret == 0) {
    1056                 :          0 :                 rte_tel_data_start_dict(d);
    1057                 :          0 :                 rte_tel_data_string(d, buf);
    1058                 :            :         }
    1059                 :            : 
    1060                 :          0 :         free(buf);
    1061                 :          0 :         return ret;
    1062                 :            : }
    1063                 :            : #endif /* !RTE_EXEC_ENV_WINDOWS */
    1064                 :            : 
    1065                 :        238 : RTE_INIT(dmadev_init_telemetry)
    1066                 :            : {
    1067                 :        238 :         rte_telemetry_register_cmd("/dmadev/list", dmadev_handle_dev_list,
    1068                 :            :                         "Returns list of available dmadev devices by IDs. No parameters.");
    1069                 :        238 :         rte_telemetry_register_cmd("/dmadev/info", dmadev_handle_dev_info,
    1070                 :            :                         "Returns information for a dmadev. Parameters: int dev_id");
    1071                 :        238 :         rte_telemetry_register_cmd("/dmadev/stats", dmadev_handle_dev_stats,
    1072                 :            :                         "Returns the stats for a dmadev vchannel. Parameters: int dev_id, vchan_id (Optional if only one vchannel)");
    1073                 :            : #ifndef RTE_EXEC_ENV_WINDOWS
    1074                 :        238 :         rte_telemetry_register_cmd("/dmadev/dump", dmadev_handle_dev_dump,
    1075                 :            :                         "Returns dump information for a dmadev. Parameters: int dev_id");
    1076                 :            : #endif
    1077                 :        238 : }

Generated by: LCOV version 1.14