[PATCH v2 net-next 01/13] net: enetc: add initial netc-lib driver to support NTMP

Wei Fang
2025-01-13T08:39:51Z

Some NETC functionality is controlled using control messages sent to the
hardware using BD ring interface with 32B descriptor similar to transmit
BD ring used on ENETC. This BD ring interface is referred to as command
BD ring. It is used to configure functionality where the underlying
resources may be shared between different entities or being too large to
configure using direct registers. Therefore, a messaging protocol called
NETC Table Management Protocol (NTMP) is provided for exchanging
configuration and management information between the software and the
hardware using the command BD ring interface.

For i.MX95, NTMP has been upgraded to version 2.0, which is incompatible
with LS1028A, because the message formats have been changed. Therefore,
add the netc-lib driver to support NTMP 2.0 to operate various tables.
Note that, only MAC address filter table and RSS table are supported at
the moment. More tables will be supported in subsequent patches.

It is worth mentioning that the purpose of the netc-lib driver is to
provide some NTMP-based generic interfaces for ENETC and NETC Switch
drivers. Currently, it only supports the configurations of some tables.
Interfaces such as tc flower and debugfs will be added in the future.

Signed-off-by: Wei Fang <wei.fang@nxp.com>
---
v2 changes:
Change NTMP_FILL_CRD() and NTMP_FILL_CRD_EID to functions.
---
drivers/net/ethernet/freescale/enetc/Kconfig | 11 +
drivers/net/ethernet/freescale/enetc/Makefile | 3 +
drivers/net/ethernet/freescale/enetc/ntmp.c | 468 ++++++++++++++++++
.../ethernet/freescale/enetc/ntmp_formats.h | 59 +++
include/linux/fsl/ntmp.h | 178 +++++++
5 files changed, 719 insertions(+)
create mode 100644 drivers/net/ethernet/freescale/enetc/ntmp.c
create mode 100644 drivers/net/ethernet/freescale/enetc/ntmp_formats.h
create mode 100644 include/linux/fsl/ntmp.h

diff --git a/drivers/net/ethernet/freescale/enetc/Kconfig b/drivers/net/ethernet/freescale/enetc/Kconfig
index 6c2779047dcd..94db8e8d0eb3 100644
--- a/drivers/net/ethernet/freescale/enetc/Kconfig
+++ b/drivers/net/ethernet/freescale/enetc/Kconfig
@@ -15,6 +15,16 @@ config NXP_ENETC_PF_COMMON

If compiled as module (M), the module name is nxp-enetc-pf-common.

+config NXP_NETC_LIB
+ tristate "NETC Library"
+ help
+ This module provides common functionalities for both ENETC and NETC
+ Switch, such as NETC Table Management Protocol (NTMP) 2.0, common tc
+ flower and debugfs interfaces and so on.
+
+ If compiled as module (M), the module name is nxp-netc-lib.
+
+
config FSL_ENETC
tristate "ENETC PF driver"
depends on PCI_MSI
@@ -40,6 +50,7 @@ config NXP_ENETC4
select FSL_ENETC_CORE
select FSL_ENETC_MDIO
select NXP_ENETC_PF_COMMON
+ select NXP_NETC_LIB
select PHYLINK
select DIMLIB
help
diff --git a/drivers/net/ethernet/freescale/enetc/Makefile b/drivers/net/ethernet/freescale/enetc/Makefile
index 6fd27ee4fcd1..707a68e26971 100644
--- a/drivers/net/ethernet/freescale/enetc/Makefile
+++ b/drivers/net/ethernet/freescale/enetc/Makefile
@@ -6,6 +6,9 @@ fsl-enetc-core-y := enetc.o enetc_cbdr.o enetc_ethtool.o
obj-$(CONFIG_NXP_ENETC_PF_COMMON) += nxp-enetc-pf-common.o
nxp-enetc-pf-common-y := enetc_pf_common.o

