#include <rte_flow.h>
#include <rte_flow_driver.h>
#include <rte_tailq.h>
+#include <rte_spinlock.h>
#include "bnxt.h"
#include "bnxt_ulp.h"
#include "ulp_mapper.h"
#include "ulp_port_db.h"
#include "ulp_tun.h"
+#include "ulp_ha_mgr.h"
+#include "bnxt_tf_pmd_shim.h"
/* Linked list of all TF sessions. */
STAILQ_HEAD(, bnxt_ulp_session_state) bnxt_ulp_session_list =
/* Mutex to synchronize bnxt_ulp_session_list operations. */
static pthread_mutex_t bnxt_ulp_global_mutex = PTHREAD_MUTEX_INITIALIZER;
+/* Spin lock to protect context global list */
+rte_spinlock_t bnxt_ulp_ctxt_lock;
+TAILQ_HEAD(cntx_list_entry_list, ulp_context_list_entry);
+static struct cntx_list_entry_list ulp_cntx_list =
+ TAILQ_HEAD_INITIALIZER(ulp_cntx_list);
+
+/* Static function declarations */
+static int32_t bnxt_ulp_cntxt_list_init(void);
+static int32_t bnxt_ulp_cntxt_list_add(struct bnxt_ulp_context *ulp_ctx);
+static void bnxt_ulp_cntxt_list_del(struct bnxt_ulp_context *ulp_ctx);
+
/*
* Allow the deletion of context only for the bnxt device that
* created the session.
enum bnxt_ulp_device_id *ulp_dev_id)
{
if (BNXT_CHIP_P5(bp)) {
- /* TBD: needs to accommodate even SR2 */
*ulp_dev_id = BNXT_ULP_DEVICE_ID_THOR;
return 0;
}
return ulp_app_cap_info_list;
}
+static struct bnxt_ulp_resource_resv_info *
+bnxt_ulp_app_resource_resv_list_get(uint32_t *num_entries)
+{
+ if (num_entries == NULL)
+ return NULL;
+ *num_entries = BNXT_ULP_APP_RESOURCE_RESV_LIST_MAX_SZ;
+ return ulp_app_resource_resv_list;
+}
+
struct bnxt_ulp_resource_resv_info *
bnxt_ulp_resource_resv_list_get(uint32_t *num_entries)
{
}
static int32_t
-bnxt_ulp_tf_resources_get(struct bnxt_ulp_context *ulp_ctx,
- struct tf_session_resources *res)
+bnxt_ulp_named_resources_calc(struct bnxt_ulp_context *ulp_ctx,
+ struct bnxt_ulp_glb_resource_info *info,
+ uint32_t num,
+ struct tf_session_resources *res)
{
- struct bnxt_ulp_resource_resv_info *info = NULL;
- uint32_t dev_id, res_type, i, num;
+ uint32_t dev_id = BNXT_ULP_DEVICE_ID_LAST, res_type, i;
enum tf_dir dir;
uint8_t app_id;
int32_t rc = 0;
- if (!ulp_ctx || !res) {
- BNXT_TF_DBG(ERR, "Invalid arguments to get resources.\n");
- return -EINVAL;
- }
-
- info = bnxt_ulp_resource_resv_list_get(&num);
- if (!info) {
- BNXT_TF_DBG(ERR, "Unable to get resource reservation list.\n");
+ if (ulp_ctx == NULL || info == NULL || res == NULL || num == 0) {
+ BNXT_TF_DBG(ERR, "Invalid parms to named resources calc.\n");
return -EINVAL;
}
rc = bnxt_ulp_cntxt_dev_id_get(ulp_ctx, &dev_id);
if (rc) {
- BNXT_TF_DBG(ERR, "Unable to get the device id from ulp.\n");
+ BNXT_TF_DBG(ERR, "Unable to get the dev id from ulp.\n");
return -EINVAL;
}
for (i = 0; i < num; i++) {
- if (app_id != info[i].app_id || dev_id != info[i].device_id)
+ if (dev_id != info[i].device_id || app_id != info[i].app_id)
continue;
dir = info[i].direction;
res_type = info[i].resource_type;
switch (info[i].resource_func) {
case BNXT_ULP_RESOURCE_FUNC_IDENTIFIER:
- res->ident_cnt[dir].cnt[res_type] = info[i].count;
+ res->ident_cnt[dir].cnt[res_type]++;
break;
case BNXT_ULP_RESOURCE_FUNC_INDEX_TABLE:
- res->tbl_cnt[dir].cnt[res_type] = info[i].count;
+ res->tbl_cnt[dir].cnt[res_type]++;
break;
case BNXT_ULP_RESOURCE_FUNC_TCAM_TABLE:
- res->tcam_cnt[dir].cnt[res_type] = info[i].count;
+ res->tcam_cnt[dir].cnt[res_type]++;
break;
case BNXT_ULP_RESOURCE_FUNC_EM_TABLE:
- res->em_cnt[dir].cnt[res_type] = info[i].count;
+ res->em_cnt[dir].cnt[res_type]++;
break;
default:
- break;
+ BNXT_TF_DBG(ERR, "Unknown resource func (0x%x)\n,",
+ info[i].resource_func);
+ continue;
}
}
}
static int32_t
-bnxt_ulp_tf_shared_session_resources_get(struct bnxt_ulp_context *ulp_ctx,
- struct tf_session_resources *res)
+bnxt_ulp_unnamed_resources_calc(struct bnxt_ulp_context *ulp_ctx,
+ struct bnxt_ulp_resource_resv_info *info,
+ uint32_t num,
+ struct tf_session_resources *res)
{
- struct bnxt_ulp_glb_resource_info *info;
- uint32_t dev_id, res_type, i, num;
+ uint32_t dev_id, res_type, i;
enum tf_dir dir;
uint8_t app_id;
- int32_t rc;
+ int32_t rc = 0;
+
+ if (ulp_ctx == NULL || res == NULL || info == NULL || num == 0) {
+ BNXT_TF_DBG(ERR, "Invalid arguments to get resources.\n");
+ return -EINVAL;
+ }
rc = bnxt_ulp_cntxt_app_id_get(ulp_ctx, &app_id);
if (rc) {
rc = bnxt_ulp_cntxt_dev_id_get(ulp_ctx, &dev_id);
if (rc) {
- BNXT_TF_DBG(ERR, "Unable to get device id from ulp.\n");
+ BNXT_TF_DBG(ERR, "Unable to get the dev id from ulp.\n");
return -EINVAL;
}
- /* Make sure the resources are zero before accumulating. */
- memset(res, 0, sizeof(struct tf_session_resources));
-
- /* Get the list and tally the resources. */
- info = bnxt_ulp_app_glb_resource_info_list_get(&num);
- if (!info) {
- BNXT_TF_DBG(ERR, "Unable to get app global resource list\n");
- return -EINVAL;
- }
for (i = 0; i < num; i++) {
- if (dev_id != info[i].device_id || app_id != info[i].app_id)
+ if (app_id != info[i].app_id || dev_id != info[i].device_id)
continue;
dir = info[i].direction;
res_type = info[i].resource_type;
switch (info[i].resource_func) {
case BNXT_ULP_RESOURCE_FUNC_IDENTIFIER:
- res->ident_cnt[dir].cnt[res_type]++;
+ res->ident_cnt[dir].cnt[res_type] = info[i].count;
break;
case BNXT_ULP_RESOURCE_FUNC_INDEX_TABLE:
- res->tbl_cnt[dir].cnt[res_type]++;
+ res->tbl_cnt[dir].cnt[res_type] = info[i].count;
break;
case BNXT_ULP_RESOURCE_FUNC_TCAM_TABLE:
- res->tcam_cnt[dir].cnt[res_type]++;
+ res->tcam_cnt[dir].cnt[res_type] = info[i].count;
break;
case BNXT_ULP_RESOURCE_FUNC_EM_TABLE:
- res->em_cnt[dir].cnt[res_type]++;
+ res->em_cnt[dir].cnt[res_type] = info[i].count;
break;
default:
- BNXT_TF_DBG(ERR, "Unknown resource func (0x%x)\n,",
- info[i].resource_func);
- continue;
+ break;
}
}
-
return 0;
}
+static int32_t
+bnxt_ulp_tf_resources_get(struct bnxt_ulp_context *ulp_ctx,
+ struct tf_session_resources *res)
+{
+ struct bnxt_ulp_resource_resv_info *unnamed = NULL;
+ uint32_t unum;
+ int32_t rc = 0;
+
+ if (ulp_ctx == NULL || res == NULL) {
+ BNXT_TF_DBG(ERR, "Invalid arguments to get resources.\n");
+ return -EINVAL;
+ }
+
+ unnamed = bnxt_ulp_resource_resv_list_get(&unum);
+ if (unnamed == NULL) {
+ BNXT_TF_DBG(ERR, "Unable to get resource resv list.\n");
+ return -EINVAL;
+ }
+
+ rc = bnxt_ulp_unnamed_resources_calc(ulp_ctx, unnamed, unum, res);
+ if (rc)
+ BNXT_TF_DBG(ERR, "Unable to calc resources for session.\n");
+
+ return rc;
+}
+
+static int32_t
+bnxt_ulp_tf_shared_session_resources_get(struct bnxt_ulp_context *ulp_ctx,
+ struct tf_session_resources *res)
+{
+ struct bnxt_ulp_resource_resv_info *unnamed;
+ struct bnxt_ulp_glb_resource_info *named;
+ uint32_t unum, nnum;
+ int32_t rc;
+
+ if (ulp_ctx == NULL || res == NULL) {
+ BNXT_TF_DBG(ERR, "Invalid arguments to get resources.\n");
+ return -EINVAL;
+ }
+
+ /* Make sure the resources are zero before accumulating. */
+ memset(res, 0, sizeof(struct tf_session_resources));
+
+ /*
+ * Shared resources are comprised of both named and unnamed resources.
+ * First get the unnamed counts, and then add the named to the result.
+ */
+ /* Get the baseline counts */
+ unnamed = bnxt_ulp_app_resource_resv_list_get(&unum);
+ if (unnamed == NULL) {
+ BNXT_TF_DBG(ERR, "Unable to get shared resource resv list.\n");
+ return -EINVAL;
+ }
+ rc = bnxt_ulp_unnamed_resources_calc(ulp_ctx, unnamed, unum, res);
+ if (rc) {
+ BNXT_TF_DBG(ERR, "Unable to calc resources for shared session.\n");
+ return -EINVAL;
+ }
+
+ /* Get the named list and add the totals */
+ named = bnxt_ulp_app_glb_resource_info_list_get(&nnum);
+ if (named == NULL) {
+ BNXT_TF_DBG(ERR, "Unable to get app global resource list\n");
+ return -EINVAL;
+ }
+ rc = bnxt_ulp_named_resources_calc(ulp_ctx, named, nnum, res);
+ if (rc)
+ BNXT_TF_DBG(ERR, "Unable to calc named resources\n");
+
+ return rc;
+}
+
int32_t
bnxt_ulp_cntxt_app_caps_init(struct bnxt_ulp_context *ulp_ctx,
uint8_t app_id, uint32_t dev_id)
if (info[i].flags & BNXT_ULP_APP_CAP_SHARED_EN)
ulp_ctx->cfg_data->ulp_flags |=
BNXT_ULP_SHARED_SESSION_ENABLED;
+ if (info[i].flags & BNXT_ULP_APP_CAP_HOT_UPGRADE_EN)
+ ulp_ctx->cfg_data->ulp_flags |=
+ BNXT_ULP_HIGH_AVAIL_ENABLED;
+ if (info[i].flags & BNXT_ULP_APP_CAP_UNICAST_ONLY)
+ ulp_ctx->cfg_data->ulp_flags |=
+ BNXT_ULP_APP_UNICAST_ONLY;
}
if (!found) {
BNXT_TF_DBG(ERR, "APP ID %d, Device ID: 0x%x not supported.\n",
struct rte_eth_dev *ethdev = bp->eth_dev;
struct tf_session_resources *resources;
struct tf_open_session_parms parms;
- size_t copy_num_bytes;
- uint32_t ulp_dev_id;
+ size_t copy_nbytes;
+ uint32_t ulp_dev_id = BNXT_ULP_DEVICE_ID_LAST;
int32_t rc = 0;
+ uint8_t app_id;
/* only perform this if shared session is enabled. */
if (!bnxt_ulp_cntxt_shared_session_enabled(bp->ulp_ctx))
* Need to account for size of ctrl_chan_name and 1 extra for Null
* terminator
*/
- copy_num_bytes = sizeof(parms.ctrl_chan_name) -
+ copy_nbytes = sizeof(parms.ctrl_chan_name) -
strlen(parms.ctrl_chan_name) - 1;
- /* Build the ctrl_chan_name with shared token */
- strncat(parms.ctrl_chan_name, "-tf_shared", copy_num_bytes);
+ /*
+ * Build the ctrl_chan_name with shared token.
+ * When HA is enabled, the WC TCAM needs extra management by the core,
+ * so add the wc_tcam string to the control channel.
+ */
+ if (bnxt_ulp_cntxt_ha_enabled(bp->ulp_ctx))
+ strncat(parms.ctrl_chan_name, "-tf_shared-wc_tcam",
+ copy_nbytes);
+ else
+ strncat(parms.ctrl_chan_name, "-tf_shared", copy_nbytes);
rc = bnxt_ulp_tf_shared_session_resources_get(bp->ulp_ctx, resources);
- if (rc) {
- BNXT_TF_DBG(ERR, "Unable to get shared resource count.\n");
+ if (rc)
return rc;
+
+ rc = bnxt_ulp_cntxt_app_id_get(bp->ulp_ctx, &app_id);
+ if (rc) {
+ BNXT_TF_DBG(ERR, "Unable to get the app id from ulp.\n");
+ return -EINVAL;
}
rc = bnxt_ulp_cntxt_dev_id_get(bp->ulp_ctx, &ulp_dev_id);
parms.device_type = TF_DEVICE_TYPE_THOR;
break;
default:
- BNXT_TF_DBG(ERR, "Unable to determine device for "
- "opening session.\n");
+ BNXT_TF_DBG(ERR, "Unable to determine dev for opening session.\n");
return rc;
}
parms.shadow_copy = true;
parms.bp = bp;
+ if (app_id == 0 || app_id == 3)
+ parms.wc_num_slices = TF_WC_TCAM_2_SLICE_PER_ROW;
+ else
+ parms.wc_num_slices = TF_WC_TCAM_1_SLICE_PER_ROW;
/*
* Open the session here, but the collect the resources during the
int32_t rc = 0;
struct tf_open_session_parms params;
struct tf_session_resources *resources;
- uint32_t ulp_dev_id;
+ uint32_t ulp_dev_id = BNXT_ULP_DEVICE_ID_LAST;
+ uint8_t app_id;
memset(¶ms, 0, sizeof(params));
params.shadow_copy = true;
+ rc = bnxt_ulp_cntxt_app_id_get(bp->ulp_ctx, &app_id);
+ if (rc) {
+ BNXT_TF_DBG(ERR, "Unable to get the app id from ulp.\n");
+ return -EINVAL;
+ }
+
rc = bnxt_ulp_cntxt_dev_id_get(bp->ulp_ctx, &ulp_dev_id);
if (rc) {
BNXT_TF_DBG(ERR, "Unable to get device id from ulp.\n");
params.device_type = TF_DEVICE_TYPE_THOR;
break;
default:
- BNXT_TF_DBG(ERR, "Unable to determine device for "
- "opening session.\n");
+ BNXT_TF_DBG(ERR, "Unable to determine device for opening session.\n");
return rc;
}
resources = ¶ms.resources;
rc = bnxt_ulp_tf_resources_get(bp->ulp_ctx, resources);
- if (rc) {
- BNXT_TF_DBG(ERR, "Unable to determine tf resources for "
- "session open.\n");
+ if (rc)
return rc;
- }
params.bp = bp;
+ if (app_id == 0 || app_id == 3)
+ params.wc_num_slices = TF_WC_TCAM_2_SLICE_PER_ROW;
+ else
+ params.wc_num_slices = TF_WC_TCAM_1_SLICE_PER_ROW;
+
rc = tf_open_session(&bp->tfp, ¶ms);
if (rc) {
BNXT_TF_DBG(ERR, "Failed to open TF session - %s, rc = %d\n",
if (!ulp_ctx || !ulp_ctx->cfg_data)
return -EINVAL;
- tfp = bnxt_ulp_cntxt_tfp_get(ulp_ctx);
+ tfp = bnxt_ulp_cntxt_tfp_get(ulp_ctx, BNXT_ULP_SHARED_SESSION_NO);
if (!tfp) {
BNXT_TF_DBG(ERR, "Failed to get the truflow pointer\n");
return -EINVAL;
int32_t rc = 0;
enum bnxt_ulp_device_id devid;
+ /* Initialize the context entries list */
+ bnxt_ulp_cntxt_list_init();
+
+ /* Add the context to the context entries list */
+ rc = bnxt_ulp_cntxt_list_add(bp->ulp_ctx);
+ if (rc) {
+ BNXT_TF_DBG(ERR, "Failed to add the context list entry\n");
+ return -ENOMEM;
+ }
+
/* Allocate memory to hold ulp context data. */
ulp_data = rte_zmalloc("bnxt_ulp_data",
sizeof(struct bnxt_ulp_data), 0);
BNXT_TF_DBG(ERR, "Unable to set app_id for ULP init.\n");
goto error_deinit;
}
+ BNXT_TF_DBG(DEBUG, "Ulp initialized with app id %d\n", bp->app_id);
rc = bnxt_ulp_cntxt_app_caps_init(bp->ulp_ctx, bp->app_id, devid);
if (rc) {
- BNXT_TF_DBG(ERR, "Unable to set capabilities for "
- " app(%x)/dev(%x)\n", bp->app_id, devid);
+ BNXT_TF_DBG(ERR, "Unable to set caps for app(%x)/dev(%x)\n",
+ bp->app_id, devid);
goto error_deinit;
}
if (rc)
goto error_deinit;
- ulp_tun_tbl_init(ulp_data->tun_tbl);
-
bnxt_ulp_cntxt_tfp_set(bp->ulp_ctx, &bp->tfp);
return rc;
ulp_dparms_init(struct bnxt *bp, struct bnxt_ulp_context *ulp_ctx)
{
struct bnxt_ulp_device_params *dparms;
- uint32_t dev_id;
+ uint32_t dev_id = BNXT_ULP_DEVICE_ID_LAST;
if (!bp->max_num_kflows) {
/* Defaults to Internal */
dparms->ext_flow_db_num_entries = bp->max_num_kflows * 1024;
/* GFID = 2 * num_flows */
dparms->mark_db_gfid_entries = dparms->ext_flow_db_num_entries * 2;
- BNXT_TF_DBG(DEBUG, "Set the number of flows = %"PRIu64"\n",
+ BNXT_TF_DBG(DEBUG, "Set the number of flows = %" PRIu64 "\n",
dparms->ext_flow_db_num_entries);
return 0;
struct bnxt_ulp_session_state *session)
{
int32_t rc = 0;
- uint32_t flags, dev_id;
+ uint32_t flags, dev_id = BNXT_ULP_DEVICE_ID_LAST;
uint8_t app_id;
/* Increment the ulp context data reference count usage. */
/* update the session details in bnxt tfp */
bp->tfp.session = session->g_tfp->session;
+ /* Add the context to the context entries list */
+ rc = bnxt_ulp_cntxt_list_add(bp->ulp_ctx);
+ if (rc) {
+ BNXT_TF_DBG(ERR, "Failed to add the context list entry\n");
+ return -EINVAL;
+ }
+
/*
* The supported flag will be set during the init. Use it now to
* know if we should go through the attach.
bnxt_ulp_deinit(struct bnxt *bp,
struct bnxt_ulp_session_state *session)
{
+ bool ha_enabled;
+
if (!bp->ulp_ctx || !bp->ulp_ctx->cfg_data)
return;
+ ha_enabled = bnxt_ulp_cntxt_ha_enabled(bp->ulp_ctx);
+ if (ha_enabled && session->session_opened) {
+ int32_t rc = ulp_ha_mgr_close(bp->ulp_ctx);
+ if (rc)
+ BNXT_TF_DBG(ERR, "Failed to close HA (%d)\n", rc);
+ }
+
/* clean up default flows */
bnxt_ulp_destroy_df_rules(bp, true);
/* free the flow db lock */
pthread_mutex_destroy(&bp->ulp_ctx->cfg_data->flow_db_lock);
+ if (ha_enabled)
+ ulp_ha_mgr_deinit(bp->ulp_ctx);
+
/* Delete the ulp context and tf session and free the ulp context */
ulp_ctx_deinit(bp, session);
BNXT_TF_DBG(DEBUG, "ulp ctx has been deinitialized\n");
BNXT_TF_DBG(ERR, "Failed to set tx global configuration\n");
goto jump_to_error;
}
+
+ if (bnxt_ulp_cntxt_ha_enabled(bp->ulp_ctx)) {
+ rc = ulp_ha_mgr_init(bp->ulp_ctx);
+ if (rc) {
+ BNXT_TF_DBG(ERR, "Failed to initialize HA %d\n", rc);
+ goto jump_to_error;
+ }
+ rc = ulp_ha_mgr_open(bp->ulp_ctx);
+ if (rc) {
+ BNXT_TF_DBG(ERR, "Failed to Process HA Open %d\n", rc);
+ goto jump_to_error;
+ }
+ }
BNXT_TF_DBG(DEBUG, "ulp ctx has been initialized\n");
return rc;
{
struct bnxt_ulp_session_state *session;
bool initialized;
+ enum bnxt_ulp_device_id devid = BNXT_ULP_DEVICE_ID_LAST;
+ uint32_t ulp_flags;
int32_t rc = 0;
- if (!bp || !BNXT_TRUFLOW_EN(bp))
- return rc;
-
if (!BNXT_PF(bp) && !BNXT_VF_IS_TRUSTED(bp)) {
BNXT_TF_DBG(ERR,
"Skip ulp init for port: %d, not a TVF or PF\n",
- bp->eth_dev->data->port_id);
+ bp->eth_dev->data->port_id);
+ return rc;
+ }
+
+ if (!BNXT_TRUFLOW_EN(bp)) {
+ BNXT_TF_DBG(ERR,
+ "Skip ulp init for port: %d, truflow is not enabled\n",
+ bp->eth_dev->data->port_id);
return rc;
}
goto jump_to_error;
}
- if (BNXT_ACCUM_STATS_EN(bp))
+ rc = bnxt_ulp_devid_get(bp, &devid);
+ if (rc) {
+ BNXT_TF_DBG(ERR, "Unable to determine device for ULP port init.\n");
+ goto jump_to_error;
+ }
+
+ if (devid != BNXT_ULP_DEVICE_ID_THOR && BNXT_ACCUM_STATS_EN(bp))
bp->ulp_ctx->cfg_data->accum_stats = true;
- BNXT_TF_DBG(DEBUG, "BNXT Port:%d ULP port init\n",
- bp->eth_dev->data->port_id);
+ BNXT_TF_DBG(DEBUG, "BNXT Port:%d ULP port init, accum_stats:%d\n",
+ bp->eth_dev->data->port_id,
+ bp->ulp_ctx->cfg_data->accum_stats);
+
+ /* set the unicast mode */
+ if (bnxt_ulp_cntxt_ptr2_ulp_flags_get(bp->ulp_ctx, &ulp_flags)) {
+ BNXT_TF_DBG(ERR, "Error in getting ULP context flags\n");
+ goto jump_to_error;
+ }
+ if (ulp_flags & BNXT_ULP_APP_UNICAST_ONLY) {
+ if (bnxt_pmd_set_unicast_rxmask(bp->eth_dev)) {
+ BNXT_TF_DBG(ERR, "Error in setting unicast rxmode\n");
+ goto jump_to_error;
+ }
+ }
+
return rc;
jump_to_error:
struct rte_pci_device *pci_dev;
struct rte_pci_addr *pci_addr;
- if (!BNXT_TRUFLOW_EN(bp))
- return;
-
if (!BNXT_PF(bp) && !BNXT_VF_IS_TRUSTED(bp)) {
BNXT_TF_DBG(ERR,
"Skip ULP deinit port:%d, not a TVF or PF\n",
return;
}
+ if (!BNXT_TRUFLOW_EN(bp)) {
+ BNXT_TF_DBG(ERR,
+ "Skip ULP deinit for port:%d, truflow is not enabled\n",
+ bp->eth_dev->data->port_id);
+ return;
+ }
+
if (!bp->ulp_ctx) {
BNXT_TF_DBG(DEBUG, "ulp ctx already de-allocated\n");
return;
BNXT_TF_DBG(DEBUG, "BNXT Port:%d ULP port deinit\n",
bp->eth_dev->data->port_id);
+ /* Free the ulp context in the context entry list */
+ bnxt_ulp_cntxt_list_del(bp->ulp_ctx);
+
/* Get the session details */
pci_dev = RTE_DEV_TO_PCI(bp->eth_dev->device);
pci_addr = &pci_dev->addr;
*dev_id = ulp_ctx->cfg_data->dev_id;
return 0;
}
-
+ *dev_id = BNXT_ULP_DEVICE_ID_LAST;
BNXT_TF_DBG(ERR, "Failed to read dev_id from ulp ctxt\n");
return -EINVAL;
}
*mem_type = ulp_ctx->cfg_data->mem_type;
return 0;
}
+ *mem_type = BNXT_ULP_FLOW_MEM_TYPE_LAST;
BNXT_TF_DBG(ERR, "Failed to read mem_type in ulp ctxt\n");
return -EINVAL;
}
return -EINVAL;
}
+ if (tfp == NULL) {
+ if (ulp->cfg_data->num_shared_clients > 0)
+ ulp->cfg_data->num_shared_clients--;
+ } else {
+ ulp->cfg_data->num_shared_clients++;
+ }
+
ulp->g_shared_tfp = tfp;
return 0;
}
return ulp->g_shared_tfp;
}
+/* Function to get the number of shared clients attached */
+uint8_t
+bnxt_ulp_cntxt_num_shared_clients_get(struct bnxt_ulp_context *ulp)
+{
+ if (ulp == NULL || ulp->cfg_data == NULL) {
+ BNXT_TF_DBG(ERR, "Invalid arguments\n");
+ return 0;
+ }
+ return ulp->cfg_data->num_shared_clients;
+}
+
/* Function to set the tfp session details from the ulp context. */
int32_t
bnxt_ulp_cntxt_tfp_set(struct bnxt_ulp_context *ulp, struct tf *tfp)
/* Function to get the tfp session details from the ulp context. */
struct tf *
-bnxt_ulp_cntxt_tfp_get(struct bnxt_ulp_context *ulp)
+bnxt_ulp_cntxt_tfp_get(struct bnxt_ulp_context *ulp,
+ enum bnxt_ulp_shared_session shared)
{
if (!ulp) {
BNXT_TF_DBG(ERR, "Invalid arguments\n");
return NULL;
}
- return ulp->g_tfp;
+ if (shared)
+ return ulp->g_shared_tfp;
+ else
+ return ulp->g_tfp;
}
/*
pthread_mutex_unlock(&ulp_ctx->cfg_data->flow_db_lock);
}
+
+/* Function to set the ha info into the context */
+int32_t
+bnxt_ulp_cntxt_ptr2_ha_info_set(struct bnxt_ulp_context *ulp_ctx,
+ struct bnxt_ulp_ha_mgr_info *ulp_ha_info)
+{
+ if (ulp_ctx == NULL || ulp_ctx->cfg_data == NULL) {
+ BNXT_TF_DBG(ERR, "Invalid ulp context data\n");
+ return -EINVAL;
+ }
+ ulp_ctx->cfg_data->ha_info = ulp_ha_info;
+ return 0;
+}
+
+/* Function to retrieve the ha info from the context. */
+struct bnxt_ulp_ha_mgr_info *
+bnxt_ulp_cntxt_ptr2_ha_info_get(struct bnxt_ulp_context *ulp_ctx)
+{
+ if (ulp_ctx == NULL || ulp_ctx->cfg_data == NULL)
+ return NULL;
+ return ulp_ctx->cfg_data->ha_info;
+}
+
+bool
+bnxt_ulp_cntxt_ha_enabled(struct bnxt_ulp_context *ulp_ctx)
+{
+ if (ulp_ctx == NULL || ulp_ctx->cfg_data == NULL)
+ return false;
+ return !!ULP_HIGH_AVAIL_IS_ENABLED(ulp_ctx->cfg_data->ulp_flags);
+}
+
+static int32_t
+bnxt_ulp_cntxt_list_init(void)
+{
+ /* Create the cntxt spin lock */
+ rte_spinlock_init(&bnxt_ulp_ctxt_lock);
+
+ return 0;
+}
+
+static int32_t
+bnxt_ulp_cntxt_list_add(struct bnxt_ulp_context *ulp_ctx)
+{
+ struct ulp_context_list_entry *entry;
+
+ entry = rte_zmalloc(NULL, sizeof(struct ulp_context_list_entry), 0);
+ if (entry == NULL) {
+ BNXT_TF_DBG(ERR, "unable to allocate memory\n");
+ return -ENOMEM;
+ }
+
+ rte_spinlock_lock(&bnxt_ulp_ctxt_lock);
+ entry->ulp_ctx = ulp_ctx;
+ TAILQ_INSERT_TAIL(&ulp_cntx_list, entry, next);
+ rte_spinlock_unlock(&bnxt_ulp_ctxt_lock);
+ return 0;
+}
+
+static void
+bnxt_ulp_cntxt_list_del(struct bnxt_ulp_context *ulp_ctx)
+{
+ struct ulp_context_list_entry *entry, *temp;
+
+ rte_spinlock_lock(&bnxt_ulp_ctxt_lock);
+ RTE_TAILQ_FOREACH_SAFE(entry, &ulp_cntx_list, next, temp) {
+ if (entry->ulp_ctx == ulp_ctx) {
+ TAILQ_REMOVE(&ulp_cntx_list, entry, next);
+ rte_free(entry);
+ break;
+ }
+ }
+ rte_spinlock_unlock(&bnxt_ulp_ctxt_lock);
+}
+
+struct bnxt_ulp_context *
+bnxt_ulp_cntxt_entry_acquire(void)
+{
+ struct ulp_context_list_entry *entry;
+
+ /* take a lock and get the first ulp context available */
+ if (rte_spinlock_trylock(&bnxt_ulp_ctxt_lock)) {
+ TAILQ_FOREACH(entry, &ulp_cntx_list, next)
+ if (entry->ulp_ctx)
+ return entry->ulp_ctx;
+ }
+ return NULL;
+}
+
+void
+bnxt_ulp_cntxt_entry_release(void)
+{
+ rte_spinlock_unlock(&bnxt_ulp_ctxt_lock);
+}
+
+/* Function to get the app tunnel details from the ulp context. */
+struct bnxt_flow_app_tun_ent *
+bnxt_ulp_cntxt_ptr2_app_tun_list_get(struct bnxt_ulp_context *ulp)
+{
+ if (!ulp || !ulp->cfg_data)
+ return NULL;
+
+ return ulp->cfg_data->app_tun;
+}