blob: 8c241ec4893832033ca038ed4f3c7c1e4a2385d5 [file] [log] [blame]
Achin Gupta4f6ad662013-10-25 09:08:21 +01001/*
Dan Handleye83b0ca2014-01-14 18:17:09 +00002 * Copyright (c) 2013-2014, ARM Limited and Contributors. All rights reserved.
Achin Gupta4f6ad662013-10-25 09:08:21 +01003 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are met:
6 *
7 * Redistributions of source code must retain the above copyright notice, this
8 * list of conditions and the following disclaimer.
9 *
10 * Redistributions in binary form must reproduce the above copyright notice,
11 * this list of conditions and the following disclaimer in the documentation
12 * and/or other materials provided with the distribution.
13 *
14 * Neither the name of ARM nor the names of its contributors may be used
15 * to endorse or promote products derived from this software without specific
16 * prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
19 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
22 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
23 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
24 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
25 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
26 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
27 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
28 * POSSIBILITY OF SUCH DAMAGE.
29 */
30
Dan Handley2bd4ef22014-04-09 13:14:54 +010031#include <arch.h>
Achin Gupta4f6ad662013-10-25 09:08:21 +010032#include <arch_helpers.h>
Dan Handley2bd4ef22014-04-09 13:14:54 +010033#include <assert.h>
Achin Gupta4f6ad662013-10-25 09:08:21 +010034#include <bl_common.h>
Dan Handley714a0d22014-04-09 13:13:04 +010035#include <debug.h>
Sandrine Bailleux467d0572014-06-24 14:02:34 +010036#include <errno.h>
Dan Handley2bd4ef22014-04-09 13:14:54 +010037#include <io_storage.h>
38#include <platform.h>
Achin Gupta4f6ad662013-10-25 09:08:21 +010039
Achin Gupta4f6ad662013-10-25 09:08:21 +010040unsigned long page_align(unsigned long value, unsigned dir)
41{
42 unsigned long page_size = 1 << FOUR_KB_SHIFT;
43
44 /* Round up the limit to the next page boundary */
45 if (value & (page_size - 1)) {
46 value &= ~(page_size - 1);
47 if (dir == UP)
48 value += page_size;
49 }
50
51 return value;
52}
53
54static inline unsigned int is_page_aligned (unsigned long addr) {
55 const unsigned long page_size = 1 << FOUR_KB_SHIFT;
56
57 return (addr & (page_size - 1)) == 0;
58}
59
60void change_security_state(unsigned int target_security_state)
61{
62 unsigned long scr = read_scr();
63
Juan Castillof558cac2014-06-05 09:45:36 +010064 assert(sec_state_is_valid(target_security_state));
Achin Gupta4f6ad662013-10-25 09:08:21 +010065 if (target_security_state == SECURE)
66 scr &= ~SCR_NS_BIT;
Achin Gupta4f6ad662013-10-25 09:08:21 +010067 else
Juan Castillof558cac2014-06-05 09:45:36 +010068 scr |= SCR_NS_BIT;
Achin Gupta4f6ad662013-10-25 09:08:21 +010069
70 write_scr(scr);
71}
72
Sandrine Bailleux467d0572014-06-24 14:02:34 +010073/******************************************************************************
74 * Determine whether the memory region delimited by 'addr' and 'size' is free,
75 * given the extents of free memory.
76 * Return 1 if it is free, 0 otherwise.
77 *****************************************************************************/
78static int is_mem_free(uint64_t free_base, size_t free_size,
79 uint64_t addr, size_t size)
80{
81 return (addr >= free_base) && (addr + size <= free_base + free_size);
82}
Achin Gupta4f6ad662013-10-25 09:08:21 +010083
Sandrine Bailleux467d0572014-06-24 14:02:34 +010084/******************************************************************************
85 * Inside a given memory region, determine whether a sub-region of memory is
86 * closer from the top or the bottom of the encompassing region. Return the
87 * size of the smallest chunk of free memory surrounding the sub-region in
88 * 'small_chunk_size'.
89 *****************************************************************************/
90static unsigned int choose_mem_pos(uint64_t mem_start, uint64_t mem_end,
91 uint64_t submem_start, uint64_t submem_end,
92 size_t *small_chunk_size)
Achin Gupta4f6ad662013-10-25 09:08:21 +010093{
Sandrine Bailleux467d0572014-06-24 14:02:34 +010094 size_t top_chunk_size, bottom_chunk_size;
95
96 assert(mem_start <= submem_start);
97 assert(submem_start <= submem_end);
98 assert(submem_end <= mem_end);
99 assert(small_chunk_size != NULL);
Achin Gupta4f6ad662013-10-25 09:08:21 +0100100
Sandrine Bailleux467d0572014-06-24 14:02:34 +0100101 top_chunk_size = mem_end - submem_end;
102 bottom_chunk_size = submem_start - mem_start;
Achin Gupta4f6ad662013-10-25 09:08:21 +0100103
Sandrine Bailleux467d0572014-06-24 14:02:34 +0100104 if (top_chunk_size < bottom_chunk_size) {
105 *small_chunk_size = top_chunk_size;
106 return TOP;
Achin Gupta4f6ad662013-10-25 09:08:21 +0100107 } else {
Sandrine Bailleux467d0572014-06-24 14:02:34 +0100108 *small_chunk_size = bottom_chunk_size;
109 return BOTTOM;
Achin Gupta4f6ad662013-10-25 09:08:21 +0100110 }
Sandrine Bailleux467d0572014-06-24 14:02:34 +0100111}
112
113/******************************************************************************
114 * Reserve the memory region delimited by 'addr' and 'size'. The extents of free
115 * memory are passed in 'free_base' and 'free_size' and they will be updated to
116 * reflect the memory usage.
117 * The caller must ensure the memory to reserve is free.
118 *****************************************************************************/
119void reserve_mem(uint64_t *free_base, size_t *free_size,
120 uint64_t addr, size_t size)
121{
122 size_t discard_size;
123 size_t reserved_size;
124 unsigned int pos;
Achin Gupta4f6ad662013-10-25 09:08:21 +0100125
Sandrine Bailleux467d0572014-06-24 14:02:34 +0100126 assert(free_base != NULL);
127 assert(free_size != NULL);
128 assert(is_mem_free(*free_base, *free_size, addr, size));
Achin Gupta4f6ad662013-10-25 09:08:21 +0100129
Sandrine Bailleux467d0572014-06-24 14:02:34 +0100130 pos = choose_mem_pos(*free_base, *free_base + *free_size,
131 addr, addr + size,
132 &discard_size);
133
134 reserved_size = size + discard_size;
135 *free_size -= reserved_size;
136
137 if (pos == BOTTOM)
138 *free_base = addr + size;
139
Dan Handley91b624e2014-07-29 17:14:00 +0100140 VERBOSE("Reserved %u bytes (discarded %u bytes %s)\n",
Sandrine Bailleux467d0572014-06-24 14:02:34 +0100141 reserved_size, discard_size,
142 pos == TOP ? "above" : "below");
Achin Gupta4f6ad662013-10-25 09:08:21 +0100143}
144
145static void dump_load_info(unsigned long image_load_addr,
146 unsigned long image_size,
Dan Handleye2712bc2014-04-10 15:37:22 +0100147 const meminfo_t *mem_layout)
Achin Gupta4f6ad662013-10-25 09:08:21 +0100148{
Dan Handley91b624e2014-07-29 17:14:00 +0100149 INFO("Trying to load image at address 0x%lx, size = 0x%lx\n",
Achin Gupta4f6ad662013-10-25 09:08:21 +0100150 image_load_addr, image_size);
Dan Handley91b624e2014-07-29 17:14:00 +0100151 INFO("Current memory layout:\n");
152 INFO(" total region = [0x%lx, 0x%lx]\n", mem_layout->total_base,
Achin Gupta4f6ad662013-10-25 09:08:21 +0100153 mem_layout->total_base + mem_layout->total_size);
Dan Handley91b624e2014-07-29 17:14:00 +0100154 INFO(" free region = [0x%lx, 0x%lx]\n", mem_layout->free_base,
Achin Gupta4f6ad662013-10-25 09:08:21 +0100155 mem_layout->free_base + mem_layout->free_size);
Achin Gupta4f6ad662013-10-25 09:08:21 +0100156}
157
Ryan Harkin87274c42014-02-04 11:43:57 +0000158/* Generic function to return the size of an image */
159unsigned long image_size(const char *image_name)
160{
Dan Handleya4cb68e2014-04-23 13:47:06 +0100161 uintptr_t dev_handle;
162 uintptr_t image_handle;
163 uintptr_t image_spec;
Ryan Harkin87274c42014-02-04 11:43:57 +0000164 size_t image_size = 0;
165 int io_result = IO_FAIL;
166
167 assert(image_name != NULL);
168
169 /* Obtain a reference to the image by querying the platform layer */
170 io_result = plat_get_image_source(image_name, &dev_handle, &image_spec);
171 if (io_result != IO_SUCCESS) {
172 WARN("Failed to obtain reference to image '%s' (%i)\n",
173 image_name, io_result);
174 return 0;
175 }
176
177 /* Attempt to access the image */
178 io_result = io_open(dev_handle, image_spec, &image_handle);
179 if (io_result != IO_SUCCESS) {
180 WARN("Failed to access image '%s' (%i)\n",
181 image_name, io_result);
182 return 0;
183 }
184
185 /* Find the size of the image */
186 io_result = io_size(image_handle, &image_size);
187 if ((io_result != IO_SUCCESS) || (image_size == 0)) {
188 WARN("Failed to determine the size of the image '%s' file (%i)\n",
189 image_name, io_result);
190 }
191 io_result = io_close(image_handle);
192 /* Ignore improbable/unrecoverable error in 'close' */
193
194 /* TODO: Consider maintaining open device connection from this
195 * bootloader stage
196 */
197 io_result = io_dev_close(dev_handle);
198 /* Ignore improbable/unrecoverable error in 'dev_close' */
199
200 return image_size;
201}
Sandrine Bailleux467d0572014-06-24 14:02:34 +0100202
Achin Gupta4f6ad662013-10-25 09:08:21 +0100203/*******************************************************************************
Sandrine Bailleux467d0572014-06-24 14:02:34 +0100204 * Generic function to load an image at a specific address given a name and
205 * extents of free memory. It updates the memory layout if the load is
206 * successful, as well as the image information and the entry point information.
207 * The caller might pass a NULL pointer for the entry point if it is not
208 * interested in this information, e.g. because the image just needs to be
209 * loaded in memory but won't ever be executed.
210 * Returns 0 on success, a negative error code otherwise.
Achin Gupta4f6ad662013-10-25 09:08:21 +0100211 ******************************************************************************/
Vikram Kanigirida567432014-04-15 18:08:08 +0100212int load_image(meminfo_t *mem_layout,
Sandrine Bailleux467d0572014-06-24 14:02:34 +0100213 const char *image_name,
214 uint64_t image_base,
215 image_info_t *image_data,
216 entry_point_info_t *entry_point_info)
Achin Gupta4f6ad662013-10-25 09:08:21 +0100217{
Dan Handleya4cb68e2014-04-23 13:47:06 +0100218 uintptr_t dev_handle;
219 uintptr_t image_handle;
220 uintptr_t image_spec;
Sandrine Bailleux467d0572014-06-24 14:02:34 +0100221 size_t image_size;
222 size_t bytes_read;
James Morrissey9d72b4e2014-02-10 17:04:32 +0000223 int io_result = IO_FAIL;
Achin Gupta4f6ad662013-10-25 09:08:21 +0100224
James Morrissey9d72b4e2014-02-10 17:04:32 +0000225 assert(mem_layout != NULL);
226 assert(image_name != NULL);
Sandrine Bailleux467d0572014-06-24 14:02:34 +0100227 assert(image_data != NULL);
Vikram Kanigirida567432014-04-15 18:08:08 +0100228 assert(image_data->h.version >= VERSION_1);
James Morrissey9d72b4e2014-02-10 17:04:32 +0000229
230 /* Obtain a reference to the image by querying the platform layer */
231 io_result = plat_get_image_source(image_name, &dev_handle, &image_spec);
232 if (io_result != IO_SUCCESS) {
Jeenu Viswambharan08c28d52014-02-20 12:03:31 +0000233 WARN("Failed to obtain reference to image '%s' (%i)\n",
James Morrissey9d72b4e2014-02-10 17:04:32 +0000234 image_name, io_result);
Vikram Kanigirida567432014-04-15 18:08:08 +0100235 return io_result;
James Morrissey9d72b4e2014-02-10 17:04:32 +0000236 }
237
238 /* Attempt to access the image */
239 io_result = io_open(dev_handle, image_spec, &image_handle);
240 if (io_result != IO_SUCCESS) {
Jeenu Viswambharan08c28d52014-02-20 12:03:31 +0000241 WARN("Failed to access image '%s' (%i)\n",
James Morrissey9d72b4e2014-02-10 17:04:32 +0000242 image_name, io_result);
Vikram Kanigirida567432014-04-15 18:08:08 +0100243 return io_result;
Achin Gupta4f6ad662013-10-25 09:08:21 +0100244 }
245
Sandrine Bailleux467d0572014-06-24 14:02:34 +0100246 INFO("Loading file '%s' at address 0x%lx\n", image_name, image_base);
247
James Morrissey9d72b4e2014-02-10 17:04:32 +0000248 /* Find the size of the image */
249 io_result = io_size(image_handle, &image_size);
250 if ((io_result != IO_SUCCESS) || (image_size == 0)) {
Jeenu Viswambharan08c28d52014-02-20 12:03:31 +0000251 WARN("Failed to determine the size of the image '%s' file (%i)\n",
James Morrissey9d72b4e2014-02-10 17:04:32 +0000252 image_name, io_result);
Vikram Kanigirida567432014-04-15 18:08:08 +0100253 goto exit;
James Morrissey9d72b4e2014-02-10 17:04:32 +0000254 }
255
Sandrine Bailleux467d0572014-06-24 14:02:34 +0100256 /* Check that the memory where the image will be loaded is free */
257 if (!is_mem_free(mem_layout->free_base, mem_layout->free_size,
258 image_base, image_size)) {
259 WARN("Failed to reserve memory: 0x%lx - 0x%lx\n",
260 image_base, image_base + image_size);
Vikram Kanigirida567432014-04-15 18:08:08 +0100261 dump_load_info(image_base, image_size, mem_layout);
262 io_result = -ENOMEM;
263 goto exit;
Achin Gupta4f6ad662013-10-25 09:08:21 +0100264 }
265
266 /* We have enough space so load the image now */
James Morrissey9d72b4e2014-02-10 17:04:32 +0000267 /* TODO: Consider whether to try to recover/retry a partially successful read */
Dan Handleya4cb68e2014-04-23 13:47:06 +0100268 io_result = io_read(image_handle, image_base, image_size, &bytes_read);
James Morrissey9d72b4e2014-02-10 17:04:32 +0000269 if ((io_result != IO_SUCCESS) || (bytes_read < image_size)) {
Jeenu Viswambharan08c28d52014-02-20 12:03:31 +0000270 WARN("Failed to load '%s' file (%i)\n", image_name, io_result);
Vikram Kanigirida567432014-04-15 18:08:08 +0100271 goto exit;
Achin Gupta4f6ad662013-10-25 09:08:21 +0100272 }
273
Sandrine Bailleux467d0572014-06-24 14:02:34 +0100274 /*
275 * Update the memory usage info.
276 * This is done after the actual loading so that it is not updated when
277 * the load is unsuccessful.
Juan Castillo09a55a82015-01-19 16:51:21 +0000278 * If the caller does not provide an entry point, bypass the memory
279 * reservation.
Sandrine Bailleux467d0572014-06-24 14:02:34 +0100280 */
Juan Castillo09a55a82015-01-19 16:51:21 +0000281 if (entry_point_info != NULL) {
282 reserve_mem(&mem_layout->free_base, &mem_layout->free_size,
283 image_base, image_size);
284 } else {
285 INFO("Skip reserving memory: 0x%lx - 0x%lx\n",
286 image_base, image_base + image_size);
287 }
Sandrine Bailleux467d0572014-06-24 14:02:34 +0100288
Vikram Kanigirida567432014-04-15 18:08:08 +0100289 image_data->image_base = image_base;
290 image_data->image_size = image_size;
291
Sandrine Bailleux3ab33f32014-05-28 11:31:18 +0100292 if (entry_point_info != NULL)
293 entry_point_info->pc = image_base;
Vikram Kanigirida567432014-04-15 18:08:08 +0100294
Achin Gupta4f6ad662013-10-25 09:08:21 +0100295 /*
Sandrine Bailleux467d0572014-06-24 14:02:34 +0100296 * File has been successfully loaded.
297 * Flush the image in TZRAM so that the next EL can see it.
Achin Gupta4f6ad662013-10-25 09:08:21 +0100298 */
James Morrissey9d72b4e2014-02-10 17:04:32 +0000299 flush_dcache_range(image_base, image_size);
Achin Gupta4f6ad662013-10-25 09:08:21 +0100300
Sandrine Bailleux467d0572014-06-24 14:02:34 +0100301 INFO("File '%s' loaded: 0x%lx - 0x%lx\n", image_name, image_base,
302 image_base + image_size);
James Morrissey9d72b4e2014-02-10 17:04:32 +0000303
304exit:
Vikram Kanigirida567432014-04-15 18:08:08 +0100305 io_close(image_handle);
James Morrissey9d72b4e2014-02-10 17:04:32 +0000306 /* Ignore improbable/unrecoverable error in 'close' */
307
308 /* TODO: Consider maintaining open device connection from this bootloader stage */
Vikram Kanigirida567432014-04-15 18:08:08 +0100309 io_dev_close(dev_handle);
James Morrissey9d72b4e2014-02-10 17:04:32 +0000310 /* Ignore improbable/unrecoverable error in 'dev_close' */
Achin Gupta4f6ad662013-10-25 09:08:21 +0100311
Vikram Kanigirida567432014-04-15 18:08:08 +0100312 return io_result;
Achin Gupta4f6ad662013-10-25 09:08:21 +0100313}