+
+/*
+ * Flush all flows in the flow database that belong to a device function.
+ *
+ * ulp_ctxt [in] Ptr to ulp context
+ * func_id [in] - The port function id
+ *
+ * returns 0 on success or negative number on failure
+ */
+int32_t
+ulp_flow_db_function_flow_flush(struct bnxt_ulp_context *ulp_ctx,
+ uint16_t func_id)
+{
+ uint32_t flow_id = 0;
+ struct bnxt_ulp_flow_db *flow_db;
+
+ if (!ulp_ctx || !func_id) {
+ BNXT_TF_DBG(ERR, "Invalid Argument\n");
+ return -EINVAL;
+ }
+
+ flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctx);
+ if (!flow_db) {
+ BNXT_TF_DBG(ERR, "Flow database not found\n");
+ return -EINVAL;
+ }
+ if (bnxt_ulp_cntxt_acquire_fdb_lock(ulp_ctx)) {
+ BNXT_TF_DBG(ERR, "Flow db lock acquire failed\n");
+ return -EINVAL;
+ }
+
+ while (!ulp_flow_db_next_entry_get(flow_db, BNXT_ULP_FDB_TYPE_REGULAR,
+ &flow_id)) {
+ if (flow_db->func_id_tbl[flow_id] == func_id)
+ ulp_mapper_resources_free(ulp_ctx,
+ BNXT_ULP_FDB_TYPE_REGULAR,
+ flow_id);
+ }
+ bnxt_ulp_cntxt_release_fdb_lock(ulp_ctx);
+ return 0;
+}
+
+/*
+ * Flush all flows in the flow database that are associated with the session.
+ *
+ * ulp_ctxt [in] Ptr to ulp context
+ *
+ * returns 0 on success or negative number on failure
+ */
+int32_t
+ulp_flow_db_session_flow_flush(struct bnxt_ulp_context *ulp_ctx)
+{
+ /*
+ * TBD: Tf core implementation of FW session flush shall change this
+ * implementation.
+ */
+ return ulp_flow_db_flush_flows(ulp_ctx, BNXT_ULP_FDB_TYPE_REGULAR);
+}
+
+/*
+ * Check that flow id matches the function id or not
+ *
+ * ulp_ctxt [in] Ptr to ulp context
+ * flow_db [in] Ptr to flow table
+ * func_id [in] The func_id to be set, for reset pass zero.
+ *
+ * returns true on success or false on failure
+ */
+bool
+ulp_flow_db_validate_flow_func(struct bnxt_ulp_context *ulp_ctx,
+ uint32_t flow_id,
+ uint32_t func_id)
+{
+ struct bnxt_ulp_flow_db *flow_db;
+
+ flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctx);
+ if (!flow_db) {
+ BNXT_TF_DBG(ERR, "Flow database not found\n");
+ return false;
+ }
+
+ /* set the function id in the function table */
+ if (flow_id < flow_db->func_id_tbl_size && func_id &&
+ flow_db->func_id_tbl[flow_id] == func_id)
+ return true;
+
+ return false;
+}
+
+/*
+ * Internal api to traverse the resource list within a flow
+ * and match a resource based on resource func and resource
+ * sub type. This api should be used only for resources that
+ * are unique and do not have multiple instances of resource
+ * func and sub type combination since it will return only
+ * the first match.
+ */
+static int32_t
+ulp_flow_db_resource_params_get(struct bnxt_ulp_context *ulp_ctx,
+ enum bnxt_ulp_fdb_type flow_type,
+ uint32_t flow_id,
+ uint32_t resource_func,
+ uint32_t res_subtype,
+ struct ulp_flow_db_res_params *params)
+{
+ struct bnxt_ulp_flow_db *flow_db;
+ struct bnxt_ulp_flow_tbl *flow_tbl;
+ struct ulp_fdb_resource_info *fid_res;
+ uint32_t res_id;
+
+ flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctx);
+ if (!flow_db) {
+ BNXT_TF_DBG(ERR, "Flow database not found\n");
+ return -EINVAL;
+ }
+
+ if (!params) {
+ BNXT_TF_DBG(ERR, "invalid argument\n");
+ return -EINVAL;
+ }
+
+ if (flow_type >= BNXT_ULP_FDB_TYPE_LAST) {
+ BNXT_TF_DBG(ERR, "Invalid flow type\n");
+ return -EINVAL;
+ }
+
+ flow_tbl = &flow_db->flow_tbl;
+
+ /* check for limits of fid */
+ if (flow_id >= flow_tbl->num_flows || !flow_id) {
+ BNXT_TF_DBG(ERR, "Invalid flow index\n");
+ return -EINVAL;
+ }
+
+ /* check if the flow is active or not */
+ if (!ulp_flow_db_active_flows_bit_is_set(flow_db, flow_type, flow_id)) {
+ BNXT_TF_DBG(ERR, "flow does not exist\n");
+ return -EINVAL;
+ }
+ /* Iterate the resource to get the resource handle */
+ res_id = flow_id;
+ memset(params, 0, sizeof(struct ulp_flow_db_res_params));
+ while (res_id) {
+ fid_res = &flow_tbl->flow_resources[res_id];
+ if (ulp_flow_db_resource_func_get(fid_res) == resource_func) {
+ if (resource_func & ULP_FLOW_DB_RES_FUNC_NEED_LOWER) {
+ if (res_subtype == fid_res->resource_sub_type) {
+ ulp_flow_db_res_info_to_params(fid_res,
+ params);
+ return 0;
+ }
+
+ } else if (resource_func ==
+ BNXT_ULP_RESOURCE_FUNC_EM_TABLE) {
+ ulp_flow_db_res_info_to_params(fid_res,
+ params);
+ return 0;
+ }
+ }
+ res_id = 0;
+ ULP_FLOW_DB_RES_NXT_SET(res_id, fid_res->nxt_resource_idx);
+ }
+ return -ENOENT;
+}
+
+/*
+ * Api to get the cfa action pointer from a flow.
+ *
+ * ulp_ctxt [in] Ptr to ulp context
+ * flow_id [in] flow id
+ * cfa_action [out] The resource handle stored in the flow database
+ *
+ * returns 0 on success
+ */
+int32_t
+ulp_default_flow_db_cfa_action_get(struct bnxt_ulp_context *ulp_ctx,
+ uint32_t flow_id,
+ uint16_t *cfa_action)
+{
+ uint8_t sub_typ = BNXT_ULP_RESOURCE_SUB_TYPE_INDEX_TABLE_VFR_CFA_ACTION;
+ struct ulp_flow_db_res_params params;
+ int32_t rc;
+
+ rc = ulp_flow_db_resource_params_get(ulp_ctx,
+ BNXT_ULP_FDB_TYPE_DEFAULT,
+ flow_id,
+ BNXT_ULP_RESOURCE_FUNC_INDEX_TABLE,
+ sub_typ, ¶ms);
+ if (rc) {
+ BNXT_TF_DBG(INFO, "CFA Action ptr not found for flow id %u\n",
+ flow_id);
+ return -ENOENT;
+ }
+ *cfa_action = params.resource_hndl;
+ return 0;
+}
+
+/*
+ * Allocate the entry in the parent-child database
+ *
+ * ulp_ctxt [in] Ptr to ulp_context
+ * fid [in] The flow id to 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)
+{
+ 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);
+ 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 == fid) {
+ BNXT_TF_DBG(ERR, "fid is already allocated\n");
+ return -EINVAL;
+ }
+ if (!p_pdb->parent_flow_tbl[idx].parent_fid && !free_idx)
+ free_idx = idx + 1;
+ }
+ /* no free slots */
+ if (!free_idx) {
+ BNXT_TF_DBG(ERR, "parent child db is full\n");
+ return -ENOMEM;
+ }
+
+ free_idx -= 1;
+ /* set the Fid in the parent child */
+ p_pdb->parent_flow_tbl[free_idx].parent_fid = fid;
+ 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
+ *
+ * returns 0 on success and negative on failure.
+ */
+int32_t
+ulp_flow_db_parent_flow_free(struct bnxt_ulp_context *ulp_ctxt,
+ uint32_t 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, 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 == 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;
+}
+
+/*
+ * 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
+ * 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,
+ uint32_t parent_fid,
+ uint32_t child_fid,
+ uint32_t set_flag)
+{
+ 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);
+ 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);
+ 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;
+ }
+ }
+ BNXT_TF_DBG(ERR, "Unable to set the parent-child flow %x:%x\n",
+ parent_fid, child_fid);
+ return -1;
+}
+
+/*
+ * Get the parent index from 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
+ *
+ * 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)
+{
+ 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) {
+ *parent_idx = idx;
+ return 0;
+ }
+ }
+ BNXT_TF_DBG(ERR, "Unable to get the parent flow %x\n", parent_fid);
+ return -1;
+}
+
+/*
+ * Get the next 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
+ * child_fid [in/out] The flow id of the child flow entry
+ *
+ * returns zero on success and negative on failure.
+ * Pass child_fid as zero for first entry.
+ */
+int32_t
+ulp_flow_db_parent_child_flow_next_entry_get(struct bnxt_ulp_flow_db *flow_db,
+ uint32_t parent_idx,
+ uint32_t *child_fid)
+{
+ struct ulp_fdb_parent_child_db *p_pdb;
+ uint32_t idx, s_idx, mod_fid;
+ uint32_t next_fid = *child_fid;
+ uint64_t *child_bitset;
+ uint64_t bs;
+
+ /* check for fid 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;
+ }
+
+ child_bitset = p_pdb->parent_flow_tbl[parent_idx].child_fid_bitset;
+ do {
+ /* increment the flow id to find the next valid flow id */
+ next_fid++;
+ if (next_fid >= flow_db->flow_tbl.num_flows)
+ return -ENOENT;
+ idx = next_fid / ULP_INDEX_BITMAP_SIZE;
+ mod_fid = next_fid % ULP_INDEX_BITMAP_SIZE;
+ s_idx = idx;
+ while (!(bs = child_bitset[idx])) {
+ idx++;
+ if ((idx * ULP_INDEX_BITMAP_SIZE) >=
+ flow_db->flow_tbl.num_flows)
+ return -ENOENT;
+ }
+ /*
+ * remove the previous bits in the bitset bs to find the
+ * next non zero bit in the bitset. This needs to be done
+ * only if the idx is same as he one you started.
+ */
+ if (s_idx == idx)
+ bs &= (-1UL >> mod_fid);
+ next_fid = (idx * ULP_INDEX_BITMAP_SIZE) + __builtin_clzl(bs);
+ if (*child_fid >= next_fid) {
+ BNXT_TF_DBG(ERR, "Parent Child Database is corrupt\n");
+ return -ENOENT;
+ }
+ idx = next_fid / ULP_INDEX_BITMAP_SIZE;
+ } while (!ULP_INDEX_BITMAP_GET(child_bitset[idx], next_fid));
+ *child_fid = next_fid;
+ return 0;
+}
+
+/*
+ * 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
+ *
+ * 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)
+{
+ 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].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
+ * BNXT_ULP_RESOURCE_FUNC_CHILD_FLOW resource
+ *
+ * ulp_ctxt [in] Ptr to ulp_context
+ * flow_type [in] Specify it is regular or default flow
+ * fid [in] The index to the flow entry
+ *
+ * Returns 0 on success and negative on failure.
+ */
+int32_t
+ulp_flow_db_child_flow_reset(struct bnxt_ulp_context *ulp_ctxt,
+ enum bnxt_ulp_fdb_type flow_type,
+ uint32_t fid)
+{
+ struct bnxt_ulp_flow_db *flow_db;
+ struct bnxt_ulp_flow_tbl *flow_tbl;
+ struct ulp_fdb_resource_info *fid_res;
+ uint32_t res_id = 0;
+
+ flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctxt);
+ if (!flow_db) {
+ BNXT_TF_DBG(ERR, "Invalid Arguments\n");
+ return -EINVAL;
+ }
+
+ if (flow_type >= BNXT_ULP_FDB_TYPE_LAST) {
+ BNXT_TF_DBG(ERR, "Invalid flow type\n");
+ return -EINVAL;
+ }
+
+ flow_tbl = &flow_db->flow_tbl;
+ /* check for max flows */
+ if (fid >= flow_tbl->num_flows || !fid) {
+ BNXT_TF_DBG(ERR, "Invalid flow index %x\n", fid);
+ return -EINVAL;
+ }
+
+ /* check if the flow is active or not */
+ if (!ulp_flow_db_active_flows_bit_is_set(flow_db, flow_type, fid)) {
+ BNXT_TF_DBG(ERR, "flow does not exist\n");
+ return -EINVAL;
+ }
+
+ /* Iterate the resource to get the resource handle */
+ res_id = fid;
+ while (res_id) {
+ fid_res = &flow_tbl->flow_resources[res_id];
+ if (ulp_flow_db_resource_func_get(fid_res) ==
+ BNXT_ULP_RESOURCE_FUNC_CHILD_FLOW) {
+ /* invalidate the resource details */
+ fid_res->resource_hndl = 0;
+ return 0;
+ }
+ res_id = 0;
+ ULP_FLOW_DB_RES_NXT_SET(res_id, fid_res->nxt_resource_idx);
+ }
+ /* failed */
+ return -1;
+}
+
+/*
+ * Create parent flow in the parent flow tbl
+ *
+ * parms [in] Ptr to mapper params
+ *
+ * Returns 0 on success and negative on failure.
+ */
+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;
+ struct ulp_flow_db_res_params res_params;
+ int32_t fid_idx, rc;
+
+ /* 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;
+ }
+
+ /* 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.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)) {
+ BNXT_TF_DBG(ERR, "Error in adding flow res for fid %x\n",
+ parms->fid);
+ return -1;
+ }
+
+ /* check of the flow has internal counter accumulation enabled */
+ if (!ulp_flow_db_resource_params_get(parms->ulp_ctx,
+ BNXT_ULP_FDB_TYPE_REGULAR,
+ parms->fid,
+ BNXT_ULP_RESOURCE_FUNC_INDEX_TABLE,
+ sub_typ,
+ &res_params)) {
+ /* Enable the counter accumulation in parent entry */
+ if (ulp_flow_db_parent_flow_count_accum_set(parms->ulp_ctx,
+ fid_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;
+}
+
+/*
+ * Create child flow in the parent flow tbl
+ *
+ * parms [in] Ptr to mapper params
+ *
+ * Returns 0 on success and negative on failure.
+ */
+int32_t
+ulp_flow_db_child_flow_create(struct bnxt_ulp_mapper_parms *parms)
+{
+ struct ulp_flow_db_res_params fid_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;
+
+ /* 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);
+ if (rc) {
+ BNXT_TF_DBG(ERR, "Error in setting child fid %x\n", parms->fid);
+ return rc;
+ }
+
+ /* 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.critical_resource = BNXT_ULP_CRITICAL_RESOURCE_NO;
+ rc = ulp_flow_db_resource_add(parms->ulp_ctx,
+ BNXT_ULP_FDB_TYPE_REGULAR,
+ parms->fid, &fid_parms);
+ if (rc) {
+ BNXT_TF_DBG(ERR, "Error in adding flow res for fid %x\n",
+ parms->fid);
+ 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);
+ 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;
+ }
+ }
+ }
+ /* return success */
+ return 0;
+}
+
+/*
+ * Update the parent counters
+ *
+ * ulp_ctxt [in] Ptr to ulp_context
+ * parent_fid [in] The flow id of the parent flow entry
+ * packet_count [in] - packet count
+ * byte_count [in] - byte count
+ *
+ * returns 0 on success
+ */
+int32_t
+ulp_flow_db_parent_flow_count_update(struct bnxt_ulp_context *ulp_ctxt,
+ uint32_t parent_fid,
+ 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;
+
+ /* 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) {
+ p_pdb->parent_flow_tbl[idx].pkt_count +=
+ packet_count;
+ p_pdb->parent_flow_tbl[idx].byte_count +=
+ byte_count;
+ }
+ return 0;
+ }
+ }
+ return -ENOENT;
+}
+
+/*
+ * Get the parent accumulation counters
+ *
+ * ulp_ctxt [in] Ptr to ulp_context
+ * parent_fid [in] The flow id of the parent flow entry
+ * packet_count [out] - packet count
+ * byte_count [out] - byte count
+ *
+ * returns 0 on success
+ */
+int32_t
+ulp_flow_db_parent_flow_count_get(struct bnxt_ulp_context *ulp_ctxt,
+ uint32_t parent_fid, 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;
+
+ /* 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) {
+ *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;
+ }
+ }
+ return -ENOENT;
+}
+
+/*
+ * reset the parent accumulation counters
+ *
+ * ulp_ctxt [in] Ptr to ulp_context
+ *
+ * returns none
+ */
+void
+ulp_flow_db_parent_flow_count_reset(struct bnxt_ulp_context *ulp_ctxt)
+{
+ 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, 1);
+ if (!flow_db) {
+ BNXT_TF_DBG(ERR, "parent child db validation failed\n");
+ return;
+ }
+
+ 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 &&
+ 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;
+ }
+ }
+}
+
+/*
+ * Set the shared bit for the flow db entry
+ *
+ * res [in] Ptr to fdb entry
+ * shared [in] shared flag
+ *
+ * returns none
+ */
+void ulp_flow_db_shared_session_set(struct ulp_flow_db_res_params *res,
+ enum bnxt_ulp_shared_session shared)
+{
+ if (res && (shared & BNXT_ULP_SHARED_SESSION_YES))
+ res->fdb_flags |= ULP_FDB_FLAG_SHARED_SESSION;
+}