blob: 81c4dc6834d78fb3c5104ef54982f44db5bfe0ae [file] [log] [blame]
Soby Mathew44170c42016-03-22 15:51:08 +00001/*
2 * Copyright (c) 2016, 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>
Soby Mathew44170c42016-03-22 15:51:08 +000034#include <cassert.h>
Antonio Nino Diazd1beee22016-12-13 15:28:54 +000035#include <common_def.h>
Soby Mathew44170c42016-03-22 15:51:08 +000036#include <debug.h>
37#include <platform_def.h>
38#include <string.h>
Soby Mathewa0fedc42016-06-16 14:52:04 +010039#include <types.h>
Sandrine Bailleux7659a262016-07-05 09:55:03 +010040#include <utils.h>
Soby Mathew44170c42016-03-22 15:51:08 +000041#include <xlat_tables.h>
Antonio Nino Diazd1beee22016-12-13 15:28:54 +000042#include "xlat_tables_private.h"
Soby Mathew44170c42016-03-22 15:51:08 +000043
44#if LOG_LEVEL >= LOG_LEVEL_VERBOSE
45#define LVL0_SPACER ""
46#define LVL1_SPACER " "
47#define LVL2_SPACER " "
48#define LVL3_SPACER " "
49#define get_level_spacer(level) \
50 (((level) == 0) ? LVL0_SPACER : \
51 (((level) == 1) ? LVL1_SPACER : \
52 (((level) == 2) ? LVL2_SPACER : LVL3_SPACER)))
53#define debug_print(...) tf_printf(__VA_ARGS__)
54#else
55#define debug_print(...) ((void)0)
56#endif
57
Soby Mathewa0fedc42016-06-16 14:52:04 +010058#define UNSET_DESC ~0ull
Soby Mathew44170c42016-03-22 15:51:08 +000059
60static uint64_t xlat_tables[MAX_XLAT_TABLES][XLAT_TABLE_ENTRIES]
61 __aligned(XLAT_TABLE_SIZE) __section("xlat_table");
62
63static unsigned next_xlat;
64static unsigned long long xlat_max_pa;
65static uintptr_t xlat_max_va;
66
67/*
68 * Array of all memory regions stored in order of ascending base address.
69 * The list is terminated by the first entry with size == 0.
70 */
71static mmap_region_t mmap[MAX_MMAP_REGIONS + 1];
72
73
74void print_mmap(void)
75{
76#if LOG_LEVEL >= LOG_LEVEL_VERBOSE
77 debug_print("mmap:\n");
78 mmap_region_t *mm = mmap;
79 while (mm->size) {
80 debug_print(" VA:%p PA:0x%llx size:0x%zx attr:0x%x\n",
81 (void *)mm->base_va, mm->base_pa,
82 mm->size, mm->attr);
83 ++mm;
84 };
85 debug_print("\n");
86#endif
87}
88
89void mmap_add_region(unsigned long long base_pa, uintptr_t base_va,
90 size_t size, unsigned int attr)
91{
92 mmap_region_t *mm = mmap;
93 mmap_region_t *mm_last = mm + ARRAY_SIZE(mmap) - 1;
Antonio Nino Diazb5e7f772016-03-30 15:45:57 +010094 unsigned long long end_pa = base_pa + size - 1;
95 uintptr_t end_va = base_va + size - 1;
Soby Mathew44170c42016-03-22 15:51:08 +000096
97 assert(IS_PAGE_ALIGNED(base_pa));
98 assert(IS_PAGE_ALIGNED(base_va));
99 assert(IS_PAGE_ALIGNED(size));
100
101 if (!size)
102 return;
103
Antonio Nino Diazb5e7f772016-03-30 15:45:57 +0100104 assert(base_pa < end_pa); /* Check for overflows */
105 assert(base_va < end_va);
106
Antonio Nino Diazd1beee22016-12-13 15:28:54 +0000107 assert((base_va + (uintptr_t)size - (uintptr_t)1) <=
108 (PLAT_VIRT_ADDR_SPACE_SIZE - 1));
109 assert((base_pa + (unsigned long long)size - 1ULL) <=
110 (PLAT_PHY_ADDR_SPACE_SIZE - 1));
111
Antonio Nino Diazb5e7f772016-03-30 15:45:57 +0100112#if DEBUG
113
114 /* Check for PAs and VAs overlaps with all other regions */
115 for (mm = mmap; mm->size; ++mm) {
116
117 uintptr_t mm_end_va = mm->base_va + mm->size - 1;
118
119 /*
120 * Check if one of the regions is completely inside the other
121 * one.
122 */
123 int fully_overlapped_va =
124 ((base_va >= mm->base_va) && (end_va <= mm_end_va)) ||
125 ((mm->base_va >= base_va) && (mm_end_va <= end_va));
126
127 /*
128 * Full VA overlaps are only allowed if both regions are
129 * identity mapped (zero offset) or have the same VA to PA
130 * offset. Also, make sure that it's not the exact same area.
131 */
132 if (fully_overlapped_va) {
133 assert((mm->base_va - mm->base_pa) ==
134 (base_va - base_pa));
135 assert((base_va != mm->base_va) || (size != mm->size));
136 } else {
137 /*
138 * If the regions do not have fully overlapping VAs,
139 * then they must have fully separated VAs and PAs.
140 * Partial overlaps are not allowed
141 */
142
143 unsigned long long mm_end_pa =
144 mm->base_pa + mm->size - 1;
145
146 int separated_pa =
147 (end_pa < mm->base_pa) || (base_pa > mm_end_pa);
148 int separated_va =
149 (end_va < mm->base_va) || (base_va > mm_end_va);
150
151 assert(separated_va && separated_pa);
152 }
153 }
154
155 mm = mmap; /* Restore pointer to the start of the array */
156
157#endif /* DEBUG */
158
Soby Mathew44170c42016-03-22 15:51:08 +0000159 /* Find correct place in mmap to insert new region */
160 while (mm->base_va < base_va && mm->size)
161 ++mm;
162
Antonio Nino Diazb5e7f772016-03-30 15:45:57 +0100163 /*
164 * If a section is contained inside another one with the same base
165 * address, it must be placed after the one it is contained in:
166 *
167 * 1st |-----------------------|
168 * 2nd |------------|
169 * 3rd |------|
170 *
171 * This is required for mmap_region_attr() to get the attributes of the
172 * small region correctly.
173 */
174 while ((mm->base_va == base_va) && (mm->size > size))
175 ++mm;
176
Soby Mathew44170c42016-03-22 15:51:08 +0000177 /* Make room for new region by moving other regions up by one place */
178 memmove(mm + 1, mm, (uintptr_t)mm_last - (uintptr_t)mm);
179
180 /* Check we haven't lost the empty sentinal from the end of the array */
181 assert(mm_last->size == 0);
182
183 mm->base_pa = base_pa;
184 mm->base_va = base_va;
185 mm->size = size;
186 mm->attr = attr;
187
Antonio Nino Diazb5e7f772016-03-30 15:45:57 +0100188 if (end_pa > xlat_max_pa)
189 xlat_max_pa = end_pa;
190 if (end_va > xlat_max_va)
191 xlat_max_va = end_va;
Soby Mathew44170c42016-03-22 15:51:08 +0000192}
193
194void mmap_add(const mmap_region_t *mm)
195{
196 while (mm->size) {
197 mmap_add_region(mm->base_pa, mm->base_va, mm->size, mm->attr);
198 ++mm;
199 }
200}
201
202static uint64_t mmap_desc(unsigned attr, unsigned long long addr_pa,
203 int level)
204{
Sandrine Bailleux7528b682016-06-14 16:29:04 +0100205 uint64_t desc;
Soby Mathew44170c42016-03-22 15:51:08 +0000206 int mem_type;
207
Antonio Nino Diaz46a33a52016-12-08 16:03:46 +0000208 /* Make sure that the granularity is fine enough to map this address. */
209 assert((addr_pa & XLAT_BLOCK_MASK(level)) == 0);
210
Sandrine Bailleux7528b682016-06-14 16:29:04 +0100211 desc = addr_pa;
Antonio Nino Diazd48ae612016-08-02 09:21:41 +0100212 /*
213 * There are different translation table descriptors for level 3 and the
214 * rest.
215 */
216 desc |= (level == XLAT_TABLE_LEVEL_MAX) ? PAGE_DESC : BLOCK_DESC;
Sandrine Bailleux7528b682016-06-14 16:29:04 +0100217 desc |= (attr & MT_NS) ? LOWER_ATTRS(NS) : 0;
218 desc |= (attr & MT_RW) ? LOWER_ATTRS(AP_RW) : LOWER_ATTRS(AP_RO);
Soby Mathew44170c42016-03-22 15:51:08 +0000219 desc |= LOWER_ATTRS(ACCESS_FLAG);
220
Sandrine Bailleux7528b682016-06-14 16:29:04 +0100221 /*
222 * Deduce shareability domain and executability of the memory region
223 * from the memory type.
224 *
225 * Data accesses to device memory and non-cacheable normal memory are
226 * coherent for all observers in the system, and correspondingly are
227 * always treated as being Outer Shareable. Therefore, for these 2 types
228 * of memory, it is not strictly needed to set the shareability field
229 * in the translation tables.
230 */
Soby Mathew44170c42016-03-22 15:51:08 +0000231 mem_type = MT_TYPE(attr);
Sandrine Bailleux7528b682016-06-14 16:29:04 +0100232 if (mem_type == MT_DEVICE) {
Soby Mathew44170c42016-03-22 15:51:08 +0000233 desc |= LOWER_ATTRS(ATTR_DEVICE_INDEX | OSH);
Sandrine Bailleux7528b682016-06-14 16:29:04 +0100234 /*
235 * Always map device memory as execute-never.
236 * This is to avoid the possibility of a speculative instruction
237 * fetch, which could be an issue if this memory region
238 * corresponds to a read-sensitive peripheral.
239 */
Soby Mathew44170c42016-03-22 15:51:08 +0000240 desc |= UPPER_ATTRS(XN);
Sandrine Bailleux7528b682016-06-14 16:29:04 +0100241 } else { /* Normal memory */
242 /*
243 * Always map read-write normal memory as execute-never.
244 * (Trusted Firmware doesn't self-modify its code, therefore
245 * R/W memory is reserved for data storage, which must not be
246 * executable.)
247 * Note that setting the XN bit here is for consistency only.
248 * The enable_mmu_elx() function sets the SCTLR_EL3.WXN bit,
249 * which makes any writable memory region to be treated as
250 * execute-never, regardless of the value of the XN bit in the
251 * translation table.
Sandrine Bailleuxac3aa682016-06-14 16:31:09 +0100252 *
253 * For read-only memory, rely on the MT_EXECUTE/MT_EXECUTE_NEVER
254 * attribute to figure out the value of the XN bit.
Sandrine Bailleux7528b682016-06-14 16:29:04 +0100255 */
Sandrine Bailleuxac3aa682016-06-14 16:31:09 +0100256 if ((attr & MT_RW) || (attr & MT_EXECUTE_NEVER))
Sandrine Bailleux7528b682016-06-14 16:29:04 +0100257 desc |= UPPER_ATTRS(XN);
258
259 if (mem_type == MT_MEMORY) {
260 desc |= LOWER_ATTRS(ATTR_IWBWA_OWBWA_NTR_INDEX | ISH);
261 } else {
262 assert(mem_type == MT_NON_CACHEABLE);
263 desc |= LOWER_ATTRS(ATTR_NON_CACHEABLE_INDEX | OSH);
264 }
Soby Mathew44170c42016-03-22 15:51:08 +0000265 }
266
267 debug_print((mem_type == MT_MEMORY) ? "MEM" :
268 ((mem_type == MT_NON_CACHEABLE) ? "NC" : "DEV"));
269 debug_print(attr & MT_RW ? "-RW" : "-RO");
270 debug_print(attr & MT_NS ? "-NS" : "-S");
Sandrine Bailleuxac3aa682016-06-14 16:31:09 +0100271 debug_print(attr & MT_EXECUTE_NEVER ? "-XN" : "-EXEC");
Soby Mathew44170c42016-03-22 15:51:08 +0000272 return desc;
273}
274
Antonio Nino Diazb5e7f772016-03-30 15:45:57 +0100275/*
276 * Returns attributes of area at `base_va` with size `size`. It returns the
277 * attributes of the innermost region that contains it. If there are partial
278 * overlaps, it returns -1, as a smaller size is needed.
279 */
Soby Mathew44170c42016-03-22 15:51:08 +0000280static int mmap_region_attr(mmap_region_t *mm, uintptr_t base_va,
281 size_t size)
282{
Antonio Nino Diazb5e7f772016-03-30 15:45:57 +0100283 /* Don't assume that the area is contained in the first region */
284 int attr = -1;
Soby Mathew44170c42016-03-22 15:51:08 +0000285
Antonio Nino Diazb5e7f772016-03-30 15:45:57 +0100286 /*
287 * Get attributes from last (innermost) region that contains the
288 * requested area. Don't stop as soon as one region doesn't contain it
289 * because there may be other internal regions that contain this area:
290 *
291 * |-----------------------------1-----------------------------|
292 * |----2----| |-------3-------| |----5----|
293 * |--4--|
294 *
295 * |---| <- Area we want the attributes of.
296 *
297 * In this example, the area is contained in regions 1, 3 and 4 but not
298 * in region 2. The loop shouldn't stop at region 2 as inner regions
299 * have priority over outer regions, it should stop at region 5.
300 */
301 for (;; ++mm) {
Soby Mathew44170c42016-03-22 15:51:08 +0000302
303 if (!mm->size)
304 return attr; /* Reached end of list */
305
Soby Mathewfea233c2016-07-13 15:45:15 +0100306 if (mm->base_va > base_va + size - 1)
Soby Mathew44170c42016-03-22 15:51:08 +0000307 return attr; /* Next region is after area so end */
308
Soby Mathewfea233c2016-07-13 15:45:15 +0100309 if (mm->base_va + mm->size - 1 < base_va)
Soby Mathew44170c42016-03-22 15:51:08 +0000310 continue; /* Next region has already been overtaken */
311
Antonio Nino Diazb5e7f772016-03-30 15:45:57 +0100312 if (mm->attr == attr)
Soby Mathew44170c42016-03-22 15:51:08 +0000313 continue; /* Region doesn't override attribs so skip */
314
Soby Mathew44170c42016-03-22 15:51:08 +0000315 if (mm->base_va > base_va ||
Soby Mathewfea233c2016-07-13 15:45:15 +0100316 mm->base_va + mm->size - 1 < base_va + size - 1)
Soby Mathew44170c42016-03-22 15:51:08 +0000317 return -1; /* Region doesn't fully cover our area */
Antonio Nino Diazb5e7f772016-03-30 15:45:57 +0100318
319 attr = mm->attr;
Soby Mathew44170c42016-03-22 15:51:08 +0000320 }
321}
322
323static mmap_region_t *init_xlation_table_inner(mmap_region_t *mm,
324 uintptr_t base_va,
325 uint64_t *table,
326 int level)
327{
Antonio Nino Diazd48ae612016-08-02 09:21:41 +0100328 assert(level >= XLAT_TABLE_LEVEL_MIN && level <= XLAT_TABLE_LEVEL_MAX);
Soby Mathew44170c42016-03-22 15:51:08 +0000329
Antonio Nino Diazd48ae612016-08-02 09:21:41 +0100330 unsigned int level_size_shift =
331 L0_XLAT_ADDRESS_SHIFT - level * XLAT_TABLE_ENTRIES_SHIFT;
332 u_register_t level_size = (u_register_t)1 << level_size_shift;
333 u_register_t level_index_mask =
334 ((u_register_t)XLAT_TABLE_ENTRIES_MASK) << level_size_shift;
Soby Mathew44170c42016-03-22 15:51:08 +0000335
336 debug_print("New xlat table:\n");
337
338 do {
339 uint64_t desc = UNSET_DESC;
340
341 if (!mm->size) {
342 /* Done mapping regions; finish zeroing the table */
343 desc = INVALID_DESC;
Soby Mathewfea233c2016-07-13 15:45:15 +0100344 } else if (mm->base_va + mm->size - 1 < base_va) {
Antonio Nino Diazb5e7f772016-03-30 15:45:57 +0100345 /* This area is after the region so get next region */
Soby Mathew44170c42016-03-22 15:51:08 +0000346 ++mm;
347 continue;
348 }
349
Antonio Nino Diazd48ae612016-08-02 09:21:41 +0100350 debug_print("%s VA:%p size:0x%llx ", get_level_spacer(level),
351 (void *)base_va, (unsigned long long)level_size);
Soby Mathew44170c42016-03-22 15:51:08 +0000352
Soby Mathewfea233c2016-07-13 15:45:15 +0100353 if (mm->base_va > base_va + level_size - 1) {
Antonio Nino Diazb5e7f772016-03-30 15:45:57 +0100354 /* Next region is after this area. Nothing to map yet */
Soby Mathew44170c42016-03-22 15:51:08 +0000355 desc = INVALID_DESC;
Antonio Nino Diaz010888d2016-12-13 15:02:31 +0000356 /* Make sure that the current level allows block descriptors */
357 } else if (level >= XLAT_BLOCK_LEVEL_MIN) {
Antonio Nino Diazb5e7f772016-03-30 15:45:57 +0100358 /*
359 * Try to get attributes of this area. It will fail if
360 * there are partially overlapping regions. On success,
361 * it will return the innermost region's attributes.
362 */
Soby Mathew44170c42016-03-22 15:51:08 +0000363 int attr = mmap_region_attr(mm, base_va, level_size);
Antonio Nino Diazb5e7f772016-03-30 15:45:57 +0100364 if (attr >= 0) {
Soby Mathew44170c42016-03-22 15:51:08 +0000365 desc = mmap_desc(attr,
366 base_va - mm->base_va + mm->base_pa,
367 level);
Antonio Nino Diazb5e7f772016-03-30 15:45:57 +0100368 }
Soby Mathew44170c42016-03-22 15:51:08 +0000369 }
Soby Mathew44170c42016-03-22 15:51:08 +0000370
371 if (desc == UNSET_DESC) {
372 /* Area not covered by a region so need finer table */
373 uint64_t *new_table = xlat_tables[next_xlat++];
374 assert(next_xlat <= MAX_XLAT_TABLES);
Soby Mathewa0fedc42016-06-16 14:52:04 +0100375 desc = TABLE_DESC | (uintptr_t)new_table;
Soby Mathew44170c42016-03-22 15:51:08 +0000376
377 /* Recurse to fill in new table */
378 mm = init_xlation_table_inner(mm, base_va,
379 new_table, level+1);
380 }
381
382 debug_print("\n");
383
384 *table++ = desc;
385 base_va += level_size;
Antonio Nino Diazd1beee22016-12-13 15:28:54 +0000386 } while ((base_va & level_index_mask) &&
387 (base_va - 1 < PLAT_VIRT_ADDR_SPACE_SIZE - 1));
Soby Mathew44170c42016-03-22 15:51:08 +0000388
389 return mm;
390}
391
392void init_xlation_table(uintptr_t base_va, uint64_t *table,
393 int level, uintptr_t *max_va,
394 unsigned long long *max_pa)
395{
396
397 init_xlation_table_inner(mmap, base_va, table, level);
398 *max_va = xlat_max_va;
399 *max_pa = xlat_max_pa;
400}