:orphan: .. title:: CONFIG_ARM_MPU .. kconfig:: CONFIG_ARM_MPU CONFIG_ARM_MPU ############## *ARM MPU Support* *ARM MPU Support* Type: ``bool`` Help ==== .. code-block:: none MCU implements Memory Protection Unit. Notes: The ARMv6-M and ARMv7-M MPU architecture requires a power-of-two alignment of MPU region base address and size. The NXP MPU as well as the ARMv8-M MPU do not require MPU regions to have power-of-two alignment for base address and region size. The ARMv8-M MPU requires the active MPU regions be non-overlapping. As a result of this, the ARMv8-M MPU needs to fully partition the memory map when programming dynamic memory regions (e.g. PRIV stack guard, user thread stack, and application memory domains), if the system requires PRIV access policy different from the access policy of the ARMv8-M background memory map. The application developer may enforce full PRIV (kernel) memory partition by enabling the CONFIG_MPU_GAP_FILLING option. By not enforcing full partition, MPU may leave part of kernel SRAM area covered only by the default ARMv8-M memory map. This is fine for User Mode, since the background ARM map does not allow nPRIV access at all. However, since the background map policy allows instruction fetches by privileged code, forcing this Kconfig option off prevents the system from directly triggering MemManage exceptions upon accidental attempts to execute code from SRAM in XIP builds. Since this does not compromise User Mode, we make the skipping of full partitioning the default behavior for the ARMv8-M MPU driver. Help ==== .. code-block:: none MPU implements Memory Protection Unit. Notes: The ARMv8-R MPU architecture requires a power-of-two alignment of MPU region base address and size(64 bytes aligned). The ARMv8-R MPU requires the active MPU regions be non-overlapping. As a result of this, the ARMv8-R MPU needs to fully partition the memory map when programming dynamic memory regions (e.g. PRIV stack guard, user thread stack, and application memory domains), if the system requires PRIV access policy different from the access policy of the ARMv8-R background memory map. The application developer may enforce full PRIV (kernel) memory partition by enabling the CONFIG_MPU_GAP_FILLING option. By not enforcing full partition, MPU may leave part of kernel SRAM area covered only by the default ARMv8-R memory map. This is fine for User Mode, since the background ARM map does not allow nPRIV access at all. However, since the background map policy allows instruction fetches by privileged code, forcing this Kconfig option off prevents the system from directly triggering MemManage exceptions upon accidental attempts to execute code from SRAM in XIP builds. Since this does not compromise User Mode, we make the skipping of full partitioning the default behavior for the ARMv8-R MPU driver. Direct dependencies =================== (\ :kconfig:`CPU_HAS_MPU ` && \ :kconfig:`ARM `) || (\ :kconfig:`CPU_HAS_MPU ` && \ :kconfig:`CPU_AARCH64_CORTEX_R ` && \ :kconfig:`ARM64 `) *(Includes any dependencies from ifs and menus.)* Default ======= - y Symbols selected by this symbol =============================== - \ :kconfig:`MPU ` - \ :kconfig:`SRAM_REGION_PERMISSIONS ` - \ :kconfig:`THREAD_STACK_INFO ` - \ :kconfig:`ARCH_HAS_EXECUTABLE_PAGE_BIT ` - \ :kconfig:`MPU_REQUIRES_POWER_OF_TWO_ALIGNMENT ` if !(\ :kconfig:`CPU_HAS_NXP_MPU ` || \ :kconfig:`ARMV8_M_BASELINE ` || \ :kconfig:`ARMV8_M_MAINLINE `) - \ :kconfig:`MPU_REQUIRES_NON_OVERLAPPING_REGIONS ` if \ :kconfig:`CPU_HAS_ARM_MPU ` && (\ :kconfig:`ARMV8_M_BASELINE ` || \ :kconfig:`ARMV8_M_MAINLINE `) - \ :kconfig:`THREAD_STACK_INFO ` Symbols that select this symbol =============================== - \ :kconfig:`ETH_MCUX ` Kconfig definitions =================== At ``/arm/core/aarch32/mpu/Kconfig:8`` Included via ``Kconfig:8`` → ``Kconfig.zephyr:39`` → ``/Kconfig:12`` → ``/arm/Kconfig:57`` → ``/arm/core/aarch32/Kconfig:297`` Menu path: (Top) → ARM Options .. code-block:: kconfig config ARM_MPU bool "ARM MPU Support" select MPU select SRAM_REGION_PERMISSIONS select THREAD_STACK_INFO select ARCH_HAS_EXECUTABLE_PAGE_BIT select MPU_REQUIRES_POWER_OF_TWO_ALIGNMENT if !(CPU_HAS_NXP_MPU || ARMV8_M_BASELINE || ARMV8_M_MAINLINE) select MPU_REQUIRES_NON_OVERLAPPING_REGIONS if CPU_HAS_ARM_MPU && (ARMV8_M_BASELINE || ARMV8_M_MAINLINE) depends on CPU_HAS_MPU && ARM help MCU implements Memory Protection Unit. Notes: The ARMv6-M and ARMv7-M MPU architecture requires a power-of-two alignment of MPU region base address and size. The NXP MPU as well as the ARMv8-M MPU do not require MPU regions to have power-of-two alignment for base address and region size. The ARMv8-M MPU requires the active MPU regions be non-overlapping. As a result of this, the ARMv8-M MPU needs to fully partition the memory map when programming dynamic memory regions (e.g. PRIV stack guard, user thread stack, and application memory domains), if the system requires PRIV access policy different from the access policy of the ARMv8-M background memory map. The application developer may enforce full PRIV (kernel) memory partition by enabling the CONFIG_MPU_GAP_FILLING option. By not enforcing full partition, MPU may leave part of kernel SRAM area covered only by the default ARMv8-M memory map. This is fine for User Mode, since the background ARM map does not allow nPRIV access at all. However, since the background map policy allows instruction fetches by privileged code, forcing this Kconfig option off prevents the system from directly triggering MemManage exceptions upon accidental attempts to execute code from SRAM in XIP builds. Since this does not compromise User Mode, we make the skipping of full partitioning the default behavior for the ARMv8-M MPU driver. ---- At ``/arm64/core/cortex_r/mpu/Kconfig:10`` Included via ``Kconfig:8`` → ``Kconfig.zephyr:39`` → ``/Kconfig:12`` → ``/arm64/Kconfig:32`` → ``/arm64/core/Kconfig:140`` Menu path: (Top) → ARM64 Options .. code-block:: kconfig config ARM_MPU bool "ARM MPU Support" default y select THREAD_STACK_INFO depends on CPU_HAS_MPU && CPU_AARCH64_CORTEX_R && ARM64 help MPU implements Memory Protection Unit. Notes: The ARMv8-R MPU architecture requires a power-of-two alignment of MPU region base address and size(64 bytes aligned). The ARMv8-R MPU requires the active MPU regions be non-overlapping. As a result of this, the ARMv8-R MPU needs to fully partition the memory map when programming dynamic memory regions (e.g. PRIV stack guard, user thread stack, and application memory domains), if the system requires PRIV access policy different from the access policy of the ARMv8-R background memory map. The application developer may enforce full PRIV (kernel) memory partition by enabling the CONFIG_MPU_GAP_FILLING option. By not enforcing full partition, MPU may leave part of kernel SRAM area covered only by the default ARMv8-R memory map. This is fine for User Mode, since the background ARM map does not allow nPRIV access at all. However, since the background map policy allows instruction fetches by privileged code, forcing this Kconfig option off prevents the system from directly triggering MemManage exceptions upon accidental attempts to execute code from SRAM in XIP builds. Since this does not compromise User Mode, we make the skipping of full partitioning the default behavior for the ARMv8-R MPU driver. *(The 'depends on' condition includes propagated dependencies from ifs and menus.)*