packages/hikptool
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

hikptool: Add HCCS and SDMA modules along with log collection

Browse Source 
The HCCS and SDMA modules and the log collection function are added.

Signed-off-by: zhangyuyang <zhangyuyang31@huawei.com>
(cherry picked from commit 73fe961568c3b5e4406a65a46e926f2f0623d585)
This commit is contained in:
zhangyuyang 2025-03-18 15:58:54 +08:00 committed by openeuler-sync-bot
parent 6d9f796b1d
commit a1e8d45430
10 changed files with 10276 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6084
0090-hikptool-Support-for-info-collect.patch Normal file
View File

File diff suppressed because it is too large Load Diff

2007
0091-hikptool-Added-compilation-options.patch Normal file
View File

File diff suppressed because it is too large Load Diff

59
0092-hikptool-pcie-The-query-result-of-pcie_dumpreg-does-.patch Normal file
View File

@ -0,0 +1,59 @@
From 4fa7bfb97799f85940d2c8cec1a2078a3a637d4d Mon Sep 17 00:00:00 2001
From: moubingquan <moubingquan@huawei.com>
Date: Fri, 20 Dec 2024 15:03:30 +0800
Subject: [PATCH 69/81] [hikptool/ pcie]:The query result of pcie_dumpreg does
not match the register list.
Rectify the problem that the pcie_regdump
command dump registers do not match the register table.
Signed-off-by: moubingquan <moubingquan@huawei.com>
---
pcie/func_lib/pcie_func/pcie_reg_dump.c | 8 ++------
1 file changed, 2 insertions(+), 6 deletions(-)
diff --git a/pcie/func_lib/pcie_func/pcie_reg_dump.c b/pcie/func_lib/pcie_func/pcie_reg_dump.c
index 4172637..ad7cc7f 100644
--- a/pcie/func_lib/pcie_func/pcie_reg_dump.c
+++ b/pcie/func_lib/pcie_func/pcie_reg_dump.c
@@ -64,10 +64,8 @@ struct pcie_dumpreg_info g_reg_table_tl[] = {
{0, "TL_RX_NONPOST_CNT"},
{0, "TL_RX_CPL_CNT"},
{0, "TL_RX_LOC_TLP_CNT"},
- {0, "TL_RX_ERR_STATUS"},
{0, "TL_CFGSPACE_BDF"},
{0, "TL_TX_UR_CNT"},
- {0, "TL_RX_ERR_STATUS"},
};
struct pcie_dumpreg_info g_reg_table_dl[] = {
@@ -126,7 +124,6 @@ struct pcie_dumpreg_info g_reg_table_mac[] = {
{0, "MAC_REG_DEBUG_PIPE9"},
{0, "MAC_REG_DEBUG_PIPE10"},
{0, "MAC_REG_DEBUG_PIPE11"},
- {0, "MAC_LEAVE_L0_INFO"},
{0, "DFX_APB_LANE_ERROR_STATUS_0"},
{0, "DFX_APB_LANE_ERROR_STATUS_1"},
{0, "MAC_REG_PHY_RXDATA_TS_REG"},
@@ -255,7 +252,6 @@ struct pcie_dumpreg_info g_reg_table_iob_rx[] = {
{0, "DFX_IOB_RX_CNT_RESP_RX"},
{0, "DFX_IOB_RX_CNT_RESP_LOC"},
{0, "DFX_IOB_RX_CNT_RESP_RECV"},
- {0, "IOB_RX_INT_STATUS"},
{0, "DFX_IOB_RX_AMB_WR_CNT_0"},
{0, "DFX_IOB_RX_AMB_WR_CNT_1"},
{0, "DFX_IOB_RX_AMB_RD_CNT_0"},
@@ -369,8 +365,8 @@ struct pcie_dumpreg_info g_reg_table_core_glb[] = {
{0, "CORE_INT_FE_RO_2"},
{0, "PORT07_LINK_MODE"},
{0, "PORT815_LINK_MODE"},
- {0, "PCIE_LINK_DOWN_CLR_PORT_EN_REG"},
- {0, "CORE_CLK_FLG_REG"},
+ {0, "PCIE_LINK_DOWN_CLR_PORT_EN"},
+ {0, "CORE_CLK_FLG"},
};
struct pcie_dumpreg_info g_reg_table_core_tl[] = {
--
2.45.0.windows.1

1032
0093-hikptool-hccs-support-dump-hccs-info.patch Normal file
View File

File diff suppressed because it is too large Load Diff

73
0094-hikptool-pcie-The-PCS-layer-register-print-command-i.patch Normal file
View File

@ -0,0 +1,73 @@
From 315bab874c894053be65b47be3ac783dcd1259da Mon Sep 17 00:00:00 2001
From: moubingquan <moubingquan@huawei.com>
Date: Wed, 8 Jan 2025 10:49:19 +0800
Subject: [PATCH 71/81] [hikptool/ pcie]:The PCS-layer register print command
is deleted.
The register print of the PCS layer is deleted.
Currently, the register of this module does
not need to be dumped.
Signed-off-by: moubingquan <moubingquan@huawei.com>
---
pcie/func_lib/pcie_func/pcie_reg_dump.c | 15 ---------------
pcie/func_lib/pcie_func/pcie_reg_dump.h | 10 ----------
2 files changed, 25 deletions(-)
diff --git a/pcie/func_lib/pcie_func/pcie_reg_dump.c b/pcie/func_lib/pcie_func/pcie_reg_dump.c
index ad7cc7f..cb59d2c 100644
--- a/pcie/func_lib/pcie_func/pcie_reg_dump.c
+++ b/pcie/func_lib/pcie_func/pcie_reg_dump.c
@@ -131,20 +131,6 @@ struct pcie_dumpreg_info g_reg_table_mac[] = {
{0, "MAC_POWERDOWN_VALUE_REG"},
};
-struct pcie_dumpreg_info g_reg_table_pcs[] = {
- HIKP_PCIE_PCS_LANE_TBL_ENTRY(SERDES_STATUS_RPT),
- HIKP_PCIE_PCS_LANE_TBL_ENTRY(EBUF_STATUS),
- HIKP_PCIE_PCS_LANE_TBL_ENTRY(GEN3_DEC_ENC_STATUS),
- HIKP_PCIE_PCS_LANE_TBL_ENTRY(WAKE_STATUS),
- HIKP_PCIE_PCS_LANE_TBL_ENTRY(RECV_DET_OR_PWR_CHAGE),
- HIKP_PCIE_PCS_LANE_TBL_ENTRY(EQEVAL_STATUS),
- HIKP_PCIE_PCS_LANE_TBL_ENTRY(LANE_INTR_STATUS),
- HIKP_PCIE_PCS_LANE_TBL_ENTRY(M_PCS_RPT_REG),
- HIKP_PCIE_PCS_LANE_TBL_ENTRY(MSG_BUS_DFX),
- HIKP_PCIE_PCS_LANE_TBL_ENTRY(DETECT_CLK_FLG_REG),
- HIKP_PCIE_PCS_LANE_TBL_ENTRY(SDS_CFG_REG_REG),
-};
-
struct pcie_dumpreg_info g_reg_table_iob_tx[] = {
{0, "IOB_TX_ECAM_CONTROL0"},
{0, "IOB_TX_ECAM_CONTROL1"},
@@ -456,7 +442,6 @@ struct pcie_dumpreg_table g_dump_info_glb[] = {
{HIKP_ARRAY_SIZE(g_reg_table_iob_rx), g_reg_table_iob_rx},
{HIKP_ARRAY_SIZE(g_reg_table_ap_glb), g_reg_table_ap_glb},
{HIKP_ARRAY_SIZE(g_reg_table_core_glb), g_reg_table_core_glb},
- {HIKP_ARRAY_SIZE(g_reg_table_pcs), g_reg_table_pcs},
{HIKP_ARRAY_SIZE(g_reg_table_core_tl), g_reg_table_core_tl},
{HIKP_ARRAY_SIZE(g_reg_table_dfx_core_tl), g_reg_table_dfx_core_tl},
};
diff --git a/pcie/func_lib/pcie_func/pcie_reg_dump.h b/pcie/func_lib/pcie_func/pcie_reg_dump.h
index 3c52a6e..c74ce56 100644
--- a/pcie/func_lib/pcie_func/pcie_reg_dump.h
+++ b/pcie/func_lib/pcie_func/pcie_reg_dump.h
@@ -22,16 +22,6 @@
#define PCIE_DUMPREG_LOGFILE_NAME "pcie_dumpreg"
#define LOG_FILE_PATH_MAX_LEN 512
-#define HIKP_PCIE_PCS_LANE_TBL_ENTRY(name) \
- {0, STR(CONTACT(name, _00))}, {0, STR(CONTACT(name, _01))}, \
- {0, STR(CONTACT(name, _02))}, {0, STR(CONTACT(name, _03))}, \
- {0, STR(CONTACT(name, _04))}, {0, STR(CONTACT(name, _05))}, \
- {0, STR(CONTACT(name, _06))}, {0, STR(CONTACT(name, _07))}, \
- {0, STR(CONTACT(name, _08))}, {0, STR(CONTACT(name, _09))}, \
- {0, STR(CONTACT(name, _10))}, {0, STR(CONTACT(name, _11))}, \
- {0, STR(CONTACT(name, _12))}, {0, STR(CONTACT(name, _13))}, \
- {0, STR(CONTACT(name, _14))}, {0, STR(CONTACT(name, _15))}
-
enum pcie_dump_level {
DUMP_GLOBAL_LEVEL = 1,
DUMP_PORT_LEVEL = 2,
--
2.45.0.windows.1

119
0095-hikptool-pcie-Resolved-the-problem-that-it-takes-a-l.patch Normal file
View File

@ -0,0 +1,119 @@
From 2f868efe20df8a6c0d28969912bee91d82482c21 Mon Sep 17 00:00:00 2001
From: moubingquan <moubingquan@huawei.com>
Date: Wed, 15 Jan 2025 10:24:28 +0800
Subject: [PATCH] hikptool/pcie: Resolved the problem that it takes a long time
to write files
The write function takes a long time to write
files when the FIO pressure is heavy.
Therefore, the function needs to be changed to
fwrite with cache.
Signed-off-by: moubingquan <moubingquan@huawei.com>
---
pcie/func_lib/pcie_func/pcie_reg_dump.c | 34 +++++++++++--------------
1 file changed, 15 insertions(+), 19 deletions(-)
diff --git a/pcie/func_lib/pcie_func/pcie_reg_dump.c b/pcie/func_lib/pcie_func/pcie_reg_dump.c
index cb59d2c..ba6641e 100644
--- a/pcie/func_lib/pcie_func/pcie_reg_dump.c
+++ b/pcie/func_lib/pcie_func/pcie_reg_dump.c
@@ -22,7 +22,7 @@
#include "pcie_common.h"
#include "pcie_reg_dump.h"
-int g_pcie_dumpreg_fd;
+FILE *g_pcie_dumpreg_fd = NULL;
char dumpreg_log_file[MAX_LOG_NAME_LEN + 1] = {0};
struct pcie_dumpreg_info g_reg_table_tl[] = {
@@ -381,7 +381,7 @@ static int pcie_create_dumpreg_log_file(uint32_t port_id, uint32_t dump_level)
{
char file_name[MAX_LOG_NAME_LEN + 1] = { 0 };
char info_str[MAX_LOG_NAME_LEN + 1] = { 0 };
- int fd_file;
+ FILE *fd_file = NULL;
int ret;
ret = snprintf(info_str, sizeof(info_str), "%s_port%u_level%u",
@@ -399,8 +399,8 @@ static int pcie_create_dumpreg_log_file(uint32_t port_id, uint32_t dump_level)
(void)remove((const char *)file_name);
/* Add write permission to the file */
- fd_file = open(file_name, O_RDWR | O_SYNC | O_CREAT, 0600);
- if (fd_file < 0) {
+ fd_file = fopen(file_name, "w+");
+ if (fd_file == NULL) {
Err("open %s failed.\n", file_name);
return -EPERM;
}
@@ -409,30 +409,26 @@ static int pcie_create_dumpreg_log_file(uint32_t port_id, uint32_t dump_level)
return 0;
}
-static int pcie_close_dumpreg_log_file(void)
+static void pcie_close_dumpreg_log_file(void)
{
- int ret;
-
- ret = fchmod(g_pcie_dumpreg_fd, 0400);
- close(g_pcie_dumpreg_fd);
+ fclose(g_pcie_dumpreg_fd);
/* Revoke write permission of file */
- g_pcie_dumpreg_fd = -1;
-
- return ret;
+ chmod(dumpreg_log_file, 0400);
+ g_pcie_dumpreg_fd = NULL;
}
static void pcie_dumpreg_write_value_to_file(const char *reg_name, uint32_t val)
{
char str[MAX_STR_LEN] = { 0 };
- ssize_t wr_ret;
+ size_t wr_ret;
int ret;
ret = snprintf(str, sizeof(str), " %-40s : 0x%x\n", reg_name, val);
if (ret < 0 || ret >= MAX_STR_LEN) {
Err("pcie dumpreg write info to logfile failed.\n");
} else {
- wr_ret = write(g_pcie_dumpreg_fd, str, strlen(str));
- if (wr_ret == -1)
+ wr_ret = fwrite(str, 1, strlen(str), g_pcie_dumpreg_fd);
+ if (wr_ret != strlen(str))
Err("write info to logfile failed.\n");
}
}
@@ -470,7 +466,7 @@ static int pcie_dumpreg_write_header_to_file(uint32_t version,
const struct pcie_dump_req_para *req_data)
{
char str[MAX_STR_LEN] = {0};
- ssize_t wr_ret;
+ size_t wr_ret;
int ret;
ret = snprintf(str, sizeof(str), "Command Version[%u], dump_level[%u], port_id[%u]\n\n",
@@ -480,8 +476,8 @@ static int pcie_dumpreg_write_header_to_file(uint32_t version,
return -EIO;
}
- wr_ret = write(g_pcie_dumpreg_fd, str, strlen(str));
- if (wr_ret == -1) {
+ wr_ret = fwrite(str, 1, strlen(str), g_pcie_dumpreg_fd);
+ if (wr_ret != strlen(str)) {
Err("write header to logfile failed.\n");
return -EIO;
}
@@ -566,7 +562,7 @@ int pcie_dumpreg_do_dump(uint32_t port_id, uint32_t dump_level)
Info("pcie reg dump finish.\n");
close_file_ret:
- (void)pcie_close_dumpreg_log_file();
+ pcie_close_dumpreg_log_file();
free_cmd_ret:
hikp_cmd_free(&cmd_ret);
--
2.45.0.windows.1

472
0096-Hikptool-add-support-dump-SDMA-register-information-.patch Normal file
View File

@ -0,0 +1,472 @@
From fde1f62e767c37f6a6c717df3d03154d081da47e Mon Sep 17 00:00:00 2001
From: wangzijian <wangzijian22@huawei.com>
Date: Tue, 25 Feb 2025 07:11:27 +0800
Subject: [PATCH 1/2] Hikptool add support dump SDMA register information
according to the usage environment.
1. support dump SDMA channel status reg e.g. hikptool sdma_dump -s -c <chip_id> -d <die_id>
2. support dump SDMA pc reg e.g. hikptool sdma_dump -p -c <chip_id> -d <die_id> -n <chn_id>
3. support dump SDMA vc reg e.g. hikptool sdma_dump -v -c <chip_id> -d <die_id> -n <chn_id>
Signed-off-by: wangzijian <wangzijian22@huawei.com>
---
CMakeLists.txt | 1 +
libhikptdev/include/hikptdev_plug.h | 3 +-
sdma/sdma_func/sdma_common.h | 31 +++++
sdma/sdma_func/sdma_dump_reg.c | 133 ++++++++++++++++++++++
sdma/sdma_func/sdma_dump_reg.h | 28 +++++
sdma/user_cmd/sdma_cmd_dump.c | 171 ++++++++++++++++++++++++++++
sdma/user_cmd/sdma_tools_include.h | 24 ++++
7 files changed, 390 insertions(+), 1 deletion(-)
create mode 100644 sdma/sdma_func/sdma_common.h
create mode 100644 sdma/sdma_func/sdma_dump_reg.c
create mode 100644 sdma/sdma_func/sdma_dump_reg.h
create mode 100644 sdma/user_cmd/sdma_cmd_dump.c
create mode 100644 sdma/user_cmd/sdma_tools_include.h
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 72f2dab..4f4eb03 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -46,6 +46,7 @@ file(GLOB_RECURSE HIKPTOOL_SRC
${CMAKE_CURRENT_SOURCE_DIR}/serdes/*.c
${CMAKE_CURRENT_SOURCE_DIR}/socip/*.c
${CMAKE_CURRENT_SOURCE_DIR}/hccs/*.c
+ ${CMAKE_CURRENT_SOURCE_DIR}/sdma/*.c
${CMAKE_CURRENT_SOURCE_DIR}/tool_lib/*.c
${CMAKE_CURRENT_SOURCE_DIR}/info_collect/*.c
${CMAKE_CURRENT_SOURCE_DIR}/hikp_init_main.c
diff --git a/libhikptdev/include/hikptdev_plug.h b/libhikptdev/include/hikptdev_plug.h
index d45a654..375fb89 100644
--- a/libhikptdev/include/hikptdev_plug.h
+++ b/libhikptdev/include/hikptdev_plug.h
@@ -44,7 +44,8 @@ enum cmd_module_type {
DPDK_MOD = 9,
CXL_MOD = 10,
UB_MOD = 11,
- HCCS_MOD = 16
+ HCCS_MOD = 16,
+ SDMA_MOD = 17
};
void hikp_unlock(void);
diff --git a/sdma/sdma_func/sdma_common.h b/sdma/sdma_func/sdma_common.h
new file mode 100644
index 0000000..40969b8
--- /dev/null
+++ b/sdma/sdma_func/sdma_common.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2025 Hisilicon Technologies Co., Ltd.
+ * Hikptool is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ * http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ *
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef SDMA_COMMON_H
+#define SDMA_COMMON_H
+
+#define RESP_MAX_NUM 160
+
+/* SDMA command code */
+enum sdma_cmd_type {
+ SDMA_DUMP = 0,
+};
+
+enum sdma_dump_cmd_type {
+ DUMP_UNKNOWN = 0,
+ DUMP_CHN_STATUS,
+ DUMP_CHN_PC,
+ DUMP_CHN_VC,
+};
+
+#endif /* SDMA_COMMON_H */
diff --git a/sdma/sdma_func/sdma_dump_reg.c b/sdma/sdma_func/sdma_dump_reg.c
new file mode 100644
index 0000000..7440fb6
--- /dev/null
+++ b/sdma/sdma_func/sdma_dump_reg.c
@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) 2025 Hisilicon Technologies Co., Ltd.
+ * Hikptool is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ * http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ *
+ * See the Mulan PSL v2 for more details.
+ */
+#include <unistd.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <dirent.h>
+#include <stdio.h>
+#include <errno.h>
+#include "hikptdev_plug.h"
+#include "sdma_common.h"
+#include "sdma_dump_reg.h"
+
+#define TARGET_DIR "/sys/devices/platform/"
+#define PREFIX "HISI0431"
+#define PREFIX_LEN 8
+
+int sdma_dev_check(void)
+{
+ struct dirent *entry;
+ DIR *dir;
+
+ dir = opendir(TARGET_DIR);
+ if (dir == NULL) {
+ perror("opendir");
+ return -errno;
+ }
+
+ while ((entry = readdir(dir)) != NULL) {
+ if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
+ continue;
+
+ if (strlen(entry->d_name) >= PREFIX_LEN) {
+ if (strncmp(entry->d_name, PREFIX, PREFIX_LEN) == 0) {
+ closedir(dir);
+ return 0;
+ }
+ }
+ }
+
+ closedir(dir);
+ return -ENODEV;
+}
+
+static int sdma_rsp_normal_check(const struct hikp_cmd_ret *cmd_ret)
+{
+ if (cmd_ret == NULL)
+ return -ENOSPC;
+
+ if (cmd_ret->status != 0)
+ return -EINVAL;
+
+ if (cmd_ret->rsp_data_num > RESP_MAX_NUM)
+ return -E2BIG;
+
+ return 0;
+}
+
+static int sdma_get_reg(const struct tool_sdma_cmd *cmd, uint32_t *reg_save, uint32_t *reg_num)
+{
+ struct sdma_dump_req_para req_data = { 0 };
+ struct hikp_cmd_header req_header = { 0 };
+ struct hikp_cmd_ret *cmd_ret;
+ uint32_t i;
+ int ret;
+
+ req_data.chip_id = cmd->chip_id;
+ req_data.die_id = cmd->die_id;
+ req_data.chn_id = cmd->chn_id;
+
+ hikp_cmd_init(&req_header, SDMA_MOD, SDMA_DUMP, cmd->sdma_cmd_type);
+ cmd_ret = hikp_cmd_alloc(&req_header, &req_data, sizeof(req_data));
+ ret = sdma_rsp_normal_check(cmd_ret);
+ if (ret) {
+ printf("check cmd ret failed, ret: %d.\n", ret);
+ hikp_cmd_free(&cmd_ret);
+ return ret;
+ }
+ *reg_num = cmd_ret->rsp_data_num;
+ for (i = 0; i < *reg_num; i++)
+ reg_save[i] = cmd_ret->rsp_data[i];
+
+ hikp_cmd_free(&cmd_ret);
+
+ return 0;
+}
+
+static void sdma_print_reg(const uint32_t *reg_save, uint32_t reg_num)
+{
+ uint32_t i;
+
+ if (reg_num == 0) {
+ printf("SDMA dump is failed\n");
+ return;
+ }
+ printf(" sdma reg dump list:\n");
+ for (i = 0; i < reg_num; i++)
+ printf(" 0x%08x\n", reg_save[i]);
+}
+
+int sdma_reg_dump(struct tool_sdma_cmd *cmd)
+{
+ uint32_t sdma_reg_save[RESP_MAX_NUM] = { 0 };
+ uint32_t sdma_reg_num = 0;
+ int ret;
+
+ if (cmd == NULL)
+ return -EINVAL;
+
+ ret = sdma_dev_check();
+ if (ret) {
+ printf("The current environment not support this feature!\n");
+ return ret;
+ }
+
+ ret = sdma_get_reg(cmd, sdma_reg_save, &sdma_reg_num);
+ if (ret)
+ return ret;
+
+ sdma_print_reg(sdma_reg_save, sdma_reg_num);
+
+ return 0;
+}
diff --git a/sdma/sdma_func/sdma_dump_reg.h b/sdma/sdma_func/sdma_dump_reg.h
new file mode 100644
index 0000000..51c4e66
--- /dev/null
+++ b/sdma/sdma_func/sdma_dump_reg.h
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2025 Hisilicon Technologies Co., Ltd.
+ * Hikptool is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ * http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ *
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef SDMA_DUMP_REG_H
+#define SDMA_DUMP_REG_H
+
+#include "sdma_tools_include.h"
+
+struct sdma_dump_req_para {
+ uint32_t chip_id;
+ uint32_t die_id;
+ uint32_t chn_id;
+};
+
+int sdma_dev_check(void);
+int sdma_reg_dump(struct tool_sdma_cmd *cmd);
+
+#endif /* SDMA_DUMP_REG_H */
diff --git a/sdma/user_cmd/sdma_cmd_dump.c b/sdma/user_cmd/sdma_cmd_dump.c
new file mode 100644
index 0000000..47b095d
--- /dev/null
+++ b/sdma/user_cmd/sdma_cmd_dump.c
@@ -0,0 +1,171 @@
+/*
+ * Copyright (c) 2025 Hisilicon Technologies Co., Ltd.
+ * Hikptool is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ * http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ *
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <stdint.h>
+#include "hikptdev_plug.h"
+#include "tool_lib.h"
+#include "tool_cmd.h"
+#include "sdma_tools_include.h"
+#include "sdma_common.h"
+#include "sdma_dump_reg.h"
+
+struct tool_sdma_cmd g_sdma_dump_cmd = {
+ .sdma_cmd_type = DUMP_UNKNOWN,
+ .chip_id = (uint32_t)(-1),
+ .die_id = (uint32_t)(-1),
+ .chn_id = (uint32_t)(-1),
+};
+
+static int sdma_dump_help(struct major_cmd_ctrl *self, const char *argv)
+{
+ int ret;
+
+ ret = sdma_dev_check();
+ if (ret) {
+ printf("The current environment not support this feature!\n");
+ return ret;
+ }
+ HIKP_SET_USED(argv);
+
+ printf("\n Usage: %s\n", self->cmd_ptr->name);
+ printf("\n %s\n", self->cmd_ptr->help_info);
+ printf(" %s, %-25s %s\n", "-c", "--chipid", "please input chip id[x] first\n");
+ printf(" %s, %-25s %s\n", "-d", "--dieid", "please input die id[x] first\n");
+ printf(" %s, %-25s %s\n", "-n", "--chnid", "please input chn id[x] first\n");
+ printf("\n Options:\n\n");
+ printf(" %s, %-25s %s\n", "-h", "--help", "display this help and exit\n");
+ printf(" %s, %-25s %s\n", "-s", "--chnstatus", "dump sdma channel status dfx reg\n");
+ printf("\tParameter Limitation: -c --chipid and -d --dieid is necessary,");
+ printf(" -n --chnid is invalid\n");
+ printf("\tUsage: -s -c [chipid] -d [dieid], e.g. -s -c 0 -d 0\n\n");
+ printf(" %s, %-25s %s\n", "-p", "--pc", "dump sdma pc channel dfx reg\n");
+ printf("\tParameter Limitation: All three parameters are necessary,");
+ printf(" the -n --chnid range is limited to 0-31\n");
+ printf("\tUsage: -p -c [chipid] -d [dieid] -n [chnid], e.g. -p -c 0 -d 0 -n 31\n\n");
+ printf(" %s, %-25s %s\n", "-v", "--vc", "dump sdma vc channel dfx reg\n");
+ printf("\tParameter Limitation: All three parameters are necessary,");
+ printf(" the -n --chnid range is limited to 0-159\n");
+ printf("\tUsage: -v -c [chipid] -d [dieid] -n [chnid], e.g. -v -c 0 -d 0 -n 159\n\n");
+ printf("\n");
+
+ return 0;
+}
+
+static int sdma_set_id(struct major_cmd_ctrl *self, const char *argv, uint32_t *id)
+{
+ uint32_t val = 0;
+ int ret;
+
+ ret = string_toui(argv, &val);
+ if (ret) {
+ snprintf(self->err_str, sizeof(self->err_str), "Invalid id.");
+ self->err_no = ret;
+ return ret;
+ }
+ *id = val;
+ return ret;
+}
+
+static int sdma_set_chip_id(struct major_cmd_ctrl *self, const char *argv)
+{
+ return sdma_set_id(self, argv, &g_sdma_dump_cmd.chip_id);
+}
+
+static int sdma_set_die_id(struct major_cmd_ctrl *self, const char *argv)
+{
+ return sdma_set_id(self, argv, &g_sdma_dump_cmd.die_id);
+}
+
+static int sdma_set_chn_id(struct major_cmd_ctrl *self, const char *argv)
+{
+ return sdma_set_id(self, argv, &g_sdma_dump_cmd.chn_id);
+}
+
+static int sdma_dump_chn_status(struct major_cmd_ctrl *self, const char *argv)
+{
+ HIKP_SET_USED(self);
+ HIKP_SET_USED(argv);
+
+ g_sdma_dump_cmd.sdma_cmd_type = DUMP_CHN_STATUS;
+ return 0;
+}
+
+static int sdma_dump_chn_pc(struct major_cmd_ctrl *self, const char *argv)
+{
+ HIKP_SET_USED(self);
+ HIKP_SET_USED(argv);
+
+ g_sdma_dump_cmd.sdma_cmd_type = DUMP_CHN_PC;
+ return 0;
+}
+
+static int sdma_dump_chn_vc(struct major_cmd_ctrl *self, const char *argv)
+{
+ HIKP_SET_USED(self);
+ HIKP_SET_USED(argv);
+
+ g_sdma_dump_cmd.sdma_cmd_type = DUMP_CHN_VC;
+ return 0;
+}
+
+static int sdma_dump_excute_function_call(uint32_t cmd_type)
+{
+ if (cmd_type != DUMP_UNKNOWN)
+ return sdma_reg_dump(&g_sdma_dump_cmd);
+
+ return -EINVAL;
+}
+
+static void sdma_dump_execute(struct major_cmd_ctrl *self)
+{
+ int ret;
+ const char *suc_msg[] = {
+ "",
+ "sdma_dump_chn_status success.",
+ "sdma_dump_dfx_pc success.",
+ "sdma_dump_dfx_vc success."
+ };
+ const char *err_msg[] = {
+ "sdma_dump failed, unknown cmd type",
+ "sdma_dump_chn_status error.",
+ "sdma_dump_dfx_pc error.",
+ "sdma_dump_dfx_vc error."
+ };
+
+ ret = sdma_dump_excute_function_call(g_sdma_dump_cmd.sdma_cmd_type);
+ if (ret == 0)
+ printf("%s\n", suc_msg[g_sdma_dump_cmd.sdma_cmd_type]);
+ else {
+ snprintf(self->err_str, sizeof(self->err_str), "%s\n",
+ err_msg[g_sdma_dump_cmd.sdma_cmd_type]);
+ self->err_no = ret;
+ }
+}
+
+static void cmd_sdma_dump_init(void)
+{
+ struct major_cmd_ctrl *major_cmd = get_major_cmd();
+
+ major_cmd->option_count = 0;
+ major_cmd->execute = sdma_dump_execute;
+
+ cmd_option_register("-c", "--chipid", true, sdma_set_chip_id);
+ cmd_option_register("-d", "--dieid", true, sdma_set_die_id);
+ cmd_option_register("-n", "--chnid", true, sdma_set_chn_id);
+ cmd_option_register("-h", "--help", false, sdma_dump_help);
+ cmd_option_register("-s", "--chnstatus", false, sdma_dump_chn_status);
+ cmd_option_register("-p", "--pc", false, sdma_dump_chn_pc);
+ cmd_option_register("-v", "--vc", false, sdma_dump_chn_vc);
+}
+
+HIKP_CMD_DECLARE("sdma_dump", "sdma reg dump", cmd_sdma_dump_init);
diff --git a/sdma/user_cmd/sdma_tools_include.h b/sdma/user_cmd/sdma_tools_include.h
new file mode 100644
index 0000000..01b24b5
--- /dev/null
+++ b/sdma/user_cmd/sdma_tools_include.h
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2025 Hisilicon Technologies Co., Ltd.
+ * Hikptool is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ * http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ *
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef SDMA_TOOLS_INCLUDE_H
+#define SDMA_TOOLS_INCLUDE_H
+
+struct tool_sdma_cmd {
+ uint32_t sdma_cmd_type;
+ uint32_t chip_id;
+ uint32_t die_id;
+ uint32_t chn_id;
+};
+
+#endif /* SDMA_TOOLS_INCLUDE_H */
--
2.45.0.windows.1

389
0097-Add-support-collect-sdma-hikptool-dump-reg-info.patch Normal file
View File

@ -0,0 +1,389 @@
From 3a8f39f91fd54a656a0b3d9278f4d77eddc94771 Mon Sep 17 00:00:00 2001
From: zhangyuyang <zhangyuyang31@huawei.com>
Date: Fri, 28 Feb 2025 14:20:26 +0800
Subject: [PATCH 2/2] Add support collect sdma hikptool dump reg info.
1. support collect sdma info e.g. hiktool info_collect -sdma
Signed-off-by: zhangyuyang <zhangyuyang31@huawei.com>
---
info_collect/hikp_collect.h | 3 +
info_collect/hikp_collect_main.c | 19 ++-
info_collect/hikp_collect_sdma.c | 261 +++++++++++++++++++++++++++++++
3 files changed, 282 insertions(+), 1 deletion(-)
create mode 100644 info_collect/hikp_collect_sdma.c
diff --git a/info_collect/hikp_collect.h b/info_collect/hikp_collect.h
index 28aa5a4..26108ac 100644
--- a/info_collect/hikp_collect.h
+++ b/info_collect/hikp_collect.h
@@ -24,6 +24,7 @@
#define GROUP_IMP "imp"
#define GROUP_COMMON "common"
#define GROUP_SERDES "serdes"
+#define GROUP_SDMA "sdma"
enum info_collect_type {
COLLECT_ACC,
@@ -35,6 +36,7 @@ enum info_collect_type {
COLLECT_SATA,
COLLECT_SERDES,
COLLECT_SOCIP,
+ COLLECT_SDMA,
COLLECT_ALL,
COLLECT_UNKNOWN_TYPE,
};
@@ -49,5 +51,6 @@ void collect_roce_log(void);
void collect_pcie_info(void);
void collect_imp_log(void);
void collect_serdes_log(void);
+void collect_sdma_log(void);
#endif /* HIKP_COLLECT_H */
diff --git a/info_collect/hikp_collect_main.c b/info_collect/hikp_collect_main.c
index c413346..46120a5 100644
--- a/info_collect/hikp_collect_main.c
+++ b/info_collect/hikp_collect_main.c
@@ -108,6 +108,15 @@ static int info_collect_socip(struct major_cmd_ctrl *self, const char *argv)
return 0;
}
+static int info_collect_sdma(struct major_cmd_ctrl *self, const char *argv)
+{
+ HIKP_SET_USED(self);
+ HIKP_SET_USED(argv);
+
+ set_info_collect_type(COLLECT_SDMA);
+ return 0;
+}
+
static int info_collect_all(struct major_cmd_ctrl *self, const char *argv)
{
HIKP_SET_USED(self);
@@ -128,12 +137,13 @@ static void collect_all_log(void)
collect_sata_log();
collect_serdes_log();
collect_socip_log();
+ collect_sdma_log();
}
static int info_collect_excute_funs_call(uint32_t collect_type)
{
const char *type_name[] = {"acc", "imp", "nic", "pcie", "roce", "sas",
- "sata", "serdes", "socip", "all"};
+ "sata", "serdes", "socip", "sdma", "all"};
int ret;
if (collect_type == COLLECT_UNKNOWN_TYPE)
@@ -173,6 +183,9 @@ static int info_collect_excute_funs_call(uint32_t collect_type)
case COLLECT_SOCIP:
collect_socip_log();
break;
+ case COLLECT_SDMA:
+ collect_sdma_log();
+ break;
case COLLECT_ALL:
collect_all_log();
break;
@@ -199,6 +212,7 @@ static void info_collect_execute(struct major_cmd_ctrl *self)
"collect sata info success.",
"collect serdes info success.",
"collect socip info success.",
+ "collect sdma info success.",
"collect all info success.",
};
const char *err_msg[] = {
@@ -211,6 +225,7 @@ static void info_collect_execute(struct major_cmd_ctrl *self)
"collect sata info error.",
"collect serdes info error.",
"collect socip info error.",
+ "collect sdma info error.",
"collect all info error.",
"collect info failed, unknown type.",
};
@@ -245,6 +260,7 @@ static int info_collect_help(struct major_cmd_ctrl *self, const char *argv)
printf(" %s, %-25s %s\n", "-sata", "--sata", "collect sata info\n");
printf(" %s, %-25s %s\n", "-serdes", "--serdes", "collect serdes info\n");
printf(" %s, %-25s %s\n", "-socip", "--socip", "collect socip info\n");
+ printf(" %s, %-25s %s\n", "-sdma", "--sdma", "collect sdma info\n");
printf(" %s, %-25s %s\n", "-all", "--all", "collect all info\n");
printf("\n");
@@ -268,6 +284,7 @@ static void cmd_info_collect_init(void)
cmd_option_register("-sata", "--sata", false, info_collect_sata);
cmd_option_register("-serdes", "--serdes", false, info_collect_serdes);
cmd_option_register("-socip", "--socip", false, info_collect_socip);
+ cmd_option_register("-sdma", "--sdma", false, info_collect_sdma);
cmd_option_register("-all", "--all", false, info_collect_all);
}
diff --git a/info_collect/hikp_collect_sdma.c b/info_collect/hikp_collect_sdma.c
new file mode 100644
index 0000000..8dc315c
--- /dev/null
+++ b/info_collect/hikp_collect_sdma.c
@@ -0,0 +1,261 @@
+/*
+ * Copyright (c) 2024 Hisilicon Technologies Co., Ltd.
+ * Hikptool is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ * http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ *
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include <unistd.h>
+#include <string.h>
+#include "hikp_collect_lib.h"
+#include "hikp_collect.h"
+#include "tool_lib.h"
+#include "sdma_dump_reg.h"
+#include "sdma_tools_include.h"
+
+#define PC_MAX_NUM 32
+#define VC_MAX_NUM 160
+#define SDMA_DIE_MAX 4
+#define SDMA_DIE_CHANGE 2
+#define SDMA_DUMP_DELAY 50000
+#define BUFFER_LENTH 1024
+
+typedef int (*reg_info_func_t)(uint32_t, uint32_t);
+
+enum sdma_dump_type {
+ SDMA_DUMP_UNKNOWN = 0,
+ SDMA_DUMP_CHN_STATUS,
+ SDMA_DUMP_CHN_PC,
+ SDMA_DUMP_CHN_VC,
+};
+
+struct reg_op {
+ char *func_name;
+ reg_info_func_t func;
+ uint32_t sdma_die;
+};
+
+static int sdma_dmesg_exec(void *data)
+{
+ struct info_collect_cmd *cmd = (struct info_collect_cmd *)data;
+ char dmesg_cmd[MAX_LOG_NAME_LEN] = {0};
+ char buffer[BUFFER_LENTH] = {0};
+ int i = 0;
+ FILE *fp;
+
+ while (cmd->args[i] != 0) {
+ strcat(dmesg_cmd, cmd->args[i]);
+ strcat(dmesg_cmd, " ");
+ i++;
+ }
+
+ fp = popen(dmesg_cmd, "r");
+ if (fp == NULL) {
+ perror("popen");
+ return -errno;
+ }
+
+ while (fgets(buffer, sizeof(buffer), fp) != NULL) {
+ printf("%s", buffer);
+ }
+
+ pclose(fp);
+
+ return 0;
+}
+
+static void collect_sdma_kernel_log(void)
+{
+ struct info_collect_cmd sdma_kernel_cmds[] = {
+ {
+ .log_name = "dmesg",
+ .args = {"dmesg", "|", "grep", "sdma", NULL},
+ },
+ };
+ size_t i, size;
+ int ret;
+
+ size = HIKP_ARRAY_SIZE(sdma_kernel_cmds);
+ for (i = 0; i < size; i++) {
+ ret = hikp_collect_log(GROUP_SDMA, sdma_kernel_cmds[i].log_name,
+ sdma_dmesg_exec, (void *)&sdma_kernel_cmds[i]);
+ if (ret) {
+ HIKP_ERROR_PRINT("collect %s log failed: %d\n",
+ sdma_kernel_cmds[i].log_name, ret);
+ }
+ }
+}
+
+static void collect_sdma_debugfs_log(void)
+{
+ struct info_collect_cmd sdma_debugfs_cmds[] = {
+ {
+ .log_name = "sdma_channels",
+ .args = {"cat", "/sys/kernel/debug/sdma/sdma_channels", NULL},
+ },
+ {
+ .log_name = "sdma_error",
+ .args = {"cat", "/sys/kernel/debug/sdma/sdma_error", NULL},
+ },
+ {
+ .log_name = "sdma_stats",
+ .args = {"cat", "/sys/kernel/debug/sdma/sdma_stats", NULL},
+ },
+ };
+ size_t i, size;
+ int ret;
+
+ size = HIKP_ARRAY_SIZE(sdma_debugfs_cmds);
+ for (i = 0; i < size; i++) {
+ ret = hikp_collect_log(GROUP_SDMA, sdma_debugfs_cmds[i].log_name,
+ hikp_collect_cat_glob_exec, (void *)&sdma_debugfs_cmds[i]);
+ if (ret) {
+ HIKP_ERROR_PRINT("collect %s log failed: %d\n",
+ sdma_debugfs_cmds[i].log_name, ret);
+ }
+ }
+}
+
+static int sdma_reg_log(void *data)
+{
+ struct reg_op *op = (struct reg_op *)data;
+ uint32_t chip, die;
+ int ret;
+
+ chip = op->sdma_die / SDMA_DIE_CHANGE;
+ die = op->sdma_die % SDMA_DIE_CHANGE;
+ ret = op->func(chip, die);
+ if (ret)
+ HIKP_ERROR_PRINT("%s chip%u die%u failed: %d\n", op->func_name, chip, die, ret);
+
+ return ret;
+}
+
+static int sdma_chn_status_dump_info(uint32_t chip_id, uint32_t die_id)
+{
+ struct tool_sdma_cmd cmd = {
+ .chip_id = chip_id,
+ .die_id = die_id,
+ };
+ int ret;
+
+ printf("hikptool sdma_dump -s -c %u -d %u\n", cmd.chip_id, cmd.die_id);
+ printf(" sdma%u channel status\n", SDMA_DIE_CHANGE * cmd.chip_id + cmd.die_id);
+ cmd.sdma_cmd_type = SDMA_DUMP_CHN_STATUS;
+ ret = sdma_reg_dump(&cmd);
+ if (ret) {
+ HIKP_ERROR_PRINT("dump channel status failed: %d\n", ret);
+ return ret;
+ }
+
+ return 0;
+}
+
+static int sdma_pc_dump_info(uint32_t chip_id, uint32_t die_id)
+{
+ struct tool_sdma_cmd cmd = {
+ .chip_id = chip_id,
+ .die_id = die_id,
+ };
+ uint32_t i;
+ int ret;
+
+ cmd.sdma_cmd_type = SDMA_DUMP_CHN_PC;
+ for (i = 0; i < PC_MAX_NUM; i++) {
+ printf("hikptool sdma_dump -p -c %u -d %u -n %u\n", cmd.chip_id, cmd.die_id, i);
+ printf(" sdma%u pc chn%u\n", SDMA_DIE_CHANGE * cmd.chip_id + cmd.die_id, i);
+ cmd.chn_id = i;
+ ret = sdma_reg_dump(&cmd);
+ if (ret) {
+ HIKP_ERROR_PRINT("dump pc chn%u reg failed: %d\n", i, ret);
+ return ret;
+ }
+ }
+
+ return 0;
+}
+
+static int sdma_vc_dump_info(uint32_t chip_id, uint32_t die_id)
+{
+ struct tool_sdma_cmd cmd = {
+ .chip_id = chip_id,
+ .die_id = die_id,
+ };
+ uint32_t i;
+ int ret;
+
+ cmd.sdma_cmd_type = SDMA_DUMP_CHN_VC;
+ for (i = 0; i < VC_MAX_NUM; i++) {
+ printf("hikptool sdma_dump -v -c %u -d %u -n %u\n", cmd.chip_id, cmd.die_id, i);
+ printf(" sdma%u vc chn%u\n", SDMA_DIE_CHANGE * cmd.chip_id + cmd.die_id, i);
+ cmd.chn_id = i;
+ ret = sdma_reg_dump(&cmd);
+ if (ret) {
+ HIKP_ERROR_PRINT("dump vc chn%u reg failed: %d\n", i, ret);
+ return ret;
+ }
+ }
+
+ return 0;
+}
+
+static void collect_sdma_reg_log(void)
+{
+ struct reg_op ch_op = {
+ .func = sdma_chn_status_dump_info,
+ .func_name = "sdma_chn_status_dump_info",
+ };
+ struct reg_op pc_op = {
+ .func = sdma_pc_dump_info,
+ .func_name = "sdma_pc_dump_info",
+ };
+ struct reg_op vc_op = {
+ .func = sdma_vc_dump_info,
+ .func_name = "sdma_vc_dump_info",
+ };
+ char log_name[MAX_LOG_NAME_LEN] = {0};
+ uint32_t i;
+ int ret;
+
+ for (i = 0; i < SDMA_DIE_MAX; i++) {
+ ch_op.sdma_die = i;
+ memset(log_name, 0, MAX_LOG_NAME_LEN);
+ (void)snprintf(log_name, MAX_LOG_NAME_LEN, "sdma%u_channel_status_dump", i);
+
+ ret = hikp_collect_log(GROUP_SDMA, log_name, sdma_reg_log, (void *)&ch_op);
+ if (ret)
+ HIKP_ERROR_PRINT("%s failed: %d\n", ch_op.func_name, ret);
+ usleep(SDMA_DUMP_DELAY);
+
+ pc_op.sdma_die = i;
+ memset(log_name, 0, MAX_LOG_NAME_LEN);
+ (void)snprintf(log_name, MAX_LOG_NAME_LEN, "sdma%u_pc_dump", i);
+
+ ret = hikp_collect_log(GROUP_SDMA, log_name, sdma_reg_log, (void *)&pc_op);
+ if (ret)
+ HIKP_ERROR_PRINT("%s failed: %d\n", pc_op.func_name, ret);
+ usleep(SDMA_DUMP_DELAY);
+
+ vc_op.sdma_die = i;
+ memset(log_name, 0, MAX_LOG_NAME_LEN);
+ (void)snprintf(log_name, MAX_LOG_NAME_LEN, "sdma%u_vc_dump", i);
+
+ ret = hikp_collect_log(GROUP_SDMA, log_name, sdma_reg_log, (void *)&vc_op);
+ if (ret)
+ HIKP_ERROR_PRINT("%s failed: %d\n", vc_op.func_name, ret);
+ usleep(SDMA_DUMP_DELAY);
+ }
+}
+
+void collect_sdma_log(void)
+{
+ collect_sdma_kernel_log();
+ collect_sdma_debugfs_log();
+ collect_sdma_reg_log();
+}
--
2.45.0.windows.1

28
0098-hikptool-Update-the-tool-version-number-to-1.1.4.patch Normal file
View File

@ -0,0 +1,28 @@
From 3feff89b32b14e562e79d7c07053dd764321accc Mon Sep 17 00:00:00 2001
From: veega2022 <zhuweijia@huawei.com>
Date: Fri, 14 Mar 2025 20:41:11 +0800
Subject: [PATCH] hikptool: Update the tool version number to 1.1.4
Update the tool version number to 1.1.4
Signed-off-by: veega2022 <zhuweijia@huawei.com>
---
tool_lib/tool_lib.h | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/tool_lib/tool_lib.h b/tool_lib/tool_lib.h
index 24b1fbb..d4493d7 100644
--- a/tool_lib/tool_lib.h
+++ b/tool_lib/tool_lib.h
@@ -18,7 +18,7 @@
#define TOOL_NAME "hikptool"
-#define TOOL_VER "1.1.3"
+#define TOOL_VER "1.1.4"
#define HI_GET_BITFIELD(value, start, mask) (((value) >> (start)) & (mask))
#define HI_SET_FIELD(origin, shift, val) ((origin) |= (val) << (shift))
--
2.45.0.windows.1

14
hikptool.spec
View File

@ -3,7 +3,7 @@
Name: hikptool
Summary: A userspace tool for Linux providing problem location on Kunpeng chips
Version: 1.0.0
Release: 16
Release: 17
License: MulanPSL2
Source: %{name}-%{version}.tar.gz
ExclusiveOS: linux
@ -105,6 +105,15 @@ Patch0086: 0086-hikptool-The-macro_num-error-is-rectified-and-the-of.patch
Patch0087: 0087-Fix-the-logic-of-obtaining-statistics-on-flow-contro.patch
Patch0088: 0088-hikptool-Rectify-the-compilation-alarm.patch
Patch0089: 0089-hikptool-Update-the-tool-version-number-to-1.1.3.patch
Patch0090: 0090-hikptool-Support-for-info-collect.patch
Patch0091: 0091-hikptool-Added-compilation-options.patch
Patch0092: 0092-hikptool-pcie-The-query-result-of-pcie_dumpreg-does-.patch
Patch0093: 0093-hikptool-hccs-support-dump-hccs-info.patch
Patch0094: 0094-hikptool-pcie-The-PCS-layer-register-print-command-i.patch
Patch0095: 0095-hikptool-pcie-Resolved-the-problem-that-it-takes-a-l.patch
Patch0096: 0096-Hikptool-add-support-dump-SDMA-register-information-.patch
Patch0097: 0097-Add-support-collect-sdma-hikptool-dump-reg-info.patch
Patch0098: 0098-hikptool-Update-the-tool-version-number-to-1.1.4.patch
%description
This package contains the hikptool
@ -157,6 +166,9 @@ fi
/sbin/ldconfig
%changelog
* Tue Mar 18 2025 veega2022 <zhuweijia@huawei.com> 1.0.0-17
- The HCCS and SDMA modules and the log collection function are added
* Thu Nov 21 2024 veega2022 <zhuweijia@huawei.com> 1.0.0-16
- Synchronize code, Modify the review comments to increase the reliability of the code