diff --git a/lib/fconf/fconf.c b/lib/fconf/fconf.c
index affec54..bc4fa8e 100644
--- a/lib/fconf/fconf.c
+++ b/lib/fconf/fconf.c
@@ -29,8 +29,11 @@
 	};
 
 	config_info = FCONF_GET_PROPERTY(dyn_cfg, dtb, image_id);
+	assert(config_info != NULL);
+
 	config_image_info.image_base = config_info->config_addr;
-	config_image_info.image_max_size = (uint32_t)config_info->config_max_size;
+	config_image_info.image_max_size =
+		(uint32_t)config_info->config_max_size;
 
 	VERBOSE("FCONF: Loading config with image ID: %d\n", image_id);
 	err = load_auth_image(image_id, &config_image_info);
diff --git a/lib/fconf/fconf_dyn_cfg_getter.c b/lib/fconf/fconf_dyn_cfg_getter.c
index 1828a80..902c07d 100644
--- a/lib/fconf/fconf_dyn_cfg_getter.c
+++ b/lib/fconf/fconf_dyn_cfg_getter.c
@@ -15,22 +15,23 @@
 /* We currently use FW, TB_FW, SOC_FW, TOS_FW, NS_fw and HW configs  */
 #define MAX_DTB_INFO	U(6)
 
-#ifdef IMAGE_BL1
-static struct dyn_cfg_dtb_info_t dtb_infos[MAX_DTB_INFO] = {
-	[0] = {
-		.config_addr = ARM_FW_CONFIG_BASE,
-		.config_max_size = (uint32_t)
-				(ARM_FW_CONFIG_LIMIT - ARM_FW_CONFIG_BASE),
-		.config_id = FW_CONFIG_ID
-	},
-};
-/* Create an object pool starting at the second element */
-static OBJECT_POOL(dtb_info_pool, &dtb_infos[1],
-		sizeof(struct dyn_cfg_dtb_info_t), MAX_DTB_INFO-1);
-#else
 static struct dyn_cfg_dtb_info_t dtb_infos[MAX_DTB_INFO];
 static OBJECT_POOL_ARRAY(dtb_info_pool, dtb_infos);
-#endif
+
+/*
+ * This function is used to alloc memory for fw config information from
+ * global pool and set fw configuration information.
+ * Specifically used by BL1 to set fw_config information in global array
+ */
+void set_fw_config_info(uintptr_t config_addr, uint32_t config_max_size)
+{
+	struct dyn_cfg_dtb_info_t *dtb_info;
+
+	dtb_info = pool_alloc(&dtb_info_pool);
+	dtb_info->config_addr = config_addr;
+	dtb_info->config_max_size = config_max_size;
+	dtb_info->config_id = FW_CONFIG_ID;
+}
 
 struct dyn_cfg_dtb_info_t *dyn_cfg_dtb_info_getter(unsigned int config_id)
 {
@@ -62,6 +63,30 @@
 	/* As libfdt use void *, we can't avoid this cast */
 	const void *dtb = (void *)config;
 
+	/*
+	 * Compile time assert if FW_CONFIG_ID is 0 which is more
+	 * unlikely as 0 is a valid image id for FIP as per the current
+	 * code but still to avoid code breakage in case of unlikely
+	 * event when image ids gets changed.
+	 */
+	CASSERT(FW_CONFIG_ID != 0, assert_invalid_fw_config_id);
+
+	/*
+	 * In case of BL1, fw_config dtb information is already
+	 * populated in global dtb_infos array by 'set_fw_config_info'
+	 * function, Below check is present to avoid re-population of
+	 * fw_config information.
+	 *
+	 * Other BLs, satisfy below check and populate fw_config information
+	 * in global dtb_infos array.
+	 */
+	if (dtb_infos[0].config_id == 0) {
+		dtb_info = pool_alloc(&dtb_info_pool);
+		dtb_info->config_addr = config;
+		dtb_info->config_max_size = fdt_totalsize(dtb);
+		dtb_info->config_id = FW_CONFIG_ID;
+	}
+
 	/* Find the node offset point to "fconf,dyn_cfg-dtb_registry" compatible property */
 	const char *compatible_str = "fconf,dyn_cfg-dtb_registry";
 	node = fdt_node_offset_by_compatible(dtb, -1, compatible_str);
@@ -70,15 +95,6 @@
 		return node;
 	}
 
-#ifndef IMAGE_BL1
-	/* Save config dtb information */
-	dtb_info = pool_alloc(&dtb_info_pool);
-
-	dtb_info->config_addr = config;
-	dtb_info->config_max_size = fdt_totalsize(dtb);
-	dtb_info->config_id = FW_CONFIG_ID;
-#endif
-
 	fdt_for_each_subnode(child, dtb, node) {
 		uint32_t val32;
 		uint64_t val64;
