git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_MPU_M33F_NXP_LPC55S69_MCUXpresso/NXP_Code/CMSIS/mpu_armv8.h

   1 /******************************************************************************\r
   2  * @file     mpu_armv8.h\r
   3  * @brief    CMSIS MPU API for Armv8-M and Armv8.1-M MPU\r
   4  * @version  V5.1.0\r
   5  * @date     08. March 2019\r
   6  ******************************************************************************/\r
   7 /*\r
   8  * Copyright (c) 2017-2019 Arm Limited. All rights reserved.\r
   9  *\r
  10  * SPDX-License-Identifier: Apache-2.0\r
  11  *\r
  12  * Licensed under the Apache License, Version 2.0 (the License); you may\r
  13  * not use this file except in compliance with the License.\r
  14  * You may obtain a copy of the License at\r
  15  *\r
  16  * www.apache.org/licenses/LICENSE-2.0\r
  17  *\r
  18  * Unless required by applicable law or agreed to in writing, software\r
  19  * distributed under the License is distributed on an AS IS BASIS, WITHOUT\r
  20  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  21  * See the License for the specific language governing permissions and\r
  22  * limitations under the License.\r
  23  */\r
  24 \r
  25 #if   defined ( __ICCARM__ )\r
  26   #pragma system_include         /* treat file as system include file for MISRA check */\r
  27 #elif defined (__clang__)\r
  28   #pragma clang system_header    /* treat file as system include file */\r
  29 #endif\r
  30 \r
  31 #ifndef ARM_MPU_ARMV8_H\r
  32 #define ARM_MPU_ARMV8_H\r
  33 \r
  34 /** \brief Attribute for device memory (outer only) */\r
  35 #define ARM_MPU_ATTR_DEVICE                           ( 0U )\r
  36 \r
  37 /** \brief Attribute for non-cacheable, normal memory */\r
  38 #define ARM_MPU_ATTR_NON_CACHEABLE                    ( 4U )\r
  39 \r
  40 /** \brief Attribute for normal memory (outer and inner)\r
  41 * \param NT Non-Transient: Set to 1 for non-transient data.\r
  42 * \param WB Write-Back: Set to 1 to use write-back update policy.\r
  43 * \param RA Read Allocation: Set to 1 to use cache allocation on read miss.\r
  44 * \param WA Write Allocation: Set to 1 to use cache allocation on write miss.\r
  45 */\r
  46 #define ARM_MPU_ATTR_MEMORY_(NT, WB, RA, WA) \\r
  47   (((NT & 1U) << 3U) | ((WB & 1U) << 2U) | ((RA & 1U) << 1U) | (WA & 1U))\r
  48 \r
  49 /** \brief Device memory type non Gathering, non Re-ordering, non Early Write Acknowledgement */\r
  50 #define ARM_MPU_ATTR_DEVICE_nGnRnE (0U)\r
  51 \r
  52 /** \brief Device memory type non Gathering, non Re-ordering, Early Write Acknowledgement */\r
  53 #define ARM_MPU_ATTR_DEVICE_nGnRE  (1U)\r
  54 \r
  55 /** \brief Device memory type non Gathering, Re-ordering, Early Write Acknowledgement */\r
  56 #define ARM_MPU_ATTR_DEVICE_nGRE   (2U)\r
  57 \r
  58 /** \brief Device memory type Gathering, Re-ordering, Early Write Acknowledgement */\r
  59 #define ARM_MPU_ATTR_DEVICE_GRE    (3U)\r
  60 \r
  61 /** \brief Memory Attribute\r
  62 * \param O Outer memory attributes\r
  63 * \param I O == ARM_MPU_ATTR_DEVICE: Device memory attributes, else: Inner memory attributes\r
  64 */\r
  65 #define ARM_MPU_ATTR(O, I) (((O & 0xFU) << 4U) | (((O & 0xFU) != 0U) ? (I & 0xFU) : ((I & 0x3U) << 2U)))\r
  66 \r
  67 /** \brief Normal memory non-shareable  */\r
  68 #define ARM_MPU_SH_NON   (0U)\r
  69 \r
  70 /** \brief Normal memory outer shareable  */\r
  71 #define ARM_MPU_SH_OUTER (2U)\r
  72 \r
  73 /** \brief Normal memory inner shareable  */\r
  74 #define ARM_MPU_SH_INNER (3U)\r
  75 \r
  76 /** \brief Memory access permissions\r
  77 * \param RO Read-Only: Set to 1 for read-only memory.\r
  78 * \param NP Non-Privileged: Set to 1 for non-privileged memory.\r
  79 */\r
  80 #define ARM_MPU_AP_(RO, NP) (((RO & 1U) << 1U) | (NP & 1U))\r
  81 \r
  82 /** \brief Region Base Address Register value\r
  83 * \param BASE The base address bits [31:5] of a memory region. The value is zero extended. Effective address gets 32 byte aligned.\r
  84 * \param SH Defines the Shareability domain for this memory region.\r
  85 * \param RO Read-Only: Set to 1 for a read-only memory region.\r
  86 * \param NP Non-Privileged: Set to 1 for a non-privileged memory region.\r
  87 * \oaram XN eXecute Never: Set to 1 for a non-executable memory region.\r
  88 */\r
  89 #define ARM_MPU_RBAR(BASE, SH, RO, NP, XN) \\r
  90   ((BASE & MPU_RBAR_BASE_Msk) | \\r
  91   ((SH << MPU_RBAR_SH_Pos) & MPU_RBAR_SH_Msk) | \\r
  92   ((ARM_MPU_AP_(RO, NP) << MPU_RBAR_AP_Pos) & MPU_RBAR_AP_Msk) | \\r
  93   ((XN << MPU_RBAR_XN_Pos) & MPU_RBAR_XN_Msk))\r
  94 \r
  95 /** \brief Region Limit Address Register value\r
  96 * \param LIMIT The limit address bits [31:5] for this memory region. The value is one extended.\r
  97 * \param IDX The attribute index to be associated with this memory region.\r
  98 */\r
  99 #define ARM_MPU_RLAR(LIMIT, IDX) \\r
 100   ((LIMIT & MPU_RLAR_LIMIT_Msk) | \\r
 101   ((IDX << MPU_RLAR_AttrIndx_Pos) & MPU_RLAR_AttrIndx_Msk) | \\r
 102   (MPU_RLAR_EN_Msk))\r
 103 \r
 104 #if defined(MPU_RLAR_PXN_Pos)\r
 105   \r
 106 /** \brief Region Limit Address Register with PXN value\r
 107 * \param LIMIT The limit address bits [31:5] for this memory region. The value is one extended.\r
 108 * \param PXN Privileged execute never. Defines whether code can be executed from this privileged region.\r
 109 * \param IDX The attribute index to be associated with this memory region.\r
 110 */\r
 111 #define ARM_MPU_RLAR_PXN(LIMIT, PXN, IDX) \\r
 112   ((LIMIT & MPU_RLAR_LIMIT_Msk) | \\r
 113   ((PXN << MPU_RLAR_PXN_Pos) & MPU_RLAR_PXN_Msk) | \\r
 114   ((IDX << MPU_RLAR_AttrIndx_Pos) & MPU_RLAR_AttrIndx_Msk) | \\r
 115   (MPU_RLAR_EN_Msk))\r
 116   \r
 117 #endif\r
 118 \r
 119 /**\r
 120 * Struct for a single MPU Region\r
 121 */\r
 122 typedef struct {\r
 123   uint32_t RBAR;                   /*!< Region Base Address Register value */\r
 124   uint32_t RLAR;                   /*!< Region Limit Address Register value */\r
 125 } ARM_MPU_Region_t;\r
 126     \r
 127 /** Enable the MPU.\r
 128 * \param MPU_Control Default access permissions for unconfigured regions.\r
 129 */\r
 130 __STATIC_INLINE void ARM_MPU_Enable(uint32_t MPU_Control)\r
 131 {\r
 132   MPU->CTRL = MPU_Control | MPU_CTRL_ENABLE_Msk;\r
 133 #ifdef SCB_SHCSR_MEMFAULTENA_Msk\r
 134   SCB->SHCSR |= SCB_SHCSR_MEMFAULTENA_Msk;\r
 135 #endif\r
 136   __DSB();\r
 137   __ISB();\r
 138 }\r
 139 \r
 140 /** Disable the MPU.\r
 141 */\r
 142 __STATIC_INLINE void ARM_MPU_Disable(void)\r
 143 {\r
 144   __DMB();\r
 145 #ifdef SCB_SHCSR_MEMFAULTENA_Msk\r
 146   SCB->SHCSR &= ~SCB_SHCSR_MEMFAULTENA_Msk;\r
 147 #endif\r
 148   MPU->CTRL  &= ~MPU_CTRL_ENABLE_Msk;\r
 149 }\r
 150 \r
 151 #ifdef MPU_NS\r
 152 /** Enable the Non-secure MPU.\r
 153 * \param MPU_Control Default access permissions for unconfigured regions.\r
 154 */\r
 155 __STATIC_INLINE void ARM_MPU_Enable_NS(uint32_t MPU_Control)\r
 156 {\r
 157   MPU_NS->CTRL = MPU_Control | MPU_CTRL_ENABLE_Msk;\r
 158 #ifdef SCB_SHCSR_MEMFAULTENA_Msk\r
 159   SCB_NS->SHCSR |= SCB_SHCSR_MEMFAULTENA_Msk;\r
 160 #endif\r
 161   __DSB();\r
 162   __ISB();\r
 163 }\r
 164 \r
 165 /** Disable the Non-secure MPU.\r
 166 */\r
 167 __STATIC_INLINE void ARM_MPU_Disable_NS(void)\r
 168 {\r
 169   __DMB();\r
 170 #ifdef SCB_SHCSR_MEMFAULTENA_Msk\r
 171   SCB_NS->SHCSR &= ~SCB_SHCSR_MEMFAULTENA_Msk;\r
 172 #endif\r
 173   MPU_NS->CTRL  &= ~MPU_CTRL_ENABLE_Msk;\r
 174 }\r
 175 #endif\r
 176 \r
 177 /** Set the memory attribute encoding to the given MPU.\r
 178 * \param mpu Pointer to the MPU to be configured.\r
 179 * \param idx The attribute index to be set [0-7]\r
 180 * \param attr The attribute value to be set.\r
 181 */\r
 182 __STATIC_INLINE void ARM_MPU_SetMemAttrEx(MPU_Type* mpu, uint8_t idx, uint8_t attr)\r
 183 {\r
 184   const uint8_t reg = idx / 4U;\r
 185   const uint32_t pos = ((idx % 4U) * 8U);\r
 186   const uint32_t mask = 0xFFU << pos;\r
 187   \r
 188   if (reg >= (sizeof(mpu->MAIR) / sizeof(mpu->MAIR[0]))) {\r
 189     return; // invalid index\r
 190   }\r
 191   \r
 192   mpu->MAIR[reg] = ((mpu->MAIR[reg] & ~mask) | ((attr << pos) & mask));\r
 193 }\r
 194 \r
 195 /** Set the memory attribute encoding.\r
 196 * \param idx The attribute index to be set [0-7]\r
 197 * \param attr The attribute value to be set.\r
 198 */\r
 199 __STATIC_INLINE void ARM_MPU_SetMemAttr(uint8_t idx, uint8_t attr)\r
 200 {\r
 201   ARM_MPU_SetMemAttrEx(MPU, idx, attr);\r
 202 }\r
 203 \r
 204 #ifdef MPU_NS\r
 205 /** Set the memory attribute encoding to the Non-secure MPU.\r
 206 * \param idx The attribute index to be set [0-7]\r
 207 * \param attr The attribute value to be set.\r
 208 */\r
 209 __STATIC_INLINE void ARM_MPU_SetMemAttr_NS(uint8_t idx, uint8_t attr)\r
 210 {\r
 211   ARM_MPU_SetMemAttrEx(MPU_NS, idx, attr);\r
 212 }\r
 213 #endif\r
 214 \r
 215 /** Clear and disable the given MPU region of the given MPU.\r
 216 * \param mpu Pointer to MPU to be used.\r
 217 * \param rnr Region number to be cleared.\r
 218 */\r
 219 __STATIC_INLINE void ARM_MPU_ClrRegionEx(MPU_Type* mpu, uint32_t rnr)\r
 220 {\r
 221   mpu->RNR = rnr;\r
 222   mpu->RLAR = 0U;\r
 223 }\r
 224 \r
 225 /** Clear and disable the given MPU region.\r
 226 * \param rnr Region number to be cleared.\r
 227 */\r
 228 __STATIC_INLINE void ARM_MPU_ClrRegion(uint32_t rnr)\r
 229 {\r
 230   ARM_MPU_ClrRegionEx(MPU, rnr);\r
 231 }\r
 232 \r
 233 #ifdef MPU_NS\r
 234 /** Clear and disable the given Non-secure MPU region.\r
 235 * \param rnr Region number to be cleared.\r
 236 */\r
 237 __STATIC_INLINE void ARM_MPU_ClrRegion_NS(uint32_t rnr)\r
 238 {  \r
 239   ARM_MPU_ClrRegionEx(MPU_NS, rnr);\r
 240 }\r
 241 #endif\r
 242 \r
 243 /** Configure the given MPU region of the given MPU.\r
 244 * \param mpu Pointer to MPU to be used.\r
 245 * \param rnr Region number to be configured.\r
 246 * \param rbar Value for RBAR register.\r
 247 * \param rlar Value for RLAR register.\r
 248 */   \r
 249 __STATIC_INLINE void ARM_MPU_SetRegionEx(MPU_Type* mpu, uint32_t rnr, uint32_t rbar, uint32_t rlar)\r
 250 {\r
 251   mpu->RNR = rnr;\r
 252   mpu->RBAR = rbar;\r
 253   mpu->RLAR = rlar;\r
 254 }\r
 255 \r
 256 /** Configure the given MPU region.\r
 257 * \param rnr Region number to be configured.\r
 258 * \param rbar Value for RBAR register.\r
 259 * \param rlar Value for RLAR register.\r
 260 */   \r
 261 __STATIC_INLINE void ARM_MPU_SetRegion(uint32_t rnr, uint32_t rbar, uint32_t rlar)\r
 262 {\r
 263   ARM_MPU_SetRegionEx(MPU, rnr, rbar, rlar);\r
 264 }\r
 265 \r
 266 #ifdef MPU_NS\r
 267 /** Configure the given Non-secure MPU region.\r
 268 * \param rnr Region number to be configured.\r
 269 * \param rbar Value for RBAR register.\r
 270 * \param rlar Value for RLAR register.\r
 271 */   \r
 272 __STATIC_INLINE void ARM_MPU_SetRegion_NS(uint32_t rnr, uint32_t rbar, uint32_t rlar)\r
 273 {\r
 274   ARM_MPU_SetRegionEx(MPU_NS, rnr, rbar, rlar);  \r
 275 }\r
 276 #endif\r
 277 \r
 278 /** Memcopy with strictly ordered memory access, e.g. for register targets.\r
 279 * \param dst Destination data is copied to.\r
 280 * \param src Source data is copied from.\r
 281 * \param len Amount of data words to be copied.\r
 282 */\r
 283 __STATIC_INLINE void ARM_MPU_OrderedMemcpy(volatile uint32_t* dst, const uint32_t* __RESTRICT src, uint32_t len)\r
 284 {\r
 285   uint32_t i;\r
 286   for (i = 0U; i < len; ++i) \r
 287   {\r
 288     dst[i] = src[i];\r
 289   }\r
 290 }\r
 291 \r
 292 /** Load the given number of MPU regions from a table to the given MPU.\r
 293 * \param mpu Pointer to the MPU registers to be used.\r
 294 * \param rnr First region number to be configured.\r
 295 * \param table Pointer to the MPU configuration table.\r
 296 * \param cnt Amount of regions to be configured.\r
 297 */\r
 298 __STATIC_INLINE void ARM_MPU_LoadEx(MPU_Type* mpu, uint32_t rnr, ARM_MPU_Region_t const* table, uint32_t cnt) \r
 299 {\r
 300   const uint32_t rowWordSize = sizeof(ARM_MPU_Region_t)/4U;\r
 301   if (cnt == 1U) {\r
 302     mpu->RNR = rnr;\r
 303     ARM_MPU_OrderedMemcpy(&(mpu->RBAR), &(table->RBAR), rowWordSize);\r
 304   } else {\r
 305     uint32_t rnrBase   = rnr & ~(MPU_TYPE_RALIASES-1U);\r
 306     uint32_t rnrOffset = rnr % MPU_TYPE_RALIASES;\r
 307     \r
 308     mpu->RNR = rnrBase;\r
 309     while ((rnrOffset + cnt) > MPU_TYPE_RALIASES) {\r
 310       uint32_t c = MPU_TYPE_RALIASES - rnrOffset;\r
 311       ARM_MPU_OrderedMemcpy(&(mpu->RBAR)+(rnrOffset*2U), &(table->RBAR), c*rowWordSize);\r
 312       table += c;\r
 313       cnt -= c;\r
 314       rnrOffset = 0U;\r
 315       rnrBase += MPU_TYPE_RALIASES;\r
 316       mpu->RNR = rnrBase;\r
 317     }\r
 318     \r
 319     ARM_MPU_OrderedMemcpy(&(mpu->RBAR)+(rnrOffset*2U), &(table->RBAR), cnt*rowWordSize);\r
 320   }\r
 321 }\r
 322 \r
 323 /** Load the given number of MPU regions from a table.\r
 324 * \param rnr First region number to be configured.\r
 325 * \param table Pointer to the MPU configuration table.\r
 326 * \param cnt Amount of regions to be configured.\r
 327 */\r
 328 __STATIC_INLINE void ARM_MPU_Load(uint32_t rnr, ARM_MPU_Region_t const* table, uint32_t cnt) \r
 329 {\r
 330   ARM_MPU_LoadEx(MPU, rnr, table, cnt);\r
 331 }\r
 332 \r
 333 #ifdef MPU_NS\r
 334 /** Load the given number of MPU regions from a table to the Non-secure MPU.\r
 335 * \param rnr First region number to be configured.\r
 336 * \param table Pointer to the MPU configuration table.\r
 337 * \param cnt Amount of regions to be configured.\r
 338 */\r
 339 __STATIC_INLINE void ARM_MPU_Load_NS(uint32_t rnr, ARM_MPU_Region_t const* table, uint32_t cnt) \r
 340 {\r
 341   ARM_MPU_LoadEx(MPU_NS, rnr, table, cnt);\r
 342 }\r
 343 #endif\r
 344 \r
 345 #endif\r
 346 \r