aboutsummaryrefslogtreecommitdiff
path: root/common
diff options
context:
space:
mode:
authorRoberto Vargas <roberto.vargas@arm.com>2018-09-24 17:20:48 +0100
committerAntonio Nino Diaz <antonio.ninodiaz@arm.com>2018-09-28 15:31:52 +0100
commited51b51f7a9163a7fc48289c5ed97a3fe4fe504f (patch)
tree09c75a5c072abcec2f196dfa5dc82ce1d3153db0 /common
parent0b812305998380569fc609ea87157975780fc1e2 (diff)
downloadtrusted-firmware-a-ed51b51f7a9163a7fc48289c5ed97a3fe4fe504f.tar.gz
Remove build option LOAD_IMAGE_V2
The code of LOAD_IMAGE_V2=0 has been removed. Change-Id: Iea03e5bebb90c66889bdb23f85c07d0c9717fffe Co-authored-by: Antonio Nino Diaz <antonio.ninodiaz@arm.com> Signed-off-by: Antonio Nino Diaz <antonio.ninodiaz@arm.com>
Diffstat (limited to 'common')
-rw-r--r--common/bl_common.c295
1 files changed, 1 insertions, 294 deletions
diff --git a/common/bl_common.c b/common/bl_common.c
index af51c07d51..60baa5bdfb 100644
--- a/common/bl_common.c
+++ b/common/bl_common.c
@@ -23,8 +23,7 @@ static int disable_auth;
/******************************************************************************
* API to dynamically disable authentication. Only meant for development
- * systems. This is only invoked if DYN_DISABLE_AUTH is defined. This
- * capability is restricted to LOAD_IMAGE_V2.
+ * systems. This is only invoked if DYN_DISABLE_AUTH is defined.
*****************************************************************************/
void dyn_disable_auth(void)
{
@@ -101,88 +100,6 @@ int is_mem_free(uintptr_t free_base, size_t free_size,
return (addr >= free_base) && (requested_end <= free_end);
}
-#if !LOAD_IMAGE_V2
-/******************************************************************************
- * Inside a given memory region, determine whether a sub-region of memory is
- * closer from the top or the bottom of the encompassing region. Return the
- * size of the smallest chunk of free memory surrounding the sub-region in
- * 'small_chunk_size'.
- *****************************************************************************/
-static unsigned int choose_mem_pos(uintptr_t mem_start, uintptr_t mem_end,
- uintptr_t submem_start, uintptr_t submem_end,
- size_t *small_chunk_size)
-{
- size_t top_chunk_size, bottom_chunk_size;
-
- assert(mem_start <= submem_start);
- assert(submem_start <= submem_end);
- assert(submem_end <= mem_end);
- assert(small_chunk_size != NULL);
-
- top_chunk_size = mem_end - submem_end;
- bottom_chunk_size = submem_start - mem_start;
-
- if (top_chunk_size < bottom_chunk_size) {
- *small_chunk_size = top_chunk_size;
- return TOP;
- } else {
- *small_chunk_size = bottom_chunk_size;
- return BOTTOM;
- }
-}
-
-/******************************************************************************
- * Reserve the memory region delimited by 'addr' and 'size'. The extents of free
- * memory are passed in 'free_base' and 'free_size' and they will be updated to
- * reflect the memory usage.
- * The caller must ensure the memory to reserve is free and that the addresses
- * and sizes passed in arguments are sane.
- *****************************************************************************/
-void reserve_mem(uintptr_t *free_base, size_t *free_size,
- uintptr_t addr, size_t size)
-{
- size_t discard_size;
- size_t reserved_size;
- unsigned int pos;
-
- assert(free_base != NULL);
- assert(free_size != NULL);
- assert(is_mem_free(*free_base, *free_size, addr, size));
-
- if (size == 0) {
- WARN("Nothing to allocate, requested size is zero\n");
- return;
- }
-
- pos = choose_mem_pos(*free_base, *free_base + (*free_size - 1),
- addr, addr + (size - 1),
- &discard_size);
-
- reserved_size = size + discard_size;
- *free_size -= reserved_size;
-
- if (pos == BOTTOM)
- *free_base = addr + size;
-
- VERBOSE("Reserved 0x%zx bytes (discarded 0x%zx bytes %s)\n",
- reserved_size, discard_size,
- pos == TOP ? "above" : "below");
-}
-
-static void dump_load_info(uintptr_t image_load_addr,
- size_t image_size,
- const meminfo_t *mem_layout)
-{
- INFO("Trying to load image at address %p, size = 0x%zx\n",
- (void *)image_load_addr, image_size);
- INFO("Current memory layout:\n");
- INFO(" total region = [base = %p, size = 0x%zx]\n",
- (void *) mem_layout->total_base, mem_layout->total_size);
- INFO(" free region = [base = %p, size = 0x%zx]\n",
- (void *) mem_layout->free_base, mem_layout->free_size);
-}
-#endif /* LOAD_IMAGE_V2 */
-
/* Generic function to return the size of an image */
size_t get_image_size(unsigned int image_id)
{
@@ -226,8 +143,6 @@ size_t get_image_size(unsigned int image_id)
return image_size;
}
-#if LOAD_IMAGE_V2
-
/*******************************************************************************
* Internal function to load an image at a specific address given
* an image ID and extents of free memory.
@@ -386,214 +301,6 @@ int load_auth_image(unsigned int image_id, image_info_t *image_data)
return err;
}
-#else /* LOAD_IMAGE_V2 */
-
-/*******************************************************************************
- * Generic function to load an image at a specific address given an image ID and
- * extents of free memory.
- *
- * If the load is successful then the image information is updated.
- *
- * If the entry_point_info argument is not NULL then this function also updates:
- * - the memory layout to mark the memory as reserved;
- * - the entry point information.
- *
- * The caller might pass a NULL pointer for the entry point if they are not
- * interested in this information. This is typically the case for non-executable
- * images (e.g. certificates) and executable images that won't ever be executed
- * on the application processor (e.g. additional microcontroller firmware).
- *
- * Returns 0 on success, a negative error code otherwise.
- ******************************************************************************/
-int load_image(meminfo_t *mem_layout,
- unsigned int image_id,
- uintptr_t image_base,
- image_info_t *image_data,
- entry_point_info_t *entry_point_info)
-{
- uintptr_t dev_handle;
- uintptr_t image_handle;
- uintptr_t image_spec;
- size_t image_size;
- size_t bytes_read;
- int io_result;
-
- assert(mem_layout != NULL);
- assert(image_data != NULL);
- assert(image_data->h.version == VERSION_1);
-
- /* Obtain a reference to the image by querying the platform layer */
- io_result = plat_get_image_source(image_id, &dev_handle, &image_spec);
- if (io_result != 0) {
- WARN("Failed to obtain reference to image id=%u (%i)\n",
- image_id, io_result);
- return io_result;
- }
-
- /* Attempt to access the image */
- io_result = io_open(dev_handle, image_spec, &image_handle);
- if (io_result != 0) {
- WARN("Failed to access image id=%u (%i)\n",
- image_id, io_result);
- return io_result;
- }
-
- INFO("Loading image id=%u at address %p\n", image_id,
- (void *) image_base);
-
- /* Find the size of the image */
- io_result = io_size(image_handle, &image_size);
- if ((io_result != 0) || (image_size == 0)) {
- WARN("Failed to determine the size of the image id=%u (%i)\n",
- image_id, io_result);
- goto exit;
- }
-
- /* Check that the memory where the image will be loaded is free */
- if (!is_mem_free(mem_layout->free_base, mem_layout->free_size,
- image_base, image_size)) {
- WARN("Failed to reserve region [base = %p, size = 0x%zx]\n",
- (void *) image_base, image_size);
- dump_load_info(image_base, image_size, mem_layout);
- io_result = -ENOMEM;
- goto exit;
- }
-
- /* We have enough space so load the image now */
- /* TODO: Consider whether to try to recover/retry a partially successful read */
- io_result = io_read(image_handle, image_base, image_size, &bytes_read);
- if ((io_result != 0) || (bytes_read < image_size)) {
- WARN("Failed to load image id=%u (%i)\n", image_id, io_result);
- goto exit;
- }
-
- image_data->image_base = image_base;
- image_data->image_size = image_size;
-
- /*
- * Update the memory usage info.
- * This is done after the actual loading so that it is not updated when
- * the load is unsuccessful.
- * If the caller does not provide an entry point, bypass the memory
- * reservation.
- */
- if (entry_point_info != NULL) {
- reserve_mem(&mem_layout->free_base, &mem_layout->free_size,
- image_base, image_size);
- entry_point_info->pc = image_base;
- } else {
- INFO("Skip reserving region [base = %p, size = 0x%zx]\n",
- (void *) image_base, image_size);
- }
-
-#if !TRUSTED_BOARD_BOOT
- /*
- * File has been successfully loaded.
- * Flush the image to main memory so that it can be executed later by
- * any CPU, regardless of cache and MMU state.
- * When TBB is enabled the image is flushed later, after image
- * authentication.
- */
- flush_dcache_range(image_base, image_size);
-#endif /* TRUSTED_BOARD_BOOT */
-
- INFO("Image id=%u loaded at address %p, size = 0x%zx\n", image_id,
- (void *) image_base, image_size);
-
-exit:
- io_close(image_handle);
- /* Ignore improbable/unrecoverable error in 'close' */
-
- /* TODO: Consider maintaining open device connection from this bootloader stage */
- io_dev_close(dev_handle);
- /* Ignore improbable/unrecoverable error in 'dev_close' */
-
- return io_result;
-}
-
-static int load_auth_image_internal(meminfo_t *mem_layout,
- unsigned int image_id,
- uintptr_t image_base,
- image_info_t *image_data,
- entry_point_info_t *entry_point_info,
- int is_parent_image)
-{
- int rc;
-
-#if TRUSTED_BOARD_BOOT
- unsigned int parent_id;
-
- /* Use recursion to authenticate parent images */
- rc = auth_mod_get_parent_id(image_id, &parent_id);
- if (rc == 0) {
- rc = load_auth_image_internal(mem_layout, parent_id, image_base,
- image_data, NULL, 1);
- if (rc != 0) {
- return rc;
- }
- }
-#endif /* TRUSTED_BOARD_BOOT */
-
- /* Load the image */
- rc = load_image(mem_layout, image_id, image_base, image_data,
- entry_point_info);
- if (rc != 0) {
- return rc;
- }
-
-#if TRUSTED_BOARD_BOOT
- /* Authenticate it */
- rc = auth_mod_verify_img(image_id,
- (void *)image_data->image_base,
- image_data->image_size);
- if (rc != 0) {
- /* Authentication error, zero memory and flush it right away. */
- zero_normalmem((void *)image_data->image_base,
- image_data->image_size);
- flush_dcache_range(image_data->image_base,
- image_data->image_size);
- return -EAUTH;
- }
- /*
- * File has been successfully loaded and authenticated.
- * Flush the image to main memory so that it can be executed later by
- * any CPU, regardless of cache and MMU state.
- * Do it only for child images, not for the parents (certificates).
- */
- if (!is_parent_image) {
- flush_dcache_range(image_data->image_base,
- image_data->image_size);
- }
-#endif /* TRUSTED_BOARD_BOOT */
-
- return 0;
-}
-
-/*******************************************************************************
- * Generic function to load and authenticate an image. The image is actually
- * loaded by calling the 'load_image()' function. Therefore, it returns the
- * same error codes if the loading operation failed, or -EAUTH if the
- * authentication failed. In addition, this function uses recursion to
- * authenticate the parent images up to the root of trust.
- ******************************************************************************/
-int load_auth_image(meminfo_t *mem_layout,
- unsigned int image_id,
- uintptr_t image_base,
- image_info_t *image_data,
- entry_point_info_t *entry_point_info)
-{
- int err;
-
- do {
- err = load_auth_image_internal(mem_layout, image_id, image_base,
- image_data, entry_point_info, 0);
- } while (err != 0 && plat_try_next_boot_source());
-
- return err;
-}
-
-#endif /* LOAD_IMAGE_V2 */
-
/*******************************************************************************
* Print the content of an entry_point_info_t structure.
******************************************************************************/