What Is the MPU of Cortex-M Core?

Follow+Star Public Account, don’t miss exciting content

Author | strongerHuang

WeChat Public Account | Embedded Column

Everyone often hears terms like MCU, MPU, MMU, but do you understand MPU?

In the embedded field, MPU usually has two different meanings: 1. Microprocessor Unit; 2.Memory Protection Unit.

In this article, the MPU of the Cortex-M core refers to the Memory Protection Unit.

I wonder if everyone has paid attention to some content about the Cortex-M core, for example, most models of STM32 have MPU.

• Prevent user applications from corrupting data used by the operating system.
• Prevent one task from accessing the data areas of other tasks, thus isolating tasks.
• Critical data areas can be set to read-only, fundamentally eliminating the possibility of corruption.
• Detect unexpected memory access, such as stack overflow and array out-of-bounds.
• In addition, access attributes for memory regions can be set through the MPU, such as whether buffered, whether cacheable, etc.

To review, what is a pointer? A pointer is actually an unsigned integer in memory, but its value is given a special interpretation: it represents the address of a variable or function. That’s why it’s vividly called a “pointer”, as if pointing to someone’s home. Before using a pointer, it must first point to a meaningful entity that is allowed to be used by the program—data and code. A “wild pointer” refers to a pointer variable whose value exceeds the legal range for some reason, causing it to “point randomly”. Program logic errors, array out-of-bounds, stack overflow, uninitialized pointers, improper handling of caches and buffers, chaotic conditions in multitasking environments, and even malicious damage can create wild pointers. If a wild pointer is used to read or modify memory, the location being read or modified is unpredictable. The former leads to returning corrupted data, while the latter can destroy data used for unknown purposes. This often causes the system to behave erratically, and in severe cases, the system may lose control or crash without any signs or reasons.

A wild pointer is like a “thorn in the flesh, maggots in the sauce”: one wild pointer is enough to ruin the entire system, and it is extremely hidden, making it difficult to identify where the wild pointer exists based on symptoms, and it cannot even be determined whether the symptoms were caused by the wild pointer (the program is large, there are many other bugs, and they can also lead to the same symptoms). For ordinary microcontroller systems, there is no way to prevent the damage caused by wild pointers; it completely relies on the quality and self-discipline of the programmer. But even the wisest can make mistakes. Especially when the program scale becomes large, complexity increases exponentially, and it becomes entangled in countless threads; even the cautious Zhuge Liang or the genius Bill Gates cannot guarantee that no mistakes will slip through.

—From the CM3 core translation author

The above only provides a further understanding of the MPU memory protection unit. For friends who want to understand it in depth, more related materials need to be consulted.

To learn MPU programming, it is necessary to master the relevant registers of the MPU. The MPU registers are relatively few; here, the Cortex-M core technical reference manual, as well as the STM32 application note Managing memory protection unit (MPU) in STM32 MCUs and programming manual all describe the knowledge about MPU.

1.STM32 Memory Mapping

2.MPU Register Group

• Privileged program code (such as OS kernel and exception service routines)

• User-level program code

• Privileged program data storage, located in the code area (data_stack)

• User-level program data storage, located in the code area (data_stack)

• General data storage, located in other memory areas (such as SRAM)

• System device area, accessible only to privileged levels, such as the address range of NVIC and MPU registers

• General peripheral area, such as UART, ADC, etc.

3.Cube HAL Configuration MPU Example

void MPU_RegionConfig(void){  MPU_Region_InitTypeDef MPU_InitStruct;  /* Disable MPU */  HAL_MPU_Disable();  /* Configure RAM region as Region N°0, 8kB of size and R/W region */  MPU_InitStruct.Enable = MPU_REGION_ENABLE;  MPU_InitStruct.BaseAddress = 0x20000000;  MPU_InitStruct.Size = MPU_REGION_SIZE_8KB;  MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;  MPU_InitStruct.IsBufferable = MPU_ACCESS_NOT_BUFFERABLE;  MPU_InitStruct.IsCacheable = MPU_ACCESS_CACHEABLE;  MPU_InitStruct.IsShareable = MPU_ACCESS_SHAREABLE;  MPU_InitStruct.Number = MPU_REGION_NUMBER0;  MPU_InitStruct.TypeExtField = MPU_TEX_LEVEL0;  MPU_InitStruct.SubRegionDisable = 0x00;  MPU_InitStruct.DisableExec = MPU_INSTRUCTION_ACCESS_ENABLE;  HAL_MPU_ConfigRegion(&MPU_InitStruct);  /* Configure FLASH region as REGION N°1, 1MB of size and R/W region */  MPU_InitStruct.BaseAddress = 0x08000000;  MPU_InitStruct.Size = MPU_REGION_SIZE_1MB;  MPU_InitStruct.IsShareable = MPU_ACCESS_NOT_SHAREABLE;  MPU_InitStruct.Number = MPU_REGION_NUMBER1;  HAL_MPU_ConfigRegion(&MPU_InitStruct);  /* Configure FMC region as REGION N°2, 0.5GB of size, R/W region */  MPU_InitStruct.BaseAddress = 0x60000000;  MPU_InitStruct.Size = MPU_REGION_SIZE_512MB;  MPU_InitStruct.IsShareable = MPU_ACCESS_SHAREABLE;  MPU_InitStruct.Number = MPU_REGION_NUMBER2;  HAL_MPU_ConfigRegion(&MPU_InitStruct);  /* Enable MPU */  HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);}

———— END ————

Click “Read Original” to see more shares, welcome to share, collect, like, and view.