drivers/net/bnxt/bnxt_stats.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2014-2018 Broadcom
   3  * All rights reserved.
   4  */
   5
   6 #include <inttypes.h>
   7
   8 #include <rte_byteorder.h>
   9
  10 #include "bnxt.h"
  11 #include "bnxt_cpr.h"
  12 #include "bnxt_hwrm.h"
  13 #include "bnxt_rxq.h"
  14 #include "bnxt_stats.h"
  15 #include "bnxt_txq.h"
  16 #include "hsi_struct_def_dpdk.h"
  17
  18 static const struct bnxt_xstats_name_off bnxt_rx_stats_strings[] = {
  19         {"rx_64b_frames", offsetof(struct rx_port_stats,
  20                                 rx_64b_frames)},
  21         {"rx_65b_127b_frames", offsetof(struct rx_port_stats,
  22                                 rx_65b_127b_frames)},
  23         {"rx_128b_255b_frames", offsetof(struct rx_port_stats,
  24                                 rx_128b_255b_frames)},
  25         {"rx_256b_511b_frames", offsetof(struct rx_port_stats,
  26                                 rx_256b_511b_frames)},
  27         {"rx_512b_1023b_frames", offsetof(struct rx_port_stats,
  28                                 rx_512b_1023b_frames)},
  29         {"rx_1024b_1518_frames", offsetof(struct rx_port_stats,
  30                                 rx_1024b_1518_frames)},
  31         {"rx_good_vlan_frames", offsetof(struct rx_port_stats,
  32                                 rx_good_vlan_frames)},
  33         {"rx_1519b_2047b_frames", offsetof(struct rx_port_stats,
  34                                 rx_1519b_2047b_frames)},
  35         {"rx_2048b_4095b_frames", offsetof(struct rx_port_stats,
  36                                 rx_2048b_4095b_frames)},
  37         {"rx_4096b_9216b_frames", offsetof(struct rx_port_stats,
  38                                 rx_4096b_9216b_frames)},
  39         {"rx_9217b_16383b_frames", offsetof(struct rx_port_stats,
  40                                 rx_9217b_16383b_frames)},
  41         {"rx_total_frames", offsetof(struct rx_port_stats,
  42                                 rx_total_frames)},
  43         {"rx_ucast_frames", offsetof(struct rx_port_stats,
  44                                 rx_ucast_frames)},
  45         {"rx_mcast_frames", offsetof(struct rx_port_stats,
  46                                 rx_mcast_frames)},
  47         {"rx_bcast_frames", offsetof(struct rx_port_stats,
  48                                 rx_bcast_frames)},
  49         {"rx_fcs_err_frames", offsetof(struct rx_port_stats,
  50                                 rx_fcs_err_frames)},
  51         {"rx_ctrl_frames", offsetof(struct rx_port_stats,
  52                                 rx_ctrl_frames)},
  53         {"rx_pause_frames", offsetof(struct rx_port_stats,
  54                                 rx_pause_frames)},
  55         {"rx_pfc_frames", offsetof(struct rx_port_stats,
  56                                 rx_pfc_frames)},
  57         {"rx_align_err_frames", offsetof(struct rx_port_stats,
  58                                 rx_align_err_frames)},
  59         {"rx_ovrsz_frames", offsetof(struct rx_port_stats,
  60                                 rx_ovrsz_frames)},
  61         {"rx_jbr_frames", offsetof(struct rx_port_stats,
  62                                 rx_jbr_frames)},
  63         {"rx_mtu_err_frames", offsetof(struct rx_port_stats,
  64                                 rx_mtu_err_frames)},
  65         {"rx_tagged_frames", offsetof(struct rx_port_stats,
  66                                 rx_tagged_frames)},
  67         {"rx_double_tagged_frames", offsetof(struct rx_port_stats,
  68                                 rx_double_tagged_frames)},
  69         {"rx_good_frames", offsetof(struct rx_port_stats,
  70                                 rx_good_frames)},
  71         {"rx_undrsz_frames", offsetof(struct rx_port_stats,
  72                                 rx_undrsz_frames)},
  73         {"rx_eee_lpi_events", offsetof(struct rx_port_stats,
  74                                 rx_eee_lpi_events)},
  75         {"rx_eee_lpi_duration", offsetof(struct rx_port_stats,
  76                                 rx_eee_lpi_duration)},
  77         {"rx_bytes", offsetof(struct rx_port_stats,
  78                                 rx_bytes)},
  79         {"rx_runt_bytes", offsetof(struct rx_port_stats,
  80                                 rx_runt_bytes)},
  81         {"rx_runt_frames", offsetof(struct rx_port_stats,
  82                                 rx_runt_frames)},
  83 };
  84
  85 static const struct bnxt_xstats_name_off bnxt_tx_stats_strings[] = {
  86         {"tx_64b_frames", offsetof(struct tx_port_stats,
  87                                 tx_64b_frames)},
  88         {"tx_65b_127b_frames", offsetof(struct tx_port_stats,
  89                                 tx_65b_127b_frames)},
  90         {"tx_128b_255b_frames", offsetof(struct tx_port_stats,
  91                                 tx_128b_255b_frames)},
  92         {"tx_256b_511b_frames", offsetof(struct tx_port_stats,
  93                                 tx_256b_511b_frames)},
  94         {"tx_512b_1023b_frames", offsetof(struct tx_port_stats,
  95                                 tx_512b_1023b_frames)},
  96         {"tx_1024b_1518_frames", offsetof(struct tx_port_stats,
  97                                 tx_1024b_1518_frames)},
  98         {"tx_good_vlan_frames", offsetof(struct tx_port_stats,
  99                                 tx_good_vlan_frames)},
 100         {"tx_1519b_2047_frames", offsetof(struct tx_port_stats,
 101                                 tx_1519b_2047_frames)},
 102         {"tx_2048b_4095b_frames", offsetof(struct tx_port_stats,
 103                                 tx_2048b_4095b_frames)},
 104         {"tx_4096b_9216b_frames", offsetof(struct tx_port_stats,
 105                                 tx_4096b_9216b_frames)},
 106         {"tx_9217b_16383b_frames", offsetof(struct tx_port_stats,
 107                                 tx_9217b_16383b_frames)},
 108         {"tx_good_frames", offsetof(struct tx_port_stats,
 109                                 tx_good_frames)},
 110         {"tx_total_frames", offsetof(struct tx_port_stats,
 111                                 tx_total_frames)},
 112         {"tx_ucast_frames", offsetof(struct tx_port_stats,
 113                                 tx_ucast_frames)},
 114         {"tx_mcast_frames", offsetof(struct tx_port_stats,
 115                                 tx_mcast_frames)},
 116         {"tx_bcast_frames", offsetof(struct tx_port_stats,
 117                                 tx_bcast_frames)},
 118         {"tx_pause_frames", offsetof(struct tx_port_stats,
 119                                 tx_pause_frames)},
 120         {"tx_pfc_frames", offsetof(struct tx_port_stats,
 121                                 tx_pfc_frames)},
 122         {"tx_jabber_frames", offsetof(struct tx_port_stats,
 123                                 tx_jabber_frames)},
 124         {"tx_fcs_err_frames", offsetof(struct tx_port_stats,
 125                                 tx_fcs_err_frames)},
 126         {"tx_err", offsetof(struct tx_port_stats,
 127                                 tx_err)},
 128         {"tx_fifo_underruns", offsetof(struct tx_port_stats,
 129                                 tx_fifo_underruns)},
 130         {"tx_eee_lpi_events", offsetof(struct tx_port_stats,
 131                                 tx_eee_lpi_events)},
 132         {"tx_eee_lpi_duration", offsetof(struct tx_port_stats,
 133                                 tx_eee_lpi_duration)},
 134         {"tx_total_collisions", offsetof(struct tx_port_stats,
 135                                 tx_total_collisions)},
 136         {"tx_bytes", offsetof(struct tx_port_stats,
 137                                 tx_bytes)},
 138 };
 139
 140 static const struct bnxt_xstats_name_off bnxt_func_stats_strings[] = {
 141         {"tx_ucast_pkts", offsetof(struct hwrm_func_qstats_output,
 142                                 tx_ucast_pkts)},
 143         {"tx_mcast_pkts", offsetof(struct hwrm_func_qstats_output,
 144                                 tx_mcast_pkts)},
 145         {"tx_bcast_pkts", offsetof(struct hwrm_func_qstats_output,
 146                                 tx_bcast_pkts)},
 147         {"tx_err_pkts", offsetof(struct hwrm_func_qstats_output,
 148                                 tx_err_pkts)},
 149         {"tx_drop_pkts", offsetof(struct hwrm_func_qstats_output,
 150                                 tx_drop_pkts)},
 151         {"tx_ucast_bytes", offsetof(struct hwrm_func_qstats_output,
 152                                 tx_ucast_bytes)},
 153         {"tx_mcast_bytes", offsetof(struct hwrm_func_qstats_output,
 154                                 tx_mcast_bytes)},
 155         {"tx_bcast_bytes", offsetof(struct hwrm_func_qstats_output,
 156                                 tx_bcast_bytes)},
 157         {"rx_ucast_pkts", offsetof(struct hwrm_func_qstats_output,
 158                                 rx_ucast_pkts)},
 159         {"rx_mcast_pkts", offsetof(struct hwrm_func_qstats_output,
 160                                 rx_mcast_pkts)},
 161         {"rx_bcast_pkts", offsetof(struct hwrm_func_qstats_output,
 162                                 rx_bcast_pkts)},
 163         {"rx_err_pkts", offsetof(struct hwrm_func_qstats_output,
 164                                 rx_err_pkts)},
 165         {"rx_drop_pkts", offsetof(struct hwrm_func_qstats_output,
 166                                 rx_drop_pkts)},
 167         {"rx_ucast_bytes", offsetof(struct hwrm_func_qstats_output,
 168                                 rx_ucast_bytes)},
 169         {"rx_mcast_bytes", offsetof(struct hwrm_func_qstats_output,
 170                                 rx_mcast_bytes)},
 171         {"rx_bcast_bytes", offsetof(struct hwrm_func_qstats_output,
 172                                 rx_bcast_bytes)},
 173         {"rx_agg_pkts", offsetof(struct hwrm_func_qstats_output,
 174                                 rx_agg_pkts)},
 175         {"rx_agg_bytes", offsetof(struct hwrm_func_qstats_output,
 176                                 rx_agg_bytes)},
 177         {"rx_agg_events", offsetof(struct hwrm_func_qstats_output,
 178                                 rx_agg_events)},
 179         {"rx_agg_aborts", offsetof(struct hwrm_func_qstats_output,
 180                                 rx_agg_aborts)},
 181 };
 182
 183 /*
 184  * Statistics functions
 185  */
 186
 187 void bnxt_free_stats(struct bnxt *bp)
 188 {
 189         int i;
 190
 191         for (i = 0; i < (int)bp->tx_cp_nr_rings; i++) {
 192                 struct bnxt_tx_queue *txq = bp->tx_queues[i];
 193
 194                 bnxt_free_txq_stats(txq);
 195         }
 196         for (i = 0; i < (int)bp->rx_cp_nr_rings; i++) {
 197                 struct bnxt_rx_queue *rxq = bp->rx_queues[i];
 198
 199                 bnxt_free_rxq_stats(rxq);
 200         }
 201 }
 202
 203 int bnxt_stats_get_op(struct rte_eth_dev *eth_dev,
 204                            struct rte_eth_stats *bnxt_stats)
 205 {
 206         int rc = 0;
 207         unsigned int i;
 208         struct bnxt *bp = eth_dev->data->dev_private;
 209
 210         memset(bnxt_stats, 0, sizeof(*bnxt_stats));
 211         if (!(bp->flags & BNXT_FLAG_INIT_DONE)) {
 212                 PMD_DRV_LOG(ERR, "Device Initialization not complete!\n");
 213                 return 0;
 214         }
 215
 216         for (i = 0; i < bp->rx_cp_nr_rings; i++) {
 217                 struct bnxt_rx_queue *rxq = bp->rx_queues[i];
 218                 struct bnxt_cp_ring_info *cpr = rxq->cp_ring;
 219
 220                 rc = bnxt_hwrm_ctx_qstats(bp, cpr->hw_stats_ctx_id, i,
 221                                      bnxt_stats, 1);
 222                 if (unlikely(rc))
 223                         return rc;
 224         }
 225
 226         for (i = 0; i < bp->tx_cp_nr_rings; i++) {
 227                 struct bnxt_tx_queue *txq = bp->tx_queues[i];
 228                 struct bnxt_cp_ring_info *cpr = txq->cp_ring;
 229
 230                 rc = bnxt_hwrm_ctx_qstats(bp, cpr->hw_stats_ctx_id, i,
 231                                      bnxt_stats, 0);
 232                 if (unlikely(rc))
 233                         return rc;
 234         }
 235         rc = bnxt_hwrm_func_qstats(bp, 0xffff, bnxt_stats);
 236         if (unlikely(rc))
 237                 return rc;
 238         bnxt_stats->rx_nombuf = rte_atomic64_read(&bp->rx_mbuf_alloc_fail);
 239         return rc;
 240 }
 241
 242 void bnxt_stats_reset_op(struct rte_eth_dev *eth_dev)
 243 {
 244         struct bnxt *bp = (struct bnxt *)eth_dev->data->dev_private;
 245
 246         if (!(bp->flags & BNXT_FLAG_INIT_DONE)) {
 247                 PMD_DRV_LOG(ERR, "Device Initialization not complete!\n");
 248                 return;
 249         }
 250
 251         bnxt_clear_all_hwrm_stat_ctxs(bp);
 252         rte_atomic64_clear(&bp->rx_mbuf_alloc_fail);
 253 }
 254
 255 int bnxt_dev_xstats_get_op(struct rte_eth_dev *eth_dev,
 256                            struct rte_eth_xstat *xstats, unsigned int n)
 257 {
 258         struct bnxt *bp = (struct bnxt *)eth_dev->data->dev_private;
 259
 260         unsigned int count, i;
 261         uint64_t tx_drop_pkts;
 262
 263         if (!(bp->flags & BNXT_FLAG_PORT_STATS)) {
 264                 PMD_DRV_LOG(ERR, "xstats not supported for VF\n");
 265                 return 0;
 266         }
 267
 268         bnxt_hwrm_port_qstats(bp);
 269         bnxt_hwrm_func_qstats_tx_drop(bp, 0xffff, &tx_drop_pkts);
 270
 271         count = RTE_DIM(bnxt_rx_stats_strings) +
 272                 RTE_DIM(bnxt_tx_stats_strings) + 1; /* For tx_drop_pkts */
 273
 274         if (n < count)
 275                 return count;
 276
 277         count = 0;
 278         for (i = 0; i < RTE_DIM(bnxt_rx_stats_strings); i++) {
 279                 uint64_t *rx_stats = (uint64_t *)bp->hw_rx_port_stats;
 280                 xstats[count].value = rte_le_to_cpu_64(
 281                                 *(uint64_t *)((char *)rx_stats +
 282                                 bnxt_rx_stats_strings[i].offset));
 283                 count++;
 284         }
 285
 286         for (i = 0; i < RTE_DIM(bnxt_tx_stats_strings); i++) {
 287                 uint64_t *tx_stats = (uint64_t *)bp->hw_tx_port_stats;
 288                 xstats[count].value = rte_le_to_cpu_64(
 289                                  *(uint64_t *)((char *)tx_stats +
 290                                 bnxt_tx_stats_strings[i].offset));
 291                 count++;
 292         }
 293
 294         /* The Tx drop pkts aka the Anti spoof coounter */
 295         xstats[count].value = rte_le_to_cpu_64(tx_drop_pkts);
 296         count++;
 297
 298         return count;
 299 }
 300
 301 int bnxt_dev_xstats_get_names_op(__rte_unused struct rte_eth_dev *eth_dev,
 302         struct rte_eth_xstat_name *xstats_names,
 303         __rte_unused unsigned int limit)
 304 {
 305         /* Account for the Tx drop pkts aka the Anti spoof counter */
 306         const unsigned int stat_cnt = RTE_DIM(bnxt_rx_stats_strings) +
 307                                 RTE_DIM(bnxt_tx_stats_strings) + 1;
 308         unsigned int i, count;
 309
 310         if (xstats_names != NULL) {
 311                 count = 0;
 312
 313                 for (i = 0; i < RTE_DIM(bnxt_rx_stats_strings); i++) {
 314                         snprintf(xstats_names[count].name,
 315                                 sizeof(xstats_names[count].name),
 316                                 "%s",
 317                                 bnxt_rx_stats_strings[i].name);
 318                         count++;
 319                 }
 320
 321                 for (i = 0; i < RTE_DIM(bnxt_tx_stats_strings); i++) {
 322                         snprintf(xstats_names[count].name,
 323                                 sizeof(xstats_names[count].name),
 324                                 "%s",
 325                                 bnxt_tx_stats_strings[i].name);
 326                         count++;
 327                 }
 328
 329                 snprintf(xstats_names[count].name,
 330                                 sizeof(xstats_names[count].name),
 331                                 "%s",
 332                                 bnxt_func_stats_strings[4].name);
 333                 count++;
 334         }
 335         return stat_cnt;
 336 }
 337
 338 void bnxt_dev_xstats_reset_op(struct rte_eth_dev *eth_dev)
 339 {
 340         struct bnxt *bp = (struct bnxt *)eth_dev->data->dev_private;
 341
 342         if (bp->flags & BNXT_FLAG_PORT_STATS && BNXT_SINGLE_PF(bp))
 343                 bnxt_hwrm_port_clr_stats(bp);
 344
 345         if (BNXT_VF(bp))
 346                 PMD_DRV_LOG(ERR, "Operation not supported on a VF device\n");
 347         if (!BNXT_SINGLE_PF(bp))
 348                 PMD_DRV_LOG(ERR, "Operation not supported on a MF device\n");
 349         if (!(bp->flags & BNXT_FLAG_PORT_STATS))
 350                 PMD_DRV_LOG(ERR, "Operation not supported\n");
 351 }
 352
 353 int bnxt_dev_xstats_get_by_id_op(struct rte_eth_dev *dev, const uint64_t *ids,
 354                 uint64_t *values, unsigned int limit)
 355 {
 356         /* Account for the Tx drop pkts aka the Anti spoof counter */
 357         const unsigned int stat_cnt = RTE_DIM(bnxt_rx_stats_strings) +
 358                                 RTE_DIM(bnxt_tx_stats_strings) + 1;
 359         struct rte_eth_xstat xstats[stat_cnt];
 360         uint64_t values_copy[stat_cnt];
 361         uint16_t i;
 362
 363         if (!ids)
 364                 return bnxt_dev_xstats_get_op(dev, xstats, stat_cnt);
 365
 366         bnxt_dev_xstats_get_by_id_op(dev, NULL, values_copy, stat_cnt);
 367         for (i = 0; i < limit; i++) {
 368                 if (ids[i] >= stat_cnt) {
 369                         PMD_DRV_LOG(ERR, "id value isn't valid");
 370                         return -1;
 371                 }
 372                 values[i] = values_copy[ids[i]];
 373         }
 374         return stat_cnt;
 375 }
 376
 377 int bnxt_dev_xstats_get_names_by_id_op(struct rte_eth_dev *dev,
 378                                 struct rte_eth_xstat_name *xstats_names,
 379                                 const uint64_t *ids, unsigned int limit)
 380 {
 381         /* Account for the Tx drop pkts aka the Anti spoof counter */
 382         const unsigned int stat_cnt = RTE_DIM(bnxt_rx_stats_strings) +
 383                                 RTE_DIM(bnxt_tx_stats_strings) + 1;
 384         struct rte_eth_xstat_name xstats_names_copy[stat_cnt];
 385         uint16_t i;
 386
 387         if (!ids)
 388                 return bnxt_dev_xstats_get_names_op(dev, xstats_names,
 389                                                     stat_cnt);
 390         bnxt_dev_xstats_get_names_by_id_op(dev, xstats_names_copy, NULL,
 391                         stat_cnt);
 392
 393         for (i = 0; i < limit; i++) {
 394                 if (ids[i] >= stat_cnt) {
 395                         PMD_DRV_LOG(ERR, "id value isn't valid");
 396                         return -1;
 397                 }
 398                 strcpy(xstats_names[i].name,
 399                                 xstats_names_copy[ids[i]].name);
 400         }
 401         return stat_cnt;
 402 }