drivers/net/hns3/hns3_stats.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2018-2019 Hisilicon Limited.
   3  */
   4
   5 #include <rte_ethdev.h>
   6 #include <rte_io.h>
   7 #include <rte_malloc.h>
   8
   9 #include "hns3_ethdev.h"
  10 #include "hns3_rxtx.h"
  11 #include "hns3_logs.h"
  12 #include "hns3_regs.h"
  13
  14 /* MAC statistics */
  15 static const struct hns3_xstats_name_offset hns3_mac_strings[] = {
  16         {"mac_tx_mac_pause_num",
  17                 HNS3_MAC_STATS_OFFSET(mac_tx_mac_pause_num)},
  18         {"mac_rx_mac_pause_num",
  19                 HNS3_MAC_STATS_OFFSET(mac_rx_mac_pause_num)},
  20         {"mac_tx_control_pkt_num",
  21                 HNS3_MAC_STATS_OFFSET(mac_tx_ctrl_pkt_num)},
  22         {"mac_rx_control_pkt_num",
  23                 HNS3_MAC_STATS_OFFSET(mac_rx_ctrl_pkt_num)},
  24         {"mac_tx_pfc_pkt_num",
  25                 HNS3_MAC_STATS_OFFSET(mac_tx_pfc_pause_pkt_num)},
  26         {"mac_tx_pfc_pri0_pkt_num",
  27                 HNS3_MAC_STATS_OFFSET(mac_tx_pfc_pri0_pkt_num)},
  28         {"mac_tx_pfc_pri1_pkt_num",
  29                 HNS3_MAC_STATS_OFFSET(mac_tx_pfc_pri1_pkt_num)},
  30         {"mac_tx_pfc_pri2_pkt_num",
  31                 HNS3_MAC_STATS_OFFSET(mac_tx_pfc_pri2_pkt_num)},
  32         {"mac_tx_pfc_pri3_pkt_num",
  33                 HNS3_MAC_STATS_OFFSET(mac_tx_pfc_pri3_pkt_num)},
  34         {"mac_tx_pfc_pri4_pkt_num",
  35                 HNS3_MAC_STATS_OFFSET(mac_tx_pfc_pri4_pkt_num)},
  36         {"mac_tx_pfc_pri5_pkt_num",
  37                 HNS3_MAC_STATS_OFFSET(mac_tx_pfc_pri5_pkt_num)},
  38         {"mac_tx_pfc_pri6_pkt_num",
  39                 HNS3_MAC_STATS_OFFSET(mac_tx_pfc_pri6_pkt_num)},
  40         {"mac_tx_pfc_pri7_pkt_num",
  41                 HNS3_MAC_STATS_OFFSET(mac_tx_pfc_pri7_pkt_num)},
  42         {"mac_rx_pfc_pkt_num",
  43                 HNS3_MAC_STATS_OFFSET(mac_rx_pfc_pause_pkt_num)},
  44         {"mac_rx_pfc_pri0_pkt_num",
  45                 HNS3_MAC_STATS_OFFSET(mac_rx_pfc_pri0_pkt_num)},
  46         {"mac_rx_pfc_pri1_pkt_num",
  47                 HNS3_MAC_STATS_OFFSET(mac_rx_pfc_pri1_pkt_num)},
  48         {"mac_rx_pfc_pri2_pkt_num",
  49                 HNS3_MAC_STATS_OFFSET(mac_rx_pfc_pri2_pkt_num)},
  50         {"mac_rx_pfc_pri3_pkt_num",
  51                 HNS3_MAC_STATS_OFFSET(mac_rx_pfc_pri3_pkt_num)},
  52         {"mac_rx_pfc_pri4_pkt_num",
  53                 HNS3_MAC_STATS_OFFSET(mac_rx_pfc_pri4_pkt_num)},
  54         {"mac_rx_pfc_pri5_pkt_num",
  55                 HNS3_MAC_STATS_OFFSET(mac_rx_pfc_pri5_pkt_num)},
  56         {"mac_rx_pfc_pri6_pkt_num",
  57                 HNS3_MAC_STATS_OFFSET(mac_rx_pfc_pri6_pkt_num)},
  58         {"mac_rx_pfc_pri7_pkt_num",
  59                 HNS3_MAC_STATS_OFFSET(mac_rx_pfc_pri7_pkt_num)},
  60         {"mac_tx_total_pkt_num",
  61                 HNS3_MAC_STATS_OFFSET(mac_tx_total_pkt_num)},
  62         {"mac_tx_total_oct_num",
  63                 HNS3_MAC_STATS_OFFSET(mac_tx_total_oct_num)},
  64         {"mac_tx_good_pkt_num",
  65                 HNS3_MAC_STATS_OFFSET(mac_tx_good_pkt_num)},
  66         {"mac_tx_bad_pkt_num",
  67                 HNS3_MAC_STATS_OFFSET(mac_tx_bad_pkt_num)},
  68         {"mac_tx_good_oct_num",
  69                 HNS3_MAC_STATS_OFFSET(mac_tx_good_oct_num)},
  70         {"mac_tx_bad_oct_num",
  71                 HNS3_MAC_STATS_OFFSET(mac_tx_bad_oct_num)},
  72         {"mac_tx_uni_pkt_num",
  73                 HNS3_MAC_STATS_OFFSET(mac_tx_uni_pkt_num)},
  74         {"mac_tx_multi_pkt_num",
  75                 HNS3_MAC_STATS_OFFSET(mac_tx_multi_pkt_num)},
  76         {"mac_tx_broad_pkt_num",
  77                 HNS3_MAC_STATS_OFFSET(mac_tx_broad_pkt_num)},
  78         {"mac_tx_undersize_pkt_num",
  79                 HNS3_MAC_STATS_OFFSET(mac_tx_undersize_pkt_num)},
  80         {"mac_tx_oversize_pkt_num",
  81                 HNS3_MAC_STATS_OFFSET(mac_tx_oversize_pkt_num)},
  82         {"mac_tx_64_oct_pkt_num",
  83                 HNS3_MAC_STATS_OFFSET(mac_tx_64_oct_pkt_num)},
  84         {"mac_tx_65_127_oct_pkt_num",
  85                 HNS3_MAC_STATS_OFFSET(mac_tx_65_127_oct_pkt_num)},
  86         {"mac_tx_128_255_oct_pkt_num",
  87                 HNS3_MAC_STATS_OFFSET(mac_tx_128_255_oct_pkt_num)},
  88         {"mac_tx_256_511_oct_pkt_num",
  89                 HNS3_MAC_STATS_OFFSET(mac_tx_256_511_oct_pkt_num)},
  90         {"mac_tx_512_1023_oct_pkt_num",
  91                 HNS3_MAC_STATS_OFFSET(mac_tx_512_1023_oct_pkt_num)},
  92         {"mac_tx_1024_1518_oct_pkt_num",
  93                 HNS3_MAC_STATS_OFFSET(mac_tx_1024_1518_oct_pkt_num)},
  94         {"mac_tx_1519_2047_oct_pkt_num",
  95                 HNS3_MAC_STATS_OFFSET(mac_tx_1519_2047_oct_pkt_num)},
  96         {"mac_tx_2048_4095_oct_pkt_num",
  97                 HNS3_MAC_STATS_OFFSET(mac_tx_2048_4095_oct_pkt_num)},
  98         {"mac_tx_4096_8191_oct_pkt_num",
  99                 HNS3_MAC_STATS_OFFSET(mac_tx_4096_8191_oct_pkt_num)},
 100         {"mac_tx_8192_9216_oct_pkt_num",
 101                 HNS3_MAC_STATS_OFFSET(mac_tx_8192_9216_oct_pkt_num)},
 102         {"mac_tx_9217_12287_oct_pkt_num",
 103                 HNS3_MAC_STATS_OFFSET(mac_tx_9217_12287_oct_pkt_num)},
 104         {"mac_tx_12288_16383_oct_pkt_num",
 105                 HNS3_MAC_STATS_OFFSET(mac_tx_12288_16383_oct_pkt_num)},
 106         {"mac_tx_1519_max_good_pkt_num",
 107                 HNS3_MAC_STATS_OFFSET(mac_tx_1519_max_good_oct_pkt_num)},
 108         {"mac_tx_1519_max_bad_pkt_num",
 109                 HNS3_MAC_STATS_OFFSET(mac_tx_1519_max_bad_oct_pkt_num)},
 110         {"mac_rx_total_pkt_num",
 111                 HNS3_MAC_STATS_OFFSET(mac_rx_total_pkt_num)},
 112         {"mac_rx_total_oct_num",
 113                 HNS3_MAC_STATS_OFFSET(mac_rx_total_oct_num)},
 114         {"mac_rx_good_pkt_num",
 115                 HNS3_MAC_STATS_OFFSET(mac_rx_good_pkt_num)},
 116         {"mac_rx_bad_pkt_num",
 117                 HNS3_MAC_STATS_OFFSET(mac_rx_bad_pkt_num)},
 118         {"mac_rx_good_oct_num",
 119                 HNS3_MAC_STATS_OFFSET(mac_rx_good_oct_num)},
 120         {"mac_rx_bad_oct_num",
 121                 HNS3_MAC_STATS_OFFSET(mac_rx_bad_oct_num)},
 122         {"mac_rx_uni_pkt_num",
 123                 HNS3_MAC_STATS_OFFSET(mac_rx_uni_pkt_num)},
 124         {"mac_rx_multi_pkt_num",
 125                 HNS3_MAC_STATS_OFFSET(mac_rx_multi_pkt_num)},
 126         {"mac_rx_broad_pkt_num",
 127                 HNS3_MAC_STATS_OFFSET(mac_rx_broad_pkt_num)},
 128         {"mac_rx_undersize_pkt_num",
 129                 HNS3_MAC_STATS_OFFSET(mac_rx_undersize_pkt_num)},
 130         {"mac_rx_oversize_pkt_num",
 131                 HNS3_MAC_STATS_OFFSET(mac_rx_oversize_pkt_num)},
 132         {"mac_rx_64_oct_pkt_num",
 133                 HNS3_MAC_STATS_OFFSET(mac_rx_64_oct_pkt_num)},
 134         {"mac_rx_65_127_oct_pkt_num",
 135                 HNS3_MAC_STATS_OFFSET(mac_rx_65_127_oct_pkt_num)},
 136         {"mac_rx_128_255_oct_pkt_num",
 137                 HNS3_MAC_STATS_OFFSET(mac_rx_128_255_oct_pkt_num)},
 138         {"mac_rx_256_511_oct_pkt_num",
 139                 HNS3_MAC_STATS_OFFSET(mac_rx_256_511_oct_pkt_num)},
 140         {"mac_rx_512_1023_oct_pkt_num",
 141                 HNS3_MAC_STATS_OFFSET(mac_rx_512_1023_oct_pkt_num)},
 142         {"mac_rx_1024_1518_oct_pkt_num",
 143                 HNS3_MAC_STATS_OFFSET(mac_rx_1024_1518_oct_pkt_num)},
 144         {"mac_rx_1519_2047_oct_pkt_num",
 145                 HNS3_MAC_STATS_OFFSET(mac_rx_1519_2047_oct_pkt_num)},
 146         {"mac_rx_2048_4095_oct_pkt_num",
 147                 HNS3_MAC_STATS_OFFSET(mac_rx_2048_4095_oct_pkt_num)},
 148         {"mac_rx_4096_8191_oct_pkt_num",
 149                 HNS3_MAC_STATS_OFFSET(mac_rx_4096_8191_oct_pkt_num)},
 150         {"mac_rx_8192_9216_oct_pkt_num",
 151                 HNS3_MAC_STATS_OFFSET(mac_rx_8192_9216_oct_pkt_num)},
 152         {"mac_rx_9217_12287_oct_pkt_num",
 153                 HNS3_MAC_STATS_OFFSET(mac_rx_9217_12287_oct_pkt_num)},
 154         {"mac_rx_12288_16383_oct_pkt_num",
 155                 HNS3_MAC_STATS_OFFSET(mac_rx_12288_16383_oct_pkt_num)},
 156         {"mac_rx_1519_max_good_pkt_num",
 157                 HNS3_MAC_STATS_OFFSET(mac_rx_1519_max_good_oct_pkt_num)},
 158         {"mac_rx_1519_max_bad_pkt_num",
 159                 HNS3_MAC_STATS_OFFSET(mac_rx_1519_max_bad_oct_pkt_num)},
 160         {"mac_tx_fragment_pkt_num",
 161                 HNS3_MAC_STATS_OFFSET(mac_tx_fragment_pkt_num)},
 162         {"mac_tx_undermin_pkt_num",
 163                 HNS3_MAC_STATS_OFFSET(mac_tx_undermin_pkt_num)},
 164         {"mac_tx_jabber_pkt_num",
 165                 HNS3_MAC_STATS_OFFSET(mac_tx_jabber_pkt_num)},
 166         {"mac_tx_err_all_pkt_num",
 167                 HNS3_MAC_STATS_OFFSET(mac_tx_err_all_pkt_num)},
 168         {"mac_tx_from_app_good_pkt_num",
 169                 HNS3_MAC_STATS_OFFSET(mac_tx_from_app_good_pkt_num)},
 170         {"mac_tx_from_app_bad_pkt_num",
 171                 HNS3_MAC_STATS_OFFSET(mac_tx_from_app_bad_pkt_num)},
 172         {"mac_rx_fragment_pkt_num",
 173                 HNS3_MAC_STATS_OFFSET(mac_rx_fragment_pkt_num)},
 174         {"mac_rx_undermin_pkt_num",
 175                 HNS3_MAC_STATS_OFFSET(mac_rx_undermin_pkt_num)},
 176         {"mac_rx_jabber_pkt_num",
 177                 HNS3_MAC_STATS_OFFSET(mac_rx_jabber_pkt_num)},
 178         {"mac_rx_fcs_err_pkt_num",
 179                 HNS3_MAC_STATS_OFFSET(mac_rx_fcs_err_pkt_num)},
 180         {"mac_rx_send_app_good_pkt_num",
 181                 HNS3_MAC_STATS_OFFSET(mac_rx_send_app_good_pkt_num)},
 182         {"mac_rx_send_app_bad_pkt_num",
 183                 HNS3_MAC_STATS_OFFSET(mac_rx_send_app_bad_pkt_num)}
 184 };
 185
 186 static const struct hns3_xstats_name_offset hns3_error_int_stats_strings[] = {
 187         {"MAC_AFIFO_TNL_INT_R",
 188                 HNS3_ERR_INT_STATS_FIELD_OFFSET(mac_afifo_tnl_int_cnt)},
 189         {"PPU_MPF_ABNORMAL_INT_ST2_MSIX",
 190                 HNS3_ERR_INT_STATS_FIELD_OFFSET(ppu_mpf_abn_int_st2_msix_cnt)},
 191         {"SSU_PORT_BASED_ERR_INT_MSIX",
 192                 HNS3_ERR_INT_STATS_FIELD_OFFSET(ssu_port_based_pf_int_cnt)},
 193         {"PPP_PF_ABNORMAL_INT_ST0",
 194                 HNS3_ERR_INT_STATS_FIELD_OFFSET(ppp_pf_abnormal_int_cnt)},
 195         {"PPU_PF_ABNORMAL_INT_ST_MSIX",
 196                 HNS3_ERR_INT_STATS_FIELD_OFFSET(ppu_pf_abnormal_int_msix_cnt)},
 197         {"IMP_TCM_ECC_INT_STS",
 198                 HNS3_ERR_INT_STATS_FIELD_OFFSET(imp_tcm_ecc_int_cnt)},
 199         {"CMDQ_MEM_ECC_INT_STS",
 200                 HNS3_ERR_INT_STATS_FIELD_OFFSET(cmdq_mem_ecc_int_cnt)},
 201         {"IMP_RD_POISON_INT_STS",
 202                 HNS3_ERR_INT_STATS_FIELD_OFFSET(imp_rd_poison_int_cnt)},
 203         {"TQP_INT_ECC_INT_STS",
 204                 HNS3_ERR_INT_STATS_FIELD_OFFSET(tqp_int_ecc_int_cnt)},
 205         {"MSIX_ECC_INT_STS",
 206                 HNS3_ERR_INT_STATS_FIELD_OFFSET(msix_ecc_int_cnt)},
 207         {"SSU_ECC_MULTI_BIT_INT_0",
 208                 HNS3_ERR_INT_STATS_FIELD_OFFSET(ssu_ecc_multi_bit_int_0_cnt)},
 209         {"SSU_ECC_MULTI_BIT_INT_1",
 210                 HNS3_ERR_INT_STATS_FIELD_OFFSET(ssu_ecc_multi_bit_int_1_cnt)},
 211         {"SSU_COMMON_ERR_INT",
 212                 HNS3_ERR_INT_STATS_FIELD_OFFSET(ssu_common_ecc_int_cnt)},
 213         {"IGU_INT_STS",
 214                 HNS3_ERR_INT_STATS_FIELD_OFFSET(igu_int_cnt)},
 215         {"PPP_MPF_ABNORMAL_INT_ST1",
 216                 HNS3_ERR_INT_STATS_FIELD_OFFSET(ppp_mpf_abnormal_int_st1_cnt)},
 217         {"PPP_MPF_ABNORMAL_INT_ST3",
 218                 HNS3_ERR_INT_STATS_FIELD_OFFSET(ppp_mpf_abnormal_int_st3_cnt)},
 219         {"PPU_MPF_ABNORMAL_INT_ST1",
 220                 HNS3_ERR_INT_STATS_FIELD_OFFSET(ppu_mpf_abnormal_int_st1_cnt)},
 221         {"PPU_MPF_ABNORMAL_INT_ST2_RAS",
 222                 HNS3_ERR_INT_STATS_FIELD_OFFSET(ppu_mpf_abn_int_st2_ras_cnt)},
 223         {"PPU_MPF_ABNORMAL_INT_ST3",
 224                 HNS3_ERR_INT_STATS_FIELD_OFFSET(ppu_mpf_abnormal_int_st3_cnt)},
 225         {"TM_SCH_RINT",
 226                 HNS3_ERR_INT_STATS_FIELD_OFFSET(tm_sch_int_cnt)},
 227         {"QCN_FIFO_RINT",
 228                 HNS3_ERR_INT_STATS_FIELD_OFFSET(qcn_fifo_int_cnt)},
 229         {"QCN_ECC_RINT",
 230                 HNS3_ERR_INT_STATS_FIELD_OFFSET(qcn_ecc_int_cnt)},
 231         {"NCSI_ECC_INT_RPT",
 232                 HNS3_ERR_INT_STATS_FIELD_OFFSET(ncsi_ecc_int_cnt)},
 233         {"SSU_PORT_BASED_ERR_INT_RAS",
 234                 HNS3_ERR_INT_STATS_FIELD_OFFSET(ssu_port_based_err_int_cnt)},
 235         {"SSU_FIFO_OVERFLOW_INT",
 236                 HNS3_ERR_INT_STATS_FIELD_OFFSET(ssu_fifo_overflow_int_cnt)},
 237         {"SSU_ETS_TCG_INT",
 238                 HNS3_ERR_INT_STATS_FIELD_OFFSET(ssu_ets_tcg_int_cnt)},
 239         {"IGU_EGU_TNL_INT_STS",
 240                 HNS3_ERR_INT_STATS_FIELD_OFFSET(igu_egu_tnl_int_cnt)},
 241         {"PPU_PF_ABNORMAL_INT_ST_RAS",
 242                 HNS3_ERR_INT_STATS_FIELD_OFFSET(ppu_pf_abnormal_int_ras_cnt)},
 243 };
 244
 245 /* The statistic of reset */
 246 static const struct hns3_xstats_name_offset hns3_reset_stats_strings[] = {
 247         {"REQ_RESET_CNT",
 248                 HNS3_RESET_STATS_FIELD_OFFSET(request_cnt)},
 249         {"GLOBAL_RESET_CNT",
 250                 HNS3_RESET_STATS_FIELD_OFFSET(global_cnt)},
 251         {"IMP_RESET_CNT",
 252                 HNS3_RESET_STATS_FIELD_OFFSET(imp_cnt)},
 253         {"RESET_EXEC_CNT",
 254                 HNS3_RESET_STATS_FIELD_OFFSET(exec_cnt)},
 255         {"RESET_SUCCESS_CNT",
 256                 HNS3_RESET_STATS_FIELD_OFFSET(success_cnt)},
 257         {"RESET_FAIL_CNT",
 258                 HNS3_RESET_STATS_FIELD_OFFSET(fail_cnt)},
 259         {"RESET_MERGE_CNT",
 260                 HNS3_RESET_STATS_FIELD_OFFSET(merge_cnt)}
 261 };
 262
 263 /* The statistic of errors in Rx BD */
 264 static const struct hns3_xstats_name_offset hns3_rx_bd_error_strings[] = {
 265         {"PKT_LEN_ERRORS",
 266                 HNS3_RX_BD_ERROR_STATS_FIELD_OFFSET(pkt_len_errors)},
 267         {"L2_ERRORS",
 268                 HNS3_RX_BD_ERROR_STATS_FIELD_OFFSET(l2_errors)}
 269 };
 270
 271 /* The dfx statistic in Rx datapath */
 272 static const struct hns3_xstats_name_offset hns3_rxq_dfx_stats_strings[] = {
 273         {"L3_CHECKSUM_ERRORS",
 274                 HNS3_RXQ_DFX_STATS_FIELD_OFFSET(l3_csum_errors)},
 275         {"L4_CHECKSUM_ERRORS",
 276                 HNS3_RXQ_DFX_STATS_FIELD_OFFSET(l4_csum_errors)},
 277         {"OL3_CHECKSUM_ERRORS",
 278                 HNS3_RXQ_DFX_STATS_FIELD_OFFSET(ol3_csum_errors)},
 279         {"OL4_CHECKSUM_ERRORS",
 280                 HNS3_RXQ_DFX_STATS_FIELD_OFFSET(ol4_csum_errors)}
 281 };
 282
 283 /* The dfx statistic in Tx datapath */
 284 static const struct hns3_xstats_name_offset hns3_txq_dfx_stats_strings[] = {
 285         {"OVER_LENGTH_PKT_CNT",
 286                 HNS3_TXQ_DFX_STATS_FIELD_OFFSET(over_length_pkt_cnt)},
 287         {"EXCEED_LIMITED_BD_PKT_CNT",
 288                 HNS3_TXQ_DFX_STATS_FIELD_OFFSET(exceed_limit_bd_pkt_cnt)},
 289         {"EXCEED_LIMITED_BD_PKT_REASSEMBLE_FAIL_CNT",
 290                 HNS3_TXQ_DFX_STATS_FIELD_OFFSET(exceed_limit_bd_reassem_fail)},
 291         {"UNSUPPORTED_TUNNEL_PKT_CNT",
 292                 HNS3_TXQ_DFX_STATS_FIELD_OFFSET(unsupported_tunnel_pkt_cnt)},
 293         {"QUEUE_FULL_CNT",
 294                 HNS3_TXQ_DFX_STATS_FIELD_OFFSET(queue_full_cnt)},
 295         {"SHORT_PKT_PAD_FAIL_CNT",
 296                 HNS3_TXQ_DFX_STATS_FIELD_OFFSET(pkt_padding_fail_cnt)}
 297 };
 298
 299 /* The statistic of rx queue */
 300 static const struct hns3_xstats_name_offset hns3_rx_queue_strings[] = {
 301         {"RX_QUEUE_FBD", HNS3_RING_RX_FBDNUM_REG}
 302 };
 303
 304 /* The statistic of tx queue */
 305 static const struct hns3_xstats_name_offset hns3_tx_queue_strings[] = {
 306         {"TX_QUEUE_FBD", HNS3_RING_TX_FBDNUM_REG}
 307 };
 308
 309 #define HNS3_NUM_MAC_STATS (sizeof(hns3_mac_strings) / \
 310         sizeof(hns3_mac_strings[0]))
 311
 312 #define HNS3_NUM_ERROR_INT_XSTATS (sizeof(hns3_error_int_stats_strings) / \
 313         sizeof(hns3_error_int_stats_strings[0]))
 314
 315 #define HNS3_NUM_RESET_XSTATS (sizeof(hns3_reset_stats_strings) / \
 316         sizeof(hns3_reset_stats_strings[0]))
 317
 318 #define HNS3_NUM_RX_BD_ERROR_XSTATS (sizeof(hns3_rx_bd_error_strings) / \
 319         sizeof(hns3_rx_bd_error_strings[0]))
 320
 321 #define HNS3_NUM_RXQ_DFX_XSTATS (sizeof(hns3_rxq_dfx_stats_strings) / \
 322         sizeof(hns3_rxq_dfx_stats_strings[0]))
 323
 324 #define HNS3_NUM_TXQ_DFX_XSTATS (sizeof(hns3_txq_dfx_stats_strings) / \
 325         sizeof(hns3_txq_dfx_stats_strings[0]))
 326
 327 #define HNS3_NUM_RX_QUEUE_STATS (sizeof(hns3_rx_queue_strings) / \
 328         sizeof(hns3_rx_queue_strings[0]))
 329
 330 #define HNS3_NUM_TX_QUEUE_STATS (sizeof(hns3_tx_queue_strings) / \
 331         sizeof(hns3_tx_queue_strings[0]))
 332
 333 #define HNS3_FIX_NUM_STATS (HNS3_NUM_MAC_STATS + HNS3_NUM_ERROR_INT_XSTATS + \
 334                             HNS3_NUM_RESET_XSTATS)
 335
 336 static void hns3_tqp_stats_clear(struct hns3_hw *hw);
 337
 338 /*
 339  * Query all the MAC statistics data of Network ICL command ,opcode id: 0x0034.
 340  * This command is used before send 'query_mac_stat command', the descriptor
 341  * number of 'query_mac_stat command' must match with reg_num in this command.
 342  * @praram hw
 343  *   Pointer to structure hns3_hw.
 344  * @return
 345  *   0 on success.
 346  */
 347 static int
 348 hns3_update_mac_stats(struct hns3_hw *hw, const uint32_t desc_num)
 349 {
 350         uint64_t *data = (uint64_t *)(&hw->mac_stats);
 351         struct hns3_cmd_desc *desc;
 352         uint64_t *desc_data;
 353         uint16_t i, k, n;
 354         int ret;
 355
 356         desc = rte_malloc("hns3_mac_desc",
 357                           desc_num * sizeof(struct hns3_cmd_desc), 0);
 358         if (desc == NULL) {
 359                 hns3_err(hw, "Mac_update_stats alloced desc malloc fail");
 360                 return -ENOMEM;
 361         }
 362
 363         hns3_cmd_setup_basic_desc(desc, HNS3_OPC_STATS_MAC_ALL, true);
 364         ret = hns3_cmd_send(hw, desc, desc_num);
 365         if (ret) {
 366                 hns3_err(hw, "Update complete MAC pkt stats fail : %d", ret);
 367                 rte_free(desc);
 368                 return ret;
 369         }
 370
 371         for (i = 0; i < desc_num; i++) {
 372                 /* For special opcode 0034, only the first desc has the head */
 373                 if (i == 0) {
 374                         desc_data = (uint64_t *)(&desc[i].data[0]);
 375                         n = HNS3_RD_FIRST_STATS_NUM;
 376                 } else {
 377                         desc_data = (uint64_t *)(&desc[i]);
 378                         n = HNS3_RD_OTHER_STATS_NUM;
 379                 }
 380
 381                 for (k = 0; k < n; k++) {
 382                         *data += rte_le_to_cpu_64(*desc_data);
 383                         data++;
 384                         desc_data++;
 385                 }
 386         }
 387         rte_free(desc);
 388
 389         return 0;
 390 }
 391
 392 /*
 393  * Query Mac stat reg num command ,opcode id: 0x0033.
 394  * This command is used before send 'query_mac_stat command', the descriptor
 395  * number of 'query_mac_stat command' must match with reg_num in this command.
 396  * @praram rte_stats
 397  *   Pointer to structure rte_eth_stats.
 398  * @return
 399  *   0 on success.
 400  */
 401 static int
 402 hns3_mac_query_reg_num(struct rte_eth_dev *dev, uint32_t *desc_num)
 403 {
 404         struct hns3_adapter *hns = dev->data->dev_private;
 405         struct hns3_hw *hw = &hns->hw;
 406         struct hns3_cmd_desc desc;
 407         uint32_t *desc_data;
 408         uint32_t reg_num;
 409         int ret;
 410
 411         hns3_cmd_setup_basic_desc(&desc, HNS3_OPC_QUERY_MAC_REG_NUM, true);
 412         ret = hns3_cmd_send(hw, &desc, 1);
 413         if (ret)
 414                 return ret;
 415
 416         /*
 417          * The num of MAC statistics registers that are provided by IMP in this
 418          * version.
 419          */
 420         desc_data = (uint32_t *)(&desc.data[0]);
 421         reg_num = rte_le_to_cpu_32(*desc_data);
 422
 423         /*
 424          * The descriptor number of 'query_additional_mac_stat command' is
 425          * '1 + (reg_num-3)/4 + ((reg_num-3)%4 !=0)';
 426          * This value is 83 in this version
 427          */
 428         *desc_num = 1 + ((reg_num - 3) >> 2) +
 429                     (uint32_t)(((reg_num - 3) & 0x3) ? 1 : 0);
 430
 431         return 0;
 432 }
 433
 434 static int
 435 hns3_query_update_mac_stats(struct rte_eth_dev *dev)
 436 {
 437         struct hns3_adapter *hns = dev->data->dev_private;
 438         struct hns3_hw *hw = &hns->hw;
 439         uint32_t desc_num;
 440         int ret;
 441
 442         ret = hns3_mac_query_reg_num(dev, &desc_num);
 443         if (ret == 0)
 444                 ret = hns3_update_mac_stats(hw, desc_num);
 445         else
 446                 hns3_err(hw, "Query mac reg num fail : %d", ret);
 447         return ret;
 448 }
 449
 450 /* Get tqp stats from register */
 451 static int
 452 hns3_update_tqp_stats(struct hns3_hw *hw)
 453 {
 454         struct hns3_tqp_stats *stats = &hw->tqp_stats;
 455         struct hns3_cmd_desc desc;
 456         uint64_t cnt;
 457         uint16_t i;
 458         int ret;
 459
 460         for (i = 0; i < hw->tqps_num; i++) {
 461                 hns3_cmd_setup_basic_desc(&desc, HNS3_OPC_QUERY_RX_STATUS,
 462                                           true);
 463
 464                 desc.data[0] = rte_cpu_to_le_32((uint32_t)i);
 465                 ret = hns3_cmd_send(hw, &desc, 1);
 466                 if (ret) {
 467                         hns3_err(hw, "Failed to query RX No.%u queue stat: %d",
 468                                  i, ret);
 469                         return ret;
 470                 }
 471                 cnt = rte_le_to_cpu_32(desc.data[1]);
 472                 stats->rcb_rx_ring_pktnum_rcd += cnt;
 473                 stats->rcb_rx_ring_pktnum[i] += cnt;
 474
 475                 hns3_cmd_setup_basic_desc(&desc, HNS3_OPC_QUERY_TX_STATUS,
 476                                           true);
 477
 478                 desc.data[0] = rte_cpu_to_le_32((uint32_t)i);
 479                 ret = hns3_cmd_send(hw, &desc, 1);
 480                 if (ret) {
 481                         hns3_err(hw, "Failed to query TX No.%u queue stat: %d",
 482                                  i, ret);
 483                         return ret;
 484                 }
 485                 cnt = rte_le_to_cpu_32(desc.data[1]);
 486                 stats->rcb_tx_ring_pktnum_rcd += cnt;
 487                 stats->rcb_tx_ring_pktnum[i] += cnt;
 488         }
 489
 490         return 0;
 491 }
 492
 493 /*
 494  * Query tqp tx queue statistics ,opcode id: 0x0B03.
 495  * Query tqp rx queue statistics ,opcode id: 0x0B13.
 496  * Get all statistics of a port.
 497  * @param eth_dev
 498  *   Pointer to Ethernet device.
 499  * @praram rte_stats
 500  *   Pointer to structure rte_eth_stats.
 501  * @return
 502  *   0 on success.
 503  */
 504 int
 505 hns3_stats_get(struct rte_eth_dev *eth_dev, struct rte_eth_stats *rte_stats)
 506 {
 507         struct hns3_adapter *hns = eth_dev->data->dev_private;
 508         struct hns3_hw *hw = &hns->hw;
 509         struct hns3_tqp_stats *stats = &hw->tqp_stats;
 510         struct hns3_rx_queue *rxq;
 511         struct hns3_tx_queue *txq;
 512         uint64_t cnt;
 513         uint64_t num;
 514         uint16_t i;
 515         int ret;
 516
 517         /* Update tqp stats by read register */
 518         ret = hns3_update_tqp_stats(hw);
 519         if (ret) {
 520                 hns3_err(hw, "Update tqp stats fail : %d", ret);
 521                 return ret;
 522         }
 523
 524         /* Get the error stats of received packets */
 525         num = RTE_MIN(RTE_ETHDEV_QUEUE_STAT_CNTRS, eth_dev->data->nb_rx_queues);
 526         for (i = 0; i != num; ++i) {
 527                 rxq = eth_dev->data->rx_queues[i];
 528                 if (rxq) {
 529                         cnt = rxq->err_stats.l2_errors +
 530                                 rxq->err_stats.pkt_len_errors;
 531                         rte_stats->q_errors[i] = cnt;
 532                         rte_stats->q_ipackets[i] =
 533                                 stats->rcb_rx_ring_pktnum[i] - cnt;
 534                         rte_stats->ierrors += cnt;
 535                 }
 536         }
 537         /* Get the error stats of transmitted packets */
 538         num = RTE_MIN(RTE_ETHDEV_QUEUE_STAT_CNTRS, eth_dev->data->nb_tx_queues);
 539         for (i = 0; i < num; i++) {
 540                 txq = eth_dev->data->tx_queues[i];
 541                 if (txq)
 542                         rte_stats->q_opackets[i] = stats->rcb_tx_ring_pktnum[i];
 543         }
 544
 545         rte_stats->oerrors = 0;
 546         rte_stats->ipackets  = stats->rcb_rx_ring_pktnum_rcd -
 547                 rte_stats->ierrors;
 548         rte_stats->opackets  = stats->rcb_tx_ring_pktnum_rcd -
 549                 rte_stats->oerrors;
 550         rte_stats->rx_nombuf = eth_dev->data->rx_mbuf_alloc_failed;
 551
 552         return 0;
 553 }
 554
 555 int
 556 hns3_stats_reset(struct rte_eth_dev *eth_dev)
 557 {
 558         struct hns3_adapter *hns = eth_dev->data->dev_private;
 559         struct hns3_hw *hw = &hns->hw;
 560         struct hns3_cmd_desc desc_reset;
 561         struct hns3_rx_queue *rxq;
 562         uint16_t i;
 563         int ret;
 564
 565         /*
 566          * Note: Reading hardware statistics of rx/tx queue packet number
 567          * will clear them.
 568          */
 569         for (i = 0; i < hw->tqps_num; i++) {
 570                 hns3_cmd_setup_basic_desc(&desc_reset, HNS3_OPC_QUERY_RX_STATUS,
 571                                           true);
 572                 desc_reset.data[0] = rte_cpu_to_le_32((uint32_t)i);
 573                 ret = hns3_cmd_send(hw, &desc_reset, 1);
 574                 if (ret) {
 575                         hns3_err(hw, "Failed to reset RX No.%u queue stat: %d",
 576                                  i, ret);
 577                         return ret;
 578                 }
 579
 580                 hns3_cmd_setup_basic_desc(&desc_reset, HNS3_OPC_QUERY_TX_STATUS,
 581                                           true);
 582                 desc_reset.data[0] = rte_cpu_to_le_32((uint32_t)i);
 583                 ret = hns3_cmd_send(hw, &desc_reset, 1);
 584                 if (ret) {
 585                         hns3_err(hw, "Failed to reset TX No.%u queue stat: %d",
 586                                  i, ret);
 587                         return ret;
 588                 }
 589         }
 590
 591         /*
 592          * Clear soft stats of rx error packet which will be dropped
 593          * in driver.
 594          */
 595         for (i = 0; i < eth_dev->data->nb_rx_queues; i++) {
 596                 rxq = eth_dev->data->rx_queues[i];
 597                 if (rxq) {
 598                         rxq->err_stats.pkt_len_errors = 0;
 599                         rxq->err_stats.l2_errors = 0;
 600                 }
 601         }
 602
 603         hns3_tqp_stats_clear(hw);
 604
 605         return 0;
 606 }
 607
 608 static int
 609 hns3_mac_stats_reset(__rte_unused struct rte_eth_dev *dev)
 610 {
 611         struct hns3_adapter *hns = dev->data->dev_private;
 612         struct hns3_hw *hw = &hns->hw;
 613         struct hns3_mac_stats *mac_stats = &hw->mac_stats;
 614         int ret;
 615
 616         ret = hns3_query_update_mac_stats(dev);
 617         if (ret) {
 618                 hns3_err(hw, "Clear Mac stats fail : %d", ret);
 619                 return ret;
 620         }
 621
 622         memset(mac_stats, 0, sizeof(struct hns3_mac_stats));
 623
 624         return 0;
 625 }
 626
 627 /* This function calculates the number of xstats based on the current config */
 628 static int
 629 hns3_xstats_calc_num(struct rte_eth_dev *dev)
 630 {
 631         struct hns3_adapter *hns = dev->data->dev_private;
 632         uint16_t nb_rx_q = dev->data->nb_rx_queues;
 633         uint16_t nb_tx_q = dev->data->nb_tx_queues;
 634         int bderr_stats = nb_rx_q * HNS3_NUM_RX_BD_ERROR_XSTATS;
 635         int rx_dfx_stats = nb_rx_q * HNS3_NUM_RXQ_DFX_XSTATS;
 636         int tx_dfx_stats = nb_tx_q * HNS3_NUM_TXQ_DFX_XSTATS;
 637         int rx_queue_stats = nb_rx_q * HNS3_NUM_RX_QUEUE_STATS;
 638         int tx_queue_stats = nb_tx_q * HNS3_NUM_TX_QUEUE_STATS;
 639
 640         if (hns->is_vf)
 641                 return bderr_stats + rx_dfx_stats + tx_dfx_stats +
 642                         rx_queue_stats + tx_queue_stats + HNS3_NUM_RESET_XSTATS;
 643         else
 644                 return bderr_stats + rx_dfx_stats + tx_dfx_stats +
 645                         rx_queue_stats + tx_queue_stats + HNS3_FIX_NUM_STATS;
 646 }
 647
 648 static void
 649 hns3_queue_stats_get(struct rte_eth_dev *dev, struct rte_eth_xstat *xstats,
 650                      int *count)
 651 {
 652         struct hns3_adapter *hns = dev->data->dev_private;
 653         struct hns3_hw *hw = &hns->hw;
 654         uint32_t reg_offset;
 655         uint16_t i, j;
 656
 657         /* Get rx queue stats */
 658         for (j = 0; j < dev->data->nb_rx_queues; j++) {
 659                 for (i = 0; i < HNS3_NUM_RX_QUEUE_STATS; i++) {
 660                         reg_offset = hns3_get_tqp_reg_offset(j);
 661                         xstats[*count].value = hns3_read_dev(hw,
 662                                 reg_offset + hns3_rx_queue_strings[i].offset);
 663                         xstats[*count].id = *count;
 664                         (*count)++;
 665                 }
 666         }
 667
 668         /* Get tx queue stats */
 669         for (j = 0; j < dev->data->nb_tx_queues; j++) {
 670                 for (i = 0; i < HNS3_NUM_TX_QUEUE_STATS; i++) {
 671                         reg_offset = hns3_get_tqp_reg_offset(j);
 672                         xstats[*count].value = hns3_read_dev(hw,
 673                                 reg_offset + hns3_tx_queue_strings[i].offset);
 674                         xstats[*count].id = *count;
 675                         (*count)++;
 676                 }
 677         }
 678 }
 679
 680 void
 681 hns3_error_int_stats_add(struct hns3_adapter *hns, const char *err)
 682 {
 683         struct hns3_pf *pf = &hns->pf;
 684         uint16_t i;
 685         char *addr;
 686
 687         for (i = 0; i < HNS3_NUM_ERROR_INT_XSTATS; i++) {
 688                 if (strcmp(hns3_error_int_stats_strings[i].name, err) == 0) {
 689                         addr = (char *)&pf->abn_int_stats +
 690                                 hns3_error_int_stats_strings[i].offset;
 691                         *(uint64_t *)addr += 1;
 692                         break;
 693                 }
 694         }
 695 }
 696
 697 static void
 698 hns3_rxq_dfx_stats_get(struct rte_eth_dev *dev, struct rte_eth_xstat *xstats,
 699                        int *count)
 700 {
 701         struct hns3_rx_dfx_stats *dfx_stats;
 702         struct hns3_rx_queue *rxq;
 703         uint16_t i, j;
 704         char *val;
 705
 706         for (i = 0; i < dev->data->nb_rx_queues; i++) {
 707                 rxq = (struct hns3_rx_queue *)dev->data->rx_queues[i];
 708                 if (rxq == NULL)
 709                         continue;
 710
 711                 dfx_stats = &rxq->dfx_stats;
 712                 for (j = 0; j < HNS3_NUM_RXQ_DFX_XSTATS; j++) {
 713                         val = (char *)dfx_stats +
 714                                 hns3_rxq_dfx_stats_strings[j].offset;
 715                         xstats[*count].value = *(uint64_t *)val;
 716                         xstats[*count].id = *count;
 717                         (*count)++;
 718                 }
 719         }
 720 }
 721
 722 static void
 723 hns3_txq_dfx_stats_get(struct rte_eth_dev *dev, struct rte_eth_xstat *xstats,
 724                        int *count)
 725 {
 726         struct hns3_tx_dfx_stats *dfx_stats;
 727         struct hns3_tx_queue *txq;
 728         uint16_t i, j;
 729         char *val;
 730
 731         for (i = 0; i < dev->data->nb_tx_queues; i++) {
 732                 txq = (struct hns3_tx_queue *)dev->data->tx_queues[i];
 733                 if (txq == NULL)
 734                         continue;
 735
 736                 dfx_stats = &txq->dfx_stats;
 737                 for (j = 0; j < HNS3_NUM_TXQ_DFX_XSTATS; j++) {
 738                         val = (char *)dfx_stats +
 739                                 hns3_txq_dfx_stats_strings[j].offset;
 740                         xstats[*count].value = *(uint64_t *)val;
 741                         xstats[*count].id = *count;
 742                         (*count)++;
 743                 }
 744         }
 745 }
 746
 747 static void
 748 hns3_tqp_dfx_stats_get(struct rte_eth_dev *dev, struct rte_eth_xstat *xstats,
 749                        int *count)
 750 {
 751         hns3_rxq_dfx_stats_get(dev, xstats, count);
 752         hns3_txq_dfx_stats_get(dev, xstats, count);
 753 }
 754 /*
 755  * Retrieve extended(tqp | Mac) statistics of an Ethernet device.
 756  * @param dev
 757  *   Pointer to Ethernet device.
 758  * @praram xstats
 759  *   A pointer to a table of structure of type *rte_eth_xstat*
 760  *   to be filled with device statistics ids and values.
 761  *   This parameter can be set to NULL if n is 0.
 762  * @param n
 763  *   The size of the xstats array (number of elements).
 764  * @return
 765  *   0 on fail, count(The size of the statistics elements) on success.
 766  */
 767 int
 768 hns3_dev_xstats_get(struct rte_eth_dev *dev, struct rte_eth_xstat *xstats,
 769                     unsigned int n)
 770 {
 771         struct hns3_adapter *hns = dev->data->dev_private;
 772         struct hns3_pf *pf = &hns->pf;
 773         struct hns3_hw *hw = &hns->hw;
 774         struct hns3_mac_stats *mac_stats = &hw->mac_stats;
 775         struct hns3_reset_stats *reset_stats = &hw->reset.stats;
 776         struct hns3_rx_bd_errors_stats *rx_err_stats;
 777         struct hns3_rx_queue *rxq;
 778         uint16_t i, j;
 779         char *addr;
 780         int count;
 781         int ret;
 782
 783         if (xstats == NULL)
 784                 return 0;
 785
 786         count = hns3_xstats_calc_num(dev);
 787         if ((int)n < count)
 788                 return count;
 789
 790         count = 0;
 791
 792         if (!hns->is_vf) {
 793                 /* Update Mac stats */
 794                 ret = hns3_query_update_mac_stats(dev);
 795                 if (ret < 0) {
 796                         hns3_err(hw, "Update Mac stats fail : %d", ret);
 797                         return ret;
 798                 }
 799
 800                 /* Get MAC stats from hw->hw_xstats.mac_stats struct */
 801                 for (i = 0; i < HNS3_NUM_MAC_STATS; i++) {
 802                         addr = (char *)mac_stats + hns3_mac_strings[i].offset;
 803                         xstats[count].value = *(uint64_t *)addr;
 804                         xstats[count].id = count;
 805                         count++;
 806                 }
 807
 808                 for (i = 0; i < HNS3_NUM_ERROR_INT_XSTATS; i++) {
 809                         addr = (char *)&pf->abn_int_stats +
 810                                hns3_error_int_stats_strings[i].offset;
 811                         xstats[count].value = *(uint64_t *)addr;
 812                         xstats[count].id = count;
 813                         count++;
 814                 }
 815         }
 816
 817         /* Get the reset stat */
 818         for (i = 0; i < HNS3_NUM_RESET_XSTATS; i++) {
 819                 addr = (char *)reset_stats + hns3_reset_stats_strings[i].offset;
 820                 xstats[count].value = *(uint64_t *)addr;
 821                 xstats[count].id = count;
 822                 count++;
 823         }
 824
 825         /* Get the Rx BD errors stats */
 826         for (j = 0; j < dev->data->nb_rx_queues; j++) {
 827                 for (i = 0; i < HNS3_NUM_RX_BD_ERROR_XSTATS; i++) {
 828                         rxq = dev->data->rx_queues[j];
 829                         if (rxq) {
 830                                 rx_err_stats = &rxq->err_stats;
 831                                 addr = (char *)rx_err_stats +
 832                                         hns3_rx_bd_error_strings[i].offset;
 833                                 xstats[count].value = *(uint64_t *)addr;
 834                                 xstats[count].id = count;
 835                                 count++;
 836                         }
 837                 }
 838         }
 839
 840         hns3_tqp_dfx_stats_get(dev, xstats, &count);
 841         hns3_queue_stats_get(dev, xstats, &count);
 842
 843         return count;
 844 }
 845
 846 static void
 847 hns3_tqp_dfx_stats_name_get(struct rte_eth_dev *dev,
 848                             struct rte_eth_xstat_name *xstats_names,
 849                             uint32_t *count)
 850 {
 851         uint16_t i, j;
 852
 853         for (j = 0; j < dev->data->nb_rx_queues; j++) {
 854                 for (i = 0; i < HNS3_NUM_RXQ_DFX_XSTATS; i++) {
 855                         snprintf(xstats_names[*count].name,
 856                                  sizeof(xstats_names[*count].name),
 857                                  "rx_q%u_%s", j,
 858                                  hns3_rxq_dfx_stats_strings[i].name);
 859                         (*count)++;
 860                 }
 861         }
 862
 863         for (j = 0; j < dev->data->nb_tx_queues; j++) {
 864                 for (i = 0; i < HNS3_NUM_TXQ_DFX_XSTATS; i++) {
 865                         snprintf(xstats_names[*count].name,
 866                                  sizeof(xstats_names[*count].name),
 867                                  "tx_q%u_%s", j,
 868                                  hns3_txq_dfx_stats_strings[i].name);
 869                         (*count)++;
 870                 }
 871         }
 872 }
 873
 874 /*
 875  * Retrieve names of extended statistics of an Ethernet device.
 876  *
 877  * There is an assumption that 'xstat_names' and 'xstats' arrays are matched
 878  * by array index:
 879  *  xstats_names[i].name => xstats[i].value
 880  *
 881  * And the array index is same with id field of 'struct rte_eth_xstat':
 882  *  xstats[i].id == i
 883  *
 884  * This assumption makes key-value pair matching less flexible but simpler.
 885  *
 886  * @param dev
 887  *   Pointer to Ethernet device.
 888  * @param xstats_names
 889  *   An rte_eth_xstat_name array of at least *size* elements to
 890  *   be filled. If set to NULL, the function returns the required number
 891  *   of elements.
 892  * @param size
 893  *   The size of the xstats_names array (number of elements).
 894  * @return
 895  *   - A positive value lower or equal to size: success. The return value
 896  *     is the number of entries filled in the stats table.
 897  */
 898 int
 899 hns3_dev_xstats_get_names(struct rte_eth_dev *dev,
 900                           struct rte_eth_xstat_name *xstats_names,
 901                           __rte_unused unsigned int size)
 902 {
 903         struct hns3_adapter *hns = dev->data->dev_private;
 904         int cnt_stats = hns3_xstats_calc_num(dev);
 905         uint32_t count = 0;
 906         uint16_t i, j;
 907
 908         if (xstats_names == NULL)
 909                 return cnt_stats;
 910
 911         /* Note: size limited checked in rte_eth_xstats_get_names() */
 912         if (!hns->is_vf) {
 913                 /* Get MAC name from hw->hw_xstats.mac_stats struct */
 914                 for (i = 0; i < HNS3_NUM_MAC_STATS; i++) {
 915                         snprintf(xstats_names[count].name,
 916                                  sizeof(xstats_names[count].name),
 917                                  "%s", hns3_mac_strings[i].name);
 918                         count++;
 919                 }
 920
 921                 for (i = 0; i < HNS3_NUM_ERROR_INT_XSTATS; i++) {
 922                         snprintf(xstats_names[count].name,
 923                                  sizeof(xstats_names[count].name),
 924                                  "%s", hns3_error_int_stats_strings[i].name);
 925                         count++;
 926                 }
 927         }
 928         for (i = 0; i < HNS3_NUM_RESET_XSTATS; i++) {
 929                 snprintf(xstats_names[count].name,
 930                          sizeof(xstats_names[count].name),
 931                          "%s", hns3_reset_stats_strings[i].name);
 932                 count++;
 933         }
 934
 935         for (j = 0; j < dev->data->nb_rx_queues; j++) {
 936                 for (i = 0; i < HNS3_NUM_RX_BD_ERROR_XSTATS; i++) {
 937                         snprintf(xstats_names[count].name,
 938                                  sizeof(xstats_names[count].name),
 939                                  "rx_q%u_%s", j,
 940                                  hns3_rx_bd_error_strings[i].name);
 941                         count++;
 942                 }
 943         }
 944
 945         hns3_tqp_dfx_stats_name_get(dev, xstats_names, &count);
 946
 947         for (j = 0; j < dev->data->nb_rx_queues; j++) {
 948                 for (i = 0; i < HNS3_NUM_RX_QUEUE_STATS; i++) {
 949                         snprintf(xstats_names[count].name,
 950                                  sizeof(xstats_names[count].name),
 951                                  "rx_q%u_%s", j, hns3_rx_queue_strings[i].name);
 952                         count++;
 953                 }
 954         }
 955
 956         for (j = 0; j < dev->data->nb_tx_queues; j++) {
 957                 for (i = 0; i < HNS3_NUM_TX_QUEUE_STATS; i++) {
 958                         snprintf(xstats_names[count].name,
 959                                  sizeof(xstats_names[count].name),
 960                                  "tx_q%u_%s", j, hns3_tx_queue_strings[i].name);
 961                         count++;
 962                 }
 963         }
 964
 965         return count;
 966 }
 967
 968 /*
 969  * Retrieve extended statistics of an Ethernet device.
 970  *
 971  * @param dev
 972  *   Pointer to Ethernet device.
 973  * @param ids
 974  *   A pointer to an ids array passed by application. This tells which
 975  *   statistics values function should retrieve. This parameter
 976  *   can be set to NULL if size is 0. In this case function will retrieve
 977  *   all avalible statistics.
 978  * @param values
 979  *   A pointer to a table to be filled with device statistics values.
 980  * @param size
 981  *   The size of the ids array (number of elements).
 982  * @return
 983  *   - A positive value lower or equal to size: success. The return value
 984  *     is the number of entries filled in the stats table.
 985  *   - A positive value higher than size: error, the given statistics table
 986  *     is too small. The return value corresponds to the size that should
 987  *     be given to succeed. The entries in the table are not valid and
 988  *     shall not be used by the caller.
 989  *   - 0 on no ids.
 990  */
 991 int
 992 hns3_dev_xstats_get_by_id(struct rte_eth_dev *dev, const uint64_t *ids,
 993                           uint64_t *values, uint32_t size)
 994 {
 995         const uint32_t cnt_stats = hns3_xstats_calc_num(dev);
 996         struct hns3_adapter *hns = dev->data->dev_private;
 997         struct rte_eth_xstat *values_copy;
 998         struct hns3_hw *hw = &hns->hw;
 999         uint32_t count_value;
1000         uint64_t len;
1001         uint32_t i;
1002         int ret;
1003
1004         if (ids == NULL && values == NULL)
1005                 return cnt_stats;
1006
1007         if (ids == NULL)
1008                 if (size < cnt_stats)
1009                         return cnt_stats;
1010
1011         /* Update tqp stats by read register */
1012         ret = hns3_update_tqp_stats(hw);
1013         if (ret) {
1014                 hns3_err(hw, "Update tqp stats fail : %d", ret);
1015                 return ret;
1016         }
1017
1018         len = cnt_stats * sizeof(struct rte_eth_xstat);
1019         values_copy = rte_zmalloc("hns3_xstats_values", len, 0);
1020         if (values_copy == NULL) {
1021                 hns3_err(hw, "Failed to allocate %" PRIx64 " bytes needed "
1022                              "to store statistics values", len);
1023                 return -ENOMEM;
1024         }
1025
1026         count_value = hns3_dev_xstats_get(dev, values_copy, cnt_stats);
1027         if (count_value != cnt_stats) {
1028                 rte_free(values_copy);
1029                 return -EINVAL;
1030         }
1031
1032         if (ids == NULL && values != NULL) {
1033                 for (i = 0; i < cnt_stats; i++)
1034                         memcpy(&values[i], &values_copy[i].value,
1035                                sizeof(values[i]));
1036
1037                 rte_free(values_copy);
1038                 return cnt_stats;
1039         }
1040
1041         for (i = 0; i < size; i++) {
1042                 if (ids[i] >= cnt_stats) {
1043                         hns3_err(hw, "ids[%u] (%" PRIx64 ") is invalid, "
1044                                      "should < %u", i, ids[i], cnt_stats);
1045                         rte_free(values_copy);
1046                         return -EINVAL;
1047                 }
1048                 memcpy(&values[i], &values_copy[ids[i]].value,
1049                         sizeof(values[i]));
1050         }
1051
1052         rte_free(values_copy);
1053         return size;
1054 }
1055
1056 /*
1057  * Retrieve names of extended statistics of an Ethernet device.
1058  *
1059  * @param dev
1060  *   Pointer to Ethernet device.
1061  * @param xstats_names
1062  *   An rte_eth_xstat_name array of at least *size* elements to
1063  *   be filled. If set to NULL, the function returns the required number
1064  *   of elements.
1065  * @param ids
1066  *   IDs array given by app to retrieve specific statistics
1067  * @param size
1068  *   The size of the xstats_names array (number of elements).
1069  * @return
1070  *   - A positive value lower or equal to size: success. The return value
1071  *     is the number of entries filled in the stats table.
1072  *   - A positive value higher than size: error, the given statistics table
1073  *     is too small. The return value corresponds to the size that should
1074  *     be given to succeed. The entries in the table are not valid and
1075  *     shall not be used by the caller.
1076  */
1077 int
1078 hns3_dev_xstats_get_names_by_id(struct rte_eth_dev *dev,
1079                                 struct rte_eth_xstat_name *xstats_names,
1080                                 const uint64_t *ids, uint32_t size)
1081 {
1082         const uint32_t cnt_stats = hns3_xstats_calc_num(dev);
1083         struct hns3_adapter *hns = dev->data->dev_private;
1084         struct rte_eth_xstat_name *names_copy;
1085         struct hns3_hw *hw = &hns->hw;
1086         uint64_t len;
1087         uint32_t i;
1088
1089         if (xstats_names == NULL)
1090                 return cnt_stats;
1091
1092         if (ids == NULL) {
1093                 if (size < cnt_stats)
1094                         return cnt_stats;
1095
1096                 return hns3_dev_xstats_get_names(dev, xstats_names, cnt_stats);
1097         }
1098
1099         len = cnt_stats * sizeof(struct rte_eth_xstat_name);
1100         names_copy = rte_zmalloc("hns3_xstats_names", len, 0);
1101         if (names_copy == NULL) {
1102                 hns3_err(hw, "Failed to allocate %" PRIx64 " bytes needed "
1103                              "to store statistics names", len);
1104                 return -ENOMEM;
1105         }
1106
1107         (void)hns3_dev_xstats_get_names(dev, names_copy, cnt_stats);
1108
1109         for (i = 0; i < size; i++) {
1110                 if (ids[i] >= cnt_stats) {
1111                         hns3_err(hw, "ids[%u] (%" PRIx64 ") is invalid, "
1112                                      "should < %u", i, ids[i], cnt_stats);
1113                         rte_free(names_copy);
1114                         return -EINVAL;
1115                 }
1116                 snprintf(xstats_names[i].name, sizeof(xstats_names[i].name),
1117                          "%s", names_copy[ids[i]].name);
1118         }
1119
1120         rte_free(names_copy);
1121         return size;
1122 }
1123
1124 static void
1125 hns3_tqp_dfx_stats_clear(struct rte_eth_dev *dev)
1126 {
1127         struct hns3_rx_queue *rxq;
1128         struct hns3_tx_queue *txq;
1129         uint16_t i;
1130
1131         /* Clear Rx dfx stats */
1132         for (i = 0; i < dev->data->nb_rx_queues; i++) {
1133                 rxq = dev->data->rx_queues[i];
1134                 if (rxq)
1135                         memset(&rxq->dfx_stats, 0,
1136                                sizeof(struct hns3_rx_dfx_stats));
1137         }
1138
1139         /* Clear Tx dfx stats */
1140         for (i = 0; i < dev->data->nb_tx_queues; i++) {
1141                 txq = dev->data->tx_queues[i];
1142                 if (txq)
1143                         memset(&txq->dfx_stats, 0,
1144                                sizeof(struct hns3_tx_dfx_stats));
1145         }
1146 }
1147
1148 int
1149 hns3_dev_xstats_reset(struct rte_eth_dev *dev)
1150 {
1151         struct hns3_adapter *hns = dev->data->dev_private;
1152         struct hns3_pf *pf = &hns->pf;
1153         int ret;
1154
1155         /* Clear tqp stats */
1156         ret = hns3_stats_reset(dev);
1157         if (ret)
1158                 return ret;
1159
1160         /* Clear reset stats */
1161         memset(&hns->hw.reset.stats, 0, sizeof(struct hns3_reset_stats));
1162
1163         hns3_tqp_dfx_stats_clear(dev);
1164
1165         if (hns->is_vf)
1166                 return 0;
1167
1168         /* HW registers are cleared on read */
1169         ret = hns3_mac_stats_reset(dev);
1170         if (ret)
1171                 return ret;
1172
1173         /* Clear error stats */
1174         memset(&pf->abn_int_stats, 0, sizeof(struct hns3_err_msix_intr_stats));
1175
1176         return 0;
1177 }
1178
1179 int
1180 hns3_tqp_stats_init(struct hns3_hw *hw)
1181 {
1182         struct hns3_tqp_stats *tqp_stats = &hw->tqp_stats;
1183
1184         tqp_stats->rcb_rx_ring_pktnum = rte_zmalloc("hns3_rx_ring_pkt_num",
1185                                          sizeof(uint64_t) * hw->tqps_num, 0);
1186         if (tqp_stats->rcb_rx_ring_pktnum == NULL) {
1187                 hns3_err(hw, "failed to allocate rx_ring pkt_num.");
1188                 return -ENOMEM;
1189         }
1190
1191         tqp_stats->rcb_tx_ring_pktnum = rte_zmalloc("hns3_tx_ring_pkt_num",
1192                                          sizeof(uint64_t) * hw->tqps_num, 0);
1193         if (tqp_stats->rcb_tx_ring_pktnum == NULL) {
1194                 hns3_err(hw, "failed to allocate tx_ring pkt_num.");
1195                 rte_free(tqp_stats->rcb_rx_ring_pktnum);
1196                 tqp_stats->rcb_rx_ring_pktnum = NULL;
1197                 return -ENOMEM;
1198         }
1199
1200         return 0;
1201 }
1202
1203 void
1204 hns3_tqp_stats_uninit(struct hns3_hw *hw)
1205 {
1206         struct hns3_tqp_stats *tqp_stats = &hw->tqp_stats;
1207
1208         rte_free(tqp_stats->rcb_rx_ring_pktnum);
1209         tqp_stats->rcb_rx_ring_pktnum = NULL;
1210         rte_free(tqp_stats->rcb_tx_ring_pktnum);
1211         tqp_stats->rcb_tx_ring_pktnum = NULL;
1212 }
1213
1214 static void
1215 hns3_tqp_stats_clear(struct hns3_hw *hw)
1216 {
1217         struct hns3_tqp_stats *stats = &hw->tqp_stats;
1218
1219         stats->rcb_rx_ring_pktnum_rcd = 0;
1220         stats->rcb_tx_ring_pktnum_rcd = 0;
1221         memset(stats->rcb_rx_ring_pktnum, 0, sizeof(uint64_t) * hw->tqps_num);
1222         memset(stats->rcb_tx_ring_pktnum, 0, sizeof(uint64_t) * hw->tqps_num);
1223 }