Fix zxdh driver packet sending and receiving errors.

Signed-off-by: Bingbin Chen <chen.bingbin@zte.com.cn>
---
 drivers/net/zxdh/zxdh_ethdev.c     | 19 +++++----
 drivers/net/zxdh/zxdh_ethdev_ops.c | 15 +++----
 drivers/net/zxdh/zxdh_msg.c        | 20 ++-------
 drivers/net/zxdh/zxdh_msg.h        | 12 +++---
 drivers/net/zxdh/zxdh_mtr.c        |  8 ++--
 drivers/net/zxdh/zxdh_np.c         | 68 ++++++++++++++++++++++++++----
 drivers/net/zxdh/zxdh_np.h         |  8 ++--
 drivers/net/zxdh/zxdh_pci.c        | 24 ++++++++++-
 drivers/net/zxdh/zxdh_pci.h        |  2 +-
 drivers/net/zxdh/zxdh_rxtx.c       | 11 +++--
 drivers/net/zxdh/zxdh_tables.c     | 42 +++++++++---------
 drivers/net/zxdh/zxdh_tables.h     | 68 +++++++++++++++++++++++-------
 12 files changed, 201 insertions(+), 96 deletions(-)

diff --git a/drivers/net/zxdh/zxdh_ethdev.c b/drivers/net/zxdh/zxdh_ethdev.c
index ea8b18e5e1..ba7ea52d20 100644
--- a/drivers/net/zxdh/zxdh_ethdev.c
+++ b/drivers/net/zxdh/zxdh_ethdev.c
@@ -1250,10 +1250,6 @@ zxdh_set_rxtx_funcs(struct rte_eth_dev *eth_dev)
 {
     struct zxdh_hw *hw = eth_dev->data->dev_private;
 
-    if (!zxdh_pci_packed_queue(hw)) {
-        PMD_DRV_LOG(ERR, "port %u not support packed queue", eth_dev->data->port_id);
-        return -1;
-    }
     if (!zxdh_pci_with_feature(hw, ZXDH_NET_F_MRG_RXBUF)) {
         PMD_DRV_LOG(ERR, "port %u not support rx mergeable", eth_dev->data->port_id);
         return -1;
@@ -1498,6 +1494,8 @@ zxdh_dtb_dump_res_init(struct zxdh_hw *hw, ZXDH_DEV_INIT_CTRL_T *dpp_ctrl)
 
     struct zxdh_dtb_bulk_dump_info dtb_dump_baseres[] = {
         {"sdt_vport_att_table", 4 * 1024 * 1024, ZXDH_SDT_VPORT_ATT_TABLE, NULL},
+        {"sdt_vlan_att_table", 4 * 1024 * 1024, ZXDH_SDT_VLAN_ATT_TABLE, NULL},
+        {"sdt_rss_table", 4 * 1024 * 1024, ZXDH_SDT_RSS_ATT_TABLE, NULL},
         {"sdt_l2_entry_table0", 5 * 1024 * 1024, ZXDH_SDT_L2_ENTRY_TABLE0, NULL},
         {"sdt_l2_entry_table1", 5 * 1024 * 1024, ZXDH_SDT_L2_ENTRY_TABLE1, NULL},
         {"sdt_l2_entry_table2", 5 * 1024 * 1024, ZXDH_SDT_L2_ENTRY_TABLE2, NULL},
@@ -1514,7 +1512,8 @@ zxdh_dtb_dump_res_init(struct zxdh_hw *hw, ZXDH_DEV_INIT_CTRL_T *dpp_ctrl)
     for (i = 0; i < (int)RTE_DIM(dtb_dump_baseres); i++) {
         struct zxdh_dtb_bulk_dump_info *p = dtb_dump_baseres + i;
         char buf[ZXDH_MAX_NAME_LEN] = {0};
-
+        memset(buf, '\0', sizeof(buf));
+        sprintf(buf, "%s_%x", p->mz_name, hw->dev_id);
         p->mz_name = buf;
 
         const struct rte_memzone *generic_dump_mz =
@@ -1544,6 +1543,7 @@ zxdh_np_dtb_res_init(struct rte_eth_dev *dev)
     struct zxdh_hw *hw = dev->data->dev_private;
     struct zxdh_bar_offset_params param = {0};
     struct zxdh_bar_offset_res res = {0};
+    char buf[ZXDH_MAX_NAME_LEN] = {0};
     struct zxdh_dtb_shared_data *dtb_data = &hw->dev_sd->dtb_sd;
     int ret = 0;
 
@@ -1569,7 +1569,7 @@ zxdh_np_dtb_res_init(struct rte_eth_dev *dev)
     dpp_ctrl->vport = hw->vport.vport;
     dpp_ctrl->vector = ZXDH_MSIX_INTR_DTB_VEC;
     strlcpy(dpp_ctrl->port_name, dev->device->name, sizeof(dpp_ctrl->port_name));
-    dpp_ctrl->pcie_vir_addr = (uint32_t)hw->bar_addr[0];
+    dpp_ctrl->pcie_vir_addr = (uint64_t)hw->bar_addr[0];
 
     param.pcie_id = hw->pcie_id;
     param.virt_addr = hw->bar_addr[0] + ZXDH_CTRLCH_OFFSET;
@@ -1584,7 +1584,8 @@ zxdh_np_dtb_res_init(struct rte_eth_dev *dev)
     dpp_ctrl->np_bar_offset = res.bar_offset;
 
     if (!dtb_data->dtb_table_conf_mz) {
-        const struct rte_memzone *conf_mz = rte_memzone_reserve_aligned("zxdh_dtb_table_conf_mz",
+        sprintf(buf, "%s_%x", "zxdh_dtb_table_conf_mz", hw->dev_id);
+        const struct rte_memzone *conf_mz = rte_memzone_reserve_aligned(buf,
                 ZXDH_DTB_TABLE_CONF_SIZE, SOCKET_ID_ANY, 0, RTE_CACHE_LINE_SIZE);
 
         if (conf_mz == NULL) {
@@ -1600,7 +1601,9 @@ zxdh_np_dtb_res_init(struct rte_eth_dev *dev)
     }
 
     if (!dtb_data->dtb_table_dump_mz) {
-        const struct rte_memzone *dump_mz = rte_memzone_reserve_aligned("zxdh_dtb_table_dump_mz",
+        memset(buf, '\0', sizeof(buf));
+        sprintf(buf, "%s_%x", "zxdh_dtb_table_dump_mz", hw->dev_id);
+        const struct rte_memzone *dump_mz = rte_memzone_reserve_aligned(buf,
                 ZXDH_DTB_TABLE_DUMP_SIZE, SOCKET_ID_ANY, 0, RTE_CACHE_LINE_SIZE);
 
         if (dump_mz == NULL) {
diff --git a/drivers/net/zxdh/zxdh_ethdev_ops.c b/drivers/net/zxdh/zxdh_ethdev_ops.c
index 2b02734c62..aa1001da01 100644
--- a/drivers/net/zxdh/zxdh_ethdev_ops.c
+++ b/drivers/net/zxdh/zxdh_ethdev_ops.c
@@ -433,7 +433,7 @@ zxdh_dev_mac_addr_set(struct rte_eth_dev *dev, struct rte_ether_addr *addr)
         ret = zxdh_del_mac_table(hw, hw->vport.vport, old_addr,
             hw->hash_search_index, 0, 0);
         if (ret) {
-            PMD_DRV_LOG(ERR, "mac_addr_add failed, code:%d", ret);
+            PMD_DRV_LOG(ERR, "mac_addr_del failed, code:%d", ret);
             return ret;
         }
         hw->uc_num--;
@@ -467,6 +467,8 @@ zxdh_dev_mac_addr_set(struct rte_eth_dev *dev, struct rte_ether_addr *addr)
         hw->uc_num--;
     }
     rte_ether_addr_copy(addr, (struct rte_ether_addr *)hw->mac_addr);
+    zxdh_pci_write_dev_config(hw, offsetof(struct zxdh_net_config, mac),
+                                &hw->mac_addr, RTE_ETHER_ADDR_LEN);
     return ret;
 }
 
@@ -566,7 +568,7 @@ zxdh_dev_mac_addr_add(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr,
 
 void zxdh_dev_mac_addr_remove(struct rte_eth_dev *dev, uint32_t index)
 {
-    struct zxdh_hw *hw    = dev->data->dev_private;
+    struct zxdh_hw *hw = dev->data->dev_private;
     struct zxdh_msg_info msg_info = {0};
     struct rte_ether_addr *mac_addr = &dev->data->mac_addrs[index];
     uint16_t ret = 0;
@@ -2040,11 +2042,6 @@ zxdh_dev_fw_version_get(struct rte_eth_dev *dev,
 
     zxdh_agent_msg_build(hw, ZXDH_FLASH_FIR_VERSION_GET, &msg_info);
 
-    struct zxdh_msg_recviver_mem rsp_data = {
-            .recv_buffer = (void *)&reply_info,
-            .buffer_len = sizeof(struct zxdh_msg_reply_info),
-    };
-
     ret = zxdh_send_msg_to_riscv(dev, &msg_info, sizeof(struct zxdh_msg_info),
                 &reply_info, sizeof(struct zxdh_msg_reply_info),
                 ZXDH_MODULE_FLASH);
@@ -2053,10 +2050,8 @@ zxdh_dev_fw_version_get(struct rte_eth_dev *dev,
                 hw->vport.vport, ZXDH_FLASH_FIR_VERSION_GET);
         return -1;
     }
-    struct zxdh_msg_reply_body *ack_msg =
-             &(((struct zxdh_msg_reply_info *)rsp_data.recv_buffer)->reply_body);
 
-    memcpy(fw_ver, ack_msg->flash_msg.firmware_version, ZXDH_FWVERS_LEN);
+    memcpy(fw_ver, &reply_info.reply_body.flash_msg, ZXDH_FWVERS_LEN);
     snprintf(fw_version, ZXDH_FWVERS_LEN - 1, "%s", fw_ver);
 
     return 0;
diff --git a/drivers/net/zxdh/zxdh_msg.c b/drivers/net/zxdh/zxdh_msg.c
index 96ad638e83..fac08fc30c 100644
--- a/drivers/net/zxdh/zxdh_msg.c
+++ b/drivers/net/zxdh/zxdh_msg.c
@@ -695,7 +695,7 @@ static uint16_t
 zxdh_bar_chan_sync_msg_reps_get(uint64_t subchan_addr,
         uint64_t recv_buffer, uint16_t buffer_len)
 {
-    struct zxdh_bar_msg_header msg_header = {0};
+    struct zxdh_bar_msg_header msg_header;
     uint16_t msg_id = 0;
     uint16_t msg_len = 0;
 
@@ -1147,13 +1147,9 @@ zxdh_send_msg_to_riscv(struct rte_eth_dev *dev, void *msg_req,
         result.recv_buffer = &reply_info;
         result.buffer_len = sizeof(reply_info);
     }
-    struct zxdh_msg_reply_head *reply_head =
-                &(((struct zxdh_msg_reply_info *)result.recv_buffer)->reply_head);
-    struct zxdh_msg_reply_body *reply_body =
-                &(((struct zxdh_msg_reply_info *)result.recv_buffer)->reply_body);
 
     struct zxdh_pci_bar_msg in = {
-        .payload_addr = &msg_req,
+        .payload_addr = msg_req,
         .payload_len = msg_req_len,
         .virt_addr = (uint64_t)(hw->bar_addr[ZXDH_BAR0_INDEX] + ZXDH_CTRLCH_OFFSET),
         .src = hw->is_pf ? ZXDH_MSG_CHAN_END_PF : ZXDH_MSG_CHAN_END_VF,
@@ -1166,15 +1162,6 @@ zxdh_send_msg_to_riscv(struct rte_eth_dev *dev, void *msg_req,
         PMD_MSG_LOG(ERR, "Failed to send sync messages or receive response");
         return -1;
     }
-    if (reply_head->flag != ZXDH_MSG_REPS_OK) {
-        PMD_MSG_LOG(ERR, "vf[%d] get pf reply failed: reply_head flag : 0x%x(0xff is OK).replylen %d",
-                hw->vport.vfid, reply_head->flag, reply_head->reps_len);
-        return -1;
-    }
-    if (reply_body->flag != ZXDH_REPS_SUCC) {
-        PMD_MSG_LOG(ERR, "vf[%d] msg processing failed", hw->vfid);
-        return -1;
-    }
 
     return 0;
 }
@@ -2043,7 +2030,8 @@ zxdh_vf_mtr_hw_profile_cfg(struct zxdh_hw *pf_hw __rte_unused,
         (struct zxdh_plcr_profile_cfg *)cfg_data;
     union zxdh_offload_profile_cfg *plcr_param = &zxdh_plcr_profile_cfg->plcr_param;
 
-    ret = zxdh_np_car_profile_cfg_set(vport,
+    ret = zxdh_np_car_profile_cfg_set(pf_hw->dev_id,
+        vport,
         zxdh_plcr_profile_cfg->car_type,
         zxdh_plcr_profile_cfg->packet_mode,
         zxdh_plcr_profile_cfg->hw_profile_id,
diff --git a/drivers/net/zxdh/zxdh_msg.h b/drivers/net/zxdh/zxdh_msg.h
index 58836bb4b7..ffe2c9472f 100644
--- a/drivers/net/zxdh/zxdh_msg.h
+++ b/drivers/net/zxdh/zxdh_msg.h
@@ -384,9 +384,9 @@ struct zxdh_mtr_profile_info {
 };
 
 struct zxdh_msg_reply_body {
-    enum zxdh_reps_flag flag;
+    uint8_t flag;
     union {
-        uint8_t reply_data[ZXDH_MSG_REPLY_BODY_MAX_LEN - sizeof(enum zxdh_reps_flag)];
+        uint8_t reply_data[ZXDH_MSG_REPLY_BODY_MAX_LEN - sizeof(uint8_t)];
         struct zxdh_hw_np_stats np_stats;
         struct zxdh_link_info_msg link_msg;
         struct zxdh_rss_reta rss_reta;
@@ -412,12 +412,12 @@ struct zxdh_vf_init_msg {
     uint8_t rss_enable;
 };
 
-struct zxdh_msg_head {
-    enum zxdh_msg_type msg_type;
+struct __rte_packed_begin zxdh_msg_head {
+    uint8_t msg_type;
     uint16_t  vport;
     uint16_t  vf_id;
     uint16_t pcieid;
-};
+} __rte_packed_end;
 
 struct zxdh_port_attr_set_msg {
     uint32_t mode;
@@ -455,7 +455,7 @@ struct zxdh_rss_enable {
 };
 
 struct zxdh_agent_msg_head {
-    enum zxdh_agent_msg_type msg_type;
+    uint8_t msg_type;
     uint8_t panel_id;
     uint8_t phyport;
     uint8_t rsv;
diff --git a/drivers/net/zxdh/zxdh_mtr.c b/drivers/net/zxdh/zxdh_mtr.c
index 3797a5b29b..809456d73f 100644
--- a/drivers/net/zxdh/zxdh_mtr.c
+++ b/drivers/net/zxdh/zxdh_mtr.c
@@ -281,7 +281,7 @@ zxdh_hw_profile_free_direct(struct rte_eth_dev *dev, ZXDH_PROFILE_TYPE car_type,
 {
     struct zxdh_hw *hw = dev->data->dev_private;
     uint16_t vport = hw->vport.vport;
-    int ret = zxdh_np_car_profile_id_delete(vport, car_type,
+    int ret = zxdh_np_car_profile_id_delete(hw->dev_id, vport, car_type,
             (uint64_t)hw_profile_id);
     if (ret) {
         PMD_DRV_LOG(ERR, "port %u free hw profile %u failed", vport, hw_profile_id);
@@ -299,7 +299,7 @@ zxdh_hw_profile_alloc_direct(struct rte_eth_dev *dev, ZXDH_PROFILE_TYPE car_type
     uint64_t profile_id = HW_PROFILE_MAX;
     struct zxdh_hw *hw = dev->data->dev_private;
     uint16_t vport = hw->vport.vport;
-    int ret = zxdh_np_car_profile_id_add(vport, car_type, &profile_id);
+    int ret = zxdh_np_car_profile_id_add(hw->dev_id, vport, car_type, &profile_id);
 
     if (ret) {
         PMD_DRV_LOG(ERR, "port %u alloc hw profile failed", vport);
@@ -551,7 +551,9 @@ zxdh_hw_profile_config_direct(struct rte_eth_dev *dev __rte_unused,
     struct zxdh_meter_profile *mp,
     struct rte_mtr_error *error)
 {
-    int ret = zxdh_np_car_profile_cfg_set(mp->hw_profile_owner_vport,
+    struct zxdh_hw *hw = dev->data->dev_private;
+    int ret = zxdh_np_car_profile_cfg_set(hw->dev_id,
+        mp->hw_profile_owner_vport,
         car_type, mp->profile.packet_mode,
         (uint32_t)hw_profile_id, &mp->plcr_param);
     if (ret) {
diff --git a/drivers/net/zxdh/zxdh_np.c b/drivers/net/zxdh/zxdh_np.c
index ab8b3ae688..640c835b8e 100644
--- a/drivers/net/zxdh/zxdh_np.c
+++ b/drivers/net/zxdh/zxdh_np.c
@@ -2350,6 +2350,8 @@ zxdh_np_dev_add(uint32_t  dev_id, ZXDH_DEV_TYPE_E dev_type,
 
     rte_spinlock_init(&p_dev_info->dtb_spinlock.spinlock);
 
+    rte_spinlock_init(&p_dev_info->smmu0_spinlock.spinlock);
+
     for (i = 0; i < ZXDH_DTB_QUEUE_NUM_MAX; i++)
         rte_spinlock_init(&p_dev_info->dtb_queue_spinlock[i].spinlock);
 
@@ -3391,6 +3393,32 @@ zxdh_np_reg_read(uint32_t dev_id, uint32_t reg_no,
     return rc;
 }
 
+static uint32_t
+zxdh_np_reg_read32(uint32_t dev_id, uint32_t reg_no,
+    uint32_t m_offset, uint32_t n_offset, uint32_t *p_data)
+{
+    uint32_t rc = 0;
+    uint32_t addr = 0;
+    ZXDH_REG_T *p_reg_info = &g_dpp_reg_info[reg_no];
+    uint32_t p_buff[ZXDH_REG_DATA_MAX] = {0};
+    uint32_t reg_real_no = p_reg_info->reg_no;
+    uint32_t reg_type = p_reg_info->flags;
+    uint32_t reg_module = p_reg_info->module_no;
+
+    addr = zxdh_np_reg_get_reg_addr(reg_no, m_offset, n_offset);
+
+    if (reg_module == DTB4K) {
+        rc = p_reg_info->p_read_fun(dev_id, addr, p_data);
+        ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "p_reg_info->p_read_fun");
+    } else {
+        rc = zxdh_np_agent_channel_reg_read(dev_id, reg_type, reg_real_no, 4, addr, p_buff);
+        ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_agent_channel_reg_read");
+        *p_data = p_buff[0];
+    }
+
+    return rc;
+}
+
 static uint32_t
 zxdh_np_dtb_queue_vm_info_get(uint32_t dev_id,
         uint32_t queue_id,
@@ -10542,9 +10570,9 @@ zxdh_np_se_done_status_check(uint32_t dev_id, uint32_t reg_no, uint32_t pos)
     uint32_t done_flag = 0;
 
     while (!done_flag) {
-        rc = zxdh_np_reg_read(dev_id, reg_no, 0, 0, &data);
+        rc = zxdh_np_reg_read32(dev_id, reg_no, 0, 0, &data);
         if (rc != 0) {
-            PMD_DRV_LOG(ERR, "reg_read fail!");
+            PMD_DRV_LOG(ERR, "reg_read32 fail!");
             return rc;
         }
 
@@ -10577,10 +10605,17 @@ zxdh_np_se_smmu0_ind_read(uint32_t dev_id,
     uint32_t temp_data[4] = {0};
     uint32_t *p_temp_data = NULL;
     ZXDH_SMMU0_SMMU0_CPU_IND_CMD_T cpu_ind_cmd = {0};
+    ZXDH_SPINLOCK_T *p_ind_spinlock = NULL;
+
+    rc = zxdh_np_dev_opr_spinlock_get(dev_id, ZXDH_DEV_SPINLOCK_T_SMMU0, &p_ind_spinlock);
+    ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dev_opr_spinlock_get");
+
+    rte_spinlock_lock(&p_ind_spinlock->spinlock);
 
     rc = zxdh_np_se_done_status_check(dev_id, ZXDH_SMMU0_SMMU0_WR_ARB_CPU_RDYR, 0);
     if (rc != ZXDH_OK) {
         PMD_DRV_LOG(ERR, "se done status check failed, rc=0x%x.", rc);
+        rte_spinlock_unlock(&p_ind_spinlock->spinlock);
         return ZXDH_ERR;
     }
 
@@ -10592,11 +10627,13 @@ zxdh_np_se_smmu0_ind_read(uint32_t dev_id,
         switch (rd_mode) {
         case ZXDH_ERAM128_OPR_128b:
             if ((0xFFFFFFFF - (base_addr)) < (index)) {
+                rte_spinlock_unlock(&p_ind_spinlock->spinlock);
                 PMD_DRV_LOG(ERR, "index 0x%x is invalid!", index);
                 return ZXDH_PAR_CHK_INVALID_INDEX;
             }
             if (base_addr + index > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
                 PMD_DRV_LOG(ERR, "index out of range!");
+                rte_spinlock_unlock(&p_ind_spinlock->spinlock);
                 return ZXDH_ERR;
             }
             row_index = (index << 7) & ZXDH_ERAM128_BADDR_MASK;
@@ -10604,6 +10641,7 @@ zxdh_np_se_smmu0_ind_read(uint32_t dev_id,
         case ZXDH_ERAM128_OPR_64b:
             if ((base_addr + (index >> 1)) > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
                 PMD_DRV_LOG(ERR, "index out of range!");
+                rte_spinlock_unlock(&p_ind_spinlock->spinlock);
                 return ZXDH_ERR;
             }
             row_index = (index << 6) & ZXDH_ERAM128_BADDR_MASK;
@@ -10612,6 +10650,7 @@ zxdh_np_se_smmu0_ind_read(uint32_t dev_id,
         case ZXDH_ERAM128_OPR_32b:
             if ((base_addr + (index >> 2)) > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
                 PMD_DRV_LOG(ERR, "index out of range!");
+                rte_spinlock_unlock(&p_ind_spinlock->spinlock);
                 return ZXDH_ERR;
             }
             row_index = (index << 5) & ZXDH_ERAM128_BADDR_MASK;
@@ -10620,6 +10659,7 @@ zxdh_np_se_smmu0_ind_read(uint32_t dev_id,
         case ZXDH_ERAM128_OPR_1b:
             if ((base_addr + (index >> 7)) > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
                 PMD_DRV_LOG(ERR, "index out of range!");
+                rte_spinlock_unlock(&p_ind_spinlock->spinlock);
                 return ZXDH_ERR;
             }
             row_index = index & ZXDH_ERAM128_BADDR_MASK;
@@ -10638,10 +10678,12 @@ zxdh_np_se_smmu0_ind_read(uint32_t dev_id,
         case ZXDH_ERAM128_OPR_128b:
             if ((0xFFFFFFFF - (base_addr)) < (index)) {
                 PMD_DRV_LOG(ERR, "index 0x%x is invalid!", index);
+                rte_spinlock_unlock(&p_ind_spinlock->spinlock);
                 return ZXDH_PAR_CHK_INVALID_INDEX;
             }
             if (base_addr + index > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
                 PMD_DRV_LOG(ERR, "index out of range!");
+                rte_spinlock_unlock(&p_ind_spinlock->spinlock);
                 return ZXDH_ERR;
             }
             row_index = (index << 7);
@@ -10650,6 +10692,7 @@ zxdh_np_se_smmu0_ind_read(uint32_t dev_id,
         case ZXDH_ERAM128_OPR_64b:
             if ((base_addr + (index >> 1)) > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
                 PMD_DRV_LOG(ERR, "index out of range!");
+                rte_spinlock_unlock(&p_ind_spinlock->spinlock);
                 return ZXDH_ERR;
             }
             row_index = (index << 6);
@@ -10658,6 +10701,7 @@ zxdh_np_se_smmu0_ind_read(uint32_t dev_id,
         case ZXDH_ERAM128_OPR_32b:
             if ((base_addr + (index >> 2)) > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) {
                 PMD_DRV_LOG(ERR, "index out of range!");
+                rte_spinlock_unlock(&p_ind_spinlock->spinlock);
                 return ZXDH_ERR;
             }
             row_index = (index << 5);
@@ -10665,7 +10709,8 @@ zxdh_np_se_smmu0_ind_read(uint32_t dev_id,
             break;
         case ZXDH_ERAM128_OPR_1b:
             PMD_DRV_LOG(ERR, "rd_clr_mode[%u] or rd_mode[%u] error!",
-            rd_clr_mode, rd_mode);
+                rd_clr_mode, rd_mode);
+            rte_spinlock_unlock(&p_ind_spinlock->spinlock);
             return ZXDH_ERR;
         default:
             break;
@@ -10680,12 +10725,14 @@ zxdh_np_se_smmu0_ind_read(uint32_t dev_id,
             &cpu_ind_cmd);
     if (rc != ZXDH_OK) {
         PMD_DRV_LOG(ERR, "zxdh_np_reg_write failed, rc=0x%x.", rc);
+        rte_spinlock_unlock(&p_ind_spinlock->spinlock);
         return ZXDH_ERR;
     }
 
     rc = zxdh_np_se_done_status_check(dev_id, ZXDH_SMMU0_SMMU0_CPU_IND_RD_DONER, 0);
     if (rc != ZXDH_OK) {
         PMD_DRV_LOG(ERR, "se done status check failed, rc=0x%x.", rc);
+        rte_spinlock_unlock(&p_ind_spinlock->spinlock);
         return ZXDH_ERR;
     }
 
@@ -10698,6 +10745,7 @@ zxdh_np_se_smmu0_ind_read(uint32_t dev_id,
             p_temp_data + 3 - i);
         if (rc != ZXDH_OK) {
             PMD_DRV_LOG(ERR, "zxdh_np_reg_write failed, rc=0x%x.", rc);
+            rte_spinlock_unlock(&p_ind_spinlock->spinlock);
             return ZXDH_ERR;
         }
     }
@@ -10736,6 +10784,8 @@ zxdh_np_se_smmu0_ind_read(uint32_t dev_id,
         }
     }
 
+    rte_spinlock_unlock(&p_ind_spinlock->spinlock);
+
     return rc;
 }
 
@@ -11012,7 +11062,8 @@ zxdh_np_stat_carc_queue_cfg_set(uint32_t dev_id,
 }
 
 uint32_t
-zxdh_np_car_profile_id_add(uint32_t vport_id,
+zxdh_np_car_profile_id_add(uint32_t dev_id,
+        uint32_t vport_id,
         uint32_t flags,
         uint64_t *p_profile_id)
 {
@@ -11027,7 +11078,7 @@ zxdh_np_car_profile_id_add(uint32_t vport_id,
         PMD_DRV_LOG(ERR, "profile_id point null!");
         return ZXDH_PAR_CHK_POINT_NULL;
     }
-    ret = zxdh_np_agent_channel_plcr_profileid_request(0, vport_id, flags, profile_id);
+    ret = zxdh_np_agent_channel_plcr_profileid_request(dev_id, vport_id, flags, profile_id);
 
     profile_id_h = *(profile_id + 1);
     profile_id_l = *profile_id;
@@ -11045,14 +11096,14 @@ zxdh_np_car_profile_id_add(uint32_t vport_id,
 }
 
 uint32_t
-zxdh_np_car_profile_cfg_set(uint32_t vport_id __rte_unused,
+zxdh_np_car_profile_cfg_set(uint32_t dev_id,
+        uint32_t vport_id __rte_unused,
         uint32_t car_type,
         uint32_t pkt_sign,
         uint32_t profile_id,
         void *p_car_profile_cfg)
 {
     uint32_t ret = 0;
-    uint32_t dev_id = 0;
 
     ret = zxdh_np_agent_channel_plcr_car_rate(dev_id, car_type,
         pkt_sign, profile_id, p_car_profile_cfg);
@@ -11065,11 +11116,10 @@ zxdh_np_car_profile_cfg_set(uint32_t vport_id __rte_unused,
 }
 
 uint32_t
-zxdh_np_car_profile_id_delete(uint32_t vport_id,
+zxdh_np_car_profile_id_delete(uint32_t dev_id, uint32_t vport_id,
     uint32_t flags, uint64_t profile_id)
 {
     uint32_t ret = 0;
-    uint32_t dev_id = 0;
     uint32_t profileid = profile_id & 0xFFFF;
 
     ret = zxdh_np_agent_channel_plcr_profileid_release(dev_id, vport_id, flags, profileid);
diff --git a/drivers/net/zxdh/zxdh_np.h b/drivers/net/zxdh/zxdh_np.h
index b1d8b1aef8..1b8f17474d 100644
--- a/drivers/net/zxdh/zxdh_np.h
+++ b/drivers/net/zxdh/zxdh_np.h
@@ -1934,15 +1934,17 @@ uint32_t zxdh_np_stat_ppu_cnt_get_ex(uint32_t dev_id,
             uint32_t clr_mode,
             uint32_t *p_data);
 uint32_t
-zxdh_np_car_profile_id_add(uint32_t vport_id,
+zxdh_np_car_profile_id_add(uint32_t dev_id,
+            uint32_t vport_id,
             uint32_t flags,
             uint64_t *p_profile_id);
-uint32_t zxdh_np_car_profile_cfg_set(uint32_t vport_id,
+uint32_t zxdh_np_car_profile_cfg_set(uint32_t dev_id,
+            uint32_t vport_id,
             uint32_t car_type,
             uint32_t pkt_sign,
             uint32_t profile_id,
             void *p_car_profile_cfg);
-uint32_t zxdh_np_car_profile_id_delete(uint32_t vport_id,
+uint32_t zxdh_np_car_profile_id_delete(uint32_t dev_id, uint32_t vport_id,
             uint32_t flags, uint64_t profile_id);
 uint32_t zxdh_np_stat_car_queue_cfg_set(uint32_t dev_id,
             uint32_t car_type,
diff --git a/drivers/net/zxdh/zxdh_pci.c b/drivers/net/zxdh/zxdh_pci.c
index 3d1a3ff0dd..4ff0f065df 100644
--- a/drivers/net/zxdh/zxdh_pci.c
+++ b/drivers/net/zxdh/zxdh_pci.c
@@ -27,6 +27,23 @@
         1ULL << ZXDH_F_NOTIFICATION_DATA | \
         1ULL << ZXDH_NET_F_MAC)
 
+#define ZXDH_PMD_DEFAULT_HOST_FEATURES   \
+    (1ULL << ZXDH_NET_F_MRG_RXBUF | \
+     1ULL << ZXDH_NET_F_STATUS    | \
+     1ULL << ZXDH_NET_F_MQ        | \
+     1ULL << ZXDH_F_ANY_LAYOUT    | \
+     1ULL << ZXDH_F_VERSION_1   | \
+     1ULL << ZXDH_F_RING_PACKED | \
+     1ULL << ZXDH_F_IN_ORDER    | \
+     1ULL << ZXDH_F_NOTIFICATION_DATA |\
+     1ULL << ZXDH_NET_F_MAC | \
+     1ULL << ZXDH_NET_F_CSUM |\
+     1ULL << ZXDH_NET_F_GUEST_CSUM |\
+     1ULL << ZXDH_NET_F_GUEST_TSO4 |\
+     1ULL << ZXDH_NET_F_GUEST_TSO6 |\
+     1ULL << ZXDH_NET_F_HOST_TSO4 |\
+     1ULL << ZXDH_NET_F_HOST_TSO6)
+
 static void
 zxdh_read_dev_config(struct zxdh_hw *hw, size_t offset,
         void *dst, int32_t length)
@@ -391,13 +408,18 @@ zxdh_pci_read_dev_config(struct zxdh_hw *hw, size_t offset, void *dst, int32_t l
     ZXDH_VTPCI_OPS(hw)->read_dev_cfg(hw, offset, dst, length);
 }
 
+void zxdh_pci_write_dev_config(struct zxdh_hw *hw, size_t offset, const void *src, int32_t length)
+{
+    ZXDH_VTPCI_OPS(hw)->write_dev_cfg(hw, offset, src, length);
+}
+
 void
 zxdh_get_pci_dev_config(struct zxdh_hw *hw)
 {
     uint64_t guest_features = 0;
     uint64_t nego_features = 0;
 
-    hw->host_features = zxdh_pci_get_features(hw);
+    hw->host_features = ZXDH_PMD_DEFAULT_HOST_FEATURES;
 
     guest_features = (uint64_t)ZXDH_PMD_DEFAULT_GUEST_FEATURES;
     nego_features = guest_features & hw->host_features;
diff --git a/drivers/net/zxdh/zxdh_pci.h b/drivers/net/zxdh/zxdh_pci.h
index 9b8bef6c09..a1834f6615 100644
--- a/drivers/net/zxdh/zxdh_pci.h
+++ b/drivers/net/zxdh/zxdh_pci.h
@@ -162,7 +162,7 @@ void zxdh_pci_read_dev_config(struct zxdh_hw *hw, size_t offset,
 
 int32_t zxdh_read_pci_caps(struct rte_pci_device *dev, struct zxdh_hw *hw);
 void zxdh_get_pci_dev_config(struct zxdh_hw *hw);
-
+void zxdh_pci_write_dev_config(struct zxdh_hw *hw, size_t offset, const void *src, int32_t length);
 uint16_t zxdh_pci_get_features(struct zxdh_hw *hw);
 enum zxdh_msix_status zxdh_pci_msix_detect(struct rte_pci_device *dev);
 uint8_t zxdh_pci_isr(struct zxdh_hw *hw);
diff --git a/drivers/net/zxdh/zxdh_rxtx.c b/drivers/net/zxdh/zxdh_rxtx.c
index 1921a23f25..4c79b9e75b 100644
--- a/drivers/net/zxdh/zxdh_rxtx.c
+++ b/drivers/net/zxdh/zxdh_rxtx.c
@@ -818,9 +818,14 @@ zxdh_recv_pkts_packed(void *rx_queue, struct rte_mbuf **rx_pkts,
         seg_num  = header->type_hdr.num_buffers;
 
         /* Private queue only handle type hdr */
-        hdr_size = ZXDH_TYPE_HDR_SIZE;
-        rxm->pkt_len = ((header->type_hdr.port & 0x7f) << 8) +
-                            header->type_hdr.pd_len;
+        hdr_size = header->type_hdr.pd_len << 1;
+        if (unlikely(hdr_size > lens[i] || hdr_size < ZXDH_TYPE_HDR_SIZE)) {
+            PMD_RX_LOG(ERR, "hdr_size:%u is invalid", hdr_size);
+            rte_pktmbuf_free(rxm);
+            rxvq->stats.errors++;
+            rxvq->stats.invalid_hdr_len_err++;
+            continue;
+        }
         rxm->data_off += hdr_size;
         rxm->nb_segs = seg_num;
         rxm->ol_flags = 0;
diff --git a/drivers/net/zxdh/zxdh_tables.c b/drivers/net/zxdh/zxdh_tables.c
index 253d9ce438..ab91d51948 100644
--- a/drivers/net/zxdh/zxdh_tables.c
+++ b/drivers/net/zxdh/zxdh_tables.c
@@ -8,14 +8,7 @@
 #include "zxdh_tables.h"
 #include "zxdh_logs.h"
 
-#define ZXDH_SDT_VPORT_ATT_TABLE          1
-#define ZXDH_SDT_PANEL_ATT_TABLE          2
-#define ZXDH_SDT_RSS_ATT_TABLE            3
-#define ZXDH_SDT_VLAN_ATT_TABLE           4
-#define ZXDH_SDT_BROCAST_ATT_TABLE        6
-#define ZXDH_SDT_UNICAST_ATT_TABLE        10
-#define ZXDH_SDT_MULTICAST_ATT_TABLE      11
-#define ZXDH_SDT_PORT_VLAN_ATT_TABLE      16
+
 
 #define ZXDH_MAC_HASH_INDEX_BASE          64
 #define ZXDH_MAC_HASH_INDEX(index)        (ZXDH_MAC_HASH_INDEX_BASE + (index))
@@ -40,15 +33,16 @@ zxdh_set_port_attr(struct zxdh_hw *hw, uint16_t vport, struct zxdh_port_attr_tab
 {
     struct zxdh_dtb_shared_data *dtb_data = &hw->dev_sd->dtb_sd;
     union zxdh_virport_num vport_num = (union zxdh_virport_num)vport;
+    uint16_t vfid = zxdh_vport_to_vfid(vport_num);
     int ret = 0;
 
-    ZXDH_DTB_ERAM_ENTRY_INFO_T entry = {vport_num.vfid, (uint32_t *)port_attr};
+    ZXDH_DTB_ERAM_ENTRY_INFO_T entry = {vfid, (uint32_t *)port_attr};
     ZXDH_DTB_USER_ENTRY_T user_entry_write = {ZXDH_SDT_VPORT_ATT_TABLE, (void *)&entry};
 
     ret = zxdh_np_dtb_table_entry_write(hw->slot_id,
                 dtb_data->queueid, 1, &user_entry_write);
     if (ret != 0)
-        PMD_DRV_LOG(ERR, "write vport_att failed vfid:%d failed", vport_num.vfid);
+        PMD_DRV_LOG(ERR, "write vport_att failed vfid:%d failed", vfid);
 
     return ret;
 }
@@ -72,6 +66,7 @@ zxdh_port_attr_init(struct rte_eth_dev *dev)
         port_attr.mtu = dev->data->mtu;
         port_attr.mtu_enable = 1;
         port_attr.is_up = 0;
+        port_attr.hash_search_index = hw->hash_search_index;
         if (!port_attr.rss_enable)
             port_attr.port_base_qid = 0;
 
@@ -144,6 +139,7 @@ int zxdh_panel_table_init(struct rte_eth_dev *dev)
     panel.pf_vfid = zxdh_vport_to_vfid(hw->vport);
     panel.mtu_enable = 1;
     panel.mtu = dev->data->mtu;
+    panel.port_vfid_1588 = panel.pf_vfid;
 
     ZXDH_DTB_ERAM_ENTRY_INFO_T panel_entry = {
         .index = hw->phyport,
@@ -212,13 +208,14 @@ zxdh_get_port_attr(struct zxdh_hw *hw, uint16_t vport, struct zxdh_port_attr_tab
 {
     struct zxdh_dtb_shared_data *dtb_data = &hw->dev_sd->dtb_sd;
     union zxdh_virport_num vport_num = (union zxdh_virport_num)vport;
-    ZXDH_DTB_ERAM_ENTRY_INFO_T entry = {vport_num.vfid, (uint32_t *)port_attr};
+    uint16_t vfid = zxdh_vport_to_vfid(vport_num);
+    ZXDH_DTB_ERAM_ENTRY_INFO_T entry = {vfid, (uint32_t *)port_attr};
     ZXDH_DTB_USER_ENTRY_T user_entry_get = {ZXDH_SDT_VPORT_ATT_TABLE, &entry};
     int ret;
 
     ret = zxdh_np_dtb_table_entry_get(hw->slot_id, dtb_data->queueid, &user_entry_get, 1);
     if (ret != 0)
-        PMD_DRV_LOG(ERR, "get port_attr vfid:%d failed, ret:%d", vport_num.vfid, ret);
+        PMD_DRV_LOG(ERR, "get port_attr vfid:%d failed, ret:%d", vfid, ret);
 
     return ret;
 }
@@ -229,7 +226,8 @@ zxdh_delete_port_attr(struct zxdh_hw *hw, uint16_t vport,
 {
     struct zxdh_dtb_shared_data *dtb_data = &hw->dev_sd->dtb_sd;
     union zxdh_virport_num vport_num = (union zxdh_virport_num)vport;
-    ZXDH_DTB_ERAM_ENTRY_INFO_T entry = {vport_num.vfid, (uint32_t *)port_attr};
+    uint16_t vfid = zxdh_vport_to_vfid(vport_num);
+    ZXDH_DTB_ERAM_ENTRY_INFO_T entry = {vfid, (uint32_t *)port_attr};
     ZXDH_DTB_USER_ENTRY_T user_entry = {
         .sdt_no = ZXDH_SDT_VPORT_ATT_TABLE,
         .p_entry_data = (void *)&entry
@@ -247,9 +245,9 @@ zxdh_add_mac_table(struct zxdh_hw *hw, uint16_t vport, struct rte_ether_addr *ad
     struct zxdh_mac_unicast_table unicast_table = {0};
     struct zxdh_mac_multicast_table multicast_table = {0};
     union zxdh_virport_num vport_num = (union zxdh_virport_num)vport;
+    uint16_t vfid = zxdh_vport_to_vfid(vport_num);
     uint32_t ret;
     uint16_t group_id = 0;
-    uint16_t vfid = vport_num.vfid;
 
     if (rte_is_unicast_ether_addr(addr)) {
         rte_memcpy(unicast_table.key.dmac_addr, addr, sizeof(struct rte_ether_addr));
@@ -351,15 +349,17 @@ zxdh_del_mac_table(struct zxdh_hw *hw, uint16_t vport, struct rte_ether_addr *ad
     struct zxdh_mac_unicast_table unicast_table = {0};
     struct zxdh_mac_multicast_table multicast_table = {0};
     union zxdh_virport_num vport_num = (union zxdh_virport_num)vport;
-    uint32_t ret, del_flag = 0;
-    uint16_t group_id = 0;
     union zxdh_virport_num port = (union zxdh_virport_num)vport;
     uint16_t vfid = zxdh_vport_to_vfid(port);
+    uint32_t ret, del_flag = 0;
+    uint16_t group_id = 0;
 
     if (rte_is_unicast_ether_addr(addr)) {
         rte_memcpy(unicast_table.key.dmac_addr, addr, sizeof(struct rte_ether_addr));
         unicast_table.key.sriov_vlan_id = srv_vlanid;
         unicast_table.key.sriov_vlan_tpid = srv_tpid;
+        unicast_table.entry.hit_flag = 0;
+        unicast_table.entry.vfid = rte_cpu_to_be_16(vfid & 0x7ff);
 
         ZXDH_DTB_HASH_ENTRY_INFO_T dtb_hash_entry = {
             .p_actu_key = (uint8_t *)&unicast_table.key,
@@ -800,6 +800,7 @@ zxdh_rss_table_set(struct zxdh_hw *hw, uint16_t vport, struct zxdh_rss_reta *rss
     struct zxdh_dtb_shared_data *dtb_data = &hw->dev_sd->dtb_sd;
     struct zxdh_rss_to_vqid_table rss_vqid = {0};
     union zxdh_virport_num vport_num = (union zxdh_virport_num)vport;
+    uint16_t vfid = zxdh_vport_to_vfid(vport_num);
     int ret = 0;
 
     for (uint16_t i = 0; i < RTE_ETH_RSS_RETA_SIZE_256 / 8; i++) {
@@ -820,7 +821,7 @@ zxdh_rss_table_set(struct zxdh_hw *hw, uint16_t vport, struct zxdh_rss_reta *rss
             rss_vqid.vqm_qid[0] |= 0x8000;
 #endif
         ZXDH_DTB_ERAM_ENTRY_INFO_T entry = {
-            .index = vport_num.vfid * 32 + i,
+            .index = vfid * 32 + i,
             .p_data = (uint32_t *)&rss_vqid
         };
         ZXDH_DTB_USER_ENTRY_T user_entry_write = {
@@ -830,7 +831,7 @@ zxdh_rss_table_set(struct zxdh_hw *hw, uint16_t vport, struct zxdh_rss_reta *rss
         ret = zxdh_np_dtb_table_entry_write(hw->slot_id,
                     dtb_data->queueid, 1, &user_entry_write);
         if (ret != 0) {
-            PMD_DRV_LOG(ERR, "write rss base qid failed vfid:%d", vport_num.vfid);
+            PMD_DRV_LOG(ERR, "write rss base qid failed vfid:%d", vfid);
             return ret;
         }
     }
@@ -843,16 +844,17 @@ zxdh_rss_table_get(struct zxdh_hw *hw, uint16_t vport, struct zxdh_rss_reta *rss
     struct zxdh_dtb_shared_data *dtb_data = &hw->dev_sd->dtb_sd;
     struct zxdh_rss_to_vqid_table rss_vqid = {0};
     union zxdh_virport_num vport_num = (union zxdh_virport_num)vport;
+    uint16_t vfid = zxdh_vport_to_vfid(vport_num);
     int ret = 0;
 
     for (uint16_t i = 0; i < RTE_ETH_RSS_RETA_SIZE_256 / 8; i++) {
-        ZXDH_DTB_ERAM_ENTRY_INFO_T entry = {vport_num.vfid * 32 + i, (uint32_t *)&rss_vqid};
+        ZXDH_DTB_ERAM_ENTRY_INFO_T entry = {vfid * 32 + i, (uint32_t *)&rss_vqid};
         ZXDH_DTB_USER_ENTRY_T user_entry = {ZXDH_SDT_RSS_ATT_TABLE, &entry};
 
         ret = zxdh_np_dtb_table_entry_get(hw->slot_id,
                     dtb_data->queueid, &user_entry, 1);
         if (ret != 0) {
-            PMD_DRV_LOG(ERR, "get rss tbl failed, vfid:%d", vport_num.vfid);
+            PMD_DRV_LOG(ERR, "get rss tbl failed, vfid:%d", vfid);
             return -1;
         }
 
diff --git a/drivers/net/zxdh/zxdh_tables.h b/drivers/net/zxdh/zxdh_tables.h
index 2f2ada3a9f..cb34e38be8 100644
--- a/drivers/net/zxdh/zxdh_tables.h
+++ b/drivers/net/zxdh/zxdh_tables.h
@@ -9,7 +9,13 @@
 
 /* eram */
 #define ZXDH_SDT_VPORT_ATT_TABLE          1
-
+#define ZXDH_SDT_PANEL_ATT_TABLE          2
+#define ZXDH_SDT_RSS_ATT_TABLE            3
+#define ZXDH_SDT_VLAN_ATT_TABLE           4
+#define ZXDH_SDT_BROCAST_ATT_TABLE        6
+#define ZXDH_SDT_UNICAST_ATT_TABLE        10
+#define ZXDH_SDT_MULTICAST_ATT_TABLE      11
+#define ZXDH_SDT_PORT_VLAN_ATT_TABLE      16
 /* hash */
 #define ZXDH_SDT_L2_ENTRY_TABLE0          64
 #define ZXDH_SDT_L2_ENTRY_TABLE1          65
@@ -80,8 +86,6 @@
 #define ZXDH_MTR_STATS_EGRESS_BASE           0x7481
 #define ZXDH_MTR_STATS_INGRESS_BASE          0x7C81
 
-extern struct zxdh_dtb_shared_data g_dtb_data;
-
 struct zxdh_port_vlan_table {
 #if RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN
     uint16_t business_vlan_tpid:16;
@@ -233,19 +237,51 @@ struct zxdh_port_attr_table {
 };
 
 struct zxdh_panel_table {
-    uint16_t port_vfid_1588 : 11,
-             rsv2           : 5;
-    uint16_t pf_vfid        : 11,
-             rsv1           : 1,
-             enable_1588_tc : 2,
-             trust_mode     : 1,
-             hit_flag       : 1;
-    uint32_t mtu            : 16,
-             mtu_enable     : 1,
-             rsv            : 3,
-             tm_base_queue  : 12;
-    uint32_t rsv_1;
-    uint32_t rsv_2;
+#if RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN
+    uint16_t port_vfid_1588   : 11,
+                rsv2             : 5;
+    uint16_t rsv1             : 11,
+             tm_shape_enable  : 1,
+             enable_1588_tc   : 2,
+             trust_mode       : 1,
+             hit_flag         : 1;
+    uint16_t mtu              : 16;
+    uint16_t mtu_enable       : 1,
+             rsv              : 3,
+             tm_base_queue    : 12;
+    uint16_t lacp_pf_qid      : 12,
+                rsv5             : 4;
+    uint16_t lacp_pf_vfid     : 11,
+                rsv6             : 2,
+                member_port_up   : 1,
+                bond_link_up     : 1,
+                hw_bond_enable   : 1;
+    uint16_t rsv3             : 16;
+    uint16_t pf_vfid          : 11,
+                rsv4             : 5;
+#else
+    uint16_t rsv1             : 11,
+                tm_shape_enable  : 1,
+                enable_1588_tc   : 2,
+                trust_mode       : 1,
+                hit_flag         : 1;
+    uint16_t port_vfid_1588   : 11,
+                rsv2             : 5;
+    uint16_t mtu_enable       : 1,
+                rsv              : 3,
+                tm_base_queue    : 12;
+    uint16_t mtu              : 16;
+    uint16_t lacp_pf_vfid     : 11,
+                rsv6             : 2,
+                member_port_up   : 1,
+                bond_link_up     : 1,
+                hw_bond_enable   : 1;
+    uint16_t lacp_pf_qid      : 12,
+                rsv5             : 4;
+    uint16_t pf_vfid          : 11,
+                rsv4             : 5;
+    uint16_t rsv3             : 16;
+#endif
 }; /* 16B */
 
 struct zxdh_mac_unicast_key {
-- 
2.27.0