blob: e2c8370e22bae023d25711ee47f515e58739ef19 [file] [log] [blame]
Soby Mathew44170c42016-03-22 15:51:08 +00001/*
Antonio Nino Diaz49074492018-04-26 12:59:08 +01002 * Copyright (c) 2016-2018, ARM Limited and Contributors. All rights reserved.
Soby Mathew44170c42016-03-22 15:51:08 +00003 *
dp-armfa3cf0b2017-05-03 09:38:09 +01004 * SPDX-License-Identifier: BSD-3-Clause
Soby Mathew44170c42016-03-22 15:51:08 +00005 */
6
Soby Mathew44170c42016-03-22 15:51:08 +00007#include <assert.h>
Antonio Nino Diaz5c97bd12018-08-02 09:57:29 +01008#include <stdbool.h>
Antonio Nino Diaz4b32e622018-08-16 16:52:57 +01009#include <stdint.h>
Soby Mathew44170c42016-03-22 15:51:08 +000010#include <string.h>
Antonio Nino Diaze0f90632018-12-14 00:18:21 +000011
12#include <platform_def.h>
13
14#include <arch.h>
15#include <arch_helpers.h>
16#include <common/debug.h>
17#include <lib/cassert.h>
18#include <lib/utils.h>
19#include <lib/xlat_tables/xlat_tables.h>
20#include <plat/common/common_def.h>
21
Antonio Nino Diazd1beee22016-12-13 15:28:54 +000022#include "xlat_tables_private.h"
Soby Mathew44170c42016-03-22 15:51:08 +000023
24#if LOG_LEVEL >= LOG_LEVEL_VERBOSE
25#define LVL0_SPACER ""
26#define LVL1_SPACER " "
27#define LVL2_SPACER " "
28#define LVL3_SPACER " "
29#define get_level_spacer(level) \
David Cunado8a354f12017-06-21 16:52:45 +010030 (((level) == U(0)) ? LVL0_SPACER : \
31 (((level) == U(1)) ? LVL1_SPACER : \
32 (((level) == U(2)) ? LVL2_SPACER : LVL3_SPACER)))
Antonio Nino Diaz00086e32018-08-16 16:46:06 +010033#define debug_print(...) printf(__VA_ARGS__)
Soby Mathew44170c42016-03-22 15:51:08 +000034#else
35#define debug_print(...) ((void)0)
36#endif
37
David Cunadoc1503122018-02-16 21:12:58 +000038#define UNSET_DESC ~0ULL
Antonio Nino Diaz50eb3742018-07-24 10:20:53 +010039#define MT_UNKNOWN ~0U
Soby Mathew44170c42016-03-22 15:51:08 +000040
41static uint64_t xlat_tables[MAX_XLAT_TABLES][XLAT_TABLE_ENTRIES]
Chris Kay33bfc5e2023-02-14 11:30:04 +000042 __aligned(XLAT_TABLE_SIZE) __section(".xlat_table");
Soby Mathew44170c42016-03-22 15:51:08 +000043
David Cunado8a354f12017-06-21 16:52:45 +010044static unsigned int next_xlat;
Soby Mathew44170c42016-03-22 15:51:08 +000045static unsigned long long xlat_max_pa;
46static uintptr_t xlat_max_va;
47
Antonio Nino Diazefabaa92017-04-27 13:30:22 +010048static uint64_t execute_never_mask;
Antonio Nino Diaz49074492018-04-26 12:59:08 +010049static uint64_t ap1_mask;
Antonio Nino Diazefabaa92017-04-27 13:30:22 +010050
Soby Mathew44170c42016-03-22 15:51:08 +000051/*
52 * Array of all memory regions stored in order of ascending base address.
53 * The list is terminated by the first entry with size == 0.
54 */
55static mmap_region_t mmap[MAX_MMAP_REGIONS + 1];
56
57
58void print_mmap(void)
59{
60#if LOG_LEVEL >= LOG_LEVEL_VERBOSE
61 debug_print("mmap:\n");
62 mmap_region_t *mm = mmap;
Antonio Nino Diaz50eb3742018-07-24 10:20:53 +010063 while (mm->size != 0U) {
Soby Mathew44170c42016-03-22 15:51:08 +000064 debug_print(" VA:%p PA:0x%llx size:0x%zx attr:0x%x\n",
65 (void *)mm->base_va, mm->base_pa,
66 mm->size, mm->attr);
67 ++mm;
68 };
69 debug_print("\n");
70#endif
71}
72
73void mmap_add_region(unsigned long long base_pa, uintptr_t base_va,
Antonio Nino Diaz8643a812018-06-21 14:39:16 +010074 size_t size, unsigned int attr)
Soby Mathew44170c42016-03-22 15:51:08 +000075{
76 mmap_region_t *mm = mmap;
Antonio Nino Diaz50eb3742018-07-24 10:20:53 +010077 const mmap_region_t *mm_last = mm + ARRAY_SIZE(mmap) - 1U;
78 unsigned long long end_pa = base_pa + size - 1U;
79 uintptr_t end_va = base_va + size - 1U;
Soby Mathew44170c42016-03-22 15:51:08 +000080
81 assert(IS_PAGE_ALIGNED(base_pa));
82 assert(IS_PAGE_ALIGNED(base_va));
83 assert(IS_PAGE_ALIGNED(size));
84
Antonio Nino Diaz50eb3742018-07-24 10:20:53 +010085 if (size == 0U)
Soby Mathew44170c42016-03-22 15:51:08 +000086 return;
87
Antonio Nino Diazb5e7f772016-03-30 15:45:57 +010088 assert(base_pa < end_pa); /* Check for overflows */
89 assert(base_va < end_va);
90
Antonio Nino Diazd1beee22016-12-13 15:28:54 +000091 assert((base_va + (uintptr_t)size - (uintptr_t)1) <=
Antonio Nino Diaz50eb3742018-07-24 10:20:53 +010092 (PLAT_VIRT_ADDR_SPACE_SIZE - 1U));
Antonio Nino Diazd1beee22016-12-13 15:28:54 +000093 assert((base_pa + (unsigned long long)size - 1ULL) <=
Antonio Nino Diaz50eb3742018-07-24 10:20:53 +010094 (PLAT_PHY_ADDR_SPACE_SIZE - 1U));
Antonio Nino Diazd1beee22016-12-13 15:28:54 +000095
Antonio Nino Diaz3759e3f2017-03-22 15:48:51 +000096#if ENABLE_ASSERTIONS
Antonio Nino Diazb5e7f772016-03-30 15:45:57 +010097
98 /* Check for PAs and VAs overlaps with all other regions */
99 for (mm = mmap; mm->size; ++mm) {
100
Antonio Nino Diaz50eb3742018-07-24 10:20:53 +0100101 uintptr_t mm_end_va = mm->base_va + mm->size - 1U;
Antonio Nino Diazb5e7f772016-03-30 15:45:57 +0100102
103 /*
104 * Check if one of the regions is completely inside the other
105 * one.
106 */
Antonio Nino Diaz5c97bd12018-08-02 09:57:29 +0100107 bool fully_overlapped_va =
108 ((base_va >= mm->base_va) && (end_va <= mm_end_va)) ||
109 ((mm->base_va >= base_va) && (mm_end_va <= end_va));
Antonio Nino Diazb5e7f772016-03-30 15:45:57 +0100110
111 /*
112 * Full VA overlaps are only allowed if both regions are
113 * identity mapped (zero offset) or have the same VA to PA
114 * offset. Also, make sure that it's not the exact same area.
115 */
Antonio Nino Diaz5c97bd12018-08-02 09:57:29 +0100116 if (fully_overlapped_va) {
Antonio Nino Diazb5e7f772016-03-30 15:45:57 +0100117 assert((mm->base_va - mm->base_pa) ==
118 (base_va - base_pa));
119 assert((base_va != mm->base_va) || (size != mm->size));
120 } else {
121 /*
122 * If the regions do not have fully overlapping VAs,
123 * then they must have fully separated VAs and PAs.
124 * Partial overlaps are not allowed
125 */
126
127 unsigned long long mm_end_pa =
128 mm->base_pa + mm->size - 1;
129
Antonio Nino Diaz5c97bd12018-08-02 09:57:29 +0100130 bool separated_pa = (end_pa < mm->base_pa) ||
131 (base_pa > mm_end_pa);
132 bool separated_va = (end_va < mm->base_va) ||
133 (base_va > mm_end_va);
Antonio Nino Diazb5e7f772016-03-30 15:45:57 +0100134
Antonio Nino Diaz5c97bd12018-08-02 09:57:29 +0100135 assert(separated_va && separated_pa);
Antonio Nino Diazb5e7f772016-03-30 15:45:57 +0100136 }
137 }
138
139 mm = mmap; /* Restore pointer to the start of the array */
140
Antonio Nino Diaz3759e3f2017-03-22 15:48:51 +0000141#endif /* ENABLE_ASSERTIONS */
Antonio Nino Diazb5e7f772016-03-30 15:45:57 +0100142
Soby Mathew44170c42016-03-22 15:51:08 +0000143 /* Find correct place in mmap to insert new region */
Antonio Nino Diaz50eb3742018-07-24 10:20:53 +0100144 while ((mm->base_va < base_va) && (mm->size != 0U))
Soby Mathew44170c42016-03-22 15:51:08 +0000145 ++mm;
146
Antonio Nino Diazb5e7f772016-03-30 15:45:57 +0100147 /*
148 * If a section is contained inside another one with the same base
149 * address, it must be placed after the one it is contained in:
150 *
151 * 1st |-----------------------|
152 * 2nd |------------|
153 * 3rd |------|
154 *
155 * This is required for mmap_region_attr() to get the attributes of the
156 * small region correctly.
157 */
158 while ((mm->base_va == base_va) && (mm->size > size))
159 ++mm;
160
Soby Mathew44170c42016-03-22 15:51:08 +0000161 /* Make room for new region by moving other regions up by one place */
Antonio Nino Diaz50eb3742018-07-24 10:20:53 +0100162 (void)memmove(mm + 1, mm, (uintptr_t)mm_last - (uintptr_t)mm);
Soby Mathew44170c42016-03-22 15:51:08 +0000163
Elyes Haouas2be03c02023-02-13 09:14:48 +0100164 /* Check we haven't lost the empty sentinel from the end of the array */
Antonio Nino Diaz50eb3742018-07-24 10:20:53 +0100165 assert(mm_last->size == 0U);
Soby Mathew44170c42016-03-22 15:51:08 +0000166
167 mm->base_pa = base_pa;
168 mm->base_va = base_va;
169 mm->size = size;
170 mm->attr = attr;
171
Antonio Nino Diazb5e7f772016-03-30 15:45:57 +0100172 if (end_pa > xlat_max_pa)
173 xlat_max_pa = end_pa;
174 if (end_va > xlat_max_va)
175 xlat_max_va = end_va;
Soby Mathew44170c42016-03-22 15:51:08 +0000176}
177
178void mmap_add(const mmap_region_t *mm)
179{
Antonio Nino Diaz50eb3742018-07-24 10:20:53 +0100180 const mmap_region_t *mm_cursor = mm;
181
Antonio Nino Diaz2cb864c2018-10-08 16:11:11 +0100182 while ((mm_cursor->size != 0U) || (mm_cursor->attr != 0U)) {
Antonio Nino Diaz50eb3742018-07-24 10:20:53 +0100183 mmap_add_region(mm_cursor->base_pa, mm_cursor->base_va,
184 mm_cursor->size, mm_cursor->attr);
185 mm_cursor++;
Soby Mathew44170c42016-03-22 15:51:08 +0000186 }
187}
188
Antonio Nino Diaz8643a812018-06-21 14:39:16 +0100189static uint64_t mmap_desc(unsigned int attr, unsigned long long addr_pa,
190 unsigned int level)
Soby Mathew44170c42016-03-22 15:51:08 +0000191{
Sandrine Bailleux7528b682016-06-14 16:29:04 +0100192 uint64_t desc;
Soby Mathew44170c42016-03-22 15:51:08 +0000193 int mem_type;
194
Antonio Nino Diaz46a33a52016-12-08 16:03:46 +0000195 /* Make sure that the granularity is fine enough to map this address. */
Antonio Nino Diaz50eb3742018-07-24 10:20:53 +0100196 assert((addr_pa & XLAT_BLOCK_MASK(level)) == 0U);
Antonio Nino Diaz46a33a52016-12-08 16:03:46 +0000197
Sandrine Bailleux7528b682016-06-14 16:29:04 +0100198 desc = addr_pa;
Antonio Nino Diazd48ae612016-08-02 09:21:41 +0100199 /*
200 * There are different translation table descriptors for level 3 and the
201 * rest.
202 */
203 desc |= (level == XLAT_TABLE_LEVEL_MAX) ? PAGE_DESC : BLOCK_DESC;
Antonio Nino Diaz50eb3742018-07-24 10:20:53 +0100204 desc |= ((attr & MT_NS) != 0U) ? LOWER_ATTRS(NS) : 0U;
205 desc |= ((attr & MT_RW) != 0U) ? LOWER_ATTRS(AP_RW) : LOWER_ATTRS(AP_RO);
Antonio Nino Diaz0842bd62018-07-12 15:54:10 +0100206 /*
207 * Always set the access flag, as this library assumes access flag
208 * faults aren't managed.
209 */
Soby Mathew44170c42016-03-22 15:51:08 +0000210 desc |= LOWER_ATTRS(ACCESS_FLAG);
Antonio Nino Diaz49074492018-04-26 12:59:08 +0100211 desc |= ap1_mask;
Soby Mathew44170c42016-03-22 15:51:08 +0000212
Sandrine Bailleux7528b682016-06-14 16:29:04 +0100213 /*
214 * Deduce shareability domain and executability of the memory region
215 * from the memory type.
216 *
217 * Data accesses to device memory and non-cacheable normal memory are
218 * coherent for all observers in the system, and correspondingly are
219 * always treated as being Outer Shareable. Therefore, for these 2 types
220 * of memory, it is not strictly needed to set the shareability field
221 * in the translation tables.
222 */
Soby Mathew44170c42016-03-22 15:51:08 +0000223 mem_type = MT_TYPE(attr);
Sandrine Bailleux7528b682016-06-14 16:29:04 +0100224 if (mem_type == MT_DEVICE) {
Soby Mathew44170c42016-03-22 15:51:08 +0000225 desc |= LOWER_ATTRS(ATTR_DEVICE_INDEX | OSH);
Sandrine Bailleux7528b682016-06-14 16:29:04 +0100226 /*
227 * Always map device memory as execute-never.
228 * This is to avoid the possibility of a speculative instruction
229 * fetch, which could be an issue if this memory region
230 * corresponds to a read-sensitive peripheral.
231 */
Antonio Nino Diazefabaa92017-04-27 13:30:22 +0100232 desc |= execute_never_mask;
233
Sandrine Bailleux7528b682016-06-14 16:29:04 +0100234 } else { /* Normal memory */
235 /*
236 * Always map read-write normal memory as execute-never.
Antonio Nino Diaz0842bd62018-07-12 15:54:10 +0100237 * This library assumes that it is used by software that does
238 * not self-modify its code, therefore R/W memory is reserved
239 * for data storage, which must not be executable.
240 *
Sandrine Bailleux7528b682016-06-14 16:29:04 +0100241 * Note that setting the XN bit here is for consistency only.
Antonio Nino Diazefabaa92017-04-27 13:30:22 +0100242 * The function that enables the MMU sets the SCTLR_ELx.WXN bit,
Sandrine Bailleux7528b682016-06-14 16:29:04 +0100243 * which makes any writable memory region to be treated as
244 * execute-never, regardless of the value of the XN bit in the
245 * translation table.
Sandrine Bailleuxac3aa682016-06-14 16:31:09 +0100246 *
247 * For read-only memory, rely on the MT_EXECUTE/MT_EXECUTE_NEVER
248 * attribute to figure out the value of the XN bit.
Sandrine Bailleux7528b682016-06-14 16:29:04 +0100249 */
Antonio Nino Diaz50eb3742018-07-24 10:20:53 +0100250 if (((attr & MT_RW) != 0U) || ((attr & MT_EXECUTE_NEVER) != 0U)) {
Antonio Nino Diazefabaa92017-04-27 13:30:22 +0100251 desc |= execute_never_mask;
252 }
Sandrine Bailleux7528b682016-06-14 16:29:04 +0100253
254 if (mem_type == MT_MEMORY) {
255 desc |= LOWER_ATTRS(ATTR_IWBWA_OWBWA_NTR_INDEX | ISH);
256 } else {
257 assert(mem_type == MT_NON_CACHEABLE);
258 desc |= LOWER_ATTRS(ATTR_NON_CACHEABLE_INDEX | OSH);
259 }
Soby Mathew44170c42016-03-22 15:51:08 +0000260 }
261
262 debug_print((mem_type == MT_MEMORY) ? "MEM" :
263 ((mem_type == MT_NON_CACHEABLE) ? "NC" : "DEV"));
Antonio Nino Diaz50eb3742018-07-24 10:20:53 +0100264 debug_print(((attr & MT_RW) != 0U) ? "-RW" : "-RO");
265 debug_print(((attr & MT_NS) != 0U) ? "-NS" : "-S");
266 debug_print(((attr & MT_EXECUTE_NEVER) != 0U) ? "-XN" : "-EXEC");
Soby Mathew44170c42016-03-22 15:51:08 +0000267 return desc;
268}
269
Antonio Nino Diazb5e7f772016-03-30 15:45:57 +0100270/*
Nishanth Menon6f243462017-05-01 12:26:34 -0500271 * Look for the innermost region that contains the area at `base_va` with size
272 * `size`. Populate *attr with the attributes of this region.
273 *
274 * On success, this function returns 0.
275 * If there are partial overlaps (meaning that a smaller size is needed) or if
Antonio Nino Diaz50eb3742018-07-24 10:20:53 +0100276 * the region can't be found in the given area, it returns MT_UNKNOWN. In this
277 * case the value pointed by attr should be ignored by the caller.
Antonio Nino Diazb5e7f772016-03-30 15:45:57 +0100278 */
Antonio Nino Diaz50eb3742018-07-24 10:20:53 +0100279static unsigned int mmap_region_attr(const mmap_region_t *mm, uintptr_t base_va,
280 size_t size, unsigned int *attr)
Soby Mathew44170c42016-03-22 15:51:08 +0000281{
Antonio Nino Diazb5e7f772016-03-30 15:45:57 +0100282 /* Don't assume that the area is contained in the first region */
Antonio Nino Diaz50eb3742018-07-24 10:20:53 +0100283 unsigned int ret = MT_UNKNOWN;
Soby Mathew44170c42016-03-22 15:51:08 +0000284
Antonio Nino Diazb5e7f772016-03-30 15:45:57 +0100285 /*
286 * Get attributes from last (innermost) region that contains the
287 * requested area. Don't stop as soon as one region doesn't contain it
288 * because there may be other internal regions that contain this area:
289 *
290 * |-----------------------------1-----------------------------|
291 * |----2----| |-------3-------| |----5----|
292 * |--4--|
293 *
294 * |---| <- Area we want the attributes of.
295 *
296 * In this example, the area is contained in regions 1, 3 and 4 but not
297 * in region 2. The loop shouldn't stop at region 2 as inner regions
298 * have priority over outer regions, it should stop at region 5.
299 */
Antonio Nino Diaz50eb3742018-07-24 10:20:53 +0100300 for ( ; ; ++mm) {
Soby Mathew44170c42016-03-22 15:51:08 +0000301
Antonio Nino Diaz50eb3742018-07-24 10:20:53 +0100302 if (mm->size == 0U)
Nishanth Menon6f243462017-05-01 12:26:34 -0500303 return ret; /* Reached end of list */
Soby Mathew44170c42016-03-22 15:51:08 +0000304
Antonio Nino Diaz50eb3742018-07-24 10:20:53 +0100305 if (mm->base_va > (base_va + size - 1U))
Nishanth Menon6f243462017-05-01 12:26:34 -0500306 return ret; /* Next region is after area so end */
Soby Mathew44170c42016-03-22 15:51:08 +0000307
Antonio Nino Diaz50eb3742018-07-24 10:20:53 +0100308 if ((mm->base_va + mm->size - 1U) < base_va)
Soby Mathew44170c42016-03-22 15:51:08 +0000309 continue; /* Next region has already been overtaken */
310
Antonio Nino Diaz50eb3742018-07-24 10:20:53 +0100311 if ((ret == 0U) && (mm->attr == *attr))
Soby Mathew44170c42016-03-22 15:51:08 +0000312 continue; /* Region doesn't override attribs so skip */
313
Antonio Nino Diaz50eb3742018-07-24 10:20:53 +0100314 if ((mm->base_va > base_va) ||
315 ((mm->base_va + mm->size - 1U) < (base_va + size - 1U)))
316 return MT_UNKNOWN; /* Region doesn't fully cover area */
Antonio Nino Diazb5e7f772016-03-30 15:45:57 +0100317
Nishanth Menon6f243462017-05-01 12:26:34 -0500318 *attr = mm->attr;
Antonio Nino Diaz50eb3742018-07-24 10:20:53 +0100319 ret = 0U;
Soby Mathew44170c42016-03-22 15:51:08 +0000320 }
Nishanth Menon6f243462017-05-01 12:26:34 -0500321 return ret;
Soby Mathew44170c42016-03-22 15:51:08 +0000322}
323
324static mmap_region_t *init_xlation_table_inner(mmap_region_t *mm,
325 uintptr_t base_va,
326 uint64_t *table,
David Cunado8a354f12017-06-21 16:52:45 +0100327 unsigned int level)
Soby Mathew44170c42016-03-22 15:51:08 +0000328{
Antonio Nino Diaz50eb3742018-07-24 10:20:53 +0100329 assert((level >= XLAT_TABLE_LEVEL_MIN) &&
330 (level <= XLAT_TABLE_LEVEL_MAX));
Soby Mathew44170c42016-03-22 15:51:08 +0000331
Antonio Nino Diazd48ae612016-08-02 09:21:41 +0100332 unsigned int level_size_shift =
333 L0_XLAT_ADDRESS_SHIFT - level * XLAT_TABLE_ENTRIES_SHIFT;
334 u_register_t level_size = (u_register_t)1 << level_size_shift;
335 u_register_t level_index_mask =
336 ((u_register_t)XLAT_TABLE_ENTRIES_MASK) << level_size_shift;
Soby Mathew44170c42016-03-22 15:51:08 +0000337
338 debug_print("New xlat table:\n");
339
340 do {
341 uint64_t desc = UNSET_DESC;
342
Antonio Nino Diaz50eb3742018-07-24 10:20:53 +0100343 if (mm->size == 0U) {
Soby Mathew44170c42016-03-22 15:51:08 +0000344 /* Done mapping regions; finish zeroing the table */
345 desc = INVALID_DESC;
Antonio Nino Diaz50eb3742018-07-24 10:20:53 +0100346 } else if ((mm->base_va + mm->size - 1U) < base_va) {
Antonio Nino Diazb5e7f772016-03-30 15:45:57 +0100347 /* This area is after the region so get next region */
Soby Mathew44170c42016-03-22 15:51:08 +0000348 ++mm;
349 continue;
350 }
351
Antonio Nino Diazd48ae612016-08-02 09:21:41 +0100352 debug_print("%s VA:%p size:0x%llx ", get_level_spacer(level),
353 (void *)base_va, (unsigned long long)level_size);
Soby Mathew44170c42016-03-22 15:51:08 +0000354
Antonio Nino Diaz50eb3742018-07-24 10:20:53 +0100355 if (mm->base_va > (base_va + level_size - 1U)) {
Antonio Nino Diazb5e7f772016-03-30 15:45:57 +0100356 /* Next region is after this area. Nothing to map yet */
Soby Mathew44170c42016-03-22 15:51:08 +0000357 desc = INVALID_DESC;
Antonio Nino Diaz010888d2016-12-13 15:02:31 +0000358 /* Make sure that the current level allows block descriptors */
359 } else if (level >= XLAT_BLOCK_LEVEL_MIN) {
Antonio Nino Diazb5e7f772016-03-30 15:45:57 +0100360 /*
361 * Try to get attributes of this area. It will fail if
362 * there are partially overlapping regions. On success,
363 * it will return the innermost region's attributes.
364 */
Antonio Nino Diaz8643a812018-06-21 14:39:16 +0100365 unsigned int attr;
Antonio Nino Diaz50eb3742018-07-24 10:20:53 +0100366 unsigned int r = mmap_region_attr(mm, base_va,
367 level_size, &attr);
Nishanth Menon6f243462017-05-01 12:26:34 -0500368
Antonio Nino Diaz50eb3742018-07-24 10:20:53 +0100369 if (r == 0U) {
Soby Mathew44170c42016-03-22 15:51:08 +0000370 desc = mmap_desc(attr,
371 base_va - mm->base_va + mm->base_pa,
372 level);
Antonio Nino Diazb5e7f772016-03-30 15:45:57 +0100373 }
Soby Mathew44170c42016-03-22 15:51:08 +0000374 }
Soby Mathew44170c42016-03-22 15:51:08 +0000375
376 if (desc == UNSET_DESC) {
377 /* Area not covered by a region so need finer table */
Antonio Nino Diaz50eb3742018-07-24 10:20:53 +0100378 uint64_t *new_table = xlat_tables[next_xlat];
379
380 next_xlat++;
Soby Mathew44170c42016-03-22 15:51:08 +0000381 assert(next_xlat <= MAX_XLAT_TABLES);
Soby Mathewa0fedc42016-06-16 14:52:04 +0100382 desc = TABLE_DESC | (uintptr_t)new_table;
Soby Mathew44170c42016-03-22 15:51:08 +0000383
384 /* Recurse to fill in new table */
385 mm = init_xlation_table_inner(mm, base_va,
Antonio Nino Diaz50eb3742018-07-24 10:20:53 +0100386 new_table, level + 1U);
Soby Mathew44170c42016-03-22 15:51:08 +0000387 }
388
389 debug_print("\n");
390
391 *table++ = desc;
392 base_va += level_size;
Antonio Nino Diazd1beee22016-12-13 15:28:54 +0000393 } while ((base_va & level_index_mask) &&
Antonio Nino Diaz50eb3742018-07-24 10:20:53 +0100394 ((base_va - 1U) < (PLAT_VIRT_ADDR_SPACE_SIZE - 1U)));
Soby Mathew44170c42016-03-22 15:51:08 +0000395
396 return mm;
397}
398
399void init_xlation_table(uintptr_t base_va, uint64_t *table,
David Cunado8a354f12017-06-21 16:52:45 +0100400 unsigned int level, uintptr_t *max_va,
Soby Mathew44170c42016-03-22 15:51:08 +0000401 unsigned long long *max_pa)
402{
Antonio Nino Diaz50eb3742018-07-24 10:20:53 +0100403 unsigned int el = xlat_arch_current_el();
Antonio Nino Diaz49074492018-04-26 12:59:08 +0100404
405 execute_never_mask = xlat_arch_get_xn_desc(el);
406
Antonio Nino Diaz50eb3742018-07-24 10:20:53 +0100407 if (el == 3U) {
Antonio Nino Diaz49074492018-04-26 12:59:08 +0100408 ap1_mask = LOWER_ATTRS(AP_ONE_VA_RANGE_RES1);
409 } else {
Antonio Nino Diaz50eb3742018-07-24 10:20:53 +0100410 assert(el == 1U);
411 ap1_mask = 0ULL;
Antonio Nino Diaz49074492018-04-26 12:59:08 +0100412 }
413
Soby Mathew44170c42016-03-22 15:51:08 +0000414 init_xlation_table_inner(mmap, base_va, table, level);
415 *max_va = xlat_max_va;
416 *max_pa = xlat_max_pa;
417}