Add agent channel to access (np)network processor registers
that are not mapped by PCIE.
Signed-off-by: Bingbin Chen <chen.bingbin@zte.com.cn>
---
drivers/net/zxdh/zxdh_np.c | 449 +++++++++++++++++++++++++++++++------
drivers/net/zxdh/zxdh_np.h | 63 +++++-
2 files changed, 442 insertions(+), 70 deletions(-)
diff --git a/drivers/net/zxdh/zxdh_np.c b/drivers/net/zxdh/zxdh_np.c
index 5ed78fde82..8113332310 100644
--- a/drivers/net/zxdh/zxdh_np.c
+++ b/drivers/net/zxdh/zxdh_np.c
@@ -394,6 +394,70 @@ zxdh_np_dev_init(void)
return 0;
}
+static void
+zxdh_np_dev_vport_get(uint32_t dev_id, uint32_t *vport)
+{
+ ZXDH_DEV_MGR_T *p_dev_mgr = &g_dev_mgr;
+ ZXDH_DEV_CFG_T *p_dev_info = p_dev_mgr->p_dev_array[dev_id];
+
+ *vport = p_dev_info->vport;
+}
+
+static void
+zxdh_np_dev_agent_addr_get(uint32_t dev_id, uint64_t *agent_addr)
+{
+ ZXDH_DEV_MGR_T *p_dev_mgr = &g_dev_mgr;
+ ZXDH_DEV_CFG_T *p_dev_info = p_dev_mgr->p_dev_array[dev_id];
+
+ *agent_addr = p_dev_info->agent_addr;
+}
+
+static void
+zxdh_np_dev_fw_bar_msg_num_set(uint32_t dev_id, uint32_t bar_msg_num)
+{
+ ZXDH_DEV_MGR_T *p_dev_mgr = &g_dev_mgr;
+ ZXDH_DEV_CFG_T *p_dev_info = p_dev_mgr->p_dev_array[dev_id];
+
+ p_dev_info->fw_bar_msg_num = bar_msg_num;
+
+ PMD_DRV_LOG(INFO, "fw_bar_msg_num_set:fw support agent msg num = %u!", bar_msg_num);
+}
+
+static void
+zxdh_np_dev_fw_bar_msg_num_get(uint32_t dev_id, uint32_t *bar_msg_num)
+{
+ ZXDH_DEV_MGR_T *p_dev_mgr = &g_dev_mgr;
+ ZXDH_DEV_CFG_T *p_dev_info = p_dev_mgr->p_dev_array[dev_id];
+
+ *bar_msg_num = p_dev_info->fw_bar_msg_num;
+}
+
+static uint32_t
+zxdh_np_dev_opr_spinlock_get(uint32_t dev_id, uint32_t type, ZXDH_SPINLOCK_T **p_spinlock_out)
+{
+ ZXDH_DEV_MGR_T *p_dev_mgr = &g_dev_mgr;
+ ZXDH_DEV_CFG_T *p_dev_info = p_dev_mgr->p_dev_array[dev_id];
+
+ if (p_dev_info == NULL) {
+ PMD_DRV_LOG(ERR, "Get dev_info[ %d ] fail!", dev_id);
+ return ZXDH_DEV_TYPE_INVALID;
+ }
+
+ switch (type) {
+ case ZXDH_DEV_SPINLOCK_T_DTB:
+ *p_spinlock_out = &p_dev_info->dtb_spinlock;
+ break;
+ case ZXDH_DEV_SPINLOCK_T_SMMU0:
+ *p_spinlock_out = &p_dev_info->smmu0_spinlock;
+ break;
+ default:
+ PMD_DRV_LOG(ERR, "spinlock type is invalid!");
+ return ZXDH_ERR;
+ }
+
+ return ZXDH_OK;
+}
+
static uint32_t
zxdh_np_dev_read_channel(uint32_t dev_id, uint32_t addr, uint32_t size, uint32_t *p_data)
{
@@ -827,6 +891,9 @@ zxdh_np_dev_add(uint32_t dev_id, ZXDH_DEV_TYPE_E dev_type,
p_dev_info->p_pcie_write_fun = zxdh_np_dev_pcie_default_write;
p_dev_info->p_pcie_read_fun = zxdh_np_dev_pcie_default_read;
+ rte_spinlock_init(&p_dev_info->dtb_spinlock.spinlock);
+ rte_spinlock_init(&p_dev_info->smmu0_spinlock.spinlock);
+
return 0;
}
@@ -918,6 +985,269 @@ zxdh_np_ppu_parse_cls_bitmap(uint32_t dev_id,
}
}
+static void
+zxdh_np_agent_msg_prt(uint8_t type, uint32_t rtn)
+{
+ switch (rtn) {
+ case ZXDH_RC_CTRLCH_MSG_LEN_ZERO:
+ PMD_DRV_LOG(ERR, "type[%u]:msg len is zero!", type);
+ break;
+ case ZXDH_RC_CTRLCH_MSG_PRO_ERR:
+ PMD_DRV_LOG(ERR, "type[%u]:msg process error!", type);
+ break;
+ case ZXDH_RC_CTRLCH_MSG_TYPE_NOT_SUPPORT:
+ PMD_DRV_LOG(ERR, "type[%u]:fw not support the msg!", type);
+ break;
+ case ZXDH_RC_CTRLCH_MSG_OPER_NOT_SUPPORT:
+ PMD_DRV_LOG(ERR, "type[%u]:fw not support opr of the msg!", type);
+ break;
+ case ZXDH_RC_CTRLCH_MSG_DROP:
+ PMD_DRV_LOG(ERR, "type[%u]:fw not support,drop msg!", type);
+ break;
+ default:
+ break;
+ }
+}
+
+static uint32_t
+zxdh_np_agent_bar_msg_check(uint32_t dev_id, ZXDH_AGENT_CHANNEL_MSG_T *p_msg)
+{
+ uint8_t type = 0;
+ uint32_t bar_msg_num = 0;
+
+ type = *((uint8_t *)(p_msg->msg) + 1);
+ if (type != ZXDH_PCIE_BAR_MSG) {
+ zxdh_np_dev_fw_bar_msg_num_get(dev_id, &bar_msg_num);
+ if (type >= bar_msg_num) {
+ PMD_DRV_LOG(ERR, "type[%u] > fw_bar_msg_num[%u]!", type, bar_msg_num);
+ return ZXDH_RC_CTRLCH_MSG_TYPE_NOT_SUPPORT;
+ }
+ }
+
+ return ZXDH_OK;
+}
+
+static uint32_t
+zxdh_np_agent_channel_sync_send(uint32_t dev_id,
+ ZXDH_AGENT_CHANNEL_MSG_T *p_msg,
+ uint32_t *p_data,
+ uint32_t rep_len)
+{
+ uint32_t ret = ZXDH_OK;
+ uint32_t vport = 0;
+ struct zxdh_pci_bar_msg in = {0};
+ struct zxdh_msg_recviver_mem result = {0};
+ uint32_t *recv_buffer = NULL;
+ uint8_t *reply_ptr = NULL;
+ uint16_t reply_msg_len = 0;
+ uint64_t agent_addr = 0;
+
+ ret = zxdh_np_agent_bar_msg_check(dev_id, p_msg);
+ if (ret != ZXDH_OK) {
+ PMD_DRV_LOG(ERR, "zxdh_np_agent_bar_msg_check failed!");
+ return ret;
+ }
+
+ zxdh_np_dev_vport_get(dev_id, &vport);
+ zxdh_np_dev_agent_addr_get(dev_id, &agent_addr);
+
+ if (ZXDH_IS_PF(vport))
+ in.src = ZXDH_MSG_CHAN_END_PF;
+ else
+ in.src = ZXDH_MSG_CHAN_END_VF;
+
+ in.virt_addr = agent_addr;
+ in.payload_addr = p_msg->msg;
+ in.payload_len = p_msg->msg_len;
+ in.dst = ZXDH_MSG_CHAN_END_RISC;
+ in.module_id = ZXDH_BAR_MDOULE_NPSDK;
+
+ recv_buffer = (uint32_t *)rte_zmalloc(NULL, rep_len + ZXDH_CHANNEL_REPS_LEN, 0);
+ if (recv_buffer == NULL) {
+ PMD_DRV_LOG(ERR, "malloc memory failed");
+ return ZXDH_PAR_CHK_POINT_NULL;
+ }
+
+ result.buffer_len = rep_len + ZXDH_CHANNEL_REPS_LEN;
+ result.recv_buffer = recv_buffer;
+
+ ret = zxdh_bar_chan_sync_msg_send(&in, &result);
+ if (ret == ZXDH_BAR_MSG_OK) {
+ reply_ptr = (uint8_t *)(result.recv_buffer);
+ if (*reply_ptr == 0XFF) {
+ reply_msg_len = *(uint16_t *)(reply_ptr + 1);
+ memcpy(p_data, reply_ptr + 4,
+ ((reply_msg_len > rep_len) ? rep_len : reply_msg_len));
+ } else {
+ PMD_DRV_LOG(ERR, "Message not replied");
+ }
+ } else {
+ PMD_DRV_LOG(ERR, "Error[0x%x], bar msg send failed!", ret);
+ }
+
+ rte_free(recv_buffer);
+ return ret;
+}
+
+static uint32_t
+zxdh_np_agent_channel_reg_sync_send(uint32_t dev_id,
+ ZXDH_AGENT_CHANNEL_REG_MSG_T *p_msg, uint32_t *p_data, uint32_t rep_len)
+{
+ uint32_t ret = ZXDH_OK;
+ ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_msg);
+ ZXDH_AGENT_CHANNEL_MSG_T agent_msg = {
+ .msg = (void *)p_msg,
+ .msg_len = sizeof(ZXDH_AGENT_CHANNEL_REG_MSG_T),
+ };
+
+ ret = zxdh_np_agent_channel_sync_send(dev_id, &agent_msg, p_data, rep_len);
+ if (ret != ZXDH_OK) {
+ PMD_DRV_LOG(ERR, "zxdh_np_agent_channel_sync_send failed");
+ return ZXDH_ERR;
+ }
+
+ ret = *p_data;
+ if (ret != ZXDH_OK) {
+ PMD_DRV_LOG(ERR, "zxdh_np_agent_channel_sync_send failed in buffer");
+ return ZXDH_ERR;
+ }
+
+ return ret;
+}
+
+static uint32_t
+zxdh_np_agent_channel_pcie_bar_request(uint32_t dev_id,
+ uint32_t *p_bar_msg_num)
+{
+ uint32_t rc = ZXDH_OK;
+ uint32_t rsp_buff[2] = {0};
+ uint32_t msg_result = 0;
+ uint32_t bar_msg_num = 0;
+ ZXDH_AGENT_PCIE_BAR_MSG_T msgcfg = {
+ .dev_id = 0,
+ .type = ZXDH_PCIE_BAR_MSG,
+ .oper = ZXDH_BAR_MSG_NUM_REQ,
+ };
+ ZXDH_AGENT_CHANNEL_MSG_T agent_msg = {
+ .msg = (void *)&msgcfg,
+ .msg_len = sizeof(ZXDH_AGENT_PCIE_BAR_MSG_T),
+ };
+
+ rc = zxdh_np_agent_channel_sync_send(dev_id, &agent_msg, rsp_buff, sizeof(rsp_buff));
+ if (rc != ZXDH_OK) {
+ PMD_DRV_LOG(ERR, "zxdh_np_agent_channel_sync_send failed!");
+ return rc;
+ }
+
+ msg_result = rsp_buff[0];
+ bar_msg_num = rsp_buff[1];
+
+ zxdh_np_agent_msg_prt(msgcfg.type, msg_result);
+
+ *p_bar_msg_num = bar_msg_num;
+
+ return msg_result;
+}
+
+static uint32_t
+zxdh_np_agent_channel_reg_read(uint32_t dev_id,
+ uint32_t reg_type,
+ uint32_t reg_no,
+ uint32_t reg_width,
+ uint32_t addr,
+ uint32_t *p_data)
+{
+ uint32_t ret = 0;
+ ZXDH_AGENT_CHANNEL_REG_MSG_T msgcfg = {
+ .dev_id = 0,
+ .type = ZXDH_REG_MSG,
+ .subtype = reg_type,
+ .oper = ZXDH_RD,
+ .reg_no = reg_no,
+ .addr = addr,
+ .val_len = reg_width / 4,
+ };
+
+ uint32_t resp_len = reg_width + 4;
+ uint8_t *resp_buffer = (uint8_t *)rte_zmalloc(NULL, resp_len, 0);
+ if (resp_buffer == NULL) {
+ PMD_DRV_LOG(ERR, "malloc memory failed");
+ return ZXDH_PAR_CHK_POINT_NULL;
+ }
+
+ ret = zxdh_np_agent_channel_reg_sync_send(dev_id,
+ &msgcfg, (uint32_t *)resp_buffer, resp_len);
+ if (ret != ZXDH_OK) {
+ PMD_DRV_LOG(ERR, "dev id %d reg_no %d send agent read failed.", dev_id, reg_no);
+ rte_free(resp_buffer);
+ return ZXDH_ERR;
+ }
+
+ if (*((uint32_t *)resp_buffer) != ZXDH_OK) {
+ PMD_DRV_LOG(ERR, "dev id %d reg_no %d agent read resp err %d .",
+ dev_id, reg_no, *((uint32_t *)resp_buffer));
+ rte_free(resp_buffer);
+ return ZXDH_ERR;
+ }
+
+ memcpy(p_data, resp_buffer + 4, reg_width);
+
+ rte_free(resp_buffer);
+
+ return ret;
+}
+
+static uint32_t
+zxdh_np_agent_channel_reg_write(uint32_t dev_id,
+ uint32_t reg_type,
+ uint32_t reg_no,
+ uint32_t reg_width,
+ uint32_t addr,
+ uint32_t *p_data)
+{
+ uint32_t ret = ZXDH_OK;
+ ZXDH_AGENT_CHANNEL_REG_MSG_T msgcfg = {
+ .dev_id = 0,
+ .type = ZXDH_REG_MSG,
+ .subtype = reg_type,
+ .oper = ZXDH_WR,
+ .reg_no = reg_no,
+ .addr = addr,
+ .val_len = reg_width / 4,
+ };
+
+ memcpy(msgcfg.val, p_data, reg_width);
+
+ uint32_t resp_len = reg_width + 4;
+ uint8_t *resp_buffer = (uint8_t *)rte_zmalloc(NULL, resp_len, 0);
+ if (resp_buffer == NULL) {
+ PMD_DRV_LOG(ERR, "malloc memory failed");
+ return ZXDH_PAR_CHK_POINT_NULL;
+ }
+
+ ret = zxdh_np_agent_channel_reg_sync_send(dev_id,
+ &msgcfg, (uint32_t *)resp_buffer, resp_len);
+
+ if (ret != ZXDH_OK) {
+ PMD_DRV_LOG(ERR, "dev id %d reg_no %d send agent write failed.", dev_id, reg_no);
+ rte_free(resp_buffer);
+ return ZXDH_ERR;
+ }
+
+ if (*((uint32_t *)resp_buffer) != ZXDH_OK) {
+ PMD_DRV_LOG(ERR, "dev id %d reg_no %d agent write resp err %d .",
+ dev_id, reg_no, *((uint32_t *)resp_buffer));
+ rte_free(resp_buffer);
+ return ZXDH_ERR;
+ }
+
+ memcpy(p_data, resp_buffer + 4, reg_width);
+
+ rte_free(resp_buffer);
+
+ return ret;
+}
+
static ZXDH_DTB_MGR_T *
zxdh_np_dtb_mgr_get(uint32_t dev_id)
{
@@ -1128,6 +1458,24 @@ zxdh_np_np_sdk_version_compatible_check(uint32_t dev_id)
return ZXDH_OK;
}
+static uint32_t
+zxdh_np_pcie_bar_msg_num_get(uint32_t dev_id, uint32_t *p_bar_msg_num)
+{
+ uint32_t rc = ZXDH_OK;
+ ZXDH_SPINLOCK_T *p_dtb_spinlock = NULL;
+ ZXDH_DEV_SPINLOCK_TYPE_E spinlock = ZXDH_DEV_SPINLOCK_T_DTB;
+
+ rc = zxdh_np_dev_opr_spinlock_get(dev_id, (uint32_t)spinlock, &p_dtb_spinlock);
+ ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_dev_opr_spinlock_get");
+
+ rte_spinlock_lock(&p_dtb_spinlock->spinlock);
+ rc = zxdh_np_agent_channel_pcie_bar_request(dev_id, p_bar_msg_num);
+ ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_agent_channel_pcie_bar_request");
+ rte_spinlock_unlock(&p_dtb_spinlock->spinlock);
+
+ return rc;
+}
+
static ZXDH_RISCV_DTB_MGR *
zxdh_np_riscv_dtb_queue_mgr_get(uint32_t dev_id)
{
@@ -1246,12 +1594,19 @@ zxdh_np_reg_read(uint32_t dev_id, uint32_t reg_no,
uint32_t i;
uint32_t addr = 0;
uint32_t reg_module = p_reg_info->module_no;
+ uint32_t reg_width = p_reg_info->width;
+ uint32_t reg_real_no = p_reg_info->reg_no;
+ uint32_t reg_type = p_reg_info->flags;
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_buff);
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, reg_width, addr, p_buff);
+ ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_agent_channel_reg_read");
}
if (!zxdh_np_comm_is_big_endian()) {
@@ -1383,6 +1738,9 @@ zxdh_np_reg_write(uint32_t dev_id, uint32_t reg_no,
uint32_t i;
uint32_t addr = 0;
uint32_t reg_module = p_reg_info->module_no;
+ uint32_t reg_width = p_reg_info->width;
+ uint32_t reg_type = p_reg_info->flags;
+ uint32_t reg_real_no = p_reg_info->reg_no;
for (i = 0; i < p_reg_info->field_num; i++) {
if (p_field_info[i].len <= 32) {
@@ -1417,6 +1775,10 @@ zxdh_np_reg_write(uint32_t dev_id, uint32_t reg_no,
if (reg_module == DTB4K) {
rc = p_reg_info->p_write_fun(dev_id, addr, p_buff);
ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "p_reg_info->p_write_fun");
+ } else {
+ rc = zxdh_np_agent_channel_reg_write(dev_id,
+ reg_type, reg_real_no, reg_width, addr, p_buff);
+ ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_agent_channel_reg_write");
}
return rc;
@@ -1790,7 +2152,7 @@ zxdh_np_dtb_eram_one_entry(uint32_t dev_id,
uint32_t base_addr;
uint32_t index;
uint32_t opr_mode;
- uint32_t rc;
+ uint32_t rc = ZXDH_OK;
ZXDH_COMM_CHECK_POINT(pdata);
ZXDH_COMM_CHECK_POINT(p_dtb_one_entry);
@@ -2687,6 +3049,7 @@ zxdh_np_host_init(uint32_t dev_id,
ZXDH_SYS_INIT_CTRL_T sys_init_ctrl = {0};
uint32_t rc;
uint64_t agent_addr;
+ uint32_t bar_msg_num = 0;
ZXDH_COMM_CHECK_DEV_POINT(dev_id, p_dev_init_ctrl);
@@ -2708,6 +3071,11 @@ zxdh_np_host_init(uint32_t dev_id,
rc = zxdh_np_np_sdk_version_compatible_check(dev_id);
ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_np_sdk_version_compatible_check");
+ rc = zxdh_np_pcie_bar_msg_num_get(dev_id, &bar_msg_num);
+ ZXDH_COMM_CHECK_DEV_RC(dev_id, rc, "zxdh_np_pcie_bar_msg_num_get");
+
+ zxdh_np_dev_fw_bar_msg_num_set(dev_id, bar_msg_num);
+
return 0;
}
@@ -2942,59 +3310,7 @@ zxdh_np_stat_ppu_cnt_get_ex(uint32_t dev_id,
}
static uint32_t
-zxdh_np_agent_channel_sync_send(ZXDH_AGENT_CHANNEL_MSG_T *p_msg,
- uint32_t *p_data,
- uint32_t rep_len)
-{
- uint32_t ret = 0;
- uint32_t vport = 0;
- struct zxdh_pci_bar_msg in = {0};
- struct zxdh_msg_recviver_mem result = {0};
- uint32_t *recv_buffer;
- uint8_t *reply_ptr = NULL;
- uint16_t reply_msg_len = 0;
- uint64_t agent_addr = 0;
-
- if (ZXDH_IS_PF(vport))
- in.src = ZXDH_MSG_CHAN_END_PF;
- else
- in.src = ZXDH_MSG_CHAN_END_VF;
-
- in.virt_addr = agent_addr;
- in.payload_addr = p_msg->msg;
- in.payload_len = p_msg->msg_len;
- in.dst = ZXDH_MSG_CHAN_END_RISC;
- in.module_id = ZXDH_BAR_MDOULE_NPSDK;
-
- recv_buffer = (uint32_t *)rte_zmalloc(NULL, rep_len + ZXDH_CHANNEL_REPS_LEN, 0);
- if (recv_buffer == NULL) {
- PMD_DRV_LOG(ERR, "%s point null!", __func__);
- return ZXDH_PAR_CHK_POINT_NULL;
- }
-
- result.buffer_len = rep_len + ZXDH_CHANNEL_REPS_LEN;
- result.recv_buffer = recv_buffer;
-
- ret = zxdh_bar_chan_sync_msg_send(&in, &result);
- if (ret == ZXDH_BAR_MSG_OK) {
- reply_ptr = (uint8_t *)(result.recv_buffer);
- if (*reply_ptr == 0XFF) {
- reply_msg_len = *(uint16_t *)(reply_ptr + 1);
- memcpy(p_data, reply_ptr + 4,
- ((reply_msg_len > rep_len) ? rep_len : reply_msg_len));
- } else {
- PMD_DRV_LOG(ERR, "Message not replied");
- }
- } else {
- PMD_DRV_LOG(ERR, "Error[0x%x], %s failed!", ret, __func__);
- }
-
- rte_free(recv_buffer);
- return ret;
-}
-
-static uint32_t
-zxdh_np_agent_channel_plcr_sync_send(ZXDH_AGENT_CHANNEL_PLCR_MSG_T *p_msg,
+zxdh_np_agent_channel_plcr_sync_send(uint32_t dev_id, ZXDH_AGENT_CHANNEL_PLCR_MSG_T *p_msg,
uint32_t *p_data, uint32_t rep_len)
{
uint32_t ret = 0;
@@ -3003,7 +3319,7 @@ zxdh_np_agent_channel_plcr_sync_send(ZXDH_AGENT_CHANNEL_PLCR_MSG_T *p_msg,
agent_msg.msg = (void *)p_msg;
agent_msg.msg_len = sizeof(ZXDH_AGENT_CHANNEL_PLCR_MSG_T);
- ret = zxdh_np_agent_channel_sync_send(&agent_msg, p_data, rep_len);
+ ret = zxdh_np_agent_channel_sync_send(dev_id, &agent_msg, p_data, rep_len);
if (ret != 0) {
PMD_DRV_LOG(ERR, "%s: agent_channel_sync_send failed.", __func__);
return 1;
@@ -3013,7 +3329,7 @@ zxdh_np_agent_channel_plcr_sync_send(ZXDH_AGENT_CHANNEL_PLCR_MSG_T *p_msg,
}
static uint32_t
-zxdh_np_agent_channel_plcr_profileid_request(uint32_t vport,
+zxdh_np_agent_channel_plcr_profileid_request(uint32_t dev_id, uint32_t vport,
uint32_t car_type, uint32_t *p_profileid)
{
uint32_t ret = 0;
@@ -3028,7 +3344,7 @@ zxdh_np_agent_channel_plcr_profileid_request(uint32_t vport,
msgcfg.car_type = car_type;
msgcfg.profile_id = 0xFFFF;
- ret = zxdh_np_agent_channel_plcr_sync_send(&msgcfg,
+ ret = zxdh_np_agent_channel_plcr_sync_send(dev_id, &msgcfg,
resp_buffer, sizeof(resp_buffer));
if (ret != 0) {
PMD_DRV_LOG(ERR, "%s: agent_channel_plcr_sync_send failed.", __func__);
@@ -3041,7 +3357,8 @@ zxdh_np_agent_channel_plcr_profileid_request(uint32_t vport,
}
static uint32_t
-zxdh_np_agent_channel_plcr_car_rate(uint32_t car_type,
+zxdh_np_agent_channel_plcr_car_rate(uint32_t dev_id,
+ uint32_t car_type,
uint32_t pkt_sign,
uint32_t profile_id __rte_unused,
void *p_car_profile_cfg)
@@ -3071,7 +3388,7 @@ zxdh_np_agent_channel_plcr_car_rate(uint32_t car_type,
agent_msg.msg = (void *)&msgpktcfg;
agent_msg.msg_len = sizeof(ZXDH_AGENT_CAR_PKT_PROFILE_MSG_T);
- ret = zxdh_np_agent_channel_sync_send(&agent_msg, resp_buffer, resp_len);
+ ret = zxdh_np_agent_channel_sync_send(dev_id, &agent_msg, resp_buffer, resp_len);
if (ret != 0) {
PMD_DRV_LOG(ERR, "%s: stat_car_a_type failed.", __func__);
return 1;
@@ -3105,7 +3422,7 @@ zxdh_np_agent_channel_plcr_car_rate(uint32_t car_type,
agent_msg.msg = (void *)&msgcfg;
agent_msg.msg_len = sizeof(ZXDH_AGENT_CAR_PROFILE_MSG_T);
- ret = zxdh_np_agent_channel_sync_send(&agent_msg, resp_buffer, resp_len);
+ ret = zxdh_np_agent_channel_sync_send(dev_id, &agent_msg, resp_buffer, resp_len);
if (ret != 0) {
PMD_DRV_LOG(ERR, "%s: stat_car_b_type failed.", __func__);
return 1;
@@ -3118,7 +3435,7 @@ zxdh_np_agent_channel_plcr_car_rate(uint32_t car_type,
}
static uint32_t
-zxdh_np_agent_channel_plcr_profileid_release(uint32_t vport,
+zxdh_np_agent_channel_plcr_profileid_release(uint32_t dev_id, uint32_t vport,
uint32_t car_type __rte_unused,
uint32_t profileid)
{
@@ -3133,7 +3450,7 @@ zxdh_np_agent_channel_plcr_profileid_release(uint32_t vport,
msgcfg.vport = vport;
msgcfg.profile_id = profileid;
- ret = zxdh_np_agent_channel_plcr_sync_send(&msgcfg,
+ ret = zxdh_np_agent_channel_plcr_sync_send(dev_id, &msgcfg,
resp_buffer, sizeof(resp_buffer));
if (ret != 0) {
PMD_DRV_LOG(ERR, "%s: agent_channel_plcr_sync_send failed.", __func__);
@@ -3234,7 +3551,7 @@ zxdh_np_car_profile_id_add(uint32_t vport_id,
PMD_DRV_LOG(ERR, "%s: profile_id point null!", __func__);
return ZXDH_PAR_CHK_POINT_NULL;
}
- ret = zxdh_np_agent_channel_plcr_profileid_request(vport_id, flags, profile_id);
+ ret = zxdh_np_agent_channel_plcr_profileid_request(0, vport_id, flags, profile_id);
profile_id_h = *(profile_id + 1);
profile_id_l = *profile_id;
@@ -3259,8 +3576,9 @@ zxdh_np_car_profile_cfg_set(uint32_t vport_id __rte_unused,
void *p_car_profile_cfg)
{
uint32_t ret = 0;
+ uint32_t dev_id = 0;
- ret = zxdh_np_agent_channel_plcr_car_rate(car_type,
+ ret = zxdh_np_agent_channel_plcr_car_rate(dev_id, car_type,
pkt_sign, profile_id, p_car_profile_cfg);
if (ret != 0) {
PMD_DRV_LOG(ERR, "%s: plcr_car_rate set failed!", __func__);
@@ -3276,10 +3594,11 @@ zxdh_np_car_profile_id_delete(uint32_t vport_id,
{
uint32_t ret = 0;
uint32_t profileid = 0;
+ uint32_t dev_id = 0;
profileid = profile_id & 0xFFFF;
- ret = zxdh_np_agent_channel_plcr_profileid_release(vport_id, flags, profileid);
+ ret = zxdh_np_agent_channel_plcr_profileid_release(dev_id, vport_id, flags, profileid);
if (ret != 0) {
PMD_DRV_LOG(ERR, "%s: plcr profiled id release failed!", __func__);
return 1;
diff --git a/drivers/net/zxdh/zxdh_np.h b/drivers/net/zxdh/zxdh_np.h
index d6ceecf3f8..c8fc8ea613 100644
--- a/drivers/net/zxdh/zxdh_np.h
+++ b/drivers/net/zxdh/zxdh_np.h
@@ -112,9 +112,17 @@
#define ZXDH_SE_SMMU0_ERAM_ADDR_NUM_TOTAL \
(ZXDH_SE_SMMU0_ERAM_BLOCK_NUM * ZXDH_SE_SMMU0_ERAM_ADDR_NUM_PER_BLOCK)
+#define ZXDH_CHANNEL_REPS_LEN (4)
+
#define ZXDH_NPSDK_COMPAT_ITEM_ID (10)
#define ZXDH_DPU_NO_DEBUG_PF_COMPAT_REG_OFFSET (0x5400)
+#define ZXDH_VF_ACTIVE(VPORT) (((VPORT) & 0x0800) >> 11)
+#define ZXDH_EPID_BY(VPORT) (((VPORT) & 0x7000) >> 12)
+#define ZXDH_FUNC_NUM(VPORT) (((VPORT) & 0x0700) >> 8)
+#define ZXDH_VFUNC_NUM(VPORT) (((VPORT) & 0x00FF))
+#define ZXDH_IS_PF(VPORT) (!ZXDH_VF_ACTIVE(VPORT))
+
/**errco code */
#define ZXDH_RC_BASE (0x1000U)
#define ZXDH_PARAMETER_CHK_BASE (ZXDH_RC_BASE | 0x200)
@@ -127,6 +135,12 @@
#define ZXDH_PAR_CHK_INVALID_DEV_ID (ZXDH_PARAMETER_CHK_BASE | 0x007)
#define ZXDH_PAR_CHK_INVALID_PARA (ZXDH_PARAMETER_CHK_BASE | 0x008)
+#define ZXDH_SPIN_LOCK_BASE (ZXDH_RC_BASE | 0x300)
+#define ZXDH_SPIN_LOCK_INIT_FAIL (ZXDH_SPIN_LOCK_BASE | 0x001)
+#define ZXDH_SPIN_LOCK_LOCK_FAIL (ZXDH_SPIN_LOCK_BASE | 0x002)
+#define ZXDH_SPIN_LOCK_ULOCK_FAIL (ZXDH_SPIN_LOCK_BASE | 0X003)
+#define ZXDH_SPIN_LOCK_DESTROY_FAIL (ZXDH_SPIN_LOCK_BASE | 0X004)
+
#define ZXDH_ERAM128_BADDR_MASK (0x3FFFF80)
#define ZXDH_DTB_TABLE_MODE_ERAM (0)
@@ -164,6 +178,13 @@
#define ZXDH_RC_DTB_SEARCH_VPORT_QUEUE_ZERO (ZXDH_RC_DTB_BASE | 0x17)
#define ZXDH_RC_DTB_QUEUE_NOT_ENABLE (ZXDH_RC_DTB_BASE | 0x18)
+#define ZXDH_RC_CTRLCH_BASE (0xf00)
+#define ZXDH_RC_CTRLCH_MSG_LEN_ZERO (ZXDH_RC_CTRLCH_BASE | 0x0)
+#define ZXDH_RC_CTRLCH_MSG_PRO_ERR (ZXDH_RC_CTRLCH_BASE | 0x1)
+#define ZXDH_RC_CTRLCH_MSG_TYPE_NOT_SUPPORT (ZXDH_RC_CTRLCH_BASE | 0x2)
+#define ZXDH_RC_CTRLCH_MSG_OPER_NOT_SUPPORT (ZXDH_RC_CTRLCH_BASE | 0x3)
+#define ZXDH_RC_CTRLCH_MSG_DROP (ZXDH_RC_CTRLCH_BASE | 0x4)
+
#define ZXDH_SCHE_RSP_LEN (2)
#define ZXDH_G_PROFILE_ID_LEN (8)
@@ -380,6 +401,7 @@ typedef struct dpp_dev_cfg_t {
uint32_t access_type;
uint32_t agent_flag;
uint32_t vport;
+ uint32_t fw_bar_msg_num;
uint64_t pcie_addr;
uint64_t riscv_addr;
uint64_t dma_vir_addr;
@@ -388,6 +410,8 @@ typedef struct dpp_dev_cfg_t {
uint32_t init_flags[ZXDH_MODULE_INIT_MAX];
ZXDH_DEV_WRITE_FUNC p_pcie_write_fun;
ZXDH_DEV_READ_FUNC p_pcie_read_fun;
+ ZXDH_SPINLOCK_T dtb_spinlock;
+ ZXDH_SPINLOCK_T smmu0_spinlock;
} ZXDH_DEV_CFG_T;
typedef struct zxdh_dev_mngr_t {
@@ -662,6 +686,17 @@ typedef enum zxdh_stat_cnt_mode_e {
ZXDH_STAT_MAX_MODE,
} ZXDH_STAT_CNT_MODE_E;
+typedef enum zxdh_agent_pcie_bar_e {
+ ZXDH_BAR_MSG_NUM_REQ = 0,
+ ZXDH_PCIE_BAR_MAX
+} ZXDH_MSG_PCIE_BAR_E;
+
+typedef enum zxdh_agent_msg_oper_e {
+ ZXDH_WR = 0,
+ ZXDH_RD,
+ ZXDH_WR_RD_MAX
+} ZXDH_MSG_OPER_E;
+
typedef struct zxdh_smmu0_smmu0_cpu_ind_cmd_t {
uint32_t cpu_ind_rw;
uint32_t cpu_ind_rd_mode;
@@ -776,11 +811,6 @@ typedef struct dpp_agent_car_pkt_profile_msg {
uint32_t pri[ZXDH_CAR_PRI_MAX];
} ZXDH_AGENT_CAR_PKT_PROFILE_MSG_T;
-typedef struct zxdh_agent_channel_msg_t {
- uint32_t msg_len;
- void *msg;
-} ZXDH_AGENT_CHANNEL_MSG_T;
-
typedef struct zxdh_agent_channel_plcr_msg {
uint8_t dev_id;
uint8_t type;
@@ -858,6 +888,29 @@ typedef struct __rte_aligned(2) zxdh_version_compatible_reg_t {
uint8_t rsv[2];
} ZXDH_VERSION_COMPATIBLE_REG_T;
+typedef struct __rte_aligned(2) zxdh_agent_channel_pcie_bar_msg_t {
+ uint8_t dev_id;
+ uint8_t type;
+ uint8_t oper;
+ uint8_t rsv;
+} ZXDH_AGENT_PCIE_BAR_MSG_T;
+
+typedef struct __rte_aligned(2) zxdh_agent_channel_reg_msg {
+ uint8_t dev_id;
+ uint8_t type;
+ uint8_t subtype;
+ uint8_t oper;
+ uint32_t reg_no;
+ uint32_t addr;
+ uint32_t val_len;
+ uint32_t val[32];
+} ZXDH_AGENT_CHANNEL_REG_MSG_T;
+
+typedef struct __rte_aligned(2) zxdh_agent_channel_msg_t {
+ uint32_t msg_len;
+ void *msg;
+} ZXDH_AGENT_CHANNEL_MSG_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,
--
2.27.0