X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=drivers%2Fnet%2Fbnxt%2Ftf_ulp%2Fulp_flow_db.c;h=35a7f868a9e6f1e37a8c4c4890c65f09a79bfa6c;hb=ac2df046a0cabd68e520fafbeaccd35e3e1b86ef;hp=6e73f25042f32480259143c36a47d0ed6d7bc340;hpb=696843cc62ab8f67eebf3447db658c97cc6ddc5e;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 6e73f25042..35a7f868a9 100644 --- a/drivers/net/bnxt/tf_ulp/ulp_flow_db.c +++ b/drivers/net/bnxt/tf_ulp/ulp_flow_db.c @@ -22,6 +22,32 @@ ULP_FLOW_DB_RES_NXT_MASK); } #define ULP_FLOW_DB_RES_NXT_RESET(dst) ((dst) &= ~(ULP_FLOW_DB_RES_NXT_MASK)) +/* + * Helper function to set the bit in the active flow table + * No validation is done in this function. + * + * flow_tbl [in] Ptr to flow table + * idx [in] The index to bit to be set or reset. + * flag [in] 1 to set and 0 to reset. + * + * returns none + */ +static void +ulp_flow_db_active_flow_set(struct bnxt_ulp_flow_tbl *flow_tbl, + uint32_t idx, + uint32_t flag) +{ + uint32_t active_index; + + active_index = idx / ULP_INDEX_BITMAP_SIZE; + if (flag) + ULP_INDEX_BITMAP_SET(flow_tbl->active_flow_tbl[active_index], + idx); + else + ULP_INDEX_BITMAP_RESET(flow_tbl->active_flow_tbl[active_index], + idx); +} + /* * Helper function to allocate the flow table and initialize * is set.No validation being done in this function. @@ -70,6 +96,35 @@ ulp_flow_db_res_params_to_info(struct ulp_fdb_resource_info *resource_info, } } +/* + * Helper function to copy the resource params to resource info + * No validation being done in this function. + * + * resource_info [in] Ptr to resource information + * params [out] The output params to the caller + * + * returns none + */ +static void +ulp_flow_db_res_info_to_params(struct ulp_fdb_resource_info *resource_info, + struct ulp_flow_db_res_params *params) +{ + memset(params, 0, sizeof(struct ulp_flow_db_res_params)); + params->direction = ((resource_info->nxt_resource_idx & + ULP_FLOW_DB_RES_DIR_MASK) >> + ULP_FLOW_DB_RES_DIR_BIT); + params->resource_func = ((resource_info->nxt_resource_idx & + ULP_FLOW_DB_RES_FUNC_MASK) >> + ULP_FLOW_DB_RES_FUNC_BITS); + + if (params->resource_func != BNXT_ULP_RESOURCE_FUNC_EM_TABLE) { + params->resource_hndl = resource_info->resource_hndl; + params->resource_type = resource_info->resource_type; + } else { + params->resource_hndl = resource_info->resource_em_handle; + } +} + /* * Helper function to allocate the flow table and initialize * the stack for allocation operations. @@ -122,7 +177,7 @@ ulp_flow_db_alloc_resource(struct bnxt_ulp_flow_db *flow_db, } /* - * Helper function to de allocate the flow table. + * Helper function to deallocate the flow table. * * flow_db [in] Ptr to flow database structure * tbl_idx [in] The index to table creation. @@ -154,6 +209,27 @@ ulp_flow_db_dealloc_resource(struct bnxt_ulp_flow_db *flow_db, } } +/* + * Helper function to add function id to the flow table + * + * flow_db [in] Ptr to flow table + * flow_id [in] The flow id of the flow + * func_id [in] The func_id to be set, for reset pass zero + * + * returns none + */ +static void +ulp_flow_db_func_id_set(struct bnxt_ulp_flow_db *flow_db, + uint32_t flow_id, + uint32_t func_id) +{ + /* set the function id in the function table */ + if (flow_id < flow_db->func_id_tbl_size) + flow_db->func_id_tbl[flow_id] = func_id; + else /* This should never happen */ + BNXT_TF_DBG(ERR, "Invalid flow id, flowdb corrupt\n"); +} + /* * Initialize the flow database. Memory is allocated in this * call and assigned to the flow database. @@ -186,7 +262,7 @@ int32_t ulp_flow_db_init(struct bnxt_ulp_context *ulp_ctxt) if (!flow_db) { BNXT_TF_DBG(ERR, "Failed to allocate memory for flow table ptr\n"); - goto error_free; + return -ENOMEM; } /* Attach the flow database to the ulp context. */ @@ -210,6 +286,17 @@ int32_t ulp_flow_db_init(struct bnxt_ulp_context *ulp_ctxt) if (ulp_flow_db_alloc_resource(flow_db, BNXT_ULP_DEFAULT_FLOW_TABLE)) goto error_free; + /* add 1 since we are not using index 0 for flow id */ + flow_db->func_id_tbl_size = dparms->num_flows + 1; + /* Allocate the function Id table */ + flow_db->func_id_tbl = rte_zmalloc("bnxt_ulp_flow_db_func_id_table", + flow_db->func_id_tbl_size * + sizeof(uint16_t), 0); + if (!flow_db->func_id_tbl) { + BNXT_TF_DBG(ERR, + "Failed to allocate mem for flow table func id\n"); + goto error_free; + } /* All good so return. */ return 0; error_free: @@ -242,11 +329,58 @@ int32_t ulp_flow_db_deinit(struct bnxt_ulp_context *ulp_ctxt) /* Free up all the memory. */ ulp_flow_db_dealloc_resource(flow_db, BNXT_ULP_REGULAR_FLOW_TABLE); ulp_flow_db_dealloc_resource(flow_db, BNXT_ULP_DEFAULT_FLOW_TABLE); + rte_free(flow_db->func_id_tbl); rte_free(flow_db); return 0; } +/* + * Allocate the flow database entry + * + * ulp_ctxt [in] Ptr to ulp_context + * tbl_idx [in] Specify it is regular or default flow + * fid [out] The index to the flow entry + * + * returns 0 on success and negative on failure. + */ +int32_t ulp_flow_db_fid_alloc(struct bnxt_ulp_context *ulp_ctxt, + enum bnxt_ulp_flow_db_tables tbl_idx, + uint16_t func_id, + uint32_t *fid) +{ + struct bnxt_ulp_flow_db *flow_db; + struct bnxt_ulp_flow_tbl *flow_tbl; + + *fid = 0; /* Initialize fid to invalid value */ + 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[tbl_idx]; + /* check for max flows */ + if (flow_tbl->num_flows <= flow_tbl->head_index) { + BNXT_TF_DBG(ERR, "Flow database has reached max flows\n"); + return -ENOMEM; + } + if (flow_tbl->tail_index <= (flow_tbl->head_index + 1)) { + BNXT_TF_DBG(ERR, "Flow database has reached max resources\n"); + return -ENOMEM; + } + *fid = flow_tbl->flow_tbl_stack[flow_tbl->head_index]; + flow_tbl->head_index++; + ulp_flow_db_active_flow_set(flow_tbl, *fid, 1); + + /* The function id update is only valid for regular flow table */ + if (tbl_idx == BNXT_ULP_REGULAR_FLOW_TABLE) + ulp_flow_db_func_id_set(flow_db, *fid, func_id); + + /* all good, return success */ + return 0; +} + /* * Allocate the flow database entry. * The params->critical_resource has to be set to 0 to allocate a new resource. @@ -293,7 +427,7 @@ int32_t ulp_flow_db_resource_add(struct bnxt_ulp_context *ulp_ctxt, } /* check for max resource */ - if ((flow_tbl->num_flows + 1) >= flow_tbl->tail_index) { + if ((flow_tbl->head_index + 1) >= flow_tbl->tail_index) { BNXT_TF_DBG(ERR, "Flow db has reached max resources\n"); return -ENOMEM; } @@ -321,3 +455,373 @@ int32_t ulp_flow_db_resource_add(struct bnxt_ulp_context *ulp_ctxt, /* all good, return success */ return 0; } + +/* + * Free the flow database entry. + * The params->critical_resource has to be set to 1 to free the first resource. + * + * ulp_ctxt [in] Ptr to ulp_context + * tbl_idx [in] Specify it is regular or default flow + * fid [in] The index to the flow entry + * params [in/out] The contents to be copied into params. + * Onlythe critical_resource needs to be set by the caller. + * + * Returns 0 on success and negative on failure. + */ +int32_t ulp_flow_db_resource_del(struct bnxt_ulp_context *ulp_ctxt, + enum bnxt_ulp_flow_db_tables tbl_idx, + uint32_t fid, + 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 *nxt_resource, *fid_resource; + uint32_t nxt_idx = 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 (tbl_idx >= BNXT_ULP_FLOW_TABLE_MAX) { + BNXT_TF_DBG(ERR, "Invalid table index\n"); + return -EINVAL; + } + flow_tbl = &flow_db->flow_tbl[tbl_idx]; + + /* check for max flows */ + if (fid >= flow_tbl->num_flows || !fid) { + BNXT_TF_DBG(ERR, "Invalid flow index\n"); + return -EINVAL; + } + + /* check if the flow is active or not */ + if (!ulp_flow_db_active_flow_is_set(flow_tbl, fid)) { + BNXT_TF_DBG(ERR, "flow does not exist\n"); + return -EINVAL; + } + + fid_resource = &flow_tbl->flow_resources[fid]; + if (!params->critical_resource) { + /* Not the critical resource so free the resource */ + ULP_FLOW_DB_RES_NXT_SET(nxt_idx, + fid_resource->nxt_resource_idx); + if (!nxt_idx) { + /* reached end of resources */ + return -ENOENT; + } + nxt_resource = &flow_tbl->flow_resources[nxt_idx]; + + /* connect the fid resource to the next resource */ + ULP_FLOW_DB_RES_NXT_RESET(fid_resource->nxt_resource_idx); + ULP_FLOW_DB_RES_NXT_SET(fid_resource->nxt_resource_idx, + nxt_resource->nxt_resource_idx); + + /* update the contents to be given to caller */ + ulp_flow_db_res_info_to_params(nxt_resource, params); + + /* Delete the nxt_resource */ + memset(nxt_resource, 0, sizeof(struct ulp_fdb_resource_info)); + + /* add it to the free list */ + flow_tbl->tail_index++; + if (flow_tbl->tail_index >= flow_tbl->num_resources) { + BNXT_TF_DBG(ERR, "FlowDB:Tail reached max\n"); + return -ENOENT; + } + flow_tbl->flow_tbl_stack[flow_tbl->tail_index] = nxt_idx; + + } else { + /* Critical resource. copy the contents and exit */ + ulp_flow_db_res_info_to_params(fid_resource, params); + ULP_FLOW_DB_RES_NXT_SET(nxt_idx, + fid_resource->nxt_resource_idx); + memset(fid_resource, 0, sizeof(struct ulp_fdb_resource_info)); + ULP_FLOW_DB_RES_NXT_SET(fid_resource->nxt_resource_idx, + nxt_idx); + } + + /* all good, return success */ + return 0; +} + +/* + * Free the flow database entry + * + * ulp_ctxt [in] Ptr to ulp_context + * tbl_idx [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_fid_free(struct bnxt_ulp_context *ulp_ctxt, + enum bnxt_ulp_flow_db_tables tbl_idx, + uint32_t fid) +{ + struct bnxt_ulp_flow_db *flow_db; + struct bnxt_ulp_flow_tbl *flow_tbl; + + flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctxt); + if (!flow_db) { + BNXT_TF_DBG(ERR, "Invalid Arguments\n"); + return -EINVAL; + } + + if (tbl_idx >= BNXT_ULP_FLOW_TABLE_MAX) { + BNXT_TF_DBG(ERR, "Invalid table index\n"); + return -EINVAL; + } + + flow_tbl = &flow_db->flow_tbl[tbl_idx]; + + /* check for limits of fid */ + if (fid >= flow_tbl->num_flows || !fid) { + BNXT_TF_DBG(ERR, "Invalid flow index\n"); + return -EINVAL; + } + + /* check if the flow is active or not */ + if (!ulp_flow_db_active_flow_is_set(flow_tbl, fid)) { + BNXT_TF_DBG(ERR, "flow does not exist\n"); + return -EINVAL; + } + flow_tbl->head_index--; + if (!flow_tbl->head_index) { + BNXT_TF_DBG(ERR, "FlowDB: Head Ptr is zero\n"); + return -ENOENT; + } + flow_tbl->flow_tbl_stack[flow_tbl->head_index] = fid; + ulp_flow_db_active_flow_set(flow_tbl, fid, 0); + if (tbl_idx == BNXT_ULP_REGULAR_FLOW_TABLE) + ulp_flow_db_func_id_set(flow_db, fid, 0); + + /* all good, return success */ + return 0; +} + +/* + * Get the flow database entry details + * + * ulp_ctxt [in] Ptr to ulp_context + * tbl_idx [in] Specify it is regular or default flow + * fid [in] The index to the flow entry + * nxt_idx [in/out] the index to the next entry + * params [out] The contents to be copied into params. + * + * returns 0 on success and negative on failure. + */ +int32_t ulp_flow_db_resource_get(struct bnxt_ulp_context *ulp_ctxt, + enum bnxt_ulp_flow_db_tables tbl_idx, + uint32_t fid, + uint32_t *nxt_idx, + 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 *nxt_resource, *fid_resource; + + flow_db = bnxt_ulp_cntxt_ptr2_flow_db_get(ulp_ctxt); + if (!flow_db) { + BNXT_TF_DBG(ERR, "Invalid Arguments\n"); + return -EINVAL; + } + + if (tbl_idx >= BNXT_ULP_FLOW_TABLE_MAX) { + BNXT_TF_DBG(ERR, "Invalid table index\n"); + return -EINVAL; + } + + flow_tbl = &flow_db->flow_tbl[tbl_idx]; + + /* check for limits of fid */ + if (fid >= flow_tbl->num_flows || !fid) { + BNXT_TF_DBG(ERR, "Invalid flow index\n"); + return -EINVAL; + } + + /* check if the flow is active or not */ + if (!ulp_flow_db_active_flow_is_set(flow_tbl, fid)) { + BNXT_TF_DBG(ERR, "flow does not exist\n"); + return -EINVAL; + } + + if (!*nxt_idx) { + fid_resource = &flow_tbl->flow_resources[fid]; + ulp_flow_db_res_info_to_params(fid_resource, params); + ULP_FLOW_DB_RES_NXT_SET(*nxt_idx, + fid_resource->nxt_resource_idx); + } else { + nxt_resource = &flow_tbl->flow_resources[*nxt_idx]; + ulp_flow_db_res_info_to_params(nxt_resource, params); + *nxt_idx = 0; + ULP_FLOW_DB_RES_NXT_SET(*nxt_idx, + nxt_resource->nxt_resource_idx); + } + + /* all good, return success */ + return 0; +} + +/* + * Get the flow database entry iteratively + * + * flow_tbl [in] Ptr to flow table + * fid [in/out] The index to the flow entry + * + * returns 0 on success and negative on failure. + */ +static int32_t +ulp_flow_db_next_entry_get(struct bnxt_ulp_flow_tbl *flowtbl, + uint32_t *fid) +{ + uint32_t lfid = *fid; + uint32_t idx, s_idx, mod_fid; + uint64_t bs; + + do { + /* increment the flow id to find the next valid flow id */ + lfid++; + if (lfid >= flowtbl->num_flows) + return -ENOENT; + idx = lfid / ULP_INDEX_BITMAP_SIZE; + mod_fid = lfid % ULP_INDEX_BITMAP_SIZE; + s_idx = idx; + while (!(bs = flowtbl->active_flow_tbl[idx])) { + idx++; + if ((idx * ULP_INDEX_BITMAP_SIZE) >= flowtbl->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); + lfid = (idx * ULP_INDEX_BITMAP_SIZE) + __builtin_clzl(bs); + if (*fid >= lfid) { + BNXT_TF_DBG(ERR, "Flow Database is corrupt\n"); + return -ENOENT; + } + } while (!ulp_flow_db_active_flow_is_set(flowtbl, lfid)); + + /* all good, return success */ + *fid = lfid; + return 0; +} + +/* + * Flush all flows in the flow database. + * + * ulp_ctxt [in] Ptr to ulp context + * tbl_idx [in] The index to table + * + * returns 0 on success or negative number on failure + */ +int32_t ulp_flow_db_flush_flows(struct bnxt_ulp_context *ulp_ctx, + uint32_t idx) +{ + uint32_t fid = 0; + struct bnxt_ulp_flow_db *flow_db; + struct bnxt_ulp_flow_tbl *flow_tbl; + + if (!ulp_ctx) { + 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; + } + flow_tbl = &flow_db->flow_tbl[idx]; + while (!ulp_flow_db_next_entry_get(flow_tbl, &fid)) + ulp_mapper_resources_free(ulp_ctx, fid, idx); + + return 0; +} + +/* + * Flush all flows in the flow database that belong to a device function. + * + * ulp_ctxt [in] Ptr to ulp context + * tbl_idx [in] The index to table + * + * 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; + struct bnxt_ulp_flow_tbl *flow_tbl; + + 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; + } + flow_tbl = &flow_db->flow_tbl[BNXT_ULP_REGULAR_FLOW_TABLE]; + while (!ulp_flow_db_next_entry_get(flow_tbl, &flow_id)) { + if (flow_db->func_id_tbl[flow_id] == func_id) + ulp_mapper_resources_free(ulp_ctx, flow_id, + BNXT_ULP_REGULAR_FLOW_TABLE); + } + + 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_REGULAR_FLOW_TABLE); +} + +/* + * 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; +}