d/numam-dpdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

net/bnxt: support multiple device

Browse Source 
Implement the Identifier, Table Type and the Resource Manager
modules.
Integrate Resource Manager with HCAPI.
Update open/close session.
Move to direct msgs for qcaps and resv messages.

Signed-off-by: Michael Wildt <michael.wildt@broadcom.com>
Signed-off-by: Venkat Duvvuru <venkatkumar.duvvuru@broadcom.com>
Reviewed-by: Randy Schacher <stuart.schacher@broadcom.com>
Reviewed-by: Ajit Khaparde <ajit.khaparde@broadcom.com>
This commit is contained in:
Michael Wildt 2020-07-02 16:28:05 -07:00 committed by Ferruh Yigit
parent 8de0132019
commit 48d3dff2b9
19 changed files with 880 additions and 1276 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

751
drivers/net/bnxt/tf_core/tf_core.c
View File

@ -19,284 +19,15 @@
#include "tf_common.h"
#include "hwrm_tf.h"
/**
* Create EM Tbl pool of memory indexes.
*
* [in] session
* Pointer to session
* [in] dir
* direction
* [in] num_entries
* number of entries to write
*
* Return:
* 0 - Success, entry allocated - no search support
* -ENOMEM -EINVAL -EOPNOTSUPP
* - Failure, entry not allocated, out of resources
*/
static int
tf_create_em_pool(struct tf_session *session,
enum tf_dir dir,
uint32_t num_entries)
{
struct tfp_calloc_parms parms;
uint32_t i, j;
int rc = 0;
struct stack *pool = &session->em_pool[dir];
parms.nitems = num_entries;
parms.size = sizeof(uint32_t);
parms.alignment = 0;
if (tfp_calloc(&parms) != 0) {
TFP_DRV_LOG(ERR, "EM pool allocation failure %s\n",
strerror(-ENOMEM));
return -ENOMEM;
}
/* Create empty stack
*/
rc = stack_init(num_entries, (uint32_t *)parms.mem_va, pool);
if (rc != 0) {
TFP_DRV_LOG(ERR, "EM pool stack init failure %s\n",
strerror(-rc));
goto cleanup;
}
/* Fill pool with indexes
*/
j = num_entries - 1;
for (i = 0; i < num_entries; i++) {
rc = stack_push(pool, j);
if (rc != 0) {
TFP_DRV_LOG(ERR, "EM pool stack push failure %s\n",
strerror(-rc));
goto cleanup;
}
j--;
}
if (!stack_is_full(pool)) {
rc = -EINVAL;
TFP_DRV_LOG(ERR, "EM pool stack failure %s\n",
strerror(-rc));
goto cleanup;
}
return 0;
cleanup:
tfp_free((void *)parms.mem_va);
return rc;
}
/**
* Create EM Tbl pool of memory indexes.
*
* [in] session
* Pointer to session
* [in] dir
* direction
*
* Return:
*/
static void
tf_free_em_pool(struct tf_session *session,
enum tf_dir dir)
{
struct stack *pool = &session->em_pool[dir];
uint32_t *ptr;
ptr = stack_items(pool);
tfp_free(ptr);
}
int
tf_open_session(struct tf *tfp,
tf_open_session(struct tf *tfp,
struct tf_open_session_parms *parms)
{
int rc;
struct tf_session *session;
struct tfp_calloc_parms alloc_parms;
unsigned int domain, bus, slot, device;
uint8_t fw_session_id;
int dir;
TF_CHECK_PARMS(tfp, parms);
/* Filter out any non-supported device types on the Core
* side. It is assumed that the Firmware will be supported if
* firmware open session succeeds.
*/
if (parms->device_type != TF_DEVICE_TYPE_WH) {
TFP_DRV_LOG(ERR,
"Unsupported device type %d\n",
parms->device_type);
return -ENOTSUP;
}
/* Build the beginning of session_id */
rc = sscanf(parms->ctrl_chan_name,
"%x:%x:%x.%d",
&domain,
&bus,
&slot,
&device);
if (rc != 4) {
TFP_DRV_LOG(ERR,
"Failed to scan device ctrl_chan_name\n");
return -EINVAL;
}
/* open FW session and get a new session_id */
rc = tf_msg_session_open(tfp,
parms->ctrl_chan_name,
&fw_session_id);
if (rc) {
/* Log error */
if (rc == -EEXIST)
TFP_DRV_LOG(ERR,
"Session is already open, rc:%s\n",
strerror(-rc));
else
TFP_DRV_LOG(ERR,
"Open message send failed, rc:%s\n",
strerror(-rc));
parms->session_id.id = TF_FW_SESSION_ID_INVALID;
return rc;
}
/* Allocate session */
alloc_parms.nitems = 1;
alloc_parms.size = sizeof(struct tf_session_info);
alloc_parms.alignment = 0;
rc = tfp_calloc(&alloc_parms);
if (rc) {
/* Log error */
TFP_DRV_LOG(ERR,
"Failed to allocate session info, rc:%s\n",
strerror(-rc));
goto cleanup;
}
tfp->session = (struct tf_session_info *)alloc_parms.mem_va;
/* Allocate core data for the session */
alloc_parms.nitems = 1;
alloc_parms.size = sizeof(struct tf_session);
alloc_parms.alignment = 0;
rc = tfp_calloc(&alloc_parms);
if (rc) {
/* Log error */
TFP_DRV_LOG(ERR,
"Failed to allocate session data, rc:%s\n",
strerror(-rc));
goto cleanup;
}
tfp->session->core_data = alloc_parms.mem_va;
session = (struct tf_session *)tfp->session->core_data;
tfp_memcpy(session->ctrl_chan_name,
parms->ctrl_chan_name,
TF_SESSION_NAME_MAX);
/* Initialize Session */
session->dev = NULL;
tf_rm_init(tfp);
/* Construct the Session ID */
session->session_id.internal.domain = domain;
session->session_id.internal.bus = bus;
session->session_id.internal.device = device;
session->session_id.internal.fw_session_id = fw_session_id;
/* Query for Session Config
*/
rc = tf_msg_session_qcfg(tfp);
if (rc) {
TFP_DRV_LOG(ERR,
"Query config message send failed, rc:%s\n",
strerror(-rc));
goto cleanup_close;
}
/* Shadow DB configuration */
if (parms->shadow_copy) {
/* Ignore shadow_copy setting */
session->shadow_copy = 0;/* parms->shadow_copy; */
#if (TF_SHADOW == 1)
rc = tf_rm_shadow_db_init(tfs);
if (rc)
TFP_DRV_LOG(ERR,
"Shadow DB Initialization failed\n, rc:%s",
strerror(-rc));
/* Add additional processing */
#endif /* TF_SHADOW */
}
/* Adjust the Session with what firmware allowed us to get */
rc = tf_rm_allocate_validate(tfp);
if (rc) {
TFP_DRV_LOG(ERR,
"Rm allocate validate failed, rc:%s\n",
strerror(-rc));
goto cleanup_close;
}
/* Initialize EM pool */
for (dir = 0; dir < TF_DIR_MAX; dir++) {
rc = tf_create_em_pool(session,
(enum tf_dir)dir,
TF_SESSION_EM_POOL_SIZE);
if (rc) {
TFP_DRV_LOG(ERR,
"EM Pool initialization failed\n");
goto cleanup_close;
}
}
session->ref_count++;
/* Return session ID */
parms->session_id = session->session_id;
TFP_DRV_LOG(INFO,
"Session created, session_id:%d\n",
parms->session_id.id);
TFP_DRV_LOG(INFO,
"domain:%d, bus:%d, device:%d, fw_session_id:%d\n",
parms->session_id.internal.domain,
parms->session_id.internal.bus,
parms->session_id.internal.device,
parms->session_id.internal.fw_session_id);
return 0;
cleanup:
tfp_free(tfp->session->core_data);
tfp_free(tfp->session);
tfp->session = NULL;
return rc;
cleanup_close:
tf_close_session(tfp);
return -EINVAL;
}
int
tf_open_session_new(struct tf *tfp,
struct tf_open_session_parms *parms)
{
int rc;
unsigned int domain, bus, slot, device;
struct tf_session_open_session_parms oparms;
TF_CHECK_PARMS(tfp, parms);
TF_CHECK_PARMS2(tfp, parms);
/* Filter out any non-supported device types on the Core
* side. It is assumed that the Firmware will be supported if
@ -347,33 +78,8 @@ tf_open_session_new(struct tf *tfp,
}
int
tf_attach_session(struct tf *tfp __rte_unused,
struct tf_attach_session_parms *parms __rte_unused)
{
#if (TF_SHARED == 1)
int rc;
TF_CHECK_PARMS_SESSION(tfp, parms);
/* - Open the shared memory for the attach_chan_name
* - Point to the shared session for this Device instance
* - Check that session is valid
* - Attach to the firmware so it can record there is more
* than one client of the session.
*/
if (tfp->session->session_id.id != TF_SESSION_ID_INVALID) {
rc = tf_msg_session_attach(tfp,
parms->ctrl_chan_name,
parms->session_id);
}
#endif /* TF_SHARED */
return -1;
}
int
tf_attach_session_new(struct tf *tfp,
struct tf_attach_session_parms *parms)
tf_attach_session(struct tf *tfp,
struct tf_attach_session_parms *parms)
{
int rc;
unsigned int domain, bus, slot, device;
@ -436,65 +142,6 @@ tf_attach_session_new(struct tf *tfp,
int
tf_close_session(struct tf *tfp)
{
int rc;
int rc_close = 0;
struct tf_session *tfs;
union tf_session_id session_id;
int dir;
TF_CHECK_TFP_SESSION(tfp);
tfs = (struct tf_session *)(tfp->session->core_data);
/* Cleanup if we're last user of the session */
if (tfs->ref_count == 1) {
/* Cleanup any outstanding resources */
rc_close = tf_rm_close(tfp);
}
if (tfs->session_id.id != TF_SESSION_ID_INVALID) {
rc = tf_msg_session_close(tfp);
if (rc) {
/* Log error */
TFP_DRV_LOG(ERR,
"Message send failed, rc:%s\n",
strerror(-rc));
}
/* Update the ref_count */
tfs->ref_count--;
}
session_id = tfs->session_id;
/* Final cleanup as we're last user of the session */
if (tfs->ref_count == 0) {
/* Free EM pool */
for (dir = 0; dir < TF_DIR_MAX; dir++)
tf_free_em_pool(tfs, (enum tf_dir)dir);
tfp_free(tfp->session->core_data);
tfp_free(tfp->session);
tfp->session = NULL;
}
TFP_DRV_LOG(INFO,
"Session closed, session_id:%d\n",
session_id.id);
TFP_DRV_LOG(INFO,
"domain:%d, bus:%d, device:%d, fw_session_id:%d\n",
session_id.internal.domain,
session_id.internal.bus,
session_id.internal.device,
session_id.internal.fw_session_id);
return rc_close;
}
int
tf_close_session_new(struct tf *tfp)
{
int rc;
struct tf_session_close_session_parms cparms = { 0 };
@ -620,76 +267,9 @@ int tf_delete_em_entry(struct tf *tfp,
return rc;
}
int tf_alloc_identifier(struct tf *tfp,
struct tf_alloc_identifier_parms *parms)
{
struct bitalloc *session_pool;
struct tf_session *tfs;
int id;
int rc;
TF_CHECK_PARMS_SESSION(tfp, parms);
tfs = (struct tf_session *)(tfp->session->core_data);
switch (parms->ident_type) {
case TF_IDENT_TYPE_L2_CTXT:
TF_RM_GET_POOLS(tfs, parms->dir, &session_pool,
TF_L2_CTXT_REMAP_POOL_NAME,
rc);
break;
case TF_IDENT_TYPE_PROF_FUNC:
TF_RM_GET_POOLS(tfs, parms->dir, &session_pool,
TF_PROF_FUNC_POOL_NAME,
rc);
break;
case TF_IDENT_TYPE_EM_PROF:
TF_RM_GET_POOLS(tfs, parms->dir, &session_pool,
TF_EM_PROF_ID_POOL_NAME,
rc);
break;
case TF_IDENT_TYPE_WC_PROF:
TF_RM_GET_POOLS(tfs, parms->dir, &session_pool,
TF_WC_TCAM_PROF_ID_POOL_NAME,
rc);
break;
case TF_IDENT_TYPE_L2_FUNC:
TFP_DRV_LOG(ERR, "%s: unsupported %s\n",
tf_dir_2_str(parms->dir),
tf_ident_2_str(parms->ident_type));
rc = -EOPNOTSUPP;
break;
default:
TFP_DRV_LOG(ERR, "%s: %s\n",
tf_dir_2_str(parms->dir),
tf_ident_2_str(parms->ident_type));
rc = -EOPNOTSUPP;
break;
}
if (rc) {
TFP_DRV_LOG(ERR, "%s: identifier pool %s failure, rc:%s\n",
tf_dir_2_str(parms->dir),
tf_ident_2_str(parms->ident_type),
strerror(-rc));
return rc;
}
id = ba_alloc(session_pool);
if (id == BA_FAIL) {
TFP_DRV_LOG(ERR, "%s: %s: No resource available\n",
tf_dir_2_str(parms->dir),
tf_ident_2_str(parms->ident_type));
return -ENOMEM;
}
parms->id = id;
return 0;
}
int
tf_alloc_identifier_new(struct tf *tfp,
struct tf_alloc_identifier_parms *parms)
tf_alloc_identifier(struct tf *tfp,
struct tf_alloc_identifier_parms *parms)
{
int rc;
struct tf_session *tfs;
@ -732,7 +312,7 @@ tf_alloc_identifier_new(struct tf *tfp,
}
aparms.dir = parms->dir;
aparms.ident_type = parms->ident_type;
aparms.type = parms->ident_type;
aparms.id = &id;
rc = dev->ops->tf_dev_alloc_ident(tfp, &aparms);
if (rc) {
@ -748,79 +328,9 @@ tf_alloc_identifier_new(struct tf *tfp,
return 0;
}
int tf_free_identifier(struct tf *tfp,
struct tf_free_identifier_parms *parms)
{
struct bitalloc *session_pool;
int rc;
int ba_rc;
struct tf_session *tfs;
TF_CHECK_PARMS_SESSION(tfp, parms);
tfs = (struct tf_session *)(tfp->session->core_data);
switch (parms->ident_type) {
case TF_IDENT_TYPE_L2_CTXT:
TF_RM_GET_POOLS(tfs, parms->dir, &session_pool,
TF_L2_CTXT_REMAP_POOL_NAME,
rc);
break;
case TF_IDENT_TYPE_PROF_FUNC:
TF_RM_GET_POOLS(tfs, parms->dir, &session_pool,
TF_PROF_FUNC_POOL_NAME,
rc);
break;
case TF_IDENT_TYPE_EM_PROF:
TF_RM_GET_POOLS(tfs, parms->dir, &session_pool,
TF_EM_PROF_ID_POOL_NAME,
rc);
break;
case TF_IDENT_TYPE_WC_PROF:
TF_RM_GET_POOLS(tfs, parms->dir, &session_pool,
TF_WC_TCAM_PROF_ID_POOL_NAME,
rc);
break;
case TF_IDENT_TYPE_L2_FUNC:
TFP_DRV_LOG(ERR, "%s: unsupported %s\n",
tf_dir_2_str(parms->dir),
tf_ident_2_str(parms->ident_type));
rc = -EOPNOTSUPP;
break;
default:
TFP_DRV_LOG(ERR, "%s: invalid %s\n",
tf_dir_2_str(parms->dir),
tf_ident_2_str(parms->ident_type));
rc = -EOPNOTSUPP;
break;
}
if (rc) {
TFP_DRV_LOG(ERR,
"%s: %s Identifier pool access failed, rc:%s\n",
tf_dir_2_str(parms->dir),
tf_ident_2_str(parms->ident_type),
strerror(-rc));
return rc;
}
ba_rc = ba_inuse(session_pool, (int)parms->id);
if (ba_rc == BA_FAIL || ba_rc == BA_ENTRY_FREE) {
TFP_DRV_LOG(ERR, "%s: %s: Entry %d already free",
tf_dir_2_str(parms->dir),
tf_ident_2_str(parms->ident_type),
parms->id);
return -EINVAL;
}
ba_free(session_pool, (int)parms->id);
return 0;
}
int
tf_free_identifier_new(struct tf *tfp,
struct tf_free_identifier_parms *parms)
tf_free_identifier(struct tf *tfp,
struct tf_free_identifier_parms *parms)
{
int rc;
struct tf_session *tfs;
@ -862,12 +372,12 @@ tf_free_identifier_new(struct tf *tfp,
}
fparms.dir = parms->dir;
fparms.ident_type = parms->ident_type;
fparms.type = parms->ident_type;
fparms.id = parms->id;
rc = dev->ops->tf_dev_free_ident(tfp, &fparms);
if (rc) {
TFP_DRV_LOG(ERR,
"%s: Identifier allocation failed, rc:%s\n",
"%s: Identifier free failed, rc:%s\n",
tf_dir_2_str(parms->dir),
strerror(-rc));
return rc;
@ -1057,3 +567,242 @@ tf_free_tcam_entry(struct tf *tfp,
return 0;
}
int
tf_alloc_tbl_entry(struct tf *tfp,
struct tf_alloc_tbl_entry_parms *parms)
{
int rc;
struct tf_session *tfs;
struct tf_dev_info *dev;
struct tf_tbl_alloc_parms aparms;
uint32_t idx;
TF_CHECK_PARMS2(tfp, parms);
/* Can't do static initialization due to UT enum check */
memset(&aparms, 0, sizeof(struct tf_tbl_alloc_parms));
/* Retrieve the session information */
rc = tf_session_get_session(tfp, &tfs);
if (rc) {
TFP_DRV_LOG(ERR,
"%s: Failed to lookup session, rc:%s\n",
tf_dir_2_str(parms->dir),
strerror(-rc));
return rc;
}
/* Retrieve the device information */
rc = tf_session_get_device(tfs, &dev);
if (rc) {
TFP_DRV_LOG(ERR,
"%s: Failed to lookup device, rc:%s\n",
tf_dir_2_str(parms->dir),
strerror(-rc));
return rc;
}
if (dev->ops->tf_dev_alloc_tbl == NULL) {
rc = -EOPNOTSUPP;
TFP_DRV_LOG(ERR,
"%s: Operation not supported, rc:%s\n",
tf_dir_2_str(parms->dir),
strerror(-rc));
return -EOPNOTSUPP;
}
aparms.dir = parms->dir;
aparms.type = parms->type;
aparms.idx = &idx;
rc = dev->ops->tf_dev_alloc_tbl(tfp, &aparms);
if (rc) {
TFP_DRV_LOG(ERR,
"%s: Table allocation failed, rc:%s\n",
tf_dir_2_str(parms->dir),
strerror(-rc));
return rc;
}
parms->idx = idx;
return 0;
}
int
tf_free_tbl_entry(struct tf *tfp,
struct tf_free_tbl_entry_parms *parms)
{
int rc;
struct tf_session *tfs;
struct tf_dev_info *dev;
struct tf_tbl_free_parms fparms;
TF_CHECK_PARMS2(tfp, parms);
/* Can't do static initialization due to UT enum check */
memset(&fparms, 0, sizeof(struct tf_tbl_free_parms));
/* Retrieve the session information */
rc = tf_session_get_session(tfp, &tfs);
if (rc) {
TFP_DRV_LOG(ERR,
"%s: Failed to lookup session, rc:%s\n",
tf_dir_2_str(parms->dir),
strerror(-rc));
return rc;
}
/* Retrieve the device information */
rc = tf_session_get_device(tfs, &dev);
if (rc) {
TFP_DRV_LOG(ERR,
"%s: Failed to lookup device, rc:%s\n",
tf_dir_2_str(parms->dir),
strerror(-rc));
return rc;
}
if (dev->ops->tf_dev_free_tbl == NULL) {
rc = -EOPNOTSUPP;
TFP_DRV_LOG(ERR,
"%s: Operation not supported, rc:%s\n",
tf_dir_2_str(parms->dir),
strerror(-rc));
return -EOPNOTSUPP;
}
fparms.dir = parms->dir;
fparms.type = parms->type;
fparms.idx = parms->idx;
rc = dev->ops->tf_dev_free_tbl(tfp, &fparms);
if (rc) {
TFP_DRV_LOG(ERR,
"%s: Table free failed, rc:%s\n",
tf_dir_2_str(parms->dir),
strerror(-rc));
return rc;
}
return 0;
}
int
tf_set_tbl_entry(struct tf *tfp,
struct tf_set_tbl_entry_parms *parms)
{
int rc = 0;
struct tf_session *tfs;
struct tf_dev_info *dev;
struct tf_tbl_set_parms sparms;
TF_CHECK_PARMS3(tfp, parms, parms->data);
/* Can't do static initialization due to UT enum check */
memset(&sparms, 0, sizeof(struct tf_tbl_set_parms));
/* Retrieve the session information */
rc = tf_session_get_session(tfp, &tfs);
if (rc) {
TFP_DRV_LOG(ERR,
"%s: Failed to lookup session, rc:%s\n",
tf_dir_2_str(parms->dir),
strerror(-rc));
return rc;
}
/* Retrieve the device information */
rc = tf_session_get_device(tfs, &dev);
if (rc) {
TFP_DRV_LOG(ERR,
"%s: Failed to lookup device, rc:%s\n",
tf_dir_2_str(parms->dir),
strerror(-rc));
return rc;
}
if (dev->ops->tf_dev_set_tbl == NULL) {
rc = -EOPNOTSUPP;
TFP_DRV_LOG(ERR,
"%s: Operation not supported, rc:%s\n",
tf_dir_2_str(parms->dir),
strerror(-rc));
return -EOPNOTSUPP;
}
sparms.dir = parms->dir;
sparms.type = parms->type;
sparms.data = parms->data;
sparms.data_sz_in_bytes = parms->data_sz_in_bytes;
sparms.idx = parms->idx;
rc = dev->ops->tf_dev_set_tbl(tfp, &sparms);
if (rc) {
TFP_DRV_LOG(ERR,
"%s: Table set failed, rc:%s\n",
tf_dir_2_str(parms->dir),
strerror(-rc));
return rc;
}
return rc;
}
int
tf_get_tbl_entry(struct tf *tfp,
struct tf_get_tbl_entry_parms *parms)
{
int rc = 0;
struct tf_session *tfs;
struct tf_dev_info *dev;
struct tf_tbl_get_parms gparms;
TF_CHECK_PARMS3(tfp, parms, parms->data);
/* Can't do static initialization due to UT enum check */
memset(&gparms, 0, sizeof(struct tf_tbl_get_parms));
/* Retrieve the session information */
rc = tf_session_get_session(tfp, &tfs);
if (rc) {
TFP_DRV_LOG(ERR,
"%s: Failed to lookup session, rc:%s\n",
tf_dir_2_str(parms->dir),
strerror(-rc));
return rc;
}
/* Retrieve the device information */
rc = tf_session_get_device(tfs, &dev);
if (rc) {
TFP_DRV_LOG(ERR,
"%s: Failed to lookup device, rc:%s\n",
tf_dir_2_str(parms->dir),
strerror(-rc));
return rc;
}
if (dev->ops->tf_dev_get_tbl == NULL) {
rc = -EOPNOTSUPP;
TFP_DRV_LOG(ERR,
"%s: Operation not supported, rc:%s\n",
tf_dir_2_str(parms->dir),
strerror(-rc));
return -EOPNOTSUPP;
}
gparms.dir = parms->dir;
gparms.type = parms->type;
gparms.data = parms->data;
gparms.data_sz_in_bytes = parms->data_sz_in_bytes;
gparms.idx = parms->idx;
rc = dev->ops->tf_dev_get_tbl(tfp, &gparms);
if (rc) {
TFP_DRV_LOG(ERR,
"%s: Table get failed, rc:%s\n",
tf_dir_2_str(parms->dir),
strerror(-rc));
return rc;
}
return rc;
}

97
drivers/net/bnxt/tf_core/tf_core.h
View File

@ -384,34 +384,87 @@ struct tf {
struct tf_session_info *session;
};
/**
* Identifier resource definition
*/
struct tf_identifier_resources {
/**
* Array of TF Identifiers where each entry is expected to be
* set to the requested resource number of that specific type.
* The index used is tf_identifier_type.
*/
uint16_t cnt[TF_IDENT_TYPE_MAX];
};
/**
* Table type resource definition
*/
struct tf_tbl_resources {
/**
* Array of TF Table types where each entry is expected to be
* set to the requeste resource number of that specific
* type. The index used is tf_tbl_type.
*/
uint16_t cnt[TF_TBL_TYPE_MAX];
};
/**
* TCAM type resource definition
*/
struct tf_tcam_resources {
/**
* Array of TF TCAM types where each entry is expected to be
* set to the requested resource number of that specific
* type. The index used is tf_tcam_tbl_type.
*/
uint16_t cnt[TF_TCAM_TBL_TYPE_MAX];
};
/**
* EM type resource definition
*/
struct tf_em_resources {
/**
* Array of TF EM table types where each entry is expected to
* be set to the requested resource number of that specific
* type. The index used is tf_em_tbl_type.
*/
uint16_t cnt[TF_EM_TBL_TYPE_MAX];
};
/**
* tf_session_resources parameter definition.
*/
struct tf_session_resources {
/** [in] Requested Identifier Resources
/**
* [in] Requested Identifier Resources
*
* The number of identifier resources requested for the session.
* The index used is tf_identifier_type.
* Number of identifier resources requested for the
* session.
*/
uint16_t identifier_cnt[TF_IDENT_TYPE_MAX][TF_DIR_MAX];
/** [in] Requested Index Table resource counts
struct tf_identifier_resources ident_cnt[TF_DIR_MAX];
/**
* [in] Requested Index Table resource counts
*
* The number of index table resources requested for the session.
* The index used is tf_tbl_type.
* The number of index table resources requested for the
* session.
*/
uint16_t tbl_cnt[TF_TBL_TYPE_MAX][TF_DIR_MAX];
/** [in] Requested TCAM Table resource counts
struct tf_tbl_resources tbl_cnt[TF_DIR_MAX];
/**
* [in] Requested TCAM Table resource counts
*
* The number of TCAM table resources requested for the session.
* The index used is tf_tcam_tbl_type.
* The number of TCAM table resources requested for the
* session.
*/
uint16_t tcam_tbl_cnt[TF_TCAM_TBL_TYPE_MAX][TF_DIR_MAX];
/** [in] Requested EM resource counts
struct tf_tcam_resources tcam_cnt[TF_DIR_MAX];
/**
* [in] Requested EM resource counts
*
* The number of internal EM table resources requested for the session
* The index used is tf_em_tbl_type.
* The number of internal EM table resources requested for the
* session.
*/
uint16_t em_tbl_cnt[TF_EM_TBL_TYPE_MAX][TF_DIR_MAX];
struct tf_em_resources em_cnt[TF_DIR_MAX];
};
/**
@ -497,9 +550,6 @@ struct tf_open_session_parms {
int tf_open_session(struct tf *tfp,
struct tf_open_session_parms *parms);
int tf_open_session_new(struct tf *tfp,
struct tf_open_session_parms *parms);
struct tf_attach_session_parms {
/**
* [in] ctrl_chan_name
@ -565,8 +615,6 @@ struct tf_attach_session_parms {
*/
int tf_attach_session(struct tf *tfp,
struct tf_attach_session_parms *parms);
int tf_attach_session_new(struct tf *tfp,
struct tf_attach_session_parms *parms);
/**
* Closes an existing session. Cleans up all hardware and firmware
@ -576,7 +624,6 @@ int tf_attach_session_new(struct tf *tfp,
* Returns success or failure code.
*/
int tf_close_session(struct tf *tfp);
int tf_close_session_new(struct tf *tfp);
/**
* @page ident Identity Management
@ -631,8 +678,6 @@ struct tf_free_identifier_parms {
*/
int tf_alloc_identifier(struct tf *tfp,
struct tf_alloc_identifier_parms *parms);
int tf_alloc_identifier_new(struct tf *tfp,
struct tf_alloc_identifier_parms *parms);
/**
* free identifier resource
@ -645,8 +690,6 @@ int tf_alloc_identifier_new(struct tf *tfp,
*/
int tf_free_identifier(struct tf *tfp,
struct tf_free_identifier_parms *parms);
int tf_free_identifier_new(struct tf *tfp,
struct tf_free_identifier_parms *parms);
/**
* @page dram_table DRAM Table Scope Interface
@ -1277,7 +1320,7 @@ struct tf_bulk_get_tbl_entry_parms {
* provided data buffer is too small for the data type requested.
*/
int tf_bulk_get_tbl_entry(struct tf *tfp,
struct tf_bulk_get_tbl_entry_parms *parms);
struct tf_bulk_get_tbl_entry_parms *parms);
/**
* @page exact_match Exact Match Table

10
drivers/net/bnxt/tf_core/tf_device.c
View File

@ -43,6 +43,14 @@ dev_bind_p4(struct tf *tfp,
struct tf_tbl_cfg_parms tbl_cfg;
struct tf_tcam_cfg_parms tcam_cfg;
dev_handle->type = TF_DEVICE_TYPE_WH;
/* Initial function initialization */
dev_handle->ops = &tf_dev_ops_p4_init;
dev_handle->type = TF_DEVICE_TYPE_WH;
/* Initial function initialization */
dev_handle->ops = &tf_dev_ops_p4_init;
/* Initialize the modules */
ident_cfg.num_elements = TF_IDENT_TYPE_MAX;
@ -78,7 +86,7 @@ dev_bind_p4(struct tf *tfp,
goto fail;
}
dev_handle->type = TF_DEVICE_TYPE_WH;
/* Final function initialization */
dev_handle->ops = &tf_dev_ops_p4;
return 0;

1
drivers/net/bnxt/tf_core/tf_device.h
View File

@ -407,6 +407,7 @@ struct tf_dev_ops {
/**
* Supported device operation structures
*/
extern const struct tf_dev_ops tf_dev_ops_p4_init;
extern const struct tf_dev_ops tf_dev_ops_p4;
#endif /* _TF_DEVICE_H_ */

26
drivers/net/bnxt/tf_core/tf_device_p4.c
View File

@ -75,6 +75,26 @@ tf_dev_p4_get_tcam_slice_info(struct tf *tfp __rte_unused,
return 0;
}
/**
* Truflow P4 device specific functions
*/
const struct tf_dev_ops tf_dev_ops_p4_init = {
.tf_dev_get_max_types = tf_dev_p4_get_max_types,
.tf_dev_get_tcam_slice_info = tf_dev_p4_get_tcam_slice_info,
.tf_dev_alloc_ident = NULL,
.tf_dev_free_ident = NULL,
.tf_dev_alloc_tbl = NULL,
.tf_dev_free_tbl = NULL,
.tf_dev_alloc_search_tbl = NULL,
.tf_dev_set_tbl = NULL,
.tf_dev_get_tbl = NULL,
.tf_dev_alloc_tcam = NULL,
.tf_dev_free_tcam = NULL,
.tf_dev_alloc_search_tcam = NULL,
.tf_dev_set_tcam = NULL,
.tf_dev_get_tcam = NULL,
};
/**
* Truflow P4 device specific functions
*/
@ -85,14 +105,14 @@ const struct tf_dev_ops tf_dev_ops_p4 = {
.tf_dev_free_ident = tf_ident_free,
.tf_dev_alloc_tbl = tf_tbl_alloc,
.tf_dev_free_tbl = tf_tbl_free,
.tf_dev_alloc_search_tbl = tf_tbl_alloc_search,
.tf_dev_alloc_search_tbl = NULL,
.tf_dev_set_tbl = tf_tbl_set,
.tf_dev_get_tbl = tf_tbl_get,
.tf_dev_alloc_tcam = tf_tcam_alloc,
.tf_dev_free_tcam = tf_tcam_free,
.tf_dev_alloc_search_tcam = tf_tcam_alloc_search,
.tf_dev_alloc_search_tcam = NULL,
.tf_dev_set_tcam = tf_tcam_set,
.tf_dev_get_tcam = tf_tcam_get,
.tf_dev_get_tcam = NULL,
.tf_dev_insert_em_entry = tf_em_insert_entry,
.tf_dev_delete_em_entry = tf_em_delete_entry,
};

29
drivers/net/bnxt/tf_core/tf_identifier.c
View File

@ -45,19 +45,22 @@ tf_ident_bind(struct tf *tfp,
db_cfg.dir = i;
db_cfg.num_elements = parms->num_elements;
db_cfg.cfg = parms->cfg;
db_cfg.alloc_num = parms->resources->identifier_cnt[i];
db_cfg.rm_db = ident_db[i];
db_cfg.alloc_cnt = parms->resources->ident_cnt[i].cnt;
db_cfg.rm_db = &ident_db[i];
rc = tf_rm_create_db(tfp, &db_cfg);
if (rc) {
TFP_DRV_LOG(ERR,
"%s: Identifier DB creation failed\n",
tf_dir_2_str(i));
return rc;
}
}
init = 1;
printf("Identifier - initialized\n");
return 0;
}
@ -73,8 +76,11 @@ tf_ident_unbind(struct tf *tfp __rte_unused)
/* Bail if nothing has been initialized done silent as to
* allow for creation cleanup.
*/
if (!init)
if (!init) {
TFP_DRV_LOG(ERR,
"No Identifier DBs created\n");
return -EINVAL;
}
for (i = 0; i < TF_DIR_MAX; i++) {
fparms.dir = i;
@ -96,6 +102,7 @@ tf_ident_alloc(struct tf *tfp __rte_unused,
struct tf_ident_alloc_parms *parms)
{
int rc;
uint32_t id;
struct tf_rm_allocate_parms aparms = { 0 };
TF_CHECK_PARMS2(tfp, parms);
@ -109,17 +116,19 @@ tf_ident_alloc(struct tf *tfp __rte_unused,
/* Allocate requested element */
aparms.rm_db = ident_db[parms->dir];
aparms.db_index = parms->ident_type;
aparms.index = (uint32_t *)&parms->id;
aparms.db_index = parms->type;
aparms.index = &id;
rc = tf_rm_allocate(&aparms);
if (rc) {
TFP_DRV_LOG(ERR,
"%s: Failed allocate, type:%d\n",
tf_dir_2_str(parms->dir),
parms->ident_type);
parms->type);
return rc;
}
*parms->id = id;
return 0;
}
@ -143,7 +152,7 @@ tf_ident_free(struct tf *tfp __rte_unused,
/* Check if element is in use */
aparms.rm_db = ident_db[parms->dir];
aparms.db_index = parms->ident_type;
aparms.db_index = parms->type;
aparms.index = parms->id;
aparms.allocated = &allocated;
rc = tf_rm_is_allocated(&aparms);
@ -154,21 +163,21 @@ tf_ident_free(struct tf *tfp __rte_unused,
TFP_DRV_LOG(ERR,
"%s: Entry already free, type:%d, index:%d\n",
tf_dir_2_str(parms->dir),
parms->ident_type,
parms->type,
parms->id);
return rc;
}
/* Free requested element */
fparms.rm_db = ident_db[parms->dir];
fparms.db_index = parms->ident_type;
fparms.db_index = parms->type;
fparms.index = parms->id;
rc = tf_rm_free(&fparms);
if (rc) {
TFP_DRV_LOG(ERR,
"%s: Free failed, type:%d, index:%d\n",
tf_dir_2_str(parms->dir),
parms->ident_type,
parms->type,
parms->id);
return rc;
}

4
drivers/net/bnxt/tf_core/tf_identifier.h
View File

@ -43,7 +43,7 @@ struct tf_ident_alloc_parms {
/**
* [in] Identifier type
*/
enum tf_identifier_type ident_type;
enum tf_identifier_type type;
/**
* [out] Identifier allocated
*/
@ -61,7 +61,7 @@ struct tf_ident_free_parms {
/**
* [in] Identifier type
*/
enum tf_identifier_type ident_type;
enum tf_identifier_type type;
/**
* [in] ID to free
*/

45
drivers/net/bnxt/tf_core/tf_msg.c
View File

@ -12,6 +12,7 @@
#include "tf_device.h"
#include "tf_msg.h"
#include "tf_util.h"
#include "tf_common.h"
#include "tf_session.h"
#include "tfp.h"
#include "hwrm_tf.h"
@ -935,13 +936,7 @@ tf_msg_session_resc_qcaps(struct tf *tfp,
struct tf_rm_resc_req_entry *data;
int dma_size;
if (size == 0 || query == NULL || resv_strategy == NULL) {
TFP_DRV_LOG(ERR,
"%s: Resource QCAPS parameter error, rc:%s\n",
tf_dir_2_str(dir),
strerror(-EINVAL));
return -EINVAL;
}
TF_CHECK_PARMS3(tfp, query, resv_strategy);
rc = tf_session_get_fw_session_id(tfp, &fw_session_id);
if (rc) {
@ -962,7 +957,7 @@ tf_msg_session_resc_qcaps(struct tf *tfp,
req.fw_session_id = tfp_cpu_to_le_32(fw_session_id);
req.flags = tfp_cpu_to_le_16(dir);
req.qcaps_size = size;
req.qcaps_addr = qcaps_buf.pa_addr;
req.qcaps_addr = tfp_cpu_to_le_64(qcaps_buf.pa_addr);
parms.tf_type = HWRM_TF_SESSION_RESC_QCAPS;
parms.req_data = (uint32_t *)&req;
@ -980,18 +975,29 @@ tf_msg_session_resc_qcaps(struct tf *tfp,
*/
if (resp.size != size) {
TFP_DRV_LOG(ERR,
"%s: QCAPS message error, rc:%s\n",
"%s: QCAPS message size error, rc:%s\n",
tf_dir_2_str(dir),
strerror(-EINVAL));
return -EINVAL;
}
printf("size: %d\n", resp.size);
/* Post process the response */
data = (struct tf_rm_resc_req_entry *)qcaps_buf.va_addr;
printf("\nQCAPS\n");
for (i = 0; i < size; i++) {
query[i].type = tfp_cpu_to_le_32(data[i].type);
query[i].min = tfp_le_to_cpu_16(data[i].min);
query[i].max = tfp_le_to_cpu_16(data[i].max);
printf("type: %d(0x%x) %d %d\n",
query[i].type,
query[i].type,
query[i].min,
query[i].max);
}
*resv_strategy = resp.flags &
@ -1021,6 +1027,8 @@ tf_msg_session_resc_alloc(struct tf *tfp,
struct tf_rm_resc_entry *resv_data;
int dma_size;
TF_CHECK_PARMS3(tfp, request, resv);
rc = tf_session_get_fw_session_id(tfp, &fw_session_id);
if (rc) {
TFP_DRV_LOG(ERR,
@ -1053,8 +1061,8 @@ tf_msg_session_resc_alloc(struct tf *tfp,
req_data[i].max = tfp_cpu_to_le_16(request[i].max);
}
req.req_addr = req_buf.pa_addr;
req.resp_addr = resv_buf.pa_addr;
req.req_addr = tfp_cpu_to_le_64(req_buf.pa_addr);
req.resc_addr = tfp_cpu_to_le_64(resv_buf.pa_addr);
parms.tf_type = HWRM_TF_SESSION_RESC_ALLOC;
parms.req_data = (uint32_t *)&req;
@ -1072,18 +1080,28 @@ tf_msg_session_resc_alloc(struct tf *tfp,
*/
if (resp.size != size) {
TFP_DRV_LOG(ERR,
"%s: Alloc message error, rc:%s\n",
"%s: Alloc message size error, rc:%s\n",
tf_dir_2_str(dir),
strerror(-EINVAL));
return -EINVAL;
}
printf("\nRESV\n");
printf("size: %d\n", resp.size);
/* Post process the response */
resv_data = (struct tf_rm_resc_entry *)resv_buf.va_addr;
for (i = 0; i < size; i++) {
resv[i].type = tfp_cpu_to_le_32(resv_data[i].type);
resv[i].start = tfp_cpu_to_le_16(resv_data[i].start);
resv[i].stride = tfp_cpu_to_le_16(resv_data[i].stride);
printf("%d type: %d(0x%x) %d %d\n",
i,
resv[i].type,
resv[i].type,
resv[i].start,
resv[i].stride);
}
tf_msg_free_dma_buf(&req_buf);
@ -1460,7 +1478,8 @@ tf_msg_bulk_get_tbl_entry(struct tf *tfp,
req.start_index = tfp_cpu_to_le_32(params->starting_idx);
req.num_entries = tfp_cpu_to_le_32(params->num_entries);
data_size = (params->num_entries * params->entry_sz_in_bytes);
data_size = params->num_entries * params->entry_sz_in_bytes;
req.host_addr = tfp_cpu_to_le_64(params->physical_mem_addr);
MSG_PREP(parms,

1
drivers/net/bnxt/tf_core/tf_msg.h
View File

@ -12,6 +12,7 @@
#include "tf_tbl.h"
#include "tf_rm.h"
#include "tf_rm_new.h"
#include "tf_tcam.h"
struct tf;

225
drivers/net/bnxt/tf_core/tf_rm_new.c
View File

@ -10,6 +10,7 @@
#include <cfa_resource_types.h>
#include "tf_rm_new.h"
#include "tf_common.h"
#include "tf_util.h"
#include "tf_session.h"
#include "tf_device.h"
@ -65,6 +66,46 @@ struct tf_rm_new_db {
struct tf_rm_element *db;
};
/**
* Adjust an index according to the allocation information.
*
* All resources are controlled in a 0 based pool. Some resources, by
* design, are not 0 based, i.e. Full Action Records (SRAM) thus they
* need to be adjusted before they are handed out.
*
* [in] cfg
* Pointer to the DB configuration
*
* [in] reservations
* Pointer to the allocation values associated with the module
*
* [in] count
* Number of DB configuration elements
*
* [out] valid_count
* Number of HCAPI entries with a reservation value greater than 0
*
* Returns:
* 0 - Success
* - EOPNOTSUPP - Operation not supported
*/
static void
tf_rm_count_hcapi_reservations(struct tf_rm_element_cfg *cfg,
uint16_t *reservations,
uint16_t count,
uint16_t *valid_count)
{
int i;
uint16_t cnt = 0;
for (i = 0; i < count; i++) {
if (cfg[i].cfg_type == TF_RM_ELEM_CFG_HCAPI &&
reservations[i] > 0)
cnt++;
}
*valid_count = cnt;
}
/**
* Resource Manager Adjust of base index definitions.
@ -132,6 +173,7 @@ tf_rm_create_db(struct tf *tfp,
{
int rc;
int i;
int j;
struct tf_session *tfs;
struct tf_dev_info *dev;
uint16_t max_types;
@ -143,6 +185,9 @@ tf_rm_create_db(struct tf *tfp,
struct tf_rm_new_db *rm_db;
struct tf_rm_element *db;
uint32_t pool_size;
uint16_t hcapi_items;
TF_CHECK_PARMS2(tfp, parms);
/* Retrieve the session information */
rc = tf_session_get_session(tfp, &tfs);
@ -177,10 +222,19 @@ tf_rm_create_db(struct tf *tfp,
if (rc)
return rc;
/* Process capabilities against db requirements */
/* Process capabilities against DB requirements. However, as a
* DB can hold elements that are not HCAPI we can reduce the
* req msg content by removing those out of the request yet
* the DB holds them all as to give a fast lookup. We can also
* remove entries where there are no request for elements.
*/
tf_rm_count_hcapi_reservations(parms->cfg,
parms->alloc_cnt,
parms->num_elements,
&hcapi_items);
/* Alloc request, alignment already set */
cparms.nitems = parms->num_elements;
cparms.nitems = (size_t)hcapi_items;
cparms.size = sizeof(struct tf_rm_resc_req_entry);
rc = tfp_calloc(&cparms);
if (rc)
@ -195,15 +249,24 @@ tf_rm_create_db(struct tf *tfp,
resv = (struct tf_rm_resc_entry *)cparms.mem_va;
/* Build the request */
for (i = 0; i < parms->num_elements; i++) {
for (i = 0, j = 0; i < parms->num_elements; i++) {
/* Skip any non HCAPI cfg elements */
if (parms->cfg[i].cfg_type == TF_RM_ELEM_CFG_HCAPI) {
req[i].type = parms->cfg[i].hcapi_type;
/* Check that we can get the full amount allocated */
if (parms->alloc_num[i] <=
/* Only perform reservation for entries that
* has been requested
*/
if (parms->alloc_cnt[i] == 0)
continue;
/* Verify that we can get the full amount
* allocated per the qcaps availability.
*/
if (parms->alloc_cnt[i] <=
query[parms->cfg[i].hcapi_type].max) {
req[i].min = parms->alloc_num[i];
req[i].max = parms->alloc_num[i];
req[j].type = parms->cfg[i].hcapi_type;
req[j].min = parms->alloc_cnt[i];
req[j].max = parms->alloc_cnt[i];
j++;
} else {
TFP_DRV_LOG(ERR,
"%s: Resource failure, type:%d\n",
@ -211,19 +274,16 @@ tf_rm_create_db(struct tf *tfp,
parms->cfg[i].hcapi_type);
TFP_DRV_LOG(ERR,
"req:%d, avail:%d\n",
parms->alloc_num[i],
parms->alloc_cnt[i],
query[parms->cfg[i].hcapi_type].max);
return -EINVAL;
}
} else {
/* Skip the element */
req[i].type = CFA_RESOURCE_TYPE_INVALID;
}
}
rc = tf_msg_session_resc_alloc(tfp,
parms->dir,
parms->num_elements,
hcapi_items,
req,
resv);
if (rc)
@ -246,42 +306,74 @@ tf_rm_create_db(struct tf *tfp,
rm_db->db = (struct tf_rm_element *)cparms.mem_va;
db = rm_db->db;
for (i = 0; i < parms->num_elements; i++) {
/* If allocation failed for a single entry the DB
* creation is considered a failure.
for (i = 0, j = 0; i < parms->num_elements; i++) {
db[i].cfg_type = parms->cfg[i].cfg_type;
db[i].hcapi_type = parms->cfg[i].hcapi_type;
/* Skip any non HCAPI types as we didn't include them
* in the reservation request.
*/
if (parms->alloc_num[i] != resv[i].stride) {
if (parms->cfg[i].cfg_type != TF_RM_ELEM_CFG_HCAPI)
continue;
/* If the element didn't request an allocation no need
* to create a pool nor verify if we got a reservation.
*/
if (parms->alloc_cnt[i] == 0)
continue;
/* If the element had requested an allocation and that
* allocation was a success (full amount) then
* allocate the pool.
*/
if (parms->alloc_cnt[i] == resv[j].stride) {
db[i].alloc.entry.start = resv[j].start;
db[i].alloc.entry.stride = resv[j].stride;
/* Create pool */
pool_size = (BITALLOC_SIZEOF(resv[j].stride) /
sizeof(struct bitalloc));
/* Alloc request, alignment already set */
cparms.nitems = pool_size;
cparms.size = sizeof(struct bitalloc);
rc = tfp_calloc(&cparms);
if (rc) {
TFP_DRV_LOG(ERR,
"%s: Pool alloc failed, type:%d\n",
tf_dir_2_str(parms->dir),
db[i].cfg_type);
goto fail;
}
db[i].pool = (struct bitalloc *)cparms.mem_va;
rc = ba_init(db[i].pool, resv[j].stride);
if (rc) {
TFP_DRV_LOG(ERR,
"%s: Pool init failed, type:%d\n",
tf_dir_2_str(parms->dir),
db[i].cfg_type);
goto fail;
}
j++;
} else {
/* Bail out as we want what we requested for
* all elements, not any less.
*/
TFP_DRV_LOG(ERR,
"%s: Alloc failed, type:%d\n",
tf_dir_2_str(parms->dir),
i);
db[i].cfg_type);
TFP_DRV_LOG(ERR,
"req:%d, alloc:%d\n",
parms->alloc_num[i],
resv[i].stride);
parms->alloc_cnt[i],
resv[j].stride);
goto fail;
}
db[i].cfg_type = parms->cfg[i].cfg_type;
db[i].hcapi_type = parms->cfg[i].hcapi_type;
db[i].alloc.entry.start = resv[i].start;
db[i].alloc.entry.stride = resv[i].stride;
/* Create pool */
pool_size = (BITALLOC_SIZEOF(resv[i].stride) /
sizeof(struct bitalloc));
/* Alloc request, alignment already set */
cparms.nitems = pool_size;
cparms.size = sizeof(struct bitalloc);
rc = tfp_calloc(&cparms);
if (rc)
return rc;
db[i].pool = (struct bitalloc *)cparms.mem_va;
}
rm_db->num_entries = i;
rm_db->dir = parms->dir;
parms->rm_db = (void *)rm_db;
*parms->rm_db = (void *)rm_db;
tfp_free((void *)req);
tfp_free((void *)resv);
@ -307,13 +399,15 @@ tf_rm_free_db(struct tf *tfp __rte_unused,
int i;
struct tf_rm_new_db *rm_db;
TF_CHECK_PARMS1(parms);
/* Traverse the DB and clear each pool.
* NOTE:
* Firmware is not cleared. It will be cleared on close only.
*/
rm_db = (struct tf_rm_new_db *)parms->rm_db;
for (i = 0; i < rm_db->num_entries; i++)
tfp_free((void *)rm_db->db->pool);
tfp_free((void *)rm_db->db[i].pool);
tfp_free((void *)parms->rm_db);
@ -325,11 +419,11 @@ tf_rm_allocate(struct tf_rm_allocate_parms *parms)
{
int rc = 0;
int id;
uint32_t index;
struct tf_rm_new_db *rm_db;
enum tf_rm_elem_cfg_type cfg_type;
if (parms == NULL || parms->rm_db == NULL)
return -EINVAL;
TF_CHECK_PARMS2(parms, parms->rm_db);
rm_db = (struct tf_rm_new_db *)parms->rm_db;
cfg_type = rm_db->db[parms->db_index].cfg_type;
@ -339,6 +433,17 @@ tf_rm_allocate(struct tf_rm_allocate_parms *parms)
cfg_type != TF_RM_ELEM_CFG_PRIVATE)
return -ENOTSUP;
/* Bail out if the pool is not valid, should never happen */
if (rm_db->db[parms->db_index].pool == NULL) {
rc = -ENOTSUP;
TFP_DRV_LOG(ERR,
"%s: Invalid pool for this type:%d, rc:%s\n",
tf_dir_2_str(rm_db->dir),
parms->db_index,
strerror(-rc));
return rc;
}
id = ba_alloc(rm_db->db[parms->db_index].pool);
if (id == BA_FAIL) {
TFP_DRV_LOG(ERR,
@ -353,15 +458,17 @@ tf_rm_allocate(struct tf_rm_allocate_parms *parms)
TF_RM_ADJUST_ADD_BASE,
parms->db_index,
id,
parms->index);
&index);
if (rc) {
TFP_DRV_LOG(ERR,
"%s: Alloc adjust of base index failed, rc:%s\n",
tf_dir_2_str(rm_db->dir),
strerror(-rc));
return -1;
return -EINVAL;
}
*parms->index = index;
return rc;
}
@ -373,8 +480,7 @@ tf_rm_free(struct tf_rm_free_parms *parms)
struct tf_rm_new_db *rm_db;
enum tf_rm_elem_cfg_type cfg_type;
if (parms == NULL || parms->rm_db == NULL)
return -EINVAL;
TF_CHECK_PARMS2(parms, parms->rm_db);
rm_db = (struct tf_rm_new_db *)parms->rm_db;
cfg_type = rm_db->db[parms->db_index].cfg_type;
@ -384,6 +490,17 @@ tf_rm_free(struct tf_rm_free_parms *parms)
cfg_type != TF_RM_ELEM_CFG_PRIVATE)
return -ENOTSUP;
/* Bail out if the pool is not valid, should never happen */
if (rm_db->db[parms->db_index].pool == NULL) {
rc = -ENOTSUP;
TFP_DRV_LOG(ERR,
"%s: Invalid pool for this type:%d, rc:%s\n",
tf_dir_2_str(rm_db->dir),
parms->db_index,
strerror(-rc));
return rc;
}
/* Adjust for any non zero start value */
rc = tf_rm_adjust_index(rm_db->db,
TF_RM_ADJUST_RM_BASE,
@ -409,8 +526,7 @@ tf_rm_is_allocated(struct tf_rm_is_allocated_parms *parms)
struct tf_rm_new_db *rm_db;
enum tf_rm_elem_cfg_type cfg_type;
if (parms == NULL || parms->rm_db == NULL)
return -EINVAL;
TF_CHECK_PARMS2(parms, parms->rm_db);
rm_db = (struct tf_rm_new_db *)parms->rm_db;
cfg_type = rm_db->db[parms->db_index].cfg_type;
@ -420,6 +536,17 @@ tf_rm_is_allocated(struct tf_rm_is_allocated_parms *parms)
cfg_type != TF_RM_ELEM_CFG_PRIVATE)
return -ENOTSUP;
/* Bail out if the pool is not valid, should never happen */
if (rm_db->db[parms->db_index].pool == NULL) {
rc = -ENOTSUP;
TFP_DRV_LOG(ERR,
"%s: Invalid pool for this type:%d, rc:%s\n",
tf_dir_2_str(rm_db->dir),
parms->db_index,
strerror(-rc));
return rc;
}
/* Adjust for any non zero start value */
rc = tf_rm_adjust_index(rm_db->db,
TF_RM_ADJUST_RM_BASE,
@ -442,8 +569,7 @@ tf_rm_get_info(struct tf_rm_get_alloc_info_parms *parms)
struct tf_rm_new_db *rm_db;
enum tf_rm_elem_cfg_type cfg_type;
if (parms == NULL || parms->rm_db == NULL)
return -EINVAL;
TF_CHECK_PARMS2(parms, parms->rm_db);
rm_db = (struct tf_rm_new_db *)parms->rm_db;
cfg_type = rm_db->db[parms->db_index].cfg_type;
@ -465,8 +591,7 @@ tf_rm_get_hcapi_type(struct tf_rm_get_hcapi_parms *parms)
struct tf_rm_new_db *rm_db;
enum tf_rm_elem_cfg_type cfg_type;
if (parms == NULL || parms->rm_db == NULL)
return -EINVAL;
TF_CHECK_PARMS2(parms, parms->rm_db);
rm_db = (struct tf_rm_new_db *)parms->rm_db;
cfg_type = rm_db->db[parms->db_index].cfg_type;

11
drivers/net/bnxt/tf_core/tf_rm_new.h
View File

@ -135,13 +135,16 @@ struct tf_rm_create_db_parms {
*/
struct tf_rm_element_cfg *cfg;
/**
* Allocation number array. Array size is num_elements.
* Resource allocation count array. This array content
* originates from the tf_session_resources that is passed in
* on session open.
* Array size is num_elements.
*/
uint16_t *alloc_num;
uint16_t *alloc_cnt;
/**
* [out] RM DB Handle
*/
void *rm_db;
void **rm_db;
};
/**
@ -382,7 +385,7 @@ int tf_rm_get_info(struct tf_rm_get_alloc_info_parms *parms);
/**
* Performs a lookup in the Resource Manager DB and retrieves the
* requested HCAPI type.
* requested HCAPI RM type.
*
* [in] parms
* Pointer to get hcapi parameters

28
drivers/net/bnxt/tf_core/tf_session.c
View File

@ -95,21 +95,11 @@ tf_session_open_session(struct tf *tfp,
parms->open_cfg->device_type,
session->shadow_copy,
&parms->open_cfg->resources,
session->dev);
&session->dev);
/* Logging handled by dev_bind */
if (rc)
return rc;
/* Query for Session Config
*/
rc = tf_msg_session_qcfg(tfp);
if (rc) {
TFP_DRV_LOG(ERR,
"Query config message send failed, rc:%s\n",
strerror(-rc));
goto cleanup_close;
}
session->ref_count++;
return 0;
@ -119,10 +109,6 @@ tf_session_open_session(struct tf *tfp,
tfp_free(tfp->session);
tfp->session = NULL;
return rc;
cleanup_close:
tf_close_session(tfp);
return -EINVAL;
}
int
@ -231,17 +217,7 @@ int
tf_session_get_device(struct tf_session *tfs,
struct tf_dev_info **tfd)
{
int rc;
if (tfs->dev == NULL) {
rc = -EINVAL;
TFP_DRV_LOG(ERR,
"Device not created, rc:%s\n",
strerror(-rc));
return rc;
}
*tfd = tfs->dev;
*tfd = &tfs->dev;
return 0;
}

2
drivers/net/bnxt/tf_core/tf_session.h
View File

@ -97,7 +97,7 @@ struct tf_session {
uint8_t ref_count;
/** Device handle */
struct tf_dev_info *dev;
struct tf_dev_info dev;
/** Session HW and SRAM resources */
struct tf_rm_db resc;

611
drivers/net/bnxt/tf_core/tf_tbl.c
View File

@ -761,163 +761,6 @@ tf_em_validate_num_entries(struct tf_tbl_scope_cb *tbl_scope_cb,
return 0;
}
/**
* Internal function to set a Table Entry. Supports all internal Table Types
*
* [in] tfp
* Pointer to TruFlow handle
*
* [in] parms
* Pointer to input parameters
*
* Returns:
* 0 - Success
* -EINVAL - Parameter error
*/
static int
tf_set_tbl_entry_internal(struct tf *tfp,
struct tf_set_tbl_entry_parms *parms)
{
int rc;
int id;
uint32_t index;
struct bitalloc *session_pool;
struct tf_session *tfs = (struct tf_session *)(tfp->session->core_data);
/* Lookup the pool using the table type of the element */
rc = tf_rm_lookup_tbl_type_pool(tfs,
parms->dir,
parms->type,
&session_pool);
/* Error logging handled by tf_rm_lookup_tbl_type_pool */
if (rc)
return rc;
index = parms->idx;
if (parms->type != TF_TBL_TYPE_FULL_ACT_RECORD &&
parms->type != TF_TBL_TYPE_ACT_SP_SMAC_IPV4 &&
parms->type != TF_TBL_TYPE_ACT_STATS_64) {
TFP_DRV_LOG(ERR,
"%s, Type not supported, type:%d\n",
tf_dir_2_str(parms->dir),
parms->type);
return -EOPNOTSUPP;
}
/* Adjust the returned index/offset as there is no guarantee
* that the start is 0 at time of RM allocation
*/
tf_rm_convert_index(tfs,
parms->dir,
parms->type,
TF_RM_CONVERT_RM_BASE,
parms->idx,
&index);
/* Verify that the entry has been previously allocated */
id = ba_inuse(session_pool, index);
if (id != 1) {
TFP_DRV_LOG(ERR,
"%s, Invalid or not allocated index, type:%d, idx:%d\n",
tf_dir_2_str(parms->dir),
parms->type,
index);
return -EINVAL;
}
/* Set the entry */
rc = tf_msg_set_tbl_entry(tfp,
parms->dir,
parms->type,
parms->data_sz_in_bytes,
parms->data,
parms->idx);
if (rc) {
TFP_DRV_LOG(ERR,
"%s, Set failed, type:%d, rc:%s\n",
tf_dir_2_str(parms->dir),
parms->type,
strerror(-rc));
}
return rc;
}
/**
* Internal function to get a Table Entry. Supports all Table Types
* except the TF_TBL_TYPE_EXT as that is handled as a table scope.
*
* [in] tfp
* Pointer to TruFlow handle
*
* [in] parms
* Pointer to input parameters
*
* Returns:
* 0 - Success
* -EINVAL - Parameter error
*/
static int
tf_get_tbl_entry_internal(struct tf *tfp,
struct tf_get_tbl_entry_parms *parms)
{
int rc;
int id;
uint32_t index;
struct bitalloc *session_pool;
struct tf_session *tfs = (struct tf_session *)(tfp->session->core_data);
/* Lookup the pool using the table type of the element */
rc = tf_rm_lookup_tbl_type_pool(tfs,
parms->dir,
parms->type,
&session_pool);
/* Error logging handled by tf_rm_lookup_tbl_type_pool */
if (rc)
return rc;
index = parms->idx;
/* Adjust the returned index/offset as there is no guarantee
* that the start is 0 at time of RM allocation
*/
tf_rm_convert_index(tfs,
parms->dir,
parms->type,
TF_RM_CONVERT_RM_BASE,
parms->idx,
&index);
/* Verify that the entry has been previously allocated */
id = ba_inuse(session_pool, index);
if (id != 1) {
TFP_DRV_LOG(ERR,
"%s, Invalid or not allocated index, type:%d, idx:%d\n",
tf_dir_2_str(parms->dir),
parms->type,
index);
return -EINVAL;
}
/* Get the entry */
rc = tf_msg_get_tbl_entry(tfp,
parms->dir,
parms->type,
parms->data_sz_in_bytes,
parms->data,
parms->idx);
if (rc) {
TFP_DRV_LOG(ERR,
"%s, Get failed, type:%d, rc:%s\n",
tf_dir_2_str(parms->dir),
parms->type,
strerror(-rc));
}
return rc;
}
/**
* Internal function to get a Table Entry. Supports all Table Types
* except the TF_TBL_TYPE_EXT as that is handled as a table scope.
@ -1145,266 +988,6 @@ tf_destroy_tbl_pool_external(enum tf_dir dir,
tfp_free(ext_act_pool_mem);
}
/**
* Allocate External Tbl entry from the Session Pool.
*
* [in] tfp
* Pointer to Truflow Handle
* [in] parms
* Allocation parameters
*
* Return:
* 0 - Success, entry allocated - no search support
* -ENOMEM -EINVAL -EOPNOTSUPP
* - Failure, entry not allocated, out of resources
*/
static int
tf_alloc_tbl_entry_pool_external(struct tf *tfp,
struct tf_alloc_tbl_entry_parms *parms)
{
int rc;
uint32_t index;
struct tf_session *tfs;
struct tf_tbl_scope_cb *tbl_scope_cb;
struct stack *pool;
TF_CHECK_PARMS_SESSION(tfp, parms);
tfs = (struct tf_session *)(tfp->session->core_data);
/* Get the pool info from the table scope
*/
tbl_scope_cb = tbl_scope_cb_find(tfs, parms->tbl_scope_id);
if (tbl_scope_cb == NULL) {
TFP_DRV_LOG(ERR,
"%s, table scope not allocated\n",
tf_dir_2_str(parms->dir));
return -EINVAL;
}
pool = &tbl_scope_cb->ext_act_pool[parms->dir];
/* Allocate an element
*/
rc = stack_pop(pool, &index);
if (rc != 0) {
TFP_DRV_LOG(ERR,
"%s, Allocation failed, type:%d\n",
tf_dir_2_str(parms->dir),
parms->type);
return rc;
}
parms->idx = index;
return rc;
}
/**
* Allocate Internal Tbl entry from the Session Pool.
*
* [in] tfp
* Pointer to Truflow Handle
* [in] parms
* Allocation parameters
*
* Return:
* 0 - Success, entry found and ref count decremented
* -ENOMEM - Failure, entry not allocated, out of resources
*/
static int
tf_alloc_tbl_entry_pool_internal(struct tf *tfp,
struct tf_alloc_tbl_entry_parms *parms)
{
int rc;
int id;
int free_cnt;
uint32_t index;
struct bitalloc *session_pool;
struct tf_session *tfs;
TF_CHECK_PARMS_SESSION(tfp, parms);
tfs = (struct tf_session *)(tfp->session->core_data);
if (parms->type != TF_TBL_TYPE_FULL_ACT_RECORD &&
parms->type != TF_TBL_TYPE_ACT_SP_SMAC &&
parms->type != TF_TBL_TYPE_ACT_SP_SMAC_IPV4 &&
parms->type != TF_TBL_TYPE_ACT_ENCAP_8B &&
parms->type != TF_TBL_TYPE_ACT_ENCAP_16B &&
parms->type != TF_TBL_TYPE_ACT_ENCAP_64B &&
parms->type != TF_TBL_TYPE_ACT_STATS_64) {
TFP_DRV_LOG(ERR,
"%s, Type not supported, type:%d\n",
tf_dir_2_str(parms->dir),
parms->type);
return -EOPNOTSUPP;
}
/* Lookup the pool using the table type of the element */
rc = tf_rm_lookup_tbl_type_pool(tfs,
parms->dir,
parms->type,
&session_pool);
/* Error logging handled by tf_rm_lookup_tbl_type_pool */
if (rc)
return rc;
id = ba_alloc(session_pool);
if (id == -1) {
free_cnt = ba_free_count(session_pool);
TFP_DRV_LOG(ERR,
"%s, Allocation failed, type:%d, free:%d\n",
tf_dir_2_str(parms->dir),
parms->type,
free_cnt);
return -ENOMEM;
}
/* Adjust the returned index/offset as there is no guarantee
* that the start is 0 at time of RM allocation
*/
tf_rm_convert_index(tfs,
parms->dir,
parms->type,
TF_RM_CONVERT_ADD_BASE,
id,
&index);
parms->idx = index;
return rc;
}
/**
* Free External Tbl entry to the session pool.
*
* [in] tfp
* Pointer to Truflow Handle
* [in] parms
* Allocation parameters
*
* Return:
* 0 - Success, entry freed
*
* - Failure, entry not successfully freed for these reasons
* -ENOMEM
* -EOPNOTSUPP
* -EINVAL
*/
static int
tf_free_tbl_entry_pool_external(struct tf *tfp,
struct tf_free_tbl_entry_parms *parms)
{
int rc = 0;
struct tf_session *tfs;
uint32_t index;
struct tf_tbl_scope_cb *tbl_scope_cb;
struct stack *pool;
TF_CHECK_PARMS_SESSION(tfp, parms);
tfs = (struct tf_session *)(tfp->session->core_data);
/* Get the pool info from the table scope
*/
tbl_scope_cb = tbl_scope_cb_find(tfs, parms->tbl_scope_id);
if (tbl_scope_cb == NULL) {
TFP_DRV_LOG(ERR,
"%s, table scope error\n",
tf_dir_2_str(parms->dir));
return -EINVAL;
}
pool = &tbl_scope_cb->ext_act_pool[parms->dir];
index = parms->idx;
rc = stack_push(pool, index);
if (rc != 0) {
TFP_DRV_LOG(ERR,
"%s, consistency error, stack full, type:%d, idx:%d\n",
tf_dir_2_str(parms->dir),
parms->type,
index);
}
return rc;
}
/**
* Free Internal Tbl entry from the Session Pool.
*
* [in] tfp
* Pointer to Truflow Handle
* [in] parms
* Allocation parameters
*
* Return:
* 0 - Success, entry found and ref count decremented
* -ENOMEM - Failure, entry not allocated, out of resources
*/
static int
tf_free_tbl_entry_pool_internal(struct tf *tfp,
struct tf_free_tbl_entry_parms *parms)
{
int rc = 0;
int id;
struct bitalloc *session_pool;
struct tf_session *tfs;
uint32_t index;
TF_CHECK_PARMS_SESSION(tfp, parms);
tfs = (struct tf_session *)(tfp->session->core_data);
if (parms->type != TF_TBL_TYPE_FULL_ACT_RECORD &&
parms->type != TF_TBL_TYPE_ACT_SP_SMAC &&
parms->type != TF_TBL_TYPE_ACT_SP_SMAC_IPV4 &&
parms->type != TF_TBL_TYPE_ACT_ENCAP_8B &&
parms->type != TF_TBL_TYPE_ACT_ENCAP_16B &&
parms->type != TF_TBL_TYPE_ACT_ENCAP_64B &&
parms->type != TF_TBL_TYPE_ACT_STATS_64) {
TFP_DRV_LOG(ERR,
"%s, Type not supported, type:%d\n",
tf_dir_2_str(parms->dir),
parms->type);
return -EOPNOTSUPP;
}
/* Lookup the pool using the table type of the element */
rc = tf_rm_lookup_tbl_type_pool(tfs,
parms->dir,
parms->type,
&session_pool);
/* Error logging handled by tf_rm_lookup_tbl_type_pool */
if (rc)
return rc;
index = parms->idx;
/* Adjust the returned index/offset as there is no guarantee
* that the start is 0 at time of RM allocation
*/
tf_rm_convert_index(tfs,
parms->dir,
parms->type,
TF_RM_CONVERT_RM_BASE,
parms->idx,
&index);
/* Check if element was indeed allocated */
id = ba_inuse_free(session_pool, index);
if (id == -1) {
TFP_DRV_LOG(ERR,
"%s, Element not previously alloc'ed, type:%d, idx:%d\n",
tf_dir_2_str(parms->dir),
parms->type,
index);
return -ENOMEM;
}
return rc;
}
/* API defined in tf_em.h */
struct tf_tbl_scope_cb *
tbl_scope_cb_find(struct tf_session *session,
@ -1584,113 +1167,7 @@ tf_alloc_eem_tbl_scope(struct tf *tfp,
return -EINVAL;
}
/* API defined in tf_core.h */
int
tf_set_tbl_entry(struct tf *tfp,
struct tf_set_tbl_entry_parms *parms)
{
int rc = 0;
struct tf_tbl_scope_cb *tbl_scope_cb;
struct tf_session *session;
TF_CHECK_PARMS_SESSION(tfp, parms);
if (parms->data == NULL) {
TFP_DRV_LOG(ERR,
"%s, invalid parms->data\n",
tf_dir_2_str(parms->dir));
return -EINVAL;
}
if (parms->type == TF_TBL_TYPE_EXT) {
void *base_addr;
uint32_t offset = parms->idx;
uint32_t tbl_scope_id;
session = (struct tf_session *)(tfp->session->core_data);
tbl_scope_id = parms->tbl_scope_id;
if (tbl_scope_id == TF_TBL_SCOPE_INVALID) {
TFP_DRV_LOG(ERR,
"%s, Table scope not allocated\n",
tf_dir_2_str(parms->dir));
return -EINVAL;
}
/* Get the table scope control block associated with the
* external pool
*/
tbl_scope_cb = tbl_scope_cb_find(session, tbl_scope_id);
if (tbl_scope_cb == NULL) {
TFP_DRV_LOG(ERR,
"%s, table scope error\n",
tf_dir_2_str(parms->dir));
return -EINVAL;
}
/* External table, implicitly the Action table */
base_addr = (void *)(uintptr_t)
hcapi_get_table_page(&tbl_scope_cb->em_ctx_info[parms->dir].em_tables[TF_RECORD_TABLE], offset);
if (base_addr == NULL) {
TFP_DRV_LOG(ERR,
"%s, Base address lookup failed\n",
tf_dir_2_str(parms->dir));
return -EINVAL;
}
offset %= TF_EM_PAGE_SIZE;
rte_memcpy((char *)base_addr + offset,
parms->data,
parms->data_sz_in_bytes);
} else {
/* Internal table type processing */
rc = tf_set_tbl_entry_internal(tfp, parms);
if (rc) {
TFP_DRV_LOG(ERR,
"%s, Set failed, type:%d, rc:%s\n",
tf_dir_2_str(parms->dir),
parms->type,
strerror(-rc));
}
}
return rc;
}
/* API defined in tf_core.h */
int
tf_get_tbl_entry(struct tf *tfp,
struct tf_get_tbl_entry_parms *parms)
{
int rc = 0;
TF_CHECK_PARMS_SESSION(tfp, parms);
if (parms->type == TF_TBL_TYPE_EXT) {
/* Not supported, yet */
TFP_DRV_LOG(ERR,
"%s, External table type not supported\n",
tf_dir_2_str(parms->dir));
rc = -EOPNOTSUPP;
} else {
/* Internal table type processing */
rc = tf_get_tbl_entry_internal(tfp, parms);
if (rc)
TFP_DRV_LOG(ERR,
"%s, Get failed, type:%d, rc:%s\n",
tf_dir_2_str(parms->dir),
parms->type,
strerror(-rc));
}
return rc;
}
/* API defined in tf_core.h */
/* API defined in tf_core.h */
int
tf_bulk_get_tbl_entry(struct tf *tfp,
struct tf_bulk_get_tbl_entry_parms *parms)
@ -1749,92 +1226,6 @@ tf_free_tbl_scope(struct tf *tfp,
return rc;
}
/* API defined in tf_core.h */
int
tf_alloc_tbl_entry(struct tf *tfp,
struct tf_alloc_tbl_entry_parms *parms)
{
int rc;
#if (TF_SHADOW == 1)
struct tf_session *tfs;
#endif /* TF_SHADOW */
TF_CHECK_PARMS_SESSION(tfp, parms);
/*
* No shadow copy support for external tables, allocate and return
*/
if (parms->type == TF_TBL_TYPE_EXT) {
rc = tf_alloc_tbl_entry_pool_external(tfp, parms);
return rc;
}
#if (TF_SHADOW == 1)
tfs = (struct tf_session *)(tfp->session->core_data);
/* Search the Shadow DB for requested element. If not found go
* allocate one from the Session Pool
*/
if (parms->search_enable && tfs->shadow_copy) {
rc = tf_alloc_tbl_entry_shadow(tfs, parms);
/* Entry found and parms populated with return data */
if (rc == 0)
return rc;
}
#endif /* TF_SHADOW */
rc = tf_alloc_tbl_entry_pool_internal(tfp, parms);
if (rc)
TFP_DRV_LOG(ERR, "%s, Alloc failed, rc:%s\n",
tf_dir_2_str(parms->dir),
strerror(-rc));
return rc;
}
/* API defined in tf_core.h */
int
tf_free_tbl_entry(struct tf *tfp,
struct tf_free_tbl_entry_parms *parms)
{
int rc;
#if (TF_SHADOW == 1)
struct tf_session *tfs;
#endif /* TF_SHADOW */
TF_CHECK_PARMS_SESSION(tfp, parms);
/*
* No shadow of external tables so just free the entry
*/
if (parms->type == TF_TBL_TYPE_EXT) {
rc = tf_free_tbl_entry_pool_external(tfp, parms);
return rc;
}
#if (TF_SHADOW == 1)
tfs = (struct tf_session *)(tfp->session->core_data);
/* Search the Shadow DB for requested element. If not found go
* allocate one from the Session Pool
*/
if (parms->search_enable && tfs->shadow_copy) {
rc = tf_free_tbl_entry_shadow(tfs, parms);
/* Entry free'ed and parms populated with return data */
if (rc == 0)
return rc;
}
#endif /* TF_SHADOW */
rc = tf_free_tbl_entry_pool_internal(tfp, parms);
if (rc)
TFP_DRV_LOG(ERR, "%s, Alloc failed, rc:%s\n",
tf_dir_2_str(parms->dir),
strerror(-rc));
return rc;
}
static void
tf_dump_link_page_table(struct hcapi_cfa_em_page_tbl *tp,
struct hcapi_cfa_em_page_tbl *tp_next)

252
drivers/net/bnxt/tf_core/tf_tbl_type.c
View File

@ -6,13 +6,18 @@
#include <rte_common.h>
#include "tf_tbl_type.h"
#include "tf_common.h"
#include "tf_rm_new.h"
#include "tf_util.h"
#include "tf_msg.h"
#include "tfp.h"
struct tf;
/**
* Table DBs.
*/
/* static void *tbl_db[TF_DIR_MAX]; */
static void *tbl_db[TF_DIR_MAX];
/**
* Table Shadow DBs
@ -22,7 +27,7 @@ struct tf;
/**
* Init flag, set on bind and cleared on unbind
*/
/* static uint8_t init; */
static uint8_t init;
/**
* Shadow init flag, set on bind and cleared on unbind
@ -30,29 +35,164 @@ struct tf;
/* static uint8_t shadow_init; */
int
tf_tbl_bind(struct tf *tfp __rte_unused,
struct tf_tbl_cfg_parms *parms __rte_unused)
tf_tbl_bind(struct tf *tfp,
struct tf_tbl_cfg_parms *parms)
{
int rc;
int i;
struct tf_rm_create_db_parms db_cfg = { 0 };
TF_CHECK_PARMS2(tfp, parms);
if (init) {
TFP_DRV_LOG(ERR,
"Table already initialized\n");
return -EINVAL;
}
db_cfg.num_elements = parms->num_elements;
for (i = 0; i < TF_DIR_MAX; i++) {
db_cfg.dir = i;
db_cfg.num_elements = parms->num_elements;
db_cfg.cfg = parms->cfg;
db_cfg.alloc_cnt = parms->resources->tbl_cnt[i].cnt;
db_cfg.rm_db = &tbl_db[i];
rc = tf_rm_create_db(tfp, &db_cfg);
if (rc) {
TFP_DRV_LOG(ERR,
"%s: Table DB creation failed\n",
tf_dir_2_str(i));
return rc;
}
}
init = 1;
printf("Table Type - initialized\n");
return 0;
}
int
tf_tbl_unbind(struct tf *tfp __rte_unused)
{
int rc;
int i;
struct tf_rm_free_db_parms fparms = { 0 };
TF_CHECK_PARMS1(tfp);
/* Bail if nothing has been initialized done silent as to
* allow for creation cleanup.
*/
if (!init) {
TFP_DRV_LOG(ERR,
"No Table DBs created\n");
return -EINVAL;
}
for (i = 0; i < TF_DIR_MAX; i++) {
fparms.dir = i;
fparms.rm_db = tbl_db[i];
rc = tf_rm_free_db(tfp, &fparms);
if (rc)
return rc;
tbl_db[i] = NULL;
}
init = 0;
return 0;
}
int
tf_tbl_alloc(struct tf *tfp __rte_unused,
struct tf_tbl_alloc_parms *parms __rte_unused)
struct tf_tbl_alloc_parms *parms)
{
int rc;
uint32_t idx;
struct tf_rm_allocate_parms aparms = { 0 };
TF_CHECK_PARMS2(tfp, parms);
if (!init) {
TFP_DRV_LOG(ERR,
"%s: No Table DBs created\n",
tf_dir_2_str(parms->dir));
return -EINVAL;
}
/* Allocate requested element */
aparms.rm_db = tbl_db[parms->dir];
aparms.db_index = parms->type;
aparms.index = &idx;
rc = tf_rm_allocate(&aparms);
if (rc) {
TFP_DRV_LOG(ERR,
"%s: Failed allocate, type:%d\n",
tf_dir_2_str(parms->dir),
parms->type);
return rc;
}
*parms->idx = idx;
return 0;
}
int
tf_tbl_free(struct tf *tfp __rte_unused,
struct tf_tbl_free_parms *parms __rte_unused)
struct tf_tbl_free_parms *parms)
{
int rc;
struct tf_rm_is_allocated_parms aparms = { 0 };
struct tf_rm_free_parms fparms = { 0 };
int allocated = 0;
TF_CHECK_PARMS2(tfp, parms);
if (!init) {
TFP_DRV_LOG(ERR,
"%s: No Table DBs created\n",
tf_dir_2_str(parms->dir));
return -EINVAL;
}
/* Check if element is in use */
aparms.rm_db = tbl_db[parms->dir];
aparms.db_index = parms->type;
aparms.index = parms->idx;
aparms.allocated = &allocated;
rc = tf_rm_is_allocated(&aparms);
if (rc)
return rc;
if (!allocated) {
TFP_DRV_LOG(ERR,
"%s: Entry already free, type:%d, index:%d\n",
tf_dir_2_str(parms->dir),
parms->type,
parms->idx);
return rc;
}
/* Free requested element */
fparms.rm_db = tbl_db[parms->dir];
fparms.db_index = parms->type;
fparms.index = parms->idx;
rc = tf_rm_free(&fparms);
if (rc) {
TFP_DRV_LOG(ERR,
"%s: Free failed, type:%d, index:%d\n",
tf_dir_2_str(parms->dir),
parms->type,
parms->idx);
return rc;
}
return 0;
}
@ -64,15 +204,107 @@ tf_tbl_alloc_search(struct tf *tfp __rte_unused,
}
int
tf_tbl_set(struct tf *tfp __rte_unused,
struct tf_tbl_set_parms *parms __rte_unused)
tf_tbl_set(struct tf *tfp,
struct tf_tbl_set_parms *parms)
{
int rc;
struct tf_rm_is_allocated_parms aparms;
int allocated = 0;
TF_CHECK_PARMS3(tfp, parms, parms->data);
if (!init) {
TFP_DRV_LOG(ERR,
"%s: No Table DBs created\n",
tf_dir_2_str(parms->dir));
return -EINVAL;
}
/* Verify that the entry has been previously allocated */
aparms.rm_db = tbl_db[parms->dir];
aparms.db_index = parms->type;
aparms.index = parms->idx;
aparms.allocated = &allocated;
rc = tf_rm_is_allocated(&aparms);
if (rc)
return rc;
if (!allocated) {
TFP_DRV_LOG(ERR,
"%s, Invalid or not allocated index, type:%d, idx:%d\n",
tf_dir_2_str(parms->dir),
parms->type,
parms->idx);
return -EINVAL;
}
/* Set the entry */
rc = tf_msg_set_tbl_entry(tfp,
parms->dir,
parms->type,
parms->data_sz_in_bytes,
parms->data,
parms->idx);
if (rc) {
TFP_DRV_LOG(ERR,
"%s, Set failed, type:%d, rc:%s\n",
tf_dir_2_str(parms->dir),
parms->type,
strerror(-rc));
}
return 0;
}
int
tf_tbl_get(struct tf *tfp __rte_unused,
struct tf_tbl_get_parms *parms __rte_unused)
tf_tbl_get(struct tf *tfp,
struct tf_tbl_get_parms *parms)
{
int rc;
struct tf_rm_is_allocated_parms aparms;
int allocated = 0;
TF_CHECK_PARMS3(tfp, parms, parms->data);
if (!init) {
TFP_DRV_LOG(ERR,
"%s: No Table DBs created\n",
tf_dir_2_str(parms->dir));
return -EINVAL;
}
/* Verify that the entry has been previously allocated */
aparms.rm_db = tbl_db[parms->dir];
aparms.db_index = parms->type;
aparms.index = parms->idx;
aparms.allocated = &allocated;
rc = tf_rm_is_allocated(&aparms);
if (rc)
return rc;
if (!allocated) {
TFP_DRV_LOG(ERR,
"%s, Invalid or not allocated index, type:%d, idx:%d\n",
tf_dir_2_str(parms->dir),
parms->type,
parms->idx);
return -EINVAL;
}
/* Get the entry */
rc = tf_msg_get_tbl_entry(tfp,
parms->dir,
parms->type,
parms->data_sz_in_bytes,
parms->data,
parms->idx);
if (rc) {
TFP_DRV_LOG(ERR,
"%s, Get failed, type:%d, rc:%s\n",
tf_dir_2_str(parms->dir),
parms->type,
strerror(-rc));
}
return 0;
}

2
drivers/net/bnxt/tf_core/tf_tbl_type.h
View File

@ -55,7 +55,7 @@ struct tf_tbl_alloc_parms {
/**
* [out] Idx of allocated entry or found entry (if search_enable)
*/
uint32_t idx;
uint32_t *idx;
};
/**

12
drivers/net/bnxt/tf_core/tf_tcam.c
View File

@ -38,8 +38,8 @@ static uint8_t init;
/* static uint8_t shadow_init; */
int
tf_tcam_bind(struct tf *tfp __rte_unused,
struct tf_tcam_cfg_parms *parms __rte_unused)
tf_tcam_bind(struct tf *tfp,
struct tf_tcam_cfg_parms *parms)
{
int rc;
int i;
@ -59,8 +59,8 @@ tf_tcam_bind(struct tf *tfp __rte_unused,
db_cfg.dir = i;
db_cfg.num_elements = parms->num_elements;
db_cfg.cfg = parms->cfg;
db_cfg.alloc_num = parms->resources->tcam_tbl_cnt[i];
db_cfg.rm_db = tcam_db[i];
db_cfg.alloc_cnt = parms->resources->tcam_cnt[i].cnt;
db_cfg.rm_db = &tcam_db[i];
rc = tf_rm_create_db(tfp, &db_cfg);
if (rc) {
TFP_DRV_LOG(ERR,
@ -72,11 +72,13 @@ tf_tcam_bind(struct tf *tfp __rte_unused,
init = 1;
printf("TCAM - initialized\n");
return 0;
}
int
tf_tcam_unbind(struct tf *tfp __rte_unused)
tf_tcam_unbind(struct tf *tfp)
{
int rc;
int i;

45
drivers/net/bnxt/tf_core/tf_util.h
View File

@ -10,32 +10,57 @@
/**
* Helper function converting direction to text string
*
* [in] dir
* Receive or transmit direction identifier
*
* Returns:
* Pointer to a char string holding the string for the direction
*/
const char
*tf_dir_2_str(enum tf_dir dir);
const char *tf_dir_2_str(enum tf_dir dir);
/**
* Helper function converting identifier to text string
*
* [in] id_type
* Identifier type
*
* Returns:
* Pointer to a char string holding the string for the identifier
*/
const char
*tf_ident_2_str(enum tf_identifier_type id_type);
const char *tf_ident_2_str(enum tf_identifier_type id_type);
/**
* Helper function converting tcam type to text string
*
* [in] tcam_type
* TCAM type
*
* Returns:
* Pointer to a char string holding the string for the tcam
*/
const char
*tf_tcam_tbl_2_str(enum tf_tcam_tbl_type tcam_type);
const char *tf_tcam_tbl_2_str(enum tf_tcam_tbl_type tcam_type);
/**
* Helper function converting tbl type to text string
*
* [in] tbl_type
* Table type
*
* Returns:
* Pointer to a char string holding the string for the table type
*/
const char
*tf_tbl_type_2_str(enum tf_tbl_type tbl_type);
const char *tf_tbl_type_2_str(enum tf_tbl_type tbl_type);
/**
* Helper function converting em tbl type to text string
*
* [in] em_type
* EM type
*
* Returns:
* Pointer to a char string holding the string for the EM type
*/
const char
*tf_em_tbl_type_2_str(enum tf_em_tbl_type em_type);
const char *tf_em_tbl_type_2_str(enum tf_em_tbl_type em_type);
#endif /* _TF_UTIL_H_ */

4
drivers/net/bnxt/tf_core/tfp.c
View File

@ -102,13 +102,13 @@ tfp_calloc(struct tfp_calloc_parms *parms)
(parms->nitems * parms->size),
parms->alignment);
if (parms->mem_va == NULL) {
PMD_DRV_LOG(ERR, "Allocate failed mem_va\n");
TFP_DRV_LOG(ERR, "Allocate failed mem_va\n");
return -ENOMEM;
}
parms->mem_pa = (void *)((uintptr_t)rte_mem_virt2iova(parms->mem_va));
if (parms->mem_pa == (void *)((uintptr_t)RTE_BAD_IOVA)) {
PMD_DRV_LOG(ERR, "Allocate failed mem_pa\n");
TFP_DRV_LOG(ERR, "Allocate failed mem_pa\n");
return -ENOMEM;
}