#include "tfp.h"
#include "tf_msg.h"
-/* Logging defines */
-#define TF_RM_DEBUG 0
-
/**
* Generic RM Element data type that an RM DB is build upon.
*/
*/
uint16_t hcapi_type;
+ /**
+ * Resource slices. How many slices will fit in the
+ * resource pool chunk size.
+ */
+ uint8_t slices;
+
/**
* HCAPI RM allocated range information for the element.
*/
return rc;
}
-/**
- * Logs an array of found residual entries to the console.
- *
- * [in] dir
- * Receive or transmit direction
- *
- * [in] module
- * Type of Device Module
- *
- * [in] count
- * Number of entries in the residual array
- *
- * [in] residuals
- * Pointer to an array of residual entries. Array is index same as
- * the DB in which this function is used. Each entry holds residual
- * value for that entry.
- */
-static void
-tf_rm_log_residuals(enum tf_dir dir,
- enum tf_module_type module,
- uint16_t count,
- uint16_t *residuals)
-{
- int i;
-
- /* Walk the residual array and log the types that wasn't
- * cleaned up to the console.
- */
- for (i = 0; i < count; i++) {
- if (residuals[i] != 0)
- TFP_DRV_LOG(ERR,
- "%s, %s was not cleaned up, %d outstanding\n",
- tf_dir_2_str(dir),
- tf_module_subtype_2_str(module, i),
- residuals[i]);
- }
-}
-
/**
* Performs a check of the passed in DB for any lingering elements. If
* a resource type was found to not have been cleaned up by the caller
*resv_size = found;
}
- tf_rm_log_residuals(rm_db->dir,
- rm_db->module,
- rm_db->num_entries,
- residuals);
-
tfp_free((void *)residuals);
*resv = local_resv;
* - - Failure if negative
*/
static int
-tf_rm_update_parent_reservations(struct tf_rm_element_cfg *cfg,
+tf_rm_update_parent_reservations(struct tf *tfp,
+ struct tf_dev_info *dev,
+ struct tf_rm_element_cfg *cfg,
uint16_t *alloc_cnt,
uint16_t num_elements,
uint16_t *req_cnt)
{
int parent, child;
+ const char *type_str;
/* Search through all the elements */
for (parent = 0; parent < num_elements; parent++) {
if (alloc_cnt[parent] % cfg[parent].slices)
combined_cnt++;
+ if (alloc_cnt[parent]) {
+ dev->ops->tf_dev_get_resource_str(tfp,
+ cfg[parent].hcapi_type,
+ &type_str);
+ }
+
/* Search again through all the elements */
for (child = 0; child < num_elements; child++) {
/* If this is one of my children */
if (cfg[child].cfg_type ==
TF_RM_ELEM_CFG_HCAPI_BA_CHILD &&
- cfg[child].parent_subtype == parent) {
+ cfg[child].parent_subtype == parent &&
+ alloc_cnt[child]) {
uint16_t cnt = 0;
RTE_ASSERT(cfg[child].slices);
+ dev->ops->tf_dev_get_resource_str(tfp,
+ cfg[child].hcapi_type,
+ &type_str);
/* Increment the parents combined count
* with each child's count adjusted for
* number of slices per RM allocated item.
/* Update the req_cnt based upon the element configuration
*/
- tf_rm_update_parent_reservations(parms->cfg,
+ tf_rm_update_parent_reservations(tfp, dev, parms->cfg,
parms->alloc_cnt,
parms->num_elements,
req_cnt);
&hcapi_items);
if (hcapi_items == 0) {
- TFP_DRV_LOG(ERR,
- "%s: module:%s Empty RM DB create request\n",
- tf_dir_2_str(parms->dir),
- tf_module_2_str(parms->module));
-
parms->rm_db = NULL;
return -ENOMEM;
}
db[i].cfg_type = cfg->cfg_type;
db[i].hcapi_type = cfg->hcapi_type;
+ db[i].slices = cfg->slices;
/* Save the parent subtype for later use to find the pool
*/
/* Only allocate BA pool if a BA type not a child */
if (cfg->cfg_type == TF_RM_ELEM_CFG_HCAPI_BA ||
cfg->cfg_type == TF_RM_ELEM_CFG_HCAPI_BA_PARENT) {
- if (cfg->divider) {
- resv[j].stride =
- resv[j].stride / cfg->divider;
- if (resv[j].stride <= 0) {
- TFP_DRV_LOG(ERR,
- "%s:Divide fails:%d:%s\n",
- tf_dir_2_str(parms->dir),
- cfg->hcapi_type, type_str);
- goto fail;
- }
- }
/* Create pool */
pool_size = (BITALLOC_SIZEOF(resv[j].stride) /
sizeof(struct bitalloc));
/* Only allocate BA pool if a BA type not a child */
if (cfg->cfg_type == TF_RM_ELEM_CFG_HCAPI_BA ||
cfg->cfg_type == TF_RM_ELEM_CFG_HCAPI_BA_PARENT) {
- if (cfg->divider) {
- resv[j].stride =
- resv[j].stride / cfg->divider;
- if (resv[j].stride <= 0) {
- TFP_DRV_LOG(ERR,
- "%s:Divide fails:%d:%s\n",
- tf_dir_2_str(parms->dir),
- cfg->hcapi_type, type_str);
- goto fail;
- }
- }
/* Create pool */
pool_size = (BITALLOC_SIZEOF(resv[j].stride) /
sizeof(struct bitalloc));
struct tf_rm_alloc_info *info = parms->info;
int i;
- TF_CHECK_PARMS2(parms, parms->rm_db);
+ TF_CHECK_PARMS1(parms);
+
+ /* No rm info available for this module type
+ */
+ if (!parms->rm_db)
+ return -ENOMEM;
+
rm_db = (struct tf_rm_new_db *)parms->rm_db;
TF_CHECK_PARMS1(rm_db->db);
return 0;
}
+int
+tf_rm_get_slices(struct tf_rm_get_slices_parms *parms)
+{
+ struct tf_rm_new_db *rm_db;
+ enum tf_rm_elem_cfg_type cfg_type;
+
+ TF_CHECK_PARMS2(parms, parms->rm_db);
+ rm_db = (struct tf_rm_new_db *)parms->rm_db;
+ TF_CHECK_PARMS1(rm_db->db);
+
+ cfg_type = rm_db->db[parms->subtype].cfg_type;
+
+ /* Bail out if not controlled by HCAPI */
+ if (cfg_type == TF_RM_ELEM_CFG_NULL)
+ return -ENOTSUP;
+
+ *parms->slices = rm_db->db[parms->subtype].slices;
+
+ return 0;
+}
int
tf_rm_get_inuse_count(struct tf_rm_get_inuse_count_parms *parms)