X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=drivers%2Fnet%2Fbnxt%2Ftf_ulp%2Fulp_flow_db.c;h=1cb52e9bfa3fe710ea72f80a7f0c298959ea2711;hb=c8834a3663b7ff3269a1b4e6a2772999dd485760;hp=ab6013f0e3348507786a29ac955b481168f91f47;hpb=1993b267dbcb66555c4bb54db15fc2fc69ef902d;p=dpdk.git

diff --git a/drivers/net/bnxt/tf_ulp/ulp_flow_db.c b/drivers/net/bnxt/tf_ulp/ulp_flow_db.c
index ab6013f0e3..1cb52e9bfa 100644
--- a/drivers/net/bnxt/tf_ulp/ulp_flow_db.c
+++ b/drivers/net/bnxt/tf_ulp/ulp_flow_db.c
@@ -386,101 +386,6 @@ ulp_flow_db_parent_tbl_deinit(struct bnxt_ulp_flow_db *flow_db)
 	}
 }
 
-/* internal validation function for parent flow tbl */
-static struct bnxt_ulp_flow_db *
-ulp_flow_db_parent_arg_validation(struct bnxt_ulp_context *ulp_ctxt,
-				  uint32_t fid)
-{
-	struct bnxt_ulp_flow_db *flow_db;
-
-	flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctxt);
-	if (!flow_db) {
-		BNXT_TF_DBG(ERR, "Invalid Arguments\n");
-		return NULL;
-	}
-
-	/* check for max flows */
-	if (fid >= flow_db->flow_tbl.num_flows || !fid) {
-		BNXT_TF_DBG(ERR, "Invalid flow index\n");
-		return NULL;
-	}
-
-	/* No support for parent child db then just exit */
-	if (!flow_db->parent_child_db.entries_count) {
-		BNXT_TF_DBG(ERR, "parent child db not supported\n");
-		return NULL;
-	}
-
-	return flow_db;
-}
-
-/*
- * Set the tunnel index in the parent flow
- *
- * ulp_ctxt [in] Ptr to ulp_context
- * parent_idx [in] The parent index of the parent flow entry
- *
- * returns index on success and negative on failure.
- */
-static int32_t
-ulp_flow_db_parent_tun_idx_set(struct bnxt_ulp_context *ulp_ctxt,
-			       uint32_t parent_idx, uint8_t tun_idx)
-{
-	struct bnxt_ulp_flow_db *flow_db;
-	struct ulp_fdb_parent_child_db *p_pdb;
-
-	flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctxt);
-	if (!flow_db) {
-		BNXT_TF_DBG(ERR, "Invalid Arguments\n");
-		return -EINVAL;
-	}
-
-	/* check for parent idx validity */
-	p_pdb = &flow_db->parent_child_db;
-	if (parent_idx >= p_pdb->entries_count ||
-	    !p_pdb->parent_flow_tbl[parent_idx].parent_fid) {
-		BNXT_TF_DBG(ERR, "Invalid parent flow index %x\n", parent_idx);
-		return -EINVAL;
-	}
-
-	p_pdb->parent_flow_tbl[parent_idx].tun_idx = tun_idx;
-	return 0;
-}
-
-/*
- * Get the tunnel index from the parent flow
- *
- * ulp_ctxt [in] Ptr to ulp_context
- * parent_fid [in] The flow id of the parent flow entry
- *
- * returns 0 if counter accum is set else -1.
- */
-static int32_t
-ulp_flow_db_parent_tun_idx_get(struct bnxt_ulp_context *ulp_ctxt,
-			       uint32_t parent_fid, uint8_t *tun_idx)
-{
-	struct bnxt_ulp_flow_db *flow_db;
-	struct ulp_fdb_parent_child_db *p_pdb;
-	uint32_t idx;
-
-	/* validate the arguments */
-	flow_db = ulp_flow_db_parent_arg_validation(ulp_ctxt, parent_fid);
-	if (!flow_db) {
-		BNXT_TF_DBG(ERR, "parent child db validation failed\n");
-		return -EINVAL;
-	}
-
-	p_pdb = &flow_db->parent_child_db;
-	for (idx = 0; idx < p_pdb->entries_count; idx++) {
-		if (p_pdb->parent_flow_tbl[idx].parent_fid == parent_fid) {
-			*tun_idx = p_pdb->parent_flow_tbl[idx].tun_idx;
-			return 0;
-		}
-	}
-
-	return -EINVAL;
-}
-
 /*
  * Initialize the flow database. Memory is allocated in this
  * call and assigned to the flow database.
@@ -654,6 +559,9 @@ ulp_flow_db_fid_alloc(struct bnxt_ulp_context *ulp_ctxt,
 	if (flow_type == BNXT_ULP_FDB_TYPE_REGULAR)
 		ulp_flow_db_func_id_set(flow_db, *fid, func_id);
 
+#ifdef RTE_LIBRTE_BNXT_TRUFLOW_DEBUG
+	BNXT_TF_DBG(ERR, "flow_id = %u:%u allocated\n", flow_type, *fid);
+#endif
 	/* return success */
 	return 0;
 }
