diff --git a/0039-hikptool-roce-Add-a-common-frame-for-hikptool-roce-r.patch b/0039-hikptool-roce-Add-a-common-frame-for-hikptool-roce-r.patch new file mode 100644 index 0000000000000000000000000000000000000000..b0c20fbf25b479b3aa84cff04e21e3dcd9460163 --- /dev/null +++ b/0039-hikptool-roce-Add-a-common-frame-for-hikptool-roce-r.patch @@ -0,0 +1,386 @@ +From 8b3b68347165b602cded484d090509426f88cc75 Mon Sep 17 00:00:00 2001 +From: Junxian Huang +Date: Mon, 31 Jul 2023 21:19:46 +0800 +Subject: hikptool/roce: Add a common frame for hikptool roce register query + +Add a common frame for hikptool roce register query. + +Signed-off-by: Junxian Huang +--- + net/roce/roce_caep/hikp_roce_caep.h | 2 +- + .../roce_ext_common/hikp_roce_ext_common.c | 178 ++++++++++++++++++ + .../roce_ext_common/hikp_roce_ext_common.h | 52 +++++ + net/roce/roce_gmv/hikp_roce_gmv.h | 2 +- + net/roce/roce_mdb/hikp_roce_mdb.h | 2 +- + net/roce/roce_pkt/hikp_roce_pkt.h | 2 +- + net/roce/roce_qmm/hikp_roce_qmm.h | 2 +- + net/roce/roce_scc/hikp_roce_scc.h | 2 +- + net/roce/roce_timer/hikp_roce_timer.h | 2 +- + net/roce/roce_trp/hikp_roce_trp.h | 2 +- + net/roce/roce_tsp/hikp_roce_tsp.h | 2 +- + 11 files changed, 239 insertions(+), 9 deletions(-) + create mode 100644 net/roce/roce_ext_common/hikp_roce_ext_common.c + create mode 100644 net/roce/roce_ext_common/hikp_roce_ext_common.h + +diff --git a/net/roce/roce_caep/hikp_roce_caep.h b/net/roce/roce_caep/hikp_roce_caep.h +index 3c494b1..804d2df 100644 +--- a/net/roce/roce_caep/hikp_roce_caep.h ++++ b/net/roce/roce_caep/hikp_roce_caep.h +@@ -14,7 +14,7 @@ + #ifndef __HIKP_ROCE_CAEP_H__ + #define __HIKP_ROCE_CAEP_H__ + +-#include "hikp_net_lib.h" ++#include "hikp_roce_ext_common.h" + + #define ROCE_HIKP_CAEP_REG_NUM 29 + #define PER_REG_NUM 2 +diff --git a/net/roce/roce_ext_common/hikp_roce_ext_common.c b/net/roce/roce_ext_common/hikp_roce_ext_common.c +new file mode 100644 +index 0000000..ec47dce +--- /dev/null ++++ b/net/roce/roce_ext_common/hikp_roce_ext_common.c +@@ -0,0 +1,178 @@ ++/* ++ * 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_roce_ext_common.h" ++ ++static void hikp_roce_ext_reg_data_free(struct reg_data *reg) ++{ ++ if (reg->offset) ++ free(reg->offset); ++ ++ if (reg->data) ++ free(reg->data); ++} ++ ++static void hikp_roce_ext_cmd_ret_free(struct hikp_cmd_ret *cmd_ret) ++{ ++ if (cmd_ret) ++ free(cmd_ret); ++} ++ ++static const struct cmd_type_info { ++ enum roce_cmd_type cmd_type; ++ const char *cmd_name; ++ uint8_t reg_array_length; ++} cmd_info_table[] = { ++ {GET_ROCEE_MDB_CMD, "MDB", ROCE_HIKP_MDB_REG_NUM_EXT}, ++ {GET_ROCEE_GMV_CMD, "GMV", ROCE_HIKP_GMV_REG_NUM_EXT}, ++ {GET_ROCEE_CAEP_CMD, "CAEP", ROCE_HIKP_CAEP_REG_NUM_EXT}, ++ {GET_ROCEE_PKT_CMD, "PKT", ROCE_HIKP_PKT_REG_NUM_EXT}, ++ {GET_ROCEE_SCC_CMD, "SCC", ROCE_HIKP_SCC_REG_NUM_EXT}, ++ {GET_ROCEE_QMM_CMD, "QMM", ROCE_HIKP_QMM_REG_NUM_EXT}, ++ {GET_ROCEE_TIMER_CMD, "TIMER", ROCE_HIKP_TIMER_REG_NUM_EXT}, ++ {GET_ROCEE_TRP_CMD, "TRP", ROCE_HIKP_TRP_REG_NUM_EXT}, ++ {GET_ROCEE_TSP_CMD, "TSP", ROCE_HIKP_TSP_REG_NUM_EXT}, ++}; ++ ++static int get_cmd_info_table_idx(enum roce_cmd_type cmd_type) ++{ ++ int array_size = sizeof(cmd_info_table) / sizeof(struct cmd_type_info); ++ int i; ++ ++ for (i = 0; i < array_size; i++) ++ if (cmd_type == cmd_info_table[i].cmd_type) ++ return i; ++ ++ return -ENOENT; ++} ++ ++static const char *get_cmd_name(enum roce_cmd_type cmd_type) ++{ ++ int idx; ++ ++ idx = get_cmd_info_table_idx(cmd_type); ++ if (idx >= 0) ++ return cmd_info_table[idx].cmd_name; ++ ++ printf("Failed to get cmd name, cmd_type = %d\n", cmd_type); ++ return NULL; ++} ++ ++static int get_cmd_reg_array_length(enum roce_cmd_type cmd_type) ++{ ++ int idx; ++ ++ idx = get_cmd_info_table_idx(cmd_type); ++ if (idx >= 0) ++ return cmd_info_table[idx].reg_array_length; ++ ++ printf("Failed to get cmd reg array length, cmd_type = %d\n", cmd_type); ++ return idx; ++} ++ ++static int hikp_roce_ext_get_res(enum roce_cmd_type cmd_type, ++ uint32_t block_id, ++ struct roce_ext_head *res_head, ++ struct reg_data *reg, ++ int (*get_data)(struct hikp_cmd_ret **cmd_ret, ++ uint32_t block_id)) ++{ ++ int reg_array_length = get_cmd_reg_array_length(cmd_type); ++ const char *cmd_name = get_cmd_name(cmd_type); ++ struct roce_ext_res_param *roce_ext_res; ++ struct hikp_cmd_ret *cmd_ret; ++ size_t max_size; ++ size_t cur_size; ++ int ret; ++ ++ /* reg_array_length greater than or equal to 0 ensures that cmd_name ++ * is not NULL, so cmd_name does not need to be checked. ++ */ ++ if (reg_array_length < 0) ++ return reg_array_length; ++ ++ ret = get_data(&cmd_ret, block_id); ++ if (ret) { ++ printf("hikptool roce_%s get data failed!\n", cmd_name); ++ goto get_data_error; ++ } ++ ++ roce_ext_res = (struct roce_ext_res_param *)cmd_ret->rsp_data; ++ *res_head = roce_ext_res->head; ++ max_size = res_head->total_block_num * sizeof(uint32_t); ++ ++ if (block_id == 0) { ++ reg->offset = (uint32_t *)malloc(max_size); ++ reg->data = (uint32_t *)malloc(max_size); ++ if ((reg->offset == NULL) || (reg->data == NULL)) { ++ printf("hikptool roce_%s alloc log memmory 0x%x failed!\n", ++ cmd_name, max_size); ++ ret = -ENOMEM; ++ hikp_roce_ext_reg_data_free(reg); ++ goto get_data_error; ++ } ++ } ++ ++ cur_size = res_head->cur_block_num * sizeof(uint32_t); ++ if (cur_size > max_size) { ++ printf("hikptool roce_%s log data copy size error, data size: 0x%x, max size: 0x%x\n", ++ cmd_name, cur_size, max_size); ++ ret = -EINVAL; ++ hikp_roce_ext_reg_data_free(reg); ++ goto get_data_error; ++ } ++ ++ memcpy(reg->offset + block_id, ++ (uint32_t *)&roce_ext_res->reg_data, cur_size); ++ memcpy(reg->data + block_id, ++ (uint32_t *)&roce_ext_res->reg_data + reg_array_length, cur_size); ++ ++get_data_error: ++ hikp_roce_ext_cmd_ret_free(cmd_ret); ++ return ret; ++} ++ ++static void hikp_roce_ext_print(const char *cmd_name, uint32_t total_block_num, ++ const uint32_t *offset, const uint32_t *data) ++{ ++ int i; ++ ++ printf("**************%s INFO*************\n", cmd_name); ++ for (i = 0; i < total_block_num; i++) ++ printf("[0x%08X] : 0x%08X\n", offset[i], data[i]); ++ printf("************************************\n"); ++} ++ ++void hikp_roce_ext_execute(struct major_cmd_ctrl *self, ++ enum roce_cmd_type cmd_type, ++ int (*get_data)(struct hikp_cmd_ret **cmd_ret, ++ uint32_t block_id)) ++{ ++ uint32_t queried_block_id = 0; ++ struct roce_ext_head res_head; ++ struct reg_data reg = { 0 }; ++ ++ do { ++ self->err_no = hikp_roce_ext_get_res(cmd_type, queried_block_id, ++ &res_head, ®, get_data); ++ if (self->err_no) ++ return; ++ ++ queried_block_id += res_head.cur_block_num; ++ } while (queried_block_id < res_head.total_block_num); ++ ++ hikp_roce_ext_print(get_cmd_name(cmd_type), res_head.total_block_num, ++ reg.offset, reg.data); ++ ++ hikp_roce_ext_reg_data_free(®); ++} +diff --git a/net/roce/roce_ext_common/hikp_roce_ext_common.h b/net/roce/roce_ext_common/hikp_roce_ext_common.h +new file mode 100644 +index 0000000..1e8063d +--- /dev/null ++++ b/net/roce/roce_ext_common/hikp_roce_ext_common.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_ROCE_EXT_COMMON_H__ ++#define __HIKP_ROCE_EXT_COMMON_H__ ++ ++#include "hikp_net_lib.h" ++ ++#define ROCE_MAX_REG_NUM (NET_MAX_REQ_DATA_NUM - 1) ++ ++#define ROCE_HIKP_CAEP_REG_NUM_EXT ROCE_MAX_REG_NUM ++#define ROCE_HIKP_GMV_REG_NUM_EXT ROCE_MAX_REG_NUM ++#define ROCE_HIKP_MDB_REG_NUM_EXT ROCE_MAX_REG_NUM ++#define ROCE_HIKP_PKT_REG_NUM_EXT ROCE_MAX_REG_NUM ++#define ROCE_HIKP_QMM_REG_NUM_EXT ROCE_MAX_REG_NUM ++#define ROCE_HIKP_SCC_REG_NUM_EXT ROCE_MAX_REG_NUM ++#define ROCE_HIKP_TIMER_REG_NUM_EXT ROCE_MAX_REG_NUM ++#define ROCE_HIKP_TRP_REG_NUM_EXT ROCE_MAX_REG_NUM ++#define ROCE_HIKP_TSP_REG_NUM_EXT ROCE_MAX_REG_NUM ++ ++struct roce_ext_head { ++ uint8_t total_block_num; ++ uint8_t cur_block_num; ++ uint16_t reserved; ++}; ++ ++struct roce_ext_res_param { ++ struct roce_ext_head head; ++ uint32_t reg_data[0]; ++}; ++ ++struct reg_data { ++ uint32_t *offset; ++ uint32_t *data; ++}; ++ ++void hikp_roce_ext_execute(struct major_cmd_ctrl *self, ++ enum roce_cmd_type cmd_type, ++ int (*get_data)(struct hikp_cmd_ret **cmd_ret, ++ uint32_t block_id)); ++ ++#endif /* __HIKP_ROCE_EXT_COMMON_H__ */ +diff --git a/net/roce/roce_gmv/hikp_roce_gmv.h b/net/roce/roce_gmv/hikp_roce_gmv.h +index 30f37fb..1ef5b93 100644 +--- a/net/roce/roce_gmv/hikp_roce_gmv.h ++++ b/net/roce/roce_gmv/hikp_roce_gmv.h +@@ -14,7 +14,7 @@ + #ifndef __HIKP_ROCE_GMV_H__ + #define __HIKP_ROCE_GMV_H__ + +-#include "hikp_net_lib.h" ++#include "hikp_roce_ext_common.h" + + #define ROCE_HIKP_GMV_REG_NUM 7 + #define ROCE_HIKP_GMV_REG_SWICTH 2 +diff --git a/net/roce/roce_mdb/hikp_roce_mdb.h b/net/roce/roce_mdb/hikp_roce_mdb.h +index 8e7da03..7643dff 100644 +--- a/net/roce/roce_mdb/hikp_roce_mdb.h ++++ b/net/roce/roce_mdb/hikp_roce_mdb.h +@@ -14,7 +14,7 @@ + #ifndef __HIKP_ROCE_MDB_H__ + #define __HIKP_ROCE_MDB_H__ + +-#include "hikp_net_lib.h" ++#include "hikp_roce_ext_common.h" + + #define ROCE_HIKP_MDB_REG_NUM 22 + #define ROCE_HIKP_REG_SWICTH 2 +diff --git a/net/roce/roce_pkt/hikp_roce_pkt.h b/net/roce/roce_pkt/hikp_roce_pkt.h +index 5f438b7..0200c44 100644 +--- a/net/roce/roce_pkt/hikp_roce_pkt.h ++++ b/net/roce/roce_pkt/hikp_roce_pkt.h +@@ -14,7 +14,7 @@ + #ifndef __HIKP_ROCE_PKT_H__ + #define __HIKP_ROCE_PKT_H__ + +-#include "hikp_net_lib.h" ++#include "hikp_roce_ext_common.h" + + #define ROCE_HIKP_PKT_REG_NUM 29 + #define PKT_PER_REG_NUM 2 +diff --git a/net/roce/roce_qmm/hikp_roce_qmm.h b/net/roce/roce_qmm/hikp_roce_qmm.h +index 08cb5d2..0645ab3 100644 +--- a/net/roce/roce_qmm/hikp_roce_qmm.h ++++ b/net/roce/roce_qmm/hikp_roce_qmm.h +@@ -14,7 +14,7 @@ + #ifndef __HIKP_ROCE_QMM_H__ + #define __HIKP_ROCE_QMM_H__ + +-#include "hikp_net_lib.h" ++#include "hikp_roce_ext_common.h" + + #define ROCE_HIKP_QMM_REG_NUM 36 + #define QMM_BANK_NUM 0x7 +diff --git a/net/roce/roce_scc/hikp_roce_scc.h b/net/roce/roce_scc/hikp_roce_scc.h +index de8772e..5d37a11 100644 +--- a/net/roce/roce_scc/hikp_roce_scc.h ++++ b/net/roce/roce_scc/hikp_roce_scc.h +@@ -14,7 +14,7 @@ + #ifndef __HIKP_ROCE_SCC_H__ + #define __HIKP_ROCE_SCC_H__ + +-#include "hikp_net_lib.h" ++#include "hikp_roce_ext_common.h" + + #define ROCE_HIKP_SCC_REG_NUM 29 + #define MAX_SCC_MODULE_NAME_LEN 20 +diff --git a/net/roce/roce_timer/hikp_roce_timer.h b/net/roce/roce_timer/hikp_roce_timer.h +index a4a32b1..7f7deb6 100644 +--- a/net/roce/roce_timer/hikp_roce_timer.h ++++ b/net/roce/roce_timer/hikp_roce_timer.h +@@ -14,7 +14,7 @@ + #ifndef __HIKP_ROCE_TIMER_H__ + #define __HIKP_ROCE_TIMER_H__ + +-#include "hikp_net_lib.h" ++#include "hikp_roce_ext_common.h" + + #define ROCE_HIKP_TIMER_REG_NUM 25 + #define ROCE_TIMER_CMD_CLEAR (1 << 0) +diff --git a/net/roce/roce_trp/hikp_roce_trp.h b/net/roce/roce_trp/hikp_roce_trp.h +index 80d28af..97f1838 100644 +--- a/net/roce/roce_trp/hikp_roce_trp.h ++++ b/net/roce/roce_trp/hikp_roce_trp.h +@@ -14,7 +14,7 @@ + #ifndef __HIKP_ROCE_TRP_H__ + #define __HIKP_ROCE_TRP_H__ + +-#include "hikp_net_lib.h" ++#include "hikp_roce_ext_common.h" + + #define TRP_DIV_NUM_T 4 + #define ROCE_HIKP_TRP_REG_NUM 29 +diff --git a/net/roce/roce_tsp/hikp_roce_tsp.h b/net/roce/roce_tsp/hikp_roce_tsp.h +index ae864ba..43d0d0d 100644 +--- a/net/roce/roce_tsp/hikp_roce_tsp.h ++++ b/net/roce/roce_tsp/hikp_roce_tsp.h +@@ -14,7 +14,7 @@ + #ifndef __HIKP_ROCE_TSP_H__ + #define __HIKP_ROCE_TSP_H__ + +-#include "hikp_net_lib.h" ++#include "hikp_roce_ext_common.h" + + #define ROCE_HIKP_TSP_REG_NUM 29 + #define TSP_PER_REG_NUM 2 +-- +2.30.0 + diff --git a/0040-hikptool-roce-Add-roce_rst-cmd-for-reset-signal-regi.patch b/0040-hikptool-roce-Add-roce_rst-cmd-for-reset-signal-regi.patch new file mode 100644 index 0000000000000000000000000000000000000000..22312d35d94e39fcb37135997299b74919ba42b8 --- /dev/null +++ b/0040-hikptool-roce-Add-roce_rst-cmd-for-reset-signal-regi.patch @@ -0,0 +1,179 @@ +From a0ac3e3cd5e94657ee1a58c74037aa6898898c75 Mon Sep 17 00:00:00 2001 +From: Junxian Huang +Date: Fri, 4 Aug 2023 17:25:53 +0800 +Subject: hikptool/roce: Add roce_rst cmd for reset signal registers query + +Add roce_rst cmd for reset signal registers query. + +Example: +hikptool roce_rst -i eth1 + +Signed-off-by: Junxian Huang +--- + net/hikp_net_lib.h | 1 + + .../roce_ext_common/hikp_roce_ext_common.c | 1 + + .../roce_ext_common/hikp_roce_ext_common.h | 1 + + net/roce/roce_rst/hikp_roce_rst.c | 78 +++++++++++++++++++ + net/roce/roce_rst/hikp_roce_rst.h | 29 +++++++ + 5 files changed, 110 insertions(+) + create mode 100644 net/roce/roce_rst/hikp_roce_rst.c + create mode 100644 net/roce/roce_rst/hikp_roce_rst.h + +diff --git a/net/hikp_net_lib.h b/net/hikp_net_lib.h +index 21b5357..e60fc15 100644 +--- a/net/hikp_net_lib.h ++++ b/net/hikp_net_lib.h +@@ -100,6 +100,7 @@ enum roce_cmd_type { + GET_ROCEE_TIMER_CMD, + GET_ROCEE_TRP_CMD, + GET_ROCEE_TSP_CMD, ++ GET_ROCEE_RST_CMD, + }; + + enum ub_cmd_type { +diff --git a/net/roce/roce_ext_common/hikp_roce_ext_common.c b/net/roce/roce_ext_common/hikp_roce_ext_common.c +index ec47dce..01dded5 100644 +--- a/net/roce/roce_ext_common/hikp_roce_ext_common.c ++++ b/net/roce/roce_ext_common/hikp_roce_ext_common.c +@@ -42,6 +42,7 @@ static const struct cmd_type_info { + {GET_ROCEE_TIMER_CMD, "TIMER", ROCE_HIKP_TIMER_REG_NUM_EXT}, + {GET_ROCEE_TRP_CMD, "TRP", ROCE_HIKP_TRP_REG_NUM_EXT}, + {GET_ROCEE_TSP_CMD, "TSP", ROCE_HIKP_TSP_REG_NUM_EXT}, ++ {GET_ROCEE_RST_CMD, "RST", ROCE_HIKP_RST_REG_NUM}, + }; + + static int get_cmd_info_table_idx(enum roce_cmd_type cmd_type) +diff --git a/net/roce/roce_ext_common/hikp_roce_ext_common.h b/net/roce/roce_ext_common/hikp_roce_ext_common.h +index 1e8063d..918712f 100644 +--- a/net/roce/roce_ext_common/hikp_roce_ext_common.h ++++ b/net/roce/roce_ext_common/hikp_roce_ext_common.h +@@ -27,6 +27,7 @@ + #define ROCE_HIKP_TIMER_REG_NUM_EXT ROCE_MAX_REG_NUM + #define ROCE_HIKP_TRP_REG_NUM_EXT ROCE_MAX_REG_NUM + #define ROCE_HIKP_TSP_REG_NUM_EXT ROCE_MAX_REG_NUM ++#define ROCE_HIKP_RST_REG_NUM ROCE_MAX_REG_NUM + + struct roce_ext_head { + uint8_t total_block_num; +diff --git a/net/roce/roce_rst/hikp_roce_rst.c b/net/roce/roce_rst/hikp_roce_rst.c +new file mode 100644 +index 0000000..ad4dd0c +--- /dev/null ++++ b/net/roce/roce_rst/hikp_roce_rst.c +@@ -0,0 +1,78 @@ ++/* ++ * 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_roce_rst.h" ++ ++static struct cmd_roce_rst_param g_roce_rst_param = { 0 }; ++ ++static int hikp_roce_rst_help(struct major_cmd_ctrl *self, const char *argv) ++{ ++ printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i \n"); ++ printf("\n %s\n", self->cmd_ptr->help_info); ++ printf(" Options:\n\n"); ++ printf(" %s, %-25s %s\n", "-h", "--help", "display this help and exit"); ++ printf(" %s, %-25s %s\n", "-i", "--interface=", "device target, e.g. eth0"); ++ printf("\n"); ++ ++ return 0; ++} ++ ++static int hikp_roce_rst_target(struct major_cmd_ctrl *self, const char *argv) ++{ ++ self->err_no = tool_check_and_get_valid_bdf_id(argv, &(g_roce_rst_param.target)); ++ if (self->err_no) ++ snprintf(self->err_str, sizeof(self->err_str), "Unknown device %s.\n", argv); ++ ++ return self->err_no; ++} ++ ++static int hikp_roce_rst_get_data(struct hikp_cmd_ret **cmd_ret, ++ uint32_t block_id) ++{ ++ struct hikp_cmd_header req_header = { 0 }; ++ struct roce_rst_req_param req_data; ++ uint32_t req_size; ++ int ret; ++ ++ req_data.bdf = g_roce_rst_param.target.bdf; ++ req_data.block_id = block_id; ++ ++ req_size = sizeof(struct roce_rst_req_param); ++ hikp_cmd_init(&req_header, ROCE_MOD, GET_ROCEE_RST_CMD, ++ g_roce_rst_param.sub_cmd); ++ *cmd_ret = hikp_cmd_alloc(&req_header, &req_data, req_size); ++ ret = hikp_rsp_normal_check(*cmd_ret); ++ if (ret) ++ printf("hikptool roce_rst cmd_ret malloc failed, sub_cmd = %u, ret = %d.\n", ++ g_roce_rst_param.sub_cmd, ret); ++ ++ return ret; ++} ++ ++static void hikp_roce_rst_execute(struct major_cmd_ctrl *self) ++{ ++ hikp_roce_ext_execute(self, GET_ROCEE_RST_CMD, hikp_roce_rst_get_data); ++} ++ ++static void cmd_roce_rst_init(void) ++{ ++ struct major_cmd_ctrl *major_cmd = get_major_cmd(); ++ ++ major_cmd->option_count = 0; ++ major_cmd->execute = hikp_roce_rst_execute; ++ ++ cmd_option_register("-h", "--help", false, hikp_roce_rst_help); ++ cmd_option_register("-i", "--interface", true, hikp_roce_rst_target); ++} ++ ++HIKP_CMD_DECLARE("roce_rst", "get roce_rst registers information", cmd_roce_rst_init); +diff --git a/net/roce/roce_rst/hikp_roce_rst.h b/net/roce/roce_rst/hikp_roce_rst.h +new file mode 100644 +index 0000000..731effc +--- /dev/null ++++ b/net/roce/roce_rst/hikp_roce_rst.h +@@ -0,0 +1,29 @@ ++/* ++ * 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_ROCE_RST_H__ ++#define __HIKP_ROCE_RST_H__ ++ ++#include "hikp_roce_ext_common.h" ++ ++struct cmd_roce_rst_param { ++ struct tool_target target; ++ uint32_t sub_cmd; ++}; ++ ++struct roce_rst_req_param { ++ struct bdf_t bdf; ++ uint32_t block_id; ++}; ++ ++#endif /* __HIKP_ROCE_RST_H__ */ +-- +2.30.0 + diff --git a/0041-hikptool-roce-Add-roce_global_cfg-cmd-for-global-con.patch b/0041-hikptool-roce-Add-roce_global_cfg-cmd-for-global-con.patch new file mode 100644 index 0000000000000000000000000000000000000000..460cad38259fcdde17e6a15907c9e5b49dec25e2 --- /dev/null +++ b/0041-hikptool-roce-Add-roce_global_cfg-cmd-for-global-con.patch @@ -0,0 +1,210 @@ +From 36ba114387e6b262d5a55b397a47e63fd0e75d0a Mon Sep 17 00:00:00 2001 +From: Junxian Huang +Date: Wed, 2 Aug 2023 16:12:49 +0800 +Subject: hikptool/roce: Add roce_global_cfg cmd for global config registers + query + +Add roce_global_cfg cmd for global config registers query + +Example: +hikptool roce_global_cfg -i eth1 + +Signed-off-by: Junxian Huang +--- + net/hikp_net_lib.h | 1 + + .../roce_ext_common/hikp_roce_ext_common.c | 1 + + .../roce_ext_common/hikp_roce_ext_common.h | 1 + + .../roce_global_cfg/hikp_roce_global_cfg.c | 97 +++++++++++++++++++ + .../roce_global_cfg/hikp_roce_global_cfg.h | 40 ++++++++ + 5 files changed, 140 insertions(+) + create mode 100644 net/roce/roce_global_cfg/hikp_roce_global_cfg.c + create mode 100644 net/roce/roce_global_cfg/hikp_roce_global_cfg.h + +diff --git a/net/hikp_net_lib.h b/net/hikp_net_lib.h +index e60fc15..bdaacb1 100644 +--- a/net/hikp_net_lib.h ++++ b/net/hikp_net_lib.h +@@ -101,6 +101,7 @@ enum roce_cmd_type { + GET_ROCEE_TRP_CMD, + GET_ROCEE_TSP_CMD, + GET_ROCEE_RST_CMD, ++ GET_ROCEE_GLOBAL_CFG_CMD, + }; + + enum ub_cmd_type { +diff --git a/net/roce/roce_ext_common/hikp_roce_ext_common.c b/net/roce/roce_ext_common/hikp_roce_ext_common.c +index 01dded5..0ff07dc 100644 +--- a/net/roce/roce_ext_common/hikp_roce_ext_common.c ++++ b/net/roce/roce_ext_common/hikp_roce_ext_common.c +@@ -43,6 +43,7 @@ static const struct cmd_type_info { + {GET_ROCEE_TRP_CMD, "TRP", ROCE_HIKP_TRP_REG_NUM_EXT}, + {GET_ROCEE_TSP_CMD, "TSP", ROCE_HIKP_TSP_REG_NUM_EXT}, + {GET_ROCEE_RST_CMD, "RST", ROCE_HIKP_RST_REG_NUM}, ++ {GET_ROCEE_GLOBAL_CFG_CMD, "GLOBAL_CFG", ROCE_HIKP_GLOBAL_CFG_REG_NUM}, + }; + + static int get_cmd_info_table_idx(enum roce_cmd_type cmd_type) +diff --git a/net/roce/roce_ext_common/hikp_roce_ext_common.h b/net/roce/roce_ext_common/hikp_roce_ext_common.h +index 918712f..870a361 100644 +--- a/net/roce/roce_ext_common/hikp_roce_ext_common.h ++++ b/net/roce/roce_ext_common/hikp_roce_ext_common.h +@@ -28,6 +28,7 @@ + #define ROCE_HIKP_TRP_REG_NUM_EXT ROCE_MAX_REG_NUM + #define ROCE_HIKP_TSP_REG_NUM_EXT ROCE_MAX_REG_NUM + #define ROCE_HIKP_RST_REG_NUM ROCE_MAX_REG_NUM ++#define ROCE_HIKP_GLOBAL_CFG_REG_NUM ROCE_MAX_REG_NUM + + struct roce_ext_head { + uint8_t total_block_num; +diff --git a/net/roce/roce_global_cfg/hikp_roce_global_cfg.c b/net/roce/roce_global_cfg/hikp_roce_global_cfg.c +new file mode 100644 +index 0000000..49a4a2c +--- /dev/null ++++ b/net/roce/roce_global_cfg/hikp_roce_global_cfg.c +@@ -0,0 +1,97 @@ ++/* ++ * 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_roce_global_cfg.h" ++ ++static struct cmd_roce_global_cfg_param g_roce_global_cfg_param = { 0 }; ++ ++static int hikp_roce_global_cfg_help(struct major_cmd_ctrl *self, ++ const char *argv) ++{ ++ printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i \n"); ++ printf("\n %s\n", self->cmd_ptr->help_info); ++ printf(" Options:\n\n"); ++ printf(" %s, %-25s %s\n", "-h", "--help", "display this help and exit"); ++ printf(" %s, %-25s %s\n", "-i", "--interface=", "device target, e.g. eth0"); ++ printf("\n"); ++ ++ return 0; ++} ++ ++static int hikp_roce_global_cfg_target(struct major_cmd_ctrl *self, ++ const char *argv) ++{ ++ self->err_no = tool_check_and_get_valid_bdf_id(argv, &(g_roce_global_cfg_param.target)); ++ if (self->err_no) ++ snprintf(self->err_str, sizeof(self->err_str), ++ "Unknown device %s.\n", argv); ++ ++ return self->err_no; ++} ++ ++static int hikp_roce_global_cfg_get_data(struct hikp_cmd_ret **cmd_ret, ++ uint32_t block_id) ++{ ++ struct hikp_cmd_header req_header = { 0 }; ++ struct roce_global_cfg_req_param req_data; ++ uint32_t req_size; ++ int ret; ++ ++ req_data.bdf = g_roce_global_cfg_param.target.bdf; ++ req_data.block_id = block_id; ++ ++ req_size = sizeof(struct roce_global_cfg_req_param); ++ hikp_cmd_init(&req_header, ROCE_MOD, GET_ROCEE_GLOBAL_CFG_CMD, ++ g_roce_global_cfg_param.sub_cmd); ++ *cmd_ret = hikp_cmd_alloc(&req_header, &req_data, req_size); ++ ret = hikp_rsp_normal_check(*cmd_ret); ++ if (ret) ++ printf("hikptool roce_global_cfg cmd_ret malloc failed, sub_cmd = %u, ret = %d.\n", ++ g_roce_global_cfg_param.sub_cmd, ret); ++ ++ return ret; ++} ++ ++static void hikp_roce_global_cfg_execute(struct major_cmd_ctrl *self) ++{ ++ enum roce_global_cfg_cmd_type sub_cmds[] = { ++ ROCE_GLB_GENAC, ++ ROCE_GLB_TRP_BANK, ++ ROCE_GLB_TRP_RX, ++ ROCE_GLB_TPP_M, ++ ROCE_GLB_QMM, ++ ROCE_GLB_TGP_TMP, ++ ROCE_GLB_TDP_M, ++ ROCE_GLB_NICL, ++ }; ++ int i; ++ ++ for (i = 0; i < HIKP_ARRAY_SIZE(sub_cmds); i++) { ++ g_roce_global_cfg_param.sub_cmd = sub_cmds[i]; ++ hikp_roce_ext_execute(self, GET_ROCEE_GLOBAL_CFG_CMD, ++ hikp_roce_global_cfg_get_data); ++ } ++} ++ ++static void cmd_roce_global_cfg_init(void) ++{ ++ struct major_cmd_ctrl *major_cmd = get_major_cmd(); ++ ++ major_cmd->option_count = 0; ++ major_cmd->execute = hikp_roce_global_cfg_execute; ++ ++ cmd_option_register("-h", "--help", false, hikp_roce_global_cfg_help); ++ cmd_option_register("-i", "--interface", true, hikp_roce_global_cfg_target); ++} ++ ++HIKP_CMD_DECLARE("roce_global_cfg", "get roce_global_cfg registers information", cmd_roce_global_cfg_init); +diff --git a/net/roce/roce_global_cfg/hikp_roce_global_cfg.h b/net/roce/roce_global_cfg/hikp_roce_global_cfg.h +new file mode 100644 +index 0000000..66e7fb8 +--- /dev/null ++++ b/net/roce/roce_global_cfg/hikp_roce_global_cfg.h +@@ -0,0 +1,40 @@ ++/* ++ * 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_ROCE_GLOBAL_CFG_H__ ++#define __HIKP_ROCE_GLOBAL_CFG_H__ ++ ++#include "hikp_roce_ext_common.h" ++ ++struct cmd_roce_global_cfg_param { ++ struct tool_target target; ++ uint32_t sub_cmd; ++}; ++ ++struct roce_global_cfg_req_param { ++ struct bdf_t bdf; ++ uint32_t block_id; ++}; ++ ++enum roce_global_cfg_cmd_type { ++ ROCE_GLB_GENAC = 0, ++ ROCE_GLB_TRP_BANK, ++ ROCE_GLB_TRP_RX, ++ ROCE_GLB_TPP_M, ++ ROCE_GLB_QMM, ++ ROCE_GLB_TGP_TMP, ++ ROCE_GLB_TDP_M, ++ ROCE_GLB_NICL, ++}; ++ ++#endif /* __HIKP_ROCE_GLOBAL_CFG_H__ */ +-- +2.30.0 + diff --git a/0042-hikptool-roce-Add-roce_bond-cmd-for-bond-registers-q.patch b/0042-hikptool-roce-Add-roce_bond-cmd-for-bond-registers-q.patch new file mode 100644 index 0000000000000000000000000000000000000000..d35e5337339ebc6b8d98606a1c63198b43943b42 --- /dev/null +++ b/0042-hikptool-roce-Add-roce_bond-cmd-for-bond-registers-q.patch @@ -0,0 +1,179 @@ +From 7f0a2e3f2dff9b49ce5be8b07835fa7c791cdce1 Mon Sep 17 00:00:00 2001 +From: Junxian Huang +Date: Wed, 2 Aug 2023 16:17:40 +0800 +Subject: hikptool/roce: Add roce_bond cmd for bond registers query + +Add roce_bond cmd for bond registers query. + +Example: +hikptool roce_bond -i eth1 + +Signed-off-by: Junxian Huang +--- + net/hikp_net_lib.h | 1 + + net/roce/roce_bond/hikp_roce_bond.c | 78 +++++++++++++++++++ + net/roce/roce_bond/hikp_roce_bond.h | 29 +++++++ + .../roce_ext_common/hikp_roce_ext_common.c | 1 + + .../roce_ext_common/hikp_roce_ext_common.h | 1 + + 5 files changed, 110 insertions(+) + create mode 100644 net/roce/roce_bond/hikp_roce_bond.c + create mode 100644 net/roce/roce_bond/hikp_roce_bond.h + +diff --git a/net/hikp_net_lib.h b/net/hikp_net_lib.h +index bdaacb1..ad9e7e4 100644 +--- a/net/hikp_net_lib.h ++++ b/net/hikp_net_lib.h +@@ -102,6 +102,7 @@ enum roce_cmd_type { + GET_ROCEE_TSP_CMD, + GET_ROCEE_RST_CMD, + GET_ROCEE_GLOBAL_CFG_CMD, ++ GET_ROCEE_BOND_CMD, + }; + + enum ub_cmd_type { +diff --git a/net/roce/roce_bond/hikp_roce_bond.c b/net/roce/roce_bond/hikp_roce_bond.c +new file mode 100644 +index 0000000..89f8bab +--- /dev/null ++++ b/net/roce/roce_bond/hikp_roce_bond.c +@@ -0,0 +1,78 @@ ++/* ++ * 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_roce_bond.h" ++ ++static struct cmd_roce_bond_param g_roce_bond_param = { 0 }; ++ ++static int hikp_roce_bond_help(struct major_cmd_ctrl *self, const char *argv) ++{ ++ printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i \n"); ++ printf("\n %s\n", self->cmd_ptr->help_info); ++ printf(" Options:\n\n"); ++ printf(" %s, %-25s %s\n", "-h", "--help", "display this help and exit"); ++ printf(" %s, %-25s %s\n", "-i", "--interface=", "device target, e.g. eth0"); ++ printf("\n"); ++ ++ return 0; ++} ++ ++static int hikp_roce_bond_target(struct major_cmd_ctrl *self, const char *argv) ++{ ++ self->err_no = tool_check_and_get_valid_bdf_id(argv, &(g_roce_bond_param.target)); ++ if (self->err_no) ++ snprintf(self->err_str, sizeof(self->err_str), "Unknown device %s.\n", argv); ++ ++ return self->err_no; ++} ++ ++static int hikp_roce_bond_get_data(struct hikp_cmd_ret **cmd_ret, ++ uint32_t block_id) ++{ ++ struct hikp_cmd_header req_header = { 0 }; ++ struct roce_bond_req_param req_data; ++ uint32_t req_size; ++ int ret; ++ ++ req_data.bdf = g_roce_bond_param.target.bdf; ++ req_data.block_id = block_id; ++ ++ req_size = sizeof(struct roce_bond_req_param); ++ hikp_cmd_init(&req_header, ROCE_MOD, GET_ROCEE_BOND_CMD, ++ g_roce_bond_param.sub_cmd); ++ *cmd_ret = hikp_cmd_alloc(&req_header, &req_data, req_size); ++ ret = hikp_rsp_normal_check(*cmd_ret); ++ if (ret) ++ printf("hikptool roce_bond cmd_ret malloc failed, sub_cmd = %u, ret = %d.\n", ++ g_roce_bond_param.sub_cmd, ret); ++ ++ return ret; ++} ++ ++static void hikp_roce_bond_execute(struct major_cmd_ctrl *self) ++{ ++ hikp_roce_ext_execute(self, GET_ROCEE_BOND_CMD, hikp_roce_bond_get_data); ++} ++ ++static void cmd_roce_bond_init(void) ++{ ++ struct major_cmd_ctrl *major_cmd = get_major_cmd(); ++ ++ major_cmd->option_count = 0; ++ major_cmd->execute = hikp_roce_bond_execute; ++ ++ cmd_option_register("-h", "--help", false, hikp_roce_bond_help); ++ cmd_option_register("-i", "--interface", true, hikp_roce_bond_target); ++} ++ ++HIKP_CMD_DECLARE("roce_bond", "get roce_bond registers information", cmd_roce_bond_init); +diff --git a/net/roce/roce_bond/hikp_roce_bond.h b/net/roce/roce_bond/hikp_roce_bond.h +new file mode 100644 +index 0000000..14bd233 +--- /dev/null ++++ b/net/roce/roce_bond/hikp_roce_bond.h +@@ -0,0 +1,29 @@ ++/* ++ * 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_ROCE_BOND_H__ ++#define __HIKP_ROCE_BOND_H__ ++ ++#include "hikp_roce_ext_common.h" ++ ++struct cmd_roce_bond_param { ++ struct tool_target target; ++ uint32_t sub_cmd; ++}; ++ ++struct roce_bond_req_param { ++ struct bdf_t bdf; ++ uint32_t block_id; ++}; ++ ++#endif /* __HIKP_ROCE_BOND_H__ */ +diff --git a/net/roce/roce_ext_common/hikp_roce_ext_common.c b/net/roce/roce_ext_common/hikp_roce_ext_common.c +index 0ff07dc..d0fae69 100644 +--- a/net/roce/roce_ext_common/hikp_roce_ext_common.c ++++ b/net/roce/roce_ext_common/hikp_roce_ext_common.c +@@ -44,6 +44,7 @@ static const struct cmd_type_info { + {GET_ROCEE_TSP_CMD, "TSP", ROCE_HIKP_TSP_REG_NUM_EXT}, + {GET_ROCEE_RST_CMD, "RST", ROCE_HIKP_RST_REG_NUM}, + {GET_ROCEE_GLOBAL_CFG_CMD, "GLOBAL_CFG", ROCE_HIKP_GLOBAL_CFG_REG_NUM}, ++ {GET_ROCEE_BOND_CMD, "BOND", ROCE_HIKP_BOND_REG_NUM}, + }; + + static int get_cmd_info_table_idx(enum roce_cmd_type cmd_type) +diff --git a/net/roce/roce_ext_common/hikp_roce_ext_common.h b/net/roce/roce_ext_common/hikp_roce_ext_common.h +index 870a361..a600449 100644 +--- a/net/roce/roce_ext_common/hikp_roce_ext_common.h ++++ b/net/roce/roce_ext_common/hikp_roce_ext_common.h +@@ -29,6 +29,7 @@ + #define ROCE_HIKP_TSP_REG_NUM_EXT ROCE_MAX_REG_NUM + #define ROCE_HIKP_RST_REG_NUM ROCE_MAX_REG_NUM + #define ROCE_HIKP_GLOBAL_CFG_REG_NUM ROCE_MAX_REG_NUM ++#define ROCE_HIKP_BOND_REG_NUM ROCE_MAX_REG_NUM + + struct roce_ext_head { + uint8_t total_block_num; +-- +2.30.0 + diff --git a/0043-hikptool-roce-Add-ext-query-for-roce_caep-cmd.patch b/0043-hikptool-roce-Add-ext-query-for-roce_caep-cmd.patch new file mode 100644 index 0000000000000000000000000000000000000000..7ee6275c8ba0ec477de9b9eb180d3a00f5250aef --- /dev/null +++ b/0043-hikptool-roce-Add-ext-query-for-roce_caep-cmd.patch @@ -0,0 +1,174 @@ +From 80d9d76b7d5af23e58d13569bd1898604c8e2456 Mon Sep 17 00:00:00 2001 +From: Junxian Huang +Date: Tue, 1 Aug 2023 17:41:24 +0800 +Subject: hikptool/roce: Add ext query for roce_caep cmd + +Add ext query for roce_caep cmd. To query these ext registers, add +-e to the query cmd. + +Example: +hikptool roce_caep -i eth1 -e + +Signed-off-by: Junxian Huang +--- + net/roce/roce_caep/hikp_roce_caep.c | 69 +++++++++++++++++++---------- + net/roce/roce_caep/hikp_roce_caep.h | 11 +++++ + 2 files changed, 57 insertions(+), 23 deletions(-) + +diff --git a/net/roce/roce_caep/hikp_roce_caep.c b/net/roce/roce_caep/hikp_roce_caep.c +index 69a4742..6c92ea1 100644 +--- a/net/roce/roce_caep/hikp_roce_caep.c ++++ b/net/roce/roce_caep/hikp_roce_caep.c +@@ -22,6 +22,7 @@ static int hikp_roce_caep_help(struct major_cmd_ctrl *self, const char *argv) + printf(" Options:\n\n"); + printf(" %s, %-25s %s\n", "-h", "--help", "display this help and exit"); + printf(" %s, %-25s %s\n", "-i", "--interface=", "device target, e.g. eth0"); ++ printf(" %s, %-25s %s\n", "-e", "--extend", "query extend caep registers"); + printf("\n"); + + return 0; +@@ -31,7 +32,7 @@ static int hikp_roce_caep_target(struct major_cmd_ctrl *self, const char *argv) + { + self->err_no = tool_check_and_get_valid_bdf_id(argv, &(g_roce_caep_param_t.target)); + if (self->err_no != 0) { +- snprintf(self->err_str, sizeof(self->err_str), "Unknown device %s.", argv); ++ snprintf(self->err_str, sizeof(self->err_str), "Unknown device %s.\n", argv); + return self->err_no; + } + +@@ -39,18 +40,28 @@ static int hikp_roce_caep_target(struct major_cmd_ctrl *self, const char *argv) + } + + static int hikp_roce_caep_get_data(struct hikp_cmd_ret **cmd_ret, +- struct roce_caep_req_param req_data) ++ uint32_t block_id) + { ++ struct roce_caep_req_param_ext req_data_ext; + struct hikp_cmd_header req_header = { 0 }; ++ uint32_t req_size; ++ int ret; + +- hikp_cmd_init(&req_header, ROCE_MOD, GET_ROCEE_CAEP_CMD, 0); +- *cmd_ret = hikp_cmd_alloc(&req_header, &req_data, sizeof(req_data)); +- if (*cmd_ret == NULL) { +- printf("hikptool roce_caep cmd_ret malloc failed\n"); +- return -EIO; +- } +- +- return 0; ++ req_data_ext.origin_param.bdf = g_roce_caep_param_t.target.bdf; ++ req_data_ext.block_id = block_id; ++ ++ req_size = (g_roce_caep_param_t.sub_cmd == CAEP_ORIGIN) ? ++ sizeof(struct roce_caep_req_param) : ++ sizeof(struct roce_caep_req_param_ext); ++ hikp_cmd_init(&req_header, ROCE_MOD, GET_ROCEE_CAEP_CMD, ++ g_roce_caep_param_t.sub_cmd); ++ *cmd_ret = hikp_cmd_alloc(&req_header, &req_data_ext, req_size); ++ ret = hikp_rsp_normal_check(*cmd_ret); ++ if (ret) ++ printf("hikptool roce_caep cmd_ret malloc failed, sub_cmd = %u, ret = %d.\n", ++ g_roce_caep_param_t.sub_cmd, ret); ++ ++ return ret; + } + + static void hikp_roce_caep_print(uint32_t total_block_num, +@@ -64,29 +75,40 @@ static void hikp_roce_caep_print(uint32_t total_block_num, + printf("************************************\n"); + } + +-static void hikp_roce_caep_execute(struct major_cmd_ctrl *self) ++static void hikp_roce_caep_execute_origin(struct major_cmd_ctrl *self) + { + struct roce_caep_res_param *roce_caep_res; +- struct roce_caep_req_param req_data; + struct hikp_cmd_ret *cmd_ret; +- int ret; + +- req_data.bdf = g_roce_caep_param_t.target.bdf; +- ret = hikp_roce_caep_get_data(&cmd_ret, req_data); +- if (ret < 0) { +- self->err_no = ret; +- return; +- } else if (cmd_ret->status != 0) { +- printf("hikptool roce_caep read data failed\n"); ++ self->err_no = hikp_roce_caep_get_data(&cmd_ret, 0); ++ if (self->err_no) { ++ printf("hikptool roce_caep get data failed.\n"); + goto exec_error; + } + roce_caep_res = (struct roce_caep_res_param *)cmd_ret->rsp_data; + hikp_roce_caep_print(roce_caep_res->total_block_num, +- roce_caep_res->reg_data.offset, roce_caep_res->reg_data.data); ++ roce_caep_res->reg_data.offset, ++ roce_caep_res->reg_data.data); + + exec_error: +- free(cmd_ret); +- cmd_ret = NULL; ++ if (cmd_ret) ++ free(cmd_ret); ++} ++ ++static void hikp_roce_caep_execute(struct major_cmd_ctrl *self) ++{ ++ if (g_roce_caep_param_t.sub_cmd == CAEP_ORIGIN) ++ hikp_roce_caep_execute_origin(self); ++ else ++ hikp_roce_ext_execute(self, GET_ROCEE_CAEP_CMD, ++ hikp_roce_caep_get_data); ++} ++ ++static int hikp_roce_caep_ext_set(struct major_cmd_ctrl *self, const char *argv) ++{ ++ g_roce_caep_param_t.sub_cmd = CAEP_EXT; ++ ++ return 0; + } + + static void cmd_roce_caep_init(void) +@@ -98,6 +120,7 @@ static void cmd_roce_caep_init(void) + + cmd_option_register("-h", "--help", false, hikp_roce_caep_help); + cmd_option_register("-i", "--interface", true, hikp_roce_caep_target); ++ cmd_option_register("-e", "--extend", false, hikp_roce_caep_ext_set); + } + + HIKP_CMD_DECLARE("roce_caep", "get roce_caep registers information", cmd_roce_caep_init); +diff --git a/net/roce/roce_caep/hikp_roce_caep.h b/net/roce/roce_caep/hikp_roce_caep.h +index 804d2df..547a4d6 100644 +--- a/net/roce/roce_caep/hikp_roce_caep.h ++++ b/net/roce/roce_caep/hikp_roce_caep.h +@@ -21,12 +21,18 @@ + + struct cmd_roce_caep_param_t { + struct tool_target target; ++ uint32_t sub_cmd; + }; + + struct roce_caep_req_param { + struct bdf_t bdf; + }; + ++struct roce_caep_req_param_ext { ++ struct roce_caep_req_param origin_param; ++ uint32_t block_id; ++}; ++ + struct roce_caep_res { + uint32_t offset[ROCE_HIKP_CAEP_REG_NUM]; + uint32_t data[ROCE_HIKP_CAEP_REG_NUM]; +@@ -37,4 +43,9 @@ struct roce_caep_res_param { + struct roce_caep_res reg_data; + }; + ++enum roce_caep_cmd_type { ++ CAEP_ORIGIN = 0, ++ CAEP_EXT, ++}; ++ + #endif /* __HIKP_ROCE_CAEP_H__ */ +-- +2.30.0 + diff --git a/0044-hikptool-roce-Add-ext-query-for-roce_mdb-cmd.patch b/0044-hikptool-roce-Add-ext-query-for-roce_mdb-cmd.patch new file mode 100644 index 0000000000000000000000000000000000000000..e167f36de9ea7b8c67e2b43182bd41665daa7ac3 --- /dev/null +++ b/0044-hikptool-roce-Add-ext-query-for-roce_mdb-cmd.patch @@ -0,0 +1,210 @@ +From b949611a7a302743916155adee01db0c73c0f8e7 Mon Sep 17 00:00:00 2001 +From: Junxian Huang +Date: Fri, 4 Aug 2023 17:25:23 +0800 +Subject: hikptool/roce: Add ext query for roce_mdb cmd + +Add ext query for roce_mdb cmd. To query these ext registers, add +-e to the query cmd. + +Example: +hikptool roce_mdb -i eth1 -e + +Signed-off-by: Junxian Huang +--- + net/roce/roce_mdb/hikp_roce_mdb.c | 83 ++++++++++++++++++++----------- + net/roce/roce_mdb/hikp_roce_mdb.h | 13 ++++- + 2 files changed, 67 insertions(+), 29 deletions(-) + +diff --git a/net/roce/roce_mdb/hikp_roce_mdb.c b/net/roce/roce_mdb/hikp_roce_mdb.c +index 9cc07a1..04af817 100644 +--- a/net/roce/roce_mdb/hikp_roce_mdb.c ++++ b/net/roce/roce_mdb/hikp_roce_mdb.c +@@ -14,7 +14,6 @@ + #include + #include "hikp_roce_mdb.h" + +-#define ROCE_MDB_CMD_CLEAR HI_BIT(0) + static struct cmd_roce_mdb_param g_roce_mdb_param = { 0 }; + + static int hikp_roce_mdb_help(struct major_cmd_ctrl *self, const char *argv) +@@ -25,6 +24,7 @@ static int hikp_roce_mdb_help(struct major_cmd_ctrl *self, const char *argv) + printf(" %s, %-25s %s\n", "-h", "--help", "display this help and exit"); + printf(" %s, %-25s %s\n", "-i", "--interface=", "device target, e.g. eth0"); + printf(" %s, %-25s %s\n", "-c", "--clear=", "clear mdb registers"); ++ printf(" %s, %-25s %s\n", "-e", "--extend", "query extend mdb registers"); + printf("\n"); + + return 0; +@@ -34,7 +34,7 @@ static int hikp_roce_mdb_target(struct major_cmd_ctrl *self, const char *argv) + { + self->err_no = tool_check_and_get_valid_bdf_id(argv, &(g_roce_mdb_param.target)); + if (self->err_no) { +- snprintf(self->err_str, sizeof(self->err_str), "Unknown device %s.", argv); ++ snprintf(self->err_str, sizeof(self->err_str), "Unknown device %s.\n", argv); + return self->err_no; + } + +@@ -43,7 +43,8 @@ static int hikp_roce_mdb_target(struct major_cmd_ctrl *self, const char *argv) + + static int hikp_roce_mdb_clear_set(struct major_cmd_ctrl *self, const char *argv) + { +- g_roce_mdb_param.reset_flag = ROCE_MDB_CMD_CLEAR; ++ g_roce_mdb_param.flag |= ROCE_MDB_CMD_CLEAR; ++ + return 0; + } + +@@ -58,53 +59,78 @@ static void hikp_roce_mdb_print(uint32_t reg_num, struct roce_mdb_rsp_data *mdb_ + printf("***********************************\n"); + } + +-static int hikp_roce_mdb_show(struct major_cmd_ctrl *self) ++static int hikp_roce_mdb_get_data(struct hikp_cmd_ret **cmd_ret, ++ uint32_t block_id) + { +- struct roce_mdb_req_para req_data = { 0 }; +- struct roce_mdb_rsp_data *mdb_rsp = NULL; ++ struct roce_mdb_req_param_ext req_data_ext; + struct hikp_cmd_header req_header = { 0 }; ++ uint32_t req_size; ++ int ret; ++ ++ req_data_ext.origin_param.bdf = g_roce_mdb_param.target.bdf; ++ req_data_ext.block_id = block_id; ++ ++ req_size = (g_roce_mdb_param.flag & ROCE_MDB_CMD_EXT) ? ++ sizeof(struct roce_mdb_req_param_ext) : ++ sizeof(struct roce_mdb_req_para); ++ hikp_cmd_init(&req_header, ROCE_MOD, GET_ROCEE_MDB_CMD, ++ g_roce_mdb_param.sub_cmd); ++ *cmd_ret = hikp_cmd_alloc(&req_header, &req_data_ext, req_size); ++ ret = hikp_rsp_normal_check(*cmd_ret); ++ if (ret) ++ printf("hikptool roce_mdb cmd_ret malloc failed, sub_cmd = %u, ret = %d.\n", ++ g_roce_mdb_param.sub_cmd, ret); ++ ++ return ret; ++} ++ ++static void hikp_roce_mdb_execute_origin(struct major_cmd_ctrl *self) ++{ ++ struct roce_mdb_rsp_data *mdb_rsp = NULL; + struct hikp_cmd_ret *cmd_ret = NULL; + uint32_t reg_num; + int ret; + +- req_data.bdf = g_roce_mdb_param.target.bdf; +- if (g_roce_mdb_param.reset_flag) +- hikp_cmd_init(&req_header, ROCE_MOD, GET_ROCEE_MDB_CMD, MDB_CLEAR); +- else +- hikp_cmd_init(&req_header, ROCE_MOD, GET_ROCEE_MDB_CMD, MDB_SHOW); +- +- cmd_ret = hikp_cmd_alloc(&req_header, &req_data, sizeof(req_data)); +- ret = hikp_rsp_normal_check(cmd_ret); +- if (ret != 0) ++ self->err_no = hikp_roce_mdb_get_data(&cmd_ret, 0); ++ if (self->err_no) { ++ printf("hikptool roce_mdb get data failed\n"); + goto exec_error; ++ } + + reg_num = cmd_ret->rsp_data_num / ROCE_HIKP_REG_SWICTH; + if (reg_num != ROCE_HIKP_MDB_REG_NUM) { + printf("version might not match.\n"); +- ret = -1; ++ self->err_no = -EPROTO; + goto exec_error; + } + + mdb_rsp = (struct roce_mdb_rsp_data *)(cmd_ret->rsp_data); + hikp_roce_mdb_print(reg_num, mdb_rsp); +- ret = 0; + + exec_error: +- free(cmd_ret); +- cmd_ret = NULL; +- return ret; ++ if (cmd_ret) ++ free(cmd_ret); + } + + static void hikp_roce_mdb_execute(struct major_cmd_ctrl *self) + { +- self->err_no = hikp_roce_mdb_show(self); +- if (self->err_no) +- return; +- +- if (g_roce_mdb_param.reset_flag) +- printf("clear roce_mdb reg success.\n"); +- else +- printf("show roce_mdb reg success.\n"); ++ if (g_roce_mdb_param.flag & ROCE_MDB_CMD_EXT) { ++ g_roce_mdb_param.sub_cmd = (g_roce_mdb_param.flag & ROCE_MDB_CMD_CLEAR) ? ++ MDB_CLEAR_EXT : MDB_EXT; ++ hikp_roce_ext_execute(self, GET_ROCEE_MDB_CMD, ++ hikp_roce_mdb_get_data); ++ } else { ++ g_roce_mdb_param.sub_cmd = (g_roce_mdb_param.flag & ROCE_MDB_CMD_CLEAR) ? ++ MDB_CLEAR : MDB_SHOW; ++ hikp_roce_mdb_execute_origin(self); ++ } ++} ++ ++static int hikp_roce_mdb_ext_set(struct major_cmd_ctrl *self, const char *argv) ++{ ++ g_roce_mdb_param.flag |= ROCE_MDB_CMD_EXT; ++ ++ return 0; + } + + static void cmd_roce_mdb_init(void) +@@ -117,6 +143,7 @@ static void cmd_roce_mdb_init(void) + cmd_option_register("-h", "--help", false, hikp_roce_mdb_help); + cmd_option_register("-i", "--interface", true, hikp_roce_mdb_target); + cmd_option_register("-c", "--clear", false, hikp_roce_mdb_clear_set); ++ cmd_option_register("-e", "--extend", false, hikp_roce_mdb_ext_set); + } + + HIKP_CMD_DECLARE("roce_mdb", "get or clear roce_mdb registers information", cmd_roce_mdb_init); +diff --git a/net/roce/roce_mdb/hikp_roce_mdb.h b/net/roce/roce_mdb/hikp_roce_mdb.h +index 7643dff..26fc549 100644 +--- a/net/roce/roce_mdb/hikp_roce_mdb.h ++++ b/net/roce/roce_mdb/hikp_roce_mdb.h +@@ -19,15 +19,24 @@ + #define ROCE_HIKP_MDB_REG_NUM 22 + #define ROCE_HIKP_REG_SWICTH 2 + ++#define ROCE_MDB_CMD_CLEAR (1 << 0) ++#define ROCE_MDB_CMD_EXT (1 << 1) ++ + struct cmd_roce_mdb_param { + struct tool_target target; +- int reset_flag; ++ uint32_t sub_cmd; ++ uint8_t flag; + }; + + struct roce_mdb_req_para { + struct bdf_t bdf; + }; + ++struct roce_mdb_req_param_ext { ++ struct roce_mdb_req_para origin_param; ++ uint32_t block_id; ++}; ++ + struct roce_mdb_rsp_data { + uint32_t reg_offset[ROCE_HIKP_MDB_REG_NUM]; + uint32_t reg_data[ROCE_HIKP_MDB_REG_NUM]; +@@ -36,6 +45,8 @@ struct roce_mdb_rsp_data { + enum roce_mdb_cmd_type { + MDB_SHOW = 0x0, + MDB_CLEAR, ++ MDB_EXT, ++ MDB_CLEAR_EXT, + }; + + #endif /* __HIKP_ROCE_MDB_H__ */ +-- +2.30.0 + diff --git a/0045-hikptool-roce-Add-ext-query-for-roce_qmm-cmd.patch b/0045-hikptool-roce-Add-ext-query-for-roce_qmm-cmd.patch new file mode 100644 index 0000000000000000000000000000000000000000..29a344a419475ad0ef7baf7c2b7094fa5c38ad47 --- /dev/null +++ b/0045-hikptool-roce-Add-ext-query-for-roce_qmm-cmd.patch @@ -0,0 +1,252 @@ +From 87f8605c32d308938df17b29816720ca97b0a23f Mon Sep 17 00:00:00 2001 +From: Junxian Huang +Date: Sat, 26 Aug 2023 15:05:53 +0800 +Subject: hikptool/roce: Add ext query for roce_qmm cmd + +Add ext query for roce_qmm cmd. To query these ext registers, add +-e to the query cmd. + +Example: +hikptool roce_qmm -i eth1 -e + +Signed-off-by: Junxian Huang +--- + net/roce/roce_qmm/hikp_roce_qmm.c | 137 ++++++++++++++---------------- + net/roce/roce_qmm/hikp_roce_qmm.h | 11 +++ + 2 files changed, 75 insertions(+), 73 deletions(-) + +diff --git a/net/roce/roce_qmm/hikp_roce_qmm.c b/net/roce/roce_qmm/hikp_roce_qmm.c +index c7e0ca4..b020c6a 100644 +--- a/net/roce/roce_qmm/hikp_roce_qmm.c ++++ b/net/roce/roce_qmm/hikp_roce_qmm.c +@@ -25,6 +25,7 @@ static int hikp_roce_qmm_help(struct major_cmd_ctrl *self, const char *argv) + printf(" %s, %-25s %s\n", "-i", "--interface=", "device target, e.g. eth0"); + printf(" %s, %-25s %s\n", "-b", "--bank=", + "[option]bank number, e.g. 0~7. (default 0)"); ++ printf(" %s, %-25s %s\n", "-e", "--extend", "query extend qmm registers"); + printf("\n"); + + return 0; +@@ -34,7 +35,7 @@ static int hikp_roce_qmm_target(struct major_cmd_ctrl *self, const char *argv) + { + self->err_no = tool_check_and_get_valid_bdf_id(argv, &(g_roce_qmm_param.target)); + if (self->err_no != 0) { +- snprintf(self->err_str, sizeof(self->err_str), "Unknown device %s.", argv); ++ snprintf(self->err_str, sizeof(self->err_str), "Unknown device %s.\n", argv); + return self->err_no; + } + +@@ -61,6 +62,8 @@ static void hikp_roce_qmm_print(struct roce_qmm_rsp_data *qmm_rsp) + { + int index = 0; + ++ printf("**************QMM %s INFO*************\n", ++ g_roce_qmm_param.sub_name); + while (index < qmm_rsp->reg_num) { + printf("0x%08X : 0x%08X\n", qmm_rsp->qmm_content[index][0], + qmm_rsp->qmm_content[index][1]); +@@ -69,101 +72,88 @@ static void hikp_roce_qmm_print(struct roce_qmm_rsp_data *qmm_rsp) + printf("***************************************\n"); + } + +-static int hikp_roce_qmm_show_cqc(struct major_cmd_ctrl *self) ++static int hikp_roce_qmm_get_data(struct hikp_cmd_ret **cmd_ret, ++ uint32_t block_id) + { +- struct roce_qmm_req_para req_data = { 0 }; +- struct roce_qmm_rsp_data *qmm_rsp = NULL; ++ struct roce_qmm_req_para_ext req_data_ext; + struct hikp_cmd_header req_header = { 0 }; +- struct hikp_cmd_ret *cmd_ret = NULL; ++ uint32_t req_size; + int ret; + +- req_data.bdf = g_roce_qmm_param.target.bdf; ++ req_data_ext.origin_param.bdf = g_roce_qmm_param.target.bdf; ++ req_data_ext.origin_param.bank_id = g_roce_qmm_param.bank_id; ++ req_data_ext.block_id = block_id; ++ ++ req_size = g_roce_qmm_param.ext_flag ? ++ sizeof(struct roce_qmm_req_para) : ++ sizeof(struct roce_qmm_req_para_ext); ++ hikp_cmd_init(&req_header, ROCE_MOD, GET_ROCEE_QMM_CMD, ++ g_roce_qmm_param.sub_cmd); ++ *cmd_ret = hikp_cmd_alloc(&req_header, &req_data_ext, req_size); ++ ret = hikp_rsp_normal_check(*cmd_ret); ++ if (ret) ++ printf("hikptool roce_qmm cmd_ret malloc failed, sub_cmd = %u, ret = %d.\n", ++ g_roce_qmm_param.sub_cmd, ret); + +- hikp_cmd_init(&req_header, ROCE_MOD, GET_ROCEE_QMM_CMD, QMM_SHOW_CQC); +- cmd_ret = hikp_cmd_alloc(&req_header, &req_data, sizeof(req_data)); +- ret = hikp_rsp_normal_check(cmd_ret); +- if (ret != 0) +- goto out; +- +- qmm_rsp = (struct roce_qmm_rsp_data *)(cmd_ret->rsp_data); +- printf("**************QMM CQC INFO*************\n"); +- hikp_roce_qmm_print(qmm_rsp); +-out: +- free(cmd_ret); +- cmd_ret = NULL; +- return ret; +-} +- +-static int hikp_roce_qmm_show_qpc(struct major_cmd_ctrl *self) +-{ +- struct roce_qmm_req_para req_data = { 0 }; +- struct roce_qmm_rsp_data *qmm_rsp = NULL; +- struct hikp_cmd_header req_header = { 0 }; +- struct hikp_cmd_ret *cmd_ret = NULL; +- int ret; +- +- req_data.bdf = g_roce_qmm_param.target.bdf; +- req_data.bank_id = g_roce_qmm_param.bank_id; +- +- hikp_cmd_init(&req_header, ROCE_MOD, GET_ROCEE_QMM_CMD, QMM_SHOW_QPC); +- cmd_ret = hikp_cmd_alloc(&req_header, &req_data, sizeof(req_data)); +- ret = hikp_rsp_normal_check(cmd_ret); +- if (ret != 0) +- goto out; +- +- qmm_rsp = (struct roce_qmm_rsp_data *)(cmd_ret->rsp_data); +- printf("**************QMM QPC INFO*************\n"); +- hikp_roce_qmm_print(qmm_rsp); +-out: +- free(cmd_ret); +- cmd_ret = NULL; + return ret; + } + +-static int hikp_roce_qmm_show_top(struct major_cmd_ctrl *self) ++static void hikp_roce_qmm_execute_origin(struct major_cmd_ctrl *self) + { +- struct roce_qmm_req_para req_data = { 0 }; +- struct roce_qmm_rsp_data *qmm_rsp = NULL; +- struct hikp_cmd_header req_header = { 0 }; +- struct hikp_cmd_ret *cmd_ret = NULL; +- int ret; ++ struct roce_qmm_rsp_data *roce_qmm_res; ++ struct hikp_cmd_ret *cmd_ret; + +- req_data.bdf = g_roce_qmm_param.target.bdf; +- +- hikp_cmd_init(&req_header, ROCE_MOD, GET_ROCEE_QMM_CMD, QMM_SHOW_TOP); +- cmd_ret = hikp_cmd_alloc(&req_header, &req_data, sizeof(req_data)); +- ret = hikp_rsp_normal_check(cmd_ret); +- if (ret != 0) +- goto out; ++ self->err_no = hikp_roce_qmm_get_data(&cmd_ret, 0); ++ if (self->err_no) { ++ printf("hikptool roce_qmm get data failed.\n"); ++ goto exec_error; ++ } ++ roce_qmm_res = (struct roce_qmm_rsp_data *)cmd_ret->rsp_data; ++ hikp_roce_qmm_print(roce_qmm_res); + +- qmm_rsp = (struct roce_qmm_rsp_data *)(cmd_ret->rsp_data); +- printf("**************QMM TOP INFO*************\n"); +- hikp_roce_qmm_print(qmm_rsp); +-out: +- free(cmd_ret); +- cmd_ret = NULL; +- return ret; ++exec_error: ++ if (cmd_ret) ++ free(cmd_ret); + } + + static void hikp_roce_qmm_execute(struct major_cmd_ctrl *self) + { +- int (*func[])(struct major_cmd_ctrl *self) = { +- hikp_roce_qmm_show_cqc, hikp_roce_qmm_show_qpc, hikp_roce_qmm_show_top ++ const struct cmd_type_info { ++ enum roce_qmm_cmd_type sub_cmd; ++ enum roce_qmm_cmd_type sub_ext_cmd; ++ const char *sub_name; ++ } sub_cmd_info_table[] = { ++ {QMM_SHOW_CQC, QMM_SHOW_CQC_EXT, "CQC"}, ++ {QMM_SHOW_QPC, QMM_SHOW_QPC_EXT, "QPC"}, ++ {QMM_SHOW_TOP, QMM_SHOW_TOP_EXT, "TOP"}, + }; +- char *function[] = {"show cqc", "show qpc", "show top"}; +- int ret; + +- for (int i = 0; i < HIKP_ARRAY_SIZE(func); i++) { +- ret = func[i](self); +- if (ret != 0) { +- self->err_no = -EINVAL; ++ for (int i = 0; i < HIKP_ARRAY_SIZE(sub_cmd_info_table); i++) { ++ g_roce_qmm_param.sub_name = sub_cmd_info_table[i].sub_name; ++ if (g_roce_qmm_param.ext_flag) { ++ g_roce_qmm_param.sub_cmd = sub_cmd_info_table[i].sub_ext_cmd; ++ hikp_roce_ext_execute(self, GET_ROCEE_QMM_CMD, ++ hikp_roce_qmm_get_data); ++ } else { ++ g_roce_qmm_param.sub_cmd = sub_cmd_info_table[i].sub_cmd; ++ hikp_roce_qmm_execute_origin(self); ++ } ++ if (self->err_no) { + snprintf(self->err_str, sizeof(self->err_str), +- "roce_qmm %s function failed\n", function[i]); ++ "roce_qmm show %s function failed\n", ++ sub_cmd_info_table[i].sub_name); + break; + } + } + } + ++static int hikp_roce_qmm_ext_set(struct major_cmd_ctrl *self, const char *argv) ++{ ++ g_roce_qmm_param.ext_flag = true; ++ ++ return 0; ++} ++ + static void cmd_roce_qmm_init(void) + { + struct major_cmd_ctrl *major_cmd = get_major_cmd(); +@@ -174,6 +164,7 @@ static void cmd_roce_qmm_init(void) + cmd_option_register("-h", "--help", false, hikp_roce_qmm_help); + cmd_option_register("-i", "--interface", true, hikp_roce_qmm_target); + cmd_option_register("-b", "--bank", true, hikp_roce_qmm_bank_get); ++ cmd_option_register("-e", "--extend", false, hikp_roce_qmm_ext_set); + } + + HIKP_CMD_DECLARE("roce_qmm", "get roce_qmm registers information", cmd_roce_qmm_init); +diff --git a/net/roce/roce_qmm/hikp_roce_qmm.h b/net/roce/roce_qmm/hikp_roce_qmm.h +index 0645ab3..06e6bcf 100644 +--- a/net/roce/roce_qmm/hikp_roce_qmm.h ++++ b/net/roce/roce_qmm/hikp_roce_qmm.h +@@ -22,6 +22,9 @@ + struct cmd_roce_qmm_param_t { + struct tool_target target; + uint32_t bank_id; ++ uint32_t sub_cmd; ++ const char *sub_name; ++ bool ext_flag; + }; + + struct roce_qmm_rsp_data { +@@ -34,10 +37,18 @@ struct roce_qmm_req_para { + uint32_t bank_id; + }; + ++struct roce_qmm_req_para_ext { ++ struct roce_qmm_req_para origin_param; ++ uint32_t block_id; ++}; ++ + enum roce_qmm_cmd_type { + QMM_SHOW_CQC = 0x1, + QMM_SHOW_QPC = 0x2, + QMM_SHOW_TOP = 0x3, ++ QMM_SHOW_CQC_EXT, ++ QMM_SHOW_QPC_EXT, ++ QMM_SHOW_TOP_EXT, + }; + + #endif /* __HIKP_ROCE_QMM_H__ */ +-- +2.30.0 + diff --git a/0046-hikptool-Querying-the-SerDes-Relationship-of-the-PCI.patch b/0046-hikptool-Querying-the-SerDes-Relationship-of-the-PCI.patch new file mode 100644 index 0000000000000000000000000000000000000000..6646cc54a5383e84412908dd29ca105874fe2140 --- /dev/null +++ b/0046-hikptool-Querying-the-SerDes-Relationship-of-the-PCI.patch @@ -0,0 +1,100 @@ +From 6747635a4423fc0844230bc66112853856b9fe97 Mon Sep 17 00:00:00 2001 +From: mou bingquan +Date: Wed, 18 Oct 2023 09:52:39 +0800 +Subject: [PATCH] hikptool : Querying the SerDes Relationship of the PCIe + +This function is used to query the macro corresponding to the +port of the PCIe. It is a type of SerDes multiplexing relationship. +--- + pcie/func_lib/pcie_func/pcie_statistics.c | 30 +++++++++++++++++++++++ + pcie/func_lib/pcie_func/pcie_statistics.h | 10 ++++++++ + 2 files changed, 40 insertions(+) + +diff --git a/pcie/func_lib/pcie_func/pcie_statistics.c b/pcie/func_lib/pcie_func/pcie_statistics.c +index 308a142..128e7f7 100644 +--- a/pcie/func_lib/pcie_func/pcie_statistics.c ++++ b/pcie/func_lib/pcie_func/pcie_statistics.c +@@ -25,6 +25,10 @@ static const char *g_global_width_name[GLOBAL_WIDTH_TABLE_SIZE] = { + "PCIE_WIDTH_X1", "PCIE_WIDTH_X2", "PCIE_WIDTH_X4", "PCIE_WIDTH_X8", "PCIE_WIDTH_X16" + }; + ++static const char *g_global_ndie_name[] = { ++ "Ndie_A", "Ndie_B" ++}; ++ + static int port_distribution_rsp_data_check(const struct hikp_cmd_ret *cmd_ret, uint32_t *port_num) + { + size_t rsp_data_size, expect_data_size; +@@ -58,6 +62,29 @@ static int port_distribution_rsp_data_check(const struct hikp_cmd_ret *cmd_ret, + return 0; + } + ++static int pcie_portid_serdes_relation(const struct pcie_macro_info *macro_info, ++ uint32_t macro_num, uint32_t ndie_id) ++{ ++ uint32_t i, j; ++ ++ if (ndie_id >= HIKP_ARRAY_SIZE(g_global_ndie_name)) { ++ Info("PCIe Base", "ndie_id [%u]: %s\n", ndie_id, "UNKNOWN_NDIE"); ++ return -1; ++ } ++ ++ if (macro_num >= MAX_MACRO_ONEPORT) { ++ Info("PCIe Base", "macro_num [%u] exceeds the maximum array length\n", macro_num); ++ return -1; ++ } ++ ++ Info("PCIe Base", "\tndie_id: %s\n", g_global_ndie_name[ndie_id]); ++ for (i = 0; i < macro_num; i++) { ++ for (j = macro_info[i].lane_s; j <= macro_info[i].lane_e; j++) ++ Info("PCIe Base", "\t\tmacro %d \t lane: %d\n", macro_info[i].id, j); ++ } ++ return 0; ++} ++ + int pcie_port_distribution_get(uint32_t chip_id) + { + struct hikp_cmd_header req_header; +@@ -86,6 +113,9 @@ int pcie_port_distribution_get(uint32_t chip_id) + } + Info("PCIe Base", "port_id[%u] %s\n", port_info->info_pair[i].port_id, + g_global_width_name[port_info->info_pair[i].port_width]); ++ pcie_portid_serdes_relation(port_info->info_pair[i].macro_info, ++ port_info->info_pair[i].macro_num, ++ port_info->info_pair[i].ndie_id); + } + free_cmd_ret: + free(cmd_ret); +diff --git a/pcie/func_lib/pcie_func/pcie_statistics.h b/pcie/func_lib/pcie_func/pcie_statistics.h +index 2a3cc66..3e3916b 100644 +--- a/pcie/func_lib/pcie_func/pcie_statistics.h ++++ b/pcie/func_lib/pcie_func/pcie_statistics.h +@@ -17,6 +17,7 @@ + #include "pcie_common_api.h" + + #define GLOBAL_WIDTH_TABLE_SIZE 5 ++#define MAX_MACRO_ONEPORT 3 + + union mac_test_cnt { + /* Define the struct bits */ +@@ -88,9 +89,18 @@ union dfx_dcrc_err_num { + unsigned int u32; + }; + ++struct pcie_macro_info { ++ uint32_t id; ++ uint32_t lane_s; ++ uint32_t lane_e; ++}; ++ + struct pcie_info_distribution_pair { + uint32_t port_id; + uint32_t port_width; ++ uint32_t ndie_id; ++ uint32_t macro_num; ++ struct pcie_macro_info macro_info[MAX_MACRO_ONEPORT]; + }; + + struct pcie_port_info { +-- +2.33.0 diff --git a/0047-hikptool-Remove-the-function-of-querying-SAS-device-.patch b/0047-hikptool-Remove-the-function-of-querying-SAS-device-.patch new file mode 100644 index 0000000000000000000000000000000000000000..b4af52f61aa494b156ff93a3297e1c8f86cd845b --- /dev/null +++ b/0047-hikptool-Remove-the-function-of-querying-SAS-device-.patch @@ -0,0 +1,177 @@ +From ba80a0dd531a4eebccb1852a65b4b7272a02c06d Mon Sep 17 00:00:00 2001 +From: Yihang Li +Date: Tue, 17 Oct 2023 18:58:27 +0800 +Subject: [PATCH] hikptool: Remove the function of querying SAS device + configurations + +Currently, SAS device information cannot be obtained. +Remove the function of querying SAS device configurations + +Signed-off-by: Yihang Li +--- + sas/sas_func/sas_common.h | 2 -- + sas/sas_func/sas_read_dev.c | 21 --------------------- + sas/user_cmd/cmd_code/sas_cmd_common.c | 10 ---------- + sas/user_cmd/cmd_code/sas_cmd_dev.c | 17 ----------------- + sas/user_cmd/cmd_code/sas_tools_include.h | 2 -- + 5 files changed, 52 deletions(-) + +diff --git a/sas/sas_func/sas_common.h b/sas/sas_func/sas_common.h +index 9464792..1bace0c 100644 +--- a/sas/sas_func/sas_common.h ++++ b/sas/sas_func/sas_common.h +@@ -22,7 +22,6 @@ + #define IPTT_ICT_STATUS 29 + #define LINK_SPEED_OFFSET 8 + #define LINK_SPEED_WIDTH 4 +-#define MAX_DEVICE_NUM 2048 + + #define DWS_LOST 0 + #define RESET_PROB 1 +@@ -73,7 +72,6 @@ enum sas_errcode_cmd_type { + + enum sas_dev_cmd_type { + DEV_LINK, +- DEV_INFO, + DEV_UNKNOWN_TYPE, + }; + +diff --git a/sas/sas_func/sas_read_dev.c b/sas/sas_func/sas_read_dev.c +index 8b9b58d..3a3db07 100644 +--- a/sas/sas_func/sas_read_dev.c ++++ b/sas/sas_func/sas_read_dev.c +@@ -76,24 +76,6 @@ static void print_dev_link(const uint32_t *reg_save, uint32_t reg_num) + } + } + +-static void print_dev_info(const void *reg_save, uint32_t reg_num) +-{ +- volatile struct hikp_sas_itct *itct = (volatile struct hikp_sas_itct *)reg_save; +- +- printf("The device information as below:\n"); +- printf("dev_type: %d\n", itct->dw0.dev_type); +- printf("dev_valid: %d\n", itct->dw0.dev_valid); +- printf("break_reply_en: %d\n", itct->dw0.break_reply_en); +- printf("smp_timeout: %d\n", itct->dw0.smp_timeout); +- printf("tlr_en: %d\n", itct->dw0.tlr_en); +- printf("awt_continue: %d\n", itct->dw0.awt_continue); +- printf("sas_addr: 0x%llx\n", itct->sas_addr); +- printf("I_T_nexus_loss: %d\n", itct->dw2.I_T_nexus_loss); +- printf("awt_initial_value: %d\n", itct->dw2.awt_initial_value); +- printf("maximum_connect_time: %d\n", itct->dw2.maximum_connect_time); +- printf("reject_to_open_limit: %d\n", itct->dw2.reject_to_open_limit); +-} +- + static void sas_print_dev(const uint32_t *reg_save, uint32_t reg_num, uint32_t cmd_type) + { + uint32_t i; +@@ -106,9 +88,6 @@ static void sas_print_dev(const uint32_t *reg_save, uint32_t reg_num, uint32_t c + case DEV_LINK: + print_dev_link(reg_save, reg_num); + break; +- case DEV_INFO: +- print_dev_info(reg_save, reg_num); +- break; + default: + printf("cmd_type is error\n"); + } +diff --git a/sas/user_cmd/cmd_code/sas_cmd_common.c b/sas/user_cmd/cmd_code/sas_cmd_common.c +index 9dca63f..358cf39 100644 +--- a/sas/user_cmd/cmd_code/sas_cmd_common.c ++++ b/sas/user_cmd/cmd_code/sas_cmd_common.c +@@ -54,11 +54,6 @@ int sas_get_phy_id(void) + return g_sas_cmd.phy_id; + } + +-int sas_get_dev_id(void) +-{ +- return g_sas_cmd.dev_id; +-} +- + int sas_get_que_id(void) + { + return g_sas_cmd.que_id; +@@ -84,11 +79,6 @@ int sas_set_die_id(struct major_cmd_ctrl *self, const char *argv) + return sas_set_id(self, argv, &g_sas_cmd.die_id); + } + +-int sas_set_dev_id(struct major_cmd_ctrl *self, const char *argv) +-{ +- return sas_set_id(self, argv, &g_sas_cmd.dev_id); +-} +- + int sas_set_que_id(struct major_cmd_ctrl *self, const char *argv) + { + return sas_set_id(self, argv, &g_sas_cmd.que_id); +diff --git a/sas/user_cmd/cmd_code/sas_cmd_dev.c b/sas/user_cmd/cmd_code/sas_cmd_dev.c +index c95006b..6a5eae0 100644 +--- a/sas/user_cmd/cmd_code/sas_cmd_dev.c ++++ b/sas/user_cmd/cmd_code/sas_cmd_dev.c +@@ -26,7 +26,6 @@ static int sas_dev_help(struct major_cmd_ctrl *self, const char *argv) + printf("\n Options:\n\n"); + printf(" %s, %-25s %s\n", "-h", "--help", "display this help and exit\n"); + printf(" %s, %-25s %s\n", "-l", "--link", "dispaly device type and speed\n"); +- printf(" %s, %-25s %s\n", "-i", "--info", "dispaly the device detail information\n"); + printf("\n"); + + return 0; +@@ -37,19 +36,6 @@ static int sas_dev_link(struct major_cmd_ctrl *self, const char *argv) + return sas_set_cmd_type(DEV_LINK); + } + +-static int sas_dev_info(struct major_cmd_ctrl *self, const char *argv) +-{ +- int ret; +- +- (void)sas_set_cmd_type(DEV_INFO); +- ret = sas_set_dev_id(self, argv); +- if (ret || sas_get_dev_id() >= MAX_DEVICE_NUM) { +- printf("device id is too large(>=%d)\n", MAX_DEVICE_NUM); +- return -EINVAL; +- } +- return ret; +-} +- + static int sas_dev_excute_funs_call(uint32_t cmd_type) + { + if (cmd_type != SAS_UNKNOW_CMD) +@@ -63,11 +49,9 @@ static void sas_dev_execute(struct major_cmd_ctrl *self) + int ret, cmd; + const char *suc_msg[] = { + "sas_dev_link success.", +- "sas_dev_info success.", + }; + const char *err_msg[] = { + "sas_dev_link error.", +- "sas_dev_info error.", + "sas_dev failed, unknown type", + }; + +@@ -95,7 +79,6 @@ static void cmd_sas_dev_init(void) + cmd_option_register("-d", "--dieid", true, sas_set_die_id); + cmd_option_register("-h", "--help", false, sas_dev_help); + cmd_option_register("-l", "--link", false, sas_dev_link); +- cmd_option_register("-i", "--info", true, sas_dev_info); + } + + HIKP_CMD_DECLARE("sas_dev", "sas device information ", cmd_sas_dev_init); +diff --git a/sas/user_cmd/cmd_code/sas_tools_include.h b/sas/user_cmd/cmd_code/sas_tools_include.h +index a71e614..0aa7703 100644 +--- a/sas/user_cmd/cmd_code/sas_tools_include.h ++++ b/sas/user_cmd/cmd_code/sas_tools_include.h +@@ -34,13 +34,11 @@ struct tool_sas_cmd { + int sas_set_cmd_type(int cmd_type); + int sas_get_cmd_type(void); + int sas_get_phy_id(void); +-int sas_get_dev_id(void); + int sas_get_que_id(void); + struct tool_sas_cmd *sas_get_cmd_p(void); + int sas_set_chip_id(struct major_cmd_ctrl *self, const char *argv); + int sas_set_phy_id(struct major_cmd_ctrl *self, const char *argv); + int sas_set_die_id(struct major_cmd_ctrl *self, const char *argv); +-int sas_set_dev_id(struct major_cmd_ctrl *self, const char *argv); + int sas_set_que_id(struct major_cmd_ctrl *self, const char *argv); + int sas_set_dqe_id(struct major_cmd_ctrl *self, const char *argv); + +-- +2.33.0 diff --git a/0048-hikptool-roce-Use-calloc-to-alloc-memory-for-array-i.patch b/0048-hikptool-roce-Use-calloc-to-alloc-memory-for-array-i.patch new file mode 100644 index 0000000000000000000000000000000000000000..9ddbce8f88ee1affeb0782ad8936147b13a2f025 --- /dev/null +++ b/0048-hikptool-roce-Use-calloc-to-alloc-memory-for-array-i.patch @@ -0,0 +1,31 @@ +From 2abbc6020498b1c464775623de8b2db76e684d55 Mon Sep 17 00:00:00 2001 +From: Junxian Huang +Date: Tue, 24 Oct 2023 11:16:49 +0800 +Subject: hikptool/roce: Use calloc to alloc memory for array instead of malloc + +calloc is more situable for memory allocation for array than malloc, +since the allocated memory will be set to 0. + +Fixes: 8b3b68347165 ("hikptool/roce: Add a common frame for hikptool roce register query") +Signed-off-by: Junxian Huang +--- + net/roce/roce_ext_common/hikp_roce_ext_common.c | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +diff --git a/net/roce/roce_ext_common/hikp_roce_ext_common.c b/net/roce/roce_ext_common/hikp_roce_ext_common.c +index d0fae69..d5ae64a 100644 +--- a/net/roce/roce_ext_common/hikp_roce_ext_common.c ++++ b/net/roce/roce_ext_common/hikp_roce_ext_common.c +@@ -115,8 +115,8 @@ static int hikp_roce_ext_get_res(enum roce_cmd_type cmd_type, + max_size = res_head->total_block_num * sizeof(uint32_t); + + if (block_id == 0) { +- reg->offset = (uint32_t *)malloc(max_size); +- reg->data = (uint32_t *)malloc(max_size); ++ reg->offset = (uint32_t *)calloc(res_head->total_block_num, sizeof(uint32_t)); ++ reg->data = (uint32_t *)calloc(res_head->total_block_num, sizeof(uint32_t)); + if ((reg->offset == NULL) || (reg->data == NULL)) { + printf("hikptool roce_%s alloc log memmory 0x%x failed!\n", + cmd_name, max_size); +-- +2.30.0 diff --git a/0049-hikptool-roce-Fix-missing-check-of-reg-num-responsed.patch b/0049-hikptool-roce-Fix-missing-check-of-reg-num-responsed.patch new file mode 100644 index 0000000000000000000000000000000000000000..f12db5627fc8c40deb65b355861944f1bc86f7d9 --- /dev/null +++ b/0049-hikptool-roce-Fix-missing-check-of-reg-num-responsed.patch @@ -0,0 +1,127 @@ +From 679cfd5353da2165dbf5b89769bbd5b69209bc5b Mon Sep 17 00:00:00 2001 +From: Junxian Huang +Date: Tue, 24 Oct 2023 15:12:41 +0800 +Subject: hikptool/roce: Fix missing check of reg num responsed from FW + +If the reg num responsed from a new-version FW exceeds the array +length in the old-version hikptool, an out-of-bounds access error +will occur. So add a check to ensure the reg num is not greater +than tha array length. + +Fixes: 392c269be165 ("support querying RoCE module information") +Fixes: 87f8605c32d3 ("hikptool/roce: Add ext query for roce_qmm cmd") +Signed-off-by: Junxian Huang +--- + net/roce/roce_caep/hikp_roce_caep.c | 7 +++++++ + net/roce/roce_pkt/hikp_roce_pkt.c | 7 +++++++ + net/roce/roce_qmm/hikp_roce_qmm.c | 7 +++++++ + net/roce/roce_timer/hikp_roce_timer.c | 12 ++++++++++++ + net/roce/roce_tsp/hikp_roce_tsp.c | 6 ++++++ + 5 files changed, 39 insertions(+) + +diff --git a/net/roce/roce_caep/hikp_roce_caep.c b/net/roce/roce_caep/hikp_roce_caep.c +index 6c92ea1..126551a 100644 +--- a/net/roce/roce_caep/hikp_roce_caep.c ++++ b/net/roce/roce_caep/hikp_roce_caep.c +@@ -85,7 +85,14 @@ static void hikp_roce_caep_execute_origin(struct major_cmd_ctrl *self) + printf("hikptool roce_caep get data failed.\n"); + goto exec_error; + } ++ + roce_caep_res = (struct roce_caep_res_param *)cmd_ret->rsp_data; ++ if (roce_caep_res->total_block_num > ROCE_HIKP_CAEP_REG_NUM) { ++ printf("version might not match, adjust the reg num to %d.\n", ++ ROCE_HIKP_CAEP_REG_NUM); ++ roce_caep_res->total_block_num = ROCE_HIKP_CAEP_REG_NUM; ++ } ++ + hikp_roce_caep_print(roce_caep_res->total_block_num, + roce_caep_res->reg_data.offset, + roce_caep_res->reg_data.data); +diff --git a/net/roce/roce_pkt/hikp_roce_pkt.c b/net/roce/roce_pkt/hikp_roce_pkt.c +index d3bf885..e710e08 100644 +--- a/net/roce/roce_pkt/hikp_roce_pkt.c ++++ b/net/roce/roce_pkt/hikp_roce_pkt.c +@@ -87,7 +87,14 @@ static void hikp_roce_pkt_execute(struct major_cmd_ctrl *self) + self->err_no = ret; + return; + } ++ + roce_pkt_res = (struct roce_pkt_res_param *)cmd_ret->rsp_data; ++ if (roce_pkt_res->total_block_num > ROCE_HIKP_PKT_REG_NUM) { ++ printf("version might not match, adjust the reg num to %d.\n", ++ ROCE_HIKP_PKT_REG_NUM); ++ roce_pkt_res->total_block_num = ROCE_HIKP_PKT_REG_NUM; ++ } ++ + hikp_roce_pkt_print(roce_pkt_res->total_block_num, + roce_pkt_res->reg_data.offset, roce_pkt_res->reg_data.data); + +diff --git a/net/roce/roce_qmm/hikp_roce_qmm.c b/net/roce/roce_qmm/hikp_roce_qmm.c +index b020c6a..d127264 100644 +--- a/net/roce/roce_qmm/hikp_roce_qmm.c ++++ b/net/roce/roce_qmm/hikp_roce_qmm.c +@@ -108,7 +108,14 @@ static void hikp_roce_qmm_execute_origin(struct major_cmd_ctrl *self) + printf("hikptool roce_qmm get data failed.\n"); + goto exec_error; + } ++ + roce_qmm_res = (struct roce_qmm_rsp_data *)cmd_ret->rsp_data; ++ if (roce_qmm_res->reg_num > ROCE_HIKP_QMM_REG_NUM) { ++ printf("version might not match, adjust the reg num to %d.\n", ++ ROCE_HIKP_QMM_REG_NUM); ++ roce_qmm_res->reg_num = ROCE_HIKP_QMM_REG_NUM; ++ } ++ + hikp_roce_qmm_print(roce_qmm_res); + + exec_error: +diff --git a/net/roce/roce_timer/hikp_roce_timer.c b/net/roce/roce_timer/hikp_roce_timer.c +index c4e979f..a78d383 100644 +--- a/net/roce/roce_timer/hikp_roce_timer.c ++++ b/net/roce/roce_timer/hikp_roce_timer.c +@@ -76,6 +76,12 @@ static int hikp_roce_timer_show_qpc(struct major_cmd_ctrl *self) + goto out; + + timer_rsp = (struct roce_timer_rsp_data *)(cmd_ret->rsp_data); ++ if (timer_rsp->reg_num > ROCE_HIKP_TIMER_REG_NUM) { ++ printf("version might not match, adjust the reg num to %d.\n", ++ ROCE_HIKP_TIMER_REG_NUM); ++ timer_rsp->reg_num = ROCE_HIKP_TIMER_REG_NUM; ++ } ++ + printf("**************QPC TIMER INFO*************\n"); + hikp_roce_timer_print(timer_rsp); + out: +@@ -104,6 +110,12 @@ static int hikp_roce_timer_show_cqc(struct major_cmd_ctrl *self) + goto out; + + timer_rsp = (struct roce_timer_rsp_data *)(cmd_ret->rsp_data); ++ if (timer_rsp->reg_num > ROCE_HIKP_TIMER_REG_NUM) { ++ printf("version might not match, adjust the reg num to %d.\n", ++ ROCE_HIKP_TIMER_REG_NUM); ++ timer_rsp->reg_num = ROCE_HIKP_TIMER_REG_NUM; ++ } ++ + printf("**************CQC TIMER INFO*************\n"); + hikp_roce_timer_print(timer_rsp); + out: +diff --git a/net/roce/roce_tsp/hikp_roce_tsp.c b/net/roce/roce_tsp/hikp_roce_tsp.c +index a036fae..5bb2649 100644 +--- a/net/roce/roce_tsp/hikp_roce_tsp.c ++++ b/net/roce/roce_tsp/hikp_roce_tsp.c +@@ -181,6 +181,12 @@ static void hikp_roce_tsp_execute(struct major_cmd_ctrl *self) + } + + roce_tsp_res = (struct roce_tsp_res_param *)cmd_ret->rsp_data; ++ if (roce_tsp_res->total_block_num > ROCE_HIKP_TSP_REG_NUM) { ++ printf("version might not match, adjust the reg num to %d.\n", ++ ROCE_HIKP_TSP_REG_NUM); ++ roce_tsp_res->total_block_num = ROCE_HIKP_TSP_REG_NUM; ++ } ++ + hikp_roce_tsp_print(roce_tsp_res->total_block_num, + roce_tsp_res->reg_data.offset, roce_tsp_res->reg_data.data); + +-- +2.30.0 \ No newline at end of file diff --git a/0050-hikptool-Change-the-unic_ppp-directory-to-ub_ppp.patch b/0050-hikptool-Change-the-unic_ppp-directory-to-ub_ppp.patch new file mode 100644 index 0000000000000000000000000000000000000000..6f9d370eb1c0d6e9eda15504ab6d12359385fa2d --- /dev/null +++ b/0050-hikptool-Change-the-unic_ppp-directory-to-ub_ppp.patch @@ -0,0 +1,43 @@ +From bb4201e589f3875351a5a7b1305254701663dc9a Mon Sep 17 00:00:00 2001 +From: JianQiang Li +Date: Wed, 25 Oct 2023 09:14:55 +0800 +Subject: [PATCH] [hikptool] Change the unic_ppp directory to ub_ppp. + +tool inclusion +category:bugfix +bugzilla:NA +CVE:NA + +---------------------------------------------------------------------- + +Change the unic_ppp directory to ub_ppp and add a blank line to the end of the hikp_unic_ppp.c file. + +Signed-off-by: Jianqiang Li +--- + net/ub/{ub_unic => ub_ppp}/hikp_unic_ppp.c | 2 +- + net/ub/{ub_unic => ub_ppp}/hikp_unic_ppp.h | 0 + 2 files changed, 1 insertion(+), 1 deletion(-) + rename net/ub/{ub_unic => ub_ppp}/hikp_unic_ppp.c (99%) + rename net/ub/{ub_unic => ub_ppp}/hikp_unic_ppp.h (100%) + +diff --git a/net/ub/ub_unic/hikp_unic_ppp.c b/net/ub/ub_ppp/hikp_unic_ppp.c +similarity index 99% +rename from net/ub/ub_unic/hikp_unic_ppp.c +rename to net/ub/ub_ppp/hikp_unic_ppp.c +index 5325b03..ccba4e0 100644 +--- a/net/ub/ub_unic/hikp_unic_ppp.c ++++ b/net/ub/ub_ppp/hikp_unic_ppp.c +@@ -465,4 +465,4 @@ static void cmd_unic_get_ppp_init(void) + 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 ++HIKP_CMD_DECLARE("unic_ppp", "dump ppp info of unic!", cmd_unic_get_ppp_init); +diff --git a/net/ub/ub_unic/hikp_unic_ppp.h b/net/ub/ub_ppp/hikp_unic_ppp.h +similarity index 100% +rename from net/ub/ub_unic/hikp_unic_ppp.h +rename to net/ub/ub_ppp/hikp_unic_ppp.h +-- +2.21.0.windows.1 + diff --git a/0051-hikptool-roce-Fix-the-wrong-maximum-of-gmv-index.patch b/0051-hikptool-roce-Fix-the-wrong-maximum-of-gmv-index.patch new file mode 100644 index 0000000000000000000000000000000000000000..1c6e632462f7439337f0c1994045ab00336f9c35 --- /dev/null +++ b/0051-hikptool-roce-Fix-the-wrong-maximum-of-gmv-index.patch @@ -0,0 +1,29 @@ +From 48d87bcd204c6aa226b5dbdb8c68ead8d12b1745 Mon Sep 17 00:00:00 2001 +From: Junxian Huang +Date: Tue, 31 Oct 2023 20:51:38 +0800 +Subject: hikptool/roce: Fix the wrong maximum of gmv index + +The RoCE driver supports up to 256 gmv table entry, the allowed +gmv index of hikptool command roce_gmv should cover this range. + +Signed-off-by: Junxian Huang +--- + net/roce/roce_gmv/hikp_roce_gmv.h | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/net/roce/roce_gmv/hikp_roce_gmv.h b/net/roce/roce_gmv/hikp_roce_gmv.h +index 1ef5b93..a02b960 100644 +--- a/net/roce/roce_gmv/hikp_roce_gmv.h ++++ b/net/roce/roce_gmv/hikp_roce_gmv.h +@@ -18,7 +18,7 @@ + + #define ROCE_HIKP_GMV_REG_NUM 7 + #define ROCE_HIKP_GMV_REG_SWICTH 2 +-#define ROCE_MAX_HIKPTOOL_GMV 128 ++#define ROCE_MAX_HIKPTOOL_GMV 256 + struct cmd_roce_gmv_param { + struct tool_target target; + uint32_t gmv_index; +-- +2.30.0 + diff --git a/0052-hikptool-Resolved-some-centralized-code-review-comme.patch b/0052-hikptool-Resolved-some-centralized-code-review-comme.patch new file mode 100644 index 0000000000000000000000000000000000000000..154d70c2672ccb7e8e612807e96431fd2b9453ea --- /dev/null +++ b/0052-hikptool-Resolved-some-centralized-code-review-comme.patch @@ -0,0 +1,1390 @@ +From faccc8979f5a6e458b02c7865b9e3316b9facfd1 Mon Sep 17 00:00:00 2001 +From: veega2022 +Date: Wed, 8 Nov 2023 20:43:06 +0800 +Subject: [PATCH] hikptool: Resolved some centralized code review comments. + +1. The ret variable may be a random value. +2. The unsigned variable judgment branch is redundant judgment. +3. Fix Magic Numbers. +4. The print format does not match. +5. After the pointer is released, a null value is assigned to the pointer to prevent it from being used again. +6. Delete unused variables. +7. The uint64_t print issue is rectified and PRIx64/PRIu64 is used. +8. Add 'const' to constant array. +9. Modifying File Permissions.Eliminate software privilege escalation risks. + +Signed-off-by: veega2022 +--- + cxl/func_lib/cxl_func/cxl_feature.c | 16 +++---- + cxl/usr_cmd/cmd_analysis/cxl_cmd_cpa.c | 2 +- + libhikptdev/src/rciep/hikpt_rciep.c | 22 ++++----- + libhikptdev/src/rciep/hikpt_rciep.h | 2 + + net/hikp_net_lib.c | 33 +++++++------ + net/hikp_net_lib.h | 6 +-- + net/nic/nic_dfx/hikp_nic_dfx.c | 1 - + net/nic/nic_fd/hikp_nic_fd.c | 48 +++++++++---------- + net/nic/nic_fec/hikp_nic_fec.c | 7 +-- + net/nic/nic_info/hikp_nic_info.c | 9 ++-- + net/nic/nic_log/hikp_nic_log.c | 2 +- + net/nic/nic_ppp/hikp_nic_ppp.c | 27 +++++++---- + net/nic/nic_qos/hikp_nic_qos.c | 9 ++-- + net/nic/nic_queue/hikp_nic_queue.c | 3 +- + net/nic/nic_rss/hikp_nic_rss.c | 3 +- + .../roce_ext_common/hikp_roce_ext_common.c | 12 +++-- + net/roce/roce_gmv/hikp_roce_gmv.c | 8 ++-- + net/roce/roce_mdb/hikp_roce_mdb.c | 1 - + net/roce/roce_qmm/hikp_roce_qmm.c | 8 ++-- + net/roce/roce_scc/hikp_roce_scc.c | 6 +-- + net/roce/roce_timer/hikp_roce_timer.c | 2 +- + net/roce/roce_trp/hikp_roce_trp.c | 18 ++++--- + net/roce/roce_tsp/hikp_roce_tsp.c | 7 +-- + net/ub/ub_crd/hikp_ub_crd.c | 1 - + net/ub/ub_ppp/hikp_unic_ppp.c | 5 ++ + ossl/ossl_user_linux.c | 1 - + pcie/func_lib/pcie_func/pcie_link_ltssm.c | 3 +- + pcie/func_lib/pcie_func/pcie_link_ltssm.h | 1 + + pcie/func_lib/pcie_func/pcie_reg_dump.c | 4 +- + pcie/func_lib/pcie_func/pcie_statistics.c | 4 +- + sas/sas_func/sas_read_dev.c | 2 - + sas/sas_func/sas_read_dqe.c | 4 +- + sas/user_cmd/cmd_code/sas_cmd_dqe.c | 1 - + sas/user_cmd/cmd_code/sas_cmd_dump.c | 1 - + serdes/hikp_serdes.c | 4 +- + socip/hikp_socip_dumpreg.c | 1 - + tool_lib/op_logs.c | 18 ++++--- + tool_lib/tool_cmd.c | 1 - + tool_lib/tool_lib.c | 3 ++ + 39 files changed, 161 insertions(+), 145 deletions(-) + +diff --git a/cxl/func_lib/cxl_func/cxl_feature.c b/cxl/func_lib/cxl_func/cxl_feature.c +index 6de3f89..cd41b09 100644 +--- a/cxl/func_lib/cxl_func/cxl_feature.c ++++ b/cxl/func_lib/cxl_func/cxl_feature.c +@@ -77,13 +77,9 @@ static void cxl_dl_fsm_str_get(struct cxl_fsm_state_str *fsm_str_table, + { + int i = 0; + +- while (fsm_str_table[i].fsm_state >= 0) { +- if ((uint32_t)fsm_str_table[i].fsm_state != fsm_state) { +- i++; +- continue; +- } +- break; +- } ++ while (fsm_str_table[i].fsm_state >= 0 && ++ (uint32_t)fsm_str_table[i].fsm_state != fsm_state) ++ i++; + + *fsm_s = fsm_str_table[i].fsm_str; + } +@@ -95,7 +91,7 @@ static void cxl_dl_fsm_state_print(const struct cxl_data_unit *data, uint32_t da + struct cxl_fsm_state_str rrsm_state[] = { + {0x0, "retry_remote_normal"}, + {0x1, "retry_llrack"}, +- {-1, "unknow"} ++ {-1, "unknown"} + }; + struct cxl_fsm_state_str lrsm_state[] = { + {0x1, "retry_local_normal"}, +@@ -103,14 +99,14 @@ static void cxl_dl_fsm_state_print(const struct cxl_data_unit *data, uint32_t da + {0x4, "retry_phy_reinit"}, + {0x8, "retry_local_idle"}, + {0x10, "retry_abort"}, +- {-1, "unknow"} ++ {-1, "unknown"} + }; + struct cxl_fsm_state_str init_fsm_state[] = { + {0x1, "inactive"}, + {0x2, "retry"}, + {0x4, "param"}, + {0x8, "active"}, +- {-1, "unknow"} ++ {-1, "unknown"} + }; + + if (data_unit_len == 0) { +diff --git a/cxl/usr_cmd/cmd_analysis/cxl_cmd_cpa.c b/cxl/usr_cmd/cmd_analysis/cxl_cmd_cpa.c +index 2607705..2df9dc5 100644 +--- a/cxl/usr_cmd/cmd_analysis/cxl_cmd_cpa.c ++++ b/cxl/usr_cmd/cmd_analysis/cxl_cmd_cpa.c +@@ -46,7 +46,7 @@ static int cxl_port_id_set(struct major_cmd_ctrl *self, const char *argv) + + ret = string_toui(argv, &val); + if (ret) { +- printf("cpa set port id err %d\n", ret); ++ printf("cxl cpa set port id err %d\n", ret); + return ret; + } + g_cxl_cpa_cmd.port_id = val; +diff --git a/libhikptdev/src/rciep/hikpt_rciep.c b/libhikptdev/src/rciep/hikpt_rciep.c +index 5c7e82f..f673dd0 100644 +--- a/libhikptdev/src/rciep/hikpt_rciep.c ++++ b/libhikptdev/src/rciep/hikpt_rciep.c +@@ -41,7 +41,7 @@ static int hikp_memcpy_io(void *dst, size_t dst_size, void const *src, size_t sr + if (dst_size < src_size) + return -EINVAL; + +- for (i = 0; i < src_size / sizeof(uint32_t); i++) ++ for (i = 0; i < src_size / REP_DATA_BLK_SIZE; i++) + ((uint32_t *)dst)[i] = ((uint32_t *)src)[i]; + + return 0; +@@ -148,13 +148,13 @@ static int hikp_rep_init(void const *req_data, uint32_t req_size, + printf("The request data is NULL.\n"); + return -EINVAL; + } +- data_num = (req_size + (sizeof(uint32_t) - 1)) / sizeof(uint32_t); ++ data_num = (req_size + (REP_DATA_BLK_SIZE - 1)) / REP_DATA_BLK_SIZE; + if (data_num > HIKP_REQ_DATA_MAX) { +- printf("request data num(%u) exceeds max size(%u).\n", data_num, HIKP_REQ_DATA_MAX); ++ printf("request data num(%zu) exceeds max size(%u).\n", data_num, HIKP_REQ_DATA_MAX); + return -EINVAL; + } + if (data_num != 0) { +- *align_req_data = (uint32_t *)calloc(data_num, sizeof(uint32_t)); ++ *align_req_data = (uint32_t *)calloc(data_num, REP_DATA_BLK_SIZE); + if (*align_req_data == NULL) { + printf("request memory malloc failed.\n"); + return -ENOMEM; +@@ -175,12 +175,12 @@ static int hikp_req_first_round(uint32_t *req_data, uint32_t rep_num, uint32_t * + if (req_data == NULL) + return 0; + +- src_size = rep_num * sizeof(uint32_t); ++ src_size = rep_num * REP_DATA_BLK_SIZE; + dst_size = sizeof(g_hikp_req->field.data); + hikp_memclr_io(); + ret = hikp_memcpy_io((uint32_t *)(g_hikp_req->field.data), dst_size, req_data, src_size); + if (ret != 0) { +- printf("size error, dst_size:%u, src_size:%u.\n", dst_size, src_size); ++ printf("size error, dst_size:%zu, src_size:%zu.\n", dst_size, src_size); + return ret; + } + g_hikp_req->field.exe_round = 0; +@@ -209,7 +209,7 @@ static int hikp_multi_round_interact(struct hikp_cmd_ret **cmd_ret, uint32_t sta + } + + p_cmd_ret = (struct hikp_cmd_ret *)malloc(sizeof(struct hikp_cmd_ret) + +- rsp_num * sizeof(uint32_t)); ++ rsp_num * REP_DATA_BLK_SIZE); + if (p_cmd_ret == NULL) { + printf("response memory malloc fail.\n"); + return -ENOMEM; +@@ -235,8 +235,8 @@ static int hikp_multi_round_interact(struct hikp_cmd_ret **cmd_ret, uint32_t sta + } + } + src_size = (i == cycle - 1) ? +- (rsp_num - (i * HIKP_RSP_DATA_MAX)) * sizeof(uint32_t) : +- HIKP_RSP_DATA_MAX * sizeof(uint32_t); ++ (rsp_num - (i * HIKP_RSP_DATA_MAX)) * REP_DATA_BLK_SIZE : ++ HIKP_RSP_DATA_MAX * REP_DATA_BLK_SIZE; + dst_size = src_size; + (void)hikp_memcpy_io(&(p_cmd_ret->rsp_data)[i * HIKP_RSP_DATA_MAX], + dst_size, (uint32_t *)(g_hikp_rsp->field.data), src_size); +@@ -258,7 +258,7 @@ struct hikp_cmd_ret *hikp_cmd_alloc(struct hikp_cmd_header *req_header, + { + struct hikp_cmd_ret *cmd_ret = NULL; + uint32_t *p_req_data = NULL; +- uint32_t rep_num, rsp_num; ++ uint32_t rep_num; + uint32_t cpl_status = HIKP_INIT_STAT; + int ret; + +@@ -557,7 +557,7 @@ int hikp_dev_init(void) + goto out_unmap; + } + +- len = (sizeof(union hikp_space_req) - sizeof(struct iep_doorbell)) / sizeof(uint32_t); ++ len = (sizeof(union hikp_space_req) - sizeof(struct iep_doorbell)) / REP_DATA_BLK_SIZE; + for (i = 0; i < len; i++) + g_hikp_req->dw[i] = 0; + +diff --git a/libhikptdev/src/rciep/hikpt_rciep.h b/libhikptdev/src/rciep/hikpt_rciep.h +index dd08759..296d235 100644 +--- a/libhikptdev/src/rciep/hikpt_rciep.h ++++ b/libhikptdev/src/rciep/hikpt_rciep.h +@@ -42,6 +42,8 @@ + #define CPL_CHECK_GAP_US 1000 + #define WAIT_CPL_MAX_MS 8000 + ++#define REP_DATA_BLK_SIZE sizeof(uint32_t) ++ + enum { + HIKP_RESOURCE_DIR, + HIKP_CONFIG_DIR, +diff --git a/net/hikp_net_lib.c b/net/hikp_net_lib.c +index eba086e..8db4ad5 100644 +--- a/net/hikp_net_lib.c ++++ b/net/hikp_net_lib.c +@@ -23,7 +23,7 @@ + #include "tool_lib.h" + #include "hikptdev_plug.h" + +-static int hikp_read_net_pci_info(const char *file_path, uint32_t len, char *content) ++static int hikp_read_net_pci_info(const char *file_path, char *content, size_t len) + { + char path[PATH_MAX + 1] = { 0 }; + int ret; +@@ -32,7 +32,7 @@ static int hikp_read_net_pci_info(const char *file_path, uint32_t len, char *con + if (file_path == NULL || content == NULL) + return -EINVAL; + +- if (len > MAX_PCI_ID_LEN) ++ if (len > MAX_PCI_ID_LEN + 1 || len < 1) + return -EINVAL; + + if (strlen(file_path) > PATH_MAX || realpath(file_path, path) == NULL) +@@ -42,12 +42,12 @@ static int hikp_read_net_pci_info(const char *file_path, uint32_t len, char *con + if (fd < 0) + return -EPERM; + +- ret = pread(fd, content, len, 0); ++ ret = pread(fd, content, len - 1, 0); + if (ret < 0) { + close(fd); + return -EIO; + } +- content[len] = '\0'; // The invoker ensures that the bounds are not crossed. ++ content[len - 1] = '\0'; // The invoker ensures that the bounds are not crossed. + close(fd); + + return 0; +@@ -191,7 +191,7 @@ static int tool_get_bdf_by_dev_name(const char *name, struct tool_target *target + int tool_check_and_get_valid_bdf_id(const char *name, struct tool_target *target) + { + if (!name || !target) +- return 0; ++ return -EINVAL; + + if (interface_is_bdf_id(name, target)) + return 0; +@@ -211,11 +211,14 @@ bool is_dev_valid_and_special(int sockfd, struct tool_target *target) + return true; + } + +-int get_revision_id_by_bdf(const struct bdf_t *bdf, char *revision_id) ++int get_revision_id_by_bdf(const struct bdf_t *bdf, char *revision_id, size_t id_len) + { + char revision_dir[MAX_BUS_PCI_DIR_LEN] = { 0 }; + int ret; + ++ if (id_len < MAX_PCI_ID_LEN + 1) ++ return -EINVAL; ++ + ret = snprintf(revision_dir, sizeof(revision_dir), "%s%04x:%02x:%02x.%u%s", + HIKP_BUS_PCI_DEV_DIR, bdf->domain, bdf->bus_id, bdf->dev_id, + bdf->fun_id, HIKP_PCI_REVISION_DIR); +@@ -223,14 +226,14 @@ int get_revision_id_by_bdf(const struct bdf_t *bdf, char *revision_id) + HIKP_ERROR_PRINT("get revision dir fail.\n"); + return -EIO; + } +- ret = hikp_read_net_pci_info((const char *)revision_dir, MAX_PCI_ID_LEN, revision_id); ++ ret = hikp_read_net_pci_info((const char *)revision_dir, revision_id, id_len); + if (ret != 0) + return ret; + + return 0; + } + +-static int hikp_get_dir_name_of_device(const char *path, uint32_t len, char *dir_name) ++static int hikp_get_dir_name_of_device(const char *path, size_t len, char *dir_name) + { + struct dirent *ptr; + DIR *dir = NULL; +@@ -261,12 +264,12 @@ static int hikp_get_dir_name_of_device(const char *path, uint32_t len, char *dir + return closedir(dir); + } + +-int get_dev_name_by_bdf(const struct bdf_t *bdf, char *dev_name) ++int get_dev_name_by_bdf(const struct bdf_t *bdf, char *dev_name, size_t name_len) + { + char dev_name_dir[MAX_BUS_PCI_DIR_LEN] = { 0 }; + int ret; + +- if (!dev_name || !bdf) ++ if (!dev_name || !bdf || name_len < IFNAMSIZ) + return -EINVAL; + + /* if dev_name already has a value, we do not need to obtain it. */ +@@ -283,7 +286,7 @@ int get_dev_name_by_bdf(const struct bdf_t *bdf, char *dev_name) + if (!is_dir_exist(dev_name_dir)) + return -ENOENT; + +- return hikp_get_dir_name_of_device(dev_name_dir, IFNAMSIZ, dev_name); ++ return hikp_get_dir_name_of_device(dev_name_dir, name_len, dev_name); + } + + int get_vf_dev_info_by_pf_dev_name(const char *pf_dev_name, +@@ -352,7 +355,7 @@ int get_numvfs_by_bdf(const struct bdf_t *bdf, uint8_t *numvfs) + HIKP_ERROR_PRINT("get numvfs dir fail.\n"); + return -EIO; + } +- ret = hikp_read_net_pci_info((const char *)numvfs_dir, MAX_PCI_ID_LEN, numvf); ++ ret = hikp_read_net_pci_info((const char *)numvfs_dir, numvf, MAX_PCI_ID_LEN + 1); + if (ret != 0) + return ret; + +@@ -366,12 +369,12 @@ int get_numvfs_by_bdf(const struct bdf_t *bdf, uint8_t *numvfs) + return 0; + } + +-void hikp_ether_format_addr(char *buf, uint16_t size, const uint8_t *mac_addr) ++void hikp_ether_format_addr(char *buf, uint16_t size, const uint8_t *mac_addr, uint8_t mac_len) + { + int len; + +- if (buf == NULL || mac_addr == NULL) { +- HIKP_WARN_PRINT("buf or mac_addr pointer is NULL.\n"); ++ if (buf == NULL || mac_addr == NULL || mac_len != HIKP_NIC_ETH_MAC_ADDR_LEN) { ++ HIKP_WARN_PRINT("buf or mac_addr pointer is NULL, or len(%u) is invalid\n", mac_len); + return; + } + +diff --git a/net/hikp_net_lib.h b/net/hikp_net_lib.h +index ad9e7e4..8a0958f 100644 +--- a/net/hikp_net_lib.h ++++ b/net/hikp_net_lib.h +@@ -130,12 +130,12 @@ enum nic_get_ncsi_sub_cmd { + int hikp_net_creat_sock(void); + int tool_check_and_get_valid_bdf_id(const char *name, struct tool_target *target); + bool is_dev_valid_and_special(int sockfd, struct tool_target *target); +-int get_revision_id_by_bdf(const struct bdf_t *bdf, char *revision_id); +-int get_dev_name_by_bdf(const struct bdf_t *bdf, char *dev_name); ++int get_revision_id_by_bdf(const struct bdf_t *bdf, char *revision_id, size_t id_len); ++int get_dev_name_by_bdf(const struct bdf_t *bdf, char *dev_name, size_t name_len); + int get_numvfs_by_bdf(const struct bdf_t *bdf, uint8_t *numvfs); + int get_vf_dev_info_by_pf_dev_name(const char *pf_dev_name, + struct tool_target *vf_target, uint8_t vf_id); + int get_pf_dev_info_by_vf_dev_name(const char *vf_dev_name, struct tool_target *pf_target); +-void hikp_ether_format_addr(char *buf, uint16_t size, const uint8_t *mac_addr); ++void hikp_ether_format_addr(char *buf, uint16_t size, const uint8_t *mac_addr, uint8_t mac_len); + + #endif +diff --git a/net/nic/nic_dfx/hikp_nic_dfx.c b/net/nic/nic_dfx/hikp_nic_dfx.c +index c734ce0..4095229 100644 +--- a/net/nic/nic_dfx/hikp_nic_dfx.c ++++ b/net/nic/nic_dfx/hikp_nic_dfx.c +@@ -318,7 +318,6 @@ static void hikp_nic_dfx_cmd_execute(struct major_cmd_ctrl *self) + uint32_t max_dfx_size; + uint32_t version; + uint32_t i; +- int ret; + + if (!(g_dfx_param.flag & MODULE_SET_FLAG)) { + self->err_no = -EINVAL; +diff --git a/net/nic/nic_fd/hikp_nic_fd.c b/net/nic/nic_fd/hikp_nic_fd.c +index 57bc94b..e699bf9 100644 +--- a/net/nic/nic_fd/hikp_nic_fd.c ++++ b/net/nic/nic_fd/hikp_nic_fd.c +@@ -15,7 +15,7 @@ + #include + #include + #include +- ++#include + #include "hikp_nic_fd.h" + + struct key_info { +@@ -255,13 +255,13 @@ static void hikp_nic_print_tuple(const struct key_info *tuple_key, + case OUTER_SRC_MAC: + case INNER_DST_MAC: + case INNER_SRC_MAC: +- printf("\t %s[mask=0x%llx]: ", tuple_key->key_name, mask); ++ printf("\t %s[mask=0x%" PRIx64 "]: ", tuple_key->key_name, mask); + printf("%02x:%02x:%02x:%02x:%02x:%02x\n", *(tcam_y + 5), *(tcam_y + 4), + *(tcam_y + 3), *(tcam_y + 2), *(tcam_y + 1), *tcam_y); + break; + case OUTER_ETH_TYPE: + case INNER_ETH_TYPE: +- printf("\t %s[mask=0x%llx]: ", tuple_key->key_name, mask); ++ printf("\t %s[mask=0x%" PRIx64 "]: ", tuple_key->key_name, mask); + printf("0x%x\n", *(uint16_t *)tcam_y); + break; + case OUTER_VLAN_TAG_FST: +@@ -276,7 +276,7 @@ static void hikp_nic_print_tuple(const struct key_info *tuple_key, + case OUTER_DST_PORT: + case INNER_SRC_PORT: + case INNER_DST_PORT: +- printf("\t %s[mask=0x%llx]: ", tuple_key->key_name, mask); ++ printf("\t %s[mask=0x%" PRIx64 "]: ", tuple_key->key_name, mask); + printf("%u\n", *(uint16_t *)tcam_y); + break; + case OUTER_IP_TOS: +@@ -284,25 +284,25 @@ static void hikp_nic_print_tuple(const struct key_info *tuple_key, + case OUTER_IP_PROTO: + case INNER_IP_PROTO: + case OUTER_TUN_FLOW_ID: +- printf("\t %s[mask=0x%llx]: ", tuple_key->key_name, mask); ++ printf("\t %s[mask=0x%" PRIx64 "]: ", tuple_key->key_name, mask); + printf("0x%x\n", *tcam_y); + break; + case OUTER_SRC_IP: + case OUTER_DST_IP: + case INNER_SRC_IP: + case INNER_DST_IP: +- printf("\t %s[mask=0x%llx]: ", tuple_key->key_name, mask); ++ printf("\t %s[mask=0x%" PRIx64 "]: ", tuple_key->key_name, mask); + printf("%u.%u.%u.%u\n", *(tcam_y + 3), *(tcam_y + 2), *(tcam_y + 1), *tcam_y); + break; + case OUTER_L4_RSV: + case INNER_L4_RSV: +- printf("\t %s[mask=0x%llx]: ", tuple_key->key_name, mask); ++ printf("\t %s[mask=0x%" PRIx64 "]: ", tuple_key->key_name, mask); + printf("%u\n", *(uint32_t *)tcam_y); + break; + case OUTER_TUN_VNI: + for (i = 0; i < HIKP_NIC_FD_TUN_VNI_LEN; i++) + tun_vni |= (((uint32_t)*(tcam_y + i)) << (i * HIKP_BITS_PER_BYTE)); +- printf("\t %s[mask=0x%llx]: ", tuple_key->key_name, mask); ++ printf("\t %s[mask=0x%" PRIx64 "]: ", tuple_key->key_name, mask); + printf("0x%x\n", tun_vni); + break; + default: +@@ -407,12 +407,12 @@ static void hikp_nic_fd_print_meta_data(struct nic_fd_rule_info *rule) + meta_bytes = HIKP_DIV_ROUND_UP(active_meta_width, HIKP_BITS_PER_BYTE); + meta_data_region = active_tcam_size - meta_bytes; + if (meta_bytes > sizeof(meta_data)) { +- printf("meta data copy size error, data size: 0x%x, max size: 0x%x\n", ++ printf("meta data copy size error, data size: %u, max size: %zu\n", + meta_bytes, sizeof(meta_data)); + return; + } + memcpy(&meta_data, &key_y[meta_data_region], meta_bytes); +- printf("\t meta_data[meta_data=0x%llx]:\n", meta_data); ++ printf("\t meta_data[meta_data=0x%" PRIx64 "]:\n", meta_data); + cur_pos = meta_bytes * HIKP_BITS_PER_BYTE; + end = cur_pos - 1; + for (i = MAX_META_DATA - 1; i >= 0; i--) { +@@ -470,7 +470,7 @@ static void hikp_nic_fd_print_ad_data(struct nic_fd_rule_info *rule) + uint64_t ad_data; + + ad_data = (uint64_t)rule->ad_data_h << NIC_FD_AD_DATA_S | rule->ad_data_l; +- printf("\n\tAction[ad data: 0x%llx]:\n", ad_data); ++ printf("\n\tAction[ad data: 0x%" PRIx64 "]:\n", ad_data); + + hikp_nic_parse_ad_data(rule, &action); + +@@ -544,7 +544,7 @@ static void hikp_nic_show_fd_counter(const void *data) + printf(" idx | hit_cnt\n"); + for (i = 0; i < counter[stage_no].counter_size; i++) { + entry = &counter[stage_no].entry[i]; +- printf(" %3u | %llu\n", entry->idx, entry->value); ++ printf(" %3u | %" PRIu64 "\n", entry->idx, entry->value); + } + } + +@@ -554,7 +554,6 @@ static int hikp_nic_fd_get_blk(struct hikp_cmd_header *req_header, + { + struct hikp_cmd_ret *cmd_ret; + struct nic_fd_rsp *rsp; +- uint16_t idx; + int ret = 0; + + cmd_ret = hikp_cmd_alloc(req_header, req_data, sizeof(*req_data)); +@@ -792,10 +791,13 @@ static void hikp_nic_fd_data_free(union nic_fd_feature_info *fd_data) + const struct fd_feature_cmd *fd_cmd; + + fd_cmd = &g_fd_feature_cmd[g_fd_param.feature_idx]; +- if (strcmp(fd_cmd->feature_name, NIC_FD_RULES_NAME) == 0) ++ if (strcmp(fd_cmd->feature_name, NIC_FD_RULES_NAME) == 0) { + free(fd_data->rules[stage_no].rule); +- else if (strcmp(fd_cmd->feature_name, NIC_FD_COUNTER_NAME) == 0) ++ fd_data->rules[stage_no].rule = NULL; ++ } else if (strcmp(fd_cmd->feature_name, NIC_FD_COUNTER_NAME) == 0) { + free(fd_data->counter[stage_no].entry); ++ fd_data->counter[stage_no].entry = NULL; ++ } + + free(fd_data); + } +@@ -859,31 +861,27 @@ static int hikp_nic_fd_check_input_param(struct major_cmd_ctrl *self, + + 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; ++ return -EINVAL; + } + + if (fd_param->feature_idx == -1) { + hikp_nic_fd_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 -EINVAL; + } + + fd_cmd = &g_fd_feature_cmd[g_fd_param.feature_idx]; + if (fd_param->stage_no == -1 && fd_cmd->sub_cmd_code != NIC_FD_HW_INFO_DUMP) { + snprintf(self->err_str, sizeof(self->err_str), + "please input '-st/--stage' parameter."); +- self->err_no = -EINVAL; +- return self->err_no; ++ return -EINVAL; + } + + if (fd_cmd->sub_cmd_code == NIC_FD_HW_INFO_DUMP && + (fd_param->id != -1 || fd_param->stage_no != -1)) { + snprintf(self->err_str, sizeof(self->err_str), + "no need '-id/--index' and '-st/--stage' parameter."); +- self->err_no = -EINVAL; +- return self->err_no; ++ return -EINVAL; + } + + return 0; +@@ -899,8 +897,10 @@ static void hikp_nic_fd_cmd_execute(struct major_cmd_ctrl *self) + int ret; + + ret = hikp_nic_fd_check_input_param(self, &g_fd_param); +- if (ret != 0) ++ if (ret != 0) { ++ self->err_no = ret; + return; ++ } + + ret = hikp_nic_get_fd_hw_info(bdf, &g_fd_hw_info); + if (ret != 0) { +diff --git a/net/nic/nic_fec/hikp_nic_fec.c b/net/nic/nic_fec/hikp_nic_fec.c +index 5d9025c..342b3eb 100644 +--- a/net/nic/nic_fec/hikp_nic_fec.c ++++ b/net/nic/nic_fec/hikp_nic_fec.c +@@ -15,7 +15,7 @@ + #include + #include + #include +- ++#include + #include "hikp_nic_fec.h" + + static struct tool_target g_fec_target; +@@ -40,6 +40,7 @@ static int hikp_nic_fec_err_query(const struct bdf_t *bdf, struct nic_fec_err_in + rsp = (struct nic_fec_rsp *)cmd_ret->rsp_data; + *info = *(struct nic_fec_err_info *)rsp->data; + free(cmd_ret); ++ cmd_ret = NULL; + + if (info->fec_mode >= NIC_FEC_MODE_BUTT) { + HIKP_ERROR_PRINT("unknown fec mode: %u\n", info->fec_mode); +@@ -71,7 +72,7 @@ static void hikp_nic_fec_err_show_basefec(const struct nic_fec_err_info *info) + for (total = 0, i = 0; i < lane_num; i++) + total += info->basefec.lane_corr_block_cnt[i]; + +- printf(" corrected_blocks: %llu\n", total); ++ printf(" corrected_blocks: %" PRIu64 "\n", total); + for (i = 0; i < lane_num; i++) + printf(" Lane %u: %u\n", i, info->basefec.lane_corr_block_cnt[i]); + +@@ -79,7 +80,7 @@ static void hikp_nic_fec_err_show_basefec(const struct nic_fec_err_info *info) + for (total = 0, i = 0; i < lane_num; i++) + total += info->basefec.lane_uncorr_block_cnt[i]; + +- printf(" uncorrectable_blocks: %llu\n", total); ++ printf(" uncorrectable_blocks: %" PRIu64 "\n", total); + for (i = 0; i < lane_num; i++) + printf(" Lane %u: %u\n", i, info->basefec.lane_uncorr_block_cnt[i]); + } +diff --git a/net/nic/nic_info/hikp_nic_info.c b/net/nic/nic_info/hikp_nic_info.c +index d84ca18..cd78bc7 100644 +--- a/net/nic/nic_info/hikp_nic_info.c ++++ b/net/nic/nic_info/hikp_nic_info.c +@@ -79,7 +79,8 @@ static int hikp_nic_get_curr_die_info(void) + free(cmd_ret); + cmd_ret = NULL; + +- ret = get_revision_id_by_bdf(&g_info_param.target.bdf, g_info_param.revision_id); ++ ret = get_revision_id_by_bdf(&g_info_param.target.bdf, g_info_param.revision_id, ++ sizeof(g_info_param.revision_id)); + if (ret != 0) { + HIKP_ERROR_PRINT("Getting revision fail.\n"); + return ret; +@@ -87,7 +88,8 @@ static int hikp_nic_get_curr_die_info(void) + ret = get_numvfs_by_bdf(&g_info_param.target.bdf, &g_info_param.numvfs); + if (ret != 0) + HIKP_ERROR_PRINT("Getting numvfs fail, ret = %d.\n", ret); +- ret = get_dev_name_by_bdf(&g_info_param.target.bdf, g_info_param.target.dev_name); ++ ret = get_dev_name_by_bdf(&g_info_param.target.bdf, g_info_param.target.dev_name, ++ sizeof(g_info_param.target.dev_name)); + if ((ret != 0) && (ret != -ENOENT)) { + HIKP_ERROR_PRINT("Getting dev name fail.\n"); + return ret; +@@ -258,7 +260,8 @@ static void hikp_nic_info_print_cur_vf(const struct bdf_t *bdf) + printf("Current function is vf:\n"); + printf("\t%-16s %04x:%02x:%02x.%u\n", "vf bdf id:", + bdf->domain, bdf->bus_id, bdf->dev_id, bdf->fun_id); +- ret = get_dev_name_by_bdf(&g_info_param.target.bdf, g_info_param.target.dev_name); ++ ret = get_dev_name_by_bdf(&g_info_param.target.bdf, g_info_param.target.dev_name, ++ sizeof(g_info_param.target.dev_name)); + if ((ret != 0) && (ret != -ENOENT)) { + HIKP_ERROR_PRINT("Getting dev name fail.\n"); + return; +diff --git a/net/nic/nic_log/hikp_nic_log.c b/net/nic/nic_log/hikp_nic_log.c +index 5cafe4e..893aef1 100644 +--- a/net/nic/nic_log/hikp_nic_log.c ++++ b/net/nic/nic_log/hikp_nic_log.c +@@ -113,7 +113,7 @@ static int hikp_nic_get_first_blk_info(uint32_t *total_blk_num, + } + *log_data = (uint8_t *)calloc(1, log_size); + if (*log_data == NULL) { +- HIKP_ERROR_PRINT("malloc log memory 0x%x failed.", log_size); ++ HIKP_ERROR_PRINT("calloc log memory 0x%x failed.", log_size); + ret = -ENOMEM; + goto err_out; + } +diff --git a/net/nic/nic_ppp/hikp_nic_ppp.c b/net/nic/nic_ppp/hikp_nic_ppp.c +index b71fc48..7968ac3 100644 +--- a/net/nic/nic_ppp/hikp_nic_ppp.c ++++ b/net/nic/nic_ppp/hikp_nic_ppp.c +@@ -95,7 +95,7 @@ static uint16_t hikp_nic_ppp_get_abs_func_id(const struct bdf_t *bdf, int relati + static void hikp_nic_ppp_get_func_name(char *buf, uint8_t len, uint8_t id) + { + if (id > 0) +- snprintf(buf, len, "vf%d", id - 1); ++ snprintf(buf, len, "vf%u", id - 1); + else + snprintf(buf, len, "pf"); + } +@@ -145,7 +145,8 @@ static void hikp_nic_ppp_show_key_mem(struct nic_mac_tbl *tbl, bool is_key_mem) + uc_entry = &uc_tbl->entry[idx]; + if (uc_entry->idx < g_ppp_hw_res.max_key_mem_size || !is_key_mem) { + hikp_ether_format_addr(mac_str, +- HIKP_NIC_ETH_ADDR_FMT_SIZE, uc_entry->mac_addr); ++ HIKP_NIC_ETH_ADDR_FMT_SIZE, uc_entry->mac_addr, ++ HIKP_NIC_ETH_MAC_ADDR_LEN); + printf("%04u | %01u | %s | ", uc_entry->idx, uc_entry->valid, mac_str); + printf("%04u | %u | %01u | ", + uc_entry->vlan_id, uc_entry->vmdq1, uc_entry->mac_en); +@@ -161,7 +162,8 @@ static void hikp_nic_ppp_show_key_mem(struct nic_mac_tbl *tbl, bool is_key_mem) + mc_entry = &mc_tbl->entry[idx]; + if (mc_entry->idx < g_ppp_hw_res.max_key_mem_size || !is_key_mem) { + hikp_ether_format_addr(mac_str, +- HIKP_NIC_ETH_ADDR_FMT_SIZE, mc_entry->mac_addr); ++ HIKP_NIC_ETH_ADDR_FMT_SIZE, mc_entry->mac_addr, ++ HIKP_NIC_ETH_MAC_ADDR_LEN); + printf("%04u | %s | ", mc_entry->idx, mac_str); + printf("%08x:%08x:%08x:%08x:%08x:%08x:%08x:%08x", + mc_entry->function_bitmap[7], mc_entry->function_bitmap[6], +@@ -191,7 +193,7 @@ static void hikp_nic_ppp_show_func_uc_mac_addr(struct mac_vlan_uc_tbl *uc_tbl, + vf_id = hikp_get_field(uc_entry->e_vport, HIKP_NIC_VF_ID_MASK, HIKP_NIC_VF_ID_S); + if (bdf->fun_id == pf_id && vf_id == func_id) { + hikp_ether_format_addr(mac_str, HIKP_NIC_ETH_ADDR_FMT_SIZE, +- uc_entry->mac_addr); ++ uc_entry->mac_addr, HIKP_NIC_ETH_MAC_ADDR_LEN); + printf("\t%s\n", mac_str); + } + } +@@ -205,7 +207,7 @@ static void hikp_nic_ppp_show_func_mc_mac_addr(struct mac_vlan_mc_tbl *mc_tbl, + uint16_t abs_func_id; + uint8_t offset; + uint8_t idx; +- uint8_t i; ++ uint32_t i; + + abs_func_id = hikp_nic_ppp_get_abs_func_id(bdf, func_id); + idx = abs_func_id / HIKP_NIC_PPP_FUNC_BITMAP_SIZE; +@@ -218,7 +220,7 @@ static void hikp_nic_ppp_show_func_mc_mac_addr(struct mac_vlan_mc_tbl *mc_tbl, + + if (hikp_get_bit(mc_entry->function_bitmap[idx], offset) != 0) { + hikp_ether_format_addr(mac_str, HIKP_NIC_ETH_ADDR_FMT_SIZE, +- mc_entry->mac_addr); ++ mc_entry->mac_addr, HIKP_NIC_ETH_MAC_ADDR_LEN); + printf("\t%s\n", mac_str); + } + } +@@ -401,7 +403,8 @@ static void hikp_nic_ppp_show_manager_tbl(const void *data) + "| i_map | i_dir | e_type | pf_id | vf_id | q_id | drop\n"); + for (i = 0; i < tbl->entry_size; i++) { + entry = &tbl->entry[i]; +- hikp_ether_format_addr(mac_str, HIKP_NIC_ETH_ADDR_FMT_SIZE, entry->mac_addr); ++ hikp_ether_format_addr(mac_str, HIKP_NIC_ETH_ADDR_FMT_SIZE, entry->mac_addr, ++ HIKP_NIC_ETH_MAC_ADDR_LEN); + printf(" %02u | %s | %u ", entry->entry_no, mac_str, entry->mac_mask); + printf("| %04x | %u | %04u | %u ", + entry->ether_type, entry->ether_mask, entry->vlan_id, entry->vlan_mask); +@@ -489,7 +492,7 @@ static int hikp_nic_ppp_get_blk(struct hikp_cmd_header *req_header, + rsp = (struct nic_ppp_rsp *)cmd_ret->rsp_data; + if (rsp->rsp_head.cur_blk_size > buf_len) { + HIKP_ERROR_PRINT("nic_ppp block context copy size error, " +- "buffer size=%u, data size=%u.\n", ++ "buffer size=%zu, data size=%u.\n", + buf_len, rsp->rsp_head.cur_blk_size); + ret = -EINVAL; + goto out; +@@ -791,6 +794,7 @@ static int hikp_nic_ppp_alloc_mac_tbl_entry(struct nic_mac_tbl *mac_tbl, + if (mac_tbl->mc_tbl.entry == NULL) { + HIKP_ERROR_PRINT("Fail to alloc mc_entry memory.\n"); + free(mac_tbl->uc_tbl.entry); ++ mac_tbl->uc_tbl.entry = NULL; + return -ENOMEM; + } + +@@ -813,6 +817,7 @@ static int hikp_nic_ppp_alloc_vlan_tbl_entry(struct nic_vlan_tbl *vlan_tbl, + if (vlan_tbl->vf_vlan_tbl.entry == NULL) { + HIKP_ERROR_PRINT("Fail to alloc vf_vlan_tbl_entry memory.\n"); + free(vlan_tbl->port_vlan_tbl.entry); ++ vlan_tbl->port_vlan_tbl.entry = NULL; + return -ENOMEM; + } + +@@ -872,16 +877,22 @@ static void hikp_nic_ppp_data_free(union nic_ppp_feature_info *ppp_data) + if (strcmp(ppp_cmd->feature_name, NIC_PPP_MAC_TBL_NAME) == 0) { + mac_tbl = &ppp_data->mac_tbl; + free(mac_tbl->uc_tbl.entry); ++ mac_tbl->uc_tbl.entry = NULL; + free(mac_tbl->mc_tbl.entry); ++ mac_tbl->mc_tbl.entry = NULL; + } else if (strcmp(ppp_cmd->feature_name, NIC_PPP_VLAN_TBL_NAME) == 0) { + vlan_tbl = &ppp_data->vlan_tbl; + free(vlan_tbl->vf_vlan_tbl.entry); ++ vlan_tbl->vf_vlan_tbl.entry = NULL; + free(vlan_tbl->port_vlan_tbl.entry); ++ vlan_tbl->port_vlan_tbl.entry = NULL; + } else if (strcmp(ppp_cmd->feature_name, NIC_PPP_MNG_TBL_NAME) == 0) { + mng_tbl = &ppp_data->mng_tbl; + free(mng_tbl->entry); ++ mng_tbl->entry = NULL; + } + free(ppp_data); ++ ppp_data = NULL; + } + + static int hikp_nic_ppp_check_optional_param(struct major_cmd_ctrl *self, +diff --git a/net/nic/nic_qos/hikp_nic_qos.c b/net/nic/nic_qos/hikp_nic_qos.c +index e3f0e9c..a09b4f1 100644 +--- a/net/nic/nic_qos/hikp_nic_qos.c ++++ b/net/nic/nic_qos/hikp_nic_qos.c +@@ -98,12 +98,12 @@ static void hikp_nic_qos_show_dcb_info(const void *data) + printf("PFC configuration\n"); + printf(" PFC enable:"); + for (up = 0; up < HIKP_NIC_MAX_USER_PRIO_NUM; up++) +- printf(" %d", HI_BIT(up) & pfc->pfc_en ? 1 : 0); ++ printf(" %u", HI_BIT(up) & pfc->pfc_en ? 1 : 0); + + printf("\n"); + printf(" TC enable:"); + for (tc_no = 0; tc_no < HIKP_NIC_MAX_TC_NUM; tc_no++) +- printf(" %d", HI_BIT(tc_no) & pfc->hw_tc_map ? 1 : 0); ++ printf(" %u", HI_BIT(tc_no) & pfc->hw_tc_map ? 1 : 0); + + printf("\n"); + printf("ETS configuration\n"); +@@ -176,7 +176,7 @@ static int hikp_nic_qos_get_blk(struct hikp_cmd_header *req_header, + rsp = (struct nic_qos_rsp *)cmd_ret->rsp_data; + if (rsp->rsp_head.cur_blk_size > buf_len) { + HIKP_ERROR_PRINT("nic_qos block-%u copy size error, " +- "buffer size=%u, data size=%u.\n", ++ "buffer size=%zu, data size=%u.\n", + req_data->block_id, buf_len, rsp->rsp_head.cur_blk_size); + ret = -EINVAL; + goto out; +@@ -198,7 +198,6 @@ static int hikp_nic_query_qos_feature(struct hikp_cmd_header *req_header, const + size_t buf_len = sizeof(*data); + uint32_t total_blk_size; + uint8_t total_blk_num; +- uint8_t blk_num = 0; + uint8_t blk_id = 0; + int ret; + +@@ -272,7 +271,7 @@ static void hikp_nic_qos_cmd_execute(struct major_cmd_ctrl *self) + } + + memset(revision_id, 0, MAX_PCI_ID_LEN + 1); +- ret = get_revision_id_by_bdf(bdf, revision_id); ++ ret = get_revision_id_by_bdf(bdf, revision_id, sizeof(g_qos_param.revision_id)); + // show pfc threshold as default if get revision_id error + if (ret) + strncpy(g_qos_param.revision_id, HIKP_IEP_REVISION, +diff --git a/net/nic/nic_queue/hikp_nic_queue.c b/net/nic/nic_queue/hikp_nic_queue.c +index f229e09..fa3b9d3 100644 +--- a/net/nic/nic_queue/hikp_nic_queue.c ++++ b/net/nic/nic_queue/hikp_nic_queue.c +@@ -248,7 +248,7 @@ static int hikp_nic_queue_get_blk(struct hikp_cmd_header *req_header, + rsp = (struct nic_queue_rsp *)cmd_ret->rsp_data; + if (rsp->rsp_head.cur_blk_size > buf_len) { + HIKP_ERROR_PRINT("nic_queue block-%u copy size error, " +- "buffer size=%u, data size=%u.\n", ++ "buffer size=%zu, data size=%u.\n", + req_data->block_id, buf_len, rsp->rsp_head.cur_blk_size); + ret = -EINVAL; + goto out; +@@ -340,7 +340,6 @@ static bool hikp_nic_queue_check_feature_para_vaild(const struct queue_feature_c + + static void hikp_nic_queue_cmd_execute(struct major_cmd_ctrl *self) + { +- struct bdf_t *bdf = &g_queue_param.target.bdf; + const struct queue_feature_cmd *queue_cmd; + union nic_queue_feature_info *queue_data; + struct hikp_cmd_header req_header = {0}; +diff --git a/net/nic/nic_rss/hikp_nic_rss.c b/net/nic/nic_rss/hikp_nic_rss.c +index 5e4d261..ff1cfd2 100644 +--- a/net/nic/nic_rss/hikp_nic_rss.c ++++ b/net/nic/nic_rss/hikp_nic_rss.c +@@ -366,7 +366,7 @@ static int hikp_nic_rss_get_blk(struct hikp_cmd_header *req_header, + rsp = (struct nic_rss_rsp *)cmd_ret->rsp_data; + if (rsp->rsp_head.cur_blk_size > buf_len) { + HIKP_ERROR_PRINT("nic_rss block-%u copy size error, " +- "buffer size=%u, data size=%u.\n", ++ "buffer size=%zu, data size=%u.\n", + req_data->block_id, buf_len, rsp->rsp_head.cur_blk_size); + ret = -EINVAL; + goto out; +@@ -388,7 +388,6 @@ static int hikp_nic_query_rss_feature(struct hikp_cmd_header *req_header, const + size_t buf_len = sizeof(*data); + uint32_t total_blk_size; + uint8_t total_blk_num; +- uint8_t blk_num = 0; + uint8_t blk_id = 0; + int ret; + +diff --git a/net/roce/roce_ext_common/hikp_roce_ext_common.c b/net/roce/roce_ext_common/hikp_roce_ext_common.c +index d5ae64a..3a0c1ae 100644 +--- a/net/roce/roce_ext_common/hikp_roce_ext_common.c ++++ b/net/roce/roce_ext_common/hikp_roce_ext_common.c +@@ -15,11 +15,15 @@ + + static void hikp_roce_ext_reg_data_free(struct reg_data *reg) + { +- if (reg->offset) ++ if (reg->offset) { + free(reg->offset); ++ reg->offset = NULL; ++ } + +- if (reg->data) ++ if (reg->data) { + free(reg->data); ++ reg->data = NULL; ++ } + } + + static void hikp_roce_ext_cmd_ret_free(struct hikp_cmd_ret *cmd_ret) +@@ -118,7 +122,7 @@ static int hikp_roce_ext_get_res(enum roce_cmd_type cmd_type, + reg->offset = (uint32_t *)calloc(res_head->total_block_num, sizeof(uint32_t)); + reg->data = (uint32_t *)calloc(res_head->total_block_num, sizeof(uint32_t)); + if ((reg->offset == NULL) || (reg->data == NULL)) { +- printf("hikptool roce_%s alloc log memmory 0x%x failed!\n", ++ printf("hikptool roce_%s alloc log memmory 0x%zx failed!\n", + cmd_name, max_size); + ret = -ENOMEM; + hikp_roce_ext_reg_data_free(reg); +@@ -128,7 +132,7 @@ static int hikp_roce_ext_get_res(enum roce_cmd_type cmd_type, + + cur_size = res_head->cur_block_num * sizeof(uint32_t); + if (cur_size > max_size) { +- printf("hikptool roce_%s log data copy size error, data size: 0x%x, max size: 0x%x\n", ++ printf("hikptool roce_%s log data copy size error, data size: 0x%zx, max size: 0x%zx\n", + cmd_name, cur_size, max_size); + ret = -EINVAL; + hikp_roce_ext_reg_data_free(reg); +diff --git a/net/roce/roce_gmv/hikp_roce_gmv.c b/net/roce/roce_gmv/hikp_roce_gmv.c +index d65dc82..36ba665 100644 +--- a/net/roce/roce_gmv/hikp_roce_gmv.c ++++ b/net/roce/roce_gmv/hikp_roce_gmv.c +@@ -44,16 +44,16 @@ static int hikp_roce_gmv_target(struct major_cmd_ctrl *self, const char *argv) + static int hikp_roce_gmv_idxget(struct major_cmd_ctrl *self, const char *argv) + { + char *endptr = NULL; +- int index; ++ uint64_t index; + +- index = strtol(argv, &endptr, 0); ++ index = strtoul(argv, &endptr, 0); + if ((endptr <= argv) || (*endptr != '\0') || +- (index < 0) || (index >= ROCE_MAX_HIKPTOOL_GMV)) { ++ (index >= ROCE_MAX_HIKPTOOL_GMV)) { + snprintf(self->err_str, sizeof(self->err_str), "Invalid gmv_index."); + self->err_no = -EINVAL; + return -EINVAL; + } +- g_roce_gmv_param.gmv_index = index; ++ g_roce_gmv_param.gmv_index = (uint32_t)index; + + return 0; + } +diff --git a/net/roce/roce_mdb/hikp_roce_mdb.c b/net/roce/roce_mdb/hikp_roce_mdb.c +index 04af817..374f100 100644 +--- a/net/roce/roce_mdb/hikp_roce_mdb.c ++++ b/net/roce/roce_mdb/hikp_roce_mdb.c +@@ -89,7 +89,6 @@ static void hikp_roce_mdb_execute_origin(struct major_cmd_ctrl *self) + struct roce_mdb_rsp_data *mdb_rsp = NULL; + struct hikp_cmd_ret *cmd_ret = NULL; + uint32_t reg_num; +- int ret; + + self->err_no = hikp_roce_mdb_get_data(&cmd_ret, 0); + if (self->err_no) { +diff --git a/net/roce/roce_qmm/hikp_roce_qmm.c b/net/roce/roce_qmm/hikp_roce_qmm.c +index d127264..e440b82 100644 +--- a/net/roce/roce_qmm/hikp_roce_qmm.c ++++ b/net/roce/roce_qmm/hikp_roce_qmm.c +@@ -45,16 +45,16 @@ static int hikp_roce_qmm_target(struct major_cmd_ctrl *self, const char *argv) + static int hikp_roce_qmm_bank_get(struct major_cmd_ctrl *self, const char *argv) + { + char *endptr = NULL; +- int bank_num; ++ uint64_t bank_num; + +- bank_num = strtol(argv, &endptr, 0); +- if ((endptr <= argv) || (*endptr != '\0') || bank_num > QMM_BANK_NUM || bank_num < 0) { ++ bank_num = strtoul(argv, &endptr, 0); ++ if ((endptr <= argv) || (*endptr != '\0') || bank_num > QMM_BANK_NUM) { + snprintf(self->err_str, sizeof(self->err_str), "Invalid bank number!\n"); + self->err_no = -EINVAL; + return -EINVAL; + } + +- g_roce_qmm_param.bank_id = bank_num; ++ g_roce_qmm_param.bank_id = (uint32_t)bank_num; + return 0; + } + +diff --git a/net/roce/roce_scc/hikp_roce_scc.c b/net/roce/roce_scc/hikp_roce_scc.c +index e8e166d..fe08873 100644 +--- a/net/roce/roce_scc/hikp_roce_scc.c ++++ b/net/roce/roce_scc/hikp_roce_scc.c +@@ -150,7 +150,7 @@ static int hikp_roce_scc_get_total_data_num(struct roce_scc_head *res_head, + *offset = (uint32_t *)calloc(1, max_size); + *data = (uint32_t *)calloc(1, max_size); + if ((*offset == NULL) || (*data == NULL)) { +- printf("hikptool roce_scc alloc log memmory 0x%x failed\n", max_size); ++ printf("hikptool roce_scc alloc log memmory 0x%zx failed\n", max_size); + ret = -ENOMEM; + goto get_data_error; + } +@@ -158,7 +158,7 @@ static int hikp_roce_scc_get_total_data_num(struct roce_scc_head *res_head, + cur_size = roce_scc_res->head.cur_block_num * sizeof(uint32_t); + if (cur_size > max_size) { + printf("hikptool roce_scc log data copy size error, " +- "data size: 0x%x, max size: 0x%x\n", cur_size, max_size); ++ "data size: 0x%zx, max size: 0x%zx\n", cur_size, max_size); + ret = -EINVAL; + goto get_data_error; + } +@@ -194,7 +194,7 @@ static int hikp_roce_scc_get_next_data(struct roce_scc_head *res_head, + if (cur_size > data_size) { + hikp_roce_scc_cmd_ret_free(&cmd_ret); + printf("hikptool roce_scc next log data copy size error, " +- "data size: 0x%x, max size: 0x%x\n", cur_size, data_size); ++ "data size: 0x%zx, max size: 0x%zx\n", cur_size, data_size); + return -EINVAL; + } + memcpy(*offset, roce_scc_res->reg_data.offset, cur_size); +diff --git a/net/roce/roce_timer/hikp_roce_timer.c b/net/roce/roce_timer/hikp_roce_timer.c +index a78d383..05ad3e1 100644 +--- a/net/roce/roce_timer/hikp_roce_timer.c ++++ b/net/roce/roce_timer/hikp_roce_timer.c +@@ -149,7 +149,7 @@ static void hikp_roce_timer_execute(struct major_cmd_ctrl *self) + int (*func[])(struct major_cmd_ctrl *self) = { + hikp_roce_timer_show_cqc, hikp_roce_timer_show_qpc + }; +- char *function[] = {"show cqc", "show qpc"}; ++ const char *function[] = {"show cqc", "show qpc"}; + int i = 0; + int ret; + +diff --git a/net/roce/roce_trp/hikp_roce_trp.c b/net/roce/roce_trp/hikp_roce_trp.c +index 4591a47..fad3317 100644 +--- a/net/roce/roce_trp/hikp_roce_trp.c ++++ b/net/roce/roce_trp/hikp_roce_trp.c +@@ -85,20 +85,17 @@ static int hikp_roce_trp_bank_get(struct major_cmd_ctrl *self, const char *argv) + + static int hikp_roce_trp_bank_check(void) + { +- uint32_t temp; +- +- temp = g_roce_trp_param_t.bank_id; + switch (g_roce_trp_param_t.sub_cmd) { + case (COMMON): +- if (temp > TRP_MAX_BANK_NUM || temp < 0) ++ if (g_roce_trp_param_t.bank_id > TRP_MAX_BANK_NUM) + return -EINVAL; + break; + case (PAYL): +- if (temp > PAYL_MAX_BANK_NUM || temp < 0) ++ if (g_roce_trp_param_t.bank_id > PAYL_MAX_BANK_NUM) + return -EINVAL; + break; + case (GEN_AC): +- if (temp > GAC_MAX_BANK_NUM || temp < 0) ++ if (g_roce_trp_param_t.bank_id > GAC_MAX_BANK_NUM) + return -EINVAL; + break; + default: +@@ -173,7 +170,8 @@ static int hikp_roce_trp_get_total_data_num(struct roce_trp_head *res_head, + *offset = (uint32_t *)calloc(1, max_size); + *data = (uint32_t *)calloc(1, max_size); + if ((*offset == NULL) || (*data == NULL)) { +- printf("hikptool roce_trp alloc log memmory 0x%x failed\n", max_size); ++ printf("hikptool roce_trp alloc log memmory 0x%zx failed\n", max_size); ++ hikp_roce_trp_reg_data_free(offset, data); + ret = -ENOMEM; + goto get_data_error; + } +@@ -181,7 +179,8 @@ static int hikp_roce_trp_get_total_data_num(struct roce_trp_head *res_head, + cur_size = roce_trp_res->head.cur_block_num * sizeof(uint32_t); + if (cur_size > max_size) { + printf("hikptool roce_trp log data copy size error, " +- "data size: 0x%x, max size: 0x%x\n", cur_size, max_size); ++ "data size: 0x%zx, max size: 0x%zx\n", cur_size, max_size); ++ hikp_roce_trp_reg_data_free(offset, data); + ret = -EINVAL; + goto get_data_error; + } +@@ -218,7 +217,7 @@ static int hikp_roce_trp_get_next_data(struct roce_trp_head *res_head, + if (cur_size > data_size) { + hikp_roce_trp_cmd_ret_free(&cmd_ret); + printf("hikptool roce_trp next log data copy size error, " +- "data size: 0x%x, max size: 0x%x\n", cur_size, data_size); ++ "data size: 0x%zx, max size: 0x%zx\n", cur_size, data_size); + return -EINVAL; + } + memcpy(*offset, roce_trp_res->reg_data.offset, cur_size); +@@ -268,7 +267,6 @@ static void hikp_roce_trp_execute(struct major_cmd_ctrl *self) + if (self->err_no) { + snprintf(self->err_str, sizeof(self->err_str), + "get the first roce_trp block dfx fail."); +- hikp_roce_trp_reg_data_free(&offset, &data); + return; + } + total_block_num = res_head.total_block_num; +diff --git a/net/roce/roce_tsp/hikp_roce_tsp.c b/net/roce/roce_tsp/hikp_roce_tsp.c +index 9469e4d..5bb2649 100644 +--- a/net/roce/roce_tsp/hikp_roce_tsp.c ++++ b/net/roce/roce_tsp/hikp_roce_tsp.c +@@ -84,16 +84,13 @@ static int hikp_roce_tsp_bank_get(struct major_cmd_ctrl *self, const char *argv) + + static int hikp_roce_tsp_bank_check(void) + { +- uint32_t temp; +- +- temp = g_roce_tsp_param_t.bank_id; + switch (g_roce_tsp_param_t.sub_cmd_code) { + case (COMMON): +- if ((temp > MAX_TSP_BANK_NUM) || temp < 0) ++ if (g_roce_tsp_param_t.bank_id > MAX_TSP_BANK_NUM) + return -EINVAL; + break; + case (TGP_TMP): +- if ((temp > MAX_TGP_TMP_BANK_NUM) || temp < 0) ++ if (g_roce_tsp_param_t.bank_id > MAX_TGP_TMP_BANK_NUM) + return -EINVAL; + break; + default: +diff --git a/net/ub/ub_crd/hikp_ub_crd.c b/net/ub/ub_crd/hikp_ub_crd.c +index e207ea2..0e47b5b 100644 +--- a/net/ub/ub_crd/hikp_ub_crd.c ++++ b/net/ub/ub_crd/hikp_ub_crd.c +@@ -64,7 +64,6 @@ static int hikp_ub_query_crd(void) + 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"}, +diff --git a/net/ub/ub_ppp/hikp_unic_ppp.c b/net/ub/ub_ppp/hikp_unic_ppp.c +index ccba4e0..bf0c026 100644 +--- a/net/ub/ub_ppp/hikp_unic_ppp.c ++++ b/net/ub/ub_ppp/hikp_unic_ppp.c +@@ -191,6 +191,7 @@ static int hikp_unic_ppp_alloc_guid_tbl_entry(const struct hikp_unic_ppp_hw_reso + 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); ++ guid_tbl->uc_tbl.entry = NULL; + return -ENOMEM; + } + +@@ -399,13 +400,17 @@ static void hikp_unic_ppp_data_free(union unic_ppp_feature_info *unic_ppp_data) + if (g_unic_ppp_param.feature_idx == UNIC_PPP_IP_FEATURE_IDX) { + ip_tbl = &unic_ppp_data->ip_tbl; + free(ip_tbl->entry); ++ ip_tbl->entry = NULL; + } 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); ++ guid_tbl->uc_tbl.entry = NULL; + free(guid_tbl->mc_tbl.entry); ++ guid_tbl->mc_tbl.entry = NULL; + } + + free(unic_ppp_data); ++ unic_ppp_data = NULL; + } + + static void hikp_unic_ppp_cmd_execute(struct major_cmd_ctrl *self) +diff --git a/ossl/ossl_user_linux.c b/ossl/ossl_user_linux.c +index 8266a19..9dee61c 100644 +--- a/ossl/ossl_user_linux.c ++++ b/ossl/ossl_user_linux.c +@@ -47,7 +47,6 @@ int uda_realpath(const char *file_dir, char *format_dir) + + int uda_fcntl(const char *lock_file, uint32_t operation, int *fd) + { +- uint32_t f_opt = 0; + int fd_t = 0; + int ret; + +diff --git a/pcie/func_lib/pcie_func/pcie_link_ltssm.c b/pcie/func_lib/pcie_func/pcie_link_ltssm.c +index 9697529..66226e0 100644 +--- a/pcie/func_lib/pcie_func/pcie_link_ltssm.c ++++ b/pcie/func_lib/pcie_func/pcie_link_ltssm.c +@@ -213,7 +213,7 @@ static int pcie_print_ltssm_trace(const uint64_t *ltssm_input, uint32_t ltssm_nu + (uint32_t)ltssm_val.bits.any_change_pipe_req, + (uint32_t)ltssm_val.bits.rxl0s_st, + (uint32_t)ltssm_val.bits.train_bit_map1, +- (((uint32_t)ltssm_val.bits.rxl0s_st) << 2) | ++ (((uint32_t)ltssm_val.bits.rxl0s_st) << GEN5_BIT_OFFEST) | + ((uint32_t)ltssm_val.bits.mac_rate), + (uint32_t)ltssm_val.bits.duration_counter, + (uint32_t)ltssm_val.bits.ltssm_state, +@@ -271,7 +271,6 @@ int pcie_ltssm_trace_clear(uint32_t port_id) + + int pcie_ltssm_link_status_get(uint32_t port_id) + { +- uint32_t i; + union pcie_link_info reg_val; + struct hikp_cmd_header req_header; + struct hikp_cmd_ret *cmd_ret; +diff --git a/pcie/func_lib/pcie_func/pcie_link_ltssm.h b/pcie/func_lib/pcie_func/pcie_link_ltssm.h +index 8f3502b..cc51501 100644 +--- a/pcie/func_lib/pcie_func/pcie_link_ltssm.h ++++ b/pcie/func_lib/pcie_func/pcie_link_ltssm.h +@@ -19,6 +19,7 @@ + #define TRACE_STR_NUM 0x20 + #define TRACER_DEPTH 65 + #define PM_TRACE_STR_NUM 0x28 ++#define GEN5_BIT_OFFEST 2 + + struct pcie_ltssm_num_string { + int ltssm; +diff --git a/pcie/func_lib/pcie_func/pcie_reg_dump.c b/pcie/func_lib/pcie_func/pcie_reg_dump.c +index aac3843..b8c2241 100644 +--- a/pcie/func_lib/pcie_func/pcie_reg_dump.c ++++ b/pcie/func_lib/pcie_func/pcie_reg_dump.c +@@ -405,7 +405,7 @@ static int pcie_create_dumpreg_log_file(uint32_t port_id, uint32_t dump_level) + + (void)remove((const char *)file_name); + /* Add write permission to the file */ +- fd_file = open(file_name, O_RDWR | O_SYNC | O_CREAT, 0640); ++ fd_file = open(file_name, O_RDWR | O_SYNC | O_CREAT, 0600); + if (fd_file < 0) { + Err("PCIe DUMPREG", "open %s failed.\n", file_name); + return -EPERM; +@@ -419,7 +419,7 @@ static int pcie_close_dumpreg_log_file(void) + { + int ret; + +- ret = fchmod(g_pcie_dumpreg_fd, 0440); ++ ret = fchmod(g_pcie_dumpreg_fd, 0400); + close(g_pcie_dumpreg_fd); + /* Revoke write permission of file */ + g_pcie_dumpreg_fd = -1; +diff --git a/pcie/func_lib/pcie_func/pcie_statistics.c b/pcie/func_lib/pcie_func/pcie_statistics.c +index 40e5645..ed42cec 100644 +--- a/pcie/func_lib/pcie_func/pcie_statistics.c ++++ b/pcie/func_lib/pcie_func/pcie_statistics.c +@@ -63,7 +63,7 @@ static int port_distribution_rsp_data_check(const struct hikp_cmd_ret *cmd_ret, + } + + static int pcie_portid_serdes_relation(const struct pcie_macro_info *macro_info, +- uint32_t macro_num, uint32_t ndie_id) ++ uint32_t macro_num, uint32_t ndie_id) + { + uint32_t i, j; + +@@ -90,7 +90,7 @@ int pcie_port_distribution_get(uint32_t chip_id) + struct hikp_cmd_header req_header; + struct hikp_cmd_ret *cmd_ret; + struct pcie_info_req_para req_data = { 0 }; +- uint32_t src_size, dst_size, pair_num; ++ uint32_t pair_num; + struct pcie_port_info *port_info; + uint32_t i; + int ret; +diff --git a/sas/sas_func/sas_read_dev.c b/sas/sas_func/sas_read_dev.c +index 3a3db07..670e2d4 100644 +--- a/sas/sas_func/sas_read_dev.c ++++ b/sas/sas_func/sas_read_dev.c +@@ -78,8 +78,6 @@ static void print_dev_link(const uint32_t *reg_save, uint32_t reg_num) + + static void sas_print_dev(const uint32_t *reg_save, uint32_t reg_num, uint32_t cmd_type) + { +- uint32_t i; +- + if (reg_num == 0) { + printf("SAS device is failed\n"); + return; +diff --git a/sas/sas_func/sas_read_dqe.c b/sas/sas_func/sas_read_dqe.c +index dbd30f3..7d49c0a 100644 +--- a/sas/sas_func/sas_read_dqe.c ++++ b/sas/sas_func/sas_read_dqe.c +@@ -57,7 +57,7 @@ static void print_dqe_info(const void *reg_save, uint32_t reg_num) + printf("TLR_Ctrl: %u\n", dqe->dw0.TLR_Ctrl); + printf("Phy_ID: %u\n", dqe->dw0.Phy_ID); + printf("Force_Phy: %u\n", dqe->dw0.Force_Phy); +- printf("PORT: 0x%llx\n", dqe->dw0.PORT); ++ printf("PORT: 0x%x\n", dqe->dw0.PORT); + printf("PRI: %u\n", dqe->dw0.PRI); + printf("CMD: %u\n", dqe->dw0.CMD); + +@@ -68,7 +68,7 @@ static void print_dqe_info(const void *reg_save, uint32_t reg_num) + printf("Reset: %u\n", dqe->dw1.Reset); + printf("PIR_Present: %u\n", dqe->dw1.PIR_Present); + printf("Enable_Transport_Layer_Retry: %u\n", dqe->dw1.Enable_Transport_Layer_Retry); +- printf("Verify_Data_Transfer_Length: 0x%llx\n", dqe->dw1.Verify_Data_Transfer_Length); ++ printf("Verify_Data_Transfer_Length: 0x%x\n", dqe->dw1.Verify_Data_Transfer_Length); + printf("Frame_Type: %u\n", dqe->dw1.Frame_Type); + printf("Device_ID: %u\n", dqe->dw1.Device_ID); + +diff --git a/sas/user_cmd/cmd_code/sas_cmd_dqe.c b/sas/user_cmd/cmd_code/sas_cmd_dqe.c +index 4a9547a..26bf0eb 100644 +--- a/sas/user_cmd/cmd_code/sas_cmd_dqe.c ++++ b/sas/user_cmd/cmd_code/sas_cmd_dqe.c +@@ -44,7 +44,6 @@ static int sas_dqe_info(struct major_cmd_ctrl *self, const char *argv) + static int sas_set_queue_id(struct major_cmd_ctrl *self, const char *argv) + { + int ret; +- uint32_t val = 0; + + ret = sas_set_que_id(self, argv); + if (ret || sas_get_que_id() >= SAS_QUEUE_NUM) { +diff --git a/sas/user_cmd/cmd_code/sas_cmd_dump.c b/sas/user_cmd/cmd_code/sas_cmd_dump.c +index 4f2cfea..e7dedf0 100644 +--- a/sas/user_cmd/cmd_code/sas_cmd_dump.c ++++ b/sas/user_cmd/cmd_code/sas_cmd_dump.c +@@ -42,7 +42,6 @@ static int sas_dump_global(struct major_cmd_ctrl *self, const char *argv) + static int sas_dump_phyx(struct major_cmd_ctrl *self, char const *argv) + { + int ret; +- uint32_t val = 0; + + (void)sas_set_cmd_type(DUMP_PHYX); + ret = sas_set_phy_id(self, argv); +diff --git a/serdes/hikp_serdes.c b/serdes/hikp_serdes.c +index 320ded2..4afcb9b 100644 +--- a/serdes/hikp_serdes.c ++++ b/serdes/hikp_serdes.c +@@ -322,7 +322,7 @@ static void hikp_serdes_info_cmd_execute(struct major_cmd_ctrl *self) + SERDES_OUTPUT_MAX_SIZE) { + self->err_no = -EINVAL; + snprintf(self->err_str, sizeof(self->err_str), +- "serdes_info rsp_data data copy size error, data size:0x%x max size:0x%x.", ++ "serdes_info rsp_data data copy size error, data size:0x%zx max size:0x%x.", + (cmd_ret->rsp_data_num * sizeof(uint32_t) - out_out_header_size), + SERDES_OUTPUT_MAX_SIZE); + goto err_out; +@@ -480,7 +480,7 @@ static void hikp_serdes_dump_cmd_execute(struct major_cmd_ctrl *self) + SERDES_OUTPUT_MAX_SIZE) { + self->err_no = -EINVAL; + snprintf(self->err_str, sizeof(self->err_str), +- "serdes_dump rsp_data data copy size error, data size:0x%x max size:0x%x.", ++ "serdes_dump rsp_data data copy size error, data size:0x%zx max size:0x%x.", + (cmd_ret->rsp_data_num * sizeof(uint32_t) - out_out_header_size), + SERDES_OUTPUT_MAX_SIZE); + goto err_out; +diff --git a/socip/hikp_socip_dumpreg.c b/socip/hikp_socip_dumpreg.c +index 0153dd9..7b11523 100644 +--- a/socip/hikp_socip_dumpreg.c ++++ b/socip/hikp_socip_dumpreg.c +@@ -108,7 +108,6 @@ static bool check_socip_dumpreg_param(void) + static void dump_reg_info(const uint32_t *reg_data, uint32_t data_num) + { + #define ONE_LINE_PRINT_DATA_NUM 4 +- struct dump_reg_param_t *param = &g_dump_reg_param[0]; + uint32_t i; + + for (i = 0; i < data_num; i++) { +diff --git a/tool_lib/op_logs.c b/tool_lib/op_logs.c +index d91ddb0..f57f5fd 100644 +--- a/tool_lib/op_logs.c ++++ b/tool_lib/op_logs.c +@@ -29,7 +29,6 @@ static void op_log_write(const char *log_data) + { + size_t w_size; + FILE *fd; +- int ret; + + if (strlen(g_op_log) == 0) + return; +@@ -108,8 +107,6 @@ static int op_log_add_time_to_log(char *log_base, int *offset, uint32_t flag) + struct timeval tv; + struct tm ptm; + int len = 0; +- long usec; +- long sec; + int ret; + + (void)gettimeofday(&tv, NULL); +@@ -118,12 +115,18 @@ static int op_log_add_time_to_log(char *log_base, int *offset, uint32_t flag) + g_tv = tv; + len = (int)strftime(log_base + *offset, (OP_LOG_FILE_W_MAXSIZE + 1 - *offset), + OP_LOG_TIME_TEMP, &ptm); ++ if ((*offset + len) >= (OP_LOG_FILE_W_MAXSIZE + 1)) ++ return -ENOMEM; ++ + ret = snprintf(log_base + *offset + len, + (OP_LOG_FILE_W_MAXSIZE + 1 - *offset - len), OP_LOG_SEC_TIME_TEMP, + tv.tv_sec + tv.tv_usec / OP_LOG_SEC_AND_MICROSEC_TRANS); +- } else if (flag == LOG_FLAG_ONLY_TIME) { ++ } else { + len = (int)strftime(log_base + *offset, (OP_LOG_FILE_W_MAXSIZE + 1 - *offset), + OP_LOG_RESULT_TIME_TEMP, &ptm); ++ if ((*offset + len) >= (OP_LOG_FILE_W_MAXSIZE + 1)) ++ return -ENOMEM; ++ + ret = snprintf(log_base + *offset + len, + (OP_LOG_FILE_W_MAXSIZE + 1 - *offset - len), + OP_LOG_SEC_TIME_TEMP, +@@ -157,7 +160,6 @@ static int op_log_file_rollback(const char *op_log_backup, const char *log_dir) + char rollback_log[OP_LOG_FILE_W_MAXSIZE + 1] = {0}; + int offset = 0; + int ret; +- int len; + + ret = file_rollback(g_op_log, op_log_backup, OP_LOG_FILE_MAX_SIZE); + if (ret) { +@@ -280,10 +282,14 @@ void op_log_record_input(const int argc, const char **argv) + + arg = input_str; + for (i = 0; i < argc; i++) { +- snprintf(arg, (sizeof(input_str) - (arg - input_str)), "%s ", argv[i]); ++ ret = snprintf(arg, (sizeof(input_str) - (arg - input_str)), "%s ", argv[i]); ++ if (ret < 0 || ret >= (sizeof(input_str) - (arg - input_str))) ++ return; ++ + arg = arg + strlen(argv[i]) + 1; + } + input_str[strlen(input_str) - 1] = 0; ++ + arr_size = HIKP_ARRAY_SIZE(log_info); + for (i = 0; i < arr_size; i++) { + ret = snprintf(g_input_buf + offset, (OP_LOG_FILE_W_MAXSIZE + 1 - offset), +diff --git a/tool_lib/tool_cmd.c b/tool_lib/tool_cmd.c +index 43a3b61..db54f0f 100644 +--- a/tool_lib/tool_cmd.c ++++ b/tool_lib/tool_cmd.c +@@ -186,7 +186,6 @@ void command_parse_and_excute(const int argc, const char **argv) + { + struct major_cmd_ctrl *major_cmd = get_major_cmd(); + int lock_fd; +- int check; + int ret; + + major_cmd->err_no = check_command_length(argc, argv); +diff --git a/tool_lib/tool_lib.c b/tool_lib/tool_lib.c +index ad4bb68..180418f 100644 +--- a/tool_lib/tool_lib.c ++++ b/tool_lib/tool_lib.c +@@ -337,6 +337,9 @@ bool tool_can_print(uint32_t interval, uint32_t burst, uint32_t *print_num, uint + { + uint64_t cur_time; + ++ if (!print_num || !last_time) ++ return false; ++ + cur_time = (uint64_t)time(NULL); + if ((*last_time + interval) == cur_time) + *print_num = 0; +-- +2.42.0.windows.2 + diff --git a/0053-hikptool-roce-Fix-the-infinite-loop-due-to-compatibi.patch b/0053-hikptool-roce-Fix-the-infinite-loop-due-to-compatibi.patch new file mode 100644 index 0000000000000000000000000000000000000000..27662ab0cbdc64d68e5992d9acae0cc102cde1d6 --- /dev/null +++ b/0053-hikptool-roce-Fix-the-infinite-loop-due-to-compatibi.patch @@ -0,0 +1,42 @@ +From 15e5379c7a1e041d8ea384f55c6cf77698646ac7 Mon Sep 17 00:00:00 2001 +From: Junxian Huang +Date: Tue, 7 Nov 2023 15:59:27 +0800 +Subject: hikptool/roce: Fix the infinite loop due to compatibility issue + +When a new-version hikptool sends a subcmd of caep ext registers to +an old-version FW which doesn't support the query of ext registers +yet, due to the lack of subcmd check in old-version FW, there will +be no error and register data will still be responsed to hikptool. + +In the new-version hikptool, a do-while loop is used to implement a +multi-round query, and the loop variable is updated based on the +cur_block_num responsed from FW. Since there is no error reported, +the new-version hikptool will parse the old-version data based on the +new-version data structure. This may cause the parsed cur_block_num +remains 0, and the loop becomes infinite. + +To fix this problem, add a check of the responsed cur_block_num. +If it's 0, return with an error code. + +Fixes: 8b3b68347165 ("hikptool/roce: Add a common frame for hikptool roce register query") +Signed-off-by: Junxian Huang +--- + net/roce/roce_ext_common/hikp_roce_ext_common.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/net/roce/roce_ext_common/hikp_roce_ext_common.c b/net/roce/roce_ext_common/hikp_roce_ext_common.c +index 3a0c1ae..5bc3ce6 100644 +--- a/net/roce/roce_ext_common/hikp_roce_ext_common.c ++++ b/net/roce/roce_ext_common/hikp_roce_ext_common.c +@@ -131,7 +131,7 @@ static int hikp_roce_ext_get_res(enum roce_cmd_type cmd_type, + } + + cur_size = res_head->cur_block_num * sizeof(uint32_t); +- if (cur_size > max_size) { ++ if (!cur_size || cur_size > max_size) { + printf("hikptool roce_%s log data copy size error, data size: 0x%zx, max size: 0x%zx\n", + cmd_name, cur_size, max_size); + ret = -EINVAL; +-- +2.30.0 + diff --git a/hikptool.spec b/hikptool.spec index dc0bb9ef1d8ed07b4568881630321ac2a2183201..0843f23e2b33af9da0d71fb79c77742dfc60e686 100644 --- a/hikptool.spec +++ b/hikptool.spec @@ -3,7 +3,7 @@ Name: hikptool Summary: A userspace tool for Linux providing problem location on Kunpeng chips Version: 1.0.0 -Release: 12 +Release: 13 License: MulanPSL2 Source: %{name}-%{version}.tar.gz ExclusiveOS: linux @@ -54,6 +54,21 @@ Patch0035: 0035-hikptool-support-to-query-pfc-storm-parameters.patch Patch0036: 0036-hikptool-add-sub-cmd-nic_torus-support.patch Patch0037: 0037-hikptool-optimized-display-the-hot-plug-card-info-in.patch Patch0038: 0038-hikptool-Update-the-tool-version-number-to-1.1.0.patch +Patch0039: 0039-hikptool-roce-Add-a-common-frame-for-hikptool-roce-r.patch +Patch0040: 0040-hikptool-roce-Add-roce_rst-cmd-for-reset-signal-regi.patch +Patch0041: 0041-hikptool-roce-Add-roce_global_cfg-cmd-for-global-con.patch +Patch0042: 0042-hikptool-roce-Add-roce_bond-cmd-for-bond-registers-q.patch +Patch0043: 0043-hikptool-roce-Add-ext-query-for-roce_caep-cmd.patch +Patch0044: 0044-hikptool-roce-Add-ext-query-for-roce_mdb-cmd.patch +Patch0045: 0045-hikptool-roce-Add-ext-query-for-roce_qmm-cmd.patch +Patch0046: 0046-hikptool-Querying-the-SerDes-Relationship-of-the-PCI.patch +Patch0047: 0047-hikptool-Remove-the-function-of-querying-SAS-device-.patch +Patch0048: 0048-hikptool-roce-Use-calloc-to-alloc-memory-for-array-i.patch +Patch0049: 0049-hikptool-roce-Fix-missing-check-of-reg-num-responsed.patch +Patch0050: 0050-hikptool-Change-the-unic_ppp-directory-to-ub_ppp.patch +Patch0051: 0051-hikptool-roce-Fix-the-wrong-maximum-of-gmv-index.patch +Patch0052: 0052-hikptool-Resolved-some-centralized-code-review-comme.patch +Patch0053: 0053-hikptool-roce-Fix-the-infinite-loop-due-to-compatibi.patch %description This package contains the hikptool @@ -106,6 +121,9 @@ fi /sbin/ldconfig %changelog +* Thu Nov 16 2023 veega2022 1.0.0-13 +- Synchronize the code and add the DFX of the roce module to resolve some review comments + * Fri Oct 20 2023 veega2022 1.0.0-12 - Added DFX for UB, NIC, MAC modules, fixed some bugs