drivers/event/cnxk/cnxk_eventdev_stats.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(C) 2021 Marvell.
   3  */
   4
   5 #include "cnxk_eventdev.h"
   6
   7 struct cnxk_sso_xstats_name {
   8         const char name[RTE_EVENT_DEV_XSTATS_NAME_SIZE];
   9         const size_t offset;
  10         const uint64_t mask;
  11         const uint8_t shift;
  12         uint64_t reset_snap[CNXK_SSO_MAX_HWGRP];
  13 };
  14
  15 static struct cnxk_sso_xstats_name sso_hws_xstats[] = {
  16         {
  17                 "last_grp_serviced",
  18                 offsetof(struct roc_sso_hws_stats, arbitration),
  19                 0x3FF,
  20                 0,
  21                 {0},
  22         },
  23         {
  24                 "affinity_arbitration_credits",
  25                 offsetof(struct roc_sso_hws_stats, arbitration),
  26                 0xF,
  27                 16,
  28                 {0},
  29         },
  30 };
  31
  32 static struct cnxk_sso_xstats_name sso_hwgrp_xstats[] = {
  33         {
  34                 "wrk_sched",
  35                 offsetof(struct roc_sso_hwgrp_stats, ws_pc),
  36                 ~0x0,
  37                 0,
  38                 {0},
  39         },
  40         {
  41                 "xaq_dram",
  42                 offsetof(struct roc_sso_hwgrp_stats, ext_pc),
  43                 ~0x0,
  44                 0,
  45                 {0},
  46         },
  47         {
  48                 "add_wrk",
  49                 offsetof(struct roc_sso_hwgrp_stats, wa_pc),
  50                 ~0x0,
  51                 0,
  52                 {0},
  53         },
  54         {
  55                 "tag_switch_req",
  56                 offsetof(struct roc_sso_hwgrp_stats, ts_pc),
  57                 ~0x0,
  58                 0,
  59                 {0},
  60         },
  61         {
  62                 "desched_req",
  63                 offsetof(struct roc_sso_hwgrp_stats, ds_pc),
  64                 ~0x0,
  65                 0,
  66                 {0},
  67         },
  68         {
  69                 "desched_wrk",
  70                 offsetof(struct roc_sso_hwgrp_stats, dq_pc),
  71                 ~0x0,
  72                 0,
  73                 {0},
  74         },
  75         {
  76                 "xaq_cached",
  77                 offsetof(struct roc_sso_hwgrp_stats, aw_status),
  78                 0x3,
  79                 0,
  80                 {0},
  81         },
  82         {
  83                 "work_inflight",
  84                 offsetof(struct roc_sso_hwgrp_stats, aw_status),
  85                 0x3F,
  86                 16,
  87                 {0},
  88         },
  89         {
  90                 "inuse_pages",
  91                 offsetof(struct roc_sso_hwgrp_stats, page_cnt),
  92                 0xFFFFFFFF,
  93                 0,
  94                 {0},
  95         },
  96 };
  97
  98 #define CNXK_SSO_NUM_HWS_XSTATS RTE_DIM(sso_hws_xstats)
  99 #define CNXK_SSO_NUM_GRP_XSTATS RTE_DIM(sso_hwgrp_xstats)
 100
 101 #define CNXK_SSO_NUM_XSTATS (CNXK_SSO_NUM_HWS_XSTATS + CNXK_SSO_NUM_GRP_XSTATS)
 102
 103 int
 104 cnxk_sso_xstats_get(const struct rte_eventdev *event_dev,
 105                     enum rte_event_dev_xstats_mode mode, uint8_t queue_port_id,
 106                     const unsigned int ids[], uint64_t values[], unsigned int n)
 107 {
 108         struct cnxk_sso_evdev *dev = cnxk_sso_pmd_priv(event_dev);
 109         struct roc_sso_hwgrp_stats hwgrp_stats;
 110         struct cnxk_sso_xstats_name *xstats;
 111         struct cnxk_sso_xstats_name *xstat;
 112         struct roc_sso_hws_stats hws_stats;
 113         uint32_t xstats_mode_count = 0;
 114         uint32_t start_offset = 0;
 115         unsigned int i;
 116         uint64_t value;
 117         void *rsp;
 118         int rc;
 119
 120         switch (mode) {
 121         case RTE_EVENT_DEV_XSTATS_DEVICE:
 122                 return 0;
 123         case RTE_EVENT_DEV_XSTATS_PORT:
 124                 if (queue_port_id >= (signed int)dev->nb_event_ports)
 125                         goto invalid_value;
 126
 127                 xstats_mode_count = CNXK_SSO_NUM_HWS_XSTATS;
 128                 xstats = sso_hws_xstats;
 129
 130                 rc = roc_sso_hws_stats_get(&dev->sso, queue_port_id,
 131                                            &hws_stats);
 132                 if (rc < 0)
 133                         goto invalid_value;
 134                 rsp = &hws_stats;
 135                 break;
 136         case RTE_EVENT_DEV_XSTATS_QUEUE:
 137                 if (queue_port_id >= (signed int)dev->nb_event_queues)
 138                         goto invalid_value;
 139
 140                 xstats_mode_count = CNXK_SSO_NUM_GRP_XSTATS;
 141                 start_offset = CNXK_SSO_NUM_HWS_XSTATS;
 142                 xstats = sso_hwgrp_xstats;
 143
 144                 rc = roc_sso_hwgrp_stats_get(&dev->sso, queue_port_id,
 145                                              &hwgrp_stats);
 146                 if (rc < 0)
 147                         goto invalid_value;
 148                 rsp = &hwgrp_stats;
 149
 150                 break;
 151         default:
 152                 plt_err("Invalid mode received");
 153                 goto invalid_value;
 154         };
 155
 156         for (i = 0; i < n && i < xstats_mode_count; i++) {
 157                 xstat = &xstats[ids[i] - start_offset];
 158                 value = *(uint64_t *)((char *)rsp + xstat->offset);
 159                 value = (value >> xstat->shift) & xstat->mask;
 160
 161                 values[i] = value;
 162                 values[i] -= xstat->reset_snap[queue_port_id];
 163         }
 164
 165         return i;
 166 invalid_value:
 167         return -EINVAL;
 168 }
 169
 170 int
 171 cnxk_sso_xstats_reset(struct rte_eventdev *event_dev,
 172                       enum rte_event_dev_xstats_mode mode,
 173                       int16_t queue_port_id, const uint32_t ids[], uint32_t n)
 174 {
 175         struct cnxk_sso_evdev *dev = cnxk_sso_pmd_priv(event_dev);
 176         struct roc_sso_hwgrp_stats hwgrp_stats;
 177         struct cnxk_sso_xstats_name *xstats;
 178         struct cnxk_sso_xstats_name *xstat;
 179         struct roc_sso_hws_stats hws_stats;
 180         uint32_t xstats_mode_count = 0;
 181         uint32_t start_offset = 0;
 182         unsigned int i;
 183         uint64_t value;
 184         void *rsp;
 185         int rc;
 186
 187         switch (mode) {
 188         case RTE_EVENT_DEV_XSTATS_DEVICE:
 189                 return 0;
 190         case RTE_EVENT_DEV_XSTATS_PORT:
 191                 if (queue_port_id >= (signed int)dev->nb_event_ports)
 192                         goto invalid_value;
 193
 194                 xstats_mode_count = CNXK_SSO_NUM_HWS_XSTATS;
 195                 xstats = sso_hws_xstats;
 196                 rc = roc_sso_hws_stats_get(&dev->sso, queue_port_id,
 197                                            &hws_stats);
 198                 if (rc < 0)
 199                         goto invalid_value;
 200                 rsp = &hws_stats;
 201                 break;
 202         case RTE_EVENT_DEV_XSTATS_QUEUE:
 203                 if (queue_port_id >= (signed int)dev->nb_event_queues)
 204                         goto invalid_value;
 205
 206                 xstats_mode_count = CNXK_SSO_NUM_GRP_XSTATS;
 207                 start_offset = CNXK_SSO_NUM_HWS_XSTATS;
 208                 xstats = sso_hwgrp_xstats;
 209
 210                 rc = roc_sso_hwgrp_stats_get(&dev->sso, queue_port_id,
 211                                              &hwgrp_stats);
 212                 if (rc < 0)
 213                         goto invalid_value;
 214                 rsp = &hwgrp_stats;
 215                 break;
 216         default:
 217                 plt_err("Invalid mode received");
 218                 goto invalid_value;
 219         };
 220
 221         for (i = 0; i < n && i < xstats_mode_count; i++) {
 222                 xstat = &xstats[ids[i] - start_offset];
 223                 value = *(uint64_t *)((char *)rsp + xstat->offset);
 224                 value = (value >> xstat->shift) & xstat->mask;
 225
 226                 xstat->reset_snap[queue_port_id] = value;
 227         }
 228         return i;
 229 invalid_value:
 230         return -EINVAL;
 231 }
 232
 233 int
 234 cnxk_sso_xstats_get_names(const struct rte_eventdev *event_dev,
 235                           enum rte_event_dev_xstats_mode mode,
 236                           uint8_t queue_port_id,
 237                           struct rte_event_dev_xstats_name *xstats_names,
 238                           unsigned int *ids, unsigned int size)
 239 {
 240         struct rte_event_dev_xstats_name xstats_names_copy[CNXK_SSO_NUM_XSTATS];
 241         struct cnxk_sso_evdev *dev = cnxk_sso_pmd_priv(event_dev);
 242         uint32_t xstats_mode_count = 0;
 243         uint32_t start_offset = 0;
 244         unsigned int xidx = 0;
 245         unsigned int i;
 246
 247         for (i = 0; i < CNXK_SSO_NUM_HWS_XSTATS; i++) {
 248                 snprintf(xstats_names_copy[i].name,
 249                          sizeof(xstats_names_copy[i].name), "%s",
 250                          sso_hws_xstats[i].name);
 251         }
 252
 253         for (; i < CNXK_SSO_NUM_XSTATS; i++) {
 254                 snprintf(xstats_names_copy[i].name,
 255                          sizeof(xstats_names_copy[i].name), "%s",
 256                          sso_hwgrp_xstats[i - CNXK_SSO_NUM_HWS_XSTATS].name);
 257         }
 258
 259         switch (mode) {
 260         case RTE_EVENT_DEV_XSTATS_DEVICE:
 261                 break;
 262         case RTE_EVENT_DEV_XSTATS_PORT:
 263                 if (queue_port_id >= (signed int)dev->nb_event_ports)
 264                         break;
 265                 xstats_mode_count = CNXK_SSO_NUM_HWS_XSTATS;
 266                 break;
 267         case RTE_EVENT_DEV_XSTATS_QUEUE:
 268                 if (queue_port_id >= (signed int)dev->nb_event_queues)
 269                         break;
 270                 xstats_mode_count = CNXK_SSO_NUM_GRP_XSTATS;
 271                 start_offset = CNXK_SSO_NUM_HWS_XSTATS;
 272                 break;
 273         default:
 274                 plt_err("Invalid mode received");
 275                 return -EINVAL;
 276         };
 277
 278         if (xstats_mode_count > size || !ids || !xstats_names)
 279                 return xstats_mode_count;
 280
 281         for (i = 0; i < xstats_mode_count; i++) {
 282                 xidx = i + start_offset;
 283                 strncpy(xstats_names[i].name, xstats_names_copy[xidx].name,
 284                         sizeof(xstats_names[i].name));
 285                 ids[i] = xidx;
 286         }
 287
 288         return i;
 289 }