#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 =
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;
}
uint32_t num,
struct tf_session_resources *res)
{
- uint32_t dev_id, res_type, i;
+ 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 (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)
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);
if (rc) {
BNXT_TF_DBG(ERR, "Unable to get device id from ulp.\n");
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");
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",
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) {
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. */
{
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;
*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)
struct ulp_context_list_entry *entry, *temp;
rte_spinlock_lock(&bnxt_ulp_ctxt_lock);
- TAILQ_FOREACH_SAFE(entry, &ulp_cntx_list, next, temp) {
+ 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);
{
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;
+}
git.droids-corp.org / dpdk.git / blobdiff