Registered User m (Update name of Resource Manager with an 's' when referring in SW context) Tag: 2017 source edit |
Registered User No edit summary |
||
| (13 intermediate revisions by 3 users not shown) | |||
| Line 1: | Line 1: | ||
{{ApplicableFor | |||
|MPUs list=STM32MP25x | |MPUs list=STM32MP23x, STM32MP25x | ||
|MPUs checklist=STM32MP25x | |MPUs checklist=STM32MP13x, STM32MP15x, STM32MP23x, STM32MP25x | ||
}} | |||
==Article purpose== | ==Article purpose== | ||
This article introduces '''STM32CubeMP2 Package''' (a.k.a., ''''STM32CubeMP2''') architecture based on the Arm<sup>®</sup> Cortex<sup>®</sup>-M33 processor, acting as coprocessor of the Arm<sup>®</sup> Cortex<sup>®</sup>-A35. | This article introduces '''STM32CubeMP2 Package''' (a.k.a., ''''STM32CubeMP2''') architecture based on the Arm<sup>®</sup> Cortex<sup>®</sup>-M33 processor, acting as coprocessor of the Arm<sup>®</sup> Cortex<sup>®</sup>-A35. | ||
| Line 12: | Line 11: | ||
The '''STM32CubeMP2 Package''' gathers together, in a single package, all the generic embedded software components required to develop applications on top of Arm<sup>®</sup> Cortex<sup>®</sup>-M33 microprocessors. | The '''STM32CubeMP2 Package''' gathers together, in a single package, all the generic embedded software components required to develop applications on top of Arm<sup>®</sup> Cortex<sup>®</sup>-M33 microprocessors. | ||
On top of the hardware, the '''STM32CubeMP2 Package''' solution is built around three levels of software components | On top of the hardware, the '''STM32CubeMP2 Package''' solution is built around three levels of software components: | ||
[[File: | * '''Level 0:''' drivers | ||
* '''Level 1:''' middleware | |||
* '''Level 2:''' board demonstrations | |||
These levels interact easily with each other. It also includes two common components, '''CMSIS''' and '''Utilities''', which interact with all three levels. | |||
[[File:STM32CubeMP2 Package Architecture Block Diagram DV6.0.png|850px|link=]] | |||
{{info| '''Notes:''' | {{info| '''Notes:''' | ||
* '''HAL drivers''' deal with the [[STM32MP25 peripherals overview|STM32MP25 internal peripherals]] | * '''HAL drivers''' deal with the [[STM32MP25 peripherals overview|STM32MP25 internal peripherals]] | ||
* '''BSP drivers''' deal with the boards configuration and high-level APIs: they are the equivalent of the Linux DT mechanism ([[Device tree]] or [[STM32 MPU device tree]]) and of the Linux frameworks ([[Linux application frameworks overview]])}} | * '''BSP drivers''' deal with the boards' configuration and high-level APIs: they are the equivalent of the Linux DT mechanism ([[Device tree]] or [[STM32 MPU device tree]]) and of the Linux frameworks ([[Linux application frameworks overview]])}} | ||
==Level 0 (Drivers)== | ==Level 0 (Drivers)== | ||
This level is divided into three software components: | This level is divided into three software components: | ||
* '''Hardware | * '''Hardware abstraction layer''' (HAL) | ||
* '''Low | * '''Low layer''' (LL) | ||
* '''Board | * '''Board support package''' (BSP) | ||
===HAL drivers=== | ===HAL drivers=== | ||
The '''HAL drivers''' provide the low level drivers and the hardware interfacing methods to interact with the upper layers (application, libraries and stacks). They provide generic, multi instance and function-oriented APIs which simplify user application implementation by providing ready-to-use processes. | The '''HAL drivers''' provide the low-level drivers and the hardware interfacing methods to interact with the upper layers (application, libraries, and stacks). They provide generic, multi-instance, and function-oriented APIs, which simplify user application implementation by providing ready-to-use processes. | ||
For example, for the communication peripherals (I2C, UART, etc.), they include APIs allowing the initialization and configuration of the peripheral, management of data transfer based on polling, interrupt, or DMA process, and handling of communication errors that may arise during communication. | |||
{{info| '''Note:''' | {{info| '''Note:''' | ||
| Line 38: | Line 41: | ||
====HAL drivers overview==== | ====HAL drivers overview==== | ||
The HAL APIs layer is composed of native and extended | The '''HAL APIs layer''' is composed of native and extended API sets. It is directly built around a generic architecture and allows the build-upon layers, like the middleware layer, to implement their functions without in-depth knowledge about the used STM32 device. This improves the library code reusability and guarantees easy portability to other devices and STM32 families. | ||
Contrary to the low layer drivers (see Low Layer section), the HAL ones are functionality-oriented and not internal peripheral-oriented. | Contrary to the low-layer drivers (see Low Layer section), the HAL ones are functionality-oriented and not internal peripheral-oriented. For example, for the timer peripheral, the APIs could be split into several categories following the functions offered by the internal peripherals (basic timer, capture, PWM, etc.). | ||
The HAL drivers are a set of common APIs with a high | The HAL drivers are a set of common APIs with a high compliance level with most of the clients available on the market (stacks) called native APIs. They also embed some extended functionalities for special services or a combination of several features offered by the STM32 peripherals. | ||
The HAL drivers APIs are split | The HAL drivers APIs are split into two categories: | ||
* Generic APIs | |||
* Extension APIs | * '''Generic APIs:''' provide common and generic functions to all the STM32 series. | ||
* '''Extension APIs:''' provide specific customized functions for a specific family or a specific part number. | |||
====List of HAL drivers==== | ====List of HAL drivers==== | ||
The list of HAL drivers available for | The list of HAL drivers available for STM32MP2 lines is accessible in [[STM32CubeMP2_Package#HAL_drivers| HAL drivers]]. | ||
===LL drivers=== | ===LL drivers=== | ||
The '''Low Layer (LL) drivers''' offer a fast | The '''Low Layer (LL) drivers''' offer a fast, lightweight, expert-oriented layer that is closer to the hardware than the HAL. The LL APIs are available only for a set of peripherals. | ||
====LL drivers overview==== | ====LL drivers overview==== | ||
The Low Layer (LL) drivers are part of the STM32CubeMPU firmware HAL that provides basic set of optimized and one-shot services. | The '''Low Layer (LL) drivers''' are part of the STM32CubeMPU firmware HAL that provides a basic set of optimized and one-shot services. Unlike the HAL drivers, the LL drivers are not fully portable across the STM32 families; the availability of some functions depends on the physical availability of the relative features on the product. | ||
The Low Layer (LL) drivers are designed to offer the following features: | The Low Layer (LL) drivers are designed to offer the following features: | ||
* | * A new set of inline functions for direct and atomic register access | ||
* One-shot operations that can be used by the HAL drivers or from application level | * One-shot operations that can be used by the HAL drivers or from the application level | ||
* Fully independent from HAL and can be used in standalone usage (without HAL drivers) | * Fully independent from HAL and can be used in standalone usage (without HAL drivers) | ||
* Full feature coverage of all the supported peripherals | * Full feature coverage of all the supported peripherals | ||
====List of LL drivers==== | ====List of LL drivers==== | ||
The list of LL drivers available for | The list of LL drivers available for STM32MP2 lines is accessible in [[STM32CubeMP2_Package#LL_drivers|LL drivers]]. | ||
===BSP drivers=== | ===BSP drivers=== | ||
The '''BSP drivers''' are firmware components based on the HAL drivers and provide a set of APIs | The '''BSP drivers''' are firmware components based on the HAL drivers and provide a set of APIs related to the hardware components in the evaluation boards that come with the '''STM32CubeMPU Package'''. All examples and applications provided with the '''STM32CubeMPU Package''' are based on these BSP drivers. | ||
====BSP drivers overview==== | ====BSP drivers overview==== | ||
| Line 77: | Line 80: | ||
* Portable external resources code (components): the external components could be used by all STM32 families, | * Portable external resources code (components): the external components could be used by all STM32 families, | ||
* Multiple use of hardware resources without duplicated initialization: example: I2C | * Multiple use of hardware resources without duplicated initialization: example: I2C physical layer could be used for several EVAL drivers, | ||
* Intuitive functionalities based on high level use case, | * Intuitive functionalities based on high-level use case, | ||
* Portable BSP drivers for different external devices. | * Portable BSP drivers for different external devices. | ||
====List of BSP drivers==== | ====List of BSP drivers==== | ||
The '''BSP drivers''' offer a set of APIs relative to the hardware components available in the hardware boards (LEDs, | The '''BSP drivers''' offer a set of APIs relative to the hardware components available in the hardware boards (LEDs, buttons, and COM port). | ||
Refer to [[STM32CubeMP2_Package#BSP_drivers | BSP_drivers]] | Refer to [[STM32CubeMP2_Package#BSP_drivers | BSP_drivers]] | ||
==Level 1 ( | ==Level 1 (Middleware)== | ||
Middleware components are a set of libraries providing a set of services. '''STM32CubeMP2 Package''' offers | Middleware components are a set of libraries providing a set of services. '''STM32CubeMP2 Package''' offers three main components: | ||
* OpenAMP | * OpenAMP | ||
* FreeRTOS | * FreeRTOS | ||
* | * USB power delivery | ||
Each middleware component is mainly composed of: | Each middleware component is mainly composed of: | ||
* Library core: this is the core of a component; it manages the main library state machine and the data flow between the several modules | |||
* Interface layer: | * '''Library core:''' this is the core of a component; it manages the main library state machine and the data flow between the several modules. | ||
* '''Interface layer:''' the interface layer is generally used to link the component core with the lower layers, such as the HAL and the BSP drivers. | |||
===OpenAMP=== | ===OpenAMP=== | ||
OpenAMP <ref> [https://www.multicore-association.org/workgroup/oamp.php OpenAMP] </ref> is a library implementing the | OpenAMP <ref> [https://www.multicore-association.org/workgroup/oamp.php OpenAMP] </ref> is a library implementing the remote processor service framework ([[Linux_RPMsg_framework_overview|RPMsg]]) which is a messaging mechanism to communicate with a remote processor. | ||
* Load and control Arm<sup>®</sup> Cortex<sup>®</sup>-M33 firmware | * Load and control Arm<sup>®</sup> Cortex<sup>®</sup>-M33 firmware | ||
* Inter processor communication | * Inter-processor communication | ||
{{info| Note: | {{info| Note: | ||
| Line 105: | Line 109: | ||
===FreeRTOS=== | ===FreeRTOS=== | ||
FreeRTOS <ref> [https://www.freertos.org/ FreeRTOS] </ref> is a | FreeRTOS <ref> [https://www.freertos.org/ FreeRTOS] </ref> is a free real time operating system (RTOS). The '''FreeRTOS''' offers preemptive real-time performance with optimized context switch and interrupt times, enabling fast, highly predictable response times. | ||
It includes the following main features : | It includes the following main features: | ||
* | * Small memory fingerprint | ||
* | * High portability | ||
* | * Multithread management | ||
* | * Preemptive scheduling | ||
* | * Fast interrupt response | ||
* | * Extensive inter-process communication | ||
* | * Synchronization facilities | ||
* | * Tickless operation during low-power mode | ||
* | * Open-source standard | ||
* CMSIS compatibility layer | * CMSIS compatibility layer | ||
==Level 2 (Boards demonstrations)== | ==Level 2 (Boards demonstrations)== | ||
The '''Boards demonstrations''' level is composed of a single layer which provides all ''examples'' and ''applications''. It includes | The '''Boards demonstrations''' level is composed of a single layer, which provides all ''examples'' and ''applications''. It also includes all [[STM32CubeIDE]] '''projects''' for each supported board as well as ''templates'' source files. | ||
There are four kinds of projects demonstrating different usages of software APIs from Level 0 (Drivers) and Level 1 (Middleware): | |||
* '''Examples projects:''' show how to use HAL APIs and Low Layer drivers (if any) with very basic usage of the BSP layer (buttons and LEDs in general). | |||
* '''Examples projects''' | * '''Applications projects:''' show how to use the middleware components (Level 1) and how to integrate them with the hardware and BSP/HAL layers (Level 0). These applications could be hybrid and use several other middleware components. | ||
* '''Applications projects''' | * '''Demonstrations projects:''' show how to integrate and run a maximum number of peripherals and middleware stacks to showcase the product features and performance. | ||
* '''Demonstrations projects''' | * '''Templates projects:''' a very basic user application including STM32CubeIDE project files, which can be used to start a custom project. | ||
* '''Templates projects''' | |||
{{info| '''Notes:''' | {{info| '''Notes:''' | ||
* Refer to [[STM32CubeMP2_Package#STM32CubeMP2_Package_structure| STM32CubeMP2 Package structure]] to get information on locating | * Refer to [[STM32CubeMP2_Package#STM32CubeMP2_Package_structure| STM32CubeMP2 Package structure]] to get information on locating examples, applications, and demonstrations in '''STM32CubeMP2 Package''' | ||
* Refer to [[STM32CubeMP2_Package#Projects|List of projects]] to get information on the list of available | * Refer to [[STM32CubeMP2_Package#Projects|List of projects]] to get information on the list of available examples, applications, and demonstrations in '''STM32CubeMP2 Package'''}} | ||
==Utilities== | ==Utilities== | ||
The '''Utilities''' is a set of common utilities and services offered by '''STM32CubeMP2 Package''' and is composed of different components : | The '''Utilities''' is a set of common utilities and services offered by '''STM32CubeMP2 Package''' and is composed of different components : | ||
└── Utilities | └── Utilities | ||
└── ResourcesManager {{Green|Services for coprocessing in multi-core devices. }} | └── ResourcesManager {{Green|Services for coprocessing in multi-core devices. }} | ||
'''ResourceManager provides 2 APIs:''' | '''ResourceManager provides 2 APIs:''' | ||
| Line 154: | Line 155: | ||
==CMSIS== | ==CMSIS== | ||
The '''Cortex | The '''Cortex microcontroller software interface standard''' (CMSIS) is a vendor-independent hardware abstraction layer for the Arm<sup>®</sup> Cortex<sup>®</sup>-M33 processor series. | ||
* Refer to CMSIS<ref> [https://arm-software.github.io/CMSIS_5/General/html/index.html CMSIS]</ref> to get more information on CMSIS component. | * Refer to CMSIS<ref> [https://arm-software.github.io/CMSIS_5/General/html/index.html CMSIS]</ref> to get more information on CMSIS component. | ||
The CMSIS component also provides specific common resources for device support. It enables consistent and simple software interfaces to the processor and | The CMSIS component also provides specific common resources for device support. It enables consistent and simple software interfaces to the processor and peripherals, simplifying software reuse, reducing the learning curve for microcontroller developers, and reducing the time to market for new devices. | ||
This vendor part is called '''CMSIS Device''' and it provides interrupt list, | This vendor part is called '''CMSIS Device''' and it provides an interrupt list, peripheral registers description, and associated defines for all registers' bitfields.<br> | ||
* '''CMSIS''' structure overview: | * '''CMSIS''' structure overview: | ||
| Line 294: | Line 295: | ||
<noinclude> | <noinclude> | ||
[[Category:STM32CubeMP2 Package|01]] | [[Category:STM32CubeMP2 Package|01]] | ||
{{PublicationRequestId | 32062 | 2024-08-22 |}} | |||
</noinclude> | </noinclude> | ||
Latest revision as of 07:45, 14 November 2024
1. Article purpose[edit | edit source]
This article introduces STM32CubeMP2 Package (a.k.a., 'STM32CubeMP2) architecture based on the Arm® Cortex®-M33 processor, acting as coprocessor of the Arm® Cortex®-A35.
- Refer to STM32CubeMP2 Package - Getting started article to get started.
2. Architecture overview[edit | edit source]
The STM32CubeMP2 Package gathers together, in a single package, all the generic embedded software components required to develop applications on top of Arm® Cortex®-M33 microprocessors.
On top of the hardware, the STM32CubeMP2 Package solution is built around three levels of software components:
- Level 0: drivers
- Level 1: middleware
- Level 2: board demonstrations
These levels interact easily with each other. It also includes two common components, CMSIS and Utilities, which interact with all three levels.
3. Level 0 (Drivers)[edit | edit source]
This level is divided into three software components:
- Hardware abstraction layer (HAL)
- Low layer (LL)
- Board support package (BSP)
3.1. HAL drivers[edit | edit source]
The HAL drivers provide the low-level drivers and the hardware interfacing methods to interact with the upper layers (application, libraries, and stacks). They provide generic, multi-instance, and function-oriented APIs, which simplify user application implementation by providing ready-to-use processes.
For example, for the communication peripherals (I2C, UART, etc.), they include APIs allowing the initialization and configuration of the peripheral, management of data transfer based on polling, interrupt, or DMA process, and handling of communication errors that may arise during communication.
3.1.1. HAL drivers overview[edit | edit source]
The HAL APIs layer is composed of native and extended API sets. It is directly built around a generic architecture and allows the build-upon layers, like the middleware layer, to implement their functions without in-depth knowledge about the used STM32 device. This improves the library code reusability and guarantees easy portability to other devices and STM32 families.
Contrary to the low-layer drivers (see Low Layer section), the HAL ones are functionality-oriented and not internal peripheral-oriented. For example, for the timer peripheral, the APIs could be split into several categories following the functions offered by the internal peripherals (basic timer, capture, PWM, etc.).
The HAL drivers are a set of common APIs with a high compliance level with most of the clients available on the market (stacks) called native APIs. They also embed some extended functionalities for special services or a combination of several features offered by the STM32 peripherals.
The HAL drivers APIs are split into two categories:
- Generic APIs: provide common and generic functions to all the STM32 series.
- Extension APIs: provide specific customized functions for a specific family or a specific part number.
3.1.2. List of HAL drivers[edit | edit source]
The list of HAL drivers available for STM32MP2 lines is accessible in HAL drivers.
3.2. LL drivers[edit | edit source]
The Low Layer (LL) drivers offer a fast, lightweight, expert-oriented layer that is closer to the hardware than the HAL. The LL APIs are available only for a set of peripherals.
3.2.1. LL drivers overview[edit | edit source]
The Low Layer (LL) drivers are part of the STM32CubeMPU firmware HAL that provides a basic set of optimized and one-shot services. Unlike the HAL drivers, the LL drivers are not fully portable across the STM32 families; the availability of some functions depends on the physical availability of the relative features on the product.
The Low Layer (LL) drivers are designed to offer the following features:
- A new set of inline functions for direct and atomic register access
- One-shot operations that can be used by the HAL drivers or from the application level
- Fully independent from HAL and can be used in standalone usage (without HAL drivers)
- Full feature coverage of all the supported peripherals
3.2.2. List of LL drivers[edit | edit source]
The list of LL drivers available for STM32MP2 lines is accessible in LL drivers.
3.3. BSP drivers[edit | edit source]
The BSP drivers are firmware components based on the HAL drivers and provide a set of APIs related to the hardware components in the evaluation boards that come with the STM32CubeMPU Package. All examples and applications provided with the STM32CubeMPU Package are based on these BSP drivers.
3.3.1. BSP drivers overview[edit | edit source]
The BSP architecture proposes a new model that prevents some standard library weaknesses and provides more features:
- Portable external resources code (components): the external components could be used by all STM32 families,
- Multiple use of hardware resources without duplicated initialization: example: I2C physical layer could be used for several EVAL drivers,
- Intuitive functionalities based on high-level use case,
- Portable BSP drivers for different external devices.
3.3.2. List of BSP drivers[edit | edit source]
The BSP drivers offer a set of APIs relative to the hardware components available in the hardware boards (LEDs, buttons, and COM port). Refer to BSP_drivers
4. Level 1 (Middleware)[edit | edit source]
Middleware components are a set of libraries providing a set of services. STM32CubeMP2 Package offers three main components:
- OpenAMP
- FreeRTOS
- USB power delivery
Each middleware component is mainly composed of:
- Library core: this is the core of a component; it manages the main library state machine and the data flow between the several modules.
- Interface layer: the interface layer is generally used to link the component core with the lower layers, such as the HAL and the BSP drivers.
4.1. OpenAMP[edit | edit source]
OpenAMP [1] is a library implementing the remote processor service framework (RPMsg) which is a messaging mechanism to communicate with a remote processor.
- Load and control Arm® Cortex®-M33 firmware
- Inter-processor communication
4.2. FreeRTOS[edit | edit source]
FreeRTOS [2] is a free real time operating system (RTOS). The FreeRTOS offers preemptive real-time performance with optimized context switch and interrupt times, enabling fast, highly predictable response times.
It includes the following main features:
- Small memory fingerprint
- High portability
- Multithread management
- Preemptive scheduling
- Fast interrupt response
- Extensive inter-process communication
- Synchronization facilities
- Tickless operation during low-power mode
- Open-source standard
- CMSIS compatibility layer
5. Level 2 (Boards demonstrations)[edit | edit source]
The Boards demonstrations level is composed of a single layer, which provides all examples and applications. It also includes all STM32CubeIDE projects for each supported board as well as templates source files.
There are four kinds of projects demonstrating different usages of software APIs from Level 0 (Drivers) and Level 1 (Middleware):
- Examples projects: show how to use HAL APIs and Low Layer drivers (if any) with very basic usage of the BSP layer (buttons and LEDs in general).
- Applications projects: show how to use the middleware components (Level 1) and how to integrate them with the hardware and BSP/HAL layers (Level 0). These applications could be hybrid and use several other middleware components.
- Demonstrations projects: show how to integrate and run a maximum number of peripherals and middleware stacks to showcase the product features and performance.
- Templates projects: a very basic user application including STM32CubeIDE project files, which can be used to start a custom project.
6. Utilities[edit | edit source]
The Utilities is a set of common utilities and services offered by STM32CubeMP2 Package and is composed of different components :
└── Utilities └── ResourcesManager Services for coprocessing in multi-core devices.
ResourceManager provides 2 APIs:
ResMgr_Status_t ResMgr_Request(ResMgr_Res_Type_t res_type, uint8_t res_num);
ResMgr_Status_t ResMgr_Release(ResMgr_Res_Type_t res_type, uint8_t res_num);
- The idea of the ResMgr_Request() API is to check and allocate a H/W resource (if available) for use by Cortex-M. This allocation could be shareable or exclusive as defined by the resource isolation framework (RIF) configuration.
- Corresponding ResMgr_Release() API is for releasing the reservation of resource done by the Request API.
7. CMSIS[edit | edit source]
The Cortex microcontroller software interface standard (CMSIS) is a vendor-independent hardware abstraction layer for the Arm® Cortex®-M33 processor series.
- Refer to CMSIS[3] to get more information on CMSIS component.
The CMSIS component also provides specific common resources for device support. It enables consistent and simple software interfaces to the processor and peripherals, simplifying software reuse, reducing the learning curve for microcontroller developers, and reducing the time to market for new devices.
This vendor part is called CMSIS Device and it provides an interrupt list, peripheral registers description, and associated defines for all registers' bitfields.
- CMSIS structure overview:
├── CMSIS │ ├── Core │ │ ├── Include │ │ └── Template │ ├── Core_A │ │ ├── Include │ │ └── Template │ ├── Device CMSIS Device │ │ └── ST │ │ │ └── STM32MP2xx Common resources for STM32MP25x lines │ ├── docs │ │ ├── Core │ │ ├── Core_A │ │ ├── DAP │ │ ├── Driver │ │ ├── DSP │ │ ├── General │ │ ├── index.html │ │ ├── Pack │ │ ├── RTOS │ │ ├── RTOS2 │ │ ├── SVD │ │ └── Zone │ ├── DSP │ │ ├── Examples │ │ ├── Include │ │ └── Source │ ├── Include │ │ ├── cmsis_armcc.h │ │ ├── cmsis_armclang.h │ │ ├── cmsis_compiler.h │ │ ├── cmsis_gcc.h │ │ ├── cmsis_iccarm.h │ │ ├── cmsis_version.h │ │ ├── core_armv8mbl.h │ │ ├── core_armv8mml.h │ │ ├── core_cm0.h │ │ ├── core_cm0plus.h │ │ ├── core_cm23.h │ │ ├── core_cm33.h │ │ ├── core_cm3.h │ │ ├── core_cm4.h │ │ ├── core_cm7.h │ │ ├── core_sc000.h │ │ ├── core_sc300.h │ │ ├── mpu_armv7.h │ │ ├── mpu_armv8.h │ │ └── tz_context.h │ ├── LICENSE.txt │ ├── README.md │ ├── RTOS │ │ └── Template │ └── RTOS2 │ ├── Include │ ├── Source │ └── Template
- CMSIS Device structure :
Device/ └── ST └── STM32MP2xx ├── Include │ ├── RTE_Components.h │ ├── stm32mp251axx_cm33.h │ ├── stm32mp251cxx_cm33.h │ ├── stm32mp251dxx_cm33.h │ ├── stm32mp251fxx_cm33.h │ ├── stm32mp253axx_cm33.h │ ├── stm32mp253cxx_cm33.h │ ├── stm32mp253dxx_cm33.h │ ├── stm32mp253fxx_cm33.h │ ├── stm32mp255axx_cm33.h │ ├── stm32mp255cxx_cm33.h │ ├── stm32mp255dxx_cm33.h │ ├── stm32mp255fxx_cm33.h │ ├── stm32mp257axx_cm0.h │ ├── stm32mp257axx_cm33.h │ ├── stm32mp257cxx_cm33.h │ ├── stm32mp257dxx_cm33.h │ ├── stm32mp257fxx_cm33.h │ ├── stm32mp2xx.h │ ├── system_stm32mp2xx.h │ └── Templates_TZ │ └── partition_stm32mp2xx.h └── Source └── Templates ├── gcc │ ├── linker │ │ ├── stm32mp23xx_DDR_m33_ns.ld │ │ ├── stm32mp23xx_RETRAM_m33_s.ld │ │ └── stm32mp2xx_DDR_m33_ns.ld │ ├── startup_stm32mp251axx_m33.s │ ├── startup_stm32mp251cxx_m33.s │ ├── startup_stm32mp251dxx_m33.s │ ├── startup_stm32mp251fxx_m33.s │ ├── startup_stm32mp253axx_m33.s │ ├── startup_stm32mp253cxx_m33.s │ ├── startup_stm32mp253dxx_m33.s │ ├── startup_stm32mp253fxx_m33.s │ ├── startup_stm32mp255axx_m33.s │ ├── startup_stm32mp255cxx_m33.s │ ├── startup_stm32mp255dxx_m33.s │ ├── startup_stm32mp255fxx_m33.s │ ├── startup_stm32mp257axx_m33.s │ ├── startup_stm32mp257cxx_m33.s │ ├── startup_stm32mp257dxx_m33.s │ ├── startup_stm32mp257fxx_m33.s │ ├── startup_stm32mp257xx_m33.s │ └── startup_stm32mp2xx_m33_ns.S ├── mmu_lpae_stm32mp2xx.c ├── system_stm32mp2xx_m33.c ├── system_stm32mp2xx_m33_ns.c └── system_stm32mp2xx_m33_s.c |
8. References[edit | edit source]
Arm® is a registered trademark of Arm Limited (or its subsidiaries) in the US and/or elsewhere. 