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"
10939ccd10SJijie 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 */
hclge_dbg_fill_content(char * content,u16 len,const struct hclge_dbg_item * items,const char ** result,u16 size)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
hclge_dbg_get_func_id_str(char * buf,u8 id)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
hclge_dbg_get_dfx_bd_num(struct hclge_dev * hdev,int offset,u32 * bd_num)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
hclge_dbg_cmd_send(struct hclge_dev * hdev,struct hclge_desc * desc_src,int index,int bd_num,enum hclge_opcode_type cmd)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
hclge_dbg_dump_reg_tqp(struct hclge_dev * hdev,const struct hclge_dbg_reg_type_info * reg_info,char * buf,int len,int * pos)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
hclge_dbg_dump_reg_common(struct hclge_dev * hdev,const struct hclge_dbg_reg_type_info * reg_info,char * buf,int len,int * pos)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
hclge_dbg_dump_mac_enable_status(struct hclge_dev * hdev,char * buf,int len,int * pos)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
hclge_dbg_dump_mac_frame_size(struct hclge_dev * hdev,char * buf,int len,int * pos)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
hclge_dbg_dump_mac_speed_duplex(struct hclge_dev * hdev,char * buf,int len,int * pos)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
hclge_dbg_dump_mac(struct hclge_dev * hdev,char * buf,int len)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
hclge_dbg_dump_dcb_qset(struct hclge_dev * hdev,char * buf,int len,int * pos)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
hclge_dbg_dump_dcb_pri(struct hclge_dev * hdev,char * buf,int len,int * pos)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
hclge_dbg_dump_dcb_pg(struct hclge_dev * hdev,char * buf,int len,int * pos)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
hclge_dbg_dump_dcb_queue(struct hclge_dev * hdev,char * buf,int len,int * pos)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
hclge_dbg_dump_dcb_port(struct hclge_dev * hdev,char * buf,int len,int * pos)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
hclge_dbg_dump_dcb_tm(struct hclge_dev * hdev,char * buf,int len,int * pos)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
hclge_dbg_dump_dcb(struct hclge_dev * hdev,char * buf,int len)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
hclge_dbg_dump_reg_cmd(struct hclge_dev * hdev,enum hnae3_dbg_cmd cmd,char * buf,int len)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
hclge_dbg_dump_tc(struct hclge_dev * hdev,char * buf,int len)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
hclge_dbg_fill_shaper_content(struct hclge_tm_shaper_para * para,char ** result,u8 * index)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
__hclge_dbg_dump_tm_pg(struct hclge_dev * hdev,char * data_str,char * buf,int len)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
hclge_dbg_dump_tm_pg(struct hclge_dev * hdev,char * buf,int len)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
hclge_dbg_dump_tm_port(struct hclge_dev * hdev,char * buf,int len)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
hclge_dbg_dump_tm_bp_qset_map(struct hclge_dev * hdev,u8 tc_id,char * buf,int len)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
hclge_dbg_dump_tm_map(struct hclge_dev * hdev,char * buf,int len)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
hclge_dbg_dump_tm_nodes(struct hclge_dev * hdev,char * buf,int len)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
hclge_dbg_dump_tm_pri(struct hclge_dev * hdev,char * buf,int len)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
hclge_dbg_dump_tm_qset(struct hclge_dev * hdev,char * buf,int len)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
hclge_dbg_dump_qos_pause_cfg(struct hclge_dev * hdev,char * buf,int len)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
hclge_dbg_dump_qos_pri_map(struct hclge_dev * hdev,char * buf,int len)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
hclge_dbg_dump_qos_dscp_map(struct hclge_dev * hdev,char * buf,int len)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
hclge_dbg_dump_tx_buf_cfg(struct hclge_dev * hdev,char * buf,int len)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
hclge_dbg_dump_rx_priv_buf_cfg(struct hclge_dev * hdev,char * buf,int len)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
hclge_dbg_dump_rx_common_wl_cfg(struct hclge_dev * hdev,char * buf,int len)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
hclge_dbg_dump_rx_global_pkt_cnt(struct hclge_dev * hdev,char * buf,int len)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
hclge_dbg_dump_rx_priv_wl_buf_cfg(struct hclge_dev * hdev,char * buf,int len)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
hclge_dbg_dump_rx_common_threshold_cfg(struct hclge_dev * hdev,char * buf,int len)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
hclge_dbg_dump_qos_buf_cfg(struct hclge_dev * hdev,char * buf,int len)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
hclge_dbg_dump_mng_table(struct hclge_dev * hdev,char * buf,int len)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
hclge_dbg_fd_tcam_read(struct hclge_dev * hdev,bool sel_x,char * tcam_buf,struct hclge_dbg_tcam_msg tcam_msg)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;
1522*efccf655SHao Chen __le32 *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 */
1547*efccf655SHao Chen req = (__le32 *)req1->tcam_data;
15483c666b58Sliuzhongzhu for (i = 0; i < 2; i++)
1549b5a0b70dSHao Chen pos += scnprintf(tcam_buf + pos, HCLGE_DBG_TCAM_BUF_SIZE - pos,
1550*efccf655SHao Chen "%08x\n", le32_to_cpu(*req++));
15513c666b58Sliuzhongzhu
155246ee7350SGuojia Liao /* tcam_data2 ~ tcam_data7 */
1553*efccf655SHao Chen req = (__le32 *)req2->tcam_data;
15543c666b58Sliuzhongzhu for (i = 0; i < 6; i++)
1555b5a0b70dSHao Chen pos += scnprintf(tcam_buf + pos, HCLGE_DBG_TCAM_BUF_SIZE - pos,
1556*efccf655SHao Chen "%08x\n", le32_to_cpu(*req++));
15573c666b58Sliuzhongzhu
155846ee7350SGuojia Liao /* tcam_data8 ~ tcam_data12 */
1559*efccf655SHao Chen req = (__le32 *)req3->tcam_data;
15603c666b58Sliuzhongzhu for (i = 0; i < 5; i++)
1561b5a0b70dSHao Chen pos += scnprintf(tcam_buf + pos, HCLGE_DBG_TCAM_BUF_SIZE - pos,
1562*efccf655SHao Chen "%08x\n", le32_to_cpu(*req++));
156344b6b883SYufeng Mo
156444b6b883SYufeng Mo return ret;
156544b6b883SYufeng Mo }
156644b6b883SYufeng Mo
hclge_dbg_get_rules_location(struct hclge_dev * hdev,u16 * rule_locs)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
hclge_dbg_dump_fd_tcam(struct hclge_dev * hdev,char * buf,int len)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
hclge_dbg_dump_fd_counter(struct hclge_dev * hdev,char * buf,int len)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
hclge_dbg_dump_rst_info(struct hclge_dev * hdev,char * buf,int len)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
hclge_dbg_dump_serv_info(struct hclge_dev * hdev,char * buf,int len)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
hclge_dbg_dump_interrupt(struct hclge_dev * hdev,char * buf,int len)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
hclge_dbg_imp_info_data_print(struct hclge_desc * desc_src,char * buf,int len,u32 bd_num)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
hclge_dbg_get_imp_stats_info(struct hclge_dev * hdev,char * buf,int len)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
hclge_ncl_config_data_print(struct hclge_desc * desc,int * index,char * buf,int len,int * pos)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
hclge_dbg_dump_ncl_config(struct hclge_dev * hdev,char * buf,int len)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
hclge_dbg_dump_loopback(struct hclge_dev * hdev,char * buf,int len)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
hclge_dbg_dump_mac_tnl_status(struct hclge_dev * hdev,char * buf,int len)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
hclge_dbg_dump_mac_list(struct hclge_dev * hdev,char * buf,int len,bool is_unicast)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
hclge_dbg_dump_umv_info(struct hclge_dev * hdev,char * buf,int len)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
hclge_get_vlan_rx_offload_cfg(struct hclge_dev * hdev,u8 vf_id,struct hclge_dbg_vlan_cfg * vlan_cfg)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
hclge_get_vlan_tx_offload_cfg(struct hclge_dev * hdev,u8 vf_id,struct hclge_dbg_vlan_cfg * vlan_cfg)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
hclge_get_vlan_filter_config_cmd(struct hclge_dev * hdev,u8 vlan_type,u8 vf_id,struct hclge_desc * desc)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
hclge_get_vlan_filter_state(struct hclge_dev * hdev,u8 vlan_type,u8 vf_id,u8 * vlan_fe)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
hclge_get_port_vlan_filter_bypass_state(struct hclge_dev * hdev,u8 vf_id,u8 * bypass_en)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
hclge_dbg_dump_vlan_filter_config(struct hclge_dev * hdev,char * buf,int len,int * pos)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
hclge_dbg_dump_vlan_offload_config(struct hclge_dev * hdev,char * buf,int len,int * pos)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
hclge_dbg_dump_vlan_config(struct hclge_dev * hdev,char * buf,int len)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
hclge_dbg_dump_ptp_info(struct hclge_dev * hdev,char * buf,int len)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
hclge_dbg_dump_mac_uc(struct hclge_dev * hdev,char * buf,int len)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
hclge_dbg_dump_mac_mc(struct hclge_dev * hdev,char * buf,int len)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
hclge_dbg_read_cmd(struct hnae3_handle * handle,enum hnae3_dbg_cmd cmd,char * buf,int len)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