@@ -1044,5 +1044,4 @@ int bnxt_flow_ops_get_op(struct rte_eth_dev *dev,
int bnxt_dev_start_op(struct rte_eth_dev *eth_dev);
int bnxt_dev_stop_op(struct rte_eth_dev *eth_dev);
void bnxt_handle_vf_cfg_change(void *arg);
-
#endif
@@ -20,5 +20,4 @@ void bnxt_enable_int(struct bnxt *bp);
int bnxt_setup_int(struct bnxt *bp);
int bnxt_request_int(struct bnxt *bp);
void bnxt_int_handler(void *param);
-
#endif
@@ -66,5 +66,4 @@ enum bnxnvm_pkglog_field_index {
BNX_PKG_LOG_FIELD_IDX_INSTALLED_ITEMS = 5,
BNX_PKG_LOG_FIELD_IDX_INSTALLED_MASK = 6
};
-
#endif /* Don't add anything after this line */
@@ -142,5 +142,4 @@ static inline void bnxt_db_cq(struct bnxt_cp_ring_info *cpr)
B_CP_DIS_DB(cpr, cp_raw_cons);
}
}
-
#endif
@@ -386,5 +386,4 @@ bnxt_parse_pkt_type_v2(struct rte_mbuf *mbuf,
mbuf->packet_type = pkt_type;
}
-
#endif /* _BNXT_RXR_H_ */
@@ -90,5 +90,4 @@ int bnxt_flush_tx_cmp(struct bnxt_cp_ring_info *cpr);
TX_BD_LONG_LFLAGS_IP_CHKSUM)
#define TX_BD_FLG_TIP_TCP_UDP_CHKSUM (TX_BD_LONG_LFLAGS_TCP_UDP_CHKSUM | \
TX_BD_LONG_LFLAGS_T_IP_CHKSUM)
-
#endif
@@ -17,5 +17,4 @@
int bnxt_check_zero_bytes(const uint8_t *bytes, int len);
void bnxt_eth_hw_addr_random(uint8_t *mac_addr);
-
#endif /* _BNXT_UTIL_H_ */
@@ -63,7 +63,6 @@
#define CFA_RESOURCE_TYPE_P59_VEB_TCAM 0x18UL
#define CFA_RESOURCE_TYPE_P59_LAST CFA_RESOURCE_TYPE_P59_VEB_TCAM
-
/* Meter */
#define CFA_RESOURCE_TYPE_P58_METER 0x0UL
/* SRAM_Bank_0 */
@@ -184,7 +183,6 @@
#define CFA_RESOURCE_TYPE_P45_TBL_SCOPE 0x23UL
#define CFA_RESOURCE_TYPE_P45_LAST CFA_RESOURCE_TYPE_P45_TBL_SCOPE
-
/* Multicast Group */
#define CFA_RESOURCE_TYPE_P4_MCG 0x0UL
/* Encap 8 byte record */
new file mode 100644
@@ -0,0 +1,2116 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2021-2023 Broadcom
+ * All rights reserved.
+ */
+
+#include <inttypes.h>
+#include <signal.h>
+
+#include "hcapi_cfa_defs.h"
+
+#include "tfp.h"
+#include "tf_session.h"
+#include "tf_util.h"
+#include "cfa_tcam_mgr.h"
+#include "cfa_tcam_mgr_hwop_msg.h"
+#include "cfa_tcam_mgr_device.h"
+#include "cfa_tcam_mgr_session.h"
+#include "cfa_tcam_mgr_p58.h"
+#include "cfa_tcam_mgr_p4.h"
+
+#define TF_TCAM_SLICE_INVALID (-1)
+
+/*
+ * The following macros are for setting the entry status in a row entry.
+ * row is (struct cfa_tcam_mgr_table_rows_0 *)
+ */
+#define ROW_ENTRY_INUSE(row, entry) ((row)->entry_inuse & (1U << (entry)))
+#define ROW_ENTRY_SET(row, entry) ((row)->entry_inuse |= (1U << (entry)))
+#define ROW_ENTRY_CLEAR(row, entry) ((row)->entry_inuse &= ~(1U << (entry)))
+#define ROW_INUSE(row) ((row)->entry_inuse != 0)
+
+static struct cfa_tcam_mgr_entry_data *entry_data[TF_TCAM_MAX_SESSIONS];
+
+static int global_data_initialized[TF_TCAM_MAX_SESSIONS];
+int cfa_tcam_mgr_max_entries[TF_TCAM_MAX_SESSIONS];
+
+struct cfa_tcam_mgr_table_data
+cfa_tcam_mgr_tables[TF_TCAM_MAX_SESSIONS][TF_DIR_MAX][CFA_TCAM_MGR_TBL_TYPE_MAX];
+
+static int physical_table_types[CFA_TCAM_MGR_TBL_TYPE_MAX] = {
+ [CFA_TCAM_MGR_TBL_TYPE_L2_CTXT_TCAM_HIGH_APPS] =
+ TF_TCAM_TBL_TYPE_L2_CTXT_TCAM_HIGH,
+ [CFA_TCAM_MGR_TBL_TYPE_L2_CTXT_TCAM_LOW_APPS] =
+ TF_TCAM_TBL_TYPE_L2_CTXT_TCAM_LOW,
+ [CFA_TCAM_MGR_TBL_TYPE_PROF_TCAM_APPS] =
+ TF_TCAM_TBL_TYPE_PROF_TCAM,
+ [CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_APPS] =
+ TF_TCAM_TBL_TYPE_WC_TCAM,
+ [CFA_TCAM_MGR_TBL_TYPE_SP_TCAM_APPS] =
+ TF_TCAM_TBL_TYPE_SP_TCAM,
+ [CFA_TCAM_MGR_TBL_TYPE_CT_RULE_TCAM_APPS] =
+ TF_TCAM_TBL_TYPE_CT_RULE_TCAM,
+ [CFA_TCAM_MGR_TBL_TYPE_VEB_TCAM_APPS] =
+ TF_TCAM_TBL_TYPE_VEB_TCAM,
+ [CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_HIGH_APPS] =
+ TF_TCAM_TBL_TYPE_WC_TCAM_HIGH,
+ [CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_LOW_APPS] =
+ TF_TCAM_TBL_TYPE_WC_TCAM_LOW,
+};
+
+int
+cfa_tcam_mgr_get_phys_table_type(enum cfa_tcam_mgr_tbl_type type)
+{
+ if (type >= CFA_TCAM_MGR_TBL_TYPE_MAX)
+ assert(0);
+ else
+ return physical_table_types[type];
+}
+
+const char *
+cfa_tcam_mgr_tbl_2_str(enum cfa_tcam_mgr_tbl_type tcam_type)
+{
+ switch (tcam_type) {
+ case CFA_TCAM_MGR_TBL_TYPE_L2_CTXT_TCAM_HIGH_AFM:
+ return "l2_ctxt_tcam_high AFM";
+ case CFA_TCAM_MGR_TBL_TYPE_L2_CTXT_TCAM_HIGH_APPS:
+ return "l2_ctxt_tcam_high Apps";
+ case CFA_TCAM_MGR_TBL_TYPE_L2_CTXT_TCAM_LOW_AFM:
+ return "l2_ctxt_tcam_low AFM";
+ case CFA_TCAM_MGR_TBL_TYPE_L2_CTXT_TCAM_LOW_APPS:
+ return "l2_ctxt_tcam_low Apps";
+ case CFA_TCAM_MGR_TBL_TYPE_PROF_TCAM_AFM:
+ return "prof_tcam AFM";
+ case CFA_TCAM_MGR_TBL_TYPE_PROF_TCAM_APPS:
+ return "prof_tcam Apps";
+ case CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_AFM:
+ return "wc_tcam AFM";
+ case CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_APPS:
+ return "wc_tcam Apps";
+ case CFA_TCAM_MGR_TBL_TYPE_VEB_TCAM_AFM:
+ return "veb_tcam AFM";
+ case CFA_TCAM_MGR_TBL_TYPE_VEB_TCAM_APPS:
+ return "veb_tcam Apps";
+ case CFA_TCAM_MGR_TBL_TYPE_SP_TCAM_AFM:
+ return "sp_tcam AFM";
+ case CFA_TCAM_MGR_TBL_TYPE_SP_TCAM_APPS:
+ return "sp_tcam Apps";
+ case CFA_TCAM_MGR_TBL_TYPE_CT_RULE_TCAM_AFM:
+ return "ct_rule_tcam AFM";
+ case CFA_TCAM_MGR_TBL_TYPE_CT_RULE_TCAM_APPS:
+ return "ct_rule_tcam Apps";
+ case CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_HIGH_AFM:
+ return "wc_tcam_high AFM";
+ case CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_HIGH_APPS:
+ return "wc_tcam_high Apps";
+ case CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_LOW_AFM:
+ return "wc_tcam_low AFM";
+ case CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_LOW_APPS:
+ return "wc_tcam_low Apps";
+ default:
+ return "Invalid tcam table type";
+ }
+}
+
+/* key_size and slice_width are in bytes */
+static int
+cfa_tcam_mgr_get_num_slices(unsigned int key_size, unsigned int slice_width)
+{
+ int num_slices = 0;
+
+ if (key_size == 0)
+ return -CFA_TCAM_MGR_ERR_CODE(INVAL);
+
+ num_slices = ((key_size - 1U) / slice_width) + 1U;
+ /* Round up to next highest power of 2 */
+ /* This is necessary since, for example, 3 slices is not a valid entry
+ * width.
+ */
+ num_slices--;
+ /* Repeat to maximum number of bits actually used */
+ /* This fills in all the bits. */
+ num_slices |= num_slices >> 1;
+ num_slices |= num_slices >> 2;
+ num_slices |= num_slices >> 4;
+ /*
+ * If the maximum number of slices that are supported by the HW
+ * increases, then additional shifts are needed.
+ */
+ num_slices++;
+ return num_slices;
+}
+
+static struct cfa_tcam_mgr_entry_data *
+cfa_tcam_mgr_entry_get(int sess_idx, uint16_t id)
+{
+ if (id > cfa_tcam_mgr_max_entries[sess_idx])
+ return NULL;
+
+ return &entry_data[sess_idx][id];
+}
+
+/* Insert an entry into the entry table */
+static int
+cfa_tcam_mgr_entry_insert(int sess_idx, uint16_t id,
+ struct cfa_tcam_mgr_entry_data *entry)
+{
+ if (id > cfa_tcam_mgr_max_entries[sess_idx])
+ return -CFA_TCAM_MGR_ERR_CODE(INVAL);
+
+ memcpy(&entry_data[sess_idx][id], entry,
+ sizeof(entry_data[sess_idx][id]));
+
+ return 0;
+}
+
+/* Delete an entry from the entry table */
+static int
+cfa_tcam_mgr_entry_delete(int sess_idx, uint16_t id)
+{
+ if (id > cfa_tcam_mgr_max_entries[sess_idx])
+ return -CFA_TCAM_MGR_ERR_CODE(INVAL);
+
+ memset(&entry_data[sess_idx][id], 0, sizeof(entry_data[sess_idx][id]));
+
+ return 0;
+}
+
+/* Returns the size of the row structure taking into account how many slices a
+ * TCAM supports.
+ */
+static int
+cfa_tcam_mgr_row_size_get(int sess_idx, enum tf_dir dir,
+ enum cfa_tcam_mgr_tbl_type type)
+{
+ return sizeof(struct cfa_tcam_mgr_table_rows_0) +
+ (cfa_tcam_mgr_tables[sess_idx][dir][type].max_slices *
+ sizeof(((struct cfa_tcam_mgr_table_rows_0 *)0)->entries[0]));
+}
+
+static void *
+cfa_tcam_mgr_row_ptr_get(void *base, int index, int row_size)
+{
+ return (uint8_t *)base + (index * row_size);
+}
+
+/*
+ * Searches a table to find the direction and type of an entry.
+ */
+static int
+cfa_tcam_mgr_entry_find_in_table(int sess_idx, int id, enum tf_dir dir,
+ enum cfa_tcam_mgr_tbl_type type)
+{
+ struct cfa_tcam_mgr_table_data *table_data;
+ struct cfa_tcam_mgr_table_rows_0 *row;
+ int max_slices, row_idx, row_size, slice;
+
+ table_data = &cfa_tcam_mgr_tables[sess_idx][dir][type];
+ if (table_data->max_entries > 0 &&
+ table_data->hcapi_type > 0) {
+ max_slices = table_data->max_slices;
+ row_size = cfa_tcam_mgr_row_size_get(sess_idx, dir, type);
+ for (row_idx = table_data->start_row;
+ row_idx <= table_data->end_row;
+ row_idx++) {
+ row = cfa_tcam_mgr_row_ptr_get(table_data->tcam_rows,
+ row_idx, row_size);
+ if (!ROW_INUSE(row))
+ continue;
+ for (slice = 0;
+ slice < (max_slices / row->entry_size);
+ slice++) {
+ if (!ROW_ENTRY_INUSE(row, slice))
+ continue;
+ if (row->entries[slice] == id)
+ return 0;
+ }
+ }
+ }
+
+ return -CFA_TCAM_MGR_ERR_CODE(NOENT);
+}
+
+/*
+ * Searches all the tables to find the direction and type of an entry.
+ */
+static int
+cfa_tcam_mgr_entry_find(int sess_idx, int id, enum tf_dir *tbl_dir,
+ enum cfa_tcam_mgr_tbl_type *tbl_type)
+{
+ enum tf_dir dir;
+ enum cfa_tcam_mgr_tbl_type type;
+ int rc = -CFA_TCAM_MGR_ERR_CODE(NOENT);
+
+ for (dir = TF_DIR_RX; dir < ARRAY_SIZE(cfa_tcam_mgr_tables[sess_idx]); dir++) {
+ for (type = CFA_TCAM_MGR_TBL_TYPE_START;
+ type < ARRAY_SIZE(cfa_tcam_mgr_tables[sess_idx][dir]);
+ type++) {
+ rc = cfa_tcam_mgr_entry_find_in_table(sess_idx, id, dir, type);
+ if (rc == 0) {
+ *tbl_dir = dir;
+ *tbl_type = type;
+ return rc;
+ }
+ }
+ }
+
+ return rc;
+}
+
+static int
+cfa_tcam_mgr_row_is_entry_free(struct cfa_tcam_mgr_table_rows_0 *row,
+ int max_slices,
+ int key_slices)
+{
+ int j;
+
+ if (ROW_INUSE(row) &&
+ row->entry_size == key_slices) {
+ for (j = 0; j < (max_slices / row->entry_size); j++) {
+ if (!ROW_ENTRY_INUSE(row, j))
+ return j;
+ }
+ }
+ return -1;
+}
+
+static int
+cfa_tcam_mgr_entry_move(int sess_idx, struct cfa_tcam_mgr_context *context,
+ enum tf_dir dir, enum cfa_tcam_mgr_tbl_type type,
+ int entry_id,
+ struct cfa_tcam_mgr_table_data *table_data,
+ int dest_row_index, int dest_row_slice,
+ struct cfa_tcam_mgr_table_rows_0 *dest_row,
+ int source_row_index,
+ struct cfa_tcam_mgr_table_rows_0 *source_row,
+ bool free_source_entry)
+{
+ struct cfa_tcam_mgr_get_parms gparms = { 0 };
+ struct cfa_tcam_mgr_set_parms sparms = { 0 };
+ struct cfa_tcam_mgr_free_parms fparms = { 0 };
+ struct cfa_tcam_mgr_entry_data *entry;
+ uint8_t key[CFA_TCAM_MGR_MAX_KEY_SIZE];
+ uint8_t mask[CFA_TCAM_MGR_MAX_KEY_SIZE];
+ uint8_t result[CFA_TCAM_MGR_MAX_KEY_SIZE];
+
+ int j, rc;
+
+ entry = cfa_tcam_mgr_entry_get(sess_idx, entry_id);
+ if (entry == NULL)
+ return -1;
+
+ gparms.dir = dir;
+ gparms.type = type;
+ gparms.hcapi_type = table_data->hcapi_type;
+ gparms.key = key;
+ gparms.mask = mask;
+ gparms.result = result;
+ gparms.id = source_row->entries[entry->slice];
+ gparms.key_size = sizeof(key);
+ gparms.result_size = sizeof(result);
+
+ rc = cfa_tcam_mgr_entry_get_msg(sess_idx, context, &gparms,
+ source_row_index,
+ entry->slice * source_row->entry_size,
+ table_data->max_slices);
+ if (rc != 0)
+ return rc;
+
+ sparms.dir = dir;
+ sparms.type = type;
+ sparms.hcapi_type = table_data->hcapi_type;
+ sparms.key = key;
+ sparms.mask = mask;
+ sparms.result = result;
+ sparms.id = gparms.id;
+ sparms.key_size = gparms.key_size;
+ sparms.result_size = gparms.result_size;
+
+ /* Slice in destination row not specified. Find first free slice. */
+ if (dest_row_slice < 0)
+ for (j = 0;
+ j < (table_data->max_slices / dest_row->entry_size);
+ j++) {
+ if (!ROW_ENTRY_INUSE(dest_row, j)) {
+ dest_row_slice = j;
+ break;
+ }
+ }
+
+ /* If no free slice found, return error. */
+ if (dest_row_slice < 0)
+ return -CFA_TCAM_MGR_ERR_CODE(PERM);
+
+ rc = cfa_tcam_mgr_entry_set_msg(sess_idx, context, &sparms,
+ dest_row_index,
+ dest_row_slice * dest_row->entry_size,
+ table_data->max_slices);
+ if (rc != 0)
+ return rc;
+
+ if (free_source_entry) {
+ fparms.dir = dir;
+ fparms.type = type;
+ fparms.hcapi_type = table_data->hcapi_type;
+ rc = cfa_tcam_mgr_entry_free_msg(sess_idx, context, &fparms,
+ source_row_index,
+ entry->slice *
+ dest_row->entry_size,
+ table_data->row_width /
+ table_data->max_slices *
+ source_row->entry_size,
+ table_data->result_size,
+ table_data->max_slices);
+ if (rc != 0) {
+ CFA_TCAM_MGR_LOG_DIR_TYPE(ERR,
+ dir, type,
+ "Failed to free entry ID %d at"
+ " row %d, slice %d for sess_idx %d. rc: %d.\n",
+ gparms.id,
+ source_row_index,
+ entry->slice,
+ sess_idx,
+ -rc);
+ }
+ }
+
+ ROW_ENTRY_SET(dest_row, dest_row_slice);
+ dest_row->entries[dest_row_slice] = entry_id;
+ ROW_ENTRY_CLEAR(source_row, entry->slice);
+ entry->row = dest_row_index;
+ entry->slice = dest_row_slice;
+
+ return 0;
+}
+
+static int
+cfa_tcam_mgr_row_move(int sess_idx, struct cfa_tcam_mgr_context *context,
+ enum tf_dir dir, enum cfa_tcam_mgr_tbl_type type,
+ struct cfa_tcam_mgr_table_data *table_data,
+ int dest_row_index,
+ struct cfa_tcam_mgr_table_rows_0 *dest_row,
+ int source_row_index,
+ struct cfa_tcam_mgr_table_rows_0 *source_row)
+{
+ struct cfa_tcam_mgr_free_parms fparms = { 0 };
+ int j, rc;
+
+ dest_row->priority = source_row->priority;
+ dest_row->entry_size = source_row->entry_size;
+ dest_row->entry_inuse = 0;
+
+ fparms.dir = dir;
+ fparms.type = type;
+ fparms.hcapi_type = table_data->hcapi_type;
+
+ for (j = 0;
+ j < (table_data->max_slices / source_row->entry_size);
+ j++) {
+ if (ROW_ENTRY_INUSE(source_row, j)) {
+ cfa_tcam_mgr_entry_move(sess_idx, context, dir, type,
+ source_row->entries[j],
+ table_data,
+ dest_row_index, j, dest_row,
+ source_row_index, source_row,
+ true);
+ } else {
+ /* Slice not in use, write an empty slice. */
+ rc = cfa_tcam_mgr_entry_free_msg(sess_idx, context, &fparms,
+ dest_row_index,
+ j *
+ dest_row->entry_size,
+ table_data->row_width /
+ table_data->max_slices *
+ dest_row->entry_size,
+ table_data->result_size,
+ table_data->max_slices);
+ if (rc != 0)
+ return rc;
+ }
+ }
+
+ return 0;
+}
+
+/* Install entry into in-memory tables, not into TCAM (yet). */
+static void
+cfa_tcam_mgr_row_entry_install(int sess_idx,
+ struct cfa_tcam_mgr_table_rows_0 *row,
+ struct cfa_tcam_mgr_alloc_parms *parms,
+ struct cfa_tcam_mgr_entry_data *entry,
+ uint16_t id,
+ int key_slices,
+ int row_index, int slice)
+{
+ if (global_data_initialized[sess_idx] == 0) {
+ CFA_TCAM_MGR_LOG(INFO, "PANIC: No TCAM data created for sess_idx %d\n",
+ sess_idx);
+ return;
+ }
+
+ if (slice == TF_TCAM_SLICE_INVALID) {
+ slice = 0;
+ row->entry_size = key_slices;
+ row->priority = parms->priority;
+ }
+
+ ROW_ENTRY_SET(row, slice);
+ row->entries[slice] = id;
+ entry->row = row_index;
+ entry->slice = slice;
+}
+
+/* Finds an empty row that can be used and reserve for entry. If necessary,
+ * entries will be shuffled in order to make room.
+ */
+static struct cfa_tcam_mgr_table_rows_0 *
+cfa_tcam_mgr_empty_row_alloc(int sess_idx, struct cfa_tcam_mgr_context *context,
+ struct cfa_tcam_mgr_alloc_parms *parms,
+ struct cfa_tcam_mgr_entry_data *entry,
+ uint16_t id,
+ int key_slices)
+{
+ struct cfa_tcam_mgr_table_rows_0 *tcam_rows;
+ struct cfa_tcam_mgr_table_rows_0 *from_row;
+ struct cfa_tcam_mgr_table_rows_0 *to_row;
+ struct cfa_tcam_mgr_table_rows_0 *row;
+ struct cfa_tcam_mgr_table_data *table_data;
+ int i, max_slices, row_size;
+ int to_row_idx, from_row_idx, slice, start_row, end_row;
+ int empty_row = -1;
+ int target_row = -1;
+
+ table_data = &cfa_tcam_mgr_tables[sess_idx][parms->dir][parms->type];
+
+ start_row = table_data->start_row;
+ end_row = table_data->end_row;
+ max_slices = table_data->max_slices;
+ tcam_rows = table_data->tcam_rows;
+
+ row_size = cfa_tcam_mgr_row_size_get(sess_idx, parms->dir, parms->type);
+
+ /*
+ * First check for partially used entries, but only if the key needs
+ * fewer slices than there are in a row.
+ */
+ if (key_slices < max_slices) {
+ for (i = start_row; i <= end_row; i++) {
+ row = cfa_tcam_mgr_row_ptr_get(tcam_rows, i, row_size);
+ if (!ROW_INUSE(row))
+ continue;
+ if (row->priority < parms->priority)
+ break;
+ if (row->priority > parms->priority)
+ continue;
+ slice = cfa_tcam_mgr_row_is_entry_free(row,
+ max_slices,
+ key_slices);
+ if (slice >= 0) {
+ cfa_tcam_mgr_row_entry_install(sess_idx, row, parms,
+ entry, id,
+ key_slices,
+ i, slice);
+ return row;
+ }
+ }
+ }
+
+ /* No partially used rows available. Find an empty row, if any. */
+
+ /*
+ * All max priority entries are placed in the beginning of the TCAM. It
+ * should not be necessary to shuffle any of these entries. All other
+ * priorities are placed from the end of the TCAM and may require
+ * shuffling.
+ */
+ if (parms->priority == TF_TCAM_PRIORITY_MAX) {
+ /* Handle max priority first. */
+ for (i = start_row; i <= end_row; i++) {
+ row = cfa_tcam_mgr_row_ptr_get(tcam_rows, i, row_size);
+ if (!ROW_INUSE(row)) {
+ cfa_tcam_mgr_row_entry_install(sess_idx,
+ row, parms,
+ entry,
+ id, key_slices,
+ i,
+ TF_TCAM_SLICE_INVALID);
+ return row;
+ }
+ if (row->priority < parms->priority) {
+ /*
+ * No free entries before priority change, table
+ * is full.
+ */
+ return NULL;
+ }
+ }
+ /* No free entries found, table is full. */
+ return NULL;
+ }
+
+ /* Use the highest available entry */
+ for (i = end_row; i >= start_row; i--) {
+ row = cfa_tcam_mgr_row_ptr_get(tcam_rows, i, row_size);
+ if (!ROW_INUSE(row)) {
+ empty_row = i;
+ break;
+ }
+
+ if (row->priority > parms->priority &&
+ target_row < 0)
+ target_row = i;
+ }
+
+ if (empty_row < 0) {
+ /* No free entries found, table is full. */
+ return NULL;
+ }
+
+ if (target_row < 0) {
+ /*
+ * Did not find a row with higher priority before unused row so
+ * just install new entry in empty_row.
+ */
+ row = cfa_tcam_mgr_row_ptr_get(tcam_rows, empty_row, row_size);
+ cfa_tcam_mgr_row_entry_install(sess_idx, row, parms, entry, id,
+ key_slices, empty_row,
+ TF_TCAM_SLICE_INVALID);
+ return row;
+ }
+
+ to_row_idx = empty_row;
+ to_row = cfa_tcam_mgr_row_ptr_get(tcam_rows, to_row_idx, row_size);
+ while (to_row_idx < target_row) {
+ from_row_idx = to_row_idx + 1;
+ from_row = cfa_tcam_mgr_row_ptr_get(tcam_rows, from_row_idx,
+ row_size);
+ /*
+ * Find the highest row with the same priority as the initial
+ * source row (from_row). It's only necessary to copy one row
+ * of each priority.
+ */
+ for (i = from_row_idx + 1; i <= target_row; i++) {
+ row = cfa_tcam_mgr_row_ptr_get(tcam_rows, i, row_size);
+ if (row->priority != from_row->priority)
+ break;
+ from_row_idx = i;
+ from_row = row;
+ }
+ cfa_tcam_mgr_row_move(sess_idx, context, parms->dir, parms->type,
+ table_data, to_row_idx, to_row,
+ from_row_idx, from_row);
+ to_row = from_row;
+ to_row_idx = from_row_idx;
+ }
+ to_row = cfa_tcam_mgr_row_ptr_get(tcam_rows, target_row, row_size);
+ memset(to_row, 0, row_size);
+ cfa_tcam_mgr_row_entry_install(sess_idx, to_row, parms, entry, id,
+ key_slices, target_row,
+ TF_TCAM_SLICE_INVALID);
+
+ return row;
+}
+
+/*
+ * This function will combine rows when possible to result in the fewest rows
+ * used necessary for the entries that are installed.
+ */
+static void
+cfa_tcam_mgr_rows_combine(int sess_idx, struct cfa_tcam_mgr_context *context,
+ struct cfa_tcam_mgr_free_parms *parms,
+ struct cfa_tcam_mgr_table_data *table_data,
+ int changed_row_index)
+{
+ struct cfa_tcam_mgr_table_rows_0 *from_row = NULL;
+ struct cfa_tcam_mgr_table_rows_0 *to_row;
+ struct cfa_tcam_mgr_table_rows_0 *tcam_rows;
+ int i, j, row_size;
+ int to_row_idx, from_row_idx, start_row, end_row, max_slices;
+ bool entry_moved = false;
+
+ start_row = table_data->start_row;
+ end_row = table_data->end_row;
+ max_slices = table_data->max_slices;
+ tcam_rows = table_data->tcam_rows;
+
+ row_size = cfa_tcam_mgr_row_size_get(sess_idx, parms->dir, parms->type);
+
+ from_row_idx = changed_row_index;
+ from_row = cfa_tcam_mgr_row_ptr_get(tcam_rows, from_row_idx, row_size);
+
+ if (ROW_INUSE(from_row)) {
+ /*
+ * Row is still in partial use. See if remaining entry(s) can
+ * be moved to free up a row.
+ */
+ for (i = 0; i < (max_slices / from_row->entry_size); i++) {
+ if (!ROW_ENTRY_INUSE(from_row, i))
+ continue;
+ for (to_row_idx = end_row;
+ to_row_idx >= start_row;
+ to_row_idx--) {
+ to_row = cfa_tcam_mgr_row_ptr_get(tcam_rows,
+ to_row_idx,
+ row_size);
+ if (!ROW_INUSE(to_row))
+ continue;
+ if (to_row->priority > from_row->priority)
+ break;
+ if (to_row->priority != from_row->priority)
+ continue;
+ if (to_row->entry_size != from_row->entry_size)
+ continue;
+ if (to_row_idx == changed_row_index)
+ continue;
+ for (j = 0;
+ j < (max_slices / to_row->entry_size);
+ j++) {
+ if (!ROW_ENTRY_INUSE(to_row, j)) {
+ cfa_tcam_mgr_entry_move
+ (sess_idx,
+ context,
+ parms->dir,
+ parms->type,
+ from_row->entries[i],
+ table_data,
+ to_row_idx,
+ -1, to_row,
+ from_row_idx,
+ from_row,
+ true);
+ entry_moved = true;
+ break;
+ }
+ }
+ if (entry_moved)
+ break;
+ }
+ if (ROW_INUSE(from_row))
+ entry_moved = false;
+ else
+ break;
+ }
+ }
+}
+
+/*
+ * This function will ensure that all rows, except those of the highest
+ * priority, at the end of the table. When this function is finished, all the
+ * empty rows should be between the highest priority rows at the beginning of
+ * the table and the rest of the rows with lower priorities.
+ */
+/*
+ * Will need to free the row left newly empty as a result of moving.
+ *
+ * Return row to free to caller. If new_row_to_free < 0, then no new row to
+ * free.
+ */
+static void
+cfa_tcam_mgr_rows_compact(int sess_idx, struct cfa_tcam_mgr_context *context,
+ struct cfa_tcam_mgr_free_parms *parms,
+ struct cfa_tcam_mgr_table_data *table_data,
+ int *new_row_to_free,
+ int changed_row_index)
+{
+ struct cfa_tcam_mgr_table_rows_0 *from_row = NULL;
+ struct cfa_tcam_mgr_table_rows_0 *to_row;
+ struct cfa_tcam_mgr_table_rows_0 *row;
+ struct cfa_tcam_mgr_table_rows_0 *tcam_rows;
+ int i, row_size, priority;
+ int to_row_idx = 0, from_row_idx = 0, start_row = 0, end_row = 0;
+
+ *new_row_to_free = -1;
+
+ start_row = table_data->start_row;
+ end_row = table_data->end_row;
+ tcam_rows = table_data->tcam_rows;
+
+ row_size = cfa_tcam_mgr_row_size_get(sess_idx, parms->dir, parms->type);
+
+ /*
+ * The row is no longer in use, so see if rows need to be moved in order
+ * to not leave any gaps.
+ */
+ to_row_idx = changed_row_index;
+ to_row = cfa_tcam_mgr_row_ptr_get(tcam_rows, to_row_idx, row_size);
+
+ priority = to_row->priority;
+ if (priority == TF_TCAM_PRIORITY_MAX) {
+ if (changed_row_index == end_row)
+ /*
+ * Nothing to move - the last row in the TCAM is being
+ * deleted.
+ */
+ return;
+ for (i = changed_row_index + 1; i <= end_row; i++) {
+ row = cfa_tcam_mgr_row_ptr_get(tcam_rows, i, row_size);
+ if (!ROW_INUSE(row))
+ break;
+
+ if (row->priority < priority)
+ break;
+
+ from_row = row;
+ from_row_idx = i;
+ }
+ } else {
+ if (changed_row_index == start_row)
+ /*
+ * Nothing to move - the first row in the TCAM is being
+ * deleted.
+ */
+ return;
+ for (i = changed_row_index - 1; i >= start_row; i--) {
+ row = cfa_tcam_mgr_row_ptr_get(tcam_rows, i, row_size);
+ if (!ROW_INUSE(row))
+ break;
+
+ if (row->priority > priority) {
+ /* Don't move the highest priority rows. */
+ if (row->priority == TF_TCAM_PRIORITY_MAX)
+ break;
+ /*
+ * If from_row is NULL, that means that there
+ * were no rows of the deleted priority.
+ * Nothing to move yet.
+ *
+ * If from_row is not NULL, then it is the last
+ * row with the same priority and must be moved
+ * to fill the newly empty (by free or by move)
+ * row.
+ */
+ if (from_row != NULL) {
+ cfa_tcam_mgr_row_move(sess_idx, context,
+ parms->dir,
+ parms->type,
+ table_data,
+ to_row_idx, to_row,
+ from_row_idx,
+ from_row);
+ *new_row_to_free = from_row_idx;
+ to_row = from_row;
+ to_row_idx = from_row_idx;
+ }
+
+ priority = row->priority;
+ }
+ from_row = row;
+ from_row_idx = i;
+ }
+ }
+
+ if (from_row != NULL) {
+ cfa_tcam_mgr_row_move(sess_idx, context, parms->dir, parms->type,
+ table_data,
+ to_row_idx, to_row,
+ from_row_idx, from_row);
+ *new_row_to_free = from_row_idx;
+ }
+}
+
+/*
+ * This function is to set table limits for the logical TCAM tables.
+ */
+static int
+cfa_tcam_mgr_table_limits_set(int sess_idx, struct cfa_tcam_mgr_init_parms *parms)
+{
+ struct cfa_tcam_mgr_table_data *table_data;
+ unsigned int dir, type;
+ int start, stride;
+
+ if (parms == NULL)
+ return 0;
+
+ for (dir = 0; dir < ARRAY_SIZE(cfa_tcam_mgr_tables[sess_idx]); dir++)
+ for (type = 0;
+ type < ARRAY_SIZE(cfa_tcam_mgr_tables[sess_idx][dir]);
+ type++) {
+ table_data = &cfa_tcam_mgr_tables[sess_idx][dir][type];
+ /*
+ * If num_rows is zero, then TCAM Manager did not
+ * allocate any row storage for that table so cannot
+ * manage it.
+ */
+ if (table_data->num_rows == 0)
+ continue;
+ start = parms->resc[dir][type].start;
+ stride = parms->resc[dir][type].stride;
+ if (start % table_data->max_slices > 0) {
+ CFA_TCAM_MGR_LOG_DIR_TYPE(ERR, dir, type,
+ "Start of resources (%d) for table (%d) "
+ "does not begin on row boundary.\n",
+ start, sess_idx);
+ CFA_TCAM_MGR_LOG_DIR(ERR, dir,
+ "Start is %d, number of slices "
+ "is %d.\n",
+ start,
+ table_data->max_slices);
+ return -CFA_TCAM_MGR_ERR_CODE(INVAL);
+ }
+ if (stride % table_data->max_slices > 0) {
+ CFA_TCAM_MGR_LOG_DIR_TYPE(ERR, dir, type,
+ "Stride of resources (%d) for table (%d)"
+ " does not end on row boundary.\n",
+ stride, sess_idx);
+ CFA_TCAM_MGR_LOG_DIR(ERR, dir,
+ "Stride is %d, number of "
+ "slices is %d.\n",
+ stride,
+ table_data->max_slices);
+ return -CFA_TCAM_MGR_ERR_CODE(INVAL);
+ }
+ if (stride == 0) {
+ table_data->start_row = 0;
+ table_data->end_row = 0;
+ table_data->max_entries = 0;
+ } else {
+ table_data->start_row = start /
+ table_data->max_slices;
+ table_data->end_row = table_data->start_row +
+ (stride / table_data->max_slices) - 1;
+ table_data->max_entries =
+ table_data->max_slices *
+ (table_data->end_row -
+ table_data->start_row + 1);
+ }
+ }
+
+ return 0;
+}
+
+int
+cfa_tcam_mgr_init(int sess_idx, enum cfa_tcam_mgr_device_type type,
+ struct cfa_tcam_mgr_init_parms *parms)
+{
+ struct cfa_tcam_mgr_table_data *table_data;
+ unsigned int dir, tbl_type;
+ int rc;
+
+ switch (type) {
+ case CFA_TCAM_MGR_DEVICE_TYPE_P4:
+ case CFA_TCAM_MGR_DEVICE_TYPE_SR:
+ rc = cfa_tcam_mgr_init_p4(sess_idx, &entry_data[sess_idx]);
+ break;
+ case CFA_TCAM_MGR_DEVICE_TYPE_P5:
+ rc = cfa_tcam_mgr_init_p58(sess_idx, &entry_data[sess_idx]);
+ break;
+ default:
+ CFA_TCAM_MGR_LOG(ERR, "No such device %d for sess_idx %d\n",
+ type, sess_idx);
+ return -CFA_TCAM_MGR_ERR_CODE(NODEV);
+ }
+ if (rc < 0)
+ return rc;
+
+ rc = cfa_tcam_mgr_table_limits_set(sess_idx, parms);
+ if (rc < 0)
+ return rc;
+
+ /* Now calculate the max entries per table and global max entries based
+ * on the updated table limits.
+ */
+ for (dir = 0; dir < ARRAY_SIZE(cfa_tcam_mgr_tables[sess_idx]); dir++)
+ for (tbl_type = 0;
+ tbl_type < ARRAY_SIZE(cfa_tcam_mgr_tables[sess_idx][dir]);
+ tbl_type++) {
+ table_data = &cfa_tcam_mgr_tables[sess_idx][dir][tbl_type];
+ /*
+ * If num_rows is zero, then TCAM Manager did not
+ * allocate any row storage for that table so cannot
+ * manage it.
+ */
+ if (table_data->num_rows == 0) {
+ table_data->start_row = 0;
+ table_data->end_row = 0;
+ table_data->max_entries = 0;
+ } else if (table_data->end_row >=
+ table_data->num_rows) {
+ CFA_TCAM_MGR_LOG_DIR_TYPE(EMERG, dir, tbl_type,
+ "End row is out of "
+ "range (%d >= %d) for sess_idx %d\n",
+ table_data->end_row,
+ table_data->num_rows,
+ sess_idx);
+ return -CFA_TCAM_MGR_ERR_CODE(FAULT);
+ } else if (table_data->max_entries == 0 &&
+ table_data->start_row == 0 &&
+ table_data->end_row == 0) {
+ /* Nothing to do */
+ } else {
+ table_data->max_entries =
+ table_data->max_slices *
+ (table_data->end_row -
+ table_data->start_row + 1);
+ }
+ cfa_tcam_mgr_max_entries[sess_idx] += table_data->max_entries;
+ }
+
+ rc = cfa_tcam_mgr_hwops_init(type);
+ if (rc < 0)
+ return rc;
+
+ rc = cfa_tcam_mgr_session_init(sess_idx, type);
+ if (rc < 0)
+ return rc;
+
+ global_data_initialized[sess_idx] = 1;
+
+ if (parms != NULL)
+ parms->max_entries = cfa_tcam_mgr_max_entries[sess_idx];
+
+ CFA_TCAM_MGR_LOG(INFO, "Global TCAM table initialized for sess_idx %d.\n",
+ sess_idx);
+
+ return 0;
+}
+
+int
+cfa_tcam_mgr_qcaps(struct cfa_tcam_mgr_context *context __rte_unused,
+ struct cfa_tcam_mgr_qcaps_parms *parms)
+{
+ unsigned int type;
+ int rc, sess_idx;
+ uint32_t session_id;
+
+ CFA_TCAM_MGR_CHECK_PARMS2(context, parms);
+
+ rc = cfa_tcam_mgr_get_session_from_context(context, &session_id);
+ if (rc < 0)
+ return rc;
+
+ sess_idx = cfa_tcam_mgr_session_find(session_id);
+ if (sess_idx < 0) {
+ CFA_TCAM_MGR_LOG_0(ERR, "Session not found.\n");
+ return sess_idx;
+ }
+
+ if (global_data_initialized[sess_idx] == 0) {
+ CFA_TCAM_MGR_LOG(ERR, "PANIC: No TCAM data created for sess_idx %d\n",
+ sess_idx);
+ return -CFA_TCAM_MGR_ERR_CODE(PERM);
+ }
+
+ /*
+ * This code will indicate if TCAM Manager is managing a logical TCAM
+ * table or not. If not, then the physical TCAM will have to be
+ * accessed using the traditional methods.
+ */
+ parms->rx_tcam_supported = 0;
+ parms->tx_tcam_supported = 0;
+ for (type = 0; type < CFA_TCAM_MGR_TBL_TYPE_MAX; type++) {
+ if (cfa_tcam_mgr_tables[sess_idx][TF_DIR_RX][type].max_entries > 0 &&
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_RX][type].hcapi_type > 0)
+ parms->rx_tcam_supported |= 1 << cfa_tcam_mgr_get_phys_table_type(type);
+ if (cfa_tcam_mgr_tables[sess_idx][TF_DIR_TX][type].max_entries > 0 &&
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_TX][type].hcapi_type > 0)
+ parms->tx_tcam_supported |= 1 << cfa_tcam_mgr_get_phys_table_type(type);
+ }
+
+ return 0;
+}
+
+/*
+ * Manipulate the tables to split the WC TCAM into HIGH and LOW ranges
+ * and also update the sizes in the tcam count array
+ */
+static int
+cfa_tcam_mgr_shared_wc_bind(uint32_t sess_idx, bool dual_ha_app,
+ uint16_t tcam_cnt[][CFA_TCAM_MGR_TBL_TYPE_MAX])
+{
+ uint16_t start_row, end_row, max_entries, slices;
+ uint16_t num_pools = dual_ha_app ? 4 : 2;
+ enum tf_dir dir;
+ int rc;
+
+ for (dir = 0; dir < TF_DIR_MAX; dir++) {
+ rc = cfa_tcam_mgr_tables_get(sess_idx, dir,
+ CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_APPS,
+ &start_row, &end_row, &max_entries, &slices);
+ if (rc)
+ return rc;
+ if (max_entries) {
+ rc = cfa_tcam_mgr_tables_set(sess_idx, dir,
+ CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_HIGH_APPS,
+ start_row,
+ start_row +
+ ((max_entries / slices) / num_pools) - 1,
+ max_entries / num_pools);
+ if (rc)
+ return rc;
+ rc = cfa_tcam_mgr_tables_set(sess_idx, dir,
+ CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_LOW_APPS,
+ start_row +
+ ((max_entries / slices) / num_pools),
+ start_row +
+ (max_entries / slices) - 1,
+ max_entries / num_pools);
+ if (rc)
+ return rc;
+ rc = cfa_tcam_mgr_tables_set(sess_idx, dir,
+ CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_APPS,
+ 0, 0, 0);
+ if (rc)
+ return rc;
+ tcam_cnt[dir][CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_HIGH_APPS] =
+ max_entries / num_pools;
+ tcam_cnt[dir][CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_LOW_APPS] =
+ max_entries / num_pools;
+ tcam_cnt[dir][CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_APPS] = 0;
+ }
+ }
+
+ return 0;
+}
+
+int
+cfa_tcam_mgr_bind(struct cfa_tcam_mgr_context *context,
+ struct cfa_tcam_mgr_cfg_parms *parms)
+{
+ struct cfa_tcam_mgr_table_data *table_data;
+ struct tf_dev_info *dev;
+ unsigned int dir;
+ int rc, sess_idx;
+ uint32_t session_id;
+ struct tf_session *tfs;
+ unsigned int type;
+ int prev_max_entries;
+ int start, stride;
+ enum cfa_tcam_mgr_device_type device_type;
+
+ CFA_TCAM_MGR_CHECK_PARMS2(context, parms);
+
+ /* Retrieve the session information */
+ rc = tf_session_get_session_internal(context->tfp, &tfs);
+ if (rc)
+ return rc;
+
+ /* Retrieve the device information */
+ rc = tf_session_get_device(tfs, &dev);
+ if (rc)
+ return rc;
+
+ switch (dev->type) {
+ case TF_DEVICE_TYPE_P4:
+ device_type = CFA_TCAM_MGR_DEVICE_TYPE_P4;
+ break;
+ case TF_DEVICE_TYPE_SR:
+ device_type = CFA_TCAM_MGR_DEVICE_TYPE_SR;
+ break;
+ case TF_DEVICE_TYPE_P5:
+ device_type = CFA_TCAM_MGR_DEVICE_TYPE_P5;
+ break;
+ default:
+ CFA_TCAM_MGR_LOG(ERR, "No such device %d\n", dev->type);
+ return -CFA_TCAM_MGR_ERR_CODE(NODEV);
+ }
+
+ rc = cfa_tcam_mgr_get_session_from_context(context, &session_id);
+ if (rc < 0)
+ return rc;
+
+ sess_idx = cfa_tcam_mgr_session_add(session_id);
+ if (sess_idx < 0)
+ return sess_idx;
+
+ if (global_data_initialized[sess_idx] == 0) {
+ rc = cfa_tcam_mgr_init(sess_idx, device_type, NULL);
+ if (rc < 0)
+ return rc;
+ }
+
+ if (parms->num_elements != ARRAY_SIZE(cfa_tcam_mgr_tables[sess_idx][dir])) {
+ CFA_TCAM_MGR_LOG(ERR,
+ "Session element count (%d) differs "
+ "from table count (%zu) for sess_idx %d.\n",
+ parms->num_elements,
+ ARRAY_SIZE(cfa_tcam_mgr_tables[sess_idx][dir]),
+ sess_idx);
+ return -CFA_TCAM_MGR_ERR_CODE(INVAL);
+ }
+
+ /*
+ * Only managing one session. resv_res contains the resources allocated
+ * to this session by the resource manager. Update the limits on TCAMs.
+ */
+ for (dir = 0; dir < ARRAY_SIZE(cfa_tcam_mgr_tables[sess_idx]); dir++) {
+ for (type = 0;
+ type < ARRAY_SIZE(cfa_tcam_mgr_tables[sess_idx][dir]);
+ type++) {
+ table_data = &cfa_tcam_mgr_tables[sess_idx][dir][type];
+ prev_max_entries = table_data->max_entries;
+ /*
+ * In AFM logical tables, max_entries is initialized to
+ * zero. These logical tables are not used when TCAM
+ * Manager is in the core so skip.
+ */
+ if (prev_max_entries == 0)
+ continue;
+ start = parms->resv_res[dir][type].start;
+ stride = parms->resv_res[dir][type].stride;
+ if (start % table_data->max_slices > 0) {
+ CFA_TCAM_MGR_LOG_DIR_TYPE(ERR, dir, type,
+ "Start of resources (%d) for table(%d) "
+ "does not begin on row boundary.\n",
+ start, sess_idx);
+ CFA_TCAM_MGR_LOG_DIR(ERR, dir,
+ "Start is %d, number of slices "
+ "is %d.\n",
+ start,
+ table_data->max_slices);
+ (void)cfa_tcam_mgr_session_free(session_id, context);
+ return -CFA_TCAM_MGR_ERR_CODE(INVAL);
+ }
+ if (stride % table_data->max_slices > 0) {
+ CFA_TCAM_MGR_LOG_DIR_TYPE(ERR, dir, type,
+ "Stride of resources (%d) for table(%d) "
+ "does not end on row boundary.\n",
+ stride, sess_idx);
+ CFA_TCAM_MGR_LOG_DIR(ERR, dir,
+ "Stride is %d, number of "
+ "slices is %d.\n",
+ stride,
+ table_data->max_slices);
+ (void)cfa_tcam_mgr_session_free(session_id, context);
+ return -CFA_TCAM_MGR_ERR_CODE(INVAL);
+ }
+ if (stride == 0) {
+ table_data->start_row = 0;
+ table_data->end_row = 0;
+ table_data->max_entries = 0;
+ } else {
+ table_data->start_row = start /
+ table_data->max_slices;
+ table_data->end_row = table_data->start_row +
+ (stride / table_data->max_slices) - 1;
+ table_data->max_entries =
+ table_data->max_slices *
+ (table_data->end_row -
+ table_data->start_row + 1);
+ }
+ cfa_tcam_mgr_max_entries[sess_idx] += (table_data->max_entries -
+ prev_max_entries);
+ }
+ }
+
+ if (tf_session_is_shared_hotup_session(tfs)) {
+ rc = cfa_tcam_mgr_shared_wc_bind(sess_idx, false, parms->tcam_cnt);
+ if (rc) {
+ (void)cfa_tcam_mgr_session_free(session_id, context);
+ return rc;
+ }
+ }
+
+ rc = cfa_tcam_mgr_session_cfg(session_id, parms->tcam_cnt);
+ if (rc < 0) {
+ (void)cfa_tcam_mgr_session_free(session_id, context);
+ return rc;
+ }
+
+ return 0;
+}
+
+int
+cfa_tcam_mgr_unbind(struct cfa_tcam_mgr_context *context)
+{
+ int rc, sess_idx;
+ uint32_t session_id;
+
+ CFA_TCAM_MGR_CHECK_PARMS1(context);
+
+ rc = cfa_tcam_mgr_get_session_from_context(context, &session_id);
+ if (rc < 0)
+ return rc;
+
+ sess_idx = cfa_tcam_mgr_session_find(session_id);
+ if (sess_idx < 0) {
+ CFA_TCAM_MGR_LOG_0(ERR, "Session not found.\n");
+ return sess_idx;
+ }
+
+ if (global_data_initialized[sess_idx] == 0) {
+ CFA_TCAM_MGR_LOG(INFO, "PANIC: No TCAM data created for sess_idx %d\n",
+ sess_idx);
+ return -CFA_TCAM_MGR_ERR_CODE(PERM);
+ }
+
+ (void)cfa_tcam_mgr_session_free(session_id, context);
+
+ global_data_initialized[sess_idx] = 0;
+ return 0;
+}
+
+int
+cfa_tcam_mgr_alloc(struct cfa_tcam_mgr_context *context,
+ struct cfa_tcam_mgr_alloc_parms *parms)
+{
+ struct cfa_tcam_mgr_entry_data entry;
+ struct cfa_tcam_mgr_table_rows_0 *row;
+ struct cfa_tcam_mgr_table_data *table_data;
+ int dir, tbl_type;
+ int key_slices, rc, sess_idx;
+ int new_entry_id;
+ uint32_t session_id;
+
+ CFA_TCAM_MGR_CHECK_PARMS2(context, parms);
+
+ dir = parms->dir;
+ tbl_type = parms->type;
+
+ if (dir >= TF_DIR_MAX) {
+ CFA_TCAM_MGR_LOG(ERR, "Invalid direction: %d.\n", dir);
+ return -CFA_TCAM_MGR_ERR_CODE(INVAL);
+ }
+
+ if (tbl_type >= CFA_TCAM_MGR_TBL_TYPE_MAX) {
+ CFA_TCAM_MGR_LOG_DIR(ERR, dir,
+ "Invalid table type: %d.\n",
+ tbl_type);
+ return -CFA_TCAM_MGR_ERR_CODE(INVAL);
+ }
+
+#if TF_TCAM_PRIORITY_MAX < UINT16_MAX
+ if (parms->priority > TF_TCAM_PRIORITY_MAX) {
+ CFA_TCAM_MGR_LOG_DIR(ERR, dir,
+ "Priority (%u) out of range (%u -%u).\n",
+ parms->priority,
+ TF_TCAM_PRIORITY_MIN,
+ TF_TCAM_PRIORITY_MAX);
+ }
+#endif
+
+ /* Check for session limits */
+ rc = cfa_tcam_mgr_get_session_from_context(context, &session_id);
+ if (rc < 0)
+ return rc;
+
+ sess_idx = cfa_tcam_mgr_session_find(session_id);
+ if (sess_idx < 0) {
+ CFA_TCAM_MGR_LOG(ERR, "Session 0x%08x not found.\n",
+ session_id);
+ return -CFA_TCAM_MGR_ERR_CODE(NODEV);
+ }
+
+ if (global_data_initialized[sess_idx] == 0) {
+ CFA_TCAM_MGR_LOG(ERR, "PANIC: No TCAM data created for sess_idx %d\n",
+ sess_idx);
+ return -CFA_TCAM_MGR_ERR_CODE(PERM);
+ }
+
+ table_data = &cfa_tcam_mgr_tables[sess_idx][dir][tbl_type];
+
+ if (parms->key_size == 0 ||
+ parms->key_size > table_data->row_width) {
+ CFA_TCAM_MGR_LOG_DIR(ERR, dir,
+ "Invalid key size:%d (range 1-%d) sess_idx %d.\n",
+ parms->key_size,
+ table_data->row_width,
+ sess_idx);
+ return -CFA_TCAM_MGR_ERR_CODE(INVAL);
+ }
+
+ /* Check global limits */
+ if (table_data->used_entries >=
+ table_data->max_entries) {
+ CFA_TCAM_MGR_LOG_DIR_TYPE(ERR, dir, tbl_type,
+ "Table full sess_idx %d.\n",
+ sess_idx);
+ return -CFA_TCAM_MGR_ERR_CODE(NOSPC);
+ }
+
+ /* There is room, now increment counts and allocate an entry. */
+ new_entry_id = cfa_tcam_mgr_session_entry_alloc(session_id,
+ parms->dir,
+ parms->type);
+ if (new_entry_id < 0)
+ return new_entry_id;
+
+ memset(&entry, 0, sizeof(entry));
+ entry.ref_cnt++;
+
+ key_slices = cfa_tcam_mgr_get_num_slices(parms->key_size,
+ (table_data->row_width /
+ table_data->max_slices));
+
+ row = cfa_tcam_mgr_empty_row_alloc(sess_idx, context, parms, &entry,
+ new_entry_id, key_slices);
+ if (row == NULL) {
+ CFA_TCAM_MGR_LOG_DIR_TYPE(ERR, parms->dir, parms->type,
+ "Table full (HW) sess_idx %d.\n",
+ sess_idx);
+ (void)cfa_tcam_mgr_session_entry_free(session_id, new_entry_id,
+ parms->dir, parms->type);
+ return -CFA_TCAM_MGR_ERR_CODE(NOSPC);
+ }
+
+ memcpy(&entry_data[sess_idx][new_entry_id],
+ &entry,
+ sizeof(entry_data[sess_idx][new_entry_id]));
+ table_data->used_entries += 1;
+
+ cfa_tcam_mgr_entry_insert(sess_idx, new_entry_id, &entry);
+
+ parms->id = new_entry_id;
+
+ return 0;
+}
+
+int
+cfa_tcam_mgr_free(struct cfa_tcam_mgr_context *context,
+ struct cfa_tcam_mgr_free_parms *parms)
+{
+ struct cfa_tcam_mgr_entry_data *entry;
+ struct cfa_tcam_mgr_table_rows_0 *row;
+ struct cfa_tcam_mgr_table_data *table_data;
+ int row_size, rc, sess_idx, new_row_to_free;
+ uint32_t session_id;
+ uint16_t id;
+
+ CFA_TCAM_MGR_CHECK_PARMS2(context, parms);
+
+ rc = cfa_tcam_mgr_get_session_from_context(context, &session_id);
+ if (rc < 0)
+ return rc;
+
+ sess_idx = cfa_tcam_mgr_session_find(session_id);
+ if (sess_idx < 0) {
+ CFA_TCAM_MGR_LOG(ERR, "Session 0x%08x not found.\n",
+ session_id);
+ return sess_idx;
+ }
+
+ if (global_data_initialized[sess_idx] == 0) {
+ CFA_TCAM_MGR_LOG(INFO, "PANIC: No TCAM data created for sess_idx %d\n",
+ sess_idx);
+ return -CFA_TCAM_MGR_ERR_CODE(PERM);
+ }
+
+ id = parms->id;
+ entry = cfa_tcam_mgr_entry_get(sess_idx, id);
+ if (entry == NULL) {
+ CFA_TCAM_MGR_LOG(INFO, "Entry %d not found for sess_idx %d.\n",
+ id, sess_idx);
+ return -CFA_TCAM_MGR_ERR_CODE(INVAL);
+ }
+
+ if (entry->ref_cnt == 0) {
+ CFA_TCAM_MGR_LOG(ERR, "Entry %d not in use for sess_idx %d.\n",
+ id, sess_idx);
+ return -CFA_TCAM_MGR_ERR_CODE(INVAL);
+ }
+
+ /*
+ * If the TCAM type is CFA_TCAM_MGR_TBL_TYPE_MAX, that implies that the
+ * caller does not know the table or direction of the entry and TCAM
+ * Manager must search the tables to find out which table has the entry
+ * installed.
+ *
+ * This would be the case if RM has informed TCAM Mgr that an entry must
+ * be freed. Clients (sessions, AFM) should always know the type and
+ * direction of the table where an entry is installed.
+ */
+ if (parms->type == CFA_TCAM_MGR_TBL_TYPE_MAX) {
+ /* Need to search for the entry in the tables */
+ rc = cfa_tcam_mgr_entry_find(sess_idx, id, &parms->dir, &parms->type);
+ if (rc < 0) {
+ CFA_TCAM_MGR_LOG(ERR, "Entry %d not in tables for sess_idx %d.\n",
+ id, sess_idx);
+ return rc;
+ }
+ }
+
+ table_data = &cfa_tcam_mgr_tables[sess_idx][parms->dir][parms->type];
+ parms->hcapi_type = table_data->hcapi_type;
+
+ row_size = cfa_tcam_mgr_row_size_get(sess_idx, parms->dir, parms->type);
+
+ row = cfa_tcam_mgr_row_ptr_get(table_data->tcam_rows, entry->row,
+ row_size);
+
+ entry->ref_cnt--;
+
+ (void)cfa_tcam_mgr_session_entry_free(session_id, id,
+ parms->dir, parms->type);
+
+ if (entry->ref_cnt == 0) {
+ cfa_tcam_mgr_entry_free_msg(sess_idx, context, parms,
+ entry->row,
+ entry->slice * row->entry_size,
+ table_data->row_width /
+ table_data->max_slices *
+ row->entry_size,
+ table_data->result_size,
+ table_data->max_slices);
+ ROW_ENTRY_CLEAR(row, entry->slice);
+
+ new_row_to_free = entry->row;
+ cfa_tcam_mgr_rows_combine(sess_idx, context, parms, table_data,
+ new_row_to_free);
+
+ if (!ROW_INUSE(row)) {
+ cfa_tcam_mgr_rows_compact(sess_idx, context,
+ parms, table_data,
+ &new_row_to_free,
+ new_row_to_free);
+ if (new_row_to_free >= 0)
+ cfa_tcam_mgr_entry_free_msg(sess_idx, context, parms,
+ new_row_to_free, 0,
+ table_data->row_width,
+ table_data->result_size,
+ table_data->max_slices);
+ }
+
+ cfa_tcam_mgr_entry_delete(sess_idx, id);
+ table_data->used_entries -= 1;
+ }
+
+ return 0;
+}
+
+int
+cfa_tcam_mgr_set(struct cfa_tcam_mgr_context *context,
+ struct cfa_tcam_mgr_set_parms *parms)
+{
+ struct cfa_tcam_mgr_entry_data *entry;
+ struct cfa_tcam_mgr_table_rows_0 *row;
+ struct cfa_tcam_mgr_table_data *table_data;
+ int rc;
+ int row_size, sess_idx;
+ int entry_size_in_bytes;
+ uint32_t session_id;
+
+ CFA_TCAM_MGR_CHECK_PARMS2(context, parms);
+
+ rc = cfa_tcam_mgr_get_session_from_context(context, &session_id);
+ if (rc < 0)
+ return rc;
+
+ sess_idx = cfa_tcam_mgr_session_find(session_id);
+ if (sess_idx < 0) {
+ CFA_TCAM_MGR_LOG(ERR, "Session 0x%08x not found.\n",
+ session_id);
+ return sess_idx;
+ }
+
+ if (global_data_initialized[sess_idx] == 0) {
+ CFA_TCAM_MGR_LOG(ERR, "PANIC: No TCAM data created for sess_idx %d\n",
+ sess_idx);
+ return -CFA_TCAM_MGR_ERR_CODE(PERM);
+ }
+
+ entry = cfa_tcam_mgr_entry_get(sess_idx, parms->id);
+ if (entry == NULL) {
+ CFA_TCAM_MGR_LOG(ERR, "Entry %d not found for sess_idx %d.\n",
+ parms->id, sess_idx);
+ return -CFA_TCAM_MGR_ERR_CODE(INVAL);
+ }
+
+ table_data = &cfa_tcam_mgr_tables[sess_idx][parms->dir][parms->type];
+ parms->hcapi_type = table_data->hcapi_type;
+
+ row_size = cfa_tcam_mgr_row_size_get(sess_idx, parms->dir, parms->type);
+ row = cfa_tcam_mgr_row_ptr_get(table_data->tcam_rows, entry->row,
+ row_size);
+
+ entry_size_in_bytes = table_data->row_width /
+ table_data->max_slices *
+ row->entry_size;
+ if (parms->key_size != entry_size_in_bytes) {
+ CFA_TCAM_MGR_LOG(ERR,
+ "Key size(%d) is different from entry "
+ "size(%d).\n",
+ parms->key_size,
+ entry_size_in_bytes);
+ return -CFA_TCAM_MGR_ERR_CODE(INVAL);
+ }
+
+ rc = cfa_tcam_mgr_entry_set_msg(sess_idx, context, parms,
+ entry->row,
+ entry->slice * row->entry_size,
+ table_data->max_slices);
+ if (rc < 0) {
+ CFA_TCAM_MGR_LOG_0(ERR, "Failed to set TCAM data.\n");
+ return rc;
+ }
+
+ return 0;
+}
+
+int
+cfa_tcam_mgr_get(struct cfa_tcam_mgr_context *context __rte_unused,
+ struct cfa_tcam_mgr_get_parms *parms)
+{
+ struct cfa_tcam_mgr_entry_data *entry;
+ struct cfa_tcam_mgr_table_rows_0 *row;
+ struct cfa_tcam_mgr_table_data *table_data;
+ int rc;
+ int row_size, sess_idx;
+ uint32_t session_id;
+
+ CFA_TCAM_MGR_CHECK_PARMS2(context, parms);
+
+ rc = cfa_tcam_mgr_get_session_from_context(context, &session_id);
+ if (rc < 0)
+ return rc;
+
+ sess_idx = cfa_tcam_mgr_session_find(session_id);
+ if (sess_idx < 0) {
+ CFA_TCAM_MGR_LOG(ERR, "Session 0x%08x not found.\n",
+ session_id);
+ return sess_idx;
+ }
+
+ if (global_data_initialized[sess_idx] == 0) {
+ CFA_TCAM_MGR_LOG(ERR, "PANIC: No TCAM data created for sess_idx %d\n",
+ sess_idx);
+ return -CFA_TCAM_MGR_ERR_CODE(PERM);
+ }
+
+ entry = cfa_tcam_mgr_entry_get(sess_idx, parms->id);
+ if (entry == NULL) {
+ CFA_TCAM_MGR_LOG(ERR, "Entry %d not found.\n", parms->id);
+ return -CFA_TCAM_MGR_ERR_CODE(INVAL);
+ }
+
+ table_data = &cfa_tcam_mgr_tables[sess_idx][parms->dir][parms->type];
+ parms->hcapi_type = table_data->hcapi_type;
+
+ row_size = cfa_tcam_mgr_row_size_get(sess_idx, parms->dir, parms->type);
+ row = cfa_tcam_mgr_row_ptr_get(table_data->tcam_rows, entry->row,
+ row_size);
+
+ rc = cfa_tcam_mgr_entry_get_msg(sess_idx, context, parms,
+ entry->row,
+ entry->slice * row->entry_size,
+ table_data->max_slices);
+ if (rc < 0) {
+ CFA_TCAM_MGR_LOG_0(ERR, "Failed to read from TCAM.\n");
+ return rc;
+ }
+
+ return 0;
+}
+
+int cfa_tcam_mgr_shared_clear(struct cfa_tcam_mgr_context *context,
+ struct cfa_tcam_mgr_shared_clear_parms *parms)
+{
+ int rc;
+ uint16_t row, slice = 0;
+ int sess_idx;
+ uint32_t session_id;
+ struct cfa_tcam_mgr_free_parms fparms;
+ struct cfa_tcam_mgr_table_data *table_data;
+ uint16_t start_row, end_row, max_entries, max_slices;
+
+ CFA_TCAM_MGR_CHECK_PARMS2(context, parms);
+
+ rc = cfa_tcam_mgr_get_session_from_context(context, &session_id);
+ if (rc < 0)
+ return rc;
+
+ sess_idx = cfa_tcam_mgr_session_find(session_id);
+ if (sess_idx < 0) {
+ CFA_TCAM_MGR_LOG(ERR, "Session 0x%08x not found.\n",
+ session_id);
+ return sess_idx;
+ }
+
+ if (global_data_initialized[sess_idx] == 0) {
+ CFA_TCAM_MGR_LOG(ERR, "PANIC: No TCAM data created for sess_idx %d\n",
+ sess_idx);
+ return -CFA_TCAM_MGR_ERR_CODE(PERM);
+ }
+
+ table_data = &cfa_tcam_mgr_tables[sess_idx][parms->dir][parms->type];
+ fparms.dir = parms->dir;
+ fparms.type = parms->type;
+ fparms.hcapi_type = table_data->hcapi_type;
+ fparms.id = 0;
+
+ rc = cfa_tcam_mgr_tables_get(sess_idx, parms->dir, parms->type,
+ &start_row, &end_row, &max_entries, &max_slices);
+ if (rc)
+ return rc;
+
+ for (row = start_row; row <= end_row; row++) {
+ cfa_tcam_mgr_entry_free_msg(sess_idx, context, &fparms,
+ row,
+ slice,
+ table_data->row_width,
+ table_data->result_size,
+ table_data->max_slices);
+ }
+ return rc;
+}
+
+static void
+cfa_tcam_mgr_mv_used_entries_cnt(int sess_idx, enum tf_dir dir,
+ struct cfa_tcam_mgr_table_data *dst_table_data,
+ struct cfa_tcam_mgr_table_data *src_table_data)
+{
+ dst_table_data->used_entries++;
+ src_table_data->used_entries--;
+
+ cfa_tcam_mgr_mv_session_used_entries_cnt(sess_idx, dir,
+ CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_LOW_APPS,
+ CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_HIGH_APPS);
+}
+
+/*
+ * Move HI WC TCAM entries to LOW TCAM region for HA
+ * This happens when secondary is becoming primary
+ */
+static int
+cfa_tcam_mgr_shared_entry_move(int sess_idx, struct cfa_tcam_mgr_context *context,
+ enum tf_dir dir, enum cfa_tcam_mgr_tbl_type type,
+ int entry_id,
+ struct cfa_tcam_mgr_table_data *dst_table_data,
+ struct cfa_tcam_mgr_table_data *table_data,
+ int dst_row_index, int dst_row_slice,
+ struct cfa_tcam_mgr_table_rows_0 *dst_row,
+ int src_row_index,
+ struct cfa_tcam_mgr_table_rows_0 *src_row)
+{
+ struct cfa_tcam_mgr_get_parms gparms = { 0 };
+ struct cfa_tcam_mgr_set_parms sparms = { 0 };
+ struct cfa_tcam_mgr_free_parms fparms = { 0 };
+ struct cfa_tcam_mgr_entry_data *entry;
+ uint8_t key[CFA_TCAM_MGR_MAX_KEY_SIZE];
+ uint8_t mask[CFA_TCAM_MGR_MAX_KEY_SIZE];
+ uint8_t result[CFA_TCAM_MGR_MAX_KEY_SIZE];
+
+ int rc;
+
+ entry = cfa_tcam_mgr_entry_get(sess_idx, entry_id);
+ if (entry == NULL)
+ return -1;
+
+ gparms.dir = dir;
+ gparms.type = type;
+ gparms.hcapi_type = table_data->hcapi_type;
+ gparms.key = key;
+ gparms.mask = mask;
+ gparms.result = result;
+ gparms.id = src_row->entries[entry->slice];
+ gparms.key_size = sizeof(key);
+ gparms.result_size = sizeof(result);
+
+ rc = cfa_tcam_mgr_entry_get_msg(sess_idx, context, &gparms,
+ src_row_index,
+ entry->slice * src_row->entry_size,
+ table_data->max_slices);
+ if (rc != 0)
+ return rc;
+
+ sparms.dir = dir;
+ sparms.type = CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_LOW_APPS;
+ sparms.hcapi_type = table_data->hcapi_type;
+ sparms.key = key;
+ sparms.mask = mask;
+ sparms.result = result;
+ sparms.id = gparms.id;
+ sparms.key_size = gparms.key_size;
+ sparms.result_size = gparms.result_size;
+
+ rc = cfa_tcam_mgr_entry_set_msg(sess_idx, context, &sparms,
+ dst_row_index,
+ dst_row_slice * dst_row->entry_size,
+ table_data->max_slices);
+ if (rc != 0)
+ return rc;
+
+ fparms.dir = dir;
+ fparms.type = type;
+ fparms.hcapi_type = table_data->hcapi_type;
+ rc = cfa_tcam_mgr_entry_free_msg(sess_idx, context, &fparms,
+ src_row_index,
+ entry->slice *
+ dst_row->entry_size,
+ table_data->row_width /
+ table_data->max_slices *
+ src_row->entry_size,
+ table_data->result_size,
+ table_data->max_slices);
+ if (rc != 0) {
+ CFA_TCAM_MGR_LOG_DIR_TYPE(ERR,
+ dir, type,
+ "Failed to free entry ID %d at"
+ " row %d, slice %d for sess_idx %d. rc: %d.\n",
+ gparms.id,
+ src_row_index,
+ entry->slice,
+ sess_idx,
+ -rc);
+ }
+
+#ifdef CFA_TCAM_MGR_TRACING
+ CFA_TCAM_MGR_TRACE(INFO, "Moved entry %d from row %d, slice %d to "
+ "row %d, slice %d.\n",
+ entry_id, src_row_index, entry->slice,
+ dst_row_index, dst_row_slice);
+#endif
+
+ ROW_ENTRY_SET(dst_row, dst_row_slice);
+ dst_row->entries[dst_row_slice] = entry_id;
+ dst_row->entry_size = src_row->entry_size;
+ dst_row->priority = src_row->priority;
+ ROW_ENTRY_CLEAR(src_row, entry->slice);
+ entry->row = dst_row_index;
+ entry->slice = dst_row_slice;
+
+ cfa_tcam_mgr_mv_used_entries_cnt(sess_idx, dir, dst_table_data, table_data);
+
+#ifdef CFA_TCAM_MGR_TRACING
+ cfa_tcam_mgr_rows_dump(sess_idx, dir, type);
+ cfa_tcam_mgr_rows_dump(sess_idx, dir, CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_LOW_APPS);
+#endif
+
+ return 0;
+}
+
+int cfa_tcam_mgr_shared_move(struct cfa_tcam_mgr_context *context,
+ struct cfa_tcam_mgr_shared_move_parms *parms)
+{
+ int rc;
+ int sess_idx;
+ uint32_t session_id;
+ uint16_t src_row, dst_row, row_size, slice;
+ struct cfa_tcam_mgr_table_rows_0 *src_table_row;
+ struct cfa_tcam_mgr_table_rows_0 *dst_table_row;
+ struct cfa_tcam_mgr_table_data *src_table_data;
+ struct cfa_tcam_mgr_table_data *dst_table_data;
+
+ CFA_TCAM_MGR_CHECK_PARMS2(context, parms);
+
+ rc = cfa_tcam_mgr_get_session_from_context(context, &session_id);
+ if (rc < 0)
+ return rc;
+
+ sess_idx = cfa_tcam_mgr_session_find(session_id);
+ if (sess_idx < 0) {
+ CFA_TCAM_MGR_LOG(ERR, "Session 0x%08x not found.\n",
+ session_id);
+ return sess_idx;
+ }
+
+ if (global_data_initialized[sess_idx] == 0) {
+ CFA_TCAM_MGR_LOG(ERR, "PANIC: No TCAM data created for sess_idx %d\n",
+ sess_idx);
+ return -CFA_TCAM_MGR_ERR_CODE(PERM);
+ }
+
+ src_table_data =
+ &cfa_tcam_mgr_tables[sess_idx][parms->dir][CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_HIGH_APPS];
+ dst_table_data =
+ &cfa_tcam_mgr_tables[sess_idx][parms->dir][CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_LOW_APPS];
+
+ row_size =
+ cfa_tcam_mgr_row_size_get(sess_idx,
+ parms->dir,
+ CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_HIGH_APPS);
+
+ for (src_row = src_table_data->start_row,
+ dst_row = dst_table_data->start_row;
+ src_row <= src_table_data->end_row;
+ src_row++, dst_row++) {
+ src_table_row = cfa_tcam_mgr_row_ptr_get(src_table_data->tcam_rows,
+ src_row, row_size);
+ dst_table_row = cfa_tcam_mgr_row_ptr_get(dst_table_data->tcam_rows,
+ dst_row, row_size);
+ if (ROW_INUSE(src_table_row)) {
+ for (slice = 0;
+ slice < src_table_data->max_slices / src_table_row->entry_size;
+ slice++) {
+ if (ROW_ENTRY_INUSE(src_table_row, slice)) {
+#ifdef CFA_TCAM_MGR_TRACING
+ CFA_TCAM_MGR_TRACE(INFO, "Move entry id %d "
+ "from src_row %d, slice %d "
+ "to dst_row %d, slice %d.\n",
+ src_table_row->entries[slice],
+ src_row, slice,
+ dst_row, slice);
+#endif
+ rc = cfa_tcam_mgr_shared_entry_move(sess_idx,
+ context,
+ parms->dir,
+ CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_HIGH_APPS,
+ src_table_row->entries[slice],
+ dst_table_data,
+ src_table_data,
+ dst_row, slice,
+ dst_table_row,
+ src_row,
+ src_table_row);
+ }
+ }
+ }
+ }
+
+ return rc;
+}
+
+static void
+cfa_tcam_mgr_tbl_get(int sess_idx, enum tf_dir dir,
+ enum cfa_tcam_mgr_tbl_type type,
+ uint16_t *start_row,
+ uint16_t *end_row,
+ uint16_t *max_entries,
+ uint16_t *slices)
+{
+ struct cfa_tcam_mgr_table_data *table_data =
+ &cfa_tcam_mgr_tables[sess_idx][dir][type];
+
+ /* Get start, end and max for tcam type*/
+ *start_row = table_data->start_row;
+ *end_row = table_data->end_row;
+ *max_entries = table_data->max_entries;
+ *slices = table_data->max_slices;
+}
+
+int
+cfa_tcam_mgr_tables_get(int sess_idx, enum tf_dir dir,
+ enum cfa_tcam_mgr_tbl_type type,
+ uint16_t *start_row,
+ uint16_t *end_row,
+ uint16_t *max_entries,
+ uint16_t *slices)
+{
+ CFA_TCAM_MGR_CHECK_PARMS3(start_row, end_row, max_entries);
+
+ if (global_data_initialized[sess_idx] == 0) {
+ CFA_TCAM_MGR_LOG(ERR, "PANIC: TCAM not initialized for sess_idx %d.\n",
+ sess_idx);
+ return -CFA_TCAM_MGR_ERR_CODE(INVAL);
+ }
+
+ if (dir >= TF_DIR_MAX) {
+ CFA_TCAM_MGR_LOG(ERR, "Must specify valid dir (0-%d) forsess_idx %d.\n",
+ TF_DIR_MAX - 1, sess_idx);
+ return -CFA_TCAM_MGR_ERR_CODE(INVAL);
+ }
+
+ if (type >= CFA_TCAM_MGR_TBL_TYPE_MAX) {
+ CFA_TCAM_MGR_LOG(ERR, "Must specify valid tbl type (0-%d) forsess_idx %d.\n",
+ CFA_TCAM_MGR_TBL_TYPE_MAX - 1, sess_idx);
+ return -CFA_TCAM_MGR_ERR_CODE(INVAL);
+ }
+
+ cfa_tcam_mgr_tbl_get(sess_idx, dir,
+ type,
+ start_row,
+ end_row,
+ max_entries,
+ slices);
+ return 0;
+}
+
+static void
+cfa_tcam_mgr_tbl_set(int sess_idx, enum tf_dir dir,
+ enum cfa_tcam_mgr_tbl_type type,
+ uint16_t start_row,
+ uint16_t end_row,
+ uint16_t max_entries)
+{
+ struct cfa_tcam_mgr_table_data *table_data =
+ &cfa_tcam_mgr_tables[sess_idx][dir][type];
+
+ /* Update start, end and max for tcam type*/
+ table_data->start_row = start_row;
+ table_data->end_row = end_row;
+ table_data->max_entries = max_entries;
+}
+
+int
+cfa_tcam_mgr_tables_set(int sess_idx, enum tf_dir dir,
+ enum cfa_tcam_mgr_tbl_type type,
+ uint16_t start_row,
+ uint16_t end_row,
+ uint16_t max_entries)
+{
+ if (global_data_initialized[sess_idx] == 0) {
+ CFA_TCAM_MGR_LOG(ERR, "PANIC: TCAM not initialized for sess_idx %d.\n",
+ sess_idx);
+ return -CFA_TCAM_MGR_ERR_CODE(INVAL);
+ }
+
+ if (dir >= TF_DIR_MAX) {
+ CFA_TCAM_MGR_LOG(ERR, "Must specify valid dir (0-%d) forsess_idx %d.\n",
+ TF_DIR_MAX - 1, sess_idx);
+ return -CFA_TCAM_MGR_ERR_CODE(INVAL);
+ }
+
+ if (type >= CFA_TCAM_MGR_TBL_TYPE_MAX) {
+ CFA_TCAM_MGR_LOG(ERR, "Must specify valid tbl type (0-%d) forsess_idx %d.\n",
+ CFA_TCAM_MGR_TBL_TYPE_MAX - 1, sess_idx);
+ return -CFA_TCAM_MGR_ERR_CODE(INVAL);
+ }
+
+ cfa_tcam_mgr_tbl_set(sess_idx, dir,
+ type,
+ start_row,
+ end_row,
+ max_entries);
+ return 0;
+}
+
+void
+cfa_tcam_mgr_rows_dump(int sess_idx, enum tf_dir dir,
+ enum cfa_tcam_mgr_tbl_type type)
+{
+ struct cfa_tcam_mgr_table_data *table_data;
+ struct cfa_tcam_mgr_table_rows_0 *table_row;
+ int i, row, row_size;
+ bool row_found = false;
+ bool empty_row = false;
+
+ if (global_data_initialized[sess_idx] == 0) {
+ printf("PANIC: TCAM not initialized for sess_idx %d.\n", sess_idx);
+ return;
+ }
+
+ if (dir >= TF_DIR_MAX) {
+ printf("Must specify a valid direction (0-%d).\n",
+ TF_DIR_MAX - 1);
+ return;
+ }
+ if (type >= CFA_TCAM_MGR_TBL_TYPE_MAX) {
+ printf("Must specify a valid type (0-%d).\n",
+ CFA_TCAM_MGR_TBL_TYPE_MAX - 1);
+ return;
+ }
+
+ table_data = &cfa_tcam_mgr_tables[sess_idx][dir][type];
+ row_size = cfa_tcam_mgr_row_size_get(sess_idx, dir, type);
+
+ printf("\nTCAM Rows:\n");
+ printf("Rows for direction %s, Logical table type %s\n",
+ tf_dir_2_str(dir), cfa_tcam_mgr_tbl_2_str(type));
+ printf("Managed rows %d-%d for sess_idx %d:\n",
+ table_data->start_row, table_data->end_row, sess_idx);
+
+ printf("Index Pri Size Entry IDs\n");
+ printf(" Sl 0");
+ for (i = 1; i < table_data->max_slices; i++)
+ printf(" Sl %d", i);
+ printf("\n");
+ for (row = table_data->start_row; row <= table_data->end_row; row++) {
+ table_row = cfa_tcam_mgr_row_ptr_get(table_data->tcam_rows, row,
+ row_size);
+ if (ROW_INUSE(table_row)) {
+ empty_row = false;
+ printf("%5u %5u %4u",
+ row,
+ TF_TCAM_PRIORITY_MAX - table_row->priority - 1,
+ table_row->entry_size);
+ for (i = 0;
+ i < table_data->max_slices / table_row->entry_size;
+ i++) {
+ if (ROW_ENTRY_INUSE(table_row, i))
+ printf(" %5u", table_row->entries[i]);
+ else
+ printf(" x");
+ }
+ printf("\n");
+ row_found = true;
+ } else if (!empty_row) {
+ empty_row = true;
+ printf("\n");
+ }
+ }
+
+ if (!row_found)
+ printf("No rows in use.\n");
+}
+
+static void
+cfa_tcam_mgr_table_dump(int sess_idx, enum tf_dir dir,
+ enum cfa_tcam_mgr_tbl_type type)
+{
+ struct cfa_tcam_mgr_table_data *table_data =
+ &cfa_tcam_mgr_tables[sess_idx][dir][type];
+
+ printf("%3s %-22s %5u %5u %5u %5u %6u %7u %2u\n",
+ tf_dir_2_str(dir),
+ cfa_tcam_mgr_tbl_2_str(type),
+ table_data->row_width,
+ table_data->num_rows,
+ table_data->start_row,
+ table_data->end_row,
+ table_data->max_entries,
+ table_data->used_entries,
+ table_data->max_slices);
+}
+
+#define TABLE_DUMP_HEADER \
+ "Dir Table Width Rows Start End " \
+ "MaxEnt UsedEnt Slices\n"
+
+void
+cfa_tcam_mgr_tables_dump(int sess_idx, enum tf_dir dir,
+ enum cfa_tcam_mgr_tbl_type type)
+{
+ if (global_data_initialized[sess_idx] == 0) {
+ printf("PANIC: TCAM not initialized for sess_idx %d.\n", sess_idx);
+ return;
+ }
+
+ printf("\nTCAM Table(s) for sess_idx %d:\n", sess_idx);
+ printf(TABLE_DUMP_HEADER);
+ if (dir >= TF_DIR_MAX) {
+ /* Iterate over all directions */
+ for (dir = 0; dir < TF_DIR_MAX; dir++) {
+ if (type >= CFA_TCAM_MGR_TBL_TYPE_MAX) {
+ /* Iterate over all types */
+ for (type = 0;
+ type < CFA_TCAM_MGR_TBL_TYPE_MAX;
+ type++) {
+ cfa_tcam_mgr_table_dump(sess_idx, dir, type);
+ }
+ } else {
+ /* Display a specific type */
+ cfa_tcam_mgr_table_dump(sess_idx, dir, type);
+ }
+ }
+ } else if (type >= CFA_TCAM_MGR_TBL_TYPE_MAX) {
+ /* Iterate over all types for a direction */
+ for (type = 0; type < CFA_TCAM_MGR_TBL_TYPE_MAX; type++)
+ cfa_tcam_mgr_table_dump(sess_idx, dir, type);
+ } else {
+ /* Display a specific direction and type */
+ cfa_tcam_mgr_table_dump(sess_idx, dir, type);
+ }
+}
+
+#define ENTRY_DUMP_HEADER "Entry RefCnt Row Slice\n"
+
+void
+cfa_tcam_mgr_entries_dump(int sess_idx)
+{
+ struct cfa_tcam_mgr_entry_data *entry;
+ bool entry_found = false;
+ uint16_t id;
+
+ if (global_data_initialized[sess_idx] == 0) {
+ CFA_TCAM_MGR_LOG(INFO, "PANIC: No TCAM data created for sess_idx %d\n",
+ sess_idx);
+ return;
+ }
+
+ printf("\nGlobal Maximum Entries: %d\n\n",
+ cfa_tcam_mgr_max_entries[sess_idx]);
+ printf("TCAM Entry Table:\n");
+ for (id = 0; id < cfa_tcam_mgr_max_entries[sess_idx]; id++) {
+ if (entry_data[sess_idx][id].ref_cnt > 0) {
+ entry = &entry_data[sess_idx][id];
+ if (!entry_found)
+ printf(ENTRY_DUMP_HEADER);
+ printf("%5u %5u %5u %5u",
+ id, entry->ref_cnt,
+ entry->row, entry->slice);
+ printf("\n");
+ entry_found = true;
+ }
+ }
+
+ if (!entry_found)
+ printf("No entries found.\n");
+}
new file mode 100644
@@ -0,0 +1,523 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2021-2023 Broadcom
+ * All rights reserved.
+ */
+
+#ifndef _CFA_TCAM_MGR_H_
+#define _CFA_TCAM_MGR_H_
+
+#include <errno.h>
+#include "rte_common.h"
+#include "hsi_struct_def_dpdk.h"
+#include "tf_core.h"
+
+#ifndef __rte_unused
+#define __rte_unused __attribute__((unused))
+#endif
+
+/**
+ * The TCAM module provides processing of Internal TCAM types.
+ */
+
+#ifndef TF_TCAM_MAX_SESSIONS
+#define TF_TCAM_MAX_SESSIONS 16
+#endif
+
+#define ENTRY_ID_INVALID UINT16_MAX
+
+#define TF_TCAM_PRIORITY_MIN 0
+#define TF_TCAM_PRIORITY_MAX UINT16_MAX
+
+#ifndef ARRAY_SIZE
+#define ARRAY_SIZE(_array) (sizeof(_array) / sizeof(_array[0]))
+#endif
+
+/* Use TFP_DRV_LOG definition in tfp.h */
+#define CFA_TCAM_MGR_LOG(level, fmt, args...) \
+ TFP_DRV_LOG(level, fmt, ## args)
+#define CFA_TCAM_MGR_LOG_DIR(level, dir, fmt, args...) \
+ TFP_DRV_LOG(level, "%s: " fmt, tf_dir_2_str(dir), ## args)
+#define CFA_TCAM_MGR_LOG_DIR_TYPE(level, dir, type, fmt, args...) \
+ TFP_DRV_LOG(level, "%s: %s " fmt, tf_dir_2_str(dir), \
+ cfa_tcam_mgr_tbl_2_str(type), ## args)
+
+#define CFA_TCAM_MGR_LOG_0(level, fmt) \
+ TFP_DRV_LOG(level, fmt)
+#define CFA_TCAM_MGR_LOG_DIR_0(level, dir, fmt) \
+ TFP_DRV_LOG(level, "%s: " fmt, tf_dir_2_str(dir))
+#define CFA_TCAM_MGR_LOG_DIR_TYPE_0(level, dir, type, fmt) \
+ TFP_DRV_LOG(level, "%s: %s " fmt, tf_dir_2_str(dir), \
+ cfa_tcam_mgr_tbl_2_str(type))
+
+#define CFA_TCAM_MGR_ERR_CODE(type) E ## type
+
+/**
+ * Checks 1 parameter against NULL.
+ */
+#define CFA_TCAM_MGR_CHECK_PARMS1(parms) do { \
+ if ((parms) == NULL) { \
+ CFA_TCAM_MGR_LOG_0(ERR, "Invalid Argument(s)\n"); \
+ return -CFA_TCAM_MGR_ERR_CODE(INVAL); \
+ } \
+ } while (0)
+
+/**
+ * Checks 2 parameters against NULL.
+ */
+#define CFA_TCAM_MGR_CHECK_PARMS2(parms1, parms2) do { \
+ if ((parms1) == NULL || (parms2) == NULL) { \
+ CFA_TCAM_MGR_LOG_0(ERR, "Invalid Argument(s)\n"); \
+ return -CFA_TCAM_MGR_ERR_CODE(INVAL); \
+ } \
+ } while (0)
+
+/**
+ * Checks 3 parameters against NULL.
+ */
+#define CFA_TCAM_MGR_CHECK_PARMS3(parms1, parms2, parms3) do { \
+ if ((parms1) == NULL || \
+ (parms2) == NULL || \
+ (parms3) == NULL) { \
+ CFA_TCAM_MGR_LOG_0(ERR, "Invalid Argument(s)\n"); \
+ return -CFA_TCAM_MGR_ERR_CODE(INVAL); \
+ } \
+ } while (0)
+
+enum cfa_tcam_mgr_tbl_type {
+ /* Logical TCAM tables */
+ CFA_TCAM_MGR_TBL_TYPE_START,
+ CFA_TCAM_MGR_TBL_TYPE_L2_CTXT_TCAM_HIGH_AFM =
+ CFA_TCAM_MGR_TBL_TYPE_START,
+ CFA_TCAM_MGR_TBL_TYPE_L2_CTXT_TCAM_HIGH_APPS,
+ CFA_TCAM_MGR_TBL_TYPE_L2_CTXT_TCAM_LOW_AFM,
+ CFA_TCAM_MGR_TBL_TYPE_L2_CTXT_TCAM_LOW_APPS,
+ CFA_TCAM_MGR_TBL_TYPE_PROF_TCAM_AFM,
+ CFA_TCAM_MGR_TBL_TYPE_PROF_TCAM_APPS,
+ CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_AFM,
+ CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_APPS,
+ CFA_TCAM_MGR_TBL_TYPE_SP_TCAM_AFM,
+ CFA_TCAM_MGR_TBL_TYPE_SP_TCAM_APPS,
+ CFA_TCAM_MGR_TBL_TYPE_CT_RULE_TCAM_AFM,
+ CFA_TCAM_MGR_TBL_TYPE_CT_RULE_TCAM_APPS,
+ CFA_TCAM_MGR_TBL_TYPE_VEB_TCAM_AFM,
+ CFA_TCAM_MGR_TBL_TYPE_VEB_TCAM_APPS,
+ CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_HIGH_AFM,
+ CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_HIGH_APPS,
+ CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_LOW_AFM,
+ CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_LOW_APPS,
+ CFA_TCAM_MGR_TBL_TYPE_MAX
+};
+
+enum cfa_tcam_mgr_device_type {
+ CFA_TCAM_MGR_DEVICE_TYPE_P4 = 0,
+ CFA_TCAM_MGR_DEVICE_TYPE_SR,
+ CFA_TCAM_MGR_DEVICE_TYPE_P5,
+ CFA_TCAM_MGR_DEVICE_TYPE_MAX
+};
+
+struct cfa_tcam_mgr_context {
+ struct tf *tfp;
+};
+
+/**
+ * TCAM Manager initialization parameters
+ */
+struct cfa_tcam_mgr_init_parms {
+ /**
+ * [in] TCAM resources reserved
+ * type element is not used.
+ */
+ struct tf_rm_resc_entry resc[TF_DIR_MAX][CFA_TCAM_MGR_TBL_TYPE_MAX];
+ /**
+ * [out] maximum number of entries available.
+ */
+ uint32_t max_entries;
+};
+
+/**
+ * TCAM Manager initialization parameters
+ */
+struct cfa_tcam_mgr_qcaps_parms {
+ /**
+ * [out] Bitmasks. Set if TCAM Manager is managing a logical TCAM.
+ * Each bitmask is indexed by logical TCAM table ID.
+ */
+ uint32_t rx_tcam_supported;
+ uint32_t tx_tcam_supported;
+};
+
+/**
+ * TCAM Manager configuration parameters
+ */
+struct cfa_tcam_mgr_cfg_parms {
+ /**
+ * [in] Number of tcam types in each of the configuration arrays
+ */
+ uint16_t num_elements;
+ /**
+ * [in] Session resource allocations
+ */
+ uint16_t tcam_cnt[TF_DIR_MAX][CFA_TCAM_MGR_TBL_TYPE_MAX];
+
+ /**
+ * [in] TCAM Locations reserved
+ */
+ struct tf_rm_resc_entry (*resv_res)[CFA_TCAM_MGR_TBL_TYPE_MAX];
+};
+
+/**
+ * TCAM Manager allocation parameters
+ */
+struct cfa_tcam_mgr_alloc_parms {
+ /**
+ * [in] Receive or transmit direction
+ */
+ enum tf_dir dir;
+ /**
+ * [in] Type of the allocation
+ */
+ enum cfa_tcam_mgr_tbl_type type;
+ /**
+ * [in] Type of HCAPI
+ */
+ uint16_t hcapi_type;
+ /**
+ * [in] key size (bytes)
+ */
+ uint16_t key_size;
+ /**
+ * [in] Priority of entry requested (definition TBD)
+ */
+ uint16_t priority;
+ /**
+ * [out] Id of allocated entry or found entry (if search_enable)
+ */
+ uint16_t id;
+};
+
+/**
+ * TCAM Manager free parameters
+ */
+struct cfa_tcam_mgr_free_parms {
+ /**
+ * [in] Receive or transmit direction
+ */
+ enum tf_dir dir;
+ /**
+ * [in] Type of the allocation
+ * If the type is not known, set the type to CFA_TCAM_MGR_TBL_TYPE_MAX.
+ */
+ enum cfa_tcam_mgr_tbl_type type;
+ /**
+ * [in] Type of HCAPI
+ */
+ uint16_t hcapi_type;
+ /**
+ * [in] Entry ID to free
+ */
+ uint16_t id;
+};
+
+/**
+ * TCAM Manager set parameters
+ */
+struct cfa_tcam_mgr_set_parms {
+ /**
+ * [in] Receive or transmit direction
+ */
+ enum tf_dir dir;
+ /**
+ * [in] Type of object to set
+ */
+ enum cfa_tcam_mgr_tbl_type type;
+ /**
+ * [in] Type of HCAPI
+ */
+ uint16_t hcapi_type;
+ /**
+ * [in] Entry ID to write to
+ */
+ uint16_t id;
+ /**
+ * [in] array containing key
+ */
+ uint8_t *key;
+ /**
+ * [in] array containing mask fields
+ */
+ uint8_t *mask;
+ /**
+ * [in] key size (bytes)
+ */
+ uint16_t key_size;
+ /**
+ * [in] array containing result
+ */
+ uint8_t *result;
+ /**
+ * [in] result size (bytes)
+ */
+ uint16_t result_size;
+};
+
+/**
+ * TCAM Manager get parameters
+ */
+struct cfa_tcam_mgr_get_parms {
+ /**
+ * [in] Receive or transmit direction
+ */
+ enum tf_dir dir;
+ /**
+ * [in] Type of object to get
+ */
+ enum cfa_tcam_mgr_tbl_type type;
+ /**
+ * [in] Type of HCAPI
+ */
+ uint16_t hcapi_type;
+ /**
+ * [in] Entry ID to read
+ */
+ uint16_t id;
+ /**
+ * [out] array containing key
+ */
+ uint8_t *key;
+ /**
+ * [out] array containing mask fields
+ */
+ uint8_t *mask;
+ /**
+ * [out] key size (bytes)
+ */
+ uint16_t key_size;
+ /**
+ * [out] array containing result
+ */
+ uint8_t *result;
+ /**
+ * [out] result size (bytes)
+ */
+ uint16_t result_size;
+};
+
+/**
+ * cfa_tcam_mgr_shared_clear_parms parameter definition
+ */
+struct cfa_tcam_mgr_shared_clear_parms {
+ /**
+ * [in] receive or transmit direction
+ */
+ enum tf_dir dir;
+ /**
+ * [in] TCAM table type
+ */
+ enum cfa_tcam_mgr_tbl_type type;
+};
+
+/**
+ * cfa_tcam_mgr_shared_move_parms parameter definition
+ */
+struct cfa_tcam_mgr_shared_move_parms {
+ /**
+ * [in] receive or transmit direction
+ */
+ enum tf_dir dir;
+ /**
+ * [in] TCAM table type
+ */
+ enum cfa_tcam_mgr_tbl_type type;
+};
+
+/**
+ * @page tcam TCAM Manager
+ *
+ * @ref cfa_tcam_mgr_init
+ *
+ * @ref cfa_tcam_mgr_get_phys_table_type
+ *
+ * @ref cfa_tcam_mgr_bind
+ *
+ * @ref cfa_tcam_mgr_unbind
+ *
+ * @ref cfa_tcam_mgr_alloc
+ *
+ * @ref cfa_tcam_mgr_free
+ *
+ * @ref cfa_tcam_mgr_set
+ *
+ * @ref cfa_tcam_mgr_get
+ *
+ */
+
+const char *
+cfa_tcam_mgr_tbl_2_str(enum cfa_tcam_mgr_tbl_type tcam_type);
+
+/**
+ * Initializes the TCAM Manager
+ *
+ * [in] type
+ * Device type
+ *
+ * Returns
+ * - (0) if successful.
+ * - (<0) on failure.
+ */
+int
+cfa_tcam_mgr_init(int sess_idx, enum cfa_tcam_mgr_device_type type,
+ struct cfa_tcam_mgr_init_parms *parms);
+
+/**
+ * Returns the physical TCAM table that a logical TCAM table uses.
+ *
+ * [in] type
+ * Logical table type
+ *
+ * Returns
+ * - (tf_tcam_tbl_type) if successful.
+ * - (<0) on failure.
+ */
+int
+cfa_tcam_mgr_get_phys_table_type(enum cfa_tcam_mgr_tbl_type type);
+
+/**
+ * Queries the capabilities of TCAM Manager.
+ *
+ * [in] context
+ * Pointer to context information
+ *
+ * [out] parms
+ * Pointer to parameters to be returned
+ *
+ * Returns
+ * - (0) if successful.
+ * - (<0) on failure.
+ */
+int
+cfa_tcam_mgr_qcaps(struct cfa_tcam_mgr_context *context __rte_unused,
+ struct cfa_tcam_mgr_qcaps_parms *parms);
+
+/**
+ * Initializes the TCAM module with the requested DBs. Must be
+ * invoked as the first thing before any of the access functions.
+ *
+ * [in] context
+ * Pointer to context information
+ *
+ * [in] parms
+ * Pointer to parameters
+ *
+ * Returns
+ * - (0) if successful.
+ * - (-EINVAL) on failure.
+ */
+int cfa_tcam_mgr_bind(struct cfa_tcam_mgr_context *context,
+ struct cfa_tcam_mgr_cfg_parms *parms);
+
+/**
+ * Cleans up the private DBs and releases all the data.
+ *
+ * [in] context
+ * Pointer to context information
+ *
+ * [in] parms
+ * Pointer to parameters
+ *
+ * Returns
+ * - (0) if successful.
+ * - (-EINVAL) on failure.
+ */
+int cfa_tcam_mgr_unbind(struct cfa_tcam_mgr_context *context);
+
+/**
+ * Allocates the requested tcam type from the internal RM DB.
+ *
+ * [in] context
+ * Pointer to context information
+ *
+ * [in] parms
+ * Pointer to parameters
+ *
+ * Returns
+ * - (0) if successful.
+ * - (-EINVAL) on failure.
+ */
+int cfa_tcam_mgr_alloc(struct cfa_tcam_mgr_context *context,
+ struct cfa_tcam_mgr_alloc_parms *parms);
+
+/**
+ * Free's the requested table type and returns it to the DB.
+ * If refcount goes to 0 then it is returned to the table type DB.
+ *
+ * [in] context
+ * Pointer to context information
+ *
+ * [in] parms
+ * Pointer to parameters
+ *
+ * Returns
+ * - (0) if successful.
+ * - (-EINVAL) on failure.
+ */
+int cfa_tcam_mgr_free(struct cfa_tcam_mgr_context *context,
+ struct cfa_tcam_mgr_free_parms *parms);
+
+/**
+ * Configures the requested element by sending a firmware request which
+ * then installs it into the device internal structures.
+ *
+ * [in] context
+ * Pointer to context information
+ *
+ * [in] parms
+ * Pointer to parameters
+ *
+ * Returns
+ * - (0) if successful.
+ * - (-EINVAL) on failure.
+ */
+int cfa_tcam_mgr_set(struct cfa_tcam_mgr_context *context,
+ struct cfa_tcam_mgr_set_parms *parms);
+
+/**
+ * Retrieves the requested element by sending a firmware request to get
+ * the element.
+ *
+ * [in] context
+ * Pointer to context information
+ *
+ * [in] parms
+ * Pointer to parameters
+ *
+ * Returns
+ * - (0) if successful.
+ * - (-EINVAL) on failure.
+ */
+int cfa_tcam_mgr_get(struct cfa_tcam_mgr_context *context,
+ struct cfa_tcam_mgr_get_parms *parms);
+
+int
+cfa_tcam_mgr_tables_get(int sess_idx, enum tf_dir dir,
+ enum cfa_tcam_mgr_tbl_type type,
+ uint16_t *start_row,
+ uint16_t *end_row,
+ uint16_t *max_entries,
+ uint16_t *slices);
+int
+cfa_tcam_mgr_tables_set(int sess_idx, enum tf_dir dir,
+ enum cfa_tcam_mgr_tbl_type type,
+ uint16_t start_row,
+ uint16_t end_row,
+ uint16_t max_entries);
+
+int cfa_tcam_mgr_shared_clear(struct cfa_tcam_mgr_context *context,
+ struct cfa_tcam_mgr_shared_clear_parms *parms);
+
+int cfa_tcam_mgr_shared_move(struct cfa_tcam_mgr_context *context,
+ struct cfa_tcam_mgr_shared_move_parms *parms);
+
+void cfa_tcam_mgr_rows_dump(int sess_idx, enum tf_dir dir, enum cfa_tcam_mgr_tbl_type type);
+void cfa_tcam_mgr_tables_dump(int sess_idx, enum tf_dir dir, enum cfa_tcam_mgr_tbl_type type);
+void cfa_tcam_mgr_entries_dump(int sess_idx);
+#endif /* _CFA_TCAM_MGR_H */
new file mode 100644
@@ -0,0 +1,101 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2021-2023 Broadcom
+ * All rights reserved.
+ */
+
+#ifndef CFA_TCAM_MGR_DEVICE_H
+#define CFA_TCAM_MGR_DEVICE_H
+
+#include <inttypes.h>
+#include "cfa_tcam_mgr.h"
+
+/*
+ * This identifier is to be used for one-off variable sizes. Do not use it for
+ * sizing keys in an array.
+ */
+#define CFA_TCAM_MGR_MAX_KEY_SIZE 96
+
+/* Note that this macro's arguments are not macro expanded due to
+ * concatenation.
+ */
+#define TF_TCAM_TABLE_ROWS_DEF(_slices) \
+ struct cfa_tcam_mgr_table_rows_ ## _slices { \
+ uint16_t priority; \
+ uint8_t entry_size; /* Slices per entry */ \
+ uint8_t entry_inuse; /* bit[entry] set if in use */ \
+ uint16_t entries[_slices]; \
+ }
+
+/*
+ * Have to explicitly declare this struct since some compilers don't accept the
+ * GNU C extension of zero length arrays.
+ */
+struct cfa_tcam_mgr_table_rows_0 {
+ uint16_t priority;
+ uint8_t entry_size; /* Slices per entry */
+ uint8_t entry_inuse; /* bit[entry] set if in use */
+ uint16_t entries[];
+};
+
+TF_TCAM_TABLE_ROWS_DEF(1);
+TF_TCAM_TABLE_ROWS_DEF(2);
+TF_TCAM_TABLE_ROWS_DEF(4);
+TF_TCAM_TABLE_ROWS_DEF(8);
+
+#define TF_TCAM_MAX_ENTRIES (L2_CTXT_TCAM_RX_MAX_ENTRIES + \
+ L2_CTXT_TCAM_TX_MAX_ENTRIES + \
+ PROF_TCAM_RX_MAX_ENTRIES + \
+ PROF_TCAM_TX_MAX_ENTRIES + \
+ WC_TCAM_RX_MAX_ENTRIES + \
+ WC_TCAM_TX_MAX_ENTRIES + \
+ SP_TCAM_RX_MAX_ENTRIES + \
+ SP_TCAM_TX_MAX_ENTRIES + \
+ CT_RULE_TCAM_RX_MAX_ENTRIES + \
+ CT_RULE_TCAM_TX_MAX_ENTRIES + \
+ VEB_TCAM_RX_MAX_ENTRIES + \
+ VEB_TCAM_TX_MAX_ENTRIES)
+
+struct cfa_tcam_mgr_entry_data {
+ uint16_t row;
+ uint8_t slice;
+ uint8_t ref_cnt;
+};
+
+struct cfa_tcam_mgr_table_data {
+ struct cfa_tcam_mgr_table_rows_0 *tcam_rows;
+ uint16_t hcapi_type;
+ uint16_t num_rows; /* Rows in physical TCAM */
+ uint16_t start_row; /* Where the logical TCAM starts */
+ uint16_t end_row; /* Where the logical TCAM ends */
+ uint16_t max_entries;
+ uint16_t used_entries;
+ uint8_t row_width; /* bytes */
+ uint8_t result_size; /* bytes */
+ uint8_t max_slices;
+};
+
+extern int cfa_tcam_mgr_max_entries[TF_TCAM_MAX_SESSIONS];
+
+extern struct cfa_tcam_mgr_table_data
+cfa_tcam_mgr_tables[TF_TCAM_MAX_SESSIONS][TF_DIR_MAX][CFA_TCAM_MGR_TBL_TYPE_MAX];
+
+/* HW OP definitions begin here */
+typedef int (*cfa_tcam_mgr_hwop_set_func_t)(int sess_idx,
+ struct cfa_tcam_mgr_set_parms
+ *parms, int row, int slice,
+ int max_slices);
+typedef int (*cfa_tcam_mgr_hwop_get_func_t)(int sess_idx,
+ struct cfa_tcam_mgr_get_parms
+ *parms, int row, int slice,
+ int max_slices);
+typedef int (*cfa_tcam_mgr_hwop_free_func_t)(int sess_idx,
+ struct cfa_tcam_mgr_free_parms
+ *parms, int row, int slice,
+ int max_slices);
+
+struct cfa_tcam_mgr_hwops_funcs {
+ cfa_tcam_mgr_hwop_set_func_t set;
+ cfa_tcam_mgr_hwop_get_func_t get;
+ cfa_tcam_mgr_hwop_free_func_t free;
+};
+#endif /* CFA_TCAM_MGR_DEVICE_H */
new file mode 100644
@@ -0,0 +1,201 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2021-2023 Broadcom
+ * All rights reserved.
+ */
+
+/*
+ * This file will "do the right thing" for each of the primitives set, get and
+ * free. The TCAM manager is running in the core, so the tables will be cached.
+ * Set and free messages will also be sent to the firmware. Instead of sending
+ * get messages, the entry will be read from the cached copy thus saving a
+ * firmware message.
+ */
+
+#include "tf_tcam.h"
+#include "hcapi_cfa_defs.h"
+#include "cfa_tcam_mgr.h"
+#include "cfa_tcam_mgr_hwop_msg.h"
+#include "cfa_tcam_mgr_device.h"
+#include "cfa_tcam_mgr_p58.h"
+#include "cfa_tcam_mgr_p4.h"
+#include "tf_session.h"
+#include "tf_msg.h"
+#include "tfp.h"
+#include "tf_util.h"
+
+/*
+ * The free hwop will free more than a single slice so cannot be used.
+ */
+struct cfa_tcam_mgr_hwops_funcs hwop_funcs;
+
+int
+cfa_tcam_mgr_hwops_init(enum cfa_tcam_mgr_device_type type)
+{
+ switch (type) {
+ case CFA_TCAM_MGR_DEVICE_TYPE_P4:
+ case CFA_TCAM_MGR_DEVICE_TYPE_SR:
+ return cfa_tcam_mgr_hwops_get_funcs_p4(&hwop_funcs);
+ case CFA_TCAM_MGR_DEVICE_TYPE_P5:
+ return cfa_tcam_mgr_hwops_get_funcs_p58(&hwop_funcs);
+ default:
+ CFA_TCAM_MGR_LOG(ERR, "No such device\n");
+ return -CFA_TCAM_MGR_ERR_CODE(NODEV);
+ }
+}
+
+/*
+ * This is the glue between the TCAM manager and the firmware HW operations. It
+ * is intended to abstract out the location of the TCAM manager so that the TCAM
+ * manager code will be the same whether or not it is actually using the
+ * firmware.
+ */
+
+int
+cfa_tcam_mgr_entry_set_msg(int sess_idx, struct cfa_tcam_mgr_context *context
+ __rte_unused,
+ struct cfa_tcam_mgr_set_parms *parms,
+ int row, int slice,
+ int max_slices __rte_unused)
+{
+ cfa_tcam_mgr_hwop_set_func_t set_func;
+
+ set_func = hwop_funcs.set;
+ if (set_func == NULL)
+ return -CFA_TCAM_MGR_ERR_CODE(PERM);
+
+ struct tf_tcam_set_parms sparms;
+ struct tf_session *tfs;
+ struct tf_dev_info *dev;
+ int rc;
+ enum tf_tcam_tbl_type type =
+ cfa_tcam_mgr_get_phys_table_type(parms->type);
+
+ /* Retrieve the session information */
+ rc = tf_session_get_session_internal(context->tfp, &tfs);
+ if (rc)
+ return rc;
+
+ /* Retrieve the device information */
+ rc = tf_session_get_device(tfs, &dev);
+ if (rc)
+ return rc;
+
+ memset(&sparms, 0, sizeof(sparms));
+ sparms.dir = parms->dir;
+ sparms.type = type;
+ sparms.hcapi_type = parms->hcapi_type;
+ sparms.idx = (row * max_slices) + slice;
+ sparms.key = parms->key;
+ sparms.mask = parms->mask;
+ sparms.key_size = parms->key_size;
+ sparms.result = parms->result;
+ sparms.result_size = parms->result_size;
+
+ rc = tf_msg_tcam_entry_set(context->tfp, dev, &sparms);
+ if (rc) {
+ /* Log error */
+ CFA_TCAM_MGR_LOG_DIR_TYPE(ERR, parms->dir, parms->type,
+ "Entry %d set failed, rc:%d\n",
+ parms->id, -rc);
+ return rc;
+ }
+
+ return set_func(sess_idx, parms, row, slice, max_slices);
+}
+
+int
+cfa_tcam_mgr_entry_get_msg(int sess_idx, struct cfa_tcam_mgr_context *context
+ __rte_unused,
+ struct cfa_tcam_mgr_get_parms *parms,
+ int row, int slice,
+ int max_slices __rte_unused)
+{
+ cfa_tcam_mgr_hwop_get_func_t get_func;
+
+ get_func = hwop_funcs.get;
+ if (get_func == NULL)
+ return -CFA_TCAM_MGR_ERR_CODE(PERM);
+
+ return get_func(sess_idx, parms, row, slice, max_slices);
+}
+
+int
+cfa_tcam_mgr_entry_free_msg(int sess_idx, struct cfa_tcam_mgr_context *context
+ __rte_unused,
+ struct cfa_tcam_mgr_free_parms *parms,
+ int row, int slice,
+ int key_size,
+ int result_size,
+ int max_slices)
+{
+ cfa_tcam_mgr_hwop_free_func_t free_func;
+
+ free_func = hwop_funcs.free;
+ if (free_func == NULL)
+ return -CFA_TCAM_MGR_ERR_CODE(PERM);
+
+ struct tf_dev_info *dev;
+ struct tf_session *tfs;
+ int rc;
+ enum tf_tcam_tbl_type type =
+ cfa_tcam_mgr_get_phys_table_type(parms->type);
+
+ /* Free will clear an entire row. */
+ /* Use set message to clear an individual entry */
+ struct tf_tcam_set_parms sparms;
+ uint8_t key[CFA_TCAM_MGR_MAX_KEY_SIZE] = { 0 };
+ uint8_t mask[CFA_TCAM_MGR_MAX_KEY_SIZE] = { 0 };
+
+ /* Retrieve the session information */
+ rc = tf_session_get_session_internal(context->tfp, &tfs);
+ if (rc)
+ return rc;
+
+ /* Retrieve the device information */
+ rc = tf_session_get_device(tfs, &dev);
+ if (rc)
+ return rc;
+
+ if (key_size > CFA_TCAM_MGR_MAX_KEY_SIZE) {
+ CFA_TCAM_MGR_LOG_DIR_TYPE(ERR, parms->dir, parms->type,
+ "Entry %d key size is %d greater than:%d\n",
+ parms->id, key_size,
+ CFA_TCAM_MGR_MAX_KEY_SIZE);
+ return -EINVAL;
+ }
+
+ if (result_size > CFA_TCAM_MGR_MAX_KEY_SIZE) {
+ CFA_TCAM_MGR_LOG_DIR_TYPE(ERR, parms->dir, parms->type,
+ "Entry %d result size is %d greater than:%d\n",
+ parms->id, result_size,
+ CFA_TCAM_MGR_MAX_KEY_SIZE);
+ return -EINVAL;
+ }
+
+ memset(&sparms, 0, sizeof(sparms));
+ memset(&key, 0, sizeof(key));
+ memset(&mask, 0xff, sizeof(mask));
+
+ sparms.dir = parms->dir;
+ sparms.type = type;
+ sparms.hcapi_type = parms->hcapi_type;
+ sparms.key = key;
+ sparms.mask = mask;
+ sparms.result = key;
+ sparms.idx = (row * max_slices) + slice;
+ sparms.key_size = key_size;
+ sparms.result_size = result_size;
+
+ rc = tf_msg_tcam_entry_set(context->tfp, dev, &sparms);
+ if (rc) {
+ /* Log error */
+ CFA_TCAM_MGR_LOG_DIR_TYPE(ERR, parms->dir, parms->type,
+ "Row %d, slice %d set failed, "
+ "rc:%d.\n",
+ row,
+ slice,
+ rc);
+ return rc;
+ }
+ return free_func(sess_idx, parms, row, slice, max_slices);
+}
new file mode 100644
@@ -0,0 +1,28 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2021-2023 Broadcom
+ * All rights reserved.
+ */
+
+#ifndef CFA_TCAM_MGR_HWOP_MSG_H
+#define CFA_TCAM_MGR_HWOP_MSG_H
+
+int
+cfa_tcam_mgr_hwops_init(enum cfa_tcam_mgr_device_type type);
+
+int
+cfa_tcam_mgr_entry_set_msg(int sess_idx,
+ struct cfa_tcam_mgr_context *context,
+ struct cfa_tcam_mgr_set_parms *parms,
+ int row, int slice, int max_slices);
+int
+cfa_tcam_mgr_entry_get_msg(int sess_idx,
+ struct cfa_tcam_mgr_context *context,
+ struct cfa_tcam_mgr_get_parms *parms,
+ int row, int slice, int max_slices);
+int
+cfa_tcam_mgr_entry_free_msg(int sess_idx,
+ struct cfa_tcam_mgr_context *context,
+ struct cfa_tcam_mgr_free_parms *parms,
+ int row, int slice, int key_size,
+ int result_size, int max_slices);
+#endif /* CFA_TCAM_MGR_HWOP_MSG_H */
new file mode 100644
@@ -0,0 +1,921 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2021-2023 Broadcom
+ * All rights reserved.
+ */
+
+#include "hcapi_cfa_defs.h"
+
+#include "cfa_tcam_mgr.h"
+#include "cfa_tcam_mgr_p4.h"
+#include "cfa_tcam_mgr_device.h"
+#include "cfa_resource_types.h"
+#include "tfp.h"
+#include "assert.h"
+#include "tf_util.h"
+
+/*
+ * Sizings of the TCAMs on P4
+ */
+
+#define MAX_ROW_WIDTH 48
+#define MAX_RESULT_SIZE 8
+
+#if MAX_ROW_WIDTH > CFA_TCAM_MGR_MAX_KEY_SIZE
+#error MAX_ROW_WIDTH > CFA_TCAM_MGR_MAX_KEY_SIZE
+#endif
+
+/*
+ * TCAM definitions
+ *
+ * These define the TCAMs in HW.
+ *
+ * Note: Set xxx_TCAM_[R|T]X_NUM_ROWS to zero if a TCAM is either not supported
+ * by HW or not supported by TCAM Manager.
+ */
+
+/** L2 Context TCAM */
+#define L2_CTXT_TCAM_RX_MAX_SLICES 1
+#define L2_CTXT_TCAM_RX_ROW_WIDTH TF_BITS2BYTES_WORD_ALIGN(167)
+#define L2_CTXT_TCAM_RX_NUM_ROWS 1024
+#define L2_CTXT_TCAM_RX_MAX_ENTRIES (L2_CTXT_TCAM_RX_MAX_SLICES * \
+ L2_CTXT_TCAM_RX_NUM_ROWS)
+#define L2_CTXT_TCAM_RX_RESULT_SIZE 8
+
+#define L2_CTXT_TCAM_TX_MAX_SLICES L2_CTXT_TCAM_RX_MAX_SLICES
+#define L2_CTXT_TCAM_TX_ROW_WIDTH L2_CTXT_TCAM_RX_ROW_WIDTH
+#define L2_CTXT_TCAM_TX_NUM_ROWS L2_CTXT_TCAM_RX_NUM_ROWS
+#define L2_CTXT_TCAM_TX_MAX_ENTRIES L2_CTXT_TCAM_RX_MAX_ENTRIES
+#define L2_CTXT_TCAM_TX_RESULT_SIZE L2_CTXT_TCAM_RX_RESULT_SIZE
+
+/** Profile TCAM */
+#define PROF_TCAM_RX_MAX_SLICES 1
+#define PROF_TCAM_RX_ROW_WIDTH TF_BITS2BYTES_WORD_ALIGN(81)
+#define PROF_TCAM_RX_NUM_ROWS 1024
+#define PROF_TCAM_RX_MAX_ENTRIES (PROF_TCAM_RX_MAX_SLICES * \
+ PROF_TCAM_RX_NUM_ROWS)
+#define PROF_TCAM_RX_RESULT_SIZE 8
+
+#define PROF_TCAM_TX_MAX_SLICES PROF_TCAM_RX_MAX_SLICES
+#define PROF_TCAM_TX_ROW_WIDTH PROF_TCAM_RX_ROW_WIDTH
+#define PROF_TCAM_TX_NUM_ROWS PROF_TCAM_RX_NUM_ROWS
+#define PROF_TCAM_TX_MAX_ENTRIES PROF_TCAM_RX_MAX_ENTRIES
+#define PROF_TCAM_TX_RESULT_SIZE PROF_TCAM_RX_RESULT_SIZE
+
+/** Wildcard TCAM */
+#define WC_TCAM_RX_MAX_SLICES 4
+/* 82 bits per slice */
+#define WC_TCAM_RX_ROW_WIDTH (TF_BITS2BYTES_WORD_ALIGN(82) * \
+ WC_TCAM_RX_MAX_SLICES)
+#define WC_TCAM_RX_NUM_ROWS 256
+#define WC_TCAM_RX_MAX_ENTRIES (WC_TCAM_RX_MAX_SLICES * WC_TCAM_RX_NUM_ROWS)
+#define WC_TCAM_RX_RESULT_SIZE 4
+
+#define WC_TCAM_TX_MAX_SLICES WC_TCAM_RX_MAX_SLICES
+#define WC_TCAM_TX_ROW_WIDTH WC_TCAM_RX_ROW_WIDTH
+#define WC_TCAM_TX_NUM_ROWS WC_TCAM_RX_NUM_ROWS
+#define WC_TCAM_TX_MAX_ENTRIES WC_TCAM_RX_MAX_ENTRIES
+#define WC_TCAM_TX_RESULT_SIZE WC_TCAM_RX_RESULT_SIZE
+
+/** Source Properties TCAM */
+#define SP_TCAM_RX_MAX_SLICES 1
+#define SP_TCAM_RX_ROW_WIDTH TF_BITS2BYTES_WORD_ALIGN(89)
+#define SP_TCAM_RX_NUM_ROWS 512
+#define SP_TCAM_RX_MAX_ENTRIES (SP_TCAM_RX_MAX_SLICES * SP_TCAM_RX_NUM_ROWS)
+#define SP_TCAM_RX_RESULT_SIZE 8
+
+#define SP_TCAM_TX_MAX_SLICES SP_TCAM_RX_MAX_SLICES
+#define SP_TCAM_TX_ROW_WIDTH SP_TCAM_RX_ROW_WIDTH
+#define SP_TCAM_TX_NUM_ROWS SP_TCAM_RX_NUM_ROWS
+#define SP_TCAM_TX_MAX_ENTRIES SP_TCAM_RX_MAX_ENTRIES
+#define SP_TCAM_TX_RESULT_SIZE SP_TCAM_RX_RESULT_SIZE
+
+/** Connection Tracking Rule TCAM */
+#define CT_RULE_TCAM_RX_MAX_SLICES 1
+#define CT_RULE_TCAM_RX_ROW_WIDTH TF_BITS2BYTES_WORD_ALIGN(16)
+#define CT_RULE_TCAM_RX_NUM_ROWS 0
+#define CT_RULE_TCAM_RX_MAX_ENTRIES (CT_RULE_TCAM_RX_MAX_SLICES * \
+ CT_RULE_TCAM_RX_NUM_ROWS)
+#define CT_RULE_TCAM_RX_RESULT_SIZE 8
+
+#define CT_RULE_TCAM_TX_MAX_SLICES CT_RULE_TCAM_RX_MAX_SLICES
+#define CT_RULE_TCAM_TX_ROW_WIDTH CT_RULE_TCAM_RX_ROW_WIDTH
+#define CT_RULE_TCAM_TX_NUM_ROWS CT_RULE_TCAM_RX_NUM_ROWS
+#define CT_RULE_TCAM_TX_MAX_ENTRIES CT_RULE_TCAM_RX_MAX_ENTRIES
+#define CT_RULE_TCAM_TX_RESULT_SIZE CT_RULE_TCAM_RX_RESULT_SIZE
+
+/** Virtual Edge Bridge TCAM */
+#define VEB_TCAM_RX_MAX_SLICES 1
+#define VEB_TCAM_RX_ROW_WIDTH TF_BITS2BYTES_WORD_ALIGN(78)
+/* Tx only */
+#define VEB_TCAM_RX_NUM_ROWS 0
+#define VEB_TCAM_RX_MAX_ENTRIES (VEB_TCAM_RX_MAX_SLICES * VEB_TCAM_RX_NUM_ROWS)
+#define VEB_TCAM_RX_RESULT_SIZE 8
+
+#define VEB_TCAM_TX_MAX_SLICES VEB_TCAM_RX_MAX_SLICES
+#define VEB_TCAM_TX_ROW_WIDTH VEB_TCAM_RX_ROW_WIDTH
+#define VEB_TCAM_TX_NUM_ROWS 1024
+#define VEB_TCAM_TX_MAX_ENTRIES (VEB_TCAM_TX_MAX_SLICES * VEB_TCAM_TX_NUM_ROWS)
+#define VEB_TCAM_TX_RESULT_SIZE VEB_TCAM_RX_RESULT_SIZE
+
+/* Declare the table rows for each table here. If new tables are added to the
+ * enum tf_tcam_tbl_type, then new declarations will be needed here.
+ *
+ * The numeric suffix of the structure type indicates how many slices a
+ * particular TCAM supports.
+ *
+ * Array sizes have 1 added to avoid zero length arrays.
+ */
+
+static struct cfa_tcam_mgr_table_rows_1
+ cfa_tcam_mgr_table_rows_L2_CTXT_TCAM_RX[TF_TCAM_MAX_SESSIONS][L2_CTXT_TCAM_RX_NUM_ROWS + 1];
+static struct cfa_tcam_mgr_table_rows_1
+ cfa_tcam_mgr_table_rows_L2_CTXT_TCAM_TX[TF_TCAM_MAX_SESSIONS][L2_CTXT_TCAM_TX_NUM_ROWS + 1];
+static struct cfa_tcam_mgr_table_rows_1
+ cfa_tcam_mgr_table_rows_PROF_TCAM_RX[TF_TCAM_MAX_SESSIONS][PROF_TCAM_RX_NUM_ROWS + 1];
+static struct cfa_tcam_mgr_table_rows_1
+ cfa_tcam_mgr_table_rows_PROF_TCAM_TX[TF_TCAM_MAX_SESSIONS][PROF_TCAM_TX_NUM_ROWS + 1];
+static struct cfa_tcam_mgr_table_rows_4
+ cfa_tcam_mgr_table_rows_WC_TCAM_RX[TF_TCAM_MAX_SESSIONS][WC_TCAM_RX_NUM_ROWS + 1];
+static struct cfa_tcam_mgr_table_rows_4
+ cfa_tcam_mgr_table_rows_WC_TCAM_TX[TF_TCAM_MAX_SESSIONS][WC_TCAM_TX_NUM_ROWS + 1];
+static struct cfa_tcam_mgr_table_rows_1
+ cfa_tcam_mgr_table_rows_SP_TCAM_RX[TF_TCAM_MAX_SESSIONS][SP_TCAM_RX_NUM_ROWS + 1];
+static struct cfa_tcam_mgr_table_rows_1
+ cfa_tcam_mgr_table_rows_SP_TCAM_TX[TF_TCAM_MAX_SESSIONS][SP_TCAM_TX_NUM_ROWS + 1];
+static struct cfa_tcam_mgr_table_rows_1
+ cfa_tcam_mgr_table_rows_CT_RULE_TCAM_RX[TF_TCAM_MAX_SESSIONS][CT_RULE_TCAM_RX_NUM_ROWS + 1];
+static struct cfa_tcam_mgr_table_rows_1
+ cfa_tcam_mgr_table_rows_CT_RULE_TCAM_TX[TF_TCAM_MAX_SESSIONS][CT_RULE_TCAM_TX_NUM_ROWS + 1];
+static struct cfa_tcam_mgr_table_rows_1
+ cfa_tcam_mgr_table_rows_VEB_TCAM_RX[TF_TCAM_MAX_SESSIONS][VEB_TCAM_RX_NUM_ROWS + 1];
+static struct cfa_tcam_mgr_table_rows_1
+ cfa_tcam_mgr_table_rows_VEB_TCAM_TX[TF_TCAM_MAX_SESSIONS][VEB_TCAM_TX_NUM_ROWS + 1];
+static struct cfa_tcam_mgr_table_rows_4
+ cfa_tcam_mgr_table_rows_WC_TCAM_RX_HIGH[TF_TCAM_MAX_SESSIONS][WC_TCAM_RX_NUM_ROWS + 1];
+static struct cfa_tcam_mgr_table_rows_4
+ cfa_tcam_mgr_table_rows_WC_TCAM_RX_LOW[TF_TCAM_MAX_SESSIONS][WC_TCAM_RX_NUM_ROWS + 1];
+static struct cfa_tcam_mgr_table_rows_4
+ cfa_tcam_mgr_table_rows_WC_TCAM_TX_HIGH[TF_TCAM_MAX_SESSIONS][WC_TCAM_TX_NUM_ROWS + 1];
+static struct cfa_tcam_mgr_table_rows_4
+ cfa_tcam_mgr_table_rows_WC_TCAM_TX_LOW[TF_TCAM_MAX_SESSIONS][WC_TCAM_TX_NUM_ROWS + 1];
+
+struct cfa_tcam_mgr_table_data
+cfa_tcam_mgr_tables_p4[TF_DIR_MAX][CFA_TCAM_MGR_TBL_TYPE_MAX] = {
+ { /* RX */
+ { /* High AFM */
+ .max_slices = L2_CTXT_TCAM_RX_MAX_SLICES,
+ .row_width = L2_CTXT_TCAM_RX_ROW_WIDTH,
+ .num_rows = L2_CTXT_TCAM_RX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = 0,
+ .max_entries = 0,
+ .result_size = L2_CTXT_TCAM_RX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P4_L2_CTXT_TCAM_HIGH,
+ },
+ { /* High APPS */
+ .max_slices = L2_CTXT_TCAM_RX_MAX_SLICES,
+ .row_width = L2_CTXT_TCAM_RX_ROW_WIDTH,
+ .num_rows = L2_CTXT_TCAM_RX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = (L2_CTXT_TCAM_RX_NUM_ROWS / 2) - 1,
+ .max_entries = (L2_CTXT_TCAM_RX_MAX_ENTRIES / 2),
+ .result_size = L2_CTXT_TCAM_RX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P4_L2_CTXT_TCAM_HIGH,
+ },
+ { /* Low AFM */
+ .max_slices = L2_CTXT_TCAM_RX_MAX_SLICES,
+ .row_width = L2_CTXT_TCAM_RX_ROW_WIDTH,
+ .num_rows = L2_CTXT_TCAM_RX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = 0,
+ .max_entries = 0,
+ .result_size = L2_CTXT_TCAM_RX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P4_L2_CTXT_TCAM_LOW,
+ },
+ { /* Low APPS */
+ .max_slices = L2_CTXT_TCAM_RX_MAX_SLICES,
+ .row_width = L2_CTXT_TCAM_RX_ROW_WIDTH,
+ .num_rows = L2_CTXT_TCAM_RX_NUM_ROWS,
+ .start_row = (L2_CTXT_TCAM_RX_NUM_ROWS / 2),
+ .end_row = L2_CTXT_TCAM_RX_NUM_ROWS - 1,
+ .max_entries = (L2_CTXT_TCAM_RX_MAX_ENTRIES / 2),
+ .result_size = L2_CTXT_TCAM_RX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P4_L2_CTXT_TCAM_LOW,
+ },
+ { /* AFM */
+ .max_slices = PROF_TCAM_RX_MAX_SLICES,
+ .row_width = PROF_TCAM_RX_ROW_WIDTH,
+ .num_rows = PROF_TCAM_RX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = 0,
+ .max_entries = 0,
+ .result_size = PROF_TCAM_RX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P4_PROF_TCAM,
+ },
+ { /* APPS */
+ .max_slices = PROF_TCAM_RX_MAX_SLICES,
+ .row_width = PROF_TCAM_RX_ROW_WIDTH,
+ .num_rows = PROF_TCAM_RX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = PROF_TCAM_RX_NUM_ROWS - 1,
+ .max_entries = PROF_TCAM_RX_MAX_ENTRIES,
+ .result_size = PROF_TCAM_RX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P4_PROF_TCAM,
+ },
+ { /* AFM */
+ .max_slices = WC_TCAM_RX_MAX_SLICES,
+ .row_width = WC_TCAM_RX_ROW_WIDTH,
+ .num_rows = WC_TCAM_RX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = 0,
+ .max_entries = 0,
+ .result_size = WC_TCAM_RX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P4_WC_TCAM,
+ },
+ { /* APPS */
+ .max_slices = WC_TCAM_RX_MAX_SLICES,
+ .row_width = WC_TCAM_RX_ROW_WIDTH,
+ .num_rows = WC_TCAM_RX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = WC_TCAM_RX_NUM_ROWS - 1,
+ .max_entries = WC_TCAM_RX_MAX_ENTRIES,
+ .result_size = WC_TCAM_RX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P4_WC_TCAM,
+ },
+ { /* AFM */
+ .max_slices = SP_TCAM_RX_MAX_SLICES,
+ .row_width = SP_TCAM_RX_ROW_WIDTH,
+ .num_rows = SP_TCAM_RX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = 0,
+ .max_entries = 0,
+ .result_size = SP_TCAM_RX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P4_SP_TCAM,
+ },
+ { /* APPS */
+ .max_slices = SP_TCAM_RX_MAX_SLICES,
+ .row_width = SP_TCAM_RX_ROW_WIDTH,
+ .num_rows = SP_TCAM_RX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = SP_TCAM_RX_NUM_ROWS - 1,
+ .max_entries = SP_TCAM_RX_MAX_ENTRIES,
+ .result_size = SP_TCAM_RX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P4_SP_TCAM,
+ },
+ { /* AFM */
+ .max_slices = CT_RULE_TCAM_RX_MAX_SLICES,
+ .row_width = CT_RULE_TCAM_RX_ROW_WIDTH,
+ .num_rows = CT_RULE_TCAM_RX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = 0,
+ .max_entries = 0,
+ .result_size = CT_RULE_TCAM_RX_RESULT_SIZE,
+ },
+ { /* APPS */
+ .max_slices = CT_RULE_TCAM_RX_MAX_SLICES,
+ .row_width = CT_RULE_TCAM_RX_ROW_WIDTH,
+ .num_rows = CT_RULE_TCAM_RX_NUM_ROWS,
+ .start_row = 0,
+#if CT_RULE_TCAM_RX_NUM_ROWS > 0
+ .end_row = CT_RULE_TCAM_RX_NUM_ROWS - 1,
+#else
+ .end_row = CT_RULE_TCAM_RX_NUM_ROWS,
+#endif
+ .max_entries = CT_RULE_TCAM_RX_MAX_ENTRIES,
+ .result_size = CT_RULE_TCAM_RX_RESULT_SIZE,
+ },
+ { /* AFM */
+ .max_slices = VEB_TCAM_RX_MAX_SLICES,
+ .row_width = VEB_TCAM_RX_ROW_WIDTH,
+ .num_rows = VEB_TCAM_RX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = 0,
+ .max_entries = 0,
+ .result_size = VEB_TCAM_RX_RESULT_SIZE,
+ },
+ { /* APPS */
+ .max_slices = VEB_TCAM_RX_MAX_SLICES,
+ .row_width = VEB_TCAM_RX_ROW_WIDTH,
+ .num_rows = VEB_TCAM_RX_NUM_ROWS,
+ .start_row = 0,
+#if VEB_TCAM_RX_NUM_ROWS > 0
+ .end_row = VEB_TCAM_RX_NUM_ROWS - 1,
+#else
+ .end_row = VEB_TCAM_RX_NUM_ROWS,
+#endif
+ .max_entries = VEB_TCAM_RX_MAX_ENTRIES,
+ .result_size = VEB_TCAM_RX_RESULT_SIZE,
+ },
+ { /* AFM */
+ .max_slices = WC_TCAM_RX_MAX_SLICES,
+ .row_width = WC_TCAM_RX_ROW_WIDTH,
+ .num_rows = WC_TCAM_RX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = 0,
+ .max_entries = 0,
+ .result_size = WC_TCAM_RX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P4_WC_TCAM,
+ },
+ { /* APPS */
+ .max_slices = WC_TCAM_RX_MAX_SLICES,
+ .row_width = WC_TCAM_RX_ROW_WIDTH,
+ .num_rows = WC_TCAM_RX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = WC_TCAM_RX_NUM_ROWS - 1,
+ .max_entries = WC_TCAM_RX_MAX_ENTRIES,
+ .result_size = WC_TCAM_RX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P4_WC_TCAM,
+ },
+ { /* AFM */
+ .max_slices = WC_TCAM_RX_MAX_SLICES,
+ .row_width = WC_TCAM_RX_ROW_WIDTH,
+ .num_rows = WC_TCAM_RX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = 0,
+ .max_entries = 0,
+ .result_size = WC_TCAM_RX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P4_WC_TCAM,
+ },
+ { /* APPS */
+ .max_slices = WC_TCAM_RX_MAX_SLICES,
+ .row_width = WC_TCAM_RX_ROW_WIDTH,
+ .num_rows = WC_TCAM_RX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = WC_TCAM_RX_NUM_ROWS - 1,
+ .max_entries = WC_TCAM_RX_MAX_ENTRIES,
+ .result_size = WC_TCAM_RX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P4_WC_TCAM,
+ },
+ },
+ { /* TX */
+ { /* AFM */
+ .max_slices = L2_CTXT_TCAM_TX_MAX_SLICES,
+ .row_width = L2_CTXT_TCAM_TX_ROW_WIDTH,
+ .num_rows = L2_CTXT_TCAM_TX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = 0,
+ .max_entries = 0,
+ .result_size = L2_CTXT_TCAM_TX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P4_L2_CTXT_TCAM_HIGH,
+ },
+ { /* APPS */
+ .max_slices = L2_CTXT_TCAM_TX_MAX_SLICES,
+ .row_width = L2_CTXT_TCAM_TX_ROW_WIDTH,
+ .num_rows = L2_CTXT_TCAM_TX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = (L2_CTXT_TCAM_TX_NUM_ROWS / 2) - 1,
+ .max_entries = (L2_CTXT_TCAM_TX_MAX_ENTRIES / 2),
+ .result_size = L2_CTXT_TCAM_TX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P4_L2_CTXT_TCAM_HIGH,
+ },
+ { /* AFM */
+ .max_slices = L2_CTXT_TCAM_TX_MAX_SLICES,
+ .row_width = L2_CTXT_TCAM_TX_ROW_WIDTH,
+ .num_rows = L2_CTXT_TCAM_TX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = 0,
+ .max_entries = 0,
+ .result_size = L2_CTXT_TCAM_TX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P4_L2_CTXT_TCAM_LOW,
+ },
+ { /* APPS */
+ .max_slices = L2_CTXT_TCAM_TX_MAX_SLICES,
+ .row_width = L2_CTXT_TCAM_TX_ROW_WIDTH,
+ .num_rows = L2_CTXT_TCAM_TX_NUM_ROWS,
+ .start_row = (L2_CTXT_TCAM_TX_NUM_ROWS / 2),
+ .end_row = L2_CTXT_TCAM_TX_NUM_ROWS - 1,
+ .max_entries = (L2_CTXT_TCAM_TX_MAX_ENTRIES / 2),
+ .result_size = L2_CTXT_TCAM_TX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P4_L2_CTXT_TCAM_LOW,
+ },
+ { /* AFM */
+ .max_slices = PROF_TCAM_TX_MAX_SLICES,
+ .row_width = PROF_TCAM_TX_ROW_WIDTH,
+ .num_rows = PROF_TCAM_TX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = 0,
+ .max_entries = 0,
+ .result_size = PROF_TCAM_TX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P4_PROF_TCAM,
+ },
+ { /* APPS */
+ .max_slices = PROF_TCAM_TX_MAX_SLICES,
+ .row_width = PROF_TCAM_TX_ROW_WIDTH,
+ .num_rows = PROF_TCAM_TX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = PROF_TCAM_TX_NUM_ROWS - 1,
+ .max_entries = PROF_TCAM_TX_MAX_ENTRIES,
+ .result_size = PROF_TCAM_TX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P4_PROF_TCAM,
+ },
+ { /* AFM */
+ .max_slices = WC_TCAM_TX_MAX_SLICES,
+ .row_width = WC_TCAM_TX_ROW_WIDTH,
+ .num_rows = WC_TCAM_TX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = 0,
+ .max_entries = 0,
+ .result_size = WC_TCAM_TX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P4_WC_TCAM,
+ },
+ { /* APPS */
+ .max_slices = WC_TCAM_TX_MAX_SLICES,
+ .row_width = WC_TCAM_TX_ROW_WIDTH,
+ .num_rows = WC_TCAM_TX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = WC_TCAM_TX_NUM_ROWS - 1,
+ .max_entries = WC_TCAM_TX_MAX_ENTRIES,
+ .result_size = WC_TCAM_TX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P4_WC_TCAM,
+ },
+ { /* AFM */
+ .max_slices = SP_TCAM_TX_MAX_SLICES,
+ .row_width = SP_TCAM_TX_ROW_WIDTH,
+ .num_rows = SP_TCAM_TX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = 0,
+ .max_entries = 0,
+ .result_size = SP_TCAM_TX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P4_SP_TCAM,
+ },
+ { /* APPS */
+ .max_slices = SP_TCAM_TX_MAX_SLICES,
+ .row_width = SP_TCAM_TX_ROW_WIDTH,
+ .num_rows = SP_TCAM_TX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = SP_TCAM_TX_NUM_ROWS - 1,
+ .max_entries = SP_TCAM_TX_MAX_ENTRIES,
+ .result_size = SP_TCAM_TX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P4_SP_TCAM,
+ },
+ { /* AFM */
+ .max_slices = CT_RULE_TCAM_TX_MAX_SLICES,
+ .row_width = CT_RULE_TCAM_TX_ROW_WIDTH,
+ .num_rows = CT_RULE_TCAM_TX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = 0,
+ .max_entries = 0,
+ .result_size = CT_RULE_TCAM_RX_RESULT_SIZE,
+ },
+ { /* APPS */
+ .max_slices = CT_RULE_TCAM_TX_MAX_SLICES,
+ .row_width = CT_RULE_TCAM_TX_ROW_WIDTH,
+ .num_rows = CT_RULE_TCAM_TX_NUM_ROWS,
+ .start_row = 0,
+#if CT_RULE_TCAM_TX_NUM_ROWS > 0
+ .end_row = CT_RULE_TCAM_TX_NUM_ROWS - 1,
+#else
+ .end_row = CT_RULE_TCAM_TX_NUM_ROWS,
+#endif
+ .max_entries = CT_RULE_TCAM_TX_MAX_ENTRIES,
+ .result_size = CT_RULE_TCAM_RX_RESULT_SIZE,
+ },
+ { /* AFM */
+ .max_slices = VEB_TCAM_TX_MAX_SLICES,
+ .row_width = VEB_TCAM_TX_ROW_WIDTH,
+ .num_rows = VEB_TCAM_TX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = 0,
+ .max_entries = 0,
+ .result_size = VEB_TCAM_RX_RESULT_SIZE,
+ },
+ { /* APPS */
+ .max_slices = VEB_TCAM_TX_MAX_SLICES,
+ .row_width = VEB_TCAM_TX_ROW_WIDTH,
+ .num_rows = VEB_TCAM_TX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = VEB_TCAM_TX_NUM_ROWS - 1,
+ .max_entries = VEB_TCAM_TX_MAX_ENTRIES,
+ .result_size = VEB_TCAM_RX_RESULT_SIZE,
+ },
+ { /* AFM */
+ .max_slices = WC_TCAM_TX_MAX_SLICES,
+ .row_width = WC_TCAM_TX_ROW_WIDTH,
+ .num_rows = WC_TCAM_TX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = 0,
+ .max_entries = 0,
+ .result_size = WC_TCAM_TX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P4_WC_TCAM,
+ },
+ { /* APPS */
+ .max_slices = WC_TCAM_TX_MAX_SLICES,
+ .row_width = WC_TCAM_TX_ROW_WIDTH,
+ .num_rows = WC_TCAM_TX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = WC_TCAM_TX_NUM_ROWS - 1,
+ .max_entries = WC_TCAM_TX_MAX_ENTRIES,
+ .result_size = WC_TCAM_TX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P4_WC_TCAM,
+ },
+ { /* AFM */
+ .max_slices = WC_TCAM_TX_MAX_SLICES,
+ .row_width = WC_TCAM_TX_ROW_WIDTH,
+ .num_rows = WC_TCAM_TX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = 0,
+ .max_entries = 0,
+ .result_size = WC_TCAM_TX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P4_WC_TCAM,
+ },
+ { /* APPS */
+ .max_slices = WC_TCAM_TX_MAX_SLICES,
+ .row_width = WC_TCAM_TX_ROW_WIDTH,
+ .num_rows = WC_TCAM_TX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = WC_TCAM_TX_NUM_ROWS - 1,
+ .max_entries = WC_TCAM_TX_MAX_ENTRIES,
+ .result_size = WC_TCAM_TX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P4_WC_TCAM,
+ },
+ },
+};
+
+static struct cfa_tcam_mgr_entry_data entry_data_p4[TF_TCAM_MAX_SESSIONS][TF_TCAM_MAX_ENTRIES];
+
+static struct sbmp session_bmp_p4[TF_TCAM_MAX_SESSIONS][TF_TCAM_MAX_ENTRIES];
+
+int
+cfa_tcam_mgr_sess_table_get_p4(int sess_idx, struct sbmp **session_bmp)
+{
+ *session_bmp = session_bmp_p4[sess_idx];
+ return 0;
+}
+
+int
+cfa_tcam_mgr_init_p4(int sess_idx, struct cfa_tcam_mgr_entry_data **global_entry_data)
+{
+ int max_row_width = 0;
+ int max_result_size = 0;
+ int dir, type;
+
+ *global_entry_data = entry_data_p4[sess_idx];
+
+ memcpy(&cfa_tcam_mgr_tables[sess_idx],
+ &cfa_tcam_mgr_tables_p4,
+ sizeof(cfa_tcam_mgr_tables[sess_idx]));
+
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_RX]
+ [CFA_TCAM_MGR_TBL_TYPE_L2_CTXT_TCAM_HIGH_AFM].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_L2_CTXT_TCAM_RX[sess_idx];
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_RX]
+ [CFA_TCAM_MGR_TBL_TYPE_L2_CTXT_TCAM_HIGH_APPS].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_L2_CTXT_TCAM_RX[sess_idx];
+
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_TX]
+ [CFA_TCAM_MGR_TBL_TYPE_L2_CTXT_TCAM_HIGH_AFM].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_L2_CTXT_TCAM_TX[sess_idx];
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_TX]
+ [CFA_TCAM_MGR_TBL_TYPE_L2_CTXT_TCAM_HIGH_APPS].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_L2_CTXT_TCAM_TX[sess_idx];
+
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_RX]
+ [CFA_TCAM_MGR_TBL_TYPE_L2_CTXT_TCAM_LOW_AFM].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_L2_CTXT_TCAM_RX[sess_idx];
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_RX]
+ [CFA_TCAM_MGR_TBL_TYPE_L2_CTXT_TCAM_LOW_APPS].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_L2_CTXT_TCAM_RX[sess_idx];
+
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_TX]
+ [CFA_TCAM_MGR_TBL_TYPE_L2_CTXT_TCAM_LOW_AFM].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_L2_CTXT_TCAM_TX[sess_idx];
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_TX]
+ [CFA_TCAM_MGR_TBL_TYPE_L2_CTXT_TCAM_LOW_APPS].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_L2_CTXT_TCAM_TX[sess_idx];
+
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_RX]
+ [CFA_TCAM_MGR_TBL_TYPE_PROF_TCAM_AFM].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_PROF_TCAM_RX[sess_idx];
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_RX]
+ [CFA_TCAM_MGR_TBL_TYPE_PROF_TCAM_APPS].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_PROF_TCAM_RX[sess_idx];
+
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_TX]
+ [CFA_TCAM_MGR_TBL_TYPE_PROF_TCAM_AFM].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_PROF_TCAM_TX[sess_idx];
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_TX]
+ [CFA_TCAM_MGR_TBL_TYPE_PROF_TCAM_APPS].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_PROF_TCAM_TX[sess_idx];
+
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_RX]
+ [CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_AFM].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_WC_TCAM_RX[sess_idx];
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_RX]
+ [CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_APPS].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_WC_TCAM_RX[sess_idx];
+
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_TX]
+ [CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_AFM].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_WC_TCAM_TX[sess_idx];
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_TX]
+ [CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_APPS].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_WC_TCAM_TX[sess_idx];
+
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_RX]
+ [CFA_TCAM_MGR_TBL_TYPE_SP_TCAM_AFM].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_SP_TCAM_RX[sess_idx];
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_RX]
+ [CFA_TCAM_MGR_TBL_TYPE_SP_TCAM_APPS].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_SP_TCAM_RX[sess_idx];
+
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_TX]
+ [CFA_TCAM_MGR_TBL_TYPE_SP_TCAM_AFM].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_SP_TCAM_TX[sess_idx];
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_TX]
+ [CFA_TCAM_MGR_TBL_TYPE_SP_TCAM_APPS].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_SP_TCAM_TX[sess_idx];
+
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_RX]
+ [CFA_TCAM_MGR_TBL_TYPE_CT_RULE_TCAM_AFM].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_CT_RULE_TCAM_RX[sess_idx];
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_RX]
+ [CFA_TCAM_MGR_TBL_TYPE_CT_RULE_TCAM_APPS].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_CT_RULE_TCAM_RX[sess_idx];
+
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_TX]
+ [CFA_TCAM_MGR_TBL_TYPE_CT_RULE_TCAM_AFM].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_CT_RULE_TCAM_TX[sess_idx];
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_TX]
+ [CFA_TCAM_MGR_TBL_TYPE_CT_RULE_TCAM_APPS].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_CT_RULE_TCAM_TX[sess_idx];
+
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_RX]
+ [CFA_TCAM_MGR_TBL_TYPE_VEB_TCAM_AFM].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_VEB_TCAM_RX[sess_idx];
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_RX]
+ [CFA_TCAM_MGR_TBL_TYPE_VEB_TCAM_APPS].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_VEB_TCAM_RX[sess_idx];
+
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_TX]
+ [CFA_TCAM_MGR_TBL_TYPE_VEB_TCAM_AFM].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_VEB_TCAM_TX[sess_idx];
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_TX]
+ [CFA_TCAM_MGR_TBL_TYPE_VEB_TCAM_APPS].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_VEB_TCAM_TX[sess_idx];
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_RX]
+ [CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_HIGH_AFM].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_WC_TCAM_RX_HIGH[sess_idx];
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_RX]
+ [CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_HIGH_APPS].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_WC_TCAM_RX_HIGH[sess_idx];
+
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_TX]
+ [CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_HIGH_AFM].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_WC_TCAM_TX_HIGH[sess_idx];
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_TX]
+ [CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_HIGH_APPS].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_WC_TCAM_TX_HIGH[sess_idx];
+
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_RX]
+ [CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_LOW_AFM].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_WC_TCAM_RX_LOW[sess_idx];
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_RX]
+ [CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_LOW_APPS].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_WC_TCAM_RX_LOW[sess_idx];
+
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_TX]
+ [CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_LOW_AFM].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_WC_TCAM_TX_LOW[sess_idx];
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_TX]
+ [CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_LOW_APPS].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_WC_TCAM_TX_LOW[sess_idx];
+
+ for (dir = 0; dir < TF_DIR_MAX; dir++) {
+ for (type = 0; type < CFA_TCAM_MGR_TBL_TYPE_MAX; type++) {
+ if (cfa_tcam_mgr_tables[sess_idx][dir][type].row_width >
+ max_row_width)
+ max_row_width =
+ cfa_tcam_mgr_tables[sess_idx][dir][type].row_width;
+ if (cfa_tcam_mgr_tables[sess_idx][dir][type].result_size >
+ max_result_size)
+ max_result_size =
+ cfa_tcam_mgr_tables[sess_idx][dir][type].result_size;
+ }
+ }
+
+ if (max_row_width != MAX_ROW_WIDTH) {
+ CFA_TCAM_MGR_LOG(ERR,
+ "MAX_ROW_WIDTH (%d) does not match actual "
+ "value (%d).\n",
+ MAX_ROW_WIDTH,
+ max_row_width);
+ return -CFA_TCAM_MGR_ERR_CODE(INVAL);
+ }
+ if (max_result_size != MAX_RESULT_SIZE) {
+ CFA_TCAM_MGR_LOG(ERR,
+ "MAX_RESULT_SIZE (%d) does not match actual "
+ "value (%d).\n",
+ MAX_RESULT_SIZE,
+ max_result_size);
+ return -CFA_TCAM_MGR_ERR_CODE(INVAL);
+ }
+ return 0;
+}
+
+/* HW OP declarations begin here */
+struct cfa_tcam_mgr_TCAM_row_data {
+ int key_size;
+ int result_size;
+ uint8_t key[MAX_ROW_WIDTH];
+ uint8_t mask[MAX_ROW_WIDTH];
+ uint8_t result[MAX_RESULT_SIZE];
+};
+
+/* These macros are only needed to avoid exceeding 80 columns */
+#define L2_CTXT_RX_MAX_ROWS \
+ (L2_CTXT_TCAM_RX_MAX_SLICES * L2_CTXT_TCAM_RX_NUM_ROWS)
+#define PROF_RX_MAX_ROWS (PROF_TCAM_RX_MAX_SLICES * PROF_TCAM_RX_NUM_ROWS)
+#define WC_RX_MAX_ROWS (WC_TCAM_RX_MAX_SLICES * WC_TCAM_RX_NUM_ROWS)
+#define SP_RX_MAX_ROWS (SP_TCAM_RX_MAX_SLICES * SP_TCAM_RX_NUM_ROWS)
+#define CT_RULE_RX_MAX_ROWS \
+ (CT_RULE_TCAM_RX_MAX_SLICES * CT_RULE_TCAM_RX_NUM_ROWS)
+#define VEB_RX_MAX_ROWS (VEB_TCAM_RX_MAX_SLICES * VEB_TCAM_RX_NUM_ROWS)
+
+#define L2_CTXT_TX_MAX_ROWS \
+ (L2_CTXT_TCAM_TX_MAX_SLICES * L2_CTXT_TCAM_TX_NUM_ROWS)
+#define PROF_TX_MAX_ROWS (PROF_TCAM_TX_MAX_SLICES * PROF_TCAM_TX_NUM_ROWS)
+#define WC_TX_MAX_ROWS (WC_TCAM_TX_MAX_SLICES * WC_TCAM_TX_NUM_ROWS)
+#define SP_TX_MAX_ROWS (SP_TCAM_TX_MAX_SLICES * SP_TCAM_TX_NUM_ROWS)
+#define CT_RULE_TX_MAX_ROWS \
+ (CT_RULE_TCAM_TX_MAX_SLICES * CT_RULE_TCAM_TX_NUM_ROWS)
+#define VEB_TX_MAX_ROWS (VEB_TCAM_TX_MAX_SLICES * VEB_TCAM_TX_NUM_ROWS)
+
+static int cfa_tcam_mgr_max_rows[TF_TCAM_TBL_TYPE_MAX] = {
+ L2_CTXT_RX_MAX_ROWS,
+ L2_CTXT_RX_MAX_ROWS,
+ PROF_RX_MAX_ROWS,
+ WC_RX_MAX_ROWS,
+ SP_RX_MAX_ROWS,
+ CT_RULE_RX_MAX_ROWS,
+ VEB_RX_MAX_ROWS,
+ WC_RX_MAX_ROWS,
+ WC_RX_MAX_ROWS
+};
+static struct cfa_tcam_mgr_TCAM_row_data
+ cfa_tcam_mgr_L2_CTXT_TCAM_RX_row_data[TF_TCAM_MAX_SESSIONS][L2_CTXT_RX_MAX_ROWS];
+static struct cfa_tcam_mgr_TCAM_row_data
+ cfa_tcam_mgr_PROF_TCAM_RX_row_data[TF_TCAM_MAX_SESSIONS][PROF_RX_MAX_ROWS];
+static struct cfa_tcam_mgr_TCAM_row_data
+ cfa_tcam_mgr_WC_TCAM_RX_row_data[TF_TCAM_MAX_SESSIONS][WC_RX_MAX_ROWS];
+static struct cfa_tcam_mgr_TCAM_row_data
+ cfa_tcam_mgr_SP_TCAM_RX_row_data[TF_TCAM_MAX_SESSIONS][SP_RX_MAX_ROWS];
+static struct cfa_tcam_mgr_TCAM_row_data
+ cfa_tcam_mgr_CT_RULE_TCAM_RX_row_data[TF_TCAM_MAX_SESSIONS][CT_RULE_RX_MAX_ROWS];
+static struct cfa_tcam_mgr_TCAM_row_data
+ cfa_tcam_mgr_VEB_TCAM_RX_row_data[TF_TCAM_MAX_SESSIONS][VEB_RX_MAX_ROWS];
+static struct cfa_tcam_mgr_TCAM_row_data
+ cfa_tcam_mgr_WC_TCAM_RX_row_data[TF_TCAM_MAX_SESSIONS][WC_RX_MAX_ROWS];
+
+static struct cfa_tcam_mgr_TCAM_row_data
+ cfa_tcam_mgr_L2_CTXT_TCAM_TX_row_data[TF_TCAM_MAX_SESSIONS][L2_CTXT_TX_MAX_ROWS];
+static struct cfa_tcam_mgr_TCAM_row_data
+ cfa_tcam_mgr_PROF_TCAM_TX_row_data[TF_TCAM_MAX_SESSIONS][PROF_TX_MAX_ROWS];
+static struct cfa_tcam_mgr_TCAM_row_data
+ cfa_tcam_mgr_WC_TCAM_TX_row_data[TF_TCAM_MAX_SESSIONS][WC_TX_MAX_ROWS];
+static struct cfa_tcam_mgr_TCAM_row_data
+ cfa_tcam_mgr_SP_TCAM_TX_row_data[TF_TCAM_MAX_SESSIONS][SP_TX_MAX_ROWS];
+static struct cfa_tcam_mgr_TCAM_row_data
+ cfa_tcam_mgr_CT_RULE_TCAM_TX_row_data[TF_TCAM_MAX_SESSIONS][CT_RULE_TX_MAX_ROWS];
+static struct cfa_tcam_mgr_TCAM_row_data
+ cfa_tcam_mgr_VEB_TCAM_TX_row_data[TF_TCAM_MAX_SESSIONS][VEB_TX_MAX_ROWS];
+static struct cfa_tcam_mgr_TCAM_row_data
+ cfa_tcam_mgr_WC_TCAM_TX_row_data[TF_TCAM_MAX_SESSIONS][WC_TX_MAX_ROWS];
+
+static struct cfa_tcam_mgr_TCAM_row_data *
+row_tables[TF_DIR_MAX][TF_TCAM_TBL_TYPE_MAX] = {
+ {
+ cfa_tcam_mgr_L2_CTXT_TCAM_RX_row_data[0],
+ cfa_tcam_mgr_L2_CTXT_TCAM_RX_row_data[0],
+ cfa_tcam_mgr_PROF_TCAM_RX_row_data[0],
+ cfa_tcam_mgr_WC_TCAM_RX_row_data[0],
+ cfa_tcam_mgr_SP_TCAM_RX_row_data[0],
+ cfa_tcam_mgr_CT_RULE_TCAM_RX_row_data[0],
+ cfa_tcam_mgr_VEB_TCAM_RX_row_data[0],
+ cfa_tcam_mgr_WC_TCAM_RX_row_data[0],
+ cfa_tcam_mgr_WC_TCAM_RX_row_data[0],
+ },
+ {
+ cfa_tcam_mgr_L2_CTXT_TCAM_TX_row_data[0],
+ cfa_tcam_mgr_L2_CTXT_TCAM_TX_row_data[0],
+ cfa_tcam_mgr_PROF_TCAM_TX_row_data[0],
+ cfa_tcam_mgr_WC_TCAM_TX_row_data[0],
+ cfa_tcam_mgr_SP_TCAM_TX_row_data[0],
+ cfa_tcam_mgr_CT_RULE_TCAM_TX_row_data[0],
+ cfa_tcam_mgr_VEB_TCAM_TX_row_data[0],
+ cfa_tcam_mgr_WC_TCAM_TX_row_data[0],
+ cfa_tcam_mgr_WC_TCAM_TX_row_data[0],
+ }
+};
+
+static int cfa_tcam_mgr_get_max_rows(enum tf_tcam_tbl_type type)
+{
+ if (type >= TF_TCAM_TBL_TYPE_MAX)
+ assert(0);
+ else
+ return cfa_tcam_mgr_max_rows[type];
+}
+
+static int cfa_tcam_mgr_hwop_set(int sess_idx,
+ struct cfa_tcam_mgr_set_parms *parms, int row,
+ int slice, int max_slices)
+{
+ struct cfa_tcam_mgr_TCAM_row_data *this_table;
+ struct cfa_tcam_mgr_TCAM_row_data *this_row;
+ this_table = row_tables[parms->dir]
+ [cfa_tcam_mgr_get_phys_table_type(parms->type)];
+ this_table += (sess_idx *
+ cfa_tcam_mgr_get_max_rows(cfa_tcam_mgr_get_phys_table_type(parms->type)));
+ this_row = &this_table[row * max_slices + slice];
+ this_row->key_size = parms->key_size;
+ memcpy(&this_row->key, parms->key, parms->key_size);
+ memcpy(&this_row->mask, parms->mask, parms->key_size);
+ this_row->result_size = parms->result_size;
+ if (parms->result != ((void *)0))
+ memcpy(&this_row->result, parms->result, parms->result_size);
+ return 0;
+};
+
+static int cfa_tcam_mgr_hwop_get(int sess_idx,
+ struct cfa_tcam_mgr_get_parms *parms, int row,
+ int slice, int max_slices)
+{
+ struct cfa_tcam_mgr_TCAM_row_data *this_table;
+ struct cfa_tcam_mgr_TCAM_row_data *this_row;
+ this_table = row_tables[parms->dir]
+ [cfa_tcam_mgr_get_phys_table_type(parms->type)];
+ this_table += (sess_idx *
+ cfa_tcam_mgr_get_max_rows(cfa_tcam_mgr_get_phys_table_type(parms->type)));
+ this_row = &this_table[row * max_slices + slice];
+ parms->key_size = this_row->key_size;
+ parms->result_size = this_row->result_size;
+ if (parms->key != ((void *)0))
+ memcpy(parms->key, &this_row->key, parms->key_size);
+ if (parms->mask != ((void *)0))
+ memcpy(parms->mask, &this_row->mask, parms->key_size);
+ if (parms->result != ((void *)0))
+ memcpy(parms->result, &this_row->result, parms->result_size);
+ return 0;
+};
+
+static int cfa_tcam_mgr_hwop_free(int sess_idx,
+ struct cfa_tcam_mgr_free_parms *parms,
+ int row, int slice, int max_slices)
+{
+ struct cfa_tcam_mgr_TCAM_row_data *this_table;
+ struct cfa_tcam_mgr_TCAM_row_data *this_row;
+ this_table = row_tables[parms->dir]
+ [cfa_tcam_mgr_get_phys_table_type(parms->type)];
+ this_table += (sess_idx *
+ cfa_tcam_mgr_get_max_rows(cfa_tcam_mgr_get_phys_table_type(parms->type)));
+ this_row = &this_table[row * max_slices + slice];
+ memset(&this_row->key, 0, sizeof(this_row->key));
+ memset(&this_row->mask, 0, sizeof(this_row->mask));
+ memset(&this_row->result, 0, sizeof(this_row->result));
+ this_row->key_size = 0;
+ this_row->result_size = 0;
+ return 0;
+};
+
+int cfa_tcam_mgr_hwops_get_funcs_p4(struct cfa_tcam_mgr_hwops_funcs *hwop_funcs)
+{
+ hwop_funcs->set = cfa_tcam_mgr_hwop_set;
+ hwop_funcs->get = cfa_tcam_mgr_hwop_get;
+ hwop_funcs->free = cfa_tcam_mgr_hwop_free;
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,20 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2021-2023 Broadcom
+ * All rights reserved.
+ */
+
+#ifndef CFA_TCAM_MGR_P4_H
+#define CFA_TCAM_MGR_P4_H
+
+#include "cfa_tcam_mgr_device.h"
+#include "cfa_tcam_mgr_sbmp.h"
+
+int
+cfa_tcam_mgr_init_p4(int sess_idx, struct cfa_tcam_mgr_entry_data **global_entry_data);
+
+int
+cfa_tcam_mgr_sess_table_get_p4(int sess_idx, struct sbmp **session_bmp);
+
+int
+cfa_tcam_mgr_hwops_get_funcs_p4(struct cfa_tcam_mgr_hwops_funcs *hwop_funcs);
+#endif /* CFA_TCAM_MGR_P4_H */
new file mode 100644
@@ -0,0 +1,926 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2021-2023 Broadcom
+ * All rights reserved.
+ */
+
+#include "hcapi_cfa_defs.h"
+
+#include "cfa_tcam_mgr.h"
+#include "cfa_tcam_mgr_p58.h"
+#include "cfa_tcam_mgr.h"
+#include "cfa_tcam_mgr_device.h"
+#include "cfa_resource_types.h"
+#include "tfp.h"
+#include "assert.h"
+#include "tf_util.h"
+
+/*
+ * Sizings of the TCAMs on P5
+ */
+
+#define MAX_ROW_WIDTH 96
+#define MAX_RESULT_SIZE 8
+
+#if MAX_ROW_WIDTH > CFA_TCAM_MGR_MAX_KEY_SIZE
+#error MAX_ROW_WIDTH > CFA_TCAM_MGR_MAX_KEY_SIZE
+#endif
+
+/*
+ * TCAM definitions
+ *
+ * These define the TCAMs in HW.
+ *
+ * Note: Set xxx_TCAM_[R|T]X_NUM_ROWS to zero if a TCAM is either not supported
+ * by HW or not supported by TCAM Manager.
+ */
+
+/** L2 Context TCAM */
+#define L2_CTXT_TCAM_RX_MAX_SLICES 1
+#define L2_CTXT_TCAM_RX_ROW_WIDTH TF_BITS2BYTES_64B_WORD_ALIGN(214)
+#define L2_CTXT_TCAM_RX_NUM_ROWS 1024
+#define L2_CTXT_TCAM_RX_MAX_ENTRIES (L2_CTXT_TCAM_RX_MAX_SLICES * \
+ L2_CTXT_TCAM_RX_NUM_ROWS)
+#define L2_CTXT_TCAM_RX_RESULT_SIZE 8
+
+#define L2_CTXT_TCAM_TX_MAX_SLICES L2_CTXT_TCAM_RX_MAX_SLICES
+#define L2_CTXT_TCAM_TX_ROW_WIDTH L2_CTXT_TCAM_RX_ROW_WIDTH
+#define L2_CTXT_TCAM_TX_NUM_ROWS L2_CTXT_TCAM_RX_NUM_ROWS
+#define L2_CTXT_TCAM_TX_MAX_ENTRIES L2_CTXT_TCAM_RX_MAX_ENTRIES
+#define L2_CTXT_TCAM_TX_RESULT_SIZE L2_CTXT_TCAM_RX_RESULT_SIZE
+
+/** Profile TCAM */
+#define PROF_TCAM_RX_MAX_SLICES 1
+#define PROF_TCAM_RX_ROW_WIDTH TF_BITS2BYTES_64B_WORD_ALIGN(94)
+#define PROF_TCAM_RX_NUM_ROWS 256
+#define PROF_TCAM_RX_MAX_ENTRIES (PROF_TCAM_RX_MAX_SLICES * \
+ PROF_TCAM_RX_NUM_ROWS)
+#define PROF_TCAM_RX_RESULT_SIZE 8
+
+#define PROF_TCAM_TX_MAX_SLICES PROF_TCAM_RX_MAX_SLICES
+#define PROF_TCAM_TX_ROW_WIDTH PROF_TCAM_RX_ROW_WIDTH
+#define PROF_TCAM_TX_NUM_ROWS PROF_TCAM_RX_NUM_ROWS
+#define PROF_TCAM_TX_MAX_ENTRIES PROF_TCAM_RX_MAX_ENTRIES
+#define PROF_TCAM_TX_RESULT_SIZE PROF_TCAM_RX_RESULT_SIZE
+
+/** Wildcard TCAM */
+#define WC_TCAM_RX_MAX_SLICES 4
+/* 162 bits per slice */
+#define WC_TCAM_RX_ROW_WIDTH (TF_BITS2BYTES_64B_WORD_ALIGN(162) * \
+ WC_TCAM_RX_MAX_SLICES)
+#define WC_TCAM_RX_NUM_ROWS 2048
+#define WC_TCAM_RX_MAX_ENTRIES (WC_TCAM_RX_MAX_SLICES * WC_TCAM_RX_NUM_ROWS)
+#define WC_TCAM_RX_RESULT_SIZE 8
+
+#define WC_TCAM_TX_MAX_SLICES WC_TCAM_RX_MAX_SLICES
+#define WC_TCAM_TX_ROW_WIDTH WC_TCAM_RX_ROW_WIDTH
+#define WC_TCAM_TX_NUM_ROWS WC_TCAM_RX_NUM_ROWS
+#define WC_TCAM_TX_MAX_ENTRIES WC_TCAM_RX_MAX_ENTRIES
+#define WC_TCAM_TX_RESULT_SIZE WC_TCAM_RX_RESULT_SIZE
+
+/** Source Properties TCAM */
+#define SP_TCAM_RX_MAX_SLICES 1
+#define SP_TCAM_RX_ROW_WIDTH TF_BITS2BYTES_64B_WORD_ALIGN(89)
+#define SP_TCAM_RX_NUM_ROWS 0
+#define SP_TCAM_RX_MAX_ENTRIES (SP_TCAM_RX_MAX_SLICES * SP_TCAM_RX_NUM_ROWS)
+#define SP_TCAM_RX_RESULT_SIZE 8
+
+#define SP_TCAM_TX_MAX_SLICES SP_TCAM_RX_MAX_SLICES
+#define SP_TCAM_TX_ROW_WIDTH SP_TCAM_RX_ROW_WIDTH
+#define SP_TCAM_TX_NUM_ROWS SP_TCAM_RX_NUM_ROWS
+#define SP_TCAM_TX_MAX_ENTRIES SP_TCAM_RX_MAX_ENTRIES
+#define SP_TCAM_TX_RESULT_SIZE SP_TCAM_RX_RESULT_SIZE
+
+/** Connection Tracking Rule TCAM */
+#define CT_RULE_TCAM_RX_MAX_SLICES 1
+#define CT_RULE_TCAM_RX_ROW_WIDTH TF_BITS2BYTES_64B_WORD_ALIGN(16)
+#define CT_RULE_TCAM_RX_NUM_ROWS 0
+#define CT_RULE_TCAM_RX_MAX_ENTRIES (CT_RULE_TCAM_RX_MAX_SLICES * \
+ CT_RULE_TCAM_RX_NUM_ROWS)
+#define CT_RULE_TCAM_RX_RESULT_SIZE 8
+
+#define CT_RULE_TCAM_TX_MAX_SLICES CT_RULE_TCAM_RX_MAX_SLICES
+#define CT_RULE_TCAM_TX_ROW_WIDTH CT_RULE_TCAM_RX_ROW_WIDTH
+#define CT_RULE_TCAM_TX_NUM_ROWS CT_RULE_TCAM_RX_NUM_ROWS
+#define CT_RULE_TCAM_TX_MAX_ENTRIES CT_RULE_TCAM_RX_MAX_ENTRIES
+#define CT_RULE_TCAM_TX_RESULT_SIZE CT_RULE_TCAM_RX_RESULT_SIZE
+
+/** Virtual Edge Bridge TCAM */
+#define VEB_TCAM_RX_MAX_SLICES 1
+#define VEB_TCAM_RX_ROW_WIDTH TF_BITS2BYTES_WORD_ALIGN(79)
+/* Tx only */
+#define VEB_TCAM_RX_NUM_ROWS 0
+#define VEB_TCAM_RX_MAX_ENTRIES (VEB_TCAM_RX_MAX_SLICES * VEB_TCAM_RX_NUM_ROWS)
+#define VEB_TCAM_RX_RESULT_SIZE 8
+
+#define VEB_TCAM_TX_MAX_SLICES VEB_TCAM_RX_MAX_SLICES
+#define VEB_TCAM_TX_ROW_WIDTH VEB_TCAM_RX_ROW_WIDTH
+#define VEB_TCAM_TX_NUM_ROWS 1024
+#define VEB_TCAM_TX_MAX_ENTRIES (VEB_TCAM_TX_MAX_SLICES * VEB_TCAM_TX_NUM_ROWS)
+#define VEB_TCAM_TX_RESULT_SIZE VEB_TCAM_RX_RESULT_SIZE
+
+/* Declare the table rows for each table here. If new tables are added to the
+ * enum tf_tcam_tbl_type, then new declarations will be needed here.
+ *
+ * The numeric suffix of the structure type indicates how many slices a
+ * particular TCAM supports.
+ *
+ * Array sizes have 1 added to avoid zero length arrays.
+ */
+
+static struct cfa_tcam_mgr_table_rows_1
+ cfa_tcam_mgr_table_rows_L2_CTXT_TCAM_RX[TF_TCAM_MAX_SESSIONS][L2_CTXT_TCAM_RX_NUM_ROWS + 1];
+static struct cfa_tcam_mgr_table_rows_1
+ cfa_tcam_mgr_table_rows_L2_CTXT_TCAM_TX[TF_TCAM_MAX_SESSIONS][L2_CTXT_TCAM_TX_NUM_ROWS + 1];
+static struct cfa_tcam_mgr_table_rows_1
+ cfa_tcam_mgr_table_rows_PROF_TCAM_RX[TF_TCAM_MAX_SESSIONS][PROF_TCAM_RX_NUM_ROWS + 1];
+static struct cfa_tcam_mgr_table_rows_1
+ cfa_tcam_mgr_table_rows_PROF_TCAM_TX[TF_TCAM_MAX_SESSIONS][PROF_TCAM_TX_NUM_ROWS + 1];
+static struct cfa_tcam_mgr_table_rows_4
+ cfa_tcam_mgr_table_rows_WC_TCAM_RX[TF_TCAM_MAX_SESSIONS][WC_TCAM_RX_NUM_ROWS + 1];
+static struct cfa_tcam_mgr_table_rows_4
+ cfa_tcam_mgr_table_rows_WC_TCAM_TX[TF_TCAM_MAX_SESSIONS][WC_TCAM_TX_NUM_ROWS + 1];
+static struct cfa_tcam_mgr_table_rows_1
+ cfa_tcam_mgr_table_rows_SP_TCAM_RX[TF_TCAM_MAX_SESSIONS][SP_TCAM_RX_NUM_ROWS + 1];
+static struct cfa_tcam_mgr_table_rows_1
+ cfa_tcam_mgr_table_rows_SP_TCAM_TX[TF_TCAM_MAX_SESSIONS][SP_TCAM_TX_NUM_ROWS + 1];
+static struct cfa_tcam_mgr_table_rows_1
+ cfa_tcam_mgr_table_rows_CT_RULE_TCAM_RX[TF_TCAM_MAX_SESSIONS][CT_RULE_TCAM_RX_NUM_ROWS + 1];
+static struct cfa_tcam_mgr_table_rows_1
+ cfa_tcam_mgr_table_rows_CT_RULE_TCAM_TX[TF_TCAM_MAX_SESSIONS][CT_RULE_TCAM_TX_NUM_ROWS + 1];
+static struct cfa_tcam_mgr_table_rows_1
+ cfa_tcam_mgr_table_rows_VEB_TCAM_RX[TF_TCAM_MAX_SESSIONS][VEB_TCAM_RX_NUM_ROWS + 1];
+static struct cfa_tcam_mgr_table_rows_1
+ cfa_tcam_mgr_table_rows_VEB_TCAM_TX[TF_TCAM_MAX_SESSIONS][VEB_TCAM_TX_NUM_ROWS + 1];
+static struct cfa_tcam_mgr_table_rows_4
+ cfa_tcam_mgr_table_rows_WC_TCAM_RX_HIGH[TF_TCAM_MAX_SESSIONS][WC_TCAM_RX_NUM_ROWS + 1];
+static struct cfa_tcam_mgr_table_rows_4
+ cfa_tcam_mgr_table_rows_WC_TCAM_RX_LOW[TF_TCAM_MAX_SESSIONS][WC_TCAM_RX_NUM_ROWS + 1];
+static struct cfa_tcam_mgr_table_rows_4
+ cfa_tcam_mgr_table_rows_WC_TCAM_TX_HIGH[TF_TCAM_MAX_SESSIONS][WC_TCAM_TX_NUM_ROWS + 1];
+static struct cfa_tcam_mgr_table_rows_4
+ cfa_tcam_mgr_table_rows_WC_TCAM_TX_LOW[TF_TCAM_MAX_SESSIONS][WC_TCAM_TX_NUM_ROWS + 1];
+
+struct cfa_tcam_mgr_table_data
+cfa_tcam_mgr_tables_p58[TF_DIR_MAX][CFA_TCAM_MGR_TBL_TYPE_MAX] = {
+ { /* RX */
+ { /* High AFM */
+ .max_slices = L2_CTXT_TCAM_RX_MAX_SLICES,
+ .row_width = L2_CTXT_TCAM_RX_ROW_WIDTH,
+ .num_rows = 0,
+ .start_row = 0,
+ .end_row = 0,
+ .max_entries = 0,
+ .result_size = L2_CTXT_TCAM_RX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P58_L2_CTXT_TCAM_HIGH,
+ },
+ { /* High APPS */
+ .max_slices = L2_CTXT_TCAM_RX_MAX_SLICES,
+ .row_width = L2_CTXT_TCAM_RX_ROW_WIDTH,
+ .num_rows = L2_CTXT_TCAM_RX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = (L2_CTXT_TCAM_RX_NUM_ROWS / 2) - 1,
+ .max_entries = (L2_CTXT_TCAM_RX_MAX_ENTRIES / 2),
+ .result_size = L2_CTXT_TCAM_RX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P58_L2_CTXT_TCAM_HIGH,
+ },
+ { /* Low AFM */
+ .max_slices = L2_CTXT_TCAM_RX_MAX_SLICES,
+ .row_width = L2_CTXT_TCAM_RX_ROW_WIDTH,
+ .num_rows = 0,
+ .start_row = 0,
+ .end_row = 0,
+ .max_entries = 0,
+ .result_size = L2_CTXT_TCAM_RX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P58_L2_CTXT_TCAM_LOW,
+ },
+ { /* Low APPS */
+ .max_slices = L2_CTXT_TCAM_RX_MAX_SLICES,
+ .row_width = L2_CTXT_TCAM_RX_ROW_WIDTH,
+ .num_rows = L2_CTXT_TCAM_RX_NUM_ROWS,
+ .start_row = (L2_CTXT_TCAM_RX_NUM_ROWS / 2),
+ .end_row = L2_CTXT_TCAM_RX_NUM_ROWS - 1,
+ .max_entries = (L2_CTXT_TCAM_RX_MAX_ENTRIES / 2),
+ .result_size = L2_CTXT_TCAM_RX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P58_L2_CTXT_TCAM_LOW,
+ },
+ { /* AFM */
+ .max_slices = PROF_TCAM_RX_MAX_SLICES,
+ .row_width = PROF_TCAM_RX_ROW_WIDTH,
+ .num_rows = 0,
+ .start_row = 0,
+ .end_row = 0,
+ .max_entries = 0,
+ .result_size = PROF_TCAM_RX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P58_PROF_TCAM,
+ },
+ { /* APPS */
+ .max_slices = PROF_TCAM_RX_MAX_SLICES,
+ .row_width = PROF_TCAM_RX_ROW_WIDTH,
+ .num_rows = PROF_TCAM_RX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = PROF_TCAM_RX_NUM_ROWS - 1,
+ .max_entries = PROF_TCAM_RX_MAX_ENTRIES,
+ .result_size = PROF_TCAM_RX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P58_PROF_TCAM,
+ },
+ { /* AFM */
+ .max_slices = WC_TCAM_RX_MAX_SLICES,
+ .row_width = WC_TCAM_RX_ROW_WIDTH,
+ .num_rows = WC_TCAM_RX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = 0,
+ .max_entries = 0,
+ .result_size = WC_TCAM_RX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P58_WC_TCAM,
+ },
+ { /* APPS */
+ .max_slices = WC_TCAM_RX_MAX_SLICES,
+ .row_width = WC_TCAM_RX_ROW_WIDTH,
+ .num_rows = WC_TCAM_RX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = WC_TCAM_RX_NUM_ROWS - 1,
+ .max_entries = WC_TCAM_RX_MAX_ENTRIES,
+ .result_size = WC_TCAM_RX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P58_WC_TCAM,
+ },
+ { /* AFM */
+ .max_slices = SP_TCAM_RX_MAX_SLICES,
+ .row_width = SP_TCAM_RX_ROW_WIDTH,
+ .num_rows = 0,
+ .start_row = 0,
+ .end_row = 0,
+ .max_entries = 0,
+ .result_size = SP_TCAM_RX_RESULT_SIZE,
+ },
+ { /* APPS */
+ .max_slices = SP_TCAM_RX_MAX_SLICES,
+ .row_width = SP_TCAM_RX_ROW_WIDTH,
+ .num_rows = SP_TCAM_RX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = SP_TCAM_RX_NUM_ROWS - 1,
+ .max_entries = SP_TCAM_RX_MAX_ENTRIES,
+ .result_size = SP_TCAM_RX_RESULT_SIZE,
+ },
+ { /* AFM */
+ .max_slices = CT_RULE_TCAM_RX_MAX_SLICES,
+ .row_width = CT_RULE_TCAM_RX_ROW_WIDTH,
+ .num_rows = CT_RULE_TCAM_RX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = 0,
+ .max_entries = 0,
+ .result_size = CT_RULE_TCAM_RX_RESULT_SIZE,
+ },
+ { /* APPS */
+ .max_slices = CT_RULE_TCAM_RX_MAX_SLICES,
+ .row_width = CT_RULE_TCAM_RX_ROW_WIDTH,
+ .num_rows = CT_RULE_TCAM_RX_NUM_ROWS,
+ .start_row = 0,
+#if CT_RULE_TCAM_RX_NUM_ROWS > 0
+ .end_row = CT_RULE_TCAM_RX_NUM_ROWS - 1,
+#else
+ .end_row = CT_RULE_TCAM_RX_NUM_ROWS,
+#endif
+ .max_entries = CT_RULE_TCAM_RX_MAX_ENTRIES,
+ .result_size = CT_RULE_TCAM_RX_RESULT_SIZE,
+ },
+ { /* AFM */
+ .max_slices = VEB_TCAM_RX_MAX_SLICES,
+ .row_width = VEB_TCAM_RX_ROW_WIDTH,
+ .num_rows = VEB_TCAM_RX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = 0,
+ .max_entries = 0,
+ .result_size = VEB_TCAM_RX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P58_VEB_TCAM,
+ },
+ { /* APPS */
+ .max_slices = VEB_TCAM_RX_MAX_SLICES,
+ .row_width = VEB_TCAM_RX_ROW_WIDTH,
+ .num_rows = VEB_TCAM_RX_NUM_ROWS,
+ .start_row = 0,
+#if VEB_TCAM_RX_NUM_ROWS > 0
+ .end_row = VEB_TCAM_RX_NUM_ROWS - 1,
+#else
+ .end_row = VEB_TCAM_RX_NUM_ROWS,
+#endif
+ .max_entries = VEB_TCAM_RX_MAX_ENTRIES,
+ .result_size = VEB_TCAM_RX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P58_VEB_TCAM,
+ },
+ { /* AFM */
+ .max_slices = WC_TCAM_RX_MAX_SLICES,
+ .row_width = WC_TCAM_RX_ROW_WIDTH,
+ .num_rows = WC_TCAM_RX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = 0,
+ .max_entries = 0,
+ .result_size = WC_TCAM_RX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P58_WC_TCAM,
+ },
+ { /* APPS */
+ .max_slices = WC_TCAM_RX_MAX_SLICES,
+ .row_width = WC_TCAM_RX_ROW_WIDTH,
+ .num_rows = WC_TCAM_RX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = WC_TCAM_RX_NUM_ROWS - 1,
+ .max_entries = WC_TCAM_RX_MAX_ENTRIES,
+ .result_size = WC_TCAM_RX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P58_WC_TCAM,
+ },
+ { /* AFM */
+ .max_slices = WC_TCAM_RX_MAX_SLICES,
+ .row_width = WC_TCAM_RX_ROW_WIDTH,
+ .num_rows = WC_TCAM_RX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = 0,
+ .max_entries = 0,
+ .result_size = WC_TCAM_RX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P58_WC_TCAM,
+ },
+ { /* APPS */
+ .max_slices = WC_TCAM_RX_MAX_SLICES,
+ .row_width = WC_TCAM_RX_ROW_WIDTH,
+ .num_rows = WC_TCAM_RX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = WC_TCAM_RX_NUM_ROWS - 1,
+ .max_entries = WC_TCAM_RX_MAX_ENTRIES,
+ .result_size = WC_TCAM_RX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P58_WC_TCAM,
+ },
+ },
+ { /* TX */
+ { /* AFM */
+ .max_slices = L2_CTXT_TCAM_TX_MAX_SLICES,
+ .row_width = L2_CTXT_TCAM_TX_ROW_WIDTH,
+ .num_rows = L2_CTXT_TCAM_TX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = 0,
+ .max_entries = 0,
+ .result_size = L2_CTXT_TCAM_TX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P58_L2_CTXT_TCAM_HIGH,
+ },
+ { /* APPS */
+ .max_slices = L2_CTXT_TCAM_TX_MAX_SLICES,
+ .row_width = L2_CTXT_TCAM_TX_ROW_WIDTH,
+ .num_rows = L2_CTXT_TCAM_TX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = (L2_CTXT_TCAM_TX_NUM_ROWS / 2) - 1,
+ .max_entries = (L2_CTXT_TCAM_TX_MAX_ENTRIES / 2),
+ .result_size = L2_CTXT_TCAM_TX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P58_L2_CTXT_TCAM_HIGH,
+ },
+ { /* AFM */
+ .max_slices = L2_CTXT_TCAM_TX_MAX_SLICES,
+ .row_width = L2_CTXT_TCAM_TX_ROW_WIDTH,
+ .num_rows = L2_CTXT_TCAM_TX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = 0,
+ .max_entries = 0,
+ .result_size = L2_CTXT_TCAM_TX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P58_L2_CTXT_TCAM_LOW,
+ },
+ { /* APPS */
+ .max_slices = L2_CTXT_TCAM_TX_MAX_SLICES,
+ .row_width = L2_CTXT_TCAM_TX_ROW_WIDTH,
+ .num_rows = L2_CTXT_TCAM_TX_NUM_ROWS,
+ .start_row = (L2_CTXT_TCAM_TX_NUM_ROWS / 2),
+ .end_row = L2_CTXT_TCAM_TX_NUM_ROWS - 1,
+ .max_entries = (L2_CTXT_TCAM_TX_MAX_ENTRIES / 2),
+ .result_size = L2_CTXT_TCAM_TX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P58_L2_CTXT_TCAM_LOW,
+ },
+ { /* AFM */
+ .max_slices = PROF_TCAM_TX_MAX_SLICES,
+ .row_width = PROF_TCAM_TX_ROW_WIDTH,
+ .num_rows = PROF_TCAM_TX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = 0,
+ .max_entries = 0,
+ .result_size = PROF_TCAM_TX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P58_PROF_TCAM,
+ },
+ { /* APPS */
+ .max_slices = PROF_TCAM_TX_MAX_SLICES,
+ .row_width = PROF_TCAM_TX_ROW_WIDTH,
+ .num_rows = PROF_TCAM_TX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = PROF_TCAM_TX_NUM_ROWS - 1,
+ .max_entries = PROF_TCAM_TX_MAX_ENTRIES,
+ .result_size = PROF_TCAM_TX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P58_PROF_TCAM,
+ },
+ { /* AFM */
+ .max_slices = WC_TCAM_TX_MAX_SLICES,
+ .row_width = WC_TCAM_TX_ROW_WIDTH,
+ .num_rows = WC_TCAM_TX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = 0,
+ .max_entries = 0,
+ .result_size = WC_TCAM_TX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P58_WC_TCAM,
+ },
+ { /* APPS */
+ .max_slices = WC_TCAM_TX_MAX_SLICES,
+ .row_width = WC_TCAM_TX_ROW_WIDTH,
+ .num_rows = WC_TCAM_TX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = WC_TCAM_TX_NUM_ROWS - 1,
+ .max_entries = WC_TCAM_TX_MAX_ENTRIES,
+ .result_size = WC_TCAM_TX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P58_WC_TCAM,
+ },
+ { /* AFM */
+ .max_slices = SP_TCAM_TX_MAX_SLICES,
+ .row_width = SP_TCAM_TX_ROW_WIDTH,
+ .num_rows = SP_TCAM_TX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = 0,
+ .max_entries = 0,
+ .result_size = SP_TCAM_TX_RESULT_SIZE,
+ },
+ { /* APPS */
+ .max_slices = SP_TCAM_TX_MAX_SLICES,
+ .row_width = SP_TCAM_TX_ROW_WIDTH,
+ .num_rows = SP_TCAM_TX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = SP_TCAM_TX_NUM_ROWS - 1,
+ .max_entries = SP_TCAM_TX_MAX_ENTRIES,
+ .result_size = SP_TCAM_TX_RESULT_SIZE,
+ },
+ { /* AFM */
+ .max_slices = CT_RULE_TCAM_TX_MAX_SLICES,
+ .row_width = CT_RULE_TCAM_TX_ROW_WIDTH,
+ .num_rows = CT_RULE_TCAM_TX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = 0,
+ .max_entries = 0,
+ .result_size = CT_RULE_TCAM_RX_RESULT_SIZE,
+ },
+ { /* APPS */
+ .max_slices = CT_RULE_TCAM_TX_MAX_SLICES,
+ .row_width = CT_RULE_TCAM_TX_ROW_WIDTH,
+ .num_rows = CT_RULE_TCAM_TX_NUM_ROWS,
+ .start_row = 0,
+#if CT_RULE_TCAM_TX_NUM_ROWS > 0
+ .end_row = CT_RULE_TCAM_TX_NUM_ROWS - 1,
+#else
+ .end_row = CT_RULE_TCAM_TX_NUM_ROWS,
+#endif
+ .max_entries = CT_RULE_TCAM_TX_MAX_ENTRIES,
+ .result_size = CT_RULE_TCAM_RX_RESULT_SIZE,
+ },
+ { /* AFM */
+ .max_slices = VEB_TCAM_TX_MAX_SLICES,
+ .row_width = VEB_TCAM_TX_ROW_WIDTH,
+ .num_rows = VEB_TCAM_TX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = 0,
+ .max_entries = 0,
+ .result_size = VEB_TCAM_RX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P58_VEB_TCAM,
+ },
+ { /* APPS */
+ .max_slices = VEB_TCAM_TX_MAX_SLICES,
+ .row_width = VEB_TCAM_TX_ROW_WIDTH,
+ .num_rows = VEB_TCAM_TX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = VEB_TCAM_TX_NUM_ROWS - 1,
+ .max_entries = VEB_TCAM_TX_MAX_ENTRIES,
+ .result_size = VEB_TCAM_RX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P58_VEB_TCAM,
+ },
+ { /* AFM */
+ .max_slices = WC_TCAM_TX_MAX_SLICES,
+ .row_width = WC_TCAM_TX_ROW_WIDTH,
+ .num_rows = WC_TCAM_TX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = 0,
+ .max_entries = 0,
+ .result_size = WC_TCAM_TX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P58_WC_TCAM,
+ },
+ { /* APPS */
+ .max_slices = WC_TCAM_TX_MAX_SLICES,
+ .row_width = WC_TCAM_TX_ROW_WIDTH,
+ .num_rows = WC_TCAM_TX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = WC_TCAM_TX_NUM_ROWS - 1,
+ .max_entries = WC_TCAM_TX_MAX_ENTRIES,
+ .result_size = WC_TCAM_TX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P58_WC_TCAM,
+ },
+ { /* AFM */
+ .max_slices = WC_TCAM_TX_MAX_SLICES,
+ .row_width = WC_TCAM_TX_ROW_WIDTH,
+ .num_rows = WC_TCAM_TX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = 0,
+ .max_entries = 0,
+ .result_size = WC_TCAM_TX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P58_WC_TCAM,
+ },
+ { /* APPS */
+ .max_slices = WC_TCAM_TX_MAX_SLICES,
+ .row_width = WC_TCAM_TX_ROW_WIDTH,
+ .num_rows = WC_TCAM_TX_NUM_ROWS,
+ .start_row = 0,
+ .end_row = WC_TCAM_TX_NUM_ROWS - 1,
+ .max_entries = WC_TCAM_TX_MAX_ENTRIES,
+ .result_size = WC_TCAM_TX_RESULT_SIZE,
+ .hcapi_type = CFA_RESOURCE_TYPE_P58_WC_TCAM,
+ },
+ },
+};
+
+static struct cfa_tcam_mgr_entry_data entry_data_p58[TF_TCAM_MAX_SESSIONS][TF_TCAM_MAX_ENTRIES];
+
+static struct sbmp session_bmp_p58[TF_TCAM_MAX_SESSIONS][TF_TCAM_MAX_ENTRIES];
+
+int
+cfa_tcam_mgr_sess_table_get_p58(int sess_idx, struct sbmp **session_bmp)
+{
+ *session_bmp = session_bmp_p58[sess_idx];
+ return 0;
+}
+
+int
+cfa_tcam_mgr_init_p58(int sess_idx, struct cfa_tcam_mgr_entry_data **global_entry_data)
+{
+ int max_row_width = 0;
+ int max_result_size = 0;
+ int dir, type;
+
+ *global_entry_data = entry_data_p58[sess_idx];
+
+ memcpy(&cfa_tcam_mgr_tables[sess_idx],
+ &cfa_tcam_mgr_tables_p58,
+ sizeof(cfa_tcam_mgr_tables[sess_idx]));
+
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_RX]
+ [CFA_TCAM_MGR_TBL_TYPE_L2_CTXT_TCAM_HIGH_AFM].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_L2_CTXT_TCAM_RX[sess_idx];
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_RX]
+ [CFA_TCAM_MGR_TBL_TYPE_L2_CTXT_TCAM_HIGH_APPS].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_L2_CTXT_TCAM_RX[sess_idx];
+
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_TX]
+ [CFA_TCAM_MGR_TBL_TYPE_L2_CTXT_TCAM_HIGH_AFM].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_L2_CTXT_TCAM_TX[sess_idx];
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_TX]
+ [CFA_TCAM_MGR_TBL_TYPE_L2_CTXT_TCAM_HIGH_APPS].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_L2_CTXT_TCAM_TX[sess_idx];
+
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_RX]
+ [CFA_TCAM_MGR_TBL_TYPE_L2_CTXT_TCAM_LOW_AFM].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_L2_CTXT_TCAM_RX[sess_idx];
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_RX]
+ [CFA_TCAM_MGR_TBL_TYPE_L2_CTXT_TCAM_LOW_APPS].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_L2_CTXT_TCAM_RX[sess_idx];
+
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_TX]
+ [CFA_TCAM_MGR_TBL_TYPE_L2_CTXT_TCAM_LOW_AFM].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_L2_CTXT_TCAM_TX[sess_idx];
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_TX]
+ [CFA_TCAM_MGR_TBL_TYPE_L2_CTXT_TCAM_LOW_APPS].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_L2_CTXT_TCAM_TX[sess_idx];
+
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_RX]
+ [CFA_TCAM_MGR_TBL_TYPE_PROF_TCAM_AFM].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_PROF_TCAM_RX[sess_idx];
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_RX]
+ [CFA_TCAM_MGR_TBL_TYPE_PROF_TCAM_APPS].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_PROF_TCAM_RX[sess_idx];
+
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_TX]
+ [CFA_TCAM_MGR_TBL_TYPE_PROF_TCAM_AFM].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_PROF_TCAM_TX[sess_idx];
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_TX]
+ [CFA_TCAM_MGR_TBL_TYPE_PROF_TCAM_APPS].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_PROF_TCAM_TX[sess_idx];
+
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_RX]
+ [CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_AFM].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_WC_TCAM_RX[sess_idx];
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_RX]
+ [CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_APPS].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_WC_TCAM_RX[sess_idx];
+
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_TX]
+ [CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_AFM].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_WC_TCAM_TX[sess_idx];
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_TX]
+ [CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_APPS].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_WC_TCAM_TX[sess_idx];
+
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_RX]
+ [CFA_TCAM_MGR_TBL_TYPE_SP_TCAM_AFM].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_SP_TCAM_RX[sess_idx];
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_RX]
+ [CFA_TCAM_MGR_TBL_TYPE_SP_TCAM_APPS].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_SP_TCAM_RX[sess_idx];
+
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_TX]
+ [CFA_TCAM_MGR_TBL_TYPE_SP_TCAM_AFM].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_SP_TCAM_TX[sess_idx];
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_TX]
+ [CFA_TCAM_MGR_TBL_TYPE_SP_TCAM_APPS].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_SP_TCAM_TX[sess_idx];
+
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_RX]
+ [CFA_TCAM_MGR_TBL_TYPE_CT_RULE_TCAM_AFM].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_CT_RULE_TCAM_RX[sess_idx];
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_RX]
+ [CFA_TCAM_MGR_TBL_TYPE_CT_RULE_TCAM_APPS].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_CT_RULE_TCAM_RX[sess_idx];
+
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_TX]
+ [CFA_TCAM_MGR_TBL_TYPE_CT_RULE_TCAM_AFM].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_CT_RULE_TCAM_TX[sess_idx];
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_TX]
+ [CFA_TCAM_MGR_TBL_TYPE_CT_RULE_TCAM_APPS].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_CT_RULE_TCAM_TX[sess_idx];
+
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_RX]
+ [CFA_TCAM_MGR_TBL_TYPE_VEB_TCAM_AFM].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_VEB_TCAM_RX[sess_idx];
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_RX]
+ [CFA_TCAM_MGR_TBL_TYPE_VEB_TCAM_APPS].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_VEB_TCAM_RX[sess_idx];
+
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_TX]
+ [CFA_TCAM_MGR_TBL_TYPE_VEB_TCAM_AFM].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_VEB_TCAM_TX[sess_idx];
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_TX]
+ [CFA_TCAM_MGR_TBL_TYPE_VEB_TCAM_APPS].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_VEB_TCAM_TX[sess_idx];
+
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_RX]
+ [CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_HIGH_AFM].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_WC_TCAM_RX_HIGH[sess_idx];
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_RX]
+ [CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_HIGH_APPS].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_WC_TCAM_RX_HIGH[sess_idx];
+
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_TX]
+ [CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_HIGH_AFM].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_WC_TCAM_TX_HIGH[sess_idx];
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_TX]
+ [CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_HIGH_APPS].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_WC_TCAM_TX_HIGH[sess_idx];
+
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_RX]
+ [CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_LOW_AFM].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_WC_TCAM_RX_LOW[sess_idx];
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_RX]
+ [CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_LOW_APPS].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_WC_TCAM_RX_LOW[sess_idx];
+
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_TX]
+ [CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_LOW_AFM].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_WC_TCAM_TX_LOW[sess_idx];
+ cfa_tcam_mgr_tables[sess_idx][TF_DIR_TX]
+ [CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_LOW_APPS].tcam_rows =
+ (struct cfa_tcam_mgr_table_rows_0 *)
+ &cfa_tcam_mgr_table_rows_WC_TCAM_TX_LOW[sess_idx];
+
+ for (dir = 0; dir < TF_DIR_MAX; dir++) {
+ for (type = 0; type < CFA_TCAM_MGR_TBL_TYPE_MAX; type++) {
+ if (cfa_tcam_mgr_tables[sess_idx][dir][type].row_width >
+ max_row_width)
+ max_row_width =
+ cfa_tcam_mgr_tables[sess_idx][dir][type].row_width;
+ if (cfa_tcam_mgr_tables[sess_idx][dir][type].result_size >
+ max_result_size)
+ max_result_size =
+ cfa_tcam_mgr_tables[sess_idx][dir][type].result_size;
+ }
+ }
+
+ if (max_row_width != MAX_ROW_WIDTH) {
+ CFA_TCAM_MGR_LOG(ERR,
+ "MAX_ROW_WIDTH (%d) does not match actual "
+ "value (%d).\n",
+ MAX_ROW_WIDTH,
+ max_row_width);
+ return -CFA_TCAM_MGR_ERR_CODE(INVAL);
+ }
+ if (max_result_size != MAX_RESULT_SIZE) {
+ CFA_TCAM_MGR_LOG(ERR,
+ "MAX_RESULT_SIZE (%d) does not match actual "
+ "value (%d).\n",
+ MAX_RESULT_SIZE,
+ max_result_size);
+ return -CFA_TCAM_MGR_ERR_CODE(INVAL);
+ }
+ return 0;
+}
+
+/* HW OP declarations begin here */
+
+struct cfa_tcam_mgr_TCAM_row_data {
+ int key_size;
+ int result_size;
+ uint8_t key[MAX_ROW_WIDTH];
+ uint8_t mask[MAX_ROW_WIDTH];
+ uint8_t result[MAX_RESULT_SIZE];
+};
+
+/* These macros are only needed to avoid exceeding 80 columns */
+#define L2_CTXT_RX_MAX_ROWS \
+ (L2_CTXT_TCAM_RX_MAX_SLICES * L2_CTXT_TCAM_RX_NUM_ROWS)
+#define PROF_RX_MAX_ROWS (PROF_TCAM_RX_MAX_SLICES * PROF_TCAM_RX_NUM_ROWS)
+#define WC_RX_MAX_ROWS (WC_TCAM_RX_MAX_SLICES * WC_TCAM_RX_NUM_ROWS)
+#define SP_RX_MAX_ROWS (SP_TCAM_RX_MAX_SLICES * SP_TCAM_RX_NUM_ROWS)
+#define CT_RULE_RX_MAX_ROWS \
+ (CT_RULE_TCAM_RX_MAX_SLICES * CT_RULE_TCAM_RX_NUM_ROWS)
+#define VEB_RX_MAX_ROWS (VEB_TCAM_RX_MAX_SLICES * VEB_TCAM_RX_NUM_ROWS)
+
+#define L2_CTXT_TX_MAX_ROWS \
+ (L2_CTXT_TCAM_TX_MAX_SLICES * L2_CTXT_TCAM_TX_NUM_ROWS)
+#define PROF_TX_MAX_ROWS (PROF_TCAM_TX_MAX_SLICES * PROF_TCAM_TX_NUM_ROWS)
+#define WC_TX_MAX_ROWS (WC_TCAM_TX_MAX_SLICES * WC_TCAM_TX_NUM_ROWS)
+#define SP_TX_MAX_ROWS (SP_TCAM_TX_MAX_SLICES * SP_TCAM_TX_NUM_ROWS)
+#define CT_RULE_TX_MAX_ROWS \
+ (CT_RULE_TCAM_TX_MAX_SLICES * CT_RULE_TCAM_TX_NUM_ROWS)
+#define VEB_TX_MAX_ROWS (VEB_TCAM_TX_MAX_SLICES * VEB_TCAM_TX_NUM_ROWS)
+
+static int cfa_tcam_mgr_max_rows[TF_TCAM_TBL_TYPE_MAX] = {
+ L2_CTXT_RX_MAX_ROWS,
+ L2_CTXT_RX_MAX_ROWS,
+ PROF_RX_MAX_ROWS,
+ WC_RX_MAX_ROWS,
+ SP_RX_MAX_ROWS,
+ CT_RULE_RX_MAX_ROWS,
+ VEB_RX_MAX_ROWS,
+ WC_RX_MAX_ROWS,
+ WC_RX_MAX_ROWS
+};
+
+static struct cfa_tcam_mgr_TCAM_row_data
+ cfa_tcam_mgr_L2_CTXT_TCAM_RX_row_data[TF_TCAM_MAX_SESSIONS][L2_CTXT_RX_MAX_ROWS];
+static struct cfa_tcam_mgr_TCAM_row_data
+ cfa_tcam_mgr_PROF_TCAM_RX_row_data[TF_TCAM_MAX_SESSIONS][PROF_RX_MAX_ROWS];
+static struct cfa_tcam_mgr_TCAM_row_data
+ cfa_tcam_mgr_WC_TCAM_RX_row_data[TF_TCAM_MAX_SESSIONS][WC_RX_MAX_ROWS];
+static struct cfa_tcam_mgr_TCAM_row_data
+ cfa_tcam_mgr_SP_TCAM_RX_row_data[TF_TCAM_MAX_SESSIONS][SP_RX_MAX_ROWS];
+static struct cfa_tcam_mgr_TCAM_row_data
+ cfa_tcam_mgr_CT_RULE_TCAM_RX_row_data[TF_TCAM_MAX_SESSIONS][CT_RULE_RX_MAX_ROWS];
+static struct cfa_tcam_mgr_TCAM_row_data
+ cfa_tcam_mgr_VEB_TCAM_RX_row_data[TF_TCAM_MAX_SESSIONS][VEB_RX_MAX_ROWS];
+static struct cfa_tcam_mgr_TCAM_row_data
+ cfa_tcam_mgr_WC_TCAM_RX_row_data[TF_TCAM_MAX_SESSIONS][WC_RX_MAX_ROWS];
+
+static struct cfa_tcam_mgr_TCAM_row_data
+ cfa_tcam_mgr_L2_CTXT_TCAM_TX_row_data[TF_TCAM_MAX_SESSIONS][L2_CTXT_TX_MAX_ROWS];
+static struct cfa_tcam_mgr_TCAM_row_data
+ cfa_tcam_mgr_PROF_TCAM_TX_row_data[TF_TCAM_MAX_SESSIONS][PROF_TX_MAX_ROWS];
+static struct cfa_tcam_mgr_TCAM_row_data
+ cfa_tcam_mgr_WC_TCAM_TX_row_data[TF_TCAM_MAX_SESSIONS][WC_TX_MAX_ROWS];
+static struct cfa_tcam_mgr_TCAM_row_data
+ cfa_tcam_mgr_SP_TCAM_TX_row_data[TF_TCAM_MAX_SESSIONS][SP_TX_MAX_ROWS];
+static struct cfa_tcam_mgr_TCAM_row_data
+ cfa_tcam_mgr_CT_RULE_TCAM_TX_row_data[TF_TCAM_MAX_SESSIONS][CT_RULE_TX_MAX_ROWS];
+static struct cfa_tcam_mgr_TCAM_row_data
+ cfa_tcam_mgr_VEB_TCAM_TX_row_data[TF_TCAM_MAX_SESSIONS][VEB_TX_MAX_ROWS];
+static struct cfa_tcam_mgr_TCAM_row_data
+ cfa_tcam_mgr_WC_TCAM_TX_row_data[TF_TCAM_MAX_SESSIONS][WC_TX_MAX_ROWS];
+
+static struct cfa_tcam_mgr_TCAM_row_data *
+row_tables[TF_DIR_MAX][TF_TCAM_TBL_TYPE_MAX] = {
+ {
+ cfa_tcam_mgr_L2_CTXT_TCAM_RX_row_data[0],
+ cfa_tcam_mgr_L2_CTXT_TCAM_RX_row_data[0],
+ cfa_tcam_mgr_PROF_TCAM_RX_row_data[0],
+ cfa_tcam_mgr_WC_TCAM_RX_row_data[0],
+ cfa_tcam_mgr_SP_TCAM_RX_row_data[0],
+ cfa_tcam_mgr_CT_RULE_TCAM_RX_row_data[0],
+ cfa_tcam_mgr_VEB_TCAM_RX_row_data[0],
+ cfa_tcam_mgr_WC_TCAM_RX_row_data[0],
+ cfa_tcam_mgr_WC_TCAM_RX_row_data[0],
+ },
+ {
+ cfa_tcam_mgr_L2_CTXT_TCAM_TX_row_data[0],
+ cfa_tcam_mgr_L2_CTXT_TCAM_TX_row_data[0],
+ cfa_tcam_mgr_PROF_TCAM_TX_row_data[0],
+ cfa_tcam_mgr_WC_TCAM_TX_row_data[0],
+ cfa_tcam_mgr_SP_TCAM_TX_row_data[0],
+ cfa_tcam_mgr_CT_RULE_TCAM_TX_row_data[0],
+ cfa_tcam_mgr_VEB_TCAM_TX_row_data[0],
+ cfa_tcam_mgr_WC_TCAM_TX_row_data[0],
+ cfa_tcam_mgr_WC_TCAM_TX_row_data[0],
+ }
+};
+
+static int cfa_tcam_mgr_get_max_rows(enum tf_tcam_tbl_type type)
+{
+ if (type >= TF_TCAM_TBL_TYPE_MAX)
+ assert(0);
+ else
+ return cfa_tcam_mgr_max_rows[type];
+}
+
+static int cfa_tcam_mgr_hwop_set(int sess_idx,
+ struct cfa_tcam_mgr_set_parms *parms, int row,
+ int slice, int max_slices)
+{
+ struct cfa_tcam_mgr_TCAM_row_data *this_table;
+ struct cfa_tcam_mgr_TCAM_row_data *this_row;
+ this_table = row_tables[parms->dir]
+ [cfa_tcam_mgr_get_phys_table_type(parms->type)];
+ this_table += (sess_idx *
+ cfa_tcam_mgr_get_max_rows(cfa_tcam_mgr_get_phys_table_type(parms->type)));
+ this_row = &this_table[row * max_slices + slice];
+ this_row->key_size = parms->key_size;
+ memcpy(&this_row->key, parms->key, parms->key_size);
+ memcpy(&this_row->mask, parms->mask, parms->key_size);
+ this_row->result_size = parms->result_size;
+ if (parms->result != ((void *)0))
+ memcpy(&this_row->result, parms->result, parms->result_size);
+ return 0;
+};
+
+static int cfa_tcam_mgr_hwop_get(int sess_idx,
+ struct cfa_tcam_mgr_get_parms *parms, int row,
+ int slice, int max_slices)
+{
+ struct cfa_tcam_mgr_TCAM_row_data *this_table;
+ struct cfa_tcam_mgr_TCAM_row_data *this_row;
+ this_table = row_tables[parms->dir]
+ [cfa_tcam_mgr_get_phys_table_type(parms->type)];
+ this_table += (sess_idx *
+ cfa_tcam_mgr_get_max_rows(cfa_tcam_mgr_get_phys_table_type(parms->type)));
+ this_row = &this_table[row * max_slices + slice];
+ parms->key_size = this_row->key_size;
+ parms->result_size = this_row->result_size;
+ if (parms->key != ((void *)0))
+ memcpy(parms->key, &this_row->key, parms->key_size);
+ if (parms->mask != ((void *)0))
+ memcpy(parms->mask, &this_row->mask, parms->key_size);
+ if (parms->result != ((void *)0))
+ memcpy(parms->result, &this_row->result, parms->result_size);
+ return 0;
+};
+
+static int cfa_tcam_mgr_hwop_free(int sess_idx,
+ struct cfa_tcam_mgr_free_parms *parms,
+ int row, int slice, int max_slices)
+{
+ struct cfa_tcam_mgr_TCAM_row_data *this_table;
+ struct cfa_tcam_mgr_TCAM_row_data *this_row;
+ this_table = row_tables[parms->dir]
+ [cfa_tcam_mgr_get_phys_table_type(parms->type)];
+ this_table += (sess_idx *
+ cfa_tcam_mgr_get_max_rows(cfa_tcam_mgr_get_phys_table_type(parms->type)));
+ this_row = &this_table[row * max_slices + slice];
+ memset(&this_row->key, 0, sizeof(this_row->key));
+ memset(&this_row->mask, 0, sizeof(this_row->mask));
+ memset(&this_row->result, 0, sizeof(this_row->result));
+ this_row->key_size = 0;
+ this_row->result_size = 0;
+ return 0;
+};
+
+int cfa_tcam_mgr_hwops_get_funcs_p58(struct cfa_tcam_mgr_hwops_funcs
+ *hwop_funcs)
+{
+ hwop_funcs->set = cfa_tcam_mgr_hwop_set;
+ hwop_funcs->get = cfa_tcam_mgr_hwop_get;
+ hwop_funcs->free = cfa_tcam_mgr_hwop_free;
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,20 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2021-2023 Broadcom
+ * All rights reserved.
+ */
+
+#ifndef CFA_TCAM_MGR_P58_H
+#define CFA_TCAM_MGR_P58_H
+
+#include "cfa_tcam_mgr_device.h"
+#include "cfa_tcam_mgr_sbmp.h"
+
+int
+cfa_tcam_mgr_init_p58(int sess_idx, struct cfa_tcam_mgr_entry_data **global_entry_data);
+
+int
+cfa_tcam_mgr_sess_table_get_p58(int sess_idx, struct sbmp **session_bmp);
+
+int
+cfa_tcam_mgr_hwops_get_funcs_p58(struct cfa_tcam_mgr_hwops_funcs *hwop_funcs);
+#endif /* CFA_TCAM_MGR_P58_H */
new file mode 100644
@@ -0,0 +1,126 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2021-2023 Broadcom
+ * All rights reserved.
+ */
+
+#ifndef CFA_TCAM_MGR_SBMP_H
+#define CFA_TCAM_MGR_SBMP_H
+
+#include <inttypes.h>
+
+#include "cfa_tcam_mgr.h"
+
+#define SBMP_SESSION_MAX TF_TCAM_MAX_SESSIONS
+#if SBMP_SESSION_MAX <= 16
+#define SBMP_WORD_WIDTH 16
+#else
+#define SBMP_WORD_WIDTH 32
+#endif
+
+#define SBMP_WIDTH (((SBMP_SESSION_MAX + SBMP_WORD_WIDTH - 1) / \
+ SBMP_WORD_WIDTH) * SBMP_WORD_WIDTH)
+#define SBMP_WORD_MAX ((SBMP_WIDTH + SBMP_WORD_WIDTH - 1) / SBMP_WORD_WIDTH)
+
+struct sbmp {
+#if SBMP_WORD_WIDTH == 16
+ uint16_t bits[SBMP_WORD_MAX];
+#elif SBMP_WORD_WIDTH == 32
+ uint32_t bits[SBMP_WORD_MAX];
+#else
+ uint64_t bits[SBMP_WORD_MAX];
+#endif
+};
+
+#define SBMP_WORD_GET(bm, word) ((bm).bits[(word)])
+
+#if SBMP_WORD_MAX == 1
+#define SBMP_WENT(session) (0)
+#define SBMP_WBIT(session) (1U << (session))
+#define SBMP_CLEAR(bm) (SBMP_WORD_GET(bm, 0) = 0)
+#define SBMP_IS_NULL(bm) (SBMP_WORD_GET(bm, 0) == 0)
+#define SBMP_COUNT(bm, count) \
+ (count = __builtin_popcount(SBMP_WORD_GET(bm, 0)))
+#elif SBMP_WORD_MAX == 2
+#define SBMP_WENT(session) ((session) / SBMP_WORD_WIDTH)
+#define SBMP_WBIT(session) (1U << ((session) % SBMP_WORD_WIDTH))
+#define SBMP_CLEAR(bm) \
+ do { \
+ typeof(bm) *_bm = &(bm); \
+ SBMP_WORD_GET(*_bm, 0) = SBMP_WORD_GET(*_bm, 1) = 0; \
+ } while (0)
+#define SBMP_IS_NULL(bm) \
+ (SBMP_WORD_GET(bm, 0) == 0 && SBMP_WORD_GET(bm, 1) == 0)
+#define SBMP_COUNT(bm, count) \
+ do { \
+ typeof(bm) *_bm = &(bm); \
+ count = __builtin_popcount(SBMP_WORD_GET(*_bm, 0)) + \
+ __builtin_popcount(SBMP_WORD_GET(*_bm, 1))); \
+ } while (0)
+#elif SBMP_WORD_MAX == 3
+#define SBMP_WENT(session) ((session) / SBMP_WORD_WIDTH)
+#define SBMP_WBIT(session) (1U << ((session) % SBMP_WORD_WIDTH))
+#define SBMP_CLEAR(bm) \
+ do { \
+ typeof(bm) *_bm = &(bm); \
+ SBMP_WORD_GET(*_bm, 0) = SBMP_WORD_GET(*_bm, 1) = \
+ SBMP_WORD_GET(*_bm, 2) = 0; \
+ } while (0)
+#define SBMP_IS_NULL(bm) \
+ (SBMP_WORD_GET(bm, 0) == 0 && SBMP_WORD_GET(bm, 1) == 0 && \
+ SBMP_WORD_GET(bm, 2) == 0)
+#define SBMP_COUNT(bm, count) \
+ do { \
+ typeof(bm) *_bm = &(bm); \
+ count = __builtin_popcount(SBMP_WORD_GET(*_bm, 0)) + \
+ __builtin_popcount(SBMP_WORD_GET(*_bm, 1)) + \
+ __builtin_popcount(SBMP_WORD_GET(*_bm, 2)); \
+ } while (0)
+#else /* SBMP_WORD_MAX > 3 */
+#define SBMP_WENT(session) ((session) / SBMP_WORD_WIDTH)
+#define SBMP_WBIT(session) (1U << ((session) % SBMP_WORD_WIDTH))
+#define SBMP_CLEAR(bm) \
+ do { \
+ typeof(bm) *_bm = &(bm); \
+ int _w; \
+ for (_w = 0; _w < SBMP_WORD_MAX; _w++) { \
+ SBMP_WORD_GET(*_bm, _w) = 0; \
+ } \
+ } while (0)
+#define SBMP_IS_NULL(bm) (sbmp_bmnull(&(bm)))
+#define SBMP_COUNT(bm, count) \
+ do { \
+ typeof(bm) *_bm = &(bm); \
+ int _count, _w; \
+ _count = 0; \
+ for (_w = 0; _w < SBMP_WORD_MAX; _w++) { \
+ _count += __builtin_popcount(SBMP_WORD_GET(*_bm, _w)); \
+ } \
+ count = _count; \
+ } while (0)
+
+/* Only needed if SBMP_WORD_MAX > 3 */
+static int
+sbmp_bmnull(struct ebmp *bmp)
+{
+ int i;
+
+ for (i = 0; i < SBMP_WORD_MAX; i++) {
+ if (SBMP_WORD_GET(*bmp, i) != 0)
+ return 0;
+ }
+ return 1;
+}
+#endif
+
+/* generics that use the previously defined helpers */
+#define SBMP_NOT_NULL(bm) (!SBMP_IS_NULL(bm))
+
+#define SBMP_ENTRY(bm, session) \
+ (SBMP_WORD_GET(bm, SBMP_WENT(session)))
+#define SBMP_MEMBER(bm, session) \
+ ((SBMP_ENTRY(bm, session) & SBMP_WBIT(session)) != 0)
+#define SBMP_SESSION_ADD(bm, session) \
+ (SBMP_ENTRY(bm, session) |= SBMP_WBIT(session))
+#define SBMP_SESSION_REMOVE(bm, session) \
+ (SBMP_ENTRY(bm, session) &= ~SBMP_WBIT(session))
+#endif /* CFA_TCAM_MGR_SBMP_H */
new file mode 100644
@@ -0,0 +1,377 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2021-2023 Broadcom
+ * All rights reserved.
+ */
+
+#include <inttypes.h>
+#include "hcapi_cfa_defs.h"
+#include "tf_util.h"
+#include "cfa_tcam_mgr.h"
+#include "cfa_tcam_mgr_device.h"
+#include "cfa_tcam_mgr_session.h"
+#include "cfa_tcam_mgr_sbmp.h"
+#include "tfp.h"
+#include "cfa_tcam_mgr_p58.h"
+#include "cfa_tcam_mgr_p4.h"
+
+struct cfa_tcam_mgr_session_data {
+ uint32_t session_id;
+ /* The following are per-session values */
+ uint16_t max_entries[TF_DIR_MAX][CFA_TCAM_MGR_TBL_TYPE_MAX];
+ uint16_t used_entries[TF_DIR_MAX][CFA_TCAM_MGR_TBL_TYPE_MAX];
+};
+
+static struct cfa_tcam_mgr_session_data session_data[TF_TCAM_MAX_SESSIONS];
+
+static uint16_t last_entry_id;
+
+static struct sbmp *session_bmp[TF_TCAM_MAX_SESSIONS];
+
+int
+cfa_tcam_mgr_session_init(int sess_idx, enum cfa_tcam_mgr_device_type type)
+{
+ int rc;
+
+ switch (type) {
+ case CFA_TCAM_MGR_DEVICE_TYPE_P4:
+ case CFA_TCAM_MGR_DEVICE_TYPE_SR:
+ rc = cfa_tcam_mgr_sess_table_get_p4(sess_idx, &session_bmp[sess_idx]);
+ break;
+ case CFA_TCAM_MGR_DEVICE_TYPE_P5:
+ rc = cfa_tcam_mgr_sess_table_get_p58(sess_idx, &session_bmp[sess_idx]);
+ break;
+ default:
+ CFA_TCAM_MGR_LOG(ERR, "No such device %d\n", type);
+ rc = -CFA_TCAM_MGR_ERR_CODE(NODEV);
+ }
+
+ return rc;
+}
+
+int
+cfa_tcam_mgr_get_session_from_context(struct cfa_tcam_mgr_context *context,
+ uint32_t *session_id)
+{
+ if (context == NULL) {
+ CFA_TCAM_MGR_LOG_0(ERR, "context passed as NULL pointer.\n");
+ return -CFA_TCAM_MGR_ERR_CODE(INVAL);
+ }
+
+ *session_id = context->tfp->session->session_id.id;
+ return 0;
+}
+
+int
+cfa_tcam_mgr_session_find(unsigned int session_id)
+{
+ unsigned int sess_idx;
+
+ for (sess_idx = 0; sess_idx < ARRAY_SIZE(session_data); sess_idx++) {
+ if (session_data[sess_idx].session_id == session_id)
+ return sess_idx;
+ }
+
+ return -CFA_TCAM_MGR_ERR_CODE(INVAL);
+}
+
+int
+cfa_tcam_mgr_session_add(unsigned int session_id)
+{
+ int sess_idx;
+
+ sess_idx = cfa_tcam_mgr_session_find(session_id);
+ if (sess_idx >= 0) {
+ CFA_TCAM_MGR_LOG_0(ERR, "Session is already bound.\n");
+ return -CFA_TCAM_MGR_ERR_CODE(BUSY);
+ }
+
+ /* Session not found in table, find first empty entry. */
+ for (sess_idx = 0;
+ sess_idx < (signed int)ARRAY_SIZE(session_data);
+ sess_idx++) {
+ if (session_data[sess_idx].session_id == 0)
+ break;
+ }
+
+ if (sess_idx >= (signed int)ARRAY_SIZE(session_data)) {
+ /* No room in the session table */
+ CFA_TCAM_MGR_LOG_0(ERR, "Session table is full.\n");
+ return -CFA_TCAM_MGR_ERR_CODE(NOMEM);
+ }
+
+ session_data[sess_idx].session_id = session_id;
+
+ return sess_idx;
+}
+
+int
+cfa_tcam_mgr_session_free(unsigned int session_id,
+ struct cfa_tcam_mgr_context *context)
+{
+ struct cfa_tcam_mgr_free_parms free_parms;
+ int entry_id;
+ int sess_idx = cfa_tcam_mgr_session_find(session_id);
+
+ if (sess_idx < 0)
+ return sess_idx;
+
+ memset(&free_parms, 0, sizeof(free_parms));
+ /* Since we are freeing all pending TCAM entries (which is typically
+ * done during tcam_unbind), we don't know the type of each entry.
+ * So we set the type to MAX as a hint to cfa_tcam_mgr_free() to
+ * figure out the actual type. We need to set it through each
+ * iteration in the loop below; otherwise, the type determined for
+ * the first entry would be used for subsequent entries that may or
+ * may not be of the same type, resulting in errors.
+ */
+ for (entry_id = 0; entry_id < cfa_tcam_mgr_max_entries[sess_idx]; entry_id++) {
+ if (SBMP_MEMBER(session_bmp[sess_idx][entry_id], sess_idx)) {
+ SBMP_SESSION_REMOVE(session_bmp[sess_idx][entry_id], sess_idx);
+
+ free_parms.id = entry_id;
+ free_parms.type = CFA_TCAM_MGR_TBL_TYPE_MAX;
+ cfa_tcam_mgr_free(context, &free_parms);
+ }
+ }
+
+ memset(&session_data[sess_idx], 0, sizeof(session_data[sess_idx]));
+ return 0;
+}
+
+int
+cfa_tcam_mgr_session_cfg(unsigned int session_id,
+ uint16_t tcam_cnt[][CFA_TCAM_MGR_TBL_TYPE_MAX])
+{
+ struct cfa_tcam_mgr_table_data *table_data;
+ struct cfa_tcam_mgr_session_data *session_entry;
+ unsigned int dir, type;
+ int sess_idx = cfa_tcam_mgr_session_find(session_id);
+ uint16_t requested_cnt;
+
+ if (sess_idx < 0)
+ return sess_idx;
+
+ session_entry = &session_data[sess_idx];
+
+ /* Validate session request */
+ for (dir = 0; dir < ARRAY_SIZE(cfa_tcam_mgr_tables[sess_idx]); dir++) {
+ for (type = 0;
+ type < ARRAY_SIZE(cfa_tcam_mgr_tables[sess_idx][dir]);
+ type++) {
+ table_data = &cfa_tcam_mgr_tables[sess_idx][dir][type];
+ requested_cnt = tcam_cnt[dir][type];
+ /*
+ * Only check if table supported (max_entries > 0).
+ */
+ if (table_data->max_entries > 0 &&
+ requested_cnt > table_data->max_entries) {
+ CFA_TCAM_MGR_LOG_DIR_TYPE(ERR, dir, type,
+ "Requested %d, available %d.\n",
+ requested_cnt,
+ table_data->max_entries);
+ return -CFA_TCAM_MGR_ERR_CODE(NOSPC);
+ }
+ }
+ }
+
+ memcpy(session_entry->max_entries, tcam_cnt,
+ sizeof(session_entry->max_entries));
+ return 0;
+}
+
+void
+cfa_tcam_mgr_mv_session_used_entries_cnt(int sess_idx, enum tf_dir dir,
+ enum cfa_tcam_mgr_tbl_type dst_type,
+ enum cfa_tcam_mgr_tbl_type src_type)
+{
+ session_data[sess_idx].used_entries[dir][dst_type]++;
+ session_data[sess_idx].used_entries[dir][src_type]--;
+}
+
+int
+cfa_tcam_mgr_session_entry_alloc(unsigned int session_id,
+ enum tf_dir dir,
+ enum cfa_tcam_mgr_tbl_type type)
+{
+ int sess_idx;
+
+ sess_idx = cfa_tcam_mgr_session_find(session_id);
+ if (sess_idx < 0) {
+ CFA_TCAM_MGR_LOG_0(ERR, "Session not found.\n");
+ return -CFA_TCAM_MGR_ERR_CODE(NODEV);
+ }
+
+ if (session_data[sess_idx].used_entries[dir][type] >=
+ session_data[sess_idx].max_entries[dir][type]) {
+ CFA_TCAM_MGR_LOG_0(ERR, "Table full (session).\n");
+ return -CFA_TCAM_MGR_ERR_CODE(NOSPC);
+ }
+
+ do {
+ last_entry_id++;
+ if (cfa_tcam_mgr_max_entries[sess_idx] <= last_entry_id)
+ last_entry_id = 0;
+ } while (!SBMP_IS_NULL(session_bmp[sess_idx][last_entry_id]));
+
+ SBMP_SESSION_ADD(session_bmp[sess_idx][last_entry_id], sess_idx);
+
+ session_data[sess_idx].used_entries[dir][type] += 1;
+
+ return last_entry_id;
+}
+
+int
+cfa_tcam_mgr_session_entry_free(unsigned int session_id,
+ unsigned int entry_id,
+ enum tf_dir dir,
+ enum cfa_tcam_mgr_tbl_type type)
+{
+ int sess_idx;
+
+ sess_idx = cfa_tcam_mgr_session_find(session_id);
+ if (sess_idx < 0) {
+ CFA_TCAM_MGR_LOG_0(ERR, "Session not found.\n");
+ return -CFA_TCAM_MGR_ERR_CODE(NODEV);
+ }
+
+ SBMP_SESSION_REMOVE(session_bmp[sess_idx][entry_id], sess_idx);
+ session_data[sess_idx].used_entries[dir][type] -= 1;
+
+ return 0;
+}
+
+#if SBMP_WORD_WIDTH == 16
+#define SBMP_FORMAT PRIX16
+#define SBMP_PRECISION "4"
+#elif SBMP_WORD_WIDTH == 32
+#define SBMP_FORMAT PRIX32
+#define SBMP_PRECISION "8"
+#elif SBMP_WORD_WIDTH == 64
+#define SBMP_FORMAT PRIX64
+#define SBMP_PRECISION "16"
+#else
+#error "Invalid value for SBMP_WORD_WIDTH."
+#endif
+
+static void
+cfa_tcam_mgr_session_bitmap_print(struct sbmp *session_bmp)
+{
+ unsigned int i;
+
+ printf("0x");
+ for (i = 0;
+ i < ARRAY_SIZE(session_bmp->bits);
+ i++) {
+ printf("%0" SBMP_PRECISION SBMP_FORMAT,
+ session_bmp->bits[i]);
+ }
+}
+
+#define SESSION_DUMP_HEADER_1 " RX TX\n"
+#define SESSION_DUMP_HEADER_2 \
+ " Max Used Max Used\n"
+
+static void
+cfa_tcam_mgr_session_printf(struct cfa_tcam_mgr_session_data *session,
+ enum cfa_tcam_mgr_tbl_type tbl_type)
+{
+ printf("%-22s: %5u %5u %5u %5u\n",
+ cfa_tcam_mgr_tbl_2_str(tbl_type),
+ session->max_entries[TF_DIR_RX][tbl_type],
+ session->used_entries[TF_DIR_RX][tbl_type],
+ session->max_entries[TF_DIR_TX][tbl_type],
+ session->used_entries[TF_DIR_TX][tbl_type]);
+}
+
+void
+cfa_tcam_mgr_sessions_dump(void)
+{
+ struct cfa_tcam_mgr_session_data *session;
+ unsigned int sess_idx;
+ bool sess_found = false;
+ enum cfa_tcam_mgr_tbl_type tbl_type;
+
+ printf("\nTCAM Sessions Table:\n");
+ for (sess_idx = 0; sess_idx < ARRAY_SIZE(session_data); sess_idx++) {
+ if (session_data[sess_idx].session_id != 0) {
+ session = &session_data[sess_idx];
+ if (!sess_found) {
+ printf(SESSION_DUMP_HEADER_1);
+ printf(SESSION_DUMP_HEADER_2);
+ }
+ printf("Session 0x%08x:\n",
+ session->session_id);
+ for (tbl_type = CFA_TCAM_MGR_TBL_TYPE_START;
+ tbl_type < CFA_TCAM_MGR_TBL_TYPE_MAX;
+ tbl_type++) {
+ cfa_tcam_mgr_session_printf(session, tbl_type);
+ }
+ sess_found = true;
+ }
+ }
+
+ if (!sess_found)
+ printf("No sessions found.\n");
+}
+
+/* This dumps all the sessions using an entry */
+void
+cfa_tcam_mgr_entry_sessions_dump(int sess_idx, uint16_t id)
+{
+ bool session_found = false;
+
+ if (id >= cfa_tcam_mgr_max_entries[sess_idx]) {
+ printf("Entry ID %u out of range for sess_idx %d. Max ID %u.\n",
+ id, sess_idx, cfa_tcam_mgr_max_entries[sess_idx] - 1);
+ return;
+ }
+
+ if (!SBMP_IS_NULL(session_bmp[sess_idx][id])) {
+ printf("Sessions using entry ID %u:\n", id);
+ for (sess_idx = 0; sess_idx < SBMP_SESSION_MAX; sess_idx++)
+ if (SBMP_MEMBER(session_bmp[sess_idx][id], (sess_idx))) {
+ if (session_data[sess_idx].session_id != 0) {
+ printf("0x%08x (index %d)\n",
+ session_data[sess_idx].session_id,
+ sess_idx);
+ session_found = true;
+ } else {
+ printf("Error! Entry ID %u used by "
+ "session index %d which is not "
+ "in use.\n",
+ id, sess_idx);
+ }
+ }
+ if (!session_found)
+ printf("No sessions using entry ID %u.\n", id);
+ } else {
+ printf("Entry ID %u not in use.\n",
+ id);
+ return;
+ }
+}
+
+/* This dumps all the entries in use by any session */
+void
+cfa_tcam_mgr_session_entries_dump(int sess_idx)
+{
+ bool entry_found = false;
+ uint16_t id;
+
+ printf("\nGlobal Maximum Entries for sess_idx %d: %d\n\n",
+ sess_idx, cfa_tcam_mgr_max_entries[sess_idx]);
+ printf("TCAM Session Entry Table:\n");
+ for (id = 0; id < cfa_tcam_mgr_max_entries[sess_idx]; id++) {
+ if (!SBMP_IS_NULL(session_bmp[sess_idx][id])) {
+ if (!entry_found)
+ printf(" EID Session bitmap\n");
+ printf("%5u ", id);
+ cfa_tcam_mgr_session_bitmap_print(&session_bmp[sess_idx][id]);
+ printf("\n");
+ entry_found = true;
+ }
+ }
+
+ if (!entry_found)
+ printf("No entries found.\n");
+}
new file mode 100644
@@ -0,0 +1,54 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2019-2023 Broadcom
+ * All rights reserved.
+ */
+
+#ifndef CFA_TCAM_MGR_SESSION_H
+#define CFA_TCAM_MGR_SESSION_H
+
+#include <inttypes.h>
+#include "cfa_tcam_mgr.h"
+
+int
+cfa_tcam_mgr_session_init(int sess_idx, enum cfa_tcam_mgr_device_type type);
+
+int
+cfa_tcam_mgr_get_session_from_context(struct cfa_tcam_mgr_context *context,
+ uint32_t *session_id);
+
+int
+cfa_tcam_mgr_session_find(unsigned int session_id);
+
+int
+cfa_tcam_mgr_session_add(unsigned int session_id);
+
+int
+cfa_tcam_mgr_session_free(unsigned int session_id,
+ struct cfa_tcam_mgr_context *context);
+
+int
+cfa_tcam_mgr_session_cfg(unsigned int session_id,
+ uint16_t tcam_cnt[][CFA_TCAM_MGR_TBL_TYPE_MAX]);
+
+int
+cfa_tcam_mgr_session_entry_alloc(unsigned int session_id,
+ enum tf_dir dir,
+ enum cfa_tcam_mgr_tbl_type type);
+int
+cfa_tcam_mgr_session_entry_free(unsigned int session_id,
+ unsigned int entry_id,
+ enum tf_dir dir,
+ enum cfa_tcam_mgr_tbl_type type);
+
+void
+cfa_tcam_mgr_sessions_dump(void);
+void
+cfa_tcam_mgr_entry_sessions_dump(int sess_idx, uint16_t id);
+void
+cfa_tcam_mgr_session_entries_dump(int sess_idx);
+
+void
+cfa_tcam_mgr_mv_session_used_entries_cnt(int sess_idx, enum tf_dir dir,
+ enum cfa_tcam_mgr_tbl_type dst_type,
+ enum cfa_tcam_mgr_tbl_type src_type);
+#endif /* CFA_TCAM_MGR_SESSION_H */
@@ -1,36 +1,42 @@
# SPDX-License-Identifier: BSD-3-Clause
# Copyright(c) 2018 Intel Corporation
-# Copyright(c) 2021 Broadcom
+# Copyright(c) 2023 Broadcom
#Include the folder for headers
includes += include_directories('.')
#Add the source files
sources += files(
- 'tf_core.c',
'bitalloc.c',
- 'tf_msg.c',
- 'll.c',
+ 'cfa_tcam_mgr.c',
+ 'cfa_tcam_mgr_hwop_msg.c',
+ 'cfa_tcam_mgr_p4.c',
+ 'cfa_tcam_mgr_p58.c',
+ 'cfa_tcam_mgr_session.c',
'dpool.c',
+ 'll.c',
'rand.c',
'stack.c',
- 'tf_rm.c',
- 'tf_tbl.c',
- 'tf_tbl_sram.c',
- 'tf_sram_mgr.c',
+ 'tf_core.c',
+ 'tf_device.c',
+ 'tf_device_p4.c',
+ 'tf_device_p58.c',
'tf_em_common.c',
+ 'tf_em_hash_internal.c',
'tf_em_host.c',
'tf_em_internal.c',
- 'tf_em_hash_internal.c',
- 'tfp.c',
- 'tf_util.c',
- 'tf_device.c',
- 'tf_device_p4.c',
'tf_global_cfg.c',
+ 'tf_hash.c',
'tf_identifier.c',
'tf_if_tbl.c',
+ 'tf_msg.c',
+ 'tfp.c',
+ 'tf_rm.c',
'tf_session.c',
+ 'tf_sram_mgr.c',
+ 'tf_tbl.c',
+ 'tf_tbl_sram.c',
'tf_tcam.c',
+ 'tf_tcam_mgr_msg.c',
'tf_tcam_shared.c',
- 'tf_hash.c',
- 'tf_device_p58.c')
+ 'tf_util.c')
@@ -1,5 +1,5 @@
/* SPDX-License-Identifier: BSD-3-Clause
- * Copyright(c) 2019-2021 Broadcom
+ * Copyright(c) 2019-2023 Broadcom
* All rights reserved.
*/
@@ -34,8 +34,8 @@ tf_open_session(struct tf *tfp,
* side. It is assumed that the Firmware will be supported if
* firmware open session succeeds.
*/
- if (parms->device_type != TF_DEVICE_TYPE_WH &&
- parms->device_type != TF_DEVICE_TYPE_THOR &&
+ if (parms->device_type != TF_DEVICE_TYPE_P4 &&
+ parms->device_type != TF_DEVICE_TYPE_P5 &&
parms->device_type != TF_DEVICE_TYPE_SR) {
TFP_DRV_LOG(ERR,
"Unsupported device type %d\n",
@@ -83,7 +83,7 @@ tf_open_session(struct tf *tfp,
return rc;
TFP_DRV_LOG(INFO,
- "domain:%d, bus:%d, device:%u\n",
+ "domain:%x, bus:%x, device:%u\n",
parms->session_id.internal.domain,
parms->session_id.internal.bus,
parms->session_id.internal.device);
@@ -176,7 +176,7 @@ tf_close_session(struct tf *tfp)
return rc;
TFP_DRV_LOG(INFO,
- "domain:%d, bus:%d, device:%d\n",
+ "domain:%d, bus:%x, device:%d\n",
cparms.session_id->internal.domain,
cparms.session_id->internal.bus,
cparms.session_id->internal.device);
@@ -742,7 +742,6 @@ tf_set_tcam_entry(struct tf *tfp,
memset(&sparms, 0, sizeof(struct tf_tcam_set_parms));
-
/* Retrieve the session information */
rc = tf_session_get_session(tfp, &tfs);
if (rc) {
@@ -790,6 +789,10 @@ tf_set_tcam_entry(struct tf *tfp,
strerror(-rc));
return rc;
}
+ TFP_DRV_LOG(DEBUG,
+ "%s: TCAM type %d set idx:%d key size %d result size %d\n",
+ tf_dir_2_str(parms->dir), sparms.type,
+ sparms.idx, sparms.key_size, sparms.result_size);
return 0;
}
@@ -807,7 +810,6 @@ tf_get_tcam_entry(struct tf *tfp __rte_unused,
memset(&gparms, 0, sizeof(struct tf_tcam_get_parms));
-
/* Retrieve the session information */
rc = tf_session_get_session(tfp, &tfs);
if (rc) {
@@ -1812,8 +1814,8 @@ int tf_get_version(struct tf *tfp,
/* This function can be called before open session, filter
* out any non-supported device types on the Core side.
*/
- if (parms->device_type != TF_DEVICE_TYPE_WH &&
- parms->device_type != TF_DEVICE_TYPE_THOR &&
+ if (parms->device_type != TF_DEVICE_TYPE_P4 &&
+ parms->device_type != TF_DEVICE_TYPE_P5 &&
parms->device_type != TF_DEVICE_TYPE_SR) {
TFP_DRV_LOG(ERR,
"Unsupported device type %d\n",
@@ -1845,7 +1847,7 @@ int tf_query_sram_resources(struct tf *tfp,
/* This function can be called before open session, filter
* out any non-supported device types on the Core side.
*/
- if (parms->device_type != TF_DEVICE_TYPE_THOR) {
+ if (parms->device_type != TF_DEVICE_TYPE_P5) {
TFP_DRV_LOG(ERR,
"Unsupported device type %d\n",
parms->device_type);
@@ -1927,7 +1929,7 @@ int tf_set_sram_policy(struct tf *tfp,
/* This function can be called before open session, filter
* out any non-supported device types on the Core side.
*/
- if (parms->device_type != TF_DEVICE_TYPE_THOR) {
+ if (parms->device_type != TF_DEVICE_TYPE_P5) {
TFP_DRV_LOG(ERR,
"Unsupported device type %d\n",
parms->device_type);
@@ -1968,7 +1970,7 @@ int tf_get_sram_policy(struct tf *tfp,
/* This function can be called before open session, filter
* out any non-supported device types on the Core side.
*/
- if (parms->device_type != TF_DEVICE_TYPE_THOR) {
+ if (parms->device_type != TF_DEVICE_TYPE_P5) {
TFP_DRV_LOG(ERR,
"Unsupported device type %d\n",
parms->device_type);
@@ -1997,3 +1999,31 @@ int tf_get_sram_policy(struct tf *tfp,
return rc;
}
+
+int tf_set_session_hotup_state(struct tf *tfp,
+ struct tf_set_session_hotup_state_parms *parms)
+{
+ int rc = 0;
+
+ TF_CHECK_PARMS1(tfp);
+
+ rc = tf_session_set_hotup_state(tfp, parms);
+ if (rc)
+ return rc;
+
+ return rc;
+}
+
+int tf_get_session_hotup_state(struct tf *tfp,
+ struct tf_get_session_hotup_state_parms *parms)
+{
+ int rc = 0;
+
+ TF_CHECK_PARMS1(tfp);
+
+ rc = tf_session_get_hotup_state(tfp, parms);
+ if (rc)
+ return rc;
+
+ return rc;
+}
@@ -1,5 +1,5 @@
/* SPDX-License-Identifier: BSD-3-Clause
- * Copyright(c) 2019-2021 Broadcom
+ * Copyright(c) 2019-2023 Broadcom
* All rights reserved.
*/
@@ -112,6 +112,10 @@ enum tf_sram_bank_id {
* @ref tf_attach_session
*
* @ref tf_close_session
+ *
+ * @ref tf_get_session_info
+ *
+ * @ref tf_get_session_info
*/
/**
@@ -188,10 +192,10 @@ struct tf_session_version {
* Session supported device types
*/
enum tf_device_type {
- TF_DEVICE_TYPE_WH = 0, /**< Whitney+ */
- TF_DEVICE_TYPE_SR, /**< Stingray */
- TF_DEVICE_TYPE_THOR, /**< Thor */
- TF_DEVICE_TYPE_MAX /**< Maximum */
+ TF_DEVICE_TYPE_P4 = 0,
+ TF_DEVICE_TYPE_SR,
+ TF_DEVICE_TYPE_P5,
+ TF_DEVICE_TYPE_MAX
};
/**
@@ -286,6 +290,8 @@ enum tf_tbl_type {
TF_TBL_TYPE_ACT_ENCAP_32B,
/** Wh+/SR/TH Action Encap 64 Bytes */
TF_TBL_TYPE_ACT_ENCAP_64B,
+ /* TH Action Encap 128 Bytes */
+ TF_TBL_TYPE_ACT_ENCAP_128B,
/** WH+/SR/TH Action Source Properties SMAC */
TF_TBL_TYPE_ACT_SP_SMAC,
/** Wh+/SR/TH Action Source Properties SMAC IPv4 */
@@ -331,7 +337,7 @@ enum tf_tbl_type {
* External table type - initially 1 poolsize entries.
* All External table types are associated with a table
* scope. Internal types are not. Currently this is
- * a pool of 64B entries.
+ * a pool of 128B entries.
*/
TF_TBL_TYPE_EXT,
TF_TBL_TYPE_MAX
@@ -914,6 +920,71 @@ int tf_attach_session(struct tf *tfp,
*/
int tf_close_session(struct tf *tfp);
+/**
+ * tf_set_session_hotup_state parameter definition.
+ */
+struct tf_set_session_hotup_state_parms {
+ /**
+ * [in] the structure is used to set the state of
+ * the hotup shared session.
+ *
+ */
+ uint16_t state;
+};
+
+/**
+ * set hot upgrade shared session state
+ *
+ * This API is used to set the state of the shared session.
+ *
+ * [in] tfp
+ * Pointer to TF handle
+ *
+ * [in] parms
+ * Pointer to set hotup state parameters
+ *
+ * Returns
+ * - (0) if successful.
+ * - (-EINVAL) on failure.
+ */
+int tf_set_session_hotup_state(struct tf *tfp,
+ struct tf_set_session_hotup_state_parms *parms);
+
+/**
+ * tf_get_session_hotup_state parameter definition.
+ */
+struct tf_get_session_hotup_state_parms {
+ /**
+ * [out] the structure is used to get the state of
+ * the hotup shared session.
+ *
+ */
+ uint16_t state;
+ /**
+ * [out] get the ref_cnt of the hotup shared session.
+ *
+ */
+ uint16_t ref_cnt;
+};
+
+/**
+ * get hot upgrade shared session state
+ *
+ * This API is used to set the state of the shared session.
+ *
+ * [in] tfp
+ * Pointer to TF handle
+ *
+ * [in] parms
+ * Pointer to get hotup state parameters
+ *
+ * Returns
+ * - (0) if successful.
+ * - (-EINVAL) on failure.
+ */
+int tf_get_session_hotup_state(struct tf *tfp,
+ struct tf_get_session_hotup_state_parms *parms);
+
/**
* @page ident Identity Management
*
@@ -1192,8 +1263,6 @@ int tf_free_tbl_scope(struct tf *tfp,
*
* @ref tf_get_tcam_entry
*
- * @ref tf_free_tcam_entry
- *
* @ref tf_move_tcam_shared_entries
*
* @ref tf_clear_tcam_shared_entries
@@ -1258,7 +1327,7 @@ struct tf_search_tcam_entry_parms {
};
/**
- * search TCAM entry (experimental)
+ * search TCAM entry
*
* Search for a TCAM entry
*
@@ -1732,7 +1801,7 @@ struct tf_get_shared_tbl_increment_parms {
* tf_get_shared_tbl_increment
*
* This API is currently only required for use in the shared
- * session for Thor (p58) actions. An increment count is returned per
+ * session for P5 actions. An increment count is returned per
* type to indicate how much to increment the start by for each
* entry (see tf_resource_info)
*
@@ -1898,6 +1967,7 @@ struct tf_insert_em_entry_parms {
*/
uint64_t flow_id;
};
+
/**
* tf_delete_em_entry parameter definition
*/
@@ -1927,6 +1997,7 @@ struct tf_delete_em_entry_parms {
*/
uint64_t flow_handle;
};
+
/**
* tf_move_em_entry parameter definition
*/
@@ -1969,6 +2040,7 @@ struct tf_move_em_entry_parms {
*/
uint64_t flow_handle;
};
+
/**
* tf_search_em_entry parameter definition (Future)
*/
@@ -2108,6 +2180,7 @@ int tf_search_em_entry(struct tf *tfp,
*
* @ref tf_get_global_cfg
*/
+
/**
* Tunnel Encapsulation Offsets
*/
@@ -2121,6 +2194,7 @@ enum tf_tunnel_encap_offsets {
TF_TUNNEL_ENCAP_GRE,
TF_TUNNEL_ENCAP_FULL_GENERIC
};
+
/**
* Global Configuration Table Types
*/
@@ -2193,9 +2267,8 @@ int tf_set_global_cfg(struct tf *tfp,
* @ref tf_set_if_tbl_entry
*
* @ref tf_get_if_tbl_entry
- *
- * @ref tf_restore_if_tbl_entry
*/
+
/**
* Enumeration of TruFlow interface table types.
*/
@@ -1,5 +1,5 @@
/* SPDX-License-Identifier: BSD-3-Clause
- * Copyright(c) 2019-2021 Broadcom
+ * Copyright(c) 2019-2023 Broadcom
* All rights reserved.
*/
@@ -332,7 +332,7 @@ tf_dev_unbind_p4(struct tf *tfp)
}
/**
- * Device specific bind function, THOR
+ * Device specific bind function, P5
*
* [in] tfp
* Pointer to TF handle
@@ -504,7 +504,7 @@ tf_dev_bind_p58(struct tf *tfp,
}
/**
- * Device specific unbind function, THOR
+ * Device specific unbind function, P5
*
* [in] tfp
* Pointer to TF handle
@@ -602,14 +602,14 @@ tf_dev_bind(struct tf *tfp __rte_unused,
struct tf_dev_info *dev_handle)
{
switch (type) {
- case TF_DEVICE_TYPE_WH:
+ case TF_DEVICE_TYPE_P4:
case TF_DEVICE_TYPE_SR:
dev_handle->type = type;
return tf_dev_bind_p4(tfp,
resources,
dev_handle,
wc_num_slices);
- case TF_DEVICE_TYPE_THOR:
+ case TF_DEVICE_TYPE_P5:
dev_handle->type = type;
return tf_dev_bind_p58(tfp,
resources,
@@ -627,11 +627,11 @@ tf_dev_bind_ops(enum tf_device_type type,
struct tf_dev_info *dev_handle)
{
switch (type) {
- case TF_DEVICE_TYPE_WH:
+ case TF_DEVICE_TYPE_P4:
case TF_DEVICE_TYPE_SR:
dev_handle->ops = &tf_dev_ops_p4_init;
break;
- case TF_DEVICE_TYPE_THOR:
+ case TF_DEVICE_TYPE_P5:
dev_handle->ops = &tf_dev_ops_p58_init;
break;
default:
@@ -648,10 +648,10 @@ tf_dev_unbind(struct tf *tfp,
struct tf_dev_info *dev_handle)
{
switch (dev_handle->type) {
- case TF_DEVICE_TYPE_WH:
+ case TF_DEVICE_TYPE_P4:
case TF_DEVICE_TYPE_SR:
return tf_dev_unbind_p4(tfp);
- case TF_DEVICE_TYPE_THOR:
+ case TF_DEVICE_TYPE_P5:
return tf_dev_unbind_p58(tfp);
default:
TFP_DRV_LOG(ERR,
@@ -1,5 +1,5 @@
/* SPDX-License-Identifier: BSD-3-Clause
- * Copyright(c) 2019-2021 Broadcom
+ * Copyright(c) 2019-2023 Broadcom
* All rights reserved.
*/
@@ -1,5 +1,5 @@
/* SPDX-License-Identifier: BSD-3-Clause
- * Copyright(c) 2019-2021 Broadcom
+ * Copyright(c) 2019-2023 Broadcom
* All rights reserved.
*/
@@ -296,11 +296,15 @@ tf_dev_p4_get_tcam_slice_info(struct tf *tfp,
return rc;
/* Single slice support */
-#define CFA_P4_WC_TCAM_SLICE_SIZE 12
-
+#define CFA_P4_WC_TCAM_SLICE_SIZE (12)
if (type == TF_TCAM_TBL_TYPE_WC_TCAM) {
- *num_slices_per_row = tfs->wc_num_slices_per_row;
- if (key_sz > *num_slices_per_row * CFA_P4_WC_TCAM_SLICE_SIZE)
+ if (key_sz <= 1 * CFA_P4_WC_TCAM_SLICE_SIZE)
+ *num_slices_per_row = TF_WC_TCAM_1_SLICE_PER_ROW;
+ else if (key_sz <= 2 * CFA_P4_WC_TCAM_SLICE_SIZE)
+ *num_slices_per_row = TF_WC_TCAM_2_SLICE_PER_ROW;
+ else if (key_sz <= 4 * CFA_P4_WC_TCAM_SLICE_SIZE)
+ *num_slices_per_row = TF_WC_TCAM_4_SLICE_PER_ROW;
+ else
return -ENOTSUP;
} else { /* for other type of tcam */
*num_slices_per_row = 1;
@@ -1,5 +1,5 @@
/* SPDX-License-Identifier: BSD-3-Clause
- * Copyright(c) 2019-2021 Broadcom
+ * Copyright(c) 2019-2023 Broadcom
* All rights reserved.
*/
@@ -16,6 +16,7 @@
#include "tfp.h"
#include "tf_msg_common.h"
#include "tf_tbl_sram.h"
+#include "tf_util.h"
#define TF_DEV_P58_PARIF_MAX 16
#define TF_DEV_P58_PF_MASK 0xfUL
@@ -79,33 +80,39 @@ struct tf_rm_element_cfg tf_tbl_p58[TF_DIR_MAX][TF_TBL_TYPE_MAX] = {
[TF_DIR_RX][TF_TBL_TYPE_FULL_ACT_RECORD] = {
.cfg_type = TF_RM_ELEM_CFG_HCAPI_BA_PARENT,
.hcapi_type = CFA_RESOURCE_TYPE_P58_SRAM_BANK_1,
- .slices = 4,
+ .slices = 8,
},
[TF_DIR_RX][TF_TBL_TYPE_COMPACT_ACT_RECORD] = {
.cfg_type = TF_RM_ELEM_CFG_HCAPI_BA_CHILD,
.parent_subtype = TF_TBL_TYPE_FULL_ACT_RECORD,
.hcapi_type = CFA_RESOURCE_TYPE_P58_SRAM_BANK_1,
- .slices = 8,
+ .slices = 16,
},
/* Policy - Encaps in bank 2 */
[TF_DIR_RX][TF_TBL_TYPE_ACT_ENCAP_8B] = {
.cfg_type = TF_RM_ELEM_CFG_HCAPI_BA_PARENT,
.hcapi_type = CFA_RESOURCE_TYPE_P58_SRAM_BANK_2,
- .slices = 8,
+ .slices = 16,
},
[TF_DIR_RX][TF_TBL_TYPE_ACT_ENCAP_16B] = {
.cfg_type = TF_RM_ELEM_CFG_HCAPI_BA_CHILD,
.parent_subtype = TF_TBL_TYPE_ACT_ENCAP_8B,
.hcapi_type = CFA_RESOURCE_TYPE_P58_SRAM_BANK_2,
- .slices = 4,
+ .slices = 8,
},
[TF_DIR_RX][TF_TBL_TYPE_ACT_ENCAP_32B] = {
.cfg_type = TF_RM_ELEM_CFG_HCAPI_BA_CHILD,
.parent_subtype = TF_TBL_TYPE_ACT_ENCAP_8B,
.hcapi_type = CFA_RESOURCE_TYPE_P58_SRAM_BANK_2,
- .slices = 2,
+ .slices = 4,
},
[TF_DIR_RX][TF_TBL_TYPE_ACT_ENCAP_64B] = {
+ .cfg_type = TF_RM_ELEM_CFG_HCAPI_BA_CHILD,
+ .parent_subtype = TF_TBL_TYPE_ACT_ENCAP_8B,
+ .hcapi_type = CFA_RESOURCE_TYPE_P58_SRAM_BANK_2,
+ .slices = 2,
+ },
+ [TF_DIR_RX][TF_TBL_TYPE_ACT_ENCAP_128B] = {
.cfg_type = TF_RM_ELEM_CFG_HCAPI_BA_CHILD,
.parent_subtype = TF_TBL_TYPE_ACT_ENCAP_8B,
.hcapi_type = CFA_RESOURCE_TYPE_P58_SRAM_BANK_2,
@@ -116,49 +123,49 @@ struct tf_rm_element_cfg tf_tbl_p58[TF_DIR_MAX][TF_TBL_TYPE_MAX] = {
.cfg_type = TF_RM_ELEM_CFG_HCAPI_BA_CHILD,
.parent_subtype = TF_TBL_TYPE_ACT_ENCAP_8B,
.hcapi_type = CFA_RESOURCE_TYPE_P58_SRAM_BANK_2,
- .slices = 8,
+ .slices = 16,
},
[TF_DIR_RX][TF_TBL_TYPE_ACT_MODIFY_16B] = {
.cfg_type = TF_RM_ELEM_CFG_HCAPI_BA_CHILD,
.parent_subtype = TF_TBL_TYPE_ACT_ENCAP_8B,
.hcapi_type = CFA_RESOURCE_TYPE_P58_SRAM_BANK_2,
- .slices = 4,
+ .slices = 8,
},
[TF_DIR_RX][TF_TBL_TYPE_ACT_MODIFY_32B] = {
.cfg_type = TF_RM_ELEM_CFG_HCAPI_BA_CHILD,
.parent_subtype = TF_TBL_TYPE_ACT_ENCAP_8B,
.hcapi_type = CFA_RESOURCE_TYPE_P58_SRAM_BANK_2,
- .slices = 2,
+ .slices = 4,
},
[TF_DIR_RX][TF_TBL_TYPE_ACT_MODIFY_64B] = {
.cfg_type = TF_RM_ELEM_CFG_HCAPI_BA_CHILD,
.parent_subtype = TF_TBL_TYPE_ACT_ENCAP_8B,
.hcapi_type = CFA_RESOURCE_TYPE_P58_SRAM_BANK_2,
- .slices = 1,
+ .slices = 2,
},
/* Policy - SP in bank 0 */
[TF_DIR_RX][TF_TBL_TYPE_ACT_SP_SMAC] = {
.cfg_type = TF_RM_ELEM_CFG_HCAPI_BA_PARENT,
.hcapi_type = CFA_RESOURCE_TYPE_P58_SRAM_BANK_0,
- .slices = 8,
+ .slices = 16,
},
[TF_DIR_RX][TF_TBL_TYPE_ACT_SP_SMAC_IPV4] = {
.cfg_type = TF_RM_ELEM_CFG_HCAPI_BA_CHILD,
.parent_subtype = TF_TBL_TYPE_ACT_SP_SMAC,
.hcapi_type = CFA_RESOURCE_TYPE_P58_SRAM_BANK_0,
- .slices = 4,
+ .slices = 8,
},
[TF_DIR_RX][TF_TBL_TYPE_ACT_SP_SMAC_IPV6] = {
.cfg_type = TF_RM_ELEM_CFG_HCAPI_BA_CHILD,
.parent_subtype = TF_TBL_TYPE_ACT_SP_SMAC,
.hcapi_type = CFA_RESOURCE_TYPE_P58_SRAM_BANK_0,
- .slices = 2,
+ .slices = 4,
},
/* Policy - Stats in bank 3 */
[TF_DIR_RX][TF_TBL_TYPE_ACT_STATS_64] = {
.cfg_type = TF_RM_ELEM_CFG_HCAPI_BA_PARENT,
.hcapi_type = CFA_RESOURCE_TYPE_P58_SRAM_BANK_3,
- .slices = 8,
+ .slices = 16,
},
[TF_DIR_TX][TF_TBL_TYPE_EM_FKB] = {
TF_RM_ELEM_CFG_HCAPI_BA, CFA_RESOURCE_TYPE_P58_EM_FKB,
@@ -192,33 +199,39 @@ struct tf_rm_element_cfg tf_tbl_p58[TF_DIR_MAX][TF_TBL_TYPE_MAX] = {
[TF_DIR_TX][TF_TBL_TYPE_FULL_ACT_RECORD] = {
.cfg_type = TF_RM_ELEM_CFG_HCAPI_BA_PARENT,
.hcapi_type = CFA_RESOURCE_TYPE_P58_SRAM_BANK_1,
- .slices = 4,
+ .slices = 8,
},
[TF_DIR_TX][TF_TBL_TYPE_COMPACT_ACT_RECORD] = {
.cfg_type = TF_RM_ELEM_CFG_HCAPI_BA_CHILD,
.parent_subtype = TF_TBL_TYPE_FULL_ACT_RECORD,
.hcapi_type = CFA_RESOURCE_TYPE_P58_SRAM_BANK_1,
- .slices = 8,
+ .slices = 16,
},
/* Policy - Encaps in bank 2 */
[TF_DIR_TX][TF_TBL_TYPE_ACT_ENCAP_8B] = {
.cfg_type = TF_RM_ELEM_CFG_HCAPI_BA_PARENT,
.hcapi_type = CFA_RESOURCE_TYPE_P58_SRAM_BANK_2,
- .slices = 8,
+ .slices = 16,
},
[TF_DIR_TX][TF_TBL_TYPE_ACT_ENCAP_16B] = {
.cfg_type = TF_RM_ELEM_CFG_HCAPI_BA_CHILD,
.parent_subtype = TF_TBL_TYPE_ACT_ENCAP_8B,
.hcapi_type = CFA_RESOURCE_TYPE_P58_SRAM_BANK_2,
- .slices = 4,
+ .slices = 8,
},
[TF_DIR_TX][TF_TBL_TYPE_ACT_ENCAP_32B] = {
.cfg_type = TF_RM_ELEM_CFG_HCAPI_BA_CHILD,
.parent_subtype = TF_TBL_TYPE_ACT_ENCAP_8B,
.hcapi_type = CFA_RESOURCE_TYPE_P58_SRAM_BANK_2,
- .slices = 2,
+ .slices = 4,
},
[TF_DIR_TX][TF_TBL_TYPE_ACT_ENCAP_64B] = {
+ .cfg_type = TF_RM_ELEM_CFG_HCAPI_BA_CHILD,
+ .parent_subtype = TF_TBL_TYPE_ACT_ENCAP_8B,
+ .hcapi_type = CFA_RESOURCE_TYPE_P58_SRAM_BANK_2,
+ .slices = 2,
+ },
+ [TF_DIR_TX][TF_TBL_TYPE_ACT_ENCAP_128B] = {
.cfg_type = TF_RM_ELEM_CFG_HCAPI_BA_CHILD,
.parent_subtype = TF_TBL_TYPE_ACT_ENCAP_8B,
.hcapi_type = CFA_RESOURCE_TYPE_P58_SRAM_BANK_2,
@@ -229,49 +242,49 @@ struct tf_rm_element_cfg tf_tbl_p58[TF_DIR_MAX][TF_TBL_TYPE_MAX] = {
.cfg_type = TF_RM_ELEM_CFG_HCAPI_BA_CHILD,
.parent_subtype = TF_TBL_TYPE_ACT_ENCAP_8B,
.hcapi_type = CFA_RESOURCE_TYPE_P58_SRAM_BANK_2,
- .slices = 8,
+ .slices = 16,
},
[TF_DIR_TX][TF_TBL_TYPE_ACT_MODIFY_16B] = {
.cfg_type = TF_RM_ELEM_CFG_HCAPI_BA_CHILD,
.parent_subtype = TF_TBL_TYPE_ACT_ENCAP_8B,
.hcapi_type = CFA_RESOURCE_TYPE_P58_SRAM_BANK_2,
- .slices = 4,
+ .slices = 8,
},
[TF_DIR_TX][TF_TBL_TYPE_ACT_MODIFY_32B] = {
.cfg_type = TF_RM_ELEM_CFG_HCAPI_BA_CHILD,
.parent_subtype = TF_TBL_TYPE_ACT_ENCAP_8B,
.hcapi_type = CFA_RESOURCE_TYPE_P58_SRAM_BANK_2,
- .slices = 2,
+ .slices = 4,
},
[TF_DIR_TX][TF_TBL_TYPE_ACT_MODIFY_64B] = {
.cfg_type = TF_RM_ELEM_CFG_HCAPI_BA_CHILD,
.parent_subtype = TF_TBL_TYPE_ACT_ENCAP_8B,
.hcapi_type = CFA_RESOURCE_TYPE_P58_SRAM_BANK_2,
- .slices = 1,
+ .slices = 2,
},
/* Policy - SP in bank 0 */
[TF_DIR_TX][TF_TBL_TYPE_ACT_SP_SMAC] = {
.cfg_type = TF_RM_ELEM_CFG_HCAPI_BA_PARENT,
.hcapi_type = CFA_RESOURCE_TYPE_P58_SRAM_BANK_0,
- .slices = 8,
+ .slices = 16,
},
[TF_DIR_TX][TF_TBL_TYPE_ACT_SP_SMAC_IPV4] = {
.cfg_type = TF_RM_ELEM_CFG_HCAPI_BA_CHILD,
.parent_subtype = TF_TBL_TYPE_ACT_SP_SMAC,
.hcapi_type = CFA_RESOURCE_TYPE_P58_SRAM_BANK_0,
- .slices = 4,
+ .slices = 8,
},
[TF_DIR_TX][TF_TBL_TYPE_ACT_SP_SMAC_IPV6] = {
.cfg_type = TF_RM_ELEM_CFG_HCAPI_BA_CHILD,
.parent_subtype = TF_TBL_TYPE_ACT_SP_SMAC,
.hcapi_type = CFA_RESOURCE_TYPE_P58_SRAM_BANK_0,
- .slices = 2,
+ .slices = 4,
},
/* Policy - Stats in bank 3 */
[TF_DIR_TX][TF_TBL_TYPE_ACT_STATS_64] = {
.cfg_type = TF_RM_ELEM_CFG_HCAPI_BA_PARENT,
.hcapi_type = CFA_RESOURCE_TYPE_P58_SRAM_BANK_3,
- .slices = 8,
+ .slices = 16,
},
};
@@ -406,10 +419,15 @@ tf_dev_p58_get_tcam_slice_info(struct tf *tfp,
if (rc)
return rc;
-#define CFA_P58_WC_TCAM_SLICE_SIZE 24
+#define CFA_P58_WC_TCAM_SLICE_SIZE (24)
if (type == TF_TCAM_TBL_TYPE_WC_TCAM) {
- *num_slices_per_row = tfs->wc_num_slices_per_row;
- if (key_sz > *num_slices_per_row * CFA_P58_WC_TCAM_SLICE_SIZE)
+ if (key_sz <= 1 * CFA_P58_WC_TCAM_SLICE_SIZE)
+ *num_slices_per_row = TF_WC_TCAM_1_SLICE_PER_ROW;
+ else if (key_sz <= 2 * CFA_P58_WC_TCAM_SLICE_SIZE)
+ *num_slices_per_row = TF_WC_TCAM_2_SLICE_PER_ROW;
+ else if (key_sz <= 4 * CFA_P58_WC_TCAM_SLICE_SIZE)
+ *num_slices_per_row = TF_WC_TCAM_4_SLICE_PER_ROW;
+ else
return -ENOTSUP;
} else { /* for other type of tcam */
*num_slices_per_row = 1;
@@ -452,6 +470,7 @@ static int tf_dev_p58_get_shared_tbl_increment(struct tf *tfp __rte_unused,
case TF_TBL_TYPE_ACT_ENCAP_16B:
case TF_TBL_TYPE_ACT_ENCAP_32B:
case TF_TBL_TYPE_ACT_ENCAP_64B:
+ case TF_TBL_TYPE_ACT_ENCAP_128B:
case TF_TBL_TYPE_ACT_SP_SMAC:
case TF_TBL_TYPE_ACT_SP_SMAC_IPV4:
case TF_TBL_TYPE_ACT_SP_SMAC_IPV6:
@@ -461,7 +480,7 @@ static int tf_dev_p58_get_shared_tbl_increment(struct tf *tfp __rte_unused,
case TF_TBL_TYPE_ACT_MODIFY_16B:
case TF_TBL_TYPE_ACT_MODIFY_32B:
case TF_TBL_TYPE_ACT_MODIFY_64B:
- parms->increment_cnt = 8;
+ parms->increment_cnt = 16;
break;
default:
parms->increment_cnt = 1;
@@ -493,6 +512,7 @@ static bool tf_dev_p58_is_sram_managed(struct tf *tfp __rte_unused,
case TF_TBL_TYPE_ACT_ENCAP_16B:
case TF_TBL_TYPE_ACT_ENCAP_32B:
case TF_TBL_TYPE_ACT_ENCAP_64B:
+ case TF_TBL_TYPE_ACT_ENCAP_128B:
case TF_TBL_TYPE_ACT_SP_SMAC:
case TF_TBL_TYPE_ACT_SP_SMAC_IPV4:
case TF_TBL_TYPE_ACT_SP_SMAC_IPV6:
@@ -527,7 +547,7 @@ static bool tf_dev_p58_is_sram_managed(struct tf *tfp __rte_unused,
*
* [in/out] shift
* Pointer to the factor to be used as a multiplier to translate
- * between the RM units to the user address. SRAM manages 64B entries
+ * between the RM units to the user address. SRAM manages 128B entries
* Addresses must be shifted to an 8B address.
*
* Returns
@@ -1000,8 +1000,8 @@ tf_em_ext_common_unbind(struct tf *tfp)
strerror(-rc));
return rc;
}
- ext_db = (struct em_ext_db *)ext_ptr;
+ ext_db = (struct em_ext_db *)ext_ptr;
if (ext_db != NULL) {
entry = ext_db->tbl_scope_ll.head;
while (entry != NULL) {
@@ -7,7 +7,6 @@
#include <rte_common.h>
#include <rte_errno.h>
#include <rte_log.h>
-
#include "tf_core.h"
#include "tf_util.h"
#include "tf_common.h"
@@ -63,7 +62,6 @@ tf_em_insert_int_entry(struct tf *tfp,
return -1;
}
-
rptr_index = index;
rc = tf_msg_insert_em_internal_entry(tfp,
parms,
@@ -75,6 +73,7 @@ tf_em_insert_int_entry(struct tf *tfp,
dpool_free(pool, index);
return -1;
}
+
TF_SET_GFID(gfid,
((rptr_index << TF_EM_INTERNAL_INDEX_SHIFT) |
rptr_entry),
@@ -95,7 +94,6 @@ tf_em_insert_int_entry(struct tf *tfp,
return 0;
}
-
/** Delete EM internal entry API
*
* returns:
@@ -253,7 +251,6 @@ tf_em_int_bind(struct tf *tfp,
return db_rc[TF_DIR_RX];
}
-
if (!tf_session_is_shared_session(tfs)) {
for (i = 0; i < TF_DIR_MAX; i++) {
iparms.rm_db = em_db->em_db[i];
@@ -335,11 +332,10 @@ tf_em_int_unbind(struct tf *tfp)
}
rc = tf_session_get_db(tfp, TF_MODULE_TYPE_EM, &em_db_ptr);
- if (rc) {
+ if (rc)
return 0;
- }
- em_db = (struct em_rm_db *)em_db_ptr;
+ em_db = (struct em_rm_db *)em_db_ptr;
for (i = 0; i < TF_DIR_MAX; i++) {
if (em_db->em_db[i] == NULL)
continue;
@@ -89,6 +89,7 @@ tf_ident_unbind(struct tf *tfp)
rc = tf_session_get_db(tfp, TF_MODULE_TYPE_IDENTIFIER, &ident_db_ptr);
if (rc)
return 0;
+
ident_db = (struct ident_rm_db *)ident_db_ptr;
for (i = 0; i < TF_DIR_MAX; i++) {
@@ -1,5 +1,5 @@
/* SPDX-License-Identifier: BSD-3-Clause
- * Copyright(c) 2019-2021 Broadcom
+ * Copyright(c) 2019-2023 Broadcom
* All rights reserved.
*/
@@ -21,12 +21,6 @@ struct tf_if_tbl_db {
struct tf_if_tbl_cfg *if_tbl_cfg_db[TF_DIR_MAX];
};
-/**
- * Init flag, set on bind and cleared on unbind
- * TODO: Store this data in session db
- */
-static uint8_t init;
-
/**
* Convert if_tbl_type to hwrm type.
*
@@ -80,8 +74,6 @@ tf_if_tbl_bind(struct tf *tfp,
if_tbl_db->if_tbl_cfg_db[TF_DIR_TX] = parms->cfg;
tf_session_set_if_tbl_db(tfp, (void *)if_tbl_db);
- init = 1;
-
TFP_DRV_LOG(INFO,
"Table Type - initialized\n");
@@ -92,14 +84,7 @@ int
tf_if_tbl_unbind(struct tf *tfp)
{
int rc;
- struct tf_if_tbl_db *if_tbl_db_ptr;
-
- /* Bail if nothing has been initialized */
- if (!init) {
- TFP_DRV_LOG(INFO,
- "No Table DBs created\n");
- return 0;
- }
+ struct tf_if_tbl_db *if_tbl_db_ptr = NULL;
TF_CHECK_PARMS1(tfp);
@@ -108,9 +93,15 @@ tf_if_tbl_unbind(struct tf *tfp)
TFP_DRV_LOG(INFO, "No IF Table DBs initialized\n");
return 0;
}
+ /* Bail if nothing has been initialized */
+ if (!if_tbl_db_ptr) {
+ TFP_DRV_LOG(INFO,
+ "No Table DBs created\n");
+ return 0;
+ }
tfp_free((void *)if_tbl_db_ptr);
- init = 0;
+ tf_session_set_if_tbl_db(tfp, NULL);
return 0;
}
@@ -120,24 +111,24 @@ tf_if_tbl_set(struct tf *tfp,
struct tf_if_tbl_set_parms *parms)
{
int rc;
- struct tf_if_tbl_db *if_tbl_db_ptr;
+ struct tf_if_tbl_db *if_tbl_db_ptr = NULL;
struct tf_if_tbl_get_hcapi_parms hparms;
TF_CHECK_PARMS3(tfp, parms, parms->data);
- if (!init) {
- TFP_DRV_LOG(ERR,
- "%s: No Table DBs created\n",
- tf_dir_2_str(parms->dir));
- return -EINVAL;
- }
-
rc = tf_session_get_if_tbl_db(tfp, (void **)&if_tbl_db_ptr);
if (rc) {
TFP_DRV_LOG(INFO, "No IF Table DBs initialized\n");
return 0;
}
+ if (!if_tbl_db_ptr) {
+ TFP_DRV_LOG(ERR,
+ "%s: No Table DBs created\n",
+ tf_dir_2_str(parms->dir));
+ return -EINVAL;
+ }
+
/* Convert TF type to HCAPI type */
hparms.tbl_db = if_tbl_db_ptr->if_tbl_cfg_db[parms->dir];
hparms.db_index = parms->type;
@@ -163,24 +154,24 @@ tf_if_tbl_get(struct tf *tfp,
struct tf_if_tbl_get_parms *parms)
{
int rc = 0;
- struct tf_if_tbl_db *if_tbl_db_ptr;
+ struct tf_if_tbl_db *if_tbl_db_ptr = NULL;
struct tf_if_tbl_get_hcapi_parms hparms;
TF_CHECK_PARMS3(tfp, parms, parms->data);
- if (!init) {
- TFP_DRV_LOG(ERR,
- "%s: No Table DBs created\n",
- tf_dir_2_str(parms->dir));
- return -EINVAL;
- }
-
rc = tf_session_get_if_tbl_db(tfp, (void **)&if_tbl_db_ptr);
if (rc) {
TFP_DRV_LOG(INFO, "No IF Table DBs initialized\n");
return 0;
}
+ if (!if_tbl_db_ptr) {
+ TFP_DRV_LOG(ERR,
+ "%s: No Table DBs created\n",
+ tf_dir_2_str(parms->dir));
+ return -EINVAL;
+ }
+
/* Convert TF type to HCAPI type */
hparms.tbl_db = if_tbl_db_ptr->if_tbl_cfg_db[parms->dir];
hparms.db_index = parms->type;
@@ -1,5 +1,5 @@
/* SPDX-License-Identifier: BSD-3-Clause
- * Copyright(c) 2019-2021 Broadcom
+ * Copyright(c) 2019-2023 Broadcom
* All rights reserved.
*/
@@ -47,7 +47,6 @@ static_assert(sizeof(struct hwrm_tf_global_cfg_set_input) ==
static_assert(sizeof(struct hwrm_tf_em_insert_input) ==
TF_MSG_SIZE_HWRM_TF_EM_INSERT,
"HWRM message size changed: hwrm_tf_em_insert_input");
-
#define TF_MSG_SIZE_HWRM_TF_TBL_TYPE_SET 128
static_assert(sizeof(struct hwrm_tf_tbl_type_set_input) ==
TF_MSG_SIZE_HWRM_TF_TBL_TYPE_SET,
@@ -61,13 +60,18 @@ static_assert(sizeof(struct hwrm_tf_tbl_type_set_input) ==
/**
* This is the length of shared session name "tf_share"
*/
-#define TF_SHARED_SESSION_NAME_LEN 8
+#define TF_SHARED_SESSION_NAME_LEN 9
/**
* This is the length of tcam shared session name "tf_shared-wc_tcam"
*/
#define TF_TCAM_SHARED_SESSION_NAME_LEN 17
+/**
+ * This is the length of tcam shared session name "tf_shared-poolx"
+ */
+#define TF_POOL_SHARED_SESSION_NAME_LEN 16
+
/**
* If data bigger than TF_PCI_BUF_SIZE_MAX then use DMA method
*/
@@ -135,18 +139,30 @@ tf_msg_session_open(struct bnxt *bp,
struct hwrm_tf_session_open_input req = { 0 };
struct hwrm_tf_session_open_output resp = { 0 };
struct tfp_send_msg_parms parms = { 0 };
- int name_len;
char *session_name;
char *tcam_session_name;
+ char *pool_session_name;
- /* Populate the request */
- name_len = strnlen(ctrl_chan_name, TF_SESSION_NAME_MAX);
- session_name = &ctrl_chan_name[name_len - strlen("tf_shared")];
- tcam_session_name = &ctrl_chan_name[name_len - strlen("tf_shared-wc_tcam")];
- if (!strncmp(tcam_session_name, "tf_shared-wc_tcam", strlen("tf_shared-wc_tcam")))
- tfp_memcpy(&req.session_name, tcam_session_name, TF_TCAM_SHARED_SESSION_NAME_LEN);
- else if (!strncmp(session_name, "tf_shared", strlen("tf_shared")))
- tfp_memcpy(&req.session_name, session_name, TF_SHARED_SESSION_NAME_LEN);
+ /*
+ * "tf_shared-wc_tcam" is defined for tf_fw version 1.0.0.
+ * "tf_shared-pool" is defined for version 1.0.1.
+ * "tf_shared" is used by both verions.
+ */
+ tcam_session_name = strstr(ctrl_chan_name, "tf_shared-wc_tcam");
+ pool_session_name = strstr(ctrl_chan_name, "tf_shared-pool");
+ session_name = strstr(ctrl_chan_name, "tf_shared");
+ if (tcam_session_name)
+ tfp_memcpy(&req.session_name,
+ tcam_session_name,
+ TF_TCAM_SHARED_SESSION_NAME_LEN);
+ else if (pool_session_name)
+ tfp_memcpy(&req.session_name,
+ pool_session_name,
+ TF_POOL_SHARED_SESSION_NAME_LEN);
+ else if (session_name)
+ tfp_memcpy(&req.session_name,
+ session_name,
+ TF_SHARED_SESSION_NAME_LEN);
else
tfp_memcpy(&req.session_name, ctrl_chan_name, TF_SESSION_NAME_MAX);
@@ -191,9 +207,9 @@ tf_msg_session_client_register(struct tf *tfp,
struct tfp_send_msg_parms parms = { 0 };
uint8_t fw_session_id;
struct tf_dev_info *dev;
- int name_len;
char *session_name;
char *tcam_session_name;
+ char *pool_session_name;
/* Retrieve the device information */
rc = tf_session_get_device(tfs, &dev);
@@ -214,24 +230,31 @@ tf_msg_session_client_register(struct tf *tfp,
/* Populate the request */
req.fw_session_id = tfp_cpu_to_le_32(fw_session_id);
- name_len = strnlen(ctrl_channel_name, TF_SESSION_NAME_MAX);
- session_name = &ctrl_channel_name[name_len - strlen("tf_shared")];
- tcam_session_name = &ctrl_channel_name[name_len -
- strlen("tf_shared-wc_tcam")];
- if (!strncmp(tcam_session_name,
- "tf_shared-wc_tcam",
- strlen("tf_shared-wc_tcam")))
+
+ /*
+ * "tf_shared-wc_tcam" is defined for tf_fw version 1.0.0.
+ * "tf_shared-pool" is defined for version 1.0.1.
+ * "tf_shared" is used by both verions.
+ */
+ tcam_session_name = strstr(ctrl_channel_name, "tf_shared-wc_tcam");
+ pool_session_name = strstr(ctrl_channel_name, "tf_shared-pool");
+ session_name = strstr(ctrl_channel_name, "tf_shared");
+ if (tcam_session_name)
+ tfp_memcpy(&req.session_client_name,
+ tcam_session_name,
+ TF_TCAM_SHARED_SESSION_NAME_LEN);
+ else if (pool_session_name)
tfp_memcpy(&req.session_client_name,
- tcam_session_name,
- TF_TCAM_SHARED_SESSION_NAME_LEN);
- else if (!strncmp(session_name, "tf_shared", strlen("tf_shared")))
+ pool_session_name,
+ TF_POOL_SHARED_SESSION_NAME_LEN);
+ else if (session_name)
tfp_memcpy(&req.session_client_name,
- session_name,
- TF_SHARED_SESSION_NAME_LEN);
+ session_name,
+ TF_SHARED_SESSION_NAME_LEN);
else
tfp_memcpy(&req.session_client_name,
- ctrl_channel_name,
- TF_SESSION_NAME_MAX);
+ ctrl_channel_name,
+ TF_SESSION_NAME_MAX);
parms.tf_type = HWRM_TF_SESSION_REGISTER;
parms.req_data = (uint32_t *)&req;
@@ -431,7 +454,6 @@ tf_msg_session_resc_qcaps(struct tf *tfp,
/* Post process the response */
data = (struct tf_rm_resc_req_entry *)qcaps_buf.va_addr;
-
for (i = 0; i < resp.size; i++) {
query[i].type = tfp_le_to_cpu_32(data[i].type);
query[i].min = tfp_le_to_cpu_16(data[i].min);
@@ -1757,6 +1779,7 @@ tf_msg_set_tbl_entry(struct tf *tfp,
struct hwrm_tf_tbl_type_set_input req = { 0 };
struct hwrm_tf_tbl_type_set_output resp = { 0 };
struct tfp_send_msg_parms parms = { 0 };
+ struct tf_msg_dma_buf buf = { 0 };
uint8_t fw_session_id;
struct tf_dev_info *dev;
struct tf_session *tfs;
@@ -1802,18 +1825,19 @@ tf_msg_set_tbl_entry(struct tf *tfp,
/* Check for data size conformity */
if (size > TF_MSG_TBL_TYPE_SET_DATA_SIZE) {
- rc = -EINVAL;
- TFP_DRV_LOG(ERR,
- "%s: Invalid parameters for msg type, rc:%s\n",
- tf_dir_2_str(dir),
- strerror(-rc));
- return rc;
+ /* use dma buffer */
+ req.flags |= HWRM_TF_TBL_TYPE_SET_INPUT_FLAGS_DMA;
+ rc = tf_msg_alloc_dma_buf(&buf, size);
+ if (rc)
+ goto cleanup;
+ tfp_memcpy(buf.va_addr, data, size);
+ tfp_memcpy(&req.data[0],
+ &buf.pa_addr,
+ sizeof(buf.pa_addr));
+ } else {
+ tfp_memcpy(&req.data, data, size);
}
- tfp_memcpy(&req.data,
- data,
- size);
-
parms.tf_type = HWRM_TF_TBL_TYPE_SET;
parms.req_data = (uint32_t *)&req;
parms.req_size = sizeof(req);
@@ -1823,10 +1847,10 @@ tf_msg_set_tbl_entry(struct tf *tfp,
rc = tfp_send_msg_direct(tf_session_get_bp(tfp),
&parms);
- if (rc)
- return rc;
+cleanup:
+ tf_msg_free_dma_buf(&buf);
- return 0;
+ return rc;
}
int
@@ -2325,3 +2349,114 @@ tf_msg_get_version(struct bnxt *bp,
return rc;
}
+
+int
+tf_msg_session_set_hotup_state(struct tf *tfp, uint16_t state)
+{
+ int rc;
+ struct hwrm_tf_session_hotup_state_set_input req = { 0 };
+ struct hwrm_tf_session_hotup_state_set_output resp = { 0 };
+ struct tfp_send_msg_parms parms = { 0 };
+ uint8_t fw_session_id;
+ struct tf_dev_info *dev;
+ struct tf_session *tfs;
+
+ /* Retrieve the session information */
+ rc = tf_session_get_session_internal(tfp, &tfs);
+ if (rc) {
+ TFP_DRV_LOG(ERR,
+ "Failed to lookup session, rc:%s\n",
+ strerror(-rc));
+ return rc;
+ }
+
+ /* Retrieve the device information */
+ rc = tf_session_get_device(tfs, &dev);
+ if (rc) {
+ TFP_DRV_LOG(ERR,
+ "Failed to lookup device, rc:%s\n",
+ strerror(-rc));
+ return rc;
+ }
+
+ rc = tf_session_get_fw_session_id(tfp, &fw_session_id);
+ if (rc) {
+ TFP_DRV_LOG(ERR,
+ "Unable to lookup FW id, rc:%s\n",
+ strerror(-rc));
+ return rc;
+ }
+
+ /* Populate the request */
+ req.fw_session_id = tfp_cpu_to_le_32(fw_session_id);
+ req.state = tfp_cpu_to_le_16(state);
+
+ parms.tf_type = HWRM_TF_SESSION_HOTUP_STATE_SET;
+ parms.req_data = (uint32_t *)&req;
+ parms.req_size = sizeof(req);
+ parms.resp_data = (uint32_t *)&resp;
+ parms.resp_size = sizeof(resp);
+ parms.mailbox = dev->ops->tf_dev_get_mailbox();
+
+ rc = tfp_send_msg_direct(tf_session_get_bp(tfp),
+ &parms);
+ return rc;
+}
+
+int
+tf_msg_session_get_hotup_state(struct tf *tfp,
+ uint16_t *state,
+ uint16_t *ref_cnt)
+{
+ int rc;
+ struct hwrm_tf_session_hotup_state_get_input req = { 0 };
+ struct hwrm_tf_session_hotup_state_get_output resp = { 0 };
+ struct tfp_send_msg_parms parms = { 0 };
+ uint8_t fw_session_id;
+ struct tf_dev_info *dev;
+ struct tf_session *tfs;
+
+ /* Retrieve the session information */
+ rc = tf_session_get_session_internal(tfp, &tfs);
+ if (rc) {
+ TFP_DRV_LOG(ERR,
+ "Failed to lookup session, rc:%s\n",
+ strerror(-rc));
+ return rc;
+ }
+
+ /* Retrieve the device information */
+ rc = tf_session_get_device(tfs, &dev);
+ if (rc) {
+ TFP_DRV_LOG(ERR,
+ "Failed to lookup device, rc:%s\n",
+ strerror(-rc));
+ return rc;
+ }
+
+ rc = tf_session_get_fw_session_id(tfp, &fw_session_id);
+ if (rc) {
+ TFP_DRV_LOG(ERR,
+ "Unable to lookup FW id, rc:%s\n",
+ strerror(-rc));
+ return rc;
+ }
+
+ /* Populate the request */
+ req.fw_session_id = tfp_cpu_to_le_32(fw_session_id);
+
+ parms.tf_type = HWRM_TF_SESSION_HOTUP_STATE_GET;
+ parms.req_data = (uint32_t *)&req;
+ parms.req_size = sizeof(req);
+ parms.resp_data = (uint32_t *)&resp;
+ parms.resp_size = sizeof(resp);
+ parms.mailbox = dev->ops->tf_dev_get_mailbox();
+
+ rc = tfp_send_msg_direct(tf_session_get_bp(tfp),
+ &parms);
+
+ *state = tfp_le_to_cpu_16(resp.state);
+ *ref_cnt = tfp_le_to_cpu_16(resp.ref_cnt);
+
+ return rc;
+}
@@ -1,5 +1,5 @@
/* SPDX-License-Identifier: BSD-3-Clause
- * Copyright(c) 2019-2021 Broadcom
+ * Copyright(c) 2019-2023 Broadcom
* All rights reserved.
*/
@@ -761,4 +761,40 @@ int
tf_msg_get_version(struct bnxt *bp,
struct tf_dev_info *dev,
struct tf_get_version_parms *parms);
+
+/**
+ * Send set hot upgrade state request to the firmware.
+ *
+ * [in] tfp
+ * Pointer to session handle
+ *
+ * [in] state
+ * Hot upgrade session state
+ *
+ * Returns:
+ * 0 on Success else internal Truflow error
+ */
+int
+tf_msg_session_set_hotup_state(struct tf *tfp,
+ uint16_t state);
+
+/**
+ * Send get hot upgrade state request to the firmware.
+ *
+ * [in] tfp
+ * Pointer to session handle
+ *
+ * [out] state
+ * Pointer to hot upgrade session state
+ *
+ * [out] ref_cnt
+ * Pointer to hot upgrade session reference count
+ *
+ * Returns:
+ * 0 on Success else internal Truflow error
+ */
+int
+tf_msg_session_get_hotup_state(struct tf *tfp,
+ uint16_t *state,
+ uint16_t *ref_cnt);
#endif /* _TF_MSG_H_ */
@@ -1,15 +1,12 @@
/* SPDX-License-Identifier: BSD-3-Clause
- * Copyright(c) 2019-2021 Broadcom
+ * Copyright(c) 2019-2023 Broadcom
* All rights reserved.
*/
#include <string.h>
-
#include <rte_common.h>
#include <rte_debug.h>
-
#include <cfa_resource_types.h>
-
#include "tf_rm.h"
#include "tf_common.h"
#include "tf_util.h"
@@ -18,9 +15,6 @@
#include "tfp.h"
#include "tf_msg.h"
-/* Logging defines */
-#define TF_RM_DEBUG 0
-
/**
* Generic RM Element data type that an RM DB is build upon.
*/
@@ -210,45 +204,6 @@ tf_rm_adjust_index(struct tf_rm_element *db,
return rc;
}
-/**
- * Logs an array of found residual entries to the console.
- *
- * [in] dir
- * Receive or transmit direction
- *
- * [in] module
- * Type of Device Module
- *
- * [in] count
- * Number of entries in the residual array
- *
- * [in] residuals
- * Pointer to an array of residual entries. Array is index same as
- * the DB in which this function is used. Each entry holds residual
- * value for that entry.
- */
-#if (TF_RM_DEBUG == 1)
-static void
-tf_rm_log_residuals(enum tf_dir dir,
- enum tf_module_type module,
- uint16_t count,
- uint16_t *residuals)
-{
- int i;
-
- /* Walk the residual array and log the types that wasn't
- * cleaned up to the console.
- */
- for (i = 0; i < count; i++) {
- if (residuals[i] != 0)
- TFP_DRV_LOG(INFO,
- "%s, %s was not cleaned up, %d outstanding\n",
- tf_dir_2_str(dir),
- tf_module_subtype_2_str(module, i),
- residuals[i]);
- }
-}
-#endif /* TF_RM_DEBUG == 1 */
/**
* Performs a check of the passed in DB for any lingering elements. If
* a resource type was found to not have been cleaned up by the caller
@@ -364,12 +319,6 @@ tf_rm_check_residuals(struct tf_rm_new_db *rm_db,
*resv_size = found;
}
-#if (TF_RM_DEBUG == 1)
- tf_rm_log_residuals(rm_db->dir,
- rm_db->module,
- rm_db->num_entries,
- residuals);
-#endif
tfp_free((void *)residuals);
*resv = local_resv;
@@ -419,7 +368,7 @@ tf_rm_update_parent_reservations(struct tf *tfp,
bool shared_session)
{
int parent, child;
- const char *type_str;
+ const char *type_str = NULL;
/* Search through all the elements */
for (parent = 0; parent < num_elements; parent++) {
@@ -444,11 +393,6 @@ tf_rm_update_parent_reservations(struct tf *tfp,
dev->ops->tf_dev_get_resource_str(tfp,
cfg[parent].hcapi_type,
&type_str);
-#if (TF_RM_DEBUG == 1)
- printf("%s:%s cnt(%d) slices(%d)\n",
- type_str, tf_tbl_type_2_str(parent),
- alloc_cnt[parent], p_slices);
-#endif /* (TF_RM_DEBUG == 1) */
}
/* Search again through all the elements */
@@ -469,13 +413,7 @@ tf_rm_update_parent_reservations(struct tf *tfp,
dev->ops->tf_dev_get_resource_str(tfp,
cfg[child].hcapi_type,
&type_str);
-#if (TF_RM_DEBUG == 1)
- printf("%s:%s cnt(%d) slices(%d)\n",
- type_str,
- tf_tbl_type_2_str(child),
- alloc_cnt[child],
- c_slices);
-#endif /* (TF_RM_DEBUG == 1) */
+
/* Increment the parents combined count
* with each child's count adjusted for
* number of slices per RM alloc item.
@@ -492,10 +430,6 @@ tf_rm_update_parent_reservations(struct tf *tfp,
}
/* Save the parent count to be requested */
req_cnt[parent] = combined_cnt;
-#if (TF_RM_DEBUG == 1)
- printf("%s calculated total:%d\n\n",
- type_str, req_cnt[parent]);
-#endif /* (TF_RM_DEBUG == 1) */
}
}
return 0;
@@ -595,12 +529,6 @@ tf_rm_create_db(struct tf *tfp,
&hcapi_items);
if (hcapi_items == 0) {
-#if (TF_RM_DEBUG == 1)
- TFP_DRV_LOG(INFO,
- "%s: module: %s Empty RM DB create request\n",
- tf_dir_2_str(parms->dir),
- tf_module_2_str(parms->module));
-#endif
parms->rm_db = NULL;
return -ENOMEM;
}
@@ -746,7 +674,7 @@ tf_rm_create_db(struct tf *tfp,
rc = ba_init(db[i].pool,
resv[j].stride,
- !tf_session_is_shared_session(tfs));
+ true);
if (rc) {
TFP_DRV_LOG(ERR,
"%s: Pool init failed, type:%d:%s\n",
@@ -773,13 +701,6 @@ tf_rm_create_db(struct tf *tfp,
rm_db->module = parms->module;
*parms->rm_db = (void *)rm_db;
-#if (TF_RM_DEBUG == 1)
-
- printf("%s: module:%s\n",
- tf_dir_2_str(parms->dir),
- tf_module_2_str(parms->module));
-#endif /* (TF_RM_DEBUG == 1) */
-
tfp_free((void *)req);
tfp_free((void *)resv);
tfp_free((void *)req_cnt);
@@ -812,6 +733,7 @@ tf_rm_create_db_no_reservation(struct tf *tfp,
struct tf_rm_new_db *rm_db;
struct tf_rm_element *db;
uint32_t pool_size;
+ bool shared_session = 0;
TF_CHECK_PARMS2(tfp, parms);
@@ -841,6 +763,16 @@ tf_rm_create_db_no_reservation(struct tf *tfp,
tfp_memcpy(req_cnt, parms->alloc_cnt,
parms->num_elements * sizeof(uint16_t));
+ shared_session = tf_session_is_shared_session(tfs);
+
+ /* Update the req_cnt based upon the element configuration
+ */
+ tf_rm_update_parent_reservations(tfp, dev, parms->cfg,
+ parms->alloc_cnt,
+ parms->num_elements,
+ req_cnt,
+ shared_session);
+
/* Process capabilities against DB requirements. However, as a
* DB can hold elements that are not HCAPI we can reduce the
* req msg content by removing those out of the request yet
@@ -855,11 +787,6 @@ tf_rm_create_db_no_reservation(struct tf *tfp,
&hcapi_items);
if (hcapi_items == 0) {
- TFP_DRV_LOG(ERR,
- "%s: module:%s Empty RM DB create request\n",
- tf_dir_2_str(parms->dir),
- tf_module_2_str(parms->module));
-
parms->rm_db = NULL;
return -ENOMEM;
}
@@ -938,6 +865,7 @@ tf_rm_create_db_no_reservation(struct tf *tfp,
db[i].cfg_type = cfg->cfg_type;
db[i].hcapi_type = cfg->hcapi_type;
+ db[i].slices = cfg->slices;
/* Save the parent subtype for later use to find the pool
*/
@@ -986,7 +914,7 @@ tf_rm_create_db_no_reservation(struct tf *tfp,
rc = ba_init(db[i].pool,
resv[j].stride,
- !tf_session_is_shared_session(tfs));
+ true);
if (rc) {
TFP_DRV_LOG(ERR,
"%s: Pool init failed, type:%d:%s\n",
@@ -1013,13 +941,6 @@ tf_rm_create_db_no_reservation(struct tf *tfp,
rm_db->module = parms->module;
*parms->rm_db = (void *)rm_db;
-#if (TF_RM_DEBUG == 1)
-
- printf("%s: module:%s\n",
- tf_dir_2_str(parms->dir),
- tf_module_2_str(parms->module));
-#endif /* (TF_RM_DEBUG == 1) */
-
tfp_free((void *)req);
tfp_free((void *)resv);
tfp_free((void *)req_cnt);
@@ -1036,6 +957,7 @@ tf_rm_create_db_no_reservation(struct tf *tfp,
return -EINVAL;
}
+
int
tf_rm_free_db(struct tf *tfp,
struct tf_rm_free_db_parms *parms)
@@ -1110,6 +1032,7 @@ tf_rm_free_db(struct tf *tfp,
return rc;
}
+
/**
* Get the bit allocator pool associated with the subtype and the db
*
@@ -1388,6 +1311,7 @@ tf_rm_get_hcapi_type(struct tf_rm_get_hcapi_parms *parms)
return 0;
}
+
int
tf_rm_get_slices(struct tf_rm_get_slices_parms *parms)
{
@@ -1440,6 +1364,7 @@ tf_rm_get_inuse_count(struct tf_rm_get_inuse_count_parms *parms)
return rc;
}
+
/* Only used for table bulk get at this time
*/
int
@@ -1,12 +1,10 @@
/* SPDX-License-Identifier: BSD-3-Clause
- * Copyright(c) 2019-2021 Broadcom
+ * Copyright(c) 2019-2023 Broadcom
* All rights reserved.
*/
#include <string.h>
-
#include <rte_common.h>
-
#include "tf_session.h"
#include "tf_common.h"
#include "tf_msg.h"
@@ -59,8 +57,9 @@ tf_session_create(struct tf *tfp,
union tf_session_id *session_id;
struct tf_dev_info dev;
bool shared_session_creator;
- int name_len;
- char *name;
+ char *shared_name;
+ char *tcam_session_name;
+ char *pool_session_name;
TF_CHECK_PARMS2(tfp, parms);
@@ -180,16 +179,18 @@ tf_session_create(struct tf *tfp,
session->em_ext_db_handle = NULL;
/* Populate the request */
- name_len = strnlen(parms->open_cfg->ctrl_chan_name,
- TF_SESSION_NAME_MAX);
- name = &parms->open_cfg->ctrl_chan_name[name_len - strlen("tf_shared")];
- if (!strncmp(name, "tf_shared", strlen("tf_shared")))
- session->shared_session = true;
-
- name = &parms->open_cfg->ctrl_chan_name[name_len -
- strlen("tf_shared-wc_tcam")];
- if (!strncmp(name, "tf_shared-wc_tcam", strlen("tf_shared-wc_tcam")))
+ shared_name = strstr(parms->open_cfg->ctrl_chan_name, "tf_shared");
+ if (shared_name) {
session->shared_session = true;
+ /*
+ * "tf_shared-wc_tcam" is defined for tf_fw version 1.0.0.
+ * "tf_shared-pool" is defined for version 1.0.1.
+ */
+ tcam_session_name = strstr(parms->open_cfg->ctrl_chan_name, "tf_shared-wc_tcam");
+ pool_session_name = strstr(parms->open_cfg->ctrl_chan_name, "tf_shared-pool");
+ if (tcam_session_name || pool_session_name)
+ session->shared_session_hotup = true;
+ }
if (session->shared_session && shared_session_creator) {
session->shared_session_creator = true;
@@ -342,7 +343,6 @@ tf_session_client_create(struct tf *tfp,
return rc;
}
-
/**
* Destroys a Session Client on an existing Session.
*
@@ -441,7 +441,7 @@ tf_session_open_session(struct tf *tfp,
TFP_DRV_LOG(INFO,
"Session created, session_client_id:%d,"
- "session_id:0x%08x, fw_session_id:%d\n",
+ " session_id:0x%08x, fw_session_id:%d\n",
parms->open_cfg->session_client_id.id,
parms->open_cfg->session_id.id,
parms->open_cfg->session_id.internal.fw_session_id);
@@ -462,7 +462,7 @@ tf_session_open_session(struct tf *tfp,
}
TFP_DRV_LOG(INFO,
- "Session Client:%d registered on session:0x%8x\n",
+ "Session Client:%d registered on session:0x%08x\n",
scparms.session_client_id->internal.fw_session_client_id,
tfp->session->session_id.id);
}
@@ -535,6 +535,11 @@ tf_session_close_session(struct tf *tfp,
return rc;
}
+ /* Record the session we're closing so the caller knows the
+ * details.
+ */
+ *parms->session_id = tfs->session_id;
+
/* In case multiple clients we chose to close those first */
if (tfs->ref_count > 1) {
/* Linaro gcc can't static init this structure */
@@ -567,11 +572,6 @@ tf_session_close_session(struct tf *tfp,
return 0;
}
- /* Record the session we're closing so the caller knows the
- * details.
- */
- *parms->session_id = tfs->session_id;
-
rc = tf_session_get_device(tfs, &tfd);
if (rc) {
TFP_DRV_LOG(ERR,
@@ -1140,3 +1140,71 @@ tf_session_set_if_tbl_db(struct tf *tfp,
tfs->if_tbl_db_handle = if_tbl_handle;
return rc;
}
+
+int
+tf_session_set_hotup_state(struct tf *tfp,
+ struct tf_set_session_hotup_state_parms *parms)
+{
+ int rc = 0;
+ struct tf_session *tfs = NULL;
+
+ rc = tf_session_get_session(tfp, &tfs);
+ if (rc) {
+ TFP_DRV_LOG(ERR,
+ "Session lookup failed, rc:%s\n",
+ strerror(-rc));
+ return rc;
+ }
+
+ if (!tf_session_is_shared_session(tfs)) {
+ rc = -EINVAL;
+ TFP_DRV_LOG(ERR,
+ "Only shared session able to set state, rc:%s\n",
+ strerror(-rc));
+ return rc;
+ }
+
+ rc = tf_msg_session_set_hotup_state(tfp, parms->state);
+ if (rc) {
+ /* Log error */
+ TFP_DRV_LOG(ERR,
+ "Set session hot upgrade state failed, rc:%s\n",
+ strerror(-rc));
+ }
+
+ return rc;
+}
+
+int
+tf_session_get_hotup_state(struct tf *tfp,
+ struct tf_get_session_hotup_state_parms *parms)
+{
+ int rc = 0;
+ struct tf_session *tfs = NULL;
+
+ rc = tf_session_get_session(tfp, &tfs);
+ if (rc) {
+ TFP_DRV_LOG(ERR,
+ "Session lookup failed, rc:%s\n",
+ strerror(-rc));
+ return rc;
+ }
+
+ if (!tf_session_is_shared_session(tfs)) {
+ rc = -EINVAL;
+ TFP_DRV_LOG(ERR,
+ "Only shared session able to get state, rc:%s\n",
+ strerror(-rc));
+ return rc;
+ }
+
+ rc = tf_msg_session_get_hotup_state(tfp, &parms->state, &parms->ref_cnt);
+ if (rc) {
+ /* Log error */
+ TFP_DRV_LOG(ERR,
+ "Get session hot upgrade state failed, rc:%s\n",
+ strerror(-rc));
+ }
+
+ return rc;
+}
@@ -1,5 +1,5 @@
/* SPDX-License-Identifier: BSD-3-Clause
- * Copyright(c) 2019-2021 Broadcom
+ * Copyright(c) 2019-2023 Broadcom
* All rights reserved.
*/
@@ -8,7 +8,6 @@
#include <stdint.h>
#include <stdlib.h>
-
#include "bitalloc.h"
#include "tf_core.h"
#include "tf_device.h"
@@ -48,7 +47,7 @@
*
* Shared memory containing private TruFlow session information.
* Through this structure the session can keep track of resource
- * allocations. It also holds info about Session Clients.
+ * allocations. It also holds info about Session Clients.
*
* Memory is assigned to the Truflow instance by way of
* tf_open_session. Memory is allocated and owned by i.e. ULP.
@@ -78,6 +77,11 @@ struct tf_session {
*/
bool shared_session;
+ /**
+ * Boolean controlling the split of hardware resources for hotupgrade.
+ */
+ bool shared_session_hotup;
+
/**
* This flag indicates the shared session on firmware side is created
* by this session. Some privileges may be assigned to this session.
@@ -169,6 +173,12 @@ struct tf_session {
* Number of slices per row for WC TCAM
*/
uint16_t wc_num_slices_per_row;
+
+ /**
+ * Indicates if TCAM is controlled by TCAM Manager
+ */
+ int tcam_mgr_control[TF_DIR_MAX][TF_TCAM_TBL_TYPE_MAX];
+
};
/**
@@ -276,11 +286,9 @@ struct tf_session_close_session_parms {
*
* @ref tf_session_is_shared_session
*
- * #define TF_SHARED
* @ref tf_session_get_tcam_shared_db
*
* @ref tf_session_set_tcam_shared_db
- * #endif
*
* @ref tf_session_get_sram_db
*
@@ -588,6 +596,21 @@ tf_session_is_shared_session(struct tf_session *tfs)
return tfs->shared_session;
}
+/**
+ * Check if the session is shared session for hot upgrade.
+ *
+ * [in] session, pointer to the session
+ *
+ * Returns:
+ * - true if it is shared session for hot upgrade
+ * - false if it is not shared session for hot upgrade
+ */
+static inline bool
+tf_session_is_shared_hotup_session(struct tf_session *tfs)
+{
+ return tfs->shared_session_hotup;
+}
+
/**
* Check if the session is the shared session creator
*
@@ -716,4 +739,36 @@ tf_session_set_if_tbl_db(struct tf *tfp,
int
tf_session_get_if_tbl_db(struct tf *tfp,
void **if_tbl_handle);
+
+/**
+ * Set hot upgrade session state.
+ *
+ * [in] tfp
+ * Pointer to session handle
+ *
+ * [in] parms
+ * Hot upgrade session state parms
+ *
+ * Returns:
+ * 0 on Success else internal Truflow error
+ */
+int
+tf_session_set_hotup_state(struct tf *tfp,
+ struct tf_set_session_hotup_state_parms *parms);
+
+/**
+ * Get hot upgrade session state.
+ *
+ * [in] tfp
+ * Pointer to session handle
+ *
+ * [out] parms
+ * Pointer to hot upgrade session state parms
+ *
+ * Returns:
+ * 0 on Success else internal Truflow error
+ */
+int
+tf_session_get_hotup_state(struct tf *tfp,
+ struct tf_get_session_hotup_state_parms *parms);
#endif /* _TF_SESSION_H_ */
@@ -1,5 +1,5 @@
/* SPDX-License-Identifier: BSD-3-Clause
- * Copyright(c) 2019-2021 Broadcom
+ * Copyright(c) 2019-2023 Broadcom
* All rights reserved.
*/
#include <stdlib.h>
@@ -21,7 +21,7 @@
/**
* TF SRAM block info
*
- * Contains all the information about a particular 64B SRAM
+ * Contains all the information about a particular 128B SRAM
* block and the slices within it.
*/
struct tf_sram_block {
@@ -36,9 +36,9 @@ struct tf_sram_block {
* If a bit is set, it indicates the slice
* in the row is in use.
*/
- uint8_t in_use_mask;
+ uint16_t in_use_mask;
- /** Block id - this is a 64B offset
+ /** Block id - this is a 128B offset
*/
uint16_t block_id;
};
@@ -46,7 +46,7 @@ struct tf_sram_block {
/**
* TF SRAM block list
*
- * List of 64B SRAM blocks used for fixed size slices (8, 16, 32, 64B)
+ * List of 128B SRAM blocks used for fixed size slices (8, 16, 32, 64B, 128B)
*/
struct tf_sram_slice_list {
/** Pointer to head of linked list of blocks.
@@ -70,7 +70,6 @@ struct tf_sram_slice_list {
enum tf_sram_slice_size size;
};
-
/**
* TF SRAM bank info consists of lists of different slice sizes per bank
*/
@@ -111,6 +110,8 @@ const char
return "32B slice";
case TF_SRAM_SLICE_SIZE_64B:
return "64B slice";
+ case TF_SRAM_SLICE_SIZE_128B:
+ return "128B slice";
default:
return "Invalid slice size";
}
@@ -179,8 +180,8 @@ static void
tf_sram_offset_2_block_id(enum tf_sram_bank_id bank_id, uint16_t offset,
uint16_t *block_id, uint16_t *slice_offset)
{
- *slice_offset = offset & 0x7;
- *block_id = ((offset & ~0x7) >> 3) -
+ *slice_offset = offset & 0xf;
+ *block_id = ((offset & ~0xf) >> 3) -
tf_sram_bank_2_base_offset[bank_id];
}
@@ -232,31 +233,37 @@ tf_sram_free_slice(enum tf_sram_slice_size slice_size,
bool *block_is_empty)
{
int rc = 0;
- uint8_t shift;
- uint8_t slice_mask = 0;
+ uint16_t shift;
+ uint16_t slice_mask = 0;
TF_CHECK_PARMS2(block, block_is_empty);
switch (slice_size) {
case TF_SRAM_SLICE_SIZE_8B:
shift = slice_offset >> 0;
- assert(shift < 8);
+ assert(shift < 16);
slice_mask = 1 << shift;
break;
case TF_SRAM_SLICE_SIZE_16B:
shift = slice_offset >> 1;
- assert(shift < 4);
+ assert(shift < 8);
slice_mask = 1 << shift;
break;
case TF_SRAM_SLICE_SIZE_32B:
shift = slice_offset >> 2;
- assert(shift < 2);
+ assert(shift < 4);
slice_mask = 1 << shift;
break;
case TF_SRAM_SLICE_SIZE_64B:
+ shift = slice_offset >> 3;
+ assert(shift < 2);
+ slice_mask = 1 << shift;
+ break;
+
+ case TF_SRAM_SLICE_SIZE_128B:
default:
shift = slice_offset >> 0;
assert(shift < 1);
@@ -294,27 +301,32 @@ tf_sram_get_next_slice_in_block(struct tf_sram_block *block,
bool *block_is_full)
{
int rc, free_id = -1;
- uint8_t shift, max_slices, mask, i, full_mask;
+ uint16_t shift, max_slices, mask, i, full_mask;
TF_CHECK_PARMS3(block, slice_offset, block_is_full);
switch (slice_size) {
case TF_SRAM_SLICE_SIZE_8B:
shift = 0;
- max_slices = 8;
- full_mask = 0xff;
+ max_slices = 16;
+ full_mask = 0xffff;
break;
case TF_SRAM_SLICE_SIZE_16B:
shift = 1;
- max_slices = 4;
- full_mask = 0xf;
+ max_slices = 8;
+ full_mask = 0xff;
break;
case TF_SRAM_SLICE_SIZE_32B:
shift = 2;
+ max_slices = 4;
+ full_mask = 0xf;
+ break;
+ case TF_SRAM_SLICE_SIZE_64B:
+ shift = 3;
max_slices = 2;
full_mask = 0x3;
break;
- case TF_SRAM_SLICE_SIZE_64B:
+ case TF_SRAM_SLICE_SIZE_128B:
default:
shift = 0;
max_slices = 1;
@@ -338,7 +350,6 @@ tf_sram_get_next_slice_in_block(struct tf_sram_block *block,
else
*block_is_full = false;
-
if (free_id >= 0) {
*slice_offset = free_id << shift;
rc = 0;
@@ -362,8 +373,8 @@ tf_sram_is_slice_allocated_in_block(struct tf_sram_block *block,
bool *is_allocated)
{
int rc = 0;
- uint8_t shift;
- uint8_t slice_mask = 0;
+ uint16_t shift;
+ uint16_t slice_mask = 0;
TF_CHECK_PARMS2(block, is_allocated);
@@ -372,23 +383,29 @@ tf_sram_is_slice_allocated_in_block(struct tf_sram_block *block,
switch (slice_size) {
case TF_SRAM_SLICE_SIZE_8B:
shift = slice_offset >> 0;
- assert(shift < 8);
+ assert(shift < 16);
slice_mask = 1 << shift;
break;
case TF_SRAM_SLICE_SIZE_16B:
shift = slice_offset >> 1;
- assert(shift < 4);
+ assert(shift < 8);
slice_mask = 1 << shift;
break;
case TF_SRAM_SLICE_SIZE_32B:
shift = slice_offset >> 2;
- assert(shift < 2);
+ assert(shift < 4);
slice_mask = 1 << shift;
break;
case TF_SRAM_SLICE_SIZE_64B:
+ shift = slice_offset >> 3;
+ assert(shift < 2);
+ slice_mask = 1 << shift;
+ break;
+
+ case TF_SRAM_SLICE_SIZE_128B:
default:
shift = slice_offset >> 0;
assert(shift < 1);
@@ -416,7 +433,6 @@ tf_sram_get_block_cnt(struct tf_sram_slice_list *slice_list)
return slice_list->cnt;
}
-
/**
* Free a block data structure - does not free to the RM
*/
@@ -508,22 +524,26 @@ tf_sram_find_first_not_full_block(struct tf_sram_slice_list *slice_list,
struct tf_sram_block **first_not_full_block)
{
struct tf_sram_block *block = slice_list->head;
- uint8_t slice_mask, mask;
+ uint16_t slice_mask, mask;
switch (slice_size) {
case TF_SRAM_SLICE_SIZE_8B:
- slice_mask = 0xff;
+ slice_mask = 0xffff;
break;
case TF_SRAM_SLICE_SIZE_16B:
- slice_mask = 0xf;
+ slice_mask = 0xff;
break;
case TF_SRAM_SLICE_SIZE_32B:
- slice_mask = 0x3;
+ slice_mask = 0xf;
break;
case TF_SRAM_SLICE_SIZE_64B:
+ slice_mask = 0x3;
+ break;
+
+ case TF_SRAM_SLICE_SIZE_128B:
default:
slice_mask = 0x1;
break;
@@ -543,7 +563,7 @@ tf_sram_find_first_not_full_block(struct tf_sram_slice_list *slice_list,
static void
tf_sram_dump_block(struct tf_sram_block *block)
{
- TFP_DRV_LOG(INFO, "block_id(0x%x) in_use_mask(0x%02x)\n",
+ TFP_DRV_LOG(INFO, "block_id(0x%x) in_use_mask(0x%04x)\n",
block->block_id,
block->in_use_mask);
}
@@ -631,9 +651,10 @@ int tf_sram_mgr_alloc(void *sram_handle,
struct tf_sram *sram;
struct tf_sram_slice_list *slice_list;
uint16_t block_id, slice_offset = 0;
- uint32_t index;
+ uint32_t index, next_index;
struct tf_sram_block *block;
struct tf_rm_allocate_parms aparms = { 0 };
+ struct tf_rm_free_parms fparms = { 0 };
bool block_is_full;
uint16_t block_offset;
@@ -662,11 +683,34 @@ int tf_sram_mgr_alloc(void *sram_handle,
aparms.subtype = parms->tbl_type;
aparms.rm_db = parms->rm_db;
rc = tf_rm_allocate(&aparms);
+ if (rc)
+ return rc;
+ /* to support 128B block rows, we are allocating
+ * 2 sequential 64B blocks from RM, if they are not next to
+ * each other we are going to have issues
+ */
+ aparms.index = &next_index;
+ rc = tf_rm_allocate(&aparms);
if (rc)
return rc;
+ /* make sure we do get the next 64B block, else free the
+ * allocated indexes and return error
+ */
+ if (unlikely(index + 1 != next_index)) {
+ fparms.index = index;
+ fparms.subtype = parms->tbl_type;
+ fparms.rm_db = parms->rm_db;
+ tf_rm_free(&fparms);
+ fparms.index = next_index;
+ tf_rm_free(&fparms);
+ TFP_DRV_LOG(ERR,
+ "Could not allocate two sequential 64B blocks\n");
+ return -ENOMEM;
+ }
block_id = index;
block = tf_sram_alloc_block(slice_list, block_id);
+
} else {
/* Block exists
*/
@@ -742,7 +786,7 @@ tf_sram_mgr_free(void *sram_handle,
}
#if (STATS_CLEAR_ON_READ_SUPPORT == 0)
/* If this is a counter, clear it. In the future we need to switch to
- * using the special access registers on Thor to automatically clear on
+ * using the special access registers on P5 to automatically clear on
* read.
*/
/* If this is counter table, clear the entry on free */
@@ -794,6 +838,13 @@ tf_sram_mgr_free(void *sram_handle,
TFP_DRV_LOG(ERR, "Free block_id(%d) failed error(%s)\n",
block_id, strerror(-rc));
}
+ fparms.index = block_id + 1;
+ rc = tf_rm_free(&fparms);
+
+ if (rc) {
+ TFP_DRV_LOG(ERR, "Free next block_id(%d) failed error(%s)\n",
+ block_id + 1, strerror(-rc));
+ }
/* Free local entry regardless */
tf_sram_free_block(slice_list, block);
@@ -1,5 +1,5 @@
/* SPDX-License-Identifier: BSD-3-Clause
- * Copyright(c) 2019-2021 Broadcom
+ * Copyright(c) 2019-2023 Broadcom
* All rights reserved.
*/
@@ -26,28 +26,28 @@
*/
#define STATS_CLEAR_ON_READ_SUPPORT 0
-#define TF_SRAM_MGR_BLOCK_SZ_BYTES 64
+#define TF_SRAM_MGR_BLOCK_SZ_BYTES 128
#define TF_SRAM_MGR_MIN_SLICE_BYTES 8
/**
* TF slice size.
*
- * A slice is part of a 64B row
+ * A slice is part of a 128B row
*
* Each slice is a multiple of 8B
*/
enum tf_sram_slice_size {
- TF_SRAM_SLICE_SIZE_8B, /**< 8 byte SRAM slice */
- TF_SRAM_SLICE_SIZE_16B, /**< 16 byte SRAM slice */
- TF_SRAM_SLICE_SIZE_32B, /**< 32 byte SRAM slice */
- TF_SRAM_SLICE_SIZE_64B, /**< 64 byte SRAM slice */
- TF_SRAM_SLICE_SIZE_MAX /**< slice limit */
+ TF_SRAM_SLICE_SIZE_8B, /**< 8 byte SRAM slice */
+ TF_SRAM_SLICE_SIZE_16B, /**< 16 byte SRAM slice */
+ TF_SRAM_SLICE_SIZE_32B, /**< 32 byte SRAM slice */
+ TF_SRAM_SLICE_SIZE_64B, /**< 64 byte SRAM slice */
+ TF_SRAM_SLICE_SIZE_128B, /**< 128 byte SRAM slice */
+ TF_SRAM_SLICE_SIZE_MAX /**< slice limit */
};
-
/** Initialize the SRAM slice manager
*
- * The SRAM slice manager manages slices within 64B rows. Slices are of size
+ * The SRAM slice manager manages slices within 128B rows. Slices are of size
* tf_sram_slice_size. This function provides a handle to the SRAM manager
* data.
*
@@ -181,7 +181,7 @@ struct tf_sram_mgr_free_parms {
/**
* Free an SRAM Slice
*
- * Free an SRAM slice to the indicated bank. This may result in a 64B row
+ * Free an SRAM slice to the indicated bank. This may result in a 128B row
* being returned to the RM SRAM bank pool.
*
* [in] sram_handle
@@ -1,12 +1,11 @@
/* SPDX-License-Identifier: BSD-3-Clause
- * Copyright(c) 2019-2021 Broadcom
+ * Copyright(c) 2019-2023 Broadcom
* All rights reserved.
*/
/* Truflow Table APIs and supporting code */
#include <rte_common.h>
-
#include "tf_tbl.h"
#include "tf_common.h"
#include "tf_rm.h"
@@ -18,8 +17,8 @@
struct tf;
-#define TF_TBL_RM_TO_PTR(new_idx, idx, base, shift) { \
- *(new_idx) = (((idx) + (base)) << (shift)); \
+#define TF_TBL_RM_TO_PTR(new_idx, idx, base, shift) { \
+ *(new_idx) = (((idx) + (base)) << (shift)); \
}
int
@@ -98,6 +97,7 @@ tf_tbl_unbind(struct tf *tfp)
rc = tf_session_get_db(tfp, TF_MODULE_TYPE_TABLE, &tbl_db_ptr);
if (rc)
return 0;
+
tbl_db = (struct tbl_rm_db *)tbl_db_ptr;
for (i = 0; i < TF_DIR_MAX; i++) {
@@ -1,5 +1,5 @@
/* SPDX-License-Identifier: BSD-3-Clause
- * Copyright(c) 2019-2021 Broadcom
+ * Copyright(c) 2019-2023 Broadcom
* All rights reserved.
*/
@@ -73,11 +73,12 @@ const uint16_t tf_tbl_sram_hcapi_2_bank[CFA_RESOURCE_TYPE_P58_LAST] = {
* Translate HCAPI type to SRAM Manager bank
*/
const uint8_t tf_tbl_sram_slices_2_size[TF_TBL_SRAM_SLICES_MAX + 1] = {
- [0] = TF_SRAM_SLICE_SIZE_64B, /* if 0 slices assume 1 64B block */
- [1] = TF_SRAM_SLICE_SIZE_64B, /* 1 slice per 64B block */
- [2] = TF_SRAM_SLICE_SIZE_32B, /* 2 slices per 64B block */
- [4] = TF_SRAM_SLICE_SIZE_16B, /* 4 slices per 64B block */
- [8] = TF_SRAM_SLICE_SIZE_8B /* 8 slices per 64B block */
+ [0] = TF_SRAM_SLICE_SIZE_128B, /* if 0 slices assume 1 128B block */
+ [1] = TF_SRAM_SLICE_SIZE_128B, /* 1 slice per 128B block */
+ [2] = TF_SRAM_SLICE_SIZE_64B, /* 2 slice per 128B block */
+ [4] = TF_SRAM_SLICE_SIZE_32B, /* 4 slices per 128B block */
+ [8] = TF_SRAM_SLICE_SIZE_16B, /* 8 slices per 128B block */
+ [16] = TF_SRAM_SLICE_SIZE_8B /* 16 slices per 128B block */
};
/**
@@ -340,7 +341,7 @@ tf_tbl_sram_free(struct tf *tfp __rte_unused,
rc = tf_sram_mgr_is_allocated(sram_handle, &aparms);
if (rc || !allocated) {
TFP_DRV_LOG(ERR,
- "%s: Free of invalid entry:%s idx(%d):(%s)\n",
+ "%s: Free of invalid entry:%s idx(0x%x):(%s)\n",
tf_dir_2_str(parms->dir),
tf_tbl_type_2_str(parms->type),
parms->idx,
@@ -361,7 +362,7 @@ tf_tbl_sram_free(struct tf *tfp __rte_unused,
rc = tf_sram_mgr_free(sram_handle, &fparms);
if (rc) {
TFP_DRV_LOG(ERR,
- "%s: Failed to free entry:%s idx(%d)\n",
+ "%s: Failed to free entry:%s idx(0x%x)\n",
tf_dir_2_str(parms->dir),
tf_tbl_type_2_str(parms->type),
parms->idx);
@@ -469,7 +470,7 @@ tf_tbl_sram_set(struct tf *tfp,
if (rallocated != TF_RM_ALLOCATED_ENTRY_IN_USE) {
TFP_DRV_LOG(ERR,
- "%s, Invalid or not allocated index, type:%s, idx:%d\n",
+ "%s, Invalid or not allocated index, type:%s, idx:0x%x\n",
tf_dir_2_str(parms->dir),
tf_tbl_type_2_str(parms->type),
parms->idx);
@@ -484,7 +485,7 @@ tf_tbl_sram_set(struct tf *tfp,
rc = tf_sram_mgr_is_allocated(sram_handle, &aparms);
if (rc || !allocated) {
TFP_DRV_LOG(ERR,
- "%s: Entry not allocated:%s idx(%d):(%s)\n",
+ "%s: Entry not allocated:%s idx(0x%x):(%s)\n",
tf_dir_2_str(parms->dir),
tf_tbl_type_2_str(parms->type),
parms->idx,
@@ -587,7 +588,7 @@ tf_tbl_sram_get(struct tf *tfp,
rc = tf_sram_mgr_is_allocated(sram_handle, &aparms);
if (rc || !allocated) {
TFP_DRV_LOG(ERR,
- "%s: Entry not allocated:%s idx(%d):(%s)\n",
+ "%s: Entry not allocated:%s idx(0x%x):(%s)\n",
tf_dir_2_str(parms->dir),
tf_tbl_type_2_str(parms->type),
parms->idx,
@@ -711,7 +712,7 @@ tf_tbl_sram_bulk_get(struct tf *tfp,
rc = tf_sram_mgr_is_allocated(sram_handle, &aparms);
if (rc || !allocated) {
TFP_DRV_LOG(ERR,
- "%s: Entry not allocated:%s last_idx(%d):(%s)\n",
+ "%s: Entry not allocated:%s last_idx(0x%x):(%s)\n",
tf_dir_2_str(parms->dir),
tf_tbl_type_2_str(parms->type),
idx,
@@ -1,5 +1,5 @@
/* SPDX-License-Identifier: BSD-3-Clause
- * Copyright(c) 2019-2021 Broadcom
+ * Copyright(c) 2019-2023 Broadcom
* All rights reserved.
*/
@@ -14,6 +14,7 @@
#include "tfp.h"
#include "tf_session.h"
#include "tf_msg.h"
+#include "tf_tcam_mgr_msg.h"
struct tf;
@@ -23,17 +24,22 @@ tf_tcam_bind(struct tf *tfp,
{
int rc;
int db_rc[TF_DIR_MAX] = { 0 };
- int i, d;
+ int d, t;
struct tf_rm_alloc_info info;
struct tf_rm_free_db_parms fparms;
struct tf_rm_create_db_parms db_cfg;
+ struct tf_tcam_resources local_tcam_cnt[TF_DIR_MAX];
struct tf_tcam_resources *tcam_cnt;
struct tf_rm_get_alloc_info_parms ainfo;
- uint16_t num_slices = parms->wc_num_slices;
+ uint16_t num_slices = 1;
struct tf_session *tfs;
struct tf_dev_info *dev;
struct tcam_rm_db *tcam_db;
struct tfp_calloc_parms cparms;
+ struct tf_resource_info resv_res[TF_DIR_MAX][TF_TCAM_TBL_TYPE_MAX];
+ uint32_t rx_supported;
+ uint32_t tx_supported;
+ bool no_req = true;
TF_CHECK_PARMS2(tfp, parms);
@@ -47,7 +53,7 @@ tf_tcam_bind(struct tf *tfp,
if (rc)
return rc;
- if (dev->ops->tf_dev_set_tcam_slice_info == NULL) {
+ if (dev->ops->tf_dev_get_tcam_slice_info == NULL) {
rc = -EOPNOTSUPP;
TFP_DRV_LOG(ERR,
"Operation not supported, rc:%s\n",
@@ -55,18 +61,28 @@ tf_tcam_bind(struct tf *tfp,
return rc;
}
- rc = dev->ops->tf_dev_set_tcam_slice_info(tfp,
- num_slices);
+ tcam_cnt = parms->resources->tcam_cnt;
+
+ for (d = 0; d < TF_DIR_MAX; d++) {
+ for (t = 0; t < TF_TCAM_TBL_TYPE_MAX; t++) {
+ rc = dev->ops->tf_dev_get_tcam_slice_info(tfp, t, 0,
+ &num_slices);
if (rc)
return rc;
- tcam_cnt = parms->resources->tcam_cnt;
- if ((tcam_cnt[TF_DIR_RX].cnt[TF_TCAM_TBL_TYPE_WC_TCAM] % num_slices) ||
- (tcam_cnt[TF_DIR_TX].cnt[TF_TCAM_TBL_TYPE_WC_TCAM] % num_slices)) {
- TFP_DRV_LOG(ERR,
- "Requested num of WC TCAM entries has to be multiple %d\n",
- num_slices);
- return -EINVAL;
+ if (num_slices == 1)
+ continue;
+
+ if (tcam_cnt[d].cnt[t] % num_slices) {
+ TFP_DRV_LOG(ERR,
+ "%s: Requested num of %s entries "
+ "has to be multiple of %d\n",
+ tf_dir_2_str(d),
+ tf_tcam_tbl_2_str(t),
+ num_slices);
+ return -EINVAL;
+ }
+ }
}
memset(&db_cfg, 0, sizeof(db_cfg));
@@ -80,8 +96,8 @@ tf_tcam_bind(struct tf *tfp,
}
tcam_db = cparms.mem_va;
- for (i = 0; i < TF_DIR_MAX; i++)
- tcam_db->tcam_db[i] = NULL;
+ for (d = 0; d < TF_DIR_MAX; d++)
+ tcam_db->tcam_db[d] = NULL;
tf_session_set_db(tfp, TF_MODULE_TYPE_TCAM, tcam_db);
db_cfg.module = TF_MODULE_TYPE_TCAM;
@@ -90,7 +106,7 @@ tf_tcam_bind(struct tf *tfp,
for (d = 0; d < TF_DIR_MAX; d++) {
db_cfg.dir = d;
- db_cfg.alloc_cnt = parms->resources->tcam_cnt[d].cnt;
+ db_cfg.alloc_cnt = tcam_cnt[d].cnt;
db_cfg.rm_db = (void *)&tcam_db->tcam_db[d];
if (tf_session_is_shared_session(tfs) &&
(!tf_session_is_shared_session_creator(tfs)))
@@ -98,53 +114,112 @@ tf_tcam_bind(struct tf *tfp,
else
db_rc[d] = tf_rm_create_db(tfp, &db_cfg);
}
-
/* No db created */
if (db_rc[TF_DIR_RX] && db_rc[TF_DIR_TX]) {
TFP_DRV_LOG(ERR, "No TCAM DB created\n");
return db_rc[TF_DIR_RX];
}
- /* check if reserved resource for WC is multiple of num_slices */
+ /* Collect info on which entries were reserved. */
for (d = 0; d < TF_DIR_MAX; d++) {
- if (!tcam_db->tcam_db[d])
- continue;
+ for (t = 0; t < TF_TCAM_TBL_TYPE_MAX; t++) {
+ memset(&info, 0, sizeof(info));
+ if (tcam_cnt[d].cnt[t] == 0) {
+ resv_res[d][t].start = 0;
+ resv_res[d][t].stride = 0;
+ continue;
+ }
+ ainfo.rm_db = tcam_db->tcam_db[d];
+ ainfo.subtype = t;
+ ainfo.info = &info;
+ rc = tf_rm_get_info(&ainfo);
+ if (rc)
+ goto error;
+
+ rc = dev->ops->tf_dev_get_tcam_slice_info(tfp, t, 0,
+ &num_slices);
+ if (rc)
+ return rc;
+
+ if (num_slices > 1) {
+ /* check if reserved resource for is multiple of
+ * num_slices
+ */
+ if (info.entry.start % num_slices != 0 ||
+ info.entry.stride % num_slices != 0) {
+ TFP_DRV_LOG(ERR,
+ "%s: %s reserved resource"
+ " is not multiple of %d\n",
+ tf_dir_2_str(d),
+ tf_tcam_tbl_2_str(t),
+ num_slices);
+ rc = -EINVAL;
+ goto error;
+ }
+ }
+
+ resv_res[d][t].start = info.entry.start;
+ resv_res[d][t].stride = info.entry.stride;
+ }
+ }
- memset(&info, 0, sizeof(info));
- ainfo.rm_db = tcam_db->tcam_db[d];
- ainfo.subtype = TF_TCAM_TBL_TYPE_WC_TCAM;
- ainfo.info = &info;
- rc = tf_rm_get_info(&ainfo);
- if (rc)
- goto error;
-
- if (info.entry.start % num_slices != 0 ||
- info.entry.stride % num_slices != 0) {
- TFP_DRV_LOG(ERR,
- "%s: TCAM reserved resource is not multiple of %d\n",
- tf_dir_2_str(d),
- num_slices);
- rc = -EINVAL;
- goto error;
+ rc = tf_tcam_mgr_bind_msg(tfp, dev, parms, resv_res);
+ if (rc)
+ return rc;
+
+ rc = tf_tcam_mgr_qcaps_msg(tfp, dev,
+ &rx_supported, &tx_supported);
+ if (rc)
+ return rc;
+
+ for (t = 0; t < TF_TCAM_TBL_TYPE_MAX; t++) {
+ if (rx_supported & 1 << t)
+ tfs->tcam_mgr_control[TF_DIR_RX][t] = 1;
+ if (tx_supported & 1 << t)
+ tfs->tcam_mgr_control[TF_DIR_TX][t] = 1;
+ }
+
+ /*
+ * Make a local copy of tcam_cnt with only resources not managed by TCAM
+ * Manager requested.
+ */
+ memcpy(&local_tcam_cnt, tcam_cnt, sizeof(local_tcam_cnt));
+ tcam_cnt = local_tcam_cnt;
+ for (d = 0; d < TF_DIR_MAX; d++) {
+ for (t = 0; t < TF_TCAM_TBL_TYPE_MAX; t++) {
+ /* If controlled by TCAM Manager */
+ if (tfs->tcam_mgr_control[d][t])
+ tcam_cnt[d].cnt[t] = 0;
+ else if (tcam_cnt[d].cnt[t] > 0)
+ no_req = false;
}
}
- /* Initialize the TCAM manager. */
+ /* If no resources left to request */
+ if (no_req)
+ goto finished;
+
+finished:
TFP_DRV_LOG(INFO,
"TCAM - initialized\n");
return 0;
error:
- for (i = 0; i < TF_DIR_MAX; i++) {
- memset(&fparms, 0, sizeof(fparms));
- fparms.dir = i;
- fparms.rm_db = tcam_db->tcam_db[i];
- /* Ignoring return here since we are in the error case */
- (void)tf_rm_free_db(tfp, &fparms);
- tcam_db->tcam_db[i] = NULL;
+ for (d = 0; d < TF_DIR_MAX; d++) {
+ if (tcam_db->tcam_db[d] != NULL) {
+ memset(&fparms, 0, sizeof(fparms));
+ fparms.dir = d;
+ fparms.rm_db = tcam_db->tcam_db[d];
+ /*
+ * Ignoring return here since we are in the error case
+ */
+ (void)tf_rm_free_db(tfp, &fparms);
+
+ tcam_db->tcam_db[d] = NULL;
+ }
+ tcam_db->tcam_db[d] = NULL;
tf_session_set_db(tfp, TF_MODULE_TYPE_TCAM, NULL);
}
-
return rc;
}
@@ -156,27 +231,43 @@ tf_tcam_unbind(struct tf *tfp)
struct tf_rm_free_db_parms fparms;
struct tcam_rm_db *tcam_db;
void *tcam_db_ptr = NULL;
+ struct tf_session *tfs;
+ struct tf_dev_info *dev;
TF_CHECK_PARMS1(tfp);
+ /* Retrieve the session information */
+ rc = tf_session_get_session_internal(tfp, &tfs);
+ if (rc)
+ return rc;
+
+ /* Retrieve the device information */
+ rc = tf_session_get_device(tfs, &dev);
+ if (rc)
+ return rc;
rc = tf_session_get_db(tfp, TF_MODULE_TYPE_TCAM, &tcam_db_ptr);
- if (rc) {
+ if (rc)
return 0;
- }
+
tcam_db = (struct tcam_rm_db *)tcam_db_ptr;
for (i = 0; i < TF_DIR_MAX; i++) {
- if (tcam_db->tcam_db[i] == NULL)
- continue;
- memset(&fparms, 0, sizeof(fparms));
- fparms.dir = i;
- fparms.rm_db = tcam_db->tcam_db[i];
- rc = tf_rm_free_db(tfp, &fparms);
- if (rc)
- return rc;
+ if (tcam_db->tcam_db[i] != NULL) {
+ memset(&fparms, 0, sizeof(fparms));
+ fparms.dir = i;
+ fparms.rm_db = tcam_db->tcam_db[i];
+ rc = tf_rm_free_db(tfp, &fparms);
+ if (rc)
+ return rc;
+
+ tcam_db->tcam_db[i] = NULL;
+ }
- tcam_db->tcam_db[i] = NULL;
}
+ rc = tf_tcam_mgr_unbind_msg(tfp, dev);
+ if (rc)
+ return rc;
+
return 0;
}
@@ -222,6 +313,9 @@ tf_tcam_alloc(struct tf *tfp,
if (rc)
return rc;
+ /* If TCAM controlled by TCAM Manager */
+ if (tfs->tcam_mgr_control[parms->dir][parms->type])
+ return tf_tcam_mgr_alloc_msg(tfp, dev, parms);
rc = tf_session_get_db(tfp, TF_MODULE_TYPE_TCAM, &tcam_db_ptr);
if (rc) {
TFP_DRV_LOG(ERR,
@@ -251,12 +345,8 @@ tf_tcam_alloc(struct tf *tfp,
}
/* return the start index of each row */
- if (parms->priority == 0) {
if (i == 0)
parms->idx = index;
- } else {
- parms->idx = index;
- }
}
return 0;
@@ -307,6 +397,14 @@ tf_tcam_free(struct tf *tfp,
if (rc)
return rc;
+ /* If TCAM controlled by TCAM Manager */
+ if (tfs->tcam_mgr_control[parms->dir][parms->type])
+ /*
+ * If a session can have multiple references to an entry, check
+ * the reference count here before actually freeing the entry.
+ */
+ return tf_tcam_mgr_free_msg(tfp, dev, parms);
+
if (parms->idx % num_slices) {
TFP_DRV_LOG(ERR,
"%s: TCAM reserved resource is not multiple of %d\n",
@@ -429,6 +527,10 @@ tf_tcam_set(struct tf *tfp __rte_unused,
if (rc)
return rc;
+ /* If TCAM controlled by TCAM Manager */
+ if (tfs->tcam_mgr_control[parms->dir][parms->type])
+ return tf_tcam_mgr_set_msg(tfp, dev, parms);
+
rc = tf_session_get_db(tfp, TF_MODULE_TYPE_TCAM, &tcam_db_ptr);
if (rc) {
TFP_DRV_LOG(ERR,
@@ -508,6 +610,10 @@ tf_tcam_get(struct tf *tfp __rte_unused,
if (rc)
return rc;
+ /* If TCAM controlled by TCAM Manager */
+ if (tfs->tcam_mgr_control[parms->dir][parms->type])
+ return tf_tcam_mgr_get_msg(tfp, dev, parms);
+
rc = tf_session_get_db(tfp, TF_MODULE_TYPE_TCAM, &tcam_db_ptr);
if (rc) {
TFP_DRV_LOG(ERR,
new file mode 100644
@@ -0,0 +1,286 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2021-2023 Broadcom
+ * All rights reserved.
+ */
+
+#include <errno.h>
+
+#include "tfp.h"
+#include "tf_tcam.h"
+#include "cfa_tcam_mgr.h"
+#include "tf_tcam_mgr_msg.h"
+
+/*
+ * Table to convert TCAM type to logical TCAM type for applications.
+ * Index is tf_tcam_tbl_type.
+ */
+static enum cfa_tcam_mgr_tbl_type tcam_types[TF_TCAM_TBL_TYPE_MAX] = {
+ [TF_TCAM_TBL_TYPE_L2_CTXT_TCAM_HIGH] =
+ CFA_TCAM_MGR_TBL_TYPE_L2_CTXT_TCAM_HIGH_APPS,
+ [TF_TCAM_TBL_TYPE_L2_CTXT_TCAM_LOW] =
+ CFA_TCAM_MGR_TBL_TYPE_L2_CTXT_TCAM_LOW_APPS,
+ [TF_TCAM_TBL_TYPE_PROF_TCAM] =
+ CFA_TCAM_MGR_TBL_TYPE_PROF_TCAM_APPS,
+ [TF_TCAM_TBL_TYPE_WC_TCAM] =
+ CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_APPS,
+ [TF_TCAM_TBL_TYPE_SP_TCAM] =
+ CFA_TCAM_MGR_TBL_TYPE_SP_TCAM_APPS,
+ [TF_TCAM_TBL_TYPE_CT_RULE_TCAM] =
+ CFA_TCAM_MGR_TBL_TYPE_CT_RULE_TCAM_APPS,
+ [TF_TCAM_TBL_TYPE_VEB_TCAM] =
+ CFA_TCAM_MGR_TBL_TYPE_VEB_TCAM_APPS,
+ [TF_TCAM_TBL_TYPE_WC_TCAM_HIGH] =
+ CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_HIGH_APPS,
+ [TF_TCAM_TBL_TYPE_WC_TCAM_LOW] =
+ CFA_TCAM_MGR_TBL_TYPE_WC_TCAM_LOW_APPS,
+};
+
+static uint16_t hcapi_type[TF_TCAM_TBL_TYPE_MAX];
+
+/*
+ * This is the glue between the core tf_tcam and the TCAM manager. It is
+ * intended to abstract out the location of the TCAM manager so that the core
+ * code will be the same if the TCAM manager is in the core or in firmware.
+ *
+ * If the TCAM manager is in the core, then this file will just translate to
+ * TCAM manager APIs. If TCAM manager is in firmware, then this file will cause
+ * messages to be sent (except for bind and unbind).
+ */
+
+int
+tf_tcam_mgr_qcaps_msg(struct tf *tfp,
+ struct tf_dev_info *dev __rte_unused,
+ uint32_t *rx_tcam_supported,
+ uint32_t *tx_tcam_supported)
+{
+ struct cfa_tcam_mgr_context context;
+ struct cfa_tcam_mgr_qcaps_parms mgr_parms;
+ int rc;
+
+ context.tfp = tfp;
+ memset(&mgr_parms, 0, sizeof(mgr_parms));
+ rc = cfa_tcam_mgr_qcaps(&context, &mgr_parms);
+ if (rc >= 0) {
+ *rx_tcam_supported = mgr_parms.rx_tcam_supported;
+ *tx_tcam_supported = mgr_parms.tx_tcam_supported;
+ }
+ return rc;
+}
+
+int
+tf_tcam_mgr_bind_msg(struct tf *tfp,
+ struct tf_dev_info *dev __rte_unused,
+ struct tf_tcam_cfg_parms *parms,
+ struct tf_resource_info resv_res[][TF_TCAM_TBL_TYPE_MAX]
+ __rte_unused
+ )
+{
+ /* Common Code */
+ int type;
+
+ if (parms->num_elements != TF_TCAM_TBL_TYPE_MAX) {
+ TFP_DRV_LOG(ERR,
+ "Invalid number of elements in bind request.\n");
+ TFP_DRV_LOG(ERR,
+ "Expected %d, received %d.\n",
+ TF_TCAM_TBL_TYPE_MAX,
+ parms->num_elements);
+ return -EINVAL;
+ }
+
+ for (type = 0; type < TF_TCAM_TBL_TYPE_MAX; type++)
+ hcapi_type[type] = parms->cfg[type].hcapi_type;
+
+ struct cfa_tcam_mgr_context context;
+ struct cfa_tcam_mgr_cfg_parms mgr_parms;
+ struct tf_rm_resc_entry
+ mgr_resv_res[TF_DIR_MAX][CFA_TCAM_MGR_TBL_TYPE_MAX];
+ int dir, rc;
+
+ context.tfp = tfp;
+
+ memset(&mgr_parms, 0, sizeof(mgr_parms));
+
+ mgr_parms.num_elements = CFA_TCAM_MGR_TBL_TYPE_MAX;
+
+ /* Convert the data to logical tables */
+ for (dir = 0; dir < TF_DIR_MAX; dir++) {
+ for (type = 0; type < TF_TCAM_TBL_TYPE_MAX; type++) {
+ mgr_parms.tcam_cnt[dir][tcam_types[type]] =
+ parms->resources->tcam_cnt[dir].cnt[type];
+ mgr_resv_res[dir][tcam_types[type]].start =
+ resv_res[dir][type].start;
+ mgr_resv_res[dir][tcam_types[type]].stride =
+ resv_res[dir][type].stride;
+ }
+ }
+ mgr_parms.resv_res = mgr_resv_res;
+
+ rc = cfa_tcam_mgr_bind(&context, &mgr_parms);
+
+ return rc;
+}
+
+int
+tf_tcam_mgr_unbind_msg(struct tf *tfp,
+ struct tf_dev_info *dev __rte_unused)
+{
+ struct cfa_tcam_mgr_context context;
+
+ context.tfp = tfp;
+
+ return cfa_tcam_mgr_unbind(&context);
+}
+
+int
+tf_tcam_mgr_alloc_msg(struct tf *tfp,
+ struct tf_dev_info *dev __rte_unused,
+ struct tf_tcam_alloc_parms *parms)
+{
+ struct cfa_tcam_mgr_context context;
+ struct cfa_tcam_mgr_alloc_parms mgr_parms;
+ int rc;
+
+ if (parms->type >= TF_TCAM_TBL_TYPE_MAX) {
+ TFP_DRV_LOG(ERR,
+ "No such TCAM table %d.\n",
+ parms->type);
+ return -EINVAL;
+ }
+
+ context.tfp = tfp;
+
+ mgr_parms.dir = parms->dir;
+ mgr_parms.type = tcam_types[parms->type];
+ mgr_parms.hcapi_type = hcapi_type[parms->type];
+ mgr_parms.key_size = parms->key_size;
+ if (parms->priority > TF_TCAM_PRIORITY_MAX)
+ mgr_parms.priority = 0;
+ else
+ mgr_parms.priority = TF_TCAM_PRIORITY_MAX - parms->priority - 1;
+
+ rc = cfa_tcam_mgr_alloc(&context, &mgr_parms);
+ if (rc)
+ return rc;
+
+ parms->idx = mgr_parms.id;
+ return 0;
+}
+
+int
+tf_tcam_mgr_free_msg(struct tf *tfp,
+ struct tf_dev_info *dev __rte_unused,
+ struct tf_tcam_free_parms *parms)
+{
+ struct cfa_tcam_mgr_context context;
+ struct cfa_tcam_mgr_free_parms mgr_parms;
+
+ if (parms->type >= TF_TCAM_TBL_TYPE_MAX) {
+ TFP_DRV_LOG(ERR,
+ "No such TCAM table %d.\n",
+ parms->type);
+ return -EINVAL;
+ }
+
+ context.tfp = tfp;
+ mgr_parms.dir = parms->dir;
+ mgr_parms.type = tcam_types[parms->type];
+ mgr_parms.hcapi_type = hcapi_type[parms->type];
+ mgr_parms.id = parms->idx;
+
+ return cfa_tcam_mgr_free(&context, &mgr_parms);
+}
+
+int
+tf_tcam_mgr_set_msg(struct tf *tfp,
+ struct tf_dev_info *dev __rte_unused,
+ struct tf_tcam_set_parms *parms)
+{
+ struct cfa_tcam_mgr_context context;
+ struct cfa_tcam_mgr_set_parms mgr_parms;
+
+ if (parms->type >= TF_TCAM_TBL_TYPE_MAX) {
+ TFP_DRV_LOG(ERR,
+ "No such TCAM table %d.\n",
+ parms->type);
+ return -EINVAL;
+ }
+
+ context.tfp = tfp;
+ mgr_parms.dir = parms->dir;
+ mgr_parms.type = tcam_types[parms->type];
+ mgr_parms.hcapi_type = hcapi_type[parms->type];
+ mgr_parms.id = parms->idx;
+ mgr_parms.key = parms->key;
+ mgr_parms.mask = parms->mask;
+ mgr_parms.key_size = parms->key_size;
+ mgr_parms.result = parms->result;
+ mgr_parms.result_size = parms->result_size;
+
+ return cfa_tcam_mgr_set(&context, &mgr_parms);
+}
+
+int
+tf_tcam_mgr_get_msg(struct tf *tfp,
+ struct tf_dev_info *dev __rte_unused,
+ struct tf_tcam_get_parms *parms)
+{
+ int rc;
+ struct cfa_tcam_mgr_context context;
+ struct cfa_tcam_mgr_get_parms mgr_parms;
+
+ if (parms->type >= TF_TCAM_TBL_TYPE_MAX) {
+ TFP_DRV_LOG(ERR,
+ "No such TCAM table %d.\n",
+ parms->type);
+ return -EINVAL;
+ }
+
+ context.tfp = tfp;
+ mgr_parms.dir = parms->dir;
+ mgr_parms.type = tcam_types[parms->type];
+ mgr_parms.hcapi_type = hcapi_type[parms->type];
+ mgr_parms.id = parms->idx;
+ mgr_parms.key = parms->key;
+ mgr_parms.mask = parms->mask;
+ mgr_parms.key_size = parms->key_size;
+ mgr_parms.result = parms->result;
+ mgr_parms.result_size = parms->result_size;
+
+ rc = cfa_tcam_mgr_get(&context, &mgr_parms);
+ if (rc)
+ return rc;
+
+ parms->key_size = mgr_parms.key_size;
+ parms->result_size = mgr_parms.result_size;
+
+ return rc;
+}
+
+int
+tf_tcam_mgr_shared_clear_msg(struct tf *tfp,
+ struct tf_clear_tcam_shared_entries_parms *parms)
+{
+ struct cfa_tcam_mgr_context context;
+ struct cfa_tcam_mgr_shared_clear_parms mgr_parms;
+
+ context.tfp = tfp;
+ mgr_parms.dir = parms->dir;
+ mgr_parms.type = tcam_types[parms->tcam_tbl_type];
+
+ return cfa_tcam_mgr_shared_clear(&context, &mgr_parms);
+}
+
+int
+tf_tcam_mgr_shared_move_msg(struct tf *tfp,
+ struct tf_move_tcam_shared_entries_parms *parms)
+{
+ struct cfa_tcam_mgr_context context;
+ struct cfa_tcam_mgr_shared_move_parms mgr_parms;
+
+ context.tfp = tfp;
+ mgr_parms.dir = parms->dir;
+ mgr_parms.type = tcam_types[parms->tcam_tbl_type];
+
+ return cfa_tcam_mgr_shared_move(&context, &mgr_parms);
+}
new file mode 100644
@@ -0,0 +1,49 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2021-2023 Broadcom
+ * All rights reserved.
+ */
+
+#ifndef _TF_TCAM_MGR_MSG_H_
+#define _TF_TCAM_MGR_MSG_H_
+
+#include "tf_tcam.h"
+#include "tf_rm.h"
+
+int
+tf_tcam_mgr_qcaps_msg(struct tf *tfp,
+ struct tf_dev_info *dev __rte_unused,
+ uint32_t *rx_tcam_supported,
+ uint32_t *tx_tcam_supported);
+
+int
+tf_tcam_mgr_bind_msg(struct tf *tfp,
+ struct tf_dev_info *dev,
+ struct tf_tcam_cfg_parms *parms,
+ struct tf_resource_info resv_res[][TF_TCAM_TBL_TYPE_MAX]);
+int
+tf_tcam_mgr_unbind_msg(struct tf *tfp,
+ struct tf_dev_info *dev);
+int
+tf_tcam_mgr_alloc_msg(struct tf *tfp,
+ struct tf_dev_info *dev,
+ struct tf_tcam_alloc_parms *parms);
+int
+tf_tcam_mgr_free_msg(struct tf *tfp,
+ struct tf_dev_info *dev,
+ struct tf_tcam_free_parms *parms);
+int
+tf_tcam_mgr_set_msg(struct tf *tfp,
+ struct tf_dev_info *dev,
+ struct tf_tcam_set_parms *parms);
+int
+tf_tcam_mgr_get_msg(struct tf *tfp,
+ struct tf_dev_info *dev,
+ struct tf_tcam_get_parms *parms);
+int
+tf_tcam_mgr_shared_clear_msg(struct tf *tfp,
+ struct tf_clear_tcam_shared_entries_parms *parms);
+
+int
+tf_tcam_mgr_shared_move_msg(struct tf *tfp,
+ struct tf_move_tcam_shared_entries_parms *parms);
+#endif /* _TF_TCAM_MGR_MSG_H_ */
@@ -1,11 +1,13 @@
/* SPDX-License-Identifier: BSD-3-Clause
- * Copyright(c) 2019-2021 Broadcom
+ * Copyright(c) 2019-2023 Broadcom
* All rights reserved.
*/
#include <string.h>
#include <rte_common.h>
+#include "tf_core.h"
+
#include "tf_tcam_shared.h"
#include "tf_tcam.h"
#include "tf_common.h"
@@ -16,229 +18,8 @@
#include "tf_session.h"
#include "tf_msg.h"
#include "bitalloc.h"
-#include "tf_core.h"
-
-/** Shared WC TCAM pool identifiers
- */
-enum tf_tcam_shared_wc_pool_id {
- TF_TCAM_SHARED_WC_POOL_HI = 0,
- TF_TCAM_SHARED_WC_POOL_LO = 1,
- TF_TCAM_SHARED_WC_POOL_MAX = 2
-};
-
-/** Get string representation of a WC TCAM shared pool id
- */
-static const char *
-tf_pool_2_str(enum tf_tcam_shared_wc_pool_id id)
-{
- switch (id) {
- case TF_TCAM_SHARED_WC_POOL_HI:
- return "TCAM_SHARED_WC_POOL_HI";
- case TF_TCAM_SHARED_WC_POOL_LO:
- return "TCAM_SHARED_WC_POOL_LO";
- default:
- return "Invalid TCAM_SHARED_WC_POOL";
- }
-}
-
-/** The WC TCAM shared pool datastructure
- */
-struct tf_tcam_shared_wc_pool {
- /** Start and stride data */
- struct tf_resource_info info;
- /** bitalloc pool */
- struct bitalloc *pool;
-};
-
-struct tf_tcam_shared_wc_pools {
- struct tf_tcam_shared_wc_pool db[TF_DIR_MAX][TF_TCAM_SHARED_WC_POOL_MAX];
-};
-
-/** The WC TCAM shared pool declarations
- */
-/* struct tf_tcam_shared_wc_pool tcam_shared_wc[TF_DIR_MAX][TF_TCAM_SHARED_WC_POOL_MAX]; */
-
-static int
-tf_tcam_shared_create_db(struct tf_tcam_shared_wc_pools **db)
-{
- struct tfp_calloc_parms cparms;
- int rc = 0;
-
- cparms.nitems = 1;
- cparms.alignment = 0;
- cparms.size = sizeof(struct tf_tcam_shared_wc_pools);
- rc = tfp_calloc(&cparms);
- if (rc) {
- TFP_DRV_LOG(ERR,
- "TCAM shared db allocation failed (%s)\n",
- strerror(-rc));
- return rc;
- }
- *db = cparms.mem_va;
-
- return rc;
-}
-
-/** Create a WC TCAM shared pool
- */
-static int
-tf_tcam_shared_create_wc_pool(int dir,
- enum tf_tcam_shared_wc_pool_id id,
- int start,
- int stride,
- struct tf_tcam_shared_wc_pools *tcam_shared_wc)
-{
- int rc = 0;
- bool free = true;
- struct tfp_calloc_parms cparms;
- uint32_t pool_size;
-
- /* Create pool */
- pool_size = (BITALLOC_SIZEOF(stride) / sizeof(struct bitalloc));
- cparms.nitems = pool_size;
- cparms.alignment = 0;
- cparms.size = sizeof(struct bitalloc);
- rc = tfp_calloc(&cparms);
- if (rc) {
- TFP_DRV_LOG(ERR,
- "%s: pool memory alloc failed %s:%s\n",
- tf_dir_2_str(dir), tf_pool_2_str(id),
- strerror(-rc));
- return rc;
- }
- tcam_shared_wc->db[dir][id].pool = (struct bitalloc *)cparms.mem_va;
-
- rc = ba_init(tcam_shared_wc->db[dir][id].pool,
- stride,
- free);
-
- if (rc) {
- TFP_DRV_LOG(ERR,
- "%s: pool bitalloc failed %s\n",
- tf_dir_2_str(dir), tf_pool_2_str(id));
- return rc;
- }
-
- tcam_shared_wc->db[dir][id].info.start = start;
- tcam_shared_wc->db[dir][id].info.stride = stride;
-
- return rc;
-}
-/** Free a WC TCAM shared pool
- */
-static int
-tf_tcam_shared_free_wc_pool(int dir,
- enum tf_tcam_shared_wc_pool_id id,
- struct tf_tcam_shared_wc_pools *tcam_shared_wc)
-{
- int rc = 0;
- TF_CHECK_PARMS1(tcam_shared_wc);
-
- tcam_shared_wc->db[dir][id].info.start = 0;
- tcam_shared_wc->db[dir][id].info.stride = 0;
-
- if (tcam_shared_wc->db[dir][id].pool)
- tfp_free((void *)tcam_shared_wc->db[dir][id].pool);
- return rc;
-}
-
-/** Get the number of WC TCAM slices allocated during 1 allocation/free
- */
-static int
-tf_tcam_shared_get_slices(struct tf *tfp,
- struct tf_dev_info *dev,
- uint16_t *num_slices)
-{
- int rc;
-
- if (dev->ops->tf_dev_get_tcam_slice_info == NULL) {
- rc = -EOPNOTSUPP;
- TFP_DRV_LOG(ERR,
- "Operation not supported, rc:%s\n", strerror(-rc));
- return rc;
- }
- rc = dev->ops->tf_dev_get_tcam_slice_info(tfp,
- TF_TCAM_TBL_TYPE_WC_TCAM,
- 0,
- num_slices);
- return rc;
-}
-
-static bool
-tf_tcam_db_valid(struct tf *tfp,
- enum tf_dir dir)
-{
- struct tcam_rm_db *tcam_db;
- void *tcam_db_ptr = NULL;
- int rc;
-
- TF_CHECK_PARMS1(tfp);
-
- rc = tf_session_get_db(tfp, TF_MODULE_TYPE_TCAM, &tcam_db_ptr);
- if (rc)
- return false;
-
- tcam_db = (struct tcam_rm_db *)tcam_db_ptr;
-
- if (tcam_db->tcam_db[dir])
- return true;
-
- return false;
-}
-
-static int
-tf_tcam_shared_get_rm_info(struct tf *tfp,
- enum tf_dir dir,
- uint16_t *hcapi_type,
- struct tf_rm_alloc_info *info)
-{
- int rc;
- struct tcam_rm_db *tcam_db;
- void *tcam_db_ptr = NULL;
- struct tf_rm_get_alloc_info_parms ainfo;
- struct tf_rm_get_hcapi_parms hparms;
-
- TF_CHECK_PARMS3(tfp, hcapi_type, info);
-
- rc = tf_session_get_db(tfp, TF_MODULE_TYPE_TCAM, &tcam_db_ptr);
- if (rc) {
- TFP_DRV_LOG(INFO,
- "Tcam_db is not initialized, rc:%s\n",
- strerror(-rc));
- return 0;
- }
- tcam_db = (struct tcam_rm_db *)tcam_db_ptr;
-
- /* Convert TF type to HCAPI RM type */
- memset(&hparms, 0, sizeof(hparms));
- hparms.rm_db = tcam_db->tcam_db[dir];
- hparms.subtype = TF_TCAM_TBL_TYPE_WC_TCAM;
- hparms.hcapi_type = hcapi_type;
-
- rc = tf_rm_get_hcapi_type(&hparms);
- if (rc) {
- TFP_DRV_LOG(ERR,
- "%s: Get RM hcapi type failed %s\n",
- tf_dir_2_str(dir),
- strerror(-rc));
- return rc;
- }
-
- memset(info, 0, sizeof(struct tf_rm_alloc_info));
- ainfo.rm_db = tcam_db->tcam_db[dir];
- ainfo.subtype = TF_TCAM_TBL_TYPE_WC_TCAM;
- ainfo.info = info;
-
- rc = tf_rm_get_info(&ainfo);
- if (rc) {
- TFP_DRV_LOG(ERR,
- "%s: TCAM rm info get failed %s\n",
- tf_dir_2_str(dir),
- strerror(-rc));
- return rc;
- }
- return rc;
-}
+#include "tf_rm.h"
+#include "tf_tcam_mgr_msg.h"
/**
* tf_tcam_shared_bind
@@ -247,92 +28,15 @@ int
tf_tcam_shared_bind(struct tf *tfp,
struct tf_tcam_cfg_parms *parms)
{
- int rc, dir;
- struct tf_session *tfs;
- struct tf_dev_info *dev;
- struct tf_rm_alloc_info info;
- uint16_t start, stride;
- uint16_t num_slices;
- uint16_t hcapi_type;
- struct tf_tcam_shared_wc_pools *tcam_shared_wc = NULL;
+ int rc;
TF_CHECK_PARMS2(tfp, parms);
/* Perform normal bind
*/
rc = tf_tcam_bind(tfp, parms);
- if (rc)
- return rc;
-
- /* After the normal TCAM bind, if this is a shared session
- * create all required databases for the WC_HI and WC_LO pools
- */
- rc = tf_session_get_session_internal(tfp, &tfs);
- if (rc) {
- TFP_DRV_LOG(ERR,
- "Session access failure: %s\n", strerror(-rc));
- return rc;
- }
- if (tf_session_is_shared_session(tfs)) {
- /* Retrieve the device information */
- rc = tf_session_get_device(tfs, &dev);
- if (rc)
- return rc;
-
- tf_tcam_shared_create_db(&tcam_shared_wc);
-
-
- /* If there are WC TCAM entries, create 2 pools each with 1/2
- * the total number of entries
- */
- for (dir = 0; dir < TF_DIR_MAX; dir++) {
- if (!tf_tcam_db_valid(tfp, dir))
- continue;
-
- rc = tf_tcam_shared_get_rm_info(tfp,
- dir,
- &hcapi_type,
- &info);
- if (rc) {
- TFP_DRV_LOG(ERR,
- "%s: TCAM rm info get failed\n",
- tf_dir_2_str(dir));
- goto done;
- }
-
- start = info.entry.start;
- stride = info.entry.stride / 2;
-
- tf_tcam_shared_create_wc_pool(dir,
- TF_TCAM_SHARED_WC_POOL_HI,
- start,
- stride,
- tcam_shared_wc);
-
- start += stride;
- tf_tcam_shared_create_wc_pool(dir,
- TF_TCAM_SHARED_WC_POOL_LO,
- start,
- stride,
- tcam_shared_wc);
-
- tf_session_set_tcam_shared_db(tfp, (void *)tcam_shared_wc);
- }
-
- rc = tf_tcam_shared_get_slices(tfp,
- dev,
- &num_slices);
- if (rc)
- return rc;
-
- if (num_slices > 1) {
- TFP_DRV_LOG(ERR,
- "Only single slice supported\n");
- return -EOPNOTSUPP;
- }
- }
-done:
return rc;
+
}
/**
* tf_tcam_shared_unbind
@@ -340,132 +44,10 @@ tf_tcam_shared_bind(struct tf *tfp,
int
tf_tcam_shared_unbind(struct tf *tfp)
{
- int rc, dir;
- struct tf_dev_info *dev;
- struct tf_session *tfs;
- void *tcam_shared_db_ptr = NULL;
- struct tf_tcam_shared_wc_pools *tcam_shared_wc;
- enum tf_tcam_shared_wc_pool_id pool_id;
- struct tf_tcam_free_parms parms;
- struct bitalloc *pool;
- uint16_t start;
- int log_idx, phy_idx;
- uint16_t hcapi_type;
- struct tf_rm_alloc_info info;
- int i, pool_cnt;
+ int rc;
TF_CHECK_PARMS1(tfp);
- /* Retrieve the session information */
- rc = tf_session_get_session_internal(tfp, &tfs);
- if (rc)
- return rc;
-
- /* If not the shared session, call the normal
- * tcam unbind and exit
- */
- if (!tf_session_is_shared_session(tfs)) {
- rc = tf_tcam_unbind(tfp);
- return rc;
- }
-
- /* We must be a shared session, get the database
- */
- rc = tf_session_get_tcam_shared_db(tfp,
- (void *)&tcam_shared_db_ptr);
- if (rc) {
- TFP_DRV_LOG(ERR,
- "Failed to get tcam_shared_db, rc:%s\n",
- strerror(-rc));
- return rc;
- }
-
- tcam_shared_wc =
- (struct tf_tcam_shared_wc_pools *)tcam_shared_db_ptr;
-
-
- /* Get the device
- */
- rc = tf_session_get_device(tfs, &dev);
- if (rc)
- return rc;
-
-
- /* If there are WC TCAM entries allocated, free them
- */
- for (dir = 0; dir < TF_DIR_MAX; dir++) {
- /* If the database is invalid, skip
- */
- if (!tf_tcam_db_valid(tfp, dir))
- continue;
-
- rc = tf_tcam_shared_get_rm_info(tfp,
- dir,
- &hcapi_type,
- &info);
- if (rc) {
- TFP_DRV_LOG(ERR,
- "%s: TCAM shared rm info get failed\n",
- tf_dir_2_str(dir));
- return rc;
- }
-
- for (pool_id = TF_TCAM_SHARED_WC_POOL_HI;
- pool_id < TF_TCAM_SHARED_WC_POOL_MAX;
- pool_id++) {
- pool = tcam_shared_wc->db[dir][pool_id].pool;
- start = tcam_shared_wc->db[dir][pool_id].info.start;
- pool_cnt = ba_inuse_count(pool);
-
- if (pool_cnt) {
- TFP_DRV_LOG(INFO,
- "%s: %s: %d residuals found, freeing\n",
- tf_dir_2_str(dir),
- tf_pool_2_str(pool_id),
- pool_cnt);
- }
-
- log_idx = 0;
-
- for (i = 0; i < pool_cnt; i++) {
- log_idx = ba_find_next_inuse(pool, log_idx);
-
- if (log_idx < 0) {
- TFP_DRV_LOG(ERR,
- "Expected a found %s entry %d\n",
- tf_pool_2_str(pool_id),
- i);
- /* attempt normal unbind
- */
- goto done;
- }
- phy_idx = start + log_idx;
-
- parms.type = TF_TCAM_TBL_TYPE_WC_TCAM;
- parms.hcapi_type = hcapi_type;
- parms.idx = phy_idx;
- parms.dir = dir;
- rc = tf_msg_tcam_entry_free(tfp, dev, &parms);
- if (rc) {
- /* Log error */
- TFP_DRV_LOG(ERR,
- "%s: %s: %d free failed, rc:%s\n",
- tf_dir_2_str(parms.dir),
- tf_tcam_tbl_2_str(parms.type),
- phy_idx,
- strerror(-rc));
- return rc;
- }
- }
- /* Free the pool once all the entries
- * have been cleared
- */
- tf_tcam_shared_free_wc_pool(dir,
- pool_id,
- tcam_shared_wc);
- }
- }
-done:
rc = tf_tcam_unbind(tfp);
return rc;
}
@@ -478,79 +60,11 @@ tf_tcam_shared_alloc(struct tf *tfp,
struct tf_tcam_alloc_parms *parms)
{
int rc;
- struct tf_session *tfs;
- struct tf_dev_info *dev;
- int log_idx;
- struct bitalloc *pool;
- enum tf_tcam_shared_wc_pool_id id;
- struct tf_tcam_shared_wc_pools *tcam_shared_wc;
- void *tcam_shared_db_ptr = NULL;
TF_CHECK_PARMS2(tfp, parms);
- /* Retrieve the session information */
- rc = tf_session_get_session_internal(tfp, &tfs);
- if (rc)
- return rc;
-
- /* If we aren't the shared session or the type is
- * not one of the special WC TCAM types, call the normal
- * allocation.
- */
- if (!tf_session_is_shared_session(tfs) ||
- (parms->type != TF_TCAM_TBL_TYPE_WC_TCAM_HIGH &&
- parms->type != TF_TCAM_TBL_TYPE_WC_TCAM_LOW)) {
- /* Perform normal alloc
- */
- rc = tf_tcam_alloc(tfp, parms);
- return rc;
- }
-
- if (!tf_tcam_db_valid(tfp, parms->dir)) {
- TFP_DRV_LOG(ERR,
- "%s: tcam shared pool doesn't exist\n",
- tf_dir_2_str(parms->dir));
- return -ENOMEM;
- }
-
- rc = tf_session_get_tcam_shared_db(tfp, (void *)&tcam_shared_db_ptr);
- if (rc) {
- TFP_DRV_LOG(ERR,
- "Failed to get tcam_shared_db from session, rc:%s\n",
- strerror(-rc));
- return rc;
- }
- tcam_shared_wc = (struct tf_tcam_shared_wc_pools *)tcam_shared_db_ptr;
-
- if (parms->type == TF_TCAM_TBL_TYPE_WC_TCAM_HIGH)
- id = TF_TCAM_SHARED_WC_POOL_HI;
- else
- id = TF_TCAM_SHARED_WC_POOL_LO;
-
- /* Retrieve the device information */
- rc = tf_session_get_device(tfs, &dev);
- if (rc)
- return rc;
-
- pool = tcam_shared_wc->db[parms->dir][id].pool;
-
- /*
- * priority 0: allocate from top of the tcam i.e. high
- * priority !0: allocate index from bottom i.e lowest
- */
- if (parms->priority)
- log_idx = ba_alloc_reverse(pool);
- else
- log_idx = ba_alloc(pool);
- if (log_idx == BA_FAIL) {
- TFP_DRV_LOG(ERR,
- "%s: Allocation failed, rc:%s\n",
- tf_dir_2_str(parms->dir),
- strerror(ENOMEM));
- return -ENOMEM;
- }
- parms->idx = log_idx;
- return 0;
+ rc = tf_tcam_alloc(tfp, parms);
+ return rc;
}
int
@@ -558,118 +72,11 @@ tf_tcam_shared_free(struct tf *tfp,
struct tf_tcam_free_parms *parms)
{
int rc;
- struct tf_session *tfs;
- struct tf_dev_info *dev;
- int allocated = 0;
- uint16_t start;
- int phy_idx;
- struct bitalloc *pool;
- enum tf_tcam_shared_wc_pool_id id;
- struct tf_tcam_free_parms nparms;
- uint16_t hcapi_type;
- struct tf_rm_alloc_info info;
- void *tcam_shared_db_ptr = NULL;
- struct tf_tcam_shared_wc_pools *tcam_shared_wc;
TF_CHECK_PARMS2(tfp, parms);
- /* Retrieve the session information */
- rc = tf_session_get_session_internal(tfp, &tfs);
- if (rc)
- return rc;
-
- /* If we aren't the shared session or the type is
- * not one of the special WC TCAM types, call the normal
- * allocation.
- */
- if (!tf_session_is_shared_session(tfs) ||
- (parms->type != TF_TCAM_TBL_TYPE_WC_TCAM_HIGH &&
- parms->type != TF_TCAM_TBL_TYPE_WC_TCAM_LOW)) {
- /* Perform normal free
- */
- rc = tf_tcam_free(tfp, parms);
- return rc;
- }
-
- if (!tf_tcam_db_valid(tfp, parms->dir)) {
- TFP_DRV_LOG(ERR,
- "%s: tcam shared pool doesn't exist\n",
- tf_dir_2_str(parms->dir));
- return -ENOMEM;
- }
-
- rc = tf_session_get_tcam_shared_db(tfp, (void *)&tcam_shared_db_ptr);
- if (rc) {
- TFP_DRV_LOG(ERR,
- "Failed to get tcam_shared_db from session, rc:%s\n",
- strerror(-rc));
- return rc;
- }
- tcam_shared_wc = (struct tf_tcam_shared_wc_pools *)tcam_shared_db_ptr;
-
-
- if (parms->type == TF_TCAM_TBL_TYPE_WC_TCAM_HIGH)
- id = TF_TCAM_SHARED_WC_POOL_HI;
- else
- id = TF_TCAM_SHARED_WC_POOL_LO;
-
- /* Retrieve the device information */
- rc = tf_session_get_device(tfs, &dev);
- if (rc)
- return rc;
-
- rc = tf_tcam_shared_get_rm_info(tfp,
- parms->dir,
- &hcapi_type,
- &info);
- if (rc) {
- TFP_DRV_LOG(ERR,
- "%s: TCAM rm info get failed\n",
- tf_dir_2_str(parms->dir));
- return rc;
- }
-
- pool = tcam_shared_wc->db[parms->dir][id].pool;
- start = tcam_shared_wc->db[parms->dir][id].info.start;
-
- phy_idx = parms->idx + start;
- allocated = ba_inuse(pool, parms->idx);
-
- if (allocated != TF_RM_ALLOCATED_ENTRY_IN_USE) {
- TFP_DRV_LOG(ERR,
- "%s: Entry already free, type:%d, idx:%d\n",
- tf_dir_2_str(parms->dir), parms->type, parms->idx);
- return -EINVAL;
- }
-
- rc = ba_free(pool, parms->idx);
- if (rc) {
- TFP_DRV_LOG(ERR,
- "%s: Free failed, type:%s, idx:%d\n",
- tf_dir_2_str(parms->dir),
- tf_tcam_tbl_2_str(parms->type),
- parms->idx);
- return rc;
- }
-
- /* Override HI/LO type with parent WC TCAM type */
- nparms = *parms;
- nparms.type = TF_TCAM_TBL_TYPE_WC_TCAM;
- nparms.hcapi_type = hcapi_type;
- nparms.idx = phy_idx;
-
- rc = tf_msg_tcam_entry_free(tfp, dev, &nparms);
- if (rc) {
- /* Log error */
- TFP_DRV_LOG(ERR,
- "%s: %s: log%d free failed, rc:%s\n",
- tf_dir_2_str(nparms.dir),
- tf_tcam_tbl_2_str(nparms.type),
- phy_idx,
- strerror(-rc));
- return rc;
- }
- return 0;
+ rc = tf_tcam_free(tfp, parms);
+ return rc;
}
int
@@ -677,109 +84,11 @@ tf_tcam_shared_set(struct tf *tfp __rte_unused,
struct tf_tcam_set_parms *parms __rte_unused)
{
int rc;
- struct tf_session *tfs;
- struct tf_dev_info *dev;
- int allocated = 0;
- int phy_idx, log_idx;
- struct tf_tcam_set_parms nparms;
- struct bitalloc *pool;
- uint16_t start;
- enum tf_tcam_shared_wc_pool_id id;
- uint16_t hcapi_type;
- struct tf_rm_alloc_info info;
- struct tf_tcam_shared_wc_pools *tcam_shared_wc;
- void *tcam_shared_db_ptr = NULL;
-
TF_CHECK_PARMS2(tfp, parms);
- /* Retrieve the session information */
- rc = tf_session_get_session_internal(tfp, &tfs);
- if (rc)
- return rc;
-
- /* If we aren't the shared session or one of our
- * special types
- */
- if (!tf_session_is_shared_session(tfs) ||
- (parms->type != TF_TCAM_TBL_TYPE_WC_TCAM_HIGH &&
- parms->type != TF_TCAM_TBL_TYPE_WC_TCAM_LOW)) {
- /* Perform normal set and exit
- */
- rc = tf_tcam_set(tfp, parms);
- return rc;
- }
-
- if (!tf_tcam_db_valid(tfp, parms->dir)) {
- TFP_DRV_LOG(ERR,
- "%s: tcam shared pool doesn't exist\n",
- tf_dir_2_str(parms->dir));
- return -ENOMEM;
- }
-
- /* Retrieve the device information */
- rc = tf_session_get_device(tfs, &dev);
- if (rc)
- return rc;
-
- if (parms->type == TF_TCAM_TBL_TYPE_WC_TCAM_HIGH)
- id = TF_TCAM_SHARED_WC_POOL_HI;
- else
- id = TF_TCAM_SHARED_WC_POOL_LO;
-
- rc = tf_session_get_tcam_shared_db(tfp, (void *)&tcam_shared_db_ptr);
- if (rc) {
- TFP_DRV_LOG(ERR,
- "Failed to get tcam_shared_db from session, rc:%s\n",
- strerror(-rc));
- return rc;
- }
- tcam_shared_wc = (struct tf_tcam_shared_wc_pools *)tcam_shared_db_ptr;
-
- pool = tcam_shared_wc->db[parms->dir][id].pool;
- start = tcam_shared_wc->db[parms->dir][id].info.start;
-
- log_idx = parms->idx;
- phy_idx = parms->idx + start;
- allocated = ba_inuse(pool, parms->idx);
-
- if (allocated != TF_RM_ALLOCATED_ENTRY_IN_USE) {
- TFP_DRV_LOG(ERR,
- "%s: Entry is not allocated, type:%d, logid:%d\n",
- tf_dir_2_str(parms->dir), parms->type, log_idx);
- return -EINVAL;
- }
-
- rc = tf_tcam_shared_get_rm_info(tfp,
- parms->dir,
- &hcapi_type,
- &info);
- if (rc)
- return rc;
-
- /* Override HI/LO type with parent WC TCAM type */
- nparms.hcapi_type = hcapi_type;
- nparms.dir = parms->dir;
- nparms.type = TF_TCAM_TBL_TYPE_WC_TCAM;
- nparms.idx = phy_idx;
- nparms.key = parms->key;
- nparms.mask = parms->mask;
- nparms.key_size = parms->key_size;
- nparms.result = parms->result;
- nparms.result_size = parms->result_size;
-
- rc = tf_msg_tcam_entry_set(tfp, dev, &nparms);
- if (rc) {
- /* Log error */
- TFP_DRV_LOG(ERR,
- "%s: %s: phy entry %d set failed, rc:%s",
- tf_dir_2_str(parms->dir),
- tf_tcam_tbl_2_str(nparms.type),
- phy_idx,
- strerror(-rc));
- return rc;
- }
- return 0;
+ rc = tf_tcam_set(tfp, parms);
+ return rc;
}
int
@@ -787,226 +96,10 @@ tf_tcam_shared_get(struct tf *tfp __rte_unused,
struct tf_tcam_get_parms *parms)
{
int rc;
- struct tf_session *tfs;
- struct tf_dev_info *dev;
- int allocated = 0;
- int phy_idx, log_idx;
- struct tf_tcam_get_parms nparms;
- struct bitalloc *pool;
- uint16_t start;
- enum tf_tcam_shared_wc_pool_id id;
- uint16_t hcapi_type;
- struct tf_rm_alloc_info info;
- struct tf_tcam_shared_wc_pools *tcam_shared_wc;
- void *tcam_shared_db_ptr = NULL;
TF_CHECK_PARMS2(tfp, parms);
- /* Retrieve the session information */
- rc = tf_session_get_session_internal(tfp, &tfs);
- if (rc)
- return rc;
-
- /* If we aren't the shared session or one of our
- * special types
- */
- if (!tf_session_is_shared_session(tfs) ||
- (parms->type != TF_TCAM_TBL_TYPE_WC_TCAM_HIGH &&
- parms->type != TF_TCAM_TBL_TYPE_WC_TCAM_LOW)) {
- /* Perform normal get and exit
- */
- rc = tf_tcam_get(tfp, parms);
- return rc;
- }
-
- if (!tf_tcam_db_valid(tfp, parms->dir)) {
- TFP_DRV_LOG(ERR,
- "%s: tcam shared pool doesn't exist\n",
- tf_dir_2_str(parms->dir));
- return -ENOMEM;
- }
-
- /* Retrieve the device information */
- rc = tf_session_get_device(tfs, &dev);
- if (rc)
- return rc;
- if (parms->type == TF_TCAM_TBL_TYPE_WC_TCAM_HIGH)
- id = TF_TCAM_SHARED_WC_POOL_HI;
- else
- id = TF_TCAM_SHARED_WC_POOL_LO;
-
-
- rc = tf_session_get_tcam_shared_db(tfp, (void *)&tcam_shared_db_ptr);
- if (rc) {
- TFP_DRV_LOG(ERR,
- "Failed to get tcam_shared_db from session, rc:%s\n",
- strerror(-rc));
- return rc;
- }
- tcam_shared_wc = (struct tf_tcam_shared_wc_pools *)tcam_shared_db_ptr;
-
- pool = tcam_shared_wc->db[parms->dir][id].pool;
- start = tcam_shared_wc->db[parms->dir][id].info.start;
-
- log_idx = parms->idx;
- phy_idx = parms->idx + start;
- allocated = ba_inuse(pool, parms->idx);
-
- if (allocated != TF_RM_ALLOCATED_ENTRY_IN_USE) {
- TFP_DRV_LOG(ERR,
- "%s: Entry is not allocated, type:%d, logid:%d\n",
- tf_dir_2_str(parms->dir), parms->type, log_idx);
- return -EINVAL;
- }
-
- rc = tf_tcam_shared_get_rm_info(tfp,
- parms->dir,
- &hcapi_type,
- &info);
- if (rc)
- return rc;
-
- /* Override HI/LO type with parent WC TCAM type */
- nparms = *parms;
- nparms.type = TF_TCAM_TBL_TYPE_WC_TCAM;
- nparms.hcapi_type = hcapi_type;
- nparms.idx = phy_idx;
-
- rc = tf_msg_tcam_entry_get(tfp, dev, &nparms);
- if (rc) {
- /* Log error */
- TFP_DRV_LOG(ERR,
- "%s: %s: Entry %d set failed, rc:%s",
- tf_dir_2_str(nparms.dir),
- tf_tcam_tbl_2_str(nparms.type),
- nparms.idx,
- strerror(-rc));
- return rc;
- }
- return 0;
-}
-
-/* Normally, device specific code wouldn't reside here, it belongs
- * in a separate device specific function in tf_device_pxx.c.
- * But this code is placed here as it is not a long term solution
- * and we would like to have this code centrally located for easy
- * removal
- */
-#define TF_TCAM_SHARED_KEY_SLICE_SZ_BYTES_P4 12
-#define TF_TCAM_SHARED_REMAP_SZ_BYTES_P4 4
-#define TF_TCAM_SHARED_KEY_SLICE_SZ_BYTES_P58 24
-#define TF_TCAM_SHARED_REMAP_SZ_BYTES_P58 8
-
-/* Temporary builder defines pulled in here and adjusted
- * for max WC TCAM values
- */
-union tf_tmp_field_obj {
- uint32_t words[(TF_TCAM_SHARED_REMAP_SZ_BYTES_P58 + 3) / 4];
- uint8_t bytes[TF_TCAM_SHARED_REMAP_SZ_BYTES_P58];
-};
-
-union tf_tmp_key {
- uint32_t words[(TF_TCAM_SHARED_KEY_SLICE_SZ_BYTES_P58 + 3) / 4];
- uint8_t bytes[TF_TCAM_SHARED_KEY_SLICE_SZ_BYTES_P58];
-};
-
-/** p58 has an enable bit, p4 does not
- */
-#define TF_TCAM_SHARED_ENTRY_ENABLE 0x8
-
-/** Move a WC TCAM entry from the high offset to the same low offset
- */
-static int
-tf_tcam_shared_move_entry(struct tf *tfp,
- struct tf_dev_info *dev,
- uint16_t hcapi_type,
- enum tf_dir dir,
- int sphy_idx,
- int dphy_idx,
- int key_sz_bytes,
- int remap_sz_bytes,
- bool set_enable_bit)
-{
- int rc = 0;
- struct tf_tcam_get_parms gparms;
- struct tf_tcam_set_parms sparms;
- struct tf_tcam_free_parms fparms;
- union tf_tmp_key tcam_key_obj;
- union tf_tmp_key tcam_key_msk_obj;
- union tf_tmp_field_obj tcam_remap_obj;
-
- memset(&tcam_key_obj, 0, sizeof(tcam_key_obj));
- memset(&tcam_key_msk_obj, 0, sizeof(tcam_key_msk_obj));
- memset(&tcam_remap_obj, 0, sizeof(tcam_remap_obj));
- memset(&gparms, 0, sizeof(gparms));
-
- gparms.hcapi_type = hcapi_type;
- gparms.dir = dir;
- gparms.type = TF_TCAM_TBL_TYPE_WC_TCAM;
- gparms.idx = sphy_idx;
- gparms.key = (uint8_t *)&tcam_key_obj;
- gparms.key_size = key_sz_bytes;
- gparms.mask = (uint8_t *)&tcam_key_msk_obj;
- gparms.result = (uint8_t *)&tcam_remap_obj;
- gparms.result_size = remap_sz_bytes;
-
- rc = tf_msg_tcam_entry_get(tfp, dev, &gparms);
- if (rc) {
- /* Log error */
- TFP_DRV_LOG(ERR,
- "%s: %s: phyid(%d) get failed, rc:%s\n",
- tf_tcam_tbl_2_str(gparms.type),
- tf_dir_2_str(dir),
- gparms.idx,
- strerror(-rc));
- return rc;
- }
-
- if (set_enable_bit)
- tcam_key_obj.bytes[0] |= TF_TCAM_SHARED_ENTRY_ENABLE;
-
- /* Override HI/LO type with parent WC TCAM type */
- sparms.hcapi_type = hcapi_type;
- sparms.dir = dir;
- sparms.type = TF_TCAM_TBL_TYPE_WC_TCAM;
- sparms.idx = dphy_idx;
- sparms.key = gparms.key;
- sparms.mask = gparms.mask;
- sparms.key_size = key_sz_bytes;
- sparms.result = gparms.result;
- sparms.result_size = remap_sz_bytes;
-
- rc = tf_msg_tcam_entry_set(tfp, dev, &sparms);
- if (rc) {
- /* Log error */
- TFP_DRV_LOG(ERR,
- "%s: %s phyid(%d/0x%x) set failed, rc:%s\n",
- tf_tcam_tbl_2_str(sparms.type),
- tf_dir_2_str(dir),
- sparms.idx,
- sparms.idx,
- strerror(-rc));
- return rc;
- }
-
- /* Override HI/LO type with parent WC TCAM type */
- fparms.dir = dir;
- fparms.type = TF_TCAM_TBL_TYPE_WC_TCAM;
- fparms.hcapi_type = hcapi_type;
- fparms.idx = sphy_idx;
-
- rc = tf_msg_tcam_entry_free(tfp, dev, &fparms);
- if (rc) {
- /* Log error */
- TFP_DRV_LOG(ERR,
- "%s: %s: phyid(%d/0x%x) free failed, rc:%s\n",
- tf_dir_2_str(dir),
- tf_tcam_tbl_2_str(fparms.type),
- sphy_idx,
- sphy_idx,
- strerror(-rc));
- return rc;
- }
+ rc = tf_tcam_get(tfp, parms);
return rc;
}
@@ -1015,23 +108,10 @@ tf_tcam_shared_move_entry(struct tf *tfp,
*/
static
int tf_tcam_shared_move(struct tf *tfp,
- struct tf_move_tcam_shared_entries_parms *parms,
- int key_sz_bytes,
- int remap_sz_bytes,
- bool set_enable_bit)
+ struct tf_move_tcam_shared_entries_parms *parms)
{
- int rc;
struct tf_session *tfs;
- struct tf_dev_info *dev;
- int log_idx;
- struct bitalloc *hi_pool, *lo_pool;
- uint16_t hi_start, lo_start;
- enum tf_tcam_shared_wc_pool_id hi_id, lo_id;
- uint16_t hcapi_type;
- struct tf_rm_alloc_info info;
- int hi_cnt, i;
- struct tf_tcam_shared_wc_pools *tcam_shared_wc;
- void *tcam_shared_db_ptr = NULL;
+ int rc;
TF_CHECK_PARMS2(tfp, parms);
@@ -1052,104 +132,7 @@ int tf_tcam_shared_move(struct tf *tfp,
return -EOPNOTSUPP;
}
- if (!tf_tcam_db_valid(tfp, parms->dir)) {
- TFP_DRV_LOG(ERR,
- "%s: tcam shared pool doesn't exist\n",
- tf_dir_2_str(parms->dir));
- return -ENOMEM;
- }
-
- /* Retrieve the device information */
- rc = tf_session_get_device(tfs, &dev);
- if (rc) {
- /* TODO print amazing error */
- return rc;
- }
-
- rc = tf_tcam_shared_get_rm_info(tfp,
- parms->dir,
- &hcapi_type,
- &info);
- if (rc) {
- TFP_DRV_LOG(ERR,
- "%s: TCAM rm info get failed\n",
- tf_dir_2_str(parms->dir));
- return rc;
- }
-
- rc = tf_session_get_tcam_shared_db(tfp, (void *)&tcam_shared_db_ptr);
- if (rc) {
- TFP_DRV_LOG(ERR,
- "Failed to get tcam_shared_db from session, rc:%s\n",
- strerror(-rc));
- return rc;
- }
- tcam_shared_wc = (struct tf_tcam_shared_wc_pools *)tcam_shared_db_ptr;
-
- hi_id = TF_TCAM_SHARED_WC_POOL_HI;
- hi_pool = tcam_shared_wc->db[parms->dir][hi_id].pool;
- hi_start = tcam_shared_wc->db[parms->dir][hi_id].info.start;
-
- lo_id = TF_TCAM_SHARED_WC_POOL_LO;
- lo_pool = tcam_shared_wc->db[parms->dir][lo_id].pool;
- lo_start = tcam_shared_wc->db[parms->dir][lo_id].info.start;
-
- if (hi_pool == NULL || lo_pool == NULL)
- return -ENOMEM;
-
- /* Get the total count of in use entries in the high pool
- */
- hi_cnt = ba_inuse_count(hi_pool);
-
- /* Copy each valid entry to the same low pool logical offset
- */
- log_idx = 0;
-
- for (i = 0; i < hi_cnt; i++) {
- /* Find next free index starting from where we left off
- */
- log_idx = ba_find_next_inuse(hi_pool, log_idx);
- if (log_idx < 0) {
- TFP_DRV_LOG(ERR,
- "Expected a found %s entry %d\n",
- tf_pool_2_str(hi_id),
- i);
- goto done;
- }
- /* The user should have never allocated from the low
- * pool because the move only happens when switching
- * from the high to the low pool
- */
- if (ba_alloc_index(lo_pool, log_idx) < 0) {
- TFP_DRV_LOG(ERR,
- "Warning %s index %d already allocated\n",
- tf_pool_2_str(lo_id),
- i);
-
- /* Since already allocated, continue with move
- */
- }
-
- rc = tf_tcam_shared_move_entry(tfp, dev,
- hcapi_type,
- parms->dir,
- hi_start + log_idx,
- lo_start + log_idx,
- key_sz_bytes,
- remap_sz_bytes,
- set_enable_bit);
- if (rc) {
- TFP_DRV_LOG(ERR,
- "%s: Move error %s to %s index %d\n",
- tf_dir_2_str(parms->dir),
- tf_pool_2_str(hi_id),
- tf_pool_2_str(lo_id),
- i);
- goto done;
- }
- ba_free(hi_pool, log_idx);
- }
-done:
+ rc = tf_tcam_mgr_shared_move_msg(tfp, parms);
return rc;
}
@@ -1159,24 +142,17 @@ tf_tcam_shared_move_p4(struct tf *tfp,
{
int rc = 0;
rc = tf_tcam_shared_move(tfp,
- parms,
- TF_TCAM_SHARED_KEY_SLICE_SZ_BYTES_P4,
- TF_TCAM_SHARED_REMAP_SZ_BYTES_P4,
- false); /* no enable bit */
+ parms);
return rc;
}
-
int
tf_tcam_shared_move_p58(struct tf *tfp,
struct tf_move_tcam_shared_entries_parms *parms)
{
int rc = 0;
rc = tf_tcam_shared_move(tfp,
- parms,
- TF_TCAM_SHARED_KEY_SLICE_SZ_BYTES_P58,
- TF_TCAM_SHARED_REMAP_SZ_BYTES_P58,
- true); /* set enable bit */
+ parms);
return rc;
}
@@ -1186,16 +162,6 @@ tf_tcam_shared_clear(struct tf *tfp,
{
int rc = 0;
struct tf_session *tfs;
- struct tf_dev_info *dev;
- uint16_t start;
- int phy_idx;
- enum tf_tcam_shared_wc_pool_id id;
- struct tf_tcam_free_parms nparms;
- uint16_t hcapi_type;
- struct tf_rm_alloc_info info;
- void *tcam_shared_db_ptr = NULL;
- struct tf_tcam_shared_wc_pools *tcam_shared_wc;
- int i, cnt;
TF_CHECK_PARMS2(tfp, parms);
@@ -1209,74 +175,6 @@ tf_tcam_shared_clear(struct tf *tfp,
parms->tcam_tbl_type != TF_TCAM_TBL_TYPE_WC_TCAM_LOW))
return -EOPNOTSUPP;
- if (!tf_tcam_db_valid(tfp, parms->dir)) {
- TFP_DRV_LOG(ERR,
- "%s: tcam shared pool doesn't exist\n",
- tf_dir_2_str(parms->dir));
- return -ENOMEM;
- }
-
- rc = tf_session_get_tcam_shared_db(tfp, (void *)&tcam_shared_db_ptr);
- if (rc) {
- TFP_DRV_LOG(ERR,
- "Failed to get tcam_shared_db from session, rc:%s\n",
- strerror(-rc));
- return rc;
- }
- tcam_shared_wc = (struct tf_tcam_shared_wc_pools *)tcam_shared_db_ptr;
-
-
- if (parms->tcam_tbl_type == TF_TCAM_TBL_TYPE_WC_TCAM_HIGH)
- id = TF_TCAM_SHARED_WC_POOL_HI;
- else
- id = TF_TCAM_SHARED_WC_POOL_LO;
-
-
- /* Retrieve the device information */
- rc = tf_session_get_device(tfs, &dev);
- if (rc)
- return rc;
-
- rc = tf_tcam_shared_get_rm_info(tfp,
- parms->dir,
- &hcapi_type,
- &info);
- if (rc) {
- TFP_DRV_LOG(ERR,
- "%s: TCAM rm info get failed\n",
- tf_dir_2_str(parms->dir));
- return rc;
- }
-
- start = tcam_shared_wc->db[parms->dir][id].info.start;
- cnt = tcam_shared_wc->db[parms->dir][id].info.stride;
-
- /* Override HI/LO type with parent WC TCAM type */
- nparms.dir = parms->dir;
- nparms.type = TF_TCAM_TBL_TYPE_WC_TCAM;
- nparms.hcapi_type = hcapi_type;
-
- for (i = 0; i < cnt; i++) {
- phy_idx = start + i;
- nparms.idx = phy_idx;
-
- /* Clear entry */
- rc = tf_msg_tcam_entry_free(tfp, dev, &nparms);
- if (rc) {
- /* Log error */
- TFP_DRV_LOG(ERR,
- "%s: %s: log%d free failed, rc:%s\n",
- tf_dir_2_str(nparms.dir),
- tf_tcam_tbl_2_str(nparms.type),
- phy_idx,
- strerror(-rc));
- return rc;
- }
- }
-
- TFP_DRV_LOG(DEBUG,
- "%s: TCAM shared clear pool(%s)\n",
- tf_dir_2_str(nparms.dir),
- tf_pool_2_str(id));
- return 0;
+ rc = tf_tcam_mgr_shared_clear_msg(tfp, parms);
+ return rc;
}
@@ -1,5 +1,5 @@
/* SPDX-License-Identifier: BSD-3-Clause
- * Copyright(c) 2019-2021 Broadcom
+ * Copyright(c) 2019-2023 Broadcom
* All rights reserved.
*/
@@ -129,7 +129,6 @@ int tf_tcam_shared_set(struct tf *tfp,
int tf_tcam_shared_get(struct tf *tfp,
struct tf_tcam_get_parms *parms);
-
/**
* Moves entries from the WC_TCAM_HI to the WC_TCAM_LO shared pools
* for the P4 device.
@@ -448,13 +448,13 @@ ulp_ctx_shared_session_open(struct bnxt *bp,
switch (ulp_dev_id) {
case BNXT_ULP_DEVICE_ID_WH_PLUS:
- parms.device_type = TF_DEVICE_TYPE_WH;
+ parms.device_type = TF_DEVICE_TYPE_P5;
break;
case BNXT_ULP_DEVICE_ID_STINGRAY:
parms.device_type = TF_DEVICE_TYPE_SR;
break;
case BNXT_ULP_DEVICE_ID_THOR:
- parms.device_type = TF_DEVICE_TYPE_THOR;
+ parms.device_type = TF_DEVICE_TYPE_P4;
break;
default:
BNXT_TF_DBG(ERR, "Unable to determine dev for opening session.\n");
@@ -563,13 +563,13 @@ ulp_ctx_session_open(struct bnxt *bp,
switch (ulp_dev_id) {
case BNXT_ULP_DEVICE_ID_WH_PLUS:
- params.device_type = TF_DEVICE_TYPE_WH;
+ params.device_type = TF_DEVICE_TYPE_P5;
break;
case BNXT_ULP_DEVICE_ID_STINGRAY:
params.device_type = TF_DEVICE_TYPE_SR;
break;
case BNXT_ULP_DEVICE_ID_THOR:
- params.device_type = TF_DEVICE_TYPE_THOR;
+ params.device_type = TF_DEVICE_TYPE_P4;
break;
default:
BNXT_TF_DBG(ERR, "Unable to determine device for opening session.\n");