13c666b58Sliuzhongzhu // SPDX-License-Identifier: GPL-2.0+ 23c666b58Sliuzhongzhu /* Copyright (c) 2018-2019 Hisilicon Limited. */ 33c666b58Sliuzhongzhu 43c666b58Sliuzhongzhu #include <linux/device.h> 52870c4d6SJakub Kicinski #include <linux/sched/clock.h> 63c666b58Sliuzhongzhu 76fc22440Sliuzhongzhu #include "hclge_debugfs.h" 81a7ff828SJiaran Zhang #include "hclge_err.h" 93c666b58Sliuzhongzhu #include "hclge_main.h" 10*939ccd10SJijie Shao #include "hclge_regs.h" 112849d4e7Sliuzhongzhu #include "hclge_tm.h" 123c666b58Sliuzhongzhu #include "hnae3.h" 133c666b58Sliuzhongzhu 14d658ff34SYufeng Mo static const char * const state_str[] = { "off", "on" }; 151556ea91SHuazhong Tan static const char * const hclge_mac_state_str[] = { 161556ea91SHuazhong Tan "TO_ADD", "TO_DEL", "ACTIVE" 171556ea91SHuazhong Tan }; 181556ea91SHuazhong Tan 19fddc02ebSGuangbin Huang static const char * const tc_map_mode_str[] = { "PRIO", "DSCP" }; 20fddc02ebSGuangbin Huang 21e4b91468SRikard Falkeborn static const struct hclge_dbg_reg_type_info hclge_dbg_reg_info[] = { 22d96b0e59SYufeng Mo { .cmd = HNAE3_DBG_CMD_REG_BIOS_COMMON, 23a582b78dSZhongzhu Liu .dfx_msg = &hclge_dbg_bios_common_reg[0], 24a582b78dSZhongzhu Liu .reg_msg = { .msg_num = ARRAY_SIZE(hclge_dbg_bios_common_reg), 25a582b78dSZhongzhu Liu .offset = HCLGE_DBG_DFX_BIOS_OFFSET, 26a582b78dSZhongzhu Liu .cmd = HCLGE_OPC_DFX_BIOS_COMMON_REG } }, 27d96b0e59SYufeng Mo { .cmd = HNAE3_DBG_CMD_REG_SSU, 28a582b78dSZhongzhu Liu .dfx_msg = &hclge_dbg_ssu_reg_0[0], 29a582b78dSZhongzhu Liu .reg_msg = { .msg_num = ARRAY_SIZE(hclge_dbg_ssu_reg_0), 30a582b78dSZhongzhu Liu .offset = HCLGE_DBG_DFX_SSU_0_OFFSET, 31a582b78dSZhongzhu Liu .cmd = HCLGE_OPC_DFX_SSU_REG_0 } }, 32d96b0e59SYufeng Mo { .cmd = HNAE3_DBG_CMD_REG_SSU, 33a582b78dSZhongzhu Liu .dfx_msg = &hclge_dbg_ssu_reg_1[0], 34a582b78dSZhongzhu Liu .reg_msg = { .msg_num = ARRAY_SIZE(hclge_dbg_ssu_reg_1), 35a582b78dSZhongzhu Liu .offset = HCLGE_DBG_DFX_SSU_1_OFFSET, 36a582b78dSZhongzhu Liu .cmd = HCLGE_OPC_DFX_SSU_REG_1 } }, 37d96b0e59SYufeng Mo { .cmd = HNAE3_DBG_CMD_REG_SSU, 38a582b78dSZhongzhu Liu .dfx_msg = &hclge_dbg_ssu_reg_2[0], 39a582b78dSZhongzhu Liu .reg_msg = { .msg_num = ARRAY_SIZE(hclge_dbg_ssu_reg_2), 40a582b78dSZhongzhu Liu .offset = HCLGE_DBG_DFX_SSU_2_OFFSET, 41a582b78dSZhongzhu Liu .cmd = HCLGE_OPC_DFX_SSU_REG_2 } }, 42d96b0e59SYufeng Mo { .cmd = HNAE3_DBG_CMD_REG_IGU_EGU, 43a582b78dSZhongzhu Liu .dfx_msg = &hclge_dbg_igu_egu_reg[0], 44a582b78dSZhongzhu Liu .reg_msg = { .msg_num = ARRAY_SIZE(hclge_dbg_igu_egu_reg), 45a582b78dSZhongzhu Liu .offset = HCLGE_DBG_DFX_IGU_OFFSET, 46a582b78dSZhongzhu Liu .cmd = HCLGE_OPC_DFX_IGU_EGU_REG } }, 47d96b0e59SYufeng Mo { .cmd = HNAE3_DBG_CMD_REG_RPU, 48a582b78dSZhongzhu Liu .dfx_msg = &hclge_dbg_rpu_reg_0[0], 49a582b78dSZhongzhu Liu .reg_msg = { .msg_num = ARRAY_SIZE(hclge_dbg_rpu_reg_0), 50a582b78dSZhongzhu Liu .offset = HCLGE_DBG_DFX_RPU_0_OFFSET, 51a582b78dSZhongzhu Liu .cmd = HCLGE_OPC_DFX_RPU_REG_0 } }, 52d96b0e59SYufeng Mo { .cmd = HNAE3_DBG_CMD_REG_RPU, 53a582b78dSZhongzhu Liu .dfx_msg = &hclge_dbg_rpu_reg_1[0], 54a582b78dSZhongzhu Liu .reg_msg = { .msg_num = ARRAY_SIZE(hclge_dbg_rpu_reg_1), 55a582b78dSZhongzhu Liu .offset = HCLGE_DBG_DFX_RPU_1_OFFSET, 56a582b78dSZhongzhu Liu .cmd = HCLGE_OPC_DFX_RPU_REG_1 } }, 57d96b0e59SYufeng Mo { .cmd = HNAE3_DBG_CMD_REG_NCSI, 58a582b78dSZhongzhu Liu .dfx_msg = &hclge_dbg_ncsi_reg[0], 59a582b78dSZhongzhu Liu .reg_msg = { .msg_num = ARRAY_SIZE(hclge_dbg_ncsi_reg), 60a582b78dSZhongzhu Liu .offset = HCLGE_DBG_DFX_NCSI_OFFSET, 61a582b78dSZhongzhu Liu .cmd = HCLGE_OPC_DFX_NCSI_REG } }, 62d96b0e59SYufeng Mo { .cmd = HNAE3_DBG_CMD_REG_RTC, 63a582b78dSZhongzhu Liu .dfx_msg = &hclge_dbg_rtc_reg[0], 64a582b78dSZhongzhu Liu .reg_msg = { .msg_num = ARRAY_SIZE(hclge_dbg_rtc_reg), 65a582b78dSZhongzhu Liu .offset = HCLGE_DBG_DFX_RTC_OFFSET, 66a582b78dSZhongzhu Liu .cmd = HCLGE_OPC_DFX_RTC_REG } }, 67d96b0e59SYufeng Mo { .cmd = HNAE3_DBG_CMD_REG_PPP, 68a582b78dSZhongzhu Liu .dfx_msg = &hclge_dbg_ppp_reg[0], 69a582b78dSZhongzhu Liu .reg_msg = { .msg_num = ARRAY_SIZE(hclge_dbg_ppp_reg), 70a582b78dSZhongzhu Liu .offset = HCLGE_DBG_DFX_PPP_OFFSET, 71a582b78dSZhongzhu Liu .cmd = HCLGE_OPC_DFX_PPP_REG } }, 72d96b0e59SYufeng Mo { .cmd = HNAE3_DBG_CMD_REG_RCB, 73a582b78dSZhongzhu Liu .dfx_msg = &hclge_dbg_rcb_reg[0], 74a582b78dSZhongzhu Liu .reg_msg = { .msg_num = ARRAY_SIZE(hclge_dbg_rcb_reg), 75a582b78dSZhongzhu Liu .offset = HCLGE_DBG_DFX_RCB_OFFSET, 76a582b78dSZhongzhu Liu .cmd = HCLGE_OPC_DFX_RCB_REG } }, 77d96b0e59SYufeng Mo { .cmd = HNAE3_DBG_CMD_REG_TQP, 78a582b78dSZhongzhu Liu .dfx_msg = &hclge_dbg_tqp_reg[0], 79a582b78dSZhongzhu Liu .reg_msg = { .msg_num = ARRAY_SIZE(hclge_dbg_tqp_reg), 80a582b78dSZhongzhu Liu .offset = HCLGE_DBG_DFX_TQP_OFFSET, 81a582b78dSZhongzhu Liu .cmd = HCLGE_OPC_DFX_TQP_REG } }, 82a582b78dSZhongzhu Liu }; 83a582b78dSZhongzhu Liu 844e599dddSHao Chen /* make sure: len(name) + interval >= maxlen(item data) + 2, 854e599dddSHao Chen * for example, name = "pkt_num"(len: 7), the prototype of item data is u32, 864e599dddSHao Chen * and print as "%u"(maxlen: 10), so the interval should be at least 5. 874e599dddSHao Chen */ 881556ea91SHuazhong Tan static void hclge_dbg_fill_content(char *content, u16 len, 891556ea91SHuazhong Tan const struct hclge_dbg_item *items, 901556ea91SHuazhong Tan const char **result, u16 size) 911556ea91SHuazhong Tan { 921cf3d556SHao Chen #define HCLGE_DBG_LINE_END_LEN 2 931556ea91SHuazhong Tan char *pos = content; 941cf3d556SHao Chen u16 item_len; 951556ea91SHuazhong Tan u16 i; 961556ea91SHuazhong Tan 971cf3d556SHao Chen if (!len) { 981cf3d556SHao Chen return; 991cf3d556SHao Chen } else if (len <= HCLGE_DBG_LINE_END_LEN) { 1001cf3d556SHao Chen *pos++ = '\0'; 1011cf3d556SHao Chen return; 1021cf3d556SHao Chen } 1031cf3d556SHao Chen 1041556ea91SHuazhong Tan memset(content, ' ', len); 1051cf3d556SHao Chen len -= HCLGE_DBG_LINE_END_LEN; 1061cf3d556SHao Chen 1071556ea91SHuazhong Tan for (i = 0; i < size; i++) { 1081cf3d556SHao Chen item_len = strlen(items[i].name) + items[i].interval; 1091cf3d556SHao Chen if (len < item_len) 1101cf3d556SHao Chen break; 1111cf3d556SHao Chen 1121cf3d556SHao Chen if (result) { 1131cf3d556SHao Chen if (item_len < strlen(result[i])) 1141cf3d556SHao Chen break; 1155e3d2061SHao Chen memcpy(pos, result[i], strlen(result[i])); 1161cf3d556SHao Chen } else { 1175e3d2061SHao Chen memcpy(pos, items[i].name, strlen(items[i].name)); 1181cf3d556SHao Chen } 1191cf3d556SHao Chen pos += item_len; 1201cf3d556SHao Chen len -= item_len; 1211556ea91SHuazhong Tan } 1221556ea91SHuazhong Tan *pos++ = '\n'; 1231556ea91SHuazhong Tan *pos++ = '\0'; 1241556ea91SHuazhong Tan } 1251556ea91SHuazhong Tan 1261556ea91SHuazhong Tan static char *hclge_dbg_get_func_id_str(char *buf, u8 id) 1271556ea91SHuazhong Tan { 1281556ea91SHuazhong Tan if (id) 1290cc25c6aSHao Chen sprintf(buf, "vf%u", id - 1U); 1301556ea91SHuazhong Tan else 1311556ea91SHuazhong Tan sprintf(buf, "pf"); 1321556ea91SHuazhong Tan 1331556ea91SHuazhong Tan return buf; 1341556ea91SHuazhong Tan } 1351556ea91SHuazhong Tan 136d96b0e59SYufeng Mo static int hclge_dbg_get_dfx_bd_num(struct hclge_dev *hdev, int offset, 137d96b0e59SYufeng Mo u32 *bd_num) 13827cf979aSliuzhongzhu { 139a582b78dSZhongzhu Liu struct hclge_desc desc[HCLGE_GET_DFX_REG_TYPE_CNT]; 140a582b78dSZhongzhu Liu int entries_per_desc; 141a582b78dSZhongzhu Liu int index; 14227cf979aSliuzhongzhu int ret; 14327cf979aSliuzhongzhu 144ddb54554SGuangbin Huang ret = hclge_query_bd_num_cmd_send(hdev, desc); 145ddb54554SGuangbin Huang if (ret) { 14627cf979aSliuzhongzhu dev_err(&hdev->pdev->dev, 147d96b0e59SYufeng Mo "failed to get dfx bd_num, offset = %d, ret = %d\n", 148d96b0e59SYufeng Mo offset, ret); 14927cf979aSliuzhongzhu return ret; 15027cf979aSliuzhongzhu } 15127cf979aSliuzhongzhu 152a582b78dSZhongzhu Liu entries_per_desc = ARRAY_SIZE(desc[0].data); 153a582b78dSZhongzhu Liu index = offset % entries_per_desc; 154d96b0e59SYufeng Mo 155d96b0e59SYufeng Mo *bd_num = le32_to_cpu(desc[offset / entries_per_desc].data[index]); 156d96b0e59SYufeng Mo if (!(*bd_num)) { 157d96b0e59SYufeng Mo dev_err(&hdev->pdev->dev, "The value of dfx bd_num is 0!\n"); 158d96b0e59SYufeng Mo return -EINVAL; 159d96b0e59SYufeng Mo } 160d96b0e59SYufeng Mo 161d96b0e59SYufeng Mo return 0; 16227cf979aSliuzhongzhu } 16327cf979aSliuzhongzhu 16427cf979aSliuzhongzhu static int hclge_dbg_cmd_send(struct hclge_dev *hdev, 16527cf979aSliuzhongzhu struct hclge_desc *desc_src, 16627cf979aSliuzhongzhu int index, int bd_num, 16727cf979aSliuzhongzhu enum hclge_opcode_type cmd) 16827cf979aSliuzhongzhu { 16927cf979aSliuzhongzhu struct hclge_desc *desc = desc_src; 17027cf979aSliuzhongzhu int ret, i; 17127cf979aSliuzhongzhu 17227cf979aSliuzhongzhu hclge_cmd_setup_basic_desc(desc, cmd, true); 17327cf979aSliuzhongzhu desc->data[0] = cpu_to_le32(index); 17427cf979aSliuzhongzhu 17527cf979aSliuzhongzhu for (i = 1; i < bd_num; i++) { 176d3c69a88SJie Wang desc->flag |= cpu_to_le16(HCLGE_COMM_CMD_FLAG_NEXT); 17727cf979aSliuzhongzhu desc++; 17827cf979aSliuzhongzhu hclge_cmd_setup_basic_desc(desc, cmd, true); 17927cf979aSliuzhongzhu } 18027cf979aSliuzhongzhu 18127cf979aSliuzhongzhu ret = hclge_cmd_send(&hdev->hw, desc_src, bd_num); 182ed5b255bSYufeng Mo if (ret) 18327cf979aSliuzhongzhu dev_err(&hdev->pdev->dev, 184ed5b255bSYufeng Mo "cmd(0x%x) send fail, ret = %d\n", cmd, ret); 18527cf979aSliuzhongzhu return ret; 18627cf979aSliuzhongzhu } 18727cf979aSliuzhongzhu 188d96b0e59SYufeng Mo static int 189d96b0e59SYufeng Mo hclge_dbg_dump_reg_tqp(struct hclge_dev *hdev, 190e4b91468SRikard Falkeborn const struct hclge_dbg_reg_type_info *reg_info, 191d96b0e59SYufeng Mo char *buf, int len, int *pos) 19227cf979aSliuzhongzhu { 193e4b91468SRikard Falkeborn const struct hclge_dbg_dfx_message *dfx_message = reg_info->dfx_msg; 194e4b91468SRikard Falkeborn const struct hclge_dbg_reg_common_msg *reg_msg = ®_info->reg_msg; 19527cf979aSliuzhongzhu struct hclge_desc *desc_src; 196d96b0e59SYufeng Mo u32 index, entry, i, cnt; 197d96b0e59SYufeng Mo int bd_num, min_num, ret; 19827cf979aSliuzhongzhu struct hclge_desc *desc; 19927cf979aSliuzhongzhu 200d96b0e59SYufeng Mo ret = hclge_dbg_get_dfx_bd_num(hdev, reg_msg->offset, &bd_num); 201d96b0e59SYufeng Mo if (ret) 202d96b0e59SYufeng Mo return ret; 20327cf979aSliuzhongzhu 204d96b0e59SYufeng Mo desc_src = kcalloc(bd_num, sizeof(struct hclge_desc), GFP_KERNEL); 205fbdc4d79SYufeng Mo if (!desc_src) 206d96b0e59SYufeng Mo return -ENOMEM; 20727cf979aSliuzhongzhu 208d96b0e59SYufeng Mo min_num = min_t(int, bd_num * HCLGE_DESC_DATA_LEN, reg_msg->msg_num); 209d96b0e59SYufeng Mo 210d96b0e59SYufeng Mo for (i = 0, cnt = 0; i < min_num; i++, dfx_message++) 211d96b0e59SYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "item%u = %s\n", 212d96b0e59SYufeng Mo cnt++, dfx_message->message); 213d96b0e59SYufeng Mo 214d96b0e59SYufeng Mo for (i = 0; i < cnt; i++) 215d96b0e59SYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "item%u\t", i); 216d96b0e59SYufeng Mo 217d96b0e59SYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "\n"); 218d96b0e59SYufeng Mo 219d96b0e59SYufeng Mo for (index = 0; index < hdev->vport[0].alloc_tqps; index++) { 220d96b0e59SYufeng Mo dfx_message = reg_info->dfx_msg; 22127cf979aSliuzhongzhu desc = desc_src; 222d96b0e59SYufeng Mo ret = hclge_dbg_cmd_send(hdev, desc, index, bd_num, 223d96b0e59SYufeng Mo reg_msg->cmd); 224d96b0e59SYufeng Mo if (ret) 225d96b0e59SYufeng Mo break; 22627cf979aSliuzhongzhu 227d96b0e59SYufeng Mo for (i = 0; i < min_num; i++, dfx_message++) { 228d96b0e59SYufeng Mo entry = i % HCLGE_DESC_DATA_LEN; 229d96b0e59SYufeng Mo if (i > 0 && !entry) 230a582b78dSZhongzhu Liu desc++; 23127cf979aSliuzhongzhu 232d96b0e59SYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "%#x\t", 233d96b0e59SYufeng Mo le32_to_cpu(desc->data[entry])); 234d96b0e59SYufeng Mo } 235d96b0e59SYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "\n"); 23627cf979aSliuzhongzhu } 23727cf979aSliuzhongzhu 23827cf979aSliuzhongzhu kfree(desc_src); 239d96b0e59SYufeng Mo return ret; 24027cf979aSliuzhongzhu } 24127cf979aSliuzhongzhu 242d96b0e59SYufeng Mo static int 243d96b0e59SYufeng Mo hclge_dbg_dump_reg_common(struct hclge_dev *hdev, 244d96b0e59SYufeng Mo const struct hclge_dbg_reg_type_info *reg_info, 245d96b0e59SYufeng Mo char *buf, int len, int *pos) 246d96b0e59SYufeng Mo { 247d96b0e59SYufeng Mo const struct hclge_dbg_reg_common_msg *reg_msg = ®_info->reg_msg; 248d96b0e59SYufeng Mo const struct hclge_dbg_dfx_message *dfx_message = reg_info->dfx_msg; 249d96b0e59SYufeng Mo struct hclge_desc *desc_src; 250d96b0e59SYufeng Mo int bd_num, min_num, ret; 251d96b0e59SYufeng Mo struct hclge_desc *desc; 252d96b0e59SYufeng Mo u32 entry, i; 253d96b0e59SYufeng Mo 254d96b0e59SYufeng Mo ret = hclge_dbg_get_dfx_bd_num(hdev, reg_msg->offset, &bd_num); 255d96b0e59SYufeng Mo if (ret) 256d96b0e59SYufeng Mo return ret; 257d96b0e59SYufeng Mo 258d96b0e59SYufeng Mo desc_src = kcalloc(bd_num, sizeof(struct hclge_desc), GFP_KERNEL); 259d96b0e59SYufeng Mo if (!desc_src) 260d96b0e59SYufeng Mo return -ENOMEM; 261d96b0e59SYufeng Mo 262d96b0e59SYufeng Mo desc = desc_src; 263d96b0e59SYufeng Mo 264d96b0e59SYufeng Mo ret = hclge_dbg_cmd_send(hdev, desc, 0, bd_num, reg_msg->cmd); 265d96b0e59SYufeng Mo if (ret) { 266d96b0e59SYufeng Mo kfree(desc); 267d96b0e59SYufeng Mo return ret; 268d96b0e59SYufeng Mo } 269d96b0e59SYufeng Mo 270d96b0e59SYufeng Mo min_num = min_t(int, bd_num * HCLGE_DESC_DATA_LEN, reg_msg->msg_num); 271d96b0e59SYufeng Mo 272d96b0e59SYufeng Mo for (i = 0; i < min_num; i++, dfx_message++) { 273d96b0e59SYufeng Mo entry = i % HCLGE_DESC_DATA_LEN; 274d96b0e59SYufeng Mo if (i > 0 && !entry) 275d96b0e59SYufeng Mo desc++; 276d96b0e59SYufeng Mo if (!dfx_message->flag) 277d96b0e59SYufeng Mo continue; 278d96b0e59SYufeng Mo 279d96b0e59SYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "%s: %#x\n", 280d96b0e59SYufeng Mo dfx_message->message, 281d96b0e59SYufeng Mo le32_to_cpu(desc->data[entry])); 282d96b0e59SYufeng Mo } 283d96b0e59SYufeng Mo 284d96b0e59SYufeng Mo kfree(desc_src); 285d96b0e59SYufeng Mo return 0; 286d96b0e59SYufeng Mo } 287d96b0e59SYufeng Mo 288e6fe5e16SJie Wang static const struct hclge_dbg_status_dfx_info hclge_dbg_mac_en_status[] = { 289e6fe5e16SJie Wang {HCLGE_MAC_TX_EN_B, "mac_trans_en"}, 290e6fe5e16SJie Wang {HCLGE_MAC_RX_EN_B, "mac_rcv_en"}, 291e6fe5e16SJie Wang {HCLGE_MAC_PAD_TX_B, "pad_trans_en"}, 292e6fe5e16SJie Wang {HCLGE_MAC_PAD_RX_B, "pad_rcv_en"}, 293e6fe5e16SJie Wang {HCLGE_MAC_1588_TX_B, "1588_trans_en"}, 294e6fe5e16SJie Wang {HCLGE_MAC_1588_RX_B, "1588_rcv_en"}, 295e6fe5e16SJie Wang {HCLGE_MAC_APP_LP_B, "mac_app_loop_en"}, 296e6fe5e16SJie Wang {HCLGE_MAC_LINE_LP_B, "mac_line_loop_en"}, 297e6fe5e16SJie Wang {HCLGE_MAC_FCS_TX_B, "mac_fcs_tx_en"}, 298e6fe5e16SJie Wang {HCLGE_MAC_RX_OVERSIZE_TRUNCATE_B, "mac_rx_oversize_truncate_en"}, 299e6fe5e16SJie Wang {HCLGE_MAC_RX_FCS_STRIP_B, "mac_rx_fcs_strip_en"}, 300e6fe5e16SJie Wang {HCLGE_MAC_RX_FCS_B, "mac_rx_fcs_en"}, 301e6fe5e16SJie Wang {HCLGE_MAC_TX_UNDER_MIN_ERR_B, "mac_tx_under_min_err_en"}, 302e6fe5e16SJie Wang {HCLGE_MAC_TX_OVERSIZE_TRUNCATE_B, "mac_tx_oversize_truncate_en"} 303e6fe5e16SJie Wang }; 304e6fe5e16SJie Wang 305d96b0e59SYufeng Mo static int hclge_dbg_dump_mac_enable_status(struct hclge_dev *hdev, char *buf, 306d96b0e59SYufeng Mo int len, int *pos) 3075cb51cfeSYufeng Mo { 3085cb51cfeSYufeng Mo struct hclge_config_mac_mode_cmd *req; 3095cb51cfeSYufeng Mo struct hclge_desc desc; 310e6fe5e16SJie Wang u32 loop_en, i, offset; 3115cb51cfeSYufeng Mo int ret; 3125cb51cfeSYufeng Mo 3135cb51cfeSYufeng Mo hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_CONFIG_MAC_MODE, true); 3145cb51cfeSYufeng Mo 3155cb51cfeSYufeng Mo ret = hclge_cmd_send(&hdev->hw, &desc, 1); 3165cb51cfeSYufeng Mo if (ret) { 3175cb51cfeSYufeng Mo dev_err(&hdev->pdev->dev, 3185cb51cfeSYufeng Mo "failed to dump mac enable status, ret = %d\n", ret); 319d96b0e59SYufeng Mo return ret; 3205cb51cfeSYufeng Mo } 3215cb51cfeSYufeng Mo 3225cb51cfeSYufeng Mo req = (struct hclge_config_mac_mode_cmd *)desc.data; 3235cb51cfeSYufeng Mo loop_en = le32_to_cpu(req->txrx_pad_fcs_loop_en); 3245cb51cfeSYufeng Mo 325e6fe5e16SJie Wang for (i = 0; i < ARRAY_SIZE(hclge_dbg_mac_en_status); i++) { 326e6fe5e16SJie Wang offset = hclge_dbg_mac_en_status[i].offset; 327e6fe5e16SJie Wang *pos += scnprintf(buf + *pos, len - *pos, "%s: %#x\n", 328e6fe5e16SJie Wang hclge_dbg_mac_en_status[i].message, 329e6fe5e16SJie Wang hnae3_get_bit(loop_en, offset)); 330e6fe5e16SJie Wang } 331d96b0e59SYufeng Mo 332d96b0e59SYufeng Mo return 0; 3335cb51cfeSYufeng Mo } 3345cb51cfeSYufeng Mo 335d96b0e59SYufeng Mo static int hclge_dbg_dump_mac_frame_size(struct hclge_dev *hdev, char *buf, 336d96b0e59SYufeng Mo int len, int *pos) 3375cb51cfeSYufeng Mo { 3385cb51cfeSYufeng Mo struct hclge_config_max_frm_size_cmd *req; 3395cb51cfeSYufeng Mo struct hclge_desc desc; 3405cb51cfeSYufeng Mo int ret; 3415cb51cfeSYufeng Mo 3425cb51cfeSYufeng Mo hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_CONFIG_MAX_FRM_SIZE, true); 3435cb51cfeSYufeng Mo 3445cb51cfeSYufeng Mo ret = hclge_cmd_send(&hdev->hw, &desc, 1); 3455cb51cfeSYufeng Mo if (ret) { 3465cb51cfeSYufeng Mo dev_err(&hdev->pdev->dev, 3475cb51cfeSYufeng Mo "failed to dump mac frame size, ret = %d\n", ret); 348d96b0e59SYufeng Mo return ret; 3495cb51cfeSYufeng Mo } 3505cb51cfeSYufeng Mo 3515cb51cfeSYufeng Mo req = (struct hclge_config_max_frm_size_cmd *)desc.data; 3525cb51cfeSYufeng Mo 353d96b0e59SYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "max_frame_size: %u\n", 3545cb51cfeSYufeng Mo le16_to_cpu(req->max_frm_size)); 355d96b0e59SYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "min_frame_size: %u\n", 356d96b0e59SYufeng Mo req->min_frm_size); 357d96b0e59SYufeng Mo 358d96b0e59SYufeng Mo return 0; 3595cb51cfeSYufeng Mo } 3605cb51cfeSYufeng Mo 361d96b0e59SYufeng Mo static int hclge_dbg_dump_mac_speed_duplex(struct hclge_dev *hdev, char *buf, 362d96b0e59SYufeng Mo int len, int *pos) 3635cb51cfeSYufeng Mo { 3645cb51cfeSYufeng Mo #define HCLGE_MAC_SPEED_SHIFT 0 3655cb51cfeSYufeng Mo #define HCLGE_MAC_SPEED_MASK GENMASK(5, 0) 3665cb51cfeSYufeng Mo #define HCLGE_MAC_DUPLEX_SHIFT 7 3675cb51cfeSYufeng Mo 3685cb51cfeSYufeng Mo struct hclge_config_mac_speed_dup_cmd *req; 3695cb51cfeSYufeng Mo struct hclge_desc desc; 3705cb51cfeSYufeng Mo int ret; 3715cb51cfeSYufeng Mo 3725cb51cfeSYufeng Mo hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_CONFIG_SPEED_DUP, true); 3735cb51cfeSYufeng Mo 3745cb51cfeSYufeng Mo ret = hclge_cmd_send(&hdev->hw, &desc, 1); 3755cb51cfeSYufeng Mo if (ret) { 3765cb51cfeSYufeng Mo dev_err(&hdev->pdev->dev, 3775cb51cfeSYufeng Mo "failed to dump mac speed duplex, ret = %d\n", ret); 378d96b0e59SYufeng Mo return ret; 3795cb51cfeSYufeng Mo } 3805cb51cfeSYufeng Mo 3815cb51cfeSYufeng Mo req = (struct hclge_config_mac_speed_dup_cmd *)desc.data; 3825cb51cfeSYufeng Mo 383d96b0e59SYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "speed: %#lx\n", 3845cb51cfeSYufeng Mo hnae3_get_field(req->speed_dup, HCLGE_MAC_SPEED_MASK, 3855cb51cfeSYufeng Mo HCLGE_MAC_SPEED_SHIFT)); 386d96b0e59SYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "duplex: %#x\n", 387d96b0e59SYufeng Mo hnae3_get_bit(req->speed_dup, 388d96b0e59SYufeng Mo HCLGE_MAC_DUPLEX_SHIFT)); 389d96b0e59SYufeng Mo return 0; 3905cb51cfeSYufeng Mo } 3915cb51cfeSYufeng Mo 392d96b0e59SYufeng Mo static int hclge_dbg_dump_mac(struct hclge_dev *hdev, char *buf, int len) 3935cb51cfeSYufeng Mo { 394d96b0e59SYufeng Mo int pos = 0; 395d96b0e59SYufeng Mo int ret; 3965cb51cfeSYufeng Mo 397d96b0e59SYufeng Mo ret = hclge_dbg_dump_mac_enable_status(hdev, buf, len, &pos); 398d96b0e59SYufeng Mo if (ret) 399d96b0e59SYufeng Mo return ret; 4005cb51cfeSYufeng Mo 401d96b0e59SYufeng Mo ret = hclge_dbg_dump_mac_frame_size(hdev, buf, len, &pos); 402d96b0e59SYufeng Mo if (ret) 403d96b0e59SYufeng Mo return ret; 404d96b0e59SYufeng Mo 405d96b0e59SYufeng Mo return hclge_dbg_dump_mac_speed_duplex(hdev, buf, len, &pos); 4065cb51cfeSYufeng Mo } 4075cb51cfeSYufeng Mo 408365e860aSYufeng Mo static int hclge_dbg_dump_dcb_qset(struct hclge_dev *hdev, char *buf, int len, 409365e860aSYufeng Mo int *pos) 410c0ebebb9Sliuzhongzhu { 4112a21dab5SJie Wang struct hclge_dbg_bitmap_cmd req; 412365e860aSYufeng Mo struct hclge_desc desc; 413365e860aSYufeng Mo u16 qset_id, qset_num; 414365e860aSYufeng Mo int ret; 415c0ebebb9Sliuzhongzhu 416365e860aSYufeng Mo ret = hclge_tm_get_qset_num(hdev, &qset_num); 417365e860aSYufeng Mo if (ret) 418365e860aSYufeng Mo return ret; 419c0ebebb9Sliuzhongzhu 420365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, 421365e860aSYufeng Mo "qset_id roce_qset_mask nic_qset_mask qset_shaping_pass qset_bp_status\n"); 422365e860aSYufeng Mo for (qset_id = 0; qset_id < qset_num; qset_id++) { 423365e860aSYufeng Mo ret = hclge_dbg_cmd_send(hdev, &desc, qset_id, 1, 424365e860aSYufeng Mo HCLGE_OPC_QSET_DFX_STS); 425365e860aSYufeng Mo if (ret) 426365e860aSYufeng Mo return ret; 427365e860aSYufeng Mo 4282a21dab5SJie Wang req.bitmap = (u8)le32_to_cpu(desc.data[1]); 429365e860aSYufeng Mo 430365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, 431365e860aSYufeng Mo "%04u %#x %#x %#x %#x\n", 4322a21dab5SJie Wang qset_id, req.bit0, req.bit1, req.bit2, 4332a21dab5SJie Wang req.bit3); 434c0ebebb9Sliuzhongzhu } 435c0ebebb9Sliuzhongzhu 436365e860aSYufeng Mo return 0; 437365e860aSYufeng Mo } 438365e860aSYufeng Mo 439365e860aSYufeng Mo static int hclge_dbg_dump_dcb_pri(struct hclge_dev *hdev, char *buf, int len, 440365e860aSYufeng Mo int *pos) 441365e860aSYufeng Mo { 4422a21dab5SJie Wang struct hclge_dbg_bitmap_cmd req; 443365e860aSYufeng Mo struct hclge_desc desc; 444365e860aSYufeng Mo u8 pri_id, pri_num; 445365e860aSYufeng Mo int ret; 446365e860aSYufeng Mo 447365e860aSYufeng Mo ret = hclge_tm_get_pri_num(hdev, &pri_num); 448c0ebebb9Sliuzhongzhu if (ret) 449365e860aSYufeng Mo return ret; 450c0ebebb9Sliuzhongzhu 451365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, 452365e860aSYufeng Mo "pri_id pri_mask pri_cshaping_pass pri_pshaping_pass\n"); 453365e860aSYufeng Mo for (pri_id = 0; pri_id < pri_num; pri_id++) { 454365e860aSYufeng Mo ret = hclge_dbg_cmd_send(hdev, &desc, pri_id, 1, 455365e860aSYufeng Mo HCLGE_OPC_PRI_DFX_STS); 456c0ebebb9Sliuzhongzhu if (ret) 457365e860aSYufeng Mo return ret; 458c0ebebb9Sliuzhongzhu 4592a21dab5SJie Wang req.bitmap = (u8)le32_to_cpu(desc.data[1]); 460c0ebebb9Sliuzhongzhu 461365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, 462365e860aSYufeng Mo "%03u %#x %#x %#x\n", 4632a21dab5SJie Wang pri_id, req.bit0, req.bit1, req.bit2); 464365e860aSYufeng Mo } 465365e860aSYufeng Mo 466365e860aSYufeng Mo return 0; 467365e860aSYufeng Mo } 468365e860aSYufeng Mo 469365e860aSYufeng Mo static int hclge_dbg_dump_dcb_pg(struct hclge_dev *hdev, char *buf, int len, 470365e860aSYufeng Mo int *pos) 471365e860aSYufeng Mo { 4722a21dab5SJie Wang struct hclge_dbg_bitmap_cmd req; 473365e860aSYufeng Mo struct hclge_desc desc; 474365e860aSYufeng Mo u8 pg_id; 475365e860aSYufeng Mo int ret; 476365e860aSYufeng Mo 477365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, 478365e860aSYufeng Mo "pg_id pg_mask pg_cshaping_pass pg_pshaping_pass\n"); 479365e860aSYufeng Mo for (pg_id = 0; pg_id < hdev->tm_info.num_pg; pg_id++) { 480365e860aSYufeng Mo ret = hclge_dbg_cmd_send(hdev, &desc, pg_id, 1, 481365e860aSYufeng Mo HCLGE_OPC_PG_DFX_STS); 482c0ebebb9Sliuzhongzhu if (ret) 483365e860aSYufeng Mo return ret; 484c0ebebb9Sliuzhongzhu 4852a21dab5SJie Wang req.bitmap = (u8)le32_to_cpu(desc.data[1]); 486c0ebebb9Sliuzhongzhu 487365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, 488365e860aSYufeng Mo "%03u %#x %#x %#x\n", 4892a21dab5SJie Wang pg_id, req.bit0, req.bit1, req.bit2); 490365e860aSYufeng Mo } 491365e860aSYufeng Mo 492365e860aSYufeng Mo return 0; 493365e860aSYufeng Mo } 494365e860aSYufeng Mo 495365e860aSYufeng Mo static int hclge_dbg_dump_dcb_queue(struct hclge_dev *hdev, char *buf, int len, 496365e860aSYufeng Mo int *pos) 497365e860aSYufeng Mo { 498365e860aSYufeng Mo struct hclge_desc desc; 499365e860aSYufeng Mo u16 nq_id; 500365e860aSYufeng Mo int ret; 501365e860aSYufeng Mo 502365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, 503365e860aSYufeng Mo "nq_id sch_nic_queue_cnt sch_roce_queue_cnt\n"); 504365e860aSYufeng Mo for (nq_id = 0; nq_id < hdev->num_tqps; nq_id++) { 505365e860aSYufeng Mo ret = hclge_dbg_cmd_send(hdev, &desc, nq_id, 1, 506365e860aSYufeng Mo HCLGE_OPC_SCH_NQ_CNT); 507c0ebebb9Sliuzhongzhu if (ret) 508365e860aSYufeng Mo return ret; 509c0ebebb9Sliuzhongzhu 510365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "%04u %#x", 511365e860aSYufeng Mo nq_id, le32_to_cpu(desc.data[1])); 512c0ebebb9Sliuzhongzhu 513365e860aSYufeng Mo ret = hclge_dbg_cmd_send(hdev, &desc, nq_id, 1, 514365e860aSYufeng Mo HCLGE_OPC_SCH_RQ_CNT); 515c0ebebb9Sliuzhongzhu if (ret) 516365e860aSYufeng Mo return ret; 517c0ebebb9Sliuzhongzhu 518365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, 519365e860aSYufeng Mo " %#x\n", 520365e860aSYufeng Mo le32_to_cpu(desc.data[1])); 521365e860aSYufeng Mo } 522c0ebebb9Sliuzhongzhu 523365e860aSYufeng Mo return 0; 524365e860aSYufeng Mo } 525365e860aSYufeng Mo 526365e860aSYufeng Mo static int hclge_dbg_dump_dcb_port(struct hclge_dev *hdev, char *buf, int len, 527365e860aSYufeng Mo int *pos) 528365e860aSYufeng Mo { 5292a21dab5SJie Wang struct hclge_dbg_bitmap_cmd req; 530365e860aSYufeng Mo struct hclge_desc desc; 531365e860aSYufeng Mo u8 port_id = 0; 532365e860aSYufeng Mo int ret; 533365e860aSYufeng Mo 534365e860aSYufeng Mo ret = hclge_dbg_cmd_send(hdev, &desc, port_id, 1, 535365e860aSYufeng Mo HCLGE_OPC_PORT_DFX_STS); 536c0ebebb9Sliuzhongzhu if (ret) 537365e860aSYufeng Mo return ret; 538c0ebebb9Sliuzhongzhu 5392a21dab5SJie Wang req.bitmap = (u8)le32_to_cpu(desc.data[1]); 540c0ebebb9Sliuzhongzhu 541365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "port_mask: %#x\n", 5422a21dab5SJie Wang req.bit0); 543365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "port_shaping_pass: %#x\n", 5442a21dab5SJie Wang req.bit1); 545365e860aSYufeng Mo 546365e860aSYufeng Mo return 0; 547365e860aSYufeng Mo } 548365e860aSYufeng Mo 549365e860aSYufeng Mo static int hclge_dbg_dump_dcb_tm(struct hclge_dev *hdev, char *buf, int len, 550365e860aSYufeng Mo int *pos) 551365e860aSYufeng Mo { 552365e860aSYufeng Mo struct hclge_desc desc[2]; 553365e860aSYufeng Mo u8 port_id = 0; 554365e860aSYufeng Mo int ret; 555365e860aSYufeng Mo 556365e860aSYufeng Mo ret = hclge_dbg_cmd_send(hdev, desc, port_id, 1, 557365e860aSYufeng Mo HCLGE_OPC_TM_INTERNAL_CNT); 558c0ebebb9Sliuzhongzhu if (ret) 559365e860aSYufeng Mo return ret; 560c0ebebb9Sliuzhongzhu 561365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "SCH_NIC_NUM: %#x\n", 562365e860aSYufeng Mo le32_to_cpu(desc[0].data[1])); 563365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "SCH_ROCE_NUM: %#x\n", 564365e860aSYufeng Mo le32_to_cpu(desc[0].data[2])); 565365e860aSYufeng Mo 566365e860aSYufeng Mo ret = hclge_dbg_cmd_send(hdev, desc, port_id, 2, 567365e860aSYufeng Mo HCLGE_OPC_TM_INTERNAL_STS); 568365e860aSYufeng Mo if (ret) 569365e860aSYufeng Mo return ret; 570365e860aSYufeng Mo 571365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "pri_bp: %#x\n", 572365e860aSYufeng Mo le32_to_cpu(desc[0].data[1])); 573365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "fifo_dfx_info: %#x\n", 574365e860aSYufeng Mo le32_to_cpu(desc[0].data[2])); 575365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, 576365e860aSYufeng Mo "sch_roce_fifo_afull_gap: %#x\n", 57739edaf24SGuojia Liao le32_to_cpu(desc[0].data[3])); 578365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, 579365e860aSYufeng Mo "tx_private_waterline: %#x\n", 58039edaf24SGuojia Liao le32_to_cpu(desc[0].data[4])); 581365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "tm_bypass_en: %#x\n", 58239edaf24SGuojia Liao le32_to_cpu(desc[0].data[5])); 583365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "SSU_TM_BYPASS_EN: %#x\n", 584365e860aSYufeng Mo le32_to_cpu(desc[1].data[0])); 585365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "SSU_RESERVE_CFG: %#x\n", 586365e860aSYufeng Mo le32_to_cpu(desc[1].data[1])); 58777ba415dSYufeng Mo 588365e860aSYufeng Mo if (hdev->hw.mac.media_type == HNAE3_MEDIA_TYPE_COPPER) 589365e860aSYufeng Mo return 0; 590365e860aSYufeng Mo 591365e860aSYufeng Mo ret = hclge_dbg_cmd_send(hdev, desc, port_id, 1, 592365e860aSYufeng Mo HCLGE_OPC_TM_INTERNAL_STS_1); 593365e860aSYufeng Mo if (ret) 594365e860aSYufeng Mo return ret; 595365e860aSYufeng Mo 596365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "TC_MAP_SEL: %#x\n", 597365e860aSYufeng Mo le32_to_cpu(desc[0].data[1])); 598365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "IGU_PFC_PRI_EN: %#x\n", 599365e860aSYufeng Mo le32_to_cpu(desc[0].data[2])); 600365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "MAC_PFC_PRI_EN: %#x\n", 601365e860aSYufeng Mo le32_to_cpu(desc[0].data[3])); 602365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, "IGU_PRI_MAP_TC_CFG: %#x\n", 603365e860aSYufeng Mo le32_to_cpu(desc[0].data[4])); 604365e860aSYufeng Mo *pos += scnprintf(buf + *pos, len - *pos, 605365e860aSYufeng Mo "IGU_TX_PRI_MAP_TC_CFG: %#x\n", 606365e860aSYufeng Mo le32_to_cpu(desc[0].data[5])); 607365e860aSYufeng Mo 608365e860aSYufeng Mo return 0; 609365e860aSYufeng Mo } 610365e860aSYufeng Mo 611365e860aSYufeng Mo static int hclge_dbg_dump_dcb(struct hclge_dev *hdev, char *buf, int len) 612365e860aSYufeng Mo { 613365e860aSYufeng Mo int pos = 0; 614365e860aSYufeng Mo int ret; 615365e860aSYufeng Mo 616365e860aSYufeng Mo ret = hclge_dbg_dump_dcb_qset(hdev, buf, len, &pos); 617365e860aSYufeng Mo if (ret) 618365e860aSYufeng Mo return ret; 619365e860aSYufeng Mo 620365e860aSYufeng Mo ret = hclge_dbg_dump_dcb_pri(hdev, buf, len, &pos); 621365e860aSYufeng Mo if (ret) 622365e860aSYufeng Mo return ret; 623365e860aSYufeng Mo 624365e860aSYufeng Mo ret = hclge_dbg_dump_dcb_pg(hdev, buf, len, &pos); 625365e860aSYufeng Mo if (ret) 626365e860aSYufeng Mo return ret; 627365e860aSYufeng Mo 628365e860aSYufeng Mo ret = hclge_dbg_dump_dcb_queue(hdev, buf, len, &pos); 629365e860aSYufeng Mo if (ret) 630365e860aSYufeng Mo return ret; 631365e860aSYufeng Mo 632365e860aSYufeng Mo ret = hclge_dbg_dump_dcb_port(hdev, buf, len, &pos); 633365e860aSYufeng Mo if (ret) 634365e860aSYufeng Mo return ret; 635365e860aSYufeng Mo 636365e860aSYufeng Mo return hclge_dbg_dump_dcb_tm(hdev, buf, len, &pos); 637c0ebebb9Sliuzhongzhu } 638c0ebebb9Sliuzhongzhu 639d96b0e59SYufeng Mo static int hclge_dbg_dump_reg_cmd(struct hclge_dev *hdev, 640d96b0e59SYufeng Mo enum hnae3_dbg_cmd cmd, char *buf, int len) 64127cf979aSliuzhongzhu { 642e4b91468SRikard Falkeborn const struct hclge_dbg_reg_type_info *reg_info; 643d96b0e59SYufeng Mo int pos = 0, ret = 0; 644a582b78dSZhongzhu Liu int i; 64527cf979aSliuzhongzhu 646a582b78dSZhongzhu Liu for (i = 0; i < ARRAY_SIZE(hclge_dbg_reg_info); i++) { 647a582b78dSZhongzhu Liu reg_info = &hclge_dbg_reg_info[i]; 648d96b0e59SYufeng Mo if (cmd == reg_info->cmd) { 649d96b0e59SYufeng Mo if (cmd == HNAE3_DBG_CMD_REG_TQP) 650d96b0e59SYufeng Mo return hclge_dbg_dump_reg_tqp(hdev, reg_info, 651d96b0e59SYufeng Mo buf, len, &pos); 652d96b0e59SYufeng Mo 653d96b0e59SYufeng Mo ret = hclge_dbg_dump_reg_common(hdev, reg_info, buf, 654d96b0e59SYufeng Mo len, &pos); 655d96b0e59SYufeng Mo if (ret) 656d96b0e59SYufeng Mo break; 657a582b78dSZhongzhu Liu } 658a582b78dSZhongzhu Liu } 65927cf979aSliuzhongzhu 660d96b0e59SYufeng Mo return ret; 66127cf979aSliuzhongzhu } 66227cf979aSliuzhongzhu 6630e32038dSGuangbin Huang static int hclge_dbg_dump_tc(struct hclge_dev *hdev, char *buf, int len) 6642849d4e7Sliuzhongzhu { 6652849d4e7Sliuzhongzhu struct hclge_ets_tc_weight_cmd *ets_weight; 6662849d4e7Sliuzhongzhu struct hclge_desc desc; 6670e32038dSGuangbin Huang char *sch_mode_str; 6680e32038dSGuangbin Huang int pos = 0; 6690e32038dSGuangbin Huang int ret; 6700e32038dSGuangbin Huang u8 i; 6712849d4e7Sliuzhongzhu 6723f0f3253SYufeng Mo if (!hnae3_dev_dcb_supported(hdev)) { 6730e32038dSGuangbin Huang dev_err(&hdev->pdev->dev, 6743f0f3253SYufeng Mo "Only DCB-supported dev supports tc\n"); 6750e32038dSGuangbin Huang return -EOPNOTSUPP; 6763f0f3253SYufeng Mo } 6773f0f3253SYufeng Mo 6782849d4e7Sliuzhongzhu hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_ETS_TC_WEIGHT, true); 6792849d4e7Sliuzhongzhu ret = hclge_cmd_send(&hdev->hw, &desc, 1); 6802849d4e7Sliuzhongzhu if (ret) { 6810e32038dSGuangbin Huang dev_err(&hdev->pdev->dev, "failed to get tc weight, ret = %d\n", 6820e32038dSGuangbin Huang ret); 6830e32038dSGuangbin Huang return ret; 6842849d4e7Sliuzhongzhu } 6852849d4e7Sliuzhongzhu 6862849d4e7Sliuzhongzhu ets_weight = (struct hclge_ets_tc_weight_cmd *)desc.data; 6872849d4e7Sliuzhongzhu 6880e32038dSGuangbin Huang pos += scnprintf(buf + pos, len - pos, "enabled tc number: %u\n", 689a8adbb8aSYonglong Liu hdev->tm_info.num_tc); 6900e32038dSGuangbin Huang pos += scnprintf(buf + pos, len - pos, "weight_offset: %u\n", 6912849d4e7Sliuzhongzhu ets_weight->weight_offset); 6922849d4e7Sliuzhongzhu 6930e32038dSGuangbin Huang pos += scnprintf(buf + pos, len - pos, "TC MODE WEIGHT\n"); 6940e32038dSGuangbin Huang for (i = 0; i < HNAE3_MAX_TC; i++) { 6950e32038dSGuangbin Huang sch_mode_str = ets_weight->tc_weight[i] ? "dwrr" : "sp"; 6960e32038dSGuangbin Huang pos += scnprintf(buf + pos, len - pos, "%u %4s %3u\n", 697116d9f73SJijie Shao i, sch_mode_str, ets_weight->tc_weight[i]); 6980e32038dSGuangbin Huang } 6990e32038dSGuangbin Huang 7000e32038dSGuangbin Huang return 0; 7012849d4e7Sliuzhongzhu } 7022849d4e7Sliuzhongzhu 703cad7c215SGuangbin Huang static const struct hclge_dbg_item tm_pg_items[] = { 704cad7c215SGuangbin Huang { "ID", 2 }, 705cad7c215SGuangbin Huang { "PRI_MAP", 2 }, 706cad7c215SGuangbin Huang { "MODE", 2 }, 707cad7c215SGuangbin Huang { "DWRR", 2 }, 708cad7c215SGuangbin Huang { "C_IR_B", 2 }, 709cad7c215SGuangbin Huang { "C_IR_U", 2 }, 710cad7c215SGuangbin Huang { "C_IR_S", 2 }, 711cad7c215SGuangbin Huang { "C_BS_B", 2 }, 712cad7c215SGuangbin Huang { "C_BS_S", 2 }, 713cad7c215SGuangbin Huang { "C_FLAG", 2 }, 714cad7c215SGuangbin Huang { "C_RATE(Mbps)", 2 }, 715cad7c215SGuangbin Huang { "P_IR_B", 2 }, 716cad7c215SGuangbin Huang { "P_IR_U", 2 }, 717cad7c215SGuangbin Huang { "P_IR_S", 2 }, 718cad7c215SGuangbin Huang { "P_BS_B", 2 }, 719cad7c215SGuangbin Huang { "P_BS_S", 2 }, 720cad7c215SGuangbin Huang { "P_FLAG", 2 }, 721cad7c215SGuangbin Huang { "P_RATE(Mbps)", 0 } 722cad7c215SGuangbin Huang }; 723cad7c215SGuangbin Huang 724cad7c215SGuangbin Huang static void hclge_dbg_fill_shaper_content(struct hclge_tm_shaper_para *para, 725cad7c215SGuangbin Huang char **result, u8 *index) 72696227f4cSliuzhongzhu { 727cad7c215SGuangbin Huang sprintf(result[(*index)++], "%3u", para->ir_b); 728cad7c215SGuangbin Huang sprintf(result[(*index)++], "%3u", para->ir_u); 729cad7c215SGuangbin Huang sprintf(result[(*index)++], "%3u", para->ir_s); 730cad7c215SGuangbin Huang sprintf(result[(*index)++], "%3u", para->bs_b); 731cad7c215SGuangbin Huang sprintf(result[(*index)++], "%3u", para->bs_s); 732cad7c215SGuangbin Huang sprintf(result[(*index)++], "%3u", para->flag); 733cad7c215SGuangbin Huang sprintf(result[(*index)++], "%6u", para->rate); 7343f0f3253SYufeng Mo } 7353f0f3253SYufeng Mo 736c894b51eSArnd Bergmann static int __hclge_dbg_dump_tm_pg(struct hclge_dev *hdev, char *data_str, 737c894b51eSArnd Bergmann char *buf, int len) 73896227f4cSliuzhongzhu { 739cad7c215SGuangbin Huang struct hclge_tm_shaper_para c_shaper_para, p_shaper_para; 740cad7c215SGuangbin Huang char *result[ARRAY_SIZE(tm_pg_items)], *sch_mode_str; 741cad7c215SGuangbin Huang u8 pg_id, sch_mode, weight, pri_bit_map, i, j; 742cad7c215SGuangbin Huang char content[HCLGE_DBG_TM_INFO_LEN]; 743cad7c215SGuangbin Huang int pos = 0; 74496227f4cSliuzhongzhu int ret; 74596227f4cSliuzhongzhu 746c894b51eSArnd Bergmann for (i = 0; i < ARRAY_SIZE(tm_pg_items); i++) { 747c894b51eSArnd Bergmann result[i] = data_str; 748c894b51eSArnd Bergmann data_str += HCLGE_DBG_DATA_STR_LEN; 749c894b51eSArnd Bergmann } 750cad7c215SGuangbin Huang 751cad7c215SGuangbin Huang hclge_dbg_fill_content(content, sizeof(content), tm_pg_items, 752cad7c215SGuangbin Huang NULL, ARRAY_SIZE(tm_pg_items)); 753cad7c215SGuangbin Huang pos += scnprintf(buf + pos, len - pos, "%s", content); 754cad7c215SGuangbin Huang 755cad7c215SGuangbin Huang for (pg_id = 0; pg_id < hdev->tm_info.num_pg; pg_id++) { 756cad7c215SGuangbin Huang ret = hclge_tm_get_pg_to_pri_map(hdev, pg_id, &pri_bit_map); 75796227f4cSliuzhongzhu if (ret) 758cad7c215SGuangbin Huang return ret; 75996227f4cSliuzhongzhu 760cad7c215SGuangbin Huang ret = hclge_tm_get_pg_sch_mode(hdev, pg_id, &sch_mode); 76196227f4cSliuzhongzhu if (ret) 762cad7c215SGuangbin Huang return ret; 76396227f4cSliuzhongzhu 764cad7c215SGuangbin Huang ret = hclge_tm_get_pg_weight(hdev, pg_id, &weight); 76596227f4cSliuzhongzhu if (ret) 766cad7c215SGuangbin Huang return ret; 76796227f4cSliuzhongzhu 768cad7c215SGuangbin Huang ret = hclge_tm_get_pg_shaper(hdev, pg_id, 769cad7c215SGuangbin Huang HCLGE_OPC_TM_PG_C_SHAPPING, 770cad7c215SGuangbin Huang &c_shaper_para); 77196227f4cSliuzhongzhu if (ret) 772cad7c215SGuangbin Huang return ret; 77396227f4cSliuzhongzhu 774cad7c215SGuangbin Huang ret = hclge_tm_get_pg_shaper(hdev, pg_id, 775cad7c215SGuangbin Huang HCLGE_OPC_TM_PG_P_SHAPPING, 776cad7c215SGuangbin Huang &p_shaper_para); 77796227f4cSliuzhongzhu if (ret) 778cad7c215SGuangbin Huang return ret; 77996227f4cSliuzhongzhu 780cad7c215SGuangbin Huang sch_mode_str = sch_mode & HCLGE_TM_TX_SCHD_DWRR_MSK ? "dwrr" : 781cad7c215SGuangbin Huang "sp"; 78296227f4cSliuzhongzhu 783cad7c215SGuangbin Huang j = 0; 784cad7c215SGuangbin Huang sprintf(result[j++], "%02u", pg_id); 785cad7c215SGuangbin Huang sprintf(result[j++], "0x%02x", pri_bit_map); 786cad7c215SGuangbin Huang sprintf(result[j++], "%4s", sch_mode_str); 787cad7c215SGuangbin Huang sprintf(result[j++], "%3u", weight); 788cad7c215SGuangbin Huang hclge_dbg_fill_shaper_content(&c_shaper_para, result, &j); 789cad7c215SGuangbin Huang hclge_dbg_fill_shaper_content(&p_shaper_para, result, &j); 790cad7c215SGuangbin Huang 791cad7c215SGuangbin Huang hclge_dbg_fill_content(content, sizeof(content), tm_pg_items, 792cad7c215SGuangbin Huang (const char **)result, 793cad7c215SGuangbin Huang ARRAY_SIZE(tm_pg_items)); 794cad7c215SGuangbin Huang pos += scnprintf(buf + pos, len - pos, "%s", content); 795cad7c215SGuangbin Huang } 796cad7c215SGuangbin Huang 797cad7c215SGuangbin Huang return 0; 798cad7c215SGuangbin Huang } 799cad7c215SGuangbin Huang 800c894b51eSArnd Bergmann static int hclge_dbg_dump_tm_pg(struct hclge_dev *hdev, char *buf, int len) 801c894b51eSArnd Bergmann { 802c894b51eSArnd Bergmann char *data_str; 803c894b51eSArnd Bergmann int ret; 804c894b51eSArnd Bergmann 805c894b51eSArnd Bergmann data_str = kcalloc(ARRAY_SIZE(tm_pg_items), 806c894b51eSArnd Bergmann HCLGE_DBG_DATA_STR_LEN, GFP_KERNEL); 807c894b51eSArnd Bergmann if (!data_str) 808c894b51eSArnd Bergmann return -ENOMEM; 809c894b51eSArnd Bergmann 810c894b51eSArnd Bergmann ret = __hclge_dbg_dump_tm_pg(hdev, data_str, buf, len); 811c894b51eSArnd Bergmann 812c894b51eSArnd Bergmann kfree(data_str); 813c894b51eSArnd Bergmann 814c894b51eSArnd Bergmann return ret; 815c894b51eSArnd Bergmann } 816c894b51eSArnd Bergmann 817cad7c215SGuangbin Huang static int hclge_dbg_dump_tm_port(struct hclge_dev *hdev, char *buf, int len) 818cad7c215SGuangbin Huang { 819cad7c215SGuangbin Huang struct hclge_tm_shaper_para shaper_para; 820cad7c215SGuangbin Huang int pos = 0; 821cad7c215SGuangbin Huang int ret; 822cad7c215SGuangbin Huang 823cad7c215SGuangbin Huang ret = hclge_tm_get_port_shaper(hdev, &shaper_para); 82496227f4cSliuzhongzhu if (ret) 825cad7c215SGuangbin Huang return ret; 82696227f4cSliuzhongzhu 827cad7c215SGuangbin Huang pos += scnprintf(buf + pos, len - pos, 828cad7c215SGuangbin Huang "IR_B IR_U IR_S BS_B BS_S FLAG RATE(Mbps)\n"); 829cad7c215SGuangbin Huang pos += scnprintf(buf + pos, len - pos, 830cad7c215SGuangbin Huang "%3u %3u %3u %3u %3u %1u %6u\n", 831cad7c215SGuangbin Huang shaper_para.ir_b, shaper_para.ir_u, shaper_para.ir_s, 832cad7c215SGuangbin Huang shaper_para.bs_b, shaper_para.bs_s, shaper_para.flag, 833cad7c215SGuangbin Huang shaper_para.rate); 83496227f4cSliuzhongzhu 835cad7c215SGuangbin Huang return 0; 83696227f4cSliuzhongzhu } 83796227f4cSliuzhongzhu 8387679f28eSGuangbin Huang static int hclge_dbg_dump_tm_bp_qset_map(struct hclge_dev *hdev, u8 tc_id, 8397679f28eSGuangbin Huang char *buf, int len) 84082e00b86Sliuzhongzhu { 8419a5ef4aaSYonglong Liu u32 qset_mapping[HCLGE_BP_EXT_GRP_NUM]; 8427679f28eSGuangbin Huang struct hclge_bp_to_qs_map_cmd *map; 84382e00b86Sliuzhongzhu struct hclge_desc desc; 8447679f28eSGuangbin Huang int pos = 0; 8457679f28eSGuangbin Huang u8 group_id; 8467679f28eSGuangbin Huang u8 grp_num; 8477679f28eSGuangbin Huang u16 i = 0; 8480256844dSYonglong Liu int ret; 8493f0f3253SYufeng Mo 8509a5ef4aaSYonglong Liu grp_num = hdev->num_tqps <= HCLGE_TQP_MAX_SIZE_DEV_V2 ? 8519a5ef4aaSYonglong Liu HCLGE_BP_GRP_NUM : HCLGE_BP_EXT_GRP_NUM; 8527679f28eSGuangbin Huang map = (struct hclge_bp_to_qs_map_cmd *)desc.data; 8539a5ef4aaSYonglong Liu for (group_id = 0; group_id < grp_num; group_id++) { 8547679f28eSGuangbin Huang hclge_cmd_setup_basic_desc(&desc, 8557679f28eSGuangbin Huang HCLGE_OPC_TM_BP_TO_QSET_MAPPING, 8567679f28eSGuangbin Huang true); 8577679f28eSGuangbin Huang map->tc_id = tc_id; 8587679f28eSGuangbin Huang map->qs_group_id = group_id; 85982e00b86Sliuzhongzhu ret = hclge_cmd_send(&hdev->hw, &desc, 1); 8607679f28eSGuangbin Huang if (ret) { 8617679f28eSGuangbin Huang dev_err(&hdev->pdev->dev, 8627679f28eSGuangbin Huang "failed to get bp to qset map, ret = %d\n", 8637679f28eSGuangbin Huang ret); 8647679f28eSGuangbin Huang return ret; 86582e00b86Sliuzhongzhu } 86682e00b86Sliuzhongzhu 8677679f28eSGuangbin Huang qset_mapping[group_id] = le32_to_cpu(map->qs_bit_map); 8687679f28eSGuangbin Huang } 86982e00b86Sliuzhongzhu 8707679f28eSGuangbin Huang pos += scnprintf(buf + pos, len - pos, "INDEX | TM BP QSET MAPPING:\n"); 8719a5ef4aaSYonglong Liu for (group_id = 0; group_id < grp_num / 8; group_id++) { 8727679f28eSGuangbin Huang pos += scnprintf(buf + pos, len - pos, 87382e00b86Sliuzhongzhu "%04d | %08x:%08x:%08x:%08x:%08x:%08x:%08x:%08x\n", 8747679f28eSGuangbin Huang group_id * 256, qset_mapping[i + 7], 8757679f28eSGuangbin Huang qset_mapping[i + 6], qset_mapping[i + 5], 8767679f28eSGuangbin Huang qset_mapping[i + 4], qset_mapping[i + 3], 8777679f28eSGuangbin Huang qset_mapping[i + 2], qset_mapping[i + 1], 87896b8e878SHuazhong Tan qset_mapping[i]); 87982e00b86Sliuzhongzhu i += 8; 88082e00b86Sliuzhongzhu } 88182e00b86Sliuzhongzhu 8827679f28eSGuangbin Huang return pos; 8837679f28eSGuangbin Huang } 88482e00b86Sliuzhongzhu 8857679f28eSGuangbin Huang static int hclge_dbg_dump_tm_map(struct hclge_dev *hdev, char *buf, int len) 8867679f28eSGuangbin Huang { 8877679f28eSGuangbin Huang u16 queue_id; 8887679f28eSGuangbin Huang u16 qset_id; 8897679f28eSGuangbin Huang u8 link_vld; 8907679f28eSGuangbin Huang int pos = 0; 8917679f28eSGuangbin Huang u8 pri_id; 8927679f28eSGuangbin Huang u8 tc_id; 8937679f28eSGuangbin Huang int ret; 8947679f28eSGuangbin Huang 8957679f28eSGuangbin Huang for (queue_id = 0; queue_id < hdev->num_tqps; queue_id++) { 8967679f28eSGuangbin Huang ret = hclge_tm_get_q_to_qs_map(hdev, queue_id, &qset_id); 8977679f28eSGuangbin Huang if (ret) 8987679f28eSGuangbin Huang return ret; 8997679f28eSGuangbin Huang 9007679f28eSGuangbin Huang ret = hclge_tm_get_qset_map_pri(hdev, qset_id, &pri_id, 9017679f28eSGuangbin Huang &link_vld); 9027679f28eSGuangbin Huang if (ret) 9037679f28eSGuangbin Huang return ret; 9047679f28eSGuangbin Huang 9057679f28eSGuangbin Huang ret = hclge_tm_get_q_to_tc(hdev, queue_id, &tc_id); 9067679f28eSGuangbin Huang if (ret) 9077679f28eSGuangbin Huang return ret; 9087679f28eSGuangbin Huang 9097679f28eSGuangbin Huang pos += scnprintf(buf + pos, len - pos, 9107679f28eSGuangbin Huang "QUEUE_ID QSET_ID PRI_ID TC_ID\n"); 9117679f28eSGuangbin Huang pos += scnprintf(buf + pos, len - pos, 9127679f28eSGuangbin Huang "%04u %4u %3u %2u\n", 9137679f28eSGuangbin Huang queue_id, qset_id, pri_id, tc_id); 9147679f28eSGuangbin Huang 9157679f28eSGuangbin Huang if (!hnae3_dev_dcb_supported(hdev)) 9167679f28eSGuangbin Huang continue; 9177679f28eSGuangbin Huang 9187679f28eSGuangbin Huang ret = hclge_dbg_dump_tm_bp_qset_map(hdev, tc_id, buf + pos, 9197679f28eSGuangbin Huang len - pos); 9207679f28eSGuangbin Huang if (ret < 0) 9217679f28eSGuangbin Huang return ret; 9227679f28eSGuangbin Huang pos += ret; 9237679f28eSGuangbin Huang 9247679f28eSGuangbin Huang pos += scnprintf(buf + pos, len - pos, "\n"); 9257679f28eSGuangbin Huang } 9267679f28eSGuangbin Huang 9277679f28eSGuangbin Huang return 0; 92882e00b86Sliuzhongzhu } 92982e00b86Sliuzhongzhu 93004987ca1SGuangbin Huang static int hclge_dbg_dump_tm_nodes(struct hclge_dev *hdev, char *buf, int len) 93104987ca1SGuangbin Huang { 93204987ca1SGuangbin Huang struct hclge_tm_nodes_cmd *nodes; 93304987ca1SGuangbin Huang struct hclge_desc desc; 93404987ca1SGuangbin Huang int pos = 0; 93504987ca1SGuangbin Huang int ret; 93604987ca1SGuangbin Huang 93704987ca1SGuangbin Huang hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_TM_NODES, true); 93804987ca1SGuangbin Huang ret = hclge_cmd_send(&hdev->hw, &desc, 1); 93904987ca1SGuangbin Huang if (ret) { 94004987ca1SGuangbin Huang dev_err(&hdev->pdev->dev, 94104987ca1SGuangbin Huang "failed to dump tm nodes, ret = %d\n", ret); 94204987ca1SGuangbin Huang return ret; 94304987ca1SGuangbin Huang } 94404987ca1SGuangbin Huang 94504987ca1SGuangbin Huang nodes = (struct hclge_tm_nodes_cmd *)desc.data; 94604987ca1SGuangbin Huang 94704987ca1SGuangbin Huang pos += scnprintf(buf + pos, len - pos, " BASE_ID MAX_NUM\n"); 94804987ca1SGuangbin Huang pos += scnprintf(buf + pos, len - pos, "PG %4u %4u\n", 94904987ca1SGuangbin Huang nodes->pg_base_id, nodes->pg_num); 95004987ca1SGuangbin Huang pos += scnprintf(buf + pos, len - pos, "PRI %4u %4u\n", 95104987ca1SGuangbin Huang nodes->pri_base_id, nodes->pri_num); 95204987ca1SGuangbin Huang pos += scnprintf(buf + pos, len - pos, "QSET %4u %4u\n", 95304987ca1SGuangbin Huang le16_to_cpu(nodes->qset_base_id), 95404987ca1SGuangbin Huang le16_to_cpu(nodes->qset_num)); 95504987ca1SGuangbin Huang pos += scnprintf(buf + pos, len - pos, "QUEUE %4u %4u\n", 95604987ca1SGuangbin Huang le16_to_cpu(nodes->queue_base_id), 95704987ca1SGuangbin Huang le16_to_cpu(nodes->queue_num)); 95804987ca1SGuangbin Huang 95904987ca1SGuangbin Huang return 0; 96004987ca1SGuangbin Huang } 96104987ca1SGuangbin Huang 96204d96139SGuangbin Huang static const struct hclge_dbg_item tm_pri_items[] = { 96304d96139SGuangbin Huang { "ID", 4 }, 96404d96139SGuangbin Huang { "MODE", 2 }, 96504d96139SGuangbin Huang { "DWRR", 2 }, 96604d96139SGuangbin Huang { "C_IR_B", 2 }, 96704d96139SGuangbin Huang { "C_IR_U", 2 }, 96804d96139SGuangbin Huang { "C_IR_S", 2 }, 96904d96139SGuangbin Huang { "C_BS_B", 2 }, 97004d96139SGuangbin Huang { "C_BS_S", 2 }, 97104d96139SGuangbin Huang { "C_FLAG", 2 }, 97204d96139SGuangbin Huang { "C_RATE(Mbps)", 2 }, 97304d96139SGuangbin Huang { "P_IR_B", 2 }, 97404d96139SGuangbin Huang { "P_IR_U", 2 }, 97504d96139SGuangbin Huang { "P_IR_S", 2 }, 97604d96139SGuangbin Huang { "P_BS_B", 2 }, 97704d96139SGuangbin Huang { "P_BS_S", 2 }, 97804d96139SGuangbin Huang { "P_FLAG", 2 }, 97904d96139SGuangbin Huang { "P_RATE(Mbps)", 0 } 98004d96139SGuangbin Huang }; 98104d96139SGuangbin Huang 98204987ca1SGuangbin Huang static int hclge_dbg_dump_tm_pri(struct hclge_dev *hdev, char *buf, int len) 98304987ca1SGuangbin Huang { 98404d96139SGuangbin Huang char data_str[ARRAY_SIZE(tm_pri_items)][HCLGE_DBG_DATA_STR_LEN]; 98504d96139SGuangbin Huang struct hclge_tm_shaper_para c_shaper_para, p_shaper_para; 98604d96139SGuangbin Huang char *result[ARRAY_SIZE(tm_pri_items)], *sch_mode_str; 98704d96139SGuangbin Huang char content[HCLGE_DBG_TM_INFO_LEN]; 98804d96139SGuangbin Huang u8 pri_num, sch_mode, weight, i, j; 98904d96139SGuangbin Huang int pos, ret; 99004987ca1SGuangbin Huang 99104987ca1SGuangbin Huang ret = hclge_tm_get_pri_num(hdev, &pri_num); 99204987ca1SGuangbin Huang if (ret) 99304987ca1SGuangbin Huang return ret; 99404987ca1SGuangbin Huang 99504d96139SGuangbin Huang for (i = 0; i < ARRAY_SIZE(tm_pri_items); i++) 99604d96139SGuangbin Huang result[i] = &data_str[i][0]; 99704d96139SGuangbin Huang 99804d96139SGuangbin Huang hclge_dbg_fill_content(content, sizeof(content), tm_pri_items, 99904d96139SGuangbin Huang NULL, ARRAY_SIZE(tm_pri_items)); 100004d96139SGuangbin Huang pos = scnprintf(buf, len, "%s", content); 100104987ca1SGuangbin Huang 100204987ca1SGuangbin Huang for (i = 0; i < pri_num; i++) { 100304987ca1SGuangbin Huang ret = hclge_tm_get_pri_sch_mode(hdev, i, &sch_mode); 100404987ca1SGuangbin Huang if (ret) 100504987ca1SGuangbin Huang return ret; 100604987ca1SGuangbin Huang 100704987ca1SGuangbin Huang ret = hclge_tm_get_pri_weight(hdev, i, &weight); 100804987ca1SGuangbin Huang if (ret) 100904987ca1SGuangbin Huang return ret; 101004987ca1SGuangbin Huang 101104987ca1SGuangbin Huang ret = hclge_tm_get_pri_shaper(hdev, i, 101204987ca1SGuangbin Huang HCLGE_OPC_TM_PRI_C_SHAPPING, 101304987ca1SGuangbin Huang &c_shaper_para); 101404987ca1SGuangbin Huang if (ret) 101504987ca1SGuangbin Huang return ret; 101604987ca1SGuangbin Huang 101704987ca1SGuangbin Huang ret = hclge_tm_get_pri_shaper(hdev, i, 101804987ca1SGuangbin Huang HCLGE_OPC_TM_PRI_P_SHAPPING, 101904987ca1SGuangbin Huang &p_shaper_para); 102004987ca1SGuangbin Huang if (ret) 102104987ca1SGuangbin Huang return ret; 102204987ca1SGuangbin Huang 102304987ca1SGuangbin Huang sch_mode_str = sch_mode & HCLGE_TM_TX_SCHD_DWRR_MSK ? "dwrr" : 102404987ca1SGuangbin Huang "sp"; 102504987ca1SGuangbin Huang 102604d96139SGuangbin Huang j = 0; 102704d96139SGuangbin Huang sprintf(result[j++], "%04u", i); 102804d96139SGuangbin Huang sprintf(result[j++], "%4s", sch_mode_str); 102904d96139SGuangbin Huang sprintf(result[j++], "%3u", weight); 103004d96139SGuangbin Huang hclge_dbg_fill_shaper_content(&c_shaper_para, result, &j); 103104d96139SGuangbin Huang hclge_dbg_fill_shaper_content(&p_shaper_para, result, &j); 103204d96139SGuangbin Huang hclge_dbg_fill_content(content, sizeof(content), tm_pri_items, 103304d96139SGuangbin Huang (const char **)result, 103404d96139SGuangbin Huang ARRAY_SIZE(tm_pri_items)); 103504d96139SGuangbin Huang pos += scnprintf(buf + pos, len - pos, "%s", content); 103604987ca1SGuangbin Huang } 103704987ca1SGuangbin Huang 103804987ca1SGuangbin Huang return 0; 103904987ca1SGuangbin Huang } 104004987ca1SGuangbin Huang 1041484e1ed1SGuangbin Huang static const struct hclge_dbg_item tm_qset_items[] = { 1042484e1ed1SGuangbin Huang { "ID", 4 }, 1043484e1ed1SGuangbin Huang { "MAP_PRI", 2 }, 1044484e1ed1SGuangbin Huang { "LINK_VLD", 2 }, 1045484e1ed1SGuangbin Huang { "MODE", 2 }, 1046484e1ed1SGuangbin Huang { "DWRR", 2 }, 1047484e1ed1SGuangbin Huang { "IR_B", 2 }, 1048484e1ed1SGuangbin Huang { "IR_U", 2 }, 1049484e1ed1SGuangbin Huang { "IR_S", 2 }, 1050484e1ed1SGuangbin Huang { "BS_B", 2 }, 1051484e1ed1SGuangbin Huang { "BS_S", 2 }, 1052484e1ed1SGuangbin Huang { "FLAG", 2 }, 1053484e1ed1SGuangbin Huang { "RATE(Mbps)", 0 } 1054484e1ed1SGuangbin Huang }; 1055484e1ed1SGuangbin Huang 105604987ca1SGuangbin Huang static int hclge_dbg_dump_tm_qset(struct hclge_dev *hdev, char *buf, int len) 105704987ca1SGuangbin Huang { 1058484e1ed1SGuangbin Huang char data_str[ARRAY_SIZE(tm_qset_items)][HCLGE_DBG_DATA_STR_LEN]; 1059484e1ed1SGuangbin Huang char *result[ARRAY_SIZE(tm_qset_items)], *sch_mode_str; 106004987ca1SGuangbin Huang u8 priority, link_vld, sch_mode, weight; 1061484e1ed1SGuangbin Huang struct hclge_tm_shaper_para shaper_para; 1062484e1ed1SGuangbin Huang char content[HCLGE_DBG_TM_INFO_LEN]; 1063484e1ed1SGuangbin Huang u16 qset_num, i; 106404987ca1SGuangbin Huang int ret, pos; 1065484e1ed1SGuangbin Huang u8 j; 106604987ca1SGuangbin Huang 106704987ca1SGuangbin Huang ret = hclge_tm_get_qset_num(hdev, &qset_num); 106804987ca1SGuangbin Huang if (ret) 106904987ca1SGuangbin Huang return ret; 107004987ca1SGuangbin Huang 1071484e1ed1SGuangbin Huang for (i = 0; i < ARRAY_SIZE(tm_qset_items); i++) 1072484e1ed1SGuangbin Huang result[i] = &data_str[i][0]; 1073484e1ed1SGuangbin Huang 1074484e1ed1SGuangbin Huang hclge_dbg_fill_content(content, sizeof(content), tm_qset_items, 1075484e1ed1SGuangbin Huang NULL, ARRAY_SIZE(tm_qset_items)); 1076484e1ed1SGuangbin Huang pos = scnprintf(buf, len, "%s", content); 107704987ca1SGuangbin Huang 107804987ca1SGuangbin Huang for (i = 0; i < qset_num; i++) { 107904987ca1SGuangbin Huang ret = hclge_tm_get_qset_map_pri(hdev, i, &priority, &link_vld); 108004987ca1SGuangbin Huang if (ret) 108104987ca1SGuangbin Huang return ret; 108204987ca1SGuangbin Huang 108304987ca1SGuangbin Huang ret = hclge_tm_get_qset_sch_mode(hdev, i, &sch_mode); 108404987ca1SGuangbin Huang if (ret) 108504987ca1SGuangbin Huang return ret; 108604987ca1SGuangbin Huang 108704987ca1SGuangbin Huang ret = hclge_tm_get_qset_weight(hdev, i, &weight); 108804987ca1SGuangbin Huang if (ret) 108904987ca1SGuangbin Huang return ret; 109004987ca1SGuangbin Huang 1091484e1ed1SGuangbin Huang ret = hclge_tm_get_qset_shaper(hdev, i, &shaper_para); 1092484e1ed1SGuangbin Huang if (ret) 1093484e1ed1SGuangbin Huang return ret; 1094484e1ed1SGuangbin Huang 109504987ca1SGuangbin Huang sch_mode_str = sch_mode & HCLGE_TM_TX_SCHD_DWRR_MSK ? "dwrr" : 109604987ca1SGuangbin Huang "sp"; 1097484e1ed1SGuangbin Huang 1098484e1ed1SGuangbin Huang j = 0; 1099484e1ed1SGuangbin Huang sprintf(result[j++], "%04u", i); 1100484e1ed1SGuangbin Huang sprintf(result[j++], "%4u", priority); 1101484e1ed1SGuangbin Huang sprintf(result[j++], "%4u", link_vld); 1102484e1ed1SGuangbin Huang sprintf(result[j++], "%4s", sch_mode_str); 1103484e1ed1SGuangbin Huang sprintf(result[j++], "%3u", weight); 1104484e1ed1SGuangbin Huang hclge_dbg_fill_shaper_content(&shaper_para, result, &j); 1105484e1ed1SGuangbin Huang 1106484e1ed1SGuangbin Huang hclge_dbg_fill_content(content, sizeof(content), tm_qset_items, 1107484e1ed1SGuangbin Huang (const char **)result, 1108484e1ed1SGuangbin Huang ARRAY_SIZE(tm_qset_items)); 1109484e1ed1SGuangbin Huang pos += scnprintf(buf + pos, len - pos, "%s", content); 111004987ca1SGuangbin Huang } 111104987ca1SGuangbin Huang 111204987ca1SGuangbin Huang return 0; 111304987ca1SGuangbin Huang } 111404987ca1SGuangbin Huang 11156571ec2eSGuangbin Huang static int hclge_dbg_dump_qos_pause_cfg(struct hclge_dev *hdev, char *buf, 11166571ec2eSGuangbin Huang int len) 1117d958919dSliuzhongzhu { 1118d958919dSliuzhongzhu struct hclge_cfg_pause_param_cmd *pause_param; 1119d958919dSliuzhongzhu struct hclge_desc desc; 11206571ec2eSGuangbin Huang int pos = 0; 1121d958919dSliuzhongzhu int ret; 1122d958919dSliuzhongzhu 1123d958919dSliuzhongzhu hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_CFG_MAC_PARA, true); 1124d958919dSliuzhongzhu ret = hclge_cmd_send(&hdev->hw, &desc, 1); 1125d958919dSliuzhongzhu if (ret) { 11266571ec2eSGuangbin Huang dev_err(&hdev->pdev->dev, 11276571ec2eSGuangbin Huang "failed to dump qos pause, ret = %d\n", ret); 11286571ec2eSGuangbin Huang return ret; 1129d958919dSliuzhongzhu } 1130d958919dSliuzhongzhu 1131d958919dSliuzhongzhu pause_param = (struct hclge_cfg_pause_param_cmd *)desc.data; 11326571ec2eSGuangbin Huang 11336571ec2eSGuangbin Huang pos += scnprintf(buf + pos, len - pos, "pause_trans_gap: 0x%x\n", 1134d958919dSliuzhongzhu pause_param->pause_trans_gap); 11356571ec2eSGuangbin Huang pos += scnprintf(buf + pos, len - pos, "pause_trans_time: 0x%x\n", 113639edaf24SGuojia Liao le16_to_cpu(pause_param->pause_trans_time)); 11376571ec2eSGuangbin Huang return 0; 1138d958919dSliuzhongzhu } 1139d958919dSliuzhongzhu 1140fddc02ebSGuangbin Huang #define HCLGE_DBG_TC_MASK 0x0F 1141fddc02ebSGuangbin Huang 114228d3badaSGuangbin Huang static int hclge_dbg_dump_qos_pri_map(struct hclge_dev *hdev, char *buf, 114328d3badaSGuangbin Huang int len) 11446fc22440Sliuzhongzhu { 114528d3badaSGuangbin Huang #define HCLGE_DBG_TC_BIT_WIDTH 4 114628d3badaSGuangbin Huang 11476fc22440Sliuzhongzhu struct hclge_qos_pri_map_cmd *pri_map; 11486fc22440Sliuzhongzhu struct hclge_desc desc; 114928d3badaSGuangbin Huang int pos = 0; 115028d3badaSGuangbin Huang u8 *pri_tc; 115128d3badaSGuangbin Huang u8 tc, i; 11526fc22440Sliuzhongzhu int ret; 11536fc22440Sliuzhongzhu 11546fc22440Sliuzhongzhu hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_PRI_TO_TC_MAPPING, true); 11556fc22440Sliuzhongzhu ret = hclge_cmd_send(&hdev->hw, &desc, 1); 11566fc22440Sliuzhongzhu if (ret) { 11576fc22440Sliuzhongzhu dev_err(&hdev->pdev->dev, 115828d3badaSGuangbin Huang "failed to dump qos pri map, ret = %d\n", ret); 115928d3badaSGuangbin Huang return ret; 11606fc22440Sliuzhongzhu } 11616fc22440Sliuzhongzhu 11626fc22440Sliuzhongzhu pri_map = (struct hclge_qos_pri_map_cmd *)desc.data; 116328d3badaSGuangbin Huang 116428d3badaSGuangbin Huang pos += scnprintf(buf + pos, len - pos, "vlan_to_pri: 0x%x\n", 116528d3badaSGuangbin Huang pri_map->vlan_pri); 116628d3badaSGuangbin Huang pos += scnprintf(buf + pos, len - pos, "PRI TC\n"); 116728d3badaSGuangbin Huang 116828d3badaSGuangbin Huang pri_tc = (u8 *)pri_map; 116928d3badaSGuangbin Huang for (i = 0; i < HNAE3_MAX_TC; i++) { 117028d3badaSGuangbin Huang tc = pri_tc[i >> 1] >> ((i & 1) * HCLGE_DBG_TC_BIT_WIDTH); 117128d3badaSGuangbin Huang tc &= HCLGE_DBG_TC_MASK; 117228d3badaSGuangbin Huang pos += scnprintf(buf + pos, len - pos, "%u %u\n", i, tc); 117328d3badaSGuangbin Huang } 117428d3badaSGuangbin Huang 117528d3badaSGuangbin Huang return 0; 11766fc22440Sliuzhongzhu } 11776fc22440Sliuzhongzhu 1178fddc02ebSGuangbin Huang static int hclge_dbg_dump_qos_dscp_map(struct hclge_dev *hdev, char *buf, 1179fddc02ebSGuangbin Huang int len) 1180fddc02ebSGuangbin Huang { 1181dfea275eSGuangbin Huang struct hnae3_knic_private_info *kinfo = &hdev->vport[0].nic.kinfo; 1182fddc02ebSGuangbin Huang struct hclge_desc desc[HCLGE_DSCP_MAP_TC_BD_NUM]; 1183fddc02ebSGuangbin Huang u8 *req0 = (u8 *)desc[0].data; 1184fddc02ebSGuangbin Huang u8 *req1 = (u8 *)desc[1].data; 1185dfea275eSGuangbin Huang u8 dscp_tc[HNAE3_MAX_DSCP]; 1186fddc02ebSGuangbin Huang int pos, ret; 1187fddc02ebSGuangbin Huang u8 i, j; 1188fddc02ebSGuangbin Huang 1189fddc02ebSGuangbin Huang pos = scnprintf(buf, len, "tc map mode: %s\n", 1190dfea275eSGuangbin Huang tc_map_mode_str[kinfo->tc_map_mode]); 1191fddc02ebSGuangbin Huang 1192dfea275eSGuangbin Huang if (kinfo->tc_map_mode != HNAE3_TC_MAP_MODE_DSCP) 1193fddc02ebSGuangbin Huang return 0; 1194fddc02ebSGuangbin Huang 1195fddc02ebSGuangbin Huang hclge_cmd_setup_basic_desc(&desc[0], HCLGE_OPC_QOS_MAP, true); 1196fddc02ebSGuangbin Huang desc[0].flag |= cpu_to_le16(HCLGE_COMM_CMD_FLAG_NEXT); 1197fddc02ebSGuangbin Huang hclge_cmd_setup_basic_desc(&desc[1], HCLGE_OPC_QOS_MAP, true); 1198fddc02ebSGuangbin Huang ret = hclge_cmd_send(&hdev->hw, desc, HCLGE_DSCP_MAP_TC_BD_NUM); 1199fddc02ebSGuangbin Huang if (ret) { 1200fddc02ebSGuangbin Huang dev_err(&hdev->pdev->dev, 1201fddc02ebSGuangbin Huang "failed to dump qos dscp map, ret = %d\n", ret); 1202fddc02ebSGuangbin Huang return ret; 1203fddc02ebSGuangbin Huang } 1204fddc02ebSGuangbin Huang 1205fddc02ebSGuangbin Huang pos += scnprintf(buf + pos, len - pos, "\nDSCP PRIO TC\n"); 1206fddc02ebSGuangbin Huang 1207fddc02ebSGuangbin Huang /* The low 32 dscp setting use bd0, high 32 dscp setting use bd1 */ 1208dfea275eSGuangbin Huang for (i = 0; i < HNAE3_MAX_DSCP / HCLGE_DSCP_MAP_TC_BD_NUM; i++) { 1209dfea275eSGuangbin Huang j = i + HNAE3_MAX_DSCP / HCLGE_DSCP_MAP_TC_BD_NUM; 1210fddc02ebSGuangbin Huang /* Each dscp setting has 4 bits, so each byte saves two dscp 1211fddc02ebSGuangbin Huang * setting 1212fddc02ebSGuangbin Huang */ 1213fddc02ebSGuangbin Huang dscp_tc[i] = req0[i >> 1] >> HCLGE_DSCP_TC_SHIFT(i); 1214fddc02ebSGuangbin Huang dscp_tc[j] = req1[i >> 1] >> HCLGE_DSCP_TC_SHIFT(i); 1215fddc02ebSGuangbin Huang dscp_tc[i] &= HCLGE_DBG_TC_MASK; 1216fddc02ebSGuangbin Huang dscp_tc[j] &= HCLGE_DBG_TC_MASK; 1217fddc02ebSGuangbin Huang } 1218fddc02ebSGuangbin Huang 1219dfea275eSGuangbin Huang for (i = 0; i < HNAE3_MAX_DSCP; i++) { 1220dfea275eSGuangbin Huang if (kinfo->dscp_prio[i] == HNAE3_PRIO_ID_INVALID) 1221fddc02ebSGuangbin Huang continue; 1222fddc02ebSGuangbin Huang 1223fddc02ebSGuangbin Huang pos += scnprintf(buf + pos, len - pos, " %2u %u %u\n", 1224dfea275eSGuangbin Huang i, kinfo->dscp_prio[i], dscp_tc[i]); 1225fddc02ebSGuangbin Huang } 1226fddc02ebSGuangbin Huang 1227fddc02ebSGuangbin Huang return 0; 1228fddc02ebSGuangbin Huang } 1229fddc02ebSGuangbin Huang 123095b19586SGuangbin Huang static int hclge_dbg_dump_tx_buf_cfg(struct hclge_dev *hdev, char *buf, int len) 12317d9d7f88Sliuzhongzhu { 12327d9d7f88Sliuzhongzhu struct hclge_tx_buff_alloc_cmd *tx_buf_cmd; 1233b3712fa7SJian Shen struct hclge_desc desc; 123495b19586SGuangbin Huang int pos = 0; 12357d9d7f88Sliuzhongzhu int i, ret; 12367d9d7f88Sliuzhongzhu 1237b3712fa7SJian Shen hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_TX_BUFF_ALLOC, true); 1238b3712fa7SJian Shen ret = hclge_cmd_send(&hdev->hw, &desc, 1); 123995b19586SGuangbin Huang if (ret) { 124095b19586SGuangbin Huang dev_err(&hdev->pdev->dev, 124195b19586SGuangbin Huang "failed to dump tx buf, ret = %d\n", ret); 1242b3712fa7SJian Shen return ret; 1243b3712fa7SJian Shen } 1244b3712fa7SJian Shen 124595b19586SGuangbin Huang tx_buf_cmd = (struct hclge_tx_buff_alloc_cmd *)desc.data; 124695b19586SGuangbin Huang for (i = 0; i < HCLGE_MAX_TC_NUM; i++) 124795b19586SGuangbin Huang pos += scnprintf(buf + pos, len - pos, 124895b19586SGuangbin Huang "tx_packet_buf_tc_%d: 0x%x\n", i, 124995b19586SGuangbin Huang le16_to_cpu(tx_buf_cmd->tx_pkt_buff[i])); 125095b19586SGuangbin Huang 125195b19586SGuangbin Huang return pos; 125295b19586SGuangbin Huang } 125395b19586SGuangbin Huang 125495b19586SGuangbin Huang static int hclge_dbg_dump_rx_priv_buf_cfg(struct hclge_dev *hdev, char *buf, 125595b19586SGuangbin Huang int len) 1256b3712fa7SJian Shen { 1257b3712fa7SJian Shen struct hclge_rx_priv_buff_cmd *rx_buf_cmd; 1258b3712fa7SJian Shen struct hclge_desc desc; 125995b19586SGuangbin Huang int pos = 0; 1260b3712fa7SJian Shen int i, ret; 1261b3712fa7SJian Shen 1262b3712fa7SJian Shen hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_RX_PRIV_BUFF_ALLOC, true); 1263b3712fa7SJian Shen ret = hclge_cmd_send(&hdev->hw, &desc, 1); 126495b19586SGuangbin Huang if (ret) { 126595b19586SGuangbin Huang dev_err(&hdev->pdev->dev, 126695b19586SGuangbin Huang "failed to dump rx priv buf, ret = %d\n", ret); 1267b3712fa7SJian Shen return ret; 1268b3712fa7SJian Shen } 12693f0f3253SYufeng Mo 127095b19586SGuangbin Huang pos += scnprintf(buf + pos, len - pos, "\n"); 127195b19586SGuangbin Huang 127295b19586SGuangbin Huang rx_buf_cmd = (struct hclge_rx_priv_buff_cmd *)desc.data; 127395b19586SGuangbin Huang for (i = 0; i < HCLGE_MAX_TC_NUM; i++) 127495b19586SGuangbin Huang pos += scnprintf(buf + pos, len - pos, 127595b19586SGuangbin Huang "rx_packet_buf_tc_%d: 0x%x\n", i, 127695b19586SGuangbin Huang le16_to_cpu(rx_buf_cmd->buf_num[i])); 127795b19586SGuangbin Huang 127895b19586SGuangbin Huang pos += scnprintf(buf + pos, len - pos, "rx_share_buf: 0x%x\n", 127995b19586SGuangbin Huang le16_to_cpu(rx_buf_cmd->shared_buf)); 128095b19586SGuangbin Huang 128195b19586SGuangbin Huang return pos; 128295b19586SGuangbin Huang } 128395b19586SGuangbin Huang 128495b19586SGuangbin Huang static int hclge_dbg_dump_rx_common_wl_cfg(struct hclge_dev *hdev, char *buf, 128595b19586SGuangbin Huang int len) 1286b3712fa7SJian Shen { 1287b3712fa7SJian Shen struct hclge_rx_com_wl *rx_com_wl; 1288b3712fa7SJian Shen struct hclge_desc desc; 128995b19586SGuangbin Huang int pos = 0; 1290b3712fa7SJian Shen int ret; 1291b3712fa7SJian Shen 1292b3712fa7SJian Shen hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_RX_COM_WL_ALLOC, true); 1293b3712fa7SJian Shen ret = hclge_cmd_send(&hdev->hw, &desc, 1); 129495b19586SGuangbin Huang if (ret) { 129595b19586SGuangbin Huang dev_err(&hdev->pdev->dev, 129695b19586SGuangbin Huang "failed to dump rx common wl, ret = %d\n", ret); 1297b3712fa7SJian Shen return ret; 129895b19586SGuangbin Huang } 1299b3712fa7SJian Shen 1300b3712fa7SJian Shen rx_com_wl = (struct hclge_rx_com_wl *)desc.data; 130195b19586SGuangbin Huang pos += scnprintf(buf + pos, len - pos, "\n"); 130295b19586SGuangbin Huang pos += scnprintf(buf + pos, len - pos, 130395b19586SGuangbin Huang "rx_com_wl: high: 0x%x, low: 0x%x\n", 130439edaf24SGuojia Liao le16_to_cpu(rx_com_wl->com_wl.high), 130539edaf24SGuojia Liao le16_to_cpu(rx_com_wl->com_wl.low)); 13063f0f3253SYufeng Mo 130795b19586SGuangbin Huang return pos; 1308b3712fa7SJian Shen } 13093f0f3253SYufeng Mo 131095b19586SGuangbin Huang static int hclge_dbg_dump_rx_global_pkt_cnt(struct hclge_dev *hdev, char *buf, 131195b19586SGuangbin Huang int len) 1312b3712fa7SJian Shen { 1313b3712fa7SJian Shen struct hclge_rx_com_wl *rx_packet_cnt; 1314b3712fa7SJian Shen struct hclge_desc desc; 131595b19586SGuangbin Huang int pos = 0; 1316b3712fa7SJian Shen int ret; 1317b3712fa7SJian Shen 1318b3712fa7SJian Shen hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_RX_GBL_PKT_CNT, true); 1319b3712fa7SJian Shen ret = hclge_cmd_send(&hdev->hw, &desc, 1); 132095b19586SGuangbin Huang if (ret) { 132195b19586SGuangbin Huang dev_err(&hdev->pdev->dev, 132295b19586SGuangbin Huang "failed to dump rx global pkt cnt, ret = %d\n", ret); 1323b3712fa7SJian Shen return ret; 132495b19586SGuangbin Huang } 1325b3712fa7SJian Shen 1326b3712fa7SJian Shen rx_packet_cnt = (struct hclge_rx_com_wl *)desc.data; 132795b19586SGuangbin Huang pos += scnprintf(buf + pos, len - pos, 13283f0f3253SYufeng Mo "rx_global_packet_cnt: high: 0x%x, low: 0x%x\n", 132939edaf24SGuojia Liao le16_to_cpu(rx_packet_cnt->com_wl.high), 133039edaf24SGuojia Liao le16_to_cpu(rx_packet_cnt->com_wl.low)); 13313f0f3253SYufeng Mo 133295b19586SGuangbin Huang return pos; 13333f0f3253SYufeng Mo } 1334b3712fa7SJian Shen 133595b19586SGuangbin Huang static int hclge_dbg_dump_rx_priv_wl_buf_cfg(struct hclge_dev *hdev, char *buf, 133695b19586SGuangbin Huang int len) 1337b3712fa7SJian Shen { 1338b3712fa7SJian Shen struct hclge_rx_priv_wl_buf *rx_priv_wl; 1339b3712fa7SJian Shen struct hclge_desc desc[2]; 134095b19586SGuangbin Huang int pos = 0; 1341b3712fa7SJian Shen int i, ret; 1342b3712fa7SJian Shen 1343b3712fa7SJian Shen hclge_cmd_setup_basic_desc(&desc[0], HCLGE_OPC_RX_PRIV_WL_ALLOC, true); 1344d3c69a88SJie Wang desc[0].flag |= cpu_to_le16(HCLGE_COMM_CMD_FLAG_NEXT); 1345b3712fa7SJian Shen hclge_cmd_setup_basic_desc(&desc[1], HCLGE_OPC_RX_PRIV_WL_ALLOC, true); 13467d9d7f88Sliuzhongzhu ret = hclge_cmd_send(&hdev->hw, desc, 2); 134795b19586SGuangbin Huang if (ret) { 134895b19586SGuangbin Huang dev_err(&hdev->pdev->dev, 134995b19586SGuangbin Huang "failed to dump rx priv wl buf, ret = %d\n", ret); 1350b3712fa7SJian Shen return ret; 135195b19586SGuangbin Huang } 13527d9d7f88Sliuzhongzhu 13537d9d7f88Sliuzhongzhu rx_priv_wl = (struct hclge_rx_priv_wl_buf *)desc[0].data; 13547d9d7f88Sliuzhongzhu for (i = 0; i < HCLGE_TC_NUM_ONE_DESC; i++) 135595b19586SGuangbin Huang pos += scnprintf(buf + pos, len - pos, 13567d9d7f88Sliuzhongzhu "rx_priv_wl_tc_%d: high: 0x%x, low: 0x%x\n", i, 135739edaf24SGuojia Liao le16_to_cpu(rx_priv_wl->tc_wl[i].high), 135839edaf24SGuojia Liao le16_to_cpu(rx_priv_wl->tc_wl[i].low)); 13597d9d7f88Sliuzhongzhu 13607d9d7f88Sliuzhongzhu rx_priv_wl = (struct hclge_rx_priv_wl_buf *)desc[1].data; 13617d9d7f88Sliuzhongzhu for (i = 0; i < HCLGE_TC_NUM_ONE_DESC; i++) 136295b19586SGuangbin Huang pos += scnprintf(buf + pos, len - pos, 13636f92bfd7SHuazhong Tan "rx_priv_wl_tc_%d: high: 0x%x, low: 0x%x\n", 13646f92bfd7SHuazhong Tan i + HCLGE_TC_NUM_ONE_DESC, 136539edaf24SGuojia Liao le16_to_cpu(rx_priv_wl->tc_wl[i].high), 136639edaf24SGuojia Liao le16_to_cpu(rx_priv_wl->tc_wl[i].low)); 13677d9d7f88Sliuzhongzhu 136895b19586SGuangbin Huang return pos; 1369b3712fa7SJian Shen } 1370b3712fa7SJian Shen 137195b19586SGuangbin Huang static int hclge_dbg_dump_rx_common_threshold_cfg(struct hclge_dev *hdev, 137295b19586SGuangbin Huang char *buf, int len) 1373b3712fa7SJian Shen { 1374b3712fa7SJian Shen struct hclge_rx_com_thrd *rx_com_thrd; 1375b3712fa7SJian Shen struct hclge_desc desc[2]; 137695b19586SGuangbin Huang int pos = 0; 1377b3712fa7SJian Shen int i, ret; 1378b3712fa7SJian Shen 1379b3712fa7SJian Shen hclge_cmd_setup_basic_desc(&desc[0], HCLGE_OPC_RX_COM_THRD_ALLOC, true); 1380d3c69a88SJie Wang desc[0].flag |= cpu_to_le16(HCLGE_COMM_CMD_FLAG_NEXT); 1381b3712fa7SJian Shen hclge_cmd_setup_basic_desc(&desc[1], HCLGE_OPC_RX_COM_THRD_ALLOC, true); 13827d9d7f88Sliuzhongzhu ret = hclge_cmd_send(&hdev->hw, desc, 2); 138395b19586SGuangbin Huang if (ret) { 138495b19586SGuangbin Huang dev_err(&hdev->pdev->dev, 138595b19586SGuangbin Huang "failed to dump rx common threshold, ret = %d\n", ret); 1386b3712fa7SJian Shen return ret; 138795b19586SGuangbin Huang } 13887d9d7f88Sliuzhongzhu 138995b19586SGuangbin Huang pos += scnprintf(buf + pos, len - pos, "\n"); 13907d9d7f88Sliuzhongzhu rx_com_thrd = (struct hclge_rx_com_thrd *)desc[0].data; 13917d9d7f88Sliuzhongzhu for (i = 0; i < HCLGE_TC_NUM_ONE_DESC; i++) 139295b19586SGuangbin Huang pos += scnprintf(buf + pos, len - pos, 13937d9d7f88Sliuzhongzhu "rx_com_thrd_tc_%d: high: 0x%x, low: 0x%x\n", i, 139439edaf24SGuojia Liao le16_to_cpu(rx_com_thrd->com_thrd[i].high), 139539edaf24SGuojia Liao le16_to_cpu(rx_com_thrd->com_thrd[i].low)); 13967d9d7f88Sliuzhongzhu 13977d9d7f88Sliuzhongzhu rx_com_thrd = (struct hclge_rx_com_thrd *)desc[1].data; 13987d9d7f88Sliuzhongzhu for (i = 0; i < HCLGE_TC_NUM_ONE_DESC; i++) 139995b19586SGuangbin Huang pos += scnprintf(buf + pos, len - pos, 14006f92bfd7SHuazhong Tan "rx_com_thrd_tc_%d: high: 0x%x, low: 0x%x\n", 14016f92bfd7SHuazhong Tan i + HCLGE_TC_NUM_ONE_DESC, 140239edaf24SGuojia Liao le16_to_cpu(rx_com_thrd->com_thrd[i].high), 140339edaf24SGuojia Liao le16_to_cpu(rx_com_thrd->com_thrd[i].low)); 1404b3712fa7SJian Shen 140595b19586SGuangbin Huang return pos; 1406b3712fa7SJian Shen } 1407b3712fa7SJian Shen 140895b19586SGuangbin Huang static int hclge_dbg_dump_qos_buf_cfg(struct hclge_dev *hdev, char *buf, 140995b19586SGuangbin Huang int len) 1410b3712fa7SJian Shen { 141195b19586SGuangbin Huang int pos = 0; 1412b3712fa7SJian Shen int ret; 1413b3712fa7SJian Shen 141495b19586SGuangbin Huang ret = hclge_dbg_dump_tx_buf_cfg(hdev, buf + pos, len - pos); 141595b19586SGuangbin Huang if (ret < 0) 141695b19586SGuangbin Huang return ret; 141795b19586SGuangbin Huang pos += ret; 1418b3712fa7SJian Shen 141995b19586SGuangbin Huang ret = hclge_dbg_dump_rx_priv_buf_cfg(hdev, buf + pos, len - pos); 142095b19586SGuangbin Huang if (ret < 0) 142195b19586SGuangbin Huang return ret; 142295b19586SGuangbin Huang pos += ret; 1423b3712fa7SJian Shen 142495b19586SGuangbin Huang ret = hclge_dbg_dump_rx_common_wl_cfg(hdev, buf + pos, len - pos); 142595b19586SGuangbin Huang if (ret < 0) 142695b19586SGuangbin Huang return ret; 142795b19586SGuangbin Huang pos += ret; 1428b3712fa7SJian Shen 142995b19586SGuangbin Huang ret = hclge_dbg_dump_rx_global_pkt_cnt(hdev, buf + pos, len - pos); 143095b19586SGuangbin Huang if (ret < 0) 143195b19586SGuangbin Huang return ret; 143295b19586SGuangbin Huang pos += ret; 1433b3712fa7SJian Shen 143495b19586SGuangbin Huang pos += scnprintf(buf + pos, len - pos, "\n"); 143595b19586SGuangbin Huang if (!hnae3_dev_dcb_supported(hdev)) 143695b19586SGuangbin Huang return 0; 1437b3712fa7SJian Shen 143895b19586SGuangbin Huang ret = hclge_dbg_dump_rx_priv_wl_buf_cfg(hdev, buf + pos, len - pos); 143995b19586SGuangbin Huang if (ret < 0) 144095b19586SGuangbin Huang return ret; 144195b19586SGuangbin Huang pos += ret; 1442b3712fa7SJian Shen 144395b19586SGuangbin Huang ret = hclge_dbg_dump_rx_common_threshold_cfg(hdev, buf + pos, 144495b19586SGuangbin Huang len - pos); 144595b19586SGuangbin Huang if (ret < 0) 144695b19586SGuangbin Huang return ret; 1447b3712fa7SJian Shen 144895b19586SGuangbin Huang return 0; 14497d9d7f88Sliuzhongzhu } 14507d9d7f88Sliuzhongzhu 14518ddfd9c4SYufeng Mo static int hclge_dbg_dump_mng_table(struct hclge_dev *hdev, char *buf, int len) 14527737f1fbSliuzhongzhu { 14537737f1fbSliuzhongzhu struct hclge_mac_ethertype_idx_rd_cmd *req0; 14547737f1fbSliuzhongzhu struct hclge_desc desc; 145572fa4904SGuojia Liao u32 msg_egress_port; 14568ddfd9c4SYufeng Mo int pos = 0; 14577737f1fbSliuzhongzhu int ret, i; 14587737f1fbSliuzhongzhu 14598ddfd9c4SYufeng Mo pos += scnprintf(buf + pos, len - pos, 14608ddfd9c4SYufeng Mo "entry mac_addr mask ether "); 14618ddfd9c4SYufeng Mo pos += scnprintf(buf + pos, len - pos, 14628ddfd9c4SYufeng Mo "mask vlan mask i_map i_dir e_type "); 14638ddfd9c4SYufeng Mo pos += scnprintf(buf + pos, len - pos, "pf_id vf_id q_id drop\n"); 14647737f1fbSliuzhongzhu 14657737f1fbSliuzhongzhu for (i = 0; i < HCLGE_DBG_MNG_TBL_MAX; i++) { 14667737f1fbSliuzhongzhu hclge_cmd_setup_basic_desc(&desc, HCLGE_MAC_ETHERTYPE_IDX_RD, 14677737f1fbSliuzhongzhu true); 14687737f1fbSliuzhongzhu req0 = (struct hclge_mac_ethertype_idx_rd_cmd *)&desc.data; 14697737f1fbSliuzhongzhu req0->index = cpu_to_le16(i); 14707737f1fbSliuzhongzhu 14717737f1fbSliuzhongzhu ret = hclge_cmd_send(&hdev->hw, &desc, 1); 14727737f1fbSliuzhongzhu if (ret) { 14737737f1fbSliuzhongzhu dev_err(&hdev->pdev->dev, 14748ddfd9c4SYufeng Mo "failed to dump manage table, ret = %d\n", ret); 14758ddfd9c4SYufeng Mo return ret; 14767737f1fbSliuzhongzhu } 14777737f1fbSliuzhongzhu 14787737f1fbSliuzhongzhu if (!req0->resp_code) 14797737f1fbSliuzhongzhu continue; 14807737f1fbSliuzhongzhu 14818ddfd9c4SYufeng Mo pos += scnprintf(buf + pos, len - pos, "%02u %pM ", 14828ddfd9c4SYufeng Mo le16_to_cpu(req0->index), req0->mac_addr); 14837737f1fbSliuzhongzhu 14848ddfd9c4SYufeng Mo pos += scnprintf(buf + pos, len - pos, 14858ddfd9c4SYufeng Mo "%x %04x %x %04x ", 14867737f1fbSliuzhongzhu !!(req0->flags & HCLGE_DBG_MNG_MAC_MASK_B), 148772fa4904SGuojia Liao le16_to_cpu(req0->ethter_type), 14887737f1fbSliuzhongzhu !!(req0->flags & HCLGE_DBG_MNG_ETHER_MASK_B), 14898ddfd9c4SYufeng Mo le16_to_cpu(req0->vlan_tag) & 14908ddfd9c4SYufeng Mo HCLGE_DBG_MNG_VLAN_TAG); 14918ddfd9c4SYufeng Mo 14928ddfd9c4SYufeng Mo pos += scnprintf(buf + pos, len - pos, 14938ddfd9c4SYufeng Mo "%x %02x %02x ", 14947737f1fbSliuzhongzhu !!(req0->flags & HCLGE_DBG_MNG_VLAN_MASK_B), 14957737f1fbSliuzhongzhu req0->i_port_bitmap, req0->i_port_direction); 14967737f1fbSliuzhongzhu 149772fa4904SGuojia Liao msg_egress_port = le16_to_cpu(req0->egress_port); 14988ddfd9c4SYufeng Mo pos += scnprintf(buf + pos, len - pos, 14998ddfd9c4SYufeng Mo "%x %x %02x %04x %x\n", 150072fa4904SGuojia Liao !!(msg_egress_port & HCLGE_DBG_MNG_E_TYPE_B), 150172fa4904SGuojia Liao msg_egress_port & HCLGE_DBG_MNG_PF_ID, 150272fa4904SGuojia Liao (msg_egress_port >> 3) & HCLGE_DBG_MNG_VF_ID, 150372fa4904SGuojia Liao le16_to_cpu(req0->egress_queue), 150472fa4904SGuojia Liao !!(msg_egress_port & HCLGE_DBG_MNG_DROP_B)); 15057737f1fbSliuzhongzhu } 15068ddfd9c4SYufeng Mo 15078ddfd9c4SYufeng Mo return 0; 15087737f1fbSliuzhongzhu } 15097737f1fbSliuzhongzhu 1510b5a0b70dSHao Chen #define HCLGE_DBG_TCAM_BUF_SIZE 256 1511b5a0b70dSHao Chen 1512b5a0b70dSHao Chen static int hclge_dbg_fd_tcam_read(struct hclge_dev *hdev, bool sel_x, 1513b5a0b70dSHao Chen char *tcam_buf, 1514b5a0b70dSHao Chen struct hclge_dbg_tcam_msg tcam_msg) 15153c666b58Sliuzhongzhu { 15163c666b58Sliuzhongzhu struct hclge_fd_tcam_config_1_cmd *req1; 15173c666b58Sliuzhongzhu struct hclge_fd_tcam_config_2_cmd *req2; 15183c666b58Sliuzhongzhu struct hclge_fd_tcam_config_3_cmd *req3; 15193c666b58Sliuzhongzhu struct hclge_desc desc[3]; 1520b5a0b70dSHao Chen int pos = 0; 15213c666b58Sliuzhongzhu int ret, i; 15223c666b58Sliuzhongzhu u32 *req; 15233c666b58Sliuzhongzhu 15243c666b58Sliuzhongzhu hclge_cmd_setup_basic_desc(&desc[0], HCLGE_OPC_FD_TCAM_OP, true); 1525d3c69a88SJie Wang desc[0].flag |= cpu_to_le16(HCLGE_COMM_CMD_FLAG_NEXT); 15263c666b58Sliuzhongzhu hclge_cmd_setup_basic_desc(&desc[1], HCLGE_OPC_FD_TCAM_OP, true); 1527d3c69a88SJie Wang desc[1].flag |= cpu_to_le16(HCLGE_COMM_CMD_FLAG_NEXT); 15283c666b58Sliuzhongzhu hclge_cmd_setup_basic_desc(&desc[2], HCLGE_OPC_FD_TCAM_OP, true); 15293c666b58Sliuzhongzhu 15303c666b58Sliuzhongzhu req1 = (struct hclge_fd_tcam_config_1_cmd *)desc[0].data; 15313c666b58Sliuzhongzhu req2 = (struct hclge_fd_tcam_config_2_cmd *)desc[1].data; 15323c666b58Sliuzhongzhu req3 = (struct hclge_fd_tcam_config_3_cmd *)desc[2].data; 15333c666b58Sliuzhongzhu 1534b5a0b70dSHao Chen req1->stage = tcam_msg.stage; 15353c666b58Sliuzhongzhu req1->xy_sel = sel_x ? 1 : 0; 1536b5a0b70dSHao Chen req1->index = cpu_to_le32(tcam_msg.loc); 15373c666b58Sliuzhongzhu 15383c666b58Sliuzhongzhu ret = hclge_cmd_send(&hdev->hw, desc, 3); 15393c666b58Sliuzhongzhu if (ret) 154044b6b883SYufeng Mo return ret; 15413c666b58Sliuzhongzhu 1542b5a0b70dSHao Chen pos += scnprintf(tcam_buf + pos, HCLGE_DBG_TCAM_BUF_SIZE - pos, 1543b5a0b70dSHao Chen "read result tcam key %s(%u):\n", sel_x ? "x" : "y", 1544b5a0b70dSHao Chen tcam_msg.loc); 15453c666b58Sliuzhongzhu 154646ee7350SGuojia Liao /* tcam_data0 ~ tcam_data1 */ 15473c666b58Sliuzhongzhu req = (u32 *)req1->tcam_data; 15483c666b58Sliuzhongzhu for (i = 0; i < 2; i++) 1549b5a0b70dSHao Chen pos += scnprintf(tcam_buf + pos, HCLGE_DBG_TCAM_BUF_SIZE - pos, 1550b5a0b70dSHao Chen "%08x\n", *req++); 15513c666b58Sliuzhongzhu 155246ee7350SGuojia Liao /* tcam_data2 ~ tcam_data7 */ 15533c666b58Sliuzhongzhu req = (u32 *)req2->tcam_data; 15543c666b58Sliuzhongzhu for (i = 0; i < 6; i++) 1555b5a0b70dSHao Chen pos += scnprintf(tcam_buf + pos, HCLGE_DBG_TCAM_BUF_SIZE - pos, 1556b5a0b70dSHao Chen "%08x\n", *req++); 15573c666b58Sliuzhongzhu 155846ee7350SGuojia Liao /* tcam_data8 ~ tcam_data12 */ 15593c666b58Sliuzhongzhu req = (u32 *)req3->tcam_data; 15603c666b58Sliuzhongzhu for (i = 0; i < 5; i++) 1561b5a0b70dSHao Chen pos += scnprintf(tcam_buf + pos, HCLGE_DBG_TCAM_BUF_SIZE - pos, 1562b5a0b70dSHao Chen "%08x\n", *req++); 156344b6b883SYufeng Mo 156444b6b883SYufeng Mo return ret; 156544b6b883SYufeng Mo } 156644b6b883SYufeng Mo 156744b6b883SYufeng Mo static int hclge_dbg_get_rules_location(struct hclge_dev *hdev, u16 *rule_locs) 156844b6b883SYufeng Mo { 156944b6b883SYufeng Mo struct hclge_fd_rule *rule; 157044b6b883SYufeng Mo struct hlist_node *node; 157144b6b883SYufeng Mo int cnt = 0; 157244b6b883SYufeng Mo 157344b6b883SYufeng Mo spin_lock_bh(&hdev->fd_rule_lock); 157444b6b883SYufeng Mo hlist_for_each_entry_safe(rule, node, &hdev->fd_rule_list, rule_node) { 157544b6b883SYufeng Mo rule_locs[cnt] = rule->location; 157644b6b883SYufeng Mo cnt++; 157744b6b883SYufeng Mo } 157844b6b883SYufeng Mo spin_unlock_bh(&hdev->fd_rule_lock); 157944b6b883SYufeng Mo 1580b5a0b70dSHao Chen if (cnt != hdev->hclge_fd_rule_num || cnt == 0) 158144b6b883SYufeng Mo return -EINVAL; 158244b6b883SYufeng Mo 158344b6b883SYufeng Mo return cnt; 15843c666b58Sliuzhongzhu } 15853c666b58Sliuzhongzhu 1586b5a0b70dSHao Chen static int hclge_dbg_dump_fd_tcam(struct hclge_dev *hdev, char *buf, int len) 15873c666b58Sliuzhongzhu { 1588b5a0b70dSHao Chen u32 rule_num = hdev->fd_cfg.rule_num[HCLGE_FD_STAGE_1]; 1589b5a0b70dSHao Chen struct hclge_dbg_tcam_msg tcam_msg; 159044b6b883SYufeng Mo int i, ret, rule_cnt; 159144b6b883SYufeng Mo u16 *rule_locs; 1592b5a0b70dSHao Chen char *tcam_buf; 1593b5a0b70dSHao Chen int pos = 0; 15943c666b58Sliuzhongzhu 1595507e46aeSGuangbin Huang if (!hnae3_ae_dev_fd_supported(hdev->ae_dev)) { 159644b6b883SYufeng Mo dev_err(&hdev->pdev->dev, 159744b6b883SYufeng Mo "Only FD-supported dev supports dump fd tcam\n"); 1598b5a0b70dSHao Chen return -EOPNOTSUPP; 15993c666b58Sliuzhongzhu } 160044b6b883SYufeng Mo 1601b5a0b70dSHao Chen if (!hdev->hclge_fd_rule_num || !rule_num) 1602b5a0b70dSHao Chen return 0; 160344b6b883SYufeng Mo 1604b5a0b70dSHao Chen rule_locs = kcalloc(rule_num, sizeof(u16), GFP_KERNEL); 160544b6b883SYufeng Mo if (!rule_locs) 1606b5a0b70dSHao Chen return -ENOMEM; 1607b5a0b70dSHao Chen 1608b5a0b70dSHao Chen tcam_buf = kzalloc(HCLGE_DBG_TCAM_BUF_SIZE, GFP_KERNEL); 1609b5a0b70dSHao Chen if (!tcam_buf) { 1610b5a0b70dSHao Chen kfree(rule_locs); 1611b5a0b70dSHao Chen return -ENOMEM; 1612b5a0b70dSHao Chen } 161344b6b883SYufeng Mo 161444b6b883SYufeng Mo rule_cnt = hclge_dbg_get_rules_location(hdev, rule_locs); 1615b5a0b70dSHao Chen if (rule_cnt < 0) { 1616b5a0b70dSHao Chen ret = rule_cnt; 161744b6b883SYufeng Mo dev_err(&hdev->pdev->dev, 1618b5a0b70dSHao Chen "failed to get rule number, ret = %d\n", ret); 1619b5a0b70dSHao Chen goto out; 162044b6b883SYufeng Mo } 162144b6b883SYufeng Mo 1622030c8198SColin Ian King ret = 0; 162344b6b883SYufeng Mo for (i = 0; i < rule_cnt; i++) { 1624b5a0b70dSHao Chen tcam_msg.stage = HCLGE_FD_STAGE_1; 1625b5a0b70dSHao Chen tcam_msg.loc = rule_locs[i]; 1626b5a0b70dSHao Chen 1627b5a0b70dSHao Chen ret = hclge_dbg_fd_tcam_read(hdev, true, tcam_buf, tcam_msg); 162844b6b883SYufeng Mo if (ret) { 162944b6b883SYufeng Mo dev_err(&hdev->pdev->dev, 163044b6b883SYufeng Mo "failed to get fd tcam key x, ret = %d\n", ret); 1631b5a0b70dSHao Chen goto out; 163244b6b883SYufeng Mo } 163344b6b883SYufeng Mo 1634b5a0b70dSHao Chen pos += scnprintf(buf + pos, len - pos, "%s", tcam_buf); 1635b5a0b70dSHao Chen 1636b5a0b70dSHao Chen ret = hclge_dbg_fd_tcam_read(hdev, false, tcam_buf, tcam_msg); 163744b6b883SYufeng Mo if (ret) { 163844b6b883SYufeng Mo dev_err(&hdev->pdev->dev, 163944b6b883SYufeng Mo "failed to get fd tcam key y, ret = %d\n", ret); 1640b5a0b70dSHao Chen goto out; 164144b6b883SYufeng Mo } 164244b6b883SYufeng Mo 1643b5a0b70dSHao Chen pos += scnprintf(buf + pos, len - pos, "%s", tcam_buf); 1644b5a0b70dSHao Chen } 1645b5a0b70dSHao Chen 1646b5a0b70dSHao Chen out: 1647b5a0b70dSHao Chen kfree(tcam_buf); 164844b6b883SYufeng Mo kfree(rule_locs); 1649b5a0b70dSHao Chen return ret; 16503c666b58Sliuzhongzhu } 16513c666b58Sliuzhongzhu 165203a92fe8SJian Shen static int hclge_dbg_dump_fd_counter(struct hclge_dev *hdev, char *buf, int len) 165303a92fe8SJian Shen { 165403a92fe8SJian Shen u8 func_num = pci_num_vf(hdev->pdev) + 1; /* pf and enabled vf num */ 165503a92fe8SJian Shen struct hclge_fd_ad_cnt_read_cmd *req; 165603a92fe8SJian Shen char str_id[HCLGE_DBG_ID_LEN]; 165703a92fe8SJian Shen struct hclge_desc desc; 165803a92fe8SJian Shen int pos = 0; 165903a92fe8SJian Shen int ret; 166003a92fe8SJian Shen u64 cnt; 166103a92fe8SJian Shen u8 i; 166203a92fe8SJian Shen 1663507e46aeSGuangbin Huang if (!hnae3_ae_dev_fd_supported(hdev->ae_dev)) 1664507e46aeSGuangbin Huang return -EOPNOTSUPP; 1665507e46aeSGuangbin Huang 166603a92fe8SJian Shen pos += scnprintf(buf + pos, len - pos, 166703a92fe8SJian Shen "func_id\thit_times\n"); 166803a92fe8SJian Shen 166903a92fe8SJian Shen for (i = 0; i < func_num; i++) { 167003a92fe8SJian Shen hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_FD_CNT_OP, true); 167103a92fe8SJian Shen req = (struct hclge_fd_ad_cnt_read_cmd *)desc.data; 167203a92fe8SJian Shen req->index = cpu_to_le16(i); 167303a92fe8SJian Shen ret = hclge_cmd_send(&hdev->hw, &desc, 1); 167403a92fe8SJian Shen if (ret) { 167503a92fe8SJian Shen dev_err(&hdev->pdev->dev, "failed to get fd counter, ret = %d\n", 167603a92fe8SJian Shen ret); 167703a92fe8SJian Shen return ret; 167803a92fe8SJian Shen } 167903a92fe8SJian Shen cnt = le64_to_cpu(req->cnt); 168003a92fe8SJian Shen hclge_dbg_get_func_id_str(str_id, i); 168103a92fe8SJian Shen pos += scnprintf(buf + pos, len - pos, 168203a92fe8SJian Shen "%s\t%llu\n", str_id, cnt); 168303a92fe8SJian Shen } 168403a92fe8SJian Shen 168503a92fe8SJian Shen return 0; 168603a92fe8SJian Shen } 168703a92fe8SJian Shen 1688e6fe5e16SJie Wang static const struct hclge_dbg_status_dfx_info hclge_dbg_rst_info[] = { 1689e6fe5e16SJie Wang {HCLGE_MISC_VECTOR_REG_BASE, "vector0 interrupt enable status"}, 1690e6fe5e16SJie Wang {HCLGE_MISC_RESET_STS_REG, "reset interrupt source"}, 1691e6fe5e16SJie Wang {HCLGE_MISC_VECTOR_INT_STS, "reset interrupt status"}, 1692e6fe5e16SJie Wang {HCLGE_RAS_PF_OTHER_INT_STS_REG, "RAS interrupt status"}, 1693e6fe5e16SJie Wang {HCLGE_GLOBAL_RESET_REG, "hardware reset status"}, 1694e6fe5e16SJie Wang {HCLGE_NIC_CSQ_DEPTH_REG, "handshake status"}, 1695e6fe5e16SJie Wang {HCLGE_FUN_RST_ING, "function reset status"} 1696e6fe5e16SJie Wang }; 1697e6fe5e16SJie Wang 16981a7ff828SJiaran Zhang int hclge_dbg_dump_rst_info(struct hclge_dev *hdev, char *buf, int len) 1699f02eb82dSHuazhong Tan { 1700e6fe5e16SJie Wang u32 i, offset; 17011a7ff828SJiaran Zhang int pos = 0; 17021a7ff828SJiaran Zhang 17031a7ff828SJiaran Zhang pos += scnprintf(buf + pos, len - pos, "PF reset count: %u\n", 1704f02eb82dSHuazhong Tan hdev->rst_stats.pf_rst_cnt); 17051a7ff828SJiaran Zhang pos += scnprintf(buf + pos, len - pos, "FLR reset count: %u\n", 1706f02eb82dSHuazhong Tan hdev->rst_stats.flr_rst_cnt); 17071a7ff828SJiaran Zhang pos += scnprintf(buf + pos, len - pos, "GLOBAL reset count: %u\n", 1708f02eb82dSHuazhong Tan hdev->rst_stats.global_rst_cnt); 17091a7ff828SJiaran Zhang pos += scnprintf(buf + pos, len - pos, "IMP reset count: %u\n", 1710f02eb82dSHuazhong Tan hdev->rst_stats.imp_rst_cnt); 17111a7ff828SJiaran Zhang pos += scnprintf(buf + pos, len - pos, "reset done count: %u\n", 1712f02eb82dSHuazhong Tan hdev->rst_stats.reset_done_cnt); 17131a7ff828SJiaran Zhang pos += scnprintf(buf + pos, len - pos, "HW reset done count: %u\n", 1714f02eb82dSHuazhong Tan hdev->rst_stats.hw_reset_done_cnt); 17151a7ff828SJiaran Zhang pos += scnprintf(buf + pos, len - pos, "reset count: %u\n", 1716f02eb82dSHuazhong Tan hdev->rst_stats.reset_cnt); 17171a7ff828SJiaran Zhang pos += scnprintf(buf + pos, len - pos, "reset fail count: %u\n", 17180ecf1f7bSHuazhong Tan hdev->rst_stats.reset_fail_cnt); 1719e6fe5e16SJie Wang 1720e6fe5e16SJie Wang for (i = 0; i < ARRAY_SIZE(hclge_dbg_rst_info); i++) { 1721e6fe5e16SJie Wang offset = hclge_dbg_rst_info[i].offset; 1722e6fe5e16SJie Wang pos += scnprintf(buf + pos, len - pos, "%s: 0x%x\n", 1723e6fe5e16SJie Wang hclge_dbg_rst_info[i].message, 1724e6fe5e16SJie Wang hclge_read_dev(&hdev->hw, offset)); 1725e6fe5e16SJie Wang } 1726e6fe5e16SJie Wang 17271a7ff828SJiaran Zhang pos += scnprintf(buf + pos, len - pos, "hdev state: 0x%lx\n", 17281a7ff828SJiaran Zhang hdev->state); 17291a7ff828SJiaran Zhang 17301a7ff828SJiaran Zhang return 0; 1731f02eb82dSHuazhong Tan } 1732f02eb82dSHuazhong Tan 1733058c3be9SYufeng Mo static int hclge_dbg_dump_serv_info(struct hclge_dev *hdev, char *buf, int len) 17341c6dfe6fSYunsheng Lin { 1735058c3be9SYufeng Mo unsigned long rem_nsec; 1736058c3be9SYufeng Mo int pos = 0; 1737058c3be9SYufeng Mo u64 lc; 1738058c3be9SYufeng Mo 1739058c3be9SYufeng Mo lc = local_clock(); 1740058c3be9SYufeng Mo rem_nsec = do_div(lc, HCLGE_BILLION_NANO_SECONDS); 1741058c3be9SYufeng Mo 1742058c3be9SYufeng Mo pos += scnprintf(buf + pos, len - pos, "local_clock: [%5lu.%06lu]\n", 1743058c3be9SYufeng Mo (unsigned long)lc, rem_nsec / 1000); 1744058c3be9SYufeng Mo pos += scnprintf(buf + pos, len - pos, "delta: %u(ms)\n", 1745058c3be9SYufeng Mo jiffies_to_msecs(jiffies - hdev->last_serv_processed)); 1746058c3be9SYufeng Mo pos += scnprintf(buf + pos, len - pos, 1747058c3be9SYufeng Mo "last_service_task_processed: %lu(jiffies)\n", 17481c6dfe6fSYunsheng Lin hdev->last_serv_processed); 1749058c3be9SYufeng Mo pos += scnprintf(buf + pos, len - pos, "last_service_task_cnt: %lu\n", 17501c6dfe6fSYunsheng Lin hdev->serv_processed_cnt); 1751058c3be9SYufeng Mo 1752058c3be9SYufeng Mo return 0; 17531c6dfe6fSYunsheng Lin } 17541c6dfe6fSYunsheng Lin 17559149ca0fSJiaran Zhang static int hclge_dbg_dump_interrupt(struct hclge_dev *hdev, char *buf, int len) 1756348775ebSYufeng Mo { 17579149ca0fSJiaran Zhang int pos = 0; 17589149ca0fSJiaran Zhang 17599149ca0fSJiaran Zhang pos += scnprintf(buf + pos, len - pos, "num_nic_msi: %u\n", 17609149ca0fSJiaran Zhang hdev->num_nic_msi); 17619149ca0fSJiaran Zhang pos += scnprintf(buf + pos, len - pos, "num_roce_msi: %u\n", 17629149ca0fSJiaran Zhang hdev->num_roce_msi); 17639149ca0fSJiaran Zhang pos += scnprintf(buf + pos, len - pos, "num_msi_used: %u\n", 17649149ca0fSJiaran Zhang hdev->num_msi_used); 17659149ca0fSJiaran Zhang pos += scnprintf(buf + pos, len - pos, "num_msi_left: %u\n", 17669149ca0fSJiaran Zhang hdev->num_msi_left); 17679149ca0fSJiaran Zhang 17689149ca0fSJiaran Zhang return 0; 1769348775ebSYufeng Mo } 1770348775ebSYufeng Mo 17710b198b0dSJiaran Zhang static void hclge_dbg_imp_info_data_print(struct hclge_desc *desc_src, 17720b198b0dSJiaran Zhang char *buf, int len, u32 bd_num) 177333a90e2fSZhongzhu Liu { 17740b198b0dSJiaran Zhang #define HCLGE_DBG_IMP_INFO_PRINT_OFFSET 0x2 17750b198b0dSJiaran Zhang 17760b198b0dSJiaran Zhang struct hclge_desc *desc_index = desc_src; 17770b198b0dSJiaran Zhang u32 offset = 0; 17780b198b0dSJiaran Zhang int pos = 0; 17790b198b0dSJiaran Zhang u32 i, j; 17800b198b0dSJiaran Zhang 17810b198b0dSJiaran Zhang pos += scnprintf(buf + pos, len - pos, "offset | data\n"); 17820b198b0dSJiaran Zhang 17830b198b0dSJiaran Zhang for (i = 0; i < bd_num; i++) { 17840b198b0dSJiaran Zhang j = 0; 17850b198b0dSJiaran Zhang while (j < HCLGE_DESC_DATA_LEN - 1) { 17860b198b0dSJiaran Zhang pos += scnprintf(buf + pos, len - pos, "0x%04x | ", 17870b198b0dSJiaran Zhang offset); 17880b198b0dSJiaran Zhang pos += scnprintf(buf + pos, len - pos, "0x%08x ", 17890b198b0dSJiaran Zhang le32_to_cpu(desc_index->data[j++])); 17900b198b0dSJiaran Zhang pos += scnprintf(buf + pos, len - pos, "0x%08x\n", 17910b198b0dSJiaran Zhang le32_to_cpu(desc_index->data[j++])); 17920b198b0dSJiaran Zhang offset += sizeof(u32) * HCLGE_DBG_IMP_INFO_PRINT_OFFSET; 17930b198b0dSJiaran Zhang } 17940b198b0dSJiaran Zhang desc_index++; 17950b198b0dSJiaran Zhang } 17960b198b0dSJiaran Zhang } 17970b198b0dSJiaran Zhang 17980b198b0dSJiaran Zhang static int 17990b198b0dSJiaran Zhang hclge_dbg_get_imp_stats_info(struct hclge_dev *hdev, char *buf, int len) 18000b198b0dSJiaran Zhang { 18010b198b0dSJiaran Zhang struct hclge_get_imp_bd_cmd *req; 18020b198b0dSJiaran Zhang struct hclge_desc *desc_src; 180333a90e2fSZhongzhu Liu struct hclge_desc desc; 18040b198b0dSJiaran Zhang u32 bd_num; 18050b198b0dSJiaran Zhang int ret; 180633a90e2fSZhongzhu Liu 18070b198b0dSJiaran Zhang hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_IMP_STATS_BD, true); 180833a90e2fSZhongzhu Liu 18090b198b0dSJiaran Zhang req = (struct hclge_get_imp_bd_cmd *)desc.data; 181033a90e2fSZhongzhu Liu ret = hclge_cmd_send(&hdev->hw, &desc, 1); 181133a90e2fSZhongzhu Liu if (ret) { 181233a90e2fSZhongzhu Liu dev_err(&hdev->pdev->dev, 18130b198b0dSJiaran Zhang "failed to get imp statistics bd number, ret = %d\n", 181433a90e2fSZhongzhu Liu ret); 18150b198b0dSJiaran Zhang return ret; 181633a90e2fSZhongzhu Liu } 181733a90e2fSZhongzhu Liu 181833a90e2fSZhongzhu Liu bd_num = le32_to_cpu(req->bd_num); 1819472430a7SJiaran Zhang if (!bd_num) { 1820472430a7SJiaran Zhang dev_err(&hdev->pdev->dev, "imp statistics bd number is 0!\n"); 1821472430a7SJiaran Zhang return -EINVAL; 1822472430a7SJiaran Zhang } 182333a90e2fSZhongzhu Liu 18240b198b0dSJiaran Zhang desc_src = kcalloc(bd_num, sizeof(struct hclge_desc), GFP_KERNEL); 1825fbdc4d79SYufeng Mo if (!desc_src) 18260b198b0dSJiaran Zhang return -ENOMEM; 182733a90e2fSZhongzhu Liu 18280b198b0dSJiaran Zhang ret = hclge_dbg_cmd_send(hdev, desc_src, 0, bd_num, 18290b198b0dSJiaran Zhang HCLGE_OPC_IMP_STATS_INFO); 183033a90e2fSZhongzhu Liu if (ret) { 183133a90e2fSZhongzhu Liu kfree(desc_src); 183233a90e2fSZhongzhu Liu dev_err(&hdev->pdev->dev, 18330b198b0dSJiaran Zhang "failed to get imp statistics, ret = %d\n", ret); 18340b198b0dSJiaran Zhang return ret; 183533a90e2fSZhongzhu Liu } 183633a90e2fSZhongzhu Liu 18370b198b0dSJiaran Zhang hclge_dbg_imp_info_data_print(desc_src, buf, len, bd_num); 183833a90e2fSZhongzhu Liu 183933a90e2fSZhongzhu Liu kfree(desc_src); 18400b198b0dSJiaran Zhang 18410b198b0dSJiaran Zhang return 0; 184233a90e2fSZhongzhu Liu } 184333a90e2fSZhongzhu Liu 1844dec84660SYufeng Mo #define HCLGE_CMD_NCL_CONFIG_BD_NUM 5 1845e76e6886SJiaran Zhang #define HCLGE_MAX_NCL_CONFIG_LENGTH 16384 1846dec84660SYufeng Mo 1847e76e6886SJiaran Zhang static void hclge_ncl_config_data_print(struct hclge_desc *desc, int *index, 184872dcdec1SGuangbin Huang char *buf, int len, int *pos) 1849dec84660SYufeng Mo { 1850dec84660SYufeng Mo #define HCLGE_CMD_DATA_NUM 6 1851dec84660SYufeng Mo 1852e76e6886SJiaran Zhang int offset = HCLGE_MAX_NCL_CONFIG_LENGTH - *index; 1853e76e6886SJiaran Zhang int i, j; 1854dec84660SYufeng Mo 1855dec84660SYufeng Mo for (i = 0; i < HCLGE_CMD_NCL_CONFIG_BD_NUM; i++) { 1856dec84660SYufeng Mo for (j = 0; j < HCLGE_CMD_DATA_NUM; j++) { 1857dec84660SYufeng Mo if (i == 0 && j == 0) 1858dec84660SYufeng Mo continue; 1859dec84660SYufeng Mo 186072dcdec1SGuangbin Huang *pos += scnprintf(buf + *pos, len - *pos, 1861e76e6886SJiaran Zhang "0x%04x | 0x%08x\n", offset, 1862dec84660SYufeng Mo le32_to_cpu(desc[i].data[j])); 1863e76e6886SJiaran Zhang 1864e76e6886SJiaran Zhang offset += sizeof(u32); 1865e76e6886SJiaran Zhang *index -= sizeof(u32); 1866e76e6886SJiaran Zhang 1867e76e6886SJiaran Zhang if (*index <= 0) 1868dec84660SYufeng Mo return; 1869dec84660SYufeng Mo } 1870dec84660SYufeng Mo } 1871dec84660SYufeng Mo } 1872dec84660SYufeng Mo 1873e76e6886SJiaran Zhang static int 1874e76e6886SJiaran Zhang hclge_dbg_dump_ncl_config(struct hclge_dev *hdev, char *buf, int len) 1875ffd140e2SWeihang Li { 18764960cabfSYufeng Mo #define HCLGE_NCL_CONFIG_LENGTH_IN_EACH_CMD (20 + 24 * 4) 1877ffd140e2SWeihang Li 1878dec84660SYufeng Mo struct hclge_desc desc[HCLGE_CMD_NCL_CONFIG_BD_NUM]; 1879dec84660SYufeng Mo int bd_num = HCLGE_CMD_NCL_CONFIG_BD_NUM; 1880e76e6886SJiaran Zhang int index = HCLGE_MAX_NCL_CONFIG_LENGTH; 1881e76e6886SJiaran Zhang int pos = 0; 1882e76e6886SJiaran Zhang u32 data0; 1883ffd140e2SWeihang Li int ret; 1884ffd140e2SWeihang Li 1885e76e6886SJiaran Zhang pos += scnprintf(buf + pos, len - pos, "offset | data\n"); 1886b4401a04SYufeng Mo 1887e76e6886SJiaran Zhang while (index > 0) { 1888e76e6886SJiaran Zhang data0 = HCLGE_MAX_NCL_CONFIG_LENGTH - index; 1889e76e6886SJiaran Zhang if (index >= HCLGE_NCL_CONFIG_LENGTH_IN_EACH_CMD) 18904960cabfSYufeng Mo data0 |= HCLGE_NCL_CONFIG_LENGTH_IN_EACH_CMD << 16; 1891ffd140e2SWeihang Li else 1892e76e6886SJiaran Zhang data0 |= (u32)index << 16; 1893ffd140e2SWeihang Li ret = hclge_dbg_cmd_send(hdev, desc, data0, bd_num, 1894ffd140e2SWeihang Li HCLGE_OPC_QUERY_NCL_CONFIG); 1895ffd140e2SWeihang Li if (ret) 1896e76e6886SJiaran Zhang return ret; 1897ffd140e2SWeihang Li 189872dcdec1SGuangbin Huang hclge_ncl_config_data_print(desc, &index, buf, len, &pos); 1899ffd140e2SWeihang Li } 1900e76e6886SJiaran Zhang 1901e76e6886SJiaran Zhang return 0; 1902ffd140e2SWeihang Li } 1903ffd140e2SWeihang Li 1904d658ff34SYufeng Mo static int hclge_dbg_dump_loopback(struct hclge_dev *hdev, char *buf, int len) 1905ded45d40SYufeng Mo { 1906ded45d40SYufeng Mo struct phy_device *phydev = hdev->hw.mac.phydev; 1907ded45d40SYufeng Mo struct hclge_config_mac_mode_cmd *req_app; 1908b47cfe1fSGuangbin Huang struct hclge_common_lb_cmd *req_common; 1909ded45d40SYufeng Mo struct hclge_desc desc; 1910ded45d40SYufeng Mo u8 loopback_en; 1911d658ff34SYufeng Mo int pos = 0; 1912ded45d40SYufeng Mo int ret; 1913ded45d40SYufeng Mo 1914ded45d40SYufeng Mo req_app = (struct hclge_config_mac_mode_cmd *)desc.data; 1915b47cfe1fSGuangbin Huang req_common = (struct hclge_common_lb_cmd *)desc.data; 1916ded45d40SYufeng Mo 1917d658ff34SYufeng Mo pos += scnprintf(buf + pos, len - pos, "mac id: %u\n", 1918d658ff34SYufeng Mo hdev->hw.mac.mac_id); 1919ded45d40SYufeng Mo 1920ded45d40SYufeng Mo hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_CONFIG_MAC_MODE, true); 1921ded45d40SYufeng Mo ret = hclge_cmd_send(&hdev->hw, &desc, 1); 1922ded45d40SYufeng Mo if (ret) { 1923ded45d40SYufeng Mo dev_err(&hdev->pdev->dev, 1924ded45d40SYufeng Mo "failed to dump app loopback status, ret = %d\n", ret); 1925d658ff34SYufeng Mo return ret; 1926ded45d40SYufeng Mo } 1927ded45d40SYufeng Mo 1928ded45d40SYufeng Mo loopback_en = hnae3_get_bit(le32_to_cpu(req_app->txrx_pad_fcs_loop_en), 1929ded45d40SYufeng Mo HCLGE_MAC_APP_LP_B); 1930d658ff34SYufeng Mo pos += scnprintf(buf + pos, len - pos, "app loopback: %s\n", 1931d658ff34SYufeng Mo state_str[loopback_en]); 1932ded45d40SYufeng Mo 1933b47cfe1fSGuangbin Huang hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_COMMON_LOOPBACK, true); 1934ded45d40SYufeng Mo ret = hclge_cmd_send(&hdev->hw, &desc, 1); 1935ded45d40SYufeng Mo if (ret) { 1936ded45d40SYufeng Mo dev_err(&hdev->pdev->dev, 1937b47cfe1fSGuangbin Huang "failed to dump common loopback status, ret = %d\n", 1938ded45d40SYufeng Mo ret); 1939d658ff34SYufeng Mo return ret; 1940ded45d40SYufeng Mo } 1941ded45d40SYufeng Mo 1942b47cfe1fSGuangbin Huang loopback_en = req_common->enable & HCLGE_CMD_SERDES_SERIAL_INNER_LOOP_B; 1943d658ff34SYufeng Mo pos += scnprintf(buf + pos, len - pos, "serdes serial loopback: %s\n", 1944d658ff34SYufeng Mo state_str[loopback_en]); 1945ded45d40SYufeng Mo 1946b47cfe1fSGuangbin Huang loopback_en = req_common->enable & 1947d658ff34SYufeng Mo HCLGE_CMD_SERDES_PARALLEL_INNER_LOOP_B ? 1 : 0; 1948d658ff34SYufeng Mo pos += scnprintf(buf + pos, len - pos, "serdes parallel loopback: %s\n", 1949d658ff34SYufeng Mo state_str[loopback_en]); 1950ded45d40SYufeng Mo 1951b47cfe1fSGuangbin Huang if (phydev) { 1952d658ff34SYufeng Mo loopback_en = phydev->loopback_enabled; 1953d658ff34SYufeng Mo pos += scnprintf(buf + pos, len - pos, "phy loopback: %s\n", 1954d658ff34SYufeng Mo state_str[loopback_en]); 1955b47cfe1fSGuangbin Huang } else if (hnae3_dev_phy_imp_supported(hdev)) { 1956b47cfe1fSGuangbin Huang loopback_en = req_common->enable & 1957b47cfe1fSGuangbin Huang HCLGE_CMD_GE_PHY_INNER_LOOP_B; 1958d658ff34SYufeng Mo pos += scnprintf(buf + pos, len - pos, "phy loopback: %s\n", 1959d658ff34SYufeng Mo state_str[loopback_en]); 1960b47cfe1fSGuangbin Huang } 1961d658ff34SYufeng Mo 1962d658ff34SYufeng Mo return 0; 1963ded45d40SYufeng Mo } 1964ded45d40SYufeng Mo 1965a6345787SWeihang Li /* hclge_dbg_dump_mac_tnl_status: print message about mac tnl interrupt 1966a6345787SWeihang Li * @hdev: pointer to struct hclge_dev 1967a6345787SWeihang Li */ 19687b07ab06SJiaran Zhang static int 19697b07ab06SJiaran Zhang hclge_dbg_dump_mac_tnl_status(struct hclge_dev *hdev, char *buf, int len) 1970a6345787SWeihang Li { 1971a6345787SWeihang Li struct hclge_mac_tnl_stats stats; 1972a6345787SWeihang Li unsigned long rem_nsec; 19737b07ab06SJiaran Zhang int pos = 0; 1974a6345787SWeihang Li 19757b07ab06SJiaran Zhang pos += scnprintf(buf + pos, len - pos, 19767b07ab06SJiaran Zhang "Recently generated mac tnl interruption:\n"); 1977a6345787SWeihang Li 1978a6345787SWeihang Li while (kfifo_get(&hdev->mac_tnl_log, &stats)) { 1979a6345787SWeihang Li rem_nsec = do_div(stats.time, HCLGE_BILLION_NANO_SECONDS); 19807b07ab06SJiaran Zhang 19817b07ab06SJiaran Zhang pos += scnprintf(buf + pos, len - pos, 19827b07ab06SJiaran Zhang "[%07lu.%03lu] status = 0x%x\n", 1983a6345787SWeihang Li (unsigned long)stats.time, rem_nsec / 1000, 1984a6345787SWeihang Li stats.status); 1985a6345787SWeihang Li } 19867b07ab06SJiaran Zhang 19877b07ab06SJiaran Zhang return 0; 1988a6345787SWeihang Li } 1989a6345787SWeihang Li 1990ee9e4424SYonglong Liu 19911556ea91SHuazhong Tan static const struct hclge_dbg_item mac_list_items[] = { 19921556ea91SHuazhong Tan { "FUNC_ID", 2 }, 19931556ea91SHuazhong Tan { "MAC_ADDR", 12 }, 19941556ea91SHuazhong Tan { "STATE", 2 }, 19951556ea91SHuazhong Tan }; 19961556ea91SHuazhong Tan 19971556ea91SHuazhong Tan static void hclge_dbg_dump_mac_list(struct hclge_dev *hdev, char *buf, int len, 1998f671237aSJian Shen bool is_unicast) 1999f671237aSJian Shen { 20001556ea91SHuazhong Tan char data_str[ARRAY_SIZE(mac_list_items)][HCLGE_DBG_DATA_STR_LEN]; 20011556ea91SHuazhong Tan char content[HCLGE_DBG_INFO_LEN], str_id[HCLGE_DBG_ID_LEN]; 20021556ea91SHuazhong Tan char *result[ARRAY_SIZE(mac_list_items)]; 2003f671237aSJian Shen struct hclge_mac_node *mac_node, *tmp; 2004f671237aSJian Shen struct hclge_vport *vport; 2005f671237aSJian Shen struct list_head *list; 2006f671237aSJian Shen u32 func_id; 20071556ea91SHuazhong Tan int pos = 0; 20081556ea91SHuazhong Tan int i; 2009f671237aSJian Shen 20101556ea91SHuazhong Tan for (i = 0; i < ARRAY_SIZE(mac_list_items); i++) 20111556ea91SHuazhong Tan result[i] = &data_str[i][0]; 2012f671237aSJian Shen 20131556ea91SHuazhong Tan pos += scnprintf(buf + pos, len - pos, "%s MAC_LIST:\n", 20141556ea91SHuazhong Tan is_unicast ? "UC" : "MC"); 20151556ea91SHuazhong Tan hclge_dbg_fill_content(content, sizeof(content), mac_list_items, 20161556ea91SHuazhong Tan NULL, ARRAY_SIZE(mac_list_items)); 20171556ea91SHuazhong Tan pos += scnprintf(buf + pos, len - pos, "%s", content); 2018f671237aSJian Shen 20191556ea91SHuazhong Tan for (func_id = 0; func_id < hdev->num_alloc_vport; func_id++) { 2020f671237aSJian Shen vport = &hdev->vport[func_id]; 2021f671237aSJian Shen list = is_unicast ? &vport->uc_mac_list : &vport->mc_mac_list; 2022f671237aSJian Shen spin_lock_bh(&vport->mac_list_lock); 2023f671237aSJian Shen list_for_each_entry_safe(mac_node, tmp, list, node) { 20241556ea91SHuazhong Tan i = 0; 20251556ea91SHuazhong Tan result[i++] = hclge_dbg_get_func_id_str(str_id, 20261556ea91SHuazhong Tan func_id); 20271556ea91SHuazhong Tan sprintf(result[i++], "%pM", mac_node->mac_addr); 20281556ea91SHuazhong Tan sprintf(result[i++], "%5s", 20291556ea91SHuazhong Tan hclge_mac_state_str[mac_node->state]); 20301556ea91SHuazhong Tan hclge_dbg_fill_content(content, sizeof(content), 20311556ea91SHuazhong Tan mac_list_items, 20321556ea91SHuazhong Tan (const char **)result, 20331556ea91SHuazhong Tan ARRAY_SIZE(mac_list_items)); 20341556ea91SHuazhong Tan pos += scnprintf(buf + pos, len - pos, "%s", content); 20351556ea91SHuazhong Tan } 20361556ea91SHuazhong Tan spin_unlock_bh(&vport->mac_list_lock); 20371556ea91SHuazhong Tan } 2038f671237aSJian Shen } 2039f671237aSJian Shen 2040d59daf6aSJian Shen static int hclge_dbg_dump_umv_info(struct hclge_dev *hdev, char *buf, int len) 2041d59daf6aSJian Shen { 2042d59daf6aSJian Shen u8 func_num = pci_num_vf(hdev->pdev) + 1; 2043d59daf6aSJian Shen struct hclge_vport *vport; 2044d59daf6aSJian Shen int pos = 0; 2045d59daf6aSJian Shen u8 i; 2046d59daf6aSJian Shen 2047d59daf6aSJian Shen pos += scnprintf(buf, len, "num_alloc_vport : %u\n", 2048d59daf6aSJian Shen hdev->num_alloc_vport); 2049d59daf6aSJian Shen pos += scnprintf(buf + pos, len - pos, "max_umv_size : %u\n", 2050d59daf6aSJian Shen hdev->max_umv_size); 2051d59daf6aSJian Shen pos += scnprintf(buf + pos, len - pos, "wanted_umv_size : %u\n", 2052d59daf6aSJian Shen hdev->wanted_umv_size); 2053d59daf6aSJian Shen pos += scnprintf(buf + pos, len - pos, "priv_umv_size : %u\n", 2054d59daf6aSJian Shen hdev->priv_umv_size); 2055d59daf6aSJian Shen 2056d59daf6aSJian Shen mutex_lock(&hdev->vport_lock); 2057d59daf6aSJian Shen pos += scnprintf(buf + pos, len - pos, "share_umv_size : %u\n", 2058d59daf6aSJian Shen hdev->share_umv_size); 2059d59daf6aSJian Shen for (i = 0; i < func_num; i++) { 2060d59daf6aSJian Shen vport = &hdev->vport[i]; 2061d59daf6aSJian Shen pos += scnprintf(buf + pos, len - pos, 2062d59daf6aSJian Shen "vport(%u) used_umv_num : %u\n", 2063d59daf6aSJian Shen i, vport->used_umv_num); 2064d59daf6aSJian Shen } 2065d59daf6aSJian Shen mutex_unlock(&hdev->vport_lock); 2066d59daf6aSJian Shen 20675c56ff48SGuangbin Huang pos += scnprintf(buf + pos, len - pos, "used_mc_mac_num : %u\n", 20685c56ff48SGuangbin Huang hdev->used_mc_mac_num); 20695c56ff48SGuangbin Huang 2070d59daf6aSJian Shen return 0; 2071d59daf6aSJian Shen } 2072d59daf6aSJian Shen 20730ca821daSJian Shen static int hclge_get_vlan_rx_offload_cfg(struct hclge_dev *hdev, u8 vf_id, 20740ca821daSJian Shen struct hclge_dbg_vlan_cfg *vlan_cfg) 20750ca821daSJian Shen { 20760ca821daSJian Shen struct hclge_vport_vtag_rx_cfg_cmd *req; 20770ca821daSJian Shen struct hclge_desc desc; 20780ca821daSJian Shen u16 bmap_index; 20790ca821daSJian Shen u8 rx_cfg; 20800ca821daSJian Shen int ret; 20810ca821daSJian Shen 20820ca821daSJian Shen hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_VLAN_PORT_RX_CFG, true); 20830ca821daSJian Shen 20840ca821daSJian Shen req = (struct hclge_vport_vtag_rx_cfg_cmd *)desc.data; 20850ca821daSJian Shen req->vf_offset = vf_id / HCLGE_VF_NUM_PER_CMD; 20860ca821daSJian Shen bmap_index = vf_id % HCLGE_VF_NUM_PER_CMD / HCLGE_VF_NUM_PER_BYTE; 20870ca821daSJian Shen req->vf_bitmap[bmap_index] = 1U << (vf_id % HCLGE_VF_NUM_PER_BYTE); 20880ca821daSJian Shen 20890ca821daSJian Shen ret = hclge_cmd_send(&hdev->hw, &desc, 1); 20900ca821daSJian Shen if (ret) { 20910ca821daSJian Shen dev_err(&hdev->pdev->dev, 20920ca821daSJian Shen "failed to get vport%u rxvlan cfg, ret = %d\n", 20930ca821daSJian Shen vf_id, ret); 20940ca821daSJian Shen return ret; 20950ca821daSJian Shen } 20960ca821daSJian Shen 20970ca821daSJian Shen rx_cfg = req->vport_vlan_cfg; 20980ca821daSJian Shen vlan_cfg->strip_tag1 = hnae3_get_bit(rx_cfg, HCLGE_REM_TAG1_EN_B); 20990ca821daSJian Shen vlan_cfg->strip_tag2 = hnae3_get_bit(rx_cfg, HCLGE_REM_TAG2_EN_B); 21000ca821daSJian Shen vlan_cfg->drop_tag1 = hnae3_get_bit(rx_cfg, HCLGE_DISCARD_TAG1_EN_B); 21010ca821daSJian Shen vlan_cfg->drop_tag2 = hnae3_get_bit(rx_cfg, HCLGE_DISCARD_TAG2_EN_B); 21020ca821daSJian Shen vlan_cfg->pri_only1 = hnae3_get_bit(rx_cfg, HCLGE_SHOW_TAG1_EN_B); 21030ca821daSJian Shen vlan_cfg->pri_only2 = hnae3_get_bit(rx_cfg, HCLGE_SHOW_TAG2_EN_B); 21040ca821daSJian Shen 21050ca821daSJian Shen return 0; 21060ca821daSJian Shen } 21070ca821daSJian Shen 21080ca821daSJian Shen static int hclge_get_vlan_tx_offload_cfg(struct hclge_dev *hdev, u8 vf_id, 21090ca821daSJian Shen struct hclge_dbg_vlan_cfg *vlan_cfg) 21100ca821daSJian Shen { 21110ca821daSJian Shen struct hclge_vport_vtag_tx_cfg_cmd *req; 21120ca821daSJian Shen struct hclge_desc desc; 21130ca821daSJian Shen u16 bmap_index; 21140ca821daSJian Shen u8 tx_cfg; 21150ca821daSJian Shen int ret; 21160ca821daSJian Shen 21170ca821daSJian Shen hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_VLAN_PORT_TX_CFG, true); 21180ca821daSJian Shen req = (struct hclge_vport_vtag_tx_cfg_cmd *)desc.data; 21190ca821daSJian Shen req->vf_offset = vf_id / HCLGE_VF_NUM_PER_CMD; 21200ca821daSJian Shen bmap_index = vf_id % HCLGE_VF_NUM_PER_CMD / HCLGE_VF_NUM_PER_BYTE; 21210ca821daSJian Shen req->vf_bitmap[bmap_index] = 1U << (vf_id % HCLGE_VF_NUM_PER_BYTE); 21220ca821daSJian Shen 21230ca821daSJian Shen ret = hclge_cmd_send(&hdev->hw, &desc, 1); 21240ca821daSJian Shen if (ret) { 21250ca821daSJian Shen dev_err(&hdev->pdev->dev, 21260ca821daSJian Shen "failed to get vport%u txvlan cfg, ret = %d\n", 21270ca821daSJian Shen vf_id, ret); 21280ca821daSJian Shen return ret; 21290ca821daSJian Shen } 21300ca821daSJian Shen 21310ca821daSJian Shen tx_cfg = req->vport_vlan_cfg; 21320ca821daSJian Shen vlan_cfg->pvid = le16_to_cpu(req->def_vlan_tag1); 21330ca821daSJian Shen 21340ca821daSJian Shen vlan_cfg->accept_tag1 = hnae3_get_bit(tx_cfg, HCLGE_ACCEPT_TAG1_B); 21350ca821daSJian Shen vlan_cfg->accept_tag2 = hnae3_get_bit(tx_cfg, HCLGE_ACCEPT_TAG2_B); 21360ca821daSJian Shen vlan_cfg->accept_untag1 = hnae3_get_bit(tx_cfg, HCLGE_ACCEPT_UNTAG1_B); 21370ca821daSJian Shen vlan_cfg->accept_untag2 = hnae3_get_bit(tx_cfg, HCLGE_ACCEPT_UNTAG2_B); 21380ca821daSJian Shen vlan_cfg->insert_tag1 = hnae3_get_bit(tx_cfg, HCLGE_PORT_INS_TAG1_EN_B); 21390ca821daSJian Shen vlan_cfg->insert_tag2 = hnae3_get_bit(tx_cfg, HCLGE_PORT_INS_TAG2_EN_B); 21400ca821daSJian Shen vlan_cfg->shift_tag = hnae3_get_bit(tx_cfg, HCLGE_TAG_SHIFT_MODE_EN_B); 21410ca821daSJian Shen 21420ca821daSJian Shen return 0; 21430ca821daSJian Shen } 21440ca821daSJian Shen 21450ca821daSJian Shen static int hclge_get_vlan_filter_config_cmd(struct hclge_dev *hdev, 21460ca821daSJian Shen u8 vlan_type, u8 vf_id, 21470ca821daSJian Shen struct hclge_desc *desc) 21480ca821daSJian Shen { 21490ca821daSJian Shen struct hclge_vlan_filter_ctrl_cmd *req; 21500ca821daSJian Shen int ret; 21510ca821daSJian Shen 21520ca821daSJian Shen hclge_cmd_setup_basic_desc(desc, HCLGE_OPC_VLAN_FILTER_CTRL, true); 21530ca821daSJian Shen req = (struct hclge_vlan_filter_ctrl_cmd *)desc->data; 21540ca821daSJian Shen req->vlan_type = vlan_type; 21550ca821daSJian Shen req->vf_id = vf_id; 21560ca821daSJian Shen 21570ca821daSJian Shen ret = hclge_cmd_send(&hdev->hw, desc, 1); 21580ca821daSJian Shen if (ret) 21590ca821daSJian Shen dev_err(&hdev->pdev->dev, 21600ca821daSJian Shen "failed to get vport%u vlan filter config, ret = %d.\n", 21610ca821daSJian Shen vf_id, ret); 21620ca821daSJian Shen 21630ca821daSJian Shen return ret; 21640ca821daSJian Shen } 21650ca821daSJian Shen 21660ca821daSJian Shen static int hclge_get_vlan_filter_state(struct hclge_dev *hdev, u8 vlan_type, 21670ca821daSJian Shen u8 vf_id, u8 *vlan_fe) 21680ca821daSJian Shen { 21690ca821daSJian Shen struct hclge_vlan_filter_ctrl_cmd *req; 21700ca821daSJian Shen struct hclge_desc desc; 21710ca821daSJian Shen int ret; 21720ca821daSJian Shen 21730ca821daSJian Shen ret = hclge_get_vlan_filter_config_cmd(hdev, vlan_type, vf_id, &desc); 21740ca821daSJian Shen if (ret) 21750ca821daSJian Shen return ret; 21760ca821daSJian Shen 21770ca821daSJian Shen req = (struct hclge_vlan_filter_ctrl_cmd *)desc.data; 21780ca821daSJian Shen *vlan_fe = req->vlan_fe; 21790ca821daSJian Shen 21800ca821daSJian Shen return 0; 21810ca821daSJian Shen } 21820ca821daSJian Shen 21830ca821daSJian Shen static int hclge_get_port_vlan_filter_bypass_state(struct hclge_dev *hdev, 21840ca821daSJian Shen u8 vf_id, u8 *bypass_en) 21850ca821daSJian Shen { 21860ca821daSJian Shen struct hclge_port_vlan_filter_bypass_cmd *req; 21870ca821daSJian Shen struct hclge_desc desc; 21880ca821daSJian Shen int ret; 21890ca821daSJian Shen 21900ca821daSJian Shen if (!test_bit(HNAE3_DEV_SUPPORT_PORT_VLAN_BYPASS_B, hdev->ae_dev->caps)) 21910ca821daSJian Shen return 0; 21920ca821daSJian Shen 21930ca821daSJian Shen hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_PORT_VLAN_BYPASS, true); 21940ca821daSJian Shen req = (struct hclge_port_vlan_filter_bypass_cmd *)desc.data; 21950ca821daSJian Shen req->vf_id = vf_id; 21960ca821daSJian Shen 21970ca821daSJian Shen ret = hclge_cmd_send(&hdev->hw, &desc, 1); 21980ca821daSJian Shen if (ret) { 21990ca821daSJian Shen dev_err(&hdev->pdev->dev, 22000ca821daSJian Shen "failed to get vport%u port vlan filter bypass state, ret = %d.\n", 22010ca821daSJian Shen vf_id, ret); 22020ca821daSJian Shen return ret; 22030ca821daSJian Shen } 22040ca821daSJian Shen 22050ca821daSJian Shen *bypass_en = hnae3_get_bit(req->bypass_state, HCLGE_INGRESS_BYPASS_B); 22060ca821daSJian Shen 22070ca821daSJian Shen return 0; 22080ca821daSJian Shen } 22090ca821daSJian Shen 22100ca821daSJian Shen static const struct hclge_dbg_item vlan_filter_items[] = { 22110ca821daSJian Shen { "FUNC_ID", 2 }, 22120ca821daSJian Shen { "I_VF_VLAN_FILTER", 2 }, 22130ca821daSJian Shen { "E_VF_VLAN_FILTER", 2 }, 22140ca821daSJian Shen { "PORT_VLAN_FILTER_BYPASS", 0 } 22150ca821daSJian Shen }; 22160ca821daSJian Shen 22170ca821daSJian Shen static const struct hclge_dbg_item vlan_offload_items[] = { 22180ca821daSJian Shen { "FUNC_ID", 2 }, 22190ca821daSJian Shen { "PVID", 4 }, 22200ca821daSJian Shen { "ACCEPT_TAG1", 2 }, 22210ca821daSJian Shen { "ACCEPT_TAG2", 2 }, 22220ca821daSJian Shen { "ACCEPT_UNTAG1", 2 }, 22230ca821daSJian Shen { "ACCEPT_UNTAG2", 2 }, 22240ca821daSJian Shen { "INSERT_TAG1", 2 }, 22250ca821daSJian Shen { "INSERT_TAG2", 2 }, 22260ca821daSJian Shen { "SHIFT_TAG", 2 }, 22270ca821daSJian Shen { "STRIP_TAG1", 2 }, 22280ca821daSJian Shen { "STRIP_TAG2", 2 }, 22290ca821daSJian Shen { "DROP_TAG1", 2 }, 22300ca821daSJian Shen { "DROP_TAG2", 2 }, 22310ca821daSJian Shen { "PRI_ONLY_TAG1", 2 }, 22320ca821daSJian Shen { "PRI_ONLY_TAG2", 0 } 22330ca821daSJian Shen }; 22340ca821daSJian Shen 22350ca821daSJian Shen static int hclge_dbg_dump_vlan_filter_config(struct hclge_dev *hdev, char *buf, 22360ca821daSJian Shen int len, int *pos) 22370ca821daSJian Shen { 22380ca821daSJian Shen char content[HCLGE_DBG_VLAN_FLTR_INFO_LEN], str_id[HCLGE_DBG_ID_LEN]; 22390ca821daSJian Shen const char *result[ARRAY_SIZE(vlan_filter_items)]; 22400ca821daSJian Shen u8 i, j, vlan_fe, bypass, ingress, egress; 22410ca821daSJian Shen u8 func_num = pci_num_vf(hdev->pdev) + 1; /* pf and enabled vf num */ 22420ca821daSJian Shen int ret; 22430ca821daSJian Shen 22440ca821daSJian Shen ret = hclge_get_vlan_filter_state(hdev, HCLGE_FILTER_TYPE_PORT, 0, 22450ca821daSJian Shen &vlan_fe); 22460ca821daSJian Shen if (ret) 22470ca821daSJian Shen return ret; 22480ca821daSJian Shen ingress = vlan_fe & HCLGE_FILTER_FE_NIC_INGRESS_B; 22490ca821daSJian Shen egress = vlan_fe & HCLGE_FILTER_FE_NIC_EGRESS_B ? 1 : 0; 22500ca821daSJian Shen 22510ca821daSJian Shen *pos += scnprintf(buf, len, "I_PORT_VLAN_FILTER: %s\n", 22520ca821daSJian Shen state_str[ingress]); 22530ca821daSJian Shen *pos += scnprintf(buf + *pos, len - *pos, "E_PORT_VLAN_FILTER: %s\n", 22540ca821daSJian Shen state_str[egress]); 22550ca821daSJian Shen 22560ca821daSJian Shen hclge_dbg_fill_content(content, sizeof(content), vlan_filter_items, 22570ca821daSJian Shen NULL, ARRAY_SIZE(vlan_filter_items)); 22580ca821daSJian Shen *pos += scnprintf(buf + *pos, len - *pos, "%s", content); 22590ca821daSJian Shen 22600ca821daSJian Shen for (i = 0; i < func_num; i++) { 22610ca821daSJian Shen ret = hclge_get_vlan_filter_state(hdev, HCLGE_FILTER_TYPE_VF, i, 22620ca821daSJian Shen &vlan_fe); 22630ca821daSJian Shen if (ret) 22640ca821daSJian Shen return ret; 22650ca821daSJian Shen 22660ca821daSJian Shen ingress = vlan_fe & HCLGE_FILTER_FE_NIC_INGRESS_B; 22670ca821daSJian Shen egress = vlan_fe & HCLGE_FILTER_FE_NIC_EGRESS_B ? 1 : 0; 22680ca821daSJian Shen ret = hclge_get_port_vlan_filter_bypass_state(hdev, i, &bypass); 22690ca821daSJian Shen if (ret) 22700ca821daSJian Shen return ret; 22710ca821daSJian Shen j = 0; 22720ca821daSJian Shen result[j++] = hclge_dbg_get_func_id_str(str_id, i); 22730ca821daSJian Shen result[j++] = state_str[ingress]; 22740ca821daSJian Shen result[j++] = state_str[egress]; 22750ca821daSJian Shen result[j++] = 22760ca821daSJian Shen test_bit(HNAE3_DEV_SUPPORT_PORT_VLAN_BYPASS_B, 22770ca821daSJian Shen hdev->ae_dev->caps) ? state_str[bypass] : "NA"; 22780ca821daSJian Shen hclge_dbg_fill_content(content, sizeof(content), 22790ca821daSJian Shen vlan_filter_items, result, 22800ca821daSJian Shen ARRAY_SIZE(vlan_filter_items)); 22810ca821daSJian Shen *pos += scnprintf(buf + *pos, len - *pos, "%s", content); 22820ca821daSJian Shen } 22830ca821daSJian Shen *pos += scnprintf(buf + *pos, len - *pos, "\n"); 22840ca821daSJian Shen 22850ca821daSJian Shen return 0; 22860ca821daSJian Shen } 22870ca821daSJian Shen 22880ca821daSJian Shen static int hclge_dbg_dump_vlan_offload_config(struct hclge_dev *hdev, char *buf, 22890ca821daSJian Shen int len, int *pos) 22900ca821daSJian Shen { 22910ca821daSJian Shen char str_id[HCLGE_DBG_ID_LEN], str_pvid[HCLGE_DBG_ID_LEN]; 22920ca821daSJian Shen const char *result[ARRAY_SIZE(vlan_offload_items)]; 22930ca821daSJian Shen char content[HCLGE_DBG_VLAN_OFFLOAD_INFO_LEN]; 22940ca821daSJian Shen u8 func_num = pci_num_vf(hdev->pdev) + 1; /* pf and enabled vf num */ 22950ca821daSJian Shen struct hclge_dbg_vlan_cfg vlan_cfg; 22960ca821daSJian Shen int ret; 22970ca821daSJian Shen u8 i, j; 22980ca821daSJian Shen 22990ca821daSJian Shen hclge_dbg_fill_content(content, sizeof(content), vlan_offload_items, 23000ca821daSJian Shen NULL, ARRAY_SIZE(vlan_offload_items)); 23010ca821daSJian Shen *pos += scnprintf(buf + *pos, len - *pos, "%s", content); 23020ca821daSJian Shen 23030ca821daSJian Shen for (i = 0; i < func_num; i++) { 23040ca821daSJian Shen ret = hclge_get_vlan_tx_offload_cfg(hdev, i, &vlan_cfg); 23050ca821daSJian Shen if (ret) 23060ca821daSJian Shen return ret; 23070ca821daSJian Shen 23080ca821daSJian Shen ret = hclge_get_vlan_rx_offload_cfg(hdev, i, &vlan_cfg); 23090ca821daSJian Shen if (ret) 23100ca821daSJian Shen return ret; 23110ca821daSJian Shen 23120ca821daSJian Shen sprintf(str_pvid, "%u", vlan_cfg.pvid); 23130ca821daSJian Shen j = 0; 23140ca821daSJian Shen result[j++] = hclge_dbg_get_func_id_str(str_id, i); 23150ca821daSJian Shen result[j++] = str_pvid; 23160ca821daSJian Shen result[j++] = state_str[vlan_cfg.accept_tag1]; 23170ca821daSJian Shen result[j++] = state_str[vlan_cfg.accept_tag2]; 23180ca821daSJian Shen result[j++] = state_str[vlan_cfg.accept_untag1]; 23190ca821daSJian Shen result[j++] = state_str[vlan_cfg.accept_untag2]; 23200ca821daSJian Shen result[j++] = state_str[vlan_cfg.insert_tag1]; 23210ca821daSJian Shen result[j++] = state_str[vlan_cfg.insert_tag2]; 23220ca821daSJian Shen result[j++] = state_str[vlan_cfg.shift_tag]; 23230ca821daSJian Shen result[j++] = state_str[vlan_cfg.strip_tag1]; 23240ca821daSJian Shen result[j++] = state_str[vlan_cfg.strip_tag2]; 23250ca821daSJian Shen result[j++] = state_str[vlan_cfg.drop_tag1]; 23260ca821daSJian Shen result[j++] = state_str[vlan_cfg.drop_tag2]; 23270ca821daSJian Shen result[j++] = state_str[vlan_cfg.pri_only1]; 23280ca821daSJian Shen result[j++] = state_str[vlan_cfg.pri_only2]; 23290ca821daSJian Shen 23300ca821daSJian Shen hclge_dbg_fill_content(content, sizeof(content), 23310ca821daSJian Shen vlan_offload_items, result, 23320ca821daSJian Shen ARRAY_SIZE(vlan_offload_items)); 23330ca821daSJian Shen *pos += scnprintf(buf + *pos, len - *pos, "%s", content); 23340ca821daSJian Shen } 23350ca821daSJian Shen 23360ca821daSJian Shen return 0; 23370ca821daSJian Shen } 23380ca821daSJian Shen 23390ca821daSJian Shen static int hclge_dbg_dump_vlan_config(struct hclge_dev *hdev, char *buf, 23400ca821daSJian Shen int len) 23410ca821daSJian Shen { 23420ca821daSJian Shen int pos = 0; 23430ca821daSJian Shen int ret; 23440ca821daSJian Shen 23450ca821daSJian Shen ret = hclge_dbg_dump_vlan_filter_config(hdev, buf, len, &pos); 23460ca821daSJian Shen if (ret) 23470ca821daSJian Shen return ret; 23480ca821daSJian Shen 23490ca821daSJian Shen return hclge_dbg_dump_vlan_offload_config(hdev, buf, len, &pos); 23500ca821daSJian Shen } 23510ca821daSJian Shen 2352b34c157fSHuazhong Tan static int hclge_dbg_dump_ptp_info(struct hclge_dev *hdev, char *buf, int len) 2353b34c157fSHuazhong Tan { 2354b34c157fSHuazhong Tan struct hclge_ptp *ptp = hdev->ptp; 2355b34c157fSHuazhong Tan u32 sw_cfg = ptp->ptp_cfg; 2356b34c157fSHuazhong Tan unsigned int tx_start; 2357b34c157fSHuazhong Tan unsigned int last_rx; 2358b34c157fSHuazhong Tan int pos = 0; 2359b34c157fSHuazhong Tan u32 hw_cfg; 2360b34c157fSHuazhong Tan int ret; 2361b34c157fSHuazhong Tan 2362b34c157fSHuazhong Tan pos += scnprintf(buf + pos, len - pos, "phc %s's debug info:\n", 2363b34c157fSHuazhong Tan ptp->info.name); 2364b34c157fSHuazhong Tan pos += scnprintf(buf + pos, len - pos, "ptp enable: %s\n", 2365b34c157fSHuazhong Tan test_bit(HCLGE_PTP_FLAG_EN, &ptp->flags) ? 2366b34c157fSHuazhong Tan "yes" : "no"); 2367b34c157fSHuazhong Tan pos += scnprintf(buf + pos, len - pos, "ptp tx enable: %s\n", 2368b34c157fSHuazhong Tan test_bit(HCLGE_PTP_FLAG_TX_EN, &ptp->flags) ? 2369b34c157fSHuazhong Tan "yes" : "no"); 2370b34c157fSHuazhong Tan pos += scnprintf(buf + pos, len - pos, "ptp rx enable: %s\n", 2371b34c157fSHuazhong Tan test_bit(HCLGE_PTP_FLAG_RX_EN, &ptp->flags) ? 2372b34c157fSHuazhong Tan "yes" : "no"); 2373b34c157fSHuazhong Tan 2374b34c157fSHuazhong Tan last_rx = jiffies_to_msecs(ptp->last_rx); 2375b34c157fSHuazhong Tan pos += scnprintf(buf + pos, len - pos, "last rx time: %lu.%lu\n", 2376b34c157fSHuazhong Tan last_rx / MSEC_PER_SEC, last_rx % MSEC_PER_SEC); 2377b34c157fSHuazhong Tan pos += scnprintf(buf + pos, len - pos, "rx count: %lu\n", ptp->rx_cnt); 2378b34c157fSHuazhong Tan 2379b34c157fSHuazhong Tan tx_start = jiffies_to_msecs(ptp->tx_start); 2380b34c157fSHuazhong Tan pos += scnprintf(buf + pos, len - pos, "last tx start time: %lu.%lu\n", 2381b34c157fSHuazhong Tan tx_start / MSEC_PER_SEC, tx_start % MSEC_PER_SEC); 2382b34c157fSHuazhong Tan pos += scnprintf(buf + pos, len - pos, "tx count: %lu\n", ptp->tx_cnt); 2383b34c157fSHuazhong Tan pos += scnprintf(buf + pos, len - pos, "tx skipped count: %lu\n", 2384b34c157fSHuazhong Tan ptp->tx_skipped); 2385b34c157fSHuazhong Tan pos += scnprintf(buf + pos, len - pos, "tx timeout count: %lu\n", 2386b34c157fSHuazhong Tan ptp->tx_timeout); 2387b34c157fSHuazhong Tan pos += scnprintf(buf + pos, len - pos, "last tx seqid: %u\n", 2388b34c157fSHuazhong Tan ptp->last_tx_seqid); 2389b34c157fSHuazhong Tan 2390b34c157fSHuazhong Tan ret = hclge_ptp_cfg_qry(hdev, &hw_cfg); 2391b34c157fSHuazhong Tan if (ret) 2392b34c157fSHuazhong Tan return ret; 2393b34c157fSHuazhong Tan 2394b34c157fSHuazhong Tan pos += scnprintf(buf + pos, len - pos, "sw_cfg: %#x, hw_cfg: %#x\n", 2395b34c157fSHuazhong Tan sw_cfg, hw_cfg); 2396b34c157fSHuazhong Tan 2397b34c157fSHuazhong Tan pos += scnprintf(buf + pos, len - pos, "tx type: %d, rx filter: %d\n", 2398b34c157fSHuazhong Tan ptp->ts_cfg.tx_type, ptp->ts_cfg.rx_filter); 2399b34c157fSHuazhong Tan 2400b34c157fSHuazhong Tan return 0; 2401b34c157fSHuazhong Tan } 2402b34c157fSHuazhong Tan 24031556ea91SHuazhong Tan static int hclge_dbg_dump_mac_uc(struct hclge_dev *hdev, char *buf, int len) 24041556ea91SHuazhong Tan { 24051556ea91SHuazhong Tan hclge_dbg_dump_mac_list(hdev, buf, len, true); 24061556ea91SHuazhong Tan 24071556ea91SHuazhong Tan return 0; 24081556ea91SHuazhong Tan } 24091556ea91SHuazhong Tan 24101556ea91SHuazhong Tan static int hclge_dbg_dump_mac_mc(struct hclge_dev *hdev, char *buf, int len) 24111556ea91SHuazhong Tan { 24121556ea91SHuazhong Tan hclge_dbg_dump_mac_list(hdev, buf, len, false); 2413f671237aSJian Shen 2414f671237aSJian Shen return 0; 2415f671237aSJian Shen } 2416f671237aSJian Shen 24175e69ea7eSYufeng Mo static const struct hclge_dbg_func hclge_dbg_cmd_func[] = { 24185e69ea7eSYufeng Mo { 24195e69ea7eSYufeng Mo .cmd = HNAE3_DBG_CMD_TM_NODES, 24205e69ea7eSYufeng Mo .dbg_dump = hclge_dbg_dump_tm_nodes, 24215e69ea7eSYufeng Mo }, 24225e69ea7eSYufeng Mo { 24235e69ea7eSYufeng Mo .cmd = HNAE3_DBG_CMD_TM_PRI, 24245e69ea7eSYufeng Mo .dbg_dump = hclge_dbg_dump_tm_pri, 24255e69ea7eSYufeng Mo }, 24265e69ea7eSYufeng Mo { 24275e69ea7eSYufeng Mo .cmd = HNAE3_DBG_CMD_TM_QSET, 24285e69ea7eSYufeng Mo .dbg_dump = hclge_dbg_dump_tm_qset, 24295e69ea7eSYufeng Mo }, 24301556ea91SHuazhong Tan { 24317679f28eSGuangbin Huang .cmd = HNAE3_DBG_CMD_TM_MAP, 24327679f28eSGuangbin Huang .dbg_dump = hclge_dbg_dump_tm_map, 24337679f28eSGuangbin Huang }, 24347679f28eSGuangbin Huang { 2435cad7c215SGuangbin Huang .cmd = HNAE3_DBG_CMD_TM_PG, 2436cad7c215SGuangbin Huang .dbg_dump = hclge_dbg_dump_tm_pg, 2437cad7c215SGuangbin Huang }, 2438cad7c215SGuangbin Huang { 2439cad7c215SGuangbin Huang .cmd = HNAE3_DBG_CMD_TM_PORT, 2440cad7c215SGuangbin Huang .dbg_dump = hclge_dbg_dump_tm_port, 2441cad7c215SGuangbin Huang }, 2442cad7c215SGuangbin Huang { 24430e32038dSGuangbin Huang .cmd = HNAE3_DBG_CMD_TC_SCH_INFO, 24440e32038dSGuangbin Huang .dbg_dump = hclge_dbg_dump_tc, 24450e32038dSGuangbin Huang }, 24460e32038dSGuangbin Huang { 24476571ec2eSGuangbin Huang .cmd = HNAE3_DBG_CMD_QOS_PAUSE_CFG, 24486571ec2eSGuangbin Huang .dbg_dump = hclge_dbg_dump_qos_pause_cfg, 24496571ec2eSGuangbin Huang }, 24506571ec2eSGuangbin Huang { 245128d3badaSGuangbin Huang .cmd = HNAE3_DBG_CMD_QOS_PRI_MAP, 245228d3badaSGuangbin Huang .dbg_dump = hclge_dbg_dump_qos_pri_map, 245328d3badaSGuangbin Huang }, 245428d3badaSGuangbin Huang { 2455fddc02ebSGuangbin Huang .cmd = HNAE3_DBG_CMD_QOS_DSCP_MAP, 2456fddc02ebSGuangbin Huang .dbg_dump = hclge_dbg_dump_qos_dscp_map, 2457fddc02ebSGuangbin Huang }, 2458fddc02ebSGuangbin Huang { 245995b19586SGuangbin Huang .cmd = HNAE3_DBG_CMD_QOS_BUF_CFG, 246095b19586SGuangbin Huang .dbg_dump = hclge_dbg_dump_qos_buf_cfg, 246195b19586SGuangbin Huang }, 246295b19586SGuangbin Huang { 24631556ea91SHuazhong Tan .cmd = HNAE3_DBG_CMD_MAC_UC, 24641556ea91SHuazhong Tan .dbg_dump = hclge_dbg_dump_mac_uc, 24651556ea91SHuazhong Tan }, 24661556ea91SHuazhong Tan { 24671556ea91SHuazhong Tan .cmd = HNAE3_DBG_CMD_MAC_MC, 24681556ea91SHuazhong Tan .dbg_dump = hclge_dbg_dump_mac_mc, 24691556ea91SHuazhong Tan }, 24708ddfd9c4SYufeng Mo { 24718ddfd9c4SYufeng Mo .cmd = HNAE3_DBG_CMD_MNG_TBL, 24728ddfd9c4SYufeng Mo .dbg_dump = hclge_dbg_dump_mng_table, 24738ddfd9c4SYufeng Mo }, 2474d658ff34SYufeng Mo { 2475d658ff34SYufeng Mo .cmd = HNAE3_DBG_CMD_LOOPBACK, 2476d658ff34SYufeng Mo .dbg_dump = hclge_dbg_dump_loopback, 2477d658ff34SYufeng Mo }, 24789149ca0fSJiaran Zhang { 2479b34c157fSHuazhong Tan .cmd = HNAE3_DBG_CMD_PTP_INFO, 2480b34c157fSHuazhong Tan .dbg_dump = hclge_dbg_dump_ptp_info, 2481b34c157fSHuazhong Tan }, 2482b34c157fSHuazhong Tan { 24839149ca0fSJiaran Zhang .cmd = HNAE3_DBG_CMD_INTERRUPT_INFO, 24849149ca0fSJiaran Zhang .dbg_dump = hclge_dbg_dump_interrupt, 24859149ca0fSJiaran Zhang }, 24861a7ff828SJiaran Zhang { 24871a7ff828SJiaran Zhang .cmd = HNAE3_DBG_CMD_RESET_INFO, 24881a7ff828SJiaran Zhang .dbg_dump = hclge_dbg_dump_rst_info, 24891a7ff828SJiaran Zhang }, 24900b198b0dSJiaran Zhang { 24910b198b0dSJiaran Zhang .cmd = HNAE3_DBG_CMD_IMP_INFO, 24920b198b0dSJiaran Zhang .dbg_dump = hclge_dbg_get_imp_stats_info, 24930b198b0dSJiaran Zhang }, 2494e76e6886SJiaran Zhang { 2495e76e6886SJiaran Zhang .cmd = HNAE3_DBG_CMD_NCL_CONFIG, 2496e76e6886SJiaran Zhang .dbg_dump = hclge_dbg_dump_ncl_config, 2497e76e6886SJiaran Zhang }, 2498d96b0e59SYufeng Mo { 2499d96b0e59SYufeng Mo .cmd = HNAE3_DBG_CMD_REG_BIOS_COMMON, 2500d96b0e59SYufeng Mo .dbg_dump_reg = hclge_dbg_dump_reg_cmd, 2501d96b0e59SYufeng Mo }, 2502d96b0e59SYufeng Mo { 2503d96b0e59SYufeng Mo .cmd = HNAE3_DBG_CMD_REG_SSU, 2504d96b0e59SYufeng Mo .dbg_dump_reg = hclge_dbg_dump_reg_cmd, 2505d96b0e59SYufeng Mo }, 2506d96b0e59SYufeng Mo { 2507d96b0e59SYufeng Mo .cmd = HNAE3_DBG_CMD_REG_IGU_EGU, 2508d96b0e59SYufeng Mo .dbg_dump_reg = hclge_dbg_dump_reg_cmd, 2509d96b0e59SYufeng Mo }, 2510d96b0e59SYufeng Mo { 2511d96b0e59SYufeng Mo .cmd = HNAE3_DBG_CMD_REG_RPU, 2512d96b0e59SYufeng Mo .dbg_dump_reg = hclge_dbg_dump_reg_cmd, 2513d96b0e59SYufeng Mo }, 2514d96b0e59SYufeng Mo { 2515d96b0e59SYufeng Mo .cmd = HNAE3_DBG_CMD_REG_NCSI, 2516d96b0e59SYufeng Mo .dbg_dump_reg = hclge_dbg_dump_reg_cmd, 2517d96b0e59SYufeng Mo }, 2518d96b0e59SYufeng Mo { 2519d96b0e59SYufeng Mo .cmd = HNAE3_DBG_CMD_REG_RTC, 2520d96b0e59SYufeng Mo .dbg_dump_reg = hclge_dbg_dump_reg_cmd, 2521d96b0e59SYufeng Mo }, 2522d96b0e59SYufeng Mo { 2523d96b0e59SYufeng Mo .cmd = HNAE3_DBG_CMD_REG_PPP, 2524d96b0e59SYufeng Mo .dbg_dump_reg = hclge_dbg_dump_reg_cmd, 2525d96b0e59SYufeng Mo }, 2526d96b0e59SYufeng Mo { 2527d96b0e59SYufeng Mo .cmd = HNAE3_DBG_CMD_REG_RCB, 2528d96b0e59SYufeng Mo .dbg_dump_reg = hclge_dbg_dump_reg_cmd, 2529d96b0e59SYufeng Mo }, 2530d96b0e59SYufeng Mo { 2531d96b0e59SYufeng Mo .cmd = HNAE3_DBG_CMD_REG_TQP, 2532d96b0e59SYufeng Mo .dbg_dump_reg = hclge_dbg_dump_reg_cmd, 2533d96b0e59SYufeng Mo }, 2534d96b0e59SYufeng Mo { 2535d96b0e59SYufeng Mo .cmd = HNAE3_DBG_CMD_REG_MAC, 2536d96b0e59SYufeng Mo .dbg_dump = hclge_dbg_dump_mac, 2537d96b0e59SYufeng Mo }, 2538365e860aSYufeng Mo { 2539365e860aSYufeng Mo .cmd = HNAE3_DBG_CMD_REG_DCB, 2540365e860aSYufeng Mo .dbg_dump = hclge_dbg_dump_dcb, 2541365e860aSYufeng Mo }, 2542b5a0b70dSHao Chen { 2543b5a0b70dSHao Chen .cmd = HNAE3_DBG_CMD_FD_TCAM, 2544b5a0b70dSHao Chen .dbg_dump = hclge_dbg_dump_fd_tcam, 2545b5a0b70dSHao Chen }, 25467b07ab06SJiaran Zhang { 25477b07ab06SJiaran Zhang .cmd = HNAE3_DBG_CMD_MAC_TNL_STATUS, 25487b07ab06SJiaran Zhang .dbg_dump = hclge_dbg_dump_mac_tnl_status, 25497b07ab06SJiaran Zhang }, 2550058c3be9SYufeng Mo { 2551058c3be9SYufeng Mo .cmd = HNAE3_DBG_CMD_SERV_INFO, 2552058c3be9SYufeng Mo .dbg_dump = hclge_dbg_dump_serv_info, 2553058c3be9SYufeng Mo }, 25540ca821daSJian Shen { 25550ca821daSJian Shen .cmd = HNAE3_DBG_CMD_VLAN_CONFIG, 25560ca821daSJian Shen .dbg_dump = hclge_dbg_dump_vlan_config, 25570ca821daSJian Shen }, 255803a92fe8SJian Shen { 255903a92fe8SJian Shen .cmd = HNAE3_DBG_CMD_FD_COUNTER, 256003a92fe8SJian Shen .dbg_dump = hclge_dbg_dump_fd_counter, 256103a92fe8SJian Shen }, 2562d59daf6aSJian Shen { 2563d59daf6aSJian Shen .cmd = HNAE3_DBG_CMD_UMV_INFO, 2564d59daf6aSJian Shen .dbg_dump = hclge_dbg_dump_umv_info, 2565d59daf6aSJian Shen }, 25665e69ea7eSYufeng Mo }; 25675e69ea7eSYufeng Mo 25685e69ea7eSYufeng Mo int hclge_dbg_read_cmd(struct hnae3_handle *handle, enum hnae3_dbg_cmd cmd, 256904987ca1SGuangbin Huang char *buf, int len) 257004987ca1SGuangbin Huang { 257104987ca1SGuangbin Huang struct hclge_vport *vport = hclge_get_vport(handle); 2572d96b0e59SYufeng Mo const struct hclge_dbg_func *cmd_func; 257304987ca1SGuangbin Huang struct hclge_dev *hdev = vport->back; 25745e69ea7eSYufeng Mo u32 i; 257504987ca1SGuangbin Huang 25765e69ea7eSYufeng Mo for (i = 0; i < ARRAY_SIZE(hclge_dbg_cmd_func); i++) { 2577d96b0e59SYufeng Mo if (cmd == hclge_dbg_cmd_func[i].cmd) { 2578d96b0e59SYufeng Mo cmd_func = &hclge_dbg_cmd_func[i]; 2579d96b0e59SYufeng Mo if (cmd_func->dbg_dump) 2580d96b0e59SYufeng Mo return cmd_func->dbg_dump(hdev, buf, len); 2581d96b0e59SYufeng Mo else 2582d96b0e59SYufeng Mo return cmd_func->dbg_dump_reg(hdev, cmd, buf, 2583d96b0e59SYufeng Mo len); 2584d96b0e59SYufeng Mo } 25855e69ea7eSYufeng Mo } 258604987ca1SGuangbin Huang 25875e69ea7eSYufeng Mo dev_err(&hdev->pdev->dev, "invalid command(%d)\n", cmd); 258804987ca1SGuangbin Huang return -EINVAL; 258904987ca1SGuangbin Huang } 2590