LCOV - code coverage report
Current view: top level - drivers/event/dlb2 - dlb2.c (source / functions) Hit Total Coverage
Test: Code coverage Lines: 1 1812 0.1 %
Date: 2024-01-22 15:35:40 Functions: 1 99 1.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 1 969 0.1 %

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  * Copyright(c) 2016-2022 Intel Corporation
       3                 :            :  */
       4                 :            : 
       5                 :            : #include <assert.h>
       6                 :            : #include <errno.h>
       7                 :            : #include <nmmintrin.h>
       8                 :            : #include <pthread.h>
       9                 :            : #include <stdint.h>
      10                 :            : #include <stdbool.h>
      11                 :            : #include <stdio.h>
      12                 :            : #include <string.h>
      13                 :            : #include <sys/mman.h>
      14                 :            : #include <fcntl.h>
      15                 :            : 
      16                 :            : #include <rte_common.h>
      17                 :            : #include <rte_config.h>
      18                 :            : #include <rte_cycles.h>
      19                 :            : #include <rte_debug.h>
      20                 :            : #include <dev_driver.h>
      21                 :            : #include <rte_errno.h>
      22                 :            : #include <rte_eventdev.h>
      23                 :            : #include <eventdev_pmd.h>
      24                 :            : #include <rte_io.h>
      25                 :            : #include <rte_kvargs.h>
      26                 :            : #include <rte_log.h>
      27                 :            : #include <rte_malloc.h>
      28                 :            : #include <rte_mbuf.h>
      29                 :            : #include <rte_power_intrinsics.h>
      30                 :            : #include <rte_prefetch.h>
      31                 :            : #include <rte_ring.h>
      32                 :            : #include <rte_string_fns.h>
      33                 :            : 
      34                 :            : #include "dlb2_priv.h"
      35                 :            : #include "dlb2_iface.h"
      36                 :            : #include "dlb2_inline_fns.h"
      37                 :            : 
      38                 :            : /*
      39                 :            :  * Bypass memory fencing instructions when port is of Producer type.
      40                 :            :  * This should be enabled very carefully with understanding that producer
      41                 :            :  * is not doing any writes which need fencing. The movdir64 instruction used to
      42                 :            :  * enqueue events to DLB is a weakly-ordered instruction and movdir64 write
      43                 :            :  * to DLB can go ahead of relevant application writes like updates to buffers
      44                 :            :  * being sent with event
      45                 :            :  */
      46                 :            : #define DLB2_BYPASS_FENCE_ON_PP 0  /* 1 == Bypass fence, 0 == do not bypass */
      47                 :            : 
      48                 :            : /*
      49                 :            :  * Resources exposed to eventdev. Some values overridden at runtime using
      50                 :            :  * values returned by the DLB kernel driver.
      51                 :            :  */
      52                 :            : #if (RTE_EVENT_MAX_QUEUES_PER_DEV > UINT8_MAX)
      53                 :            : #error "RTE_EVENT_MAX_QUEUES_PER_DEV cannot fit in member max_event_queues"
      54                 :            : #endif
      55                 :            : static struct rte_event_dev_info evdev_dlb2_default_info = {
      56                 :            :         .driver_name = "", /* probe will set */
      57                 :            :         .min_dequeue_timeout_ns = DLB2_MIN_DEQUEUE_TIMEOUT_NS,
      58                 :            :         .max_dequeue_timeout_ns = DLB2_MAX_DEQUEUE_TIMEOUT_NS,
      59                 :            : #if (RTE_EVENT_MAX_QUEUES_PER_DEV < DLB2_MAX_NUM_LDB_QUEUES)
      60                 :            :         .max_event_queues = RTE_EVENT_MAX_QUEUES_PER_DEV,
      61                 :            : #else
      62                 :            :         .max_event_queues = DLB2_MAX_NUM_LDB_QUEUES,
      63                 :            : #endif
      64                 :            :         .max_event_queue_flows = DLB2_MAX_NUM_FLOWS,
      65                 :            :         .max_event_queue_priority_levels = DLB2_QID_PRIORITIES,
      66                 :            :         .max_event_priority_levels = DLB2_QID_PRIORITIES,
      67                 :            :         .max_event_ports = DLB2_MAX_NUM_LDB_PORTS,
      68                 :            :         .max_event_port_dequeue_depth = DLB2_DEFAULT_CQ_DEPTH,
      69                 :            :         .max_event_port_enqueue_depth = DLB2_MAX_ENQUEUE_DEPTH,
      70                 :            :         .max_event_port_links = DLB2_MAX_NUM_QIDS_PER_LDB_CQ,
      71                 :            :         .max_num_events = DLB2_MAX_NUM_LDB_CREDITS,
      72                 :            :         .max_single_link_event_port_queue_pairs =
      73                 :            :                 DLB2_MAX_NUM_DIR_PORTS(DLB2_HW_V2),
      74                 :            :         .event_dev_cap = (RTE_EVENT_DEV_CAP_EVENT_QOS |
      75                 :            :                           RTE_EVENT_DEV_CAP_NONSEQ_MODE |
      76                 :            :                           RTE_EVENT_DEV_CAP_DISTRIBUTED_SCHED |
      77                 :            :                           RTE_EVENT_DEV_CAP_QUEUE_ALL_TYPES |
      78                 :            :                           RTE_EVENT_DEV_CAP_BURST_MODE |
      79                 :            :                           RTE_EVENT_DEV_CAP_IMPLICIT_RELEASE_DISABLE |
      80                 :            :                           RTE_EVENT_DEV_CAP_RUNTIME_PORT_LINK |
      81                 :            :                           RTE_EVENT_DEV_CAP_MULTIPLE_QUEUE_PORT |
      82                 :            :                           RTE_EVENT_DEV_CAP_MAINTENANCE_FREE),
      83                 :            :         .max_profiles_per_port = 1,
      84                 :            : };
      85                 :            : 
      86                 :            : struct process_local_port_data
      87                 :            : dlb2_port[DLB2_MAX_NUM_PORTS_ALL][DLB2_NUM_PORT_TYPES];
      88                 :            : 
      89                 :            : static void
      90                 :          0 : dlb2_free_qe_mem(struct dlb2_port *qm_port)
      91                 :            : {
      92         [ #  # ]:          0 :         if (qm_port == NULL)
      93                 :            :                 return;
      94                 :            : 
      95                 :          0 :         rte_free(qm_port->qe4);
      96                 :          0 :         qm_port->qe4 = NULL;
      97                 :            : 
      98                 :          0 :         rte_free(qm_port->int_arm_qe);
      99                 :          0 :         qm_port->int_arm_qe = NULL;
     100                 :            : 
     101                 :          0 :         rte_free(qm_port->consume_qe);
     102                 :          0 :         qm_port->consume_qe = NULL;
     103                 :            : 
     104                 :          0 :         rte_memzone_free(dlb2_port[qm_port->id][PORT_TYPE(qm_port)].mz);
     105                 :          0 :         dlb2_port[qm_port->id][PORT_TYPE(qm_port)].mz = NULL;
     106                 :            : }
     107                 :            : 
     108                 :            : /* override defaults with value(s) provided on command line */
     109                 :            : static void
     110                 :            : dlb2_init_queue_depth_thresholds(struct dlb2_eventdev *dlb2,
     111                 :            :                                  int *qid_depth_thresholds)
     112                 :            : {
     113                 :            :         int q;
     114                 :            : 
     115   [ #  #  #  # ]:          0 :         for (q = 0; q < DLB2_MAX_NUM_QUEUES(dlb2->version); q++) {
     116         [ #  # ]:          0 :                 if (qid_depth_thresholds[q] != 0)
     117                 :          0 :                         dlb2->ev_queues[q].depth_threshold =
     118                 :            :                                 qid_depth_thresholds[q];
     119                 :            :         }
     120                 :            : }
     121                 :            : 
     122                 :            : /* override defaults with value(s) provided on command line */
     123                 :            : static void
     124                 :            : dlb2_init_port_cos(struct dlb2_eventdev *dlb2, int *port_cos)
     125                 :            : {
     126                 :            :         int q;
     127                 :            : 
     128         [ #  # ]:          0 :         for (q = 0; q < DLB2_MAX_NUM_PORTS_ALL; q++) {
     129                 :          0 :                 dlb2->ev_ports[q].cos_id = port_cos[q];
     130         [ #  # ]:          0 :                 if (port_cos[q] != DLB2_COS_DEFAULT &&
     131         [ #  # ]:          0 :                     dlb2->cos_ports[port_cos[q]] < DLB2_MAX_NUM_LDB_PORTS_PER_COS) {
     132                 :          0 :                         dlb2->cos_ports[port_cos[q]]++;
     133                 :          0 :                         dlb2->max_cos_port = q;
     134                 :            :                 }
     135                 :            :         }
     136                 :            : }
     137                 :            : 
     138                 :            : static void
     139                 :          0 : dlb2_init_cos_bw(struct dlb2_eventdev *dlb2,
     140                 :            :                  struct dlb2_cos_bw *cos_bw)
     141                 :            : {
     142                 :            :         int q;
     143                 :            : 
     144                 :            : 
     145                 :            :         /* If cos_bw not set, then split evenly */
     146   [ #  #  #  # ]:          0 :         if (cos_bw->val[0] == 0 && cos_bw->val[1] == 0 &&
     147   [ #  #  #  # ]:          0 :                 cos_bw->val[2] == 0 && cos_bw->val[3] == 0) {
     148                 :          0 :                 cos_bw->val[0] = 25;
     149                 :          0 :                 cos_bw->val[1] = 25;
     150                 :          0 :                 cos_bw->val[2] = 25;
     151                 :          0 :                 cos_bw->val[3] = 25;
     152                 :            :         }
     153                 :            : 
     154         [ #  # ]:          0 :         for (q = 0; q < DLB2_COS_NUM_VALS; q++)
     155                 :          0 :                 dlb2->cos_bw[q] = cos_bw->val[q];
     156                 :            : 
     157                 :          0 : }
     158                 :            : 
     159                 :            : static int
     160                 :          0 : dlb2_hw_query_resources(struct dlb2_eventdev *dlb2)
     161                 :            : {
     162                 :          0 :         struct dlb2_hw_dev *handle = &dlb2->qm_instance;
     163                 :          0 :         struct dlb2_hw_resource_info *dlb2_info = &handle->info;
     164                 :            :         int num_ldb_ports;
     165                 :            :         int ret;
     166                 :            : 
     167                 :            :         /* Query driver resources provisioned for this device */
     168                 :            : 
     169                 :          0 :         ret = dlb2_iface_get_num_resources(handle,
     170                 :            :                                            &dlb2->hw_rsrc_query_results);
     171         [ #  # ]:          0 :         if (ret) {
     172                 :          0 :                 DLB2_LOG_ERR("ioctl get dlb2 num resources, err=%d\n", ret);
     173                 :          0 :                 return ret;
     174                 :            :         }
     175                 :            : 
     176                 :            :         /* Complete filling in device resource info returned to evdev app,
     177                 :            :          * overriding any default values.
     178                 :            :          * The capabilities (CAPs) were set at compile time.
     179                 :            :          */
     180                 :            : 
     181         [ #  # ]:          0 :         if (dlb2->max_cq_depth != DLB2_DEFAULT_CQ_DEPTH)
     182                 :          0 :                 num_ldb_ports = DLB2_MAX_HL_ENTRIES / dlb2->max_cq_depth;
     183                 :            :         else
     184                 :          0 :                 num_ldb_ports = dlb2->hw_rsrc_query_results.num_ldb_ports;
     185                 :            : 
     186                 :          0 :         evdev_dlb2_default_info.max_event_queues =
     187                 :          0 :                 dlb2->hw_rsrc_query_results.num_ldb_queues;
     188                 :            : 
     189                 :          0 :         evdev_dlb2_default_info.max_event_ports = num_ldb_ports;
     190                 :            : 
     191         [ #  # ]:          0 :         if (dlb2->version == DLB2_HW_V2_5) {
     192                 :          0 :                 evdev_dlb2_default_info.max_num_events =
     193                 :          0 :                         dlb2->hw_rsrc_query_results.num_credits;
     194                 :            :         } else {
     195                 :          0 :                 evdev_dlb2_default_info.max_num_events =
     196                 :          0 :                         dlb2->hw_rsrc_query_results.num_ldb_credits;
     197                 :            :         }
     198                 :            :         /* Save off values used when creating the scheduling domain. */
     199                 :            : 
     200                 :          0 :         handle->info.num_sched_domains =
     201                 :          0 :                 dlb2->hw_rsrc_query_results.num_sched_domains;
     202                 :            : 
     203         [ #  # ]:          0 :         if (dlb2->version == DLB2_HW_V2_5) {
     204                 :          0 :                 handle->info.hw_rsrc_max.nb_events_limit =
     205                 :          0 :                         dlb2->hw_rsrc_query_results.num_credits;
     206                 :            :         } else {
     207                 :          0 :                 handle->info.hw_rsrc_max.nb_events_limit =
     208                 :          0 :                         dlb2->hw_rsrc_query_results.num_ldb_credits;
     209                 :            :         }
     210                 :          0 :         handle->info.hw_rsrc_max.num_queues =
     211                 :          0 :                 dlb2->hw_rsrc_query_results.num_ldb_queues +
     212                 :          0 :                 dlb2->hw_rsrc_query_results.num_dir_ports;
     213                 :            : 
     214                 :          0 :         handle->info.hw_rsrc_max.num_ldb_queues =
     215                 :            :                 dlb2->hw_rsrc_query_results.num_ldb_queues;
     216                 :            : 
     217                 :          0 :         handle->info.hw_rsrc_max.num_ldb_ports = num_ldb_ports;
     218                 :            : 
     219                 :          0 :         handle->info.hw_rsrc_max.num_dir_ports =
     220                 :            :                 dlb2->hw_rsrc_query_results.num_dir_ports;
     221                 :            : 
     222                 :          0 :         handle->info.hw_rsrc_max.reorder_window_size =
     223                 :          0 :                 dlb2->hw_rsrc_query_results.num_hist_list_entries;
     224                 :            : 
     225                 :          0 :         rte_memcpy(dlb2_info, &handle->info.hw_rsrc_max, sizeof(*dlb2_info));
     226                 :            : 
     227                 :            :         return 0;
     228                 :            : }
     229                 :            : 
     230                 :            : #define DLB2_BASE_10 10
     231                 :            : 
     232                 :            : static int
     233                 :          0 : dlb2_string_to_int(int *result, const char *str)
     234                 :            : {
     235                 :            :         long ret;
     236                 :            :         char *endptr;
     237                 :            : 
     238         [ #  # ]:          0 :         if (str == NULL || result == NULL)
     239                 :            :                 return -EINVAL;
     240                 :            : 
     241                 :          0 :         errno = 0;
     242                 :          0 :         ret = strtol(str, &endptr, DLB2_BASE_10);
     243         [ #  # ]:          0 :         if (errno)
     244                 :          0 :                 return -errno;
     245                 :            : 
     246                 :            :         /* long int and int may be different width for some architectures */
     247   [ #  #  #  # ]:          0 :         if (ret < INT_MIN || ret > INT_MAX || endptr == str)
     248                 :            :                 return -EINVAL;
     249                 :            : 
     250                 :          0 :         *result = ret;
     251                 :          0 :         return 0;
     252                 :            : }
     253                 :            : 
     254                 :            : static int
     255                 :          0 : set_producer_coremask(const char *key __rte_unused,
     256                 :            :                       const char *value,
     257                 :            :                       void *opaque)
     258                 :            : {
     259                 :            :         const char **mask_str = opaque;
     260                 :            : 
     261         [ #  # ]:          0 :         if (value == NULL || opaque == NULL) {
     262                 :          0 :                 DLB2_LOG_ERR("NULL pointer\n");
     263                 :          0 :                 return -EINVAL;
     264                 :            :         }
     265                 :            : 
     266                 :          0 :         *mask_str = value;
     267                 :            : 
     268                 :          0 :         return 0;
     269                 :            : }
     270                 :            : 
     271                 :            : static int
     272                 :          0 : set_numa_node(const char *key __rte_unused, const char *value, void *opaque)
     273                 :            : {
     274                 :            :         int *socket_id = opaque;
     275                 :            :         int ret;
     276                 :            : 
     277                 :          0 :         ret = dlb2_string_to_int(socket_id, value);
     278         [ #  # ]:          0 :         if (ret < 0)
     279                 :            :                 return ret;
     280                 :            : 
     281         [ #  # ]:          0 :         if (*socket_id > RTE_MAX_NUMA_NODES)
     282                 :          0 :                 return -EINVAL;
     283                 :            :         return 0;
     284                 :            : }
     285                 :            : 
     286                 :            : 
     287                 :            : static int
     288                 :          0 : set_max_cq_depth(const char *key __rte_unused,
     289                 :            :                  const char *value,
     290                 :            :                  void *opaque)
     291                 :            : {
     292                 :            :         int *max_cq_depth = opaque;
     293                 :            :         int ret;
     294                 :            : 
     295         [ #  # ]:          0 :         if (value == NULL || opaque == NULL) {
     296                 :          0 :                 DLB2_LOG_ERR("NULL pointer\n");
     297                 :          0 :                 return -EINVAL;
     298                 :            :         }
     299                 :            : 
     300                 :          0 :         ret = dlb2_string_to_int(max_cq_depth, value);
     301         [ #  # ]:          0 :         if (ret < 0)
     302                 :            :                 return ret;
     303                 :            : 
     304         [ #  # ]:          0 :         if (*max_cq_depth < DLB2_MIN_CQ_DEPTH_OVERRIDE ||
     305                 :            :             *max_cq_depth > DLB2_MAX_CQ_DEPTH_OVERRIDE ||
     306                 :            :             !rte_is_power_of_2(*max_cq_depth)) {
     307                 :          0 :                 DLB2_LOG_ERR("dlb2: max_cq_depth %d and %d and a power of 2\n",
     308                 :            :                              DLB2_MIN_CQ_DEPTH_OVERRIDE,
     309                 :            :                              DLB2_MAX_CQ_DEPTH_OVERRIDE);
     310                 :          0 :                 return -EINVAL;
     311                 :            :         }
     312                 :            : 
     313                 :            :         return 0;
     314                 :            : }
     315                 :            : 
     316                 :            : static int
     317                 :          0 : set_max_enq_depth(const char *key __rte_unused,
     318                 :            :                   const char *value,
     319                 :            :                   void *opaque)
     320                 :            : {
     321                 :            :         int *max_enq_depth = opaque;
     322                 :            :         int ret;
     323                 :            : 
     324         [ #  # ]:          0 :         if (value == NULL || opaque == NULL) {
     325                 :          0 :                 DLB2_LOG_ERR("NULL pointer\n");
     326                 :          0 :                 return -EINVAL;
     327                 :            :         }
     328                 :            : 
     329                 :          0 :         ret = dlb2_string_to_int(max_enq_depth, value);
     330         [ #  # ]:          0 :         if (ret < 0)
     331                 :            :                 return ret;
     332                 :            : 
     333         [ #  # ]:          0 :         if (*max_enq_depth < DLB2_MIN_ENQ_DEPTH_OVERRIDE ||
     334                 :            :             *max_enq_depth > DLB2_MAX_ENQ_DEPTH_OVERRIDE ||
     335                 :            :             !rte_is_power_of_2(*max_enq_depth)) {
     336                 :          0 :                 DLB2_LOG_ERR("dlb2: max_enq_depth %d and %d and a power of 2\n",
     337                 :            :                 DLB2_MIN_ENQ_DEPTH_OVERRIDE,
     338                 :            :                 DLB2_MAX_ENQ_DEPTH_OVERRIDE);
     339                 :          0 :                 return -EINVAL;
     340                 :            :         }
     341                 :            : 
     342                 :            :         return 0;
     343                 :            : }
     344                 :            : 
     345                 :            : static int
     346                 :          0 : set_max_num_events(const char *key __rte_unused,
     347                 :            :                    const char *value,
     348                 :            :                    void *opaque)
     349                 :            : {
     350                 :            :         int *max_num_events = opaque;
     351                 :            :         int ret;
     352                 :            : 
     353         [ #  # ]:          0 :         if (value == NULL || opaque == NULL) {
     354                 :          0 :                 DLB2_LOG_ERR("NULL pointer\n");
     355                 :          0 :                 return -EINVAL;
     356                 :            :         }
     357                 :            : 
     358                 :          0 :         ret = dlb2_string_to_int(max_num_events, value);
     359         [ #  # ]:          0 :         if (ret < 0)
     360                 :            :                 return ret;
     361                 :            : 
     362         [ #  # ]:          0 :         if (*max_num_events < 0 || *max_num_events >
     363                 :            :                         DLB2_MAX_NUM_LDB_CREDITS) {
     364                 :          0 :                 DLB2_LOG_ERR("dlb2: max_num_events must be between 0 and %d\n",
     365                 :            :                              DLB2_MAX_NUM_LDB_CREDITS);
     366                 :          0 :                 return -EINVAL;
     367                 :            :         }
     368                 :            : 
     369                 :            :         return 0;
     370                 :            : }
     371                 :            : 
     372                 :            : static int
     373                 :          0 : set_num_dir_credits(const char *key __rte_unused,
     374                 :            :                     const char *value,
     375                 :            :                     void *opaque)
     376                 :            : {
     377                 :            :         int *num_dir_credits = opaque;
     378                 :            :         int ret;
     379                 :            : 
     380         [ #  # ]:          0 :         if (value == NULL || opaque == NULL) {
     381                 :          0 :                 DLB2_LOG_ERR("NULL pointer\n");
     382                 :          0 :                 return -EINVAL;
     383                 :            :         }
     384                 :            : 
     385                 :          0 :         ret = dlb2_string_to_int(num_dir_credits, value);
     386         [ #  # ]:          0 :         if (ret < 0)
     387                 :            :                 return ret;
     388                 :            : 
     389         [ #  # ]:          0 :         if (*num_dir_credits < 0 ||
     390                 :            :             *num_dir_credits > DLB2_MAX_NUM_DIR_CREDITS(DLB2_HW_V2)) {
     391                 :          0 :                 DLB2_LOG_ERR("dlb2: num_dir_credits must be between 0 and %d\n",
     392                 :            :                              DLB2_MAX_NUM_DIR_CREDITS(DLB2_HW_V2));
     393                 :          0 :                 return -EINVAL;
     394                 :            :         }
     395                 :            : 
     396                 :            :         return 0;
     397                 :            : }
     398                 :            : 
     399                 :            : static int
     400                 :          0 : set_dev_id(const char *key __rte_unused,
     401                 :            :            const char *value,
     402                 :            :            void *opaque)
     403                 :            : {
     404                 :            :         int *dev_id = opaque;
     405                 :            :         int ret;
     406                 :            : 
     407         [ #  # ]:          0 :         if (value == NULL || opaque == NULL) {
     408                 :          0 :                 DLB2_LOG_ERR("NULL pointer\n");
     409                 :          0 :                 return -EINVAL;
     410                 :            :         }
     411                 :            : 
     412                 :          0 :         ret = dlb2_string_to_int(dev_id, value);
     413                 :            :         if (ret < 0)
     414                 :            :                 return ret;
     415                 :            : 
     416                 :            :         return 0;
     417                 :            : }
     418                 :            : 
     419                 :            : static int
     420                 :          0 : set_poll_interval(const char *key __rte_unused,
     421                 :            :         const char *value,
     422                 :            :         void *opaque)
     423                 :            : {
     424                 :            :         int *poll_interval = opaque;
     425                 :            :         int ret;
     426                 :            : 
     427         [ #  # ]:          0 :         if (value == NULL || opaque == NULL) {
     428                 :          0 :                 DLB2_LOG_ERR("NULL pointer\n");
     429                 :          0 :                 return -EINVAL;
     430                 :            :         }
     431                 :            : 
     432                 :          0 :         ret = dlb2_string_to_int(poll_interval, value);
     433                 :            :         if (ret < 0)
     434                 :            :                 return ret;
     435                 :            : 
     436                 :            :         return 0;
     437                 :            : }
     438                 :            : 
     439                 :            : static int
     440                 :          0 : set_port_cos(const char *key __rte_unused,
     441                 :            :              const char *value,
     442                 :            :              void *opaque)
     443                 :            : {
     444                 :            :         struct dlb2_port_cos *port_cos = opaque;
     445                 :            :         int first, last, cos_id, i;
     446                 :            : 
     447         [ #  # ]:          0 :         if (value == NULL || opaque == NULL) {
     448                 :          0 :                 DLB2_LOG_ERR("NULL pointer\n");
     449                 :          0 :                 return -EINVAL;
     450                 :            :         }
     451                 :            : 
     452                 :            :         /* command line override may take one of the following 3 forms:
     453                 :            :          * port_cos=port-port:<cos_id> ... a range of ports
     454                 :            :          * port_cos=port:<cos_id> ... just one port
     455                 :            :          */
     456         [ #  # ]:          0 :         if (sscanf(value, "%d-%d:%d", &first, &last, &cos_id) == 3) {
     457                 :            :                 /* we have everything we need */
     458         [ #  # ]:          0 :         } else if (sscanf(value, "%d:%d", &first, &cos_id) == 2) {
     459                 :          0 :                 last = first;
     460                 :            :         } else {
     461                 :          0 :                 DLB2_LOG_ERR("Error parsing ldb port port_cos devarg. Should be port-port:val, or port:val\n");
     462                 :          0 :                 return -EINVAL;
     463                 :            :         }
     464                 :            : 
     465   [ #  #  #  #  :          0 :         if (first > last || first < 0 ||
                   #  # ]
     466                 :            :                 last >= DLB2_MAX_NUM_LDB_PORTS) {
     467                 :          0 :                 DLB2_LOG_ERR("Error parsing ldb port cos_id arg, invalid port value\n");
     468                 :          0 :                 return -EINVAL;
     469                 :            :         }
     470                 :            : 
     471         [ #  # ]:          0 :         if (cos_id < DLB2_COS_0 || cos_id > DLB2_COS_3) {
     472                 :          0 :                 DLB2_LOG_ERR("Error parsing ldb port cos_id devarg, must be between 0 and 4\n");
     473                 :          0 :                 return -EINVAL;
     474                 :            :         }
     475                 :            : 
     476         [ #  # ]:          0 :         for (i = first; i <= last; i++)
     477                 :          0 :                 port_cos->cos_id[i] = cos_id; /* indexed by port */
     478                 :            : 
     479                 :            :         return 0;
     480                 :            : }
     481                 :            : 
     482                 :            : static int
     483                 :          0 : set_cos_bw(const char *key __rte_unused,
     484                 :            :              const char *value,
     485                 :            :              void *opaque)
     486                 :            : {
     487                 :            :         struct dlb2_cos_bw *cos_bw = opaque;
     488                 :            : 
     489         [ #  # ]:          0 :         if (opaque == NULL) {
     490                 :          0 :                 DLB2_LOG_ERR("NULL pointer\n");
     491                 :          0 :                 return -EINVAL;
     492                 :            :         }
     493                 :            : 
     494                 :            :         /* format must be %d,%d,%d,%d */
     495                 :            : 
     496         [ #  # ]:          0 :         if (sscanf(value, "%d:%d:%d:%d", &cos_bw->val[0], &cos_bw->val[1],
     497                 :            :                    &cos_bw->val[2], &cos_bw->val[3]) != 4) {
     498                 :          0 :                 DLB2_LOG_ERR("Error parsing cos bandwidth devarg. Should be bw0:bw1:bw2:bw3 where all values combined are <= 100\n");
     499                 :          0 :                 return -EINVAL;
     500                 :            :         }
     501         [ #  # ]:          0 :         if (cos_bw->val[0] + cos_bw->val[1] + cos_bw->val[2] + cos_bw->val[3] > 100) {
     502                 :          0 :                 DLB2_LOG_ERR("Error parsing cos bandwidth devarg. Should be bw0:bw1:bw2:bw3  where all values combined are <= 100\n");
     503                 :          0 :                 return -EINVAL;
     504                 :            :         }
     505                 :            : 
     506                 :            :         return 0;
     507                 :            : }
     508                 :            : 
     509                 :            : static int
     510                 :          0 : set_sw_credit_quanta(const char *key __rte_unused,
     511                 :            :         const char *value,
     512                 :            :         void *opaque)
     513                 :            : {
     514                 :            :         int *sw_credit_quanta = opaque;
     515                 :            :         int ret;
     516                 :            : 
     517         [ #  # ]:          0 :         if (value == NULL || opaque == NULL) {
     518                 :          0 :                 DLB2_LOG_ERR("NULL pointer\n");
     519                 :          0 :                 return -EINVAL;
     520                 :            :         }
     521                 :            : 
     522                 :          0 :         ret = dlb2_string_to_int(sw_credit_quanta, value);
     523         [ #  # ]:          0 :         if (ret < 0)
     524                 :            :                 return ret;
     525                 :            : 
     526         [ #  # ]:          0 :         if (*sw_credit_quanta <= 0) {
     527                 :          0 :                 DLB2_LOG_ERR("sw_credit_quanta must be > 0\n");
     528                 :          0 :                 return -EINVAL;
     529                 :            :         }
     530                 :            : 
     531                 :            :         return 0;
     532                 :            : }
     533                 :            : 
     534                 :            : static int
     535                 :          0 : set_hw_credit_quanta(const char *key __rte_unused,
     536                 :            :         const char *value,
     537                 :            :         void *opaque)
     538                 :            : {
     539                 :            :         int *hw_credit_quanta = opaque;
     540                 :            :         int ret;
     541                 :            : 
     542         [ #  # ]:          0 :         if (value == NULL || opaque == NULL) {
     543                 :          0 :                 DLB2_LOG_ERR("NULL pointer\n");
     544                 :          0 :                 return -EINVAL;
     545                 :            :         }
     546                 :            : 
     547                 :          0 :         ret = dlb2_string_to_int(hw_credit_quanta, value);
     548                 :            :         if (ret < 0)
     549                 :            :                 return ret;
     550                 :            : 
     551                 :            :         return 0;
     552                 :            : }
     553                 :            : 
     554                 :            : static int
     555                 :          0 : set_default_depth_thresh(const char *key __rte_unused,
     556                 :            :         const char *value,
     557                 :            :         void *opaque)
     558                 :            : {
     559                 :            :         int *default_depth_thresh = opaque;
     560                 :            :         int ret;
     561                 :            : 
     562         [ #  # ]:          0 :         if (value == NULL || opaque == NULL) {
     563                 :          0 :                 DLB2_LOG_ERR("NULL pointer\n");
     564                 :          0 :                 return -EINVAL;
     565                 :            :         }
     566                 :            : 
     567                 :          0 :         ret = dlb2_string_to_int(default_depth_thresh, value);
     568                 :            :         if (ret < 0)
     569                 :            :                 return ret;
     570                 :            : 
     571                 :            :         return 0;
     572                 :            : }
     573                 :            : 
     574                 :            : static int
     575                 :          0 : set_vector_opts_enab(const char *key __rte_unused,
     576                 :            :         const char *value,
     577                 :            :         void *opaque)
     578                 :            : {
     579                 :            :         bool *dlb2_vector_opts_enabled = opaque;
     580                 :            : 
     581         [ #  # ]:          0 :         if (value == NULL || opaque == NULL) {
     582                 :          0 :                 DLB2_LOG_ERR("NULL pointer\n");
     583                 :          0 :                 return -EINVAL;
     584                 :            :         }
     585                 :            : 
     586         [ #  # ]:          0 :         if ((*value == 'y') || (*value == 'Y'))
     587                 :          0 :                 *dlb2_vector_opts_enabled = true;
     588                 :            :         else
     589                 :          0 :                 *dlb2_vector_opts_enabled = false;
     590                 :            : 
     591                 :            :         return 0;
     592                 :            : }
     593                 :            : 
     594                 :            : static int
     595                 :          0 : set_default_ldb_port_allocation(const char *key __rte_unused,
     596                 :            :                       const char *value,
     597                 :            :                       void *opaque)
     598                 :            : {
     599                 :            :         bool *default_ldb_port_allocation = opaque;
     600                 :            : 
     601         [ #  # ]:          0 :         if (value == NULL || opaque == NULL) {
     602                 :          0 :                 DLB2_LOG_ERR("NULL pointer\n");
     603                 :          0 :                 return -EINVAL;
     604                 :            :         }
     605                 :            : 
     606         [ #  # ]:          0 :         if ((*value == 'y') || (*value == 'Y'))
     607                 :          0 :                 *default_ldb_port_allocation = true;
     608                 :            :         else
     609                 :          0 :                 *default_ldb_port_allocation = false;
     610                 :            : 
     611                 :            :         return 0;
     612                 :            : }
     613                 :            : 
     614                 :            : static int
     615                 :          0 : set_enable_cq_weight(const char *key __rte_unused,
     616                 :            :                       const char *value,
     617                 :            :                       void *opaque)
     618                 :            : {
     619                 :            :         bool *enable_cq_weight = opaque;
     620                 :            : 
     621         [ #  # ]:          0 :         if (value == NULL || opaque == NULL) {
     622                 :          0 :                 DLB2_LOG_ERR("NULL pointer\n");
     623                 :          0 :                 return -EINVAL;
     624                 :            :         }
     625                 :            : 
     626         [ #  # ]:          0 :         if ((*value == 'y') || (*value == 'Y'))
     627                 :          0 :                 *enable_cq_weight = true;
     628                 :            :         else
     629                 :          0 :                 *enable_cq_weight = false;
     630                 :            : 
     631                 :            :         return 0;
     632                 :            : }
     633                 :            : 
     634                 :            : static int
     635                 :          0 : set_qid_depth_thresh(const char *key __rte_unused,
     636                 :            :                      const char *value,
     637                 :            :                      void *opaque)
     638                 :            : {
     639                 :            :         struct dlb2_qid_depth_thresholds *qid_thresh = opaque;
     640                 :            :         int first, last, thresh, i;
     641                 :            : 
     642         [ #  # ]:          0 :         if (value == NULL || opaque == NULL) {
     643                 :          0 :                 DLB2_LOG_ERR("NULL pointer\n");
     644                 :          0 :                 return -EINVAL;
     645                 :            :         }
     646                 :            : 
     647                 :            :         /* command line override may take one of the following 3 forms:
     648                 :            :          * qid_depth_thresh=all:<threshold_value> ... all queues
     649                 :            :          * qid_depth_thresh=qidA-qidB:<threshold_value> ... a range of queues
     650                 :            :          * qid_depth_thresh=qid:<threshold_value> ... just one queue
     651                 :            :          */
     652         [ #  # ]:          0 :         if (sscanf(value, "all:%d", &thresh) == 1) {
     653                 :          0 :                 first = 0;
     654                 :          0 :                 last = DLB2_MAX_NUM_QUEUES(DLB2_HW_V2) - 1;
     655         [ #  # ]:          0 :         } else if (sscanf(value, "%d-%d:%d", &first, &last, &thresh) == 3) {
     656                 :            :                 /* we have everything we need */
     657         [ #  # ]:          0 :         } else if (sscanf(value, "%d:%d", &first, &thresh) == 2) {
     658                 :          0 :                 last = first;
     659                 :            :         } else {
     660                 :          0 :                 DLB2_LOG_ERR("Error parsing qid depth devarg. Should be all:val, qid-qid:val, or qid:val\n");
     661                 :          0 :                 return -EINVAL;
     662                 :            :         }
     663                 :            : 
     664   [ #  #  #  #  :          0 :         if (first > last || first < 0 ||
                   #  # ]
     665                 :            :                 last >= DLB2_MAX_NUM_QUEUES(DLB2_HW_V2)) {
     666                 :          0 :                 DLB2_LOG_ERR("Error parsing qid depth devarg, invalid qid value\n");
     667                 :          0 :                 return -EINVAL;
     668                 :            :         }
     669                 :            : 
     670         [ #  # ]:          0 :         if (thresh < 0 || thresh > DLB2_MAX_QUEUE_DEPTH_THRESHOLD) {
     671                 :          0 :                 DLB2_LOG_ERR("Error parsing qid depth devarg, threshold > %d\n",
     672                 :            :                              DLB2_MAX_QUEUE_DEPTH_THRESHOLD);
     673                 :          0 :                 return -EINVAL;
     674                 :            :         }
     675                 :            : 
     676         [ #  # ]:          0 :         for (i = first; i <= last; i++)
     677                 :          0 :                 qid_thresh->val[i] = thresh; /* indexed by qid */
     678                 :            : 
     679                 :            :         return 0;
     680                 :            : }
     681                 :            : 
     682                 :            : static int
     683                 :          0 : set_qid_depth_thresh_v2_5(const char *key __rte_unused,
     684                 :            :                           const char *value,
     685                 :            :                           void *opaque)
     686                 :            : {
     687                 :            :         struct dlb2_qid_depth_thresholds *qid_thresh = opaque;
     688                 :            :         int first, last, thresh, i;
     689                 :            : 
     690         [ #  # ]:          0 :         if (value == NULL || opaque == NULL) {
     691                 :          0 :                 DLB2_LOG_ERR("NULL pointer\n");
     692                 :          0 :                 return -EINVAL;
     693                 :            :         }
     694                 :            : 
     695                 :            :         /* command line override may take one of the following 3 forms:
     696                 :            :          * qid_depth_thresh=all:<threshold_value> ... all queues
     697                 :            :          * qid_depth_thresh=qidA-qidB:<threshold_value> ... a range of queues
     698                 :            :          * qid_depth_thresh=qid:<threshold_value> ... just one queue
     699                 :            :          */
     700         [ #  # ]:          0 :         if (sscanf(value, "all:%d", &thresh) == 1) {
     701                 :          0 :                 first = 0;
     702                 :          0 :                 last = DLB2_MAX_NUM_QUEUES(DLB2_HW_V2_5) - 1;
     703         [ #  # ]:          0 :         } else if (sscanf(value, "%d-%d:%d", &first, &last, &thresh) == 3) {
     704                 :            :                 /* we have everything we need */
     705         [ #  # ]:          0 :         } else if (sscanf(value, "%d:%d", &first, &thresh) == 2) {
     706                 :          0 :                 last = first;
     707                 :            :         } else {
     708                 :          0 :                 DLB2_LOG_ERR("Error parsing qid depth devarg. Should be all:val, qid-qid:val, or qid:val\n");
     709                 :          0 :                 return -EINVAL;
     710                 :            :         }
     711                 :            : 
     712   [ #  #  #  #  :          0 :         if (first > last || first < 0 ||
                   #  # ]
     713                 :            :                 last >= DLB2_MAX_NUM_QUEUES(DLB2_HW_V2_5)) {
     714                 :          0 :                 DLB2_LOG_ERR("Error parsing qid depth devarg, invalid qid value\n");
     715                 :          0 :                 return -EINVAL;
     716                 :            :         }
     717                 :            : 
     718         [ #  # ]:          0 :         if (thresh < 0 || thresh > DLB2_MAX_QUEUE_DEPTH_THRESHOLD) {
     719                 :          0 :                 DLB2_LOG_ERR("Error parsing qid depth devarg, threshold > %d\n",
     720                 :            :                              DLB2_MAX_QUEUE_DEPTH_THRESHOLD);
     721                 :          0 :                 return -EINVAL;
     722                 :            :         }
     723                 :            : 
     724         [ #  # ]:          0 :         for (i = first; i <= last; i++)
     725                 :          0 :                 qid_thresh->val[i] = thresh; /* indexed by qid */
     726                 :            : 
     727                 :            :         return 0;
     728                 :            : }
     729                 :            : 
     730                 :            : static void
     731                 :          0 : dlb2_eventdev_info_get(struct rte_eventdev *dev,
     732                 :            :                        struct rte_event_dev_info *dev_info)
     733                 :            : {
     734                 :            :         struct dlb2_eventdev *dlb2 = dlb2_pmd_priv(dev);
     735                 :            :         int ret;
     736                 :            : 
     737                 :          0 :         ret = dlb2_hw_query_resources(dlb2);
     738         [ #  # ]:          0 :         if (ret) {
     739                 :          0 :                 const struct rte_eventdev_data *data = dev->data;
     740                 :            : 
     741                 :          0 :                 DLB2_LOG_ERR("get resources err=%d, devid=%d\n",
     742                 :            :                              ret, data->dev_id);
     743                 :            :                 /* fn is void, so fall through and return values set up in
     744                 :            :                  * probe
     745                 :            :                  */
     746                 :            :         }
     747                 :            : 
     748                 :            :         /* Add num resources currently owned by this domain.
     749                 :            :          * These would become available if the scheduling domain were reset due
     750                 :            :          * to the application recalling eventdev_configure to *reconfigure* the
     751                 :            :          * domain.
     752                 :            :          */
     753                 :          0 :         evdev_dlb2_default_info.max_event_ports += dlb2->num_ldb_ports;
     754                 :          0 :         evdev_dlb2_default_info.max_event_queues += dlb2->num_ldb_queues;
     755         [ #  # ]:          0 :         if (dlb2->version == DLB2_HW_V2_5) {
     756                 :          0 :                 evdev_dlb2_default_info.max_num_events +=
     757                 :          0 :                         dlb2->max_credits;
     758                 :            :         } else {
     759                 :          0 :                 evdev_dlb2_default_info.max_num_events +=
     760                 :          0 :                         dlb2->max_ldb_credits;
     761                 :            :         }
     762                 :          0 :         evdev_dlb2_default_info.max_event_queues =
     763                 :          0 :                 RTE_MIN(evdev_dlb2_default_info.max_event_queues,
     764                 :            :                         RTE_EVENT_MAX_QUEUES_PER_DEV);
     765                 :            : 
     766                 :          0 :         evdev_dlb2_default_info.max_num_events =
     767                 :          0 :                 RTE_MIN(evdev_dlb2_default_info.max_num_events,
     768                 :            :                         dlb2->max_num_events_override);
     769                 :            : 
     770                 :          0 :         *dev_info = evdev_dlb2_default_info;
     771                 :          0 : }
     772                 :            : 
     773                 :            : static int
     774                 :          0 : dlb2_hw_create_sched_domain(struct dlb2_eventdev *dlb2,
     775                 :            :                             struct dlb2_hw_dev *handle,
     776                 :            :                             const struct dlb2_hw_rsrcs *resources_asked,
     777                 :            :                             uint8_t device_version)
     778                 :            : {
     779                 :            :         int ret = 0;
     780                 :            :         uint32_t cos_ports = 0;
     781                 :            :         struct dlb2_create_sched_domain_args *cfg;
     782                 :            : 
     783         [ #  # ]:          0 :         if (resources_asked == NULL) {
     784                 :          0 :                 DLB2_LOG_ERR("dlb2: dlb2_create NULL parameter\n");
     785                 :            :                 ret = EINVAL;
     786                 :          0 :                 goto error_exit;
     787                 :            :         }
     788                 :            : 
     789                 :            :         /* Map generic qm resources to dlb2 resources */
     790                 :          0 :         cfg = &handle->cfg.resources;
     791                 :            : 
     792                 :            :         /* DIR ports and queues */
     793                 :            : 
     794                 :          0 :         cfg->num_dir_ports = resources_asked->num_dir_ports;
     795         [ #  # ]:          0 :         if (device_version == DLB2_HW_V2_5)
     796                 :          0 :                 cfg->num_credits = resources_asked->num_credits;
     797                 :            :         else
     798                 :          0 :                 cfg->num_dir_credits = resources_asked->num_dir_credits;
     799                 :            : 
     800                 :            :         /* LDB queues */
     801                 :            : 
     802                 :          0 :         cfg->num_ldb_queues = resources_asked->num_ldb_queues;
     803                 :            : 
     804                 :            :         /* LDB ports */
     805                 :            : 
     806                 :            :         /* tally of COS ports from cmd line */
     807                 :          0 :         cos_ports = dlb2->cos_ports[0] + dlb2->cos_ports[1] +
     808                 :          0 :                     dlb2->cos_ports[2] + dlb2->cos_ports[3];
     809                 :            : 
     810   [ #  #  #  # ]:          0 :         if (cos_ports > resources_asked->num_ldb_ports ||
     811         [ #  # ]:          0 :             (cos_ports && dlb2->max_cos_port >= resources_asked->num_ldb_ports)) {
     812                 :          0 :                 DLB2_LOG_ERR("dlb2: num_ldb_ports < cos_ports\n");
     813                 :            :                 ret = EINVAL;
     814                 :          0 :                 goto error_exit;
     815                 :            :         }
     816                 :            : 
     817                 :          0 :         cfg->cos_strict = 0; /* Best effort */
     818                 :          0 :         cfg->num_cos_ldb_ports[0] = dlb2->cos_ports[0];
     819                 :          0 :         cfg->num_cos_ldb_ports[1] = dlb2->cos_ports[1];
     820                 :          0 :         cfg->num_cos_ldb_ports[2] = dlb2->cos_ports[2];
     821                 :          0 :         cfg->num_cos_ldb_ports[3] = dlb2->cos_ports[3];
     822                 :          0 :         cfg->num_ldb_ports = resources_asked->num_ldb_ports - cos_ports;
     823                 :            : 
     824         [ #  # ]:          0 :         if (device_version == DLB2_HW_V2)
     825                 :          0 :                 cfg->num_ldb_credits = resources_asked->num_ldb_credits;
     826                 :            : 
     827                 :          0 :         cfg->num_atomic_inflights =
     828                 :          0 :                 DLB2_NUM_ATOMIC_INFLIGHTS_PER_QUEUE *
     829                 :            :                 cfg->num_ldb_queues;
     830                 :            : 
     831                 :          0 :         cfg->num_hist_list_entries = resources_asked->num_ldb_ports *
     832                 :          0 :                 evdev_dlb2_default_info.max_event_port_dequeue_depth;
     833                 :            : 
     834                 :            :         if (device_version == DLB2_HW_V2_5) {
     835                 :            :                 DLB2_LOG_DBG("sched domain create - ldb_qs=%d, ldb_ports=%d, dir_ports=%d, atomic_inflights=%d, hist_list_entries=%d, credits=%d\n",
     836                 :            :                              cfg->num_ldb_queues,
     837                 :            :                              resources_asked->num_ldb_ports,
     838                 :            :                              cfg->num_dir_ports,
     839                 :            :                              cfg->num_atomic_inflights,
     840                 :            :                              cfg->num_hist_list_entries,
     841                 :            :                              cfg->num_credits);
     842                 :            :         } else {
     843                 :            :                 DLB2_LOG_DBG("sched domain create - ldb_qs=%d, ldb_ports=%d, dir_ports=%d, atomic_inflights=%d, hist_list_entries=%d, ldb_credits=%d, dir_credits=%d\n",
     844                 :            :                              cfg->num_ldb_queues,
     845                 :            :                              resources_asked->num_ldb_ports,
     846                 :            :                              cfg->num_dir_ports,
     847                 :            :                              cfg->num_atomic_inflights,
     848                 :            :                              cfg->num_hist_list_entries,
     849                 :            :                              cfg->num_ldb_credits,
     850                 :            :                              cfg->num_dir_credits);
     851                 :            :         }
     852                 :            : 
     853                 :            :         /* Configure the QM */
     854                 :            : 
     855                 :          0 :         ret = dlb2_iface_sched_domain_create(handle, cfg);
     856         [ #  # ]:          0 :         if (ret < 0) {
     857                 :          0 :                 DLB2_LOG_ERR("dlb2: domain create failed, ret = %d, extra status: %s\n",
     858                 :            :                              ret,
     859                 :            :                              dlb2_error_strings[cfg->response.status]);
     860                 :            : 
     861                 :          0 :                 goto error_exit;
     862                 :            :         }
     863                 :            : 
     864                 :          0 :         handle->domain_id = cfg->response.id;
     865                 :          0 :         handle->cfg.configured = true;
     866                 :            : 
     867                 :          0 : error_exit:
     868                 :            : 
     869                 :          0 :         return ret;
     870                 :            : }
     871                 :            : 
     872                 :            : static void
     873                 :          0 : dlb2_hw_reset_sched_domain(const struct rte_eventdev *dev, bool reconfig)
     874                 :            : {
     875                 :            :         struct dlb2_eventdev *dlb2 = dlb2_pmd_priv(dev);
     876                 :            :         enum dlb2_configuration_state config_state;
     877                 :            :         int i, j;
     878                 :            : 
     879                 :          0 :         dlb2_iface_domain_reset(dlb2);
     880                 :            : 
     881                 :            :         /* Free all dynamically allocated port memory */
     882         [ #  # ]:          0 :         for (i = 0; i < dlb2->num_ports; i++)
     883                 :          0 :                 dlb2_free_qe_mem(&dlb2->ev_ports[i].qm_port);
     884                 :            : 
     885                 :            :         /* If reconfiguring, mark the device's queues and ports as "previously
     886                 :            :          * configured." If the user doesn't reconfigure them, the PMD will
     887                 :            :          * reapply their previous configuration when the device is started.
     888                 :            :          */
     889                 :          0 :         config_state = (reconfig) ? DLB2_PREV_CONFIGURED :
     890                 :            :                 DLB2_NOT_CONFIGURED;
     891                 :            : 
     892         [ #  # ]:          0 :         for (i = 0; i < dlb2->num_ports; i++) {
     893                 :          0 :                 dlb2->ev_ports[i].qm_port.config_state = config_state;
     894                 :            :                 /* Reset setup_done so ports can be reconfigured */
     895                 :          0 :                 dlb2->ev_ports[i].setup_done = false;
     896         [ #  # ]:          0 :                 for (j = 0; j < DLB2_MAX_NUM_QIDS_PER_LDB_CQ; j++)
     897                 :          0 :                         dlb2->ev_ports[i].link[j].mapped = false;
     898                 :            :         }
     899                 :            : 
     900         [ #  # ]:          0 :         for (i = 0; i < dlb2->num_queues; i++)
     901                 :          0 :                 dlb2->ev_queues[i].qm_queue.config_state = config_state;
     902                 :            : 
     903         [ #  # ]:          0 :         for (i = 0; i < DLB2_MAX_NUM_QUEUES(DLB2_HW_V2_5); i++)
     904                 :          0 :                 dlb2->ev_queues[i].setup_done = false;
     905                 :            : 
     906                 :          0 :         dlb2->num_ports = 0;
     907                 :          0 :         dlb2->num_ldb_ports = 0;
     908                 :          0 :         dlb2->num_dir_ports = 0;
     909                 :          0 :         dlb2->num_queues = 0;
     910                 :          0 :         dlb2->num_ldb_queues = 0;
     911                 :          0 :         dlb2->num_dir_queues = 0;
     912                 :          0 :         dlb2->configured = false;
     913                 :          0 : }
     914                 :            : 
     915                 :            : /* Note: 1 QM instance per QM device, QM instance/device == event device */
     916                 :            : static int
     917         [ #  # ]:          0 : dlb2_eventdev_configure(const struct rte_eventdev *dev)
     918                 :            : {
     919                 :            :         struct dlb2_eventdev *dlb2 = dlb2_pmd_priv(dev);
     920                 :          0 :         struct dlb2_hw_dev *handle = &dlb2->qm_instance;
     921                 :          0 :         struct dlb2_hw_rsrcs *rsrcs = &handle->info.hw_rsrc_max;
     922                 :            :         const struct rte_eventdev_data *data = dev->data;
     923                 :            :         const struct rte_event_dev_config *config = &data->dev_conf;
     924                 :            :         int ret;
     925                 :            : 
     926                 :            :         /* If this eventdev is already configured, we must release the current
     927                 :            :          * scheduling domain before attempting to configure a new one.
     928                 :            :          */
     929         [ #  # ]:          0 :         if (dlb2->configured) {
     930                 :          0 :                 dlb2_hw_reset_sched_domain(dev, true);
     931                 :          0 :                 ret = dlb2_hw_query_resources(dlb2);
     932         [ #  # ]:          0 :                 if (ret) {
     933                 :          0 :                         DLB2_LOG_ERR("get resources err=%d, devid=%d\n",
     934                 :            :                                      ret, data->dev_id);
     935                 :          0 :                         return ret;
     936                 :            :                 }
     937                 :            :         }
     938                 :            : 
     939         [ #  # ]:          0 :         if (config->nb_event_queues > rsrcs->num_queues) {
     940                 :          0 :                 DLB2_LOG_ERR("nb_event_queues parameter (%d) exceeds the QM device's capabilities (%d).\n",
     941                 :            :                              config->nb_event_queues,
     942                 :            :                              rsrcs->num_queues);
     943                 :          0 :                 return -EINVAL;
     944                 :            :         }
     945                 :          0 :         if (config->nb_event_ports > (rsrcs->num_ldb_ports
     946         [ #  # ]:          0 :                         + rsrcs->num_dir_ports)) {
     947                 :          0 :                 DLB2_LOG_ERR("nb_event_ports parameter (%d) exceeds the QM device's capabilities (%d).\n",
     948                 :            :                              config->nb_event_ports,
     949                 :            :                              (rsrcs->num_ldb_ports + rsrcs->num_dir_ports));
     950                 :          0 :                 return -EINVAL;
     951                 :            :         }
     952         [ #  # ]:          0 :         if (config->nb_events_limit > rsrcs->nb_events_limit) {
     953                 :          0 :                 DLB2_LOG_ERR("nb_events_limit parameter (%d) exceeds the QM device's capabilities (%d).\n",
     954                 :            :                              config->nb_events_limit,
     955                 :            :                              rsrcs->nb_events_limit);
     956                 :          0 :                 return -EINVAL;
     957                 :            :         }
     958                 :            : 
     959         [ #  # ]:          0 :         if (config->event_dev_cfg & RTE_EVENT_DEV_CFG_PER_DEQUEUE_TIMEOUT)
     960                 :          0 :                 dlb2->global_dequeue_wait = false;
     961                 :            :         else {
     962                 :            :                 uint32_t timeout32;
     963                 :            : 
     964                 :          0 :                 dlb2->global_dequeue_wait = true;
     965                 :            : 
     966                 :            :                 /* note size mismatch of timeout vals in eventdev lib. */
     967                 :          0 :                 timeout32 = config->dequeue_timeout_ns;
     968                 :            : 
     969                 :          0 :                 dlb2->global_dequeue_wait_ticks =
     970                 :          0 :                         timeout32 * (rte_get_timer_hz() / 1E9);
     971                 :            :         }
     972                 :            : 
     973                 :            :         /* Does this platform support umonitor/umwait? */
     974         [ #  # ]:          0 :         if (rte_cpu_get_flag_enabled(RTE_CPUFLAG_WAITPKG))
     975                 :          0 :                 dlb2->umwait_allowed = true;
     976                 :            : 
     977                 :          0 :         rsrcs->num_dir_ports = config->nb_single_link_event_port_queues;
     978                 :          0 :         rsrcs->num_ldb_ports  = config->nb_event_ports - rsrcs->num_dir_ports;
     979                 :            :         /* 1 dir queue per dir port */
     980                 :          0 :         rsrcs->num_ldb_queues = config->nb_event_queues - rsrcs->num_dir_ports;
     981                 :            : 
     982         [ #  # ]:          0 :         if (dlb2->version == DLB2_HW_V2_5) {
     983                 :          0 :                 rsrcs->num_credits = 0;
     984   [ #  #  #  # ]:          0 :                 if (rsrcs->num_ldb_queues || rsrcs->num_dir_ports)
     985                 :          0 :                         rsrcs->num_credits = config->nb_events_limit;
     986                 :            :         } else {
     987                 :            :                 /* Scale down nb_events_limit by 4 for directed credits,
     988                 :            :                  * since there are 4x as many load-balanced credits.
     989                 :            :                  */
     990                 :          0 :                 rsrcs->num_ldb_credits = 0;
     991                 :          0 :                 rsrcs->num_dir_credits = 0;
     992                 :            : 
     993         [ #  # ]:          0 :                 if (rsrcs->num_ldb_queues)
     994                 :          0 :                         rsrcs->num_ldb_credits = config->nb_events_limit;
     995         [ #  # ]:          0 :                 if (rsrcs->num_dir_ports)
     996                 :          0 :                         rsrcs->num_dir_credits = config->nb_events_limit / 2;
     997         [ #  # ]:          0 :                 if (dlb2->num_dir_credits_override != -1)
     998                 :          0 :                         rsrcs->num_dir_credits = dlb2->num_dir_credits_override;
     999                 :            :         }
    1000                 :            : 
    1001         [ #  # ]:          0 :         if (dlb2_hw_create_sched_domain(dlb2, handle, rsrcs,
    1002                 :            :                                         dlb2->version) < 0) {
    1003                 :          0 :                 DLB2_LOG_ERR("dlb2_hw_create_sched_domain failed\n");
    1004                 :          0 :                 return -ENODEV;
    1005                 :            :         }
    1006                 :            : 
    1007                 :          0 :         dlb2->new_event_limit = config->nb_events_limit;
    1008                 :          0 :         __atomic_store_n(&dlb2->inflights, 0, __ATOMIC_SEQ_CST);
    1009                 :            : 
    1010                 :            :         /* Save number of ports/queues for this event dev */
    1011                 :          0 :         dlb2->num_ports = config->nb_event_ports;
    1012                 :          0 :         dlb2->num_queues = config->nb_event_queues;
    1013                 :          0 :         dlb2->num_dir_ports = rsrcs->num_dir_ports;
    1014                 :          0 :         dlb2->num_ldb_ports = dlb2->num_ports - dlb2->num_dir_ports;
    1015                 :          0 :         dlb2->num_ldb_queues = dlb2->num_queues - dlb2->num_dir_ports;
    1016                 :          0 :         dlb2->num_dir_queues = dlb2->num_dir_ports;
    1017         [ #  # ]:          0 :         if (dlb2->version == DLB2_HW_V2_5) {
    1018                 :          0 :                 dlb2->credit_pool = rsrcs->num_credits;
    1019                 :          0 :                 dlb2->max_credits = rsrcs->num_credits;
    1020                 :            :         } else {
    1021                 :          0 :                 dlb2->ldb_credit_pool = rsrcs->num_ldb_credits;
    1022                 :          0 :                 dlb2->max_ldb_credits = rsrcs->num_ldb_credits;
    1023                 :          0 :                 dlb2->dir_credit_pool = rsrcs->num_dir_credits;
    1024                 :          0 :                 dlb2->max_dir_credits = rsrcs->num_dir_credits;
    1025                 :            :         }
    1026                 :            : 
    1027                 :          0 :         dlb2->configured = true;
    1028                 :            : 
    1029                 :          0 :         return 0;
    1030                 :            : }
    1031                 :            : 
    1032                 :            : static void
    1033                 :          0 : dlb2_eventdev_port_default_conf_get(struct rte_eventdev *dev,
    1034                 :            :                                     uint8_t port_id,
    1035                 :            :                                     struct rte_event_port_conf *port_conf)
    1036                 :            : {
    1037                 :            :         RTE_SET_USED(port_id);
    1038                 :            :         struct dlb2_eventdev *dlb2 = dlb2_pmd_priv(dev);
    1039                 :            : 
    1040                 :          0 :         port_conf->new_event_threshold = dlb2->new_event_limit;
    1041                 :          0 :         port_conf->dequeue_depth = 32;
    1042                 :          0 :         port_conf->enqueue_depth = DLB2_MAX_ENQUEUE_DEPTH;
    1043                 :          0 :         port_conf->event_port_cfg = 0;
    1044                 :          0 : }
    1045                 :            : 
    1046                 :            : static void
    1047                 :          0 : dlb2_eventdev_queue_default_conf_get(struct rte_eventdev *dev,
    1048                 :            :                                      uint8_t queue_id,
    1049                 :            :                                      struct rte_event_queue_conf *queue_conf)
    1050                 :            : {
    1051                 :            :         RTE_SET_USED(dev);
    1052                 :            :         RTE_SET_USED(queue_id);
    1053                 :            : 
    1054                 :          0 :         queue_conf->nb_atomic_flows = 1024;
    1055                 :          0 :         queue_conf->nb_atomic_order_sequences = 64;
    1056                 :          0 :         queue_conf->event_queue_cfg = 0;
    1057                 :          0 :         queue_conf->priority = 0;
    1058                 :          0 : }
    1059                 :            : 
    1060                 :            : static int32_t
    1061                 :          0 : dlb2_get_sn_allocation(struct dlb2_eventdev *dlb2, int group)
    1062                 :            : {
    1063                 :          0 :         struct dlb2_hw_dev *handle = &dlb2->qm_instance;
    1064                 :            :         struct dlb2_get_sn_allocation_args cfg;
    1065                 :            :         int ret;
    1066                 :            : 
    1067                 :          0 :         cfg.group = group;
    1068                 :            : 
    1069                 :          0 :         ret = dlb2_iface_get_sn_allocation(handle, &cfg);
    1070         [ #  # ]:          0 :         if (ret < 0) {
    1071                 :          0 :                 DLB2_LOG_ERR("dlb2: get_sn_allocation ret=%d (driver status: %s)\n",
    1072                 :            :                              ret, dlb2_error_strings[cfg.response.status]);
    1073                 :          0 :                 return ret;
    1074                 :            :         }
    1075                 :            : 
    1076                 :          0 :         return cfg.response.id;
    1077                 :            : }
    1078                 :            : 
    1079                 :            : static int
    1080                 :          0 : dlb2_set_sn_allocation(struct dlb2_eventdev *dlb2, int group, int num)
    1081                 :            : {
    1082                 :          0 :         struct dlb2_hw_dev *handle = &dlb2->qm_instance;
    1083                 :            :         struct dlb2_set_sn_allocation_args cfg;
    1084                 :            :         int ret;
    1085                 :            : 
    1086                 :          0 :         cfg.num = num;
    1087                 :          0 :         cfg.group = group;
    1088                 :            : 
    1089                 :          0 :         ret = dlb2_iface_set_sn_allocation(handle, &cfg);
    1090         [ #  # ]:          0 :         if (ret < 0) {
    1091                 :          0 :                 DLB2_LOG_ERR("dlb2: set_sn_allocation ret=%d (driver status: %s)\n",
    1092                 :            :                              ret, dlb2_error_strings[cfg.response.status]);
    1093                 :          0 :                 return ret;
    1094                 :            :         }
    1095                 :            : 
    1096                 :            :         return ret;
    1097                 :            : }
    1098                 :            : 
    1099                 :            : static int32_t
    1100                 :          0 : dlb2_get_sn_occupancy(struct dlb2_eventdev *dlb2, int group)
    1101                 :            : {
    1102                 :          0 :         struct dlb2_hw_dev *handle = &dlb2->qm_instance;
    1103                 :            :         struct dlb2_get_sn_occupancy_args cfg;
    1104                 :            :         int ret;
    1105                 :            : 
    1106                 :          0 :         cfg.group = group;
    1107                 :            : 
    1108                 :          0 :         ret = dlb2_iface_get_sn_occupancy(handle, &cfg);
    1109         [ #  # ]:          0 :         if (ret < 0) {
    1110                 :          0 :                 DLB2_LOG_ERR("dlb2: get_sn_occupancy ret=%d (driver status: %s)\n",
    1111                 :            :                              ret, dlb2_error_strings[cfg.response.status]);
    1112                 :          0 :                 return ret;
    1113                 :            :         }
    1114                 :            : 
    1115                 :          0 :         return cfg.response.id;
    1116                 :            : }
    1117                 :            : 
    1118                 :            : /* Query the current sequence number allocations and, if they conflict with the
    1119                 :            :  * requested LDB queue configuration, attempt to re-allocate sequence numbers.
    1120                 :            :  * This is best-effort; if it fails, the PMD will attempt to configure the
    1121                 :            :  * load-balanced queue and return an error.
    1122                 :            :  */
    1123                 :            : static void
    1124                 :          0 : dlb2_program_sn_allocation(struct dlb2_eventdev *dlb2,
    1125                 :            :                            const struct rte_event_queue_conf *queue_conf)
    1126                 :            : {
    1127                 :            :         int grp_occupancy[DLB2_NUM_SN_GROUPS];
    1128                 :            :         int grp_alloc[DLB2_NUM_SN_GROUPS];
    1129                 :            :         int i, sequence_numbers;
    1130                 :            : 
    1131                 :          0 :         sequence_numbers = (int)queue_conf->nb_atomic_order_sequences;
    1132                 :            : 
    1133         [ #  # ]:          0 :         for (i = 0; i < DLB2_NUM_SN_GROUPS; i++) {
    1134                 :            :                 int total_slots;
    1135                 :            : 
    1136                 :          0 :                 grp_alloc[i] = dlb2_get_sn_allocation(dlb2, i);
    1137         [ #  # ]:          0 :                 if (grp_alloc[i] < 0)
    1138                 :          0 :                         return;
    1139                 :            : 
    1140                 :          0 :                 total_slots = DLB2_MAX_LDB_SN_ALLOC / grp_alloc[i];
    1141                 :            : 
    1142                 :          0 :                 grp_occupancy[i] = dlb2_get_sn_occupancy(dlb2, i);
    1143         [ #  # ]:          0 :                 if (grp_occupancy[i] < 0)
    1144                 :            :                         return;
    1145                 :            : 
    1146                 :            :                 /* DLB has at least one available slot for the requested
    1147                 :            :                  * sequence numbers, so no further configuration required.
    1148                 :            :                  */
    1149   [ #  #  #  # ]:          0 :                 if (grp_alloc[i] == sequence_numbers &&
    1150                 :            :                     grp_occupancy[i] < total_slots)
    1151                 :            :                         return;
    1152                 :            :         }
    1153                 :            : 
    1154                 :            :         /* None of the sequence number groups are configured for the requested
    1155                 :            :          * sequence numbers, so we have to reconfigure one of them. This is
    1156                 :            :          * only possible if a group is not in use.
    1157                 :            :          */
    1158         [ #  # ]:          0 :         for (i = 0; i < DLB2_NUM_SN_GROUPS; i++) {
    1159         [ #  # ]:          0 :                 if (grp_occupancy[i] == 0)
    1160                 :            :                         break;
    1161                 :            :         }
    1162                 :            : 
    1163         [ #  # ]:          0 :         if (i == DLB2_NUM_SN_GROUPS) {
    1164                 :          0 :                 DLB2_LOG_ERR("[%s()] No groups with %d sequence_numbers are available or have free slots\n",
    1165                 :            :                        __func__, sequence_numbers);
    1166                 :          0 :                 return;
    1167                 :            :         }
    1168                 :            : 
    1169                 :            :         /* Attempt to configure slot i with the requested number of sequence
    1170                 :            :          * numbers. Ignore the return value -- if this fails, the error will be
    1171                 :            :          * caught during subsequent queue configuration.
    1172                 :            :          */
    1173                 :          0 :         dlb2_set_sn_allocation(dlb2, i, sequence_numbers);
    1174                 :            : }
    1175                 :            : 
    1176                 :            : static int32_t
    1177                 :          0 : dlb2_hw_create_ldb_queue(struct dlb2_eventdev *dlb2,
    1178                 :            :                          struct dlb2_eventdev_queue *ev_queue,
    1179                 :            :                          const struct rte_event_queue_conf *evq_conf)
    1180                 :            : {
    1181                 :          0 :         struct dlb2_hw_dev *handle = &dlb2->qm_instance;
    1182                 :            :         struct dlb2_queue *queue = &ev_queue->qm_queue;
    1183                 :            :         struct dlb2_create_ldb_queue_args cfg;
    1184                 :            :         int32_t ret;
    1185                 :            :         uint32_t qm_qid;
    1186                 :            :         int sched_type = -1;
    1187                 :            : 
    1188         [ #  # ]:          0 :         if (evq_conf == NULL)
    1189                 :            :                 return -EINVAL;
    1190                 :            : 
    1191         [ #  # ]:          0 :         if (evq_conf->event_queue_cfg & RTE_EVENT_QUEUE_CFG_ALL_TYPES) {
    1192         [ #  # ]:          0 :                 if (evq_conf->nb_atomic_order_sequences != 0)
    1193                 :            :                         sched_type = RTE_SCHED_TYPE_ORDERED;
    1194                 :            :                 else
    1195                 :            :                         sched_type = RTE_SCHED_TYPE_PARALLEL;
    1196                 :            :         } else
    1197                 :          0 :                 sched_type = evq_conf->schedule_type;
    1198                 :            : 
    1199                 :          0 :         cfg.num_atomic_inflights = DLB2_NUM_ATOMIC_INFLIGHTS_PER_QUEUE;
    1200                 :          0 :         cfg.num_sequence_numbers = evq_conf->nb_atomic_order_sequences;
    1201                 :          0 :         cfg.num_qid_inflights = evq_conf->nb_atomic_order_sequences;
    1202                 :            : 
    1203         [ #  # ]:          0 :         if (sched_type != RTE_SCHED_TYPE_ORDERED) {
    1204                 :          0 :                 cfg.num_sequence_numbers = 0;
    1205                 :          0 :                 cfg.num_qid_inflights = 2048;
    1206                 :            :         }
    1207                 :            : 
    1208                 :            :         /* App should set this to the number of hardware flows they want, not
    1209                 :            :          * the overall number of flows they're going to use. E.g. if app is
    1210                 :            :          * using 64 flows and sets compression to 64, best-case they'll get
    1211                 :            :          * 64 unique hashed flows in hardware.
    1212                 :            :          */
    1213         [ #  # ]:          0 :         switch (evq_conf->nb_atomic_flows) {
    1214                 :            :         /* Valid DLB2 compression levels */
    1215                 :          0 :         case 64:
    1216                 :            :         case 128:
    1217                 :            :         case 256:
    1218                 :            :         case 512:
    1219                 :            :         case (1 * 1024): /* 1K */
    1220                 :            :         case (2 * 1024): /* 2K */
    1221                 :            :         case (4 * 1024): /* 4K */
    1222                 :            :         case (64 * 1024): /* 64K */
    1223                 :          0 :                 cfg.lock_id_comp_level = evq_conf->nb_atomic_flows;
    1224                 :          0 :                 break;
    1225                 :          0 :         default:
    1226                 :            :                 /* Invalid compression level */
    1227                 :          0 :                 cfg.lock_id_comp_level = 0; /* no compression */
    1228                 :            :         }
    1229                 :            : 
    1230         [ #  # ]:          0 :         if (ev_queue->depth_threshold == 0) {
    1231                 :          0 :                 cfg.depth_threshold = dlb2->default_depth_thresh;
    1232                 :          0 :                 ev_queue->depth_threshold =
    1233                 :            :                         dlb2->default_depth_thresh;
    1234                 :            :         } else
    1235                 :          0 :                 cfg.depth_threshold = ev_queue->depth_threshold;
    1236                 :            : 
    1237                 :          0 :         ret = dlb2_iface_ldb_queue_create(handle, &cfg);
    1238         [ #  # ]:          0 :         if (ret < 0) {
    1239                 :          0 :                 DLB2_LOG_ERR("dlb2: create LB event queue error, ret=%d (driver status: %s)\n",
    1240                 :            :                              ret, dlb2_error_strings[cfg.response.status]);
    1241                 :          0 :                 return -EINVAL;
    1242                 :            :         }
    1243                 :            : 
    1244                 :          0 :         qm_qid = cfg.response.id;
    1245                 :            : 
    1246                 :            :         /* Save off queue config for debug, resource lookups, and reconfig */
    1247                 :          0 :         queue->num_qid_inflights = cfg.num_qid_inflights;
    1248                 :          0 :         queue->num_atm_inflights = cfg.num_atomic_inflights;
    1249                 :            : 
    1250                 :          0 :         queue->sched_type = sched_type;
    1251                 :          0 :         queue->config_state = DLB2_CONFIGURED;
    1252                 :            : 
    1253                 :            :         DLB2_LOG_DBG("Created LB event queue %d, nb_inflights=%d, nb_seq=%d, qid inflights=%d\n",
    1254                 :            :                      qm_qid,
    1255                 :            :                      cfg.num_atomic_inflights,
    1256                 :            :                      cfg.num_sequence_numbers,
    1257                 :            :                      cfg.num_qid_inflights);
    1258                 :            : 
    1259                 :          0 :         return qm_qid;
    1260                 :            : }
    1261                 :            : 
    1262                 :            : static int
    1263         [ #  # ]:          0 : dlb2_eventdev_ldb_queue_setup(struct rte_eventdev *dev,
    1264                 :            :                               struct dlb2_eventdev_queue *ev_queue,
    1265                 :            :                               const struct rte_event_queue_conf *queue_conf)
    1266                 :            : {
    1267                 :            :         struct dlb2_eventdev *dlb2 = dlb2_pmd_priv(dev);
    1268                 :            :         int32_t qm_qid;
    1269                 :            : 
    1270         [ #  # ]:          0 :         if (queue_conf->nb_atomic_order_sequences)
    1271                 :          0 :                 dlb2_program_sn_allocation(dlb2, queue_conf);
    1272                 :            : 
    1273                 :          0 :         qm_qid = dlb2_hw_create_ldb_queue(dlb2, ev_queue, queue_conf);
    1274         [ #  # ]:          0 :         if (qm_qid < 0) {
    1275                 :          0 :                 DLB2_LOG_ERR("Failed to create the load-balanced queue\n");
    1276                 :            : 
    1277                 :          0 :                 return qm_qid;
    1278                 :            :         }
    1279                 :            : 
    1280                 :          0 :         dlb2->qm_ldb_to_ev_queue_id[qm_qid] = ev_queue->id;
    1281                 :            : 
    1282                 :          0 :         ev_queue->qm_queue.id = qm_qid;
    1283                 :            : 
    1284                 :          0 :         return 0;
    1285                 :            : }
    1286                 :            : 
    1287                 :            : static int dlb2_num_dir_queues_setup(struct dlb2_eventdev *dlb2)
    1288                 :            : {
    1289                 :            :         int i, num = 0;
    1290                 :            : 
    1291         [ #  # ]:          0 :         for (i = 0; i < dlb2->num_queues; i++) {
    1292         [ #  # ]:          0 :                 if (dlb2->ev_queues[i].setup_done &&
    1293         [ #  # ]:          0 :                     dlb2->ev_queues[i].qm_queue.is_directed)
    1294                 :          0 :                         num++;
    1295                 :            :         }
    1296                 :            : 
    1297                 :            :         return num;
    1298                 :            : }
    1299                 :            : 
    1300                 :            : static void
    1301                 :          0 : dlb2_queue_link_teardown(struct dlb2_eventdev *dlb2,
    1302                 :            :                          struct dlb2_eventdev_queue *ev_queue)
    1303                 :            : {
    1304                 :            :         struct dlb2_eventdev_port *ev_port;
    1305                 :            :         int i, j;
    1306                 :            : 
    1307         [ #  # ]:          0 :         for (i = 0; i < dlb2->num_ports; i++) {
    1308                 :            :                 ev_port = &dlb2->ev_ports[i];
    1309                 :            : 
    1310         [ #  # ]:          0 :                 for (j = 0; j < DLB2_MAX_NUM_QIDS_PER_LDB_CQ; j++) {
    1311         [ #  # ]:          0 :                         if (!ev_port->link[j].valid ||
    1312         [ #  # ]:          0 :                             ev_port->link[j].queue_id != ev_queue->id)
    1313                 :          0 :                                 continue;
    1314                 :            : 
    1315                 :          0 :                         ev_port->link[j].valid = false;
    1316                 :          0 :                         ev_port->num_links--;
    1317                 :            :                 }
    1318                 :            :         }
    1319                 :            : 
    1320                 :          0 :         ev_queue->num_links = 0;
    1321                 :          0 : }
    1322                 :            : 
    1323                 :            : static int
    1324         [ #  # ]:          0 : dlb2_eventdev_queue_setup(struct rte_eventdev *dev,
    1325                 :            :                           uint8_t ev_qid,
    1326                 :            :                           const struct rte_event_queue_conf *queue_conf)
    1327                 :            : {
    1328                 :            :         struct dlb2_eventdev *dlb2 = dlb2_pmd_priv(dev);
    1329                 :            :         struct dlb2_eventdev_queue *ev_queue;
    1330                 :            :         int ret;
    1331                 :            : 
    1332         [ #  # ]:          0 :         if (queue_conf == NULL)
    1333                 :            :                 return -EINVAL;
    1334                 :            : 
    1335         [ #  # ]:          0 :         if (ev_qid >= dlb2->num_queues)
    1336                 :            :                 return -EINVAL;
    1337                 :            : 
    1338                 :          0 :         ev_queue = &dlb2->ev_queues[ev_qid];
    1339                 :            : 
    1340                 :          0 :         ev_queue->qm_queue.is_directed = queue_conf->event_queue_cfg &
    1341                 :            :                 RTE_EVENT_QUEUE_CFG_SINGLE_LINK;
    1342                 :          0 :         ev_queue->id = ev_qid;
    1343                 :          0 :         ev_queue->conf = *queue_conf;
    1344                 :            : 
    1345         [ #  # ]:          0 :         if (!ev_queue->qm_queue.is_directed) {
    1346                 :          0 :                 ret = dlb2_eventdev_ldb_queue_setup(dev, ev_queue, queue_conf);
    1347                 :            :         } else {
    1348                 :            :                 /* The directed queue isn't setup until link time, at which
    1349                 :            :                  * point we know its directed port ID. Directed queue setup
    1350                 :            :                  * will only fail if this queue is already setup or there are
    1351                 :            :                  * no directed queues left to configure.
    1352                 :            :                  */
    1353                 :            :                 ret = 0;
    1354                 :            : 
    1355                 :          0 :                 ev_queue->qm_queue.config_state = DLB2_NOT_CONFIGURED;
    1356                 :            : 
    1357         [ #  # ]:          0 :                 if (ev_queue->setup_done ||
    1358         [ #  # ]:          0 :                     dlb2_num_dir_queues_setup(dlb2) == dlb2->num_dir_queues)
    1359                 :            :                         ret = -EINVAL;
    1360                 :            :         }
    1361                 :            : 
    1362                 :            :         /* Tear down pre-existing port->queue links */
    1363   [ #  #  #  # ]:          0 :         if (!ret && dlb2->run_state == DLB2_RUN_STATE_STOPPED)
    1364                 :          0 :                 dlb2_queue_link_teardown(dlb2, ev_queue);
    1365                 :            : 
    1366         [ #  # ]:          0 :         if (!ret)
    1367                 :          0 :                 ev_queue->setup_done = true;
    1368                 :            : 
    1369                 :            :         return ret;
    1370                 :            : }
    1371                 :            : 
    1372                 :            : static int
    1373                 :          0 : dlb2_init_consume_qe(struct dlb2_port *qm_port, char *mz_name)
    1374                 :            : {
    1375                 :            :         struct dlb2_cq_pop_qe *qe;
    1376                 :            : 
    1377                 :          0 :         qe = rte_zmalloc(mz_name,
    1378                 :            :                         DLB2_NUM_QES_PER_CACHE_LINE *
    1379                 :            :                                 sizeof(struct dlb2_cq_pop_qe),
    1380                 :            :                         RTE_CACHE_LINE_SIZE);
    1381                 :            : 
    1382         [ #  # ]:          0 :         if (qe == NULL) {
    1383                 :          0 :                 DLB2_LOG_ERR("dlb2: no memory for consume_qe\n");
    1384                 :          0 :                 return -ENOMEM;
    1385                 :            :         }
    1386                 :          0 :         qm_port->consume_qe = qe;
    1387                 :            : 
    1388                 :          0 :         qe->qe_valid = 0;
    1389                 :          0 :         qe->qe_frag = 0;
    1390                 :          0 :         qe->qe_comp = 0;
    1391                 :          0 :         qe->cq_token = 1;
    1392                 :            :         /* Tokens value is 0-based; i.e. '0' returns 1 token, '1' returns 2,
    1393                 :            :          * and so on.
    1394                 :            :          */
    1395                 :          0 :         qe->tokens = 0;      /* set at run time */
    1396                 :          0 :         qe->meas_lat = 0;
    1397                 :          0 :         qe->no_dec = 0;
    1398                 :            :         /* Completion IDs are disabled */
    1399                 :          0 :         qe->cmp_id = 0;
    1400                 :            : 
    1401                 :          0 :         return 0;
    1402                 :            : }
    1403                 :            : 
    1404                 :            : static int
    1405                 :          0 : dlb2_init_int_arm_qe(struct dlb2_port *qm_port, char *mz_name)
    1406                 :            : {
    1407                 :            :         struct dlb2_enqueue_qe *qe;
    1408                 :            : 
    1409                 :          0 :         qe = rte_zmalloc(mz_name,
    1410                 :            :                         DLB2_NUM_QES_PER_CACHE_LINE *
    1411                 :            :                                 sizeof(struct dlb2_enqueue_qe),
    1412                 :            :                         RTE_CACHE_LINE_SIZE);
    1413                 :            : 
    1414         [ #  # ]:          0 :         if (qe == NULL) {
    1415                 :          0 :                 DLB2_LOG_ERR("dlb2: no memory for complete_qe\n");
    1416                 :          0 :                 return -ENOMEM;
    1417                 :            :         }
    1418                 :          0 :         qm_port->int_arm_qe = qe;
    1419                 :            : 
    1420                 :            :         /* V2 - INT ARM is CQ_TOKEN + FRAG */
    1421                 :          0 :         qe->qe_valid = 0;
    1422                 :          0 :         qe->qe_frag = 1;
    1423                 :          0 :         qe->qe_comp = 0;
    1424                 :          0 :         qe->cq_token = 1;
    1425                 :          0 :         qe->meas_lat = 0;
    1426                 :          0 :         qe->no_dec = 0;
    1427                 :            :         /* Completion IDs are disabled */
    1428                 :          0 :         qe->cmp_id = 0;
    1429                 :            : 
    1430                 :          0 :         return 0;
    1431                 :            : }
    1432                 :            : 
    1433                 :            : static int
    1434                 :          0 : dlb2_init_qe_mem(struct dlb2_port *qm_port, char *mz_name)
    1435                 :            : {
    1436                 :            :         int ret, sz;
    1437                 :            : 
    1438                 :            :         sz = DLB2_NUM_QES_PER_CACHE_LINE * sizeof(struct dlb2_enqueue_qe);
    1439                 :            : 
    1440                 :          0 :         qm_port->qe4 = rte_zmalloc(mz_name, sz, RTE_CACHE_LINE_SIZE);
    1441                 :            : 
    1442         [ #  # ]:          0 :         if (qm_port->qe4 == NULL) {
    1443                 :          0 :                 DLB2_LOG_ERR("dlb2: no qe4 memory\n");
    1444                 :            :                 ret = -ENOMEM;
    1445                 :          0 :                 goto error_exit;
    1446                 :            :         }
    1447                 :            : 
    1448                 :          0 :         ret = dlb2_init_int_arm_qe(qm_port, mz_name);
    1449         [ #  # ]:          0 :         if (ret < 0) {
    1450                 :          0 :                 DLB2_LOG_ERR("dlb2: dlb2_init_int_arm_qe ret=%d\n", ret);
    1451                 :          0 :                 goto error_exit;
    1452                 :            :         }
    1453                 :            : 
    1454                 :          0 :         ret = dlb2_init_consume_qe(qm_port, mz_name);
    1455         [ #  # ]:          0 :         if (ret < 0) {
    1456                 :          0 :                 DLB2_LOG_ERR("dlb2: dlb2_init_consume_qe ret=%d\n", ret);
    1457                 :          0 :                 goto error_exit;
    1458                 :            :         }
    1459                 :            : 
    1460                 :            :         return 0;
    1461                 :            : 
    1462                 :          0 : error_exit:
    1463                 :            : 
    1464                 :          0 :         dlb2_free_qe_mem(qm_port);
    1465                 :            : 
    1466                 :          0 :         return ret;
    1467                 :            : }
    1468                 :            : 
    1469                 :            : static inline uint16_t
    1470                 :            : dlb2_event_enqueue_delayed(void *event_port,
    1471                 :            :                            const struct rte_event events[]);
    1472                 :            : 
    1473                 :            : static inline uint16_t
    1474                 :            : dlb2_event_enqueue_burst_delayed(void *event_port,
    1475                 :            :                                  const struct rte_event events[],
    1476                 :            :                                  uint16_t num);
    1477                 :            : 
    1478                 :            : static inline uint16_t
    1479                 :            : dlb2_event_enqueue_new_burst_delayed(void *event_port,
    1480                 :            :                                      const struct rte_event events[],
    1481                 :            :                                      uint16_t num);
    1482                 :            : 
    1483                 :            : static inline uint16_t
    1484                 :            : dlb2_event_enqueue_forward_burst_delayed(void *event_port,
    1485                 :            :                                          const struct rte_event events[],
    1486                 :            :                                          uint16_t num);
    1487                 :            : 
    1488                 :            : /* Generate the required bitmask for rotate-style expected QE gen bits.
    1489                 :            :  * This requires a pattern of 1's and zeros, starting with expected as
    1490                 :            :  * 1 bits, so when hardware writes 0's they're "new". This requires the
    1491                 :            :  * ring size to be powers of 2 to wrap correctly.
    1492                 :            :  */
    1493                 :            : static void
    1494                 :            : dlb2_hw_cq_bitmask_init(struct dlb2_port *qm_port, uint32_t cq_depth)
    1495                 :            : {
    1496                 :            :         uint64_t cq_build_mask = 0;
    1497                 :            :         uint32_t i;
    1498                 :            : 
    1499                 :          0 :         if (cq_depth > 64)
    1500                 :            :                 return; /* need to fall back to scalar code */
    1501                 :            : 
    1502                 :            :         /*
    1503                 :            :          * all 1's in first u64, all zeros in second is correct bit pattern to
    1504                 :            :          * start. Special casing == 64 easier than adapting complex loop logic.
    1505                 :            :          */
    1506   [ #  #  #  # ]:          0 :         if (cq_depth == 64) {
    1507                 :          0 :                 qm_port->cq_rolling_mask = 0;
    1508                 :          0 :                 qm_port->cq_rolling_mask_2 = -1;
    1509                 :          0 :                 return;
    1510                 :            :         }
    1511                 :            : 
    1512   [ #  #  #  # ]:          0 :         for (i = 0; i < 64; i += (cq_depth * 2))
    1513                 :          0 :                 cq_build_mask |= ((1ULL << cq_depth) - 1) << (i + cq_depth);
    1514                 :            : 
    1515                 :          0 :         qm_port->cq_rolling_mask = cq_build_mask;
    1516                 :          0 :         qm_port->cq_rolling_mask_2 = cq_build_mask;
    1517                 :            : }
    1518                 :            : 
    1519                 :            : static int
    1520                 :          0 : dlb2_hw_create_ldb_port(struct dlb2_eventdev *dlb2,
    1521                 :            :                         struct dlb2_eventdev_port *ev_port,
    1522                 :            :                         uint32_t dequeue_depth,
    1523                 :            :                         uint32_t enqueue_depth)
    1524                 :            : {
    1525                 :          0 :         struct dlb2_hw_dev *handle = &dlb2->qm_instance;
    1526                 :          0 :         struct dlb2_create_ldb_port_args cfg = { {0} };
    1527                 :            :         int ret;
    1528                 :            :         struct dlb2_port *qm_port = NULL;
    1529                 :            :         char mz_name[RTE_MEMZONE_NAMESIZE];
    1530                 :            :         uint32_t qm_port_id;
    1531                 :            :         uint16_t ldb_credit_high_watermark = 0;
    1532                 :            :         uint16_t dir_credit_high_watermark = 0;
    1533                 :            :         uint16_t credit_high_watermark = 0;
    1534                 :            : 
    1535                 :            :         if (handle == NULL)
    1536                 :            :                 return -EINVAL;
    1537                 :            : 
    1538         [ #  # ]:          0 :         if (dequeue_depth < DLB2_MIN_CQ_DEPTH) {
    1539                 :          0 :                 DLB2_LOG_ERR("dlb2: invalid cq depth, must be at least %d\n",
    1540                 :            :                              DLB2_MIN_CQ_DEPTH);
    1541                 :          0 :                 return -EINVAL;
    1542                 :            :         }
    1543                 :            : 
    1544   [ #  #  #  #  :          0 :         if (dlb2->version == DLB2_HW_V2 && ev_port->cq_weight != 0 &&
                   #  # ]
    1545                 :            :             ev_port->cq_weight > dequeue_depth) {
    1546                 :          0 :                 DLB2_LOG_ERR("dlb2: invalid cq dequeue depth %d, must be >= cq weight %d\n",
    1547                 :            :                              dequeue_depth, ev_port->cq_weight);
    1548                 :          0 :                 return -EINVAL;
    1549                 :            :         }
    1550                 :            : 
    1551                 :          0 :         rte_spinlock_lock(&handle->resource_lock);
    1552                 :            : 
    1553                 :            :         /* We round up to the next power of 2 if necessary */
    1554                 :          0 :         cfg.cq_depth = rte_align32pow2(dequeue_depth);
    1555                 :          0 :         cfg.cq_depth_threshold = 1;
    1556                 :            : 
    1557                 :          0 :         cfg.cq_history_list_size = cfg.cq_depth;
    1558                 :            : 
    1559                 :          0 :         cfg.cos_id = ev_port->cos_id;
    1560                 :          0 :         cfg.cos_strict = 0;/* best effots */
    1561                 :            : 
    1562                 :            :         /* User controls the LDB high watermark via enqueue depth. The DIR high
    1563                 :            :          * watermark is equal, unless the directed credit pool is too small.
    1564                 :            :          */
    1565         [ #  # ]:          0 :         if (dlb2->version == DLB2_HW_V2) {
    1566                 :          0 :                 ldb_credit_high_watermark = enqueue_depth;
    1567                 :            :                 /* If there are no directed ports, the kernel driver will
    1568                 :            :                  * ignore this port's directed credit settings. Don't use
    1569                 :            :                  * enqueue_depth if it would require more directed credits
    1570                 :            :                  * than are available.
    1571                 :            :                  */
    1572                 :          0 :                 dir_credit_high_watermark =
    1573                 :          0 :                         RTE_MIN(enqueue_depth,
    1574                 :            :                                 handle->cfg.num_dir_credits / dlb2->num_ports);
    1575                 :            :         } else
    1576                 :          0 :                 credit_high_watermark = enqueue_depth;
    1577                 :            : 
    1578                 :            :         /* Per QM values */
    1579                 :            : 
    1580                 :          0 :         ret = dlb2_iface_ldb_port_create(handle, &cfg,  dlb2->poll_mode);
    1581         [ #  # ]:          0 :         if (ret < 0) {
    1582                 :          0 :                 DLB2_LOG_ERR("dlb2: dlb2_ldb_port_create error, ret=%d (driver status: %s)\n",
    1583                 :            :                              ret, dlb2_error_strings[cfg.response.status]);
    1584                 :          0 :                 goto error_exit;
    1585                 :            :         }
    1586                 :            : 
    1587                 :          0 :         qm_port_id = cfg.response.id;
    1588                 :            : 
    1589                 :            :         DLB2_LOG_DBG("dlb2: ev_port %d uses qm LB port %d <<<<<\n",
    1590                 :            :                      ev_port->id, qm_port_id);
    1591                 :            : 
    1592                 :          0 :         qm_port = &ev_port->qm_port;
    1593                 :          0 :         qm_port->ev_port = ev_port; /* back ptr */
    1594                 :          0 :         qm_port->dlb2 = dlb2; /* back ptr */
    1595                 :            :         /*
    1596                 :            :          * Allocate and init local qe struct(s).
    1597                 :            :          * Note: MOVDIR64 requires the enqueue QE (qe4) to be aligned.
    1598                 :            :          */
    1599                 :            : 
    1600                 :          0 :         snprintf(mz_name, sizeof(mz_name), "dlb2_ldb_port%d",
    1601                 :            :                  ev_port->id);
    1602                 :            : 
    1603                 :          0 :         ret = dlb2_init_qe_mem(qm_port, mz_name);
    1604         [ #  # ]:          0 :         if (ret < 0) {
    1605                 :          0 :                 DLB2_LOG_ERR("dlb2: init_qe_mem failed, ret=%d\n", ret);
    1606                 :          0 :                 goto error_exit;
    1607                 :            :         }
    1608                 :            : 
    1609                 :          0 :         qm_port->id = qm_port_id;
    1610                 :            : 
    1611   [ #  #  #  # ]:          0 :         if (dlb2->version == DLB2_HW_V2_5 && (dlb2->enable_cq_weight == true)) {
    1612                 :          0 :                 struct dlb2_enable_cq_weight_args cq_weight_args = { {0} };
    1613                 :          0 :                 cq_weight_args.port_id = qm_port->id;
    1614                 :          0 :                 cq_weight_args.limit = dequeue_depth;
    1615                 :          0 :                 ret = dlb2_iface_enable_cq_weight(handle, &cq_weight_args);
    1616                 :            : 
    1617         [ #  # ]:          0 :                 if (ret < 0) {
    1618                 :          0 :                         DLB2_LOG_ERR("dlb2: dlb2_dir_port_create error, ret=%d (driver status: %s)\n",
    1619                 :            :                                         ret,
    1620                 :            :                                         dlb2_error_strings[cfg.response.  status]);
    1621                 :          0 :                         goto error_exit;
    1622                 :            :                 }
    1623                 :          0 :                 qm_port->cq_weight = dequeue_depth;
    1624                 :            :         } else {
    1625                 :          0 :                 qm_port->cq_weight = 0;
    1626                 :            :         }
    1627                 :            : 
    1628                 :            :         /* CQs with depth < 8 use an 8-entry queue, but withhold credits so
    1629                 :            :          * the effective depth is smaller.
    1630                 :            :          */
    1631                 :          0 :         qm_port->cq_depth = cfg.cq_depth <= 8 ? 8 : cfg.cq_depth;
    1632                 :          0 :         qm_port->cq_idx = 0;
    1633                 :          0 :         qm_port->cq_idx_unmasked = 0;
    1634                 :            : 
    1635         [ #  # ]:          0 :         if (dlb2->poll_mode == DLB2_CQ_POLL_MODE_SPARSE)
    1636                 :          0 :                 qm_port->cq_depth_mask = (qm_port->cq_depth * 4) - 1;
    1637                 :            :         else
    1638                 :          0 :                 qm_port->cq_depth_mask = qm_port->cq_depth - 1;
    1639                 :            : 
    1640         [ #  # ]:          0 :         qm_port->gen_bit_shift = rte_popcount32(qm_port->cq_depth_mask);
    1641                 :            :         /* starting value of gen bit - it toggles at wrap time */
    1642                 :          0 :         qm_port->gen_bit = 1;
    1643                 :            : 
    1644         [ #  # ]:          0 :         dlb2_hw_cq_bitmask_init(qm_port, qm_port->cq_depth);
    1645                 :            : 
    1646                 :          0 :         qm_port->int_armed = false;
    1647                 :            : 
    1648                 :            :         /* Save off for later use in info and lookup APIs. */
    1649                 :          0 :         qm_port->qid_mappings = &dlb2->qm_ldb_to_ev_queue_id[0];
    1650                 :            : 
    1651                 :          0 :         qm_port->dequeue_depth = dequeue_depth;
    1652                 :          0 :         qm_port->token_pop_thresh = dequeue_depth;
    1653                 :            : 
    1654                 :            :         /* The default enqueue functions do not include delayed-pop support for
    1655                 :            :          * performance reasons.
    1656                 :            :          */
    1657         [ #  # ]:          0 :         if (qm_port->token_pop_mode == DELAYED_POP) {
    1658                 :          0 :                 dlb2->event_dev->enqueue = dlb2_event_enqueue_delayed;
    1659                 :          0 :                 dlb2->event_dev->enqueue_burst =
    1660                 :            :                         dlb2_event_enqueue_burst_delayed;
    1661                 :          0 :                 dlb2->event_dev->enqueue_new_burst =
    1662                 :            :                         dlb2_event_enqueue_new_burst_delayed;
    1663                 :          0 :                 dlb2->event_dev->enqueue_forward_burst =
    1664                 :            :                         dlb2_event_enqueue_forward_burst_delayed;
    1665                 :            :         }
    1666                 :            : 
    1667                 :          0 :         qm_port->owed_tokens = 0;
    1668                 :          0 :         qm_port->issued_releases = 0;
    1669                 :            : 
    1670                 :            :         /* Save config message too. */
    1671         [ #  # ]:          0 :         rte_memcpy(&qm_port->cfg.ldb, &cfg, sizeof(qm_port->cfg.ldb));
    1672                 :            : 
    1673                 :            :         /* update state */
    1674                 :          0 :         qm_port->state = PORT_STARTED; /* enabled at create time */
    1675                 :          0 :         qm_port->config_state = DLB2_CONFIGURED;
    1676                 :            : 
    1677         [ #  # ]:          0 :         if (dlb2->version == DLB2_HW_V2) {
    1678                 :          0 :                 qm_port->dir_credits = dir_credit_high_watermark;
    1679                 :          0 :                 qm_port->ldb_credits = ldb_credit_high_watermark;
    1680                 :          0 :                 qm_port->credit_pool[DLB2_DIR_QUEUE] = &dlb2->dir_credit_pool;
    1681                 :          0 :                 qm_port->credit_pool[DLB2_LDB_QUEUE] = &dlb2->ldb_credit_pool;
    1682                 :            : 
    1683                 :            :                 DLB2_LOG_DBG("dlb2: created ldb port %d, depth = %d, ldb credits=%d, dir credits=%d\n",
    1684                 :            :                              qm_port_id,
    1685                 :            :                              dequeue_depth,
    1686                 :            :                              qm_port->ldb_credits,
    1687                 :            :                              qm_port->dir_credits);
    1688                 :            :         } else {
    1689                 :          0 :                 qm_port->credits = credit_high_watermark;
    1690                 :          0 :                 qm_port->credit_pool[DLB2_COMBINED_POOL] = &dlb2->credit_pool;
    1691                 :            : 
    1692                 :            :                 DLB2_LOG_DBG("dlb2: created ldb port %d, depth = %d, credits=%d\n",
    1693                 :            :                              qm_port_id,
    1694                 :            :                              dequeue_depth,
    1695                 :            :                              qm_port->credits);
    1696                 :            :         }
    1697                 :            : 
    1698                 :          0 :         qm_port->use_scalar = false;
    1699                 :            : 
    1700                 :            : #if (!defined RTE_ARCH_X86_64)
    1701                 :            :         qm_port->use_scalar = true;
    1702                 :            : #else
    1703         [ #  # ]:          0 :         if ((qm_port->cq_depth > 64) ||
    1704                 :          0 :             (!rte_is_power_of_2(qm_port->cq_depth)) ||
    1705         [ #  # ]:          0 :             (dlb2->vector_opts_enabled == false))
    1706                 :          0 :                 qm_port->use_scalar = true;
    1707                 :            : #endif
    1708                 :            : 
    1709                 :            :         rte_spinlock_unlock(&handle->resource_lock);
    1710                 :            : 
    1711                 :          0 :         return 0;
    1712                 :            : 
    1713                 :          0 : error_exit:
    1714                 :            : 
    1715                 :            :         if (qm_port)
    1716                 :          0 :                 dlb2_free_qe_mem(qm_port);
    1717                 :            : 
    1718                 :            :         rte_spinlock_unlock(&handle->resource_lock);
    1719                 :            : 
    1720                 :          0 :         DLB2_LOG_ERR("dlb2: create ldb port failed!\n");
    1721                 :            : 
    1722                 :          0 :         return ret;
    1723                 :            : }
    1724                 :            : 
    1725                 :            : static void
    1726                 :            : dlb2_port_link_teardown(struct dlb2_eventdev *dlb2,
    1727                 :            :                         struct dlb2_eventdev_port *ev_port)
    1728                 :            : {
    1729                 :            :         struct dlb2_eventdev_queue *ev_queue;
    1730                 :            :         int i;
    1731                 :            : 
    1732         [ #  # ]:          0 :         for (i = 0; i < DLB2_MAX_NUM_QIDS_PER_LDB_CQ; i++) {
    1733         [ #  # ]:          0 :                 if (!ev_port->link[i].valid)
    1734                 :          0 :                         continue;
    1735                 :            : 
    1736                 :          0 :                 ev_queue = &dlb2->ev_queues[ev_port->link[i].queue_id];
    1737                 :            : 
    1738                 :          0 :                 ev_port->link[i].valid = false;
    1739                 :          0 :                 ev_port->num_links--;
    1740                 :          0 :                 ev_queue->num_links--;
    1741                 :            :         }
    1742                 :            : }
    1743                 :            : 
    1744                 :            : static int
    1745                 :          0 : dlb2_hw_create_dir_port(struct dlb2_eventdev *dlb2,
    1746                 :            :                         struct dlb2_eventdev_port *ev_port,
    1747                 :            :                         uint32_t dequeue_depth,
    1748                 :            :                         uint32_t enqueue_depth)
    1749                 :            : {
    1750                 :          0 :         struct dlb2_hw_dev *handle = &dlb2->qm_instance;
    1751                 :          0 :         struct dlb2_create_dir_port_args cfg = { {0} };
    1752                 :            :         int ret;
    1753                 :            :         struct dlb2_port *qm_port = NULL;
    1754                 :            :         char mz_name[RTE_MEMZONE_NAMESIZE];
    1755                 :            :         uint32_t qm_port_id;
    1756                 :            :         uint16_t ldb_credit_high_watermark = 0;
    1757                 :            :         uint16_t dir_credit_high_watermark = 0;
    1758                 :            :         uint16_t credit_high_watermark = 0;
    1759                 :            : 
    1760         [ #  # ]:          0 :         if (dlb2 == NULL || handle == NULL)
    1761                 :            :                 return -EINVAL;
    1762                 :            : 
    1763         [ #  # ]:          0 :         if (dequeue_depth < DLB2_MIN_CQ_DEPTH) {
    1764                 :          0 :                 DLB2_LOG_ERR("dlb2: invalid dequeue_depth, must be %d-%d\n",
    1765                 :            :                              DLB2_MIN_CQ_DEPTH, DLB2_MAX_INPUT_QUEUE_DEPTH);
    1766                 :          0 :                 return -EINVAL;
    1767                 :            :         }
    1768                 :            : 
    1769         [ #  # ]:          0 :         if (enqueue_depth < DLB2_MIN_ENQUEUE_DEPTH) {
    1770                 :          0 :                 DLB2_LOG_ERR("dlb2: invalid enqueue_depth, must be at least %d\n",
    1771                 :            :                              DLB2_MIN_ENQUEUE_DEPTH);
    1772                 :          0 :                 return -EINVAL;
    1773                 :            :         }
    1774                 :            : 
    1775                 :          0 :         rte_spinlock_lock(&handle->resource_lock);
    1776                 :            : 
    1777                 :            :         /* Directed queues are configured at link time. */
    1778         [ #  # ]:          0 :         cfg.queue_id = -1;
    1779                 :            : 
    1780                 :            :         /* We round up to the next power of 2 if necessary */
    1781                 :          0 :         cfg.cq_depth = rte_align32pow2(dequeue_depth);
    1782                 :          0 :         cfg.cq_depth_threshold = 1;
    1783                 :            : 
    1784                 :            :         /* User controls the LDB high watermark via enqueue depth. The DIR high
    1785                 :            :          * watermark is equal, unless the directed credit pool is too small.
    1786                 :            :          */
    1787         [ #  # ]:          0 :         if (dlb2->version == DLB2_HW_V2) {
    1788                 :          0 :                 ldb_credit_high_watermark = enqueue_depth;
    1789                 :            :                 /* Don't use enqueue_depth if it would require more directed
    1790                 :            :                  * credits than are available.
    1791                 :            :                  */
    1792                 :          0 :                 dir_credit_high_watermark =
    1793                 :          0 :                         RTE_MIN(enqueue_depth,
    1794                 :            :                                 handle->cfg.num_dir_credits / dlb2->num_ports);
    1795                 :            :         } else
    1796                 :          0 :                 credit_high_watermark = enqueue_depth;
    1797                 :            : 
    1798         [ #  # ]:          0 :         if (ev_port->conf.event_port_cfg & RTE_EVENT_PORT_CFG_HINT_PRODUCER)
    1799                 :          0 :                 cfg.is_producer = 1;
    1800                 :            : 
    1801                 :            :         /* Per QM values */
    1802                 :            : 
    1803                 :          0 :         ret = dlb2_iface_dir_port_create(handle, &cfg,  dlb2->poll_mode);
    1804         [ #  # ]:          0 :         if (ret < 0) {
    1805                 :          0 :                 DLB2_LOG_ERR("dlb2: dlb2_dir_port_create error, ret=%d (driver status: %s)\n",
    1806                 :            :                              ret, dlb2_error_strings[cfg.response.status]);
    1807                 :          0 :                 goto error_exit;
    1808                 :            :         }
    1809                 :            : 
    1810                 :          0 :         qm_port_id = cfg.response.id;
    1811                 :            : 
    1812                 :            :         DLB2_LOG_DBG("dlb2: ev_port %d uses qm DIR port %d <<<<<\n",
    1813                 :            :                      ev_port->id, qm_port_id);
    1814                 :            : 
    1815                 :          0 :         qm_port = &ev_port->qm_port;
    1816                 :          0 :         qm_port->ev_port = ev_port; /* back ptr */
    1817                 :          0 :         qm_port->dlb2 = dlb2;  /* back ptr */
    1818                 :            : 
    1819                 :            :         /*
    1820                 :            :          * Init local qe struct(s).
    1821                 :            :          * Note: MOVDIR64 requires the enqueue QE to be aligned
    1822                 :            :          */
    1823                 :            : 
    1824                 :          0 :         snprintf(mz_name, sizeof(mz_name), "dlb2_dir_port%d",
    1825                 :            :                  ev_port->id);
    1826                 :            : 
    1827                 :          0 :         ret = dlb2_init_qe_mem(qm_port, mz_name);
    1828                 :            : 
    1829         [ #  # ]:          0 :         if (ret < 0) {
    1830                 :          0 :                 DLB2_LOG_ERR("dlb2: init_qe_mem failed, ret=%d\n", ret);
    1831                 :          0 :                 goto error_exit;
    1832                 :            :         }
    1833                 :            : 
    1834                 :          0 :         qm_port->id = qm_port_id;
    1835                 :            : 
    1836         [ #  # ]:          0 :         if (dlb2->version == DLB2_HW_V2) {
    1837                 :          0 :                 qm_port->cached_ldb_credits = 0;
    1838                 :          0 :                 qm_port->cached_dir_credits = 0;
    1839                 :            :         } else
    1840                 :          0 :                 qm_port->cached_credits = 0;
    1841                 :            : 
    1842                 :            :         /* CQs with depth < 8 use an 8-entry queue, but withhold credits so
    1843                 :            :          * the effective depth is smaller.
    1844                 :            :          */
    1845                 :          0 :         qm_port->cq_depth = cfg.cq_depth <= 8 ? 8 : cfg.cq_depth;
    1846                 :          0 :         qm_port->cq_idx = 0;
    1847                 :          0 :         qm_port->cq_idx_unmasked = 0;
    1848                 :            : 
    1849         [ #  # ]:          0 :         if (dlb2->poll_mode == DLB2_CQ_POLL_MODE_SPARSE)
    1850                 :          0 :                 qm_port->cq_depth_mask = (cfg.cq_depth * 4) - 1;
    1851                 :            :         else
    1852                 :          0 :                 qm_port->cq_depth_mask = cfg.cq_depth - 1;
    1853                 :            : 
    1854         [ #  # ]:          0 :         qm_port->gen_bit_shift = rte_popcount32(qm_port->cq_depth_mask);
    1855                 :            :         /* starting value of gen bit - it toggles at wrap time */
    1856                 :          0 :         qm_port->gen_bit = 1;
    1857         [ #  # ]:          0 :         dlb2_hw_cq_bitmask_init(qm_port, qm_port->cq_depth);
    1858                 :            : 
    1859                 :          0 :         qm_port->int_armed = false;
    1860                 :            : 
    1861                 :            :         /* Save off for later use in info and lookup APIs. */
    1862                 :          0 :         qm_port->qid_mappings = &dlb2->qm_dir_to_ev_queue_id[0];
    1863                 :            : 
    1864                 :          0 :         qm_port->dequeue_depth = dequeue_depth;
    1865                 :            : 
    1866                 :            :         /* Directed ports are auto-pop, by default. */
    1867                 :          0 :         qm_port->token_pop_mode = AUTO_POP;
    1868                 :          0 :         qm_port->owed_tokens = 0;
    1869                 :          0 :         qm_port->issued_releases = 0;
    1870                 :            : 
    1871                 :            :         /* Save config message too. */
    1872         [ #  # ]:          0 :         rte_memcpy(&qm_port->cfg.dir, &cfg, sizeof(qm_port->cfg.dir));
    1873                 :            : 
    1874                 :            :         /* update state */
    1875                 :          0 :         qm_port->state = PORT_STARTED; /* enabled at create time */
    1876                 :          0 :         qm_port->config_state = DLB2_CONFIGURED;
    1877                 :            : 
    1878         [ #  # ]:          0 :         if (dlb2->version == DLB2_HW_V2) {
    1879                 :          0 :                 qm_port->dir_credits = dir_credit_high_watermark;
    1880                 :          0 :                 qm_port->ldb_credits = ldb_credit_high_watermark;
    1881                 :          0 :                 qm_port->credit_pool[DLB2_DIR_QUEUE] = &dlb2->dir_credit_pool;
    1882                 :          0 :                 qm_port->credit_pool[DLB2_LDB_QUEUE] = &dlb2->ldb_credit_pool;
    1883                 :            : 
    1884                 :            :                 DLB2_LOG_DBG("dlb2: created dir port %d, depth = %d cr=%d,%d\n",
    1885                 :            :                              qm_port_id,
    1886                 :            :                              dequeue_depth,
    1887                 :            :                              dir_credit_high_watermark,
    1888                 :            :                              ldb_credit_high_watermark);
    1889                 :            :         } else {
    1890                 :          0 :                 qm_port->credits = credit_high_watermark;
    1891                 :          0 :                 qm_port->credit_pool[DLB2_COMBINED_POOL] = &dlb2->credit_pool;
    1892                 :            : 
    1893                 :            :                 DLB2_LOG_DBG("dlb2: created dir port %d, depth = %d cr=%d\n",
    1894                 :            :                              qm_port_id,
    1895                 :            :                              dequeue_depth,
    1896                 :            :                              credit_high_watermark);
    1897                 :            :         }
    1898                 :            : 
    1899                 :            : #if (!defined RTE_ARCH_X86_64)
    1900                 :            :         qm_port->use_scalar = true;
    1901                 :            : #else
    1902         [ #  # ]:          0 :         if ((qm_port->cq_depth > 64) ||
    1903                 :          0 :             (!rte_is_power_of_2(qm_port->cq_depth)) ||
    1904         [ #  # ]:          0 :             (dlb2->vector_opts_enabled == false))
    1905                 :          0 :                 qm_port->use_scalar = true;
    1906                 :            : #endif
    1907                 :            : 
    1908                 :            :         rte_spinlock_unlock(&handle->resource_lock);
    1909                 :            : 
    1910                 :          0 :         return 0;
    1911                 :            : 
    1912                 :            : error_exit:
    1913                 :            : 
    1914                 :            :         if (qm_port)
    1915                 :          0 :                 dlb2_free_qe_mem(qm_port);
    1916                 :            : 
    1917                 :            :         rte_spinlock_unlock(&handle->resource_lock);
    1918                 :            : 
    1919                 :          0 :         DLB2_LOG_ERR("dlb2: create dir port failed!\n");
    1920                 :            : 
    1921                 :          0 :         return ret;
    1922                 :            : }
    1923                 :            : 
    1924                 :            : static int
    1925                 :          0 : dlb2_eventdev_port_setup(struct rte_eventdev *dev,
    1926                 :            :                          uint8_t ev_port_id,
    1927                 :            :                          const struct rte_event_port_conf *port_conf)
    1928                 :            : {
    1929                 :            :         struct dlb2_eventdev *dlb2;
    1930                 :            :         struct dlb2_eventdev_port *ev_port;
    1931                 :            :         uint32_t hw_credit_quanta, sw_credit_quanta;
    1932                 :            :         int ret;
    1933                 :            : 
    1934         [ #  # ]:          0 :         if (dev == NULL || port_conf == NULL) {
    1935                 :          0 :                 DLB2_LOG_ERR("Null parameter\n");
    1936                 :          0 :                 return -EINVAL;
    1937                 :            :         }
    1938                 :            : 
    1939                 :            :         dlb2 = dlb2_pmd_priv(dev);
    1940                 :            : 
    1941   [ #  #  #  # ]:          0 :         if (ev_port_id >= DLB2_MAX_NUM_PORTS(dlb2->version))
    1942                 :            :                 return -EINVAL;
    1943                 :            : 
    1944                 :          0 :         if (port_conf->dequeue_depth >
    1945         [ #  # ]:          0 :                 evdev_dlb2_default_info.max_event_port_dequeue_depth ||
    1946                 :          0 :             port_conf->enqueue_depth >
    1947         [ #  # ]:          0 :                 evdev_dlb2_default_info.max_event_port_enqueue_depth)
    1948                 :            :                 return -EINVAL;
    1949                 :            : 
    1950                 :          0 :         ev_port = &dlb2->ev_ports[ev_port_id];
    1951                 :            :         /* configured? */
    1952         [ #  # ]:          0 :         if (ev_port->setup_done) {
    1953                 :          0 :                 DLB2_LOG_ERR("evport %d is already configured\n", ev_port_id);
    1954                 :          0 :                 return -EINVAL;
    1955                 :            :         }
    1956                 :            : 
    1957                 :            :         /* Default for worker ports */
    1958                 :          0 :         sw_credit_quanta = dlb2->sw_credit_quanta;
    1959                 :          0 :         hw_credit_quanta = dlb2->hw_credit_quanta;
    1960                 :            : 
    1961                 :          0 :         ev_port->qm_port.is_producer = false;
    1962                 :          0 :         ev_port->qm_port.is_directed = port_conf->event_port_cfg &
    1963                 :            :                 RTE_EVENT_PORT_CFG_SINGLE_LINK;
    1964                 :            : 
    1965         [ #  # ]:          0 :         if (port_conf->event_port_cfg & RTE_EVENT_PORT_CFG_HINT_PRODUCER) {
    1966                 :            :                 /* Producer type ports. Mostly enqueue */
    1967                 :            :                 sw_credit_quanta = DLB2_SW_CREDIT_P_QUANTA_DEFAULT;
    1968                 :            :                 hw_credit_quanta = DLB2_SW_CREDIT_P_BATCH_SZ;
    1969                 :          0 :                 ev_port->qm_port.is_producer = true;
    1970                 :            :         }
    1971         [ #  # ]:          0 :         if (port_conf->event_port_cfg & RTE_EVENT_PORT_CFG_HINT_CONSUMER) {
    1972                 :            :                 /* Consumer type ports. Mostly dequeue */
    1973                 :            :                 sw_credit_quanta = DLB2_SW_CREDIT_C_QUANTA_DEFAULT;
    1974                 :            :                 hw_credit_quanta = DLB2_SW_CREDIT_C_BATCH_SZ;
    1975                 :            :         }
    1976                 :          0 :         ev_port->credit_update_quanta = sw_credit_quanta;
    1977                 :          0 :         ev_port->qm_port.hw_credit_quanta = hw_credit_quanta;
    1978                 :            : 
    1979                 :            :         /*
    1980                 :            :          * Validate credit config before creating port
    1981                 :            :          */
    1982                 :            : 
    1983   [ #  #  #  # ]:          0 :         if (port_conf->enqueue_depth > sw_credit_quanta ||
    1984                 :            :             port_conf->enqueue_depth > hw_credit_quanta) {
    1985                 :          0 :                 DLB2_LOG_ERR("Invalid port config. Enqueue depth %d must be <= credit quanta %d and batch size %d\n",
    1986                 :            :                              port_conf->enqueue_depth,
    1987                 :            :                              sw_credit_quanta,
    1988                 :            :                              hw_credit_quanta);
    1989                 :          0 :                 return -EINVAL;
    1990                 :            :         }
    1991                 :          0 :         ev_port->enq_retries = port_conf->enqueue_depth / sw_credit_quanta;
    1992                 :            : 
    1993                 :            :         /* Save off port config for reconfig */
    1994                 :          0 :         ev_port->conf = *port_conf;
    1995                 :            : 
    1996                 :            : 
    1997                 :            :         /*
    1998                 :            :          * Create port
    1999                 :            :          */
    2000                 :            : 
    2001         [ #  # ]:          0 :         if (!ev_port->qm_port.is_directed) {
    2002                 :          0 :                 ret = dlb2_hw_create_ldb_port(dlb2,
    2003                 :            :                                               ev_port,
    2004                 :          0 :                                               port_conf->dequeue_depth,
    2005                 :          0 :                                               port_conf->enqueue_depth);
    2006         [ #  # ]:          0 :                 if (ret < 0) {
    2007                 :          0 :                         DLB2_LOG_ERR("Failed to create the lB port ve portId=%d\n",
    2008                 :            :                                      ev_port_id);
    2009                 :            : 
    2010                 :          0 :                         return ret;
    2011                 :            :                 }
    2012                 :            :         } else {
    2013                 :          0 :                 ret = dlb2_hw_create_dir_port(dlb2,
    2014                 :            :                                               ev_port,
    2015                 :          0 :                                               port_conf->dequeue_depth,
    2016                 :          0 :                                               port_conf->enqueue_depth);
    2017         [ #  # ]:          0 :                 if (ret < 0) {
    2018                 :          0 :                         DLB2_LOG_ERR("Failed to create the DIR port\n");
    2019                 :          0 :                         return ret;
    2020                 :            :                 }
    2021                 :            :         }
    2022                 :            : 
    2023                 :          0 :         ev_port->id = ev_port_id;
    2024                 :          0 :         ev_port->enq_configured = true;
    2025                 :          0 :         ev_port->setup_done = true;
    2026                 :          0 :         ev_port->inflight_max = port_conf->new_event_threshold;
    2027                 :          0 :         ev_port->implicit_release = !(port_conf->event_port_cfg &
    2028                 :            :                   RTE_EVENT_PORT_CFG_DISABLE_IMPL_REL);
    2029                 :          0 :         ev_port->outstanding_releases = 0;
    2030                 :          0 :         ev_port->inflight_credits = 0;
    2031                 :          0 :         ev_port->dlb2 = dlb2; /* reverse link */
    2032                 :            : 
    2033                 :            :         /* Default for worker ports */
    2034                 :          0 :         sw_credit_quanta = dlb2->sw_credit_quanta;
    2035                 :          0 :         hw_credit_quanta = dlb2->hw_credit_quanta;
    2036                 :            : 
    2037         [ #  # ]:          0 :         if (port_conf->event_port_cfg & RTE_EVENT_PORT_CFG_HINT_PRODUCER) {
    2038                 :            :                 /* Producer type ports. Mostly enqueue */
    2039                 :            :                 sw_credit_quanta = DLB2_SW_CREDIT_P_QUANTA_DEFAULT;
    2040                 :            :                 hw_credit_quanta = DLB2_SW_CREDIT_P_BATCH_SZ;
    2041                 :            :         }
    2042         [ #  # ]:          0 :         if (port_conf->event_port_cfg & RTE_EVENT_PORT_CFG_HINT_CONSUMER) {
    2043                 :            :                 /* Consumer type ports. Mostly dequeue */
    2044                 :            :                 sw_credit_quanta = DLB2_SW_CREDIT_C_QUANTA_DEFAULT;
    2045                 :            :                 hw_credit_quanta = DLB2_SW_CREDIT_C_BATCH_SZ;
    2046                 :            :         }
    2047                 :          0 :         ev_port->credit_update_quanta = sw_credit_quanta;
    2048                 :          0 :         ev_port->qm_port.hw_credit_quanta = hw_credit_quanta;
    2049                 :            : 
    2050                 :            : 
    2051                 :            :         /* Tear down pre-existing port->queue links */
    2052         [ #  # ]:          0 :         if (dlb2->run_state == DLB2_RUN_STATE_STOPPED)
    2053                 :            :                 dlb2_port_link_teardown(dlb2, &dlb2->ev_ports[ev_port_id]);
    2054                 :            : 
    2055                 :          0 :         dev->data->ports[ev_port_id] = &dlb2->ev_ports[ev_port_id];
    2056                 :            : 
    2057   [ #  #  #  # ]:          0 :         if (rte_cpu_get_flag_enabled(RTE_CPUFLAG_AVX512VL) &&
    2058                 :          0 :             rte_vect_get_max_simd_bitwidth() >= RTE_VECT_SIMD_512)
    2059                 :          0 :                 ev_port->qm_port.use_avx512 = true;
    2060                 :            :         else
    2061                 :          0 :                 ev_port->qm_port.use_avx512 = false;
    2062                 :            : 
    2063                 :            :         return 0;
    2064                 :            : }
    2065                 :            : 
    2066                 :            : static int16_t
    2067                 :          0 : dlb2_hw_map_ldb_qid_to_port(struct dlb2_hw_dev *handle,
    2068                 :            :                             uint32_t qm_port_id,
    2069                 :            :                             uint16_t qm_qid,
    2070                 :            :                             uint8_t priority)
    2071                 :            : {
    2072                 :            :         struct dlb2_map_qid_args cfg;
    2073                 :            :         int32_t ret;
    2074                 :            : 
    2075         [ #  # ]:          0 :         if (handle == NULL)
    2076                 :            :                 return -EINVAL;
    2077                 :            : 
    2078                 :            :         /* Build message */
    2079                 :          0 :         cfg.port_id = qm_port_id;
    2080                 :          0 :         cfg.qid = qm_qid;
    2081                 :          0 :         cfg.priority = EV_TO_DLB2_PRIO(priority);
    2082                 :            : 
    2083                 :          0 :         ret = dlb2_iface_map_qid(handle, &cfg);
    2084         [ #  # ]:          0 :         if (ret < 0) {
    2085                 :          0 :                 DLB2_LOG_ERR("dlb2: map qid error, ret=%d (driver status: %s)\n",
    2086                 :            :                              ret, dlb2_error_strings[cfg.response.status]);
    2087                 :          0 :                 DLB2_LOG_ERR("dlb2: grp=%d, qm_port=%d, qm_qid=%d prio=%d\n",
    2088                 :            :                              handle->domain_id, cfg.port_id,
    2089                 :            :                              cfg.qid,
    2090                 :            :                              cfg.priority);
    2091                 :            :         } else {
    2092                 :            :                 DLB2_LOG_DBG("dlb2: mapped queue %d to qm_port %d\n",
    2093                 :            :                              qm_qid, qm_port_id);
    2094                 :            :         }
    2095                 :            : 
    2096                 :          0 :         return ret;
    2097                 :            : }
    2098                 :            : 
    2099                 :            : static int
    2100                 :          0 : dlb2_event_queue_join_ldb(struct dlb2_eventdev *dlb2,
    2101                 :            :                           struct dlb2_eventdev_port *ev_port,
    2102                 :            :                           struct dlb2_eventdev_queue *ev_queue,
    2103                 :            :                           uint8_t priority)
    2104                 :            : {
    2105                 :            :         int first_avail = -1;
    2106                 :            :         int ret, i;
    2107                 :            : 
    2108         [ #  # ]:          0 :         for (i = 0; i < DLB2_MAX_NUM_QIDS_PER_LDB_CQ; i++) {
    2109         [ #  # ]:          0 :                 if (ev_port->link[i].valid) {
    2110         [ #  # ]:          0 :                         if (ev_port->link[i].queue_id == ev_queue->id &&
    2111         [ #  # ]:          0 :                             ev_port->link[i].priority == priority) {
    2112         [ #  # ]:          0 :                                 if (ev_port->link[i].mapped)
    2113                 :            :                                         return 0; /* already mapped */
    2114                 :            :                                 first_avail = i;
    2115                 :            :                         }
    2116         [ #  # ]:          0 :                 } else if (first_avail == -1)
    2117                 :            :                         first_avail = i;
    2118                 :            :         }
    2119         [ #  # ]:          0 :         if (first_avail == -1) {
    2120                 :          0 :                 DLB2_LOG_ERR("dlb2: qm_port %d has no available QID slots.\n",
    2121                 :            :                              ev_port->qm_port.id);
    2122                 :          0 :                 return -EINVAL;
    2123                 :            :         }
    2124                 :            : 
    2125                 :          0 :         ret = dlb2_hw_map_ldb_qid_to_port(&dlb2->qm_instance,
    2126                 :            :                                           ev_port->qm_port.id,
    2127                 :          0 :                                           ev_queue->qm_queue.id,
    2128                 :            :                                           priority);
    2129                 :            : 
    2130         [ #  # ]:          0 :         if (!ret)
    2131                 :          0 :                 ev_port->link[first_avail].mapped = true;
    2132                 :            : 
    2133                 :            :         return ret;
    2134                 :            : }
    2135                 :            : 
    2136                 :            : static int32_t
    2137                 :          0 : dlb2_hw_create_dir_queue(struct dlb2_eventdev *dlb2,
    2138                 :            :                          struct dlb2_eventdev_queue *ev_queue,
    2139                 :            :                          int32_t qm_port_id)
    2140                 :            : {
    2141                 :          0 :         struct dlb2_hw_dev *handle = &dlb2->qm_instance;
    2142                 :            :         struct dlb2_create_dir_queue_args cfg;
    2143                 :            :         int32_t ret;
    2144                 :            : 
    2145                 :            :         /* The directed port is always configured before its queue */
    2146                 :          0 :         cfg.port_id = qm_port_id;
    2147                 :            : 
    2148         [ #  # ]:          0 :         if (ev_queue->depth_threshold == 0) {
    2149                 :          0 :                 cfg.depth_threshold = dlb2->default_depth_thresh;
    2150                 :          0 :                 ev_queue->depth_threshold =
    2151                 :            :                         dlb2->default_depth_thresh;
    2152                 :            :         } else
    2153                 :          0 :                 cfg.depth_threshold = ev_queue->depth_threshold;
    2154                 :            : 
    2155                 :          0 :         ret = dlb2_iface_dir_queue_create(handle, &cfg);
    2156         [ #  # ]:          0 :         if (ret < 0) {
    2157                 :          0 :                 DLB2_LOG_ERR("dlb2: create DIR event queue error, ret=%d (driver status: %s)\n",
    2158                 :            :                              ret, dlb2_error_strings[cfg.response.status]);
    2159                 :          0 :                 return -EINVAL;
    2160                 :            :         }
    2161                 :            : 
    2162                 :          0 :         return cfg.response.id;
    2163                 :            : }
    2164                 :            : 
    2165                 :            : static int
    2166                 :          0 : dlb2_eventdev_dir_queue_setup(struct dlb2_eventdev *dlb2,
    2167                 :            :                               struct dlb2_eventdev_queue *ev_queue,
    2168                 :            :                               struct dlb2_eventdev_port *ev_port)
    2169                 :            : {
    2170                 :            :         int32_t qm_qid;
    2171                 :            : 
    2172                 :          0 :         qm_qid = dlb2_hw_create_dir_queue(dlb2, ev_queue, ev_port->qm_port.id);
    2173                 :            : 
    2174         [ #  # ]:          0 :         if (qm_qid < 0) {
    2175                 :          0 :                 DLB2_LOG_ERR("Failed to create the DIR queue\n");
    2176                 :          0 :                 return qm_qid;
    2177                 :            :         }
    2178                 :            : 
    2179                 :          0 :         dlb2->qm_dir_to_ev_queue_id[qm_qid] = ev_queue->id;
    2180                 :            : 
    2181                 :          0 :         ev_queue->qm_queue.id = qm_qid;
    2182                 :            : 
    2183                 :          0 :         return 0;
    2184                 :            : }
    2185                 :            : 
    2186                 :            : static int
    2187         [ #  # ]:          0 : dlb2_do_port_link(struct rte_eventdev *dev,
    2188                 :            :                   struct dlb2_eventdev_queue *ev_queue,
    2189                 :            :                   struct dlb2_eventdev_port *ev_port,
    2190                 :            :                   uint8_t prio)
    2191                 :            : {
    2192                 :            :         struct dlb2_eventdev *dlb2 = dlb2_pmd_priv(dev);
    2193                 :            :         int err;
    2194                 :            : 
    2195                 :            :         /* Don't link until start time. */
    2196         [ #  # ]:          0 :         if (dlb2->run_state == DLB2_RUN_STATE_STOPPED)
    2197                 :            :                 return 0;
    2198                 :            : 
    2199         [ #  # ]:          0 :         if (ev_queue->qm_queue.is_directed)
    2200                 :          0 :                 err = dlb2_eventdev_dir_queue_setup(dlb2, ev_queue, ev_port);
    2201                 :            :         else
    2202                 :          0 :                 err = dlb2_event_queue_join_ldb(dlb2, ev_port, ev_queue, prio);
    2203                 :            : 
    2204         [ #  # ]:          0 :         if (err) {
    2205         [ #  # ]:          0 :                 DLB2_LOG_ERR("port link failure for %s ev_q %d, ev_port %d\n",
    2206                 :            :                              ev_queue->qm_queue.is_directed ? "DIR" : "LDB",
    2207                 :            :                              ev_queue->id, ev_port->id);
    2208                 :            : 
    2209                 :          0 :                 rte_errno = err;
    2210                 :          0 :                 return -1;
    2211                 :            :         }
    2212                 :            : 
    2213                 :            :         return 0;
    2214                 :            : }
    2215                 :            : 
    2216                 :            : static int
    2217                 :          0 : dlb2_validate_port_link(struct dlb2_eventdev_port *ev_port,
    2218                 :            :                         uint8_t queue_id,
    2219                 :            :                         bool link_exists,
    2220                 :            :                         int index)
    2221                 :            : {
    2222                 :          0 :         struct dlb2_eventdev *dlb2 = ev_port->dlb2;
    2223                 :            :         struct dlb2_eventdev_queue *ev_queue;
    2224                 :            :         bool port_is_dir, queue_is_dir;
    2225                 :            : 
    2226         [ #  # ]:          0 :         if (queue_id > dlb2->num_queues) {
    2227                 :          0 :                 rte_errno = -EINVAL;
    2228                 :          0 :                 return -1;
    2229                 :            :         }
    2230                 :            : 
    2231                 :          0 :         ev_queue = &dlb2->ev_queues[queue_id];
    2232                 :            : 
    2233         [ #  # ]:          0 :         if (!ev_queue->setup_done &&
    2234         [ #  # ]:          0 :             ev_queue->qm_queue.config_state != DLB2_PREV_CONFIGURED) {
    2235                 :          0 :                 rte_errno = -EINVAL;
    2236                 :          0 :                 return -1;
    2237                 :            :         }
    2238                 :            : 
    2239                 :          0 :         port_is_dir = ev_port->qm_port.is_directed;
    2240                 :          0 :         queue_is_dir = ev_queue->qm_queue.is_directed;
    2241                 :            : 
    2242         [ #  # ]:          0 :         if (port_is_dir != queue_is_dir) {
    2243   [ #  #  #  # ]:          0 :                 DLB2_LOG_ERR("%s queue %u can't link to %s port %u\n",
    2244                 :            :                              queue_is_dir ? "DIR" : "LDB", ev_queue->id,
    2245                 :            :                              port_is_dir ? "DIR" : "LDB", ev_port->id);
    2246                 :            : 
    2247                 :          0 :                 rte_errno = -EINVAL;
    2248                 :          0 :                 return -1;
    2249                 :            :         }
    2250                 :            : 
    2251                 :            :         /* Check if there is space for the requested link */
    2252         [ #  # ]:          0 :         if (!link_exists && index == -1) {
    2253                 :          0 :                 DLB2_LOG_ERR("no space for new link\n");
    2254                 :          0 :                 rte_errno = -ENOSPC;
    2255                 :          0 :                 return -1;
    2256                 :            :         }
    2257                 :            : 
    2258                 :            :         /* Check if the directed port is already linked */
    2259   [ #  #  #  #  :          0 :         if (ev_port->qm_port.is_directed && ev_port->num_links > 0 &&
                   #  # ]
    2260                 :            :             !link_exists) {
    2261                 :          0 :                 DLB2_LOG_ERR("Can't link DIR port %d to >1 queues\n",
    2262                 :            :                              ev_port->id);
    2263                 :          0 :                 rte_errno = -EINVAL;
    2264                 :          0 :                 return -1;
    2265                 :            :         }
    2266                 :            : 
    2267                 :            :         /* Check if the directed queue is already linked */
    2268   [ #  #  #  #  :          0 :         if (ev_queue->qm_queue.is_directed && ev_queue->num_links > 0 &&
                   #  # ]
    2269                 :            :             !link_exists) {
    2270                 :          0 :                 DLB2_LOG_ERR("Can't link DIR queue %d to >1 ports\n",
    2271                 :            :                              ev_queue->id);
    2272                 :          0 :                 rte_errno = -EINVAL;
    2273                 :          0 :                 return -1;
    2274                 :            :         }
    2275                 :            : 
    2276                 :            :         return 0;
    2277                 :            : }
    2278                 :            : 
    2279                 :            : static int
    2280                 :          0 : dlb2_eventdev_port_link(struct rte_eventdev *dev, void *event_port,
    2281                 :            :                         const uint8_t queues[], const uint8_t priorities[],
    2282                 :            :                         uint16_t nb_links)
    2283                 :            : 
    2284                 :            : {
    2285                 :            :         struct dlb2_eventdev_port *ev_port = event_port;
    2286                 :            :         struct dlb2_eventdev *dlb2;
    2287                 :            :         int i, j;
    2288                 :            : 
    2289                 :            :         RTE_SET_USED(dev);
    2290                 :            : 
    2291         [ #  # ]:          0 :         if (ev_port == NULL) {
    2292                 :          0 :                 DLB2_LOG_ERR("dlb2: evport not setup\n");
    2293                 :          0 :                 rte_errno = -EINVAL;
    2294                 :          0 :                 return 0;
    2295                 :            :         }
    2296                 :            : 
    2297         [ #  # ]:          0 :         if (!ev_port->setup_done &&
    2298         [ #  # ]:          0 :             ev_port->qm_port.config_state != DLB2_PREV_CONFIGURED) {
    2299                 :          0 :                 DLB2_LOG_ERR("dlb2: evport not setup\n");
    2300                 :          0 :                 rte_errno = -EINVAL;
    2301                 :          0 :                 return 0;
    2302                 :            :         }
    2303                 :            : 
    2304                 :            :         /* Note: rte_event_port_link() ensures the PMD won't receive a NULL
    2305                 :            :          * queues pointer.
    2306                 :            :          */
    2307         [ #  # ]:          0 :         if (nb_links == 0) {
    2308                 :            :                 DLB2_LOG_DBG("dlb2: nb_links is 0\n");
    2309                 :            :                 return 0; /* Ignore and return success */
    2310                 :            :         }
    2311                 :            : 
    2312                 :          0 :         dlb2 = ev_port->dlb2;
    2313                 :            : 
    2314                 :            :         DLB2_LOG_DBG("Linking %u queues to %s port %d\n",
    2315                 :            :                      nb_links,
    2316                 :            :                      ev_port->qm_port.is_directed ? "DIR" : "LDB",
    2317                 :            :                      ev_port->id);
    2318                 :            : 
    2319         [ #  # ]:          0 :         for (i = 0; i < nb_links; i++) {
    2320                 :            :                 struct dlb2_eventdev_queue *ev_queue;
    2321                 :            :                 uint8_t queue_id, prio;
    2322                 :            :                 bool found = false;
    2323                 :            :                 int index = -1;
    2324                 :            : 
    2325                 :          0 :                 queue_id = queues[i];
    2326                 :          0 :                 prio = priorities[i];
    2327                 :            : 
    2328                 :            :                 /* Check if the link already exists. */
    2329         [ #  # ]:          0 :                 for (j = 0; j < DLB2_MAX_NUM_QIDS_PER_LDB_CQ; j++)
    2330         [ #  # ]:          0 :                         if (ev_port->link[j].valid) {
    2331         [ #  # ]:          0 :                                 if (ev_port->link[j].queue_id == queue_id) {
    2332                 :            :                                         found = true;
    2333                 :            :                                         index = j;
    2334                 :            :                                         break;
    2335                 :            :                                 }
    2336         [ #  # ]:          0 :                         } else if (index == -1) {
    2337                 :            :                                 index = j;
    2338                 :            :                         }
    2339                 :            : 
    2340                 :            :                 /* could not link */
    2341         [ #  # ]:          0 :                 if (index == -1)
    2342                 :            :                         break;
    2343                 :            : 
    2344                 :            :                 /* Check if already linked at the requested priority */
    2345   [ #  #  #  # ]:          0 :                 if (found && ev_port->link[j].priority == prio)
    2346                 :          0 :                         continue;
    2347                 :            : 
    2348         [ #  # ]:          0 :                 if (dlb2_validate_port_link(ev_port, queue_id, found, index))
    2349                 :            :                         break; /* return index of offending queue */
    2350                 :            : 
    2351                 :          0 :                 ev_queue = &dlb2->ev_queues[queue_id];
    2352                 :            : 
    2353         [ #  # ]:          0 :                 if (dlb2_do_port_link(dev, ev_queue, ev_port, prio))
    2354                 :            :                         break; /* return index of offending queue */
    2355                 :            : 
    2356                 :          0 :                 ev_queue->num_links++;
    2357                 :            : 
    2358                 :          0 :                 ev_port->link[index].queue_id = queue_id;
    2359                 :          0 :                 ev_port->link[index].priority = prio;
    2360                 :          0 :                 ev_port->link[index].valid = true;
    2361                 :            :                 /* Entry already exists?  If so, then must be prio change */
    2362         [ #  # ]:          0 :                 if (!found)
    2363                 :          0 :                         ev_port->num_links++;
    2364                 :            :         }
    2365                 :            :         return i;
    2366                 :            : }
    2367                 :            : 
    2368                 :            : static int16_t
    2369                 :          0 : dlb2_hw_unmap_ldb_qid_from_port(struct dlb2_hw_dev *handle,
    2370                 :            :                                 uint32_t qm_port_id,
    2371                 :            :                                 uint16_t qm_qid)
    2372                 :            : {
    2373                 :            :         struct dlb2_unmap_qid_args cfg;
    2374                 :            :         int32_t ret;
    2375                 :            : 
    2376         [ #  # ]:          0 :         if (handle == NULL)
    2377                 :            :                 return -EINVAL;
    2378                 :            : 
    2379                 :          0 :         cfg.port_id = qm_port_id;
    2380                 :          0 :         cfg.qid = qm_qid;
    2381                 :            : 
    2382                 :          0 :         ret = dlb2_iface_unmap_qid(handle, &cfg);
    2383         [ #  # ]:          0 :         if (ret < 0)
    2384                 :          0 :                 DLB2_LOG_ERR("dlb2: unmap qid error, ret=%d (driver status: %s)\n",
    2385                 :            :                              ret, dlb2_error_strings[cfg.response.status]);
    2386                 :            : 
    2387                 :          0 :         return ret;
    2388                 :            : }
    2389                 :            : 
    2390                 :            : static int
    2391                 :          0 : dlb2_event_queue_detach_ldb(struct dlb2_eventdev *dlb2,
    2392                 :            :                             struct dlb2_eventdev_port *ev_port,
    2393                 :            :                             struct dlb2_eventdev_queue *ev_queue)
    2394                 :            : {
    2395                 :            :         int ret, i;
    2396                 :            : 
    2397                 :            :         /* Don't unlink until start time. */
    2398         [ #  # ]:          0 :         if (dlb2->run_state == DLB2_RUN_STATE_STOPPED)
    2399                 :            :                 return 0;
    2400                 :            : 
    2401         [ #  # ]:          0 :         for (i = 0; i < DLB2_MAX_NUM_QIDS_PER_LDB_CQ; i++) {
    2402         [ #  # ]:          0 :                 if (ev_port->link[i].valid &&
    2403         [ #  # ]:          0 :                     ev_port->link[i].queue_id == ev_queue->id)
    2404                 :            :                         break; /* found */
    2405                 :            :         }
    2406                 :            : 
    2407                 :            :         /* This is expected with eventdev API!
    2408                 :            :          * It blindly attempts to unmap all queues.
    2409                 :            :          */
    2410         [ #  # ]:          0 :         if (i == DLB2_MAX_NUM_QIDS_PER_LDB_CQ) {
    2411                 :            :                 DLB2_LOG_DBG("dlb2: ignoring LB QID %d not mapped for qm_port %d.\n",
    2412                 :            :                              ev_queue->qm_queue.id,
    2413                 :            :                              ev_port->qm_port.id);
    2414                 :            :                 return 0;
    2415                 :            :         }
    2416                 :            : 
    2417                 :          0 :         ret = dlb2_hw_unmap_ldb_qid_from_port(&dlb2->qm_instance,
    2418                 :            :                                               ev_port->qm_port.id,
    2419                 :          0 :                                               ev_queue->qm_queue.id);
    2420         [ #  # ]:          0 :         if (!ret)
    2421                 :          0 :                 ev_port->link[i].mapped = false;
    2422                 :            : 
    2423                 :            :         return ret;
    2424                 :            : }
    2425                 :            : 
    2426                 :            : static int
    2427                 :          0 : dlb2_eventdev_port_unlink(struct rte_eventdev *dev, void *event_port,
    2428                 :            :                           uint8_t queues[], uint16_t nb_unlinks)
    2429                 :            : {
    2430                 :            :         struct dlb2_eventdev_port *ev_port = event_port;
    2431                 :            :         struct dlb2_eventdev *dlb2;
    2432                 :            :         int i;
    2433                 :            : 
    2434                 :            :         RTE_SET_USED(dev);
    2435                 :            : 
    2436         [ #  # ]:          0 :         if (!ev_port->setup_done) {
    2437                 :          0 :                 DLB2_LOG_ERR("dlb2: evport %d is not configured\n",
    2438                 :            :                              ev_port->id);
    2439                 :          0 :                 rte_errno = -EINVAL;
    2440                 :          0 :                 return 0;
    2441                 :            :         }
    2442                 :            : 
    2443         [ #  # ]:          0 :         if (queues == NULL || nb_unlinks == 0) {
    2444                 :            :                 DLB2_LOG_DBG("dlb2: queues is NULL or nb_unlinks is 0\n");
    2445                 :            :                 return 0; /* Ignore and return success */
    2446                 :            :         }
    2447                 :            : 
    2448         [ #  # ]:          0 :         if (ev_port->qm_port.is_directed) {
    2449                 :            :                 DLB2_LOG_DBG("dlb2: ignore unlink from dir port %d\n",
    2450                 :            :                              ev_port->id);
    2451                 :          0 :                 rte_errno = 0;
    2452                 :          0 :                 return nb_unlinks; /* as if success */
    2453                 :            :         }
    2454                 :            : 
    2455                 :          0 :         dlb2 = ev_port->dlb2;
    2456                 :            : 
    2457         [ #  # ]:          0 :         for (i = 0; i < nb_unlinks; i++) {
    2458                 :            :                 struct dlb2_eventdev_queue *ev_queue;
    2459                 :            :                 int ret, j;
    2460                 :            : 
    2461         [ #  # ]:          0 :                 if (queues[i] >= dlb2->num_queues) {
    2462                 :          0 :                         DLB2_LOG_ERR("dlb2: invalid queue id %d\n", queues[i]);
    2463                 :          0 :                         rte_errno = -EINVAL;
    2464                 :          0 :                         return i; /* return index of offending queue */
    2465                 :            :                 }
    2466                 :            : 
    2467                 :          0 :                 ev_queue = &dlb2->ev_queues[queues[i]];
    2468                 :            : 
    2469                 :            :                 /* Does a link exist? */
    2470         [ #  # ]:          0 :                 for (j = 0; j < DLB2_MAX_NUM_QIDS_PER_LDB_CQ; j++)
    2471         [ #  # ]:          0 :                         if (ev_port->link[j].queue_id == queues[i] &&
    2472         [ #  # ]:          0 :                             ev_port->link[j].valid)
    2473                 :            :                                 break;
    2474                 :            : 
    2475         [ #  # ]:          0 :                 if (j == DLB2_MAX_NUM_QIDS_PER_LDB_CQ)
    2476                 :          0 :                         continue;
    2477                 :            : 
    2478                 :          0 :                 ret = dlb2_event_queue_detach_ldb(dlb2, ev_port, ev_queue);
    2479         [ #  # ]:          0 :                 if (ret) {
    2480                 :          0 :                         DLB2_LOG_ERR("unlink err=%d for port %d queue %d\n",
    2481                 :            :                                      ret, ev_port->id, queues[i]);
    2482                 :          0 :                         rte_errno = -ENOENT;
    2483                 :          0 :                         return i; /* return index of offending queue */
    2484                 :            :                 }
    2485                 :            : 
    2486                 :          0 :                 ev_port->link[j].valid = false;
    2487                 :          0 :                 ev_port->num_links--;
    2488                 :          0 :                 ev_queue->num_links--;
    2489                 :            :         }
    2490                 :            : 
    2491                 :            :         return nb_unlinks;
    2492                 :            : }
    2493                 :            : 
    2494                 :            : static int
    2495                 :          0 : dlb2_eventdev_port_unlinks_in_progress(struct rte_eventdev *dev,
    2496                 :            :                                        void *event_port)
    2497                 :            : {
    2498                 :            :         struct dlb2_eventdev_port *ev_port = event_port;
    2499                 :            :         struct dlb2_eventdev *dlb2;
    2500                 :            :         struct dlb2_hw_dev *handle;
    2501                 :            :         struct dlb2_pending_port_unmaps_args cfg;
    2502                 :            :         int ret;
    2503                 :            : 
    2504                 :            :         RTE_SET_USED(dev);
    2505                 :            : 
    2506         [ #  # ]:          0 :         if (!ev_port->setup_done) {
    2507                 :          0 :                 DLB2_LOG_ERR("dlb2: evport %d is not configured\n",
    2508                 :            :                              ev_port->id);
    2509                 :          0 :                 rte_errno = -EINVAL;
    2510                 :          0 :                 return 0;
    2511                 :            :         }
    2512                 :            : 
    2513                 :          0 :         cfg.port_id = ev_port->qm_port.id;
    2514                 :          0 :         dlb2 = ev_port->dlb2;
    2515                 :          0 :         handle = &dlb2->qm_instance;
    2516                 :          0 :         ret = dlb2_iface_pending_port_unmaps(handle, &cfg);
    2517                 :            : 
    2518         [ #  # ]:          0 :         if (ret < 0) {
    2519                 :          0 :                 DLB2_LOG_ERR("dlb2: num_unlinks_in_progress ret=%d (driver status: %s)\n",
    2520                 :            :                              ret, dlb2_error_strings[cfg.response.status]);
    2521                 :          0 :                 return ret;
    2522                 :            :         }
    2523                 :            : 
    2524                 :          0 :         return cfg.response.id;
    2525                 :            : }
    2526                 :            : 
    2527                 :            : static int
    2528                 :          0 : dlb2_eventdev_reapply_configuration(struct rte_eventdev *dev)
    2529                 :            : {
    2530                 :            :         struct dlb2_eventdev *dlb2 = dlb2_pmd_priv(dev);
    2531                 :            :         int ret, i;
    2532                 :            : 
    2533                 :            :         /* If an event queue or port was previously configured, but hasn't been
    2534                 :            :          * reconfigured, reapply its original configuration.
    2535                 :            :          */
    2536         [ #  # ]:          0 :         for (i = 0; i < dlb2->num_queues; i++) {
    2537                 :            :                 struct dlb2_eventdev_queue *ev_queue;
    2538                 :            : 
    2539                 :            :                 ev_queue = &dlb2->ev_queues[i];
    2540                 :            : 
    2541         [ #  # ]:          0 :                 if (ev_queue->qm_queue.config_state != DLB2_PREV_CONFIGURED)
    2542                 :          0 :                         continue;
    2543                 :            : 
    2544                 :          0 :                 ret = dlb2_eventdev_queue_setup(dev, i, &ev_queue->conf);
    2545         [ #  # ]:          0 :                 if (ret < 0) {
    2546                 :          0 :                         DLB2_LOG_ERR("dlb2: failed to reconfigure queue %d", i);
    2547                 :          0 :                         return ret;
    2548                 :            :                 }
    2549                 :            :         }
    2550                 :            : 
    2551         [ #  # ]:          0 :         for (i = 0; i < dlb2->num_ports; i++) {
    2552                 :            :                 struct dlb2_eventdev_port *ev_port = &dlb2->ev_ports[i];
    2553                 :            : 
    2554         [ #  # ]:          0 :                 if (ev_port->qm_port.config_state != DLB2_PREV_CONFIGURED)
    2555                 :          0 :                         continue;
    2556                 :            : 
    2557                 :          0 :                 ret = dlb2_eventdev_port_setup(dev, i, &ev_port->conf);
    2558         [ #  # ]:          0 :                 if (ret < 0) {
    2559                 :          0 :                         DLB2_LOG_ERR("dlb2: failed to reconfigure ev_port %d",
    2560                 :            :                                      i);
    2561                 :          0 :                         return ret;
    2562                 :            :                 }
    2563                 :            :         }
    2564                 :            : 
    2565                 :            :         return 0;
    2566                 :            : }
    2567                 :            : 
    2568                 :            : static int
    2569                 :          0 : dlb2_eventdev_apply_port_links(struct rte_eventdev *dev)
    2570                 :            : {
    2571                 :            :         struct dlb2_eventdev *dlb2 = dlb2_pmd_priv(dev);
    2572                 :            :         int i;
    2573                 :            : 
    2574                 :            :         /* Perform requested port->queue links */
    2575         [ #  # ]:          0 :         for (i = 0; i < dlb2->num_ports; i++) {
    2576                 :          0 :                 struct dlb2_eventdev_port *ev_port = &dlb2->ev_ports[i];
    2577                 :            :                 int j;
    2578                 :            : 
    2579         [ #  # ]:          0 :                 for (j = 0; j < DLB2_MAX_NUM_QIDS_PER_LDB_CQ; j++) {
    2580                 :            :                         struct dlb2_eventdev_queue *ev_queue;
    2581                 :            :                         uint8_t prio, queue_id;
    2582                 :            : 
    2583         [ #  # ]:          0 :                         if (!ev_port->link[j].valid)
    2584                 :          0 :                                 continue;
    2585                 :            : 
    2586                 :          0 :                         prio = ev_port->link[j].priority;
    2587                 :          0 :                         queue_id = ev_port->link[j].queue_id;
    2588                 :            : 
    2589         [ #  # ]:          0 :                         if (dlb2_validate_port_link(ev_port, queue_id, true, j))
    2590                 :            :                                 return -EINVAL;
    2591                 :            : 
    2592                 :          0 :                         ev_queue = &dlb2->ev_queues[queue_id];
    2593                 :            : 
    2594         [ #  # ]:          0 :                         if (dlb2_do_port_link(dev, ev_queue, ev_port, prio))
    2595                 :            :                                 return -EINVAL;
    2596                 :            :                 }
    2597                 :            :         }
    2598                 :            : 
    2599                 :            :         return 0;
    2600                 :            : }
    2601                 :            : 
    2602                 :            : static int
    2603                 :          0 : dlb2_eventdev_start(struct rte_eventdev *dev)
    2604                 :            : {
    2605                 :            :         struct dlb2_eventdev *dlb2 = dlb2_pmd_priv(dev);
    2606                 :          0 :         struct dlb2_hw_dev *handle = &dlb2->qm_instance;
    2607                 :            :         struct dlb2_start_domain_args cfg;
    2608                 :            :         int ret, i;
    2609                 :            : 
    2610                 :          0 :         rte_spinlock_lock(&dlb2->qm_instance.resource_lock);
    2611         [ #  # ]:          0 :         if (dlb2->run_state != DLB2_RUN_STATE_STOPPED) {
    2612                 :          0 :                 DLB2_LOG_ERR("bad state %d for dev_start\n",
    2613                 :            :                              (int)dlb2->run_state);
    2614                 :            :                 rte_spinlock_unlock(&dlb2->qm_instance.resource_lock);
    2615                 :          0 :                 return -EINVAL;
    2616                 :            :         }
    2617                 :          0 :         dlb2->run_state = DLB2_RUN_STATE_STARTING;
    2618                 :            :         rte_spinlock_unlock(&dlb2->qm_instance.resource_lock);
    2619                 :            : 
    2620                 :            :         /* If the device was configured more than once, some event ports and/or
    2621                 :            :          * queues may need to be reconfigured.
    2622                 :            :          */
    2623                 :          0 :         ret = dlb2_eventdev_reapply_configuration(dev);
    2624         [ #  # ]:          0 :         if (ret)
    2625                 :            :                 return ret;
    2626                 :            : 
    2627                 :            :         /* The DLB PMD delays port links until the device is started. */
    2628                 :          0 :         ret = dlb2_eventdev_apply_port_links(dev);
    2629         [ #  # ]:          0 :         if (ret)
    2630                 :            :                 return ret;
    2631                 :            : 
    2632         [ #  # ]:          0 :         for (i = 0; i < dlb2->num_ports; i++) {
    2633         [ #  # ]:          0 :                 if (!dlb2->ev_ports[i].setup_done) {
    2634                 :          0 :                         DLB2_LOG_ERR("dlb2: port %d not setup", i);
    2635                 :          0 :                         return -ESTALE;
    2636                 :            :                 }
    2637                 :            :         }
    2638                 :            : 
    2639         [ #  # ]:          0 :         for (i = 0; i < dlb2->num_queues; i++) {
    2640         [ #  # ]:          0 :                 if (dlb2->ev_queues[i].num_links == 0) {
    2641                 :          0 :                         DLB2_LOG_ERR("dlb2: queue %d is not linked", i);
    2642                 :          0 :                         return -ENOLINK;
    2643                 :            :                 }
    2644                 :            :         }
    2645                 :            : 
    2646                 :          0 :         ret = dlb2_iface_sched_domain_start(handle, &cfg);
    2647         [ #  # ]:          0 :         if (ret < 0) {
    2648                 :          0 :                 DLB2_LOG_ERR("dlb2: sched_domain_start ret=%d (driver status: %s)\n",
    2649                 :            :                              ret, dlb2_error_strings[cfg.response.status]);
    2650                 :          0 :                 return ret;
    2651                 :            :         }
    2652                 :            : 
    2653                 :          0 :         dlb2->run_state = DLB2_RUN_STATE_STARTED;
    2654                 :            :         DLB2_LOG_DBG("dlb2: sched_domain_start completed OK\n");
    2655                 :            : 
    2656                 :          0 :         return 0;
    2657                 :            : }
    2658                 :            : 
    2659                 :            : static inline uint32_t
    2660                 :            : dlb2_port_credits_get(struct dlb2_port *qm_port,
    2661                 :            :                       enum dlb2_hw_queue_types type)
    2662                 :            : {
    2663                 :          0 :         uint32_t credits = *qm_port->credit_pool[type];
    2664                 :            :         /* By default hw_credit_quanta is DLB2_SW_CREDIT_BATCH_SZ */
    2665                 :          0 :         uint32_t batch_size = qm_port->hw_credit_quanta;
    2666                 :            : 
    2667   [ #  #  #  #  :          0 :         if (unlikely(credits < batch_size))
                   #  # ]
    2668                 :            :                 batch_size = credits;
    2669                 :            : 
    2670   [ #  #  #  #  :          0 :         if (likely(credits &&
          #  #  #  #  #  
                #  #  # ]
    2671                 :            :                    __atomic_compare_exchange_n(
    2672                 :            :                         qm_port->credit_pool[type],
    2673                 :            :                         &credits, credits - batch_size, false,
    2674                 :            :                         __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)))
    2675                 :            :                 return batch_size;
    2676                 :            :         else
    2677                 :            :                 return 0;
    2678                 :            : }
    2679                 :            : 
    2680                 :            : static inline void
    2681                 :          0 : dlb2_replenish_sw_credits(struct dlb2_eventdev *dlb2,
    2682                 :            :                           struct dlb2_eventdev_port *ev_port)
    2683                 :            : {
    2684                 :          0 :         uint16_t quanta = ev_port->credit_update_quanta;
    2685                 :            : 
    2686         [ #  # ]:          0 :         if (ev_port->inflight_credits >= quanta * 2) {
    2687                 :            :                 /* Replenish credits, saving one quanta for enqueues */
    2688                 :          0 :                 uint16_t val = ev_port->inflight_credits - quanta;
    2689                 :            : 
    2690                 :          0 :                 __atomic_fetch_sub(&dlb2->inflights, val, __ATOMIC_SEQ_CST);
    2691                 :          0 :                 ev_port->inflight_credits -= val;
    2692                 :            :         }
    2693                 :          0 : }
    2694                 :            : 
    2695                 :            : static inline int
    2696                 :          0 : dlb2_check_enqueue_sw_credits(struct dlb2_eventdev *dlb2,
    2697                 :            :                               struct dlb2_eventdev_port *ev_port)
    2698                 :            : {
    2699                 :          0 :         uint32_t sw_inflights = __atomic_load_n(&dlb2->inflights,
    2700                 :            :                                                 __ATOMIC_SEQ_CST);
    2701                 :            :         const int num = 1;
    2702                 :            : 
    2703         [ #  # ]:          0 :         if (unlikely(ev_port->inflight_max < sw_inflights)) {
    2704                 :          0 :                 DLB2_INC_STAT(ev_port->stats.traffic.tx_nospc_inflight_max, 1);
    2705                 :          0 :                 rte_errno = -ENOSPC;
    2706                 :          0 :                 return 1;
    2707                 :            :         }
    2708                 :            : 
    2709         [ #  # ]:          0 :         if (ev_port->inflight_credits < num) {
    2710                 :            :                 /* check if event enqueue brings ev_port over max threshold */
    2711                 :          0 :                 uint32_t credit_update_quanta = ev_port->credit_update_quanta;
    2712                 :            : 
    2713                 :          0 :                 if (sw_inflights + credit_update_quanta >
    2714         [ #  # ]:          0 :                                 dlb2->new_event_limit) {
    2715                 :          0 :                         DLB2_INC_STAT(
    2716                 :            :                         ev_port->stats.traffic.tx_nospc_new_event_limit,
    2717                 :            :                         1);
    2718                 :          0 :                         rte_errno = -ENOSPC;
    2719                 :          0 :                         return 1;
    2720                 :            :                 }
    2721                 :            : 
    2722                 :          0 :                 __atomic_fetch_add(&dlb2->inflights, credit_update_quanta,
    2723                 :            :                                    __ATOMIC_SEQ_CST);
    2724                 :          0 :                 ev_port->inflight_credits += (credit_update_quanta);
    2725                 :            : 
    2726         [ #  # ]:          0 :                 if (ev_port->inflight_credits < num) {
    2727                 :          0 :                         DLB2_INC_STAT(
    2728                 :            :                         ev_port->stats.traffic.tx_nospc_inflight_credits,
    2729                 :            :                         1);
    2730                 :          0 :                         rte_errno = -ENOSPC;
    2731                 :          0 :                         return 1;
    2732                 :            :                 }
    2733                 :            :         }
    2734                 :            : 
    2735                 :            :         return 0;
    2736                 :            : }
    2737                 :            : 
    2738                 :            : static inline int
    2739                 :          0 : dlb2_check_enqueue_hw_ldb_credits(struct dlb2_port *qm_port)
    2740                 :            : {
    2741         [ #  # ]:          0 :         if (unlikely(qm_port->cached_ldb_credits == 0)) {
    2742                 :          0 :                 qm_port->cached_ldb_credits =
    2743                 :            :                         dlb2_port_credits_get(qm_port,
    2744                 :            :                                               DLB2_LDB_QUEUE);
    2745         [ #  # ]:          0 :                 if (unlikely(qm_port->cached_ldb_credits == 0)) {
    2746                 :          0 :                         DLB2_INC_STAT(
    2747                 :            :                         qm_port->ev_port->stats.traffic.tx_nospc_ldb_hw_credits,
    2748                 :            :                         1);
    2749                 :            :                         DLB2_LOG_DBG("ldb credits exhausted\n");
    2750                 :          0 :                         return 1; /* credits exhausted */
    2751                 :            :                 }
    2752                 :            :         }
    2753                 :            : 
    2754                 :            :         return 0;
    2755                 :            : }
    2756                 :            : 
    2757                 :            : static inline int
    2758                 :          0 : dlb2_check_enqueue_hw_dir_credits(struct dlb2_port *qm_port)
    2759                 :            : {
    2760         [ #  # ]:          0 :         if (unlikely(qm_port->cached_dir_credits == 0)) {
    2761                 :          0 :                 qm_port->cached_dir_credits =
    2762                 :            :                         dlb2_port_credits_get(qm_port,
    2763                 :            :                                               DLB2_DIR_QUEUE);
    2764         [ #  # ]:          0 :                 if (unlikely(qm_port->cached_dir_credits == 0)) {
    2765                 :          0 :                         DLB2_INC_STAT(
    2766                 :            :                         qm_port->ev_port->stats.traffic.tx_nospc_dir_hw_credits,
    2767                 :            :                         1);
    2768                 :            :                         DLB2_LOG_DBG("dir credits exhausted\n");
    2769                 :          0 :                         return 1; /* credits exhausted */
    2770                 :            :                 }
    2771                 :            :         }
    2772                 :            : 
    2773                 :            :         return 0;
    2774                 :            : }
    2775                 :            : 
    2776                 :            : static inline int
    2777                 :          0 : dlb2_check_enqueue_hw_credits(struct dlb2_port *qm_port)
    2778                 :            : {
    2779         [ #  # ]:          0 :         if (unlikely(qm_port->cached_credits == 0)) {
    2780                 :          0 :                 qm_port->cached_credits =
    2781                 :            :                         dlb2_port_credits_get(qm_port,
    2782                 :            :                                               DLB2_COMBINED_POOL);
    2783         [ #  # ]:          0 :                 if (unlikely(qm_port->cached_credits == 0)) {
    2784                 :          0 :                         DLB2_INC_STAT(
    2785                 :            :                         qm_port->ev_port->stats.traffic.tx_nospc_hw_credits, 1);
    2786                 :            :                         DLB2_LOG_DBG("credits exhausted\n");
    2787                 :          0 :                         return 1; /* credits exhausted */
    2788                 :            :                 }
    2789                 :            :         }
    2790                 :            : 
    2791                 :            :         return 0;
    2792                 :            : }
    2793                 :            : 
    2794                 :            : static __rte_always_inline void
    2795                 :            : dlb2_pp_write(struct dlb2_enqueue_qe *qe4,
    2796                 :            :               struct process_local_port_data *port_data)
    2797                 :            : {
    2798                 :          0 :         dlb2_movdir64b(port_data->pp_addr, qe4);
    2799                 :            : }
    2800                 :            : 
    2801                 :            : static inline int
    2802                 :            : dlb2_consume_qe_immediate(struct dlb2_port *qm_port, int num)
    2803                 :            : {
    2804                 :            :         struct process_local_port_data *port_data;
    2805                 :            :         struct dlb2_cq_pop_qe *qe;
    2806                 :            : 
    2807                 :            :         RTE_ASSERT(qm_port->config_state == DLB2_CONFIGURED);
    2808                 :            : 
    2809                 :          0 :         qe = qm_port->consume_qe;
    2810                 :            : 
    2811                 :          0 :         qe->tokens = num - 1;
    2812                 :            : 
    2813                 :            :         /* No store fence needed since no pointer is being sent, and CQ token
    2814                 :            :          * pops can be safely reordered with other HCWs.
    2815                 :            :          */
    2816                 :          0 :         port_data = &dlb2_port[qm_port->id][PORT_TYPE(qm_port)];
    2817                 :            : 
    2818                 :          0 :         dlb2_movntdq_single(port_data->pp_addr, qe);
    2819                 :            : 
    2820                 :            :         DLB2_LOG_DBG("dlb2: consume immediate - %d QEs\n", num);
    2821                 :            : 
    2822                 :          0 :         qm_port->owed_tokens = 0;
    2823                 :            : 
    2824                 :          0 :         return 0;
    2825                 :            : }
    2826                 :            : 
    2827                 :            : static inline void
    2828                 :            : dlb2_hw_do_enqueue(struct dlb2_port *qm_port,
    2829                 :            :                    bool do_sfence,
    2830                 :            :                    struct process_local_port_data *port_data)
    2831                 :            : {
    2832                 :            :         /* Since MOVDIR64B is weakly-ordered, use an SFENCE to ensure that
    2833                 :            :          * application writes complete before enqueueing the QE.
    2834                 :            :          */
    2835   [ #  #  #  # ]:          0 :         if (do_sfence)
    2836                 :            :                 rte_wmb();
    2837                 :            : 
    2838                 :          0 :         dlb2_pp_write(qm_port->qe4, port_data);
    2839                 :            : }
    2840                 :            : 
    2841                 :            : static inline void
    2842                 :            : dlb2_construct_token_pop_qe(struct dlb2_port *qm_port, int idx)
    2843                 :            : {
    2844                 :          0 :         struct dlb2_cq_pop_qe *qe = (void *)qm_port->qe4;
    2845                 :          0 :         int num = qm_port->owed_tokens;
    2846                 :            : 
    2847                 :          0 :         qe[idx].cmd_byte = DLB2_POP_CMD_BYTE;
    2848                 :          0 :         qe[idx].tokens = num - 1;
    2849                 :            : 
    2850                 :          0 :         qm_port->owed_tokens = 0;
    2851                 :            : }
    2852                 :            : 
    2853                 :            : static inline int
    2854                 :          0 : dlb2_event_enqueue_prep(struct dlb2_eventdev_port *ev_port,
    2855                 :            :                         struct dlb2_port *qm_port,
    2856                 :            :                         const struct rte_event ev[],
    2857                 :            :                         uint8_t *sched_type,
    2858                 :            :                         uint8_t *queue_id)
    2859                 :            : {
    2860                 :          0 :         struct dlb2_eventdev *dlb2 = ev_port->dlb2;
    2861                 :            :         struct dlb2_eventdev_queue *ev_queue;
    2862                 :            :         uint16_t *cached_credits = NULL;
    2863                 :            :         struct dlb2_queue *qm_queue;
    2864                 :            : 
    2865                 :          0 :         ev_queue = &dlb2->ev_queues[ev->queue_id];
    2866                 :            :         qm_queue = &ev_queue->qm_queue;
    2867                 :          0 :         *queue_id = qm_queue->id;
    2868                 :            : 
    2869                 :            :         /* Ignore sched_type and hardware credits on release events */
    2870         [ #  # ]:          0 :         if (ev->op == RTE_EVENT_OP_RELEASE)
    2871                 :          0 :                 goto op_check;
    2872                 :            : 
    2873         [ #  # ]:          0 :         if (!qm_queue->is_directed) {
    2874                 :            :                 /* Load balanced destination queue */
    2875                 :            : 
    2876         [ #  # ]:          0 :                 if (dlb2->version == DLB2_HW_V2) {
    2877         [ #  # ]:          0 :                         if (dlb2_check_enqueue_hw_ldb_credits(qm_port)) {
    2878                 :          0 :                                 rte_errno = -ENOSPC;
    2879                 :          0 :                                 return 1;
    2880                 :            :                         }
    2881                 :          0 :                         cached_credits = &qm_port->cached_ldb_credits;
    2882                 :            :                 } else {
    2883         [ #  # ]:          0 :                         if (dlb2_check_enqueue_hw_credits(qm_port)) {
    2884                 :          0 :                                 rte_errno = -ENOSPC;
    2885                 :          0 :                                 return 1;
    2886                 :            :                         }
    2887                 :          0 :                         cached_credits = &qm_port->cached_credits;
    2888                 :            :                 }
    2889   [ #  #  #  # ]:          0 :                 switch (ev->sched_type) {
    2890                 :          0 :                 case RTE_SCHED_TYPE_ORDERED:
    2891                 :            :                         DLB2_LOG_DBG("dlb2: put_qe: RTE_SCHED_TYPE_ORDERED\n");
    2892         [ #  # ]:          0 :                         if (qm_queue->sched_type != RTE_SCHED_TYPE_ORDERED) {
    2893                 :          0 :                                 DLB2_LOG_ERR("dlb2: tried to send ordered event to unordered queue %d\n",
    2894                 :            :                                              *queue_id);
    2895                 :          0 :                                 rte_errno = -EINVAL;
    2896                 :          0 :                                 return 1;
    2897                 :            :                         }
    2898                 :          0 :                         *sched_type = DLB2_SCHED_ORDERED;
    2899                 :          0 :                         break;
    2900                 :          0 :                 case RTE_SCHED_TYPE_ATOMIC:
    2901                 :            :                         DLB2_LOG_DBG("dlb2: put_qe: RTE_SCHED_TYPE_ATOMIC\n");
    2902                 :          0 :                         *sched_type = DLB2_SCHED_ATOMIC;
    2903                 :          0 :                         break;
    2904                 :          0 :                 case RTE_SCHED_TYPE_PARALLEL:
    2905                 :            :                         DLB2_LOG_DBG("dlb2: put_qe: RTE_SCHED_TYPE_PARALLEL\n");
    2906         [ #  # ]:          0 :                         if (qm_queue->sched_type == RTE_SCHED_TYPE_ORDERED)
    2907                 :          0 :                                 *sched_type = DLB2_SCHED_ORDERED;
    2908                 :            :                         else
    2909                 :          0 :                                 *sched_type = DLB2_SCHED_UNORDERED;
    2910                 :            :                         break;
    2911                 :          0 :                 default:
    2912                 :          0 :                         DLB2_LOG_ERR("Unsupported LDB sched type in put_qe\n");
    2913                 :          0 :                         DLB2_INC_STAT(ev_port->stats.tx_invalid, 1);
    2914                 :          0 :                         rte_errno = -EINVAL;
    2915                 :          0 :                         return 1;
    2916                 :            :                 }
    2917                 :            :         } else {
    2918                 :            :                 /* Directed destination queue */
    2919                 :            : 
    2920         [ #  # ]:          0 :                 if (dlb2->version == DLB2_HW_V2) {
    2921         [ #  # ]:          0 :                         if (dlb2_check_enqueue_hw_dir_credits(qm_port)) {
    2922                 :          0 :                                 rte_errno = -ENOSPC;
    2923                 :          0 :                                 return 1;
    2924                 :            :                         }
    2925                 :          0 :                         cached_credits = &qm_port->cached_dir_credits;
    2926                 :            :                 } else {
    2927         [ #  # ]:          0 :                         if (dlb2_check_enqueue_hw_credits(qm_port)) {
    2928                 :          0 :                                 rte_errno = -ENOSPC;
    2929                 :          0 :                                 return 1;
    2930                 :            :                         }
    2931                 :          0 :                         cached_credits = &qm_port->cached_credits;
    2932                 :            :                 }
    2933                 :            :                 DLB2_LOG_DBG("dlb2: put_qe: RTE_SCHED_TYPE_DIRECTED\n");
    2934                 :            : 
    2935                 :          0 :                 *sched_type = DLB2_SCHED_DIRECTED;
    2936                 :            :         }
    2937                 :            : 
    2938                 :          0 : op_check:
    2939   [ #  #  #  # ]:          0 :         switch (ev->op) {
    2940                 :          0 :         case RTE_EVENT_OP_NEW:
    2941                 :            :                 /* Check that a sw credit is available */
    2942         [ #  # ]:          0 :                 if (dlb2_check_enqueue_sw_credits(dlb2, ev_port)) {
    2943                 :          0 :                         rte_errno = -ENOSPC;
    2944                 :          0 :                         return 1;
    2945                 :            :                 }
    2946                 :          0 :                 ev_port->inflight_credits--;
    2947                 :          0 :                 (*cached_credits)--;
    2948                 :          0 :                 break;
    2949                 :          0 :         case RTE_EVENT_OP_FORWARD:
    2950                 :            :                 /* Check for outstanding_releases underflow. If this occurs,
    2951                 :            :                  * the application is not using the EVENT_OPs correctly; for
    2952                 :            :                  * example, forwarding or releasing events that were not
    2953                 :            :                  * dequeued.
    2954                 :            :                  */
    2955                 :            :                 RTE_ASSERT(ev_port->outstanding_releases > 0);
    2956                 :          0 :                 ev_port->outstanding_releases--;
    2957                 :          0 :                 qm_port->issued_releases++;
    2958                 :          0 :                 (*cached_credits)--;
    2959                 :          0 :                 break;
    2960                 :          0 :         case RTE_EVENT_OP_RELEASE:
    2961                 :          0 :                 ev_port->inflight_credits++;
    2962                 :            :                 /* Check for outstanding_releases underflow. If this occurs,
    2963                 :            :                  * the application is not using the EVENT_OPs correctly; for
    2964                 :            :                  * example, forwarding or releasing events that were not
    2965                 :            :                  * dequeued.
    2966                 :            :                  */
    2967                 :            :                 RTE_ASSERT(ev_port->outstanding_releases > 0);
    2968                 :          0 :                 ev_port->outstanding_releases--;
    2969                 :          0 :                 qm_port->issued_releases++;
    2970                 :            : 
    2971                 :            :                 /* Replenish s/w credits if enough are cached */
    2972                 :          0 :                 dlb2_replenish_sw_credits(dlb2, ev_port);
    2973                 :          0 :                 break;
    2974                 :            :         }
    2975                 :            : 
    2976                 :          0 :         DLB2_INC_STAT(ev_port->stats.tx_op_cnt[ev->op], 1);
    2977                 :          0 :         DLB2_INC_STAT(ev_port->stats.traffic.tx_ok, 1);
    2978                 :            : 
    2979                 :            : #ifndef RTE_LIBRTE_PMD_DLB_QUELL_STATS
    2980         [ #  # ]:          0 :         if (ev->op != RTE_EVENT_OP_RELEASE) {
    2981                 :          0 :                 DLB2_INC_STAT(ev_port->stats.queue[ev->queue_id].enq_ok, 1);
    2982                 :          0 :                 DLB2_INC_STAT(ev_port->stats.tx_sched_cnt[*sched_type], 1);
    2983                 :            :         }
    2984                 :            : #endif
    2985                 :            : 
    2986                 :            :         return 0;
    2987                 :            : }
    2988                 :            : 
    2989                 :            : static inline uint16_t
    2990                 :          0 : __dlb2_event_enqueue_burst(void *event_port,
    2991                 :            :                            const struct rte_event events[],
    2992                 :            :                            uint16_t num,
    2993                 :            :                            bool use_delayed)
    2994                 :            : {
    2995                 :            :         struct dlb2_eventdev_port *ev_port = event_port;
    2996                 :          0 :         struct dlb2_port *qm_port = &ev_port->qm_port;
    2997                 :            :         struct process_local_port_data *port_data;
    2998                 :          0 :         int retries = ev_port->enq_retries;
    2999                 :            :         int num_tx;
    3000                 :            :         int i;
    3001                 :            : 
    3002                 :            :         RTE_ASSERT(ev_port->enq_configured);
    3003                 :            :         RTE_ASSERT(events != NULL);
    3004                 :            : 
    3005                 :            :         i = 0;
    3006                 :            : 
    3007                 :          0 :         port_data = &dlb2_port[qm_port->id][PORT_TYPE(qm_port)];
    3008                 :          0 :         num_tx = RTE_MIN(num, ev_port->conf.enqueue_depth);
    3009         [ #  # ]:          0 :         while (i < num_tx) {
    3010                 :            :                 uint8_t sched_types[DLB2_NUM_QES_PER_CACHE_LINE];
    3011                 :            :                 uint8_t queue_ids[DLB2_NUM_QES_PER_CACHE_LINE];
    3012                 :            :                 int pop_offs = 0;
    3013                 :            :                 int j = 0;
    3014                 :            : 
    3015                 :          0 :                 memset(qm_port->qe4,
    3016                 :            :                        0,
    3017                 :            :                        DLB2_NUM_QES_PER_CACHE_LINE *
    3018                 :            :                        sizeof(struct dlb2_enqueue_qe));
    3019                 :            : 
    3020   [ #  #  #  # ]:          0 :                 for (; j < DLB2_NUM_QES_PER_CACHE_LINE && (i + j) < num; j++) {
    3021                 :          0 :                         const struct rte_event *ev = &events[i + j];
    3022                 :          0 :                         int16_t thresh = qm_port->token_pop_thresh;
    3023                 :            :                         int ret;
    3024                 :            : 
    3025         [ #  # ]:          0 :                         if (use_delayed &&
    3026         [ #  # ]:          0 :                             qm_port->token_pop_mode == DELAYED_POP &&
    3027         [ #  # ]:          0 :                             (ev->op == RTE_EVENT_OP_FORWARD ||
    3028                 :          0 :                              ev->op == RTE_EVENT_OP_RELEASE) &&
    3029         [ #  # ]:          0 :                             qm_port->issued_releases >= thresh - 1) {
    3030                 :            :                                 /* Insert the token pop QE and break out. This
    3031                 :            :                                  * may result in a partial HCW, but that is
    3032                 :            :                                  * simpler than supporting arbitrary QE
    3033                 :            :                                  * insertion.
    3034                 :            :                                  */
    3035                 :            :                                 dlb2_construct_token_pop_qe(qm_port, j);
    3036                 :            : 
    3037                 :            :                                 /* Reset the releases for the next QE batch */
    3038                 :          0 :                                 qm_port->issued_releases -= thresh;
    3039                 :            : 
    3040                 :            :                                 pop_offs = 1;
    3041                 :          0 :                                 j++;
    3042                 :          0 :                                 break;
    3043                 :            :                         }
    3044                 :            : 
    3045                 :            :                         /*
    3046                 :            :                          * Retry if insufficient credits
    3047                 :            :                          */
    3048                 :            :                         do {
    3049                 :          0 :                                 ret = dlb2_event_enqueue_prep(ev_port,
    3050                 :            :                                                               qm_port,
    3051                 :            :                                                               ev,
    3052                 :            :                                                               &sched_types[j],
    3053                 :            :                                                               &queue_ids[j]);
    3054   [ #  #  #  # ]:          0 :                         } while ((ret == -ENOSPC) && (retries-- > 0));
    3055                 :            : 
    3056         [ #  # ]:          0 :                         if (ret != 0)
    3057                 :            :                                 break;
    3058                 :            :                 }
    3059                 :            : 
    3060         [ #  # ]:          0 :                 if (j == 0)
    3061                 :            :                         break;
    3062                 :            : 
    3063                 :          0 :                 dlb2_event_build_hcws(qm_port, &events[i], j - pop_offs,
    3064                 :            :                                       sched_types, queue_ids);
    3065                 :            : 
    3066                 :            : #if DLB2_BYPASS_FENCE_ON_PP == 1
    3067                 :            :                 /* Bypass fence instruction for producer ports */
    3068                 :            :                 dlb2_hw_do_enqueue(qm_port, i == 0 && !qm_port->is_producer, port_data);
    3069                 :            : #else
    3070                 :            :                 dlb2_hw_do_enqueue(qm_port, i == 0, port_data);
    3071                 :            : #endif
    3072                 :            : 
    3073                 :            :                 /* Don't include the token pop QE in the enqueue count */
    3074                 :          0 :                 i += j - pop_offs;
    3075                 :            : 
    3076                 :            :                 /* Don't interpret j < DLB2_NUM_... as out-of-credits if
    3077                 :            :                  * pop_offs != 0
    3078                 :            :                  */
    3079         [ #  # ]:          0 :                 if (j < DLB2_NUM_QES_PER_CACHE_LINE && pop_offs == 0)
    3080                 :            :                         break;
    3081                 :            :         }
    3082                 :            : 
    3083                 :          0 :         return i;
    3084                 :            : }
    3085                 :            : 
    3086                 :            : static uint16_t
    3087                 :          0 : dlb2_event_enqueue_burst(void *event_port,
    3088                 :            :                              const struct rte_event events[],
    3089                 :            :                              uint16_t num)
    3090                 :            : {
    3091                 :          0 :         return __dlb2_event_enqueue_burst(event_port, events, num, false);
    3092                 :            : }
    3093                 :            : 
    3094                 :            : static uint16_t
    3095                 :          0 : dlb2_event_enqueue_burst_delayed(void *event_port,
    3096                 :            :                                      const struct rte_event events[],
    3097                 :            :                                      uint16_t num)
    3098                 :            : {
    3099                 :          0 :         return __dlb2_event_enqueue_burst(event_port, events, num, true);
    3100                 :            : }
    3101                 :            : 
    3102                 :            : static inline uint16_t
    3103                 :          0 : dlb2_event_enqueue(void *event_port,
    3104                 :            :                    const struct rte_event events[])
    3105                 :            : {
    3106                 :          0 :         return __dlb2_event_enqueue_burst(event_port, events, 1, false);
    3107                 :            : }
    3108                 :            : 
    3109                 :            : static inline uint16_t
    3110                 :          0 : dlb2_event_enqueue_delayed(void *event_port,
    3111                 :            :                            const struct rte_event events[])
    3112                 :            : {
    3113                 :          0 :         return __dlb2_event_enqueue_burst(event_port, events, 1, true);
    3114                 :            : }
    3115                 :            : 
    3116                 :            : static uint16_t
    3117                 :          0 : dlb2_event_enqueue_new_burst(void *event_port,
    3118                 :            :                              const struct rte_event events[],
    3119                 :            :                              uint16_t num)
    3120                 :            : {
    3121                 :          0 :         return __dlb2_event_enqueue_burst(event_port, events, num, false);
    3122                 :            : }
    3123                 :            : 
    3124                 :            : static uint16_t
    3125                 :          0 : dlb2_event_enqueue_new_burst_delayed(void *event_port,
    3126                 :            :                                      const struct rte_event events[],
    3127                 :            :                                      uint16_t num)
    3128                 :            : {
    3129                 :          0 :         return __dlb2_event_enqueue_burst(event_port, events, num, true);
    3130                 :            : }
    3131                 :            : 
    3132                 :            : static uint16_t
    3133                 :          0 : dlb2_event_enqueue_forward_burst(void *event_port,
    3134                 :            :                                  const struct rte_event events[],
    3135                 :            :                                  uint16_t num)
    3136                 :            : {
    3137                 :          0 :         return __dlb2_event_enqueue_burst(event_port, events, num, false);
    3138                 :            : }
    3139                 :            : 
    3140                 :            : static uint16_t
    3141                 :          0 : dlb2_event_enqueue_forward_burst_delayed(void *event_port,
    3142                 :            :                                          const struct rte_event events[],
    3143                 :            :                                          uint16_t num)
    3144                 :            : {
    3145                 :          0 :         return __dlb2_event_enqueue_burst(event_port, events, num, true);
    3146                 :            : }
    3147                 :            : 
    3148                 :            : static void
    3149                 :          0 : dlb2_event_release(struct dlb2_eventdev *dlb2,
    3150                 :            :                    uint8_t port_id,
    3151                 :            :                    int n)
    3152                 :            : {
    3153                 :            :         struct process_local_port_data *port_data;
    3154                 :            :         struct dlb2_eventdev_port *ev_port;
    3155                 :            :         struct dlb2_port *qm_port;
    3156                 :            :         int i;
    3157                 :            : 
    3158         [ #  # ]:          0 :         if (port_id > dlb2->num_ports) {
    3159                 :          0 :                 DLB2_LOG_ERR("Invalid port id %d in dlb2-event_release\n",
    3160                 :            :                              port_id);
    3161                 :          0 :                 rte_errno = -EINVAL;
    3162                 :          0 :                 return;
    3163                 :            :         }
    3164                 :            : 
    3165                 :          0 :         ev_port = &dlb2->ev_ports[port_id];
    3166                 :            :         qm_port = &ev_port->qm_port;
    3167                 :          0 :         port_data = &dlb2_port[qm_port->id][PORT_TYPE(qm_port)];
    3168                 :            : 
    3169                 :            :         i = 0;
    3170                 :            : 
    3171         [ #  # ]:          0 :         if (qm_port->is_directed) {
    3172                 :            :                 i = n;
    3173                 :          0 :                 goto sw_credit_update;
    3174                 :            :         }
    3175                 :            : 
    3176         [ #  # ]:          0 :         while (i < n) {
    3177                 :            :                 int pop_offs = 0;
    3178                 :            :                 int j = 0;
    3179                 :            : 
    3180                 :            :                 /* Zero-out QEs */
    3181                 :          0 :                 _mm_storeu_si128((void *)&qm_port->qe4[0], _mm_setzero_si128());
    3182                 :          0 :                 _mm_storeu_si128((void *)&qm_port->qe4[1], _mm_setzero_si128());
    3183                 :          0 :                 _mm_storeu_si128((void *)&qm_port->qe4[2], _mm_setzero_si128());
    3184                 :          0 :                 _mm_storeu_si128((void *)&qm_port->qe4[3], _mm_setzero_si128());
    3185                 :            : 
    3186                 :            : 
    3187   [ #  #  #  # ]:          0 :                 for (; j < DLB2_NUM_QES_PER_CACHE_LINE && (i + j) < n; j++) {
    3188                 :          0 :                         int16_t thresh = qm_port->token_pop_thresh;
    3189                 :            : 
    3190         [ #  # ]:          0 :                         if (qm_port->token_pop_mode == DELAYED_POP &&
    3191         [ #  # ]:          0 :                             qm_port->issued_releases >= thresh - 1) {
    3192                 :            :                                 /* Insert the token pop QE */
    3193                 :            :                                 dlb2_construct_token_pop_qe(qm_port, j);
    3194                 :            : 
    3195                 :            :                                 /* Reset the releases for the next QE batch */
    3196                 :          0 :                                 qm_port->issued_releases -= thresh;
    3197                 :            : 
    3198                 :            :                                 pop_offs = 1;
    3199                 :          0 :                                 j++;
    3200                 :          0 :                                 break;
    3201                 :            :                         }
    3202                 :            : 
    3203                 :          0 :                         qm_port->qe4[j].cmd_byte = DLB2_COMP_CMD_BYTE;
    3204                 :          0 :                         qm_port->issued_releases++;
    3205                 :            :                 }
    3206                 :            : 
    3207                 :            :                 dlb2_hw_do_enqueue(qm_port, i == 0, port_data);
    3208                 :            : 
    3209                 :            :                 /* Don't include the token pop QE in the release count */
    3210                 :          0 :                 i += j - pop_offs;
    3211                 :            :         }
    3212                 :            : 
    3213                 :          0 : sw_credit_update:
    3214                 :            :         /* each release returns one credit */
    3215         [ #  # ]:          0 :         if (unlikely(!ev_port->outstanding_releases)) {
    3216                 :          0 :                 DLB2_LOG_ERR("%s: Outstanding releases underflowed.\n",
    3217                 :            :                              __func__);
    3218                 :          0 :                 return;
    3219                 :            :         }
    3220                 :          0 :         ev_port->outstanding_releases -= i;
    3221                 :          0 :         ev_port->inflight_credits += i;
    3222                 :            : 
    3223                 :            :         /* Replenish s/w credits if enough releases are performed */
    3224                 :          0 :         dlb2_replenish_sw_credits(dlb2, ev_port);
    3225                 :            : }
    3226                 :            : 
    3227                 :            : static inline void
    3228                 :          0 : dlb2_port_credits_inc(struct dlb2_port *qm_port, int num)
    3229                 :            : {
    3230                 :          0 :         uint32_t batch_size = qm_port->hw_credit_quanta;
    3231                 :            : 
    3232                 :            :         /* increment port credits, and return to pool if exceeds threshold */
    3233         [ #  # ]:          0 :         if (!qm_port->is_directed) {
    3234         [ #  # ]:          0 :                 if (qm_port->dlb2->version == DLB2_HW_V2) {
    3235                 :          0 :                         qm_port->cached_ldb_credits += num;
    3236         [ #  # ]:          0 :                         if (qm_port->cached_ldb_credits >= 2 * batch_size) {
    3237                 :          0 :                                 __atomic_fetch_add(
    3238                 :          0 :                                         qm_port->credit_pool[DLB2_LDB_QUEUE],
    3239                 :            :                                         batch_size, __ATOMIC_SEQ_CST);
    3240                 :          0 :                                 qm_port->cached_ldb_credits -= batch_size;
    3241                 :            :                         }
    3242                 :            :                 } else {
    3243                 :          0 :                         qm_port->cached_credits += num;
    3244         [ #  # ]:          0 :                         if (qm_port->cached_credits >= 2 * batch_size) {
    3245                 :          0 :                                 __atomic_fetch_add(
    3246                 :          0 :                                       qm_port->credit_pool[DLB2_COMBINED_POOL],
    3247                 :            :                                       batch_size, __ATOMIC_SEQ_CST);
    3248                 :          0 :                                 qm_port->cached_credits -= batch_size;
    3249                 :            :                         }
    3250                 :            :                 }
    3251                 :            :         } else {
    3252         [ #  # ]:          0 :                 if (qm_port->dlb2->version == DLB2_HW_V2) {
    3253                 :          0 :                         qm_port->cached_dir_credits += num;
    3254         [ #  # ]:          0 :                         if (qm_port->cached_dir_credits >= 2 * batch_size) {
    3255                 :          0 :                                 __atomic_fetch_add(
    3256                 :          0 :                                         qm_port->credit_pool[DLB2_DIR_QUEUE],
    3257                 :            :                                         batch_size, __ATOMIC_SEQ_CST);
    3258                 :          0 :                                 qm_port->cached_dir_credits -= batch_size;
    3259                 :            :                         }
    3260                 :            :                 } else {
    3261                 :          0 :                         qm_port->cached_credits += num;
    3262         [ #  # ]:          0 :                         if (qm_port->cached_credits >= 2 * batch_size) {
    3263                 :          0 :                                 __atomic_fetch_add(
    3264                 :          0 :                                       qm_port->credit_pool[DLB2_COMBINED_POOL],
    3265                 :            :                                       batch_size, __ATOMIC_SEQ_CST);
    3266                 :          0 :                                 qm_port->cached_credits -= batch_size;
    3267                 :            :                         }
    3268                 :            :                 }
    3269                 :            :         }
    3270                 :          0 : }
    3271                 :            : 
    3272                 :            : #define CLB_MASK_IDX 0
    3273                 :            : #define CLB_VAL_IDX 1
    3274                 :            : static int
    3275                 :          0 : dlb2_monitor_callback(const uint64_t val,
    3276                 :            :                 const uint64_t opaque[RTE_POWER_MONITOR_OPAQUE_SZ])
    3277                 :            : {
    3278                 :            :         /* abort if the value matches */
    3279         [ #  # ]:          0 :         return (val & opaque[CLB_MASK_IDX]) == opaque[CLB_VAL_IDX] ? -1 : 0;
    3280                 :            : }
    3281                 :            : 
    3282                 :            : static inline int
    3283                 :          0 : dlb2_dequeue_wait(struct dlb2_eventdev *dlb2,
    3284                 :            :                   struct dlb2_eventdev_port *ev_port,
    3285                 :            :                   struct dlb2_port *qm_port,
    3286                 :            :                   uint64_t timeout,
    3287                 :            :                   uint64_t start_ticks)
    3288                 :            : {
    3289                 :            :         struct process_local_port_data *port_data;
    3290                 :            :         uint64_t elapsed_ticks;
    3291                 :            : 
    3292                 :          0 :         port_data = &dlb2_port[qm_port->id][PORT_TYPE(qm_port)];
    3293                 :            : 
    3294                 :          0 :         elapsed_ticks = rte_get_timer_cycles() - start_ticks;
    3295                 :            : 
    3296                 :            :         /* Wait/poll time expired */
    3297         [ #  # ]:          0 :         if (elapsed_ticks >= timeout) {
    3298                 :            :                 return 1;
    3299         [ #  # ]:          0 :         } else if (dlb2->umwait_allowed) {
    3300                 :            :                 struct rte_power_monitor_cond pmc;
    3301                 :            :                 volatile struct dlb2_dequeue_qe *cq_base;
    3302                 :            :                 union {
    3303                 :            :                         uint64_t raw_qe[2];
    3304                 :            :                         struct dlb2_dequeue_qe qe;
    3305                 :            :                 } qe_mask;
    3306                 :            :                 uint64_t expected_value;
    3307                 :            :                 volatile uint64_t *monitor_addr;
    3308                 :            : 
    3309                 :          0 :                 qe_mask.qe.cq_gen = 1; /* set mask */
    3310                 :            : 
    3311                 :          0 :                 cq_base = port_data->cq_base;
    3312                 :            :                 monitor_addr = (volatile uint64_t *)(volatile void *)
    3313                 :          0 :                         &cq_base[qm_port->cq_idx];
    3314                 :          0 :                 monitor_addr++; /* cq_gen bit is in second 64bit location */
    3315                 :            : 
    3316         [ #  # ]:          0 :                 if (qm_port->gen_bit)
    3317                 :          0 :                         expected_value = qe_mask.raw_qe[1];
    3318                 :            :                 else
    3319                 :            :                         expected_value = 0;
    3320                 :            : 
    3321                 :          0 :                 pmc.addr = monitor_addr;
    3322                 :            :                 /* store expected value and comparison mask in opaque data */
    3323                 :          0 :                 pmc.opaque[CLB_VAL_IDX] = expected_value;
    3324                 :          0 :                 pmc.opaque[CLB_MASK_IDX] = qe_mask.raw_qe[1];
    3325                 :            :                 /* set up callback */
    3326                 :          0 :                 pmc.fn = dlb2_monitor_callback;
    3327                 :          0 :                 pmc.size = sizeof(uint64_t);
    3328                 :            : 
    3329                 :          0 :                 rte_power_monitor(&pmc, timeout + start_ticks);
    3330                 :            : 
    3331                 :          0 :                 DLB2_INC_STAT(ev_port->stats.traffic.rx_umonitor_umwait, 1);
    3332                 :            :         } else {
    3333                 :          0 :                 uint64_t poll_interval = dlb2->poll_interval;
    3334                 :            :                 uint64_t curr_ticks = rte_get_timer_cycles();
    3335                 :            :                 uint64_t init_ticks = curr_ticks;
    3336                 :            : 
    3337         [ #  # ]:          0 :                 while ((curr_ticks - start_ticks < timeout) &&
    3338         [ #  # ]:          0 :                        (curr_ticks - init_ticks < poll_interval))
    3339                 :            :                         curr_ticks = rte_get_timer_cycles();
    3340                 :            :         }
    3341                 :            : 
    3342                 :            :         return 0;
    3343                 :            : }
    3344                 :            : 
    3345                 :            : static __rte_noinline int
    3346                 :          0 : dlb2_process_dequeue_qes(struct dlb2_eventdev_port *ev_port,
    3347                 :            :                          struct dlb2_port *qm_port,
    3348                 :            :                          struct rte_event *events,
    3349                 :            :                          struct dlb2_dequeue_qe *qes,
    3350                 :            :                          int cnt)
    3351                 :            : {
    3352                 :          0 :         uint8_t *qid_mappings = qm_port->qid_mappings;
    3353                 :            :         int i, num, evq_id;
    3354                 :            : 
    3355         [ #  # ]:          0 :         for (i = 0, num = 0; i < cnt; i++) {
    3356                 :          0 :                 struct dlb2_dequeue_qe *qe = &qes[i];
    3357                 :          0 :                 int sched_type_map[DLB2_NUM_HW_SCHED_TYPES] = {
    3358                 :            :                         [DLB2_SCHED_ATOMIC] = RTE_SCHED_TYPE_ATOMIC,
    3359                 :            :                         [DLB2_SCHED_UNORDERED] = RTE_SCHED_TYPE_PARALLEL,
    3360                 :            :                         [DLB2_SCHED_ORDERED] = RTE_SCHED_TYPE_ORDERED,
    3361                 :            :                         [DLB2_SCHED_DIRECTED] = RTE_SCHED_TYPE_ATOMIC,
    3362                 :            :                 };
    3363                 :            : 
    3364                 :            :                 /* Fill in event information.
    3365                 :            :                  * Note that flow_id must be embedded in the data by
    3366                 :            :                  * the app, such as the mbuf RSS hash field if the data
    3367                 :            :                  * buffer is a mbuf.
    3368                 :            :                  */
    3369         [ #  # ]:          0 :                 if (unlikely(qe->error)) {
    3370                 :          0 :                         DLB2_LOG_ERR("QE error bit ON\n");
    3371                 :          0 :                         DLB2_INC_STAT(ev_port->stats.traffic.rx_drop, 1);
    3372                 :            :                         dlb2_consume_qe_immediate(qm_port, 1);
    3373                 :          0 :                         continue; /* Ignore */
    3374                 :            :                 }
    3375                 :            : 
    3376                 :          0 :                 events[num].u64 = qe->data;
    3377                 :          0 :                 events[num].flow_id = qe->flow_id;
    3378                 :          0 :                 events[num].priority = DLB2_TO_EV_PRIO((uint8_t)qe->priority);
    3379                 :          0 :                 events[num].event_type = qe->u.event_type.major;
    3380                 :          0 :                 events[num].sub_event_type = qe->u.event_type.sub;
    3381                 :          0 :                 events[num].sched_type = sched_type_map[qe->sched_type];
    3382                 :          0 :                 events[num].impl_opaque = qe->qid_depth;
    3383                 :            : 
    3384                 :            :                 /* qid not preserved for directed queues */
    3385         [ #  # ]:          0 :                 if (qm_port->is_directed)
    3386                 :          0 :                         evq_id = ev_port->link[0].queue_id;
    3387                 :            :                 else
    3388                 :          0 :                         evq_id = qid_mappings[qe->qid];
    3389                 :            : 
    3390                 :          0 :                 events[num].queue_id = evq_id;
    3391                 :          0 :                 DLB2_INC_STAT(
    3392                 :            :                         ev_port->stats.queue[evq_id].qid_depth[qe->qid_depth],
    3393                 :            :                         1);
    3394                 :          0 :                 DLB2_INC_STAT(ev_port->stats.rx_sched_cnt[qe->sched_type], 1);
    3395                 :          0 :                 num++;
    3396                 :            :         }
    3397                 :            : 
    3398                 :          0 :         DLB2_INC_STAT(ev_port->stats.traffic.rx_ok, num);
    3399                 :            : 
    3400                 :          0 :         return num;
    3401                 :            : }
    3402                 :            : 
    3403                 :            : static inline int
    3404                 :          0 : dlb2_process_dequeue_four_qes(struct dlb2_eventdev_port *ev_port,
    3405                 :            :                               struct dlb2_port *qm_port,
    3406                 :            :                               struct rte_event *events,
    3407                 :            :                               struct dlb2_dequeue_qe *qes)
    3408                 :            : {
    3409                 :          0 :         int sched_type_map[] = {
    3410                 :            :                 [DLB2_SCHED_ATOMIC] = RTE_SCHED_TYPE_ATOMIC,
    3411                 :            :                 [DLB2_SCHED_UNORDERED] = RTE_SCHED_TYPE_PARALLEL,
    3412                 :            :                 [DLB2_SCHED_ORDERED] = RTE_SCHED_TYPE_ORDERED,
    3413                 :            :                 [DLB2_SCHED_DIRECTED] = RTE_SCHED_TYPE_ATOMIC,
    3414                 :            :         };
    3415                 :            :         const int num_events = DLB2_NUM_QES_PER_CACHE_LINE;
    3416                 :          0 :         uint8_t *qid_mappings = qm_port->qid_mappings;
    3417                 :            :         __m128i sse_evt[2];
    3418                 :            : 
    3419                 :            :         /* In the unlikely case that any of the QE error bits are set, process
    3420                 :            :          * them one at a time.
    3421                 :            :          */
    3422   [ #  #  #  #  :          0 :         if (unlikely(qes[0].error || qes[1].error ||
             #  #  #  # ]
    3423                 :            :                      qes[2].error || qes[3].error))
    3424                 :          0 :                 return dlb2_process_dequeue_qes(ev_port, qm_port, events,
    3425                 :            :                                                  qes, num_events);
    3426                 :            : 
    3427                 :          0 :         events[0].u64 = qes[0].data;
    3428                 :          0 :         events[1].u64 = qes[1].data;
    3429                 :          0 :         events[2].u64 = qes[2].data;
    3430                 :          0 :         events[3].u64 = qes[3].data;
    3431                 :            : 
    3432                 :            :         /* Construct the metadata portion of two struct rte_events
    3433                 :            :          * in one 128b SSE register. Event metadata is constructed in the SSE
    3434                 :            :          * registers like so:
    3435                 :            :          * sse_evt[0][63:0]:   event[0]'s metadata
    3436                 :            :          * sse_evt[0][127:64]: event[1]'s metadata
    3437                 :            :          * sse_evt[1][63:0]:   event[2]'s metadata
    3438                 :            :          * sse_evt[1][127:64]: event[3]'s metadata
    3439                 :            :          */
    3440                 :            :         sse_evt[0] = _mm_setzero_si128();
    3441                 :            :         sse_evt[1] = _mm_setzero_si128();
    3442                 :            : 
    3443                 :            :         /* Convert the hardware queue ID to an event queue ID and store it in
    3444                 :            :          * the metadata:
    3445                 :            :          * sse_evt[0][47:40]   = qid_mappings[qes[0].qid]
    3446                 :            :          * sse_evt[0][111:104] = qid_mappings[qes[1].qid]
    3447                 :            :          * sse_evt[1][47:40]   = qid_mappings[qes[2].qid]
    3448                 :            :          * sse_evt[1][111:104] = qid_mappings[qes[3].qid]
    3449                 :            :          */
    3450                 :            : #define DLB_EVENT_QUEUE_ID_BYTE 5
    3451                 :            :         sse_evt[0] = _mm_insert_epi8(sse_evt[0],
    3452                 :          0 :                                      qid_mappings[qes[0].qid],
    3453                 :            :                                      DLB_EVENT_QUEUE_ID_BYTE);
    3454                 :            :         sse_evt[0] = _mm_insert_epi8(sse_evt[0],
    3455                 :          0 :                                      qid_mappings[qes[1].qid],
    3456                 :            :                                      DLB_EVENT_QUEUE_ID_BYTE + 8);
    3457                 :            :         sse_evt[1] = _mm_insert_epi8(sse_evt[1],
    3458                 :          0 :                                      qid_mappings[qes[2].qid],
    3459                 :            :                                      DLB_EVENT_QUEUE_ID_BYTE);
    3460                 :            :         sse_evt[1] = _mm_insert_epi8(sse_evt[1],
    3461                 :          0 :                                      qid_mappings[qes[3].qid],
    3462                 :            :                                      DLB_EVENT_QUEUE_ID_BYTE + 8);
    3463                 :            : 
    3464                 :            :         /* Convert the hardware priority to an event priority and store it in
    3465                 :            :          * the metadata, while also returning the queue depth status
    3466                 :            :          * value captured by the hardware, storing it in impl_opaque, which can
    3467                 :            :          * be read by the application but not modified
    3468                 :            :          * sse_evt[0][55:48]   = DLB2_TO_EV_PRIO(qes[0].priority)
    3469                 :            :          * sse_evt[0][63:56]   = qes[0].qid_depth
    3470                 :            :          * sse_evt[0][119:112] = DLB2_TO_EV_PRIO(qes[1].priority)
    3471                 :            :          * sse_evt[0][127:120] = qes[1].qid_depth
    3472                 :            :          * sse_evt[1][55:48]   = DLB2_TO_EV_PRIO(qes[2].priority)
    3473                 :            :          * sse_evt[1][63:56]   = qes[2].qid_depth
    3474                 :            :          * sse_evt[1][119:112] = DLB2_TO_EV_PRIO(qes[3].priority)
    3475                 :            :          * sse_evt[1][127:120] = qes[3].qid_depth
    3476                 :            :          */
    3477                 :            : #define DLB_EVENT_PRIO_IMPL_OPAQUE_WORD 3
    3478                 :            : #define DLB_BYTE_SHIFT 8
    3479                 :            :         sse_evt[0] =
    3480                 :          0 :                 _mm_insert_epi16(sse_evt[0],
    3481                 :          0 :                         DLB2_TO_EV_PRIO((uint8_t)qes[0].priority) |
    3482                 :          0 :                         (qes[0].qid_depth << DLB_BYTE_SHIFT),
    3483                 :            :                         DLB_EVENT_PRIO_IMPL_OPAQUE_WORD);
    3484                 :            :         sse_evt[0] =
    3485                 :          0 :                 _mm_insert_epi16(sse_evt[0],
    3486                 :          0 :                         DLB2_TO_EV_PRIO((uint8_t)qes[1].priority) |
    3487                 :          0 :                         (qes[1].qid_depth << DLB_BYTE_SHIFT),
    3488                 :            :                         DLB_EVENT_PRIO_IMPL_OPAQUE_WORD + 4);
    3489                 :            :         sse_evt[1] =
    3490                 :          0 :                 _mm_insert_epi16(sse_evt[1],
    3491                 :          0 :                         DLB2_TO_EV_PRIO((uint8_t)qes[2].priority) |
    3492                 :          0 :                         (qes[2].qid_depth << DLB_BYTE_SHIFT),
    3493                 :            :                         DLB_EVENT_PRIO_IMPL_OPAQUE_WORD);
    3494                 :            :         sse_evt[1] =
    3495                 :          0 :                 _mm_insert_epi16(sse_evt[1],
    3496                 :          0 :                         DLB2_TO_EV_PRIO((uint8_t)qes[3].priority) |
    3497                 :          0 :                         (qes[3].qid_depth << DLB_BYTE_SHIFT),
    3498                 :            :                         DLB_EVENT_PRIO_IMPL_OPAQUE_WORD + 4);
    3499                 :            : 
    3500                 :            :         /* Write the event type, sub event type, and flow_id to the event
    3501                 :            :          * metadata.
    3502                 :            :          * sse_evt[0][31:0]   = qes[0].flow_id |
    3503                 :            :          *                      qes[0].u.event_type.major << 28 |
    3504                 :            :          *                      qes[0].u.event_type.sub << 20;
    3505                 :            :          * sse_evt[0][95:64]  = qes[1].flow_id |
    3506                 :            :          *                      qes[1].u.event_type.major << 28 |
    3507                 :            :          *                      qes[1].u.event_type.sub << 20;
    3508                 :            :          * sse_evt[1][31:0]   = qes[2].flow_id |
    3509                 :            :          *                      qes[2].u.event_type.major << 28 |
    3510                 :            :          *                      qes[2].u.event_type.sub << 20;
    3511                 :            :          * sse_evt[1][95:64]  = qes[3].flow_id |
    3512                 :            :          *                      qes[3].u.event_type.major << 28 |
    3513                 :            :          *                      qes[3].u.event_type.sub << 20;
    3514                 :            :          */
    3515                 :            : #define DLB_EVENT_EV_TYPE_DW 0
    3516                 :            : #define DLB_EVENT_EV_TYPE_SHIFT 28
    3517                 :            : #define DLB_EVENT_SUB_EV_TYPE_SHIFT 20
    3518                 :          0 :         sse_evt[0] = _mm_insert_epi32(sse_evt[0],
    3519                 :          0 :                         qes[0].flow_id |
    3520                 :          0 :                         qes[0].u.event_type.major << DLB_EVENT_EV_TYPE_SHIFT |
    3521                 :          0 :                         qes[0].u.event_type.sub <<  DLB_EVENT_SUB_EV_TYPE_SHIFT,
    3522                 :            :                         DLB_EVENT_EV_TYPE_DW);
    3523                 :          0 :         sse_evt[0] = _mm_insert_epi32(sse_evt[0],
    3524                 :          0 :                         qes[1].flow_id |
    3525                 :          0 :                         qes[1].u.event_type.major << DLB_EVENT_EV_TYPE_SHIFT |
    3526                 :          0 :                         qes[1].u.event_type.sub <<  DLB_EVENT_SUB_EV_TYPE_SHIFT,
    3527                 :            :                         DLB_EVENT_EV_TYPE_DW + 2);
    3528                 :          0 :         sse_evt[1] = _mm_insert_epi32(sse_evt[1],
    3529                 :          0 :                         qes[2].flow_id |
    3530                 :          0 :                         qes[2].u.event_type.major << DLB_EVENT_EV_TYPE_SHIFT |
    3531                 :          0 :                         qes[2].u.event_type.sub <<  DLB_EVENT_SUB_EV_TYPE_SHIFT,
    3532                 :            :                         DLB_EVENT_EV_TYPE_DW);
    3533                 :          0 :         sse_evt[1] = _mm_insert_epi32(sse_evt[1],
    3534                 :          0 :                         qes[3].flow_id |
    3535                 :          0 :                         qes[3].u.event_type.major << DLB_EVENT_EV_TYPE_SHIFT  |
    3536                 :          0 :                         qes[3].u.event_type.sub << DLB_EVENT_SUB_EV_TYPE_SHIFT,
    3537                 :            :                         DLB_EVENT_EV_TYPE_DW + 2);
    3538                 :            : 
    3539                 :            :         /* Write the sched type to the event metadata. 'op' and 'rsvd' are not
    3540                 :            :          * set:
    3541                 :            :          * sse_evt[0][39:32]  = sched_type_map[qes[0].sched_type] << 6
    3542                 :            :          * sse_evt[0][103:96] = sched_type_map[qes[1].sched_type] << 6
    3543                 :            :          * sse_evt[1][39:32]  = sched_type_map[qes[2].sched_type] << 6
    3544                 :            :          * sse_evt[1][103:96] = sched_type_map[qes[3].sched_type] << 6
    3545                 :            :          */
    3546                 :            : #define DLB_EVENT_SCHED_TYPE_BYTE 4
    3547                 :            : #define DLB_EVENT_SCHED_TYPE_SHIFT 6
    3548                 :          0 :         sse_evt[0] = _mm_insert_epi8(sse_evt[0],
    3549                 :          0 :                 sched_type_map[qes[0].sched_type] << DLB_EVENT_SCHED_TYPE_SHIFT,
    3550                 :            :                 DLB_EVENT_SCHED_TYPE_BYTE);
    3551                 :          0 :         sse_evt[0] = _mm_insert_epi8(sse_evt[0],
    3552                 :          0 :                 sched_type_map[qes[1].sched_type] << DLB_EVENT_SCHED_TYPE_SHIFT,
    3553                 :            :                 DLB_EVENT_SCHED_TYPE_BYTE + 8);
    3554                 :          0 :         sse_evt[1] = _mm_insert_epi8(sse_evt[1],
    3555                 :          0 :                 sched_type_map[qes[2].sched_type] << DLB_EVENT_SCHED_TYPE_SHIFT,
    3556                 :            :                 DLB_EVENT_SCHED_TYPE_BYTE);
    3557                 :          0 :         sse_evt[1] = _mm_insert_epi8(sse_evt[1],
    3558                 :          0 :                 sched_type_map[qes[3].sched_type] << DLB_EVENT_SCHED_TYPE_SHIFT,
    3559                 :            :                 DLB_EVENT_SCHED_TYPE_BYTE + 8);
    3560                 :            : 
    3561                 :            :         /* Store the metadata to the event (use the double-precision
    3562                 :            :          * _mm_storeh_pd because there is no integer function for storing the
    3563                 :            :          * upper 64b):
    3564                 :            :          * events[0].event = sse_evt[0][63:0]
    3565                 :            :          * events[1].event = sse_evt[0][127:64]
    3566                 :            :          * events[2].event = sse_evt[1][63:0]
    3567                 :            :          * events[3].event = sse_evt[1][127:64]
    3568                 :            :          */
    3569                 :            :         _mm_storel_epi64((__m128i *)&events[0].event, sse_evt[0]);
    3570                 :            :         _mm_storeh_pd((double *)&events[1].event, (__m128d) sse_evt[0]);
    3571                 :            :         _mm_storel_epi64((__m128i *)&events[2].event, sse_evt[1]);
    3572                 :            :         _mm_storeh_pd((double *)&events[3].event, (__m128d) sse_evt[1]);
    3573                 :            : 
    3574                 :          0 :         DLB2_INC_STAT(ev_port->stats.rx_sched_cnt[qes[0].sched_type], 1);
    3575                 :          0 :         DLB2_INC_STAT(ev_port->stats.rx_sched_cnt[qes[1].sched_type], 1);
    3576                 :          0 :         DLB2_INC_STAT(ev_port->stats.rx_sched_cnt[qes[2].sched_type], 1);
    3577                 :          0 :         DLB2_INC_STAT(ev_port->stats.rx_sched_cnt[qes[3].sched_type], 1);
    3578                 :            : 
    3579                 :          0 :         DLB2_INC_STAT(
    3580                 :            :                 ev_port->stats.queue[events[0].queue_id].
    3581                 :            :                         qid_depth[qes[0].qid_depth],
    3582                 :            :                 1);
    3583                 :          0 :         DLB2_INC_STAT(
    3584                 :            :                 ev_port->stats.queue[events[1].queue_id].
    3585                 :            :                         qid_depth[qes[1].qid_depth],
    3586                 :            :                 1);
    3587                 :          0 :         DLB2_INC_STAT(
    3588                 :            :                 ev_port->stats.queue[events[2].queue_id].
    3589                 :            :                         qid_depth[qes[2].qid_depth],
    3590                 :            :                 1);
    3591                 :          0 :         DLB2_INC_STAT(
    3592                 :            :                 ev_port->stats.queue[events[3].queue_id].
    3593                 :            :                         qid_depth[qes[3].qid_depth],
    3594                 :            :                 1);
    3595                 :            : 
    3596                 :          0 :         DLB2_INC_STAT(ev_port->stats.traffic.rx_ok, num_events);
    3597                 :            : 
    3598                 :          0 :         return num_events;
    3599                 :            : }
    3600                 :            : 
    3601                 :            : static __rte_always_inline int
    3602                 :            : dlb2_recv_qe_sparse(struct dlb2_port *qm_port, struct dlb2_dequeue_qe *qe)
    3603                 :            : {
    3604                 :            :         volatile struct dlb2_dequeue_qe *cq_addr;
    3605                 :          0 :         uint8_t xor_mask[2] = {0x0F, 0x00};
    3606                 :            :         const uint8_t and_mask = 0x0F;
    3607                 :            :         __m128i *qes = (__m128i *)qe;
    3608                 :            :         uint8_t gen_bits, gen_bit;
    3609                 :            :         uintptr_t addr[4];
    3610                 :            :         uint16_t idx;
    3611                 :            : 
    3612                 :          0 :         cq_addr = dlb2_port[qm_port->id][PORT_TYPE(qm_port)].cq_base;
    3613                 :            : 
    3614                 :          0 :         idx = qm_port->cq_idx_unmasked & qm_port->cq_depth_mask;
    3615                 :            :         /* Load the next 4 QEs */
    3616                 :          0 :         addr[0] = (uintptr_t)&cq_addr[idx];
    3617                 :          0 :         addr[1] = (uintptr_t)&cq_addr[(idx +  4) & qm_port->cq_depth_mask];
    3618                 :          0 :         addr[2] = (uintptr_t)&cq_addr[(idx +  8) & qm_port->cq_depth_mask];
    3619                 :          0 :         addr[3] = (uintptr_t)&cq_addr[(idx + 12) & qm_port->cq_depth_mask];
    3620                 :            : 
    3621                 :            :         /* Prefetch next batch of QEs (all CQs occupy minimum 8 cache lines) */
    3622                 :          0 :         rte_prefetch0(&cq_addr[(idx + 16) & qm_port->cq_depth_mask]);
    3623                 :          0 :         rte_prefetch0(&cq_addr[(idx + 20) & qm_port->cq_depth_mask]);
    3624                 :          0 :         rte_prefetch0(&cq_addr[(idx + 24) & qm_port->cq_depth_mask]);
    3625                 :          0 :         rte_prefetch0(&cq_addr[(idx + 28) & qm_port->cq_depth_mask]);
    3626                 :            : 
    3627                 :            :         /* Correct the xor_mask for wrap-around QEs */
    3628                 :          0 :         gen_bit = qm_port->gen_bit;
    3629         [ #  # ]:          0 :         xor_mask[gen_bit] ^= !!((idx +  4) > qm_port->cq_depth_mask) << 1;
    3630         [ #  # ]:          0 :         xor_mask[gen_bit] ^= !!((idx +  8) > qm_port->cq_depth_mask) << 2;
    3631         [ #  # ]:          0 :         xor_mask[gen_bit] ^= !!((idx + 12) > qm_port->cq_depth_mask) << 3;
    3632                 :            : 
    3633                 :            :         /* Read the cache lines backwards to ensure that if QE[N] (N > 0) is
    3634                 :            :          * valid, then QEs[0:N-1] are too.
    3635                 :            :          */
    3636                 :          0 :         qes[3] = _mm_load_si128((__m128i *)(void *)addr[3]);
    3637                 :          0 :         rte_compiler_barrier();
    3638                 :          0 :         qes[2] = _mm_load_si128((__m128i *)(void *)addr[2]);
    3639                 :          0 :         rte_compiler_barrier();
    3640                 :          0 :         qes[1] = _mm_load_si128((__m128i *)(void *)addr[1]);
    3641                 :          0 :         rte_compiler_barrier();
    3642         [ #  # ]:          0 :         qes[0] = _mm_load_si128((__m128i *)(void *)addr[0]);
    3643                 :            : 
    3644                 :            :         /* Extract and combine the gen bits */
    3645                 :          0 :         gen_bits = ((_mm_extract_epi8(qes[0], 15) & 0x1) << 0) |
    3646                 :          0 :                    ((_mm_extract_epi8(qes[1], 15) & 0x1) << 1) |
    3647                 :          0 :                    ((_mm_extract_epi8(qes[2], 15) & 0x1) << 2) |
    3648                 :          0 :                    ((_mm_extract_epi8(qes[3], 15) & 0x1) << 3);
    3649                 :            : 
    3650                 :            :         /* XOR the combined bits such that a 1 represents a valid QE */
    3651                 :          0 :         gen_bits ^= xor_mask[gen_bit];
    3652                 :            : 
    3653                 :            :         /* Mask off gen bits we don't care about */
    3654                 :          0 :         gen_bits &= and_mask;
    3655                 :            : 
    3656         [ #  # ]:          0 :         return rte_popcount32(gen_bits);
    3657                 :            : }
    3658                 :            : 
    3659                 :            : static inline void
    3660   [ #  #  #  #  :          0 : _process_deq_qes_vec_impl(struct dlb2_port *qm_port,
                      # ]
    3661                 :            :                           struct rte_event *events,
    3662                 :            :                           __m128i v_qe_3,
    3663                 :            :                           __m128i v_qe_2,
    3664                 :            :                           __m128i v_qe_1,
    3665                 :            :                           __m128i v_qe_0,
    3666                 :            :                           __m128i v_qe_meta,
    3667                 :            :                           __m128i v_qe_status,
    3668                 :            :                           uint32_t valid_events)
    3669                 :            : {
    3670                 :            :         /* Look up the event QIDs, using the hardware QIDs to index the
    3671                 :            :          * port's QID mapping.
    3672                 :            :          *
    3673                 :            :          * Each v_qe_[0-4] is just a 16-byte load of the whole QE. It is
    3674                 :            :          * passed along in registers as the QE data is required later.
    3675                 :            :          *
    3676                 :            :          * v_qe_meta is an u32 unpack of all 4x QEs. A.k.a, it contains one
    3677                 :            :          * 32-bit slice of each QE, so makes up a full SSE register. This
    3678                 :            :          * allows parallel processing of 4x QEs in a single register.
    3679                 :            :          */
    3680                 :            : 
    3681                 :            :         __m128i v_qid_done = {0};
    3682                 :            :         int hw_qid0 = _mm_extract_epi8(v_qe_meta, 2);
    3683                 :            :         int hw_qid1 = _mm_extract_epi8(v_qe_meta, 6);
    3684                 :            :         int hw_qid2 = _mm_extract_epi8(v_qe_meta, 10);
    3685                 :            :         int hw_qid3 = _mm_extract_epi8(v_qe_meta, 14);
    3686                 :            : 
    3687                 :          0 :         int ev_qid0 = qm_port->qid_mappings[hw_qid0];
    3688                 :          0 :         int ev_qid1 = qm_port->qid_mappings[hw_qid1];
    3689                 :          0 :         int ev_qid2 = qm_port->qid_mappings[hw_qid2];
    3690                 :          0 :         int ev_qid3 = qm_port->qid_mappings[hw_qid3];
    3691                 :            : 
    3692                 :          0 :         int hw_sched0 = _mm_extract_epi8(v_qe_meta, 3) & 3ul;
    3693                 :          0 :         int hw_sched1 = _mm_extract_epi8(v_qe_meta, 7) & 3ul;
    3694                 :          0 :         int hw_sched2 = _mm_extract_epi8(v_qe_meta, 11) & 3ul;
    3695   [ #  #  #  #  :          0 :         int hw_sched3 = _mm_extract_epi8(v_qe_meta, 15) & 3ul;
                      # ]
    3696                 :            : 
    3697                 :            :         v_qid_done = _mm_insert_epi8(v_qid_done, ev_qid0, 2);
    3698                 :            :         v_qid_done = _mm_insert_epi8(v_qid_done, ev_qid1, 6);
    3699                 :            :         v_qid_done = _mm_insert_epi8(v_qid_done, ev_qid2, 10);
    3700                 :            :         v_qid_done = _mm_insert_epi8(v_qid_done, ev_qid3, 14);
    3701                 :            : 
    3702                 :            :         /* Schedule field remapping using byte shuffle
    3703                 :            :          * - Full byte containing sched field handled here (op, rsvd are zero)
    3704                 :            :          * - Note sanitizing the register requires two masking ANDs:
    3705                 :            :          *   1) to strip prio/msg_type from byte for correct shuffle lookup
    3706                 :            :          *   2) to strip any non-sched-field lanes from any results to OR later
    3707                 :            :          * - Final byte result is >> 10 to another byte-lane inside the u32.
    3708                 :            :          *   This makes the final combination OR easier to make the rte_event.
    3709                 :            :          */
    3710                 :            :         __m128i v_sched_done;
    3711                 :            :         __m128i v_sched_bits;
    3712                 :            :         {
    3713                 :            :                 static const uint8_t sched_type_map[16] = {
    3714                 :            :                         [DLB2_SCHED_ATOMIC] = RTE_SCHED_TYPE_ATOMIC,
    3715                 :            :                         [DLB2_SCHED_UNORDERED] = RTE_SCHED_TYPE_PARALLEL,
    3716                 :            :                         [DLB2_SCHED_ORDERED] = RTE_SCHED_TYPE_ORDERED,
    3717                 :            :                         [DLB2_SCHED_DIRECTED] = RTE_SCHED_TYPE_ATOMIC,
    3718                 :            :                 };
    3719                 :            :                 static const uint8_t sched_and_mask[16] = {
    3720                 :            :                         0x00, 0x00, 0x00, 0x03,
    3721                 :            :                         0x00, 0x00, 0x00, 0x03,
    3722                 :            :                         0x00, 0x00, 0x00, 0x03,
    3723                 :            :                         0x00, 0x00, 0x00, 0x03,
    3724                 :            :                 };
    3725                 :            :                 const __m128i v_sched_map = _mm_loadu_si128(
    3726                 :            :                                              (const __m128i *)sched_type_map);
    3727                 :            :                 __m128i v_sched_mask = _mm_loadu_si128(
    3728                 :            :                                              (const __m128i *)&sched_and_mask);
    3729                 :            :                 v_sched_bits = _mm_and_si128(v_qe_meta, v_sched_mask);
    3730                 :            :                 __m128i v_sched_remapped = _mm_shuffle_epi8(v_sched_map,
    3731                 :            :                                                             v_sched_bits);
    3732                 :            :                 __m128i v_preshift = _mm_and_si128(v_sched_remapped,
    3733                 :            :                                                    v_sched_mask);
    3734                 :            :                 v_sched_done = _mm_srli_epi32(v_preshift, 10);
    3735                 :            :         }
    3736                 :            : 
    3737                 :            :         /* Priority handling
    3738                 :            :          * - QE provides 3 bits of priority
    3739                 :            :          * - Shift << 3 to move to MSBs for byte-prio in rte_event
    3740                 :            :          * - Mask bits to avoid pollution, leaving only 3 prio MSBs in reg
    3741                 :            :          */
    3742                 :            :         __m128i v_prio_done;
    3743                 :            :         {
    3744                 :            :                 static const uint8_t prio_mask[16] = {
    3745                 :            :                         0x00, 0x00, 0x00, 0x07 << 5,
    3746                 :            :                         0x00, 0x00, 0x00, 0x07 << 5,
    3747                 :            :                         0x00, 0x00, 0x00, 0x07 << 5,
    3748                 :            :                         0x00, 0x00, 0x00, 0x07 << 5,
    3749                 :            :                 };
    3750                 :            :                 __m128i v_prio_mask  = _mm_loadu_si128(
    3751                 :            :                                                 (const __m128i *)prio_mask);
    3752                 :            :                 __m128i v_prio_shifted = _mm_slli_epi32(v_qe_meta, 3);
    3753                 :            :                 v_prio_done = _mm_and_si128(v_prio_shifted, v_prio_mask);
    3754                 :            :         }
    3755                 :            : 
    3756                 :            :         /* Event Sub/Type handling:
    3757                 :            :          * we want to keep the lower 12 bits of each QE. Shift up by 20 bits
    3758                 :            :          * to get the sub/ev type data into rte_event location, clearing the
    3759                 :            :          * lower 20 bits in the process.
    3760                 :            :          */
    3761                 :            :         __m128i v_types_done;
    3762                 :            :         {
    3763                 :            :                 static const uint8_t event_mask[16] = {
    3764                 :            :                         0x0f, 0x00, 0x00, 0x00,
    3765                 :            :                         0x0f, 0x00, 0x00, 0x00,
    3766                 :            :                         0x0f, 0x00, 0x00, 0x00,
    3767                 :            :                         0x0f, 0x00, 0x00, 0x00,
    3768                 :            :                 };
    3769                 :            :                 static const uint8_t sub_event_mask[16] = {
    3770                 :            :                         0xff, 0x00, 0x00, 0x00,
    3771                 :            :                         0xff, 0x00, 0x00, 0x00,
    3772                 :            :                         0xff, 0x00, 0x00, 0x00,
    3773                 :            :                         0xff, 0x00, 0x00, 0x00,
    3774                 :            :                 };
    3775                 :            :                 static const uint8_t flow_mask[16] = {
    3776                 :            :                         0xff, 0xff, 0x00, 0x00,
    3777                 :            :                         0xff, 0xff, 0x00, 0x00,
    3778                 :            :                         0xff, 0xff, 0x00, 0x00,
    3779                 :            :                         0xff, 0xff, 0x00, 0x00,
    3780                 :            :                 };
    3781                 :            :                 __m128i v_event_mask  = _mm_loadu_si128(
    3782                 :            :                                         (const __m128i *)event_mask);
    3783                 :            :                 __m128i v_sub_event_mask  = _mm_loadu_si128(
    3784                 :            :                                         (const __m128i *)sub_event_mask);
    3785                 :            :                 __m128i v_flow_mask  = _mm_loadu_si128(
    3786                 :            :                                        (const __m128i *)flow_mask);
    3787                 :            :                 __m128i v_sub = _mm_srli_epi32(v_qe_meta, 8);
    3788                 :            :                 v_sub = _mm_and_si128(v_sub, v_sub_event_mask);
    3789                 :            :                 __m128i v_type = _mm_and_si128(v_qe_meta, v_event_mask);
    3790                 :            :                 v_type = _mm_slli_epi32(v_type, 8);
    3791                 :            :                 v_types_done = _mm_or_si128(v_type, v_sub);
    3792                 :            :                 v_types_done = _mm_slli_epi32(v_types_done, 20);
    3793                 :            :                 __m128i v_flow = _mm_and_si128(v_qe_status, v_flow_mask);
    3794                 :            :                 v_types_done = _mm_or_si128(v_types_done, v_flow);
    3795                 :            :         }
    3796                 :            : 
    3797                 :            :         /* Combine QID, Sched and Prio fields, then Shift >> 8 bits to align
    3798                 :            :          * with the rte_event, allowing unpacks to move/blend with payload.
    3799                 :            :          */
    3800                 :            :         __m128i v_q_s_p_done;
    3801                 :            :         {
    3802                 :            :                 __m128i v_qid_sched = _mm_or_si128(v_qid_done, v_sched_done);
    3803                 :            :                 __m128i v_q_s_prio = _mm_or_si128(v_qid_sched, v_prio_done);
    3804                 :            :                 v_q_s_p_done = _mm_srli_epi32(v_q_s_prio, 8);
    3805                 :            :         }
    3806                 :            : 
    3807                 :            :         __m128i v_unpk_ev_23, v_unpk_ev_01, v_ev_2, v_ev_3, v_ev_0, v_ev_1;
    3808                 :            : 
    3809                 :            :         /* Unpack evs into u64 metadata, then indiv events */
    3810                 :            :         v_unpk_ev_23 = _mm_unpackhi_epi32(v_types_done, v_q_s_p_done);
    3811                 :            :         v_unpk_ev_01 = _mm_unpacklo_epi32(v_types_done, v_q_s_p_done);
    3812                 :            : 
    3813   [ #  #  #  #  :          0 :         switch (valid_events) {
                      # ]
    3814                 :            :         case 4:
    3815                 :            :                 v_ev_3 = _mm_blend_epi16(v_unpk_ev_23, v_qe_3, 0x0F);
    3816                 :            :                 v_ev_3 = _mm_alignr_epi8(v_ev_3, v_ev_3, 8);
    3817                 :            :                 _mm_storeu_si128((__m128i *)&events[3], v_ev_3);
    3818                 :          0 :                 DLB2_INC_STAT(qm_port->ev_port->stats.rx_sched_cnt[hw_sched3],
    3819                 :            :                               1);
    3820                 :            :                 /* fallthrough */
    3821                 :          0 :         case 3:
    3822                 :            :                 v_ev_2 = _mm_unpacklo_epi64(v_unpk_ev_23, v_qe_2);
    3823                 :            :                 _mm_storeu_si128((__m128i *)&events[2], v_ev_2);
    3824                 :          0 :                 DLB2_INC_STAT(qm_port->ev_port->stats.rx_sched_cnt[hw_sched2],
    3825                 :            :                               1);
    3826                 :            :                 /* fallthrough */
    3827                 :          0 :         case 2:
    3828                 :            :                 v_ev_1 = _mm_blend_epi16(v_unpk_ev_01, v_qe_1, 0x0F);
    3829                 :            :                 v_ev_1 = _mm_alignr_epi8(v_ev_1, v_ev_1, 8);
    3830                 :            :                 _mm_storeu_si128((__m128i *)&events[1], v_ev_1);
    3831                 :          0 :                 DLB2_INC_STAT(qm_port->ev_port->stats.rx_sched_cnt[hw_sched1],
    3832                 :            :                               1);
    3833                 :            :                 /* fallthrough */
    3834                 :          0 :         case 1:
    3835                 :            :                 v_ev_0 = _mm_unpacklo_epi64(v_unpk_ev_01, v_qe_0);
    3836                 :            :                 _mm_storeu_si128((__m128i *)&events[0], v_ev_0);
    3837                 :          0 :                 DLB2_INC_STAT(qm_port->ev_port->stats.rx_sched_cnt[hw_sched0],
    3838                 :            :                               1);
    3839                 :            :         }
    3840                 :          0 : }
    3841                 :            : 
    3842                 :            : static __rte_always_inline int
    3843                 :            : dlb2_recv_qe_sparse_vec(struct dlb2_port *qm_port, void *events,
    3844                 :            :                         uint32_t max_events)
    3845                 :            : {
    3846                 :            :         /* Using unmasked idx for perf, and masking manually */
    3847                 :          0 :         uint16_t idx = qm_port->cq_idx_unmasked;
    3848                 :            :         volatile struct dlb2_dequeue_qe *cq_addr;
    3849                 :            : 
    3850                 :          0 :         cq_addr = dlb2_port[qm_port->id][PORT_TYPE(qm_port)].cq_base;
    3851                 :            : 
    3852                 :          0 :         uintptr_t qe_ptr_3 = (uintptr_t)&cq_addr[(idx + 12) &
    3853                 :          0 :                                                  qm_port->cq_depth_mask];
    3854                 :          0 :         uintptr_t qe_ptr_2 = (uintptr_t)&cq_addr[(idx +  8) &
    3855                 :            :                                                  qm_port->cq_depth_mask];
    3856                 :          0 :         uintptr_t qe_ptr_1 = (uintptr_t)&cq_addr[(idx +  4) &
    3857                 :            :                                                  qm_port->cq_depth_mask];
    3858                 :          0 :         uintptr_t qe_ptr_0 = (uintptr_t)&cq_addr[(idx +  0) &
    3859                 :            :                                                  qm_port->cq_depth_mask];
    3860                 :            : 
    3861                 :            :         /* Load QEs from CQ: use compiler barriers to avoid load reordering */
    3862                 :            :         __m128i v_qe_3 = _mm_loadu_si128((const __m128i *)qe_ptr_3);
    3863                 :          0 :         rte_compiler_barrier();
    3864                 :            :         __m128i v_qe_2 = _mm_loadu_si128((const __m128i *)qe_ptr_2);
    3865                 :          0 :         rte_compiler_barrier();
    3866                 :            :         __m128i v_qe_1 = _mm_loadu_si128((const __m128i *)qe_ptr_1);
    3867                 :          0 :         rte_compiler_barrier();
    3868                 :            :         __m128i v_qe_0 = _mm_loadu_si128((const __m128i *)qe_ptr_0);
    3869                 :            : 
    3870                 :            :         /* Generate the pkt_shuffle mask;
    3871                 :            :          * - Avoids load in otherwise load-heavy section of code
    3872                 :            :          * - Moves bytes 3,7,11,15 (gen bit bytes) to LSB bytes in XMM
    3873                 :            :          */
    3874                 :            :         const uint32_t stat_shuf_bytes = (15 << 24) | (11 << 16) | (7 << 8) | 3;
    3875                 :            :         __m128i v_zeros = _mm_setzero_si128();
    3876                 :            :         __m128i v_ffff = _mm_cmpeq_epi8(v_zeros, v_zeros);
    3877                 :            :         __m128i v_stat_shuf_mask = _mm_insert_epi32(v_ffff, stat_shuf_bytes, 0);
    3878                 :            : 
    3879                 :            :         /* Extract u32 components required from the QE
    3880                 :            :          * - QE[64 to 95 ] for metadata (qid, sched, prio, event type, ...)
    3881                 :            :          * - QE[96 to 127] for status (cq gen bit, error)
    3882                 :            :          *
    3883                 :            :          * Note that stage 1 of the unpacking is re-used for both u32 extracts
    3884                 :            :          */
    3885                 :            :         __m128i v_qe_02 = _mm_unpackhi_epi32(v_qe_0, v_qe_2);
    3886                 :            :         __m128i v_qe_13 = _mm_unpackhi_epi32(v_qe_1, v_qe_3);
    3887                 :            :         __m128i v_qe_status = _mm_unpackhi_epi32(v_qe_02, v_qe_13);
    3888                 :            :         __m128i v_qe_meta   = _mm_unpacklo_epi32(v_qe_02, v_qe_13);
    3889                 :            : 
    3890                 :            :         /* Status byte (gen_bit, error) handling:
    3891                 :            :          * - Shuffle to lanes 0,1,2,3, clear all others
    3892                 :            :          * - Shift right by 7 for gen bit to MSB, movemask to scalar
    3893                 :            :          * - Shift right by 2 for error bit to MSB, movemask to scalar
    3894                 :            :          */
    3895                 :            :         __m128i v_qe_shuffled = _mm_shuffle_epi8(v_qe_status, v_stat_shuf_mask);
    3896                 :            :         __m128i v_qes_shift_gen_bit = _mm_slli_epi32(v_qe_shuffled, 7);
    3897                 :          0 :         int32_t qe_gen_bits = _mm_movemask_epi8(v_qes_shift_gen_bit) & 0xf;
    3898                 :            : 
    3899                 :            :         /* Expected vs Reality of QE Gen bits
    3900                 :            :          * - cq_rolling_mask provides expected bits
    3901                 :            :          * - QE loads, unpacks/shuffle and movemask provides reality
    3902                 :            :          * - XOR of the two gives bitmask of new packets
    3903                 :            :          * - POPCNT to get the number of new events
    3904                 :            :          */
    3905                 :          0 :         uint64_t rolling = qm_port->cq_rolling_mask & 0xF;
    3906                 :          0 :         uint64_t qe_xor_bits = (qe_gen_bits ^ rolling);
    3907         [ #  # ]:          0 :         uint32_t count_new = rte_popcount32(qe_xor_bits);
    3908                 :          0 :         count_new = RTE_MIN(count_new, max_events);
    3909         [ #  # ]:          0 :         if (!count_new)
    3910                 :            :                 return 0;
    3911                 :            : 
    3912                 :            :         /* emulate a 128 bit rotate using 2x 64-bit numbers and bit-shifts */
    3913                 :            : 
    3914                 :          0 :         uint64_t m_rshift = qm_port->cq_rolling_mask >> count_new;
    3915                 :          0 :         uint64_t m_lshift = qm_port->cq_rolling_mask << (64 - count_new);
    3916                 :          0 :         uint64_t m2_rshift = qm_port->cq_rolling_mask_2 >> count_new;
    3917                 :          0 :         uint64_t m2_lshift = qm_port->cq_rolling_mask_2 << (64 - count_new);
    3918                 :            : 
    3919                 :            :         /* shifted out of m2 into MSB of m */
    3920                 :          0 :         qm_port->cq_rolling_mask = (m_rshift | m2_lshift);
    3921                 :            : 
    3922                 :            :         /* shifted out of m "looped back" into MSB of m2 */
    3923                 :          0 :         qm_port->cq_rolling_mask_2 = (m2_rshift | m_lshift);
    3924                 :            : 
    3925                 :            :         /* Prefetch the next QEs - should run as IPC instead of cycles */
    3926                 :          0 :         rte_prefetch0(&cq_addr[(idx + 16) & qm_port->cq_depth_mask]);
    3927                 :          0 :         rte_prefetch0(&cq_addr[(idx + 20) & qm_port->cq_depth_mask]);
    3928                 :          0 :         rte_prefetch0(&cq_addr[(idx + 24) & qm_port->cq_depth_mask]);
    3929                 :          0 :         rte_prefetch0(&cq_addr[(idx + 28) & qm_port->cq_depth_mask]);
    3930                 :            : 
    3931                 :            :         /* Convert QEs from XMM regs to events and store events directly */
    3932                 :          0 :         _process_deq_qes_vec_impl(qm_port, events, v_qe_3, v_qe_2, v_qe_1,
    3933                 :            :                                   v_qe_0, v_qe_meta, v_qe_status, count_new);
    3934                 :            : 
    3935                 :          0 :         return count_new;
    3936                 :            : }
    3937                 :            : 
    3938                 :            : static inline void
    3939                 :            : dlb2_inc_cq_idx(struct dlb2_port *qm_port, int cnt)
    3940                 :            : {
    3941                 :          0 :         uint16_t idx = qm_port->cq_idx_unmasked + cnt;
    3942                 :            : 
    3943                 :          0 :         qm_port->cq_idx_unmasked = idx;
    3944                 :          0 :         qm_port->cq_idx = idx & qm_port->cq_depth_mask;
    3945                 :          0 :         qm_port->gen_bit = (~(idx >> qm_port->gen_bit_shift)) & 0x1;
    3946                 :            : }
    3947                 :            : 
    3948                 :            : static inline int16_t
    3949                 :          0 : dlb2_hw_dequeue_sparse(struct dlb2_eventdev *dlb2,
    3950                 :            :                        struct dlb2_eventdev_port *ev_port,
    3951                 :            :                        struct rte_event *events,
    3952                 :            :                        uint16_t max_num,
    3953                 :            :                        uint64_t dequeue_timeout_ticks)
    3954                 :            : {
    3955                 :            :         uint64_t start_ticks = 0ULL;
    3956                 :            :         struct dlb2_port *qm_port;
    3957                 :            :         int num = 0;
    3958                 :            :         bool use_scalar;
    3959                 :            :         uint64_t timeout;
    3960                 :            : 
    3961                 :          0 :         qm_port = &ev_port->qm_port;
    3962                 :          0 :         use_scalar = qm_port->use_scalar;
    3963                 :            : 
    3964         [ #  # ]:          0 :         if (!dlb2->global_dequeue_wait)
    3965                 :            :                 timeout = dequeue_timeout_ticks;
    3966                 :            :         else
    3967                 :          0 :                 timeout = dlb2->global_dequeue_wait_ticks;
    3968                 :            : 
    3969                 :            :         start_ticks = rte_get_timer_cycles();
    3970                 :            : 
    3971   [ #  #  #  # ]:          0 :         use_scalar = use_scalar || (max_num & 0x3);
    3972                 :            : 
    3973         [ #  # ]:          0 :         while (num < max_num) {
    3974                 :            :                 struct dlb2_dequeue_qe qes[DLB2_NUM_QES_PER_CACHE_LINE];
    3975                 :            :                 int num_avail;
    3976                 :            : 
    3977         [ #  # ]:          0 :                 if (use_scalar) {
    3978                 :            :                         int n_iter = 0;
    3979                 :            :                         uint64_t m_rshift, m_lshift, m2_rshift, m2_lshift;
    3980                 :            : 
    3981                 :            :                         num_avail = dlb2_recv_qe_sparse(qm_port, qes);
    3982                 :          0 :                         num_avail = RTE_MIN(num_avail, max_num - num);
    3983                 :          0 :                         dlb2_inc_cq_idx(qm_port, num_avail << 2);
    3984         [ #  # ]:          0 :                         if (num_avail == DLB2_NUM_QES_PER_CACHE_LINE)
    3985                 :          0 :                                 n_iter = dlb2_process_dequeue_four_qes(ev_port,
    3986                 :            :                                                                 qm_port,
    3987                 :          0 :                                                                 &events[num],
    3988                 :            :                                                                 &qes[0]);
    3989         [ #  # ]:          0 :                         else if (num_avail)
    3990                 :          0 :                                 n_iter = dlb2_process_dequeue_qes(ev_port,
    3991                 :            :                                                                 qm_port,
    3992                 :          0 :                                                                 &events[num],
    3993                 :            :                                                                 &qes[0],
    3994                 :            :                                                                 num_avail);
    3995         [ #  # ]:          0 :                         if (n_iter != 0) {
    3996                 :          0 :                                 num += n_iter;
    3997                 :            :                                 /* update rolling_mask for vector code support */
    3998                 :          0 :                                 m_rshift = qm_port->cq_rolling_mask >> n_iter;
    3999                 :          0 :                                 m_lshift = qm_port->cq_rolling_mask << (64 - n_iter);
    4000                 :          0 :                                 m2_rshift = qm_port->cq_rolling_mask_2 >> n_iter;
    4001                 :          0 :                                 m2_lshift = qm_port->cq_rolling_mask_2 <<
    4002                 :            :                                         (64 - n_iter);
    4003                 :          0 :                                 qm_port->cq_rolling_mask = (m_rshift | m2_lshift);
    4004                 :          0 :                                 qm_port->cq_rolling_mask_2 = (m2_rshift | m_lshift);
    4005                 :            :                         }
    4006                 :            :                 } else { /* !use_scalar */
    4007                 :          0 :                         num_avail = dlb2_recv_qe_sparse_vec(qm_port,
    4008                 :          0 :                                                             &events[num],
    4009                 :          0 :                                                             max_num - num);
    4010                 :          0 :                         dlb2_inc_cq_idx(qm_port, num_avail << 2);
    4011                 :          0 :                         num += num_avail;
    4012                 :          0 :                         DLB2_INC_STAT(ev_port->stats.traffic.rx_ok, num_avail);
    4013                 :            :                 }
    4014         [ #  # ]:          0 :                 if (!num_avail) {
    4015         [ #  # ]:          0 :                         if ((timeout == 0) || (num > 0))
    4016                 :            :                                 /* Not waiting in any form or 1+ events recd */
    4017                 :            :                                 break;
    4018         [ #  # ]:          0 :                         else if (dlb2_dequeue_wait(dlb2, ev_port, qm_port,
    4019                 :            :                                                    timeout, start_ticks))
    4020                 :            :                                 break;
    4021                 :            :                 }
    4022                 :            :         }
    4023                 :            : 
    4024                 :          0 :         qm_port->owed_tokens += num;
    4025                 :            : 
    4026         [ #  # ]:          0 :         if (num) {
    4027         [ #  # ]:          0 :                 if (qm_port->token_pop_mode == AUTO_POP)
    4028                 :            :                         dlb2_consume_qe_immediate(qm_port, num);
    4029                 :            : 
    4030                 :          0 :                 ev_port->outstanding_releases += num;
    4031                 :            : 
    4032                 :          0 :                 dlb2_port_credits_inc(qm_port, num);
    4033                 :            :         }
    4034                 :            : 
    4035                 :          0 :         return num;
    4036                 :            : }
    4037                 :            : 
    4038                 :            : static __rte_always_inline int
    4039                 :            : dlb2_recv_qe(struct dlb2_port *qm_port, struct dlb2_dequeue_qe *qe,
    4040                 :            :              uint8_t *offset)
    4041                 :            : {
    4042                 :          0 :         uint8_t xor_mask[2][4] = { {0x0F, 0x0E, 0x0C, 0x08},
    4043                 :            :                                    {0x00, 0x01, 0x03, 0x07} };
    4044                 :          0 :         uint8_t and_mask[4] = {0x0F, 0x0E, 0x0C, 0x08};
    4045                 :            :         volatile struct dlb2_dequeue_qe *cq_addr;
    4046                 :            :         __m128i *qes = (__m128i *)qe;
    4047                 :            :         uint64_t *cache_line_base;
    4048                 :            :         uint8_t gen_bits;
    4049                 :            : 
    4050                 :          0 :         cq_addr = dlb2_port[qm_port->id][PORT_TYPE(qm_port)].cq_base;
    4051                 :          0 :         cq_addr = &cq_addr[qm_port->cq_idx];
    4052                 :            : 
    4053                 :          0 :         cache_line_base = (void *)(((uintptr_t)cq_addr) & ~0x3F);
    4054                 :          0 :         *offset = ((uintptr_t)cq_addr & 0x30) >> 4;
    4055                 :            : 
    4056                 :            :         /* Load the next CQ cache line from memory. Pack these reads as tight
    4057                 :            :          * as possible to reduce the chance that DLB invalidates the line while
    4058                 :            :          * the CPU is reading it. Read the cache line backwards to ensure that
    4059                 :            :          * if QE[N] (N > 0) is valid, then QEs[0:N-1] are too.
    4060                 :            :          *
    4061                 :            :          * (Valid QEs start at &qe[offset])
    4062                 :            :          */
    4063                 :          0 :         qes[3] = _mm_load_si128((__m128i *)&cache_line_base[6]);
    4064                 :          0 :         qes[2] = _mm_load_si128((__m128i *)&cache_line_base[4]);
    4065                 :          0 :         qes[1] = _mm_load_si128((__m128i *)&cache_line_base[2]);
    4066                 :          0 :         qes[0] = _mm_load_si128((__m128i *)&cache_line_base[0]);
    4067                 :            : 
    4068                 :            :         /* Evict the cache line ASAP */
    4069                 :            :         rte_cldemote(cache_line_base);
    4070                 :            : 
    4071                 :            :         /* Extract and combine the gen bits */
    4072                 :          0 :         gen_bits = ((_mm_extract_epi8(qes[0], 15) & 0x1) << 0) |
    4073                 :          0 :                    ((_mm_extract_epi8(qes[1], 15) & 0x1) << 1) |
    4074                 :          0 :                    ((_mm_extract_epi8(qes[2], 15) & 0x1) << 2) |
    4075                 :          0 :                    ((_mm_extract_epi8(qes[3], 15) & 0x1) << 3);
    4076                 :            : 
    4077                 :            :         /* XOR the combined bits such that a 1 represents a valid QE */
    4078                 :          0 :         gen_bits ^= xor_mask[qm_port->gen_bit][*offset];
    4079                 :            : 
    4080                 :            :         /* Mask off gen bits we don't care about */
    4081                 :          0 :         gen_bits &= and_mask[*offset];
    4082                 :            : 
    4083         [ #  # ]:          0 :         return rte_popcount32(gen_bits);
    4084                 :            : }
    4085                 :            : 
    4086                 :            : static inline int16_t
    4087                 :          0 : dlb2_hw_dequeue(struct dlb2_eventdev *dlb2,
    4088                 :            :                 struct dlb2_eventdev_port *ev_port,
    4089                 :            :                 struct rte_event *events,
    4090                 :            :                 uint16_t max_num,
    4091                 :            :                 uint64_t dequeue_timeout_ticks)
    4092                 :            : {
    4093                 :            :         uint64_t timeout;
    4094                 :            :         uint64_t start_ticks = 0ULL;
    4095                 :            :         struct dlb2_port *qm_port;
    4096                 :            :         int num = 0;
    4097                 :            : 
    4098                 :          0 :         qm_port = &ev_port->qm_port;
    4099                 :            : 
    4100                 :            :         /* We have a special implementation for waiting. Wait can be:
    4101                 :            :          * 1) no waiting at all
    4102                 :            :          * 2) busy poll only
    4103                 :            :          * 3) wait for interrupt. If wakeup and poll time
    4104                 :            :          * has expired, then return to caller
    4105                 :            :          * 4) umonitor/umwait repeatedly up to poll time
    4106                 :            :          */
    4107                 :            : 
    4108                 :            :         /* If configured for per dequeue wait, then use wait value provided
    4109                 :            :          * to this API. Otherwise we must use the global
    4110                 :            :          * value from eventdev config time.
    4111                 :            :          */
    4112         [ #  # ]:          0 :         if (!dlb2->global_dequeue_wait)
    4113                 :            :                 timeout = dequeue_timeout_ticks;
    4114                 :            :         else
    4115                 :          0 :                 timeout = dlb2->global_dequeue_wait_ticks;
    4116                 :            : 
    4117                 :            :         start_ticks = rte_get_timer_cycles();
    4118                 :            : 
    4119         [ #  # ]:          0 :         while (num < max_num) {
    4120                 :            :                 struct dlb2_dequeue_qe qes[DLB2_NUM_QES_PER_CACHE_LINE];
    4121                 :            :                 uint8_t offset;
    4122                 :            :                 int num_avail;
    4123                 :            : 
    4124                 :            :                 /* Copy up to 4 QEs from the current cache line into qes */
    4125                 :            :                 num_avail = dlb2_recv_qe(qm_port, qes, &offset);
    4126                 :            : 
    4127                 :            :                 /* But don't process more than the user requested */
    4128                 :          0 :                 num_avail = RTE_MIN(num_avail, max_num - num);
    4129                 :            : 
    4130                 :            :                 dlb2_inc_cq_idx(qm_port, num_avail);
    4131                 :            : 
    4132         [ #  # ]:          0 :                 if (num_avail == DLB2_NUM_QES_PER_CACHE_LINE)
    4133                 :          0 :                         num += dlb2_process_dequeue_four_qes(ev_port,
    4134                 :            :                                                              qm_port,
    4135                 :          0 :                                                              &events[num],
    4136                 :            :                                                              &qes[offset]);
    4137         [ #  # ]:          0 :                 else if (num_avail)
    4138                 :          0 :                         num += dlb2_process_dequeue_qes(ev_port,
    4139                 :            :                                                         qm_port,
    4140                 :          0 :                                                         &events[num],
    4141                 :            :                                                         &qes[offset],
    4142                 :            :                                                         num_avail);
    4143         [ #  # ]:          0 :                 else if ((timeout == 0) || (num > 0))
    4144                 :            :                         /* Not waiting in any form, or 1+ events received? */
    4145                 :            :                         break;
    4146         [ #  # ]:          0 :                 else if (dlb2_dequeue_wait(dlb2, ev_port, qm_port,
    4147                 :            :                                            timeout, start_ticks))
    4148                 :            :                         break;
    4149                 :            :         }
    4150                 :            : 
    4151                 :          0 :         qm_port->owed_tokens += num;
    4152                 :            : 
    4153         [ #  # ]:          0 :         if (num) {
    4154         [ #  # ]:          0 :                 if (qm_port->token_pop_mode == AUTO_POP)
    4155                 :            :                         dlb2_consume_qe_immediate(qm_port, num);
    4156                 :            : 
    4157                 :          0 :                 ev_port->outstanding_releases += num;
    4158                 :            : 
    4159                 :          0 :                 dlb2_port_credits_inc(qm_port, num);
    4160                 :            :         }
    4161                 :            : 
    4162                 :          0 :         return num;
    4163                 :            : }
    4164                 :            : 
    4165                 :            : static uint16_t
    4166                 :          0 : dlb2_event_dequeue_burst(void *event_port, struct rte_event *ev, uint16_t num,
    4167                 :            :                          uint64_t wait)
    4168                 :            : {
    4169                 :            :         struct dlb2_eventdev_port *ev_port = event_port;
    4170                 :            :         struct dlb2_port *qm_port = &ev_port->qm_port;
    4171                 :          0 :         struct dlb2_eventdev *dlb2 = ev_port->dlb2;
    4172                 :            :         uint16_t cnt;
    4173                 :            : 
    4174                 :            :         RTE_ASSERT(ev_port->setup_done);
    4175                 :            :         RTE_ASSERT(ev != NULL);
    4176                 :            : 
    4177   [ #  #  #  # ]:          0 :         if (ev_port->implicit_release && ev_port->outstanding_releases > 0) {
    4178                 :            :                 uint16_t out_rels = ev_port->outstanding_releases;
    4179                 :            : 
    4180                 :          0 :                 dlb2_event_release(dlb2, ev_port->id, out_rels);
    4181                 :            : 
    4182                 :          0 :                 DLB2_INC_STAT(ev_port->stats.tx_implicit_rel, out_rels);
    4183                 :            :         }
    4184                 :            : 
    4185   [ #  #  #  # ]:          0 :         if (qm_port->token_pop_mode == DEFERRED_POP && qm_port->owed_tokens)
    4186                 :            :                 dlb2_consume_qe_immediate(qm_port, qm_port->owed_tokens);
    4187                 :            : 
    4188                 :          0 :         cnt = dlb2_hw_dequeue(dlb2, ev_port, ev, num, wait);
    4189                 :            : 
    4190                 :          0 :         DLB2_INC_STAT(ev_port->stats.traffic.total_polls, 1);
    4191         [ #  # ]:          0 :         DLB2_INC_STAT(ev_port->stats.traffic.zero_polls, ((cnt == 0) ? 1 : 0));
    4192                 :            : 
    4193                 :          0 :         return cnt;
    4194                 :            : }
    4195                 :            : 
    4196                 :            : static uint16_t
    4197                 :          0 : dlb2_event_dequeue(void *event_port, struct rte_event *ev, uint64_t wait)
    4198                 :            : {
    4199                 :          0 :         return dlb2_event_dequeue_burst(event_port, ev, 1, wait);
    4200                 :            : }
    4201                 :            : 
    4202                 :            : static uint16_t
    4203                 :          0 : dlb2_event_dequeue_burst_sparse(void *event_port, struct rte_event *ev,
    4204                 :            :                                 uint16_t num, uint64_t wait)
    4205                 :            : {
    4206                 :            :         struct dlb2_eventdev_port *ev_port = event_port;
    4207                 :            :         struct dlb2_port *qm_port = &ev_port->qm_port;
    4208                 :          0 :         struct dlb2_eventdev *dlb2 = ev_port->dlb2;
    4209                 :            :         uint16_t cnt;
    4210                 :            : 
    4211                 :            :         RTE_ASSERT(ev_port->setup_done);
    4212                 :            :         RTE_ASSERT(ev != NULL);
    4213                 :            : 
    4214   [ #  #  #  # ]:          0 :         if (ev_port->implicit_release && ev_port->outstanding_releases > 0) {
    4215                 :            :                 uint16_t out_rels = ev_port->outstanding_releases;
    4216                 :            : 
    4217                 :          0 :                 dlb2_event_release(dlb2, ev_port->id, out_rels);
    4218                 :            : 
    4219                 :          0 :                 DLB2_INC_STAT(ev_port->stats.tx_implicit_rel, out_rels);
    4220                 :            :         }
    4221                 :            : 
    4222   [ #  #  #  # ]:          0 :         if (qm_port->token_pop_mode == DEFERRED_POP && qm_port->owed_tokens)
    4223                 :            :                 dlb2_consume_qe_immediate(qm_port, qm_port->owed_tokens);
    4224                 :            : 
    4225                 :          0 :         cnt = dlb2_hw_dequeue_sparse(dlb2, ev_port, ev, num, wait);
    4226                 :            : 
    4227                 :          0 :         DLB2_INC_STAT(ev_port->stats.traffic.total_polls, 1);
    4228         [ #  # ]:          0 :         DLB2_INC_STAT(ev_port->stats.traffic.zero_polls, ((cnt == 0) ? 1 : 0));
    4229                 :          0 :         return cnt;
    4230                 :            : }
    4231                 :            : 
    4232                 :            : static uint16_t
    4233                 :          0 : dlb2_event_dequeue_sparse(void *event_port, struct rte_event *ev,
    4234                 :            :                           uint64_t wait)
    4235                 :            : {
    4236                 :          0 :         return dlb2_event_dequeue_burst_sparse(event_port, ev, 1, wait);
    4237                 :            : }
    4238                 :            : 
    4239                 :            : static void
    4240                 :          0 : dlb2_flush_port(struct rte_eventdev *dev, int port_id)
    4241                 :            : {
    4242                 :            :         struct dlb2_eventdev *dlb2 = dlb2_pmd_priv(dev);
    4243                 :            :         eventdev_stop_flush_t flush;
    4244                 :            :         struct rte_event ev;
    4245                 :            :         uint8_t dev_id;
    4246                 :            :         void *arg;
    4247                 :            :         int i;
    4248                 :            : 
    4249                 :          0 :         flush = dev->dev_ops->dev_stop_flush;
    4250                 :          0 :         dev_id = dev->data->dev_id;
    4251                 :          0 :         arg = dev->data->dev_stop_flush_arg;
    4252                 :            : 
    4253         [ #  # ]:          0 :         while (rte_event_dequeue_burst(dev_id, port_id, &ev, 1, 0)) {
    4254         [ #  # ]:          0 :                 if (flush)
    4255                 :          0 :                         flush(dev_id, ev, arg);
    4256                 :            : 
    4257         [ #  # ]:          0 :                 if (dlb2->ev_ports[port_id].qm_port.is_directed)
    4258                 :          0 :                         continue;
    4259                 :            : 
    4260                 :          0 :                 ev.op = RTE_EVENT_OP_RELEASE;
    4261                 :            : 
    4262                 :          0 :                 rte_event_enqueue_burst(dev_id, port_id, &ev, 1);
    4263                 :            :         }
    4264                 :            : 
    4265                 :            :         /* Enqueue any additional outstanding releases */
    4266                 :          0 :         ev.op = RTE_EVENT_OP_RELEASE;
    4267                 :            : 
    4268         [ #  # ]:          0 :         for (i = dlb2->ev_ports[port_id].outstanding_releases; i > 0; i--)
    4269                 :          0 :                 rte_event_enqueue_burst(dev_id, port_id, &ev, 1);
    4270                 :          0 : }
    4271                 :            : 
    4272                 :            : static uint32_t
    4273                 :          0 : dlb2_get_ldb_queue_depth(struct dlb2_eventdev *dlb2,
    4274                 :            :                          struct dlb2_eventdev_queue *queue)
    4275                 :            : {
    4276                 :          0 :         struct dlb2_hw_dev *handle = &dlb2->qm_instance;
    4277                 :            :         struct dlb2_get_ldb_queue_depth_args cfg;
    4278                 :            :         int ret;
    4279                 :            : 
    4280                 :          0 :         cfg.queue_id = queue->qm_queue.id;
    4281                 :            : 
    4282                 :          0 :         ret = dlb2_iface_get_ldb_queue_depth(handle, &cfg);
    4283         [ #  # ]:          0 :         if (ret < 0) {
    4284                 :          0 :                 DLB2_LOG_ERR("dlb2: get_ldb_queue_depth ret=%d (driver status: %s)\n",
    4285                 :            :                              ret, dlb2_error_strings[cfg.response.status]);
    4286                 :          0 :                 return ret;
    4287                 :            :         }
    4288                 :            : 
    4289                 :          0 :         return cfg.response.id;
    4290                 :            : }
    4291                 :            : 
    4292                 :            : static uint32_t
    4293                 :          0 : dlb2_get_dir_queue_depth(struct dlb2_eventdev *dlb2,
    4294                 :            :                          struct dlb2_eventdev_queue *queue)
    4295                 :            : {
    4296                 :          0 :         struct dlb2_hw_dev *handle = &dlb2->qm_instance;
    4297                 :            :         struct dlb2_get_dir_queue_depth_args cfg;
    4298                 :            :         int ret;
    4299                 :            : 
    4300                 :          0 :         cfg.queue_id = queue->qm_queue.id;
    4301                 :            : 
    4302                 :          0 :         ret = dlb2_iface_get_dir_queue_depth(handle, &cfg);
    4303         [ #  # ]:          0 :         if (ret < 0) {
    4304                 :          0 :                 DLB2_LOG_ERR("dlb2: get_dir_queue_depth ret=%d (driver status: %s)\n",
    4305                 :            :                              ret, dlb2_error_strings[cfg.response.status]);
    4306                 :          0 :                 return ret;
    4307                 :            :         }
    4308                 :            : 
    4309                 :          0 :         return cfg.response.id;
    4310                 :            : }
    4311                 :            : 
    4312                 :            : uint32_t
    4313                 :          0 : dlb2_get_queue_depth(struct dlb2_eventdev *dlb2,
    4314                 :            :                      struct dlb2_eventdev_queue *queue)
    4315                 :            : {
    4316         [ #  # ]:          0 :         if (queue->qm_queue.is_directed)
    4317                 :          0 :                 return dlb2_get_dir_queue_depth(dlb2, queue);
    4318                 :            :         else
    4319                 :          0 :                 return dlb2_get_ldb_queue_depth(dlb2, queue);
    4320                 :            : }
    4321                 :            : 
    4322                 :            : static bool
    4323                 :            : dlb2_queue_is_empty(struct dlb2_eventdev *dlb2,
    4324                 :            :                     struct dlb2_eventdev_queue *queue)
    4325                 :            : {
    4326                 :          0 :         return dlb2_get_queue_depth(dlb2, queue) == 0;
    4327                 :            : }
    4328                 :            : 
    4329                 :            : static bool
    4330                 :          0 : dlb2_linked_queues_empty(struct dlb2_eventdev *dlb2)
    4331                 :            : {
    4332                 :            :         int i;
    4333                 :            : 
    4334         [ #  # ]:          0 :         for (i = 0; i < dlb2->num_queues; i++) {
    4335         [ #  # ]:          0 :                 if (dlb2->ev_queues[i].num_links == 0)
    4336                 :          0 :                         continue;
    4337         [ #  # ]:          0 :                 if (!dlb2_queue_is_empty(dlb2, &dlb2->ev_queues[i]))
    4338                 :            :                         return false;
    4339                 :            :         }
    4340                 :            : 
    4341                 :            :         return true;
    4342                 :            : }
    4343                 :            : 
    4344                 :            : static bool
    4345                 :            : dlb2_queues_empty(struct dlb2_eventdev *dlb2)
    4346                 :            : {
    4347                 :            :         int i;
    4348                 :            : 
    4349         [ #  # ]:          0 :         for (i = 0; i < dlb2->num_queues; i++) {
    4350         [ #  # ]:          0 :                 if (!dlb2_queue_is_empty(dlb2, &dlb2->ev_queues[i]))
    4351                 :            :                         return false;
    4352                 :            :         }
    4353                 :            : 
    4354                 :            :         return true;
    4355                 :            : }
    4356                 :            : 
    4357                 :            : static void
    4358                 :          0 : dlb2_drain(struct rte_eventdev *dev)
    4359                 :            : {
    4360                 :            :         struct dlb2_eventdev *dlb2 = dlb2_pmd_priv(dev);
    4361                 :            :         struct dlb2_eventdev_port *ev_port = NULL;
    4362                 :            :         uint8_t dev_id;
    4363                 :            :         int i;
    4364                 :            : 
    4365                 :          0 :         dev_id = dev->data->dev_id;
    4366                 :            : 
    4367         [ #  # ]:          0 :         while (!dlb2_linked_queues_empty(dlb2)) {
    4368                 :            :                 /* Flush all the ev_ports, which will drain all their connected
    4369                 :            :                  * queues.
    4370                 :            :                  */
    4371         [ #  # ]:          0 :                 for (i = 0; i < dlb2->num_ports; i++)
    4372                 :          0 :                         dlb2_flush_port(dev, i);
    4373                 :            :         }
    4374                 :            : 
    4375                 :            :         /* The queues are empty, but there may be events left in the ports. */
    4376         [ #  # ]:          0 :         for (i = 0; i < dlb2->num_ports; i++)
    4377                 :          0 :                 dlb2_flush_port(dev, i);
    4378                 :            : 
    4379                 :            :         /* If the domain's queues are empty, we're done. */
    4380         [ #  # ]:          0 :         if (dlb2_queues_empty(dlb2))
    4381                 :            :                 return;
    4382                 :            : 
    4383                 :            :         /* Else, there must be at least one unlinked load-balanced queue.
    4384                 :            :          * Select a load-balanced port with which to drain the unlinked
    4385                 :            :          * queue(s).
    4386                 :            :          */
    4387         [ #  # ]:          0 :         for (i = 0; i < dlb2->num_ports; i++) {
    4388                 :          0 :                 ev_port = &dlb2->ev_ports[i];
    4389                 :            : 
    4390         [ #  # ]:          0 :                 if (!ev_port->qm_port.is_directed)
    4391                 :            :                         break;
    4392                 :            :         }
    4393                 :            : 
    4394         [ #  # ]:          0 :         if (i == dlb2->num_ports) {
    4395                 :          0 :                 DLB2_LOG_ERR("internal error: no LDB ev_ports\n");
    4396                 :          0 :                 return;
    4397                 :            :         }
    4398                 :            : 
    4399                 :          0 :         rte_errno = 0;
    4400                 :          0 :         rte_event_port_unlink(dev_id, ev_port->id, NULL, 0);
    4401                 :            : 
    4402         [ #  # ]:          0 :         if (rte_errno) {
    4403                 :          0 :                 DLB2_LOG_ERR("internal error: failed to unlink ev_port %d\n",
    4404                 :            :                              ev_port->id);
    4405                 :          0 :                 return;
    4406                 :            :         }
    4407                 :            : 
    4408         [ #  # ]:          0 :         for (i = 0; i < dlb2->num_queues; i++) {
    4409                 :            :                 uint8_t qid, prio;
    4410                 :            :                 int ret;
    4411                 :            : 
    4412         [ #  # ]:          0 :                 if (dlb2_queue_is_empty(dlb2, &dlb2->ev_queues[i]))
    4413                 :          0 :                         continue;
    4414                 :            : 
    4415                 :          0 :                 qid = i;
    4416                 :          0 :                 prio = 0;
    4417                 :            : 
    4418                 :            :                 /* Link the ev_port to the queue */
    4419                 :          0 :                 ret = rte_event_port_link(dev_id, ev_port->id, &qid, &prio, 1);
    4420         [ #  # ]:          0 :                 if (ret != 1) {
    4421                 :          0 :                         DLB2_LOG_ERR("internal error: failed to link ev_port %d to queue %d\n",
    4422                 :            :                                      ev_port->id, qid);
    4423                 :          0 :                         return;
    4424                 :            :                 }
    4425                 :            : 
    4426                 :            :                 /* Flush the queue */
    4427         [ #  # ]:          0 :                 while (!dlb2_queue_is_empty(dlb2, &dlb2->ev_queues[i]))
    4428                 :          0 :                         dlb2_flush_port(dev, ev_port->id);
    4429                 :            : 
    4430                 :            :                 /* Drain any extant events in the ev_port. */
    4431                 :          0 :                 dlb2_flush_port(dev, ev_port->id);
    4432                 :            : 
    4433                 :            :                 /* Unlink the ev_port from the queue */
    4434                 :          0 :                 ret = rte_event_port_unlink(dev_id, ev_port->id, &qid, 1);
    4435         [ #  # ]:          0 :                 if (ret != 1) {
    4436                 :          0 :                         DLB2_LOG_ERR("internal error: failed to unlink ev_port %d to queue %d\n",
    4437                 :            :                                      ev_port->id, qid);
    4438                 :          0 :                         return;
    4439                 :            :                 }
    4440                 :            :         }
    4441                 :            : }
    4442                 :            : 
    4443                 :            : static void
    4444                 :          0 : dlb2_eventdev_stop(struct rte_eventdev *dev)
    4445                 :            : {
    4446                 :            :         struct dlb2_eventdev *dlb2 = dlb2_pmd_priv(dev);
    4447                 :            : 
    4448                 :          0 :         rte_spinlock_lock(&dlb2->qm_instance.resource_lock);
    4449                 :            : 
    4450         [ #  # ]:          0 :         if (dlb2->run_state == DLB2_RUN_STATE_STOPPED) {
    4451                 :            :                 DLB2_LOG_DBG("Internal error: already stopped\n");
    4452                 :            :                 rte_spinlock_unlock(&dlb2->qm_instance.resource_lock);
    4453                 :          0 :                 return;
    4454         [ #  # ]:          0 :         } else if (dlb2->run_state != DLB2_RUN_STATE_STARTED) {
    4455                 :          0 :                 DLB2_LOG_ERR("Internal error: bad state %d for dev_stop\n",
    4456                 :            :                              (int)dlb2->run_state);
    4457                 :            :                 rte_spinlock_unlock(&dlb2->qm_instance.resource_lock);
    4458                 :          0 :                 return;
    4459                 :            :         }
    4460                 :            : 
    4461                 :          0 :         dlb2->run_state = DLB2_RUN_STATE_STOPPING;
    4462                 :            : 
    4463                 :            :         rte_spinlock_unlock(&dlb2->qm_instance.resource_lock);
    4464                 :            : 
    4465                 :          0 :         dlb2_drain(dev);
    4466                 :            : 
    4467                 :          0 :         dlb2->run_state = DLB2_RUN_STATE_STOPPED;
    4468                 :            : }
    4469                 :            : 
    4470                 :            : static int
    4471                 :          0 : dlb2_eventdev_close(struct rte_eventdev *dev)
    4472                 :            : {
    4473                 :          0 :         dlb2_hw_reset_sched_domain(dev, false);
    4474                 :            : 
    4475                 :          0 :         return 0;
    4476                 :            : }
    4477                 :            : 
    4478                 :            : static void
    4479                 :          0 : dlb2_eventdev_queue_release(struct rte_eventdev *dev, uint8_t id)
    4480                 :            : {
    4481                 :            :         RTE_SET_USED(dev);
    4482                 :            :         RTE_SET_USED(id);
    4483                 :            : 
    4484                 :            :         /* This function intentionally left blank. */
    4485                 :          0 : }
    4486                 :            : 
    4487                 :            : static void
    4488                 :          0 : dlb2_eventdev_port_release(void *port)
    4489                 :            : {
    4490                 :            :         struct dlb2_eventdev_port *ev_port = port;
    4491                 :            :         struct dlb2_port *qm_port;
    4492                 :            : 
    4493         [ #  # ]:          0 :         if (ev_port) {
    4494                 :          0 :                 qm_port = &ev_port->qm_port;
    4495         [ #  # ]:          0 :                 if (qm_port->config_state == DLB2_CONFIGURED)
    4496                 :          0 :                         dlb2_free_qe_mem(qm_port);
    4497                 :            :         }
    4498                 :          0 : }
    4499                 :            : 
    4500                 :            : static int
    4501                 :          0 : dlb2_eventdev_timeout_ticks(struct rte_eventdev *dev, uint64_t ns,
    4502                 :            :                             uint64_t *timeout_ticks)
    4503                 :            : {
    4504                 :            :         RTE_SET_USED(dev);
    4505                 :          0 :         uint64_t cycles_per_ns = rte_get_timer_hz() / 1E9;
    4506                 :            : 
    4507                 :          0 :         *timeout_ticks = ns * cycles_per_ns;
    4508                 :            : 
    4509                 :          0 :         return 0;
    4510                 :            : }
    4511                 :            : 
    4512                 :            : static void
    4513                 :            : dlb2_entry_points_init(struct rte_eventdev *dev)
    4514                 :            : {
    4515                 :            :         struct dlb2_eventdev *dlb2;
    4516                 :            : 
    4517                 :            :         /* Expose PMD's eventdev interface */
    4518                 :            :         static struct eventdev_ops dlb2_eventdev_entry_ops = {
    4519                 :            :                 .dev_infos_get    = dlb2_eventdev_info_get,
    4520                 :            :                 .dev_configure    = dlb2_eventdev_configure,
    4521                 :            :                 .dev_start        = dlb2_eventdev_start,
    4522                 :            :                 .dev_stop         = dlb2_eventdev_stop,
    4523                 :            :                 .dev_close        = dlb2_eventdev_close,
    4524                 :            :                 .queue_def_conf   = dlb2_eventdev_queue_default_conf_get,
    4525                 :            :                 .queue_setup      = dlb2_eventdev_queue_setup,
    4526                 :            :                 .queue_release    = dlb2_eventdev_queue_release,
    4527                 :            :                 .port_def_conf    = dlb2_eventdev_port_default_conf_get,
    4528                 :            :                 .port_setup       = dlb2_eventdev_port_setup,
    4529                 :            :                 .port_release     = dlb2_eventdev_port_release,
    4530                 :            :                 .port_link        = dlb2_eventdev_port_link,
    4531                 :            :                 .port_unlink      = dlb2_eventdev_port_unlink,
    4532                 :            :                 .port_unlinks_in_progress =
    4533                 :            :                                     dlb2_eventdev_port_unlinks_in_progress,
    4534                 :            :                 .timeout_ticks    = dlb2_eventdev_timeout_ticks,
    4535                 :            :                 .dump             = dlb2_eventdev_dump,
    4536                 :            :                 .xstats_get       = dlb2_eventdev_xstats_get,
    4537                 :            :                 .xstats_get_names = dlb2_eventdev_xstats_get_names,
    4538                 :            :                 .xstats_get_by_name = dlb2_eventdev_xstats_get_by_name,
    4539                 :            :                 .xstats_reset       = dlb2_eventdev_xstats_reset,
    4540                 :            :                 .dev_selftest     = test_dlb2_eventdev,
    4541                 :            :         };
    4542                 :            : 
    4543                 :            :         /* Expose PMD's eventdev interface */
    4544                 :            : 
    4545                 :          0 :         dev->dev_ops = &dlb2_eventdev_entry_ops;
    4546                 :          0 :         dev->enqueue = dlb2_event_enqueue;
    4547                 :          0 :         dev->enqueue_burst = dlb2_event_enqueue_burst;
    4548                 :          0 :         dev->enqueue_new_burst = dlb2_event_enqueue_new_burst;
    4549                 :          0 :         dev->enqueue_forward_burst = dlb2_event_enqueue_forward_burst;
    4550                 :            : 
    4551                 :          0 :         dlb2 = dev->data->dev_private;
    4552   [ #  #  #  # ]:          0 :         if (dlb2->poll_mode == DLB2_CQ_POLL_MODE_SPARSE) {
    4553                 :          0 :                 dev->dequeue = dlb2_event_dequeue_sparse;
    4554                 :          0 :                 dev->dequeue_burst = dlb2_event_dequeue_burst_sparse;
    4555                 :            :         } else {
    4556                 :          0 :                 dev->dequeue = dlb2_event_dequeue;
    4557                 :          0 :                 dev->dequeue_burst = dlb2_event_dequeue_burst;
    4558                 :            :         }
    4559                 :            : }
    4560                 :            : 
    4561                 :            : int
    4562                 :          0 : dlb2_primary_eventdev_probe(struct rte_eventdev *dev,
    4563                 :            :                             const char *name,
    4564                 :            :                             struct dlb2_devargs *dlb2_args)
    4565                 :            : {
    4566                 :            :         struct dlb2_eventdev *dlb2;
    4567                 :            :         int err, i;
    4568                 :            : 
    4569                 :          0 :         dlb2 = dev->data->dev_private;
    4570                 :            : 
    4571                 :          0 :         dlb2->event_dev = dev; /* backlink */
    4572                 :            : 
    4573                 :          0 :         evdev_dlb2_default_info.driver_name = name;
    4574                 :            : 
    4575                 :          0 :         dlb2->max_num_events_override = dlb2_args->max_num_events;
    4576                 :          0 :         dlb2->num_dir_credits_override = dlb2_args->num_dir_credits_override;
    4577                 :          0 :         dlb2->poll_interval = dlb2_args->poll_interval;
    4578                 :          0 :         dlb2->sw_credit_quanta = dlb2_args->sw_credit_quanta;
    4579                 :          0 :         dlb2->hw_credit_quanta = dlb2_args->hw_credit_quanta;
    4580                 :          0 :         dlb2->default_depth_thresh = dlb2_args->default_depth_thresh;
    4581                 :          0 :         dlb2->vector_opts_enabled = dlb2_args->vector_opts_enabled;
    4582                 :          0 :         dlb2->enable_cq_weight = dlb2_args->enable_cq_weight;
    4583                 :            : 
    4584                 :            : 
    4585         [ #  # ]:          0 :         if (dlb2_args->max_cq_depth != 0)
    4586                 :          0 :                 dlb2->max_cq_depth = dlb2_args->max_cq_depth;
    4587                 :            :         else
    4588                 :          0 :                 dlb2->max_cq_depth = DLB2_DEFAULT_CQ_DEPTH;
    4589                 :            : 
    4590                 :          0 :         evdev_dlb2_default_info.max_event_port_dequeue_depth = dlb2->max_cq_depth;
    4591                 :            : 
    4592         [ #  # ]:          0 :         if (dlb2_args->max_enq_depth != 0)
    4593                 :          0 :                 dlb2->max_enq_depth = dlb2_args->max_enq_depth;
    4594                 :            :         else
    4595                 :          0 :                 dlb2->max_enq_depth = DLB2_DEFAULT_CQ_DEPTH;
    4596                 :            : 
    4597                 :          0 :         evdev_dlb2_default_info.max_event_port_enqueue_depth =
    4598                 :          0 :                 dlb2->max_enq_depth;
    4599                 :            : 
    4600                 :            :         dlb2_init_queue_depth_thresholds(dlb2,
    4601                 :          0 :                                          dlb2_args->qid_depth_thresholds.val);
    4602                 :            : 
    4603                 :            :         dlb2_init_port_cos(dlb2,
    4604                 :          0 :                            dlb2_args->port_cos.cos_id);
    4605                 :            : 
    4606                 :          0 :         dlb2_init_cos_bw(dlb2,
    4607                 :            :                          &dlb2_args->cos_bw);
    4608                 :            : 
    4609                 :          0 :         err = dlb2_iface_open(&dlb2->qm_instance, name);
    4610         [ #  # ]:          0 :         if (err < 0) {
    4611                 :          0 :                 DLB2_LOG_ERR("could not open event hardware device, err=%d\n",
    4612                 :            :                              err);
    4613                 :          0 :                 return err;
    4614                 :            :         }
    4615                 :            : 
    4616                 :          0 :         err = dlb2_iface_get_device_version(&dlb2->qm_instance,
    4617                 :            :                                             &dlb2->revision);
    4618         [ #  # ]:          0 :         if (err < 0) {
    4619                 :          0 :                 DLB2_LOG_ERR("dlb2: failed to get the device version, err=%d\n",
    4620                 :            :                              err);
    4621                 :          0 :                 return err;
    4622                 :            :         }
    4623                 :            : 
    4624                 :          0 :         err = dlb2_hw_query_resources(dlb2);
    4625         [ #  # ]:          0 :         if (err) {
    4626                 :          0 :                 DLB2_LOG_ERR("get resources err=%d for %s\n",
    4627                 :            :                              err, name);
    4628                 :          0 :                 return err;
    4629                 :            :         }
    4630                 :            : 
    4631                 :          0 :         dlb2_iface_hardware_init(&dlb2->qm_instance);
    4632                 :            : 
    4633                 :            :         /* configure class of service */
    4634                 :            :         {
    4635                 :            :                 struct dlb2_set_cos_bw_args
    4636                 :          0 :                         set_cos_bw_args = { {0} };
    4637                 :            :                 int id;
    4638                 :            :                 int ret = 0;
    4639                 :            : 
    4640         [ #  # ]:          0 :                 for (id = 0; id < DLB2_COS_NUM_VALS; id++) {
    4641                 :          0 :                         set_cos_bw_args.cos_id = id;
    4642                 :          0 :                         set_cos_bw_args.bandwidth = dlb2->cos_bw[id];
    4643                 :          0 :                         ret = dlb2_iface_set_cos_bw(&dlb2->qm_instance,
    4644                 :            :                                                     &set_cos_bw_args);
    4645         [ #  # ]:          0 :                         if (ret != 0)
    4646                 :            :                                 break;
    4647                 :            :                 }
    4648         [ #  # ]:          0 :                 if (ret) {
    4649                 :          0 :                         DLB2_LOG_ERR("dlb2: failed to configure class of service, err=%d\n",
    4650                 :            :                                      err);
    4651                 :          0 :                         return err;
    4652                 :            :                 }
    4653                 :            :         }
    4654                 :            : 
    4655                 :          0 :         err = dlb2_iface_get_cq_poll_mode(&dlb2->qm_instance, &dlb2->poll_mode);
    4656         [ #  # ]:          0 :         if (err < 0) {
    4657                 :          0 :                 DLB2_LOG_ERR("dlb2: failed to get the poll mode, err=%d\n",
    4658                 :            :                              err);
    4659                 :          0 :                 return err;
    4660                 :            :         }
    4661                 :            : 
    4662                 :            :         /* Complete xtstats runtime initialization */
    4663                 :          0 :         err = dlb2_xstats_init(dlb2);
    4664         [ #  # ]:          0 :         if (err) {
    4665                 :          0 :                 DLB2_LOG_ERR("dlb2: failed to init xstats, err=%d\n", err);
    4666                 :          0 :                 return err;
    4667                 :            :         }
    4668                 :            : 
    4669                 :            :         /* Initialize each port's token pop mode */
    4670   [ #  #  #  # ]:          0 :         for (i = 0; i < DLB2_MAX_NUM_PORTS(dlb2->version); i++)
    4671                 :          0 :                 dlb2->ev_ports[i].qm_port.token_pop_mode = AUTO_POP;
    4672                 :            : 
    4673                 :            :         rte_spinlock_init(&dlb2->qm_instance.resource_lock);
    4674                 :            : 
    4675                 :          0 :         dlb2_iface_low_level_io_init();
    4676                 :            : 
    4677                 :            :         dlb2_entry_points_init(dev);
    4678                 :            : 
    4679                 :            :         return 0;
    4680                 :            : }
    4681                 :            : 
    4682                 :            : int
    4683                 :          0 : dlb2_secondary_eventdev_probe(struct rte_eventdev *dev,
    4684                 :            :                               const char *name)
    4685                 :            : {
    4686                 :            :         struct dlb2_eventdev *dlb2;
    4687                 :            :         int err;
    4688                 :            : 
    4689                 :          0 :         dlb2 = dev->data->dev_private;
    4690                 :            : 
    4691                 :          0 :         evdev_dlb2_default_info.driver_name = name;
    4692                 :            : 
    4693                 :          0 :         err = dlb2_iface_open(&dlb2->qm_instance, name);
    4694         [ #  # ]:          0 :         if (err < 0) {
    4695                 :          0 :                 DLB2_LOG_ERR("could not open event hardware device, err=%d\n",
    4696                 :            :                              err);
    4697                 :          0 :                 return err;
    4698                 :            :         }
    4699                 :            : 
    4700                 :          0 :         err = dlb2_hw_query_resources(dlb2);
    4701         [ #  # ]:          0 :         if (err) {
    4702                 :          0 :                 DLB2_LOG_ERR("get resources err=%d for %s\n",
    4703                 :            :                              err, name);
    4704                 :          0 :                 return err;
    4705                 :            :         }
    4706                 :            : 
    4707                 :          0 :         dlb2_iface_low_level_io_init();
    4708                 :            : 
    4709                 :            :         dlb2_entry_points_init(dev);
    4710                 :            : 
    4711                 :            :         return 0;
    4712                 :            : }
    4713                 :            : 
    4714                 :            : int
    4715                 :          0 : dlb2_parse_params(const char *params,
    4716                 :            :                   const char *name,
    4717                 :            :                   struct dlb2_devargs *dlb2_args,
    4718                 :            :                   uint8_t version)
    4719                 :            : {
    4720                 :            :         int ret = 0;
    4721                 :            :         static const char * const args[] = { NUMA_NODE_ARG,
    4722                 :            :                                              DLB2_MAX_NUM_EVENTS,
    4723                 :            :                                              DLB2_NUM_DIR_CREDITS,
    4724                 :            :                                              DEV_ID_ARG,
    4725                 :            :                                              DLB2_QID_DEPTH_THRESH_ARG,
    4726                 :            :                                              DLB2_POLL_INTERVAL_ARG,
    4727                 :            :                                              DLB2_SW_CREDIT_QUANTA_ARG,
    4728                 :            :                                              DLB2_HW_CREDIT_QUANTA_ARG,
    4729                 :            :                                              DLB2_DEPTH_THRESH_ARG,
    4730                 :            :                                              DLB2_VECTOR_OPTS_ENAB_ARG,
    4731                 :            :                                              DLB2_MAX_CQ_DEPTH,
    4732                 :            :                                              DLB2_MAX_ENQ_DEPTH,
    4733                 :            :                                              DLB2_PORT_COS,
    4734                 :            :                                              DLB2_COS_BW,
    4735                 :            :                                              DLB2_PRODUCER_COREMASK,
    4736                 :            :                                              DLB2_DEFAULT_LDB_PORT_ALLOCATION_ARG,
    4737                 :            :                                              DLB2_ENABLE_CQ_WEIGHT_ARG,
    4738                 :            :                                              NULL };
    4739                 :            : 
    4740   [ #  #  #  # ]:          0 :         if (params != NULL && params[0] != '\0') {
    4741                 :          0 :                 struct rte_kvargs *kvlist = rte_kvargs_parse(params, args);
    4742                 :            : 
    4743         [ #  # ]:          0 :                 if (kvlist == NULL) {
    4744                 :          0 :                         RTE_LOG(INFO, PMD,
    4745                 :            :                                 "Ignoring unsupported parameters when creating device '%s'\n",
    4746                 :            :                                 name);
    4747                 :            :                 } else {
    4748                 :          0 :                         int ret = rte_kvargs_process(kvlist, NUMA_NODE_ARG,
    4749                 :            :                                                      set_numa_node,
    4750                 :          0 :                                                      &dlb2_args->socket_id);
    4751         [ #  # ]:          0 :                         if (ret != 0) {
    4752                 :          0 :                                 DLB2_LOG_ERR("%s: Error parsing numa node parameter",
    4753                 :            :                                              name);
    4754                 :          0 :                                 rte_kvargs_free(kvlist);
    4755                 :          0 :                                 return ret;
    4756                 :            :                         }
    4757                 :            : 
    4758                 :          0 :                         ret = rte_kvargs_process(kvlist, DLB2_MAX_NUM_EVENTS,
    4759                 :            :                                                  set_max_num_events,
    4760                 :          0 :                                                  &dlb2_args->max_num_events);
    4761         [ #  # ]:          0 :                         if (ret != 0) {
    4762                 :          0 :                                 DLB2_LOG_ERR("%s: Error parsing max_num_events parameter",
    4763                 :            :                                              name);
    4764                 :          0 :                                 rte_kvargs_free(kvlist);
    4765                 :          0 :                                 return ret;
    4766                 :            :                         }
    4767                 :            : 
    4768         [ #  # ]:          0 :                         if (version == DLB2_HW_V2) {
    4769                 :          0 :                                 ret = rte_kvargs_process(kvlist,
    4770                 :            :                                         DLB2_NUM_DIR_CREDITS,
    4771                 :            :                                         set_num_dir_credits,
    4772                 :          0 :                                         &dlb2_args->num_dir_credits_override);
    4773         [ #  # ]:          0 :                                 if (ret != 0) {
    4774                 :          0 :                                         DLB2_LOG_ERR("%s: Error parsing num_dir_credits parameter",
    4775                 :            :                                                      name);
    4776                 :          0 :                                         rte_kvargs_free(kvlist);
    4777                 :          0 :                                         return ret;
    4778                 :            :                                 }
    4779                 :            :                         }
    4780                 :          0 :                         ret = rte_kvargs_process(kvlist, DEV_ID_ARG,
    4781                 :            :                                                  set_dev_id,
    4782                 :          0 :                                                  &dlb2_args->dev_id);
    4783         [ #  # ]:          0 :                         if (ret != 0) {
    4784                 :          0 :                                 DLB2_LOG_ERR("%s: Error parsing dev_id parameter",
    4785                 :            :                                              name);
    4786                 :          0 :                                 rte_kvargs_free(kvlist);
    4787                 :          0 :                                 return ret;
    4788                 :            :                         }
    4789                 :            : 
    4790         [ #  # ]:          0 :                         if (version == DLB2_HW_V2) {
    4791                 :          0 :                                 ret = rte_kvargs_process(
    4792                 :            :                                         kvlist,
    4793                 :            :                                         DLB2_QID_DEPTH_THRESH_ARG,
    4794                 :            :                                         set_qid_depth_thresh,
    4795                 :          0 :                                         &dlb2_args->qid_depth_thresholds);
    4796                 :            :                         } else {
    4797                 :          0 :                                 ret = rte_kvargs_process(
    4798                 :            :                                         kvlist,
    4799                 :            :                                         DLB2_QID_DEPTH_THRESH_ARG,
    4800                 :            :                                         set_qid_depth_thresh_v2_5,
    4801                 :          0 :                                         &dlb2_args->qid_depth_thresholds);
    4802                 :            :                         }
    4803         [ #  # ]:          0 :                         if (ret != 0) {
    4804                 :          0 :                                 DLB2_LOG_ERR("%s: Error parsing qid_depth_thresh parameter",
    4805                 :            :                                              name);
    4806                 :          0 :                                 rte_kvargs_free(kvlist);
    4807                 :          0 :                                 return ret;
    4808                 :            :                         }
    4809                 :            : 
    4810                 :          0 :                         ret = rte_kvargs_process(kvlist, DLB2_POLL_INTERVAL_ARG,
    4811                 :            :                                                  set_poll_interval,
    4812                 :          0 :                                                  &dlb2_args->poll_interval);
    4813         [ #  # ]:          0 :                         if (ret != 0) {
    4814                 :          0 :                                 DLB2_LOG_ERR("%s: Error parsing poll interval parameter",
    4815                 :            :                                              name);
    4816                 :          0 :                                 rte_kvargs_free(kvlist);
    4817                 :          0 :                                 return ret;
    4818                 :            :                         }
    4819                 :            : 
    4820                 :          0 :                         ret = rte_kvargs_process(kvlist,
    4821                 :            :                                                  DLB2_SW_CREDIT_QUANTA_ARG,
    4822                 :            :                                                  set_sw_credit_quanta,
    4823                 :          0 :                                                  &dlb2_args->sw_credit_quanta);
    4824         [ #  # ]:          0 :                         if (ret != 0) {
    4825                 :          0 :                                 DLB2_LOG_ERR("%s: Error parsing sw credit quanta parameter",
    4826                 :            :                                              name);
    4827                 :          0 :                                 rte_kvargs_free(kvlist);
    4828                 :          0 :                                 return ret;
    4829                 :            :                         }
    4830                 :            : 
    4831                 :          0 :                         ret = rte_kvargs_process(kvlist,
    4832                 :            :                                                  DLB2_HW_CREDIT_QUANTA_ARG,
    4833                 :            :                                                  set_hw_credit_quanta,
    4834                 :          0 :                                                  &dlb2_args->hw_credit_quanta);
    4835         [ #  # ]:          0 :                         if (ret != 0) {
    4836                 :          0 :                                 DLB2_LOG_ERR("%s: Error parsing hw credit quanta parameter",
    4837                 :            :                                              name);
    4838                 :          0 :                                 rte_kvargs_free(kvlist);
    4839                 :          0 :                                 return ret;
    4840                 :            :                         }
    4841                 :            : 
    4842                 :          0 :                         ret = rte_kvargs_process(kvlist, DLB2_DEPTH_THRESH_ARG,
    4843                 :            :                                         set_default_depth_thresh,
    4844                 :          0 :                                         &dlb2_args->default_depth_thresh);
    4845         [ #  # ]:          0 :                         if (ret != 0) {
    4846                 :          0 :                                 DLB2_LOG_ERR("%s: Error parsing set depth thresh parameter",
    4847                 :            :                                              name);
    4848                 :          0 :                                 rte_kvargs_free(kvlist);
    4849                 :          0 :                                 return ret;
    4850                 :            :                         }
    4851                 :            : 
    4852                 :          0 :                         ret = rte_kvargs_process(kvlist,
    4853                 :            :                                         DLB2_VECTOR_OPTS_ENAB_ARG,
    4854                 :            :                                         set_vector_opts_enab,
    4855                 :          0 :                                         &dlb2_args->vector_opts_enabled);
    4856         [ #  # ]:          0 :                         if (ret != 0) {
    4857                 :          0 :                                 DLB2_LOG_ERR("%s: Error parsing vector opts enabled",
    4858                 :            :                                              name);
    4859                 :          0 :                                 rte_kvargs_free(kvlist);
    4860                 :          0 :                                 return ret;
    4861                 :            :                         }
    4862                 :            : 
    4863                 :          0 :                         ret = rte_kvargs_process(kvlist,
    4864                 :            :                                         DLB2_MAX_CQ_DEPTH,
    4865                 :            :                                         set_max_cq_depth,
    4866                 :          0 :                                         &dlb2_args->max_cq_depth);
    4867         [ #  # ]:          0 :                         if (ret != 0) {
    4868                 :          0 :                                 DLB2_LOG_ERR("%s: Error parsing max cq depth",
    4869                 :            :                                              name);
    4870                 :          0 :                                 rte_kvargs_free(kvlist);
    4871                 :          0 :                                 return ret;
    4872                 :            :                         }
    4873                 :            : 
    4874                 :          0 :                         ret = rte_kvargs_process(kvlist,
    4875                 :            :                                                  DLB2_MAX_ENQ_DEPTH,
    4876                 :            :                                                  set_max_enq_depth,
    4877                 :          0 :                                                  &dlb2_args->max_enq_depth);
    4878         [ #  # ]:          0 :                         if (ret != 0) {
    4879                 :          0 :                                 DLB2_LOG_ERR("%s: Error parsing vector opts enabled",
    4880                 :            :                                              name);
    4881                 :          0 :                                 rte_kvargs_free(kvlist);
    4882                 :          0 :                                 return ret;
    4883                 :            :                         }
    4884                 :            : 
    4885                 :          0 :                         ret = rte_kvargs_process(kvlist,
    4886                 :            :                                         DLB2_PORT_COS,
    4887                 :            :                                         set_port_cos,
    4888                 :          0 :                                         &dlb2_args->port_cos);
    4889         [ #  # ]:          0 :                         if (ret != 0) {
    4890                 :          0 :                                 DLB2_LOG_ERR("%s: Error parsing port cos",
    4891                 :            :                                              name);
    4892                 :          0 :                                 rte_kvargs_free(kvlist);
    4893                 :          0 :                                 return ret;
    4894                 :            :                         }
    4895                 :            : 
    4896                 :          0 :                         ret = rte_kvargs_process(kvlist,
    4897                 :            :                                         DLB2_COS_BW,
    4898                 :            :                                         set_cos_bw,
    4899                 :          0 :                                         &dlb2_args->cos_bw);
    4900         [ #  # ]:          0 :                         if (ret != 0) {
    4901                 :          0 :                                 DLB2_LOG_ERR("%s: Error parsing cos_bw",
    4902                 :            :                                              name);
    4903                 :          0 :                                 rte_kvargs_free(kvlist);
    4904                 :          0 :                                 return ret;
    4905                 :            :                         }
    4906                 :            : 
    4907                 :            : 
    4908                 :          0 :                         ret = rte_kvargs_process(kvlist,
    4909                 :            :                                                  DLB2_PRODUCER_COREMASK,
    4910                 :            :                                                  set_producer_coremask,
    4911                 :          0 :                                                  &dlb2_args->producer_coremask);
    4912         [ #  # ]:          0 :                         if (ret != 0) {
    4913                 :          0 :                                 DLB2_LOG_ERR(
    4914                 :            :                                         "%s: Error parsing producer coremask",
    4915                 :            :                                         name);
    4916                 :          0 :                                 rte_kvargs_free(kvlist);
    4917                 :          0 :                                 return ret;
    4918                 :            :                         }
    4919                 :            : 
    4920                 :          0 :                         ret = rte_kvargs_process(kvlist,
    4921                 :            :                                                  DLB2_DEFAULT_LDB_PORT_ALLOCATION_ARG,
    4922                 :            :                                                  set_default_ldb_port_allocation,
    4923                 :          0 :                                                  &dlb2_args->default_ldb_port_allocation);
    4924         [ #  # ]:          0 :                         if (ret != 0) {
    4925                 :          0 :                                 DLB2_LOG_ERR("%s: Error parsing ldb default port allocation arg",
    4926                 :            :                                              name);
    4927                 :          0 :                                 rte_kvargs_free(kvlist);
    4928                 :          0 :                                 return ret;
    4929                 :            :                         }
    4930                 :            : 
    4931                 :          0 :                         ret = rte_kvargs_process(kvlist,
    4932                 :            :                                                  DLB2_ENABLE_CQ_WEIGHT_ARG,
    4933                 :            :                                                  set_enable_cq_weight,
    4934                 :          0 :                                                  &dlb2_args->enable_cq_weight);
    4935         [ #  # ]:          0 :                         if (ret != 0) {
    4936                 :          0 :                                 DLB2_LOG_ERR("%s: Error parsing enable_cq_weight arg",
    4937                 :            :                                              name);
    4938                 :          0 :                                 rte_kvargs_free(kvlist);
    4939                 :          0 :                                 return ret;
    4940                 :            :                         }
    4941                 :            : 
    4942                 :          0 :                         rte_kvargs_free(kvlist);
    4943                 :            :                 }
    4944                 :            :         }
    4945                 :            :         return ret;
    4946                 :            : }
    4947         [ -  + ]:        235 : RTE_LOG_REGISTER_DEFAULT(eventdev_dlb2_log_level, NOTICE);

Generated by: LCOV version 1.14