Antonio Nino Diaz | 233c7c1 | 2017-03-08 14:40:23 +0000 | [diff] [blame] | 1 | /* |
Jeenu Viswambharan | 58e8148 | 2018-04-27 15:06:57 +0100 | [diff] [blame] | 2 | * Copyright (c) 2017-2018, ARM Limited and Contributors. All rights reserved. |
Antonio Nino Diaz | 233c7c1 | 2017-03-08 14:40:23 +0000 | [diff] [blame] | 3 | * |
dp-arm | fa3cf0b | 2017-05-03 09:38:09 +0100 | [diff] [blame] | 4 | * SPDX-License-Identifier: BSD-3-Clause |
Antonio Nino Diaz | 233c7c1 | 2017-03-08 14:40:23 +0000 | [diff] [blame] | 5 | */ |
| 6 | |
Antonio Nino Diaz | 50eb374 | 2018-07-24 10:20:53 +0100 | [diff] [blame] | 7 | #ifndef XLAT_TABLES_V2_H |
| 8 | #define XLAT_TABLES_V2_H |
Antonio Nino Diaz | 233c7c1 | 2017-03-08 14:40:23 +0000 | [diff] [blame] | 9 | |
| 10 | #include <xlat_tables_defs.h> |
Jeenu Viswambharan | 58e8148 | 2018-04-27 15:06:57 +0100 | [diff] [blame] | 11 | #include <xlat_tables_v2_helpers.h> |
Antonio Nino Diaz | 233c7c1 | 2017-03-08 14:40:23 +0000 | [diff] [blame] | 12 | |
| 13 | #ifndef __ASSEMBLY__ |
| 14 | #include <stddef.h> |
| 15 | #include <stdint.h> |
| 16 | #include <xlat_mmu_helpers.h> |
| 17 | |
Sandrine Bailleux | 8f23fa8 | 2017-09-28 21:58:12 +0100 | [diff] [blame] | 18 | /* |
| 19 | * Default granularity size for an mmap_region_t. |
| 20 | * Useful when no specific granularity is required. |
| 21 | * |
| 22 | * By default, choose the biggest possible block size allowed by the |
| 23 | * architectural state and granule size in order to minimize the number of page |
| 24 | * tables required for the mapping. |
Antonio Nino Diaz | 233c7c1 | 2017-03-08 14:40:23 +0000 | [diff] [blame] | 25 | */ |
Sandrine Bailleux | 8f23fa8 | 2017-09-28 21:58:12 +0100 | [diff] [blame] | 26 | #define REGION_DEFAULT_GRANULARITY XLAT_BLOCK_SIZE(MIN_LVL_BLOCK_DESC) |
| 27 | |
| 28 | /* Helper macro to define an mmap_region_t. */ |
| 29 | #define MAP_REGION(_pa, _va, _sz, _attr) \ |
Antonio Nino Diaz | 50eb374 | 2018-07-24 10:20:53 +0100 | [diff] [blame] | 30 | MAP_REGION_FULL_SPEC(_pa, _va, _sz, _attr, REGION_DEFAULT_GRANULARITY) |
Antonio Nino Diaz | 233c7c1 | 2017-03-08 14:40:23 +0000 | [diff] [blame] | 31 | |
Sandrine Bailleux | 8f23fa8 | 2017-09-28 21:58:12 +0100 | [diff] [blame] | 32 | /* Helper macro to define an mmap_region_t with an identity mapping. */ |
| 33 | #define MAP_REGION_FLAT(_adr, _sz, _attr) \ |
| 34 | MAP_REGION(_adr, _adr, _sz, _attr) |
| 35 | |
| 36 | /* |
Antonio Nino Diaz | c003328 | 2018-11-20 16:03:11 +0000 | [diff] [blame] | 37 | * Helper macro to define entries for mmap_region_t. It allows to define 'pa' |
| 38 | * and sets 'va' to 0 for each region. To be used with mmap_add_alloc_va(). |
| 39 | */ |
| 40 | #define MAP_REGION_ALLOC_VA(pa, sz, attr) MAP_REGION(pa, 0, sz, attr) |
| 41 | |
| 42 | /* |
Sandrine Bailleux | 8f23fa8 | 2017-09-28 21:58:12 +0100 | [diff] [blame] | 43 | * Helper macro to define an mmap_region_t to map with the desired granularity |
| 44 | * of translation tables. |
| 45 | * |
| 46 | * The granularity value passed to this macro must be a valid block or page |
| 47 | * size. When using a 4KB translation granule, this might be 4KB, 2MB or 1GB. |
| 48 | * Passing REGION_DEFAULT_GRANULARITY is also allowed and means that the library |
| 49 | * is free to choose the granularity for this region. In this case, it is |
| 50 | * equivalent to the MAP_REGION() macro. |
Antonio Nino Diaz | 233c7c1 | 2017-03-08 14:40:23 +0000 | [diff] [blame] | 51 | */ |
Sandrine Bailleux | 8f23fa8 | 2017-09-28 21:58:12 +0100 | [diff] [blame] | 52 | #define MAP_REGION2(_pa, _va, _sz, _attr, _gr) \ |
Antonio Nino Diaz | 50eb374 | 2018-07-24 10:20:53 +0100 | [diff] [blame] | 53 | MAP_REGION_FULL_SPEC(_pa, _va, _sz, _attr, _gr) |
Antonio Nino Diaz | 233c7c1 | 2017-03-08 14:40:23 +0000 | [diff] [blame] | 54 | |
| 55 | /* |
Antonio Nino Diaz | 8643a81 | 2018-06-21 14:39:16 +0100 | [diff] [blame] | 56 | * Shifts and masks to access fields of an mmap attribute |
Antonio Nino Diaz | 233c7c1 | 2017-03-08 14:40:23 +0000 | [diff] [blame] | 57 | */ |
Varun Wadekar | c6a11f6 | 2017-05-25 18:04:48 -0700 | [diff] [blame] | 58 | #define MT_TYPE_MASK U(0x7) |
Antonio Nino Diaz | 233c7c1 | 2017-03-08 14:40:23 +0000 | [diff] [blame] | 59 | #define MT_TYPE(_attr) ((_attr) & MT_TYPE_MASK) |
| 60 | /* Access permissions (RO/RW) */ |
Varun Wadekar | c6a11f6 | 2017-05-25 18:04:48 -0700 | [diff] [blame] | 61 | #define MT_PERM_SHIFT U(3) |
Antonio Nino Diaz | 233c7c1 | 2017-03-08 14:40:23 +0000 | [diff] [blame] | 62 | /* Security state (SECURE/NS) */ |
Varun Wadekar | c6a11f6 | 2017-05-25 18:04:48 -0700 | [diff] [blame] | 63 | #define MT_SEC_SHIFT U(4) |
Antonio Nino Diaz | 233c7c1 | 2017-03-08 14:40:23 +0000 | [diff] [blame] | 64 | /* Access permissions for instruction execution (EXECUTE/EXECUTE_NEVER) */ |
Varun Wadekar | c6a11f6 | 2017-05-25 18:04:48 -0700 | [diff] [blame] | 65 | #define MT_EXECUTE_SHIFT U(5) |
Antonio Nino Diaz | 8643a81 | 2018-06-21 14:39:16 +0100 | [diff] [blame] | 66 | /* In the EL1&0 translation regime, User (EL0) or Privileged (EL1). */ |
Antonio Nino Diaz | dcf9d92 | 2017-10-04 16:52:15 +0100 | [diff] [blame] | 67 | #define MT_USER_SHIFT U(6) |
Antonio Nino Diaz | ac99803 | 2017-02-27 17:23:54 +0000 | [diff] [blame] | 68 | /* All other bits are reserved */ |
Antonio Nino Diaz | 233c7c1 | 2017-03-08 14:40:23 +0000 | [diff] [blame] | 69 | |
| 70 | /* |
| 71 | * Memory mapping attributes |
| 72 | */ |
Antonio Nino Diaz | 8643a81 | 2018-06-21 14:39:16 +0100 | [diff] [blame] | 73 | |
| 74 | /* |
| 75 | * Memory types supported. |
| 76 | * These are organised so that, going down the list, the memory types are |
| 77 | * getting weaker; conversely going up the list the memory types are getting |
| 78 | * stronger. |
| 79 | */ |
| 80 | #define MT_DEVICE U(0) |
| 81 | #define MT_NON_CACHEABLE U(1) |
| 82 | #define MT_MEMORY U(2) |
| 83 | /* Values up to 7 are reserved to add new memory types in the future */ |
Antonio Nino Diaz | 233c7c1 | 2017-03-08 14:40:23 +0000 | [diff] [blame] | 84 | |
Antonio Nino Diaz | 8643a81 | 2018-06-21 14:39:16 +0100 | [diff] [blame] | 85 | #define MT_RO (U(0) << MT_PERM_SHIFT) |
| 86 | #define MT_RW (U(1) << MT_PERM_SHIFT) |
Antonio Nino Diaz | 233c7c1 | 2017-03-08 14:40:23 +0000 | [diff] [blame] | 87 | |
Antonio Nino Diaz | 8643a81 | 2018-06-21 14:39:16 +0100 | [diff] [blame] | 88 | #define MT_SECURE (U(0) << MT_SEC_SHIFT) |
| 89 | #define MT_NS (U(1) << MT_SEC_SHIFT) |
Antonio Nino Diaz | 233c7c1 | 2017-03-08 14:40:23 +0000 | [diff] [blame] | 90 | |
Antonio Nino Diaz | 8643a81 | 2018-06-21 14:39:16 +0100 | [diff] [blame] | 91 | /* |
| 92 | * Access permissions for instruction execution are only relevant for normal |
| 93 | * read-only memory, i.e. MT_MEMORY | MT_RO. They are ignored (and potentially |
| 94 | * overridden) otherwise: |
| 95 | * - Device memory is always marked as execute-never. |
| 96 | * - Read-write normal memory is always marked as execute-never. |
| 97 | */ |
| 98 | #define MT_EXECUTE (U(0) << MT_EXECUTE_SHIFT) |
| 99 | #define MT_EXECUTE_NEVER (U(1) << MT_EXECUTE_SHIFT) |
Antonio Nino Diaz | dcf9d92 | 2017-10-04 16:52:15 +0100 | [diff] [blame] | 100 | |
Antonio Nino Diaz | 8643a81 | 2018-06-21 14:39:16 +0100 | [diff] [blame] | 101 | /* |
| 102 | * When mapping a region at EL0 or EL1, this attribute will be used to determine |
| 103 | * if a User mapping (EL0) will be created or a Privileged mapping (EL1). |
| 104 | */ |
| 105 | #define MT_USER (U(1) << MT_USER_SHIFT) |
| 106 | #define MT_PRIVILEGED (U(0) << MT_USER_SHIFT) |
Antonio Nino Diaz | 233c7c1 | 2017-03-08 14:40:23 +0000 | [diff] [blame] | 107 | |
Antonio Nino Diaz | dcf9d92 | 2017-10-04 16:52:15 +0100 | [diff] [blame] | 108 | /* Compound attributes for most common usages */ |
Antonio Nino Diaz | 8643a81 | 2018-06-21 14:39:16 +0100 | [diff] [blame] | 109 | #define MT_CODE (MT_MEMORY | MT_RO | MT_EXECUTE) |
| 110 | #define MT_RO_DATA (MT_MEMORY | MT_RO | MT_EXECUTE_NEVER) |
| 111 | #define MT_RW_DATA (MT_MEMORY | MT_RW | MT_EXECUTE_NEVER) |
| 112 | |
Antonio Nino Diaz | 233c7c1 | 2017-03-08 14:40:23 +0000 | [diff] [blame] | 113 | /* |
| 114 | * Structure for specifying a single region of memory. |
| 115 | */ |
| 116 | typedef struct mmap_region { |
| 117 | unsigned long long base_pa; |
| 118 | uintptr_t base_va; |
| 119 | size_t size; |
Antonio Nino Diaz | 8643a81 | 2018-06-21 14:39:16 +0100 | [diff] [blame] | 120 | unsigned int attr; |
Sandrine Bailleux | 8f23fa8 | 2017-09-28 21:58:12 +0100 | [diff] [blame] | 121 | /* Desired granularity. See the MAP_REGION2() macro for more details. */ |
| 122 | size_t granularity; |
Antonio Nino Diaz | 233c7c1 | 2017-03-08 14:40:23 +0000 | [diff] [blame] | 123 | } mmap_region_t; |
| 124 | |
Sandrine Bailleux | 3120ea2 | 2017-07-10 13:37:48 +0100 | [diff] [blame] | 125 | /* |
Antonio Nino Diaz | 9d596c4 | 2018-07-12 15:43:07 +0100 | [diff] [blame] | 126 | * Translation regimes supported by this library. EL_REGIME_INVALID tells the |
| 127 | * library to detect it at runtime. |
Douglas Raillard | 2d54579 | 2017-09-25 15:23:22 +0100 | [diff] [blame] | 128 | */ |
Antonio Nino Diaz | f1b84f6 | 2018-07-03 11:58:49 +0100 | [diff] [blame] | 129 | #define EL1_EL0_REGIME 1 |
Antonio Nino Diaz | 128de8d | 2018-08-07 19:59:49 +0100 | [diff] [blame] | 130 | #define EL2_REGIME 2 |
Antonio Nino Diaz | f1b84f6 | 2018-07-03 11:58:49 +0100 | [diff] [blame] | 131 | #define EL3_REGIME 3 |
Antonio Nino Diaz | 9d596c4 | 2018-07-12 15:43:07 +0100 | [diff] [blame] | 132 | #define EL_REGIME_INVALID -1 |
Douglas Raillard | 2d54579 | 2017-09-25 15:23:22 +0100 | [diff] [blame] | 133 | |
| 134 | /* |
Sandrine Bailleux | 3120ea2 | 2017-07-10 13:37:48 +0100 | [diff] [blame] | 135 | * Declare the translation context type. |
| 136 | * Its definition is private. |
| 137 | */ |
| 138 | typedef struct xlat_ctx xlat_ctx_t; |
| 139 | |
| 140 | /* |
| 141 | * Statically allocate a translation context and associated structures. Also |
| 142 | * initialize them. |
| 143 | * |
| 144 | * _ctx_name: |
| 145 | * Prefix for the translation context variable. |
| 146 | * E.g. If _ctx_name is 'foo', the variable will be called 'foo_xlat_ctx'. |
| 147 | * Useful to distinguish multiple contexts from one another. |
| 148 | * |
| 149 | * _mmap_count: |
| 150 | * Number of mmap_region_t to allocate. |
| 151 | * Would typically be MAX_MMAP_REGIONS for the translation context describing |
| 152 | * the BL image currently executing. |
| 153 | * |
| 154 | * _xlat_tables_count: |
| 155 | * Number of sub-translation tables to allocate. |
| 156 | * Would typically be MAX_XLAT_TABLES for the translation context describing |
| 157 | * the BL image currently executing. |
| 158 | * Note that this is only for sub-tables ; at the initial lookup level, there |
| 159 | * is always a single table. |
| 160 | * |
| 161 | * _virt_addr_space_size, _phy_addr_space_size: |
| 162 | * Size (in bytes) of the virtual (resp. physical) address space. |
| 163 | * Would typically be PLAT_VIRT_ADDR_SPACE_SIZE |
| 164 | * (resp. PLAT_PHY_ADDR_SPACE_SIZE) for the translation context describing the |
| 165 | * BL image currently executing. |
| 166 | */ |
Antonio Nino Diaz | f1b84f6 | 2018-07-03 11:58:49 +0100 | [diff] [blame] | 167 | #define REGISTER_XLAT_CONTEXT(_ctx_name, _mmap_count, _xlat_tables_count, \ |
| 168 | _virt_addr_space_size, _phy_addr_space_size) \ |
Antonio Nino Diaz | 50eb374 | 2018-07-24 10:20:53 +0100 | [diff] [blame] | 169 | REGISTER_XLAT_CONTEXT_FULL_SPEC(_ctx_name, (_mmap_count), \ |
Antonio Nino Diaz | f1b84f6 | 2018-07-03 11:58:49 +0100 | [diff] [blame] | 170 | (_xlat_tables_count), \ |
| 171 | (_virt_addr_space_size), \ |
| 172 | (_phy_addr_space_size), \ |
Antonio Nino Diaz | 9d596c4 | 2018-07-12 15:43:07 +0100 | [diff] [blame] | 173 | EL_REGIME_INVALID, "xlat_table") |
Antonio Nino Diaz | dcf9d92 | 2017-10-04 16:52:15 +0100 | [diff] [blame] | 174 | |
| 175 | /* |
Antonio Nino Diaz | 086fbd6 | 2017-11-17 11:48:55 +0000 | [diff] [blame] | 176 | * Same as REGISTER_XLAT_CONTEXT plus the additional parameters: |
| 177 | * |
| 178 | * _xlat_regime: |
| 179 | * Specify the translation regime managed by this xlat_ctx_t instance. The |
Antonio Nino Diaz | f1b84f6 | 2018-07-03 11:58:49 +0100 | [diff] [blame] | 180 | * values are the one from the EL*_REGIME definitions. |
Antonio Nino Diaz | 086fbd6 | 2017-11-17 11:48:55 +0000 | [diff] [blame] | 181 | * |
| 182 | * _section_name: |
| 183 | * Specify the name of the section where the translation tables have to be |
| 184 | * placed by the linker. |
Antonio Nino Diaz | dcf9d92 | 2017-10-04 16:52:15 +0100 | [diff] [blame] | 185 | */ |
Antonio Nino Diaz | f1b84f6 | 2018-07-03 11:58:49 +0100 | [diff] [blame] | 186 | #define REGISTER_XLAT_CONTEXT2(_ctx_name, _mmap_count, _xlat_tables_count, \ |
| 187 | _virt_addr_space_size, _phy_addr_space_size, \ |
| 188 | _xlat_regime, _section_name) \ |
Antonio Nino Diaz | 50eb374 | 2018-07-24 10:20:53 +0100 | [diff] [blame] | 189 | REGISTER_XLAT_CONTEXT_FULL_SPEC(_ctx_name, (_mmap_count), \ |
Antonio Nino Diaz | f1b84f6 | 2018-07-03 11:58:49 +0100 | [diff] [blame] | 190 | (_xlat_tables_count), \ |
| 191 | (_virt_addr_space_size), \ |
| 192 | (_phy_addr_space_size), \ |
| 193 | (_xlat_regime), (_section_name)) |
Sandrine Bailleux | 3120ea2 | 2017-07-10 13:37:48 +0100 | [diff] [blame] | 194 | |
Sandrine Bailleux | 6634293 | 2017-07-18 13:26:36 +0100 | [diff] [blame] | 195 | /****************************************************************************** |
| 196 | * Generic translation table APIs. |
| 197 | * Each API comes in 2 variants: |
| 198 | * - one that acts on the current translation context for this BL image |
| 199 | * - another that acts on the given translation context instead. This variant |
| 200 | * is named after the 1st version, with an additional '_ctx' suffix. |
| 201 | *****************************************************************************/ |
Antonio Nino Diaz | 9b11f39 | 2017-05-08 16:43:53 +0100 | [diff] [blame] | 202 | |
| 203 | /* |
| 204 | * Initialize translation tables from the current list of mmap regions. Calling |
| 205 | * this function marks the transition point after which static regions can no |
| 206 | * longer be added. |
| 207 | */ |
Antonio Nino Diaz | 233c7c1 | 2017-03-08 14:40:23 +0000 | [diff] [blame] | 208 | void init_xlat_tables(void); |
Sandrine Bailleux | 6634293 | 2017-07-18 13:26:36 +0100 | [diff] [blame] | 209 | void init_xlat_tables_ctx(xlat_ctx_t *ctx); |
Antonio Nino Diaz | 233c7c1 | 2017-03-08 14:40:23 +0000 | [diff] [blame] | 210 | |
| 211 | /* |
Antonio Nino Diaz | 9b11f39 | 2017-05-08 16:43:53 +0100 | [diff] [blame] | 212 | * Add a static region with defined base PA and base VA. This function can only |
| 213 | * be used before initializing the translation tables. The region cannot be |
| 214 | * removed afterwards. |
Antonio Nino Diaz | 233c7c1 | 2017-03-08 14:40:23 +0000 | [diff] [blame] | 215 | */ |
| 216 | void mmap_add_region(unsigned long long base_pa, uintptr_t base_va, |
Antonio Nino Diaz | 8643a81 | 2018-06-21 14:39:16 +0100 | [diff] [blame] | 217 | size_t size, unsigned int attr); |
Sandrine Bailleux | 6634293 | 2017-07-18 13:26:36 +0100 | [diff] [blame] | 218 | void mmap_add_region_ctx(xlat_ctx_t *ctx, const mmap_region_t *mm); |
Antonio Nino Diaz | 233c7c1 | 2017-03-08 14:40:23 +0000 | [diff] [blame] | 219 | |
| 220 | /* |
Sandrine Bailleux | 6634293 | 2017-07-18 13:26:36 +0100 | [diff] [blame] | 221 | * Add an array of static regions with defined base PA and base VA. This |
| 222 | * function can only be used before initializing the translation tables. The |
| 223 | * regions cannot be removed afterwards. |
| 224 | */ |
| 225 | void mmap_add(const mmap_region_t *mm); |
| 226 | void mmap_add_ctx(xlat_ctx_t *ctx, const mmap_region_t *mm); |
| 227 | |
Antonio Nino Diaz | c003328 | 2018-11-20 16:03:11 +0000 | [diff] [blame] | 228 | /* |
| 229 | * Add a region with defined base PA. Returns base VA calculated using the |
| 230 | * highest existing region in the mmap array even if it fails to allocate the |
| 231 | * region. |
| 232 | */ |
| 233 | void mmap_add_region_alloc_va(unsigned long long base_pa, uintptr_t *base_va, |
| 234 | size_t size, unsigned int attr); |
| 235 | void mmap_add_region_alloc_va_ctx(xlat_ctx_t *ctx, mmap_region_t *mm); |
| 236 | |
| 237 | /* |
| 238 | * Add an array of static regions with defined base PA, and fill the base VA |
| 239 | * field on the array of structs. This function can only be used before |
| 240 | * initializing the translation tables. The regions cannot be removed afterwards. |
| 241 | */ |
| 242 | void mmap_add_alloc_va(mmap_region_t *mm); |
Sandrine Bailleux | 6634293 | 2017-07-18 13:26:36 +0100 | [diff] [blame] | 243 | |
| 244 | #if PLAT_XLAT_TABLES_DYNAMIC |
| 245 | /* |
Antonio Nino Diaz | 9b11f39 | 2017-05-08 16:43:53 +0100 | [diff] [blame] | 246 | * Add a dynamic region with defined base PA and base VA. This type of region |
| 247 | * can be added and removed even after the translation tables are initialized. |
Antonio Nino Diaz | ac99803 | 2017-02-27 17:23:54 +0000 | [diff] [blame] | 248 | * |
| 249 | * Returns: |
| 250 | * 0: Success. |
| 251 | * EINVAL: Invalid values were used as arguments. |
| 252 | * ERANGE: Memory limits were surpassed. |
| 253 | * ENOMEM: Not enough space in the mmap array or not enough free xlat tables. |
| 254 | * EPERM: It overlaps another region in an invalid way. |
| 255 | */ |
| 256 | int mmap_add_dynamic_region(unsigned long long base_pa, uintptr_t base_va, |
Antonio Nino Diaz | 8643a81 | 2018-06-21 14:39:16 +0100 | [diff] [blame] | 257 | size_t size, unsigned int attr); |
Sandrine Bailleux | 6634293 | 2017-07-18 13:26:36 +0100 | [diff] [blame] | 258 | int mmap_add_dynamic_region_ctx(xlat_ctx_t *ctx, mmap_region_t *mm); |
Antonio Nino Diaz | ac99803 | 2017-02-27 17:23:54 +0000 | [diff] [blame] | 259 | |
| 260 | /* |
Antonio Nino Diaz | c003328 | 2018-11-20 16:03:11 +0000 | [diff] [blame] | 261 | * Add a dynamic region with defined base PA. Returns base VA calculated using |
| 262 | * the highest existing region in the mmap array even if it fails to allocate |
| 263 | * the region. |
| 264 | * |
| 265 | * mmap_add_dynamic_region_alloc_va() returns the allocated VA in 'base_va'. |
| 266 | * mmap_add_dynamic_region_alloc_va_ctx() returns it in 'mm->base_va'. |
| 267 | * |
| 268 | * It returns the same error values as mmap_add_dynamic_region(). |
| 269 | */ |
| 270 | int mmap_add_dynamic_region_alloc_va(unsigned long long base_pa, |
| 271 | uintptr_t *base_va, |
| 272 | size_t size, unsigned int attr); |
| 273 | int mmap_add_dynamic_region_alloc_va_ctx(xlat_ctx_t *ctx, mmap_region_t *mm); |
| 274 | |
| 275 | /* |
Antonio Nino Diaz | ac99803 | 2017-02-27 17:23:54 +0000 | [diff] [blame] | 276 | * Remove a region with the specified base VA and size. Only dynamic regions can |
Antonio Nino Diaz | 9b11f39 | 2017-05-08 16:43:53 +0100 | [diff] [blame] | 277 | * be removed, and they can be removed even if the translation tables are |
| 278 | * initialized. |
Antonio Nino Diaz | ac99803 | 2017-02-27 17:23:54 +0000 | [diff] [blame] | 279 | * |
| 280 | * Returns: |
| 281 | * 0: Success. |
| 282 | * EINVAL: The specified region wasn't found. |
| 283 | * EPERM: Trying to remove a static region. |
| 284 | */ |
| 285 | int mmap_remove_dynamic_region(uintptr_t base_va, size_t size); |
Sandrine Bailleux | 6634293 | 2017-07-18 13:26:36 +0100 | [diff] [blame] | 286 | int mmap_remove_dynamic_region_ctx(xlat_ctx_t *ctx, |
| 287 | uintptr_t base_va, |
| 288 | size_t size); |
| 289 | |
| 290 | #endif /* PLAT_XLAT_TABLES_DYNAMIC */ |
Antonio Nino Diaz | ac99803 | 2017-02-27 17:23:54 +0000 | [diff] [blame] | 291 | |
Sandrine Bailleux | c3708e2 | 2017-10-13 14:17:09 +0100 | [diff] [blame] | 292 | /* |
Sandrine Bailleux | 439c901 | 2017-10-17 12:02:03 +0100 | [diff] [blame] | 293 | * Change the memory attributes of the memory region starting from a given |
| 294 | * virtual address in a set of translation tables. |
| 295 | * |
| 296 | * This function can only be used after the translation tables have been |
| 297 | * initialized. |
| 298 | * |
| 299 | * The base address of the memory region must be aligned on a page boundary. |
| 300 | * The size of this memory region must be a multiple of a page size. |
| 301 | * The memory region must be already mapped by the given translation tables |
| 302 | * and it must be mapped at the granularity of a page. |
| 303 | * |
| 304 | * Return 0 on success, a negative value on error. |
| 305 | * |
| 306 | * In case of error, the memory attributes remain unchanged and this function |
| 307 | * has no effect. |
| 308 | * |
| 309 | * ctx |
| 310 | * Translation context to work on. |
| 311 | * base_va: |
| 312 | * Virtual address of the 1st page to change the attributes of. |
| 313 | * size: |
| 314 | * Size in bytes of the memory region. |
| 315 | * attr: |
| 316 | * New attributes of the page tables. The attributes that can be changed are |
| 317 | * data access (MT_RO/MT_RW), instruction access (MT_EXECUTE_NEVER/MT_EXECUTE) |
| 318 | * and user/privileged access (MT_USER/MT_PRIVILEGED) in the case of contexts |
| 319 | * that are used in the EL1&0 translation regime. Also, note that this |
| 320 | * function doesn't allow to remap a region as RW and executable, or to remap |
| 321 | * device memory as executable. |
| 322 | * |
| 323 | * NOTE: The caller of this function must be able to write to the translation |
| 324 | * tables, i.e. the memory where they are stored must be mapped with read-write |
| 325 | * access permissions. This function assumes it is the case. If this is not |
| 326 | * the case then this function might trigger a data abort exception. |
| 327 | * |
| 328 | * NOTE2: The caller is responsible for making sure that the targeted |
| 329 | * translation tables are not modified by any other code while this function is |
| 330 | * executing. |
| 331 | */ |
Antonio Nino Diaz | 6c4c9ee | 2018-08-05 15:34:10 +0100 | [diff] [blame] | 332 | int xlat_change_mem_attributes_ctx(const xlat_ctx_t *ctx, uintptr_t base_va, |
| 333 | size_t size, uint32_t attr); |
| 334 | int xlat_change_mem_attributes(uintptr_t base_va, size_t size, uint32_t attr); |
Sandrine Bailleux | 439c901 | 2017-10-17 12:02:03 +0100 | [diff] [blame] | 335 | |
| 336 | /* |
Sandrine Bailleux | c3708e2 | 2017-10-13 14:17:09 +0100 | [diff] [blame] | 337 | * Query the memory attributes of a memory page in a set of translation tables. |
| 338 | * |
| 339 | * Return 0 on success, a negative error code on error. |
Antonio Nino Diaz | 6c4c9ee | 2018-08-05 15:34:10 +0100 | [diff] [blame] | 340 | * On success, the attributes are stored into *attr. |
Sandrine Bailleux | c3708e2 | 2017-10-13 14:17:09 +0100 | [diff] [blame] | 341 | * |
| 342 | * ctx |
| 343 | * Translation context to work on. |
| 344 | * base_va |
| 345 | * Virtual address of the page to get the attributes of. |
| 346 | * There are no alignment restrictions on this address. The attributes of the |
| 347 | * memory page it lies within are returned. |
Antonio Nino Diaz | 6c4c9ee | 2018-08-05 15:34:10 +0100 | [diff] [blame] | 348 | * attr |
Sandrine Bailleux | c3708e2 | 2017-10-13 14:17:09 +0100 | [diff] [blame] | 349 | * Output parameter where to store the attributes of the targeted memory page. |
| 350 | */ |
Antonio Nino Diaz | 6c4c9ee | 2018-08-05 15:34:10 +0100 | [diff] [blame] | 351 | int xlat_get_mem_attributes_ctx(const xlat_ctx_t *ctx, uintptr_t base_va, |
| 352 | uint32_t *attr); |
| 353 | int xlat_get_mem_attributes(uintptr_t base_va, uint32_t *attr); |
Sandrine Bailleux | c3708e2 | 2017-10-13 14:17:09 +0100 | [diff] [blame] | 354 | |
Antonio Nino Diaz | 233c7c1 | 2017-03-08 14:40:23 +0000 | [diff] [blame] | 355 | #endif /*__ASSEMBLY__*/ |
Antonio Nino Diaz | 50eb374 | 2018-07-24 10:20:53 +0100 | [diff] [blame] | 356 | #endif /* XLAT_TABLES_V2_H */ |