common/desc_image_load.c - TF-A/trusted-firmware-a - Gitiles

 /*
  * Copyright (c) 2016-2020, ARM Limited and Contributors. All rights reserved.
  *
  * SPDX-License-Identifier: BSD-3-Clause
  */

 #include <assert.h>

 #include <arch_helpers.h>
 #include <common/bl_common.h>
 #include <common/desc_image_load.h>
 #include <common/tbbr/tbbr_img_def.h>

 static bl_load_info_t bl_load_info;
 static bl_params_t next_bl_params;


 /*******************************************************************************
  * This function flushes the data structures so that they are visible
  * in memory for the next BL image.
  ******************************************************************************/
 void flush_bl_params_desc(void)
 {
 	flush_bl_params_desc_args(bl_mem_params_desc_ptr,
 		bl_mem_params_desc_num,
 		&next_bl_params);
 }

 /*******************************************************************************
  * This function flushes the data structures specified as arguments so that they
  * are visible in memory for the next BL image.
  ******************************************************************************/
 void flush_bl_params_desc_args(bl_mem_params_node_t *mem_params_desc_ptr,
 	unsigned int mem_params_desc_num,
 	bl_params_t *next_bl_params_ptr)
 {
 	assert(mem_params_desc_ptr != NULL);
 	assert(mem_params_desc_num != 0U);
 	assert(next_bl_params_ptr != NULL);

 	flush_dcache_range((uintptr_t)mem_params_desc_ptr,
 		sizeof(*mem_params_desc_ptr) * mem_params_desc_num);

 	flush_dcache_range((uintptr_t)next_bl_params_ptr,
 			sizeof(*next_bl_params_ptr));
 }

 /*******************************************************************************
  * This function returns the index for given image_id, within the
  * image descriptor array provided by bl_image_info_descs_ptr, if the
  * image is found else it returns -1.
  ******************************************************************************/
 int get_bl_params_node_index(unsigned int image_id)
 {
 	unsigned int index;
 	assert(image_id != INVALID_IMAGE_ID);

 	for (index = 0U; index < bl_mem_params_desc_num; index++) {
 		if (bl_mem_params_desc_ptr[index].image_id == image_id)
 			return (int)index;
 	}

 	return -1;
 }

 /*******************************************************************************
  * This function returns the pointer to `bl_mem_params_node_t` object for
  * given image_id, within the image descriptor array provided by
  * bl_mem_params_desc_ptr, if the image is found else it returns NULL.
  ******************************************************************************/
 bl_mem_params_node_t *get_bl_mem_params_node(unsigned int image_id)
 {
 	int index;
 	assert(image_id != INVALID_IMAGE_ID);

 	index = get_bl_params_node_index(image_id);
 	if (index >= 0)
 		return &bl_mem_params_desc_ptr[index];
 	else
 		return NULL;
 }

 /*******************************************************************************
  * This function creates the list of loadable images, by populating and
  * linking each `bl_load_info_node_t` type node, using the internal array
  * of image descriptor provided by bl_mem_params_desc_ptr. It also populates
  * and returns `bl_load_info_t` type structure that contains head of the list
  * of loadable images.
  ******************************************************************************/
 bl_load_info_t *get_bl_load_info_from_mem_params_desc(void)
 {
 	unsigned int index = 0;

 	/* If there is no image to start with, return NULL */
 	if (bl_mem_params_desc_num == 0U)
 		return NULL;

 	/* Assign initial data structures */
 	bl_load_info_node_t *bl_node_info =
 		&bl_mem_params_desc_ptr[index].load_node_mem;
 	bl_load_info.head = bl_node_info;
 	SET_PARAM_HEAD(&bl_load_info, PARAM_BL_LOAD_INFO, VERSION_2, 0U);

 	/* Go through the image descriptor array and create the list */
 	for (; index < bl_mem_params_desc_num; index++) {

 		/* Populate the image information */
 		bl_node_info->image_id = bl_mem_params_desc_ptr[index].image_id;
 		bl_node_info->image_info = &bl_mem_params_desc_ptr[index].image_info;

 		/* Link next image if present */
 		if ((index + 1U) < bl_mem_params_desc_num) {
 			/* Get the memory and link the next node */
 			bl_node_info->next_load_info =
 				&bl_mem_params_desc_ptr[index + 1U].load_node_mem;
 			bl_node_info = bl_node_info->next_load_info;
 		}
 	}

 	return &bl_load_info;
 }

 /*******************************************************************************
  * This function creates the list of executable images, by populating and
  * linking each `bl_params_node_t` type node, using the internal array of
  * image descriptor provided by bl_mem_params_desc_ptr. It also populates
  * and returns `bl_params_t` type structure that contains head of the list
  * of executable images.
  ******************************************************************************/
 bl_params_t *get_next_bl_params_from_mem_params_desc(void)
 {
 	unsigned int count;
 	unsigned int img_id = 0U;
 	unsigned int link_index = 0U;
 	bl_params_node_t *bl_current_exec_node = NULL;
 	bl_params_node_t *bl_last_exec_node = NULL;
 	bl_mem_params_node_t *desc_ptr;

 	/* If there is no image to start with, return NULL */
 	if (bl_mem_params_desc_num == 0U)
 		return NULL;

 	/* Get the list HEAD */
 	for (count = 0U; count < bl_mem_params_desc_num; count++) {

 		desc_ptr = &bl_mem_params_desc_ptr[count];

 		if ((EP_GET_EXE(desc_ptr->ep_info.h.attr) == EXECUTABLE) &&
 			(EP_GET_FIRST_EXE(desc_ptr->ep_info.h.attr) == EP_FIRST_EXE)) {
 			next_bl_params.head = &desc_ptr->params_node_mem;
 			link_index = count;
 			break;
 		}
 	}

 	/* Make sure we have a HEAD node */
 	assert(next_bl_params.head != NULL);

 	/* Populate the HEAD information */
 	SET_PARAM_HEAD(&next_bl_params, PARAM_BL_PARAMS, VERSION_2, 0U);

 	/*
 	 * Go through the image descriptor array and create the list.
 	 * This bounded loop is to make sure that we are not looping forever.
 	 */
 	for (count = 0U; count < bl_mem_params_desc_num; count++) {

 		desc_ptr = &bl_mem_params_desc_ptr[link_index];

 		/* Make sure the image is executable */
 		assert(EP_GET_EXE(desc_ptr->ep_info.h.attr) == EXECUTABLE);

 		/* Get the memory for current node */
 		bl_current_exec_node = &desc_ptr->params_node_mem;

 		/* Populate the image information */
 		bl_current_exec_node->image_id = desc_ptr->image_id;
 		bl_current_exec_node->image_info = &desc_ptr->image_info;
 		bl_current_exec_node->ep_info = &desc_ptr->ep_info;

 		if (bl_last_exec_node != NULL) {
 			/* Assert if loop detected */
 			assert(bl_last_exec_node->next_params_info == NULL);

 			/* Link the previous node to the current one */
 			bl_last_exec_node->next_params_info = bl_current_exec_node;
 		}

 		/* Update the last node */
 		bl_last_exec_node = bl_current_exec_node;

 		/* If no next hand-off image then break out */
 		img_id = desc_ptr->next_handoff_image_id;
 		if (img_id == INVALID_IMAGE_ID)
 			break;

 		/* Get the index for the next hand-off image */
 		link_index = get_bl_params_node_index(img_id);
 		assert((link_index > 0U) &&
 			(link_index < bl_mem_params_desc_num));
 	}

 	/* Invalid image is expected to terminate the loop */
 	assert(img_id == INVALID_IMAGE_ID);

 	return &next_bl_params;
 }

 /*******************************************************************************
  * This function populates the entry point information with the corresponding
  * config file for all executable BL images described in bl_params.
  ******************************************************************************/
 void populate_next_bl_params_config(bl_params_t *bl2_to_next_bl_params)
 {
 	bl_params_node_t *params_node;
 	unsigned int fw_config_id;
 	uintptr_t fw_config_base;
 	bl_mem_params_node_t *mem_params;
 	uintptr_t hw_config_base = 0;

 	assert(bl2_to_next_bl_params != NULL);

 	/*
 	 * Get the `bl_mem_params_node_t` corresponding to HW_CONFIG
 	 * if available.
 	 */
 	mem_params = get_bl_mem_params_node(HW_CONFIG_ID);

 	if (mem_params != NULL)
 		hw_config_base = mem_params->image_info.image_base;

 	for (params_node = bl2_to_next_bl_params->head; params_node != NULL;
 			params_node = params_node->next_params_info) {

 		fw_config_base = 0;

 		switch (params_node->image_id) {
 		case BL31_IMAGE_ID:
 			fw_config_id = SOC_FW_CONFIG_ID;
 			break;
 		case BL32_IMAGE_ID:
 		/*
 		 * At the moment, OPTEE cannot accept a DTB in secure memory,
 		 * so fall back and use NT_FW_CONFIG instead.
 		 * This MUST be fixed as soon as OPTEE has support to
 		 * receive DTBs in secure memory.
 		 */
 #ifndef SPD_opteed
 			fw_config_id = TOS_FW_CONFIG_ID;
 			break;
 #endif
 		case BL33_IMAGE_ID:
 			fw_config_id = NT_FW_CONFIG_ID;
 			break;
 		default:
 			fw_config_id = INVALID_IMAGE_ID;
 			break;
 		}

 		if (fw_config_id != INVALID_IMAGE_ID) {
 			mem_params = get_bl_mem_params_node(fw_config_id);
 			if (mem_params != NULL) {
 				fw_config_base = mem_params->image_info.image_base;
 			}
 		}

 #ifdef SPD_opteed
 		/*
 		 * If SPD_opteed is enabled, arg[0,2] are populated by
 		 * parse_optee_header(), which is called by
 		 * arm_bl2_handle_post_image_load(). The meaning of the
 		 * arguments are:
 		 * arg0 <-- MODE_RW
 		 * arg1 <-- Paged image base
 		 * arg2 <-- Paged image size
 		 */
 		if (params_node->image_id == BL32_IMAGE_ID) {
 			params_node->ep_info->args.arg3 = fw_config_base;
 		} else {
 #endif
 			/*
 			 * Pass hw and tb_fw config addresses to next images.
 			 * NOTE - for EL3 runtime images (BL31 for AArch64
 			 * and BL32 for AArch32), arg0 is already used by
 			 * generic code. Take care of not overwriting the
 			 * previous initialisations.
 			 */
 			if (params_node == bl2_to_next_bl_params->head) {
 				if (params_node->ep_info->args.arg1 == 0U)
 					params_node->ep_info->args.arg1 =
 								fw_config_base;
 				if (params_node->ep_info->args.arg2 == 0U)
 					params_node->ep_info->args.arg2 =
 								hw_config_base;
 			} else {
 				if (params_node->ep_info->args.arg0 == 0U)
 					params_node->ep_info->args.arg0 =
 								fw_config_base;
 				if (params_node->ep_info->args.arg1 == 0U)
 					params_node->ep_info->args.arg1 =
 								hw_config_base;
 			}
 #ifdef SPD_opteed
 		}
 #endif
 	}
 }

 /*******************************************************************************
  * Helper to extract BL32/BL33 entry point info from arg0 passed to BL31, for
  * platforms that are only interested in those. Platforms that need to extract
  * more information can parse the structures themselves.
  ******************************************************************************/

 void bl31_params_parse_helper(u_register_t param,
 			      entry_point_info_t *bl32_ep_info_out,
 			      entry_point_info_t *bl33_ep_info_out)
 {
 	bl_params_node_t *node;
 	bl_params_t *v2 = (void *)(uintptr_t)param;

 #if !ERROR_DEPRECATED
 	if (v2->h.version == PARAM_VERSION_1) {
 		struct { /* Deprecated version 1 parameter structure. */
 			param_header_t h;
 			image_info_t *bl31_image_info;
 			entry_point_info_t *bl32_ep_info;
 			image_info_t *bl32_image_info;
 			entry_point_info_t *bl33_ep_info;
 			image_info_t *bl33_image_info;
 		} *v1 = (void *)(uintptr_t)param;
 		assert(v1->h.type == PARAM_BL31);
 		if (bl32_ep_info_out != NULL)
 			*bl32_ep_info_out = *v1->bl32_ep_info;
 		if (bl33_ep_info_out != NULL)
 			*bl33_ep_info_out = *v1->bl33_ep_info;
 		return;
 	}
 #endif /* !ERROR_DEPRECATED */

 	assert(v2->h.version == PARAM_VERSION_2);
 	assert(v2->h.type == PARAM_BL_PARAMS);
 	for (node = v2->head; node != NULL; node = node->next_params_info) {
 		if (node->image_id == BL32_IMAGE_ID)
 			if (bl32_ep_info_out != NULL)
 				*bl32_ep_info_out = *node->ep_info;
 		if (node->image_id == BL33_IMAGE_ID)
 			if (bl33_ep_info_out != NULL)
 				*bl33_ep_info_out = *node->ep_info;
 	}
 }
	/*
	* Copyright (c) 2016-2020, ARM Limited and Contributors. All rights reserved.
	*
	* SPDX-License-Identifier: BSD-3-Clause
	*/

	#include <assert.h>

	#include <arch_helpers.h>
	#include <common/bl_common.h>
	#include <common/desc_image_load.h>
	#include <common/tbbr/tbbr_img_def.h>

	static bl_load_info_t bl_load_info;
	static bl_params_t next_bl_params;


	/*******************************************************************************
	* This function flushes the data structures so that they are visible
	* in memory for the next BL image.
	******************************************************************************/
	void flush_bl_params_desc(void)
	{
	flush_bl_params_desc_args(bl_mem_params_desc_ptr,
	bl_mem_params_desc_num,
	&next_bl_params);
	}

	/*******************************************************************************
	* This function flushes the data structures specified as arguments so that they
	* are visible in memory for the next BL image.
	******************************************************************************/
	void flush_bl_params_desc_args(bl_mem_params_node_t *mem_params_desc_ptr,
	unsigned int mem_params_desc_num,
	bl_params_t *next_bl_params_ptr)
	{
	assert(mem_params_desc_ptr != NULL);
	assert(mem_params_desc_num != 0U);
	assert(next_bl_params_ptr != NULL);

	flush_dcache_range((uintptr_t)mem_params_desc_ptr,
	sizeof(mem_params_desc_ptr) mem_params_desc_num);

	flush_dcache_range((uintptr_t)next_bl_params_ptr,
	sizeof(*next_bl_params_ptr));
	}

	/*******************************************************************************
	* This function returns the index for given image_id, within the
	* image descriptor array provided by bl_image_info_descs_ptr, if the
	* image is found else it returns -1.
	******************************************************************************/
	int get_bl_params_node_index(unsigned int image_id)
	{
	unsigned int index;
	assert(image_id != INVALID_IMAGE_ID);

	for (index = 0U; index < bl_mem_params_desc_num; index++) {
	if (bl_mem_params_desc_ptr[index].image_id == image_id)
	return (int)index;
	}

	return -1;
	}

	/*******************************************************************************
	* This function returns the pointer to `bl_mem_params_node_t` object for
	* given image_id, within the image descriptor array provided by
	* bl_mem_params_desc_ptr, if the image is found else it returns NULL.
	******************************************************************************/
	bl_mem_params_node_t *get_bl_mem_params_node(unsigned int image_id)
	{
	int index;
	assert(image_id != INVALID_IMAGE_ID);

	index = get_bl_params_node_index(image_id);
	if (index >= 0)
	return &bl_mem_params_desc_ptr[index];
	else
	return NULL;
	}

	/*******************************************************************************
	* This function creates the list of loadable images, by populating and
	* linking each `bl_load_info_node_t` type node, using the internal array
	* of image descriptor provided by bl_mem_params_desc_ptr. It also populates
	* and returns `bl_load_info_t` type structure that contains head of the list
	* of loadable images.
	******************************************************************************/
	bl_load_info_t *get_bl_load_info_from_mem_params_desc(void)
	{
	unsigned int index = 0;

	/* If there is no image to start with, return NULL */
	if (bl_mem_params_desc_num == 0U)
	return NULL;

	/* Assign initial data structures */
	bl_load_info_node_t *bl_node_info =
	&bl_mem_params_desc_ptr[index].load_node_mem;
	bl_load_info.head = bl_node_info;
	SET_PARAM_HEAD(&bl_load_info, PARAM_BL_LOAD_INFO, VERSION_2, 0U);

	/* Go through the image descriptor array and create the list */
	for (; index < bl_mem_params_desc_num; index++) {

	/* Populate the image information */
	bl_node_info->image_id = bl_mem_params_desc_ptr[index].image_id;
	bl_node_info->image_info = &bl_mem_params_desc_ptr[index].image_info;

	/* Link next image if present */
	if ((index + 1U) < bl_mem_params_desc_num) {
	/* Get the memory and link the next node */
	bl_node_info->next_load_info =
	&bl_mem_params_desc_ptr[index + 1U].load_node_mem;
	bl_node_info = bl_node_info->next_load_info;
	}
	}

	return &bl_load_info;
	}

	/*******************************************************************************
	* This function creates the list of executable images, by populating and
	* linking each `bl_params_node_t` type node, using the internal array of
	* image descriptor provided by bl_mem_params_desc_ptr. It also populates
	* and returns `bl_params_t` type structure that contains head of the list
	* of executable images.
	******************************************************************************/
	bl_params_t *get_next_bl_params_from_mem_params_desc(void)
	{
	unsigned int count;
	unsigned int img_id = 0U;
	unsigned int link_index = 0U;
	bl_params_node_t *bl_current_exec_node = NULL;
	bl_params_node_t *bl_last_exec_node = NULL;
	bl_mem_params_node_t *desc_ptr;

	/* If there is no image to start with, return NULL */
	if (bl_mem_params_desc_num == 0U)
	return NULL;

	/* Get the list HEAD */
	for (count = 0U; count < bl_mem_params_desc_num; count++) {

	desc_ptr = &bl_mem_params_desc_ptr[count];

	if ((EP_GET_EXE(desc_ptr->ep_info.h.attr) == EXECUTABLE) &&
	(EP_GET_FIRST_EXE(desc_ptr->ep_info.h.attr) == EP_FIRST_EXE)) {
	next_bl_params.head = &desc_ptr->params_node_mem;
	link_index = count;
	break;
	}
	}

	/* Make sure we have a HEAD node */
	assert(next_bl_params.head != NULL);

	/* Populate the HEAD information */
	SET_PARAM_HEAD(&next_bl_params, PARAM_BL_PARAMS, VERSION_2, 0U);

	/*
	* Go through the image descriptor array and create the list.
	* This bounded loop is to make sure that we are not looping forever.
	*/
	for (count = 0U; count < bl_mem_params_desc_num; count++) {

	desc_ptr = &bl_mem_params_desc_ptr[link_index];

	/* Make sure the image is executable */
	assert(EP_GET_EXE(desc_ptr->ep_info.h.attr) == EXECUTABLE);

	/* Get the memory for current node */
	bl_current_exec_node = &desc_ptr->params_node_mem;

	/* Populate the image information */
	bl_current_exec_node->image_id = desc_ptr->image_id;
	bl_current_exec_node->image_info = &desc_ptr->image_info;
	bl_current_exec_node->ep_info = &desc_ptr->ep_info;

	if (bl_last_exec_node != NULL) {
	/* Assert if loop detected */
	assert(bl_last_exec_node->next_params_info == NULL);

	/* Link the previous node to the current one */
	bl_last_exec_node->next_params_info = bl_current_exec_node;
	}

	/* Update the last node */
	bl_last_exec_node = bl_current_exec_node;

	/* If no next hand-off image then break out */
	img_id = desc_ptr->next_handoff_image_id;
	if (img_id == INVALID_IMAGE_ID)
	break;

	/* Get the index for the next hand-off image */
	link_index = get_bl_params_node_index(img_id);
	assert((link_index > 0U) &&
	(link_index < bl_mem_params_desc_num));
	}

	/* Invalid image is expected to terminate the loop */
	assert(img_id == INVALID_IMAGE_ID);

	return &next_bl_params;
	}

	/*******************************************************************************
	* This function populates the entry point information with the corresponding
	* config file for all executable BL images described in bl_params.
	******************************************************************************/
	void populate_next_bl_params_config(bl_params_t *bl2_to_next_bl_params)
	{
	bl_params_node_t *params_node;
	unsigned int fw_config_id;
	uintptr_t fw_config_base;
	bl_mem_params_node_t *mem_params;
	uintptr_t hw_config_base = 0;

	assert(bl2_to_next_bl_params != NULL);

	/*
	* Get the `bl_mem_params_node_t` corresponding to HW_CONFIG
	* if available.
	*/
	mem_params = get_bl_mem_params_node(HW_CONFIG_ID);

	if (mem_params != NULL)
	hw_config_base = mem_params->image_info.image_base;

	for (params_node = bl2_to_next_bl_params->head; params_node != NULL;
	params_node = params_node->next_params_info) {

	fw_config_base = 0;

	switch (params_node->image_id) {
	case BL31_IMAGE_ID:
	fw_config_id = SOC_FW_CONFIG_ID;
	break;
	case BL32_IMAGE_ID:
	/*
	* At the moment, OPTEE cannot accept a DTB in secure memory,
	* so fall back and use NT_FW_CONFIG instead.
	* This MUST be fixed as soon as OPTEE has support to
	* receive DTBs in secure memory.
	*/
	#ifndef SPD_opteed
	fw_config_id = TOS_FW_CONFIG_ID;
	break;
	#endif
	case BL33_IMAGE_ID:
	fw_config_id = NT_FW_CONFIG_ID;
	break;
	default:
	fw_config_id = INVALID_IMAGE_ID;
	break;
	}

	if (fw_config_id != INVALID_IMAGE_ID) {
	mem_params = get_bl_mem_params_node(fw_config_id);
	if (mem_params != NULL) {
	fw_config_base = mem_params->image_info.image_base;
	}
	}

	#ifdef SPD_opteed
	/*
	* If SPD_opteed is enabled, arg[0,2] are populated by
	* parse_optee_header(), which is called by
	* arm_bl2_handle_post_image_load(). The meaning of the
	* arguments are:
	* arg0 <-- MODE_RW
	* arg1 <-- Paged image base
	* arg2 <-- Paged image size
	*/
	if (params_node->image_id == BL32_IMAGE_ID) {
	params_node->ep_info->args.arg3 = fw_config_base;
	} else {
	#endif
	/*
	* Pass hw and tb_fw config addresses to next images.
	* NOTE - for EL3 runtime images (BL31 for AArch64
	* and BL32 for AArch32), arg0 is already used by
	* generic code. Take care of not overwriting the
	* previous initialisations.
	*/
	if (params_node == bl2_to_next_bl_params->head) {
	if (params_node->ep_info->args.arg1 == 0U)
	params_node->ep_info->args.arg1 =
	fw_config_base;
	if (params_node->ep_info->args.arg2 == 0U)
	params_node->ep_info->args.arg2 =
	hw_config_base;
	} else {
	if (params_node->ep_info->args.arg0 == 0U)
	params_node->ep_info->args.arg0 =
	fw_config_base;
	if (params_node->ep_info->args.arg1 == 0U)
	params_node->ep_info->args.arg1 =
	hw_config_base;
	}
	#ifdef SPD_opteed
	}
	#endif
	}
	}

	/*******************************************************************************
	* Helper to extract BL32/BL33 entry point info from arg0 passed to BL31, for
	* platforms that are only interested in those. Platforms that need to extract
	* more information can parse the structures themselves.
	******************************************************************************/

	void bl31_params_parse_helper(u_register_t param,
	entry_point_info_t *bl32_ep_info_out,
	entry_point_info_t *bl33_ep_info_out)
	{
	bl_params_node_t *node;
	bl_params_t v2 = (void )(uintptr_t)param;

	#if !ERROR_DEPRECATED
	if (v2->h.version == PARAM_VERSION_1) {
	struct { /* Deprecated version 1 parameter structure. */
	param_header_t h;
	image_info_t *bl31_image_info;
	entry_point_info_t *bl32_ep_info;
	image_info_t *bl32_image_info;
	entry_point_info_t *bl33_ep_info;
	image_info_t *bl33_image_info;
	} v1 = (void )(uintptr_t)param;
	assert(v1->h.type == PARAM_BL31);
	if (bl32_ep_info_out != NULL)
	bl32_ep_info_out = v1->bl32_ep_info;
	if (bl33_ep_info_out != NULL)
	bl33_ep_info_out = v1->bl33_ep_info;
	return;
	}
	#endif /* !ERROR_DEPRECATED */

	assert(v2->h.version == PARAM_VERSION_2);
	assert(v2->h.type == PARAM_BL_PARAMS);
	for (node = v2->head; node != NULL; node = node->next_params_info) {
	if (node->image_id == BL32_IMAGE_ID)
	if (bl32_ep_info_out != NULL)
	bl32_ep_info_out = node->ep_info;
	if (node->image_id == BL33_IMAGE_ID)
	if (bl33_ep_info_out != NULL)
	bl33_ep_info_out = node->ep_info;
	}
	}