1 /* 2 * Copyright (c) 2013-2014, ARM Limited and Contributors. All rights reserved. 3 * 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 31 #include <arch.h> 32 #include <arch_helpers.h> 33 #include <assert.h> 34 #include <bl_common.h> 35 #include <debug.h> 36 #include <io_storage.h> 37 #include <platform.h> 38 #include <errno.h> 39 #include <stdio.h> 40 41 unsigned long page_align(unsigned long value, unsigned dir) 42 { 43 unsigned long page_size = 1 << FOUR_KB_SHIFT; 44 45 /* Round up the limit to the next page boundary */ 46 if (value & (page_size - 1)) { 47 value &= ~(page_size - 1); 48 if (dir == UP) 49 value += page_size; 50 } 51 52 return value; 53 } 54 55 static inline unsigned int is_page_aligned (unsigned long addr) { 56 const unsigned long page_size = 1 << FOUR_KB_SHIFT; 57 58 return (addr & (page_size - 1)) == 0; 59 } 60 61 void change_security_state(unsigned int target_security_state) 62 { 63 unsigned long scr = read_scr(); 64 65 if (target_security_state == SECURE) 66 scr &= ~SCR_NS_BIT; 67 else if (target_security_state == NON_SECURE) 68 scr |= SCR_NS_BIT; 69 else 70 assert(0); 71 72 write_scr(scr); 73 } 74 75 76 /******************************************************************************* 77 * The next function has a weak definition. Platform specific code can override 78 * it if it wishes to. 79 ******************************************************************************/ 80 #pragma weak init_bl2_mem_layout 81 82 /******************************************************************************* 83 * Function that takes a memory layout into which BL2 has been either top or 84 * bottom loaded along with the address where BL2 has been loaded in it. Using 85 * this information, it populates bl2_mem_layout to tell BL2 how much memory 86 * it has access to and how much is available for use. 87 ******************************************************************************/ 88 void init_bl2_mem_layout(meminfo_t *bl1_mem_layout, 89 meminfo_t *bl2_mem_layout, 90 unsigned int load_type, 91 unsigned long bl2_base) 92 { 93 unsigned tmp; 94 95 if (load_type == BOT_LOAD) { 96 bl2_mem_layout->total_base = bl2_base; 97 tmp = bl1_mem_layout->free_base - bl2_base; 98 bl2_mem_layout->total_size = bl1_mem_layout->free_size + tmp; 99 100 } else { 101 bl2_mem_layout->total_base = bl1_mem_layout->free_base; 102 tmp = bl1_mem_layout->total_base + bl1_mem_layout->total_size; 103 bl2_mem_layout->total_size = tmp - bl1_mem_layout->free_base; 104 } 105 106 bl2_mem_layout->free_base = bl1_mem_layout->free_base; 107 bl2_mem_layout->free_size = bl1_mem_layout->free_size; 108 bl2_mem_layout->attr = load_type; 109 110 flush_dcache_range((unsigned long) bl2_mem_layout, sizeof(meminfo_t)); 111 return; 112 } 113 114 static void dump_load_info(unsigned long image_load_addr, 115 unsigned long image_size, 116 const meminfo_t *mem_layout) 117 { 118 #if DEBUG 119 printf("Trying to load image at address 0x%lx, size = 0x%lx\r\n", 120 image_load_addr, image_size); 121 printf("Current memory layout:\r\n"); 122 printf(" total region = [0x%lx, 0x%lx]\r\n", mem_layout->total_base, 123 mem_layout->total_base + mem_layout->total_size); 124 printf(" free region = [0x%lx, 0x%lx]\r\n", mem_layout->free_base, 125 mem_layout->free_base + mem_layout->free_size); 126 #endif 127 } 128 129 /* Generic function to return the size of an image */ 130 unsigned long image_size(const char *image_name) 131 { 132 uintptr_t dev_handle; 133 uintptr_t image_handle; 134 uintptr_t image_spec; 135 size_t image_size = 0; 136 int io_result = IO_FAIL; 137 138 assert(image_name != NULL); 139 140 /* Obtain a reference to the image by querying the platform layer */ 141 io_result = plat_get_image_source(image_name, &dev_handle, &image_spec); 142 if (io_result != IO_SUCCESS) { 143 WARN("Failed to obtain reference to image '%s' (%i)\n", 144 image_name, io_result); 145 return 0; 146 } 147 148 /* Attempt to access the image */ 149 io_result = io_open(dev_handle, image_spec, &image_handle); 150 if (io_result != IO_SUCCESS) { 151 WARN("Failed to access image '%s' (%i)\n", 152 image_name, io_result); 153 return 0; 154 } 155 156 /* Find the size of the image */ 157 io_result = io_size(image_handle, &image_size); 158 if ((io_result != IO_SUCCESS) || (image_size == 0)) { 159 WARN("Failed to determine the size of the image '%s' file (%i)\n", 160 image_name, io_result); 161 } 162 io_result = io_close(image_handle); 163 /* Ignore improbable/unrecoverable error in 'close' */ 164 165 /* TODO: Consider maintaining open device connection from this 166 * bootloader stage 167 */ 168 io_result = io_dev_close(dev_handle); 169 /* Ignore improbable/unrecoverable error in 'dev_close' */ 170 171 return image_size; 172 } 173 /******************************************************************************* 174 * Generic function to load an image into the trusted RAM, 175 * given a name, extents of free memory & whether the image should be loaded at 176 * the bottom or top of the free memory. It updates the memory layout if the 177 * load is successful. It also updates the image information and the entry point 178 * information in the params passed. The caller might pass a NULL pointer for 179 * the entry point if it is not interested in this information, e.g. because 180 * the image just needs to be loaded in memory but won't ever be executed. 181 ******************************************************************************/ 182 int load_image(meminfo_t *mem_layout, 183 const char *image_name, 184 unsigned int load_type, 185 unsigned long fixed_addr, 186 image_info_t *image_data, 187 entry_point_info_t *entry_point_info) 188 { 189 uintptr_t dev_handle; 190 uintptr_t image_handle; 191 uintptr_t image_spec; 192 unsigned long temp_image_base = 0; 193 unsigned long image_base = 0; 194 long offset = 0; 195 size_t image_size = 0; 196 size_t bytes_read = 0; 197 int io_result = IO_FAIL; 198 199 assert(mem_layout != NULL); 200 assert(image_name != NULL); 201 assert(image_data->h.version >= VERSION_1); 202 203 /* Obtain a reference to the image by querying the platform layer */ 204 io_result = plat_get_image_source(image_name, &dev_handle, &image_spec); 205 if (io_result != IO_SUCCESS) { 206 WARN("Failed to obtain reference to image '%s' (%i)\n", 207 image_name, io_result); 208 return io_result; 209 } 210 211 /* Attempt to access the image */ 212 io_result = io_open(dev_handle, image_spec, &image_handle); 213 if (io_result != IO_SUCCESS) { 214 WARN("Failed to access image '%s' (%i)\n", 215 image_name, io_result); 216 return io_result; 217 } 218 219 /* Find the size of the image */ 220 io_result = io_size(image_handle, &image_size); 221 if ((io_result != IO_SUCCESS) || (image_size == 0)) { 222 WARN("Failed to determine the size of the image '%s' file (%i)\n", 223 image_name, io_result); 224 goto exit; 225 } 226 227 /* See if we have enough space */ 228 if (image_size > mem_layout->free_size) { 229 WARN("Cannot load '%s' file: Not enough space.\n", 230 image_name); 231 dump_load_info(0, image_size, mem_layout); 232 goto exit; 233 } 234 235 switch (load_type) { 236 237 case TOP_LOAD: 238 239 /* Load the image in the top of free memory */ 240 temp_image_base = mem_layout->free_base + mem_layout->free_size; 241 temp_image_base -= image_size; 242 243 /* Page align base address and check whether the image still fits */ 244 image_base = page_align(temp_image_base, DOWN); 245 assert(image_base <= temp_image_base); 246 247 if (image_base < mem_layout->free_base) { 248 WARN("Cannot load '%s' file: Not enough space.\n", 249 image_name); 250 dump_load_info(image_base, image_size, mem_layout); 251 io_result = -ENOMEM; 252 goto exit; 253 } 254 255 /* Calculate the amount of extra memory used due to alignment */ 256 offset = temp_image_base - image_base; 257 258 break; 259 260 case BOT_LOAD: 261 262 /* Load the BL2 image in the bottom of free memory */ 263 temp_image_base = mem_layout->free_base; 264 image_base = page_align(temp_image_base, UP); 265 assert(image_base >= temp_image_base); 266 267 /* Page align base address and check whether the image still fits */ 268 if (image_base + image_size > 269 mem_layout->free_base + mem_layout->free_size) { 270 WARN("Cannot load '%s' file: Not enough space.\n", 271 image_name); 272 dump_load_info(image_base, image_size, mem_layout); 273 io_result = -ENOMEM; 274 goto exit; 275 } 276 277 /* Calculate the amount of extra memory used due to alignment */ 278 offset = image_base - temp_image_base; 279 280 break; 281 282 default: 283 assert(0); 284 285 } 286 287 /* 288 * Some images must be loaded at a fixed address, not a dynamic one. 289 * 290 * This has been implemented as a hack on top of the existing dynamic 291 * loading mechanism, for the time being. If the 'fixed_addr' function 292 * argument is different from zero, then it will force the load address. 293 * So we still have this principle of top/bottom loading but the code 294 * determining the load address is bypassed and the load address is 295 * forced to the fixed one. 296 * 297 * This can result in quite a lot of wasted space because we still use 298 * 1 sole meminfo structure to represent the extents of free memory, 299 * where we should use some sort of linked list. 300 * 301 * E.g. we want to load BL2 at address 0x04020000, the resulting memory 302 * layout should look as follows: 303 * ------------ 0x04040000 304 * | | <- Free space (1) 305 * |----------| 306 * | BL2 | 307 * |----------| 0x04020000 308 * | | <- Free space (2) 309 * |----------| 310 * | BL1 | 311 * ------------ 0x04000000 312 * 313 * But in the current hacky implementation, we'll need to specify 314 * whether BL2 is loaded at the top or bottom of the free memory. 315 * E.g. if BL2 is considered as top-loaded, the meminfo structure 316 * will give the following view of the memory, hiding the chunk of 317 * free memory above BL2: 318 * ------------ 0x04040000 319 * | | 320 * | | 321 * | BL2 | 322 * |----------| 0x04020000 323 * | | <- Free space (2) 324 * |----------| 325 * | BL1 | 326 * ------------ 0x04000000 327 */ 328 if (fixed_addr != 0) { 329 /* Load the image at the given address. */ 330 image_base = fixed_addr; 331 332 /* Check whether the image fits. */ 333 if ((image_base < mem_layout->free_base) || 334 (image_base + image_size > 335 mem_layout->free_base + mem_layout->free_size)) { 336 WARN("Cannot load '%s' file: Not enough space.\n", 337 image_name); 338 dump_load_info(image_base, image_size, mem_layout); 339 io_result = -ENOMEM; 340 goto exit; 341 } 342 343 /* Check whether the fixed load address is page-aligned. */ 344 if (!is_page_aligned(image_base)) { 345 WARN("Cannot load '%s' file at unaligned address 0x%lx\n", 346 image_name, fixed_addr); 347 io_result = -ENOMEM; 348 goto exit; 349 } 350 351 /* 352 * Calculate the amount of extra memory used due to fixed 353 * loading. 354 */ 355 if (load_type == TOP_LOAD) { 356 unsigned long max_addr, space_used; 357 /* 358 * ------------ max_addr 359 * | /wasted/ | | offset 360 * |..........|.............................. 361 * | image | | image_flen 362 * |----------| fixed_addr 363 * | | 364 * | | 365 * ------------ total_base 366 */ 367 max_addr = mem_layout->total_base + mem_layout->total_size; 368 /* 369 * Compute the amount of memory used by the image. 370 * Corresponds to all space above the image load 371 * address. 372 */ 373 space_used = max_addr - fixed_addr; 374 /* 375 * Calculate the amount of wasted memory within the 376 * amount of memory used by the image. 377 */ 378 offset = space_used - image_size; 379 } else /* BOT_LOAD */ 380 /* 381 * ------------ 382 * | | 383 * | | 384 * |----------| 385 * | image | 386 * |..........| fixed_addr 387 * | /wasted/ | | offset 388 * ------------ total_base 389 */ 390 offset = fixed_addr - mem_layout->total_base; 391 } 392 393 /* We have enough space so load the image now */ 394 /* TODO: Consider whether to try to recover/retry a partially successful read */ 395 io_result = io_read(image_handle, image_base, image_size, &bytes_read); 396 if ((io_result != IO_SUCCESS) || (bytes_read < image_size)) { 397 WARN("Failed to load '%s' file (%i)\n", image_name, io_result); 398 goto exit; 399 } 400 401 image_data->image_base = image_base; 402 image_data->image_size = image_size; 403 404 if (entry_point_info != NULL) 405 entry_point_info->pc = image_base; 406 407 /* 408 * File has been successfully loaded. Update the free memory 409 * data structure & flush the contents of the TZRAM so that 410 * the next EL can see it. 411 */ 412 /* Update the memory contents */ 413 flush_dcache_range(image_base, image_size); 414 415 mem_layout->free_size -= image_size + offset; 416 417 /* Update the base of free memory since its moved up */ 418 if (load_type == BOT_LOAD) 419 mem_layout->free_base += offset + image_size; 420 421 exit: 422 io_close(image_handle); 423 /* Ignore improbable/unrecoverable error in 'close' */ 424 425 /* TODO: Consider maintaining open device connection from this bootloader stage */ 426 io_dev_close(dev_handle); 427 /* Ignore improbable/unrecoverable error in 'dev_close' */ 428 429 return io_result; 430 } 431