13c666b58Sliuzhongzhu // SPDX-License-Identifier: GPL-2.0+ 23c666b58Sliuzhongzhu /* Copyright (c) 2018-2019 Hisilicon Limited. */ 33c666b58Sliuzhongzhu 43c666b58Sliuzhongzhu #include <linux/device.h> 53c666b58Sliuzhongzhu 66fc22440Sliuzhongzhu #include "hclge_debugfs.h" 71a7ff828SJiaran Zhang #include "hclge_err.h" 83c666b58Sliuzhongzhu #include "hclge_main.h" 92849d4e7Sliuzhongzhu #include "hclge_tm.h" 103c666b58Sliuzhongzhu #include "hnae3.h" 113c666b58Sliuzhongzhu 12d658ff34SYufeng Mo static const char * const state_str[] = { "off", "on" }; 131556ea91SHuazhong Tan static const char * const hclge_mac_state_str[] = { 141556ea91SHuazhong Tan "TO_ADD", "TO_DEL", "ACTIVE" 151556ea91SHuazhong Tan }; 161556ea91SHuazhong Tan 17e4b91468SRikard Falkeborn static const struct hclge_dbg_reg_type_info hclge_dbg_reg_info[] = { 18d96b0e59SYufeng Mo { .cmd = HNAE3_DBG_CMD_REG_BIOS_COMMON, 19a582b78dSZhongzhu Liu .dfx_msg = &hclge_dbg_bios_common_reg[0], 20a582b78dSZhongzhu Liu .reg_msg = { .msg_num = ARRAY_SIZE(hclge_dbg_bios_common_reg), 21a582b78dSZhongzhu Liu .offset = HCLGE_DBG_DFX_BIOS_OFFSET, 22a582b78dSZhongzhu Liu .cmd = HCLGE_OPC_DFX_BIOS_COMMON_REG } }, 23d96b0e59SYufeng Mo { .cmd = HNAE3_DBG_CMD_REG_SSU, 24a582b78dSZhongzhu Liu .dfx_msg = &hclge_dbg_ssu_reg_0[0], 25a582b78dSZhongzhu Liu .reg_msg = { .msg_num = ARRAY_SIZE(hclge_dbg_ssu_reg_0), 26a582b78dSZhongzhu Liu .offset = HCLGE_DBG_DFX_SSU_0_OFFSET, 27a582b78dSZhongzhu Liu .cmd = HCLGE_OPC_DFX_SSU_REG_0 } }, 28d96b0e59SYufeng Mo { .cmd = HNAE3_DBG_CMD_REG_SSU, 29a582b78dSZhongzhu Liu .dfx_msg = &hclge_dbg_ssu_reg_1[0], 30a582b78dSZhongzhu Liu .reg_msg = { .msg_num = ARRAY_SIZE(hclge_dbg_ssu_reg_1), 31a582b78dSZhongzhu Liu .offset = HCLGE_DBG_DFX_SSU_1_OFFSET, 32a582b78dSZhongzhu Liu .cmd = HCLGE_OPC_DFX_SSU_REG_1 } }, 33d96b0e59SYufeng Mo { .cmd = HNAE3_DBG_CMD_REG_SSU, 34a582b78dSZhongzhu Liu .dfx_msg = &hclge_dbg_ssu_reg_2[0], 35a582b78dSZhongzhu Liu .reg_msg = { .msg_num = ARRAY_SIZE(hclge_dbg_ssu_reg_2), 36a582b78dSZhongzhu Liu .offset = HCLGE_DBG_DFX_SSU_2_OFFSET, 37a582b78dSZhongzhu Liu .cmd = HCLGE_OPC_DFX_SSU_REG_2 } }, 38d96b0e59SYufeng Mo { .cmd = HNAE3_DBG_CMD_REG_IGU_EGU, 39a582b78dSZhongzhu Liu .dfx_msg = &hclge_dbg_igu_egu_reg[0], 40a582b78dSZhongzhu Liu .reg_msg = { .msg_num = ARRAY_SIZE(hclge_dbg_igu_egu_reg), 41a582b78dSZhongzhu Liu .offset = HCLGE_DBG_DFX_IGU_OFFSET, 42a582b78dSZhongzhu Liu .cmd = HCLGE_OPC_DFX_IGU_EGU_REG } }, 43d96b0e59SYufeng Mo { .cmd = HNAE3_DBG_CMD_REG_RPU, 44a582b78dSZhongzhu Liu .dfx_msg = &hclge_dbg_rpu_reg_0[0], 45a582b78dSZhongzhu Liu .reg_msg = { .msg_num = ARRAY_SIZE(hclge_dbg_rpu_reg_0), 46a582b78dSZhongzhu Liu .offset = HCLGE_DBG_DFX_RPU_0_OFFSET, 47a582b78dSZhongzhu Liu .cmd = HCLGE_OPC_DFX_RPU_REG_0 } }, 48d96b0e59SYufeng Mo { .cmd = HNAE3_DBG_CMD_REG_RPU, 49a582b78dSZhongzhu Liu .dfx_msg = &hclge_dbg_rpu_reg_1[0], 50a582b78dSZhongzhu Liu .reg_msg = { .msg_num = ARRAY_SIZE(hclge_dbg_rpu_reg_1), 51a582b78dSZhongzhu Liu .offset = HCLGE_DBG_DFX_RPU_1_OFFSET, 52a582b78dSZhongzhu Liu .cmd = HCLGE_OPC_DFX_RPU_REG_1 } }, 53d96b0e59SYufeng Mo { .cmd = HNAE3_DBG_CMD_REG_NCSI, 54a582b78dSZhongzhu Liu .dfx_msg = &hclge_dbg_ncsi_reg[0], 55a582b78dSZhongzhu Liu .reg_msg = { .msg_num = ARRAY_SIZE(hclge_dbg_ncsi_reg), 56a582b78dSZhongzhu Liu .offset = HCLGE_DBG_DFX_NCSI_OFFSET, 57a582b78dSZhongzhu Liu .cmd = HCLGE_OPC_DFX_NCSI_REG } }, 58d96b0e59SYufeng Mo { .cmd = HNAE3_DBG_CMD_REG_RTC, 59a582b78dSZhongzhu Liu .dfx_msg = &hclge_dbg_rtc_reg[0], 60a582b78dSZhongzhu Liu .reg_msg = { .msg_num = ARRAY_SIZE(hclge_dbg_rtc_reg), 61a582b78dSZhongzhu Liu .offset = HCLGE_DBG_DFX_RTC_OFFSET, 62a582b78dSZhongzhu Liu .cmd = HCLGE_OPC_DFX_RTC_REG } }, 63d96b0e59SYufeng Mo { .cmd = HNAE3_DBG_CMD_REG_PPP, 64a582b78dSZhongzhu Liu .dfx_msg = &hclge_dbg_ppp_reg[0], 65a582b78dSZhongzhu Liu .reg_msg = { .msg_num = ARRAY_SIZE(hclge_dbg_ppp_reg), 66a582b78dSZhongzhu Liu .offset = HCLGE_DBG_DFX_PPP_OFFSET, 67a582b78dSZhongzhu Liu .cmd = HCLGE_OPC_DFX_PPP_REG } }, 68d96b0e59SYufeng Mo { .cmd = HNAE3_DBG_CMD_REG_RCB, 69a582b78dSZhongzhu Liu .dfx_msg = &hclge_dbg_rcb_reg[0], 70a582b78dSZhongzhu Liu .reg_msg = { .msg_num = ARRAY_SIZE(hclge_dbg_rcb_reg), 71a582b78dSZhongzhu Liu .offset = HCLGE_DBG_DFX_RCB_OFFSET, 72a582b78dSZhongzhu Liu .cmd = HCLGE_OPC_DFX_RCB_REG } }, 73d96b0e59SYufeng Mo { .cmd = HNAE3_DBG_CMD_REG_TQP, 74a582b78dSZhongzhu Liu .dfx_msg = &hclge_dbg_tqp_reg[0], 75a582b78dSZhongzhu Liu .reg_msg = { .msg_num = ARRAY_SIZE(hclge_dbg_tqp_reg), 76a582b78dSZhongzhu Liu .offset = HCLGE_DBG_DFX_TQP_OFFSET, 77a582b78dSZhongzhu Liu .cmd = HCLGE_OPC_DFX_TQP_REG } }, 78a582b78dSZhongzhu Liu }; 79a582b78dSZhongzhu Liu 801556ea91SHuazhong Tan static void hclge_dbg_fill_content(char *content, u16 len, 811556ea91SHuazhong Tan const struct hclge_dbg_item *items, 821556ea91SHuazhong Tan const char **result, u16 size) 831556ea91SHuazhong Tan { 841556ea91SHuazhong Tan char *pos = content; 851556ea91SHuazhong Tan u16 i; 861556ea91SHuazhong Tan 871556ea91SHuazhong Tan memset(content, ' ', len); 881556ea91SHuazhong Tan for (i = 0; i < size; i++) { 891556ea91SHuazhong Tan if (result) 901556ea91SHuazhong Tan strncpy(pos, result[i], strlen(result[i])); 911556ea91SHuazhong Tan else 921556ea91SHuazhong Tan strncpy(pos, items[i].name, strlen(items[i].name)); 931556ea91SHuazhong Tan pos += strlen(items[i].name) + items[i].interval; 941556ea91SHuazhong Tan } 951556ea91SHuazhong Tan *pos++ = '\n'; 961556ea91SHuazhong Tan *pos++ = '\0'; 971556ea91SHuazhong Tan } 981556ea91SHuazhong Tan 991556ea91SHuazhong Tan static char *hclge_dbg_get_func_id_str(char *buf, u8 id) 1001556ea91SHuazhong Tan { 1011556ea91SHuazhong Tan if (id) 1021556ea91SHuazhong Tan sprintf(buf, "vf%u", id - 1); 1031556ea91SHuazhong Tan else 1041556ea91SHuazhong Tan sprintf(buf, "pf"); 1051556ea91SHuazhong Tan 1061556ea91SHuazhong Tan return buf; 1071556ea91SHuazhong Tan } 1081556ea91SHuazhong Tan 109d96b0e59SYufeng Mo static int hclge_dbg_get_dfx_bd_num(struct hclge_dev *hdev, int offset, 110d96b0e59SYufeng Mo u32 *bd_num) 11127cf979aSliuzhongzhu { 112a582b78dSZhongzhu Liu struct hclge_desc desc[HCLGE_GET_DFX_REG_TYPE_CNT]; 113a582b78dSZhongzhu Liu int entries_per_desc; 114a582b78dSZhongzhu Liu int index; 11527cf979aSliuzhongzhu int ret; 11627cf979aSliuzhongzhu 117ddb54554SGuangbin Huang ret = hclge_query_bd_num_cmd_send(hdev, desc); 118ddb54554SGuangbin Huang if (ret) { 11927cf979aSliuzhongzhu dev_err(&hdev->pdev->dev, 120d96b0e59SYufeng Mo "failed to get dfx bd_num, offset = %d, ret = %d\n", 121d96b0e59SYufeng Mo offset, ret); 12227cf979aSliuzhongzhu return ret; 12327cf979aSliuzhongzhu } 12427cf979aSliuzhongzhu 125a582b78dSZhongzhu Liu entries_per_desc = ARRAY_SIZE(desc[0].data); 126a582b78dSZhongzhu Liu index = offset % entries_per_desc; 127d96b0e59SYufeng Mo 128d96b0e59SYufeng Mo *bd_num = le32_to_cpu(desc[offset / entries_per_desc].data[index]); 129d96b0e59SYufeng Mo if (!(*bd_num)) { 130d96b0e59SYufeng Mo dev_err(&hdev->pdev->dev, "The value of dfx bd_num is 0!\n"); 131d96b0e59SYufeng Mo return -EINVAL; 132d96b0e59SYufeng Mo } 133d96b0e59SYufeng Mo 134d96b0e59SYufeng Mo return 0; 13527cf979aSliuzhongzhu } 13627cf979aSliuzhongzhu 13727cf979aSliuzhongzhu static int hclge_dbg_cmd_send(struct hclge_dev *hdev, 13827cf979aSliuzhongzhu struct hclge_desc *desc_src, 13927cf979aSliuzhongzhu int index, int bd_num, 14027cf979aSliuzhongzhu enum hclge_opcode_type cmd) 14127cf979aSliuzhongzhu { 14227cf979aSliuzhongzhu struct hclge_desc *desc = desc_src; 14327cf979aSliuzhongzhu int ret, i; 14427cf979aSliuzhongzhu 14527cf979aSliuzhongzhu hclge_cmd_setup_basic_desc(desc, cmd, true); 14627cf979aSliuzhongzhu desc->data[0] = cpu_to_le32(index); 14727cf979aSliuzhongzhu 14827cf979aSliuzhongzhu for (i = 1; i < bd_num; i++) { 14927cf979aSliuzhongzhu desc->flag |= cpu_to_le16(HCLGE_CMD_FLAG_NEXT); 15027cf979aSliuzhongzhu desc++; 15127cf979aSliuzhongzhu hclge_cmd_setup_basic_desc(desc, cmd, true); 15227cf979aSliuzhongzhu } 15327cf979aSliuzhongzhu 15427cf979aSliuzhongzhu ret = hclge_cmd_send(&hdev->hw, desc_src, bd_num); 155ed5b255bSYufeng Mo if (ret) 15627cf979aSliuzhongzhu dev_err(&hdev->pdev->dev, 157ed5b255bSYufeng Mo "cmd(0x%x) send fail, ret = %d\n", cmd, ret); 15827cf979aSliuzhongzhu return ret; 15927cf979aSliuzhongzhu } 16027cf979aSliuzhongzhu 161d96b0e59SYufeng Mo static int 162d96b0e59SYufeng Mo hclge_dbg_dump_reg_tqp(struct hclge_dev *hdev, 163e4b91468SRikard Falkeborn const struct hclge_dbg_reg_type_info *reg_info, 164d96b0e59SYufeng Mo char *buf, int len, int *pos) 16527cf979aSliuzhongzhu { 166e4b91468SRikard Falkeborn const struct hclge_dbg_dfx_message *dfx_message = reg_info->dfx_msg; 167e4b91468SRikard Falkeborn const struct hclge_dbg_reg_common_msg *reg_msg = ®_info->reg_msg; 16827cf979aSliuzhongzhu struct hclge_desc *desc_src; 169d96b0e59SYufeng Mo u32 index, entry, i, cnt; 170d96b0e59SYufeng Mo int bd_num, min_num, ret; 17127cf979aSliuzhongzhu struct hclge_desc *desc; 17227cf979aSliuzhongzhu 173d96b0e59SYufeng Mo ret = hclge_dbg_get_dfx_bd_num(hdev, reg_msg->offset, &bd_num); 174d96b0e59SYufeng Mo if (ret) 175d96b0e59SYufeng Mo return ret; 17627cf979aSliuzhongzhu 177d96b0e59SYufeng Mo desc_src = kcalloc(bd_num, sizeof(struct hclge_desc), GFP_KERNEL); 178fbdc4d79SYufeng Mo if (!desc_src) 179d96b0e59SYufeng Mo return -ENOMEM; 18027cf979aSliuzhongzhu 181d96b0e59SYufeng Mo min_num = min_t(int, bd_num * HCLGE_DESC_DATA_LEN, reg_msg->msg_num); 182d96b0e59SYufeng Mo 183d96b0e59SYufeng Mo for (i = 0, cnt = 0; i < min_num; i++, dfx_message++) 184d96b0e59SYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "item%u = %s\n", 185d96b0e59SYufeng Mo cnt++, dfx_message->message); 186d96b0e59SYufeng Mo 187d96b0e59SYufeng Mo for (i = 0; i < cnt; i++) 188d96b0e59SYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "item%u\t", i); 189d96b0e59SYufeng Mo 190d96b0e59SYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "\n"); 191d96b0e59SYufeng Mo 192d96b0e59SYufeng Mo for (index = 0; index < hdev->vport[0].alloc_tqps; index++) { 193d96b0e59SYufeng Mo dfx_message = reg_info->dfx_msg; 19427cf979aSliuzhongzhu desc = desc_src; 195d96b0e59SYufeng Mo ret = hclge_dbg_cmd_send(hdev, desc, index, bd_num, 196d96b0e59SYufeng Mo reg_msg->cmd); 197d96b0e59SYufeng Mo if (ret) 198d96b0e59SYufeng Mo break; 19927cf979aSliuzhongzhu 200d96b0e59SYufeng Mo for (i = 0; i < min_num; i++, dfx_message++) { 201d96b0e59SYufeng Mo entry = i % HCLGE_DESC_DATA_LEN; 202d96b0e59SYufeng Mo if (i > 0 && !entry) 203a582b78dSZhongzhu Liu desc++; 20427cf979aSliuzhongzhu 205d96b0e59SYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "%#x\t", 206d96b0e59SYufeng Mo le32_to_cpu(desc->data[entry])); 207d96b0e59SYufeng Mo } 208d96b0e59SYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "\n"); 20927cf979aSliuzhongzhu } 21027cf979aSliuzhongzhu 21127cf979aSliuzhongzhu kfree(desc_src); 212d96b0e59SYufeng Mo return ret; 21327cf979aSliuzhongzhu } 21427cf979aSliuzhongzhu 215d96b0e59SYufeng Mo static int 216d96b0e59SYufeng Mo hclge_dbg_dump_reg_common(struct hclge_dev *hdev, 217d96b0e59SYufeng Mo const struct hclge_dbg_reg_type_info *reg_info, 218d96b0e59SYufeng Mo char *buf, int len, int *pos) 219d96b0e59SYufeng Mo { 220d96b0e59SYufeng Mo const struct hclge_dbg_reg_common_msg *reg_msg = ®_info->reg_msg; 221d96b0e59SYufeng Mo const struct hclge_dbg_dfx_message *dfx_message = reg_info->dfx_msg; 222d96b0e59SYufeng Mo struct hclge_desc *desc_src; 223d96b0e59SYufeng Mo int bd_num, min_num, ret; 224d96b0e59SYufeng Mo struct hclge_desc *desc; 225d96b0e59SYufeng Mo u32 entry, i; 226d96b0e59SYufeng Mo 227d96b0e59SYufeng Mo ret = hclge_dbg_get_dfx_bd_num(hdev, reg_msg->offset, &bd_num); 228d96b0e59SYufeng Mo if (ret) 229d96b0e59SYufeng Mo return ret; 230d96b0e59SYufeng Mo 231d96b0e59SYufeng Mo desc_src = kcalloc(bd_num, sizeof(struct hclge_desc), GFP_KERNEL); 232d96b0e59SYufeng Mo if (!desc_src) 233d96b0e59SYufeng Mo return -ENOMEM; 234d96b0e59SYufeng Mo 235d96b0e59SYufeng Mo desc = desc_src; 236d96b0e59SYufeng Mo 237d96b0e59SYufeng Mo ret = hclge_dbg_cmd_send(hdev, desc, 0, bd_num, reg_msg->cmd); 238d96b0e59SYufeng Mo if (ret) { 239d96b0e59SYufeng Mo kfree(desc); 240d96b0e59SYufeng Mo return ret; 241d96b0e59SYufeng Mo } 242d96b0e59SYufeng Mo 243d96b0e59SYufeng Mo min_num = min_t(int, bd_num * HCLGE_DESC_DATA_LEN, reg_msg->msg_num); 244d96b0e59SYufeng Mo 245d96b0e59SYufeng Mo for (i = 0; i < min_num; i++, dfx_message++) { 246d96b0e59SYufeng Mo entry = i % HCLGE_DESC_DATA_LEN; 247d96b0e59SYufeng Mo if (i > 0 && !entry) 248d96b0e59SYufeng Mo desc++; 249d96b0e59SYufeng Mo if (!dfx_message->flag) 250d96b0e59SYufeng Mo continue; 251d96b0e59SYufeng Mo 252d96b0e59SYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "%s: %#x\n", 253d96b0e59SYufeng Mo dfx_message->message, 254d96b0e59SYufeng Mo le32_to_cpu(desc->data[entry])); 255d96b0e59SYufeng Mo } 256d96b0e59SYufeng Mo 257d96b0e59SYufeng Mo kfree(desc_src); 258d96b0e59SYufeng Mo return 0; 259d96b0e59SYufeng Mo } 260d96b0e59SYufeng Mo 261d96b0e59SYufeng Mo static int hclge_dbg_dump_mac_enable_status(struct hclge_dev *hdev, char *buf, 262d96b0e59SYufeng Mo int len, int *pos) 2635cb51cfeSYufeng Mo { 2645cb51cfeSYufeng Mo struct hclge_config_mac_mode_cmd *req; 2655cb51cfeSYufeng Mo struct hclge_desc desc; 2665cb51cfeSYufeng Mo u32 loop_en; 2675cb51cfeSYufeng Mo int ret; 2685cb51cfeSYufeng Mo 2695cb51cfeSYufeng Mo hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_CONFIG_MAC_MODE, true); 2705cb51cfeSYufeng Mo 2715cb51cfeSYufeng Mo ret = hclge_cmd_send(&hdev->hw, &desc, 1); 2725cb51cfeSYufeng Mo if (ret) { 2735cb51cfeSYufeng Mo dev_err(&hdev->pdev->dev, 2745cb51cfeSYufeng Mo "failed to dump mac enable status, ret = %d\n", ret); 275d96b0e59SYufeng Mo return ret; 2765cb51cfeSYufeng Mo } 2775cb51cfeSYufeng Mo 2785cb51cfeSYufeng Mo req = (struct hclge_config_mac_mode_cmd *)desc.data; 2795cb51cfeSYufeng Mo loop_en = le32_to_cpu(req->txrx_pad_fcs_loop_en); 2805cb51cfeSYufeng Mo 281d96b0e59SYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "mac_trans_en: %#x\n", 2825cb51cfeSYufeng Mo hnae3_get_bit(loop_en, HCLGE_MAC_TX_EN_B)); 283d96b0e59SYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "mac_rcv_en: %#x\n", 2845cb51cfeSYufeng Mo hnae3_get_bit(loop_en, HCLGE_MAC_RX_EN_B)); 285d96b0e59SYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "pad_trans_en: %#x\n", 2865cb51cfeSYufeng Mo hnae3_get_bit(loop_en, HCLGE_MAC_PAD_TX_B)); 287d96b0e59SYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "pad_rcv_en: %#x\n", 2885cb51cfeSYufeng Mo hnae3_get_bit(loop_en, HCLGE_MAC_PAD_RX_B)); 289d96b0e59SYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "1588_trans_en: %#x\n", 2905cb51cfeSYufeng Mo hnae3_get_bit(loop_en, HCLGE_MAC_1588_TX_B)); 291d96b0e59SYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "1588_rcv_en: %#x\n", 2925cb51cfeSYufeng Mo hnae3_get_bit(loop_en, HCLGE_MAC_1588_RX_B)); 293d96b0e59SYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "mac_app_loop_en: %#x\n", 2945cb51cfeSYufeng Mo hnae3_get_bit(loop_en, HCLGE_MAC_APP_LP_B)); 295d96b0e59SYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "mac_line_loop_en: %#x\n", 2965cb51cfeSYufeng Mo hnae3_get_bit(loop_en, HCLGE_MAC_LINE_LP_B)); 297d96b0e59SYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "mac_fcs_tx_en: %#x\n", 2985cb51cfeSYufeng Mo hnae3_get_bit(loop_en, HCLGE_MAC_FCS_TX_B)); 299d96b0e59SYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, 300d96b0e59SYufeng Mo "mac_rx_oversize_truncate_en: %#x\n", 301d96b0e59SYufeng Mo hnae3_get_bit(loop_en, 302d96b0e59SYufeng Mo HCLGE_MAC_RX_OVERSIZE_TRUNCATE_B)); 303d96b0e59SYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "mac_rx_fcs_strip_en: %#x\n", 3045cb51cfeSYufeng Mo hnae3_get_bit(loop_en, HCLGE_MAC_RX_FCS_STRIP_B)); 305d96b0e59SYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "mac_rx_fcs_en: %#x\n", 3065cb51cfeSYufeng Mo hnae3_get_bit(loop_en, HCLGE_MAC_RX_FCS_B)); 307d96b0e59SYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, 308d96b0e59SYufeng Mo "mac_tx_under_min_err_en: %#x\n", 3095cb51cfeSYufeng Mo hnae3_get_bit(loop_en, HCLGE_MAC_TX_UNDER_MIN_ERR_B)); 310d96b0e59SYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, 311d96b0e59SYufeng Mo "mac_tx_oversize_truncate_en: %#x\n", 312d96b0e59SYufeng Mo hnae3_get_bit(loop_en, 313d96b0e59SYufeng Mo HCLGE_MAC_TX_OVERSIZE_TRUNCATE_B)); 314d96b0e59SYufeng Mo 315d96b0e59SYufeng Mo return 0; 3165cb51cfeSYufeng Mo } 3175cb51cfeSYufeng Mo 318d96b0e59SYufeng Mo static int hclge_dbg_dump_mac_frame_size(struct hclge_dev *hdev, char *buf, 319d96b0e59SYufeng Mo int len, int *pos) 3205cb51cfeSYufeng Mo { 3215cb51cfeSYufeng Mo struct hclge_config_max_frm_size_cmd *req; 3225cb51cfeSYufeng Mo struct hclge_desc desc; 3235cb51cfeSYufeng Mo int ret; 3245cb51cfeSYufeng Mo 3255cb51cfeSYufeng Mo hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_CONFIG_MAX_FRM_SIZE, true); 3265cb51cfeSYufeng Mo 3275cb51cfeSYufeng Mo ret = hclge_cmd_send(&hdev->hw, &desc, 1); 3285cb51cfeSYufeng Mo if (ret) { 3295cb51cfeSYufeng Mo dev_err(&hdev->pdev->dev, 3305cb51cfeSYufeng Mo "failed to dump mac frame size, ret = %d\n", ret); 331d96b0e59SYufeng Mo return ret; 3325cb51cfeSYufeng Mo } 3335cb51cfeSYufeng Mo 3345cb51cfeSYufeng Mo req = (struct hclge_config_max_frm_size_cmd *)desc.data; 3355cb51cfeSYufeng Mo 336d96b0e59SYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "max_frame_size: %u\n", 3375cb51cfeSYufeng Mo le16_to_cpu(req->max_frm_size)); 338d96b0e59SYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "min_frame_size: %u\n", 339d96b0e59SYufeng Mo req->min_frm_size); 340d96b0e59SYufeng Mo 341d96b0e59SYufeng Mo return 0; 3425cb51cfeSYufeng Mo } 3435cb51cfeSYufeng Mo 344d96b0e59SYufeng Mo static int hclge_dbg_dump_mac_speed_duplex(struct hclge_dev *hdev, char *buf, 345d96b0e59SYufeng Mo int len, int *pos) 3465cb51cfeSYufeng Mo { 3475cb51cfeSYufeng Mo #define HCLGE_MAC_SPEED_SHIFT 0 3485cb51cfeSYufeng Mo #define HCLGE_MAC_SPEED_MASK GENMASK(5, 0) 3495cb51cfeSYufeng Mo #define HCLGE_MAC_DUPLEX_SHIFT 7 3505cb51cfeSYufeng Mo 3515cb51cfeSYufeng Mo struct hclge_config_mac_speed_dup_cmd *req; 3525cb51cfeSYufeng Mo struct hclge_desc desc; 3535cb51cfeSYufeng Mo int ret; 3545cb51cfeSYufeng Mo 3555cb51cfeSYufeng Mo hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_CONFIG_SPEED_DUP, true); 3565cb51cfeSYufeng Mo 3575cb51cfeSYufeng Mo ret = hclge_cmd_send(&hdev->hw, &desc, 1); 3585cb51cfeSYufeng Mo if (ret) { 3595cb51cfeSYufeng Mo dev_err(&hdev->pdev->dev, 3605cb51cfeSYufeng Mo "failed to dump mac speed duplex, ret = %d\n", ret); 361d96b0e59SYufeng Mo return ret; 3625cb51cfeSYufeng Mo } 3635cb51cfeSYufeng Mo 3645cb51cfeSYufeng Mo req = (struct hclge_config_mac_speed_dup_cmd *)desc.data; 3655cb51cfeSYufeng Mo 366d96b0e59SYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "speed: %#lx\n", 3675cb51cfeSYufeng Mo hnae3_get_field(req->speed_dup, HCLGE_MAC_SPEED_MASK, 3685cb51cfeSYufeng Mo HCLGE_MAC_SPEED_SHIFT)); 369d96b0e59SYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "duplex: %#x\n", 370d96b0e59SYufeng Mo hnae3_get_bit(req->speed_dup, 371d96b0e59SYufeng Mo HCLGE_MAC_DUPLEX_SHIFT)); 372d96b0e59SYufeng Mo return 0; 3735cb51cfeSYufeng Mo } 3745cb51cfeSYufeng Mo 375d96b0e59SYufeng Mo static int hclge_dbg_dump_mac(struct hclge_dev *hdev, char *buf, int len) 3765cb51cfeSYufeng Mo { 377d96b0e59SYufeng Mo int pos = 0; 378d96b0e59SYufeng Mo int ret; 3795cb51cfeSYufeng Mo 380d96b0e59SYufeng Mo ret = hclge_dbg_dump_mac_enable_status(hdev, buf, len, &pos); 381d96b0e59SYufeng Mo if (ret) 382d96b0e59SYufeng Mo return ret; 3835cb51cfeSYufeng Mo 384d96b0e59SYufeng Mo ret = hclge_dbg_dump_mac_frame_size(hdev, buf, len, &pos); 385d96b0e59SYufeng Mo if (ret) 386d96b0e59SYufeng Mo return ret; 387d96b0e59SYufeng Mo 388d96b0e59SYufeng Mo return hclge_dbg_dump_mac_speed_duplex(hdev, buf, len, &pos); 3895cb51cfeSYufeng Mo } 3905cb51cfeSYufeng Mo 391365e860aSYufeng Mo static int hclge_dbg_dump_dcb_qset(struct hclge_dev *hdev, char *buf, int len, 392365e860aSYufeng Mo int *pos) 393c0ebebb9Sliuzhongzhu { 394c0ebebb9Sliuzhongzhu struct hclge_dbg_bitmap_cmd *bitmap; 395365e860aSYufeng Mo struct hclge_desc desc; 396365e860aSYufeng Mo u16 qset_id, qset_num; 397365e860aSYufeng Mo int ret; 398c0ebebb9Sliuzhongzhu 399365e860aSYufeng Mo ret = hclge_tm_get_qset_num(hdev, &qset_num); 400365e860aSYufeng Mo if (ret) 401365e860aSYufeng Mo return ret; 402c0ebebb9Sliuzhongzhu 403365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, 404365e860aSYufeng Mo "qset_id roce_qset_mask nic_qset_mask qset_shaping_pass qset_bp_status\n"); 405365e860aSYufeng Mo for (qset_id = 0; qset_id < qset_num; qset_id++) { 406365e860aSYufeng Mo ret = hclge_dbg_cmd_send(hdev, &desc, qset_id, 1, 407365e860aSYufeng Mo HCLGE_OPC_QSET_DFX_STS); 408365e860aSYufeng Mo if (ret) 409365e860aSYufeng Mo return ret; 410365e860aSYufeng Mo 411365e860aSYufeng Mo bitmap = (struct hclge_dbg_bitmap_cmd *)&desc.data[1]; 412365e860aSYufeng Mo 413365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, 414365e860aSYufeng Mo "%04u %#x %#x %#x %#x\n", 415365e860aSYufeng Mo qset_id, bitmap->bit0, bitmap->bit1, 416365e860aSYufeng Mo bitmap->bit2, bitmap->bit3); 417c0ebebb9Sliuzhongzhu } 418c0ebebb9Sliuzhongzhu 419365e860aSYufeng Mo return 0; 420365e860aSYufeng Mo } 421365e860aSYufeng Mo 422365e860aSYufeng Mo static int hclge_dbg_dump_dcb_pri(struct hclge_dev *hdev, char *buf, int len, 423365e860aSYufeng Mo int *pos) 424365e860aSYufeng Mo { 425365e860aSYufeng Mo struct hclge_dbg_bitmap_cmd *bitmap; 426365e860aSYufeng Mo struct hclge_desc desc; 427365e860aSYufeng Mo u8 pri_id, pri_num; 428365e860aSYufeng Mo int ret; 429365e860aSYufeng Mo 430365e860aSYufeng Mo ret = hclge_tm_get_pri_num(hdev, &pri_num); 431c0ebebb9Sliuzhongzhu if (ret) 432365e860aSYufeng Mo return ret; 433c0ebebb9Sliuzhongzhu 434365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, 435365e860aSYufeng Mo "pri_id pri_mask pri_cshaping_pass pri_pshaping_pass\n"); 436365e860aSYufeng Mo for (pri_id = 0; pri_id < pri_num; pri_id++) { 437365e860aSYufeng Mo ret = hclge_dbg_cmd_send(hdev, &desc, pri_id, 1, 438365e860aSYufeng Mo HCLGE_OPC_PRI_DFX_STS); 439c0ebebb9Sliuzhongzhu if (ret) 440365e860aSYufeng Mo return ret; 441c0ebebb9Sliuzhongzhu 442365e860aSYufeng Mo bitmap = (struct hclge_dbg_bitmap_cmd *)&desc.data[1]; 443c0ebebb9Sliuzhongzhu 444365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, 445365e860aSYufeng Mo "%03u %#x %#x %#x\n", 446365e860aSYufeng Mo pri_id, bitmap->bit0, bitmap->bit1, 447365e860aSYufeng Mo bitmap->bit2); 448365e860aSYufeng Mo } 449365e860aSYufeng Mo 450365e860aSYufeng Mo return 0; 451365e860aSYufeng Mo } 452365e860aSYufeng Mo 453365e860aSYufeng Mo static int hclge_dbg_dump_dcb_pg(struct hclge_dev *hdev, char *buf, int len, 454365e860aSYufeng Mo int *pos) 455365e860aSYufeng Mo { 456365e860aSYufeng Mo struct hclge_dbg_bitmap_cmd *bitmap; 457365e860aSYufeng Mo struct hclge_desc desc; 458365e860aSYufeng Mo u8 pg_id; 459365e860aSYufeng Mo int ret; 460365e860aSYufeng Mo 461365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, 462365e860aSYufeng Mo "pg_id pg_mask pg_cshaping_pass pg_pshaping_pass\n"); 463365e860aSYufeng Mo for (pg_id = 0; pg_id < hdev->tm_info.num_pg; pg_id++) { 464365e860aSYufeng Mo ret = hclge_dbg_cmd_send(hdev, &desc, pg_id, 1, 465365e860aSYufeng Mo HCLGE_OPC_PG_DFX_STS); 466c0ebebb9Sliuzhongzhu if (ret) 467365e860aSYufeng Mo return ret; 468c0ebebb9Sliuzhongzhu 469365e860aSYufeng Mo bitmap = (struct hclge_dbg_bitmap_cmd *)&desc.data[1]; 470c0ebebb9Sliuzhongzhu 471365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, 472365e860aSYufeng Mo "%03u %#x %#x %#x\n", 473365e860aSYufeng Mo pg_id, bitmap->bit0, bitmap->bit1, 474365e860aSYufeng Mo bitmap->bit2); 475365e860aSYufeng Mo } 476365e860aSYufeng Mo 477365e860aSYufeng Mo return 0; 478365e860aSYufeng Mo } 479365e860aSYufeng Mo 480365e860aSYufeng Mo static int hclge_dbg_dump_dcb_queue(struct hclge_dev *hdev, char *buf, int len, 481365e860aSYufeng Mo int *pos) 482365e860aSYufeng Mo { 483365e860aSYufeng Mo struct hclge_desc desc; 484365e860aSYufeng Mo u16 nq_id; 485365e860aSYufeng Mo int ret; 486365e860aSYufeng Mo 487365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, 488365e860aSYufeng Mo "nq_id sch_nic_queue_cnt sch_roce_queue_cnt\n"); 489365e860aSYufeng Mo for (nq_id = 0; nq_id < hdev->num_tqps; nq_id++) { 490365e860aSYufeng Mo ret = hclge_dbg_cmd_send(hdev, &desc, nq_id, 1, 491365e860aSYufeng Mo HCLGE_OPC_SCH_NQ_CNT); 492c0ebebb9Sliuzhongzhu if (ret) 493365e860aSYufeng Mo return ret; 494c0ebebb9Sliuzhongzhu 495365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "%04u %#x", 496365e860aSYufeng Mo nq_id, le32_to_cpu(desc.data[1])); 497c0ebebb9Sliuzhongzhu 498365e860aSYufeng Mo ret = hclge_dbg_cmd_send(hdev, &desc, nq_id, 1, 499365e860aSYufeng Mo HCLGE_OPC_SCH_RQ_CNT); 500c0ebebb9Sliuzhongzhu if (ret) 501365e860aSYufeng Mo return ret; 502c0ebebb9Sliuzhongzhu 503365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, 504365e860aSYufeng Mo " %#x\n", 505365e860aSYufeng Mo le32_to_cpu(desc.data[1])); 506365e860aSYufeng Mo } 507c0ebebb9Sliuzhongzhu 508365e860aSYufeng Mo return 0; 509365e860aSYufeng Mo } 510365e860aSYufeng Mo 511365e860aSYufeng Mo static int hclge_dbg_dump_dcb_port(struct hclge_dev *hdev, char *buf, int len, 512365e860aSYufeng Mo int *pos) 513365e860aSYufeng Mo { 514365e860aSYufeng Mo struct hclge_dbg_bitmap_cmd *bitmap; 515365e860aSYufeng Mo struct hclge_desc desc; 516365e860aSYufeng Mo u8 port_id = 0; 517365e860aSYufeng Mo int ret; 518365e860aSYufeng Mo 519365e860aSYufeng Mo ret = hclge_dbg_cmd_send(hdev, &desc, port_id, 1, 520365e860aSYufeng Mo HCLGE_OPC_PORT_DFX_STS); 521c0ebebb9Sliuzhongzhu if (ret) 522365e860aSYufeng Mo return ret; 523c0ebebb9Sliuzhongzhu 524365e860aSYufeng Mo bitmap = (struct hclge_dbg_bitmap_cmd *)&desc.data[1]; 525c0ebebb9Sliuzhongzhu 526365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "port_mask: %#x\n", 527365e860aSYufeng Mo bitmap->bit0); 528365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "port_shaping_pass: %#x\n", 529365e860aSYufeng Mo bitmap->bit1); 530365e860aSYufeng Mo 531365e860aSYufeng Mo return 0; 532365e860aSYufeng Mo } 533365e860aSYufeng Mo 534365e860aSYufeng Mo static int hclge_dbg_dump_dcb_tm(struct hclge_dev *hdev, char *buf, int len, 535365e860aSYufeng Mo int *pos) 536365e860aSYufeng Mo { 537365e860aSYufeng Mo struct hclge_desc desc[2]; 538365e860aSYufeng Mo u8 port_id = 0; 539365e860aSYufeng Mo int ret; 540365e860aSYufeng Mo 541365e860aSYufeng Mo ret = hclge_dbg_cmd_send(hdev, desc, port_id, 1, 542365e860aSYufeng Mo HCLGE_OPC_TM_INTERNAL_CNT); 543c0ebebb9Sliuzhongzhu if (ret) 544365e860aSYufeng Mo return ret; 545c0ebebb9Sliuzhongzhu 546365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "SCH_NIC_NUM: %#x\n", 547365e860aSYufeng Mo le32_to_cpu(desc[0].data[1])); 548365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "SCH_ROCE_NUM: %#x\n", 549365e860aSYufeng Mo le32_to_cpu(desc[0].data[2])); 550365e860aSYufeng Mo 551365e860aSYufeng Mo ret = hclge_dbg_cmd_send(hdev, desc, port_id, 2, 552365e860aSYufeng Mo HCLGE_OPC_TM_INTERNAL_STS); 553365e860aSYufeng Mo if (ret) 554365e860aSYufeng Mo return ret; 555365e860aSYufeng Mo 556365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "pri_bp: %#x\n", 557365e860aSYufeng Mo le32_to_cpu(desc[0].data[1])); 558365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "fifo_dfx_info: %#x\n", 559365e860aSYufeng Mo le32_to_cpu(desc[0].data[2])); 560365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, 561365e860aSYufeng Mo "sch_roce_fifo_afull_gap: %#x\n", 56239edaf24SGuojia Liao le32_to_cpu(desc[0].data[3])); 563365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, 564365e860aSYufeng Mo "tx_private_waterline: %#x\n", 56539edaf24SGuojia Liao le32_to_cpu(desc[0].data[4])); 566365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "tm_bypass_en: %#x\n", 56739edaf24SGuojia Liao le32_to_cpu(desc[0].data[5])); 568365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "SSU_TM_BYPASS_EN: %#x\n", 569365e860aSYufeng Mo le32_to_cpu(desc[1].data[0])); 570365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "SSU_RESERVE_CFG: %#x\n", 571365e860aSYufeng Mo le32_to_cpu(desc[1].data[1])); 57277ba415dSYufeng Mo 573365e860aSYufeng Mo if (hdev->hw.mac.media_type == HNAE3_MEDIA_TYPE_COPPER) 574365e860aSYufeng Mo return 0; 575365e860aSYufeng Mo 576365e860aSYufeng Mo ret = hclge_dbg_cmd_send(hdev, desc, port_id, 1, 577365e860aSYufeng Mo HCLGE_OPC_TM_INTERNAL_STS_1); 578365e860aSYufeng Mo if (ret) 579365e860aSYufeng Mo return ret; 580365e860aSYufeng Mo 581365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "TC_MAP_SEL: %#x\n", 582365e860aSYufeng Mo le32_to_cpu(desc[0].data[1])); 583365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "IGU_PFC_PRI_EN: %#x\n", 584365e860aSYufeng Mo le32_to_cpu(desc[0].data[2])); 585365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "MAC_PFC_PRI_EN: %#x\n", 586365e860aSYufeng Mo le32_to_cpu(desc[0].data[3])); 587365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "IGU_PRI_MAP_TC_CFG: %#x\n", 588365e860aSYufeng Mo le32_to_cpu(desc[0].data[4])); 589365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, 590365e860aSYufeng Mo "IGU_TX_PRI_MAP_TC_CFG: %#x\n", 591365e860aSYufeng Mo le32_to_cpu(desc[0].data[5])); 592365e860aSYufeng Mo 593365e860aSYufeng Mo return 0; 594365e860aSYufeng Mo } 595365e860aSYufeng Mo 596365e860aSYufeng Mo static int hclge_dbg_dump_dcb(struct hclge_dev *hdev, char *buf, int len) 597365e860aSYufeng Mo { 598365e860aSYufeng Mo int pos = 0; 599365e860aSYufeng Mo int ret; 600365e860aSYufeng Mo 601365e860aSYufeng Mo ret = hclge_dbg_dump_dcb_qset(hdev, buf, len, &pos); 602365e860aSYufeng Mo if (ret) 603365e860aSYufeng Mo return ret; 604365e860aSYufeng Mo 605365e860aSYufeng Mo ret = hclge_dbg_dump_dcb_pri(hdev, buf, len, &pos); 606365e860aSYufeng Mo if (ret) 607365e860aSYufeng Mo return ret; 608365e860aSYufeng Mo 609365e860aSYufeng Mo ret = hclge_dbg_dump_dcb_pg(hdev, buf, len, &pos); 610365e860aSYufeng Mo if (ret) 611365e860aSYufeng Mo return ret; 612365e860aSYufeng Mo 613365e860aSYufeng Mo ret = hclge_dbg_dump_dcb_queue(hdev, buf, len, &pos); 614365e860aSYufeng Mo if (ret) 615365e860aSYufeng Mo return ret; 616365e860aSYufeng Mo 617365e860aSYufeng Mo ret = hclge_dbg_dump_dcb_port(hdev, buf, len, &pos); 618365e860aSYufeng Mo if (ret) 619365e860aSYufeng Mo return ret; 620365e860aSYufeng Mo 621365e860aSYufeng Mo return hclge_dbg_dump_dcb_tm(hdev, buf, len, &pos); 622c0ebebb9Sliuzhongzhu } 623c0ebebb9Sliuzhongzhu 624d96b0e59SYufeng Mo static int hclge_dbg_dump_reg_cmd(struct hclge_dev *hdev, 625d96b0e59SYufeng Mo enum hnae3_dbg_cmd cmd, char *buf, int len) 62627cf979aSliuzhongzhu { 627e4b91468SRikard Falkeborn const struct hclge_dbg_reg_type_info *reg_info; 628d96b0e59SYufeng Mo int pos = 0, ret = 0; 629a582b78dSZhongzhu Liu int i; 63027cf979aSliuzhongzhu 631a582b78dSZhongzhu Liu for (i = 0; i < ARRAY_SIZE(hclge_dbg_reg_info); i++) { 632a582b78dSZhongzhu Liu reg_info = &hclge_dbg_reg_info[i]; 633d96b0e59SYufeng Mo if (cmd == reg_info->cmd) { 634d96b0e59SYufeng Mo if (cmd == HNAE3_DBG_CMD_REG_TQP) 635d96b0e59SYufeng Mo return hclge_dbg_dump_reg_tqp(hdev, reg_info, 636d96b0e59SYufeng Mo buf, len, &pos); 637d96b0e59SYufeng Mo 638d96b0e59SYufeng Mo ret = hclge_dbg_dump_reg_common(hdev, reg_info, buf, 639d96b0e59SYufeng Mo len, &pos); 640d96b0e59SYufeng Mo if (ret) 641d96b0e59SYufeng Mo break; 642a582b78dSZhongzhu Liu } 643a582b78dSZhongzhu Liu } 64427cf979aSliuzhongzhu 645d96b0e59SYufeng Mo return ret; 64627cf979aSliuzhongzhu } 64727cf979aSliuzhongzhu 64800577c8bSYufeng Mo static void hclge_print_tc_info(struct hclge_dev *hdev, bool flag, int index) 6492849d4e7Sliuzhongzhu { 6502849d4e7Sliuzhongzhu if (flag) 65100577c8bSYufeng Mo dev_info(&hdev->pdev->dev, "tc(%d): no sp mode weight: %u\n", 65200577c8bSYufeng Mo index, hdev->tm_info.pg_info[0].tc_dwrr[index]); 6532849d4e7Sliuzhongzhu else 65400577c8bSYufeng Mo dev_info(&hdev->pdev->dev, "tc(%d): sp mode\n", index); 6552849d4e7Sliuzhongzhu } 6562849d4e7Sliuzhongzhu 6572849d4e7Sliuzhongzhu static void hclge_dbg_dump_tc(struct hclge_dev *hdev) 6582849d4e7Sliuzhongzhu { 6592849d4e7Sliuzhongzhu struct hclge_ets_tc_weight_cmd *ets_weight; 6602849d4e7Sliuzhongzhu struct hclge_desc desc; 6612849d4e7Sliuzhongzhu int i, ret; 6622849d4e7Sliuzhongzhu 6633f0f3253SYufeng Mo if (!hnae3_dev_dcb_supported(hdev)) { 6643f0f3253SYufeng Mo dev_info(&hdev->pdev->dev, 6653f0f3253SYufeng Mo "Only DCB-supported dev supports tc\n"); 6663f0f3253SYufeng Mo return; 6673f0f3253SYufeng Mo } 6683f0f3253SYufeng Mo 6692849d4e7Sliuzhongzhu hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_ETS_TC_WEIGHT, true); 6702849d4e7Sliuzhongzhu 6712849d4e7Sliuzhongzhu ret = hclge_cmd_send(&hdev->hw, &desc, 1); 6722849d4e7Sliuzhongzhu if (ret) { 673ed5b255bSYufeng Mo dev_err(&hdev->pdev->dev, "dump tc fail, ret = %d\n", ret); 6742849d4e7Sliuzhongzhu return; 6752849d4e7Sliuzhongzhu } 6762849d4e7Sliuzhongzhu 6772849d4e7Sliuzhongzhu ets_weight = (struct hclge_ets_tc_weight_cmd *)desc.data; 6782849d4e7Sliuzhongzhu 679a8adbb8aSYonglong Liu dev_info(&hdev->pdev->dev, "dump tc: %u tc enabled\n", 680a8adbb8aSYonglong Liu hdev->tm_info.num_tc); 6812849d4e7Sliuzhongzhu dev_info(&hdev->pdev->dev, "weight_offset: %u\n", 6822849d4e7Sliuzhongzhu ets_weight->weight_offset); 6832849d4e7Sliuzhongzhu 6842849d4e7Sliuzhongzhu for (i = 0; i < HNAE3_MAX_TC; i++) 68500577c8bSYufeng Mo hclge_print_tc_info(hdev, ets_weight->tc_weight[i], i); 6862849d4e7Sliuzhongzhu } 6872849d4e7Sliuzhongzhu 688*cad7c215SGuangbin Huang static const struct hclge_dbg_item tm_pg_items[] = { 689*cad7c215SGuangbin Huang { "ID", 2 }, 690*cad7c215SGuangbin Huang { "PRI_MAP", 2 }, 691*cad7c215SGuangbin Huang { "MODE", 2 }, 692*cad7c215SGuangbin Huang { "DWRR", 2 }, 693*cad7c215SGuangbin Huang { "C_IR_B", 2 }, 694*cad7c215SGuangbin Huang { "C_IR_U", 2 }, 695*cad7c215SGuangbin Huang { "C_IR_S", 2 }, 696*cad7c215SGuangbin Huang { "C_BS_B", 2 }, 697*cad7c215SGuangbin Huang { "C_BS_S", 2 }, 698*cad7c215SGuangbin Huang { "C_FLAG", 2 }, 699*cad7c215SGuangbin Huang { "C_RATE(Mbps)", 2 }, 700*cad7c215SGuangbin Huang { "P_IR_B", 2 }, 701*cad7c215SGuangbin Huang { "P_IR_U", 2 }, 702*cad7c215SGuangbin Huang { "P_IR_S", 2 }, 703*cad7c215SGuangbin Huang { "P_BS_B", 2 }, 704*cad7c215SGuangbin Huang { "P_BS_S", 2 }, 705*cad7c215SGuangbin Huang { "P_FLAG", 2 }, 706*cad7c215SGuangbin Huang { "P_RATE(Mbps)", 0 } 707*cad7c215SGuangbin Huang }; 708*cad7c215SGuangbin Huang 709*cad7c215SGuangbin Huang static void hclge_dbg_fill_shaper_content(struct hclge_tm_shaper_para *para, 710*cad7c215SGuangbin Huang char **result, u8 *index) 71196227f4cSliuzhongzhu { 712*cad7c215SGuangbin Huang sprintf(result[(*index)++], "%3u", para->ir_b); 713*cad7c215SGuangbin Huang sprintf(result[(*index)++], "%3u", para->ir_u); 714*cad7c215SGuangbin Huang sprintf(result[(*index)++], "%3u", para->ir_s); 715*cad7c215SGuangbin Huang sprintf(result[(*index)++], "%3u", para->bs_b); 716*cad7c215SGuangbin Huang sprintf(result[(*index)++], "%3u", para->bs_s); 717*cad7c215SGuangbin Huang sprintf(result[(*index)++], "%3u", para->flag); 718*cad7c215SGuangbin Huang sprintf(result[(*index)++], "%6u", para->rate); 7193f0f3253SYufeng Mo } 7203f0f3253SYufeng Mo 721*cad7c215SGuangbin Huang static int hclge_dbg_dump_tm_pg(struct hclge_dev *hdev, char *buf, int len) 72296227f4cSliuzhongzhu { 723*cad7c215SGuangbin Huang char data_str[ARRAY_SIZE(tm_pg_items)][HCLGE_DBG_DATA_STR_LEN]; 724*cad7c215SGuangbin Huang struct hclge_tm_shaper_para c_shaper_para, p_shaper_para; 725*cad7c215SGuangbin Huang char *result[ARRAY_SIZE(tm_pg_items)], *sch_mode_str; 726*cad7c215SGuangbin Huang u8 pg_id, sch_mode, weight, pri_bit_map, i, j; 727*cad7c215SGuangbin Huang char content[HCLGE_DBG_TM_INFO_LEN]; 728*cad7c215SGuangbin Huang int pos = 0; 72996227f4cSliuzhongzhu int ret; 73096227f4cSliuzhongzhu 731*cad7c215SGuangbin Huang for (i = 0; i < ARRAY_SIZE(tm_pg_items); i++) 732*cad7c215SGuangbin Huang result[i] = &data_str[i][0]; 733*cad7c215SGuangbin Huang 734*cad7c215SGuangbin Huang hclge_dbg_fill_content(content, sizeof(content), tm_pg_items, 735*cad7c215SGuangbin Huang NULL, ARRAY_SIZE(tm_pg_items)); 736*cad7c215SGuangbin Huang pos += scnprintf(buf + pos, len - pos, "%s", content); 737*cad7c215SGuangbin Huang 738*cad7c215SGuangbin Huang for (pg_id = 0; pg_id < hdev->tm_info.num_pg; pg_id++) { 739*cad7c215SGuangbin Huang ret = hclge_tm_get_pg_to_pri_map(hdev, pg_id, &pri_bit_map); 74096227f4cSliuzhongzhu if (ret) 741*cad7c215SGuangbin Huang return ret; 74296227f4cSliuzhongzhu 743*cad7c215SGuangbin Huang ret = hclge_tm_get_pg_sch_mode(hdev, pg_id, &sch_mode); 74496227f4cSliuzhongzhu if (ret) 745*cad7c215SGuangbin Huang return ret; 74696227f4cSliuzhongzhu 747*cad7c215SGuangbin Huang ret = hclge_tm_get_pg_weight(hdev, pg_id, &weight); 74896227f4cSliuzhongzhu if (ret) 749*cad7c215SGuangbin Huang return ret; 75096227f4cSliuzhongzhu 751*cad7c215SGuangbin Huang ret = hclge_tm_get_pg_shaper(hdev, pg_id, 752*cad7c215SGuangbin Huang HCLGE_OPC_TM_PG_C_SHAPPING, 753*cad7c215SGuangbin Huang &c_shaper_para); 75496227f4cSliuzhongzhu if (ret) 755*cad7c215SGuangbin Huang return ret; 75696227f4cSliuzhongzhu 757*cad7c215SGuangbin Huang ret = hclge_tm_get_pg_shaper(hdev, pg_id, 758*cad7c215SGuangbin Huang HCLGE_OPC_TM_PG_P_SHAPPING, 759*cad7c215SGuangbin Huang &p_shaper_para); 76096227f4cSliuzhongzhu if (ret) 761*cad7c215SGuangbin Huang return ret; 76296227f4cSliuzhongzhu 763*cad7c215SGuangbin Huang sch_mode_str = sch_mode & HCLGE_TM_TX_SCHD_DWRR_MSK ? "dwrr" : 764*cad7c215SGuangbin Huang "sp"; 76596227f4cSliuzhongzhu 766*cad7c215SGuangbin Huang j = 0; 767*cad7c215SGuangbin Huang sprintf(result[j++], "%02u", pg_id); 768*cad7c215SGuangbin Huang sprintf(result[j++], "0x%02x", pri_bit_map); 769*cad7c215SGuangbin Huang sprintf(result[j++], "%4s", sch_mode_str); 770*cad7c215SGuangbin Huang sprintf(result[j++], "%3u", weight); 771*cad7c215SGuangbin Huang hclge_dbg_fill_shaper_content(&c_shaper_para, result, &j); 772*cad7c215SGuangbin Huang hclge_dbg_fill_shaper_content(&p_shaper_para, result, &j); 773*cad7c215SGuangbin Huang 774*cad7c215SGuangbin Huang hclge_dbg_fill_content(content, sizeof(content), tm_pg_items, 775*cad7c215SGuangbin Huang (const char **)result, 776*cad7c215SGuangbin Huang ARRAY_SIZE(tm_pg_items)); 777*cad7c215SGuangbin Huang pos += scnprintf(buf + pos, len - pos, "%s", content); 778*cad7c215SGuangbin Huang } 779*cad7c215SGuangbin Huang 780*cad7c215SGuangbin Huang return 0; 781*cad7c215SGuangbin Huang } 782*cad7c215SGuangbin Huang 783*cad7c215SGuangbin Huang static int hclge_dbg_dump_tm_port(struct hclge_dev *hdev, char *buf, int len) 784*cad7c215SGuangbin Huang { 785*cad7c215SGuangbin Huang struct hclge_tm_shaper_para shaper_para; 786*cad7c215SGuangbin Huang int pos = 0; 787*cad7c215SGuangbin Huang int ret; 788*cad7c215SGuangbin Huang 789*cad7c215SGuangbin Huang ret = hclge_tm_get_port_shaper(hdev, &shaper_para); 79096227f4cSliuzhongzhu if (ret) 791*cad7c215SGuangbin Huang return ret; 79296227f4cSliuzhongzhu 793*cad7c215SGuangbin Huang pos += scnprintf(buf + pos, len - pos, 794*cad7c215SGuangbin Huang "IR_B IR_U IR_S BS_B BS_S FLAG RATE(Mbps)\n"); 795*cad7c215SGuangbin Huang pos += scnprintf(buf + pos, len - pos, 796*cad7c215SGuangbin Huang "%3u %3u %3u %3u %3u %1u %6u\n", 797*cad7c215SGuangbin Huang shaper_para.ir_b, shaper_para.ir_u, shaper_para.ir_s, 798*cad7c215SGuangbin Huang shaper_para.bs_b, shaper_para.bs_s, shaper_para.flag, 799*cad7c215SGuangbin Huang shaper_para.rate); 80096227f4cSliuzhongzhu 801*cad7c215SGuangbin Huang return 0; 80296227f4cSliuzhongzhu } 80396227f4cSliuzhongzhu 8047679f28eSGuangbin Huang static int hclge_dbg_dump_tm_bp_qset_map(struct hclge_dev *hdev, u8 tc_id, 8057679f28eSGuangbin Huang char *buf, int len) 80682e00b86Sliuzhongzhu { 8079a5ef4aaSYonglong Liu u32 qset_mapping[HCLGE_BP_EXT_GRP_NUM]; 8087679f28eSGuangbin Huang struct hclge_bp_to_qs_map_cmd *map; 80982e00b86Sliuzhongzhu struct hclge_desc desc; 8107679f28eSGuangbin Huang int pos = 0; 8117679f28eSGuangbin Huang u8 group_id; 8127679f28eSGuangbin Huang u8 grp_num; 8137679f28eSGuangbin Huang u16 i = 0; 8140256844dSYonglong Liu int ret; 8153f0f3253SYufeng Mo 8169a5ef4aaSYonglong Liu grp_num = hdev->num_tqps <= HCLGE_TQP_MAX_SIZE_DEV_V2 ? 8179a5ef4aaSYonglong Liu HCLGE_BP_GRP_NUM : HCLGE_BP_EXT_GRP_NUM; 8187679f28eSGuangbin Huang map = (struct hclge_bp_to_qs_map_cmd *)desc.data; 8199a5ef4aaSYonglong Liu for (group_id = 0; group_id < grp_num; group_id++) { 8207679f28eSGuangbin Huang hclge_cmd_setup_basic_desc(&desc, 8217679f28eSGuangbin Huang HCLGE_OPC_TM_BP_TO_QSET_MAPPING, 8227679f28eSGuangbin Huang true); 8237679f28eSGuangbin Huang map->tc_id = tc_id; 8247679f28eSGuangbin Huang map->qs_group_id = group_id; 82582e00b86Sliuzhongzhu ret = hclge_cmd_send(&hdev->hw, &desc, 1); 8267679f28eSGuangbin Huang if (ret) { 8277679f28eSGuangbin Huang dev_err(&hdev->pdev->dev, 8287679f28eSGuangbin Huang "failed to get bp to qset map, ret = %d\n", 8297679f28eSGuangbin Huang ret); 8307679f28eSGuangbin Huang return ret; 83182e00b86Sliuzhongzhu } 83282e00b86Sliuzhongzhu 8337679f28eSGuangbin Huang qset_mapping[group_id] = le32_to_cpu(map->qs_bit_map); 8347679f28eSGuangbin Huang } 83582e00b86Sliuzhongzhu 8367679f28eSGuangbin Huang pos += scnprintf(buf + pos, len - pos, "INDEX | TM BP QSET MAPPING:\n"); 8379a5ef4aaSYonglong Liu for (group_id = 0; group_id < grp_num / 8; group_id++) { 8387679f28eSGuangbin Huang pos += scnprintf(buf + pos, len - pos, 83982e00b86Sliuzhongzhu "%04d | %08x:%08x:%08x:%08x:%08x:%08x:%08x:%08x\n", 8407679f28eSGuangbin Huang group_id * 256, qset_mapping[i + 7], 8417679f28eSGuangbin Huang qset_mapping[i + 6], qset_mapping[i + 5], 8427679f28eSGuangbin Huang qset_mapping[i + 4], qset_mapping[i + 3], 8437679f28eSGuangbin Huang qset_mapping[i + 2], qset_mapping[i + 1], 84496b8e878SHuazhong Tan qset_mapping[i]); 84582e00b86Sliuzhongzhu i += 8; 84682e00b86Sliuzhongzhu } 84782e00b86Sliuzhongzhu 8487679f28eSGuangbin Huang return pos; 8497679f28eSGuangbin Huang } 85082e00b86Sliuzhongzhu 8517679f28eSGuangbin Huang static int hclge_dbg_dump_tm_map(struct hclge_dev *hdev, char *buf, int len) 8527679f28eSGuangbin Huang { 8537679f28eSGuangbin Huang u16 queue_id; 8547679f28eSGuangbin Huang u16 qset_id; 8557679f28eSGuangbin Huang u8 link_vld; 8567679f28eSGuangbin Huang int pos = 0; 8577679f28eSGuangbin Huang u8 pri_id; 8587679f28eSGuangbin Huang u8 tc_id; 8597679f28eSGuangbin Huang int ret; 8607679f28eSGuangbin Huang 8617679f28eSGuangbin Huang for (queue_id = 0; queue_id < hdev->num_tqps; queue_id++) { 8627679f28eSGuangbin Huang ret = hclge_tm_get_q_to_qs_map(hdev, queue_id, &qset_id); 8637679f28eSGuangbin Huang if (ret) 8647679f28eSGuangbin Huang return ret; 8657679f28eSGuangbin Huang 8667679f28eSGuangbin Huang ret = hclge_tm_get_qset_map_pri(hdev, qset_id, &pri_id, 8677679f28eSGuangbin Huang &link_vld); 8687679f28eSGuangbin Huang if (ret) 8697679f28eSGuangbin Huang return ret; 8707679f28eSGuangbin Huang 8717679f28eSGuangbin Huang ret = hclge_tm_get_q_to_tc(hdev, queue_id, &tc_id); 8727679f28eSGuangbin Huang if (ret) 8737679f28eSGuangbin Huang return ret; 8747679f28eSGuangbin Huang 8757679f28eSGuangbin Huang pos += scnprintf(buf + pos, len - pos, 8767679f28eSGuangbin Huang "QUEUE_ID QSET_ID PRI_ID TC_ID\n"); 8777679f28eSGuangbin Huang pos += scnprintf(buf + pos, len - pos, 8787679f28eSGuangbin Huang "%04u %4u %3u %2u\n", 8797679f28eSGuangbin Huang queue_id, qset_id, pri_id, tc_id); 8807679f28eSGuangbin Huang 8817679f28eSGuangbin Huang if (!hnae3_dev_dcb_supported(hdev)) 8827679f28eSGuangbin Huang continue; 8837679f28eSGuangbin Huang 8847679f28eSGuangbin Huang ret = hclge_dbg_dump_tm_bp_qset_map(hdev, tc_id, buf + pos, 8857679f28eSGuangbin Huang len - pos); 8867679f28eSGuangbin Huang if (ret < 0) 8877679f28eSGuangbin Huang return ret; 8887679f28eSGuangbin Huang pos += ret; 8897679f28eSGuangbin Huang 8907679f28eSGuangbin Huang pos += scnprintf(buf + pos, len - pos, "\n"); 8917679f28eSGuangbin Huang } 8927679f28eSGuangbin Huang 8937679f28eSGuangbin Huang return 0; 89482e00b86Sliuzhongzhu } 89582e00b86Sliuzhongzhu 89604987ca1SGuangbin Huang static int hclge_dbg_dump_tm_nodes(struct hclge_dev *hdev, char *buf, int len) 89704987ca1SGuangbin Huang { 89804987ca1SGuangbin Huang struct hclge_tm_nodes_cmd *nodes; 89904987ca1SGuangbin Huang struct hclge_desc desc; 90004987ca1SGuangbin Huang int pos = 0; 90104987ca1SGuangbin Huang int ret; 90204987ca1SGuangbin Huang 90304987ca1SGuangbin Huang hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_TM_NODES, true); 90404987ca1SGuangbin Huang ret = hclge_cmd_send(&hdev->hw, &desc, 1); 90504987ca1SGuangbin Huang if (ret) { 90604987ca1SGuangbin Huang dev_err(&hdev->pdev->dev, 90704987ca1SGuangbin Huang "failed to dump tm nodes, ret = %d\n", ret); 90804987ca1SGuangbin Huang return ret; 90904987ca1SGuangbin Huang } 91004987ca1SGuangbin Huang 91104987ca1SGuangbin Huang nodes = (struct hclge_tm_nodes_cmd *)desc.data; 91204987ca1SGuangbin Huang 91304987ca1SGuangbin Huang pos += scnprintf(buf + pos, len - pos, " BASE_ID MAX_NUM\n"); 91404987ca1SGuangbin Huang pos += scnprintf(buf + pos, len - pos, "PG %4u %4u\n", 91504987ca1SGuangbin Huang nodes->pg_base_id, nodes->pg_num); 91604987ca1SGuangbin Huang pos += scnprintf(buf + pos, len - pos, "PRI %4u %4u\n", 91704987ca1SGuangbin Huang nodes->pri_base_id, nodes->pri_num); 91804987ca1SGuangbin Huang pos += scnprintf(buf + pos, len - pos, "QSET %4u %4u\n", 91904987ca1SGuangbin Huang le16_to_cpu(nodes->qset_base_id), 92004987ca1SGuangbin Huang le16_to_cpu(nodes->qset_num)); 92104987ca1SGuangbin Huang pos += scnprintf(buf + pos, len - pos, "QUEUE %4u %4u\n", 92204987ca1SGuangbin Huang le16_to_cpu(nodes->queue_base_id), 92304987ca1SGuangbin Huang le16_to_cpu(nodes->queue_num)); 92404987ca1SGuangbin Huang 92504987ca1SGuangbin Huang return 0; 92604987ca1SGuangbin Huang } 92704987ca1SGuangbin Huang 92804987ca1SGuangbin Huang static int hclge_dbg_dump_tm_pri(struct hclge_dev *hdev, char *buf, int len) 92904987ca1SGuangbin Huang { 930*cad7c215SGuangbin Huang struct hclge_tm_shaper_para c_shaper_para; 931*cad7c215SGuangbin Huang struct hclge_tm_shaper_para p_shaper_para; 93204987ca1SGuangbin Huang u8 pri_num, sch_mode, weight; 93304987ca1SGuangbin Huang char *sch_mode_str; 93404987ca1SGuangbin Huang int pos = 0; 93504987ca1SGuangbin Huang int ret; 93604987ca1SGuangbin Huang u8 i; 93704987ca1SGuangbin Huang 93804987ca1SGuangbin Huang ret = hclge_tm_get_pri_num(hdev, &pri_num); 93904987ca1SGuangbin Huang if (ret) 94004987ca1SGuangbin Huang return ret; 94104987ca1SGuangbin Huang 94204987ca1SGuangbin Huang pos += scnprintf(buf + pos, len - pos, 94304987ca1SGuangbin Huang "ID MODE DWRR C_IR_B C_IR_U C_IR_S C_BS_B "); 94404987ca1SGuangbin Huang pos += scnprintf(buf + pos, len - pos, 94504987ca1SGuangbin Huang "C_BS_S C_FLAG C_RATE(Mbps) P_IR_B P_IR_U "); 94604987ca1SGuangbin Huang pos += scnprintf(buf + pos, len - pos, 94704987ca1SGuangbin Huang "P_IR_S P_BS_B P_BS_S P_FLAG P_RATE(Mbps)\n"); 94804987ca1SGuangbin Huang 94904987ca1SGuangbin Huang for (i = 0; i < pri_num; i++) { 95004987ca1SGuangbin Huang ret = hclge_tm_get_pri_sch_mode(hdev, i, &sch_mode); 95104987ca1SGuangbin Huang if (ret) 95204987ca1SGuangbin Huang return ret; 95304987ca1SGuangbin Huang 95404987ca1SGuangbin Huang ret = hclge_tm_get_pri_weight(hdev, i, &weight); 95504987ca1SGuangbin Huang if (ret) 95604987ca1SGuangbin Huang return ret; 95704987ca1SGuangbin Huang 95804987ca1SGuangbin Huang ret = hclge_tm_get_pri_shaper(hdev, i, 95904987ca1SGuangbin Huang HCLGE_OPC_TM_PRI_C_SHAPPING, 96004987ca1SGuangbin Huang &c_shaper_para); 96104987ca1SGuangbin Huang if (ret) 96204987ca1SGuangbin Huang return ret; 96304987ca1SGuangbin Huang 96404987ca1SGuangbin Huang ret = hclge_tm_get_pri_shaper(hdev, i, 96504987ca1SGuangbin Huang HCLGE_OPC_TM_PRI_P_SHAPPING, 96604987ca1SGuangbin Huang &p_shaper_para); 96704987ca1SGuangbin Huang if (ret) 96804987ca1SGuangbin Huang return ret; 96904987ca1SGuangbin Huang 97004987ca1SGuangbin Huang sch_mode_str = sch_mode & HCLGE_TM_TX_SCHD_DWRR_MSK ? "dwrr" : 97104987ca1SGuangbin Huang "sp"; 97204987ca1SGuangbin Huang 97304987ca1SGuangbin Huang pos += scnprintf(buf + pos, len - pos, 97404987ca1SGuangbin Huang "%04u %4s %3u %3u %3u %3u ", 97504987ca1SGuangbin Huang i, sch_mode_str, weight, c_shaper_para.ir_b, 97604987ca1SGuangbin Huang c_shaper_para.ir_u, c_shaper_para.ir_s); 97704987ca1SGuangbin Huang pos += scnprintf(buf + pos, len - pos, 97804987ca1SGuangbin Huang "%3u %3u %1u %6u ", 97904987ca1SGuangbin Huang c_shaper_para.bs_b, c_shaper_para.bs_s, 98004987ca1SGuangbin Huang c_shaper_para.flag, c_shaper_para.rate); 98104987ca1SGuangbin Huang pos += scnprintf(buf + pos, len - pos, 98204987ca1SGuangbin Huang "%3u %3u %3u %3u %3u ", 98304987ca1SGuangbin Huang p_shaper_para.ir_b, p_shaper_para.ir_u, 98404987ca1SGuangbin Huang p_shaper_para.ir_s, p_shaper_para.bs_b, 98504987ca1SGuangbin Huang p_shaper_para.bs_s); 98604987ca1SGuangbin Huang pos += scnprintf(buf + pos, len - pos, "%1u %6u\n", 98704987ca1SGuangbin Huang p_shaper_para.flag, p_shaper_para.rate); 98804987ca1SGuangbin Huang } 98904987ca1SGuangbin Huang 99004987ca1SGuangbin Huang return 0; 99104987ca1SGuangbin Huang } 99204987ca1SGuangbin Huang 99304987ca1SGuangbin Huang static int hclge_dbg_dump_tm_qset(struct hclge_dev *hdev, char *buf, int len) 99404987ca1SGuangbin Huang { 99504987ca1SGuangbin Huang u8 priority, link_vld, sch_mode, weight; 99604987ca1SGuangbin Huang char *sch_mode_str; 99704987ca1SGuangbin Huang int ret, pos; 99804987ca1SGuangbin Huang u16 qset_num; 99904987ca1SGuangbin Huang u16 i; 100004987ca1SGuangbin Huang 100104987ca1SGuangbin Huang ret = hclge_tm_get_qset_num(hdev, &qset_num); 100204987ca1SGuangbin Huang if (ret) 100304987ca1SGuangbin Huang return ret; 100404987ca1SGuangbin Huang 100504987ca1SGuangbin Huang pos = scnprintf(buf, len, "ID MAP_PRI LINK_VLD MODE DWRR\n"); 100604987ca1SGuangbin Huang 100704987ca1SGuangbin Huang for (i = 0; i < qset_num; i++) { 100804987ca1SGuangbin Huang ret = hclge_tm_get_qset_map_pri(hdev, i, &priority, &link_vld); 100904987ca1SGuangbin Huang if (ret) 101004987ca1SGuangbin Huang return ret; 101104987ca1SGuangbin Huang 101204987ca1SGuangbin Huang ret = hclge_tm_get_qset_sch_mode(hdev, i, &sch_mode); 101304987ca1SGuangbin Huang if (ret) 101404987ca1SGuangbin Huang return ret; 101504987ca1SGuangbin Huang 101604987ca1SGuangbin Huang ret = hclge_tm_get_qset_weight(hdev, i, &weight); 101704987ca1SGuangbin Huang if (ret) 101804987ca1SGuangbin Huang return ret; 101904987ca1SGuangbin Huang 102004987ca1SGuangbin Huang sch_mode_str = sch_mode & HCLGE_TM_TX_SCHD_DWRR_MSK ? "dwrr" : 102104987ca1SGuangbin Huang "sp"; 102204987ca1SGuangbin Huang pos += scnprintf(buf + pos, len - pos, 102304987ca1SGuangbin Huang "%04u %4u %1u %4s %3u\n", 102404987ca1SGuangbin Huang i, priority, link_vld, sch_mode_str, weight); 102504987ca1SGuangbin Huang } 102604987ca1SGuangbin Huang 102704987ca1SGuangbin Huang return 0; 102804987ca1SGuangbin Huang } 102904987ca1SGuangbin Huang 1030d958919dSliuzhongzhu static void hclge_dbg_dump_qos_pause_cfg(struct hclge_dev *hdev) 1031d958919dSliuzhongzhu { 1032d958919dSliuzhongzhu struct hclge_cfg_pause_param_cmd *pause_param; 1033d958919dSliuzhongzhu struct hclge_desc desc; 1034d958919dSliuzhongzhu int ret; 1035d958919dSliuzhongzhu 1036d958919dSliuzhongzhu hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_CFG_MAC_PARA, true); 1037d958919dSliuzhongzhu 1038d958919dSliuzhongzhu ret = hclge_cmd_send(&hdev->hw, &desc, 1); 1039d958919dSliuzhongzhu if (ret) { 1040ed5b255bSYufeng Mo dev_err(&hdev->pdev->dev, "dump checksum fail, ret = %d\n", 1041d958919dSliuzhongzhu ret); 1042d958919dSliuzhongzhu return; 1043d958919dSliuzhongzhu } 1044d958919dSliuzhongzhu 1045d958919dSliuzhongzhu pause_param = (struct hclge_cfg_pause_param_cmd *)desc.data; 1046d958919dSliuzhongzhu dev_info(&hdev->pdev->dev, "dump qos pause cfg\n"); 1047d958919dSliuzhongzhu dev_info(&hdev->pdev->dev, "pause_trans_gap: 0x%x\n", 1048d958919dSliuzhongzhu pause_param->pause_trans_gap); 1049d958919dSliuzhongzhu dev_info(&hdev->pdev->dev, "pause_trans_time: 0x%x\n", 105039edaf24SGuojia Liao le16_to_cpu(pause_param->pause_trans_time)); 1051d958919dSliuzhongzhu } 1052d958919dSliuzhongzhu 10536fc22440Sliuzhongzhu static void hclge_dbg_dump_qos_pri_map(struct hclge_dev *hdev) 10546fc22440Sliuzhongzhu { 10556fc22440Sliuzhongzhu struct hclge_qos_pri_map_cmd *pri_map; 10566fc22440Sliuzhongzhu struct hclge_desc desc; 10576fc22440Sliuzhongzhu int ret; 10586fc22440Sliuzhongzhu 10596fc22440Sliuzhongzhu hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_PRI_TO_TC_MAPPING, true); 10606fc22440Sliuzhongzhu 10616fc22440Sliuzhongzhu ret = hclge_cmd_send(&hdev->hw, &desc, 1); 10626fc22440Sliuzhongzhu if (ret) { 10636fc22440Sliuzhongzhu dev_err(&hdev->pdev->dev, 1064ed5b255bSYufeng Mo "dump qos pri map fail, ret = %d\n", ret); 10656fc22440Sliuzhongzhu return; 10666fc22440Sliuzhongzhu } 10676fc22440Sliuzhongzhu 10686fc22440Sliuzhongzhu pri_map = (struct hclge_qos_pri_map_cmd *)desc.data; 10696fc22440Sliuzhongzhu dev_info(&hdev->pdev->dev, "dump qos pri map\n"); 10706fc22440Sliuzhongzhu dev_info(&hdev->pdev->dev, "vlan_to_pri: 0x%x\n", pri_map->vlan_pri); 10716fc22440Sliuzhongzhu dev_info(&hdev->pdev->dev, "pri_0_to_tc: 0x%x\n", pri_map->pri0_tc); 10726fc22440Sliuzhongzhu dev_info(&hdev->pdev->dev, "pri_1_to_tc: 0x%x\n", pri_map->pri1_tc); 10736fc22440Sliuzhongzhu dev_info(&hdev->pdev->dev, "pri_2_to_tc: 0x%x\n", pri_map->pri2_tc); 10746fc22440Sliuzhongzhu dev_info(&hdev->pdev->dev, "pri_3_to_tc: 0x%x\n", pri_map->pri3_tc); 10756fc22440Sliuzhongzhu dev_info(&hdev->pdev->dev, "pri_4_to_tc: 0x%x\n", pri_map->pri4_tc); 10766fc22440Sliuzhongzhu dev_info(&hdev->pdev->dev, "pri_5_to_tc: 0x%x\n", pri_map->pri5_tc); 10776fc22440Sliuzhongzhu dev_info(&hdev->pdev->dev, "pri_6_to_tc: 0x%x\n", pri_map->pri6_tc); 10786fc22440Sliuzhongzhu dev_info(&hdev->pdev->dev, "pri_7_to_tc: 0x%x\n", pri_map->pri7_tc); 10796fc22440Sliuzhongzhu } 10806fc22440Sliuzhongzhu 1081b3712fa7SJian Shen static int hclge_dbg_dump_tx_buf_cfg(struct hclge_dev *hdev) 10827d9d7f88Sliuzhongzhu { 10837d9d7f88Sliuzhongzhu struct hclge_tx_buff_alloc_cmd *tx_buf_cmd; 1084b3712fa7SJian Shen struct hclge_desc desc; 10857d9d7f88Sliuzhongzhu int i, ret; 10867d9d7f88Sliuzhongzhu 1087b3712fa7SJian Shen hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_TX_BUFF_ALLOC, true); 1088b3712fa7SJian Shen ret = hclge_cmd_send(&hdev->hw, &desc, 1); 10897d9d7f88Sliuzhongzhu if (ret) 1090b3712fa7SJian Shen return ret; 10917d9d7f88Sliuzhongzhu 10927d9d7f88Sliuzhongzhu dev_info(&hdev->pdev->dev, "dump qos buf cfg\n"); 1093b3712fa7SJian Shen tx_buf_cmd = (struct hclge_tx_buff_alloc_cmd *)desc.data; 1094f9f07091Sliuzhongzhu for (i = 0; i < HCLGE_MAX_TC_NUM; i++) 10957d9d7f88Sliuzhongzhu dev_info(&hdev->pdev->dev, "tx_packet_buf_tc_%d: 0x%x\n", i, 109639edaf24SGuojia Liao le16_to_cpu(tx_buf_cmd->tx_pkt_buff[i])); 10977d9d7f88Sliuzhongzhu 1098b3712fa7SJian Shen return 0; 1099b3712fa7SJian Shen } 1100b3712fa7SJian Shen 1101b3712fa7SJian Shen static int hclge_dbg_dump_rx_priv_buf_cfg(struct hclge_dev *hdev) 1102b3712fa7SJian Shen { 1103b3712fa7SJian Shen struct hclge_rx_priv_buff_cmd *rx_buf_cmd; 1104b3712fa7SJian Shen struct hclge_desc desc; 1105b3712fa7SJian Shen int i, ret; 1106b3712fa7SJian Shen 1107b3712fa7SJian Shen hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_RX_PRIV_BUFF_ALLOC, true); 1108b3712fa7SJian Shen ret = hclge_cmd_send(&hdev->hw, &desc, 1); 11097d9d7f88Sliuzhongzhu if (ret) 1110b3712fa7SJian Shen return ret; 11117d9d7f88Sliuzhongzhu 11127d9d7f88Sliuzhongzhu dev_info(&hdev->pdev->dev, "\n"); 1113b3712fa7SJian Shen rx_buf_cmd = (struct hclge_rx_priv_buff_cmd *)desc.data; 1114f9f07091Sliuzhongzhu for (i = 0; i < HCLGE_MAX_TC_NUM; i++) 11157d9d7f88Sliuzhongzhu dev_info(&hdev->pdev->dev, "rx_packet_buf_tc_%d: 0x%x\n", i, 111639edaf24SGuojia Liao le16_to_cpu(rx_buf_cmd->buf_num[i])); 11177d9d7f88Sliuzhongzhu 11187d9d7f88Sliuzhongzhu dev_info(&hdev->pdev->dev, "rx_share_buf: 0x%x\n", 111939edaf24SGuojia Liao le16_to_cpu(rx_buf_cmd->shared_buf)); 11207d9d7f88Sliuzhongzhu 1121b3712fa7SJian Shen return 0; 1122b3712fa7SJian Shen } 11233f0f3253SYufeng Mo 1124b3712fa7SJian Shen static int hclge_dbg_dump_rx_common_wl_cfg(struct hclge_dev *hdev) 1125b3712fa7SJian Shen { 1126b3712fa7SJian Shen struct hclge_rx_com_wl *rx_com_wl; 1127b3712fa7SJian Shen struct hclge_desc desc; 1128b3712fa7SJian Shen int ret; 1129b3712fa7SJian Shen 1130b3712fa7SJian Shen hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_RX_COM_WL_ALLOC, true); 1131b3712fa7SJian Shen ret = hclge_cmd_send(&hdev->hw, &desc, 1); 1132b3712fa7SJian Shen if (ret) 1133b3712fa7SJian Shen return ret; 1134b3712fa7SJian Shen 1135b3712fa7SJian Shen rx_com_wl = (struct hclge_rx_com_wl *)desc.data; 11363f0f3253SYufeng Mo dev_info(&hdev->pdev->dev, "\n"); 11373f0f3253SYufeng Mo dev_info(&hdev->pdev->dev, "rx_com_wl: high: 0x%x, low: 0x%x\n", 113839edaf24SGuojia Liao le16_to_cpu(rx_com_wl->com_wl.high), 113939edaf24SGuojia Liao le16_to_cpu(rx_com_wl->com_wl.low)); 11403f0f3253SYufeng Mo 1141b3712fa7SJian Shen return 0; 1142b3712fa7SJian Shen } 11433f0f3253SYufeng Mo 1144b3712fa7SJian Shen static int hclge_dbg_dump_rx_global_pkt_cnt(struct hclge_dev *hdev) 1145b3712fa7SJian Shen { 1146b3712fa7SJian Shen struct hclge_rx_com_wl *rx_packet_cnt; 1147b3712fa7SJian Shen struct hclge_desc desc; 1148b3712fa7SJian Shen int ret; 1149b3712fa7SJian Shen 1150b3712fa7SJian Shen hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_RX_GBL_PKT_CNT, true); 1151b3712fa7SJian Shen ret = hclge_cmd_send(&hdev->hw, &desc, 1); 1152b3712fa7SJian Shen if (ret) 1153b3712fa7SJian Shen return ret; 1154b3712fa7SJian Shen 1155b3712fa7SJian Shen rx_packet_cnt = (struct hclge_rx_com_wl *)desc.data; 11563f0f3253SYufeng Mo dev_info(&hdev->pdev->dev, 11573f0f3253SYufeng Mo "rx_global_packet_cnt: high: 0x%x, low: 0x%x\n", 115839edaf24SGuojia Liao le16_to_cpu(rx_packet_cnt->com_wl.high), 115939edaf24SGuojia Liao le16_to_cpu(rx_packet_cnt->com_wl.low)); 11603f0f3253SYufeng Mo 1161b3712fa7SJian Shen return 0; 11623f0f3253SYufeng Mo } 1163b3712fa7SJian Shen 1164b3712fa7SJian Shen static int hclge_dbg_dump_rx_priv_wl_buf_cfg(struct hclge_dev *hdev) 1165b3712fa7SJian Shen { 1166b3712fa7SJian Shen struct hclge_rx_priv_wl_buf *rx_priv_wl; 1167b3712fa7SJian Shen struct hclge_desc desc[2]; 1168b3712fa7SJian Shen int i, ret; 1169b3712fa7SJian Shen 1170b3712fa7SJian Shen hclge_cmd_setup_basic_desc(&desc[0], HCLGE_OPC_RX_PRIV_WL_ALLOC, true); 11717d9d7f88Sliuzhongzhu desc[0].flag |= cpu_to_le16(HCLGE_CMD_FLAG_NEXT); 1172b3712fa7SJian Shen hclge_cmd_setup_basic_desc(&desc[1], HCLGE_OPC_RX_PRIV_WL_ALLOC, true); 11737d9d7f88Sliuzhongzhu ret = hclge_cmd_send(&hdev->hw, desc, 2); 11747d9d7f88Sliuzhongzhu if (ret) 1175b3712fa7SJian Shen return ret; 11767d9d7f88Sliuzhongzhu 11777d9d7f88Sliuzhongzhu rx_priv_wl = (struct hclge_rx_priv_wl_buf *)desc[0].data; 11787d9d7f88Sliuzhongzhu for (i = 0; i < HCLGE_TC_NUM_ONE_DESC; i++) 11797d9d7f88Sliuzhongzhu dev_info(&hdev->pdev->dev, 11807d9d7f88Sliuzhongzhu "rx_priv_wl_tc_%d: high: 0x%x, low: 0x%x\n", i, 118139edaf24SGuojia Liao le16_to_cpu(rx_priv_wl->tc_wl[i].high), 118239edaf24SGuojia Liao le16_to_cpu(rx_priv_wl->tc_wl[i].low)); 11837d9d7f88Sliuzhongzhu 11847d9d7f88Sliuzhongzhu rx_priv_wl = (struct hclge_rx_priv_wl_buf *)desc[1].data; 11857d9d7f88Sliuzhongzhu for (i = 0; i < HCLGE_TC_NUM_ONE_DESC; i++) 11867d9d7f88Sliuzhongzhu dev_info(&hdev->pdev->dev, 11876f92bfd7SHuazhong Tan "rx_priv_wl_tc_%d: high: 0x%x, low: 0x%x\n", 11886f92bfd7SHuazhong Tan i + HCLGE_TC_NUM_ONE_DESC, 118939edaf24SGuojia Liao le16_to_cpu(rx_priv_wl->tc_wl[i].high), 119039edaf24SGuojia Liao le16_to_cpu(rx_priv_wl->tc_wl[i].low)); 11917d9d7f88Sliuzhongzhu 1192b3712fa7SJian Shen return 0; 1193b3712fa7SJian Shen } 1194b3712fa7SJian Shen 1195b3712fa7SJian Shen static int hclge_dbg_dump_rx_common_threshold_cfg(struct hclge_dev *hdev) 1196b3712fa7SJian Shen { 1197b3712fa7SJian Shen struct hclge_rx_com_thrd *rx_com_thrd; 1198b3712fa7SJian Shen struct hclge_desc desc[2]; 1199b3712fa7SJian Shen int i, ret; 1200b3712fa7SJian Shen 1201b3712fa7SJian Shen hclge_cmd_setup_basic_desc(&desc[0], HCLGE_OPC_RX_COM_THRD_ALLOC, true); 12027d9d7f88Sliuzhongzhu desc[0].flag |= cpu_to_le16(HCLGE_CMD_FLAG_NEXT); 1203b3712fa7SJian Shen hclge_cmd_setup_basic_desc(&desc[1], HCLGE_OPC_RX_COM_THRD_ALLOC, true); 12047d9d7f88Sliuzhongzhu ret = hclge_cmd_send(&hdev->hw, desc, 2); 12057d9d7f88Sliuzhongzhu if (ret) 1206b3712fa7SJian Shen return ret; 12077d9d7f88Sliuzhongzhu 12087d9d7f88Sliuzhongzhu dev_info(&hdev->pdev->dev, "\n"); 12097d9d7f88Sliuzhongzhu rx_com_thrd = (struct hclge_rx_com_thrd *)desc[0].data; 12107d9d7f88Sliuzhongzhu for (i = 0; i < HCLGE_TC_NUM_ONE_DESC; i++) 12117d9d7f88Sliuzhongzhu dev_info(&hdev->pdev->dev, 12127d9d7f88Sliuzhongzhu "rx_com_thrd_tc_%d: high: 0x%x, low: 0x%x\n", i, 121339edaf24SGuojia Liao le16_to_cpu(rx_com_thrd->com_thrd[i].high), 121439edaf24SGuojia Liao le16_to_cpu(rx_com_thrd->com_thrd[i].low)); 12157d9d7f88Sliuzhongzhu 12167d9d7f88Sliuzhongzhu rx_com_thrd = (struct hclge_rx_com_thrd *)desc[1].data; 12177d9d7f88Sliuzhongzhu for (i = 0; i < HCLGE_TC_NUM_ONE_DESC; i++) 12187d9d7f88Sliuzhongzhu dev_info(&hdev->pdev->dev, 12196f92bfd7SHuazhong Tan "rx_com_thrd_tc_%d: high: 0x%x, low: 0x%x\n", 12206f92bfd7SHuazhong Tan i + HCLGE_TC_NUM_ONE_DESC, 122139edaf24SGuojia Liao le16_to_cpu(rx_com_thrd->com_thrd[i].high), 122239edaf24SGuojia Liao le16_to_cpu(rx_com_thrd->com_thrd[i].low)); 1223b3712fa7SJian Shen 1224b3712fa7SJian Shen return 0; 1225b3712fa7SJian Shen } 1226b3712fa7SJian Shen 1227b3712fa7SJian Shen static void hclge_dbg_dump_qos_buf_cfg(struct hclge_dev *hdev) 1228b3712fa7SJian Shen { 1229b3712fa7SJian Shen enum hclge_opcode_type cmd; 1230b3712fa7SJian Shen int ret; 1231b3712fa7SJian Shen 1232b3712fa7SJian Shen cmd = HCLGE_OPC_TX_BUFF_ALLOC; 1233b3712fa7SJian Shen ret = hclge_dbg_dump_tx_buf_cfg(hdev); 1234b3712fa7SJian Shen if (ret) 1235b3712fa7SJian Shen goto err_qos_cmd_send; 1236b3712fa7SJian Shen 1237b3712fa7SJian Shen cmd = HCLGE_OPC_RX_PRIV_BUFF_ALLOC; 1238b3712fa7SJian Shen ret = hclge_dbg_dump_rx_priv_buf_cfg(hdev); 1239b3712fa7SJian Shen if (ret) 1240b3712fa7SJian Shen goto err_qos_cmd_send; 1241b3712fa7SJian Shen 1242b3712fa7SJian Shen cmd = HCLGE_OPC_RX_COM_WL_ALLOC; 1243b3712fa7SJian Shen ret = hclge_dbg_dump_rx_common_wl_cfg(hdev); 1244b3712fa7SJian Shen if (ret) 1245b3712fa7SJian Shen goto err_qos_cmd_send; 1246b3712fa7SJian Shen 1247b3712fa7SJian Shen cmd = HCLGE_OPC_RX_GBL_PKT_CNT; 1248b3712fa7SJian Shen ret = hclge_dbg_dump_rx_global_pkt_cnt(hdev); 1249b3712fa7SJian Shen if (ret) 1250b3712fa7SJian Shen goto err_qos_cmd_send; 1251b3712fa7SJian Shen 1252b3712fa7SJian Shen dev_info(&hdev->pdev->dev, "\n"); 1253b3712fa7SJian Shen if (!hnae3_dev_dcb_supported(hdev)) { 1254b3712fa7SJian Shen dev_info(&hdev->pdev->dev, 1255b3712fa7SJian Shen "Only DCB-supported dev supports rx priv wl\n"); 1256b3712fa7SJian Shen return; 1257b3712fa7SJian Shen } 1258b3712fa7SJian Shen 1259b3712fa7SJian Shen cmd = HCLGE_OPC_RX_PRIV_WL_ALLOC; 1260b3712fa7SJian Shen ret = hclge_dbg_dump_rx_priv_wl_buf_cfg(hdev); 1261b3712fa7SJian Shen if (ret) 1262b3712fa7SJian Shen goto err_qos_cmd_send; 1263b3712fa7SJian Shen 1264b3712fa7SJian Shen cmd = HCLGE_OPC_RX_COM_THRD_ALLOC; 1265b3712fa7SJian Shen ret = hclge_dbg_dump_rx_common_threshold_cfg(hdev); 1266b3712fa7SJian Shen if (ret) 1267b3712fa7SJian Shen goto err_qos_cmd_send; 1268b3712fa7SJian Shen 12697d9d7f88Sliuzhongzhu return; 12707d9d7f88Sliuzhongzhu 12717d9d7f88Sliuzhongzhu err_qos_cmd_send: 12727d9d7f88Sliuzhongzhu dev_err(&hdev->pdev->dev, 1273ed5b255bSYufeng Mo "dump qos buf cfg fail(0x%x), ret = %d\n", cmd, ret); 12747d9d7f88Sliuzhongzhu } 12757d9d7f88Sliuzhongzhu 12768ddfd9c4SYufeng Mo static int hclge_dbg_dump_mng_table(struct hclge_dev *hdev, char *buf, int len) 12777737f1fbSliuzhongzhu { 12787737f1fbSliuzhongzhu struct hclge_mac_ethertype_idx_rd_cmd *req0; 12797737f1fbSliuzhongzhu struct hclge_desc desc; 128072fa4904SGuojia Liao u32 msg_egress_port; 12818ddfd9c4SYufeng Mo int pos = 0; 12827737f1fbSliuzhongzhu int ret, i; 12837737f1fbSliuzhongzhu 12848ddfd9c4SYufeng Mo pos += scnprintf(buf + pos, len - pos, 12858ddfd9c4SYufeng Mo "entry mac_addr mask ether "); 12868ddfd9c4SYufeng Mo pos += scnprintf(buf + pos, len - pos, 12878ddfd9c4SYufeng Mo "mask vlan mask i_map i_dir e_type "); 12888ddfd9c4SYufeng Mo pos += scnprintf(buf + pos, len - pos, "pf_id vf_id q_id drop\n"); 12897737f1fbSliuzhongzhu 12907737f1fbSliuzhongzhu for (i = 0; i < HCLGE_DBG_MNG_TBL_MAX; i++) { 12917737f1fbSliuzhongzhu hclge_cmd_setup_basic_desc(&desc, HCLGE_MAC_ETHERTYPE_IDX_RD, 12927737f1fbSliuzhongzhu true); 12937737f1fbSliuzhongzhu req0 = (struct hclge_mac_ethertype_idx_rd_cmd *)&desc.data; 12947737f1fbSliuzhongzhu req0->index = cpu_to_le16(i); 12957737f1fbSliuzhongzhu 12967737f1fbSliuzhongzhu ret = hclge_cmd_send(&hdev->hw, &desc, 1); 12977737f1fbSliuzhongzhu if (ret) { 12987737f1fbSliuzhongzhu dev_err(&hdev->pdev->dev, 12998ddfd9c4SYufeng Mo "failed to dump manage table, ret = %d\n", ret); 13008ddfd9c4SYufeng Mo return ret; 13017737f1fbSliuzhongzhu } 13027737f1fbSliuzhongzhu 13037737f1fbSliuzhongzhu if (!req0->resp_code) 13047737f1fbSliuzhongzhu continue; 13057737f1fbSliuzhongzhu 13068ddfd9c4SYufeng Mo pos += scnprintf(buf + pos, len - pos, "%02u %pM ", 13078ddfd9c4SYufeng Mo le16_to_cpu(req0->index), req0->mac_addr); 13087737f1fbSliuzhongzhu 13098ddfd9c4SYufeng Mo pos += scnprintf(buf + pos, len - pos, 13108ddfd9c4SYufeng Mo "%x %04x %x %04x ", 13117737f1fbSliuzhongzhu !!(req0->flags & HCLGE_DBG_MNG_MAC_MASK_B), 131272fa4904SGuojia Liao le16_to_cpu(req0->ethter_type), 13137737f1fbSliuzhongzhu !!(req0->flags & HCLGE_DBG_MNG_ETHER_MASK_B), 13148ddfd9c4SYufeng Mo le16_to_cpu(req0->vlan_tag) & 13158ddfd9c4SYufeng Mo HCLGE_DBG_MNG_VLAN_TAG); 13168ddfd9c4SYufeng Mo 13178ddfd9c4SYufeng Mo pos += scnprintf(buf + pos, len - pos, 13188ddfd9c4SYufeng Mo "%x %02x %02x ", 13197737f1fbSliuzhongzhu !!(req0->flags & HCLGE_DBG_MNG_VLAN_MASK_B), 13207737f1fbSliuzhongzhu req0->i_port_bitmap, req0->i_port_direction); 13217737f1fbSliuzhongzhu 132272fa4904SGuojia Liao msg_egress_port = le16_to_cpu(req0->egress_port); 13238ddfd9c4SYufeng Mo pos += scnprintf(buf + pos, len - pos, 13248ddfd9c4SYufeng Mo "%x %x %02x %04x %x\n", 132572fa4904SGuojia Liao !!(msg_egress_port & HCLGE_DBG_MNG_E_TYPE_B), 132672fa4904SGuojia Liao msg_egress_port & HCLGE_DBG_MNG_PF_ID, 132772fa4904SGuojia Liao (msg_egress_port >> 3) & HCLGE_DBG_MNG_VF_ID, 132872fa4904SGuojia Liao le16_to_cpu(req0->egress_queue), 132972fa4904SGuojia Liao !!(msg_egress_port & HCLGE_DBG_MNG_DROP_B)); 13307737f1fbSliuzhongzhu } 13318ddfd9c4SYufeng Mo 13328ddfd9c4SYufeng Mo return 0; 13337737f1fbSliuzhongzhu } 13347737f1fbSliuzhongzhu 1335b5a0b70dSHao Chen #define HCLGE_DBG_TCAM_BUF_SIZE 256 1336b5a0b70dSHao Chen 1337b5a0b70dSHao Chen static int hclge_dbg_fd_tcam_read(struct hclge_dev *hdev, bool sel_x, 1338b5a0b70dSHao Chen char *tcam_buf, 1339b5a0b70dSHao Chen struct hclge_dbg_tcam_msg tcam_msg) 13403c666b58Sliuzhongzhu { 13413c666b58Sliuzhongzhu struct hclge_fd_tcam_config_1_cmd *req1; 13423c666b58Sliuzhongzhu struct hclge_fd_tcam_config_2_cmd *req2; 13433c666b58Sliuzhongzhu struct hclge_fd_tcam_config_3_cmd *req3; 13443c666b58Sliuzhongzhu struct hclge_desc desc[3]; 1345b5a0b70dSHao Chen int pos = 0; 13463c666b58Sliuzhongzhu int ret, i; 13473c666b58Sliuzhongzhu u32 *req; 13483c666b58Sliuzhongzhu 13493c666b58Sliuzhongzhu hclge_cmd_setup_basic_desc(&desc[0], HCLGE_OPC_FD_TCAM_OP, true); 13503c666b58Sliuzhongzhu desc[0].flag |= cpu_to_le16(HCLGE_CMD_FLAG_NEXT); 13513c666b58Sliuzhongzhu hclge_cmd_setup_basic_desc(&desc[1], HCLGE_OPC_FD_TCAM_OP, true); 13523c666b58Sliuzhongzhu desc[1].flag |= cpu_to_le16(HCLGE_CMD_FLAG_NEXT); 13533c666b58Sliuzhongzhu hclge_cmd_setup_basic_desc(&desc[2], HCLGE_OPC_FD_TCAM_OP, true); 13543c666b58Sliuzhongzhu 13553c666b58Sliuzhongzhu req1 = (struct hclge_fd_tcam_config_1_cmd *)desc[0].data; 13563c666b58Sliuzhongzhu req2 = (struct hclge_fd_tcam_config_2_cmd *)desc[1].data; 13573c666b58Sliuzhongzhu req3 = (struct hclge_fd_tcam_config_3_cmd *)desc[2].data; 13583c666b58Sliuzhongzhu 1359b5a0b70dSHao Chen req1->stage = tcam_msg.stage; 13603c666b58Sliuzhongzhu req1->xy_sel = sel_x ? 1 : 0; 1361b5a0b70dSHao Chen req1->index = cpu_to_le32(tcam_msg.loc); 13623c666b58Sliuzhongzhu 13633c666b58Sliuzhongzhu ret = hclge_cmd_send(&hdev->hw, desc, 3); 13643c666b58Sliuzhongzhu if (ret) 136544b6b883SYufeng Mo return ret; 13663c666b58Sliuzhongzhu 1367b5a0b70dSHao Chen pos += scnprintf(tcam_buf + pos, HCLGE_DBG_TCAM_BUF_SIZE - pos, 1368b5a0b70dSHao Chen "read result tcam key %s(%u):\n", sel_x ? "x" : "y", 1369b5a0b70dSHao Chen tcam_msg.loc); 13703c666b58Sliuzhongzhu 137146ee7350SGuojia Liao /* tcam_data0 ~ tcam_data1 */ 13723c666b58Sliuzhongzhu req = (u32 *)req1->tcam_data; 13733c666b58Sliuzhongzhu for (i = 0; i < 2; i++) 1374b5a0b70dSHao Chen pos += scnprintf(tcam_buf + pos, HCLGE_DBG_TCAM_BUF_SIZE - pos, 1375b5a0b70dSHao Chen "%08x\n", *req++); 13763c666b58Sliuzhongzhu 137746ee7350SGuojia Liao /* tcam_data2 ~ tcam_data7 */ 13783c666b58Sliuzhongzhu req = (u32 *)req2->tcam_data; 13793c666b58Sliuzhongzhu for (i = 0; i < 6; i++) 1380b5a0b70dSHao Chen pos += scnprintf(tcam_buf + pos, HCLGE_DBG_TCAM_BUF_SIZE - pos, 1381b5a0b70dSHao Chen "%08x\n", *req++); 13823c666b58Sliuzhongzhu 138346ee7350SGuojia Liao /* tcam_data8 ~ tcam_data12 */ 13843c666b58Sliuzhongzhu req = (u32 *)req3->tcam_data; 13853c666b58Sliuzhongzhu for (i = 0; i < 5; i++) 1386b5a0b70dSHao Chen pos += scnprintf(tcam_buf + pos, HCLGE_DBG_TCAM_BUF_SIZE - pos, 1387b5a0b70dSHao Chen "%08x\n", *req++); 138844b6b883SYufeng Mo 138944b6b883SYufeng Mo return ret; 139044b6b883SYufeng Mo } 139144b6b883SYufeng Mo 139244b6b883SYufeng Mo static int hclge_dbg_get_rules_location(struct hclge_dev *hdev, u16 *rule_locs) 139344b6b883SYufeng Mo { 139444b6b883SYufeng Mo struct hclge_fd_rule *rule; 139544b6b883SYufeng Mo struct hlist_node *node; 139644b6b883SYufeng Mo int cnt = 0; 139744b6b883SYufeng Mo 139844b6b883SYufeng Mo spin_lock_bh(&hdev->fd_rule_lock); 139944b6b883SYufeng Mo hlist_for_each_entry_safe(rule, node, &hdev->fd_rule_list, rule_node) { 140044b6b883SYufeng Mo rule_locs[cnt] = rule->location; 140144b6b883SYufeng Mo cnt++; 140244b6b883SYufeng Mo } 140344b6b883SYufeng Mo spin_unlock_bh(&hdev->fd_rule_lock); 140444b6b883SYufeng Mo 1405b5a0b70dSHao Chen if (cnt != hdev->hclge_fd_rule_num || cnt == 0) 140644b6b883SYufeng Mo return -EINVAL; 140744b6b883SYufeng Mo 140844b6b883SYufeng Mo return cnt; 14093c666b58Sliuzhongzhu } 14103c666b58Sliuzhongzhu 1411b5a0b70dSHao Chen static int hclge_dbg_dump_fd_tcam(struct hclge_dev *hdev, char *buf, int len) 14123c666b58Sliuzhongzhu { 1413b5a0b70dSHao Chen u32 rule_num = hdev->fd_cfg.rule_num[HCLGE_FD_STAGE_1]; 1414b5a0b70dSHao Chen struct hclge_dbg_tcam_msg tcam_msg; 141544b6b883SYufeng Mo int i, ret, rule_cnt; 141644b6b883SYufeng Mo u16 *rule_locs; 1417b5a0b70dSHao Chen char *tcam_buf; 1418b5a0b70dSHao Chen int pos = 0; 14193c666b58Sliuzhongzhu 142044b6b883SYufeng Mo if (!hnae3_dev_fd_supported(hdev)) { 142144b6b883SYufeng Mo dev_err(&hdev->pdev->dev, 142244b6b883SYufeng Mo "Only FD-supported dev supports dump fd tcam\n"); 1423b5a0b70dSHao Chen return -EOPNOTSUPP; 14243c666b58Sliuzhongzhu } 142544b6b883SYufeng Mo 1426b5a0b70dSHao Chen if (!hdev->hclge_fd_rule_num || !rule_num) 1427b5a0b70dSHao Chen return 0; 142844b6b883SYufeng Mo 1429b5a0b70dSHao Chen rule_locs = kcalloc(rule_num, sizeof(u16), GFP_KERNEL); 143044b6b883SYufeng Mo if (!rule_locs) 1431b5a0b70dSHao Chen return -ENOMEM; 1432b5a0b70dSHao Chen 1433b5a0b70dSHao Chen tcam_buf = kzalloc(HCLGE_DBG_TCAM_BUF_SIZE, GFP_KERNEL); 1434b5a0b70dSHao Chen if (!tcam_buf) { 1435b5a0b70dSHao Chen kfree(rule_locs); 1436b5a0b70dSHao Chen return -ENOMEM; 1437b5a0b70dSHao Chen } 143844b6b883SYufeng Mo 143944b6b883SYufeng Mo rule_cnt = hclge_dbg_get_rules_location(hdev, rule_locs); 1440b5a0b70dSHao Chen if (rule_cnt < 0) { 1441b5a0b70dSHao Chen ret = rule_cnt; 144244b6b883SYufeng Mo dev_err(&hdev->pdev->dev, 1443b5a0b70dSHao Chen "failed to get rule number, ret = %d\n", ret); 1444b5a0b70dSHao Chen goto out; 144544b6b883SYufeng Mo } 144644b6b883SYufeng Mo 144744b6b883SYufeng Mo for (i = 0; i < rule_cnt; i++) { 1448b5a0b70dSHao Chen tcam_msg.stage = HCLGE_FD_STAGE_1; 1449b5a0b70dSHao Chen tcam_msg.loc = rule_locs[i]; 1450b5a0b70dSHao Chen 1451b5a0b70dSHao Chen ret = hclge_dbg_fd_tcam_read(hdev, true, tcam_buf, tcam_msg); 145244b6b883SYufeng Mo if (ret) { 145344b6b883SYufeng Mo dev_err(&hdev->pdev->dev, 145444b6b883SYufeng Mo "failed to get fd tcam key x, ret = %d\n", ret); 1455b5a0b70dSHao Chen goto out; 145644b6b883SYufeng Mo } 145744b6b883SYufeng Mo 1458b5a0b70dSHao Chen pos += scnprintf(buf + pos, len - pos, "%s", tcam_buf); 1459b5a0b70dSHao Chen 1460b5a0b70dSHao Chen ret = hclge_dbg_fd_tcam_read(hdev, false, tcam_buf, tcam_msg); 146144b6b883SYufeng Mo if (ret) { 146244b6b883SYufeng Mo dev_err(&hdev->pdev->dev, 146344b6b883SYufeng Mo "failed to get fd tcam key y, ret = %d\n", ret); 1464b5a0b70dSHao Chen goto out; 146544b6b883SYufeng Mo } 146644b6b883SYufeng Mo 1467b5a0b70dSHao Chen pos += scnprintf(buf + pos, len - pos, "%s", tcam_buf); 1468b5a0b70dSHao Chen } 1469b5a0b70dSHao Chen 1470b5a0b70dSHao Chen out: 1471b5a0b70dSHao Chen kfree(tcam_buf); 147244b6b883SYufeng Mo kfree(rule_locs); 1473b5a0b70dSHao Chen return ret; 14743c666b58Sliuzhongzhu } 14753c666b58Sliuzhongzhu 14761a7ff828SJiaran Zhang int hclge_dbg_dump_rst_info(struct hclge_dev *hdev, char *buf, int len) 1477f02eb82dSHuazhong Tan { 14781a7ff828SJiaran Zhang int pos = 0; 14791a7ff828SJiaran Zhang 14801a7ff828SJiaran Zhang pos += scnprintf(buf + pos, len - pos, "PF reset count: %u\n", 1481f02eb82dSHuazhong Tan hdev->rst_stats.pf_rst_cnt); 14821a7ff828SJiaran Zhang pos += scnprintf(buf + pos, len - pos, "FLR reset count: %u\n", 1483f02eb82dSHuazhong Tan hdev->rst_stats.flr_rst_cnt); 14841a7ff828SJiaran Zhang pos += scnprintf(buf + pos, len - pos, "GLOBAL reset count: %u\n", 1485f02eb82dSHuazhong Tan hdev->rst_stats.global_rst_cnt); 14861a7ff828SJiaran Zhang pos += scnprintf(buf + pos, len - pos, "IMP reset count: %u\n", 1487f02eb82dSHuazhong Tan hdev->rst_stats.imp_rst_cnt); 14881a7ff828SJiaran Zhang pos += scnprintf(buf + pos, len - pos, "reset done count: %u\n", 1489f02eb82dSHuazhong Tan hdev->rst_stats.reset_done_cnt); 14901a7ff828SJiaran Zhang pos += scnprintf(buf + pos, len - pos, "HW reset done count: %u\n", 1491f02eb82dSHuazhong Tan hdev->rst_stats.hw_reset_done_cnt); 14921a7ff828SJiaran Zhang pos += scnprintf(buf + pos, len - pos, "reset count: %u\n", 1493f02eb82dSHuazhong Tan hdev->rst_stats.reset_cnt); 14941a7ff828SJiaran Zhang pos += scnprintf(buf + pos, len - pos, "reset fail count: %u\n", 14950ecf1f7bSHuazhong Tan hdev->rst_stats.reset_fail_cnt); 14961a7ff828SJiaran Zhang pos += scnprintf(buf + pos, len - pos, 14971a7ff828SJiaran Zhang "vector0 interrupt enable status: 0x%x\n", 14980ecf1f7bSHuazhong Tan hclge_read_dev(&hdev->hw, HCLGE_MISC_VECTOR_REG_BASE)); 14991a7ff828SJiaran Zhang pos += scnprintf(buf + pos, len - pos, "reset interrupt source: 0x%x\n", 15000ecf1f7bSHuazhong Tan hclge_read_dev(&hdev->hw, HCLGE_MISC_RESET_STS_REG)); 15011a7ff828SJiaran Zhang pos += scnprintf(buf + pos, len - pos, "reset interrupt status: 0x%x\n", 15020ecf1f7bSHuazhong Tan hclge_read_dev(&hdev->hw, HCLGE_MISC_VECTOR_INT_STS)); 15031a7ff828SJiaran Zhang pos += scnprintf(buf + pos, len - pos, "RAS interrupt status: 0x%x\n", 15041a7ff828SJiaran Zhang hclge_read_dev(&hdev->hw, 15051a7ff828SJiaran Zhang HCLGE_RAS_PF_OTHER_INT_STS_REG)); 15061a7ff828SJiaran Zhang pos += scnprintf(buf + pos, len - pos, "hardware reset status: 0x%x\n", 15070ecf1f7bSHuazhong Tan hclge_read_dev(&hdev->hw, HCLGE_GLOBAL_RESET_REG)); 15081a7ff828SJiaran Zhang pos += scnprintf(buf + pos, len - pos, "handshake status: 0x%x\n", 15090ecf1f7bSHuazhong Tan hclge_read_dev(&hdev->hw, HCLGE_NIC_CSQ_DEPTH_REG)); 15101a7ff828SJiaran Zhang pos += scnprintf(buf + pos, len - pos, "function reset status: 0x%x\n", 15110ecf1f7bSHuazhong Tan hclge_read_dev(&hdev->hw, HCLGE_FUN_RST_ING)); 15121a7ff828SJiaran Zhang pos += scnprintf(buf + pos, len - pos, "hdev state: 0x%lx\n", 15131a7ff828SJiaran Zhang hdev->state); 15141a7ff828SJiaran Zhang 15151a7ff828SJiaran Zhang return 0; 1516f02eb82dSHuazhong Tan } 1517f02eb82dSHuazhong Tan 15181c6dfe6fSYunsheng Lin static void hclge_dbg_dump_serv_info(struct hclge_dev *hdev) 15191c6dfe6fSYunsheng Lin { 15201c6dfe6fSYunsheng Lin dev_info(&hdev->pdev->dev, "last_serv_processed: %lu\n", 15211c6dfe6fSYunsheng Lin hdev->last_serv_processed); 15221c6dfe6fSYunsheng Lin dev_info(&hdev->pdev->dev, "last_serv_cnt: %lu\n", 15231c6dfe6fSYunsheng Lin hdev->serv_processed_cnt); 15241c6dfe6fSYunsheng Lin } 15251c6dfe6fSYunsheng Lin 15269149ca0fSJiaran Zhang static int hclge_dbg_dump_interrupt(struct hclge_dev *hdev, char *buf, int len) 1527348775ebSYufeng Mo { 15289149ca0fSJiaran Zhang int pos = 0; 15299149ca0fSJiaran Zhang 15309149ca0fSJiaran Zhang pos += scnprintf(buf + pos, len - pos, "num_nic_msi: %u\n", 15319149ca0fSJiaran Zhang hdev->num_nic_msi); 15329149ca0fSJiaran Zhang pos += scnprintf(buf + pos, len - pos, "num_roce_msi: %u\n", 15339149ca0fSJiaran Zhang hdev->num_roce_msi); 15349149ca0fSJiaran Zhang pos += scnprintf(buf + pos, len - pos, "num_msi_used: %u\n", 15359149ca0fSJiaran Zhang hdev->num_msi_used); 15369149ca0fSJiaran Zhang pos += scnprintf(buf + pos, len - pos, "num_msi_left: %u\n", 15379149ca0fSJiaran Zhang hdev->num_msi_left); 15389149ca0fSJiaran Zhang 15399149ca0fSJiaran Zhang return 0; 1540348775ebSYufeng Mo } 1541348775ebSYufeng Mo 15420b198b0dSJiaran Zhang static void hclge_dbg_imp_info_data_print(struct hclge_desc *desc_src, 15430b198b0dSJiaran Zhang char *buf, int len, u32 bd_num) 154433a90e2fSZhongzhu Liu { 15450b198b0dSJiaran Zhang #define HCLGE_DBG_IMP_INFO_PRINT_OFFSET 0x2 15460b198b0dSJiaran Zhang 15470b198b0dSJiaran Zhang struct hclge_desc *desc_index = desc_src; 15480b198b0dSJiaran Zhang u32 offset = 0; 15490b198b0dSJiaran Zhang int pos = 0; 15500b198b0dSJiaran Zhang u32 i, j; 15510b198b0dSJiaran Zhang 15520b198b0dSJiaran Zhang pos += scnprintf(buf + pos, len - pos, "offset | data\n"); 15530b198b0dSJiaran Zhang 15540b198b0dSJiaran Zhang for (i = 0; i < bd_num; i++) { 15550b198b0dSJiaran Zhang j = 0; 15560b198b0dSJiaran Zhang while (j < HCLGE_DESC_DATA_LEN - 1) { 15570b198b0dSJiaran Zhang pos += scnprintf(buf + pos, len - pos, "0x%04x | ", 15580b198b0dSJiaran Zhang offset); 15590b198b0dSJiaran Zhang pos += scnprintf(buf + pos, len - pos, "0x%08x ", 15600b198b0dSJiaran Zhang le32_to_cpu(desc_index->data[j++])); 15610b198b0dSJiaran Zhang pos += scnprintf(buf + pos, len - pos, "0x%08x\n", 15620b198b0dSJiaran Zhang le32_to_cpu(desc_index->data[j++])); 15630b198b0dSJiaran Zhang offset += sizeof(u32) * HCLGE_DBG_IMP_INFO_PRINT_OFFSET; 15640b198b0dSJiaran Zhang } 15650b198b0dSJiaran Zhang desc_index++; 15660b198b0dSJiaran Zhang } 15670b198b0dSJiaran Zhang } 15680b198b0dSJiaran Zhang 15690b198b0dSJiaran Zhang static int 15700b198b0dSJiaran Zhang hclge_dbg_get_imp_stats_info(struct hclge_dev *hdev, char *buf, int len) 15710b198b0dSJiaran Zhang { 15720b198b0dSJiaran Zhang struct hclge_get_imp_bd_cmd *req; 15730b198b0dSJiaran Zhang struct hclge_desc *desc_src; 157433a90e2fSZhongzhu Liu struct hclge_desc desc; 15750b198b0dSJiaran Zhang u32 bd_num; 15760b198b0dSJiaran Zhang int ret; 157733a90e2fSZhongzhu Liu 15780b198b0dSJiaran Zhang hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_IMP_STATS_BD, true); 157933a90e2fSZhongzhu Liu 15800b198b0dSJiaran Zhang req = (struct hclge_get_imp_bd_cmd *)desc.data; 158133a90e2fSZhongzhu Liu ret = hclge_cmd_send(&hdev->hw, &desc, 1); 158233a90e2fSZhongzhu Liu if (ret) { 158333a90e2fSZhongzhu Liu dev_err(&hdev->pdev->dev, 15840b198b0dSJiaran Zhang "failed to get imp statistics bd number, ret = %d\n", 158533a90e2fSZhongzhu Liu ret); 15860b198b0dSJiaran Zhang return ret; 158733a90e2fSZhongzhu Liu } 158833a90e2fSZhongzhu Liu 158933a90e2fSZhongzhu Liu bd_num = le32_to_cpu(req->bd_num); 159033a90e2fSZhongzhu Liu 15910b198b0dSJiaran Zhang desc_src = kcalloc(bd_num, sizeof(struct hclge_desc), GFP_KERNEL); 1592fbdc4d79SYufeng Mo if (!desc_src) 15930b198b0dSJiaran Zhang return -ENOMEM; 159433a90e2fSZhongzhu Liu 15950b198b0dSJiaran Zhang ret = hclge_dbg_cmd_send(hdev, desc_src, 0, bd_num, 15960b198b0dSJiaran Zhang HCLGE_OPC_IMP_STATS_INFO); 159733a90e2fSZhongzhu Liu if (ret) { 159833a90e2fSZhongzhu Liu kfree(desc_src); 159933a90e2fSZhongzhu Liu dev_err(&hdev->pdev->dev, 16000b198b0dSJiaran Zhang "failed to get imp statistics, ret = %d\n", ret); 16010b198b0dSJiaran Zhang return ret; 160233a90e2fSZhongzhu Liu } 160333a90e2fSZhongzhu Liu 16040b198b0dSJiaran Zhang hclge_dbg_imp_info_data_print(desc_src, buf, len, bd_num); 160533a90e2fSZhongzhu Liu 160633a90e2fSZhongzhu Liu kfree(desc_src); 16070b198b0dSJiaran Zhang 16080b198b0dSJiaran Zhang return 0; 160933a90e2fSZhongzhu Liu } 161033a90e2fSZhongzhu Liu 1611dec84660SYufeng Mo #define HCLGE_CMD_NCL_CONFIG_BD_NUM 5 1612e76e6886SJiaran Zhang #define HCLGE_MAX_NCL_CONFIG_LENGTH 16384 1613dec84660SYufeng Mo 1614e76e6886SJiaran Zhang static void hclge_ncl_config_data_print(struct hclge_desc *desc, int *index, 1615e76e6886SJiaran Zhang char *buf, int *len, int *pos) 1616dec84660SYufeng Mo { 1617dec84660SYufeng Mo #define HCLGE_CMD_DATA_NUM 6 1618dec84660SYufeng Mo 1619e76e6886SJiaran Zhang int offset = HCLGE_MAX_NCL_CONFIG_LENGTH - *index; 1620e76e6886SJiaran Zhang int i, j; 1621dec84660SYufeng Mo 1622dec84660SYufeng Mo for (i = 0; i < HCLGE_CMD_NCL_CONFIG_BD_NUM; i++) { 1623dec84660SYufeng Mo for (j = 0; j < HCLGE_CMD_DATA_NUM; j++) { 1624dec84660SYufeng Mo if (i == 0 && j == 0) 1625dec84660SYufeng Mo continue; 1626dec84660SYufeng Mo 1627e76e6886SJiaran Zhang *pos += scnprintf(buf + *pos, *len - *pos, 1628e76e6886SJiaran Zhang "0x%04x | 0x%08x\n", offset, 1629dec84660SYufeng Mo le32_to_cpu(desc[i].data[j])); 1630e76e6886SJiaran Zhang 1631e76e6886SJiaran Zhang offset += sizeof(u32); 1632e76e6886SJiaran Zhang *index -= sizeof(u32); 1633e76e6886SJiaran Zhang 1634e76e6886SJiaran Zhang if (*index <= 0) 1635dec84660SYufeng Mo return; 1636dec84660SYufeng Mo } 1637dec84660SYufeng Mo } 1638dec84660SYufeng Mo } 1639dec84660SYufeng Mo 1640e76e6886SJiaran Zhang static int 1641e76e6886SJiaran Zhang hclge_dbg_dump_ncl_config(struct hclge_dev *hdev, char *buf, int len) 1642ffd140e2SWeihang Li { 16434960cabfSYufeng Mo #define HCLGE_NCL_CONFIG_LENGTH_IN_EACH_CMD (20 + 24 * 4) 1644ffd140e2SWeihang Li 1645dec84660SYufeng Mo struct hclge_desc desc[HCLGE_CMD_NCL_CONFIG_BD_NUM]; 1646dec84660SYufeng Mo int bd_num = HCLGE_CMD_NCL_CONFIG_BD_NUM; 1647e76e6886SJiaran Zhang int index = HCLGE_MAX_NCL_CONFIG_LENGTH; 1648e76e6886SJiaran Zhang int pos = 0; 1649e76e6886SJiaran Zhang u32 data0; 1650ffd140e2SWeihang Li int ret; 1651ffd140e2SWeihang Li 1652e76e6886SJiaran Zhang pos += scnprintf(buf + pos, len - pos, "offset | data\n"); 1653b4401a04SYufeng Mo 1654e76e6886SJiaran Zhang while (index > 0) { 1655e76e6886SJiaran Zhang data0 = HCLGE_MAX_NCL_CONFIG_LENGTH - index; 1656e76e6886SJiaran Zhang if (index >= HCLGE_NCL_CONFIG_LENGTH_IN_EACH_CMD) 16574960cabfSYufeng Mo data0 |= HCLGE_NCL_CONFIG_LENGTH_IN_EACH_CMD << 16; 1658ffd140e2SWeihang Li else 1659e76e6886SJiaran Zhang data0 |= (u32)index << 16; 1660ffd140e2SWeihang Li ret = hclge_dbg_cmd_send(hdev, desc, data0, bd_num, 1661ffd140e2SWeihang Li HCLGE_OPC_QUERY_NCL_CONFIG); 1662ffd140e2SWeihang Li if (ret) 1663e76e6886SJiaran Zhang return ret; 1664ffd140e2SWeihang Li 1665e76e6886SJiaran Zhang hclge_ncl_config_data_print(desc, &index, buf, &len, &pos); 1666ffd140e2SWeihang Li } 1667e76e6886SJiaran Zhang 1668e76e6886SJiaran Zhang return 0; 1669ffd140e2SWeihang Li } 1670ffd140e2SWeihang Li 1671d658ff34SYufeng Mo static int hclge_dbg_dump_loopback(struct hclge_dev *hdev, char *buf, int len) 1672ded45d40SYufeng Mo { 1673ded45d40SYufeng Mo struct phy_device *phydev = hdev->hw.mac.phydev; 1674ded45d40SYufeng Mo struct hclge_config_mac_mode_cmd *req_app; 1675b47cfe1fSGuangbin Huang struct hclge_common_lb_cmd *req_common; 1676ded45d40SYufeng Mo struct hclge_desc desc; 1677ded45d40SYufeng Mo u8 loopback_en; 1678d658ff34SYufeng Mo int pos = 0; 1679ded45d40SYufeng Mo int ret; 1680ded45d40SYufeng Mo 1681ded45d40SYufeng Mo req_app = (struct hclge_config_mac_mode_cmd *)desc.data; 1682b47cfe1fSGuangbin Huang req_common = (struct hclge_common_lb_cmd *)desc.data; 1683ded45d40SYufeng Mo 1684d658ff34SYufeng Mo pos += scnprintf(buf + pos, len - pos, "mac id: %u\n", 1685d658ff34SYufeng Mo hdev->hw.mac.mac_id); 1686ded45d40SYufeng Mo 1687ded45d40SYufeng Mo hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_CONFIG_MAC_MODE, true); 1688ded45d40SYufeng Mo ret = hclge_cmd_send(&hdev->hw, &desc, 1); 1689ded45d40SYufeng Mo if (ret) { 1690ded45d40SYufeng Mo dev_err(&hdev->pdev->dev, 1691ded45d40SYufeng Mo "failed to dump app loopback status, ret = %d\n", ret); 1692d658ff34SYufeng Mo return ret; 1693ded45d40SYufeng Mo } 1694ded45d40SYufeng Mo 1695ded45d40SYufeng Mo loopback_en = hnae3_get_bit(le32_to_cpu(req_app->txrx_pad_fcs_loop_en), 1696ded45d40SYufeng Mo HCLGE_MAC_APP_LP_B); 1697d658ff34SYufeng Mo pos += scnprintf(buf + pos, len - pos, "app loopback: %s\n", 1698d658ff34SYufeng Mo state_str[loopback_en]); 1699ded45d40SYufeng Mo 1700b47cfe1fSGuangbin Huang hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_COMMON_LOOPBACK, true); 1701ded45d40SYufeng Mo ret = hclge_cmd_send(&hdev->hw, &desc, 1); 1702ded45d40SYufeng Mo if (ret) { 1703ded45d40SYufeng Mo dev_err(&hdev->pdev->dev, 1704b47cfe1fSGuangbin Huang "failed to dump common loopback status, ret = %d\n", 1705ded45d40SYufeng Mo ret); 1706d658ff34SYufeng Mo return ret; 1707ded45d40SYufeng Mo } 1708ded45d40SYufeng Mo 1709b47cfe1fSGuangbin Huang loopback_en = req_common->enable & HCLGE_CMD_SERDES_SERIAL_INNER_LOOP_B; 1710d658ff34SYufeng Mo pos += scnprintf(buf + pos, len - pos, "serdes serial loopback: %s\n", 1711d658ff34SYufeng Mo state_str[loopback_en]); 1712ded45d40SYufeng Mo 1713b47cfe1fSGuangbin Huang loopback_en = req_common->enable & 1714d658ff34SYufeng Mo HCLGE_CMD_SERDES_PARALLEL_INNER_LOOP_B ? 1 : 0; 1715d658ff34SYufeng Mo pos += scnprintf(buf + pos, len - pos, "serdes parallel loopback: %s\n", 1716d658ff34SYufeng Mo state_str[loopback_en]); 1717ded45d40SYufeng Mo 1718b47cfe1fSGuangbin Huang if (phydev) { 1719d658ff34SYufeng Mo loopback_en = phydev->loopback_enabled; 1720d658ff34SYufeng Mo pos += scnprintf(buf + pos, len - pos, "phy loopback: %s\n", 1721d658ff34SYufeng Mo state_str[loopback_en]); 1722b47cfe1fSGuangbin Huang } else if (hnae3_dev_phy_imp_supported(hdev)) { 1723b47cfe1fSGuangbin Huang loopback_en = req_common->enable & 1724b47cfe1fSGuangbin Huang HCLGE_CMD_GE_PHY_INNER_LOOP_B; 1725d658ff34SYufeng Mo pos += scnprintf(buf + pos, len - pos, "phy loopback: %s\n", 1726d658ff34SYufeng Mo state_str[loopback_en]); 1727b47cfe1fSGuangbin Huang } 1728d658ff34SYufeng Mo 1729d658ff34SYufeng Mo return 0; 1730ded45d40SYufeng Mo } 1731ded45d40SYufeng Mo 1732a6345787SWeihang Li /* hclge_dbg_dump_mac_tnl_status: print message about mac tnl interrupt 1733a6345787SWeihang Li * @hdev: pointer to struct hclge_dev 1734a6345787SWeihang Li */ 1735a6345787SWeihang Li static void hclge_dbg_dump_mac_tnl_status(struct hclge_dev *hdev) 1736a6345787SWeihang Li { 1737a6345787SWeihang Li #define HCLGE_BILLION_NANO_SECONDS 1000000000 1738a6345787SWeihang Li 1739a6345787SWeihang Li struct hclge_mac_tnl_stats stats; 1740a6345787SWeihang Li unsigned long rem_nsec; 1741a6345787SWeihang Li 1742a6345787SWeihang Li dev_info(&hdev->pdev->dev, "Recently generated mac tnl interruption:\n"); 1743a6345787SWeihang Li 1744a6345787SWeihang Li while (kfifo_get(&hdev->mac_tnl_log, &stats)) { 1745a6345787SWeihang Li rem_nsec = do_div(stats.time, HCLGE_BILLION_NANO_SECONDS); 1746a6345787SWeihang Li dev_info(&hdev->pdev->dev, "[%07lu.%03lu] status = 0x%x\n", 1747a6345787SWeihang Li (unsigned long)stats.time, rem_nsec / 1000, 1748a6345787SWeihang Li stats.status); 1749a6345787SWeihang Li } 1750a6345787SWeihang Li } 1751a6345787SWeihang Li 1752ee9e4424SYonglong Liu static void hclge_dbg_dump_qs_shaper_single(struct hclge_dev *hdev, u16 qsid) 1753ee9e4424SYonglong Liu { 1754ee9e4424SYonglong Liu struct hclge_qs_shapping_cmd *shap_cfg_cmd; 1755ee9e4424SYonglong Liu u8 ir_u, ir_b, ir_s, bs_b, bs_s; 1756ee9e4424SYonglong Liu struct hclge_desc desc; 1757ee9e4424SYonglong Liu u32 shapping_para; 1758c331ecf1SYonglong Liu u32 rate; 1759ee9e4424SYonglong Liu int ret; 1760ee9e4424SYonglong Liu 1761ee9e4424SYonglong Liu hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_QCN_SHAPPING_CFG, true); 1762ee9e4424SYonglong Liu 1763ee9e4424SYonglong Liu shap_cfg_cmd = (struct hclge_qs_shapping_cmd *)desc.data; 1764ee9e4424SYonglong Liu shap_cfg_cmd->qs_id = cpu_to_le16(qsid); 1765ee9e4424SYonglong Liu 1766ee9e4424SYonglong Liu ret = hclge_cmd_send(&hdev->hw, &desc, 1); 1767ee9e4424SYonglong Liu if (ret) { 1768ee9e4424SYonglong Liu dev_err(&hdev->pdev->dev, 1769ee9e4424SYonglong Liu "qs%u failed to get tx_rate, ret=%d\n", 1770ee9e4424SYonglong Liu qsid, ret); 1771ee9e4424SYonglong Liu return; 1772ee9e4424SYonglong Liu } 1773ee9e4424SYonglong Liu 1774ee9e4424SYonglong Liu shapping_para = le32_to_cpu(shap_cfg_cmd->qs_shapping_para); 1775ee9e4424SYonglong Liu ir_b = hclge_tm_get_field(shapping_para, IR_B); 1776ee9e4424SYonglong Liu ir_u = hclge_tm_get_field(shapping_para, IR_U); 1777ee9e4424SYonglong Liu ir_s = hclge_tm_get_field(shapping_para, IR_S); 1778ee9e4424SYonglong Liu bs_b = hclge_tm_get_field(shapping_para, BS_B); 1779ee9e4424SYonglong Liu bs_s = hclge_tm_get_field(shapping_para, BS_S); 1780c331ecf1SYonglong Liu rate = le32_to_cpu(shap_cfg_cmd->qs_rate); 1781ee9e4424SYonglong Liu 1782ee9e4424SYonglong Liu dev_info(&hdev->pdev->dev, 1783c331ecf1SYonglong Liu "qs%u ir_b:%u, ir_u:%u, ir_s:%u, bs_b:%u, bs_s:%u, flag:%#x, rate:%u(Mbps)\n", 1784c331ecf1SYonglong Liu qsid, ir_b, ir_u, ir_s, bs_b, bs_s, shap_cfg_cmd->flag, rate); 1785ee9e4424SYonglong Liu } 1786ee9e4424SYonglong Liu 1787ee9e4424SYonglong Liu static void hclge_dbg_dump_qs_shaper_all(struct hclge_dev *hdev) 1788ee9e4424SYonglong Liu { 1789ee9e4424SYonglong Liu struct hnae3_knic_private_info *kinfo; 1790ee9e4424SYonglong Liu struct hclge_vport *vport; 1791ee9e4424SYonglong Liu int vport_id, i; 1792ee9e4424SYonglong Liu 1793ee9e4424SYonglong Liu for (vport_id = 0; vport_id <= pci_num_vf(hdev->pdev); vport_id++) { 1794ee9e4424SYonglong Liu vport = &hdev->vport[vport_id]; 1795ee9e4424SYonglong Liu kinfo = &vport->nic.kinfo; 1796ee9e4424SYonglong Liu 1797ee9e4424SYonglong Liu dev_info(&hdev->pdev->dev, "qs cfg of vport%d:\n", vport_id); 1798ee9e4424SYonglong Liu 179935244430SJian Shen for (i = 0; i < kinfo->tc_info.num_tc; i++) { 1800ee9e4424SYonglong Liu u16 qsid = vport->qs_offset + i; 1801ee9e4424SYonglong Liu 1802ee9e4424SYonglong Liu hclge_dbg_dump_qs_shaper_single(hdev, qsid); 1803ee9e4424SYonglong Liu } 1804ee9e4424SYonglong Liu } 1805ee9e4424SYonglong Liu } 1806ee9e4424SYonglong Liu 1807ee9e4424SYonglong Liu static void hclge_dbg_dump_qs_shaper(struct hclge_dev *hdev, 1808ee9e4424SYonglong Liu const char *cmd_buf) 1809ee9e4424SYonglong Liu { 1810ee9e4424SYonglong Liu u16 qsid; 1811ee9e4424SYonglong Liu int ret; 1812ee9e4424SYonglong Liu 1813ee9e4424SYonglong Liu ret = kstrtou16(cmd_buf, 0, &qsid); 1814ee9e4424SYonglong Liu if (ret) { 1815ee9e4424SYonglong Liu hclge_dbg_dump_qs_shaper_all(hdev); 1816ee9e4424SYonglong Liu return; 1817ee9e4424SYonglong Liu } 1818ee9e4424SYonglong Liu 18193f094bd1SGuangbin Huang if (qsid >= hdev->ae_dev->dev_specs.max_qset_num) { 18203f094bd1SGuangbin Huang dev_err(&hdev->pdev->dev, "qsid(%u) out of range[0-%u]\n", 18213f094bd1SGuangbin Huang qsid, hdev->ae_dev->dev_specs.max_qset_num - 1); 1822ee9e4424SYonglong Liu return; 1823ee9e4424SYonglong Liu } 1824ee9e4424SYonglong Liu 1825ee9e4424SYonglong Liu hclge_dbg_dump_qs_shaper_single(hdev, qsid); 1826ee9e4424SYonglong Liu } 1827ee9e4424SYonglong Liu 18281556ea91SHuazhong Tan static const struct hclge_dbg_item mac_list_items[] = { 18291556ea91SHuazhong Tan { "FUNC_ID", 2 }, 18301556ea91SHuazhong Tan { "MAC_ADDR", 12 }, 18311556ea91SHuazhong Tan { "STATE", 2 }, 18321556ea91SHuazhong Tan }; 18331556ea91SHuazhong Tan 18341556ea91SHuazhong Tan static void hclge_dbg_dump_mac_list(struct hclge_dev *hdev, char *buf, int len, 1835f671237aSJian Shen bool is_unicast) 1836f671237aSJian Shen { 18371556ea91SHuazhong Tan char data_str[ARRAY_SIZE(mac_list_items)][HCLGE_DBG_DATA_STR_LEN]; 18381556ea91SHuazhong Tan char content[HCLGE_DBG_INFO_LEN], str_id[HCLGE_DBG_ID_LEN]; 18391556ea91SHuazhong Tan char *result[ARRAY_SIZE(mac_list_items)]; 1840f671237aSJian Shen struct hclge_mac_node *mac_node, *tmp; 1841f671237aSJian Shen struct hclge_vport *vport; 1842f671237aSJian Shen struct list_head *list; 1843f671237aSJian Shen u32 func_id; 18441556ea91SHuazhong Tan int pos = 0; 18451556ea91SHuazhong Tan int i; 1846f671237aSJian Shen 18471556ea91SHuazhong Tan for (i = 0; i < ARRAY_SIZE(mac_list_items); i++) 18481556ea91SHuazhong Tan result[i] = &data_str[i][0]; 1849f671237aSJian Shen 18501556ea91SHuazhong Tan pos += scnprintf(buf + pos, len - pos, "%s MAC_LIST:\n", 18511556ea91SHuazhong Tan is_unicast ? "UC" : "MC"); 18521556ea91SHuazhong Tan hclge_dbg_fill_content(content, sizeof(content), mac_list_items, 18531556ea91SHuazhong Tan NULL, ARRAY_SIZE(mac_list_items)); 18541556ea91SHuazhong Tan pos += scnprintf(buf + pos, len - pos, "%s", content); 1855f671237aSJian Shen 18561556ea91SHuazhong Tan for (func_id = 0; func_id < hdev->num_alloc_vport; func_id++) { 1857f671237aSJian Shen vport = &hdev->vport[func_id]; 1858f671237aSJian Shen list = is_unicast ? &vport->uc_mac_list : &vport->mc_mac_list; 1859f671237aSJian Shen spin_lock_bh(&vport->mac_list_lock); 1860f671237aSJian Shen list_for_each_entry_safe(mac_node, tmp, list, node) { 18611556ea91SHuazhong Tan i = 0; 18621556ea91SHuazhong Tan result[i++] = hclge_dbg_get_func_id_str(str_id, 18631556ea91SHuazhong Tan func_id); 18641556ea91SHuazhong Tan sprintf(result[i++], "%pM", mac_node->mac_addr); 18651556ea91SHuazhong Tan sprintf(result[i++], "%5s", 18661556ea91SHuazhong Tan hclge_mac_state_str[mac_node->state]); 18671556ea91SHuazhong Tan hclge_dbg_fill_content(content, sizeof(content), 18681556ea91SHuazhong Tan mac_list_items, 18691556ea91SHuazhong Tan (const char **)result, 18701556ea91SHuazhong Tan ARRAY_SIZE(mac_list_items)); 18711556ea91SHuazhong Tan pos += scnprintf(buf + pos, len - pos, "%s", content); 18721556ea91SHuazhong Tan } 18731556ea91SHuazhong Tan spin_unlock_bh(&vport->mac_list_lock); 18741556ea91SHuazhong Tan } 1875f671237aSJian Shen } 1876f671237aSJian Shen 18771556ea91SHuazhong Tan static int hclge_dbg_dump_mac_uc(struct hclge_dev *hdev, char *buf, int len) 18781556ea91SHuazhong Tan { 18791556ea91SHuazhong Tan hclge_dbg_dump_mac_list(hdev, buf, len, true); 18801556ea91SHuazhong Tan 18811556ea91SHuazhong Tan return 0; 18821556ea91SHuazhong Tan } 18831556ea91SHuazhong Tan 18841556ea91SHuazhong Tan static int hclge_dbg_dump_mac_mc(struct hclge_dev *hdev, char *buf, int len) 18851556ea91SHuazhong Tan { 18861556ea91SHuazhong Tan hclge_dbg_dump_mac_list(hdev, buf, len, false); 1887f671237aSJian Shen 1888f671237aSJian Shen return 0; 1889f671237aSJian Shen } 1890f671237aSJian Shen 1891ebaf1908SWeihang Li int hclge_dbg_run_cmd(struct hnae3_handle *handle, const char *cmd_buf) 18923c666b58Sliuzhongzhu { 18933c666b58Sliuzhongzhu struct hclge_vport *vport = hclge_get_vport(handle); 18943c666b58Sliuzhongzhu struct hclge_dev *hdev = vport->back; 18953c666b58Sliuzhongzhu 1896b5a0b70dSHao Chen if (strncmp(cmd_buf, "dump tc", 7) == 0) { 18972849d4e7Sliuzhongzhu hclge_dbg_dump_tc(hdev); 1898d958919dSliuzhongzhu } else if (strncmp(cmd_buf, "dump qos pause cfg", 18) == 0) { 1899d958919dSliuzhongzhu hclge_dbg_dump_qos_pause_cfg(hdev); 19006fc22440Sliuzhongzhu } else if (strncmp(cmd_buf, "dump qos pri map", 16) == 0) { 19016fc22440Sliuzhongzhu hclge_dbg_dump_qos_pri_map(hdev); 19027d9d7f88Sliuzhongzhu } else if (strncmp(cmd_buf, "dump qos buf cfg", 16) == 0) { 19037d9d7f88Sliuzhongzhu hclge_dbg_dump_qos_buf_cfg(hdev); 19041c6dfe6fSYunsheng Lin } else if (strncmp(cmd_buf, "dump serv info", 14) == 0) { 19051c6dfe6fSYunsheng Lin hclge_dbg_dump_serv_info(hdev); 1906a6345787SWeihang Li } else if (strncmp(cmd_buf, "dump mac tnl status", 19) == 0) { 1907a6345787SWeihang Li hclge_dbg_dump_mac_tnl_status(hdev); 1908ee9e4424SYonglong Liu } else if (strncmp(cmd_buf, "dump qs shaper", 14) == 0) { 1909ee9e4424SYonglong Liu hclge_dbg_dump_qs_shaper(hdev, 1910ee9e4424SYonglong Liu &cmd_buf[sizeof("dump qs shaper")]); 19113c666b58Sliuzhongzhu } else { 19123c666b58Sliuzhongzhu dev_info(&hdev->pdev->dev, "unknown command\n"); 19133c666b58Sliuzhongzhu return -EINVAL; 19143c666b58Sliuzhongzhu } 19153c666b58Sliuzhongzhu 19163c666b58Sliuzhongzhu return 0; 19173c666b58Sliuzhongzhu } 191804987ca1SGuangbin Huang 19195e69ea7eSYufeng Mo static const struct hclge_dbg_func hclge_dbg_cmd_func[] = { 19205e69ea7eSYufeng Mo { 19215e69ea7eSYufeng Mo .cmd = HNAE3_DBG_CMD_TM_NODES, 19225e69ea7eSYufeng Mo .dbg_dump = hclge_dbg_dump_tm_nodes, 19235e69ea7eSYufeng Mo }, 19245e69ea7eSYufeng Mo { 19255e69ea7eSYufeng Mo .cmd = HNAE3_DBG_CMD_TM_PRI, 19265e69ea7eSYufeng Mo .dbg_dump = hclge_dbg_dump_tm_pri, 19275e69ea7eSYufeng Mo }, 19285e69ea7eSYufeng Mo { 19295e69ea7eSYufeng Mo .cmd = HNAE3_DBG_CMD_TM_QSET, 19305e69ea7eSYufeng Mo .dbg_dump = hclge_dbg_dump_tm_qset, 19315e69ea7eSYufeng Mo }, 19321556ea91SHuazhong Tan { 19337679f28eSGuangbin Huang .cmd = HNAE3_DBG_CMD_TM_MAP, 19347679f28eSGuangbin Huang .dbg_dump = hclge_dbg_dump_tm_map, 19357679f28eSGuangbin Huang }, 19367679f28eSGuangbin Huang { 1937*cad7c215SGuangbin Huang .cmd = HNAE3_DBG_CMD_TM_PG, 1938*cad7c215SGuangbin Huang .dbg_dump = hclge_dbg_dump_tm_pg, 1939*cad7c215SGuangbin Huang }, 1940*cad7c215SGuangbin Huang { 1941*cad7c215SGuangbin Huang .cmd = HNAE3_DBG_CMD_TM_PORT, 1942*cad7c215SGuangbin Huang .dbg_dump = hclge_dbg_dump_tm_port, 1943*cad7c215SGuangbin Huang }, 1944*cad7c215SGuangbin Huang { 19451556ea91SHuazhong Tan .cmd = HNAE3_DBG_CMD_MAC_UC, 19461556ea91SHuazhong Tan .dbg_dump = hclge_dbg_dump_mac_uc, 19471556ea91SHuazhong Tan }, 19481556ea91SHuazhong Tan { 19491556ea91SHuazhong Tan .cmd = HNAE3_DBG_CMD_MAC_MC, 19501556ea91SHuazhong Tan .dbg_dump = hclge_dbg_dump_mac_mc, 19511556ea91SHuazhong Tan }, 19528ddfd9c4SYufeng Mo { 19538ddfd9c4SYufeng Mo .cmd = HNAE3_DBG_CMD_MNG_TBL, 19548ddfd9c4SYufeng Mo .dbg_dump = hclge_dbg_dump_mng_table, 19558ddfd9c4SYufeng Mo }, 1956d658ff34SYufeng Mo { 1957d658ff34SYufeng Mo .cmd = HNAE3_DBG_CMD_LOOPBACK, 1958d658ff34SYufeng Mo .dbg_dump = hclge_dbg_dump_loopback, 1959d658ff34SYufeng Mo }, 19609149ca0fSJiaran Zhang { 19619149ca0fSJiaran Zhang .cmd = HNAE3_DBG_CMD_INTERRUPT_INFO, 19629149ca0fSJiaran Zhang .dbg_dump = hclge_dbg_dump_interrupt, 19639149ca0fSJiaran Zhang }, 19641a7ff828SJiaran Zhang { 19651a7ff828SJiaran Zhang .cmd = HNAE3_DBG_CMD_RESET_INFO, 19661a7ff828SJiaran Zhang .dbg_dump = hclge_dbg_dump_rst_info, 19671a7ff828SJiaran Zhang }, 19680b198b0dSJiaran Zhang { 19690b198b0dSJiaran Zhang .cmd = HNAE3_DBG_CMD_IMP_INFO, 19700b198b0dSJiaran Zhang .dbg_dump = hclge_dbg_get_imp_stats_info, 19710b198b0dSJiaran Zhang }, 1972e76e6886SJiaran Zhang { 1973e76e6886SJiaran Zhang .cmd = HNAE3_DBG_CMD_NCL_CONFIG, 1974e76e6886SJiaran Zhang .dbg_dump = hclge_dbg_dump_ncl_config, 1975e76e6886SJiaran Zhang }, 1976d96b0e59SYufeng Mo { 1977d96b0e59SYufeng Mo .cmd = HNAE3_DBG_CMD_REG_BIOS_COMMON, 1978d96b0e59SYufeng Mo .dbg_dump_reg = hclge_dbg_dump_reg_cmd, 1979d96b0e59SYufeng Mo }, 1980d96b0e59SYufeng Mo { 1981d96b0e59SYufeng Mo .cmd = HNAE3_DBG_CMD_REG_SSU, 1982d96b0e59SYufeng Mo .dbg_dump_reg = hclge_dbg_dump_reg_cmd, 1983d96b0e59SYufeng Mo }, 1984d96b0e59SYufeng Mo { 1985d96b0e59SYufeng Mo .cmd = HNAE3_DBG_CMD_REG_IGU_EGU, 1986d96b0e59SYufeng Mo .dbg_dump_reg = hclge_dbg_dump_reg_cmd, 1987d96b0e59SYufeng Mo }, 1988d96b0e59SYufeng Mo { 1989d96b0e59SYufeng Mo .cmd = HNAE3_DBG_CMD_REG_RPU, 1990d96b0e59SYufeng Mo .dbg_dump_reg = hclge_dbg_dump_reg_cmd, 1991d96b0e59SYufeng Mo }, 1992d96b0e59SYufeng Mo { 1993d96b0e59SYufeng Mo .cmd = HNAE3_DBG_CMD_REG_NCSI, 1994d96b0e59SYufeng Mo .dbg_dump_reg = hclge_dbg_dump_reg_cmd, 1995d96b0e59SYufeng Mo }, 1996d96b0e59SYufeng Mo { 1997d96b0e59SYufeng Mo .cmd = HNAE3_DBG_CMD_REG_RTC, 1998d96b0e59SYufeng Mo .dbg_dump_reg = hclge_dbg_dump_reg_cmd, 1999d96b0e59SYufeng Mo }, 2000d96b0e59SYufeng Mo { 2001d96b0e59SYufeng Mo .cmd = HNAE3_DBG_CMD_REG_PPP, 2002d96b0e59SYufeng Mo .dbg_dump_reg = hclge_dbg_dump_reg_cmd, 2003d96b0e59SYufeng Mo }, 2004d96b0e59SYufeng Mo { 2005d96b0e59SYufeng Mo .cmd = HNAE3_DBG_CMD_REG_RCB, 2006d96b0e59SYufeng Mo .dbg_dump_reg = hclge_dbg_dump_reg_cmd, 2007d96b0e59SYufeng Mo }, 2008d96b0e59SYufeng Mo { 2009d96b0e59SYufeng Mo .cmd = HNAE3_DBG_CMD_REG_TQP, 2010d96b0e59SYufeng Mo .dbg_dump_reg = hclge_dbg_dump_reg_cmd, 2011d96b0e59SYufeng Mo }, 2012d96b0e59SYufeng Mo { 2013d96b0e59SYufeng Mo .cmd = HNAE3_DBG_CMD_REG_MAC, 2014d96b0e59SYufeng Mo .dbg_dump = hclge_dbg_dump_mac, 2015d96b0e59SYufeng Mo }, 2016365e860aSYufeng Mo { 2017365e860aSYufeng Mo .cmd = HNAE3_DBG_CMD_REG_DCB, 2018365e860aSYufeng Mo .dbg_dump = hclge_dbg_dump_dcb, 2019365e860aSYufeng Mo }, 2020b5a0b70dSHao Chen { 2021b5a0b70dSHao Chen .cmd = HNAE3_DBG_CMD_FD_TCAM, 2022b5a0b70dSHao Chen .dbg_dump = hclge_dbg_dump_fd_tcam, 2023b5a0b70dSHao Chen }, 20245e69ea7eSYufeng Mo }; 20255e69ea7eSYufeng Mo 20265e69ea7eSYufeng Mo int hclge_dbg_read_cmd(struct hnae3_handle *handle, enum hnae3_dbg_cmd cmd, 202704987ca1SGuangbin Huang char *buf, int len) 202804987ca1SGuangbin Huang { 202904987ca1SGuangbin Huang struct hclge_vport *vport = hclge_get_vport(handle); 2030d96b0e59SYufeng Mo const struct hclge_dbg_func *cmd_func; 203104987ca1SGuangbin Huang struct hclge_dev *hdev = vport->back; 20325e69ea7eSYufeng Mo u32 i; 203304987ca1SGuangbin Huang 20345e69ea7eSYufeng Mo for (i = 0; i < ARRAY_SIZE(hclge_dbg_cmd_func); i++) { 2035d96b0e59SYufeng Mo if (cmd == hclge_dbg_cmd_func[i].cmd) { 2036d96b0e59SYufeng Mo cmd_func = &hclge_dbg_cmd_func[i]; 2037d96b0e59SYufeng Mo if (cmd_func->dbg_dump) 2038d96b0e59SYufeng Mo return cmd_func->dbg_dump(hdev, buf, len); 2039d96b0e59SYufeng Mo else 2040d96b0e59SYufeng Mo return cmd_func->dbg_dump_reg(hdev, cmd, buf, 2041d96b0e59SYufeng Mo len); 2042d96b0e59SYufeng Mo } 20435e69ea7eSYufeng Mo } 204404987ca1SGuangbin Huang 20455e69ea7eSYufeng Mo dev_err(&hdev->pdev->dev, "invalid command(%d)\n", cmd); 204604987ca1SGuangbin Huang return -EINVAL; 204704987ca1SGuangbin Huang } 2048