From: Oleksandr Kolomeiets <okl-...@napatech.com>
The Flow Matcher module is a high-performance stateful SDRAM lookup
and programming engine which supported exact match lookup
in line-rate of up to hundreds of millions of flows.
Signed-off-by: Oleksandr Kolomeiets <okl-...@napatech.com>
---
drivers/net/ntnic/include/hw_mod_backend.h | 117 +++++++
drivers/net/ntnic/meson.build | 1 +
drivers/net/ntnic/nthw/flow_api/flow_api.c | 6 +
.../nthw/flow_api/hw_mod/hw_mod_backend.c | 1 +
.../ntnic/nthw/flow_api/hw_mod/hw_mod_flm.c | 300 ++++++++++++++++++
5 files changed, 425 insertions(+)
create mode 100644 drivers/net/ntnic/nthw/flow_api/hw_mod/hw_mod_flm.c
diff --git a/drivers/net/ntnic/include/hw_mod_backend.h
b/drivers/net/ntnic/include/hw_mod_backend.h
index f40b33a888..3933d4bf53 100644
--- a/drivers/net/ntnic/include/hw_mod_backend.h
+++ b/drivers/net/ntnic/include/hw_mod_backend.h
@@ -367,6 +367,122 @@ struct flm_func_s {
struct hw_mod_flm_v25_s v25;
};
};
+enum hw_flm_e {
+ /* functions */
+ HW_FLM_CONTROL_PRESET_ALL = 0,
+ HW_FLM_RCP_PRESET_ALL,
+ HW_FLM_FLOW_LRN_DATA,
+ HW_FLM_FLOW_INF_STA_DATA,
+ /* Control fields */
+ HW_FLM_CONTROL_ENABLE = FIELD_START_INDEX,
+ HW_FLM_CONTROL_INIT,
+ HW_FLM_CONTROL_LDS,
+ HW_FLM_CONTROL_LFS,
+ HW_FLM_CONTROL_LIS,
+ HW_FLM_CONTROL_UDS,
+ HW_FLM_CONTROL_UIS,
+ HW_FLM_CONTROL_RDS,
+ HW_FLM_CONTROL_RIS,
+ HW_FLM_CONTROL_PDS,
+ HW_FLM_CONTROL_PIS,
+ HW_FLM_CONTROL_CRCWR,
+ HW_FLM_CONTROL_CRCRD,
+ HW_FLM_CONTROL_RBL,
+ HW_FLM_CONTROL_EAB,
+ HW_FLM_CONTROL_SPLIT_SDRAM_USAGE,
+ HW_FLM_STATUS_CALIB_SUCCESS,
+ HW_FLM_STATUS_CALIB_FAIL,
+ HW_FLM_STATUS_INITDONE,
+ HW_FLM_STATUS_IDLE,
+ HW_FLM_STATUS_CRITICAL,
+ HW_FLM_STATUS_PANIC,
+ HW_FLM_STATUS_CRCERR,
+ HW_FLM_STATUS_EFT_BP,
+ HW_FLM_STATUS_CACHE_BUFFER_CRITICAL,
+ HW_FLM_LOAD_BIN,
+ HW_FLM_LOAD_LPS,
+ HW_FLM_LOAD_APS,
+ HW_FLM_PRIO_LIMIT0,
+ HW_FLM_PRIO_FT0,
+ HW_FLM_PRIO_LIMIT1,
+ HW_FLM_PRIO_FT1,
+ HW_FLM_PRIO_LIMIT2,
+ HW_FLM_PRIO_FT2,
+ HW_FLM_PRIO_LIMIT3,
+ HW_FLM_PRIO_FT3,
+ HW_FLM_PST_PRESET_ALL,
+ HW_FLM_PST_BP,
+ HW_FLM_PST_PP,
+ HW_FLM_PST_TP,
+ HW_FLM_RCP_LOOKUP,
+ HW_FLM_RCP_QW0_DYN,
+ HW_FLM_RCP_QW0_OFS,
+ HW_FLM_RCP_QW0_SEL,
+ HW_FLM_RCP_QW4_DYN,
+ HW_FLM_RCP_QW4_OFS,
+ HW_FLM_RCP_SW8_DYN,
+ HW_FLM_RCP_SW8_OFS,
+ HW_FLM_RCP_SW8_SEL,
+ HW_FLM_RCP_SW9_DYN,
+ HW_FLM_RCP_SW9_OFS,
+ HW_FLM_RCP_MASK,
+ HW_FLM_RCP_KID,
+ HW_FLM_RCP_OPN,
+ HW_FLM_RCP_IPN,
+ HW_FLM_RCP_BYT_DYN,
+ HW_FLM_RCP_BYT_OFS,
+ HW_FLM_RCP_TXPLM,
+ HW_FLM_RCP_AUTO_IPV4_MASK,
+ HW_FLM_BUF_CTRL_LRN_FREE,
+ HW_FLM_BUF_CTRL_INF_AVAIL,
+ HW_FLM_BUF_CTRL_STA_AVAIL,
+ HW_FLM_STAT_LRN_DONE,
+ HW_FLM_STAT_LRN_IGNORE,
+ HW_FLM_STAT_LRN_FAIL,
+ HW_FLM_STAT_UNL_DONE,
+ HW_FLM_STAT_UNL_IGNORE,
+ HW_FLM_STAT_REL_DONE,
+ HW_FLM_STAT_REL_IGNORE,
+ HW_FLM_STAT_PRB_DONE,
+ HW_FLM_STAT_PRB_IGNORE,
+ HW_FLM_STAT_AUL_DONE,
+ HW_FLM_STAT_AUL_IGNORE,
+ HW_FLM_STAT_AUL_FAIL,
+ HW_FLM_STAT_TUL_DONE,
+ HW_FLM_STAT_FLOWS,
+ HW_FLM_STAT_STA_DONE, /* module ver 0.20 */
+ HW_FLM_STAT_INF_DONE, /* module ver 0.20 */
+ HW_FLM_STAT_INF_SKIP, /* module ver 0.20 */
+ HW_FLM_STAT_PCK_HIT, /* module ver 0.20 */
+ HW_FLM_STAT_PCK_MISS, /* module ver 0.20 */
+ HW_FLM_STAT_PCK_UNH, /* module ver 0.20 */
+ HW_FLM_STAT_PCK_DIS, /* module ver 0.20 */
+ HW_FLM_STAT_CSH_HIT, /* module ver 0.20 */
+ HW_FLM_STAT_CSH_MISS, /* module ver 0.20 */
+ HW_FLM_STAT_CSH_UNH, /* module ver 0.20 */
+ HW_FLM_STAT_CUC_START, /* module ver 0.20 */
+ HW_FLM_STAT_CUC_MOVE, /* module ver 0.20 */
+ HW_FLM_SCAN_I, /* module ver 0.22 */
+ HW_FLM_SCRUB_PRESET_ALL,
+ HW_FLM_SCRUB_T, /* module ver 0.22 */
+ HW_FLM_SCRUB_R, /* module ver 0.24 */
+ HW_FLM_SCRUB_DEL, /* module ver 0.24 */
+ HW_FLM_SCRUB_INF, /* module ver 0.24 */
+};
+
+bool hw_mod_flm_present(struct flow_api_backend_s *be);
+int hw_mod_flm_alloc(struct flow_api_backend_s *be);
+void hw_mod_flm_free(struct flow_api_backend_s *be);
+int hw_mod_flm_reset(struct flow_api_backend_s *be);
+
+int hw_mod_flm_control_flush(struct flow_api_backend_s *be);
+int hw_mod_flm_control_set(struct flow_api_backend_s *be, enum hw_flm_e field,
uint32_t value);
+
+int hw_mod_flm_scan_flush(struct flow_api_backend_s *be);
+
+int hw_mod_flm_rcp_flush(struct flow_api_backend_s *be, int start_idx, int
count);
+
+int hw_mod_flm_scrub_flush(struct flow_api_backend_s *be, int start_idx, int
count);
struct hsh_func_s {
COMMON_FUNC_INFO_S;
@@ -568,6 +684,7 @@ struct flow_api_backend_s {
/* flow filter FPGA modules */
struct cat_func_s cat;
struct km_func_s km;
+ struct flm_func_s flm;
/* NIC attributes */
unsigned int num_phy_ports;
diff --git a/drivers/net/ntnic/meson.build b/drivers/net/ntnic/meson.build
index e37bb96331..9af7e3d813 100644
--- a/drivers/net/ntnic/meson.build
+++ b/drivers/net/ntnic/meson.build
@@ -50,6 +50,7 @@ sources = files(
'nthw/flow_api/flow_km.c',
'nthw/flow_api/hw_mod/hw_mod_backend.c',
'nthw/flow_api/hw_mod/hw_mod_cat.c',
+ 'nthw/flow_api/hw_mod/hw_mod_flm.c',
'nthw/flow_api/hw_mod/hw_mod_km.c',
'nthw/flow_filter/flow_nthw_cat.c',
'nthw/flow_filter/flow_nthw_csu.c',
diff --git a/drivers/net/ntnic/nthw/flow_api/flow_api.c
b/drivers/net/ntnic/nthw/flow_api/flow_api.c
index c85838519b..d39bdc9936 100644
--- a/drivers/net/ntnic/nthw/flow_api/flow_api.c
+++ b/drivers/net/ntnic/nthw/flow_api/flow_api.c
@@ -296,6 +296,12 @@ struct flow_nic_dev *flow_api_create(uint8_t adapter_no,
const struct flow_api_b
if (init_resource_elements(ndev, RES_FLM_FLOW_TYPE,
ndev->be.cat.nb_flow_types))
goto err_exit;
+ if (init_resource_elements(ndev, RES_FLM_RCP,
ndev->be.flm.nb_categories))
+ goto err_exit;
+
+ if (init_resource_elements(ndev, RES_SCRUB_RCP,
ndev->be.flm.nb_scrub_profiles))
+ goto err_exit;
+
/* may need IPF, COR */
/* check all defined has been initialized */
diff --git a/drivers/net/ntnic/nthw/flow_api/hw_mod/hw_mod_backend.c
b/drivers/net/ntnic/nthw/flow_api/hw_mod/hw_mod_backend.c
index 9d5572f4b2..fe66493336 100644
--- a/drivers/net/ntnic/nthw/flow_api/hw_mod/hw_mod_backend.c
+++ b/drivers/net/ntnic/nthw/flow_api/hw_mod/hw_mod_backend.c
@@ -19,6 +19,7 @@ static const struct {
} module[] = {
{ "CAT", hw_mod_cat_alloc, hw_mod_cat_free, hw_mod_cat_reset,
hw_mod_cat_present },
{ "KM", hw_mod_km_alloc, hw_mod_km_free, hw_mod_km_reset,
hw_mod_km_present },
+ { "FLM", hw_mod_flm_alloc, hw_mod_flm_free, hw_mod_flm_reset,
hw_mod_flm_present },
};
#define MOD_COUNT (ARRAY_SIZE(module))
diff --git a/drivers/net/ntnic/nthw/flow_api/hw_mod/hw_mod_flm.c
b/drivers/net/ntnic/nthw/flow_api/hw_mod/hw_mod_flm.c
new file mode 100644
index 0000000000..c52467b575
--- /dev/null
+++ b/drivers/net/ntnic/nthw/flow_api/hw_mod/hw_mod_flm.c
@@ -0,0 +1,300 @@
+/*
+ * SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2023 Napatech A/S
+ */
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "hw_mod_backend.h"
+
+#define _MOD_ "FLM"
+#define _VER_ be->flm.ver
+
+bool hw_mod_flm_present(struct flow_api_backend_s *be)
+{
+ return be->iface->get_flm_present(be->be_dev);
+}
+
+int hw_mod_flm_alloc(struct flow_api_backend_s *be)
+{
+ int nb;
+ _VER_ = be->iface->get_flm_version(be->be_dev);
+ NT_LOG(DBG, FILTER, "FLM MODULE VERSION %i.%i\n", VER_MAJOR(_VER_),
VER_MINOR(_VER_));
+
+ nb = be->iface->get_nb_flm_categories(be->be_dev);
+
+ if (nb <= 0)
+ return COUNT_ERROR(flm_categories);
+
+ be->flm.nb_categories = (uint32_t)nb;
+
+ nb = be->iface->get_nb_flm_size_mb(be->be_dev);
+
+ if (nb <= 0)
+ return COUNT_ERROR(flm_size_mb);
+
+ be->flm.nb_size_mb = (uint32_t)nb;
+
+ nb = be->iface->get_nb_flm_entry_size(be->be_dev);
+
+ if (nb <= 0)
+ return COUNT_ERROR(flm_entry_size);
+
+ be->flm.nb_entry_size = (uint32_t)nb;
+
+ nb = be->iface->get_nb_flm_variant(be->be_dev);
+
+ if (nb <= 0)
+ return COUNT_ERROR(flm_variant);
+
+ be->flm.nb_variant = (uint32_t)nb;
+
+ nb = be->iface->get_nb_flm_prios(be->be_dev);
+
+ if (nb <= 0)
+ return COUNT_ERROR(flm_prios);
+
+ be->flm.nb_prios = (uint32_t)nb;
+
+ nb = be->iface->get_nb_flm_pst_profiles(be->be_dev);
+
+ if (nb <= 0)
+ return COUNT_ERROR(flm_pst_profiles);
+
+ be->flm.nb_pst_profiles = (uint32_t)nb;
+
+ if (_VER_ >= 22) {
+ nb = be->iface->get_nb_flm_scrub_profiles(be->be_dev);
+
+ if (nb <= 0)
+ return COUNT_ERROR(flm_scrub_profiles);
+
+ be->flm.nb_scrub_profiles = (uint32_t)nb;
+ }
+
+ nb = be->iface->get_nb_rpp_per_ps(be->be_dev);
+
+ if (nb <= 0)
+ return COUNT_ERROR(flm_rpp_clock);
+
+ be->flm.nb_rpp_clock_in_ps = (uint32_t)nb;
+
+ nb = be->iface->get_nb_flm_load_aps_max(be->be_dev);
+
+ if (nb <= 0)
+ return COUNT_ERROR(flm_load_aps_max);
+
+ be->flm.nb_load_aps_max = (uint32_t)nb;
+
+ switch (_VER_) {
+ case 25:
+ if (!callocate_mod((struct common_func_s *)&be->flm, 38,
&be->flm.v25.control, 1,
+ sizeof(struct flm_v25_control_s),
&be->flm.v25.status, 1,
+ sizeof(struct flm_v25_status_s),
&be->flm.v25.load_bin, 1,
+ sizeof(struct flm_v25_load_bin_s),
&be->flm.v25.load_pps, 1,
+ sizeof(struct flm_v25_load_pps_s),
&be->flm.v25.load_lps, 1,
+ sizeof(struct flm_v25_load_lps_s),
&be->flm.v25.load_aps, 1,
+ sizeof(struct flm_v25_load_aps_s),
&be->flm.v25.prio, 1,
+ sizeof(struct flm_v25_prio_s), &be->flm.v25.pst,
+ be->flm.nb_pst_profiles, sizeof(struct
flm_v25_pst_s),
+ &be->flm.v25.rcp, be->flm.nb_categories,
+ sizeof(struct flm_v25_rcp_s),
+ &be->flm.v25.buf_ctrl, 1, sizeof(struct
flm_v25_buf_ctrl_s),
+ &be->flm.v25.lrn_done, 1, sizeof(struct
flm_v25_stat_lrn_done_s),
+ &be->flm.v25.lrn_ignore, 1,
+ sizeof(struct flm_v25_stat_lrn_ignore_s),
+ &be->flm.v25.lrn_fail, 1, sizeof(struct
flm_v25_stat_lrn_fail_s),
+ &be->flm.v25.unl_done, 1, sizeof(struct
flm_v25_stat_unl_done_s),
+ &be->flm.v25.unl_ignore, 1,
+ sizeof(struct flm_v25_stat_unl_ignore_s),
+ &be->flm.v25.rel_done, 1, sizeof(struct
flm_v25_stat_rel_done_s),
+ &be->flm.v25.rel_ignore, 1,
+ sizeof(struct flm_v25_stat_rel_ignore_s),
+ &be->flm.v25.aul_done, 1, sizeof(struct
flm_v25_stat_aul_done_s),
+ &be->flm.v25.aul_ignore, 1,
+ sizeof(struct flm_v25_stat_aul_ignore_s),
+ &be->flm.v25.aul_fail, 1, sizeof(struct
flm_v25_stat_aul_fail_s),
+ &be->flm.v25.tul_done, 1, sizeof(struct
flm_v25_stat_tul_done_s),
+ &be->flm.v25.flows, 1, sizeof(struct
flm_v25_stat_flows_s),
+ &be->flm.v25.prb_done, 1, sizeof(struct
flm_v25_stat_prb_done_s),
+ &be->flm.v25.prb_ignore, 1,
+ sizeof(struct flm_v25_stat_prb_ignore_s),
+ &be->flm.v25.sta_done, 1, sizeof(struct
flm_v25_stat_sta_done_s),
+ &be->flm.v25.inf_done, 1, sizeof(struct
flm_v25_stat_inf_done_s),
+ &be->flm.v25.inf_skip, 1, sizeof(struct
flm_v25_stat_inf_skip_s),
+ &be->flm.v25.pck_hit, 1, sizeof(struct
flm_v25_stat_pck_hit_s),
+ &be->flm.v25.pck_miss, 1, sizeof(struct
flm_v25_stat_pck_miss_s),
+ &be->flm.v25.pck_unh, 1, sizeof(struct
flm_v25_stat_pck_unh_s),
+ &be->flm.v25.pck_dis, 1, sizeof(struct
flm_v25_stat_pck_dis_s),
+ &be->flm.v25.csh_hit, 1, sizeof(struct
flm_v25_stat_csh_hit_s),
+ &be->flm.v25.csh_miss, 1, sizeof(struct
flm_v25_stat_csh_miss_s),
+ &be->flm.v25.csh_unh, 1, sizeof(struct
flm_v25_stat_csh_unh_s),
+ &be->flm.v25.cuc_start, 1, sizeof(struct
flm_v25_stat_cuc_start_s),
+ &be->flm.v25.cuc_move, 1, sizeof(struct
flm_v25_stat_cuc_move_s),
+ &be->flm.v25.scan, 1, sizeof(struct
flm_v25_scan_s),
+ &be->flm.v25.scrub, be->flm.nb_scrub_profiles,
+ sizeof(struct flm_v25_scrub_s)))
+ return -1;
+
+ break;
+
+ default:
+ return UNSUP_VER;
+ }
+
+ return 0;
+}
+
+void hw_mod_flm_free(struct flow_api_backend_s *be)
+{
+ if (be->flm.base) {
+ free(be->flm.base);
+ be->flm.base = NULL;
+ }
+}
+
+int hw_mod_flm_reset(struct flow_api_backend_s *be)
+{
+ /* Zero entire cache area */
+ zero_module_cache((struct common_func_s *)(&be->flm));
+
+ NT_LOG(DBG, FILTER, "INIT FLM\n");
+ hw_mod_flm_control_set(be, HW_FLM_CONTROL_SPLIT_SDRAM_USAGE, 0x10);
+
+ hw_mod_flm_control_flush(be);
+ hw_mod_flm_scrub_flush(be, 0, ALL_ENTRIES);
+ hw_mod_flm_scan_flush(be);
+ hw_mod_flm_rcp_flush(be, 0, ALL_ENTRIES);
+
+ return 0;
+}
+
+int hw_mod_flm_control_flush(struct flow_api_backend_s *be)
+{
+ return be->iface->flm_control_flush(be->be_dev, &be->flm);
+}
+
+static int hw_mod_flm_control_mod(struct flow_api_backend_s *be, enum hw_flm_e
field,
+ uint32_t *value, int get)
+{
+ switch (_VER_) {
+ case 25:
+ switch (field) {
+ case HW_FLM_CONTROL_PRESET_ALL:
+ if (get)
+ return UNSUP_FIELD;
+
+ memset(be->flm.v25.control, (uint8_t)*value,
+ sizeof(struct flm_v25_control_s));
+ break;
+
+ case HW_FLM_CONTROL_ENABLE:
+ GET_SET(be->flm.v25.control->enable, value);
+ break;
+
+ case HW_FLM_CONTROL_INIT:
+ GET_SET(be->flm.v25.control->init, value);
+ break;
+
+ case HW_FLM_CONTROL_LDS:
+ GET_SET(be->flm.v25.control->lds, value);
+ break;
+
+ case HW_FLM_CONTROL_LFS:
+ GET_SET(be->flm.v25.control->lfs, value);
+ break;
+
+ case HW_FLM_CONTROL_LIS:
+ GET_SET(be->flm.v25.control->lis, value);
+ break;
+
+ case HW_FLM_CONTROL_UDS:
+ GET_SET(be->flm.v25.control->uds, value);
+ break;
+
+ case HW_FLM_CONTROL_UIS:
+ GET_SET(be->flm.v25.control->uis, value);
+ break;
+
+ case HW_FLM_CONTROL_RDS:
+ GET_SET(be->flm.v25.control->rds, value);
+ break;
+
+ case HW_FLM_CONTROL_RIS:
+ GET_SET(be->flm.v25.control->ris, value);
+ break;
+
+ case HW_FLM_CONTROL_PDS:
+ GET_SET(be->flm.v25.control->pds, value);
+ break;
+
+ case HW_FLM_CONTROL_PIS:
+ GET_SET(be->flm.v25.control->pis, value);
+ break;
+
+ case HW_FLM_CONTROL_CRCWR:
+ GET_SET(be->flm.v25.control->crcwr, value);
+ break;
+
+ case HW_FLM_CONTROL_CRCRD:
+ GET_SET(be->flm.v25.control->crcrd, value);
+ break;
+
+ case HW_FLM_CONTROL_RBL:
+ GET_SET(be->flm.v25.control->rbl, value);
+ break;
+
+ case HW_FLM_CONTROL_EAB:
+ GET_SET(be->flm.v25.control->eab, value);
+ break;
+
+ case HW_FLM_CONTROL_SPLIT_SDRAM_USAGE:
+ GET_SET(be->flm.v25.control->split_sdram_usage, value);
+ break;
+
+ default:
+ return UNSUP_FIELD;
+ }
+
+ break;
+
+ default:
+ return UNSUP_VER;
+ }
+
+ return 0;
+}
+
+int hw_mod_flm_control_set(struct flow_api_backend_s *be, enum hw_flm_e field,
uint32_t value)
+{
+ return hw_mod_flm_control_mod(be, field, &value, 0);
+}
+
+int hw_mod_flm_scan_flush(struct flow_api_backend_s *be)
+{
+ return be->iface->flm_scan_flush(be->be_dev, &be->flm);
+}
+
+int hw_mod_flm_rcp_flush(struct flow_api_backend_s *be, int start_idx, int
count)
+{
+ if (count == ALL_ENTRIES)
+ count = be->flm.nb_categories;
+
+ if ((unsigned int)(start_idx + count) > be->flm.nb_categories)
+ return INDEX_TOO_LARGE;
+
+ return be->iface->flm_rcp_flush(be->be_dev, &be->flm, start_idx, count);
+}
+
+int hw_mod_flm_scrub_flush(struct flow_api_backend_s *be, int start_idx, int
count)
+{
+ if (count == ALL_ENTRIES)
+ count = be->flm.nb_scrub_profiles;
+
+ if ((unsigned int)(start_idx + count) > be->flm.nb_scrub_profiles)
+ return INDEX_TOO_LARGE;
+
+ return be->iface->flm_scrub_flush(be->be_dev, &be->flm, start_idx,
count);
+}
--
2.45.0
