From: veega2022 <zhuweijia@huawei.com> add link options "-fPIE -pie", because the -T link is used, the pie becomes invalid.Therefore,change the ld file PROVIDE address to 0. Signed-off-by: veega2022 <zhuweijia@huawei.com> --- CMakeLists.txt | 4 ++-- hikp_register.ld | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 0ba7370..6a396e7 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -11,7 +11,7 @@ project(hikptool C) -set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g -O2 -pie -fPIE -Wall") +set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g -O2 -fPIC -fPIE -Wall") set(CMAKE_SKIP_RPATH TRUE) macro(get_header_dir_recurse HEADER_DIR_LIST) @@ -44,6 +44,6 @@ target_include_directories(hikptool PRIVATE ${HIKPTOOL_HEADER_DIR}) target_link_directories(hikptool PRIVATE ${CMAKE_INSTALL_PREFIX}/lib) target_link_libraries(hikptool PRIVATE KPTDEV_SO) target_link_options(hikptool PRIVATE - -Wl,-z,relro,-z,now -Wl,-z,noexecstack + -Wl,-z,relro,-z,now -Wl,-z,noexecstack -fPIE -pie -g -lpthread -ldl -lm -lrt -T ${CMAKE_CURRENT_SOURCE_DIR}/hikp_register.ld) install(TARGETS hikptool RUNTIME DESTINATION bin OPTIONAL) diff --git a/hikp_register.ld b/hikp_register.ld index b1bec44..3bd44ff 100644 --- a/hikp_register.ld +++ b/hikp_register.ld @@ -11,7 +11,7 @@ SEARCH_DIR("=/usr/aarch64-Huawei-linux/lib64"); SEARCH_DIR("=/usr/lib64"); SEARC SECTIONS { /* Read-only sections, merged into text segment: */ - PROVIDE (__executable_start = SEGMENT_START("text-segment", 0x400000)); . = SEGMENT_START("text-segment", 0x400000) + SIZEOF_HEADERS; + PROVIDE (__executable_start = SEGMENT_START("text-segment", 0x0)); . = SEGMENT_START("text-segment", 0x0) + SIZEOF_HEADERS; .interp : { *(.interp) } .note.gnu.build-id : { *(.note.gnu.build-id) } .hash : { *(.hash) } -- 2.25.1

From: veega2022 <zhuweijia@huawei.com> union hikp_space_rsp 0xF8h is reserved and 0xFCh is cpl_status Signed-off-by: hesiyuan <hesiyuan4@huawei.com> --- libhikptdev/src/rciep/hikpt_rciep.c | 2 +- libhikptdev/src/rciep/hikpt_rciep.h | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/libhikptdev/src/rciep/hikpt_rciep.c b/libhikptdev/src/rciep/hikpt_rciep.c index 9b7a82a..5c7e82f 100644 --- a/libhikptdev/src/rciep/hikpt_rciep.c +++ b/libhikptdev/src/rciep/hikpt_rciep.c @@ -97,7 +97,7 @@ static uint32_t hikp_wait_for_cpl_status(void) uint32_t status; do { - status = g_hikp_req->field.cpl_status; + status = g_hikp_rsp->field.cpl_status; if (status != HIKP_INIT_STAT) return status; count--; diff --git a/libhikptdev/src/rciep/hikpt_rciep.h b/libhikptdev/src/rciep/hikpt_rciep.h index 093724a..8fbb3c0 100644 --- a/libhikptdev/src/rciep/hikpt_rciep.h +++ b/libhikptdev/src/rciep/hikpt_rciep.h @@ -75,8 +75,8 @@ union hikp_space_rsp { uint32_t version; /* 000h */ uint32_t rsp_para_num; /* 004h */ uint32_t data[HIKP_RSP_DATA_MAX]; /* 008h */ - uint32_t cpl_status; /* 0F8h */ - uint32_t pid_record; /* 0FCh */ + uint32_t rsv; /* 0F8h */ + uint32_t cpl_status; /* 0FCh */ struct iep_doorbell sw_db; /* 100h. Fixed and unmodifiable */ } field; -- 2.36.1.windows.1

From: veega2022 <zhuweijia@huawei.com> move sig_init api to op_logs public header file Signed-off-by: wangkang <wangkang124@hisilicon.com> --- hikp_init_main.c | 20 -------------------- libhikptdev/src/rciep/hikpt_rciep.h | 2 +- tool_lib/op_logs.c | 23 ++++++++++++++++++++++- tool_lib/op_logs.h | 3 ++- 4 files changed, 25 insertions(+), 23 deletions(-) diff --git a/hikp_init_main.c b/hikp_init_main.c index 4102c69..4629b40 100644 --- a/hikp_init_main.c +++ b/hikp_init_main.c @@ -19,26 +19,6 @@ /* hikptool command adapter */ struct cmd_adapter g_tool = { 0 }; -static void _sig_ign_handle(int arg) -{ - signal_op_log_write(arg); - hikp_unlock(); - _exit(1); -} - -static void sig_init(void) -{ - (void)signal(SIGINT, _sig_ign_handle); /* Quit process */ - (void)signal(SIGTERM, _sig_ign_handle); - (void)signal(SIGQUIT, _sig_ign_handle); - (void)signal(SIGHUP, _sig_ign_handle); - (void)signal(SIGSEGV, _sig_ign_handle); - (void)signal(SIGBUS, _sig_ign_handle); - (void)signal(SIGFPE, _sig_ign_handle); - (void)signal(SIGABRT, _sig_ign_handle); - (void)signal(SIGTSTP, _sig_ign_handle); /* Stop process */ -} - static void show_tool_version(const struct cmd_adapter *adapter) { printf("%s version %s Huawei\n", adapter->name, adapter->version); diff --git a/libhikptdev/src/rciep/hikpt_rciep.h b/libhikptdev/src/rciep/hikpt_rciep.h index 8fbb3c0..dd08759 100644 --- a/libhikptdev/src/rciep/hikpt_rciep.h +++ b/libhikptdev/src/rciep/hikpt_rciep.h @@ -40,7 +40,7 @@ #define MAX_LOCK_COUNT 5 #define LOCK_CHECK_GAP_US 1000 #define CPL_CHECK_GAP_US 1000 -#define WAIT_CPL_MAX_MS 5000 +#define WAIT_CPL_MAX_MS 8000 enum { HIKP_RESOURCE_DIR, diff --git a/tool_lib/op_logs.c b/tool_lib/op_logs.c index d6082a3..069428d 100644 --- a/tool_lib/op_logs.c +++ b/tool_lib/op_logs.c @@ -14,7 +14,9 @@ #include <syslog.h> #include <unistd.h> #include <sys/stat.h> +#include <signal.h> #include "tool_lib.h" +#include "hikptdev_plug.h" #include "op_logs.h" static char g_op_log[OP_LOG_FILE_PATH_MAXLEN] = {0}; @@ -23,7 +25,6 @@ static bool g_record = true; static bool g_log_info; static char g_input_buf[OP_LOG_FILE_W_MAXSIZE + 1] = {0}; - static void op_log_write(const char *log_data) { size_t w_size; @@ -414,3 +415,23 @@ SIGNAL_LOG_OUT: (void)close(fd); (void)uda_unfcntl(&op_log_fd, UDA_FLOCK_BLOCK); } + +static void signal_handle(int arg) +{ + signal_op_log_write(arg); + hikp_unlock(); + _exit(1); +} + +void sig_init(void) +{ + (void)signal(SIGINT, signal_handle); /* Quit process */ + (void)signal(SIGTERM, signal_handle); + (void)signal(SIGQUIT, signal_handle); + (void)signal(SIGHUP, signal_handle); + (void)signal(SIGSEGV, signal_handle); + (void)signal(SIGBUS, signal_handle); + (void)signal(SIGFPE, signal_handle); + (void)signal(SIGABRT, signal_handle); + (void)signal(SIGTSTP, signal_handle); /* Stop process */ +} diff --git a/tool_lib/op_logs.h b/tool_lib/op_logs.h index 597f063..6b6e421 100644 --- a/tool_lib/op_logs.h +++ b/tool_lib/op_logs.h @@ -45,7 +45,8 @@ struct op_log_print_t { char *str; }; -void signal_op_log_write(int signal_code); +void sig_init(void); + void op_log_on(void); void op_log_off(void); int op_log_initialise(const char *log_dir); -- 2.36.1.windows.1

From: veega2022 <zhuweijia@huawei.com> The number of new chip registers may increase. Therefore, increase the number of dump registers. Signed-off-by: wangkang <wangkang124@hisilicon.com> --- serdes/hikp_serdes.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/serdes/hikp_serdes.c b/serdes/hikp_serdes.c index 89e66e1..dd9eee3 100644 --- a/serdes/hikp_serdes.c +++ b/serdes/hikp_serdes.c @@ -23,7 +23,7 @@ static struct cmd_serdes_param g_serdes_param = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; -#define SERDES_OUTPUT_MAX_SIZE 2048 +#define SERDES_OUTPUT_MAX_SIZE 2560 static char g_serdes_data_out_buf[SERDES_OUTPUT_MAX_SIZE] = {0}; static int cmd_serdes_maininfo_help(struct major_cmd_ctrl *self, const char *argv) -- 2.36.1.windows.1

From: veega2022 <zhuweijia@huawei.com> The hikptool ub_dfx command is submitted for the first time. This command can be used to dump register information of the LRB, PFA, and PM modules. Signed-off-by: Jianqiang Li <lijianqiang16@huawei.com> --- libhikptdev/include/hikptdev_plug.h | 1 + net/hikp_net_lib.h | 9 + net/ub/ub_dfx/hikp_ub_dfx.c | 319 ++++++++++++++++++++++++++++ net/ub/ub_dfx/hikp_ub_dfx.h | 100 +++++++++ tool_lib/tool_lib.h | 2 +- 5 files changed, 430 insertions(+), 1 deletion(-) create mode 100644 net/ub/ub_dfx/hikp_ub_dfx.c create mode 100644 net/ub/ub_dfx/hikp_ub_dfx.h diff --git a/libhikptdev/include/hikptdev_plug.h b/libhikptdev/include/hikptdev_plug.h index 42bea6b..56cea78 100644 --- a/libhikptdev/include/hikptdev_plug.h +++ b/libhikptdev/include/hikptdev_plug.h @@ -43,6 +43,7 @@ enum cmd_module_type { MAC_MOD = 8, DPDK_MOD = 9, CXL_MOD = 10, + UB_MOD = 11, }; void hikp_unlock(void); diff --git a/net/hikp_net_lib.h b/net/hikp_net_lib.h index cc99d0c..af0a51d 100644 --- a/net/hikp_net_lib.h +++ b/net/hikp_net_lib.h @@ -98,6 +98,15 @@ enum roce_cmd_type { GET_ROCEE_TSP_CMD, }; +enum ub_cmd_type { + GET_UNIC_PPP_CMD = 0x1, + GET_UB_DFX_INFO_CMD, + GET_UB_LINK_INFO_CMD, + GET_UB_BP_INFO_CMD, + GET_UB_CRD_INFO_CMD, + GET_UB_BASIC_INFO_CMD, +}; + #define HIKP_MAX_PF_NUM 8 #define HIKP_NIC_MAX_FUNC_NUM 256 diff --git a/net/ub/ub_dfx/hikp_ub_dfx.c b/net/ub/ub_dfx/hikp_ub_dfx.c new file mode 100644 index 0000000..c50f555 --- /dev/null +++ b/net/ub/ub_dfx/hikp_ub_dfx.c @@ -0,0 +1,319 @@ +/* + * Copyright (c) 2023 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 "tool_cmd.h" +#include "hikp_net_lib.h" +#include "hikp_ub_dfx.h" + +struct ub_dfx_param g_ub_dfx_param = { 0 }; + +static const struct dfx_module_cmd g_ub_dfx_module_parse[] = { + {"LRB", LRB_DFX_REG_DUMP}, + {"PFA", PFA_DFX_REG_DUMP}, + {"PM", PM_DFX_REG_DUMP} +}; + +static const struct dfx_type_parse g_dfx_type_parse[] = { + {INCORRECT_REG_TYPE, WIDTH_32_BIT, "INCORRECT TYPE"}, + {TYPE_32_STATS, WIDTH_32_BIT, "32 bit statistics"}, + {TYPE_32_RUNNING_STATUS, WIDTH_32_BIT, "32 bit running status"}, + {TYPE_64_STATS, WIDTH_64_BIT, "64 bit statistics"}, +}; + +static void dfx_help_info(const struct major_cmd_ctrl *self) +{ + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i <interface>\n"); + printf("\n %s\n", self->cmd_ptr->help_info); + printf(" Options:\n\n"); + printf(" %s, %-25s %s\n", "-h", "--help", "display this help and exit"); + printf(" %s, %-25s %s\n", "-i", "--interface=<interface>", + "device target or bdf id, e.g. ubn0 or 0000:35:00.0"); + printf(" %s\n", " [-m/--module LRB/PFA/PM] : this is necessary param\n"); +} + +static int hikp_ub_dfx_help(struct major_cmd_ctrl *self, const char *argv) +{ + dfx_help_info(self); + return 0; +} + +static int hikp_ub_dfx_target(struct major_cmd_ctrl *self, const char *argv) +{ + self->err_no = tool_check_and_get_valid_bdf_id(argv, &(g_ub_dfx_param.target)); + if (self->err_no != 0) { + snprintf(self->err_str, sizeof(self->err_str), "Unknown device %s.", argv); + return self->err_no; + } + + return 0; +} + +static int hikp_ub_dfx_module_select(struct major_cmd_ctrl *self, const char *argv) +{ + size_t arr_size = HIKP_ARRAY_SIZE(g_ub_dfx_module_parse); + bool is_found; + size_t i; + + for (i = 0; i < arr_size; i++) { + is_found = strncmp(argv, (const char *)g_ub_dfx_module_parse[i].module_name, + sizeof(g_ub_dfx_module_parse[i].module_name)) == 0; + if (is_found) { + g_ub_dfx_param.sub_cmd_code = g_ub_dfx_module_parse[i].sub_cmd_code; + g_ub_dfx_param.module_idx = i; + g_ub_dfx_param.flag |= MODULE_SET_FLAG; + return 0; + } + } + dfx_help_info(self); + snprintf(self->err_str, sizeof(self->err_str), "-m/--module param error!!!"); + self->err_no = -EINVAL; + + return -EINVAL; +} + +static int hikp_ub_dfx_get_blk_data(struct hikp_cmd_ret **cmd_ret, + uint32_t blk_id, uint32_t sub_cmd_code) +{ + struct hikp_cmd_header req_header = { 0 }; + struct ub_dfx_req_para req_data = { 0 }; + + req_data.bdf = g_ub_dfx_param.target.bdf; + req_data.block_id = blk_id; + hikp_cmd_init(&req_header, UB_MOD, GET_UB_DFX_INFO_CMD, sub_cmd_code); + *cmd_ret = hikp_cmd_alloc(&req_header, &req_data, sizeof(req_data)); + + return hikp_rsp_normal_check(*cmd_ret); +} + +static int hikp_ub_get_first_blk_dfx(struct ub_dfx_rsp_head *rsp_head, uint32_t **reg_data, + uint32_t *max_dfx_size, uint32_t *version) +{ + struct ub_dfx_rsp *dfx_rsp = NULL; + struct hikp_cmd_ret *cmd_ret; + int ret; + + ret = hikp_ub_dfx_get_blk_data(&cmd_ret, 0, g_ub_dfx_param.sub_cmd_code); + if (ret < 0) + goto err_out; + + dfx_rsp = (struct ub_dfx_rsp *)(cmd_ret->rsp_data); + *version = cmd_ret->version; + *rsp_head = dfx_rsp->rsp_head; + if (rsp_head->total_blk_num == 0) { + /* if total block number is zero, set total type number to zero anyway */ + rsp_head->total_type_num = 0; + goto err_out; + } + *max_dfx_size = (uint32_t)(rsp_head->total_blk_num * MAX_DFX_DATA_NUM * sizeof(uint32_t)); + *reg_data = (uint32_t *)calloc(1, *max_dfx_size); + if (*reg_data == NULL) { + HIKP_ERROR_PRINT("malloc log memory 0x%x failed.\n", *max_dfx_size); + ret = -ENOMEM; + goto err_out; + } + + if (rsp_head->cur_blk_size > *max_dfx_size) { + free(*reg_data); + *reg_data = NULL; + HIKP_ERROR_PRINT("blk0 reg_data copy size error, data size: 0x%x, max size: 0x%x\n", + rsp_head->cur_blk_size, *max_dfx_size); + ret = -EINVAL; + goto err_out; + } + memcpy(*reg_data, dfx_rsp->reg_data, rsp_head->cur_blk_size); + + *max_dfx_size -= (uint32_t)rsp_head->cur_blk_size; +err_out: + free(cmd_ret); + cmd_ret = NULL; + + return ret; +} + +static int hikp_ub_get_blk_dfx(struct ub_dfx_rsp_head *rsp_head, uint32_t blk_id, + uint32_t *reg_data, uint32_t *max_dfx_size) +{ + struct ub_dfx_rsp *dfx_rsp = NULL; + struct hikp_cmd_ret *cmd_ret; + int ret; + + ret = hikp_ub_dfx_get_blk_data(&cmd_ret, blk_id, g_ub_dfx_param.sub_cmd_code); + if (ret < 0) + goto err_out; + + dfx_rsp = (struct ub_dfx_rsp *)(cmd_ret->rsp_data); + *rsp_head = dfx_rsp->rsp_head; + if (rsp_head->cur_blk_size > *max_dfx_size) { + HIKP_ERROR_PRINT("blk%u reg_data copy size error, " + "data size: 0x%x, max size: 0x%x\n", + blk_id, rsp_head->cur_blk_size, *max_dfx_size); + ret = -EINVAL; + goto err_out; + } + memcpy(reg_data, dfx_rsp->reg_data, rsp_head->cur_blk_size); + *max_dfx_size -= (uint32_t)rsp_head->cur_blk_size; + +err_out: + free(cmd_ret); + cmd_ret = NULL; + + return ret; +} + +static bool is_type_found(uint16_t type_id, uint32_t *index) +{ + size_t arr_size = HIKP_ARRAY_SIZE(g_dfx_type_parse); + size_t i; + + for (i = 0; i < arr_size; i++) { + if (g_dfx_type_parse[i].type_id == type_id) { + *index = i; + return true; + } + } + + return false; +} + +static void hikp_ub_dfx_print_type_head(uint8_t type_id, uint8_t *last_type_id) +{ + uint32_t index = 0; + + if (type_id != *last_type_id) { + printf("-----------------------------------------------------\n"); + if (is_type_found(type_id, &index)) + printf("type name: %s\n\n", g_dfx_type_parse[index].type_name); + else + HIKP_WARN_PRINT("type name: unknown type, type id is %u\n\n", type_id); + + *last_type_id = type_id; + } +} + +static void hikp_ub_dfx_print_b32(uint32_t num, uint32_t *reg_data) +{ + uint32_t word_num = num * WORD_NUM_PER_REG; + uint16_t offset; + uint32_t value; + uint32_t index; + uint32_t i; + + for (i = 0, index = 1; i < word_num; i = i + WORD_NUM_PER_REG, index++) { + offset = (uint16_t)HI_GET_BITFIELD(reg_data[i], 0, DFX_REG_ADDR_MASK); + value = reg_data[i + 1]; + printf("%03u: 0x%04x\t0x%08x\n", index, offset, value); + } +} + +static void hikp_ub_dfx_print_b64(uint32_t num, uint32_t *reg_data) +{ + uint32_t word_num = num * WORD_NUM_PER_REG; + uint16_t offset; + uint64_t value; + uint32_t index; + uint32_t i; + + for (i = 0, index = 1; i < word_num; i = i + WORD_NUM_PER_REG, index++) { + offset = (uint16_t)HI_GET_BITFIELD(reg_data[i], 0, DFX_REG_ADDR_MASK); + value = (uint64_t)reg_data[i + 1] | + (HI_GET_BITFIELD((uint64_t)reg_data[i], DFX_REG_VALUE_OFF, + DFX_REG_VALUE_MASK) << BIT_NUM_OF_WORD); + printf("%03u: 0x%04x\t0x%016lx\n", index, offset, value); + } +} + +static void hikp_ub_dfx_print(const struct ub_dfx_rsp_head *rsp_head, uint32_t *reg_data) +{ + struct ub_dfx_type_head *type_head; + uint8_t last_type_id = 0; + uint32_t *ptr = reg_data; + uint8_t i; + + printf("****************** module %s reg dump start ********************\n", + g_ub_dfx_module_parse[g_ub_dfx_param.module_idx].module_name); + for (i = 0; i < rsp_head->total_type_num; i++) { + type_head = (struct ub_dfx_type_head *)ptr; + if (type_head->type_id == INCORRECT_REG_TYPE) { + HIKP_ERROR_PRINT("No.%u type is incorrect reg type\n", i + 1u); + break; + } + hikp_ub_dfx_print_type_head(type_head->type_id, &last_type_id); + ptr++; + if (type_head->bit_width == WIDTH_32_BIT) { + hikp_ub_dfx_print_b32((uint32_t)type_head->reg_num, ptr); + } else if (type_head->bit_width == WIDTH_64_BIT) { + hikp_ub_dfx_print_b64((uint32_t)type_head->reg_num, ptr); + } else { + HIKP_ERROR_PRINT("type%u's bit width error.\n", type_head->type_id); + break; + } + ptr += (uint32_t)type_head->reg_num * WORD_NUM_PER_REG; + } + printf("################### ====== dump end ====== ######################\n"); +} + +static void hikp_ub_dfx_execute(struct major_cmd_ctrl *self) +{ + struct ub_dfx_rsp_head rsp_head = { 0 }; + struct ub_dfx_rsp_head tmp_head = { 0 }; + uint32_t *reg_data = NULL; + uint32_t max_dfx_size = 0; + uint32_t real_reg_size; + uint32_t version; + uint32_t i; + + if (!(g_ub_dfx_param.flag & MODULE_SET_FLAG)) { + self->err_no = -EINVAL; + snprintf(self->err_str, sizeof(self->err_str), "Please specify a module."); + dfx_help_info(self); + return; + } + + self->err_no = hikp_ub_get_first_blk_dfx(&rsp_head, ®_data, &max_dfx_size, &version); + if (self->err_no != 0) { + snprintf(self->err_str, sizeof(self->err_str), "get the first block dfx fail."); + return; + } + real_reg_size = (uint32_t)rsp_head.cur_blk_size; + for (i = 1; i < rsp_head.total_blk_num; i++) { + self->err_no = hikp_ub_get_blk_dfx(&tmp_head, i, + reg_data + (real_reg_size / sizeof(uint32_t)), + &max_dfx_size); + if (self->err_no != 0) { + snprintf(self->err_str, sizeof(self->err_str), + "getting block%u reg fail.", i); + free(reg_data); + return; + } + real_reg_size += (uint32_t)tmp_head.cur_blk_size; + memset(&tmp_head, 0, sizeof(struct ub_dfx_rsp_head)); + } + + printf("DFX cmd version: 0x%x\n\n", version); + hikp_ub_dfx_print((const struct ub_dfx_rsp_head *)&rsp_head, reg_data); + free(reg_data); +} + +static void cmd_ub_dfx_init(void) +{ + struct major_cmd_ctrl *major_cmd = get_major_cmd(); + + major_cmd->option_count = 0; + major_cmd->execute = hikp_ub_dfx_execute; + + cmd_option_register("-h", "--help", false, hikp_ub_dfx_help); + cmd_option_register("-i", "--interface", true, hikp_ub_dfx_target); + cmd_option_register("-m", "--module", true, hikp_ub_dfx_module_select); +} + +HIKP_CMD_DECLARE("ub_dfx", "dump ub dfx info of hardware", cmd_ub_dfx_init); diff --git a/net/ub/ub_dfx/hikp_ub_dfx.h b/net/ub/ub_dfx/hikp_ub_dfx.h new file mode 100644 index 0000000..4ba37a1 --- /dev/null +++ b/net/ub/ub_dfx/hikp_ub_dfx.h @@ -0,0 +1,100 @@ +/* + * Copyright (c) 2023 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_UB_DFX_H +#define HIKP_UB_DFX_H + +#include "hikp_net_lib.h" + +#define MAX_DFX_DATA_NUM 59 +#define MODULE_SET_FLAG 0x1 + +enum ub_dfx_cmd_type { + LRB_DFX_REG_DUMP = 0, + PFA_DFX_REG_DUMP = 1, + PM_DFX_REG_DUMP = 2, + INVALID_MODULE = 0xFFFFFFFF, +}; + +enum ub_dfx_reg_type { + INCORRECT_REG_TYPE = 0, + TYPE_32_STATS = 1, + TYPE_32_RUNNING_STATUS = 2, + TYPE_64_STATS = 3, + TYPE_INVALID = 255, +}; + +#define MAX_TYPE_NAME_LEN 40 + +enum ub_dfx_reg_width { + WIDTH_32_BIT = 32, + WIDTH_64_BIT = 64, +}; + +struct dfx_type_parse { + uint8_t type_id; + uint8_t bit_width; + uint8_t type_name[MAX_TYPE_NAME_LEN]; +}; + +struct ub_dfx_param { + struct tool_target target; + uint32_t sub_cmd_code; + uint8_t module_idx; + uint8_t flag; +}; + +#define MAX_MODULE_NAME_LEN 20 +struct dfx_module_cmd { + uint8_t module_name[MAX_MODULE_NAME_LEN]; + uint32_t sub_cmd_code; +}; + +struct ub_dfx_req_para { + struct bdf_t bdf; + uint8_t block_id; +}; + +struct ub_dfx_type_head { + uint8_t type_id; + uint8_t bit_width; + uint8_t reg_num; + uint8_t flag; +}; + +struct ub_dfx_rsp_head { + uint8_t total_blk_num; + uint8_t total_type_num; + uint8_t cur_blk_size; + uint8_t rsvd; +}; + +/********************************************************* + * All registers are returned as key-value pairs, and divided + * into three groups of data. + * 1. 32bit regs: R0 bit0~bit15: offset, R1 bit0~bit31: value + * 2. 64bit regs: R0 bit0~bit15: offset, R0 bit16~bit31 high16 value, R1 bit0~bit31: low32 value + *********************************************************/ +#define DFX_REG_VALUE_OFF 16 +#define DFX_REG_VALUE_MASK 0xFFFF +#define DFX_REG_ADDR_MASK 0xFFFF + +#define WORD_NUM_PER_REG 2 +#define BIT_NUM_OF_WORD 32 + +struct ub_dfx_rsp { + struct ub_dfx_rsp_head rsp_head; + uint32_t reg_data[MAX_DFX_DATA_NUM]; +}; + +#endif /* HIKP_UB_DFX_H */ diff --git a/tool_lib/tool_lib.h b/tool_lib/tool_lib.h index b211175..bf37465 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.0.13" +#define TOOL_VER "1.0.14" #define HI_GET_BITFIELD(value, start, mask) (((value) >> (start)) & (mask)) #define HI_SET_FIELD(origin, shift, val) ((origin) |= (val) << (shift)) -- 2.36.1.windows.1

From: veega2022 <zhuweijia@huawei.com> The hikptool ub_link command is submitted for the first time. This command can be used to query the link state machine and status statistics during link establishment. Signed-off-by: Jianqiang Li <lijianqiang16@huawei.com> --- net/ub/ub_link/hikp_ub_link.c | 98 +++++++++++++++++++++++++++++++++++ net/ub/ub_link/hikp_ub_link.h | 53 +++++++++++++++++++ 2 files changed, 151 insertions(+) create mode 100644 net/ub/ub_link/hikp_ub_link.c create mode 100644 net/ub/ub_link/hikp_ub_link.h diff --git a/net/ub/ub_link/hikp_ub_link.c b/net/ub/ub_link/hikp_ub_link.c new file mode 100644 index 0000000..b6353f7 --- /dev/null +++ b/net/ub/ub_link/hikp_ub_link.c @@ -0,0 +1,98 @@ +/* + * Copyright (c) 2023 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_ub_link.h" + +static struct ub_link_param g_ub_link_param = { 0 }; + +static int hikp_ub_link_help(struct major_cmd_ctrl *self, const char *argv) +{ + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i <interface>\n"); + printf("\n %s\n", self->cmd_ptr->help_info); + printf(" Options:\n\n"); + printf(" %s, %-25s %s\n", "-h", "--help", "display this help and exit"); + printf(" %s, %-25s %s\n", "-i", "--interface=<interface>", + "device target or bdf id, e.g. ubn0 or 0000:35:00.0"); + printf("\n"); + return 0; +} + +static int hikp_ub_link_target(struct major_cmd_ctrl *self, const char *argv) +{ + self->err_no = tool_check_and_get_valid_bdf_id(argv, &(g_ub_link_param.target)); + if (self->err_no != 0) { + snprintf(self->err_str, sizeof(self->err_str), "Unknown device %s.", argv); + return self->err_no; + } + + return 0; +} + +static void hikp_ub_link_info_show(const struct ub_link_rsp *info) +{ + printf("%-32s %u\n", "mac id:", info->mac_id); + printf("%-32s %s\n", "hdlc link status:", info->hdlc_link ? "true" : "false"); + printf("%-32s %s\n", "hpcs link status:", info->hpcs_link ? "true" : "false"); + printf("%-32s 0x%08x\n", "hdlc_link_fsm register value:", info->hdlc_link_fsm); + printf("%-32s 0x%08x\n", "hpcs_link_fsm register value:", info->hpcs_link_fsm); +} + +static int hikp_ub_query_link_info(const struct bdf_t *bdf) +{ + struct hikp_cmd_header header = { 0 }; + struct ub_link_req_paras req = { 0 }; + struct hikp_cmd_ret *cmd_ret; + struct ub_link_rsp *rsp; + + req.bdf = *bdf; + hikp_cmd_init(&header, UB_MOD, GET_UB_LINK_INFO_CMD, UB_LINK_INFO_DUMP); + cmd_ret = hikp_cmd_alloc(&header, &req, sizeof(req)); + if (cmd_ret == NULL || cmd_ret->status != 0) { + free(cmd_ret); + cmd_ret = NULL; + return -EIO; + } + + rsp = (struct ub_link_rsp *)cmd_ret->rsp_data; + hikp_ub_link_info_show(rsp); + + free(cmd_ret); + cmd_ret = NULL; + return 0; +} + +static void hikp_ub_link_cmd_execute(struct major_cmd_ctrl *self) +{ + struct bdf_t *bdf = &g_ub_link_param.target.bdf; + int ret; + + ret = hikp_ub_query_link_info(bdf); + if (ret != 0) { + snprintf(self->err_str, sizeof(self->err_str), "fail to get link info."); + self->err_no = ret; + return; + } +} + +static void cmd_ub_link_init(void) +{ + struct major_cmd_ctrl *major_cmd = get_major_cmd(); + + major_cmd->option_count = 0; + major_cmd->execute = hikp_ub_link_cmd_execute; + + cmd_option_register("-h", "--help", false, hikp_ub_link_help); + cmd_option_register("-i", "--interface", true, hikp_ub_link_target); +} + +HIKP_CMD_DECLARE("ub_link", "get ub link information", cmd_ub_link_init); diff --git a/net/ub/ub_link/hikp_ub_link.h b/net/ub/ub_link/hikp_ub_link.h new file mode 100644 index 0000000..dec5129 --- /dev/null +++ b/net/ub/ub_link/hikp_ub_link.h @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2023 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. + */ + +/* + * Copyright (c) 2023 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_UB_LINK_H +#define HIKP_UB_LINK_H + +#include "hikp_net_lib.h" + +enum ub_link_sub_cmd_type { + UB_LINK_INFO_DUMP = 0, +}; + +struct ub_link_param { + struct tool_target target; +}; + +struct ub_link_req_paras { + struct bdf_t bdf; +}; + +struct ub_link_rsp { + uint8_t mac_id; + uint8_t hdlc_link; + uint8_t hpcs_link; + uint8_t rsvd; + uint32_t hdlc_link_fsm; + uint32_t hpcs_link_fsm; +}; + +#endif /* HIKP_UB_LINK_H */ -- 2.36.1.windows.1

From: veega2022 <zhuweijia@huawei.com> The hikptool ub_crd command is submitted for the first time. This command is used to query the letter of credit status by reading the register value. Signed-off-by: Jianqiang Li <lijianqiang16@huawei.com> --- net/ub/ub_crd/hikp_ub_crd.c | 133 ++++++++++++++++++++++++++++++++++++ net/ub/ub_crd/hikp_ub_crd.h | 44 ++++++++++++ 2 files changed, 177 insertions(+) create mode 100644 net/ub/ub_crd/hikp_ub_crd.c create mode 100644 net/ub/ub_crd/hikp_ub_crd.h diff --git a/net/ub/ub_crd/hikp_ub_crd.c b/net/ub/ub_crd/hikp_ub_crd.c new file mode 100644 index 0000000..d5d0015 --- /dev/null +++ b/net/ub/ub_crd/hikp_ub_crd.c @@ -0,0 +1,133 @@ +/* + * Copyright (c) 2023 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_ub_crd.h" + +static struct ub_crd_param g_ub_crd_param = { 0 }; + +static int hikp_ub_crd_help(struct major_cmd_ctrl *self, const char *argv) +{ + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i <interface>\n"); + printf("\n %s\n", self->cmd_ptr->help_info); + printf(" Options:\n\n"); + printf(" %s, %-25s %s\n", "-h", "--help", "display this help and exit"); + printf(" %s, %-25s %s\n", "-i", "--interface=<interface>", + "device target or bdf id, e.g. ubn0 or 0000:35:00.0"); + printf("\n"); + return 0; +} + +static int hikp_ub_crd_target(struct major_cmd_ctrl *self, const char *argv) +{ + self->err_no = tool_check_and_get_valid_bdf_id(argv, &(g_ub_crd_param.target)); + if (self->err_no) { + snprintf(self->err_str, sizeof(self->err_str), "Unknown device %s.", argv); + return self->err_no; + } + return 0; +} + +static int hikp_ub_show_crd(uint32_t off, struct ub_crd_rsp *crd_rsp, uint32_t num_rows, + char const *crds[][2]) +{ + int reg_index; + int i; + + for (i = 0; i < num_rows; i++) { + union cut_reg reg; + + reg_index = off + i; + reg.value = crd_rsp->cut_reg_value[reg_index]; + if (strcmp(crds[i][0], "NULL") != 0) + printf("%-28s : %#x\n", crds[i][0], reg.cut[0]); + + if (strcmp(crds[i][1], "NULL") != 0) + printf("%-28s : %#x\n", crds[i][1], reg.cut[1]); + } + return off + num_rows; +} + +static int hikp_ub_query_crd(void) +{ + struct hikp_cmd_header req_header = { 0 }; + struct ub_crd_req_para req_data = { 0 }; + struct hikp_cmd_ret *cmd_ret = NULL; + struct ub_crd_rsp *crd_rsp = NULL; + int offset; + int ret; + + char const *init_crds[][2] = { + {"CFG_REMOTE_ICRD", "CFG_REMOTE_LCRD"}, + {"CFG_REMOTE_CRD_VL6", "CFG_REMOTE_CRD_VL7"}, + {"CFG_REMOTE_CRD_VL4", "CFG_REMOTE_CRD_VL5"}, + {"CFG_REMOTE_CRD_VL2", "CFG_REMOTE_CRD_VL3"}, + {"CFG_REMOTE_CRD_VL0", "CFG_REMOTE_CRD_VL1"}, + {"CFG_REMOTE_CRD_VL8", "NULL"} }; + + char const *temp_crds[][2] = { + {"TX_LCRD_VNA_EXIST_NUM", "NULL"}, {"TX_ICRD_VNA_EXIST_NUM", "NULL"}, + {"TX_CRD_VN0_EXIST_NUM", "NULL"}, {"TX_CRD_VN1_EXIST_NUM", "NULL"}, + {"TX_CRD_VN2_EXIST_NUM", "NULL"}, {"TX_CRD_VN3_EXIST_NUM", "NULL"}, + {"TX_CRD_VN4_EXIST_NUM", "NULL"}, {"TX_CRD_VN5_EXIST_NUM", "NULL"}, + {"TX_CRD_VN6_EXIST_NUM", "NULL"}, {"TX_CRD_VN7_EXIST_NUM", "NULL"}, + {"TX_ACK_EXIST_NUM", "NULL"}, {"TX_ROH_LCRD_LOCAL_NUM", "NULL"} }; + + hikp_cmd_init(&req_header, UB_MOD, GET_UB_CRD_INFO_CMD, UB_CRD_INFO_DUMP); + req_data.bdf = g_ub_crd_param.target.bdf; + cmd_ret = hikp_cmd_alloc(&req_header, &req_data, sizeof(req_data)); + if (cmd_ret == NULL || cmd_ret->status != 0) { + free(cmd_ret); + cmd_ret = NULL; + return -EIO; + } + + crd_rsp = (struct ub_crd_rsp *)(cmd_ret->rsp_data); + + printf("******************** CREDIT CNT START ********************\n"); + printf("------------------- INIT CREDIT START -----------------\n"); + offset = hikp_ub_show_crd(0, crd_rsp, NUM_ROWS_INIT_CRDS, init_crds); + printf("------------------- INIT CREDIT END --------------------\n"); + printf("------------------- TEMP CREDIT START ------------------\n"); + offset = hikp_ub_show_crd(offset, crd_rsp, NUM_ROWS_TEMP_CRDS, temp_crds); + printf("------------------- TEMP CREDIT END --------------------\n"); + printf("********************* CREDIT CNT END *********************\n"); + + free(cmd_ret); + cmd_ret = NULL; + return 0; +} + +static void hikp_ub_crd_cmd_execute(struct major_cmd_ctrl *self) +{ + int ret; + + ret = hikp_ub_query_crd(); + if (ret != 0) { + snprintf(self->err_str, sizeof(self->err_str), "fail to get ub crd info."); + self->err_no = ret; + return; + } +} + +static void cmd_ub_crd_init(void) +{ + struct major_cmd_ctrl *major_cmd = get_major_cmd(); + + major_cmd->option_count = 0; + major_cmd->execute = hikp_ub_crd_cmd_execute; + + cmd_option_register("-h", "--help", false, hikp_ub_crd_help); + cmd_option_register("-i", "--interface", true, hikp_ub_crd_target); +} + +HIKP_CMD_DECLARE("ub_crd", "get ub crd information", cmd_ub_crd_init); diff --git a/net/ub/ub_crd/hikp_ub_crd.h b/net/ub/ub_crd/hikp_ub_crd.h new file mode 100644 index 0000000..5dfa38a --- /dev/null +++ b/net/ub/ub_crd/hikp_ub_crd.h @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2023 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_UB_CRD_H +#define HIKP_UB_CRD_H + +#include "hikp_net_lib.h" + +#define MAX_CRD_SIZE 20 +#define NUM_ROWS_INIT_CRDS 6 +#define NUM_ROWS_TEMP_CRDS 12 + +enum ub_crd_sub_cmd_type { + UB_CRD_INFO_DUMP = 0, +}; + +union cut_reg { + uint32_t value; + uint16_t cut[2]; +}; + +struct ub_crd_param { + struct tool_target target; +}; + +struct ub_crd_req_para { + struct bdf_t bdf; +}; + +struct ub_crd_rsp { + uint32_t cut_reg_value[MAX_CRD_SIZE]; +}; + +#endif /* HIKP_UB_CRD_H */ -- 2.36.1.windows.1

From: veega2022 <zhuweijia@huawei.com> The function of reading IP and guid entries through the imp command is added. Signed-off-by: Jianqiang Li <lijianqiang16@huawei.com> --- net/ub/ub_unic/hikp_unic_ppp.c | 468 +++++++++++++++++++++++++++++++++ net/ub/ub_unic/hikp_unic_ppp.h | 139 ++++++++++ 2 files changed, 607 insertions(+) create mode 100644 net/ub/ub_unic/hikp_unic_ppp.c create mode 100644 net/ub/ub_unic/hikp_unic_ppp.h diff --git a/net/ub/ub_unic/hikp_unic_ppp.c b/net/ub/ub_unic/hikp_unic_ppp.c new file mode 100644 index 0000000..5325b03 --- /dev/null +++ b/net/ub/ub_unic/hikp_unic_ppp.c @@ -0,0 +1,468 @@ +/* + * Copyright (c) 2023 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 <string.h> +#include <stdio.h> +#include <sys/types.h> +#include <arpa/inet.h> +#include <unistd.h> +#include "hikp_unic_ppp.h" + +static struct hikp_unic_ppp_hw_resources g_unic_ppp_hw_res = { 0 }; +static struct unic_ppp_param g_unic_ppp_param = { 0 }; + +static void hikp_unic_ppp_show_ip_tbl(const void *data); +static void hikp_unic_ppp_show_guid_tbl(const void *data); + +static int hikp_unic_query_ppp_ip_tbl(struct hikp_cmd_header *req_header, + const struct bdf_t *bdf, void *data); +static int hikp_unic_query_ppp_guid_tbl(struct hikp_cmd_header *req_header, + const struct bdf_t *bdf, void *data); + +static const struct unic_ppp_feature_cmd g_unic_ppp_feature_cmd[] = { + { UNIC_PPP_IP_TBL_NAME, UNIC_IP_TBL_DUMP, true, + hikp_unic_query_ppp_ip_tbl, hikp_unic_ppp_show_ip_tbl }, + { UNIC_PPP_GUID_TBL_NAME, UNIC_GUID_TBL_DUMP, true, + hikp_unic_query_ppp_guid_tbl, hikp_unic_ppp_show_guid_tbl }, +}; + +static int hikp_unic_ppp_cmd_help(struct major_cmd_ctrl *self, const char *argv) +{ + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i <interface>"); + 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", "-i", "--interface=<interface>", + "device target or bdf id, e.g. ubn0 or 0000:35:00.0"); + printf(" %s, %-24s %s\n", "-du", "--dump", "dump ip or guid table info."); + + return 0; +} + +static int hikp_unic_cmd_get_ppp_target(struct major_cmd_ctrl *self, const char *argv) +{ + self->err_no = tool_check_and_get_valid_bdf_id(argv, &(g_unic_ppp_param.target)); + if (self->err_no != 0) { + snprintf(self->err_str, sizeof(self->err_str), "unknown device!"); + return self->err_no; + } + + return 0; +} + +static int hikp_unic_cmd_ppp_feature_select(struct major_cmd_ctrl *self, const char *argv) +{ + size_t feat_size = HIKP_ARRAY_SIZE(g_unic_ppp_feature_cmd); + size_t i; + + for (i = 0; i < feat_size; i++) { + if (strncmp(argv, g_unic_ppp_feature_cmd[i].feature_name, + HIKP_UNIC_PPP_MAX_FEATURE_NAME_LEN) == 0) { + g_unic_ppp_param.feature_idx = i; + return 0; + } + } + + hikp_unic_ppp_cmd_help(self, NULL); + snprintf(self->err_str, sizeof(self->err_str), "please input valid dump type."); + self->err_no = -EINVAL; + + return self->err_no; +} + +static int hikp_unic_ppp_get_blk(struct hikp_cmd_header *req_header, + const struct unic_ppp_req_para *req_data, void *buf, + size_t buf_len, struct unic_ppp_rsp_head *rsp_head) +{ + struct hikp_cmd_ret *cmd_ret; + struct unic_ppp_rsp *rsp; + int ret = 0; + + cmd_ret = hikp_cmd_alloc(req_header, req_data, sizeof(*req_data)); + if (cmd_ret == NULL || cmd_ret->status != 0) { + ret = -EIO; + goto out; + } + + rsp = (struct unic_ppp_rsp *)cmd_ret->rsp_data; + if (rsp->rsp_head.cur_blk_size > buf_len) { + HIKP_ERROR_PRINT("unic_ppp block context copy size error, " + "buffer size=%llu, data size=%u.\n", + buf_len, rsp->rsp_head.cur_blk_size); + ret = -EINVAL; + goto out; + } + memcpy(buf, rsp->rsp_data, rsp->rsp_head.cur_blk_size); + memcpy(rsp_head, &rsp->rsp_head, sizeof(struct unic_ppp_rsp_head)); + +out: + free(cmd_ret); + return ret; +} + +static int hikp_unic_query_ppp_by_blkid(struct hikp_cmd_header *req_header, const struct bdf_t *bdf, + void *data, size_t len) +{ + struct unic_ppp_rsp_head rsp_head = { 0 }; + struct unic_ppp_req_para req_data = { 0 }; + uint32_t total_blk_size; + uint8_t blk_id = 0; + int ret = 0; + + req_data.bdf = *bdf; + req_data.block_id = blk_id; + ret = hikp_unic_ppp_get_blk(req_header, &req_data, data, len, &rsp_head); + if (ret != 0) { + HIKP_ERROR_PRINT("Fail to get block-%u context.\n", blk_id); + return ret; + } + total_blk_size = rsp_head.cur_blk_size; + + for (blk_id = 1; blk_id < rsp_head.total_blk_num; blk_id++) { + req_data.block_id = blk_id; + ret = hikp_unic_ppp_get_blk(req_header, &req_data, (uint8_t *)data + total_blk_size, + len - total_blk_size, &rsp_head); + if (ret != 0) { + HIKP_ERROR_PRINT("Fail to get block-%u context.\n", blk_id); + return ret; + } + total_blk_size += rsp_head.cur_blk_size; + } + + return ret; +} + +static int hikp_unic_get_ppp_entry_hw_res(const struct bdf_t *bdf, + struct hikp_unic_ppp_hw_resources *hw_res) +{ + struct hikp_cmd_header req_header = { 0 }; + + hikp_cmd_init(&req_header, UB_MOD, GET_UNIC_PPP_CMD, UNIC_PPP_ENTRY_HW_SPEC_GET); + return hikp_unic_query_ppp_by_blkid(&req_header, bdf, hw_res, + sizeof(struct hikp_unic_ppp_hw_resources)); +} + +static int hikp_unic_ppp_alloc_ip_tbl_entry(const struct hikp_unic_ppp_hw_resources *hw_res, + struct unic_ip_tbl *ip_tbl) +{ + uint32_t max_ip_entry_size; + + max_ip_entry_size = hw_res->ip_max_mem_size + hw_res->ip_overflow_size; + if (max_ip_entry_size == 0) { + HIKP_ERROR_PRINT("ip tbl query is not supported\n"); + return -EIO; + } + ip_tbl->entry = (struct unic_ip_entry *)calloc(max_ip_entry_size, + sizeof(struct unic_ip_entry)); + if (ip_tbl->entry == NULL) { + HIKP_ERROR_PRINT("fail to alloc ip_table_entry memory.\n"); + return -ENOMEM; + } + + return 0; +} + +static int hikp_unic_ppp_alloc_guid_tbl_entry(const struct hikp_unic_ppp_hw_resources *hw_res, + struct unic_guid_tbl *guid_tbl) +{ + if (hw_res->uc_guid_tbl_size == 0 && hw_res->mc_guid_tbl_size == 0) { + HIKP_ERROR_PRINT("guid tbl query is not supported\n"); + return -EIO; + } + guid_tbl->uc_tbl.entry = (struct unic_guid_uc_entry *)calloc(hw_res->uc_guid_tbl_size, + sizeof(struct unic_guid_uc_entry)); + if (guid_tbl->uc_tbl.entry == NULL) { + HIKP_ERROR_PRINT("fail to alloc uc_guid_entry_table memory.\n"); + return -ENOMEM; + } + + guid_tbl->mc_tbl.entry = (struct unic_guid_mc_entry *)calloc(hw_res->mc_guid_tbl_size, + sizeof(struct unic_guid_mc_entry)); + if (guid_tbl->mc_tbl.entry == NULL) { + HIKP_ERROR_PRINT("fail to alloc mc_guid_entry_table memory.\n"); + free(guid_tbl->uc_tbl.entry); + return -ENOMEM; + } + + return 0; +} + +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) +{ + union unic_ppp_feature_info *unic_ppp_data; + int ret = -1; + + unic_ppp_data = (union unic_ppp_feature_info *)calloc(1, + sizeof(union unic_ppp_feature_info)); + if (unic_ppp_data == NULL) { + HIKP_ERROR_PRINT("Fail to allocate unic_ppp_feature_info memory.\n"); + return NULL; + } + + if (g_unic_ppp_param.feature_idx == UNIC_PPP_IP_FEATURE_IDX) { + ret = hikp_unic_ppp_alloc_ip_tbl_entry(hw_res, &unic_ppp_data->ip_tbl); + } else if (g_unic_ppp_param.feature_idx == UNIC_PPP_GUID_FEATURE_IDX) { + ret = hikp_unic_ppp_alloc_guid_tbl_entry(hw_res, &unic_ppp_data->guid_tbl); + } + + if (ret != 0) { + goto out; + } + + return unic_ppp_data; +out: + free(unic_ppp_data); + return NULL; +} + +static int hikp_unic_query_ppp_ip_tbl(struct hikp_cmd_header *req_header, const struct bdf_t *bdf, + void *data) +{ + struct unic_ip_tbl *ip_tbl = (struct unic_ip_tbl *)data; + struct unic_ppp_rsp_head unic_rsp_head = { 0 }; + struct unic_ppp_req_para req_data = { 0 }; + uint32_t max_ip_entry_size; + uint32_t entry_size = 0; + size_t left_buf_len = 0; + uint32_t index = 0; + int ret = -1; + + max_ip_entry_size = g_unic_ppp_hw_res.ip_max_mem_size + g_unic_ppp_hw_res.ip_overflow_size; + req_data.bdf = *bdf; + while (index < max_ip_entry_size) { + req_data.cur_entry_idx = index; + left_buf_len = sizeof(struct unic_ip_entry) * (max_ip_entry_size - entry_size); + ret = hikp_unic_ppp_get_blk(req_header, &req_data, ip_tbl->entry + entry_size, + left_buf_len, &unic_rsp_head); + if (ret != 0) { + HIKP_ERROR_PRINT("Fail to get the ip entry after index=%u, ret=%d.\n", + index, ret); + return ret; + } + entry_size += unic_rsp_head.cur_blk_entry_cnt; + index = unic_rsp_head.next_entry_idx; + } + ip_tbl->entry_size = entry_size; + + return ret; +} + +static int hikp_unic_query_ppp_guid_tbl(struct hikp_cmd_header *req_header, + const struct bdf_t *bdf, void *data) +{ + struct unic_guid_tbl *guid_tbl = (struct unic_guid_tbl*)data; + struct unic_ppp_rsp_head unic_rsp_head = { 0 }; + struct unic_ppp_req_para req_data = { 0 }; + uint32_t entry_size = 0; + size_t left_buf_len = 0; + uint32_t index = 0; + int ret = -1; + + req_data.bdf = *bdf; + req_data.is_unicast = 1; + while (index < g_unic_ppp_hw_res.uc_guid_tbl_size) { + req_data.cur_entry_idx = index; + left_buf_len = sizeof(struct unic_guid_uc_entry) * + (g_unic_ppp_hw_res.uc_guid_tbl_size - entry_size); + ret = hikp_unic_ppp_get_blk(req_header, &req_data, + guid_tbl->uc_tbl.entry + entry_size, + left_buf_len, &unic_rsp_head); + if (ret != 0) { + HIKP_ERROR_PRINT("Fail to get the uc_guid entry after index=%u, ret=%d.\n", + index, ret); + return ret; + } + entry_size += unic_rsp_head.cur_blk_entry_cnt; + index = unic_rsp_head.next_entry_idx; + } + guid_tbl->uc_tbl.entry_size = entry_size; + + left_buf_len = 0; + entry_size = 0; + index = 0; + req_data.is_unicast = 0; + + while (index < g_unic_ppp_hw_res.mc_guid_tbl_size) { + req_data.cur_entry_idx = index; + left_buf_len = sizeof(struct unic_guid_mc_entry) * + (g_unic_ppp_hw_res.mc_guid_tbl_size - entry_size); + ret = hikp_unic_ppp_get_blk(req_header, &req_data, + guid_tbl->mc_tbl.entry + entry_size, + left_buf_len, &unic_rsp_head); + if (ret != 0) { + HIKP_ERROR_PRINT("Fail to get the mc_guid entry after index=%u, ret=%d.\n", + index, ret); + return ret; + } + entry_size += unic_rsp_head.cur_blk_entry_cnt; + index = unic_rsp_head.next_entry_idx; + } + guid_tbl->mc_tbl.entry_size = entry_size; + + return ret; +} + +static void hikp_unic_ppp_show_ip_tbl(const void *data) +{ + struct unic_ip_tbl *ip_tbl = (struct unic_ip_tbl *)data; + struct unic_ip_entry *entry; + uint16_t *ip_addr_tbl_str; + int i, j; + + printf("ip_table_size = %u\n", ip_tbl->entry_size); + printf("index\t| func_id\t| ip_addr\n"); + for (i = 0; i < ip_tbl->entry_size; i++) { + entry = &ip_tbl->entry[i]; + ip_addr_tbl_str = (uint16_t *)entry->ip_addr; + printf("%-4u\t| %-3u\t\t| ", entry->index, entry->function_id); + for (j = 0; j < IP_ADDR_TBL_LEN - 1; j++) + printf("%04x:" , ntohs(ip_addr_tbl_str[j])); + printf("%04x\n", ntohs(ip_addr_tbl_str[IP_ADDR_TBL_LEN - 1])); + } +} + +static void hikp_unic_ppp_show_guid_tbl(const void *data) +{ + struct unic_guid_tbl *guid_tbl = (struct unic_guid_tbl *)data; + uint32_t cnt; + int i; + + printf("unicast guid num : %u\n", guid_tbl->uc_tbl.entry_size); + if (guid_tbl->uc_tbl.entry_size > 0) { + printf("| num\t| func id | GUID \n"); + for (cnt = 0; cnt < guid_tbl->uc_tbl.entry_size; cnt++) { + printf("| %3u\t| %7u | ", cnt, guid_tbl->uc_tbl.entry[cnt].function_id); + for (i = 0; i < HIKP_UNIC_GUID_ADDR_LEN - 1; i++) { + printf("%02x:", guid_tbl->uc_tbl.entry[cnt].guid_addr[i]); + } + printf("%02x\n", + guid_tbl->uc_tbl.entry[cnt].guid_addr[HIKP_UNIC_GUID_ADDR_LEN - 1]); + } + } + + printf("multicast guid num : %u\n", guid_tbl->mc_tbl.entry_size); + if (guid_tbl->mc_tbl.entry_size > 0) { + printf("| num\t| idx\t| %-48s\t| bitmap\n", "GUID"); + for (cnt = 0; cnt < guid_tbl->mc_tbl.entry_size; cnt++) { + printf("| %3u\t| %4u\t| ", cnt, guid_tbl->mc_tbl.entry[cnt].idx); + for (i = 0; i < HIKP_UNIC_GUID_ADDR_LEN - 1; i++) { + printf("%02x:", guid_tbl->mc_tbl.entry[cnt].guid_addr[i]); + } + printf("%02x\t| ", + guid_tbl->mc_tbl.entry[cnt].guid_addr[HIKP_UNIC_GUID_ADDR_LEN - 1]); + for (i = HIKP_UNIC_GUID_BITMAP_LEN - 1; i > 0; i--) { + printf("%08x:", guid_tbl->mc_tbl.entry[cnt].function_bitmap[i]); + } + printf("%08x\n", guid_tbl->mc_tbl.entry[cnt].function_bitmap[0]); + } + } +} + +static int hikp_unic_ppp_check_input_param(struct major_cmd_ctrl *self, + const struct unic_ppp_param *ppp_param) +{ + const struct bdf_t *bdf = &ppp_param->target.bdf; + + if (bdf->dev_id != 0) { + snprintf(self->err_str, sizeof(self->err_str), "VF does not support query!"); + self->err_no = -EINVAL; + return self->err_no; + } + + if (ppp_param->feature_idx == UNIC_PPP_INIT_FEATURE_IDX) { + hikp_unic_ppp_cmd_help(self, NULL); + snprintf(self->err_str, sizeof(self->err_str), "-du/--dump parameter error!"); + self->err_no = -EINVAL; + return self->err_no; + } + + return 0; +} + +static void hikp_unic_ppp_data_free(union unic_ppp_feature_info *unic_ppp_data) +{ + struct unic_guid_tbl *guid_tbl; + struct unic_ip_tbl *ip_tbl; + + if (g_unic_ppp_param.feature_idx == UNIC_PPP_IP_FEATURE_IDX) { + ip_tbl = &unic_ppp_data->ip_tbl; + free(ip_tbl->entry); + } else if (g_unic_ppp_param.feature_idx == UNIC_PPP_GUID_FEATURE_IDX) { + guid_tbl = &unic_ppp_data->guid_tbl; + free(guid_tbl->uc_tbl.entry); + free(guid_tbl->mc_tbl.entry); + } + + free(unic_ppp_data); +} + +static void hikp_unic_ppp_cmd_execute(struct major_cmd_ctrl *self) +{ + const struct unic_ppp_feature_cmd *unic_ppp_cmd; + union unic_ppp_feature_info *unic_ppp_data; + struct hikp_cmd_header req_header = {0}; + int ret; + + ret = hikp_unic_ppp_check_input_param(self, &g_unic_ppp_param); + if (ret != 0) + return; + + ret = hikp_unic_get_ppp_entry_hw_res(&g_unic_ppp_param.target.bdf, &g_unic_ppp_hw_res); + if (ret != 0) { + snprintf(self->err_str, sizeof(self->err_str), + "fail to obtain unic_ppp hardware resources."); + self->err_no = ret; + return; + } + + 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); + if (unic_ppp_data == NULL) { + snprintf(self->err_str, sizeof(self->err_str), + "failed to allocate unic_ppp_data memory!"); + self->err_no = -ENOMEM; + return; + } + + hikp_cmd_init(&req_header, UB_MOD, GET_UNIC_PPP_CMD, unic_ppp_cmd->sub_cmd_code); + ret = unic_ppp_cmd->query(&req_header, &g_unic_ppp_param.target.bdf, unic_ppp_data); + if (ret != 0) { + snprintf(self->err_str, sizeof(self->err_str), + "failed to query %s info, ret = %d.", unic_ppp_cmd->feature_name, ret); + self->err_no = ret; + goto out; + } + + printf("############## UNIC_PPP: %s info ############\n", unic_ppp_cmd->feature_name); + unic_ppp_cmd->show(unic_ppp_data); + printf("#################### END #######################\n"); + +out: + hikp_unic_ppp_data_free(unic_ppp_data); +} + +static void cmd_unic_get_ppp_init(void) +{ + struct major_cmd_ctrl *major_cmd = get_major_cmd(); + + g_unic_ppp_param.feature_idx = UNIC_PPP_INIT_FEATURE_IDX; + major_cmd->execute = hikp_unic_ppp_cmd_execute; + + cmd_option_register("-h", "--help", false, hikp_unic_ppp_cmd_help); + cmd_option_register("-i", "--interface", true, hikp_unic_cmd_get_ppp_target); + cmd_option_register("-du", "--dump", true, hikp_unic_cmd_ppp_feature_select); +} + +HIKP_CMD_DECLARE("unic_ppp", "dump ppp info of unic!", cmd_unic_get_ppp_init); \ No newline at end of file diff --git a/net/ub/ub_unic/hikp_unic_ppp.h b/net/ub/ub_unic/hikp_unic_ppp.h new file mode 100644 index 0000000..c25fabd --- /dev/null +++ b/net/ub/ub_unic/hikp_unic_ppp.h @@ -0,0 +1,139 @@ +/* + * Copyright (c) 2023 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_UNIC_PPP_H +#define HIKP_UNIC_PPP_H + +#include "hikp_net_lib.h" + +#define HIKP_UNIC_IP_ADDR_FMT_SIZE 50 +#define MAX_IP_ADDR_STR_LEN 50 +#define IP_ADDR_LEN 16 +#define IP_ADDR_TBL_LEN 8 + +#define HIKP_UNIC_IP_ADDR_LEN 4 +#define HIKP_UNIC_GUID_BITMAP_LEN 8 +#define HIKP_UNIC_GUID_ADDR_LEN 16 + +#define UNIC_PPP_MAX_RSP_DATA 57 +#define HIKP_UNIC_PPP_MAX_FEATURE_NAME_LEN 20 + +#define UNIC_PPP_IP_TBL_NAME "ip" +#define UNIC_PPP_GUID_TBL_NAME "guid" + +enum unic_ppp_sub_cmd_type { + UNIC_PPP_ENTRY_HW_SPEC_GET = 0, + UNIC_IP_TBL_DUMP, + UNIC_GUID_TBL_DUMP, +}; + +enum unic_ppp_feature_idx { + UNIC_PPP_IP_FEATURE_IDX = 0, + UNIC_PPP_GUID_FEATURE_IDX, + UNIC_PPP_INIT_FEATURE_IDX = -1, +}; + +struct hikp_unic_ppp_hw_resources { + uint16_t uc_guid_tbl_size; + uint16_t mc_guid_tbl_size; + uint32_t ip_max_mem_size; + uint32_t ip_overflow_size; + uint32_t rsv; + /* port information */ + uint16_t total_func_num; /* contain PF and VF. */ + uint16_t abs_func_id_base; /* The absolute func_id of the first VF in this port. */ + uint32_t rsv1[11]; +}; + +struct unic_ip_entry { + uint32_t index; + uint32_t function_id; + uint32_t ip_addr[HIKP_UNIC_IP_ADDR_LEN]; +}; + +struct unic_ip_tbl { + uint32_t entry_size; + struct unic_ip_entry *entry; +}; + +struct unic_guid_uc_entry { + uint32_t function_id; + uint8_t guid_addr[HIKP_UNIC_GUID_ADDR_LEN]; +}; + +struct unic_guid_uc_tbl { + uint32_t entry_size; + struct unic_guid_uc_entry *entry; +}; + +struct unic_guid_mc_entry { + uint32_t idx; + uint8_t guid_addr[HIKP_UNIC_GUID_ADDR_LEN]; + uint32_t function_bitmap[8]; +}; + +struct unic_guid_mc_tbl { + uint32_t entry_size; + struct unic_guid_mc_entry *entry; +}; + +struct unic_guid_tbl { + struct unic_guid_uc_tbl uc_tbl; + struct unic_guid_mc_tbl mc_tbl; +}; + +union unic_ppp_feature_info { + struct unic_guid_tbl guid_tbl; + struct unic_ip_tbl ip_tbl; +}; + +struct unic_ppp_feature_cmd { + const char feature_name[HIKP_UNIC_PPP_MAX_FEATURE_NAME_LEN]; + uint32_t sub_cmd_code; + bool need_query_hw_res; + int (*query)(struct hikp_cmd_header *req_header, + const struct bdf_t *bdf, void *data); + void (*show)(const void *data); +}; + +struct unic_ppp_param { + struct tool_target target; + int feature_idx; +}; + +struct unic_ppp_req_para { + struct bdf_t bdf; + uint8_t block_id; + union { + uint8_t is_unicast; /* 1: uc GUID, 0: mc GUID. */ + uint8_t rsv; /* firmware ignores it if isn't used to query GUID table. */ + }; + uint8_t rsv1[2]; + uint32_t cur_entry_idx; /* firmware queries GUID/IP table from the value. */ +}; + +struct unic_ppp_rsp_head { + uint8_t total_blk_num; + uint8_t cur_blk_size; /* real data size, not contain head size. */ + uint16_t rsv; + /* firmware must set following fields when query GUID/IP table. */ + uint32_t next_entry_idx; + uint32_t cur_blk_entry_cnt; +}; + +typedef struct unic_ppp_rsp { + struct unic_ppp_rsp_head rsp_head; /* 12 Byte */ + uint32_t rsp_data[UNIC_PPP_MAX_RSP_DATA]; +} unic_ppp_rsp_t; + +#endif /* HIKP_UNIC_PPP_H */ -- 2.36.1.windows.1

From: veega2022 <zhuweijia@huawei.com> Add a space on the left and right of the "=" Signed-off-by: veega2022 <zhuweijia@huawei.com> --- socip/hikp_socip_dumpreg.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/socip/hikp_socip_dumpreg.c b/socip/hikp_socip_dumpreg.c index b74dac8..32325bb 100644 --- a/socip/hikp_socip_dumpreg.c +++ b/socip/hikp_socip_dumpreg.c @@ -142,7 +142,7 @@ static void hikp_socip_dumpreg_execute(struct major_cmd_ctrl *self) hikp_cmd_init(&req_header, SOCIP_MOD, HIKP_SOCIP_CMD_DUMPREG, param[MODULE_ID_INDEX].val); cmd_ret = hikp_cmd_alloc(&req_header, &req_data, sizeof(req_data)); if (!cmd_ret) { - self->err_no=-EINVAL; + self->err_no = -EINVAL; HIKP_ERROR_PRINT("hikp_cmd_alloc\n"); return; } -- 2.36.1.windows.1

From: huangguanhua <huangguanhua3@huawei.com> Signed-off-by: huangguanhua <huangguanhua3@huawei.com> --- serdes/hikp_serdes.c | 12 ++++++++---- serdes/hikp_serdes.h | 3 ++- tool_lib/op_logs.c | 6 +++--- 3 files changed, 13 insertions(+), 8 deletions(-) diff --git a/serdes/hikp_serdes.c b/serdes/hikp_serdes.c index dd9eee3..527fd53 100644 --- a/serdes/hikp_serdes.c +++ b/serdes/hikp_serdes.c @@ -184,21 +184,22 @@ static void hikp_serdes_brief_info_print(struct major_cmd_ctrl *self, "Tap16,Tap17,Tap18,Tap19,Tap20]\n" \ "FWFourEye: It only takes effect when the firmware is running and " \ "continuous adaptation is turned on\n" \ + "Snr: [SNR_METRIC,SNR_METRIC_HIS_MIN,SNR_CYCLES,HEH,SNR_METRIC_SW]\n" \ "-----------------------------------------------------" \ "------------------------------------------------" \ "-----------------------------------------------------" \ "------------------------------------------------" \ - "-------------------\n" \ + "--------------------------------\n" \ " [ FFE ]" \ "[ CTLE ]" \ "[ " \ "DFE ]" \ - "[ FWFourEye ][ snr ]\n" \ + "[ FWFourEye ][ Snr ]\n" \ "-----------------------------------------------------" \ "-------------------------------------------------" \ "-----------------------------------------------------" \ "-------------------------------------------------" \ - "------------------\n") + "--------------------------------\n") static void hikp_serdes_detail_info_print(struct major_cmd_ctrl *self, const struct hilink_detail_info *data, @@ -233,7 +234,10 @@ static void hikp_serdes_detail_info_print(struct major_cmd_ctrl *self, printf("][%4d,%4d,%4d,%4d]", data[ds_id].eye_diagram.top, data[ds_id].eye_diagram.bottom, data[ds_id].eye_diagram.left, data[ds_id].eye_diagram.right); - printf("[%7d]\n", data[ds_id].snr); + /* 0: SNR_METRIC, 1:SNR_METRIC_HIS_MIN */ + printf("[%3d,%3d,%3d,%3d,%3d]\n", data[ds_id].snr_para[0], data[ds_id].snr_para[1], + /* 2:SNR_CYCLES, 3:HEH, 4:SNR_METRIC_SW */ + data[ds_id].snr_para[2], data[ds_id].snr_para[3], data[ds_id].snr_para[4]); } } diff --git a/serdes/hikp_serdes.h b/serdes/hikp_serdes.h index 99b9b15..83c28b8 100644 --- a/serdes/hikp_serdes.h +++ b/serdes/hikp_serdes.h @@ -192,7 +192,8 @@ struct hilink_detail_info { struct hilink_rx_param rx_ctle_cfg; struct hilink_serdes_rx_tap rx_tap_cfg; struct hilink_4p_eye_result eye_diagram; - uint32_t snr; + /* 5: (0: SNR_METRIC, 1:SNR_METRIC_HIS_MIN, 2:SNR_CYCLES, 3:HEH, 4:SNR_METRIC_SW) */ + int32_t snr_para[5]; }; struct hilink_brief_info { diff --git a/tool_lib/op_logs.c b/tool_lib/op_logs.c index 069428d..d91ddb0 100644 --- a/tool_lib/op_logs.c +++ b/tool_lib/op_logs.c @@ -431,7 +431,7 @@ void sig_init(void) (void)signal(SIGHUP, signal_handle); (void)signal(SIGSEGV, signal_handle); (void)signal(SIGBUS, signal_handle); - (void)signal(SIGFPE, signal_handle); - (void)signal(SIGABRT, signal_handle); - (void)signal(SIGTSTP, signal_handle); /* Stop process */ + (void)signal(SIGFPE, signal_handle); + (void)signal(SIGABRT, signal_handle); + (void)signal(SIGTSTP, signal_handle); /* Stop process */ } -- 2.21.0.windows.1

delete -g option for release vesion and add compile option: -Wextra -fno-common -std=gnu11 -Wfloat-equal Signed-off-by: veega <zhuweijia@huawei.com> --- CMakeLists.txt | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 6a396e7..174dd8f 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -11,7 +11,8 @@ project(hikptool C) -set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g -O2 -fPIC -fPIE -Wall") +set(CMAKE_C_FLAGS + "${CMAKE_C_FLAGS} -O2 -fPIC -fPIE -Wall -Wextra -fno-common -std=gnu11 -Wfloat-equal") set(CMAKE_SKIP_RPATH TRUE) macro(get_header_dir_recurse HEADER_DIR_LIST) -- 2.36.1.windows.1

add -fstack-protector-strong and -D_FORTIFY_SOURCE=2 compiler options for SP and FS. add -s link options for Strip. Signed-off-by: veega <zhuweijia@huawei.com> --- CMakeLists.txt | 6 +++--- libhikptdev/src/rciep/CMakeLists.txt | 4 +++- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 174dd8f..cbd063c 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -11,8 +11,8 @@ project(hikptool C) -set(CMAKE_C_FLAGS - "${CMAKE_C_FLAGS} -O2 -fPIC -fPIE -Wall -Wextra -fno-common -std=gnu11 -Wfloat-equal") +set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O2 -fPIC -fPIE -Wall -Wextra -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) macro(get_header_dir_recurse HEADER_DIR_LIST) @@ -46,5 +46,5 @@ target_link_directories(hikptool PRIVATE ${CMAKE_INSTALL_PREFIX}/lib) target_link_libraries(hikptool PRIVATE KPTDEV_SO) target_link_options(hikptool PRIVATE -Wl,-z,relro,-z,now -Wl,-z,noexecstack -fPIE -pie - -g -lpthread -ldl -lm -lrt -T ${CMAKE_CURRENT_SOURCE_DIR}/hikp_register.ld) + -s -lpthread -ldl -lm -lrt -T ${CMAKE_CURRENT_SOURCE_DIR}/hikp_register.ld) install(TARGETS hikptool RUNTIME DESTINATION bin OPTIONAL) diff --git a/libhikptdev/src/rciep/CMakeLists.txt b/libhikptdev/src/rciep/CMakeLists.txt index b96d621..5017f5b 100644 --- a/libhikptdev/src/rciep/CMakeLists.txt +++ b/libhikptdev/src/rciep/CMakeLists.txt @@ -17,5 +17,7 @@ add_library(KPTDEV_SO SHARED hikpt_rciep.c) target_include_directories(KPTDEV_SO PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../../include) +target_link_options(KPTDEV_SO PRIVATE -Wl,-z,relro,-z,now -Wl,-z,noexecstack -fPIE -pie -s) + set_target_properties(KPTDEV_SO PROPERTIES OUTPUT_NAME ${KPTDEV_SO_NAME} SOVERSION 1 VERSION 1.0.0) -install(TARGETS KPTDEV_SO LIBRARY DESTINATION lib OPTIONAL) \ No newline at end of file +install(TARGETS KPTDEV_SO LIBRARY DESTINATION lib OPTIONAL) -- 2.36.1.windows.1

