drivers/net/hns3/hns3_ethdev_dump.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(C) 2022 HiSilicon Limited
   3  */
   4
   5 #include "hns3_common.h"
   6 #include "hns3_logs.h"
   7 #include "hns3_regs.h"
   8 #include "hns3_rxtx.h"
   9 #include "hns3_ethdev.h"
  10
  11 static const char *
  12 get_adapter_state_name(enum hns3_adapter_state state)
  13 {
  14         const struct {
  15                 enum hns3_adapter_state state;
  16                 const char *name;
  17         } adapter_state_name[] = {
  18                 {HNS3_NIC_UNINITIALIZED, "UNINITIALIZED"},
  19                 {HNS3_NIC_INITIALIZED, "INITIALIZED"},
  20                 {HNS3_NIC_CONFIGURING, "CONFIGURING"},
  21                 {HNS3_NIC_CONFIGURED, "CONFIGURED"},
  22                 {HNS3_NIC_STARTING, "STARTING"},
  23                 {HNS3_NIC_STARTED, "STARTED"},
  24                 {HNS3_NIC_STOPPING, "STOPPING"},
  25                 {HNS3_NIC_CLOSING, "CLOSING"},
  26                 {HNS3_NIC_CLOSED, "CLOSED"},
  27                 {HNS3_NIC_REMOVED, "REMOVED"},
  28                 {HNS3_NIC_NSTATES, "NSTATES"},
  29         };
  30         uint32_t i;
  31
  32         for (i = 0; i < RTE_DIM(adapter_state_name); i++)
  33                 if (state == adapter_state_name[i].state)
  34                         return adapter_state_name[i].name;
  35
  36         return "Unknown";
  37 }
  38
  39 static const char *
  40 get_io_func_hint_name(uint32_t hint)
  41 {
  42         switch (hint) {
  43         case HNS3_IO_FUNC_HINT_NONE:
  44                 return "none";
  45         case HNS3_IO_FUNC_HINT_VEC:
  46                 return "vec";
  47         case HNS3_IO_FUNC_HINT_SVE:
  48                 return "sve";
  49         case HNS3_IO_FUNC_HINT_SIMPLE:
  50                 return "simple";
  51         case HNS3_IO_FUNC_HINT_COMMON:
  52                 return "common";
  53         default:
  54                 return "unknown";
  55         }
  56 }
  57
  58 static void
  59 get_dev_mac_info(FILE *file, struct hns3_adapter *hns)
  60 {
  61         struct hns3_hw *hw = &hns->hw;
  62         struct hns3_pf *pf = &hns->pf;
  63
  64         fprintf(file, "  - MAC Info:\n");
  65         fprintf(file,
  66                 "\t  -- query_type=%u\n"
  67                 "\t  -- supported_speed=0x%x\n"
  68                 "\t  -- advertising=0x%x\n"
  69                 "\t  -- lp_advertising=0x%x\n"
  70                 "\t  -- support_autoneg=%s\n"
  71                 "\t  -- support_fc_autoneg=%s\n",
  72                 hw->mac.query_type,
  73                 hw->mac.supported_speed,
  74                 hw->mac.advertising,
  75                 hw->mac.lp_advertising,
  76                 hw->mac.support_autoneg != 0 ? "Yes" : "No",
  77                 pf->support_fc_autoneg ? "Yes" : "No");
  78 }
  79
  80 static void
  81 get_dev_feature_capability(FILE *file, struct hns3_hw *hw)
  82 {
  83         const struct {
  84                 enum hns3_dev_cap cap;
  85                 const char *name;
  86         } caps_name[] = {
  87                 {HNS3_DEV_SUPPORT_DCB_B, "DCB"},
  88                 {HNS3_DEV_SUPPORT_COPPER_B, "COPPER"},
  89                 {HNS3_DEV_SUPPORT_FD_QUEUE_REGION_B, "FD QUEUE REGION"},
  90                 {HNS3_DEV_SUPPORT_PTP_B, "PTP"},
  91                 {HNS3_DEV_SUPPORT_TX_PUSH_B, "TX PUSH"},
  92                 {HNS3_DEV_SUPPORT_INDEP_TXRX_B, "INDEP TXRX"},
  93                 {HNS3_DEV_SUPPORT_STASH_B, "STASH"},
  94                 {HNS3_DEV_SUPPORT_RXD_ADV_LAYOUT_B, "RXD Advanced Layout"},
  95                 {HNS3_DEV_SUPPORT_OUTER_UDP_CKSUM_B, "OUTER UDP CKSUM"},
  96                 {HNS3_DEV_SUPPORT_RAS_IMP_B, "RAS IMP"},
  97                 {HNS3_DEV_SUPPORT_TM_B, "TM"},
  98         };
  99         uint32_t i;
 100
 101         fprintf(file, "  - Dev Capability:\n");
 102         for (i = 0; i < RTE_DIM(caps_name); i++)
 103                 fprintf(file, "\t  -- support %s: %s\n", caps_name[i].name,
 104                         hns3_get_bit(hw->capability, caps_name[i].cap) ? "Yes" :
 105                                                                          "No");
 106 }
 107
 108 static const char *
 109 get_fdir_tuple_name(uint32_t index)
 110 {
 111         static const char * const tuple_name[] = {
 112                 "outer_dst_mac",
 113                 "outer_src_mac",
 114                 "outer_vlan_1st_tag",
 115                 "outer_vlan_2nd_tag",
 116                 "outer_eth_type",
 117                 "outer_l2_rsv",
 118                 "outer_ip_tos",
 119                 "outer_ip_proto",
 120                 "outer_src_ip",
 121                 "outer_dst_ip",
 122                 "outer_l3_rsv",
 123                 "outer_src_port",
 124                 "outer_dst_port",
 125                 "outer_l4_rsv",
 126                 "outer_tun_vni",
 127                 "outer_tun_flow_id",
 128                 "inner_dst_mac",
 129                 "inner_src_mac",
 130                 "inner_vlan_tag1",
 131                 "inner_vlan_tag2",
 132                 "inner_eth_type",
 133                 "inner_l2_rsv",
 134                 "inner_ip_tos",
 135                 "inner_ip_proto",
 136                 "inner_src_ip",
 137                 "inner_dst_ip",
 138                 "inner_l3_rsv",
 139                 "inner_src_port",
 140                 "inner_dst_port",
 141                 "inner_sctp_tag",
 142         };
 143         if (index < RTE_DIM(tuple_name))
 144                 return tuple_name[index];
 145         else
 146                 return "unknown";
 147 }
 148
 149 static void
 150 get_fdir_basic_info(FILE *file, struct hns3_pf *pf)
 151 {
 152 #define TMPBUF_SIZE             2048
 153 #define PERLINE_TUPLE_NAMES     4
 154         struct hns3_fd_cfg *fdcfg = &pf->fdir.fd_cfg;
 155         char tmpbuf[TMPBUF_SIZE] = {0};
 156         uint32_t i, count = 0;
 157
 158         fprintf(file, "  - Fdir Info:\n");
 159         fprintf(file,
 160                 "\t  -- mode=%u max_key_len=%u rule_num:%u cnt_num:%u\n"
 161                 "\t  -- key_sel=%u tuple_active=0x%x meta_data_active=0x%x\n"
 162                 "\t  -- ipv6_word_en: in_s=%u in_d=%u out_s=%u out_d=%u\n"
 163                 "\t  -- active_tuples:\n",
 164                 fdcfg->fd_mode, fdcfg->max_key_length,
 165                 fdcfg->rule_num[HNS3_FD_STAGE_1],
 166                 fdcfg->cnt_num[HNS3_FD_STAGE_1],
 167                 fdcfg->key_cfg[HNS3_FD_STAGE_1].key_sel,
 168                 fdcfg->key_cfg[HNS3_FD_STAGE_1].tuple_active,
 169                 fdcfg->key_cfg[HNS3_FD_STAGE_1].meta_data_active,
 170                 fdcfg->key_cfg[HNS3_FD_STAGE_1].inner_sipv6_word_en,
 171                 fdcfg->key_cfg[HNS3_FD_STAGE_1].inner_dipv6_word_en,
 172                 fdcfg->key_cfg[HNS3_FD_STAGE_1].outer_sipv6_word_en,
 173                 fdcfg->key_cfg[HNS3_FD_STAGE_1].outer_dipv6_word_en);
 174
 175         for (i = 0; i < MAX_TUPLE; i++) {
 176                 if (!(fdcfg->key_cfg[HNS3_FD_STAGE_1].tuple_active & BIT(i)))
 177                         continue;
 178                 if (count % PERLINE_TUPLE_NAMES == 0)
 179                         fprintf(file, "\t      ");
 180                 fprintf(file, " %s", get_fdir_tuple_name(i));
 181                 count++;
 182                 if (count % PERLINE_TUPLE_NAMES == 0)
 183                         fprintf(file, "\n");
 184         }
 185         if (count % PERLINE_TUPLE_NAMES)
 186                 fprintf(file, "\n");
 187
 188         fprintf(file, "%s", tmpbuf);
 189 }
 190
 191 static void
 192 get_device_basic_info(FILE *file, struct rte_eth_dev *dev)
 193 {
 194         struct hns3_adapter *hns = dev->data->dev_private;
 195         struct hns3_hw *hw = &hns->hw;
 196
 197         fprintf(file,
 198                 "  - Device Base Info:\n"
 199                 "\t  -- name: %s\n"
 200                 "\t  -- adapter_state=%s\n"
 201                 "\t  -- nb_rx_queues=%u nb_tx_queues=%u\n"
 202                 "\t  -- total_tqps_num=%u tqps_num=%u intr_tqps_num=%u\n"
 203                 "\t  -- rss_size_max=%u alloc_rss_size=%u tx_qnum_per_tc=%u\n"
 204                 "\t  -- min_tx_pkt_len=%u intr_mapping_mode=%u vlan_mode=%u\n"
 205                 "\t  -- tso_mode=%u max_non_tso_bd_num=%u\n"
 206                 "\t  -- max_tm_rate=%u Mbps\n"
 207                 "\t  -- set link down: %s\n"
 208                 "\t  -- rx_func_hint=%s tx_func_hint=%s\n"
 209                 "\t  -- dev_flags: lsc=%d\n"
 210                 "\t  -- intr_conf: lsc=%u rxq=%u\n",
 211                 dev->data->name,
 212                 get_adapter_state_name(hw->adapter_state),
 213                 dev->data->nb_rx_queues, dev->data->nb_tx_queues,
 214                 hw->total_tqps_num, hw->tqps_num, hw->intr_tqps_num,
 215                 hw->rss_size_max, hw->alloc_rss_size, hw->tx_qnum_per_tc,
 216                 hw->min_tx_pkt_len, hw->intr.mapping_mode, hw->vlan_mode,
 217                 hw->tso_mode, hw->max_non_tso_bd_num,
 218                 hw->max_tm_rate,
 219                 hw->set_link_down ? "Yes" : "No",
 220                 get_io_func_hint_name(hns->rx_func_hint),
 221                 get_io_func_hint_name(hns->tx_func_hint),
 222                 !!(dev->data->dev_flags & RTE_ETH_DEV_INTR_LSC),
 223                 dev->data->dev_conf.intr_conf.lsc,
 224                 dev->data->dev_conf.intr_conf.rxq);
 225 }
 226
 227 static struct hns3_rx_queue *
 228 get_rx_queue(struct rte_eth_dev *dev)
 229 {
 230         struct hns3_hw *hw = HNS3_DEV_PRIVATE_TO_HW(dev->data->dev_private);
 231         struct hns3_rx_queue *rxq;
 232         uint32_t queue_id;
 233         void **rx_queues;
 234
 235         for (queue_id = 0; queue_id < dev->data->nb_rx_queues; queue_id++) {
 236                 rx_queues = dev->data->rx_queues;
 237                 if (rx_queues == NULL || rx_queues[queue_id] == NULL) {
 238                         hns3_err(hw, "detect rx_queues is NULL!\n");
 239                         return NULL;
 240                 }
 241
 242                 rxq = (struct hns3_rx_queue *)rx_queues[queue_id];
 243                 if (rxq->rx_deferred_start)
 244                         continue;
 245
 246                 return rx_queues[queue_id];
 247         }
 248
 249         return NULL;
 250 }
 251
 252 static struct hns3_tx_queue *
 253 get_tx_queue(struct rte_eth_dev *dev)
 254 {
 255         struct hns3_hw *hw = HNS3_DEV_PRIVATE_TO_HW(dev->data->dev_private);
 256         struct hns3_tx_queue *txq;
 257         uint32_t queue_id;
 258         void **tx_queues;
 259
 260         for (queue_id = 0; queue_id < dev->data->nb_tx_queues; queue_id++) {
 261                 tx_queues = dev->data->tx_queues;
 262                 if (tx_queues == NULL || tx_queues[queue_id] == NULL) {
 263                         hns3_err(hw, "detect tx_queues is NULL!\n");
 264                         return NULL;
 265                 }
 266
 267                 txq = (struct hns3_tx_queue *)tx_queues[queue_id];
 268                 if (txq->tx_deferred_start)
 269                         continue;
 270
 271                 return tx_queues[queue_id];
 272         }
 273
 274         return NULL;
 275 }
 276
 277 static void
 278 get_rxtx_fake_queue_info(FILE *file, struct rte_eth_dev *dev)
 279 {
 280         struct hns3_hw *hw = HNS3_DEV_PRIVATE_TO_HW(dev->data->dev_private);
 281         struct hns3_rx_queue *rxq;
 282         struct hns3_tx_queue *txq;
 283         uint32_t queue_id = 0;
 284         void **rx_queues;
 285         void **tx_queues;
 286
 287         if (hns3_dev_get_support(hw, INDEP_TXRX))
 288                 return;
 289
 290         if (dev->data->nb_rx_queues < dev->data->nb_tx_queues) {
 291                 rx_queues = hw->fkq_data.rx_queues;
 292                 if (rx_queues == NULL || rx_queues[queue_id] == NULL) {
 293                         hns3_err(hw, "detect rx_queues is NULL!\n");
 294                         return;
 295                 }
 296                 rxq = (struct hns3_rx_queue *)rx_queues[queue_id];
 297
 298                 fprintf(file,
 299                         "\t  -- first fake_queue info:\n"
 300                         "\t       Rx: port=%u nb_desc=%u free_thresh=%u\n",
 301                         rxq->port_id, rxq->nb_rx_desc, rxq->rx_free_thresh);
 302         } else if (dev->data->nb_rx_queues > dev->data->nb_tx_queues) {
 303                 tx_queues = hw->fkq_data.tx_queues;
 304                 queue_id = 0;
 305
 306                 if (tx_queues == NULL || tx_queues[queue_id] == NULL) {
 307                         hns3_err(hw, "detect tx_queues is NULL!\n");
 308                         return;
 309                 }
 310                 txq = (struct hns3_tx_queue *)tx_queues[queue_id];
 311
 312                 fprintf(file,
 313                         "\t  -- first fake_queue info:\n"
 314                         "\t       Tx: port=%u nb_desc=%u\n",
 315                         txq->port_id, txq->nb_tx_desc);
 316         }
 317 }
 318
 319 static void
 320 get_queue_enable_state(struct hns3_hw *hw, uint32_t *queue_state,
 321                         uint32_t nb_queues, bool is_rxq)
 322 {
 323 #define STATE_SIZE (sizeof(*queue_state) * CHAR_BIT)
 324         uint32_t queue_en_reg;
 325         uint32_t reg_offset;
 326         uint32_t state;
 327         uint32_t i;
 328
 329         queue_en_reg = is_rxq ? HNS3_RING_RX_EN_REG : HNS3_RING_TX_EN_REG;
 330         for (i = 0; i < nb_queues; i++) {
 331                 reg_offset = hns3_get_tqp_reg_offset(i);
 332                 state = hns3_read_dev(hw, reg_offset + HNS3_RING_EN_REG);
 333                 if (hns3_dev_get_support(hw, INDEP_TXRX))
 334                         state = state && hns3_read_dev(hw, reg_offset +
 335                                                        queue_en_reg);
 336                 hns3_set_bit(queue_state[i / STATE_SIZE],
 337                                 i % STATE_SIZE, state);
 338         }
 339 }
 340
 341 static void
 342 print_queue_state_perline(FILE *file, const uint32_t *queue_state,
 343                           uint32_t nb_queues, uint32_t line_num)
 344 {
 345 #define NUM_QUEUE_PER_LINE (sizeof(*queue_state) * CHAR_BIT)
 346         uint32_t qid = line_num * NUM_QUEUE_PER_LINE;
 347         uint32_t j;
 348
 349         for (j = 0; j < NUM_QUEUE_PER_LINE; j++) {
 350                 fprintf(file, "%1lx", hns3_get_bit(queue_state[line_num], j));
 351
 352                 if (qid % CHAR_BIT == CHAR_BIT - 1) {
 353                         fprintf(file, "%s",
 354                                 j == NUM_QUEUE_PER_LINE - 1 ? "\n" : ":");
 355                 }
 356                 qid++;
 357                 if (qid >= nb_queues) {
 358                         fprintf(file, "\n");
 359                         break;
 360                 }
 361         }
 362 }
 363
 364 static void
 365 display_queue_enable_state(FILE *file, const uint32_t *queue_state,
 366                            uint32_t nb_queues, bool is_rxq)
 367 {
 368 #define NUM_QUEUE_PER_LINE (sizeof(*queue_state) * CHAR_BIT)
 369         uint32_t i;
 370
 371         if (nb_queues == 0) {
 372                 fprintf(file, "\t       %s queue number is 0\n",
 373                                 is_rxq ? "Rx" : "Tx");
 374                 return;
 375         }
 376
 377         fprintf(file, "\t       %s queue id | enable state bitMap\n",
 378                         is_rxq ? "rx" : "tx");
 379
 380         for (i = 0; i < (nb_queues - 1) / NUM_QUEUE_PER_LINE + 1; i++) {
 381                 uint32_t line_end = (i + 1) * NUM_QUEUE_PER_LINE - 1;
 382                 uint32_t line_start = i * NUM_QUEUE_PER_LINE;
 383                 fprintf(file, "\t       %04u - %04u | ", line_start,
 384                         nb_queues - 1 > line_end ? line_end : nb_queues - 1);
 385
 386
 387                 print_queue_state_perline(file, queue_state, nb_queues, i);
 388         }
 389 }
 390
 391 static void
 392 get_rxtx_queue_enable_state(FILE *file, struct rte_eth_dev *dev)
 393 {
 394 #define MAX_TQP_NUM 1280
 395 #define QUEUE_BITMAP_SIZE (MAX_TQP_NUM / 32)
 396         struct hns3_hw *hw = HNS3_DEV_PRIVATE_TO_HW(dev->data->dev_private);
 397         uint32_t rx_queue_state[QUEUE_BITMAP_SIZE] = {0};
 398         uint32_t tx_queue_state[QUEUE_BITMAP_SIZE] = {0};
 399         uint32_t nb_rx_queues;
 400         uint32_t nb_tx_queues;
 401
 402         nb_rx_queues = dev->data->nb_rx_queues;
 403         nb_tx_queues = dev->data->nb_tx_queues;
 404
 405         fprintf(file, "\t  -- enable state:\n");
 406         get_queue_enable_state(hw, rx_queue_state, nb_rx_queues, true);
 407         display_queue_enable_state(file, rx_queue_state, nb_rx_queues,
 408                                          true);
 409
 410         get_queue_enable_state(hw, tx_queue_state, nb_tx_queues, false);
 411         display_queue_enable_state(file, tx_queue_state, nb_tx_queues,
 412                                          false);
 413 }
 414
 415 static void
 416 get_rxtx_queue_info(FILE *file, struct rte_eth_dev *dev)
 417 {
 418         struct hns3_rx_queue *rxq;
 419         struct hns3_tx_queue *txq;
 420
 421         rxq = get_rx_queue(dev);
 422         if (rxq == NULL)
 423                 return;
 424         txq = get_tx_queue(dev);
 425         if (txq == NULL)
 426                 return;
 427         fprintf(file, "  - Rx/Tx Queue Info:\n");
 428         fprintf(file,
 429                 "\t  -- first queue rxtx info:\n"
 430                 "\t       Rx: port=%u nb_desc=%u free_thresh=%u\n"
 431                 "\t       Tx: port=%u nb_desc=%u\n"
 432                 "\t  -- tx push: %s\n",
 433                 rxq->port_id, rxq->nb_rx_desc, rxq->rx_free_thresh,
 434                 txq->port_id, txq->nb_tx_desc,
 435                 txq->tx_push_enable ? "enabled" : "disabled");
 436
 437         get_rxtx_fake_queue_info(file, dev);
 438         get_rxtx_queue_enable_state(file, dev);
 439 }
 440
 441 static int
 442 get_vlan_filter_cfg(FILE *file, struct hns3_hw *hw)
 443 {
 444 #define HNS3_FILTER_TYPE_VF             0
 445 #define HNS3_FILTER_TYPE_PORT           1
 446 #define HNS3_FILTER_FE_NIC_INGRESS_B    BIT(0)
 447 #define HNS3_FILTER_FE_NIC_EGRESS_B     BIT(1)
 448         struct hns3_vlan_filter_ctrl_cmd *req;
 449         struct hns3_cmd_desc desc;
 450         uint8_t i;
 451         int ret;
 452
 453         static const uint32_t vlan_filter_type[] = {
 454                 HNS3_FILTER_TYPE_PORT,
 455                 HNS3_FILTER_TYPE_VF
 456         };
 457
 458         for (i = 0; i < RTE_DIM(vlan_filter_type); i++) {
 459                 hns3_cmd_setup_basic_desc(&desc, HNS3_OPC_VLAN_FILTER_CTRL,
 460                                                 true);
 461                 req = (struct hns3_vlan_filter_ctrl_cmd *)desc.data;
 462                 req->vlan_type = vlan_filter_type[i];
 463                 req->vf_id = HNS3_PF_FUNC_ID;
 464                 ret = hns3_cmd_send(hw, &desc, 1);
 465                 if (ret != 0) {
 466                         hns3_err(hw,
 467                                 "NIC IMP exec ret=%d desc_num=%d optcode=0x%x!",
 468                                 ret, 1, rte_le_to_cpu_16(desc.opcode));
 469                         return ret;
 470                 }
 471                 fprintf(file,
 472                         "\t  -- %s VLAN filter configuration\n"
 473                         "\t       nic_ingress           :%s\n"
 474                         "\t       nic_egress            :%s\n",
 475                         req->vlan_type == HNS3_FILTER_TYPE_PORT ?
 476                         "Port" : "VF",
 477                         req->vlan_fe & HNS3_FILTER_FE_NIC_INGRESS_B ?
 478                         "Enable" : "Disable",
 479                         req->vlan_fe & HNS3_FILTER_FE_NIC_EGRESS_B ?
 480                         "Enable" : "Disable");
 481         }
 482
 483         return 0;
 484 }
 485
 486 static int
 487 get_vlan_rx_offload_cfg(FILE *file, struct hns3_hw *hw)
 488 {
 489         struct hns3_vport_vtag_rx_cfg_cmd *req;
 490         struct hns3_cmd_desc desc;
 491         uint16_t vport_id;
 492         uint8_t bitmap;
 493         int ret;
 494
 495         hns3_cmd_setup_basic_desc(&desc, HNS3_OPC_VLAN_PORT_RX_CFG, true);
 496         req = (struct hns3_vport_vtag_rx_cfg_cmd *)desc.data;
 497         vport_id = HNS3_PF_FUNC_ID;
 498         req->vf_offset = vport_id / HNS3_VF_NUM_PER_CMD;
 499         bitmap = 1 << (vport_id % HNS3_VF_NUM_PER_BYTE);
 500         req->vf_bitmap[req->vf_offset] = bitmap;
 501
 502         /*
 503          * current version VF is not supported when PF is driven by DPDK driver,
 504          * just need to configure rx parameters for PF vport.
 505          */
 506         ret = hns3_cmd_send(hw, &desc, 1);
 507         if (ret != 0) {
 508                 hns3_err(hw,
 509                         "NIC IMP exec ret=%d desc_num=%d optcode=0x%x!",
 510                         ret, 1, rte_le_to_cpu_16(desc.opcode));
 511                 return ret;
 512         }
 513
 514         fprintf(file,
 515                 "\t  -- RX VLAN configuration\n"
 516                 "\t       vlan1_strip_en        :%s\n"
 517                 "\t       vlan2_strip_en        :%s\n"
 518                 "\t       vlan1_vlan_prionly    :%s\n"
 519                 "\t       vlan2_vlan_prionly    :%s\n"
 520                 "\t       vlan1_strip_discard   :%s\n"
 521                 "\t       vlan2_strip_discard   :%s\n",
 522                 hns3_get_bit(req->vport_vlan_cfg,
 523                         HNS3_REM_TAG1_EN_B) ? "Enable" : "Disable",
 524                 hns3_get_bit(req->vport_vlan_cfg,
 525                         HNS3_REM_TAG2_EN_B) ? "Enable" : "Disable",
 526                 hns3_get_bit(req->vport_vlan_cfg,
 527                         HNS3_SHOW_TAG1_EN_B) ? "Enable" : "Disable",
 528                 hns3_get_bit(req->vport_vlan_cfg,
 529                         HNS3_SHOW_TAG2_EN_B) ? "Enable" : "Disable",
 530                 hns3_get_bit(req->vport_vlan_cfg,
 531                         HNS3_DISCARD_TAG1_EN_B) ? "Enable" : "Disable",
 532                 hns3_get_bit(req->vport_vlan_cfg,
 533                         HNS3_DISCARD_TAG2_EN_B) ? "Enable" : "Disable");
 534
 535         return 0;
 536 }
 537
 538 static void
 539 parse_tx_vlan_cfg(FILE *file, struct hns3_vport_vtag_tx_cfg_cmd *req)
 540 {
 541 #define VLAN_VID_MASK 0x0fff
 542 #define VLAN_PRIO_SHIFT 13
 543
 544         fprintf(file,
 545                 "\t  -- TX VLAN configuration\n"
 546                 "\t       accept_tag1           :%s\n"
 547                 "\t       accept_untag1         :%s\n"
 548                 "\t       insert_tag1_en        :%s\n"
 549                 "\t       default_vlan_tag1 = %d, qos = %d\n"
 550                 "\t       accept_tag2           :%s\n"
 551                 "\t       accept_untag2         :%s\n"
 552                 "\t       insert_tag2_en        :%s\n"
 553                 "\t       default_vlan_tag2 = %d, qos = %d\n"
 554                 "\t       vlan_shift_mode       :%s\n",
 555                 hns3_get_bit(req->vport_vlan_cfg,
 556                         HNS3_ACCEPT_TAG1_B) ? "Enable" : "Disable",
 557                 hns3_get_bit(req->vport_vlan_cfg,
 558                         HNS3_ACCEPT_UNTAG1_B) ? "Enable" : "Disable",
 559                 hns3_get_bit(req->vport_vlan_cfg,
 560                         HNS3_PORT_INS_TAG1_EN_B) ? "Enable" : "Disable",
 561                 req->def_vlan_tag1 & VLAN_VID_MASK,
 562                 req->def_vlan_tag1 >> VLAN_PRIO_SHIFT,
 563                 hns3_get_bit(req->vport_vlan_cfg,
 564                         HNS3_ACCEPT_TAG2_B) ? "Enable" : "Disable",
 565                 hns3_get_bit(req->vport_vlan_cfg,
 566                         HNS3_ACCEPT_UNTAG2_B) ? "Enable" : "Disable",
 567                 hns3_get_bit(req->vport_vlan_cfg,
 568                         HNS3_PORT_INS_TAG2_EN_B) ? "Enable" : "Disable",
 569                 req->def_vlan_tag2 & VLAN_VID_MASK,
 570                 req->def_vlan_tag2 >> VLAN_PRIO_SHIFT,
 571                 hns3_get_bit(req->vport_vlan_cfg,
 572                         HNS3_TAG_SHIFT_MODE_EN_B) ? "Enable" :
 573                         "Disable");
 574 }
 575
 576 static int
 577 get_vlan_tx_offload_cfg(FILE *file, struct hns3_hw *hw)
 578 {
 579         struct hns3_vport_vtag_tx_cfg_cmd *req;
 580         struct hns3_cmd_desc desc;
 581         uint16_t vport_id;
 582         uint8_t bitmap;
 583         int ret;
 584
 585         hns3_cmd_setup_basic_desc(&desc, HNS3_OPC_VLAN_PORT_TX_CFG, true);
 586         req = (struct hns3_vport_vtag_tx_cfg_cmd *)desc.data;
 587         vport_id = HNS3_PF_FUNC_ID;
 588         req->vf_offset = vport_id / HNS3_VF_NUM_PER_CMD;
 589         bitmap = 1 << (vport_id % HNS3_VF_NUM_PER_BYTE);
 590         req->vf_bitmap[req->vf_offset] = bitmap;
 591         /*
 592          * current version VF is not supported when PF is driven by DPDK driver,
 593          * just need to configure tx parameters for PF vport.
 594          */
 595         ret = hns3_cmd_send(hw, &desc, 1);
 596         if (ret != 0) {
 597                 hns3_err(hw,
 598                         "NIC IMP exec ret=%d desc_num=%d optcode=0x%x!",
 599                         ret, 1, rte_le_to_cpu_16(desc.opcode));
 600                 return ret;
 601         }
 602
 603         parse_tx_vlan_cfg(file, req);
 604
 605         return 0;
 606 }
 607
 608 static void
 609 get_port_pvid_info(FILE *file, struct hns3_hw *hw)
 610 {
 611         fprintf(file, "\t  -- pvid status: %s\n",
 612                 hw->port_base_vlan_cfg.state ? "on" : "off");
 613 }
 614
 615 static void
 616 get_vlan_config_info(FILE *file, struct hns3_hw *hw)
 617 {
 618         int ret;
 619
 620         fprintf(file, "  - VLAN Config Info:\n");
 621         ret = get_vlan_filter_cfg(file, hw);
 622         if (ret < 0)
 623                 return;
 624
 625         ret = get_vlan_rx_offload_cfg(file, hw);
 626         if (ret < 0)
 627                 return;
 628
 629         ret = get_vlan_tx_offload_cfg(file, hw);
 630         if (ret < 0)
 631                 return;
 632
 633         get_port_pvid_info(file, hw);
 634 }
 635
 636 static void
 637 get_tm_conf_shaper_info(FILE *file, struct hns3_tm_conf *conf)
 638 {
 639         struct hns3_shaper_profile_list *shaper_profile_list =
 640                 &conf->shaper_profile_list;
 641         struct hns3_tm_shaper_profile *shaper_profile;
 642
 643         if (!conf->nb_shaper_profile)
 644                 return;
 645
 646         fprintf(file, "  shaper_profile:\n");
 647         TAILQ_FOREACH(shaper_profile, shaper_profile_list, node) {
 648                 fprintf(file,
 649                         "    id=%u reference_count=%u peak_rate=%" PRIu64 "Bps\n",
 650                         shaper_profile->shaper_profile_id,
 651                         shaper_profile->reference_count,
 652                         shaper_profile->profile.peak.rate);
 653         }
 654 }
 655
 656 static void
 657 get_tm_conf_port_node_info(FILE *file, struct hns3_tm_conf *conf)
 658 {
 659         if (!conf->root)
 660                 return;
 661
 662         fprintf(file,
 663                 "  port_node:\n"
 664                 "    node_id=%u reference_count=%u shaper_profile_id=%d\n",
 665                 conf->root->id, conf->root->reference_count,
 666                 conf->root->shaper_profile ?
 667                 (int)conf->root->shaper_profile->shaper_profile_id : -1);
 668 }
 669
 670 static void
 671 get_tm_conf_tc_node_info(FILE *file, struct hns3_tm_conf *conf)
 672 {
 673         struct hns3_tm_node_list *tc_list = &conf->tc_list;
 674         struct hns3_tm_node *tc_node[HNS3_MAX_TC_NUM];
 675         struct hns3_tm_node *tm_node;
 676         uint32_t tidx;
 677
 678         if (!conf->nb_tc_node)
 679                 return;
 680
 681         fprintf(file, "  tc_node:\n");
 682         memset(tc_node, 0, sizeof(tc_node));
 683         TAILQ_FOREACH(tm_node, tc_list, node) {
 684                 tidx = hns3_tm_calc_node_tc_no(conf, tm_node->id);
 685                 if (tidx < HNS3_MAX_TC_NUM)
 686                         tc_node[tidx] = tm_node;
 687         }
 688
 689         for (tidx = 0; tidx < HNS3_MAX_TC_NUM; tidx++) {
 690                 tm_node = tc_node[tidx];
 691                 if (tm_node == NULL)
 692                         continue;
 693                 fprintf(file,
 694                         "    id=%u TC%u reference_count=%u parent_id=%d "
 695                         "shaper_profile_id=%d\n",
 696                         tm_node->id, hns3_tm_calc_node_tc_no(conf, tm_node->id),
 697                         tm_node->reference_count,
 698                         tm_node->parent ? (int)tm_node->parent->id : -1,
 699                         tm_node->shaper_profile ?
 700                         (int)tm_node->shaper_profile->shaper_profile_id : -1);
 701         }
 702 }
 703
 704 static void
 705 get_tm_conf_queue_format_info(FILE *file, struct hns3_tm_node **queue_node,
 706                               uint32_t *queue_node_tc,  uint32_t nb_tx_queues)
 707 {
 708 #define PERLINE_QUEUES  32
 709 #define PERLINE_STRIDE  8
 710 #define LINE_BUF_SIZE   1024
 711         uint32_t i, j, line_num, start_queue, end_queue;
 712         char tmpbuf[LINE_BUF_SIZE] = {0};
 713
 714         line_num = (nb_tx_queues + PERLINE_QUEUES - 1) / PERLINE_QUEUES;
 715         for (i = 0; i < line_num; i++) {
 716                 start_queue = i * PERLINE_QUEUES;
 717                 end_queue = (i + 1) * PERLINE_QUEUES - 1;
 718                 if (end_queue > nb_tx_queues - 1)
 719                         end_queue = nb_tx_queues - 1;
 720                 fprintf(file, "    %04u - %04u | ", start_queue, end_queue);
 721                 for (j = start_queue; j < nb_tx_queues; j++) {
 722                         if (j >= end_queue + 1)
 723                                 break;
 724                         if (j > start_queue && j % PERLINE_STRIDE == 0)
 725                                 fprintf(file, ":");
 726                         fprintf(file, "%u",
 727                                 queue_node[j] ? queue_node_tc[j] :
 728                                 HNS3_MAX_TC_NUM);
 729                 }
 730                 fprintf(file, "%s\n", tmpbuf);
 731         }
 732 }
 733
 734 static void
 735 get_tm_conf_queue_node_info(FILE *file, struct hns3_tm_conf *conf,
 736                             uint32_t nb_tx_queues)
 737 {
 738         struct hns3_tm_node_list *queue_list = &conf->queue_list;
 739         uint32_t nb_queue_node = conf->nb_leaf_nodes_max + 1;
 740         struct hns3_tm_node *queue_node[nb_queue_node];
 741         uint32_t queue_node_tc[nb_queue_node];
 742         struct hns3_tm_node *tm_node;
 743
 744         if (!conf->nb_queue_node)
 745                 return;
 746
 747         fprintf(file,
 748                 "  queue_node:\n"
 749                 "    tx queue id | mapped tc (8 mean node not exist)\n");
 750
 751         memset(queue_node, 0, sizeof(queue_node));
 752         memset(queue_node_tc, 0, sizeof(queue_node_tc));
 753         nb_tx_queues = RTE_MIN(nb_tx_queues, nb_queue_node);
 754         TAILQ_FOREACH(tm_node, queue_list, node) {
 755                 if (tm_node->id >= nb_queue_node)
 756                         continue;
 757                 queue_node[tm_node->id] = tm_node;
 758                 queue_node_tc[tm_node->id] = tm_node->parent ?
 759                         hns3_tm_calc_node_tc_no(conf, tm_node->parent->id) : 0;
 760                 nb_tx_queues = RTE_MAX(nb_tx_queues, tm_node->id + 1);
 761         }
 762
 763         get_tm_conf_queue_format_info(file, queue_node, queue_node_tc,
 764                                       nb_tx_queues);
 765 }
 766
 767 static void
 768 get_tm_conf_info(FILE *file, struct rte_eth_dev *dev)
 769 {
 770         struct hns3_pf *pf = HNS3_DEV_PRIVATE_TO_PF(dev->data->dev_private);
 771         struct hns3_tm_conf *conf = &pf->tm_conf;
 772
 773         fprintf(file, "  - TM config info:\n");
 774         fprintf(file,
 775                 "\t  -- nb_leaf_nodes_max=%u nb_nodes_max=%u\n"
 776                 "\t  -- nb_shaper_profile=%u nb_tc_node=%u nb_queue_node=%u\n"
 777                 "\t  -- committed=%u\n",
 778                 conf->nb_leaf_nodes_max, conf->nb_nodes_max,
 779                 conf->nb_shaper_profile, conf->nb_tc_node, conf->nb_queue_node,
 780                 conf->committed);
 781
 782         get_tm_conf_shaper_info(file, conf);
 783         get_tm_conf_port_node_info(file, conf);
 784         get_tm_conf_tc_node_info(file, conf);
 785         get_tm_conf_queue_node_info(file, conf, dev->data->nb_tx_queues);
 786 }
 787
 788 static void
 789 hns3_fc_mode_to_rxtx_pause(enum hns3_fc_mode fc_mode, bool *rx_pause,
 790                            bool *tx_pause)
 791 {
 792         switch (fc_mode) {
 793         case HNS3_FC_NONE:
 794                 *tx_pause = false;
 795                 *rx_pause = false;
 796                 break;
 797         case HNS3_FC_RX_PAUSE:
 798                 *rx_pause = true;
 799                 *tx_pause = false;
 800                 break;
 801         case HNS3_FC_TX_PAUSE:
 802                 *rx_pause = false;
 803                 *tx_pause = true;
 804                 break;
 805         case HNS3_FC_FULL:
 806                 *rx_pause = true;
 807                 *tx_pause = true;
 808                 break;
 809         default:
 810                 *rx_pause = false;
 811                 *tx_pause = false;
 812                 break;
 813         }
 814 }
 815
 816 static bool
 817 is_link_fc_mode(struct hns3_adapter *hns)
 818 {
 819         struct hns3_hw *hw = &hns->hw;
 820         struct hns3_pf *pf = &hns->pf;
 821
 822         if (hw->current_fc_status == HNS3_FC_STATUS_PFC)
 823                 return false;
 824
 825         if (hw->num_tc > 1 && !pf->support_multi_tc_pause)
 826                 return false;
 827
 828         return true;
 829 }
 830
 831 static void
 832 get_link_fc_info(FILE *file, struct rte_eth_dev *dev)
 833 {
 834         struct hns3_adapter *hns = dev->data->dev_private;
 835         struct hns3_hw *hw = &hns->hw;
 836         struct rte_eth_fc_conf fc_conf;
 837         bool rx_pause1;
 838         bool tx_pause1;
 839         bool rx_pause2;
 840         bool tx_pause2;
 841         int ret;
 842
 843         if (!is_link_fc_mode(hns))
 844                 return;
 845
 846         ret = hns3_flow_ctrl_get(dev, &fc_conf);
 847         if (ret)  {
 848                 fprintf(file, "get device flow control info fail!\n");
 849                 return;
 850         }
 851
 852         hns3_fc_mode_to_rxtx_pause(hw->requested_fc_mode,
 853                                    &rx_pause1, &tx_pause1);
 854         hns3_fc_mode_to_rxtx_pause((enum hns3_fc_mode)fc_conf.mode,
 855                                    &rx_pause2, &tx_pause2);
 856
 857         fprintf(file,
 858                 "\t  -- link_fc_info:\n"
 859                 "\t       Requested fc:\n"
 860                 "\t         Rx: %s\n"
 861                 "\t         Tx: %s\n"
 862                 "\t       Current fc:\n"
 863                 "\t         Rx: %s\n"
 864                 "\t         Tx: %s\n"
 865                 "\t       Autonegotiate: %s\n"
 866                 "\t       Pause time:   0x%x\n",
 867                 rx_pause1 ? "On" : "Off", tx_pause1 ? "On" : "Off",
 868                 rx_pause2 ? "On" : "Off", tx_pause2 ? "On" : "Off",
 869                 fc_conf.autoneg == RTE_ETH_LINK_AUTONEG ? "On" : "Off",
 870                 fc_conf.pause_time);
 871 }
 872
 873 static void
 874 get_flow_ctrl_info(FILE *file, struct rte_eth_dev *dev)
 875 {
 876         struct hns3_adapter *hns = dev->data->dev_private;
 877         struct hns3_hw *hw = &hns->hw;
 878
 879         fprintf(file, "  - Flow Ctrl Info:\n");
 880         fprintf(file,
 881                 "\t  -- fc_common_info:\n"
 882                 "\t       current_fc_status=%u\n"
 883                 "\t       requested_fc_mode=%u\n",
 884                 hw->current_fc_status,
 885                 hw->requested_fc_mode);
 886
 887         get_link_fc_info(file, dev);
 888 }
 889
 890 int
 891 hns3_eth_dev_priv_dump(struct rte_eth_dev *dev, FILE *file)
 892 {
 893         struct hns3_adapter *hns = dev->data->dev_private;
 894         struct hns3_hw *hw = &hns->hw;
 895
 896         get_device_basic_info(file, dev);
 897         get_dev_feature_capability(file, hw);
 898
 899         /* VF only supports dumping basic info and feaure capability */
 900         if (hns->is_vf)
 901                 return 0;
 902
 903         get_dev_mac_info(file, hns);
 904         get_rxtx_queue_info(file, dev);
 905         get_vlan_config_info(file, hw);
 906         get_fdir_basic_info(file, &hns->pf);
 907         get_tm_conf_info(file, dev);
 908         get_flow_ctrl_info(file, dev);
 909
 910         return 0;
 911 }