1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2014-2021 Broadcom
7 #include <rte_malloc.h>
9 #include "ulp_template_db_enum.h"
10 #include "ulp_template_struct.h"
11 #include "bnxt_tf_common.h"
12 #include "ulp_utils.h"
15 #include "tf_ext_flow_handle.h"
16 #include "ulp_mark_mgr.h"
17 #include "ulp_mapper.h"
18 #include "ulp_flow_db.h"
20 #include "ulp_template_db_tbl.h"
21 #include "ulp_port_db.h"
22 #include "ulp_ha_mgr.h"
23 #include "bnxt_tf_pmd_shim.h"
25 static uint8_t mapper_fld_zeros[16] = { 0 };
27 static uint8_t mapper_fld_ones[16] = {
28 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
29 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
32 static uint8_t mapper_fld_one[16] = {
33 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
34 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01
38 ulp_mapper_tmpl_name_str(enum bnxt_ulp_template_type tmpl_type)
41 case BNXT_ULP_TEMPLATE_TYPE_CLASS:
43 case BNXT_ULP_TEMPLATE_TYPE_ACTION:
46 return "invalid template type";
50 static struct bnxt_ulp_glb_resource_info *
51 ulp_mapper_glb_resource_info_list_get(uint32_t *num_entries)
55 *num_entries = BNXT_ULP_GLB_RESOURCE_TBL_MAX_SZ;
56 return ulp_glb_resource_tbl;
60 * Read the global resource from the mapper global resource list
62 * The regval is always returned in big-endian.
64 * returns 0 on success
67 ulp_mapper_glb_resource_read(struct bnxt_ulp_mapper_data *mapper_data,
73 if (!mapper_data || !regval || !shared ||
74 dir >= TF_DIR_MAX || idx >= BNXT_ULP_GLB_RF_IDX_LAST)
77 *regval = mapper_data->glb_res_tbl[dir][idx].resource_hndl;
78 *shared = mapper_data->glb_res_tbl[dir][idx].shared;
83 * Write a global resource to the mapper global resource list
85 * The regval value must be in big-endian.
87 * return 0 on success.
90 ulp_mapper_glb_resource_write(struct bnxt_ulp_mapper_data *data,
91 struct bnxt_ulp_glb_resource_info *res,
92 uint64_t regval, bool shared)
94 struct bnxt_ulp_mapper_glb_resource_entry *ent;
96 /* validate the arguments */
97 if (!data || res->direction >= TF_DIR_MAX ||
98 res->glb_regfile_index >= BNXT_ULP_GLB_RF_IDX_LAST)
101 /* write to the mapper data */
102 ent = &data->glb_res_tbl[res->direction][res->glb_regfile_index];
103 ent->resource_func = res->resource_func;
104 ent->resource_type = res->resource_type;
105 ent->resource_hndl = regval;
106 ent->shared = shared;
111 * Internal function to allocate identity resource and store it in mapper data.
113 * returns 0 on success
116 ulp_mapper_resource_ident_allocate(struct bnxt_ulp_context *ulp_ctx,
117 struct bnxt_ulp_mapper_data *mapper_data,
118 struct bnxt_ulp_glb_resource_info *glb_res)
120 struct tf_alloc_identifier_parms iparms = { 0 };
121 struct tf_free_identifier_parms fparms;
126 tfp = bnxt_ulp_cntxt_tfp_get(ulp_ctx, BNXT_ULP_SHARED_SESSION_NO);
130 iparms.ident_type = glb_res->resource_type;
131 iparms.dir = glb_res->direction;
133 /* Allocate the Identifier using tf api */
134 rc = tf_alloc_identifier(tfp, &iparms);
136 BNXT_TF_DBG(ERR, "Failed to alloc identifier [%s][%d]\n",
137 tf_dir_2_str(iparms.dir),
142 /* entries are stored as big-endian format */
143 regval = tfp_cpu_to_be_64((uint64_t)iparms.id);
145 * write to the mapper global resource
146 * Shared resources are never allocated through this method, so the
147 * shared flag is always false.
149 rc = ulp_mapper_glb_resource_write(mapper_data, glb_res, regval, false);
151 BNXT_TF_DBG(ERR, "Failed to write to global resource id\n");
152 /* Free the identifier when update failed */
153 fparms.dir = iparms.dir;
154 fparms.ident_type = iparms.ident_type;
155 fparms.id = iparms.id;
156 tf_free_identifier(tfp, &fparms);
163 * Internal function to allocate index tbl resource and store it in mapper data.
165 * returns 0 on success
168 ulp_mapper_resource_index_tbl_alloc(struct bnxt_ulp_context *ulp_ctx,
169 struct bnxt_ulp_mapper_data *mapper_data,
170 struct bnxt_ulp_glb_resource_info *glb_res)
172 struct tf_alloc_tbl_entry_parms aparms = { 0 };
173 struct tf_free_tbl_entry_parms free_parms = { 0 };
176 uint32_t tbl_scope_id;
179 tfp = bnxt_ulp_cntxt_tfp_get(ulp_ctx, BNXT_ULP_SHARED_SESSION_NO);
183 /* Get the scope id */
184 rc = bnxt_ulp_cntxt_tbl_scope_id_get(ulp_ctx, &tbl_scope_id);
186 BNXT_TF_DBG(ERR, "Failed to get table scope rc=%d\n", rc);
190 aparms.type = glb_res->resource_type;
191 aparms.dir = glb_res->direction;
192 aparms.tbl_scope_id = tbl_scope_id;
194 /* Allocate the index tbl using tf api */
195 rc = tf_alloc_tbl_entry(tfp, &aparms);
197 BNXT_TF_DBG(ERR, "Failed to alloc index table [%s][%d]\n",
198 tf_dir_2_str(aparms.dir), aparms.type);
202 /* entries are stored as big-endian format */
203 regval = tfp_cpu_to_be_64((uint64_t)aparms.idx);
205 * write to the mapper global resource
206 * Shared resources are never allocated through this method, so the
207 * shared flag is always false.
209 rc = ulp_mapper_glb_resource_write(mapper_data, glb_res, regval, false);
211 BNXT_TF_DBG(ERR, "Failed to write to global resource id\n");
212 /* Free the identifier when update failed */
213 free_parms.dir = aparms.dir;
214 free_parms.type = aparms.type;
215 free_parms.idx = aparms.idx;
216 tf_free_tbl_entry(tfp, &free_parms);
223 ulp_mapper_glb_field_tbl_get(struct bnxt_ulp_mapper_parms *parms,
229 t_idx = parms->app_id << (BNXT_ULP_APP_ID_SHIFT +
230 BNXT_ULP_HDR_SIG_ID_SHIFT +
231 BNXT_ULP_GLB_FIELD_TBL_SHIFT);
232 t_idx += parms->class_tid << (BNXT_ULP_HDR_SIG_ID_SHIFT +
233 BNXT_ULP_GLB_FIELD_TBL_SHIFT);
234 t_idx += ULP_COMP_FLD_IDX_RD(parms, BNXT_ULP_CF_IDX_HDR_SIG_ID) <<
235 BNXT_ULP_GLB_FIELD_TBL_SHIFT;
238 if (t_idx >= BNXT_ULP_GLB_FIELD_TBL_SIZE) {
239 BNXT_TF_DBG(ERR, "Invalid hdr field index %x:%x:%x\n",
240 parms->class_tid, t_idx, operand);
242 return -EINVAL; /* error */
244 *val = ulp_glb_field_tbl[t_idx];
249 * Get the size of the action property for a given index.
251 * idx [in] The index for the action property
253 * returns the size of the action property.
256 ulp_mapper_act_prop_size_get(uint32_t idx)
258 if (idx >= BNXT_ULP_ACT_PROP_IDX_LAST)
260 return ulp_act_prop_map_table[idx];
263 static struct bnxt_ulp_mapper_cond_info *
264 ulp_mapper_tmpl_reject_list_get(struct bnxt_ulp_mapper_parms *mparms,
267 enum bnxt_ulp_cond_list_opc *opc)
270 const struct bnxt_ulp_template_device_tbls *dev_tbls;
272 dev_tbls = &mparms->device_params->dev_tbls[mparms->tmpl_type];
273 *num_tbls = dev_tbls->tmpl_list[tid].reject_info.cond_nums;
274 *opc = dev_tbls->tmpl_list[tid].reject_info.cond_list_opcode;
275 idx = dev_tbls->tmpl_list[tid].reject_info.cond_start_idx;
277 return &dev_tbls->cond_list[idx];
280 static struct bnxt_ulp_mapper_cond_info *
281 ulp_mapper_tbl_execute_list_get(struct bnxt_ulp_mapper_parms *mparms,
282 struct bnxt_ulp_mapper_tbl_info *tbl,
284 enum bnxt_ulp_cond_list_opc *opc)
287 const struct bnxt_ulp_template_device_tbls *dev_tbls;
289 dev_tbls = &mparms->device_params->dev_tbls[mparms->tmpl_type];
290 *num_tbls = tbl->execute_info.cond_nums;
291 *opc = tbl->execute_info.cond_list_opcode;
292 idx = tbl->execute_info.cond_start_idx;
294 return &dev_tbls->cond_list[idx];
298 * Get a list of classifier tables that implement the flow
299 * Gets a device dependent list of tables that implement the class template id
301 * mparms [in] The mappers parms with data related to the flow.
303 * tid [in] The template id that matches the flow
305 * num_tbls [out] The number of classifier tables in the returned array
307 * returns An array of classifier tables to implement the flow, or NULL on
310 static struct bnxt_ulp_mapper_tbl_info *
311 ulp_mapper_tbl_list_get(struct bnxt_ulp_mapper_parms *mparms,
316 const struct bnxt_ulp_template_device_tbls *dev_tbls;
318 dev_tbls = &mparms->device_params->dev_tbls[mparms->tmpl_type];
320 idx = dev_tbls->tmpl_list[tid].start_tbl_idx;
321 *num_tbls = dev_tbls->tmpl_list[tid].num_tbls;
323 return &dev_tbls->tbl_list[idx];
327 * Get the list of key fields that implement the flow.
329 * mparms [in] The mapper parms with information about the flow
331 * tbl [in] A single table instance to get the key fields from
333 * num_flds [out] The number of key fields in the returned array
335 * Returns array of Key fields, or NULL on error.
337 static struct bnxt_ulp_mapper_key_info *
338 ulp_mapper_key_fields_get(struct bnxt_ulp_mapper_parms *mparms,
339 struct bnxt_ulp_mapper_tbl_info *tbl,
343 const struct bnxt_ulp_template_device_tbls *dev_tbls;
345 dev_tbls = &mparms->device_params->dev_tbls[mparms->tmpl_type];
346 if (!dev_tbls->key_info_list) {
351 idx = tbl->key_start_idx;
352 *num_flds = tbl->key_num_fields;
354 return &dev_tbls->key_info_list[idx];
358 * Get the list of data fields that implement the flow.
360 * mparms [in] The mapper parms with information about the flow
362 * tbl [in] A single table instance to get the data fields from
364 * num_flds [out] The number of data fields in the returned array.
366 * num_encap_flds [out] The number of encap fields in the returned array.
368 * Returns array of data fields, or NULL on error.
370 static struct bnxt_ulp_mapper_field_info *
371 ulp_mapper_result_fields_get(struct bnxt_ulp_mapper_parms *mparms,
372 struct bnxt_ulp_mapper_tbl_info *tbl,
374 uint32_t *num_encap_flds)
377 const struct bnxt_ulp_template_device_tbls *dev_tbls;
379 dev_tbls = &mparms->device_params->dev_tbls[mparms->tmpl_type];
380 if (!dev_tbls->result_field_list) {
386 idx = tbl->result_start_idx;
387 *num_flds = tbl->result_num_fields;
388 *num_encap_flds = tbl->encap_num_fields;
390 return &dev_tbls->result_field_list[idx];
394 * Get the list of ident fields that implement the flow
396 * tbl [in] A single table instance to get the ident fields from
398 * num_flds [out] The number of ident fields in the returned array
400 * returns array of ident fields, or NULL on error
402 static struct bnxt_ulp_mapper_ident_info *
403 ulp_mapper_ident_fields_get(struct bnxt_ulp_mapper_parms *mparms,
404 struct bnxt_ulp_mapper_tbl_info *tbl,
408 const struct bnxt_ulp_template_device_tbls *dev_tbls;
410 dev_tbls = &mparms->device_params->dev_tbls[mparms->tmpl_type];
411 if (!dev_tbls->ident_list) {
416 idx = tbl->ident_start_idx;
417 *num_flds = tbl->ident_nums;
419 return &dev_tbls->ident_list[idx];
422 static enum tf_tbl_type
423 ulp_mapper_dyn_tbl_type_get(struct bnxt_ulp_mapper_parms *mparms,
424 struct bnxt_ulp_mapper_tbl_info *tbl,
425 struct ulp_blob *bdata,
428 struct bnxt_ulp_device_params *d_params = mparms->device_params;
429 uint16_t blob_len = ulp_blob_data_len_get(bdata);
430 struct bnxt_ulp_dyn_size_map *size_map;
433 if (d_params->dynamic_sram_en) {
434 switch (tbl->resource_type) {
435 case TF_TBL_TYPE_ACT_ENCAP_8B:
436 case TF_TBL_TYPE_ACT_ENCAP_16B:
437 case TF_TBL_TYPE_ACT_ENCAP_32B:
438 case TF_TBL_TYPE_ACT_ENCAP_64B:
439 size_map = d_params->dyn_encap_sizes;
440 for (i = 0; i < d_params->dyn_encap_list_size; i++) {
441 if (blob_len <= size_map[i].slab_size) {
442 *out_len = size_map[i].slab_size;
443 return size_map[i].tbl_type;
447 case TF_TBL_TYPE_ACT_MODIFY_8B:
448 case TF_TBL_TYPE_ACT_MODIFY_16B:
449 case TF_TBL_TYPE_ACT_MODIFY_32B:
450 case TF_TBL_TYPE_ACT_MODIFY_64B:
451 size_map = d_params->dyn_modify_sizes;
452 for (i = 0; i < d_params->dyn_modify_list_size; i++) {
453 if (blob_len <= size_map[i].slab_size) {
454 *out_len = size_map[i].slab_size;
455 return size_map[i].tbl_type;
463 return tbl->resource_type;
467 ulp_mapper_dyn_blob_size_get(struct bnxt_ulp_mapper_parms *mparms,
468 struct bnxt_ulp_mapper_tbl_info *tbl)
470 struct bnxt_ulp_device_params *d_params = mparms->device_params;
472 if (d_params->dynamic_sram_en) {
473 switch (tbl->resource_type) {
474 case TF_TBL_TYPE_ACT_ENCAP_8B:
475 case TF_TBL_TYPE_ACT_ENCAP_16B:
476 case TF_TBL_TYPE_ACT_ENCAP_32B:
477 case TF_TBL_TYPE_ACT_ENCAP_64B:
478 case TF_TBL_TYPE_ACT_MODIFY_8B:
479 case TF_TBL_TYPE_ACT_MODIFY_16B:
480 case TF_TBL_TYPE_ACT_MODIFY_32B:
481 case TF_TBL_TYPE_ACT_MODIFY_64B:
482 /* return max size */
483 return BNXT_ULP_FLMP_BLOB_SIZE_IN_BITS;
487 } else if (tbl->encap_num_fields) {
488 return BNXT_ULP_FLMP_BLOB_SIZE_IN_BITS;
490 return tbl->result_bit_size;
493 static inline int32_t
494 ulp_mapper_tcam_entry_free(struct bnxt_ulp_context *ulp,
496 struct ulp_flow_db_res_params *res)
498 struct tf_free_tcam_entry_parms fparms = {
499 .dir = res->direction,
500 .tcam_tbl_type = res->resource_type,
501 .idx = (uint16_t)res->resource_hndl
504 /* If HA is enabled, we may have to remap the TF Type */
505 if (bnxt_ulp_cntxt_ha_enabled(ulp)) {
506 enum ulp_ha_mgr_region region;
509 switch (res->resource_type) {
510 case TF_TCAM_TBL_TYPE_WC_TCAM_HIGH:
511 case TF_TCAM_TBL_TYPE_WC_TCAM_LOW:
512 rc = ulp_ha_mgr_region_get(ulp, ®ion);
514 /* Log this, but assume region is correct */
516 "Unable to get HA region (%d)\n",
519 fparms.tcam_tbl_type =
520 (region == ULP_HA_REGION_LOW) ?
521 TF_TCAM_TBL_TYPE_WC_TCAM_LOW :
522 TF_TCAM_TBL_TYPE_WC_TCAM_HIGH;
528 return tf_free_tcam_entry(tfp, &fparms);
531 static inline int32_t
532 ulp_mapper_index_entry_free(struct bnxt_ulp_context *ulp,
534 struct ulp_flow_db_res_params *res)
536 struct tf_free_tbl_entry_parms fparms = {
537 .dir = res->direction,
538 .type = res->resource_type,
539 .idx = (uint32_t)res->resource_hndl
543 * Just get the table scope, it will be ignored if not necessary
544 * by the tf_free_tbl_entry
546 (void)bnxt_ulp_cntxt_tbl_scope_id_get(ulp, &fparms.tbl_scope_id);
548 return tf_free_tbl_entry(tfp, &fparms);
551 static inline int32_t
552 ulp_mapper_em_entry_free(struct bnxt_ulp_context *ulp,
554 struct ulp_flow_db_res_params *res)
556 struct tf_delete_em_entry_parms fparms = { 0 };
559 fparms.dir = res->direction;
560 fparms.flow_handle = res->resource_hndl;
562 rc = bnxt_ulp_cntxt_tbl_scope_id_get(ulp, &fparms.tbl_scope_id);
564 BNXT_TF_DBG(ERR, "Failed to get table scope\n");
568 return tf_delete_em_entry(tfp, &fparms);
571 static inline int32_t
572 ulp_mapper_ident_free(struct bnxt_ulp_context *ulp __rte_unused,
574 struct ulp_flow_db_res_params *res)
576 struct tf_free_identifier_parms fparms = {
577 .dir = res->direction,
578 .ident_type = res->resource_type,
579 .id = (uint16_t)res->resource_hndl
582 return tf_free_identifier(tfp, &fparms);
585 static inline int32_t
586 ulp_mapper_mark_free(struct bnxt_ulp_context *ulp,
587 struct ulp_flow_db_res_params *res)
589 return ulp_mark_db_mark_del(ulp,
594 static inline int32_t
595 ulp_mapper_parent_flow_free(struct bnxt_ulp_context *ulp,
597 struct ulp_flow_db_res_params *res)
601 pc_idx = (uint32_t)res->resource_hndl;
603 /* reset the child flow bitset*/
604 if (ulp_flow_db_pc_db_parent_flow_set(ulp, pc_idx, parent_fid, 0)) {
605 BNXT_TF_DBG(ERR, "error in reset parent flow bitset %x:%x\n",
612 static inline int32_t
613 ulp_mapper_child_flow_free(struct bnxt_ulp_context *ulp,
615 struct ulp_flow_db_res_params *res)
619 pc_idx = (uint32_t)res->resource_hndl;
621 /* reset the child flow bitset*/
622 if (ulp_flow_db_pc_db_child_flow_set(ulp, pc_idx, child_fid, 0)) {
623 BNXT_TF_DBG(ERR, "error in resetting child flow bitset %x:%x\n",
631 * Process the flow database opcode alloc action.
632 * returns 0 on success
635 ulp_mapper_fdb_opc_alloc_rid(struct bnxt_ulp_mapper_parms *parms,
636 struct bnxt_ulp_mapper_tbl_info *tbl)
642 /* allocate a new fid */
643 rc = ulp_flow_db_fid_alloc(parms->ulp_ctx,
644 BNXT_ULP_FDB_TYPE_RID,
648 "Unable to allocate flow table entry\n");
651 /* Store the allocated fid in regfile*/
653 rc = ulp_regfile_write(parms->regfile, tbl->fdb_operand,
654 tfp_cpu_to_be_64(val64));
656 BNXT_TF_DBG(ERR, "Write regfile[%d] failed\n",
658 ulp_flow_db_fid_free(parms->ulp_ctx,
659 BNXT_ULP_FDB_TYPE_RID, rid);
666 * Process the flow database opcode action.
667 * returns 0 on success.
670 ulp_mapper_fdb_opc_process(struct bnxt_ulp_mapper_parms *parms,
671 struct bnxt_ulp_mapper_tbl_info *tbl,
672 struct ulp_flow_db_res_params *fid_parms)
676 enum bnxt_ulp_fdb_type flow_type;
679 switch (tbl->fdb_opcode) {
680 case BNXT_ULP_FDB_OPC_PUSH_FID:
681 push_fid = parms->fid;
682 flow_type = parms->flow_type;
684 case BNXT_ULP_FDB_OPC_PUSH_RID_REGFILE:
685 /* get the fid from the regfile */
686 rc = ulp_regfile_read(parms->regfile, tbl->fdb_operand,
689 BNXT_TF_DBG(ERR, "regfile[%d] read oob\n",
693 /* Use the extracted fid to update the flow resource */
694 push_fid = (uint32_t)tfp_be_to_cpu_64(val64);
695 flow_type = BNXT_ULP_FDB_TYPE_RID;
698 return rc; /* Nothing to be done */
701 /* Add the resource to the flow database */
702 rc = ulp_flow_db_resource_add(parms->ulp_ctx, flow_type,
703 push_fid, fid_parms);
705 BNXT_TF_DBG(ERR, "Failed to add res to flow %x rc = %d\n",
711 * Process the flow database opcode action.
712 * returns 0 on success.
715 ulp_mapper_priority_opc_process(struct bnxt_ulp_mapper_parms *parms,
716 struct bnxt_ulp_mapper_tbl_info *tbl,
721 switch (tbl->pri_opcode) {
722 case BNXT_ULP_PRI_OPC_NOT_USED:
725 case BNXT_ULP_PRI_OPC_CONST:
726 *priority = tbl->pri_operand;
728 case BNXT_ULP_PRI_OPC_APP_PRI:
729 *priority = parms->app_priority;
732 BNXT_TF_DBG(ERR, "Priority opcode not supported %d\n",
741 * Process the identifier list in the given table.
742 * Extract the ident from the table entry and
743 * write it to the reg file.
744 * returns 0 on success.
747 ulp_mapper_tbl_ident_scan_ext(struct bnxt_ulp_mapper_parms *parms,
748 struct bnxt_ulp_mapper_tbl_info *tbl,
750 uint32_t byte_data_size,
751 enum bnxt_ulp_byte_order byte_order)
753 struct bnxt_ulp_mapper_ident_info *idents;
754 uint32_t i, num_idents = 0;
757 /* validate the null arguments */
759 BNXT_TF_DBG(ERR, "invalid argument\n");
763 /* Get the ident list and process each one */
764 idents = ulp_mapper_ident_fields_get(parms, tbl, &num_idents);
766 for (i = 0; i < num_idents; i++) {
767 /* check the size of the buffer for validation */
768 if ((idents[i].ident_bit_pos + idents[i].ident_bit_size) >
769 ULP_BYTE_2_BITS(byte_data_size) ||
770 idents[i].ident_bit_size > ULP_BYTE_2_BITS(sizeof(val64))) {
771 BNXT_TF_DBG(ERR, "invalid offset or length %x:%x:%x\n",
772 idents[i].ident_bit_pos,
773 idents[i].ident_bit_size,
778 if (byte_order == BNXT_ULP_BYTE_ORDER_LE)
779 ulp_bs_pull_lsb(byte_data, (uint8_t *)&val64,
781 idents[i].ident_bit_pos,
782 idents[i].ident_bit_size);
784 ulp_bs_pull_msb(byte_data, (uint8_t *)&val64,
785 idents[i].ident_bit_pos,
786 idents[i].ident_bit_size);
788 /* Write it to the regfile, val64 is already in big-endian*/
789 if (ulp_regfile_write(parms->regfile,
790 idents[i].regfile_idx, val64)) {
791 BNXT_TF_DBG(ERR, "Regfile[%d] write failed.\n",
792 idents[i].regfile_idx);
800 * Process the identifier instruction and either store it in the flow database
801 * or return it in the val (if not NULL) on success. If val is NULL, the
802 * identifier is to be stored in the flow database.
805 ulp_mapper_ident_process(struct bnxt_ulp_mapper_parms *parms,
806 struct bnxt_ulp_mapper_tbl_info *tbl,
807 struct bnxt_ulp_mapper_ident_info *ident,
810 struct ulp_flow_db_res_params fid_parms;
813 struct tf_alloc_identifier_parms iparms = { 0 };
814 struct tf_free_identifier_parms free_parms = { 0 };
818 tfp = bnxt_ulp_cntxt_tfp_get(parms->ulp_ctx, tbl->shared_session);
820 BNXT_TF_DBG(ERR, "Failed to get tf pointer\n");
824 idx = ident->regfile_idx;
826 iparms.ident_type = ident->ident_type;
827 iparms.dir = tbl->direction;
829 rc = tf_alloc_identifier(tfp, &iparms);
831 BNXT_TF_DBG(ERR, "Alloc ident %s:%s failed.\n",
832 tf_dir_2_str(iparms.dir),
833 tf_ident_2_str(iparms.ident_type));
836 BNXT_TF_INF("Alloc ident %s:%s.success.\n",
837 tf_dir_2_str(iparms.dir),
838 tf_ident_2_str(iparms.ident_type));
840 id = (uint64_t)tfp_cpu_to_be_64(iparms.id);
841 if (ulp_regfile_write(parms->regfile, idx, id)) {
842 BNXT_TF_DBG(ERR, "Regfile[%d] write failed.\n", idx);
844 /* Need to free the identifier, so goto error */
848 /* Link the resource to the flow in the flow db */
850 memset(&fid_parms, 0, sizeof(fid_parms));
851 fid_parms.direction = tbl->direction;
852 fid_parms.resource_func = ident->resource_func;
853 fid_parms.resource_type = ident->ident_type;
854 fid_parms.resource_hndl = iparms.id;
855 fid_parms.critical_resource = tbl->critical_resource;
856 ulp_flow_db_shared_session_set(&fid_parms, tbl->shared_session);
858 rc = ulp_mapper_fdb_opc_process(parms, tbl, &fid_parms);
860 BNXT_TF_DBG(ERR, "Failed to link res to flow rc = %d\n",
862 /* Need to free the identifier, so goto error */
871 /* Need to free the identifier */
872 free_parms.dir = tbl->direction;
873 free_parms.ident_type = ident->ident_type;
874 free_parms.id = iparms.id;
876 (void)tf_free_identifier(tfp, &free_parms);
878 BNXT_TF_DBG(ERR, "Ident process failed for %s:%s\n",
880 tf_dir_2_str(tbl->direction));
885 * Process the identifier instruction and extract it from result blob.
886 * Increment the identifier reference count and store it in the flow database.
889 ulp_mapper_ident_extract(struct bnxt_ulp_mapper_parms *parms,
890 struct bnxt_ulp_mapper_tbl_info *tbl,
891 struct bnxt_ulp_mapper_ident_info *ident,
892 struct ulp_blob *res_blob)
894 struct ulp_flow_db_res_params fid_parms;
897 struct tf_search_identifier_parms sparms = { 0 };
898 struct tf_free_identifier_parms free_parms = { 0 };
902 /* Get the tfp from ulp context */
903 tfp = bnxt_ulp_cntxt_tfp_get(parms->ulp_ctx, tbl->shared_session);
905 BNXT_TF_DBG(ERR, "Failed to get tf pointer\n");
909 /* Extract the index from the result blob */
910 rc = ulp_blob_pull(res_blob, (uint8_t *)&idx, sizeof(idx),
911 ident->ident_bit_pos, ident->ident_bit_size);
913 BNXT_TF_DBG(ERR, "Failed to extract identifier from blob\n");
917 /* populate the search params and search identifier shadow table */
918 sparms.ident_type = ident->ident_type;
919 sparms.dir = tbl->direction;
920 /* convert the idx into cpu format */
921 sparms.search_id = tfp_be_to_cpu_32(idx);
923 /* Search identifier also increase the reference count */
924 rc = tf_search_identifier(tfp, &sparms);
926 BNXT_TF_DBG(ERR, "Search ident %s:%s:%x failed.\n",
927 tf_dir_2_str(sparms.dir),
928 tf_ident_2_str(sparms.ident_type),
932 BNXT_TF_INF("Search ident %s:%s:%x.success.\n",
933 tf_dir_2_str(sparms.dir),
934 tf_tbl_type_2_str(sparms.ident_type),
937 /* Write it to the regfile */
938 id = (uint64_t)tfp_cpu_to_be_64(sparms.search_id);
939 if (ulp_regfile_write(parms->regfile, ident->regfile_idx, id)) {
940 BNXT_TF_DBG(ERR, "Regfile[%d] write failed.\n", idx);
942 /* Need to free the identifier, so goto error */
946 /* Link the resource to the flow in the flow db */
947 memset(&fid_parms, 0, sizeof(fid_parms));
948 fid_parms.direction = tbl->direction;
949 fid_parms.resource_func = ident->resource_func;
950 fid_parms.resource_type = ident->ident_type;
951 fid_parms.resource_hndl = sparms.search_id;
952 fid_parms.critical_resource = tbl->critical_resource;
953 ulp_flow_db_shared_session_set(&fid_parms, tbl->shared_session);
955 rc = ulp_mapper_fdb_opc_process(parms, tbl, &fid_parms);
957 BNXT_TF_DBG(ERR, "Failed to link res to flow rc = %d\n",
959 /* Need to free the identifier, so goto error */
966 /* Need to free the identifier */
967 free_parms.dir = tbl->direction;
968 free_parms.ident_type = ident->ident_type;
969 free_parms.id = sparms.search_id;
970 (void)tf_free_identifier(tfp, &free_parms);
971 BNXT_TF_DBG(ERR, "Ident extract failed for %s:%s:%x\n",
973 tf_dir_2_str(tbl->direction), sparms.search_id);
978 ulp_mapper_field_port_db_process(struct bnxt_ulp_mapper_parms *parms,
983 enum bnxt_ulp_port_table port_data = val16;
986 case BNXT_ULP_PORT_TABLE_DRV_FUNC_PARENT_MAC:
987 if (ulp_port_db_parent_mac_addr_get(parms->ulp_ctx, port_id,
989 BNXT_TF_DBG(ERR, "Invalid port id %u\n", port_id);
993 case BNXT_ULP_PORT_TABLE_DRV_FUNC_MAC:
994 if (ulp_port_db_drv_mac_addr_get(parms->ulp_ctx, port_id,
996 BNXT_TF_DBG(ERR, "Invalid port id %u\n", port_id);
1000 case BNXT_ULP_PORT_TABLE_DRV_FUNC_PARENT_VNIC:
1001 if (ulp_port_db_parent_vnic_get(parms->ulp_ctx, port_id,
1003 BNXT_TF_DBG(ERR, "Invalid port id %u\n", port_id);
1008 BNXT_TF_DBG(ERR, "Invalid port_data %d\n", port_data);
1015 ulp_mapper_field_src_process(struct bnxt_ulp_mapper_parms *parms,
1016 enum bnxt_ulp_field_src field_src,
1025 struct bnxt_ulp_mapper_data *m;
1027 uint32_t port_id, val_size, field_size;
1028 uint16_t idx, size_idx, offset;
1029 uint32_t bytelen = ULP_BITS_2_BYTE(bitlen);
1036 /* Perform the action */
1037 switch (field_src) {
1038 case BNXT_ULP_FIELD_SRC_ZERO:
1039 *val = mapper_fld_zeros;
1041 case BNXT_ULP_FIELD_SRC_CONST:
1044 case BNXT_ULP_FIELD_SRC_ONES:
1045 *val = mapper_fld_ones;
1048 case BNXT_ULP_FIELD_SRC_CF:
1049 if (!ulp_operand_read(field_opr,
1050 (uint8_t *)&idx, sizeof(uint16_t))) {
1051 BNXT_TF_DBG(ERR, "CF operand read failed\n");
1054 idx = tfp_be_to_cpu_16(idx);
1055 if (idx >= BNXT_ULP_CF_IDX_LAST || bytelen > sizeof(uint64_t)) {
1056 BNXT_TF_DBG(ERR, "comp field [%d] read oob %d\n", idx,
1060 buffer = (uint8_t *)&parms->comp_fld[idx];
1061 *val = &buffer[sizeof(uint64_t) - bytelen];
1062 *value = ULP_COMP_FLD_IDX_RD(parms, idx);
1064 case BNXT_ULP_FIELD_SRC_RF:
1065 if (!ulp_operand_read(field_opr,
1066 (uint8_t *)&idx, sizeof(uint16_t))) {
1067 BNXT_TF_DBG(ERR, "RF operand read failed\n");
1071 idx = tfp_be_to_cpu_16(idx);
1072 /* Uninitialized regfile entries return 0 */
1073 if (!ulp_regfile_read(parms->regfile, idx, &lregval) ||
1074 sizeof(uint64_t) < bytelen) {
1075 BNXT_TF_DBG(ERR, "regfile[%d] read oob %u\n", idx,
1079 buffer = (uint8_t *)&parms->regfile->entry[idx].data;
1080 *val = &buffer[sizeof(uint64_t) - bytelen];
1081 *value = tfp_be_to_cpu_64(lregval);
1083 case BNXT_ULP_FIELD_SRC_ACT_PROP:
1084 if (!ulp_operand_read(field_opr,
1085 (uint8_t *)&idx, sizeof(uint16_t))) {
1086 BNXT_TF_DBG(ERR, "Action operand read failed\n");
1089 idx = tfp_be_to_cpu_16(idx);
1090 if (idx >= BNXT_ULP_ACT_PROP_IDX_LAST) {
1091 BNXT_TF_DBG(ERR, "act_prop[%d] oob\n", idx);
1094 buffer = &parms->act_prop->act_details[idx];
1095 field_size = ulp_mapper_act_prop_size_get(idx);
1096 if (bytelen > field_size) {
1097 BNXT_TF_DBG(ERR, "act_prop[%d] field size small %u\n",
1101 *val = &buffer[field_size - bytelen];
1103 case BNXT_ULP_FIELD_SRC_ACT_PROP_SZ:
1104 if (!ulp_operand_read(field_opr,
1105 (uint8_t *)&idx, sizeof(uint16_t))) {
1106 BNXT_TF_DBG(ERR, "Action sz operand read failed\n");
1109 idx = tfp_be_to_cpu_16(idx);
1111 if (idx >= BNXT_ULP_ACT_PROP_IDX_LAST) {
1112 BNXT_TF_DBG(ERR, "act_prop_sz[%d] oob\n", idx);
1115 *val = &parms->act_prop->act_details[idx];
1117 /* get the size index next */
1118 if (!ulp_operand_read(&field_opr[sizeof(uint16_t)],
1119 (uint8_t *)&size_idx, sizeof(uint16_t))) {
1120 BNXT_TF_DBG(ERR, "Action sz operand read failed\n");
1123 size_idx = tfp_be_to_cpu_16(size_idx);
1124 if (size_idx >= BNXT_ULP_ACT_PROP_IDX_LAST) {
1125 BNXT_TF_DBG(ERR, "act_prop[%d] oob\n", size_idx);
1128 memcpy(&val_size, &parms->act_prop->act_details[size_idx],
1130 val_size = tfp_be_to_cpu_32(val_size);
1131 *val_len = ULP_BYTE_2_BITS(val_size);
1133 case BNXT_ULP_FIELD_SRC_GLB_RF:
1134 if (!ulp_operand_read(field_opr,
1135 (uint8_t *)&idx, sizeof(uint16_t))) {
1136 BNXT_TF_DBG(ERR, "Global regfile read failed\n");
1139 idx = tfp_be_to_cpu_16(idx);
1140 if (ulp_mapper_glb_resource_read(parms->mapper_data,
1141 dir, idx, &lregval, &shared) ||
1142 sizeof(uint64_t) < bytelen) {
1143 BNXT_TF_DBG(ERR, "Global regfile[%d] read failed %u\n",
1147 m = parms->mapper_data;
1148 buffer = (uint8_t *)&m->glb_res_tbl[dir][idx].resource_hndl;
1149 *val = &buffer[sizeof(uint64_t) - bytelen];
1150 *value = tfp_be_to_cpu_64(lregval);
1152 case BNXT_ULP_FIELD_SRC_HF:
1153 case BNXT_ULP_FIELD_SRC_SUB_HF:
1154 if (!ulp_operand_read(field_opr,
1155 (uint8_t *)&idx, sizeof(uint16_t))) {
1156 BNXT_TF_DBG(ERR, "Header field read failed\n");
1159 idx = tfp_be_to_cpu_16(idx);
1160 /* get the index from the global field list */
1161 if (ulp_mapper_glb_field_tbl_get(parms, idx, &bit)) {
1162 BNXT_TF_DBG(ERR, "invalid ulp_glb_field_tbl idx %d\n",
1167 buffer = parms->hdr_field[bit].spec;
1169 buffer = parms->hdr_field[bit].mask;
1171 field_size = parms->hdr_field[bit].size;
1172 if (bytelen > field_size) {
1173 BNXT_TF_DBG(ERR, "Hdr field[%d] size small %u\n",
1177 if (field_src == BNXT_ULP_FIELD_SRC_HF) {
1178 *val = &buffer[field_size - bytelen];
1180 /* get the offset next */
1181 if (!ulp_operand_read(&field_opr[sizeof(uint16_t)],
1183 sizeof(uint16_t))) {
1184 BNXT_TF_DBG(ERR, "Hdr fld size read failed\n");
1187 offset = tfp_be_to_cpu_16(offset);
1188 offset = ULP_BITS_2_BYTE_NR(offset);
1189 if ((offset + bytelen) > field_size) {
1190 BNXT_TF_DBG(ERR, "Hdr field[%d] oob\n", bit);
1193 *val = &buffer[offset];
1196 case BNXT_ULP_FIELD_SRC_HDR_BIT:
1197 if (!ulp_operand_read(field_opr,
1198 (uint8_t *)&lregval, sizeof(uint64_t))) {
1199 BNXT_TF_DBG(ERR, "Header bit read failed\n");
1202 lregval = tfp_be_to_cpu_64(lregval);
1203 if (ULP_BITMAP_ISSET(parms->hdr_bitmap->bits, lregval)) {
1204 *val = mapper_fld_one;
1207 *val = mapper_fld_zeros;
1210 case BNXT_ULP_FIELD_SRC_ACT_BIT:
1211 if (!ulp_operand_read(field_opr,
1212 (uint8_t *)&lregval, sizeof(uint64_t))) {
1213 BNXT_TF_DBG(ERR, "Action bit read failed\n");
1216 lregval = tfp_be_to_cpu_64(lregval);
1217 if (ULP_BITMAP_ISSET(parms->act_bitmap->bits, lregval)) {
1218 *val = mapper_fld_one;
1221 *val = mapper_fld_zeros;
1224 case BNXT_ULP_FIELD_SRC_FIELD_BIT:
1225 if (!ulp_operand_read(field_opr,
1226 (uint8_t *)&idx, sizeof(uint16_t))) {
1227 BNXT_TF_DBG(ERR, "Field bit read failed\n");
1230 idx = tfp_be_to_cpu_16(idx);
1231 /* get the index from the global field list */
1232 if (ulp_mapper_glb_field_tbl_get(parms, idx, &bit)) {
1233 BNXT_TF_DBG(ERR, "invalid ulp_glb_field_tbl idx %d\n",
1237 if (ULP_INDEX_BITMAP_GET(parms->fld_bitmap->bits, bit)) {
1238 *val = mapper_fld_one;
1241 *val = mapper_fld_zeros;
1244 case BNXT_ULP_FIELD_SRC_PORT_TABLE:
1245 /* The port id is present in the comp field list */
1246 port_id = ULP_COMP_FLD_IDX_RD(parms,
1247 BNXT_ULP_CF_IDX_DEV_PORT_ID);
1248 /* get the port table enum */
1249 if (!ulp_operand_read(field_opr,
1250 (uint8_t *)&idx, sizeof(uint16_t))) {
1251 BNXT_TF_DBG(ERR, "Port table enum read failed\n");
1254 idx = tfp_be_to_cpu_16(idx);
1255 if (ulp_mapper_field_port_db_process(parms, port_id, idx,
1257 BNXT_TF_DBG(ERR, "field port table failed\n");
1261 case BNXT_ULP_FIELD_SRC_ENC_HDR_BIT:
1262 if (!ulp_operand_read(field_opr,
1263 (uint8_t *)&lregval, sizeof(uint64_t))) {
1264 BNXT_TF_DBG(ERR, "Header bit read failed\n");
1267 lregval = tfp_be_to_cpu_64(lregval);
1268 if (ULP_BITMAP_ISSET(parms->enc_hdr_bitmap->bits, lregval)) {
1269 *val = mapper_fld_one;
1272 *val = mapper_fld_zeros;
1275 case BNXT_ULP_FIELD_SRC_ENC_FIELD:
1276 if (!ulp_operand_read(field_opr,
1277 (uint8_t *)&idx, sizeof(uint16_t))) {
1278 BNXT_TF_DBG(ERR, "Header field read failed\n");
1281 idx = tfp_be_to_cpu_16(idx);
1282 /* get the index from the global field list */
1283 if (idx >= BNXT_ULP_ENC_FIELD_LAST) {
1284 BNXT_TF_DBG(ERR, "invalid encap field tbl idx %d\n",
1288 buffer = parms->enc_field[idx].spec;
1289 field_size = parms->enc_field[idx].size;
1290 if (bytelen > field_size) {
1291 BNXT_TF_DBG(ERR, "Encap field[%d] size small %u\n",
1295 *val = &buffer[field_size - bytelen];
1297 case BNXT_ULP_FIELD_SRC_SKIP:
1299 *val = mapper_fld_zeros;
1302 case BNXT_ULP_FIELD_SRC_REJECT:
1305 BNXT_TF_DBG(ERR, "invalid field opcode 0x%x\n", field_src);
1311 static int32_t ulp_mapper_field_buffer_eval(uint8_t *buffer, uint32_t bitlen,
1319 bytelen = ULP_BITS_2_BYTE(bitlen);
1320 if (bytelen == sizeof(uint8_t)) {
1321 *output = *((uint8_t *)buffer);
1322 } else if (bytelen == sizeof(uint16_t)) {
1323 val_16 = *((uint16_t *)buffer);
1324 *output = tfp_be_to_cpu_16(val_16);
1325 } else if (bytelen == sizeof(uint32_t)) {
1326 val_32 = *((uint32_t *)buffer);
1327 *output = tfp_be_to_cpu_32(val_32);
1328 } else if (bytelen == sizeof(val_64)) {
1329 val_64 = *((uint64_t *)buffer);
1330 *output = tfp_be_to_cpu_64(val_64);
1338 static int32_t ulp_mapper_field_blob_write(enum bnxt_ulp_field_src fld_src,
1339 struct ulp_blob *blob,
1344 if (fld_src == BNXT_ULP_FIELD_SRC_ZERO) {
1345 if (ulp_blob_pad_push(blob, val_len) < 0) {
1346 BNXT_TF_DBG(ERR, "too large for blob\n");
1349 } else if (fld_src == BNXT_ULP_FIELD_SRC_ACT_PROP_SZ) {
1350 if (ulp_blob_push_encap(blob, val, val_len) < 0) {
1351 BNXT_TF_DBG(ERR, "encap blob push failed\n");
1354 } else if (fld_src == BNXT_ULP_FIELD_SRC_SKIP) {
1357 if (!ulp_blob_push(blob, val, val_len)) {
1358 BNXT_TF_DBG(ERR, "push of val1 failed\n");
1367 ulp_mapper_field_opc_process(struct bnxt_ulp_mapper_parms *parms,
1369 struct bnxt_ulp_mapper_field_info *fld,
1370 struct ulp_blob *blob,
1374 uint16_t write_idx = blob->write_idx;
1375 uint8_t *val = NULL, *val1, *val2, *val3;
1376 uint32_t val_len = 0, val1_len = 0, val2_len = 0, val3_len = 0;
1377 uint8_t process_src1 = 0, process_src2 = 0, process_src3 = 0;
1378 uint8_t eval_src1 = 0, eval_src2 = 0, eval_src3 = 0;
1379 uint64_t val_int = 0, val1_int = 0, val2_int = 0, val3_int = 0;
1380 uint64_t value1 = 0, value2 = 0, value3 = 0;
1383 /* prepare the field source and values */
1384 switch (fld->field_opc) {
1385 case BNXT_ULP_FIELD_OPC_SRC1:
1388 case BNXT_ULP_FIELD_OPC_SRC1_THEN_SRC2_ELSE_SRC3:
1391 case BNXT_ULP_FIELD_OPC_SRC1_OR_SRC2_OR_SRC3:
1392 case BNXT_ULP_FIELD_OPC_SRC1_AND_SRC2_OR_SRC3:
1400 case BNXT_ULP_FIELD_OPC_SRC1_PLUS_SRC2:
1401 case BNXT_ULP_FIELD_OPC_SRC1_MINUS_SRC2:
1402 case BNXT_ULP_FIELD_OPC_SRC1_PLUS_SRC2_POST:
1403 case BNXT_ULP_FIELD_OPC_SRC1_MINUS_SRC2_POST:
1404 case BNXT_ULP_FIELD_OPC_SRC1_OR_SRC2:
1405 case BNXT_ULP_FIELD_OPC_SRC1_AND_SRC2:
1415 /* process the src1 opcode */
1417 if (ulp_mapper_field_src_process(parms, fld->field_src1,
1418 fld->field_opr1, dir, is_key,
1419 fld->field_bit_size, &val1,
1420 &val1_len, &value1)) {
1421 BNXT_TF_DBG(ERR, "fld src1 process failed\n");
1425 if (ulp_mapper_field_buffer_eval(val1, val1_len,
1427 BNXT_TF_DBG(ERR, "fld src1 eval failed\n");
1433 /* for "if then clause" set the correct process */
1434 if (fld->field_opc == BNXT_ULP_FIELD_OPC_SRC1_THEN_SRC2_ELSE_SRC3) {
1441 /* process src2 opcode */
1443 if (ulp_mapper_field_src_process(parms, fld->field_src2,
1444 fld->field_opr2, dir, is_key,
1445 fld->field_bit_size, &val2,
1446 &val2_len, &value2)) {
1447 BNXT_TF_DBG(ERR, "fld src2 process failed\n");
1451 if (ulp_mapper_field_buffer_eval(val2, val2_len,
1453 BNXT_TF_DBG(ERR, "fld src2 eval failed\n");
1459 /* process src3 opcode */
1461 if (ulp_mapper_field_src_process(parms, fld->field_src3,
1462 fld->field_opr3, dir, is_key,
1463 fld->field_bit_size, &val3,
1464 &val3_len, &value3)) {
1465 BNXT_TF_DBG(ERR, "fld src3 process failed\n");
1469 if (ulp_mapper_field_buffer_eval(val3, val3_len,
1471 BNXT_TF_DBG(ERR, "fld src3 eval failed\n");
1477 val_len = fld->field_bit_size;
1478 /* process the field opcodes */
1479 switch (fld->field_opc) {
1480 case BNXT_ULP_FIELD_OPC_SRC1:
1481 rc = ulp_mapper_field_blob_write(fld->field_src1,
1482 blob, val1, val1_len, &val);
1485 case BNXT_ULP_FIELD_OPC_SRC1_THEN_SRC2_ELSE_SRC3:
1487 rc = ulp_mapper_field_blob_write(fld->field_src2, blob,
1488 val2, val2_len, &val);
1491 rc = ulp_mapper_field_blob_write(fld->field_src3, blob,
1492 val3, val3_len, &val);
1496 case BNXT_ULP_FIELD_OPC_SRC1_PLUS_SRC2:
1497 case BNXT_ULP_FIELD_OPC_SRC1_PLUS_SRC2_POST:
1498 val_int = val1_int + val2_int;
1499 val_int = tfp_cpu_to_be_64(val_int);
1500 val = ulp_blob_push_64(blob, &val_int, fld->field_bit_size);
1504 case BNXT_ULP_FIELD_OPC_SRC1_MINUS_SRC2:
1505 case BNXT_ULP_FIELD_OPC_SRC1_MINUS_SRC2_POST:
1506 val_int = val1_int - val2_int;
1507 val_int = tfp_cpu_to_be_64(val_int);
1508 val = ulp_blob_push_64(blob, &val_int, fld->field_bit_size);
1512 case BNXT_ULP_FIELD_OPC_SRC1_OR_SRC2:
1513 val_int = val1_int | val2_int;
1514 val_int = tfp_cpu_to_be_64(val_int);
1515 val = ulp_blob_push_64(blob, &val_int, fld->field_bit_size);
1519 case BNXT_ULP_FIELD_OPC_SRC1_OR_SRC2_OR_SRC3:
1520 val_int = val1_int | val2_int | val3_int;
1521 val_int = tfp_cpu_to_be_64(val_int);
1522 val = ulp_blob_push_64(blob, &val_int, fld->field_bit_size);
1526 case BNXT_ULP_FIELD_OPC_SRC1_AND_SRC2:
1527 val_int = val1_int & val2_int;
1528 val_int = tfp_cpu_to_be_64(val_int);
1529 val = ulp_blob_push_64(blob, &val_int, fld->field_bit_size);
1533 case BNXT_ULP_FIELD_OPC_SRC1_AND_SRC2_OR_SRC3:
1534 val_int = val1_int & (val2_int | val3_int);
1535 val_int = tfp_cpu_to_be_64(val_int);
1536 val = ulp_blob_push_64(blob, &val_int, fld->field_bit_size);
1540 case BNXT_ULP_FIELD_OPC_SKIP:
1543 BNXT_TF_DBG(ERR, "Invalid fld opcode %u\n", fld->field_opc);
1552 BNXT_TF_DBG(ERR, "Error in %s:%s process %u:%u\n", name,
1553 fld->description, (val) ? write_idx : 0, val_len);
1558 * Result table process and fill the result blob.
1559 * data [out] - the result blob data
1562 ulp_mapper_tbl_result_build(struct bnxt_ulp_mapper_parms *parms,
1563 struct bnxt_ulp_mapper_tbl_info *tbl,
1564 struct ulp_blob *data,
1567 struct bnxt_ulp_mapper_field_info *dflds;
1568 uint32_t i = 0, num_flds = 0, encap_flds = 0;
1569 struct ulp_blob encap_blob;
1572 /* Get the result field list */
1573 dflds = ulp_mapper_result_fields_get(parms, tbl, &num_flds,
1576 /* validate the result field list counts */
1577 if ((tbl->resource_func == BNXT_ULP_RESOURCE_FUNC_INDEX_TABLE &&
1578 (!num_flds && !encap_flds)) || !dflds ||
1579 (tbl->resource_func != BNXT_ULP_RESOURCE_FUNC_INDEX_TABLE &&
1580 (!num_flds || encap_flds))) {
1581 BNXT_TF_DBG(ERR, "Failed to get data fields %x:%x\n",
1582 num_flds, encap_flds);
1586 /* process the result fields */
1587 for (i = 0; i < num_flds; i++) {
1588 rc = ulp_mapper_field_opc_process(parms, tbl->direction,
1589 &dflds[i], data, 0, name);
1591 BNXT_TF_DBG(ERR, "result field processing failed\n");
1596 /* process encap fields if any */
1599 /* Initialize the encap blob */
1600 if (!tbl->record_size &&
1601 !parms->device_params->dynamic_sram_en) {
1602 BNXT_TF_DBG(ERR, "Encap tbl record size incorrect\n");
1605 if (!ulp_blob_init(&encap_blob,
1606 ULP_BYTE_2_BITS(tbl->record_size),
1607 parms->device_params->encap_byte_order)) {
1608 BNXT_TF_DBG(ERR, "blob inits failed.\n");
1611 for (; i < encap_flds; i++) {
1612 rc = ulp_mapper_field_opc_process(parms, tbl->direction,
1614 &encap_blob, 0, name);
1617 "encap field processing failed\n");
1621 /* add the dynamic pad push */
1622 if (parms->device_params->dynamic_sram_en) {
1623 uint16_t rec_s = ULP_BYTE_2_BITS(tbl->record_size);
1625 (void)ulp_mapper_dyn_tbl_type_get(parms, tbl,
1626 &encap_blob, &rec_s);
1627 pad = rec_s - ulp_blob_data_len_get(&encap_blob);
1629 pad = ULP_BYTE_2_BITS(tbl->record_size) -
1630 ulp_blob_data_len_get(&encap_blob);
1632 if (ulp_blob_pad_push(&encap_blob, pad) < 0) {
1633 BNXT_TF_DBG(ERR, "encap buffer padding failed\n");
1638 /* perform the 64 bit byte swap */
1639 ulp_blob_perform_64B_byte_swap(&encap_blob);
1640 /* Append encap blob to the result blob */
1641 rc = ulp_blob_buffer_copy(data, &encap_blob);
1643 BNXT_TF_DBG(ERR, "encap buffer copy failed\n");
1651 ulp_mapper_mark_gfid_process(struct bnxt_ulp_mapper_parms *parms,
1652 struct bnxt_ulp_mapper_tbl_info *tbl,
1655 struct ulp_flow_db_res_params fid_parms;
1656 uint32_t mark, gfid, mark_flag;
1657 enum bnxt_ulp_mark_db_opc mark_op = tbl->mark_db_opcode;
1660 if (mark_op == BNXT_ULP_MARK_DB_OPC_NOP ||
1661 !(mark_op == BNXT_ULP_MARK_DB_OPC_PUSH_IF_MARK_ACTION &&
1662 ULP_BITMAP_ISSET(parms->act_bitmap->bits,
1663 BNXT_ULP_ACT_BIT_MARK)))
1664 return rc; /* no need to perform gfid process */
1666 /* Get the mark id details from action property */
1667 memcpy(&mark, &parms->act_prop->act_details[BNXT_ULP_ACT_PROP_IDX_MARK],
1669 mark = tfp_be_to_cpu_32(mark);
1671 TF_GET_GFID_FROM_FLOW_ID(flow_id, gfid);
1672 mark_flag = BNXT_ULP_MARK_GLOBAL_HW_FID;
1674 rc = ulp_mark_db_mark_add(parms->ulp_ctx, mark_flag,
1677 BNXT_TF_DBG(ERR, "Failed to add mark to flow\n");
1680 fid_parms.direction = tbl->direction;
1681 fid_parms.resource_func = BNXT_ULP_RESOURCE_FUNC_HW_FID;
1682 fid_parms.critical_resource = tbl->critical_resource;
1683 fid_parms.resource_type = mark_flag;
1684 fid_parms.resource_hndl = gfid;
1685 ulp_flow_db_shared_session_set(&fid_parms, tbl->shared_session);
1687 rc = ulp_mapper_fdb_opc_process(parms, tbl, &fid_parms);
1689 BNXT_TF_DBG(ERR, "Fail to link res to flow rc = %d\n", rc);
1694 ulp_mapper_mark_act_ptr_process(struct bnxt_ulp_mapper_parms *parms,
1695 struct bnxt_ulp_mapper_tbl_info *tbl)
1697 struct ulp_flow_db_res_params fid_parms;
1698 uint32_t act_idx, mark, mark_flag;
1700 enum bnxt_ulp_mark_db_opc mark_op = tbl->mark_db_opcode;
1703 if (mark_op == BNXT_ULP_MARK_DB_OPC_NOP ||
1704 !(mark_op == BNXT_ULP_MARK_DB_OPC_PUSH_IF_MARK_ACTION &&
1705 ULP_BITMAP_ISSET(parms->act_bitmap->bits,
1706 BNXT_ULP_ACT_BIT_MARK)))
1707 return rc; /* no need to perform mark action process */
1709 /* Get the mark id details from action property */
1710 memcpy(&mark, &parms->act_prop->act_details[BNXT_ULP_ACT_PROP_IDX_MARK],
1712 mark = tfp_be_to_cpu_32(mark);
1714 if (!ulp_regfile_read(parms->regfile,
1715 BNXT_ULP_RF_IDX_MAIN_ACTION_PTR,
1717 BNXT_TF_DBG(ERR, "read action ptr main failed\n");
1720 act_idx = tfp_be_to_cpu_64(val64);
1721 mark_flag = BNXT_ULP_MARK_LOCAL_HW_FID;
1722 rc = ulp_mark_db_mark_add(parms->ulp_ctx, mark_flag,
1725 BNXT_TF_DBG(ERR, "Failed to add mark to flow\n");
1728 fid_parms.direction = tbl->direction;
1729 fid_parms.resource_func = BNXT_ULP_RESOURCE_FUNC_HW_FID;
1730 fid_parms.critical_resource = tbl->critical_resource;
1731 fid_parms.resource_type = mark_flag;
1732 fid_parms.resource_hndl = act_idx;
1733 ulp_flow_db_shared_session_set(&fid_parms, tbl->shared_session);
1735 rc = ulp_mapper_fdb_opc_process(parms, tbl, &fid_parms);
1737 BNXT_TF_DBG(ERR, "Fail to link res to flow rc = %d\n", rc);
1742 ulp_mapper_mark_vfr_idx_process(struct bnxt_ulp_mapper_parms *parms,
1743 struct bnxt_ulp_mapper_tbl_info *tbl)
1745 struct ulp_flow_db_res_params fid_parms;
1746 uint32_t act_idx, mark, mark_flag;
1748 enum bnxt_ulp_mark_db_opc mark_op = tbl->mark_db_opcode;
1751 if (mark_op == BNXT_ULP_MARK_DB_OPC_NOP ||
1752 mark_op == BNXT_ULP_MARK_DB_OPC_PUSH_IF_MARK_ACTION)
1753 return rc; /* no need to perform mark action process */
1755 /* Get the mark id details from the computed field of dev port id */
1756 mark = ULP_COMP_FLD_IDX_RD(parms, BNXT_ULP_CF_IDX_DEV_PORT_ID);
1758 /* Get the main action pointer */
1759 if (!ulp_regfile_read(parms->regfile,
1760 BNXT_ULP_RF_IDX_MAIN_ACTION_PTR,
1762 BNXT_TF_DBG(ERR, "read action ptr main failed\n");
1765 act_idx = tfp_be_to_cpu_64(val64);
1767 /* Set the mark flag to local fid and vfr flag */
1768 mark_flag = BNXT_ULP_MARK_LOCAL_HW_FID | BNXT_ULP_MARK_VFR_ID;
1770 rc = ulp_mark_db_mark_add(parms->ulp_ctx, mark_flag,
1773 BNXT_TF_DBG(ERR, "Failed to add mark to flow\n");
1776 fid_parms.direction = tbl->direction;
1777 fid_parms.resource_func = BNXT_ULP_RESOURCE_FUNC_HW_FID;
1778 fid_parms.critical_resource = tbl->critical_resource;
1779 fid_parms.resource_type = mark_flag;
1780 fid_parms.resource_hndl = act_idx;
1781 ulp_flow_db_shared_session_set(&fid_parms, tbl->shared_session);
1783 rc = ulp_mapper_fdb_opc_process(parms, tbl, &fid_parms);
1785 BNXT_TF_DBG(ERR, "Fail to link res to flow rc = %d\n", rc);
1789 /* Tcam table scan the identifier list and allocate each identifier */
1791 ulp_mapper_tcam_tbl_scan_ident_alloc(struct bnxt_ulp_mapper_parms *parms,
1792 struct bnxt_ulp_mapper_tbl_info *tbl)
1794 struct bnxt_ulp_mapper_ident_info *idents;
1795 uint32_t num_idents;
1798 idents = ulp_mapper_ident_fields_get(parms, tbl, &num_idents);
1799 for (i = 0; i < num_idents; i++) {
1800 if (ulp_mapper_ident_process(parms, tbl,
1808 * Tcam table scan the identifier list and extract the identifier from
1812 ulp_mapper_tcam_tbl_scan_ident_extract(struct bnxt_ulp_mapper_parms *parms,
1813 struct bnxt_ulp_mapper_tbl_info *tbl,
1814 struct ulp_blob *data)
1816 struct bnxt_ulp_mapper_ident_info *idents;
1817 uint32_t num_idents = 0, i;
1821 * Extract the listed identifiers from the result field,
1822 * no need to allocate them.
1824 idents = ulp_mapper_ident_fields_get(parms, tbl, &num_idents);
1825 for (i = 0; i < num_idents; i++) {
1826 rc = ulp_mapper_ident_extract(parms, tbl, &idents[i], data);
1828 BNXT_TF_DBG(ERR, "Error in identifier extraction\n");
1835 /* Internal function to write the tcam entry */
1837 ulp_mapper_tcam_tbl_entry_write(struct bnxt_ulp_mapper_parms *parms,
1838 struct bnxt_ulp_mapper_tbl_info *tbl,
1839 struct ulp_blob *key,
1840 struct ulp_blob *mask,
1841 struct ulp_blob *data,
1844 struct tf_set_tcam_entry_parms sparms = { 0 };
1849 tfp = bnxt_ulp_cntxt_tfp_get(parms->ulp_ctx, tbl->shared_session);
1851 BNXT_TF_DBG(ERR, "Failed to get truflow pointer\n");
1855 sparms.dir = tbl->direction;
1856 sparms.tcam_tbl_type = tbl->resource_type;
1858 sparms.key = ulp_blob_data_get(key, &tmplen);
1859 sparms.key_sz_in_bits = tmplen;
1860 sparms.mask = ulp_blob_data_get(mask, &tmplen);
1861 sparms.result = ulp_blob_data_get(data, &tmplen);
1862 sparms.result_sz_in_bits = tmplen;
1863 if (tf_set_tcam_entry(tfp, &sparms)) {
1864 BNXT_TF_DBG(ERR, "tcam[%s][%s][%x] write failed.\n",
1865 tf_tcam_tbl_2_str(sparms.tcam_tbl_type),
1866 tf_dir_2_str(sparms.dir), sparms.idx);
1869 BNXT_TF_INF("tcam[%s][%s][%x] write success.\n",
1870 tf_tcam_tbl_2_str(sparms.tcam_tbl_type),
1871 tf_dir_2_str(sparms.dir), sparms.idx);
1874 rc = ulp_mapper_mark_act_ptr_process(parms, tbl);
1876 BNXT_TF_DBG(ERR, "failed mark action processing\n");
1884 * internal function to post process key/mask blobs for dynamic pad WC tcam tbl
1886 * parms [in] The mappers parms with data related to the flow.
1888 * key [in] The original key to be transformed
1890 * mask [in] The original mask to be transformed
1892 * tkey [in/out] The transformed key
1894 * tmask [in/out] The transformed mask
1896 * returns zero on success, non-zero on failure
1899 ulp_mapper_wc_tcam_tbl_dyn_post_process(struct bnxt_ulp_device_params *dparms,
1900 struct ulp_blob *key,
1901 struct ulp_blob *mask,
1902 struct ulp_blob *tkey,
1903 struct ulp_blob *tmask)
1905 uint16_t tlen, blen, clen, slice_width, num_slices, max_slices, offset;
1906 uint32_t cword, i, rc;
1910 slice_width = dparms->wc_slice_width;
1911 clen = dparms->wc_ctl_size_bits;
1912 max_slices = dparms->wc_max_slices;
1913 blen = ulp_blob_data_len_get(key);
1915 /* Get the length of the key based on number of slices and width */
1918 while (tlen < blen &&
1919 num_slices <= max_slices) {
1920 num_slices = num_slices << 1;
1924 if (num_slices > max_slices) {
1925 BNXT_TF_DBG(ERR, "Key size (%d) too large for WC\n", blen);
1929 /* The key/mask may not be on a natural slice boundary, pad it */
1931 if (ulp_blob_pad_push(key, pad) < 0 ||
1932 ulp_blob_pad_push(mask, pad) < 0) {
1933 BNXT_TF_DBG(ERR, "Unable to pad key/mask\n");
1937 /* The new length accounts for the ctrl word length and num slices */
1938 tlen = tlen + clen * num_slices;
1939 if (!ulp_blob_init(tkey, tlen, key->byte_order) ||
1940 !ulp_blob_init(tmask, tlen, mask->byte_order)) {
1941 BNXT_TF_DBG(ERR, "Unable to post process wc tcam entry\n");
1945 /* Build the transformed key/mask */
1946 cword = dparms->wc_mode_list[num_slices - 1];
1947 cword = tfp_cpu_to_be_32(cword);
1949 for (i = 0; i < num_slices; i++) {
1950 val = ulp_blob_push_32(tkey, &cword, clen);
1952 BNXT_TF_DBG(ERR, "Key ctrl word push failed\n");
1955 val = ulp_blob_push_32(tmask, &cword, clen);
1957 BNXT_TF_DBG(ERR, "Mask ctrl word push failed\n");
1960 rc = ulp_blob_append(tkey, key, offset, slice_width);
1962 BNXT_TF_DBG(ERR, "Key blob append failed\n");
1965 rc = ulp_blob_append(tmask, mask, offset, slice_width);
1967 BNXT_TF_DBG(ERR, "Mask blob append failed\n");
1970 offset += slice_width;
1973 /* The key/mask are byte reversed on every 4 byte chunk */
1974 ulp_blob_perform_byte_reverse(tkey, 4);
1975 ulp_blob_perform_byte_reverse(tmask, 4);
1980 /* internal function to post process the key/mask blobs for wildcard tcam tbl */
1981 static void ulp_mapper_wc_tcam_tbl_post_process(struct ulp_blob *blob)
1983 ulp_blob_perform_64B_word_swap(blob);
1984 ulp_blob_perform_64B_byte_swap(blob);
1987 static int32_t ulp_mapper_tcam_is_wc_tcam(struct bnxt_ulp_mapper_tbl_info *tbl)
1989 if (tbl->resource_type == TF_TCAM_TBL_TYPE_WC_TCAM ||
1990 tbl->resource_type == TF_TCAM_TBL_TYPE_WC_TCAM_HIGH ||
1991 tbl->resource_type == TF_TCAM_TBL_TYPE_WC_TCAM_LOW)
1997 ulp_mapper_tcam_tbl_process(struct bnxt_ulp_mapper_parms *parms,
1998 struct bnxt_ulp_mapper_tbl_info *tbl)
2000 struct bnxt_ulp_mapper_key_info *kflds;
2001 struct ulp_blob okey, omask, data, update_data;
2002 struct ulp_blob tkey, tmask; /* transform key and mask */
2003 struct ulp_blob *key, *mask;
2004 uint32_t i, num_kflds;
2007 struct bnxt_ulp_device_params *dparms = parms->device_params;
2008 struct tf_alloc_tcam_entry_parms aparms = { 0 };
2009 struct tf_search_tcam_entry_parms searchparms = { 0 };
2010 struct ulp_flow_db_res_params fid_parms = { 0 };
2011 struct tf_free_tcam_entry_parms free_parms = { 0 };
2013 uint16_t tmplen = 0;
2015 enum bnxt_ulp_byte_order key_byte_order;
2017 /* Set the key and mask to the original key and mask. */
2021 /* Skip this if table opcode is NOP */
2022 if (tbl->tbl_opcode == BNXT_ULP_TCAM_TBL_OPC_NOT_USED ||
2023 tbl->tbl_opcode >= BNXT_ULP_TCAM_TBL_OPC_LAST) {
2024 BNXT_TF_DBG(ERR, "Invalid tcam table opcode %d\n",
2029 tfp = bnxt_ulp_cntxt_tfp_get(parms->ulp_ctx, tbl->shared_session);
2031 BNXT_TF_DBG(ERR, "Failed to get truflow pointer\n");
2035 /* If only allocation of identifier then perform and exit */
2036 if (tbl->tbl_opcode == BNXT_ULP_TCAM_TBL_OPC_ALLOC_IDENT) {
2037 rc = ulp_mapper_tcam_tbl_scan_ident_alloc(parms, tbl);
2041 kflds = ulp_mapper_key_fields_get(parms, tbl, &num_kflds);
2042 if (!kflds || !num_kflds) {
2043 BNXT_TF_DBG(ERR, "Failed to get key fields\n");
2047 if (ulp_mapper_tcam_is_wc_tcam(tbl))
2048 key_byte_order = dparms->wc_key_byte_order;
2050 key_byte_order = dparms->key_byte_order;
2052 if (!ulp_blob_init(key, tbl->blob_key_bit_size, key_byte_order) ||
2053 !ulp_blob_init(mask, tbl->blob_key_bit_size, key_byte_order) ||
2054 !ulp_blob_init(&data, tbl->result_bit_size,
2055 dparms->result_byte_order) ||
2056 !ulp_blob_init(&update_data, tbl->result_bit_size,
2057 dparms->result_byte_order)) {
2058 BNXT_TF_DBG(ERR, "blob inits failed.\n");
2062 /* create the key/mask */
2064 * NOTE: The WC table will require some kind of flag to handle the
2065 * mode bits within the key/mask
2067 for (i = 0; i < num_kflds; i++) {
2069 rc = ulp_mapper_field_opc_process(parms, tbl->direction,
2070 &kflds[i].field_info_spec,
2071 key, 1, "TCAM Key");
2073 BNXT_TF_DBG(ERR, "Key field set failed %s\n",
2074 kflds[i].field_info_spec.description);
2078 /* Setup the mask */
2079 rc = ulp_mapper_field_opc_process(parms, tbl->direction,
2080 &kflds[i].field_info_mask,
2081 mask, 0, "TCAM Mask");
2083 BNXT_TF_DBG(ERR, "Mask field set failed %s\n",
2084 kflds[i].field_info_mask.description);
2089 /* For wild card tcam perform the post process to swap the blob */
2090 if (ulp_mapper_tcam_is_wc_tcam(tbl)) {
2091 if (dparms->dynamic_pad_en) {
2092 /* Sets up the slices for writing to the WC TCAM */
2093 rc = ulp_mapper_wc_tcam_tbl_dyn_post_process(dparms,
2099 "Failed to post proc WC entry.\n");
2102 /* Now need to use the transform Key/Mask */
2106 ulp_mapper_wc_tcam_tbl_post_process(key);
2107 ulp_mapper_wc_tcam_tbl_post_process(mask);
2112 if (tbl->tbl_opcode == BNXT_ULP_TCAM_TBL_OPC_ALLOC_WR_REGFILE) {
2113 /* allocate the tcam index */
2114 aparms.dir = tbl->direction;
2115 aparms.tcam_tbl_type = tbl->resource_type;
2116 aparms.key = ulp_blob_data_get(key, &tmplen);
2117 aparms.key_sz_in_bits = tmplen;
2118 aparms.mask = ulp_blob_data_get(mask, &tmplen);
2120 /* calculate the entry priority */
2121 rc = ulp_mapper_priority_opc_process(parms, tbl,
2124 BNXT_TF_DBG(ERR, "entry priority process failed\n");
2128 rc = tf_alloc_tcam_entry(tfp, &aparms);
2130 BNXT_TF_DBG(ERR, "tcam alloc failed rc=%d.\n", rc);
2137 * Searching before allocation to see if we already have an
2138 * entry. This allows re-use of a constrained resource.
2140 searchparms.dir = tbl->direction;
2141 searchparms.tcam_tbl_type = tbl->resource_type;
2142 searchparms.key = ulp_blob_data_get(key, &tmplen);
2143 searchparms.key_sz_in_bits = tbl->key_bit_size;
2144 searchparms.mask = ulp_blob_data_get(mask, &tmplen);
2145 searchparms.alloc = 1;
2146 searchparms.result = ulp_blob_data_get(&data, &tmplen);
2147 searchparms.result_sz_in_bits = tbl->result_bit_size;
2149 /* calculate the entry priority */
2150 rc = ulp_mapper_priority_opc_process(parms, tbl,
2151 &searchparms.priority);
2153 BNXT_TF_DBG(ERR, "entry priority process failed\n");
2157 rc = tf_search_tcam_entry(tfp, &searchparms);
2159 BNXT_TF_DBG(ERR, "tcam search failed rc=%d\n", rc);
2163 /* Successful search, check the result */
2164 if (searchparms.search_status == REJECT) {
2165 BNXT_TF_DBG(ERR, "tcam alloc rejected\n");
2168 idx = searchparms.idx;
2169 hit = searchparms.hit;
2172 /* Write the tcam index into the regfile*/
2173 if (ulp_regfile_write(parms->regfile, tbl->tbl_operand,
2174 (uint64_t)tfp_cpu_to_be_64(idx))) {
2175 BNXT_TF_DBG(ERR, "Regfile[%d] write failed.\n",
2178 /* Need to free the tcam idx, so goto error */
2182 /* if it is miss then it is same as no search before alloc */
2183 if (!hit || tbl->tbl_opcode == BNXT_ULP_TCAM_TBL_OPC_ALLOC_WR_REGFILE) {
2184 /*Scan identifier list, allocate identifier and update regfile*/
2185 rc = ulp_mapper_tcam_tbl_scan_ident_alloc(parms, tbl);
2186 /* Create the result blob */
2188 rc = ulp_mapper_tbl_result_build(parms, tbl, &data,
2190 /* write the tcam entry */
2192 rc = ulp_mapper_tcam_tbl_entry_write(parms, tbl, key,
2195 /*Scan identifier list, extract identifier and update regfile*/
2196 rc = ulp_mapper_tcam_tbl_scan_ident_extract(parms, tbl, &data);
2201 /* Add the tcam index to the flow database */
2202 fid_parms.direction = tbl->direction;
2203 fid_parms.resource_func = tbl->resource_func;
2204 fid_parms.resource_type = tbl->resource_type;
2205 fid_parms.critical_resource = tbl->critical_resource;
2206 fid_parms.resource_hndl = idx;
2207 ulp_flow_db_shared_session_set(&fid_parms, tbl->shared_session);
2209 rc = ulp_mapper_fdb_opc_process(parms, tbl, &fid_parms);
2211 BNXT_TF_DBG(ERR, "Failed to link resource to flow rc = %d\n",
2213 /* Need to free the identifier, so goto error */
2219 free_parms.dir = tbl->direction;
2220 free_parms.tcam_tbl_type = tbl->resource_type;
2221 free_parms.idx = idx;
2222 trc = tf_free_tcam_entry(tfp, &free_parms);
2224 BNXT_TF_DBG(ERR, "Failed to free tcam[%d][%d][%d] on failure\n",
2225 tbl->resource_type, tbl->direction, idx);
2230 ulp_mapper_em_tbl_process(struct bnxt_ulp_mapper_parms *parms,
2231 struct bnxt_ulp_mapper_tbl_info *tbl)
2233 struct bnxt_ulp_mapper_key_info *kflds;
2234 struct ulp_blob key, data;
2235 uint32_t i, num_kflds;
2238 struct ulp_flow_db_res_params fid_parms = { 0 };
2239 struct tf_insert_em_entry_parms iparms = { 0 };
2240 struct tf_delete_em_entry_parms free_parms = { 0 };
2241 enum bnxt_ulp_flow_mem_type mtype;
2242 struct bnxt_ulp_device_params *dparms = parms->device_params;
2246 enum bnxt_ulp_byte_order key_order, res_order;
2248 tfp = bnxt_ulp_cntxt_tfp_get(parms->ulp_ctx, tbl->shared_session);
2249 rc = bnxt_ulp_cntxt_mem_type_get(parms->ulp_ctx, &mtype);
2251 BNXT_TF_DBG(ERR, "Failed to get the mem type for EM\n");
2255 kflds = ulp_mapper_key_fields_get(parms, tbl, &num_kflds);
2256 if (!kflds || !num_kflds) {
2257 BNXT_TF_DBG(ERR, "Failed to get key fields\n");
2261 key_order = dparms->em_byte_order;
2262 res_order = dparms->em_byte_order;
2264 /* Initialize the key/result blobs */
2265 if (!ulp_blob_init(&key, tbl->blob_key_bit_size, key_order) ||
2266 !ulp_blob_init(&data, tbl->result_bit_size, res_order)) {
2267 BNXT_TF_DBG(ERR, "blob inits failed.\n");
2271 /* create the key */
2272 for (i = 0; i < num_kflds; i++) {
2274 rc = ulp_mapper_field_opc_process(parms, tbl->direction,
2275 &kflds[i].field_info_spec,
2278 BNXT_TF_DBG(ERR, "Key field set failed.\n");
2283 /* if dynamic padding is enabled then add padding to result data */
2284 if (dparms->dynamic_pad_en) {
2285 /* add padding to make sure key is at byte boundary */
2286 ulp_blob_pad_align(&key, ULP_BUFFER_ALIGN_8_BITS);
2289 pad = dparms->em_blk_align_bits - dparms->em_blk_size_bits;
2291 BNXT_TF_DBG(ERR, "Invalid em blk size and align\n");
2294 ulp_blob_pad_push(&data, (uint32_t)pad);
2297 /* Create the result data blob */
2298 rc = ulp_mapper_tbl_result_build(parms, tbl, &data, "EM Result");
2300 BNXT_TF_DBG(ERR, "Failed to build the result blob\n");
2303 if (dparms->dynamic_pad_en) {
2304 uint32_t abits = dparms->em_blk_align_bits;
2306 /* when dynamic padding is enabled merge result + key */
2307 rc = ulp_blob_block_merge(&data, &key, abits, pad);
2309 BNXT_TF_DBG(ERR, "Failed to merge the result blob\n");
2313 /* add padding to make sure merged result is at slice boundary*/
2314 ulp_blob_pad_align(&data, abits);
2316 ulp_blob_perform_byte_reverse(&data, ULP_BITS_2_BYTE(abits));
2319 /* do the transpose for the internal EM keys */
2320 if (tbl->resource_type == TF_MEM_INTERNAL) {
2321 if (dparms->em_key_align_bytes) {
2322 int32_t b = ULP_BYTE_2_BITS(dparms->em_key_align_bytes);
2324 tmplen = ulp_blob_data_len_get(&key);
2325 ulp_blob_pad_push(&key, b - tmplen);
2327 tmplen = ulp_blob_data_len_get(&key);
2328 ulp_blob_perform_byte_reverse(&key, ULP_BITS_2_BYTE(tmplen));
2331 rc = bnxt_ulp_cntxt_tbl_scope_id_get(parms->ulp_ctx,
2332 &iparms.tbl_scope_id);
2334 BNXT_TF_DBG(ERR, "Failed to get table scope rc=%d\n", rc);
2339 * NOTE: the actual blob size will differ from the size in the tbl
2340 * entry due to the padding.
2342 iparms.dup_check = 0;
2343 iparms.dir = tbl->direction;
2344 iparms.mem = tbl->resource_type;
2345 iparms.key = ulp_blob_data_get(&key, &tmplen);
2346 iparms.key_sz_in_bits = tbl->key_bit_size;
2347 iparms.em_record = ulp_blob_data_get(&data, &tmplen);
2348 if (tbl->result_bit_size)
2349 iparms.em_record_sz_in_bits = tbl->result_bit_size;
2351 iparms.em_record_sz_in_bits = tmplen;
2353 rc = tf_insert_em_entry(tfp, &iparms);
2355 BNXT_TF_DBG(ERR, "Failed to insert em entry rc=%d.\n", rc);
2359 /* Mark action process */
2360 if (mtype == BNXT_ULP_FLOW_MEM_TYPE_EXT &&
2361 tbl->resource_type == TF_MEM_EXTERNAL)
2362 rc = ulp_mapper_mark_gfid_process(parms, tbl, iparms.flow_id);
2363 else if (mtype == BNXT_ULP_FLOW_MEM_TYPE_INT &&
2364 tbl->resource_type == TF_MEM_INTERNAL)
2365 rc = ulp_mapper_mark_act_ptr_process(parms, tbl);
2367 BNXT_TF_DBG(ERR, "Failed to add mark to flow\n");
2371 /* Link the EM resource to the flow in the flow db */
2372 memset(&fid_parms, 0, sizeof(fid_parms));
2373 fid_parms.direction = tbl->direction;
2374 fid_parms.resource_func = tbl->resource_func;
2375 fid_parms.resource_type = tbl->resource_type;
2376 fid_parms.critical_resource = tbl->critical_resource;
2377 fid_parms.resource_hndl = iparms.flow_handle;
2379 rc = ulp_mapper_fdb_opc_process(parms, tbl, &fid_parms);
2381 BNXT_TF_DBG(ERR, "Fail to link res to flow rc = %d\n",
2383 /* Need to free the identifier, so goto error */
2389 free_parms.dir = iparms.dir;
2390 free_parms.mem = iparms.mem;
2391 free_parms.tbl_scope_id = iparms.tbl_scope_id;
2392 free_parms.flow_handle = iparms.flow_handle;
2394 trc = tf_delete_em_entry(tfp, &free_parms);
2396 BNXT_TF_DBG(ERR, "Failed to delete EM entry on failed add\n");
2402 ulp_mapper_index_tbl_process(struct bnxt_ulp_mapper_parms *parms,
2403 struct bnxt_ulp_mapper_tbl_info *tbl)
2405 struct ulp_flow_db_res_params fid_parms;
2406 struct ulp_blob data;
2407 uint64_t regval = 0;
2410 int32_t rc = 0, trc = 0;
2411 struct tf_alloc_tbl_entry_parms aparms = { 0 };
2412 struct tf_set_tbl_entry_parms sparms = { 0 };
2413 struct tf_get_tbl_entry_parms gparms = { 0 };
2414 struct tf_free_tbl_entry_parms free_parms = { 0 };
2415 uint32_t tbl_scope_id;
2417 struct bnxt_ulp_glb_resource_info glb_res = { 0 };
2421 bool global = false;
2422 uint64_t act_rec_size;
2423 bool shared = false;
2424 enum tf_tbl_type tbl_type = tbl->resource_type;
2426 tfp = bnxt_ulp_cntxt_tfp_get(parms->ulp_ctx, tbl->shared_session);
2427 /* compute the blob size */
2428 bit_size = ulp_mapper_dyn_blob_size_get(parms, tbl);
2430 /* Initialize the blob data */
2431 if (!ulp_blob_init(&data, bit_size,
2432 parms->device_params->result_byte_order)) {
2433 BNXT_TF_DBG(ERR, "Failed to initialize index table blob\n");
2437 /* Get the scope id first */
2438 rc = bnxt_ulp_cntxt_tbl_scope_id_get(parms->ulp_ctx, &tbl_scope_id);
2440 BNXT_TF_DBG(ERR, "Failed to get table scope rc=%d\n", rc);
2444 switch (tbl->tbl_opcode) {
2445 case BNXT_ULP_INDEX_TBL_OPC_ALLOC_REGFILE:
2448 case BNXT_ULP_INDEX_TBL_OPC_ALLOC_WR_REGFILE:
2450 * Build the entry, alloc an index, write the table, and store
2451 * the data in the regfile.
2456 case BNXT_ULP_INDEX_TBL_OPC_WR_REGFILE:
2458 * get the index to write to from the regfile and then write
2461 if (!ulp_regfile_read(parms->regfile,
2465 "Failed to get tbl idx from regfile[%d].\n",
2469 index = tfp_be_to_cpu_64(regval);
2470 /* For external, we need to reverse shift */
2471 if (tbl->resource_type == TF_TBL_TYPE_EXT)
2472 index = TF_ACT_REC_PTR_2_OFFSET(index);
2476 case BNXT_ULP_INDEX_TBL_OPC_ALLOC_WR_GLB_REGFILE:
2478 * Build the entry, alloc an index, write the table, and store
2479 * the data in the global regfile.
2484 glb_res.direction = tbl->direction;
2485 glb_res.resource_func = tbl->resource_func;
2486 glb_res.resource_type = tbl->resource_type;
2487 glb_res.glb_regfile_index = tbl->tbl_operand;
2489 case BNXT_ULP_INDEX_TBL_OPC_WR_GLB_REGFILE:
2490 if (tbl->fdb_opcode != BNXT_ULP_FDB_OPC_NOP) {
2491 BNXT_TF_DBG(ERR, "Template error, wrong fdb opcode\n");
2495 * get the index to write to from the global regfile and then
2498 if (ulp_mapper_glb_resource_read(parms->mapper_data,
2501 ®val, &shared)) {
2503 "Failed to get tbl idx from Glb RF[%d].\n",
2507 index = tfp_be_to_cpu_64(regval);
2508 /* For external, we need to reverse shift */
2509 if (tbl->resource_type == TF_TBL_TYPE_EXT)
2510 index = TF_ACT_REC_PTR_2_OFFSET(index);
2513 case BNXT_ULP_INDEX_TBL_OPC_RD_REGFILE:
2515 * The read is different from the rest and can be handled here
2516 * instead of trying to use common code. Simply read the table
2517 * with the index from the regfile, scan and store the
2518 * identifiers, and return.
2520 if (tbl->resource_type == TF_TBL_TYPE_EXT) {
2521 /* Not currently supporting with EXT */
2523 "Ext Table Read Opcode not supported.\n");
2526 if (!ulp_regfile_read(parms->regfile,
2527 tbl->tbl_operand, ®val)) {
2529 "Failed to get tbl idx from regfile[%d]\n",
2533 index = tfp_be_to_cpu_64(regval);
2534 gparms.dir = tbl->direction;
2535 gparms.type = tbl->resource_type;
2536 gparms.data = ulp_blob_data_get(&data, &tmplen);
2537 gparms.data_sz_in_bytes = ULP_BITS_2_BYTE(tmplen);
2539 rc = tf_get_tbl_entry(tfp, &gparms);
2541 BNXT_TF_DBG(ERR, "Failed to read the tbl entry %d:%d\n",
2542 tbl->resource_type, index);
2546 * Scan the fields in the entry and push them into the regfile.
2548 rc = ulp_mapper_tbl_ident_scan_ext(parms, tbl,
2550 gparms.data_sz_in_bytes,
2554 "Failed to get flds on tbl read rc=%d\n",
2560 BNXT_TF_DBG(ERR, "Invalid index table opcode %d\n",
2566 /* Get the result fields list */
2567 rc = ulp_mapper_tbl_result_build(parms,
2572 BNXT_TF_DBG(ERR, "Failed to build the result blob\n");
2578 aparms.dir = tbl->direction;
2579 tbl_type = ulp_mapper_dyn_tbl_type_get(parms, tbl,
2581 aparms.type = tbl_type;
2582 aparms.tbl_scope_id = tbl_scope_id;
2584 /* All failures after the alloc succeeds require a free */
2585 rc = tf_alloc_tbl_entry(tfp, &aparms);
2587 BNXT_TF_DBG(ERR, "Alloc table[%s][%s] failed rc=%d\n",
2588 tf_tbl_type_2_str(aparms.type),
2589 tf_dir_2_str(tbl->direction), rc);
2595 * Store the index in the regfile since we either allocated it
2598 * Calculate the idx for the result record, for external EM the
2599 * offset needs to be shifted accordingly.
2600 * If external non-inline table types are used then need to
2601 * revisit this logic.
2603 if (tbl->resource_type == TF_TBL_TYPE_EXT)
2604 regval = TF_ACT_REC_OFFSET_2_PTR(index);
2607 regval = tfp_cpu_to_be_64(regval);
2611 * Shared resources are never allocated through this
2612 * method, so the shared flag is always false.
2614 rc = ulp_mapper_glb_resource_write(parms->mapper_data,
2618 rc = ulp_regfile_write(parms->regfile,
2619 tbl->tbl_operand, regval);
2623 "Failed to write %s regfile[%d] rc=%d\n",
2624 (global) ? "global" : "reg",
2625 tbl->tbl_operand, rc);
2631 sparms.dir = tbl->direction;
2632 sparms.data = ulp_blob_data_get(&data, &tmplen);
2633 tbl_type = ulp_mapper_dyn_tbl_type_get(parms, tbl, &data,
2635 sparms.type = tbl_type;
2636 sparms.data_sz_in_bytes = ULP_BITS_2_BYTE(tmplen);
2638 sparms.tbl_scope_id = tbl_scope_id;
2640 tfp = bnxt_ulp_cntxt_shared_tfp_get(parms->ulp_ctx);
2641 rc = tf_set_tbl_entry(tfp, &sparms);
2644 "Index table[%s][%s][%x] write fail rc=%d\n",
2645 tf_tbl_type_2_str(sparms.type),
2646 tf_dir_2_str(sparms.dir),
2650 BNXT_TF_INF("Index table[%s][%s][%x] write successful.\n",
2651 tf_tbl_type_2_str(sparms.type),
2652 tf_dir_2_str(sparms.dir), sparms.idx);
2654 /* Calculate action record size */
2655 if (tbl->resource_type == TF_TBL_TYPE_EXT) {
2656 act_rec_size = (ULP_BITS_2_BYTE_NR(tmplen) + 15) / 16;
2658 if (ulp_regfile_write(parms->regfile,
2659 BNXT_ULP_RF_IDX_ACTION_REC_SIZE,
2660 tfp_cpu_to_be_64(act_rec_size)))
2662 "Failed write the act rec size\n");
2666 /* Link the resource to the flow in the flow db */
2667 memset(&fid_parms, 0, sizeof(fid_parms));
2668 fid_parms.direction = tbl->direction;
2669 fid_parms.resource_func = tbl->resource_func;
2670 fid_parms.resource_type = tbl_type;
2671 fid_parms.resource_sub_type = tbl->resource_sub_type;
2672 fid_parms.resource_hndl = index;
2673 fid_parms.critical_resource = tbl->critical_resource;
2674 ulp_flow_db_shared_session_set(&fid_parms, tbl->shared_session);
2676 rc = ulp_mapper_fdb_opc_process(parms, tbl, &fid_parms);
2678 BNXT_TF_DBG(ERR, "Failed to link resource to flow rc = %d\n",
2683 /* Perform the VF rep action */
2684 rc = ulp_mapper_mark_vfr_idx_process(parms, tbl);
2686 BNXT_TF_DBG(ERR, "Failed to add vfr mark rc = %d\n", rc);
2691 /* Shared resources are not freed */
2695 * Free the allocated resource since we failed to either
2696 * write to the entry or link the flow
2698 free_parms.dir = tbl->direction;
2699 free_parms.type = tbl_type;
2700 free_parms.idx = index;
2701 free_parms.tbl_scope_id = tbl_scope_id;
2703 trc = tf_free_tbl_entry(tfp, &free_parms);
2705 BNXT_TF_DBG(ERR, "Failed to free tbl entry on failure\n");
2711 ulp_mapper_if_tbl_process(struct bnxt_ulp_mapper_parms *parms,
2712 struct bnxt_ulp_mapper_tbl_info *tbl)
2714 struct ulp_blob data, res_blob;
2718 struct tf_set_if_tbl_entry_parms iftbl_params = { 0 };
2719 struct tf_get_if_tbl_entry_parms get_parms = { 0 };
2721 enum bnxt_ulp_if_tbl_opc if_opc = tbl->tbl_opcode;
2724 tfp = bnxt_ulp_cntxt_tfp_get(parms->ulp_ctx, tbl->shared_session);
2725 /* Initialize the blob data */
2726 if (!ulp_blob_init(&data, tbl->result_bit_size,
2727 parms->device_params->result_byte_order)) {
2728 BNXT_TF_DBG(ERR, "Failed initial index table blob\n");
2732 /* create the result blob */
2733 rc = ulp_mapper_tbl_result_build(parms, tbl, &data, "IFtable Result");
2735 BNXT_TF_DBG(ERR, "Failed to build the result blob\n");
2739 /* Get the index details */
2741 case BNXT_ULP_IF_TBL_OPC_WR_COMP_FIELD:
2742 idx = ULP_COMP_FLD_IDX_RD(parms, tbl->tbl_operand);
2744 case BNXT_ULP_IF_TBL_OPC_WR_REGFILE:
2745 if (!ulp_regfile_read(parms->regfile, tbl->tbl_operand, &idx)) {
2746 BNXT_TF_DBG(ERR, "regfile[%d] read oob\n",
2750 idx = tfp_be_to_cpu_64(idx);
2752 case BNXT_ULP_IF_TBL_OPC_WR_CONST:
2753 idx = tbl->tbl_operand;
2755 case BNXT_ULP_IF_TBL_OPC_RD_COMP_FIELD:
2756 /* Initialize the result blob */
2757 if (!ulp_blob_init(&res_blob, tbl->result_bit_size,
2758 parms->device_params->result_byte_order)) {
2759 BNXT_TF_DBG(ERR, "Failed initial result blob\n");
2763 /* read the interface table */
2764 idx = ULP_COMP_FLD_IDX_RD(parms, tbl->tbl_operand);
2765 res_size = ULP_BITS_2_BYTE(tbl->result_bit_size);
2766 get_parms.dir = tbl->direction;
2767 get_parms.type = tbl->resource_type;
2768 get_parms.idx = idx;
2769 get_parms.data = ulp_blob_data_get(&res_blob, &tmplen);
2770 get_parms.data_sz_in_bytes = res_size;
2772 rc = tf_get_if_tbl_entry(tfp, &get_parms);
2774 BNXT_TF_DBG(ERR, "Get table[%d][%s][%x] failed rc=%d\n",
2776 tf_dir_2_str(get_parms.dir),
2780 rc = ulp_mapper_tbl_ident_scan_ext(parms, tbl,
2783 res_blob.byte_order);
2785 BNXT_TF_DBG(ERR, "Scan and extract failed rc=%d\n", rc);
2787 case BNXT_ULP_IF_TBL_OPC_NOT_USED:
2788 return rc; /* skip it */
2790 BNXT_TF_DBG(ERR, "Invalid tbl index opcode\n");
2794 /* Perform the tf table set by filling the set params */
2795 iftbl_params.dir = tbl->direction;
2796 iftbl_params.type = tbl->resource_type;
2797 iftbl_params.data = ulp_blob_data_get(&data, &tmplen);
2798 iftbl_params.data_sz_in_bytes = ULP_BITS_2_BYTE(tmplen);
2799 iftbl_params.idx = idx;
2801 rc = tf_set_if_tbl_entry(tfp, &iftbl_params);
2803 BNXT_TF_DBG(ERR, "Set table[%d][%s][%x] failed rc=%d\n",
2804 iftbl_params.type,/* TBD: add tf_if_tbl_2_str */
2805 tf_dir_2_str(iftbl_params.dir),
2806 iftbl_params.idx, rc);
2809 BNXT_TF_INF("Set table[%s][%s][%x] success.\n",
2810 tf_if_tbl_2_str(iftbl_params.type),
2811 tf_dir_2_str(iftbl_params.dir),
2815 * TBD: Need to look at the need to store idx in flow db for restore
2816 * the table to its original state on deletion of this entry.
2822 ulp_mapper_gen_tbl_process(struct bnxt_ulp_mapper_parms *parms,
2823 struct bnxt_ulp_mapper_tbl_info *tbl)
2825 struct ulp_mapper_gen_tbl_list *gen_tbl_list;
2826 struct bnxt_ulp_mapper_key_info *kflds;
2827 struct ulp_flow_db_res_params fid_parms;
2828 struct ulp_mapper_gen_tbl_entry gen_tbl_ent, *g;
2829 struct ulp_gen_hash_entry_params hash_entry;
2830 uint16_t tmplen = 0;
2831 struct ulp_blob key, data;
2834 uint32_t i, num_kflds = 0, key_index = 0;
2835 uint32_t gen_tbl_miss = 1, fdb_write = 0;
2839 /* Get the key fields list and build the key. */
2840 kflds = ulp_mapper_key_fields_get(parms, tbl, &num_kflds);
2841 if (!kflds || !num_kflds) {
2842 BNXT_TF_DBG(ERR, "Failed to get key fields\n");
2846 if (!ulp_blob_init(&key, tbl->key_bit_size,
2847 parms->device_params->key_byte_order)) {
2848 BNXT_TF_DBG(ERR, "Failed to alloc blob\n");
2851 for (i = 0; i < num_kflds; i++) {
2853 rc = ulp_mapper_field_opc_process(parms, tbl->direction,
2854 &kflds[i].field_info_spec,
2855 &key, 1, "Gen Tbl Key");
2858 "Failed to create key for Gen tbl rc=%d\n",
2864 /* Calculate the table index for the generic table*/
2865 tbl_idx = ulp_mapper_gen_tbl_idx_calculate(tbl->resource_sub_type,
2868 BNXT_TF_DBG(ERR, "Invalid table index %x:%x\n",
2869 tbl->resource_sub_type, tbl->direction);
2873 /* The_key is a byte array convert it to a search index */
2874 cache_key = ulp_blob_data_get(&key, &tmplen);
2875 /* get the generic table */
2876 gen_tbl_list = &parms->mapper_data->gen_tbl_list[tbl_idx];
2878 /* Check if generic hash table */
2879 if (gen_tbl_list->hash_tbl) {
2880 if (tbl->gen_tbl_lkup_type !=
2881 BNXT_ULP_GENERIC_TBL_LKUP_TYPE_HASH) {
2882 BNXT_TF_DBG(ERR, "%s: Invalid template lkup type\n",
2883 gen_tbl_list->gen_tbl_name);
2886 hash_entry.key_data = cache_key;
2887 hash_entry.key_length = ULP_BITS_2_BYTE(tmplen);
2888 rc = ulp_gen_hash_tbl_list_key_search(gen_tbl_list->hash_tbl,
2891 BNXT_TF_DBG(ERR, "%s: hash tbl search failed\n",
2892 gen_tbl_list->gen_tbl_name);
2895 if (hash_entry.search_flag == ULP_GEN_HASH_SEARCH_FOUND) {
2896 key_index = hash_entry.key_idx;
2897 /* Get the generic table entry */
2898 if (ulp_mapper_gen_tbl_entry_get(gen_tbl_list,
2902 /* store the hash index in the fdb */
2903 key_index = hash_entry.hash_index;
2906 /* convert key to index directly */
2907 if (ULP_BITS_2_BYTE(tmplen) > (int32_t)sizeof(key_index)) {
2908 BNXT_TF_DBG(ERR, "%s: keysize is bigger then 4 bytes\n",
2909 gen_tbl_list->gen_tbl_name);
2912 memcpy(&key_index, cache_key, ULP_BITS_2_BYTE(tmplen));
2913 /* Get the generic table entry */
2914 if (ulp_mapper_gen_tbl_entry_get(gen_tbl_list, key_index,
2918 switch (tbl->tbl_opcode) {
2919 case BNXT_ULP_GENERIC_TBL_OPC_READ:
2920 if (gen_tbl_list->hash_tbl) {
2921 if (hash_entry.search_flag != ULP_GEN_HASH_SEARCH_FOUND)
2922 break; /* nothing to be done , no entry */
2925 /* check the reference count */
2926 if (ULP_GEN_TBL_REF_CNT(&gen_tbl_ent)) {
2928 /* Scan ident list and create the result blob*/
2929 rc = ulp_mapper_tbl_ident_scan_ext(parms, tbl,
2935 "Failed to scan ident list\n");
2938 if (tbl->fdb_opcode != BNXT_ULP_FDB_OPC_NOP) {
2939 /* increment the reference count */
2940 ULP_GEN_TBL_REF_CNT_INC(&gen_tbl_ent);
2948 case BNXT_ULP_GENERIC_TBL_OPC_WRITE:
2949 if (gen_tbl_list->hash_tbl) {
2950 rc = ulp_mapper_gen_tbl_hash_entry_add(gen_tbl_list,
2955 /* store the hash index in the fdb */
2956 key_index = hash_entry.hash_index;
2958 /* check the reference count */
2959 if (ULP_GEN_TBL_REF_CNT(&gen_tbl_ent)) {
2960 /* a hit then error */
2961 BNXT_TF_DBG(ERR, "generic entry already present\n");
2962 return -EINVAL; /* success */
2965 /* Initialize the blob data */
2966 if (!ulp_blob_init(&data, tbl->result_bit_size,
2967 gen_tbl_ent.byte_order)) {
2968 BNXT_TF_DBG(ERR, "Failed initial index table blob\n");
2972 /* Get the result fields list */
2973 rc = ulp_mapper_tbl_result_build(parms, tbl, &data,
2976 BNXT_TF_DBG(ERR, "Failed to build the result blob\n");
2979 byte_data = ulp_blob_data_get(&data, &tmplen);
2980 rc = ulp_mapper_gen_tbl_entry_data_set(&gen_tbl_ent,
2982 ULP_BITS_2_BYTE(tmplen));
2984 BNXT_TF_DBG(ERR, "Failed to write generic table\n");
2988 /* increment the reference count */
2989 ULP_GEN_TBL_REF_CNT_INC(&gen_tbl_ent);
2991 parms->shared_hndl = (uint64_t)tbl_idx << 32 | key_index;
2994 BNXT_TF_DBG(ERR, "Invalid table opcode %x\n", tbl->tbl_opcode);
2998 /* Set the generic entry hit */
2999 rc = ulp_regfile_write(parms->regfile,
3000 BNXT_ULP_RF_IDX_GENERIC_TBL_MISS,
3001 tfp_cpu_to_be_64(gen_tbl_miss));
3003 BNXT_TF_DBG(ERR, "Write regfile[%d] failed\n",
3004 BNXT_ULP_RF_IDX_GENERIC_TBL_MISS);
3008 /* add the entry to the flow database */
3010 memset(&fid_parms, 0, sizeof(fid_parms));
3011 fid_parms.direction = tbl->direction;
3012 fid_parms.resource_func = tbl->resource_func;
3013 fid_parms.resource_sub_type = tbl->resource_sub_type;
3014 fid_parms.resource_hndl = key_index;
3015 fid_parms.critical_resource = tbl->critical_resource;
3016 ulp_flow_db_shared_session_set(&fid_parms, tbl->shared_session);
3018 rc = ulp_mapper_fdb_opc_process(parms, tbl, &fid_parms);
3020 BNXT_TF_DBG(ERR, "Fail to add gen ent flowdb %d\n", rc);
3026 ulp_mapper_ctrl_tbl_process(struct bnxt_ulp_mapper_parms *parms,
3027 struct bnxt_ulp_mapper_tbl_info *tbl)
3031 /* process the fdb opcode for alloc push */
3032 if (tbl->fdb_opcode == BNXT_ULP_FDB_OPC_ALLOC_RID_REGFILE) {
3033 rc = ulp_mapper_fdb_opc_alloc_rid(parms, tbl);
3035 BNXT_TF_DBG(ERR, "Failed to do fdb alloc\n");
3043 ulp_mapper_glb_resource_info_init(struct bnxt_ulp_context *ulp_ctx,
3044 struct bnxt_ulp_mapper_data *mapper_data)
3046 struct bnxt_ulp_glb_resource_info *glb_res;
3047 uint32_t num_glb_res_ids, idx, dev_id;
3051 glb_res = ulp_mapper_glb_resource_info_list_get(&num_glb_res_ids);
3052 if (!glb_res || !num_glb_res_ids) {
3053 BNXT_TF_DBG(ERR, "Invalid Arguments\n");
3057 rc = bnxt_ulp_cntxt_dev_id_get(ulp_ctx, &dev_id);
3059 BNXT_TF_DBG(ERR, "Failed to get device id for glb init (%d)\n",
3064 rc = bnxt_ulp_cntxt_app_id_get(ulp_ctx, &app_id);
3066 BNXT_TF_DBG(ERR, "Failed to get app id for glb init (%d)\n",
3071 /* Iterate the global resources and process each one */
3072 for (idx = 0; idx < num_glb_res_ids; idx++) {
3073 if (dev_id != glb_res[idx].device_id ||
3074 glb_res[idx].app_id != app_id)
3076 switch (glb_res[idx].resource_func) {
3077 case BNXT_ULP_RESOURCE_FUNC_IDENTIFIER:
3078 rc = ulp_mapper_resource_ident_allocate(ulp_ctx,
3082 case BNXT_ULP_RESOURCE_FUNC_INDEX_TABLE:
3083 rc = ulp_mapper_resource_index_tbl_alloc(ulp_ctx,
3088 BNXT_TF_DBG(ERR, "Global resource %x not supported\n",
3089 glb_res[idx].resource_func);
3100 * Iterate over the shared resources assigned during tf_open_session and store
3101 * them in the global regfile with the shared flag.
3104 ulp_mapper_app_glb_resource_info_init(struct bnxt_ulp_context *ulp_ctx,
3105 struct bnxt_ulp_mapper_data *mapper_data)
3107 struct tf_get_shared_tbl_increment_parms iparms;
3108 struct bnxt_ulp_glb_resource_info *glb_res;
3109 struct tf_get_session_info_parms sparms;
3110 uint32_t num_entries, i, dev_id, res;
3111 struct tf_resource_info *res_info;
3119 memset(&sparms, 0, sizeof(sparms));
3120 glb_res = bnxt_ulp_app_glb_resource_info_list_get(&num_entries);
3121 if (!glb_res || !num_entries) {
3122 BNXT_TF_DBG(ERR, "Invalid Arguments\n");
3125 tfp = bnxt_ulp_cntxt_shared_tfp_get(ulp_ctx);
3127 BNXT_TF_DBG(ERR, "Failed to get tfp for app global init");
3131 * Retrieve the resources that were assigned during the shared session
3134 rc = tf_get_session_info(tfp, &sparms);
3136 BNXT_TF_DBG(ERR, "Failed to get session info (%d)\n", rc);
3140 rc = bnxt_ulp_cntxt_app_id_get(ulp_ctx, &app_id);
3142 BNXT_TF_DBG(ERR, "Failed to get the app id in glb init (%d).\n",
3147 rc = bnxt_ulp_cntxt_dev_id_get(ulp_ctx, &dev_id);
3149 BNXT_TF_DBG(ERR, "Failed to get dev id for app glb init (%d)\n",
3154 /* Store all the app global resources */
3155 for (i = 0; i < num_entries; i++) {
3156 if (dev_id != glb_res[i].device_id ||
3157 app_id != glb_res[i].app_id)
3159 dir = glb_res[i].direction;
3160 res = glb_res[i].resource_type;
3163 switch (glb_res[i].resource_func) {
3164 case BNXT_ULP_RESOURCE_FUNC_IDENTIFIER:
3165 res_info = &sparms.session_info.ident[dir].info[res];
3167 case BNXT_ULP_RESOURCE_FUNC_INDEX_TABLE:
3169 * Tables may have various strides for the allocations.
3172 memset(&iparms, 0, sizeof(iparms));
3175 rc = tf_get_shared_tbl_increment(tfp, &iparms);
3178 "Failed to get addend for %s[%s] rc=(%d)\n",
3179 tf_tbl_type_2_str(res),
3180 tf_dir_2_str(dir), rc);
3183 addend = iparms.increment_cnt;
3184 res_info = &sparms.session_info.tbl[dir].info[res];
3186 case BNXT_ULP_RESOURCE_FUNC_TCAM_TABLE:
3187 res_info = &sparms.session_info.tcam[dir].info[res];
3189 case BNXT_ULP_RESOURCE_FUNC_EM_TABLE:
3190 res_info = &sparms.session_info.em[dir].info[res];
3193 BNXT_TF_DBG(ERR, "Unknown resource func (0x%x)\n",
3194 glb_res[i].resource_func);
3197 regval = tfp_cpu_to_be_64((uint64_t)res_info->start);
3198 res_info->start += addend;
3200 * All resources written to the global regfile are shared for
3203 rc = ulp_mapper_glb_resource_write(mapper_data, &glb_res[i],
3213 * Common conditional opcode process routine that is used for both the template
3214 * rejection and table conditional execution.
3217 ulp_mapper_cond_opc_process(struct bnxt_ulp_mapper_parms *parms,
3218 enum bnxt_ulp_cond_opc opc,
3222 enum bnxt_ulp_flow_mem_type mtype = BNXT_ULP_FLOW_MEM_TYPE_INT;
3228 case BNXT_ULP_COND_OPC_CF_IS_SET:
3229 if (operand < BNXT_ULP_CF_IDX_LAST) {
3230 *res = ULP_COMP_FLD_IDX_RD(parms, operand);
3232 BNXT_TF_DBG(ERR, "comp field out of bounds %d\n",
3237 case BNXT_ULP_COND_OPC_CF_NOT_SET:
3238 if (operand < BNXT_ULP_CF_IDX_LAST) {
3239 *res = !ULP_COMP_FLD_IDX_RD(parms, operand);
3241 BNXT_TF_DBG(ERR, "comp field out of bounds %d\n",
3246 case BNXT_ULP_COND_OPC_ACT_BIT_IS_SET:
3247 if (operand < BNXT_ULP_ACT_BIT_LAST) {
3248 *res = ULP_BITMAP_ISSET(parms->act_bitmap->bits,
3251 BNXT_TF_DBG(ERR, "action bit out of bounds %d\n",
3256 case BNXT_ULP_COND_OPC_ACT_BIT_NOT_SET:
3257 if (operand < BNXT_ULP_ACT_BIT_LAST) {
3258 *res = !ULP_BITMAP_ISSET(parms->act_bitmap->bits,
3261 BNXT_TF_DBG(ERR, "action bit out of bounds %d\n",
3266 case BNXT_ULP_COND_OPC_HDR_BIT_IS_SET:
3267 if (operand < BNXT_ULP_HDR_BIT_LAST) {
3268 *res = ULP_BITMAP_ISSET(parms->hdr_bitmap->bits,
3271 BNXT_TF_DBG(ERR, "header bit out of bounds %d\n",
3276 case BNXT_ULP_COND_OPC_HDR_BIT_NOT_SET:
3277 if (operand < BNXT_ULP_HDR_BIT_LAST) {
3278 *res = !ULP_BITMAP_ISSET(parms->hdr_bitmap->bits,
3281 BNXT_TF_DBG(ERR, "header bit out of bounds %d\n",
3286 case BNXT_ULP_COND_OPC_FIELD_BIT_IS_SET:
3287 rc = ulp_mapper_glb_field_tbl_get(parms, operand, &bit);
3289 BNXT_TF_DBG(ERR, "invalid ulp_glb_field_tbl idx %d\n",
3293 *res = ULP_INDEX_BITMAP_GET(parms->fld_bitmap->bits, bit);
3295 case BNXT_ULP_COND_OPC_FIELD_BIT_NOT_SET:
3296 rc = ulp_mapper_glb_field_tbl_get(parms, operand, &bit);
3298 BNXT_TF_DBG(ERR, "invalid ulp_glb_field_tbl idx %d\n",
3302 *res = !ULP_INDEX_BITMAP_GET(parms->fld_bitmap->bits, bit);
3304 case BNXT_ULP_COND_OPC_RF_IS_SET:
3305 if (!ulp_regfile_read(parms->regfile, operand, ®val)) {
3306 BNXT_TF_DBG(ERR, "regfile[%d] read oob\n", operand);
3311 case BNXT_ULP_COND_OPC_RF_NOT_SET:
3312 if (!ulp_regfile_read(parms->regfile, operand, ®val)) {
3313 BNXT_TF_DBG(ERR, "regfile[%d] read oob\n", operand);
3318 case BNXT_ULP_COND_OPC_FLOW_PAT_MATCH:
3319 *res = parms->flow_pattern_id == operand;
3321 case BNXT_ULP_COND_OPC_ACT_PAT_MATCH:
3322 *res = parms->act_pattern_id == operand;
3324 case BNXT_ULP_COND_OPC_EXT_MEM_IS_SET:
3325 if (bnxt_ulp_cntxt_mem_type_get(parms->ulp_ctx, &mtype)) {
3326 BNXT_TF_DBG(ERR, "Failed to get the mem type\n");
3329 *res = (mtype == BNXT_ULP_FLOW_MEM_TYPE_INT) ? 0 : 1;
3331 case BNXT_ULP_COND_OPC_EXT_MEM_NOT_SET:
3332 if (bnxt_ulp_cntxt_mem_type_get(parms->ulp_ctx, &mtype)) {
3333 BNXT_TF_DBG(ERR, "Failed to get the mem type\n");
3336 *res = (mtype == BNXT_ULP_FLOW_MEM_TYPE_INT) ? 1 : 0;
3338 case BNXT_ULP_COND_OPC_ENC_HDR_BIT_IS_SET:
3339 if (operand < BNXT_ULP_HDR_BIT_LAST) {
3340 *res = ULP_BITMAP_ISSET(parms->enc_hdr_bitmap->bits,
3343 BNXT_TF_DBG(ERR, "header bit out of bounds %d\n",
3348 case BNXT_ULP_COND_OPC_ENC_HDR_BIT_NOT_SET:
3349 if (operand < BNXT_ULP_HDR_BIT_LAST) {
3350 *res = !ULP_BITMAP_ISSET(parms->enc_hdr_bitmap->bits,
3353 BNXT_TF_DBG(ERR, "header bit out of bounds %d\n",
3359 BNXT_TF_DBG(ERR, "Invalid conditional opcode %d\n", opc);
3367 ulp_mapper_func_opr_compute(struct bnxt_ulp_mapper_parms *parms,
3369 enum bnxt_ulp_func_src func_src,
3378 case BNXT_ULP_FUNC_SRC_COMP_FIELD:
3379 if (func_opr >= BNXT_ULP_CF_IDX_LAST) {
3380 BNXT_TF_DBG(ERR, "invalid index %u\n", func_opr);
3383 *result = ULP_COMP_FLD_IDX_RD(parms, func_opr);
3385 case BNXT_ULP_FUNC_SRC_REGFILE:
3386 if (!ulp_regfile_read(parms->regfile, func_opr, ®val)) {
3387 BNXT_TF_DBG(ERR, "regfile[%d] read oob\n", func_opr);
3390 *result = tfp_be_to_cpu_64(regval);
3392 case BNXT_ULP_FUNC_SRC_GLB_REGFILE:
3393 if (ulp_mapper_glb_resource_read(parms->mapper_data, dir,
3394 func_opr, ®val, &shared)) {
3395 BNXT_TF_DBG(ERR, "global regfile[%d] read failed.\n",
3399 *result = tfp_be_to_cpu_64(regval);
3401 case BNXT_ULP_FUNC_SRC_CONST:
3405 BNXT_TF_DBG(ERR, "invalid src code %u\n", func_src);
3412 ulp_mapper_func_info_process(struct bnxt_ulp_mapper_parms *parms,
3413 struct bnxt_ulp_mapper_tbl_info *tbl)
3415 struct bnxt_ulp_mapper_func_info *func_info = &tbl->func_info;
3416 uint64_t res = 0, res1 = 0, res2 = 0;
3418 uint32_t process_src1 = 0, process_src2 = 0;
3420 /* determine which functional operands to compute */
3421 switch (func_info->func_opc) {
3422 case BNXT_ULP_FUNC_OPC_NOP:
3424 case BNXT_ULP_FUNC_OPC_EQ:
3425 case BNXT_ULP_FUNC_OPC_NE:
3426 case BNXT_ULP_FUNC_OPC_GE:
3427 case BNXT_ULP_FUNC_OPC_GT:
3428 case BNXT_ULP_FUNC_OPC_LE:
3429 case BNXT_ULP_FUNC_OPC_LT:
3433 case BNXT_ULP_FUNC_OPC_COPY_SRC1_TO_RF:
3441 rc = ulp_mapper_func_opr_compute(parms, tbl->direction,
3442 func_info->func_src1,
3443 func_info->func_opr1, &res1);
3449 rc = ulp_mapper_func_opr_compute(parms, tbl->direction,
3450 func_info->func_src2,
3451 func_info->func_opr2, &res2);
3456 /* perform the functional opcode operations */
3457 switch (func_info->func_opc) {
3458 case BNXT_ULP_FUNC_OPC_EQ:
3462 case BNXT_ULP_FUNC_OPC_NE:
3466 case BNXT_ULP_FUNC_OPC_GE:
3470 case BNXT_ULP_FUNC_OPC_GT:
3474 case BNXT_ULP_FUNC_OPC_LE:
3478 case BNXT_ULP_FUNC_OPC_LT:
3482 case BNXT_ULP_FUNC_OPC_COPY_SRC1_TO_RF:
3485 case BNXT_ULP_FUNC_OPC_RSS_CONFIG:
3486 /* apply the rss config using pmd method */
3487 return bnxt_rss_config_action_apply(parms);
3488 case BNXT_ULP_FUNC_OPC_GET_PARENT_MAC_ADDR:
3489 rc = bnxt_pmd_get_parent_mac_addr(parms, (uint8_t *)&res);
3492 res = tfp_be_to_cpu_64(res);
3495 BNXT_TF_DBG(ERR, "invalid func code %u\n", func_info->func_opc);
3498 if (ulp_regfile_write(parms->regfile, func_info->func_dst_opr,
3499 tfp_cpu_to_be_64(res))) {
3500 BNXT_TF_DBG(ERR, "Failed write the func_opc %u\n",
3501 func_info->func_dst_opr);
3509 * Processes a list of conditions and returns both a status and result of the
3510 * list. The status must be checked prior to verifying the result.
3512 * returns 0 for success, negative on failure
3513 * returns res = 1 for true, res = 0 for false.
3516 ulp_mapper_cond_opc_list_process(struct bnxt_ulp_mapper_parms *parms,
3517 enum bnxt_ulp_cond_list_opc list_opc,
3518 struct bnxt_ulp_mapper_cond_info *list,
3523 int32_t rc = 0, trc = 0;
3526 case BNXT_ULP_COND_LIST_OPC_AND:
3527 /* AND Defaults to true. */
3530 case BNXT_ULP_COND_LIST_OPC_OR:
3531 /* OR Defaults to false. */
3534 case BNXT_ULP_COND_LIST_OPC_TRUE:
3537 case BNXT_ULP_COND_LIST_OPC_FALSE:
3541 BNXT_TF_DBG(ERR, "Invalid conditional list opcode %d\n",
3547 for (i = 0; i < num; i++) {
3548 rc = ulp_mapper_cond_opc_process(parms,
3549 list[i].cond_opcode,
3550 list[i].cond_operand,
3555 if (list_opc == BNXT_ULP_COND_LIST_OPC_AND) {
3556 /* early return if result is ever zero */
3562 /* early return if result is ever non-zero */
3574 * Processes conflict resolution and returns both a status and result.
3575 * The status must be checked prior to verifying the result.
3577 * returns 0 for success, negative on failure
3578 * returns res = 1 for true, res = 0 for false.
3581 ulp_mapper_conflict_resolution_process(struct bnxt_ulp_mapper_parms *parms,
3582 struct bnxt_ulp_mapper_tbl_info *tbl,
3590 switch (tbl->accept_opcode) {
3591 case BNXT_ULP_ACCEPT_OPC_ALWAYS:
3594 case BNXT_ULP_ACCEPT_OPC_FLOW_SIG_ID_MATCH:
3595 /* perform the signature validation*/
3596 if (tbl->resource_func ==
3597 BNXT_ULP_RESOURCE_FUNC_GENERIC_TABLE) {
3598 /* Perform the check that generic table is hit or not */
3599 if (!ulp_regfile_read(parms->regfile,
3600 BNXT_ULP_RF_IDX_GENERIC_TBL_MISS,
3602 BNXT_TF_DBG(ERR, "regfile[%d] read oob\n",
3603 BNXT_ULP_RF_IDX_GENERIC_TBL_MISS);
3607 /* not a hit so no need to check flow sign*/
3612 /* compare the new flow signature against stored one */
3613 if (!ulp_regfile_read(parms->regfile,
3614 BNXT_ULP_RF_IDX_FLOW_SIG_ID,
3616 BNXT_TF_DBG(ERR, "regfile[%d] read oob\n",
3617 BNXT_ULP_RF_IDX_FLOW_SIG_ID);
3620 comp_sig = ULP_COMP_FLD_IDX_RD(parms,
3621 BNXT_ULP_CF_IDX_FLOW_SIG_ID);
3622 regval = tfp_be_to_cpu_64(regval);
3623 if (comp_sig == regval)
3626 BNXT_TF_DBG(ERR, "failed signature match 0x%016"
3627 PRIX64 ":%x\n", comp_sig, (uint32_t)regval);
3630 BNXT_TF_DBG(ERR, "Invalid accept opcode %d\n",
3631 tbl->accept_opcode);
3638 ulp_mapper_tbls_process(struct bnxt_ulp_mapper_parms *parms, uint32_t tid)
3640 struct bnxt_ulp_mapper_cond_info *cond_tbls = NULL;
3641 enum bnxt_ulp_cond_list_opc cond_opc;
3642 struct bnxt_ulp_mapper_tbl_info *tbls;
3643 struct bnxt_ulp_mapper_tbl_info *tbl;
3644 uint32_t num_tbls, tbl_idx, num_cond_tbls;
3645 int32_t rc = -EINVAL, cond_rc = 0;
3646 int32_t cond_goto = 1;
3648 cond_tbls = ulp_mapper_tmpl_reject_list_get(parms, tid,
3652 * Process the reject list if exists, otherwise assume that the
3653 * template is allowed.
3655 if (cond_tbls && num_cond_tbls) {
3656 rc = ulp_mapper_cond_opc_list_process(parms,
3664 /* Reject the template if True */
3666 BNXT_TF_DBG(ERR, "%s Template %d rejected.\n",
3667 ulp_mapper_tmpl_name_str(parms->tmpl_type),
3673 tbls = ulp_mapper_tbl_list_get(parms, tid, &num_tbls);
3674 if (!tbls || !num_tbls) {
3675 BNXT_TF_DBG(ERR, "No %s tables for %d:%d\n",
3676 ulp_mapper_tmpl_name_str(parms->tmpl_type),
3677 parms->dev_id, tid);
3681 for (tbl_idx = 0; tbl_idx < num_tbls && cond_goto;) {
3682 tbl = &tbls[tbl_idx];
3683 cond_goto = tbl->execute_info.cond_true_goto;
3684 /* Process the conditional func code opcodes */
3685 if (ulp_mapper_func_info_process(parms, tbl)) {
3686 BNXT_TF_DBG(ERR, "Failed to process cond update\n");
3691 cond_tbls = ulp_mapper_tbl_execute_list_get(parms, tbl,
3694 rc = ulp_mapper_cond_opc_list_process(parms, cond_opc,
3695 cond_tbls, num_cond_tbls,
3698 BNXT_TF_DBG(ERR, "Failed to proc cond opc list (%d)\n",
3702 /* Skip the table if False */
3704 cond_goto = tbl->execute_info.cond_false_goto;
3705 goto next_iteration;
3708 switch (tbl->resource_func) {
3709 case BNXT_ULP_RESOURCE_FUNC_TCAM_TABLE:
3710 rc = ulp_mapper_tcam_tbl_process(parms, tbl);
3712 case BNXT_ULP_RESOURCE_FUNC_EM_TABLE:
3713 rc = ulp_mapper_em_tbl_process(parms, tbl);
3715 case BNXT_ULP_RESOURCE_FUNC_INDEX_TABLE:
3716 rc = ulp_mapper_index_tbl_process(parms, tbl);
3718 case BNXT_ULP_RESOURCE_FUNC_IF_TABLE:
3719 rc = ulp_mapper_if_tbl_process(parms, tbl);
3721 case BNXT_ULP_RESOURCE_FUNC_GENERIC_TABLE:
3722 rc = ulp_mapper_gen_tbl_process(parms, tbl);
3724 case BNXT_ULP_RESOURCE_FUNC_CTRL_TABLE:
3725 rc = ulp_mapper_ctrl_tbl_process(parms, tbl);
3727 case BNXT_ULP_RESOURCE_FUNC_INVALID:
3731 BNXT_TF_DBG(ERR, "Unexpected mapper resource %d\n",
3732 tbl->resource_func);
3738 BNXT_TF_DBG(ERR, "Resource type %d failed\n",
3739 tbl->resource_func);
3743 /* perform the post table process */
3744 rc = ulp_mapper_conflict_resolution_process(parms, tbl,
3746 if (rc || !cond_rc) {
3747 BNXT_TF_DBG(ERR, "Failed due to conflict resolution\n");
3752 if (cond_goto == BNXT_ULP_COND_GOTO_REJECT) {
3753 BNXT_TF_DBG(ERR, "reject the flow\n");
3756 } else if (cond_goto & BNXT_ULP_COND_GOTO_RF) {
3760 /* least significant 16 bits from reg_file index */
3761 rf_idx = (uint32_t)(cond_goto & 0xFFFF);
3762 if (!ulp_regfile_read(parms->regfile, rf_idx,
3764 BNXT_TF_DBG(ERR, "regfile[%d] read oob\n",
3769 cond_goto = (int32_t)regval;
3772 if (cond_goto < 0 && ((int32_t)tbl_idx + cond_goto) < 0) {
3773 BNXT_TF_DBG(ERR, "invalid conditional goto %d\n",
3777 tbl_idx += cond_goto;
3782 BNXT_TF_DBG(ERR, "%s tables failed creation for %d:%d\n",
3783 ulp_mapper_tmpl_name_str(parms->tmpl_type),
3784 parms->dev_id, tid);
3789 ulp_mapper_resource_free(struct bnxt_ulp_context *ulp,
3791 struct ulp_flow_db_res_params *res)
3797 BNXT_TF_DBG(ERR, "Unable to free resource\n ");
3800 if (res->fdb_flags & ULP_FDB_FLAG_SHARED_SESSION)
3801 tfp = bnxt_ulp_cntxt_tfp_get(ulp, BNXT_ULP_SHARED_SESSION_YES);
3803 tfp = bnxt_ulp_cntxt_tfp_get(ulp, BNXT_ULP_SHARED_SESSION_NO);
3805 BNXT_TF_DBG(ERR, "Unable to free resource failed to get tfp\n");
3809 switch (res->resource_func) {
3810 case BNXT_ULP_RESOURCE_FUNC_TCAM_TABLE:
3811 rc = ulp_mapper_tcam_entry_free(ulp, tfp, res);
3813 case BNXT_ULP_RESOURCE_FUNC_EM_TABLE:
3814 rc = ulp_mapper_em_entry_free(ulp, tfp, res);
3816 case BNXT_ULP_RESOURCE_FUNC_INDEX_TABLE:
3817 rc = ulp_mapper_index_entry_free(ulp, tfp, res);
3819 case BNXT_ULP_RESOURCE_FUNC_IDENTIFIER:
3820 rc = ulp_mapper_ident_free(ulp, tfp, res);
3822 case BNXT_ULP_RESOURCE_FUNC_HW_FID:
3823 rc = ulp_mapper_mark_free(ulp, res);
3825 case BNXT_ULP_RESOURCE_FUNC_PARENT_FLOW:
3826 rc = ulp_mapper_parent_flow_free(ulp, fid, res);
3828 case BNXT_ULP_RESOURCE_FUNC_CHILD_FLOW:
3829 rc = ulp_mapper_child_flow_free(ulp, fid, res);
3831 case BNXT_ULP_RESOURCE_FUNC_GENERIC_TABLE:
3832 rc = ulp_mapper_gen_tbl_res_free(ulp, res);
3842 ulp_mapper_resources_free(struct bnxt_ulp_context *ulp_ctx,
3843 enum bnxt_ulp_fdb_type flow_type,
3846 struct ulp_flow_db_res_params res_parms = { 0 };
3850 BNXT_TF_DBG(ERR, "Invalid parms, unable to free flow\n");
3855 * Set the critical resource on the first resource del, then iterate
3856 * while status is good
3858 res_parms.critical_resource = BNXT_ULP_CRITICAL_RESOURCE_YES;
3860 rc = ulp_flow_db_resource_del(ulp_ctx, flow_type, fid, &res_parms);
3864 * This is unexpected on the first call to resource del.
3865 * It likely means that the flow did not exist in the flow db.
3867 BNXT_TF_DBG(ERR, "Flow[%d][0x%08x] failed to free (rc=%d)\n",
3868 flow_type, fid, rc);
3873 trc = ulp_mapper_resource_free(ulp_ctx, fid, &res_parms);
3876 * On fail, we still need to attempt to free the
3877 * remaining resources. Don't return
3880 "Flow[%d][0x%x] Res[%d][0x%016" PRIX64
3881 "] failed rc=%d.\n",
3882 flow_type, fid, res_parms.resource_func,
3883 res_parms.resource_hndl, trc);
3885 /* All subsequent call require the non-critical_resource */
3886 res_parms.critical_resource = BNXT_ULP_CRITICAL_RESOURCE_NO;
3888 rc = ulp_flow_db_resource_del(ulp_ctx,
3894 /* Free the Flow ID since we've removed all resources */
3895 rc = ulp_flow_db_fid_free(ulp_ctx, flow_type, fid);
3901 ulp_mapper_glb_resource_info_deinit(struct bnxt_ulp_context *ulp_ctx,
3902 struct bnxt_ulp_mapper_data *mapper_data)
3904 struct bnxt_ulp_mapper_glb_resource_entry *ent;
3905 struct ulp_flow_db_res_params res;
3908 /* Iterate the global resources and process each one */
3909 for (dir = TF_DIR_RX; dir < TF_DIR_MAX; dir++) {
3910 for (idx = 0; idx < BNXT_ULP_GLB_RF_IDX_LAST; idx++) {
3911 ent = &mapper_data->glb_res_tbl[dir][idx];
3912 if (ent->resource_func ==
3913 BNXT_ULP_RESOURCE_FUNC_INVALID ||
3916 memset(&res, 0, sizeof(struct ulp_flow_db_res_params));
3917 res.resource_func = ent->resource_func;
3918 res.direction = dir;
3919 res.resource_type = ent->resource_type;
3920 /*convert it from BE to cpu */
3922 tfp_be_to_cpu_64(ent->resource_hndl);
3923 ulp_mapper_resource_free(ulp_ctx, 0, &res);
3929 ulp_mapper_flow_destroy(struct bnxt_ulp_context *ulp_ctx,
3930 enum bnxt_ulp_fdb_type flow_type,
3936 BNXT_TF_DBG(ERR, "Invalid parms, unable to free flow\n");
3940 rc = ulp_mapper_resources_free(ulp_ctx, flow_type, fid);
3944 /* Function to handle the mapping of the Flow to be compatible
3945 * with the underlying hardware.
3948 ulp_mapper_flow_create(struct bnxt_ulp_context *ulp_ctx,
3949 struct bnxt_ulp_mapper_create_parms *cparms)
3951 struct bnxt_ulp_mapper_parms parms;
3952 struct ulp_regfile regfile;
3953 int32_t rc = 0, trc;
3955 if (!ulp_ctx || !cparms)
3958 /* Initialize the parms structure */
3959 memset(&parms, 0, sizeof(parms));
3960 parms.act_prop = cparms->act_prop;
3961 parms.act_bitmap = cparms->act;
3962 parms.hdr_bitmap = cparms->hdr_bitmap;
3963 parms.enc_hdr_bitmap = cparms->enc_hdr_bitmap;
3964 parms.regfile = ®file;
3965 parms.hdr_field = cparms->hdr_field;
3966 parms.enc_field = cparms->enc_field;
3967 parms.fld_bitmap = cparms->fld_bitmap;
3968 parms.comp_fld = cparms->comp_fld;
3969 parms.ulp_ctx = ulp_ctx;
3970 parms.act_tid = cparms->act_tid;
3971 parms.class_tid = cparms->class_tid;
3972 parms.flow_type = cparms->flow_type;
3973 parms.parent_flow = cparms->parent_flow;
3974 parms.child_flow = cparms->child_flow;
3975 parms.fid = cparms->flow_id;
3976 parms.tun_idx = cparms->tun_idx;
3977 parms.app_priority = cparms->app_priority;
3978 parms.flow_pattern_id = cparms->flow_pattern_id;
3979 parms.act_pattern_id = cparms->act_pattern_id;
3980 parms.app_id = cparms->app_id;
3981 parms.port_id = cparms->port_id;
3983 /* Get the device id from the ulp context */
3984 if (bnxt_ulp_cntxt_dev_id_get(ulp_ctx, &parms.dev_id)) {
3985 BNXT_TF_DBG(ERR, "Invalid ulp context\n");
3989 /* Get the device params, it will be used in later processing */
3990 parms.device_params = bnxt_ulp_device_params_get(parms.dev_id);
3991 if (!parms.device_params) {
3992 BNXT_TF_DBG(ERR, "No device parms for device id %d\n",
3998 * Get the mapper data for dynamic mapper data such as default
4001 parms.mapper_data = (struct bnxt_ulp_mapper_data *)
4002 bnxt_ulp_cntxt_ptr2_mapper_data_get(ulp_ctx);
4003 if (!parms.mapper_data) {
4004 BNXT_TF_DBG(ERR, "Failed to get the ulp mapper data\n");
4008 /* initialize the registry file for further processing */
4009 if (!ulp_regfile_init(parms.regfile)) {
4010 BNXT_TF_DBG(ERR, "regfile initialization failed.\n");
4014 /* Process the action template list from the selected action table*/
4015 if (parms.act_tid) {
4016 parms.tmpl_type = BNXT_ULP_TEMPLATE_TYPE_ACTION;
4017 /* Process the action template tables */
4018 rc = ulp_mapper_tbls_process(&parms, parms.act_tid);
4021 cparms->shared_hndl = parms.shared_hndl;
4024 if (parms.class_tid) {
4025 parms.tmpl_type = BNXT_ULP_TEMPLATE_TYPE_CLASS;
4027 /* Process the class template tables.*/
4028 rc = ulp_mapper_tbls_process(&parms, parms.class_tid);
4033 /* setup the parent-child details */
4034 if (parms.parent_flow) {
4035 /* create a parent flow details */
4036 rc = ulp_flow_db_parent_flow_create(&parms);
4039 } else if (parms.child_flow) {
4040 /* create a child flow details */
4041 rc = ulp_flow_db_child_flow_create(&parms);
4049 /* Free all resources that were allocated during flow creation */
4050 trc = ulp_mapper_flow_destroy(ulp_ctx, parms.flow_type,
4053 BNXT_TF_DBG(ERR, "Failed to free all resources rc=%d\n", trc);
4059 ulp_mapper_init(struct bnxt_ulp_context *ulp_ctx)
4061 struct bnxt_ulp_mapper_data *data;
4068 tfp = bnxt_ulp_cntxt_tfp_get(ulp_ctx, BNXT_ULP_SHARED_SESSION_NO);
4072 data = rte_zmalloc("ulp_mapper_data",
4073 sizeof(struct bnxt_ulp_mapper_data), 0);
4075 BNXT_TF_DBG(ERR, "Failed to allocate the mapper data\n");
4079 if (bnxt_ulp_cntxt_ptr2_mapper_data_set(ulp_ctx, data)) {
4080 BNXT_TF_DBG(ERR, "Failed to set mapper data in context\n");
4081 /* Don't call deinit since the prof_func wasn't allocated. */
4086 /* Allocate the global resource ids */
4087 rc = ulp_mapper_glb_resource_info_init(ulp_ctx, data);
4089 BNXT_TF_DBG(ERR, "Failed to initialize global resource ids\n");
4094 * Only initialize the app global resources if a shared session was
4097 if (bnxt_ulp_cntxt_shared_session_enabled(ulp_ctx)) {
4098 rc = ulp_mapper_app_glb_resource_info_init(ulp_ctx, data);
4100 BNXT_TF_DBG(ERR, "Failed to init app glb resources\n");
4105 /* Allocate the generic table list */
4106 rc = ulp_mapper_generic_tbl_list_init(data);
4108 BNXT_TF_DBG(ERR, "Failed to initialize generic tbl list\n");
4114 /* Ignore the return code in favor of returning the original error. */
4115 ulp_mapper_deinit(ulp_ctx);
4120 ulp_mapper_deinit(struct bnxt_ulp_context *ulp_ctx)
4122 struct bnxt_ulp_mapper_data *data;
4127 "Failed to acquire ulp context, so data may not be released.\n");
4131 data = (struct bnxt_ulp_mapper_data *)
4132 bnxt_ulp_cntxt_ptr2_mapper_data_get(ulp_ctx);
4134 /* Go ahead and return since there is no allocated data. */
4135 BNXT_TF_DBG(ERR, "No data appears to have been allocated.\n");
4139 tfp = bnxt_ulp_cntxt_tfp_get(ulp_ctx, BNXT_ULP_SHARED_SESSION_NO);
4141 BNXT_TF_DBG(ERR, "Failed to acquire tfp.\n");
4142 /* Free the mapper data regardless of errors. */
4143 goto free_mapper_data;
4146 /* Free the global resource info table entries */
4147 ulp_mapper_glb_resource_info_deinit(ulp_ctx, data);
4150 /* Free the generic table */
4151 (void)ulp_mapper_generic_tbl_list_deinit(data);
4154 /* Reset the data pointer within the ulp_ctx. */
4155 bnxt_ulp_cntxt_ptr2_mapper_data_set(ulp_ctx, NULL);