The hikptool ub_link command is submitted for the first time. This command can be used to query the link state machine and status statistics during link establishment. Signed-off-by: Jianqiang Li <lijianqiang16@huawei.com> --- net/ub/ub_link/hikp_ub_link.c | 98 +++++++++++++++++++++++++++++++++++ net/ub/ub_link/hikp_ub_link.h | 53 +++++++++++++++++++ 2 files changed, 151 insertions(+) create mode 100644 net/ub/ub_link/hikp_ub_link.c create mode 100644 net/ub/ub_link/hikp_ub_link.h diff --git a/net/ub/ub_link/hikp_ub_link.c b/net/ub/ub_link/hikp_ub_link.c new file mode 100644 index 0000000..b6353f7 --- /dev/null +++ b/net/ub/ub_link/hikp_ub_link.c @@ -0,0 +1,98 @@ +/* + * Copyright (c) 2023 Hisilicon Technologies Co., Ltd. + * Hikptool is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * + * See the Mulan PSL v2 for more details. + */ + +#include "hikp_ub_link.h" + +static struct ub_link_param g_ub_link_param = { 0 }; + +static int hikp_ub_link_help(struct major_cmd_ctrl *self, const char *argv) +{ + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i <interface>\n"); + printf("\n %s\n", self->cmd_ptr->help_info); + printf(" Options:\n\n"); + printf(" %s, %-25s %s\n", "-h", "--help", "display this help and exit"); + printf(" %s, %-25s %s\n", "-i", "--interface=<interface>", + "device target or bdf id, e.g. ubn0 or 0000:35:00.0"); + printf("\n"); + return 0; +} + +static int hikp_ub_link_target(struct major_cmd_ctrl *self, const char *argv) +{ + self->err_no = tool_check_and_get_valid_bdf_id(argv, &(g_ub_link_param.target)); + if (self->err_no != 0) { + snprintf(self->err_str, sizeof(self->err_str), "Unknown device %s.", argv); + return self->err_no; + } + + return 0; +} + +static void hikp_ub_link_info_show(const struct ub_link_rsp *info) +{ + printf("%-32s %u\n", "mac id:", info->mac_id); + printf("%-32s %s\n", "hdlc link status:", info->hdlc_link ? "true" : "false"); + printf("%-32s %s\n", "hpcs link status:", info->hpcs_link ? "true" : "false"); + printf("%-32s 0x%08x\n", "hdlc_link_fsm register value:", info->hdlc_link_fsm); + printf("%-32s 0x%08x\n", "hpcs_link_fsm register value:", info->hpcs_link_fsm); +} + +static int hikp_ub_query_link_info(const struct bdf_t *bdf) +{ + struct hikp_cmd_header header = { 0 }; + struct ub_link_req_paras req = { 0 }; + struct hikp_cmd_ret *cmd_ret; + struct ub_link_rsp *rsp; + + req.bdf = *bdf; + hikp_cmd_init(&header, UB_MOD, GET_UB_LINK_INFO_CMD, UB_LINK_INFO_DUMP); + cmd_ret = hikp_cmd_alloc(&header, &req, sizeof(req)); + if (cmd_ret == NULL || cmd_ret->status != 0) { + free(cmd_ret); + cmd_ret = NULL; + return -EIO; + } + + rsp = (struct ub_link_rsp *)cmd_ret->rsp_data; + hikp_ub_link_info_show(rsp); + + free(cmd_ret); + cmd_ret = NULL; + return 0; +} + +static void hikp_ub_link_cmd_execute(struct major_cmd_ctrl *self) +{ + struct bdf_t *bdf = &g_ub_link_param.target.bdf; + int ret; + + ret = hikp_ub_query_link_info(bdf); + if (ret != 0) { + snprintf(self->err_str, sizeof(self->err_str), "fail to get link info."); + self->err_no = ret; + return; + } +} + +static void cmd_ub_link_init(void) +{ + struct major_cmd_ctrl *major_cmd = get_major_cmd(); + + major_cmd->option_count = 0; + major_cmd->execute = hikp_ub_link_cmd_execute; + + cmd_option_register("-h", "--help", false, hikp_ub_link_help); + cmd_option_register("-i", "--interface", true, hikp_ub_link_target); +} + +HIKP_CMD_DECLARE("ub_link", "get ub link information", cmd_ub_link_init); diff --git a/net/ub/ub_link/hikp_ub_link.h b/net/ub/ub_link/hikp_ub_link.h new file mode 100644 index 0000000..dec5129 --- /dev/null +++ b/net/ub/ub_link/hikp_ub_link.h @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2023 Hisilicon Technologies Co., Ltd. + * Hikptool is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * + * See the Mulan PSL v2 for more details. + */ + +/* + * Copyright (c) 2023 Hisilicon Technologies Co., Ltd. + * Hikptool is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * + * See the Mulan PSL v2 for more details. + */ + +#ifndef HIKP_UB_LINK_H +#define HIKP_UB_LINK_H + +#include "hikp_net_lib.h" + +enum ub_link_sub_cmd_type { + UB_LINK_INFO_DUMP = 0, +}; + +struct ub_link_param { + struct tool_target target; +}; + +struct ub_link_req_paras { + struct bdf_t bdf; +}; + +struct ub_link_rsp { + uint8_t mac_id; + uint8_t hdlc_link; + uint8_t hpcs_link; + uint8_t rsvd; + uint32_t hdlc_link_fsm; + uint32_t hpcs_link_fsm; +}; + +#endif /* HIKP_UB_LINK_H */ -- 2.36.1.windows.1

The hikptool ub_crd command is submitted for the first time. This command is used to query the letter of credit status by reading the register value. Signed-off-by: Jianqiang Li <lijianqiang16@huawei.com> --- net/ub/ub_crd/hikp_ub_crd.c | 133 ++++++++++++++++++++++++++++++++++++ net/ub/ub_crd/hikp_ub_crd.h | 44 ++++++++++++ 2 files changed, 177 insertions(+) create mode 100644 net/ub/ub_crd/hikp_ub_crd.c create mode 100644 net/ub/ub_crd/hikp_ub_crd.h diff --git a/net/ub/ub_crd/hikp_ub_crd.c b/net/ub/ub_crd/hikp_ub_crd.c new file mode 100644 index 0000000..d5d0015 --- /dev/null +++ b/net/ub/ub_crd/hikp_ub_crd.c @@ -0,0 +1,133 @@ +/* + * Copyright (c) 2023 Hisilicon Technologies Co., Ltd. + * Hikptool is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * + * See the Mulan PSL v2 for more details. + */ + +#include "hikp_ub_crd.h" + +static struct ub_crd_param g_ub_crd_param = { 0 }; + +static int hikp_ub_crd_help(struct major_cmd_ctrl *self, const char *argv) +{ + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i <interface>\n"); + printf("\n %s\n", self->cmd_ptr->help_info); + printf(" Options:\n\n"); + printf(" %s, %-25s %s\n", "-h", "--help", "display this help and exit"); + printf(" %s, %-25s %s\n", "-i", "--interface=<interface>", + "device target or bdf id, e.g. ubn0 or 0000:35:00.0"); + printf("\n"); + return 0; +} + +static int hikp_ub_crd_target(struct major_cmd_ctrl *self, const char *argv) +{ + self->err_no = tool_check_and_get_valid_bdf_id(argv, &(g_ub_crd_param.target)); + if (self->err_no) { + snprintf(self->err_str, sizeof(self->err_str), "Unknown device %s.", argv); + return self->err_no; + } + return 0; +} + +static int hikp_ub_show_crd(uint32_t off, struct ub_crd_rsp *crd_rsp, uint32_t num_rows, + char const *crds[][2]) +{ + int reg_index; + int i; + + for (i = 0; i < num_rows; i++) { + union cut_reg reg; + + reg_index = off + i; + reg.value = crd_rsp->cut_reg_value[reg_index]; + if (strcmp(crds[i][0], "NULL") != 0) + printf("%-28s : %#x\n", crds[i][0], reg.cut[0]); + + if (strcmp(crds[i][1], "NULL") != 0) + printf("%-28s : %#x\n", crds[i][1], reg.cut[1]); + } + return off + num_rows; +} + +static int hikp_ub_query_crd(void) +{ + struct hikp_cmd_header req_header = { 0 }; + struct ub_crd_req_para req_data = { 0 }; + struct hikp_cmd_ret *cmd_ret = NULL; + struct ub_crd_rsp *crd_rsp = NULL; + int offset; + int ret; + + char const *init_crds[][2] = { + {"CFG_REMOTE_ICRD", "CFG_REMOTE_LCRD"}, + {"CFG_REMOTE_CRD_VL6", "CFG_REMOTE_CRD_VL7"}, + {"CFG_REMOTE_CRD_VL4", "CFG_REMOTE_CRD_VL5"}, + {"CFG_REMOTE_CRD_VL2", "CFG_REMOTE_CRD_VL3"}, + {"CFG_REMOTE_CRD_VL0", "CFG_REMOTE_CRD_VL1"}, + {"CFG_REMOTE_CRD_VL8", "NULL"} }; + + char const *temp_crds[][2] = { + {"TX_LCRD_VNA_EXIST_NUM", "NULL"}, {"TX_ICRD_VNA_EXIST_NUM", "NULL"}, + {"TX_CRD_VN0_EXIST_NUM", "NULL"}, {"TX_CRD_VN1_EXIST_NUM", "NULL"}, + {"TX_CRD_VN2_EXIST_NUM", "NULL"}, {"TX_CRD_VN3_EXIST_NUM", "NULL"}, + {"TX_CRD_VN4_EXIST_NUM", "NULL"}, {"TX_CRD_VN5_EXIST_NUM", "NULL"}, + {"TX_CRD_VN6_EXIST_NUM", "NULL"}, {"TX_CRD_VN7_EXIST_NUM", "NULL"}, + {"TX_ACK_EXIST_NUM", "NULL"}, {"TX_ROH_LCRD_LOCAL_NUM", "NULL"} }; + + hikp_cmd_init(&req_header, UB_MOD, GET_UB_CRD_INFO_CMD, UB_CRD_INFO_DUMP); + req_data.bdf = g_ub_crd_param.target.bdf; + cmd_ret = hikp_cmd_alloc(&req_header, &req_data, sizeof(req_data)); + if (cmd_ret == NULL || cmd_ret->status != 0) { + free(cmd_ret); + cmd_ret = NULL; + return -EIO; + } + + crd_rsp = (struct ub_crd_rsp *)(cmd_ret->rsp_data); + + printf("******************** CREDIT CNT START ********************\n"); + printf("------------------- INIT CREDIT START -----------------\n"); + offset = hikp_ub_show_crd(0, crd_rsp, NUM_ROWS_INIT_CRDS, init_crds); + printf("------------------- INIT CREDIT END --------------------\n"); + printf("------------------- TEMP CREDIT START ------------------\n"); + offset = hikp_ub_show_crd(offset, crd_rsp, NUM_ROWS_TEMP_CRDS, temp_crds); + printf("------------------- TEMP CREDIT END --------------------\n"); + printf("********************* CREDIT CNT END *********************\n"); + + free(cmd_ret); + cmd_ret = NULL; + return 0; +} + +static void hikp_ub_crd_cmd_execute(struct major_cmd_ctrl *self) +{ + int ret; + + ret = hikp_ub_query_crd(); + if (ret != 0) { + snprintf(self->err_str, sizeof(self->err_str), "fail to get ub crd info."); + self->err_no = ret; + return; + } +} + +static void cmd_ub_crd_init(void) +{ + struct major_cmd_ctrl *major_cmd = get_major_cmd(); + + major_cmd->option_count = 0; + major_cmd->execute = hikp_ub_crd_cmd_execute; + + cmd_option_register("-h", "--help", false, hikp_ub_crd_help); + cmd_option_register("-i", "--interface", true, hikp_ub_crd_target); +} + +HIKP_CMD_DECLARE("ub_crd", "get ub crd information", cmd_ub_crd_init); diff --git a/net/ub/ub_crd/hikp_ub_crd.h b/net/ub/ub_crd/hikp_ub_crd.h new file mode 100644 index 0000000..5dfa38a --- /dev/null +++ b/net/ub/ub_crd/hikp_ub_crd.h @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2023 Hisilicon Technologies Co., Ltd. + * Hikptool is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * + * See the Mulan PSL v2 for more details. + */ + +#ifndef HIKP_UB_CRD_H +#define HIKP_UB_CRD_H + +#include "hikp_net_lib.h" + +#define MAX_CRD_SIZE 20 +#define NUM_ROWS_INIT_CRDS 6 +#define NUM_ROWS_TEMP_CRDS 12 + +enum ub_crd_sub_cmd_type { + UB_CRD_INFO_DUMP = 0, +}; + +union cut_reg { + uint32_t value; + uint16_t cut[2]; +}; + +struct ub_crd_param { + struct tool_target target; +}; + +struct ub_crd_req_para { + struct bdf_t bdf; +}; + +struct ub_crd_rsp { + uint32_t cut_reg_value[MAX_CRD_SIZE]; +}; + +#endif /* HIKP_UB_CRD_H */ -- 2.36.1.windows.1

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

