X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=drivers%2Fnet%2Fbnxt%2Ftf_core%2Ftf_rm.c;h=dd537aaececc1950ab9bad3f2d9ca8e3fd620a9d;hb=53a80512644c8a12cb8efc903f77dd7b42263565;hp=0a46e2a343a53d3052ee77938c272bf993f32642;hpb=31a2db5a177649f4b979e148c89d9f248c0ca97a;p=dpdk.git diff --git a/drivers/net/bnxt/tf_core/tf_rm.c b/drivers/net/bnxt/tf_core/tf_rm.c index 0a46e2a343..dd537aaece 100644 --- a/drivers/net/bnxt/tf_core/tf_rm.c +++ b/drivers/net/bnxt/tf_core/tf_rm.c @@ -18,6 +18,9 @@ #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. */ @@ -34,6 +37,12 @@ struct tf_rm_element { */ 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. */ @@ -201,6 +210,45 @@ tf_rm_adjust_index(struct tf_rm_element *db, 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. + */ +#if (TF_RM_DEBUG == 1) +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(INFO, + "%s, %s was not cleaned up, %d outstanding\n", + tf_dir_2_str(dir), + tf_module_subtype_2_str(module, i), + residuals[i]); + } +} +#endif /* TF_RM_DEBUG == 1 */ /** * 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 @@ -316,6 +364,12 @@ tf_rm_check_residuals(struct tf_rm_new_db *rm_db, *resv_size = found; } +#if (TF_RM_DEBUG == 1) + tf_rm_log_residuals(rm_db->dir, + rm_db->module, + rm_db->num_entries, + residuals); +#endif tfp_free((void *)residuals); *resv = local_resv; @@ -356,12 +410,16 @@ tf_rm_check_residuals(struct tf_rm_new_db *rm_db, * - - 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) + uint16_t *req_cnt, + bool shared_session) { int parent, child; + const char *type_str; /* Search through all the elements */ for (parent = 0; parent < num_elements; parent++) { @@ -369,31 +427,62 @@ tf_rm_update_parent_reservations(struct tf_rm_element_cfg *cfg, /* If I am a parent */ if (cfg[parent].cfg_type == TF_RM_ELEM_CFG_HCAPI_BA_PARENT) { - /* start with my own count */ - RTE_ASSERT(cfg[parent].slices); - combined_cnt = - alloc_cnt[parent] / cfg[parent].slices; + uint8_t p_slices = 1; - if (alloc_cnt[parent] % cfg[parent].slices) + /* Shared session doesn't support slices */ + if (!shared_session) + p_slices = cfg[parent].slices; + + RTE_ASSERT(p_slices); + + combined_cnt = alloc_cnt[parent] / p_slices; + + if (alloc_cnt[parent] % p_slices) combined_cnt++; + if (alloc_cnt[parent]) { + dev->ops->tf_dev_get_resource_str(tfp, + cfg[parent].hcapi_type, + &type_str); +#if (TF_RM_DEBUG == 1) + printf("%s:%s cnt(%d) slices(%d)\n", + type_str, tf_tbl_type_2_str(parent), + alloc_cnt[parent], p_slices); +#endif /* (TF_RM_DEBUG == 1) */ + } + /* 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]) { + uint8_t c_slices = 1; uint16_t cnt = 0; - RTE_ASSERT(cfg[child].slices); + if (!shared_session) + c_slices = cfg[child].slices; + + RTE_ASSERT(c_slices); + + dev->ops->tf_dev_get_resource_str(tfp, + cfg[child].hcapi_type, + &type_str); +#if (TF_RM_DEBUG == 1) + printf("%s:%s cnt(%d) slices(%d)\n", + type_str, + tf_tbl_type_2_str(child), + alloc_cnt[child], + c_slices); +#endif /* (TF_RM_DEBUG == 1) */ /* Increment the parents combined count * with each child's count adjusted for - * number of slices per RM allocated item. + * number of slices per RM alloc item. */ - cnt = - alloc_cnt[child] / cfg[child].slices; + cnt = alloc_cnt[child] / c_slices; - if (alloc_cnt[child] % cfg[child].slices) + if (alloc_cnt[child] % c_slices) cnt++; combined_cnt += cnt; @@ -403,6 +492,10 @@ tf_rm_update_parent_reservations(struct tf_rm_element_cfg *cfg, } /* Save the parent count to be requested */ req_cnt[parent] = combined_cnt; +#if (TF_RM_DEBUG == 1) + printf("%s calculated total:%d\n\n", + type_str, req_cnt[parent]); +#endif /* (TF_RM_DEBUG == 1) */ } } return 0; @@ -425,6 +518,7 @@ tf_rm_create_db(struct tf *tfp, struct tf_rm_new_db *rm_db; struct tf_rm_element *db; uint32_t pool_size; + bool shared_session = 0; TF_CHECK_PARMS2(tfp, parms); @@ -441,7 +535,6 @@ tf_rm_create_db(struct tf *tfp, /* Need device max number of elements for the RM QCAPS */ rc = dev->ops->tf_dev_get_max_types(tfp, &max_types); - /* Allocate memory for RM QCAPS request */ cparms.nitems = max_types; cparms.size = sizeof(struct tf_rm_resc_req_entry); @@ -477,12 +570,15 @@ tf_rm_create_db(struct tf *tfp, tfp_memcpy(req_cnt, parms->alloc_cnt, parms->num_elements * sizeof(uint16_t)); + shared_session = tf_session_is_shared_session(tfs); + /* 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); + req_cnt, + shared_session); /* Process capabilities against DB requirements. However, as a * DB can hold elements that are not HCAPI we can reduce the @@ -498,6 +594,12 @@ tf_rm_create_db(struct tf *tfp, &hcapi_items); if (hcapi_items == 0) { +#if (TF_RM_DEBUG == 1) + TFP_DRV_LOG(INFO, + "%s: module: %s Empty RM DB create request\n", + tf_dir_2_str(parms->dir), + tf_module_2_str(parms->module)); +#endif parms->rm_db = NULL; return -ENOMEM; } @@ -546,11 +648,11 @@ tf_rm_create_db(struct tf *tfp, hcapi_type, &type_str); TFP_DRV_LOG(ERR, - "Failure, %s:%d:%s req:%d avail:%d\n", - tf_dir_2_str(parms->dir), - hcapi_type, type_str, - req_cnt[i], - query[hcapi_type].max); + "Failure, %s:%d:%s req:%d avail:%d\n", + tf_dir_2_str(parms->dir), + hcapi_type, type_str, + req_cnt[i], + query[hcapi_type].max); return -EINVAL; } } @@ -594,6 +696,7 @@ tf_rm_create_db(struct tf *tfp, 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 */ @@ -669,6 +772,13 @@ tf_rm_create_db(struct tf *tfp, rm_db->module = parms->module; *parms->rm_db = (void *)rm_db; +#if (TF_RM_DEBUG == 1) + + printf("%s: module:%s\n", + tf_dir_2_str(parms->dir), + tf_module_2_str(parms->module)); +#endif /* (TF_RM_DEBUG == 1) */ + tfp_free((void *)req); tfp_free((void *)resv); tfp_free((void *)req_cnt); @@ -902,6 +1012,13 @@ tf_rm_create_db_no_reservation(struct tf *tfp, rm_db->module = parms->module; *parms->rm_db = (void *)rm_db; +#if (TF_RM_DEBUG == 1) + + printf("%s: module:%s\n", + tf_dir_2_str(parms->dir), + tf_module_2_str(parms->module)); +#endif /* (TF_RM_DEBUG == 1) */ + tfp_free((void *)req); tfp_free((void *)resv); tfp_free((void *)req_cnt); @@ -1165,7 +1282,6 @@ tf_rm_is_allocated(struct tf_rm_is_allocated_parms *parms) cfg_type = rm_db->db[parms->subtype].cfg_type; - /* Bail out if not controlled by RM */ if (cfg_type != TF_RM_ELEM_CFG_HCAPI_BA && cfg_type != TF_RM_ELEM_CFG_HCAPI_BA_PARENT && @@ -1271,6 +1387,26 @@ tf_rm_get_hcapi_type(struct tf_rm_get_hcapi_parms *parms) 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)