@@ -780,9 +688,6 @@ ulp_flow_db_resource_del(struct bnxt_ulp_context *ulp_ctxt,
 	struct bnxt_ulp_flow_tbl *flow_tbl;
 	struct ulp_fdb_resource_info *nxt_resource, *fid_resource;
 	uint32_t nxt_idx = 0;
-	struct bnxt_tun_cache_entry *tun_tbl;
-	uint8_t tun_idx = 0;
-	int rc;
 
 	flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctxt);
 	if (!flow_db) {
@@ -859,18 +764,6 @@ ulp_flow_db_resource_del(struct bnxt_ulp_context *ulp_ctxt,
 				      params->resource_hndl);
 	}
 
-	if (params->resource_func == BNXT_ULP_RESOURCE_FUNC_PARENT_FLOW) {
-		tun_tbl = bnxt_ulp_cntxt_ptr2_tun_tbl_get(ulp_ctxt);
-		if (!tun_tbl)
-			return -EINVAL;
-
-		rc = ulp_flow_db_parent_tun_idx_get(ulp_ctxt, fid, &tun_idx);
-		if (rc)
-			return rc;
-
-		ulp_clear_tun_entry(tun_tbl, tun_idx);
-	}
-
 	/* all good, return success */
 	return 0;
 }
@@ -889,7 +782,6 @@ ulp_flow_db_fid_free(struct bnxt_ulp_context *ulp_ctxt,
 		     enum bnxt_ulp_fdb_type flow_type,
 		     uint32_t fid)
 {
-	struct bnxt_tun_cache_entry *tun_tbl;
 	struct bnxt_ulp_flow_tbl *flow_tbl;
 	struct bnxt_ulp_flow_db *flow_db;
 
@@ -931,12 +823,9 @@ ulp_flow_db_fid_free(struct bnxt_ulp_context *ulp_ctxt,
 	if (flow_type == BNXT_ULP_FDB_TYPE_REGULAR)
 		ulp_flow_db_func_id_set(flow_db, fid, 0);
 
-	tun_tbl = bnxt_ulp_cntxt_ptr2_tun_tbl_get(ulp_ctxt);
-	if (!tun_tbl)
-		return -EINVAL;
-
-	ulp_clear_tun_inner_entry(tun_tbl, fid);
-
+#ifdef RTE_LIBRTE_BNXT_TRUFLOW_DEBUG
+	BNXT_TF_DBG(ERR, "flow_id = %u:%u freed\n", flow_type, fid);
+#endif
 	/* all good, return success */
 	return 0;
 }
@@ -1301,24 +1190,84 @@ ulp_default_flow_db_cfa_action_get(struct bnxt_ulp_context *ulp_ctx,
 	return 0;
 }
 
+/* internal validation function for parent flow tbl */
+static struct ulp_fdb_parent_info *
+ulp_flow_db_pc_db_entry_get(struct bnxt_ulp_context *ulp_ctxt,
+			    uint32_t pc_idx)
+{
+	struct bnxt_ulp_flow_db *flow_db;
+
+	flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctxt);
+	if (!flow_db) {
+		BNXT_TF_DBG(ERR, "Invalid Arguments\n");
+		return NULL;
+	}
+
+	/* check for max flows */
+	if (pc_idx >= BNXT_ULP_MAX_TUN_CACHE_ENTRIES) {
+		BNXT_TF_DBG(ERR, "Invalid tunnel index\n");
+		return NULL;
+	}
+
+	/* No support for parent child db then just exit */
+	if (!flow_db->parent_child_db.entries_count) {
+		BNXT_TF_DBG(ERR, "parent child db not supported\n");
+		return NULL;
+	}
+	if (!flow_db->parent_child_db.parent_flow_tbl[pc_idx].valid) {
+		BNXT_TF_DBG(ERR, "Not a valid tunnel index\n");
+		return NULL;
+	}
+
+	return &flow_db->parent_child_db.parent_flow_tbl[pc_idx];
+}
+
+/* internal validation function for parent flow tbl */
+static struct bnxt_ulp_flow_db *
+ulp_flow_db_parent_arg_validation(struct bnxt_ulp_context *ulp_ctxt,
+				  uint32_t tun_idx)
+{
+	struct bnxt_ulp_flow_db *flow_db;
+
+	flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctxt);
+	if (!flow_db) {
+		BNXT_TF_DBG(ERR, "Invalid Arguments\n");
+		return NULL;
+	}
+
+	/* check for max flows */
+	if (tun_idx >= BNXT_ULP_MAX_TUN_CACHE_ENTRIES) {
+		BNXT_TF_DBG(ERR, "Invalid tunnel index\n");
+		return NULL;
+	}
+
+	/* No support for parent child db then just exit */
+	if (!flow_db->parent_child_db.entries_count) {
+		BNXT_TF_DBG(ERR, "parent child db not supported\n");
+		return NULL;
+	}
+
+	return flow_db;
+}
+
 /*
  * Allocate the entry in the parent-child database
  *
  * ulp_ctxt [in] Ptr to ulp_context
- * fid [in] The flow id to the flow entry
+ * tun_idx [in] The tunnel index of the flow entry
  *
  * returns index on success and negative on failure.
  */
