diff --git a/drivers/net/bnxt/tf_core/tf_em_internal.c b/drivers/net/bnxt/tf_core/tf_em_internal.c
index 2d57595f17..67ba011eae 100644
--- a/drivers/net/bnxt/tf_core/tf_em_internal.c
+++ b/drivers/net/bnxt/tf_core/tf_em_internal.c
@@ -326,8 +326,11 @@ tf_em_int_unbind(struct tf *tfp)
 		return rc;
 
 	if (!tf_session_is_shared_session(tfs)) {
-		for (i = 0; i < TF_DIR_MAX; i++)
+		for (i = 0; i < TF_DIR_MAX; i++) {
+			if (tfs->em_pool[i] == NULL)
+				continue;
 			dpool_free_all(tfs->em_pool[i]);
+		}
 	}
 
 	rc = tf_session_get_db(tfp, TF_MODULE_TYPE_EM, &em_db_ptr);
diff --git a/drivers/net/bnxt/tf_core/tf_rm.c b/drivers/net/bnxt/tf_core/tf_rm.c
index 03c958a7d6..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.
  */
@@ -207,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
@@ -322,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;
 
@@ -367,7 +415,8 @@ tf_rm_update_parent_reservations(struct tf *tfp,
 				 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;
@@ -378,18 +427,28 @@ tf_rm_update_parent_reservations(struct tf *tfp,
 
 		/* 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;
+
+			/* Shared session doesn't support slices */
+			if (!shared_session)
+				p_slices = cfg[parent].slices;
+
+			RTE_ASSERT(p_slices);
 
-			if (alloc_cnt[parent] % cfg[parent].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 */
@@ -399,20 +458,31 @@ tf_rm_update_parent_reservations(struct tf *tfp,
 				    TF_RM_ELEM_CFG_HCAPI_BA_CHILD &&
 				    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;
@@ -422,6 +492,10 @@ tf_rm_update_parent_reservations(struct tf *tfp,
 			}
 			/* 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;
@@ -444,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);
 
@@ -460,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);
@@ -496,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(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
@@ -517,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;
 	}
@@ -565,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;
 			}
 		}
@@ -689,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);
@@ -922,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);
@@ -1185,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 &&
diff --git a/drivers/net/bnxt/tf_core/tf_tbl_sram.c b/drivers/net/bnxt/tf_core/tf_tbl_sram.c
index d7727f7a11..167078a8c6 100644
--- a/drivers/net/bnxt/tf_core/tf_tbl_sram.c
+++ b/drivers/net/bnxt/tf_core/tf_tbl_sram.c
@@ -21,6 +21,10 @@
 
 #define DBG_SRAM 0
 
+#define TF_TBL_PTR_TO_RM(new_idx, idx, base, shift) {		\
+		*(new_idx) = (((idx) >> (shift)) - (base));	\
+}
+
 /**
  * tf_sram_tbl_get_info_parms parameter definition
  */
@@ -394,6 +398,7 @@ tf_tbl_sram_set(struct tf *tfp,
 {
 	int rc;
 	bool allocated = 0;
+	int rallocated = 0;
 	uint16_t hcapi_type;
 	struct tf_rm_get_hcapi_parms hparms = { 0 };
 	struct tf_session *tfs;
@@ -402,7 +407,9 @@ tf_tbl_sram_set(struct tf *tfp,
 	void *tbl_db_ptr = NULL;
 	struct tf_tbl_sram_get_info_parms iparms = { 0 };
 	struct tf_sram_mgr_is_allocated_parms aparms = { 0 };
+	struct tf_rm_is_allocated_parms raparms = { 0 };
 	void *sram_handle = NULL;
+	uint16_t base = 0, shift = 0;
 
 
 	TF_CHECK_PARMS3(tfp, parms, parms->data);
@@ -442,23 +449,57 @@ tf_tbl_sram_set(struct tf *tfp,
 		return rc;
 	}
 
-	aparms.sram_offset = parms->idx;
-	aparms.slice_size = iparms.slice_size;
-	aparms.bank_id = iparms.bank_id;
-	aparms.dir = parms->dir;
-	aparms.is_allocated = &allocated;
-	rc = tf_sram_mgr_is_allocated(sram_handle, &aparms);
-	if (rc || !allocated) {
-		TFP_DRV_LOG(ERR,
-			    "%s: Entry not allocated:%s idx(%d):(%s)\n",
-			    tf_dir_2_str(parms->dir),
-			    tf_tbl_type_2_str(parms->type),
-			    parms->idx,
-			    strerror(-rc));
-		rc = -ENOMEM;
-		return rc;
+	if (tf_session_is_shared_session(tfs)) {
+		/* Only get table info if required for the device */
+		if (dev->ops->tf_dev_get_tbl_info) {
+			rc = dev->ops->tf_dev_get_tbl_info(tfp,
+							   tbl_db->tbl_db[parms->dir],
+							   parms->type,
+							   &base,
+							   &shift);
+			if (rc) {
+				TFP_DRV_LOG(ERR,
+					    "%s: Failed to get table info:%d\n",
+					    tf_dir_2_str(parms->dir),
+					    parms->type);
+				return rc;
+			}
+		}
+		TF_TBL_PTR_TO_RM(&raparms.index, parms->idx, base, shift);
+
+		raparms.rm_db = tbl_db->tbl_db[parms->dir];
+		raparms.subtype = parms->type;
+		raparms.allocated = &rallocated;
+		rc = tf_rm_is_allocated(&raparms);
+		if (rc)
+			return rc;
+
+		if (rallocated != TF_RM_ALLOCATED_ENTRY_IN_USE) {
+			TFP_DRV_LOG(ERR,
+			   "%s, Invalid or not allocated index, type:%s, idx:%d\n",
+			   tf_dir_2_str(parms->dir),
+			   tf_tbl_type_2_str(parms->type),
+			   parms->idx);
+			return -EINVAL;
+		}
+	} else {
+		aparms.sram_offset = parms->idx;
+		aparms.slice_size = iparms.slice_size;
+		aparms.bank_id = iparms.bank_id;
+		aparms.dir = parms->dir;
+		aparms.is_allocated = &allocated;
+		rc = tf_sram_mgr_is_allocated(sram_handle, &aparms);
+		if (rc || !allocated) {
+			TFP_DRV_LOG(ERR,
+				    "%s: Entry not allocated:%s idx(%d):(%s)\n",
+				    tf_dir_2_str(parms->dir),
+				    tf_tbl_type_2_str(parms->type),
+				    parms->idx,
+				    strerror(-rc));
+			rc = -ENOMEM;
+			return rc;
+		}
 	}
-
 	/* Set the entry */
 	hparms.rm_db = tbl_db->tbl_db[parms->dir];
 	hparms.subtype = parms->type;