From: m30045533 <moubingquan@huawei.com> --- pcie/func_lib/pcie_func/pcie_link_ltssm.c | 41 ++-- pcie/func_lib/pcie_func/pcie_reg_dump.c | 235 +++++++++++++++------- pcie/func_lib/pcie_func/pcie_reg_dump.h | 5 + 3 files changed, 189 insertions(+), 92 deletions(-) diff --git a/pcie/func_lib/pcie_func/pcie_link_ltssm.c b/pcie/func_lib/pcie_func/pcie_link_ltssm.c index 9c4b70c..09d3b5e 100644 --- a/pcie/func_lib/pcie_func/pcie_link_ltssm.c +++ b/pcie/func_lib/pcie_func/pcie_link_ltssm.c @@ -45,25 +45,25 @@ union ltssm_state_reg { union pm_state_reg { struct { - uint64_t pm_state : 6; /* [0:5] */ - uint64_t pm_clock : 18; /* [6:23] */ - uint64_t reserved1 : 8; /* [24:31] */ - uint64_t refclk_stable_vld : 1; /* [32] */ - uint64_t enter_l12_case : 1; /* [33] */ - uint64_t pm_t_dl_l2_gnt_timeout : 1; /* [34] */ - uint64_t pm_t_dl_l1_gnt_timeout : 1; /* [35] */ - uint64_t pm_t_dl_l0s_gnt_timeout : 1; /* [36] */ - uint64_t pm_t_dl_lastack_timeout : 1; /* [37] */ - uint64_t pme_turn_off_vld_hold : 1; /* [38] */ - uint64_t pm_blk_tlp_timeout : 1; /* [39] */ - uint64_t aspm_nak_vld : 1; /* [40] */ - uint64_t retrain_link_vld : 1; /* [41] */ - uint64_t pending_dllp_vld : 1; /* [42] */ - uint64_t pm_wakeup_tol0_en : 1; /* [43] */ - uint64_t mac2pm_rx_data_vld : 1; /* [44] */ - uint64_t dfe_req : 1; /* [45] */ - uint64_t pm_t_dfe_time_meet : 1; /* [46] */ - uint64_t reserved2 : 17; /* [47:63] */ + uint64_t pm_state : 6; /* [0:5] */ + uint64_t pm_clock : 18; /* [6:23] */ + uint64_t reserved1 : 8; /* [24:31] */ + uint64_t refclk_stable_vld : 1; /* [32] */ + uint64_t enter_l12_case : 1; /* [33] */ + uint64_t pm_t_dl_l2_gnt_timeout : 1; /* [34] */ + uint64_t pm_t_dl_l1_gnt_timeout : 1; /* [35] */ + uint64_t pm_t_dl_l0s_gnt_timeout : 1; /* [36] */ + uint64_t pm_t_dl_lastack_timeout : 1; /* [37] */ + uint64_t pme_turn_off_vld_hold : 1; /* [38] */ + uint64_t pm_blk_tlp_timeout : 1; /* [39] */ + uint64_t aspm_nak_vld : 1; /* [40] */ + uint64_t retrain_link_vld : 1; /* [41] */ + uint64_t pending_dllp_vld : 1; /* [42] */ + uint64_t pm_wakeup_tol0_en : 1; /* [43] */ + uint64_t mac2pm_rx_data_vld : 1; /* [44] */ + uint64_t dfe_req : 1; /* [45] */ + uint64_t pm_t_dfe_time_meet : 1; /* [46] */ + uint64_t reserved2 : 17; /* [47:63] */ } bits; uint64_t val; }; @@ -423,7 +423,8 @@ static int pcie_print_pm_trace(const uint64_t *pm_status, uint32_t pm_num) pm_val.val = pm_status[i]; pm_c = hisi_pcie_pm_string_get((uint32_t)pm_val.bits.pm_state); Info("PCIe Base", - "\tpm[%02u]:\t %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x 0x%06x 0x%02x %s\n", + "\tpm[%02u]:\t %x %x %x %x %x %x %x %x %x %x %x " + "%x %x %x %x 0x%06x 0x%02x %s\n", i, (uint32_t)pm_val.bits.pm_t_dfe_time_meet, (uint32_t)pm_val.bits.dfe_req, diff --git a/pcie/func_lib/pcie_func/pcie_reg_dump.c b/pcie/func_lib/pcie_func/pcie_reg_dump.c index e10ff7e..aac3843 100644 --- a/pcie/func_lib/pcie_func/pcie_reg_dump.c +++ b/pcie/func_lib/pcie_func/pcie_reg_dump.c @@ -66,6 +66,8 @@ struct pcie_dumpreg_info g_reg_table_tl[] = { {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[] = { @@ -105,6 +107,28 @@ struct pcie_dumpreg_info g_reg_table_mac[] = { {0, "MAC_REG_FE_INT_RO"}, {0, "MAC_REG_CE_INT_RO"}, {0, "MAC_REG_NFE_INT_RO"}, + {0, "MAC_REG_EQ_FIX_LP_TX_PRESET"}, + {0, "MAC_REG_ESM_32G_EQ_FIX_LP_TX_PRESET"}, + {0, "MAC_REG_ADJ_HILINK_MODE_EN"}, + {0, "MAC_REG_EQ_OPT_TX_PRESET_1"}, + {0, "MAC_REG_LP_GEN3_TX_PRESET_P1_2"}, + {0, "MAC_REG_GEN3_EQ_OPT_TX_PRESET_2"}, + {0, "MAC_REG_GEN4_EQ_OPT_TX_PRESET_1"}, + {0, "MAC_REG_GEN4_EQ_OPT_TX_PRESET_2"}, + {0, "MAC_REG_LP_GEN4_TX_PRESET_P1_1"}, + {0, "MAC_REG_LP_GEN4_TX_PRESET_P1_2"}, + {0, "MAC_REG_DEBUG_PIPE1"}, + {0, "MAC_REG_DEBUG_PIPE2"}, + {0, "MAC_REG_DEBUG_PIPE3"}, + {0, "MAC_REG_DEBUG_PIPE5"}, + {0, "MAC_REG_DEBUG_PIPE7"}, + {0, "MAC_REG_DEBUG_PIPE8"}, + {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"}, }; struct pcie_dumpreg_info g_reg_table_pcs[] = { @@ -115,6 +139,8 @@ struct pcie_dumpreg_info g_reg_table_pcs[] = { 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), }; struct pcie_dumpreg_info g_reg_table_iob_tx[] = { @@ -141,6 +167,71 @@ struct pcie_dumpreg_info g_reg_table_iob_tx[] = { {0, "IOB_TX_INT_SEVERITY3"}, {0, "IOB_TX_INT_SEVERITY4"}, {0, "IOB_TX_INT_SEVERITY5"}, + {0, "IOB_TX_TCS_DEC_ERR_INFO_L"}, + {0, "IOB_TX_TCS_DEC_ERR_INFO_H"}, + {0, "DFX_IOB_TX_P_CNT_0"}, + {0, "DFX_IOB_TX_P_CNT_1"}, + {0, "DFX_IOB_TX_P_CNT_2"}, + {0, "DFX_IOB_TX_P_CNT_3"}, + {0, "DFX_IOB_TX_P_CNT_4"}, + {0, "DFX_IOB_TX_NP_CNT_0"}, + {0, "DFX_IOB_TX_NP_CNT_1"}, + {0, "DFX_IOB_TX_NP_CNT_2"}, + {0, "DFX_IOB_TX_NP_CNT_3"}, + {0, "DFX_IOB_TX_NP_CNT_4"}, + {0, "DFX_IOB_TX_NP_CNT_5"}, + {0, "DFX_IOB_TX_NP_CNT_6"}, + {0, "DFX_IOB_TX_NP_CNT_7"}, + {0, "DFX_IOB_TX_NP_CNT_8"}, + {0, "DFX_IOB_TX_NP_CNT_9"}, + {0, "DFX_IOB_TX_NP_CNT_10"}, + {0, "DFX_IOB_TX_NP_CNT_11"}, + {0, "DFX_IOB_TX_CPL_CNT_0"}, + {0, "DFX_IOB_TX_CPL_CNT_1"}, + {0, "DFX_IOB_TX_CPL_CNT_2"}, + {0, "DFX_IOB_TX_REQ_CNT"}, + {0, "DFX_IOB_TX_STATUS0"}, + {0, "DFX_IOB_TX_STATUS1"}, + {0, "DFX_IOB_TX_STATUS2"}, + {0, "DFX_IOB_TX_STATUS3"}, + {0, "DFX_IOB_TX_STATUS4"}, + {0, "DFX_IOB_TX_STATUS5"}, + {0, "DFX_IOB_TX_ABNORMAL_CNT_0"}, + {0, "DFX_IOB_TX_ABNORMAL_CNT_1"}, + {0, "DFX_IOB_TX_ABNORMAL_CNT_2"}, + {0, "DFX_IOB_TX_ABNORMAL_CNT_3"}, + {0, "DFX_IOB_TX_ERROR0"}, + {0, "DFX_IOB_TX_ERROR1"}, + {0, "DFX_IOB_TX_TCS_NORMAL_CNT_0"}, + {0, "DFX_IOB_TX_TCS_NORMAL_CNT_1"}, + {0, "DFX_IOB_TX_TCS_NORMAL_CNT_2"}, + {0, "DFX_IOB_TX_TCS_NORMAL_CNT_3"}, + {0, "DFX_IOB_TX_TCS_NORMAL_CNT_4"}, + {0, "DFX_IOB_TX_TCS_NORMAL_CNT_5"}, + {0, "DFX_IOB_TX_TCS_NORMAL_CNT_6"}, + {0, "DFX_IOB_TX_TCS_NORMAL_CNT_7"}, + {0, "DFX_IOB_TX_TCS_NORMAL_CNT_8"}, + {0, "DFX_IOB_TX_TCS_NORMAL_CNT_9"}, + {0, "DFX_IOB_TX_TCS_NORMAL_CNT_10"}, + {0, "DFX_IOB_TX_TCS_NORMAL_CNT_11"}, + {0, "DFX_IOB_TX_TCS_NORMAL_CNT_12"}, + {0, "DFX_IOB_TX_TCS_NORMAL_CNT_13"}, + {0, "DFX_IOB_TX_TCS_NORMAL_CNT_14"}, + {0, "DFX_IOB_TX_TCS_NORMAL_CNT_15"}, + {0, "DFX_IOB_TX_TCS_P2P_CNT_0"}, + {0, "DFX_IOB_TX_TCS_P2P_CNT_1"}, + {0, "DFX_IOB_TX_TCS_P2P_CNT_2"}, + {0, "DFX_IOB_TX_TCS_P2P_CNT_3"}, + {0, "DFX_IOB_TX_TCS_P2P_CNT_4"}, + {0, "DFX_IOB_TX_TCS_P2P_CNT_5"}, + {0, "DFX_IOB_TX_TCS_P2P_CNT_6"}, + {0, "DFX_IOB_TX_TCS_P2P_CNT_7"}, + {0, "DFX_IOB_TX_TCS_ARNORAML_CNT_0"}, + {0, "DFX_IOB_TX_TCS_ARNORAML_CNT_1"}, + {0, "DFX_IOB_TX_TCS_STATUS0"}, + {0, "DFX_IOB_TX_TCS_STATUS1"}, + {0, "DFX_IOB_TX_TCS_STATUS2"}, + {0, "DFX_IOB_TX_TCS_IDLE"}, }; struct pcie_dumpreg_info g_reg_table_iob_rx[] = { @@ -150,6 +241,19 @@ struct pcie_dumpreg_info g_reg_table_iob_rx[] = { {0, "IOB_RX_MSI_MSIX_CTRL_0"}, {0, "IOB_RX_MSI_MSIX_ADDR_HIGH_0"}, {0, "IOB_RX_MSI_MSIX_ADDR_LOW_0"}, + {0, "DFX_IOB_RX_CNT_RX_REQ"}, + {0, "DFX_IOB_RX_CNT_LOC_REQ"}, + {0, "DFX_IOB_RX_CNT_SEND_AM"}, + {0, "DFX_IOB_RX_CNT_SEND_LOC"}, + {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"}, + {0, "DFX_IOB_RX_AMB_RD_CNT_1"}, + {0, "DFX_IOB_RX_AMB_INT_NUM"}, }; struct pcie_dumpreg_info g_reg_table_ap_glb[] = { @@ -256,6 +360,30 @@ struct pcie_dumpreg_info g_reg_table_core_glb[] = { {0, "CORE_INT_FE_MSK_2"}, {0, "CORE_INT_FE_STATUS_2"}, {0, "CORE_INT_FE_RO_2"}, + {0, "PORT07_LINK_MODE"}, + {0, "PORT815_LINK_MODE"}, +}; + +struct pcie_dumpreg_info g_reg_table_core_tl[] = { + {0, "TL_PM_AUTO_EXIT_TIME_VALUE"}, + {0, "TL_DFX_PM_CORE_FUNC_EN"}, + {0, "TL_PM_DFE_TIME_VALUE"}, +}; + +struct pcie_dumpreg_info g_reg_table_dfx_core_tl[] = { + {0, "TL_TX_ASYN_FIFO_ST"}, + {0, "TL_TX_INGRESS_CNT"}, + {0, "TL_TX_CTRL_EGRESS_CNT"}, + {0, "TL_TX_CFG_CNT"}, + {0, "TL_TX_MEM_RD_CNT"}, + {0, "TL_TX_MEM_WR_CNT"}, + {0, "TL_TX_IO_RD_CNT"}, + {0, "TL_TX_IO_WR_CNT"}, + {0, "TL_TX_MSG_CNT"}, + {0, "TL_TX_CPL_CNT"}, + {0, "TL_TX_ATOMIC_CNT"}, + {0, "TL_TX_CFG_TX_CNT"}, + {0, "TL_TX_GEN_CPL_CNT"}, }; static int pcie_create_dumpreg_log_file(uint32_t port_id, uint32_t dump_level) @@ -315,73 +443,33 @@ static void pcie_dumpreg_write_value_to_file(const char *reg_name, uint32_t val) } } -static void pcie_dumpreg_save_glb_analysis_log(const uint32_t *data, uint32_t data_num) -{ - uint32_t item_i, data_i; - - data_i = 0; - /* IOB_TX REG */ - for (item_i = 0; item_i < HIKP_ARRAY_SIZE(g_reg_table_iob_tx) && - data_i < data_num; item_i++, data_i++) { - g_reg_table_iob_tx[item_i].val = data[data_i]; - pcie_dumpreg_write_value_to_file(g_reg_table_iob_tx[item_i].name, - g_reg_table_iob_tx[item_i].val); - } - /* IOB_RX REG */ - for (item_i = 0; item_i < HIKP_ARRAY_SIZE(g_reg_table_iob_rx) && - data_i < data_num; item_i++, data_i++) { - g_reg_table_iob_rx[item_i].val = data[data_i]; - pcie_dumpreg_write_value_to_file(g_reg_table_iob_rx[item_i].name, - g_reg_table_iob_rx[item_i].val); - } - /* AP_GLB REG */ - for (item_i = 0; item_i < HIKP_ARRAY_SIZE(g_reg_table_ap_glb) && - data_i < data_num; item_i++, data_i++) { - g_reg_table_ap_glb[item_i].val = data[data_i]; - pcie_dumpreg_write_value_to_file(g_reg_table_ap_glb[item_i].name, - g_reg_table_ap_glb[item_i].val); - } - /* CORE_GLB REG */ - for (item_i = 0; item_i < HIKP_ARRAY_SIZE(g_reg_table_core_glb) && - data_i < data_num; item_i++, data_i++) { - g_reg_table_core_glb[item_i].val = data[data_i]; - pcie_dumpreg_write_value_to_file(g_reg_table_core_glb[item_i].name, - g_reg_table_core_glb[item_i].val); - } - /* PCS REG */ - for (item_i = 0; item_i < HIKP_ARRAY_SIZE(g_reg_table_pcs) && - data_i < data_num; item_i++, data_i++) { - g_reg_table_pcs[item_i].val = data[data_i]; - pcie_dumpreg_write_value_to_file(g_reg_table_pcs[item_i].name, - g_reg_table_pcs[item_i].val); - } -} +struct pcie_dumpreg_table g_dump_info_glb[] = { + {HIKP_ARRAY_SIZE(g_reg_table_iob_tx), g_reg_table_iob_tx}, + {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}, +}; -static void pcie_dumpreg_save_port_analysis_log(uint32_t *data, uint32_t data_num) +struct pcie_dumpreg_table g_dump_info_port[] = { + {HIKP_ARRAY_SIZE(g_reg_table_tl), g_reg_table_tl}, + {HIKP_ARRAY_SIZE(g_reg_table_dl), g_reg_table_dl}, + {HIKP_ARRAY_SIZE(g_reg_table_mac), g_reg_table_mac}, +}; + +static void pcie_dumpreg_save_analysis_log(const uint32_t *data, uint32_t data_num, + struct pcie_dumpreg_table *table, uint32_t size) { - uint32_t item_i, data_i; - - data_i = 0; - /* TL REG */ - for (item_i = 0; item_i < HIKP_ARRAY_SIZE(g_reg_table_tl) && - data_i < data_num; item_i++, data_i++) { - g_reg_table_tl[item_i].val = data[data_i]; - pcie_dumpreg_write_value_to_file(g_reg_table_tl[item_i].name, - g_reg_table_tl[item_i].val); - } - /* DL REG */ - for (item_i = 0; item_i < HIKP_ARRAY_SIZE(g_reg_table_dl) && - data_i < data_num; item_i++, data_i++) { - g_reg_table_dl[item_i].val = data[data_i]; - pcie_dumpreg_write_value_to_file(g_reg_table_dl[item_i].name, - g_reg_table_dl[item_i].val); - } - /* MAC REG */ - for (item_i = 0; item_i < HIKP_ARRAY_SIZE(g_reg_table_mac) && - data_i < data_num; item_i++, data_i++) { - g_reg_table_mac[item_i].val = data[data_i]; - pcie_dumpreg_write_value_to_file(g_reg_table_mac[item_i].name, - g_reg_table_mac[item_i].val); + uint32_t i, j, data_i = 0; + + for (i = 0; i < size; i++) { + struct pcie_dumpreg_info *info = table[i].dump_info; + for (j = 0; j < table[i].size && data_i < data_num; j++, data_i++) { + info[j].val = data[data_i]; + pcie_dumpreg_write_value_to_file(info[j].name, info[j].val); + } } } @@ -420,13 +508,14 @@ static int pcie_dumpreg_save_log(uint32_t *data, uint32_t data_num, switch (req_data->level) { case DUMP_GLOBAL_LEVEL: - expect_data_num = HIKP_ARRAY_SIZE(g_reg_table_iob_tx) + - HIKP_ARRAY_SIZE(g_reg_table_iob_rx) + HIKP_ARRAY_SIZE(g_reg_table_ap_glb) + - HIKP_ARRAY_SIZE(g_reg_table_core_glb) + HIKP_ARRAY_SIZE(g_reg_table_pcs); + for (i = 0; i < HIKP_ARRAY_SIZE(g_dump_info_glb); i++) { + expect_data_num += g_dump_info_glb[i].size; + } break; case DUMP_PORT_LEVEL: - expect_data_num = HIKP_ARRAY_SIZE(g_reg_table_tl) + - HIKP_ARRAY_SIZE(g_reg_table_dl) + HIKP_ARRAY_SIZE(g_reg_table_mac); + for (i = 0; i < HIKP_ARRAY_SIZE(g_dump_info_port); i++) { + expect_data_num += g_dump_info_port[i].size; + } break; default: Err("PCIe DUMPREG", "check dump level failed.\n"); @@ -441,9 +530,11 @@ static int pcie_dumpreg_save_log(uint32_t *data, uint32_t data_num, pcie_dumpreg_write_value_to_file(reg_name, data[i]); } } else if (req_data->level == DUMP_GLOBAL_LEVEL) { - pcie_dumpreg_save_glb_analysis_log(data, data_num); + pcie_dumpreg_save_analysis_log(data, data_num, + g_dump_info_glb, HIKP_ARRAY_SIZE(g_dump_info_glb)); } else { - pcie_dumpreg_save_port_analysis_log(data, data_num); + pcie_dumpreg_save_analysis_log(data, data_num, + g_dump_info_port, HIKP_ARRAY_SIZE(g_dump_info_port)); } return 0; diff --git a/pcie/func_lib/pcie_func/pcie_reg_dump.h b/pcie/func_lib/pcie_func/pcie_reg_dump.h index 4ec1909..cbea2f6 100644 --- a/pcie/func_lib/pcie_func/pcie_reg_dump.h +++ b/pcie/func_lib/pcie_func/pcie_reg_dump.h @@ -49,6 +49,11 @@ struct pcie_dump_req_para { uint32_t level; }; +struct pcie_dumpreg_table { + uint32_t size; + struct pcie_dumpreg_info *dump_info; +}; + int pcie_dumpreg_do_dump(uint32_t port_id, uint32_t dump_level); #endif -- 2.33.0

add nic_ncsi cmd for query nic port number of NCSI packets processed by software Signed-off-by: veega <zhuweijia@huawei.com> --- net/hikp_net_lib.h | 5 ++ net/nic/nic_ncsi/hikp_nic_ncsi.c | 116 +++++++++++++++++++++++++++++++ net/nic/nic_ncsi/hikp_nic_ncsi.h | 57 +++++++++++++++ 3 files changed, 178 insertions(+) create mode 100644 net/nic/nic_ncsi/hikp_nic_ncsi.c create mode 100644 net/nic/nic_ncsi/hikp_nic_ncsi.h diff --git a/net/hikp_net_lib.h b/net/hikp_net_lib.h index af0a51d..ed984ce 100644 --- a/net/hikp_net_lib.h +++ b/net/hikp_net_lib.h @@ -78,6 +78,7 @@ enum nic_cmd_type { GET_FD_INFO_CMD, GET_FEC_INFO_CMD, GET_GRO_INFO_CMD, + GET_NCSI_INFO_CMD, }; enum roh_cmd_type { @@ -107,6 +108,10 @@ enum ub_cmd_type { GET_UB_BASIC_INFO_CMD, }; +enum nic_get_ncsi_sub_cmd { + NIC_NCSI_GET_DFX_INFO, +}; + #define HIKP_MAX_PF_NUM 8 #define HIKP_NIC_MAX_FUNC_NUM 256 diff --git a/net/nic/nic_ncsi/hikp_nic_ncsi.c b/net/nic/nic_ncsi/hikp_nic_ncsi.c new file mode 100644 index 0000000..d09e16f --- /dev/null +++ b/net/nic/nic_ncsi/hikp_nic_ncsi.c @@ -0,0 +1,116 @@ +/* + * Copyright (c) 2022 Hisilicon Technologies Co., Ltd. + * Hikptool is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * + * See the Mulan PSL v2 for more details. + */ + +#include <unistd.h> +#include "tool_cmd.h" +#include "hikp_net_lib.h" +#include "hikptdev_plug.h" +#include "hikp_nic_ncsi.h" + +static struct nic_ncsi_cmd_info g_ncsi_cmd_info = {0}; + +static void nic_ncsi_cmd_print_dfx_info(struct nic_ncsi_cmd_resp *ncsi_info) +{ + printf("port ncsi: %s\n", ncsi_info->ncsi_en ? "enable" : "disable"); + if (!ncsi_info->ncsi_en) + return; /* ncsi not enable do not print dfx info */ + + printf("processing packet statistics\n"); + printf("\tncsi_control_total: %u\n", ncsi_info->ncsi_dfx.ncsi_control_total); + printf("\tncsi_eth_to_ub_total: %u\n", ncsi_info->ncsi_dfx.ncsi_eth_to_ub_total); + printf("\tncsi_ub_to_eth_total: %u\n", ncsi_info->ncsi_dfx.ncsi_ub_to_eth_total); + printf("\tncsi_control_good: %u\n", ncsi_info->ncsi_dfx.ncsi_control_good); + printf("\tncsi_eth_to_ub_good: %u\n", ncsi_info->ncsi_dfx.ncsi_eth_to_ub_good); + printf("\tncsi_ub_to_eth_good: %u\n", ncsi_info->ncsi_dfx.ncsi_ub_to_eth_good); + + printf("\tncsi_eth_to_ub_arp: %u\n", ncsi_info->ncsi_dfx.ncsi_eth_to_ub_arp); + printf("\tncsi_eth_to_ub_free_arp: %u\n", ncsi_info->ncsi_dfx.ncsi_eth_to_ub_free_arp); + printf("\tncsi_eth_to_ub_ipv6_ra: %u\n", ncsi_info->ncsi_dfx.ncsi_eth_to_ub_ipv6_ra); + printf("\tncsi_eth_to_ub_dhcpv4: %u\n", ncsi_info->ncsi_dfx.ncsi_eth_to_ub_dhcpv4); + printf("\tncsi_eth_to_ub_dhcpv6: %u\n", ncsi_info->ncsi_dfx.ncsi_eth_to_ub_dhcpv6); + printf("\tncsi_eth_to_ub_lldp: %u\n", ncsi_info->ncsi_dfx.ncsi_eth_to_ub_lldp); + + printf("\tncsi_ub_to_eth_ipv4: %u\n", ncsi_info->ncsi_dfx.ncsi_ub_to_eth_ipv4); + printf("\tncsi_ub_to_eth_ipv6: %u\n", ncsi_info->ncsi_dfx.ncsi_ub_to_eth_ipv6); + printf("\tncsi_ub_to_eth_ipnotify: %u\n", ncsi_info->ncsi_dfx.ncsi_ub_to_eth_ipnotify); + printf("\tncsi_ub_to_eth_dhcpv4: %u\n", ncsi_info->ncsi_dfx.ncsi_ub_to_eth_dhcpv4); + printf("\tncsi_ub_to_eth_dhcpv6: %u\n", ncsi_info->ncsi_dfx.ncsi_ub_to_eth_dhcpv6); + printf("\tncsi_ub_to_eth_lldp: %u\n", ncsi_info->ncsi_dfx.ncsi_ub_to_eth_lldp); +} + +static void nic_ncsi_cmd_execute(struct major_cmd_ctrl *self) +{ + struct hikp_cmd_ret *cmd_resp = NULL; + struct hikp_cmd_header req_header = {0}; + struct nic_ncsi_cmd_req ncsi_req = {0}; + + if (!g_ncsi_cmd_info.port_flag) { + self->err_no = -EINVAL; + snprintf(self->err_str, sizeof(self->err_str), "Need port id."); + return; + } + + memcpy(&ncsi_req.bdf, &g_ncsi_cmd_info.target.bdf, sizeof(ncsi_req.bdf)); + hikp_cmd_init(&req_header, NIC_MOD, GET_NCSI_INFO_CMD, NIC_NCSI_GET_DFX_INFO); + cmd_resp = hikp_cmd_alloc(&req_header, &ncsi_req, sizeof(ncsi_req)); + self->err_no = hikp_rsp_normal_check(cmd_resp); + if (self->err_no) { + snprintf(self->err_str, sizeof(self->err_str), "Get ncsi dfx info failed."); + goto ERR_OUT; + } + + nic_ncsi_cmd_print_dfx_info((struct nic_ncsi_cmd_resp *)cmd_resp->rsp_data); + +ERR_OUT: + free(cmd_resp); + cmd_resp = NULL; +} + +static int nic_ncsi_cmd_get_port_info(struct major_cmd_ctrl *self, const char *argv) +{ + self->err_no = tool_check_and_get_valid_bdf_id(argv, &g_ncsi_cmd_info.target); + if (self->err_no) { + snprintf(self->err_str, sizeof(self->err_str), "Unknown device %s.", argv); + return self->err_no; + } + g_ncsi_cmd_info.port_flag = true; + + return 0; +} + +static int nic_ncsi_cmd_show_help(struct major_cmd_ctrl *self, const char *argv) +{ + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i <interface>"); + 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", "-i", "--interface=<interface>", + "device target or bdf id, e.g. eth0~3 or 0000:35:00.0"); + printf("\n"); + + return 0; +} + +static void cmd_nic_get_ncsi_init(void) +{ + struct major_cmd_ctrl *major_cmd = get_major_cmd(); + + g_ncsi_cmd_info.port_flag = false; + major_cmd->option_count = 0; + major_cmd->execute = nic_ncsi_cmd_execute; + + cmd_option_register("-h", "--help", false, nic_ncsi_cmd_show_help); + cmd_option_register("-i", "--interface", true, nic_ncsi_cmd_get_port_info); +} + +HIKP_CMD_DECLARE("nic_ncsi", "query nic port ncsi information", cmd_nic_get_ncsi_init); diff --git a/net/nic/nic_ncsi/hikp_nic_ncsi.h b/net/nic/nic_ncsi/hikp_nic_ncsi.h new file mode 100644 index 0000000..a391d20 --- /dev/null +++ b/net/nic/nic_ncsi/hikp_nic_ncsi.h @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2022 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_NIC_NCSI_H +#define HIKP_NIC_NCSI_H + +#include "hikp_net_lib.h" + +struct nic_ncsi_dfx_info { + uint16_t ncsi_control_total; + uint16_t ncsi_eth_to_ub_total; + uint16_t ncsi_ub_to_eth_total; + uint16_t ncsi_control_good; + uint16_t ncsi_eth_to_ub_good; + uint16_t ncsi_ub_to_eth_good; + uint16_t ncsi_eth_to_ub_arp; + uint16_t ncsi_eth_to_ub_free_arp; + uint16_t ncsi_eth_to_ub_ipv6_ra; + uint16_t ncsi_eth_to_ub_dhcpv4; + uint16_t ncsi_eth_to_ub_dhcpv6; + uint16_t ncsi_eth_to_ub_lldp; + uint16_t ncsi_ub_to_eth_ipv4; + uint16_t ncsi_ub_to_eth_ipv6; + uint16_t ncsi_ub_to_eth_ipnotify; + uint16_t ncsi_ub_to_eth_dhcpv4; + uint16_t ncsi_ub_to_eth_dhcpv6; + uint16_t ncsi_ub_to_eth_lldp; +}; + +struct nic_ncsi_cmd_resp { + uint8_t ncsi_en; + uint8_t rsv0[3]; + struct nic_ncsi_dfx_info ncsi_dfx; + uint32_t rsv1[50]; /* max resp data: 240 Bytes */ +}; + +struct nic_ncsi_cmd_req { + struct bdf_t bdf; + uint32_t rsv0[30]; /* max req data: 128 Bytes */ +}; + +struct nic_ncsi_cmd_info { + struct tool_target target; + bool port_flag; +}; + +#endif /* HIKP_NIC_NCSI_H */ -- 2.36.1.windows.1

From: Junxian Huang <huangjunxian6@hisilicon.com> Upstream: Yes AR20220105919341 Currently hikptool only accepts bank ID 0 and 1 for roce_trp GEN_AC. The firmware then multiplies the bank ID received from hikptool by 2 and converts it to 0 and 2. But actually there are 4 banks in GEN_AC and each of them is independent. To fix the problem, both hikptool and firmware should be modified. This patch modifies the bank ID limit form 2 to 4 in hikptool. Signed-off-by: Junxian Huang <huangjunxian6@hisilicon.com> --- net/roce/roce_trp/hikp_roce_trp.c | 2 +- net/roce/roce_trp/hikp_roce_trp.h | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/net/roce/roce_trp/hikp_roce_trp.c b/net/roce/roce_trp/hikp_roce_trp.c index 8befb06..bf22484 100644 --- a/net/roce/roce_trp/hikp_roce_trp.c +++ b/net/roce/roce_trp/hikp_roce_trp.c @@ -32,7 +32,7 @@ static int hikp_roce_trp_help(struct major_cmd_ctrl *self, const char *argv) "this is necessary param COMMON/TRP_RX/GEN_AC/PAYL"); printf(" %s, %-25s %s\n", "-b", "--bank=<bank>", "[option]set which bank to read. (default 0) " - "COMMON : 0~3\n PAYL: 0~1\n GEN_AC : 0~1\n "); + "COMMON : 0~3\n PAYL: 0~1\n GEN_AC : 0~3\n "); printf("\n"); return 0; diff --git a/net/roce/roce_trp/hikp_roce_trp.h b/net/roce/roce_trp/hikp_roce_trp.h index db58216..80d28af 100644 --- a/net/roce/roce_trp/hikp_roce_trp.h +++ b/net/roce/roce_trp/hikp_roce_trp.h @@ -25,7 +25,7 @@ } #define TRP_MAX_BANK_NUM 0x3 #define PAYL_MAX_BANK_NUM 0x1 -#define GAC_MAX_BANK_NUM 0x1 +#define GAC_MAX_BANK_NUM 0x3 #define PER_TRP_DATA_NUM 2 struct roce_trp_req_param { -- 2.30.0

From: Jijie Shao <shaojijie@huawei.com> add nic_notify_pkt cmd for query fault notify pkt info AR:AR20230712025695 Bugfix or Feature: Feature Signed-off-by: Jijie Shao <shaojijie@huawei.com> --- net/hikp_net_lib.h | 1 + net/nic/nic_notify_pkt/hikp_nic_notify_pkt.c | 126 +++++++++++++++++++ net/nic/nic_notify_pkt/hikp_nic_notify_pkt.h | 52 ++++++++ 3 files changed, 179 insertions(+) create mode 100644 net/nic/nic_notify_pkt/hikp_nic_notify_pkt.c create mode 100644 net/nic/nic_notify_pkt/hikp_nic_notify_pkt.h diff --git a/net/hikp_net_lib.h b/net/hikp_net_lib.h index ed984ce..06ae598 100644 --- a/net/hikp_net_lib.h +++ b/net/hikp_net_lib.h @@ -79,6 +79,7 @@ enum nic_cmd_type { GET_FEC_INFO_CMD, GET_GRO_INFO_CMD, GET_NCSI_INFO_CMD, + GET_NOTIFY_PKT_CMD, }; enum roh_cmd_type { diff --git a/net/nic/nic_notify_pkt/hikp_nic_notify_pkt.c b/net/nic/nic_notify_pkt/hikp_nic_notify_pkt.c new file mode 100644 index 0000000..307d336 --- /dev/null +++ b/net/nic/nic_notify_pkt/hikp_nic_notify_pkt.c @@ -0,0 +1,126 @@ +/* + * Copyright (c) 2023 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 <stdio.h> +#include <string.h> +#include <sys/types.h> +#include <unistd.h> +#include "hikp_nic_notify_pkt.h" + +static struct tool_target g_notify_pkt_target; + +static int hikp_nic_notify_pkt_query(struct major_cmd_ctrl *self, const struct bdf_t *bdf, + struct nic_notify_pkt_info *info) +{ + struct nic_notify_pkt_req_para req = { 0 }; + struct hikp_cmd_header header = { 0 }; + struct nic_notify_pkt_rsp *rsp; + struct hikp_cmd_ret *cmd_resp; + + req.bdf = *bdf; + hikp_cmd_init(&header, NIC_MOD, GET_NOTIFY_PKT_CMD, GET_NOTIFY_PKT_CMD); + cmd_resp = hikp_cmd_alloc(&header, &req, sizeof(req)); + self->err_no = hikp_rsp_normal_check(cmd_resp); + if (self->err_no) { + snprintf(self->err_str, sizeof(self->err_str), "get notify pkt failed."); + if (cmd_resp) + free(cmd_resp); + return self->err_no; + } + + rsp = (struct nic_notify_pkt_rsp *)cmd_resp->rsp_data; + *info = *(struct nic_notify_pkt_info *)rsp->data; + free(cmd_resp); + + return 0; +} + +static void hikp_nic_notify_pkt_show(const struct nic_notify_pkt_info *info) +{ +#define HIKP_NIC_NOFITY_PKT_DATA_PEER_LINE_MAX_CNT 16 + + uint32_t pkt_start_en = hikp_get_bit(info->cfg, HIKP_NOTIFY_PKT_CFG_START_EN); + uint32_t pkt_num = hikp_get_field(info->cfg, HIKP_NOTIFY_PKT_CFG_PKT_NUM_M, + HIKP_NOTIFY_PKT_CFG_PKT_NUM_S); + uint32_t pkt_en = hikp_get_bit(info->cfg, HIKP_NOTIFY_PKT_CFG_PKT_EN); + uint32_t i; + + printf("################ NIC notify pkt info ##################\n"); + printf("pkt_en : %u\n", pkt_en); + printf("pkt_start_en : %u\n", pkt_start_en); + printf("pkt_num : %u\n", pkt_num); + printf("pkt_ipg : %u %s\n", info->ipg, info->ipg > 1 ? + "clock cycles" : "clock cycle"); + + printf("pkt_data:\n"); + for (i = 1; i <= NIC_NOTIFY_PKT_DATA_LEN; i++) { + printf("%02x ", info->data[i - 1]); + if (i % HIKP_NIC_NOFITY_PKT_DATA_PEER_LINE_MAX_CNT == 0) + printf("\n"); + } + printf("####################### END ###########################\n"); +} + +static 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; + + self->err_no = hikp_nic_notify_pkt_query(self, bdf, &info); + if (self->err_no) + return; + + hikp_nic_notify_pkt_show(&info); +} + +static int hikp_nic_notify_pkt_cmd_help(struct major_cmd_ctrl *self, const char *argv) +{ + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i <device>"); + 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", "-i", "--interface=<interface>", + "device target or bdf id, e.g. eth0~7 or 0000:35:00.0"); + + return 0; +} + +static 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) { + snprintf(self->err_str, sizeof(self->err_str), "unknown device!"); + return self->err_no; + } + + if (g_notify_pkt_target.bdf.dev_id != 0) { + snprintf(self->err_str, sizeof(self->err_str), "VF does not support query!"); + self->err_no = -EOPNOTSUPP; + return self->err_no; + } + + return 0; +} + +static void cmd_nic_notify_pkt_init(void) +{ + struct major_cmd_ctrl *major_cmd = get_major_cmd(); + + major_cmd->option_count = 0; + major_cmd->execute = hikp_nic_notify_pkt_cmd_execute; + + cmd_option_register("-h", "--help", false, hikp_nic_notify_pkt_cmd_help); + cmd_option_register("-i", "--interface", true, hikp_nic_notify_pkt_get_target); +} + +HIKP_CMD_DECLARE("nic_notify_pkt", "dump notify pkt info of nic!", cmd_nic_notify_pkt_init); diff --git a/net/nic/nic_notify_pkt/hikp_nic_notify_pkt.h b/net/nic/nic_notify_pkt/hikp_nic_notify_pkt.h new file mode 100644 index 0000000..8bdb795 --- /dev/null +++ b/net/nic/nic_notify_pkt/hikp_nic_notify_pkt.h @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2023 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_NIC_NOTIFY_PKT_H +#define HIKP_NIC_NOTIFY_PKT_H + +#include "hikp_net_lib.h" + +enum nic_notify_pkt_sub_cmd_type { + NIC_NOTIFY_PKT_DUMP = 0, +}; + +struct nic_notify_pkt_req_para { + struct bdf_t bdf; + uint32_t block_id; +}; + +struct nic_notify_pkt_rsp_head { + uint8_t total_blk_num; + uint8_t curr_blk_size; /* real data size, not contain head size. */ + uint16_t rsv; +}; + +#define NIC_NOTIFY_PKT_MAX_RSP_DATA 18 +struct nic_notify_pkt_rsp { + struct nic_notify_pkt_rsp_head head; + uint32_t data[NIC_NOTIFY_PKT_MAX_RSP_DATA]; +}; + +#define NIC_NOTIFY_PKT_DATA_LEN 64 +struct nic_notify_pkt_info { + uint32_t cfg; + uint32_t ipg; + uint8_t data[NIC_NOTIFY_PKT_DATA_LEN]; +}; + +#define HIKP_NOTIFY_PKT_CFG_PKT_EN 0 +#define HIKP_NOTIFY_PKT_CFG_START_EN 1 +#define HIKP_NOTIFY_PKT_CFG_PKT_NUM_M GENMASK(5, 2) +#define HIKP_NOTIFY_PKT_CFG_PKT_NUM_S 2 + +#endif /* HIKP_NIC_NOTIFY_PKT_H */ -- 2.30.0

From: Peiyang Wang <wangpeiyang1@huawei.com> Add new feature in nic_qos to support query pfc storm parameters info. AR:AR20230712033518 Bugfix or Feature: Feature Signed-off-by: Peiyang Wang <wangpeiyang1@huawei.com> --- net/nic/nic_qos/hikp_nic_qos.c | 72 ++++++++++++++++++++++++++++++++-- net/nic/nic_qos/hikp_nic_qos.h | 20 ++++++++++ 2 files changed, 89 insertions(+), 3 deletions(-) diff --git a/net/nic/nic_qos/hikp_nic_qos.c b/net/nic/nic_qos/hikp_nic_qos.c index 6c2db1d..e3f0e9c 100644 --- a/net/nic/nic_qos/hikp_nic_qos.c +++ b/net/nic/nic_qos/hikp_nic_qos.c @@ -17,17 +17,21 @@ #include <unistd.h> #include "hikp_nic_qos.h" +#include "hikpt_rciep.h" static struct nic_qos_param g_qos_param = { 0 }; static void hikp_nic_qos_show_pkt_buf(const void *data); static void hikp_nic_qos_show_dcb_info(const void *data); static void hikp_nic_qos_show_pause_info(const void *data); +static void hikp_nic_qos_show_pfc_storm_para(const void *data); static const struct qos_feature_cmd g_qos_feature_cmd[] = { {"pkt_buf", NIC_PACKET_BUFFER_DUMP, hikp_nic_qos_show_pkt_buf}, {"dcb", NIC_DCB_DUMP, hikp_nic_qos_show_dcb_info}, {"pause", NIC_PAUSE_DUMP, hikp_nic_qos_show_pause_info}, + {"pfc_storm_para", NIC_PFC_STORM_PARA_DUMP, + hikp_nic_qos_show_pfc_storm_para}, }; static int hikp_nic_qos_cmd_help(struct major_cmd_ctrl *self, const char *argv) @@ -42,8 +46,12 @@ static int hikp_nic_qos_cmd_help(struct major_cmd_ctrl *self, const char *argv) "[-g/--get <options>]\n" " pkt_buf : get nic packet buffer.\n" " dcb : get dcb information.\n" - " pause : get pause information\n"); - + " pause : get pause information\n" + " pfc_storm_para : get pfc storm configuration parameters\n"); + printf(" %s\n", + "[-d/--dir <options>]\n" + " tx : transmit.\n" + " rx : receive.\n"); return 0; } @@ -134,6 +142,22 @@ static void hikp_nic_qos_show_pause_info(const void *data) printf("pause gap: 0x%x\n", pause->pause_gap); } +static void hikp_nic_qos_show_pfc_storm_para(const void *data) +{ + struct nic_pfc_storm_para *pfc_storm_para = + (struct nic_pfc_storm_para *)data; + + printf("PFC STORM Information:\n"); + printf("direction: %s\n", pfc_storm_para->dir ? "tx" : "rx"); + printf("enabled: %s\n", pfc_storm_para->enable ? "on" : "off"); + printf("period: %ums\n", pfc_storm_para->period_ms); + strncmp(g_qos_param.revision_id, HIKP_IEP_REVISION, + MAX_PCI_REVISION_LEN) ? + printf("check times: %u\n", pfc_storm_para->times) : + printf("pfc threshold: %ums\n", pfc_storm_para->times); + printf("recovery period: %ums\n", pfc_storm_para->recovery_period_ms); +} + static int hikp_nic_qos_get_blk(struct hikp_cmd_header *req_header, const struct nic_qos_req_para *req_data, void *buf, size_t buf_len, struct nic_qos_rsp_head *rsp_head) @@ -181,6 +205,8 @@ static int hikp_nic_query_qos_feature(struct hikp_cmd_header *req_header, const req_data.bdf = *bdf; req_data.block_id = blk_id; + req_data.dir = g_qos_param.dir; + ret = hikp_nic_qos_get_blk(req_header, &req_data, data, buf_len, &rsp_head); if (ret != 0) return ret; @@ -191,6 +217,8 @@ static int hikp_nic_query_qos_feature(struct hikp_cmd_header *req_header, const /* Copy the remaining block content if total block number is greater than 1. */ for (blk_id = 1; blk_id < total_blk_num; blk_id++) { req_data.block_id = blk_id; + req_data.dir = g_qos_param.dir; + ret = hikp_nic_qos_get_blk(req_header, &req_data, (uint8_t *)data + total_blk_size, buf_len - total_blk_size, &rsp_head); @@ -204,10 +232,11 @@ static int hikp_nic_query_qos_feature(struct hikp_cmd_header *req_header, const static 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; union nic_qos_feature_info qos_data = {0}; - const struct qos_feature_cmd *qos_cmd; struct hikp_cmd_header req_header = {0}; + const struct qos_feature_cmd *qos_cmd; int ret; if (bdf->dev_id != 0) { @@ -223,6 +252,15 @@ static void hikp_nic_qos_cmd_execute(struct major_cmd_ctrl *self) return; } + if (g_qos_param.feature_idx == NIC_PFC_STORM_PARA_DUMP && + g_qos_param.dir == NIC_QUEUE_DIR_NONE) { + hikp_nic_qos_cmd_help(self, NULL); + snprintf(self->err_str, sizeof(self->err_str), + "-d/--dir param error!"); + self->err_no = -EINVAL; + return; + } + qos_cmd = &g_qos_feature_cmd[g_qos_param.feature_idx]; hikp_cmd_init(&req_header, NIC_MOD, GET_QOS_INFO_CMD, qos_cmd->sub_cmd_code); ret = hikp_nic_query_qos_feature(&req_header, &g_qos_param.target.bdf, &qos_data); @@ -233,6 +271,13 @@ static void hikp_nic_qos_cmd_execute(struct major_cmd_ctrl *self) return; } + memset(revision_id, 0, MAX_PCI_ID_LEN + 1); + ret = get_revision_id_by_bdf(bdf, revision_id); + // show pfc threshold as default if get revision_id error + if (ret) + strncpy(g_qos_param.revision_id, HIKP_IEP_REVISION, + MAX_PCI_REVISION_LEN); + printf("############## NIC QOS: %s info ############\n", qos_cmd->feature_name); qos_cmd->show(&qos_data); printf("#################### END #######################\n"); @@ -268,11 +313,31 @@ static int hikp_nic_cmd_qos_feature_select(struct major_cmd_ctrl *self, const ch return self->err_no; } +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; + return 0; + } + if (strcmp(argv, "tx") == 0) { + g_qos_param.dir = NIC_TX_QUEUE; + return 0; + } + + snprintf(self->err_str, sizeof(self->err_str), + "-d/--dir option is invalid."); + self->err_no = -EINVAL; + + return self->err_no; +} + 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; major_cmd->option_count = 0; major_cmd->execute = hikp_nic_qos_cmd_execute; @@ -280,6 +345,7 @@ static void cmd_nic_get_qos_init(void) cmd_option_register("-h", "--help", false, hikp_nic_qos_cmd_help); cmd_option_register("-i", "--interface", true, hikp_nic_cmd_get_qos_target); cmd_option_register("-g", "--get", true, hikp_nic_cmd_qos_feature_select); + cmd_option_register("-d", "--dir", true, hikp_nic_cmd_qos_direct); } HIKP_CMD_DECLARE("nic_qos", "show qos info of nic!", cmd_nic_get_qos_init); diff --git a/net/nic/nic_qos/hikp_nic_qos.h b/net/nic/nic_qos/hikp_nic_qos.h index b5481f5..d55970a 100644 --- a/net/nic/nic_qos/hikp_nic_qos.h +++ b/net/nic/nic_qos/hikp_nic_qos.h @@ -20,6 +20,7 @@ enum nic_qos_sub_cmd_type { NIC_PACKET_BUFFER_DUMP = 0, NIC_DCB_DUMP, NIC_PAUSE_DUMP, + NIC_PFC_STORM_PARA_DUMP, }; struct nic_buf_waterline { @@ -50,6 +51,14 @@ struct nic_pfc_info { uint8_t rsv[2]; }; +struct nic_pfc_storm_para { + uint32_t dir; + uint32_t enable; + uint32_t period_ms; + uint32_t times; + uint32_t recovery_period_ms; +}; + struct nic_ets_info { uint8_t prio_tc[HIKP_NIC_MAX_USER_PRIO_NUM]; uint8_t tc_bw[HIKP_NIC_MAX_TC_NUM]; @@ -82,6 +91,7 @@ union nic_qos_feature_info { struct nic_pkt_buf_info pkt_buf; struct nic_dcb_info dcb; struct nic_pause_info pause; + struct nic_pfc_storm_para pfc_storm_para; }; struct nic_qos_rsp_head { @@ -99,11 +109,21 @@ struct nic_qos_rsp { struct nic_qos_req_para { struct bdf_t bdf; uint8_t block_id; + uint8_t dir; + uint8_t rsv[2]; +}; + +enum nic_pfc_dir { + NIC_RX_QUEUE = 0, + NIC_TX_QUEUE, + NIC_QUEUE_DIR_NONE, }; struct nic_qos_param { struct tool_target target; int feature_idx; + enum nic_pfc_dir dir; + char revision_id[MAX_PCI_ID_LEN + 1]; }; #define HIKP_QOS_MAX_FEATURE_NAME_LEN 20 -- 2.33.0

A command word was added to query the port information display capability. If a port does not support a flexible card, the card information is not displayed. Signed-off-by: veega <zhuweijia@huawei.com> --- net/nic/nic_mac/hikp_mac_cmd.h | 1 + net/nic/nic_mac/hikp_nic_port.c | 81 +++++++++++++++++++++------------ net/nic/nic_mac/hikp_nic_port.h | 17 ++++--- 3 files changed, 65 insertions(+), 34 deletions(-) diff --git a/net/nic/nic_mac/hikp_mac_cmd.h b/net/nic/nic_mac/hikp_mac_cmd.h index adaadf4..f74fd2a 100644 --- a/net/nic/nic_mac/hikp_mac_cmd.h +++ b/net/nic/nic_mac/hikp_mac_cmd.h @@ -31,6 +31,7 @@ enum mac_port_sub_cmd { QUERY_PORT_PHY_DFX, QUERY_HOT_PLUG_CARD_DFX, QUERY_PORT_CDR_DFX, + QUERY_PORT_INFO_DFX_CAP, }; enum mac_dump_reg_sub_cmd { diff --git a/net/nic/nic_mac/hikp_nic_port.c b/net/nic/nic_mac/hikp_nic_port.c index c9f46fc..5ba6927 100644 --- a/net/nic/nic_mac/hikp_nic_port.c +++ b/net/nic/nic_mac/hikp_nic_port.c @@ -361,11 +361,12 @@ static void mac_cmd_disp_arb_info(const struct mac_cmd_arb_dfx *arb_dfx) static void mac_cmd_disp_hot_plug_card_info(const struct cmd_hot_plug_card_info *hpc_dfx) { - printf("\n======================== HOT PLUG CARD INFO =======================\n"); + printf("\n===================== HOT PLUG CARD INFO =====================\n"); printf("hot plug card in position: 0x%x\n", hpc_dfx->in_pos); printf("support type: 0x%x\n", hpc_dfx->support_type); - printf("current type: 0x%x\n", hpc_dfx->cur_type); + if (hpc_dfx->in_pos) + printf("current type: 0x%x\n", hpc_dfx->cur_type); printf("----------------------------------------------------------------------------\n"); } @@ -408,13 +409,13 @@ static void mac_cmd_show_hot_plug_card(struct major_cmd_ctrl *self) static void mac_cmd_print_cdr_dfx(struct mac_cmd_cdr_dfx *cdr_dfx, struct mac_port_cdr_dfx *info) { struct mac_item type_table[] = { - {PORT_CDR_SD5902, "sd5902"}, {PORT_CDR_SD5901, "sd5901"}, + {PORT_CDR_TYPE_A, "cdr_a"}, {PORT_CDR_TYPE_B, "cdr_b"}, }; - struct mac_item sd5902_mode[] = { - {SD5902_MODE_2PLL, "2pll"}, {SD5902_MODE_FASTPI, "fastpi"}, + struct mac_item cdr_a_mode[] = { + {CDR_A_MODE_2PLL, "2pll"}, {CDR_A_MODE_FASTPI, "fastpi"}, }; - struct mac_item sd5901_mode[] = { - {SD5901_MODE_PCS, "pcs"}, {SD5901_MODE_CDR, "cdr"}, + struct mac_item cdr_b_mode[] = { + {CDR_B_MODE_PCS, "pcs"}, {CDR_B_MODE_CDR, "cdr"}, }; struct mac_item status_table[] = { {CDR_STATUS_NORMAL, "normal"}, {CDR_STATUS_ERROR, "error"}, @@ -424,12 +425,12 @@ static void mac_cmd_print_cdr_dfx(struct mac_cmd_cdr_dfx *cdr_dfx, struct mac_po const char *mode_str = "NA"; for (uint32_t i = 0; i < cdr_dfx->cdr_num; i++) { - if (cdr_dfx->cdr_type == PORT_CDR_SD5902) { - mode_str = mac_get_str(info->dfx[i].cdr_mode, sd5902_mode, - HIKP_ARRAY_SIZE(sd5902_mode), "unknown"); - } else if (cdr_dfx->cdr_type == PORT_CDR_SD5901) { - mode_str = mac_get_str(info->dfx[i].cdr_mode, sd5901_mode, - HIKP_ARRAY_SIZE(sd5901_mode), "unknown"); + if (cdr_dfx->cdr_type == PORT_CDR_TYPE_A) { + mode_str = mac_get_str(info->dfx[i].cdr_mode, cdr_a_mode, + HIKP_ARRAY_SIZE(cdr_a_mode), "unknown"); + } else if (cdr_dfx->cdr_type == PORT_CDR_TYPE_B) { + mode_str = mac_get_str(info->dfx[i].cdr_mode, cdr_b_mode, + HIKP_ARRAY_SIZE(cdr_b_mode), "unknown"); } printf("\t|0x%-8x%-9u%-10s%-10s%-10s\n", info->dfx[i].cdr_addr, info->dfx[i].cdr_start_lane, type_str, mode_str, @@ -491,35 +492,59 @@ static void mac_cmd_show_port_dfx(struct major_cmd_ctrl *self, uint32_t mask) } } -static void mac_cmd_port_execute(struct major_cmd_ctrl *self) +static int mac_cmd_get_port_dfx_cap(uint32_t *cap) { struct mac_cmd_port_hardware *port_hw = NULL; + struct mac_cmd_port_dfx_cap *dfx_cap = NULL; + struct hikp_cmd_ret *dfx_cap_resp = NULL; struct hikp_cmd_ret *hw_cmd_ret = NULL; - uint32_t mask; int ret; - if (!g_port_info.port_flag) { - self->err_no = -EINVAL; - snprintf(self->err_str, sizeof(self->err_str), "Need port id."); - return; + ret = mac_cmd_get_dfx_cfg(QUERY_PORT_INFO_DFX_CAP, &dfx_cap_resp); + if (ret == 0) { + dfx_cap = (struct mac_cmd_port_dfx_cap *)dfx_cap_resp->rsp_data; + *cap = dfx_cap->cap_bit_map; + free(dfx_cap_resp); + dfx_cap_resp = NULL; + return ret; } + /* not support get capability, so use old process */ ret = mac_cmd_get_dfx_cfg(QUERY_PORT_HARDWARE, &hw_cmd_ret); - if (ret != 0) { - printf("hikp_data_proc get port hw failed.\n"); - self->err_no = -ENOSPC; - return; - } + if (ret) + return ret; - mask = MAC_LSPORT_LINK | MAC_LSPORT_MAC | - MAC_LSPORT_ARB | MAC_HOT_PLUG_CARD | MAC_LSPORT_CDR; + *cap = MAC_LSPORT_LINK | MAC_LSPORT_MAC | MAC_LSPORT_ARB | + MAC_HOT_PLUG_CARD | MAC_LSPORT_CDR; port_hw = (struct mac_cmd_port_hardware *)(hw_cmd_ret->rsp_data); if (port_hw->port_type == HIKP_PORT_TYPE_PHY || port_hw->port_type == HIKP_PORT_TYPE_PHY_SDS) - mask |= MAC_LSPORT_PHY; + *cap |= MAC_LSPORT_PHY; - mac_cmd_show_port_dfx(self, mask); free(hw_cmd_ret); + hw_cmd_ret = NULL; + return ret; +} + +static void mac_cmd_port_execute(struct major_cmd_ctrl *self) +{ + uint32_t dfx_cap; + int ret; + + if (!g_port_info.port_flag) { + self->err_no = -EINVAL; + snprintf(self->err_str, sizeof(self->err_str), "Need port id."); + return; + } + + ret = mac_cmd_get_port_dfx_cap(&dfx_cap); + if (ret) { + self->err_no = ret; + snprintf(self->err_str, sizeof(self->err_str), "Get DFX capability failed."); + return; + } + + mac_cmd_show_port_dfx(self, dfx_cap); } static int mac_cmd_get_port_target(struct major_cmd_ctrl *self, const char *argv) diff --git a/net/nic/nic_mac/hikp_nic_port.h b/net/nic/nic_mac/hikp_nic_port.h index 42ab3f9..78928b3 100644 --- a/net/nic/nic_mac/hikp_nic_port.h +++ b/net/nic/nic_mac/hikp_nic_port.h @@ -188,18 +188,18 @@ struct mac_cmd_phy_info { }; enum { - PORT_CDR_SD5902 = 0, - PORT_CDR_SD5901, + PORT_CDR_TYPE_A = 0, + PORT_CDR_TYPE_B, }; enum { - SD5902_MODE_2PLL = 0, - SD5902_MODE_FASTPI, + CDR_A_MODE_2PLL = 0, + CDR_A_MODE_FASTPI, }; enum { - SD5901_MODE_PCS = 0, - SD5901_MODE_CDR, + CDR_B_MODE_PCS = 0, + CDR_B_MODE_CDR, }; enum { @@ -225,6 +225,11 @@ struct mac_cmd_cdr_dfx { struct mac_port_cdr_dfx host_cdr; }; +struct mac_cmd_port_dfx_cap { + uint32_t cap_bit_map; + uint32_t rsvd[3]; +}; + struct mac_cmd_dfx_callback { uint32_t mask; void (*show_dfx)(struct major_cmd_ctrl *self); -- 2.36.1.windows.1