-int32_t
-ulp_flow_db_parent_flow_alloc(struct bnxt_ulp_context *ulp_ctxt,
-			      uint32_t fid)
+static int32_t
+ulp_flow_db_pc_db_idx_alloc(struct bnxt_ulp_context *ulp_ctxt,
+			    uint32_t tun_idx)
 {
 	struct bnxt_ulp_flow_db *flow_db;
 	struct ulp_fdb_parent_child_db *p_pdb;
 	uint32_t idx, free_idx = 0;
 
 	/* validate the arguments */
-	flow_db = ulp_flow_db_parent_arg_validation(ulp_ctxt, fid);
+	flow_db = ulp_flow_db_parent_arg_validation(ulp_ctxt, tun_idx);
 	if (!flow_db) {
 		BNXT_TF_DBG(ERR, "parent child db validation failed\n");
 		return -EINVAL;
@@ -1326,11 +1275,11 @@ ulp_flow_db_parent_flow_alloc(struct bnxt_ulp_context *ulp_ctxt,
 
 	p_pdb = &flow_db->parent_child_db;
 	for (idx = 0; idx < p_pdb->entries_count; idx++) {
-		if (p_pdb->parent_flow_tbl[idx].parent_fid == fid) {
-			BNXT_TF_DBG(ERR, "fid is already allocated\n");
-			return -EINVAL;
+		if (p_pdb->parent_flow_tbl[idx].valid &&
+		    p_pdb->parent_flow_tbl[idx].tun_idx == tun_idx) {
+			return idx;
 		}
-		if (!p_pdb->parent_flow_tbl[idx].parent_fid && !free_idx)
+		if (!p_pdb->parent_flow_tbl[idx].valid && !free_idx)
 			free_idx = idx + 1;
 	}
 	/* no free slots */
@@ -1341,132 +1290,148 @@ ulp_flow_db_parent_flow_alloc(struct bnxt_ulp_context *ulp_ctxt,
 
 	free_idx -= 1;
 	/* set the Fid in the parent child */
-	p_pdb->parent_flow_tbl[free_idx].parent_fid = fid;
+	p_pdb->parent_flow_tbl[free_idx].tun_idx = tun_idx;
+	p_pdb->parent_flow_tbl[free_idx].valid = 1;
 	return free_idx;
 }
 
 /*
  * Free the entry in the parent-child database
  *
- * ulp_ctxt [in] Ptr to ulp_context
- * fid [in] The flow id to the flow entry
+ * pc_entry [in] Ptr to parent child db entry
  *
- * returns 0 on success and negative on failure.
+ * returns none.
  */
-int32_t
-ulp_flow_db_parent_flow_free(struct bnxt_ulp_context *ulp_ctxt,
-			     uint32_t fid)
+static void
+ulp_flow_db_pc_db_entry_free(struct bnxt_ulp_context *ulp_ctxt,
+			     struct ulp_fdb_parent_info *pc_entry)
 {
+	struct bnxt_tun_cache_entry *tun_tbl;
 	struct bnxt_ulp_flow_db *flow_db;
-	struct ulp_fdb_parent_child_db *p_pdb;
-	uint32_t idx;
+	uint64_t *tmp_bitset;
 
-	/* validate the arguments */
-	flow_db = ulp_flow_db_parent_arg_validation(ulp_ctxt, fid);
-	if (!flow_db) {
-		BNXT_TF_DBG(ERR, "parent child db validation failed\n");
-		return -EINVAL;
-	}
+	/* free the tunnel entry */
+	tun_tbl = bnxt_ulp_cntxt_ptr2_tun_tbl_get(ulp_ctxt);
+	if (tun_tbl)
+		ulp_tunnel_offload_entry_clear(tun_tbl, pc_entry->tun_idx);
 
-	p_pdb = &flow_db->parent_child_db;
-	for (idx = 0; idx < p_pdb->entries_count; idx++) {
-		if (p_pdb->parent_flow_tbl[idx].parent_fid == fid) {
-			/* free the contents */
-			p_pdb->parent_flow_tbl[idx].parent_fid = 0;
-			memset(p_pdb->parent_flow_tbl[idx].child_fid_bitset,
-			       0, p_pdb->child_bitset_size);
-			return 0;
-		}
-	}
-	BNXT_TF_DBG(ERR, "parent entry not found = %x\n", fid);
-	return -EINVAL;
+	/* free the child bitset*/
+	flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctxt);
+	if (flow_db)
+		memset(pc_entry->child_fid_bitset, 0,
+		       flow_db->parent_child_db.child_bitset_size);
+
+	/* free the contents */
+	tmp_bitset = pc_entry->child_fid_bitset;
+	memset(pc_entry, 0, sizeof(struct ulp_fdb_parent_info));
+	pc_entry->child_fid_bitset = tmp_bitset;
 }
 
 /*
- * Set or reset the child flow in the parent-child database
+ * Set or reset the parent flow in the parent-child database
  *
  * ulp_ctxt [in] Ptr to ulp_context
+ * pc_idx [in] The index to parent child db
  * parent_fid [in] The flow id of the parent flow entry
- * child_fid [in] The flow id of the child flow entry
  * set_flag [in] Use 1 for setting child, 0 to reset
  *
  * returns zero on success and negative on failure.
  */
 int32_t
-ulp_flow_db_parent_child_flow_set(struct bnxt_ulp_context *ulp_ctxt,
+ulp_flow_db_pc_db_parent_flow_set(struct bnxt_ulp_context *ulp_ctxt,
+				  uint32_t pc_idx,
 				  uint32_t parent_fid,
-				  uint32_t child_fid,
 				  uint32_t set_flag)
 {
+	struct ulp_fdb_parent_info *pc_entry;
 	struct bnxt_ulp_flow_db *flow_db;
-	struct ulp_fdb_parent_child_db *p_pdb;
-	uint32_t idx, a_idx;
-	uint64_t *t;
 
-	/* validate the arguments */
-	flow_db = ulp_flow_db_parent_arg_validation(ulp_ctxt, parent_fid);
+	flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctxt);
 	if (!flow_db) {
 		BNXT_TF_DBG(ERR, "parent child db validation failed\n");
 		return -EINVAL;
 	}
 
 	/* check for fid validity */
-	if (child_fid >= flow_db->flow_tbl.num_flows || !child_fid) {
-		BNXT_TF_DBG(ERR, "Invalid child flow index %x\n", child_fid);
+	if (parent_fid >= flow_db->flow_tbl.num_flows || !parent_fid) {
+		BNXT_TF_DBG(ERR, "Invalid parent flow index %x\n", parent_fid);
 		return -EINVAL;
 	}
 
-	p_pdb = &flow_db->parent_child_db;
-	a_idx = child_fid / ULP_INDEX_BITMAP_SIZE;
-	for (idx = 0; idx < p_pdb->entries_count; idx++) {
-		if (p_pdb->parent_flow_tbl[idx].parent_fid == parent_fid) {
-			t = p_pdb->parent_flow_tbl[idx].child_fid_bitset;
-			if (set_flag)
-				ULP_INDEX_BITMAP_SET(t[a_idx], child_fid);
-			else
-				ULP_INDEX_BITMAP_RESET(t[a_idx], child_fid);
-			return 0;
-		}
+	/* validate the arguments and parent child entry */
+	pc_entry = ulp_flow_db_pc_db_entry_get(ulp_ctxt, pc_idx);
+	if (!pc_entry) {
+		BNXT_TF_DBG(ERR, "failed to get the parent child entry\n");
+		return -EINVAL;
 	}
-	BNXT_TF_DBG(ERR, "Unable to set the parent-child flow %x:%x\n",
-		    parent_fid, child_fid);
-	return -1;
+
+	if (set_flag) {
+		pc_entry->parent_fid = parent_fid;
+	} else {
+		if (pc_entry->parent_fid != parent_fid)
+			BNXT_TF_DBG(ERR, "Panic: invalid parent id\n");
+		pc_entry->parent_fid = 0;
+
+		/* Free the parent child db entry if no user present */
+		if (!pc_entry->f2_cnt)
+			ulp_flow_db_pc_db_entry_free(ulp_ctxt, pc_entry);
+	}
+	return 0;
 }
 
 /*
- * Get the parent index from the parent-child database
+ * Set or reset the child flow in the parent-child database
  *
  * ulp_ctxt [in] Ptr to ulp_context
- * parent_fid [in] The flow id of the parent flow entry
- * parent_idx [out] The parent index of parent flow entry
+ * pc_idx [in] The index to parent child db
+ * child_fid [in] The flow id of the child flow entry
+ * set_flag [in] Use 1 for setting child, 0 to reset
  *
  * returns zero on success and negative on failure.
  */
 int32_t
-ulp_flow_db_parent_flow_idx_get(struct bnxt_ulp_context *ulp_ctxt,
-				uint32_t parent_fid,
-				uint32_t *parent_idx)
+ulp_flow_db_pc_db_child_flow_set(struct bnxt_ulp_context *ulp_ctxt,
+				 uint32_t pc_idx,
+				 uint32_t child_fid,
+				 uint32_t set_flag)
 {
+	struct ulp_fdb_parent_info *pc_entry;
 	struct bnxt_ulp_flow_db *flow_db;
-	struct ulp_fdb_parent_child_db *p_pdb;
-	uint32_t idx;
+	uint32_t a_idx;
+	uint64_t *t;
 
-	/* validate the arguments */
-	flow_db = ulp_flow_db_parent_arg_validation(ulp_ctxt, parent_fid);
+	flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctxt);
 	if (!flow_db) {
 		BNXT_TF_DBG(ERR, "parent child db validation failed\n");
 		return -EINVAL;
 	}
 
-	p_pdb = &flow_db->parent_child_db;
-	for (idx = 0; idx < p_pdb->entries_count; idx++) {
-		if (p_pdb->parent_flow_tbl[idx].parent_fid == parent_fid) {
-			*parent_idx = idx;
-			return 0;
-		}
+	/* check for fid validity */
+	if (child_fid >= flow_db->flow_tbl.num_flows || !child_fid) {
+		BNXT_TF_DBG(ERR, "Invalid child flow index %x\n", child_fid);
+		return -EINVAL;
 	}
-	BNXT_TF_DBG(ERR, "Unable to get the parent flow %x\n", parent_fid);
-	return -1;
+
+	/* validate the arguments and parent child entry */
+	pc_entry = ulp_flow_db_pc_db_entry_get(ulp_ctxt, pc_idx);
+	if (!pc_entry) {
+		BNXT_TF_DBG(ERR, "failed to get the parent child entry\n");
+		return -EINVAL;
+	}
+
+	a_idx = child_fid / ULP_INDEX_BITMAP_SIZE;
+	t = pc_entry->child_fid_bitset;
+	if (set_flag) {
+		ULP_INDEX_BITMAP_SET(t[a_idx], child_fid);
+		pc_entry->f2_cnt++;
+	} else {
+		ULP_INDEX_BITMAP_RESET(t[a_idx], child_fid);
+		if (pc_entry->f2_cnt)
+			pc_entry->f2_cnt--;
+		if (!pc_entry->f2_cnt && !pc_entry->parent_fid)
+			ulp_flow_db_pc_db_entry_free(ulp_ctxt, pc_entry);
+	}
+	return 0;
 }
 
 /*
@@ -1535,13 +1500,13 @@ ulp_flow_db_parent_child_flow_next_entry_get(struct bnxt_ulp_flow_db *flow_db,
  * Set the counter accumulation in the parent flow
  *
  * ulp_ctxt [in] Ptr to ulp_context
- * parent_idx [in] The parent index of the parent flow entry
+ * pc_idx [in] The parent child index of the parent flow entry
  *
  * returns index on success and negative on failure.
  */
 static int32_t
 ulp_flow_db_parent_flow_count_accum_set(struct bnxt_ulp_context *ulp_ctxt,
-					uint32_t parent_idx)
+					uint32_t pc_idx)
 {
 	struct bnxt_ulp_flow_db *flow_db;
 	struct ulp_fdb_parent_child_db *p_pdb;
@@ -1554,50 +1519,16 @@ ulp_flow_db_parent_flow_count_accum_set(struct bnxt_ulp_context *ulp_ctxt,
 
 	/* check for parent idx validity */
 	p_pdb = &flow_db->parent_child_db;
-	if (parent_idx >= p_pdb->entries_count ||
-	    !p_pdb->parent_flow_tbl[parent_idx].parent_fid) {
-		BNXT_TF_DBG(ERR, "Invalid parent flow index %x\n", parent_idx);
+	if (pc_idx >= p_pdb->entries_count ||
+	    !p_pdb->parent_flow_tbl[pc_idx].parent_fid) {
+		BNXT_TF_DBG(ERR, "Invalid parent child index %x\n", pc_idx);
 		return -EINVAL;
 	}
 
-	p_pdb->parent_flow_tbl[parent_idx].counter_acc = 1;
+	p_pdb->parent_flow_tbl[pc_idx].counter_acc = 1;
 	return 0;
 }
 
-/*
- * Get the counter accumulation in the parent flow
- *
- * ulp_ctxt [in] Ptr to ulp_context
- * parent_fid [in] The flow id of the parent flow entry
- *
- * returns 0 if counter accum is set else -1.
- */
-static int32_t
-ulp_flow_db_parent_flow_count_accum_get(struct bnxt_ulp_context *ulp_ctxt,
-					uint32_t parent_fid)
-{
-	struct bnxt_ulp_flow_db *flow_db;
-	struct ulp_fdb_parent_child_db *p_pdb;
-	uint32_t idx;
-
-	/* validate the arguments */
-	flow_db = ulp_flow_db_parent_arg_validation(ulp_ctxt, parent_fid);
-	if (!flow_db) {
-		BNXT_TF_DBG(ERR, "parent child db validation failed\n");
-		return -EINVAL;
-	}
-
-	p_pdb = &flow_db->parent_child_db;
-	for (idx = 0; idx < p_pdb->entries_count; idx++) {
-		if (p_pdb->parent_flow_tbl[idx].parent_fid == parent_fid) {
-			if (p_pdb->parent_flow_tbl[idx].counter_acc)
-				return 0;
-			break;
-		}
-	}
-	return -1;
-}
-
 /*
  * Orphan the child flow entry
  * This is called only for child flows that have
@@ -1671,22 +1602,30 @@ int32_t
 ulp_flow_db_parent_flow_create(struct bnxt_ulp_mapper_parms *parms)
 {
 	struct ulp_flow_db_res_params fid_parms;
-	uint32_t sub_typ = BNXT_ULP_RESOURCE_SUB_TYPE_INDEX_TABLE_INT_COUNT_ACC;
+	uint32_t sub_typ = BNXT_ULP_RESOURCE_SUB_TYPE_INDEX_TABLE_INT_COUNT;
 	struct ulp_flow_db_res_params res_params;
-	int32_t fid_idx, rc;
+	int32_t pc_idx;
 
-	/* create the child flow entry in parent flow table */
-	fid_idx = ulp_flow_db_parent_flow_alloc(parms->ulp_ctx, parms->fid);
-	if (fid_idx < 0) {
-		BNXT_TF_DBG(ERR, "Error in creating parent flow fid %x\n",
-			    parms->fid);
-		return -1;
+	/* create or get the parent child database */
+	pc_idx = ulp_flow_db_pc_db_idx_alloc(parms->ulp_ctx, parms->tun_idx);
+	if (pc_idx < 0) {
+		BNXT_TF_DBG(ERR, "Error in getting parent child db %x\n",
+			    parms->tun_idx);
+		return -EINVAL;
+	}
+
+	/* Update the parent fid */
+	if (ulp_flow_db_pc_db_parent_flow_set(parms->ulp_ctx, pc_idx,
+					      parms->fid, 1)) {
+		BNXT_TF_DBG(ERR, "Error in setting parent fid %x\n",
+			    parms->tun_idx);
+		return -EINVAL;
 	}
 
 	/* Add the parent details in the resource list of the flow */
 	memset(&fid_parms, 0, sizeof(fid_parms));
 	fid_parms.resource_func	= BNXT_ULP_RESOURCE_FUNC_PARENT_FLOW;
-	fid_parms.resource_hndl	= fid_idx;
+	fid_parms.resource_hndl	= pc_idx;
 	fid_parms.critical_resource = BNXT_ULP_CRITICAL_RESOURCE_NO;
 	if (ulp_flow_db_resource_add(parms->ulp_ctx, BNXT_ULP_FDB_TYPE_REGULAR,
 				     parms->fid, &fid_parms)) {
@@ -1704,20 +1643,13 @@ ulp_flow_db_parent_flow_create(struct bnxt_ulp_mapper_parms *parms)
 					     &res_params)) {
 		/* Enable the counter accumulation in parent entry */
 		if (ulp_flow_db_parent_flow_count_accum_set(parms->ulp_ctx,
-							    fid_idx)) {
+							    pc_idx)) {
 			BNXT_TF_DBG(ERR, "Error in setting counter acc %x\n",
 				    parms->fid);
 			return -1;
 		}
 	}
 
-	rc  = ulp_flow_db_parent_tun_idx_set(parms->ulp_ctx, fid_idx,
-					     parms->tun_idx);
-	if (rc) {
-		BNXT_TF_DBG(ERR, "Error setting tun_idx in the parent flow\n");
-		return rc;
-	}
-
 	return 0;
 }
 
@@ -1735,13 +1667,19 @@ ulp_flow_db_child_flow_create(struct bnxt_ulp_mapper_parms *parms)
 	uint32_t sub_type = BNXT_ULP_RESOURCE_SUB_TYPE_INDEX_TABLE_INT_COUNT;
 	enum bnxt_ulp_resource_func res_fun;
 	struct ulp_flow_db_res_params res_p;
-	uint32_t parent_fid = parms->parent_fid;
-	int32_t rc;
+	int32_t rc, pc_idx;
+
+	/* create or get the parent child database */
+	pc_idx = ulp_flow_db_pc_db_idx_alloc(parms->ulp_ctx, parms->tun_idx);
+	if (pc_idx < 0) {
+		BNXT_TF_DBG(ERR, "Error in getting parent child db %x\n",
+			    parms->tun_idx);
+		return -1;
+	}
 
 	/* create the parent flow entry in parent flow table */
-	rc = ulp_flow_db_parent_child_flow_set(parms->ulp_ctx,
-					       parms->parent_fid,
-					       parms->fid, 1);
+	rc = ulp_flow_db_pc_db_child_flow_set(parms->ulp_ctx, pc_idx,
+					      parms->fid, 1);
 	if (rc) {
 		BNXT_TF_DBG(ERR, "Error in setting child fid %x\n", parms->fid);
 		return rc;
@@ -1750,7 +1688,7 @@ ulp_flow_db_child_flow_create(struct bnxt_ulp_mapper_parms *parms)
 	/* Add the parent details in the resource list of the flow */
 	memset(&fid_parms, 0, sizeof(fid_parms));
 	fid_parms.resource_func	= BNXT_ULP_RESOURCE_FUNC_CHILD_FLOW;
-	fid_parms.resource_hndl	= parms->parent_fid;
+	fid_parms.resource_hndl	= pc_idx;
 	fid_parms.critical_resource = BNXT_ULP_CRITICAL_RESOURCE_NO;
 	rc  = ulp_flow_db_resource_add(parms->ulp_ctx,
 				       BNXT_ULP_FDB_TYPE_REGULAR,
@@ -1761,30 +1699,26 @@ ulp_flow_db_child_flow_create(struct bnxt_ulp_mapper_parms *parms)
 		return rc;
 	}
 
-	/* check if accumulation count is set for parent flow */
-	rc = ulp_flow_db_parent_flow_count_accum_get(parms->ulp_ctx,
-						     parms->parent_fid);
+	/* check if internal count action included for this flow.*/
+	res_fun = BNXT_ULP_RESOURCE_FUNC_INDEX_TABLE;
+	rc = ulp_flow_db_resource_params_get(parms->ulp_ctx,
+					     BNXT_ULP_FDB_TYPE_REGULAR,
+					     parms->fid,
+					     res_fun,
+					     sub_type,
+					     &res_p);
 	if (!rc) {
-		/* check if internal count action included for this flow.*/
-		res_fun = BNXT_ULP_RESOURCE_FUNC_INDEX_TABLE;
-		rc = ulp_flow_db_resource_params_get(parms->ulp_ctx,
-						     BNXT_ULP_FDB_TYPE_REGULAR,
-						     parms->fid,
-						     res_fun,
-						     sub_type,
-						     &res_p);
-		if (!rc) {
-			/* update the counter manager to include parent fid */
-			if (ulp_fc_mgr_cntr_parent_flow_set(parms->ulp_ctx,
-							    res_p.direction,
-							    res_p.resource_hndl,
-							    parent_fid)) {
-				BNXT_TF_DBG(ERR, "Error in setting child %x\n",
-					    parms->fid);
-				return -1;
-			}
+		/* update the counter manager to include parent fid */
+		if (ulp_fc_mgr_cntr_parent_flow_set(parms->ulp_ctx,
+						    res_p.direction,
+						    res_p.resource_hndl,
+						    pc_idx)) {
+			BNXT_TF_DBG(ERR, "Error in setting child %x\n",
+				    parms->fid);
+			return -1;
 		}
 	}
+
 	/* return success */
 	return 0;
 }
@@ -1793,7 +1727,7 @@ ulp_flow_db_child_flow_create(struct bnxt_ulp_mapper_parms *parms)
  * Update the parent counters
  *
  * ulp_ctxt [in] Ptr to ulp_context
- * parent_fid [in] The flow id of the parent flow entry
+ * pc_idx [in] The parent flow entry idx
  * packet_count [in] - packet count
  * byte_count [in] - byte count
  *
@@ -1801,41 +1735,31 @@ ulp_flow_db_child_flow_create(struct bnxt_ulp_mapper_parms *parms)
  */
 int32_t
 ulp_flow_db_parent_flow_count_update(struct bnxt_ulp_context *ulp_ctxt,
-				     uint32_t parent_fid,
+				     uint32_t pc_idx,
 				     uint64_t packet_count,
 				     uint64_t byte_count)
 {
-	struct bnxt_ulp_flow_db *flow_db;
-	struct ulp_fdb_parent_child_db *p_pdb;
-	uint32_t idx;
+	struct ulp_fdb_parent_info *pc_entry;
 
-	/* validate the arguments */
-	flow_db = ulp_flow_db_parent_arg_validation(ulp_ctxt, parent_fid);
-	if (!flow_db) {
-		BNXT_TF_DBG(ERR, "parent child db validation failed\n");
+	/* validate the arguments and get parent child entry */
+	pc_entry = ulp_flow_db_pc_db_entry_get(ulp_ctxt, pc_idx);
+	if (!pc_entry) {
+		BNXT_TF_DBG(ERR, "failed to get the parent child entry\n");
 		return -EINVAL;
 	}
 
-	p_pdb = &flow_db->parent_child_db;
-	for (idx = 0; idx < p_pdb->entries_count; idx++) {
-		if (p_pdb->parent_flow_tbl[idx].parent_fid == parent_fid) {
-			if (p_pdb->parent_flow_tbl[idx].counter_acc) {
-				p_pdb->parent_flow_tbl[idx].pkt_count +=
-					packet_count;
-				p_pdb->parent_flow_tbl[idx].byte_count +=
-					byte_count;
-			}
-			return 0;
-		}
+	if (pc_entry->counter_acc) {
+		pc_entry->pkt_count += packet_count;
+		pc_entry->byte_count += byte_count;
 	}
-	return -ENOENT;
+	return 0;
 }
 
 /*
  * Get the parent accumulation counters
  *
  * ulp_ctxt [in] Ptr to ulp_context
- * parent_fid [in] The flow id of the parent flow entry
+ * pc_idx [in] The parent flow entry idx
  * packet_count [out] - packet count
  * byte_count [out] - byte count
  *
@@ -1843,37 +1767,27 @@ ulp_flow_db_parent_flow_count_update(struct bnxt_ulp_context *ulp_ctxt,
  */
 int32_t
 ulp_flow_db_parent_flow_count_get(struct bnxt_ulp_context *ulp_ctxt,
-				  uint32_t parent_fid, uint64_t *packet_count,
+				  uint32_t pc_idx, uint64_t *packet_count,
 				  uint64_t *byte_count, uint8_t count_reset)
 {
-	struct bnxt_ulp_flow_db *flow_db;
-	struct ulp_fdb_parent_child_db *p_pdb;
-	uint32_t idx;
+	struct ulp_fdb_parent_info *pc_entry;
 
-	/* validate the arguments */
-	flow_db = ulp_flow_db_parent_arg_validation(ulp_ctxt, parent_fid);
-	if (!flow_db) {
-		BNXT_TF_DBG(ERR, "parent child db validation failed\n");
+	/* validate the arguments and get parent child entry */
+	pc_entry = ulp_flow_db_pc_db_entry_get(ulp_ctxt, pc_idx);
+	if (!pc_entry) {
+		BNXT_TF_DBG(ERR, "failed to get the parent child entry\n");
 		return -EINVAL;
 	}
 
-	p_pdb = &flow_db->parent_child_db;
-	for (idx = 0; idx < p_pdb->entries_count; idx++) {
-		if (p_pdb->parent_flow_tbl[idx].parent_fid == parent_fid) {
-			if (p_pdb->parent_flow_tbl[idx].counter_acc) {
-				*packet_count =
-					p_pdb->parent_flow_tbl[idx].pkt_count;
-				*byte_count =
-					p_pdb->parent_flow_tbl[idx].byte_count;
-				if (count_reset) {
-					p_pdb->parent_flow_tbl[idx].pkt_count = 0;
-					p_pdb->parent_flow_tbl[idx].byte_count = 0;
-				}
-			}
-			return 0;
+	if (pc_entry->counter_acc) {
+		*packet_count = pc_entry->pkt_count;
+		*byte_count = pc_entry->byte_count;
+		if (count_reset) {
+			pc_entry->pkt_count = 0;
+			pc_entry->byte_count = 0;
 		}
 	}
-	return -ENOENT;
+	return 0;
 }
 
 /*
@@ -1891,7 +1805,7 @@ ulp_flow_db_parent_flow_count_reset(struct bnxt_ulp_context *ulp_ctxt)
 	uint32_t idx;
 
 	/* validate the arguments */
-	flow_db = ulp_flow_db_parent_arg_validation(ulp_ctxt, 1);
+	flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctxt);
 	if (!flow_db) {
 		BNXT_TF_DBG(ERR, "parent child db validation failed\n");
 		return;
@@ -1899,7 +1813,7 @@ ulp_flow_db_parent_flow_count_reset(struct bnxt_ulp_context *ulp_ctxt)
 
 	p_pdb = &flow_db->parent_child_db;
 	for (idx = 0; idx < p_pdb->entries_count; idx++) {
-		if (p_pdb->parent_flow_tbl[idx].parent_fid &&
+		if (p_pdb->parent_flow_tbl[idx].valid &&
 		    p_pdb->parent_flow_tbl[idx].counter_acc) {
 			p_pdb->parent_flow_tbl[idx].pkt_count = 0;
 			p_pdb->parent_flow_tbl[idx].byte_count = 0;
@@ -1921,3 +1835,113 @@ void ulp_flow_db_shared_session_set(struct ulp_flow_db_res_params *res,
 	if (res && (shared & BNXT_ULP_SHARED_SESSION_YES))
 		res->fdb_flags |= ULP_FDB_FLAG_SHARED_SESSION;
 }
+
+#ifdef RTE_LIBRTE_BNXT_TRUFLOW_DEBUG
+/*
+ * Dump the entry details
+ *
+ * ulp_ctxt [in] Ptr to ulp_context
+ *
+ * returns none
+ */
+static void ulp_flow_db_res_dump(struct ulp_fdb_resource_info *r,
+				 uint32_t *nxt_res)
+{
+	uint8_t res_func = ulp_flow_db_resource_func_get(r);
+
+	BNXT_TF_DBG(DEBUG, "Resource func = %x, nxt_resource_idx = %x\n",
+		    res_func, (ULP_FLOW_DB_RES_NXT_MASK & r->nxt_resource_idx));
+	if (res_func == BNXT_ULP_RESOURCE_FUNC_EM_TABLE)
+		BNXT_TF_DBG(DEBUG, "EM Handle = 0x%016" PRIX64 "\n",
+			    r->resource_em_handle);
+	else
+		BNXT_TF_DBG(DEBUG, "Handle = 0x%08x\n", r->resource_hndl);
+
+	*nxt_res = 0;
+	ULP_FLOW_DB_RES_NXT_SET(*nxt_res,
+				r->nxt_resource_idx);
+}
+
+/*
+ * Dump the flow entry details
+ *
+ * flow_db [in] Ptr to flow db
+ * fid [in] flow id
+ *
+ * returns none
+ */
+void
+ulp_flow_db_debug_fid_dump(struct bnxt_ulp_flow_db *flow_db, uint32_t fid)
+{
+	struct ulp_fdb_resource_info *r;
+	struct bnxt_ulp_flow_tbl *flow_tbl;
+	uint32_t nxt_res = 0;
+	uint32_t def_flag = 0, reg_flag = 0;
+
+	flow_tbl = &flow_db->flow_tbl;
+	if (ulp_flow_db_active_flows_bit_is_set(flow_db,
+						BNXT_ULP_FDB_TYPE_REGULAR, fid))
+		reg_flag = 1;
+	if (ulp_flow_db_active_flows_bit_is_set(flow_db,
+						BNXT_ULP_FDB_TYPE_DEFAULT, fid))
+		def_flag = 1;
+
+	if (reg_flag && def_flag)
+		BNXT_TF_DBG(DEBUG, "RID = %u\n", fid);
+	else if (reg_flag)
+		BNXT_TF_DBG(DEBUG, "Regular fid = %u and func id = %u\n",
+			    fid, flow_db->func_id_tbl[fid]);
+	else if (def_flag)
+		BNXT_TF_DBG(DEBUG, "Default fid = %u\n", fid);
+	else
+		return;
+	/* iterate the resource */
+	nxt_res = fid;
+	do {
+		r = &flow_tbl->flow_resources[nxt_res];
+		ulp_flow_db_res_dump(r, &nxt_res);
+	} while (nxt_res);
+}
+
+/*
+ * Dump the flow database entry details
+ *
+ * ulp_ctxt [in] Ptr to ulp_context
+ * flow_id [in] if zero then all fids are dumped.
+ *
+ * returns none
+ */
+int32_t	ulp_flow_db_debug_dump(struct bnxt_ulp_context *ulp_ctxt,
+			       uint32_t flow_id)
+{
+	struct bnxt_ulp_flow_db *flow_db;
+	struct bnxt_ulp_flow_tbl *flow_tbl;
+	uint32_t fid;
+
+	if (!ulp_ctxt || !ulp_ctxt->cfg_data) {
+		BNXT_TF_DBG(ERR, "Invalid Arguments\n");
+		return -EINVAL;
+	}
+	flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctxt);
+	if (!flow_db) {
+		BNXT_TF_DBG(ERR, "Invalid Arguments\n");
+		return -EINVAL;
+	}
+
+	flow_tbl = &flow_db->flow_tbl;
+	if (flow_id) {
+		ulp_flow_db_debug_fid_dump(flow_db, flow_id);
+		return 0;
+	}
+
+	BNXT_TF_DBG(DEBUG, "Dump flows = %u:%u\n",
+		    flow_tbl->num_flows,
+		    flow_tbl->num_resources);
+	BNXT_TF_DBG(DEBUG, "Head_index = %u, Tail_index = %u\n",
+		    flow_tbl->head_index, flow_tbl->tail_index);
+	for (fid = 1; fid < flow_tbl->num_flows; fid++)
+		ulp_flow_db_debug_fid_dump(flow_db, fid);
+	BNXT_TF_DBG(DEBUG, "Done.\n");
+	return 0;
+}
+#endif