From: m30045533 <moubingquan@huawei.com> --- pcie/func_lib/pcie_func/pcie_common.h | 1 + pcie/func_lib/pcie_func/pcie_link_ltssm.c | 180 +++++++++++++++++++++ pcie/func_lib/pcie_func/pcie_link_ltssm.h | 7 + pcie/usr_cmd/cmd_analysis/pcie_cmd_trace.c | 17 +- pcie/usr_cmd/interface/pcie_common_api.c | 1 + pcie/usr_cmd/interface/pcie_common_api.h | 1 + 6 files changed, 205 insertions(+), 2 deletions(-) diff --git a/pcie/func_lib/pcie_func/pcie_common.h b/pcie/func_lib/pcie_func/pcie_common.h index 434b4ed..98d9e25 100644 --- a/pcie/func_lib/pcie_func/pcie_common.h +++ b/pcie/func_lib/pcie_func/pcie_common.h @@ -28,6 +28,7 @@ enum pcie_trace_cmd_type { TRACE_CLEAR = 2, TRACE_INFO = 3, TRACE_MODE = 4, + TRACE_PM = 5, }; enum pcie_info_cmd_type { diff --git a/pcie/func_lib/pcie_func/pcie_link_ltssm.c b/pcie/func_lib/pcie_func/pcie_link_ltssm.c index d57688b..9c4b70c 100644 --- a/pcie/func_lib/pcie_func/pcie_link_ltssm.c +++ b/pcie/func_lib/pcie_func/pcie_link_ltssm.c @@ -43,6 +43,31 @@ union ltssm_state_reg { uint64_t val; }; +union pm_state_reg { + struct { + uint64_t pm_state : 6; /* [0:5] */ + uint64_t pm_clock : 18; /* [6:23] */ + uint64_t reserved1 : 8; /* [24:31] */ + uint64_t refclk_stable_vld : 1; /* [32] */ + uint64_t enter_l12_case : 1; /* [33] */ + uint64_t pm_t_dl_l2_gnt_timeout : 1; /* [34] */ + uint64_t pm_t_dl_l1_gnt_timeout : 1; /* [35] */ + uint64_t pm_t_dl_l0s_gnt_timeout : 1; /* [36] */ + uint64_t pm_t_dl_lastack_timeout : 1; /* [37] */ + uint64_t pme_turn_off_vld_hold : 1; /* [38] */ + uint64_t pm_blk_tlp_timeout : 1; /* [39] */ + uint64_t aspm_nak_vld : 1; /* [40] */ + uint64_t retrain_link_vld : 1; /* [41] */ + uint64_t pending_dllp_vld : 1; /* [42] */ + uint64_t pm_wakeup_tol0_en : 1; /* [43] */ + uint64_t mac2pm_rx_data_vld : 1; /* [44] */ + uint64_t dfe_req : 1; /* [45] */ + uint64_t pm_t_dfe_time_meet : 1; /* [46] */ + uint64_t reserved2 : 17; /* [47:63] */ + } bits; + uint64_t val; +}; + static int pcie_get_ltssm_trace(uint32_t port_id, uint64_t *ltssm_status, uint32_t *ltssm_num) { struct hikp_cmd_header req_header; @@ -280,3 +305,158 @@ free_cmd_ret: return ret; } + +static int pcie_get_pm_trace(uint32_t port_id, uint64_t *pm_status, uint32_t *pm_num) +{ + struct hikp_cmd_header req_header; + struct hikp_cmd_ret *cmd_ret = NULL; + struct pcie_trace_req_para req_data = { 0 }; + size_t src_size, dst_size; + int ret; + + req_data.port_id = port_id; + hikp_cmd_init(&req_header, PCIE_MOD, PCIE_TRACE, TRACE_PM); + cmd_ret = hikp_cmd_alloc(&req_header, &req_data, sizeof(req_data)); + ret = hikp_rsp_normal_check(cmd_ret); + if (ret) { + Err("PCIe Base", "pcie pm trace cmd_ret check failed, ret: %d.\n", ret); + goto free_cmd_ret; + } + + if (cmd_ret->rsp_data_num == 0) { + Err("PCIe Base", "without rsp data.\n"); + ret = -EINVAL; + goto free_cmd_ret; + } + /* 0: First uint32_t is pm trace num received from TF */ + *pm_num = cmd_ret->rsp_data[0]; + + if ((cmd_ret->rsp_data_num - 1) * sizeof(uint32_t) != (*pm_num) * sizeof(uint64_t)) { + Err("PCIe Base", "rsp data number check failed, rsp_data_num: %u, pm_num: %u.\n", + cmd_ret->rsp_data_num, *pm_num); + ret = -EINVAL; + goto free_cmd_ret; + } + + src_size = (*pm_num) * sizeof(uint64_t); + dst_size = TRACER_DEPTH * sizeof(uint64_t); + if (src_size > dst_size) { + Err("PCIe Base", "size check failed, %u > %u.\n", src_size, dst_size); + ret = -EINVAL; + goto free_cmd_ret; + } + memcpy(pm_status, (cmd_ret->rsp_data + 1), src_size); + +free_cmd_ret: + free(cmd_ret); + return ret; +} + +struct pcie_pm_num_string g_pm_string_table[] = { + {0x0, "pm_pme_idle"}, + {0x1, "pm_wait_dc_pme_msg_send_out"}, + {0x2, "pm_wait_dc_tl_enter_l2"}, + {0x3, "pm_wait_dc_dl_enter_l2"}, + {0x4, "pm_wait_dc_mac_enter_l2"}, + {0x5, "pm_dc_enter_l2"}, + {0x6, "pm_wait_dc_tl_enter_pcipm_l1"}, + {0x7, "pm_wait_dc_dl_enter_pcipm_l1"}, + {0x8, "pm_wait_dc_tl_enter_aspm_l1"}, + {0x9, "pm_wait_dc_dl_enter_aspm_l1"}, + {0xa, "pm_wait_tl_enter_aspm_l0"}, + {0xb, "pm_wait_dl_enter_aspm_l0"}, + {0xc, "pm_wait_dc_mac_enter_l1"}, + {0xd, "pm_wait_mac_enter_l0s"}, + {0xe, "pm_device_in_l0s"}, + {0xf, "pm_dc_device_in_l1"}, + {0x10, "pm_wait_dc_enter_l0"}, + {0x11, "pm_wait_uc_tl_enter_l2"}, + {0x12, "pm_wait_uc_dl_enter_l2"}, + {0x13, "pm_wait_uc_mac_enter_l2"}, + {0x15, "pm_wait_uc_tl_enter_pcipm_l1"}, + {0x17, "pm_wait_uc_dl_enter_aspm_l1"}, + {0x18, "pm_wait_uc_tl_enter_aspm_l1"}, + {0x1a, "pm_wait_uc_dl_enter_pcipm_l1"}, + {0x1c, "pm_wait_uc_mac_enter_l1"}, + {0x1d, "pm_wait_uc_pme_enter_l1_nak_sent_out"}, + {0x1e, "pm_wait_uc_enter_l0"}, + {0x20, "pm_device_will_enter_l1_substate"}, + {0x21, "pm_device_in_l1_1"}, + {0x22, "pm_device_will_exit_l1_substate"}, + {0x23, "pm_device_in_l1_2_entry"}, + {0x24, "pm_device_in_l1_2_idle"}, + {0x25, "pm_device_in_l1_2_exit"}, + {-1, "unknown"} /* end of array */ +}; + +static char *hisi_pcie_pm_string_get(uint32_t pm) +{ + int i = 0; + + while (g_pm_string_table[i].pm >= 0) { + if ((uint32_t)g_pm_string_table[i].pm != pm) { + i++; + continue; + } + break; + } + + return g_pm_string_table[i].pm_c; +} + +static int pcie_print_pm_trace(const uint64_t *pm_status, uint32_t pm_num) +{ + uint32_t i; + char *pm_c = NULL; + union pm_state_reg pm_val; + + if (pm_num > TRACER_DEPTH || pm_num == 0) { + Err("PCIe Base", "pm_num(%u) is over range or zero\n", pm_num); + return -EINVAL; + } + Info("PCIe Base", "pm tracer:\n"); + Info("PCIe Base", "\ttrace state: %llx\n", pm_status[0]); + Info("PCIe Base", + "\tpm[ii]: BE8: 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 " + "BD8: 23:6 5:0 : pm state\n"); + for (i = 1; i < pm_num; i++) { + pm_val.val = pm_status[i]; + pm_c = hisi_pcie_pm_string_get((uint32_t)pm_val.bits.pm_state); + Info("PCIe Base", + "\tpm[%02u]:\t %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x 0x%06x 0x%02x %s\n", + i, + (uint32_t)pm_val.bits.pm_t_dfe_time_meet, + (uint32_t)pm_val.bits.dfe_req, + (uint32_t)pm_val.bits.mac2pm_rx_data_vld, + (uint32_t)pm_val.bits.pm_wakeup_tol0_en, + (uint32_t)pm_val.bits.pending_dllp_vld, + (uint32_t)pm_val.bits.retrain_link_vld, + (uint32_t)pm_val.bits.aspm_nak_vld, + (uint32_t)pm_val.bits.pm_blk_tlp_timeout, + (uint32_t)pm_val.bits.pme_turn_off_vld_hold, + (uint32_t)pm_val.bits.pm_t_dl_lastack_timeout, + (uint32_t)pm_val.bits.pm_t_dl_l0s_gnt_timeout, + (uint32_t)pm_val.bits.pm_t_dl_l1_gnt_timeout, + (uint32_t)pm_val.bits.pm_t_dl_l2_gnt_timeout, + (uint32_t)pm_val.bits.enter_l12_case, + (uint32_t)pm_val.bits.refclk_stable_vld, + (uint32_t)pm_val.bits.pm_clock, + (uint32_t)pm_val.bits.pm_state, + pm_c); + } + + return 0; +} + +int pcie_pm_trace(uint32_t port_id) +{ + int ret; + uint32_t pm_num = 0; + uint64_t pm_st_save[TRACER_DEPTH]; + + ret = pcie_get_pm_trace(port_id, pm_st_save, &pm_num); + if (ret) + return ret; + + return pcie_print_pm_trace(pm_st_save, pm_num); +} \ No newline at end of file diff --git a/pcie/func_lib/pcie_func/pcie_link_ltssm.h b/pcie/func_lib/pcie_func/pcie_link_ltssm.h index eb57ead..8f3502b 100644 --- a/pcie/func_lib/pcie_func/pcie_link_ltssm.h +++ b/pcie/func_lib/pcie_func/pcie_link_ltssm.h @@ -18,12 +18,18 @@ #define TRACE_STR_NUM 0x20 #define TRACER_DEPTH 65 +#define PM_TRACE_STR_NUM 0x28 struct pcie_ltssm_num_string { int ltssm; char ltssm_c[TRACE_STR_NUM]; }; +struct pcie_pm_num_string { + int pm; + char pm_c[PM_TRACE_STR_NUM]; +}; + struct pcie_trace_req_para { uint32_t port_id; uint32_t trace_mode; @@ -51,5 +57,6 @@ int pcie_ltssm_trace_show(uint32_t port_id); int pcie_ltssm_trace_clear(uint32_t port_id); int pcie_ltssm_trace_mode_set(uint32_t port_id, uint32_t mode); int pcie_ltssm_link_status_get(uint32_t port_id); +int pcie_pm_trace(uint32_t port_id); #endif diff --git a/pcie/usr_cmd/cmd_analysis/pcie_cmd_trace.c b/pcie/usr_cmd/cmd_analysis/pcie_cmd_trace.c index e50b434..8ceb85a 100644 --- a/pcie/usr_cmd/cmd_analysis/pcie_cmd_trace.c +++ b/pcie/usr_cmd/cmd_analysis/pcie_cmd_trace.c @@ -37,6 +37,7 @@ static int pcie_trace_help(struct major_cmd_ctrl *self, const char *argv) printf(" %s, %-25s %s\n", "-m", "--mode", "set ltssm trace mode val 1:recver_en 0:recver_dis\n"); printf(" %s, %-25s %s\n", "-f", "--information", "display link information\n"); + printf(" %s, %-25s %s\n", "-pm", "--pm-state", "show pm status\n"); printf("\n"); return 0; @@ -57,6 +58,13 @@ static int pcie_trace_show(struct major_cmd_ctrl *self, const char *argv) return 0; } +static int pcie_pm_show(struct major_cmd_ctrl *self, const char *argv) +{ + g_trace_cmd.cmd_type = TRACE_PM; + + return 0; +} + static int pcie_trace_mode_set(struct major_cmd_ctrl *self, const char *argv) { int ret; @@ -108,6 +116,8 @@ static int pcie_trace_excute_funs_call(int cmd_type) return comm_api->ltssm_trace_mode_set(port_id, recover_en); else if (cmd_type == TRACE_INFO) return comm_api->ltssm_link_information_get(port_id); + else if (cmd_type == TRACE_PM) + return comm_api->pm_trace(port_id); else return -EINVAL; } @@ -120,14 +130,16 @@ static void pcie_trace_execute(struct major_cmd_ctrl *self) "pcie_trace_show success.", "pcie_trace_clear success.", "get mac link information success.", - "pcie_trace_mode_set success." + "pcie_trace_mode_set success.", + "pcie_pm_trace success." }; const char *err_msg[] = { "pcie_trace sub command type error.", "pcie_trace_show error.", "pcie_trace_clear error.", "get mac link information error.", - "pcie_trace_mode_set error." + "pcie_trace_mode_set error.", + "pcie_pm_trace error" }; ret = pcie_trace_excute_funs_call(g_trace_cmd.cmd_type); @@ -153,6 +165,7 @@ static void cmd_pcie_trace_init(void) cmd_option_register("-m", "--mode", true, pcie_trace_mode_set); cmd_option_register("-f", "--information", false, pcie_link_information_get); cmd_option_register("-i", "--interface", true, pcie_port_id_set); + cmd_option_register("-pm", "--pm-state", false, pcie_pm_show); } HIKP_CMD_DECLARE("pcie_trace", "pcie ltssm trace", cmd_pcie_trace_init); diff --git a/pcie/usr_cmd/interface/pcie_common_api.c b/pcie/usr_cmd/interface/pcie_common_api.c index 491daf2..8875481 100644 --- a/pcie/usr_cmd/interface/pcie_common_api.c +++ b/pcie/usr_cmd/interface/pcie_common_api.c @@ -27,6 +27,7 @@ struct pcie_comm_api g_tools_api = { .err_status_clear = pcie_error_state_clear, .reg_dump = pcie_dumpreg_do_dump, .reg_read = pcie_reg_read, + .pm_trace = pcie_pm_trace, }; diff --git a/pcie/usr_cmd/interface/pcie_common_api.h b/pcie/usr_cmd/interface/pcie_common_api.h index 9809575..08d4403 100644 --- a/pcie/usr_cmd/interface/pcie_common_api.h +++ b/pcie/usr_cmd/interface/pcie_common_api.h @@ -37,6 +37,7 @@ struct pcie_comm_api { int (*err_status_clear)(uint32_t port_id); int (*reg_dump)(uint32_t port_id, uint32_t dump_level); int (*reg_read)(uint32_t port_id, uint32_t moudle_id, uint32_t offset); + int (*pm_trace)(uint32_t port_id); }; struct pcie_comm_api *pcie_get_comm_api(void); -- 2.33.0

From: veega <zhuweijia@huawei.com> add arbitration information print in port ARB LINK INFO display area, and PHY INFO display area for print PHY config and regs Signed-off-by: veega <zhuweijia@huawei.com> --- net/nic/nic_mac/hikp_nic_port.c | 4 +++- net/nic/nic_mac/hikp_nic_port.h | 4 ++++ 2 files changed, 7 insertions(+), 1 deletion(-) diff --git a/net/nic/nic_mac/hikp_nic_port.c b/net/nic/nic_mac/hikp_nic_port.c index 1ff3569..22a6467 100644 --- a/net/nic/nic_mac/hikp_nic_port.c +++ b/net/nic/nic_mac/hikp_nic_port.c @@ -355,6 +355,7 @@ static void mac_cmd_disp_arb_info(const struct mac_cmd_arb_dfx *arb_dfx) mac_cmd_disp_port_param("Default", &arb_dfx->default_cfg); mac_cmd_disp_port_param("BIOS", &arb_dfx->bios_cfg); mac_cmd_disp_port_param("TOOL", &arb_dfx->user_cfg); + mac_cmd_disp_port_param("ARB", &arb_dfx->arb_cfg); mac_cmd_disp_port_param("Final", &arb_dfx->port_cfg); } @@ -443,7 +444,8 @@ static void mac_cmd_port_execute(struct major_cmd_ctrl *self) } port_hw = (struct mac_cmd_port_hardware *)(hw_cmd_ret->rsp_data); - if (port_hw->port_type == 1) + if (port_hw->port_type == HIKP_PORT_TYPE_PHY || + port_hw->port_type == HIKP_PORT_TYPE_PHY_SDS) mask |= MAC_LSPORT_PHY; mac_cmd_show_port_dfx(self, mask); diff --git a/net/nic/nic_mac/hikp_nic_port.h b/net/nic/nic_mac/hikp_nic_port.h index ac00f55..f6334d0 100644 --- a/net/nic/nic_mac/hikp_nic_port.h +++ b/net/nic/nic_mac/hikp_nic_port.h @@ -95,6 +95,9 @@ enum { #define HIKP_MAC_PHY_ABI_PAUSE HI_BIT(13) #define HIKP_MAC_PHY_ABI_ASYM_PAUSE HI_BIT(14) +#define HIKP_PORT_TYPE_PHY 1 +#define HIKP_PORT_TYPE_PHY_SDS 3 + struct mac_item { uint32_t key; const char *name; @@ -151,6 +154,7 @@ struct mac_cmd_arb_dfx { struct mac_port_param bios_cfg; struct mac_port_param user_cfg; struct mac_port_param port_cfg; + struct mac_port_param arb_cfg; }; #define MAC_PHY_DFX_REG_NUM 12 -- 2.36.1.windows.1

From: veega <zhuweijia@huawei.com> If the port contains CDRs, the nic_port command displays the hardware information of the CDRs, which helps locate port link setup faults. Signed-off-by: veega <zhuweijia@huawei.com> --- net/nic/nic_mac/hikp_mac_cmd.h | 1 + net/nic/nic_mac/hikp_nic_port.c | 72 ++++++++++++++++++++++++++++++++- net/nic/nic_mac/hikp_nic_port.h | 49 +++++++++++++++++++--- 3 files changed, 116 insertions(+), 6 deletions(-) diff --git a/net/nic/nic_mac/hikp_mac_cmd.h b/net/nic/nic_mac/hikp_mac_cmd.h index 5f0450a..adaadf4 100644 --- a/net/nic/nic_mac/hikp_mac_cmd.h +++ b/net/nic/nic_mac/hikp_mac_cmd.h @@ -30,6 +30,7 @@ enum mac_port_sub_cmd { QUERY_PORT_ADAPT_DFX, QUERY_PORT_PHY_DFX, QUERY_HOT_PLUG_CARD_DFX, + QUERY_PORT_CDR_DFX, }; enum mac_dump_reg_sub_cmd { diff --git a/net/nic/nic_mac/hikp_nic_port.c b/net/nic/nic_mac/hikp_nic_port.c index 22a6467..c9f46fc 100644 --- a/net/nic/nic_mac/hikp_nic_port.c +++ b/net/nic/nic_mac/hikp_nic_port.c @@ -405,6 +405,73 @@ static void mac_cmd_show_hot_plug_card(struct major_cmd_ctrl *self) free(cmd_ret); } +static void mac_cmd_print_cdr_dfx(struct mac_cmd_cdr_dfx *cdr_dfx, struct mac_port_cdr_dfx *info) +{ + struct mac_item type_table[] = { + {PORT_CDR_TYPE_A, "cdr_a"}, {PORT_CDR_TYPE_B, "cdr_b"}, + }; + struct mac_item cdr_a_mode[] = { + {CDR_A_MODE_2PLL, "2pll"}, {CDR_A_MODE_FASTPI, "fastpi"}, + }; + struct mac_item cdr_b_mode[] = { + {CDR_B_MODE_PCS, "pcs"}, {CDR_B_MODE_CDR, "cdr"}, + }; + struct mac_item status_table[] = { + {CDR_STATUS_NORMAL, "normal"}, {CDR_STATUS_ERROR, "error"}, + }; + const char *type_str = mac_get_str(cdr_dfx->cdr_type, + type_table, HIKP_ARRAY_SIZE(type_table), "unknown"); + const char *mode_str = "NA"; + + for (uint32_t i = 0; i < cdr_dfx->cdr_num; i++) { + if (cdr_dfx->cdr_type == PORT_CDR_TYPE_A) { + mode_str = mac_get_str(info->dfx[i].cdr_mode, cdr_a_mode, + HIKP_ARRAY_SIZE(cdr_a_mode), "unknown"); + } else if (cdr_dfx->cdr_type == PORT_CDR_TYPE_B) { + mode_str = mac_get_str(info->dfx[i].cdr_mode, cdr_b_mode, + HIKP_ARRAY_SIZE(cdr_b_mode), "unknown"); + } + printf("\t|0x%-8x%-9u%-10s%-10s%-10s\n", info->dfx[i].cdr_addr, + info->dfx[i].cdr_start_lane, type_str, mode_str, + mac_get_str(info->dfx[i].cdr_err, + status_table, HIKP_ARRAY_SIZE(status_table), "unknown")); + } +} + +static void mac_cmd_disp_cdr_info(struct mac_cmd_cdr_dfx *cdr_dfx) +{ + if (!cdr_dfx->cdr_num) + return; + + printf("\n======================== PORT CDR INFO =======================\n"); + printf("direct\t|addr |lane |type |mode |status \n"); + printf("----------------------------------------------------------------------------\n"); + + printf("WIRE"); + mac_cmd_print_cdr_dfx(cdr_dfx, &cdr_dfx->wire_cdr); + + printf("HOST"); + mac_cmd_print_cdr_dfx(cdr_dfx, &cdr_dfx->host_cdr); +} + +static void mac_cmd_show_cdr(struct major_cmd_ctrl *self) +{ + struct mac_cmd_cdr_dfx *cdr_dfx = NULL; + struct hikp_cmd_ret *cmd_ret = NULL; + int ret; + + ret = mac_cmd_get_dfx_cfg(QUERY_PORT_CDR_DFX, &cmd_ret); + if (ret != 0) { + self->err_no = -ENOSPC; + snprintf(self->err_str, sizeof(self->err_str), "mac get cdr dfx failed."); + return; + } + + cdr_dfx = (struct mac_cmd_cdr_dfx *)(cmd_ret->rsp_data); + mac_cmd_disp_cdr_info(cdr_dfx); + free(cmd_ret); +} + static void mac_cmd_show_port_dfx(struct major_cmd_ctrl *self, uint32_t mask) { struct mac_cmd_dfx_callback dfx_cb[] = { @@ -413,6 +480,7 @@ static void mac_cmd_show_port_dfx(struct major_cmd_ctrl *self, uint32_t mask) {MAC_LSPORT_PHY, mac_cmd_show_phy}, {MAC_LSPORT_ARB, mac_cmd_show_arb}, {MAC_HOT_PLUG_CARD, mac_cmd_show_hot_plug_card}, + {MAC_LSPORT_CDR, mac_cmd_show_cdr} }; size_t size = HIKP_ARRAY_SIZE(dfx_cb); size_t i; @@ -425,9 +493,9 @@ static void mac_cmd_show_port_dfx(struct major_cmd_ctrl *self, uint32_t mask) static void mac_cmd_port_execute(struct major_cmd_ctrl *self) { - uint32_t mask = MAC_LSPORT_LINK | MAC_LSPORT_MAC | MAC_LSPORT_ARB | MAC_HOT_PLUG_CARD; struct mac_cmd_port_hardware *port_hw = NULL; struct hikp_cmd_ret *hw_cmd_ret = NULL; + uint32_t mask; int ret; if (!g_port_info.port_flag) { @@ -443,6 +511,8 @@ static void mac_cmd_port_execute(struct major_cmd_ctrl *self) return; } + mask = MAC_LSPORT_LINK | MAC_LSPORT_MAC | + MAC_LSPORT_ARB | MAC_HOT_PLUG_CARD | MAC_LSPORT_CDR; port_hw = (struct mac_cmd_port_hardware *)(hw_cmd_ret->rsp_data); if (port_hw->port_type == HIKP_PORT_TYPE_PHY || port_hw->port_type == HIKP_PORT_TYPE_PHY_SDS) diff --git a/net/nic/nic_mac/hikp_nic_port.h b/net/nic/nic_mac/hikp_nic_port.h index f6334d0..42ab3f9 100644 --- a/net/nic/nic_mac/hikp_nic_port.h +++ b/net/nic/nic_mac/hikp_nic_port.h @@ -16,11 +16,12 @@ #include "hikp_net_lib.h" -#define MAC_LSPORT_LINK HI_BIT(0) -#define MAC_LSPORT_MAC HI_BIT(1) -#define MAC_LSPORT_PHY HI_BIT(2) -#define MAC_LSPORT_ARB HI_BIT(3) -#define MAC_HOT_PLUG_CARD HI_BIT(4) +#define MAC_LSPORT_LINK HI_BIT(0) +#define MAC_LSPORT_MAC HI_BIT(1) +#define MAC_LSPORT_PHY HI_BIT(2) +#define MAC_LSPORT_ARB HI_BIT(3) +#define MAC_HOT_PLUG_CARD HI_BIT(4) +#define MAC_LSPORT_CDR HI_BIT(5) enum { PORT_CFG_NOT_SET = 0, @@ -186,6 +187,44 @@ struct mac_cmd_phy_info { struct mac_cmd_phy_dfx phy_dfx; }; +enum { + PORT_CDR_TYPE_A = 0, + PORT_CDR_TYPE_B, +}; + +enum { + CDR_A_MODE_2PLL = 0, + CDR_A_MODE_FASTPI, +}; + +enum { + CDR_B_MODE_PCS = 0, + CDR_B_MODE_CDR, +}; + +enum { + CDR_STATUS_NORMAL = 0, + CDR_STATUS_ERROR, +}; + +struct cdr_dfx_info { + uint8_t cdr_mode; + uint8_t cdr_addr; + uint8_t cdr_start_lane; + uint8_t cdr_err; /* 0:normal, 1:error */ +}; + +struct mac_port_cdr_dfx { + struct cdr_dfx_info dfx[2]; /* one side reserved max 2 cdr */ +}; + +struct mac_cmd_cdr_dfx { + uint8_t cdr_num; + uint8_t cdr_type; + struct mac_port_cdr_dfx wire_cdr; + struct mac_port_cdr_dfx host_cdr; +}; + struct mac_cmd_dfx_callback { uint32_t mask; void (*show_dfx)(struct major_cmd_ctrl *self); -- 2.36.1.windows.1

From: m30045533 <moubingquan@huawei.com> --- pcie/func_lib/pcie_func/pcie_link_ltssm.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/pcie/func_lib/pcie_func/pcie_link_ltssm.c b/pcie/func_lib/pcie_func/pcie_link_ltssm.c index 09d3b5e..156f4be 100644 --- a/pcie/func_lib/pcie_func/pcie_link_ltssm.c +++ b/pcie/func_lib/pcie_func/pcie_link_ltssm.c @@ -213,7 +213,8 @@ 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.mac_rate, + (((uint32_t)ltssm_val.bits.rxl0s_st) << 2) | + ((uint32_t)ltssm_val.bits.mac_rate), (uint32_t)ltssm_val.bits.duration_counter, (uint32_t)ltssm_val.bits.ltssm_state, ltssm_c); -- 2.33.0

From: veega <zhuweijia@huawei.com> After the framework fails to apply for memory, the memory needs to be released. The framework returns a processing failure message. The module needs to exit and release the memory. Signed-off-by: veega <zhuweijia@huawei.com> --- net/nic/nic_dfx/hikp_nic_dfx.c | 17 +++++++++-------- net/nic/nic_fd/hikp_nic_fd.c | 6 ++++-- net/nic/nic_info/hikp_nic_info.c | 4 +++- net/nic/nic_log/hikp_nic_log.c | 8 ++++---- net/nic/nic_ppp/hikp_nic_ppp.c | 5 +++-- net/nic/nic_qos/hikp_nic_qos.c | 5 +++-- net/nic/nic_queue/hikp_nic_queue.c | 5 +++-- net/nic/nic_rss/hikp_nic_rss.c | 5 +++-- net/roce/roce_pkt/hikp_roce_pkt.c | 11 +++++++---- net/roce/roce_scc/hikp_roce_scc.c | 11 +++++++---- net/roce/roce_trp/hikp_roce_trp.c | 11 +++++++---- net/roce/roce_tsp/hikp_roce_tsp.c | 11 +++++++---- sas/sas_func/sas_analy_queue.c | 3 ++- sas/sas_func/sas_dump_reg.c | 3 ++- sas/sas_func/sas_read_dev.c | 3 ++- sas/sas_func/sas_read_dqe.c | 3 ++- sas/sas_func/sas_read_errcode.c | 3 ++- sata/sata_func/sata_dump_reg.c | 3 ++- serdes/hikp_serdes.c | 8 ++++---- socip/hikp_socip_dumpreg.c | 4 +++- 20 files changed, 79 insertions(+), 50 deletions(-) diff --git a/net/nic/nic_dfx/hikp_nic_dfx.c b/net/nic/nic_dfx/hikp_nic_dfx.c index 3584493..c734ce0 100644 --- a/net/nic/nic_dfx/hikp_nic_dfx.c +++ b/net/nic/nic_dfx/hikp_nic_dfx.c @@ -123,12 +123,12 @@ static int hikp_nic_get_first_blk_dfx(struct nic_dfx_rsp_head_t *rsp_head, uint3 uint32_t *max_dfx_size, uint32_t *version) { struct nic_dfx_rsp_t *dfx_rsp = NULL; - struct hikp_cmd_ret *cmd_ret; + struct hikp_cmd_ret *cmd_ret = NULL; int ret; ret = hikp_nic_dfx_get_blk(&cmd_ret, 0, g_dfx_param.sub_cmd_code); if (ret < 0) - return ret; + goto err_out; dfx_rsp = (struct nic_dfx_rsp_t *)(cmd_ret->rsp_data); *version = cmd_ret->version; @@ -168,12 +168,12 @@ static int hikp_nic_get_blk_dfx(struct nic_dfx_rsp_head_t *rsp_head, uint32_t bl uint32_t *reg_data, uint32_t *max_dfx_size) { struct nic_dfx_rsp_t *dfx_rsp = NULL; - struct hikp_cmd_ret *cmd_ret; + struct hikp_cmd_ret *cmd_ret = NULL; int ret; ret = hikp_nic_dfx_get_blk(&cmd_ret, blk_id, g_dfx_param.sub_cmd_code); if (ret < 0) - return ret; + goto err_out; dfx_rsp = (struct nic_dfx_rsp_t *)(cmd_ret->rsp_data); *rsp_head = dfx_rsp->rsp_head; @@ -181,16 +181,17 @@ static int hikp_nic_get_blk_dfx(struct nic_dfx_rsp_head_t *rsp_head, uint32_t bl HIKP_ERROR_PRINT("blk%u reg_data copy size error, " "data size: 0x%x, max size: 0x%x\n", blk_id, rsp_head->cur_blk_size, *max_dfx_size); - free(cmd_ret); - cmd_ret = NULL; - return -EINVAL; + ret = -EINVAL; + goto err_out; } memcpy(reg_data, dfx_rsp->reg_data, rsp_head->cur_blk_size); *max_dfx_size -= (uint32_t)rsp_head->cur_blk_size; + +err_out: free(cmd_ret); cmd_ret = NULL; - return 0; + return ret; } static int cmd_dfx_module_select(struct major_cmd_ctrl *self, const char *argv) diff --git a/net/nic/nic_fd/hikp_nic_fd.c b/net/nic/nic_fd/hikp_nic_fd.c index 5a87c30..57bc94b 100644 --- a/net/nic/nic_fd/hikp_nic_fd.c +++ b/net/nic/nic_fd/hikp_nic_fd.c @@ -558,8 +558,10 @@ static int hikp_nic_fd_get_blk(struct hikp_cmd_header *req_header, int ret = 0; cmd_ret = hikp_cmd_alloc(req_header, req_data, sizeof(*req_data)); - if (cmd_ret == NULL) - return -EIO; + if (hikp_rsp_normal_check(cmd_ret)) { + ret = -EIO; + goto out; + } rsp = (struct nic_fd_rsp *)cmd_ret->rsp_data; if (rsp->rsp_head.cur_blk_size > buf_len) { diff --git a/net/nic/nic_info/hikp_nic_info.c b/net/nic/nic_info/hikp_nic_info.c index 1853d95..d84ca18 100644 --- a/net/nic/nic_info/hikp_nic_info.c +++ b/net/nic/nic_info/hikp_nic_info.c @@ -64,12 +64,14 @@ static int hikp_nic_get_hw_info(struct hikp_cmd_ret **cmd_ret) static int hikp_nic_get_curr_die_info(void) { struct nic_info_rsp_t *info_rsp = NULL; - struct hikp_cmd_ret *cmd_ret; + struct hikp_cmd_ret *cmd_ret = NULL; int ret; ret = hikp_nic_get_hw_info(&cmd_ret); if (ret != 0) { HIKP_ERROR_PRINT("Get chip info fail.\n"); + free(cmd_ret); + cmd_ret = NULL; return ret; } info_rsp = (struct nic_info_rsp_t *)(cmd_ret->rsp_data); diff --git a/net/nic/nic_log/hikp_nic_log.c b/net/nic/nic_log/hikp_nic_log.c index 527f9e9..5cafe4e 100644 --- a/net/nic/nic_log/hikp_nic_log.c +++ b/net/nic/nic_log/hikp_nic_log.c @@ -96,13 +96,13 @@ static int hikp_nic_get_first_blk_info(uint32_t *total_blk_num, uint32_t *cur_blk_size, uint8_t **log_data) { struct nic_log_rsp_data *log_rsp = NULL; - struct hikp_cmd_ret *cmd_ret; + struct hikp_cmd_ret *cmd_ret = NULL; uint32_t log_size; int ret; ret = hikp_nic_get_blk_log(&cmd_ret, 0); if (ret < 0) - return ret; + goto err_out; log_rsp = (struct nic_log_rsp_data *)(cmd_ret->rsp_data); log_size = (uint32_t)(log_rsp->total_blk_num * MAX_LOG_DATA_NUM * sizeof(uint32_t)); @@ -132,12 +132,12 @@ static int hikp_nic_get_log_info(uint32_t blk_id, uint32_t *cur_blk_size, uint8_ uint32_t max_log_size, uint32_t *blk_num) { struct nic_log_rsp_data *log_rsp = NULL; - struct hikp_cmd_ret *cmd_ret; + struct hikp_cmd_ret *cmd_ret = NULL; int ret; ret = hikp_nic_get_blk_log(&cmd_ret, blk_id); if (ret) - return ret; + goto err_out; log_rsp = (struct nic_log_rsp_data *)(cmd_ret->rsp_data); *cur_blk_size = (uint32_t)log_rsp->cur_blk_size; diff --git a/net/nic/nic_ppp/hikp_nic_ppp.c b/net/nic/nic_ppp/hikp_nic_ppp.c index 28c867d..b71fc48 100644 --- a/net/nic/nic_ppp/hikp_nic_ppp.c +++ b/net/nic/nic_ppp/hikp_nic_ppp.c @@ -482,8 +482,9 @@ static int hikp_nic_ppp_get_blk(struct hikp_cmd_header *req_header, int ret = 0; cmd_ret = hikp_cmd_alloc(req_header, req_data, sizeof(*req_data)); - if (cmd_ret == NULL) - return -EIO; + ret = hikp_rsp_normal_check(cmd_ret); + if (ret) + goto out; rsp = (struct nic_ppp_rsp *)cmd_ret->rsp_data; if (rsp->rsp_head.cur_blk_size > buf_len) { diff --git a/net/nic/nic_qos/hikp_nic_qos.c b/net/nic/nic_qos/hikp_nic_qos.c index 2d55e45..6c2db1d 100644 --- a/net/nic/nic_qos/hikp_nic_qos.c +++ b/net/nic/nic_qos/hikp_nic_qos.c @@ -143,9 +143,10 @@ static int hikp_nic_qos_get_blk(struct hikp_cmd_header *req_header, int ret = 0; cmd_ret = hikp_cmd_alloc(req_header, req_data, sizeof(*req_data)); - if (cmd_ret == NULL) { + ret = hikp_rsp_normal_check(cmd_ret); + if (ret) { HIKP_ERROR_PRINT("failed to get block-%u context.\n", req_data->block_id); - return -EIO; + goto out; } rsp = (struct nic_qos_rsp *)cmd_ret->rsp_data; diff --git a/net/nic/nic_queue/hikp_nic_queue.c b/net/nic/nic_queue/hikp_nic_queue.c index 37460c0..f229e09 100644 --- a/net/nic/nic_queue/hikp_nic_queue.c +++ b/net/nic/nic_queue/hikp_nic_queue.c @@ -239,9 +239,10 @@ static int hikp_nic_queue_get_blk(struct hikp_cmd_header *req_header, int ret = 0; cmd_ret = hikp_cmd_alloc(req_header, req_data, sizeof(*req_data)); - if (cmd_ret == NULL) { + ret = hikp_rsp_normal_check(cmd_ret); + if (ret) { HIKP_ERROR_PRINT("failed to get block-%u context.\n", req_data->block_id); - return -EIO; + goto out; } rsp = (struct nic_queue_rsp *)cmd_ret->rsp_data; diff --git a/net/nic/nic_rss/hikp_nic_rss.c b/net/nic/nic_rss/hikp_nic_rss.c index b785ba4..5e4d261 100644 --- a/net/nic/nic_rss/hikp_nic_rss.c +++ b/net/nic/nic_rss/hikp_nic_rss.c @@ -357,9 +357,10 @@ static int hikp_nic_rss_get_blk(struct hikp_cmd_header *req_header, int ret = 0; cmd_ret = hikp_cmd_alloc(req_header, req_data, sizeof(*req_data)); - if (cmd_ret == NULL) { + ret = hikp_rsp_normal_check(cmd_ret); + if (ret) { HIKP_ERROR_PRINT("failed to get block-%u context.\n", req_data->block_id); - return -EIO; + goto out; } rsp = (struct nic_rss_rsp *)cmd_ret->rsp_data; diff --git a/net/roce/roce_pkt/hikp_roce_pkt.c b/net/roce/roce_pkt/hikp_roce_pkt.c index abfc526..d3bf885 100644 --- a/net/roce/roce_pkt/hikp_roce_pkt.c +++ b/net/roce/roce_pkt/hikp_roce_pkt.c @@ -48,15 +48,18 @@ static int hikp_roce_pkt_clear_set(struct major_cmd_ctrl *self, const char *argv static int hikp_roce_pkt_get_data(struct hikp_cmd_ret **cmd_ret, struct roce_pkt_req_param req_data) { struct hikp_cmd_header req_header = { 0 }; + int ret; hikp_cmd_init(&req_header, ROCE_MOD, GET_ROCEE_PKT_CMD, 0); *cmd_ret = hikp_cmd_alloc(&req_header, &req_data, sizeof(req_data)); - if (*cmd_ret == NULL) { - printf("hikptool roce_pkt cmd_ret malloc failed\n"); - return -EIO; + ret = hikp_rsp_normal_check(*cmd_ret); + if (ret) { + printf("hikptool roce_pkt get cmd data failed, ret: %d\n", ret); + free(*cmd_ret); + *cmd_ret = NULL; } - return 0; + return ret; } static void hikp_roce_pkt_print(uint32_t total_block_num, diff --git a/net/roce/roce_scc/hikp_roce_scc.c b/net/roce/roce_scc/hikp_roce_scc.c index 1011814..e8e166d 100644 --- a/net/roce/roce_scc/hikp_roce_scc.c +++ b/net/roce/roce_scc/hikp_roce_scc.c @@ -88,6 +88,7 @@ static int hikp_roce_scc_get_data(struct hikp_cmd_ret **cmd_ret, const uint32_t { struct roce_scc_req_param req_data = { 0 }; struct hikp_cmd_header req_header = { 0 }; + int ret; req_data.block_id = *block_id; req_data.bdf = g_roce_scc_param_t.target.bdf; @@ -99,12 +100,14 @@ static int hikp_roce_scc_get_data(struct hikp_cmd_ret **cmd_ret, const uint32_t hikp_cmd_init(&req_header, ROCE_MOD, GET_ROCEE_SCC_CMD, g_roce_scc_param_t.sub_cmd); *cmd_ret = hikp_cmd_alloc(&req_header, &req_data, sizeof(req_data)); - if (*cmd_ret == NULL) { - printf("hikptool roce_scc cmd_ret malloc failed\n"); - return -EIO; + ret = hikp_rsp_normal_check(*cmd_ret); + if (ret) { + printf("hikptool roce_scc get cmd data failed, ret: %d\n", ret); + free(*cmd_ret); + *cmd_ret = NULL; } - return 0; + return ret; } static void hikp_roce_scc_reg_data_free(uint32_t **offset, uint32_t **data) diff --git a/net/roce/roce_trp/hikp_roce_trp.c b/net/roce/roce_trp/hikp_roce_trp.c index bf22484..4591a47 100644 --- a/net/roce/roce_trp/hikp_roce_trp.c +++ b/net/roce/roce_trp/hikp_roce_trp.c @@ -112,6 +112,7 @@ static int hikp_roce_trp_get_data(struct hikp_cmd_ret **cmd_ret, const uint32_t { struct roce_trp_req_param req_data = { 0 }; struct hikp_cmd_header req_header = { 0 }; + int ret; req_data.block_id = *block_id; req_data.bdf = g_roce_trp_param_t.target.bdf; @@ -122,12 +123,14 @@ static int hikp_roce_trp_get_data(struct hikp_cmd_ret **cmd_ret, const uint32_t } hikp_cmd_init(&req_header, ROCE_MOD, GET_ROCEE_TRP_CMD, g_roce_trp_param_t.sub_cmd); *cmd_ret = hikp_cmd_alloc(&req_header, &req_data, sizeof(req_data)); - if (*cmd_ret == NULL) { - printf("hikptool roce_trp cmd_ret malloc failed\n"); - return -EIO; + ret = hikp_rsp_normal_check(*cmd_ret); + if (ret) { + printf("hikptool roce_trp get cmd data failed, ret: %d\n", ret); + free(*cmd_ret); + *cmd_ret = NULL; } - return 0; + return ret; } static void hikp_roce_trp_reg_data_free(uint32_t **offset, uint32_t **data) diff --git a/net/roce/roce_tsp/hikp_roce_tsp.c b/net/roce/roce_tsp/hikp_roce_tsp.c index 5d06ede..ca3126b 100644 --- a/net/roce/roce_tsp/hikp_roce_tsp.c +++ b/net/roce/roce_tsp/hikp_roce_tsp.c @@ -122,6 +122,7 @@ static int hikp_roce_tsp_get_data(struct hikp_cmd_ret **cmd_ret, struct roce_tsp_req_param req_data, uint32_t sub_cmd_code) { struct hikp_cmd_header req_header = { 0 }; + int ret; if (g_roce_tsp_param_t.sub_cmd_code == 0) { printf("please enter module name: -m/--modlue\n"); @@ -129,12 +130,14 @@ static int hikp_roce_tsp_get_data(struct hikp_cmd_ret **cmd_ret, } hikp_cmd_init(&req_header, ROCE_MOD, GET_ROCEE_TSP_CMD, sub_cmd_code); *cmd_ret = hikp_cmd_alloc(&req_header, &req_data, sizeof(req_data)); - if (*cmd_ret == NULL) { - printf("hikptool roce_tsp cmd_ret malloc failed\n"); - return -EIO; + ret = hikp_rsp_normal_check(*cmd_ret); + if (ret) { + printf("hikptool roce_tsp get cmd data failed, ret: %d\n", ret); + free(*cmd_ret); + *cmd_ret = NULL; } - return 0; + return ret; } static void hikp_roce_tsp_print(uint32_t total_block_num, diff --git a/sas/sas_func/sas_analy_queue.c b/sas/sas_func/sas_analy_queue.c index ce886b9..8fca197 100644 --- a/sas/sas_func/sas_analy_queue.c +++ b/sas/sas_func/sas_analy_queue.c @@ -40,8 +40,9 @@ static int sas_get_res(const struct tool_sas_cmd *cmd, uint32_t *reg_save, uint3 hikp_cmd_init(&req_header, SAS_MOD, SAS_ANACQ, ANACQ_PRT); cmd_ret = hikp_cmd_alloc(&req_header, &req_data, sizeof(req_data)); - if (cmd_ret == NULL) { + if (cmd_ret == NULL || cmd_ret->status != 0) { printf("sas_analy excutes hikp_cmd_alloc err\n"); + free(cmd_ret); return -EINVAL; } *reg_num = cmd_ret->rsp_data_num; diff --git a/sas/sas_func/sas_dump_reg.c b/sas/sas_func/sas_dump_reg.c index d012aa1..5736726 100644 --- a/sas/sas_func/sas_dump_reg.c +++ b/sas/sas_func/sas_dump_reg.c @@ -32,8 +32,9 @@ static int sas_get_reg(const struct tool_sas_cmd *cmd, uint32_t *reg_save, uint3 hikp_cmd_init(&req_header, SAS_MOD, SAS_DUMP, cmd->sas_cmd_type); cmd_ret = hikp_cmd_alloc(&req_header, &req_data, sizeof(req_data)); - if (cmd_ret == NULL) { + if (cmd_ret == NULL || cmd_ret->status != 0) { printf("sas_dump excutes hikp_cmd_alloc err\n"); + free(cmd_ret); return -1; } *reg_num = cmd_ret->rsp_data_num; diff --git a/sas/sas_func/sas_read_dev.c b/sas/sas_func/sas_read_dev.c index d01f95f..8b9b58d 100644 --- a/sas/sas_func/sas_read_dev.c +++ b/sas/sas_func/sas_read_dev.c @@ -33,8 +33,9 @@ static int sas_get_dev(const struct tool_sas_cmd *cmd, uint32_t *reg_save, uint3 hikp_cmd_init(&req_header, SAS_MOD, SAS_DEV, cmd->sas_cmd_type); cmd_ret = hikp_cmd_alloc(&req_header, &req_data, sizeof(req_data)); - if (cmd_ret == NULL) { + if (cmd_ret == NULL || cmd_ret->status != 0) { printf("sas_dqe excutes hikp_cmd_alloc err\n"); + free(cmd_ret); return -EINVAL; } *reg_num = cmd_ret->rsp_data_num; diff --git a/sas/sas_func/sas_read_dqe.c b/sas/sas_func/sas_read_dqe.c index 2f653df..dbd30f3 100644 --- a/sas/sas_func/sas_read_dqe.c +++ b/sas/sas_func/sas_read_dqe.c @@ -33,8 +33,9 @@ static int sas_get_dqe(const struct tool_sas_cmd *cmd, uint32_t *reg_save, uint3 hikp_cmd_init(&req_header, SAS_MOD, SAS_DQE, cmd->sas_cmd_type); cmd_ret = hikp_cmd_alloc(&req_header, &req_data, sizeof(req_data)); - if (cmd_ret == NULL) { + if (cmd_ret == NULL || cmd_ret->status != 0) { printf("sas_dqe excutes hikp_cmd_alloc err\n"); + free(cmd_ret); return -EINVAL; } *reg_num = cmd_ret->rsp_data_num; diff --git a/sas/sas_func/sas_read_errcode.c b/sas/sas_func/sas_read_errcode.c index 4f89bda..6c7850e 100644 --- a/sas/sas_func/sas_read_errcode.c +++ b/sas/sas_func/sas_read_errcode.c @@ -31,8 +31,9 @@ static int sas_get_errcode(const struct tool_sas_cmd *cmd, uint32_t *reg_save, u hikp_cmd_init(&req_header, SAS_MOD, SAS_ERRCODE, cmd->sas_cmd_type); cmd_ret = hikp_cmd_alloc(&req_header, &req_data, sizeof(req_data)); - if (cmd_ret == NULL) { + if (cmd_ret == NULL || cmd_ret->status != 0) { printf("sas_errcode excutes hikp_cmd_alloc err\n"); + free(cmd_ret); return -EINVAL; } *reg_num = cmd_ret->rsp_data_num; diff --git a/sata/sata_func/sata_dump_reg.c b/sata/sata_func/sata_dump_reg.c index 86f6760..b4ff35f 100644 --- a/sata/sata_func/sata_dump_reg.c +++ b/sata/sata_func/sata_dump_reg.c @@ -33,8 +33,9 @@ static int sata_get_reg(const struct tool_sata_cmd *cmd, uint32_t *reg_save, uin hikp_cmd_init(&req_header, SATA_MOD, SATA_DUMP, cmd->sata_cmd_type); cmd_ret = hikp_cmd_alloc(&req_header, &req_data, sizeof(req_data)); - if (cmd_ret == NULL) { + if (cmd_ret == NULL || cmd_ret->status != 0) { printf("hikp_data_proc err\n"); + free(cmd_ret); return -1; } *reg_num = cmd_ret->rsp_data_num; diff --git a/serdes/hikp_serdes.c b/serdes/hikp_serdes.c index 527fd53..320ded2 100644 --- a/serdes/hikp_serdes.c +++ b/serdes/hikp_serdes.c @@ -309,10 +309,10 @@ static void hikp_serdes_info_cmd_execute(struct major_cmd_ctrl *self) hikp_cmd_init(&req_header, SERDES_MOD, SERDES_KEY_INFO, g_serdes_param.sub_cmd); cmd_ret = hikp_cmd_alloc(&req_header, &hilink_cmd, sizeof(hilink_cmd)); - if (cmd_ret == NULL) { + if (cmd_ret == NULL || cmd_ret->status != 0) { snprintf(self->err_str, sizeof(self->err_str), "hikp_cmd_alloc err."); self->err_no = -EINVAL; - return; + goto err_out; } out_out_header_size = sizeof(out_put.str_len) + sizeof(out_put.result_offset) + sizeof(out_put.type) + sizeof(out_put.ret_val); @@ -467,10 +467,10 @@ static void hikp_serdes_dump_cmd_execute(struct major_cmd_ctrl *self) hikp_cmd_init(&req_header, SERDES_MOD, SERDES_DUMP_REG, g_serdes_param.sub_cmd); cmd_ret = hikp_cmd_alloc(&req_header, &hilink_cmd, sizeof(hilink_cmd)); - if (cmd_ret == NULL) { + if (cmd_ret == NULL || cmd_ret->status != 0) { self->err_no = -EINVAL; snprintf(self->err_str, sizeof(self->err_str), "hikp_cmd_alloc err."); - return; + goto err_out; } out_out_header_size = sizeof(out_put.str_len) + sizeof(out_put.result_offset) + sizeof(out_put.type) + sizeof(out_put.ret_val); diff --git a/socip/hikp_socip_dumpreg.c b/socip/hikp_socip_dumpreg.c index 32325bb..0153dd9 100644 --- a/socip/hikp_socip_dumpreg.c +++ b/socip/hikp_socip_dumpreg.c @@ -141,9 +141,11 @@ static void hikp_socip_dumpreg_execute(struct major_cmd_ctrl *self) req_data.controller_id = param[CONTROLLER_ID_INDEX].val; hikp_cmd_init(&req_header, SOCIP_MOD, HIKP_SOCIP_CMD_DUMPREG, param[MODULE_ID_INDEX].val); cmd_ret = hikp_cmd_alloc(&req_header, &req_data, sizeof(req_data)); - if (!cmd_ret) { + if (!cmd_ret || cmd_ret->status != 0) { self->err_no = -EINVAL; HIKP_ERROR_PRINT("hikp_cmd_alloc\n"); + free(cmd_ret); + cmd_ret = NULL; return; } -- 2.36.1.windows.1

From: Jie Wang <wangjie125@huawei.com> Add nic port fault cmd for query nic port fault status. AR:AR20230712025691 Bugfix or Feature: Feature Signed-off-by: Jie Wang <wangjie125@huawei.com> --- net/hikp_net_lib.h | 1 + net/nic/nic_ft/hikp_nic_port_fault.c | 139 +++++++++++++++++++++++++++ net/nic/nic_ft/hikp_nic_port_fault.h | 54 +++++++++++ 3 files changed, 194 insertions(+) create mode 100644 net/nic/nic_ft/hikp_nic_port_fault.c create mode 100644 net/nic/nic_ft/hikp_nic_port_fault.h diff --git a/net/hikp_net_lib.h b/net/hikp_net_lib.h index 06ae598..cb537ff 100644 --- a/net/hikp_net_lib.h +++ b/net/hikp_net_lib.h @@ -80,6 +80,7 @@ enum nic_cmd_type { GET_GRO_INFO_CMD, GET_NCSI_INFO_CMD, GET_NOTIFY_PKT_CMD, + GET_PORT_FAULT_STATUS = 0xE, }; enum roh_cmd_type { diff --git a/net/nic/nic_ft/hikp_nic_port_fault.c b/net/nic/nic_ft/hikp_nic_port_fault.c new file mode 100644 index 0000000..fd94214 --- /dev/null +++ b/net/nic/nic_ft/hikp_nic_port_fault.c @@ -0,0 +1,139 @@ +/* + * Copyright (c) 2023 Hisilicon Technologies Co., Ltd. + * Hikptool is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * + * See the Mulan PSL v2 for more details. + */ + +#include <stdio.h> +#include <string.h> +#include <sys/types.h> +#include <unistd.h> +#include "hikp_nic_port_fault.h" + +static struct tool_target g_port_fault_target; + +static int hikp_nic_port_fault_query(const struct bdf_t *bdf, + struct nic_port_fault_status *info) +{ + struct nic_port_fault_req_para req = { 0 }; + struct hikp_cmd_header header = { 0 }; + struct nic_port_fault_rsp *rsp; + struct hikp_cmd_ret *cmd_ret; + + req.bdf = *bdf; + hikp_cmd_init(&header, NIC_MOD, GET_PORT_FAULT_STATUS, + NIC_PORT_FAULT_INFO_DUMP); + cmd_ret = hikp_cmd_alloc(&header, &req, sizeof(req)); + if (cmd_ret == NULL || cmd_ret->status != 0) { + HIKP_ERROR_PRINT("fail to get port fault, retcode: %u\n", + cmd_ret ? cmd_ret->status : EIO); + if (cmd_ret != NULL) + free(cmd_ret); + + return -EIO; + } + + rsp = (struct nic_port_fault_rsp *)cmd_ret->rsp_data; + *info = *(struct nic_port_fault_status *)rsp->data; + free(cmd_ret); + + return 0; +} + +static void hikp_nic_format_port_fault_info(struct nic_port_fault_status *info) +{ + if (info->cdr_core_status > NIC_PORT_FAULT_INVALID) + info->cdr_core_status = NIC_PORT_FAULT_INVALID; + + if (info->cdr_flash_status > NIC_PORT_FAULT_INVALID) + info->cdr_flash_status = NIC_PORT_FAULT_INVALID; + + if (info->fault_9545_status > NIC_PORT_FAULT_INVALID) + info->fault_9545_status = NIC_PORT_FAULT_INVALID; + + if (info->hilink_ref_status > NIC_PORT_FAULT_INVALID) + info->hilink_ref_status = NIC_PORT_FAULT_INVALID; +} + +static void hikp_nic_port_fault_show(struct nic_port_fault_status *info) +{ + const char *port_fault_info[] = { + "OK", + "Device error", + "Device not support", + "Invalid" + }; + + hikp_nic_format_port_fault_info(info); + printf("############ NIC port fault status ###############\n"); + printf("cdr flash : %s.\n", port_fault_info[info->cdr_flash_status]); + printf("cdr core : %s.\n", port_fault_info[info->cdr_core_status]); + printf("9545 fault: %s.\n", port_fault_info[info->fault_9545_status]); + printf("hilink ref: %s.\n", port_fault_info[info->hilink_ref_status]); + printf("#################### END #######################\n"); +} + +static void hikp_nic_port_fault_cmd_execute(struct major_cmd_ctrl *self) +{ + struct bdf_t *bdf = &g_port_fault_target.bdf; + struct nic_port_fault_status info; + int ret; + + ret = hikp_nic_port_fault_query(bdf, &info); + if (ret != 0) { + snprintf(self->err_str, sizeof(self->err_str), "fail to get fault info."); + self->err_no = ret; + return; + } + + hikp_nic_port_fault_show(&info); +} + +static int hikp_nic_port_fault_cmd_help(struct major_cmd_ctrl *self, const char *argv) +{ + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i <device>"); + printf("\n %s\n", self->cmd_ptr->help_info); + printf("\n Options:\n\n"); + printf(" %s, %-25s %s\n", "-h", "--help", "display this help and exit"); + printf(" %s, %-25s %s\n", "-i", "--interface=<interface>", + "device target or bdf id, e.g. eth0~7 or 0000:35:00.0"); + + return 0; +} + +static int hikp_nic_port_fault_get_target(struct major_cmd_ctrl *self, const char *argv) +{ + self->err_no = tool_check_and_get_valid_bdf_id(argv, &g_port_fault_target); + if (self->err_no != 0) { + snprintf(self->err_str, sizeof(self->err_str), "unknown device!"); + return self->err_no; + } + + if (g_port_fault_target.bdf.dev_id != 0) { + snprintf(self->err_str, sizeof(self->err_str), "VF is not supported!"); + self->err_no = -EOPNOTSUPP; + return self->err_no; + } + + return 0; +} + +static void cmd_nic_port_fault_init(void) +{ + struct major_cmd_ctrl *major_cmd = get_major_cmd(); + + major_cmd->option_count = 0; + major_cmd->execute = hikp_nic_port_fault_cmd_execute; + + cmd_option_register("-h", "--help", false, hikp_nic_port_fault_cmd_help); + cmd_option_register("-i", "--interface", true, hikp_nic_port_fault_get_target); +} + +HIKP_CMD_DECLARE("nic_port_fault", "dump port fault of nic!", cmd_nic_port_fault_init); diff --git a/net/nic/nic_ft/hikp_nic_port_fault.h b/net/nic/nic_ft/hikp_nic_port_fault.h new file mode 100644 index 0000000..7db54f7 --- /dev/null +++ b/net/nic/nic_ft/hikp_nic_port_fault.h @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2023 Hisilicon Technologies Co., Ltd. + * Hikptool is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * + * See the Mulan PSL v2 for more details. + */ + +#ifndef HIKP_NIC_PORT_FAULT_H +#define HIKP_NIC_PORT_FAULT_H + +#include "hikp_net_lib.h" + +enum nic_port_fault_sub_cmd_type { + NIC_PORT_FAULT_INFO_DUMP, +}; + +enum nic_port_fault_info_type { + NIC_PORT_FAULT_OK, + NIC_PORT_FAULT_ERR, + NIC_PORT_FAULT_NOTSUP, + NIC_PORT_FAULT_INVALID +}; + +struct nic_port_fault_req_para { + struct bdf_t bdf; + uint8_t block_id; +}; + +struct nic_port_fault_rsp_head { + uint8_t total_blk_num; + uint8_t curr_blk_size; + uint16_t rsv; +}; + +#define NIC_PORT_FAULT_MAX_RSP_DATA 1 +struct nic_port_fault_rsp { + struct nic_port_fault_rsp_head head; + uint32_t data[NIC_PORT_FAULT_MAX_RSP_DATA]; +}; + +struct nic_port_fault_status { + uint8_t cdr_flash_status; + uint8_t fault_9545_status; + uint8_t cdr_core_status; + uint8_t hilink_ref_status; +}; + +#endif /* HIKP_NIC_PORT_FAULT_H */ -- 2.30.0

From: Hao Chen <chenhao418@huawei.com> add nic_torus cmd for query 1D torus setting info AR:AR20230712033425 Bugfix or Feature: Feature Signed-off-by: Hao Chen <chenhao418@huawei.com> --- net/hikp_net_lib.h | 1 + net/nic/nic_torus/hikp_nic_torus.c | 189 +++++++++++++++++++++++++++++ net/nic/nic_torus/hikp_nic_torus.h | 76 ++++++++++++ 3 files changed, 266 insertions(+) create mode 100644 net/nic/nic_torus/hikp_nic_torus.c create mode 100644 net/nic/nic_torus/hikp_nic_torus.h diff --git a/net/hikp_net_lib.h b/net/hikp_net_lib.h index cb537ff..21b5357 100644 --- a/net/hikp_net_lib.h +++ b/net/hikp_net_lib.h @@ -80,6 +80,7 @@ enum nic_cmd_type { GET_GRO_INFO_CMD, GET_NCSI_INFO_CMD, GET_NOTIFY_PKT_CMD, + GET_TORUS_INFO_CMD = 0xD, GET_PORT_FAULT_STATUS = 0xE, }; diff --git a/net/nic/nic_torus/hikp_nic_torus.c b/net/nic/nic_torus/hikp_nic_torus.c new file mode 100644 index 0000000..4baede6 --- /dev/null +++ b/net/nic/nic_torus/hikp_nic_torus.c @@ -0,0 +1,189 @@ +/* + * Copyright (c) 2023 Hisilicon Technologies Co., Ltd. + * Hikptool is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * + * See the Mulan PSL v2 for more details. + */ + +#include <stdio.h> +#include <string.h> +#include <sys/types.h> +#include <unistd.h> + +#include "hikp_nic_torus.h" + +static struct tool_target g_torus_target; + +static int hikp_nic_torus_query(const struct bdf_t *bdf, + struct nic_torus_info *info) +{ + struct nic_torus_req_para req = { 0 }; + struct hikp_cmd_header header = { 0 }; + struct hikp_cmd_ret *cmd_ret; + struct nic_torus_rsp *rsp; + + req.bdf = *bdf; + hikp_cmd_init(&header, NIC_MOD, GET_TORUS_INFO_CMD, NIC_TORUS_INFO_DUMP); + cmd_ret = hikp_cmd_alloc(&header, &req, sizeof(req)); + if (cmd_ret == NULL || cmd_ret->status != 0) { + HIKP_ERROR_PRINT("fail to get torus info, retcode: %u\n", + cmd_ret ? cmd_ret->status : EIO); + if (cmd_ret) + free(cmd_ret); + return -EIO; + } + + rsp = (struct nic_torus_rsp *)cmd_ret->rsp_data; + *info = *(struct nic_torus_info *)rsp->data; + free(cmd_ret); + + return 0; +} + +static void hikp_nic_torus_lan_prt_pair_show(const struct nic_torus_info *info) +{ + uint32_t mac_id = hikp_get_field(info->lan_prt_pair, NIC_TORUS_MAC_ID_M, + NIC_TORUS_MAC_ID_S); + uint32_t uc_lan_pair_en = hikp_get_bit(info->lan_prt_pair, + NIC_TORUS_UC_LAN_PAIR_EN); + uint32_t mc_bc_lan_pair_en = hikp_get_bit(info->lan_prt_pair, + NIC_TORUS_MC_BC_LAN_PAIR_EN); + uint32_t lldp_lan_pair_en = hikp_get_bit(info->lan_prt_pair, + NIC_TORUS_LLDP_LAN_PAIR_EN); + uint32_t tc2vlanpri_mapping_en = hikp_get_bit(info->lan_prt_pair, + NIC_TORUS_TC2VLANPRI_MAPPING_EN); + uint32_t torus_lpbk_drop_en = hikp_get_bit(info->lan_prt_pair, + NIC_TORUS_LPBK_DROP_EN); + + printf("dst mac id: %u\n", mac_id); + printf("uc_lan_pair_en: %u\n", uc_lan_pair_en); + printf("mc_bc_lan_pair_en: %u\n", mc_bc_lan_pair_en); + printf("lldp_lan_pair_en: %u\n", lldp_lan_pair_en); + printf("tc2vlanpri_mapping_en: %u\n", tc2vlanpri_mapping_en); + printf("torus_lpbk_drop_en: %u\n", torus_lpbk_drop_en); +} + +static void hikp_nic_torus_lan_fwd_tc_cfg_show(const struct nic_torus_info *info) +{ + uint32_t tc0_map_tc = hikp_get_field(info->lan_fwd_tc_cfg, + NIC_TORUS_TC0_MAP_TC_M, + NIC_TORUS_TC0_MAP_TC_S); + uint32_t tc1_map_tc = hikp_get_field(info->lan_fwd_tc_cfg, + NIC_TORUS_TC1_MAP_TC_M, + NIC_TORUS_TC1_MAP_TC_S); + uint32_t tc2_map_tc = hikp_get_field(info->lan_fwd_tc_cfg, + NIC_TORUS_TC2_MAP_TC_M, + NIC_TORUS_TC2_MAP_TC_S); + uint32_t tc3_map_tc = hikp_get_field(info->lan_fwd_tc_cfg, + NIC_TORUS_TC3_MAP_TC_M, + NIC_TORUS_TC3_MAP_TC_S); + + printf("tc0_map_tc : %u\n", tc0_map_tc); + printf("tc1_map_tc : %u\n", tc1_map_tc); + printf("tc2_map_tc : %u\n", tc2_map_tc); + printf("tc3_map_tc : %u\n", tc3_map_tc); +} + +static void hikp_nic_torus_switch_param_show(const struct nic_torus_info *info) +{ + printf("nic_mac_anti_spoof_en: %s\n", info->nic_switch_param & + NIC_TORUS_MAC_ANTI_SPOOF_EN_MASK ? "enable" : "disable"); + printf("nic_alw_lpbk: %s\n", info->nic_switch_param & + NIC_TORUS_ALW_LPBK_MASK ? "enable" : "disable"); + printf("nic_alw_lcl_lpbk: %s\n", info->nic_switch_param & + NIC_TORUS_ALW_LCL_LPBK_MASK ? "enable" : "disable"); + printf("nic_alw_dst_ovrd: %s\n", info->nic_switch_param & + NIC_TORUS_ALW_DST_OVRD_MASK ? "enable" : "disable"); + printf("roce_mac_anti_spoof_en: %s\n", info->roce_switch_param & + NIC_TORUS_MAC_ANTI_SPOOF_EN_MASK ? "enable" : "disable"); + printf("roce_alw_lpbk: %s\n", info->roce_switch_param & + NIC_TORUS_ALW_LPBK_MASK ? "enable" : "disable"); + printf("roce_alw_lcl_lpbk: %s\n", info->roce_switch_param & + NIC_TORUS_ALW_LCL_LPBK_MASK ? "enable" : "disable"); + printf("roce_alw_dst_ovrd: %s\n", info->roce_switch_param & + NIC_TORUS_ALW_DST_OVRD_MASK ? "enable" : "disable"); +} + +static void hikp_nic_torus_show(const struct nic_torus_info *info) +{ + printf("################ NIC TORUS info ##################\n"); + printf("enable: %s\n", info->enable ? "true" : "false"); + + hikp_nic_torus_lan_prt_pair_show(info); + + hikp_nic_torus_lan_fwd_tc_cfg_show(info); + + printf("ssu_pause_time_out: %uus\n", info->pause_time_out); + printf("ssu_pause_time_out_en: %u\n", info->pause_time_out_en); + printf("vlan_fe: 0x%x (for port vlan)\n", info->vlan_fe); + printf("ets_tcg0_mapping: 0x%x\n", info->ets_tcg0_mapping); + printf("ets_tcg0_mapping is showed as 0xff if ncl_config forward bit is setted to 1\n"); + + hikp_nic_torus_switch_param_show(info); + + printf("#################### END ##########################\n"); +} + +static void hikp_nic_torus_cmd_execute(struct major_cmd_ctrl *self) +{ + struct bdf_t *bdf = &g_torus_target.bdf; + struct nic_torus_info info; + int ret; + + ret = hikp_nic_torus_query(bdf, &info); + if (ret != 0) { + snprintf(self->err_str, sizeof(self->err_str), "fail to obtain torus info."); + self->err_no = ret; + return; + } + + hikp_nic_torus_show(&info); +} + +static int hikp_nic_torus_cmd_help(struct major_cmd_ctrl *self, const char *argv) +{ + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i <device>"); + printf("\n %s\n", self->cmd_ptr->help_info); + printf("\n Options:\n\n"); + printf(" %s, %-25s %s\n", "-h", "--help", "display this help and exit"); + printf(" %s, %-25s %s\n", "-i", "--interface=<interface>", + "device target or bdf id, e.g. eth0~7 or 0000:35:00.0"); + + return 0; +} + +static int hikp_nic_torus_get_target(struct major_cmd_ctrl *self, const char *argv) +{ + self->err_no = tool_check_and_get_valid_bdf_id(argv, &g_torus_target); + if (self->err_no != 0) { + snprintf(self->err_str, sizeof(self->err_str), "unknown device!"); + return self->err_no; + } + + if (g_torus_target.bdf.dev_id != 0) { + snprintf(self->err_str, sizeof(self->err_str), "VF does not support query!"); + self->err_no = -EOPNOTSUPP; + return self->err_no; + } + + return 0; +} + +static void cmd_nic_torus_init(void) +{ + struct major_cmd_ctrl *major_cmd = get_major_cmd(); + + major_cmd->option_count = 0; + major_cmd->execute = hikp_nic_torus_cmd_execute; + + cmd_option_register("-h", "--help", false, hikp_nic_torus_cmd_help); + cmd_option_register("-i", "--interface", true, hikp_nic_torus_get_target); +} + +HIKP_CMD_DECLARE("nic_torus", "dump torus info of nic!", cmd_nic_torus_init); diff --git a/net/nic/nic_torus/hikp_nic_torus.h b/net/nic/nic_torus/hikp_nic_torus.h new file mode 100644 index 0000000..e6b6552 --- /dev/null +++ b/net/nic/nic_torus/hikp_nic_torus.h @@ -0,0 +1,76 @@ +/* + * Copyright (c) 2023 Hisilicon Technologies Co., Ltd. + * Hikptool is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * + * See the Mulan PSL v2 for more details. + */ + +#ifndef HIKP_NIC_TORUS_H +#define HIKP_NIC_TORUS_H + +#include "hikp_net_lib.h" + +#define NIC_TORUS_MAC_ANTI_SPOOF_EN_MASK 0x1 +#define NIC_TORUS_ALW_LPBK_MASK 0x2 +#define NIC_TORUS_ALW_LCL_LPBK_MASK 0x4 +#define NIC_TORUS_ALW_DST_OVRD_MASK 0x8 + +#define NIC_TORUS_UC_LAN_PAIR_EN 16 +#define NIC_TORUS_MC_BC_LAN_PAIR_EN 17 +#define NIC_TORUS_LLDP_LAN_PAIR_EN 18 +#define NIC_TORUS_TC2VLANPRI_MAPPING_EN 19 +#define NIC_TORUS_LPBK_DROP_EN 20 + +#define NIC_TORUS_MAC_ID_M GENMASK(1, 0) +#define NIC_TORUS_MAC_ID_S 0 + +#define NIC_TORUS_TC0_MAP_TC_M GENMASK(2, 0) +#define NIC_TORUS_TC0_MAP_TC_S 0 +#define NIC_TORUS_TC1_MAP_TC_M GENMASK(8, 6) +#define NIC_TORUS_TC1_MAP_TC_S 6 +#define NIC_TORUS_TC2_MAP_TC_M GENMASK(14, 12) +#define NIC_TORUS_TC2_MAP_TC_S 12 +#define NIC_TORUS_TC3_MAP_TC_M GENMASK(20, 18) +#define NIC_TORUS_TC3_MAP_TC_S 18 + +enum nic_torus_sub_cmd_type { + NIC_TORUS_INFO_DUMP, +}; + +struct nic_torus_req_para { + struct bdf_t bdf; + uint8_t block_id; + uint8_t rsv[3]; +}; + +struct nic_torus_rsp_head { + uint8_t total_blk_num; + uint8_t curr_blk_size; /* real data size, not contain head size. */ + uint16_t rsv; +}; + +#define NIC_TORUS_MAX_RSP_DATA 6 +struct nic_torus_rsp { + struct nic_torus_rsp_head head; + uint32_t data[NIC_TORUS_MAX_RSP_DATA]; +}; + +struct nic_torus_info { + uint32_t enable; + uint32_t lan_prt_pair; + uint32_t lan_fwd_tc_cfg; + uint32_t pause_time_out; + uint8_t pause_time_out_en; + uint8_t vlan_fe; + uint8_t nic_switch_param; + uint8_t roce_switch_param; + uint32_t ets_tcg0_mapping; +}; + +#endif /* HIKP_NIC_TORUS_H */ -- 2.30.0

不要往 kernel 邮件列表中发送非 kernel 相关的 patch。 On 2023/10/6 14:44, veega2022 wrote:

The hikptool ub_dfx command is submitted for the first time. This command can be used to dump register information of the LRB, PFA, and PM modules.

Signed-off-by: Jianqiang Li <lijianqiang16@huawei.com> --- libhikptdev/include/hikptdev_plug.h | 1 + net/hikp_net_lib.h | 9 + net/ub/ub_dfx/hikp_ub_dfx.c | 319 ++++++++++++++++++++++++++++ net/ub/ub_dfx/hikp_ub_dfx.h | 100 +++++++++ tool_lib/tool_lib.h | 2 +- 5 files changed, 430 insertions(+), 1 deletion(-) create mode 100644 net/ub/ub_dfx/hikp_ub_dfx.c create mode 100644 net/ub/ub_dfx/hikp_ub_dfx.h

diff --git a/libhikptdev/include/hikptdev_plug.h b/libhikptdev/include/hikptdev_plug.h index 42bea6b..56cea78 100644 --- a/libhikptdev/include/hikptdev_plug.h +++ b/libhikptdev/include/hikptdev_plug.h @@ -43,6 +43,7 @@ enum cmd_module_type { MAC_MOD = 8, DPDK_MOD = 9, CXL_MOD = 10, + UB_MOD = 11, };

void hikp_unlock(void); diff --git a/net/hikp_net_lib.h b/net/hikp_net_lib.h index cc99d0c..af0a51d 100644 --- a/net/hikp_net_lib.h +++ b/net/hikp_net_lib.h @@ -98,6 +98,15 @@ enum roce_cmd_type { GET_ROCEE_TSP_CMD, };

+enum ub_cmd_type { + GET_UNIC_PPP_CMD = 0x1, + GET_UB_DFX_INFO_CMD, + GET_UB_LINK_INFO_CMD, + GET_UB_BP_INFO_CMD, + GET_UB_CRD_INFO_CMD, + GET_UB_BASIC_INFO_CMD, +}; + #define HIKP_MAX_PF_NUM 8 #define HIKP_NIC_MAX_FUNC_NUM 256

diff --git a/net/ub/ub_dfx/hikp_ub_dfx.c b/net/ub/ub_dfx/hikp_ub_dfx.c new file mode 100644 index 0000000..c50f555 --- /dev/null +++ b/net/ub/ub_dfx/hikp_ub_dfx.c @@ -0,0 +1,319 @@ +/* + * Copyright (c) 2023 Hisilicon Technologies Co., Ltd. + * Hikptool is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * + * See the Mulan PSL v2 for more details. + */ + +#include "tool_cmd.h" +#include "hikp_net_lib.h" +#include "hikp_ub_dfx.h" + +struct ub_dfx_param g_ub_dfx_param = { 0 }; + +static const struct dfx_module_cmd g_ub_dfx_module_parse[] = { + {"LRB", LRB_DFX_REG_DUMP}, + {"PFA", PFA_DFX_REG_DUMP}, + {"PM", PM_DFX_REG_DUMP} +}; + +static const struct dfx_type_parse g_dfx_type_parse[] = { + {INCORRECT_REG_TYPE, WIDTH_32_BIT, "INCORRECT TYPE"}, + {TYPE_32_STATS, WIDTH_32_BIT, "32 bit statistics"}, + {TYPE_32_RUNNING_STATUS, WIDTH_32_BIT, "32 bit running status"}, + {TYPE_64_STATS, WIDTH_64_BIT, "64 bit statistics"}, +}; + +static void dfx_help_info(const struct major_cmd_ctrl *self) +{ + printf("\n Usage: %s %s\n", self->cmd_ptr->name, "-i <interface>\n"); + printf("\n %s\n", self->cmd_ptr->help_info); + printf(" Options:\n\n"); + printf(" %s, %-25s %s\n", "-h", "--help", "display this help and exit"); + printf(" %s, %-25s %s\n", "-i", "--interface=<interface>", + "device target or bdf id, e.g. ubn0 or 0000:35:00.0"); + printf(" %s\n", " [-m/--module LRB/PFA/PM] : this is necessary param\n"); +} + +static int hikp_ub_dfx_help(struct major_cmd_ctrl *self, const char *argv) +{ + dfx_help_info(self); + return 0; +} + +static int hikp_ub_dfx_target(struct major_cmd_ctrl *self, const char *argv) +{ + self->err_no = tool_check_and_get_valid_bdf_id(argv, &(g_ub_dfx_param.target)); + if (self->err_no != 0) { + snprintf(self->err_str, sizeof(self->err_str), "Unknown device %s.", argv); + return self->err_no; + } + + return 0; +} + +static int hikp_ub_dfx_module_select(struct major_cmd_ctrl *self, const char *argv) +{ + size_t arr_size = HIKP_ARRAY_SIZE(g_ub_dfx_module_parse); + bool is_found; + size_t i; + + for (i = 0; i < arr_size; i++) { + is_found = strncmp(argv, (const char *)g_ub_dfx_module_parse[i].module_name, + sizeof(g_ub_dfx_module_parse[i].module_name)) == 0; + if (is_found) { + g_ub_dfx_param.sub_cmd_code = g_ub_dfx_module_parse[i].sub_cmd_code; + g_ub_dfx_param.module_idx = i; + g_ub_dfx_param.flag |= MODULE_SET_FLAG; + return 0; + } + } + dfx_help_info(self); + snprintf(self->err_str, sizeof(self->err_str), "-m/--module param error!!!"); + self->err_no = -EINVAL; + + return -EINVAL; +} + +static int hikp_ub_dfx_get_blk_data(struct hikp_cmd_ret **cmd_ret, + uint32_t blk_id, uint32_t sub_cmd_code) +{ + struct hikp_cmd_header req_header = { 0 }; + struct ub_dfx_req_para req_data = { 0 }; + + req_data.bdf = g_ub_dfx_param.target.bdf; + req_data.block_id = blk_id; + hikp_cmd_init(&req_header, UB_MOD, GET_UB_DFX_INFO_CMD, sub_cmd_code); + *cmd_ret = hikp_cmd_alloc(&req_header, &req_data, sizeof(req_data)); + + return hikp_rsp_normal_check(*cmd_ret); +} + +static int hikp_ub_get_first_blk_dfx(struct ub_dfx_rsp_head *rsp_head, uint32_t **reg_data, + uint32_t *max_dfx_size, uint32_t *version) +{ + struct ub_dfx_rsp *dfx_rsp = NULL; + struct hikp_cmd_ret *cmd_ret; + int ret; + + ret = hikp_ub_dfx_get_blk_data(&cmd_ret, 0, g_ub_dfx_param.sub_cmd_code); + if (ret < 0) + goto err_out; + + dfx_rsp = (struct ub_dfx_rsp *)(cmd_ret->rsp_data); + *version = cmd_ret->version; + *rsp_head = dfx_rsp->rsp_head; + if (rsp_head->total_blk_num == 0) { + /* if total block number is zero, set total type number to zero anyway */ + rsp_head->total_type_num = 0; + goto err_out; + } + *max_dfx_size = (uint32_t)(rsp_head->total_blk_num * MAX_DFX_DATA_NUM * sizeof(uint32_t)); + *reg_data = (uint32_t *)calloc(1, *max_dfx_size); + if (*reg_data == NULL) { + HIKP_ERROR_PRINT("malloc log memory 0x%x failed.\n", *max_dfx_size); + ret = -ENOMEM; + goto err_out; + } + + if (rsp_head->cur_blk_size > *max_dfx_size) { + free(*reg_data); + *reg_data = NULL; + HIKP_ERROR_PRINT("blk0 reg_data copy size error, data size: 0x%x, max size: 0x%x\n", + rsp_head->cur_blk_size, *max_dfx_size); + ret = -EINVAL; + goto err_out; + } + memcpy(*reg_data, dfx_rsp->reg_data, rsp_head->cur_blk_size); + + *max_dfx_size -= (uint32_t)rsp_head->cur_blk_size; +err_out: + free(cmd_ret); + cmd_ret = NULL; + + return ret; +} + +static int hikp_ub_get_blk_dfx(struct ub_dfx_rsp_head *rsp_head, uint32_t blk_id, + uint32_t *reg_data, uint32_t *max_dfx_size) +{ + struct ub_dfx_rsp *dfx_rsp = NULL; + struct hikp_cmd_ret *cmd_ret; + int ret; + + ret = hikp_ub_dfx_get_blk_data(&cmd_ret, blk_id, g_ub_dfx_param.sub_cmd_code); + if (ret < 0) + goto err_out; + + dfx_rsp = (struct ub_dfx_rsp *)(cmd_ret->rsp_data); + *rsp_head = dfx_rsp->rsp_head; + if (rsp_head->cur_blk_size > *max_dfx_size) { + HIKP_ERROR_PRINT("blk%u reg_data copy size error, " + "data size: 0x%x, max size: 0x%x\n", + blk_id, rsp_head->cur_blk_size, *max_dfx_size); + ret = -EINVAL; + goto err_out; + } + memcpy(reg_data, dfx_rsp->reg_data, rsp_head->cur_blk_size); + *max_dfx_size -= (uint32_t)rsp_head->cur_blk_size; + +err_out: + free(cmd_ret); + cmd_ret = NULL; + + return ret; +} + +static bool is_type_found(uint16_t type_id, uint32_t *index) +{ + size_t arr_size = HIKP_ARRAY_SIZE(g_dfx_type_parse); + size_t i; + + for (i = 0; i < arr_size; i++) { + if (g_dfx_type_parse[i].type_id == type_id) { + *index = i; + return true; + } + } + + return false; +} + +static void hikp_ub_dfx_print_type_head(uint8_t type_id, uint8_t *last_type_id) +{ + uint32_t index = 0; + + if (type_id != *last_type_id) { + printf("-----------------------------------------------------\n"); + if (is_type_found(type_id, &index)) + printf("type name: %s\n\n", g_dfx_type_parse[index].type_name); + else + HIKP_WARN_PRINT("type name: unknown type, type id is %u\n\n", type_id); + + *last_type_id = type_id; + } +} + +static void hikp_ub_dfx_print_b32(uint32_t num, uint32_t *reg_data) +{ + uint32_t word_num = num * WORD_NUM_PER_REG; + uint16_t offset; + uint32_t value; + uint32_t index; + uint32_t i; + + for (i = 0, index = 1; i < word_num; i = i + WORD_NUM_PER_REG, index++) { + offset = (uint16_t)HI_GET_BITFIELD(reg_data[i], 0, DFX_REG_ADDR_MASK); + value = reg_data[i + 1]; + printf("%03u: 0x%04x\t0x%08x\n", index, offset, value); + } +} + +static void hikp_ub_dfx_print_b64(uint32_t num, uint32_t *reg_data) +{ + uint32_t word_num = num * WORD_NUM_PER_REG; + uint16_t offset; + uint64_t value; + uint32_t index; + uint32_t i; + + for (i = 0, index = 1; i < word_num; i = i + WORD_NUM_PER_REG, index++) { + offset = (uint16_t)HI_GET_BITFIELD(reg_data[i], 0, DFX_REG_ADDR_MASK); + value = (uint64_t)reg_data[i + 1] | + (HI_GET_BITFIELD((uint64_t)reg_data[i], DFX_REG_VALUE_OFF, + DFX_REG_VALUE_MASK) << BIT_NUM_OF_WORD); + printf("%03u: 0x%04x\t0x%016lx\n", index, offset, value); + } +} + +static void hikp_ub_dfx_print(const struct ub_dfx_rsp_head *rsp_head, uint32_t *reg_data) +{ + struct ub_dfx_type_head *type_head; + uint8_t last_type_id = 0; + uint32_t *ptr = reg_data; + uint8_t i; + + printf("****************** module %s reg dump start ********************\n", + g_ub_dfx_module_parse[g_ub_dfx_param.module_idx].module_name); + for (i = 0; i < rsp_head->total_type_num; i++) { + type_head = (struct ub_dfx_type_head *)ptr; + if (type_head->type_id == INCORRECT_REG_TYPE) { + HIKP_ERROR_PRINT("No.%u type is incorrect reg type\n", i + 1u); + break; + } + hikp_ub_dfx_print_type_head(type_head->type_id, &last_type_id); + ptr++; + if (type_head->bit_width == WIDTH_32_BIT) { + hikp_ub_dfx_print_b32((uint32_t)type_head->reg_num, ptr); + } else if (type_head->bit_width == WIDTH_64_BIT) { + hikp_ub_dfx_print_b64((uint32_t)type_head->reg_num, ptr); + } else { + HIKP_ERROR_PRINT("type%u's bit width error.\n", type_head->type_id); + break; + } + ptr += (uint32_t)type_head->reg_num * WORD_NUM_PER_REG; + } + printf("################### ====== dump end ====== ######################\n"); +} + +static void hikp_ub_dfx_execute(struct major_cmd_ctrl *self) +{ + struct ub_dfx_rsp_head rsp_head = { 0 }; + struct ub_dfx_rsp_head tmp_head = { 0 }; + uint32_t *reg_data = NULL; + uint32_t max_dfx_size = 0; + uint32_t real_reg_size; + uint32_t version; + uint32_t i; + + if (!(g_ub_dfx_param.flag & MODULE_SET_FLAG)) { + self->err_no = -EINVAL; + snprintf(self->err_str, sizeof(self->err_str), "Please specify a module."); + dfx_help_info(self); + return; + } + + self->err_no = hikp_ub_get_first_blk_dfx(&rsp_head, ®_data, &max_dfx_size, &version); + if (self->err_no != 0) { + snprintf(self->err_str, sizeof(self->err_str), "get the first block dfx fail."); + return; + } + real_reg_size = (uint32_t)rsp_head.cur_blk_size; + for (i = 1; i < rsp_head.total_blk_num; i++) { + self->err_no = hikp_ub_get_blk_dfx(&tmp_head, i, + reg_data + (real_reg_size / sizeof(uint32_t)), + &max_dfx_size); + if (self->err_no != 0) { + snprintf(self->err_str, sizeof(self->err_str), + "getting block%u reg fail.", i); + free(reg_data); + return; + } + real_reg_size += (uint32_t)tmp_head.cur_blk_size; + memset(&tmp_head, 0, sizeof(struct ub_dfx_rsp_head)); + } + + printf("DFX cmd version: 0x%x\n\n", version); + hikp_ub_dfx_print((const struct ub_dfx_rsp_head *)&rsp_head, reg_data); + free(reg_data); +} + +static void cmd_ub_dfx_init(void) +{ + struct major_cmd_ctrl *major_cmd = get_major_cmd(); + + major_cmd->option_count = 0; + major_cmd->execute = hikp_ub_dfx_execute; + + cmd_option_register("-h", "--help", false, hikp_ub_dfx_help); + cmd_option_register("-i", "--interface", true, hikp_ub_dfx_target); + cmd_option_register("-m", "--module", true, hikp_ub_dfx_module_select); +} + +HIKP_CMD_DECLARE("ub_dfx", "dump ub dfx info of hardware", cmd_ub_dfx_init); diff --git a/net/ub/ub_dfx/hikp_ub_dfx.h b/net/ub/ub_dfx/hikp_ub_dfx.h new file mode 100644 index 0000000..4ba37a1 --- /dev/null +++ b/net/ub/ub_dfx/hikp_ub_dfx.h @@ -0,0 +1,100 @@ +/* + * Copyright (c) 2023 Hisilicon Technologies Co., Ltd. + * Hikptool is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * + * See the Mulan PSL v2 for more details. + */ + +#ifndef HIKP_UB_DFX_H +#define HIKP_UB_DFX_H + +#include "hikp_net_lib.h" + +#define MAX_DFX_DATA_NUM 59 +#define MODULE_SET_FLAG 0x1 + +enum ub_dfx_cmd_type { + LRB_DFX_REG_DUMP = 0, + PFA_DFX_REG_DUMP = 1, + PM_DFX_REG_DUMP = 2, + INVALID_MODULE = 0xFFFFFFFF, +}; + +enum ub_dfx_reg_type { + INCORRECT_REG_TYPE = 0, + TYPE_32_STATS = 1, + TYPE_32_RUNNING_STATUS = 2, + TYPE_64_STATS = 3, + TYPE_INVALID = 255, +}; + +#define MAX_TYPE_NAME_LEN 40 + +enum ub_dfx_reg_width { + WIDTH_32_BIT = 32, + WIDTH_64_BIT = 64, +}; + +struct dfx_type_parse { + uint8_t type_id; + uint8_t bit_width; + uint8_t type_name[MAX_TYPE_NAME_LEN]; +}; + +struct ub_dfx_param { + struct tool_target target; + uint32_t sub_cmd_code; + uint8_t module_idx; + uint8_t flag; +}; + +#define MAX_MODULE_NAME_LEN 20 +struct dfx_module_cmd { + uint8_t module_name[MAX_MODULE_NAME_LEN]; + uint32_t sub_cmd_code; +}; + +struct ub_dfx_req_para { + struct bdf_t bdf; + uint8_t block_id; +}; + +struct ub_dfx_type_head { + uint8_t type_id; + uint8_t bit_width; + uint8_t reg_num; + uint8_t flag; +}; + +struct ub_dfx_rsp_head { + uint8_t total_blk_num; + uint8_t total_type_num; + uint8_t cur_blk_size; + uint8_t rsvd; +}; + +/********************************************************* + * All registers are returned as key-value pairs, and divided + * into three groups of data. + * 1. 32bit regs: R0 bit0~bit15: offset, R1 bit0~bit31: value + * 2. 64bit regs: R0 bit0~bit15: offset, R0 bit16~bit31 high16 value, R1 bit0~bit31: low32 value + *********************************************************/ +#define DFX_REG_VALUE_OFF 16 +#define DFX_REG_VALUE_MASK 0xFFFF +#define DFX_REG_ADDR_MASK 0xFFFF + +#define WORD_NUM_PER_REG 2 +#define BIT_NUM_OF_WORD 32 + +struct ub_dfx_rsp { + struct ub_dfx_rsp_head rsp_head; + uint32_t reg_data[MAX_DFX_DATA_NUM]; +}; + +#endif /* HIKP_UB_DFX_H */ diff --git a/tool_lib/tool_lib.h b/tool_lib/tool_lib.h index b211175..bf37465 100644 --- a/tool_lib/tool_lib.h +++ b/tool_lib/tool_lib.h @@ -18,7 +18,7 @@

#define TOOL_NAME "hikptool"

-#define TOOL_VER "1.0.14" +#define TOOL_VER "1.0.15"

#define HI_GET_BITFIELD(value, start, mask) (((value) >> (start)) & (mask)) #define HI_SET_FIELD(origin, shift, val) ((origin) |= (val) << (shift)) -- 2.36.1.windows.1 _______________________________________________ Kernel mailing list -- kernel@openeuler.org To unsubscribe send an email to kernel-leave@openeuler.org