provided link info update, set link up /down, and link intr. Signed-off-by: Junlong Wang --- doc/guides/nics/features/zxdh.ini | 2 + doc/guides/nics/zxdh.rst | 3 + drivers/net/zxdh/meson.build | 1 + drivers/net/zxdh/zxdh_ethdev.c | 14 ++- drivers/net/zxdh/zxdh_ethdev.h | 2 + drivers/net/zxdh/zxdh_ethdev_ops.c | 166 ++++++++++++++++++++++++++++ drivers/net/zxdh/zxdh_ethdev_ops.h | 14 +++ drivers/net/zxdh/zxdh_msg.c | 57 ++++++++++ drivers/net/zxdh/zxdh_msg.h | 40 +++++++ drivers/net/zxdh/zxdh_np.c | 172 ++++++++++++++++++++++++++++- drivers/net/zxdh/zxdh_np.h | 20 ++++ drivers/net/zxdh/zxdh_tables.c | 15 +++ drivers/net/zxdh/zxdh_tables.h | 6 +- 13 files changed, 503 insertions(+), 9 deletions(-) create mode 100644 drivers/net/zxdh/zxdh_ethdev_ops.c create mode 100644 drivers/net/zxdh/zxdh_ethdev_ops.h diff --git a/doc/guides/nics/features/zxdh.ini b/doc/guides/nics/features/zxdh.ini index bb44e93fad..7da3aaced1 100644 --- a/doc/guides/nics/features/zxdh.ini +++ b/doc/guides/nics/features/zxdh.ini @@ -10,3 +10,5 @@ ARMv8 = Y SR-IOV = Y Multiprocess aware = Y Scattered Rx = Y +Link status = Y +Link status event = Y diff --git a/doc/guides/nics/zxdh.rst b/doc/guides/nics/zxdh.rst index f42db9c1f1..fdbc3b3923 100644 --- a/doc/guides/nics/zxdh.rst +++ b/doc/guides/nics/zxdh.rst @@ -21,6 +21,9 @@ Features of the ZXDH PMD are: - Multiple queues for TX and RX - SR-IOV VF - Scattered and gather for TX and RX +- Link Auto-negotiation +- Link state information +- Set Link down or up Driver compilation and testing diff --git a/drivers/net/zxdh/meson.build b/drivers/net/zxdh/meson.build index 20b2cf484a..48f8f5e1ee 100644 --- a/drivers/net/zxdh/meson.build +++ b/drivers/net/zxdh/meson.build @@ -22,4 +22,5 @@ sources = files( 'zxdh_np.c', 'zxdh_tables.c', 'zxdh_rxtx.c', + 'zxdh_ethdev_ops.c', ) diff --git a/drivers/net/zxdh/zxdh_ethdev.c b/drivers/net/zxdh/zxdh_ethdev.c index 0d63129d8d..d3876ec9b3 100644 --- a/drivers/net/zxdh/zxdh_ethdev.c +++ b/drivers/net/zxdh/zxdh_ethdev.c @@ -16,6 +16,7 @@ #include "zxdh_np.h" #include "zxdh_tables.h" #include "zxdh_rxtx.h" +#include "zxdh_ethdev_ops.h" struct zxdh_hw_internal zxdh_hw_internal[RTE_MAX_ETHPORTS]; struct zxdh_shared_data *zxdh_shared_data; @@ -105,12 +106,18 @@ static void zxdh_devconf_intr_handler(void *param) { struct rte_eth_dev *dev = param; + struct zxdh_hw *hw = dev->data->dev_private; + + uint8_t isr = zxdh_pci_isr(hw); if (zxdh_intr_unmask(dev) < 0) PMD_DRV_LOG(ERR, "interrupt enable failed"); + if (isr & ZXDH_PCI_ISR_CONFIG) { + if (zxdh_dev_link_update(dev, 0) == 0) + rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_LSC, NULL); + } } - /* Interrupt handler triggered by NIC for handling specific interrupt. */ static void zxdh_fromriscv_intr_handler(void *param) @@ -1006,6 +1013,8 @@ zxdh_dev_start(struct rte_eth_dev *dev) vq = hw->vqs[logic_qidx]; zxdh_queue_notify(vq); } + zxdh_dev_set_link_up(dev); + return 0; } @@ -1020,6 +1029,9 @@ static const struct eth_dev_ops zxdh_eth_dev_ops = { .tx_queue_setup = zxdh_dev_tx_queue_setup, .rx_queue_intr_enable = zxdh_dev_rx_queue_intr_enable, .rx_queue_intr_disable = zxdh_dev_rx_queue_intr_disable, + .link_update = zxdh_dev_link_update, + .dev_set_link_up = zxdh_dev_set_link_up, + .dev_set_link_down = zxdh_dev_set_link_down, }; static int32_t diff --git a/drivers/net/zxdh/zxdh_ethdev.h b/drivers/net/zxdh/zxdh_ethdev.h index b1f398b28e..c0b719062c 100644 --- a/drivers/net/zxdh/zxdh_ethdev.h +++ b/drivers/net/zxdh/zxdh_ethdev.h @@ -72,6 +72,7 @@ struct zxdh_hw { uint64_t guest_features; uint32_t max_queue_pairs; uint32_t speed; + uint32_t speed_mode; uint32_t notify_off_multiplier; uint16_t *notify_base; uint16_t pcie_id; @@ -93,6 +94,7 @@ struct zxdh_hw { uint8_t panel_id; uint8_t has_tx_offload; uint8_t has_rx_offload; + uint8_t admin_status; }; struct zxdh_dtb_shared_data { diff --git a/drivers/net/zxdh/zxdh_ethdev_ops.c b/drivers/net/zxdh/zxdh_ethdev_ops.c new file mode 100644 index 0000000000..5a0af98cc0 --- /dev/null +++ b/drivers/net/zxdh/zxdh_ethdev_ops.c @@ -0,0 +1,166 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2024 ZTE Corporation + */ + +#include "zxdh_ethdev.h" +#include "zxdh_pci.h" +#include "zxdh_msg.h" +#include "zxdh_ethdev_ops.h" +#include "zxdh_tables.h" +#include "zxdh_logs.h" + +static int32_t zxdh_config_port_status(struct rte_eth_dev *dev, uint16_t link_status) +{ + struct zxdh_hw *hw = dev->data->dev_private; + struct zxdh_port_attr_table port_attr = {0}; + struct zxdh_msg_info msg_info = {0}; + int32_t ret = 0; + + if (hw->is_pf) { + ret = zxdh_get_port_attr(hw->vfid, &port_attr); + if (ret) { + PMD_DRV_LOG(ERR, "write port_attr failed"); + return -1; + } + port_attr.is_up = link_status; + + ret = zxdh_set_port_attr(hw->vfid, &port_attr); + if (ret) { + PMD_DRV_LOG(ERR, "write port_attr failed"); + return -1; + } + } else { + struct zxdh_port_attr_set_msg *port_attr_msg = &msg_info.data.port_attr_msg; + + zxdh_msg_head_build(hw, ZXDH_PORT_ATTRS_SET, &msg_info); + port_attr_msg->mode = ZXDH_PORT_ATTR_IS_UP_FLAG; + port_attr_msg->value = link_status; + ret = zxdh_vf_send_msg_to_pf(dev, &msg_info, sizeof(msg_info), NULL, 0); + if (ret) { + PMD_DRV_LOG(ERR, "Failed to send msg: port 0x%x msg type %d", + hw->vport.vport, ZXDH_PORT_ATTR_IS_UP_FLAG); + return ret; + } + } + return ret; +} + +static int32_t +zxdh_link_info_get(struct rte_eth_dev *dev, struct rte_eth_link *link) +{ + struct zxdh_hw *hw = dev->data->dev_private; + struct zxdh_msg_info msg_info = {0}; + struct zxdh_msg_reply_info reply_info = {0}; + uint16_t status = 0; + int32_t ret = 0; + + if (zxdh_pci_with_feature(hw, ZXDH_NET_F_STATUS)) + zxdh_pci_read_dev_config(hw, offsetof(struct zxdh_net_config, status), + &status, sizeof(status)); + + link->link_status = status; + + if (status == RTE_ETH_LINK_DOWN) { + link->link_speed = RTE_ETH_SPEED_NUM_UNKNOWN; + link->link_duplex = RTE_ETH_LINK_FULL_DUPLEX; + } else { + zxdh_agent_msg_build(hw, ZXDH_MAC_LINK_GET, &msg_info); + + ret = zxdh_send_msg_to_riscv(dev, &msg_info, sizeof(struct zxdh_msg_info), + &reply_info, sizeof(struct zxdh_msg_reply_info), + ZXDH_BAR_MODULE_MAC); + if (ret) { + PMD_DRV_LOG(ERR, "Failed to send msg: port 0x%x msg type %d", + hw->vport.vport, ZXDH_MAC_LINK_GET); + return -1; + } + link->link_speed = reply_info.reply_body.link_msg.speed; + hw->speed_mode = reply_info.reply_body.link_msg.speed_modes; + if ((reply_info.reply_body.link_msg.duplex & RTE_ETH_LINK_FULL_DUPLEX) == + RTE_ETH_LINK_FULL_DUPLEX) + link->link_duplex = RTE_ETH_LINK_FULL_DUPLEX; + else + link->link_duplex = RTE_ETH_LINK_HALF_DUPLEX; + } + hw->speed = link->link_speed; + + return 0; +} + +static int zxdh_set_link_status(struct rte_eth_dev *dev, uint8_t link_status) +{ + uint16_t curr_link_status = dev->data->dev_link.link_status; + + struct rte_eth_link link; + struct zxdh_hw *hw = dev->data->dev_private; + int32_t ret = 0; + + if (link_status == curr_link_status) { + PMD_DRV_LOG(DEBUG, "curr_link_status %u", curr_link_status); + return 0; + } + + hw->admin_status = link_status; + ret = zxdh_link_info_get(dev, &link); + if (ret != 0) { + PMD_DRV_LOG(ERR, "Failed to get link status from hw"); + return ret; + } + dev->data->dev_link.link_status = hw->admin_status & link.link_status; + + if (dev->data->dev_link.link_status == RTE_ETH_LINK_UP) { + dev->data->dev_link.link_speed = link.link_speed; + dev->data->dev_link.link_duplex = link.link_duplex; + } else { + dev->data->dev_link.link_speed = RTE_ETH_SPEED_NUM_UNKNOWN; + dev->data->dev_link.link_duplex = RTE_ETH_LINK_FULL_DUPLEX; + } + return zxdh_config_port_status(dev, dev->data->dev_link.link_status); +} + +int zxdh_dev_set_link_up(struct rte_eth_dev *dev) +{ + int ret = zxdh_set_link_status(dev, RTE_ETH_LINK_UP); + + if (ret) + PMD_DRV_LOG(ERR, "Set link up failed, code:%d", ret); + + return ret; +} + +int32_t zxdh_dev_link_update(struct rte_eth_dev *dev, int32_t wait_to_complete __rte_unused) +{ + struct rte_eth_link link; + struct zxdh_hw *hw = dev->data->dev_private; + int32_t ret = 0; + + memset(&link, 0, sizeof(link)); + link.link_duplex = hw->duplex; + link.link_speed = hw->speed; + link.link_autoneg = RTE_ETH_LINK_AUTONEG; + + ret = zxdh_link_info_get(dev, &link); + if (ret != 0) { + PMD_DRV_LOG(ERR, " Failed to get link status from hw"); + return ret; + } + link.link_status &= hw->admin_status; + if (link.link_status == RTE_ETH_LINK_DOWN) + link.link_speed = RTE_ETH_SPEED_NUM_UNKNOWN; + + ret = zxdh_config_port_status(dev, link.link_status); + if (ret != 0) { + PMD_DRV_LOG(ERR, "set port attr %d failed.", link.link_status); + return ret; + } + return rte_eth_linkstatus_set(dev, &link); +} + +int zxdh_dev_set_link_down(struct rte_eth_dev *dev) +{ + int ret = zxdh_set_link_status(dev, RTE_ETH_LINK_DOWN); + + if (ret) + PMD_DRV_LOG(ERR, "Set link down failed"); + return ret; +} diff --git a/drivers/net/zxdh/zxdh_ethdev_ops.h b/drivers/net/zxdh/zxdh_ethdev_ops.h new file mode 100644 index 0000000000..c6d6ca56fd --- /dev/null +++ b/drivers/net/zxdh/zxdh_ethdev_ops.h @@ -0,0 +1,14 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2024 ZTE Corporation + */ + +#ifndef ZXDH_ETHDEV_OPS_H +#define ZXDH_ETHDEV_OPS_H + +#include "zxdh_ethdev.h" + +int zxdh_dev_set_link_up(struct rte_eth_dev *dev); +int zxdh_dev_set_link_down(struct rte_eth_dev *dev); +int32_t zxdh_dev_link_update(struct rte_eth_dev *dev, int32_t wait_to_complete __rte_unused); + +#endif /* ZXDH_ETHDEV_OPS_H */ diff --git a/drivers/net/zxdh/zxdh_msg.c b/drivers/net/zxdh/zxdh_msg.c index aa2e10fd45..23a7ed2097 100644 --- a/drivers/net/zxdh/zxdh_msg.c +++ b/drivers/net/zxdh/zxdh_msg.c @@ -1134,6 +1134,51 @@ int zxdh_vf_send_msg_to_pf(struct rte_eth_dev *dev, void *msg_req, return 0; } +int32_t zxdh_send_msg_to_riscv(struct rte_eth_dev *dev, void *msg_req, + uint16_t msg_req_len, void *reply, uint16_t reply_len, + enum ZXDH_BAR_MODULE_ID module_id) +{ + struct zxdh_hw *hw = dev->data->dev_private; + struct zxdh_pci_bar_msg in = {0}; + struct zxdh_msg_recviver_mem result = {0}; + struct zxdh_msg_reply_info reply_info = {0}; + + if (reply) { + RTE_ASSERT(reply_len < sizeof(zxdh_msg_reply_info)); + result.recv_buffer = reply; + result.buffer_len = reply_len; + } else { + 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); + in.payload_addr = &msg_req; + in.payload_len = msg_req_len; + in.virt_addr = (uint64_t)(hw->bar_addr[ZXDH_BAR0_INDEX] + ZXDH_CTRLCH_OFFSET); + in.src = hw->is_pf ? ZXDH_MSG_CHAN_END_PF : ZXDH_MSG_CHAN_END_VF; + in.dst = ZXDH_MSG_CHAN_END_RISC; + in.module_id = module_id; + in.src_pcieid = hw->pcie_id; + if (zxdh_bar_chan_sync_msg_send(&in, &result) != ZXDH_BAR_MSG_OK) { + 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; +} + void zxdh_msg_head_build(struct zxdh_hw *hw, enum zxdh_msg_type type, struct zxdh_msg_info *msg_info) { @@ -1144,3 +1189,15 @@ void zxdh_msg_head_build(struct zxdh_hw *hw, enum zxdh_msg_type type, msghead->vf_id = hw->vport.vfid; msghead->pcieid = hw->pcie_id; } + +void zxdh_agent_msg_build(struct zxdh_hw *hw, enum zxdh_agent_msg_type type, + struct zxdh_msg_info *msg_info) +{ + struct zxdh_agent_msg_head *agent_head = &msg_info->agent_msg_head; + + agent_head->msg_type = type; + agent_head->panel_id = hw->panel_id; + agent_head->phyport = hw->phyport; + agent_head->vf_id = hw->vfid; + agent_head->pcie_id = hw->pcie_id; +} diff --git a/drivers/net/zxdh/zxdh_msg.h b/drivers/net/zxdh/zxdh_msg.h index 613ca71170..a78075c914 100644 --- a/drivers/net/zxdh/zxdh_msg.h +++ b/drivers/net/zxdh/zxdh_msg.h @@ -164,11 +164,18 @@ enum pciebar_layout_type { ZXDH_URI_MAX, }; +/* riscv msg opcodes */ +enum zxdh_agent_msg_type { + ZXDH_MAC_LINK_GET = 14, +}; + enum zxdh_msg_type { ZXDH_NULL = 0, ZXDH_VF_PORT_INIT = 1, ZXDH_VF_PORT_UNINIT = 2, + ZXDH_PORT_ATTRS_SET = 25, + ZXDH_MSG_TYPE_END, }; @@ -261,6 +268,15 @@ struct zxdh_offset_get_msg { uint16_t type; }; +struct zxdh_link_info_msg { + uint8_t autoneg; + uint8_t link_state; + uint8_t blink_enable; + uint8_t duplex; + uint32_t speed_modes; + uint32_t speed; +} __rte_packed; + struct zxdh_msg_reply_head { uint8_t flag; uint16_t reps_len; @@ -276,6 +292,7 @@ struct zxdh_msg_reply_body { enum zxdh_reps_flag flag; union { uint8_t reply_data[ZXDH_MSG_REPLY_BODY_MAX_LEN - sizeof(enum zxdh_reps_flag)]; + struct zxdh_link_info_msg link_msg; } __rte_packed; } __rte_packed; @@ -291,6 +308,12 @@ struct zxdh_vf_init_msg { uint8_t rss_enable; } __rte_packed; +struct zxdh_port_attr_set_msg { + uint32_t mode; + uint32_t value; + uint8_t allmulti_follow; +} __rte_packed; + struct zxdh_msg_head { enum zxdh_msg_type msg_type; uint16_t vport; @@ -298,14 +321,26 @@ struct zxdh_msg_head { uint16_t pcieid; } __rte_packed; +struct zxdh_agent_msg_head { + enum zxdh_agent_msg_type msg_type; + uint8_t panel_id; + uint8_t phyport; + uint8_t rsv; + uint16_t vf_id; + uint16_t pcie_id; +} __rte_packed; + struct zxdh_msg_info { union { uint8_t head_len[ZXDH_MSG_HEAD_LEN]; struct zxdh_msg_head msg_head; + struct zxdh_agent_msg_head agent_msg_head; }; union { uint8_t datainfo[ZXDH_MSG_REQ_BODY_MAX_LEN]; struct zxdh_vf_init_msg vf_init_msg; + struct zxdh_port_attr_set_msg port_attr_msg; + struct zxdh_link_info_msg link_msg; } __rte_packed data; } __rte_packed; @@ -326,5 +361,10 @@ void zxdh_msg_head_build(struct zxdh_hw *hw, enum zxdh_msg_type type, struct zxdh_msg_info *msg_info); int zxdh_vf_send_msg_to_pf(struct rte_eth_dev *dev, void *msg_req, uint16_t msg_req_len, void *reply, uint16_t reply_len); +void zxdh_agent_msg_build(struct zxdh_hw *hw, enum zxdh_agent_msg_type type, + struct zxdh_msg_info *msg_info); +int32_t zxdh_send_msg_to_riscv(struct rte_eth_dev *dev, void *msg_req, + uint16_t msg_req_len, void *reply, uint16_t reply_len, + enum ZXDH_BAR_MODULE_ID module_id); #endif /* ZXDH_MSG_H */ diff --git a/drivers/net/zxdh/zxdh_np.c b/drivers/net/zxdh/zxdh_np.c index 99a7dc11b4..1f06539263 100644 --- a/drivers/net/zxdh/zxdh_np.c +++ b/drivers/net/zxdh/zxdh_np.c @@ -36,6 +36,10 @@ ZXDH_SDT_TBL_DATA_T g_sdt_info[ZXDH_DEV_CHANNEL_MAX][ZXDH_DEV_SDT_ID_MAX]; #define ZXDH_COMM_GET_BIT_MASK(_inttype_, _bitqnt_)\ ((_inttype_)(((_bitqnt_) < 32))) +#define ZXDH_COMM_UINT32_GET_BITS(_uidst_, _uisrc_, _uistartpos_, _uilen_)\ + ((_uidst_) = (((_uisrc_) >> (_uistartpos_)) & \ + (ZXDH_COMM_GET_BIT_MASK(uint32_t, (_uilen_))))) + #define ZXDH_REG_DATA_MAX (128) #define ZXDH_COMM_CHECK_DEV_POINT(dev_id, point)\ @@ -1456,15 +1460,11 @@ zxdh_np_dtb_table_entry_write(uint32_t dev_id, return rc; } -static uint32_t +static void zxdh_np_sdt_tbl_data_get(uint32_t dev_id, uint32_t sdt_no, ZXDH_SDT_TBL_DATA_T *p_sdt_data) { - uint32_t rc = 0; - p_sdt_data->data_high32 = g_sdt_info[dev_id][sdt_no].data_high32; p_sdt_data->data_low32 = g_sdt_info[dev_id][sdt_no].data_low32; - - return rc; } int @@ -1507,7 +1507,7 @@ zxdh_np_dtb_table_entry_delete(uint32_t dev_id, pentry = delete_entries + entry_index; sdt_no = pentry->sdt_no; - rc = zxdh_np_sdt_tbl_data_get(dev_id, sdt_no, &sdt_tbl); + zxdh_np_sdt_tbl_data_get(dev_id, sdt_no, &sdt_tbl); switch (tbl_type) { case ZXDH_SDT_TBLT_ERAM: { @@ -1557,3 +1557,163 @@ zxdh_np_dtb_table_entry_delete(uint32_t dev_id, rte_free(p_data_buff_ex); return 0; } + +static uint32_t +zxdh_np_sdt_tbl_data_parser(uint32_t sdt_hig32, uint32_t sdt_low32, void *p_sdt_info) +{ + uint32_t tbl_type = 0; + uint32_t clutch_en = 0; + + ZXDH_SDTTBL_ERAM_T *p_sdt_eram = NULL; + ZXDH_SDTTBL_PORTTBL_T *p_sdt_porttbl = NULL; + + ZXDH_COMM_UINT32_GET_BITS(tbl_type, sdt_hig32, + ZXDH_SDT_H_TBL_TYPE_BT_POS, ZXDH_SDT_H_TBL_TYPE_BT_LEN); + ZXDH_COMM_UINT32_GET_BITS(clutch_en, sdt_low32, 0, 1); + + switch (tbl_type) { + case ZXDH_SDT_TBLT_ERAM: + { + p_sdt_eram = (ZXDH_SDTTBL_ERAM_T *)p_sdt_info; + p_sdt_eram->table_type = tbl_type; + p_sdt_eram->eram_clutch_en = clutch_en; + break; + } + + case ZXDH_SDT_TBLT_PORTTBL: + { + p_sdt_porttbl = (ZXDH_SDTTBL_PORTTBL_T *)p_sdt_info; + p_sdt_porttbl->table_type = tbl_type; + p_sdt_porttbl->porttbl_clutch_en = clutch_en; + break; + } + default: + { + PMD_DRV_LOG(ERR, "SDT table_type[ %d ] is invalid!", tbl_type); + return 1; + } + } + + return 0; +} + +static uint32_t +zxdh_np_soft_sdt_tbl_get(uint32_t dev_id, uint32_t sdt_no, void *p_sdt_info) +{ + ZXDH_SDT_TBL_DATA_T sdt_tbl = {0}; + uint32_t rc; + + zxdh_np_sdt_tbl_data_get(dev_id, sdt_no, &sdt_tbl); + + rc = zxdh_np_sdt_tbl_data_parser(sdt_tbl.data_high32, sdt_tbl.data_low32, p_sdt_info); + if (rc != 0) + PMD_DRV_LOG(ERR, "dpp sdt [%d] tbl_data_parser error.", sdt_no); + + return rc; +} + +static void +zxdh_np_eram_index_cal(uint32_t eram_mode, uint32_t index, + uint32_t *p_row_index, uint32_t *p_col_index) +{ + uint32_t row_index = 0; + uint32_t col_index = 0; + + switch (eram_mode) { + case ZXDH_ERAM128_TBL_128b: + { + row_index = index; + break; + } + case ZXDH_ERAM128_TBL_64b: + { + row_index = (index >> 1); + col_index = index & 0x1; + break; + } + case ZXDH_ERAM128_TBL_1b: + { + row_index = (index >> 7); + col_index = index & 0x7F; + break; + } + } + *p_row_index = row_index; + *p_col_index = col_index; +} + +static uint32_t +zxdh_np_dtb_eram_data_get(uint32_t dev_id, uint32_t queue_id, uint32_t sdt_no, + ZXDH_DTB_ERAM_ENTRY_INFO_T *p_dump_eram_entry) +{ + uint32_t index = p_dump_eram_entry->index; + uint32_t *p_data = p_dump_eram_entry->p_data; + ZXDH_SDTTBL_ERAM_T sdt_eram_info = {0}; + uint32_t temp_data[4] = {0}; + uint32_t row_index = 0; + uint32_t col_index = 0; + uint32_t rd_mode; + uint32_t rc; + + rc = zxdh_np_soft_sdt_tbl_get(queue_id, sdt_no, &sdt_eram_info); + ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "dpp_soft_sdt_tbl_get"); + rd_mode = sdt_eram_info.eram_mode; + + zxdh_np_eram_index_cal(rd_mode, index, &row_index, &col_index); + + switch (rd_mode) { + case ZXDH_ERAM128_TBL_128b: + { + memcpy(p_data, temp_data, (128 / 8)); + break; + } + case ZXDH_ERAM128_TBL_64b: + { + memcpy(p_data, temp_data + ((1 - col_index) << 1), (64 / 8)); + break; + } + case ZXDH_ERAM128_TBL_1b: + { + ZXDH_COMM_UINT32_GET_BITS(p_data[0], *(temp_data + + (3 - col_index / 32)), (col_index % 32), 1); + break; + } + } + return rc; +} + +int +zxdh_np_dtb_table_entry_get(uint32_t dev_id, + uint32_t queue_id, + ZXDH_DTB_USER_ENTRY_T *get_entry, + uint32_t srh_mode) +{ + ZXDH_SDT_TBL_DATA_T sdt_tbl = {0}; + uint32_t tbl_type = 0; + uint32_t rc; + uint32_t sdt_no; + + sdt_no = get_entry->sdt_no; + zxdh_np_sdt_tbl_data_get(srh_mode, sdt_no, &sdt_tbl); + + ZXDH_COMM_UINT32_GET_BITS(tbl_type, sdt_tbl.data_high32, + ZXDH_SDT_H_TBL_TYPE_BT_POS, ZXDH_SDT_H_TBL_TYPE_BT_LEN); + switch (tbl_type) { + case ZXDH_SDT_TBLT_ERAM: + { + rc = zxdh_np_dtb_eram_data_get(dev_id, + queue_id, + sdt_no, + (ZXDH_DTB_ERAM_ENTRY_INFO_T *)get_entry->p_entry_data); + ZXDH_COMM_CHECK_RC_NO_ASSERT(rc, "dpp_dtb_eram_data_get"); + break; + } + default: + { + PMD_DRV_LOG(ERR, "SDT table_type[ %d ] is invalid!", tbl_type); + return 1; + } + } + + return 0; +} diff --git a/drivers/net/zxdh/zxdh_np.h b/drivers/net/zxdh/zxdh_np.h index 42a652dd6b..ac3931ba65 100644 --- a/drivers/net/zxdh/zxdh_np.h +++ b/drivers/net/zxdh/zxdh_np.h @@ -514,11 +514,31 @@ typedef struct zxdh_sdt_tbl_data_t { uint32_t data_low32; } ZXDH_SDT_TBL_DATA_T; +typedef struct zxdh_sdt_tbl_etcam_t { + uint32_t table_type; + uint32_t etcam_id; + uint32_t etcam_key_mode; + uint32_t etcam_table_id; + uint32_t no_as_rsp_mode; + uint32_t as_en; + uint32_t as_eram_baddr; + uint32_t as_rsp_mode; + uint32_t etcam_table_depth; + uint32_t etcam_clutch_en; +} ZXDH_SDTTBL_ETCAM_T; + +typedef struct zxdh_sdt_tbl_porttbl_t { + uint32_t table_type; + uint32_t porttbl_clutch_en; +} ZXDH_SDTTBL_PORTTBL_T; + 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, uint32_t entrynum, ZXDH_DTB_USER_ENTRY_T *down_entries); int zxdh_np_dtb_table_entry_delete(uint32_t dev_id, uint32_t queue_id, uint32_t entrynum, ZXDH_DTB_USER_ENTRY_T *delete_entries); +int zxdh_np_dtb_table_entry_get(uint32_t dev_id, uint32_t queue_id, + ZXDH_DTB_USER_ENTRY_T *get_entry, uint32_t srh_mode); #endif /* ZXDH_NP_H */ diff --git a/drivers/net/zxdh/zxdh_tables.c b/drivers/net/zxdh/zxdh_tables.c index 9fd184e612..db0132ce3f 100644 --- a/drivers/net/zxdh/zxdh_tables.c +++ b/drivers/net/zxdh/zxdh_tables.c @@ -134,3 +134,18 @@ int zxdh_panel_table_init(struct rte_eth_dev *dev) return ret; } + +int +zxdh_get_port_attr(uint16_t vfid, struct zxdh_port_attr_table *port_attr) +{ + int ret; + + 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}; + + ret = zxdh_np_dtb_table_entry_get(ZXDH_DEVICE_NO, g_dtb_data.queueid, &user_entry_get, 1); + if (ret != 0) + PMD_DRV_LOG(ERR, "get port_attr vfid:%d failed, ret:%d ", vfid, ret); + + return ret; +} diff --git a/drivers/net/zxdh/zxdh_tables.h b/drivers/net/zxdh/zxdh_tables.h index 5e9b36faee..8676a8b375 100644 --- a/drivers/net/zxdh/zxdh_tables.h +++ b/drivers/net/zxdh/zxdh_tables.h @@ -7,9 +7,10 @@ #include -extern struct zxdh_dtb_shared_data g_dtb_data; - #define ZXDH_DEVICE_NO 0 +#define ZXDH_PORT_ATTR_IS_UP_FLAG 35 + +extern struct zxdh_dtb_shared_data g_dtb_data; struct zxdh_port_attr_table { #if RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN @@ -145,5 +146,6 @@ int zxdh_port_attr_init(struct rte_eth_dev *dev); int zxdh_panel_table_init(struct rte_eth_dev *dev); int zxdh_set_port_attr(uint16_t vfid, struct zxdh_port_attr_table *port_attr); int zxdh_port_attr_uninit(struct rte_eth_dev *dev); +int zxdh_get_port_attr(uint16_t vfid, struct zxdh_port_attr_table *port_attr); #endif /* ZXDH_TABLES_H */ -- 2.27.0