diff --git a/CMakeLists.txt b/CMakeLists.txt index 4fb82ca96f0b1c1b58d5a167ac4cebb430e9c31e..4f4eb039189a65e6df2080d8e0961f8ed465af17 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -11,7 +11,15 @@ project(hikptool C) -set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O2 -fPIC -fPIE -Wall -Werror -fno-common -std=gnu11") +set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} \ + -O2 -fPIC -fPIE -Wall -Werror -Wextra -Wuninitialized -Wundef -Wunused -Wdate-time \ + -Wshadow -Wvla -Wdisabled-optimization -Wempty-body -Wignored-qualifiers \ + -Wimplicit-fallthrough=3 -Wtype-limits -Wshift-negative-value -Wswitch-default \ + -Wframe-larger-than=8192 -Wshift-overflow=2 -Wwrite-strings -Wmissing-format-attribute \ + -Wformat-nonliteral -Wduplicated-cond -Wtrampolines -Wlogical-op -Wsuggest-attribute=format \ + -Wduplicated-branches -Wmissing-include-dirs -Wmissing-declarations \ + -Wreturn-local-addr -Wredundant-decls -Wfloat-conversion -Wmissing-prototypes \ + -Wno-discarded-qualifiers -Wstrict-prototypes -fno-common -std=gnu11") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wfloat-equal -fstack-protector-strong -D_FORTIFY_SOURCE=2") set(CMAKE_SKIP_RPATH TRUE) @@ -37,7 +45,10 @@ file(GLOB_RECURSE HIKPTOOL_SRC ${CMAKE_CURRENT_SOURCE_DIR}/sata/*.c ${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/cxl/usr_cmd/cmd_analysis/cxl_cmd_cpa.c b/cxl/usr_cmd/cmd_analysis/cxl_cmd_cpa.c index 2df9dc59e4d8cdd467d83b464a1d93d15900a960..208a7d44504e2c23e522bf6885f49f9de8259e29 100644 --- a/cxl/usr_cmd/cmd_analysis/cxl_cmd_cpa.c +++ b/cxl/usr_cmd/cmd_analysis/cxl_cmd_cpa.c @@ -25,6 +25,8 @@ struct tool_cxl_cmd g_cxl_cpa_cmd = { static int cxl_cpa_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf(" Usage: %s\n", self->cmd_ptr->name); printf(" %s\n", self->cmd_ptr->help_info); printf(" %s, %-25s %s\n", "-i", "--interface", "please input port[x] first"); @@ -44,6 +46,8 @@ static int cxl_port_id_set(struct major_cmd_ctrl *self, const char *argv) uint32_t val; int ret; + HIKP_SET_USED(self); + ret = string_toui(argv, &val); if (ret) { printf("cxl cpa set port id err %d\n", ret); @@ -56,6 +60,9 @@ static int cxl_port_id_set(struct major_cmd_ctrl *self, const char *argv) static int cxl_cpa_err_status_show(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_cxl_cpa_cmd.cmd_type = CPA_ERR; return 0; @@ -63,6 +70,9 @@ static int cxl_cpa_err_status_show(struct major_cmd_ctrl *self, const char *argv static int cxl_cpa_mmrg_show(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_cxl_cpa_cmd.cmd_type = CPA_MMRG; return 0; @@ -70,6 +80,9 @@ static int cxl_cpa_mmrg_show(struct major_cmd_ctrl *self, const char *argv) static int cxl_cpa_dump(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_cxl_cpa_cmd.cmd_type = CPA_DUMP; return 0; @@ -77,6 +90,9 @@ static int cxl_cpa_dump(struct major_cmd_ctrl *self, const char *argv) static int cxl_cpa_config(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_cxl_cpa_cmd.cmd_type = CPA_CONFIG; return 0; diff --git a/cxl/usr_cmd/cmd_analysis/cxl_cmd_dl.c b/cxl/usr_cmd/cmd_analysis/cxl_cmd_dl.c index 226db1e9caba64ec527f6a071aac65a97538fc49..7ac078441a8fefecabfc60a26809b0539268a4bb 100644 --- a/cxl/usr_cmd/cmd_analysis/cxl_cmd_dl.c +++ b/cxl/usr_cmd/cmd_analysis/cxl_cmd_dl.c @@ -25,6 +25,8 @@ struct tool_cxl_cmd g_cxl_dl_cmd = { static int cxl_dl_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf(" Usage: %s\n", self->cmd_ptr->name); printf(" %s\n", self->cmd_ptr->help_info); printf(" %s, %-25s %s\n", "-i", "--interface", "please input port[x] first"); @@ -44,6 +46,8 @@ static int cxl_dl_port_id_set(struct major_cmd_ctrl *self, const char *argv) uint32_t val; int ret; + HIKP_SET_USED(self); + ret = string_toui(argv, &val); if (ret) { printf("cxl dl set port id err %d\n", ret); @@ -56,6 +60,9 @@ static int cxl_dl_port_id_set(struct major_cmd_ctrl *self, const char *argv) static int cxl_dl_err_status(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_cxl_dl_cmd.cmd_type = CXL_DL_ERR; return 0; @@ -63,6 +70,9 @@ static int cxl_dl_err_status(struct major_cmd_ctrl *self, const char *argv) static int cxl_dl_dump(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_cxl_dl_cmd.cmd_type = CXL_DL_DUMP; return 0; @@ -70,6 +80,9 @@ static int cxl_dl_dump(struct major_cmd_ctrl *self, const char *argv) static int cxl_dl_dfx(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_cxl_dl_cmd.cmd_type = CXL_DL_DFX; return 0; @@ -77,6 +90,9 @@ static int cxl_dl_dfx(struct major_cmd_ctrl *self, const char *argv) static int cxl_dl_fsm_state(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_cxl_dl_cmd.cmd_type = CXL_DL_FSM_STATE; return 0; diff --git a/cxl/usr_cmd/cmd_analysis/cxl_cmd_membar.c b/cxl/usr_cmd/cmd_analysis/cxl_cmd_membar.c index f444b561305f546594d175c52654fdd7892a23b6..0ebca4ff47b5cbb7871025482a05e7331c7307a4 100644 --- a/cxl/usr_cmd/cmd_analysis/cxl_cmd_membar.c +++ b/cxl/usr_cmd/cmd_analysis/cxl_cmd_membar.c @@ -25,6 +25,8 @@ struct tool_cxl_cmd g_cxl_membar_cmd = { static int cxl_membar_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf(" Usage: %s\n", self->cmd_ptr->name); printf(" %s\n", self->cmd_ptr->help_info); printf(" %s, %-25s %s\n", "-i", "--interface", "please input port[x] first"); @@ -42,6 +44,8 @@ static int cxl_membar_port_id_set(struct major_cmd_ctrl *self, const char *argv) uint32_t val; int ret; + HIKP_SET_USED(self); + ret = string_toui(argv, &val); if (ret) { printf("cxl membar set port id err %d\n", ret); @@ -54,6 +58,9 @@ static int cxl_membar_port_id_set(struct major_cmd_ctrl *self, const char *argv) static int cxl_membar_err_info(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_cxl_membar_cmd.cmd_type = CXL_MEMBAR_ERR; return 0; @@ -61,6 +68,9 @@ static int cxl_membar_err_info(struct major_cmd_ctrl *self, const char *argv) static int cxl_membar_dump(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_cxl_membar_cmd.cmd_type = CXL_MEMBAR_DUMP; return 0; diff --git a/cxl/usr_cmd/cmd_analysis/cxl_cmd_rcrb.c b/cxl/usr_cmd/cmd_analysis/cxl_cmd_rcrb.c index f83b64dbd87c2a9bb5634f75f0c5e28493d10839..01796056f0f3728f107dbe24f672ae1079005bcc 100644 --- a/cxl/usr_cmd/cmd_analysis/cxl_cmd_rcrb.c +++ b/cxl/usr_cmd/cmd_analysis/cxl_cmd_rcrb.c @@ -25,6 +25,8 @@ struct tool_cxl_cmd g_cxl_rcrb_cmd = { static int cxl_rcrb_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf(" Usage: %s\n", self->cmd_ptr->name); printf(" %s\n", self->cmd_ptr->help_info); printf(" %s, %-25s %s\n", "-i", "--interface", "please input port[x] first"); @@ -43,6 +45,8 @@ static int cxl_rcrb_port_id_set(struct major_cmd_ctrl *self, const char *argv) uint32_t val; int ret; + HIKP_SET_USED(self); + ret = string_toui(argv, &val); if (ret) { printf("cxl rcrb set port id err %d\n", ret); @@ -55,6 +59,9 @@ static int cxl_rcrb_port_id_set(struct major_cmd_ctrl *self, const char *argv) static int cxl_rcrb_link_status(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_cxl_rcrb_cmd.cmd_type = CXL_RCRB_LINK; return 0; @@ -62,6 +69,9 @@ static int cxl_rcrb_link_status(struct major_cmd_ctrl *self, const char *argv) static int cxl_rcrb_header_info(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_cxl_rcrb_cmd.cmd_type = CXL_RCRB_HDR; return 0; @@ -69,6 +79,9 @@ static int cxl_rcrb_header_info(struct major_cmd_ctrl *self, const char *argv) static int cxl_rcrb_dump(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_cxl_rcrb_cmd.cmd_type = CXL_RCRB_DUMP; return 0; diff --git a/hccs/hikp_hccs.c b/hccs/hikp_hccs.c new file mode 100644 index 0000000000000000000000000000000000000000..5ef42225918a1e4133de29488eb042d1141d2ed3 --- /dev/null +++ b/hccs/hikp_hccs.c @@ -0,0 +1,807 @@ +/* + * Copyright (c) 2024-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 "tool_cmd.h" +#include "hikpt_rciep.h" +#include "hikp_hccs.h" + +enum hccs_link_fsm { + HCCS_PORT_RESET = 1, + HCCS_PORT_SETUP, + HCCS_PORT_CONFIG, + HCCS_PORT_READY +}; + +const struct { + enum hccs_link_fsm link_fsm; + const char *str; +} link_fsm_map[] = { + {HCCS_PORT_RESET, "reset"}, + {HCCS_PORT_SETUP, "setup"}, + {HCCS_PORT_CONFIG, "config"}, + {HCCS_PORT_READY, "link-up"}, +}; + +static struct hccs_param g_hccs_param = { 0 }; +static struct hikp_plat_hccs_info g_hccs_info = { 0 }; + +static int hikp_hccs_get_plat_topo(struct hccs_param *param, + union hccs_feature_info *info); +static void hikp_hccs_show_topo(union hccs_feature_info *data); +static int hikp_hccs_get_port_attr(struct hccs_param *param, + union hccs_feature_info *info); +static void hikp_hccs_show_port_attr(union hccs_feature_info *feature_info); +static int hikp_hccs_get_port_dfx_info(struct hccs_param *param, + union hccs_feature_info *info); +static void hikp_hccs_show_port_dfx_info(union hccs_feature_info *feature_info); +static int hikp_plat_hccs_hw_info(struct hikp_plat_hccs_info *hccs_info); +static int hikp_hccs_get_die_num(uint8_t chip_id, struct hikp_plat_hccs_info *hccs_info); + +static const struct hikp_hccs_feature_cmd g_hccs_feature_cmd[] = { + {"topo", HCCS_GET_PORT_IDS_ON_DIE, hikp_hccs_get_plat_topo, + hikp_hccs_show_topo, 0}, + {"fixed_attr", HCCS_GET_PORT_FIXED_ATTR, hikp_hccs_get_port_attr, + hikp_hccs_show_port_attr, HCCS_PORT_INFO_MASK}, + {"dfx_info", HCCS_GET_PORT_DFX_INFO, hikp_hccs_get_port_dfx_info, + hikp_hccs_show_port_dfx_info, HCCS_PORT_INFO_MASK}, +}; + +static int hikp_hccs_cmd_help(struct major_cmd_ctrl *self, const char *argv) +{ + HIKP_SET_USED(argv); + + printf("\n Usage: %s\n", self->cmd_ptr->name); + printf("\n %s\n", self->cmd_ptr->help_info); + printf("\n Options:\n\n"); + printf(" %s, %-25s %s\n", "-h", "--help", "display this help and exit"); + printf(" %s, %-25s %s\n", "-c", "--chip_id=", "target chip"); + printf(" %s, %-25s %s\n", "-d", "--die_id=", "target die"); + printf(" %s, %-25s %s\n", "-p", "--port_id=", "target port"); + printf(" %s\n", + "[-g/--get ]\n" + " topo : get hccs_typo info, no target specified.\n" + " fixed_attr : get fixed attributes for port specified by -c X -d X -p X.\n" + " dfx_info : get dfx info for port specified by -c X -d X -p X.\n"); + return 0; +} + +static int hikp_hccs_cmd_send(struct hikp_cmd_header *req_header, + struct hikp_hccs_req *req_data, + void *buff, size_t buff_len, + struct hikp_hccs_rsp_head *rsp_head) +{ + struct hikp_cmd_ret *cmd_ret; + struct hikp_hccs_rsp *rsp; + uint64_t cur_blk_size; + int ret; + + cmd_ret = hikp_cmd_alloc(req_header, req_data, sizeof(struct hikp_hccs_req)); + ret = hikp_rsp_normal_check(cmd_ret); + if (ret != 0) { + HIKP_ERROR_PRINT("Failed to query from firmware! ret = %d.\n", ret); + goto out; + } + + rsp = (struct hikp_hccs_rsp *)cmd_ret->rsp_data; + cur_blk_size = rsp->rsp_head.cur_blk_size; + if (cur_blk_size == 0) { + HIKP_ERROR_PRINT("Firmware reported zero data size!\n"); + ret = -EINVAL; + goto out; + } + if (cur_blk_size > buff_len || + cur_blk_size > sizeof(struct hikp_hccs_rsp)) { + HIKP_ERROR_PRINT("The firmware data size (%" PRIu64 ") greater than " + "sw buffer(%zu) or hikp_hccs_rsp size(%zu).\n", + cur_blk_size, buff_len, sizeof(struct hikp_hccs_rsp)); + ret = -EINVAL; + goto out; + } + + memcpy(buff, rsp->rsp_data, rsp->rsp_head.cur_blk_size); + rsp_head->total_blk_num = rsp->rsp_head.total_blk_num; + rsp_head->cur_blk_size = rsp->rsp_head.cur_blk_size; + +out: + hikp_cmd_free(&cmd_ret); + return ret; +} + +static int hikp_hccs_query(struct hikp_cmd_header *req_header, + struct hikp_hccs_req *req_data, + void *buff, size_t buff_len) +{ + struct hikp_hccs_rsp_head rsp_head = {0}; + uint16_t total_blk_size = 0; + uint16_t total_blk_num; + uint16_t blk_id = 0; + int ret; + + ret = hikp_hccs_cmd_send(req_header, req_data, buff, buff_len, &rsp_head); + if (ret != 0) + return ret; + total_blk_num = rsp_head.total_blk_num; + total_blk_size += rsp_head.cur_blk_size; + for (blk_id = 1; blk_id < total_blk_num; blk_id++) { + if (buff_len <= total_blk_size) { + HIKP_ERROR_PRINT("No enough buffer to get block-(%u) context.\n", + blk_id); + return -EINVAL; + } + + req_data->head.blk_id = blk_id; + ret = hikp_hccs_cmd_send(req_header, req_data, + (uint8_t *)buff + total_blk_size, + buff_len - total_blk_size, &rsp_head); + if (ret != 0) { + HIKP_ERROR_PRINT("Failed to get context for block-(%u)!\n", + blk_id); + return -EINVAL; + } + total_blk_size += rsp_head.cur_blk_size; + } + + return 0; +} + +static int hikp_hccs_get_chip_num(struct hikp_plat_hccs_info *hccs_info) +{ + struct hccs_chip_num_rsp_data rsp_data = {0}; + struct hikp_cmd_header req_header = {0}; + struct hikp_hccs_req req = {0}; + int ret; + + hikp_cmd_init(&req_header, HCCS_MOD, HCCS_GET_CHIP_NUM, 0); + ret = hikp_hccs_query(&req_header, &req, + &rsp_data, sizeof(struct hccs_chip_num_rsp_data)); + if (ret != 0) { + HIKP_ERROR_PRINT("Failed to get chip number from firmware, ret = %d!\n", ret); + return ret; + } + + if (rsp_data.chip_num == 0) { + HIKP_ERROR_PRINT("The chip number obtained from firmware is zero!\n"); + return -EINVAL; + } + hccs_info->chip_num = rsp_data.chip_num; + + return 0; +} + +static int hikp_hccs_get_die_num(uint8_t chip_id, struct hikp_plat_hccs_info *hccs_info) +{ + struct hccs_die_num_rsp_data rsp_data = {0}; + struct hikp_cmd_header req_header = {0}; + struct hccs_die_num_req_para *req_param; + struct hikp_hccs_req req = {0}; + int ret; + + hikp_cmd_init(&req_header, HCCS_MOD, HCCS_GET_DIE_NUM, 0); + req_param = (struct hccs_die_num_req_para *)&req.req_data; + req_param->chip_id = chip_id; + ret = hikp_hccs_query(&req_header, &req, + &rsp_data, sizeof(struct hccs_die_num_rsp_data)); + if (ret != 0) { + HIKP_ERROR_PRINT("Failed to get die number from firmware, ret = %d!\n", ret); + return ret; + } + + hccs_info->chip_info[chip_id].die_num = rsp_data.die_num; + return 0; +} + +static int hikp_hccs_get_die_info(struct hccs_die_info *die_info, + uint8_t chip_id, uint8_t die_idx) +{ + struct hccs_die_info_rsp_data rsp_data = {0}; + struct hccs_die_info_req_para *req_param; + struct hikp_cmd_header req_header = {0}; + struct hikp_hccs_req req = {0}; + int ret; + + hikp_cmd_init(&req_header, HCCS_MOD, HCCS_GET_DIE_INFO, 0); + req_param = (struct hccs_die_info_req_para *)&req.req_data; + req_param->chip_id = chip_id; + req_param->die_idx = die_idx; + ret = hikp_hccs_query(&req_header, &req, + &rsp_data, sizeof(struct hccs_die_info_rsp_data)); + if (ret != 0) { + HIKP_ERROR_PRINT("Fail to get die information from firmware, ret = %d!\n", ret); + return ret; + } + + die_info->die_id = rsp_data.die_id; + die_info->port_num = rsp_data.port_num; + return 0; +} + +static int hikp_hccs_get_all_die_info(struct hikp_plat_hccs_info *hccs_info) +{ + uint8_t chip_id, die_idx, die_num; + struct hccs_chip_info *chip_info; + struct hccs_die_info *die_info; + bool has_die = false; + int ret; + + for (chip_id = 0; chip_id < hccs_info->chip_num; chip_id++) { + chip_info = &hccs_info->chip_info[chip_id]; + die_num = chip_info->die_num; + if (die_num == 0) + continue; + + has_die = true; + die_info = (struct hccs_die_info *)calloc(die_num, sizeof(struct hccs_die_info)); + if (die_info == NULL) { + HIKP_ERROR_PRINT("Failed to allocate memory for die information!\n"); + return -ENOMEM; + } + chip_info->die_info = die_info; + for (die_idx = 0; die_idx < die_num; die_idx++, die_info++) { + ret = hikp_hccs_get_die_info(die_info, chip_id, die_idx); + if (ret < 0) { + HIKP_ERROR_PRINT("Failed to get die information for die idx %u!\n", + die_idx); + return ret; + } + } + } + + return has_die ? 0 : -EINVAL; +} + +static int hikp_hccs_get_ports_on_die(uint8_t *port_ids, uint16_t port_num, + uint8_t chip_id, uint8_t die_id) +{ + struct hccs_die_ports_req_para *req_param; + struct hikp_cmd_header req_header = {0}; + struct hikp_hccs_req req = {0}; + int ret; + + hikp_cmd_init(&req_header, HCCS_MOD, HCCS_GET_PORT_IDS_ON_DIE, 0); + req_param = (struct hccs_die_ports_req_para *)&req.req_data; + req_param->chip_id = chip_id; + req_param->die_id = die_id; + ret = hikp_hccs_query(&req_header, &req, + port_ids, sizeof(uint8_t) * port_num); + if (ret != 0) { + HIKP_ERROR_PRINT("Fail to get port ids from firmware, ret = %d!\n", ret); + return ret; + } + + return 0; +} + +static int hikp_hccs_get_all_port_info(struct hikp_plat_hccs_info *hccs_info) +{ + struct hccs_chip_info *chip_info; + struct hccs_die_info *die_info; + struct hccs_die_info *dies; + uint8_t chip_id, die_idx; + bool has_port = false; + int ret; + + for (chip_id = 0; chip_id < hccs_info->chip_num; chip_id++) { + chip_info = &hccs_info->chip_info[chip_id]; + dies = chip_info->die_info; + has_port = false; + for (die_idx = 0; die_idx < chip_info->die_num; die_idx++) { + die_info = &dies[die_idx]; + if (die_info->port_num == 0) + continue; + + has_port = true; + die_info->port_ids = (uint8_t *)calloc(die_info->port_num, + sizeof(uint8_t)); + if (die_info->port_ids == NULL) + return -ENOMEM; + + ret = hikp_hccs_get_ports_on_die(die_info->port_ids, die_info->port_num, + chip_id, die_info->die_id); + if (ret < 0) { + HIKP_ERROR_PRINT("Failed to get port ids for " + "chip (%u) die idx (%u)!\n", + chip_id, die_idx); + return ret; + } + } + } + + return has_port ? 0 : -EINVAL; +} + +static int hikp_hccs_get_chip_info(struct hikp_plat_hccs_info *hccs_info) +{ + uint8_t chip_id; + int ret; + + ret = hikp_hccs_get_chip_num(hccs_info); + if (ret < 0) { + HIKP_ERROR_PRINT("Failed to get chip num!\n"); + return ret; + } + + hccs_info->chip_info = (struct hccs_chip_info *)calloc(hccs_info->chip_num, + sizeof(struct hccs_chip_info)); + if (hccs_info->chip_info == NULL) { + HIKP_ERROR_PRINT("Failed to allocate memory for chip info!\n"); + return -ENOMEM; + } + + for (chip_id = 0; chip_id < hccs_info->chip_num; chip_id++) { + ret = hikp_hccs_get_die_num(chip_id, hccs_info); + if (ret < 0) { + HIKP_ERROR_PRINT("Failed to get die num!\n"); + return ret; + } + } + + return 0; +} + +static int hikp_plat_hccs_hw_info(struct hikp_plat_hccs_info *hccs_info) +{ + int ret; + + ret = hikp_hccs_get_chip_info(hccs_info); + if (ret != 0) { + HIKP_ERROR_PRINT("Failed to get chip info, ret = %d!\n", ret); + return ret; + } + + ret = hikp_hccs_get_all_die_info(hccs_info); + if (ret != 0) { + HIKP_ERROR_PRINT("Failed to get all die info, ret = %d!\n", ret); + return ret; + } + + ret = hikp_hccs_get_all_port_info(hccs_info); + if (ret != 0) { + HIKP_ERROR_PRINT("Failed to get all port info, ret = %d!\n", ret); + return ret; + } + return 0; +} + +static int hikp_hccs_get_plat_topo(struct hccs_param *param, + union hccs_feature_info *info) +{ + int ret; + + HIKP_SET_USED(param); + HIKP_SET_USED(info); + + ret = hikp_plat_hccs_hw_info(&g_hccs_info); + if (ret < 0) { + HIKP_ERROR_PRINT("Failed to get HCCS hardware info, ret = %d!\n", ret); + return ret; + } + return 0; +} + +static void hikp_plat_hccs_free(struct hikp_plat_hccs_info *hccs_info) +{ + struct hccs_chip_info *chip_info; + struct hccs_die_info *die_info; + uint8_t chip_id, die_idx; + + if (hccs_info->chip_info == NULL) + return; + + for (chip_id = 0; chip_id < hccs_info->chip_num; chip_id++) { + chip_info = &hccs_info->chip_info[chip_id]; + die_info = chip_info->die_info; + if (die_info == NULL) + continue; + + for (die_idx = 0; die_idx < chip_info->die_num; die_idx++) { + if (die_info[die_idx].port_ids == NULL) + continue; + free(die_info[die_idx].port_ids); + die_info[die_idx].port_ids = NULL; + } + free(die_info); + chip_info->die_info = NULL; + } + free(hccs_info->chip_info); + hccs_info->chip_info = NULL; +} + +static bool hikp_hccs_die_id_valid(struct hikp_plat_hccs_info *hccs_info, + struct hccs_param *param, uint8_t *die_idx) +{ + struct hccs_chip_info *chip_info; + struct hccs_die_info *die_info; + uint8_t idx; + + chip_info = &hccs_info->chip_info[param->chip_id]; + die_info = chip_info->die_info; + for (idx = 0; idx < chip_info->die_num; idx++) { + if (param->die_id != die_info[idx].die_id) + continue; + *die_idx = idx; + return true; + } + return false; +} + +static bool hikp_hccs_port_id_valid(struct hikp_plat_hccs_info *hccs_info, + struct hccs_param *param, uint8_t die_idx) +{ + struct hccs_chip_info *chip_info; + struct hccs_die_info *die_info; + uint8_t port_id, *port_ids; + + chip_info = &hccs_info->chip_info[param->chip_id]; + die_info = &chip_info->die_info[die_idx]; + port_ids = die_info->port_ids; + + for (port_id = 0; port_id < die_info->port_num; port_id++) { + if (param->port_id == port_ids[port_id]) + return true; + } + + return false; +} + +static bool hikp_hccs_req_param_check(struct hikp_plat_hccs_info *hccs_info, + struct hccs_param *param) +{ + uint8_t die_idx; + + if (param->chip_id >= hccs_info->chip_num) { + HIKP_ERROR_PRINT("param error: chip id %u exceed chip number %u!\n", + param->chip_id, hccs_info->chip_num); + return false; + } + + if (!hikp_hccs_die_id_valid(hccs_info, param, &die_idx)) { + HIKP_ERROR_PRINT("Param error: die%u not found on chip%u!\n", + param->die_id, param->chip_id); + return false; + } + + if (!hikp_hccs_port_id_valid(hccs_info, param, die_idx)) { + HIKP_ERROR_PRINT("Param error: port id %u not found on chip%u die%u!\n", + param->port_id, param->chip_id, param->die_id); + return false; + } + + return true; +} + +static int hikp_hccs_get_port_attr(struct hccs_param *param, + union hccs_feature_info *info) +{ + struct hccs_port_attr_req_para *req_para; + struct hikp_cmd_header req_header = {0}; + struct hikp_hccs_req req = {0}; + int ret; + + ret = hikp_plat_hccs_hw_info(&g_hccs_info); + if (ret != 0) { + HIKP_ERROR_PRINT("Failed to get HCCS hardware info for " + "port attributes, ret = %d.\n", ret); + return ret; + } + + if (!hikp_hccs_req_param_check(&g_hccs_info, param)) + return -EINVAL; + + hikp_cmd_init(&req_header, HCCS_MOD, HCCS_GET_PORT_FIXED_ATTR, 0); + req_para = (struct hccs_port_attr_req_para *)&req.req_data; + req_para->chip_id = param->chip_id; + req_para->die_id = param->die_id; + req_para->port_id = param->port_id; + ret = hikp_hccs_query(&req_header, &req, + info, sizeof(union hccs_feature_info)); + if (ret != 0) + return ret; + return 0; +} + +static int hikp_hccs_get_port_dfx_info(struct hccs_param *param, + union hccs_feature_info *info) +{ + struct hikp_hccs_rsp_head rsp_head = {0}; + struct hikp_cmd_header req_header = {0}; + struct hccs_port_dfx_info_vld *dfx_info; + struct hccs_port_dfx_req_para *dfx_req; + struct hikp_hccs_req req = {0}; + int ret; + + ret = hikp_plat_hccs_hw_info(&g_hccs_info); + if (ret != 0) { + HIKP_ERROR_PRINT("Failed to get HCCS hardware info for dfx info, ret = %d\n", + ret); + return ret; + } + + if (!hikp_hccs_req_param_check(&g_hccs_info, param)) + return -EINVAL; + + dfx_info = &info->dfx_info; + dfx_req = (struct hccs_port_dfx_req_para *)&req.req_data; + dfx_req->chip_id = param->chip_id; + dfx_req->port_id = param->port_id; + dfx_req->die_id = param->die_id; + hikp_cmd_init(&req_header, HCCS_MOD, HCCS_GET_PORT_DFX_INFO, 0); + ret = hikp_hccs_cmd_send(&req_header, &req, + &dfx_info->info, + sizeof(struct hccs_port_dfx_info), + &rsp_head); + if (ret != 0) + return ret; + + dfx_info->vld_size = rsp_head.cur_blk_size; + + return 0; +} + +static void hikp_hccs_show_topo(union hccs_feature_info *data) +{ + uint8_t chip_id, die_idx, die_num, port_idx, *port_ids; + struct hccs_die_info *die_info; + struct hccs_die_info *dies; + + HIKP_SET_USED(data); + + for (chip_id = 0; chip_id < g_hccs_info.chip_num; chip_id++) { + die_num = g_hccs_info.chip_info[chip_id].die_num; + dies = g_hccs_info.chip_info[chip_id].die_info; + printf("--chip%u\n", chip_id); + if (die_num == 0) + continue; + for (die_idx = 0; die_idx < die_num; die_idx++) { + die_info = &dies[die_idx]; + printf("\t--die%u\n", die_info->die_id); + port_ids = die_info->port_ids; + if (die_info->port_num == 0) + continue; + + for (port_idx = 0; port_idx < die_info->port_num; port_idx++) + printf("\t\t--hccs%u\n", port_ids[port_idx]); + } + } +} + +static void hikp_hccs_show_port_attr(union hccs_feature_info *feature_info) +{ + struct hccs_port_fixed_attr *info = &feature_info->attr; + + printf("%-16s\tHCCS-V%u\n" + "%-16s\tx%u\n" + "%-16s\t%uMbps\n" + "%-16s\t%u\n", + "hccs_type", info->hccs_type, + "lane_mode", info->lane_mode, + "speed", info->speed, + "enabled", info->enabled); +} + +static const char *hikp_hccs_link_fsm_to_str(uint8_t link_fsm) +{ + size_t i; + + for (i = 0; i < sizeof(link_fsm_map) / sizeof(link_fsm_map[0]); i++) { + if (link_fsm_map[i].link_fsm == link_fsm) + return link_fsm_map[i].str; + } + + return "unknown"; +} + +static void hikp_hccs_show_port_dfx_info(union hccs_feature_info *feature_info) +{ + struct hccs_port_dfx_info_vld *info_vld = &feature_info->dfx_info; + struct hccs_port_dfx_info *info = &info_vld->info; + size_t vld_size; + + vld_size = (size_t)info_vld->vld_size; + if (vld_size >= sizeof(info->link_fsm)) { + printf("%-16s\t%s\n", "link_fsm", hikp_hccs_link_fsm_to_str(info->link_fsm)); + vld_size -= sizeof(info->link_fsm); + } + + if (vld_size >= sizeof(info->cur_lane_num)) { + printf("%-16s\t%u\n", "cur_lane_num", info->cur_lane_num); + vld_size -= sizeof(info->cur_lane_num); + } + + if (vld_size >= sizeof(info->lane_mask)) { + printf("%-16s\t0x%x\n", "lane_mask", info->lane_mask); + vld_size -= sizeof(info->lane_mask); + } + + if (vld_size >= sizeof(info->crc_err_cnt)) { + printf("%-16s\t%u\n", "crc_err_cnt", info->crc_err_cnt); + vld_size -= sizeof(info->crc_err_cnt); + } + + if (vld_size >= sizeof(info->retry_cnt)) { + printf("%-16s\t%u\n", "retry_cnt", info->retry_cnt); + vld_size -= sizeof(info->retry_cnt); + } + + if (vld_size >= sizeof(info->phy_reinit_cnt)) { + printf("%-16s\t%u\n", "phy_reinit_cnt", info->phy_reinit_cnt); + vld_size -= sizeof(info->phy_reinit_cnt); + } + + if (vld_size >= sizeof(info->tx_credit)) { + printf("%-16s\t%u\n", "tx_credit", info->tx_credit); + vld_size -= sizeof(info->tx_credit); + } +} + +static void hikp_hccs_cmd_execute(struct major_cmd_ctrl *self) +{ + const struct hikp_hccs_feature_cmd *hccs_cmd; + union hccs_feature_info info = {0}; + int ret; + + if (g_hccs_param.feature_idx == -1) { + hikp_hccs_cmd_help(self, NULL); + snprintf(self->err_str, sizeof(self->err_str), "-g/--get param error!"); + self->err_no = -EINVAL; + return; + } + + hccs_cmd = &g_hccs_feature_cmd[g_hccs_param.feature_idx]; + if (g_hccs_param.param_mask != hccs_cmd->param_needed) { + hikp_hccs_cmd_help(self, NULL); + snprintf(self->err_str, sizeof(self->err_str), "Parameter mismatched!"); + self->err_no = -EINVAL; + return; + } + + ret = hikp_hccs_get_chip_num(&g_hccs_info); + if (ret < 0) { + self->err_no = ret; + return; + } + + if (g_hccs_info.chip_num == 1) { + snprintf(self->err_str, sizeof(self->err_str), + "The command is just supported on multi-sockets!\n"); + self->err_no = -EINVAL; + return; + } + + ret = hccs_cmd->query(&g_hccs_param, &info); + if (ret != 0) { + snprintf(self->err_str, sizeof(self->err_str), "Failed to query %s, ret = %d.", + hccs_cmd->feature_name, ret); + self->err_no = ret; + hikp_plat_hccs_free(&g_hccs_info); + return; + } + + printf("############## HCCS: %s info ############\n", hccs_cmd->feature_name); + hccs_cmd->show(&info); + printf("#################### END #######################\n"); + + hikp_plat_hccs_free(&g_hccs_info); +} + +static int hikp_hccs_cmd_feature_select(struct major_cmd_ctrl *self, const char *argv) +{ + size_t feat_size = HIKP_ARRAY_SIZE(g_hccs_feature_cmd); + size_t i; + + for (i = 0; i < feat_size; i++) { + if (strcmp(argv, g_hccs_feature_cmd[i].feature_name) == 0) { + g_hccs_param.feature_idx = i; + return 0; + } + } + + hikp_hccs_cmd_help(self, NULL); + snprintf(self->err_str, sizeof(self->err_str), "-g/--get param error!!!"); + self->err_no = -EINVAL; + + return self->err_no; +} + +static int hikp_hccs_cmd_parse_chip(struct major_cmd_ctrl *self, const char *argv) +{ + uint32_t chip_id; + + self->err_no = string_toui(argv, &chip_id); + if (self->err_no) { + snprintf(self->err_str, sizeof(self->err_str), + "Failed to parse -c/--chip_id parameter."); + return self->err_no; + } + if (chip_id > UINT8_MAX) { + snprintf(self->err_str, sizeof(self->err_str), + "chip id should not be greater than %u.", UINT8_MAX); + self->err_no = -EINVAL; + return self->err_no; + } + + g_hccs_param.param_mask |= HCCS_ENABLE_CHIP_ID; + g_hccs_param.chip_id = (uint8_t)chip_id; + + return 0; +} + +static int hikp_hccs_cmd_parse_die(struct major_cmd_ctrl *self, const char *argv) +{ + uint32_t die_id; + + self->err_no = string_toui(argv, &die_id); + if (self->err_no) { + snprintf(self->err_str, sizeof(self->err_str), + "Failed to parse -d/--die_id parameter."); + return self->err_no; + } + + if (die_id > UINT8_MAX) { + snprintf(self->err_str, sizeof(self->err_str), + "die id should not be greater than %u.", UINT8_MAX); + self->err_no = -EINVAL; + return self->err_no; + } + + g_hccs_param.param_mask |= HCCS_ENABLE_DIE_ID; + g_hccs_param.die_id = (uint8_t)die_id; + + return 0; +} + +static int hikp_hccs_cmd_parse_port(struct major_cmd_ctrl *self, const char *argv) +{ + uint32_t port_id; + + self->err_no = string_toui(argv, &port_id); + if (self->err_no) { + snprintf(self->err_str, sizeof(self->err_str), + "Failed to parse -p/--port_id parameter."); + return self->err_no; + } + + if (port_id > UINT8_MAX) { + snprintf(self->err_str, sizeof(self->err_str), + "port id should not be greater %u.", UINT8_MAX); + self->err_no = -EINVAL; + return self->err_no; + } + + g_hccs_param.param_mask |= HCCS_ENABLE_PORT_ID; + g_hccs_param.port_id = (uint8_t)port_id; + return 0; +} + +static void hikp_hccs_cmd_init(void) +{ + struct major_cmd_ctrl *major_cmd = get_major_cmd(); + + g_hccs_param.feature_idx = -1; + + major_cmd->option_count = 0; + major_cmd->execute = hikp_hccs_cmd_execute; + + cmd_option_register("-h", "--help", false, hikp_hccs_cmd_help); + cmd_option_register("-g", "--get", true, hikp_hccs_cmd_feature_select); + cmd_option_register("-c", "--chip_id", true, hikp_hccs_cmd_parse_chip); + cmd_option_register("-d", "--die_id", true, hikp_hccs_cmd_parse_die); + cmd_option_register("-p", "--port_id", true, hikp_hccs_cmd_parse_port); +} + +HIKP_CMD_DECLARE("hccs", "dump HCCS information.", hikp_hccs_cmd_init); diff --git a/hccs/hikp_hccs.h b/hccs/hikp_hccs.h new file mode 100644 index 0000000000000000000000000000000000000000..8ccc01a9b032dbeb3280305401235003f32b676d --- /dev/null +++ b/hccs/hikp_hccs.h @@ -0,0 +1,161 @@ +/* + * Copyright (c) 2024-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 HIKP_HCCS_H +#define HIKP_HCCS_H + +#include + +enum hikp_hccs_cmd_type { + HCCS_GET_CHIP_NUM = 0, + HCCS_GET_DIE_NUM, + HCCS_GET_DIE_INFO, + HCCS_GET_PORT_IDS_ON_DIE, + HCCS_GET_PORT_FIXED_ATTR, + HCCS_GET_PORT_DFX_INFO, +}; + +struct hccs_die_info { + uint8_t die_id; + uint16_t port_num; + uint8_t *port_ids; +}; + +struct hccs_chip_info { + uint8_t chip_id; + uint8_t die_num; + struct hccs_die_info *die_info; +}; + +struct hccs_port_fixed_attr { + uint8_t hccs_type; /* HCCS_V1, HCCS_V2 and etc. */ + uint8_t lane_mode; + uint16_t speed; /* Unit Mbps. */ + uint8_t enabled; /* Indicate if port is enabled. */ + uint8_t rsv[3]; +}; + +struct hccs_port_dfx_info { + uint8_t link_fsm; + uint8_t cur_lane_num; + uint16_t lane_mask; + uint32_t crc_err_cnt; + uint32_t retry_cnt; + uint32_t phy_reinit_cnt; + uint32_t tx_credit; + uint32_t rsv1[54]; +}; + +struct hccs_port_dfx_info_vld { + struct hccs_port_dfx_info info; + uint8_t vld_size; /* Indicate the valid bytes firmware reported. */ +}; + +union hccs_feature_info { + struct hccs_port_fixed_attr attr; + struct hccs_port_dfx_info_vld dfx_info; +}; + +struct hccs_chip_num_rsp_data { + uint8_t chip_num; +}; + +struct hccs_die_num_req_para { + uint8_t chip_id; +}; + +struct hccs_die_num_rsp_data { + uint8_t die_num; +}; + +struct hccs_die_info_req_para { + uint8_t chip_id; + uint8_t die_idx; +}; + +struct hccs_die_info_rsp_data { + uint8_t die_id; + uint8_t rsv; + uint16_t port_num; +}; + +struct hccs_die_ports_req_para { + uint8_t chip_id; + uint8_t die_id; +}; + +struct hccs_port_attr_req_para { + uint8_t chip_id; + uint8_t die_id; + uint8_t port_id; +}; + +struct hccs_port_dfx_req_para { + uint8_t chip_id; + uint8_t die_id; + uint8_t port_id; +}; + +struct hikp_hccs_rsp_head { + uint16_t total_blk_num; + uint8_t cur_blk_size; /* real data size, not contain header size. */ + uint8_t rsv; +}; + +#define HCCS_MAX_RSP_DATA 59 +struct hikp_hccs_rsp { + struct hikp_hccs_rsp_head rsp_head; /* 4 Byte */ + uint32_t rsp_data[HCCS_MAX_RSP_DATA]; +}; + +struct hikp_hccs_req_head { + uint16_t blk_id; + uint16_t rsv; +}; + +#define HCCS_MAX_REQ_DATA 31 +struct hikp_hccs_req { + struct hikp_hccs_req_head head; /* 4 Byte */ + uint32_t req_data[HCCS_MAX_REQ_DATA]; +}; + +#define HCCS_ENABLE_CHIP_ID HI_BIT(0) +#define HCCS_ENABLE_DIE_ID HI_BIT(1) +#define HCCS_ENABLE_PORT_ID HI_BIT(2) +#define HCCS_PORT_INFO_MASK (HCCS_ENABLE_CHIP_ID | HCCS_ENABLE_DIE_ID | \ + HCCS_ENABLE_PORT_ID) + +struct hccs_param { + int feature_idx; + uint8_t chip_id; + uint8_t die_id; + uint32_t port_id; + /* mask for param passed by user, see HCCS_ENABLE_XXX. */ + uint16_t param_mask; +}; + +struct hikp_plat_hccs_info { + uint8_t chip_num; + struct hccs_chip_info *chip_info; +}; + +#define HIKP_HCCS_FEATURE_NAME_LEN 20 +struct hikp_hccs_feature_cmd { + const char feature_name[HIKP_HCCS_FEATURE_NAME_LEN]; + uint32_t cmd_code; + int (*query)(struct hccs_param *param, union hccs_feature_info *info); + void (*show)(union hccs_feature_info *data); + uint16_t param_needed; +}; + +#endif /* HIKP_HCCS_H */ diff --git a/info_collect/hikp_collect.h b/info_collect/hikp_collect.h new file mode 100644 index 0000000000000000000000000000000000000000..26108ac2bef47520c3d31f61a8e5b63203344188 --- /dev/null +++ b/info_collect/hikp_collect.h @@ -0,0 +1,56 @@ +/* + * 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. + */ + +#ifndef HIKP_COLLECT_H +#define HIKP_COLLECT_H + +#define GROUP_SAS "sas" +#define GROUP_SATA "sata" +#define GROUP_ACC "acc" +#define GROUP_SOCIP "socip" +#define GROUP_NIC "nic" +#define GROUP_ROCE "roce" +#define GROUP_PCIE "pcie" +#define GROUP_IMP "imp" +#define GROUP_COMMON "common" +#define GROUP_SERDES "serdes" +#define GROUP_SDMA "sdma" + +enum info_collect_type { + COLLECT_ACC, + COLLECT_IMP, + COLLECT_NIC, + COLLECT_PCIE, + COLLECT_ROCE, + COLLECT_SAS, + COLLECT_SATA, + COLLECT_SERDES, + COLLECT_SOCIP, + COLLECT_SDMA, + COLLECT_ALL, + COLLECT_UNKNOWN_TYPE, +}; + +void collect_sas_log(void); +void collect_sata_log(void); +void collect_acc_log(void); +void collect_socip_log(void); +void collect_common_log(void); +void collect_nic_log(void); +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_acc.c b/info_collect/hikp_collect_acc.c new file mode 100644 index 0000000000000000000000000000000000000000..e0f391863b9f9321d73227157b3e685dc8edd3b3 --- /dev/null +++ b/info_collect/hikp_collect_acc.c @@ -0,0 +1,237 @@ +/* + * 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 +#include + +#include "hikp_collect_lib.h" +#include "hikp_collect.h" +#include "tool_lib.h" + +struct info_collect_cmd acc_cmd_arr[] = { + { + .group = GROUP_ACC, + .log_name = "uadk_version", + .args = {"uadk_tool", "dfx", "--version", NULL}, + }, + { + .group = GROUP_ACC, + .log_name = "openssl_version", + .args = {"openssl", "version", NULL}, + }, + { + .group = GROUP_ACC, + .log_name = "openssl3_version", + .args = {"openssl3", "version", NULL}, + }, + { + .group = GROUP_ACC, + .log_name = "qemu_version", + .args = {"qemu-system-aarch64", "-version", NULL}, + }, +}; + +struct info_collect_cmd acc_cmd_copy[] = { + { + .group = GROUP_ACC, + .log_name = "uadk", + .args = {"cp", "-rf", "/var/log/uadk.log", NULL}, + }, + { + .group = GROUP_ACC, + .log_name = "acc_sec", + .args = {"cp", "-rf", "/sys/kernel/debug/hisi_sec2/", NULL}, + }, + { + .group = GROUP_ACC, + .log_name = "acc_sec", + .args = {"cp", "-rf", "/sys/module/hisi_sec2/parameters/", NULL}, + }, + { + .group = GROUP_ACC, + .log_name = "acc_hpre", + .args = {"cp", "-rf", "/sys/kernel/debug/hisi_hpre/", NULL}, + }, + { + .group = GROUP_ACC, + .log_name = "acc_hpre", + .args = {"cp", "-rf", "/sys/module/hisi_hpre/parameters/", NULL}, + }, + { + .group = GROUP_ACC, + .log_name = "acc_zip", + .args = {"cp", "-rf", "/sys/kernel/debug/hisi_zip/", NULL}, + }, + { + .group = GROUP_ACC, + .log_name = "acc_zip", + .args = {"cp", "-rf", "/sys/module/hisi_zip/parameters/", NULL}, + }, + { + .group = GROUP_ACC, + .log_name = "acc_trng", + .args = {"cp", "-rf", "/sys/module/hisi_trng_v2/parameters/", NULL}, + }, +}; + +struct info_collect_cmd acc_copy_link[] = { + { + .group = GROUP_ACC, + .log_name = "uacce", + .args = {"cp", "-rf", "/sys/class/uacce", NULL}, + } +}; + +static int acc_cmd_mkdir(char *root_path, char *src_patch) +{ + char dir_path[LOG_FILE_PATH_MAX_LEN] = {0}; + int ret; + + /* mkdir for log sub source */ + ret = snprintf(dir_path, LOG_FILE_PATH_MAX_LEN, "%s/%s", + root_path, src_patch); + if (ret < 0 || (uint32_t)(ret) >= LOG_FILE_PATH_MAX_LEN) { + HIKP_ERROR_PRINT("create dir path failed: %d\n", ret); + return -EINVAL; + } + + ret = tool_mk_dir((const char *)dir_path); + if (ret) + return ret; + + return 0; +} + +static int acc_collect_file(struct info_collect_cmd *acc_cmd, char *root_path, char *dev_path) +{ + char sub_src_path[LOG_FILE_PATH_MAX_LEN] = {0}; + char save_path[LOG_FILE_PATH_MAX_LEN] = {0}; + struct info_collect_cmd tmp_cmd = {0}; + char *source_path = acc_cmd->args[ARGS_IDX2]; + char *sub_group = acc_cmd->log_name; + int ret; + + ret = snprintf(sub_src_path, LOG_FILE_PATH_MAX_LEN, "%s/%s/", + source_path, dev_path); + if (ret < 0 || (uint32_t)(ret) >= LOG_FILE_PATH_MAX_LEN) { + HIKP_ERROR_PRINT("create sub source path failed: %d\n", ret); + return -EINVAL; + } + if (access(sub_src_path, F_OK) != 0) { + HIKP_ERROR_PRINT("Can't access sub source path: %s\n", sub_src_path); + return -ENOENT; + } + + ret = snprintf(save_path, LOG_FILE_PATH_MAX_LEN, "%s/%s/%s/", + root_path, sub_group, dev_path); + if (ret < 0 || (uint32_t)(ret) >= LOG_FILE_PATH_MAX_LEN) { + HIKP_ERROR_PRINT("create save path failed: %d\n", ret); + return -EINVAL; + } + + tmp_cmd.group = acc_cmd->group; + tmp_cmd.log_name = acc_cmd->log_name; + tmp_cmd.args[ARGS_IDX0] = acc_cmd->args[ARGS_IDX0]; + tmp_cmd.args[ARGS_IDX1] = acc_cmd->args[ARGS_IDX1]; + tmp_cmd.args[ARGS_IDX2] = sub_src_path; + tmp_cmd.args[ARGS_IDX3] = save_path; + tmp_cmd.args[ARGS_IDX4] = NULL; + + ret = hikp_collect_exec((void *)&tmp_cmd); + if (ret) + return ret; + + return 0; +} + +static int acc_save_link_files(struct info_collect_cmd *link_cmd) +{ + char root_path[LOG_FILE_PATH_MAX_LEN] = {0}; + char *source_path = link_cmd->args[ARGS_IDX2]; + char *sub_group = link_cmd->log_name; + struct dirent *dev_dir; + DIR *link_dir; + int ret; + + if (strcmp(link_cmd->args[ARGS_IDX0], "cp") != 0) { + HIKP_ERROR_PRINT("input cmd failed: %s.\n", link_cmd->args[ARGS_IDX0]); + return -EINVAL; + } + + ret = hikp_get_file_path(root_path, LOG_FILE_PATH_MAX_LEN, link_cmd->group); + if (ret < 0) { + HIKP_ERROR_PRINT("get save path fail: %d\n", ret); + return ret; + } + + if (source_path == NULL || access(source_path, F_OK) != 0) { + HIKP_ERROR_PRINT("Can't access source path: %s\n", source_path); + return -ENOENT; + } + + ret = acc_cmd_mkdir(root_path, sub_group); + if (ret) + return ret; + + link_dir = opendir(source_path); + if (!link_dir) { + HIKP_ERROR_PRINT("input source file dir is error!\n"); + return -ENOENT; + } + + /* 1 is sizeof ".", 2 is sizeof ".." */ + while ((dev_dir = readdir(link_dir)) != NULL) { + if (!strncmp(dev_dir->d_name, ".", 1) || + !strncmp(dev_dir->d_name, "..", sizeof(".."))) + continue; + + ret = acc_collect_file(link_cmd, root_path, dev_dir->d_name); + if (ret) + goto free_dir; + } + + closedir(link_dir); + return 0; + +free_dir: + closedir(link_dir); + return ret; +} + +void collect_acc_log(void) +{ + int i, asize; + int ret; + + asize = (int)HIKP_ARRAY_SIZE(acc_cmd_arr); + for (i = 0; i < asize; i++) { + ret = hikp_collect_log(acc_cmd_arr[i].group, acc_cmd_arr[i].log_name, + hikp_collect_exec, (void *)&acc_cmd_arr[i]); + if (ret) + HIKP_ERROR_PRINT("collect_acc_log arr failed: %d\n", ret); + } + + asize = (int)HIKP_ARRAY_SIZE(acc_copy_link); + for (i = 0; i < asize; i++) { + ret = acc_save_link_files(&acc_copy_link[i]); + if (ret) + HIKP_ERROR_PRINT("collect_acc_log link copy failed: %d\n", ret); + } + + asize = (int)HIKP_ARRAY_SIZE(acc_cmd_copy); + for (i = 0; i < asize; i++) { + ret = hikp_save_files(&acc_cmd_copy[i]); + if (ret) + HIKP_ERROR_PRINT("collect_acc_log copy failed: %d\n", ret); + } +} diff --git a/info_collect/hikp_collect_common.c b/info_collect/hikp_collect_common.c new file mode 100644 index 0000000000000000000000000000000000000000..413aac14cb5ff5d31225d2b3c63a60ac21ecf1a7 --- /dev/null +++ b/info_collect/hikp_collect_common.c @@ -0,0 +1,258 @@ +/* + * 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 "hikp_collect_lib.h" +#include "hikp_collect.h" +#include "tool_lib.h" + +static int software_version_exec(void *data) +{ + const struct info_collect_cmd software_version_cmds[] = { + { + .args = {"uname", "-a", NULL}, + }, + { + .log_name = "os-release", + .args = {"cat", "/etc/*release", NULL}, + }, + { + .log_name = "os-latest", + .args = {"cat", "/etc/*latest", NULL}, + }, + }; + HIKP_SET_USED(data); + size_t i, size; + int ret; + + size = HIKP_ARRAY_SIZE(software_version_cmds); + for (i = 0; i < size; i++) { + if (!strcmp(software_version_cmds[i].args[ARGS_IDX0], "cat")) + ret = hikp_collect_cat_glob_exec((void *)&software_version_cmds[i]); + else + ret = hikp_collect_exec((void *)&software_version_cmds[i]); + + if (ret) + HIKP_ERROR_PRINT("collect software_version_cmds[%zu] log failed: %d\n", + i, ret); + } + + return 0; +} + +static int mem_info_exec(void *data) +{ + const struct info_collect_cmd mem_info_cmds[] = { + { + .args = {"cat", "/proc/meminfo", NULL}, + }, + { + .args = {"free", "-m", NULL}, + }, + { + .args = {"vmstat", NULL}, + }, + { + .args = {"cat", "/proc/iomem", NULL}, + }, + }; + HIKP_SET_USED(data); + size_t i, size; + int ret; + + size = HIKP_ARRAY_SIZE(mem_info_cmds); + for (i = 0; i < size; i++) { + ret = hikp_collect_exec((void *)&mem_info_cmds[i]); + if (ret) + HIKP_ERROR_PRINT("collect mem_info_cmds[%zu] log failed: %d\n", i, ret); + } + + return 0; +} + +static int process_info_exec(void *data) +{ + const struct info_collect_cmd process_info_cmds[] = { + { + .args = {"ps", "euf", NULL}, + }, + { + .args = {"ps", "aux", NULL}, + }, + { + .args = {"top", "-bn", "1", NULL}, + }, + { + .args = {"mpstat", NULL}, + }, + }; + HIKP_SET_USED(data); + size_t i, size; + int ret; + + size = HIKP_ARRAY_SIZE(process_info_cmds); + for (i = 0; i < size; i++) { + ret = hikp_collect_exec((void *)&process_info_cmds[i]); + if (ret) + HIKP_ERROR_PRINT("collect process_info_cmds[%zu] log failed: %d\n", + i, ret); + } + + return 0; +} + +static int config_info_exec(void *data) +{ + struct info_collect_cmd config_info_cmds[] = { + { + .args = {"cat", "/proc/cmdline", NULL}, + }, + { + .args = {"getconf", "PAGE_SIZE", NULL}, + }, + { + .group = GROUP_COMMON, + .log_name = "config", + .args = {"cp", "-f", "/boot/config-*", NULL}, + }, + { + .group = GROUP_COMMON, + .log_name = "smmu", + .args = {"cp", "-rf", "/sys/class/iommu", NULL}, + }, + }; + HIKP_SET_USED(data); + size_t i, size; + int ret; + + size = HIKP_ARRAY_SIZE(config_info_cmds); + for (i = 0; i < size; i++) { + char *log_name = config_info_cmds[i].log_name; + + if (log_name && !strcmp(log_name, "config")) + ret = hikp_collect_cp_glob_exec((void *)&config_info_cmds[i]); + else if (log_name && !strcmp(log_name, "smmu")) + ret = hikp_save_files(&config_info_cmds[i]); + else + ret = hikp_collect_exec((void *)&config_info_cmds[i]); + + if (ret) + HIKP_ERROR_PRINT("collect process_info_cmds[%zu] log failed: %d\n", + i, ret); + } + + return 0; +} + +static int service_info_exec(void *data) +{ + const struct info_collect_cmd service_info_cmds[] = { + { + .args = {"service", "iptables", "status", NULL}, + }, + { + .args = {"service", "irqbalance", "status", NULL}, + }, + }; + HIKP_SET_USED(data); + size_t i, size; + int ret; + + size = HIKP_ARRAY_SIZE(service_info_cmds); + for (i = 0; i < size; i++) { + ret = hikp_collect_exec((void *)&service_info_cmds[i]); + if (ret) + HIKP_ERROR_PRINT("collect service_info_cmds[%zu] log failed: %d\n", + i, ret); + } + + return 0; +} + +static void collect_software_info(void) +{ + int ret; + + ret = hikp_collect_log(GROUP_COMMON, "software_version", software_version_exec, (void *)NULL); + if (ret) + HIKP_ERROR_PRINT("software_version_exec failed: %d\n", ret); + + ret = hikp_collect_log(GROUP_COMMON, "mem_info", mem_info_exec, (void *)NULL); + if (ret) + HIKP_ERROR_PRINT("mem_info_exec failed: %d\n", ret); + + ret = hikp_collect_log(GROUP_COMMON, "process_info", process_info_exec, (void *)NULL); + if (ret) + HIKP_ERROR_PRINT("process_info_exec failed: %d\n", ret); + + ret = hikp_collect_log(GROUP_COMMON, "config_info", config_info_exec, (void *)NULL); + if (ret) + HIKP_ERROR_PRINT("config_info_exec failed: %d\n", ret); + + ret = hikp_collect_log(GROUP_COMMON, "service_info", service_info_exec, (void *)NULL); + if (ret) + HIKP_ERROR_PRINT("service_info_exec failed: %d\n", ret); +} + +static int hardware_info_exec(void *data) +{ + const struct info_collect_cmd hardware_cmds[] = { + { + .args = {"cat", MIDR_EL1_PATH, NULL}, + }, + { + .args = {"cat", "/sys/bus/cpu/devices/cpu0/cpufreq/scaling_governor", NULL}, + }, + { + .args = {"cat", "/sys/devices/system/cpu/online", NULL}, + }, + { + .args = {"numactl", "-H", NULL}, + }, + { + .args = {"numastat", NULL}, + }, + { + .args = {"lscpu", NULL}, + }, + { + .args = {"dmidecode", NULL}, + }, + }; + HIKP_SET_USED(data); + size_t i, size; + int ret; + + size = HIKP_ARRAY_SIZE(hardware_cmds); + for (i = 0; i < size; i++) { + ret = hikp_collect_exec((void *)&hardware_cmds[i]); + if (ret) + HIKP_ERROR_PRINT("collect hardware_cmds[%zu] log failed: %d\n", i, ret); + } + + return 0; +} + +static void collect_hardware_info(void) +{ + int ret; + + ret = hikp_collect_log(GROUP_COMMON, "hardware_info", hardware_info_exec, (void *)NULL); + if (ret) + HIKP_ERROR_PRINT("hardware_info_exec failed: %d\n", ret); +} + +void collect_common_log(void) +{ + collect_software_info(); + collect_hardware_info(); +} diff --git a/info_collect/hikp_collect_imp.c b/info_collect/hikp_collect_imp.c new file mode 100644 index 0000000000000000000000000000000000000000..296cf07c10a592882dfe8614dfdbf993bceb15da --- /dev/null +++ b/info_collect/hikp_collect_imp.c @@ -0,0 +1,133 @@ +/* + * 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 "hikp_collect_lib.h" +#include "hikp_collect.h" +#include "tool_lib.h" +#include "hikp_nic_log.h" +#include "hikp_nic_mac_dump.h" +#include "hikp_nic_port.h" +#include "hikp_nic_xsfp.h" +#include "hikp_nic_ncsi.h" + +static int hikp_collect_nic_log_info(void *dev_name) +{ + struct info_collect_cmd nic_log_cmd = { + .group = GROUP_IMP, + .log_name = NULL, + .args = {"mv", NULL, NULL}, + }; + struct nic_log_collect_param param = {0}; + char log_name[MAX_LOG_NAME_LEN] = {0}; + int ret; + + param.net_dev_name = (const char *)dev_name; + ret = snprintf(log_name, MAX_LOG_NAME_LEN, "%s_nic_log", (char *)dev_name); + if (ret < 0 || (uint32_t)ret >= MAX_LOG_NAME_LEN) + return -EINVAL; + + ret = hikp_collect_log(GROUP_IMP, log_name, hikp_info_collect_nic_log, (void *)¶m); + if (ret) { + HIKP_ERROR_PRINT("collect %s log failed: %d\n", log_name, ret); + return ret; + } + + nic_log_cmd.args[ARGS_IDX1] = (char *)hikp_info_collect_get_log_path(); + ret = hikp_move_files(&nic_log_cmd); + if (ret) + HIKP_ERROR_PRINT("collect imp log failed, %d\n", ret); + + return ret; +} + +static int hikp_collect_nic_port_info(void *dev_name) +{ + struct nic_port_collect_param param = {0}; + char log_name[MAX_LOG_NAME_LEN] = {0}; + int ret; + + param.net_dev_name = (const char *)dev_name; + ret = snprintf(log_name, MAX_LOG_NAME_LEN, "%s_nic_port", (char *)dev_name); + if (ret < 0 || (uint32_t)ret >= MAX_LOG_NAME_LEN) + return -EINVAL; + + ret = hikp_collect_log(GROUP_IMP, log_name, hikp_info_collect_nic_port, (void *)¶m); + if (ret) + HIKP_ERROR_PRINT("collect %s log failed: %d\n", log_name, ret); + + return ret; +} + +static int hikp_collect_nic_xsfp_info(void *dev_name) +{ + struct nic_xsfp_collect_param param = {0}; + char log_name[MAX_LOG_NAME_LEN] = {0}; + int ret; + + param.net_dev_name = (const char *)dev_name; + ret = snprintf(log_name, MAX_LOG_NAME_LEN, "%s_nic_xsfp", (char *)dev_name); + if (ret < 0 || (uint32_t)ret >= MAX_LOG_NAME_LEN) + return -EINVAL; + + ret = hikp_collect_log(GROUP_IMP, log_name, hikp_info_collect_nic_xsfp, (void *)¶m); + if (ret) + HIKP_ERROR_PRINT("collect %s log failed: %d\n", log_name, ret); + + return ret; +} + +static int hikp_collect_nic_mac_info(void *dev_name) +{ + struct nic_mac_collect_param param = {0}; + char log_name[MAX_LOG_NAME_LEN] = {0}; + int ret; + + param.net_dev_name = (const char *)dev_name; + param.module_name = "ALL"; + ret = snprintf(log_name, MAX_LOG_NAME_LEN, "%s_nic_mac", (char *)dev_name); + if (ret < 0 || (uint32_t)ret >= MAX_LOG_NAME_LEN) + return -EINVAL; + + ret = hikp_collect_log(GROUP_IMP, log_name, hikp_info_collect_nic_mac, (void *)¶m); + if (ret) + HIKP_ERROR_PRINT("collect %s log failed: %d\n", log_name, ret); + + return ret; +} + +static int hikp_collect_nic_ncsi_info(void *dev_name) +{ + struct nic_ncsi_collect_param param = {0}; + char log_name[MAX_LOG_NAME_LEN] = {0}; + int ret; + + param.net_dev_name = (const char *)dev_name; + ret = snprintf(log_name, MAX_LOG_NAME_LEN, "%s_nic_ncsi", (char *)dev_name); + if (ret < 0 || (uint32_t)ret >= MAX_LOG_NAME_LEN) + return -EINVAL; + + ret = hikp_collect_log(GROUP_IMP, log_name, hikp_info_collect_nic_ncsi, (void *)¶m); + if (ret) + HIKP_ERROR_PRINT("collect %s log failed: %d\n", log_name, ret); + + return ret; +} + +void collect_imp_log(void) +{ + hikp_collect_all_nic_cmd_log(hikp_collect_nic_log_info); + hikp_collect_all_nic_cmd_log(hikp_collect_nic_port_info); + hikp_collect_all_nic_cmd_log(hikp_collect_nic_xsfp_info); + hikp_collect_all_nic_cmd_log(hikp_collect_nic_mac_info); + hikp_collect_all_nic_cmd_log(hikp_collect_nic_ncsi_info); +} diff --git a/info_collect/hikp_collect_lib.c b/info_collect/hikp_collect_lib.c new file mode 100644 index 0000000000000000000000000000000000000000..bada8466b406af033beff842a978e102da30dcab --- /dev/null +++ b/info_collect/hikp_collect_lib.c @@ -0,0 +1,508 @@ +/* + * 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 "hikp_collect_lib.h" +#include +#include +#include +#include +#include +#include +#include "tool_lib.h" + +static char log_save_path[LOG_FILE_PATH_MAX_LEN] = {0}; +static char g_collect_name[MAX_LOG_NAME_LEN] = {0}; + +static bool hikp_nic_drv_check(char *nic_name) +{ + char drv_path[LOG_FILE_PATH_MAX_LEN] = {0}; + struct dirent *ptr = NULL; + bool hns3_if = false; + DIR *dir = NULL; + int ret; + + ret = snprintf(drv_path, LOG_FILE_PATH_MAX_LEN, "%s%s/%s", HIKP_NIC_NAME_DIR, + nic_name, HIKP_NIC_DRV_DIR); + if (ret < 0 || (uint32_t)(ret) >= LOG_FILE_PATH_MAX_LEN) + return false; + + if ((dir = opendir(drv_path)) == NULL) + return false; + + while ((ptr = readdir(dir)) != NULL) { + if (strcmp(ptr->d_name, HIKP_NIC_DRV_NAME) == 0) { + hns3_if = true; + break; + } + } + + closedir(dir); + return hns3_if; +} + +void hikp_collect_all_nic_cmd_log(collect_cmd_handler_t hikp_collect_one_nic_log) +{ + struct dirent *ptr = NULL; + DIR *dir = NULL; + int ret; + + if (!hikp_collect_one_nic_log) { + HIKP_ERROR_PRINT("Invalid parameters!\n"); + return; + } + + dir = opendir(HIKP_NIC_NAME_DIR); + if (!dir) { + HIKP_ERROR_PRINT("failed to open path!\n"); + return; + } + + while ((ptr = readdir(dir)) != NULL) { + if ((strcmp(ptr->d_name, ".") == 0) || (strcmp(ptr->d_name, "..") == 0)) { + continue; + } else if (ptr->d_type == DT_LNK) { + if (hikp_nic_drv_check(ptr->d_name)) { + ret = hikp_collect_one_nic_log((void *)ptr->d_name); + if (ret) { + HIKP_WARN_PRINT("failed to collect log for: %s", ptr->d_name); + break; + } + } + } + } + + closedir(dir); +} + +static bool is_cmd_valid(struct info_collect_cmd *cmd, unsigned int args_num) +{ + unsigned int i; + + if (cmd == NULL || cmd->log_name == NULL || args_num == 0 || args_num >= ARGS_MAX_NUM) + return false; + + for (i = 0; i < args_num; i++) + if (cmd->args[i] == NULL) + return false; + + return true; +} + +int hikp_create_save_path(const char *name) +{ + char collect_name[MAX_LOG_NAME_LEN] = {0}; + time_t time_seconds = time(0); + struct tm timeinfo; + int ret; + + localtime_r(&time_seconds, &timeinfo); + if (name != NULL) + (void)snprintf((char *)collect_name, MAX_LOG_NAME_LEN, + "collect_%s_%04d%02d%02d%02d%02d%02d", + name, timeinfo.tm_year + START_YEAR, + timeinfo.tm_mon + 1, timeinfo.tm_mday, + timeinfo.tm_hour, timeinfo.tm_min, timeinfo.tm_sec); + else + (void)snprintf((char *)collect_name, MAX_LOG_NAME_LEN, + "collect_%04d%02d%02d%02d%02d%02d", + timeinfo.tm_year + START_YEAR, timeinfo.tm_mon + 1, + timeinfo.tm_mday, timeinfo.tm_hour, timeinfo.tm_min, + timeinfo.tm_sec); + + ret = snprintf((char *)log_save_path, LOG_FILE_PATH_MAX_LEN, + HIKP_COLLECT_LOG_DIR_PATH"%s", collect_name); + if (ret < 0 || (uint32_t)(ret) >= LOG_FILE_PATH_MAX_LEN) + return -EINVAL; + + if (!is_dir_exist((const char*)log_save_path)) { + if (tool_mk_dir((const char*)log_save_path)) { + HIKP_ERROR_PRINT("mkdir %s failed, errno is %d\n", + log_save_path, errno); + memset(log_save_path, 0, LOG_FILE_PATH_MAX_LEN); + return -ENOENT; + } + } + + ret = snprintf((char *)g_collect_name, MAX_LOG_NAME_LEN, "%s", collect_name); + if (ret < 0 || (uint32_t)(ret) >= MAX_LOG_NAME_LEN) + return -EINVAL; + + return 0; +} + +static int hikp_get_save_path(char *file_path, unsigned int file_path_len) +{ + int ret; + + if (access(log_save_path, F_OK) != 0) + return -ENOENT; + + ret = snprintf((char *)file_path, file_path_len, "%s", log_save_path); + if (ret < 0 || (uint32_t)(ret) >= LOG_FILE_PATH_MAX_LEN) + return -EINVAL; + + return 0; +} + +int hikp_get_file_path(char *file_path, uint32_t file_path_len, + char *group) +{ + char tmp_path[LOG_FILE_PATH_MAX_LEN] = {0}; + int ret; + + ret = hikp_get_save_path(tmp_path, LOG_FILE_PATH_MAX_LEN); + if (ret < 0) { + HIKP_ERROR_PRINT("get file save path failed: %d\n", ret); + return ret; + } + + if (group != NULL) + ret = snprintf(file_path, file_path_len, "%s/%s", + tmp_path, group); + else + ret = snprintf(file_path, file_path_len, "%s", + tmp_path); + + if (ret < 0 || (uint32_t)(ret) >= LOG_FILE_PATH_MAX_LEN) { + HIKP_ERROR_PRINT("create file path fail: %d\n", ret); + return -EINVAL; + } + + if (!is_dir_exist((const char*)file_path)) { + if (tool_mk_dir((const char*)file_path)) { + HIKP_ERROR_PRINT("mkdir %s failed: %d\n", + file_path, errno); + return -ENOENT; + } + } + + return 0; +} + +static int hikp_collect_cmd_exec(const struct info_collect_cmd *cmd) +{ + pid_t pid; + int status; + + pid = fork(); + if (pid == 0) { + /* + * When the command execution fails, exit the child + * process just like when it succeeds. + * */ + if (execvp(cmd->args[ARGS_IDX0], cmd->args) < 0) { + HIKP_ERROR_PRINT("execvp failed: %d\n", errno); + exit(EXIT_FAILURE); + } + } else if (pid > 0) { + /* Parent process */ + waitpid(pid, &status, 0); + } else { + HIKP_ERROR_PRINT("fork failed!\n"); + return -ECHILD; + } + + return 0; +} + +int hikp_collect_exec(void *data) +{ + struct info_collect_cmd *cmd = (struct info_collect_cmd *)data; + struct info_collect_cmd echo_cmd = {0}; + char result[MAX_LOG_NAME_LEN] = {0}; + int len = 0; + int ret; + int i; + + echo_cmd.args[ARGS_IDX0] = "echo"; + echo_cmd.args[ARGS_IDX1] = result; + echo_cmd.args[ARGS_IDX2] = NULL; + for (i = 0; i < ARGS_MAX_NUM && cmd->args[i] != NULL; i++) { + ret = snprintf(result + len, + MAX_LOG_NAME_LEN - len - 1, + "%s ", cmd->args[i]); + len += ret; + if (ret < 0 || len >= (MAX_LOG_NAME_LEN - 1)) { + HIKP_INFO_PRINT("Error getting command args"); + break; + } + } + + ret = hikp_collect_cmd_exec(&echo_cmd); + if (ret) + return ret; + + return hikp_collect_cmd_exec(cmd); +} + +int hikp_collect_log(char *group, char *log_name, collect_cmd_handler_t func, void *data) +{ + unsigned char file_name[MAX_LOG_NAME_LEN] = {0}; + char file_dir[LOG_FILE_PATH_MAX_LEN] = {0}; + char file_path[LOG_FILE_PATH_MAX_LEN] = {0}; + int stdout_fd = dup(STDOUT_FILENO); + int stderr_fd = dup(STDERR_FILENO); + FILE *log_file; + int ret; + + if (log_name == NULL) { + HIKP_ERROR_PRINT("log name is NULL"); + return -EINVAL; + } + + ret = generate_file_name(file_name, MAX_LOG_NAME_LEN, + (const unsigned char*)log_name); + if (ret < 0) + return ret; + + ret = hikp_get_file_path(file_dir, LOG_FILE_PATH_MAX_LEN, group); + if (ret < 0) + return ret; + + ret = snprintf(file_path, LOG_FILE_PATH_MAX_LEN, "%s/%s", file_dir, file_name); + if (ret < 0 || (uint32_t)(ret) >= LOG_FILE_PATH_MAX_LEN) { + HIKP_ERROR_PRINT("create log file path fail: %d\n", ret); + return -EINVAL; + } + + log_file = fopen(file_path, "a"); + if (log_file == NULL) { + HIKP_ERROR_PRINT("open %s failed.", file_path); + return -ENOENT; + } + + (void)chmod(file_path, S_IRUSR | S_IWUSR | S_IRGRP); + + fflush(stdout); + fflush(stderr); + + /* Copy the standard output and error information to log_file */ + dup2(fileno(log_file), STDOUT_FILENO); + dup2(fileno(log_file), STDERR_FILENO); + + ret = func(data); + + fflush(stdout); + fflush(stderr); + + /* Redirect stdout and stderr back to the terminal */ + dup2(stdout_fd, STDOUT_FILENO); + dup2(stderr_fd, STDERR_FILENO); + + fclose(log_file); + close(stdout_fd); + close(stderr_fd); + + return ret; +} + +int hikp_compress_log(void) +{ + char file_path[LOG_FILE_PATH_MAX_LEN] = {0}; + char tar_name[LOG_FILE_PATH_MAX_LEN] = {0}; + struct info_collect_cmd tar_cmd = {0}; + struct info_collect_cmd rm_cmd = {0}; + int ret; + + ret = hikp_get_save_path(file_path, LOG_FILE_PATH_MAX_LEN); + if (ret < 0) { + HIKP_ERROR_PRINT("get save path fail: %d\n", ret); + return ret; + } + + ret = snprintf((char *)tar_name, LOG_FILE_PATH_MAX_LEN, "%s.tar.gz", + file_path); + if (ret < 0 || (uint32_t)(ret) >= LOG_FILE_PATH_MAX_LEN) { + HIKP_ERROR_PRINT("create tar path fail: %d\n", ret); + return -EINVAL; + } + + tar_cmd.args[ARGS_IDX0] = "tar"; + tar_cmd.args[ARGS_IDX1] = "-zPcf"; + tar_cmd.args[ARGS_IDX2] = tar_name; + tar_cmd.args[ARGS_IDX3] = "-C"; + tar_cmd.args[ARGS_IDX4] = HIKP_COLLECT_LOG_DIR_PATH; + tar_cmd.args[ARGS_IDX5] = g_collect_name; + tar_cmd.args[ARGS_IDX6] = NULL; + + ret = hikp_collect_exec(&tar_cmd); + if (ret) + return ret; + + /* Delete the original log after the log is packaged. */ + rm_cmd.args[ARGS_IDX0] = "rm"; + rm_cmd.args[ARGS_IDX1] = "-rf"; + rm_cmd.args[ARGS_IDX2] = file_path; + rm_cmd.args[ARGS_IDX3] = NULL; + + return hikp_collect_exec(&rm_cmd); +} + +int hikp_move_files(struct info_collect_cmd *mv_cmd) +{ + char dest_path[LOG_FILE_PATH_MAX_LEN] = {0}; + char tmp_path[LOG_FILE_PATH_MAX_LEN] = {0}; + char *src_path = mv_cmd->args[ARGS_IDX1]; + char *sub_group = mv_cmd->log_name; + int ret; + + if (strcmp(mv_cmd->args[ARGS_IDX0], "mv") != 0) { + HIKP_ERROR_PRINT("input cmd failed: %s.\n", mv_cmd->args[ARGS_IDX0]); + return -EINVAL; + } + + if (src_path == NULL || access(src_path, F_OK) != 0) { + HIKP_ERROR_PRINT("Can't access source path: %s\n", src_path); + return -ENOENT; + } + + ret = hikp_get_file_path(tmp_path, LOG_FILE_PATH_MAX_LEN, mv_cmd->group); + if (ret < 0) { + HIKP_ERROR_PRINT("get destination path fail: %d\n", ret); + return ret; + } + + if (sub_group == NULL) + ret = snprintf(dest_path, LOG_FILE_PATH_MAX_LEN, "%s", tmp_path); + else + ret = snprintf(dest_path, LOG_FILE_PATH_MAX_LEN, "%s/%s", + tmp_path, sub_group); + if (ret < 0 || (uint32_t)(ret) >= LOG_FILE_PATH_MAX_LEN) { + HIKP_ERROR_PRINT("create destination path failed: %d\n", ret); + return -EINVAL; + } + + mv_cmd->args[ARGS_IDX2] = dest_path; + mv_cmd->args[ARGS_IDX3] = NULL; + + return hikp_collect_exec((void *)mv_cmd); +} + +int hikp_save_files(struct info_collect_cmd *save_cmd) +{ + char save_path[LOG_FILE_PATH_MAX_LEN] = {0}; + char tmp_path[LOG_FILE_PATH_MAX_LEN] = {0}; + char *source_path = save_cmd->args[ARGS_IDX2]; + char *sub_group = save_cmd->log_name; + int ret; + + if (strcmp(save_cmd->args[ARGS_IDX0], "cp") != 0) { + HIKP_ERROR_PRINT("input cmd failed: %s.\n", save_cmd->args[ARGS_IDX0]); + return -EINVAL; + } + + if (source_path == NULL || access(source_path, F_OK) != 0) { + HIKP_ERROR_PRINT("Can't access source path: %s\n", source_path); + return -ENOENT; + } + + ret = hikp_get_file_path(tmp_path, LOG_FILE_PATH_MAX_LEN, save_cmd->group); + if (ret < 0) { + HIKP_ERROR_PRINT("get save path fail: %d\n", ret); + return ret; + } + + if (sub_group == NULL) + ret = snprintf(save_path, LOG_FILE_PATH_MAX_LEN, "%s", tmp_path); + else + ret = snprintf(save_path, LOG_FILE_PATH_MAX_LEN, "%s/%s", + tmp_path, sub_group); + if (ret < 0 || (uint32_t)(ret) >= LOG_FILE_PATH_MAX_LEN) { + HIKP_ERROR_PRINT("create save path failed: %d\n", ret); + return -EINVAL; + } + + save_cmd->args[ARGS_IDX3] = save_path; + save_cmd->args[ARGS_IDX4] = NULL; + + return hikp_collect_exec((void *)save_cmd); +} + +int hikp_collect_cat_glob_exec(void *data) +{ + struct info_collect_cmd *cmd = (struct info_collect_cmd *)data; + glob_t glb_buff; + size_t i; + int ret; + + if (!is_cmd_valid(cmd, ARGS_IDX2)) + return -EINVAL; + + if (strcmp(cmd->args[ARGS_IDX0], "cat")) + return -EINVAL; + + ret = glob(cmd->args[ARGS_IDX1], GLOB_TILDE, NULL, &glb_buff); + if (ret) { + HIKP_ERROR_PRINT("failed to generate cat paths: %s\n", cmd->args[ARGS_IDX1]); + return ret; + } + + for (i = 0; i < glb_buff.gl_pathc; i++) { + cmd->args[ARGS_IDX1] = glb_buff.gl_pathv[i]; + ret = hikp_collect_exec((void *)cmd); + if(ret) + HIKP_INFO_PRINT("cat %s failed\n", glb_buff.gl_pathv[i]); + } + + globfree(&glb_buff); + + return 0; +} + +int hikp_collect_cp_glob_exec(void *data) +{ + struct info_collect_cmd *cmd = (struct info_collect_cmd *)data; + char log_name[MAX_LOG_NAME_LEN] = {0}; + char tmp[MAX_LOG_NAME_LEN] = {0}; + glob_t glb_buff; + size_t i; + int ret; + + if (!is_cmd_valid(cmd, ARGS_IDX3)) + return -EINVAL; + + if (strcmp(cmd->args[ARGS_IDX0], "cp")) + return -EINVAL; + + ret = glob(cmd->args[ARGS_IDX2], GLOB_TILDE, NULL, &glb_buff); + if (ret) { + HIKP_ERROR_PRINT("failed to generate cp paths: %s\n", cmd->args[ARGS_IDX2]); + return ret; + } + + ret = snprintf(tmp, MAX_LOG_NAME_LEN, "%s", cmd->log_name); + if (ret < 0 || (uint32_t)(ret) >= MAX_LOG_NAME_LEN) { + HIKP_ERROR_PRINT("log name is invalid\n"); + globfree(&glb_buff); + return -EINVAL; + } + + for (i = 0; i < glb_buff.gl_pathc; i++) { + ret = snprintf(log_name, MAX_LOG_NAME_LEN, "%s_%zu", tmp, i); + if (ret < 0 || (uint32_t)(ret) >= MAX_LOG_NAME_LEN) { + HIKP_ERROR_PRINT("create log name failed\n"); + globfree(&glb_buff); + return -EINVAL; + } + + cmd->log_name = log_name; + cmd->args[ARGS_IDX2] = glb_buff.gl_pathv[i]; + ret = hikp_save_files(cmd); + if(ret) + HIKP_INFO_PRINT("cp %s failed\n", glb_buff.gl_pathv[i]); + } + + globfree(&glb_buff); + + return 0; +} diff --git a/info_collect/hikp_collect_lib.h b/info_collect/hikp_collect_lib.h new file mode 100644 index 0000000000000000000000000000000000000000..2c59bf06d47c83490c77f4b04a47d95d81c75a68 --- /dev/null +++ b/info_collect/hikp_collect_lib.h @@ -0,0 +1,61 @@ +/* + * 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. + */ + +#ifndef HIKP_COLLECT_LIB_H +#define HIKP_COLLECT_LIB_H + +#ifndef NULL +#define NULL ((void *)0) +#endif + +#define ARGS_IDX0 0 +#define ARGS_IDX1 1 +#define ARGS_IDX2 2 +#define ARGS_IDX3 3 +#define ARGS_IDX4 4 +#define ARGS_IDX5 5 +#define ARGS_IDX6 6 +#define ARGS_IDX7 7 +#define ARGS_IDX8 8 +#define ARGS_IDX9 9 +#define ARGS_IDX10 10 +#define ARGS_IDX11 11 +#define ARGS_MAX_NUM 12 +#define LOG_FILE_PATH_MAX_LEN 512 +#define HIKP_COLLECT_LOG_DIR_PATH "/var/log/hikp/" +#define HIKP_ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0])) +#define HIKP_NIC_NAME_DIR "/sys/class/net/" +#define HIKP_NIC_DRV_DIR "device/driver/module/drivers/" +#define HIKP_NIC_DRV_NAME "pci:hns3" + +typedef int (*collect_cmd_handler_t)(void *); + +struct info_collect_cmd { + char *group; + char *log_name; + char *args[ARGS_MAX_NUM]; +}; + +int hikp_compress_log(void); +int hikp_create_save_path(const char *name); +int hikp_get_file_path(char *file_path, unsigned int file_path_len, + char *group); +int hikp_collect_exec(void *data); +int hikp_collect_log(char *group, char *log_name, + collect_cmd_handler_t func, void *data); +int hikp_move_files(struct info_collect_cmd *mv_cmd); +int hikp_save_files(struct info_collect_cmd *save_cmd); +int hikp_collect_cat_glob_exec(void *data); +int hikp_collect_cp_glob_exec(void *data); +void hikp_collect_all_nic_cmd_log(collect_cmd_handler_t hikp_collect_one_nic_log); +#endif /* HIKP_COLLECT_LIB_H */ diff --git a/info_collect/hikp_collect_main.c b/info_collect/hikp_collect_main.c new file mode 100644 index 0000000000000000000000000000000000000000..46120a55c2f94843cadacb7ee69d4ab8838d57d3 --- /dev/null +++ b/info_collect/hikp_collect_main.c @@ -0,0 +1,291 @@ +/* + * 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 "hikp_collect_lib.h" +#include "hikp_collect.h" +#include "tool_lib.h" +#include "tool_cmd.h" + +static enum info_collect_type g_info_collect_type = COLLECT_UNKNOWN_TYPE; +static enum info_collect_type get_info_collect_type(void) +{ + return g_info_collect_type; +} + +static void set_info_collect_type(enum info_collect_type type) +{ + g_info_collect_type = type; +} + +static int info_collect_acc(struct major_cmd_ctrl *self, const char *argv) +{ + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + + set_info_collect_type(COLLECT_ACC); + return 0; +} + +static int info_collect_imp(struct major_cmd_ctrl *self, const char *argv) +{ + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + + set_info_collect_type(COLLECT_IMP); + return 0; +} + +static int info_collect_nic(struct major_cmd_ctrl *self, const char *argv) +{ + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + + set_info_collect_type(COLLECT_NIC); + return 0; +} + +static int info_collect_pcie(struct major_cmd_ctrl *self, const char *argv) +{ + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + + set_info_collect_type(COLLECT_PCIE); + return 0; +} + +static int info_collect_roce(struct major_cmd_ctrl *self, const char *argv) +{ + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + + set_info_collect_type(COLLECT_ROCE); + return 0; +} + +static int info_collect_sas(struct major_cmd_ctrl *self, const char *argv) +{ + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + + set_info_collect_type(COLLECT_SAS); + return 0; +} + +static int info_collect_sata(struct major_cmd_ctrl *self, const char *argv) +{ + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + + set_info_collect_type(COLLECT_SATA); + return 0; +} + +static int info_collect_serdes(struct major_cmd_ctrl *self, const char *argv) +{ + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + + set_info_collect_type(COLLECT_SERDES); + return 0; +} + +static int info_collect_socip(struct major_cmd_ctrl *self, const char *argv) +{ + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + + set_info_collect_type(COLLECT_SOCIP); + 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); + HIKP_SET_USED(argv); + + set_info_collect_type(COLLECT_ALL); + return 0; +} + +static void collect_all_log(void) +{ + collect_pcie_info(); + collect_acc_log(); + collect_imp_log(); + collect_nic_log(); + collect_roce_log(); + collect_sas_log(); + 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", "sdma", "all"}; + int ret; + + if (collect_type == COLLECT_UNKNOWN_TYPE) + return -EINVAL; + + ret = hikp_create_save_path(type_name[collect_type]); + if (ret) { + HIKP_ERROR_PRINT("create save path fail: %d\n", ret); + return ret; + } + + switch (collect_type) { + case COLLECT_ACC: + collect_acc_log(); + break; + case COLLECT_IMP: + collect_imp_log(); + break; + case COLLECT_NIC: + collect_nic_log(); + break; + case COLLECT_PCIE: + collect_pcie_info(); + break; + case COLLECT_ROCE: + collect_roce_log(); + break; + case COLLECT_SAS: + collect_sas_log(); + break; + case COLLECT_SATA: + collect_sata_log(); + break; + case COLLECT_SERDES: + collect_serdes_log(); + break; + case COLLECT_SOCIP: + collect_socip_log(); + break; + case COLLECT_SDMA: + collect_sdma_log(); + break; + case COLLECT_ALL: + collect_all_log(); + break; + default: + return -EINVAL; + } + + collect_common_log(); + ret = hikp_compress_log(); + + return ret; +} + + +static void info_collect_execute(struct major_cmd_ctrl *self) +{ + const char *suc_msg[] = { + "collect acc info success.", + "collect imp info success.", + "collect nic info success.", + "collect pcie info success.", + "collect roce info success.", + "collect sas info success.", + "collect sata info success.", + "collect serdes info success.", + "collect socip info success.", + "collect sdma info success.", + "collect all info success.", + }; + const char *err_msg[] = { + "collect acc info error.", + "collect imp info error.", + "collect nic info error.", + "collect pcie info error.", + "collect roce info error.", + "collect sas info error.", + "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.", + }; + enum info_collect_type type; + int ret; + + type = get_info_collect_type(); + ret = info_collect_excute_funs_call(type); + set_info_collect_type(COLLECT_UNKNOWN_TYPE); + if (ret == 0) { + printf("%s\n", suc_msg[type]); + } else { + (void)snprintf(self->err_str, sizeof(self->err_str), "%s\n", err_msg[type]); + self->err_no = ret; + } +} + +static int info_collect_help(struct major_cmd_ctrl *self, const char *argv) +{ + HIKP_SET_USED(argv); + + printf("\n Usage: %s\n", self->cmd_ptr->name); + printf("\n %s\n", self->cmd_ptr->help_info); + printf("\n Options:\n\n"); + printf(" %s, %-25s %s\n", "-h", "--help", "display this help and exit\n"); + printf(" %s, %-25s %s\n", "-acc", "--acc", "collect acc info\n"); + printf(" %s, %-25s %s\n", "-imp", "--imp", "collect imp info\n"); + printf(" %s, %-25s %s\n", "-nic", "--nic", "collect nic info\n"); + printf(" %s, %-25s %s\n", "-pcie", "--pcie", "collect pcie info\n"); + printf(" %s, %-25s %s\n", "-roce", "--roce", "collect roce info\n"); + printf(" %s, %-25s %s\n", "-sas", "--sas", "collect sas info\n"); + 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"); + + return 0; +} + +static void cmd_info_collect_init(void) +{ + struct major_cmd_ctrl *major_cmd = get_major_cmd(); + + major_cmd->option_count = 0; + major_cmd->execute = info_collect_execute; + + cmd_option_register("-h", "--help", false, info_collect_help); + cmd_option_register("-acc", "--acc", false, info_collect_acc); + cmd_option_register("-imp", "--imp", false, info_collect_imp); + cmd_option_register("-nic", "--nic", false, info_collect_nic); + cmd_option_register("-pcie", "--pcie", false, info_collect_pcie); + cmd_option_register("-roce", "--roce", false, info_collect_roce); + cmd_option_register("-sas", "--sas", false, info_collect_sas); + 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); +} + +HIKP_CMD_DECLARE("info_collect", "information collect", cmd_info_collect_init); diff --git a/info_collect/hikp_collect_nic.c b/info_collect/hikp_collect_nic.c new file mode 100644 index 0000000000000000000000000000000000000000..23c4e49694893144804950b27bb44c8188fb8aee --- /dev/null +++ b/info_collect/hikp_collect_nic.c @@ -0,0 +1,368 @@ +/* + * 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 "hikp_collect_lib.h" +#include "hikp_collect.h" +#include "tool_lib.h" +#include "hikp_nic_fd.h" +#include "hikp_nic_gro.h" +#include "hikp_nic_ppp.h" +#include "hikp_nic_qos.h" +#include "hikp_nic_queue.h" +#include "hikp_nic_rss.h" +#include "hikp_nic_torus.h" +#include "hikp_nic_fec.h" +#include "hikp_nic_dfx.h" +#include "hikp_nic_info.h" +#include "hikp_nic_notify_pkt.h" +#include "hikp_nic_port_fault.h" +#include "hikp_nic_mac_dump.h" + +static void collect_nic_debugfs_log(void) +{ + struct info_collect_cmd nic_cmd_copy = { + .group = GROUP_NIC, + .log_name = "debugfs", + .args = {"cp", "-rf", "/sys/kernel/debug/hns3/", NULL}, + }; + int ret; + + ret = hikp_save_files(&nic_cmd_copy); + if (ret) + HIKP_ERROR_PRINT("collect_nic_log debugfs failed, %d\n", ret); +} + +static int collect_hikp_nic_fd_log(void *nic_name) +{ + struct major_cmd_ctrl self = {0}; + struct hikp_cmd_type type = {0}; + int ret; + + /* collect nic_fd hw_info */ + printf("hikptool nic_fd -i %s -du hw_info\n", (char *)nic_name); + hikp_nic_set_fd_idx(NIC_FD_HW_INFO_DUMP, -1); + self.cmd_ptr = &type; + ret = hikp_nic_cmd_get_fd_target(&self, (char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to set bdf for %s.\n", (char *)nic_name); + return ret; + } + hikp_nic_fd_cmd_execute(&self); + + /* collect nic_fd rules and counters */ + printf("hikptool nic_fd -i %s -du rules -st 1\n", (char *)nic_name); + hikp_nic_set_fd_idx(NIC_FD_RULES_INFO_DUMP, 1); + hikp_nic_fd_cmd_execute(&self); + printf("hikptool nic_fd -i %s -du counter -st 1\n", (char *)nic_name); + hikp_nic_set_fd_idx(NIC_FD_COUNTER_STATS_DUMP, 1); + hikp_nic_fd_cmd_execute(&self); + + return 0; +} + +static int collect_hikp_nic_gro_log(void *nic_name) +{ + struct major_cmd_ctrl self = {0}; + struct hikp_cmd_type type = {0}; + int ret; + + printf("hikptool nic_gro -i %s\n", (char *)nic_name); + self.cmd_ptr = &type; + ret = hikp_nic_gro_get_target(&self, (char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to get bdf for %s.\n", (char *)nic_name); + return ret; + } + + hikp_nic_gro_cmd_execute(&self); + return 0; +} + +static int collect_hikp_nic_ppp_log(void *nic_name) +{ + const char *sub_cmd_name[] = {"mac", "vlan", "mng", "promisc", "vlan_offload"}; + struct major_cmd_ctrl self = {0}; + struct hikp_cmd_type type = {0}; + int i, ret; + + self.cmd_ptr = &type; + ret = hikp_nic_cmd_get_ppp_target(&self, (char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to get bdf for %s.\n", (char *)nic_name); + return ret; + } + + for (i = NIC_MAC_TBL_DUMP; i <= NIC_VLAN_OFFLOAD_DUMP; ++i) { + printf("hikptool nic_ppp -i %s -du %s\n", (char *)nic_name, + sub_cmd_name[i - NIC_MAC_TBL_DUMP]); + hikp_nic_ppp_set_cmd_param(i-1); + hikp_nic_ppp_cmd_execute(&self); + } + + return 0; +} + +static int collect_hikp_nic_qos_log(void *nic_name) +{ + const char *sub_cmd_name[] = {"pkt_buf", "dcb", "pause"}; + const char *dir_name[] = {"rx", "tx"}; + struct major_cmd_ctrl self = {0}; + struct hikp_cmd_type type = {0}; + int i, ret; + + self.cmd_ptr = &type; + ret = hikp_nic_cmd_get_qos_target(&self, (char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to get bdf for %s.\n", (char *)nic_name); + return ret; + } + + for (i = NIC_PACKET_BUFFER_DUMP; i <= NIC_PAUSE_DUMP; ++i) { + printf("hikptool nic_qos -i %s -g %s\n", (char *)nic_name, sub_cmd_name[i]); + hikp_nic_qos_set_cmd_feature_idx(i); + hikp_nic_qos_cmd_execute(&self); + } + + hikp_nic_qos_set_cmd_feature_idx(NIC_PFC_STORM_PARA_DUMP); + for (i = NIC_RX_QOS; i <= NIC_TX_QOS; ++i) { + printf("hikptool nic_qos -i %s -g pfc_storm_para -d %s\n", (char *)nic_name, + dir_name[i]); + hikp_nic_qos_set_cmd_direction(i); + hikp_nic_qos_cmd_execute(&self); + } + + return 0; +} + +static int collect_hikp_nic_queue_log(void *nic_name) +{ + const char *dir_name[] = {"tx", "rx"}; + struct major_cmd_ctrl self = {0}; + struct hikp_cmd_type type = {0}; + int j, ret; + + self.cmd_ptr = &type; + ret = hikp_nic_cmd_get_queue_target(&self, (char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to get bdf for %s.\n", (char *)nic_name); + return ret; + } + + printf("hikptool nic_queue -i %s -du queue_en -a on\n", (char *)nic_name); + hikp_nic_queue_cmd_set_param(QUEUE_EN_INFO, -1, NIC_QUEUE_DIR_UNKNOWN); + hikp_nic_queue_cmd_execute(&self); + printf("hikptool nic_queue -i %s -du func_map\n", (char *)nic_name); + hikp_nic_queue_cmd_set_param(QUEUE_FUNC_MAP, -1, NIC_QUEUE_DIR_UNKNOWN); + hikp_nic_queue_cmd_execute(&self); + + for (j = NIC_TX_QUEUE; j <= NIC_RX_QUEUE; ++j) { + printf("hikptool nic_queue -i %s -du basic_info -d %s -q 0\n", (char *)nic_name, + dir_name[j]); + hikp_nic_queue_cmd_set_param(QUEUE_BASIC_INFO, 0, j); + hikp_nic_queue_cmd_execute(&self); + printf("hikptool nic_queue -i %s -du intr_map -d %s -a on\n", (char *)nic_name, + dir_name[j]); + hikp_nic_queue_cmd_set_param(QUEUE_INTR_MAP, -1, j); + hikp_nic_queue_cmd_execute(&self); + } + + return 0; +} + +static int collect_hikp_nic_rss_log(void *nic_name) +{ + const char *sub_cmd_name[] = {"algo", "key", "tuple", "reta", "tc_mode"}; + struct major_cmd_ctrl self = {0}; + struct hikp_cmd_type type = {0}; + int i, ret; + + self.cmd_ptr = &type; + ret = hikp_nic_cmd_get_rss_target(&self, (char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to get bdf for %s.\n", (char *)nic_name); + return ret; + } + + for (i = RSS_ALGO_DUMP; i <= RSS_TC_MODE_DUMP; ++i) { + printf("hikptool nic_rss -i %s -g %s\n", (char *)nic_name, sub_cmd_name[i]); + hikp_nic_rss_cmd_set_feature_idx(i); + hikp_nic_rss_cmd_execute(&self); + } + + return 0; +} + +static int collect_hikp_nic_torus_log(void *nic_name) +{ + struct major_cmd_ctrl self = {0}; + struct hikp_cmd_type type = {0}; + int ret; + + self.cmd_ptr = &type; + ret = hikp_nic_torus_get_target(&self, (char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to get bdf for %s.\n", (char *)nic_name); + return ret; + } + + printf("hikptool nic_torus -i %s\n", (char *)nic_name); + hikp_nic_torus_cmd_execute(&self); + return 0; +} + +static int collect_hikp_nic_fec_log(void *nic_name) +{ + struct major_cmd_ctrl self = {0}; + struct hikp_cmd_type type = {0}; + int ret; + + self.cmd_ptr = &type; + ret = hikp_nic_fec_get_target(&self, (char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to get bdf for %s.\n", (char *)nic_name); + return ret; + } + + printf("hikptool nic_fec -i %s\n", (char *)nic_name); + hikp_nic_fec_cmd_execute(&self); + return 0; +} + +static int collect_hikp_nic_dfx_log(void *nic_name) +{ + const char *sub_cmd_name[] = {"SSU", "IGU_EGU", "PPP", "NCSI", "BIOS", "RCB", "TXDMA", + "MASTER"}; + struct major_cmd_ctrl self = {0}; + struct hikp_cmd_type type = {0}; + int i, ret; + + self.cmd_ptr = &type; + ret = hikp_nic_cmd_dfx_target(&self, (char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to get bdf for %s.\n", (char *)nic_name); + return ret; + } + for (i = SSU_DFX_REG_DUMP; i <= MASTER_DFX_REG_DUMP; ++i) { + printf("hikptool nic_dfx -i %s -m %s\n", (char *)nic_name, sub_cmd_name[i]); + hikp_nic_dfx_set_cmd_para(i); + hikp_nic_dfx_cmd_execute(&self); + } + + return 0; +} + +static int collect_hikp_nic_info_log(void *nic_name) +{ + struct major_cmd_ctrl self = {0}; + struct hikp_cmd_type type = {0}; + int ret; + + printf("hikptool nic_info -i %s\n", (char *)nic_name); + self.cmd_ptr = &type; + ret = hikp_nic_cmd_get_info_target(&self, (char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to get bdf for %s.\n", (char *)nic_name); + return ret; + } + + hikp_nic_info_cmd_execute(&self); + return 0; +} + +static int collect_hikp_nic_notify_pkt_log(void *nic_name) +{ + struct major_cmd_ctrl self = {0}; + struct hikp_cmd_type type = {0}; + int ret; + + printf("hikptool nic_notify_pkt -i %s\n", (char *)nic_name); + self.cmd_ptr = &type; + ret = hikp_nic_notify_pkt_get_target(&self, (char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to get bdf for %s.\n", (char *)nic_name); + return ret; + } + + hikp_nic_notify_pkt_cmd_execute(&self); + return 0; +} + +static int collect_hikp_nic_port_fault_log(void *nic_name) +{ + struct major_cmd_ctrl self = {0}; + struct hikp_cmd_type type = {0}; + int ret; + + printf("hikptool nic_port_fault -i %s\n", (char *)nic_name); + self.cmd_ptr = &type; + ret = hikp_nic_port_fault_get_target(&self, (char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to get bdf for %s.\n", (char *)nic_name); + return ret; + } + + hikp_nic_port_fault_cmd_execute(&self); + return 0; +} + +static int collect_one_nic_hikp_log_compact(char *net_name, char *module, collect_cmd_handler_t hikp_pfn) +{ + char log_name[LOG_FILE_PATH_MAX_LEN] = {0}; + int ret; + + ret = snprintf(log_name, LOG_FILE_PATH_MAX_LEN, "%s_%s", net_name, module); + if (ret < 0 || (uint32_t)ret >= LOG_FILE_PATH_MAX_LEN) + return -EINVAL; + + return hikp_collect_log(GROUP_NIC, log_name, hikp_pfn, (void *)net_name); +} + +static int collect_one_nic_hikp_log(void *net_name) +{ + struct collect_nic_hikp_log_meta { + const char *module_name; + collect_cmd_handler_t hikp_pfn; + } nic_hikp_log_meta[] = { + { "nic_fd", collect_hikp_nic_fd_log }, + { "nic_gro", collect_hikp_nic_gro_log }, + { "nic_ppp", collect_hikp_nic_ppp_log }, + { "nic_qos", collect_hikp_nic_qos_log }, + { "nic_queue", collect_hikp_nic_queue_log }, + { "nic_rss", collect_hikp_nic_rss_log }, + { "nic_torus", collect_hikp_nic_torus_log }, + { "nic_fec", collect_hikp_nic_fec_log }, + { "nic_dfx", collect_hikp_nic_dfx_log }, + { "nic_info", collect_hikp_nic_info_log }, + { "nic_notify_pkt", collect_hikp_nic_notify_pkt_log }, + { "nic_port_fault", collect_hikp_nic_port_fault_log }, + }; + size_t i; + int ret; + + for (i = 0; i < HIKP_ARRAY_SIZE(nic_hikp_log_meta); ++i) { + ret = collect_one_nic_hikp_log_compact((char *)net_name, + nic_hikp_log_meta[i].module_name, + nic_hikp_log_meta[i].hikp_pfn); + if (ret) + HIKP_ERROR_PRINT("collect %s log failed: %d\n", + nic_hikp_log_meta[i].module_name, ret); + } + + return 0; +} + +void collect_nic_log(void) +{ + collect_nic_debugfs_log(); + hikp_collect_all_nic_cmd_log(collect_one_nic_hikp_log); +} diff --git a/info_collect/hikp_collect_pcie.c b/info_collect/hikp_collect_pcie.c new file mode 100644 index 0000000000000000000000000000000000000000..d3cd7ad7eb6614014d88ebdff3784c04be581ac9 --- /dev/null +++ b/info_collect/hikp_collect_pcie.c @@ -0,0 +1,215 @@ +/* + * 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 +#include +#include +#include "hikp_collect_lib.h" +#include "hikp_collect.h" +#include "tool_lib.h" +#include "hikptdev_plug.h" +#include "pcie_link_ltssm.h" +#include "pcie_statistics.h" +#include "pcie_common.h" +#include "pcie_reg_dump.h" + +#define PCIE_DEV_LEN 512 +#define PCIE_DEV_PATH "/sys/bus/pci/devices" +#define MAX_NIMBUS_NUM_ALL 8 + +/* Optimization barrier */ +#ifndef barrier +/* The "volatile" is due to gcc bugs */ +# define barrier() __asm__ __volatile__("": : :"memory") +#endif + +struct pcie_id_info { + uint32_t chip_id; + uint32_t port_id; +}; + +/* get pcie config space info */ +static void collect_pcie_common(char *pcie_dev_name) +{ + struct info_collect_cmd pcie_cmd_arr = {0}; + int ret; + + pcie_cmd_arr.group = GROUP_PCIE; + pcie_cmd_arr.log_name = pcie_dev_name; + pcie_cmd_arr.args[ARGS_IDX0] = "lspci"; + pcie_cmd_arr.args[ARGS_IDX1] = "-vvvxxxx"; + pcie_cmd_arr.args[ARGS_IDX2] = "-s"; + pcie_cmd_arr.args[ARGS_IDX3] = pcie_dev_name; + pcie_cmd_arr.args[ARGS_IDX4] = NULL; + ret = hikp_collect_log(pcie_cmd_arr.group, pcie_cmd_arr.log_name, + hikp_collect_exec, (void *)&pcie_cmd_arr); + if (ret) + HIKP_ERROR_PRINT("collect_pcie_common failed: %d\n", ret); +} + +static void collect_pcie_single_cfg(void) +{ + char dev_name[PCIE_DEV_LEN]; + struct dirent *ptr = NULL; + DIR *dir = NULL; + + if ((dir = opendir(PCIE_DEV_PATH)) == NULL) { + perror("failed to open path \n"); + return; + } + + while ((ptr = readdir(dir)) != NULL) { + if ((strcmp(ptr->d_name, ".") == 0) || (strcmp(ptr->d_name, "..") == 0)) { + continue; + } else if (ptr->d_type == DT_LNK) { + memset(dev_name, 0, sizeof(dev_name)); + strncpy(dev_name, ptr->d_name, sizeof(dev_name) - 1); + dev_name[sizeof(dev_name) - 1] = '\0'; + collect_pcie_common(dev_name); + } + } + + closedir(dir); +} + +/* get pcie config tree info */ +static void collect_pcie_cfg_tree(void) +{ + struct info_collect_cmd pcie_cmd_arr = { + .group = GROUP_PCIE, + .log_name = "pcie_tree", + .args = {"lspci", "-tv", NULL}, + }; + int ret; + + ret = hikp_collect_log(pcie_cmd_arr.group, pcie_cmd_arr.log_name, + hikp_collect_exec, (void *)&pcie_cmd_arr); + if (ret) + HIKP_ERROR_PRINT("collect_pcie_cfg_tree failed: %d\n", ret); +} + +static int pcie_mv_dumplog(void) +{ + struct info_collect_cmd pcie_cmd_arr = { 0 }; + + pcie_cmd_arr.group = GROUP_PCIE; + pcie_cmd_arr.args[ARGS_IDX0] = "mv"; + pcie_cmd_arr.args[ARGS_IDX1] = dumpreg_log_file; + + return hikp_move_files(&pcie_cmd_arr); +} + +static int collect_pcie_local_info(void *data) +{ + struct pcie_id_info *info = (struct pcie_id_info *)data; + uint32_t port_id; + + port_id = info->port_id; + printf("chip_id:%u, port_id:%u\n", info->chip_id, port_id); + /* do dump action for each port */ + /* step 1 pcie trace */ + printf("hikptool pcie_trace -i %u -s\n", port_id); + (void)pcie_ltssm_trace_show(port_id); + /* step 2 pcie link status */ + printf("hikptool pcie_trace -i %u -f\n", port_id); + (void)pcie_ltssm_link_status_get(port_id); + /* step 3 pcie err cnt */ + printf("hikptool pcie_info -i %u -es\n", port_id); + (void)pcie_error_state_get(port_id); + /* step 4 pcie pm trace */ + printf("hikptool pcie_trace -i %u -pm\n", port_id); + (void)pcie_pm_trace(port_id); + + return 0; +} + +static int pcie_port_distribution_info(void *data) +{ + uint32_t chip_id = *(uint32_t *)(data); + int ret; + + printf("hikptool pcie_info -i %u -d\n", chip_id); + ret = pcie_port_distribution_get(chip_id); + if (ret) + HIKP_ERROR_PRINT("pcie_port_distribution_get failed: %d\n", ret); + return ret; +} + +static void collect_pcie_local(void) +{ + struct pcie_info_req_para req_data = { 0 }; + char name[MAX_LOG_NAME_LEN + 1] = { 0 }; + struct pcie_port_info *port_info = NULL; + struct hikp_cmd_ret *cmd_ret = NULL; + struct hikp_cmd_header req_header; + struct pcie_id_info info; + uint32_t port_num; + uint32_t port_id; + uint32_t i, j; + int ret; + + for (i = 0; i < MAX_NIMBUS_NUM_ALL; i++) { + req_data.interface_id = i; + + memset(name, 0, MAX_LOG_NAME_LEN + 1); + (void)snprintf(name, MAX_LOG_NAME_LEN, "pcie_local_nimbus_%u", i); + + ret = hikp_collect_log(GROUP_PCIE, name, pcie_port_distribution_info, (void *)&i); + if (ret) { + HIKP_INFO_PRINT("Nimbus:%u hikp_collect_log pcie_port_distribution_info unsuccessful!\n", i); + return; + } + + hikp_cmd_init(&req_header, PCIE_MOD, PCIE_INFO, INFO_DISTRIBUTION); + cmd_ret = hikp_cmd_alloc(&req_header, &req_data, sizeof(req_data)); + ret = port_distribution_rsp_data_check(cmd_ret, &port_num); + if (ret) { + HIKP_ERROR_PRINT("port_distribution_rsp_data_check failed: %d\n", ret); + hikp_cmd_free(&cmd_ret); + return; + } + + port_info = (struct pcie_port_info *)cmd_ret->rsp_data; + for (j = 0; j < port_num; j++) { + port_id = port_info->info_pair[j].port_id; + info.chip_id = i; + info.port_id = port_info->info_pair[j].port_id; + + memset(name, 0, MAX_LOG_NAME_LEN + 1); + (void)snprintf(name, MAX_LOG_NAME_LEN, "pcie_local_port_%u", j); + + ret = hikp_collect_log(GROUP_PCIE, name, collect_pcie_local_info, (void *)&info); + if (ret) { + HIKP_ERROR_PRINT("hikp_collect_log collect_pcie_local_info failed: %d\n", ret); + hikp_cmd_free(&cmd_ret); + return; + } + /* step 1 pcie dumpreg core level */ + (void)pcie_dumpreg_do_dump(port_id, DUMP_GLOBAL_LEVEL); + (void)pcie_mv_dumplog(); + /* step 2 pcie dumpreg port level */ + (void)pcie_dumpreg_do_dump(port_id, DUMP_PORT_LEVEL); + (void)pcie_mv_dumplog(); + } + hikp_cmd_free(&cmd_ret); + } +} + +void collect_pcie_info(void) +{ + collect_pcie_cfg_tree(); + + collect_pcie_single_cfg(); + + collect_pcie_local(); +} diff --git a/info_collect/hikp_collect_roce.c b/info_collect/hikp_collect_roce.c new file mode 100644 index 0000000000000000000000000000000000000000..fffceb1c5dd58377c367236d932012d1506c6da0 --- /dev/null +++ b/info_collect/hikp_collect_roce.c @@ -0,0 +1,488 @@ +/* + * 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 "hikp_collect_lib.h" +#include "hikp_collect.h" +#include "tool_lib.h" +#include "hikp_roce_bond.h" +#include "hikp_roce_global_cfg.h" +#include "hikp_roce_rst.h" +#include "hikp_roce_timer.h" +#include "hikp_roce_pkt.h" +#include "hikp_roce_mdb.h" +#include "hikp_roce_caep.h" +#include "hikp_roce_qmm.h" +#include "hikp_roce_trp.h" +#include "hikp_roce_tsp.h" +#include "hikp_roce_scc.h" +#include "hikp_roce_gmv.h" + +static void collect_roce_devinfo_log(void) +{ + const struct info_collect_cmd roce_devinfo_cmd = { + .group = GROUP_ROCE, + .log_name = "ibv_devinfo", + .args = {"ibv_devinfo", NULL}, + }; + int ret; + + ret = hikp_collect_log(roce_devinfo_cmd.group, + roce_devinfo_cmd.log_name, + hikp_collect_exec, + (void *)&roce_devinfo_cmd); + if (ret) + HIKP_ERROR_PRINT("collect %s log failed: %d\n", + roce_devinfo_cmd.log_name, ret); +} + +static void collect_roce_cc_param_log(void) +{ + struct info_collect_cmd roce_cc_param_cmd = { + .group = GROUP_ROCE, + .log_name = "cc_param", + .args = {"cp", "-rf", + "/sys/class/infiniband/*/ports/1/cc_param", NULL}, + }; + int ret; + + ret = hikp_collect_log(roce_cc_param_cmd.group, + roce_cc_param_cmd.log_name, + hikp_collect_cp_glob_exec, + (void *)&roce_cc_param_cmd); + if (ret) + HIKP_ERROR_PRINT("collect %s log failed: %d\n", + roce_cc_param_cmd.log_name, ret); +} + +static void collect_roce_sw_stats_log(void) +{ + struct info_collect_cmd roce_sw_stats_cmd = { + .group = GROUP_ROCE, + .log_name = "sw_stat", + .args = {"cat", "/sys/kernel/debug/hns_roce/*/sw_stat/sw_stat", + NULL}, + }; + int ret; + + ret = hikp_collect_log(roce_sw_stats_cmd.group, + roce_sw_stats_cmd.log_name, + hikp_collect_cat_glob_exec, + (void *)&roce_sw_stats_cmd); + if (ret) + HIKP_ERROR_PRINT("collect %s log failed: %d\n", + roce_sw_stats_cmd.log_name, ret); +} + +static void collect_roce_res_stats_log(void) +{ + const struct info_collect_cmd roce_res_stats_cmd = { + .group = GROUP_ROCE, + .log_name = "rdma_res_show", + .args = {"rdma", "res", "show", NULL}, + }; + int ret; + + ret = hikp_collect_log(roce_res_stats_cmd.group, + roce_res_stats_cmd.log_name, + hikp_collect_exec, + (void *)&roce_res_stats_cmd); + if (ret) + HIKP_ERROR_PRINT("collect %s log failed: %d\n", + roce_res_stats_cmd.log_name, ret); +} + +static int collect_hikp_roce_gmv_log(void *nic_name) +{ + struct major_cmd_ctrl self = {0}; + struct hikp_cmd_type type = {0}; + uint32_t gmv_index; + int ret; + + self.cmd_ptr = &type; + ret = hikp_roce_set_gmv_bdf((char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to set roce_gmv bdf for %s.\n", + (char *)nic_name); + return ret; + } + + for (gmv_index = 0; gmv_index < ROCE_MAX_HIKPTOOL_GMV; gmv_index++) { + printf("hikptool roce_gmv -i %s -x %u\n", (char *)nic_name, gmv_index); + hikp_roce_set_gmv_index(gmv_index); + hikp_roce_gmv_execute(&self); + } + + return 0; +} + +static int collect_hikp_roce_scc_log(void *nic_name) +{ + struct major_cmd_ctrl self = {0}; + struct hikp_cmd_type type = {0}; + int ret; + + self.cmd_ptr = &type; + ret = hikp_roce_set_scc_bdf((char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to set roce_scc bdf for %s.\n", + (char *)nic_name); + return ret; + } + + printf("hikptool roce_scc -i %s -m COMMON\n", (char *)nic_name); + hikp_roce_set_scc_submodule(SCC_COMMON); + hikp_roce_scc_execute(&self); + + printf("hikptool roce_scc -i %s -m DCQCN\n", (char *)nic_name); + hikp_roce_set_scc_submodule(DCQCN); + hikp_roce_scc_execute(&self); + + printf("hikptool roce_scc -i %s -m DIP\n", (char *)nic_name); + hikp_roce_set_scc_submodule(DIP); + hikp_roce_scc_execute(&self); + + printf("hikptool roce_scc -i %s -m HC3\n", (char *)nic_name); + hikp_roce_set_scc_submodule(HC3); + hikp_roce_scc_execute(&self); + + printf("hikptool roce_scc -i %s -m LDCP\n", (char *)nic_name); + hikp_roce_set_scc_submodule(LDCP); + hikp_roce_scc_execute(&self); + + printf("hikptool roce_scc -i %s -m CFG\n", (char *)nic_name); + hikp_roce_set_scc_submodule(CFG); + hikp_roce_scc_execute(&self); + + return 0; +} + +static int collect_hikp_roce_tsp_log(void *nic_name) +{ + struct major_cmd_ctrl self = {0}; + struct hikp_cmd_type type = {0}; + uint32_t bankid; + int ret; + + self.cmd_ptr = &type; + ret = hikp_roce_set_tsp_bdf((char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to set roce_tsp bdf for %s.\n", + (char *)nic_name); + return ret; + } + + hikp_roce_set_tsp_submodule(TSP_COMMON); + for (bankid = 0; bankid <= MAX_TSP_BANK_NUM; bankid++) { + hikp_roce_set_tsp_bankid(bankid); + + printf("hikptool roce_tsp -i %s -m COMMON -b %u\n", (char *)nic_name, bankid); + hikp_roce_tsp_execute(&self); + } + + hikp_roce_set_tsp_submodule(TGP_TMP); + for (bankid = 0; bankid <= MAX_TGP_TMP_BANK_NUM; bankid++) { + hikp_roce_set_tsp_bankid(bankid); + + printf("hikptool roce_tsp -i %s -m TGP_TMP -b %u\n", (char *)nic_name, bankid); + hikp_roce_tsp_execute(&self); + } + + printf("hikptool roce_tsp -i %s -m TDP\n", (char *)nic_name); + hikp_roce_set_tsp_submodule(TDP); + hikp_roce_tsp_execute(&self); + + return 0; +} + +static int collect_hikp_roce_trp_log(void *nic_name) +{ + struct major_cmd_ctrl self = {0}; + struct hikp_cmd_type type = {0}; + uint32_t bankid; + int ret; + + self.cmd_ptr = &type; + ret = hikp_roce_set_trp_bdf((char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to set roce_trp bdf for %s.\n", + (char *)nic_name); + return ret; + } + + hikp_roce_set_trp_submodule(TRP_COMMON); + for (bankid = 0; bankid <= TRP_MAX_BANK_NUM; bankid++) { + hikp_roce_set_trp_bankid(bankid); + + printf("hikptool roce_trp -i %s -m COMMON -b %u\n", (char *)nic_name, bankid); + hikp_roce_trp_execute(&self); + } + + printf("hikptool roce_trp -i %s -m TRP_RX\n", (char *)nic_name); + hikp_roce_set_trp_submodule(TRP_RX); + hikp_roce_trp_execute(&self); + + hikp_roce_set_trp_submodule(GEN_AC); + for (bankid = 0; bankid <= GAC_MAX_BANK_NUM; bankid++) { + hikp_roce_set_trp_bankid(bankid); + + printf("hikptool roce_trp -i %s -m GEN_AC -b %u\n", (char *)nic_name, bankid); + hikp_roce_trp_execute(&self); + } + + hikp_roce_set_trp_submodule(PAYL); + for (bankid = 0; bankid <= PAYL_MAX_BANK_NUM; bankid++) { + hikp_roce_set_trp_bankid(bankid); + + printf("hikptool roce_trp -i %s -m PAYL -b %u\n", (char *)nic_name, bankid); + hikp_roce_trp_execute(&self); + } + + return 0; +} + +static int collect_hikp_roce_qmm_log(void *nic_name) +{ + struct major_cmd_ctrl self = {0}; + struct hikp_cmd_type type = {0}; + uint32_t bankid; + int ret; + + self.cmd_ptr = &type; + ret = hikp_roce_set_qmm_bdf((char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to set roce_qmm bdf for %s.\n", + (char *)nic_name); + return ret; + } + + for (bankid = 0; bankid <= QMM_BANK_NUM; bankid++) { + hikp_roce_set_qmm_bankid(bankid); + + printf("hikptool roce_qmm -i %s -b %u\n", (char *)nic_name, bankid); + hikp_roce_set_qmm_ext_flag(false); + hikp_roce_qmm_execute(&self); + + printf("hikptool roce_qmm -i %s -b %u -e\n", (char *)nic_name, bankid); + hikp_roce_set_qmm_ext_flag(true); + hikp_roce_qmm_execute(&self); + } + + return 0; +} + +static int collect_hikp_roce_caep_log(void *nic_name) +{ + struct major_cmd_ctrl self = {0}; + struct hikp_cmd_type type = {0}; + int ret; + + self.cmd_ptr = &type; + ret = hikp_roce_set_caep_bdf((char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to set roce_caep bdf for %s.\n", + (char *)nic_name); + return ret; + } + + printf("hikptool roce_caep -i %s\n", (char *)nic_name); + hikp_roce_set_caep_mode(CAEP_ORIGIN); + hikp_roce_caep_execute(&self); + + printf("hikptool roce_caep -i %s -e\n", (char *)nic_name); + hikp_roce_set_caep_mode(CAEP_EXT); + hikp_roce_caep_execute(&self); + + return 0; +} + +static int collect_hikp_roce_mdb_log(void *nic_name) +{ + struct major_cmd_ctrl self = {0}; + struct hikp_cmd_type type = {0}; + int ret; + + self.cmd_ptr = &type; + ret = hikp_roce_set_mdb_bdf((char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to set roce_mdb bdf for %s.\n", + (char *)nic_name); + return ret; + } + + printf("hikptool roce_mdb -i %s\n", (char *)nic_name); + hikp_roce_set_mdb_mode(ROCE_MDB_CMD); + hikp_roce_mdb_execute(&self); + + printf("hikptool roce_mdb -i %s -e\n", (char *)nic_name); + hikp_roce_set_mdb_mode(ROCE_MDB_CMD_EXT); + hikp_roce_mdb_execute(&self); + + return 0; +} + +static int collect_hikp_roce_pkt_log(void *nic_name) +{ + struct major_cmd_ctrl self = {0}; + struct hikp_cmd_type type = {0}; + int ret; + + self.cmd_ptr = &type; + ret = hikp_roce_set_pkt_bdf((char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to set roce_pkt bdf for %s.\n", + (char *)nic_name); + return ret; + } + + printf("hikptool roce_pkt -i %s\n", (char *)nic_name); + hikp_roce_pkt_execute(&self); + + return 0; +} + +static int collect_hikp_roce_timer_log(void *nic_name) +{ + struct major_cmd_ctrl self = {0}; + struct hikp_cmd_type type = {0}; + int ret; + + self.cmd_ptr = &type; + ret = hikp_roce_set_timer_bdf((char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to set roce_timer bdf for %s.\n", + (char *)nic_name); + return ret; + } + + printf("hikptool roce_timer -i %s\n", (char *)nic_name); + hikp_roce_timer_execute(&self); + + return 0; +} + +static int collect_hikp_roce_rst_log(void *nic_name) +{ + struct major_cmd_ctrl self = {0}; + struct hikp_cmd_type type = {0}; + int ret; + + self.cmd_ptr = &type; + ret = hikp_roce_set_rst_bdf((char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to set roce_rst bdf for %s.\n", + (char *)nic_name); + return ret; + } + + printf("hikptool roce_rst -i %s\n", (char *)nic_name); + hikp_roce_rst_execute(&self); + + return 0; +} + +static int collect_hikp_roce_global_cfg_log(void *nic_name) +{ + struct major_cmd_ctrl self = {0}; + struct hikp_cmd_type type = {0}; + int ret; + + self.cmd_ptr = &type; + ret = hikp_roce_set_global_cfg_bdf((char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to set roce global_cfg bdf for %s.\n", + (char *)nic_name); + return ret; + } + + printf("hikptool roce_global_cfg -i %s\n", (char *)nic_name); + hikp_roce_global_cfg_execute(&self); + + return 0; +} + +static int collect_hikp_roce_bond_log(void *nic_name) +{ + struct major_cmd_ctrl self = {0}; + struct hikp_cmd_type type = {0}; + int ret; + + self.cmd_ptr = &type; + ret = hikp_roce_set_bond_bdf((char *)nic_name); + if (ret) { + HIKP_ERROR_PRINT("failed to set roce bond bdf for %s.\n", + (char *)nic_name); + return ret; + } + + printf("hikptool roce_bond -i %s\n", (char *)nic_name); + hikp_roce_bond_execute(&self); + + return 0; +} + +static void collect_one_roce_hikp_log_compact(char *net_name, char *module, + collect_cmd_handler_t hikp_pfn) +{ + char log_name[LOG_FILE_PATH_MAX_LEN] = {0}; + int ret; + + ret = snprintf(log_name, LOG_FILE_PATH_MAX_LEN, "%s_%s", net_name, + module); + if (ret < 0 || (uint32_t)ret >= LOG_FILE_PATH_MAX_LEN) { + HIKP_ERROR_PRINT("failed to set %s path %d\n", net_name, ret); + return; + } + + ret = hikp_collect_log(GROUP_ROCE, log_name, hikp_pfn, (void *)net_name); + if (ret) + HIKP_ERROR_PRINT("failed to get %s info %d\n", net_name, ret); +} + +static int collect_one_roce_hikp_log(void *net_name) +{ + struct collect_roce_hikp_log_meta { + const char *module_name; + collect_cmd_handler_t hikp_pfn; + } roce_hikp_log_meta[] = { + { "roce_bond", collect_hikp_roce_bond_log }, + { "roce_global_cfg", collect_hikp_roce_global_cfg_log }, + { "roce_rst", collect_hikp_roce_rst_log }, + { "roce_timer", collect_hikp_roce_timer_log }, + { "roce_pkt", collect_hikp_roce_pkt_log }, + { "roce_mdb", collect_hikp_roce_mdb_log }, + { "roce_caep", collect_hikp_roce_caep_log }, + { "roce_qmm", collect_hikp_roce_qmm_log }, + { "roce_trp", collect_hikp_roce_trp_log }, + { "roce_tsp", collect_hikp_roce_tsp_log }, + { "roce_scc", collect_hikp_roce_scc_log }, + { "roce_gmv", collect_hikp_roce_gmv_log }, + }; + size_t i; + + for (i = 0; i < HIKP_ARRAY_SIZE(roce_hikp_log_meta); ++i) { + collect_one_roce_hikp_log_compact((char *)net_name, + roce_hikp_log_meta[i].module_name, + roce_hikp_log_meta[i].hikp_pfn); + } + + return 0; +} + +void collect_roce_log(void) +{ + collect_roce_devinfo_log(); + collect_roce_cc_param_log(); + collect_roce_sw_stats_log(); + collect_roce_res_stats_log(); + hikp_collect_all_nic_cmd_log(collect_one_roce_hikp_log); +} diff --git a/info_collect/hikp_collect_sas.c b/info_collect/hikp_collect_sas.c new file mode 100644 index 0000000000000000000000000000000000000000..11022dccbd74bc0295dc0e96597a6d627bb8500c --- /dev/null +++ b/info_collect/hikp_collect_sas.c @@ -0,0 +1,453 @@ +/* + * 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 "hikp_collect_lib.h" +#include "hikp_collect.h" +#include "tool_lib.h" +#include "sas_tools_include.h" +#include "sas_common.h" +#include "sas_analy_queue.h" +#include "sas_dump_reg.h" +#include "sas_read_dev.h" +#include "sas_read_errcode.h" +#include "sata_dump_reg.h" + +#define CHIP_MAX_SIZE 10 +#define DIE_MAX_SIZE 10 + +typedef int (*reg_info_func_t)(uint32_t, uint32_t); + +enum sata_dump_type { + SATA_DUMP_UNKNOWN = 0, + SATA_DUMP_GLOBAL, + SATA_DUMP_PORTX, +}; + +struct reg_op { + char *func_name; + reg_info_func_t func; +}; + +static int sas_sata_reg_log(void *data) +{ + struct reg_op *op = (struct reg_op *)data; + bool stop_flag = false; + uint32_t i, j; + int ret; + + for (i = 0; i < CHIP_MAX_SIZE; i++) { + for (j = 0; j < DIE_MAX_SIZE; j++) { + ret = op->func(i, j); + if (ret) { + HIKP_ERROR_PRINT("%s chip%u die%u failed: %d\n", op->func_name, + i, j, ret); + /* + * Stop collection when the die id is 0, indicating that the + * current chip id is not supported. + * */ + if (j == 0) + stop_flag = true; + + break; + } + } + + if (stop_flag) + break; + } + + return 0; +} + +static void collect_sas_path_log(char *group) +{ + struct info_collect_cmd sas_path_cmd = { + .log_name = "ls_by-path", + .args = {"ls", "-l", "/dev/disk/by-path/", NULL}, + }; + int ret; + + ret = hikp_collect_log(group, sas_path_cmd.log_name, + hikp_collect_exec, (void *)&sas_path_cmd); + if (ret) + HIKP_ERROR_PRINT("collect %s log failed: %d\n", sas_path_cmd.log_name, ret); +} + +static void collect_sas_phy_log(void) +{ + struct info_collect_cmd sas_phy_cmds[] = { + { + .log_name = "phy-invalid_dword_count", + .args = {"cat", "/sys/class/sas_phy/*/invalid_dword_count", NULL}, + }, + { + .log_name = "phy-negotiated_linkrate", + .args = {"cat", "/sys/class/sas_phy/*/negotiated_linkrate", NULL}, + }, + { + .log_name = "phy-enable", + .args = {"cat", "/sys/class/sas_phy/*/enable", NULL}, + }, + }; + size_t i, size; + int ret; + + size = HIKP_ARRAY_SIZE(sas_phy_cmds); + for (i = 0; i < size; i++) { + ret = hikp_collect_log(GROUP_SAS, sas_phy_cmds[i].log_name, + hikp_collect_cat_glob_exec, (void *)&sas_phy_cmds[i]); + if (ret) + HIKP_ERROR_PRINT("collect %s log failed: %d\n", + sas_phy_cmds[i].log_name, ret); + } +} + +static void collect_sas_host_log(void) +{ + struct info_collect_cmd sas_host_cmds[] = { + { + .log_name = "host-nr_hw_queues", + .args = {"cat", "/sys/class/scsi_host/host*/nr_hw_queues", NULL}, + }, + { + .log_name = "host-intr", + .args = {"cat", "/sys/class/scsi_host/host*/intr*", NULL}, + }, + }; + size_t i, size; + int ret; + + size = HIKP_ARRAY_SIZE(sas_host_cmds); + for (i = 0; i < size; i++) { + ret = hikp_collect_log(GROUP_SAS, sas_host_cmds[i].log_name, + hikp_collect_cat_glob_exec, (void *)&sas_host_cmds[i]); + if (ret) + HIKP_ERROR_PRINT("collect %s log failed: %d\n", + sas_host_cmds[i].log_name, ret); + } +} + +static void collect_sas_disk_log(void) +{ + struct info_collect_cmd sas_disk_cmds[] = { + { + .log_name = "disk-scheduler", + .args = {"cat", "/sys/block/sd*/queue/scheduler", NULL}, + }, + { + .log_name = "disk-max", + .args = {"cat", "/sys/block/sd*/queue/max*", NULL}, + }, + { + .log_name = "disk-state", + .args = {"cat", "/sys/block/sd*/device/state", NULL}, + }, + }; + size_t i, size; + int ret; + + size = HIKP_ARRAY_SIZE(sas_disk_cmds); + for (i = 0; i < size; i++) { + ret = hikp_collect_log(GROUP_SAS, sas_disk_cmds[i].log_name, + hikp_collect_cat_glob_exec, (void *)&sas_disk_cmds[i]); + if (ret) + HIKP_ERROR_PRINT("collect %s log failed: %d\n", + sas_disk_cmds[i].log_name, ret); + } +} + +static int collect_sas_lsscsi_log_exec(void *data) +{ + const struct info_collect_cmd sas_lsscsi_cmds[] = { + { + .args = {"lsscsi", "-lg", NULL}, + }, + { + .args = {"lsscsi", "-pvt", NULL}, + }, + { + .args = {"lsscsi", "-H", NULL}, + }, + }; + size_t i, size; + (void)data; + int ret; + + size = HIKP_ARRAY_SIZE(sas_lsscsi_cmds); + for (i = 0; i < size; i++) { + ret = hikp_collect_exec((void *)&sas_lsscsi_cmds[i]); + if (ret) + return ret; + } + + return 0; +} + +static void collect_sas_lsscsi_log(char *group) +{ + int ret; + + ret = hikp_collect_log(group, "lsscsi", collect_sas_lsscsi_log_exec, (void *)NULL); + if (ret) + HIKP_ERROR_PRINT("collect lsscsi log failed: %d\n", ret); +} + +static void collect_sas_copy_files(void) +{ + struct info_collect_cmd sas_copy_cmds[] = { + { + .group = GROUP_SAS, + .log_name = "debugfs", + .args = {"cp", "-rf", "/sys/kernel/debug/hisi_sas/", NULL}, + }, + { + .group = GROUP_SAS, + .log_name = "parameters_hw", + .args = {"cp", "-rf", "/sys/module/hisi_sas_v3_hw/parameters/", NULL}, + }, + { + .group = GROUP_SAS, + .log_name = "parameters_main", + .args = {"cp", "-rf", "/sys/module/hisi_sas_main/parameters/", NULL}, + }, + }; + size_t i, size; + int ret; + + size = HIKP_ARRAY_SIZE(sas_copy_cmds); + for (i = 0; i < size; i++) { + ret = hikp_save_files(&sas_copy_cmds[i]); + if (ret) + HIKP_ERROR_PRINT("cp %s failed: %d\n", + sas_copy_cmds[i].args[ARGS_IDX2], ret); + } +} + +static int sas_anacq_info(uint32_t chip_id, uint32_t die_id) +{ + struct tool_sas_cmd cmd = { + .chip_id = chip_id, + .die_id = die_id, + }; + int ret; + + printf("hikptool sas_anacq -c %u -d %u -s\n", cmd.chip_id, cmd.die_id); + cmd.sas_cmd_type = ANACQ_NUM; + ret = sas_analy_cmd(&cmd); + if (ret) { + HIKP_ERROR_PRINT("collect cq number failed: %d\n", ret); + return ret; + } + + printf("hikptool sas_anacq -c %u -d %u -p\n", cmd.chip_id, cmd.die_id); + cmd.sas_cmd_type = ANACQ_PRT; + ret = sas_analy_cmd(&cmd); + if (ret) + HIKP_ERROR_PRINT("collect cq read/write pointer failed: %d\n", ret); + + return ret; +} + +static int sas_anadq_info(uint32_t chip_id, uint32_t die_id) +{ + struct tool_sas_cmd cmd = { + .chip_id = chip_id, + .die_id = die_id, + }; + int ret; + + printf("hikptool sas_anadq -c %u -d %u -s\n", cmd.chip_id, cmd.die_id); + cmd.sas_cmd_type = ANADQ_NUM; + ret = sas_analy_cmd(&cmd); + if (ret) { + HIKP_ERROR_PRINT("collect dq num failed: %d\n", ret); + return ret; + } + + printf("hikptool sas_anadq -c %u -d %u -p\n", cmd.chip_id, cmd.die_id); + cmd.sas_cmd_type = ANADQ_PRT; + ret = sas_analy_cmd(&cmd); + if (ret) + HIKP_ERROR_PRINT("collect dq read/write pointer failed: %d\n", ret); + + return ret; +} + +static int sas_dump_info(uint32_t chip_id, uint32_t die_id) +{ + struct tool_sas_cmd cmd = { + .chip_id = chip_id, + .die_id = die_id, + }; + uint32_t i; + int ret; + + printf("hikptool sas_dump -c %u -d %u -g\n", cmd.chip_id, cmd.die_id); + cmd.sas_cmd_type = DUMP_GLOBAL; + ret = sas_reg_dump(&cmd); + if (ret) { + HIKP_ERROR_PRINT("dump global failed: %d\n", ret); + return ret; + } + + for (i = 0; i <= SAS_MAX_PHY_NUM; i++) { + printf("hikptool sas_dump -c %u -d %u -p %u\n", cmd.chip_id, cmd.die_id, i); + cmd.sas_cmd_type = DUMP_PHYX; + cmd.phy_id = i; + ret = sas_reg_dump(&cmd); + if (ret) { + HIKP_ERROR_PRINT("dump phy %u failed: %d\n", i, ret); + return ret; + } + } + + printf("hikptool sas_dump -c %u -d %u -b\n", cmd.chip_id, cmd.die_id); + cmd.sas_cmd_type = DUMP_AXI; + ret = sas_reg_dump(&cmd); + if (ret) + HIKP_ERROR_PRINT("dump axi failed: %d\n", ret); + + return ret; +} + +static int sas_dev_info(uint32_t chip_id, uint32_t die_id) +{ + struct tool_sas_cmd cmd = { + .chip_id = chip_id, + .die_id = die_id, + }; + + printf("hikptool sas_dev -c %u -d %u -l\n", cmd.chip_id, cmd.die_id); + cmd.sas_cmd_type = DEV_LINK; + return sas_dev(&cmd); +} + +static int sas_errcode_info(uint32_t chip_id, uint32_t die_id) +{ + struct tool_sas_cmd cmd = { + .chip_id = chip_id, + .die_id = die_id, + }; + uint32_t i; + int ret; + + for (i = 0; i < SAS_MAX_ERR_NUM; i++) { + printf("hikptool sas_errcode -c %u -d %u -t %u\n", cmd.chip_id, cmd.die_id, i); + cmd.sas_cmd_type = i; + ret = sas_errcode_read(&cmd); + if (ret) { + HIKP_ERROR_PRINT("collect errcode %u info failed: %d\n", i, ret); + return ret; + } + } + + return 0; +} + +static void collect_sas_reg_log(void) +{ + struct reg_op op = {0}; + int ret; + + op.func = sas_anacq_info; + op.func_name = "sas_anacq_info"; + ret = hikp_collect_log(GROUP_SAS, "sas_anacq", sas_sata_reg_log, (void *)&op); + if (ret) + HIKP_INFO_PRINT("%s failed: %d\n", op.func_name, ret); + + op.func = sas_anadq_info; + op.func_name = "sas_anadq_info"; + ret = hikp_collect_log(GROUP_SAS, "sas_anadq", sas_sata_reg_log, (void *)&op); + if (ret) + HIKP_INFO_PRINT("%s failed: %d\n", op.func_name, ret); + + op.func = sas_dump_info; + op.func_name = "sas_dump_info"; + ret = hikp_collect_log(GROUP_SAS, "sas_dump", sas_sata_reg_log, (void *)&op); + if (ret) + HIKP_INFO_PRINT("%s failed: %d\n", op.func_name, ret); + + op.func = sas_dev_info; + op.func_name = "sas_dev_info"; + ret = hikp_collect_log(GROUP_SAS, "sas_dev", sas_sata_reg_log, (void *)&op); + if (ret) + HIKP_INFO_PRINT("%s failed: %d\n", op.func_name, ret); + + op.func = sas_errcode_info; + op.func_name = "sas_errcode_info"; + ret = hikp_collect_log(GROUP_SAS, "sas_errcode", sas_sata_reg_log, (void *)&op); + if (ret) + HIKP_INFO_PRINT("%s failed: %d\n", op.func_name, ret); +} + +void collect_sas_log(void) +{ + collect_sas_phy_log(); + collect_sas_host_log(); + collect_sas_disk_log(); + collect_sas_copy_files(); + collect_sas_path_log(GROUP_SAS); + collect_sas_lsscsi_log(GROUP_SAS); + collect_sas_reg_log(); +} + +static int sata_reg_dump_info(uint32_t chip_id, uint32_t die_id) +{ + struct tool_sata_cmd cmd = { + .chip_id = chip_id, + .die_id = die_id, + }; + uint32_t i; + int ret; + + printf("hikptool sata_dump -c %u -d %u -g\n", cmd.chip_id, cmd.die_id); + cmd.sata_cmd_type = SATA_DUMP_GLOBAL; + ret = sata_reg_dump(&cmd); + if (ret) { + HIKP_ERROR_PRINT("dump global failed: %d\n", ret); + return ret; + } + + cmd.sata_cmd_type = SATA_DUMP_PORTX; + for (i = 0; i <= 1; i++) { + printf("hikptool sata_dump -c %u -d %u -p %u\n", cmd.chip_id, cmd.die_id, i); + cmd.phy_id = i; + ret = sata_reg_dump(&cmd); + if (ret) { + HIKP_INFO_PRINT("dump port%u reg failed: %d\n", i, ret); + return ret; + } + } + + return 0; +} + +static void collect_sata_reg_log(void) +{ + struct reg_op op = { + .func = sata_reg_dump_info, + .func_name = "sata_reg_dump_info", + }; + int ret; + + ret = hikp_collect_log(GROUP_SATA, "reg_dump", sas_sata_reg_log, (void *)&op); + if (ret) + HIKP_INFO_PRINT("%s failed: %d\n", op.func_name, ret); +} + +void collect_sata_log(void) +{ + collect_sas_path_log(GROUP_SATA); + collect_sas_lsscsi_log(GROUP_SATA); + collect_sata_reg_log(); +} diff --git a/info_collect/hikp_collect_sdma.c b/info_collect/hikp_collect_sdma.c new file mode 100644 index 0000000000000000000000000000000000000000..8dc315cd5e6104c5ad478e0c9f7c1e87f9841423 --- /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 +#include +#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(); +} diff --git a/info_collect/hikp_collect_serdes.c b/info_collect/hikp_collect_serdes.c new file mode 100644 index 0000000000000000000000000000000000000000..31f29b341c37707ffe75c1bc7399b546675e69d1 --- /dev/null +++ b/info_collect/hikp_collect_serdes.c @@ -0,0 +1,244 @@ +/* + * 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 "hikp_collect_lib.h" +#include "hikp_collect.h" +#include "tool_lib.h" +#include "hikp_serdes.h" + +#define MAX_CHIP_NUM_SUPPORT 8 +#define HIP10_DIE_NUM 2 +#define HIP11_DIE_NUM 4 +#define HIP10_DIE_MACRO_NUM 7 +#define HIP11_DIE_MACRO_NUM 4 + +struct serdes_macro_info { + uint8_t macro_id; + uint8_t ds_num; +}; + +struct serdes_log_cmd { + struct cmd_serdes_param *cmd; + unsigned char die_id; +}; + +struct serdes_macro_info g_hip10[] = { + {0, 4}, /* 0, 4: macro_id, ds_num */ + {1, 4}, /* 1, 4: macro_id, ds_num */ + {2, 8}, /* 2, 8: macro_id, ds_num */ + {3, 8}, /* 3, 8: macro_id, ds_num */ + {4, 8}, /* 4, 8: macro_id, ds_num */ + {5, 8}, /* 5, 8: macro_id, ds_num */ + {6, 8}, /* 6, 8: macro_id, ds_num */ +}; + +struct serdes_macro_info g_hip11[] = { + {0, 4}, /* 0, 4: macro_id, ds_num */ + {1, 8}, /* 1, 8: macro_id, ds_num */ + {2, 4}, /* 2, 4: macro_id, ds_num */ + {3, 4}, /* 3, 4: macro_id, ds_num */ +}; + +static int is_chip_hip11(void) +{ + return get_chip_type() == CHIP_HIP11; +} + +static unsigned char serdes_get_die_num(void) +{ + return is_chip_hip11() ? HIP11_DIE_NUM : HIP10_DIE_NUM; +} + +static unsigned char serdes_get_die_macro_num(void) +{ + return is_chip_hip11() ? HIP11_DIE_MACRO_NUM : HIP10_DIE_MACRO_NUM; +} + +static struct serdes_macro_info *serdes_get_macro_info(void) +{ + return is_chip_hip11() ? g_hip11 : g_hip10; +} + +static int collect_serdes_info_process(void *data) +{ + struct serdes_log_cmd *log_cmd = (struct serdes_log_cmd *)data; + struct serdes_macro_info *macro_info = serdes_get_macro_info(); + unsigned char die_macro_num = serdes_get_die_macro_num(); + struct cmd_serdes_param *cmd = log_cmd->cmd; + const char *info_cmd_str[] = {"", "-k"}; + unsigned char die_id = log_cmd->die_id; + /* 0, 1: brief info, detail info */ + unsigned char subcmd_list[] = {0, 1}; + unsigned char k, p; + int ret; + + for (k = 0; k < die_macro_num; k++) { + cmd->macro_id = die_id * die_macro_num + k; + cmd->start_sds_id = 0; + cmd->sds_num = macro_info[k].ds_num; + for (p = 0; p < sizeof(subcmd_list) / sizeof(subcmd_list[0]); p++) { + cmd->sub_cmd = subcmd_list[p]; + printf("hikptool serdes_info -i %u -s m%ud%u -n %u %s\n", + cmd->chip_id, cmd->macro_id, cmd->start_sds_id, + cmd->sds_num, info_cmd_str[cmd->sub_cmd]); + ret = hikp_serdes_get_reponse(cmd); + if (ret) { + HIKP_ERROR_PRINT("collect chip%u die%u macro%u " + "serdes_info%u failed: %d\n", + cmd->chip_id, die_id, k, subcmd_list[p], ret); + + if (ret == -EINVAL) + return ret; + } + } + } + + return 0; +} + +static void collect_serdes_info_log(void) +{ + struct cmd_serdes_param serdes_info_cmd = {0}; + unsigned char chip_num = MAX_CHIP_NUM_SUPPORT; + unsigned char die_num = serdes_get_die_num(); + char log_name[MAX_LOG_NAME_LEN] = {0}; + struct serdes_log_cmd log_cmd = {0}; + bool stop = false; + unsigned char i, j; + int ret; + + serdes_info_cmd.cmd_type = SERDES_KEY_INFO; + for (i = 0; i < chip_num; i++) { + for (j = 0; j < die_num; j++) { + serdes_info_cmd.chip_id = i; + log_cmd.cmd = &serdes_info_cmd; + log_cmd.die_id = j; + ret = snprintf(log_name, MAX_LOG_NAME_LEN, "serdes_info_c%ud%u", i, j); + if (ret < 0 || (uint32_t)(ret) >= MAX_LOG_NAME_LEN) { + HIKP_ERROR_PRINT("create serdes_info log name failed\n"); + break; + } + ret = hikp_collect_log(GROUP_SERDES, log_name, + collect_serdes_info_process, + (void *)&log_cmd); + if (ret) { + /* + * Stop collection when the die id is 0 and ret is -EINVAL, + * indicating that the current chip id is not supported. + */ + if (j == 0 && ret == -EINVAL) + stop = true; + + if (ret == -EINVAL) + break; + + HIKP_ERROR_PRINT("%s chip%u die%u failed: %d\n", __func__, + i, j, ret); + } + } + + if (stop) + break; + } +} + +static int collect_serdes_dump_process(void *data) +{ + const char *dump_cmd_str[HILINK_DUMP_TYPE_END] = {"cs", "ds", "csds", "ram", "subctrl"}; + struct serdes_log_cmd *log_cmd = (struct serdes_log_cmd *)data; + struct serdes_macro_info *macro_info = serdes_get_macro_info(); + unsigned char die_macro_num = serdes_get_die_macro_num(); + struct cmd_serdes_param *cmd = log_cmd->cmd; + unsigned char die_id = log_cmd->die_id; + unsigned char subcmd_list[] = {0, 1, 4}; /* 0, 1, 4: cs, ds, subctrl reg */ + unsigned char k, p, q; + int ret; + + for (k = 0; k < die_macro_num; k++) { + cmd->macro_id = die_id * die_macro_num + k; + for (q = 0; q < macro_info[k].ds_num; q++) { + cmd->start_sds_id = q; + cmd->sds_num = 1; + for (p = 0; p < sizeof(subcmd_list) / sizeof(subcmd_list[0]); p++) { + cmd->sub_cmd = subcmd_list[p]; + printf("hikptool serdes_dump -i %u -s m%ud%u -c %s\n", + cmd->chip_id, cmd->macro_id, cmd->start_sds_id, + dump_cmd_str[cmd->sub_cmd]); + ret = hikp_serdes_get_reponse(cmd); + if (ret) { + HIKP_ERROR_PRINT("collect chip%u die%u macro%u lane%u " + "serdes_dump%u failed: %d\n", + cmd->chip_id, die_id, k, q, + subcmd_list[p], ret); + + if (ret == -EINVAL) + return ret; + } + } + } + } + + return 0; +} + +static void collect_serdes_dump_log(void) +{ + struct cmd_serdes_param serdes_dump_cmd = {0}; + unsigned char chip_num = MAX_CHIP_NUM_SUPPORT; + unsigned char die_num = serdes_get_die_num(); + struct serdes_log_cmd log_cmd = {0}; + char log_name[MAX_LOG_NAME_LEN] = {0}; + unsigned char i, j; + bool stop = false; + int ret; + + serdes_dump_cmd.cmd_type = SERDES_DUMP_REG; + for (i = 0; i < chip_num; i++) { + for (j = 0; j < die_num; j++) { + serdes_dump_cmd.chip_id = i; + log_cmd.cmd = &serdes_dump_cmd; + log_cmd.die_id = j; + ret = snprintf(log_name, MAX_LOG_NAME_LEN, "serdes_dump_c%ud%u", i, j); + if (ret < 0 || (uint32_t)(ret) >= MAX_LOG_NAME_LEN) { + HIKP_ERROR_PRINT("create serdes_info log name failed\n"); + break; + } + ret = hikp_collect_log(GROUP_SERDES, log_name, + collect_serdes_dump_process, + (void *)&log_cmd); + if (ret) { + /* + * Stop collection when the die id is 0 and ret is -EINVAL, + * indicating that the current chip id is not supported. + */ + if (j == 0 && ret == -EINVAL) + stop = true; + + if (ret == -EINVAL) + break; + + HIKP_ERROR_PRINT("%s chip%u die%u failed: %d\n", __func__, + i, j, ret); + } + } + + if (stop) + break; + } +} + +void collect_serdes_log(void) +{ + collect_serdes_info_log(); + collect_serdes_dump_log(); +} diff --git a/info_collect/hikp_collect_socip.c b/info_collect/hikp_collect_socip.c new file mode 100644 index 0000000000000000000000000000000000000000..6bccf6a274df6ac907cfacc4973cb07b308c3bf8 --- /dev/null +++ b/info_collect/hikp_collect_socip.c @@ -0,0 +1,272 @@ +/* + * 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 +#include "hikp_collect_lib.h" +#include "hikp_collect.h" +#include "tool_lib.h" +#include "hikptdev_plug.h" +#include "hikp_socip.h" +#include "hikp_collect_socip.h" + +#define SOCIP_MODULENUM 7 +#define MAX_CHIPNUM 30 + +enum socip_collect_type { + GPIO, + SPI, + I2C, + SFC, + USB, + UART, + BT, +}; + +const char *g_socip_modulename[SOCIP_MODULENUM] = { + "gpio", + "spi", + "i2c", + "sfc", + "usb", + "uart", + "bt", +}; + +struct info_collect_cmd gpio_cmd_arr[] = { + { + .group = GROUP_SOCIP, + .log_name = "gpio", + .args = {"cat", "/sys/kernel/debug/gpio", NULL}, + }, +}; + +struct info_collect_cmd spi_cmd_arr[] = { + { + .group = GROUP_SOCIP, + .log_name = "spi", + .args = {"cat", "/sys/kernel/debug/dw_spi*/registers", NULL}, + }, + + { + .group = GROUP_SOCIP, + .log_name = "spi", + .args = {"cat", "/sys/kernel/debug/hisi_spi*/registers", NULL}, + }, + + { + .group = GROUP_SOCIP, + .log_name = "spi", + .args = {"cat", "/sys/class/spi_master/spi*/statistics/bytes", NULL}, + }, + + { + .group = GROUP_SOCIP, + .log_name = "spi", + .args = {"cat", "/sys/class/spi_master/spi*/statistics/bytes_rx", NULL}, + }, + + { + .group = GROUP_SOCIP, + .log_name = "spi", + .args = {"cat", "/sys/class/spi_master/spi*/statistics/bytes_tx", NULL}, + }, +}; + +struct info_collect_cmd i2c_cmd_arr[] = { + { + .group = GROUP_SOCIP, + .log_name = "i2c", + .args = {"ls", "/sys/class/i2c-adapter", NULL}, + }, + + { + .group = GROUP_SOCIP, + .log_name = "i2c", + .args = {"ls", "/sys/class/i2c-dev", NULL}, + }, +}; + +struct info_collect_cmd sfc_cmd_arr[] = { + { + .group = GROUP_SOCIP, + .log_name = "sfc", + .args = {"mtd_debug", "info", "/dev/mtd0", NULL}, + }, +}; + +struct info_collect_cmd usb_cmd_arr[] = { + { + .group = GROUP_SOCIP, + .log_name = "usb", + .args = {"cat", "/sys/kernel/debug/usb/devices", NULL}, + }, +}; + +struct info_collect_cmd uart_cmd_arr[] = { + { + .group = GROUP_SOCIP, + .log_name = "uart", + .args = {"stty", "-F", "/dev/ttyAMA0", "-a", NULL}, + }, + + { + .group = GROUP_SOCIP, + .log_name = "uart", + .args = {"cat", "/proc/tty/driver/ttyAMA", NULL}, + }, +}; + +struct info_collect_cmd bt_cmd_arr[] = { + { + .group = GROUP_SOCIP, + .log_name = "bt", + .args = {"ls", "/dev/ipmi0", NULL}, + }, +}; + +static int socip_get_dumpregparam(struct socip_collect_dumpreg_req req_struct, + struct socip_dump_reg_req_data_t *req_data_ptr, uint8_t chip_id, int controller_num) +{ + req_data_ptr->controller_id = req_struct.controller_id[controller_num]; + if (req_data_ptr->controller_id == CONTROLLER_MAX_NUM) + return -EINVAL; + + req_data_ptr->chip_id = chip_id; + req_data_ptr->die_id = req_struct.die_id; + return 0; +} + +static int collect_socip_dumpreglog(void *version) +{ + size_t i, msize; + uint8_t chip_id; + uint32_t cpu_version = *(uint32_t *)version; + int controller_num, ret; + struct hikp_cmd_ret *cmd_ret; + struct socip_collect_dumpreg_req *req_struct; + struct socip_dump_reg_req_data_t req_data = {0}; + struct hikp_cmd_header req_header = {0}; + + switch (cpu_version) { + case CHIP_HIP09: + case CHIP_HIP10: + case CHIP_HIP10C: + req_struct = socip_hip09_hip10x_reg_arr; + msize = HIKP_ARRAY_SIZE(socip_hip09_hip10x_reg_arr); + break; + case CHIP_HIP11: + req_struct = socip_hip11_reg_arr; + msize = HIKP_ARRAY_SIZE(socip_hip11_reg_arr); + break; + default: + HIKP_ERROR_PRINT("Cpu version not support.\n"); + return 0; + } + + for (chip_id = 0; chip_id < MAX_CHIPNUM; chip_id++) { + for (i = 0; i < msize; i++) { + controller_num = 0; + while(controller_num < CONTROLLER_MAX_NUM) { + struct socip_dump_reg_req_data_t *req_data_ptr = &req_data; + ret = socip_get_dumpregparam(req_struct[i], req_data_ptr, chip_id, controller_num); + if (ret) + break; + + hikp_cmd_init(&req_header, SOCIP_MOD, HIKP_SOCIP_CMD_DUMPREG, + req_struct[i].module); + cmd_ret = hikp_cmd_alloc(&req_header, &req_data, sizeof(req_data)); + if (!cmd_ret || cmd_ret->status != 0) { + HIKP_ERROR_PRINT("hikp_cmd_alloc failed\n"); + hikp_cmd_free(&cmd_ret); + return 0; + } + printf("%s\n", req_struct[i].reg_info); + printf("hikptool socip_dumpreg -c %u -d %u -m %u -i %u\n",req_data.chip_id, + req_data.die_id, req_struct[i].module, req_data.controller_id); + dump_reg_info(&cmd_ret->rsp_data[0], cmd_ret->rsp_data_num); + hikp_cmd_free(&cmd_ret); + controller_num++; + } + } + } + + return 0; +} + +static int collect_socip_modulelog(void *module) +{ + size_t i, msize; + int ret; + + switch (*(int *)module) { + case GPIO: + msize = HIKP_ARRAY_SIZE(gpio_cmd_arr); + for (i = 0; i < msize; i++) + ret = hikp_collect_exec((void *)&gpio_cmd_arr[i]); + break; + case SPI: + msize = HIKP_ARRAY_SIZE(spi_cmd_arr); + for (i = 0; i < msize; i++) + ret = hikp_collect_cat_glob_exec((void *)&spi_cmd_arr[i]); + break; + case I2C: + msize = HIKP_ARRAY_SIZE(i2c_cmd_arr); + for (i = 0; i < msize; i++) + ret = hikp_collect_exec((void *)&i2c_cmd_arr[i]); + break; + case SFC: + msize = HIKP_ARRAY_SIZE(sfc_cmd_arr); + for (i = 0; i < msize; i++) + ret = hikp_collect_exec((void *)&sfc_cmd_arr[i]); + break; + case USB: + msize = HIKP_ARRAY_SIZE(usb_cmd_arr); + for (i = 0; i < msize; i++) + ret = hikp_collect_exec((void *)&usb_cmd_arr[i]); + break; + case UART: + msize = HIKP_ARRAY_SIZE(uart_cmd_arr); + for (i = 0; i < msize; i++) + ret = hikp_collect_exec((void *)&uart_cmd_arr[i]); + break; + case BT: + msize = HIKP_ARRAY_SIZE(bt_cmd_arr); + for (i = 0; i < msize; i++) + ret = hikp_collect_exec((void *)&bt_cmd_arr[i]); + break; + default: + ret = 0; + break; + } + + return ret; +} + +void collect_socip_log(void) +{ + int i, ret; + uint32_t cpu_version = get_chip_type(); + + for (i = 0; i < SOCIP_MODULENUM; i++) { + ret = hikp_collect_log(GROUP_SOCIP, (char *)g_socip_modulename[i], + collect_socip_modulelog, (void *)&i); + if (ret) { + HIKP_ERROR_PRINT("collect_socip_log %s arr failed: %d\n", + g_socip_modulename[i], ret); + } + } + + ret = hikp_collect_log(GROUP_SOCIP, "dumpreg", collect_socip_dumpreglog, (void *)&cpu_version); + if (ret) + HIKP_ERROR_PRINT("collect_socip_log dumpreg failed: %d\n", ret); +} diff --git a/info_collect/hikp_collect_socip.h b/info_collect/hikp_collect_socip.h new file mode 100644 index 0000000000000000000000000000000000000000..b8bb879ab0d4aad36883b8511fae7cf4f6469a63 --- /dev/null +++ b/info_collect/hikp_collect_socip.h @@ -0,0 +1,238 @@ +/* + * 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. + */ +#ifndef HIKP_COLLECT_SOCIP_H +#define HIKP_COLLECT_SOCIP_H + +#define MIN_DIE_ID 0 +#define NIMBUS_A_ID 0 +#define TOTEM_A_ID 1 +#define NIMBUS_B_ID 2 +#define TOTEM_C_ID 2 +#define TOTEM_B_ID 3 +#define INVALID_DIE_ID 0xFF +#define MAX_DIE_ID 3 +#define CONTROLLER_MAX_NUM 12 + +#define DIE_MIN_INDEX 0 +#define CPUDIE_MIN_INDEX 0 +#define CPUDIE_A_INDEX 0 +#define CPUDIE_B_INDEX 1 +#define CPUDIE_MAX_INDEX 1 +#define IODIE_MIN_INDEX 2 +#define IODIE_A0_INDEX 2 +#define IODIE_A1_INDEX 3 +#define IODIE_B0_INDEX 4 +#define IODIE_B1_INDEX 5 +#define IODIE_MAX_INDEX 5 +#define DIE_MAX_INDEX 5 + +struct socip_collect_dumpreg_req { + char *reg_info; + uint8_t module; + uint8_t die_id; + uint8_t controller_id[CONTROLLER_MAX_NUM]; +}; + +struct socip_collect_dumpreg_req socip_hip09_hip10x_reg_arr[] = { + { + .reg_info = "gpio_NA", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_GPIO, + .die_id = NIMBUS_A_ID, + .controller_id = {0, 1, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "gpio_NB", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_GPIO, + .die_id = NIMBUS_B_ID, + .controller_id = {0, 1, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "gpio_TA", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_GPIO, + .die_id = TOTEM_A_ID, + .controller_id = {0, 1, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "gpio_TB", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_GPIO, + .die_id = TOTEM_B_ID, + .controller_id = {0, 1, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "i2c_NA", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_I2C, + .die_id = NIMBUS_A_ID, + .controller_id = {0, 1, 5, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "i2c_NB", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_I2C, + .die_id = NIMBUS_A_ID, + .controller_id = {0, 1, 5, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "spi_NA", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_SPI, + .die_id = NIMBUS_A_ID, + .controller_id = {0, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "spi_NB", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_SPI, + .die_id = NIMBUS_B_ID, + .controller_id = {0, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "sfc_NA", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_SFC, + .die_id = NIMBUS_A_ID, + .controller_id = {0, 1, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "sfc_NB", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_SFC, + .die_id = NIMBUS_B_ID, + .controller_id = {0, 1, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "btc_NA", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_SFC, + .die_id = NIMBUS_A_ID, + .controller_id = {0, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "btc_NB", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_SFC, + .die_id = NIMBUS_B_ID, + .controller_id = {0, CONTROLLER_MAX_NUM}, + }, +}; + +struct socip_collect_dumpreg_req socip_hip11_reg_arr[] = { + { + .reg_info = "gpio_IOA0", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_GPIO, + .die_id = IODIE_A0_INDEX, + .controller_id = {0, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "gpio_IOA1", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_GPIO, + .die_id = IODIE_A1_INDEX, + .controller_id = {0, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "gpio_IOB0", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_GPIO, + .die_id = IODIE_B0_INDEX, + .controller_id = {0, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "gpio_IOB1", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_GPIO, + .die_id = IODIE_B1_INDEX, + .controller_id = {0, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "gpio_CA", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_GPIO, + .die_id = CPUDIE_A_INDEX, + .controller_id = {0, 1, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "gpio_CB", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_GPIO, + .die_id = CPUDIE_B_INDEX, + .controller_id = {0, 1, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "i2c_IOA0", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_I2C, + .die_id = IODIE_A0_INDEX, + .controller_id = {0, 1, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "i2c_IOA1", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_I2C, + .die_id = IODIE_A1_INDEX, + .controller_id = {0, 1, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "i2c_IOB0", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_I2C, + .die_id = IODIE_B0_INDEX, + .controller_id = {0, 1, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "i2c_IOB1", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_I2C, + .die_id = IODIE_B1_INDEX, + .controller_id = {0, 1, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "i2c_CA", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_I2C, + .die_id = CPUDIE_A_INDEX, + .controller_id = {0, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "i2c_CB", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_I2C, + .die_id = CPUDIE_B_INDEX, + .controller_id = {0, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "spi_CB", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_SPI, + .die_id = CPUDIE_B_INDEX, + .controller_id = {0, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "sfc_CA", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_SFC, + .die_id = CPUDIE_A_INDEX, + .controller_id = {0, CONTROLLER_MAX_NUM}, + }, + + { + .reg_info = "BTC_IOB0", + .module = HIKP_SOCIP_SUBCMD_DUMPREG_SFC, + .die_id = IODIE_B0_INDEX, + .controller_id = {0, CONTROLLER_MAX_NUM}, + }, +}; +#endif /* HIKP_COLLECT_SOCIP_H */ diff --git a/libhikptdev/include/hikptdev_plug.h b/libhikptdev/include/hikptdev_plug.h index 2123935e72e234135cc81032f83d19276b8578c9..375fb893987a26b34a3934258ab39e0c132b9b55 100644 --- a/libhikptdev/include/hikptdev_plug.h +++ b/libhikptdev/include/hikptdev_plug.h @@ -44,6 +44,8 @@ enum cmd_module_type { DPDK_MOD = 9, CXL_MOD = 10, UB_MOD = 11, + HCCS_MOD = 16, + SDMA_MOD = 17 }; void hikp_unlock(void); diff --git a/libhikptdev/src/rciep/hikpt_rciep.c b/libhikptdev/src/rciep/hikpt_rciep.c index 5a38b3bdd863714ae09d68f9e5781939ffdaaed7..88ac16e6f37bb81ae0c8fd787aac32c4f511301f 100644 --- a/libhikptdev/src/rciep/hikpt_rciep.c +++ b/libhikptdev/src/rciep/hikpt_rciep.c @@ -526,27 +526,35 @@ static void hikp_munmap(void) g_hikp_rsp = NULL; } +static int hikp_dev_set_iep_fd(char *iep) +{ + char path[PATH_MAX + 1] = { 0 }; + + if (strlen(iep) > PATH_MAX || realpath(iep, path) == NULL) + return -ENOENT; + + g_iep_fd = open(path, O_RDWR | O_SYNC); + if (g_iep_fd < 0) { + printf("failed to open %s.\n", iep); + return -errno; + } + + return 0; +} + int hikp_dev_init(void) { size_t i, len; int ret = 0; char *iep; - char path[PATH_MAX + 1] = { 0 }; iep = hikp_get_iep_dir(HIKP_RESOURCE_DIR); if (iep == NULL) return -ENOENT; - if (strlen(iep) > PATH_MAX || realpath(iep, path) == NULL) { - ret = -ENOENT; - goto out_free_iep; - } - g_iep_fd = open(path, O_RDWR | O_SYNC); - if (g_iep_fd < 0) { - printf("failed to open %s.\n", iep); - ret = -errno; + ret = hikp_dev_set_iep_fd(iep); + if (ret) goto out_free_iep; - } g_hikp_req = (union hikp_space_req *)mmap(0, sizeof(union hikp_space_req), PROT_READ | PROT_WRITE, MAP_SHARED, g_iep_fd, 0); diff --git a/net/hikp_net_lib.c b/net/hikp_net_lib.c index f4d4c2aaa5b26c399442237b7b9e729880cadf7c..7646aad8399a200c996c58a4d2ce466825716eec 100644 --- a/net/hikp_net_lib.c +++ b/net/hikp_net_lib.c @@ -309,7 +309,7 @@ int get_vf_dev_info_by_pf_dev_name(const char *pf_dev_name, ret = snprintf(dev_name_dir, sizeof(dev_name_dir), "%s%s%s%u%s", HIKP_NET_DEV_PATH, pf_dev_name, HIKP_VIRTFN_PATH, vf_id, HIKP_NET_PATH); - if (ret < 0 || ret >= sizeof(dev_name_dir)) { + if (ret < 0 || ret >= MAX_BUS_PCI_DIR_LEN) { HIKP_ERROR_PRINT("get vf dev_name dir fail.\n"); return -EIO; } @@ -333,7 +333,7 @@ int get_pf_dev_info_by_vf_dev_name(const char *vf_dev_name, struct tool_target * ret = snprintf(dev_name_dir, sizeof(dev_name_dir), "%s%s%s", HIKP_NET_DEV_PATH, vf_dev_name, HIKP_PHYSFN_PATH); - if (ret < 0 || ret >= sizeof(dev_name_dir)) { + if (ret < 0 || ret >= MAX_BUS_PCI_DIR_LEN) { HIKP_ERROR_PRINT("get vf dev_name dir fail.\n"); return -EIO; } diff --git a/net/nic/nic_dfx/hikp_nic_dfx.c b/net/nic/nic_dfx/hikp_nic_dfx.c index c42b8e7c5a75874f96693264256c629fe53d125e..d6114de385698c8225f5d570152909c6ba19c5fe 100644 --- a/net/nic/nic_dfx/hikp_nic_dfx.c +++ b/net/nic/nic_dfx/hikp_nic_dfx.c @@ -404,6 +404,13 @@ static const struct dfx_type_name_parse g_dfx_ssu_name_parse[] = { dfx_ssu_type_64_tx_comm_stats, HIKP_ARRAY_SIZE(dfx_ssu_type_64_tx_comm_stats)}, }; +void hikp_nic_dfx_set_cmd_para(int idx) +{ + g_dfx_param.sub_cmd_code = g_dfx_module_parse[idx].sub_cmd_code; + g_dfx_param.module_idx = idx; + g_dfx_param.flag |= MODULE_SET_FLAG; +} + static void dfx_help_info(const struct major_cmd_ctrl *self) { printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i \n"); @@ -417,11 +424,13 @@ static void dfx_help_info(const struct major_cmd_ctrl *self) static int hikp_cmd_dfx_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + dfx_help_info(self); return 0; } -static int hikp_nic_cmd_dfx_target(struct major_cmd_ctrl *self, const char *argv) +int hikp_nic_cmd_dfx_target(struct major_cmd_ctrl *self, const char *argv) { self->err_no = tool_check_and_get_valid_bdf_id(argv, &(g_dfx_param.target)); if (self->err_no != 0) { @@ -714,7 +723,7 @@ static void hikp_nic_dfx_print(const struct nic_dfx_rsp_head_t *rsp_head, uint32 printf("################### ====== dump end ====== ######################\n"); } -static void hikp_nic_dfx_cmd_execute(struct major_cmd_ctrl *self) +void hikp_nic_dfx_cmd_execute(struct major_cmd_ctrl *self) { struct nic_dfx_rsp_head_t rsp_head = { 0 }; struct nic_dfx_rsp_head_t tmp_head = { 0 }; diff --git a/net/nic/nic_dfx/hikp_nic_dfx.h b/net/nic/nic_dfx/hikp_nic_dfx.h index 38f76aa1592849cf935cecc4a48d94000ddafd0c..d77bbc3d10baae2dcb2ac3e4a10cf3c2ee76146e 100644 --- a/net/nic/nic_dfx/hikp_nic_dfx.h +++ b/net/nic/nic_dfx/hikp_nic_dfx.h @@ -149,4 +149,7 @@ struct dfx_type_name_parse { uint32_t reg_num; }; +int hikp_nic_cmd_dfx_target(struct major_cmd_ctrl *self, const char *argv); +void hikp_nic_dfx_cmd_execute(struct major_cmd_ctrl *self); +void hikp_nic_dfx_set_cmd_para(int idx); #endif /* HIKP_NIC_DFX_H */ diff --git a/net/nic/nic_fd/hikp_nic_fd.c b/net/nic/nic_fd/hikp_nic_fd.c index 3296ebf4cd58c8371cac0cdc841e73a43f5480ef..10fee423c43013bd0b2b9dc93328d23bbd80fee1 100644 --- a/net/nic/nic_fd/hikp_nic_fd.c +++ b/net/nic/nic_fd/hikp_nic_fd.c @@ -109,8 +109,17 @@ static const struct fd_feature_cmd g_fd_feature_cmd[] = { hikp_nic_query_fd_counter, hikp_nic_show_fd_counter}, }; +void hikp_nic_set_fd_idx(int feature_idx, int stage_no) +{ + g_fd_param.id = -1; + g_fd_param.feature_idx = feature_idx; + g_fd_param.stage_no = stage_no; +} + static int hikp_nic_fd_cmd_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i "); printf("\n %s\n", self->cmd_ptr->help_info); printf("\n Options:\n\n"); @@ -633,6 +642,8 @@ static int hikp_nic_query_fd_rules(struct hikp_cmd_header *req_header, const str uint32_t idx; int ret = 0; + HIKP_SET_USED(len); + if (stage >= NIC_FD_STAGE_NUM) { HIKP_ERROR_PRINT("The fd stage number(%d) is error!\n", stage + 1); return -EIO; @@ -693,6 +704,8 @@ static int hikp_nic_query_fd_counter(struct hikp_cmd_header *req_header, const s uint16_t idx; int ret = 0; + HIKP_SET_USED(len); + if (stage >= NIC_FD_STAGE_NUM) { HIKP_ERROR_PRINT("The fd stage number(%d) is error!\n", stage + 1); return -EIO; @@ -750,7 +763,7 @@ static int hikp_nic_get_fd_hw_info(const struct bdf_t *bdf, struct nic_fd_hw_inf sizeof(*hw_info)); } -static int hikp_nic_fd_alloc_rules_buf(struct nic_fd_rules *rules, uint8_t stage_num, +static int hikp_nic_fd_alloc_rules_buf(struct nic_fd_rules *rules, struct nic_fd_hw_info *hw_info, uint16_t stage_no) { uint16_t max_key_bytes; @@ -768,7 +781,7 @@ static int hikp_nic_fd_alloc_rules_buf(struct nic_fd_rules *rules, uint8_t stage return 0; } -static int hikp_nic_fd_alloc_counter_buf(struct nic_fd_counter *counter, uint8_t stage_num, +static int hikp_nic_fd_alloc_counter_buf(struct nic_fd_counter *counter, struct nic_fd_hw_info *hw_info, uint16_t stage_no) { counter[stage_no].entry = @@ -782,8 +795,7 @@ static int hikp_nic_fd_alloc_counter_buf(struct nic_fd_counter *counter, uint8_t return 0; } -static union nic_fd_feature_info *hikp_nic_fd_data_alloc(const struct fd_feature_cmd *fd_cmd, - const struct nic_fd_hw_info *hw_cfg) +static union nic_fd_feature_info *hikp_nic_fd_data_alloc(const struct fd_feature_cmd *fd_cmd) { uint16_t stage_no = g_fd_param.stage_no - 1; union nic_fd_feature_info *fd_data; @@ -796,11 +808,9 @@ static union nic_fd_feature_info *hikp_nic_fd_data_alloc(const struct fd_feature } if (strcmp(fd_cmd->feature_name, NIC_FD_RULES_NAME) == 0) - ret = hikp_nic_fd_alloc_rules_buf(fd_data->rules, NIC_FD_STAGE_NUM, - &g_fd_hw_info, stage_no); + ret = hikp_nic_fd_alloc_rules_buf(fd_data->rules, &g_fd_hw_info, stage_no); else if (strcmp(fd_cmd->feature_name, NIC_FD_COUNTER_NAME) == 0) - ret = hikp_nic_fd_alloc_counter_buf(fd_data->counter, NIC_FD_STAGE_NUM, - &g_fd_hw_info, stage_no); + ret = hikp_nic_fd_alloc_counter_buf(fd_data->counter, &g_fd_hw_info, stage_no); if (ret != 0) goto out; @@ -877,7 +887,7 @@ static int hikp_nic_fd_check_entry_index_valid(struct major_cmd_ctrl *self, hw_entry_size = fd_cmd->sub_cmd_code == NIC_FD_RULES_INFO_DUMP ? hw_info->alloc.stage_entry_num[stage_no] : hw_info->alloc.stage_counter_num[stage_no]; - if (fd_param->id >= hw_entry_size) { + if ((uint32_t)fd_param->id >= hw_entry_size) { snprintf(self->err_str, sizeof(self->err_str), "entry id(%d) must be less than hardware specifications(%u).", fd_param->id, hw_entry_size); @@ -923,7 +933,7 @@ static int hikp_nic_fd_check_input_param(struct major_cmd_ctrl *self, return 0; } -static void hikp_nic_fd_cmd_execute(struct major_cmd_ctrl *self) +void hikp_nic_fd_cmd_execute(struct major_cmd_ctrl *self) { struct bdf_t *bdf = &g_fd_param.target.bdf; const struct fd_feature_cmd *fd_cmd; @@ -956,7 +966,7 @@ static void hikp_nic_fd_cmd_execute(struct major_cmd_ctrl *self) if (ret != 0) return; - fd_data = hikp_nic_fd_data_alloc(fd_cmd, &g_fd_hw_info); + fd_data = hikp_nic_fd_data_alloc(fd_cmd); if (fd_data == NULL) { HIKP_ERROR_PRINT("Fail to alloc fd data memory.\n"); self->err_no = -ENOMEM; @@ -983,7 +993,7 @@ out: hikp_nic_fd_data_free(fd_data); } -static int hikp_nic_cmd_get_fd_target(struct major_cmd_ctrl *self, const char *argv) +int hikp_nic_cmd_get_fd_target(struct major_cmd_ctrl *self, const char *argv) { self->err_no = tool_check_and_get_valid_bdf_id(argv, &(g_fd_param.target)); if (self->err_no != 0) { diff --git a/net/nic/nic_fd/hikp_nic_fd.h b/net/nic/nic_fd/hikp_nic_fd.h index 3f409d0c0bb98381f2c4ff512c467b29ec44073d..ce363c9b7f0f87fd4119d229c72f8e14f7beb546 100644 --- a/net/nic/nic_fd/hikp_nic_fd.h +++ b/net/nic/nic_fd/hikp_nic_fd.h @@ -224,4 +224,8 @@ struct fd_feature_cmd { void (*show)(const void *data); }; +int hikp_nic_cmd_get_fd_target(struct major_cmd_ctrl *self, const char *argv); +void hikp_nic_fd_cmd_execute(struct major_cmd_ctrl *self); +void hikp_nic_set_fd_idx(int feature_idx, int stage_no); + #endif /* HIKP_NIC_FD_H */ diff --git a/net/nic/nic_fec/hikp_nic_fec.c b/net/nic/nic_fec/hikp_nic_fec.c index 5a34bfd201e85f8d7d48f1075d42b27879236206..8de0b59103351c8ab93d88e50856e36d80e92023 100644 --- a/net/nic/nic_fec/hikp_nic_fec.c +++ b/net/nic/nic_fec/hikp_nic_fec.c @@ -108,7 +108,7 @@ static void hikp_nic_fec_err_show(const struct nic_fec_err_info *info) printf("#################### END #######################\n"); } -static void hikp_nic_fec_cmd_execute(struct major_cmd_ctrl *self) +void hikp_nic_fec_cmd_execute(struct major_cmd_ctrl *self) { struct bdf_t *bdf = &g_fec_target.bdf; struct nic_fec_err_info info = { 0 }; @@ -126,6 +126,8 @@ static void hikp_nic_fec_cmd_execute(struct major_cmd_ctrl *self) static int hikp_nic_fec_cmd_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i "); printf("\n %s\n", self->cmd_ptr->help_info); printf("\n Options:\n\n"); @@ -136,7 +138,7 @@ static int hikp_nic_fec_cmd_help(struct major_cmd_ctrl *self, const char *argv) return 0; } -static int hikp_nic_fec_get_target(struct major_cmd_ctrl *self, const char *argv) +int hikp_nic_fec_get_target(struct major_cmd_ctrl *self, const char *argv) { self->err_no = tool_check_and_get_valid_bdf_id(argv, &g_fec_target); if (self->err_no != 0) { diff --git a/net/nic/nic_fec/hikp_nic_fec.h b/net/nic/nic_fec/hikp_nic_fec.h index 7996273a8119ce3f7b6197100b746981f5e4ee76..79a87b52dadf4231df2558c76a12f38bea751de5 100644 --- a/net/nic/nic_fec/hikp_nic_fec.h +++ b/net/nic/nic_fec/hikp_nic_fec.h @@ -69,4 +69,6 @@ struct nic_fec_err_info { }; }; +int hikp_nic_fec_get_target(struct major_cmd_ctrl *self, const char *argv); +void hikp_nic_fec_cmd_execute(struct major_cmd_ctrl *self); #endif /* HIKP_NIC_FEC_H */ diff --git a/net/nic/nic_ft/hikp_nic_port_fault.c b/net/nic/nic_ft/hikp_nic_port_fault.c index 5f78cdde1abde6b50c8692f6ed85a2e1d86b5855..7d15a079dabb9e093f78ad9f0df9945b39c844b2 100644 --- a/net/nic/nic_ft/hikp_nic_port_fault.c +++ b/net/nic/nic_ft/hikp_nic_port_fault.c @@ -80,7 +80,7 @@ static void hikp_nic_port_fault_show(struct nic_port_fault_status *info) printf("#################### END #######################\n"); } -static void hikp_nic_port_fault_cmd_execute(struct major_cmd_ctrl *self) +void hikp_nic_port_fault_cmd_execute(struct major_cmd_ctrl *self) { struct bdf_t *bdf = &g_port_fault_target.bdf; struct nic_port_fault_status info = { 0 }; @@ -98,6 +98,8 @@ static void hikp_nic_port_fault_cmd_execute(struct major_cmd_ctrl *self) static int hikp_nic_port_fault_cmd_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i "); printf("\n %s\n", self->cmd_ptr->help_info); printf("\n Options:\n\n"); @@ -108,7 +110,7 @@ static int hikp_nic_port_fault_cmd_help(struct major_cmd_ctrl *self, const char return 0; } -static int hikp_nic_port_fault_get_target(struct major_cmd_ctrl *self, const char *argv) +int hikp_nic_port_fault_get_target(struct major_cmd_ctrl *self, const char *argv) { self->err_no = tool_check_and_get_valid_bdf_id(argv, &g_port_fault_target); if (self->err_no != 0) { diff --git a/net/nic/nic_ft/hikp_nic_port_fault.h b/net/nic/nic_ft/hikp_nic_port_fault.h index 7db54f76d6fa9a5ce28102d3b790111492370108..9c7e4b2f0d0b5e0ea38203ee76335932fd02f2af 100644 --- a/net/nic/nic_ft/hikp_nic_port_fault.h +++ b/net/nic/nic_ft/hikp_nic_port_fault.h @@ -51,4 +51,6 @@ struct nic_port_fault_status { uint8_t hilink_ref_status; }; +int hikp_nic_port_fault_get_target(struct major_cmd_ctrl *self, const char *argv); +void hikp_nic_port_fault_cmd_execute(struct major_cmd_ctrl *self); #endif /* HIKP_NIC_PORT_FAULT_H */ diff --git a/net/nic/nic_gro/hikp_nic_gro.c b/net/nic/nic_gro/hikp_nic_gro.c index 19395afd74195c65d21a4ed611d03ddc9a2569b7..3e9b31a2b3cd0e176947779200d1ef310e3627ec 100644 --- a/net/nic/nic_gro/hikp_nic_gro.c +++ b/net/nic/nic_gro/hikp_nic_gro.c @@ -53,7 +53,7 @@ static void hikp_nic_gro_show(const struct nic_gro_info *info) printf("#################### END #######################\n"); } -static void hikp_nic_gro_cmd_execute(struct major_cmd_ctrl *self) +void hikp_nic_gro_cmd_execute(struct major_cmd_ctrl *self) { struct bdf_t *bdf = &g_gro_target.bdf; struct nic_gro_info info = { 0 }; @@ -71,6 +71,8 @@ static void hikp_nic_gro_cmd_execute(struct major_cmd_ctrl *self) static int hikp_nic_gro_cmd_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i "); printf("\n %s\n", self->cmd_ptr->help_info); printf("\n Options:\n\n"); @@ -81,7 +83,7 @@ static int hikp_nic_gro_cmd_help(struct major_cmd_ctrl *self, const char *argv) return 0; } -static int hikp_nic_gro_get_target(struct major_cmd_ctrl *self, const char *argv) +int hikp_nic_gro_get_target(struct major_cmd_ctrl *self, const char *argv) { self->err_no = tool_check_and_get_valid_bdf_id(argv, &g_gro_target); if (self->err_no != 0) { diff --git a/net/nic/nic_gro/hikp_nic_gro.h b/net/nic/nic_gro/hikp_nic_gro.h index 49328e673de6cb467cbe4ba703c463887634110c..ae58703386b5ec8f13170bae84135a25562870d1 100644 --- a/net/nic/nic_gro/hikp_nic_gro.h +++ b/net/nic/nic_gro/hikp_nic_gro.h @@ -43,4 +43,6 @@ struct nic_gro_info { uint32_t max_coal_bd_num; }; +int hikp_nic_gro_get_target(struct major_cmd_ctrl *self, const char *argv); +void hikp_nic_gro_cmd_execute(struct major_cmd_ctrl *self); #endif /* HIKP_NIC_GRO_H */ diff --git a/net/nic/nic_info/hikp_nic_info.c b/net/nic/nic_info/hikp_nic_info.c index 49f143f445b485c2975556169d68542174f9b1fc..b05d6ef001bebcd2181ff776da8b26d66aa76b0c 100644 --- a/net/nic/nic_info/hikp_nic_info.c +++ b/net/nic/nic_info/hikp_nic_info.c @@ -25,6 +25,8 @@ static struct nic_info_param g_info_param = { 0 }; static int hikp_nic_cmd_get_info_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i "); printf("\n %s\n", self->cmd_ptr->help_info); printf("\n Options:\n\n"); @@ -37,7 +39,7 @@ static int hikp_nic_cmd_get_info_help(struct major_cmd_ctrl *self, const char *a return 0; } -static int hikp_nic_cmd_get_info_target(struct major_cmd_ctrl *self, const char *argv) +int hikp_nic_cmd_get_info_target(struct major_cmd_ctrl *self, const char *argv) { self->err_no = tool_check_and_get_valid_bdf_id(argv, &(g_info_param.target)); if (self->err_no != 0) { @@ -305,7 +307,7 @@ static void hikp_nic_info_print_cur_vf(const struct bdf_t *bdf) } } -static void hikp_nic_info_cmd_execute(struct major_cmd_ctrl *self) +void hikp_nic_info_cmd_execute(struct major_cmd_ctrl *self) { struct bdf_t *bdf = &g_info_param.target.bdf; diff --git a/net/nic/nic_info/hikp_nic_info.h b/net/nic/nic_info/hikp_nic_info.h index b1dd7dc8a333ff498f565f56c04648818c462ee2..83323e823b0f6b3d613e3ec4261bf37057444116 100644 --- a/net/nic/nic_info/hikp_nic_info.h +++ b/net/nic/nic_info/hikp_nic_info.h @@ -77,4 +77,6 @@ enum nic_info_mac_type { MAC_TYPE_MAX, }; +void hikp_nic_info_cmd_execute(struct major_cmd_ctrl *self); +int hikp_nic_cmd_get_info_target(struct major_cmd_ctrl *self, const char *argv); #endif /* HIKP_NIC_INFO_H */ diff --git a/net/nic/nic_log/hikp_nic_log.c b/net/nic/nic_log/hikp_nic_log.c index f182d25e08db3808f37b1039605dbd3f2b70617e..0e2d5566041c470bd636d04dc67fb6229b56a061 100644 --- a/net/nic/nic_log/hikp_nic_log.c +++ b/net/nic/nic_log/hikp_nic_log.c @@ -23,9 +23,12 @@ #include "hikp_nic_log.h" static struct log_param g_log_param = { 0 }; +static char g_log_path[OP_LOG_FILE_PATH_MAXLEN] = {0}; static int hikp_nic_cmd_log_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i \n"); printf("\n %s\n", self->cmd_ptr->help_info); printf(" Options:\n\n"); @@ -49,7 +52,6 @@ static int hikp_nic_cmd_log_target(struct major_cmd_ctrl *self, const char *argv static int hikp_nic_write_data_to_file(uint8_t *data, uint32_t len) { - uint8_t file_path[OP_LOG_FILE_PATH_MAXLEN] = { 0 }; uint8_t file_name[MAX_LOG_NAME_LEN] = { 0 }; size_t write_cnt; FILE *fp = NULL; @@ -59,23 +61,23 @@ static int hikp_nic_write_data_to_file(uint8_t *data, uint32_t len) if (ret < 0) return ret; - ret = snprintf((char *)file_path, sizeof(file_path), HIKP_LOG_DIR_PATH"%s", file_name); + ret = snprintf(g_log_path, sizeof(g_log_path), HIKP_LOG_DIR_PATH"%s", file_name); if (ret < 0) { HIKP_ERROR_PRINT("creat log file path fail.\n"); return -EIO; } - (void)remove((const char *)file_path); - fp = fopen((char *)file_path, "w+"); + (void)remove((const char *)g_log_path); + fp = fopen(g_log_path, "w+"); if (fp == NULL) { - HIKP_ERROR_PRINT("open %s failed, errno is %d\n", file_path, errno); + HIKP_ERROR_PRINT("open %s failed, errno is %d\n", g_log_path, errno); return -errno; } write_cnt = fwrite(data, 1, len, fp); if (write_cnt != len) - HIKP_ERROR_PRINT("write %s failed, write cnt %lu.\n", file_path, write_cnt); + HIKP_ERROR_PRINT("write %s failed, write cnt %lu.\n", g_log_path, write_cnt); - printf("dump m7 log completed, log file: %s.\n", file_path); - (void)chmod((char *)file_path, 0440); + printf("dump m7 log completed, log file: %s.\n", g_log_path); + (void)chmod(g_log_path, 0440); (void)fclose(fp); return 0; } @@ -199,6 +201,29 @@ static void hikp_nic_log_cmd_execute(struct major_cmd_ctrl *self) self->err_no = hikp_nic_dump_m7_log(self); } +const char *hikp_info_collect_get_log_path(void) +{ + return (const char *)g_log_path; +} + +int hikp_info_collect_nic_log(void *data) +{ + struct nic_log_collect_param *param = (struct nic_log_collect_param *)data; + struct major_cmd_ctrl *major_cmd = get_major_cmd(); + int ret; + + memset(&g_log_param, 0, sizeof(g_log_param)); + + ret = hikp_nic_cmd_log_target(major_cmd, param->net_dev_name); + if (ret) + return ret; + + printf("hikptool nic_log -i %s\n", param->net_dev_name); + hikp_nic_log_cmd_execute(major_cmd); + + return ret; +} + static void cmd_nic_log_init(void) { struct major_cmd_ctrl *major_cmd = get_major_cmd(); diff --git a/net/nic/nic_log/hikp_nic_log.h b/net/nic/nic_log/hikp_nic_log.h index 2998464c6c5f68f7a38f496e0eaed559e0005ac5..cff1980be66f81bbdceb2152192f5ad6b9f9e362 100644 --- a/net/nic/nic_log/hikp_nic_log.h +++ b/net/nic/nic_log/hikp_nic_log.h @@ -38,4 +38,11 @@ struct log_param { struct tool_target target; }; +struct nic_log_collect_param { + const char *net_dev_name; +}; + +const char *hikp_info_collect_get_log_path(void); +int hikp_info_collect_nic_log(void *data); + #endif /* HIKP_NIC_LOG_H */ diff --git a/net/nic/nic_mac/hikp_nic_mac_dump.c b/net/nic/nic_mac/hikp_nic_mac_dump.c index 5439c713b7848e39c726c93376c126ddd8e7e844..e0d08914bb587d6c37b22ea1d399f2406d1ffd2d 100644 --- a/net/nic/nic_mac/hikp_nic_mac_dump.c +++ b/net/nic/nic_mac/hikp_nic_mac_dump.c @@ -184,7 +184,7 @@ static int mac_cmd_dump_para_check(struct major_cmd_ctrl *self) return 0; } -static void mac_cmd_dump_execute(struct major_cmd_ctrl *self) +void mac_cmd_dump_execute(struct major_cmd_ctrl *self) { int ret; @@ -203,7 +203,7 @@ static void mac_cmd_dump_execute(struct major_cmd_ctrl *self) mac_cmd_dump_module(self, g_dump_reg_info.module_name); } -static int mac_cmd_dump_reg_target(struct major_cmd_ctrl *self, const char *argv) +int mac_cmd_dump_reg_target(struct major_cmd_ctrl *self, const char *argv) { self->err_no = tool_check_and_get_valid_bdf_id(argv, &g_dump_reg_info.target); if (self->err_no) { @@ -217,6 +217,8 @@ static int mac_cmd_dump_reg_target(struct major_cmd_ctrl *self, const char *argv static int mac_cmd_dump_reg_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i -m \n"); printf("\n %s\n", self->cmd_ptr->help_info); printf(" Options:\n\n"); @@ -233,13 +235,37 @@ static int mac_cmd_dump_reg_help(struct major_cmd_ctrl *self, const char *argv) return 0; } -static int mac_cmd_dump_module_cfg(struct major_cmd_ctrl *self, const char *argv) +int mac_cmd_dump_module_cfg(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + g_dump_reg_info.module_name = argv; return 0; } +int hikp_info_collect_nic_mac(void *data) +{ + struct nic_mac_collect_param *param = (struct nic_mac_collect_param *)data; + struct major_cmd_ctrl *major_cmd = get_major_cmd(); + int ret; + + memset(&g_dump_reg_info, 0, sizeof(g_dump_reg_info)); + + ret = mac_cmd_dump_reg_target(major_cmd, param->net_dev_name); + if (ret) + return ret; + + ret = mac_cmd_dump_module_cfg(major_cmd, param->module_name); + if (ret) + return ret; + + printf("hikptool nic_mac -i %s -m %s\n", param->net_dev_name, param->module_name); + mac_cmd_dump_execute(major_cmd); + + return ret; +} + static void cmd_mac_dump_reg_init(void) { struct major_cmd_ctrl *major_cmd = get_major_cmd(); diff --git a/net/nic/nic_mac/hikp_nic_mac_dump.h b/net/nic/nic_mac/hikp_nic_mac_dump.h index 0c58ad53d43f17335318d1bbc54738aa3f3ab91f..f74a99ece53b5a1f0e7438c27271e78a56cde5da 100644 --- a/net/nic/nic_mac/hikp_nic_mac_dump.h +++ b/net/nic/nic_mac/hikp_nic_mac_dump.h @@ -60,4 +60,15 @@ struct cmd_mac_dump { uint32_t blk_num[MOD_ID_MAX]; const char *module_name; }; + +struct nic_mac_collect_param { + const char *net_dev_name; + const char *module_name; +}; + +int hikp_info_collect_nic_mac(void *data); + +int mac_cmd_dump_module_cfg(struct major_cmd_ctrl *self, const char *argv); +int mac_cmd_dump_reg_target(struct major_cmd_ctrl *self, const char *argv); +void mac_cmd_dump_execute(struct major_cmd_ctrl *self); #endif /* HIKP_NIC_MAC_DUMP_H */ diff --git a/net/nic/nic_mac/hikp_nic_port.c b/net/nic/nic_mac/hikp_nic_port.c index e28a0409503c94be516821ece7742716b720c822..396c3ec862b1c57da1db499e11c8c6aa6edb5947 100644 --- a/net/nic/nic_mac/hikp_nic_port.c +++ b/net/nic/nic_mac/hikp_nic_port.c @@ -619,6 +619,8 @@ static int mac_cmd_get_port_target(struct major_cmd_ctrl *self, const char *argv static int mac_cmd_port_show_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i "); printf("\n %s\n", self->cmd_ptr->help_info); printf("\n Options:\n\n"); @@ -630,6 +632,24 @@ static int mac_cmd_port_show_help(struct major_cmd_ctrl *self, const char *argv) return 0; } +int hikp_info_collect_nic_port(void *data) +{ + struct nic_port_collect_param *param = (struct nic_port_collect_param *)data; + struct major_cmd_ctrl *major_cmd = get_major_cmd(); + int ret; + + memset(&g_port_info, 0, sizeof(g_port_info)); + + ret = mac_cmd_get_port_target(major_cmd, param->net_dev_name); + if (ret) + return ret; + + printf("hikptool nic_port -i %s\n", param->net_dev_name); + mac_cmd_port_execute(major_cmd); + + return ret; +} + static void cmd_mac_get_port_init(void) { struct major_cmd_ctrl *major_cmd = get_major_cmd(); diff --git a/net/nic/nic_mac/hikp_nic_port.h b/net/nic/nic_mac/hikp_nic_port.h index 69ebb53618cbae8a99d783c8b4b82ec0a4a397c2..433eba49cb7ddb3f817e9175f087104fe07d6bad 100644 --- a/net/nic/nic_mac/hikp_nic_port.h +++ b/net/nic/nic_mac/hikp_nic_port.h @@ -271,4 +271,10 @@ struct cmd_hot_plug_card_info { uint8_t cur_type; }; +struct nic_port_collect_param { + const char *net_dev_name; +}; + +int hikp_info_collect_nic_port(void *data); + #endif /* HIKP_NIC_PORT_H */ diff --git a/net/nic/nic_mac/hikp_nic_xsfp.c b/net/nic/nic_mac/hikp_nic_xsfp.c index 573837b206a434078f6c71db8ec10f6405a753b0..fc24d595e502056720c695f4ea9363b2070f139e 100644 --- a/net/nic/nic_mac/hikp_nic_xsfp.c +++ b/net/nic/nic_mac/hikp_nic_xsfp.c @@ -313,7 +313,7 @@ static void sfp_print_dom_info(const struct sfp_page_info *info) (int8_t)info->page_a2.temperature[0], info->page_a2.temperature[1]); } -static void hikp_show_sfp_info(const uint8_t *data, uint32_t size) +static void hikp_show_sfp_info(const uint8_t *data) { struct sfp_page_info *sfp_data = (struct sfp_page_info *)data; @@ -412,7 +412,7 @@ static void qsfp_print_dom_info(const struct qsfp_page0_info *info) (int8_t)info->page_lower.temperature_msb, info->page_lower.temperature_lsb); } -static void hikp_show_qsfp_info(const uint8_t *data, uint32_t size) +static void hikp_show_qsfp_info(const uint8_t *data) { struct qsfp_page0_info *qsfp_data = (struct qsfp_page0_info *)(data); @@ -554,7 +554,7 @@ static void cmis_print_dom_info(const struct cmis_page_info *info) info->page0_lower.module_temp[1]); } -static void hikp_show_cmis_info(const uint8_t *data, uint32_t size) +static void hikp_show_cmis_info(const uint8_t *data) { struct cmis_page_info *cmis_data = (struct cmis_page_info *)data; @@ -567,17 +567,17 @@ static void hikp_show_cmis_info(const uint8_t *data, uint32_t size) static void hikp_xsfp_parse_info(const uint8_t *data, uint32_t size) { if (data[SFF_ID_OFFSET] == ID_SFP) { - hikp_show_sfp_info(data, size); + hikp_show_sfp_info(data); } else if (data[SFF_ID_OFFSET] == ID_QSFP || data[SFF_ID_OFFSET] == ID_QSFP_PLUS || data[SFF_ID_OFFSET] == ID_QSFP28) { - hikp_show_qsfp_info(data, size); + hikp_show_qsfp_info(data); } else if (data[SFF_ID_OFFSET] == ID_QSFP_DD || data[SFF_ID_OFFSET] == ID_SFP_DD || data[SFF_ID_OFFSET] == ID_QSFP_P_CMIS || data[SFF_ID_OFFSET] == ID_SFP_DD_CMIS || data[SFF_ID_OFFSET] == ID_SFP_P_CMIS) { - hikp_show_cmis_info(data, size); + hikp_show_cmis_info(data); } else { /* unknown type just dump hex data */ hikp_xsfp_dump_hex(data, size); @@ -702,6 +702,8 @@ ERR_OUT: static int hikp_xsfp_show_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i [-d]"); printf("\n %s\n", self->cmd_ptr->help_info); printf("\n Options:\n\n"); @@ -729,11 +731,37 @@ static int hikp_xsfp_get_target(struct major_cmd_ctrl *self, const char *argv) static int hikp_xsfp_dump_raw_data(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_xsfp_dump.dump_param |= XSFP_RAW_DATA_BIT; return 0; } +int hikp_info_collect_nic_xsfp(void *data) +{ + struct nic_xsfp_collect_param *param = (struct nic_xsfp_collect_param *)data; + struct major_cmd_ctrl *major_cmd = get_major_cmd(); + int ret; + + memset(&g_xsfp_dump, 0, sizeof(g_xsfp_dump)); + + ret = hikp_xsfp_get_target(major_cmd, param->net_dev_name); + if (ret) + return ret; + + printf("hikptool nic_xsfp -i %s\n", param->net_dev_name); + hikp_xsfp_get_info(major_cmd); + + printf("hikptool nic_xsfp -i %s -d\n", param->net_dev_name); + /* No need to judge the return value */ + (void)hikp_xsfp_dump_raw_data(major_cmd, NULL); + hikp_xsfp_get_info(major_cmd); + + return ret; +} + static void cmd_get_xsfp_info(void) { struct major_cmd_ctrl *major_cmd = get_major_cmd(); diff --git a/net/nic/nic_mac/hikp_nic_xsfp.h b/net/nic/nic_mac/hikp_nic_xsfp.h index 50cbb2df11c412ddc006efdc641dcf2be05319e7..7db969390f09397070211ba2a6fc62f60a04b23f 100644 --- a/net/nic/nic_mac/hikp_nic_xsfp.h +++ b/net/nic/nic_mac/hikp_nic_xsfp.h @@ -549,4 +549,10 @@ struct hikp_xsfp_ctrl { uint32_t dump_param; }; +struct nic_xsfp_collect_param { + const char *net_dev_name; +}; + +int hikp_info_collect_nic_xsfp(void *data); + #endif /* HIKP_NIC_XSFP_H */ diff --git a/net/nic/nic_ncsi/hikp_nic_ncsi.c b/net/nic/nic_ncsi/hikp_nic_ncsi.c index 2e1ea1138fad005254611e1b30051ef4700a42a4..955e456a1b73d37a8c43bc858e81c25fda1aad58 100644 --- a/net/nic/nic_ncsi/hikp_nic_ncsi.c +++ b/net/nic/nic_ncsi/hikp_nic_ncsi.c @@ -89,6 +89,8 @@ static int nic_ncsi_cmd_get_port_info(struct major_cmd_ctrl *self, const char *a static int nic_ncsi_cmd_show_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i "); printf("\n %s\n", self->cmd_ptr->help_info); printf("\n Options:\n\n"); @@ -100,6 +102,24 @@ static int nic_ncsi_cmd_show_help(struct major_cmd_ctrl *self, const char *argv) return 0; } +int hikp_info_collect_nic_ncsi(void *data) +{ + struct nic_ncsi_collect_param *param = (struct nic_ncsi_collect_param *)data; + struct major_cmd_ctrl *major_cmd = get_major_cmd(); + int ret; + + memset(&g_ncsi_cmd_info, 0, sizeof(g_ncsi_cmd_info)); + + ret = nic_ncsi_cmd_get_port_info(major_cmd, param->net_dev_name); + if (ret) + return ret; + + printf("hikptool nic_ncsi -i %s\n", param->net_dev_name); + nic_ncsi_cmd_execute(major_cmd); + + return ret; +} + static void cmd_nic_get_ncsi_init(void) { struct major_cmd_ctrl *major_cmd = get_major_cmd(); diff --git a/net/nic/nic_ncsi/hikp_nic_ncsi.h b/net/nic/nic_ncsi/hikp_nic_ncsi.h index a391d20578452150542cc83ce7071149981632e2..56ab6533d9108ec4edd8a0a1ad617afd313a9d78 100644 --- a/net/nic/nic_ncsi/hikp_nic_ncsi.h +++ b/net/nic/nic_ncsi/hikp_nic_ncsi.h @@ -54,4 +54,10 @@ struct nic_ncsi_cmd_info { bool port_flag; }; +struct nic_ncsi_collect_param { + const char *net_dev_name; +}; + +int hikp_info_collect_nic_ncsi(void *data); + #endif /* HIKP_NIC_NCSI_H */ diff --git a/net/nic/nic_notify_pkt/hikp_nic_notify_pkt.c b/net/nic/nic_notify_pkt/hikp_nic_notify_pkt.c index 5cd8bfab1df0b88f7a2825c8f0b7d5e56ccb2071..c301dad9b62c7dc951a100d525405e7125809751 100644 --- a/net/nic/nic_notify_pkt/hikp_nic_notify_pkt.c +++ b/net/nic/nic_notify_pkt/hikp_nic_notify_pkt.c @@ -70,7 +70,7 @@ static void hikp_nic_notify_pkt_show(const struct nic_notify_pkt_info *info) printf("####################### END ###########################\n"); } -static void hikp_nic_notify_pkt_cmd_execute(struct major_cmd_ctrl *self) +void hikp_nic_notify_pkt_cmd_execute(struct major_cmd_ctrl *self) { struct bdf_t *bdf = &g_notify_pkt_target.bdf; struct nic_notify_pkt_info info = {0}; @@ -84,6 +84,8 @@ static void hikp_nic_notify_pkt_cmd_execute(struct major_cmd_ctrl *self) static int hikp_nic_notify_pkt_cmd_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i "); printf("\n %s\n", self->cmd_ptr->help_info); printf("\n Options:\n\n"); @@ -94,7 +96,7 @@ static int hikp_nic_notify_pkt_cmd_help(struct major_cmd_ctrl *self, const char return 0; } -static int hikp_nic_notify_pkt_get_target(struct major_cmd_ctrl *self, const char *argv) +int hikp_nic_notify_pkt_get_target(struct major_cmd_ctrl *self, const char *argv) { self->err_no = tool_check_and_get_valid_bdf_id(argv, &g_notify_pkt_target); if (self->err_no != 0) { diff --git a/net/nic/nic_notify_pkt/hikp_nic_notify_pkt.h b/net/nic/nic_notify_pkt/hikp_nic_notify_pkt.h index 8bdb795421dc24f9fc70d3881650b66f41bb13ae..26a86fed4d826ed6b05f80f12d530209b55ae580 100644 --- a/net/nic/nic_notify_pkt/hikp_nic_notify_pkt.h +++ b/net/nic/nic_notify_pkt/hikp_nic_notify_pkt.h @@ -49,4 +49,6 @@ struct nic_notify_pkt_info { #define HIKP_NOTIFY_PKT_CFG_PKT_NUM_M GENMASK(5, 2) #define HIKP_NOTIFY_PKT_CFG_PKT_NUM_S 2 +int hikp_nic_notify_pkt_get_target(struct major_cmd_ctrl *self, const char *argv); +void hikp_nic_notify_pkt_cmd_execute(struct major_cmd_ctrl *self); #endif /* HIKP_NIC_NOTIFY_PKT_H */ diff --git a/net/nic/nic_ppp/hikp_nic_ppp.c b/net/nic/nic_ppp/hikp_nic_ppp.c index c19a5d0f366435a0e82918ab89f11f590e4a2eeb..d5cf61f1a75c4462f30d891f01981b6b873af06c 100644 --- a/net/nic/nic_ppp/hikp_nic_ppp.c +++ b/net/nic/nic_ppp/hikp_nic_ppp.c @@ -57,8 +57,17 @@ static const struct ppp_feature_cmd g_ppp_feature_cmd[] = { hikp_nic_query_ppp_by_blkid, hikp_nic_ppp_show_vlan_offload}, }; +void hikp_nic_ppp_set_cmd_param(int feature_idx) +{ + g_ppp_param.func_id = -1; + g_ppp_param.is_uc = -1; + g_ppp_param.feature_idx = feature_idx; +} + static int hikp_nic_ppp_cmd_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i "); printf("\n %s\n", self->cmd_ptr->help_info); printf("\n Options:\n\n"); @@ -781,6 +790,8 @@ static int hikp_nic_query_ppp_by_entryid(struct hikp_cmd_header *req_header, const struct ppp_feature_cmd *ppp_cmd; struct nic_ppp_req_para req_data = {0}; + HIKP_SET_USED(len); + req_data.bdf = *bdf; ppp_cmd = &g_ppp_feature_cmd[g_ppp_param.feature_idx]; if (strcmp(ppp_cmd->feature_name, NIC_PPP_MAC_TBL_NAME) == 0) @@ -1098,7 +1109,7 @@ static int hikp_nic_check_hw_res(struct hikp_nic_ppp_hw_resources *hw_res) return 0; } -static void hikp_nic_ppp_cmd_execute(struct major_cmd_ctrl *self) +void hikp_nic_ppp_cmd_execute(struct major_cmd_ctrl *self) { struct bdf_t *bdf = &g_ppp_param.target.bdf; const struct ppp_feature_cmd *ppp_cmd; @@ -1157,7 +1168,7 @@ out: hikp_nic_ppp_data_free(ppp_data); } -static int hikp_nic_cmd_get_ppp_target(struct major_cmd_ctrl *self, const char *argv) +int hikp_nic_cmd_get_ppp_target(struct major_cmd_ctrl *self, const char *argv) { self->err_no = tool_check_and_get_valid_bdf_id(argv, &(g_ppp_param.target)); if (self->err_no != 0) { diff --git a/net/nic/nic_ppp/hikp_nic_ppp.h b/net/nic/nic_ppp/hikp_nic_ppp.h index 659ed57db0b9ac332a6711e1123a4762ed3f82c2..d62962790f71a183f3bf3aa82e4ff96039e81f64 100644 --- a/net/nic/nic_ppp/hikp_nic_ppp.h +++ b/net/nic/nic_ppp/hikp_nic_ppp.h @@ -246,4 +246,7 @@ struct ppp_feature_cmd { void (*show)(const void *data); }; +void hikp_nic_ppp_set_cmd_param(int feature_idx); +int hikp_nic_cmd_get_ppp_target(struct major_cmd_ctrl *self, const char *argv); +void hikp_nic_ppp_cmd_execute(struct major_cmd_ctrl *self); #endif /* HIKP_NIC_PPP_H */ diff --git a/net/nic/nic_qos/hikp_nic_qos.c b/net/nic/nic_qos/hikp_nic_qos.c index c620a082fe3074468e1aded2584a0e86546e59f1..6435f7c7e23dcc995ccfebcec99d2d0a3862a548 100644 --- a/net/nic/nic_qos/hikp_nic_qos.c +++ b/net/nic/nic_qos/hikp_nic_qos.c @@ -33,8 +33,20 @@ static const struct qos_feature_cmd g_qos_feature_cmd[] = { hikp_nic_qos_show_pfc_storm_para}, }; +void hikp_nic_qos_set_cmd_feature_idx(int feature_idx) +{ + g_qos_param.feature_idx = feature_idx; +} + +void hikp_nic_qos_set_cmd_direction(enum nic_pfc_dir dir) +{ + g_qos_param.dir = dir; +} + static int hikp_nic_qos_cmd_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i "); printf("\n %s\n", self->cmd_ptr->help_info); printf("\n Options:\n\n"); @@ -242,7 +254,7 @@ static int hikp_nic_query_qos_feature(struct hikp_cmd_header *req_header, const return ret; } -static void hikp_nic_qos_cmd_execute(struct major_cmd_ctrl *self) +void hikp_nic_qos_cmd_execute(struct major_cmd_ctrl *self) { char *revision_id = g_qos_param.revision_id; struct bdf_t *bdf = &g_qos_param.target.bdf; @@ -265,7 +277,7 @@ static void hikp_nic_qos_cmd_execute(struct major_cmd_ctrl *self) } if (g_qos_param.feature_idx == NIC_PFC_STORM_PARA_DUMP && - g_qos_param.dir == NIC_QUEUE_DIR_NONE) { + g_qos_param.dir == NIC_QOS_DIR_NONE) { hikp_nic_qos_cmd_help(self, NULL); snprintf(self->err_str, sizeof(self->err_str), "-d/--dir param error!"); @@ -296,7 +308,7 @@ static void hikp_nic_qos_cmd_execute(struct major_cmd_ctrl *self) printf("#################### END #######################\n"); } -static int hikp_nic_cmd_get_qos_target(struct major_cmd_ctrl *self, const char *argv) +int hikp_nic_cmd_get_qos_target(struct major_cmd_ctrl *self, const char *argv) { self->err_no = tool_check_and_get_valid_bdf_id(argv, &(g_qos_param.target)); if (self->err_no != 0) { @@ -330,11 +342,11 @@ static int hikp_nic_cmd_qos_direct(struct major_cmd_ctrl *self, const char *argv) { if (strcmp(argv, "rx") == 0) { - g_qos_param.dir = NIC_RX_QUEUE; + g_qos_param.dir = NIC_RX_QOS; return 0; } if (strcmp(argv, "tx") == 0) { - g_qos_param.dir = NIC_TX_QUEUE; + g_qos_param.dir = NIC_TX_QOS; return 0; } @@ -350,7 +362,7 @@ static void cmd_nic_get_qos_init(void) struct major_cmd_ctrl *major_cmd = get_major_cmd(); g_qos_param.feature_idx = -1; - g_qos_param.dir = NIC_QUEUE_DIR_NONE; + g_qos_param.dir = NIC_QOS_DIR_NONE; major_cmd->option_count = 0; major_cmd->execute = hikp_nic_qos_cmd_execute; diff --git a/net/nic/nic_qos/hikp_nic_qos.h b/net/nic/nic_qos/hikp_nic_qos.h index 77fbdd99109608fa5ea81bd4da5fe982717804a4..6ff4e0563f1f0404c37ced4a70037067db21e21f 100644 --- a/net/nic/nic_qos/hikp_nic_qos.h +++ b/net/nic/nic_qos/hikp_nic_qos.h @@ -118,9 +118,9 @@ struct nic_qos_req_para { }; enum nic_pfc_dir { - NIC_RX_QUEUE = 0, - NIC_TX_QUEUE, - NIC_QUEUE_DIR_NONE, + NIC_RX_QOS = 0, + NIC_TX_QOS, + NIC_QOS_DIR_NONE, }; struct nic_qos_param { @@ -137,4 +137,8 @@ struct qos_feature_cmd { void (*show)(const void *data); }; +int hikp_nic_cmd_get_qos_target(struct major_cmd_ctrl *self, const char *argv); +void hikp_nic_qos_cmd_execute(struct major_cmd_ctrl *self); +void hikp_nic_qos_set_cmd_feature_idx(int feature_idx); +void hikp_nic_qos_set_cmd_direction(enum nic_pfc_dir dir); #endif /* HIKP_NIC_QOS_H */ diff --git a/net/nic/nic_queue/hikp_nic_queue.c b/net/nic/nic_queue/hikp_nic_queue.c index dafa05eaff8c6efa9580675998deee0db5a5e17f..dae634f352906398fdca8baf05501f62d12be8a0 100644 --- a/net/nic/nic_queue/hikp_nic_queue.c +++ b/net/nic/nic_queue/hikp_nic_queue.c @@ -32,8 +32,18 @@ static const struct queue_feature_cmd g_queue_feature_cmd[] = { {"func_map", QUEUE_FUNC_MAP, hikp_nic_queue_show_func_map}, }; +void hikp_nic_queue_cmd_set_param(int feature_idx, int qid, enum nic_queue_dir dir) +{ + g_queue_param.is_display_all = true; + g_queue_param.qid = qid; + g_queue_param.dir = dir; + g_queue_param.feature_idx = feature_idx; +} + static int hikp_nic_queue_cmd_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i "); printf("\n %s\n", self->cmd_ptr->help_info); printf("\n Options:\n\n"); @@ -340,7 +350,7 @@ static bool hikp_nic_queue_check_feature_para_vaild(const struct queue_feature_c return valid; } -static void hikp_nic_queue_cmd_execute(struct major_cmd_ctrl *self) +void hikp_nic_queue_cmd_execute(struct major_cmd_ctrl *self) { const struct queue_feature_cmd *queue_cmd; union nic_queue_feature_info *queue_data; @@ -387,7 +397,7 @@ out: free(queue_data); } -static int hikp_nic_cmd_get_queue_target(struct major_cmd_ctrl *self, const char *argv) +int hikp_nic_cmd_get_queue_target(struct major_cmd_ctrl *self, const char *argv) { self->err_no = tool_check_and_get_valid_bdf_id(argv, &(g_queue_param.target)); if (self->err_no != 0) { diff --git a/net/nic/nic_queue/hikp_nic_queue.h b/net/nic/nic_queue/hikp_nic_queue.h index fac39a0c728308f9f17dc1d17a9229c0f508cfdf..ca3541abfac97853a1eca9ed9112f50d775d7896 100644 --- a/net/nic/nic_queue/hikp_nic_queue.h +++ b/net/nic/nic_queue/hikp_nic_queue.h @@ -152,4 +152,8 @@ struct queue_feature_cmd { uint32_t sub_cmd_code; void (*show)(const void *data); }; + +int hikp_nic_cmd_get_queue_target(struct major_cmd_ctrl *self, const char *argv); +void hikp_nic_queue_cmd_execute(struct major_cmd_ctrl *self); +void hikp_nic_queue_cmd_set_param(int feature_idx, int qid, enum nic_queue_dir dir); #endif /* HIKP_NIC_QUEUE_H */ diff --git a/net/nic/nic_rss/hikp_nic_rss.c b/net/nic/nic_rss/hikp_nic_rss.c index 65336ffa331810f38c037b1d13ecd3470c197413..76cab8ae2e42f6351a407622b3fa8888cca418ca 100644 --- a/net/nic/nic_rss/hikp_nic_rss.c +++ b/net/nic/nic_rss/hikp_nic_rss.c @@ -132,8 +132,15 @@ static const struct rss_feature_cmd g_rss_feature_cmd[] = { {"tc_mode", RSS_TC_MODE_DUMP, hikp_nic_rss_show_tc_mode}, }; +void hikp_nic_rss_cmd_set_feature_idx(int feature_idx) +{ + g_rss_param.feature_idx = feature_idx; +} + static int hikp_nic_rss_cmd_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i "); printf("\n %s\n", self->cmd_ptr->help_info); printf("\n Options:\n\n"); @@ -417,7 +424,7 @@ static int hikp_nic_query_rss_feature(struct hikp_cmd_header *req_header, const return ret; } -static void hikp_nic_rss_cmd_execute(struct major_cmd_ctrl *self) +void hikp_nic_rss_cmd_execute(struct major_cmd_ctrl *self) { union nic_rss_feature_info rss_data = {0}; const struct rss_feature_cmd *rss_cmd; @@ -446,7 +453,7 @@ static void hikp_nic_rss_cmd_execute(struct major_cmd_ctrl *self) printf("#################### END #######################\n"); } -static int hikp_nic_cmd_get_rss_target(struct major_cmd_ctrl *self, const char *argv) +int hikp_nic_cmd_get_rss_target(struct major_cmd_ctrl *self, const char *argv) { self->err_no = tool_check_and_get_valid_bdf_id(argv, &(g_rss_param.target)); if (self->err_no != 0) { diff --git a/net/nic/nic_rss/hikp_nic_rss.h b/net/nic/nic_rss/hikp_nic_rss.h index 39b33002105377cf6717c2dadd61e2fd1d79f87a..47aa2b9d59d1965dc01d01dec6362aee6b9c69d7 100644 --- a/net/nic/nic_rss/hikp_nic_rss.h +++ b/net/nic/nic_rss/hikp_nic_rss.h @@ -91,4 +91,7 @@ struct rss_feature_cmd { void (*show)(const void *data); }; +int hikp_nic_cmd_get_rss_target(struct major_cmd_ctrl *self, const char *argv); +void hikp_nic_rss_cmd_execute(struct major_cmd_ctrl *self); +void hikp_nic_rss_cmd_set_feature_idx(int feature_idx); #endif /* HIKP_NIC_RSS_H */ diff --git a/net/nic/nic_torus/hikp_nic_torus.c b/net/nic/nic_torus/hikp_nic_torus.c index 5208bdc7e26f4ab9929f3c38fa048cf7129f3125..7ad5211156638dd7b29f8e62f18e72ec6003b3a3 100644 --- a/net/nic/nic_torus/hikp_nic_torus.c +++ b/net/nic/nic_torus/hikp_nic_torus.c @@ -130,7 +130,7 @@ static void hikp_nic_torus_show(const struct nic_torus_info *info) printf("#################### END ##########################\n"); } -static void hikp_nic_torus_cmd_execute(struct major_cmd_ctrl *self) +void hikp_nic_torus_cmd_execute(struct major_cmd_ctrl *self) { struct bdf_t *bdf = &g_torus_target.bdf; struct nic_torus_info info = { 0 }; @@ -148,6 +148,8 @@ static void hikp_nic_torus_cmd_execute(struct major_cmd_ctrl *self) static int hikp_nic_torus_cmd_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i "); printf("\n %s\n", self->cmd_ptr->help_info); printf("\n Options:\n\n"); @@ -158,7 +160,7 @@ static int hikp_nic_torus_cmd_help(struct major_cmd_ctrl *self, const char *argv return 0; } -static int hikp_nic_torus_get_target(struct major_cmd_ctrl *self, const char *argv) +int hikp_nic_torus_get_target(struct major_cmd_ctrl *self, const char *argv) { self->err_no = tool_check_and_get_valid_bdf_id(argv, &g_torus_target); if (self->err_no != 0) { diff --git a/net/nic/nic_torus/hikp_nic_torus.h b/net/nic/nic_torus/hikp_nic_torus.h index e6b65524d5ea81d0b9a84492f58007fd65eae4a1..064ffa39620222ec848458276582211dc070a208 100644 --- a/net/nic/nic_torus/hikp_nic_torus.h +++ b/net/nic/nic_torus/hikp_nic_torus.h @@ -73,4 +73,6 @@ struct nic_torus_info { uint32_t ets_tcg0_mapping; }; +int hikp_nic_torus_get_target(struct major_cmd_ctrl *self, const char *argv); +void hikp_nic_torus_cmd_execute(struct major_cmd_ctrl *self); #endif /* HIKP_NIC_TORUS_H */ diff --git a/net/roce/roce_bond/hikp_roce_bond.c b/net/roce/roce_bond/hikp_roce_bond.c index 8434a0bde7d04f654850ca3442bed4839205340b..244f29cbe1f479b7c652d7512b0c3edbbe1e6aee 100644 --- a/net/roce/roce_bond/hikp_roce_bond.c +++ b/net/roce/roce_bond/hikp_roce_bond.c @@ -15,8 +15,16 @@ static struct cmd_roce_bond_param g_roce_bond_param = { 0 }; +int hikp_roce_set_bond_bdf(char *nic_name) +{ + return tool_check_and_get_valid_bdf_id(nic_name, + &g_roce_bond_param.target); +} + static int hikp_roce_bond_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i \n"); printf("\n %s\n", self->cmd_ptr->help_info); printf(" Options:\n\n"); @@ -45,6 +53,8 @@ static int hikp_roce_bond_get_data(struct hikp_cmd_ret **cmd_ret, uint32_t req_size; int ret; + HIKP_SET_USED(reg_name); + req_data.bdf = g_roce_bond_param.target.bdf; req_data.block_id = block_id; @@ -60,7 +70,7 @@ static int hikp_roce_bond_get_data(struct hikp_cmd_ret **cmd_ret, return ret; } -static void hikp_roce_bond_execute(struct major_cmd_ctrl *self) +void hikp_roce_bond_execute(struct major_cmd_ctrl *self) { hikp_roce_ext_execute(self, GET_ROCEE_BOND_CMD, hikp_roce_bond_get_data); } diff --git a/net/roce/roce_bond/hikp_roce_bond.h b/net/roce/roce_bond/hikp_roce_bond.h index 5e18723bc948c98fa2be208c86bac9321ea08428..2f617272df455fd51f6c60c4c4eb54c419c9efe8 100644 --- a/net/roce/roce_bond/hikp_roce_bond.h +++ b/net/roce/roce_bond/hikp_roce_bond.h @@ -26,4 +26,7 @@ struct roce_bond_req_param { uint32_t block_id; }; +int hikp_roce_set_bond_bdf(char *nic_name); +void hikp_roce_bond_execute(struct major_cmd_ctrl *self); + #endif /* HIKP_ROCE_BOND_H */ diff --git a/net/roce/roce_caep/hikp_roce_caep.c b/net/roce/roce_caep/hikp_roce_caep.c index a52cd543e20da14492879f729608a5838bcf346b..290aa182eb4a94219e15992592f897cc6f0526c6 100644 --- a/net/roce/roce_caep/hikp_roce_caep.c +++ b/net/roce/roce_caep/hikp_roce_caep.c @@ -15,8 +15,21 @@ static struct cmd_roce_caep_param_t g_roce_caep_param_t = { 0 }; +int hikp_roce_set_caep_bdf(char *nic_name) +{ + return tool_check_and_get_valid_bdf_id(nic_name, + &g_roce_caep_param_t.target); +} + +void hikp_roce_set_caep_mode(uint32_t mode) +{ + g_roce_caep_param_t.sub_cmd = mode; +} + static int hikp_roce_caep_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i \n"); printf("\n %s\n", self->cmd_ptr->help_info); printf(" Options:\n\n"); @@ -48,6 +61,8 @@ static int hikp_roce_caep_get_data(struct hikp_cmd_ret **cmd_ret, uint32_t req_size; int ret; + HIKP_SET_USED(reg_name); + req_data_ext.origin_param.bdf = g_roce_caep_param_t.target.bdf; req_data_ext.block_id = block_id; @@ -102,7 +117,7 @@ exec_error: hikp_cmd_free(&cmd_ret); } -static void hikp_roce_caep_execute(struct major_cmd_ctrl *self) +void hikp_roce_caep_execute(struct major_cmd_ctrl *self) { if (g_roce_caep_param_t.sub_cmd == CAEP_ORIGIN) hikp_roce_caep_execute_origin(self); @@ -113,6 +128,9 @@ static void hikp_roce_caep_execute(struct major_cmd_ctrl *self) static int hikp_roce_caep_ext_set(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_roce_caep_param_t.sub_cmd = CAEP_EXT; return 0; diff --git a/net/roce/roce_caep/hikp_roce_caep.h b/net/roce/roce_caep/hikp_roce_caep.h index becb332318f4d146d059225cb989da262daa1fe8..770e2ab5096099b33b73c47fb1f5a9eb11c21f7e 100644 --- a/net/roce/roce_caep/hikp_roce_caep.h +++ b/net/roce/roce_caep/hikp_roce_caep.h @@ -48,4 +48,8 @@ enum roce_caep_cmd_type { CAEP_EXT, }; +int hikp_roce_set_caep_bdf(char *nic_name); +void hikp_roce_set_caep_mode(uint32_t mode); +void hikp_roce_caep_execute(struct major_cmd_ctrl *self); + #endif /* HIKP_ROCE_CAEP_H */ diff --git a/net/roce/roce_global_cfg/hikp_roce_global_cfg.c b/net/roce/roce_global_cfg/hikp_roce_global_cfg.c index 18df065c2a54556c13d86ef157531edc84320c94..8b0d93a15cce9428a412c64b7e2f06449bc6de91 100644 --- a/net/roce/roce_global_cfg/hikp_roce_global_cfg.c +++ b/net/roce/roce_global_cfg/hikp_roce_global_cfg.c @@ -15,9 +15,17 @@ static struct cmd_roce_global_cfg_param g_roce_global_cfg_param = { 0 }; +int hikp_roce_set_global_cfg_bdf(char *nic_name) +{ + return tool_check_and_get_valid_bdf_id(nic_name, + &g_roce_global_cfg_param.target); +} + static int hikp_roce_global_cfg_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i \n"); printf("\n %s\n", self->cmd_ptr->help_info); printf(" Options:\n\n"); @@ -48,6 +56,8 @@ static int hikp_roce_global_cfg_get_data(struct hikp_cmd_ret **cmd_ret, uint32_t req_size; int ret; + HIKP_SET_USED(reg_name); + req_data.bdf = g_roce_global_cfg_param.target.bdf; req_data.block_id = block_id; @@ -63,7 +73,7 @@ static int hikp_roce_global_cfg_get_data(struct hikp_cmd_ret **cmd_ret, return ret; } -static void hikp_roce_global_cfg_execute(struct major_cmd_ctrl *self) +void hikp_roce_global_cfg_execute(struct major_cmd_ctrl *self) { enum roce_global_cfg_cmd_type sub_cmds[] = { ROCE_GLB_GENAC, @@ -75,7 +85,7 @@ static void hikp_roce_global_cfg_execute(struct major_cmd_ctrl *self) ROCE_GLB_TDP_M, ROCE_GLB_NICL, }; - int i; + size_t i; for (i = 0; i < HIKP_ARRAY_SIZE(sub_cmds); i++) { g_roce_global_cfg_param.sub_cmd = sub_cmds[i]; diff --git a/net/roce/roce_global_cfg/hikp_roce_global_cfg.h b/net/roce/roce_global_cfg/hikp_roce_global_cfg.h index aa1db92693d65782658e1b0216436a8491ba5cee..eb6f359a941831ed842b030066ec70fe20a344f3 100644 --- a/net/roce/roce_global_cfg/hikp_roce_global_cfg.h +++ b/net/roce/roce_global_cfg/hikp_roce_global_cfg.h @@ -37,4 +37,7 @@ enum roce_global_cfg_cmd_type { ROCE_GLB_NICL, }; +int hikp_roce_set_global_cfg_bdf(char *nic_name); +void hikp_roce_global_cfg_execute(struct major_cmd_ctrl *self); + #endif /* HIKP_ROCE_GLOBAL_CFG_H */ diff --git a/net/roce/roce_gmv/hikp_roce_gmv.c b/net/roce/roce_gmv/hikp_roce_gmv.c index 1b7db32f3b74c176a8dd840a6fc56ee2adf15de7..92bead13d6ca0d5f96f9ab18c7bbc638788f3155 100644 --- a/net/roce/roce_gmv/hikp_roce_gmv.c +++ b/net/roce/roce_gmv/hikp_roce_gmv.c @@ -16,8 +16,21 @@ static struct cmd_roce_gmv_param g_roce_gmv_param = { 0 }; +int hikp_roce_set_gmv_bdf(char *nic_name) +{ + return tool_check_and_get_valid_bdf_id(nic_name, + &g_roce_gmv_param.target); +} + +void hikp_roce_set_gmv_index(uint32_t gmv_index) +{ + g_roce_gmv_param.gmv_index = gmv_index; +} + static int hikp_roce_gmv_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i \n"); printf("\n %s\n", self->cmd_ptr->help_info); printf(" Options:\n\n"); @@ -83,7 +96,7 @@ static void hikp_roce_gmv_print(uint32_t reg_num, struct roce_gmv_rsp_data *gmv_ printf("*******************************************\n"); } -static void hikp_roce_gmv_execute(struct major_cmd_ctrl *self) +void hikp_roce_gmv_execute(struct major_cmd_ctrl *self) { struct roce_gmv_req_para req_data = { 0 }; struct roce_gmv_rsp_data *gmv_rsp = NULL; @@ -92,6 +105,8 @@ static void hikp_roce_gmv_execute(struct major_cmd_ctrl *self) uint32_t reg_num; int ret; + HIKP_SET_USED(self); + req_data.bdf = g_roce_gmv_param.target.bdf; req_data.gmv_index = g_roce_gmv_param.gmv_index; hikp_cmd_init(&req_header, ROCE_MOD, GET_ROCEE_GMV_CMD, GMV_SHOW); diff --git a/net/roce/roce_gmv/hikp_roce_gmv.h b/net/roce/roce_gmv/hikp_roce_gmv.h index 8bc49d0fac5d456959f9fcb3dc584263b101e0bc..29c2e6dd3dc057c036837ee0df8558f3ba943f49 100644 --- a/net/roce/roce_gmv/hikp_roce_gmv.h +++ b/net/roce/roce_gmv/hikp_roce_gmv.h @@ -38,4 +38,8 @@ enum roce_gmv_cmd_type { GMV_SHOW = 0x0, }; +int hikp_roce_set_gmv_bdf(char *nic_name); +void hikp_roce_set_gmv_index(uint32_t gmv_index); +void hikp_roce_gmv_execute(struct major_cmd_ctrl *self); + #endif /* HIKP_ROCE_GMV_H */ diff --git a/net/roce/roce_mdb/hikp_roce_mdb.c b/net/roce/roce_mdb/hikp_roce_mdb.c index a578c875166c9f8296f128145b0e033d7ff00bfe..c0d028fc54ac7ef89b85c6ac5501c5fbf375f973 100644 --- a/net/roce/roce_mdb/hikp_roce_mdb.c +++ b/net/roce/roce_mdb/hikp_roce_mdb.c @@ -16,8 +16,21 @@ static struct cmd_roce_mdb_param g_roce_mdb_param = { 0 }; +int hikp_roce_set_mdb_bdf(char *nic_name) +{ + return tool_check_and_get_valid_bdf_id(nic_name, + &g_roce_mdb_param.target); +} + +void hikp_roce_set_mdb_mode(uint8_t mode) +{ + g_roce_mdb_param.flag = mode; +} + static int hikp_roce_mdb_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i \n"); printf("\n %s\n", self->cmd_ptr->help_info); printf(" Options:\n\n"); @@ -43,6 +56,9 @@ static int hikp_roce_mdb_target(struct major_cmd_ctrl *self, const char *argv) static int hikp_roce_mdb_clear_set(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_roce_mdb_param.flag |= ROCE_MDB_CMD_CLEAR; return 0; @@ -155,7 +171,7 @@ exec_error: hikp_cmd_free(&cmd_ret); } -static void hikp_roce_mdb_execute(struct major_cmd_ctrl *self) +void hikp_roce_mdb_execute(struct major_cmd_ctrl *self) { if (g_roce_mdb_param.flag & ROCE_MDB_CMD_EXT) { g_roce_mdb_param.sub_cmd = (g_roce_mdb_param.flag & ROCE_MDB_CMD_CLEAR) ? @@ -171,6 +187,9 @@ static void hikp_roce_mdb_execute(struct major_cmd_ctrl *self) static int hikp_roce_mdb_ext_set(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_roce_mdb_param.flag |= ROCE_MDB_CMD_EXT; return 0; diff --git a/net/roce/roce_mdb/hikp_roce_mdb.h b/net/roce/roce_mdb/hikp_roce_mdb.h index e8dfcca743f9c084647d4e4a78a35aa3629870f2..b95bb56f863c41836d528c02f44cf8bb75adf26b 100644 --- a/net/roce/roce_mdb/hikp_roce_mdb.h +++ b/net/roce/roce_mdb/hikp_roce_mdb.h @@ -20,6 +20,7 @@ #define ROCE_HIKP_REG_SWICTH 2 #define ROCE_MDB_CMD_CLEAR (1 << 0) +#define ROCE_MDB_CMD 0 #define ROCE_MDB_CMD_EXT (1 << 1) struct cmd_roce_mdb_param { @@ -49,4 +50,8 @@ enum roce_mdb_cmd_type { MDB_CLEAR_EXT, }; +int hikp_roce_set_mdb_bdf(char *nic_name); +void hikp_roce_set_mdb_mode(uint8_t mode); +void hikp_roce_mdb_execute(struct major_cmd_ctrl *self); + #endif /* HIKP_ROCE_MDB_H */ diff --git a/net/roce/roce_pkt/hikp_roce_pkt.c b/net/roce/roce_pkt/hikp_roce_pkt.c index 81bdae6140a32bae2b9cc82090eef2e79b9834d0..15387884a5a596fdc2decffebfe5c6f1013a8329 100644 --- a/net/roce/roce_pkt/hikp_roce_pkt.c +++ b/net/roce/roce_pkt/hikp_roce_pkt.c @@ -15,8 +15,16 @@ static struct cmd_roce_pkt_param_t g_roce_pkt_param_t = { 0 }; +int hikp_roce_set_pkt_bdf(char *nic_name) +{ + return tool_check_and_get_valid_bdf_id(nic_name, + &g_roce_pkt_param_t.target); +} + static int hikp_roce_pkt_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i \n"); printf("\n %s\n", self->cmd_ptr->help_info); printf(" Options:\n\n"); @@ -41,6 +49,9 @@ static int hikp_roce_pkt_target(struct major_cmd_ctrl *self, const char *argv) static int hikp_roce_pkt_clear_set(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_roce_pkt_param_t.reset_flag = 1; return 0; } @@ -96,7 +107,7 @@ static void hikp_roce_pkt_print(uint32_t total_block_num, printf("***********************************\n"); } -static void hikp_roce_pkt_execute(struct major_cmd_ctrl *self) +void hikp_roce_pkt_execute(struct major_cmd_ctrl *self) { struct roce_pkt_req_param req_data = { 0 }; struct roce_pkt_res_param *roce_pkt_res; diff --git a/net/roce/roce_pkt/hikp_roce_pkt.h b/net/roce/roce_pkt/hikp_roce_pkt.h index 05d464e65f49e0e81aabf711f167c3f11f70301e..7d23c8f583fcfda0cdcd7e51a9ac2e8a480f887b 100644 --- a/net/roce/roce_pkt/hikp_roce_pkt.h +++ b/net/roce/roce_pkt/hikp_roce_pkt.h @@ -39,4 +39,7 @@ struct roce_pkt_res_param { struct roce_pkt_res reg_data; }; +int hikp_roce_set_pkt_bdf(char *nic_name); +void hikp_roce_pkt_execute(struct major_cmd_ctrl *self); + #endif /* HIKP_ROCE_PKT_H */ diff --git a/net/roce/roce_qmm/hikp_roce_qmm.c b/net/roce/roce_qmm/hikp_roce_qmm.c index 814008003b99115be9f5324ca0cdb68b7e4ddf95..af327c2a90091bf4fff586c12b6f12387af971fe 100644 --- a/net/roce/roce_qmm/hikp_roce_qmm.c +++ b/net/roce/roce_qmm/hikp_roce_qmm.c @@ -16,8 +16,26 @@ static struct cmd_roce_qmm_param_t g_roce_qmm_param = { 0 }; +int hikp_roce_set_qmm_bdf(char *nic_name) +{ + return tool_check_and_get_valid_bdf_id(nic_name, + &g_roce_qmm_param.target); +} + +void hikp_roce_set_qmm_ext_flag(bool ext_flag) +{ + g_roce_qmm_param.ext_flag = ext_flag; +} + +void hikp_roce_set_qmm_bankid(uint32_t bank_id) +{ + g_roce_qmm_param.bank_id = bank_id; +} + static int hikp_roce_qmm_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i \n"); printf("\n %s\n", self->cmd_ptr->help_info); printf(" Options:\n\n"); @@ -192,7 +210,8 @@ static int hikp_roce_qmm_get_data(struct hikp_cmd_ret **cmd_ret, struct roce_qmm_req_para_ext req_data_ext; struct hikp_cmd_header req_header = { 0 }; uint32_t req_size; - int ret, i; + size_t i; + int ret; if (reg_name) { for (i = 0; i < HIKP_ARRAY_SIZE(g_qmm_reg_name_info_table); i++) { @@ -249,7 +268,7 @@ exec_error: hikp_cmd_free(&cmd_ret); } -static void hikp_roce_qmm_execute(struct major_cmd_ctrl *self) +void hikp_roce_qmm_execute(struct major_cmd_ctrl *self) { static const struct cmd_type_info { enum roce_qmm_cmd_type sub_cmd; @@ -261,7 +280,7 @@ static void hikp_roce_qmm_execute(struct major_cmd_ctrl *self) {QMM_SHOW_TOP, QMM_SHOW_TOP_EXT, "TOP"}, }; - for (int i = 0; i < HIKP_ARRAY_SIZE(sub_cmd_info_table); i++) { + for (size_t i = 0; i < HIKP_ARRAY_SIZE(sub_cmd_info_table); i++) { g_roce_qmm_param.sub_name = sub_cmd_info_table[i].sub_name; if (g_roce_qmm_param.ext_flag) { g_roce_qmm_param.sub_cmd = sub_cmd_info_table[i].sub_ext_cmd; @@ -282,6 +301,9 @@ static void hikp_roce_qmm_execute(struct major_cmd_ctrl *self) static int hikp_roce_qmm_ext_set(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_roce_qmm_param.ext_flag = true; return 0; diff --git a/net/roce/roce_qmm/hikp_roce_qmm.h b/net/roce/roce_qmm/hikp_roce_qmm.h index eb7722bf4c9d434f7462236aab6c232a1939cd21..b13a716c7cbe80adc8a5f003102f1364bc818f94 100644 --- a/net/roce/roce_qmm/hikp_roce_qmm.h +++ b/net/roce/roce_qmm/hikp_roce_qmm.h @@ -51,4 +51,9 @@ enum roce_qmm_cmd_type { QMM_SHOW_TOP_EXT, }; +int hikp_roce_set_qmm_bdf(char *nic_name); +void hikp_roce_set_qmm_ext_flag(bool ext_flag); +void hikp_roce_set_qmm_bankid(uint32_t bank_id); +void hikp_roce_qmm_execute(struct major_cmd_ctrl *self); + #endif /* HIKP_ROCE_QMM_H */ diff --git a/net/roce/roce_rst/hikp_roce_rst.c b/net/roce/roce_rst/hikp_roce_rst.c index 570e7f43e0d1d86ce06b047c16aa86ccfc79ba97..c49074b7cd89133ec86187d8a1fafd95722d5192 100644 --- a/net/roce/roce_rst/hikp_roce_rst.c +++ b/net/roce/roce_rst/hikp_roce_rst.c @@ -15,8 +15,16 @@ static struct cmd_roce_rst_param g_roce_rst_param = { 0 }; +int hikp_roce_set_rst_bdf(char *nic_name) +{ + return tool_check_and_get_valid_bdf_id(nic_name, + &g_roce_rst_param.target); +} + static int hikp_roce_rst_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i \n"); printf("\n %s\n", self->cmd_ptr->help_info); printf(" Options:\n\n"); @@ -45,6 +53,8 @@ static int hikp_roce_rst_get_data(struct hikp_cmd_ret **cmd_ret, uint32_t req_size; int ret; + HIKP_SET_USED(reg_name); + req_data.bdf = g_roce_rst_param.target.bdf; req_data.block_id = block_id; @@ -60,7 +70,7 @@ static int hikp_roce_rst_get_data(struct hikp_cmd_ret **cmd_ret, return ret; } -static void hikp_roce_rst_execute(struct major_cmd_ctrl *self) +void hikp_roce_rst_execute(struct major_cmd_ctrl *self) { hikp_roce_ext_execute(self, GET_ROCEE_RST_CMD, hikp_roce_rst_get_data); } diff --git a/net/roce/roce_rst/hikp_roce_rst.h b/net/roce/roce_rst/hikp_roce_rst.h index e864b68a721a707349cee0bc47d5c1f2f6adf5cc..782d0ffb373142961ecd1b18ae1182afc5aa23ba 100644 --- a/net/roce/roce_rst/hikp_roce_rst.h +++ b/net/roce/roce_rst/hikp_roce_rst.h @@ -26,4 +26,7 @@ struct roce_rst_req_param { uint32_t block_id; }; +int hikp_roce_set_rst_bdf(char *nic_name); +void hikp_roce_rst_execute(struct major_cmd_ctrl *self); + #endif /* HIKP_ROCE_RST_H */ diff --git a/net/roce/roce_scc/hikp_roce_scc.c b/net/roce/roce_scc/hikp_roce_scc.c index f330e974ca193c439ff89d3f4aafab7732d119d8..67a2a1ef15250eaafc4098b4828f5ebffbf734af 100644 --- a/net/roce/roce_scc/hikp_roce_scc.c +++ b/net/roce/roce_scc/hikp_roce_scc.c @@ -15,7 +15,7 @@ struct cmd_roce_scc_param_t g_roce_scc_param_t = { 0 }; struct roce_scc_module g_roce_scc_module[] = { - ROCE_SCC_HANDLE(COMMON), + { "COMMON", SCC_COMMON }, ROCE_SCC_HANDLE(DCQCN), ROCE_SCC_HANDLE(DIP), ROCE_SCC_HANDLE(HC3), @@ -23,8 +23,21 @@ struct roce_scc_module g_roce_scc_module[] = { ROCE_SCC_HANDLE(CFG), }; +int hikp_roce_set_scc_bdf(char *nic_name) +{ + return tool_check_and_get_valid_bdf_id(nic_name, + &g_roce_scc_param_t.target); +} + +void hikp_roce_set_scc_submodule(uint32_t module) +{ + g_roce_scc_param_t.sub_cmd = module; +} + static int hikp_roce_scc_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i \n"); printf("\n %s\n", self->cmd_ptr->help_info); printf(" Options:\n\n"); @@ -71,6 +84,9 @@ static int hikp_roce_scc_module_select(struct major_cmd_ctrl *self, const char * static int hikp_roce_scc_clear_set(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_roce_scc_param_t.reset_flag = 1; return 0; @@ -78,7 +94,7 @@ static int hikp_roce_scc_clear_set(struct major_cmd_ctrl *self, const char *argv static int hikp_roce_scc_clear_module_check(void) { - if (g_roce_scc_param_t.sub_cmd == COMMON) + if (g_roce_scc_param_t.sub_cmd == SCC_COMMON) return 0; return -EINVAL; @@ -292,7 +308,7 @@ static const struct reg_name_info { const char **reg_name; uint8_t arr_len; } g_scc_reg_name_info_table[] = { - {COMMON, g_scc_common_reg_name, HIKP_ARRAY_SIZE(g_scc_common_reg_name)}, + {SCC_COMMON, g_scc_common_reg_name, HIKP_ARRAY_SIZE(g_scc_common_reg_name)}, {DCQCN, g_scc_dcqcn_reg_name, HIKP_ARRAY_SIZE(g_scc_dcqcn_reg_name)}, {DIP, g_scc_dip_reg_name, HIKP_ARRAY_SIZE(g_scc_dip_reg_name)}, {HC3, g_scc_hc3_reg_name, HIKP_ARRAY_SIZE(g_scc_hc3_reg_name)}, @@ -330,7 +346,7 @@ static void hikp_roce_scc_print(uint8_t total_block_num, printf("***********************************\n"); } -static void hikp_roce_scc_execute(struct major_cmd_ctrl *self) +void hikp_roce_scc_execute(struct major_cmd_ctrl *self) { struct roce_scc_head res_head; uint32_t *offset_start = NULL; diff --git a/net/roce/roce_scc/hikp_roce_scc.h b/net/roce/roce_scc/hikp_roce_scc.h index 9b5c0c53b7fb1096b09cce965bc97dde61bd03d6..b86b59ac60d14fde3aa96d90908ee885ec4688d6 100644 --- a/net/roce/roce_scc/hikp_roce_scc.h +++ b/net/roce/roce_scc/hikp_roce_scc.h @@ -58,7 +58,7 @@ struct roce_scc_module { }; enum roce_scc_type { - COMMON = 1, + SCC_COMMON = 1, DCQCN, DIP, HC3, @@ -66,4 +66,8 @@ enum roce_scc_type { CFG, }; +int hikp_roce_set_scc_bdf(char *nic_name); +void hikp_roce_set_scc_submodule(uint32_t module); +void hikp_roce_scc_execute(struct major_cmd_ctrl *self); + #endif /* HIKP_ROCE_SCC_H */ diff --git a/net/roce/roce_timer/hikp_roce_timer.c b/net/roce/roce_timer/hikp_roce_timer.c index 962127b4f22c93d7ffea6403886045e7ed82bb96..927d8a636af67a66874aa5b49751f0a588a3c87d 100644 --- a/net/roce/roce_timer/hikp_roce_timer.c +++ b/net/roce/roce_timer/hikp_roce_timer.c @@ -15,8 +15,16 @@ static struct cmd_roce_timer_params g_roce_timer_param = { 0 }; +int hikp_roce_set_timer_bdf(char *nic_name) +{ + return tool_check_and_get_valid_bdf_id(nic_name, + &g_roce_timer_param.target); +} + static int hikp_roce_timer_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i \n"); printf("\n %s\n", self->cmd_ptr->help_info); printf(" Options:\n\n"); @@ -40,6 +48,9 @@ static int hikp_roce_timer_target(struct major_cmd_ctrl *self, const char *argv) static int hikp_roce_timer_clear_set(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_roce_timer_param.flag = ROCE_TIMER_CMD_CLEAR; return 0; } @@ -114,6 +125,8 @@ static int hikp_roce_timer_show_qpc(struct major_cmd_ctrl *self) struct hikp_cmd_ret *cmd_ret = NULL; int ret; + HIKP_SET_USED(self); + req_data.bdf = g_roce_timer_param.target.bdf; if (g_roce_timer_param.flag) hikp_cmd_init(&req_header, ROCE_MOD, GET_ROCEE_TIMER_CMD, TIMER_QPC_CLEAR); @@ -147,6 +160,8 @@ static int hikp_roce_timer_show_cqc(struct major_cmd_ctrl *self) struct hikp_cmd_ret *cmd_ret = NULL; int ret; + HIKP_SET_USED(self); + req_data.bdf = g_roce_timer_param.target.bdf; if (g_roce_timer_param.flag) hikp_cmd_init(&req_header, ROCE_MOD, GET_ROCEE_TIMER_CMD, TIMER_CQC_CLEAR); @@ -192,13 +207,13 @@ static int hikp_roce_timer_clear(struct major_cmd_ctrl *self) return 0; } -static void hikp_roce_timer_execute(struct major_cmd_ctrl *self) +void hikp_roce_timer_execute(struct major_cmd_ctrl *self) { int (*func[])(struct major_cmd_ctrl *self) = { hikp_roce_timer_show_cqc, hikp_roce_timer_show_qpc }; const char *function[] = {"show cqc", "show qpc"}; - int i = 0; + size_t i = 0; int ret; if (g_roce_timer_param.flag) { diff --git a/net/roce/roce_timer/hikp_roce_timer.h b/net/roce/roce_timer/hikp_roce_timer.h index 314547e2abe1643ca189a4ad77c4fe458d1297b6..f82afe1e8171a9023cad6eec0b9c1c6334981b2d 100644 --- a/net/roce/roce_timer/hikp_roce_timer.h +++ b/net/roce/roce_timer/hikp_roce_timer.h @@ -40,4 +40,7 @@ struct roce_timer_rsp_data { uint32_t timer_content[ROCE_HIKP_TIMER_REG_NUM][2]; }; +int hikp_roce_set_timer_bdf(char *nic_name); +void hikp_roce_timer_execute(struct major_cmd_ctrl *self); + #endif /* HIKP_ROCE_TIMER_H */ diff --git a/net/roce/roce_trp/hikp_roce_trp.c b/net/roce/roce_trp/hikp_roce_trp.c index 68c4cf208e87dc04660d00623b891929040041b4..67dfb8e1aee9cbb202720c4607a585b4033505d7 100644 --- a/net/roce/roce_trp/hikp_roce_trp.c +++ b/net/roce/roce_trp/hikp_roce_trp.c @@ -18,11 +18,29 @@ struct roce_trp_module g_roce_trp_module[] = { ROCE_TRP_HANDLE(TRP_RX), ROCE_TRP_HANDLE(GEN_AC), ROCE_TRP_HANDLE(PAYL), - ROCE_TRP_HANDLE(COMMON), + { "COMMON", TRP_COMMON }, }; +int hikp_roce_set_trp_bdf(char *nic_name) +{ + return tool_check_and_get_valid_bdf_id(nic_name, + &g_roce_trp_param_t.target); +} + +void hikp_roce_set_trp_bankid(uint32_t bank_id) +{ + g_roce_trp_param_t.bank_id = bank_id; +} + +void hikp_roce_set_trp_submodule(uint32_t module) +{ + g_roce_trp_param_t.sub_cmd = module; +} + static int hikp_roce_trp_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i \n"); printf("\n %s\n", self->cmd_ptr->help_info); printf(" Options:\n\n"); @@ -86,7 +104,7 @@ static int hikp_roce_trp_bank_get(struct major_cmd_ctrl *self, const char *argv) static int hikp_roce_trp_bank_check(void) { switch (g_roce_trp_param_t.sub_cmd) { - case (COMMON): + case (TRP_COMMON): if (g_roce_trp_param_t.bank_id > TRP_MAX_BANK_NUM) return -EINVAL; break; @@ -341,7 +359,7 @@ static const struct reg_name_info { const char **reg_name; uint8_t arr_len; } g_trp_reg_name_info_table[] = { - {COMMON, g_trp_common_reg_name, HIKP_ARRAY_SIZE(g_trp_common_reg_name)}, + {TRP_COMMON, g_trp_common_reg_name, HIKP_ARRAY_SIZE(g_trp_common_reg_name)}, {TRP_RX, g_trp_trp_rx_reg_name, HIKP_ARRAY_SIZE(g_trp_trp_rx_reg_name)}, {GEN_AC, g_trp_gen_ac_reg_name, HIKP_ARRAY_SIZE(g_trp_gen_ac_reg_name)}, {PAYL, g_trp_payl_reg_name, HIKP_ARRAY_SIZE(g_trp_payl_reg_name)}, @@ -377,7 +395,7 @@ static void hikp_roce_trp_print(uint8_t total_block_num, printf("***********************************\n"); } -static void hikp_roce_trp_execute(struct major_cmd_ctrl *self) +void hikp_roce_trp_execute(struct major_cmd_ctrl *self) { struct roce_trp_head res_head; uint32_t *offset_start = NULL; diff --git a/net/roce/roce_trp/hikp_roce_trp.h b/net/roce/roce_trp/hikp_roce_trp.h index 212d36fee83c35d4f1fe4d6b13b4f60f1bab4834..023e290d1e5cad21abb3bdac7a63cb3ae03e0f02 100644 --- a/net/roce/roce_trp/hikp_roce_trp.h +++ b/net/roce/roce_trp/hikp_roce_trp.h @@ -67,7 +67,12 @@ enum roce_trp_type { TRP_RX = 1, GEN_AC, PAYL, - COMMON, + TRP_COMMON, }; +void hikp_roce_set_trp_submodule(uint32_t module); +void hikp_roce_set_trp_bankid(uint32_t bank_id); +int hikp_roce_set_trp_bdf(char *nic_name); +void hikp_roce_trp_execute(struct major_cmd_ctrl *self); + #endif /* HIKP_ROCE_TRP_H */ diff --git a/net/roce/roce_tsp/hikp_roce_tsp.c b/net/roce/roce_tsp/hikp_roce_tsp.c index 9dd79564fd8f8ac19493dd350a7e0b1b4500715b..5fe2104ef26a53a0ee4531b9d6b0f9f9abebded8 100644 --- a/net/roce/roce_tsp/hikp_roce_tsp.c +++ b/net/roce/roce_tsp/hikp_roce_tsp.c @@ -15,13 +15,31 @@ static struct cmd_roce_tsp_param_t g_roce_tsp_param_t = { 0 }; static struct roce_tsp_module g_roce_tsp_module[] = { - TSP_HANDLE(COMMON), + { "COMMON", TSP_COMMON }, TSP_HANDLE(TDP), TSP_HANDLE(TGP_TMP), }; +int hikp_roce_set_tsp_bdf(char *nic_name) +{ + return tool_check_and_get_valid_bdf_id(nic_name, + &g_roce_tsp_param_t.target); +} + +void hikp_roce_set_tsp_bankid(uint32_t bank_id) +{ + g_roce_tsp_param_t.bank_id = bank_id; +} + +void hikp_roce_set_tsp_submodule(uint32_t module) +{ + g_roce_tsp_param_t.sub_cmd_code = module; +} + static int hikp_roce_tsp_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i \n"); printf("\n %s\n", self->cmd_ptr->help_info); printf(" Options:\n\n"); @@ -85,7 +103,7 @@ static int hikp_roce_tsp_bank_get(struct major_cmd_ctrl *self, const char *argv) static int hikp_roce_tsp_bank_check(void) { switch (g_roce_tsp_param_t.sub_cmd_code) { - case (COMMON): + case (TSP_COMMON): if (g_roce_tsp_param_t.bank_id > MAX_TSP_BANK_NUM) return -EINVAL; break; @@ -102,6 +120,9 @@ static int hikp_roce_tsp_bank_check(void) static int hikp_roce_tsp_clear_set(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_roce_tsp_param_t.reset_flag = 1; return 0; @@ -194,9 +215,11 @@ static const struct reg_name_info { const char **reg_name; uint8_t arr_len; } g_tsp_reg_name_info_table[] = { - {COMMON, g_tsp_common_reg_name, HIKP_ARRAY_SIZE(g_tsp_common_reg_name)}, + {TSP_COMMON, g_tsp_common_reg_name, + HIKP_ARRAY_SIZE(g_tsp_common_reg_name)}, {TDP, g_tsp_tdp_reg_name, HIKP_ARRAY_SIZE(g_tsp_tdp_reg_name)}, - {TGP_TMP, g_tsp_tgp_tmp_reg_name, HIKP_ARRAY_SIZE(g_tsp_tgp_tmp_reg_name)}, + {TGP_TMP, g_tsp_tgp_tmp_reg_name, + HIKP_ARRAY_SIZE(g_tsp_tgp_tmp_reg_name)}, }; static void hikp_roce_tsp_print(uint32_t total_block_num, @@ -229,7 +252,7 @@ static void hikp_roce_tsp_print(uint32_t total_block_num, printf("***********************************\n"); } -static void hikp_roce_tsp_execute(struct major_cmd_ctrl *self) +void hikp_roce_tsp_execute(struct major_cmd_ctrl *self) { struct roce_tsp_res_param *roce_tsp_res; struct roce_tsp_req_param req_data; diff --git a/net/roce/roce_tsp/hikp_roce_tsp.h b/net/roce/roce_tsp/hikp_roce_tsp.h index a35f869e04784a2e985366f59dfe55b196f6da7b..12bd0a3b91bd7cc6b7cdcfd6281f15d0e75de019 100644 --- a/net/roce/roce_tsp/hikp_roce_tsp.h +++ b/net/roce/roce_tsp/hikp_roce_tsp.h @@ -56,9 +56,14 @@ struct roce_tsp_module { }; enum roce_tsp_sub_cmd_code { - COMMON = 1, + TSP_COMMON = 1, TDP, TGP_TMP, }; +int hikp_roce_set_tsp_bdf(char *nic_name); +void hikp_roce_set_tsp_bankid(uint32_t bank_id); +void hikp_roce_set_tsp_submodule(uint32_t module); +void hikp_roce_tsp_execute(struct major_cmd_ctrl *self); + #endif /* HIKP_ROCE_TSP_H */ diff --git a/net/roh/hikp_roh_mac.c b/net/roh/hikp_roh_mac.c index aa13f92d2b4566e7af08a1f236a47f0525aeef7d..e16a3db8a5edcdff04c66c06a905de84ba164b13 100644 --- a/net/roh/hikp_roh_mac.c +++ b/net/roh/hikp_roh_mac.c @@ -18,6 +18,8 @@ static struct roh_mac_param g_roh_mac_param = { 0 }; static int hikp_roh_mac_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i -s \n"); printf("\n %s\n", self->cmd_ptr->help_info); @@ -96,7 +98,7 @@ int hikp_roh_get_mac_type(struct major_cmd_ctrl *self, struct bdf_t bdf) return is_roh; } -static void hikp_roh_show_mac_type(struct major_cmd_ctrl *self, int mac_type) +static void hikp_roh_show_mac_type(int mac_type) { if (mac_type) printf("MAC_TYPE: ROH\n"); @@ -382,7 +384,7 @@ static void hikp_roh_mac_execute_entry(struct major_cmd_ctrl *self) HIKP_ERROR_PRINT("Failed get current mac type\n"); return; } - hikp_roh_show_mac_type(self, mac_type); + hikp_roh_show_mac_type(mac_type); break; case (CMD_SHOW_CAM_FLAG): if (hikp_roh_is_roh(self) > 0) diff --git a/net/roh/hikp_roh_show_bp.c b/net/roh/hikp_roh_show_bp.c index 0b53edad142fed50d91bf3142e3a1dddd8549ba5..edc1dc6872f0ff583c6b9b21ab7980b97580a02e 100644 --- a/net/roh/hikp_roh_show_bp.c +++ b/net/roh/hikp_roh_show_bp.c @@ -17,6 +17,8 @@ static struct cmd_roh_show_bp_param g_roh_show_bp_param = { 0 }; static int hikp_roh_show_bp_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i -s\n"); printf("\n %s\n", self->cmd_ptr->help_info); printf(" Options:\n\n"); @@ -115,6 +117,9 @@ static void hikp_roh_show_bp_execute(struct major_cmd_ctrl *self) static int hikp_roh_show_bp_parse(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_roh_show_bp_param.flag |= ROH_CMD_SHOW_BP; return 0; } diff --git a/net/roh/hikp_roh_show_mib.c b/net/roh/hikp_roh_show_mib.c index 5f03355b9290ef93946668298debe3914143e16c..96dd688f665beda8c20e0e17deb64266c8d3fa76 100644 --- a/net/roh/hikp_roh_show_mib.c +++ b/net/roh/hikp_roh_show_mib.c @@ -151,6 +151,8 @@ static char g_roh_mac_mib_name[MIB_EVENT_COUNT][ROH_NAME_MAX] = { static int hikp_roh_show_mib_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i -s\n"); printf("\n %s\n", self->cmd_ptr->help_info); printf(" Options:\n\n"); @@ -253,6 +255,9 @@ static void hikp_roh_show_mib_execute(struct major_cmd_ctrl *self) static int hikp_roh_show_mib_parse(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + roh_show_mib_param.flag |= ROH_CMD_SHOW_MIB; return 0; } diff --git a/net/ub/ub_bp/hikp_ub_bp.c b/net/ub/ub_bp/hikp_ub_bp.c index 179aa22d2ac352ceda24e19b6631cd3a309daf29..2dfe69cbef594089df0add1035fbac3e8ea233dc 100644 --- a/net/ub/ub_bp/hikp_ub_bp.c +++ b/net/ub/ub_bp/hikp_ub_bp.c @@ -17,6 +17,8 @@ static struct ub_bp_param g_ub_bp_param = { 0 }; static int hikp_ub_bp_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i \n"); printf("\n %s\n", self->cmd_ptr->help_info); printf(" Options:\n\n"); diff --git a/net/ub/ub_crd/hikp_ub_crd.c b/net/ub/ub_crd/hikp_ub_crd.c index 6d2ba21e76c5d6bc790c4546119360f7a0c9559c..678bc8433875ebdadb16710b6a6b3a0b0515ff2e 100644 --- a/net/ub/ub_crd/hikp_ub_crd.c +++ b/net/ub/ub_crd/hikp_ub_crd.c @@ -17,6 +17,8 @@ static struct ub_crd_param g_ub_crd_param = { 0 }; static int hikp_ub_crd_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i \n"); printf("\n %s\n", self->cmd_ptr->help_info); printf(" Options:\n\n"); diff --git a/net/ub/ub_dfx/hikp_ub_dfx.c b/net/ub/ub_dfx/hikp_ub_dfx.c index dd3a713812091792c917e916ba8f814e90c03eaa..8a3e293bf8e9ad78472de70f640b0e4e14c7a39f 100644 --- a/net/ub/ub_dfx/hikp_ub_dfx.c +++ b/net/ub/ub_dfx/hikp_ub_dfx.c @@ -44,6 +44,8 @@ static void dfx_help_info(const struct major_cmd_ctrl *self) static int hikp_ub_dfx_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + dfx_help_info(self); return 0; } diff --git a/net/ub/ub_info/hikp_ub_info.c b/net/ub/ub_info/hikp_ub_info.c index d113f7cb5c097b405e180d3e3e97f4eb5204c64e..ef58ff5443390daa5d81f4db5419be7077a82f6b 100644 --- a/net/ub/ub_info/hikp_ub_info.c +++ b/net/ub/ub_info/hikp_ub_info.c @@ -17,6 +17,8 @@ static struct ub_info_param g_ub_info_param = { 0 }; static int hikp_ub_info_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i \n"); printf("\n %s\n", self->cmd_ptr->help_info); printf(" Options:\n\n"); diff --git a/net/ub/ub_link/hikp_ub_link.c b/net/ub/ub_link/hikp_ub_link.c index 1cc1879afda6e889506622be01131f5984023b78..801e56eb6ef41ebb0203f237e11485360b31bd99 100644 --- a/net/ub/ub_link/hikp_ub_link.c +++ b/net/ub/ub_link/hikp_ub_link.c @@ -17,6 +17,8 @@ static struct ub_link_param g_ub_link_param = { 0 }; static int hikp_ub_link_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i \n"); printf("\n %s\n", self->cmd_ptr->help_info); printf(" Options:\n\n"); diff --git a/net/ub/ub_ppp/hikp_unic_ppp.c b/net/ub/ub_ppp/hikp_unic_ppp.c index 01c162482c6f54ceabafb21bacdb21d3452cd61d..4c48e705d743e2ed5cd0435897a442e867fb7e96 100644 --- a/net/ub/ub_ppp/hikp_unic_ppp.c +++ b/net/ub/ub_ppp/hikp_unic_ppp.c @@ -39,6 +39,8 @@ static const struct unic_ppp_feature_cmd g_unic_ppp_feature_cmd[] = { static int hikp_unic_ppp_cmd_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i "); printf("\n %s\n", self->cmd_ptr->help_info); printf("\n Options:\n\n"); @@ -209,8 +211,7 @@ static int hikp_unic_ppp_alloc_guid_tbl_entry(const struct hikp_unic_ppp_hw_reso } static union unic_ppp_feature_info* -hikp_unic_ppp_data_alloc(const struct unic_ppp_feature_cmd *unic_ppp_cmd, - const struct hikp_unic_ppp_hw_resources *hw_res) +hikp_unic_ppp_data_alloc(const struct hikp_unic_ppp_hw_resources *hw_res) { union unic_ppp_feature_info *unic_ppp_data; int ret = -1; @@ -461,7 +462,7 @@ static void hikp_unic_ppp_cmd_execute(struct major_cmd_ctrl *self) } unic_ppp_cmd = &g_unic_ppp_feature_cmd[g_unic_ppp_param.feature_idx]; - unic_ppp_data = hikp_unic_ppp_data_alloc(unic_ppp_cmd, &g_unic_ppp_hw_res); + unic_ppp_data = hikp_unic_ppp_data_alloc(&g_unic_ppp_hw_res); if (unic_ppp_data == NULL) { snprintf(self->err_str, sizeof(self->err_str), "failed to allocate unic_ppp_data memory!"); diff --git a/pcie/func_lib/pcie_func/pcie_link_ltssm.c b/pcie/func_lib/pcie_func/pcie_link_ltssm.c index d3534f5f72ac92e5dcf78a5c653d8f4b1f250648..695d40fcae9204857635015178a1442c70effd0a 100644 --- a/pcie/func_lib/pcie_func/pcie_link_ltssm.c +++ b/pcie/func_lib/pcie_func/pcie_link_ltssm.c @@ -69,7 +69,7 @@ union pm_state_reg { uint64_t val; }; -static int pcie_get_ltssm_trace(uint32_t port_id, uint64_t *ltssm_status, uint32_t *ltssm_num) +int pcie_get_ltssm_trace(uint32_t port_id, uint64_t *ltssm_status, uint32_t *ltssm_num) { struct hikp_cmd_header req_header; struct hikp_cmd_ret *cmd_ret = NULL; diff --git a/pcie/func_lib/pcie_func/pcie_link_ltssm.h b/pcie/func_lib/pcie_func/pcie_link_ltssm.h index 278f3e4d9e893d4f88eb92c6b42ce9c39924d9a5..9d025576673a38a076fece622520720848ebb4b8 100644 --- a/pcie/func_lib/pcie_func/pcie_link_ltssm.h +++ b/pcie/func_lib/pcie_func/pcie_link_ltssm.h @@ -59,5 +59,6 @@ int pcie_ltssm_trace_clear(uint32_t port_id); int pcie_ltssm_trace_mode_set(uint32_t port_id, uint32_t mode); int pcie_ltssm_link_status_get(uint32_t port_id); int pcie_pm_trace(uint32_t port_id); +int pcie_get_ltssm_trace(uint32_t port_id, uint64_t *ltssm_status, uint32_t *ltssm_num); #endif /* PCIE_LINK_LTSSM_H */ diff --git a/pcie/func_lib/pcie_func/pcie_reg_dump.c b/pcie/func_lib/pcie_func/pcie_reg_dump.c index abf0e266c5a9385efb6d4c1cb5e890635b50ec5b..ba6641ea18ffc0300f91a3a16abf77f8008fcdd5 100644 --- a/pcie/func_lib/pcie_func/pcie_reg_dump.c +++ b/pcie/func_lib/pcie_func/pcie_reg_dump.c @@ -17,13 +17,13 @@ #include #include #include -#include "tool_lib.h" #include "hikptdev_plug.h" #include "os_common.h" #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[] = { {0, "TL_ASPM_IDLE_CNT"}, @@ -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"}, @@ -134,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"}, @@ -255,7 +238,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 +351,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[] = { @@ -399,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", @@ -412,10 +394,13 @@ static int pcie_create_dumpreg_log_file(uint32_t port_id, uint32_t dump_level) if (ret) return -EINVAL; + memset(dumpreg_log_file, 0, sizeof(dumpreg_log_file)); + (void)strncpy((char *)dumpreg_log_file, file_name, MAX_LOG_NAME_LEN + 1); + (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; } @@ -424,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 >= sizeof(str)) { + 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"); } } @@ -457,7 +438,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}, }; @@ -486,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", @@ -496,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; } @@ -558,7 +538,7 @@ int pcie_dumpreg_do_dump(uint32_t port_id, uint32_t dump_level) struct pcie_dump_req_para req_data = { 0 }; int ret = 0; - Info("pcie reg dump start.\n"); + Info("hikptool pcie_dumpreg -i %u -l %u -d\n", port_id, dump_level); req_data.port_id = port_id; req_data.level = dump_level; @@ -582,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); diff --git a/pcie/func_lib/pcie_func/pcie_reg_dump.h b/pcie/func_lib/pcie_func/pcie_reg_dump.h index aaf22ba2a61b708a8de6a02f8b3a6c4fb0112e13..c74ce56ec3b6e36e0029d960523e950a2e06a785 100644 --- a/pcie/func_lib/pcie_func/pcie_reg_dump.h +++ b/pcie/func_lib/pcie_func/pcie_reg_dump.h @@ -15,20 +15,12 @@ #define PCIE_REG_DUMP_H #include "pcie_common_api.h" +#include "tool_lib.h" #define PCIE_REG_NAME_LEN 60 #define MAX_STR_LEN 80 #define PCIE_DUMPREG_LOGFILE_NAME "pcie_dumpreg" - -#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))} +#define LOG_FILE_PATH_MAX_LEN 512 enum pcie_dump_level { DUMP_GLOBAL_LEVEL = 1, @@ -54,6 +46,8 @@ struct pcie_dumpreg_table { struct pcie_dumpreg_info *dump_info; }; +extern char dumpreg_log_file[MAX_LOG_NAME_LEN + 1]; int pcie_dumpreg_do_dump(uint32_t port_id, uint32_t dump_level); + #endif /* PCIE_REG_DUMP_H */ diff --git a/pcie/func_lib/pcie_func/pcie_statistics.c b/pcie/func_lib/pcie_func/pcie_statistics.c index be187f2c87c6321e8f4da6ee2e436d15db869ac9..c7fee0bc9d5e1e12bbc30b68e3435a23eae6c0cd 100644 --- a/pcie/func_lib/pcie_func/pcie_statistics.c +++ b/pcie/func_lib/pcie_func/pcie_statistics.c @@ -29,7 +29,7 @@ static const char *g_global_ndie_name[] = { "Ndie_A", "Ndie_B", "Ndie_C", "Ndie_D" }; -static int port_distribution_rsp_data_check(const struct hikp_cmd_ret *cmd_ret, uint32_t *port_num) +int port_distribution_rsp_data_check(const struct hikp_cmd_ret *cmd_ret, uint32_t *port_num) { size_t rsp_data_size, expect_data_size; struct pcie_port_info *port_info = NULL; diff --git a/pcie/func_lib/pcie_func/pcie_statistics.h b/pcie/func_lib/pcie_func/pcie_statistics.h index c3735733faa9222e68abefdffd2ae9f58d2364e2..d7a68e275c7fa2b7070a6ba9c71921ebe1d9a407 100644 --- a/pcie/func_lib/pcie_func/pcie_statistics.h +++ b/pcie/func_lib/pcie_func/pcie_statistics.h @@ -15,6 +15,7 @@ #define PCIE_STATISTICS_H #include "pcie_common_api.h" +#include "hikptdev_plug.h" #define GLOBAL_WIDTH_TABLE_SIZE 5 #define MAX_MACRO_ONEPORT 3 @@ -126,5 +127,6 @@ struct pcie_info_req_para { int pcie_port_distribution_get(uint32_t chip_id); int pcie_error_state_get(uint32_t port_id); int pcie_error_state_clear(uint32_t port_id); +int port_distribution_rsp_data_check(const struct hikp_cmd_ret *cmd_ret, uint32_t *port_num); #endif /* PCIE_STATISTICS_H */ diff --git a/pcie/usr_cmd/cmd_analysis/pcie_cmd_dumpreg.c b/pcie/usr_cmd/cmd_analysis/pcie_cmd_dumpreg.c index 6d1c674327d3ebd29686970d285ecf2b79180a7e..8ec040476e55566fc5dc0c6dbdd6ea33aabeb39c 100644 --- a/pcie/usr_cmd/cmd_analysis/pcie_cmd_dumpreg.c +++ b/pcie/usr_cmd/cmd_analysis/pcie_cmd_dumpreg.c @@ -29,6 +29,8 @@ struct tool_pcie_cmd g_dumpreg_cmd = { static int pcie_dumpreg_help(struct major_cmd_ctrl *self, const char *argv) { + 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", "-i", "--interface", "please input port[x] first\n"); @@ -48,6 +50,8 @@ static int pcie_port_set(struct major_cmd_ctrl *self, const char *argv) uint32_t val; int ret; + HIKP_SET_USED(self); + ret = string_toui(argv, &val); if (ret) { printf("info set port id err %d.\n", ret); @@ -63,6 +67,8 @@ static int dump_level_set(struct major_cmd_ctrl *self, const char *argv) uint32_t val = 0; int ret; + HIKP_SET_USED(self); + ret = string_toui(argv, &val); if (ret || val < DUMP_GLOBAL_LEVEL || val > DUMP_PORT_LEVEL) { printf("info set id err, ret = %d, val = %u\n", ret, val); @@ -75,6 +81,9 @@ static int dump_level_set(struct major_cmd_ctrl *self, const char *argv) static int pcie_dumpreg_dump(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_dumpreg_cmd.cmd_type = DUMPREG_DUMP; return 0; diff --git a/pcie/usr_cmd/cmd_analysis/pcie_cmd_info.c b/pcie/usr_cmd/cmd_analysis/pcie_cmd_info.c index aeab241a6e38d634567426ec65fccf9c392a6bb1..f3bd46fba900285d0f402d9f7ecef563bb022fac 100644 --- a/pcie/usr_cmd/cmd_analysis/pcie_cmd_info.c +++ b/pcie/usr_cmd/cmd_analysis/pcie_cmd_info.c @@ -26,6 +26,8 @@ struct tool_pcie_cmd g_info_cmd = { static int pcie_info_help(struct major_cmd_ctrl *self, const char *argv) { + 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", "-i", "--interface", @@ -42,6 +44,9 @@ static int pcie_info_help(struct major_cmd_ctrl *self, const char *argv) static int pcie_distribution_show(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_info_cmd.cmd_type = INFO_DISTRIBUTION; return 0; @@ -49,6 +54,9 @@ static int pcie_distribution_show(struct major_cmd_ctrl *self, const char *argv) static int pcie_err_state_show(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_info_cmd.cmd_type = INFO_ERR_STATE_SHOW; return 0; @@ -56,6 +64,9 @@ static int pcie_err_state_show(struct major_cmd_ctrl *self, const char *argv) static int pcie_err_state_clear(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_info_cmd.cmd_type = INFO_ERR_STATE_CLEAR; return 0; @@ -66,6 +77,8 @@ static int pcie_port_chip_set(struct major_cmd_ctrl *self, const char *argv) uint32_t val; int ret; + HIKP_SET_USED(self); + ret = string_toui(argv, &val); if (ret) { printf("info set id err %d\n", ret); diff --git a/pcie/usr_cmd/cmd_analysis/pcie_cmd_reg_read.c b/pcie/usr_cmd/cmd_analysis/pcie_cmd_reg_read.c index 6e545164535ddf383598d83cf02f81b48a21d4c9..a88460459e63fb42145827d99cb477b27390b9a6 100644 --- a/pcie/usr_cmd/cmd_analysis/pcie_cmd_reg_read.c +++ b/pcie/usr_cmd/cmd_analysis/pcie_cmd_reg_read.c @@ -32,6 +32,8 @@ struct tool_pcie_cmd g_regread_cmd = { static int pcie_reg_read_help(struct major_cmd_ctrl *self, const char *argv) { + 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", "-i", "--interface", "please input port[x] first\n"); @@ -50,6 +52,8 @@ static int pcie_port_set(struct major_cmd_ctrl *self, const char *argv) uint32_t val; int ret; + HIKP_SET_USED(self); + ret = string_toui(argv, &val); if (ret) { printf("info set port id err %d.\n", ret); @@ -65,6 +69,8 @@ static int read_module_set(struct major_cmd_ctrl *self, const char *argv) uint32_t val; int ret; + HIKP_SET_USED(self); + ret = pcie_read_name2module_id(argv, &val); if (ret) { printf("undefined module \"%s\".\n", argv); @@ -80,6 +86,8 @@ static int read_offset_set(struct major_cmd_ctrl *self, const char *argv) uint32_t val; int ret; + HIKP_SET_USED(self); + ret = string_toui(argv, &val); if (ret) { printf("info set offset err %d.\n", ret); @@ -92,6 +100,9 @@ static int read_offset_set(struct major_cmd_ctrl *self, const char *argv) static int pcie_reg_read_exe(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_regread_cmd.cmd_type = REGRD_READ; return 0; diff --git a/pcie/usr_cmd/cmd_analysis/pcie_cmd_trace.c b/pcie/usr_cmd/cmd_analysis/pcie_cmd_trace.c index 8ceb85a305434e1947145e74a7d8f18c38a133ad..7b0efde1140919e35f824e45fbf451ed2a333005 100644 --- a/pcie/usr_cmd/cmd_analysis/pcie_cmd_trace.c +++ b/pcie/usr_cmd/cmd_analysis/pcie_cmd_trace.c @@ -27,6 +27,8 @@ struct tool_pcie_cmd g_trace_cmd = { static int pcie_trace_help(struct major_cmd_ctrl *self, const char *argv) { + 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", "-i", "--interface", "please input port[x] first\n"); @@ -45,6 +47,9 @@ static int pcie_trace_help(struct major_cmd_ctrl *self, const char *argv) static int pcie_trace_clear(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_trace_cmd.cmd_type = TRACE_CLEAR; return 0; @@ -53,6 +58,9 @@ static int pcie_trace_clear(struct major_cmd_ctrl *self, const char *argv) static int pcie_trace_show(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_trace_cmd.cmd_type = TRACE_SHOW; return 0; @@ -60,6 +68,9 @@ static int pcie_trace_show(struct major_cmd_ctrl *self, const char *argv) static int pcie_pm_show(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_trace_cmd.cmd_type = TRACE_PM; return 0; @@ -70,6 +81,8 @@ static int pcie_trace_mode_set(struct major_cmd_ctrl *self, const char *argv) int ret; uint32_t val = 0; + HIKP_SET_USED(self); + g_trace_cmd.cmd_type = TRACE_MODE; ret = string_toui(argv, &val); if (ret || val > 1) { @@ -83,6 +96,9 @@ static int pcie_trace_mode_set(struct major_cmd_ctrl *self, const char *argv) static int pcie_link_information_get(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_trace_cmd.cmd_type = TRACE_INFO; return 0; } @@ -92,6 +108,8 @@ static int pcie_port_id_set(struct major_cmd_ctrl *self, const char *argv) uint32_t val; int ret; + HIKP_SET_USED(self); + ret = string_toui(argv, &val); if (ret) { printf("trace set port id err %d\n", ret); diff --git a/sas/sas_func/sas_analy_queue.c b/sas/sas_func/sas_analy_queue.c index f1d2e7eb8e8e0f2ba1c533eedf3fafbdbb1d08fe..3411f67f63b2c8b06dc93dbe31ce228dfe6e5ce1 100644 --- a/sas/sas_func/sas_analy_queue.c +++ b/sas/sas_func/sas_analy_queue.c @@ -46,7 +46,7 @@ static int sas_get_res(const struct tool_sas_cmd *cmd, uint32_t *reg_save, uint3 return -EINVAL; } *reg_num = cmd_ret->rsp_data_num; - for (int i = 0; i < *reg_num; i++) + for (uint32_t i = 0; i < *reg_num; i++) reg_save[i] = cmd_ret->rsp_data[i]; hikp_cmd_free(&cmd_ret); diff --git a/sas/sas_func/sas_common.h b/sas/sas_func/sas_common.h index eed0fa585844953dba1328f020bee1b032635efe..78edf2ef7e63f2b9f50ad873e7266c55b00f2319 100644 --- a/sas/sas_func/sas_common.h +++ b/sas/sas_func/sas_common.h @@ -16,7 +16,7 @@ #define RESP_MAX_NUM 60 #define SAS_MAX_PHY_NUM 7 -#define SAS_MAX_ERR_NUM 6 +#define SAS_MAX_ERR_NUM 5 #define SAS_ERR_NUM 4 #define SAS_QUEUE_NUM 16 #define IPTT_ICT_STATUS 29 diff --git a/sas/sas_func/sas_dump_reg.c b/sas/sas_func/sas_dump_reg.c index 39fa5ed660b820f3da3694c1550f7a215c83014c..426982209a79854866008fd95fc8ee293402d2f9 100644 --- a/sas/sas_func/sas_dump_reg.c +++ b/sas/sas_func/sas_dump_reg.c @@ -38,14 +38,14 @@ static int sas_get_reg(const struct tool_sas_cmd *cmd, uint32_t *reg_save, uint3 return -1; } *reg_num = cmd_ret->rsp_data_num; - for (int i = 0; i < *reg_num; i++) + for (uint32_t i = 0; i < *reg_num; i++) reg_save[i] = cmd_ret->rsp_data[i]; hikp_cmd_free(&cmd_ret); return 0; } -static void sas_print_reg(uint32_t cmd_type, const uint32_t *reg_save, uint32_t reg_num) +static void sas_print_reg(const uint32_t *reg_save, uint32_t reg_num) { uint32_t i; @@ -71,7 +71,7 @@ int sas_reg_dump(struct tool_sas_cmd *cmd) if (ret) return ret; - sas_print_reg(cmd->sas_cmd_type, reg_save, reg_num); + sas_print_reg(reg_save, reg_num); return 0; } diff --git a/sas/sas_func/sas_read_dev.c b/sas/sas_func/sas_read_dev.c index b5d7e1803c0a9394eebdaa57e94b2426d0f6f264..dec29354ebd0a6da70c721534fe4b89b239b92f7 100644 --- a/sas/sas_func/sas_read_dev.c +++ b/sas/sas_func/sas_read_dev.c @@ -22,7 +22,7 @@ static int sas_get_dev(const struct tool_sas_cmd *cmd, uint32_t *reg_save, uint32_t *reg_num) { - int i; + uint32_t i; struct hikp_cmd_header req_header; struct hikp_cmd_ret *cmd_ret; struct sas_dev_req_para req_data = { 0 }; @@ -46,7 +46,7 @@ static int sas_get_dev(const struct tool_sas_cmd *cmd, uint32_t *reg_save, uint3 return 0; } -static void print_dev_link(const uint32_t *reg_save, uint32_t reg_num) +static void print_dev_link(const uint32_t *reg_save) { uint32_t i; uint32_t index, index1; @@ -84,7 +84,7 @@ static void sas_print_dev(const uint32_t *reg_save, uint32_t reg_num, uint32_t c } switch (cmd_type) { case DEV_LINK: - print_dev_link(reg_save, reg_num); + print_dev_link(reg_save); break; default: printf("cmd_type is error\n"); diff --git a/sas/sas_func/sas_read_dqe.c b/sas/sas_func/sas_read_dqe.c index dac2546f5214606a7fa6580d13e5ad07750fceba..ae4ef68c6b9d7aa61b384c3808db7c7dabe2dcb5 100644 --- a/sas/sas_func/sas_read_dqe.c +++ b/sas/sas_func/sas_read_dqe.c @@ -39,14 +39,14 @@ static int sas_get_dqe(const struct tool_sas_cmd *cmd, uint32_t *reg_save, uint3 return -EINVAL; } *reg_num = cmd_ret->rsp_data_num; - for (int i = 0; i < *reg_num; i++) + for (uint32_t i = 0; i < *reg_num; i++) reg_save[i] = cmd_ret->rsp_data[i]; hikp_cmd_free(&cmd_ret); return 0; } -static void print_dqe_info(const void *reg_save, uint32_t reg_num) +static void print_dqe_info(const void *reg_save) { volatile struct hisi_sas_dq_info *dqe = (volatile struct hisi_sas_dq_info *)(reg_save); @@ -109,6 +109,6 @@ int sas_dqe(const struct tool_sas_cmd *cmd) printf("SAS dqe is failed\n"); return -EINVAL; } - print_dqe_info(reg_save, reg_num); + print_dqe_info(reg_save); return 0; } diff --git a/sas/sas_func/sas_read_errcode.c b/sas/sas_func/sas_read_errcode.c index d451a983e33e1a0813bc0bf562aa6477f566ecde..8263550a02cd3ed4e8d1824f3b2012fe049d5ef6 100644 --- a/sas/sas_func/sas_read_errcode.c +++ b/sas/sas_func/sas_read_errcode.c @@ -37,7 +37,7 @@ static int sas_get_errcode(const struct tool_sas_cmd *cmd, uint32_t *reg_save, u return -EINVAL; } *reg_num = cmd_ret->rsp_data_num; - for (int i = 0; i < *reg_num; i++) + for (uint32_t i = 0; i < *reg_num; i++) reg_save[i] = cmd_ret->rsp_data[i]; hikp_cmd_free(&cmd_ret); diff --git a/sas/user_cmd/cmd_code/sas_cmd_anacq.c b/sas/user_cmd/cmd_code/sas_cmd_anacq.c index 6e39daec56e2acb9011b0d8406b3b2ab0dd67608..4d9a7503b9b58bbd3710dbc6e874f02e61875229 100644 --- a/sas/user_cmd/cmd_code/sas_cmd_anacq.c +++ b/sas/user_cmd/cmd_code/sas_cmd_anacq.c @@ -19,6 +19,8 @@ static int sas_anacq_help(struct major_cmd_ctrl *self, const char *argv) { + 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"); @@ -34,11 +36,17 @@ static int sas_anacq_help(struct major_cmd_ctrl *self, const char *argv) static int sas_anacq_prt(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + return sas_set_cmd_type(ANACQ_PRT); } static int sas_anacq_num(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + return sas_set_cmd_type(ANACQ_NUM); } diff --git a/sas/user_cmd/cmd_code/sas_cmd_anadq.c b/sas/user_cmd/cmd_code/sas_cmd_anadq.c index e1b68b6082dcd28482a6e698626f16e560e9b7a9..bff2c71e5265695f1704ef806c044aa2e22c06b0 100644 --- a/sas/user_cmd/cmd_code/sas_cmd_anadq.c +++ b/sas/user_cmd/cmd_code/sas_cmd_anadq.c @@ -19,6 +19,8 @@ static int sas_anadq_help(struct major_cmd_ctrl *self, const char *argv) { + 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"); @@ -34,11 +36,17 @@ static int sas_anadq_help(struct major_cmd_ctrl *self, const char *argv) static int sas_anadq_prt(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + return sas_set_cmd_type(ANADQ_PRT); } static int sas_anadq_num(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + return sas_set_cmd_type(ANADQ_NUM); } diff --git a/sas/user_cmd/cmd_code/sas_cmd_common.c b/sas/user_cmd/cmd_code/sas_cmd_common.c index 7d4ffbb123dabcc8be128ad4b3697a90e69270ac..1dafc0acf281ef8b7c29cf16ba5345586dbd6dfe 100644 --- a/sas/user_cmd/cmd_code/sas_cmd_common.c +++ b/sas/user_cmd/cmd_code/sas_cmd_common.c @@ -23,7 +23,7 @@ static struct tool_sas_cmd g_sas_cmd = { .dqe_id = (uint32_t)(-1), }; -int sas_set_id(struct major_cmd_ctrl *self, const char *argv, uint32_t *id) +static int sas_set_id(struct major_cmd_ctrl *self, const char *argv, uint32_t *id) { int ret; uint32_t val = 0; diff --git a/sas/user_cmd/cmd_code/sas_cmd_dev.c b/sas/user_cmd/cmd_code/sas_cmd_dev.c index 6a5eae0ec120be1c9dc8dee12d27885d60fc9fec..879e7642d22d3cc53bb2133e3ba0e768ee9fc068 100644 --- a/sas/user_cmd/cmd_code/sas_cmd_dev.c +++ b/sas/user_cmd/cmd_code/sas_cmd_dev.c @@ -19,6 +19,8 @@ static int sas_dev_help(struct major_cmd_ctrl *self, const char *argv) { + 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"); @@ -33,6 +35,9 @@ static int sas_dev_help(struct major_cmd_ctrl *self, const char *argv) static int sas_dev_link(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + return sas_set_cmd_type(DEV_LINK); } diff --git a/sas/user_cmd/cmd_code/sas_cmd_dqe.c b/sas/user_cmd/cmd_code/sas_cmd_dqe.c index ba34047fb99ff44b8be8b3fa0194b70c731f4782..b914f54da94038d7da60bb8f107181be0b9ed81f 100644 --- a/sas/user_cmd/cmd_code/sas_cmd_dqe.c +++ b/sas/user_cmd/cmd_code/sas_cmd_dqe.c @@ -19,6 +19,8 @@ static int sas_dqe_help(struct major_cmd_ctrl *self, const char *argv) { + 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"); @@ -57,7 +59,7 @@ static int sas_set_queue_id(struct major_cmd_ctrl *self, const char *argv) static int sas_dqe_excute_funs_call(uint32_t cmd_type) { - if ((cmd_type != SAS_UNKNOW_CMD) && (sas_get_que_id() != (uint32_t)(-1))) + if ((cmd_type != SAS_UNKNOW_CMD) && (sas_get_que_id() != (-1))) return sas_dqe(sas_get_cmd_p()); return -EINVAL; diff --git a/sas/user_cmd/cmd_code/sas_cmd_dump.c b/sas/user_cmd/cmd_code/sas_cmd_dump.c index e7dedf0b10956f101ac2c9b83db8975529dea5a7..db7d2c80daac07586c95ac4f9c33ee1a85e266d1 100644 --- a/sas/user_cmd/cmd_code/sas_cmd_dump.c +++ b/sas/user_cmd/cmd_code/sas_cmd_dump.c @@ -19,6 +19,8 @@ static int sas_dump_help(struct major_cmd_ctrl *self, const char *argv) { + 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"); @@ -35,6 +37,9 @@ static int sas_dump_help(struct major_cmd_ctrl *self, const char *argv) static int sas_dump_global(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + (void)sas_set_cmd_type(DUMP_GLOBAL); return 0; } @@ -56,6 +61,9 @@ static int sas_dump_phyx(struct major_cmd_ctrl *self, char const *argv) static int sas_dump_axi(struct major_cmd_ctrl *self, char const *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + (void)sas_set_cmd_type(DUMP_AXI); return 0; } diff --git a/sas/user_cmd/cmd_code/sas_cmd_errcode.c b/sas/user_cmd/cmd_code/sas_cmd_errcode.c index eb3c5e6e92a550a08e955f0a1e10c3fdec7c2555..ebe7d1c82a6d9b9d287032dd3b238f7651e54cff 100644 --- a/sas/user_cmd/cmd_code/sas_cmd_errcode.c +++ b/sas/user_cmd/cmd_code/sas_cmd_errcode.c @@ -18,6 +18,8 @@ static int sas_errcode_help(struct major_cmd_ctrl *self, const char *argv) { + 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"); diff --git a/sata/sata_func/sata_dump_reg.c b/sata/sata_func/sata_dump_reg.c index d63a14bff941c59062f746b93a5ade12e28e7894..d9911d61beda15d7a2971058e7b51ab22859909b 100644 --- a/sata/sata_func/sata_dump_reg.c +++ b/sata/sata_func/sata_dump_reg.c @@ -46,7 +46,7 @@ static int sata_get_reg(const struct tool_sata_cmd *cmd, uint32_t *reg_save, uin return 0; } -static void sata_print_reg(uint32_t cmd_type, const uint32_t *reg_save, uint32_t reg_num) +static void sata_print_reg(const uint32_t *reg_save, uint32_t reg_num) { uint32_t i; @@ -72,7 +72,7 @@ int sata_reg_dump(struct tool_sata_cmd *cmd) if (ret) return ret; - sata_print_reg(cmd->sata_cmd_type, sata_reg_save, sata_reg_num); + sata_print_reg(sata_reg_save, sata_reg_num); return 0; } diff --git a/sata/user_cmd/cmd_code/sata_cmd_dump.c b/sata/user_cmd/cmd_code/sata_cmd_dump.c index d38ff1cef717e9a3140822ab19929e1198476896..2b747122e372d01ea1eecb50b7d5023305bdac58 100644 --- a/sata/user_cmd/cmd_code/sata_cmd_dump.c +++ b/sata/user_cmd/cmd_code/sata_cmd_dump.c @@ -26,6 +26,8 @@ struct tool_sata_cmd g_sata_dump_cmd = { static int sata_dump_help(struct major_cmd_ctrl *self, const char *argv) { + 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"); @@ -56,16 +58,25 @@ static int sata_set_id(struct major_cmd_ctrl *self, const char *argv, uint32_t * static int sata_set_chip_id(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + return sata_set_id(self, argv, &g_sata_dump_cmd.chip_id); } static int sata_set_die_id(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + return sata_set_id(self, argv, &g_sata_dump_cmd.die_id); } static int sata_dump_global(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_sata_dump_cmd.sata_cmd_type = DUMP_GLOBAL; return 0; } diff --git a/sdma/sdma_func/sdma_common.h b/sdma/sdma_func/sdma_common.h new file mode 100644 index 0000000000000000000000000000000000000000..40969b80e7c1307f256068aa86f9ce8a129e26fc --- /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 0000000000000000000000000000000000000000..7440fb66372dbd0365c087906db49df7c1299a82 --- /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 0000000000000000000000000000000000000000..51c4e66eaf3d5b9a7e96a79750d6a5dd0534d1b8 --- /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 0000000000000000000000000000000000000000..6f4fcc209629b2959127080c53c8501f792e57b0 --- /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 0000000000000000000000000000000000000000..01b24b5543dc281d2758943686768a598acb56e5 --- /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 */ diff --git a/serdes/hikp_serdes.c b/serdes/hikp_serdes.c index 92e380eb407e894608a38989f7d339f5d3c203b4..01776df08e78807ce37fe118834df27b74a65b78 100644 --- a/serdes/hikp_serdes.c +++ b/serdes/hikp_serdes.c @@ -24,9 +24,15 @@ static struct cmd_serdes_param g_serdes_param = {0xff, 0xff, 0xff, 0xff, 0xff, 0 #define SERDES_OUTPUT_MAX_SIZE 2560 static char g_serdes_data_out_buf[SERDES_OUTPUT_MAX_SIZE] = {0}; +static struct hilink_cmd_out g_out_put = {0}; + +static void hikp_serdes_info_print(struct cmd_serdes_param *cmd); +static void hikp_serdes_dump_print(struct cmd_serdes_param *cmd); static int cmd_serdes_maininfo_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i -s -n [-k]"); printf("\n %s, e.g. hikptool serdes_info -i 0 -s m3d0 -n 4 -k\n", @@ -115,17 +121,20 @@ static int cmd_serdes_lane_num(struct major_cmd_ctrl *self, const char *argv) static int cmd_serdes_key_info_pro(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(self); + HIKP_SET_USED(argv); + g_serdes_param.sub_cmd = 1; return 0; } #define USEMODE_SSC_STR_MAXLEN 20 -static void hikp_serdes_brief_info_print(struct major_cmd_ctrl *self, - const struct hilink_brief_info *data, uint32_t data_size) +static void hikp_serdes_brief_info_print(struct cmd_serdes_param *cmd, + const struct hilink_brief_info *data, uint32_t data_size) { uint8_t ds_id; - uint8_t start_sds_id = g_serdes_param.start_sds_id; - uint8_t sds_num = g_serdes_param.sds_num; + uint8_t start_sds_id = cmd->start_sds_id; + uint8_t sds_num = cmd->sds_num; char usemode_ssc_str[USEMODE_SSC_STR_MAXLEN] = {0}; const char *usemode_array[HILINK_USE_MODE_END] = { "default", "pcie", "sata", "sas", "hccs", @@ -136,26 +145,20 @@ static void hikp_serdes_brief_info_print(struct major_cmd_ctrl *self, }; if (data_size != sds_num) { - self->err_no = -EINVAL; - snprintf(self->err_str, sizeof(self->err_str), - "serdes brief info data size is wrong."); + printf("serdes brief info data size is wrong.\n"); return; } for (ds_id = 0; ds_id < sds_num; ds_id++) { if (data[ds_id].usemode >= HILINK_USE_MODE_END) { - self->err_no = -EINVAL; - snprintf(self->err_str, sizeof(self->err_str), - "usemode[%u] is out of range.", data[ds_id].usemode); + printf("usemode[%u] is out of range.\n", data[ds_id].usemode); return; } strncpy(usemode_ssc_str, usemode_array[data[ds_id].usemode], sizeof(usemode_ssc_str) - 1); if (data[ds_id].ssc_type >= HILINK_SSC_TYPE_END) { - self->err_no = -EINVAL; - snprintf(self->err_str, sizeof(self->err_str), - "ssc_type[%u] is out of range.", data[ds_id].ssc_type); + printf("ssc_type[%u] is out of range.\n", data[ds_id].ssc_type); return; } if (data[ds_id].usemode < HILINK_USE_MODE_HCCS) { @@ -165,7 +168,7 @@ static void hikp_serdes_brief_info_print(struct major_cmd_ctrl *self, } printf("chip%u (M%u,ds%d) pll(%u, %u) pn(%u, %u) power(%u, %u)" "(refclk_sel:%u) rate(%u, %u Mhz) usemode(%s)\n", - g_serdes_param.chip_id, g_serdes_param.macro_id, + cmd->chip_id, cmd->macro_id, ds_id + start_sds_id, data[ds_id].tx_cs_sel, data[ds_id].rx_cs_sel, data[ds_id].tx_pn, data[ds_id].rx_pn, data[ds_id].tx_power, data[ds_id].rx_power, @@ -200,25 +203,22 @@ static void hikp_serdes_brief_info_print(struct major_cmd_ctrl *self, "-------------------------------------------------" \ "--------------------------------\n") -static void hikp_serdes_detail_info_print(struct major_cmd_ctrl *self, - const struct hilink_detail_info *data, - uint32_t data_size) +static void hikp_serdes_detail_info_print(struct cmd_serdes_param *cmd, + const struct hilink_detail_info *data, uint32_t data_size) { uint32_t i; uint8_t ds_id; - uint8_t start_sds_id = g_serdes_param.start_sds_id; - uint8_t sds_num = g_serdes_param.sds_num; + uint8_t start_sds_id = cmd->start_sds_id; + uint8_t sds_num = cmd->sds_num; if (data_size != sds_num) { - self->err_no = -EINVAL; - snprintf(self->err_str, sizeof(self->err_str), - "serdes detail info data size is wrong."); + printf("serdes detail info data size is wrong.\n"); return; } printf(KEY_INFO_TITLE); for (ds_id = 0; ds_id < sds_num; ds_id++) { printf("chip%u (M%u,ds%d) [%3d,%3d,%3u,%3d,%3d]", - g_serdes_param.chip_id, g_serdes_param.macro_id, ds_id + start_sds_id, + cmd->chip_id, cmd->macro_id, ds_id + start_sds_id, data[ds_id].tx_cfg.fir_pre2, data[ds_id].tx_cfg.fir_pre1, data[ds_id].tx_cfg.fir_main, data[ds_id].tx_cfg.fir_post1, data[ds_id].tx_cfg.fir_post2); @@ -243,6 +243,8 @@ static void hikp_serdes_detail_info_print(struct major_cmd_ctrl *self, static void hikp_serdes_logout_init(struct hilink_cmd_out *logout, char *buffer, uint32_t size, uint32_t type) { + memset(buffer, 0, size); + logout->str_len = size; logout->result_offset = 0; logout->out_str = buffer; @@ -282,67 +284,88 @@ static int hikp_serdes_info_para_check(struct major_cmd_ctrl *self) return 0; } -static void hikp_serdes_info_cmd_execute(struct major_cmd_ctrl *self) +static void hikp_serdes_print(struct cmd_serdes_param *cmd) +{ + if (cmd->cmd_type == SERDES_KEY_INFO) + hikp_serdes_info_print(cmd); + else if (cmd->cmd_type == SERDES_DUMP_REG) + hikp_serdes_dump_print(cmd); +} + +int hikp_serdes_get_reponse(struct cmd_serdes_param *cmd) { struct hikp_cmd_header req_header = {0}; struct hikp_cmd_ret *cmd_ret; struct hilink_cmd_in hilink_cmd = {0}; - struct hilink_brief_info *brief_info_data = NULL; - struct hilink_detail_info *detail_info_data = NULL; - struct hilink_cmd_out out_put; size_t out_out_header_size; - int ret; - - ret = hikp_serdes_info_para_check(self); - if (ret != 0) - return; - hikp_serdes_logout_init(&out_put, g_serdes_data_out_buf, SERDES_OUTPUT_MAX_SIZE, 0); + hilink_cmd.cmd_type = cmd->cmd_type; + hilink_cmd.sub_cmd = cmd->sub_cmd; + hilink_cmd.cmd_para.chip_id = cmd->chip_id; + hilink_cmd.cmd_para.macro_id = cmd->macro_id; + hilink_cmd.cmd_para.start_sds_id = cmd->start_sds_id; + hilink_cmd.cmd_para.sds_num = cmd->sds_num; - hilink_cmd.cmd_type = SERDES_KEY_INFO; - hilink_cmd.sub_cmd = g_serdes_param.sub_cmd; - hilink_cmd.cmd_para.chip_id = g_serdes_param.chip_id; - hilink_cmd.cmd_para.macro_id = g_serdes_param.macro_id; - hilink_cmd.cmd_para.start_sds_id = g_serdes_param.start_sds_id; - hilink_cmd.cmd_para.sds_num = g_serdes_param.sds_num; + hikp_serdes_logout_init(&g_out_put, g_serdes_data_out_buf, SERDES_OUTPUT_MAX_SIZE, 0); - hikp_cmd_init(&req_header, SERDES_MOD, SERDES_KEY_INFO, g_serdes_param.sub_cmd); + hikp_cmd_init(&req_header, SERDES_MOD, cmd->cmd_type, cmd->sub_cmd); cmd_ret = hikp_cmd_alloc(&req_header, &hilink_cmd, sizeof(hilink_cmd)); if (cmd_ret == NULL || cmd_ret->status != 0) { - snprintf(self->err_str, sizeof(self->err_str), "hikp_cmd_alloc err."); - self->err_no = -EINVAL; - goto err_out; + printf("hikp_cmd_alloc err.\n"); + hikp_cmd_free(&cmd_ret); + return -EINVAL; } - out_out_header_size = sizeof(out_put.str_len) + sizeof(out_put.result_offset) + - sizeof(out_put.type) + sizeof(out_put.ret_val); - memcpy(&out_put, cmd_ret->rsp_data, out_out_header_size); + out_out_header_size = sizeof(g_out_put.str_len) + sizeof(g_out_put.result_offset) + + sizeof(g_out_put.type) + sizeof(g_out_put.ret_val); + memcpy(&g_out_put, cmd_ret->rsp_data, out_out_header_size); - if ((cmd_ret->rsp_data_num * sizeof(uint32_t) - out_out_header_size) > - SERDES_OUTPUT_MAX_SIZE) { - self->err_no = -EINVAL; - snprintf(self->err_str, sizeof(self->err_str), - "serdes_info rsp_data data copy size error, data size:0x%zx max size:0x%x.", + if ((cmd_ret->rsp_data_num * sizeof(uint32_t) - out_out_header_size) > SERDES_OUTPUT_MAX_SIZE) { + printf("serdes_info rsp_data data copy size error, data size:0x%zx max size:0x%x.", (cmd_ret->rsp_data_num * sizeof(uint32_t) - out_out_header_size), SERDES_OUTPUT_MAX_SIZE); - goto err_out; + hikp_cmd_free(&cmd_ret); + return -EINVAL; } - memcpy(out_put.out_str, cmd_ret->rsp_data + out_out_header_size / sizeof(uint32_t), + memcpy(g_out_put.out_str, cmd_ret->rsp_data + out_out_header_size / sizeof(uint32_t), cmd_ret->rsp_data_num * sizeof(uint32_t) - out_out_header_size); + hikp_cmd_free(&cmd_ret); + + hikp_serdes_print(cmd); + + return 0; +} + +static void hikp_serdes_info_print(struct cmd_serdes_param *cmd) +{ + struct hilink_brief_info *brief_info_data = NULL; + struct hilink_detail_info *detail_info_data = NULL; - if (g_serdes_param.sub_cmd > 0) { - detail_info_data = (struct hilink_detail_info *)out_put.out_str; - hikp_serdes_detail_info_print(self, detail_info_data, - out_put.result_offset / - sizeof(struct hilink_detail_info)); + if (cmd->sub_cmd > 0) { + detail_info_data = (struct hilink_detail_info *)g_out_put.out_str; + hikp_serdes_detail_info_print(cmd, detail_info_data, + g_out_put.result_offset / sizeof(struct hilink_detail_info)); } else { - brief_info_data = (struct hilink_brief_info *)out_put.out_str; - hikp_serdes_brief_info_print(self, brief_info_data, - out_put.result_offset / - sizeof(struct hilink_brief_info)); + brief_info_data = (struct hilink_brief_info *)g_out_put.out_str; + hikp_serdes_brief_info_print(cmd, brief_info_data, + g_out_put.result_offset / sizeof(struct hilink_brief_info)); } +} -err_out: - hikp_cmd_free(&cmd_ret); +static void hikp_serdes_info_cmd_execute(struct major_cmd_ctrl *self) +{ + int ret; + + ret = hikp_serdes_info_para_check(self); + if (ret != 0) + return; + + g_serdes_param.cmd_type = SERDES_KEY_INFO; + ret = hikp_serdes_get_reponse(&g_serdes_param); + if (ret != 0) { + self->err_no = ret; + snprintf(self->err_str, sizeof(self->err_str), "serdes_info hikp_serdes_get_reponse err\n"); + return; + } } static void cmd_serdes_maininfo_init(void) @@ -361,6 +384,8 @@ static void cmd_serdes_maininfo_init(void) static int cmd_serdes_dump_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-c -i -s "); printf("\n %s, e.g. hikptool serdes_dump -c cs -i 0 -s m0d0\n", @@ -393,22 +418,27 @@ _SERDES_DUMP_SUBCMD_PRO_: return 0; } -static void hikp_serdes_dump_print(struct major_cmd_ctrl *self, - const uint32_t *data, uint32_t data_size) +static void hikp_serdes_dump_print(struct cmd_serdes_param *cmd) { + uint32_t *dump_data = (uint32_t *)g_out_put.out_str; + uint32_t data_size = g_out_put.result_offset / sizeof(uint32_t); uint32_t i; + if (g_out_put.type == 1) { /* 0:data; 1:string */ + printf("serdes dump data type is string, buffer is not enough.\n"); + return; + } + /* 2: Check whether addresses and values are paired */ if (data_size == 0 || data_size % 2 != 0) { - self->err_no = -EINVAL; - snprintf(self->err_str, sizeof(self->err_str), "serdes dump data size is wrong."); + printf("serdes dump data size is wrong.\n"); return; } printf("\n[-------Macro%uCS/DS%u-------]\nAddr Value", - g_serdes_param.macro_id, g_serdes_param.start_sds_id); + cmd->macro_id, cmd->start_sds_id); for (i = 0; i < data_size; i += 2) { /* 2: Addresses and values are paired */ - printf("\n0x%04x 0x%08x", data[i], data[i + 1]); + printf("\n0x%04x 0x%08x", dump_data[i], dump_data[i + 1]); } printf("\n"); } @@ -444,59 +474,19 @@ static int hikp_serdes_dump_para_check(struct major_cmd_ctrl *self) static void hikp_serdes_dump_cmd_execute(struct major_cmd_ctrl *self) { - struct hikp_cmd_header req_header = {0}; - struct hikp_cmd_ret *cmd_ret; - struct hilink_cmd_in hilink_cmd = {0}; - uint32_t *dump_data = NULL; - struct hilink_cmd_out out_put; - size_t out_out_header_size; int ret; ret = hikp_serdes_dump_para_check(self); if (ret != 0) return; - hikp_serdes_logout_init(&out_put, g_serdes_data_out_buf, SERDES_OUTPUT_MAX_SIZE, 0); - - hilink_cmd.cmd_type = SERDES_DUMP_REG; - hilink_cmd.sub_cmd = g_serdes_param.sub_cmd; - hilink_cmd.cmd_para.chip_id = g_serdes_param.chip_id; - hilink_cmd.cmd_para.macro_id = g_serdes_param.macro_id; - hilink_cmd.cmd_para.start_sds_id = g_serdes_param.start_sds_id; - - hikp_cmd_init(&req_header, SERDES_MOD, SERDES_DUMP_REG, g_serdes_param.sub_cmd); - cmd_ret = hikp_cmd_alloc(&req_header, &hilink_cmd, sizeof(hilink_cmd)); - if (cmd_ret == NULL || cmd_ret->status != 0) { - self->err_no = -EINVAL; - snprintf(self->err_str, sizeof(self->err_str), "hikp_cmd_alloc err."); - goto err_out; - } - out_out_header_size = sizeof(out_put.str_len) + sizeof(out_put.result_offset) + - sizeof(out_put.type) + sizeof(out_put.ret_val); - memcpy(&out_put, cmd_ret->rsp_data, out_out_header_size); - - if ((cmd_ret->rsp_data_num * sizeof(uint32_t) - out_out_header_size) > - SERDES_OUTPUT_MAX_SIZE) { - self->err_no = -EINVAL; - snprintf(self->err_str, sizeof(self->err_str), - "serdes_dump rsp_data data copy size error, data size:0x%zx max size:0x%x.", - (cmd_ret->rsp_data_num * sizeof(uint32_t) - out_out_header_size), - SERDES_OUTPUT_MAX_SIZE); - goto err_out; - } - memcpy(out_put.out_str, cmd_ret->rsp_data + out_out_header_size / sizeof(uint32_t), - cmd_ret->rsp_data_num * sizeof(uint32_t) - out_out_header_size); - if (out_put.type == 1) { /* 0:data; 1:string */ - self->err_no = -EINVAL; - snprintf(self->err_str, sizeof(self->err_str), - "serdes dump data type is string, buffer is not enough."); - goto err_out; + g_serdes_param.cmd_type = SERDES_DUMP_REG; + ret = hikp_serdes_get_reponse(&g_serdes_param); + if (ret != 0) { + self->err_no = ret; + snprintf(self->err_str, sizeof(self->err_str), "serdes_dump hikp_serdes_get_reponse err\n"); + return; } - - dump_data = (uint32_t *)out_put.out_str; - hikp_serdes_dump_print(self, dump_data, out_put.result_offset / sizeof(uint32_t)); -err_out: - hikp_cmd_free(&cmd_ret); } static void cmd_serdes_dump_init(void) diff --git a/serdes/hikp_serdes.h b/serdes/hikp_serdes.h index 2c04e8aef9462ed5c7c1c9eafee7eae33d35f886..4ea969db69679b67c04ee2107ab5af6ec9dac88f 100644 --- a/serdes/hikp_serdes.h +++ b/serdes/hikp_serdes.h @@ -113,7 +113,7 @@ struct cmd_serdes_param { uint8_t sds_num; uint8_t val; uint8_t sub_cmd; - uint8_t rsvd1; + uint8_t cmd_type; uint8_t rsvd2; }; @@ -210,4 +210,6 @@ struct hilink_brief_info { uint32_t rsvd_1; }; +int hikp_serdes_get_reponse(struct cmd_serdes_param *cmd); + #endif /* HIKP_SERDES_H */ diff --git a/socip/hikp_socip.h b/socip/hikp_socip.h index 8d3f31b53edbb39df6b4c1eb099cc3d070753e27..0b82f90cce9ba2598354e93169f4f18a49f8271e 100644 --- a/socip/hikp_socip.h +++ b/socip/hikp_socip.h @@ -46,4 +46,5 @@ struct socip_dump_reg_req_data_t { uint8_t controller_id; }; +void dump_reg_info(const uint32_t *reg_data, uint32_t data_num); #endif /* HIKP_SOCIP_H */ diff --git a/socip/hikp_socip_dumpreg.c b/socip/hikp_socip_dumpreg.c index 4b6b70cfc0fbde959596354f2f19ce23235c54cb..b3b3ed7d8ccf2351ea6330201bc46337ede8bcce 100644 --- a/socip/hikp_socip_dumpreg.c +++ b/socip/hikp_socip_dumpreg.c @@ -39,6 +39,8 @@ static struct dump_reg_param_t g_dump_reg_param[SOCIP_DUMP_REG_PARAM_NUM] = {0}; static int cmd_socip_dump_help(struct major_cmd_ctrl *self, const char *argv) { + HIKP_SET_USED(argv); + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-c -d -m -i "); printf("\n %s\n", self->cmd_ptr->help_info); @@ -105,7 +107,7 @@ static bool check_socip_dumpreg_param(void) return ret; } -static void dump_reg_info(const uint32_t *reg_data, uint32_t data_num) +void dump_reg_info(const uint32_t *reg_data, uint32_t data_num) { #define ONE_LINE_PRINT_DATA_NUM 4 uint32_t i; diff --git a/tool_lib/op_logs.c b/tool_lib/op_logs.c index 6f28ecd6a914f3f5a2d6e4865e032923d729de85..c1c7d02b59cd6a64a4a80ae1753836d4a17b64f2 100644 --- a/tool_lib/op_logs.c +++ b/tool_lib/op_logs.c @@ -246,7 +246,7 @@ int op_log_initialise(const char *log_dir) memset(log_path, '\0', OP_LOG_FILE_PATH_MAXLEN); memset(g_op_log, '\0', OP_LOG_FILE_PATH_MAXLEN); ret = snprintf(log_path, sizeof(log_path), "%s", log_dir); - if (ret < 0 || ret >= sizeof(log_path)) + if (ret < 0 || (size_t)ret >= sizeof(log_path)) return -EINVAL; if (!is_dir_exist(log_path)) { @@ -275,22 +275,17 @@ int op_log_initialise(const char *log_dir) void op_log_record_input(const int argc, const char **argv) { char input_str[OP_LOG_FILE_W_MAXSIZE + 1] = {0}; - struct op_log_print_t log_info[] = { - {"%s", g_cmd_exec_time}, - {"[%s]", input_str}, - }; - size_t i, arr_size; int offset = 0; char *arg; int ret; memset(g_input_buf, 0, sizeof(g_input_buf)); - if (argv == NULL || argc == 0) + if (argv == NULL || argc <= 0) return; arg = input_str; - for (i = 0; i < argc; i++) { + for (int i = 0; i < argc; i++) { ret = snprintf(arg, (sizeof(input_str) - (arg - input_str)), "%s ", argv[i]); if (ret < 0 || ret >= (int)(sizeof(input_str) - (arg - input_str))) return; @@ -299,15 +294,18 @@ void op_log_record_input(const int argc, const char **argv) } input_str[strlen(input_str) - 1] = 0; - arr_size = HIKP_ARRAY_SIZE(log_info); - for (i = 0; i < arr_size; i++) { - ret = snprintf(g_input_buf + offset, (OP_LOG_FILE_W_MAXSIZE + 1 - offset), - log_info[i].format, log_info[i].str); - if (ret < 0 || ret >= (OP_LOG_FILE_W_MAXSIZE + 1 - offset)) - return; - - offset += ret; + ret = snprintf(g_input_buf + offset, (OP_LOG_FILE_W_MAXSIZE + 1 - offset), + "%s", g_cmd_exec_time); + if (ret < 0 || ret >= (OP_LOG_FILE_W_MAXSIZE + 1 - offset)) { + printf("snprintf exec time failed, ret 0x%x\n", ret); + return; } + + offset += ret; + ret = snprintf(g_input_buf + offset, (OP_LOG_FILE_W_MAXSIZE + 1 - offset), + "[%s]", input_str); + if (ret < 0 || ret >= (OP_LOG_FILE_W_MAXSIZE + 1 - offset)) + printf("snprintf exec cmd failed, ret 0x%x\n", ret); } void op_log_record_result(int ret, const char *tool_name, const char *log_dir) @@ -393,7 +391,7 @@ static int signal_fcntl(const char *name, uint32_t operation, int *fd) return uda_fcntl(lock_file, operation, fd); } -void signal_op_log_write(int signal_code) +static void signal_op_log_write(int signal_code) { char log_str[] = "[00:00:00] [KILLED<00>].\r\n"; int op_log_fd; diff --git a/tool_lib/tool_lib.c b/tool_lib/tool_lib.c index 4d02bdd78bf0aa6f23d464aeda5377f85f89eb4d..3dc5dadae2f7d6350adb6b9b2224d08d6545385e 100644 --- a/tool_lib/tool_lib.c +++ b/tool_lib/tool_lib.c @@ -16,6 +16,46 @@ #include #include +uint32_t get_chip_type(void) +{ + char part_num_str[MIDR_BUFFER_SIZE] = {0}; + char midr_buffer[MIDR_BUFFER_SIZE] = {0}; + uint32_t chip_type = CHIP_UNKNOW; + uint64_t midr_el1; + uint32_t part_num; + FILE *file; + + file = fopen(MIDR_EL1_PATH, "r"); + if (file == NULL) { + HIKP_ERROR_PRINT("Open file: %s failed\n", MIDR_EL1_PATH); + return chip_type; + } + + if (fgets(midr_buffer, MIDR_BUFFER_SIZE, file) == NULL) { + HIKP_ERROR_PRINT("Read file: %s failed\n", MIDR_EL1_PATH); + fclose(file); + return chip_type; + } + + fclose(file); + midr_el1 = strtoul(midr_buffer, NULL, MIDR_HEX_TYPE); + part_num = (midr_el1 & 0xffff) >> PART_NUM_OFFSET; + (void)snprintf(part_num_str, MIDR_BUFFER_SIZE, "%x", part_num); + + if (strcmp(part_num_str, "d02") == 0) + chip_type = CHIP_HIP09; + else if (strcmp(part_num_str, "d03") == 0) + chip_type = CHIP_HIP10; + else if (strcmp(part_num_str, "d45") == 0) + chip_type = CHIP_HIP10C; + else if (strcmp(part_num_str, "d22") == 0) + chip_type = CHIP_HIP11; + else + chip_type = CHIP_UNKNOW; + + return chip_type; +} + int string_toui(const char *nptr, uint32_t *value) { char *endptr = NULL; @@ -205,7 +245,7 @@ int tool_flock(const char *name, uint32_t operation, int *fd, const char *log_di } ret = snprintf(lock_file, sizeof(lock_file), "%s", log_dir); - if (ret < 0 || ret >= sizeof(lock_file)) { + if (ret < 0 || (size_t)ret >= sizeof(lock_file)) { HIKP_ERROR_PRINT("generate flock [%s] folder name failed, errno is %d\n", log_dir, errno); return -errno; diff --git a/tool_lib/tool_lib.h b/tool_lib/tool_lib.h index 34cc3e80e9831594facce908b0de08d2c4986ebd..d4493d703f1d67f4603d713699b4ce3e7fb77c5c 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)) @@ -91,6 +91,26 @@ struct type_trans { #define HIKP_INFO_PRINT(x, args...) HIKP_LOG_PRINT("[ INFO ] " x, ##args) #define HIKP_DBG_PRINT(x, args...) HIKP_LOG_PRINT("[ DBG ] " x, ##args) +/* definition to mark a variable or function parameter as used so + * as to avoid a compiler warning + */ +#define HIKP_SET_USED(x) (void)(x) + +#define MIDR_EL1_PATH "/sys/devices/system/cpu/cpu0/regs/identification/midr_el1" +#define MIDR_BUFFER_SIZE 20 +#define PART_NUM_OFFSET 4 +#define MIDR_HEX_TYPE 16 + +enum chip_type { + CHIP_HIP09, + CHIP_HIP10, + CHIP_HIP10C, + CHIP_HIP11, + CHIP_UNKNOW, +}; + +uint32_t get_chip_type(void); + int string_toui(const char *nptr, uint32_t *value); int string_toub(const char *nptr, uint8_t *value);