From fde1f62e767c37f6a6c717df3d03154d081da47e Mon Sep 17 00:00:00 2001 From: wangzijian 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 -d 2. support dump SDMA pc reg e.g. hikptool sdma_dump -p -c -d -n 3. support dump SDMA vc reg e.g. hikptool sdma_dump -v -c -d -n Signed-off-by: wangzijian --- 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 +#include +#include +#include +#include +#include +#include +#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 +#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