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 6480e32038dSGuangbin Huang static int hclge_dbg_dump_tc(struct hclge_dev *hdev, char *buf, int len) 6492849d4e7Sliuzhongzhu { 6502849d4e7Sliuzhongzhu struct hclge_ets_tc_weight_cmd *ets_weight; 6512849d4e7Sliuzhongzhu struct hclge_desc desc; 6520e32038dSGuangbin Huang char *sch_mode_str; 6530e32038dSGuangbin Huang int pos = 0; 6540e32038dSGuangbin Huang int ret; 6550e32038dSGuangbin Huang u8 i; 6562849d4e7Sliuzhongzhu 6573f0f3253SYufeng Mo if (!hnae3_dev_dcb_supported(hdev)) { 6580e32038dSGuangbin Huang dev_err(&hdev->pdev->dev, 6593f0f3253SYufeng Mo "Only DCB-supported dev supports tc\n"); 6600e32038dSGuangbin Huang return -EOPNOTSUPP; 6613f0f3253SYufeng Mo } 6623f0f3253SYufeng Mo 6632849d4e7Sliuzhongzhu hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_ETS_TC_WEIGHT, true); 6642849d4e7Sliuzhongzhu ret = hclge_cmd_send(&hdev->hw, &desc, 1); 6652849d4e7Sliuzhongzhu if (ret) { 6660e32038dSGuangbin Huang dev_err(&hdev->pdev->dev, "failed to get tc weight, ret = %d\n", 6670e32038dSGuangbin Huang ret); 6680e32038dSGuangbin Huang return ret; 6692849d4e7Sliuzhongzhu } 6702849d4e7Sliuzhongzhu 6712849d4e7Sliuzhongzhu ets_weight = (struct hclge_ets_tc_weight_cmd *)desc.data; 6722849d4e7Sliuzhongzhu 6730e32038dSGuangbin Huang pos += scnprintf(buf + pos, len - pos, "enabled tc number: %u\n", 674a8adbb8aSYonglong Liu hdev->tm_info.num_tc); 6750e32038dSGuangbin Huang pos += scnprintf(buf + pos, len - pos, "weight_offset: %u\n", 6762849d4e7Sliuzhongzhu ets_weight->weight_offset); 6772849d4e7Sliuzhongzhu 6780e32038dSGuangbin Huang pos += scnprintf(buf + pos, len - pos, "TC MODE WEIGHT\n"); 6790e32038dSGuangbin Huang for (i = 0; i < HNAE3_MAX_TC; i++) { 6800e32038dSGuangbin Huang sch_mode_str = ets_weight->tc_weight[i] ? "dwrr" : "sp"; 6810e32038dSGuangbin Huang pos += scnprintf(buf + pos, len - pos, "%u %4s %3u\n", 6820e32038dSGuangbin Huang i, sch_mode_str, 6830e32038dSGuangbin Huang hdev->tm_info.pg_info[0].tc_dwrr[i]); 6840e32038dSGuangbin Huang } 6850e32038dSGuangbin Huang 6860e32038dSGuangbin Huang return 0; 6872849d4e7Sliuzhongzhu } 6882849d4e7Sliuzhongzhu 689cad7c215SGuangbin Huang static const struct hclge_dbg_item tm_pg_items[] = { 690cad7c215SGuangbin Huang { "ID", 2 }, 691cad7c215SGuangbin Huang { "PRI_MAP", 2 }, 692cad7c215SGuangbin Huang { "MODE", 2 }, 693cad7c215SGuangbin Huang { "DWRR", 2 }, 694cad7c215SGuangbin Huang { "C_IR_B", 2 }, 695cad7c215SGuangbin Huang { "C_IR_U", 2 }, 696cad7c215SGuangbin Huang { "C_IR_S", 2 }, 697cad7c215SGuangbin Huang { "C_BS_B", 2 }, 698cad7c215SGuangbin Huang { "C_BS_S", 2 }, 699cad7c215SGuangbin Huang { "C_FLAG", 2 }, 700cad7c215SGuangbin Huang { "C_RATE(Mbps)", 2 }, 701cad7c215SGuangbin Huang { "P_IR_B", 2 }, 702cad7c215SGuangbin Huang { "P_IR_U", 2 }, 703cad7c215SGuangbin Huang { "P_IR_S", 2 }, 704cad7c215SGuangbin Huang { "P_BS_B", 2 }, 705cad7c215SGuangbin Huang { "P_BS_S", 2 }, 706cad7c215SGuangbin Huang { "P_FLAG", 2 }, 707cad7c215SGuangbin Huang { "P_RATE(Mbps)", 0 } 708cad7c215SGuangbin Huang }; 709cad7c215SGuangbin Huang 710cad7c215SGuangbin Huang static void hclge_dbg_fill_shaper_content(struct hclge_tm_shaper_para *para, 711cad7c215SGuangbin Huang char **result, u8 *index) 71296227f4cSliuzhongzhu { 713cad7c215SGuangbin Huang sprintf(result[(*index)++], "%3u", para->ir_b); 714cad7c215SGuangbin Huang sprintf(result[(*index)++], "%3u", para->ir_u); 715cad7c215SGuangbin Huang sprintf(result[(*index)++], "%3u", para->ir_s); 716cad7c215SGuangbin Huang sprintf(result[(*index)++], "%3u", para->bs_b); 717cad7c215SGuangbin Huang sprintf(result[(*index)++], "%3u", para->bs_s); 718cad7c215SGuangbin Huang sprintf(result[(*index)++], "%3u", para->flag); 719cad7c215SGuangbin Huang sprintf(result[(*index)++], "%6u", para->rate); 7203f0f3253SYufeng Mo } 7213f0f3253SYufeng Mo 722*c894b51eSArnd Bergmann static int __hclge_dbg_dump_tm_pg(struct hclge_dev *hdev, char *data_str, 723*c894b51eSArnd Bergmann char *buf, int len) 72496227f4cSliuzhongzhu { 725cad7c215SGuangbin Huang struct hclge_tm_shaper_para c_shaper_para, p_shaper_para; 726cad7c215SGuangbin Huang char *result[ARRAY_SIZE(tm_pg_items)], *sch_mode_str; 727cad7c215SGuangbin Huang u8 pg_id, sch_mode, weight, pri_bit_map, i, j; 728cad7c215SGuangbin Huang char content[HCLGE_DBG_TM_INFO_LEN]; 729cad7c215SGuangbin Huang int pos = 0; 73096227f4cSliuzhongzhu int ret; 73196227f4cSliuzhongzhu 732*c894b51eSArnd Bergmann for (i = 0; i < ARRAY_SIZE(tm_pg_items); i++) { 733*c894b51eSArnd Bergmann result[i] = data_str; 734*c894b51eSArnd Bergmann data_str += HCLGE_DBG_DATA_STR_LEN; 735*c894b51eSArnd Bergmann } 736cad7c215SGuangbin Huang 737cad7c215SGuangbin Huang hclge_dbg_fill_content(content, sizeof(content), tm_pg_items, 738cad7c215SGuangbin Huang NULL, ARRAY_SIZE(tm_pg_items)); 739cad7c215SGuangbin Huang pos += scnprintf(buf + pos, len - pos, "%s", content); 740cad7c215SGuangbin Huang 741cad7c215SGuangbin Huang for (pg_id = 0; pg_id < hdev->tm_info.num_pg; pg_id++) { 742cad7c215SGuangbin Huang ret = hclge_tm_get_pg_to_pri_map(hdev, pg_id, &pri_bit_map); 74396227f4cSliuzhongzhu if (ret) 744cad7c215SGuangbin Huang return ret; 74596227f4cSliuzhongzhu 746cad7c215SGuangbin Huang ret = hclge_tm_get_pg_sch_mode(hdev, pg_id, &sch_mode); 74796227f4cSliuzhongzhu if (ret) 748cad7c215SGuangbin Huang return ret; 74996227f4cSliuzhongzhu 750cad7c215SGuangbin Huang ret = hclge_tm_get_pg_weight(hdev, pg_id, &weight); 75196227f4cSliuzhongzhu if (ret) 752cad7c215SGuangbin Huang return ret; 75396227f4cSliuzhongzhu 754cad7c215SGuangbin Huang ret = hclge_tm_get_pg_shaper(hdev, pg_id, 755cad7c215SGuangbin Huang HCLGE_OPC_TM_PG_C_SHAPPING, 756cad7c215SGuangbin Huang &c_shaper_para); 75796227f4cSliuzhongzhu if (ret) 758cad7c215SGuangbin Huang return ret; 75996227f4cSliuzhongzhu 760cad7c215SGuangbin Huang ret = hclge_tm_get_pg_shaper(hdev, pg_id, 761cad7c215SGuangbin Huang HCLGE_OPC_TM_PG_P_SHAPPING, 762cad7c215SGuangbin Huang &p_shaper_para); 76396227f4cSliuzhongzhu if (ret) 764cad7c215SGuangbin Huang return ret; 76596227f4cSliuzhongzhu 766cad7c215SGuangbin Huang sch_mode_str = sch_mode & HCLGE_TM_TX_SCHD_DWRR_MSK ? "dwrr" : 767cad7c215SGuangbin Huang "sp"; 76896227f4cSliuzhongzhu 769cad7c215SGuangbin Huang j = 0; 770cad7c215SGuangbin Huang sprintf(result[j++], "%02u", pg_id); 771cad7c215SGuangbin Huang sprintf(result[j++], "0x%02x", pri_bit_map); 772cad7c215SGuangbin Huang sprintf(result[j++], "%4s", sch_mode_str); 773cad7c215SGuangbin Huang sprintf(result[j++], "%3u", weight); 774cad7c215SGuangbin Huang hclge_dbg_fill_shaper_content(&c_shaper_para, result, &j); 775cad7c215SGuangbin Huang hclge_dbg_fill_shaper_content(&p_shaper_para, result, &j); 776cad7c215SGuangbin Huang 777cad7c215SGuangbin Huang hclge_dbg_fill_content(content, sizeof(content), tm_pg_items, 778cad7c215SGuangbin Huang (const char **)result, 779cad7c215SGuangbin Huang ARRAY_SIZE(tm_pg_items)); 780cad7c215SGuangbin Huang pos += scnprintf(buf + pos, len - pos, "%s", content); 781cad7c215SGuangbin Huang } 782cad7c215SGuangbin Huang 783cad7c215SGuangbin Huang return 0; 784cad7c215SGuangbin Huang } 785cad7c215SGuangbin Huang 786*c894b51eSArnd Bergmann static int hclge_dbg_dump_tm_pg(struct hclge_dev *hdev, char *buf, int len) 787*c894b51eSArnd Bergmann { 788*c894b51eSArnd Bergmann char *data_str; 789*c894b51eSArnd Bergmann int ret; 790*c894b51eSArnd Bergmann 791*c894b51eSArnd Bergmann data_str = kcalloc(ARRAY_SIZE(tm_pg_items), 792*c894b51eSArnd Bergmann HCLGE_DBG_DATA_STR_LEN, GFP_KERNEL); 793*c894b51eSArnd Bergmann 794*c894b51eSArnd Bergmann if (!data_str) 795*c894b51eSArnd Bergmann return -ENOMEM; 796*c894b51eSArnd Bergmann 797*c894b51eSArnd Bergmann ret = __hclge_dbg_dump_tm_pg(hdev, data_str, buf, len); 798*c894b51eSArnd Bergmann 799*c894b51eSArnd Bergmann kfree(data_str); 800*c894b51eSArnd Bergmann 801*c894b51eSArnd Bergmann return ret; 802*c894b51eSArnd Bergmann } 803*c894b51eSArnd Bergmann 804cad7c215SGuangbin Huang static int hclge_dbg_dump_tm_port(struct hclge_dev *hdev, char *buf, int len) 805cad7c215SGuangbin Huang { 806cad7c215SGuangbin Huang struct hclge_tm_shaper_para shaper_para; 807cad7c215SGuangbin Huang int pos = 0; 808cad7c215SGuangbin Huang int ret; 809cad7c215SGuangbin Huang 810cad7c215SGuangbin Huang ret = hclge_tm_get_port_shaper(hdev, &shaper_para); 81196227f4cSliuzhongzhu if (ret) 812cad7c215SGuangbin Huang return ret; 81396227f4cSliuzhongzhu 814cad7c215SGuangbin Huang pos += scnprintf(buf + pos, len - pos, 815cad7c215SGuangbin Huang "IR_B IR_U IR_S BS_B BS_S FLAG RATE(Mbps)\n"); 816cad7c215SGuangbin Huang pos += scnprintf(buf + pos, len - pos, 817cad7c215SGuangbin Huang "%3u %3u %3u %3u %3u %1u %6u\n", 818cad7c215SGuangbin Huang shaper_para.ir_b, shaper_para.ir_u, shaper_para.ir_s, 819cad7c215SGuangbin Huang shaper_para.bs_b, shaper_para.bs_s, shaper_para.flag, 820cad7c215SGuangbin Huang shaper_para.rate); 82196227f4cSliuzhongzhu 822cad7c215SGuangbin Huang return 0; 82396227f4cSliuzhongzhu } 82496227f4cSliuzhongzhu 8257679f28eSGuangbin Huang static int hclge_dbg_dump_tm_bp_qset_map(struct hclge_dev *hdev, u8 tc_id, 8267679f28eSGuangbin Huang char *buf, int len) 82782e00b86Sliuzhongzhu { 8289a5ef4aaSYonglong Liu u32 qset_mapping[HCLGE_BP_EXT_GRP_NUM]; 8297679f28eSGuangbin Huang struct hclge_bp_to_qs_map_cmd *map; 83082e00b86Sliuzhongzhu struct hclge_desc desc; 8317679f28eSGuangbin Huang int pos = 0; 8327679f28eSGuangbin Huang u8 group_id; 8337679f28eSGuangbin Huang u8 grp_num; 8347679f28eSGuangbin Huang u16 i = 0; 8350256844dSYonglong Liu int ret; 8363f0f3253SYufeng Mo 8379a5ef4aaSYonglong Liu grp_num = hdev->num_tqps <= HCLGE_TQP_MAX_SIZE_DEV_V2 ? 8389a5ef4aaSYonglong Liu HCLGE_BP_GRP_NUM : HCLGE_BP_EXT_GRP_NUM; 8397679f28eSGuangbin Huang map = (struct hclge_bp_to_qs_map_cmd *)desc.data; 8409a5ef4aaSYonglong Liu for (group_id = 0; group_id < grp_num; group_id++) { 8417679f28eSGuangbin Huang hclge_cmd_setup_basic_desc(&desc, 8427679f28eSGuangbin Huang HCLGE_OPC_TM_BP_TO_QSET_MAPPING, 8437679f28eSGuangbin Huang true); 8447679f28eSGuangbin Huang map->tc_id = tc_id; 8457679f28eSGuangbin Huang map->qs_group_id = group_id; 84682e00b86Sliuzhongzhu ret = hclge_cmd_send(&hdev->hw, &desc, 1); 8477679f28eSGuangbin Huang if (ret) { 8487679f28eSGuangbin Huang dev_err(&hdev->pdev->dev, 8497679f28eSGuangbin Huang "failed to get bp to qset map, ret = %d\n", 8507679f28eSGuangbin Huang ret); 8517679f28eSGuangbin Huang return ret; 85282e00b86Sliuzhongzhu } 85382e00b86Sliuzhongzhu 8547679f28eSGuangbin Huang qset_mapping[group_id] = le32_to_cpu(map->qs_bit_map); 8557679f28eSGuangbin Huang } 85682e00b86Sliuzhongzhu 8577679f28eSGuangbin Huang pos += scnprintf(buf + pos, len - pos, "INDEX | TM BP QSET MAPPING:\n"); 8589a5ef4aaSYonglong Liu for (group_id = 0; group_id < grp_num / 8; group_id++) { 8597679f28eSGuangbin Huang pos += scnprintf(buf + pos, len - pos, 86082e00b86Sliuzhongzhu "%04d | %08x:%08x:%08x:%08x:%08x:%08x:%08x:%08x\n", 8617679f28eSGuangbin Huang group_id * 256, qset_mapping[i + 7], 8627679f28eSGuangbin Huang qset_mapping[i + 6], qset_mapping[i + 5], 8637679f28eSGuangbin Huang qset_mapping[i + 4], qset_mapping[i + 3], 8647679f28eSGuangbin Huang qset_mapping[i + 2], qset_mapping[i + 1], 86596b8e878SHuazhong Tan qset_mapping[i]); 86682e00b86Sliuzhongzhu i += 8; 86782e00b86Sliuzhongzhu } 86882e00b86Sliuzhongzhu 8697679f28eSGuangbin Huang return pos; 8707679f28eSGuangbin Huang } 87182e00b86Sliuzhongzhu 8727679f28eSGuangbin Huang static int hclge_dbg_dump_tm_map(struct hclge_dev *hdev, char *buf, int len) 8737679f28eSGuangbin Huang { 8747679f28eSGuangbin Huang u16 queue_id; 8757679f28eSGuangbin Huang u16 qset_id; 8767679f28eSGuangbin Huang u8 link_vld; 8777679f28eSGuangbin Huang int pos = 0; 8787679f28eSGuangbin Huang u8 pri_id; 8797679f28eSGuangbin Huang u8 tc_id; 8807679f28eSGuangbin Huang int ret; 8817679f28eSGuangbin Huang 8827679f28eSGuangbin Huang for (queue_id = 0; queue_id < hdev->num_tqps; queue_id++) { 8837679f28eSGuangbin Huang ret = hclge_tm_get_q_to_qs_map(hdev, queue_id, &qset_id); 8847679f28eSGuangbin Huang if (ret) 8857679f28eSGuangbin Huang return ret; 8867679f28eSGuangbin Huang 8877679f28eSGuangbin Huang ret = hclge_tm_get_qset_map_pri(hdev, qset_id, &pri_id, 8887679f28eSGuangbin Huang &link_vld); 8897679f28eSGuangbin Huang if (ret) 8907679f28eSGuangbin Huang return ret; 8917679f28eSGuangbin Huang 8927679f28eSGuangbin Huang ret = hclge_tm_get_q_to_tc(hdev, queue_id, &tc_id); 8937679f28eSGuangbin Huang if (ret) 8947679f28eSGuangbin Huang return ret; 8957679f28eSGuangbin Huang 8967679f28eSGuangbin Huang pos += scnprintf(buf + pos, len - pos, 8977679f28eSGuangbin Huang "QUEUE_ID QSET_ID PRI_ID TC_ID\n"); 8987679f28eSGuangbin Huang pos += scnprintf(buf + pos, len - pos, 8997679f28eSGuangbin Huang "%04u %4u %3u %2u\n", 9007679f28eSGuangbin Huang queue_id, qset_id, pri_id, tc_id); 9017679f28eSGuangbin Huang 9027679f28eSGuangbin Huang if (!hnae3_dev_dcb_supported(hdev)) 9037679f28eSGuangbin Huang continue; 9047679f28eSGuangbin Huang 9057679f28eSGuangbin Huang ret = hclge_dbg_dump_tm_bp_qset_map(hdev, tc_id, buf + pos, 9067679f28eSGuangbin Huang len - pos); 9077679f28eSGuangbin Huang if (ret < 0) 9087679f28eSGuangbin Huang return ret; 9097679f28eSGuangbin Huang pos += ret; 9107679f28eSGuangbin Huang 9117679f28eSGuangbin Huang pos += scnprintf(buf + pos, len - pos, "\n"); 9127679f28eSGuangbin Huang } 9137679f28eSGuangbin Huang 9147679f28eSGuangbin Huang return 0; 91582e00b86Sliuzhongzhu } 91682e00b86Sliuzhongzhu 91704987ca1SGuangbin Huang static int hclge_dbg_dump_tm_nodes(struct hclge_dev *hdev, char *buf, int len) 91804987ca1SGuangbin Huang { 91904987ca1SGuangbin Huang struct hclge_tm_nodes_cmd *nodes; 92004987ca1SGuangbin Huang struct hclge_desc desc; 92104987ca1SGuangbin Huang int pos = 0; 92204987ca1SGuangbin Huang int ret; 92304987ca1SGuangbin Huang 92404987ca1SGuangbin Huang hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_TM_NODES, true); 92504987ca1SGuangbin Huang ret = hclge_cmd_send(&hdev->hw, &desc, 1); 92604987ca1SGuangbin Huang if (ret) { 92704987ca1SGuangbin Huang dev_err(&hdev->pdev->dev, 92804987ca1SGuangbin Huang "failed to dump tm nodes, ret = %d\n", ret); 92904987ca1SGuangbin Huang return ret; 93004987ca1SGuangbin Huang } 93104987ca1SGuangbin Huang 93204987ca1SGuangbin Huang nodes = (struct hclge_tm_nodes_cmd *)desc.data; 93304987ca1SGuangbin Huang 93404987ca1SGuangbin Huang pos += scnprintf(buf + pos, len - pos, " BASE_ID MAX_NUM\n"); 93504987ca1SGuangbin Huang pos += scnprintf(buf + pos, len - pos, "PG %4u %4u\n", 93604987ca1SGuangbin Huang nodes->pg_base_id, nodes->pg_num); 93704987ca1SGuangbin Huang pos += scnprintf(buf + pos, len - pos, "PRI %4u %4u\n", 93804987ca1SGuangbin Huang nodes->pri_base_id, nodes->pri_num); 93904987ca1SGuangbin Huang pos += scnprintf(buf + pos, len - pos, "QSET %4u %4u\n", 94004987ca1SGuangbin Huang le16_to_cpu(nodes->qset_base_id), 94104987ca1SGuangbin Huang le16_to_cpu(nodes->qset_num)); 94204987ca1SGuangbin Huang pos += scnprintf(buf + pos, len - pos, "QUEUE %4u %4u\n", 94304987ca1SGuangbin Huang le16_to_cpu(nodes->queue_base_id), 94404987ca1SGuangbin Huang le16_to_cpu(nodes->queue_num)); 94504987ca1SGuangbin Huang 94604987ca1SGuangbin Huang return 0; 94704987ca1SGuangbin Huang } 94804987ca1SGuangbin Huang 94904d96139SGuangbin Huang static const struct hclge_dbg_item tm_pri_items[] = { 95004d96139SGuangbin Huang { "ID", 4 }, 95104d96139SGuangbin Huang { "MODE", 2 }, 95204d96139SGuangbin Huang { "DWRR", 2 }, 95304d96139SGuangbin Huang { "C_IR_B", 2 }, 95404d96139SGuangbin Huang { "C_IR_U", 2 }, 95504d96139SGuangbin Huang { "C_IR_S", 2 }, 95604d96139SGuangbin Huang { "C_BS_B", 2 }, 95704d96139SGuangbin Huang { "C_BS_S", 2 }, 95804d96139SGuangbin Huang { "C_FLAG", 2 }, 95904d96139SGuangbin Huang { "C_RATE(Mbps)", 2 }, 96004d96139SGuangbin Huang { "P_IR_B", 2 }, 96104d96139SGuangbin Huang { "P_IR_U", 2 }, 96204d96139SGuangbin Huang { "P_IR_S", 2 }, 96304d96139SGuangbin Huang { "P_BS_B", 2 }, 96404d96139SGuangbin Huang { "P_BS_S", 2 }, 96504d96139SGuangbin Huang { "P_FLAG", 2 }, 96604d96139SGuangbin Huang { "P_RATE(Mbps)", 0 } 96704d96139SGuangbin Huang }; 96804d96139SGuangbin Huang 96904987ca1SGuangbin Huang static int hclge_dbg_dump_tm_pri(struct hclge_dev *hdev, char *buf, int len) 97004987ca1SGuangbin Huang { 97104d96139SGuangbin Huang char data_str[ARRAY_SIZE(tm_pri_items)][HCLGE_DBG_DATA_STR_LEN]; 97204d96139SGuangbin Huang struct hclge_tm_shaper_para c_shaper_para, p_shaper_para; 97304d96139SGuangbin Huang char *result[ARRAY_SIZE(tm_pri_items)], *sch_mode_str; 97404d96139SGuangbin Huang char content[HCLGE_DBG_TM_INFO_LEN]; 97504d96139SGuangbin Huang u8 pri_num, sch_mode, weight, i, j; 97604d96139SGuangbin Huang int pos, ret; 97704987ca1SGuangbin Huang 97804987ca1SGuangbin Huang ret = hclge_tm_get_pri_num(hdev, &pri_num); 97904987ca1SGuangbin Huang if (ret) 98004987ca1SGuangbin Huang return ret; 98104987ca1SGuangbin Huang 98204d96139SGuangbin Huang for (i = 0; i < ARRAY_SIZE(tm_pri_items); i++) 98304d96139SGuangbin Huang result[i] = &data_str[i][0]; 98404d96139SGuangbin Huang 98504d96139SGuangbin Huang hclge_dbg_fill_content(content, sizeof(content), tm_pri_items, 98604d96139SGuangbin Huang NULL, ARRAY_SIZE(tm_pri_items)); 98704d96139SGuangbin Huang pos = scnprintf(buf, len, "%s", content); 98804987ca1SGuangbin Huang 98904987ca1SGuangbin Huang for (i = 0; i < pri_num; i++) { 99004987ca1SGuangbin Huang ret = hclge_tm_get_pri_sch_mode(hdev, i, &sch_mode); 99104987ca1SGuangbin Huang if (ret) 99204987ca1SGuangbin Huang return ret; 99304987ca1SGuangbin Huang 99404987ca1SGuangbin Huang ret = hclge_tm_get_pri_weight(hdev, i, &weight); 99504987ca1SGuangbin Huang if (ret) 99604987ca1SGuangbin Huang return ret; 99704987ca1SGuangbin Huang 99804987ca1SGuangbin Huang ret = hclge_tm_get_pri_shaper(hdev, i, 99904987ca1SGuangbin Huang HCLGE_OPC_TM_PRI_C_SHAPPING, 100004987ca1SGuangbin Huang &c_shaper_para); 100104987ca1SGuangbin Huang if (ret) 100204987ca1SGuangbin Huang return ret; 100304987ca1SGuangbin Huang 100404987ca1SGuangbin Huang ret = hclge_tm_get_pri_shaper(hdev, i, 100504987ca1SGuangbin Huang HCLGE_OPC_TM_PRI_P_SHAPPING, 100604987ca1SGuangbin Huang &p_shaper_para); 100704987ca1SGuangbin Huang if (ret) 100804987ca1SGuangbin Huang return ret; 100904987ca1SGuangbin Huang 101004987ca1SGuangbin Huang sch_mode_str = sch_mode & HCLGE_TM_TX_SCHD_DWRR_MSK ? "dwrr" : 101104987ca1SGuangbin Huang "sp"; 101204987ca1SGuangbin Huang 101304d96139SGuangbin Huang j = 0; 101404d96139SGuangbin Huang sprintf(result[j++], "%04u", i); 101504d96139SGuangbin Huang sprintf(result[j++], "%4s", sch_mode_str); 101604d96139SGuangbin Huang sprintf(result[j++], "%3u", weight); 101704d96139SGuangbin Huang hclge_dbg_fill_shaper_content(&c_shaper_para, result, &j); 101804d96139SGuangbin Huang hclge_dbg_fill_shaper_content(&p_shaper_para, result, &j); 101904d96139SGuangbin Huang hclge_dbg_fill_content(content, sizeof(content), tm_pri_items, 102004d96139SGuangbin Huang (const char **)result, 102104d96139SGuangbin Huang ARRAY_SIZE(tm_pri_items)); 102204d96139SGuangbin Huang pos += scnprintf(buf + pos, len - pos, "%s", content); 102304987ca1SGuangbin Huang } 102404987ca1SGuangbin Huang 102504987ca1SGuangbin Huang return 0; 102604987ca1SGuangbin Huang } 102704987ca1SGuangbin Huang 1028484e1ed1SGuangbin Huang static const struct hclge_dbg_item tm_qset_items[] = { 1029484e1ed1SGuangbin Huang { "ID", 4 }, 1030484e1ed1SGuangbin Huang { "MAP_PRI", 2 }, 1031484e1ed1SGuangbin Huang { "LINK_VLD", 2 }, 1032484e1ed1SGuangbin Huang { "MODE", 2 }, 1033484e1ed1SGuangbin Huang { "DWRR", 2 }, 1034484e1ed1SGuangbin Huang { "IR_B", 2 }, 1035484e1ed1SGuangbin Huang { "IR_U", 2 }, 1036484e1ed1SGuangbin Huang { "IR_S", 2 }, 1037484e1ed1SGuangbin Huang { "BS_B", 2 }, 1038484e1ed1SGuangbin Huang { "BS_S", 2 }, 1039484e1ed1SGuangbin Huang { "FLAG", 2 }, 1040484e1ed1SGuangbin Huang { "RATE(Mbps)", 0 } 1041484e1ed1SGuangbin Huang }; 1042484e1ed1SGuangbin Huang 104304987ca1SGuangbin Huang static int hclge_dbg_dump_tm_qset(struct hclge_dev *hdev, char *buf, int len) 104404987ca1SGuangbin Huang { 1045484e1ed1SGuangbin Huang char data_str[ARRAY_SIZE(tm_qset_items)][HCLGE_DBG_DATA_STR_LEN]; 1046484e1ed1SGuangbin Huang char *result[ARRAY_SIZE(tm_qset_items)], *sch_mode_str; 104704987ca1SGuangbin Huang u8 priority, link_vld, sch_mode, weight; 1048484e1ed1SGuangbin Huang struct hclge_tm_shaper_para shaper_para; 1049484e1ed1SGuangbin Huang char content[HCLGE_DBG_TM_INFO_LEN]; 1050484e1ed1SGuangbin Huang u16 qset_num, i; 105104987ca1SGuangbin Huang int ret, pos; 1052484e1ed1SGuangbin Huang u8 j; 105304987ca1SGuangbin Huang 105404987ca1SGuangbin Huang ret = hclge_tm_get_qset_num(hdev, &qset_num); 105504987ca1SGuangbin Huang if (ret) 105604987ca1SGuangbin Huang return ret; 105704987ca1SGuangbin Huang 1058484e1ed1SGuangbin Huang for (i = 0; i < ARRAY_SIZE(tm_qset_items); i++) 1059484e1ed1SGuangbin Huang result[i] = &data_str[i][0]; 1060484e1ed1SGuangbin Huang 1061484e1ed1SGuangbin Huang hclge_dbg_fill_content(content, sizeof(content), tm_qset_items, 1062484e1ed1SGuangbin Huang NULL, ARRAY_SIZE(tm_qset_items)); 1063484e1ed1SGuangbin Huang pos = scnprintf(buf, len, "%s", content); 106404987ca1SGuangbin Huang 106504987ca1SGuangbin Huang for (i = 0; i < qset_num; i++) { 106604987ca1SGuangbin Huang ret = hclge_tm_get_qset_map_pri(hdev, i, &priority, &link_vld); 106704987ca1SGuangbin Huang if (ret) 106804987ca1SGuangbin Huang return ret; 106904987ca1SGuangbin Huang 107004987ca1SGuangbin Huang ret = hclge_tm_get_qset_sch_mode(hdev, i, &sch_mode); 107104987ca1SGuangbin Huang if (ret) 107204987ca1SGuangbin Huang return ret; 107304987ca1SGuangbin Huang 107404987ca1SGuangbin Huang ret = hclge_tm_get_qset_weight(hdev, i, &weight); 107504987ca1SGuangbin Huang if (ret) 107604987ca1SGuangbin Huang return ret; 107704987ca1SGuangbin Huang 1078484e1ed1SGuangbin Huang ret = hclge_tm_get_qset_shaper(hdev, i, &shaper_para); 1079484e1ed1SGuangbin Huang if (ret) 1080484e1ed1SGuangbin Huang return ret; 1081484e1ed1SGuangbin Huang 108204987ca1SGuangbin Huang sch_mode_str = sch_mode & HCLGE_TM_TX_SCHD_DWRR_MSK ? "dwrr" : 108304987ca1SGuangbin Huang "sp"; 1084484e1ed1SGuangbin Huang 1085484e1ed1SGuangbin Huang j = 0; 1086484e1ed1SGuangbin Huang sprintf(result[j++], "%04u", i); 1087484e1ed1SGuangbin Huang sprintf(result[j++], "%4u", priority); 1088484e1ed1SGuangbin Huang sprintf(result[j++], "%4u", link_vld); 1089484e1ed1SGuangbin Huang sprintf(result[j++], "%4s", sch_mode_str); 1090484e1ed1SGuangbin Huang sprintf(result[j++], "%3u", weight); 1091484e1ed1SGuangbin Huang hclge_dbg_fill_shaper_content(&shaper_para, result, &j); 1092484e1ed1SGuangbin Huang 1093484e1ed1SGuangbin Huang hclge_dbg_fill_content(content, sizeof(content), tm_qset_items, 1094484e1ed1SGuangbin Huang (const char **)result, 1095484e1ed1SGuangbin Huang ARRAY_SIZE(tm_qset_items)); 1096484e1ed1SGuangbin Huang pos += scnprintf(buf + pos, len - pos, "%s", content); 109704987ca1SGuangbin Huang } 109804987ca1SGuangbin Huang 109904987ca1SGuangbin Huang return 0; 110004987ca1SGuangbin Huang } 110104987ca1SGuangbin Huang 11026571ec2eSGuangbin Huang static int hclge_dbg_dump_qos_pause_cfg(struct hclge_dev *hdev, char *buf, 11036571ec2eSGuangbin Huang int len) 1104d958919dSliuzhongzhu { 1105d958919dSliuzhongzhu struct hclge_cfg_pause_param_cmd *pause_param; 1106d958919dSliuzhongzhu struct hclge_desc desc; 11076571ec2eSGuangbin Huang int pos = 0; 1108d958919dSliuzhongzhu int ret; 1109d958919dSliuzhongzhu 1110d958919dSliuzhongzhu hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_CFG_MAC_PARA, true); 1111d958919dSliuzhongzhu ret = hclge_cmd_send(&hdev->hw, &desc, 1); 1112d958919dSliuzhongzhu if (ret) { 11136571ec2eSGuangbin Huang dev_err(&hdev->pdev->dev, 11146571ec2eSGuangbin Huang "failed to dump qos pause, ret = %d\n", ret); 11156571ec2eSGuangbin Huang return ret; 1116d958919dSliuzhongzhu } 1117d958919dSliuzhongzhu 1118d958919dSliuzhongzhu pause_param = (struct hclge_cfg_pause_param_cmd *)desc.data; 11196571ec2eSGuangbin Huang 11206571ec2eSGuangbin Huang pos += scnprintf(buf + pos, len - pos, "pause_trans_gap: 0x%x\n", 1121d958919dSliuzhongzhu pause_param->pause_trans_gap); 11226571ec2eSGuangbin Huang pos += scnprintf(buf + pos, len - pos, "pause_trans_time: 0x%x\n", 112339edaf24SGuojia Liao le16_to_cpu(pause_param->pause_trans_time)); 11246571ec2eSGuangbin Huang return 0; 1125d958919dSliuzhongzhu } 1126d958919dSliuzhongzhu 112728d3badaSGuangbin Huang static int hclge_dbg_dump_qos_pri_map(struct hclge_dev *hdev, char *buf, 112828d3badaSGuangbin Huang int len) 11296fc22440Sliuzhongzhu { 113028d3badaSGuangbin Huang #define HCLGE_DBG_TC_MASK 0x0F 113128d3badaSGuangbin Huang #define HCLGE_DBG_TC_BIT_WIDTH 4 113228d3badaSGuangbin Huang 11336fc22440Sliuzhongzhu struct hclge_qos_pri_map_cmd *pri_map; 11346fc22440Sliuzhongzhu struct hclge_desc desc; 113528d3badaSGuangbin Huang int pos = 0; 113628d3badaSGuangbin Huang u8 *pri_tc; 113728d3badaSGuangbin Huang u8 tc, i; 11386fc22440Sliuzhongzhu int ret; 11396fc22440Sliuzhongzhu 11406fc22440Sliuzhongzhu hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_PRI_TO_TC_MAPPING, true); 11416fc22440Sliuzhongzhu ret = hclge_cmd_send(&hdev->hw, &desc, 1); 11426fc22440Sliuzhongzhu if (ret) { 11436fc22440Sliuzhongzhu dev_err(&hdev->pdev->dev, 114428d3badaSGuangbin Huang "failed to dump qos pri map, ret = %d\n", ret); 114528d3badaSGuangbin Huang return ret; 11466fc22440Sliuzhongzhu } 11476fc22440Sliuzhongzhu 11486fc22440Sliuzhongzhu pri_map = (struct hclge_qos_pri_map_cmd *)desc.data; 114928d3badaSGuangbin Huang 115028d3badaSGuangbin Huang pos += scnprintf(buf + pos, len - pos, "vlan_to_pri: 0x%x\n", 115128d3badaSGuangbin Huang pri_map->vlan_pri); 115228d3badaSGuangbin Huang pos += scnprintf(buf + pos, len - pos, "PRI TC\n"); 115328d3badaSGuangbin Huang 115428d3badaSGuangbin Huang pri_tc = (u8 *)pri_map; 115528d3badaSGuangbin Huang for (i = 0; i < HNAE3_MAX_TC; i++) { 115628d3badaSGuangbin Huang tc = pri_tc[i >> 1] >> ((i & 1) * HCLGE_DBG_TC_BIT_WIDTH); 115728d3badaSGuangbin Huang tc &= HCLGE_DBG_TC_MASK; 115828d3badaSGuangbin Huang pos += scnprintf(buf + pos, len - pos, "%u %u\n", i, tc); 115928d3badaSGuangbin Huang } 116028d3badaSGuangbin Huang 116128d3badaSGuangbin Huang return 0; 11626fc22440Sliuzhongzhu } 11636fc22440Sliuzhongzhu 116495b19586SGuangbin Huang static int hclge_dbg_dump_tx_buf_cfg(struct hclge_dev *hdev, char *buf, int len) 11657d9d7f88Sliuzhongzhu { 11667d9d7f88Sliuzhongzhu struct hclge_tx_buff_alloc_cmd *tx_buf_cmd; 1167b3712fa7SJian Shen struct hclge_desc desc; 116895b19586SGuangbin Huang int pos = 0; 11697d9d7f88Sliuzhongzhu int i, ret; 11707d9d7f88Sliuzhongzhu 1171b3712fa7SJian Shen hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_TX_BUFF_ALLOC, true); 1172b3712fa7SJian Shen ret = hclge_cmd_send(&hdev->hw, &desc, 1); 117395b19586SGuangbin Huang if (ret) { 117495b19586SGuangbin Huang dev_err(&hdev->pdev->dev, 117595b19586SGuangbin Huang "failed to dump tx buf, ret = %d\n", ret); 1176b3712fa7SJian Shen return ret; 1177b3712fa7SJian Shen } 1178b3712fa7SJian Shen 117995b19586SGuangbin Huang tx_buf_cmd = (struct hclge_tx_buff_alloc_cmd *)desc.data; 118095b19586SGuangbin Huang for (i = 0; i < HCLGE_MAX_TC_NUM; i++) 118195b19586SGuangbin Huang pos += scnprintf(buf + pos, len - pos, 118295b19586SGuangbin Huang "tx_packet_buf_tc_%d: 0x%x\n", i, 118395b19586SGuangbin Huang le16_to_cpu(tx_buf_cmd->tx_pkt_buff[i])); 118495b19586SGuangbin Huang 118595b19586SGuangbin Huang return pos; 118695b19586SGuangbin Huang } 118795b19586SGuangbin Huang 118895b19586SGuangbin Huang static int hclge_dbg_dump_rx_priv_buf_cfg(struct hclge_dev *hdev, char *buf, 118995b19586SGuangbin Huang int len) 1190b3712fa7SJian Shen { 1191b3712fa7SJian Shen struct hclge_rx_priv_buff_cmd *rx_buf_cmd; 1192b3712fa7SJian Shen struct hclge_desc desc; 119395b19586SGuangbin Huang int pos = 0; 1194b3712fa7SJian Shen int i, ret; 1195b3712fa7SJian Shen 1196b3712fa7SJian Shen hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_RX_PRIV_BUFF_ALLOC, true); 1197b3712fa7SJian Shen ret = hclge_cmd_send(&hdev->hw, &desc, 1); 119895b19586SGuangbin Huang if (ret) { 119995b19586SGuangbin Huang dev_err(&hdev->pdev->dev, 120095b19586SGuangbin Huang "failed to dump rx priv buf, ret = %d\n", ret); 1201b3712fa7SJian Shen return ret; 1202b3712fa7SJian Shen } 12033f0f3253SYufeng Mo 120495b19586SGuangbin Huang pos += scnprintf(buf + pos, len - pos, "\n"); 120595b19586SGuangbin Huang 120695b19586SGuangbin Huang rx_buf_cmd = (struct hclge_rx_priv_buff_cmd *)desc.data; 120795b19586SGuangbin Huang for (i = 0; i < HCLGE_MAX_TC_NUM; i++) 120895b19586SGuangbin Huang pos += scnprintf(buf + pos, len - pos, 120995b19586SGuangbin Huang "rx_packet_buf_tc_%d: 0x%x\n", i, 121095b19586SGuangbin Huang le16_to_cpu(rx_buf_cmd->buf_num[i])); 121195b19586SGuangbin Huang 121295b19586SGuangbin Huang pos += scnprintf(buf + pos, len - pos, "rx_share_buf: 0x%x\n", 121395b19586SGuangbin Huang le16_to_cpu(rx_buf_cmd->shared_buf)); 121495b19586SGuangbin Huang 121595b19586SGuangbin Huang return pos; 121695b19586SGuangbin Huang } 121795b19586SGuangbin Huang 121895b19586SGuangbin Huang static int hclge_dbg_dump_rx_common_wl_cfg(struct hclge_dev *hdev, char *buf, 121995b19586SGuangbin Huang int len) 1220b3712fa7SJian Shen { 1221b3712fa7SJian Shen struct hclge_rx_com_wl *rx_com_wl; 1222b3712fa7SJian Shen struct hclge_desc desc; 122395b19586SGuangbin Huang int pos = 0; 1224b3712fa7SJian Shen int ret; 1225b3712fa7SJian Shen 1226b3712fa7SJian Shen hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_RX_COM_WL_ALLOC, true); 1227b3712fa7SJian Shen ret = hclge_cmd_send(&hdev->hw, &desc, 1); 122895b19586SGuangbin Huang if (ret) { 122995b19586SGuangbin Huang dev_err(&hdev->pdev->dev, 123095b19586SGuangbin Huang "failed to dump rx common wl, ret = %d\n", ret); 1231b3712fa7SJian Shen return ret; 123295b19586SGuangbin Huang } 1233b3712fa7SJian Shen 1234b3712fa7SJian Shen rx_com_wl = (struct hclge_rx_com_wl *)desc.data; 123595b19586SGuangbin Huang pos += scnprintf(buf + pos, len - pos, "\n"); 123695b19586SGuangbin Huang pos += scnprintf(buf + pos, len - pos, 123795b19586SGuangbin Huang "rx_com_wl: high: 0x%x, low: 0x%x\n", 123839edaf24SGuojia Liao le16_to_cpu(rx_com_wl->com_wl.high), 123939edaf24SGuojia Liao le16_to_cpu(rx_com_wl->com_wl.low)); 12403f0f3253SYufeng Mo 124195b19586SGuangbin Huang return pos; 1242b3712fa7SJian Shen } 12433f0f3253SYufeng Mo 124495b19586SGuangbin Huang static int hclge_dbg_dump_rx_global_pkt_cnt(struct hclge_dev *hdev, char *buf, 124595b19586SGuangbin Huang int len) 1246b3712fa7SJian Shen { 1247b3712fa7SJian Shen struct hclge_rx_com_wl *rx_packet_cnt; 1248b3712fa7SJian Shen struct hclge_desc desc; 124995b19586SGuangbin Huang int pos = 0; 1250b3712fa7SJian Shen int ret; 1251b3712fa7SJian Shen 1252b3712fa7SJian Shen hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_RX_GBL_PKT_CNT, true); 1253b3712fa7SJian Shen ret = hclge_cmd_send(&hdev->hw, &desc, 1); 125495b19586SGuangbin Huang if (ret) { 125595b19586SGuangbin Huang dev_err(&hdev->pdev->dev, 125695b19586SGuangbin Huang "failed to dump rx global pkt cnt, ret = %d\n", ret); 1257b3712fa7SJian Shen return ret; 125895b19586SGuangbin Huang } 1259b3712fa7SJian Shen 1260b3712fa7SJian Shen rx_packet_cnt = (struct hclge_rx_com_wl *)desc.data; 126195b19586SGuangbin Huang pos += scnprintf(buf + pos, len - pos, 12623f0f3253SYufeng Mo "rx_global_packet_cnt: high: 0x%x, low: 0x%x\n", 126339edaf24SGuojia Liao le16_to_cpu(rx_packet_cnt->com_wl.high), 126439edaf24SGuojia Liao le16_to_cpu(rx_packet_cnt->com_wl.low)); 12653f0f3253SYufeng Mo 126695b19586SGuangbin Huang return pos; 12673f0f3253SYufeng Mo } 1268b3712fa7SJian Shen 126995b19586SGuangbin Huang static int hclge_dbg_dump_rx_priv_wl_buf_cfg(struct hclge_dev *hdev, char *buf, 127095b19586SGuangbin Huang int len) 1271b3712fa7SJian Shen { 1272b3712fa7SJian Shen struct hclge_rx_priv_wl_buf *rx_priv_wl; 1273b3712fa7SJian Shen struct hclge_desc desc[2]; 127495b19586SGuangbin Huang int pos = 0; 1275b3712fa7SJian Shen int i, ret; 1276b3712fa7SJian Shen 1277b3712fa7SJian Shen hclge_cmd_setup_basic_desc(&desc[0], HCLGE_OPC_RX_PRIV_WL_ALLOC, true); 12787d9d7f88Sliuzhongzhu desc[0].flag |= cpu_to_le16(HCLGE_CMD_FLAG_NEXT); 1279b3712fa7SJian Shen hclge_cmd_setup_basic_desc(&desc[1], HCLGE_OPC_RX_PRIV_WL_ALLOC, true); 12807d9d7f88Sliuzhongzhu ret = hclge_cmd_send(&hdev->hw, desc, 2); 128195b19586SGuangbin Huang if (ret) { 128295b19586SGuangbin Huang dev_err(&hdev->pdev->dev, 128395b19586SGuangbin Huang "failed to dump rx priv wl buf, ret = %d\n", ret); 1284b3712fa7SJian Shen return ret; 128595b19586SGuangbin Huang } 12867d9d7f88Sliuzhongzhu 12877d9d7f88Sliuzhongzhu rx_priv_wl = (struct hclge_rx_priv_wl_buf *)desc[0].data; 12887d9d7f88Sliuzhongzhu for (i = 0; i < HCLGE_TC_NUM_ONE_DESC; i++) 128995b19586SGuangbin Huang pos += scnprintf(buf + pos, len - pos, 12907d9d7f88Sliuzhongzhu "rx_priv_wl_tc_%d: high: 0x%x, low: 0x%x\n", i, 129139edaf24SGuojia Liao le16_to_cpu(rx_priv_wl->tc_wl[i].high), 129239edaf24SGuojia Liao le16_to_cpu(rx_priv_wl->tc_wl[i].low)); 12937d9d7f88Sliuzhongzhu 12947d9d7f88Sliuzhongzhu rx_priv_wl = (struct hclge_rx_priv_wl_buf *)desc[1].data; 12957d9d7f88Sliuzhongzhu for (i = 0; i < HCLGE_TC_NUM_ONE_DESC; i++) 129695b19586SGuangbin Huang pos += scnprintf(buf + pos, len - pos, 12976f92bfd7SHuazhong Tan "rx_priv_wl_tc_%d: high: 0x%x, low: 0x%x\n", 12986f92bfd7SHuazhong Tan i + HCLGE_TC_NUM_ONE_DESC, 129939edaf24SGuojia Liao le16_to_cpu(rx_priv_wl->tc_wl[i].high), 130039edaf24SGuojia Liao le16_to_cpu(rx_priv_wl->tc_wl[i].low)); 13017d9d7f88Sliuzhongzhu 130295b19586SGuangbin Huang return pos; 1303b3712fa7SJian Shen } 1304b3712fa7SJian Shen 130595b19586SGuangbin Huang static int hclge_dbg_dump_rx_common_threshold_cfg(struct hclge_dev *hdev, 130695b19586SGuangbin Huang char *buf, int len) 1307b3712fa7SJian Shen { 1308b3712fa7SJian Shen struct hclge_rx_com_thrd *rx_com_thrd; 1309b3712fa7SJian Shen struct hclge_desc desc[2]; 131095b19586SGuangbin Huang int pos = 0; 1311b3712fa7SJian Shen int i, ret; 1312b3712fa7SJian Shen 1313b3712fa7SJian Shen hclge_cmd_setup_basic_desc(&desc[0], HCLGE_OPC_RX_COM_THRD_ALLOC, true); 13147d9d7f88Sliuzhongzhu desc[0].flag |= cpu_to_le16(HCLGE_CMD_FLAG_NEXT); 1315b3712fa7SJian Shen hclge_cmd_setup_basic_desc(&desc[1], HCLGE_OPC_RX_COM_THRD_ALLOC, true); 13167d9d7f88Sliuzhongzhu ret = hclge_cmd_send(&hdev->hw, desc, 2); 131795b19586SGuangbin Huang if (ret) { 131895b19586SGuangbin Huang dev_err(&hdev->pdev->dev, 131995b19586SGuangbin Huang "failed to dump rx common threshold, ret = %d\n", ret); 1320b3712fa7SJian Shen return ret; 132195b19586SGuangbin Huang } 13227d9d7f88Sliuzhongzhu 132395b19586SGuangbin Huang pos += scnprintf(buf + pos, len - pos, "\n"); 13247d9d7f88Sliuzhongzhu rx_com_thrd = (struct hclge_rx_com_thrd *)desc[0].data; 13257d9d7f88Sliuzhongzhu for (i = 0; i < HCLGE_TC_NUM_ONE_DESC; i++) 132695b19586SGuangbin Huang pos += scnprintf(buf + pos, len - pos, 13277d9d7f88Sliuzhongzhu "rx_com_thrd_tc_%d: high: 0x%x, low: 0x%x\n", i, 132839edaf24SGuojia Liao le16_to_cpu(rx_com_thrd->com_thrd[i].high), 132939edaf24SGuojia Liao le16_to_cpu(rx_com_thrd->com_thrd[i].low)); 13307d9d7f88Sliuzhongzhu 13317d9d7f88Sliuzhongzhu rx_com_thrd = (struct hclge_rx_com_thrd *)desc[1].data; 13327d9d7f88Sliuzhongzhu for (i = 0; i < HCLGE_TC_NUM_ONE_DESC; i++) 133395b19586SGuangbin Huang pos += scnprintf(buf + pos, len - pos, 13346f92bfd7SHuazhong Tan "rx_com_thrd_tc_%d: high: 0x%x, low: 0x%x\n", 13356f92bfd7SHuazhong Tan i + HCLGE_TC_NUM_ONE_DESC, 133639edaf24SGuojia Liao le16_to_cpu(rx_com_thrd->com_thrd[i].high), 133739edaf24SGuojia Liao le16_to_cpu(rx_com_thrd->com_thrd[i].low)); 1338b3712fa7SJian Shen 133995b19586SGuangbin Huang return pos; 1340b3712fa7SJian Shen } 1341b3712fa7SJian Shen 134295b19586SGuangbin Huang static int hclge_dbg_dump_qos_buf_cfg(struct hclge_dev *hdev, char *buf, 134395b19586SGuangbin Huang int len) 1344b3712fa7SJian Shen { 134595b19586SGuangbin Huang int pos = 0; 1346b3712fa7SJian Shen int ret; 1347b3712fa7SJian Shen 134895b19586SGuangbin Huang ret = hclge_dbg_dump_tx_buf_cfg(hdev, buf + pos, len - pos); 134995b19586SGuangbin Huang if (ret < 0) 135095b19586SGuangbin Huang return ret; 135195b19586SGuangbin Huang pos += ret; 1352b3712fa7SJian Shen 135395b19586SGuangbin Huang ret = hclge_dbg_dump_rx_priv_buf_cfg(hdev, buf + pos, len - pos); 135495b19586SGuangbin Huang if (ret < 0) 135595b19586SGuangbin Huang return ret; 135695b19586SGuangbin Huang pos += ret; 1357b3712fa7SJian Shen 135895b19586SGuangbin Huang ret = hclge_dbg_dump_rx_common_wl_cfg(hdev, buf + pos, len - pos); 135995b19586SGuangbin Huang if (ret < 0) 136095b19586SGuangbin Huang return ret; 136195b19586SGuangbin Huang pos += ret; 1362b3712fa7SJian Shen 136395b19586SGuangbin Huang ret = hclge_dbg_dump_rx_global_pkt_cnt(hdev, buf + pos, len - pos); 136495b19586SGuangbin Huang if (ret < 0) 136595b19586SGuangbin Huang return ret; 136695b19586SGuangbin Huang pos += ret; 1367b3712fa7SJian Shen 136895b19586SGuangbin Huang pos += scnprintf(buf + pos, len - pos, "\n"); 136995b19586SGuangbin Huang if (!hnae3_dev_dcb_supported(hdev)) 137095b19586SGuangbin Huang return 0; 1371b3712fa7SJian Shen 137295b19586SGuangbin Huang ret = hclge_dbg_dump_rx_priv_wl_buf_cfg(hdev, buf + pos, len - pos); 137395b19586SGuangbin Huang if (ret < 0) 137495b19586SGuangbin Huang return ret; 137595b19586SGuangbin Huang pos += ret; 1376b3712fa7SJian Shen 137795b19586SGuangbin Huang ret = hclge_dbg_dump_rx_common_threshold_cfg(hdev, buf + pos, 137895b19586SGuangbin Huang len - pos); 137995b19586SGuangbin Huang if (ret < 0) 138095b19586SGuangbin Huang return ret; 1381b3712fa7SJian Shen 138295b19586SGuangbin Huang return 0; 13837d9d7f88Sliuzhongzhu } 13847d9d7f88Sliuzhongzhu 13858ddfd9c4SYufeng Mo static int hclge_dbg_dump_mng_table(struct hclge_dev *hdev, char *buf, int len) 13867737f1fbSliuzhongzhu { 13877737f1fbSliuzhongzhu struct hclge_mac_ethertype_idx_rd_cmd *req0; 13887737f1fbSliuzhongzhu struct hclge_desc desc; 138972fa4904SGuojia Liao u32 msg_egress_port; 13908ddfd9c4SYufeng Mo int pos = 0; 13917737f1fbSliuzhongzhu int ret, i; 13927737f1fbSliuzhongzhu 13938ddfd9c4SYufeng Mo pos += scnprintf(buf + pos, len - pos, 13948ddfd9c4SYufeng Mo "entry mac_addr mask ether "); 13958ddfd9c4SYufeng Mo pos += scnprintf(buf + pos, len - pos, 13968ddfd9c4SYufeng Mo "mask vlan mask i_map i_dir e_type "); 13978ddfd9c4SYufeng Mo pos += scnprintf(buf + pos, len - pos, "pf_id vf_id q_id drop\n"); 13987737f1fbSliuzhongzhu 13997737f1fbSliuzhongzhu for (i = 0; i < HCLGE_DBG_MNG_TBL_MAX; i++) { 14007737f1fbSliuzhongzhu hclge_cmd_setup_basic_desc(&desc, HCLGE_MAC_ETHERTYPE_IDX_RD, 14017737f1fbSliuzhongzhu true); 14027737f1fbSliuzhongzhu req0 = (struct hclge_mac_ethertype_idx_rd_cmd *)&desc.data; 14037737f1fbSliuzhongzhu req0->index = cpu_to_le16(i); 14047737f1fbSliuzhongzhu 14057737f1fbSliuzhongzhu ret = hclge_cmd_send(&hdev->hw, &desc, 1); 14067737f1fbSliuzhongzhu if (ret) { 14077737f1fbSliuzhongzhu dev_err(&hdev->pdev->dev, 14088ddfd9c4SYufeng Mo "failed to dump manage table, ret = %d\n", ret); 14098ddfd9c4SYufeng Mo return ret; 14107737f1fbSliuzhongzhu } 14117737f1fbSliuzhongzhu 14127737f1fbSliuzhongzhu if (!req0->resp_code) 14137737f1fbSliuzhongzhu continue; 14147737f1fbSliuzhongzhu 14158ddfd9c4SYufeng Mo pos += scnprintf(buf + pos, len - pos, "%02u %pM ", 14168ddfd9c4SYufeng Mo le16_to_cpu(req0->index), req0->mac_addr); 14177737f1fbSliuzhongzhu 14188ddfd9c4SYufeng Mo pos += scnprintf(buf + pos, len - pos, 14198ddfd9c4SYufeng Mo "%x %04x %x %04x ", 14207737f1fbSliuzhongzhu !!(req0->flags & HCLGE_DBG_MNG_MAC_MASK_B), 142172fa4904SGuojia Liao le16_to_cpu(req0->ethter_type), 14227737f1fbSliuzhongzhu !!(req0->flags & HCLGE_DBG_MNG_ETHER_MASK_B), 14238ddfd9c4SYufeng Mo le16_to_cpu(req0->vlan_tag) & 14248ddfd9c4SYufeng Mo HCLGE_DBG_MNG_VLAN_TAG); 14258ddfd9c4SYufeng Mo 14268ddfd9c4SYufeng Mo pos += scnprintf(buf + pos, len - pos, 14278ddfd9c4SYufeng Mo "%x %02x %02x ", 14287737f1fbSliuzhongzhu !!(req0->flags & HCLGE_DBG_MNG_VLAN_MASK_B), 14297737f1fbSliuzhongzhu req0->i_port_bitmap, req0->i_port_direction); 14307737f1fbSliuzhongzhu 143172fa4904SGuojia Liao msg_egress_port = le16_to_cpu(req0->egress_port); 14328ddfd9c4SYufeng Mo pos += scnprintf(buf + pos, len - pos, 14338ddfd9c4SYufeng Mo "%x %x %02x %04x %x\n", 143472fa4904SGuojia Liao !!(msg_egress_port & HCLGE_DBG_MNG_E_TYPE_B), 143572fa4904SGuojia Liao msg_egress_port & HCLGE_DBG_MNG_PF_ID, 143672fa4904SGuojia Liao (msg_egress_port >> 3) & HCLGE_DBG_MNG_VF_ID, 143772fa4904SGuojia Liao le16_to_cpu(req0->egress_queue), 143872fa4904SGuojia Liao !!(msg_egress_port & HCLGE_DBG_MNG_DROP_B)); 14397737f1fbSliuzhongzhu } 14408ddfd9c4SYufeng Mo 14418ddfd9c4SYufeng Mo return 0; 14427737f1fbSliuzhongzhu } 14437737f1fbSliuzhongzhu 1444b5a0b70dSHao Chen #define HCLGE_DBG_TCAM_BUF_SIZE 256 1445b5a0b70dSHao Chen 1446b5a0b70dSHao Chen static int hclge_dbg_fd_tcam_read(struct hclge_dev *hdev, bool sel_x, 1447b5a0b70dSHao Chen char *tcam_buf, 1448b5a0b70dSHao Chen struct hclge_dbg_tcam_msg tcam_msg) 14493c666b58Sliuzhongzhu { 14503c666b58Sliuzhongzhu struct hclge_fd_tcam_config_1_cmd *req1; 14513c666b58Sliuzhongzhu struct hclge_fd_tcam_config_2_cmd *req2; 14523c666b58Sliuzhongzhu struct hclge_fd_tcam_config_3_cmd *req3; 14533c666b58Sliuzhongzhu struct hclge_desc desc[3]; 1454b5a0b70dSHao Chen int pos = 0; 14553c666b58Sliuzhongzhu int ret, i; 14563c666b58Sliuzhongzhu u32 *req; 14573c666b58Sliuzhongzhu 14583c666b58Sliuzhongzhu hclge_cmd_setup_basic_desc(&desc[0], HCLGE_OPC_FD_TCAM_OP, true); 14593c666b58Sliuzhongzhu desc[0].flag |= cpu_to_le16(HCLGE_CMD_FLAG_NEXT); 14603c666b58Sliuzhongzhu hclge_cmd_setup_basic_desc(&desc[1], HCLGE_OPC_FD_TCAM_OP, true); 14613c666b58Sliuzhongzhu desc[1].flag |= cpu_to_le16(HCLGE_CMD_FLAG_NEXT); 14623c666b58Sliuzhongzhu hclge_cmd_setup_basic_desc(&desc[2], HCLGE_OPC_FD_TCAM_OP, true); 14633c666b58Sliuzhongzhu 14643c666b58Sliuzhongzhu req1 = (struct hclge_fd_tcam_config_1_cmd *)desc[0].data; 14653c666b58Sliuzhongzhu req2 = (struct hclge_fd_tcam_config_2_cmd *)desc[1].data; 14663c666b58Sliuzhongzhu req3 = (struct hclge_fd_tcam_config_3_cmd *)desc[2].data; 14673c666b58Sliuzhongzhu 1468b5a0b70dSHao Chen req1->stage = tcam_msg.stage; 14693c666b58Sliuzhongzhu req1->xy_sel = sel_x ? 1 : 0; 1470b5a0b70dSHao Chen req1->index = cpu_to_le32(tcam_msg.loc); 14713c666b58Sliuzhongzhu 14723c666b58Sliuzhongzhu ret = hclge_cmd_send(&hdev->hw, desc, 3); 14733c666b58Sliuzhongzhu if (ret) 147444b6b883SYufeng Mo return ret; 14753c666b58Sliuzhongzhu 1476b5a0b70dSHao Chen pos += scnprintf(tcam_buf + pos, HCLGE_DBG_TCAM_BUF_SIZE - pos, 1477b5a0b70dSHao Chen "read result tcam key %s(%u):\n", sel_x ? "x" : "y", 1478b5a0b70dSHao Chen tcam_msg.loc); 14793c666b58Sliuzhongzhu 148046ee7350SGuojia Liao /* tcam_data0 ~ tcam_data1 */ 14813c666b58Sliuzhongzhu req = (u32 *)req1->tcam_data; 14823c666b58Sliuzhongzhu for (i = 0; i < 2; i++) 1483b5a0b70dSHao Chen pos += scnprintf(tcam_buf + pos, HCLGE_DBG_TCAM_BUF_SIZE - pos, 1484b5a0b70dSHao Chen "%08x\n", *req++); 14853c666b58Sliuzhongzhu 148646ee7350SGuojia Liao /* tcam_data2 ~ tcam_data7 */ 14873c666b58Sliuzhongzhu req = (u32 *)req2->tcam_data; 14883c666b58Sliuzhongzhu for (i = 0; i < 6; i++) 1489b5a0b70dSHao Chen pos += scnprintf(tcam_buf + pos, HCLGE_DBG_TCAM_BUF_SIZE - pos, 1490b5a0b70dSHao Chen "%08x\n", *req++); 14913c666b58Sliuzhongzhu 149246ee7350SGuojia Liao /* tcam_data8 ~ tcam_data12 */ 14933c666b58Sliuzhongzhu req = (u32 *)req3->tcam_data; 14943c666b58Sliuzhongzhu for (i = 0; i < 5; i++) 1495b5a0b70dSHao Chen pos += scnprintf(tcam_buf + pos, HCLGE_DBG_TCAM_BUF_SIZE - pos, 1496b5a0b70dSHao Chen "%08x\n", *req++); 149744b6b883SYufeng Mo 149844b6b883SYufeng Mo return ret; 149944b6b883SYufeng Mo } 150044b6b883SYufeng Mo 150144b6b883SYufeng Mo static int hclge_dbg_get_rules_location(struct hclge_dev *hdev, u16 *rule_locs) 150244b6b883SYufeng Mo { 150344b6b883SYufeng Mo struct hclge_fd_rule *rule; 150444b6b883SYufeng Mo struct hlist_node *node; 150544b6b883SYufeng Mo int cnt = 0; 150644b6b883SYufeng Mo 150744b6b883SYufeng Mo spin_lock_bh(&hdev->fd_rule_lock); 150844b6b883SYufeng Mo hlist_for_each_entry_safe(rule, node, &hdev->fd_rule_list, rule_node) { 150944b6b883SYufeng Mo rule_locs[cnt] = rule->location; 151044b6b883SYufeng Mo cnt++; 151144b6b883SYufeng Mo } 151244b6b883SYufeng Mo spin_unlock_bh(&hdev->fd_rule_lock); 151344b6b883SYufeng Mo 1514b5a0b70dSHao Chen if (cnt != hdev->hclge_fd_rule_num || cnt == 0) 151544b6b883SYufeng Mo return -EINVAL; 151644b6b883SYufeng Mo 151744b6b883SYufeng Mo return cnt; 15183c666b58Sliuzhongzhu } 15193c666b58Sliuzhongzhu 1520b5a0b70dSHao Chen static int hclge_dbg_dump_fd_tcam(struct hclge_dev *hdev, char *buf, int len) 15213c666b58Sliuzhongzhu { 1522b5a0b70dSHao Chen u32 rule_num = hdev->fd_cfg.rule_num[HCLGE_FD_STAGE_1]; 1523b5a0b70dSHao Chen struct hclge_dbg_tcam_msg tcam_msg; 152444b6b883SYufeng Mo int i, ret, rule_cnt; 152544b6b883SYufeng Mo u16 *rule_locs; 1526b5a0b70dSHao Chen char *tcam_buf; 1527b5a0b70dSHao Chen int pos = 0; 15283c666b58Sliuzhongzhu 152944b6b883SYufeng Mo if (!hnae3_dev_fd_supported(hdev)) { 153044b6b883SYufeng Mo dev_err(&hdev->pdev->dev, 153144b6b883SYufeng Mo "Only FD-supported dev supports dump fd tcam\n"); 1532b5a0b70dSHao Chen return -EOPNOTSUPP; 15333c666b58Sliuzhongzhu } 153444b6b883SYufeng Mo 1535b5a0b70dSHao Chen if (!hdev->hclge_fd_rule_num || !rule_num) 1536b5a0b70dSHao Chen return 0; 153744b6b883SYufeng Mo 1538b5a0b70dSHao Chen rule_locs = kcalloc(rule_num, sizeof(u16), GFP_KERNEL); 153944b6b883SYufeng Mo if (!rule_locs) 1540b5a0b70dSHao Chen return -ENOMEM; 1541b5a0b70dSHao Chen 1542b5a0b70dSHao Chen tcam_buf = kzalloc(HCLGE_DBG_TCAM_BUF_SIZE, GFP_KERNEL); 1543b5a0b70dSHao Chen if (!tcam_buf) { 1544b5a0b70dSHao Chen kfree(rule_locs); 1545b5a0b70dSHao Chen return -ENOMEM; 1546b5a0b70dSHao Chen } 154744b6b883SYufeng Mo 154844b6b883SYufeng Mo rule_cnt = hclge_dbg_get_rules_location(hdev, rule_locs); 1549b5a0b70dSHao Chen if (rule_cnt < 0) { 1550b5a0b70dSHao Chen ret = rule_cnt; 155144b6b883SYufeng Mo dev_err(&hdev->pdev->dev, 1552b5a0b70dSHao Chen "failed to get rule number, ret = %d\n", ret); 1553b5a0b70dSHao Chen goto out; 155444b6b883SYufeng Mo } 155544b6b883SYufeng Mo 1556030c8198SColin Ian King ret = 0; 155744b6b883SYufeng Mo for (i = 0; i < rule_cnt; i++) { 1558b5a0b70dSHao Chen tcam_msg.stage = HCLGE_FD_STAGE_1; 1559b5a0b70dSHao Chen tcam_msg.loc = rule_locs[i]; 1560b5a0b70dSHao Chen 1561b5a0b70dSHao Chen ret = hclge_dbg_fd_tcam_read(hdev, true, tcam_buf, tcam_msg); 156244b6b883SYufeng Mo if (ret) { 156344b6b883SYufeng Mo dev_err(&hdev->pdev->dev, 156444b6b883SYufeng Mo "failed to get fd tcam key x, ret = %d\n", ret); 1565b5a0b70dSHao Chen goto out; 156644b6b883SYufeng Mo } 156744b6b883SYufeng Mo 1568b5a0b70dSHao Chen pos += scnprintf(buf + pos, len - pos, "%s", tcam_buf); 1569b5a0b70dSHao Chen 1570b5a0b70dSHao Chen ret = hclge_dbg_fd_tcam_read(hdev, false, tcam_buf, tcam_msg); 157144b6b883SYufeng Mo if (ret) { 157244b6b883SYufeng Mo dev_err(&hdev->pdev->dev, 157344b6b883SYufeng Mo "failed to get fd tcam key y, ret = %d\n", ret); 1574b5a0b70dSHao Chen goto out; 157544b6b883SYufeng Mo } 157644b6b883SYufeng Mo 1577b5a0b70dSHao Chen pos += scnprintf(buf + pos, len - pos, "%s", tcam_buf); 1578b5a0b70dSHao Chen } 1579b5a0b70dSHao Chen 1580b5a0b70dSHao Chen out: 1581b5a0b70dSHao Chen kfree(tcam_buf); 158244b6b883SYufeng Mo kfree(rule_locs); 1583b5a0b70dSHao Chen return ret; 15843c666b58Sliuzhongzhu } 15853c666b58Sliuzhongzhu 158603a92fe8SJian Shen static int hclge_dbg_dump_fd_counter(struct hclge_dev *hdev, char *buf, int len) 158703a92fe8SJian Shen { 158803a92fe8SJian Shen u8 func_num = pci_num_vf(hdev->pdev) + 1; /* pf and enabled vf num */ 158903a92fe8SJian Shen struct hclge_fd_ad_cnt_read_cmd *req; 159003a92fe8SJian Shen char str_id[HCLGE_DBG_ID_LEN]; 159103a92fe8SJian Shen struct hclge_desc desc; 159203a92fe8SJian Shen int pos = 0; 159303a92fe8SJian Shen int ret; 159403a92fe8SJian Shen u64 cnt; 159503a92fe8SJian Shen u8 i; 159603a92fe8SJian Shen 159703a92fe8SJian Shen pos += scnprintf(buf + pos, len - pos, 159803a92fe8SJian Shen "func_id\thit_times\n"); 159903a92fe8SJian Shen 160003a92fe8SJian Shen for (i = 0; i < func_num; i++) { 160103a92fe8SJian Shen hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_FD_CNT_OP, true); 160203a92fe8SJian Shen req = (struct hclge_fd_ad_cnt_read_cmd *)desc.data; 160303a92fe8SJian Shen req->index = cpu_to_le16(i); 160403a92fe8SJian Shen ret = hclge_cmd_send(&hdev->hw, &desc, 1); 160503a92fe8SJian Shen if (ret) { 160603a92fe8SJian Shen dev_err(&hdev->pdev->dev, "failed to get fd counter, ret = %d\n", 160703a92fe8SJian Shen ret); 160803a92fe8SJian Shen return ret; 160903a92fe8SJian Shen } 161003a92fe8SJian Shen cnt = le64_to_cpu(req->cnt); 161103a92fe8SJian Shen hclge_dbg_get_func_id_str(str_id, i); 161203a92fe8SJian Shen pos += scnprintf(buf + pos, len - pos, 161303a92fe8SJian Shen "%s\t%llu\n", str_id, cnt); 161403a92fe8SJian Shen } 161503a92fe8SJian Shen 161603a92fe8SJian Shen return 0; 161703a92fe8SJian Shen } 161803a92fe8SJian Shen 16191a7ff828SJiaran Zhang int hclge_dbg_dump_rst_info(struct hclge_dev *hdev, char *buf, int len) 1620f02eb82dSHuazhong Tan { 16211a7ff828SJiaran Zhang int pos = 0; 16221a7ff828SJiaran Zhang 16231a7ff828SJiaran Zhang pos += scnprintf(buf + pos, len - pos, "PF reset count: %u\n", 1624f02eb82dSHuazhong Tan hdev->rst_stats.pf_rst_cnt); 16251a7ff828SJiaran Zhang pos += scnprintf(buf + pos, len - pos, "FLR reset count: %u\n", 1626f02eb82dSHuazhong Tan hdev->rst_stats.flr_rst_cnt); 16271a7ff828SJiaran Zhang pos += scnprintf(buf + pos, len - pos, "GLOBAL reset count: %u\n", 1628f02eb82dSHuazhong Tan hdev->rst_stats.global_rst_cnt); 16291a7ff828SJiaran Zhang pos += scnprintf(buf + pos, len - pos, "IMP reset count: %u\n", 1630f02eb82dSHuazhong Tan hdev->rst_stats.imp_rst_cnt); 16311a7ff828SJiaran Zhang pos += scnprintf(buf + pos, len - pos, "reset done count: %u\n", 1632f02eb82dSHuazhong Tan hdev->rst_stats.reset_done_cnt); 16331a7ff828SJiaran Zhang pos += scnprintf(buf + pos, len - pos, "HW reset done count: %u\n", 1634f02eb82dSHuazhong Tan hdev->rst_stats.hw_reset_done_cnt); 16351a7ff828SJiaran Zhang pos += scnprintf(buf + pos, len - pos, "reset count: %u\n", 1636f02eb82dSHuazhong Tan hdev->rst_stats.reset_cnt); 16371a7ff828SJiaran Zhang pos += scnprintf(buf + pos, len - pos, "reset fail count: %u\n", 16380ecf1f7bSHuazhong Tan hdev->rst_stats.reset_fail_cnt); 16391a7ff828SJiaran Zhang pos += scnprintf(buf + pos, len - pos, 16401a7ff828SJiaran Zhang "vector0 interrupt enable status: 0x%x\n", 16410ecf1f7bSHuazhong Tan hclge_read_dev(&hdev->hw, HCLGE_MISC_VECTOR_REG_BASE)); 16421a7ff828SJiaran Zhang pos += scnprintf(buf + pos, len - pos, "reset interrupt source: 0x%x\n", 16430ecf1f7bSHuazhong Tan hclge_read_dev(&hdev->hw, HCLGE_MISC_RESET_STS_REG)); 16441a7ff828SJiaran Zhang pos += scnprintf(buf + pos, len - pos, "reset interrupt status: 0x%x\n", 16450ecf1f7bSHuazhong Tan hclge_read_dev(&hdev->hw, HCLGE_MISC_VECTOR_INT_STS)); 16461a7ff828SJiaran Zhang pos += scnprintf(buf + pos, len - pos, "RAS interrupt status: 0x%x\n", 16471a7ff828SJiaran Zhang hclge_read_dev(&hdev->hw, 16481a7ff828SJiaran Zhang HCLGE_RAS_PF_OTHER_INT_STS_REG)); 16491a7ff828SJiaran Zhang pos += scnprintf(buf + pos, len - pos, "hardware reset status: 0x%x\n", 16500ecf1f7bSHuazhong Tan hclge_read_dev(&hdev->hw, HCLGE_GLOBAL_RESET_REG)); 16511a7ff828SJiaran Zhang pos += scnprintf(buf + pos, len - pos, "handshake status: 0x%x\n", 16520ecf1f7bSHuazhong Tan hclge_read_dev(&hdev->hw, HCLGE_NIC_CSQ_DEPTH_REG)); 16531a7ff828SJiaran Zhang pos += scnprintf(buf + pos, len - pos, "function reset status: 0x%x\n", 16540ecf1f7bSHuazhong Tan hclge_read_dev(&hdev->hw, HCLGE_FUN_RST_ING)); 16551a7ff828SJiaran Zhang pos += scnprintf(buf + pos, len - pos, "hdev state: 0x%lx\n", 16561a7ff828SJiaran Zhang hdev->state); 16571a7ff828SJiaran Zhang 16581a7ff828SJiaran Zhang return 0; 1659f02eb82dSHuazhong Tan } 1660f02eb82dSHuazhong Tan 1661058c3be9SYufeng Mo static int hclge_dbg_dump_serv_info(struct hclge_dev *hdev, char *buf, int len) 16621c6dfe6fSYunsheng Lin { 1663058c3be9SYufeng Mo unsigned long rem_nsec; 1664058c3be9SYufeng Mo int pos = 0; 1665058c3be9SYufeng Mo u64 lc; 1666058c3be9SYufeng Mo 1667058c3be9SYufeng Mo lc = local_clock(); 1668058c3be9SYufeng Mo rem_nsec = do_div(lc, HCLGE_BILLION_NANO_SECONDS); 1669058c3be9SYufeng Mo 1670058c3be9SYufeng Mo pos += scnprintf(buf + pos, len - pos, "local_clock: [%5lu.%06lu]\n", 1671058c3be9SYufeng Mo (unsigned long)lc, rem_nsec / 1000); 1672058c3be9SYufeng Mo pos += scnprintf(buf + pos, len - pos, "delta: %u(ms)\n", 1673058c3be9SYufeng Mo jiffies_to_msecs(jiffies - hdev->last_serv_processed)); 1674058c3be9SYufeng Mo pos += scnprintf(buf + pos, len - pos, 1675058c3be9SYufeng Mo "last_service_task_processed: %lu(jiffies)\n", 16761c6dfe6fSYunsheng Lin hdev->last_serv_processed); 1677058c3be9SYufeng Mo pos += scnprintf(buf + pos, len - pos, "last_service_task_cnt: %lu\n", 16781c6dfe6fSYunsheng Lin hdev->serv_processed_cnt); 1679058c3be9SYufeng Mo 1680058c3be9SYufeng Mo return 0; 16811c6dfe6fSYunsheng Lin } 16821c6dfe6fSYunsheng Lin 16839149ca0fSJiaran Zhang static int hclge_dbg_dump_interrupt(struct hclge_dev *hdev, char *buf, int len) 1684348775ebSYufeng Mo { 16859149ca0fSJiaran Zhang int pos = 0; 16869149ca0fSJiaran Zhang 16879149ca0fSJiaran Zhang pos += scnprintf(buf + pos, len - pos, "num_nic_msi: %u\n", 16889149ca0fSJiaran Zhang hdev->num_nic_msi); 16899149ca0fSJiaran Zhang pos += scnprintf(buf + pos, len - pos, "num_roce_msi: %u\n", 16909149ca0fSJiaran Zhang hdev->num_roce_msi); 16919149ca0fSJiaran Zhang pos += scnprintf(buf + pos, len - pos, "num_msi_used: %u\n", 16929149ca0fSJiaran Zhang hdev->num_msi_used); 16939149ca0fSJiaran Zhang pos += scnprintf(buf + pos, len - pos, "num_msi_left: %u\n", 16949149ca0fSJiaran Zhang hdev->num_msi_left); 16959149ca0fSJiaran Zhang 16969149ca0fSJiaran Zhang return 0; 1697348775ebSYufeng Mo } 1698348775ebSYufeng Mo 16990b198b0dSJiaran Zhang static void hclge_dbg_imp_info_data_print(struct hclge_desc *desc_src, 17000b198b0dSJiaran Zhang char *buf, int len, u32 bd_num) 170133a90e2fSZhongzhu Liu { 17020b198b0dSJiaran Zhang #define HCLGE_DBG_IMP_INFO_PRINT_OFFSET 0x2 17030b198b0dSJiaran Zhang 17040b198b0dSJiaran Zhang struct hclge_desc *desc_index = desc_src; 17050b198b0dSJiaran Zhang u32 offset = 0; 17060b198b0dSJiaran Zhang int pos = 0; 17070b198b0dSJiaran Zhang u32 i, j; 17080b198b0dSJiaran Zhang 17090b198b0dSJiaran Zhang pos += scnprintf(buf + pos, len - pos, "offset | data\n"); 17100b198b0dSJiaran Zhang 17110b198b0dSJiaran Zhang for (i = 0; i < bd_num; i++) { 17120b198b0dSJiaran Zhang j = 0; 17130b198b0dSJiaran Zhang while (j < HCLGE_DESC_DATA_LEN - 1) { 17140b198b0dSJiaran Zhang pos += scnprintf(buf + pos, len - pos, "0x%04x | ", 17150b198b0dSJiaran Zhang offset); 17160b198b0dSJiaran Zhang pos += scnprintf(buf + pos, len - pos, "0x%08x ", 17170b198b0dSJiaran Zhang le32_to_cpu(desc_index->data[j++])); 17180b198b0dSJiaran Zhang pos += scnprintf(buf + pos, len - pos, "0x%08x\n", 17190b198b0dSJiaran Zhang le32_to_cpu(desc_index->data[j++])); 17200b198b0dSJiaran Zhang offset += sizeof(u32) * HCLGE_DBG_IMP_INFO_PRINT_OFFSET; 17210b198b0dSJiaran Zhang } 17220b198b0dSJiaran Zhang desc_index++; 17230b198b0dSJiaran Zhang } 17240b198b0dSJiaran Zhang } 17250b198b0dSJiaran Zhang 17260b198b0dSJiaran Zhang static int 17270b198b0dSJiaran Zhang hclge_dbg_get_imp_stats_info(struct hclge_dev *hdev, char *buf, int len) 17280b198b0dSJiaran Zhang { 17290b198b0dSJiaran Zhang struct hclge_get_imp_bd_cmd *req; 17300b198b0dSJiaran Zhang struct hclge_desc *desc_src; 173133a90e2fSZhongzhu Liu struct hclge_desc desc; 17320b198b0dSJiaran Zhang u32 bd_num; 17330b198b0dSJiaran Zhang int ret; 173433a90e2fSZhongzhu Liu 17350b198b0dSJiaran Zhang hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_IMP_STATS_BD, true); 173633a90e2fSZhongzhu Liu 17370b198b0dSJiaran Zhang req = (struct hclge_get_imp_bd_cmd *)desc.data; 173833a90e2fSZhongzhu Liu ret = hclge_cmd_send(&hdev->hw, &desc, 1); 173933a90e2fSZhongzhu Liu if (ret) { 174033a90e2fSZhongzhu Liu dev_err(&hdev->pdev->dev, 17410b198b0dSJiaran Zhang "failed to get imp statistics bd number, ret = %d\n", 174233a90e2fSZhongzhu Liu ret); 17430b198b0dSJiaran Zhang return ret; 174433a90e2fSZhongzhu Liu } 174533a90e2fSZhongzhu Liu 174633a90e2fSZhongzhu Liu bd_num = le32_to_cpu(req->bd_num); 1747472430a7SJiaran Zhang if (!bd_num) { 1748472430a7SJiaran Zhang dev_err(&hdev->pdev->dev, "imp statistics bd number is 0!\n"); 1749472430a7SJiaran Zhang return -EINVAL; 1750472430a7SJiaran Zhang } 175133a90e2fSZhongzhu Liu 17520b198b0dSJiaran Zhang desc_src = kcalloc(bd_num, sizeof(struct hclge_desc), GFP_KERNEL); 1753fbdc4d79SYufeng Mo if (!desc_src) 17540b198b0dSJiaran Zhang return -ENOMEM; 175533a90e2fSZhongzhu Liu 17560b198b0dSJiaran Zhang ret = hclge_dbg_cmd_send(hdev, desc_src, 0, bd_num, 17570b198b0dSJiaran Zhang HCLGE_OPC_IMP_STATS_INFO); 175833a90e2fSZhongzhu Liu if (ret) { 175933a90e2fSZhongzhu Liu kfree(desc_src); 176033a90e2fSZhongzhu Liu dev_err(&hdev->pdev->dev, 17610b198b0dSJiaran Zhang "failed to get imp statistics, ret = %d\n", ret); 17620b198b0dSJiaran Zhang return ret; 176333a90e2fSZhongzhu Liu } 176433a90e2fSZhongzhu Liu 17650b198b0dSJiaran Zhang hclge_dbg_imp_info_data_print(desc_src, buf, len, bd_num); 176633a90e2fSZhongzhu Liu 176733a90e2fSZhongzhu Liu kfree(desc_src); 17680b198b0dSJiaran Zhang 17690b198b0dSJiaran Zhang return 0; 177033a90e2fSZhongzhu Liu } 177133a90e2fSZhongzhu Liu 1772dec84660SYufeng Mo #define HCLGE_CMD_NCL_CONFIG_BD_NUM 5 1773e76e6886SJiaran Zhang #define HCLGE_MAX_NCL_CONFIG_LENGTH 16384 1774dec84660SYufeng Mo 1775e76e6886SJiaran Zhang static void hclge_ncl_config_data_print(struct hclge_desc *desc, int *index, 1776e76e6886SJiaran Zhang char *buf, int *len, int *pos) 1777dec84660SYufeng Mo { 1778dec84660SYufeng Mo #define HCLGE_CMD_DATA_NUM 6 1779dec84660SYufeng Mo 1780e76e6886SJiaran Zhang int offset = HCLGE_MAX_NCL_CONFIG_LENGTH - *index; 1781e76e6886SJiaran Zhang int i, j; 1782dec84660SYufeng Mo 1783dec84660SYufeng Mo for (i = 0; i < HCLGE_CMD_NCL_CONFIG_BD_NUM; i++) { 1784dec84660SYufeng Mo for (j = 0; j < HCLGE_CMD_DATA_NUM; j++) { 1785dec84660SYufeng Mo if (i == 0 && j == 0) 1786dec84660SYufeng Mo continue; 1787dec84660SYufeng Mo 1788e76e6886SJiaran Zhang *pos += scnprintf(buf + *pos, *len - *pos, 1789e76e6886SJiaran Zhang "0x%04x | 0x%08x\n", offset, 1790dec84660SYufeng Mo le32_to_cpu(desc[i].data[j])); 1791e76e6886SJiaran Zhang 1792e76e6886SJiaran Zhang offset += sizeof(u32); 1793e76e6886SJiaran Zhang *index -= sizeof(u32); 1794e76e6886SJiaran Zhang 1795e76e6886SJiaran Zhang if (*index <= 0) 1796dec84660SYufeng Mo return; 1797dec84660SYufeng Mo } 1798dec84660SYufeng Mo } 1799dec84660SYufeng Mo } 1800dec84660SYufeng Mo 1801e76e6886SJiaran Zhang static int 1802e76e6886SJiaran Zhang hclge_dbg_dump_ncl_config(struct hclge_dev *hdev, char *buf, int len) 1803ffd140e2SWeihang Li { 18044960cabfSYufeng Mo #define HCLGE_NCL_CONFIG_LENGTH_IN_EACH_CMD (20 + 24 * 4) 1805ffd140e2SWeihang Li 1806dec84660SYufeng Mo struct hclge_desc desc[HCLGE_CMD_NCL_CONFIG_BD_NUM]; 1807dec84660SYufeng Mo int bd_num = HCLGE_CMD_NCL_CONFIG_BD_NUM; 1808e76e6886SJiaran Zhang int index = HCLGE_MAX_NCL_CONFIG_LENGTH; 1809e76e6886SJiaran Zhang int pos = 0; 1810e76e6886SJiaran Zhang u32 data0; 1811ffd140e2SWeihang Li int ret; 1812ffd140e2SWeihang Li 1813e76e6886SJiaran Zhang pos += scnprintf(buf + pos, len - pos, "offset | data\n"); 1814b4401a04SYufeng Mo 1815e76e6886SJiaran Zhang while (index > 0) { 1816e76e6886SJiaran Zhang data0 = HCLGE_MAX_NCL_CONFIG_LENGTH - index; 1817e76e6886SJiaran Zhang if (index >= HCLGE_NCL_CONFIG_LENGTH_IN_EACH_CMD) 18184960cabfSYufeng Mo data0 |= HCLGE_NCL_CONFIG_LENGTH_IN_EACH_CMD << 16; 1819ffd140e2SWeihang Li else 1820e76e6886SJiaran Zhang data0 |= (u32)index << 16; 1821ffd140e2SWeihang Li ret = hclge_dbg_cmd_send(hdev, desc, data0, bd_num, 1822ffd140e2SWeihang Li HCLGE_OPC_QUERY_NCL_CONFIG); 1823ffd140e2SWeihang Li if (ret) 1824e76e6886SJiaran Zhang return ret; 1825ffd140e2SWeihang Li 1826e76e6886SJiaran Zhang hclge_ncl_config_data_print(desc, &index, buf, &len, &pos); 1827ffd140e2SWeihang Li } 1828e76e6886SJiaran Zhang 1829e76e6886SJiaran Zhang return 0; 1830ffd140e2SWeihang Li } 1831ffd140e2SWeihang Li 1832d658ff34SYufeng Mo static int hclge_dbg_dump_loopback(struct hclge_dev *hdev, char *buf, int len) 1833ded45d40SYufeng Mo { 1834ded45d40SYufeng Mo struct phy_device *phydev = hdev->hw.mac.phydev; 1835ded45d40SYufeng Mo struct hclge_config_mac_mode_cmd *req_app; 1836b47cfe1fSGuangbin Huang struct hclge_common_lb_cmd *req_common; 1837ded45d40SYufeng Mo struct hclge_desc desc; 1838ded45d40SYufeng Mo u8 loopback_en; 1839d658ff34SYufeng Mo int pos = 0; 1840ded45d40SYufeng Mo int ret; 1841ded45d40SYufeng Mo 1842ded45d40SYufeng Mo req_app = (struct hclge_config_mac_mode_cmd *)desc.data; 1843b47cfe1fSGuangbin Huang req_common = (struct hclge_common_lb_cmd *)desc.data; 1844ded45d40SYufeng Mo 1845d658ff34SYufeng Mo pos += scnprintf(buf + pos, len - pos, "mac id: %u\n", 1846d658ff34SYufeng Mo hdev->hw.mac.mac_id); 1847ded45d40SYufeng Mo 1848ded45d40SYufeng Mo hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_CONFIG_MAC_MODE, true); 1849ded45d40SYufeng Mo ret = hclge_cmd_send(&hdev->hw, &desc, 1); 1850ded45d40SYufeng Mo if (ret) { 1851ded45d40SYufeng Mo dev_err(&hdev->pdev->dev, 1852ded45d40SYufeng Mo "failed to dump app loopback status, ret = %d\n", ret); 1853d658ff34SYufeng Mo return ret; 1854ded45d40SYufeng Mo } 1855ded45d40SYufeng Mo 1856ded45d40SYufeng Mo loopback_en = hnae3_get_bit(le32_to_cpu(req_app->txrx_pad_fcs_loop_en), 1857ded45d40SYufeng Mo HCLGE_MAC_APP_LP_B); 1858d658ff34SYufeng Mo pos += scnprintf(buf + pos, len - pos, "app loopback: %s\n", 1859d658ff34SYufeng Mo state_str[loopback_en]); 1860ded45d40SYufeng Mo 1861b47cfe1fSGuangbin Huang hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_COMMON_LOOPBACK, true); 1862ded45d40SYufeng Mo ret = hclge_cmd_send(&hdev->hw, &desc, 1); 1863ded45d40SYufeng Mo if (ret) { 1864ded45d40SYufeng Mo dev_err(&hdev->pdev->dev, 1865b47cfe1fSGuangbin Huang "failed to dump common loopback status, ret = %d\n", 1866ded45d40SYufeng Mo ret); 1867d658ff34SYufeng Mo return ret; 1868ded45d40SYufeng Mo } 1869ded45d40SYufeng Mo 1870b47cfe1fSGuangbin Huang loopback_en = req_common->enable & HCLGE_CMD_SERDES_SERIAL_INNER_LOOP_B; 1871d658ff34SYufeng Mo pos += scnprintf(buf + pos, len - pos, "serdes serial loopback: %s\n", 1872d658ff34SYufeng Mo state_str[loopback_en]); 1873ded45d40SYufeng Mo 1874b47cfe1fSGuangbin Huang loopback_en = req_common->enable & 1875d658ff34SYufeng Mo HCLGE_CMD_SERDES_PARALLEL_INNER_LOOP_B ? 1 : 0; 1876d658ff34SYufeng Mo pos += scnprintf(buf + pos, len - pos, "serdes parallel loopback: %s\n", 1877d658ff34SYufeng Mo state_str[loopback_en]); 1878ded45d40SYufeng Mo 1879b47cfe1fSGuangbin Huang if (phydev) { 1880d658ff34SYufeng Mo loopback_en = phydev->loopback_enabled; 1881d658ff34SYufeng Mo pos += scnprintf(buf + pos, len - pos, "phy loopback: %s\n", 1882d658ff34SYufeng Mo state_str[loopback_en]); 1883b47cfe1fSGuangbin Huang } else if (hnae3_dev_phy_imp_supported(hdev)) { 1884b47cfe1fSGuangbin Huang loopback_en = req_common->enable & 1885b47cfe1fSGuangbin Huang HCLGE_CMD_GE_PHY_INNER_LOOP_B; 1886d658ff34SYufeng Mo pos += scnprintf(buf + pos, len - pos, "phy loopback: %s\n", 1887d658ff34SYufeng Mo state_str[loopback_en]); 1888b47cfe1fSGuangbin Huang } 1889d658ff34SYufeng Mo 1890d658ff34SYufeng Mo return 0; 1891ded45d40SYufeng Mo } 1892ded45d40SYufeng Mo 1893a6345787SWeihang Li /* hclge_dbg_dump_mac_tnl_status: print message about mac tnl interrupt 1894a6345787SWeihang Li * @hdev: pointer to struct hclge_dev 1895a6345787SWeihang Li */ 18967b07ab06SJiaran Zhang static int 18977b07ab06SJiaran Zhang hclge_dbg_dump_mac_tnl_status(struct hclge_dev *hdev, char *buf, int len) 1898a6345787SWeihang Li { 1899a6345787SWeihang Li struct hclge_mac_tnl_stats stats; 1900a6345787SWeihang Li unsigned long rem_nsec; 19017b07ab06SJiaran Zhang int pos = 0; 1902a6345787SWeihang Li 19037b07ab06SJiaran Zhang pos += scnprintf(buf + pos, len - pos, 19047b07ab06SJiaran Zhang "Recently generated mac tnl interruption:\n"); 1905a6345787SWeihang Li 1906a6345787SWeihang Li while (kfifo_get(&hdev->mac_tnl_log, &stats)) { 1907a6345787SWeihang Li rem_nsec = do_div(stats.time, HCLGE_BILLION_NANO_SECONDS); 19087b07ab06SJiaran Zhang 19097b07ab06SJiaran Zhang pos += scnprintf(buf + pos, len - pos, 19107b07ab06SJiaran Zhang "[%07lu.%03lu] status = 0x%x\n", 1911a6345787SWeihang Li (unsigned long)stats.time, rem_nsec / 1000, 1912a6345787SWeihang Li stats.status); 1913a6345787SWeihang Li } 19147b07ab06SJiaran Zhang 19157b07ab06SJiaran Zhang return 0; 1916a6345787SWeihang Li } 1917a6345787SWeihang Li 1918ee9e4424SYonglong Liu 19191556ea91SHuazhong Tan static const struct hclge_dbg_item mac_list_items[] = { 19201556ea91SHuazhong Tan { "FUNC_ID", 2 }, 19211556ea91SHuazhong Tan { "MAC_ADDR", 12 }, 19221556ea91SHuazhong Tan { "STATE", 2 }, 19231556ea91SHuazhong Tan }; 19241556ea91SHuazhong Tan 19251556ea91SHuazhong Tan static void hclge_dbg_dump_mac_list(struct hclge_dev *hdev, char *buf, int len, 1926f671237aSJian Shen bool is_unicast) 1927f671237aSJian Shen { 19281556ea91SHuazhong Tan char data_str[ARRAY_SIZE(mac_list_items)][HCLGE_DBG_DATA_STR_LEN]; 19291556ea91SHuazhong Tan char content[HCLGE_DBG_INFO_LEN], str_id[HCLGE_DBG_ID_LEN]; 19301556ea91SHuazhong Tan char *result[ARRAY_SIZE(mac_list_items)]; 1931f671237aSJian Shen struct hclge_mac_node *mac_node, *tmp; 1932f671237aSJian Shen struct hclge_vport *vport; 1933f671237aSJian Shen struct list_head *list; 1934f671237aSJian Shen u32 func_id; 19351556ea91SHuazhong Tan int pos = 0; 19361556ea91SHuazhong Tan int i; 1937f671237aSJian Shen 19381556ea91SHuazhong Tan for (i = 0; i < ARRAY_SIZE(mac_list_items); i++) 19391556ea91SHuazhong Tan result[i] = &data_str[i][0]; 1940f671237aSJian Shen 19411556ea91SHuazhong Tan pos += scnprintf(buf + pos, len - pos, "%s MAC_LIST:\n", 19421556ea91SHuazhong Tan is_unicast ? "UC" : "MC"); 19431556ea91SHuazhong Tan hclge_dbg_fill_content(content, sizeof(content), mac_list_items, 19441556ea91SHuazhong Tan NULL, ARRAY_SIZE(mac_list_items)); 19451556ea91SHuazhong Tan pos += scnprintf(buf + pos, len - pos, "%s", content); 1946f671237aSJian Shen 19471556ea91SHuazhong Tan for (func_id = 0; func_id < hdev->num_alloc_vport; func_id++) { 1948f671237aSJian Shen vport = &hdev->vport[func_id]; 1949f671237aSJian Shen list = is_unicast ? &vport->uc_mac_list : &vport->mc_mac_list; 1950f671237aSJian Shen spin_lock_bh(&vport->mac_list_lock); 1951f671237aSJian Shen list_for_each_entry_safe(mac_node, tmp, list, node) { 19521556ea91SHuazhong Tan i = 0; 19531556ea91SHuazhong Tan result[i++] = hclge_dbg_get_func_id_str(str_id, 19541556ea91SHuazhong Tan func_id); 19551556ea91SHuazhong Tan sprintf(result[i++], "%pM", mac_node->mac_addr); 19561556ea91SHuazhong Tan sprintf(result[i++], "%5s", 19571556ea91SHuazhong Tan hclge_mac_state_str[mac_node->state]); 19581556ea91SHuazhong Tan hclge_dbg_fill_content(content, sizeof(content), 19591556ea91SHuazhong Tan mac_list_items, 19601556ea91SHuazhong Tan (const char **)result, 19611556ea91SHuazhong Tan ARRAY_SIZE(mac_list_items)); 19621556ea91SHuazhong Tan pos += scnprintf(buf + pos, len - pos, "%s", content); 19631556ea91SHuazhong Tan } 19641556ea91SHuazhong Tan spin_unlock_bh(&vport->mac_list_lock); 19651556ea91SHuazhong Tan } 1966f671237aSJian Shen } 1967f671237aSJian Shen 1968d59daf6aSJian Shen static int hclge_dbg_dump_umv_info(struct hclge_dev *hdev, char *buf, int len) 1969d59daf6aSJian Shen { 1970d59daf6aSJian Shen u8 func_num = pci_num_vf(hdev->pdev) + 1; 1971d59daf6aSJian Shen struct hclge_vport *vport; 1972d59daf6aSJian Shen int pos = 0; 1973d59daf6aSJian Shen u8 i; 1974d59daf6aSJian Shen 1975d59daf6aSJian Shen pos += scnprintf(buf, len, "num_alloc_vport : %u\n", 1976d59daf6aSJian Shen hdev->num_alloc_vport); 1977d59daf6aSJian Shen pos += scnprintf(buf + pos, len - pos, "max_umv_size : %u\n", 1978d59daf6aSJian Shen hdev->max_umv_size); 1979d59daf6aSJian Shen pos += scnprintf(buf + pos, len - pos, "wanted_umv_size : %u\n", 1980d59daf6aSJian Shen hdev->wanted_umv_size); 1981d59daf6aSJian Shen pos += scnprintf(buf + pos, len - pos, "priv_umv_size : %u\n", 1982d59daf6aSJian Shen hdev->priv_umv_size); 1983d59daf6aSJian Shen 1984d59daf6aSJian Shen mutex_lock(&hdev->vport_lock); 1985d59daf6aSJian Shen pos += scnprintf(buf + pos, len - pos, "share_umv_size : %u\n", 1986d59daf6aSJian Shen hdev->share_umv_size); 1987d59daf6aSJian Shen for (i = 0; i < func_num; i++) { 1988d59daf6aSJian Shen vport = &hdev->vport[i]; 1989d59daf6aSJian Shen pos += scnprintf(buf + pos, len - pos, 1990d59daf6aSJian Shen "vport(%u) used_umv_num : %u\n", 1991d59daf6aSJian Shen i, vport->used_umv_num); 1992d59daf6aSJian Shen } 1993d59daf6aSJian Shen mutex_unlock(&hdev->vport_lock); 1994d59daf6aSJian Shen 1995d59daf6aSJian Shen return 0; 1996d59daf6aSJian Shen } 1997d59daf6aSJian Shen 19980ca821daSJian Shen static int hclge_get_vlan_rx_offload_cfg(struct hclge_dev *hdev, u8 vf_id, 19990ca821daSJian Shen struct hclge_dbg_vlan_cfg *vlan_cfg) 20000ca821daSJian Shen { 20010ca821daSJian Shen struct hclge_vport_vtag_rx_cfg_cmd *req; 20020ca821daSJian Shen struct hclge_desc desc; 20030ca821daSJian Shen u16 bmap_index; 20040ca821daSJian Shen u8 rx_cfg; 20050ca821daSJian Shen int ret; 20060ca821daSJian Shen 20070ca821daSJian Shen hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_VLAN_PORT_RX_CFG, true); 20080ca821daSJian Shen 20090ca821daSJian Shen req = (struct hclge_vport_vtag_rx_cfg_cmd *)desc.data; 20100ca821daSJian Shen req->vf_offset = vf_id / HCLGE_VF_NUM_PER_CMD; 20110ca821daSJian Shen bmap_index = vf_id % HCLGE_VF_NUM_PER_CMD / HCLGE_VF_NUM_PER_BYTE; 20120ca821daSJian Shen req->vf_bitmap[bmap_index] = 1U << (vf_id % HCLGE_VF_NUM_PER_BYTE); 20130ca821daSJian Shen 20140ca821daSJian Shen ret = hclge_cmd_send(&hdev->hw, &desc, 1); 20150ca821daSJian Shen if (ret) { 20160ca821daSJian Shen dev_err(&hdev->pdev->dev, 20170ca821daSJian Shen "failed to get vport%u rxvlan cfg, ret = %d\n", 20180ca821daSJian Shen vf_id, ret); 20190ca821daSJian Shen return ret; 20200ca821daSJian Shen } 20210ca821daSJian Shen 20220ca821daSJian Shen rx_cfg = req->vport_vlan_cfg; 20230ca821daSJian Shen vlan_cfg->strip_tag1 = hnae3_get_bit(rx_cfg, HCLGE_REM_TAG1_EN_B); 20240ca821daSJian Shen vlan_cfg->strip_tag2 = hnae3_get_bit(rx_cfg, HCLGE_REM_TAG2_EN_B); 20250ca821daSJian Shen vlan_cfg->drop_tag1 = hnae3_get_bit(rx_cfg, HCLGE_DISCARD_TAG1_EN_B); 20260ca821daSJian Shen vlan_cfg->drop_tag2 = hnae3_get_bit(rx_cfg, HCLGE_DISCARD_TAG2_EN_B); 20270ca821daSJian Shen vlan_cfg->pri_only1 = hnae3_get_bit(rx_cfg, HCLGE_SHOW_TAG1_EN_B); 20280ca821daSJian Shen vlan_cfg->pri_only2 = hnae3_get_bit(rx_cfg, HCLGE_SHOW_TAG2_EN_B); 20290ca821daSJian Shen 20300ca821daSJian Shen return 0; 20310ca821daSJian Shen } 20320ca821daSJian Shen 20330ca821daSJian Shen static int hclge_get_vlan_tx_offload_cfg(struct hclge_dev *hdev, u8 vf_id, 20340ca821daSJian Shen struct hclge_dbg_vlan_cfg *vlan_cfg) 20350ca821daSJian Shen { 20360ca821daSJian Shen struct hclge_vport_vtag_tx_cfg_cmd *req; 20370ca821daSJian Shen struct hclge_desc desc; 20380ca821daSJian Shen u16 bmap_index; 20390ca821daSJian Shen u8 tx_cfg; 20400ca821daSJian Shen int ret; 20410ca821daSJian Shen 20420ca821daSJian Shen hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_VLAN_PORT_TX_CFG, true); 20430ca821daSJian Shen req = (struct hclge_vport_vtag_tx_cfg_cmd *)desc.data; 20440ca821daSJian Shen req->vf_offset = vf_id / HCLGE_VF_NUM_PER_CMD; 20450ca821daSJian Shen bmap_index = vf_id % HCLGE_VF_NUM_PER_CMD / HCLGE_VF_NUM_PER_BYTE; 20460ca821daSJian Shen req->vf_bitmap[bmap_index] = 1U << (vf_id % HCLGE_VF_NUM_PER_BYTE); 20470ca821daSJian Shen 20480ca821daSJian Shen ret = hclge_cmd_send(&hdev->hw, &desc, 1); 20490ca821daSJian Shen if (ret) { 20500ca821daSJian Shen dev_err(&hdev->pdev->dev, 20510ca821daSJian Shen "failed to get vport%u txvlan cfg, ret = %d\n", 20520ca821daSJian Shen vf_id, ret); 20530ca821daSJian Shen return ret; 20540ca821daSJian Shen } 20550ca821daSJian Shen 20560ca821daSJian Shen tx_cfg = req->vport_vlan_cfg; 20570ca821daSJian Shen vlan_cfg->pvid = le16_to_cpu(req->def_vlan_tag1); 20580ca821daSJian Shen 20590ca821daSJian Shen vlan_cfg->accept_tag1 = hnae3_get_bit(tx_cfg, HCLGE_ACCEPT_TAG1_B); 20600ca821daSJian Shen vlan_cfg->accept_tag2 = hnae3_get_bit(tx_cfg, HCLGE_ACCEPT_TAG2_B); 20610ca821daSJian Shen vlan_cfg->accept_untag1 = hnae3_get_bit(tx_cfg, HCLGE_ACCEPT_UNTAG1_B); 20620ca821daSJian Shen vlan_cfg->accept_untag2 = hnae3_get_bit(tx_cfg, HCLGE_ACCEPT_UNTAG2_B); 20630ca821daSJian Shen vlan_cfg->insert_tag1 = hnae3_get_bit(tx_cfg, HCLGE_PORT_INS_TAG1_EN_B); 20640ca821daSJian Shen vlan_cfg->insert_tag2 = hnae3_get_bit(tx_cfg, HCLGE_PORT_INS_TAG2_EN_B); 20650ca821daSJian Shen vlan_cfg->shift_tag = hnae3_get_bit(tx_cfg, HCLGE_TAG_SHIFT_MODE_EN_B); 20660ca821daSJian Shen 20670ca821daSJian Shen return 0; 20680ca821daSJian Shen } 20690ca821daSJian Shen 20700ca821daSJian Shen static int hclge_get_vlan_filter_config_cmd(struct hclge_dev *hdev, 20710ca821daSJian Shen u8 vlan_type, u8 vf_id, 20720ca821daSJian Shen struct hclge_desc *desc) 20730ca821daSJian Shen { 20740ca821daSJian Shen struct hclge_vlan_filter_ctrl_cmd *req; 20750ca821daSJian Shen int ret; 20760ca821daSJian Shen 20770ca821daSJian Shen hclge_cmd_setup_basic_desc(desc, HCLGE_OPC_VLAN_FILTER_CTRL, true); 20780ca821daSJian Shen req = (struct hclge_vlan_filter_ctrl_cmd *)desc->data; 20790ca821daSJian Shen req->vlan_type = vlan_type; 20800ca821daSJian Shen req->vf_id = vf_id; 20810ca821daSJian Shen 20820ca821daSJian Shen ret = hclge_cmd_send(&hdev->hw, desc, 1); 20830ca821daSJian Shen if (ret) 20840ca821daSJian Shen dev_err(&hdev->pdev->dev, 20850ca821daSJian Shen "failed to get vport%u vlan filter config, ret = %d.\n", 20860ca821daSJian Shen vf_id, ret); 20870ca821daSJian Shen 20880ca821daSJian Shen return ret; 20890ca821daSJian Shen } 20900ca821daSJian Shen 20910ca821daSJian Shen static int hclge_get_vlan_filter_state(struct hclge_dev *hdev, u8 vlan_type, 20920ca821daSJian Shen u8 vf_id, u8 *vlan_fe) 20930ca821daSJian Shen { 20940ca821daSJian Shen struct hclge_vlan_filter_ctrl_cmd *req; 20950ca821daSJian Shen struct hclge_desc desc; 20960ca821daSJian Shen int ret; 20970ca821daSJian Shen 20980ca821daSJian Shen ret = hclge_get_vlan_filter_config_cmd(hdev, vlan_type, vf_id, &desc); 20990ca821daSJian Shen if (ret) 21000ca821daSJian Shen return ret; 21010ca821daSJian Shen 21020ca821daSJian Shen req = (struct hclge_vlan_filter_ctrl_cmd *)desc.data; 21030ca821daSJian Shen *vlan_fe = req->vlan_fe; 21040ca821daSJian Shen 21050ca821daSJian Shen return 0; 21060ca821daSJian Shen } 21070ca821daSJian Shen 21080ca821daSJian Shen static int hclge_get_port_vlan_filter_bypass_state(struct hclge_dev *hdev, 21090ca821daSJian Shen u8 vf_id, u8 *bypass_en) 21100ca821daSJian Shen { 21110ca821daSJian Shen struct hclge_port_vlan_filter_bypass_cmd *req; 21120ca821daSJian Shen struct hclge_desc desc; 21130ca821daSJian Shen int ret; 21140ca821daSJian Shen 21150ca821daSJian Shen if (!test_bit(HNAE3_DEV_SUPPORT_PORT_VLAN_BYPASS_B, hdev->ae_dev->caps)) 21160ca821daSJian Shen return 0; 21170ca821daSJian Shen 21180ca821daSJian Shen hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_PORT_VLAN_BYPASS, true); 21190ca821daSJian Shen req = (struct hclge_port_vlan_filter_bypass_cmd *)desc.data; 21200ca821daSJian Shen req->vf_id = vf_id; 21210ca821daSJian Shen 21220ca821daSJian Shen ret = hclge_cmd_send(&hdev->hw, &desc, 1); 21230ca821daSJian Shen if (ret) { 21240ca821daSJian Shen dev_err(&hdev->pdev->dev, 21250ca821daSJian Shen "failed to get vport%u port vlan filter bypass state, ret = %d.\n", 21260ca821daSJian Shen vf_id, ret); 21270ca821daSJian Shen return ret; 21280ca821daSJian Shen } 21290ca821daSJian Shen 21300ca821daSJian Shen *bypass_en = hnae3_get_bit(req->bypass_state, HCLGE_INGRESS_BYPASS_B); 21310ca821daSJian Shen 21320ca821daSJian Shen return 0; 21330ca821daSJian Shen } 21340ca821daSJian Shen 21350ca821daSJian Shen static const struct hclge_dbg_item vlan_filter_items[] = { 21360ca821daSJian Shen { "FUNC_ID", 2 }, 21370ca821daSJian Shen { "I_VF_VLAN_FILTER", 2 }, 21380ca821daSJian Shen { "E_VF_VLAN_FILTER", 2 }, 21390ca821daSJian Shen { "PORT_VLAN_FILTER_BYPASS", 0 } 21400ca821daSJian Shen }; 21410ca821daSJian Shen 21420ca821daSJian Shen static const struct hclge_dbg_item vlan_offload_items[] = { 21430ca821daSJian Shen { "FUNC_ID", 2 }, 21440ca821daSJian Shen { "PVID", 4 }, 21450ca821daSJian Shen { "ACCEPT_TAG1", 2 }, 21460ca821daSJian Shen { "ACCEPT_TAG2", 2 }, 21470ca821daSJian Shen { "ACCEPT_UNTAG1", 2 }, 21480ca821daSJian Shen { "ACCEPT_UNTAG2", 2 }, 21490ca821daSJian Shen { "INSERT_TAG1", 2 }, 21500ca821daSJian Shen { "INSERT_TAG2", 2 }, 21510ca821daSJian Shen { "SHIFT_TAG", 2 }, 21520ca821daSJian Shen { "STRIP_TAG1", 2 }, 21530ca821daSJian Shen { "STRIP_TAG2", 2 }, 21540ca821daSJian Shen { "DROP_TAG1", 2 }, 21550ca821daSJian Shen { "DROP_TAG2", 2 }, 21560ca821daSJian Shen { "PRI_ONLY_TAG1", 2 }, 21570ca821daSJian Shen { "PRI_ONLY_TAG2", 0 } 21580ca821daSJian Shen }; 21590ca821daSJian Shen 21600ca821daSJian Shen static int hclge_dbg_dump_vlan_filter_config(struct hclge_dev *hdev, char *buf, 21610ca821daSJian Shen int len, int *pos) 21620ca821daSJian Shen { 21630ca821daSJian Shen char content[HCLGE_DBG_VLAN_FLTR_INFO_LEN], str_id[HCLGE_DBG_ID_LEN]; 21640ca821daSJian Shen const char *result[ARRAY_SIZE(vlan_filter_items)]; 21650ca821daSJian Shen u8 i, j, vlan_fe, bypass, ingress, egress; 21660ca821daSJian Shen u8 func_num = pci_num_vf(hdev->pdev) + 1; /* pf and enabled vf num */ 21670ca821daSJian Shen int ret; 21680ca821daSJian Shen 21690ca821daSJian Shen ret = hclge_get_vlan_filter_state(hdev, HCLGE_FILTER_TYPE_PORT, 0, 21700ca821daSJian Shen &vlan_fe); 21710ca821daSJian Shen if (ret) 21720ca821daSJian Shen return ret; 21730ca821daSJian Shen ingress = vlan_fe & HCLGE_FILTER_FE_NIC_INGRESS_B; 21740ca821daSJian Shen egress = vlan_fe & HCLGE_FILTER_FE_NIC_EGRESS_B ? 1 : 0; 21750ca821daSJian Shen 21760ca821daSJian Shen *pos += scnprintf(buf, len, "I_PORT_VLAN_FILTER: %s\n", 21770ca821daSJian Shen state_str[ingress]); 21780ca821daSJian Shen *pos += scnprintf(buf + *pos, len - *pos, "E_PORT_VLAN_FILTER: %s\n", 21790ca821daSJian Shen state_str[egress]); 21800ca821daSJian Shen 21810ca821daSJian Shen hclge_dbg_fill_content(content, sizeof(content), vlan_filter_items, 21820ca821daSJian Shen NULL, ARRAY_SIZE(vlan_filter_items)); 21830ca821daSJian Shen *pos += scnprintf(buf + *pos, len - *pos, "%s", content); 21840ca821daSJian Shen 21850ca821daSJian Shen for (i = 0; i < func_num; i++) { 21860ca821daSJian Shen ret = hclge_get_vlan_filter_state(hdev, HCLGE_FILTER_TYPE_VF, i, 21870ca821daSJian Shen &vlan_fe); 21880ca821daSJian Shen if (ret) 21890ca821daSJian Shen return ret; 21900ca821daSJian Shen 21910ca821daSJian Shen ingress = vlan_fe & HCLGE_FILTER_FE_NIC_INGRESS_B; 21920ca821daSJian Shen egress = vlan_fe & HCLGE_FILTER_FE_NIC_EGRESS_B ? 1 : 0; 21930ca821daSJian Shen ret = hclge_get_port_vlan_filter_bypass_state(hdev, i, &bypass); 21940ca821daSJian Shen if (ret) 21950ca821daSJian Shen return ret; 21960ca821daSJian Shen j = 0; 21970ca821daSJian Shen result[j++] = hclge_dbg_get_func_id_str(str_id, i); 21980ca821daSJian Shen result[j++] = state_str[ingress]; 21990ca821daSJian Shen result[j++] = state_str[egress]; 22000ca821daSJian Shen result[j++] = 22010ca821daSJian Shen test_bit(HNAE3_DEV_SUPPORT_PORT_VLAN_BYPASS_B, 22020ca821daSJian Shen hdev->ae_dev->caps) ? state_str[bypass] : "NA"; 22030ca821daSJian Shen hclge_dbg_fill_content(content, sizeof(content), 22040ca821daSJian Shen vlan_filter_items, result, 22050ca821daSJian Shen ARRAY_SIZE(vlan_filter_items)); 22060ca821daSJian Shen *pos += scnprintf(buf + *pos, len - *pos, "%s", content); 22070ca821daSJian Shen } 22080ca821daSJian Shen *pos += scnprintf(buf + *pos, len - *pos, "\n"); 22090ca821daSJian Shen 22100ca821daSJian Shen return 0; 22110ca821daSJian Shen } 22120ca821daSJian Shen 22130ca821daSJian Shen static int hclge_dbg_dump_vlan_offload_config(struct hclge_dev *hdev, char *buf, 22140ca821daSJian Shen int len, int *pos) 22150ca821daSJian Shen { 22160ca821daSJian Shen char str_id[HCLGE_DBG_ID_LEN], str_pvid[HCLGE_DBG_ID_LEN]; 22170ca821daSJian Shen const char *result[ARRAY_SIZE(vlan_offload_items)]; 22180ca821daSJian Shen char content[HCLGE_DBG_VLAN_OFFLOAD_INFO_LEN]; 22190ca821daSJian Shen u8 func_num = pci_num_vf(hdev->pdev) + 1; /* pf and enabled vf num */ 22200ca821daSJian Shen struct hclge_dbg_vlan_cfg vlan_cfg; 22210ca821daSJian Shen int ret; 22220ca821daSJian Shen u8 i, j; 22230ca821daSJian Shen 22240ca821daSJian Shen hclge_dbg_fill_content(content, sizeof(content), vlan_offload_items, 22250ca821daSJian Shen NULL, ARRAY_SIZE(vlan_offload_items)); 22260ca821daSJian Shen *pos += scnprintf(buf + *pos, len - *pos, "%s", content); 22270ca821daSJian Shen 22280ca821daSJian Shen for (i = 0; i < func_num; i++) { 22290ca821daSJian Shen ret = hclge_get_vlan_tx_offload_cfg(hdev, i, &vlan_cfg); 22300ca821daSJian Shen if (ret) 22310ca821daSJian Shen return ret; 22320ca821daSJian Shen 22330ca821daSJian Shen ret = hclge_get_vlan_rx_offload_cfg(hdev, i, &vlan_cfg); 22340ca821daSJian Shen if (ret) 22350ca821daSJian Shen return ret; 22360ca821daSJian Shen 22370ca821daSJian Shen sprintf(str_pvid, "%u", vlan_cfg.pvid); 22380ca821daSJian Shen j = 0; 22390ca821daSJian Shen result[j++] = hclge_dbg_get_func_id_str(str_id, i); 22400ca821daSJian Shen result[j++] = str_pvid; 22410ca821daSJian Shen result[j++] = state_str[vlan_cfg.accept_tag1]; 22420ca821daSJian Shen result[j++] = state_str[vlan_cfg.accept_tag2]; 22430ca821daSJian Shen result[j++] = state_str[vlan_cfg.accept_untag1]; 22440ca821daSJian Shen result[j++] = state_str[vlan_cfg.accept_untag2]; 22450ca821daSJian Shen result[j++] = state_str[vlan_cfg.insert_tag1]; 22460ca821daSJian Shen result[j++] = state_str[vlan_cfg.insert_tag2]; 22470ca821daSJian Shen result[j++] = state_str[vlan_cfg.shift_tag]; 22480ca821daSJian Shen result[j++] = state_str[vlan_cfg.strip_tag1]; 22490ca821daSJian Shen result[j++] = state_str[vlan_cfg.strip_tag2]; 22500ca821daSJian Shen result[j++] = state_str[vlan_cfg.drop_tag1]; 22510ca821daSJian Shen result[j++] = state_str[vlan_cfg.drop_tag2]; 22520ca821daSJian Shen result[j++] = state_str[vlan_cfg.pri_only1]; 22530ca821daSJian Shen result[j++] = state_str[vlan_cfg.pri_only2]; 22540ca821daSJian Shen 22550ca821daSJian Shen hclge_dbg_fill_content(content, sizeof(content), 22560ca821daSJian Shen vlan_offload_items, result, 22570ca821daSJian Shen ARRAY_SIZE(vlan_offload_items)); 22580ca821daSJian Shen *pos += scnprintf(buf + *pos, len - *pos, "%s", content); 22590ca821daSJian Shen } 22600ca821daSJian Shen 22610ca821daSJian Shen return 0; 22620ca821daSJian Shen } 22630ca821daSJian Shen 22640ca821daSJian Shen static int hclge_dbg_dump_vlan_config(struct hclge_dev *hdev, char *buf, 22650ca821daSJian Shen int len) 22660ca821daSJian Shen { 22670ca821daSJian Shen int pos = 0; 22680ca821daSJian Shen int ret; 22690ca821daSJian Shen 22700ca821daSJian Shen ret = hclge_dbg_dump_vlan_filter_config(hdev, buf, len, &pos); 22710ca821daSJian Shen if (ret) 22720ca821daSJian Shen return ret; 22730ca821daSJian Shen 22740ca821daSJian Shen return hclge_dbg_dump_vlan_offload_config(hdev, buf, len, &pos); 22750ca821daSJian Shen } 22760ca821daSJian Shen 2277b34c157fSHuazhong Tan static int hclge_dbg_dump_ptp_info(struct hclge_dev *hdev, char *buf, int len) 2278b34c157fSHuazhong Tan { 2279b34c157fSHuazhong Tan struct hclge_ptp *ptp = hdev->ptp; 2280b34c157fSHuazhong Tan u32 sw_cfg = ptp->ptp_cfg; 2281b34c157fSHuazhong Tan unsigned int tx_start; 2282b34c157fSHuazhong Tan unsigned int last_rx; 2283b34c157fSHuazhong Tan int pos = 0; 2284b34c157fSHuazhong Tan u32 hw_cfg; 2285b34c157fSHuazhong Tan int ret; 2286b34c157fSHuazhong Tan 2287b34c157fSHuazhong Tan pos += scnprintf(buf + pos, len - pos, "phc %s's debug info:\n", 2288b34c157fSHuazhong Tan ptp->info.name); 2289b34c157fSHuazhong Tan pos += scnprintf(buf + pos, len - pos, "ptp enable: %s\n", 2290b34c157fSHuazhong Tan test_bit(HCLGE_PTP_FLAG_EN, &ptp->flags) ? 2291b34c157fSHuazhong Tan "yes" : "no"); 2292b34c157fSHuazhong Tan pos += scnprintf(buf + pos, len - pos, "ptp tx enable: %s\n", 2293b34c157fSHuazhong Tan test_bit(HCLGE_PTP_FLAG_TX_EN, &ptp->flags) ? 2294b34c157fSHuazhong Tan "yes" : "no"); 2295b34c157fSHuazhong Tan pos += scnprintf(buf + pos, len - pos, "ptp rx enable: %s\n", 2296b34c157fSHuazhong Tan test_bit(HCLGE_PTP_FLAG_RX_EN, &ptp->flags) ? 2297b34c157fSHuazhong Tan "yes" : "no"); 2298b34c157fSHuazhong Tan 2299b34c157fSHuazhong Tan last_rx = jiffies_to_msecs(ptp->last_rx); 2300b34c157fSHuazhong Tan pos += scnprintf(buf + pos, len - pos, "last rx time: %lu.%lu\n", 2301b34c157fSHuazhong Tan last_rx / MSEC_PER_SEC, last_rx % MSEC_PER_SEC); 2302b34c157fSHuazhong Tan pos += scnprintf(buf + pos, len - pos, "rx count: %lu\n", ptp->rx_cnt); 2303b34c157fSHuazhong Tan 2304b34c157fSHuazhong Tan tx_start = jiffies_to_msecs(ptp->tx_start); 2305b34c157fSHuazhong Tan pos += scnprintf(buf + pos, len - pos, "last tx start time: %lu.%lu\n", 2306b34c157fSHuazhong Tan tx_start / MSEC_PER_SEC, tx_start % MSEC_PER_SEC); 2307b34c157fSHuazhong Tan pos += scnprintf(buf + pos, len - pos, "tx count: %lu\n", ptp->tx_cnt); 2308b34c157fSHuazhong Tan pos += scnprintf(buf + pos, len - pos, "tx skipped count: %lu\n", 2309b34c157fSHuazhong Tan ptp->tx_skipped); 2310b34c157fSHuazhong Tan pos += scnprintf(buf + pos, len - pos, "tx timeout count: %lu\n", 2311b34c157fSHuazhong Tan ptp->tx_timeout); 2312b34c157fSHuazhong Tan pos += scnprintf(buf + pos, len - pos, "last tx seqid: %u\n", 2313b34c157fSHuazhong Tan ptp->last_tx_seqid); 2314b34c157fSHuazhong Tan 2315b34c157fSHuazhong Tan ret = hclge_ptp_cfg_qry(hdev, &hw_cfg); 2316b34c157fSHuazhong Tan if (ret) 2317b34c157fSHuazhong Tan return ret; 2318b34c157fSHuazhong Tan 2319b34c157fSHuazhong Tan pos += scnprintf(buf + pos, len - pos, "sw_cfg: %#x, hw_cfg: %#x\n", 2320b34c157fSHuazhong Tan sw_cfg, hw_cfg); 2321b34c157fSHuazhong Tan 2322b34c157fSHuazhong Tan pos += scnprintf(buf + pos, len - pos, "tx type: %d, rx filter: %d\n", 2323b34c157fSHuazhong Tan ptp->ts_cfg.tx_type, ptp->ts_cfg.rx_filter); 2324b34c157fSHuazhong Tan 2325b34c157fSHuazhong Tan return 0; 2326b34c157fSHuazhong Tan } 2327b34c157fSHuazhong Tan 23281556ea91SHuazhong Tan static int hclge_dbg_dump_mac_uc(struct hclge_dev *hdev, char *buf, int len) 23291556ea91SHuazhong Tan { 23301556ea91SHuazhong Tan hclge_dbg_dump_mac_list(hdev, buf, len, true); 23311556ea91SHuazhong Tan 23321556ea91SHuazhong Tan return 0; 23331556ea91SHuazhong Tan } 23341556ea91SHuazhong Tan 23351556ea91SHuazhong Tan static int hclge_dbg_dump_mac_mc(struct hclge_dev *hdev, char *buf, int len) 23361556ea91SHuazhong Tan { 23371556ea91SHuazhong Tan hclge_dbg_dump_mac_list(hdev, buf, len, false); 2338f671237aSJian Shen 2339f671237aSJian Shen return 0; 2340f671237aSJian Shen } 2341f671237aSJian Shen 23425e69ea7eSYufeng Mo static const struct hclge_dbg_func hclge_dbg_cmd_func[] = { 23435e69ea7eSYufeng Mo { 23445e69ea7eSYufeng Mo .cmd = HNAE3_DBG_CMD_TM_NODES, 23455e69ea7eSYufeng Mo .dbg_dump = hclge_dbg_dump_tm_nodes, 23465e69ea7eSYufeng Mo }, 23475e69ea7eSYufeng Mo { 23485e69ea7eSYufeng Mo .cmd = HNAE3_DBG_CMD_TM_PRI, 23495e69ea7eSYufeng Mo .dbg_dump = hclge_dbg_dump_tm_pri, 23505e69ea7eSYufeng Mo }, 23515e69ea7eSYufeng Mo { 23525e69ea7eSYufeng Mo .cmd = HNAE3_DBG_CMD_TM_QSET, 23535e69ea7eSYufeng Mo .dbg_dump = hclge_dbg_dump_tm_qset, 23545e69ea7eSYufeng Mo }, 23551556ea91SHuazhong Tan { 23567679f28eSGuangbin Huang .cmd = HNAE3_DBG_CMD_TM_MAP, 23577679f28eSGuangbin Huang .dbg_dump = hclge_dbg_dump_tm_map, 23587679f28eSGuangbin Huang }, 23597679f28eSGuangbin Huang { 2360cad7c215SGuangbin Huang .cmd = HNAE3_DBG_CMD_TM_PG, 2361cad7c215SGuangbin Huang .dbg_dump = hclge_dbg_dump_tm_pg, 2362cad7c215SGuangbin Huang }, 2363cad7c215SGuangbin Huang { 2364cad7c215SGuangbin Huang .cmd = HNAE3_DBG_CMD_TM_PORT, 2365cad7c215SGuangbin Huang .dbg_dump = hclge_dbg_dump_tm_port, 2366cad7c215SGuangbin Huang }, 2367cad7c215SGuangbin Huang { 23680e32038dSGuangbin Huang .cmd = HNAE3_DBG_CMD_TC_SCH_INFO, 23690e32038dSGuangbin Huang .dbg_dump = hclge_dbg_dump_tc, 23700e32038dSGuangbin Huang }, 23710e32038dSGuangbin Huang { 23726571ec2eSGuangbin Huang .cmd = HNAE3_DBG_CMD_QOS_PAUSE_CFG, 23736571ec2eSGuangbin Huang .dbg_dump = hclge_dbg_dump_qos_pause_cfg, 23746571ec2eSGuangbin Huang }, 23756571ec2eSGuangbin Huang { 237628d3badaSGuangbin Huang .cmd = HNAE3_DBG_CMD_QOS_PRI_MAP, 237728d3badaSGuangbin Huang .dbg_dump = hclge_dbg_dump_qos_pri_map, 237828d3badaSGuangbin Huang }, 237928d3badaSGuangbin Huang { 238095b19586SGuangbin Huang .cmd = HNAE3_DBG_CMD_QOS_BUF_CFG, 238195b19586SGuangbin Huang .dbg_dump = hclge_dbg_dump_qos_buf_cfg, 238295b19586SGuangbin Huang }, 238395b19586SGuangbin Huang { 23841556ea91SHuazhong Tan .cmd = HNAE3_DBG_CMD_MAC_UC, 23851556ea91SHuazhong Tan .dbg_dump = hclge_dbg_dump_mac_uc, 23861556ea91SHuazhong Tan }, 23871556ea91SHuazhong Tan { 23881556ea91SHuazhong Tan .cmd = HNAE3_DBG_CMD_MAC_MC, 23891556ea91SHuazhong Tan .dbg_dump = hclge_dbg_dump_mac_mc, 23901556ea91SHuazhong Tan }, 23918ddfd9c4SYufeng Mo { 23928ddfd9c4SYufeng Mo .cmd = HNAE3_DBG_CMD_MNG_TBL, 23938ddfd9c4SYufeng Mo .dbg_dump = hclge_dbg_dump_mng_table, 23948ddfd9c4SYufeng Mo }, 2395d658ff34SYufeng Mo { 2396d658ff34SYufeng Mo .cmd = HNAE3_DBG_CMD_LOOPBACK, 2397d658ff34SYufeng Mo .dbg_dump = hclge_dbg_dump_loopback, 2398d658ff34SYufeng Mo }, 23999149ca0fSJiaran Zhang { 2400b34c157fSHuazhong Tan .cmd = HNAE3_DBG_CMD_PTP_INFO, 2401b34c157fSHuazhong Tan .dbg_dump = hclge_dbg_dump_ptp_info, 2402b34c157fSHuazhong Tan }, 2403b34c157fSHuazhong Tan { 24049149ca0fSJiaran Zhang .cmd = HNAE3_DBG_CMD_INTERRUPT_INFO, 24059149ca0fSJiaran Zhang .dbg_dump = hclge_dbg_dump_interrupt, 24069149ca0fSJiaran Zhang }, 24071a7ff828SJiaran Zhang { 24081a7ff828SJiaran Zhang .cmd = HNAE3_DBG_CMD_RESET_INFO, 24091a7ff828SJiaran Zhang .dbg_dump = hclge_dbg_dump_rst_info, 24101a7ff828SJiaran Zhang }, 24110b198b0dSJiaran Zhang { 24120b198b0dSJiaran Zhang .cmd = HNAE3_DBG_CMD_IMP_INFO, 24130b198b0dSJiaran Zhang .dbg_dump = hclge_dbg_get_imp_stats_info, 24140b198b0dSJiaran Zhang }, 2415e76e6886SJiaran Zhang { 2416e76e6886SJiaran Zhang .cmd = HNAE3_DBG_CMD_NCL_CONFIG, 2417e76e6886SJiaran Zhang .dbg_dump = hclge_dbg_dump_ncl_config, 2418e76e6886SJiaran Zhang }, 2419d96b0e59SYufeng Mo { 2420d96b0e59SYufeng Mo .cmd = HNAE3_DBG_CMD_REG_BIOS_COMMON, 2421d96b0e59SYufeng Mo .dbg_dump_reg = hclge_dbg_dump_reg_cmd, 2422d96b0e59SYufeng Mo }, 2423d96b0e59SYufeng Mo { 2424d96b0e59SYufeng Mo .cmd = HNAE3_DBG_CMD_REG_SSU, 2425d96b0e59SYufeng Mo .dbg_dump_reg = hclge_dbg_dump_reg_cmd, 2426d96b0e59SYufeng Mo }, 2427d96b0e59SYufeng Mo { 2428d96b0e59SYufeng Mo .cmd = HNAE3_DBG_CMD_REG_IGU_EGU, 2429d96b0e59SYufeng Mo .dbg_dump_reg = hclge_dbg_dump_reg_cmd, 2430d96b0e59SYufeng Mo }, 2431d96b0e59SYufeng Mo { 2432d96b0e59SYufeng Mo .cmd = HNAE3_DBG_CMD_REG_RPU, 2433d96b0e59SYufeng Mo .dbg_dump_reg = hclge_dbg_dump_reg_cmd, 2434d96b0e59SYufeng Mo }, 2435d96b0e59SYufeng Mo { 2436d96b0e59SYufeng Mo .cmd = HNAE3_DBG_CMD_REG_NCSI, 2437d96b0e59SYufeng Mo .dbg_dump_reg = hclge_dbg_dump_reg_cmd, 2438d96b0e59SYufeng Mo }, 2439d96b0e59SYufeng Mo { 2440d96b0e59SYufeng Mo .cmd = HNAE3_DBG_CMD_REG_RTC, 2441d96b0e59SYufeng Mo .dbg_dump_reg = hclge_dbg_dump_reg_cmd, 2442d96b0e59SYufeng Mo }, 2443d96b0e59SYufeng Mo { 2444d96b0e59SYufeng Mo .cmd = HNAE3_DBG_CMD_REG_PPP, 2445d96b0e59SYufeng Mo .dbg_dump_reg = hclge_dbg_dump_reg_cmd, 2446d96b0e59SYufeng Mo }, 2447d96b0e59SYufeng Mo { 2448d96b0e59SYufeng Mo .cmd = HNAE3_DBG_CMD_REG_RCB, 2449d96b0e59SYufeng Mo .dbg_dump_reg = hclge_dbg_dump_reg_cmd, 2450d96b0e59SYufeng Mo }, 2451d96b0e59SYufeng Mo { 2452d96b0e59SYufeng Mo .cmd = HNAE3_DBG_CMD_REG_TQP, 2453d96b0e59SYufeng Mo .dbg_dump_reg = hclge_dbg_dump_reg_cmd, 2454d96b0e59SYufeng Mo }, 2455d96b0e59SYufeng Mo { 2456d96b0e59SYufeng Mo .cmd = HNAE3_DBG_CMD_REG_MAC, 2457d96b0e59SYufeng Mo .dbg_dump = hclge_dbg_dump_mac, 2458d96b0e59SYufeng Mo }, 2459365e860aSYufeng Mo { 2460365e860aSYufeng Mo .cmd = HNAE3_DBG_CMD_REG_DCB, 2461365e860aSYufeng Mo .dbg_dump = hclge_dbg_dump_dcb, 2462365e860aSYufeng Mo }, 2463b5a0b70dSHao Chen { 2464b5a0b70dSHao Chen .cmd = HNAE3_DBG_CMD_FD_TCAM, 2465b5a0b70dSHao Chen .dbg_dump = hclge_dbg_dump_fd_tcam, 2466b5a0b70dSHao Chen }, 24677b07ab06SJiaran Zhang { 24687b07ab06SJiaran Zhang .cmd = HNAE3_DBG_CMD_MAC_TNL_STATUS, 24697b07ab06SJiaran Zhang .dbg_dump = hclge_dbg_dump_mac_tnl_status, 24707b07ab06SJiaran Zhang }, 2471058c3be9SYufeng Mo { 2472058c3be9SYufeng Mo .cmd = HNAE3_DBG_CMD_SERV_INFO, 2473058c3be9SYufeng Mo .dbg_dump = hclge_dbg_dump_serv_info, 2474058c3be9SYufeng Mo }, 24750ca821daSJian Shen { 24760ca821daSJian Shen .cmd = HNAE3_DBG_CMD_VLAN_CONFIG, 24770ca821daSJian Shen .dbg_dump = hclge_dbg_dump_vlan_config, 24780ca821daSJian Shen }, 247903a92fe8SJian Shen { 248003a92fe8SJian Shen .cmd = HNAE3_DBG_CMD_FD_COUNTER, 248103a92fe8SJian Shen .dbg_dump = hclge_dbg_dump_fd_counter, 248203a92fe8SJian Shen }, 2483d59daf6aSJian Shen { 2484d59daf6aSJian Shen .cmd = HNAE3_DBG_CMD_UMV_INFO, 2485d59daf6aSJian Shen .dbg_dump = hclge_dbg_dump_umv_info, 2486d59daf6aSJian Shen }, 24875e69ea7eSYufeng Mo }; 24885e69ea7eSYufeng Mo 24895e69ea7eSYufeng Mo int hclge_dbg_read_cmd(struct hnae3_handle *handle, enum hnae3_dbg_cmd cmd, 249004987ca1SGuangbin Huang char *buf, int len) 249104987ca1SGuangbin Huang { 249204987ca1SGuangbin Huang struct hclge_vport *vport = hclge_get_vport(handle); 2493d96b0e59SYufeng Mo const struct hclge_dbg_func *cmd_func; 249404987ca1SGuangbin Huang struct hclge_dev *hdev = vport->back; 24955e69ea7eSYufeng Mo u32 i; 249604987ca1SGuangbin Huang 24975e69ea7eSYufeng Mo for (i = 0; i < ARRAY_SIZE(hclge_dbg_cmd_func); i++) { 2498d96b0e59SYufeng Mo if (cmd == hclge_dbg_cmd_func[i].cmd) { 2499d96b0e59SYufeng Mo cmd_func = &hclge_dbg_cmd_func[i]; 2500d96b0e59SYufeng Mo if (cmd_func->dbg_dump) 2501d96b0e59SYufeng Mo return cmd_func->dbg_dump(hdev, buf, len); 2502d96b0e59SYufeng Mo else 2503d96b0e59SYufeng Mo return cmd_func->dbg_dump_reg(hdev, cmd, buf, 2504d96b0e59SYufeng Mo len); 2505d96b0e59SYufeng Mo } 25065e69ea7eSYufeng Mo } 250704987ca1SGuangbin Huang 25085e69ea7eSYufeng Mo dev_err(&hdev->pdev->dev, "invalid command(%d)\n", cmd); 250904987ca1SGuangbin Huang return -EINVAL; 251004987ca1SGuangbin Huang } 2511