optimize basic stats ops. Signed-off-by: Junlong Wang <wang.junlong1@zte.com.cn> --- drivers/net/zxdh/zxdh_ethdev.c | 1 + drivers/net/zxdh/zxdh_ethdev.h | 1 + drivers/net/zxdh/zxdh_ethdev_ops.c | 241 +++++++++++++++++++++++--- drivers/net/zxdh/zxdh_ethdev_ops.h | 43 +++-- drivers/net/zxdh/zxdh_msg.c | 143 ++++++++++++++++ drivers/net/zxdh/zxdh_msg.h | 5 + drivers/net/zxdh/zxdh_np.c | 263 +++++++++++++++++++++++++++++ drivers/net/zxdh/zxdh_np.h | 40 +++++ drivers/net/zxdh/zxdh_tables.h | 16 +- 9 files changed, 711 insertions(+), 42 deletions(-) diff --git a/drivers/net/zxdh/zxdh_ethdev.c b/drivers/net/zxdh/zxdh_ethdev.c index 731e1629b4..e170da7d07 100644 --- a/drivers/net/zxdh/zxdh_ethdev.c +++ b/drivers/net/zxdh/zxdh_ethdev.c @@ -1481,6 +1481,7 @@ static int zxdh_init_dev_share_data(struct rte_eth_dev *eth_dev) return -EINVAL; hw->slot_id = slot_id; + hw->dev_id = (hw->pcie_id << 16) | (hw->slot_id & 0xffff); g_dev_sd[slot_id].serial_id = serial_id; hw->dev_sd = &g_dev_sd[slot_id]; diff --git a/drivers/net/zxdh/zxdh_ethdev.h b/drivers/net/zxdh/zxdh_ethdev.h index be026d5b72..30df1eefe3 100644 --- a/drivers/net/zxdh/zxdh_ethdev.h +++ b/drivers/net/zxdh/zxdh_ethdev.h @@ -127,6 +127,7 @@ struct zxdh_hw { uint8_t rss_enable; uint8_t rss_init; uint16_t slot_id; + uint32_t dev_id; uint8_t queue_set_flag; uint16_t queue_pool_count; diff --git a/drivers/net/zxdh/zxdh_ethdev_ops.c b/drivers/net/zxdh/zxdh_ethdev_ops.c index 5398607c6e..65bd176762 100644 --- a/drivers/net/zxdh/zxdh_ethdev_ops.c +++ b/drivers/net/zxdh/zxdh_ethdev_ops.c @@ -83,11 +83,6 @@ struct zxdh_hw_mac_bytes { uint64_t tx_good_bytes; }; -struct zxdh_np_stats_data { - uint64_t n_pkts_dropped; - uint64_t n_bytes_dropped; -}; - struct zxdh_xstats_name_off { char name[RTE_ETH_XSTATS_NAME_SIZE]; unsigned int offset; @@ -1305,9 +1300,10 @@ zxdh_hw_vqm_stats_get(struct rte_eth_dev *dev, enum zxdh_agent_msg_type opcode, return 0; } -static int zxdh_hw_mac_stats_get(struct rte_eth_dev *dev, - struct zxdh_hw_mac_stats *mac_stats, - struct zxdh_hw_mac_bytes *mac_bytes) +static int +zxdh_hw_mac_stats_get(struct rte_eth_dev *dev, + struct zxdh_hw_mac_stats *mac_stats, + struct zxdh_hw_mac_bytes *mac_bytes) { struct zxdh_hw *hw = dev->data->dev_private; uint64_t virt_addr = (uint64_t)(hw->bar_addr[ZXDH_BAR0_INDEX] + ZXDH_MAC_OFFSET); @@ -1327,7 +1323,8 @@ static int zxdh_hw_mac_stats_get(struct rte_eth_dev *dev, return 0; } -static void zxdh_data_hi_to_lo(uint64_t *data) +void +zxdh_data_hi_to_lo(uint64_t *data) { uint32_t n_data_hi; uint32_t n_data_lo; @@ -1338,7 +1335,8 @@ static void zxdh_data_hi_to_lo(uint64_t *data) rte_le_to_cpu_32(n_data_lo); } -static int zxdh_np_stats_get(struct rte_eth_dev *dev, struct zxdh_hw_np_stats *np_stats) +static int +zxdh_np_stats_get(struct rte_eth_dev *dev, struct zxdh_hw_np_stats *np_stats) { struct zxdh_hw *hw = dev->data->dev_private; struct zxdh_dtb_shared_data *dtb_data = &hw->dev_sd->dtb_sd; @@ -1348,19 +1346,70 @@ static int zxdh_np_stats_get(struct rte_eth_dev *dev, struct zxdh_hw_np_stats *n int ret = 0; idx = stats_id + ZXDH_BROAD_STATS_EGRESS_BASE; + memset(&stats_data, 0, sizeof(stats_data)); ret = zxdh_np_dtb_stats_get(hw->slot_id, dtb_data->queueid, - 0, idx, (uint32_t *)&np_stats->np_tx_broadcast); + 0, idx, (uint32_t *)&stats_data); if (ret) return ret; - zxdh_data_hi_to_lo(&np_stats->np_tx_broadcast); + np_stats->tx_broadcast_pkts = stats_data.n_pkts_dropped; + np_stats->tx_broadcast_bytes = stats_data.n_bytes_dropped; + zxdh_data_hi_to_lo(&np_stats->tx_broadcast_pkts); + zxdh_data_hi_to_lo(&np_stats->tx_broadcast_bytes); idx = stats_id + ZXDH_BROAD_STATS_INGRESS_BASE; memset(&stats_data, 0, sizeof(stats_data)); ret = zxdh_np_dtb_stats_get(hw->slot_id, dtb_data->queueid, - 0, idx, (uint32_t *)&np_stats->np_rx_broadcast); + 0, idx, (uint32_t *)&stats_data); + if (ret) + return ret; + np_stats->rx_broadcast_pkts = stats_data.n_pkts_dropped; + np_stats->rx_broadcast_bytes = stats_data.n_bytes_dropped; + zxdh_data_hi_to_lo(&np_stats->rx_broadcast_pkts); + zxdh_data_hi_to_lo(&np_stats->rx_broadcast_bytes); + + idx = stats_id + ZXDH_MULTICAST_STATS_EGRESS_BASE; + memset(&stats_data, 0, sizeof(stats_data)); + ret = zxdh_np_dtb_stats_get(hw->slot_id, dtb_data->queueid, + 0, idx, (uint32_t *)&stats_data); + if (ret) + return ret; + np_stats->tx_multicast_pkts = stats_data.n_pkts_dropped; + np_stats->tx_multicast_bytes = stats_data.n_bytes_dropped; + zxdh_data_hi_to_lo(&np_stats->tx_multicast_pkts); + zxdh_data_hi_to_lo(&np_stats->tx_multicast_bytes); + + idx = stats_id + ZXDH_MULTICAST_STATS_INGRESS_BASE; + memset(&stats_data, 0, sizeof(stats_data)); + ret = zxdh_np_dtb_stats_get(hw->slot_id, dtb_data->queueid, + 0, idx, (uint32_t *)&stats_data); + if (ret) + return ret; + np_stats->rx_multicast_pkts = stats_data.n_pkts_dropped; + np_stats->rx_multicast_bytes = stats_data.n_bytes_dropped; + zxdh_data_hi_to_lo(&np_stats->rx_multicast_pkts); + zxdh_data_hi_to_lo(&np_stats->rx_multicast_bytes); + + idx = stats_id + ZXDH_UNICAST_STATS_EGRESS_BASE; + memset(&stats_data, 0, sizeof(stats_data)); + ret = zxdh_np_dtb_stats_get(hw->slot_id, dtb_data->queueid, + 0, idx, (uint32_t *)&stats_data); + if (ret) + return ret; + np_stats->tx_unicast_pkts = stats_data.n_pkts_dropped; + np_stats->tx_unicast_bytes = stats_data.n_bytes_dropped; + zxdh_data_hi_to_lo(&np_stats->tx_unicast_pkts); + zxdh_data_hi_to_lo(&np_stats->tx_unicast_bytes); + + idx = stats_id + ZXDH_UNICAST_STATS_INGRESS_BASE; + memset(&stats_data, 0, sizeof(stats_data)); + ret = zxdh_np_dtb_stats_get(hw->slot_id, dtb_data->queueid, + 0, idx, (uint32_t *)&stats_data); if (ret) return ret; - zxdh_data_hi_to_lo(&np_stats->np_rx_broadcast); + np_stats->rx_unicast_pkts = stats_data.n_pkts_dropped; + np_stats->rx_unicast_bytes = stats_data.n_bytes_dropped; + zxdh_data_hi_to_lo(&np_stats->rx_unicast_pkts); + zxdh_data_hi_to_lo(&np_stats->rx_unicast_bytes); idx = stats_id + ZXDH_MTU_STATS_EGRESS_BASE; memset(&stats_data, 0, sizeof(stats_data)); @@ -1368,11 +1417,10 @@ static int zxdh_np_stats_get(struct rte_eth_dev *dev, struct zxdh_hw_np_stats *n 1, idx, (uint32_t *)&stats_data); if (ret) return ret; - - np_stats->np_tx_mtu_drop_pkts = stats_data.n_pkts_dropped; - np_stats->np_tx_mtu_drop_bytes = stats_data.n_bytes_dropped; - zxdh_data_hi_to_lo(&np_stats->np_tx_mtu_drop_pkts); - zxdh_data_hi_to_lo(&np_stats->np_tx_mtu_drop_bytes); + np_stats->tx_mtu_drop_pkts = stats_data.n_pkts_dropped; + np_stats->tx_mtu_drop_bytes = stats_data.n_bytes_dropped; + zxdh_data_hi_to_lo(&np_stats->tx_mtu_drop_pkts); + zxdh_data_hi_to_lo(&np_stats->tx_mtu_drop_bytes); idx = stats_id + ZXDH_MTU_STATS_INGRESS_BASE; memset(&stats_data, 0, sizeof(stats_data)); @@ -1380,10 +1428,32 @@ static int zxdh_np_stats_get(struct rte_eth_dev *dev, struct zxdh_hw_np_stats *n 1, idx, (uint32_t *)&stats_data); if (ret) return ret; - np_stats->np_rx_mtu_drop_pkts = stats_data.n_pkts_dropped; - np_stats->np_rx_mtu_drop_bytes = stats_data.n_bytes_dropped; - zxdh_data_hi_to_lo(&np_stats->np_rx_mtu_drop_pkts); - zxdh_data_hi_to_lo(&np_stats->np_rx_mtu_drop_bytes); + np_stats->rx_mtu_drop_pkts = stats_data.n_pkts_dropped; + np_stats->rx_mtu_drop_bytes = stats_data.n_bytes_dropped; + zxdh_data_hi_to_lo(&np_stats->rx_mtu_drop_pkts); + zxdh_data_hi_to_lo(&np_stats->rx_mtu_drop_bytes); + + idx = stats_id + ZXDH_MTR_STATS_EGRESS_BASE; + memset(&stats_data, 0, sizeof(stats_data)); + ret = zxdh_np_dtb_stats_get(hw->slot_id, dtb_data->queueid, + 1, idx, (uint32_t *)&stats_data); + if (ret) + return ret; + np_stats->tx_mtr_drop_pkts = stats_data.n_pkts_dropped; + np_stats->tx_mtr_drop_bytes = stats_data.n_bytes_dropped; + zxdh_data_hi_to_lo(&np_stats->tx_mtr_drop_pkts); + zxdh_data_hi_to_lo(&np_stats->tx_mtr_drop_bytes); + + idx = stats_id + ZXDH_MTR_STATS_INGRESS_BASE; + memset(&stats_data, 0, sizeof(stats_data)); + ret = zxdh_np_dtb_stats_get(hw->slot_id, dtb_data->queueid, + 1, idx, (uint32_t *)&stats_data); + if (ret) + return ret; + np_stats->rx_mtr_drop_pkts = stats_data.n_pkts_dropped; + np_stats->rx_mtr_drop_bytes = stats_data.n_bytes_dropped; + zxdh_data_hi_to_lo(&np_stats->rx_mtr_drop_pkts); + zxdh_data_hi_to_lo(&np_stats->rx_mtr_drop_bytes); return 0; } @@ -1408,8 +1478,7 @@ zxdh_hw_np_stats_get(struct rte_eth_dev *dev, struct zxdh_hw_np_stats *np_stats) &reply_info, sizeof(struct zxdh_msg_reply_info)); if (ret) { PMD_DRV_LOG(ERR, - "%s Failed to send msg: port 0x%x msg type", - __func__, hw->vport.vport); + "Failed to send msg: port 0x%x msg type", hw->vport.vport); return -1; } memcpy(np_stats, &reply_info.reply_body.np_stats, sizeof(struct zxdh_hw_np_stats)); @@ -1438,8 +1507,8 @@ zxdh_dev_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats) stats->ibytes = vqm_stats.rx_bytes; stats->obytes = vqm_stats.tx_bytes; stats->imissed = vqm_stats.rx_drop + mac_stats.rx_drop; - stats->ierrors = vqm_stats.rx_error + mac_stats.rx_error + np_stats.np_rx_mtu_drop_pkts; - stats->oerrors = vqm_stats.tx_error + mac_stats.tx_error + np_stats.np_tx_mtu_drop_pkts; + stats->ierrors = vqm_stats.rx_error + mac_stats.rx_error + np_stats.rx_mtu_drop_pkts; + stats->oerrors = vqm_stats.tx_error + mac_stats.tx_error + np_stats.tx_mtu_drop_pkts; stats->rx_nombuf = dev->data->rx_mbuf_alloc_failed; for (i = 0; (i < dev->data->nb_rx_queues) && (i < RTE_ETHDEV_QUEUE_STAT_CNTRS); i++) { @@ -1474,7 +1543,8 @@ zxdh_dev_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats) return 0; } -static int zxdh_hw_stats_reset(struct rte_eth_dev *dev, enum zxdh_agent_msg_type opcode) +static int +zxdh_hw_stats_reset(struct rte_eth_dev *dev, enum zxdh_agent_msg_type opcode) { struct zxdh_hw *hw = dev->data->dev_private; struct zxdh_msg_info msg_info = {0}; @@ -1505,13 +1575,128 @@ static int zxdh_hw_stats_reset(struct rte_eth_dev *dev, enum zxdh_agent_msg_type return 0; } +int +zxdh_hw_np_stats_pf_reset(struct rte_eth_dev *dev, uint32_t stats_id) +{ + struct zxdh_hw *hw = dev->data->dev_private; + struct zxdh_hw_stats_data stats_data; + uint32_t idx = 0; + int ret = 0; + + idx = stats_id + ZXDH_UNICAST_STATS_EGRESS_BASE; + ret = zxdh_np_stat_ppu_cnt_get_ex(hw->dev_id, 1, idx, + 1, (uint32_t *)&stats_data); + if (ret) + return ret; + + idx = stats_id + ZXDH_UNICAST_STATS_INGRESS_BASE; + ret = zxdh_np_stat_ppu_cnt_get_ex(hw->dev_id, 1, idx, + 1, (uint32_t *)&stats_data); + if (ret) + return ret; + + idx = stats_id + ZXDH_MULTICAST_STATS_EGRESS_BASE; + ret = zxdh_np_stat_ppu_cnt_get_ex(hw->dev_id, 1, idx, + 1, (uint32_t *)&stats_data); + if (ret) + return ret; + + idx = stats_id + ZXDH_MULTICAST_STATS_INGRESS_BASE; + ret = zxdh_np_stat_ppu_cnt_get_ex(hw->dev_id, 1, idx, + 1, (uint32_t *)&stats_data); + if (ret) + return ret; + + idx = stats_id + ZXDH_BROAD_STATS_EGRESS_BASE; + ret = zxdh_np_stat_ppu_cnt_get_ex(hw->dev_id, 1, idx, + 1, (uint32_t *)&stats_data); + if (ret) + return ret; + + idx = stats_id + ZXDH_BROAD_STATS_INGRESS_BASE; + ret = zxdh_np_stat_ppu_cnt_get_ex(hw->dev_id, 1, idx, + 1, (uint32_t *)&stats_data); + if (ret) + return ret; + + idx = stats_id + ZXDH_MTU_STATS_EGRESS_BASE; + ret = zxdh_np_stat_ppu_cnt_get_ex(hw->dev_id, 1, idx, + 1, (uint32_t *)&stats_data); + if (ret) + return ret; + + idx = stats_id + ZXDH_MTU_STATS_INGRESS_BASE; + ret = zxdh_np_stat_ppu_cnt_get_ex(hw->dev_id, 1, idx, + 1, (uint32_t *)&stats_data); + if (ret) + return ret; + + idx = stats_id + ZXDH_MTR_STATS_EGRESS_BASE; + ret = zxdh_np_stat_ppu_cnt_get_ex(hw->dev_id, 1, idx, + 1, (uint32_t *)&stats_data); + if (ret) + return ret; + + idx = stats_id + ZXDH_MTR_STATS_INGRESS_BASE; + ret = zxdh_np_stat_ppu_cnt_get_ex(hw->dev_id, 1, idx, + 1, (uint32_t *)&stats_data); + + return ret; +} + +static int +zxdh_hw_np_stats_vf_reset(struct rte_eth_dev *dev) +{ + struct zxdh_hw *hw = dev->data->dev_private; + struct zxdh_msg_info msg_info = {0}; + struct zxdh_msg_reply_info reply_info = {0}; + int ret = 0; + + msg_info.data.np_stats_query.clear_mode = 1; + zxdh_msg_head_build(hw, ZXDH_GET_NP_STATS, &msg_info); + ret = zxdh_vf_send_msg_to_pf(dev, &msg_info, sizeof(struct zxdh_msg_info), + &reply_info, sizeof(reply_info)); + if (ret) + PMD_DRV_LOG(ERR, "Failed to send ZXDH_PORT_METER_STAT_GET msg. code:%d", ret); + + return ret; +} + +static int +zxdh_np_stats_reset(struct rte_eth_dev *dev) +{ + struct zxdh_hw *hw = dev->data->dev_private; + uint32_t stats_id = zxdh_vport_to_vfid(hw->vport); + int ret; + + if (hw->is_pf) + ret = zxdh_hw_np_stats_pf_reset(dev, stats_id); + else + ret = zxdh_hw_np_stats_vf_reset(dev); + return ret; +} + int zxdh_dev_stats_reset(struct rte_eth_dev *dev) { struct zxdh_hw *hw = dev->data->dev_private; + int i = 0; zxdh_hw_stats_reset(dev, ZXDH_VQM_DEV_STATS_RESET); if (hw->is_pf) zxdh_hw_stats_reset(dev, ZXDH_MAC_STATS_RESET); + zxdh_np_stats_reset(dev); + for (i = 0; ((i < dev->data->nb_rx_queues) && (i < RTE_ETHDEV_QUEUE_STAT_CNTRS)); i++) { + struct zxdh_virtnet_rx *rxvq = dev->data->rx_queues[i]; + if (rxvq == NULL) + continue; + memset(&rxvq->stats, 0, sizeof(struct zxdh_virtnet_stats)); + } + for (i = 0; ((i < dev->data->nb_tx_queues) && (i < RTE_ETHDEV_QUEUE_STAT_CNTRS)); i++) { + struct zxdh_virtnet_tx *txvq = dev->data->tx_queues[i]; + if (txvq == NULL) + continue; + memset(&txvq->stats, 0, sizeof(struct zxdh_virtnet_stats)); + } return 0; } diff --git a/drivers/net/zxdh/zxdh_ethdev_ops.h b/drivers/net/zxdh/zxdh_ethdev_ops.h index 8dbd73e2a5..9ab323fde1 100644 --- a/drivers/net/zxdh/zxdh_ethdev_ops.h +++ b/drivers/net/zxdh/zxdh_ethdev_ops.h @@ -28,17 +28,38 @@ #define ZXDH_ETHER_MIN_MTU 68 +struct zxdh_np_stats_data { + uint64_t n_pkts_dropped; + uint64_t n_bytes_dropped; +}; + +struct zxdh_hw_stats_data { + uint64_t n_pkts_dropped; + uint64_t n_bytes_dropped; +}; + struct zxdh_hw_np_stats { - uint64_t np_rx_broadcast; - uint64_t np_tx_broadcast; - uint64_t np_rx_mtu_drop_pkts; - uint64_t np_tx_mtu_drop_pkts; - uint64_t np_rx_mtu_drop_bytes; - uint64_t np_tx_mtu_drop_bytes; - uint64_t np_rx_mtr_drop_pkts; - uint64_t np_tx_mtr_drop_pkts; - uint64_t np_rx_mtr_drop_bytes; - uint64_t np_tx_mtr_drop_bytes; + uint64_t rx_unicast_pkts; + uint64_t tx_unicast_pkts; + uint64_t rx_unicast_bytes; + uint64_t tx_unicast_bytes; + uint64_t rx_multicast_pkts; + uint64_t tx_multicast_pkts; + uint64_t rx_multicast_bytes; + uint64_t tx_multicast_bytes; + uint64_t rx_broadcast_pkts; + uint64_t tx_broadcast_pkts; + uint64_t rx_broadcast_bytes; + uint64_t tx_broadcast_bytes; + uint64_t rx_mtu_drop_pkts; + uint64_t tx_mtu_drop_pkts; + uint64_t rx_mtu_drop_bytes; + uint64_t tx_mtu_drop_bytes; + uint64_t rx_mtr_drop_pkts; + uint64_t tx_mtr_drop_pkts; + uint64_t rx_mtr_drop_bytes; + uint64_t tx_mtr_drop_bytes; + uint64_t tx_ssvpc_pkts; }; struct zxdh_hw_vqm_stats { @@ -76,5 +97,7 @@ int zxdh_rss_configure(struct rte_eth_dev *dev); int zxdh_dev_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats); int zxdh_dev_stats_reset(struct rte_eth_dev *dev); int zxdh_dev_mtu_set(struct rte_eth_dev *dev, uint16_t new_mtu); +int zxdh_hw_np_stats_pf_reset(struct rte_eth_dev *dev, uint32_t stats_id); +void zxdh_data_hi_to_lo(uint64_t *data); #endif /* ZXDH_ETHDEV_OPS_H */ diff --git a/drivers/net/zxdh/zxdh_msg.c b/drivers/net/zxdh/zxdh_msg.c index 9f59b13bf3..4367c25ac2 100644 --- a/drivers/net/zxdh/zxdh_msg.c +++ b/drivers/net/zxdh/zxdh_msg.c @@ -16,6 +16,7 @@ #include "zxdh_msg.h" #include "zxdh_pci.h" #include "zxdh_tables.h" +#include "zxdh_np.h" #define ZXDH_REPS_INFO_FLAG_USABLE 0x00 #define ZXDH_BAR_SEQID_NUM_MAX 256 @@ -1711,6 +1712,147 @@ zxdh_vf_port_attr_set(struct zxdh_hw *pf_hw, uint16_t vport, void *cfg_data, return ret; } +static int +zxdh_vf_np_stats_update(struct zxdh_hw *pf_hw, uint16_t vport, + void *cfg_data __rte_unused, + struct zxdh_msg_reply_body *res_info __rte_unused, + uint16_t *res_len __rte_unused) +{ + struct zxdh_np_stats_updata_msg *np_stats_query = + (struct zxdh_np_stats_updata_msg *)cfg_data; + union zxdh_virport_num vport_num = {.vport = vport}; + struct zxdh_hw_stats_data stats_data; + uint32_t is_clr = np_stats_query->clear_mode; + uint32_t idx = 0; + int ret = 0; + + if (!res_len || !res_info) { + PMD_DRV_LOG(ERR, "get stat invalid inparams"); + return -1; + } + if (is_clr == 1) { + ret = zxdh_hw_np_stats_pf_reset(pf_hw->eth_dev, zxdh_vport_to_vfid(vport_num)); + return ret; + } + idx = zxdh_vport_to_vfid(vport_num) + ZXDH_UNICAST_STATS_EGRESS_BASE; + ret = zxdh_np_dtb_stats_get(pf_hw->dev_id, pf_hw->dev_sd->dtb_sd.queueid, + 0, idx, (uint32_t *)&stats_data); + if (ret) { + PMD_DRV_LOG(ERR, "get stats failed. code:%d", ret); + return ret; + } + zxdh_data_hi_to_lo(&res_info->np_stats.tx_unicast_pkts); + zxdh_data_hi_to_lo(&res_info->np_stats.tx_unicast_bytes); + + idx = zxdh_vport_to_vfid(vport_num) + ZXDH_UNICAST_STATS_INGRESS_BASE; + memset(&stats_data, 0, sizeof(stats_data)); + ret = zxdh_np_dtb_stats_get(pf_hw->dev_id, pf_hw->dev_sd->dtb_sd.queueid, + 0, idx, (uint32_t *)&stats_data); + if (ret) { + PMD_DRV_LOG(ERR, "get stats failed. code:%d", ret); + return ret; + } + zxdh_data_hi_to_lo(&res_info->np_stats.rx_unicast_pkts); + zxdh_data_hi_to_lo(&res_info->np_stats.rx_unicast_bytes); + + idx = zxdh_vport_to_vfid(vport_num) + ZXDH_MULTICAST_STATS_EGRESS_BASE; + ret = zxdh_np_dtb_stats_get(pf_hw->dev_id, pf_hw->dev_sd->dtb_sd.queueid, + 0, idx, (uint32_t *)&stats_data); + if (ret) { + PMD_DRV_LOG(ERR, "get stats failed. code:%d", ret); + return ret; + } + zxdh_data_hi_to_lo(&res_info->np_stats.tx_multicast_pkts); + zxdh_data_hi_to_lo(&res_info->np_stats.tx_multicast_bytes); + + idx = zxdh_vport_to_vfid(vport_num) + ZXDH_MULTICAST_STATS_INGRESS_BASE; + memset(&stats_data, 0, sizeof(stats_data)); + ret = zxdh_np_dtb_stats_get(pf_hw->dev_id, pf_hw->dev_sd->dtb_sd.queueid, + 0, idx, (uint32_t *)&stats_data); + if (ret) { + PMD_DRV_LOG(ERR, "get stats failed. code:%d", ret); + return ret; + } + zxdh_data_hi_to_lo(&res_info->np_stats.rx_multicast_pkts); + zxdh_data_hi_to_lo(&res_info->np_stats.rx_multicast_bytes); + + idx = zxdh_vport_to_vfid(vport_num) + ZXDH_BROAD_STATS_EGRESS_BASE; + ret = zxdh_np_dtb_stats_get(pf_hw->dev_id, pf_hw->dev_sd->dtb_sd.queueid, + 0, idx, (uint32_t *)&stats_data); + if (ret) { + PMD_DRV_LOG(ERR, "get stats failed. code:%d", ret); + return ret; + } + zxdh_data_hi_to_lo(&res_info->np_stats.tx_broadcast_pkts); + zxdh_data_hi_to_lo(&res_info->np_stats.tx_broadcast_bytes); + + idx = zxdh_vport_to_vfid(vport_num) + ZXDH_BROAD_STATS_INGRESS_BASE; + memset(&stats_data, 0, sizeof(stats_data)); + ret = zxdh_np_dtb_stats_get(pf_hw->dev_id, pf_hw->dev_sd->dtb_sd.queueid, + 0, idx, (uint32_t *)&stats_data); + if (ret) { + PMD_DRV_LOG(ERR, "get stats failed. code:%d", ret); + return ret; + } + zxdh_data_hi_to_lo(&res_info->np_stats.rx_broadcast_pkts); + zxdh_data_hi_to_lo(&res_info->np_stats.rx_broadcast_bytes); + + idx = zxdh_vport_to_vfid(vport_num) + ZXDH_MTU_STATS_EGRESS_BASE; + memset(&stats_data, 0, sizeof(stats_data)); + ret = zxdh_np_dtb_stats_get(pf_hw->dev_id, pf_hw->dev_sd->dtb_sd.queueid, + 1, idx, (uint32_t *)&stats_data); + if (ret) { + PMD_DRV_LOG(ERR, "get stats failed. code:%d", ret); + return ret; + } + res_info->np_stats.tx_mtu_drop_pkts = stats_data.n_pkts_dropped; + res_info->np_stats.tx_mtu_drop_bytes = stats_data.n_bytes_dropped; + zxdh_data_hi_to_lo(&res_info->np_stats.tx_mtu_drop_pkts); + zxdh_data_hi_to_lo(&res_info->np_stats.tx_mtu_drop_bytes); + + idx = zxdh_vport_to_vfid(vport_num) + ZXDH_MTU_STATS_INGRESS_BASE; + memset(&stats_data, 0, sizeof(stats_data)); + ret = zxdh_np_dtb_stats_get(pf_hw->dev_id, pf_hw->dev_sd->dtb_sd.queueid, + 1, idx, (uint32_t *)&stats_data); + if (ret) { + PMD_DRV_LOG(ERR, "get stats failed. code:%d", ret); + return ret; + } + res_info->np_stats.rx_mtu_drop_pkts = stats_data.n_pkts_dropped; + res_info->np_stats.rx_mtu_drop_bytes = stats_data.n_bytes_dropped; + zxdh_data_hi_to_lo(&res_info->np_stats.rx_mtu_drop_pkts); + zxdh_data_hi_to_lo(&res_info->np_stats.rx_mtu_drop_bytes); + + idx = zxdh_vport_to_vfid(vport_num) + ZXDH_MTR_STATS_EGRESS_BASE; + memset(&stats_data, 0, sizeof(stats_data)); + ret = zxdh_np_dtb_stats_get(pf_hw->dev_id, pf_hw->dev_sd->dtb_sd.queueid, + 1, idx, (uint32_t *)&stats_data); + if (ret) { + PMD_DRV_LOG(ERR, "get stats failed. code:%d", ret); + return ret; + } + res_info->np_stats.tx_mtr_drop_pkts = stats_data.n_pkts_dropped; + res_info->np_stats.tx_mtr_drop_bytes = stats_data.n_bytes_dropped; + zxdh_data_hi_to_lo(&res_info->np_stats.tx_mtr_drop_pkts); + zxdh_data_hi_to_lo(&res_info->np_stats.tx_mtr_drop_bytes); + + idx = zxdh_vport_to_vfid(vport_num) + ZXDH_MTR_STATS_INGRESS_BASE; + memset(&stats_data, 0, sizeof(stats_data)); + ret = zxdh_np_dtb_stats_get(pf_hw->dev_id, pf_hw->dev_sd->dtb_sd.queueid, + 1, idx, (uint32_t *)&stats_data); + if (ret) { + PMD_DRV_LOG(ERR, "get stats failed. code:%d", ret); + return ret; + } + res_info->np_stats.rx_mtr_drop_pkts = stats_data.n_pkts_dropped; + res_info->np_stats.rx_mtr_drop_bytes = stats_data.n_bytes_dropped; + zxdh_data_hi_to_lo(&res_info->np_stats.rx_mtr_drop_pkts); + zxdh_data_hi_to_lo(&res_info->np_stats.rx_mtr_drop_bytes); + *res_len = sizeof(struct zxdh_hw_np_stats); + + return 0; +} + zxdh_msg_process_callback zxdh_proc_cb[] = { [ZXDH_NULL] = NULL, [ZXDH_VF_PORT_INIT] = zxdh_vf_port_init, @@ -1728,6 +1870,7 @@ zxdh_msg_process_callback zxdh_proc_cb[] = { [ZXDH_RSS_HF_GET] = zxdh_vf_rss_hf_get, [ZXDH_VLAN_OFFLOAD] = zxdh_vf_set_vlan_offload, [ZXDH_PORT_ATTRS_SET] = zxdh_vf_port_attr_set, + [ZXDH_GET_NP_STATS] = zxdh_vf_np_stats_update, }; static inline int diff --git a/drivers/net/zxdh/zxdh_msg.h b/drivers/net/zxdh/zxdh_msg.h index 5a7085ad7b..7c0d2adc4c 100644 --- a/drivers/net/zxdh/zxdh_msg.h +++ b/drivers/net/zxdh/zxdh_msg.h @@ -316,6 +316,10 @@ enum zxdh_reps_flag { ZXDH_REPS_INVALID = 0xee, }; +struct zxdh_np_stats_updata_msg { + uint32_t clear_mode; +}; + struct zxdh_link_info_msg { uint8_t autoneg; uint8_t link_state; @@ -432,6 +436,7 @@ struct zxdh_msg_info { struct zxdh_rss_reta rss_reta; struct zxdh_rss_enable rss_enable; struct zxdh_rss_hf rss_hf; + struct zxdh_np_stats_updata_msg np_stats_query; } data; }; diff --git a/drivers/net/zxdh/zxdh_np.c b/drivers/net/zxdh/zxdh_np.c index 01237aba70..b9b8398f24 100644 --- a/drivers/net/zxdh/zxdh_np.c +++ b/drivers/net/zxdh/zxdh_np.c @@ -1993,3 +1993,266 @@ zxdh_np_dtb_stats_get(uint32_t dev_id, return rc; } + +static uint32_t +zxdh_np_se_done_status_check(uint32_t dev_id, uint32_t reg_no, uint32_t pos) +{ + uint32_t rc = 0; + + uint32_t data = 0; + uint32_t rd_cnt = 0; + uint32_t done_flag = 0; + + while (!done_flag) { + rc = zxdh_np_reg_read(dev_id, reg_no, 0, 0, &data); + if (rc != 0) { + PMD_DRV_LOG(ERR, " [ErrorCode:0x%x] !-- zxdh_np_reg_read Fail!", rc); + return rc; + } + + done_flag = (data >> pos) & 0x1; + + if (done_flag) + break; + + if (rd_cnt > ZXDH_RD_CNT_MAX * ZXDH_RD_CNT_MAX) + return -1; + + rd_cnt++; + } + + return rc; +} + +static uint32_t +zxdh_np_se_smmu0_ind_read(uint32_t dev_id, + uint32_t base_addr, + uint32_t index, + uint32_t rd_mode, + uint32_t rd_clr_mode, + uint32_t *p_data) +{ + uint32_t rc = 0; + uint32_t i = 0; + uint32_t row_index = 0; + uint32_t col_index = 0; + uint32_t temp_data[4] = {0}; + uint32_t *p_temp_data = NULL; + ZXDH_SMMU0_SMMU0_CPU_IND_CMD_T cpu_ind_cmd = {0}; + + rc = zxdh_np_se_done_status_check(dev_id, ZXDH_SMMU0_SMMU0_WR_ARB_CPU_RDYR, 0); + + if (rd_clr_mode == ZXDH_RD_MODE_HOLD) { + cpu_ind_cmd.cpu_ind_rw = ZXDH_SE_OPR_RD; + cpu_ind_cmd.cpu_ind_rd_mode = ZXDH_RD_MODE_HOLD; + cpu_ind_cmd.cpu_req_mode = ZXDH_ERAM128_OPR_128b; + + switch (rd_mode) { + case ZXDH_ERAM128_OPR_128b: + { + if ((0xFFFFFFFF - (base_addr)) < (index)) + return ZXDH_PAR_CHK_INVALID_INDEX; + + if (base_addr + index > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) { + PMD_DRV_LOG(ERR, "%s : index out of range !", __func__); + return -1; + } + + row_index = (index << 7) & ZXDH_ERAM128_BADDR_MASK; + break; + } + + case ZXDH_ERAM128_OPR_64b: + { + if ((base_addr + (index >> 1)) > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) { + PMD_DRV_LOG(ERR, "%s : index out of range !", __func__); + return -1; + } + + row_index = (index << 6) & ZXDH_ERAM128_BADDR_MASK; + col_index = index & 0x1; + break; + } + + case ZXDH_ERAM128_OPR_32b: + { + if ((base_addr + (index >> 2)) > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) { + PMD_DRV_LOG(ERR, "%s : index out of range !", __func__); + return -1; + } + + row_index = (index << 5) & ZXDH_ERAM128_BADDR_MASK; + col_index = index & 0x3; + break; + } + + case ZXDH_ERAM128_OPR_1b: + { + if ((base_addr + (index >> 7)) > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) { + PMD_DRV_LOG(ERR, "%s : index out of range !", __func__); + return -1; + } + row_index = index & ZXDH_ERAM128_BADDR_MASK; + col_index = index & 0x7F; + break; + } + } + + cpu_ind_cmd.cpu_ind_addr = ((base_addr << 7) & ZXDH_ERAM128_BADDR_MASK) + row_index; + } else { + cpu_ind_cmd.cpu_ind_rw = ZXDH_SE_OPR_RD; + cpu_ind_cmd.cpu_ind_rd_mode = ZXDH_RD_MODE_CLEAR; + + switch (rd_mode) { + case ZXDH_ERAM128_OPR_128b: + { + if ((0xFFFFFFFF - (base_addr)) < (index)) { + PMD_DRV_LOG(ERR, "%s : index 0x%x is invalid!", __func__, index); + return ZXDH_PAR_CHK_INVALID_INDEX; + } + if (base_addr + index > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) { + PMD_DRV_LOG(ERR, "%s : index out of range !", __func__); + return -1; + } + row_index = (index << 7); + cpu_ind_cmd.cpu_req_mode = ZXDH_ERAM128_OPR_128b; + break; + } + case ZXDH_ERAM128_OPR_64b: + { + if ((base_addr + (index >> 1)) > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) { + PMD_DRV_LOG(ERR, "%s : index out of range !", __func__); + return -1; + } + + row_index = (index << 6); + cpu_ind_cmd.cpu_req_mode = 2; + break; + } + case ZXDH_ERAM128_OPR_32b: + { + if ((base_addr + (index >> 2)) > ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL - 1) { + PMD_DRV_LOG(ERR, "%s : index out of range !", __func__); + return -1; + } + row_index = (index << 5); + cpu_ind_cmd.cpu_req_mode = 1; + break; + } + case ZXDH_ERAM128_OPR_1b: + { + PMD_DRV_LOG(ERR, "rd_clr_mode[%d] or rd_mode[%d] error! ", + rd_clr_mode, rd_mode); + return -1; + } + } + cpu_ind_cmd.cpu_ind_addr = ((base_addr << 7) & ZXDH_ERAM128_BADDR_MASK) + row_index; + } + + rc = zxdh_np_reg_write(dev_id, + ZXDH_SMMU0_SMMU0_CPU_IND_CMDR, + 0, + 0, + &cpu_ind_cmd); + + rc = zxdh_np_se_done_status_check(dev_id, ZXDH_SMMU0_SMMU0_RD_CPU_IND_DONER, 0); + + p_temp_data = temp_data; + for (i = 0; i < 4; i++) { + rc = zxdh_np_reg_read(dev_id, + ZXDH_SMMU0_SMMU0_CPU_IND_RDAT0R + i, + 0, + 0, + p_temp_data + 3 - i); + } + + if (rd_clr_mode == ZXDH_RD_MODE_HOLD) { + switch (rd_mode) { + case ZXDH_ERAM128_OPR_128b: + { + rte_memcpy(p_data, p_temp_data, (128 / 8)); + break; + } + case ZXDH_ERAM128_OPR_64b: + { + rte_memcpy(p_data, p_temp_data + ((1 - col_index) << 1), (64 / 8)); + break; + } + case ZXDH_ERAM128_OPR_32b: + { + rte_memcpy(p_data, p_temp_data + ((3 - col_index)), (32 / 8)); + break; + } + case ZXDH_ERAM128_OPR_1b: + { + ZXDH_COMM_UINT32_GET_BITS(p_data[0], + *(p_temp_data + (3 - col_index / 32)), (col_index % 32), 1); + break; + } + } + } else { + switch (rd_mode) { + case ZXDH_ERAM128_OPR_128b: + { + rte_memcpy(p_data, p_temp_data, (128 / 8)); + break; + } + case ZXDH_ERAM128_OPR_64b: + { + rte_memcpy(p_data, p_temp_data, (64 / 8)); + break; + } + case ZXDH_ERAM128_OPR_32b: + { + rte_memcpy(p_data, p_temp_data, (64 / 8)); + break; + } + } + } + + return rc; +} + +uint32_t +zxdh_np_stat_ppu_cnt_get_ex(uint32_t dev_id, + ZXDH_STAT_CNT_MODE_E rd_mode, + uint32_t index, + uint32_t clr_mode, + uint32_t *p_data) +{ + uint32_t rc = 0; + uint32_t ppu_eram_baddr = 0; + uint32_t ppu_eram_depth = 0; + uint32_t eram_rd_mode = 0; + uint32_t eram_clr_mode = 0; + ZXDH_PPU_STAT_CFG_T stat_cfg = {0}; + + zxdh_np_stat_cfg_soft_get(dev_id, &stat_cfg); + + ppu_eram_depth = stat_cfg.eram_depth; + ppu_eram_baddr = stat_cfg.eram_baddr; + + if ((index >> (ZXDH_STAT_128_MODE - rd_mode)) < ppu_eram_depth) { + if (rd_mode == ZXDH_STAT_128_MODE) + eram_rd_mode = ZXDH_ERAM128_OPR_128b; + else + eram_rd_mode = ZXDH_ERAM128_OPR_64b; + + if (clr_mode == ZXDH_STAT_RD_CLR_MODE_UNCLR) + eram_clr_mode = ZXDH_RD_MODE_HOLD; + else + eram_clr_mode = ZXDH_RD_MODE_CLEAR; + + rc = zxdh_np_se_smmu0_ind_read(dev_id, + ppu_eram_baddr, + index, + eram_rd_mode, + eram_clr_mode, + p_data); + ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_se_smmu0_ind_read"); + } else { + PMD_DRV_LOG(ERR, "DPDK DON'T HAVE DDR STAT."); + } + + return rc; +} diff --git a/drivers/net/zxdh/zxdh_np.h b/drivers/net/zxdh/zxdh_np.h index 7da29cf7bd..d793189657 100644 --- a/drivers/net/zxdh/zxdh_np.h +++ b/drivers/net/zxdh/zxdh_np.h @@ -12,6 +12,9 @@ #define ZXDH_PORT_NAME_MAX (32) #define ZXDH_DEV_CHANNEL_MAX (2) #define ZXDH_DEV_SDT_ID_MAX (256U) + +#define ZXDH_RD_CNT_MAX (128) + /*DTB*/ #define ZXDH_DTB_QUEUE_ITEM_NUM_MAX (32) #define ZXDH_DTB_QUEUE_NUM_MAX (128) @@ -562,6 +565,38 @@ typedef enum zxdh_stat_cnt_mode_e { ZXDH_STAT_MAX_MODE, } ZXDH_STAT_CNT_MODE_E; +typedef struct zxdh_smmu0_smmu0_cpu_ind_cmd_t { + uint32_t cpu_ind_rw; + uint32_t cpu_ind_rd_mode; + uint32_t cpu_req_mode; + uint32_t cpu_ind_addr; +} ZXDH_SMMU0_SMMU0_CPU_IND_CMD_T; + +typedef enum zxdh_smmu0_smmu0_type_e { + ZXDH_DEV_MUTEX_T_SMMU0 = 0, + ZXDH_SMMU0_SMMU0_CPU_IND_CMDR = 1, + ZXDH_SMMU0_SMMU0_CPU_IND_RDAT0R = 2, + ZXDH_SMMU0_SMMU0_RD_CPU_IND_DONER = 3, + ZXDH_SMMU0_SMMU0_WR_ARB_CPU_RDYR = 4, + ZXDH_SMMU0_SMMU0_ED_ARB_CPU_RDYR = 5, +} ZXDH_SEMMU0_SEMMU0_TYPE_E; + +typedef enum zxdh_stat_rd_clr_mode_e { + ZXDH_STAT_RD_CLR_MODE_UNCLR = 0, + ZXDH_STAT_RD_CLR_MODE_CLR = 1, + ZXDH_STAT_RD_CLR_MODE_MAX, +} STAT_RD_CLR_MODE_E; + +typedef enum zxdh_eram128_rd_clr_mode_e { + ZXDH_RD_MODE_HOLD = 0, + ZXDH_RD_MODE_CLEAR = 1, +} ZXDH_ERAM128_RD_CLR_MODE_E; + +typedef enum zxdh_se_opr_mode_e { + ZXDH_SE_OPR_RD = 0, + ZXDH_SE_OPR_WR = 1, +} ZXDH_SE_OPR_MODE_E; + int zxdh_np_host_init(uint32_t dev_id, ZXDH_DEV_INIT_CTRL_T *p_dev_init_ctrl); int zxdh_np_online_uninit(uint32_t dev_id, char *port_name, uint32_t queue_id); int zxdh_np_dtb_table_entry_write(uint32_t dev_id, uint32_t queue_id, @@ -575,5 +610,10 @@ int zxdh_np_dtb_stats_get(uint32_t dev_id, ZXDH_STAT_CNT_MODE_E rd_mode, uint32_t index, uint32_t *p_data); +uint32_t zxdh_np_stat_ppu_cnt_get_ex(uint32_t dev_id, + ZXDH_STAT_CNT_MODE_E rd_mode, + uint32_t index, + uint32_t clr_mode, + uint32_t *p_data); #endif /* ZXDH_NP_H */ diff --git a/drivers/net/zxdh/zxdh_tables.h b/drivers/net/zxdh/zxdh_tables.h index cd666a9251..f44f444bd9 100644 --- a/drivers/net/zxdh/zxdh_tables.h +++ b/drivers/net/zxdh/zxdh_tables.h @@ -65,10 +65,18 @@ #define ZXDH_PORT_RSS_EN_OFF_FLAG 42 #define ZXDH_PORT_MTU_OFFLOAD_EN_OFF_FLAG 43 -#define ZXDH_MTU_STATS_EGRESS_BASE 0x8481 -#define ZXDH_MTU_STATS_INGRESS_BASE 0x8981 -#define ZXDH_BROAD_STATS_EGRESS_BASE 0xC902 -#define ZXDH_BROAD_STATS_INGRESS_BASE 0xD102 +#define ZXDH_MTU_STATS_EGRESS_BASE 0x8481 +#define ZXDH_MTU_STATS_INGRESS_BASE 0x8981 +#define ZXDH_BROAD_STATS_EGRESS_BASE 0xA8C1 +#define ZXDH_BROAD_STATS_INGRESS_BASE 0xA3C1 +#define ZXDH_MTR_STATS_EGRESS_BASE 0x7481 +#define ZXDH_MTR_STATS_INGRESS_BASE 0x7C81 +#define ZXDH_MULTICAST_STATS_EGRESS_BASE 0x9EC1 +#define ZXDH_MULTICAST_STATS_INGRESS_BASE 0x99C1 +#define ZXDH_UNICAST_STATS_EGRESS_BASE 0x94C1 +#define ZXDH_UNICAST_STATS_INGRESS_BASE 0x8FC1 + +#define ZXDH_FLOW_STATS_INGRESS_BASE 0xADC1 extern struct zxdh_dtb_shared_data g_dtb_data; -- 2.27.0