diff --git a/cxl/func_lib/cxl_func/cxl_feature.c b/cxl/func_lib/cxl_func/cxl_feature.c
index 6de3f89c4aa24b4b3dfa04d2fcfd5b7dc51d139f..cd41b09fc7f896a90cdb7d384431d0ea891eba3e 100644
--- a/cxl/func_lib/cxl_func/cxl_feature.c
+++ b/cxl/func_lib/cxl_func/cxl_feature.c
@@ -77,13 +77,9 @@ static void cxl_dl_fsm_str_get(struct cxl_fsm_state_str *fsm_str_table,
 {
 	int i = 0;
 
-	while (fsm_str_table[i].fsm_state >= 0) {
-		if ((uint32_t)fsm_str_table[i].fsm_state != fsm_state) {
-			i++;
-			continue;
-		}
-		break;
-	}
+	while (fsm_str_table[i].fsm_state >= 0 &&
+	       (uint32_t)fsm_str_table[i].fsm_state != fsm_state)
+		i++;
 
 	*fsm_s = fsm_str_table[i].fsm_str;
 }
@@ -95,7 +91,7 @@ static void cxl_dl_fsm_state_print(const struct cxl_data_unit *data, uint32_t da
 	struct cxl_fsm_state_str rrsm_state[] = {
 		{0x0, "retry_remote_normal"},
 		{0x1, "retry_llrack"},
-		{-1, "unknow"}
+		{-1, "unknown"}
 	};
 	struct cxl_fsm_state_str lrsm_state[] = {
 		{0x1, "retry_local_normal"},
@@ -103,14 +99,14 @@ static void cxl_dl_fsm_state_print(const struct cxl_data_unit *data, uint32_t da
 		{0x4, "retry_phy_reinit"},
 		{0x8, "retry_local_idle"},
 		{0x10, "retry_abort"},
-		{-1, "unknow"}
+		{-1, "unknown"}
 	};
 	struct cxl_fsm_state_str init_fsm_state[] = {
 		{0x1, "inactive"},
 		{0x2, "retry"},
 		{0x4, "param"},
 		{0x8, "active"},
-		{-1, "unknow"}
+		{-1, "unknown"}
 	};
 
 	if (data_unit_len == 0) {
diff --git a/cxl/usr_cmd/cmd_analysis/cxl_cmd_cpa.c b/cxl/usr_cmd/cmd_analysis/cxl_cmd_cpa.c
index 2607705c13611540a207eb0c473d763ee49f754e..2df9dc59e4d8cdd467d83b464a1d93d15900a960 100644
--- a/cxl/usr_cmd/cmd_analysis/cxl_cmd_cpa.c
+++ b/cxl/usr_cmd/cmd_analysis/cxl_cmd_cpa.c
@@ -46,7 +46,7 @@ static int cxl_port_id_set(struct major_cmd_ctrl *self, const char *argv)
 
 	ret = string_toui(argv, &val);
 	if (ret) {
-		printf("cpa set port id err %d\n", ret);
+		printf("cxl cpa set port id err %d\n", ret);
 		return ret;
 	}
 	g_cxl_cpa_cmd.port_id = val;
diff --git a/libhikptdev/src/rciep/hikpt_rciep.c b/libhikptdev/src/rciep/hikpt_rciep.c
index 5c7e82faa67fca3c952f4d111cd29d214647194a..f673dd05043a4d4a44ab76c1304596d4fe1faf6b 100644
--- a/libhikptdev/src/rciep/hikpt_rciep.c
+++ b/libhikptdev/src/rciep/hikpt_rciep.c
@@ -41,7 +41,7 @@ static int hikp_memcpy_io(void *dst, size_t dst_size, void const *src, size_t sr
 	if (dst_size < src_size)
 		return -EINVAL;
 
-	for (i = 0; i < src_size / sizeof(uint32_t); i++)
+	for (i = 0; i < src_size / REP_DATA_BLK_SIZE; i++)
 		((uint32_t *)dst)[i] = ((uint32_t *)src)[i];
 
 	return 0;
@@ -148,13 +148,13 @@ static int hikp_rep_init(void const *req_data, uint32_t req_size,
 		printf("The request data is NULL.\n");
 		return -EINVAL;
 	}
-	data_num = (req_size + (sizeof(uint32_t) - 1)) / sizeof(uint32_t);
+	data_num = (req_size + (REP_DATA_BLK_SIZE - 1)) / REP_DATA_BLK_SIZE;
 	if (data_num > HIKP_REQ_DATA_MAX) {
-		printf("request data num(%u) exceeds max size(%u).\n", data_num, HIKP_REQ_DATA_MAX);
+		printf("request data num(%zu) exceeds max size(%u).\n", data_num, HIKP_REQ_DATA_MAX);
 		return -EINVAL;
 	}
 	if (data_num != 0) {
-		*align_req_data = (uint32_t *)calloc(data_num, sizeof(uint32_t));
+		*align_req_data = (uint32_t *)calloc(data_num, REP_DATA_BLK_SIZE);
 		if (*align_req_data == NULL) {
 			printf("request memory malloc failed.\n");
 			return -ENOMEM;
@@ -175,12 +175,12 @@ static int hikp_req_first_round(uint32_t *req_data, uint32_t rep_num, uint32_t *
 	if (req_data == NULL)
 		return 0;
 
-	src_size = rep_num * sizeof(uint32_t);
+	src_size = rep_num * REP_DATA_BLK_SIZE;
 	dst_size = sizeof(g_hikp_req->field.data);
 	hikp_memclr_io();
 	ret = hikp_memcpy_io((uint32_t *)(g_hikp_req->field.data), dst_size, req_data, src_size);
 	if (ret != 0) {
-		printf("size error, dst_size:%u, src_size:%u.\n", dst_size, src_size);
+		printf("size error, dst_size:%zu, src_size:%zu.\n", dst_size, src_size);
 		return ret;
 	}
 	g_hikp_req->field.exe_round = 0;
@@ -209,7 +209,7 @@ static int hikp_multi_round_interact(struct hikp_cmd_ret **cmd_ret, uint32_t sta
 	}
 
 	p_cmd_ret = (struct hikp_cmd_ret *)malloc(sizeof(struct hikp_cmd_ret) +
-		    rsp_num * sizeof(uint32_t));
+		    rsp_num * REP_DATA_BLK_SIZE);
 	if (p_cmd_ret == NULL) {
 		printf("response memory malloc fail.\n");
 		return -ENOMEM;
@@ -235,8 +235,8 @@ static int hikp_multi_round_interact(struct hikp_cmd_ret **cmd_ret, uint32_t sta
 			}
 		}
 		src_size = (i == cycle - 1) ?
-			(rsp_num - (i * HIKP_RSP_DATA_MAX)) * sizeof(uint32_t) :
-			HIKP_RSP_DATA_MAX * sizeof(uint32_t);
+			(rsp_num - (i * HIKP_RSP_DATA_MAX)) * REP_DATA_BLK_SIZE :
+			HIKP_RSP_DATA_MAX * REP_DATA_BLK_SIZE;
 		dst_size = src_size;
 		(void)hikp_memcpy_io(&(p_cmd_ret->rsp_data)[i * HIKP_RSP_DATA_MAX],
 			dst_size, (uint32_t *)(g_hikp_rsp->field.data), src_size);
@@ -258,7 +258,7 @@ struct hikp_cmd_ret *hikp_cmd_alloc(struct hikp_cmd_header *req_header,
 {
 	struct hikp_cmd_ret *cmd_ret = NULL;
 	uint32_t *p_req_data = NULL;
-	uint32_t rep_num, rsp_num;
+	uint32_t rep_num;
 	uint32_t cpl_status = HIKP_INIT_STAT;
 	int ret;
 
@@ -557,7 +557,7 @@ int hikp_dev_init(void)
 		goto out_unmap;
 	}
 
-	len = (sizeof(union hikp_space_req) - sizeof(struct iep_doorbell)) / sizeof(uint32_t);
+	len = (sizeof(union hikp_space_req) - sizeof(struct iep_doorbell)) / REP_DATA_BLK_SIZE;
 	for (i = 0; i < len; i++)
 		g_hikp_req->dw[i] = 0;
 
diff --git a/libhikptdev/src/rciep/hikpt_rciep.h b/libhikptdev/src/rciep/hikpt_rciep.h
index dd08759af7609a44a1f083ee080babc13d0661ba..296d2355f8ef45ba8a815cab5ecc33ac0498540c 100644
--- a/libhikptdev/src/rciep/hikpt_rciep.h
+++ b/libhikptdev/src/rciep/hikpt_rciep.h
@@ -42,6 +42,8 @@
 #define CPL_CHECK_GAP_US 1000
 #define WAIT_CPL_MAX_MS 8000
 
+#define REP_DATA_BLK_SIZE		sizeof(uint32_t)
+
 enum {
 	HIKP_RESOURCE_DIR,
 	HIKP_CONFIG_DIR,
diff --git a/net/hikp_net_lib.c b/net/hikp_net_lib.c
index eba086e401eee54c2a93835e16e1f573106badd4..8db4ad59ceec7aeaa2046fd3b710c1152a2c191e 100644
--- a/net/hikp_net_lib.c
+++ b/net/hikp_net_lib.c
@@ -23,7 +23,7 @@
 #include "tool_lib.h"
 #include "hikptdev_plug.h"
 
-static int hikp_read_net_pci_info(const char *file_path, uint32_t len, char *content)
+static int hikp_read_net_pci_info(const char *file_path, char *content, size_t len)
 {
 	char path[PATH_MAX + 1] = { 0 };
 	int ret;
@@ -32,7 +32,7 @@ static int hikp_read_net_pci_info(const char *file_path, uint32_t len, char *con
 	if (file_path == NULL || content == NULL)
 		return -EINVAL;
 
-	if (len > MAX_PCI_ID_LEN)
+	if (len > MAX_PCI_ID_LEN + 1 || len < 1)
 		return -EINVAL;
 
 	if (strlen(file_path) > PATH_MAX || realpath(file_path, path) == NULL)
@@ -42,12 +42,12 @@ static int hikp_read_net_pci_info(const char *file_path, uint32_t len, char *con
 	if (fd < 0)
 		return -EPERM;
 
-	ret = pread(fd, content, len, 0);
+	ret = pread(fd, content, len - 1, 0);
 	if (ret < 0) {
 		close(fd);
 		return -EIO;
 	}
-	content[len] = '\0'; // The invoker ensures that the bounds are not crossed.
+	content[len - 1] = '\0'; // The invoker ensures that the bounds are not crossed.
 	close(fd);
 
 	return 0;
@@ -191,7 +191,7 @@ static int tool_get_bdf_by_dev_name(const char *name, struct tool_target *target
 int tool_check_and_get_valid_bdf_id(const char *name, struct tool_target *target)
 {
 	if (!name || !target)
-		return 0;
+		return -EINVAL;
 
 	if (interface_is_bdf_id(name, target))
 		return 0;
@@ -211,11 +211,14 @@ bool is_dev_valid_and_special(int sockfd, struct tool_target *target)
 	return true;
 }
 
-int get_revision_id_by_bdf(const struct bdf_t *bdf, char *revision_id)
+int get_revision_id_by_bdf(const struct bdf_t *bdf, char *revision_id, size_t id_len)
 {
 	char revision_dir[MAX_BUS_PCI_DIR_LEN] = { 0 };
 	int ret;
 
+	if (id_len < MAX_PCI_ID_LEN + 1)
+		return -EINVAL;
+
 	ret = snprintf(revision_dir, sizeof(revision_dir), "%s%04x:%02x:%02x.%u%s",
 		       HIKP_BUS_PCI_DEV_DIR, bdf->domain, bdf->bus_id, bdf->dev_id,
 		       bdf->fun_id, HIKP_PCI_REVISION_DIR);
@@ -223,14 +226,14 @@ int get_revision_id_by_bdf(const struct bdf_t *bdf, char *revision_id)
 		HIKP_ERROR_PRINT("get revision dir fail.\n");
 		return -EIO;
 	}
-	ret = hikp_read_net_pci_info((const char *)revision_dir, MAX_PCI_ID_LEN, revision_id);
+	ret = hikp_read_net_pci_info((const char *)revision_dir, revision_id, id_len);
 	if (ret != 0)
 		return ret;
 
 	return 0;
 }
 
-static int hikp_get_dir_name_of_device(const char *path, uint32_t len, char *dir_name)
+static int hikp_get_dir_name_of_device(const char *path, size_t len, char *dir_name)
 {
 	struct dirent *ptr;
 	DIR *dir = NULL;
@@ -261,12 +264,12 @@ static int hikp_get_dir_name_of_device(const char *path, uint32_t len, char *dir
 	return closedir(dir);
 }
 
-int get_dev_name_by_bdf(const struct bdf_t *bdf, char *dev_name)
+int get_dev_name_by_bdf(const struct bdf_t *bdf, char *dev_name, size_t name_len)
 {
 	char dev_name_dir[MAX_BUS_PCI_DIR_LEN] = { 0 };
 	int ret;
 
-	if (!dev_name || !bdf)
+	if (!dev_name || !bdf || name_len < IFNAMSIZ)
 		return -EINVAL;
 
 	/* if dev_name already has a value, we do not need to obtain it. */
@@ -283,7 +286,7 @@ int get_dev_name_by_bdf(const struct bdf_t *bdf, char *dev_name)
 	if (!is_dir_exist(dev_name_dir))
 		return -ENOENT;
 
-	return hikp_get_dir_name_of_device(dev_name_dir, IFNAMSIZ, dev_name);
+	return hikp_get_dir_name_of_device(dev_name_dir, name_len, dev_name);
 }
 
 int get_vf_dev_info_by_pf_dev_name(const char *pf_dev_name,
@@ -352,7 +355,7 @@ int get_numvfs_by_bdf(const struct bdf_t *bdf, uint8_t *numvfs)
 		HIKP_ERROR_PRINT("get numvfs dir fail.\n");
 		return -EIO;
 	}
-	ret = hikp_read_net_pci_info((const char *)numvfs_dir, MAX_PCI_ID_LEN, numvf);
+	ret = hikp_read_net_pci_info((const char *)numvfs_dir, numvf, MAX_PCI_ID_LEN + 1);
 	if (ret != 0)
 		return ret;
 
@@ -366,12 +369,12 @@ int get_numvfs_by_bdf(const struct bdf_t *bdf, uint8_t *numvfs)
 	return 0;
 }
 
-void hikp_ether_format_addr(char *buf, uint16_t size, const uint8_t *mac_addr)
+void hikp_ether_format_addr(char *buf, uint16_t size, const uint8_t *mac_addr, uint8_t mac_len)
 {
 	int len;
 
-	if (buf == NULL || mac_addr == NULL) {
-		HIKP_WARN_PRINT("buf or mac_addr pointer is NULL.\n");
+	if (buf == NULL || mac_addr == NULL || mac_len != HIKP_NIC_ETH_MAC_ADDR_LEN) {
+		HIKP_WARN_PRINT("buf or mac_addr pointer is NULL, or len(%u) is invalid\n", mac_len);
 		return;
 	}
 
diff --git a/net/hikp_net_lib.h b/net/hikp_net_lib.h
index 21b53578e05c3f2e21be8aa51b902123f95f9322..8a0958f2de89a0e47d1f61e718e134dd18da6bc2 100644
--- a/net/hikp_net_lib.h
+++ b/net/hikp_net_lib.h
@@ -100,6 +100,9 @@ enum roce_cmd_type {
 	GET_ROCEE_TIMER_CMD,
 	GET_ROCEE_TRP_CMD,
 	GET_ROCEE_TSP_CMD,
+	GET_ROCEE_RST_CMD,
+	GET_ROCEE_GLOBAL_CFG_CMD,
+	GET_ROCEE_BOND_CMD,
 };
 
 enum ub_cmd_type {
@@ -127,12 +130,12 @@ enum nic_get_ncsi_sub_cmd {
 int hikp_net_creat_sock(void);
 int tool_check_and_get_valid_bdf_id(const char *name, struct tool_target *target);
 bool is_dev_valid_and_special(int sockfd, struct tool_target *target);
-int get_revision_id_by_bdf(const struct bdf_t *bdf, char *revision_id);
-int get_dev_name_by_bdf(const struct bdf_t *bdf, char *dev_name);
+int get_revision_id_by_bdf(const struct bdf_t *bdf, char *revision_id, size_t id_len);
+int get_dev_name_by_bdf(const struct bdf_t *bdf, char *dev_name, size_t name_len);
 int get_numvfs_by_bdf(const struct bdf_t *bdf, uint8_t *numvfs);
 int get_vf_dev_info_by_pf_dev_name(const char *pf_dev_name,
 				   struct tool_target *vf_target, uint8_t vf_id);
 int get_pf_dev_info_by_vf_dev_name(const char *vf_dev_name, struct tool_target *pf_target);
-void hikp_ether_format_addr(char *buf, uint16_t size, const uint8_t *mac_addr);
+void hikp_ether_format_addr(char *buf, uint16_t size, const uint8_t *mac_addr, uint8_t mac_len);
 
 #endif
diff --git a/net/nic/nic_dfx/hikp_nic_dfx.c b/net/nic/nic_dfx/hikp_nic_dfx.c
index c734ce07c358b9fcbff021b4288638c4bbd6d0b4..409522984ae644ffbab3810c35659aa9ec4ad2ee 100644
--- a/net/nic/nic_dfx/hikp_nic_dfx.c
+++ b/net/nic/nic_dfx/hikp_nic_dfx.c
@@ -318,7 +318,6 @@ static void hikp_nic_dfx_cmd_execute(struct major_cmd_ctrl *self)
 	uint32_t max_dfx_size;
 	uint32_t version;
 	uint32_t i;
-	int ret;
 
 	if (!(g_dfx_param.flag & MODULE_SET_FLAG)) {
 		self->err_no = -EINVAL;
diff --git a/net/nic/nic_fd/hikp_nic_fd.c b/net/nic/nic_fd/hikp_nic_fd.c
index 57bc94b6fe0f5e709a85dcdcfd632bfac183a19e..e699bf9ae600d38764687bcebcc11c46829a630e 100644
--- a/net/nic/nic_fd/hikp_nic_fd.c
+++ b/net/nic/nic_fd/hikp_nic_fd.c
@@ -15,7 +15,7 @@
 #include <string.h>
 #include <sys/types.h>
 #include <unistd.h>
-
+#include <inttypes.h>
 #include "hikp_nic_fd.h"
 
 struct key_info {
@@ -255,13 +255,13 @@ static void hikp_nic_print_tuple(const struct key_info *tuple_key,
 	case OUTER_SRC_MAC:
 	case INNER_DST_MAC:
 	case INNER_SRC_MAC:
-		printf("\t  %s[mask=0x%llx]: ", tuple_key->key_name, mask);
+		printf("\t  %s[mask=0x%" PRIx64 "]: ", tuple_key->key_name, mask);
 		printf("%02x:%02x:%02x:%02x:%02x:%02x\n", *(tcam_y + 5), *(tcam_y + 4),
 		       *(tcam_y + 3), *(tcam_y + 2), *(tcam_y + 1), *tcam_y);
 		break;
 	case OUTER_ETH_TYPE:
 	case INNER_ETH_TYPE:
-		printf("\t  %s[mask=0x%llx]: ", tuple_key->key_name, mask);
+		printf("\t  %s[mask=0x%" PRIx64 "]: ", tuple_key->key_name, mask);
 		printf("0x%x\n", *(uint16_t *)tcam_y);
 		break;
 	case OUTER_VLAN_TAG_FST:
@@ -276,7 +276,7 @@ static void hikp_nic_print_tuple(const struct key_info *tuple_key,
 	case OUTER_DST_PORT:
 	case INNER_SRC_PORT:
 	case INNER_DST_PORT:
-		printf("\t  %s[mask=0x%llx]: ", tuple_key->key_name, mask);
+		printf("\t  %s[mask=0x%" PRIx64 "]: ", tuple_key->key_name, mask);
 		printf("%u\n", *(uint16_t *)tcam_y);
 		break;
 	case OUTER_IP_TOS:
@@ -284,25 +284,25 @@ static void hikp_nic_print_tuple(const struct key_info *tuple_key,
 	case OUTER_IP_PROTO:
 	case INNER_IP_PROTO:
 	case OUTER_TUN_FLOW_ID:
-		printf("\t  %s[mask=0x%llx]: ", tuple_key->key_name, mask);
+		printf("\t  %s[mask=0x%" PRIx64 "]: ", tuple_key->key_name, mask);
 		printf("0x%x\n", *tcam_y);
 		break;
 	case OUTER_SRC_IP:
 	case OUTER_DST_IP:
 	case INNER_SRC_IP:
 	case INNER_DST_IP:
-		printf("\t  %s[mask=0x%llx]: ", tuple_key->key_name, mask);
+		printf("\t  %s[mask=0x%" PRIx64 "]: ", tuple_key->key_name, mask);
 		printf("%u.%u.%u.%u\n", *(tcam_y + 3), *(tcam_y + 2), *(tcam_y + 1), *tcam_y);
 		break;
 	case OUTER_L4_RSV:
 	case INNER_L4_RSV:
-		printf("\t  %s[mask=0x%llx]: ", tuple_key->key_name, mask);
+		printf("\t  %s[mask=0x%" PRIx64 "]: ", tuple_key->key_name, mask);
 		printf("%u\n", *(uint32_t *)tcam_y);
 		break;
 	case OUTER_TUN_VNI:
 		for (i = 0; i < HIKP_NIC_FD_TUN_VNI_LEN; i++)
 			tun_vni |= (((uint32_t)*(tcam_y + i)) << (i * HIKP_BITS_PER_BYTE));
-		printf("\t  %s[mask=0x%llx]: ", tuple_key->key_name, mask);
+		printf("\t  %s[mask=0x%" PRIx64 "]: ", tuple_key->key_name, mask);
 		printf("0x%x\n", tun_vni);
 		break;
 	default:
@@ -407,12 +407,12 @@ static void hikp_nic_fd_print_meta_data(struct nic_fd_rule_info *rule)
 	meta_bytes = HIKP_DIV_ROUND_UP(active_meta_width, HIKP_BITS_PER_BYTE);
 	meta_data_region = active_tcam_size - meta_bytes;
 	if (meta_bytes > sizeof(meta_data)) {
-		printf("meta data copy size error, data size: 0x%x, max size: 0x%x\n",
+		printf("meta data copy size error, data size: %u, max size: %zu\n",
 		       meta_bytes, sizeof(meta_data));
 		return;
 	}
 	memcpy(&meta_data, &key_y[meta_data_region], meta_bytes);
-	printf("\t  meta_data[meta_data=0x%llx]:\n", meta_data);
+	printf("\t  meta_data[meta_data=0x%" PRIx64 "]:\n", meta_data);
 	cur_pos = meta_bytes * HIKP_BITS_PER_BYTE;
 	end = cur_pos - 1;
 	for (i = MAX_META_DATA - 1; i >= 0; i--) {
@@ -470,7 +470,7 @@ static void hikp_nic_fd_print_ad_data(struct nic_fd_rule_info *rule)
 	uint64_t ad_data;
 
 	ad_data = (uint64_t)rule->ad_data_h << NIC_FD_AD_DATA_S | rule->ad_data_l;
-	printf("\n\tAction[ad data: 0x%llx]:\n", ad_data);
+	printf("\n\tAction[ad data: 0x%" PRIx64 "]:\n", ad_data);
 
 	hikp_nic_parse_ad_data(rule, &action);
 
@@ -544,7 +544,7 @@ static void hikp_nic_show_fd_counter(const void *data)
 	printf(" idx | hit_cnt\n");
 	for (i = 0; i < counter[stage_no].counter_size; i++) {
 		entry = &counter[stage_no].entry[i];
-		printf(" %3u | %llu\n", entry->idx, entry->value);
+		printf(" %3u | %" PRIu64 "\n", entry->idx, entry->value);
 	}
 }
 
@@ -554,7 +554,6 @@ static int hikp_nic_fd_get_blk(struct hikp_cmd_header *req_header,
 {
 	struct hikp_cmd_ret *cmd_ret;
 	struct nic_fd_rsp *rsp;
-	uint16_t idx;
 	int ret = 0;
 
 	cmd_ret = hikp_cmd_alloc(req_header, req_data, sizeof(*req_data));
@@ -792,10 +791,13 @@ static void hikp_nic_fd_data_free(union nic_fd_feature_info *fd_data)
 	const struct fd_feature_cmd *fd_cmd;
 
 	fd_cmd = &g_fd_feature_cmd[g_fd_param.feature_idx];
-	if (strcmp(fd_cmd->feature_name, NIC_FD_RULES_NAME) == 0)
+	if (strcmp(fd_cmd->feature_name, NIC_FD_RULES_NAME) == 0) {
 		free(fd_data->rules[stage_no].rule);
-	else if (strcmp(fd_cmd->feature_name, NIC_FD_COUNTER_NAME) == 0)
+		fd_data->rules[stage_no].rule = NULL;
+	} else if (strcmp(fd_cmd->feature_name, NIC_FD_COUNTER_NAME) == 0) {
 		free(fd_data->counter[stage_no].entry);
+		fd_data->counter[stage_no].entry = NULL;
+	}
 
 	free(fd_data);
 }
@@ -859,31 +861,27 @@ static int hikp_nic_fd_check_input_param(struct major_cmd_ctrl *self,
 
 	if (bdf->dev_id != 0) {
 		snprintf(self->err_str, sizeof(self->err_str), "VF does not support query!");
-		self->err_no = -EINVAL;
-		return self->err_no;
+		return -EINVAL;
 	}
 
 	if (fd_param->feature_idx == -1) {
 		hikp_nic_fd_cmd_help(self, NULL);
 		snprintf(self->err_str, sizeof(self->err_str), "-du/--dump parameter error!");
-		self->err_no = -EINVAL;
-		return self->err_no;
+		return -EINVAL;
 	}
 
 	fd_cmd = &g_fd_feature_cmd[g_fd_param.feature_idx];
 	if (fd_param->stage_no == -1 && fd_cmd->sub_cmd_code != NIC_FD_HW_INFO_DUMP) {
 		snprintf(self->err_str, sizeof(self->err_str),
 			 "please input '-st/--stage' parameter.");
-		self->err_no = -EINVAL;
-		return self->err_no;
+		return -EINVAL;
 	}
 
 	if (fd_cmd->sub_cmd_code == NIC_FD_HW_INFO_DUMP &&
 	    (fd_param->id != -1 || fd_param->stage_no != -1)) {
 		snprintf(self->err_str, sizeof(self->err_str),
 			 "no need '-id/--index' and '-st/--stage' parameter.");
-		self->err_no = -EINVAL;
-		return self->err_no;
+		return -EINVAL;
 	}
 
 	return 0;
@@ -899,8 +897,10 @@ static void hikp_nic_fd_cmd_execute(struct major_cmd_ctrl *self)
 	int ret;
 
 	ret = hikp_nic_fd_check_input_param(self, &g_fd_param);
-	if (ret != 0)
+	if (ret != 0) {
+		self->err_no = ret;
 		return;
+	}
 
 	ret = hikp_nic_get_fd_hw_info(bdf, &g_fd_hw_info);
 	if (ret != 0) {
diff --git a/net/nic/nic_fec/hikp_nic_fec.c b/net/nic/nic_fec/hikp_nic_fec.c
index 5d9025cce0afee5df84ceb8c9fc851f173e48b86..342b3eb412de68d3b69249c2067d71afc596bfa7 100644
--- a/net/nic/nic_fec/hikp_nic_fec.c
+++ b/net/nic/nic_fec/hikp_nic_fec.c
@@ -15,7 +15,7 @@
 #include <string.h>
 #include <sys/types.h>
 #include <unistd.h>
-
+#include <inttypes.h>
 #include "hikp_nic_fec.h"
 
 static struct tool_target g_fec_target;
@@ -40,6 +40,7 @@ static int hikp_nic_fec_err_query(const struct bdf_t *bdf, struct nic_fec_err_in
 	rsp = (struct nic_fec_rsp *)cmd_ret->rsp_data;
 	*info = *(struct nic_fec_err_info *)rsp->data;
 	free(cmd_ret);
+	cmd_ret = NULL;
 
 	if (info->fec_mode >= NIC_FEC_MODE_BUTT) {
 		HIKP_ERROR_PRINT("unknown fec mode: %u\n", info->fec_mode);
@@ -71,7 +72,7 @@ static void hikp_nic_fec_err_show_basefec(const struct nic_fec_err_info *info)
 	for (total = 0, i = 0; i < lane_num; i++)
 		total += info->basefec.lane_corr_block_cnt[i];
 
-	printf(" corrected_blocks: %llu\n", total);
+	printf(" corrected_blocks: %" PRIu64 "\n", total);
 	for (i = 0; i < lane_num; i++)
 		printf("   Lane %u: %u\n", i, info->basefec.lane_corr_block_cnt[i]);
 
@@ -79,7 +80,7 @@ static void hikp_nic_fec_err_show_basefec(const struct nic_fec_err_info *info)
 	for (total = 0, i = 0; i < lane_num; i++)
 		total += info->basefec.lane_uncorr_block_cnt[i];
 
-	printf(" uncorrectable_blocks: %llu\n", total);
+	printf(" uncorrectable_blocks: %" PRIu64 "\n", total);
 	for (i = 0; i < lane_num; i++)
 		printf("   Lane %u: %u\n", i, info->basefec.lane_uncorr_block_cnt[i]);
 }
diff --git a/net/nic/nic_info/hikp_nic_info.c b/net/nic/nic_info/hikp_nic_info.c
index d84ca18177561deb627ea2b51eda40ea92104144..cd78bc76c24245611a70263faa2a0df4c511c03b 100644
--- a/net/nic/nic_info/hikp_nic_info.c
+++ b/net/nic/nic_info/hikp_nic_info.c
@@ -79,7 +79,8 @@ static int hikp_nic_get_curr_die_info(void)
 	free(cmd_ret);
 	cmd_ret = NULL;
 
-	ret = get_revision_id_by_bdf(&g_info_param.target.bdf, g_info_param.revision_id);
+	ret = get_revision_id_by_bdf(&g_info_param.target.bdf, g_info_param.revision_id,
+				     sizeof(g_info_param.revision_id));
 	if (ret != 0) {
 		HIKP_ERROR_PRINT("Getting revision fail.\n");
 		return ret;
@@ -87,7 +88,8 @@ static int hikp_nic_get_curr_die_info(void)
 	ret = get_numvfs_by_bdf(&g_info_param.target.bdf, &g_info_param.numvfs);
 	if (ret != 0)
 		HIKP_ERROR_PRINT("Getting numvfs fail, ret = %d.\n", ret);
-	ret = get_dev_name_by_bdf(&g_info_param.target.bdf, g_info_param.target.dev_name);
+	ret = get_dev_name_by_bdf(&g_info_param.target.bdf, g_info_param.target.dev_name,
+				  sizeof(g_info_param.target.dev_name));
 	if ((ret != 0) && (ret != -ENOENT)) {
 		HIKP_ERROR_PRINT("Getting dev name fail.\n");
 		return ret;
@@ -258,7 +260,8 @@ static void hikp_nic_info_print_cur_vf(const struct bdf_t *bdf)
 	printf("Current function is vf:\n");
 	printf("\t%-16s %04x:%02x:%02x.%u\n", "vf bdf id:",
 	       bdf->domain, bdf->bus_id, bdf->dev_id, bdf->fun_id);
-	ret = get_dev_name_by_bdf(&g_info_param.target.bdf, g_info_param.target.dev_name);
+	ret = get_dev_name_by_bdf(&g_info_param.target.bdf, g_info_param.target.dev_name,
+				  sizeof(g_info_param.target.dev_name));
 	if ((ret != 0) && (ret != -ENOENT)) {
 		HIKP_ERROR_PRINT("Getting dev name fail.\n");
 		return;
diff --git a/net/nic/nic_log/hikp_nic_log.c b/net/nic/nic_log/hikp_nic_log.c
index 5cafe4ecef082b4ac9ae9ff05b222cb609b4648c..893aef146b700516120d92877417eb09b4a7d753 100644
--- a/net/nic/nic_log/hikp_nic_log.c
+++ b/net/nic/nic_log/hikp_nic_log.c
@@ -113,7 +113,7 @@ static int hikp_nic_get_first_blk_info(uint32_t *total_blk_num,
 	}
 	*log_data = (uint8_t *)calloc(1, log_size);
 	if (*log_data == NULL) {
-		HIKP_ERROR_PRINT("malloc log memory 0x%x failed.", log_size);
+		HIKP_ERROR_PRINT("calloc log memory 0x%x failed.", log_size);
 		ret = -ENOMEM;
 		goto err_out;
 	}
diff --git a/net/nic/nic_ppp/hikp_nic_ppp.c b/net/nic/nic_ppp/hikp_nic_ppp.c
index b71fc48203f6684b15ad4b3a6f62bd2474b3b503..7968ac399def2d028aac0641c5509c032a66665a 100644
--- a/net/nic/nic_ppp/hikp_nic_ppp.c
+++ b/net/nic/nic_ppp/hikp_nic_ppp.c
@@ -95,7 +95,7 @@ static uint16_t hikp_nic_ppp_get_abs_func_id(const struct bdf_t *bdf, int relati
 static void hikp_nic_ppp_get_func_name(char *buf, uint8_t len, uint8_t id)
 {
 	if (id > 0)
-		snprintf(buf, len, "vf%d", id - 1);
+		snprintf(buf, len, "vf%u", id - 1);
 	else
 		snprintf(buf, len, "pf");
 }
@@ -145,7 +145,8 @@ static void hikp_nic_ppp_show_key_mem(struct nic_mac_tbl *tbl, bool is_key_mem)
 		uc_entry = &uc_tbl->entry[idx];
 		if (uc_entry->idx < g_ppp_hw_res.max_key_mem_size || !is_key_mem) {
 			hikp_ether_format_addr(mac_str,
-					       HIKP_NIC_ETH_ADDR_FMT_SIZE, uc_entry->mac_addr);
+					       HIKP_NIC_ETH_ADDR_FMT_SIZE, uc_entry->mac_addr,
+					       HIKP_NIC_ETH_MAC_ADDR_LEN);
 			printf("%04u  | %01u     | %s | ", uc_entry->idx, uc_entry->valid, mac_str);
 			printf("%04u    | %u     | %01u      | ",
 			       uc_entry->vlan_id, uc_entry->vmdq1, uc_entry->mac_en);
@@ -161,7 +162,8 @@ static void hikp_nic_ppp_show_key_mem(struct nic_mac_tbl *tbl, bool is_key_mem)
 		mc_entry = &mc_tbl->entry[idx];
 		if (mc_entry->idx < g_ppp_hw_res.max_key_mem_size || !is_key_mem) {
 			hikp_ether_format_addr(mac_str,
-					       HIKP_NIC_ETH_ADDR_FMT_SIZE, mc_entry->mac_addr);
+					       HIKP_NIC_ETH_ADDR_FMT_SIZE, mc_entry->mac_addr,
+					       HIKP_NIC_ETH_MAC_ADDR_LEN);
 			printf("%04u  | %s | ", mc_entry->idx, mac_str);
 			printf("%08x:%08x:%08x:%08x:%08x:%08x:%08x:%08x",
 			       mc_entry->function_bitmap[7], mc_entry->function_bitmap[6],
@@ -191,7 +193,7 @@ static void hikp_nic_ppp_show_func_uc_mac_addr(struct mac_vlan_uc_tbl *uc_tbl,
 		vf_id = hikp_get_field(uc_entry->e_vport, HIKP_NIC_VF_ID_MASK, HIKP_NIC_VF_ID_S);
 		if (bdf->fun_id == pf_id && vf_id == func_id) {
 			hikp_ether_format_addr(mac_str, HIKP_NIC_ETH_ADDR_FMT_SIZE,
-					       uc_entry->mac_addr);
+					       uc_entry->mac_addr, HIKP_NIC_ETH_MAC_ADDR_LEN);
 			printf("\t%s\n", mac_str);
 		}
 	}
@@ -205,7 +207,7 @@ static void hikp_nic_ppp_show_func_mc_mac_addr(struct mac_vlan_mc_tbl *mc_tbl,
 	uint16_t abs_func_id;
 	uint8_t offset;
 	uint8_t idx;
-	uint8_t i;
+	uint32_t i;
 
 	abs_func_id = hikp_nic_ppp_get_abs_func_id(bdf, func_id);
 	idx = abs_func_id / HIKP_NIC_PPP_FUNC_BITMAP_SIZE;
@@ -218,7 +220,7 @@ static void hikp_nic_ppp_show_func_mc_mac_addr(struct mac_vlan_mc_tbl *mc_tbl,
 
 		if (hikp_get_bit(mc_entry->function_bitmap[idx], offset) != 0) {
 			hikp_ether_format_addr(mac_str, HIKP_NIC_ETH_ADDR_FMT_SIZE,
-					       mc_entry->mac_addr);
+					       mc_entry->mac_addr, HIKP_NIC_ETH_MAC_ADDR_LEN);
 			printf("\t%s\n", mac_str);
 		}
 	}
@@ -401,7 +403,8 @@ static void hikp_nic_ppp_show_manager_tbl(const void *data)
 	       "| i_map | i_dir | e_type | pf_id | vf_id | q_id | drop\n");
 	for (i = 0; i < tbl->entry_size; i++) {
 		entry = &tbl->entry[i];
-		hikp_ether_format_addr(mac_str, HIKP_NIC_ETH_ADDR_FMT_SIZE, entry->mac_addr);
+		hikp_ether_format_addr(mac_str, HIKP_NIC_ETH_ADDR_FMT_SIZE, entry->mac_addr,
+				       HIKP_NIC_ETH_MAC_ADDR_LEN);
 		printf(" %02u   | %s | %u    ", entry->entry_no, mac_str, entry->mac_mask);
 		printf("| %04x  | %u    | %04u | %u    ",
 		       entry->ether_type, entry->ether_mask, entry->vlan_id, entry->vlan_mask);
@@ -489,7 +492,7 @@ static int hikp_nic_ppp_get_blk(struct hikp_cmd_header *req_header,
 	rsp = (struct nic_ppp_rsp *)cmd_ret->rsp_data;
 	if (rsp->rsp_head.cur_blk_size > buf_len) {
 		HIKP_ERROR_PRINT("nic_ppp block context copy size error, "
-				 "buffer size=%u, data size=%u.\n",
+				 "buffer size=%zu, data size=%u.\n",
 				 buf_len, rsp->rsp_head.cur_blk_size);
 		ret = -EINVAL;
 		goto out;
@@ -791,6 +794,7 @@ static int hikp_nic_ppp_alloc_mac_tbl_entry(struct nic_mac_tbl *mac_tbl,
 	if (mac_tbl->mc_tbl.entry == NULL) {
 		HIKP_ERROR_PRINT("Fail to alloc mc_entry memory.\n");
 		free(mac_tbl->uc_tbl.entry);
+		mac_tbl->uc_tbl.entry = NULL;
 		return -ENOMEM;
 	}
 
@@ -813,6 +817,7 @@ static int hikp_nic_ppp_alloc_vlan_tbl_entry(struct nic_vlan_tbl *vlan_tbl,
 	if (vlan_tbl->vf_vlan_tbl.entry == NULL) {
 		HIKP_ERROR_PRINT("Fail to alloc vf_vlan_tbl_entry memory.\n");
 		free(vlan_tbl->port_vlan_tbl.entry);
+		vlan_tbl->port_vlan_tbl.entry = NULL;
 		return -ENOMEM;
 	}
 
@@ -872,16 +877,22 @@ static void hikp_nic_ppp_data_free(union nic_ppp_feature_info *ppp_data)
 	if (strcmp(ppp_cmd->feature_name, NIC_PPP_MAC_TBL_NAME) == 0) {
 		mac_tbl = &ppp_data->mac_tbl;
 		free(mac_tbl->uc_tbl.entry);
+		mac_tbl->uc_tbl.entry = NULL;
 		free(mac_tbl->mc_tbl.entry);
+		mac_tbl->mc_tbl.entry = NULL;
 	} else if (strcmp(ppp_cmd->feature_name, NIC_PPP_VLAN_TBL_NAME) == 0) {
 		vlan_tbl = &ppp_data->vlan_tbl;
 		free(vlan_tbl->vf_vlan_tbl.entry);
+		vlan_tbl->vf_vlan_tbl.entry = NULL;
 		free(vlan_tbl->port_vlan_tbl.entry);
+		vlan_tbl->port_vlan_tbl.entry = NULL;
 	} else if (strcmp(ppp_cmd->feature_name, NIC_PPP_MNG_TBL_NAME) == 0) {
 		mng_tbl = &ppp_data->mng_tbl;
 		free(mng_tbl->entry);
+		mng_tbl->entry = NULL;
 	}
 	free(ppp_data);
+	ppp_data = NULL;
 }
 
 static int hikp_nic_ppp_check_optional_param(struct major_cmd_ctrl *self,
diff --git a/net/nic/nic_qos/hikp_nic_qos.c b/net/nic/nic_qos/hikp_nic_qos.c
index e3f0e9c918e734d89d0c35ed1cd4869a16bc3f74..a09b4f1b73b8461bc144d8cbc308b118fb685c56 100644
--- a/net/nic/nic_qos/hikp_nic_qos.c
+++ b/net/nic/nic_qos/hikp_nic_qos.c
@@ -98,12 +98,12 @@ static void hikp_nic_qos_show_dcb_info(const void *data)
 	printf("PFC configuration\n");
 	printf("  PFC enable:");
 	for (up = 0; up < HIKP_NIC_MAX_USER_PRIO_NUM; up++)
-		printf(" %d", HI_BIT(up) & pfc->pfc_en ? 1 : 0);
+		printf(" %u", HI_BIT(up) & pfc->pfc_en ? 1 : 0);
 
 	printf("\n");
 	printf("  TC enable:");
 	for (tc_no = 0; tc_no < HIKP_NIC_MAX_TC_NUM; tc_no++)
-		printf(" %d", HI_BIT(tc_no) & pfc->hw_tc_map ? 1 : 0);
+		printf(" %u", HI_BIT(tc_no) & pfc->hw_tc_map ? 1 : 0);
 
 	printf("\n");
 	printf("ETS configuration\n");
@@ -176,7 +176,7 @@ static int hikp_nic_qos_get_blk(struct hikp_cmd_header *req_header,
 	rsp = (struct nic_qos_rsp *)cmd_ret->rsp_data;
 	if (rsp->rsp_head.cur_blk_size > buf_len) {
 		HIKP_ERROR_PRINT("nic_qos block-%u copy size error, "
-				 "buffer size=%u, data size=%u.\n",
+				 "buffer size=%zu, data size=%u.\n",
 				 req_data->block_id, buf_len, rsp->rsp_head.cur_blk_size);
 		ret = -EINVAL;
 		goto out;
@@ -198,7 +198,6 @@ static int hikp_nic_query_qos_feature(struct hikp_cmd_header *req_header, const
 	size_t buf_len = sizeof(*data);
 	uint32_t total_blk_size;
 	uint8_t total_blk_num;
-	uint8_t blk_num = 0;
 	uint8_t blk_id = 0;
 	int ret;
 
@@ -272,7 +271,7 @@ static void hikp_nic_qos_cmd_execute(struct major_cmd_ctrl *self)
 	}
 
 	memset(revision_id, 0, MAX_PCI_ID_LEN + 1);
-	ret = get_revision_id_by_bdf(bdf, revision_id);
+	ret = get_revision_id_by_bdf(bdf, revision_id, sizeof(g_qos_param.revision_id));
 	// show pfc threshold as default if get revision_id error
 	if (ret)
 		strncpy(g_qos_param.revision_id, HIKP_IEP_REVISION,
diff --git a/net/nic/nic_queue/hikp_nic_queue.c b/net/nic/nic_queue/hikp_nic_queue.c
index f229e09edb013621f7e5d32afcb56407f880aa96..fa3b9d3ebbece016062cfb1a1ffcfca8cae18979 100644
--- a/net/nic/nic_queue/hikp_nic_queue.c
+++ b/net/nic/nic_queue/hikp_nic_queue.c
@@ -248,7 +248,7 @@ static int hikp_nic_queue_get_blk(struct hikp_cmd_header *req_header,
 	rsp = (struct nic_queue_rsp *)cmd_ret->rsp_data;
 	if (rsp->rsp_head.cur_blk_size > buf_len) {
 		HIKP_ERROR_PRINT("nic_queue block-%u copy size error, "
-				 "buffer size=%u, data size=%u.\n",
+				 "buffer size=%zu, data size=%u.\n",
 				 req_data->block_id, buf_len, rsp->rsp_head.cur_blk_size);
 		ret = -EINVAL;
 		goto out;
@@ -340,7 +340,6 @@ static bool hikp_nic_queue_check_feature_para_vaild(const struct queue_feature_c
 
 static void hikp_nic_queue_cmd_execute(struct major_cmd_ctrl *self)
 {
-	struct bdf_t *bdf = &g_queue_param.target.bdf;
 	const struct queue_feature_cmd *queue_cmd;
 	union nic_queue_feature_info *queue_data;
 	struct hikp_cmd_header req_header = {0};
diff --git a/net/nic/nic_rss/hikp_nic_rss.c b/net/nic/nic_rss/hikp_nic_rss.c
index 5e4d261b60ae10f6e0dff6ec66c892598853828e..ff1cfd20b7ed4bd299bb75183d11968af231d4df 100644
--- a/net/nic/nic_rss/hikp_nic_rss.c
+++ b/net/nic/nic_rss/hikp_nic_rss.c
@@ -366,7 +366,7 @@ static int hikp_nic_rss_get_blk(struct hikp_cmd_header *req_header,
 	rsp = (struct nic_rss_rsp *)cmd_ret->rsp_data;
 	if (rsp->rsp_head.cur_blk_size > buf_len) {
 		HIKP_ERROR_PRINT("nic_rss block-%u copy size error, "
-				 "buffer size=%u, data size=%u.\n",
+				 "buffer size=%zu, data size=%u.\n",
 				 req_data->block_id, buf_len, rsp->rsp_head.cur_blk_size);
 		ret = -EINVAL;
 		goto out;
@@ -388,7 +388,6 @@ static int hikp_nic_query_rss_feature(struct hikp_cmd_header *req_header, const
 	size_t buf_len = sizeof(*data);
 	uint32_t total_blk_size;
 	uint8_t total_blk_num;
-	uint8_t blk_num = 0;
 	uint8_t blk_id = 0;
 	int ret;
 
diff --git a/net/roce/roce_bond/hikp_roce_bond.c b/net/roce/roce_bond/hikp_roce_bond.c
new file mode 100644
index 0000000000000000000000000000000000000000..89f8bab6c29563e9e6e5a080f6e4dd0b5a005d18
--- /dev/null
+++ b/net/roce/roce_bond/hikp_roce_bond.c
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2023 Hisilicon Technologies Co., Ltd.
+ * Hikptool is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *          http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ *
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "hikp_roce_bond.h"
+
+static struct cmd_roce_bond_param g_roce_bond_param = { 0 };
+
+static int hikp_roce_bond_help(struct major_cmd_ctrl *self, const char *argv)
+{
+	printf("\n  Usage: %s %s\n", self->cmd_ptr->name, "-i <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, e.g. eth0");
+	printf("\n");
+
+	return 0;
+}
+
+static int hikp_roce_bond_target(struct major_cmd_ctrl *self, const char *argv)
+{
+	self->err_no = tool_check_and_get_valid_bdf_id(argv, &(g_roce_bond_param.target));
+	if (self->err_no)
+		snprintf(self->err_str, sizeof(self->err_str), "Unknown device %s.\n", argv);
+
+	return self->err_no;
+}
+
+static int hikp_roce_bond_get_data(struct hikp_cmd_ret **cmd_ret,
+				   uint32_t block_id)
+{
+	struct hikp_cmd_header req_header = { 0 };
+	struct roce_bond_req_param req_data;
+	uint32_t req_size;
+	int ret;
+
+	req_data.bdf = g_roce_bond_param.target.bdf;
+	req_data.block_id = block_id;
+
+	req_size = sizeof(struct roce_bond_req_param);
+	hikp_cmd_init(&req_header, ROCE_MOD, GET_ROCEE_BOND_CMD,
+		      g_roce_bond_param.sub_cmd);
+	*cmd_ret = hikp_cmd_alloc(&req_header, &req_data, req_size);
+	ret = hikp_rsp_normal_check(*cmd_ret);
+	if (ret)
+		printf("hikptool roce_bond cmd_ret malloc failed, sub_cmd = %u, ret = %d.\n",
+			g_roce_bond_param.sub_cmd, ret);
+
+	return ret;
+}
+
+static void hikp_roce_bond_execute(struct major_cmd_ctrl *self)
+{
+	hikp_roce_ext_execute(self, GET_ROCEE_BOND_CMD, hikp_roce_bond_get_data);
+}
+
+static void cmd_roce_bond_init(void)
+{
+	struct major_cmd_ctrl *major_cmd = get_major_cmd();
+
+	major_cmd->option_count = 0;
+	major_cmd->execute = hikp_roce_bond_execute;
+
+	cmd_option_register("-h", "--help", false, hikp_roce_bond_help);
+	cmd_option_register("-i", "--interface", true, hikp_roce_bond_target);
+}
+
+HIKP_CMD_DECLARE("roce_bond", "get roce_bond registers information", cmd_roce_bond_init);
diff --git a/net/roce/roce_bond/hikp_roce_bond.h b/net/roce/roce_bond/hikp_roce_bond.h
new file mode 100644
index 0000000000000000000000000000000000000000..14bd233df1658f5000c02ef2cad40c5a17d2025c
--- /dev/null
+++ b/net/roce/roce_bond/hikp_roce_bond.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2023 Hisilicon Technologies Co., Ltd.
+ * Hikptool is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *          http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ *
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef __HIKP_ROCE_BOND_H__
+#define __HIKP_ROCE_BOND_H__
+
+#include "hikp_roce_ext_common.h"
+
+struct cmd_roce_bond_param {
+	struct tool_target target;
+	uint32_t sub_cmd;
+};
+
+struct roce_bond_req_param {
+	struct bdf_t bdf;
+	uint32_t block_id;
+};
+
+#endif /* __HIKP_ROCE_BOND_H__ */
diff --git a/net/roce/roce_caep/hikp_roce_caep.c b/net/roce/roce_caep/hikp_roce_caep.c
index 69a4742151db68da3d1fe937742df9bec47161b4..126551a5dff958c1ef0548edd0a9f4f0fdec761b 100644
--- a/net/roce/roce_caep/hikp_roce_caep.c
+++ b/net/roce/roce_caep/hikp_roce_caep.c
@@ -22,6 +22,7 @@ static int hikp_roce_caep_help(struct major_cmd_ctrl *self, const char *argv)
 	printf("  Options:\n\n");
 	printf("    %s, %-25s %s\n", "-h", "--help", "display this help and exit");
 	printf("    %s, %-25s %s\n", "-i", "--interface=<interface>", "device target, e.g. eth0");
+	printf("    %s, %-25s %s\n", "-e", "--extend", "query extend caep registers");
 	printf("\n");
 
 	return 0;
@@ -31,7 +32,7 @@ static int hikp_roce_caep_target(struct major_cmd_ctrl *self, const char *argv)
 {
 	self->err_no = tool_check_and_get_valid_bdf_id(argv, &(g_roce_caep_param_t.target));
 	if (self->err_no !=  0) {
-		snprintf(self->err_str, sizeof(self->err_str), "Unknown device %s.", argv);
+		snprintf(self->err_str, sizeof(self->err_str), "Unknown device %s.\n", argv);
 		return self->err_no;
 	}
 
@@ -39,18 +40,28 @@ static int hikp_roce_caep_target(struct major_cmd_ctrl *self, const char *argv)
 }
 
 static int hikp_roce_caep_get_data(struct hikp_cmd_ret **cmd_ret,
-				   struct roce_caep_req_param req_data)
+				   uint32_t block_id)
 {
+	struct roce_caep_req_param_ext req_data_ext;
 	struct hikp_cmd_header req_header = { 0 };
+	uint32_t req_size;
+	int ret;
 
-	hikp_cmd_init(&req_header, ROCE_MOD, GET_ROCEE_CAEP_CMD, 0);
-	*cmd_ret = hikp_cmd_alloc(&req_header, &req_data, sizeof(req_data));
-	if (*cmd_ret == NULL) {
-		printf("hikptool roce_caep cmd_ret malloc failed\n");
-		return -EIO;
-	}
-
-	return 0;
+	req_data_ext.origin_param.bdf = g_roce_caep_param_t.target.bdf;
+	req_data_ext.block_id = block_id;
+
+	req_size = (g_roce_caep_param_t.sub_cmd == CAEP_ORIGIN) ?
+		   sizeof(struct roce_caep_req_param) :
+		   sizeof(struct roce_caep_req_param_ext);
+	hikp_cmd_init(&req_header, ROCE_MOD, GET_ROCEE_CAEP_CMD,
+		      g_roce_caep_param_t.sub_cmd);
+	*cmd_ret = hikp_cmd_alloc(&req_header, &req_data_ext, req_size);
+	ret = hikp_rsp_normal_check(*cmd_ret);
+	if (ret)
+		printf("hikptool roce_caep cmd_ret malloc failed, sub_cmd = %u, ret = %d.\n",
+			g_roce_caep_param_t.sub_cmd, ret);
+
+	return ret;
 }
 
 static void hikp_roce_caep_print(uint32_t total_block_num,
@@ -64,29 +75,47 @@ static void hikp_roce_caep_print(uint32_t total_block_num,
 	printf("************************************\n");
 }
 
-static void hikp_roce_caep_execute(struct major_cmd_ctrl *self)
+static void hikp_roce_caep_execute_origin(struct major_cmd_ctrl *self)
 {
 	struct roce_caep_res_param *roce_caep_res;
-	struct roce_caep_req_param req_data;
 	struct hikp_cmd_ret *cmd_ret;
-	int ret;
 
-	req_data.bdf = g_roce_caep_param_t.target.bdf;
-	ret = hikp_roce_caep_get_data(&cmd_ret, req_data);
-	if (ret < 0) {
-		self->err_no = ret;
-		return;
-	} else if (cmd_ret->status != 0) {
-		printf("hikptool roce_caep read data failed\n");
+	self->err_no = hikp_roce_caep_get_data(&cmd_ret, 0);
+	if (self->err_no) {
+		printf("hikptool roce_caep get data failed.\n");
 		goto exec_error;
 	}
+
 	roce_caep_res = (struct roce_caep_res_param *)cmd_ret->rsp_data;
+	if (roce_caep_res->total_block_num > ROCE_HIKP_CAEP_REG_NUM) {
+		printf("version might not match, adjust the reg num to %d.\n",
+		       ROCE_HIKP_CAEP_REG_NUM);
+		roce_caep_res->total_block_num = ROCE_HIKP_CAEP_REG_NUM;
+	}
+
 	hikp_roce_caep_print(roce_caep_res->total_block_num,
-			     roce_caep_res->reg_data.offset, roce_caep_res->reg_data.data);
+			     roce_caep_res->reg_data.offset,
+			     roce_caep_res->reg_data.data);
 
 exec_error:
-	free(cmd_ret);
-	cmd_ret = NULL;
+	if (cmd_ret)
+		free(cmd_ret);
+}
+
+static void hikp_roce_caep_execute(struct major_cmd_ctrl *self)
+{
+	if (g_roce_caep_param_t.sub_cmd == CAEP_ORIGIN)
+		hikp_roce_caep_execute_origin(self);
+	else
+		hikp_roce_ext_execute(self, GET_ROCEE_CAEP_CMD,
+				      hikp_roce_caep_get_data);
+}
+
+static int hikp_roce_caep_ext_set(struct major_cmd_ctrl *self, const char *argv)
+{
+	g_roce_caep_param_t.sub_cmd = CAEP_EXT;
+
+	return 0;
 }
 
 static void cmd_roce_caep_init(void)
@@ -98,6 +127,7 @@ static void cmd_roce_caep_init(void)
 
 	cmd_option_register("-h", "--help", false, hikp_roce_caep_help);
 	cmd_option_register("-i", "--interface", true, hikp_roce_caep_target);
+	cmd_option_register("-e", "--extend", false, hikp_roce_caep_ext_set);
 }
 
 HIKP_CMD_DECLARE("roce_caep", "get roce_caep registers information", cmd_roce_caep_init);
diff --git a/net/roce/roce_caep/hikp_roce_caep.h b/net/roce/roce_caep/hikp_roce_caep.h
index 3c494b14abfbf364a7d282b2b7e070cb9d7e7645..547a4d69e9f032fb587218d40ad1a43674e07815 100644
--- a/net/roce/roce_caep/hikp_roce_caep.h
+++ b/net/roce/roce_caep/hikp_roce_caep.h
@@ -14,19 +14,25 @@
 #ifndef __HIKP_ROCE_CAEP_H__
 #define __HIKP_ROCE_CAEP_H__
 
-#include "hikp_net_lib.h"
+#include "hikp_roce_ext_common.h"
 
 #define ROCE_HIKP_CAEP_REG_NUM 29
 #define PER_REG_NUM 2
 
 struct cmd_roce_caep_param_t {
 	struct tool_target target;
+	uint32_t sub_cmd;
 };
 
 struct roce_caep_req_param {
 	struct bdf_t bdf;
 };
 
+struct roce_caep_req_param_ext {
+	struct roce_caep_req_param origin_param;
+	uint32_t block_id;
+};
+
 struct roce_caep_res {
 	uint32_t offset[ROCE_HIKP_CAEP_REG_NUM];
 	uint32_t data[ROCE_HIKP_CAEP_REG_NUM];
@@ -37,4 +43,9 @@ struct roce_caep_res_param {
 	struct roce_caep_res reg_data;
 };
 
+enum roce_caep_cmd_type {
+	CAEP_ORIGIN = 0,
+	CAEP_EXT,
+};
+
 #endif /* __HIKP_ROCE_CAEP_H__ */
diff --git a/net/roce/roce_ext_common/hikp_roce_ext_common.c b/net/roce/roce_ext_common/hikp_roce_ext_common.c
new file mode 100644
index 0000000000000000000000000000000000000000..5bc3ce6ca0fdc71363e8f8eab319c078bf47a813
--- /dev/null
+++ b/net/roce/roce_ext_common/hikp_roce_ext_common.c
@@ -0,0 +1,185 @@
+/*
+ * Copyright (c) 2023 Hisilicon Technologies Co., Ltd.
+ * Hikptool is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *          http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ *
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "hikp_roce_ext_common.h"
+
+static void hikp_roce_ext_reg_data_free(struct reg_data *reg)
+{
+	if (reg->offset) {
+		free(reg->offset);
+		reg->offset = NULL;
+	}
+
+	if (reg->data) {
+		free(reg->data);
+		reg->data = NULL;
+	}
+}
+
+static void hikp_roce_ext_cmd_ret_free(struct hikp_cmd_ret *cmd_ret)
+{
+	if (cmd_ret)
+		free(cmd_ret);
+}
+
+static const struct cmd_type_info {
+	enum roce_cmd_type cmd_type;
+	const char *cmd_name;
+	uint8_t reg_array_length;
+} cmd_info_table[] = {
+	{GET_ROCEE_MDB_CMD, "MDB", ROCE_HIKP_MDB_REG_NUM_EXT},
+	{GET_ROCEE_GMV_CMD, "GMV", ROCE_HIKP_GMV_REG_NUM_EXT},
+	{GET_ROCEE_CAEP_CMD, "CAEP", ROCE_HIKP_CAEP_REG_NUM_EXT},
+	{GET_ROCEE_PKT_CMD, "PKT", ROCE_HIKP_PKT_REG_NUM_EXT},
+	{GET_ROCEE_SCC_CMD, "SCC", ROCE_HIKP_SCC_REG_NUM_EXT},
+	{GET_ROCEE_QMM_CMD, "QMM", ROCE_HIKP_QMM_REG_NUM_EXT},
+	{GET_ROCEE_TIMER_CMD, "TIMER", ROCE_HIKP_TIMER_REG_NUM_EXT},
+	{GET_ROCEE_TRP_CMD, "TRP", ROCE_HIKP_TRP_REG_NUM_EXT},
+	{GET_ROCEE_TSP_CMD, "TSP", ROCE_HIKP_TSP_REG_NUM_EXT},
+	{GET_ROCEE_RST_CMD, "RST", ROCE_HIKP_RST_REG_NUM},
+	{GET_ROCEE_GLOBAL_CFG_CMD, "GLOBAL_CFG", ROCE_HIKP_GLOBAL_CFG_REG_NUM},
+	{GET_ROCEE_BOND_CMD, "BOND", ROCE_HIKP_BOND_REG_NUM},
+};
+
+static int get_cmd_info_table_idx(enum roce_cmd_type cmd_type)
+{
+	int array_size = sizeof(cmd_info_table) / sizeof(struct cmd_type_info);
+	int i;
+
+	for (i = 0; i < array_size; i++)
+		if (cmd_type == cmd_info_table[i].cmd_type)
+			return i;
+
+	return -ENOENT;
+}
+
+static const char *get_cmd_name(enum roce_cmd_type cmd_type)
+{
+	int idx;
+
+	idx = get_cmd_info_table_idx(cmd_type);
+	if (idx >= 0)
+		return cmd_info_table[idx].cmd_name;
+
+	printf("Failed to get cmd name, cmd_type = %d\n", cmd_type);
+	return NULL;
+}
+
+static int get_cmd_reg_array_length(enum roce_cmd_type cmd_type)
+{
+	int idx;
+
+	idx = get_cmd_info_table_idx(cmd_type);
+	if (idx >= 0)
+		return cmd_info_table[idx].reg_array_length;
+
+	printf("Failed to get cmd reg array length, cmd_type = %d\n", cmd_type);
+	return idx;
+}
+
+static int hikp_roce_ext_get_res(enum roce_cmd_type cmd_type,
+				 uint32_t block_id,
+				 struct roce_ext_head *res_head,
+				 struct reg_data *reg,
+				 int (*get_data)(struct hikp_cmd_ret **cmd_ret,
+						 uint32_t block_id))
+{
+	int reg_array_length = get_cmd_reg_array_length(cmd_type);
+	const char *cmd_name = get_cmd_name(cmd_type);
+	struct roce_ext_res_param *roce_ext_res;
+	struct hikp_cmd_ret *cmd_ret;
+	size_t max_size;
+	size_t cur_size;
+	int ret;
+
+	/* reg_array_length greater than or equal to 0 ensures that cmd_name
+	 * is not NULL, so cmd_name does not need to be checked.
+	 */
+	if (reg_array_length < 0)
+		return reg_array_length;
+
+	ret = get_data(&cmd_ret, block_id);
+	if (ret) {
+		printf("hikptool roce_%s get data failed!\n", cmd_name);
+		goto get_data_error;
+	}
+
+	roce_ext_res = (struct roce_ext_res_param *)cmd_ret->rsp_data;
+	*res_head = roce_ext_res->head;
+	max_size = res_head->total_block_num * sizeof(uint32_t);
+
+	if (block_id == 0) {
+		reg->offset = (uint32_t *)calloc(res_head->total_block_num, sizeof(uint32_t));
+		reg->data = (uint32_t *)calloc(res_head->total_block_num, sizeof(uint32_t));
+		if ((reg->offset == NULL) || (reg->data == NULL)) {
+			printf("hikptool roce_%s alloc log memmory 0x%zx failed!\n",
+				cmd_name, max_size);
+			ret = -ENOMEM;
+			hikp_roce_ext_reg_data_free(reg);
+			goto get_data_error;
+		}
+	}
+
+	cur_size = res_head->cur_block_num * sizeof(uint32_t);
+	if (!cur_size || cur_size > max_size) {
+		printf("hikptool roce_%s log data copy size error, data size: 0x%zx, max size: 0x%zx\n",
+		       cmd_name, cur_size, max_size);
+		ret = -EINVAL;
+		hikp_roce_ext_reg_data_free(reg);
+		goto get_data_error;
+	}
+
+	memcpy(reg->offset + block_id,
+	       (uint32_t *)&roce_ext_res->reg_data, cur_size);
+	memcpy(reg->data + block_id,
+	       (uint32_t *)&roce_ext_res->reg_data + reg_array_length, cur_size);
+
+get_data_error:
+	hikp_roce_ext_cmd_ret_free(cmd_ret);
+	return ret;
+}
+
+static void hikp_roce_ext_print(const char *cmd_name, uint32_t total_block_num,
+				const uint32_t *offset, const uint32_t *data)
+{
+	int i;
+
+	printf("**************%s INFO*************\n", cmd_name);
+	for (i = 0; i < total_block_num; i++)
+		printf("[0x%08X] : 0x%08X\n", offset[i], data[i]);
+	printf("************************************\n");
+}
+
+void hikp_roce_ext_execute(struct major_cmd_ctrl *self,
+			   enum roce_cmd_type cmd_type,
+			   int (*get_data)(struct hikp_cmd_ret **cmd_ret,
+					   uint32_t block_id))
+{
+	uint32_t queried_block_id = 0;
+	struct roce_ext_head res_head;
+	struct reg_data reg = { 0 };
+
+	do {
+		self->err_no = hikp_roce_ext_get_res(cmd_type, queried_block_id,
+						     &res_head, &reg, get_data);
+		if (self->err_no)
+			return;
+
+		queried_block_id += res_head.cur_block_num;
+	} while (queried_block_id < res_head.total_block_num);
+
+	hikp_roce_ext_print(get_cmd_name(cmd_type), res_head.total_block_num,
+			    reg.offset, reg.data);
+
+	hikp_roce_ext_reg_data_free(&reg);
+}
diff --git a/net/roce/roce_ext_common/hikp_roce_ext_common.h b/net/roce/roce_ext_common/hikp_roce_ext_common.h
new file mode 100644
index 0000000000000000000000000000000000000000..a60044925b03f3d70da1709ea4e9a1b6753b448e
--- /dev/null
+++ b/net/roce/roce_ext_common/hikp_roce_ext_common.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2023 Hisilicon Technologies Co., Ltd.
+ * Hikptool is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *          http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ *
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef __HIKP_ROCE_EXT_COMMON_H__
+#define __HIKP_ROCE_EXT_COMMON_H__
+
+#include "hikp_net_lib.h"
+
+#define ROCE_MAX_REG_NUM (NET_MAX_REQ_DATA_NUM - 1)
+
+#define ROCE_HIKP_CAEP_REG_NUM_EXT ROCE_MAX_REG_NUM
+#define ROCE_HIKP_GMV_REG_NUM_EXT ROCE_MAX_REG_NUM
+#define ROCE_HIKP_MDB_REG_NUM_EXT ROCE_MAX_REG_NUM
+#define ROCE_HIKP_PKT_REG_NUM_EXT ROCE_MAX_REG_NUM
+#define ROCE_HIKP_QMM_REG_NUM_EXT ROCE_MAX_REG_NUM
+#define ROCE_HIKP_SCC_REG_NUM_EXT ROCE_MAX_REG_NUM
+#define ROCE_HIKP_TIMER_REG_NUM_EXT ROCE_MAX_REG_NUM
+#define ROCE_HIKP_TRP_REG_NUM_EXT ROCE_MAX_REG_NUM
+#define ROCE_HIKP_TSP_REG_NUM_EXT ROCE_MAX_REG_NUM
+#define ROCE_HIKP_RST_REG_NUM ROCE_MAX_REG_NUM
+#define ROCE_HIKP_GLOBAL_CFG_REG_NUM ROCE_MAX_REG_NUM
+#define ROCE_HIKP_BOND_REG_NUM ROCE_MAX_REG_NUM
+
+struct roce_ext_head {
+	uint8_t total_block_num;
+	uint8_t cur_block_num;
+	uint16_t reserved;
+};
+
+struct roce_ext_res_param {
+	struct roce_ext_head head;
+	uint32_t reg_data[0];
+};
+
+struct reg_data {
+	uint32_t *offset;
+	uint32_t *data;
+};
+
+void hikp_roce_ext_execute(struct major_cmd_ctrl *self,
+			   enum roce_cmd_type cmd_type,
+			   int (*get_data)(struct hikp_cmd_ret **cmd_ret,
+					   uint32_t block_id));
+
+#endif /* __HIKP_ROCE_EXT_COMMON_H__ */
diff --git a/net/roce/roce_global_cfg/hikp_roce_global_cfg.c b/net/roce/roce_global_cfg/hikp_roce_global_cfg.c
new file mode 100644
index 0000000000000000000000000000000000000000..49a4a2ccc7f2c88e4a2bfcb92dffb925b4543783
--- /dev/null
+++ b/net/roce/roce_global_cfg/hikp_roce_global_cfg.c
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2023 Hisilicon Technologies Co., Ltd.
+ * Hikptool is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *          http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ *
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "hikp_roce_global_cfg.h"
+
+static struct cmd_roce_global_cfg_param g_roce_global_cfg_param = { 0 };
+
+static int hikp_roce_global_cfg_help(struct major_cmd_ctrl *self,
+				     const char *argv)
+{
+	printf("\n  Usage: %s %s\n", self->cmd_ptr->name, "-i <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, e.g. eth0");
+	printf("\n");
+
+	return 0;
+}
+
+static int hikp_roce_global_cfg_target(struct major_cmd_ctrl *self,
+				       const char *argv)
+{
+	self->err_no = tool_check_and_get_valid_bdf_id(argv, &(g_roce_global_cfg_param.target));
+	if (self->err_no)
+		snprintf(self->err_str, sizeof(self->err_str),
+			 "Unknown device %s.\n", argv);
+
+	return self->err_no;
+}
+
+static int hikp_roce_global_cfg_get_data(struct hikp_cmd_ret **cmd_ret,
+					 uint32_t block_id)
+{
+	struct hikp_cmd_header req_header = { 0 };
+	struct roce_global_cfg_req_param req_data;
+	uint32_t req_size;
+	int ret;
+
+	req_data.bdf = g_roce_global_cfg_param.target.bdf;
+	req_data.block_id = block_id;
+
+	req_size = sizeof(struct roce_global_cfg_req_param);
+	hikp_cmd_init(&req_header, ROCE_MOD, GET_ROCEE_GLOBAL_CFG_CMD,
+		      g_roce_global_cfg_param.sub_cmd);
+	*cmd_ret = hikp_cmd_alloc(&req_header, &req_data, req_size);
+	ret = hikp_rsp_normal_check(*cmd_ret);
+	if (ret)
+		printf("hikptool roce_global_cfg cmd_ret malloc failed, sub_cmd = %u, ret = %d.\n",
+			g_roce_global_cfg_param.sub_cmd, ret);
+
+	return ret;
+}
+
+static void hikp_roce_global_cfg_execute(struct major_cmd_ctrl *self)
+{
+	enum roce_global_cfg_cmd_type sub_cmds[] = {
+		ROCE_GLB_GENAC,
+		ROCE_GLB_TRP_BANK,
+		ROCE_GLB_TRP_RX,
+		ROCE_GLB_TPP_M,
+		ROCE_GLB_QMM,
+		ROCE_GLB_TGP_TMP,
+		ROCE_GLB_TDP_M,
+		ROCE_GLB_NICL,
+	};
+	int i;
+
+	for (i = 0; i < HIKP_ARRAY_SIZE(sub_cmds); i++) {
+		g_roce_global_cfg_param.sub_cmd = sub_cmds[i];
+		hikp_roce_ext_execute(self, GET_ROCEE_GLOBAL_CFG_CMD,
+				      hikp_roce_global_cfg_get_data);
+	}
+}
+
+static void cmd_roce_global_cfg_init(void)
+{
+	struct major_cmd_ctrl *major_cmd = get_major_cmd();
+
+	major_cmd->option_count = 0;
+	major_cmd->execute = hikp_roce_global_cfg_execute;
+
+	cmd_option_register("-h", "--help", false, hikp_roce_global_cfg_help);
+	cmd_option_register("-i", "--interface", true, hikp_roce_global_cfg_target);
+}
+
+HIKP_CMD_DECLARE("roce_global_cfg", "get roce_global_cfg registers information", cmd_roce_global_cfg_init);
diff --git a/net/roce/roce_global_cfg/hikp_roce_global_cfg.h b/net/roce/roce_global_cfg/hikp_roce_global_cfg.h
new file mode 100644
index 0000000000000000000000000000000000000000..66e7fb84d6d10f4b62908f34cfa89a8e14b913ef
--- /dev/null
+++ b/net/roce/roce_global_cfg/hikp_roce_global_cfg.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2023 Hisilicon Technologies Co., Ltd.
+ * Hikptool is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *          http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ *
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef __HIKP_ROCE_GLOBAL_CFG_H__
+#define __HIKP_ROCE_GLOBAL_CFG_H__
+
+#include "hikp_roce_ext_common.h"
+
+struct cmd_roce_global_cfg_param {
+	struct tool_target target;
+	uint32_t sub_cmd;
+};
+
+struct roce_global_cfg_req_param {
+	struct bdf_t bdf;
+	uint32_t block_id;
+};
+
+enum roce_global_cfg_cmd_type {
+	ROCE_GLB_GENAC = 0,
+	ROCE_GLB_TRP_BANK,
+	ROCE_GLB_TRP_RX,
+	ROCE_GLB_TPP_M,
+	ROCE_GLB_QMM,
+	ROCE_GLB_TGP_TMP,
+	ROCE_GLB_TDP_M,
+	ROCE_GLB_NICL,
+};
+
+#endif /* __HIKP_ROCE_GLOBAL_CFG_H__ */
diff --git a/net/roce/roce_gmv/hikp_roce_gmv.c b/net/roce/roce_gmv/hikp_roce_gmv.c
index d65dc827cc8ad6f9a25ca0fb020862821f257b3a..36ba6654ef63e26b199de54ead7bb3d3fdd43503 100644
--- a/net/roce/roce_gmv/hikp_roce_gmv.c
+++ b/net/roce/roce_gmv/hikp_roce_gmv.c
@@ -44,16 +44,16 @@ static int hikp_roce_gmv_target(struct major_cmd_ctrl *self, const char *argv)
 static int hikp_roce_gmv_idxget(struct major_cmd_ctrl *self, const char *argv)
 {
 	char *endptr = NULL;
-	int index;
+	uint64_t index;
 
-	index = strtol(argv, &endptr, 0);
+	index = strtoul(argv, &endptr, 0);
 	if ((endptr <= argv) || (*endptr != '\0') ||
-	    (index < 0) || (index >= ROCE_MAX_HIKPTOOL_GMV)) {
+	    (index >= ROCE_MAX_HIKPTOOL_GMV)) {
 		snprintf(self->err_str, sizeof(self->err_str), "Invalid gmv_index.");
 		self->err_no = -EINVAL;
 		return -EINVAL;
 	}
-	g_roce_gmv_param.gmv_index = index;
+	g_roce_gmv_param.gmv_index = (uint32_t)index;
 
 	return 0;
 }
diff --git a/net/roce/roce_gmv/hikp_roce_gmv.h b/net/roce/roce_gmv/hikp_roce_gmv.h
index 30f37fb65713f631c4173207378e18e2e29f18c0..a02b9604f5be5efe5ffb672168a412cc4722cccc 100644
--- a/net/roce/roce_gmv/hikp_roce_gmv.h
+++ b/net/roce/roce_gmv/hikp_roce_gmv.h
@@ -14,11 +14,11 @@
 #ifndef __HIKP_ROCE_GMV_H__
 #define __HIKP_ROCE_GMV_H__
 
-#include "hikp_net_lib.h"
+#include "hikp_roce_ext_common.h"
 
 #define ROCE_HIKP_GMV_REG_NUM 7
 #define ROCE_HIKP_GMV_REG_SWICTH 2
-#define ROCE_MAX_HIKPTOOL_GMV 128
+#define ROCE_MAX_HIKPTOOL_GMV 256
 struct cmd_roce_gmv_param {
 	struct tool_target target;
 	uint32_t gmv_index;
diff --git a/net/roce/roce_mdb/hikp_roce_mdb.c b/net/roce/roce_mdb/hikp_roce_mdb.c
index 9cc07a1fe3fa5e35bd4dffc44732e53f8a839168..374f100044daa469a4d0a92277ec9cec44035c05 100644
--- a/net/roce/roce_mdb/hikp_roce_mdb.c
+++ b/net/roce/roce_mdb/hikp_roce_mdb.c
@@ -14,7 +14,6 @@
 #include <unistd.h>
 #include "hikp_roce_mdb.h"
 
-#define ROCE_MDB_CMD_CLEAR HI_BIT(0)
 static struct cmd_roce_mdb_param g_roce_mdb_param = { 0 };
 
 static int hikp_roce_mdb_help(struct major_cmd_ctrl *self, const char *argv)
@@ -25,6 +24,7 @@ static int hikp_roce_mdb_help(struct major_cmd_ctrl *self, const char *argv)
 	printf("    %s, %-25s %s\n", "-h", "--help", "display this help and exit");
 	printf("    %s, %-25s %s\n", "-i", "--interface=<interface>", "device target, e.g. eth0");
 	printf("    %s, %-25s %s\n", "-c", "--clear=<clear>", "clear mdb registers");
+	printf("    %s, %-25s %s\n", "-e", "--extend", "query extend mdb registers");
 	printf("\n");
 
 	return 0;
@@ -34,7 +34,7 @@ static int hikp_roce_mdb_target(struct major_cmd_ctrl *self, const char *argv)
 {
 	self->err_no = tool_check_and_get_valid_bdf_id(argv, &(g_roce_mdb_param.target));
 	if (self->err_no) {
-		snprintf(self->err_str, sizeof(self->err_str), "Unknown device %s.", argv);
+		snprintf(self->err_str, sizeof(self->err_str), "Unknown device %s.\n", argv);
 		return self->err_no;
 	}
 
@@ -43,7 +43,8 @@ static int hikp_roce_mdb_target(struct major_cmd_ctrl *self, const char *argv)
 
 static int hikp_roce_mdb_clear_set(struct major_cmd_ctrl *self, const char *argv)
 {
-	g_roce_mdb_param.reset_flag = ROCE_MDB_CMD_CLEAR;
+	g_roce_mdb_param.flag |= ROCE_MDB_CMD_CLEAR;
+
 	return 0;
 }
 
@@ -58,53 +59,77 @@ static void hikp_roce_mdb_print(uint32_t reg_num, struct roce_mdb_rsp_data *mdb_
 	printf("***********************************\n");
 }
 
-static int hikp_roce_mdb_show(struct major_cmd_ctrl *self)
+static int hikp_roce_mdb_get_data(struct hikp_cmd_ret **cmd_ret,
+				  uint32_t block_id)
 {
-	struct roce_mdb_req_para req_data = { 0 };
-	struct roce_mdb_rsp_data *mdb_rsp = NULL;
+	struct roce_mdb_req_param_ext req_data_ext;
 	struct hikp_cmd_header req_header = { 0 };
-	struct hikp_cmd_ret *cmd_ret = NULL;
-	uint32_t reg_num;
+	uint32_t req_size;
 	int ret;
 
-	req_data.bdf = g_roce_mdb_param.target.bdf;
-	if (g_roce_mdb_param.reset_flag)
-		hikp_cmd_init(&req_header, ROCE_MOD, GET_ROCEE_MDB_CMD, MDB_CLEAR);
-	else
-		hikp_cmd_init(&req_header, ROCE_MOD, GET_ROCEE_MDB_CMD, MDB_SHOW);
+	req_data_ext.origin_param.bdf = g_roce_mdb_param.target.bdf;
+	req_data_ext.block_id = block_id;
+
+	req_size = (g_roce_mdb_param.flag & ROCE_MDB_CMD_EXT) ?
+		   sizeof(struct roce_mdb_req_param_ext) :
+		   sizeof(struct roce_mdb_req_para);
+	hikp_cmd_init(&req_header, ROCE_MOD, GET_ROCEE_MDB_CMD,
+		      g_roce_mdb_param.sub_cmd);
+	*cmd_ret = hikp_cmd_alloc(&req_header, &req_data_ext, req_size);
+	ret = hikp_rsp_normal_check(*cmd_ret);
+	if (ret)
+		printf("hikptool roce_mdb cmd_ret malloc failed, sub_cmd = %u, ret = %d.\n",
+			g_roce_mdb_param.sub_cmd, ret);
+
+	return ret;
+}
+
+static void hikp_roce_mdb_execute_origin(struct major_cmd_ctrl *self)
+{
+	struct roce_mdb_rsp_data *mdb_rsp = NULL;
+	struct hikp_cmd_ret *cmd_ret = NULL;
+	uint32_t reg_num;
 
-	cmd_ret = hikp_cmd_alloc(&req_header, &req_data, sizeof(req_data));
-	ret = hikp_rsp_normal_check(cmd_ret);
-	if (ret != 0)
+	self->err_no = hikp_roce_mdb_get_data(&cmd_ret, 0);
+	if (self->err_no) {
+		printf("hikptool roce_mdb get data failed\n");
 		goto exec_error;
+	}
 
 	reg_num = cmd_ret->rsp_data_num / ROCE_HIKP_REG_SWICTH;
 	if (reg_num != ROCE_HIKP_MDB_REG_NUM) {
 		printf("version might not match.\n");
-		ret = -1;
+		self->err_no = -EPROTO;
 		goto exec_error;
 	}
 
 	mdb_rsp = (struct roce_mdb_rsp_data *)(cmd_ret->rsp_data);
 	hikp_roce_mdb_print(reg_num, mdb_rsp);
-	ret = 0;
 
 exec_error:
-	free(cmd_ret);
-	cmd_ret = NULL;
-	return ret;
+	if (cmd_ret)
+		free(cmd_ret);
 }
 
 static void hikp_roce_mdb_execute(struct major_cmd_ctrl *self)
 {
-	self->err_no = hikp_roce_mdb_show(self);
-	if (self->err_no)
-		return;
-
-	if (g_roce_mdb_param.reset_flag)
-		printf("clear roce_mdb reg success.\n");
-	else
-		printf("show roce_mdb reg success.\n");
+	if (g_roce_mdb_param.flag & ROCE_MDB_CMD_EXT) {
+		g_roce_mdb_param.sub_cmd = (g_roce_mdb_param.flag & ROCE_MDB_CMD_CLEAR) ?
+					   MDB_CLEAR_EXT : MDB_EXT;
+		hikp_roce_ext_execute(self, GET_ROCEE_MDB_CMD,
+				      hikp_roce_mdb_get_data);
+	} else {
+		g_roce_mdb_param.sub_cmd = (g_roce_mdb_param.flag & ROCE_MDB_CMD_CLEAR) ?
+					   MDB_CLEAR : MDB_SHOW;
+		hikp_roce_mdb_execute_origin(self);
+	}
+}
+
+static int hikp_roce_mdb_ext_set(struct major_cmd_ctrl *self, const char *argv)
+{
+	g_roce_mdb_param.flag |= ROCE_MDB_CMD_EXT;
+
+	return 0;
 }
 
 static void cmd_roce_mdb_init(void)
@@ -117,6 +142,7 @@ static void cmd_roce_mdb_init(void)
 	cmd_option_register("-h", "--help", false, hikp_roce_mdb_help);
 	cmd_option_register("-i", "--interface", true, hikp_roce_mdb_target);
 	cmd_option_register("-c", "--clear", false, hikp_roce_mdb_clear_set);
+	cmd_option_register("-e", "--extend", false, hikp_roce_mdb_ext_set);
 }
 
 HIKP_CMD_DECLARE("roce_mdb", "get or clear roce_mdb registers information", cmd_roce_mdb_init);
diff --git a/net/roce/roce_mdb/hikp_roce_mdb.h b/net/roce/roce_mdb/hikp_roce_mdb.h
index 8e7da03618c153312cf96601e9790a7881866700..26fc5496f519351a171022445c4faf72deff39a6 100644
--- a/net/roce/roce_mdb/hikp_roce_mdb.h
+++ b/net/roce/roce_mdb/hikp_roce_mdb.h
@@ -14,20 +14,29 @@
 #ifndef __HIKP_ROCE_MDB_H__
 #define __HIKP_ROCE_MDB_H__
 
-#include "hikp_net_lib.h"
+#include "hikp_roce_ext_common.h"
 
 #define ROCE_HIKP_MDB_REG_NUM 22
 #define ROCE_HIKP_REG_SWICTH 2
 
+#define ROCE_MDB_CMD_CLEAR (1 << 0)
+#define ROCE_MDB_CMD_EXT (1 << 1)
+
 struct cmd_roce_mdb_param {
 	struct tool_target target;
-	int reset_flag;
+	uint32_t sub_cmd;
+	uint8_t flag;
 };
 
 struct roce_mdb_req_para {
 	struct bdf_t bdf;
 };
 
+struct roce_mdb_req_param_ext {
+	struct roce_mdb_req_para origin_param;
+	uint32_t block_id;
+};
+
 struct roce_mdb_rsp_data {
 	uint32_t reg_offset[ROCE_HIKP_MDB_REG_NUM];
 	uint32_t reg_data[ROCE_HIKP_MDB_REG_NUM];
@@ -36,6 +45,8 @@ struct roce_mdb_rsp_data {
 enum roce_mdb_cmd_type {
 	MDB_SHOW = 0x0,
 	MDB_CLEAR,
+	MDB_EXT,
+	MDB_CLEAR_EXT,
 };
 
 #endif /* __HIKP_ROCE_MDB_H__ */
diff --git a/net/roce/roce_pkt/hikp_roce_pkt.c b/net/roce/roce_pkt/hikp_roce_pkt.c
index d3bf885714e4a4c754f96339271ed581336178a0..e710e08b100d6f077ab02e21e86cc461aeae6c44 100644
--- a/net/roce/roce_pkt/hikp_roce_pkt.c
+++ b/net/roce/roce_pkt/hikp_roce_pkt.c
@@ -87,7 +87,14 @@ static void hikp_roce_pkt_execute(struct major_cmd_ctrl *self)
 		self->err_no = ret;
 		return;
 	}
+
 	roce_pkt_res = (struct roce_pkt_res_param *)cmd_ret->rsp_data;
+	if (roce_pkt_res->total_block_num > ROCE_HIKP_PKT_REG_NUM) {
+		printf("version might not match, adjust the reg num to %d.\n",
+		       ROCE_HIKP_PKT_REG_NUM);
+		roce_pkt_res->total_block_num = ROCE_HIKP_PKT_REG_NUM;
+	}
+
 	hikp_roce_pkt_print(roce_pkt_res->total_block_num,
 			    roce_pkt_res->reg_data.offset, roce_pkt_res->reg_data.data);
 
diff --git a/net/roce/roce_pkt/hikp_roce_pkt.h b/net/roce/roce_pkt/hikp_roce_pkt.h
index 5f438b7773226abf9db861e5c5d4ab3925140156..0200c44cd700bee35f9018f64db677bdd2beb97b 100644
--- a/net/roce/roce_pkt/hikp_roce_pkt.h
+++ b/net/roce/roce_pkt/hikp_roce_pkt.h
@@ -14,7 +14,7 @@
 #ifndef __HIKP_ROCE_PKT_H__
 #define __HIKP_ROCE_PKT_H__
 
-#include "hikp_net_lib.h"
+#include "hikp_roce_ext_common.h"
 
 #define ROCE_HIKP_PKT_REG_NUM 29
 #define PKT_PER_REG_NUM 2
diff --git a/net/roce/roce_qmm/hikp_roce_qmm.c b/net/roce/roce_qmm/hikp_roce_qmm.c
index c7e0ca4cf8b340ce1a5ff17547a7b9f509f63b99..e440b821a266a8cf0ce04427cd6e60c15acb5763 100644
--- a/net/roce/roce_qmm/hikp_roce_qmm.c
+++ b/net/roce/roce_qmm/hikp_roce_qmm.c
@@ -25,6 +25,7 @@ static int hikp_roce_qmm_help(struct major_cmd_ctrl *self, const char *argv)
 	printf("    %s, %-25s %s\n", "-i", "--interface=<interface>", "device target, e.g. eth0");
 	printf("    %s, %-25s %s\n", "-b", "--bank=<bank>",
 	       "[option]bank number, e.g. 0~7. (default 0)");
+	printf("    %s, %-25s %s\n", "-e", "--extend", "query extend qmm registers");
 	printf("\n");
 
 	return 0;
@@ -34,7 +35,7 @@ static int hikp_roce_qmm_target(struct major_cmd_ctrl *self, const char *argv)
 {
 	self->err_no = tool_check_and_get_valid_bdf_id(argv, &(g_roce_qmm_param.target));
 	if (self->err_no != 0) {
-		snprintf(self->err_str, sizeof(self->err_str), "Unknown device %s.", argv);
+		snprintf(self->err_str, sizeof(self->err_str), "Unknown device %s.\n", argv);
 		return self->err_no;
 	}
 
@@ -44,16 +45,16 @@ static int hikp_roce_qmm_target(struct major_cmd_ctrl *self, const char *argv)
 static int hikp_roce_qmm_bank_get(struct major_cmd_ctrl *self, const char *argv)
 {
 	char *endptr = NULL;
-	int bank_num;
+	uint64_t bank_num;
 
-	bank_num = strtol(argv, &endptr, 0);
-	if ((endptr <= argv) || (*endptr != '\0') || bank_num > QMM_BANK_NUM || bank_num < 0) {
+	bank_num = strtoul(argv, &endptr, 0);
+	if ((endptr <= argv) || (*endptr != '\0') || bank_num > QMM_BANK_NUM) {
 		snprintf(self->err_str, sizeof(self->err_str), "Invalid bank number!\n");
 		self->err_no = -EINVAL;
 		return -EINVAL;
 	}
 
-	g_roce_qmm_param.bank_id = bank_num;
+	g_roce_qmm_param.bank_id = (uint32_t)bank_num;
 	return 0;
 }
 
@@ -61,6 +62,8 @@ static void hikp_roce_qmm_print(struct roce_qmm_rsp_data *qmm_rsp)
 {
 	int index = 0;
 
+	printf("**************QMM %s INFO*************\n",
+	       g_roce_qmm_param.sub_name);
 	while (index < qmm_rsp->reg_num) {
 		printf("0x%08X : 0x%08X\n", qmm_rsp->qmm_content[index][0],
 		       qmm_rsp->qmm_content[index][1]);
@@ -69,101 +72,95 @@ static void hikp_roce_qmm_print(struct roce_qmm_rsp_data *qmm_rsp)
 	printf("***************************************\n");
 }
 
-static int hikp_roce_qmm_show_cqc(struct major_cmd_ctrl *self)
+static int hikp_roce_qmm_get_data(struct hikp_cmd_ret **cmd_ret,
+				  uint32_t block_id)
 {
-	struct roce_qmm_req_para req_data = { 0 };
-	struct roce_qmm_rsp_data *qmm_rsp = NULL;
+	struct roce_qmm_req_para_ext req_data_ext;
 	struct hikp_cmd_header req_header = { 0 };
-	struct hikp_cmd_ret *cmd_ret = NULL;
+	uint32_t req_size;
 	int ret;
 
-	req_data.bdf = g_roce_qmm_param.target.bdf;
+	req_data_ext.origin_param.bdf = g_roce_qmm_param.target.bdf;
+	req_data_ext.origin_param.bank_id = g_roce_qmm_param.bank_id;
+	req_data_ext.block_id = block_id;
+
+	req_size = g_roce_qmm_param.ext_flag ?
+		   sizeof(struct roce_qmm_req_para) :
+		   sizeof(struct roce_qmm_req_para_ext);
+	hikp_cmd_init(&req_header, ROCE_MOD, GET_ROCEE_QMM_CMD,
+		      g_roce_qmm_param.sub_cmd);
+	*cmd_ret = hikp_cmd_alloc(&req_header, &req_data_ext, req_size);
+	ret = hikp_rsp_normal_check(*cmd_ret);
+	if (ret)
+		printf("hikptool roce_qmm cmd_ret malloc failed, sub_cmd = %u, ret = %d.\n",
+			g_roce_qmm_param.sub_cmd, ret);
 
-	hikp_cmd_init(&req_header, ROCE_MOD, GET_ROCEE_QMM_CMD, QMM_SHOW_CQC);
-	cmd_ret = hikp_cmd_alloc(&req_header, &req_data, sizeof(req_data));
-	ret = hikp_rsp_normal_check(cmd_ret);
-	if (ret != 0)
-		goto out;
-
-	qmm_rsp = (struct roce_qmm_rsp_data *)(cmd_ret->rsp_data);
-	printf("**************QMM CQC INFO*************\n");
-	hikp_roce_qmm_print(qmm_rsp);
-out:
-	free(cmd_ret);
-	cmd_ret = NULL;
 	return ret;
 }
 
-static int hikp_roce_qmm_show_qpc(struct major_cmd_ctrl *self)
+static void hikp_roce_qmm_execute_origin(struct major_cmd_ctrl *self)
 {
-	struct roce_qmm_req_para req_data = { 0 };
-	struct roce_qmm_rsp_data *qmm_rsp = NULL;
-	struct hikp_cmd_header req_header = { 0 };
-	struct hikp_cmd_ret *cmd_ret = NULL;
-	int ret;
-
-	req_data.bdf = g_roce_qmm_param.target.bdf;
-	req_data.bank_id = g_roce_qmm_param.bank_id;
-
-	hikp_cmd_init(&req_header, ROCE_MOD, GET_ROCEE_QMM_CMD, QMM_SHOW_QPC);
-	cmd_ret = hikp_cmd_alloc(&req_header, &req_data, sizeof(req_data));
-	ret = hikp_rsp_normal_check(cmd_ret);
-	if (ret != 0)
-		goto out;
-
-	qmm_rsp = (struct roce_qmm_rsp_data *)(cmd_ret->rsp_data);
-	printf("**************QMM QPC INFO*************\n");
-	hikp_roce_qmm_print(qmm_rsp);
-out:
-	free(cmd_ret);
-	cmd_ret = NULL;
-	return ret;
-}
+	struct roce_qmm_rsp_data *roce_qmm_res;
+	struct hikp_cmd_ret *cmd_ret;
 
-static int hikp_roce_qmm_show_top(struct major_cmd_ctrl *self)
-{
-	struct roce_qmm_req_para req_data = { 0 };
-	struct roce_qmm_rsp_data *qmm_rsp = NULL;
-	struct hikp_cmd_header req_header = { 0 };
-	struct hikp_cmd_ret *cmd_ret = NULL;
-	int ret;
+	self->err_no = hikp_roce_qmm_get_data(&cmd_ret, 0);
+	if (self->err_no) {
+		printf("hikptool roce_qmm get data failed.\n");
+		goto exec_error;
+	}
 
-	req_data.bdf = g_roce_qmm_param.target.bdf;
+	roce_qmm_res = (struct roce_qmm_rsp_data *)cmd_ret->rsp_data;
+	if (roce_qmm_res->reg_num > ROCE_HIKP_QMM_REG_NUM) {
+		printf("version might not match, adjust the reg num to %d.\n",
+		       ROCE_HIKP_QMM_REG_NUM);
+		roce_qmm_res->reg_num = ROCE_HIKP_QMM_REG_NUM;
+	}
 
-	hikp_cmd_init(&req_header, ROCE_MOD, GET_ROCEE_QMM_CMD, QMM_SHOW_TOP);
-	cmd_ret = hikp_cmd_alloc(&req_header, &req_data, sizeof(req_data));
-	ret = hikp_rsp_normal_check(cmd_ret);
-	if (ret != 0)
-		goto out;
+	hikp_roce_qmm_print(roce_qmm_res);
 
-	qmm_rsp = (struct roce_qmm_rsp_data *)(cmd_ret->rsp_data);
-	printf("**************QMM TOP INFO*************\n");
-	hikp_roce_qmm_print(qmm_rsp);
-out:
-	free(cmd_ret);
-	cmd_ret = NULL;
-	return ret;
+exec_error:
+	if (cmd_ret)
+		free(cmd_ret);
 }
 
 static void hikp_roce_qmm_execute(struct major_cmd_ctrl *self)
 {
-	int (*func[])(struct major_cmd_ctrl *self) = {
-		hikp_roce_qmm_show_cqc, hikp_roce_qmm_show_qpc, hikp_roce_qmm_show_top
+	const struct cmd_type_info {
+		enum roce_qmm_cmd_type sub_cmd;
+		enum roce_qmm_cmd_type sub_ext_cmd;
+		const char *sub_name;
+	} sub_cmd_info_table[] = {
+		{QMM_SHOW_CQC, QMM_SHOW_CQC_EXT, "CQC"},
+		{QMM_SHOW_QPC, QMM_SHOW_QPC_EXT, "QPC"},
+		{QMM_SHOW_TOP, QMM_SHOW_TOP_EXT, "TOP"},
 	};
-	char *function[] = {"show cqc", "show qpc", "show top"};
-	int ret;
 
-	for (int i = 0; i < HIKP_ARRAY_SIZE(func); i++) {
-		ret = func[i](self);
-		if (ret != 0) {
-			self->err_no = -EINVAL;
+	for (int i = 0; i < HIKP_ARRAY_SIZE(sub_cmd_info_table); i++) {
+		g_roce_qmm_param.sub_name = sub_cmd_info_table[i].sub_name;
+		if (g_roce_qmm_param.ext_flag) {
+			g_roce_qmm_param.sub_cmd = sub_cmd_info_table[i].sub_ext_cmd;
+			hikp_roce_ext_execute(self, GET_ROCEE_QMM_CMD,
+					      hikp_roce_qmm_get_data);
+		} else {
+			g_roce_qmm_param.sub_cmd = sub_cmd_info_table[i].sub_cmd;
+			hikp_roce_qmm_execute_origin(self);
+		}
+		if (self->err_no) {
 			snprintf(self->err_str, sizeof(self->err_str),
-				 "roce_qmm %s function failed\n", function[i]);
+				 "roce_qmm show %s function failed\n",
+				 sub_cmd_info_table[i].sub_name);
 			break;
 		}
 	}
 }
 
+static int hikp_roce_qmm_ext_set(struct major_cmd_ctrl *self, const char *argv)
+{
+	g_roce_qmm_param.ext_flag = true;
+
+	return 0;
+}
+
 static void cmd_roce_qmm_init(void)
 {
 	struct major_cmd_ctrl *major_cmd = get_major_cmd();
@@ -174,6 +171,7 @@ static void cmd_roce_qmm_init(void)
 	cmd_option_register("-h", "--help", false, hikp_roce_qmm_help);
 	cmd_option_register("-i", "--interface", true, hikp_roce_qmm_target);
 	cmd_option_register("-b", "--bank", true, hikp_roce_qmm_bank_get);
+	cmd_option_register("-e", "--extend", false, hikp_roce_qmm_ext_set);
 }
 
 HIKP_CMD_DECLARE("roce_qmm", "get roce_qmm registers information", cmd_roce_qmm_init);
diff --git a/net/roce/roce_qmm/hikp_roce_qmm.h b/net/roce/roce_qmm/hikp_roce_qmm.h
index 08cb5d2eb8bb453f6719dec36cf4b6fcc5bfbc2f..06e6bcfbc9a6823af11f1f57f206a82d12c8a3a5 100644
--- a/net/roce/roce_qmm/hikp_roce_qmm.h
+++ b/net/roce/roce_qmm/hikp_roce_qmm.h
@@ -14,7 +14,7 @@
 #ifndef __HIKP_ROCE_QMM_H__
 #define __HIKP_ROCE_QMM_H__
 
-#include "hikp_net_lib.h"
+#include "hikp_roce_ext_common.h"
 
 #define ROCE_HIKP_QMM_REG_NUM 36
 #define QMM_BANK_NUM 0x7
@@ -22,6 +22,9 @@
 struct cmd_roce_qmm_param_t {
 	struct tool_target target;
 	uint32_t bank_id;
+	uint32_t sub_cmd;
+	const char *sub_name;
+	bool ext_flag;
 };
 
 struct roce_qmm_rsp_data {
@@ -34,10 +37,18 @@ struct roce_qmm_req_para {
 	uint32_t bank_id;
 };
 
+struct roce_qmm_req_para_ext {
+	struct roce_qmm_req_para origin_param;
+	uint32_t block_id;
+};
+
 enum roce_qmm_cmd_type {
 	QMM_SHOW_CQC = 0x1,
 	QMM_SHOW_QPC = 0x2,
 	QMM_SHOW_TOP = 0x3,
+	QMM_SHOW_CQC_EXT,
+	QMM_SHOW_QPC_EXT,
+	QMM_SHOW_TOP_EXT,
 };
 
 #endif /* __HIKP_ROCE_QMM_H__ */
diff --git a/net/roce/roce_rst/hikp_roce_rst.c b/net/roce/roce_rst/hikp_roce_rst.c
new file mode 100644
index 0000000000000000000000000000000000000000..ad4dd0c453506924a4e6534f4b6543deab397c81
--- /dev/null
+++ b/net/roce/roce_rst/hikp_roce_rst.c
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2023 Hisilicon Technologies Co., Ltd.
+ * Hikptool is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *          http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ *
+ * See the Mulan PSL v2 for more details.
+ */
+
+#include "hikp_roce_rst.h"
+
+static struct cmd_roce_rst_param g_roce_rst_param = { 0 };
+
+static int hikp_roce_rst_help(struct major_cmd_ctrl *self, const char *argv)
+{
+	printf("\n  Usage: %s %s\n", self->cmd_ptr->name, "-i <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, e.g. eth0");
+	printf("\n");
+
+	return 0;
+}
+
+static int hikp_roce_rst_target(struct major_cmd_ctrl *self, const char *argv)
+{
+	self->err_no = tool_check_and_get_valid_bdf_id(argv, &(g_roce_rst_param.target));
+	if (self->err_no)
+		snprintf(self->err_str, sizeof(self->err_str), "Unknown device %s.\n", argv);
+
+	return self->err_no;
+}
+
+static int hikp_roce_rst_get_data(struct hikp_cmd_ret **cmd_ret,
+				  uint32_t block_id)
+{
+	struct hikp_cmd_header req_header = { 0 };
+	struct roce_rst_req_param req_data;
+	uint32_t req_size;
+	int ret;
+
+	req_data.bdf = g_roce_rst_param.target.bdf;
+	req_data.block_id = block_id;
+
+	req_size = sizeof(struct roce_rst_req_param);
+	hikp_cmd_init(&req_header, ROCE_MOD, GET_ROCEE_RST_CMD,
+		      g_roce_rst_param.sub_cmd);
+	*cmd_ret = hikp_cmd_alloc(&req_header, &req_data, req_size);
+	ret = hikp_rsp_normal_check(*cmd_ret);
+	if (ret)
+		printf("hikptool roce_rst cmd_ret malloc failed, sub_cmd = %u, ret = %d.\n",
+			g_roce_rst_param.sub_cmd, ret);
+
+	return ret;
+}
+
+static void hikp_roce_rst_execute(struct major_cmd_ctrl *self)
+{
+	hikp_roce_ext_execute(self, GET_ROCEE_RST_CMD, hikp_roce_rst_get_data);
+}
+
+static void cmd_roce_rst_init(void)
+{
+	struct major_cmd_ctrl *major_cmd = get_major_cmd();
+
+	major_cmd->option_count = 0;
+	major_cmd->execute = hikp_roce_rst_execute;
+
+	cmd_option_register("-h", "--help", false, hikp_roce_rst_help);
+	cmd_option_register("-i", "--interface", true, hikp_roce_rst_target);
+}
+
+HIKP_CMD_DECLARE("roce_rst", "get roce_rst registers information", cmd_roce_rst_init);
diff --git a/net/roce/roce_rst/hikp_roce_rst.h b/net/roce/roce_rst/hikp_roce_rst.h
new file mode 100644
index 0000000000000000000000000000000000000000..731effc8e88727f8fd72df1e9429afd40672fd54
--- /dev/null
+++ b/net/roce/roce_rst/hikp_roce_rst.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2023 Hisilicon Technologies Co., Ltd.
+ * Hikptool is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *          http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ *
+ * See the Mulan PSL v2 for more details.
+ */
+
+#ifndef __HIKP_ROCE_RST_H__
+#define __HIKP_ROCE_RST_H__
+
+#include "hikp_roce_ext_common.h"
+
+struct cmd_roce_rst_param {
+	struct tool_target target;
+	uint32_t sub_cmd;
+};
+
+struct roce_rst_req_param {
+	struct bdf_t bdf;
+	uint32_t block_id;
+};
+
+#endif /* __HIKP_ROCE_RST_H__ */
diff --git a/net/roce/roce_scc/hikp_roce_scc.c b/net/roce/roce_scc/hikp_roce_scc.c
index e8e166d1ecdbd9c9da5ad943dbb78d9e6fa0826d..fe08873ac45bf407bda699e843346db0db2ebfc9 100644
--- a/net/roce/roce_scc/hikp_roce_scc.c
+++ b/net/roce/roce_scc/hikp_roce_scc.c
@@ -150,7 +150,7 @@ static int hikp_roce_scc_get_total_data_num(struct roce_scc_head *res_head,
 	*offset = (uint32_t *)calloc(1, max_size);
 	*data = (uint32_t *)calloc(1, max_size);
 	if ((*offset == NULL) || (*data == NULL)) {
-		printf("hikptool roce_scc alloc log memmory 0x%x failed\n", max_size);
+		printf("hikptool roce_scc alloc log memmory 0x%zx failed\n", max_size);
 		ret = -ENOMEM;
 		goto get_data_error;
 	}
@@ -158,7 +158,7 @@ static int hikp_roce_scc_get_total_data_num(struct roce_scc_head *res_head,
 	cur_size = roce_scc_res->head.cur_block_num * sizeof(uint32_t);
 	if (cur_size > max_size) {
 		printf("hikptool roce_scc log data copy size error, "
-		       "data size: 0x%x, max size: 0x%x\n", cur_size, max_size);
+		       "data size: 0x%zx, max size: 0x%zx\n", cur_size, max_size);
 		ret = -EINVAL;
 		goto get_data_error;
 	}
@@ -194,7 +194,7 @@ static int hikp_roce_scc_get_next_data(struct roce_scc_head *res_head,
 	if (cur_size > data_size) {
 		hikp_roce_scc_cmd_ret_free(&cmd_ret);
 		printf("hikptool roce_scc next log data copy size error, "
-		       "data size: 0x%x, max size: 0x%x\n", cur_size, data_size);
+		       "data size: 0x%zx, max size: 0x%zx\n", cur_size, data_size);
 		return -EINVAL;
 	}
 	memcpy(*offset, roce_scc_res->reg_data.offset, cur_size);
diff --git a/net/roce/roce_scc/hikp_roce_scc.h b/net/roce/roce_scc/hikp_roce_scc.h
index de8772e5164927c011c5d24d793933db4c599d43..5d37a1143b49c6ab1f571f9dc8f7e26f876b1cc9 100644
--- a/net/roce/roce_scc/hikp_roce_scc.h
+++ b/net/roce/roce_scc/hikp_roce_scc.h
@@ -14,7 +14,7 @@
 #ifndef __HIKP_ROCE_SCC_H__
 #define __HIKP_ROCE_SCC_H__
 
-#include "hikp_net_lib.h"
+#include "hikp_roce_ext_common.h"
 
 #define ROCE_HIKP_SCC_REG_NUM 29
 #define MAX_SCC_MODULE_NAME_LEN 20
diff --git a/net/roce/roce_timer/hikp_roce_timer.c b/net/roce/roce_timer/hikp_roce_timer.c
index c4e979f87273f0f862c528e4c431c7e4b86166fc..05ad3e1633b63010443044086aba0384bb3c561c 100644
--- a/net/roce/roce_timer/hikp_roce_timer.c
+++ b/net/roce/roce_timer/hikp_roce_timer.c
@@ -76,6 +76,12 @@ static int hikp_roce_timer_show_qpc(struct major_cmd_ctrl *self)
 		goto out;
 
 	timer_rsp = (struct roce_timer_rsp_data *)(cmd_ret->rsp_data);
+	if (timer_rsp->reg_num > ROCE_HIKP_TIMER_REG_NUM) {
+		printf("version might not match, adjust the reg num to %d.\n",
+		       ROCE_HIKP_TIMER_REG_NUM);
+		timer_rsp->reg_num = ROCE_HIKP_TIMER_REG_NUM;
+	}
+
 	printf("**************QPC TIMER INFO*************\n");
 	hikp_roce_timer_print(timer_rsp);
 out:
@@ -104,6 +110,12 @@ static int hikp_roce_timer_show_cqc(struct major_cmd_ctrl *self)
 		goto out;
 
 	timer_rsp = (struct roce_timer_rsp_data *)(cmd_ret->rsp_data);
+	if (timer_rsp->reg_num > ROCE_HIKP_TIMER_REG_NUM) {
+		printf("version might not match, adjust the reg num to %d.\n",
+		       ROCE_HIKP_TIMER_REG_NUM);
+		timer_rsp->reg_num = ROCE_HIKP_TIMER_REG_NUM;
+	}
+
 	printf("**************CQC TIMER INFO*************\n");
 	hikp_roce_timer_print(timer_rsp);
 out:
@@ -137,7 +149,7 @@ static void hikp_roce_timer_execute(struct major_cmd_ctrl *self)
 	int (*func[])(struct major_cmd_ctrl *self) = {
 		hikp_roce_timer_show_cqc, hikp_roce_timer_show_qpc
 	};
-	char *function[] = {"show cqc", "show qpc"};
+	const char *function[] = {"show cqc", "show qpc"};
 	int i = 0;
 	int ret;
 
diff --git a/net/roce/roce_timer/hikp_roce_timer.h b/net/roce/roce_timer/hikp_roce_timer.h
index a4a32b1143db7101bc8b060cc3aef275cd03ee4f..7f7deb69fd34d17ca2eca842e423f88328a8e7f8 100644
--- a/net/roce/roce_timer/hikp_roce_timer.h
+++ b/net/roce/roce_timer/hikp_roce_timer.h
@@ -14,7 +14,7 @@
 #ifndef __HIKP_ROCE_TIMER_H__
 #define __HIKP_ROCE_TIMER_H__
 
-#include "hikp_net_lib.h"
+#include "hikp_roce_ext_common.h"
 
 #define ROCE_HIKP_TIMER_REG_NUM 25
 #define ROCE_TIMER_CMD_CLEAR (1 << 0)
diff --git a/net/roce/roce_trp/hikp_roce_trp.c b/net/roce/roce_trp/hikp_roce_trp.c
index 4591a4719449b9a8e5526f7d08e7d972159b5dfb..fad331776cd7491a2dc438105e4ed92a847f0599 100644
--- a/net/roce/roce_trp/hikp_roce_trp.c
+++ b/net/roce/roce_trp/hikp_roce_trp.c
@@ -85,20 +85,17 @@ static int hikp_roce_trp_bank_get(struct major_cmd_ctrl *self, const char *argv)
 
 static int hikp_roce_trp_bank_check(void)
 {
-	uint32_t temp;
-
-	temp = g_roce_trp_param_t.bank_id;
 	switch (g_roce_trp_param_t.sub_cmd) {
 	case (COMMON):
-		if (temp > TRP_MAX_BANK_NUM || temp < 0)
+		if (g_roce_trp_param_t.bank_id > TRP_MAX_BANK_NUM)
 			return -EINVAL;
 		break;
 	case (PAYL):
-		if (temp > PAYL_MAX_BANK_NUM || temp < 0)
+		if (g_roce_trp_param_t.bank_id > PAYL_MAX_BANK_NUM)
 			return -EINVAL;
 		break;
 	case (GEN_AC):
-		if (temp > GAC_MAX_BANK_NUM || temp < 0)
+		if (g_roce_trp_param_t.bank_id > GAC_MAX_BANK_NUM)
 			return -EINVAL;
 		break;
 	default:
@@ -173,7 +170,8 @@ static int hikp_roce_trp_get_total_data_num(struct roce_trp_head *res_head,
 	*offset = (uint32_t *)calloc(1, max_size);
 	*data = (uint32_t *)calloc(1, max_size);
 	if ((*offset == NULL) || (*data == NULL)) {
-		printf("hikptool roce_trp alloc log memmory 0x%x failed\n", max_size);
+		printf("hikptool roce_trp alloc log memmory 0x%zx failed\n", max_size);
+		hikp_roce_trp_reg_data_free(offset, data);
 		ret = -ENOMEM;
 		goto get_data_error;
 	}
@@ -181,7 +179,8 @@ static int hikp_roce_trp_get_total_data_num(struct roce_trp_head *res_head,
 	cur_size = roce_trp_res->head.cur_block_num * sizeof(uint32_t);
 	if (cur_size > max_size) {
 		printf("hikptool roce_trp log data copy size error, "
-		       "data size: 0x%x, max size: 0x%x\n", cur_size, max_size);
+		       "data size: 0x%zx, max size: 0x%zx\n", cur_size, max_size);
+		hikp_roce_trp_reg_data_free(offset, data);
 		ret = -EINVAL;
 		goto get_data_error;
 	}
@@ -218,7 +217,7 @@ static int hikp_roce_trp_get_next_data(struct roce_trp_head *res_head,
 	if (cur_size > data_size) {
 		hikp_roce_trp_cmd_ret_free(&cmd_ret);
 		printf("hikptool roce_trp next log data copy size error, "
-		       "data size: 0x%x, max size: 0x%x\n", cur_size, data_size);
+		       "data size: 0x%zx, max size: 0x%zx\n", cur_size, data_size);
 		return -EINVAL;
 	}
 	memcpy(*offset, roce_trp_res->reg_data.offset, cur_size);
@@ -268,7 +267,6 @@ static void hikp_roce_trp_execute(struct major_cmd_ctrl *self)
 	if (self->err_no) {
 		snprintf(self->err_str, sizeof(self->err_str),
 			 "get the first roce_trp block dfx fail.");
-		hikp_roce_trp_reg_data_free(&offset, &data);
 		return;
 	}
 	total_block_num = res_head.total_block_num;
diff --git a/net/roce/roce_trp/hikp_roce_trp.h b/net/roce/roce_trp/hikp_roce_trp.h
index 80d28af3c9a64c1b629aa27bfffed7a25daddc69..97f1838e115eac64ae909d057cde2ae66b3d1ff6 100644
--- a/net/roce/roce_trp/hikp_roce_trp.h
+++ b/net/roce/roce_trp/hikp_roce_trp.h
@@ -14,7 +14,7 @@
 #ifndef __HIKP_ROCE_TRP_H__
 #define __HIKP_ROCE_TRP_H__
 
-#include "hikp_net_lib.h"
+#include "hikp_roce_ext_common.h"
 
 #define TRP_DIV_NUM_T 4
 #define ROCE_HIKP_TRP_REG_NUM 29
diff --git a/net/roce/roce_tsp/hikp_roce_tsp.c b/net/roce/roce_tsp/hikp_roce_tsp.c
index ca3126bee1211bfd42dbba2181f921b455e06630..5bb264994b83975617836eb349f5bde77e180a9d 100644
--- a/net/roce/roce_tsp/hikp_roce_tsp.c
+++ b/net/roce/roce_tsp/hikp_roce_tsp.c
@@ -84,16 +84,13 @@ static int hikp_roce_tsp_bank_get(struct major_cmd_ctrl *self, const char *argv)
 
 static int hikp_roce_tsp_bank_check(void)
 {
-	uint32_t temp;
-
-	temp = g_roce_tsp_param_t.bank_id;
 	switch (g_roce_tsp_param_t.sub_cmd_code) {
 	case (COMMON):
-		if ((temp > MAX_TSP_BANK_NUM) || temp < 0)
+		if (g_roce_tsp_param_t.bank_id > MAX_TSP_BANK_NUM)
 			return -EINVAL;
 		break;
 	case (TGP_TMP):
-		if ((temp > MAX_TGP_TMP_BANK_NUM) || temp < 0)
+		if (g_roce_tsp_param_t.bank_id > MAX_TGP_TMP_BANK_NUM)
 			return -EINVAL;
 		break;
 	default:
@@ -184,6 +181,12 @@ static void hikp_roce_tsp_execute(struct major_cmd_ctrl *self)
 	}
 
 	roce_tsp_res = (struct roce_tsp_res_param *)cmd_ret->rsp_data;
+	if (roce_tsp_res->total_block_num > ROCE_HIKP_TSP_REG_NUM) {
+		printf("version might not match, adjust the reg num to %d.\n",
+		       ROCE_HIKP_TSP_REG_NUM);
+		roce_tsp_res->total_block_num = ROCE_HIKP_TSP_REG_NUM;
+	}
+
 	hikp_roce_tsp_print(roce_tsp_res->total_block_num,
 			    roce_tsp_res->reg_data.offset, roce_tsp_res->reg_data.data);
 
diff --git a/net/roce/roce_tsp/hikp_roce_tsp.h b/net/roce/roce_tsp/hikp_roce_tsp.h
index ae864bab73e424fe6a4dcb31c08f9c7a7f6082ad..43d0d0dc5d83b76b39cd4864f8b26456593b2298 100644
--- a/net/roce/roce_tsp/hikp_roce_tsp.h
+++ b/net/roce/roce_tsp/hikp_roce_tsp.h
@@ -14,7 +14,7 @@
 #ifndef __HIKP_ROCE_TSP_H__
 #define __HIKP_ROCE_TSP_H__
 
-#include "hikp_net_lib.h"
+#include "hikp_roce_ext_common.h"
 
 #define ROCE_HIKP_TSP_REG_NUM 29
 #define TSP_PER_REG_NUM 2
diff --git a/net/ub/ub_crd/hikp_ub_crd.c b/net/ub/ub_crd/hikp_ub_crd.c
index e207ea26f8c13fd0b258449ebc54888fef9af3a1..0e47b5b18871aff4a2e41487f665d9fe96e88c27 100644
--- a/net/ub/ub_crd/hikp_ub_crd.c
+++ b/net/ub/ub_crd/hikp_ub_crd.c
@@ -64,7 +64,6 @@ static int hikp_ub_query_crd(void)
 	struct hikp_cmd_ret *cmd_ret = NULL;
 	struct ub_crd_rsp *crd_rsp = NULL;
 	int offset;
-	int ret;
 
 	char const *init_crds[][2] = {
 		{"CFG_REMOTE_ICRD", "CFG_REMOTE_LCRD"},
diff --git a/net/ub/ub_unic/hikp_unic_ppp.c b/net/ub/ub_ppp/hikp_unic_ppp.c
similarity index 98%
rename from net/ub/ub_unic/hikp_unic_ppp.c
rename to net/ub/ub_ppp/hikp_unic_ppp.c
index 5325b03b4a4afef34bafabf3c6d110310b0e31c8..bf0c026c2965e1150b1f02e25a58ccbda19a64bd 100644
--- a/net/ub/ub_unic/hikp_unic_ppp.c
+++ b/net/ub/ub_ppp/hikp_unic_ppp.c
@@ -191,6 +191,7 @@ static int hikp_unic_ppp_alloc_guid_tbl_entry(const struct hikp_unic_ppp_hw_reso
 	if (guid_tbl->mc_tbl.entry == NULL) {
 		HIKP_ERROR_PRINT("fail to alloc mc_guid_entry_table memory.\n");
 		free(guid_tbl->uc_tbl.entry);
+		guid_tbl->uc_tbl.entry = NULL;
 		return -ENOMEM;
 	}
 
@@ -399,13 +400,17 @@ static void hikp_unic_ppp_data_free(union unic_ppp_feature_info *unic_ppp_data)
 	if (g_unic_ppp_param.feature_idx == UNIC_PPP_IP_FEATURE_IDX) {
 		ip_tbl = &unic_ppp_data->ip_tbl;
 		free(ip_tbl->entry);
+		ip_tbl->entry = NULL;
 	} else if (g_unic_ppp_param.feature_idx == UNIC_PPP_GUID_FEATURE_IDX) {
 		guid_tbl = &unic_ppp_data->guid_tbl;
 		free(guid_tbl->uc_tbl.entry);
+		guid_tbl->uc_tbl.entry = NULL;
 		free(guid_tbl->mc_tbl.entry);
+		guid_tbl->mc_tbl.entry = NULL;
 	}
 
 	free(unic_ppp_data);
+	unic_ppp_data = NULL;
 }
 
 static void hikp_unic_ppp_cmd_execute(struct major_cmd_ctrl *self)
@@ -465,4 +470,4 @@ static void cmd_unic_get_ppp_init(void)
 	cmd_option_register("-du", "--dump", true, hikp_unic_cmd_ppp_feature_select);
 }
 
-HIKP_CMD_DECLARE("unic_ppp", "dump ppp info of unic!", cmd_unic_get_ppp_init);
\ No newline at end of file
+HIKP_CMD_DECLARE("unic_ppp", "dump ppp info of unic!", cmd_unic_get_ppp_init);
diff --git a/net/ub/ub_unic/hikp_unic_ppp.h b/net/ub/ub_ppp/hikp_unic_ppp.h
similarity index 100%
rename from net/ub/ub_unic/hikp_unic_ppp.h
rename to net/ub/ub_ppp/hikp_unic_ppp.h
diff --git a/ossl/ossl_user_linux.c b/ossl/ossl_user_linux.c
index 8266a1902b6222486aa68a3bb842549acb1ed652..9dee61cad824f78ab5ce6dc2f40d68cba43414bb 100644
--- a/ossl/ossl_user_linux.c
+++ b/ossl/ossl_user_linux.c
@@ -47,7 +47,6 @@ int uda_realpath(const char *file_dir, char *format_dir)
 
 int uda_fcntl(const char *lock_file, uint32_t operation, int *fd)
 {
-	uint32_t f_opt = 0;
 	int fd_t = 0;
 	int ret;
 
diff --git a/pcie/func_lib/pcie_func/pcie_link_ltssm.c b/pcie/func_lib/pcie_func/pcie_link_ltssm.c
index 96975290cead7b17698db1386576e65f8be04b03..66226e0e13c0fbe5370bf46ccdf7d582f7d67bab 100644
--- a/pcie/func_lib/pcie_func/pcie_link_ltssm.c
+++ b/pcie/func_lib/pcie_func/pcie_link_ltssm.c
@@ -213,7 +213,7 @@ static int pcie_print_ltssm_trace(const uint64_t *ltssm_input, uint32_t ltssm_nu
 			(uint32_t)ltssm_val.bits.any_change_pipe_req,
 			(uint32_t)ltssm_val.bits.rxl0s_st,
 			(uint32_t)ltssm_val.bits.train_bit_map1,
-			(((uint32_t)ltssm_val.bits.rxl0s_st) << 2) |
+			(((uint32_t)ltssm_val.bits.rxl0s_st) << GEN5_BIT_OFFEST) |
 			((uint32_t)ltssm_val.bits.mac_rate),
 			(uint32_t)ltssm_val.bits.duration_counter,
 			(uint32_t)ltssm_val.bits.ltssm_state,
@@ -271,7 +271,6 @@ int pcie_ltssm_trace_clear(uint32_t port_id)
 
 int pcie_ltssm_link_status_get(uint32_t port_id)
 {
-	uint32_t i;
 	union pcie_link_info reg_val;
 	struct hikp_cmd_header req_header;
 	struct hikp_cmd_ret *cmd_ret;
diff --git a/pcie/func_lib/pcie_func/pcie_link_ltssm.h b/pcie/func_lib/pcie_func/pcie_link_ltssm.h
index 8f3502bf8819b0a85d86331a704fc9fad473027b..cc51501695d65119687586eeb1ec2d4555eae45f 100644
--- a/pcie/func_lib/pcie_func/pcie_link_ltssm.h
+++ b/pcie/func_lib/pcie_func/pcie_link_ltssm.h
@@ -19,6 +19,7 @@
 #define TRACE_STR_NUM 0x20
 #define TRACER_DEPTH 65
 #define PM_TRACE_STR_NUM 0x28
+#define GEN5_BIT_OFFEST 2
 
 struct pcie_ltssm_num_string {
 	int ltssm;
diff --git a/pcie/func_lib/pcie_func/pcie_reg_dump.c b/pcie/func_lib/pcie_func/pcie_reg_dump.c
index aac38435f83a650b07925754b87cc85cb1303c05..b8c22414bd7c9b45d6fed5b1e44bbe0c59a38da7 100644
--- a/pcie/func_lib/pcie_func/pcie_reg_dump.c
+++ b/pcie/func_lib/pcie_func/pcie_reg_dump.c
@@ -405,7 +405,7 @@ static int pcie_create_dumpreg_log_file(uint32_t port_id, uint32_t dump_level)
 
 	(void)remove((const char *)file_name);
 	/* Add write permission to the file */
-	fd_file = open(file_name, O_RDWR | O_SYNC | O_CREAT, 0640);
+	fd_file = open(file_name, O_RDWR | O_SYNC | O_CREAT, 0600);
 	if (fd_file < 0) {
 		Err("PCIe DUMPREG", "open %s failed.\n", file_name);
 		return -EPERM;
@@ -419,7 +419,7 @@ static int pcie_close_dumpreg_log_file(void)
 {
 	int ret;
 
-	ret = fchmod(g_pcie_dumpreg_fd, 0440);
+	ret = fchmod(g_pcie_dumpreg_fd, 0400);
 	close(g_pcie_dumpreg_fd);
 	/* Revoke write permission of file  */
 	g_pcie_dumpreg_fd = -1;
diff --git a/pcie/func_lib/pcie_func/pcie_statistics.c b/pcie/func_lib/pcie_func/pcie_statistics.c
index 308a142cf8ecc0168678ce7f7921e493ef95d7ec..ed42cec36a2debb77233b940d3bb8e531c5fb199 100644
--- a/pcie/func_lib/pcie_func/pcie_statistics.c
+++ b/pcie/func_lib/pcie_func/pcie_statistics.c
@@ -25,6 +25,10 @@ static const char *g_global_width_name[GLOBAL_WIDTH_TABLE_SIZE] = {
 	"PCIE_WIDTH_X1", "PCIE_WIDTH_X2", "PCIE_WIDTH_X4", "PCIE_WIDTH_X8", "PCIE_WIDTH_X16"
 };
 
+static const char *g_global_ndie_name[] = {
+	"Ndie_A", "Ndie_B"
+};
+
 static int port_distribution_rsp_data_check(const struct hikp_cmd_ret *cmd_ret, uint32_t *port_num)
 {
 	size_t rsp_data_size, expect_data_size;
@@ -58,12 +62,35 @@ static int port_distribution_rsp_data_check(const struct hikp_cmd_ret *cmd_ret,
 	return 0;
 }
 
+static int pcie_portid_serdes_relation(const struct pcie_macro_info *macro_info,
+				       uint32_t macro_num, uint32_t ndie_id)
+{
+	uint32_t i, j;
+
+	if (ndie_id >= HIKP_ARRAY_SIZE(g_global_ndie_name)) {
+		Info("PCIe Base", "ndie_id [%u]: %s\n", ndie_id, "UNKNOWN_NDIE");
+		return -1;
+	}
+
+	if (macro_num >= MAX_MACRO_ONEPORT) {
+		Info("PCIe Base", "macro_num [%u] exceeds the maximum array length\n", macro_num);
+		return -1;
+	}
+
+	Info("PCIe Base", "\tndie_id: %s\n", g_global_ndie_name[ndie_id]);
+	for (i = 0; i < macro_num; i++) {
+		for (j = macro_info[i].lane_s; j <= macro_info[i].lane_e; j++)
+			Info("PCIe Base", "\t\tmacro %d \t lane: %d\n", macro_info[i].id, j);
+	}
+	return 0;
+}
+
 int pcie_port_distribution_get(uint32_t chip_id)
 {
 	struct hikp_cmd_header req_header;
 	struct hikp_cmd_ret *cmd_ret;
 	struct pcie_info_req_para req_data = { 0 };
-	uint32_t src_size, dst_size, pair_num;
+	uint32_t pair_num;
 	struct pcie_port_info *port_info;
 	uint32_t i;
 	int ret;
@@ -86,6 +113,9 @@ int pcie_port_distribution_get(uint32_t chip_id)
 		}
 		Info("PCIe Base", "port_id[%u] %s\n", port_info->info_pair[i].port_id,
 			g_global_width_name[port_info->info_pair[i].port_width]);
+		pcie_portid_serdes_relation(port_info->info_pair[i].macro_info,
+					    port_info->info_pair[i].macro_num,
+					    port_info->info_pair[i].ndie_id);
 	}
 free_cmd_ret:
 	free(cmd_ret);
diff --git a/pcie/func_lib/pcie_func/pcie_statistics.h b/pcie/func_lib/pcie_func/pcie_statistics.h
index 2a3cc66a01590864c31ec26528a26f1514a4dcda..3e3916b28045aa9860e425f6eaa226f997afb337 100644
--- a/pcie/func_lib/pcie_func/pcie_statistics.h
+++ b/pcie/func_lib/pcie_func/pcie_statistics.h
@@ -17,6 +17,7 @@
 #include "pcie_common_api.h"
 
 #define GLOBAL_WIDTH_TABLE_SIZE 5
+#define MAX_MACRO_ONEPORT 3
 
 union mac_test_cnt {
 	/* Define the struct bits */
@@ -88,9 +89,18 @@ union dfx_dcrc_err_num {
 	unsigned int u32;
 };
 
+struct pcie_macro_info {
+	uint32_t id;
+	uint32_t lane_s;
+	uint32_t lane_e;
+};
+
 struct pcie_info_distribution_pair {
 	uint32_t port_id;
 	uint32_t port_width;
+	uint32_t ndie_id;
+	uint32_t macro_num;
+	struct pcie_macro_info macro_info[MAX_MACRO_ONEPORT];
 };
 
 struct pcie_port_info {
diff --git a/sas/sas_func/sas_common.h b/sas/sas_func/sas_common.h
index 94647929781c4c3418a1e84e2f4fb3bfa7c78fbc..1bace0c5d2bd99a659e16d8a980b44435641415d 100644
--- a/sas/sas_func/sas_common.h
+++ b/sas/sas_func/sas_common.h
@@ -22,7 +22,6 @@
 #define IPTT_ICT_STATUS 29
 #define LINK_SPEED_OFFSET 8
 #define LINK_SPEED_WIDTH 4
-#define MAX_DEVICE_NUM 2048
 
 #define DWS_LOST 0
 #define RESET_PROB 1
@@ -73,7 +72,6 @@ enum sas_errcode_cmd_type {
 
 enum sas_dev_cmd_type {
 	DEV_LINK,
-	DEV_INFO,
 	DEV_UNKNOWN_TYPE,
 };
 
diff --git a/sas/sas_func/sas_read_dev.c b/sas/sas_func/sas_read_dev.c
index 8b9b58d519f3905f78caac131cbfd6581c629f8c..670e2d454dbecfa77e95139d6bad812db7550a53 100644
--- a/sas/sas_func/sas_read_dev.c
+++ b/sas/sas_func/sas_read_dev.c
@@ -76,28 +76,8 @@ static void print_dev_link(const uint32_t *reg_save, uint32_t reg_num)
 	}
 }
 
-static void print_dev_info(const void *reg_save, uint32_t reg_num)
-{
-	volatile struct hikp_sas_itct *itct = (volatile struct hikp_sas_itct *)reg_save;
-
-	printf("The device information as below:\n");
-	printf("dev_type: %d\n", itct->dw0.dev_type);
-	printf("dev_valid: %d\n", itct->dw0.dev_valid);
-	printf("break_reply_en: %d\n", itct->dw0.break_reply_en);
-	printf("smp_timeout: %d\n", itct->dw0.smp_timeout);
-	printf("tlr_en: %d\n", itct->dw0.tlr_en);
-	printf("awt_continue: %d\n", itct->dw0.awt_continue);
-	printf("sas_addr: 0x%llx\n", itct->sas_addr);
-	printf("I_T_nexus_loss: %d\n", itct->dw2.I_T_nexus_loss);
-	printf("awt_initial_value: %d\n", itct->dw2.awt_initial_value);
-	printf("maximum_connect_time: %d\n", itct->dw2.maximum_connect_time);
-	printf("reject_to_open_limit: %d\n", itct->dw2.reject_to_open_limit);
-}
-
 static void sas_print_dev(const uint32_t *reg_save, uint32_t reg_num, uint32_t cmd_type)
 {
-	uint32_t i;
-
 	if (reg_num == 0) {
 		printf("SAS device is failed\n");
 		return;
@@ -106,9 +86,6 @@ static void sas_print_dev(const uint32_t *reg_save, uint32_t reg_num, uint32_t c
 	case DEV_LINK:
 		print_dev_link(reg_save, reg_num);
 		break;
-	case DEV_INFO:
-		print_dev_info(reg_save, reg_num);
-		break;
 	default:
 		printf("cmd_type is error\n");
 	}
diff --git a/sas/sas_func/sas_read_dqe.c b/sas/sas_func/sas_read_dqe.c
index dbd30f3e056fac5dc4ca68ba3afc1b257bedd78c..7d49c0aea767cf494cd1c3bedd4e47b8621a2a58 100644
--- a/sas/sas_func/sas_read_dqe.c
+++ b/sas/sas_func/sas_read_dqe.c
@@ -57,7 +57,7 @@ static void print_dqe_info(const void *reg_save, uint32_t reg_num)
 	printf("TLR_Ctrl: %u\n", dqe->dw0.TLR_Ctrl);
 	printf("Phy_ID: %u\n", dqe->dw0.Phy_ID);
 	printf("Force_Phy: %u\n", dqe->dw0.Force_Phy);
-	printf("PORT: 0x%llx\n", dqe->dw0.PORT);
+	printf("PORT: 0x%x\n", dqe->dw0.PORT);
 	printf("PRI: %u\n", dqe->dw0.PRI);
 	printf("CMD: %u\n", dqe->dw0.CMD);
 
@@ -68,7 +68,7 @@ static void print_dqe_info(const void *reg_save, uint32_t reg_num)
 	printf("Reset: %u\n", dqe->dw1.Reset);
 	printf("PIR_Present: %u\n", dqe->dw1.PIR_Present);
 	printf("Enable_Transport_Layer_Retry: %u\n", dqe->dw1.Enable_Transport_Layer_Retry);
-	printf("Verify_Data_Transfer_Length: 0x%llx\n", dqe->dw1.Verify_Data_Transfer_Length);
+	printf("Verify_Data_Transfer_Length: 0x%x\n", dqe->dw1.Verify_Data_Transfer_Length);
 	printf("Frame_Type: %u\n", dqe->dw1.Frame_Type);
 	printf("Device_ID: %u\n", dqe->dw1.Device_ID);
 
diff --git a/sas/user_cmd/cmd_code/sas_cmd_common.c b/sas/user_cmd/cmd_code/sas_cmd_common.c
index cca4084ee08285361f2a5e543bd05314e9dec36b..7d4ffbb123dabcc8be128ad4b3697a90e69270ac 100644
--- a/sas/user_cmd/cmd_code/sas_cmd_common.c
+++ b/sas/user_cmd/cmd_code/sas_cmd_common.c
@@ -54,11 +54,6 @@ int sas_get_phy_id(void)
 	return g_sas_cmd.phy_id;
 }
 
-int sas_get_dev_id(void)
-{
-	return g_sas_cmd.dev_id;
-}
-
 int sas_get_que_id(void)
 {
 	return g_sas_cmd.que_id;
@@ -84,11 +79,6 @@ int sas_set_die_id(struct major_cmd_ctrl *self, const char *argv)
 	return sas_set_id(self, argv, &g_sas_cmd.die_id);
 }
 
-int sas_set_dev_id(struct major_cmd_ctrl *self, const char *argv)
-{
-	return sas_set_id(self, argv, &g_sas_cmd.dev_id);
-}
-
 int sas_set_que_id(struct major_cmd_ctrl *self, const char *argv)
 {
 	return sas_set_id(self, argv, &g_sas_cmd.que_id);
diff --git a/sas/user_cmd/cmd_code/sas_cmd_dev.c b/sas/user_cmd/cmd_code/sas_cmd_dev.c
index c95006bcd63367d35297f873f886fb57567718c5..6a5eae0ec120be1c9dc8dee12d27885d60fc9fec 100644
--- a/sas/user_cmd/cmd_code/sas_cmd_dev.c
+++ b/sas/user_cmd/cmd_code/sas_cmd_dev.c
@@ -26,7 +26,6 @@ static int sas_dev_help(struct major_cmd_ctrl *self, const char *argv)
 	printf("\n  Options:\n\n");
 	printf("    %s, %-25s %s\n", "-h", "--help", "display this help and exit\n");
 	printf("    %s, %-25s %s\n", "-l", "--link", "dispaly device type and speed\n");
-	printf("    %s, %-25s %s\n", "-i", "--info", "dispaly the device detail information\n");
 	printf("\n");
 
 	return 0;
@@ -37,19 +36,6 @@ static int sas_dev_link(struct major_cmd_ctrl *self, const char *argv)
 	return sas_set_cmd_type(DEV_LINK);
 }
 
-static int sas_dev_info(struct major_cmd_ctrl *self, const char *argv)
-{
-	int ret;
-
-	(void)sas_set_cmd_type(DEV_INFO);
-	ret = sas_set_dev_id(self, argv);
-	if (ret || sas_get_dev_id() >= MAX_DEVICE_NUM) {
-		printf("device id is too large(>=%d)\n", MAX_DEVICE_NUM);
-		return -EINVAL;
-	}
-	return ret;
-}
-
 static int sas_dev_excute_funs_call(uint32_t cmd_type)
 {
 	if (cmd_type != SAS_UNKNOW_CMD)
@@ -63,11 +49,9 @@ static void sas_dev_execute(struct major_cmd_ctrl *self)
 	int ret, cmd;
 	const char *suc_msg[] = {
 		"sas_dev_link success.",
-		"sas_dev_info success.",
 	};
 	const char *err_msg[] = {
 		"sas_dev_link error.",
-		"sas_dev_info error.",
 		"sas_dev failed, unknown type",
 	};
 
@@ -95,7 +79,6 @@ static void cmd_sas_dev_init(void)
 	cmd_option_register("-d", "--dieid", true, sas_set_die_id);
 	cmd_option_register("-h", "--help", false, sas_dev_help);
 	cmd_option_register("-l", "--link", false, sas_dev_link);
-	cmd_option_register("-i", "--info", true, sas_dev_info);
 }
 
 HIKP_CMD_DECLARE("sas_dev", "sas device information ", cmd_sas_dev_init);
diff --git a/sas/user_cmd/cmd_code/sas_cmd_dqe.c b/sas/user_cmd/cmd_code/sas_cmd_dqe.c
index 4a9547a383121f726db2b07946981c0c6139dc5e..26bf0ebee77d9ef079b997a5889ae530c65ab0ff 100644
--- a/sas/user_cmd/cmd_code/sas_cmd_dqe.c
+++ b/sas/user_cmd/cmd_code/sas_cmd_dqe.c
@@ -44,7 +44,6 @@ static int sas_dqe_info(struct major_cmd_ctrl *self, const char *argv)
 static int sas_set_queue_id(struct major_cmd_ctrl *self, const char *argv)
 {
 	int ret;
-	uint32_t val = 0;
 
 	ret = sas_set_que_id(self, argv);
 	if (ret || sas_get_que_id() >= SAS_QUEUE_NUM) {
diff --git a/sas/user_cmd/cmd_code/sas_cmd_dump.c b/sas/user_cmd/cmd_code/sas_cmd_dump.c
index 4f2cfeade19a1f94c4736b259c0ee076b7b7d12e..e7dedf0b10956f101ac2c9b83db8975529dea5a7 100644
--- a/sas/user_cmd/cmd_code/sas_cmd_dump.c
+++ b/sas/user_cmd/cmd_code/sas_cmd_dump.c
@@ -42,7 +42,6 @@ static int sas_dump_global(struct major_cmd_ctrl *self, const char *argv)
 static int sas_dump_phyx(struct major_cmd_ctrl *self, char const *argv)
 {
 	int ret;
-	uint32_t val = 0;
 
 	(void)sas_set_cmd_type(DUMP_PHYX);
 	ret = sas_set_phy_id(self, argv);
diff --git a/sas/user_cmd/cmd_code/sas_tools_include.h b/sas/user_cmd/cmd_code/sas_tools_include.h
index a71e614b655b259c7bb71b49caf2d35b0062e137..0aa7703f4dd068f535450bca8bac598a3c1e8bfa 100644
--- a/sas/user_cmd/cmd_code/sas_tools_include.h
+++ b/sas/user_cmd/cmd_code/sas_tools_include.h
@@ -34,13 +34,11 @@ struct tool_sas_cmd {
 int sas_set_cmd_type(int cmd_type);
 int sas_get_cmd_type(void);
 int sas_get_phy_id(void);
-int sas_get_dev_id(void);
 int sas_get_que_id(void);
 struct tool_sas_cmd *sas_get_cmd_p(void);
 int sas_set_chip_id(struct major_cmd_ctrl *self, const char *argv);
 int sas_set_phy_id(struct major_cmd_ctrl *self, const char *argv);
 int sas_set_die_id(struct major_cmd_ctrl *self, const char *argv);
-int sas_set_dev_id(struct major_cmd_ctrl *self, const char *argv);
 int sas_set_que_id(struct major_cmd_ctrl *self, const char *argv);
 int sas_set_dqe_id(struct major_cmd_ctrl *self, const char *argv);
 
diff --git a/serdes/hikp_serdes.c b/serdes/hikp_serdes.c
index 320ded207d9d9d51fe429ce2b977cc57b1b796e6..4afcb9ba6fe1a70f0e816406a8a7c1cd328d0357 100644
--- a/serdes/hikp_serdes.c
+++ b/serdes/hikp_serdes.c
@@ -322,7 +322,7 @@ static void hikp_serdes_info_cmd_execute(struct major_cmd_ctrl *self)
 	    SERDES_OUTPUT_MAX_SIZE) {
 		self->err_no = -EINVAL;
 		snprintf(self->err_str, sizeof(self->err_str),
-			"serdes_info rsp_data data copy size error, data size:0x%x max size:0x%x.",
+			"serdes_info rsp_data data copy size error, data size:0x%zx max size:0x%x.",
 			(cmd_ret->rsp_data_num * sizeof(uint32_t) - out_out_header_size),
 			SERDES_OUTPUT_MAX_SIZE);
 		goto err_out;
@@ -480,7 +480,7 @@ static void hikp_serdes_dump_cmd_execute(struct major_cmd_ctrl *self)
 	    SERDES_OUTPUT_MAX_SIZE) {
 		self->err_no = -EINVAL;
 		snprintf(self->err_str, sizeof(self->err_str),
-			"serdes_dump rsp_data data copy size error, data size:0x%x max size:0x%x.",
+			"serdes_dump rsp_data data copy size error, data size:0x%zx max size:0x%x.",
 			(cmd_ret->rsp_data_num * sizeof(uint32_t) - out_out_header_size),
 			SERDES_OUTPUT_MAX_SIZE);
 		goto err_out;
diff --git a/socip/hikp_socip_dumpreg.c b/socip/hikp_socip_dumpreg.c
index 0153dd9ded155dd0e42f64092aa4e6017f2c617b..7b11523f8566871f032744d95068d0718c5d25b9 100644
--- a/socip/hikp_socip_dumpreg.c
+++ b/socip/hikp_socip_dumpreg.c
@@ -108,7 +108,6 @@ static bool check_socip_dumpreg_param(void)
 static void dump_reg_info(const uint32_t *reg_data, uint32_t data_num)
 {
 #define ONE_LINE_PRINT_DATA_NUM 4
-	struct dump_reg_param_t *param = &g_dump_reg_param[0];
 	uint32_t i;
 
 	for (i = 0; i < data_num; i++) {
diff --git a/tool_lib/op_logs.c b/tool_lib/op_logs.c
index d91ddb0830a2c36f1980c50d427128bf614e34bf..f57f5fd62dfd79fb2ba82c025eb4f2dfc87c0a26 100644
--- a/tool_lib/op_logs.c
+++ b/tool_lib/op_logs.c
@@ -29,7 +29,6 @@ static void op_log_write(const char *log_data)
 {
 	size_t w_size;
 	FILE *fd;
-	int ret;
 
 	if (strlen(g_op_log) == 0)
 		return;
@@ -108,8 +107,6 @@ static int op_log_add_time_to_log(char *log_base, int *offset, uint32_t flag)
 	struct timeval tv;
 	struct tm ptm;
 	int len = 0;
-	long usec;
-	long sec;
 	int ret;
 
 	(void)gettimeofday(&tv, NULL);
@@ -118,12 +115,18 @@ static int op_log_add_time_to_log(char *log_base, int *offset, uint32_t flag)
 		g_tv = tv;
 		len = (int)strftime(log_base + *offset, (OP_LOG_FILE_W_MAXSIZE + 1 - *offset),
 				    OP_LOG_TIME_TEMP, &ptm);
+		if ((*offset + len) >= (OP_LOG_FILE_W_MAXSIZE + 1))
+			return -ENOMEM;
+
 		ret = snprintf(log_base + *offset + len,
 			       (OP_LOG_FILE_W_MAXSIZE + 1 - *offset - len), OP_LOG_SEC_TIME_TEMP,
 			       tv.tv_sec + tv.tv_usec / OP_LOG_SEC_AND_MICROSEC_TRANS);
-	} else if (flag == LOG_FLAG_ONLY_TIME) {
+	} else {
 		len = (int)strftime(log_base + *offset, (OP_LOG_FILE_W_MAXSIZE + 1 - *offset),
 				    OP_LOG_RESULT_TIME_TEMP, &ptm);
+		if ((*offset + len) >= (OP_LOG_FILE_W_MAXSIZE + 1))
+			return -ENOMEM;
+
 		ret = snprintf(log_base + *offset + len,
 			       (OP_LOG_FILE_W_MAXSIZE + 1 - *offset - len),
 			       OP_LOG_SEC_TIME_TEMP,
@@ -157,7 +160,6 @@ static int op_log_file_rollback(const char *op_log_backup, const char *log_dir)
 	char rollback_log[OP_LOG_FILE_W_MAXSIZE + 1] = {0};
 	int offset = 0;
 	int ret;
-	int len;
 
 	ret = file_rollback(g_op_log, op_log_backup, OP_LOG_FILE_MAX_SIZE);
 	if (ret) {
@@ -280,10 +282,14 @@ void op_log_record_input(const int argc, const char **argv)
 
 	arg = input_str;
 	for (i = 0; i < argc; i++) {
-		snprintf(arg, (sizeof(input_str) - (arg - input_str)), "%s ", argv[i]);
+		ret = snprintf(arg, (sizeof(input_str) - (arg - input_str)), "%s ", argv[i]);
+		if (ret < 0 || ret >= (sizeof(input_str) - (arg - input_str)))
+			return;
+
 		arg = arg + strlen(argv[i]) + 1;
 	}
 	input_str[strlen(input_str) - 1] = 0;
+
 	arr_size = HIKP_ARRAY_SIZE(log_info);
 	for (i = 0; i < arr_size; i++) {
 		ret = snprintf(g_input_buf + offset, (OP_LOG_FILE_W_MAXSIZE + 1 - offset),
diff --git a/tool_lib/tool_cmd.c b/tool_lib/tool_cmd.c
index 43a3b614c83a783715ba0e75ea5325b24689ab4a..db54f0f4afa5bb3633a5d3865bdaeeff8346d8fc 100644
--- a/tool_lib/tool_cmd.c
+++ b/tool_lib/tool_cmd.c
@@ -186,7 +186,6 @@ void command_parse_and_excute(const int argc, const char **argv)
 {
 	struct major_cmd_ctrl *major_cmd = get_major_cmd();
 	int lock_fd;
-	int check;
 	int ret;
 
 	major_cmd->err_no = check_command_length(argc, argv);
diff --git a/tool_lib/tool_lib.c b/tool_lib/tool_lib.c
index ad4bb68f27b45ff87cf7352406b2efea2c341ffb..180418f160ebe0e9391a486eff052798d0b91a69 100644
--- a/tool_lib/tool_lib.c
+++ b/tool_lib/tool_lib.c
@@ -337,6 +337,9 @@ bool tool_can_print(uint32_t interval, uint32_t burst, uint32_t *print_num, uint
 {
 	uint64_t cur_time;
 
+	if (!print_num || !last_time)
+		return false;
+
 	cur_time = (uint64_t)time(NULL);
 	if ((*last_time + interval) == cur_time)
 		*print_num = 0;