+obj-$(CONFIG_NXP_NETC_LIB) += nxp-netc-lib.o
+nxp-netc-lib-y := ntmp.o
+
obj-$(CONFIG_FSL_ENETC) += fsl-enetc.o
fsl-enetc-y := enetc_pf.o
fsl-enetc-$(CONFIG_PCI_IOV) += enetc_msg.o
diff --git a/drivers/net/ethernet/freescale/enetc/ntmp.c b/drivers/net/ethernet/freescale/enetc/ntmp.c
new file mode 100644
index 000000000000..ba8a2ac9d4b4
--- /dev/null
+++ b/drivers/net/ethernet/freescale/enetc/ntmp.c
@@ -0,0 +1,468 @@
+// SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause)
+/*
+ * NETC NTMP (NETC Table Management Protocol) 2.0 Library
+ * Copyright 2025 NXP
+ */
+
+#include <linux/dma-mapping.h>
+#include <linux/fsl/netc_global.h>
+#include <linux/iopoll.h>
+
+#include "ntmp_formats.h"
+
+#define NETC_CBDR_TIMEOUT 1000 /* us */
+#define NETC_CBDR_MR_EN BIT(31)
+
+#define NTMP_BASE_ADDR_ALIGN 128
+#define NTMP_DATA_ADDR_ALIGN 32
+
+/* Define NTMP Table ID */
+#define NTMP_MAFT_ID 1
+#define NTMP_RSST_ID 3
+
+/* Generic Update Actions for most tables */
+#define NTMP_GEN_UA_CFGEU BIT(0)
+#define NTMP_GEN_UA_STSEU BIT(1)
+
+#define NTMP_ENTRY_ID_SIZE 4
+#define RSST_ENTRY_NUM 64
+#define RSST_STSE_DATA_SIZE(n) ((n) * 8)
+#define RSST_CFGE_DATA_SIZE(n) (n)
+
+int netc_setup_cbdr(struct device *dev, int cbd_num,
+ struct netc_cbdr_regs *regs,
+ struct netc_cbdr *cbdr)
+{
+ int size;
+
+ size = cbd_num * sizeof(union netc_cbd) + NTMP_BASE_ADDR_ALIGN;
+
+ cbdr->addr_base = dma_alloc_coherent(dev, size, &cbdr->dma_base,
+ GFP_KERNEL);
+ if (!cbdr->addr_base)
+ return -ENOMEM;
+
+ cbdr->dma_size = size;
+ cbdr->bd_num = cbd_num;
+ cbdr->regs = *regs;
+
+ /* The base address of the Control BD Ring must be 128 bytes aligned */
+ cbdr->dma_base_align = ALIGN(cbdr->dma_base, NTMP_BASE_ADDR_ALIGN);
+ cbdr->addr_base_align = PTR_ALIGN(cbdr->addr_base,
+ NTMP_BASE_ADDR_ALIGN);
+
+ cbdr->next_to_clean = 0;
+ cbdr->next_to_use = 0;
+ spin_lock_init(&cbdr->ring_lock);
+
+ /* Step 1: Configure the base address of the Control BD Ring */
+ netc_write(cbdr->regs.bar0, lower_32_bits(cbdr->dma_base_align));
+ netc_write(cbdr->regs.bar1, upper_32_bits(cbdr->dma_base_align));
+
+ /* Step 2: Configure the producer index register */
+ netc_write(cbdr->regs.pir, cbdr->next_to_clean);
+
+ /* Step 3: Configure the consumer index register */
+ netc_write(cbdr->regs.cir, cbdr->next_to_use);
+
+ /* Step4: Configure the number of BDs of the Control BD Ring */
+ netc_write(cbdr->regs.lenr, cbdr->bd_num);
+
+ /* Step 5: Enable the Control BD Ring */
+ netc_write(cbdr->regs.mr, NETC_CBDR_MR_EN);
+
+ return 0;
+}
+EXPORT_SYMBOL_GPL(netc_setup_cbdr);
+
+void netc_teardown_cbdr(struct device *dev, struct netc_cbdr *cbdr)
+{
+ /* Disable the Control BD Ring */
+ netc_write(cbdr->regs.mr, 0);
+ dma_free_coherent(dev, cbdr->dma_size, cbdr->addr_base,
+ cbdr->dma_base);
+ memset(cbdr, 0, sizeof(*cbdr));
+}
+EXPORT_SYMBOL_GPL(netc_teardown_cbdr);
+
+static int netc_get_free_cbd_num(struct netc_cbdr *cbdr)
+{
+ return (cbdr->next_to_clean - cbdr->next_to_use - 1 +
+ cbdr->bd_num) % cbdr->bd_num;
+}
+
+static union netc_cbd *netc_get_cbd(struct netc_cbdr *cbdr, int index)
+{
+ return &((union netc_cbd *)(cbdr->addr_base_align))[index];
+}
+
+static void netc_clean_cbdr(struct netc_cbdr *cbdr)
+{
+ union netc_cbd *cbd;
+ int i;
+
+ i = cbdr->next_to_clean;
+ while (netc_read(cbdr->regs.cir) != i) {
+ cbd = netc_get_cbd(cbdr, i);
+ memset(cbd, 0, sizeof(*cbd));
+ i = (i + 1) % cbdr->bd_num;
+ }
+
+ cbdr->next_to_clean = i;
+}
+
+static struct netc_cbdr *netc_select_cbdr(struct netc_cbdrs *cbdrs)
+{
+ int i;
+
+ for (i = 0; i < cbdrs->cbdr_num; i++) {
+ if (spin_is_locked(&cbdrs->ring[i].ring_lock))
+ continue;
+
+ return &cbdrs->ring[i];
+ }
+
+ return &cbdrs->ring[smp_processor_id() % cbdrs->cbdr_num];
+}
+
+static int netc_xmit_ntmp_cmd(struct netc_cbdrs *cbdrs, union netc_cbd *cbd)
+{
+ union netc_cbd *cur_cbd;
+ struct netc_cbdr *cbdr;
+ int i, err;
+ u16 status;
+ u32 val;
+
+ if (cbdrs->cbdr_num == 1)
+ cbdr = &cbdrs->ring[0];
+ else
+ cbdr = netc_select_cbdr(cbdrs);
+
+ spin_lock_bh(&cbdr->ring_lock);
+
+ if (unlikely(!netc_get_free_cbd_num(cbdr)))
+ netc_clean_cbdr(cbdr);
+
+ i = cbdr->next_to_use;
+ cur_cbd = netc_get_cbd(cbdr, i);
+ *cur_cbd = *cbd;
+
+ /* Update producer index of both software and hardware */
+ i = (i + 1) % cbdr->bd_num;
+ cbdr->next_to_use = i;
+ dma_wmb();
+ netc_write(cbdr->regs.pir, i);
+
+ err = read_poll_timeout_atomic(netc_read, val, val == i,
+ 10, NETC_CBDR_TIMEOUT, true,
+ cbdr->regs.cir);
+ if (unlikely(err))
+ goto cbdr_unlock;
+
+ dma_rmb();
+ /* Get the writeback command BD, because the caller may need
+ * to check some other fields of the response header.
+ */
+ *cbd = *cur_cbd;
+
+ /* Check the writeback error status */
+ status = le16_to_cpu(cbd->resp_hdr.error_rr) & NTMP_RESP_ERROR;
+ if (unlikely(status)) {
+ err = -EIO;
+ dev_err(cbdrs->dma_dev, "Command BD error: 0x%04x\n", status);
+ }
+
+ netc_clean_cbdr(cbdr);
+ dma_wmb();
+
+cbdr_unlock:
+ spin_unlock_bh(&cbdr->ring_lock);
+
+ return err;
+}
+
+static void *ntmp_alloc_data_mem(struct device *dev, int size,
+ dma_addr_t *dma, void **data_align)
+{
+ void *data;
+
+ data = dma_alloc_coherent(dev, size + NTMP_DATA_ADDR_ALIGN,
+ dma, GFP_ATOMIC);
+ if (!data)
+ return NULL;
+
+ *data_align = PTR_ALIGN(data, NTMP_DATA_ADDR_ALIGN);
+
+ return data;
+}
+
+static void ntmp_free_data_mem(struct device *dev, int size,
+ void *data, dma_addr_t dma)
+{
+ dma_free_coherent(dev, size + NTMP_DATA_ADDR_ALIGN, data, dma);
+}
+
+static void ntmp_fill_request_headr(union netc_cbd *cbd, dma_addr_t dma,
+ int len, int table_id, int cmd,
+ int access_method)
+{
+ dma_addr_t dma_align;
+
+ memset(cbd, 0, sizeof(*cbd));
+ dma_align = ALIGN(dma, NTMP_DATA_ADDR_ALIGN);
+ cbd->req_hdr.addr = cpu_to_le64(dma_align);
+ cbd->req_hdr.len = cpu_to_le32(len);
+ cbd->req_hdr.cmd = cmd;
+ cbd->req_hdr.access_method = FIELD_PREP(NTMP_ACCESS_METHOD,
+ access_method);
+ cbd->req_hdr.table_id = table_id;
+ cbd->req_hdr.ver_cci_rr = FIELD_PREP(NTMP_HDR_VERSION,
+ NTMP_HDR_VER2);
+ /* For NTMP version 2.0 or later version */
+ cbd->req_hdr.npf = cpu_to_le32(NTMP_NPF);
+}
+
+static void ntmp_fill_crd(struct common_req_data *crd,
+ u8 tblv, u8 qa, u16 ua)
+{
+ crd->update_act = cpu_to_le16(ua);
+ crd->tblv_qact = NTMP_TBLV_QACT(tblv, qa);
+}
+
+static void ntmp_fill_crd_eid(struct ntmp_req_by_eid *rbe, u8 tblv,
+ u8 qa, u16 ua, u32 entry_id)
+{
+ ntmp_fill_crd(&rbe->crd, tblv, qa, ua);
+ rbe->entry_id = cpu_to_le32(entry_id);
+}
+
+static int ntmp_delete_entry_by_id(struct netc_cbdrs *cbdrs, int tbl_id,
+ u8 tbl_ver, u32 entry_id, u32 req_len,
+ u32 resp_len)
+{
+ struct device *dev = cbdrs->dma_dev;
+ struct ntmp_req_by_eid *req;
+ union netc_cbd cbd;
+ u32 len, dma_len;
+ dma_addr_t dma;
+ void *tmp;
+ int err;
+
+ if (entry_id == NTMP_NULL_ENTRY_ID)
+ return 0;
+
+ /* If the req_len is 0, indicates the requested length is the
+ * standard length.
+ */
+ if (!req_len)
+ req_len = sizeof(*req);
+
+ dma_len = req_len >= resp_len ? req_len : resp_len;
+ tmp = ntmp_alloc_data_mem(dev, dma_len, &dma, (void **)&req);
+ if (!tmp)
+ return -ENOMEM;
+
+ ntmp_fill_crd_eid(req, tbl_ver, 0, 0, entry_id);
+ len = NTMP_LEN(req_len, resp_len);
+ ntmp_fill_request_headr(&cbd, dma, len, tbl_id,
+ NTMP_CMD_DELETE, NTMP_AM_ENTRY_ID);
+
+ err = netc_xmit_ntmp_cmd(cbdrs, &cbd);
+ if (err)
+ dev_err(dev, "Delete table (id: %d) entry failed: %d!",
+ tbl_id, err);
+
+ ntmp_free_data_mem(dev, dma_len, tmp, dma);
+
+ return err;
+}
+
+static int ntmp_query_entry_by_id(struct netc_cbdrs *cbdrs, int tbl_id,
+ u32 len, struct ntmp_req_by_eid *req,
+ dma_addr_t *dma, bool compare_eid)
+{
+ struct device *dev = cbdrs->dma_dev;
+ struct common_resp_query *resp;
+ int cmd = NTMP_CMD_QUERY;
+ union netc_cbd cbd;
+ u32 entry_id;
+ int err;
+
+ entry_id = le32_to_cpu(req->entry_id);
+ if (le16_to_cpu(req->crd.update_act))
+ cmd = NTMP_CMD_QU;
+
+ /* Request header */
+ ntmp_fill_request_headr(&cbd, *dma, len, tbl_id,
+ cmd, NTMP_AM_ENTRY_ID);
+
+ err = netc_xmit_ntmp_cmd(cbdrs, &cbd);
+ if (err) {
+ dev_err(dev, "Query table (id: %d) entry failed: %d\n",
+ tbl_id, err);
+ return err;
+ }
+
+ /* For a few tables, the first field of its response data is not
+ * entry_id, so directly return success.
+ */
+ if (!compare_eid)
+ return 0;
+
+ resp = (struct common_resp_query *)req;
+ if (unlikely(le32_to_cpu(resp->entry_id) != entry_id)) {
+ dev_err(dev, "Table (id: %d) query EID:0x%0x, response EID:0x%x\n",
+ tbl_id, entry_id, le32_to_cpu(resp->entry_id));
+ return -EIO;
+ }
+
+ return 0;
+}
+
+int ntmp_maft_add_entry(struct netc_cbdrs *cbdrs, u32 entry_id,
+ struct maft_entry_data *data)
+{
+ struct device *dev = cbdrs->dma_dev;
+ struct maft_req_add *req;
+ union netc_cbd cbd;
+ dma_addr_t dma;
+ u32 req_len;
+ void *tmp;
+ int err;
+
+ req_len = sizeof(*req);
+ tmp = ntmp_alloc_data_mem(dev, req_len, &dma, (void **)&req);
+ if (!tmp)
+ return -ENOMEM;
+
+ /* Set mac address filter table request data buffer */
+ ntmp_fill_crd_eid(&req->rbe, cbdrs->tbl.maft_ver, 0, 0, entry_id);
+ req->keye = data->keye;
+ req->cfge = data->cfge;
+
+ ntmp_fill_request_headr(&cbd, dma, NTMP_LEN(req_len, 0),
+ NTMP_MAFT_ID, NTMP_CMD_ADD,
+ NTMP_AM_ENTRY_ID);
+ err = netc_xmit_ntmp_cmd(cbdrs, &cbd);
+ if (err)
+ dev_err(dev, "Add MAFT entry failed (%d)!", err);
+
+ ntmp_free_data_mem(dev, req_len, tmp, dma);
+
+ return err;
+}
+EXPORT_SYMBOL_GPL(ntmp_maft_add_entry);
+
+int ntmp_maft_query_entry(struct netc_cbdrs *cbdrs, u32 entry_id,
+ struct maft_entry_data *data)
+{
+ struct device *dev = cbdrs->dma_dev;
+ struct maft_resp_query *resp;
+ u32 resp_len = sizeof(*resp);
+ struct ntmp_req_by_eid *req;
+ u32 req_len = sizeof(*req);
+ void *tmp = NULL;
+ dma_addr_t dma;
+ int err;
+
+ if (entry_id == NTMP_NULL_ENTRY_ID)
+ return -EINVAL;
+
+ tmp = ntmp_alloc_data_mem(dev, resp_len, &dma, (void **)&req);
+ if (!tmp)
+ return -ENOMEM;
+
+ ntmp_fill_crd_eid(req, cbdrs->tbl.maft_ver, 0, 0, entry_id);
+ err = ntmp_query_entry_by_id(cbdrs, NTMP_MAFT_ID,
+ NTMP_LEN(req_len, resp_len),
+ req, &dma, true);
+ if (err)
+ goto end;
+
+ resp = (struct maft_resp_query *)req;
+ data->keye = resp->keye;
+ data->cfge = resp->cfge;
+
+end:
+ ntmp_free_data_mem(dev, resp_len, tmp, dma);
+
+ return err;
+}
+EXPORT_SYMBOL_GPL(ntmp_maft_query_entry);
+
+int ntmp_maft_delete_entry(struct netc_cbdrs *cbdrs, u32 entry_id)
+{
+ return ntmp_delete_entry_by_id(cbdrs, NTMP_MAFT_ID,
+ cbdrs->tbl.maft_ver,
+ entry_id, 0, 0);
+}
+EXPORT_SYMBOL_GPL(ntmp_maft_delete_entry);
+
+int ntmp_rsst_query_or_update_entry(struct netc_cbdrs *cbdrs, u32 *table,
+ int count, bool query)
+{
+ struct device *dev = cbdrs->dma_dev;
+ struct rsst_req_update *requ;
+ struct ntmp_req_by_eid *req;
+ union netc_cbd cbd;
+ u32 len, data_size;
+ dma_addr_t dma;
+ int err, i;
+ void *tmp;
+
+ if (count != RSST_ENTRY_NUM)
+ /* HW only takes in a full 64 entry table */
+ return -EINVAL;
+
+ if (query)
+ data_size = NTMP_ENTRY_ID_SIZE + RSST_STSE_DATA_SIZE(count) +
+ RSST_CFGE_DATA_SIZE(count);
+ else
+ data_size = struct_size(requ, groups, count);
+
+ tmp = ntmp_alloc_data_mem(dev, data_size, &dma, (void **)&req);
+ if (!tmp)
+ return -ENOMEM;
+
+ /* Set the request data buffer */
+ if (query) {
+ ntmp_fill_crd_eid(req, cbdrs->tbl.rsst_ver, 0, 0, 0);
+ len = NTMP_LEN(sizeof(*req), data_size);
+ ntmp_fill_request_headr(&cbd, dma, len, NTMP_RSST_ID,
+ NTMP_CMD_QUERY, NTMP_AM_ENTRY_ID);
+ } else {
+ requ = (struct rsst_req_update *)req;
+ ntmp_fill_crd_eid(&requ->rbe, cbdrs->tbl.rsst_ver, 0,
+ NTMP_GEN_UA_CFGEU | NTMP_GEN_UA_STSEU, 0);
+ for (i = 0; i < count; i++)
+ requ->groups[i] = (u8)(table[i]);
+
+ len = NTMP_LEN(data_size, 0);
+ ntmp_fill_request_headr(&cbd, dma, len, NTMP_RSST_ID,
+ NTMP_CMD_UPDATE, NTMP_AM_ENTRY_ID);
+ }
+
+ err = netc_xmit_ntmp_cmd(cbdrs, &cbd);
+ if (err) {
+ dev_err(dev, "%s RSS table entry failed (%d)!",
+ query ? "Query" : "Update", err);
+ goto end;
+ }
+
+ if (query) {
+ u8 *group = (u8 *)req;
+
+ group += NTMP_ENTRY_ID_SIZE + RSST_STSE_DATA_SIZE(count);
+ for (i = 0; i < count; i++)
+ table[i] = group[i];
+ }
+
+end:
+ ntmp_free_data_mem(dev, data_size, tmp, dma);
+
+ return err;
+}
+EXPORT_SYMBOL_GPL(ntmp_rsst_query_or_update_entry);
+
+MODULE_DESCRIPTION("NXP NETC Library");
+MODULE_LICENSE("Dual BSD/GPL");
diff --git a/drivers/net/ethernet/freescale/enetc/ntmp_formats.h b/drivers/net/ethernet/freescale/enetc/ntmp_formats.h
new file mode 100644
index 000000000000..3e581901f139
--- /dev/null
+++ b/drivers/net/ethernet/freescale/enetc/ntmp_formats.h
@@ -0,0 +1,59 @@
+/* SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause) */
+/*
+ * NTMP table request and response data buffer formats
+ * Copyright 2025 NXP
+ */
+
+#ifndef __NTMP_FORMATS_H
+#define __NTMP_FORMATS_H
+#include <linux/fsl/ntmp.h>
+
+#pragma pack(1)
+
+struct common_req_data {
+ __le16 update_act;
+ u8 dbg_opt;
+ u8 tblv_qact;
+#define NTMP_QUERY_ACT GENMASK(3, 0)
+#define NTMP_TBL_VER GENMASK(7, 0)
+#define NTMP_TBLV_QACT(v, a) (FIELD_PREP(NTMP_TBL_VER, (v)) | \
+ ((a) & NTMP_QUERY_ACT))
+};
+
+struct common_resp_query {
+ __le32 entry_id;
+};
+
+struct common_resp_nq {
+ __le32 status;
+};
+
+/* Generic structure for request data by entry ID */
+struct ntmp_req_by_eid {
+ struct common_req_data crd;
+ __le32 entry_id;
+};
+
+/* MAC Address Filter Table Request Data Buffer Format of Add action */
+struct maft_req_add {
+ struct ntmp_req_by_eid rbe;
+ struct maft_keye_data keye;
+ struct maft_cfge_data cfge;
+};
+
+/* MAC Address Filter Table Response Data Buffer Format of Query action */
+struct maft_resp_query {
+ __le32 entry_id;
+ struct maft_keye_data keye;
+ struct maft_cfge_data cfge;
+};
+
+/* RSS Table Request Data Buffer Format of Update action */
+struct rsst_req_update {
+ struct ntmp_req_by_eid rbe;
+ u8 groups[];
+};
+
+#pragma pack()
+
+#endif
diff --git a/include/linux/fsl/ntmp.h b/include/linux/fsl/ntmp.h
new file mode 100644
index 000000000000..7cf322a1c8e3
--- /dev/null
+++ b/include/linux/fsl/ntmp.h
@@ -0,0 +1,178 @@
+/* SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause) */
+/* Copyright 2025 NXP */
+#ifndef __NETC_NTMP_H
+#define __NETC_NTMP_H
+
+#include <linux/bitops.h>
+#include <linux/if_ether.h>
+
+#define NTMP_NULL_ENTRY_ID 0xffffffffU
+#define NETC_CBDR_BD_NUM 256
+
+#pragma pack(1)
+
+union netc_cbd {
+ struct {
+ __le64 addr;
+ __le32 len;
+#define NTMP_RESP_LEN GENMASK(19, 0)
+#define NTMP_REQ_LEN GENMASK(31, 20)
+#define NTMP_LEN(req, resp) (FIELD_PREP(NTMP_REQ_LEN, (req)) | \
+ ((resp) & NTMP_RESP_LEN))
+ u8 cmd;
+#define NTMP_CMD_DELETE BIT(0)
+#define NTMP_CMD_UPDATE BIT(1)
+#define NTMP_CMD_QUERY BIT(2)
+#define NTMP_CMD_ADD BIT(3)
+#define NTMP_CMD_QD (NTMP_CMD_QUERY | NTMP_CMD_DELETE)
+#define NTMP_CMD_QU (NTMP_CMD_QUERY | NTMP_CMD_UPDATE)
+#define NTMP_CMD_AU (NTMP_CMD_ADD | NTMP_CMD_UPDATE)
+#define NTMP_CMD_AQ (NTMP_CMD_ADD | NTMP_CMD_QUERY)
+#define NTMP_CMD_AQU (NTMP_CMD_AQ | NTMP_CMD_UPDATE)
+ u8 access_method;
+#define NTMP_ACCESS_METHOD GENMASK(7, 4)
+#define NTMP_AM_ENTRY_ID 0
+#define NTMP_AM_EXACT_KEY 1
+#define NTMP_AM_SEARCH 2
+#define NTMP_AM_TERNARY_KEY 3
+ u8 table_id;
+ u8 ver_cci_rr;
+#define NTMP_HDR_VERSION GENMASK(5, 0)
+#define NTMP_HDR_VER2 2
+#define NTMP_CCI BIT(6)
+#define NTMP_RR BIT(7)
+ __le32 resv[3];
+ __le32 npf;
+#define NTMP_NPF BIT(15)
+ } req_hdr; /* NTMP Request Message Header Format */
+
+ struct {
+ __le32 resv0[3];
+ __le16 num_matched;
+ __le16 error_rr;
+#define NTMP_RESP_ERROR GENMASK(11, 0)
+#define NTMP_RESP_RR BIT(15)
+ __le32 resv1[4];
+ } resp_hdr; /* NTMP Response Message Header Format */
+};
+
+struct maft_keye_data {
+ u8 mac_addr[ETH_ALEN];
+ __le16 resv;
+};
+
+struct maft_cfge_data {
+ __le16 si_bitmap;
+ __le16 resv;
+};
+
+#pragma pack()
+
+struct netc_cbdr_regs {
+ void __iomem *pir;
+ void __iomem *cir;
+ void __iomem *mr;
+
+ void __iomem *bar0;
+ void __iomem *bar1;
+ void __iomem *lenr;
+};
+
+struct netc_tbl_vers {
+ u8 maft_ver;
+ u8 rsst_ver;
+};
+
+struct netc_cbdr {
+ struct netc_cbdr_regs regs;
+
+ int bd_num;
+ int next_to_use;
+ int next_to_clean;
+
+ int dma_size;
+ void *addr_base;
+ void *addr_base_align;
+ dma_addr_t dma_base;
+ dma_addr_t dma_base_align;
+
+ spinlock_t ring_lock; /* Avoid race condition */
+};
+
+struct netc_cbdrs {
+ int cbdr_num; /* number of control BD ring */
+ int cbdr_size; /* number of BDs per control BD ring */
+ struct device *dma_dev;
+ struct netc_cbdr *ring;
+ struct netc_tbl_vers tbl;
+};
+
+enum netc_dev_type {
+ NETC_DEV_ENETC,
+ NETC_DEV_SWITCH
+};
+
+struct ntmp_priv {
+ enum netc_dev_type dev_type;
+ struct netc_cbdrs cbdrs;
+};
+
+struct maft_entry_data {
+ struct maft_keye_data keye;
+ struct maft_cfge_data cfge;
+};
+
+#if IS_ENABLED(CONFIG_NXP_NETC_LIB)
+int netc_setup_cbdr(struct device *dev, int cbd_num,
+ struct netc_cbdr_regs *regs,
+ struct netc_cbdr *cbdr);
+void netc_teardown_cbdr(struct device *dev, struct netc_cbdr *cbdr);
+
+/* NTMP APIs */
+int ntmp_maft_add_entry(struct netc_cbdrs *cbdrs, u32 entry_id,
+ struct maft_entry_data *data);
+int ntmp_maft_query_entry(struct netc_cbdrs *cbdrs, u32 entry_id,
+ struct maft_entry_data *data);
+int ntmp_maft_delete_entry(struct netc_cbdrs *cbdrs, u32 entry_id);
+int ntmp_rsst_query_or_update_entry(struct netc_cbdrs *cbdrs,
+ u32 *table, int count, bool query);
+#else
+static inline int netc_setup_cbdr(struct device *dev, int cbd_num,
+ struct netc_cbdr_regs *regs,
+ struct netc_cbdr *cbdr)
+{
+ return 0;
+}
+
+static inline void netc_teardown_cbdr(struct device *dev,
+ struct netc_cbdr *cbdr)
+{
+}
+
+static inline int ntmp_maft_add_entry(struct netc_cbdrs *cbdrs, u32 entry_id,
+ struct maft_entry_data *data)
+{
+ return 0;
+}
+
+static inline int ntmp_maft_query_entry(struct netc_cbdrs *cbdrs, u32 entry_id,
+ struct maft_entry_data *data)
+{
+ return 0;
+}
+
+static inline int ntmp_maft_delete_entry(struct netc_cbdrs *cbdrs, u32 entry_id)
+{
+ return 0;
+}
+
+static inline int ntmp_rsst_query_or_update_entry(struct netc_cbdrs *cbdrs,
+ u32 *table, int count,
+ bool query)
+{
+ return 0;
+}
+
+#endif
+
+#endif
--
2.34.1